diff --git a/.editorconfig b/.editorconfig
index e7fcfa6c07e..cafbc72a35a 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -184,6 +184,9 @@ csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimenta
 dotnet_diagnostic.IDE0090.severity = error
 csharp_style_deconstructed_variable_declaration = true:suggestion
 
+# RS0016: Add public types and members to the declared API
+dotnet_diagnostic.RS0016.severity = silent
+
 # Visual Basic files
 
 [*.vb]
diff --git a/.gitignore b/.gitignore
index 610c49c806d..c8a18b3ad19 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,9 @@
 *.userosscache
 *.sln.docstates
 
+#Visual Studio creates .bak files when editing resource files. Ignore these
+*.bak
+
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 
@@ -29,6 +32,9 @@ bld/
 [Oo]bj/
 [Ll]og/
 
+# VSCode directory
+.vscode/
+
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
diff --git a/Build.xml b/Build.xml
new file mode 100644
index 00000000000..74b41ed1b39
--- /dev/null
+++ b/Build.xml
@@ -0,0 +1,17 @@
+<Build xmlns="http://wisetechglobal.com/DevTools/Build.xsd" MSBuild="17">
+	<Solutions>
+		<Solution Filename="Winforms.sln" />
+	</Solutions>
+
+  <PreBuild>
+    <Command cacheable="false">powershell.exe -ExecutionPolicy Bypass .\DeploymentSetup.ps1</Command>
+  </PreBuild>
+
+	<DatSettings BuildDeployerType="CargoWiseCloud.Deployment.DotNetNuGetDeployer, CargoWiseCloud.Deployment" BuildDeployerRuntime="DotNet64">
+		<TestAdapter Type="Dat.Implementation.VSTest.VSTestAdapter, Dat.Implementation.VSTest" />
+		<DeploymentTargets>
+			<DeploymentTarget Type="DeployOnDemand" BuildConfiguration="RELEASE" />
+      <DeploymentTarget Type="DeployOnDemand" BuildConfiguration="RELEASE" DeploymentConfiguration="SAND" IsProduction="false" />
+    </DeploymentTargets>
+	</DatSettings>
+</Build>
\ No newline at end of file
diff --git a/BuildAndPackage.cmd b/BuildAndPackage.cmd
new file mode 100644
index 00000000000..e929307dbaf
--- /dev/null
+++ b/BuildAndPackage.cmd
@@ -0,0 +1,33 @@
+@echo off
+echo Custom NuGet Package Build Script for System.Windows.Forms
+echo =========================================================
+echo.
+
+REM Clean the workspace
+echo Cleaning workspace...
+git clean -dfx
+if errorlevel 1 (
+    echo Error: Failed to clean workspace
+    exit /b 1
+)
+
+REM Build the solution in Release configuration
+echo Building solution in Release configuration...
+dotnet build Winforms.sln -c Release
+if errorlevel 1 (
+    echo Error: Failed to build solution
+    exit /b 1
+)
+
+REM Run the custom packaging script
+echo Running custom packaging...
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0CreateCustomPackageStandalone.ps1"
+if errorlevel 1 (
+    echo Error: Failed to create custom package
+    exit /b 1
+)
+
+echo.
+echo Build and packaging completed successfully!
+echo Check the artifacts\packages\Release\Shipping folder for the System.Windows.Forms.*.nupkg file.
+pause
diff --git a/CreateCustomPackage.ps1 b/CreateCustomPackage.ps1
new file mode 100644
index 00000000000..b2e984b9a95
--- /dev/null
+++ b/CreateCustomPackage.ps1
@@ -0,0 +1,213 @@
+# Custom NuGet Package Creation Script for System.Windows.Forms
+# This script automates the manual process described in the requirements
+
+param(
+    [Parameter(Mandatory = $true)]
+    [string]$OriginalPackagePath,
+    
+    [Parameter(Mandatory = $true)]
+    [string]$CustomPackagePath,
+    
+    [Parameter(Mandatory = $true)]
+    [string]$DesignBinDir,
+    
+    [switch]$WhatIf = $false
+)
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "Starting custom NuGet package creation for System.Windows.Forms..." -ForegroundColor Green
+Write-Host "Original package: $OriginalPackagePath" -ForegroundColor Yellow
+Write-Host "Target package: $CustomPackagePath" -ForegroundColor Yellow
+Write-Host "Design bin directory: $DesignBinDir" -ForegroundColor Yellow
+
+if ($WhatIf) {
+    Write-Host "WhatIf mode: Would process package but not make changes" -ForegroundColor Cyan
+    return
+}
+
+# Validate inputs
+if (-not (Test-Path $OriginalPackagePath)) {
+    Write-Error "Original package not found: $OriginalPackagePath"
+    exit 1
+}
+
+# Ensure the Design bin directory exists
+if (-not (Test-Path $DesignBinDir)) {
+    Write-Error "System.Windows.Forms.Design output directory not found at: $DesignBinDir"
+    exit 1
+}
+
+Write-Host "Source directory: $DesignBinDir" -ForegroundColor Cyan
+
+# Validate that the required files exist in the source directory
+$requiredFiles = @(
+    "System.Windows.Forms.Primitives.dll",
+    "System.Windows.Forms.Primitives.xml", 
+    "System.Windows.Forms.Design.dll",
+    "System.Windows.Forms.Design.xml"
+)
+
+$missingFiles = @()
+foreach ($file in $requiredFiles) {
+    if (-not (Test-Path (Join-Path $DesignBinDir $file))) {
+        $missingFiles += $file
+    }
+}
+
+if ($missingFiles.Count -gt 0) {
+    Write-Warning "Some required files are missing from the source directory:"
+    foreach ($file in $missingFiles) {
+        Write-Warning "  - $file"
+    }
+    Write-Warning "The package will be created but may be incomplete. Ensure System.Windows.Forms.Design project is built correctly."
+}
+
+# Create working directory
+$WorkingDir = Join-Path ([System.IO.Path]::GetDirectoryName($CustomPackagePath)) "temp_package_work"
+$ExtractedPackageDir = Join-Path $WorkingDir "extracted"
+
+if (Test-Path $WorkingDir) {
+    Remove-Item $WorkingDir -Recurse -Force
+}
+New-Item -ItemType Directory -Path $ExtractedPackageDir -Force | Out-Null
+
+try {
+    Write-Host "Extracting original package..." -ForegroundColor Yellow
+    
+    # Extract the nupkg (it's a zip file)
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    [System.IO.Compression.ZipFile]::ExtractToDirectory($OriginalPackagePath, $ExtractedPackageDir)
+    
+    Write-Host "Renaming nuspec file..." -ForegroundColor Yellow
+    
+    # Rename the nuspec file
+    $originalNuspec = Join-Path $ExtractedPackageDir "WTG.System.Windows.Forms.nuspec"
+    $newNuspec = Join-Path $ExtractedPackageDir "System.Windows.Forms.nuspec"
+    
+    if (Test-Path $originalNuspec) {
+        Move-Item $originalNuspec $newNuspec -Force
+    } else {
+        Write-Error "Original nuspec file not found: $originalNuspec"
+        exit 1
+    }
+    
+    Write-Host "Modifying nuspec content..." -ForegroundColor Yellow
+    
+    # Modify the nuspec file content
+    $content = Get-Content $newNuspec -Raw -Encoding UTF8
+    
+    # Replace the package ID
+    $content = $content -replace '<id>WTG\.System\.Windows\.Forms</id>', '<id>System.Windows.Forms</id>'
+    
+    # Remove the System.Windows.Forms.Primitives dependency line
+    $content = $content -replace '\s*<dependency\s+id="System\.Windows\.Forms\.Primitives"[^>]*version="[^"]*"[^/]*/>\s*', ''
+    
+    # Clean up any extra whitespace
+    $content = $content -replace '\r?\n\s*\r?\n', "`r`n"
+    
+    Set-Content $newNuspec -Value $content -Encoding UTF8
+    
+    Write-Host "Copying additional files from System.Windows.Forms.Design..." -ForegroundColor Yellow
+    
+    $libNetDir = Join-Path $ExtractedPackageDir "lib\net8.0"
+    Write-Host "  Target directory: $libNetDir" -ForegroundColor Cyan
+    
+    # Copy the main files (these should replace any existing files)
+    $filesToCopy = @(
+        "System.Windows.Forms.Primitives.dll",
+        "System.Windows.Forms.Primitives.xml", 
+        "System.Windows.Forms.Design.dll",
+        "System.Windows.Forms.Design.xml"
+    )
+    
+    Write-Host "  Copying main files..." -ForegroundColor Cyan
+    foreach ($file in $filesToCopy) {
+        $sourcePath = Join-Path $DesignBinDir $file
+        $destPath = Join-Path $libNetDir $file
+        
+        if (Test-Path $sourcePath) {
+            $existsAlready = Test-Path $destPath
+            Copy-Item $sourcePath $destPath -Force
+            if ($existsAlready) {
+                Write-Host "    Replaced: $file" -ForegroundColor Green
+            } else {
+                Write-Host "    Copied: $file" -ForegroundColor Green
+            }
+        } else {
+            Write-Warning "    File not found: $sourcePath"
+        }
+    }
+    
+    # Copy resource folders (two-character country codes)
+    $resourceFolders = Get-ChildItem $DesignBinDir -Directory
+    
+    if ($resourceFolders.Count -gt 0) {
+        Write-Host "  Found $($resourceFolders.Count) resource folders to copy" -ForegroundColor Cyan
+    }
+    
+    foreach ($folder in $resourceFolders) {
+        $destFolder = Join-Path $libNetDir $folder.Name
+        
+        # Create the destination folder
+        New-Item -ItemType Directory -Path $destFolder -Force | Out-Null
+        
+        # Copy all files from source folder to destination
+        $sourceFiles = Get-ChildItem $folder.FullName -File
+        if ($sourceFiles.Count -gt 0) {
+            Copy-Item $sourceFiles.FullName $destFolder -Force
+            Write-Host "  Copied resource folder: $($folder.Name) ($($sourceFiles.Count) files)" -ForegroundColor Green
+        } else {
+            Write-Host "  Resource folder $($folder.Name) is empty, skipping" -ForegroundColor DarkYellow
+        }
+    }
+    
+    Write-Host "Creating new package..." -ForegroundColor Yellow
+    
+    # Create the new package
+    if (Test-Path $CustomPackagePath) {
+        Remove-Item $CustomPackagePath -Force
+    }
+    
+    [System.IO.Compression.ZipFile]::CreateFromDirectory($ExtractedPackageDir, $CustomPackagePath)
+    
+    Write-Host "Package created successfully: $CustomPackagePath" -ForegroundColor Green
+    
+    # Display package info
+    $packageInfo = Get-ChildItem $CustomPackagePath
+    Write-Host "Package size: $([math]::Round($packageInfo.Length / 1MB, 2)) MB" -ForegroundColor Cyan
+    
+    # Show summary of what was included
+    Write-Host ""
+    Write-Host "Package contents summary:" -ForegroundColor Yellow
+    Write-Host "  - Original System.Windows.Forms files from WTG package" -ForegroundColor White
+    Write-Host "  - Additional files from System.Windows.Forms.Design:" -ForegroundColor White
+    $filesToCopy = @(
+        "System.Windows.Forms.Primitives.dll",
+        "System.Windows.Forms.Primitives.xml", 
+        "System.Windows.Forms.Design.dll",
+        "System.Windows.Forms.Design.xml"
+    )
+    foreach ($file in $filesToCopy) {
+        $sourcePath = Join-Path $DesignBinDir $file
+        if (Test-Path $sourcePath) {
+            Write-Host "    [OK] $file" -ForegroundColor Green
+        } else {
+            Write-Host "    [MISSING] $file (not found)" -ForegroundColor Red
+        }
+    }
+    
+    if ($resourceFolders.Count -gt 0) {
+        Write-Host "  - Resource folders: $($resourceFolders.Name -join ', ')" -ForegroundColor White
+    } else {
+        Write-Host "  - No resource folders found" -ForegroundColor DarkYellow
+    }
+    
+} finally {
+    # Clean up working directory
+    if (Test-Path $WorkingDir) {
+        Remove-Item $WorkingDir -Recurse -Force
+    }
+}
+
+Write-Host "Custom NuGet package creation completed!" -ForegroundColor Green
diff --git a/CreateCustomPackageStandalone.ps1 b/CreateCustomPackageStandalone.ps1
new file mode 100644
index 00000000000..fa2f4562976
--- /dev/null
+++ b/CreateCustomPackageStandalone.ps1
@@ -0,0 +1,57 @@
+# Standalone Custom NuGet Package Creation Script for System.Windows.Forms
+# This script can be used independently for testing or manual package creation
+
+param(
+    [string]$Configuration = "Release",
+    [string]$ArtifactsDir = "$PSScriptRoot\artifacts",
+    [switch]$WhatIf = $false
+)
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "Standalone custom NuGet package creation for System.Windows.Forms..." -ForegroundColor Green
+
+# Define paths
+$PackagesOutputDir = Join-Path $ArtifactsDir "packages\$Configuration\Shipping"
+$DesignBinDir = Join-Path $ArtifactsDir "bin\System.Windows.Forms.Design\$Configuration\net8.0"
+
+# Find the original package
+$OriginalPackages = Get-ChildItem $PackagesOutputDir -Filter "WTG.System.Windows.Forms.*.nupkg" -ErrorAction SilentlyContinue | Sort-Object LastWriteTime -Descending
+if ($OriginalPackages.Count -eq 0) {
+    Write-Error "No WTG.System.Windows.Forms package found in $PackagesOutputDir. Make sure the solution is built in $Configuration configuration."
+    exit 1
+}
+
+$OriginalPackage = $OriginalPackages[0]
+$OriginalPackagePath = $OriginalPackage.FullName
+$PackageVersion = $OriginalPackage.Name -replace "WTG\.System\.Windows\.Forms\.(.*?)\.nupkg", '$1'
+$CustomPackageName = "System.Windows.Forms.$PackageVersion.nupkg"
+$CustomPackagePath = Join-Path $PackagesOutputDir $CustomPackageName
+
+Write-Host "Using the main PowerShell script..." -ForegroundColor Yellow
+
+# Call the main PowerShell script
+$mainScriptPath = Join-Path $PSScriptRoot "CreateCustomPackage.ps1"
+if (-not (Test-Path $mainScriptPath)) {
+    Write-Error "Main PowerShell script not found at: $mainScriptPath"
+    exit 1
+}
+
+$params = @{
+    OriginalPackagePath = $OriginalPackagePath
+    CustomPackagePath = $CustomPackagePath
+    DesignBinDir = $DesignBinDir
+}
+
+if ($WhatIf) {
+    $params.WhatIf = $true
+}
+
+& $mainScriptPath @params
+
+if (-not $WhatIf) {
+    Write-Host ""
+    Write-Host "Next steps:" -ForegroundColor Cyan
+    Write-Host "1. To push to proget: dotnet nuget push `"$CustomPackagePath`" --api-key `"your-api-key`" --source `"https://proget.wtg.zone/nuget/WTG-Internal/v3/index.json`"" -ForegroundColor White
+    Write-Host "2. Verify at: https://proget.wtg.zone/feeds/WTG-Internal/System.Windows.Forms/versions" -ForegroundColor White
+}
diff --git a/CustomPackageCreation.md b/CustomPackageCreation.md
new file mode 100644
index 00000000000..f6314ba8dce
--- /dev/null
+++ b/CustomPackageCreation.md
@@ -0,0 +1,173 @@
+# Automated NuGet Package Creation for System.Windows.Forms
+
+This document describes the automated NuGet package creation process that replaces the manual steps previously required.
+
+## Overview
+
+The automated system creates a custom `System.Windows.Forms` NuGet package from the `WTG.System.Windows.Forms` package built by the standard MSBuild process. The automation includes:
+
+1. Extracting the original `WTG.System.Windows.Forms.*.nupkg` package
+2. Renaming the `.nuspec` file from `WTG.System.Windows.Forms.nuspec` to `System.Windows.Forms.nuspec`
+3. Modifying the package ID in the `.nuspec` file to `System.Windows.Forms`
+4. Removing the `System.Windows.Forms.Primitives` dependency
+5. Copying additional files from `System.Windows.Forms.Design` build output
+6. Copying resource folders (localization files)
+7. Creating the final `System.Windows.Forms.*.nupkg` package
+
+## Automated Methods
+
+### Method 1: MSBuild Integration (Recommended)
+
+The automation is integrated into the MSBuild process via custom targets that call a dedicated PowerShell script.
+
+**Files involved:**
+- `eng/CustomPackaging.targets` - MSBuild targets file (calls PowerShell script)
+- `CreateCustomPackage.ps1` - Core PowerShell script with packaging logic
+- `src/System.Windows.Forms/src/System.Windows.Forms.csproj` - Updated to import the custom targets
+
+**How to use:**
+```bash
+# Build the solution in Release configuration
+dotnet build Winforms.sln -c Release
+
+# The custom package will be automatically created in:
+# artifacts/packages/Release/Shipping/System.Windows.Forms.*.nupkg
+```
+
+**What happens:**
+1. Standard MSBuild packaging creates `WTG.System.Windows.Forms.*.nupkg`
+2. Custom target `CreateCustomNuGetPackage` runs after packaging
+3. MSBuild calls `CreateCustomPackage.ps1` with appropriate parameters
+4. Final `System.Windows.Forms.*.nupkg` is created alongside the original
+
+### Method 2: Standalone PowerShell Script
+
+For more control, debugging, or manual package creation from existing build outputs.
+
+**File:** `CreateCustomPackageStandalone.ps1`
+
+**Usage:**
+```powershell
+# Run with default Release configuration (auto-discovers latest package)
+.\CreateCustomPackageStandalone.ps1
+
+# Run with specific configuration
+.\CreateCustomPackageStandalone.ps1 -Configuration Release
+
+# Preview mode (shows what would be done without making changes)
+.\CreateCustomPackageStandalone.ps1 -WhatIf
+```
+
+This script automatically finds the latest `WTG.System.Windows.Forms.*.nupkg` in the artifacts directory and processes it.
+
+### Method 3: Batch File (Simplest)
+
+For users who prefer a simple click-and-run approach.
+
+**File:** `BuildAndPackage.cmd`
+
+**Usage:**
+1. Double-click the `BuildAndPackage.cmd` file, or
+2. Run from command prompt: `BuildAndPackage.cmd`
+
+This will:
+1. Clean the workspace (`git clean -dfx`)
+2. Build the solution in Release configuration
+3. Run the standalone custom packaging script
+
+## Output
+
+After running any of the methods above, you'll find:
+
+- **Original package:** `artifacts/packages/Release/Shipping/WTG.System.Windows.Forms.*.nupkg`
+- **Custom package:** `artifacts/packages/Release/Shipping/System.Windows.Forms.*.nupkg`
+
+The custom package is the one you should push to ProGet.
+
+## Publishing to ProGet
+
+Once the custom package is created, push it to ProGet:
+
+```bash
+dotnet nuget push "artifacts/packages/Release/Shipping/System.Windows.Forms.*.nupkg" \
+  --api-key "your-api-key" \
+  --source "https://proget.wtg.zone/nuget/WTG-Internal/v3/index.json"
+```
+
+Verify the package at: https://proget.wtg.zone/feeds/WTG-Internal/System.Windows.Forms/versions
+
+## Technical Details
+
+### Files Modified
+
+1. **System.Windows.Forms.csproj**: Added import for `CustomPackaging.targets`
+
+### Files Added
+
+1. **eng/CustomPackaging.targets**: MSBuild targets file that calls the PowerShell script
+2. **CreateCustomPackage.ps1**: Core PowerShell script with all packaging logic  
+3. **CreateCustomPackageStandalone.ps1**: Standalone wrapper script for manual use
+4. **BuildAndPackage.cmd**: Simple batch file wrapper
+5. **CustomPackageCreation.md**: This documentation
+
+### Architecture
+
+The refactored solution uses a clean separation of concerns:
+
+- **MSBuild targets**: Handle integration with the build process and parameter passing
+- **Core PowerShell script**: Contains all the packaging logic (can be called from MSBuild or standalone)
+- **Standalone wrapper**: Provides auto-discovery and convenience for manual testing
+- **Batch wrapper**: Simple entry point for non-technical users
+
+### Custom Target Details
+
+The `CreateCustomNuGetPackage` target:
+- Only runs in Release configuration
+- Only runs for the `System.Windows.Forms` project  
+- Validates that required files exist
+- Calls `CreateCustomPackage.ps1` with the correct parameters
+- Provides detailed logging
+
+### Dependencies
+
+The automation requires:
+- PowerShell (available on Windows by default)
+- .NET SDK (for the build process)
+- Git (for workspace cleaning)
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Package not found**: Ensure the solution builds successfully in Release configuration first
+2. **Design files missing**: Verify that `System.Windows.Forms.Design` project builds correctly
+3. **PowerShell execution policy**: If PowerShell scripts are blocked, run: `Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope CurrentUser`
+
+### Debug Mode
+
+To debug the packaging process:
+1. Use the standalone PowerShell script with `-WhatIf` flag
+2. Check MSBuild output for custom target messages
+3. Look for temporary files in `artifacts/packages/Release/Shipping/temp_package_work` (if cleanup fails)
+
+### Manual Fallback
+
+If automation fails, the original manual process can still be used as documented in the original requirements.
+
+## Maintenance
+
+### Updating Package Dependencies
+
+If the dependencies in the `.nuspec` file need to be updated:
+1. Update the original `WTG.System.Windows.Forms.nuspec` file
+2. Update the PowerShell script in `CustomPackaging.targets` if new dependency removal logic is needed
+
+### Version Updates
+
+The automation automatically uses the version from the built package, so no manual version updates are required.
+
+### Adding New Files
+
+To include additional files in the custom package:
+1. Update the `$filesToCopy` array in the PowerShell script
+2. Ensure the files are available in the `System.Windows.Forms.Design` output directory
diff --git a/Demo/Demo.csproj b/Demo/Demo.csproj
new file mode 100644
index 00000000000..5afe319fe70
--- /dev/null
+++ b/Demo/Demo.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFrameworks>net8.0-windows;net48</TargetFrameworks>
+    <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <NoWarn>SA1400;CS0649</NoWarn>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net48'">
+    <UseWindowsForms>true</UseWindowsForms>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'net8.0-windows'">
+    <UseWindowsForms>false</UseWindowsForms>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0-windows'">
+    <ProjectReference Include="..\src\System.Windows.Forms\src\System.Windows.Forms.csproj" />
+  </ItemGroup>
+
+</Project>
\ No newline at end of file
diff --git a/Demo/Directory.Build.props b/Demo/Directory.Build.props
new file mode 100644
index 00000000000..39c1b301948
--- /dev/null
+++ b/Demo/Directory.Build.props
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+    <!-- Demo project is standalone, don't inherit the defaults. -->
+</Project>
\ No newline at end of file
diff --git a/Demo/Directory.Build.targets b/Demo/Directory.Build.targets
new file mode 100644
index 00000000000..39c1b301948
--- /dev/null
+++ b/Demo/Directory.Build.targets
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+    <!-- Demo project is standalone, don't inherit the defaults. -->
+</Project>
\ No newline at end of file
diff --git a/Demo/Form1.Designer.cs b/Demo/Form1.Designer.cs
new file mode 100644
index 00000000000..e7e66aa1aff
--- /dev/null
+++ b/Demo/Form1.Designer.cs
@@ -0,0 +1,264 @@
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace Demo
+{
+    partial class Form1
+    {
+        /// <summary>
+        ///  Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        ///  Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private void InitializeStatusBar()
+        {
+            StatusBar mainStatusBar = new StatusBar();
+
+            mainStatusBar.Dock = DockStyle.Bottom;
+            mainStatusBar.Height = 70;
+
+            StatusBarPanel statusPanel = new StatusBarPanel();
+            StatusBarPanel datetimePanel = new StatusBarPanel();
+
+            // Set first panel properties and add to StatusBar  
+            statusPanel.BorderStyle = StatusBarPanelBorderStyle.Sunken;
+            statusPanel.Text = "Status Bar Example";
+            statusPanel.AutoSize = StatusBarPanelAutoSize.Spring;
+            mainStatusBar.Panels.Add(statusPanel);
+
+            // Set second panel properties and add to StatusBar  
+            datetimePanel.BorderStyle = StatusBarPanelBorderStyle.Raised;
+
+            datetimePanel.Text = System.DateTime.Today.ToLongDateString();
+            datetimePanel.AutoSize = StatusBarPanelAutoSize.Contents;
+            mainStatusBar.Panels.Add(datetimePanel);
+
+            mainStatusBar.ShowPanels = true;
+
+            Controls.Add(mainStatusBar);
+        }
+
+        private void InitializeDataGrid()
+        {
+            this.button1 = new System.Windows.Forms.Button();
+            this.button2 = new System.Windows.Forms.Button();
+            this.myDataGrid = new DataGrid();
+
+            button1.Location = new Point(24, 60);
+            button1.Size = new Size(200, 30);
+            button1.Text = "Change Appearance";
+            button1.Click += new System.EventHandler(Button1_Click);
+
+            button2.Location = new Point(224, 60);
+            button2.Size = new Size(200, 30);
+            button2.Text = "Get Binding Manager";
+            button2.Click += new System.EventHandler(Button2_Click);
+
+            myDataGrid.Location = new Point(24, 100);
+            myDataGrid.Size = new Size(600, 400);
+            myDataGrid.CaptionText = "Microsoft DataGrid Control";
+            myDataGrid.MouseUp += new MouseEventHandler(Grid_MouseUp);
+
+            this.Controls.Add(button1);
+            this.Controls.Add(button2);
+            this.Controls.Add(myDataGrid);
+        }
+
+        private void InitializeMenu()
+        {
+            // Create the main menu
+            mainMenu = new MainMenu();
+
+            // Create menu items
+            fileMenuItem = new MenuItem("File");
+            newMenuItem = new MenuItem("New");
+            openMenuItem = new MenuItem("Open");
+            saveMenuItem = new MenuItem("Save", SaveMenuItem_Click, Shortcut.CtrlS);
+            exitMenuItem = new MenuItem("Exit");
+            viewMenuItem = new MenuItem("View");
+            toolboxMenuItem = new MenuItem("Toolbox");
+            terminalMenuItem = new MenuItem("Terminal");
+            outputMenuItem = new MenuItem("Output");
+
+            newProjectItem = new MenuItem("Project...");
+            newRepositoryItem = new MenuItem("Repository...");
+            newFileItem = new MenuItem("File...");
+
+            newMenuItem.MenuItems.Add(newProjectItem);
+            newMenuItem.MenuItems.Add(newRepositoryItem);
+            newMenuItem.MenuItems.Add(newFileItem);
+
+            openMenuItem.Shortcut = Shortcut.AltF12;
+            openMenuItem.ShowShortcut = true;
+
+            saveMenuItem.Checked = true;
+            saveMenuItem.RadioCheck = true;
+            //saveMenuItem.Shortcut = Shortcut.CtrlS;
+            //saveMenuItem.ShowShortcut = true;
+
+            // Add sub-menu items to the "File" menu item
+            fileMenuItem.MenuItems.Add(newMenuItem);
+            fileMenuItem.MenuItems.Add(openMenuItem);
+            fileMenuItem.MenuItems.Add(saveMenuItem);
+            fileMenuItem.MenuItems.Add(exitMenuItem);
+
+            viewMenuItem.MenuItems.Add(toolboxMenuItem);
+            viewMenuItem.MenuItems.Add(terminalMenuItem);
+            viewMenuItem.MenuItems.Add(outputMenuItem);
+
+            // Add "File" and "View" menu item to the main menu
+            mainMenu.MenuItems.Add(fileMenuItem);
+            mainMenu.MenuItems.Add(viewMenuItem);
+
+            var dynamicMenuItem = new MenuItem("Dynamic");
+            dynamicMenuItem.MenuItems.Add(new MenuItem("Dynamic code has not run yet"));
+            dynamicMenuItem.Popup += DynamicMenuItem_Popup;
+            mainMenu.MenuItems.Add(dynamicMenuItem);
+
+            // Add Owner Draw Demo menu
+            var ownerDrawDemoMenuItem = new MenuItem("Owner Draw Demo");
+            
+            // Create owner-draw menu items
+            var ownerDrawItem3 = new OwnerDrawMenuItem();
+            ownerDrawItem3.Text = "Custom Draw Item 1";
+            ownerDrawItem3.Click += (s, e) => MessageBox.Show("Custom Owner Draw Item 1 clicked!");
+            
+            // Add submenu items to ownerDrawItem3
+            var subItem1_1 = new OwnerDrawMenuItem();
+            subItem1_1.Text = "Submenu Item 1-1";
+            subItem1_1.Click += (s, e) => MessageBox.Show("Submenu Item 1-1 clicked!");
+            
+            var subItem1_2 = new OwnerDrawMenuItem();
+            subItem1_2.Text = "Submenu Item 1-2";
+            subItem1_2.Click += (s, e) => MessageBox.Show("Submenu Item 1-2 clicked!");
+            
+            ownerDrawItem3.MenuItems.Add(subItem1_1);
+            ownerDrawItem3.MenuItems.Add(subItem1_2);
+            
+            var ownerDrawItem4 = new OwnerDrawMenuItem();
+            ownerDrawItem4.Text = "Custom Draw Item 2"; 
+            ownerDrawItem4.Click += (s, e) => MessageBox.Show("Custom Owner Draw Item 2 clicked!");
+            
+            // Add submenu items to ownerDrawItem4
+            var subItem2_1 = new OwnerDrawMenuItem();
+            subItem2_1.Text = "Nested Custom Item A";
+            subItem2_1.Click += (s, e) => MessageBox.Show("Nested Custom Item A clicked!");
+            
+            var subItem2_2 = new OwnerDrawMenuItem();
+            subItem2_2.Text = "Nested Custom Item B";
+            subItem2_2.Click += (s, e) => MessageBox.Show("Nested Custom Item B clicked!");
+            
+            ownerDrawItem4.MenuItems.Add(subItem2_1);
+            ownerDrawItem4.MenuItems.Add(subItem2_2);
+            
+            // Add a sub-submenu to test deeper nesting
+            var deepSubmenu = new MenuItem("Deep Submenu");
+            var deepSubItem1 = new OwnerDrawMenuItem();
+            deepSubItem1.Text = "Deep Custom Item 1";
+            deepSubItem1.Click += (s, e) => MessageBox.Show("Deep Custom Item 1 clicked!\nThree levels deep with custom drawing!");
+            
+            var deepSubItem2 = new OwnerDrawMenuItem();
+            deepSubItem2.Text = "Deep Custom Item 2";
+            deepSubItem2.Click += (s, e) => MessageBox.Show("Deep Custom Item 2 clicked!\nCustom drawing works at any depth!");
+            
+            deepSubmenu.MenuItems.Add(deepSubItem1);
+            deepSubmenu.MenuItems.Add(deepSubItem2);
+            
+            ownerDrawItem4.MenuItems.Add(subItem2_1);
+            ownerDrawItem4.MenuItems.Add(subItem2_2);
+            ownerDrawItem4.MenuItems.Add(new MenuItem("-")); // Separator
+            ownerDrawItem4.MenuItems.Add(deepSubmenu);
+            
+            ownerDrawDemoMenuItem.MenuItems.Add(new MenuItem("Standard Item"));
+            ownerDrawDemoMenuItem.MenuItems.Add(new MenuItem("-"));
+            ownerDrawDemoMenuItem.MenuItems.Add(ownerDrawItem3);
+            ownerDrawDemoMenuItem.MenuItems.Add(ownerDrawItem4);
+            
+            mainMenu.MenuItems.Add(ownerDrawDemoMenuItem);
+
+            // Set the form's main menu
+            this.Menu = mainMenu;
+
+            newProjectItem.Click += NewProjectItem_Click;
+            newRepositoryItem.Click += NewRepositoryItem_Click;
+            newFileItem.Click += NewFileItem_Click;
+
+            // Add event handlers for menu items
+            //newMenuItem.Click += NewMenuItem_Click;
+            openMenuItem.Click += OpenMenuItem_Click;
+            //saveMenuItem.Click += SaveMenuItem_Click;
+            exitMenuItem.Click += ExitMenuItem_Click;
+
+            toolboxMenuItem.Click += ToolboxMenuItem_Click;
+            terminalMenuItem.Click += TerminalMenuItem_Click;
+            outputMenuItem.Click += OutputMenuItem_Click;
+        }
+
+        private void DynamicMenuItem_Popup(object sender, EventArgs e)
+        {
+            MenuItem dynamicMenuItem = sender as MenuItem;
+            if (dynamicMenuItem != null)
+            {
+                dynamicMenuItem.MenuItems.Clear();
+                for (int i = 1; i <= 5; i++)
+                {
+                    dynamicMenuItem.MenuItems.Add(new MenuItem($"Dynamic Item {i}"));
+                }
+            }
+        }
+
+        private void InitializeMenuStrip()
+        {
+            // Create a MenuStrip
+            MenuStrip menuStrip = new MenuStrip();
+
+            // Create "File" menu item
+            ToolStripMenuItem fileMenuItem = new ToolStripMenuItem("File");
+            fileMenuItem.DropDownItems.Add("New");
+            fileMenuItem.DropDownItems.Add("Open");
+            fileMenuItem.DropDownItems.Add("Save");
+            fileMenuItem.DropDownItems.Add("Exit");
+            menuStrip.Items.Add(fileMenuItem);
+
+            // Create "Edit" menu item
+            ToolStripMenuItem editMenuItem = new ToolStripMenuItem("Edit");
+            editMenuItem.DropDownItems.Add("Cut");
+            editMenuItem.DropDownItems.Add("Copy");
+            editMenuItem.DropDownItems.Add("Paste");
+            menuStrip.Items.Add(editMenuItem);
+
+            // Attach the MenuStrip to the form
+            this.Controls.Add(menuStrip);
+            this.MainMenuStrip = menuStrip;
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        ///  Required method for Designer support - do not modify
+        ///  the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(1024, 768);
+            this.Text = "WTG WinForms Demo";
+        }
+
+        #endregion
+    }
+}
diff --git a/Demo/Form1.cs b/Demo/Form1.cs
new file mode 100644
index 00000000000..a84ad6370f3
--- /dev/null
+++ b/Demo/Form1.cs
@@ -0,0 +1,394 @@
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Windows.Forms;
+
+#nullable disable
+
+namespace Demo
+{
+    /// <summary>
+    /// Summary description for Form1.
+    /// </summary>
+    public partial class Form1 : Form
+    {
+        private DataGrid myDataGrid;
+        private DataSet myDataSet;
+        private bool TablesAlreadyAdded;
+        private Button button1;
+        private Button button2;
+
+        private MainMenu mainMenu;
+        private MenuItem fileMenuItem;
+        private MenuItem newMenuItem;
+        private MenuItem openMenuItem;
+        private MenuItem saveMenuItem;
+        private MenuItem exitMenuItem;
+        private MenuItem newProjectItem;
+        private MenuItem newRepositoryItem;
+        private MenuItem newFileItem;
+        private MenuItem viewMenuItem;
+        private MenuItem toolboxMenuItem;
+        private MenuItem terminalMenuItem;
+        private MenuItem outputMenuItem;
+
+        private ToolBar toolBar;
+        private TreeView treeView;
+
+        /// <summary>
+        /// Summary description for Form1.
+        /// </summary>
+        public Form1()
+        {
+            InitializeComponent();
+
+            Shown += MainForm_Shown;
+        }
+
+        private void MainForm_Shown(object sender, EventArgs e)
+        {
+            InitializeDataGrid();
+            SetUp();
+            InitializeMenu();
+            InitializeStatusBar();
+            //InitializeMenuStrip();
+
+            InitializeToolBar();
+            InitializeTreeView();
+        }
+
+        private void InitializeTreeView()
+        {
+            this.treeView = new TreeView();
+            this.treeView.Location = new Point(650, 100);
+            this.treeView.Size = new Size(200, 200);
+            this.treeView.CheckBoxes = true;
+
+            TreeNode rootNode = new TreeNode("Root Node")
+            {
+                Nodes =
+                {
+                    new TreeNode("Child Node 1")
+                    {
+                        Nodes =
+                        {
+                            new TreeNode("Sub Child Node 1"),
+                            new TreeNode("Sub Child Node 2")
+                        }
+                    },
+                    new TreeNode("Child Node 2")
+                    {
+                        Nodes =
+                        {
+                            new TreeNode("Sub Child Node 3"),
+                            new TreeNode("Sub Child Node 4")
+                        }
+                    },
+                    new TreeNode("Child Node 3")
+                }
+            };
+
+            this.treeView.Nodes.Add(rootNode);
+
+            this.treeView.ContextMenu = new ContextMenu(
+            [
+                new MenuItem("Option 1"),
+                new MenuItem("Option 2")
+            ]);
+
+            AddContextMenuToNodes(treeView.Nodes);
+
+            Controls.Add(this.treeView);
+        }
+
+        private static void AddContextMenuToNodes(TreeNodeCollection nodes)
+        {
+            foreach (TreeNode node in nodes)
+            {
+                node.ContextMenu = new ContextMenu(
+                new MenuItem[]
+                {
+                        new($"Option for {node.Text}"),
+                        new($"Option 2 for {node.Text}")
+                });
+
+                if (node.Nodes.Count > 0)
+                {
+                    AddContextMenuToNodes(node.Nodes);
+                }
+            }
+        }
+
+        private void InitializeToolBar()
+        {
+            toolBar = new ToolBar();
+            toolBar.Buttons.Add("1st button");
+            var btn1 = toolBar.Buttons[0];
+            btn1.ToolTipText = "This is the first button";
+
+            var sep1 = new ToolBarButton("sep1");
+            sep1.Style = ToolBarButtonStyle.Separator;
+            toolBar.Buttons.Add(sep1);
+
+            var btn2 = new ToolBarButton("btn2 toggle");
+            btn2.Style = ToolBarButtonStyle.ToggleButton;
+            btn2.ToolTipText = "This is the second button";
+            toolBar.Buttons.Add(btn2);
+
+            var btn3 = new ToolBarButton("btn3 drop-down");
+            btn3.Style = ToolBarButtonStyle.DropDownButton;
+            btn3.ToolTipText = "This is the third button";
+
+            MenuItem menuItem1 = new MenuItem("Wave");
+            menuItem1.Click += (sender, e) => MessageBox.Show("Wave back");
+            ContextMenu contextMenu1 = new ContextMenu(new MenuItem[] { menuItem1 });
+            btn3.DropDownMenu = contextMenu1;
+            toolBar.Buttons.Add(btn3);
+
+            ToolBarButtonClickEventHandler clickHandler = (object sender, ToolBarButtonClickEventArgs e) =>
+            {
+                MessageBox.Show("Button clicked. text = " + e.Button.Text);
+            };
+
+            toolBar.ButtonClick += clickHandler;
+
+            Controls.Add(toolBar);
+        }
+
+        private void SetUp()
+        {
+            // Create a DataSet with two tables and one relation.
+            MakeDataSet();
+            /* Bind the DataGrid to the DataSet. The dataMember
+            specifies that the Customers table should be displayed.*/
+            myDataGrid.SetDataBinding(myDataSet, "Customers");
+        }
+
+        private void Button1_Click(object sender, System.EventArgs e)
+        {
+            if (TablesAlreadyAdded)
+                return;
+            AddCustomDataTableStyle();
+        }
+
+        private void AddCustomDataTableStyle()
+        {
+            DataGridTableStyle ts1 = new DataGridTableStyle
+            {
+                MappingName = "Customers",
+                // Set other properties.
+                AlternatingBackColor = Color.LightGray
+            };
+
+            /* Add a GridColumnStyle and set its MappingName
+            to the name of a DataColumn in the DataTable.
+            Set the HeaderText and Width properties. */
+
+            DataGridColumnStyle boolCol = new DataGridBoolColumn
+            {
+                MappingName = "Current",
+                HeaderText = "IsCurrent Customer",
+                Width = 150
+            };
+            ts1.GridColumnStyles.Add(boolCol);
+
+            // Add a second column style.
+            DataGridColumnStyle TextCol = new DataGridTextBoxColumn
+            {
+                MappingName = "custName",
+                HeaderText = "Customer Name",
+                Width = 250
+            };
+            ts1.GridColumnStyles.Add(TextCol);
+
+            // Create the second table style with columns.
+            DataGridTableStyle ts2 = new DataGridTableStyle
+            {
+                MappingName = "Orders",
+
+                // Set other properties.
+                AlternatingBackColor = Color.LightBlue
+            };
+
+            // Create new ColumnStyle objects
+            DataGridColumnStyle cOrderDate =
+            new DataGridTextBoxColumn();
+            cOrderDate.MappingName = "OrderDate";
+            cOrderDate.HeaderText = "Order Date";
+            cOrderDate.Width = 100;
+            ts2.GridColumnStyles.Add(cOrderDate);
+
+            /* Use a PropertyDescriptor to create a formatted
+            column. First get the PropertyDescriptorCollection
+            for the data source and data member. */
+            PropertyDescriptorCollection pcol = this.BindingContext[myDataSet, "Customers.custToOrders"].GetItemProperties();
+
+            /* Create a formatted column using a PropertyDescriptor.
+            The formatting character "c" specifies a currency format. */
+            DataGridColumnStyle csOrderAmount =
+            new DataGridTextBoxColumn(pcol["OrderAmount"], "c", true);
+            csOrderAmount.MappingName = "OrderAmount";
+            csOrderAmount.HeaderText = "Total";
+            csOrderAmount.Width = 100;
+            ts2.GridColumnStyles.Add(csOrderAmount);
+
+            /* Add the DataGridTableStyle instances to
+            the GridTableStylesCollection. */
+            myDataGrid.TableStyles.Add(ts1);
+            myDataGrid.TableStyles.Add(ts2);
+
+            // Sets the TablesAlreadyAdded to true so this doesn't happen again.
+            TablesAlreadyAdded = true;
+        }
+
+        private void Button2_Click(object sender, System.EventArgs e)
+        {
+            BindingManagerBase bmGrid;
+            bmGrid = BindingContext[myDataSet, "Customers"];
+            MessageBox.Show("Current BindingManager Position: " + bmGrid.Position);
+        }
+
+        private void Grid_MouseUp(object sender, MouseEventArgs e)
+        {
+            // Create a HitTestInfo object using the HitTest method.
+
+            // Get the DataGrid by casting sender.
+            DataGrid myGrid = (DataGrid)sender;
+            DataGrid.HitTestInfo myHitInfo = myGrid.HitTest(e.X, e.Y);
+            Console.WriteLine(myHitInfo);
+            Console.WriteLine(myHitInfo.Type);
+            Console.WriteLine(myHitInfo.Row);
+            Console.WriteLine(myHitInfo.Column);
+        }
+
+        // Create a DataSet with two tables and populate it.
+        private void MakeDataSet()
+        {
+            // Create a DataSet.
+            myDataSet = new DataSet("myDataSet");
+
+            // Create two DataTables.
+            DataTable tCust = new DataTable("Customers");
+            DataTable tOrders = new DataTable("Orders");
+
+            // Create two columns, and add them to the first table.
+            DataColumn cCustID = new DataColumn("CustID", typeof(int));
+            DataColumn cCustName = new DataColumn("CustName");
+            DataColumn cCurrent = new DataColumn("Current", typeof(bool));
+            tCust.Columns.Add(cCustID);
+            tCust.Columns.Add(cCustName);
+            tCust.Columns.Add(cCurrent);
+
+            // Create three columns, and add them to the second table.
+            DataColumn cID =
+            new DataColumn("CustID", typeof(int));
+            DataColumn cOrderDate =
+            new DataColumn("orderDate", typeof(DateTime));
+            DataColumn cOrderAmount =
+            new DataColumn("OrderAmount", typeof(decimal));
+            tOrders.Columns.Add(cOrderAmount);
+            tOrders.Columns.Add(cID);
+            tOrders.Columns.Add(cOrderDate);
+
+            // Add the tables to the DataSet.
+            myDataSet.Tables.Add(tCust);
+            myDataSet.Tables.Add(tOrders);
+
+            // Create a DataRelation, and add it to the DataSet.
+            DataRelation dr = new DataRelation
+            ("custToOrders", cCustID, cID);
+            myDataSet.Relations.Add(dr);
+
+            /* Populates the tables. For each customer and order,
+            creates two DataRow variables. */
+            DataRow newRow1;
+            DataRow newRow2;
+
+            // Create three customers in the Customers Table.
+            for (int i = 1; i < 4; i++)
+            {
+                newRow1 = tCust.NewRow();
+                newRow1["custID"] = i;
+                // Add the row to the Customers table.
+                tCust.Rows.Add(newRow1);
+            }
+
+            // Give each customer a distinct name.
+            tCust.Rows[0]["custName"] = "Customer1";
+            tCust.Rows[1]["custName"] = "Customer2";
+            tCust.Rows[2]["custName"] = "Customer3";
+
+            // Give the Current column a value.
+            tCust.Rows[0]["Current"] = true;
+            tCust.Rows[1]["Current"] = true;
+            tCust.Rows[2]["Current"] = false;
+
+            // For each customer, create five rows in the Orders table.
+            for (int i = 1; i < 4; i++)
+            {
+                for (int j = 1; j < 6; j++)
+                {
+                    newRow2 = tOrders.NewRow();
+                    newRow2["CustID"] = i;
+                    newRow2["orderDate"] = new DateTime(2001, i, j * 2);
+                    newRow2["OrderAmount"] = i * 10 + j * .1;
+                    // Add the row to the Orders table.
+                    tOrders.Rows.Add(newRow2);
+                }
+            }
+        }
+
+        //private void NewMenuItem_Click(object sender, EventArgs e)
+        //{
+        //    MessageBox.Show("New menu item clicked!");
+        //}
+
+        private void OpenMenuItem_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show("Open menu item clicked!");
+        }
+
+        private void SaveMenuItem_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show("Save menu item clicked!");
+        }
+
+        private void ExitMenuItem_Click(object sender, EventArgs e)
+        {
+            Application.Exit();
+        }
+
+        private void NewProjectItem_Click(object sender, EventArgs e)
+        {
+            newProjectItem.Checked = !newProjectItem.Checked;
+            MessageBox.Show("Project sub-menu item clicked!");
+        }
+
+        private void NewRepositoryItem_Click(object sender, EventArgs e)
+        {
+            newRepositoryItem.Checked = !newRepositoryItem.Checked;
+            MessageBox.Show("Repository sub-menu item clicked!");
+        }
+
+        private void NewFileItem_Click(object sender, EventArgs e)
+        {
+            newFileItem.Checked = !newFileItem.Checked;
+            MessageBox.Show("File sub-menu item clicked!");
+        }
+
+        private void ToolboxMenuItem_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show("Toolbox menu item clicked!");
+        }
+
+        private void TerminalMenuItem_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show("Terminal menu item clicked!");
+        }
+
+        private void OutputMenuItem_Click(object sender, EventArgs e)
+        {
+            MessageBox.Show("Output menu item clicked!");
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.resx b/Demo/Form1.resx
similarity index 100%
rename from src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.resx
rename to Demo/Form1.resx
diff --git a/Demo/OwnerDrawMenuItem.cs b/Demo/OwnerDrawMenuItem.cs
new file mode 100644
index 00000000000..5e0fd7b3b9a
--- /dev/null
+++ b/Demo/OwnerDrawMenuItem.cs
@@ -0,0 +1,109 @@
+#if NET
+using System.Drawing;
+using System.Windows.Forms;
+#endif
+
+namespace Demo
+{
+    class OwnerDrawMenuItem : MenuItem
+    {
+        public OwnerDrawMenuItem() : base()
+        {
+            OwnerDraw = true;
+        }
+
+        protected override void OnDrawItem(DrawItemEventArgs e)
+        {
+            // Get the drawing area
+            Rectangle bounds = e.Bounds;
+            Graphics g = e.Graphics;
+            
+            // Determine colors based on item state
+            Color backColor = e.BackColor;
+            Color textColor = e.ForeColor;
+            
+            // Custom styling for selected/highlighted state
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
+            {
+                backColor = Color.LightBlue;
+                textColor = Color.DarkBlue;
+            }
+            
+            // Draw background
+            using (Brush backBrush = new SolidBrush(backColor))
+            {
+                g.FillRectangle(backBrush, bounds);
+            }
+            
+            // Draw an icon area (simple colored rectangle as demo)
+            Rectangle iconRect = new Rectangle(bounds.X + 4, bounds.Y + 2, 16, 16);
+            using (Brush iconBrush = new SolidBrush(Color.Green))
+            {
+                g.FillRectangle(iconBrush, iconRect);
+            }
+            
+            // Draw a simple "check mark" in the icon area
+            using (Pen checkPen = new Pen(Color.White, 2))
+            {
+                Point[] checkPoints = {
+                    new (iconRect.X + 3, iconRect.Y + 8),
+                    new (iconRect.X + 7, iconRect.Y + 12),
+                    new (iconRect.X + 13, iconRect.Y + 4)
+                };
+                g.DrawLines(checkPen, checkPoints);
+            }
+            
+            // Calculate text area (leaving space for icon and margins)
+            Rectangle textRect = new Rectangle(
+                bounds.X + 24, // Start after icon area (4 + 16 + 4 spacing)
+                bounds.Y + 1,
+                bounds.Width - 28, // Total margin: 4 (left) + 16 (icon) + 4 (spacing) + 4 (right) = 28
+                bounds.Height - 2
+            );
+            
+            // Draw the menu text
+            using (Brush textBrush = new SolidBrush(textColor))
+            {
+                StringFormat format = new StringFormat()
+                {
+                    Alignment = StringAlignment.Near,
+                    LineAlignment = StringAlignment.Center
+                };
+                
+                Font font = e.Font ?? SystemInformation.MenuFont;
+                g.DrawString(Text, font, textBrush, textRect, format);
+            }
+            
+            // Draw focus rectangle if the item has focus
+            if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
+            {
+                e.DrawFocusRectangle();
+            }
+            
+            // Draw a subtle shadow effect at the bottom
+            using (Pen shadowPen = new Pen(Color.FromArgb(50, 0, 0, 0)))
+            {
+                g.DrawLine(shadowPen, bounds.X, bounds.Bottom - 1, bounds.Right, bounds.Bottom - 1);
+            }
+        }
+
+        protected override void OnMeasureItem(MeasureItemEventArgs e)
+        {
+            Font font = SystemInformation.MenuFont;
+            
+            string text = Text ?? string.Empty;
+            if (string.IsNullOrEmpty(text))
+            {
+                text = " ";
+            }
+            
+            var stringSize = e.Graphics.MeasureString(text, font);
+            e.ItemWidth = (int)Math.Ceiling(stringSize.Width) + 28;
+            
+            int minHeightForIcon = 20;
+            int textHeight = (int)Math.Ceiling(stringSize.Height) + 4;
+            
+            e.ItemHeight = Math.Max(minHeightForIcon, textHeight);
+        }
+    }
+}
diff --git a/Demo/Program.cs b/Demo/Program.cs
new file mode 100644
index 00000000000..624a9600932
--- /dev/null
+++ b/Demo/Program.cs
@@ -0,0 +1,38 @@
+#if NET
+using System.Windows.Forms;
+#endif
+
+namespace Demo
+{
+    internal static class Program
+    {
+        /// <summary>
+        ///  The main entry point for the application.
+        /// </summary>
+        [STAThread]
+        static void Main()
+        {
+            // To customize application configuration such as set high DPI settings or default font,
+            // see https://aka.ms/applicationconfiguration.
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            // Set High DPI mode to DpiUnaware, as currently there are some scaling issues when setting to other values
+            // https://github.com/WiseTechGlobal/Modernization.Content/blob/main/Controls/work-items/Difference%20display%20between%20migrated%20forms%20and%20original%20forms.md
+#if NET
+            Application.SetHighDpiMode(HighDpiMode.DpiUnaware);
+#endif
+            //ApplicationConfiguration.Initialize();
+            Application.Run(new Form1());
+        }
+    }
+}
+
+#if NETFRAMEWORK
+namespace System.Runtime.Versioning
+{
+    class SupportedOSPlatformAttribute : Attribute
+    {
+        public SupportedOSPlatformAttribute(string platformName) { }
+    }
+}
+#endif
diff --git a/Demo/xlf/Form1.cs.xlf b/Demo/xlf/Form1.cs.xlf
new file mode 100644
index 00000000000..aa40faef86f
--- /dev/null
+++ b/Demo/xlf/Form1.cs.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="cs" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.de.xlf b/Demo/xlf/Form1.de.xlf
new file mode 100644
index 00000000000..caab0ce76f7
--- /dev/null
+++ b/Demo/xlf/Form1.de.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="de" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.es.xlf b/Demo/xlf/Form1.es.xlf
new file mode 100644
index 00000000000..37761f811ce
--- /dev/null
+++ b/Demo/xlf/Form1.es.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="es" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.fr.xlf b/Demo/xlf/Form1.fr.xlf
new file mode 100644
index 00000000000..366eb9d5436
--- /dev/null
+++ b/Demo/xlf/Form1.fr.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="fr" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.it.xlf b/Demo/xlf/Form1.it.xlf
new file mode 100644
index 00000000000..e68d3fe2676
--- /dev/null
+++ b/Demo/xlf/Form1.it.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="it" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.ja.xlf b/Demo/xlf/Form1.ja.xlf
new file mode 100644
index 00000000000..2943ecce294
--- /dev/null
+++ b/Demo/xlf/Form1.ja.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="ja" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.ko.xlf b/Demo/xlf/Form1.ko.xlf
new file mode 100644
index 00000000000..83cb763b8f6
--- /dev/null
+++ b/Demo/xlf/Form1.ko.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="ko" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.pl.xlf b/Demo/xlf/Form1.pl.xlf
new file mode 100644
index 00000000000..58b6edd6da0
--- /dev/null
+++ b/Demo/xlf/Form1.pl.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="pl" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.pt-BR.xlf b/Demo/xlf/Form1.pt-BR.xlf
new file mode 100644
index 00000000000..073f6c00557
--- /dev/null
+++ b/Demo/xlf/Form1.pt-BR.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="pt-BR" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.ru.xlf b/Demo/xlf/Form1.ru.xlf
new file mode 100644
index 00000000000..5d784e2bc56
--- /dev/null
+++ b/Demo/xlf/Form1.ru.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="ru" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.tr.xlf b/Demo/xlf/Form1.tr.xlf
new file mode 100644
index 00000000000..9ae0ede5336
--- /dev/null
+++ b/Demo/xlf/Form1.tr.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="tr" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.zh-Hans.xlf b/Demo/xlf/Form1.zh-Hans.xlf
new file mode 100644
index 00000000000..2dbdc8d0ce3
--- /dev/null
+++ b/Demo/xlf/Form1.zh-Hans.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/Demo/xlf/Form1.zh-Hant.xlf b/Demo/xlf/Form1.zh-Hant.xlf
new file mode 100644
index 00000000000..8782e525d98
--- /dev/null
+++ b/Demo/xlf/Form1.zh-Hant.xlf
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
+  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../Form1.resx">
+    <body />
+  </file>
+</xliff>
\ No newline at end of file
diff --git a/DeploymentSetup.ps1 b/DeploymentSetup.ps1
new file mode 100644
index 00000000000..be37a841288
--- /dev/null
+++ b/DeploymentSetup.ps1
@@ -0,0 +1,35 @@
+$pkgId = 'CargoWiseCloudDeployment'
+
+# this uses the latest version of the package, as listed at https://proget.wtg.zone/packages?PackageSearch=CargoWiseCloudDeployment
+# if you need a specific version, you can use:
+#$pkgVersion = "1.0.0.70"
+#url = "https://proget.wtg.zone/nuget/WTG-Internal/package/${pkgId}/$pkgVersion"
+
+$Destination = '.\bin'
+
+$pkgVersion = "1.0.0.362" # Set this to $null for most recent package.
+$pkgRoot = Join-Path $Destination ("$pkgId.$pkgVersion")
+$url = "https://proget.wtg.zone/nuget/WTG-Internal/package/${pkgId}/$pkgVersion"
+
+
+try {
+	Invoke-WebRequest -Uri $url -OutFile "$pkgRoot.zip" -ErrorAction Stop
+	Write-Host "download nuget successfully"
+}
+catch {
+	Write-Error "download nuget failed: $($_.Exception.Message)"
+}
+
+try {
+	Expand-Archive -Path "$pkgRoot.zip" -DestinationPath $pkgRoot -Force
+	Write-Host "unzip successfully" -ForegroundColor Green
+}
+catch {
+	Write-Error "unzip failed: $($_.Exception.Message)"
+}
+
+Copy-Item -Path (Join-Path (Join-Path $pkgRoot '\content') '*') -Destination $Destination -Recurse -Force
+Copy-Item -Path (Join-Path (Join-Path $pkgRoot '\lib\net10.0-windows7.0') '*') -Destination $Destination -Recurse -Force
+
+Remove-Item -Path "$pkgRoot.zip" -Force
+Remove-Item -Path $pkgRoot -Recurse -Force
\ No newline at end of file
diff --git a/Directory.Build.props b/Directory.Build.props
index 3191e3fac7f..9c5d942b758 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -17,19 +17,19 @@
     <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
     <LangVersion>preview</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
-    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
-
-    <IsAnalyzerProject>false</IsAnalyzerProject>
-    <IsAnalyzerProject Condition="!$(IsTestProject) and
-                                  ($(MSBuildProjectName.EndsWith('.Analyzers')) or $(MSBuildProjectName.EndsWith('.Analyzers.CSharp')))"
-                                  >true</IsAnalyzerProject>
-
-    <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
-    <EnableTrimAnalyzer Condition="$(IsTestProject) 
-                        or $(IsAnalyzerProject) 
-                        or $(MSBuildProjectDirectory.Contains('\tests\')) 
-                        or $([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'netstandard2.0'))
-                        or $([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net472'))">false</EnableTrimAnalyzer>
+    <!--<EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>-->
+
+    <!-- <IsAnalyzerProject>false</IsAnalyzerProject> -->
+    <!-- <IsAnalyzerProject Condition="!'$(IsTestProject)' == 'true' and -->
+                                  <!-- ($(MSBuildProjectName.EndsWith('.Analyzers')) or $(MSBuildProjectName.EndsWith('.Analyzers.CSharp')))" -->
+                                  <!-- >true</IsAnalyzerProject> -->
+
+    <!-- <EnableTrimAnalyzer>true</EnableTrimAnalyzer> -->
+    <!-- <EnableTrimAnalyzer Condition="'$(IsTestProject)' == 'true'  -->
+                        <!-- or $(IsAnalyzerProject)  -->
+                        <!-- or $(MSBuildProjectDirectory.Contains('\tests\'))  -->
+                        <!-- or $([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'netstandard2.0')) -->
+                        <!-- or $([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net472'))">false</EnableTrimAnalyzer> -->
   </PropertyGroup>
 
   <!-- Making all tests run sequentially until we regroup tests. Tracked under issue https://github.com/dotnet/winforms/issues/8810. -->
@@ -44,16 +44,16 @@
     Note, any components that aren't exposed as references in the targeting pack (like analyzers/generators) those should rev
     so that they can exist SxS, as the compiler relies on different version to change assembly version for caching purposes.
     -->
-  <PropertyGroup Condition="'$(IsAnalyzerProject)' != 'true'">
-    <AssemblyVersion>$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion>
-  </PropertyGroup>
+  <!-- <PropertyGroup Condition="'$(IsAnalyzerProject)' != 'true'"> -->
+    <!-- <AssemblyVersion>$(MajorVersion).$(MinorVersion).0.0</AssemblyVersion> -->
+  <!-- </PropertyGroup> -->
 
-  <PropertyGroup Condition="'$(IsAnalyzerProject)' == 'true'">
-    <IsRoslynComponent>true</IsRoslynComponent>
+  <!-- <PropertyGroup Condition="'$(IsAnalyzerProject)' == 'true'"> -->
+    <!-- <IsRoslynComponent>true</IsRoslynComponent> -->
 
-    <!-- Mark it so eng/packageContent.targets knows how to correctly package it -->
-    <DefineConstants>WINFORMS_ANALYZERS</DefineConstants>
-  </PropertyGroup>
+    <!--  Mark it so eng/packageContent.targets knows how to correctly package it -->
+    <!-- <DefineConstants>WINFORMS_ANALYZERS</DefineConstants> -->
+  <!-- </PropertyGroup> -->
 
   <!-- SDK flipped to 'true' by default https://github.com/dotnet/sdk/pull/12720 -->
   <PropertyGroup>
diff --git a/Directory.Build.targets b/Directory.Build.targets
index cf183e46bd2..5885fe770b6 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -32,12 +32,12 @@
   </PropertyGroup>
 
   <!-- Mark all projects located under **\tests\* folders as non-shipping -->
-  <PropertyGroup>
+  <!--<PropertyGroup>
     <_ProjectDirectoryRelativePath>$([MSBuild]::MakeRelative($(RepoRoot), $(MSBuildProjectDirectory)))</_ProjectDirectoryRelativePath>
     <_IsUnderTestsFolder>$(_ProjectDirectoryRelativePath.Contains("\tests\"))</_IsUnderTestsFolder>
     <IsShipping Condition="$(_IsUnderTestsFolder)">false</IsShipping>
 	<RedistTargetFrameworkName>$(TargetFrameworkName)$(TargetFrameworkMajorVersion).</RedistTargetFrameworkName>
-  </PropertyGroup>
+  </PropertyGroup>-->
 
   <PropertyGroup Condition="'$(IsTestProject)' == 'true' ">
     <TargetArchitecture Condition="'$(TargetArchitecture)' == ''">x64</TargetArchitecture>
diff --git a/NuGet.config b/NuGet.config
index d496e7a4199..ff3297031be 100644
--- a/NuGet.config
+++ b/NuGet.config
@@ -1,29 +1,18 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <packageSources>
     <clear />
     <!--Begin: Package sources managed by Dependency Flow automation. Do not edit the sources below.-->
     <!--  Begin: Package sources from dotnet-runtime -->
-    <add key="darc-int-dotnet-runtime-9f4b1f5" value="https://pkgs.dev.azure.com/dnceng/internal/_packaging/darc-int-dotnet-runtime-9f4b1f5d/nuget/v3/index.json" />
     <!--  End: Package sources from dotnet-runtime -->
     <!--End: Package sources managed by Dependency Flow automation. Do not edit the sources above.-->
-    <add key="dotnet-eng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
-    <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json" />
-    <add key="dotnet7" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7/nuget/v3/index.json" />
-    <add key="dotnet7-transport" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7-transport/nuget/v3/index.json" />
-    <add key="dotnet8" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet8/nuget/v3/index.json" />
-    <add key="dotnet8-transport" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet8-transport/nuget/v3/index.json" />
-    <add key="dotnet-public" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json" />
-    <!-- Used for the Rich Navigation indexing task -->
-    <add key="richnav" value="https://pkgs.dev.azure.com/azure-public/vside/_packaging/vs-buildservices/nuget/v3/index.json" />
-    <!-- CsWin32 dailies -->
-    <add key="winsdk" value="https://pkgs.dev.azure.com/azure-public/winsdk/_packaging/CI/nuget/v3/index.json" />
+    <add key="proget-gallery" value="https://proget.wtg.zone/nuget/Gallery/v3/index.json" />
+    <add key="proget-azure-artifacts" value="https://proget.wtg.zone/nuget/AzureArtifacts/v3/index.json" />
   </packageSources>
   <disabledPackageSources>
     <clear />
     <!--Begin: Package sources managed by Dependency Flow automation. Do not edit the sources below.-->
     <!--  Begin: Package sources from dotnet-runtime -->
-    <add key="darc-int-dotnet-runtime-9f4b1f5" value="true" />
     <!--  End: Package sources from dotnet-runtime -->
     <!--End: Package sources managed by Dependency Flow automation. Do not edit the sources above.-->
   </disabledPackageSources>
diff --git a/README.md b/README.md
index 6f74230874e..3eee7b5285b 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,41 @@
+# WTG Notes
+
+Migrating obsolete winforms controls to compile and run in Net 8 for CW1's ZArchitecture.
+
+# WTG ChangeLog
+
+| Version | What's changed |
+|------------------|-------------|
+| 0.0.6-dev.final | initial version for net7 and net8 |
+| 0.0.7-dev.final | System.Windows.Forms.Design.dll added to package |
+| 0.0.8-dev.final | net8.0: changed version of System.Drawing.Common.dll (v4.0.0.0 -> v8.0.0.0) to fix Dev build |
+| 0.0.9-dev.final | net8.0: changed versions of all libraries in package to v8.0.0.0 |
+| 0.0.10-dev.final | skipped due to error in publishing |
+| 0.0.11-dev.final | net8.0: remove warning WFDEV001 |
+| 0.0.12-dev.final | avoid type issue when instanciated from ZBindingContext (WI00826420) |
+| 0.0.13-dev.final | comment out Debug.Fail in PaintEventArgs (WI00857973) |
+| 0.0.14-dev.final | switched to using Release configuration assemblies instead of Debug, to avoid Microsoft's plentiful Debug.Assert checks (WI00876922) |
+| 0.0.15-dev.final | removed need for forked System.Drawing.Common. We can use the public package listed on nuget.org now. |
+| 0.0.16-dev.final | fixed issue with keyboard shortcuts associated with menus not being captured (WI00895180) |
+| 0.0.17-dev.final | temporarily fixed WebBrowser memory leak (WI00938771) |
+| 0.0.18-dev.final | fixed menu popup events not firing (WI00949199) |
+| 0.0.19-dev.final | fixed menu bar size not taken into account in form sizing (WI00949199) |
+| 0.0.20-dev.final | Menu property change should trigger size update (WI00949199) |
+| 0.0.21-dev.final | fixed ToolBar tooltip moving the position of the toolbar (WI00951596) |
+| 0.0.22-dev.final | fixed control's anchor info (WI00955507) |
+| 0.0.23-dev.final | fixed disappearing Owner Draw MenuItem (WI00948012) |
+| 0.0.24-dev.final | IT  Customs - NET8 NRE on Customs Declaration MISC Tab (WI01005730) |
+
+
+# WTG How to publish new version
+
+* Do changes in code you want to be published
+* Increase version in $(LIB_ROOT)\eng\Versions.props
+* CH0 on DAT
+* Go to DAT deployments for the CH0 build and click deploy
+
+# End of WTG part, Microsoft part below
+
 # Windows Forms
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/dotnet/winforms/blob/main/LICENSE.TXT)
diff --git a/Tests/System.Windows.Forms.Tests/AdjustWindowRectTests.cs b/Tests/System.Windows.Forms.Tests/AdjustWindowRectTests.cs
new file mode 100644
index 00000000000..e5fdfd57ac9
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/AdjustWindowRectTests.cs
@@ -0,0 +1,185 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Drawing;
+
+    [TestFixture]
+    [SingleThreaded]
+    public class AdjustWindowRectTests
+    {
+        [Test]
+        public void Form_WindowRectCalculation_HandlesDpiScaling()
+        {
+            // Test that menu consideration works across different DPI scenarios
+            
+            // Arrange
+            using var form = new Form();
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("Test"));
+            form.Menu = menu;
+            
+            var baseClientSize = new Size(400, 300);
+            
+            // Act
+            form.ClientSize = baseClientSize;
+            var windowSize = form.Size;
+            
+            // Change the client size again to ensure consistency
+            form.ClientSize = new Size(600, 450);
+            var newWindowSize = form.Size;
+            
+            // Assert
+            // The window size should scale proportionally with client size
+            var clientSizeChange = new Size(200, 150); // 600-400, 450-300
+            var windowSizeChange = new Size(newWindowSize.Width - windowSize.Width, newWindowSize.Height - windowSize.Height);
+            
+            Assert.That(windowSizeChange, Is.EqualTo(clientSizeChange),
+                "Window size changes should match client size changes when menu is present");
+        }
+
+        [Test]
+        public void Form_CreateParams_MenuConsideredInWindowRectCalculation()
+        {
+            // Test that CreateParams and window rect calculations are consistent
+            
+            // Arrange
+            using var formWithMenu = new Form();
+            using var formWithoutMenu = new Form();
+            
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            formWithMenu.Menu = menu;
+            
+            // Set same size and create handles to trigger CreateParams usage
+            var testSize = new Size(300, 200);
+            formWithMenu.Size = testSize;
+            formWithoutMenu.Size = testSize;
+            
+            // Force handle creation to trigger CreateParams
+            _ = formWithMenu.Handle;
+            _ = formWithoutMenu.Handle;
+            
+            // Act & Assert
+            // The forms should maintain their size relationships after handle creation
+            // which exercises the CreateParams path
+            formWithMenu.ClientSize = new Size(250, 150);
+            formWithoutMenu.ClientSize = new Size(250, 150);
+            
+            Assert.That(formWithMenu.Size.Height, Is.GreaterThan(formWithoutMenu.Size.Height),
+                "After handle creation, form with menu should still be taller");
+        }
+
+        [Test]
+        public void ToolStripTextBox_InFormWithMenu_IndependentSizing()
+        {
+            // Test that ToolStripTextBox in a form with menu isn't affected by the form's menu
+            
+            // Arrange
+            using var formWithMenu = new Form();
+            using var formWithoutMenu = new Form();
+            
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            formWithMenu.Menu = menu;
+            
+            using var toolStrip1 = new ToolStrip();
+            using var toolStrip2 = new ToolStrip();
+            using var textBox1 = new ToolStripTextBox();
+            using var textBox2 = new ToolStripTextBox();
+            
+            toolStrip1.Items.Add(textBox1);
+            toolStrip2.Items.Add(textBox2);
+            formWithMenu.Controls.Add(toolStrip1);
+            formWithoutMenu.Controls.Add(toolStrip2);
+            
+            // Act
+            textBox1.Size = new Size(120, 22);
+            textBox2.Size = new Size(120, 22);
+            
+            // Assert
+            Assert.That(textBox1.Size, Is.EqualTo(textBox2.Size),
+                "ToolStripTextBox should not be affected by parent form's menu");
+        }
+
+        [Test]
+        public void Control_SizeCalculations_ConsistentForDifferentControlTypes()
+        {
+            // Test various control types to ensure they handle menu considerations correctly
+
+            // Arrange & Act & Assert
+            using var form1 = new Form(); // No menu
+            using var form2 = new Form(); // Menu with items
+
+            var menuWithItems = new MainMenu();
+            menuWithItems.MenuItems.Add(new MenuItem("File"));
+            form2.Menu = menuWithItems;
+
+            var clientSize = new Size(400, 300);
+
+            // Act
+            form1.ClientSize = clientSize;
+            form2.ClientSize = clientSize;
+
+            var controlTypes = new Func<Control>[]
+            {
+                () => new Button(),
+                () => new Label(),
+                () => new TextBox(),
+                () => new Panel(),
+                () => new GroupBox()
+            };
+
+            foreach (var createControl in controlTypes)
+            {
+                using var control1 = createControl();
+                using var control2 = createControl();
+                
+                var testSize = new Size(100, 50);
+                control1.Size = testSize;
+                control2.Size = testSize;
+
+                form1.Controls.Add(control1);
+                form2.Controls.Add(control2);
+
+                Assert.That(control1.Size, Is.EqualTo(control2.Size),
+                    $"{control1.GetType().Name} controls should have consistent sizing behavior");
+            }
+        }
+
+        [Test]
+        public void Form_MenuVisibility_AffectsWindowSizeCalculation()
+        {
+            // Test the specific logic: menu only affects size if it has items
+            
+            // Arrange
+            using var form1 = new Form(); // No menu
+            using var form2 = new Form(); // Empty menu
+            using var form3 = new Form(); // Menu with items
+            
+            var emptyMenu = new MainMenu();
+            form2.Menu = emptyMenu;
+            
+            var menuWithItems = new MainMenu();
+            menuWithItems.MenuItems.Add(new MenuItem("File"));
+            form3.Menu = menuWithItems;
+            
+            var clientSize = new Size(400, 300);
+            
+            // Act
+            form1.ClientSize = clientSize;
+            form2.ClientSize = clientSize;
+            form3.ClientSize = clientSize;
+            
+            // Assert
+            // Forms 1 and 2 should have same height (no menu or empty menu)
+            Assert.That(form1.Size.Height, Is.EqualTo(form2.Size.Height),
+                "Form with no menu and form with empty menu should have same height");
+                
+            // Form 3 should be taller (has menu items)
+            Assert.That(form3.Size.Height, Is.GreaterThan(form1.Size.Height),
+                "Form with menu items should be taller than form without menu");
+                
+            Assert.That(form3.Size.Height, Is.GreaterThan(form2.Size.Height),
+                "Form with menu items should be taller than form with empty menu");
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/MainMenuTests.cs b/Tests/System.Windows.Forms.Tests/MainMenuTests.cs
new file mode 100644
index 00000000000..b184260b9b0
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/MainMenuTests.cs
@@ -0,0 +1,148 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Drawing;
+    using System.Runtime.InteropServices;
+
+    [TestFixture]
+    [SingleThreaded]
+    public class MainMenuTests
+    {
+        [Test]
+        public void MainMenu_SetAndGet_ReturnsCorrectValue()
+        {
+            // Arrange
+            var form = new Form();
+            var mainMenu = new MainMenu();
+
+            // Act
+            form.Menu = mainMenu;
+
+            // Assert
+            Assert.That(form.Menu, Is.EqualTo(mainMenu));
+        }
+
+        [Test]
+        public void MainMenu_AddMenuItem_ReturnsCorrectMenuItem()
+        {
+            // Arrange
+            var mainMenu = new MainMenu();
+            var menuItem = new MenuItem("Test Item");
+
+            // Act
+            mainMenu.MenuItems.Add(menuItem);
+
+            // Assert
+            Assert.That(mainMenu.MenuItems.Count, Is.EqualTo(1));
+            Assert.That(mainMenu.MenuItems[0], Is.EqualTo(menuItem));
+        }
+
+        [Test]
+        public void MainMenu_FileMenuPopup_AddsMenuItemOnPopup()
+        {
+            // Arrange
+            using var form = new Form();
+            var mainMenu = new MainMenu();
+            var fileMenuItem = new MenuItem("File");
+            
+            // Add popup event handler that adds a menu item when fired
+            bool popupEventFired = false;
+            MenuItem? addedMenuItem = null;
+            
+            fileMenuItem.Popup += (sender, e) =>
+            {
+                popupEventFired = true;
+                addedMenuItem = new MenuItem("Dynamic Item");
+                fileMenuItem.MenuItems.Add(addedMenuItem);
+            };
+
+            mainMenu.MenuItems.Add(fileMenuItem);
+            form.Menu = mainMenu;
+            form.Size = new Size(400, 300);
+
+            // Initially, the File menu should have no items
+            Assert.That(fileMenuItem.MenuItems.Count, Is.EqualTo(0));
+
+            // Create the handle so we can send Windows messages
+            var handle = form.Handle; // Forces handle creation
+            
+            // Act - Simulate WM_INITMENUPOPUP message to trigger popup event
+            // This is what Windows sends when a menu is about to be displayed
+            const uint WM_INITMENUPOPUP = 0x0117;
+            
+            // Send the message to trigger the popup event
+            // The wParam contains the handle to the menu, lParam contains position info
+            IntPtr result = SendMessage(handle, WM_INITMENUPOPUP, fileMenuItem.Handle, IntPtr.Zero);
+
+            // Assert
+            Assert.That(popupEventFired, Is.True, "Popup event should have been fired");
+            Assert.That(fileMenuItem.MenuItems.Count, Is.EqualTo(1), "File menu should have one item after popup");
+            
+            if (addedMenuItem is not null)
+            {
+                Assert.That(fileMenuItem.MenuItems[0], Is.EqualTo(addedMenuItem), "The added item should be in the file menu");
+                Assert.That(fileMenuItem.MenuItems[0].Text, Is.EqualTo("Dynamic Item"), "The added item should have the correct text");
+            }
+            
+            // Clean up
+            form.Dispose();
+        }
+
+        [Test]
+        public void MainMenu_FileMenuWithSubmenu_PopupAddsItemToFileMenu()
+        {
+            // Arrange
+            var form = new Form();
+            var mainMenu = new MainMenu();
+            var fileMenuItem = new MenuItem("File");
+            var submenu = new MenuItem("Submenu");
+            
+            // Add the submenu to the File menu first
+            fileMenuItem.MenuItems.Add(submenu);
+            
+            // Add popup event handler to the File menu (not the submenu)
+            bool popupEventFired = false;
+            MenuItem? addedMenuItem = null;
+            
+            fileMenuItem.Popup += (sender, e) =>
+            {
+                popupEventFired = true;
+                addedMenuItem = new MenuItem("Dynamic Item Added to File");
+                fileMenuItem.MenuItems.Add(addedMenuItem);
+            };
+
+            mainMenu.MenuItems.Add(fileMenuItem);
+            form.Menu = mainMenu;
+            form.Size = new Size(400, 300);
+
+            // Initially, the File menu should have 1 item (the submenu)
+            Assert.That(fileMenuItem.MenuItems.Count, Is.EqualTo(1));
+            Assert.That(fileMenuItem.MenuItems[0], Is.EqualTo(submenu));
+
+            // Create the handle so we can send Windows messages
+            var handle = form.Handle; // Forces handle creation
+            
+            // Act - Simulate WM_INITMENUPOPUP message to the File menu
+            const uint WM_INITMENUPOPUP = 0x0117;
+            
+            // Send the message to trigger the popup event on the File menu
+            IntPtr result = SendMessage(handle, WM_INITMENUPOPUP, fileMenuItem.Handle, IntPtr.Zero);
+
+            // Assert
+            Assert.That(popupEventFired, Is.True, "Popup event should have been fired");
+            Assert.That(fileMenuItem.MenuItems.Count, Is.EqualTo(2), "File menu should have two items after popup");
+            Assert.That(fileMenuItem.MenuItems[0], Is.EqualTo(submenu), "The original submenu should still be there");
+            
+            if (addedMenuItem is not null)
+            {
+                Assert.That(fileMenuItem.MenuItems[1], Is.EqualTo(addedMenuItem), "The added item should be in the file menu");
+                Assert.That(fileMenuItem.MenuItems[1].Text, Is.EqualTo("Dynamic Item Added to File"), "The added item should have the correct text");
+            }
+            
+            // Clean up
+            form.Dispose();
+        }
+
+        [DllImport("user32.dll")]
+        private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/MenuItemTests.cs b/Tests/System.Windows.Forms.Tests/MenuItemTests.cs
new file mode 100644
index 00000000000..9c2b36db8b5
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/MenuItemTests.cs
@@ -0,0 +1,139 @@
+namespace System.Windows.Forms.Tests
+{
+    [TestFixture]
+    public class MenuItemTests
+    {
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+        [Test]
+        public void MenuItem_OnDrawItem_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnDrawItem(null);
+
+            // Handler.
+            int callCount = 0;
+            DrawItemEventHandler handler = (sender, e) =>
+            {
+                Assert.That(sender, Is.EqualTo(menuItem));
+                callCount++;
+            };
+
+            menuItem.DrawItem += handler;
+            menuItem.OnDrawItem(null);
+            Assert.That(callCount, Is.EqualTo(1));
+
+            // Should not call if the handler is removed.
+            menuItem.DrawItem -= handler;
+            menuItem.OnDrawItem(null);
+            Assert.That(callCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void MenuItem_OnDrawItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnDrawItem(null));
+        }
+
+        [Test]
+        public void MenuItem_DrawItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            DrawItemEventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DrawItem += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DrawItem -= handler);
+        }
+
+        [Test]
+        public void MenuItem_OnMeasureItem_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnMeasureItem(null);
+
+            // Handler.
+            int callCount = 0;
+            MeasureItemEventHandler handler = (sender, e) =>
+            {
+                Assert.That(sender, Is.EqualTo(menuItem));
+                callCount++;
+            };
+
+            menuItem.MeasureItem += handler;
+            menuItem.OnMeasureItem(null);
+            Assert.That(callCount, Is.EqualTo(1));
+
+            // Should not call if the handler is removed.
+            menuItem.MeasureItem -= handler;
+            menuItem.OnMeasureItem(null);
+            Assert.That(callCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void MenuItem_OnMeasureItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnMeasureItem(null));
+        }
+
+        [Test]
+        public void MenuItem_MeasureItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            MeasureItemEventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MeasureItem += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MeasureItem -= handler);
+        }
+#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
+
+        public class SubMenuItem : MenuItem
+        {
+            public SubMenuItem()
+            {
+            }
+
+            public SubMenuItem(string text) : base(text)
+            {
+            }
+
+            public SubMenuItem(string text, EventHandler onClick) : base(text, onClick)
+            {
+            }
+
+            public SubMenuItem(string text, MenuItem[] items) : base(text, items)
+            {
+            }
+
+            public SubMenuItem(string text, EventHandler onClick, Shortcut shortcut) : base(text, onClick, shortcut)
+            {
+            }
+
+            public SubMenuItem(MenuMerge mergeType, int mergeOrder, Shortcut shortcut, string text, EventHandler onClick, EventHandler onPopup, EventHandler onSelect, MenuItem[] items) : base(mergeType, mergeOrder, shortcut, text, onClick, onPopup, onSelect, items)
+            {
+            }
+
+            public new int MenuID => base.MenuID;
+
+            public new void OnClick(EventArgs e) => base.OnClick(e);
+
+            public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
+
+            public new void OnInitMenuPopup(EventArgs e) => base.OnInitMenuPopup(e);
+
+            public new void OnMeasureItem(MeasureItemEventArgs e) => base.OnMeasureItem(e);
+
+            public new void OnPopup(EventArgs e) => base.OnPopup(e);
+
+            public new void OnSelect(EventArgs e) => base.OnSelect(e);
+
+            public new void CloneMenu(Menu menuSrc) => base.CloneMenu(menuSrc);
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/MenuSizeCalculationTests.cs b/Tests/System.Windows.Forms.Tests/MenuSizeCalculationTests.cs
new file mode 100644
index 00000000000..5fa9ecdc7e3
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/MenuSizeCalculationTests.cs
@@ -0,0 +1,299 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Drawing;
+
+    [TestFixture]
+    [SingleThreaded]
+    public class MenuSizeCalculationTests
+    {
+        [Test]
+        public void Form_WithMenu_HasCorrectWindowSize()
+        {
+            // Arrange
+            using var formWithMenu = new Form();
+            using var formWithoutMenu = new Form();
+            
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            formWithMenu.Menu = menu;
+            
+            var clientSize = new Size(400, 300);
+            
+            // Act
+            formWithMenu.ClientSize = clientSize;
+            formWithoutMenu.ClientSize = clientSize;
+            
+            // Assert
+            Assert.That(formWithMenu.ClientSize, Is.EqualTo(clientSize), "Form with menu should have correct client size");
+            Assert.That(formWithoutMenu.ClientSize, Is.EqualTo(clientSize), "Form without menu should have correct client size");
+            
+            // The key test: form with menu should be taller due to menu bar
+            Assert.That(formWithMenu.Size.Height, Is.GreaterThan(formWithoutMenu.Size.Height), 
+                "Form with menu should be taller than form without menu (accounts for menu bar height)");
+                
+            // Width should be the same (menu doesn't affect width)
+            Assert.That(formWithMenu.Size.Width, Is.EqualTo(formWithoutMenu.Size.Width), 
+                "Form width should not be affected by menu presence");
+        }
+
+        [Test]
+        public void Form_WithEmptyMenu_SameHeightAsFormWithoutMenu()
+        {
+            // Arrange
+            using var formWithEmptyMenu = new Form();
+            using var formWithoutMenu = new Form();
+            
+            var emptyMenu = new MainMenu(); // No menu items
+            formWithEmptyMenu.Menu = emptyMenu;
+            
+            var clientSize = new Size(400, 300);
+            
+            // Act
+            formWithEmptyMenu.ClientSize = clientSize;
+            formWithoutMenu.ClientSize = clientSize;
+            
+            // Assert
+            // According to the implementation, empty menus should not affect window height
+            Assert.That(formWithEmptyMenu.Size.Height, Is.EqualTo(formWithoutMenu.Size.Height), 
+                "Form with empty menu should have same height as form without menu");
+        }
+
+        [Test]
+        public void Form_MenuAddedAfterCreation_AdjustsSize()
+        {
+            // Arrange
+            using var form = new Form();
+            var clientSize = new Size(400, 300);
+            form.ClientSize = clientSize;
+            
+            var initialHeight = form.Size.Height;
+            
+            // Act - Add menu with items
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            form.Menu = menu;
+            form.ClientSize = clientSize; // Trigger recalculation
+            
+            // Assert
+            Assert.That(form.Size.Height, Is.GreaterThan(initialHeight), 
+                "Form height should increase when menu with items is added");
+            Assert.That(form.ClientSize, Is.EqualTo(clientSize), 
+                "Client size should remain consistent after menu addition");
+        }
+
+        [Test]
+        public void Form_MenuRemovedAfterCreation_AdjustsSize()
+        {
+            // Arrange
+            using var form = new Form();
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            form.Menu = menu;
+            
+            var clientSize = new Size(400, 300);
+            form.ClientSize = clientSize;
+            var heightWithMenu = form.Size.Height;
+            
+            // Act - Remove menu
+            form.Menu = null;
+            form.ClientSize = clientSize; // Trigger recalculation
+            
+            // Assert
+            Assert.That(form.Size.Height, Is.LessThan(heightWithMenu), 
+                "Form height should decrease when menu is removed");
+            Assert.That(form.ClientSize, Is.EqualTo(clientSize), 
+                "Client size should remain consistent after menu removal");
+        }
+
+        [Test]
+        public void Form_NonTopLevel_MenuDoesNotAffectSize()
+        {
+            // Arrange
+            using var parentForm = new Form();
+            using var childForm = new Form();
+            
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            childForm.Menu = menu;
+            childForm.TopLevel = false;
+            childForm.Parent = parentForm;
+            
+            var clientSize = new Size(200, 150);
+            
+            // Create a comparable form without menu but also non-toplevel
+            using var childFormNoMenu = new Form();
+            childFormNoMenu.TopLevel = false;
+            childFormNoMenu.Parent = parentForm;
+            
+            // Act
+            childForm.ClientSize = clientSize;
+            childFormNoMenu.ClientSize = clientSize;
+            
+            // Assert
+            // Non-top-level forms should not account for menus in sizing
+            Assert.That(childForm.Size.Height, Is.EqualTo(childFormNoMenu.Size.Height), 
+                "Non-top-level forms should not be affected by menu presence");
+        }
+
+        [Test]
+        public void MDIChild_MenuDoesNotAffectSize()
+        {
+            // Arrange
+            using var parentForm = new Form();
+            parentForm.IsMdiContainer = true;
+            
+            using var mdiChild1 = new Form();
+            using var mdiChild2 = new Form();
+            
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            mdiChild1.Menu = menu;
+            
+            mdiChild1.MdiParent = parentForm;
+            mdiChild2.MdiParent = parentForm;
+            
+            var clientSize = new Size(200, 150);
+            
+            // Act
+            mdiChild1.ClientSize = clientSize;
+            mdiChild2.ClientSize = clientSize;
+            
+            // Assert
+            // MDI children should not account for menus in sizing
+            Assert.That(mdiChild1.Size.Height, Is.EqualTo(mdiChild2.Size.Height), 
+                "MDI child forms should not be affected by menu presence");
+        }
+
+        [Test]
+        public void Form_MenuWithMultipleItems_SameHeightAsMenuWithOneItem()
+        {
+            // Arrange
+            using var formWithOneMenuItem = new Form();
+            using var formWithMultipleMenuItems = new Form();
+            
+            var menuOne = new MainMenu();
+            menuOne.MenuItems.Add(new MenuItem("File"));
+            formWithOneMenuItem.Menu = menuOne;
+            
+            var menuMultiple = new MainMenu();
+            menuMultiple.MenuItems.Add(new MenuItem("File"));
+            menuMultiple.MenuItems.Add(new MenuItem("Edit"));
+            menuMultiple.MenuItems.Add(new MenuItem("View"));
+            formWithMultipleMenuItems.Menu = menuMultiple;
+            
+            var clientSize = new Size(400, 300);
+            
+            // Act
+            formWithOneMenuItem.ClientSize = clientSize;
+            formWithMultipleMenuItems.ClientSize = clientSize;
+            
+            // Assert
+            // Number of menu items shouldn't affect form height (all in same menu bar)
+            Assert.That(formWithMultipleMenuItems.Size.Height, Is.EqualTo(formWithOneMenuItem.Size.Height), 
+                "Forms should have same height regardless of number of menu items");
+        }
+
+        [Test]
+        public void Form_MenuWithSubmenus_SameHeightAsMenuWithoutSubmenus()
+        {
+            // Arrange
+            using var formWithSubmenu = new Form();
+            using var formWithoutSubmenu = new Form();
+            
+            var menuWithSubmenu = new MainMenu();
+            var fileMenu = new MenuItem("File");
+            fileMenu.MenuItems.Add(new MenuItem("New"));
+            fileMenu.MenuItems.Add(new MenuItem("Open"));
+            menuWithSubmenu.MenuItems.Add(fileMenu);
+            formWithSubmenu.Menu = menuWithSubmenu;
+            
+            var menuWithoutSubmenu = new MainMenu();
+            menuWithoutSubmenu.MenuItems.Add(new MenuItem("File"));
+            formWithoutSubmenu.Menu = menuWithoutSubmenu;
+            
+            var clientSize = new Size(400, 300);
+            
+            // Act
+            formWithSubmenu.ClientSize = clientSize;
+            formWithoutSubmenu.ClientSize = clientSize;
+            
+            // Assert
+            // Submenus shouldn't affect form height (they're dropdowns)
+            Assert.That(formWithSubmenu.Size.Height, Is.EqualTo(formWithoutSubmenu.Size.Height), 
+                "Forms should have same height regardless of submenu complexity");
+        }
+
+        [Test]
+        public void Form_SetClientSizeMultipleTimes_ConsistentBehavior()
+        {
+            // Test that the HasMenu logic is consistently applied
+            
+            // Arrange
+            using var form = new Form();
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            form.Menu = menu;
+            
+            var clientSize1 = new Size(300, 200);
+            var clientSize2 = new Size(500, 400);
+            
+            // Act & Assert
+            form.ClientSize = clientSize1;
+            Assert.That(form.ClientSize, Is.EqualTo(clientSize1), "First client size setting should work correctly");
+            var height1 = form.Size.Height;
+            
+            form.ClientSize = clientSize2;
+            Assert.That(form.ClientSize, Is.EqualTo(clientSize2), "Second client size setting should work correctly");
+            var height2 = form.Size.Height;
+            
+            // The height difference should be proportional to client size difference
+            var clientHeightDiff = clientSize2.Height - clientSize1.Height;
+            var windowHeightDiff = height2 - height1;
+            Assert.That(windowHeightDiff, Is.EqualTo(clientHeightDiff), 
+                "Window height difference should equal client height difference (menu bar height is constant)");
+        }
+
+        [Test]
+        public void Form_MenuRemovedBeforeHandleCreated_SizeUpdatesImmediately()
+        {
+            // This test verifies the fix for the issue where setting Menu to null 
+            // before handle creation didn't update the form size immediately
+            
+            // Arrange
+            using var form = new Form();
+            
+            // Create menu with items
+            var menu = new MainMenu();
+            menu.MenuItems.Add(new MenuItem("File"));
+            menu.MenuItems.Add(new MenuItem("Edit"));
+            
+            // Set menu first
+            form.Menu = menu;
+            
+            // Set client size - this should trigger FormStateSetClientSize
+            var targetClientSize = new Size(400, 300);
+            form.ClientSize = targetClientSize;
+            
+            // Capture size with menu (before handle is created)
+            var sizeWithMenu = form.Size;
+            
+            // Act - Remove menu before handle is created
+            // This should trigger the fix in line 760: if FormStateSetClientSize == 1 && !IsHandleCreated
+            form.Menu = null;
+            
+            // Assert
+            var sizeWithoutMenu = form.Size;
+            
+            // The form size should be updated immediately when menu is removed
+            Assert.That(sizeWithoutMenu.Height, Is.LessThan(sizeWithMenu.Height), 
+                "Form height should decrease immediately when menu is removed before handle creation");
+            
+            Assert.That(form.ClientSize, Is.EqualTo(targetClientSize), 
+                "Client size should remain the target size after menu removal");
+            
+            // Width should remain the same
+            Assert.That(sizeWithoutMenu.Width, Is.EqualTo(sizeWithMenu.Width), 
+                "Form width should not change when menu is removed");
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/MouseOperations.cs b/Tests/System.Windows.Forms.Tests/MouseOperations.cs
new file mode 100644
index 00000000000..cfb7c1dac39
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/MouseOperations.cs
@@ -0,0 +1,24 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Runtime.InteropServices;
+
+    public static class MouseOperations
+    {
+        [Flags]
+        public enum MouseEventFlags
+        {
+            LeftDown = 0x00000002,
+            LeftUp = 0x00000004,
+            RightDown = 0x00000008,
+            RightUp = 0x00000010,
+        }
+
+        [DllImport("user32.dll")]
+        private static extern void mouse_event(int dwFlags, uint dx, uint dy, int dwData, int dwExtraInfo);
+
+        public static void MouseEvent(MouseEventFlags value, uint dx, uint dy)
+        {
+            mouse_event((int)value, dx, dy, 0, 0);
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/System.Windows.Forms.Tests.csproj b/Tests/System.Windows.Forms.Tests/System.Windows.Forms.Tests.csproj
new file mode 100644
index 00000000000..e46948ac6e1
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/System.Windows.Forms.Tests.csproj
@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <OutputPath>$([System.IO.Path]::GetFullPath('$(RepoRoot)Bin\$(OutDirName)\'))</OutputPath>
+    <!-- Sign test assembly with the ECMA key to align with existing InternalsVisibleTo entries -->
+    <StrongNameKeyId>ECMA</StrongNameKeyId>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
+    <ProjectReference Include="..\..\src\System.Windows.Forms\src\System.Windows.Forms.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>
diff --git a/Tests/System.Windows.Forms.Tests/TabControlTests.cs b/Tests/System.Windows.Forms.Tests/TabControlTests.cs
new file mode 100644
index 00000000000..77b91517390
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/TabControlTests.cs
@@ -0,0 +1,48 @@
+namespace System.Windows.Forms.Tests
+{
+    [TestFixture]
+    [SingleThreaded]
+    public class TabControlTests
+    {
+        [Test]
+        public void TabControl_ClearTabsWhileSelected_DoesNotThrowNullReferenceException()
+        {
+            Exception? capturedException = null;
+            ThreadExceptionEventHandler handler = (_, e) => capturedException = e.Exception;
+
+            Application.ThreadException += handler;
+            try
+            {
+                using Form form = new();
+                using TabControl control = new();
+
+                control.TabPages.Add(new TabPage("Tab 1"));
+                control.TabPages.Add(new TabPage("Tab 2"));
+                control.TabPages.Add(new TabPage("Tab 3"));
+
+                form.Controls.Add(control);
+                form.Show();
+                _ = control.AccessibilityObject;
+
+                control.SelectedIndex = 1;
+                Application.DoEvents();
+
+                control.TabPages.Clear();
+
+                Application.DoEvents();
+                System.Threading.Thread.Sleep(10);
+
+                Assert.That(control.TabPages.Count, Is.EqualTo(0));
+                Assert.That(control.SelectedTab, Is.Null);
+            }
+            finally
+            {
+                Application.ThreadException -= handler;
+                if (capturedException is not null)
+                {
+                    Assert.Fail($"Unhandled exception: {capturedException.GetType().Name}\n{capturedException.Message}\n{capturedException.StackTrace}");
+                }
+            }
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/ToolBarToolTipTests.cs b/Tests/System.Windows.Forms.Tests/ToolBarToolTipTests.cs
new file mode 100644
index 00000000000..f834c08f47a
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/ToolBarToolTipTests.cs
@@ -0,0 +1,260 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.WindowsAndMessaging;
+
+namespace System.Windows.Forms.Tests
+{
+    [TestFixture]
+    [SingleThreaded]
+    [Apartment(System.Threading.ApartmentState.STA)]
+    public class ToolBarToolTipTests
+    {
+        // Minimal interop needed for this test (use internal wrappers/constants where available)
+
+        // Hot item flags
+        [Flags]
+        private enum HICF : uint
+        {
+            ENTERING = 0x0010,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct NMTBHOTITEM
+        {
+            public NativeMethods.NMHDR hdr;
+            public int idOld;
+            public int idNew;
+            public HICF dwFlags;
+        }
+
+        // High DPI thread awareness helpers (User32)
+        [DllImport("user32.dll", EntryPoint = "SetThreadDpiAwarenessContext", ExactSpelling = true)]
+        private static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
+
+        [DllImport("user32.dll", EntryPoint = "GetThreadDpiAwarenessContext", ExactSpelling = true)]
+        private static extern IntPtr GetThreadDpiAwarenessContext();
+
+        // Known DPI_AWARENESS_CONTEXT values (casted from macros):
+        // https://learn.microsoft.com/windows/win32/hidpi/dpi-awareness-context
+        private static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);
+
+        private sealed class DpiAwarenessScope : IDisposable
+        {
+            private readonly IntPtr _old;
+            private readonly bool _enabled;
+
+            public DpiAwarenessScope(IntPtr newContext)
+            {
+                try
+                {
+                    _old = GetThreadDpiAwarenessContext();
+                    _enabled = SetThreadDpiAwarenessContext(newContext) != IntPtr.Zero;
+                }
+                catch (EntryPointNotFoundException)
+                {
+                    _enabled = false; // OS doesn't support per-thread DPI; proceed without changing
+                }
+            }
+
+            public void Dispose()
+            {
+                if (_enabled)
+                {
+                    try
+                    {
+                        SetThreadDpiAwarenessContext(_old);
+                    }
+                    catch (EntryPointNotFoundException)
+                    {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+
+        [Test]
+        public void ToolBar_ToolTip_Show_DoesNotMove_ToolBar()
+        {
+            using var form = new Form
+            {
+                StartPosition = FormStartPosition.Manual,
+                Location = new Point(100, 100),
+                Size = new Size(400, 200)
+            };
+
+            var toolBar = new ToolBar
+            {
+                ShowToolTips = true,
+                Dock = DockStyle.None,
+                Location = new Point(0, 0)
+            };
+
+            toolBar.Buttons.Add(new ToolBarButton("Btn") { ToolTipText = "Tip" });
+            form.Controls.Add(toolBar);
+
+            form.Show();
+            Application.DoEvents();
+
+            // Precondition: toolbar starts at 0,0
+            Assert.That(toolBar.Location, Is.EqualTo(new Point(0, 0)));
+
+            // Get the native tooltip HWND created by the toolbar
+            var lres = PInvoke.SendMessage(toolBar, (MessageId)NativeMethods.TB_GETTOOLTIPS);
+            HWND tooltipHwnd = (HWND)lres;
+            Assert.That((IntPtr)tooltipHwnd.Value, Is.Not.EqualTo(IntPtr.Zero), "Expected native tooltip window");
+
+            // Force the tooltip window top-left at (0,0) so TTN_SHOW logic will try to reposition it
+            PInvoke.SetWindowPos(tooltipHwnd, HWND.Null, 0, 0, 0, 0,
+                SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
+
+            // 1) Simulate hot item change so internal hotItem != -1
+            var hot = new NMTBHOTITEM
+            {
+                hdr = new NativeMethods.NMHDR { hwndFrom = toolBar.Handle, idFrom = IntPtr.Zero, code = NativeMethods.TBN_HOTITEMCHANGE },
+                idOld = -1,
+                idNew = 0,
+                dwFlags = HICF.ENTERING
+            };
+            PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref hot);
+
+            Application.DoEvents();
+
+            // 2) Simulate TTN_SHOW from the tooltip window
+            var nmhdr = new NativeMethods.NMHDR { hwndFrom = (IntPtr)tooltipHwnd.Value, idFrom = IntPtr.Zero, code = NativeMethods.TTN_SHOW };
+            PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref nmhdr);
+
+            Application.DoEvents();
+
+            // Assertion: Showing the tooltip must NOT move the toolbar.
+            // This would fail under the original bug where SetWindowPos targeted the toolbar HWND.
+            Assert.That(toolBar.Location, Is.EqualTo(new Point(0, 0)), "ToolBar moved unexpectedly during TTN_SHOW processing");
+
+            form.Close();
+        }
+
+        [Test]
+        public void ToolBar_ToolTip_Show_Returns_1_When_Tooltip_Is_At_0_0()
+        {
+            using var form = new Form
+            {
+                StartPosition = FormStartPosition.Manual,
+                Location = new Point(200, 200),
+                Size = new Size(400, 200)
+            };
+
+            var toolBar = new ToolBar
+            {
+                ShowToolTips = true,
+                Dock = DockStyle.None,
+                Location = new Point(10, 10)
+            };
+
+            toolBar.Buttons.Add(new ToolBarButton("Btn") { ToolTipText = "Tip" });
+            form.Controls.Add(toolBar);
+
+            form.Show();
+            Application.DoEvents();
+
+            // Ensure toolbar is not at 0,0 so wrong GetWindowPlacement handle avoids the reposition branch
+            Assert.That(toolBar.Location, Is.EqualTo(new Point(10, 10)));
+
+            // Acquire native tooltip HWND
+            var lres = PInvoke.SendMessage(toolBar, (MessageId)NativeMethods.TB_GETTOOLTIPS);
+            HWND tooltipHwnd = (HWND)lres;
+            Assert.That((IntPtr)tooltipHwnd.Value, Is.Not.EqualTo(IntPtr.Zero));
+
+            // Force the tooltip at (0,0) to trigger the reposition path when correct handle is used
+            PInvoke.SetWindowPos(tooltipHwnd, HWND.Null, 0, 0, 0, 0,
+                SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
+
+            // Simulate hot item change so hotItem != -1
+            var hot = new NMTBHOTITEM
+            {
+                hdr = new NativeMethods.NMHDR { hwndFrom = toolBar.Handle, idFrom = IntPtr.Zero, code = NativeMethods.TBN_HOTITEMCHANGE },
+                idOld = -1,
+                idNew = 0,
+                dwFlags = HICF.ENTERING
+            };
+            PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref hot);
+
+            Application.DoEvents();
+
+            // Simulate TTN_SHOW and capture the return value from WndProc
+            var nmhdr = new NativeMethods.NMHDR { hwndFrom = (IntPtr)tooltipHwnd.Value, idFrom = IntPtr.Zero, code = NativeMethods.TTN_SHOW };
+            var retL = PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref nmhdr);
+            IntPtr ret = (IntPtr)(nint)retL;
+
+            // Expect: when the correct window (tooltip) is queried for placement, TTN_SHOW repositions and returns 1.
+            // With the buggy code that queries the toolbar's placement, the condition won't trigger and ret will be 0.
+            Assert.That(ret, Is.EqualTo(new IntPtr(1)), "TTN_SHOW did not signal reposition; expected m.Result==1 when tooltip at (0,0)");
+
+            form.Close();
+        }
+
+        [Test]
+        public void ToolBar_ToolTip_TTN_SHOW_PerMonitorV2_DoesNotMove_And_Returns_1()
+        {
+            // Enter Per-Monitor V2 DPI context for the thread (best effort; no-op on older OS)
+            using var scope = new DpiAwarenessScope(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
+
+            using var form = new Form
+            {
+                StartPosition = FormStartPosition.Manual,
+                Location = new Point(300, 300),
+                Size = new Size(500, 300)
+            };
+
+            var toolBar = new ToolBar
+            {
+                ShowToolTips = true,
+                Dock = DockStyle.None,
+                Location = new Point(12, 12)
+            };
+
+            toolBar.Buttons.Add(new ToolBarButton("Btn") { ToolTipText = "Tip" });
+            form.Controls.Add(toolBar);
+
+            form.Show();
+            Application.DoEvents();
+
+            var originalLocation = toolBar.Location;
+
+            // Acquire native tooltip HWND
+            var lres = PInvoke.SendMessage(toolBar, (MessageId)NativeMethods.TB_GETTOOLTIPS);
+            HWND tooltipHwnd = (HWND)lres;
+            Assert.That((IntPtr)tooltipHwnd.Value, Is.Not.EqualTo(IntPtr.Zero));
+
+            // Force tooltip to (0,0) so TTN_SHOW reposition path is taken
+            PInvoke.SetWindowPos(tooltipHwnd, HWND.Null, 0, 0, 0, 0,
+                SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
+
+            // Simulate hot item change so hotItem != -1
+            var hot = new NMTBHOTITEM
+            {
+                hdr = new NativeMethods.NMHDR { hwndFrom = toolBar.Handle, idFrom = IntPtr.Zero, code = NativeMethods.TBN_HOTITEMCHANGE },
+                idOld = -1,
+                idNew = 0,
+                dwFlags = HICF.ENTERING
+            };
+            PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref hot);
+
+            Application.DoEvents();
+
+            // Simulate TTN_SHOW and capture return value
+            var nmhdr = new NativeMethods.NMHDR { hwndFrom = (IntPtr)tooltipHwnd.Value, idFrom = IntPtr.Zero, code = NativeMethods.TTN_SHOW };
+            var retL = PInvoke.SendMessage(toolBar, (MessageId)MessageId.WM_REFLECT_NOTIFY, default, ref nmhdr);
+            IntPtr ret = (IntPtr)(nint)retL;
+
+            Application.DoEvents();
+
+            // Assertions: TTN_SHOW is handled (ret==1) and the toolbar itself does not move
+            Assert.That(ret, Is.EqualTo(new IntPtr(1)), "TTN_SHOW should be handled under Per-Monitor V2 context");
+            Assert.That(toolBar.Location, Is.EqualTo(originalLocation), "ToolBar moved unexpectedly during TTN_SHOW under Per-Monitor V2 context");
+
+            form.Close();
+        }
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/TreeNodeTests.cs b/Tests/System.Windows.Forms.Tests/TreeNodeTests.cs
new file mode 100644
index 00000000000..7a4121a3280
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/TreeNodeTests.cs
@@ -0,0 +1,155 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Drawing;
+
+    [TestFixture]
+    [SingleThreaded]
+    public class TreeNodeTests
+    {
+        [Test]
+        public void Text_SetAndGet_ReturnsCorrectValue()
+        {
+            // Arrange
+            var treeNode = new TreeNode();
+            var text = "Test Node";
+
+            // Act
+            treeNode.Text = text;
+
+            // Assert
+            Assert.That(treeNode.Text, Is.EqualTo(text));
+        }
+
+        [Test]
+        public void Nodes_AddAndGet_ReturnsCorrectNodes()
+        {
+            // Arrange
+            var parentNode = new TreeNode();
+            var childNode = new TreeNode("Child Node");
+
+            // Act
+            parentNode.Nodes.Add(childNode);
+
+            // Assert
+            Assert.That(parentNode.Nodes.Count, Is.EqualTo(1));
+            Assert.That(parentNode.Nodes[0], Is.EqualTo(childNode));
+        }
+
+        [Test]
+        public void Parent_SetAndGet_ReturnsCorrectParent()
+        {
+            // Arrange
+            var parentNode = new TreeNode("Parent Node");
+            var childNode = new TreeNode("Child Node");
+
+            // Act
+            parentNode.Nodes.Add(childNode);
+
+            // Assert
+            Assert.That(childNode.Parent, Is.EqualTo(parentNode));
+        }
+
+        [Test]
+        public void Remove_RemovesNodeFromParent()
+        {
+            // Arrange
+            var parentNode = new TreeNode("Parent Node");
+            var childNode = new TreeNode("Child Node");
+            parentNode.Nodes.Add(childNode);
+
+            // Act
+            parentNode.Nodes.Remove(childNode);
+
+            // Assert
+            Assert.That(parentNode.Nodes.Count, Is.EqualTo(0));
+            Assert.That(childNode.Parent, Is.Null);
+        }
+
+        [Test]
+        public void TreeView_SetAndGet_ReturnsCorrectTreeView()
+        {
+            // Arrange
+            var treeView = new TreeView();
+            var treeNode = new TreeNode("Test Node");
+
+            // Act
+            treeView.Nodes.Add(treeNode);
+
+            // Assert
+            Assert.That(treeNode.TreeView, Is.EqualTo(treeView));
+        }
+
+        [Test]
+        public void ContextMenu_SetAndGet_ReturnsCorrectValue()
+        {
+            // Arrange
+            var treeNode = new TreeNode();
+            var contextMenu = new ContextMenu();
+
+            // Act
+            treeNode.ContextMenu = contextMenu;
+
+            // Assert
+            Assert.That(treeNode.ContextMenu, Is.EqualTo(contextMenu));
+        }
+
+        // Commenting out this test, as it doesn't work in DAT
+        //[Test]
+        //public void ContextMenu_ShowsOnRightClick()
+        //{
+        //    // Arrange
+        //    var form = new Form();
+        //    var treeView = new TreeView();
+        //    var treeNode = new TreeNode("Test Node");
+        //    var contextMenu = new ContextMenu();
+        //    contextMenu.MenuItems.Add(new MenuItem("Test Item"));
+        //    treeNode.ContextMenu = contextMenu;
+        //    treeView.Nodes.Add(treeNode);
+        //    treeView.Bounds = new Rectangle(10, 10, 200, 200);
+        //    form.Controls.Add(treeView);
+
+        //    bool contextMenuShown = false;
+        //    contextMenu.Popup += (sender, e) => contextMenuShown = true;
+
+        //    // Ensure the Form and TreeView are created and visible
+        //    form.Load += async (sender, e) =>
+        //    {
+        //        // Need to wait for the form to be created and visible
+        //        await Task.Delay(500);
+
+        //        // Get the bounds of the TreeNode
+        //        var nodeBounds = treeNode.Bounds;
+        //        var clickPointRelativeToTreeView = nodeBounds.Location + new Size(nodeBounds.Width / 2, nodeBounds.Y + nodeBounds.Height / 2);
+        //        var clickPointRelativeToScreen = treeView.PointToScreen(clickPointRelativeToTreeView);
+
+        //        // Simulate right-click event on the TreeNode
+        //        Cursor.Position = clickPointRelativeToScreen;
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.RightDown, (uint)clickPointRelativeToScreen.X, (uint)clickPointRelativeToScreen.Y);
+        //        await Task.Delay(100);
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.RightUp, (uint)clickPointRelativeToScreen.X, (uint)clickPointRelativeToScreen.Y);
+
+        //        // Wait 1 second for the context menu to show
+        //        await Task.Delay(1000);
+
+        //        var clickPointOutsideContextMenuRelative = new Point(50, 50);
+        //        var clickPointOutsideContextMenuAbsolute = treeView.PointToScreen(clickPointOutsideContextMenuRelative);
+
+        //        Cursor.Position = clickPointOutsideContextMenuAbsolute;
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.LeftDown, (uint)clickPointOutsideContextMenuAbsolute.X, (uint)clickPointOutsideContextMenuAbsolute.Y);
+        //        await Task.Delay(100);
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.LeftUp, (uint)clickPointOutsideContextMenuAbsolute.X, (uint)clickPointOutsideContextMenuAbsolute.Y);
+
+        //        // Wait 1 second for the context menu to close
+        //        await Task.Delay(1000);
+
+        //        // Assert
+        //        Assert.IsTrue(contextMenuShown);
+        //        form.Close();
+        //        return;
+        //    };
+
+        //    // Show the form
+        //    form.ShowDialog();
+        //}
+    }
+}
diff --git a/Tests/System.Windows.Forms.Tests/TreeViewTests.cs b/Tests/System.Windows.Forms.Tests/TreeViewTests.cs
new file mode 100644
index 00000000000..c6413d3cd38
--- /dev/null
+++ b/Tests/System.Windows.Forms.Tests/TreeViewTests.cs
@@ -0,0 +1,96 @@
+namespace System.Windows.Forms.Tests
+{
+    using System.Drawing;
+
+    [TestFixture]
+    [SingleThreaded]
+    public class TreeViewTests
+    {
+        [Test]
+        public void ContextMenu_SetAndGet_ReturnsCorrectValue()
+        {
+            // Arrange
+            var treeView = new TreeView();
+            var contextMenu = new ContextMenu();
+
+            // Act
+            treeView.ContextMenu = contextMenu;
+
+            // Assert
+            Assert.That(treeView.ContextMenu, Is.EqualTo(contextMenu));
+        }
+
+        // Commenting out this test, as it doesn't work in DAT
+        //[Test]
+        //public void ContextMenu_ShowsOnRightClick()
+        //{
+        //    // Arrange
+        //    var form = new Form();
+        //    var treeView = new TreeView();
+        //    var contextMenu = new ContextMenu();
+        //    contextMenu.MenuItems.Add(new MenuItem("Test Item"));
+        //    treeView.ContextMenu = contextMenu;
+        //    treeView.Bounds = new Rectangle(10, 10, 200, 200);
+        //    form.Controls.Add(treeView);
+
+        //    bool contextMenuShown = false;
+        //    contextMenu.Popup += (sender, e) => contextMenuShown = true;
+
+        //    // Ensure the Form and TreeView are created and visible
+        //    form.Load += async (sender, e) =>
+        //    {
+        //        // Wait for the tree view to be created
+        //        await Task.Delay(500);
+
+        //        var clickPointRelativeToTreeView = treeView.Bounds.Location + new Size(treeView.Bounds.Width / 2, treeView.Bounds.Y + treeView.Bounds.Height / 2);
+        //        var clickPointRelativeToScreen = treeView.PointToScreen(clickPointRelativeToTreeView);
+
+        //        // Simulate right-click event on the TreeNode
+        //        Cursor.Position = clickPointRelativeToScreen;
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.RightDown, (uint)clickPointRelativeToScreen.X, (uint)clickPointRelativeToScreen.Y);
+        //        await Task.Delay(100);
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.RightUp, (uint)clickPointRelativeToScreen.X, (uint)clickPointRelativeToScreen.Y);
+
+        //        // Wait 1 second for the context menu to show
+        //        await Task.Delay(1000);
+
+        //        var clickPointOutsideContextMenuRelative = new Point(50, 50);
+        //        var clickPointOutsideContextMenuAbsolute = treeView.PointToScreen(clickPointOutsideContextMenuRelative);
+
+        //        Cursor.Position = clickPointOutsideContextMenuAbsolute;
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.LeftDown, (uint)clickPointOutsideContextMenuAbsolute.X, (uint)clickPointOutsideContextMenuAbsolute.Y);
+        //        await Task.Delay(100);
+        //        MouseOperations.MouseEvent(MouseOperations.MouseEventFlags.LeftUp, (uint)clickPointOutsideContextMenuAbsolute.X, (uint)clickPointOutsideContextMenuAbsolute.Y);
+
+        //        // Wait 1 second for the context menu to close
+        //        await Task.Delay(1000);
+
+        //        // Assert
+        //        Assert.IsTrue(contextMenuShown);
+        //        form.Close();
+        //        return;
+        //    };
+
+        //    // Show the form
+        //    form.ShowDialog();
+        //}
+
+        [Test]
+        public void ContextMenu_ContainsExpectedItems()
+        {
+            // Arrange
+            var treeView = new TreeView();
+            var contextMenu = new ContextMenu();
+            var menuItem = new MenuItem("Test Item");
+            contextMenu.MenuItems.Add(menuItem);
+            treeView.ContextMenu = contextMenu;
+
+            // Act
+            var items = treeView.ContextMenu.MenuItems;
+
+            // Assert
+            Assert.That(items.Count, Is.EqualTo(1));
+            Assert.That(items[0].Text, Is.EqualTo("Test Item"));
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/Common/CommonMemberDataAttribute.cs b/WTG.System.Windows.Forms.Tests/Common/CommonMemberDataAttribute.cs
new file mode 100644
index 00000000000..a4ba915c24f
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/Common/CommonMemberDataAttribute.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+
+namespace WTG.System.Windows.Forms.Tests.Common
+{
+    /// <summary>
+    ///  A custom MemberData attribute that is specialized for the CommonTestHelper type.
+    ///  Useful to remove the need to suffix all attributes with "MemberType = ..."
+    ///  We cannot inherit from MemberDataAttribute as it is sealed, so we have to reimplement
+    ///  ConvertDataItem inheriting from MemberDataAttributeBase.
+    /// </summary>
+    public sealed class CommonMemberDataAttribute : MemberDataAttributeBase
+    {
+        public CommonMemberDataAttribute(string memberName, params object[] parameters) : base(memberName, parameters)
+        {
+            MemberType = typeof(CommonTestHelper);
+        }
+
+        protected override object[] ConvertDataItem(MethodInfo testMethod, object item)
+        {
+            if (item is null)
+            {
+                return null;
+            }
+
+            if (!(item is object[] array))
+            {
+                throw new ArgumentException($"Property {MemberName} on {MemberType ?? testMethod.DeclaringType} yielded an item that is not an object[]");
+            }
+
+            return array;
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/CommonTestHelper.cs b/WTG.System.Windows.Forms.Tests/CommonTestHelper.cs
new file mode 100644
index 00000000000..25b75c62de3
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/CommonTestHelper.cs
@@ -0,0 +1,532 @@
+using System.ComponentModel.Design.Serialization;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public static class CommonTestHelper
+    {
+        // helper method to generate theory data from all values of an enum type
+        internal static TheoryData<T> GetEnumTheoryData<T>() where T : Enum
+        {
+            var data = new TheoryData<T>();
+            foreach (T item in Enum.GetValues(typeof(T)))
+            {
+                data.Add(item);
+            }
+
+            return data;
+        }
+
+        public static TheoryData GetEnumTypeTheoryData(Type enumType)
+        {
+            var data = new TheoryData<Enum>();
+            foreach (Enum item in Enum.GetValues(enumType))
+            {
+                data.Add(item);
+            }
+
+            return data;
+        }
+
+        // helper method to generate invalid theory data for an enum type
+        // This method assumes that int.MinValue and int.MaxValue are not in the enum
+        internal static TheoryData<T> GetEnumTheoryDataInvalid<T>() where T : Enum
+        {
+            var data = new TheoryData<T>
+            {
+                // This boxing is necessary because you can't cast an int to a generic,
+                // even if the generic is guaranteed to be an enum
+                (T)(object)int.MinValue,
+                (T)(object)int.MaxValue
+            };
+            return data;
+        }
+
+        public static TheoryData<Enum> GetEnumTypeTheoryDataInvalid(Type enumType)
+        {
+            var data = new TheoryData<Enum>();
+            IEnumerable<Enum> values = Enum.GetValues(enumType).Cast<Enum>().OrderBy(p => p);
+
+            // Assumes that the enum is sequential.
+            data.Add((Enum)Enum.ToObject(enumType, Convert.ToInt32(values.Min()) - 1));
+            data.Add((Enum)Enum.ToObject(enumType, Convert.ToInt32(values.Max()) + 1));
+            return data;
+        }
+
+        #region Primitives
+
+        // helper method to generate theory data for all values of a boolean
+        public static TheoryData<bool> GetBoolTheoryData()
+        {
+            var data = new TheoryData<bool>
+            {
+                true,
+                false
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for some values of a int
+        public static TheoryData<int> GetIntTheoryData()
+        {
+            var data = new TheoryData<int>
+            {
+                int.MinValue,
+                int.MaxValue,
+                0,
+                1,
+                -1,
+                int.MaxValue / 2
+            };
+            return data;
+        }
+
+        public static TheoryData<int> GetNonNegativeIntTheoryData()
+        {
+            var data = new TheoryData<int>
+            {
+                int.MaxValue,
+                0,
+                1,
+                int.MaxValue / 2
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for some values of a int
+        internal static TheoryData<uint> GetUIntTheoryData()
+        {
+            var data = new TheoryData<uint>
+            {
+                int.MaxValue,
+                0,
+                1,
+                int.MaxValue / 2
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for some values of a int
+        internal static TheoryData<int> GetNIntTheoryData()
+        {
+            var data = new TheoryData<int>
+            {
+                int.MinValue,
+                -1,
+                int.MinValue / 2
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for some values of a int
+        internal static TheoryData<float> GetFloatTheoryData()
+        {
+            var data = new TheoryData<float>
+            {
+                float.MaxValue,
+                float.MinValue,
+                float.Epsilon,
+                float.Epsilon * -1,
+                float.NegativeInfinity, // not sure about these two
+                float.PositiveInfinity, // 2
+                0,
+                -1,
+                1,
+                float.MaxValue / 2
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for some values of a int
+        internal static TheoryData<float> GetUFloatTheoryData()
+        {
+            var data = new TheoryData<float>
+            {
+                float.MaxValue,
+                float.Epsilon,
+                float.PositiveInfinity, // not sure about this one
+                0,
+                1,
+                float.MaxValue / 2
+            };
+            return data;
+        }
+
+        // helper method to generate theory data for a span of string values
+        private const string reasonable = nameof(reasonable);
+
+        public static TheoryData<string> GetStringTheoryData()
+        {
+            var data = new TheoryData<string>
+            {
+                string.Empty,
+                reasonable
+            };
+            return data;
+        }
+
+        public static TheoryData<string> GetStringWithNullTheoryData()
+        {
+            var data = new TheoryData<string>
+            {
+                null,
+                string.Empty,
+                reasonable
+            };
+            return data;
+        }
+
+        public static TheoryData<string> GetNullOrEmptyStringTheoryData()
+        {
+            var data = new TheoryData<string>
+            {
+                null,
+                string.Empty
+            };
+            return data;
+        }
+
+        public static TheoryData<string, string> GetStringNormalizedTheoryData()
+        {
+            var data = new TheoryData<string, string>
+            {
+                { null, string.Empty },
+                { string.Empty, string.Empty },
+                { reasonable, reasonable }
+            };
+            return data;
+        }
+
+        public static TheoryData<string, string, int> GetCtrlBackspaceData()
+        {
+            var data = new TheoryData<string, string, int>
+            {
+                { "aaa", "", 0 },
+                { "---", "", 0 },
+                { " aaa", "", 0 },
+                { " ---", "", 0 },
+                { "aaa---", "", 0 },
+                { "---aaa", "---", 0 },
+                { "aaa---aaa", "aaa---", 0 },
+                { "---aaa---", "---", 0 },
+                { "a-a", "a-", 0 },
+                { "-a-", "", 0 },
+                { "--a-", "--", 0 },
+                { "abc", "c", -1 },
+                { "a,1-b", "a,b", -1 }
+            };
+            return data;
+        }
+
+        public static TheoryData<string, string, int> GetCtrlBackspaceRepeatedData()
+        {
+            var data = new TheoryData<string, string, int>
+            {
+                { "aaa", "", 2 },
+                { "---", "", 2 },
+                { "aaa---aaa", "", 2 },
+                { "---aaa---", "", 2 },
+                { "aaa bbb", "", 2 },
+                { "aaa bbb ccc", "aaa ", 2 },
+                { "aaa --- ccc", "", 2 },
+                { "1 2 3 4 5 6 7 8 9 0", "1 ", 9 }
+            };
+            return data;
+        }
+
+        public static TheoryData<char> GetCharTheoryData()
+        {
+            var data = new TheoryData<char>
+            {
+                '\0',
+                'a'
+            };
+            return data;
+        }
+
+        public static TheoryData<IntPtr> GetIntPtrTheoryData()
+        {
+            var data = new TheoryData<IntPtr>
+            {
+                (IntPtr)(-1),
+                IntPtr.Zero,
+                (IntPtr)1
+            };
+            return data;
+        }
+
+        public static TheoryData<Guid> GetGuidTheoryData()
+        {
+            var data = new TheoryData<Guid>
+            {
+                Guid.Empty,
+                Guid.NewGuid()
+            };
+            return data;
+        }
+
+        public static TheoryData<Color> GetColorTheoryData()
+        {
+            var data = new TheoryData<Color>
+            {
+                Color.Red,
+                Color.Blue,
+                Color.Black
+            };
+            return data;
+        }
+
+        public static TheoryData<Color> GetColorWithEmptyTheoryData()
+        {
+            var data = new TheoryData<Color>
+            {
+                Color.Red,
+                Color.Empty
+            };
+            return data;
+        }
+
+        public static TheoryData<Color, Color> GetBackColorTheoryData()
+        {
+            return new TheoryData<Color, Color>
+            {
+                { Color.Red, Color.Red },
+                { Color.Empty, Control.DefaultBackColor }
+            };
+        }
+
+        public static TheoryData<Color, Color> GetForeColorTheoryData()
+        {
+            return new TheoryData<Color, Color>
+            {
+                { Color.Red, Color.Red },
+                { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) },
+                { Color.Empty, Control.DefaultForeColor }
+            };
+        }
+
+        public static TheoryData<Image> GetImageTheoryData()
+        {
+            var data = new TheoryData<Image>
+            {
+                new Bitmap(10, 10),
+                null
+            };
+            return data;
+        }
+
+        public static TheoryData<Font> GetFontTheoryData()
+        {
+            var data = new TheoryData<Font>
+            {
+                SystemFonts.MenuFont,
+                null
+            };
+            return data;
+        }
+
+        public static TheoryData<Type> GetTypeWithNullTheoryData()
+        {
+            var data = new TheoryData<Type>
+            {
+                null,
+                typeof(int)
+            };
+            return data;
+        }
+
+        public static TheoryData<RightToLeft, RightToLeft> GetRightToLeftTheoryData()
+        {
+            var data = new TheoryData<RightToLeft, RightToLeft>
+            {
+                { RightToLeft.Inherit, RightToLeft.No },
+                { RightToLeft.Yes, RightToLeft.Yes },
+                { RightToLeft.No, RightToLeft.No }
+            };
+            return data;
+        }
+
+        public static TheoryData<Point> GetPointTheoryData() => GetPointTheoryData(TestIncludeType.All);
+
+        public static TheoryData<Point> GetPointTheoryData(TestIncludeType includeType)
+        {
+            var data = new TheoryData<Point>();
+            if (!includeType.HasFlag(TestIncludeType.NoPositives))
+            {
+                data.Add(new Point());
+                data.Add(new Point(10));
+                data.Add(new Point(1, 2));
+            }
+
+            if (!includeType.HasFlag(TestIncludeType.NoNegatives))
+            {
+                data.Add(new Point(int.MaxValue, int.MinValue));
+                data.Add(new Point(-1, -2));
+            }
+
+            return data;
+        }
+
+        public static TheoryData<Size> GetSizeTheoryData() => GetSizeTheoryData(TestIncludeType.All);
+
+        public static TheoryData<Size> GetSizeTheoryData(TestIncludeType includeType)
+        {
+            var data = new TheoryData<Size>();
+            if (!includeType.HasFlag(TestIncludeType.NoPositives))
+            {
+                data.Add(new Size());
+                data.Add(new Size(new Point(1, 1)));
+                data.Add(new Size(1, 2));
+            }
+
+            if (!includeType.HasFlag(TestIncludeType.NoNegatives))
+            {
+                data.Add(new Size(-1, 1));
+                data.Add(new Size(1, -1));
+            }
+
+            return data;
+        }
+
+        public static TheoryData<Size> GetPositiveSizeTheoryData()
+        {
+            var data = new TheoryData<Size>
+            {
+                new(),
+                new(1, 2)
+            };
+            return data;
+        }
+
+        public static TheoryData<Rectangle> GetRectangleTheoryData()
+        {
+            var data = new TheoryData<Rectangle>
+            {
+                new(),
+                new(1, 2, 3, 4),
+                new(-1, -2, -3, -4)
+            };
+            return data;
+        }
+
+        public static TheoryData<Padding> GetPaddingTheoryData()
+        {
+            var data = new TheoryData<Padding>
+            {
+                new(),
+                new(1, 2, 3, 4),
+                new(1),
+                new(-1, -2, -3, -4)
+            };
+            return data;
+        }
+
+        public static TheoryData<Padding, Padding> GetPaddingNormalizedTheoryData()
+        {
+            var data = new TheoryData<Padding, Padding>
+            {
+                { new Padding(), new Padding() },
+                { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4) },
+                { new Padding(1), new Padding(1) },
+                { new Padding(-1, -2, -3, -4), Padding.Empty }
+            };
+            return data;
+        }
+
+        public static TheoryData<Type, bool> GetConvertFromTheoryData()
+        {
+            var data = new TheoryData<Type, bool>
+            {
+                { typeof(bool), false },
+                { typeof(InstanceDescriptor), true },
+                { typeof(int), false },
+                { typeof(double), false },
+                { null, false }
+            };
+            return data;
+        }
+
+        public static TheoryData<Cursor> GetCursorTheoryData()
+        {
+            var data = new TheoryData<Cursor>
+            {
+                null,
+                new((IntPtr)1)
+            };
+            return data;
+        }
+
+        public static TheoryData<EventArgs> GetEventArgsTheoryData()
+        {
+            var data = new TheoryData<EventArgs>
+            {
+                null,
+                new()
+            };
+            return data;
+        }
+
+        public static TheoryData<PaintEventArgs> GetPaintEventArgsTheoryData()
+        {
+            var image = new Bitmap(10, 10);
+            Graphics graphics = Graphics.FromImage(image);
+            return new TheoryData<PaintEventArgs>
+            {
+                null,
+                new(graphics, Rectangle.Empty)
+            };
+        }
+
+        public static TheoryData<KeyEventArgs> GetKeyEventArgsTheoryData()
+        {
+            var data = new TheoryData<KeyEventArgs>
+            {
+                null,
+                new(Keys.Cancel)
+            };
+            return data;
+        }
+
+        public static TheoryData<KeyPressEventArgs> GetKeyPressEventArgsTheoryData()
+        {
+            var data = new TheoryData<KeyPressEventArgs>
+            {
+                null,
+                new('1')
+            };
+            return data;
+        }
+
+        public static TheoryData<LayoutEventArgs> GetLayoutEventArgsTheoryData()
+        {
+            var data = new TheoryData<LayoutEventArgs>
+            {
+                null,
+                new(null, null),
+                new(new Control(), "affectedProperty")
+            };
+            return data;
+        }
+
+        public static TheoryData<MouseEventArgs> GetMouseEventArgsTheoryData()
+        {
+            return new TheoryData<MouseEventArgs>
+            {
+                null,
+                new(MouseButtons.Left, 1, 2, 3, 4),
+                new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4)
+            };
+        }
+
+        #endregion
+    }
+
+    [Flags]
+    public enum TestIncludeType
+    {
+        All,
+        NoPositives,
+        NoNegatives
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/ContextMenuTests.cs b/WTG.System.Windows.Forms.Tests/ContextMenuTests.cs
new file mode 100644
index 00000000000..a158fc5e873
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/ContextMenuTests.cs
@@ -0,0 +1,299 @@
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class ContextMenuTests
+    {
+        [Fact]
+        public void ContextMenu_Ctor_Default()
+        {
+            var menu = new ContextMenu();
+            Assert.Empty(menu.MenuItems);
+            Assert.False(menu.IsParent);
+            Assert.Equal(RightToLeft.No, menu.RightToLeft);
+            Assert.Null(menu.SourceControl);
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        public static IEnumerable<object[]> Ctor_MenuItemArray_TestData()
+        {
+            yield return new object[] { null, false };
+            yield return new object[] { Array.Empty<MenuItem>(), false };
+            yield return new object[] { new MenuItem[] { new() }, true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_MenuItemArray_TestData))]
+        public void ContextMenu_Ctor_MenuItemArray(MenuItem[] items, bool expectedIsParent)
+        {
+            var menu = new ContextMenu(items);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menu.MenuItems.Cast<MenuItem>());
+            for (int i = 0; i < (items?.Length ?? 0); i++)
+            {
+                Assert.Equal(i, menu.MenuItems[i].Index);
+                Assert.Equal(menu, menu.MenuItems[i].Parent);
+            }
+
+            Assert.Equal(expectedIsParent, menu.IsParent);
+            Assert.Equal(RightToLeft.No, menu.RightToLeft);
+            Assert.Null(menu.SourceControl);
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void ContextMenu_Ctor_NullItemInMenuItemArray_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("item", () => new ContextMenu(new MenuItem[] { null }));
+        }
+
+        [Fact]
+        public void ContextMenu_SourceControl_GetProcessingKeyMessage_Succes()
+        {
+            var control = new Control
+            {
+                ContextMenu = new ContextMenu()
+            };
+
+            ContextMenu menu = control.ContextMenu;
+            Assert.Null(menu.SourceControl);
+
+            var message = new Message
+            {
+                Msg = 0x0100 // WM_KEYDOWN
+            };
+            control.PreProcessMessage(ref message);
+            Assert.Same(control, menu.SourceControl);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetRightToLeftTheoryData))]
+        public void ContextMenu_RightToLeft_SetWithoutSourceControl_GetReturnsExpected(RightToLeft value, RightToLeft expectedValue)
+        {
+            var menu = new ContextMenu
+            {
+                RightToLeft = value
+            };
+            Assert.Equal(expectedValue, menu.RightToLeft);
+        }
+
+        [Theory]
+        [InlineData(RightToLeft.Yes, RightToLeft.Yes)]
+        [InlineData(RightToLeft.No, RightToLeft.No)]
+        [InlineData(RightToLeft.Inherit, RightToLeft.Yes)]
+        public void ContextMenu_RightToLeft_SetWithSourceControl_GetReturnsExpected(RightToLeft value, RightToLeft expectedValue)
+        {
+            var control = new Control
+            {
+                ContextMenu = new ContextMenu(),
+                RightToLeft = RightToLeft.Yes
+            };
+
+            ContextMenu menu = control.ContextMenu;
+            var message = new Message
+            {
+                Msg = 0x0100 // WM_KEYDOWN
+            };
+            control.PreProcessMessage(ref message);
+
+            menu.RightToLeft = value;
+            Assert.Equal(expectedValue, menu.RightToLeft);
+        }
+
+        [Fact]
+        public void ContextMenu_RightToLeft_SetCreated_GetReturnsExpected()
+        {
+            using (var menu = new ContextMenu(new MenuItem[] { new("text") }))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                menu.RightToLeft = RightToLeft.Yes;
+                menu.RightToLeft = RightToLeft.No;
+                Assert.Equal(RightToLeft.No, menu.RightToLeft);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(RightToLeft), MemberType = typeof(CommonTestHelper))]
+        public void ContextMenu_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
+        {
+            var menu = new ContextMenu();
+            Assert.Throws<InvalidEnumArgumentException>("RightToLeft", () => menu.RightToLeft = value);
+        }
+
+        public static IEnumerable<object[]> ProcessCmdKey_TestData()
+        {
+            yield return new object[] { new MenuItem { Shortcut = Shortcut.CtrlA }, true, 1, 0 };
+            yield return new object[] { new MenuItem { Shortcut = Shortcut.CtrlA, Enabled = false }, false, 0, 0 };
+            yield return new object[] { new MenuItem("text", new MenuItem[] { new() }) { Shortcut = Shortcut.CtrlA }, true, 0, 1 };
+            yield return new object[] { new MenuItem("text", new MenuItem[] { new() }) { Shortcut = Shortcut.CtrlA, Enabled = false }, false, 0, 0 };
+        }
+
+        [Theory]
+        [MemberData(nameof(ProcessCmdKey_TestData))]
+        public void ContextMenu_ProcessCmdKey_HasItemWithShoutcutKey_ReturnsExpected(MenuItem menuItem, bool expectedResult, int expectedOnClickCallCount, int expectedOnPopupCallCount)
+        {
+            var control = new Control();
+            int onClickCallCount = 0;
+            menuItem.Click += (sender, e) =>
+            {
+                onClickCallCount++;
+                Assert.Same(menuItem, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            int onPopupCallCount = 0;
+            menuItem.Popup += (sender, e) =>
+            {
+                onPopupCallCount++;
+                Assert.Same(menuItem, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            var menu = new ContextMenu(new MenuItem[] { menuItem });
+            var message = new Message();
+            Assert.Equal(expectedResult, menu.ProcessCmdKey(ref message, Keys.Control | Keys.A, control));
+            Assert.Same(control, menu.SourceControl);
+            Assert.Equal(expectedOnClickCallCount, onClickCallCount);
+            Assert.Equal(expectedOnPopupCallCount, onPopupCallCount);
+        }
+
+        [Fact]
+        public void ContextMenu_Show_ControlPoint_Success()
+        {
+            var menu = new ContextMenu();
+            var control = new Control
+            {
+                Visible = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menu, sender);
+                callCount++;
+            };
+            menu.Popup += handler;
+
+            Assert.NotEqual(IntPtr.Zero, control.Handle);
+            menu.Show(control, new Point(1, 2));
+            Assert.Equal(1, callCount);
+            Assert.Same(control, menu.SourceControl);
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(LeftRightAlignment), MemberType = typeof(CommonTestHelper))]
+        [MemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(LeftRightAlignment), MemberType = typeof(CommonTestHelper))]
+        public void ContextMenu_Show_ControlPointLeftRightAlignment_Success(LeftRightAlignment alignment)
+        {
+            var menu = new ContextMenu();
+            var control = new Control
+            {
+                Visible = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menu, sender);
+                callCount++;
+            };
+            menu.Popup += handler;
+
+            Assert.NotEqual(IntPtr.Zero, control.Handle);
+            menu.Show(control, new Point(1, 2), alignment);
+            Assert.Equal(1, callCount);
+            Assert.Same(control, menu.SourceControl);
+        }
+
+        [Fact]
+        public void ContextMenu_Show_NullControl_ThrowsArgumentNullException()
+        {
+            var menu = new ContextMenu();
+            Assert.Throws<ArgumentNullException>("control", () => menu.Show(null, new Point(1, 2)));
+            Assert.Throws<ArgumentNullException>("control", () => menu.Show(null, new Point(1, 2), LeftRightAlignment.Left));
+        }
+
+        [Fact]
+        public void ContextMenu_Show_NotVisibleControl_ThrowsArgumentException()
+        {
+            var menu = new ContextMenu();
+            var control = new Control
+            {
+                Visible = false
+            };
+            Assert.NotEqual(IntPtr.Zero, control.Handle);
+            Assert.Throws<ArgumentException>("control", () => menu.Show(control, new Point(1, 2)));
+            Assert.Throws<ArgumentException>("control", () => menu.Show(control, new Point(1, 2), LeftRightAlignment.Left));
+        }
+
+        [Fact]
+        public void ContextMenu_Show_ControlHasNoHandle_ThrowsArgumentException()
+        {
+            var menu = new ContextMenu();
+            var control = new Control
+            {
+                Visible = true
+            };
+            Assert.Throws<ArgumentException>("control", () => menu.Show(control, new Point(1, 2)));
+            Assert.Throws<ArgumentException>("control", () => menu.Show(control, new Point(1, 2), LeftRightAlignment.Left));
+        }
+
+        [Fact]
+        public void ContextMenu_OnCollapse_Invoke_Success()
+        {
+            var menu = new ContextMenu();
+
+            // No handler.
+            menu.OnCollapse(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menu, sender);
+                callCount++;
+            };
+
+            menu.Collapse += handler;
+            menu.OnCollapse(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menu.Collapse -= handler;
+            menu.OnCollapse(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void ContextMenu_OnPopup_Invoke_Success()
+        {
+            var menu = new ContextMenu();
+
+            // No handler.
+            menu.OnPopup(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menu, sender);
+                callCount++;
+            };
+
+            menu.Popup += handler;
+            menu.OnPopup(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menu.Popup -= handler;
+            menu.OnPopup(null);
+            Assert.Equal(1, callCount);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/DataGridCellTests.cs b/WTG.System.Windows.Forms.Tests/DataGridCellTests.cs
new file mode 100644
index 00000000000..91930ed6562
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/DataGridCellTests.cs
@@ -0,0 +1,89 @@
+
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class DataGridCellTests
+    {
+        [Fact]
+        public void DataGridCell_Ctor_Default()
+        {
+            var cell = new DataGridCell();
+            Assert.Equal(0, cell.RowNumber);
+            Assert.Equal(0, cell.ColumnNumber);
+        }
+
+        [Theory]
+        [InlineData(-1, -2)]
+        [InlineData(0, 0)]
+        [InlineData(1, 2)]
+        [InlineData(1, 0)]
+        [InlineData(0, 1)]
+        public void DataGridCell_Ctor_Int_Int(int rowNumber, int columnNumber)
+        {
+            var cell = new DataGridCell(rowNumber, columnNumber);
+            Assert.Equal(rowNumber, cell.RowNumber);
+            Assert.Equal(columnNumber, cell.ColumnNumber);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void DataGridCell_RowNumber_Set_GetReturnsExpected(int value)
+        {
+            var cell = new DataGridCell
+            {
+                RowNumber = value
+            };
+            Assert.Equal(value, cell.RowNumber);
+
+            // Set same.
+            cell.RowNumber = value;
+            Assert.Equal(value, cell.RowNumber);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void DataGridCell_ColumnNumber_Set_GetReturnsExpected(int value)
+        {
+            var cell = new DataGridCell
+            {
+                ColumnNumber = value
+            };
+            Assert.Equal(value, cell.ColumnNumber);
+
+            // Set same.
+            cell.ColumnNumber = value;
+            Assert.Equal(value, cell.ColumnNumber);
+        }
+
+        public static IEnumerable<object[]> Equals_TestData()
+        {
+            yield return new object[] { new DataGridCell(1, 2), new DataGridCell(1, 2), true };
+            yield return new object[] { new DataGridCell(1, 2), new DataGridCell(2, 2), false };
+            yield return new object[] { new DataGridCell(1, 2), new DataGridCell(1, 3), false };
+
+            yield return new object[] { new DataGridCell(1, 2), new(), false };
+            yield return new object[] { new DataGridCell(1, 2), "null", false };
+        }
+
+        [Theory]
+        [MemberData(nameof(Equals_TestData))]
+        public void DataGridCell_Equals_Invoke_ReturnsExpected(DataGridCell cell, object other, bool expected)
+        {
+            if (other is DataGridCell otherCell)
+            {
+                Assert.Equal(expected, cell.GetHashCode().Equals(otherCell.GetHashCode()));
+            }
+
+            Assert.Equal(expected, cell.Equals(other));
+        }
+
+        [Fact]
+        public void DataGridCell_ToString_Invoke_ReturnsExpected()
+        {
+            var cell = new DataGridCell(1, 2);
+            Assert.Equal("DataGridCell {RowNumber = 1, ColumnNumber = 2}", cell.ToString());
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/DataGridColumnHeaderAccessibleObjectTests.cs b/WTG.System.Windows.Forms.Tests/DataGridColumnHeaderAccessibleObjectTests.cs
new file mode 100644
index 00000000000..390f9183e60
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/DataGridColumnHeaderAccessibleObjectTests.cs
@@ -0,0 +1,55 @@
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class DataGridColumnHeaderAccessibleObjectTests : DataGridColumnStyle
+    {
+        [Fact]
+        public void Ctor_Default()
+        {
+            var accessibleObject = new DataGridColumnHeaderAccessibleObject();
+            Assert.Equal(AccessibleRole.ColumnHeader, accessibleObject.Role);
+        }
+
+        protected internal override void Abort(int rowNum)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override Size GetPreferredSize(Graphics g, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override int GetMinimumHeight()
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override int GetPreferredHeight(Graphics g, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/DataGridColumnStyleTests.cs b/WTG.System.Windows.Forms.Tests/DataGridColumnStyleTests.cs
new file mode 100644
index 00000000000..834b164c306
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/DataGridColumnStyleTests.cs
@@ -0,0 +1,1390 @@
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class DataGridColumnStyleTests
+    {
+        [Fact]
+        public void DataGridColumnStyle_Ctor_Default()
+        {
+            var style = new SubDataGridColumnStyle();
+            Assert.Equal(HorizontalAlignment.Left, style.Alignment);
+            Assert.True(style.CanRaiseEvents);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGridTableStyle);
+            Assert.False(style.DesignMode);
+            Assert.NotNull(style.Events);
+            Assert.Same(style.Events, style.Events);
+            Assert.Equal(Control.DefaultFont.Height, style.FontHeight);
+            Assert.NotNull(style.HeaderAccessibleObject);
+            Assert.Same(style.HeaderAccessibleObject, style.HeaderAccessibleObject);
+            Assert.Empty(style.HeaderText);
+            Assert.Empty(style.MappingName);
+            Assert.Null(style.PropertyDescriptor);
+            Assert.False(style.ReadOnly);
+            Assert.Null(style.Site);
+            Assert.Equal(-1, style.Width);
+        }
+
+        public static IEnumerable<object[]> Ctor_PropertyDescriptor_TestData()
+        {
+            yield return new object[] { null, false };
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(DataClass))[0], false };
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(ReadOnlyDataClass))[0], true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_PropertyDescriptor_TestData))]
+        public void Ctor_PropertyDescriptor(PropertyDescriptor descriptor, bool expectedReadOnly)
+        {
+            var style = new SubDataGridColumnStyle(descriptor);
+            Assert.Equal(HorizontalAlignment.Left, style.Alignment);
+            Assert.True(style.CanRaiseEvents);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGridTableStyle);
+            Assert.False(style.DesignMode);
+            Assert.NotNull(style.Events);
+            Assert.Same(style.Events, style.Events);
+            Assert.Equal(Control.DefaultFont.Height, style.FontHeight);
+            Assert.NotNull(style.HeaderAccessibleObject);
+            Assert.Same(style.HeaderAccessibleObject, style.HeaderAccessibleObject);
+            Assert.Empty(style.HeaderText);
+            Assert.Empty(style.MappingName);
+            Assert.Same(descriptor, style.PropertyDescriptor);
+            Assert.Equal(expectedReadOnly, style.ReadOnly);
+            Assert.Null(style.Site);
+            Assert.Equal(-1, style.Width);
+        }
+
+        public static IEnumerable<object[]> Ctor_PropertyDescriptor_Bool_TestData()
+        {
+            yield return new object[] { null, true, string.Empty, false };
+            yield return new object[] { null, false, string.Empty, false };
+
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(DataClass))[0], true, "Value1", false };
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(DataClass))[0], false, string.Empty, false };
+
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(ReadOnlyDataClass))[0], true, "Value1", true };
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(ReadOnlyDataClass))[0], false, string.Empty, true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_PropertyDescriptor_Bool_TestData))]
+        public void Ctor_PropertyDescriptor_Bool(PropertyDescriptor descriptor, bool isDefault, string expectedMappingName, bool expectedReadOnly)
+        {
+            var style = new SubDataGridColumnStyle(descriptor, isDefault);
+            Assert.Equal(HorizontalAlignment.Left, style.Alignment);
+            Assert.True(style.CanRaiseEvents);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGridTableStyle);
+            Assert.False(style.DesignMode);
+            Assert.NotNull(style.Events);
+            Assert.Same(style.Events, style.Events);
+            Assert.Equal(Control.DefaultFont.Height, style.FontHeight);
+            Assert.NotNull(style.HeaderAccessibleObject);
+            Assert.Same(style.HeaderAccessibleObject, style.HeaderAccessibleObject);
+            Assert.Equal(expectedMappingName, style.HeaderText);
+            Assert.Equal(expectedMappingName, style.MappingName);
+            Assert.Same(descriptor, style.PropertyDescriptor);
+            Assert.Equal(expectedReadOnly, style.ReadOnly);
+            Assert.Null(style.Site);
+            Assert.Equal(-1, style.Width);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_DefaultProperty_Get_ReturnsExpected()
+        {
+            PropertyDescriptor property = TypeDescriptor.GetDefaultProperty(typeof(DataGridColumnStyle));
+            Assert.Equal("HeaderText", property.Name);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(HorizontalAlignment))]
+        public void Alignment_Set_GetReturnsExpected(HorizontalAlignment value)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                Alignment = value
+            };
+            Assert.Equal(value, style.Alignment);
+
+            // Set same.
+            style.Alignment = value;
+            Assert.Equal(value, style.Alignment);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_Alignment_SetWithHandler_CallsAlignmentChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.AlignmentChanged += handler;
+
+            // Set different.
+            style.Alignment = HorizontalAlignment.Center;
+            Assert.Equal(HorizontalAlignment.Center, style.Alignment);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.Alignment = HorizontalAlignment.Center;
+            Assert.Equal(HorizontalAlignment.Center, style.Alignment);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.Alignment = HorizontalAlignment.Left;
+            Assert.Equal(HorizontalAlignment.Left, style.Alignment);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.AlignmentChanged -= handler;
+            style.Alignment = HorizontalAlignment.Center;
+            Assert.Equal(HorizontalAlignment.Center, style.Alignment);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(HorizontalAlignment))]
+        public void Alignment_SetInvalid_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
+        {
+            var style = new SubDataGridColumnStyle();
+            Assert.Throws<InvalidEnumArgumentException>("value", () => style.Alignment = value);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_FontHeight_GetWithParentWithDataGrid_ReturnsExpected()
+        {
+            Font font = new Font(Control.DefaultFont.FontFamily, 15);
+            var dataGrid = new DataGrid
+            {
+                Font = font
+            };
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            Assert.Equal(font.Height, style.FontHeight);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_FontHeight_GetWithParentWithoutDataGrid_ReturnsExpected()
+        {
+            var tableStyle = new DataGridTableStyle();
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            Assert.Equal(Control.DefaultFont.Height, style.FontHeight);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void HeaderText_Set_GetReturnsExpected(string value, string expected)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                HeaderText = value
+            };
+            Assert.Equal(expected, style.HeaderText);
+
+            // Set same.
+            style.HeaderText = value;
+            Assert.Equal(expected, style.HeaderText);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void HeaderText_SetWithPropertyDescriptor_GetReturnsExpected(string value, string expected)
+        {
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataClass))[0];
+            var style = new SubDataGridColumnStyle(property)
+            {
+                HeaderText = value
+            };
+            Assert.Equal(expected, style.HeaderText);
+
+            // Set same.
+            style.HeaderText = value;
+            Assert.Equal(expected, style.HeaderText);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_HeaderText_SetWithHandler_CallsHeaderTextChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderTextChanged += handler;
+
+            // Set different.
+            style.HeaderText = "HeaderText";
+            Assert.Equal("HeaderText", style.HeaderText);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.HeaderText = "HeaderText";
+            Assert.Equal("HeaderText", style.HeaderText);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.HeaderText = "OtherHeaderText";
+            Assert.Equal("OtherHeaderText", style.HeaderText);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            style.HeaderText = null;
+            Assert.Empty(style.HeaderText);
+            Assert.Equal(3, callCount);
+
+            // Set null again.
+            style.HeaderText = null;
+            Assert.Empty(style.HeaderText);
+            Assert.Equal(3, callCount);
+
+            // Set empty.
+            style.HeaderText = string.Empty;
+            Assert.Empty(style.HeaderText);
+            Assert.Equal(3, callCount);
+
+            // Remove handler.
+            style.HeaderTextChanged -= handler;
+            style.HeaderText = "HeaderText";
+            Assert.Equal("HeaderText", style.HeaderText);
+            Assert.Equal(3, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void MappingName_Set_GetReturnsExpected(string value, string expected)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                MappingName = value
+            };
+            Assert.Equal(expected, style.MappingName);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void MappingName_SetWithDataGridView_GetReturnsExpected(string value, string expected)
+        {
+            var dataGrid = new DataGrid();
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_MappingName_SetWithHandler_CallsMappingNameChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.MappingNameChanged += handler;
+
+            // Set different.
+            style.MappingName = "MappingName";
+            Assert.Equal("MappingName", style.MappingName);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.MappingName = "MappingName";
+            Assert.Equal("MappingName", style.MappingName);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.MappingName = "OtherMappingName";
+            Assert.Equal("OtherMappingName", style.MappingName);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            style.MappingName = null;
+            Assert.Empty(style.MappingName);
+            Assert.Equal(3, callCount);
+
+            // Set null again.
+            style.MappingName = null;
+            Assert.Empty(style.MappingName);
+            Assert.Equal(3, callCount);
+
+            // Set empty.
+            style.MappingName = string.Empty;
+            Assert.Empty(style.MappingName);
+            Assert.Equal(3, callCount);
+
+            // Remove handler.
+            style.MappingNameChanged -= handler;
+            style.MappingName = "MappingName";
+            Assert.Equal("MappingName", style.MappingName);
+            Assert.Equal(3, callCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_MappingName_SetInvalid_ThrowsArgumentException()
+        {
+            var dataGrid = new DataGrid();
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+
+            var style1 = new SubDataGridColumnStyle
+            {
+                MappingName = "MappingName1"
+            };
+            var style2 = new SubDataGridColumnStyle
+            {
+                MappingName = "MappingName2"
+            };
+            tableStyle.GridColumnStyles.Add(style1);
+            tableStyle.GridColumnStyles.Add(style2);
+
+            Assert.Throws<ArgumentException>("column", () => style2.MappingName = "MappingName1");
+            Assert.Equal("MappingName2", style2.MappingName);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringWithNullTheoryData))]
+        public void NullText_Set_GetReturnsExpected(string value)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                NullText = value
+            };
+            Assert.Equal(value, style.NullText);
+
+            // Set same.
+            style.NullText = value;
+            Assert.Equal(value, style.NullText);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_NullText_SetWithHandler_CallsMappingNameChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.NullTextChanged += handler;
+
+            // Set different.
+            style.NullText = "NullText";
+            Assert.Equal("NullText", style.NullText);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.NullText = "NullText";
+            Assert.Equal("NullText", style.NullText);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.NullText = "OtherMappingName";
+            Assert.Equal("OtherMappingName", style.NullText);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            style.NullText = null;
+            Assert.Null(style.NullText);
+            Assert.Equal(3, callCount);
+
+            // Set null again.
+            style.NullText = null;
+            Assert.Null(style.NullText);
+            Assert.Equal(3, callCount);
+
+            // Remove handler.
+            style.NullTextChanged -= handler;
+            style.NullText = "NullText";
+            Assert.Equal("NullText", style.NullText);
+            Assert.Equal(3, callCount);
+        }
+
+        public static IEnumerable<object[]> PropertyDescriptor_Set_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { TypeDescriptor.GetProperties(typeof(DataClass))[0] };
+        }
+
+        [Theory]
+        [MemberData(nameof(PropertyDescriptor_Set_TestData))]
+        public void PropertyDescriptor_Set_GetReturnsExpected(PropertyDescriptor value)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                PropertyDescriptor = value
+            };
+            Assert.Same(value, style.PropertyDescriptor);
+
+            // Set same.
+            style.PropertyDescriptor = value;
+            Assert.Same(value, style.PropertyDescriptor);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_PropertyDescriptor_SetWithHandler_CallsPropertyDescriptorChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.PropertyDescriptorChanged += handler;
+
+            // Set different.
+            PropertyDescriptor descriptor1 = TypeDescriptor.GetProperties(typeof(DataClass))[0];
+            style.PropertyDescriptor = descriptor1;
+            Assert.Equal(descriptor1, style.PropertyDescriptor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.PropertyDescriptor = descriptor1;
+            Assert.Equal(descriptor1, style.PropertyDescriptor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            PropertyDescriptor descriptor2 = TypeDescriptor.GetProperties(typeof(DataClass))[1];
+            style.PropertyDescriptor = descriptor2;
+            Assert.Equal(descriptor2, style.PropertyDescriptor);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            style.PropertyDescriptor = null;
+            Assert.Null(style.PropertyDescriptor);
+            Assert.Equal(3, callCount);
+
+            // Set null again.
+            style.PropertyDescriptor = null;
+            Assert.Null(style.PropertyDescriptor);
+            Assert.Equal(3, callCount);
+
+            // Remove handler.
+            style.PropertyDescriptorChanged -= handler;
+            style.PropertyDescriptor = descriptor1;
+            Assert.Equal(descriptor1, style.PropertyDescriptor);
+            Assert.Equal(3, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void ReadOnly_Set_GetReturnsExpected(bool value)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                ReadOnly = value
+            };
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set same.
+            style.ReadOnly = value;
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set different
+            style.ReadOnly = !value;
+            Assert.Equal(!value, style.ReadOnly);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_ReadOnly_SetWithHandler_CallsMappingNameChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.ReadOnlyChanged += handler;
+
+            // Set different.
+            style.ReadOnly = true;
+            Assert.True(style.ReadOnly);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.ReadOnly = true;
+            Assert.True(style.ReadOnly);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.ReadOnly = false;
+            Assert.False(style.ReadOnly);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.ReadOnlyChanged -= handler;
+            style.ReadOnly = true;
+            Assert.True(style.ReadOnly);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void Width_Set_GetReturnsExpected(int value)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                Width = value
+            };
+            Assert.Equal(value, style.Width);
+
+            // Set same.
+            style.Width = value;
+            Assert.Equal(value, style.Width);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void Width_SetWithTableStyleWithDataGrid_GetReturnsExpected(int value)
+        {
+            var dataGrid = new DataGrid();
+            int callCount = 0;
+            dataGrid.Layout += (sender, e) => callCount++;
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+
+            style.Width = value;
+            Assert.Equal(value, style.Width);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.Width = value;
+            Assert.Equal(value, style.Width);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void Width_SetWithTableStyleWithoutDataGrid_GetReturnsExpected(int value)
+        {
+            var tableStyle = new DataGridTableStyle();
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+
+            style.Width = value;
+            Assert.Equal(value, style.Width);
+
+            // Set same.
+            style.Width = value;
+            Assert.Equal(value, style.Width);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_Width_SetWithHandler_CallsWidthChanged()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.WidthChanged += handler;
+
+            // Set different.
+            style.Width = 2;
+            Assert.Equal(2, style.Width);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.Width = 2;
+            Assert.Equal(2, style.Width);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.Width = 3;
+            Assert.Equal(3, style.Width);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.WidthChanged -= handler;
+            style.Width = 2;
+            Assert.Equal(2, style.Width);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_FontChanged_Add_Remove_Success()
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) => callCount++;
+
+            style.FontChanged += handler;
+            style.FontChanged -= handler;
+            Assert.Equal(0, callCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_BeginUpdate_EndUpdate_DoesNotCallInvalidate()
+        {
+            var style = new InvalidateDataGridColumnStyle();
+            style.BeginUpdate();
+            style.EndUpdate();
+            Assert.Equal(0, style.InvalidateCallCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_BeginUpdate_SeveralTimes_DoesNotCallInvalidate()
+        {
+            var style = new InvalidateDataGridColumnStyle();
+            style.BeginUpdate();
+            style.BeginUpdate();
+            Assert.Equal(0, style.InvalidateCallCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_CheckValidDataSource_HasPropertyDescriptor_Nop()
+        {
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataClass))[0];
+            var style = new SubDataGridColumnStyle(property);
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager value = Assert.IsType<CurrencyManager>(context[dataSource]);
+            style.CheckValidDataSource(value);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_CheckValidDataSource_NullValue_ThrowsArgumentNullException()
+        {
+            var style = new SubDataGridColumnStyle();
+            Assert.Throws<ArgumentNullException>("value", () => style.CheckValidDataSource(null));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_CheckValidDataSource_NoPropertyDescriptor_ThrowsInvalidOperationException()
+        {
+            var style = new SubDataGridColumnStyle();
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager value = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<InvalidOperationException>(() => style.CheckValidDataSource(value));
+        }
+
+        public static IEnumerable<object[]> ColumnStartedEditing_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { new Control() };
+        }
+
+        [Theory]
+        [MemberData(nameof(ColumnStartedEditing_TestData))]
+        public void ColumnStartedEditing_WithTableStyleWithDataGridWithoutRows_Nop(Control editingControl)
+        {
+            var dataGrid = new DataGrid();
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            style.ColumnStartedEditing(editingControl);
+        }
+
+        [Theory]
+        [MemberData(nameof(ColumnStartedEditing_TestData))]
+        public void ColumnStartedEditing_WithTableStyle_Nop(Control editingControl)
+        {
+            var tableStyle = new DataGridTableStyle();
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            style.ColumnStartedEditing(editingControl);
+        }
+
+        [Theory]
+        [MemberData(nameof(ColumnStartedEditing_TestData))]
+        public void ColumnStartedEditing_NoTableStyle_Nop(Control editingControl)
+        {
+            var style = new SubDataGridColumnStyle();
+            style.ColumnStartedEditing(editingControl);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_ConcedeFocus_InvokeSeveralTimes_Nop()
+        {
+            var style = new SubDataGridColumnStyle();
+            style.ConcedeFocus();
+            style.ConcedeFocus();
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_CreateHeaderAccessibleObject_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridColumnStyle();
+            AccessibleObject accessibleObject = style.CreateHeaderAccessibleObject();
+            Assert.NotNull(accessibleObject);
+            Assert.NotSame(accessibleObject, style.CreateHeaderAccessibleObject());
+        }
+
+        public static IEnumerable<object[]> Edit_CurrencyManagerIntRectangleBool_TestData()
+        {
+            yield return new object[] { null, -2, Rectangle.Empty, false };
+
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            yield return new object[] { context[dataSource], -1, new Rectangle(1, 2, 3, 4), true };
+            yield return new object[] { context[dataSource], 1, new Rectangle(-1, -2, -3, -4), true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Edit_CurrencyManagerIntRectangleBool_TestData))]
+        public void Edit_InvokeCurrencyManagerIntRectangleBool_Success(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly)
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            style.EditAction = (actualSource, actualRowNum, actualBounds, actualReadOnly, actualDisplayText, actualCellIsVisible) =>
+            {
+                Assert.Same(source, actualSource);
+                Assert.Equal(rowNum, actualRowNum);
+                Assert.Equal(bounds, actualBounds);
+                Assert.Equal(readOnly, actualReadOnly);
+                Assert.Null(actualDisplayText);
+                Assert.True(actualCellIsVisible);
+                callCount++;
+            };
+            style.Edit(source, rowNum, bounds, readOnly);
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> Edit_CurrencyManagerIntRectangleBoolString_TestData()
+        {
+            yield return new object[] { null, -2, Rectangle.Empty, false, null };
+
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            yield return new object[] { context[dataSource], -1, new Rectangle(1, 2, 3, 4), true, string.Empty };
+            yield return new object[] { context[dataSource], 1, new Rectangle(-1, -2, -3, -4), true, "displayText" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Edit_CurrencyManagerIntRectangleBoolString_TestData))]
+        public void Edit_InvokeCurrencyManagerIntRectangleBoolString_Success(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText)
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            style.EditAction = (actualSource, actualRowNum, actualBounds, actualReadOnly, actualDisplayText, actualCellIsVisible) =>
+            {
+                Assert.Same(source, actualSource);
+                Assert.Equal(rowNum, actualRowNum);
+                Assert.Equal(bounds, actualBounds);
+                Assert.Equal(readOnly, actualReadOnly);
+                Assert.Same(displayText, actualDisplayText);
+                Assert.True(actualCellIsVisible);
+                callCount++;
+            };
+            style.Edit(source, rowNum, bounds, readOnly, displayText);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_EndUpdate_BeganUpdateInvalidated_DoesNotCallInvalidate()
+        {
+            var style = new InvalidateDataGridColumnStyle();
+            style.BeginUpdate();
+            Assert.Equal(0, style.InvalidateCallCount);
+
+            style.CallInvalidate();
+            Assert.Equal(1, style.InvalidateCallCount);
+
+            style.EndUpdate();
+            Assert.Equal(2, style.InvalidateCallCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_EndUpdate_NotCalledBeganUpdate_DoesNotCallInvalidate()
+        {
+            var style = new InvalidateDataGridColumnStyle();
+            style.EndUpdate();
+            Assert.Equal(0, style.InvalidateCallCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_EndUpdate_SeveralTimes_DoesNotCallInvalidate()
+        {
+            var style = new InvalidateDataGridColumnStyle();
+            style.BeginUpdate();
+            style.EndUpdate();
+            style.EndUpdate();
+            Assert.Equal(0, style.InvalidateCallCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_EnterNullValue_InvokeSeveralTimes_Nop()
+        {
+            var style = new SubDataGridColumnStyle();
+            style.EnterNullValue();
+            style.EnterNullValue();
+        }
+
+        [Theory]
+        [InlineData(0, 1)]
+        [InlineData(1, 2)]
+        [InlineData(2, 3)]
+        public void GetColumnValueAtRow_PropertyDescriptor_ReturnsExpected(int rowNum, int expected)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Equal(expected, style.GetColumnValueAtRow(source, rowNum));
+        }
+
+        [Theory]
+        [InlineData(0, 1)]
+        [InlineData(1, 2)]
+        [InlineData(2, 3)]
+        public void GetColumnValueAtRow_PropertyDescriptorCalledTwice_ReturnsExpected(int rowNum, int expected)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new NullPropertyDescriptorDataGridColumnStyle(descriptor, 2);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Equal(expected, style.GetColumnValueAtRow(source, rowNum));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_GetColumnValueAtRow_NullSource_ThrowsArgumentNullException()
+        {
+            var style = new SubDataGridColumnStyle();
+            Assert.Throws<ArgumentNullException>("value", () => style.GetColumnValueAtRow(null, 0));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_GetColumnValueAtRow_NoPropertyDescriptor_ThrowsInvalidOperationException()
+        {
+            var style = new SubDataGridColumnStyle();
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<InvalidOperationException>(() => style.GetColumnValueAtRow(source, 0));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_GetColumnValueAtRow_NoPropertyDescriptorNoValidation_ThrowsInvalidOperationException()
+        {
+            var style = new NullPropertyDescriptorDataGridColumnStyle(1);
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<InvalidOperationException>(() => style.GetColumnValueAtRow(source, 0));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(3)]
+        public void GetColumnValueAtRow_InvalidIndex_ThrowsIndexOutOfRangeException(int rowNum)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<IndexOutOfRangeException>((() => style.GetColumnValueAtRow(source, rowNum)));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_Invalidate_InvokeSeveralTimesWithTableStyleWithDataGrid_Nop()
+        {
+            var dataGrid = new DataGrid();
+            var tableStyle = new DataGridTableStyle();
+            dataGrid.TableStyles.Add(tableStyle);
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            style.Invalidate();
+            style.Invalidate();
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_Invalidate_InvokeSeveralTimesWithTableStyle_Nop()
+        {
+            var tableStyle = new DataGridTableStyle();
+            var style = new SubDataGridColumnStyle();
+            tableStyle.GridColumnStyles.Add(style);
+            style.Invalidate();
+            style.Invalidate();
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_Invalidate_InvokeSeveralTimes_Nop()
+        {
+            var style = new SubDataGridColumnStyle();
+            style.Invalidate();
+            style.Invalidate();
+        }
+
+        public static IEnumerable<object[]> Paint_TestData()
+        {
+            yield return new object[] { null, Rectangle.Empty, null, -2, null, null, false };
+
+            var image = new Bitmap(10, 10);
+            var style = new SubDataGridColumnStyle();
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            yield return new object[] { Graphics.FromImage(image), new Rectangle(1, 2, 3, 4), source, -1, new SolidBrush(Color.Red), new SolidBrush(Color.Blue), true };
+            yield return new object[] { Graphics.FromImage(image), new Rectangle(-1, -2, -3, -4), source, 1, new SolidBrush(Color.Red), new SolidBrush(Color.Blue), false };
+        }
+
+        [Theory]
+        [MemberData(nameof(Paint_TestData))]
+        public void Paint_Invoke_Success(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, Brush backBrush, Brush foreBrush, bool alignToRight)
+        {
+            var style = new SubDataGridColumnStyle();
+            int callCount = 0;
+            style.PaintAction = (actualG, actualBounds, actualSource, actualRowNum, actualAlignToRight) =>
+            {
+                Assert.Same(g, actualG);
+                Assert.Same(source, actualSource);
+                Assert.Equal(bounds, actualBounds);
+                Assert.Equal(rowNum, actualRowNum);
+                Assert.Equal(alignToRight, actualAlignToRight);
+                callCount++;
+            };
+            style.Paint(g, bounds, source, rowNum, backBrush, foreBrush, alignToRight);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_ReleaseHostedControl_InvokeSeveralTimes_Nop()
+        {
+            var style = new SubDataGridColumnStyle();
+            style.ReleaseHostedControl();
+            style.ReleaseHostedControl();
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_ResetHeaderText_Invoke_Success()
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                HeaderText = "HeaderText"
+            };
+            style.ResetHeaderText();
+            Assert.Empty(style.HeaderText);
+
+            // Reset again.
+            style.ResetHeaderText();
+            Assert.Empty(style.HeaderText);
+        }
+
+        [Theory]
+        [InlineData(0, 2)]
+        [InlineData(1, 3)]
+        [InlineData(2, 4)]
+        public void SetColumnValueAtRow_PropertyDescriptor_ReturnsExpected(int rowNum, int value)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            source.Position = rowNum;
+
+            style.SetColumnValueAtRow(source, rowNum, value);
+            Assert.Equal(value, style.GetColumnValueAtRow(source, rowNum));
+            Assert.Equal(value, dataSource[rowNum].Value1);
+        }
+
+        [Theory]
+        [InlineData(0, 2)]
+        [InlineData(1, 3)]
+        [InlineData(2, 4)]
+        public void SetColumnValueAtRow_IEditablePropertyDescriptor_ReturnsExpected(int rowNum, int value)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(EditableDataClass)).Find(nameof(EditableDataClass.Value), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor);
+            var context = new BindingContext();
+            var dataSource = new List<EditableDataClass> { new() { Value = 1 }, new() { Value = 2 }, new() { Value = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            source.Position = rowNum;
+            Assert.Equal(1, dataSource[rowNum].BeginEditCallCount);
+
+            style.SetColumnValueAtRow(source, rowNum, value);
+            Assert.Equal(value, style.GetColumnValueAtRow(source, rowNum));
+            Assert.Equal(value, dataSource[rowNum].Value);
+            Assert.Equal(2, dataSource[rowNum].BeginEditCallCount);
+        }
+
+        [Theory]
+        [InlineData(0, 2)]
+        [InlineData(1, 3)]
+        [InlineData(2, 4)]
+        public void SetColumnValueAtRow_PropertyDescriptorCalledTwice_ReturnsExpected(int rowNum, int value)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new NullPropertyDescriptorDataGridColumnStyle(descriptor, 2);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            source.Position = rowNum;
+
+            style.SetColumnValueAtRow(source, rowNum, value);
+            style.RequiredCallCount = int.MaxValue;
+            Assert.Equal(value, style.GetColumnValueAtRow(source, rowNum));
+            Assert.Equal(value, dataSource[rowNum].Value1);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_SetColumnValueAtRow_NullSource_ThrowsArgumentNullException()
+        {
+            var style = new SubDataGridColumnStyle();
+            Assert.Throws<ArgumentNullException>("value", () => style.SetColumnValueAtRow(null, 0, 1));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_SetColumnValueAtRow_NoPropertyDescriptor_ThrowsInvalidOperationException()
+        {
+            var style = new SubDataGridColumnStyle();
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<InvalidOperationException>(() => style.SetColumnValueAtRow(source, 0, 1));
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_SetColumnValueAtRow_NoPropertyDescriptorNoValidation_ThrowsInvalidOperationException()
+        {
+            var style = new NullPropertyDescriptorDataGridColumnStyle(1);
+            var context = new BindingContext();
+            var dataSource = new List<int> { 1, 2, 3 };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<InvalidOperationException>(() => style.SetColumnValueAtRow(source, 0, new object()));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        public void SetColumnValueAtRow_InvalidIndex_ThrowsArgumentException(int rowNum)
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor);
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            Assert.Throws<ArgumentException>("rowNum", () => style.SetColumnValueAtRow(source, rowNum, 1));
+        }
+
+        public static IEnumerable<object[]> DataGrid_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { new DataGrid() };
+        }
+
+        [Theory]
+        [MemberData(nameof(DataGrid_TestData))]
+        public void SetDataGrid_Invoke_CallsSetDataGridInColumn(DataGrid value)
+        {
+            var style = new SetDataGridInColumnDataGridColumnStyle();
+            int callCount = 0;
+            style.SetDataGridInColumnAction = actualValue =>
+            {
+                Assert.Same(value, actualValue);
+                callCount++;
+            };
+            style.SetDataGrid(value);
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> SetDataGridInColumn_TestData()
+        {
+            yield return new object[] { null, null, null };
+
+            var dataGridWithoutListManager = new DataGrid();
+            Assert.Null(dataGridWithoutListManager.ListManager);
+            yield return new object[] { null, dataGridWithoutListManager, null };
+
+            var dataGrid = new DataGrid
+            {
+                BindingContext = new BindingContext(),
+                DataSource = new List<DataClass> { new() { Value1 = 1 } }
+            };
+            Assert.NotNull(dataGrid.ListManager);
+            yield return new object[] { null, dataGrid, null };
+            yield return new object[] { string.Empty, dataGrid, null };
+            yield return new object[] { "NoSuchProperty", dataGrid, null };
+            yield return new object[] { nameof(DataClass.ListProperty), dataGrid, null };
+            yield return new object[] { nameof(DataClass.Value1).ToLower(), dataGrid, null };
+            yield return new object[] { nameof(DataClass.Value1), dataGrid, TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SetDataGridInColumn_TestData))]
+        public void SetDataGridInColumn_DataGridWithoutListManager_Nop(string headerText, DataGrid value, object expectedPropertyDescriptor)
+        {
+            var style = new SubDataGridColumnStyle
+            {
+                HeaderText = headerText
+            };
+            style.SetDataGrid(value);
+            Assert.Equal(expectedPropertyDescriptor, style.PropertyDescriptor);
+        }
+
+        [Fact]
+        public void DataGridColumnStyle_SetDataGridInColumn_HasPropertyDescriptor_Nop()
+        {
+            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+            var style = new SubDataGridColumnStyle(descriptor)
+            {
+                HeaderText = nameof(DataClass.Value2)
+            };
+            var dataGrid = new DataGrid
+            {
+                BindingContext = new BindingContext(),
+                DataSource = new List<DataClass> { new() { Value1 = 1 } }
+            };
+            Assert.NotNull(dataGrid.ListManager);
+            style.SetDataGridInColumn(dataGrid);
+            Assert.Same(descriptor, style.PropertyDescriptor);
+        }
+
+        public static IEnumerable<object[]> UpdateUI_TestData()
+        {
+            yield return new object[] { null, -2, null };
+
+            var style = new SubDataGridColumnStyle();
+            var context = new BindingContext();
+            var dataSource = new List<DataClass> { new() { Value1 = 1 }, new() { Value1 = 2 }, new() { Value1 = 3 } };
+            CurrencyManager source = Assert.IsType<CurrencyManager>(context[dataSource]);
+            yield return new object[] { source, -1, string.Empty };
+            yield return new object[] { source, 1, "displayText" };
+        }
+
+        [Theory]
+        [MemberData(nameof(UpdateUI_TestData))]
+        public void UpdateUI_Invoke_Nop(CurrencyManager source, int rowNum, string displayText)
+        {
+            var style = new SubDataGridColumnStyle();
+            style.UpdateUI(source, rowNum, displayText);
+        }
+
+        private class DataClass
+        {
+            public int Value1 { get; set; }
+            public int Value2 { get; set; }
+
+            public IList ListProperty { get; set; }
+        }
+
+        private class EditableDataClass : IEditableObject
+        {
+            public int BeginEditCallCount { get; set; }
+
+            public void BeginEdit() => BeginEditCallCount++;
+
+            public void CancelEdit() => throw new NotImplementedException();
+
+            public void EndEdit() { }
+
+            public int Value { get; set; }
+        }
+
+        private class ReadOnlyDataClass
+        {
+            public int Value1 { get; }
+        }
+
+        private abstract class CustomDataGridColumnStyle : DataGridColumnStyle
+        {
+            protected CustomDataGridColumnStyle()
+            {
+            }
+
+            protected CustomDataGridColumnStyle(PropertyDescriptor prop) : base(prop)
+            {
+            }
+
+            protected CustomDataGridColumnStyle(PropertyDescriptor prop, bool isDefault) : base(prop, isDefault)
+            {
+            }
+
+            protected internal override void Abort(int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override Size GetPreferredSize(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetMinimumHeight()
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetPreferredHeight(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        private class SubDataGridColumnStyle : CustomDataGridColumnStyle
+        {
+            public SubDataGridColumnStyle()
+            {
+            }
+
+            public SubDataGridColumnStyle(PropertyDescriptor prop) : base(prop)
+            {
+            }
+
+            public SubDataGridColumnStyle(PropertyDescriptor prop, bool isDefault) : base(prop, isDefault)
+            {
+            }
+
+            public new bool CanRaiseEvents => base.CanRaiseEvents;
+
+            public new bool DesignMode => base.DesignMode;
+
+            public new EventHandlerList Events => base.Events;
+
+            public new int FontHeight => base.FontHeight;
+
+            public new void BeginUpdate() => base.BeginUpdate();
+
+            public new void CheckValidDataSource(CurrencyManager value) => base.CheckValidDataSource(value);
+
+            public new AccessibleObject CreateHeaderAccessibleObject() => base.CreateHeaderAccessibleObject();
+
+            public new void EndUpdate() => base.EndUpdate();
+
+            public new void Invalidate() => base.Invalidate();
+
+            public new void SetDataGrid(DataGrid value) => base.SetDataGrid(value);
+
+            public new void SetDataGridInColumn(DataGrid value) => base.SetDataGridInColumn(value);
+
+            public Action<CurrencyManager, int, Rectangle, bool, string, bool> EditAction { get; set; }
+
+            protected internal override void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible)
+            {
+                EditAction(source, rowNum, bounds, readOnly, displayText, cellIsVisible);
+            }
+
+            public Action<Graphics, Rectangle, CurrencyManager, int, bool> PaintAction { get; set; }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+            {
+                PaintAction(g, bounds, source, rowNum, alignToRight);
+            }
+        }
+
+        private class NullPropertyDescriptorDataGridColumnStyle : CustomDataGridColumnStyle
+        {
+            public NullPropertyDescriptorDataGridColumnStyle(int requiredCallCount)
+            {
+                RequiredCallCount = requiredCallCount;
+            }
+
+            public NullPropertyDescriptorDataGridColumnStyle(PropertyDescriptor prop, int requiredCallCount) : base(prop)
+            {
+                RequiredCallCount = requiredCallCount;
+            }
+
+            public int RequiredCallCount { get; set; }
+
+            private int _callCount = 0;
+
+            public override PropertyDescriptor PropertyDescriptor
+            {
+                get
+                {
+                    if (_callCount < RequiredCallCount)
+                    {
+                        _callCount++;
+                        return TypeDescriptor.GetProperties(typeof(DataClass)).Find(nameof(DataClass.Value1), ignoreCase: false);
+                    }
+
+                    return null;
+                }
+                set { }
+            }
+        }
+
+        private class InvalidateDataGridColumnStyle : CustomDataGridColumnStyle
+        {
+            public new void BeginUpdate() => base.BeginUpdate();
+
+            public new void EndUpdate() => base.EndUpdate();
+
+            public void CallInvalidate() => Invalidate();
+
+            public int InvalidateCallCount { get; set; }
+
+            protected override void Invalidate()
+            {
+                InvalidateCallCount++;
+                base.Invalidate();
+            }
+        }
+
+        private class SetDataGridInColumnDataGridColumnStyle : CustomDataGridColumnStyle
+        {
+            public new void SetDataGrid(DataGrid value) => base.SetDataGrid(value);
+
+            public Action<DataGrid> SetDataGridInColumnAction { get; set; }
+
+            protected override void SetDataGridInColumn(DataGrid value)
+            {
+                SetDataGridInColumnAction(value);
+            }
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/DataGridTableStyleTests.cs b/WTG.System.Windows.Forms.Tests/DataGridTableStyleTests.cs
new file mode 100644
index 00000000000..96104fa9311
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/DataGridTableStyleTests.cs
@@ -0,0 +1,4874 @@
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class DataGridTableStyleTests
+    {
+        [Fact]
+        public void DataGridTableStyle_Ctor_Default()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.True(style.AllowSorting);
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.True(style.CanRaiseEvents);
+            Assert.True(style.ColumnHeadersVisible);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGrid);
+            Assert.False(style.DesignMode);
+            Assert.NotNull(style.Events);
+            Assert.Same(style.Events, style.Events);
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Empty(style.GridColumnStyles);
+            Assert.Same(style.GridColumnStyles, style.GridColumnStyles);
+            Assert.Equal(SystemColors.Control, style.GridLineColor);
+            Assert.Equal(DataGridLineStyle.Solid, style.GridLineStyle);
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Empty(style.MappingName);
+            Assert.Equal(75, style.PreferredColumnWidth);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.False(style.ReadOnly);
+            Assert.True(style.RowHeadersVisible);
+            Assert.Equal(35, style.RowHeaderWidth);
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Null(style.Site);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_Ctor_Bool(bool isDefaultTableStyle)
+        {
+            var style = new SubDataGridTableStyle(isDefaultTableStyle);
+            Assert.True(style.AllowSorting);
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.True(style.CanRaiseEvents);
+            Assert.True(style.ColumnHeadersVisible);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGrid);
+            Assert.False(style.DesignMode);
+            Assert.NotNull(style.Events);
+            Assert.Same(style.Events, style.Events);
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Empty(style.GridColumnStyles);
+            Assert.Same(style.GridColumnStyles, style.GridColumnStyles);
+            Assert.Equal(SystemColors.Control, style.GridLineColor);
+            Assert.Equal(DataGridLineStyle.Solid, style.GridLineStyle);
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Empty(style.MappingName);
+            Assert.Equal(75, style.PreferredColumnWidth);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.False(style.ReadOnly);
+            Assert.True(style.RowHeadersVisible);
+            Assert.Equal(35, style.RowHeaderWidth);
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Null(style.Site);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_DefaultTableStyle_Get_ReturnsExpected()
+        {
+            DataGridTableStyle style = DataGridTableStyle.DefaultTableStyle;
+            Assert.True(style.AllowSorting);
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.True(style.ColumnHeadersVisible);
+            Assert.Null(style.Container);
+            Assert.Null(style.DataGrid);
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Empty(style.GridColumnStyles);
+            Assert.Same(style.GridColumnStyles, style.GridColumnStyles);
+            Assert.Equal(SystemColors.Control, style.GridLineColor);
+            Assert.Equal(DataGridLineStyle.Solid, style.GridLineStyle);
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Empty(style.MappingName);
+            Assert.Equal(75, style.PreferredColumnWidth);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.False(style.ReadOnly);
+            Assert.True(style.RowHeadersVisible);
+            Assert.Equal(35, style.RowHeaderWidth);
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Null(style.Site);
+            Assert.Same(style, DataGridTableStyle.DefaultTableStyle);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_AllowSorting_Set_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle
+            {
+                AllowSorting = value
+            };
+            Assert.Equal(value, style.AllowSorting);
+
+            // Set same.
+            style.AllowSorting = value;
+            Assert.Equal(value, style.AllowSorting);
+
+            // Set different
+            style.AllowSorting = !value;
+            Assert.Equal(!value, style.AllowSorting);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_AllowSorting_SetWithDataGrid_DoesNotCallInvalidate(bool value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.AllowSorting = value;
+            Assert.Equal(value, style.AllowSorting);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.AllowSorting = value;
+            Assert.Equal(value, style.AllowSorting);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different
+            style.AllowSorting = !value;
+            Assert.Equal(!value, style.AllowSorting);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_AllowSorting_SetWithHandler_CallsAllowSortingChanged()
+        {
+            var style = new DataGridTableStyle
+            {
+                AllowSorting = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.AllowSortingChanged += handler;
+
+            // Set different.
+            style.AllowSorting = false;
+            Assert.False(style.AllowSorting);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.AllowSorting = false;
+            Assert.False(style.AllowSorting);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.AllowSorting = true;
+            Assert.True(style.AllowSorting);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.AllowSortingChanged -= handler;
+            style.AllowSorting = false;
+            Assert.False(style.AllowSorting);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_AlternatingBackColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                AlternatingBackColor = value
+            };
+            Assert.Equal(value, style.AlternatingBackColor);
+
+            // Set same.
+            style.AlternatingBackColor = value;
+            Assert.Equal(value, style.AlternatingBackColor);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_AlternatingBackColor_SetWithDataGrid_CallsInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.AlternatingBackColor = value;
+            Assert.Equal(value, style.AlternatingBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+
+            // Set same.
+            style.AlternatingBackColor = value;
+            Assert.Equal(value, style.AlternatingBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_AlternatingBackColor_SetWithHandler_CallsAlternatingBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.AlternatingBackColorChanged += handler;
+
+            // Set different.
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.AlternatingBackColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.AlternatingBackColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.AlternatingBackColorChanged -= handler;
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        public static IEnumerable<object[]> InvalidColor_TestData()
+        {
+            yield return new object[] { Color.Empty };
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidColor_TestData))]
+        public void DataGridTableStyle_AlternatingBackColor_SetInvalid_ThrowsArgumentException(Color value)
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.AlternatingBackColor = value);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_BackColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                BackColor = value
+            };
+            Assert.Equal(value, style.BackColor);
+
+            // Set same.
+            style.BackColor = value;
+            Assert.Equal(value, style.BackColor);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_BackColor_SetWithDataGrid_CallsInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.BackColor = value;
+            Assert.Equal(value, style.BackColor);
+            Assert.Equal(1, invalidatedCallCount);
+
+            // Set same.
+            style.BackColor = value;
+            Assert.Equal(value, style.BackColor);
+            Assert.Equal(1, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_BackColor_SetWithHandler_CallsBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.BackColorChanged += handler;
+
+            // Set different.
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.BackColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.BackColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.BackColorChanged -= handler;
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidColor_TestData))]
+        public void DataGridTableStyle_BackColor_SetInvalid_ThrowsArgumentException(Color value)
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.BackColor = value);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ColumnHeadersVisible_Set_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle
+            {
+                ColumnHeadersVisible = value
+            };
+            Assert.Equal(value, style.ColumnHeadersVisible);
+
+            // Set same.
+            style.ColumnHeadersVisible = value;
+            Assert.Equal(value, style.ColumnHeadersVisible);
+
+            // Set different
+            style.ColumnHeadersVisible = !value;
+            Assert.Equal(!value, style.ColumnHeadersVisible);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ColumnHeadersVisible_SetDefaultTableStyle_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle(isDefaultTableStyle: true)
+            {
+                ColumnHeadersVisible = value
+            };
+            Assert.Equal(value, style.ColumnHeadersVisible);
+
+            // Set same.
+            style.ColumnHeadersVisible = value;
+            Assert.Equal(value, style.ColumnHeadersVisible);
+
+            // Set different
+            style.ColumnHeadersVisible = !value;
+            Assert.Equal(!value, style.ColumnHeadersVisible);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ColumnHeadersVisible_SetWithDataGrid_DoesNotCallInvalidate(bool value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.ColumnHeadersVisible = value;
+            Assert.Equal(value, style.ColumnHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.ColumnHeadersVisible = value;
+            Assert.Equal(value, style.ColumnHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different
+            style.ColumnHeadersVisible = !value;
+            Assert.Equal(!value, style.ColumnHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ColumnHeadersVisible_SetWithHandler_CallsColumnHeadersVisibleChanged()
+        {
+            var style = new DataGridTableStyle
+            {
+                ColumnHeadersVisible = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.ColumnHeadersVisibleChanged += handler;
+
+            // Set different.
+            style.ColumnHeadersVisible = false;
+            Assert.False(style.ColumnHeadersVisible);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.ColumnHeadersVisible = false;
+            Assert.False(style.ColumnHeadersVisible);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.ColumnHeadersVisible = true;
+            Assert.True(style.ColumnHeadersVisible);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.ColumnHeadersVisibleChanged -= handler;
+            style.ColumnHeadersVisible = false;
+            Assert.False(style.ColumnHeadersVisible);
+            Assert.Equal(2, callCount);
+        }
+
+        public static IEnumerable<object[]> DataGrid_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { new DataGrid() };
+        }
+
+        [Theory]
+        [MemberData(nameof(DataGrid_TestData))]
+        public void DataGridTableStyle_DataGrid_Set_GetReturnsExpected(DataGrid value)
+        {
+            var style = new DataGridTableStyle
+            {
+                DataGrid = value
+            };
+            Assert.Same(value, style.DataGrid);
+            Assert.Same(value?.Font ?? Control.DefaultFont, style.HeaderFont);
+
+            // Set same.
+            style.DataGrid = value;
+            Assert.Same(value, style.DataGrid);
+            Assert.Same(value?.Font ?? Control.DefaultFont, style.HeaderFont);
+        }
+
+        [Theory]
+        [MemberData(nameof(DataGrid_TestData))]
+        public void DataGridTableStyle_DataGrid_SetDefaultTableStyle_GetReturnsExpected(DataGrid value)
+        {
+            var style = new DataGridTableStyle(isDefaultTableStyle: true)
+            {
+                DataGrid = value
+            };
+            Assert.Same(value, style.DataGrid);
+            Assert.Same(value?.Font ?? Control.DefaultFont, style.HeaderFont);
+
+            // Set same.
+            style.DataGrid = value;
+            Assert.Same(value, style.DataGrid);
+            Assert.Same(value?.Font ?? Control.DefaultFont, style.HeaderFont);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_DataGrid_SetWithGridColumnStyles_SetsDataGridOnGridColumnStyles()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle();
+            var columnStyle = new SubDataGridColumnStyle();
+            int callCount = 0;
+            columnStyle.SetDataGridInColumnAction = actualDataGrid =>
+            {
+                Assert.Same(dataGrid, actualDataGrid);
+                callCount++;
+            };
+            style.GridColumnStyles.Add(columnStyle);
+
+            style.DataGrid = dataGrid;
+            Assert.Same(dataGrid, style.DataGrid);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.DataGrid = dataGrid;
+            Assert.Same(dataGrid, style.DataGrid);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            style.DataGrid = null;
+            Assert.Null(style.DataGrid);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_DataGrid_SetWithGridColumnStylesInitializing_DoesNotSetDataGridOnGridColumnStyles()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle();
+            var columnStyle = new SubDataGridColumnStyle();
+            int callCount = 0;
+            columnStyle.SetDataGridInColumnAction = actualDataGrid =>
+            {
+                Assert.Same(dataGrid, actualDataGrid);
+                callCount++;
+            };
+            style.GridColumnStyles.Add(columnStyle);
+            dataGrid.BeginInit();
+
+            style.DataGrid = dataGrid;
+            Assert.Same(dataGrid, style.DataGrid);
+            Assert.Equal(0, callCount);
+
+            // Set same.
+            style.DataGrid = dataGrid;
+            Assert.Same(dataGrid, style.DataGrid);
+            Assert.Equal(0, callCount);
+
+            // Set null.
+            style.DataGrid = null;
+            Assert.Null(style.DataGrid);
+            Assert.Equal(0, callCount);
+        }
+
+        public static IEnumerable<object[]> ForeColor_Set_TestData()
+        {
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+            yield return new object[] { Color.Red };
+        }
+
+        [Theory]
+        [MemberData(nameof(ForeColor_Set_TestData))]
+        public void DataGridTableStyle_ForeColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                ForeColor = value
+            };
+            Assert.Equal(value, style.ForeColor);
+
+            // Set same.
+            style.ForeColor = value;
+            Assert.Equal(value, style.ForeColor);
+        }
+
+        [Theory]
+        [MemberData(nameof(ForeColor_Set_TestData))]
+        public void DataGridTableStyle_ForeColor_SetWithDataGrid_CallsInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.ForeColor = value;
+            Assert.Equal(value, style.ForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+
+            // Set same.
+            style.ForeColor = value;
+            Assert.Equal(value, style.ForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ForeColor_SetWithHandler_CallsForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.ForeColorChanged += handler;
+
+            // Set different.
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.ForeColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.ForeColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.ForeColorChanged -= handler;
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ForeColor_SetEmpty_ThrowsArgumentException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.ForeColor = Color.Empty);
+        }
+
+        public static IEnumerable<object[]> GridLineColor_Set_TestData()
+        {
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+            yield return new object[] { Color.Red };
+        }
+
+        [Theory]
+        [MemberData(nameof(GridLineColor_Set_TestData))]
+        public void DataGridTableStyle_GridLineColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                GridLineColor = value
+            };
+            Assert.Equal(value, style.GridLineColor);
+
+            // Set same.
+            style.GridLineColor = value;
+            Assert.Equal(value, style.GridLineColor);
+        }
+
+        [Theory]
+        [MemberData(nameof(GridLineColor_Set_TestData))]
+        public void DataGridTableStyle_GridLineColor_SetWithDataGrid_DoesNotCallInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.GridLineColor = value;
+            Assert.Equal(value, style.GridLineColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.GridLineColor = value;
+            Assert.Equal(value, style.GridLineColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_GridLineColor_SetWithHandler_CallsGridLineColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.GridLineColorChanged += handler;
+
+            // Set different.
+            style.GridLineColor = Color.Red;
+            Assert.Equal(Color.Red, style.GridLineColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.GridLineColor = Color.Red;
+            Assert.Equal(Color.Red, style.GridLineColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.GridLineColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.GridLineColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.GridLineColorChanged -= handler;
+            style.GridLineColor = Color.Red;
+            Assert.Equal(Color.Red, style.GridLineColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_GridLineColor_SetEmpty_ThrowsArgumentException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.GridLineColor = Color.Empty);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(DataGridLineStyle))]
+        public void DataGridTableStyle_GridLineStyle_Set_GetReturnsExpected(DataGridLineStyle value)
+        {
+            var style = new DataGridTableStyle
+            {
+                GridLineStyle = value
+            };
+            Assert.Equal(value, style.GridLineStyle);
+
+            // Set same.
+            style.GridLineStyle = value;
+            Assert.Equal(value, style.GridLineStyle);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(DataGridLineStyle))]
+        public void DataGridTableStyle_GridLineStyle_SetWithDataGrid_DoesNotCallInvalidate(DataGridLineStyle value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.GridLineStyle = value;
+            Assert.Equal(value, style.GridLineStyle);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.GridLineStyle = value;
+            Assert.Equal(value, style.GridLineStyle);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(DataGridLineStyle))]
+        public void DataGridTableStyle_GridLineStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(DataGridLineStyle value)
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<InvalidEnumArgumentException>("value", () => style.GridLineStyle = value);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_HeaderBackColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                HeaderBackColor = value
+            };
+            Assert.Equal(value, style.HeaderBackColor);
+
+            // Set same.
+            style.HeaderBackColor = value;
+            Assert.Equal(value, style.HeaderBackColor);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_HeaderBackColor_SetWithDataGrid_DoesNotCallInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.HeaderBackColor = value;
+            Assert.Equal(value, style.HeaderBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.HeaderBackColor = value;
+            Assert.Equal(value, style.HeaderBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderBackColor_SetWithHandler_CallsHeaderBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderBackColorChanged += handler;
+
+            // Set different.
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.HeaderBackColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.HeaderBackColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.HeaderBackColorChanged -= handler;
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidColor_TestData))]
+        public void DataGridTableStyle_HeaderBackColor_SetInvalid_ThrowsArgumentException(Color value)
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.HeaderBackColor = value);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderFont_Set_GetReturnsExpected()
+        {
+            var font1 = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+            var font2 = new Font(SystemFonts.MessageBoxFont.FontFamily, 11);
+            var style = new DataGridTableStyle
+            {
+                HeaderFont = font1
+            };
+            Assert.Same(font1, style.HeaderFont);
+
+            // Set same.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+
+            // Set null.
+            style.HeaderFont = null;
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+
+            // Set null again.
+            style.HeaderFont = null;
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+
+            // Set different.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+
+            // Set different.
+            style.HeaderFont = font2;
+            Assert.Same(font2, style.HeaderFont);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderFont_SetWithDataGrid_DoesNotCallInvalidate()
+        {
+            var font1 = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+            var font2 = new Font(SystemFonts.MessageBoxFont.FontFamily, 11);
+            var dataGrid = new DataGrid
+            {
+                Font = SystemFonts.StatusFont
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set null.
+            style.HeaderFont = null;
+            Assert.Same(dataGrid.Font, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set null again.
+            style.HeaderFont = null;
+            Assert.Same(dataGrid.Font, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different.
+            style.HeaderFont = font2;
+            Assert.Same(font2, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderFont_SetWithHandler_CallsHeaderFontChanged()
+        {
+            var font1 = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+            var font2 = new Font(SystemFonts.MessageBoxFont.FontFamily, 11);
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderFontChanged += handler;
+
+            // Set different.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(1, callCount);
+
+            // Set null.
+            style.HeaderFont = null;
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(2, callCount);
+
+            // Set null again.
+            style.HeaderFont = null;
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(2, callCount);
+
+            // Set different.
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(3, callCount);
+
+            // Set different.
+            style.HeaderFont = font2;
+            Assert.Same(font2, style.HeaderFont);
+            Assert.Equal(4, callCount);
+
+            // Remove handler.
+            style.HeaderFontChanged -= handler;
+            style.HeaderFont = font1;
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(4, callCount);
+        }
+
+        public static IEnumerable<object[]> HeaderForeColor_Set_TestData()
+        {
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+            yield return new object[] { Color.Red };
+        }
+
+        [Theory]
+        [MemberData(nameof(HeaderForeColor_Set_TestData))]
+        public void DataGridTableStyle_HeaderForeColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                HeaderForeColor = value
+            };
+            Assert.Equal(value, style.HeaderForeColor);
+
+            // Set same.
+            style.HeaderForeColor = value;
+            Assert.Equal(value, style.HeaderForeColor);
+        }
+
+        [Theory]
+        [MemberData(nameof(HeaderForeColor_Set_TestData))]
+        public void DataGridTableStyle_HeaderForeColor_SetWithDataGrid_DoesNotCallInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.HeaderForeColor = value;
+            Assert.Equal(value, style.HeaderForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.HeaderForeColor = value;
+            Assert.Equal(value, style.HeaderForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderForeColor_SetWithHandler_CallsHeaderForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderForeColorChanged += handler;
+
+            // Set different.
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.HeaderForeColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.HeaderForeColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.HeaderForeColorChanged -= handler;
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_HeaderForeColor_SetEmpty_ThrowsArgumentException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.HeaderForeColor = Color.Empty);
+        }
+
+        public static IEnumerable<object[]> LinkColor_Set_TestData()
+        {
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+            yield return new object[] { Color.Red };
+        }
+
+        [Theory]
+        [MemberData(nameof(LinkColor_Set_TestData))]
+        public void DataGridTableStyle_LinkColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                LinkColor = value
+            };
+            Assert.Equal(value, style.LinkColor);
+            Assert.Equal(value, style.LinkHoverColor);
+
+            // Set same.
+            style.LinkColor = value;
+            Assert.Equal(value, style.LinkColor);
+            Assert.Equal(value, style.LinkHoverColor);
+        }
+
+        [Theory]
+        [MemberData(nameof(LinkColor_Set_TestData))]
+        public void DataGridTableStyle_LinkColor_SetWithDataGrid_DoesNotCallInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.LinkColor = value;
+            Assert.Equal(value, style.LinkColor);
+            Assert.Equal(value, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.LinkColor = value;
+            Assert.Equal(value, style.LinkColor);
+            Assert.Equal(value, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_LinkColor_SetWithHandler_CallsLinkColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.LinkColorChanged += handler;
+
+            // Set different.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.LinkColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.LinkColor);
+            Assert.Equal(Color.Blue, style.LinkHoverColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.LinkColorChanged -= handler;
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_LinkColor_SetEmpty_ThrowsArgumentException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.LinkColor = Color.Empty);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
+        public void DataGridTableStyle_LinkHoverColor_Set_Nop(Color value)
+        {
+            var style = new DataGridTableStyle();
+            style.LinkHoverColor = value;
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void DataGridTableStyle_MappingName_Set_GetReturnsExpected(string value, string expected)
+        {
+            var style = new DataGridTableStyle
+            {
+                MappingName = value
+            };
+            Assert.Equal(expected, style.MappingName);
+
+            // Set same.
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void DataGridTableStyle_MappingName_SetWithDataGridView_GetReturnsExpected(string value, string expected)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+            Assert.Equal(0, invalidatedCallCount);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void DataGridTableStyle_MappingName_SetDefaultTableStyle_GetReturnsExpected(string value, string expected)
+        {
+            var style = new DataGridTableStyle(isDefaultTableStyle: true)
+            {
+                MappingName = value
+            };
+            Assert.Equal(expected, style.MappingName);
+
+            style.MappingName = value;
+            Assert.Equal(expected, style.MappingName);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        [InlineData("mappingname2", "mappingname2")]
+        public void DataGridTableStyle_MappingName_SetNonDuplicate_GetReturnsExpected(string value, string expected)
+        {
+            var dataGrid = new DataGrid();
+            var style1 = new DataGridTableStyle
+            {
+                MappingName = "MappingName1"
+            };
+            var style2 = new DataGridTableStyle
+            {
+                MappingName = "MappingName2"
+            };
+            dataGrid.TableStyles.Add(style1);
+            dataGrid.TableStyles.Add(style2);
+
+            style1.MappingName = value;
+            Assert.Equal(expected, style1.MappingName);
+
+            // Set same.
+            style1.MappingName = value;
+            Assert.Equal(expected, style1.MappingName);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_MappingName_SetDuplicate_Throws()
+        {
+            var dataGrid = new DataGrid();
+            var style1 = new DataGridTableStyle
+            {
+                MappingName = "MappingName1"
+            };
+            var style2 = new DataGridTableStyle
+            {
+                MappingName = "MappingName2"
+            };
+            dataGrid.TableStyles.Add(style1);
+            dataGrid.TableStyles.Add(style2);
+
+            Assert.Throws<ArgumentException>("table", () => style1.MappingName = "MappingName2");
+            Assert.Equal("MappingName1", style1.MappingName);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_MappingName_SetWithHandler_CallsMappingNameChanged()
+        {
+            var control = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(control, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            control.MappingNameChanged += handler;
+
+            // Set different.
+            control.MappingName = "mappingName";
+            Assert.Same("mappingName", control.MappingName);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            control.MappingName = "mappingName";
+            Assert.Same("mappingName", control.MappingName);
+            Assert.Equal(1, callCount);
+
+            // Set empty.
+            control.MappingName = string.Empty;
+            Assert.Empty(control.MappingName);
+            Assert.Equal(2, callCount);
+
+            // Set null.
+            control.MappingName = null;
+            Assert.Empty(control.MappingName);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            control.MappingNameChanged -= handler;
+            control.MappingName = "mappingName";
+            Assert.Same("mappingName", control.MappingName);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(75)]
+        [InlineData(76)]
+        public void DataGridTableStyle_PreferredColumnWidth_Set_GetReturnsExpected(int value)
+        {
+            var style = new DataGridTableStyle
+            {
+                PreferredColumnWidth = value
+            };
+            Assert.Equal(value, style.PreferredColumnWidth);
+
+            // Set same.
+            style.PreferredColumnWidth = value;
+            Assert.Equal(value, style.PreferredColumnWidth);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(75)]
+        [InlineData(76)]
+        public void DataGridTableStyle_PreferredColumnWidth_SetWithDataGrid_DoesNotCallInvalidate(int value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.PreferredColumnWidth = value;
+            Assert.Equal(value, style.PreferredColumnWidth);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.PreferredColumnWidth = value;
+            Assert.Equal(value, style.PreferredColumnWidth);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_PreferredColumnWidth_SetWithHandler_CallsPreferredColumnWidthChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.PreferredColumnWidthChanged += handler;
+
+            // Set different.
+            style.PreferredColumnWidth = 1;
+            Assert.Equal(1, style.PreferredColumnWidth);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.PreferredColumnWidth = 1;
+            Assert.Equal(1, style.PreferredColumnWidth);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.PreferredColumnWidth = 2;
+            Assert.Equal(2, style.PreferredColumnWidth);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.PreferredColumnWidthChanged -= handler;
+            style.PreferredColumnWidth = 1;
+            Assert.Equal(1, style.PreferredColumnWidth);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_PreferredColumnWidth_SetNegative_ThrowsArgumentOutOfRangeException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => style.PreferredColumnWidth = -1);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(75)]
+        [InlineData(76)]
+        public void DataGridTableStyle_PreferredRowHeight_Set_GetReturnsExpected(int value)
+        {
+            var style = new DataGridTableStyle
+            {
+                PreferredRowHeight = value
+            };
+            Assert.Equal(value, style.PreferredRowHeight);
+
+            // Set same.
+            style.PreferredRowHeight = value;
+            Assert.Equal(value, style.PreferredRowHeight);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(75)]
+        [InlineData(76)]
+        public void DataGridTableStyle_PreferredRowHeight_SetWithDataGrid_DoesNotCallInvalidate(int value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.PreferredRowHeight = value;
+            Assert.Equal(value, style.PreferredRowHeight);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.PreferredRowHeight = value;
+            Assert.Equal(value, style.PreferredRowHeight);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_PreferredRowHeight_SetWithHandler_CallsPreferredRowHeightChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.PreferredRowHeightChanged += handler;
+
+            // Set different.
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.PreferredRowHeight = 2;
+            Assert.Equal(2, style.PreferredRowHeight);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.PreferredRowHeightChanged -= handler;
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_PreferredRowHeight_SetNegative_ThrowsArgumentOutOfRangeException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => style.PreferredRowHeight = -1);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ReadOnly_Set_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle
+            {
+                ReadOnly = value
+            };
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set same.
+            style.ReadOnly = value;
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set different
+            style.ReadOnly = !value;
+            Assert.Equal(!value, style.ReadOnly);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ReadOnly_SetWithDataGrid_DoesNotCallInvalidate(bool value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.ReadOnly = value;
+            Assert.Equal(value, style.ReadOnly);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.ReadOnly = value;
+            Assert.Equal(value, style.ReadOnly);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different
+            style.ReadOnly = !value;
+            Assert.Equal(!value, style.ReadOnly);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_ReadOnly_SetDefaultTableStyle_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle(isDefaultTableStyle: true)
+            {
+                ReadOnly = value
+            };
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set same.
+            style.ReadOnly = value;
+            Assert.Equal(value, style.ReadOnly);
+
+            // Set different
+            style.ReadOnly = !value;
+            Assert.Equal(!value, style.ReadOnly);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ReadOnly_SetWithHandler_CallsReadOnlyChanged()
+        {
+            var style = new DataGridTableStyle
+            {
+                ReadOnly = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.ReadOnlyChanged += handler;
+
+            // Set different.
+            style.ReadOnly = false;
+            Assert.False(style.ReadOnly);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.ReadOnly = false;
+            Assert.False(style.ReadOnly);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.ReadOnly = true;
+            Assert.True(style.ReadOnly);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.ReadOnlyChanged -= handler;
+            style.ReadOnly = false;
+            Assert.False(style.ReadOnly);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_RowHeadersVisible_Set_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle
+            {
+                RowHeadersVisible = value
+            };
+            Assert.Equal(value, style.RowHeadersVisible);
+
+            // Set same.
+            style.RowHeadersVisible = value;
+            Assert.Equal(value, style.RowHeadersVisible);
+
+            // Set different
+            style.RowHeadersVisible = !value;
+            Assert.Equal(!value, style.RowHeadersVisible);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_RowHeadersVisible_SetWithDataGrid_DoesNotCallInvalidate(bool value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.RowHeadersVisible = value;
+            Assert.Equal(value, style.RowHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.RowHeadersVisible = value;
+            Assert.Equal(value, style.RowHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set different
+            style.RowHeadersVisible = !value;
+            Assert.Equal(!value, style.RowHeadersVisible);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_RowHeadersVisible_SetDefaultTableStyle_GetReturnsExpected(bool value)
+        {
+            var style = new DataGridTableStyle(isDefaultTableStyle: true)
+            {
+                RowHeadersVisible = value
+            };
+            Assert.Equal(value, style.RowHeadersVisible);
+
+            // Set same.
+            style.RowHeadersVisible = value;
+            Assert.Equal(value, style.RowHeadersVisible);
+
+            // Set different
+            style.RowHeadersVisible = !value;
+            Assert.Equal(!value, style.RowHeadersVisible);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_RowHeadersVisible_SetWithHandler_CallsRowHeadersVisibleChanged()
+        {
+            var style = new DataGridTableStyle
+            {
+                RowHeadersVisible = true
+            };
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.RowHeadersVisibleChanged += handler;
+
+            // Set different.
+            style.RowHeadersVisible = false;
+            Assert.False(style.RowHeadersVisible);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.RowHeadersVisible = false;
+            Assert.False(style.RowHeadersVisible);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.RowHeadersVisible = true;
+            Assert.True(style.RowHeadersVisible);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.RowHeadersVisibleChanged -= handler;
+            style.RowHeadersVisible = false;
+            Assert.False(style.RowHeadersVisible);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void DataGridTableStyle_RowHeaderWidth_Set_GetReturnsExpected(int value)
+        {
+            var style = new DataGridTableStyle
+            {
+                RowHeaderWidth = value
+            };
+            Assert.Equal(value, style.RowHeaderWidth);
+
+            // Set same.
+            style.RowHeaderWidth = value;
+            Assert.Equal(value, style.RowHeaderWidth);
+        }
+
+        [Theory]
+        [InlineData(-1, 0)]
+        [InlineData(0, 0)]
+        [InlineData(1, 1)]
+        [InlineData(35, 35)]
+        [InlineData(36, 36)]
+        public void DataGridTableStyle_RowHeaderWidth_SetWithDataGrid_DoesNotCallInvalidate(int value, int expected)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.RowHeaderWidth = value;
+            Assert.Equal(expected, style.RowHeaderWidth);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Set same.
+            style.RowHeaderWidth = value;
+            Assert.Equal(expected, style.RowHeaderWidth);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_RowHeaderWidth_SetWithHandler_CallsRowHeaderWidthChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.RowHeaderWidthChanged += handler;
+
+            // Set different.
+            style.RowHeaderWidth = 1;
+            Assert.Equal(1, style.RowHeaderWidth);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.RowHeaderWidth = 1;
+            Assert.Equal(1, style.RowHeaderWidth);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.RowHeaderWidth = 2;
+            Assert.Equal(2, style.RowHeaderWidth);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.RowHeaderWidthChanged -= handler;
+            style.RowHeaderWidth = 1;
+            Assert.Equal(1, style.RowHeaderWidth);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_SelectionBackColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                SelectionBackColor = value
+            };
+            Assert.Equal(value, style.SelectionBackColor);
+
+            // Set same.
+            style.SelectionBackColor = value;
+            Assert.Equal(value, style.SelectionBackColor);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetColorTheoryData))]
+        public void DataGridTableStyle_SelectionBackColor_SetWithDataGrid_CallsInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.SelectionBackColor = value;
+            Assert.Equal(value, style.SelectionBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+
+            // Set same.
+            style.SelectionBackColor = value;
+            Assert.Equal(value, style.SelectionBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_SelectionBackColor_SetWithHandler_CallsSelectionBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.SelectionBackColorChanged += handler;
+
+            // Set different.
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.SelectionBackColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.SelectionBackColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.SelectionBackColorChanged -= handler;
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidColor_TestData))]
+        public void DataGridTableStyle_SelectionBackColor_SetInvalid_ThrowsArgumentException(Color value)
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.SelectionBackColor = value);
+        }
+
+        public static IEnumerable<object[]> SelectionForeColor_Set_TestData()
+        {
+            yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
+            yield return new object[] { Color.Red };
+        }
+
+        [Theory]
+        [MemberData(nameof(SelectionForeColor_Set_TestData))]
+        public void DataGridTableStyle_SelectionForeColor_Set_GetReturnsExpected(Color value)
+        {
+            var style = new DataGridTableStyle
+            {
+                SelectionForeColor = value
+            };
+            Assert.Equal(value, style.SelectionForeColor);
+
+            // Set same.
+            style.SelectionForeColor = value;
+            Assert.Equal(value, style.SelectionForeColor);
+        }
+
+        [Theory]
+        [MemberData(nameof(SelectionForeColor_Set_TestData))]
+        public void DataGridTableStyle_SelectionForeColor_SetWithDataGrid_CallsInvalidate(Color value)
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            style.SelectionForeColor = value;
+            Assert.Equal(value, style.SelectionForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+
+            // Set same.
+            style.SelectionForeColor = value;
+            Assert.Equal(value, style.SelectionForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_SelectionForeColor_SetWithHandler_CallsSelectionForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.SelectionForeColorChanged += handler;
+
+            // Set different.
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set same.
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.Equal(1, callCount);
+
+            // Set different.
+            style.SelectionForeColor = Color.Blue;
+            Assert.Equal(Color.Blue, style.SelectionForeColor);
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.SelectionForeColorChanged -= handler;
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_SelectionForeColor_SetEmpty_ThrowsArgumentException()
+        {
+            var style = new DataGridTableStyle();
+            Assert.Throws<ArgumentException>("value", () => style.SelectionForeColor = Color.Empty);
+        }
+
+        public static IEnumerable<object[]> BeginEdit_WithDataSource_TestData()
+        {
+            yield return new object[] { 0, true, true, 0, 1, 0, 0, 5 };
+            yield return new object[] { 1, true, true, 1, 2, 1, 0, 5 };
+            yield return new object[] { -1, true, true, 0, 1, 0, 0, 5 };
+            yield return new object[] { 2, true, true, 1, 2, 1, 0, 5 };
+
+            yield return new object[] { 0, false, true, 0, 1, 0, 0, 2 };
+            yield return new object[] { 1, false, true, 1, 2, 1, 1, 3 };
+            yield return new object[] { -1, false, true, 0, 1, 0, 0, 2 };
+            yield return new object[] { 2, false, true, 1, 2, 1, 1, 3 };
+        }
+
+        [Theory]
+        [MemberData(nameof(BeginEdit_WithDataSource_TestData))]
+        public void DataGridTableStyle_BeginEdit_InvokeWithDataSource_ReturnsExpected(int rowNumber, bool commitResult1, bool commitResult2, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount, int expectedAbortCallCount, int expectedCommitCallCount2)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return commitResult1;
+            };
+            int abortCallCount1 = 0;
+            gridColumn1.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount1++;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return commitResult2;
+            };
+            int abortCallCount2 = 0;
+            gridColumn2.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount2++;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(expectedAbortCallCount, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Edit same.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount + 1, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount + 1, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Edit another.
+            Assert.True(style.BeginEdit(gridColumn2, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 1), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount + 1, editCallCount1);
+            Assert.Equal(2, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(1, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Edit invalid.
+            Assert.False(style.BeginEdit(new SubDataGridColumnStyle(), rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 1), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount + 1, editCallCount1);
+            Assert.Equal(2, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(1, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Edit null.
+            Assert.False(style.BeginEdit(null, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 1), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount + 1, editCallCount1);
+            Assert.Equal(2, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(1, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(-1)]
+        [InlineData(2)]
+        public void DataGridTableStyle_BeginEdit_InvokeWithEmptyDataSource_ReturnsExpected(int rowNumber)
+        {
+            var dataSource = new DataClass[0];
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                commitCallCount1++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                commitCallCount2++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(0, 0), dataGrid.CurrentCell);
+            Assert.Equal(0, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(0, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+
+            // Edit same.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(0, 0), dataGrid.CurrentCell);
+            Assert.Equal(0, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(0, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+
+            // Edit another.
+            Assert.True(style.BeginEdit(gridColumn2, rowNumber));
+            Assert.Equal(new DataGridCell(0, 0), dataGrid.CurrentCell);
+            Assert.Equal(0, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(0, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+
+            // Edit invalid.
+            Assert.False(style.BeginEdit(new SubDataGridColumnStyle(), rowNumber));
+            Assert.Equal(new DataGridCell(0, 0), dataGrid.CurrentCell);
+            Assert.Equal(0, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(0, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+
+            // Edit null.
+            Assert.False(style.BeginEdit(null, rowNumber));
+            Assert.Equal(new DataGridCell(0, 0), dataGrid.CurrentCell);
+            Assert.Equal(0, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(0, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+        }
+
+        [Theory]
+        [InlineData(0, 0, 1, 0)]
+        [InlineData(1, 1, 2, 1)]
+        [InlineData(-1, 0, 1, 0)]
+        [InlineData(2, 1, 2, 1)]
+        public void DataGridTableStyle_BeginEdit_InvokeWithDataSource_ResetsSelection(int rowNumber, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            dataGrid.Select(0);
+            Assert.True(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+        }
+
+        [Theory]
+        [InlineData(0, 0, 1, 0)]
+        [InlineData(1, 1, 2, 1)]
+        [InlineData(-1, 0, 1, 0)]
+        [InlineData(2, 1, 2, 1)]
+        public void DataGridTableStyle_BeginEdit_InvokeWithDataSourceEditing_ReturnsFalse(int rowNumber, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // Actual edit.
+            dataGrid.ColumnStartedEditing(Rectangle.Empty);
+            Assert.False(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+        }
+
+        public static IEnumerable<object[]> BeginEdit_WithoutDataSource_TestData()
+        {
+            yield return new object[] { null, null, -1, null };
+            yield return new object[] { null, null, 0, null };
+            yield return new object[] { null, null, 1, null };
+            yield return new object[] { null, new SubDataGridColumnStyle(), -1, null };
+            yield return new object[] { null, new SubDataGridColumnStyle(), 0, null };
+            yield return new object[] { null, new SubDataGridColumnStyle(), 1, null };
+
+            yield return new object[] { new DataGrid(), null, -1, new DataGridCell(0, 0) };
+            yield return new object[] { new DataGrid(), null, 0, new DataGridCell(0, 0) };
+            yield return new object[] { new DataGrid(), null, 1, new DataGridCell(0, 0) };
+            yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), -1, new DataGridCell(0, 0) };
+            yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), 0, new DataGridCell(0, 0) };
+            yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), 1, new DataGridCell(0, 0) };
+        }
+
+        [Theory]
+        [MemberData(nameof(BeginEdit_WithoutDataSource_TestData))]
+        public void DataGridTableStyle_BeginEdit_InvokeWithoutDataSource_ReturnsFalse(DataGrid dataGrid, DataGridColumnStyle gridColumn, int rowNumber, DataGridCell? expectedCurrentCell)
+        {
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            Assert.False(style.BeginEdit(gridColumn, rowNumber));
+            Assert.Equal(expectedCurrentCell, dataGrid?.CurrentCell);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_CreateGridColumn_InvokePropertyDescriptorBoolProperty_ReturnsExpected()
+        {
+            PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(ClassWithProperties))[nameof(ClassWithProperties.BoolProperty)];
+            var style = new SubDataGridTableStyle();
+            DataGridBoolColumn columnStyle = Assert.IsType<DataGridBoolColumn>(style.CreateGridColumn(prop));
+            Assert.Same(prop, columnStyle.PropertyDescriptor);
+            Assert.Empty(columnStyle.MappingName);
+        }
+
+        [Theory]
+        [InlineData(nameof(ClassWithProperties.SByteProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.ShortProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.IntProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.LongProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.ByteProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.UShortProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.UIntProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.ULongProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.CharProperty), "")]
+        [InlineData(nameof(ClassWithProperties.StringProperty), "")]
+        [InlineData(nameof(ClassWithProperties.DateTimeProperty), "d")]
+        [InlineData(nameof(ClassWithProperties.DecimalProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.DoubleProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.FloatProperty), "G")]
+        [InlineData(nameof(ClassWithProperties.ObjectProperty), "")]
+        public void DataGridTableStyle_CreateGridColumn_InvokePropertyDescriptorTextBoxProperty_ReturnsExpected(string propertyName, string expectedFormat)
+        {
+            PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(ClassWithProperties))[propertyName];
+            var style = new SubDataGridTableStyle();
+            DataGridTextBoxColumn columnStyle = Assert.IsType<DataGridTextBoxColumn>(style.CreateGridColumn(prop));
+            Assert.Same(prop, columnStyle.PropertyDescriptor);
+            Assert.Equal(expectedFormat, columnStyle.Format);
+            Assert.Empty(columnStyle.MappingName);
+        }
+
+        [Theory]
+        [InlineData(true, nameof(ClassWithProperties.BoolProperty))]
+        [InlineData(false, "")]
+        public void DataGridTableStyle_CreateGridColumn_InvokePropertyDescriptorBoolBoolProperty_ReturnsExpected(bool isDefault, string expectedMappingName)
+        {
+            PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(ClassWithProperties))[nameof(ClassWithProperties.BoolProperty)];
+            var style = new SubDataGridTableStyle();
+            DataGridBoolColumn columnStyle = Assert.IsType<DataGridBoolColumn>(style.CreateGridColumn(prop, isDefault));
+            Assert.Same(prop, columnStyle.PropertyDescriptor);
+            Assert.Equal(expectedMappingName, columnStyle.MappingName);
+        }
+
+        public static IEnumerable<object[]> CreateGridColumn_TextBoxProperty_TestData()
+        {
+            yield return new object[] { nameof(ClassWithProperties.SByteProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.ShortProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.IntProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.LongProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.ByteProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.UShortProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.UIntProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.ULongProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.CharProperty), false, "", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.StringProperty), false, "", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.DateTimeProperty), false, "d", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.DecimalProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.DoubleProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.FloatProperty), false, "G", string.Empty };
+            yield return new object[] { nameof(ClassWithProperties.ObjectProperty), false, "", string.Empty };
+
+            yield return new object[] { nameof(ClassWithProperties.SByteProperty), true, "G", nameof(ClassWithProperties.SByteProperty) };
+            yield return new object[] { nameof(ClassWithProperties.ShortProperty), true, "G", nameof(ClassWithProperties.ShortProperty) };
+            yield return new object[] { nameof(ClassWithProperties.IntProperty), true, "G", nameof(ClassWithProperties.IntProperty) };
+            yield return new object[] { nameof(ClassWithProperties.LongProperty), true, "G", nameof(ClassWithProperties.LongProperty) };
+            yield return new object[] { nameof(ClassWithProperties.ByteProperty), true, "G", nameof(ClassWithProperties.ByteProperty) };
+            yield return new object[] { nameof(ClassWithProperties.UShortProperty), true, "G", nameof(ClassWithProperties.UShortProperty) };
+            yield return new object[] { nameof(ClassWithProperties.UIntProperty), true, "G", nameof(ClassWithProperties.UIntProperty) };
+            yield return new object[] { nameof(ClassWithProperties.ULongProperty), true, "G", nameof(ClassWithProperties.ULongProperty) };
+            yield return new object[] { nameof(ClassWithProperties.CharProperty), true, "", nameof(ClassWithProperties.CharProperty) };
+            yield return new object[] { nameof(ClassWithProperties.StringProperty), true, "", nameof(ClassWithProperties.StringProperty) };
+            yield return new object[] { nameof(ClassWithProperties.DateTimeProperty), true, "d", nameof(ClassWithProperties.DateTimeProperty) };
+            yield return new object[] { nameof(ClassWithProperties.DecimalProperty), true, "G", nameof(ClassWithProperties.DecimalProperty) };
+            yield return new object[] { nameof(ClassWithProperties.DoubleProperty), true, "G", nameof(ClassWithProperties.DoubleProperty) };
+            yield return new object[] { nameof(ClassWithProperties.FloatProperty), true, "G", nameof(ClassWithProperties.FloatProperty) };
+            yield return new object[] { nameof(ClassWithProperties.ObjectProperty), true, "", nameof(ClassWithProperties.ObjectProperty) };
+        }
+
+        [Theory]
+        [MemberData(nameof(CreateGridColumn_TextBoxProperty_TestData))]
+        public void DataGridTableStyle_CreateGridColumn_InvokePropertyDescriptorBoolTextBoxProperty_ReturnsExpected(string propertyName, bool isDefault, string expectedFormat, string expectedMappingName)
+        {
+            PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(ClassWithProperties))[propertyName];
+            var style = new SubDataGridTableStyle();
+            DataGridTextBoxColumn columnStyle = Assert.IsType<DataGridTextBoxColumn>(style.CreateGridColumn(prop, isDefault));
+            Assert.Same(prop, columnStyle.PropertyDescriptor);
+            Assert.Equal(expectedFormat, columnStyle.Format);
+            Assert.Equal(expectedMappingName, columnStyle.MappingName);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_CreateGridColumn_NullProp_ThrowsArgumentNullException()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.Throws<ArgumentNullException>("prop", () => style.CreateGridColumn(null));
+            Assert.Throws<ArgumentNullException>("prop", () => style.CreateGridColumn(null, isDefault: true));
+            Assert.Throws<ArgumentNullException>("prop", () => style.CreateGridColumn(null, isDefault: false));
+        }
+
+        [Fact]
+        public void DataGridTableStyle_Dispose_InvokeWithEmptyGridColumnStyles_Nop()
+        {
+            var style = new DataGridTableStyle();
+            style.Dispose();
+            style.Dispose();
+        }
+
+        [Fact]
+        public void DataGridTableStyle_Dispose_InvokeWithNullGridColumnStyles_Nop()
+        {
+            var style = new NullGridColumnStylesDataGridTableStyle();
+            style.Dispose();
+            style.Dispose();
+        }
+
+        [Fact]
+        public void DataGridTableStyle_Dispose_Invoke_CallsDisposeOnChildren()
+        {
+            var columnStyle = new SubDataGridColumnStyle();
+            int disposeCallCount = 0;
+            columnStyle.DisposeAction = (disposing) =>
+            {
+                Assert.True(disposing);
+                disposeCallCount++;
+            };
+            var style = new DataGridTableStyle();
+            style.GridColumnStyles.Add(columnStyle);
+
+            style.Dispose();
+            Assert.Equal(1, disposeCallCount);
+            Assert.Same(columnStyle, Assert.Single(style.GridColumnStyles));
+
+            // Call again.
+            style.Dispose();
+            Assert.Equal(2, disposeCallCount);
+            Assert.Same(columnStyle, Assert.Single(style.GridColumnStyles));
+
+            columnStyle.DisposeAction = null;
+        }
+
+        [Fact]
+        public void DataGridTableStyle_Dispose_InvokeWithHandler_CallsDisposed()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.Disposed += handler;
+
+            // Call with handler.
+            style.Dispose();
+            Assert.Equal(1, callCount);
+
+            // Call again.
+            style.Dispose();
+            Assert.Equal(2, callCount);
+
+            // Remove handler.
+            style.Disposed -= handler;
+            style.Dispose();
+            Assert.Equal(2, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_Dispose_InvokeBoolWithEmptyGridColumnStyles_Nop(bool disposing)
+        {
+            var style = new SubDataGridTableStyle();
+            style.Dispose(disposing);
+            style.Dispose(disposing);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void DataGridTableStyle_Dispose_InvokeBoolWithNullGridColumnStyles_Nop(bool disposing)
+        {
+            var style = new NullGridColumnStylesDataGridTableStyle();
+            style.Dispose(disposing);
+            style.Dispose(disposing);
+        }
+
+        [Theory]
+        [InlineData(true, 1)]
+        [InlineData(false, 0)]
+        public void DataGridTableStyle_Dispose_InvokeBool_CallsDisposeOnChildren(bool disposing, int expectedCallCount)
+        {
+            var columnStyle = new SubDataGridColumnStyle();
+            int disposeCallCount = 0;
+            columnStyle.DisposeAction += (disposing) =>
+            {
+                Assert.True(disposing);
+                disposeCallCount++;
+            };
+            var style = new SubDataGridTableStyle();
+            style.GridColumnStyles.Add(columnStyle);
+
+            style.Dispose(disposing);
+            Assert.Equal(expectedCallCount, disposeCallCount);
+            Assert.Same(columnStyle, Assert.Single(style.GridColumnStyles));
+
+            // Call again.
+            style.Dispose(disposing);
+            Assert.Equal(expectedCallCount * 2, disposeCallCount);
+            Assert.Same(columnStyle, Assert.Single(style.GridColumnStyles));
+
+            columnStyle.DisposeAction = null;
+        }
+
+        [Theory]
+        [InlineData(true, 1)]
+        [InlineData(false, 0)]
+        public void DataGridTableStyle_Dispose_InvokeBoolWithHandler_CallsDisposed(bool disposing, int expectedCallCount)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.Disposed += handler;
+
+            // Call with handler.
+            style.Dispose(disposing);
+            Assert.Equal(expectedCallCount, callCount);
+
+            // Call again.
+            style.Dispose(disposing);
+            Assert.Equal(expectedCallCount * 2, callCount);
+
+            // Remove handler.
+            style.Disposed -= handler;
+            style.Dispose(disposing);
+            Assert.Equal(expectedCallCount * 2, callCount);
+        }
+
+        public static IEnumerable<object[]> EndEdit_DataSource_TestData()
+        {
+            foreach (bool commitResult in new bool[] { true, false })
+            {
+                yield return new object[] { 0, true, 0, 1, 0, 1, 0, commitResult, true };
+                yield return new object[] { 1, true, 1, 2, 1, 1, 1, commitResult, true };
+                yield return new object[] { -1, true, 0, 1, 0, 1, 0, commitResult, true };
+                yield return new object[] { 2, true, 1, 2, 1, 1, 1, commitResult, true };
+                yield return new object[] { 0, false, 0, 1, 0, 0, 1, commitResult, commitResult };
+                yield return new object[] { 1, false, 1, 2, 1, 0, 2, commitResult, commitResult };
+                yield return new object[] { -1, false, 0, 1, 0, 0, 1, commitResult, commitResult };
+                yield return new object[] { 2, false, 1, 2, 1, 0, 2, commitResult, commitResult };
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(EndEdit_DataSource_TestData))]
+        public void DataGridTableStyle_EndEdit_InvokeWithDataSourceAbort_ReturnsExpected(int rowNumber, bool shouldAbort, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount, int expectedAbortCallCount, int expectedCommitCallCount2, bool commitResult, bool expected)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return true;
+            };
+            int abortCallCount1 = 0;
+            gridColumn1.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount1++;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return true;
+            };
+            int abortCallCount2 = 0;
+            gridColumn2.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount2++;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(0, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit.
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return commitResult;
+            };
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return commitResult;
+            };
+            dataGrid.ColumnStartedEditing(Rectangle.Empty);
+            Assert.Equal(expected, style.EndEdit(gridColumn1, rowNumber, shouldAbort));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(expectedAbortCallCount, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit again.
+            Assert.False(style.EndEdit(gridColumn1, rowNumber, shouldAbort));
+        }
+
+        [Theory]
+        [MemberData(nameof(EndEdit_DataSource_TestData))]
+        public void DataGridTableStyle_EndEdit_InvokeWithDataSourceDifferentColumn_ReturnsExpected(int rowNumber, bool shouldAbort, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount, int expectedAbortCallCount, int expectedCommitCallCount2, bool commitResult, bool expected)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return true;
+            };
+            int abortCallCount1 = 0;
+            gridColumn1.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount1++;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return true;
+            };
+            int abortCallCount2 = 0;
+            gridColumn2.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount2++;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(0, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit.
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return commitResult;
+            };
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return commitResult;
+            };
+            dataGrid.ColumnStartedEditing(Rectangle.Empty);
+            Assert.Equal(expected, style.EndEdit(gridColumn2, rowNumber, shouldAbort));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(expectedAbortCallCount, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit again.
+            Assert.False(style.EndEdit(gridColumn2, rowNumber, shouldAbort));
+        }
+
+        public static IEnumerable<object[]> EndEdit_DataSourceInvalidColumn_TestData()
+        {
+            foreach (object[] testData in EndEdit_DataSource_TestData())
+            {
+                yield return testData.Prepend(null).ToArray();
+                yield return testData.Prepend(new SubDataGridColumnStyle()).ToArray();
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(EndEdit_DataSourceInvalidColumn_TestData))]
+        public void DataGridTableStyle_EndEdit_InvokeWithDataSourceInvalidColumn_ReturnsExpected(DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount, int expectedAbortCallCount, int expectedCommitCallCount2, bool commitResult, bool expected)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return true;
+            };
+            int abortCallCount1 = 0;
+            gridColumn1.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount1++;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                Assert.Same(currencyManager, source);
+                Assert.Equal(expectedRowNumber, rowNum);
+                Assert.NotEqual(Rectangle.Empty, bounds);
+                Assert.False(readOnly);
+                Assert.Null(displayText);
+                Assert.True(cellIsVisible);
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return true;
+            };
+            int abortCallCount2 = 0;
+            gridColumn2.AbortAction = (rowNum) =>
+            {
+                Assert.Equal(expectedRowNumber, rowNum);
+                abortCallCount2++;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(0, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit.
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount1++;
+                return commitResult;
+            };
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                Assert.Same(currencyManager, dataSource);
+                Assert.Equal(expectedRowNumber, rowNum);
+                commitCallCount2++;
+                return commitResult;
+            };
+            dataGrid.ColumnStartedEditing(Rectangle.Empty);
+            Assert.Equal(expected, style.EndEdit(gridColumn, rowNumber, shouldAbort));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount2, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.Equal(expectedAbortCallCount, abortCallCount1);
+            Assert.Equal(0, abortCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit again.
+            Assert.False(style.EndEdit(gridColumn, rowNumber, shouldAbort));
+        }
+
+        [Theory]
+        [InlineData(0, true, 0, 1, 0)]
+        [InlineData(1, true, 1, 2, 1)]
+        [InlineData(-1, true, 0, 1, 0)]
+        [InlineData(2, true, 1, 2, 1)]
+        [InlineData(0, false, 0, 1, 0)]
+        [InlineData(1, false, 1, 2, 1)]
+        [InlineData(-1, false, 0, 1, 0)]
+        [InlineData(2, false, 1, 2, 1)]
+        public void DataGridTableStyle_EndEdit_InvokeWithDataSourceNotEditing_ReturnsFalse(int rowNumber, bool shouldAbort, int expectedRowNumber, int expectedEditCallCount, int expectedCommitCallCount)
+        {
+            var dataSource = new DataClass[]
+            {
+                new() { Value1 = "Value1_1", Value2 = "Value2_1" },
+                new() { Value1 = "Value1_2", Value2 = "Value2_2" }
+            };
+            var bindingContext = new BindingContext();
+            CurrencyManager currencyManager = (CurrencyManager)bindingContext[dataSource, null];
+
+            var style = new DataGridTableStyle
+            {
+                MappingName = "DataClass[]"
+            };
+
+            var gridColumn1 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value1"
+            };
+            int editCallCount1 = 0;
+            gridColumn1.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                editCallCount1++;
+            };
+            int commitCallCount1 = 0;
+            gridColumn1.CommitAction = (dataSource, rowNum) =>
+            {
+                commitCallCount1++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn1);
+
+            var gridColumn2 = new SubDataGridColumnStyle
+            {
+                MappingName = "Value2"
+            };
+            int editCallCount2 = 0;
+            gridColumn2.EditAction = (source, rowNum, bounds, readOnly, displayText, cellIsVisible) =>
+            {
+                editCallCount2++;
+            };
+            int commitCallCount2 = 0;
+            gridColumn2.CommitAction = (dataSource, rowNum) =>
+            {
+                commitCallCount2++;
+                return true;
+            };
+            style.GridColumnStyles.Add(gridColumn2);
+
+            var dataGrid = new SubDataGrid
+            {
+                BindingContext = bindingContext
+            };
+            dataGrid.TableStyles.Add(style);
+            dataGrid.SetDataBinding(dataSource, null);
+
+            // Simulate layout on the DataGrid.
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                dataGrid.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, 1, 2)));
+            }
+
+            // Edit cell.
+            Assert.True(style.BeginEdit(gridColumn1, rowNumber));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+
+            // End edit.
+            Assert.False(style.EndEdit(gridColumn1, rowNumber, shouldAbort));
+            Assert.Equal(new DataGridCell(expectedRowNumber, 0), dataGrid.CurrentCell);
+            Assert.Equal(expectedEditCallCount, editCallCount1);
+            Assert.Equal(0, editCallCount2);
+            Assert.Equal(expectedCommitCallCount, commitCallCount1);
+            Assert.Equal(0, commitCallCount2);
+            Assert.False(dataGrid.IsSelected(0));
+            Assert.False(dataGrid.IsSelected(1));
+        }
+
+        public static IEnumerable<object[]> EndEdit_TestData()
+        {
+            foreach (bool shouldAbort in new bool[] { true, false })
+            {
+                yield return new object[] { null, null, -1, shouldAbort, null };
+                yield return new object[] { null, null, 0, shouldAbort, null };
+                yield return new object[] { null, null, 1, shouldAbort, null };
+                yield return new object[] { null, new SubDataGridColumnStyle(), -1, shouldAbort, null };
+                yield return new object[] { null, new SubDataGridColumnStyle(), 0, shouldAbort, null };
+                yield return new object[] { null, new SubDataGridColumnStyle(), 1, shouldAbort, null };
+
+                yield return new object[] { new DataGrid(), null, -1, shouldAbort, new DataGridCell(0, 0) };
+                yield return new object[] { new DataGrid(), null, 0, shouldAbort, new DataGridCell(0, 0) };
+                yield return new object[] { new DataGrid(), null, 1, shouldAbort, new DataGridCell(0, 0) };
+                yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), -1, shouldAbort, new DataGridCell(0, 0) };
+                yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), 0, shouldAbort, new DataGridCell(0, 0) };
+                yield return new object[] { new DataGrid(), new SubDataGridColumnStyle(), 1, shouldAbort, new DataGridCell(0, 0) };
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(EndEdit_TestData))]
+        public void DataGridTableStyle_EndEdit_InvokeWithoutDataSource_ReturnsFalse(DataGrid dataGrid, DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort, DataGridCell? expectedCurrentCell)
+        {
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            Assert.False(style.EndEdit(gridColumn, rowNumber, shouldAbort));
+            Assert.Equal(expectedCurrentCell, dataGrid?.CurrentCell);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnAllowSortingChanged_Invoke_CallsAllowSortingChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.AllowSortingChanged += handler;
+            style.OnAllowSortingChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.AllowSortingChanged -= handler;
+            style.OnAllowSortingChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnAlternatingBackColorChanged_Invoke_CallsAlternatingBackColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.AlternatingBackColorChanged += handler;
+            style.OnAlternatingBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.AlternatingBackColorChanged -= handler;
+            style.OnAlternatingBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.BackColorChanged += handler;
+            style.OnBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.BackColorChanged -= handler;
+            style.OnBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnColumnHeadersVisibleChanged_Invoke_CallsColumnHeadersVisibleChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.ColumnHeadersVisibleChanged += handler;
+            style.OnColumnHeadersVisibleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.ColumnHeadersVisibleChanged -= handler;
+            style.OnColumnHeadersVisibleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.ForeColorChanged += handler;
+            style.OnForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.ForeColorChanged -= handler;
+            style.OnForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnGridLineColorChanged_Invoke_CallsGridLineColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.GridLineColorChanged += handler;
+            style.OnGridLineColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.GridLineColorChanged -= handler;
+            style.OnGridLineColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnGridLineStyleChanged_Invoke_CallsGridLineStyleChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.GridLineStyleChanged += handler;
+            style.OnGridLineStyleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.GridLineStyleChanged -= handler;
+            style.OnGridLineStyleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnHeaderBackColorChanged_Invoke_CallsHeaderBackColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.HeaderBackColorChanged += handler;
+            style.OnHeaderBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.HeaderBackColorChanged -= handler;
+            style.OnHeaderBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnHeaderFontChanged_Invoke_CallsHeaderFontChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.HeaderFontChanged += handler;
+            style.OnHeaderFontChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.HeaderFontChanged -= handler;
+            style.OnHeaderFontChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnHeaderForeColorChanged_Invoke_CallsHeaderForeColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.HeaderForeColorChanged += handler;
+            style.OnHeaderForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.HeaderForeColorChanged -= handler;
+            style.OnHeaderForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnLinkColorChanged_Invoke_CallsLineColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.LinkColorChanged += handler;
+            style.OnLinkColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.LinkColorChanged -= handler;
+            style.OnLinkColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnLinkHoverColorChanged_Invoke_CallsLinkHoverColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.LinkHoverColorChanged += handler;
+            style.OnLinkHoverColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.LinkHoverColorChanged -= handler;
+            style.OnLinkHoverColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnMappingNameChanged_Invoke_CallsMappingNameChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.MappingNameChanged += handler;
+            style.OnMappingNameChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.MappingNameChanged -= handler;
+            style.OnMappingNameChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnPreferredColumnWidthChanged_Invoke_CallsPreferredColumnWidthChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.PreferredColumnWidthChanged += handler;
+            style.OnPreferredColumnWidthChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.PreferredColumnWidthChanged -= handler;
+            style.OnPreferredColumnWidthChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnPreferredRowHeightChanged_Invoke_CallsPreferredRowHeightChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.PreferredRowHeightChanged += handler;
+            style.OnPreferredRowHeightChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.PreferredRowHeightChanged -= handler;
+            style.OnPreferredRowHeightChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnReadOnlyChanged_Invoke_CallsReadOnlyChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.ReadOnlyChanged += handler;
+            style.OnReadOnlyChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.ReadOnlyChanged -= handler;
+            style.OnReadOnlyChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnRowHeadersVisibleChanged_Invoke_CallsRowHeadersVisibleChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.RowHeadersVisibleChanged += handler;
+            style.OnRowHeadersVisibleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.RowHeadersVisibleChanged -= handler;
+            style.OnRowHeadersVisibleChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnRowHeaderWidthChanged_Invoke_CallsRowHeaderWidthChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.RowHeaderWidthChanged += handler;
+            style.OnRowHeaderWidthChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.RowHeaderWidthChanged -= handler;
+            style.OnRowHeaderWidthChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnSelectionBackColorChanged_Invoke_CallsSelectionBackColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.SelectionBackColorChanged += handler;
+            style.OnSelectionBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.SelectionBackColorChanged -= handler;
+            style.OnSelectionBackColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEventArgsTheoryData))]
+        public void DataGridTableStyle_OnSelectionForeColorChanged_Invoke_CallsSelectionForeColorChanged(EventArgs eventArgs)
+        {
+            var style = new SubDataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(style, sender);
+                Assert.Same(eventArgs, e);
+                callCount++;
+            };
+
+            // Call with handler.
+            style.SelectionForeColorChanged += handler;
+            style.OnSelectionForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+
+            // Remove handler.
+            style.SelectionForeColorChanged -= handler;
+            style.OnSelectionForeColorChanged(eventArgs);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetAlternatingBackColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+
+            // Reset custom.
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetAlternatingBackColor_InvokeWithDataGrid_CallsInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(3, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetAlternatingBackColor_InvokeWithHandler_CallsAlternatingBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.AlternatingBackColorChanged += handler;
+
+            // Reset default.
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.Equal(1, callCount);
+            style.ResetAlternatingBackColor();
+            Assert.Equal(SystemColors.Window, style.AlternatingBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetBackColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+
+            // Reset custom.
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetBackColor_InvokeWithDataGrid_CallsInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.Equal(1, invalidatedCallCount);
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.Equal(2, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetBackColor_InvokeWithHandler_CallsBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.BackColorChanged += handler;
+
+            // Reset default.
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.Equal(1, callCount);
+            style.ResetBackColor();
+            Assert.Equal(SystemColors.Window, style.BackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetForeColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+
+            // Reset custom.
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetForeColor_InvokeWithDataGrid_CallsInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Equal(2, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetForeColor_InvokeWithHandler_CallsForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.ForeColorChanged += handler;
+
+            // Reset default.
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.Equal(1, callCount);
+            style.ResetForeColor();
+            Assert.Equal(SystemColors.WindowText, style.ForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderBackColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+
+            // Reset custom.
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderBackColor_InvokeWithDataGrid_DoesNotCallInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderBackColor_InvokeWithHandler_CallsHeaderBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderBackColorChanged += handler;
+
+            // Reset default.
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.Equal(1, callCount);
+            style.ResetHeaderBackColor();
+            Assert.Equal(SystemColors.Control, style.HeaderBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderFont_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+            var font = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+
+            // Reset default.
+            style.ResetHeaderFont();
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+
+            // Reset custom.
+            style.HeaderFont = font;
+            Assert.Same(font, style.HeaderFont);
+            style.ResetHeaderFont();
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderFont_InvokeWithDataGrid_DoesNotCallInvalidate()
+        {
+            var font1 = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+            var font2 = new Font(SystemFonts.MessageBoxFont.FontFamily, 11);
+            var dataGrid = new DataGrid
+            {
+                Font = font1
+            };
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetHeaderFont();
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.HeaderFont = font2;
+            Assert.Same(font2, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+            style.ResetHeaderFont();
+            Assert.Same(font1, style.HeaderFont);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderFont_InvokeWithHandler_CallsHeaderFontChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderFontChanged += handler;
+            var font = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+
+            // Reset default.
+            style.ResetHeaderFont();
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.HeaderFont = font;
+            Assert.Same(font, style.HeaderFont);
+            Assert.Equal(1, callCount);
+            style.ResetHeaderFont();
+            Assert.Equal(Control.DefaultFont, style.HeaderFont);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderForeColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+
+            // Reset custom.
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderForeColor_InvokeWithDataGrid_DoesNotCallInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetHeaderForeColor_InvokeWithHandler_CallsHeaderForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.HeaderForeColorChanged += handler;
+
+            // Reset default.
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.Equal(1, callCount);
+            style.ResetHeaderForeColor();
+            Assert.Equal(SystemColors.ControlText, style.HeaderForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkColor_InvokeWithDataGrid_DoesNotCallInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkColor_InvokeWithHandler_CallsLinkColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.LinkColorChanged += handler;
+
+            // Reset default.
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(1, callCount);
+            style.ResetLinkColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkHoverColor_Invoke_Nop()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetLinkHoverColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            style.ResetLinkHoverColor();
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkHoverColor_InvokeWithDataGrid_Nop()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetLinkHoverColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+            style.ResetLinkHoverColor();
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetLinkHoverColor_InvokeWithHandler_DoesNotCallLinkColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.LinkColorChanged += handler;
+
+            // Reset default.
+            style.ResetLinkHoverColor();
+            Assert.Equal(SystemColors.HotTrack, style.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, style.LinkHoverColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(1, callCount);
+            style.ResetLinkHoverColor();
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetPreferredRowHeight_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataGridTableStyle))[nameof(DataGridTableStyle.PreferredRowHeight)];
+
+            // Reset default.
+            Assert.False(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+
+            // Reset custom.
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.True(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetPreferredRowHeight_InvokeWithDataGrid_DoesNotCallInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataGridTableStyle))[nameof(DataGridTableStyle.PreferredRowHeight)];
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            Assert.False(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.Equal(0, invalidatedCallCount);
+            Assert.True(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.Equal(0, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetPreferredRowHeight_InvokeWithHandler_CallsPreferredRowHeightChanged()
+        {
+            var style = new DataGridTableStyle();
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataGridTableStyle))[nameof(DataGridTableStyle.PreferredRowHeight)];
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.PreferredRowHeightChanged += handler;
+
+            // Reset default.
+            Assert.False(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.Equal(1, callCount);
+            Assert.True(property.CanResetValue(style));
+            property.ResetValue(style);
+            Assert.Equal(Control.DefaultFont.Height + 3, style.PreferredRowHeight);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionBackColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+
+            // Reset custom.
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionBackColor_InvokeWithDataGrid_CallsInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.Equal(1, invalidatedCallCount);
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(2, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionBackColor_InvokeWithHandler_CallsSelectionBackColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.SelectionBackColorChanged += handler;
+
+            // Reset default.
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.Equal(1, callCount);
+            style.ResetSelectionBackColor();
+            Assert.Equal(SystemColors.ActiveCaption, style.SelectionBackColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionForeColor_Invoke_GetReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+
+            // Reset default.
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+
+            // Reset custom.
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionForeColor_InvokeWithDataGrid_CallsInvalidate()
+        {
+            var dataGrid = new DataGrid();
+            var style = new DataGridTableStyle
+            {
+                DataGrid = dataGrid
+            };
+            int invalidatedCallCount = 0;
+            dataGrid.Invalidated += (sender, e) => invalidatedCallCount++;
+            Assert.NotEqual(IntPtr.Zero, dataGrid.Handle);
+
+            // Reset default.
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Equal(0, invalidatedCallCount);
+
+            // Reset custom.
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.Equal(1, invalidatedCallCount);
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Equal(2, invalidatedCallCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ResetSelectionForeColor_InvokeWithHandler_CallsSelectionForeColorChanged()
+        {
+            var style = new DataGridTableStyle();
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Same(sender, sender);
+                Assert.Same(EventArgs.Empty, e);
+                callCount++;
+            };
+            style.SelectionForeColorChanged += handler;
+
+            // Reset default.
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Equal(0, callCount);
+
+            // Reset custom.
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.Equal(1, callCount);
+            style.ResetSelectionForeColor();
+            Assert.Equal(SystemColors.ActiveCaptionText, style.SelectionForeColor);
+            Assert.Equal(2, callCount);
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeAlternatingBackColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeAlternatingBackColor());
+
+            style.AlternatingBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.AlternatingBackColor);
+            Assert.True(style.ShouldSerializeAlternatingBackColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeBackColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeBackColor());
+
+            style.BackColor = Color.Red;
+            Assert.Equal(Color.Red, style.BackColor);
+            Assert.True(style.ShouldSerializeBackColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeForeColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeForeColor());
+
+            style.ForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.ForeColor);
+            Assert.True(style.ShouldSerializeForeColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeGridLineColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeGridLineColor());
+
+            style.GridLineColor = Color.Red;
+            Assert.Equal(Color.Red, style.GridLineColor);
+            Assert.True(style.ShouldSerializeGridLineColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeHeaderBackColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeHeaderBackColor());
+
+            style.HeaderBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderBackColor);
+            Assert.True(style.ShouldSerializeHeaderBackColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeHeaderFont_Invoke_ReturnsExpected()
+        {
+            var style = new DataGridTableStyle();
+            var font = new Font(SystemFonts.MessageBoxFont.FontFamily, 10);
+            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(DataGridTableStyle))[nameof(DataGridTableStyle.HeaderFont)];
+            Assert.False(property.ShouldSerializeValue(style));
+
+            style.HeaderFont = font;
+            Assert.Same(font, style.HeaderFont);
+            Assert.True(property.ShouldSerializeValue(style));
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeHeaderForeColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.True(style.ShouldSerializeHeaderForeColor());
+
+            style.HeaderForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.HeaderForeColor);
+            Assert.True(style.ShouldSerializeHeaderForeColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeLinkColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeLinkColor());
+
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.True(style.ShouldSerializeLinkColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeLinkHoverColor_Invoke_ReturnsFalse()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeLinkHoverColor());
+
+            style.LinkColor = Color.Red;
+            Assert.Equal(Color.Red, style.LinkColor);
+            Assert.Equal(Color.Red, style.LinkHoverColor);
+            Assert.False(style.ShouldSerializeLinkHoverColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldShouldSerializePreferredRowHeight_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializePreferredRowHeight());
+
+            style.PreferredRowHeight = 1;
+            Assert.Equal(1, style.PreferredRowHeight);
+            Assert.True(style.ShouldSerializePreferredRowHeight());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeSelectionBackColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeSelectionBackColor());
+
+            style.SelectionBackColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionBackColor);
+            Assert.True(style.ShouldSerializeSelectionBackColor());
+        }
+
+        [Fact]
+        public void DataGridTableStyle_ShouldSerializeSelectionForeColor_Invoke_ReturnsExpected()
+        {
+            var style = new SubDataGridTableStyle();
+            Assert.False(style.ShouldSerializeSelectionForeColor());
+
+            style.SelectionForeColor = Color.Red;
+            Assert.Equal(Color.Red, style.SelectionForeColor);
+            Assert.True(style.ShouldSerializeSelectionForeColor());
+        }
+
+        private class SubDataGridTableStyle : DataGridTableStyle
+        {
+            public SubDataGridTableStyle() : base()
+            {
+            }
+
+            public SubDataGridTableStyle(bool isDefaultTableStyle) : base(isDefaultTableStyle)
+            {
+            }
+
+            public SubDataGridTableStyle(CurrencyManager listManager) : base(listManager)
+            {
+            }
+
+            public new bool CanRaiseEvents => base.CanRaiseEvents;
+
+            public new bool DesignMode => base.DesignMode;
+
+            public new EventHandlerList Events => base.Events;
+
+            public new DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop) => base.CreateGridColumn(prop);
+
+            public new DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop, bool isDefault) => base.CreateGridColumn(prop, isDefault);
+
+            public new void Dispose(bool disposing) => base.Dispose(disposing);
+
+            public new void OnAllowSortingChanged(EventArgs e) => base.OnAllowSortingChanged(e);
+
+            public new void OnAlternatingBackColorChanged(EventArgs e) => base.OnAlternatingBackColorChanged(e);
+
+            public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
+
+            public new void OnColumnHeadersVisibleChanged(EventArgs e) => base.OnColumnHeadersVisibleChanged(e);
+
+            public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
+
+            public new void OnGridLineColorChanged(EventArgs e) => base.OnGridLineColorChanged(e);
+
+            public new void OnGridLineStyleChanged(EventArgs e) => base.OnGridLineStyleChanged(e);
+
+            public new void OnHeaderBackColorChanged(EventArgs e) => base.OnHeaderBackColorChanged(e);
+
+            public new void OnHeaderFontChanged(EventArgs e) => base.OnHeaderFontChanged(e);
+
+            public new void OnHeaderForeColorChanged(EventArgs e) => base.OnHeaderForeColorChanged(e);
+
+            public new void OnLinkColorChanged(EventArgs e) => base.OnLinkColorChanged(e);
+
+            public new void OnLinkHoverColorChanged(EventArgs e) => base.OnLinkHoverColorChanged(e);
+
+            public new void OnMappingNameChanged(EventArgs e) => base.OnMappingNameChanged(e);
+
+            public new void OnPreferredColumnWidthChanged(EventArgs e) => base.OnPreferredColumnWidthChanged(e);
+
+            public new void OnPreferredRowHeightChanged(EventArgs e) => base.OnPreferredRowHeightChanged(e);
+
+            public new void OnReadOnlyChanged(EventArgs e) => base.OnReadOnlyChanged(e);
+
+            public new void OnRowHeadersVisibleChanged(EventArgs e) => base.OnRowHeadersVisibleChanged(e);
+
+            public new void OnRowHeaderWidthChanged(EventArgs e) => base.OnRowHeaderWidthChanged(e);
+
+            public new void OnSelectionBackColorChanged(EventArgs e) => base.OnSelectionBackColorChanged(e);
+
+            public new void OnSelectionForeColorChanged(EventArgs e) => base.OnSelectionForeColorChanged(e);
+
+            public new bool ShouldSerializeAlternatingBackColor() => base.ShouldSerializeAlternatingBackColor();
+
+            public new bool ShouldSerializeBackColor() => base.ShouldSerializeBackColor();
+
+            public new bool ShouldSerializeForeColor() => base.ShouldSerializeForeColor();
+
+            public new bool ShouldSerializeGridLineColor() => base.ShouldSerializeGridLineColor();
+
+            public new bool ShouldSerializeHeaderBackColor() => base.ShouldSerializeHeaderBackColor();
+
+            public new bool ShouldSerializeHeaderForeColor() => base.ShouldSerializeHeaderForeColor();
+
+            public new bool ShouldSerializeLinkColor() => base.ShouldSerializeLinkColor();
+
+            public new bool ShouldSerializeLinkHoverColor() => base.ShouldSerializeLinkHoverColor();
+
+            public new bool ShouldSerializePreferredRowHeight() => base.ShouldSerializePreferredRowHeight();
+
+            public new bool ShouldSerializeSelectionBackColor() => base.ShouldSerializeSelectionBackColor();
+
+            public new bool ShouldSerializeSelectionForeColor() => base.ShouldSerializeSelectionForeColor();
+        }
+
+        private class SubDataGridColumnStyle : DataGridColumnStyle
+        {
+            public Action<int> AbortAction { get; set; }
+
+            protected internal override void Abort(int rowNum)
+            {
+                AbortAction(rowNum);
+            }
+
+            public Func<CurrencyManager, int, bool> CommitAction { get; set; }
+
+            protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+            {
+                return CommitAction(dataSource, rowNum);
+            }
+
+            public Action<CurrencyManager, int, Rectangle, bool, string, bool> EditAction { get; set; }
+
+            protected internal override void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible)
+            {
+                EditAction(source, rowNum, bounds, readOnly, displayText, cellIsVisible);
+            }
+
+            protected internal override Size GetPreferredSize(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetMinimumHeight()
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetPreferredHeight(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+            {
+                throw new NotImplementedException();
+            }
+
+            public Action<DataGrid> SetDataGridInColumnAction { get; set; }
+
+            protected override void SetDataGridInColumn(DataGrid value)
+            {
+                if (SetDataGridInColumnAction == null)
+                {
+                    base.SetDataGridInColumn(value);
+                }
+                else
+                {
+                    SetDataGridInColumnAction(value);
+                }
+            }
+
+            public Action<bool> DisposeAction { get; set; }
+
+            protected override void Dispose(bool disposing)
+            {
+                DisposeAction?.Invoke(disposing);
+            }
+        }
+
+        private class NullGridColumnStylesDataGridTableStyle : DataGridTableStyle
+        {
+            public override GridColumnStylesCollection GridColumnStyles => null;
+
+            public new void Dispose(bool disposing) => base.Dispose(disposing);
+        }
+
+        private class SubDataGrid : DataGrid
+        {
+            public new void ColumnStartedEditing(Rectangle bounds) => base.ColumnStartedEditing(bounds);
+
+            public new void OnPaint(PaintEventArgs pe) => base.OnPaint(pe);
+        }
+
+        private class DataClass
+        {
+            public string Value1 { get; set; }
+
+            public string Value2 { get; set; }
+        }
+
+
+        private class ClassWithProperties
+        {
+            public bool BoolProperty { get; set; }
+
+            public string StringProperty { get; set; }
+
+            public DateTime DateTimeProperty { get; set; }
+
+            public sbyte SByteProperty { get; set; }
+
+            public short ShortProperty { get; set; }
+
+            public int IntProperty { get; set; }
+
+            public long LongProperty { get; set; }
+
+            public byte ByteProperty { get; set; }
+
+            public ushort UShortProperty { get; set; }
+
+            public uint UIntProperty { get; set; }
+
+            public ulong ULongProperty { get; set; }
+
+            public char CharProperty { get; set; }
+
+            public decimal DecimalProperty { get; set; }
+
+            public double DoubleProperty { get; set; }
+
+            public float FloatProperty { get; set; }
+
+            public object ObjectProperty { get; set; }
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/DataGridTests.cs b/WTG.System.Windows.Forms.Tests/DataGridTests.cs
new file mode 100644
index 00000000000..57d9ed3e1c6
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/DataGridTests.cs
@@ -0,0 +1,140 @@
+using System.ComponentModel;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class DataGridTests
+    {
+        [Fact]
+        public void DataGrid_Ctor_Default()
+        {
+            var dataGrid = new SubDataGrid();
+            Assert.True(dataGrid.AllowNavigation);
+            Assert.True(dataGrid.AllowSorting);
+            Assert.Equal(SystemColors.Window, dataGrid.AlternatingBackColor);
+            Assert.Equal(SystemColors.Window, dataGrid.BackColor);
+            Assert.Equal(SystemColors.AppWorkspace, dataGrid.BackgroundColor);
+            Assert.Null(dataGrid.BackgroundImage);
+            Assert.Equal(ImageLayout.Tile, dataGrid.BackgroundImageLayout);
+            Assert.Equal(BorderStyle.Fixed3D, dataGrid.BorderStyle);
+            Assert.Equal(new Rectangle(0, 0, 130, 80), dataGrid.Bounds);
+            Assert.Equal(80, dataGrid.Bottom);
+            Assert.Equal(SystemColors.ActiveCaption, dataGrid.CaptionBackColor);
+            Assert.Equal(Control.DefaultFont.Name, dataGrid.CaptionFont.Name);
+            Assert.Equal(FontStyle.Bold, dataGrid.CaptionFont.Style);
+            Assert.Equal(SystemColors.ActiveCaptionText, dataGrid.CaptionForeColor);
+            Assert.Empty(dataGrid.CaptionText);
+            Assert.True(dataGrid.CaptionVisible);
+            Assert.Equal(new Rectangle(0, 0, 130, 80), dataGrid.ClientRectangle);
+            Assert.Equal(new Size(130, 80), dataGrid.ClientSize);
+            Assert.True(dataGrid.ColumnHeadersVisible);
+            Assert.Equal(0, dataGrid.CurrentCell.RowNumber);
+            Assert.Equal(0, dataGrid.CurrentCell.ColumnNumber);
+            Assert.Equal(-1, dataGrid.CurrentRowIndex);
+            Assert.Same(Cursors.Default, dataGrid.Cursor);
+            Assert.Empty(dataGrid.DataMember);
+            Assert.Null(dataGrid.DataSource);
+            Assert.Equal(new Rectangle(0, 0, 130, 80), dataGrid.DisplayRectangle);
+            Assert.Equal(Size.Empty, dataGrid.DefaultMaximumSize);
+            Assert.Equal(Size.Empty, dataGrid.DefaultMinimumSize);
+            Assert.Equal(Padding.Empty, dataGrid.DefaultPadding);
+            Assert.Equal(new Size(130, 80), dataGrid.DefaultSize);
+            Assert.Equal(0, dataGrid.FirstVisibleColumn);
+            Assert.False(dataGrid.FlatMode);
+            Assert.Equal(SystemColors.WindowText, dataGrid.ForeColor);
+            Assert.Equal(SystemColors.Control, dataGrid.GridLineColor);
+            Assert.Equal(DataGridLineStyle.Solid, dataGrid.GridLineStyle);
+            Assert.Equal(SystemColors.Control, dataGrid.HeaderBackColor);
+            Assert.Equal(Control.DefaultFont, dataGrid.HeaderFont);
+            Assert.Equal(SystemColors.ControlText, dataGrid.HeaderForeColor);
+            Assert.Equal(SystemColors.ControlText, dataGrid.HeaderForeColor);
+            Assert.Equal(80, dataGrid.Height);
+            Assert.NotNull(dataGrid.HorizScrollBar);
+            Assert.Same(dataGrid.HorizScrollBar, dataGrid.HorizScrollBar);
+            Assert.Equal(0, dataGrid.Left);
+            Assert.Equal(SystemColors.HotTrack, dataGrid.LinkColor);
+            Assert.Equal(SystemColors.HotTrack, dataGrid.LinkHoverColor);
+            Assert.Null(dataGrid.ListManager);
+            Assert.Equal(Point.Empty, dataGrid.Location);
+            Assert.Equal(new Padding(3, 3, 3, 3), dataGrid.Margin);
+            Assert.Equal(Size.Empty, dataGrid.MaximumSize);
+            Assert.Equal(Size.Empty, dataGrid.MinimumSize);
+            Assert.Equal(Padding.Empty, dataGrid.Padding);
+            Assert.Equal(SystemColors.Control, dataGrid.ParentRowsBackColor);
+            Assert.Equal(SystemColors.WindowText, dataGrid.ParentRowsForeColor);
+            Assert.Equal(DataGridParentRowsLabelStyle.Both, dataGrid.ParentRowsLabelStyle);
+            Assert.True(dataGrid.ParentRowsVisible);
+            Assert.Equal(75, dataGrid.PreferredColumnWidth);
+            Assert.Equal(Control.DefaultFont.Height + 3, dataGrid.PreferredRowHeight);
+            Assert.Equal(new Size(130, 80), dataGrid.PreferredSize);
+            Assert.False(dataGrid.ReadOnly);
+            Assert.True(dataGrid.RowHeadersVisible);
+            Assert.Equal(35, dataGrid.RowHeaderWidth);
+            Assert.Equal(SystemColors.ActiveCaption, dataGrid.SelectionBackColor);
+            Assert.Equal(SystemColors.ActiveCaptionText, dataGrid.SelectionForeColor);
+            Assert.Null(dataGrid.Site);
+            Assert.Equal(new Size(130, 80), dataGrid.Size);
+            Assert.Empty(dataGrid.TableStyles);
+            Assert.Same(dataGrid.TableStyles, dataGrid.TableStyles);
+            Assert.Empty(dataGrid.Text);
+            Assert.Equal(0, dataGrid.Top);
+            Assert.NotNull(dataGrid.VertScrollBar);
+            Assert.Same(dataGrid.VertScrollBar, dataGrid.VertScrollBar);
+            Assert.Equal(0, dataGrid.VisibleColumnCount);
+            Assert.Equal(0, dataGrid.VisibleRowCount);
+            Assert.Equal(130, dataGrid.Width);
+        }
+
+        [Fact]
+        public void DataGrid_ColumnStartedEditing_ValidControl_Success()
+        {
+            var dataGrid = new DataGrid();
+            var control = new Control();
+            dataGrid.ColumnStartedEditing(control);
+        }
+
+        [Fact]
+        public void DataGrid_ColumnStartedEditing_NullControl_Nop()
+        {
+            var dataGrid = new DataGrid();
+            dataGrid.ColumnStartedEditing(null);
+        }
+
+        private class SubDataGridTableStyle : DataGridTableStyle
+        {
+            public SubDataGridTableStyle() : base()
+            {
+            }
+
+            public SubDataGridTableStyle(bool isDefaultTableStyle) : base(isDefaultTableStyle)
+            {
+            }
+
+            public SubDataGridTableStyle(CurrencyManager listManager) : base(listManager)
+            {
+            }
+
+            public new bool CanRaiseEvents => base.CanRaiseEvents;
+
+            public new bool DesignMode => base.DesignMode;
+
+            public new EventHandlerList Events => base.Events;
+        }
+
+        private class SubDataGrid : DataGrid
+        {
+            public new Size DefaultMaximumSize => base.DefaultMaximumSize;
+
+            public new Size DefaultMinimumSize => base.DefaultMinimumSize;
+
+            public new Padding DefaultPadding => base.DefaultPadding;
+
+            public new Size DefaultSize => base.DefaultSize;
+
+            public new ScrollBar HorizScrollBar => base.HorizScrollBar;
+
+            public new ScrollBar VertScrollBar => base.VertScrollBar;
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/GlobalUsings.cs b/WTG.System.Windows.Forms.Tests/GlobalUsings.cs
new file mode 100644
index 00000000000..8c927eb747a
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/GlobalUsings.cs
@@ -0,0 +1 @@
+global using Xunit;
\ No newline at end of file
diff --git a/WTG.System.Windows.Forms.Tests/GridColumnStylesCollectionTests.cs b/WTG.System.Windows.Forms.Tests/GridColumnStylesCollectionTests.cs
new file mode 100644
index 00000000000..e7b518b9243
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/GridColumnStylesCollectionTests.cs
@@ -0,0 +1,63 @@
+
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class GridColumnStylesCollectionTests
+    {
+        [Fact]
+        public void GridColumnStylesCollection_Add_DataGridColumnStyle_Success()
+        {
+            var tableStyle = new DataGridTableStyle();
+            GridColumnStylesCollection collection = tableStyle.GridColumnStyles;
+            var style = new SubDataGridColumnStyle();
+            Assert.Equal(0, collection.Add(style));
+            Assert.Same(style, Assert.Single(collection));
+            Assert.Same(tableStyle, style.DataGridTableStyle);
+        }
+
+        private class SubDataGridColumnStyle : DataGridColumnStyle
+        {
+            protected internal override void Abort(int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override Size GetPreferredSize(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetMinimumHeight()
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override int GetPreferredHeight(Graphics g, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+            {
+                throw new NotImplementedException();
+            }
+
+            protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/GridTableStylesCollectionTests.cs b/WTG.System.Windows.Forms.Tests/GridTableStylesCollectionTests.cs
new file mode 100644
index 00000000000..de68d18014d
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/GridTableStylesCollectionTests.cs
@@ -0,0 +1,19 @@
+
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class GridTableStylesCollectionTests
+    {
+        [Fact]
+        public void GridTableStylesCollection_Add_DataGridTableStyle_Success()
+        {
+            var dataGrid = new DataGrid();
+            GridTableStylesCollection collection = dataGrid.TableStyles;
+            var style = new DataGridTableStyle();
+            Assert.Equal(0, collection.Add(style));
+            Assert.Same(style, Assert.Single(collection));
+            Assert.Same(dataGrid, style.DataGrid);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/GridTablesFactoryTests.cs b/WTG.System.Windows.Forms.Tests/GridTablesFactoryTests.cs
new file mode 100644
index 00000000000..a61ce1ded12
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/GridTablesFactoryTests.cs
@@ -0,0 +1,23 @@
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class GridTablesFactoryTests
+    {
+        public static IEnumerable<object[]> CreateGridTables_TestData()
+        {
+            yield return new object[] { null, null, null, null, new DataGridTableStyle[] { null } };
+            var style = new DataGridTableStyle();
+            yield return new object[] { style, new(), string.Empty, new BindingContext(), new DataGridTableStyle[] { style } };
+            yield return new object[] { style, new(), "dataMember", new BindingContext(), new DataGridTableStyle[] { style } };
+        }
+
+        [Theory]
+        [MemberData(nameof(CreateGridTables_TestData))]
+        public void GridTablesFactory_CreateGridTables_Invoke_ReturnsExpected(DataGridTableStyle gridTable, object dataSource, string dataMember, BindingContext bindingManager, DataGridTableStyle[] expected)
+        {
+            Assert.Equal(expected, GridTablesFactory.CreateGridTables(gridTable, dataSource, dataMember, bindingManager));
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/MainMenuTestsTests.cs b/WTG.System.Windows.Forms.Tests/MainMenuTestsTests.cs
new file mode 100644
index 00000000000..516bdb182e5
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/MainMenuTestsTests.cs
@@ -0,0 +1,233 @@
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class MainMenuTestsTests
+    {
+        [Fact]
+        public void MainMenu_Ctor_Default()
+        {
+            var menu = new MainMenu();
+            Assert.Empty(menu.MenuItems);
+            Assert.False(menu.IsParent);
+            Assert.Equal(RightToLeft.Inherit, menu.RightToLeft);
+            Assert.Null(menu.GetForm());
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void MainMenu_Ctor_IContainer()
+        {
+            var container = new Container();
+            var menu = new MainMenu(container);
+            Assert.Empty(menu.MenuItems);
+            Assert.False(menu.IsParent);
+            Assert.Equal(RightToLeft.Inherit, menu.RightToLeft);
+            Assert.Null(menu.GetForm());
+            Assert.Empty(menu.Name);
+            Assert.NotNull(menu.Site);
+            Assert.Equal(container, menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void MainMenu_Ctor_NullContainer_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("container", () => new MainMenu((IContainer)null));
+        }
+
+        public static IEnumerable<object[]> Ctor_MenuItemArray_TestData()
+        {
+            yield return new object[] { null, false };
+            yield return new object[] { Array.Empty<MenuItem>(), false };
+            yield return new object[] { new MenuItem[] { new() }, true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_MenuItemArray_TestData))]
+        public void MainMenu_Ctor_MenuItemArray(MenuItem[] items, bool expectedIsParent)
+        {
+            var menu = new MainMenu(items);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menu.MenuItems.Cast<MenuItem>());
+            for (int i = 0; i < (items?.Length ?? 0); i++)
+            {
+                Assert.Equal(i, menu.MenuItems[i].Index);
+                Assert.Equal(menu, menu.MenuItems[i].Parent);
+            }
+
+            Assert.Equal(expectedIsParent, menu.IsParent);
+            Assert.Equal(RightToLeft.Inherit, menu.RightToLeft);
+            Assert.Null(menu.GetForm());
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void MainMenu_Ctor_NullItemInMenuItemArray_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("item", () => new MainMenu(new MenuItem[] { null }));
+        }
+
+        [Fact]
+        public void MainMenu_GetForm_AddedToForm_ReturnsExpected()
+        {
+            var form = new Form
+            {
+                Menu = new MainMenu()
+            };
+
+            MainMenu menu = form.Menu;
+            Assert.Equal(form, menu.GetForm());
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(RightToLeft), MemberType = typeof(CommonTestHelper))]
+        public void MainMenu_RightToLeft_SetWithoutForm_GetReturnsExpected(RightToLeft value)
+        {
+            var menu = new MainMenu
+            {
+                RightToLeft = value
+            };
+            Assert.Equal(value, menu.RightToLeft);
+        }
+
+        [Theory]
+        [InlineData(RightToLeft.Yes, RightToLeft.Yes)]
+        [InlineData(RightToLeft.No, RightToLeft.No)]
+        [InlineData(RightToLeft.Inherit, RightToLeft.Yes)]
+        public void MainMenu_RightToLeft_SetWithSourceControl_GetReturnsExpected(RightToLeft value, RightToLeft expectedValue)
+        {
+            var form = new Form
+            {
+                Menu = new MainMenu(),
+                RightToLeft = RightToLeft.Yes
+            };
+            MainMenu menu = form.Menu;
+
+            menu.RightToLeft = value;
+            Assert.Equal(expectedValue, menu.RightToLeft);
+        }
+
+        [Fact]
+        public void MainMenu_RightToLeft_SetCreated_GetReturnsExpected()
+        {
+            using (var menu = new MainMenu(new MenuItem[] { new("text") }))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                menu.RightToLeft = RightToLeft.Yes;
+                menu.RightToLeft = RightToLeft.No;
+                Assert.Equal(RightToLeft.No, menu.RightToLeft);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(RightToLeft), MemberType = typeof(CommonTestHelper))]
+        public void MainMenu_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
+        {
+            var menu = new MainMenu();
+            Assert.Throws<InvalidEnumArgumentException>("RightToLeft", () => menu.RightToLeft = value);
+        }
+
+        [Fact]
+        public void MainMenu_OnCollapse_Invoke_Success()
+        {
+            var menu = new MainMenu();
+
+            // No handler.
+            menu.OnCollapse(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menu, sender);
+                callCount++;
+            };
+
+            menu.Collapse += handler;
+            menu.OnCollapse(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menu.Collapse -= handler;
+            menu.OnCollapse(null);
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> CloneMenu_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new("text") } };
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void MainMenu_CloneMenu_Invoke_Success(MenuItem[] items)
+        {
+            var source = new MainMenu(items)
+            {
+                RightToLeft = RightToLeft.No
+            };
+            MainMenu menu = source.CloneMenu();
+            Assert.NotSame(source, menu);
+            Assert.Equal(items.Select(m => m.Name), menu.MenuItems.Cast<MenuItem>().Select(m => m.Name));
+            Assert.Equal(source.IsParent, menu.IsParent);
+            Assert.Equal(RightToLeft.Inherit, menu.RightToLeft);
+            Assert.Null(menu.GetForm());
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void MainMenu_CreateMenuHandle_Invoke_ReturnsExpected()
+        {
+            var menu = new SubMainMenu();
+            Assert.NotEqual(IntPtr.Zero, menu.CreateMenuHandle());
+        }
+
+        [Fact]
+        public void MainMenu_Dispose_HasForm_Success()
+        {
+            var form = new Form
+            {
+                Menu = new MainMenu()
+            };
+
+            MainMenu menu = form.Menu;
+            menu.Dispose();
+            Assert.Null(menu.GetForm());
+            Assert.Null(form.Menu);
+        }
+
+        [Fact]
+        public void MainMenu_Dispose_HasOwnerForm_Success()
+        {
+            var parentForm = new Form { IsMdiContainer = true };
+            var form = new Form
+            {
+                Menu = new MainMenu(),
+                MdiParent = parentForm
+            };
+
+            MainMenu menu = form.MergedMenu;
+            menu.Dispose();
+            Assert.Null(menu.GetForm());
+            Assert.Null(form.Menu);
+        }
+
+        private class SubMainMenu : MainMenu
+        {
+            public new IntPtr CreateMenuHandle() => base.CreateMenuHandle();
+
+            public new void OnCollapse(EventArgs e) => base.OnCollapse(e);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/MenuItemCollectionTests.cs b/WTG.System.Windows.Forms.Tests/MenuItemCollectionTests.cs
new file mode 100644
index 00000000000..2d868289460
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/MenuItemCollectionTests.cs
@@ -0,0 +1,753 @@
+using System.Collections;
+using System.Windows.Forms;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class MenuItemCollectionTests
+    {
+        [Fact]
+        public void MenuItemCollection_Ctor_Menu()
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Single(collection);
+        }
+
+        [Fact]
+        public void MenuItemCollection_IList_Properties_ReturnsExpected()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.False(collection.IsFixedSize);
+            Assert.False(collection.IsReadOnly);
+            Assert.False(collection.IsSynchronized);
+            Assert.Same(collection, collection.SyncRoot);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void MenuItemCollection_Add_String_Success(string caption, string expectedText)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            MenuItem menuItem = collection.Add(caption);
+            Assert.Same(menuItem, Assert.Single(collection));
+            Assert.Equal(expectedText, menuItem.Text);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(menu, menuItem.Parent);
+            Assert.Equal(0, menuItem.Index);
+        }
+
+        public static IEnumerable<object[]> Add_StringEventHandler_TestData()
+        {
+            EventHandler onClick = (sender, e) => { };
+            yield return new object[] { null, null, string.Empty };
+            yield return new object[] { string.Empty, onClick, string.Empty };
+            yield return new object[] { "caption", onClick, "caption" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Add_StringEventHandler_TestData))]
+        public void MenuItemCollection_Add_StringEventHandler_Success(string caption, EventHandler onClick, string expectedText)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            MenuItem menuItem = collection.Add(caption, onClick);
+            Assert.Same(menuItem, Assert.Single(collection));
+            Assert.Same(expectedText, menuItem.Text);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(menu, menuItem.Parent);
+            Assert.Equal(0, menuItem.Index);
+        }
+
+        public static IEnumerable<object[]> Add_StringMenuItemArray_TestData()
+        {
+            yield return new object[] { null, null, string.Empty };
+            yield return new object[] { string.Empty, Array.Empty<MenuItem>(), string.Empty };
+            yield return new object[] { "caption", new MenuItem[] { new MenuItem() }, "caption" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Add_StringMenuItemArray_TestData))]
+        public void MenuItemCollection_Add_StringMenuItemArray_Success(string caption, MenuItem[] items, string expectedText)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            MenuItem menuItem = collection.Add(caption, items);
+            Assert.Same(menuItem, Assert.Single(collection));
+            Assert.Same(expectedText, menuItem.Text);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menuItem.MenuItems.Cast<MenuItem>());
+            Assert.Equal(menu, menuItem.Parent);
+            Assert.Equal(0, menuItem.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_MenuItem_Success()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+
+            var menuItem1 = new MenuItem("text1");
+            Assert.Equal(0, collection.Add(menuItem1));
+            Assert.Same(menuItem1, Assert.Single(collection));
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+
+            var menuItem2 = new MenuItem("text2");
+            Assert.Equal(1, collection.Add(menuItem2));
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem1, collection[0]);
+            Assert.Same(menuItem2, collection[1]);
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+            Assert.Equal(menu, menuItem2.Parent);
+            Assert.Equal(1, menuItem2.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_IndexMenuItem_Success()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+
+            var menuItem1 = new MenuItem("text1");
+            Assert.Equal(0, collection.Add(0, menuItem1));
+            Assert.Same(menuItem1, Assert.Single(collection));
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+
+            var menuItem2 = new MenuItem("text1");
+            Assert.Equal(0, collection.Add(0, menuItem2));
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem2, collection[0]);
+            Assert.Same(menuItem1, collection[1]);
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(1, menuItem1.Index);
+            Assert.Equal(menu, menuItem2.Parent);
+            Assert.Equal(0, menuItem2.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_SelfMenuItem_Nop()
+        {
+            var menuItem = new MenuItem("text", Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menuItem);
+            Assert.Empty(collection);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_AlreadyInSameCollection_Success()
+        {
+            var menuItem1 = new MenuItem();
+            var menuItem2 = new MenuItem();
+            var parent = new MenuItem("text", Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(parent)
+            {
+                menuItem1,
+                menuItem2
+            };
+
+            Assert.Equal(0, collection.Add(0, menuItem2));
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem2, collection[0]);
+            Assert.Same(menuItem1, collection[1]);
+            Assert.Equal(parent, menuItem1.Parent);
+            Assert.Equal(1, menuItem1.Index);
+            Assert.Equal(parent, menuItem2.Parent);
+            Assert.Equal(0, menuItem2.Index);
+
+            Assert.Equal(1, collection.Add(2, menuItem2));
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem1, collection[0]);
+            Assert.Same(menuItem2, collection[1]);
+            Assert.Equal(parent, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+            Assert.Equal(parent, menuItem2.Parent);
+            Assert.Equal(1, menuItem2.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_AlreadyInDifferentCollection_Success()
+        {
+            var oldParent = new MenuItem("text", Array.Empty<MenuItem>());
+            var oldCollection = new Menu.MenuItemCollection(oldParent);
+            var newParent = new MenuItem("text", Array.Empty<MenuItem>());
+            var newCollection = new Menu.MenuItemCollection(newParent);
+
+            var menuItem = new MenuItem();
+            oldCollection.Add(menuItem);
+
+            Assert.Equal(0, newCollection.Add(menuItem));
+            Assert.Empty(oldCollection);
+            Assert.Same(menuItem, Assert.Single(newCollection));
+            Assert.Equal(newParent, menuItem.Parent);
+            Assert.Equal(0, menuItem.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_MenuItemToCreatedMenu_Success()
+        {
+            using (var menu = new SubMenu(Array.Empty<MenuItem>()))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+
+                var collection = new Menu.MenuItemCollection(menu);
+
+                var menuItem1 = new MenuItem("text1");
+                Assert.Equal(0, collection.Add(menuItem1));
+                Assert.Same(menuItem1, Assert.Single(collection));
+                Assert.Equal(menu, menuItem1.Parent);
+                Assert.Equal(0, menuItem1.Index);
+
+                var menuItem2 = new MenuItem("text2");
+                Assert.Equal(1, collection.Add(menuItem2));
+                Assert.Equal(2, collection.Count);
+                Assert.Same(menuItem1, collection[0]);
+                Assert.Same(menuItem2, collection[1]);
+                Assert.Equal(menu, menuItem1.Parent);
+                Assert.Equal(0, menuItem1.Index);
+                Assert.Equal(menu, menuItem2.Parent);
+                Assert.Equal(1, menuItem2.Index);
+            }
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_CreatedMenuItemToMenu_Success()
+        {
+            var menuItem = new MenuItem("text1");
+            using (var otherMenu = new SubMenu(new MenuItem[] { menuItem }))
+            {
+                Assert.NotEqual(IntPtr.Zero, otherMenu.Handle);
+
+                var menu = new SubMenu(Array.Empty<MenuItem>());
+                var collection = new Menu.MenuItemCollection(menu);
+
+                Assert.Equal(0, collection.Add(menuItem));
+                Assert.Same(menuItem, Assert.Single(collection));
+                Assert.Equal(menu, menuItem.Parent);
+                Assert.Equal(0, menuItem.Index);
+            }
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_NullMenuItem_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentNullException>("item", () => collection.Add((MenuItem)null));
+            Assert.Throws<ArgumentNullException>("item", () => collection.Add(0, null));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_SelfWithParent_ThrowsArgumentException()
+        {
+            var menuItem = new MenuItem("text", Array.Empty<MenuItem>());
+            var parent = new MenuItem("parent", new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menuItem);
+            Assert.Throws<ArgumentException>("item", () => collection.Add(menuItem));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_ParentWithGrandparent_ThrowsArgumentException()
+        {
+            var menuItem = new MenuItem();
+            var parent = new MenuItem("parent", new MenuItem[] { menuItem });
+            var grandparent = new MenuItem("grandparent", new MenuItem[] { parent });
+
+            var oldCollection = new Menu.MenuItemCollection(menuItem);
+            Assert.Throws<ArgumentException>("item", () => oldCollection.Add(parent));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void MenuItemCollection_Add_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Add(index, new MenuItem()));
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(2)]
+        public void MenuItemCollection_Add_AlreadyInCollection_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var menuItem = new MenuItem();
+            var parent = new MenuItem("text", Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(parent)
+            {
+                menuItem
+            };
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Add(index, menuItem));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Add_IListMenuItem_Success()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+
+            var menuItem1 = new MenuItem("text1");
+            Assert.Equal(0, collection.Add(menuItem1));
+            Assert.Same(menuItem1, Assert.Single(collection));
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+
+            var menuItem2 = new MenuItem("text2");
+            Assert.Equal(1, collection.Add(menuItem2));
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem1, collection[0]);
+            Assert.Same(menuItem2, collection[1]);
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+            Assert.Equal(menu, menuItem2.Parent);
+            Assert.Equal(1, menuItem2.Index);
+        }
+
+        [Theory]
+        [InlineData("value")]
+        [InlineData(null)]
+        public void MenuItemCollection_Add_IListNotMenuItem_ThrowsArgumentException(object value)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentException>("value", () => collection.Add(value));
+        }
+
+        public static IEnumerable<object[]> AddRange_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem(), new MenuItem() } };
+        }
+
+        [Theory]
+        [MemberData(nameof(AddRange_TestData))]
+        public void MenuItemCollection_AddRange_Invoke_Success(MenuItem[] items)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.AddRange(items);
+            Assert.Equal(items.Length, collection.Count);
+            Assert.Equal(items, collection.Cast<MenuItem>());
+        }
+
+        [Fact]
+        public void MenuItemCollection_AddRange_NullItems_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentNullException>("items", () => collection.AddRange(null));
+        }
+
+        [Fact]
+        public void MenuItemCollection_AddRange_NullValueInItems_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentNullException>("item", () => collection.AddRange(new MenuItem[] { null }));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Clear_InvokeOnMenu_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.Clear();
+            Assert.Empty(collection);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(-1, menuItem.Index);
+
+            collection.Clear();
+            Assert.Empty(collection);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Clear_InvokeOnMenuItem_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new MenuItem("text", new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.Clear();
+            Assert.Empty(collection);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(-1, menuItem.Index);
+
+            collection.Clear();
+            Assert.Empty(collection);
+        }
+
+        [Fact]
+        public void MenuItemCollection_CopyTo_NotEmpty_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu)
+            {
+                menuItem
+            };
+            var array = new object[] { 1, 2, 3 };
+            collection.CopyTo(array, 1);
+            Assert.Equal(new object[] { 1, menuItem, 3 }, array);
+        }
+
+        [Fact]
+        public void MenuItemCollection_CopyTo_Empty_Nop()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            var array = new object[] { 1, 2, 3 };
+            collection.CopyTo(array, 1);
+            Assert.Equal(new object[] { 1, 2, 3 }, array);
+        }
+
+        public static IEnumerable<object[]> Contains_TestData()
+        {
+            var menuItem = new MenuItem();
+            yield return new object[] { new SubMenu(new MenuItem[] { menuItem }), menuItem, true };
+            yield return new object[] { new SubMenu(new MenuItem[] { new MenuItem() }), new MenuItem(), false };
+            yield return new object[] { new SubMenu(new MenuItem[] { new MenuItem() }), null, false };
+        }
+
+        [Theory]
+        [MemberData(nameof(Contains_TestData))]
+        public void MenuItemCollection_Contains_Invoke_ReturnsExpected(Menu menu, MenuItem value, bool expected)
+        {
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.Contains(value));
+        }
+
+        [Theory]
+        [MemberData(nameof(Contains_TestData))]
+        public void MenuItemCollection_Contains_IListInvoke_ReturnsExpected(Menu menu, MenuItem value, bool expected)
+        {
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.Contains(value));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Contains_IListNotMenuItem_ReturnsMinusOne()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.False(collection.Contains("value"));
+        }
+
+        [Theory]
+        [InlineData(null, false)]
+        [InlineData("", false)]
+        [InlineData("name", true)]
+        [InlineData("NAME", true)]
+        [InlineData("noSuchName", false)]
+        public void MenuItemCollection_ContainsKey_Invoke_ReturnsExpected(string key, bool expected)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem { Name = "name" } });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.ContainsKey(key));
+        }
+
+        public static IEnumerable<object[]> Find_TestData()
+        {
+            yield return new object[] { new MenuItem[] { new MenuItem() }, "noSuchKey", false, Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, "noSuchKey", true, Array.Empty<MenuItem>() };
+
+            foreach (bool searchAllChildren in new bool[] { true, false })
+            {
+                var menuItem1 = new MenuItem { Name = "name" };
+                var menuItem2 = new MenuItem { Name = "NAME" };
+                var menuItem3 = new MenuItem { Name = "otherName" };
+                var menuItem4 = new MenuItem { Name = "name" };
+                yield return new object[] { new MenuItem[] { menuItem1, menuItem2, menuItem3 }, "name", searchAllChildren, new MenuItem[] { menuItem1, menuItem2 } };
+            }
+
+            yield return new object[] { new MenuItem[] { new MenuItem { Name = "name" } }, "noSuchName", true, Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem { Name = "name" } }, "noSuchName", false, Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem("text", new MenuItem[] { new MenuItem { Name = "name2" } }) { Name = "name" }, }, "noSuchName", true, Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem("text", new MenuItem[] { new MenuItem { Name = "name2" } }) { Name = "name" }, }, "noSuchName", false, Array.Empty<MenuItem>() };
+
+            var menuItemChild = new MenuItem { Name = "name" };
+            yield return new object[] { new MenuItem[] { new MenuItem("text", new MenuItem[] { menuItemChild }) }, "name", true, new MenuItem[] { menuItemChild } };
+            yield return new object[] { new MenuItem[] { new MenuItem("text", new MenuItem[] { new MenuItem { Name = "name" } }) }, "name", false, Array.Empty<MenuItem>() };
+        }
+
+        [Theory]
+        [MemberData(nameof(Find_TestData))]
+        public void MenuItemCollection_Find_Invoke_ReturnsExpected(MenuItem[] items, string key, bool searchAllChildren, MenuItem[] expected)
+        {
+            var menu = new SubMenu(items);
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.Find(key, searchAllChildren));
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        public void MenuItemCollection_Find_NullOrEmptyKey_ThrowsArgumentNullException(string key)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: false));
+        }
+
+        public static IEnumerable<object[]> IndexOf_TestData()
+        {
+            var menuItem = new MenuItem();
+            yield return new object[] { new SubMenu(new MenuItem[] { menuItem }), menuItem, 0 };
+            yield return new object[] { new SubMenu(new MenuItem[] { new MenuItem() }), new MenuItem(), -1 };
+            yield return new object[] { new SubMenu(new MenuItem[] { new MenuItem() }), null, -1 };
+        }
+
+        [Theory]
+        [MemberData(nameof(IndexOf_TestData))]
+        public void MenuItemCollection_IndexOf_Invoke_ReturnsExpected(Menu menu, MenuItem value, int expected)
+        {
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.IndexOf(value));
+        }
+
+        [Theory]
+        [MemberData(nameof(IndexOf_TestData))]
+        public void MenuItemCollection_IndexOf_IListInvoke_ReturnsExpected(Menu menu, MenuItem value, int expected)
+        {
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.IndexOf(value));
+        }
+
+        [Fact]
+        public void MenuItemCollection_IndexOf_IListNotMenuItem_ReturnsMinusOne()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(-1, collection.IndexOf("value"));
+        }
+
+        [Theory]
+        [InlineData(null, -1)]
+        [InlineData("", -1)]
+        [InlineData("name", 0)]
+        [InlineData("NAME", 0)]
+        [InlineData("noSuchName", -1)]
+        public void MenuItemCollection_IndexOfKey_Invoke_ReturnsExpected(string key, int expected)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem { Name = "name" } });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected, collection.IndexOfKey(key));
+
+            // Call again to validate caching behaviour.
+            Assert.Equal(expected, collection.IndexOfKey(key));
+            Assert.Equal(-1, collection.IndexOfKey("noSuchKey"));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Insert_IListInvoke_Success()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+
+            var menuItem1 = new MenuItem("text1");
+            collection.Insert(0, menuItem1);
+            Assert.Same(menuItem1, Assert.Single(collection));
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(0, menuItem1.Index);
+
+            var menuItem2 = new MenuItem("text1");
+            collection.Insert(0, menuItem2);
+            Assert.Equal(2, collection.Count);
+            Assert.Same(menuItem2, collection[0]);
+            Assert.Same(menuItem1, collection[1]);
+            Assert.Equal(menu, menuItem1.Parent);
+            Assert.Equal(1, menuItem1.Index);
+            Assert.Equal(menu, menuItem2.Parent);
+            Assert.Equal(0, menuItem2.Index);
+        }
+
+        [Theory]
+        [InlineData("value")]
+        [InlineData(null)]
+        public void MenuItemCollection_Insert_IListNotMenuItem_ThrowsArgumentException(object value)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentException>("value", () => collection.Insert(0, value));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Item_GetValidIndex_ReturnsExpected()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(menuItem, collection[0]);
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void MenuItemCollection_Item_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Item_IListGetValidIndex_ReturnsExpected()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(menuItem, collection[0]);
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void MenuItemCollection_Item_IListGetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(0)]
+        [InlineData(1)]
+        public void MenuItemCollection_Item_IListSet_ThrowsNotSupportedException(int index)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            IList collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<NotSupportedException>(() => collection[index] = new MenuItem());
+        }
+
+        [Theory]
+        [InlineData(null, false)]
+        [InlineData("", false)]
+        [InlineData("name", true)]
+        [InlineData("NAME", true)]
+        [InlineData("noSuchName", false)]
+        public void MenuItemCollection_Item_GetKey_ReturnsExpected(string key, bool expected)
+        {
+            var menuItem = new MenuItem { Name = "name" };
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Equal(expected ? menuItem : null, collection[key]);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Remove_MenuItem_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.Remove(menuItem);
+            Assert.Empty(collection);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(-1, menuItem.Index);
+        }
+
+        [Fact]
+        public void MenuItemCollection_Remove_DifferentOwnerMenuMenuItem_Nop()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+
+            var otherMenuItem = new MenuItem();
+            var otherMenu = new SubMenu(new MenuItem[] { otherMenuItem });
+            collection.Remove(otherMenuItem);
+            Assert.Equal(menuItem, Assert.Single(collection));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Remove_NoMenuMenuItem_Nop()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.Remove(new MenuItem());
+            Assert.Equal(menuItem, Assert.Single(collection));
+        }
+
+        [Fact]
+        public void MenuItemCollection_Remove_IListMenuItem_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            IList collection = new Menu.MenuItemCollection(menu);
+            collection.Remove(menuItem);
+            Assert.Empty(collection);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(-1, menuItem.Index);
+        }
+
+        [Theory]
+        [InlineData("value")]
+        [InlineData(null)]
+        public void MenuItemCollection_Remove_IListNotMenuItem_Nop(object value)
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            IList collection = new Menu.MenuItemCollection(menu);
+            collection.Remove(value);
+            Assert.Equal(menuItem, Assert.Single(collection));
+        }
+
+        [Fact]
+        public void MenuItemCollection_RemoveAt_Invoke_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.RemoveAt(0);
+
+            Assert.Empty(collection);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(-1, menuItem.Index);
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void MenuItemCollection_RemoveAt_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            var collection = new Menu.MenuItemCollection(menu);
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
+        }
+
+        [Theory]
+        [InlineData("name")]
+        [InlineData("NAME")]
+        public void MenuItemCollection_RemoveByKey_KeyExists_Success(string key)
+        {
+            var menuItem = new MenuItem { Name = "name" };
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.RemoveByKey(key);
+            Assert.Empty(collection);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("noSuchName")]
+        public void MenuItemCollection_RemoveByKey_NoSuchKey_Nop(string key)
+        {
+            var menuItem = new MenuItem { Name = "name" };
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var collection = new Menu.MenuItemCollection(menu);
+            collection.RemoveByKey(key);
+            Assert.Equal(menuItem, Assert.Single(collection));
+        }
+
+        private class SubMenu : Menu
+        {
+            public SubMenu(params MenuItem[] items) : base(items)
+            {
+            }
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/MenuItemTests.cs b/WTG.System.Windows.Forms.Tests/MenuItemTests.cs
new file mode 100644
index 00000000000..e28ef88f1ff
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/MenuItemTests.cs
@@ -0,0 +1,1827 @@
+using System.ComponentModel;
+using System.Windows.Forms;
+using Moq;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class MenuItemTests
+    {
+        [Fact]
+        public void MenuItem_Ctor_Default()
+        {
+            var menuItem = new MenuItem();
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.False(menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(Shortcut.None, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Empty(menuItem.Text);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void MenuItem_Ctor_String(string text, string expectedText)
+        {
+            var menuItem = new MenuItem(text);
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.False(menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(Shortcut.None, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Equal(expectedText, menuItem.Text);
+        }
+
+        public static IEnumerable<object[]> Ctor_String_EventHandler_TestData()
+        {
+            EventHandler onClick = (sender, e) => { };
+            yield return new object[] { null, null, string.Empty };
+            yield return new object[] { string.Empty, onClick, string.Empty };
+            yield return new object[] { "text", onClick, "text" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_String_EventHandler_TestData))]
+        public void MenuItem_Ctor_String_EventHandler(string text, EventHandler onClick, string expectedText)
+        {
+            var menuItem = new MenuItem(text, onClick);
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.False(menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(Shortcut.None, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Same(expectedText, menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_Ctor_String_EventHandler_OnClick()
+        {
+            SubMenuItem menuItem = null;
+            int callCount = 0;
+            EventHandler onClick = (sender, e) =>
+            {
+                Assert.Same(menuItem, sender);
+                callCount++;
+            };
+            menuItem = new SubMenuItem("text", onClick);
+            menuItem.OnClick(null);
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> Ctor_String_EventHandler_Shortcut_TestData()
+        {
+            EventHandler onClick = (sender, e) => { };
+            yield return new object[] { null, null, Shortcut.None, string.Empty };
+            yield return new object[] { string.Empty, onClick, (Shortcut)(Shortcut.None - 1), string.Empty };
+            yield return new object[] { "text", onClick, Shortcut.CtrlA, "text" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_String_EventHandler_Shortcut_TestData))]
+        public void MenuItem_Ctor_String_EventHandler_Shortcut(string text, EventHandler onClick, Shortcut shortcut, string expectedText)
+        {
+            var menuItem = new MenuItem(text, onClick, shortcut);
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.False(menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Empty(menuItem.MenuItems);
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(shortcut, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Same(expectedText, menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_Ctor_String_EventHandler_Shortcut_OnClick()
+        {
+            SubMenuItem menuItem = null;
+            int callCount = 0;
+            EventHandler onClick = (sender, e) =>
+            {
+                Assert.Same(menuItem, sender);
+                callCount++;
+            };
+            menuItem = new SubMenuItem("text", onClick, Shortcut.None);
+            menuItem.OnClick(null);
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> Ctor_String_MenuItemArray_TestData()
+        {
+            yield return new object[] { null, null, false, string.Empty };
+            yield return new object[] { string.Empty, Array.Empty<MenuItem>(), false, string.Empty };
+            yield return new object[] { "text", new MenuItem[] { new MenuItem() }, true, "text" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_String_MenuItemArray_TestData))]
+        public void MenuItem_Ctor_String_MenuItemArray(string text, MenuItem[] items, bool expectedIsParent, string expectedText)
+        {
+            var menuItem = new MenuItem(text, items);
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(expectedIsParent, menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menuItem.MenuItems.Cast<MenuItem>());
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(Shortcut.None, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Same(expectedText, menuItem.Text);
+        }
+
+        public static IEnumerable<object[]> Ctor_MergeType_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray_TestData()
+        {
+            EventHandler onClick = (sender, e) => { };
+            EventHandler onPopup = (sender, e) => { };
+            EventHandler onSelect = (sender, e) => { };
+
+            yield return new object[] { (MenuMerge)(MenuMerge.Add - 1), -1, (Shortcut)(Shortcut.None - 1), null, null, null, null, null, false, string.Empty };
+            yield return new object[] { MenuMerge.Add, 0, Shortcut.None, string.Empty, onClick, onPopup, onSelect, Array.Empty<MenuItem>(), false, string.Empty };
+            yield return new object[] { MenuMerge.MergeItems, 1, Shortcut.CtrlA, "text", onClick, onPopup, onSelect, new MenuItem[] { new MenuItem() }, true, "text" };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_MergeType_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray_TestData))]
+        public void MenuItem_Ctor_MenuMerge_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray(MenuMerge mergeType, int mergeOrder, Shortcut shortcut, string text, EventHandler onClick, EventHandler onPopup, EventHandler onSelect, MenuItem[] items, bool expectedIsParent, string expectedText)
+        {
+            var menuItem = new MenuItem(mergeType, mergeOrder, shortcut, text, onClick, onPopup, onSelect, items);
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(expectedIsParent, menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menuItem.MenuItems.Cast<MenuItem>());
+            Assert.Equal(mergeOrder, menuItem.MergeOrder);
+            Assert.Equal(mergeType, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(shortcut, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Same(expectedText, menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_Ctor_MenuMerge_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray_OnClick()
+        {
+            SubMenuItem menuItem = null;
+            int callCount = 0;
+            EventHandler onClick = (sender, e) =>
+            {
+                Assert.Same(menuItem, sender);
+                callCount++;
+            };
+            menuItem = new SubMenuItem(MenuMerge.Add, 0, Shortcut.None, string.Empty, onClick, null, null, Array.Empty<MenuItem>());
+            menuItem.OnClick(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_Ctor_MenuMerge_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray_OnPopup()
+        {
+            SubMenuItem menuItem = null;
+            int callCount = 0;
+            EventHandler onPopup = (sender, e) =>
+            {
+                Assert.Same(menuItem, sender);
+                callCount++;
+            };
+            menuItem = new SubMenuItem(MenuMerge.Add, 0, Shortcut.None, string.Empty, null, onPopup, null, Array.Empty<MenuItem>());
+            menuItem.OnPopup(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_Ctor_MenuMerge_Int_Shortcut_String_EventHandler_EventHandler_EventHandler_MenuItemArray_OnSelect()
+        {
+            SubMenuItem menuItem = null;
+            int callCount = 0;
+            EventHandler onSelect = (sender, e) =>
+            {
+                Assert.Same(menuItem, sender);
+                callCount++;
+            };
+            menuItem = new SubMenuItem(MenuMerge.Add, 0, Shortcut.None, string.Empty, null, null, onSelect, Array.Empty<MenuItem>());
+            menuItem.OnSelect(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_BarBreak_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                BarBreak = value
+            };
+            Assert.Equal(value, menuItem.BarBreak);
+        }
+
+        [Fact]
+        public void MenuItem_BarBreak_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.BarBreak);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.BarBreak = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_Break_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                Break = value
+            };
+            Assert.Equal(value, menuItem.Break);
+        }
+
+        [Fact]
+        public void MenuItem_Break_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Break);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Break = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_Checked_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                Checked = value
+            };
+            Assert.Equal(value, menuItem.Checked);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_Checked_SetWithParent_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            menuItem.Checked = value;
+            Assert.Equal(value, menuItem.Checked);
+        }
+
+        [Fact]
+        public void MenuItem_Checked_SetWithMainMenuParent_ThrowsArgumentException()
+        {
+            var menuItem = new MenuItem();
+            var menu = new MainMenu(new MenuItem[] { menuItem });
+            Assert.Throws<ArgumentException>("value", () => menuItem.Checked = true);
+            Assert.False(menuItem.Checked);
+
+            menuItem.Checked = false;
+            Assert.False(menuItem.Checked);
+        }
+
+        [Fact]
+        public void MenuItem_Checked_SetWithChildren_ThrowsArgumentException()
+        {
+            var menuItem = new MenuItem("text", new MenuItem[] { new MenuItem() });
+            Assert.Throws<ArgumentException>("value", () => menuItem.Checked = true);
+            Assert.False(menuItem.Checked);
+
+            menuItem.Checked = false;
+            Assert.False(menuItem.Checked);
+        }
+
+        [Fact]
+        public void MenuItem_Checked_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Checked);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Checked = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_DefaultItem_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                DefaultItem = value
+            };
+            Assert.Equal(value, menuItem.DefaultItem);
+        }
+
+        [Fact]
+        public void MenuItem_DefaultItem_SetWithParent_GetReturnsExpected()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            menuItem.DefaultItem = true;
+            Assert.True(menuItem.DefaultItem);
+
+            // Set same.
+            menuItem.DefaultItem = true;
+            Assert.True(menuItem.DefaultItem);
+
+            menuItem.DefaultItem = false;
+            Assert.False(menuItem.DefaultItem);
+
+            // Set same.
+            menuItem.DefaultItem = false;
+            Assert.False(menuItem.DefaultItem);
+        }
+
+        [Fact]
+        public void MenuItem_DefaultItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DefaultItem);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DefaultItem = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_Enabled_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                Enabled = value
+            };
+            Assert.Equal(value, menuItem.Enabled);
+        }
+
+        [Fact]
+        public void MenuItem_Enabled_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Enabled);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Enabled = true);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        public void MenuItem_Index_SetWithParent_GetReturnsExpected(int value)
+        {
+            var menuItem1 = new MenuItem();
+            var menuItem2 = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem1, menuItem2 });
+            menuItem1.Index = value;
+            Assert.Equal(value, menuItem1.Index);
+            if (value == 0)
+            {
+                Assert.Equal(new MenuItem[] { menuItem1, menuItem2 }, menu.MenuItems.Cast<MenuItem>());
+            }
+            else
+            {
+                Assert.Equal(new MenuItem[] { menuItem2, menuItem1 }, menu.MenuItems.Cast<MenuItem>());
+            }
+        }
+
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(1)]
+        public void MenuItem_Index_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => menuItem.Index = value);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void MenuItem_Index_SetWithoutParent_Nop(int value)
+        {
+            var menuItem = new MenuItem
+            {
+                Index = value
+            };
+            Assert.Equal(-1, menuItem.Index);
+        }
+
+        public static IEnumerable<object[]> IsParent_TestData()
+        {
+            yield return new object[] { new MenuItem { MdiList = true }, new SubMenu(), true };
+            yield return new object[] { new MenuItem { MdiList = true }, null, false };
+            yield return new object[] { new MenuItem { MdiList = false }, new SubMenu(), false };
+            yield return new object[] { new MenuItem { MdiList = false }, new MenuItem(), false };
+            yield return new object[] { new MenuItem { MdiList = false }, null, false };
+
+            foreach (bool mdiList in new bool[] { true, false })
+            {
+                yield return new object[] { new MenuItem { MdiList = mdiList }, new MenuItem(), false };
+                yield return new object[] { new MenuItem { MdiList = mdiList }, null, false };
+                yield return new object[] { new MenuItem("text", new MenuItem[] { new MenuItem() }) { MdiList = mdiList }, null, true };
+            }
+
+            var disposedItem = new MenuItem("text", Array.Empty<MenuItem>());
+            disposedItem.Dispose();
+            yield return new object[] { disposedItem, new SubMenu(), false };
+
+            yield return new object[] { new MenuItem { MdiList = true }, new MainMenu(), true };
+
+            var nonMdiForm = new Form { Menu = new MainMenu() };
+            yield return new object[] { new MenuItem { MdiList = true }, nonMdiForm.Menu, true };
+
+            var formWithNoMdiChildren = new Form { Menu = new MainMenu() };
+            formWithNoMdiChildren.Controls.Add(new MdiClient());
+            yield return new object[] { new MenuItem { MdiList = true }, formWithNoMdiChildren.Menu, true };
+
+            var formWithMdiChildren = new Form { Menu = new MainMenu() };
+            var client = new MdiClient();
+            formWithMdiChildren.Controls.Add(client);
+            client.Controls.Add(new Form { MdiParent = formWithMdiChildren });
+            yield return new object[] { new MenuItem { MdiList = true }, formWithMdiChildren.Menu, true };
+        }
+
+        [Theory]
+        [MemberData(nameof(IsParent_TestData))]
+        public void MenuItem_IsParent_HasParent_ReturnsExpected(MenuItem menuItem, Menu parent, bool expected)
+        {
+            parent?.MenuItems.Add(menuItem);
+            Assert.Equal(expected, menuItem.IsParent);
+        }
+
+        [Fact]
+        public void MenuItem_IsParent_MdiSeparator_ReturnsFalse()
+        {
+            var parentForm = new Form { Menu = new MainMenu() };
+            var parentFormClient = new MdiClient();
+            parentForm.Controls.Add(parentFormClient);
+            parentFormClient.Controls.Add(new Form { MdiParent = parentForm });
+            var menuItem = new SubMenuItem("text", new MenuItem[] { new MenuItem() }) { MdiList = true };
+            var parentMenuItem = new MenuItem("parent", new MenuItem[] { menuItem });
+            parentForm.Menu.MenuItems.Add(parentMenuItem);
+
+            // Has a normal child and a MDI item.
+            menuItem.OnPopup(null);
+            Assert.True(menuItem.IsParent);
+
+            // Has only MDI items.
+            menuItem.MenuItems.RemoveAt(0);
+            Assert.Equal("-", Assert.Single(menuItem.MenuItems.Cast<MenuItem>()).Text);
+            Assert.True(menuItem.IsParent);
+
+            // Parent form does not have MDI forms.
+            parentForm.IsMdiContainer = false;
+            Assert.Equal("-", Assert.Single(menuItem.MenuItems.Cast<MenuItem>()).Text);
+            Assert.False(menuItem.IsParent);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_MdiList_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                MdiList = value
+            };
+            Assert.Equal(value, menuItem.MdiList);
+        }
+
+        [Fact]
+        public void MenuItem_MdiList_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MdiList);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MdiList = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetIntTheoryData))]
+        public void MenuItem_MergeOrder_Set_GetReturnsExpected(int value)
+        {
+            var menuItem = new MenuItem
+            {
+                MergeOrder = value
+            };
+            Assert.Equal(value, menuItem.MergeOrder);
+        }
+
+        [Fact]
+        public void MenuItem_MergeOrder_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MergeOrder);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MergeOrder = 1);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryData), typeof(MenuMerge))]
+        public void MenuItem_MergeType_Set_GetReturnsExpected(MenuMerge value)
+        {
+            var menuItem = new MenuItem
+            {
+                MergeType = value
+            };
+            Assert.Equal(value, menuItem.MergeType);
+        }
+
+        [Fact]
+        public void MenuItem_MergeType_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MergeType);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MergeType = MenuMerge.Add);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetEnumTypeTheoryDataInvalid), typeof(MenuMerge))]
+        public void MenuItem_MergeType_SetInvalid_ThrowsInvalidEnumArgumentException(MenuMerge value)
+        {
+            var menuItem = new MenuItem();
+            Assert.Throws<InvalidEnumArgumentException>("value", () => menuItem.MergeType = value);
+        }
+
+        [Theory]
+        [InlineData("", '\0')]
+        [InlineData("text", '\0')]
+        [InlineData("&&abc", '\0')]
+        [InlineData("&abc", 'A')]
+        [InlineData("&", '\0')]
+        [InlineData("&&", '\0')]
+        public void MenuItem_Mnemonic_Get_ReturnsExpected(string text, char expected)
+        {
+            var menuItem = new MenuItem(text);
+            Assert.Equal(expected, menuItem.Mnemonic);
+        }
+
+        [Fact]
+        public void MenuItem_Mneumonic_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Mnemonic);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_OwnerDraw_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                OwnerDraw = value
+            };
+            Assert.Equal(value, menuItem.OwnerDraw);
+        }
+
+        [Fact]
+        public void MenuItem_OwnerDraw_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OwnerDraw);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OwnerDraw = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_RadioCheck_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                RadioCheck = value
+            };
+            Assert.Equal(value, menuItem.RadioCheck);
+        }
+
+        [Fact]
+        public void MenuItem_RadioCheck_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.RadioCheck);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.RadioCheck = true);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_ShowShortcut_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                ShowShortcut = value
+            };
+            Assert.Equal(value, menuItem.ShowShortcut);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_ShowShortcut_SetCreated_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem();
+            using (var menu = new SubMenu(new MenuItem[] { menuItem }))
+            {
+                menuItem.ShowShortcut = value;
+                Assert.Equal(value, menuItem.ShowShortcut);
+            }
+        }
+
+        [Fact]
+        public void MenuItem_ShowShortcut_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.ShowShortcut);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.ShowShortcut = true);
+        }
+
+        [Theory]
+        [InlineData(Shortcut.None)]
+        [InlineData(Shortcut.Ctrl0)]
+        public void MenuItem_Shortcut_Set_GetReturnsExpected(Shortcut value)
+        {
+            var menuItem = new MenuItem
+            {
+                Shortcut = value
+            };
+            Assert.Equal(value, menuItem.Shortcut);
+        }
+
+        [Theory]
+        [InlineData(Shortcut.None)]
+        [InlineData(Shortcut.Ctrl0)]
+        public void MenuItem_Shortcut_SetCreated_GetReturnsExpected(Shortcut value)
+        {
+            var menuItem = new MenuItem();
+            using (var menu = new SubMenu(new MenuItem[] { menuItem }))
+            {
+                menuItem.Shortcut = value;
+                Assert.Equal(value, menuItem.Shortcut);
+            }
+        }
+
+        [Theory]
+        [InlineData((Shortcut)(Shortcut.None - 1))]
+        public void MenuItem_Shortcut_SetInvalid_ThrowsInvalidEnumArgumentException(Shortcut value)
+        {
+            var menuItem = new MenuItem();
+            Assert.Throws<InvalidEnumArgumentException>("value", () => menuItem.Shortcut = value);
+        }
+
+        [Fact]
+        public void MenuItem_Shortcut_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Shortcut);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Shortcut = Shortcut.None);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void MenuItem_Text_Set_GetReturnsExpected(string value, string expected)
+        {
+            var menuItem = new MenuItem
+            {
+                Text = value
+            };
+            Assert.Equal(expected, menuItem.Text);
+
+            // Set same.
+            menuItem.Text = value;
+            Assert.Equal(expected, menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_Text_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Text);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Text = string.Empty);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_Visible_Set_GetReturnsExpected(bool value)
+        {
+            var menuItem = new MenuItem
+            {
+                Visible = value
+            };
+            Assert.Equal(value, menuItem.Visible);
+
+            // Set same.
+            menuItem.Visible = value;
+            Assert.Equal(value, menuItem.Visible);
+
+            // Set different.
+            menuItem.Visible = !value;
+            Assert.Equal(!value, menuItem.Visible);
+        }
+
+        [Fact]
+        public void MenuItem_Visible_SetWithMainMenuParent_GetReturnsExpected()
+        {
+            var menuItem = new MenuItem();
+            var menu = new MainMenu(new MenuItem[] { menuItem });
+            menuItem.Visible = false;
+            Assert.False(menuItem.Visible);
+
+            menuItem.Visible = true;
+            Assert.True(menuItem.Visible);
+        }
+
+        [Fact]
+        public void MenuItem_Visible_SetWithHandle_GetReturnsExpected()
+        {
+            var menuItem = new MenuItem();
+            using (var menu = new SubMenu(new MenuItem[] { menuItem }))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                menuItem.Visible = false;
+                Assert.False(menuItem.Visible);
+
+                menuItem.Visible = true;
+                Assert.True(menuItem.Visible);
+            }
+        }
+
+        [Fact]
+        public void MenuItem_Visible_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Visible);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Visible = true);
+        }
+
+        [Fact]
+        public void MenuItem_MenuID_Get_ReturnsExpected()
+        {
+            var menuItem = new SubMenuItem();
+            Assert.NotEqual(0, menuItem.MenuID);
+        }
+
+        [Fact]
+        public void MenuItem_MenuID_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MenuID);
+        }
+
+        [Fact]
+        public void MenuItem_OnClick_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnClick(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Click += handler;
+            menuItem.OnClick(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Click -= handler;
+            menuItem.OnClick(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnClick_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnClick(null));
+        }
+
+        [Fact]
+        public void MenuItem_Click_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            EventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Click += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Click -= handler);
+        }
+
+        [Fact]
+        public void MenuItem_OnDrawItem_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnDrawItem(null);
+
+            // Handler.
+            int callCount = 0;
+            DrawItemEventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.DrawItem += handler;
+            menuItem.OnDrawItem(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.DrawItem -= handler;
+            menuItem.OnDrawItem(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnDrawItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnDrawItem(null));
+        }
+
+        [Fact]
+        public void MenuItem_DrawItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            DrawItemEventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DrawItem += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.DrawItem -= handler);
+        }
+
+        [Fact]
+        public void MenuItem_OnInitMenuPopup_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnInitMenuPopup(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Popup += handler;
+            menuItem.OnInitMenuPopup(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Popup -= handler;
+            menuItem.OnInitMenuPopup(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnInitMenuPopup_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnInitMenuPopup(null));
+        }
+
+        [Fact]
+        public void MenuItem_OnMeasureItem_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnMeasureItem(null);
+
+            // Handler.
+            int callCount = 0;
+            MeasureItemEventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.MeasureItem += handler;
+            menuItem.OnMeasureItem(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.MeasureItem -= handler;
+            menuItem.OnMeasureItem(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnMeasureItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnMeasureItem(null));
+        }
+
+        [Fact]
+        public void MenuItem_MeasureItem_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            MeasureItemEventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MeasureItem += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MeasureItem -= handler);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_OnPopup_Invoke_Success(bool mdiList)
+        {
+            var menuItem = new SubMenuItem
+            {
+                MdiList = mdiList
+            };
+
+            // No handler.
+            menuItem.OnPopup(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Popup += handler;
+            menuItem.OnPopup(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Popup -= handler;
+            menuItem.OnPopup(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnPopup_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnPopup(null));
+        }
+
+        [Fact]
+        public void MenuItem_Popup_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            EventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Popup += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Popup -= handler);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetBoolTheoryData))]
+        public void MenuItem_OnPopup_InvokeWithChildren_Success(bool mdiList)
+        {
+            var menuItem = new SubMenuItem("text", new MenuItem[] { new MenuItem("text") { MdiList = mdiList } });
+
+            // No handler.
+            menuItem.OnPopup(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Popup += handler;
+            menuItem.OnPopup(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Popup -= handler;
+            menuItem.OnPopup(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnPopup_MdiChildrenWithoutParent_DoesNotAddSeparator()
+        {
+            var menuItem = new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true };
+
+            menuItem.OnPopup(null);
+            Assert.Equal(new string[] { "child" }, menuItem.MenuItems.Cast<MenuItem>().Select(m => m.Text));
+
+            // Calling OnPopup again should not add duplicate items.
+            menuItem.OnPopup(null);
+            Assert.Equal(new string[] { "child" }, menuItem.MenuItems.Cast<MenuItem>().Select(m => m.Text));
+        }
+
+        public static IEnumerable<object[]> OnPopup_MdiChildren_TestData()
+        {
+            var formWithNoMdiChildren = new Form { Menu = new MainMenu() };
+            formWithNoMdiChildren.Controls.Add(new MdiClient());
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, new MainMenu(), new string[] { "child" } };
+            yield return new object[] { new SubMenuItem("text") { MdiList = true }, formWithNoMdiChildren.Menu, Array.Empty<string>() };
+
+            var formWithNoVisibleMdiChildren = new Form { Menu = new MainMenu() };
+            var formWithNoVisibleMdiChildrenClient = new MdiClient();
+            formWithNoVisibleMdiChildren.Controls.Add(formWithNoVisibleMdiChildrenClient);
+            formWithNoVisibleMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithNoVisibleMdiChildren });
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, formWithNoVisibleMdiChildren.Menu, new string[] { "child", "-" } };
+            yield return new object[] { new SubMenuItem("text"), formWithNoVisibleMdiChildren.Menu, Array.Empty<string>() };
+
+            var formWithMdiChildren = new Form { Menu = new MainMenu(), Visible = true };
+            var formWithMdiChildrenClient = new MdiClient();
+            formWithMdiChildren.Controls.Add(formWithMdiChildrenClient);
+            formWithMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithMdiChildren, Visible = true, Text = "Form" });
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, formWithMdiChildren.Menu, new string[] { "child", "-", "&1 Form", "&2 Form" } };
+
+            var formWithManyMdiChildren = new Form { Menu = new MainMenu(), Visible = true };
+            var formWithManyMdiChildrenClient = new MdiClient();
+            formWithManyMdiChildren.Controls.Add(formWithManyMdiChildrenClient);
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form1" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form2" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form3" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form4" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form5" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form6" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form7" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form8" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form9" });
+            formWithManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithManyMdiChildren, Visible = true, Text = "Form10" });
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, formWithManyMdiChildren.Menu, new string[] { "child", "-", "&1 Form1", "&2 Form1", "&3 Form2", "&4 Form2", "&5 Form3", "&6 Form3", "&7 Form4", "&8 Form4", "&9 Form10", "&10 Form10", "&More Windows..." } };
+
+            var formWithActiveMdiChildren = new SubForm { Menu = new MainMenu(), Visible = true };
+            var formWithActiveMdiChildrenClient = new MdiClient();
+            formWithActiveMdiChildren.Controls.Add(formWithActiveMdiChildrenClient);
+            var activeForm1 = new Form { MdiParent = formWithActiveMdiChildren, Visible = true, Text = "Form2" };
+            formWithActiveMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveMdiChildren, Visible = true, Text = "Form1" });
+            formWithActiveMdiChildrenClient.Controls.Add(activeForm1);
+            formWithActiveMdiChildren.ActivateMdiChild(activeForm1);
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, formWithActiveMdiChildren.Menu, new string[] { "child", "-", "&1 Form2", "&2 Form1", "&3 Form1", "&4 Form2" } };
+
+            var formWithActiveManyMdiChildren = new SubForm { Menu = new MainMenu(), Visible = true };
+            var formWithActiveManyMdiChildrenClient = new MdiClient();
+            formWithActiveManyMdiChildren.Controls.Add(formWithActiveManyMdiChildrenClient);
+            var activeForm2 = new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form11" };
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form1" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form2" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form3" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form4" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form5" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form6" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form7" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form8" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form9" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(new Form { MdiParent = formWithActiveManyMdiChildren, Visible = true, Text = "Form10" });
+            formWithActiveManyMdiChildrenClient.Controls.Add(activeForm2);
+            formWithActiveManyMdiChildren.ActivateMdiChild(activeForm2);
+            yield return new object[] { new SubMenuItem("text", new MenuItem[] { new MenuItem("child") }) { MdiList = true }, formWithActiveManyMdiChildren.Menu, new string[] { "child", "-", "&1 Form11", "&2 Form1", "&3 Form1", "&4 Form2", "&5 Form2", "&6 Form3", "&7 Form3", "&8 Form4", "&9 Form4", "&10 Form11", "&More Windows..." } };
+        }
+
+        [Theory]
+        [MemberData(nameof(OnPopup_MdiChildren_TestData))]
+        public void MenuItem_OnPopup_MdiChildren_AddsSeparator(SubMenuItem menuItem, Menu parent, string[] expectedItems)
+        {
+            try
+            {
+                parent.MenuItems.Add(menuItem);
+
+                menuItem.OnPopup(null);
+                Assert.Equal(expectedItems, menuItem.MenuItems.Cast<MenuItem>().Select(m => m.Text));
+
+                // Calling OnPopup again should not add duplicate items.
+                menuItem.OnPopup(null);
+                Assert.Equal(expectedItems, menuItem.MenuItems.Cast<MenuItem>().Select(m => m.Text));
+            }
+            catch
+            {
+                string expected = "Expected: " + string.Join(", ", expectedItems.Select(i => "\"" + i + "\""));
+                string actual = "Actual:   " + string.Join(", ", menuItem.MenuItems.Cast<MenuItem>().Select(m => m.Text).Select(i => "\"" + i + "\""));
+                throw new Exception(expected + Environment.NewLine + actual);
+            }
+        }
+
+        [Fact]
+        public void MenuItem_PerformClick_MdiSeparator_Nop()
+        {
+            var parentForm = new Form { Menu = new MainMenu() };
+            var parentFormClient = new MdiClient();
+            parentForm.Controls.Add(parentFormClient);
+            parentFormClient.Controls.Add(new Form { MdiParent = parentForm });
+            var menuItem = new SubMenuItem("text", new MenuItem[] { new MenuItem() }) { MdiList = true };
+            parentForm.Menu.MenuItems.Add(menuItem);
+            menuItem.OnPopup(null);
+
+            MenuItem separator = menuItem.MenuItems[1];
+            Assert.Equal("-", separator.Text);
+            separator.PerformClick();
+        }
+
+        [Fact]
+        public void MenuItem_OnSelect_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.OnSelect(null);
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Select += handler;
+            menuItem.OnSelect(null);
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Select -= handler;
+            menuItem.OnSelect(null);
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_OnSelect_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.OnSelect(null));
+        }
+
+        [Fact]
+        public void MenuItem_Select_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new SubMenuItem();
+            menuItem.Dispose();
+            EventHandler handler = (sender, e) => { };
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Select += handler);
+            Assert.Throws<ObjectDisposedException>(() => menuItem.Select -= handler);
+        }
+
+        [Fact]
+        public void MenuItem_PerformClick_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.PerformClick();
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(EventArgs.Empty, e);
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Click += handler;
+            menuItem.PerformClick();
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Click -= handler;
+            menuItem.PerformClick();
+            Assert.Equal(1, callCount);
+        }
+
+        [Fact]
+        public void MenuItem_PerformSelect_Invoke_Success()
+        {
+            var menuItem = new SubMenuItem();
+
+            // No handler.
+            menuItem.PerformSelect();
+
+            // Handler.
+            int callCount = 0;
+            EventHandler handler = (sender, e) =>
+            {
+                Assert.Equal(EventArgs.Empty, e);
+                Assert.Equal(menuItem, sender);
+                callCount++;
+            };
+
+            menuItem.Select += handler;
+            menuItem.PerformSelect();
+            Assert.Equal(1, callCount);
+
+            // Should not call if the handler is removed.
+            menuItem.Select -= handler;
+            menuItem.PerformSelect();
+            Assert.Equal(1, callCount);
+        }
+
+        public static IEnumerable<object[]> CloneMenu_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem("text") } };
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void MenuItem_CloneMenu_InvokeNew_Success(MenuItem[] items)
+        {
+            var source = new MenuItem("text", items)
+            {
+                BarBreak = true,
+                Break = true,
+                Checked = items.Length == 0,
+                Enabled = false,
+                MdiList = true,
+                MergeOrder = -1,
+                MergeType = MenuMerge.Remove,
+                Name = "name",
+                OwnerDraw = true,
+                RadioCheck = true,
+                ShowShortcut = false,
+                Shortcut = Shortcut.CtrlA,
+                Site = Mock.Of<ISite>(),
+                Tag = "tag",
+                Visible = false
+            };
+            var menu = new SubMenu(new MenuItem[] { new MenuItem("parent", new MenuItem[] { source }) });
+            MenuItem menuItem = source.CloneMenu();
+            Assert.NotSame(source, menuItem);
+
+            Assert.Equal(source.BarBreak, menuItem.BarBreak);
+            Assert.Equal(source.Break, menuItem.Break);
+            Assert.Equal(source.Checked, menuItem.Checked);
+            Assert.Equal(source.DefaultItem, menuItem.DefaultItem);
+            Assert.Equal(source.Enabled, menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(source.IsParent, menuItem.IsParent);
+            Assert.Equal(source.MdiList, menuItem.MdiList);
+            MenuTests.AssertEqualMenuItems(items, menuItem.MenuItems.Cast<MenuItem>().ToArray());
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.Equal(i, menuItem.MenuItems[i].Index);
+                Assert.Equal(menuItem, menuItem.MenuItems[i].Parent);
+            }
+            Assert.Equal(source.MergeOrder, menuItem.MergeOrder);
+            Assert.Equal(source.MergeType, menuItem.MergeType);
+            Assert.Equal(source.Mnemonic, menuItem.Mnemonic);
+            Assert.Equal(source.OwnerDraw, menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(source.RadioCheck, menuItem.RadioCheck);
+            Assert.Equal(source.ShowShortcut, menuItem.ShowShortcut);
+            Assert.Equal(source.Shortcut, menuItem.Shortcut);
+            Assert.Equal(source.Visible, menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Equal(source.Text, menuItem.Text);
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void MenuItem_CloneMenu_InvokeExisting_Success(MenuItem[] items)
+        {
+            var source = new MenuItem("text", items)
+            {
+                BarBreak = true,
+                Break = true,
+                Checked = items.Length == 0,
+                Enabled = false,
+                MdiList = true,
+                MergeOrder = -1,
+                MergeType = MenuMerge.Remove,
+                OwnerDraw = true,
+                Site = Mock.Of<ISite>(),
+                Tag = "tag"
+            };
+            var menu = new SubMenu(new MenuItem[] { new MenuItem("parent", new MenuItem[] { source }) });
+            var menuItem = new SubMenuItem();
+            menuItem.CloneMenu(source);
+
+            Assert.False(menuItem.BarBreak);
+            Assert.False(menuItem.Break);
+            Assert.False(menuItem.Checked);
+            Assert.False(menuItem.DefaultItem);
+            Assert.True(menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(source.IsParent, menuItem.IsParent);
+            Assert.False(menuItem.MdiList);
+            MenuTests.AssertEqualMenuItems(items, menuItem.MenuItems.Cast<MenuItem>().ToArray());
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.Equal(i, menuItem.MenuItems[i].Index);
+                Assert.Equal(menuItem, menuItem.MenuItems[i].Parent);
+            }
+            Assert.Equal(0, menuItem.MergeOrder);
+            Assert.Equal(MenuMerge.Add, menuItem.MergeType);
+            Assert.Equal('\0', menuItem.Mnemonic);
+            Assert.False(menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.False(menuItem.RadioCheck);
+            Assert.True(menuItem.ShowShortcut);
+            Assert.Equal(Shortcut.None, menuItem.Shortcut);
+            Assert.True(menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Empty(menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_CloneMenu_NullMenuSource_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenuItem("text");
+            Assert.Throws<ArgumentNullException>("menuSrc", () => menu.CloneMenu(null));
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void MenuItem_MergeMenu_InvokeNew_Success(MenuItem[] items)
+        {
+            var source = new MenuItem("text", items)
+            {
+                BarBreak = true,
+                Break = true,
+                Checked = items.Length == 0,
+                Enabled = false,
+                MdiList = true,
+                MergeOrder = -1,
+                MergeType = MenuMerge.Remove,
+                Name = "name",
+                OwnerDraw = true,
+                RadioCheck = true,
+                ShowShortcut = false,
+                Shortcut = Shortcut.CtrlA,
+                Site = Mock.Of<ISite>(),
+                Tag = "tag",
+                Visible = false
+            };
+            var menu = new SubMenu(new MenuItem[] { new MenuItem("parent", new MenuItem[] { source }) });
+            MenuItem menuItem = source.MergeMenu();
+            Assert.NotSame(source, menuItem);
+
+            Assert.Equal(source.BarBreak, menuItem.BarBreak);
+            Assert.Equal(source.Break, menuItem.Break);
+            Assert.Equal(source.Checked, menuItem.Checked);
+            Assert.Equal(source.DefaultItem, menuItem.DefaultItem);
+            Assert.Equal(source.Enabled, menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(source.IsParent, menuItem.IsParent);
+            Assert.Equal(source.MdiList, menuItem.MdiList);
+            MenuTests.AssertEqualMenuItems(items, menuItem.MenuItems.Cast<MenuItem>().ToArray());
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.Equal(i, menuItem.MenuItems[i].Index);
+                Assert.Equal(menuItem, menuItem.MenuItems[i].Parent);
+            }
+            Assert.Equal(source.MergeOrder, menuItem.MergeOrder);
+            Assert.Equal(source.MergeType, menuItem.MergeType);
+            Assert.Equal(source.Mnemonic, menuItem.Mnemonic);
+            Assert.Equal(source.OwnerDraw, menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(source.RadioCheck, menuItem.RadioCheck);
+            Assert.Equal(source.ShowShortcut, menuItem.ShowShortcut);
+            Assert.Equal(source.Shortcut, menuItem.Shortcut);
+            Assert.Equal(source.Visible, menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Equal(source.Text, menuItem.Text);
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void MenuItem_MergeMenu_InvokeExisting_Success(MenuItem[] items)
+        {
+            var source = new MenuItem("text", items)
+            {
+                BarBreak = true,
+                Break = true,
+                Checked = items.Length == 0,
+                Enabled = false,
+                MdiList = true,
+                MergeOrder = -1,
+                MergeType = MenuMerge.Remove,
+                Name = "name",
+                OwnerDraw = true,
+                RadioCheck = true,
+                ShowShortcut = false,
+                Shortcut = Shortcut.CtrlA,
+                Site = Mock.Of<ISite>(),
+                Tag = "tag",
+                Visible = false
+            };
+            var menu = new SubMenu(new MenuItem[] { new MenuItem("parent", new MenuItem[] { source }) });
+            var menuItem = new MenuItem();
+            menuItem.MergeMenu(source);
+
+            Assert.Equal(source.BarBreak, menuItem.BarBreak);
+            Assert.Equal(source.Break, menuItem.Break);
+            Assert.Equal(source.Checked, menuItem.Checked);
+            Assert.Equal(source.DefaultItem, menuItem.DefaultItem);
+            Assert.Equal(source.Enabled, menuItem.Enabled);
+            Assert.Equal(-1, menuItem.Index);
+            Assert.Equal(source.IsParent, menuItem.IsParent);
+            Assert.Equal(source.MdiList, menuItem.MdiList);
+            MenuTests.AssertEqualMenuItems(items, menuItem.MenuItems.Cast<MenuItem>().ToArray());
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.Equal(i, menuItem.MenuItems[i].Index);
+                Assert.Equal(menuItem, menuItem.MenuItems[i].Parent);
+            }
+            Assert.Equal(source.MergeOrder, menuItem.MergeOrder);
+            Assert.Equal(source.MergeType, menuItem.MergeType);
+            Assert.Equal(source.Mnemonic, menuItem.Mnemonic);
+            Assert.Equal(source.OwnerDraw, menuItem.OwnerDraw);
+            Assert.Null(menuItem.Parent);
+            Assert.Equal(source.RadioCheck, menuItem.RadioCheck);
+            Assert.Equal(source.ShowShortcut, menuItem.ShowShortcut);
+            Assert.Equal(source.Shortcut, menuItem.Shortcut);
+            Assert.Equal(source.Visible, menuItem.Visible);
+            Assert.Empty(menuItem.Name);
+            Assert.Null(menuItem.Site);
+            Assert.Null(menuItem.Container);
+            Assert.Null(menuItem.Tag);
+            Assert.Equal(source.Text, menuItem.Text);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_OnClick_Success()
+        {
+            var source = new SubMenuItem();
+
+            int sourceCallCount = 0;
+            source.Click += (sender, e) =>
+            {
+                sourceCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            SubMenuItem destination = Assert.IsType<SubMenuItem>(source.MergeMenu());
+            int destinationCallCount = 0;
+            destination.Click += (sender, e) =>
+            {
+                destinationCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            destination.OnClick(EventArgs.Empty);
+            Assert.Equal(1, sourceCallCount);
+            Assert.Equal(1, destinationCallCount);
+
+            source.OnClick(EventArgs.Empty);
+            Assert.Equal(2, sourceCallCount);
+            Assert.Equal(2, destinationCallCount);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_OnDrawItem_Success()
+        {
+            var source = new SubMenuItem();
+
+            int sourceCallCount = 0;
+            source.DrawItem += (sender, e) =>
+            {
+                sourceCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Null(e);
+            };
+
+            SubMenuItem destination = Assert.IsType<SubMenuItem>(source.MergeMenu());
+            int destinationCallCount = 0;
+            destination.DrawItem += (sender, e) =>
+            {
+                destinationCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Null(e);
+            };
+
+            destination.OnDrawItem(null);
+            Assert.Equal(1, sourceCallCount);
+            Assert.Equal(1, destinationCallCount);
+
+            source.OnDrawItem(null);
+            Assert.Equal(2, sourceCallCount);
+            Assert.Equal(2, destinationCallCount);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_OnMeasureItem_Success()
+        {
+            var source = new SubMenuItem();
+
+            int sourceCallCount = 0;
+            source.MeasureItem += (sender, e) =>
+            {
+                sourceCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Null(e);
+            };
+
+            SubMenuItem destination = Assert.IsType<SubMenuItem>(source.MergeMenu());
+            int destinationCallCount = 0;
+            destination.MeasureItem += (sender, e) =>
+            {
+                destinationCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Null(e);
+            };
+
+            destination.OnMeasureItem(null);
+            Assert.Equal(1, sourceCallCount);
+            Assert.Equal(1, destinationCallCount);
+
+            source.OnMeasureItem(null);
+            Assert.Equal(2, sourceCallCount);
+            Assert.Equal(2, destinationCallCount);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_OnPopup_Success()
+        {
+            var source = new SubMenuItem();
+
+            int sourceCallCount = 0;
+            source.Popup += (sender, e) =>
+            {
+                sourceCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            SubMenuItem destination = Assert.IsType<SubMenuItem>(source.MergeMenu());
+            int destinationCallCount = 0;
+            destination.Popup += (sender, e) =>
+            {
+                destinationCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            destination.OnPopup(EventArgs.Empty);
+            Assert.Equal(1, sourceCallCount);
+            Assert.Equal(1, destinationCallCount);
+
+            source.OnPopup(EventArgs.Empty);
+            Assert.Equal(2, sourceCallCount);
+            Assert.Equal(2, destinationCallCount);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_OnSelect_Success()
+        {
+            var source = new SubMenuItem();
+
+            int sourceCallCount = 0;
+            source.Select += (sender, e) =>
+            {
+                sourceCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            SubMenuItem destination = Assert.IsType<SubMenuItem>(source.MergeMenu());
+            int destinationCallCount = 0;
+            destination.Select += (sender, e) =>
+            {
+                destinationCallCount++;
+                Assert.Equal(source, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            destination.OnSelect(EventArgs.Empty);
+            Assert.Equal(1, sourceCallCount);
+            Assert.Equal(1, destinationCallCount);
+
+            source.OnSelect(EventArgs.Empty);
+            Assert.Equal(2, sourceCallCount);
+            Assert.Equal(2, destinationCallCount);
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_NullMenuSource_ThrowsArgumentNullException()
+        {
+            var menu = new MenuItem("text");
+            Assert.Throws<ArgumentNullException>("menuSrc", () => menu.MergeMenu(null));
+        }
+
+        [Fact]
+        public void MenuItem_MergeMenu_Disposed_ThrowsObjectDisposedException()
+        {
+            var menuItem = new MenuItem();
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MergeMenu());
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringWithNullTheoryData))]
+        public void MenuItem_ToString_Invoke_ReturnsExpected(string text)
+        {
+            var menuItem = new MenuItem
+            {
+                Text = text
+            };
+            Assert.Equal("System.Windows.Forms.MenuItem, Items.Count: 0, Text: " + text, menuItem.ToString());
+        }
+
+        [Fact]
+        public void MenuItem_Dispose_NoParentOrChildren_Success()
+        {
+            var menuItem = new MenuItem("text", Array.Empty<MenuItem>());
+            menuItem.Dispose();
+            menuItem.Dispose();
+        }
+
+        [Fact]
+        public void MenuItem_Dispose_NoParent_Success()
+        {
+            var childMenuItem = new MenuItem();
+            var menuItem = new MenuItem("text", new MenuItem[] { childMenuItem });
+            menuItem.Dispose();
+            Assert.Null(childMenuItem.Parent);
+            Assert.Empty(menuItem.MenuItems);
+
+            menuItem.Dispose();
+            Assert.Empty(menuItem.MenuItems);
+        }
+
+        [Fact]
+        public void MenuItem_Dispose_HasParent_Success()
+        {
+            var childMenuItem = new MenuItem();
+            var menuItem = new MenuItem("text", new MenuItem[] { childMenuItem });
+            childMenuItem.Dispose();
+            Assert.Null(childMenuItem.Parent);
+            Assert.Empty(menuItem.MenuItems);
+
+            childMenuItem.Dispose();
+            Assert.Empty(menuItem.MenuItems);
+        }
+
+        [Fact]
+        public void MenuItem_Dispose_HasMenuId_Success()
+        {
+            var menuItem = new SubMenuItem();
+            Assert.NotEqual(0, menuItem.MenuID);
+
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MenuID);
+
+            menuItem.Dispose();
+            Assert.Throws<ObjectDisposedException>(() => menuItem.MenuID);
+        }
+
+        public class SubMenuItem : MenuItem
+        {
+            public SubMenuItem()
+            {
+            }
+
+            public SubMenuItem(string text) : base(text)
+            {
+            }
+
+            public SubMenuItem(string text, EventHandler onClick) : base(text, onClick)
+            {
+            }
+
+            public SubMenuItem(string text, MenuItem[] items) : base(text, items)
+            {
+            }
+
+            public SubMenuItem(string text, EventHandler onClick, Shortcut shortcut) : base(text, onClick, shortcut)
+            {
+            }
+
+            public SubMenuItem(MenuMerge mergeType, int mergeOrder, Shortcut shortcut, string text, EventHandler onClick, EventHandler onPopup, EventHandler onSelect, MenuItem[] items) : base(mergeType, mergeOrder, shortcut, text, onClick, onPopup, onSelect, items)
+            {
+            }
+
+            public new int MenuID => base.MenuID;
+
+            public new void OnClick(EventArgs e) => base.OnClick(e);
+
+            public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
+
+            public new void OnInitMenuPopup(EventArgs e) => base.OnInitMenuPopup(e);
+
+            public new void OnMeasureItem(MeasureItemEventArgs e) => base.OnMeasureItem(e);
+
+            public new void OnPopup(EventArgs e) => base.OnPopup(e);
+
+            public new void OnSelect(EventArgs e) => base.OnSelect(e);
+
+            public new void CloneMenu(Menu menuSrc) => base.CloneMenu(menuSrc);
+        }
+
+        private class SubMenu : Menu
+        {
+            public SubMenu(params MenuItem[] items) : base(items)
+            {
+            }
+        }
+
+        private class SubForm : Form
+        {
+            public new void ActivateMdiChild(Form form) => base.ActivateMdiChild(form);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/MenuTests.cs b/WTG.System.Windows.Forms.Tests/MenuTests.cs
new file mode 100644
index 00000000000..8f0e703ac68
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/MenuTests.cs
@@ -0,0 +1,741 @@
+using System.ComponentModel;
+using System.Windows.Forms;
+using Moq;
+using WTG.System.Windows.Forms.Tests.Common;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class MenuTests
+    {
+        public static IEnumerable<object[]> Ctor_MenuItemArray_TestData()
+        {
+            yield return new object[] { null, false };
+            yield return new object[] { Array.Empty<MenuItem>(), false };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, true };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_MenuItemArray_TestData))]
+        public void Menu_Ctor_MenuItemArray(MenuItem[] items, bool expectedIsParent)
+        {
+            var menu = new SubMenu(items);
+            Assert.Equal(items ?? Array.Empty<MenuItem>(), menu.MenuItems.Cast<MenuItem>());
+            for (int i = 0; i < (items?.Length ?? 0); i++)
+            {
+                Assert.Equal(i, menu.MenuItems[i].Index);
+                Assert.Equal(menu, menu.MenuItems[i].Parent);
+            }
+            Assert.Equal(expectedIsParent, menu.IsParent);
+            Assert.Empty(menu.Name);
+            Assert.Null(menu.Site);
+            Assert.Null(menu.Container);
+            Assert.Null(menu.Tag);
+        }
+
+        [Fact]
+        public void Menu_Ctor_NullItemInMenuItemArray_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("item", () => new SubMenu(new MenuItem[] { null }));
+        }
+
+        [Fact]
+        public void Menu_FindHandle_Get_ReturnsExpected()
+        {
+            Assert.Equal(0, Menu.FindHandle);
+        }
+
+        [Fact]
+        public void Menu_FindShortcut_Get_ReturnsExpected()
+        {
+            Assert.Equal(1, Menu.FindShortcut);
+        }
+
+        public static IEnumerable<object[]> HandleMenuItems_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>() };
+            yield return new object[]
+            {
+                new MenuItem[]
+                {
+                    // Not visible.
+                    new MenuItem { Visible = false },
+
+                    // Has state.
+                    new MenuItem { BarBreak = true, Break = true, Checked = true, DefaultItem = true, Enabled = false },
+
+                    // Has shortcut.
+                    new MenuItem { Shortcut = Shortcut.CtrlA },
+
+                    // Has no shortcut.
+                    new MenuItem { ShowShortcut = false, Shortcut = Shortcut.CtrlA },
+
+                    // Has owner draw.
+                    new MenuItem("text") { OwnerDraw = true },
+
+                    // Has children.
+                    new MenuItem("text", new MenuItem[] { new MenuItem("child") }),
+                }
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(HandleMenuItems_TestData))]
+        public void Menu_Handle_Get_ReturnsExpected(MenuItem[] items)
+        {
+            using (var menu = new SubMenu(items))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                Assert.Equal(menu.Handle, menu.Handle);
+            }
+        }
+
+        [Fact]
+        public void Menu_Handle_GetWithDashTextInNormalMenu_ReturnsExpected()
+        {
+            var menuItem = new MenuItem("-");
+            using (var menu = new SubMenu(new MenuItem[] { menuItem }))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                Assert.Equal(menu.Handle, menu.Handle);
+
+                // Does not affect the text.
+                Assert.Equal("-", menuItem.Text);
+            }
+        }
+
+        [Fact]
+        public void Menu_Handle_GetWithDashTextInMainMenu_ReturnsExpected()
+        {
+            var menuItem = new MenuItem("-");
+            using (var menu = new MainMenu(new MenuItem[] { menuItem }))
+            {
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                Assert.Equal(menu.Handle, menu.Handle);
+
+                // Sets the separator to a space.
+                Assert.Equal(" ", menuItem.Text);
+            }
+        }
+
+        [Fact]
+        public void Menu_Handle_GetWithRightToLeftItem_ReturnsExpected()
+        {
+            using (var menu = new ContextMenu(new MenuItem[] { new MenuItem("text") }))
+            {
+                menu.RightToLeft = RightToLeft.Yes;
+                Assert.NotEqual(IntPtr.Zero, menu.Handle);
+                Assert.Equal(menu.Handle, menu.Handle);
+            }
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void Menu_Name_GetWithSite_ReturnsExpected(string name, string expected)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>())
+            {
+                Site = Mock.Of<ISite>(s => s.Name == name)
+            };
+            Assert.Equal(expected, menu.Name);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void Menu_Name_SetWithoutSite_GetReturnsExpected(string value, string expected)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>())
+            {
+                Name = value
+            };
+            Assert.Equal(expected, menu.Name);
+
+            // Set same.
+            menu.Name = value;
+            Assert.Equal(expected, menu.Name);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringNormalizedTheoryData))]
+        public void Menu_Name_SetWithSite_GetReturnsExpected(string value, string expected)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>())
+            {
+                Site = Mock.Of<ISite>(),
+                Name = value
+            };
+            Assert.Equal(expected, menu.Name);
+            Assert.Equal(value?.Length == 0 ? null : value, menu.Site.Name);
+        }
+
+        public static IEnumerable<object[]> MdiListItem_TestData()
+        {
+            var listItem1 = new MenuItem { MdiList = true };
+            var listItem2 = new MenuItem { MdiList = true };
+
+            yield return new object[] { Array.Empty<MenuItem>(), null };
+            yield return new object[] { new MenuItem[] { listItem1 }, listItem1 };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, null };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { listItem2 }) }, listItem2 };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { new MenuItem() }) }, null };
+        }
+
+        [Theory]
+        [MemberData(nameof(MdiListItem_TestData))]
+        public void Menu_MdiListItem_Get_ReturnsExpected(MenuItem[] items, MenuItem expected)
+        {
+            var menu = new SubMenu(items);
+            Assert.Equal(expected, menu.MdiListItem);
+        }
+
+        [Theory]
+        [CommonMemberData(nameof(CommonTestHelper.GetStringWithNullTheoryData))]
+        public void Menu_Tag_Set_GetReturnsExpected(object value)
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>())
+            {
+                Tag = value
+            };
+            Assert.Same(value, menu.Tag);
+
+            // Set same.
+            menu.Tag = value;
+            Assert.Same(value, menu.Tag);
+        }
+
+        public static IEnumerable<object[]> FindMenuItem_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>(), MenuItem.FindHandle, IntPtr.Zero, null };
+            yield return new object[] { Array.Empty<MenuItem>(), MenuItem.FindShortcut, IntPtr.Zero, null };
+            yield return new object[] { Array.Empty<MenuItem>(), 2, IntPtr.Zero, null };
+
+            var menuItem1 = new MenuItem();
+            var menuItem2 = new MenuItem();
+            yield return new object[] { new MenuItem[] { menuItem1 }, MenuItem.FindHandle, IntPtr.Zero, menuItem1 };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, MenuItem.FindHandle, (IntPtr)1, null };
+            yield return new object[] { new MenuItem[] { menuItem2 }, MenuItem.FindShortcut, IntPtr.Zero, menuItem2 };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, MenuItem.FindShortcut, (IntPtr)1, null };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, 2, IntPtr.Zero, null };
+
+            var shortcutItem1 = new MenuItem
+            {
+                Shortcut = Shortcut.CtrlA
+            };
+            yield return new object[] { new MenuItem[] { shortcutItem1 }, MenuItem.FindShortcut, (IntPtr)0x20041, shortcutItem1 };
+            yield return new object[] { new MenuItem[] { new MenuItem { Shortcut = Shortcut.CtrlA } }, MenuItem.FindShortcut, (IntPtr)0x20042, null };
+
+            var parent = new MenuItem("parent", new MenuItem[] { new MenuItem() });
+            var shortcutItem2 = new MenuItem
+            {
+                Shortcut = Shortcut.CtrlA
+            };
+            yield return new object[] { new MenuItem[] { parent }, MenuItem.FindHandle, IntPtr.Zero, parent };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { new MenuItem() }) }, MenuItem.FindHandle, (IntPtr)1, null };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { new MenuItem() }) }, MenuItem.FindHandle, (IntPtr)1, null };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { shortcutItem2 }) }, MenuItem.FindShortcut, (IntPtr)0x20041, shortcutItem2 };
+            yield return new object[] { new MenuItem[] { new MenuItem("parent", new MenuItem[] { new MenuItem() { Shortcut = Shortcut.CtrlA } }) }, MenuItem.FindShortcut, (IntPtr)0x20042, null };
+        }
+
+        [Theory]
+        [MemberData(nameof(FindMenuItem_TestData))]
+        public void Menu_FindMenuItem_Invoke_ReturnsExpected(MenuItem[] items, int type, IntPtr value, MenuItem expected)
+        {
+            var menu = new SubMenu(items);
+            Assert.Equal(expected, menu.FindMenuItem(type, value));
+        }
+
+        public static IEnumerable<object[]> ProcessCmdKey_TestData()
+        {
+            yield return new object[] { new MenuItem { Shortcut = Shortcut.CtrlA }, true, 1, 0 };
+            yield return new object[] { new MenuItem { Shortcut = Shortcut.CtrlA, Enabled = false }, false, 0, 0 };
+            yield return new object[] { new MenuItem("text", new MenuItem[] { new MenuItem() }) { Shortcut = Shortcut.CtrlA }, true, 0, 1 };
+            yield return new object[] { new MenuItem("text", new MenuItem[] { new MenuItem() }) { Shortcut = Shortcut.CtrlA, Enabled = false }, false, 0, 0 };
+        }
+
+        [Theory]
+        [MemberData(nameof(ProcessCmdKey_TestData))]
+        public void Menu_ProcessCmdKey_HasItemWithShoutcutKey_ReturnsExpected(MenuItem menuItem, bool expectedResult, int expectedOnClickCallCount, int expectedOnPopupCallCount)
+        {
+            int onClickCallCount = 0;
+            menuItem.Click += (sender, e) =>
+            {
+                onClickCallCount++;
+                Assert.Same(menuItem, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            int onPopupCallCount = 0;
+            menuItem.Popup += (sender, e) =>
+            {
+                onPopupCallCount++;
+                Assert.Same(menuItem, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            var message = new Message();
+            Assert.Equal(expectedResult, menu.ProcessCmdKey(ref message, Keys.Control | Keys.A));
+            Assert.Equal(expectedOnClickCallCount, onClickCallCount);
+            Assert.Equal(expectedOnPopupCallCount, onPopupCallCount);
+        }
+
+        public static IEnumerable<object[]> ProcessCmdKey_MenuItemParent_TestData()
+        {
+            var enabledParentChild = new MenuItem { Shortcut = Shortcut.CtrlA };
+            var enabledParent = new MenuItem("text", new MenuItem[] { enabledParentChild });
+            yield return new object[] { enabledParent, enabledParentChild, true, 1, 0, 0, 1 };
+
+            var enabledParentChildWithItems = new MenuItem("text", new MenuItem[] { new MenuItem() }) { Shortcut = Shortcut.CtrlA };
+            var enabledParentWithItems = new MenuItem("text", new MenuItem[] { enabledParentChildWithItems });
+            yield return new object[] { enabledParentWithItems, enabledParentChildWithItems, true, 0, 1, 0, 1 };
+
+            var disabledParentChild = new MenuItem { Shortcut = Shortcut.CtrlA };
+            var disabledParent = new MenuItem("text", new MenuItem[] { disabledParentChild }) { Enabled = false };
+            yield return new object[] { disabledParent, disabledParentChild, false, 0, 0, 0, 0 };
+        }
+
+        [Theory]
+        [MemberData(nameof(ProcessCmdKey_MenuItemParent_TestData))]
+        public void Menu_ProcessCmdKey_MenuItemParent_ReturnsExpected(MenuItem parent, MenuItem child, bool expectedResult, int expectedChildOnClickCallCount, int expectedChildOnPopupCallCount, int expectedParentOnClickCallCount, int expectedParentOnPopupCallCount)
+        {
+            int childOnClickCallCount = 0;
+            child.Click += (sender, e) =>
+            {
+                childOnClickCallCount++;
+                Assert.Same(child, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            int childOnPopupCallCount = 0;
+            child.Popup += (sender, e) =>
+            {
+                childOnPopupCallCount++;
+                Assert.Same(child, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            int parentOnClickCallCount = 0;
+            parent.Click += (sender, e) =>
+            {
+                parentOnClickCallCount++;
+                Assert.Same(parent, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            int parentOnPopupCallCount = 0;
+            parent.Popup += (sender, e) =>
+            {
+                parentOnPopupCallCount++;
+                Assert.Same(parent, sender);
+                Assert.Equal(EventArgs.Empty, e);
+            };
+
+            var message = new Message();
+            Assert.Equal(expectedResult, parent.ProcessCmdKey(ref message, Keys.Control | Keys.A));
+            Assert.Equal(expectedChildOnClickCallCount, childOnClickCallCount);
+            Assert.Equal(expectedChildOnPopupCallCount, childOnPopupCallCount);
+            Assert.Equal(expectedParentOnClickCallCount, parentOnClickCallCount);
+            Assert.Equal(expectedParentOnPopupCallCount, parentOnPopupCallCount);
+        }
+
+        [Fact]
+        public void Menu_ProcessCmdKey_ParentMenuItemPopupHandlerRemovesChild_ReturnsFalse()
+        {
+            var child = new MenuItem { Shortcut = Shortcut.CtrlA };
+            var parent = new MenuItem("text", new MenuItem[] { child });
+            var message = new Message();
+
+            parent.Popup += (sender, e) =>
+            {
+                parent.MenuItems.Remove(child);
+            };
+
+            Assert.False(parent.ProcessCmdKey(ref message, Keys.Control | Keys.A));
+        }
+
+        [Fact]
+        public void Menu_ProcessCmdKey_NoSuchShortcutKey_ReturnsFalse()
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            var message = new Message();
+            Assert.False(menu.ProcessCmdKey(ref message, Keys.Control | Keys.A));
+        }
+
+        [Fact]
+        public void Menu_Dispose_NoChildren_Success()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            menu.Dispose();
+            menu.Dispose();
+        }
+
+        [Fact]
+        public void Menu_Dispose_WithChildren_Success()
+        {
+            var menuItem = new MenuItem();
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            menu.Dispose();
+            Assert.Null(menuItem.Parent);
+            Assert.Empty(menu.MenuItems);
+
+            menu.Dispose();
+            Assert.Empty(menu.MenuItems);
+        }
+
+        [Fact]
+        public void Menu_Dispose_ItemHasSite_Success()
+        {
+            var menuItem = new MenuItem
+            {
+                Site = Mock.Of<ISite>()
+            };
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            menu.Dispose();
+            Assert.Null(menuItem.Parent);
+            Assert.Empty(menu.MenuItems);
+
+            menu.Dispose();
+            Assert.Empty(menu.MenuItems);
+        }
+
+        [Fact]
+        public void Menu_Dispose_ItemHasSiteWithContainer_Success()
+        {
+            var container = new Container();
+            var menuItem = new MenuItem
+            {
+                Site = Mock.Of<ISite>(s => s.Container == container)
+            };
+            container.Add(menuItem);
+            var menu = new SubMenu(new MenuItem[] { menuItem });
+            menu.Dispose();
+            Assert.Empty(container.Components);
+            Assert.Null(menuItem.Parent);
+            Assert.Empty(menu.MenuItems);
+
+            menu.Dispose();
+            Assert.Empty(menu.MenuItems);
+        }
+
+        public static IEnumerable<object[]> FindMergePosition_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>(), -1, 0 };
+            yield return new object[] { new MenuItem[] { new MenuItem { MergeOrder = 10 }, new MenuItem { MergeOrder = 12 }, new MenuItem(), new MenuItem(), new MenuItem() }, 12, 5 };
+            yield return new object[] { new MenuItem[] { new MenuItem { MergeOrder = 10 }, new MenuItem { MergeOrder = 12 }, new MenuItem(), new MenuItem(), new MenuItem() }, 11, 5 };
+            yield return new object[] { new MenuItem[] { new MenuItem { MergeOrder = 10 }, new MenuItem { MergeOrder = 12 }, new MenuItem(), new MenuItem(), new MenuItem() }, -1, 0 };
+            yield return new object[] { new MenuItem[] { new MenuItem { MergeOrder = 10 }, new MenuItem(), new MenuItem(), new MenuItem { MergeOrder = 12 }, new MenuItem() }, 0, 5 };
+            yield return new object[] { new MenuItem[] { new MenuItem { MergeOrder = 10 }, new MenuItem(), new MenuItem(), new MenuItem { MergeOrder = 12 }, new MenuItem() }, 5, 5 };
+            yield return new object[] { new MenuItem[] { new MenuItem() }, 0, 1 };
+        }
+
+        [Theory]
+        [MemberData(nameof(FindMergePosition_TestData))]
+        public void Menu_FindMergePosition_Invoke_ReturnsExpected(MenuItem[] items, int mergeOrder, int expected)
+        {
+            var menu = new SubMenu(items);
+            Assert.Equal(expected, menu.FindMergePosition(mergeOrder));
+        }
+
+        public static IEnumerable<object[]> GetContextMenu_TestData()
+        {
+            yield return new object[] { new SubMenu(Array.Empty<MenuItem>()), null };
+            yield return new object[] { new MenuItem(), null };
+
+            var menuItem1 = new MenuItem();
+            var menu1 = new ContextMenu(new MenuItem[] { menuItem1 });
+            yield return new object[] { menu1, menu1 };
+            yield return new object[] { menuItem1, menu1 };
+
+            var menuItem2 = new MenuItem();
+            var menu2 = new SubMenu(new MenuItem[] { menuItem2 });
+            yield return new object[] { menu2, null };
+            yield return new object[] { menuItem2, null };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetContextMenu_TestData))]
+        public void Menu_GetContextMenu_Invoke_ReturnsExpected(Menu menu, ContextMenu expected)
+        {
+            Assert.Equal(expected, menu.GetContextMenu());
+        }
+
+        public static IEnumerable<object[]> GetMainMenu_TestData()
+        {
+            yield return new object[] { new SubMenu(Array.Empty<MenuItem>()), null };
+            yield return new object[] { new MenuItem(), null };
+
+            var menuItem1 = new MenuItem();
+            var menu1 = new MainMenu(new MenuItem[] { menuItem1 });
+            yield return new object[] { menu1, menu1 };
+            yield return new object[] { menuItem1, menu1 };
+
+            var menuItem2 = new MenuItem();
+            var menu2 = new SubMenu(new MenuItem[] { menuItem2 });
+            yield return new object[] { menu2, null };
+            yield return new object[] { menuItem2, null };
+        }
+
+        [Theory]
+        [MemberData(nameof(GetMainMenu_TestData))]
+        public void Menu_GetMainMenu_Invoke_ReturnsExpected(Menu menu, MainMenu expected)
+        {
+            Assert.Equal(expected, menu.GetMainMenu());
+        }
+
+        public static IEnumerable<object[]> MergeMenu_TestData()
+        {
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2");
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1 },
+                    new MenuItem[] { menu2 },
+                    new MenuItem[] { menu1, menu2 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2") { MergeType = MenuMerge.MergeItems };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1 },
+                    new MenuItem[] { menu2 },
+                    new MenuItem[] { menu1, menu2 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2");
+                var menu3 = new MenuItem("3") { MergeType = MenuMerge.Replace };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2 },
+                    new MenuItem[] { menu3 },
+                    new MenuItem[] { menu1, menu2, menu3 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2") { MergeType = MenuMerge.Remove };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1 },
+                    new MenuItem[] { menu2 },
+                    new MenuItem[] { menu1 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = 1 };
+                var menu2 = new MenuItem("2");
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1 },
+                    new MenuItem[] { menu2 },
+                    new MenuItem[] { menu2, menu1 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = -1 };
+                var menu2 = new MenuItem("2");
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1 },
+                    new MenuItem[] { menu2 },
+                    new MenuItem[] { menu1, menu2 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = 1 };
+                var menu2 = new MenuItem("2") { MergeOrder = 1 };
+                var menu3 = new MenuItem("3") { MergeOrder = 2 };
+                var menu4 = new MenuItem("4") { MergeOrder = 2 };
+                var menu5 = new MenuItem("5") { MergeOrder = 3 };
+                var menu6 = new MenuItem("6") { MergeOrder = 0 };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2, menu3 },
+                    new MenuItem[] { menu4, menu5, menu6 },
+                    new MenuItem[] { menu6, menu1, menu2, menu3, menu4, menu5 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = 1, MergeType = MenuMerge.Replace };
+                var menu2 = new MenuItem("2") { MergeOrder = 1, MergeType = MenuMerge.Replace };
+                var menu3 = new MenuItem("3") { MergeOrder = 2, MergeType = MenuMerge.Replace };
+                var menu4 = new MenuItem("4") { MergeOrder = 2, MergeType = MenuMerge.Replace };
+                var menu5 = new MenuItem("5") { MergeOrder = 3, MergeType = MenuMerge.Replace };
+                var menu6 = new MenuItem("6") { MergeOrder = 0, MergeType = MenuMerge.Replace };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2, menu3 },
+                    new MenuItem[] { menu4, menu5, menu6 },
+                    new MenuItem[] { menu6, menu1, menu3, menu4, menu5 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = 1, MergeType = MenuMerge.Remove };
+                var menu2 = new MenuItem("2") { MergeOrder = 1, MergeType = MenuMerge.Remove };
+                var menu3 = new MenuItem("3") { MergeOrder = 2, MergeType = MenuMerge.Remove };
+                var menu4 = new MenuItem("4") { MergeOrder = 2, MergeType = MenuMerge.Remove };
+                var menu5 = new MenuItem("5") { MergeOrder = 3, MergeType = MenuMerge.Remove };
+                var menu6 = new MenuItem("6") { MergeOrder = 0, MergeType = MenuMerge.Remove };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2, menu3 },
+                    new MenuItem[] { menu4, menu5, menu6 },
+                    new MenuItem[] { menu1, menu2, menu3 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1") { MergeOrder = 1, MergeType = MenuMerge.MergeItems };
+                var menu2 = new MenuItem("2") { MergeOrder = 1, MergeType = MenuMerge.MergeItems };
+                var menu3 = new MenuItem("3") { MergeOrder = 2, MergeType = MenuMerge.MergeItems };
+                var menu4 = new MenuItem("4") { MergeOrder = 2, MergeType = MenuMerge.MergeItems };
+                var menu5 = new MenuItem("5") { MergeOrder = 3, MergeType = MenuMerge.MergeItems };
+                var menu6 = new MenuItem("6") { MergeOrder = 0, MergeType = MenuMerge.MergeItems };
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2, menu3 },
+                    new MenuItem[] { menu4, menu5, menu6 },
+                    new MenuItem[] { menu6, menu1, menu2, menu4, menu5 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2");
+                yield return new object[]
+                {
+                    new MenuItem[] { menu1, menu2 },
+                    null,
+                    new MenuItem[] { menu1, menu2 }
+                };
+            }
+            {
+                var menu1 = new MenuItem("1");
+                var menu2 = new MenuItem("2");
+                yield return new object[]
+                {
+                    null,
+                    new MenuItem[] { menu1, menu2 },
+                    new MenuItem[] { menu1, menu2 }
+                };
+            }
+            {
+                yield return new object[]
+                {
+                    null,
+                    null,
+                    Array.Empty<MenuItem>()
+                };
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(MergeMenu_TestData))]
+        public void Menu_MergeMenu_Invoke_ReturnsExpected(MenuItem[] destinationItems, MenuItem[] sourceItems, MenuItem[] expectedItems)
+        {
+            var menu = new SubMenu(destinationItems);
+            var menuSrc = new SubMenu(sourceItems);
+            menu.MergeMenu(menuSrc);
+            AssertEqualMenuItems(expectedItems, menu.MenuItems.Cast<MenuItem>().ToArray());
+        }
+
+        [Fact]
+        public void Menu_MergeMenu_SameSourceAndDestination_ThrowsArgumentException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            Assert.Throws<ArgumentException>("menuSrc", () => menu.MergeMenu(menu));
+        }
+
+        [Fact]
+        public void Menu_MergeMenu_NullSource_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            Assert.Throws<ArgumentNullException>("menuSrc", () => menu.MergeMenu(null));
+        }
+
+        public static IEnumerable<object[]> CloneMenu_TestData()
+        {
+            yield return new object[] { Array.Empty<MenuItem>() };
+            yield return new object[] { new MenuItem[] { new MenuItem("text") } };
+        }
+
+        [Theory]
+        [MemberData(nameof(CloneMenu_TestData))]
+        public void Menu_CloneMenu_Invoke_Success(MenuItem[] items)
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            menu.CloneMenu(new SubMenu(items));
+            AssertEqualMenuItems(items, menu.MenuItems.Cast<MenuItem>().ToArray());
+            for (int i = 0; i < items.Length; i++)
+            {
+                Assert.Equal(i, menu.MenuItems[i].Index);
+                Assert.Equal(menu, menu.MenuItems[i].Parent);
+            }
+        }
+
+        [Fact]
+        public void Menu_CloneMenu_NullMenuSource_ThrowsArgumentNullException()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            Assert.Throws<ArgumentNullException>("menuSrc", () => menu.CloneMenu(null));
+        }
+
+        [Fact]
+        public void Menu_CreateMenuHandle_Invoke_ReturnsExpected()
+        {
+            var menu = new SubMenu(Array.Empty<MenuItem>());
+            Assert.NotEqual(IntPtr.Zero, menu.CreateMenuHandle());
+        }
+
+        [Fact]
+        public void Menu_ToString_Invoke_ReturnsExpected()
+        {
+            var menu = new SubMenu(new MenuItem[] { new MenuItem() });
+            Assert.Equal("WTG.System.Windows.Forms.Tests.MenuTests+SubMenu, Items.Count: 1", menu.ToString());
+        }
+
+        internal static void AssertEqualMenuItems(MenuItem[] expected, MenuItem[] actual)
+        {
+            Assert.Equal(expected.Length, actual.Length);
+            try
+            {
+                Assert.Equal(expected.Select(m => m.Text), actual.Cast<MenuItem>().Select(m => m.Text));
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            for (int i = 0; i < expected.Length; i++)
+            {
+                AssertEqualMenuItem(expected[i], actual[i]);
+            }
+        }
+
+        internal static void AssertEqualMenuItem(MenuItem expected, MenuItem actual)
+        {
+            try
+            {
+                Assert.Equal(expected.Name, actual.Name);
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            AssertEqualMenuItems(expected.MenuItems.Cast<MenuItem>().ToArray(), actual.MenuItems.Cast<MenuItem>().ToArray());
+        }
+
+        private class SubMenu : Menu
+        {
+            public SubMenu(MenuItem[] items) : base(items)
+            {
+            }
+
+            public new IntPtr CreateMenuHandle() => base.CreateMenuHandle();
+
+            public new int FindMergePosition(int mergeOrder) => base.FindMergePosition(mergeOrder);
+
+            public new void CloneMenu(Menu menuSrc) => base.CloneMenu(menuSrc);
+
+            public new bool ProcessCmdKey(ref Message msg, Keys keyData) => base.ProcessCmdKey(ref msg, keyData);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/StatusBarDrawItemEventArgsTests.cs b/WTG.System.Windows.Forms.Tests/StatusBarDrawItemEventArgsTests.cs
new file mode 100644
index 00000000000..36d2b65c4c1
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/StatusBarDrawItemEventArgsTests.cs
@@ -0,0 +1,64 @@
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class StatusBarDrawItemEventArgsTests
+    {
+        public static IEnumerable<object[]> Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel_TestData()
+        {
+            yield return new object[] { null, Rectangle.Empty, -2, (DrawItemState)(DrawItemState.None - 1), null, SystemColors.HighlightText, SystemColors.Highlight };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), -1, DrawItemState.None, new StatusBarPanel(), SystemColors.WindowText, SystemColors.Window };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(-1, 2, -3, -4), 0, DrawItemState.Selected, new StatusBarPanel(), SystemColors.HighlightText, SystemColors.Highlight };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus, new StatusBarPanel(), SystemColors.WindowText, SystemColors.Window };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus | DrawItemState.NoFocusRect, new StatusBarPanel(), SystemColors.WindowText, SystemColors.Window };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel_TestData))]
+        public void StatusBarDrawItemEventArgs_Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel(Font font, Rectangle rect, int index, DrawItemState state, StatusBarPanel panel, Color expectedForeColor, Color expectedBackColor)
+        {
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                var e = new StatusBarDrawItemEventArgs(graphics, font, rect, index, state, panel);
+                Assert.Same(graphics, e.Graphics);
+                Assert.Same(font, e.Font);
+                Assert.Equal(rect, e.Bounds);
+                Assert.Equal(index, e.Index);
+                Assert.Equal(state, e.State);
+                Assert.Same(panel, e.Panel);
+                Assert.Equal(expectedForeColor, e.ForeColor);
+                Assert.Equal(expectedBackColor, e.BackColor);
+            }
+        }
+
+        public static IEnumerable<object[]> Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel_Color_Color_TestData()
+        {
+            yield return new object[] { null, Rectangle.Empty, -2, (DrawItemState)(DrawItemState.None - 1), null, Color.Empty, Color.Empty, SystemColors.HighlightText, SystemColors.Highlight };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), -1, DrawItemState.None, new StatusBarPanel(), Color.Red, Color.Blue, Color.Red, Color.Blue };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(-1, 2, -3, -4), 0, DrawItemState.Selected, new StatusBarPanel(), Color.Red, Color.Blue, SystemColors.HighlightText, SystemColors.Highlight };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus, new StatusBarPanel(), Color.Red, Color.Blue, Color.Red, Color.Blue };
+            yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus | DrawItemState.NoFocusRect, new StatusBarPanel(), Color.Red, Color.Blue, Color.Red, Color.Blue };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel_Color_Color_TestData))]
+        public void StatusBarDrawItemEventArgs_Ctor_Graphics_Font_Rectangle_Int_DrawItemState_StatusBarPanel_Color_Color(Font font, Rectangle rect, int index, DrawItemState state, StatusBarPanel panel, Color foreColor, Color backColor, Color expectedForeColor, Color expectedBackColor)
+        {
+            using (var image = new Bitmap(10, 10))
+            using (Graphics graphics = Graphics.FromImage(image))
+            {
+                var e = new StatusBarDrawItemEventArgs(graphics, font, rect, index, state, panel, foreColor, backColor);
+                Assert.Same(graphics, e.Graphics);
+                Assert.Same(font, e.Font);
+                Assert.Equal(rect, e.Bounds);
+                Assert.Equal(index, e.Index);
+                Assert.Equal(state, e.State);
+                Assert.Same(panel, e.Panel);
+                Assert.Equal(expectedForeColor, e.ForeColor);
+                Assert.Equal(expectedBackColor, e.BackColor);
+            }
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/StatusBarPanelClickEventArgsTests.cs b/WTG.System.Windows.Forms.Tests/StatusBarPanelClickEventArgsTests.cs
new file mode 100644
index 00000000000..91780370e87
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/StatusBarPanelClickEventArgsTests.cs
@@ -0,0 +1,29 @@
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.Tests
+{
+    public class StatusBarPanelClickEventArgsTests
+    {
+        public static IEnumerable<object[]> Ctor_StatusBarPanel_MouseButtons_Int_Int_Int_Int_TestData()
+        {
+            yield return new object[] { null, MouseButtons.Left, 1, 2, 3 };
+            yield return new object[] { new StatusBarPanel(), (MouseButtons)1, 0, 0, 0 };
+            yield return new object[] { new StatusBarPanel(), (MouseButtons)3, -1, -1, -1 };
+        }
+
+        [Theory]
+        [MemberData(nameof(Ctor_StatusBarPanel_MouseButtons_Int_Int_Int_Int_TestData))]
+        public void Ctor_StatusBarPanel_MouseButtons_Int_Int_Int_Int(StatusBarPanel statusBarPanel, MouseButtons button, int clicks, int x, int y)
+        {
+            var e = new StatusBarPanelClickEventArgs(statusBarPanel, button, clicks, x, y);
+            Assert.Equal(statusBarPanel, e.StatusBarPanel);
+            Assert.Equal(button, e.Button);
+            Assert.Equal(clicks, e.Clicks);
+            Assert.Equal(x, e.X);
+            Assert.Equal(y, e.Y);
+            Assert.Equal(0, e.Delta);
+            Assert.Equal(new Point(x, y), e.Location);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ErrorProviderTests.cs b/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ErrorProviderTests.cs
new file mode 100644
index 00000000000..20ad08bf227
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ErrorProviderTests.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.System.Windows.Forms
+{
+    public class ErrorProviderTests
+    {
+        public static IEnumerable<object[]> CanExtend_TestData()
+        {
+            yield return new object[] { null, false };
+            yield return new object[] { new(), false };
+            yield return new object[] { new Component(), false };
+            yield return new object[] { new ToolBar(), false };
+            yield return new object[] { new Form(), false };
+            yield return new object[] { new Control(), true };
+        }
+
+        [Theory]
+        [MemberData(nameof(CanExtend_TestData))]
+        public void ErrorProvider_CanExtend_Invoke_ReturnsExpected(object extendee, bool expected)
+        {
+            var provider = new ErrorProvider();
+            Assert.Equal(expected, provider.CanExtend(extendee));
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ToolBarButtonClickEventArgsTests.cs b/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ToolBarButtonClickEventArgsTests.cs
new file mode 100644
index 00000000000..e9dc4ac9785
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/System/Windows/Forms/ToolBarButtonClickEventArgsTests.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms.Tests
+{
+    public class ToolBarButtonClickEventArgsTests
+    {
+        public static IEnumerable<object[]> ToolBarButton_TestData()
+        {
+            yield return new object[] { null };
+            yield return new object[] { new ToolBarButton() };
+        }
+
+        [Theory]
+        [MemberData(nameof(ToolBarButton_TestData))]
+        public void Ctor_ToolBarButton(ToolBarButton button)
+        {
+            var e = new ToolBarButtonClickEventArgs(button);
+            Assert.Equal(button, e.Button);
+        }
+
+        [Theory]
+        [MemberData(nameof(ToolBarButton_TestData))]
+        public void Button_Set_GetReturnsExpected(ToolBarButton value)
+        {
+            var e = new ToolBarButtonClickEventArgs(new ToolBarButton())
+            {
+                Button = value
+            };
+            Assert.Equal(value, e.Button);
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/VisualStyles/VisualStyleElementTests.cs b/WTG.System.Windows.Forms.Tests/VisualStyles/VisualStyleElementTests.cs
new file mode 100644
index 00000000000..0884387723d
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/VisualStyles/VisualStyleElementTests.cs
@@ -0,0 +1,658 @@
+using System.Windows.Forms.VisualStyles;
+
+namespace WTG.System.Windows.Forms.Tests.VisualStyles
+{
+    public class VisualStyleElementTests
+    {
+        public static IEnumerable<object[]> CreateElement_TestData()
+        {
+            yield return new object[] { string.Empty, 0, 0 };
+            yield return new object[] { "className", -1, -2 };
+        }
+
+        [Theory]
+        [MemberData(nameof(CreateElement_TestData))]
+        public void VisualStyleElement_CreateElement_Invoke_ReturnsExpected(string className, int part, int state)
+        {
+            VisualStyleElement element = VisualStyleElement.CreateElement(className, part, state);
+            Assert.Same(className, element.ClassName);
+            Assert.Equal(part, element.Part);
+            Assert.Equal(state, element.State);
+        }
+
+        [Fact]
+        public void VisualStyleElement_CreateElement_NullClassName_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>("className", () => VisualStyleElement.CreateElement(null, 1, 2));
+        }
+
+        public static IEnumerable<object[]> KnownElements_TestData()
+        {
+            // Identity function to avoid constant casting
+            Func<VisualStyleElement> I(Func<VisualStyleElement> factory) => factory;
+
+            yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Normal), "BUTTON", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Hot), "BUTTON", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Pressed), "BUTTON", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Disabled), "BUTTON", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Default), "BUTTON", 1, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedNormal), "BUTTON", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedHot), "BUTTON", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedPressed), "BUTTON", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedDisabled), "BUTTON", 2, 4 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedNormal), "BUTTON", 2, 5 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedHot), "BUTTON", 2, 6 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedPressed), "BUTTON", 2, 7 };
+            yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedDisabled), "BUTTON", 2, 8 };
+
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedNormal), "BUTTON", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedHot), "BUTTON", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedPressed), "BUTTON", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedDisabled), "BUTTON", 3, 4 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedNormal), "BUTTON", 3, 5 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedHot), "BUTTON", 3, 6 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedPressed), "BUTTON", 3, 7 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedDisabled), "BUTTON", 3, 8 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedNormal), "BUTTON", 3, 9 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedHot), "BUTTON", 3, 10 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedPressed), "BUTTON", 3, 11 };
+            yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedDisabled), "BUTTON", 3, 12 };
+
+            yield return new object[] { I(() => VisualStyleElement.Button.GroupBox.Normal), "BUTTON", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Button.GroupBox.Disabled), "BUTTON", 4, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Button.UserButton.Normal), "BUTTON", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Normal), "COMBOBOX", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Hot), "COMBOBOX", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Pressed), "COMBOBOX", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Disabled), "COMBOBOX", 1, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.Border.Normal), "COMBOBOX", 4, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.ReadOnlyButton.Normal), "COMBOBOX", 5, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButtonRight.Normal), "COMBOBOX", 6, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButtonLeft.Normal), "COMBOBOX", 7, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Page.Up.Normal), "PAGE", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Up.Hot), "PAGE", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Up.Pressed), "PAGE", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Up.Disabled), "PAGE", 1, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Page.Down.Normal), "PAGE", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Down.Hot), "PAGE", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Down.Pressed), "PAGE", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Page.Down.Disabled), "PAGE", 2, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Normal), "PAGE", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Hot), "PAGE", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Pressed), "PAGE", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Disabled), "PAGE", 3, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Normal), "PAGE", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Hot), "PAGE", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Pressed), "PAGE", 4, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Disabled), "PAGE", 4, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Spin.Up.Normal), "SPIN", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Up.Hot), "SPIN", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Up.Pressed), "SPIN", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Up.Disabled), "SPIN", 1, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Spin.Down.Normal), "SPIN", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Down.Hot), "SPIN", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Down.Pressed), "SPIN", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.Down.Disabled), "SPIN", 2, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Normal), "SPIN", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Hot), "SPIN", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Pressed), "SPIN", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Disabled), "SPIN", 3, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Normal), "SPIN", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Hot), "SPIN", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Pressed), "SPIN", 4, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Disabled), "SPIN", 4, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpNormal), "SCROLLBAR", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpHot), "SCROLLBAR", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpPressed), "SCROLLBAR", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpDisabled), "SCROLLBAR", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownNormal), "SCROLLBAR", 1, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownHot), "SCROLLBAR", 1, 6 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownPressed), "SCROLLBAR", 1, 7 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownDisabled), "SCROLLBAR", 1, 8 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftNormal), "SCROLLBAR", 1, 9 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftHot), "SCROLLBAR", 1, 10 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftPressed), "SCROLLBAR", 1, 11 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftDisabled), "SCROLLBAR", 1, 12 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightNormal), "SCROLLBAR", 1, 13 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightHot), "SCROLLBAR", 1, 14 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightPressed), "SCROLLBAR", 1, 15 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightDisabled), "SCROLLBAR", 1, 16 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Normal), "SCROLLBAR", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Hot), "SCROLLBAR", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Pressed), "SCROLLBAR", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Disabled), "SCROLLBAR", 2, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Normal), "SCROLLBAR", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Hot), "SCROLLBAR", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Pressed), "SCROLLBAR", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Disabled), "SCROLLBAR", 3, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Normal), "SCROLLBAR", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Hot), "SCROLLBAR", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Pressed), "SCROLLBAR", 4, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Disabled), "SCROLLBAR", 4, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Normal), "SCROLLBAR", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Hot), "SCROLLBAR", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Pressed), "SCROLLBAR", 5, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Disabled), "SCROLLBAR", 5, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Normal), "SCROLLBAR", 6, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Hot), "SCROLLBAR", 6, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Pressed), "SCROLLBAR", 6, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled), "SCROLLBAR", 6, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Normal), "SCROLLBAR", 7, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Hot), "SCROLLBAR", 7, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Pressed), "SCROLLBAR", 7, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Disabled), "SCROLLBAR", 7, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.GripperHorizontal.Normal), "SCROLLBAR", 8, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.GripperVertical.Normal), "SCROLLBAR", 9, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.SizeBox.RightAlign), "SCROLLBAR", 10, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ScrollBar.SizeBox.LeftAlign), "SCROLLBAR", 10, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Normal), "TAB", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Hot), "TAB", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Pressed), "TAB", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Disabled), "TAB", 1, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Normal), "TAB", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Hot), "TAB", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Pressed), "TAB", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Disabled), "TAB", 2, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Normal), "TAB", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Hot), "TAB", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Pressed), "TAB", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Disabled), "TAB", 3, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TabItemBothEdges.Normal), "TAB", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Normal), "TAB", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Hot), "TAB", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Pressed), "TAB", 5, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Disabled), "TAB", 5, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Normal), "TAB", 6, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Hot), "TAB", 6, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Pressed), "TAB", 6, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Disabled), "TAB", 6, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Normal), "TAB", 7, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Hot), "TAB", 7, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Pressed), "TAB", 7, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Disabled), "TAB", 7, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemBothEdges.Normal), "TAB", 8, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.Pane.Normal), "TAB", 9, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Tab.Body.Normal), "TAB", 10, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderBackground.Normal), "EXPLORERBAR", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Normal), "EXPLORERBAR", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Hot), "EXPLORERBAR", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Pressed), "EXPLORERBAR", 2, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Normal), "EXPLORERBAR", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Hot), "EXPLORERBAR", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Pressed), "EXPLORERBAR", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedNormal), "EXPLORERBAR", 3, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedHot), "EXPLORERBAR", 3, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedPressed), "EXPLORERBAR", 3, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Normal), "EXPLORERBAR", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Hot), "EXPLORERBAR", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Pressed), "EXPLORERBAR", 4, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupBackground.Normal), "EXPLORERBAR", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Normal), "EXPLORERBAR", 6, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Hot), "EXPLORERBAR", 6, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Pressed), "EXPLORERBAR", 6, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Normal), "EXPLORERBAR", 7, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Hot), "EXPLORERBAR", 7, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Pressed), "EXPLORERBAR", 7, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupHead.Normal), "EXPLORERBAR", 8, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupBackground.Normal), "EXPLORERBAR", 9, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Normal), "EXPLORERBAR", 10, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Hot), "EXPLORERBAR", 10, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Pressed), "EXPLORERBAR", 10, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Normal), "EXPLORERBAR", 11, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Hot), "EXPLORERBAR", 11, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Pressed), "EXPLORERBAR", 11, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupHead.Normal), "EXPLORERBAR", 12, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Header.Item.Normal), "HEADER", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Header.Item.Hot), "HEADER", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Header.Item.Pressed), "HEADER", 1, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Normal), "HEADER", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Hot), "HEADER", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Pressed), "HEADER", 2, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Normal), "HEADER", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Hot), "HEADER", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Pressed), "HEADER", 3, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Header.SortArrow.SortedUp), "HEADER", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Header.SortArrow.SortedDown), "HEADER", 4, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.ListView.Item.Normal), "LISTVIEW", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ListView.Item.Hot), "LISTVIEW", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ListView.Item.Selected), "LISTVIEW", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ListView.Item.Disabled), "LISTVIEW", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ListView.Item.SelectedNotFocus), "LISTVIEW", 1, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.ListView.Group.Normal), "LISTVIEW", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ListView.Detail.Normal), "LISTVIEW", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ListView.SortedDetail.Normal), "LISTVIEW", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ListView.EmptyText.Normal), "LISTVIEW", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Normal), "MENUBAND", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Hot), "MENUBAND", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Pressed), "MENUBAND", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Disabled), "MENUBAND", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Checked), "MENUBAND", 1, 5 };
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.HotChecked), "MENUBAND", 1, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.MenuBand.Separator.Normal), "MENUBAND", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.Item.Normal), "MENU", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Menu.Item.Selected), "MENU", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Menu.Item.Demoted), "MENU", 1, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.DropDown.Normal), "MENU", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.BarItem.Normal), "MENU", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.BarDropDown.Normal), "MENU", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.Chevron.Normal), "MENU", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Menu.Separator.Normal), "MENU", 6, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ProgressBar.Bar.Normal), "PROGRESS", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ProgressBar.BarVertical.Normal), "PROGRESS", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ProgressBar.Chunk.Normal), "PROGRESS", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ProgressBar.ChunkVertical.Normal), "PROGRESS", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Rebar.Gripper.Normal), "REBAR", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Rebar.GripperVertical.Normal), "REBAR", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Rebar.Band.Normal), "REBAR", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Normal), "REBAR", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Hot), "REBAR", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Pressed), "REBAR", 4, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Normal), "REBAR", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Hot), "REBAR", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Pressed), "REBAR", 5, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.UserPane.Normal), "STARTPANEL", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.MorePrograms.Normal), "STARTPANEL", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Normal), "STARTPANEL", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Hot), "STARTPANEL", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Pressed), "STARTPANEL", 3, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.ProgList.Normal), "STARTPANEL", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.ProgListSeparator.Normal), "STARTPANEL", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.PlaceList.Normal), "STARTPANEL", 6, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.PlaceListSeparator.Normal), "STARTPANEL", 7, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOff.Normal), "STARTPANEL", 8, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Normal), "STARTPANEL", 9, 1 };
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Hot), "STARTPANEL", 9, 2 };
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Pressed), "STARTPANEL", 9, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.UserPicture.Normal), "STARTPANEL", 10, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.StartPanel.Preview.Normal), "STARTPANEL", 11, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Status.Bar.Normal), "STATUS", 0, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Status.Pane.Normal), "STATUS", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Status.GripperPane.Normal), "STATUS", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Status.Gripper.Normal), "STATUS", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TaskBand.GroupCount.Normal), "TASKBAND", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TaskBand.FlashButton.Normal), "TASKBAND", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TaskBand.FlashButtonGroupMenu.Normal), "TASKBAND", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TaskbarClock.Time.Normal), "CLOCK", 1, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundBottom.Normal), "TASKBAR", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundRight.Normal), "TASKBAR", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundTop.Normal), "TASKBAR", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundLeft.Normal), "TASKBAR", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarBottom.Normal), "TASKBAR", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarRight.Normal), "TASKBAR", 6, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarTop.Normal), "TASKBAR", 7, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarLeft.Normal), "TASKBAR", 8, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Bar.Normal), "TOOLBAR", 0, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Bar.Normal), "TOOLBAR", 0, 0 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Normal), "TOOLBAR", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Hot), "TOOLBAR", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Pressed), "TOOLBAR", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Disabled), "TOOLBAR", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Checked), "TOOLBAR", 1, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.HotChecked), "TOOLBAR", 1, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Normal), "TOOLBAR", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Hot), "TOOLBAR", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Pressed), "TOOLBAR", 2, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Disabled), "TOOLBAR", 2, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Checked), "TOOLBAR", 2, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.HotChecked), "TOOLBAR", 2, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Normal), "TOOLBAR", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Hot), "TOOLBAR", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Pressed), "TOOLBAR", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Disabled), "TOOLBAR", 3, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Checked), "TOOLBAR", 3, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.HotChecked), "TOOLBAR", 3, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Normal), "TOOLBAR", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Hot), "TOOLBAR", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Pressed), "TOOLBAR", 4, 3 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Disabled), "TOOLBAR", 4, 4 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Checked), "TOOLBAR", 4, 5 };
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.HotChecked), "TOOLBAR", 4, 6 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SeparatorHorizontal.Normal), "TOOLBAR", 5, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolBar.SeparatorVertical.Normal), "TOOLBAR", 6, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Standard.Normal), "TOOLTIP", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Standard.Link), "TOOLTIP", 1, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.StandardTitle.Normal), "TOOLTIP", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Balloon.Normal), "TOOLTIP", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Balloon.Link), "TOOLTIP", 3, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.BalloonTitle.Normal), "TOOLTIP", 4, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Normal), "TOOLTIP", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Hot), "TOOLTIP", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Pressed), "TOOLTIP", 5, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Track.Normal), "TRACKBAR", 1, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.TrackVertical.Normal), "TRACKBAR", 2, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Normal), "TRACKBAR", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Hot), "TRACKBAR", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Pressed), "TRACKBAR", 3, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Focused), "TRACKBAR", 3, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Disabled), "TRACKBAR", 3, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Normal), "TRACKBAR", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Hot), "TRACKBAR", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Pressed), "TRACKBAR", 4, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Focused), "TRACKBAR", 4, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Disabled), "TRACKBAR", 4, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Normal), "TRACKBAR", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Hot), "TRACKBAR", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Pressed), "TRACKBAR", 5, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Focused), "TRACKBAR", 5, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Disabled), "TRACKBAR", 5, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Normal), "TRACKBAR", 6, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Hot), "TRACKBAR", 6, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Pressed), "TRACKBAR", 6, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Focused), "TRACKBAR", 6, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Disabled), "TRACKBAR", 6, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Normal), "TRACKBAR", 7, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Hot), "TRACKBAR", 7, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Pressed), "TRACKBAR", 7, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Focused), "TRACKBAR", 7, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Disabled), "TRACKBAR", 7, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Normal), "TRACKBAR", 8, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Hot), "TRACKBAR", 8, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Pressed), "TRACKBAR", 8, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Focused), "TRACKBAR", 8, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Disabled), "TRACKBAR", 8, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.Ticks.Normal), "TRACKBAR", 9, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrackBar.TicksVertical.Normal), "TRACKBAR", 10, 1 };
+
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Normal), "TREEVIEW", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Hot), "TREEVIEW", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Selected), "TREEVIEW", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Disabled), "TREEVIEW", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Item.SelectedNotFocus), "TREEVIEW", 1, 5 };
+
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Glyph.Closed), "TREEVIEW", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Glyph.Opened), "TREEVIEW", 2, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.TreeView.Branch.Normal), "TREEVIEW", 3, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.ExplorerTreeView.Glyph.Closed), "Explorer::TreeView", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.ExplorerTreeView.Glyph.Opened), "Explorer::TreeView", 2, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Normal), "EDIT", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Hot), "EDIT", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Selected), "EDIT", 1, 3 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Disabled), "EDIT", 1, 4 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Focused), "EDIT", 1, 5 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.ReadOnly), "EDIT", 1, 6 };
+            yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Assist), "EDIT", 1, 7 };
+
+            yield return new object[] { I(() => VisualStyleElement.TextBox.Caret.Normal), "EDIT", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrayNotify.Background.Normal), "TRAYNOTIFY", 1, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.TrayNotify.AnimateBackground.Normal), "TRAYNOTIFY", 2, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.Caption.Active), "WINDOW", 1, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.Caption.Inactive), "WINDOW", 1, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.Caption.Disabled), "WINDOW", 1, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Active), "WINDOW", 2, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Inactive), "WINDOW", 2, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Disabled), "WINDOW", 2, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Active), "WINDOW", 3, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Inactive), "WINDOW", 3, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Disabled), "WINDOW", 3, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Active), "WINDOW", 4, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Inactive), "WINDOW", 4, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Disabled), "WINDOW", 4, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Active), "WINDOW", 5, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Inactive), "WINDOW", 5, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Disabled), "WINDOW", 5, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Active), "WINDOW", 6, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Inactive), "WINDOW", 6, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Disabled), "WINDOW", 6, 3 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameLeft.Active), "WINDOW", 7, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameLeft.Inactive), "WINDOW", 7, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameRight.Active), "WINDOW", 8, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameRight.Inactive), "WINDOW", 8, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameBottom.Active), "WINDOW", 9, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameBottom.Inactive), "WINDOW", 9, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeft.Active), "WINDOW", 10, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeft.Inactive), "WINDOW", 10, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRight.Active), "WINDOW", 11, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRight.Inactive), "WINDOW", 11, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottom.Active), "WINDOW", 12, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottom.Inactive), "WINDOW", 12, 2 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Normal), "WINDOW", 13, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Hot), "WINDOW", 13, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Pressed), "WINDOW", 13, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Disabled), "WINDOW", 13, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Normal), "WINDOW", 14, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Hot), "WINDOW", 14, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Pressed), "WINDOW", 14, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Disabled), "WINDOW", 14, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Normal), "WINDOW", 15, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Hot), "WINDOW", 15, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Pressed), "WINDOW", 15, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Disabled), "WINDOW", 15, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Normal), "WINDOW", 16, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Hot), "WINDOW", 16, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Pressed), "WINDOW", 16, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Disabled), "WINDOW", 16, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Normal), "WINDOW", 17, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Hot), "WINDOW", 17, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Pressed), "WINDOW", 17, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Disabled), "WINDOW", 17, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Normal), "WINDOW", 18, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Hot), "WINDOW", 18, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Pressed), "WINDOW", 18, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Disabled), "WINDOW", 18, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Normal), "WINDOW", 19, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Hot), "WINDOW", 19, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Pressed), "WINDOW", 19, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Disabled), "WINDOW", 19, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Normal), "WINDOW", 20, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Hot), "WINDOW", 20, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Pressed), "WINDOW", 20, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Disabled), "WINDOW", 20, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Normal), "WINDOW", 21, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Hot), "WINDOW", 21, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Pressed), "WINDOW", 21, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Disabled), "WINDOW", 21, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Normal), "WINDOW", 22, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Hot), "WINDOW", 22, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Pressed), "WINDOW", 22, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Disabled), "WINDOW", 22, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Normal), "WINDOW", 23, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Hot), "WINDOW", 23, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Pressed), "WINDOW", 23, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Disabled), "WINDOW", 23, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Normal), "WINDOW", 24, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Hot), "WINDOW", 24, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Pressed), "WINDOW", 24, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Disabled), "WINDOW", 24, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Normal), "WINDOW", 25, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Hot), "WINDOW", 25, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Pressed), "WINDOW", 25, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Disabled), "WINDOW", 25, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Normal), "WINDOW", 26, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Hot), "WINDOW", 26, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Pressed), "WINDOW", 26, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Disabled), "WINDOW", 26, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Normal), "WINDOW", 27, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Hot), "WINDOW", 27, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Pressed), "WINDOW", 27, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Disabled), "WINDOW", 27, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Normal), "WINDOW", 28, 1 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Hot), "WINDOW", 28, 2 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Pressed), "WINDOW", 28, 3 };
+            yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Disabled), "WINDOW", 28, 4 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.Dialog.Normal), "WINDOW", 29, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.CaptionSizingTemplate.Normal), "WINDOW", 30, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallCaptionSizingTemplate.Normal), "WINDOW", 31, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameLeftSizingTemplate.Normal), "WINDOW", 32, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeftSizingTemplate.Normal), "WINDOW", 33, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameRightSizingTemplate.Normal), "WINDOW", 34, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRightSizingTemplate.Normal), "WINDOW", 35, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.FrameBottomSizingTemplate.Normal), "WINDOW", 36, 0 };
+
+            yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottomSizingTemplate.Normal), "WINDOW", 37, 0 };
+        }
+
+        [Theory]
+        [MemberData(nameof(KnownElements_TestData))]
+        public void VisualStyleElement_KnownElements_Get_ReturnsExpected(Func<VisualStyleElement> elementFactory, string expectedClassName, int expectedPart, int expectedState)
+        {
+            VisualStyleElement element = elementFactory();
+            Assert.Same(expectedClassName, element.ClassName);
+            Assert.Equal(expectedPart, element.Part);
+            Assert.Equal(expectedState, element.State);
+            Assert.Same(element, elementFactory());
+        }
+    }
+}
diff --git a/WTG.System.Windows.Forms.Tests/WTG.System.Windows.Forms.Tests.csproj b/WTG.System.Windows.Forms.Tests/WTG.System.Windows.Forms.Tests.csproj
new file mode 100644
index 00000000000..4ec0d76dcbe
--- /dev/null
+++ b/WTG.System.Windows.Forms.Tests/WTG.System.Windows.Forms.Tests.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+	<!-- Additional suppressions relating to use of nullability were put in to handle the DAT warnings.  -->
+    <!-- ToDo: Remove the suppresions one at a time to adhere to the recommended coding styles. -->
+    <NoWarn>CS8625;CS8603;CS8600;CS8602;CS8604;CS8618;CS1591;CS8601;CS8619;CA1805;SA1507;SA1517;CSIsNull001;CA1825;IDE0090;SA1513</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="moq" Version="4.20.70" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\System.Windows.Forms\src\WTG.System.Windows.Forms.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Winforms.sln b/Winforms.sln
index 6dd1b54eeaf..2b5a8c2dad1 100644
--- a/Winforms.sln
+++ b/Winforms.sln
@@ -2,165 +2,44 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.0.31808.319
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WinformsControlsTest", "src\System.Windows.Forms\tests\IntegrationTests\WinformsControlsTest\WinformsControlsTest.csproj", "{657472B8-FDA3-49DF-B8BE-0246046A4348}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms", "src\System.Windows.Forms\src\System.Windows.Forms.csproj", "{0D23A41B-2626-4703-9E4A-87C07F69B0B2}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Tests", "src\System.Windows.Forms\tests\UnitTests\System.Windows.Forms.Tests.csproj", "{AB38E262-F206-4820-8F29-23C5F72A4A16}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Design.Tests", "src\System.Windows.Forms.Design\tests\UnitTests\System.Windows.Forms.Design.Tests.csproj", "{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Design", "src\System.Windows.Forms.Design\src\System.Windows.Forms.Design.csproj", "{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Drawing.Design.Facade", "src\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj", "{A2B1148A-1747-47BD-8048-416C2C2AF14C}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Design.Facade", "src\System.Design\src\System.Design.Facade.csproj", "{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Private.Winforms", "pkg\Microsoft.Private.Winforms\Microsoft.Private.Winforms.csproj", "{F133342A-3040-4005-A2F0-7685AA7CB82D}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Dotnet.Winforms.ProjectTemplates", "pkg\Microsoft.Dotnet.WinForms.ProjectTemplates\Microsoft.Dotnet.Winforms.ProjectTemplates.csproj", "{36A5139E-3E9C-42BD-95EE-818153A487DB}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "pkg", "pkg", "{989F376E-AE19-43B0-A3E6-96A7E22B4E80}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{DF68A171-D27B-4E6A-8A7E-63A651622355}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "facade", "facade", "{434C00C3-E498-4BA7-9764-9F0FC8CFE457}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "unit", "unit", "{583F1292-AE8D-4511-B8D8-A81FE4642DDC}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "integration", "integration", "{680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.IntegrationTests", "src\System.Windows.Forms\tests\IntegrationTests\System.Windows.Forms.IntegrationTests\System.Windows.Forms.IntegrationTests.csproj", "{238195CE-7CCE-4469-ACD8-EA00E88D947A}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Drawing.Facade", "src\System.Drawing\src\System.Drawing.Facade.csproj", "{F1B0790A-1A40-4487-A607-36D21D827E44}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Accessibility", "src\Accessibility\src\Accessibility.ilproj", "{351D8601-6E21-45E8-B3B9-847C4540BD4E}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Accessibility-version", "src\Accessibility\ver\Accessibility-version.csproj", "{6103E743-057D-41C6-946C-23A751A08748}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Accessibility", "Accessibility", "{088DD24C-DF6B-45F3-A8BC-592580A4B2A9}"
-	ProjectSection(SolutionItems) = preProject
-		src\Accessibility\readme.md = src\Accessibility\readme.md
-	EndProjectSection
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.IntegrationTests.Common", "src\System.Windows.Forms\tests\IntegrationTests\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj", "{48979B4E-EAEC-4B41-BB49-44CA230BECAB}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{462AD69A-9395-4E98-882D-569CDE562559}"
-	ProjectSection(SolutionItems) = preProject
-		azure-pipelines.yml = azure-pipelines.yml
-		eng\common\templates\job\build.yml = eng\common\templates\job\build.yml
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "documentation", "documentation", "{C029199F-7D5C-417C-AA52-913A214E3285}"
-	ProjectSection(SolutionItems) = preProject
-		docs\building.md = docs\building.md
-		CODE_OF_CONDUCT.md = CODE_OF_CONDUCT.md
-		CONTRIBUTING.md = CONTRIBUTING.md
-		docs\debugging.md = docs\debugging.md
-		docs\developer-guide.md = docs\developer-guide.md
-		docs\getting-started.md = docs\getting-started.md
-		docs\issue-guide.md = docs\issue-guide.md
-		docs\porting-guidelines.md = docs\porting-guidelines.md
-		README.md = README.md
-		docs\roadmap.md = docs\roadmap.md
-		docs\testing.md = docs\testing.md
-		THIRD-PARTY-NOTICES.TXT = THIRD-PARTY-NOTICES.TXT
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Accessibility", "Accessibility", "{D390F7D2-1E11-4DEE-B7F1-4FD0681A81F0}"
-EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualBasic.Forms", "src\Microsoft.VisualBasic.Forms\src\Microsoft.VisualBasic.Forms.vbproj", "{55E34830-B375-41FF-AFCA-F53B80A4D152}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualBasic.Tests", "src\Microsoft.VisualBasic\tests\UnitTests\Microsoft.VisualBasic.Tests.csproj", "{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualBasic.Facade", "src\Microsoft.VisualBasic\src\Microsoft.VisualBasic.Facade.csproj", "{A756D568-AC89-4577-A9B2-E147784AB728}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.VisualBasic.IntegrationTests", "src\Microsoft.VisualBasic\tests\IntegrationTests\Microsoft.VisualBasic.IntegrationTests\Microsoft.VisualBasic.IntegrationTests.csproj", "{1C6F6ADA-97B1-4EB9-934D-0071BB618729}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VisualBasicRuntimeTest", "src\Microsoft.VisualBasic\tests\IntegrationTests\VisualBasicRuntimeTest\VisualBasicRuntimeTest.csproj", "{EC7608D1-1857-432E-930F-0F89B98979FB}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Primitives", "src\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj", "{90B27178-F535-43F7-886E-0AB75203F246}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Primitives.Tests", "src\System.Windows.Forms.Primitives\tests\UnitTests\System.Windows.Forms.Primitives.Tests.csproj", "{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4AA2764C-B013-40B5-9E5B-9459EF976C8B}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		.gitattributes = .gitattributes
 		.gitignore = .gitignore
+		Build.xml = Build.xml
+		DeploymentSetup.ps1 = DeploymentSetup.ps1
 		Directory.Build.props = Directory.Build.props
 		Directory.Build.targets = Directory.Build.targets
+		..\..\..\wtg\CargoWise\Dev\EDI-Release-private.snk = ..\..\..\wtg\CargoWise\Dev\EDI-Release-private.snk
 		global.json = global.json
 		NuGet.Config = NuGet.Config
+		README.md = README.md
 		start-vs.cmd = start-vs.cmd
 		eng\Versions.props = eng\Versions.props
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Design.Editors.Facade3x", "src\System.Windows.Forms.Design.Editors\src\System.Windows.Forms.Design.Editors.Facade3x.csproj", "{E0681991-228A-420E-85D5-A9E796F0AAE0}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Primitives.TestUtilities", "src\System.Windows.Forms.Primitives\tests\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj", "{73B0857A-966B-4E7D-8A83-FECFE0281AB9}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.TestUtilities", "src\System.Windows.Forms\tests\TestUtilities\System.Windows.Forms.TestUtilities.csproj", "{86418F0B-39DC-4B5A-8145-6D607E6150AC}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Interop.Tests", "src\System.Windows.Forms\tests\InteropTests\System.Windows.Forms.Interop.Tests.csproj", "{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.PrivateSourceGenerators", "src\System.Windows.Forms.PrivateSourceGenerators\src\System.Windows.Forms.PrivateSourceGenerators.csproj", "{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.PrivateSourceGenerators.Tests", "src\System.Windows.Forms.PrivateSourceGenerators\tests\UnitTests\System.Windows.Forms.PrivateSourceGenerators.Tests.csproj", "{1976540D-65A6-45D7-95D2-13106DE6D5BB}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Primitives.TestUtilities.Tests", "src\System.Windows.Forms.Primitives\tests\TestUtilities.Tests\System.Windows.Forms.Primitives.TestUtilities.Tests.csproj", "{6EE57002-9965-46E7-A48B-B449969738BB}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "interop", "interop", "{A31B1F6F-4880-45DE-9845-EE3EF67C2FCC}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DesignSurface", "DesignSurface", "{43E46506-7DF8-4E7A-A579-996CA43041EB}"
-	ProjectSection(SolutionItems) = preProject
-		src\System.Windows.Forms\tests\IntegrationTests\DesignSurface\.editorconfig = src\System.Windows.Forms\tests\IntegrationTests\DesignSurface\.editorconfig
-	EndProjectSection
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DemoConsole", "src\System.Windows.Forms\tests\IntegrationTests\DesignSurface\DemoConsole\DemoConsole.csproj", "{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DesignSurfaceExt", "src\System.Windows.Forms\tests\IntegrationTests\DesignSurface\DesignSurfaceExt\DesignSurfaceExt.csproj", "{E96C74BA-9F74-4289-BF72-45CAD472D3D2}"
-EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.VisualBasic.Forms.Tests", "src\Microsoft.VisualBasic.Forms\tests\UnitTests\Microsoft.VisualBasic.Forms.Tests.vbproj", "{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Common.TestUtilities", "src\Common\tests\TestUtilities\System.Windows.Forms.Common.TestUtilities.csproj", "{05FD23CE-60AE-44A8-8DD6-1688F04BE385}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Analyzers", "src\System.Windows.Forms.Analyzers\src\System.Windows.Forms.Analyzers.csproj", "{3596BDE6-B211-4BE7-810D-DC7A4315E296}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Analyzers.Tests", "src\System.Windows.Forms.Analyzers\tests\UnitTests\System.Windows.Forms.Analyzers.Tests.csproj", "{E742382E-5D34-481D-A3FC-7B6B9C5033E2}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Analyzers", "Analyzers", "{E4C6C5F5-46E9-4C63-9628-26752B4D9C11}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Analyzers", "Analyzers", "{D3AD0BF9-F5E2-4913-9AE3-9C4998F95EA1}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Analyzers.CSharp", "src\System.Windows.Forms.Analyzers.CSharp\src\System.Windows.Forms.Analyzers.CSharp.csproj", "{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Analyzers.CSharp.Tests", "src\System.Windows.Forms.Analyzers.CSharp\tests\UnitTests\System.Windows.Forms.Analyzers.CSharp.Tests.csproj", "{714EC82C-D4E0-4E14-9C34-4F270774D384}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NativeHost", "src\System.Windows.Forms\tests\IntegrationTests\NativeHost\NativeHost.vcxproj", "{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}"
-	ProjectSection(ProjectDependencies) = postProject
-		{3129970B-A4EB-46AC-B163-18A5557B11BD} = {3129970B-A4EB-46AC-B163-18A5557B11BD}
-	EndProjectSection
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NativeHost.ManagedControl", "src\System.Windows.Forms\tests\IntegrationTests\NativeHost.ManagedControl\NativeHost.ManagedControl.csproj", "{3129970B-A4EB-46AC-B163-18A5557B11BD}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.UI.IntegrationTests", "src\System.Windows.Forms\tests\IntegrationTests\UIIntegrationTests\System.Windows.Forms.UI.IntegrationTests.csproj", "{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Accessibility_Core_App", "src\System.Windows.Forms\tests\AccessibilityTests\Accessibility_Core_App.csproj", "{317E131C-EA24-47A4-96EE-5A66DED10501}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AxHosts", "src\System.Windows.Forms\tests\AxHosts\AxHosts.csproj", "{93651A99-C9EB-4F83-8A66-DF9D21574550}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "BuildAssist", "BuildAssist", "{B3CE7FA8-21C5-4CE8-970E-8210D1D89251}"
-EndProject
-Project("{13B669BE-BB05-4DDF-9536-439F39A36129}") = "BuildAssist", "src\BuildAssist\BuildAssist.msbuildproj", "{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Drawing.Common", "src\System.Drawing.Common\src\System.Drawing.Common.csproj", "{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Demo", "Demo\Demo.csproj", "{313D5215-7E76-4864-AEBF-0C15819D0B34}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Drawing.Common.Tests", "src\System.Drawing.Common\tests\System.Drawing.Common.Tests.csproj", "{7650F24E-7132-42CF-ADCE-830C8DB26EE5}"
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{D34EBBF2-C22B-4424-A275-0DC4E316AB21}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ScratchProject", "src\System.Windows.Forms\tests\IntegrationTests\ScratchProject\ScratchProject.csproj", "{194D9B0B-421B-4485-B67E-B5A448388D39}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Windows.Forms.Tests", "Tests\System.Windows.Forms.Tests\System.Windows.Forms.Tests.csproj", "{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -174,22 +53,6 @@ Global
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|arm64.Build.0 = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|x64.Build.0 = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Debug|x86.Build.0 = Debug|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|Any CPU.Build.0 = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|arm64.ActiveCfg = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|arm64.Build.0 = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|x64.ActiveCfg = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|x64.Build.0 = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|x86.ActiveCfg = Release|Any CPU
-		{657472B8-FDA3-49DF-B8BE-0246046A4348}.Release|x86.Build.0 = Release|Any CPU
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -206,38 +69,6 @@ Global
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Release|x64.Build.0 = Release|Any CPU
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Release|x86.ActiveCfg = Release|Any CPU
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2}.Release|x86.Build.0 = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|arm64.Build.0 = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|x64.Build.0 = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Debug|x86.Build.0 = Debug|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|Any CPU.Build.0 = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|arm64.ActiveCfg = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|arm64.Build.0 = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|x64.ActiveCfg = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|x64.Build.0 = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|x86.ActiveCfg = Release|Any CPU
-		{AB38E262-F206-4820-8F29-23C5F72A4A16}.Release|x86.Build.0 = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|arm64.Build.0 = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|x64.Build.0 = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Debug|x86.Build.0 = Debug|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|arm64.ActiveCfg = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|arm64.Build.0 = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|x64.ActiveCfg = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|x64.Build.0 = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|x86.ActiveCfg = Release|Any CPU
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E}.Release|x86.Build.0 = Release|Any CPU
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -254,22 +85,6 @@ Global
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Release|x64.Build.0 = Release|Any CPU
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Release|x86.ActiveCfg = Release|Any CPU
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B}.Release|x86.Build.0 = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|arm64.Build.0 = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|x64.Build.0 = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Debug|x86.Build.0 = Debug|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|arm64.ActiveCfg = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|arm64.Build.0 = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|x64.ActiveCfg = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|x64.Build.0 = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|x86.ActiveCfg = Release|Any CPU
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C}.Release|x86.Build.0 = Release|Any CPU
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -286,198 +101,6 @@ Global
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Release|x64.Build.0 = Release|Any CPU
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Release|x86.ActiveCfg = Release|Any CPU
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24}.Release|x86.Build.0 = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|arm64.Build.0 = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|x64.Build.0 = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Debug|x86.Build.0 = Debug|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|arm64.ActiveCfg = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|arm64.Build.0 = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|x64.ActiveCfg = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|x64.Build.0 = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|x86.ActiveCfg = Release|Any CPU
-		{F133342A-3040-4005-A2F0-7685AA7CB82D}.Release|x86.Build.0 = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|arm64.Build.0 = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|x64.Build.0 = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Debug|x86.Build.0 = Debug|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|arm64.ActiveCfg = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|arm64.Build.0 = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|x64.ActiveCfg = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|x64.Build.0 = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|x86.ActiveCfg = Release|Any CPU
-		{36A5139E-3E9C-42BD-95EE-818153A487DB}.Release|x86.Build.0 = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|arm64.Build.0 = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|x64.Build.0 = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Debug|x86.Build.0 = Debug|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|Any CPU.Build.0 = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|arm64.ActiveCfg = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|arm64.Build.0 = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|x64.ActiveCfg = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|x64.Build.0 = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|x86.ActiveCfg = Release|Any CPU
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A}.Release|x86.Build.0 = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|arm64.Build.0 = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|x64.Build.0 = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Debug|x86.Build.0 = Debug|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|arm64.ActiveCfg = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|arm64.Build.0 = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|x64.ActiveCfg = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|x64.Build.0 = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|x86.ActiveCfg = Release|Any CPU
-		{F1B0790A-1A40-4487-A607-36D21D827E44}.Release|x86.Build.0 = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|arm64.Build.0 = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|x64.Build.0 = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Debug|x86.Build.0 = Debug|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|arm64.ActiveCfg = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|arm64.Build.0 = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|x64.ActiveCfg = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|x64.Build.0 = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|x86.ActiveCfg = Release|Any CPU
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E}.Release|x86.Build.0 = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|arm64.Build.0 = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|x64.Build.0 = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Debug|x86.Build.0 = Debug|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|arm64.ActiveCfg = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|arm64.Build.0 = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|x64.ActiveCfg = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|x64.Build.0 = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|x86.ActiveCfg = Release|Any CPU
-		{6103E743-057D-41C6-946C-23A751A08748}.Release|x86.Build.0 = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|arm64.Build.0 = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|x64.Build.0 = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Debug|x86.Build.0 = Debug|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|arm64.ActiveCfg = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|arm64.Build.0 = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|x64.ActiveCfg = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|x64.Build.0 = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|x86.ActiveCfg = Release|Any CPU
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB}.Release|x86.Build.0 = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|arm64.Build.0 = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|x64.Build.0 = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Debug|x86.Build.0 = Debug|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|Any CPU.Build.0 = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|arm64.ActiveCfg = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|arm64.Build.0 = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|x64.ActiveCfg = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|x64.Build.0 = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|x86.ActiveCfg = Release|Any CPU
-		{55E34830-B375-41FF-AFCA-F53B80A4D152}.Release|x86.Build.0 = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|arm64.Build.0 = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|x64.Build.0 = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Debug|x86.Build.0 = Debug|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|arm64.ActiveCfg = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|arm64.Build.0 = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|x64.ActiveCfg = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|x64.Build.0 = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|x86.ActiveCfg = Release|Any CPU
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938}.Release|x86.Build.0 = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|arm64.Build.0 = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|x64.Build.0 = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Debug|x86.Build.0 = Debug|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|arm64.ActiveCfg = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|arm64.Build.0 = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|x64.ActiveCfg = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|x64.Build.0 = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|x86.ActiveCfg = Release|Any CPU
-		{A756D568-AC89-4577-A9B2-E147784AB728}.Release|x86.Build.0 = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|arm64.Build.0 = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|x64.Build.0 = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Debug|x86.Build.0 = Debug|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|Any CPU.Build.0 = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|arm64.ActiveCfg = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|arm64.Build.0 = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|x64.ActiveCfg = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|x64.Build.0 = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|x86.ActiveCfg = Release|Any CPU
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729}.Release|x86.Build.0 = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|arm64.Build.0 = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|x64.Build.0 = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Debug|x86.Build.0 = Debug|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|arm64.ActiveCfg = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|arm64.Build.0 = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|x64.ActiveCfg = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|x64.Build.0 = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|x86.ActiveCfg = Release|Any CPU
-		{EC7608D1-1857-432E-930F-0F89B98979FB}.Release|x86.Build.0 = Release|Any CPU
 		{90B27178-F535-43F7-886E-0AB75203F246}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{90B27178-F535-43F7-886E-0AB75203F246}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{90B27178-F535-43F7-886E-0AB75203F246}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -494,22 +117,6 @@ Global
 		{90B27178-F535-43F7-886E-0AB75203F246}.Release|x64.Build.0 = Release|Any CPU
 		{90B27178-F535-43F7-886E-0AB75203F246}.Release|x86.ActiveCfg = Release|Any CPU
 		{90B27178-F535-43F7-886E-0AB75203F246}.Release|x86.Build.0 = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|arm64.Build.0 = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|x64.Build.0 = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Debug|x86.Build.0 = Debug|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|arm64.ActiveCfg = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|arm64.Build.0 = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|x64.ActiveCfg = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|x64.Build.0 = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|x86.ActiveCfg = Release|Any CPU
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900}.Release|x86.Build.0 = Release|Any CPU
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -526,54 +133,6 @@ Global
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Release|x64.Build.0 = Release|Any CPU
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Release|x86.ActiveCfg = Release|Any CPU
 		{E0681991-228A-420E-85D5-A9E796F0AAE0}.Release|x86.Build.0 = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|arm64.Build.0 = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|x64.Build.0 = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Debug|x86.Build.0 = Debug|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|arm64.ActiveCfg = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|arm64.Build.0 = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|x64.ActiveCfg = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|x64.Build.0 = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|x86.ActiveCfg = Release|Any CPU
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9}.Release|x86.Build.0 = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|arm64.Build.0 = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|x64.Build.0 = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Debug|x86.Build.0 = Debug|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|arm64.ActiveCfg = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|arm64.Build.0 = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|x64.ActiveCfg = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|x64.Build.0 = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|x86.ActiveCfg = Release|Any CPU
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC}.Release|x86.Build.0 = Release|Any CPU
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|Any CPU.Build.0 = Debug|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|arm64.ActiveCfg = Debug|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|arm64.Build.0 = Debug|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|x64.ActiveCfg = Debug|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|x64.Build.0 = Debug|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|x86.ActiveCfg = Debug|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Debug|x86.Build.0 = Debug|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|Any CPU.ActiveCfg = Release|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|Any CPU.Build.0 = Release|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|arm64.ActiveCfg = Release|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|arm64.Build.0 = Release|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|x64.ActiveCfg = Release|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|x64.Build.0 = Release|x64
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|x86.ActiveCfg = Release|x86
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224}.Release|x86.Build.0 = Release|x86
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Debug|arm64.ActiveCfg = Debug|Any CPU
@@ -590,361 +149,51 @@ Global
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Release|x64.Build.0 = Release|Any CPU
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Release|x86.ActiveCfg = Release|Any CPU
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478}.Release|x86.Build.0 = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|arm64.Build.0 = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|x64.Build.0 = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Debug|x86.Build.0 = Debug|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|arm64.ActiveCfg = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|arm64.Build.0 = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|x64.ActiveCfg = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|x64.Build.0 = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|x86.ActiveCfg = Release|Any CPU
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB}.Release|x86.Build.0 = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|arm64.Build.0 = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|x64.Build.0 = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Debug|x86.Build.0 = Debug|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|arm64.ActiveCfg = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|arm64.Build.0 = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|x64.ActiveCfg = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|x64.Build.0 = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|x86.ActiveCfg = Release|Any CPU
-		{6EE57002-9965-46E7-A48B-B449969738BB}.Release|x86.Build.0 = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|arm64.Build.0 = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|x64.Build.0 = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Debug|x86.Build.0 = Debug|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|Any CPU.Build.0 = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|arm64.ActiveCfg = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|arm64.Build.0 = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|x64.ActiveCfg = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|x64.Build.0 = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|x86.ActiveCfg = Release|Any CPU
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4}.Release|x86.Build.0 = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|arm64.Build.0 = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|x64.Build.0 = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Debug|x86.Build.0 = Debug|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|arm64.ActiveCfg = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|arm64.Build.0 = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|x64.ActiveCfg = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|x64.Build.0 = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|x86.ActiveCfg = Release|Any CPU
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2}.Release|x86.Build.0 = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|arm64.Build.0 = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|x64.Build.0 = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Debug|x86.Build.0 = Debug|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|arm64.ActiveCfg = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|arm64.Build.0 = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|x64.ActiveCfg = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|x64.Build.0 = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|x86.ActiveCfg = Release|Any CPU
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D}.Release|x86.Build.0 = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|arm64.Build.0 = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|x64.Build.0 = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Debug|x86.Build.0 = Debug|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|Any CPU.Build.0 = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|arm64.ActiveCfg = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|arm64.Build.0 = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|x64.ActiveCfg = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|x64.Build.0 = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|x86.ActiveCfg = Release|Any CPU
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385}.Release|x86.Build.0 = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|arm64.Build.0 = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|x64.Build.0 = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Debug|x86.Build.0 = Debug|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|arm64.ActiveCfg = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|arm64.Build.0 = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|x64.ActiveCfg = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|x64.Build.0 = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|x86.ActiveCfg = Release|Any CPU
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296}.Release|x86.Build.0 = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|arm64.Build.0 = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|x64.Build.0 = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Debug|x86.Build.0 = Debug|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|arm64.ActiveCfg = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|arm64.Build.0 = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|x64.ActiveCfg = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|x64.Build.0 = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|x86.ActiveCfg = Release|Any CPU
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2}.Release|x86.Build.0 = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|arm64.Build.0 = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|x64.Build.0 = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Debug|x86.Build.0 = Debug|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|arm64.ActiveCfg = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|arm64.Build.0 = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|x64.ActiveCfg = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|x64.Build.0 = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|x86.ActiveCfg = Release|Any CPU
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952}.Release|x86.Build.0 = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|arm64.Build.0 = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|x64.Build.0 = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Debug|x86.Build.0 = Debug|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|Any CPU.Build.0 = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|arm64.ActiveCfg = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|arm64.Build.0 = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|x64.ActiveCfg = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|x64.Build.0 = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|x86.ActiveCfg = Release|Any CPU
-		{714EC82C-D4E0-4E14-9C34-4F270774D384}.Release|x86.Build.0 = Release|Any CPU
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|Any CPU.ActiveCfg = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|Any CPU.Build.0 = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|arm64.ActiveCfg = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|arm64.Build.0 = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|x64.ActiveCfg = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|x64.Build.0 = Debug|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|x86.ActiveCfg = Debug|Win32
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Debug|x86.Build.0 = Debug|Win32
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|Any CPU.ActiveCfg = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|Any CPU.Build.0 = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|arm64.ActiveCfg = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|arm64.Build.0 = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|x64.ActiveCfg = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|x64.Build.0 = Release|x64
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|x86.ActiveCfg = Release|Win32
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815}.Release|x86.Build.0 = Release|Win32
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|Any CPU.ActiveCfg = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|Any CPU.Build.0 = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|arm64.ActiveCfg = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|arm64.Build.0 = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|x64.ActiveCfg = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|x64.Build.0 = Debug|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|x86.ActiveCfg = Debug|x86
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Debug|x86.Build.0 = Debug|x86
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|Any CPU.ActiveCfg = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|Any CPU.Build.0 = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|arm64.ActiveCfg = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|arm64.Build.0 = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|x64.ActiveCfg = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|x64.Build.0 = Release|x64
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|x86.ActiveCfg = Release|x86
-		{3129970B-A4EB-46AC-B163-18A5557B11BD}.Release|x86.Build.0 = Release|x86
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|arm64.Build.0 = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|x64.Build.0 = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Debug|x86.Build.0 = Debug|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|arm64.ActiveCfg = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|arm64.Build.0 = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|x64.ActiveCfg = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|x64.Build.0 = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|x86.ActiveCfg = Release|Any CPU
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6}.Release|x86.Build.0 = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|arm64.Build.0 = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|x64.Build.0 = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Debug|x86.Build.0 = Debug|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|Any CPU.Build.0 = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|arm64.ActiveCfg = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|arm64.Build.0 = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|x64.ActiveCfg = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|x64.Build.0 = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|x86.ActiveCfg = Release|Any CPU
-		{317E131C-EA24-47A4-96EE-5A66DED10501}.Release|x86.Build.0 = Release|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Release|arm64.ActiveCfg = Release|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Release|x64.ActiveCfg = Release|Any CPU
-		{93651A99-C9EB-4F83-8A66-DF9D21574550}.Release|x86.ActiveCfg = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|arm64.Build.0 = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|x64.Build.0 = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Debug|x86.Build.0 = Debug|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|Any CPU.Build.0 = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|arm64.ActiveCfg = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|arm64.Build.0 = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|x64.ActiveCfg = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|x64.Build.0 = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|x86.ActiveCfg = Release|Any CPU
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8}.Release|x86.Build.0 = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|arm64.Build.0 = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|x64.Build.0 = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Debug|x86.Build.0 = Debug|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|arm64.ActiveCfg = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|arm64.Build.0 = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|x64.ActiveCfg = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|x64.Build.0 = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|x86.ActiveCfg = Release|Any CPU
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D}.Release|x86.Build.0 = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|arm64.Build.0 = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|x64.Build.0 = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Debug|x86.Build.0 = Debug|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|arm64.ActiveCfg = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|arm64.Build.0 = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|x64.ActiveCfg = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|x64.Build.0 = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|x86.ActiveCfg = Release|Any CPU
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5}.Release|x86.Build.0 = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|arm64.Build.0 = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|x64.Build.0 = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Debug|x86.Build.0 = Debug|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|Any CPU.Build.0 = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|arm64.ActiveCfg = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|arm64.Build.0 = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|x64.ActiveCfg = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|x64.Build.0 = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|x86.ActiveCfg = Release|Any CPU
-		{194D9B0B-421B-4485-B67E-B5A448388D39}.Release|x86.Build.0 = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|arm64.ActiveCfg = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|arm64.Build.0 = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|x64.Build.0 = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Debug|x86.Build.0 = Debug|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|Any CPU.Build.0 = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|arm64.ActiveCfg = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|arm64.Build.0 = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|x64.ActiveCfg = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|x64.Build.0 = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|x86.ActiveCfg = Release|Any CPU
+		{313D5215-7E76-4864-AEBF-0C15819D0B34}.Release|x86.Build.0 = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|arm64.ActiveCfg = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|arm64.Build.0 = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|x64.Build.0 = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Debug|x86.Build.0 = Debug|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|arm64.ActiveCfg = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|arm64.Build.0 = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|x64.ActiveCfg = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|x64.Build.0 = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|x86.ActiveCfg = Release|Any CPU
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{657472B8-FDA3-49DF-B8BE-0246046A4348} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
 		{0D23A41B-2626-4703-9E4A-87C07F69B0B2} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{AB38E262-F206-4820-8F29-23C5F72A4A16} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
-		{F977CA8C-FBF9-4D82-80BA-FE5B2F33486E} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
 		{61D06BBD-B0CF-4CE1-9139-1CC4B82F0F9B} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{A2B1148A-1747-47BD-8048-416C2C2AF14C} = {434C00C3-E498-4BA7-9764-9F0FC8CFE457}
 		{9BEC2806-D8E0-443B-8B58-9D344E0C2D24} = {434C00C3-E498-4BA7-9764-9F0FC8CFE457}
-		{F133342A-3040-4005-A2F0-7685AA7CB82D} = {989F376E-AE19-43B0-A3E6-96A7E22B4E80}
-		{36A5139E-3E9C-42BD-95EE-818153A487DB} = {989F376E-AE19-43B0-A3E6-96A7E22B4E80}
-		{583F1292-AE8D-4511-B8D8-A81FE4642DDC} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{238195CE-7CCE-4469-ACD8-EA00E88D947A} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{F1B0790A-1A40-4487-A607-36D21D827E44} = {434C00C3-E498-4BA7-9764-9F0FC8CFE457}
-		{351D8601-6E21-45E8-B3B9-847C4540BD4E} = {088DD24C-DF6B-45F3-A8BC-592580A4B2A9}
-		{6103E743-057D-41C6-946C-23A751A08748} = {088DD24C-DF6B-45F3-A8BC-592580A4B2A9}
-		{088DD24C-DF6B-45F3-A8BC-592580A4B2A9} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{48979B4E-EAEC-4B41-BB49-44CA230BECAB} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{462AD69A-9395-4E98-882D-569CDE562559} = {4AA2764C-B013-40B5-9E5B-9459EF976C8B}
-		{D390F7D2-1E11-4DEE-B7F1-4FD0681A81F0} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{55E34830-B375-41FF-AFCA-F53B80A4D152} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{D8598EC8-D64B-4BE7-A4DC-5D5CED6A3938} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
-		{A756D568-AC89-4577-A9B2-E147784AB728} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{1C6F6ADA-97B1-4EB9-934D-0071BB618729} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{EC7608D1-1857-432E-930F-0F89B98979FB} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
 		{90B27178-F535-43F7-886E-0AB75203F246} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{9BFDE7F2-C8F3-40D6-9A16-8DCD1A37E900} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
 		{E0681991-228A-420E-85D5-A9E796F0AAE0} = {434C00C3-E498-4BA7-9764-9F0FC8CFE457}
-		{73B0857A-966B-4E7D-8A83-FECFE0281AB9} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{86418F0B-39DC-4B5A-8145-6D607E6150AC} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{C272DA06-B98D-4BB7-B1C4-ECF58F54B224} = {A31B1F6F-4880-45DE-9845-EE3EF67C2FCC}
 		{3BB220A9-7BC9-4D45-9DC7-B5A1D659B478} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{1976540D-65A6-45D7-95D2-13106DE6D5BB} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
-		{6EE57002-9965-46E7-A48B-B449969738BB} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
-		{A31B1F6F-4880-45DE-9845-EE3EF67C2FCC} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{43E46506-7DF8-4E7A-A579-996CA43041EB} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{93310A19-DDCA-4BCD-AEDE-5C5D788DAFB4} = {43E46506-7DF8-4E7A-A579-996CA43041EB}
-		{E96C74BA-9F74-4289-BF72-45CAD472D3D2} = {43E46506-7DF8-4E7A-A579-996CA43041EB}
-		{FC75CB54-D8D0-4B41-9A4D-9F862F34A02D} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
-		{05FD23CE-60AE-44A8-8DD6-1688F04BE385} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{3596BDE6-B211-4BE7-810D-DC7A4315E296} = {E4C6C5F5-46E9-4C63-9628-26752B4D9C11}
-		{E742382E-5D34-481D-A3FC-7B6B9C5033E2} = {D3AD0BF9-F5E2-4913-9AE3-9C4998F95EA1}
-		{E4C6C5F5-46E9-4C63-9628-26752B4D9C11} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{D3AD0BF9-F5E2-4913-9AE3-9C4998F95EA1} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{5025D7FF-EB6D-4250-B9C5-887ADFBBD952} = {E4C6C5F5-46E9-4C63-9628-26752B4D9C11}
-		{714EC82C-D4E0-4E14-9C34-4F270774D384} = {D3AD0BF9-F5E2-4913-9AE3-9C4998F95EA1}
-		{B68FD1FC-EA37-40F2-BBBD-77577A0A1815} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{3129970B-A4EB-46AC-B163-18A5557B11BD} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{5A6AFB8C-0EFE-4466-BD77-0F4159151AE6} = {680FB14C-7B0C-4D63-9F1A-18ACCDB0F52A}
-		{317E131C-EA24-47A4-96EE-5A66DED10501} = {D390F7D2-1E11-4DEE-B7F1-4FD0681A81F0}
-		{93651A99-C9EB-4F83-8A66-DF9D21574550} = {DF68A171-D27B-4E6A-8A7E-63A651622355}
-		{B3CE7FA8-21C5-4CE8-970E-8210D1D89251} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{20E7C5E8-CD56-4A1C-9CB2-B7169FD7A5B8} = {B3CE7FA8-21C5-4CE8-970E-8210D1D89251}
-		{90CC3A84-1087-48A0-8FDC-3A0F6D4D3B4D} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
-		{7650F24E-7132-42CF-ADCE-830C8DB26EE5} = {583F1292-AE8D-4511-B8D8-A81FE4642DDC}
+		{313D5215-7E76-4864-AEBF-0C15819D0B34} = {77FEDB47-F7F6-490D-AF7C-ABB4A9E0B9D7}
+		{EAF018D1-D51E-4F67-BC7F-6F7F5702C411} = {D34EBBF2-C22B-4424-A275-0DC4E316AB21}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {7B1B0433-F612-4E5A-BE7E-FCF5B9F6E136}
diff --git a/azure-pipelines-PR.yml b/azure-pipelines-PR.yml
new file mode 100644
index 00000000000..1a0d40d5408
--- /dev/null
+++ b/azure-pipelines-PR.yml
@@ -0,0 +1,196 @@
+# Parameters ARE available in template expressions, and parameters can have default values,
+# so they can be used to control yaml flow.
+
+# trigger ci builds for completed checkins into main and any release branches
+trigger:
+  branches:
+    include:
+      - main
+      - release/*
+      - internal/release/*
+      - internal/experimental/*
+  paths:
+    include:
+      - '*'
+    exclude:
+      - .github/*
+      - docs/*
+      - CODE-OF-CONDUCT.md
+      - CONTRIBUTING.md
+      - LICENSE.TXT
+      - PATENTS.TXT
+      - README.md
+      - SECURITY.md
+      - THIRD-PARTY-NOTICES.TXT
+
+# trigger ci builds on pull requests into main and any release branches
+pr:
+  autoCancel: true
+  branches:
+    include:
+      - main
+      - vnext
+      - release/*
+      - internal/release/*
+      - internal/experimental/*
+      - feature/win32
+      - feature/9.0
+  paths:
+    include:
+      - '*'
+    exclude:
+      - .github/*
+      - docs/*
+      - CODE-OF-CONDUCT.md
+      - CONTRIBUTING.md
+      - LICENSE.TXT
+      - PATENTS.TXT
+      - README.md
+      - SECURITY.md
+      - THIRD-PARTY-NOTICES.TXT
+
+variables:
+  - name: TeamName
+    value: DotNetCore
+  # clean the local repo on the build agents
+  - name: Build.Repository.Clean
+    value: true
+  - ${{ if or(startswith(variables['Build.SourceBranch'], 'refs/heads/release/'), startswith(variables['Build.SourceBranch'], 'refs/heads/internal/release/'), eq(variables['Build.Reason'], 'Manual')) }}:
+    - name: PostBuildSign
+      value: false
+  - ${{ else }}:
+    - name: PostBuildSign
+      value: true
+  - name: EnableLoc
+    value: ${{ contains(variables['Build.SourceBranch'], 'main') }}
+  - name: NativeToolsOnMachine
+    value: true
+  - name: isPublic
+    value: ${{ eq(variables['System.TeamProject'], 'public') }}
+  - name: isPR
+    value: ${{ eq(variables['Build.Reason'], 'PullRequest')}}
+
+  # used for post-build phases, internal builds only
+  - ${{ if and(ne(variables['isPublic'], 'true'), ne(variables['isPR'], 'true')) }}:
+    - group: DotNet-Winforms-SDLValidation-Params
+  - ${{ if ne(variables['System.TeamProject'], 'internal') }}:
+    - name: _InternalRuntimeDownloadArgs
+      value: ''
+  - ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+    - group: DotNetBuilds storage account read tokens
+    - group: AzureDevOps-Artifact-Feeds-Pats
+    - name: _InternalRuntimeDownloadArgs
+      value: /p:DotNetRuntimeSourceFeed=https://dotnetbuilds.blob.core.windows.net/internal
+             /p:DotNetRuntimeSourceFeedKey=$(dotnetbuilds-internal-container-read-token-base64)
+
+  # Produce test-signed build for PR and Public builds
+  - ${{ if or(eq(variables['isPublic'], 'true'), eq(variables['isPR'], 'true')) }}:
+    # needed for darc (dependency flow) publishing
+    - name: _PublishArgs
+      value: ''
+    - name: _OfficialBuildIdArgs
+      value: ''
+    # needed for signing
+    - name: _SignType
+      value: test
+    - name: _SignArgs
+      value: ''
+    - name: _Sign
+      value: false
+
+  # Set up non-PR build from internal project
+  - ${{ if and(ne(variables['isPublic'], 'true'), ne(variables['isPR'], 'true')) }}:
+    # needed for darc (dependency flow) publishing
+    - name: _PublishArgs
+      value: >-
+            /p:DotNetPublishUsingPipelines=true
+    - name: _OfficialBuildIdArgs
+      value: /p:OfficialBuildId=$(BUILD.BUILDNUMBER)
+    # needed for signing
+    - name: _SignType
+      value: real
+    - name: _SignArgs
+      value: /p:DotNetSignType=$(_SignType) /p:TeamName=$(_TeamName) /p:Sign=$(_Sign)
+    - name: _Sign
+      value: true
+
+
+stages:
+
+- stage: Build
+  jobs:
+
+  # Windows x64
+  - template: /eng/pipelines/build-PR.yml
+    parameters:
+      name: Windows_x64
+      targetArchitecture: x64
+      skipTests: $(SkipTests)
+
+  # Windows x86
+  - template: /eng/pipelines/build-PR.yml
+    parameters:
+      name: Windows_x86
+      targetArchitecture: x86
+      skipTests: $(SkipTests)
+
+  # Windows arm64
+  - template: /eng/pipelines/build-PR.yml
+    parameters:
+      name: Windows_arm64
+      targetArchitecture: arm64
+      skipTests: $(SkipTests)
+
+
+- ${{ if and(eq(variables['EnableLoc'], 'true'), ne(variables['isPublic'], 'true'), ne(variables['isPR'], 'true')) }}:
+  - stage: OneLocBuild
+    displayName: Publish localizable content to OneLocBuild
+    jobs:
+    - template: /eng/common/templates/job/onelocbuild.yml
+      parameters:
+        MirrorRepo: winforms
+        UseCheckedInLocProjectJson: true
+        LclSource: lclFilesfromPackage
+        LclPackageId: 'LCL-JUNO-PROD-WINFORMS'
+
+
+- ${{ if and(ne(variables['isPublic'], 'true'), ne(variables['isPR'], 'true')) }}:
+  - stage: PublishAssetRegistry
+    displayName: Publish to Build Asset Registry
+    dependsOn: Build
+    variables:
+    - template: /eng/common/templates/variables/pool-providers.yml
+    jobs:
+    # Publish to Build Asset Registry in order to generate the ReleaseConfigs artifact.
+    - template: /eng/common/templates/job/publish-build-assets.yml
+      parameters:
+        publishUsingPipelines: true
+        pool:
+          name: $(DncEngInternalBuildPool)
+          demands: ImageOverride -equals windows.vs2022preview.amd64
+
+
+# Copied from the arcade repo and modified for winforms
+- ${{ if and(ne(variables['isPublic'], 'true'), ne(variables['isPR'], 'true')) }}:
+  - template: /eng/common/templates/post-build/post-build.yml
+    parameters:
+      validateDependsOn: PublishAssetRegistry
+      publishingInfraVersion: 3
+      enableSymbolValidation: false
+      enableSigningValidation: false
+      enableNugetValidation: false
+      enableSourceLinkValidation: false
+      # these param values come from the DotNet-Winforms-SDLValidation-Params azdo variable group
+      SDLValidationParameters:
+        enable: false
+        params: ' -SourceToolsList $(_TsaSourceToolsList)
+        -TsaInstanceURL $(_TsaInstanceURL)
+        -TsaProjectName $(_TsaProjectName)
+        -TsaNotificationEmail $(_TsaNotificationEmail)
+        -TsaCodebaseAdmin $(_TsaCodebaseAdmin)
+        -TsaBugAreaPath $(_TsaBugAreaPath)
+        -TsaIterationPath $(_TsaIterationPath)
+        -TsaRepositoryName $(_TsaRepositoryName)
+        -TsaCodebaseName $(_TsaCodebaseName)
+        -TsaOnboard $(_TsaOnboard)
+        -TsaPublish $(_TsaPublish)'
diff --git a/docs/accessibility/accessible-role-controltype.md b/docs/accessibility/accessible-role-controltype.md
deleted file mode 100644
index a1e26b8fb2a..00000000000
--- a/docs/accessibility/accessible-role-controltype.md
+++ /dev/null
@@ -1,227 +0,0 @@
-# Consistency of AccessibleRole and "ControlType" for accessible objects
-
-This document describes a behavior and relations of `AccessibleRole` property of 
-[controls](https://docs.microsoft.com/dotnet/api/system.windows.forms.control.accessiblerole) and 
-[ToolStrip items](https://docs.microsoft.com/dotnet/api/system.windows.forms.toolstripitem.accessiblerole) 
- and `"ControlType"` accessibility property.
-
-* [Overview](#Overview)
-* [AccessibleRole-"ControlType" mapping](#AccessibleRole-"ControlType"-mapping)
-* [Default "ControlType" values](#Default-"ControlType"-values)
-* [Exceptional cases and additional info](#Exceptional-cases-and-additional-info)
-    
-
-# Overview
-
-All accessible objects have `"ControlType"` (a part of modern [UIA](https://docs.microsoft.com/dotnet/framework/ui-automation/ui-automation-overview)) and "[LegacyIAccessible](https://docs.microsoft.com/windows/win32/winauto/uiauto-implementinglegacyiaccessible)`.Role"` 
-(further `"Role"` - a part of outdated [MSAA](https://docs.microsoft.com/windows/win32/winauto/microsoft-active-accessibility)) accessibility properties. 
-
-![inspect-accessibility-properties][inspect-accessibility-properties]
-
-Accessibility tools ([Inspect](https://docs.microsoft.com/windows/win32/winauto/inspect-objects), 
-[Narrator](https://support.microsoft.com/windows/complete-guide-to-narrator-e4397a0d-ef4f-b386-d8ae-c172f109bdb1),
- etc.) request [Role](https://docs.microsoft.com/dotnet/api/system.windows.forms.accessibleobject.role) property of accessible objects to 
-get `"Role"` accessibility property value. `Role` property value of 
-[ControlAccessibleObject](https://docs.microsoft.com/dotnet/api/system.windows.forms.control.controlaccessibleobject), 
-[ToolStripItemAccessibleObject](https://docs.microsoft.com/dotnet/api/system.windows.forms.toolstripitem.toolstripitemaccessibleobject), 
-and their descendants can be set by the developer using public `AccessibleRole` property.
-
-![accessibleobject-role-implementation][accessibleobject-role-implementation]
-
-
-Accessibility tools call internal `GetPropertyValue` method with `ControlTypePropertyId` 
-argument to get `"ControlType"` value.
-
-![accessibleobject-getpropertyvalue-implementation][accessibleobject-getpropertyvalue-implementation]
-
-
-**.NET Framework 4.7.2** implements the following `AccessibleRole` property and 
-`"ControlType"` accessibility property relations:
-when `Control`'s or `ToolStripItem`'s `AccessibleRole` property is set to a non-default 
-value by the developer, the native accessibility proxy implementation would 
-set `"ControlType"` property to a matching value.</br>
-**.NET Framework 4.8**, **.NET Core 3.0** and **3.1**, **.NET 5.0** lost 
-this behavior for all controls that implement **UIA providers** because 
-they provide custom implementation of UIA properties and no longer rely 
-on UIA proxy to match roles to control types. **.NET 6.0** restores the **.NET Framework 4.7.2** behavior.
-
-
-# AccessibleRole-"ControlType" mapping
-
-When a developer changes `AccessibleRole` property value of a control 
-or a `ToolStrip` item (for example: `control.AccessibleRole = AccessibleRole.List;`), `"ControlType"` accessibility 
-property value of the corresponding accessible object will 
-be changed according to the following list (except some cases described below):
-
-| AccessibleRole | ControlType |
-| ------------- | ------------- |
-|Alert|Pane|
-|Animation|Pane|
-|Application|Window|
-|Border|Pane|
-|ButtonDropDown|SplitButton|
-|ButtonDropDownGrid|Button|
-|ButtonMenu|MenuItem|
-|Caret|Pane|
-|Cell|DataItem|
-|Character|Pane|
-|Chart|Pane|
-|CheckButton|CheckBox|
-|Client|Pane|
-|Clock|Button|
-|Column|Pane|
-|ColumnHeader|Header|
-|ComboBox|ComboBox|
-|Cursor|Pane|
-|Default|Pane|
-|Diagram|Pane|
-|Dial|Pane|
-|Dialog|Pane|
-|Document|Document|
-|DropList|Pane|
-|Equation|Pane|
-|Graphic|Image|
-|Grip|Thumb|
-|Grouping|Group|
-|HelpBalloon|Pane|
-|HotkeyField|Pane|
-|Indicator|Thumb|
-|IpAddress|Pane|
-|Link|Hyperlink|
-|List|List|
-|ListItem|ListItem|
-|MenuBar|MenuBar|
-|MenuItem|MenuItem|
-|MenuPopup|Menu|
-|None|Pane|
-|Outline|Tree|
-|OutlineButton|Pane|
-|OutlineItem|TreeItem|
-|PageTab|TabItem|
-|PageTabList|Tab|
-|Pane|Pane|
-|ProgressBar|ProgressBar|
-|PropertyPage|Pane|
-|PushButton|Button|
-|RadioButton|RadioButton|
-|Row|Pane|
-|RowHeader|Header|
-|ScrollBar|ScrollBar|
-|Separator|Separator|
-|Slider|Slider|
-|Sound|Pane|
-|SpinButton|Spinner|
-|SplitButton|SplitButton|
-|StaticText|Text|
-|StatusBar|StatusBar|
-|Table|Table|
-|Text|Edit|
-|TitleBar|TitleBar|
-|ToolBar|ToolBar|
-|ToolTip|ToolTip|
-|WhiteSpace|Pane|
-|Window|Window|
-
-
-# Default "ControlType" values
-
-Here is the list of common controls and `ToolStrip` items with 
-their accessible objects `"ControlType"` accessibility property values 
-by default - when `AccessibleRole` property value of these controls 
-and `ToolStrip` items is not set:
-```cs
-Control control = new Control();
-// control.AccessibleRole = AccessibleRole.List; - Role is not set
-```
-or equals [AccessibleRole](https://docs.microsoft.com/dotnet/api/system.windows.forms.accessiblerole)`.Default`:
-```cs
-Control control = new Control();
-control.AccessibleRole = AccessibleRole.Default; // Role is set to the default value
-```
-
-| Control or item | Default ControlType |
-| ------------- | ------------- |
-|Button|Button |
-|CheckBox |CheckBox |
-|CheckedListBox |List |
-|ComboBox |ComboBox |
-|ContextMenuStrip<br/>└ ToolStripMenuItem<br/>└┴ ToolStripMenuItem<br/>└┴ ToolStripComboBox<br/>└┴ ToolStripTextBox<br/>└┴ ToolStripSeparator<br/>└ ToolStripComboBox<br/>└ ToolStripTextBox<br/>└ ToolStripSeparator|Menu<br/>MenuItem<br/>Pane<br/>ComboBox<br/>Edit<br/>Separator<br/>ComboBox<br/>Edit<br/>Separator|
-|DataGridView <br/>└ DataGridViewEditingPanel |Table <br/>Pane|
-|DateTimePicker |ComboBox|
-|DomainUpDown<br/>└ UpDownButtons<br/>└ UpDownEdit|Spinner<br/>Spinner<br/>Edit|
-|FlowLayoutPanel|Pane|
-|Form|Window|
-|GroupBox|Group|
-|HScrollBar|ScrollBar|
-|Label|Text|
-|LinkLabel|Text|
-|ListBox|List|
-|ListView|List|
-|MenuStrip<br/>└ ToolStripMenuItem<br/>└┴ ToolStripMenuItem<br/>└┴ ToolStripComboBox<br/>└┴ ToolStripTextBox<br/>└┴ ToolStripSeparator<br/>└ ToolStripComboBox<br/>└ ToolStripTextBox|MenuBar<br/>MenuItem<br/>MenuItem<br/>ComboBox<br/>Edit<br/>Separator<br/>ComboBox<br/>Edit|
-|MaskedTextBox|Edit|
-|MonthCalendar|Calendar/Table|
-|NumericUpDown<br/>└ UpDownButtons<br/>└ UpDownEdit|Spinner<br/>Spinner<br/>Edit|
-|PictureBox|Pane|
-|ProgressBar|ProgressBar|
-|PropertyGrid|Pane|
-|RadioButton|RadioButton|
-|RichTextBox|Document|
-|ScrollBar|ScrollBar|
-|SplitContainer|Pane|
-|Splitter|Pane|
-|StatusStrip<br/>└ ToolStripStatusLabel<br/>└ ToolStripProgressBar<br/>└ ToolStripSplitButton<br/>└ ToolStripDropDownButton<br/>└┴ ToolStripMenuItem<br/>└┴ ToolStripComboBox<br/>└┴ ToolStripTextBox<br/>└┴ ToolStripSeparator|StatusBar<br/>Text/Link<br/>ProgressBar<br/>Button<br/>Button<br/>MenuItem<br/>ComboBox<br/>Edit<br/>Separator|
-|TabControl|Tab|
-|TableLayoutPanel|Pane|
-|TabPage|Pane|
-|TextBox|Edit|
-|TextBoxBase|Edit|
-|ToolStrip<br/>└ ToolStripItem<br/>└ ToolStripComboBox<br/>└ ToolStripDropDown<br/>└ ToolStripNumericUpDown<br/>└ ToolStripOverflow<br/>└ ToolStripProgressBar<br/>└ ToolStripTextBox<br/>└ ToolStripButton<br/>└ ToolStripLabel<br/>└ ToolStripSplitButton<br/>└ ToolStripDropDownButton<br/>└ ToolStripSeparator<br/>└ ToolStripOverflowButton<br/>|ToolBar<br/>Button<br/>ComboBox<br/>Menu<br/>Spinner<br/>Menu<br/>ProgressBar<br/>Edit<br/>Button<br/>Text/Link<br/>Button<br/>Button<br/>Separator<br/>MenuItem|
-|TrackBar|Slider|
-|TreeView|Tree|
-|VScrollBar|ScrollBar|
-|TrackBar|Slider|
-|TreeView|Tree|
-|VScrollBar|ScrollBar|
-
-# Exceptional cases and additional info
-- Here is the list of controls and `ToolStrip` items that didn't change 
-their accessible objects `"ControlType"` values depending on `Role` in **.NET Framework 4.7.2** 
-but in **in .NET 6.0** they can do it correctly:
-  1. **`ListView`** - `"ControlType"` was always `List`
-  2. **`ToolStripMenuItem`** - `"ControlType"` was always `Menu item`
-  3. **`ToolStripSplitButton`** - `"ControlType"` was always `Button`
-  4. **`ToolStripDropDownButton`** - `"ControlType"` was always `Button`
-
-- **`RichTextBox`**: at this moment, we don't provide a managed accessible object for it. 
-It doesn't support setting a custom `AccessibleRole` and 
-changing `"ControlType"` respectively (in **.NET Framework 4.7.2** too). 
-It always has `"Role"` as `Document` and `"ControlType"` as `Document`.
-- **`TreeView`**: at this moment, we don't provide a managed accessible object for it. 
-It doesn't support setting a custom `AccessibleRole` and 
-changing `"ControlType"` respectively (in **.NET Framework 4.7.2** too). 
-It always has `"Role"` value as `Outline` and `"ControlType"` value as `Tree`.
-- **`DateTimePicker`**: its accessible object has non-standard 
-`"LocalizedControlType"` accessibility property value by default. 
-But it changes if to change `AccessibleRole` property value of the control.
-- **`Form`**: default `"Role"` value is `Client` but default `"ControlType"` value
-is `Window`. This is an exception and does not correspond to the list above.
-In the rest, `Form` with a custom `AccessibleRole` value works as expected.
-- **`MonthCalendar`**: if `AccessibleName` property value is null or empty 
-default `"ControlType"` of its accessible object is `Calendar`, 
-if `AccessibleName` is a some text - default `"ControlType"` is `Table`.
-- **`ToolStripLabel`**: if `IsLink` property value equals `false` 
-its accessible object default `"ControlType"` value is `Text`, 
-and `"ControlType"` is `Hyperlink` if `IsLink` is `true`.
-- **`ToolStripStatusLabel`**: if `IsLink` property value equals `false` 
-its accessible object default `"ControlType"` value is `Text`, 
-and `"ControlType"` is `Hyperlink` if `IsLink` is `true`.
-- **`ToolStripNumericUpDown`**: this item is used in [PrintPreviewDialog](https://docs.microsoft.com/dotnet/api/system.windows.forms.printpreviewdialog) control.
-- **`ToolStripOverflowButton`**:  needs to use [ToolStrip.OverflowButton](https://docs.microsoft.com/dotnet/api/system.windows.forms.toolstrip.overflowbutton) 
-property to get this item and set a custom `AccessibleRole` value.
-- **`DataGridViewEditingPanel`**: default `"Role"` is `Client`. 
-Needs to use [DataGridView.EditingPanel](https://docs.microsoft.com/dotnet/api/system.windows.forms.datagridview.editingpanel) to get the control and set 
-a custom value for its `AccessibleRole`.
-
-[inspect-accessibility-properties]: ../images/inspect-accessibility-properties.png
-[accessibleobject-role-implementation]: ../images/accessibleobject-role-implementation.png
-[accessibleobject-getpropertyvalue-implementation]: ../images/accessibleobject-getpropertyvalue-implementation.png
\ No newline at end of file
diff --git a/docs/accessibility/listview-expected-behavior.md b/docs/accessibility/listview-expected-behavior.md
deleted file mode 100644
index c7cf81c52bb..00000000000
--- a/docs/accessibility/listview-expected-behavior.md
+++ /dev/null
@@ -1,655 +0,0 @@
-# ListView accessibility objects expected behavior
-
-This document describes the expected behavior of [ListView](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview) , [ListView](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewgroup), [ListViewSubItem](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.listviewsubitem) accessibility objects when using Inspect.
-
-
-- [Overview](#Overview)
-- [ListView](#ListView)
-    - [Accessibility tree for ListView](##Accessibility-tree-for-ListView)
-- [ListViewGroup](#ListViewGroup)
-    - [Accessibility tree for a ListView with displayed ListViewGroups](##Accessibility-tree-for-a-ListView-with-displayed-ListViewGroups)
-	- [Accessibility tree for a ListView with disabled visual styles](##Accessibility-tree-for-a-ListView-with-disabled-visual-styles)	
-	- [Accessibility tree for a ListView with disabled ListViewGroups](##Accessibility-tree-for-a-ListView-with-disabled-ListViewGroups)
-	- [Accessibility tree for a ListView in virtual mode](##Accessibility-tree-for-a-ListView-in-virtual-mode)
-	- [Accessibility tree for a ListView without ListViewGroups](##Accessibility-tree-for-a-ListView-without-ListViewGroups)
-- [ListViewSubItem](#ListViewSubItem)
-    - [Accessibility tree for a ListViewItem](##Accessibility-tree-for-a-ListViewItem)
-	- [Accessibility tree for a ListViewItem (Details view)](##Accessibility-tree-for-a-ListViewItem-(Details-view))
-	- [Accessibility tree for a ListViewItem (Tile view)](##Accessibility-tree-for-a-ListViewItem-(Tile-view))
-
-# Overview
-
-[ListView](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview) is a Win32 native control provided by Windows.
-Windows Forms runtime provides a support for [UI Automation](https://docs.microsoft.com/dotnet/framework/ui-automation/ui-automation-overview) and, thus, responsible for providing required accessible objects with correct properties and actions to make all aspects of the `ListView` control accessible for customers.
-
-# ListView
-
-## Accessibility tree for ListView
-
-`ListView` accessibility tree must contain all visible items based on the selected `View` [view](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.view).
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-inspect-details-view-tree][listview-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-inspect-largeicon-view-tree][listview-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-inspect-list-view-tree][listview-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-inspect-smallicon-view-tree][listview-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listview-inspect-tile-view-tree][listview-inspect-tile-view-tree]
-
-</details>
-</br>
-
-# ListViewGroup
-
-The `ListView` always contains one or more [ListViewGroup](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewgroup), but depending on a configuration of the operating system, application and/or the `ListView` itself, these [groups](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.groups) can be visible or not.
-
-## Accessibility tree for a ListView with displayed ListViewGroups
-
-A `ListViewGroup` is display if the following conditions are met:
-1. An application has [visual styles](https://docs.microsoft.com/dotnet/api/system.windows.forms.application.enablevisualstyles) are enabled.
-2. A `ListView` is not in a [virtual mode](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.virtualmode).
-3. The [ShowGroups](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.showgroups) property has `true` value
-4. A `ListView` has one or more [groups](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.groups)
-5. A `ListView` is not in a `List` view
-
-```cs
-ListViewGroup listViewGroup = new ListViewGroup("Test group");
-listView.Groups.Add(listViewGroup);
-
-listView.ShowGroups = true;
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 3", "SubItem 31" }, imageIndex: 0));
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-withgroup-inspect-details-view-tree][listview-withgroup-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-withgroup-inspect-largeicon-view-tree][listview-withgroup-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-withgroup-inspect-list-view-tree][listview-withgroup-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-withgroup-inspect-smallicon-view-tree][listview-withgroup-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listview-withgroup-inspect-tile-view-tree][listview-withgroup-inspect-tile-view-tree]
-
-</details>
-</br>
-
-## Accessibility tree for a ListView with disabled visual styles
-`ListViewGroups` are not visible when [visual styles](https://docs.microsoft.com/dotnet/api/system.windows.forms.application.enablevisualstyles) are disabled.
-
-```cs
-ListViewGroup listViewGroup = new ListViewGroup("Test group");
-listView.Groups.Add(listViewGroup);
-
-listView.ShowGroups = true;
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 3", "SubItem 31" }, imageIndex: 0));
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-disabledstyles-inspect-details-view-tree][listview-disabledstyles-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-disabledstyles-inspect-largeicon-view-tree][listview-disabledstyles-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-disabledstyles-inspect-list-view-tree][listview-disabledstyles-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-disabledstyles-inspect-smallicon-view-tree][listview-disabledstyles-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listview-disabledstyles-inspect-tile-view-tree][listview-disabledstyles-inspect-tile-view-tree]
-
-</details>
-</br>
-
-## Accessibility tree for a ListView with disabled ListViewGroups
-`ListViewGroups` are not visible when [ShowGroups](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.showgroups) property is set to `false`.
-
-```cs
-ListViewGroup listViewGroup = new ListViewGroup("Test group");
-listView.Groups.Add(listViewGroup);
-
-listView.ShowGroups = false;
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0, group: listViewGroup));
-listView.Items.Add(new ListViewItem(new string[] { "Item 3", "SubItem 31" }, imageIndex: 0));
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-showgroupdisabled-inspect-details-view-tree][listview-showgroupdisabled-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-showgroupdisabled-inspect-largeicon-view-tree][listview-showgroupdisabled-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-showgroupdisabled-inspect-list-view-tree][listview-showgroupdisabled-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-showgroupdisabled-inspect-smallicon-view-tree][listview-showgroupdisabled-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listview-showgroupdisabled-inspect-tile-view-tree][listview-showgroupdisabled-inspect-tile-view-tree]
-
-</details>
-</br>
-
-## Accessibility tree for a ListView in virtual mode
-`ListViewGroups` are not visible when `ListView` is in [virtual mode](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.virtualmode).
-
-```cs
-ListViewGroup listViewGroup = new ListViewGroup("Test group");
-listView.Groups.Add(listViewGroup);
-
-listView.VirtualMode = virtualMode;
-listView.VirtualListSize = 3;
-
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-ListViewItem listItem1 = new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0, group: listViewGroup));
-ListViewItem listItem2 = new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0, group: listViewGroup));
-ListViewItem listItem3 = new ListViewItem(new string[] { "Item 3", "SubItem 31", "SubItem 32", "SubItem 33" }, imageIndex: 0));
-
-listView.RetrieveVirtualItem += (s, e) =>
-    {
-        e.Item = e.ItemIndex switch
-        {
-            0 => listItem1,
-            1 => listItem2,
-            2 => listItem3,
-            _ => throw new NotImplementedException()
-        };
-    };
-
-listItem1.SetItemIndex(listView, 0);
-listItem2.SetItemIndex(listView, 1);
-listItem3.SetItemIndex(listView, 2);
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-virtualmode-inspect-details-view-tree][listview-virtualmode-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-virtualmode-inspect-largeicon-view-tree][listview-virtualmode-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-virtualmode-inspect-list-view-tree][listview-virtualmode-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-virtualmode-inspect-smallicon-view-tree][listview-virtualmode-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-The ListView in virtual mode does not support "Tile" view
-
-</details>
-</br>
-
-## Accessibility tree for a ListView without ListViewGroups
-`ListViewGroups` are not visible when `ListView` has no [groups](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.groups).
-
-```cs
-listView.ShowGroups = true;
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 3", "SubItem 31" }, imageIndex: 0));
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listview-withoutgroup-inspect-details-view-tree][listview-withoutgroup-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listview-withoutgroup-inspect-largeicon-view-tree][listview-withoutgroup-inspect-largeicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listview-withoutgroup-inspect-list-view-tree][listview-withoutgroup-inspect-list-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listview-withoutgroup-inspect-smallicon-view-tree][listview-withoutgroup-inspect-smallicon-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listview-withoutgroup-inspect-tile-view-tree][listview-withoutgroup-inspect-tile-view-tree]
-
-</details>
-</br>
-
-# ListViewSubItem
-
-## Accessibility tree for a ListViewItem
-A [ListViewSubItem](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem) is display if the following conditions are met:
-1. A `ListView` is in a `List` or `Details` [views](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.view).
-2. A `ListView` has one or more [ListViewSubItems](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.subitems)
-3. A `ListView` has one or more [Columns](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.subitems)
-4. The `ListViewItem` has a [TileSize](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.tilesize) enough to display `ListViewSubItems` (only for `Tile` view)
-
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 100);  
-```
-
-<details>
-<summary>1. Details view</summary>
-</br>
-
-![listviewsubitem-inspect-details-view-tree][listviewsubitem-inspect-details-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. LargeIcon view</summary>
-</br>
-
-![listviewsubitem-inspect-largeicon-view-tree][listviewsubitem-inspect-largeicon-view-tree]
-This view does not support ListViewSubItems
-
-</details>
-</br>
-
-<details>
-<summary>3. List view</summary>
-</br>
-
-![listviewsubitem-inspect-list-view-tree][listviewsubitem-inspect-list-view-tree]
-This view does not support ListViewSubItems
-
-</details>
-</br>
-
-<details>
-<summary>4. SmallIcon view</summary>
-</br>
-
-![listviewsubitem-inspect-smallicon-view-tree][listviewsubitem-inspect-smallicon-view-tree]
-This view does not support ListViewSubItems
-
-</details>
-</br>
-
-<details>
-<summary>5. Tile view</summary>
-</br>
-
-![listviewsubitem-inspect-tile-view-tree][listviewsubitem-inspect-tile-view-tree]
-
-</details>
-</br>
-
-## Accessibility tree for a ListViewItem (Details view)
-
-It is typical for this mode that when displaying accessibility objects for `ListViewSubItems` in the Inspect tree, the main parameter is not the number of [ListViewSubItems](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.subitems), but the number of [Columns](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.columns) that the user can see. 
-
-In the case when the number of `Columns` and `ListViewSubItems` is the same, the user sees that all `Columns` contain data and all `ListViewSubItems` are displayed in the Accessibility tree.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-```
-
-![listviewsubitem-inspect-details-view-tree][listviewsubitem-inspect-details-view-tree]
-
-If the number of `Columns` is less than the number of `ListViewSubItems`, then the user sees only those `ListViewSubItems` for which there are `Columns`. As a result, only `ListViewSubItems` with matching `Columns` are displayed in the Inspector tree. `ListViewSubItems` without corresponding `Columns` on the screen and in the Accessibility tree are not displayed.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-```
-
-![listviewsubitem-twocolumns-inspect-details-view-tree][listviewsubitem-twocolumns-inspect-details-view-tree]
-
-If the number of `Columns` is greater than the number of `ListViewSubItems`, then a fake accessibility object is displayed for non-existent `ListViewSubItems`. This is because whether they exist or not, the user sees the cell for the `ListViewSubItem`, so it should have an accessibility object to interact with the Accessibility tree.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21" }, imageIndex: 0));
-```
-
-![listviewsubitem-twosubitems-inspect-details-view-tree][listviewsubitem-twosubitems-inspect-details-view-tree]
-
-## Accessibility tree for a ListViewItem (Tile view)
-This view takes many factors into account when displaying `ListViewSubItems`.
-
-The first `ListViewSubItem` (with 0 index) is never shown in the Accessibility tree, as its data is displayed within the `ListViewItem`. `ListViewItem.FragmentNavigate(NavigateDirection.FirstChild)`, `ListViewItem.FragmentNavigate(NavigateDirection.LastChild)` and
-`ListViewSubItem.FragmentNavigate(NavigateDirection.PreviousSibling)` methods, also never return a 0-indexed `ListViewSubItem`
-
-All [ListViewSubItem](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem) is display if the following conditions are met:
-1. A `ListView` has one or more [ListViewSubItems](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.subitems)
-2. A `ListView` has one or more [Columns](https://docs.microsoft.com/dotnet/api/system.windows.forms.listviewitem.subitems)
-3. The `ListViewItem` has a [TileSize](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.tilesize) enough to display `ListViewSubItems`
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 100);  
-```
-
-![listviewsubitem-inspect-tile-view-tree][listviewsubitem-inspect-tile-view-tree]
-
-If the number of `Columns` is less than the number of `ListViewSubItems`, then only `ListViewSubItems` with corresponding `Columns` are displayed. The rest of the `ListViewSubItems` are hidden both on the screen and in the Accessibility tree.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 100);  
-```
-
-![listviewsubitem-twocolumns-inspect-tile-view-tree][listviewsubitem-twocolumns-inspect-tile-view-tree]
-
-If the number of `ListViewSubItems` is less than the number of `Columns`, then only existing `ListViewSubItems` are displayed in the Accessibility tree (as opposed to the `Details` view), since nonexistent `ListViewSubItems` are not displayed on the screen and the user cannot interact with them.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 100);  
-```
-
-![listviewsubitem-threeitems-inspect-tile-view-tree][listviewsubitem-threeitems-inspect-tile-view-tree]
-
-If the [TileSize](https://docs.microsoft.com/dotnet/api/system.windows.forms.listview.tilesize) of the `ListViewItem` is too small, then only those `ListViewSubItems` that are included in the visible area of ​​the `ListViewItem` are displayed. The rest of the `ListViewSubItems` are hidden both on the screen and in the Accessibility tree.
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 40);  
-```
-
-![listviewsubitem-smallsize-inspect-tile-view-tree][listviewsubitem-smallsize-inspect-tile-view-tree]
-
-`ListViewSubItems` are not displayed when [visual styles](https://docs.microsoft.com/dotnet/api/system.windows.forms.application.enablevisualstyles) are disabled for an application. As a result, `ListViewSubItems` are also hidden in the Accessibility tree
-
-```cs
-listView.Columns.Add(new ColumnHeader { Text = "Column 1" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 2" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 3" });
-listView.Columns.Add(new ColumnHeader { Text = "Column 4" });
-
-listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12", "SubItem 13" }, imageIndex: 0));
-listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22", "SubItem 23" }, imageIndex: 0));
-
-listView.TileSize = new Size(100, 100);  
-```
-
-![listviewsubitem-disabledvisualstyles-inspect-tile-view-tree][listviewsubitem-disabledvisualstyles-inspect-tile-view-tree]
-
-[listview-inspect-details-view-tree]: ../images/listview-inspect-details-view-tree.png
-[listview-inspect-largeicon-view-tree]: ../images/listview-inspect-largeicon-view-tree.png
-[listview-inspect-list-view-tree]: ../images/listview-inspect-list-view-tree.png
-[listview-inspect-smallicon-view-tree]: ../images/listview-inspect-smallicon-view-tree.png
-[listview-inspect-tile-view-tree]: ../images/listview-inspect-tile-view-tree.png
-[listview-withgroup-inspect-details-view-tree]: ../images/listview-withgroup-inspect-details-view-tree.png
-[listview-withgroup-inspect-largeicon-view-tree]: ../images/listview-withgroup-inspect-largeicon-view-tree.png
-[listview-withgroup-inspect-list-view-tree]: ../images/listview-withgroup-inspect-list-view-tree.png
-[listview-withgroup-inspect-smallicon-view-tree]: ../images/listview-withgroup-inspect-smallicon-view-tree.png
-[listview-withgroup-inspect-tile-view-tree]: ../images/listview-withgroup-inspect-tile-view-tree.png
-[listview-disabledstyles-inspect-details-view-tree]: ../images/listview-disabledstyles-inspect-details-view-tree.png
-[listview-disabledstyles-inspect-largeicon-view-tree]: ../images/listview-disabledstyles-inspect-largeicon-view-tree.png
-[listview-disabledstyles-inspect-list-view-tree]: ../images/listview-disabledstyles-inspect-list-view-tree.png
-[listview-disabledstyles-inspect-smallicon-view-tree]: ../images/listview-disabledstyles-inspect-smallicon-view-tree.png
-[listview-disabledstyles-inspect-tile-view-tree]: ../images/listview-disabledstyles-inspect-tile-view-tree.png
-[listview-showgroupdisabled-inspect-details-view-tree]: ../images/listview-showgroupdisabled-inspect-details-view-tree.png
-[listview-showgroupdisabled-inspect-largeicon-view-tree]: ../images/listview-showgroupdisabled-inspect-largeicon-view-tree.png
-[listview-showgroupdisabled-inspect-list-view-tree]: ../images/listview-showgroupdisabled-inspect-list-view-tree.png
-[listview-showgroupdisabled-inspect-smallicon-view-tree]: ../images/listview-showgroupdisabled-inspect-smallicon-view-tree.png
-[listview-showgroupdisabled-inspect-tile-view-tree]: ../images/listview-showgroupdisabled-inspect-tile-view-tree.png
-[listview-withoutgroup-inspect-details-view-tree]: ../images/listview-withoutgroup-inspect-details-view-tree.png
-[listview-withoutgroup-inspect-largeicon-view-tree]: ../images/listview-withoutgroup-inspect-largeicon-view-tree.png
-[listview-withoutgroup-inspect-list-view-tree]: ../images/listview-withoutgroup-inspect-list-view-tree.png
-[listview-withoutgroup-inspect-smallicon-view-tree]: ../images/listview-withoutgroup-inspect-smallicon-view-tree.png
-[listview-withoutgroup-inspect-tile-view-tree]: ../images/listview-withoutgroup-inspect-tile-view-tree.png
-[listview-virtualmode-inspect-details-view-tree]: ../images/listview-virtualmode-inspect-details-view-tree.png
-[listview-virtualmode-inspect-largeicon-view-tree]: ../images/listview-virtualmode-inspect-largeicon-view-tree.png
-[listview-virtualmode-inspect-list-view-tree]: ../images/listview-virtualmode-inspect-list-view-tree.png
-[listview-virtualmode-inspect-smallicon-view-tree]: ../images/listview-virtualmode-inspect-smallicon-view-tree.png
-[listviewsubitem-inspect-details-view-tree]: ../images/listviewsubitem-inspect-details-view-tree.png
-[listviewsubitem-inspect-largeicon-view-tree]: ../images/listviewsubitem-inspect-largeicon-view-tree.png
-[listviewsubitem-inspect-list-view-tree]: ../images/listviewsubitem-inspect-list-view-tree.png
-[listviewsubitem-inspect-smallicon-view-tree]: ../images/listviewsubitem-inspect-smallicon-view-tree.png
-[listviewsubitem-inspect-tile-view-tree]: ../images/listviewsubitem-inspect-tile-view-tree.png
-[listviewsubitem-twocolumns-inspect-details-view-tree]: ../images/listviewsubitem-twocolumns-inspect-details-view-tree.png
-[listviewsubitem-twosubitems-inspect-details-view-tree]: ../images/listviewsubitem-twosubitems-inspect-details-view-tree.png
-[listviewsubitem-twocolumns-inspect-tile-view-tree]: ../images/listviewsubitem-twocolumns-inspect-tile-view-tree.png
-[listviewsubitem-threeitems-inspect-tile-view-tree]: ../images/listviewsubitem-threeitems-inspect-tile-view-tree.png
-[listviewsubitem-smallsize-inspect-tile-view-tree]: ../images/listviewsubitem-smallsize-inspect-tile-view-tree.png
-[listviewsubitem-disabledvisualstyles-inspect-tile-view-tree]: ../images/listviewsubitem-disabledvisualstyles-inspect-tile-view-tree.png
\ No newline at end of file
diff --git a/docs/accessibility/monthcalendar-expected-behavior.md b/docs/accessibility/monthcalendar-expected-behavior.md
deleted file mode 100644
index b5578c66dee..00000000000
--- a/docs/accessibility/monthcalendar-expected-behavior.md
+++ /dev/null
@@ -1,1374 +0,0 @@
-# MonthCalendarAccessibleObject expected properties and behavior
-
-This document describes the expected behavior of `MonthCalendarAccessibleObject` 
-when using accessibility tools such as Inspect, Narrator or Accessibility Insights, and 
-expected accessibility properties of all visible items 
-of the [MonthCalendar control](https://docs.microsoft.com/dotnet/api/system.windows.forms.monthcalendar).
-
-
-- [Overview](#Overview)
-- [Accessibility Tools](#Accessibility-Tools)
-    - [Inspect](#Inspect)
-        - [Accessibility tree](##Accessibility-tree)
-        - [Accessibility properties](##Accessibility-properties)
-        - [Accessibility actions](##Accessibility-actions)
-        - [ElementProviderFromPoint (get an item when hovering by mouse) behavior](##ElementProviderFromPoint-(get-an-item-when-hovering-by-mouse)-behavior)   
-    - [Narrator](#Narrator)
-    - [AccessibilityInsights](#AccessibilityInsights)
-- [Behavior test cases](#Behavior-test-cases)
-- [Additional dev points that don't affect users](#Additional-dev-points-that-don't-affect-users)
-    
-
-# Overview
-
-[MonthCalendar](https://docs.microsoft.com/dotnet/api/system.windows.forms.monthcalendar) is a native Windows control, wrapped by Windows Forms SDK. Windows Forms provide a [UIA support](https://docs.microsoft.com/dotnet/framework/ui-automation/ui-automation-overview) for all
-MonthCalendar accessible objects and their children making the MonthCalendar control accessible for Windows Forms end users.
-
-Expected properties and actions of a MonthCalendar and its parts in different accessibility tools are listed below.
-:point_up: A checked item means that the current implementation provides the full support, and the unchecked item means the expected implementation is currently unavailable.
-
-# Accessibility Tools
-
-## Inspect
-
-### Accessibility tree
-
-MonthCalendar accessibility tree must contain all visible items based on its view.
-
-<details>
-<summary>1. Month view</summary>
-
-![monthcalendar-inspect-month-view-tree][monthcalendar-inspect-month-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-
-![monthcalendar-inspect-year-view-tree][monthcalendar-inspect-year-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-
-![monthcalendar-inspect-decade-view-tree][monthcalendar-inspect-decade-view-tree]
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-
-![monthcalendar-inspect-century-view-tree][monthcalendar-inspect-century-view-tree]
-
-</details>
-</br>
-
-### Accessibility properties
-
-
-<details>
-<summary>1. Month view</summary>
-</br>
-
-MonthCalendar:
-- [x] `ControlType` = "calendar" always
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `HelpText` = "MonthCalendar(Control)"
-- [x] Correct grid Column and Row count
-- [x] `Name` is empty, if it is not set
-- [x] `Role` = "table"
-- [x] `Value` = selected dates (e.g. "Saturday, April 10, 2021 - Wednesday, April 14, 2021")
-- [x] Column and row headers = `null`
-- [x] `State` = "focusable" + "focused", if the control is in focus
-- [x] Supports Grid, LegacyIAccessible, Table, Value patterns
-
-Previous/Next buttons:
-- [x] `Name` = "Previous" or "Next"
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled and there are next/previous calendars
-- [x] `HasKeyboardFocus` = `false`
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Today button:
-- [x] `Name` = a button text (e.g. "Today: 3/20/2021")
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar:
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "pane"
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] Has correct GridItem properties
-- [x] `Role` == "client"
-- [x] `State` = "focusable, selectable" + has "focused", "selected", if the calendar contains the focused cell
-- [x] Doesn't have TableItems columns and rows
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-Calendar header button:
-- [x] `Name` = the button text (e.g. "March 2021")
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `DefaultAction` = "Click"
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar body:
-- [x] `Name` = the header text (e.g. March 2021)
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "table"
-- [x] Correct grid Column and Row count (headers are not included)
-- [x] `Role` = "table"
-- [x] `State` = "default"
-- [x] Supports Grid, LegacyIAccessible, Table patterns
-
-Calendar row:
-- [x] `Name` is empty
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the row contains the focused cell
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `ControlType` = "pane"
-- [x] `Role` = "row"
-- [x] `State` = "normal"
-- [x] `Description` = "Week {number}" for date rows. `Description` is empty for a header row
-- [x] Supports LegacyIAccessible pattern
-
-Cell of the header row (day of week):
-- [x] `Name` = the cell text (e.g. "Mon" or "Fri")
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "header"
-- [x] `HasKeyboardFocus` = always `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `Role` = "column header"
-- [x] `State` = "normal"
-- [x] Doesn't have a `Description`
-- [x] Doesn't have a `DefaultAction`
-- [x] Supports LegacyIAccessible pattern
-
-The first cell of date rows (week number):
-- [x] `Name` = "Week {the cell text}" (e.g. "Week 12" or "Week 36" - a week number)
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "header"
-- [x] `HasKeyboardFocus` = always `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `Role` = "row header"
-- [x] `State` = "normal"
-- [x] Doesn't have a `Description`
-- [x] Doesn't have a `DefaultAction`
-- [x] Supports LegacyIAccessible pattern
-
-Date cell:
-- [x] `Name` = the day long name (e.g. "Wednesday, July 14, 2021")
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "DataItem" ("item" in the accessibility tree)
-- [x] `HasKeyboardFocus` = `true`, if the cell is focused and the control in focus
-- [x] `IsKeyboardFocusable` = `true`, if the control is enabled
-- [x] Correct GridItem pattern properties
-- [x] `Description` = "Week {number}, {day of week}" (e.g. "Week 10, Friday")
-- [x] `DefaultAction` = "Click"
-- [x] `Role` = "cell"
-- [x] `State` = "focusable, selectable", if the control is enabled (the order of the states doesn't matter), <br/>
-              "selected, focusable, selectable", if the cell is selected, <br/>
-              "focused, selected, focusable, selectable", if the cell is selected and focused. <br/>
-              :warning: Important point: if a user selects several cells, all of them should have "selected" state, but only one of them should have "focused" state.
-- [x] Correct TableItem column and row headers items
-- [x] Supports Invoke, GridItem, LegacyIAccessible, TableItem patterns
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-</br>
-
-MonthCalendar:
-- [x] `ControlType` = "calendar" always
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `HelpText` = "MonthCalendar(Control)"
-- [x] Correct grid Column and Row count
-- [x] `Name` is empty, if it is not set
-- [x] `Role` = "table"
-- [x] `Value` = a selected month (e.g. "September 2022")
-- [x] Column and row headers = null
-- [x] `State` = "focusable" + "focused" if the control is in focus
-- [x] Supports Grid, LegacyIAccessible, Table, Value patterns
-
-Previous/Next buttons:
-- [x] `Name` = "Previous" or "Next"
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled and there are next/previous calendars
-- [x] `HasKeyboardFocus` = `false`
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Today button:
-- [x] `Name` = a button text (e.g. "Today: 3/20/2021")
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar:
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "pane"
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] Has correct GridItem properties
-- [x] `Role` == "client"
-- [x] `State` = "focusable, selectable" + has "focused", "selected", if the calendar contains the focused cell
-- [x] Doesn't have TableItems columns and rows
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-Calendar header button:
-- [x] `Name` = the button text (e.g. "2021")
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar body:
-- [x] `Name` = the header text (e.g. "2021")
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "table"
-- [x] Correct grid Column and Row count (headers are not included)
-- [x] `Role` = "table"
-- [x] `State` = "default"
-- [x] Supports Grid, LegacyIAccessible, Table patterns
-
-Calendar row:
-- [x] `Name` is empty
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the row contains the focused cell
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `ControlType` = "pane"
-- [x] `Role` = "row"
-- [x] `State` = "normal"
-- [x] `Description` is empty
-- [x] Supports LegacyIAccessible pattern
-
-Month cell:
-- [x] `Name` = the cell text (e.g. "May")
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "DataItem" ("item" in the accessibility tree)
-- [x] `HasKeyboardFocus` = `true`, if the cell is focused
-- [x] `IsKeyboardFocusable` = `true`, if the control is enabled
-- [x] Correct GridItem pattern properties
-- [x] `Description` is empty
-- [x] `Role` = "cell"
-- [x] `State` = "focusable, selectable" if the control is enabled. (the order of the states doesn't matter) <br/>
-              "focused, selected, focusable, selectable" if the cell is selected and focused <br/>
-	          :warning: Important point: if a user can't select several cells in this view, so only one cell should have "selected" state, and this cell should have "focused" state.
-- [x] Doesn't have TableItem column and row headers items 
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-</br>
-
-MonthCalendar:
-- [x] `ControlType` = "calendar" always
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `HelpText` = "MonthCalendar(Control)"
-- [x] Correct grid Column and Row count
-- [x] `Name` is empty, if it is not set
-- [x] `Role` = "table"
-- [x] `Value` = a selected year (e.g. "2022")
-- [x] Column and row headers = null
-- [x] `State` = "focusable" + "focused" if the control is in focus
-- [x] Supports Grid, LegacyIAccessible, Table, Value patterns
-
-Previous/Next buttons:
-- [x] `Name` = "Previous" or "Next"
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled and there are next/previous calendars
-- [x] `HasKeyboardFocus` = `false`
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Today button:
-- [x] `Name` = a button text (e.g. "Today: 3/20/2021")
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar:
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "pane"
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] Has correct GridItem properties
-- [x] `Role` == "client"
-- [x] `State` = "focusable, selectable" + has "focused", "selected", if the calendar contains the focused cell
-- [x] Doesn't have TableItems columns and rows
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-Calendar header button:
-- [x] `Name` = the button text (e.g. "2020-2029")
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar body:
-- [x] `Name` = the header text (e.g. "2020-2029")
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "table"
-- [x] Correct grid Column and Row count (headers are not included)
-- [x] `Role` = "table"
-- [x] `State` = "default"
-- [x] Supports Grid, LegacyIAccessible, Table patterns
-
-Calendar row:
-- [x] `Name` is empty
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the row contains the focused cell
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `ControlType` = "pane"
-- [x] `Role` = "row"
-- [x] `State` = "normal"
-- [x] `Description` is empty
-- [x] Supports LegacyIAccessible pattern
-
-Year cell:
-- [x] `Name` = the cell text (e.g. "2020")
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "DataItem" ("item" in the accessibility tree)
-- [x] `HasKeyboardFocus ` = `true`, if the cell is focused
-- [x] `IsKeyboardFocusable` = `true`, if the control is enabled
-- [x] Correct GridItem pattern properties
-- [x] `Description` is empty
-- [x] `Role` = "cell"
-- [x] `State` = "focusable, selectable" if the control is enabled. (the order of the states doesn't matter) <br/>
-              "focused, selected, focusable, selectable" if the cell is selected and focused <br/>
-	          :warning: Important point: if a user can't select several cells in this view, so only one cell should have "selected" state, and this cell should have "focused" state.
-- [x] Doesn't have TableItem column and row headers items 
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-</br>
-
-MonthCalendar:
-- [x] `ControlType` = "calendar" always
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `HelpText` = "MonthCalendar(Control)"
-- [x] Correct grid Column and Row count
-- [x] `Name` is empty, if it is not set
-- [x] `Role` = "table"
-- [x] `Value` = a selected decade (e.g. "2020-2029")
-- [x] Column and row headers = null
-- [x] `State` = "focusable" + "focused" if the control is in focus
-- [x] Supports Grid, LegacyIAccessible, Table, Value patterns
-
-Previous/Next buttons:
-- [x] `Name` = "Previous" or "Next"
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled and there are next/previous calendars
-- [x] `HasKeyboardFocus` = `false`
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Today button:
-- [x] `Name` = a button text (e.g. "Today: 3/20/2021")
-- [x] `ControlType` = "button"
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action and description
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar:
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "pane"
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] Has correct GridItem properties
-- [x] `Role` == "client"
-- [x] `State` = "focusable, selectable" + has "focused", "selected", if the calendar contains the focused cell
-- [x] Doesn't have TableItems columns and rows
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-Calendar header button:
-- [x] `Name` = the button text (e.g. "2000-2099")
-- [x] `HasKeyboardFocus` = `false`
-- [x] `IsKeyboardFocusable` = `false`
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] Has a default action
-- [x] `Role` = "push button"
-- [x] `State` = "normal"
-- [x] Supports Invoke and LegacyIAccessible
-
-Calendar body:
-- [x] `Name` = the header text (e.g. "2000-2099")
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the calendar contains the focused cell
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "table"
-- [x] Correct grid Column and Row count (headers are not included)
-- [x] `Role` = "table"
-- [x] `State` = "default"
-- [x] Supports Grid, LegacyIAccessible, Table patterns
-
-Calendar row:
-- [x] `Name` is empty
-- [x] `HasKeyboardFocus` = `true`, if the control is in focus and the row contains the focused cell
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `IsKeyboardFocusable` = `true`, if the calendar is enabled
-- [x] `ControlType` = "pane"
-- [x] `Role` = "row"
-- [x] `State` = "normal"
-- [x] `Description` is empty
-- [x] Supports LegacyIAccessible pattern
-
-Decade cell:
-- [x] `Name` = the cell text (e.g. "2020-2029")
-- [x] `IsEnabled` = `true`, if the control is enabled
-- [x] `ControlType` = "DataItem" ("item" in the accessibility tree)
-- [x] `HasKeyboardFocus` = `true`, if the cell is focused
-- [x] `IsKeyboardFocusable` = `true`, if the control is enabled
-- [x] Correct GridItem pattern properties
-- [x] `Description` is empty
-- [x] `Role` = "cell"
-- [x] `State` = "focusable, selectable" if the control is enabled. (the order of the states doesn't matter) <br/>
-          "focused, selected, focusable, selectable" if the cell is selected and focused <br/>
-	      :warning: Important point: if a user can't select several cells in this view, so only one cell should have "selected" state, and this cell should have "focused" state.
-- [x] Doesn't have TableItem column and row headers items 
-- [x] Supports GridItem, LegacyIAccessible, TableItem patterns
-
-</details>
-</br>
-
-### Accessibility actions
-
-Here are described accessibility actions of supported patterns.
-:point_up: The "Focus" action has unexpected behavior, because when you call it from Inspect,
-the testing form loses focus. Then the form gets focus, in this case,
-MonthCalendar.OnGotFocus handler works, that raises accessibility focus event for the focused cell accessible object.
-
-<details>
-<summary>1. Month view</summary>
-</br>
-
-MonthCalendar:
-- [x] Focus - focuses on the focused cell
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the previous/next month)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (works in the debug mode only, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [ ] Focus - focuses on the focused cell, if the row contains it. And does nothing, if the row doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Cell of the header row (day of week):
-- [ ] Focus - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the header cell is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-The first cell of date rows (week numbers):
-- [ ] Focus - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the header cell is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Date cell:
-- [x] Focus - focuses on the focused cell
-- [x] Invoke.Invoke - clicks the cell (select it)
-- [x] LegacyIAccessible.Select - selects the cell
-- [x] LegacyIAccessible.DoDefaultAction - selects the cell
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-</br>
-
-MonthCalendar:
-- [x] Focus - focuses on the focused cell
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the previous/next month)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (works in the debug mode only, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [ ] Focus - focuses on the focused cell, if the row contains it. And does nothing, if the row doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Month cell:
-- [x] Focus - focuses on the focused cell
-- [x] Invoke.Invoke - clicks the cell (changes the view)
-- [x] LegacyIAccessible.Select - selects the cell
-- [x] LegacyIAccessible.DoDefaultAction - click the cell
-- [x] LegacyIAccessible.SetValue - does nothing
-
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-</br>
-
-MonthCalendar:
-- [x] Focus - focuses on the focused cell
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the previous/next month)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (works in the debug mode only, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [ ] Focus - focuses on the focused cell, if the row contains it. And does nothing, if the row doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Year cell:
-- [x] Focus - focuses on the focused cell
-- [x] Invoke.Invoke - clicks the cell (changes the view)
-- [x] LegacyIAccessible.Select - selects the cell
-- [x] LegacyIAccessible.DoDefaultAction - click the cell
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-</br>
-
-MonthCalendar:
-- [x] Focus - focuses on the focused cell
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the previous/next month)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (works in the debug mode only, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [ ] Focus - the button is not keyboard focusable, so does nothing
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Focus - focuses on the focused cell, if the calendar contains it. And does nothing, if the calendar doesn't contain the focused cell 
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [ ] Focus - focuses on the focused cell, if the row contains it. And does nothing, if the row doesn't contain the focused cell 
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Decade cell:
-- [x] Focus - focuses on the focused cell
-- [x] Invoke.Invoke - clicks the cell (changes the view)
-- [x] LegacyIAccessible.Select - selects the cell
-- [x] LegacyIAccessible.DoDefaultAction - click the cell
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-### ElementProviderFromPoint (get an item when hovering by mouse) behavior
-
-- [x] Returns a MonthCalendar accessible object, if mouse isn't hovering any element
-- [x] Returns a "Previous" button accessible object, if mouse is hovering it
-- [x] Returns a "Next" button accessible object, if mouse is hovering it
-- [x] Returns a "Today" button accessible object, if mouse is hovering the "Today" text, or to the right of the text
-- [x] Returns a calendar header button accessible object (e.g. "March 2021"), if mouse is hovering it
-- [x] Returns a day of week cell accessible object (e.g. "Sat"), if its MonthCalendar is in the Month view and mouse is hovering it
-- [x] Returns a week number cell accessible object (e.g. "18"), if 
-    - `ShowWeekNumber` = `true`, 
-    - its MonthCalendar is in the Month view
-    - mouse is hovering this cell
-- [x] Returns a day/month/year/years cell accessible object, if this cell is visible, and mouse is hovering it
-- [x] Returns an accessible object of a gray cell of the next/previous calendar, if it is, and if mouse is hovering it <details><summary>Screenshot</summary>![monthcalendar-gray-dates-accessible-from-point][monthcalendar-gray-dates-accessible-from-point]</details>
-- [x] Returns a calendar accessible object, if its Bounds contains mouse coordinates, and if there is no any cell in this point <details><summary>Screenshot</summary>![monthcalendar-calendar-accessible-from-point][monthcalendar-calendar-accessible-from-point]</details>
-- [x] Returns a MonthCalendar accessible object, if `MaxDate` and `MinDate` are set, and several months are missing there (they are invisible) and if mouse is hovering some invisible calendar <details><summary>Screenshot</summary>![monthcalendar-control-accessible-from-point][monthcalendar-control-accessible-from-point]</details>
-- [x] Returns an accessible object of the first week number of a calendar, if mouse is hovering it, and if the calendar first row is partial (a specific case - there is a workaround that fixes a bug of Win API) <details><summary>Screenshot</summary>![monthcalendar-first-weeknumber-accessible-from-point][monthcalendar-first-weeknumber-accessible-from-point]</details>
-- [x] Doesn't return week number cells accessible objects of the last calendar, if `MaxDate` is set, and mouse is hovering them <details><summary>Screenshot</summary>![monthcalendar-last-weeknumbers-accessible-from-point][monthcalendar-last-weeknumbers-accessible-from-point]</details>
-- [x] Returns a correct accessible object, that is visible, if `MaxDate`, `MinDate`, `FirstDayOfWeek` are changed or the display range is changed via the "Next"/"Previous" buttons
-
-## Narrator
-
-<details>
-<summary>1. Month view</summary>
-</br>
-
-- [x] Announces dates when moving through them
-- [x] Moves through all the accessibility tree nodes in the "Scan" mode
-- [ ] Moves through all the accessibility tree nodes in the "Scan" mode after the display range is changed
-- [x] Focuses on the focused cell when the control gets focus
-- [ ] Focuses on the focused cell, if `MaxDate`, `MinDate`, `FirstDayOfWeek` are changed or the display range is changed via the "Next"/"Previous" buttons
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-</br>
-
-- [x] Announces dates when moving through them
-- [x] Moves through all the accessibility tree nodes in the "Scan" mode
-- [ ] Moves through all the accessibility tree nodes in the "Scan" mode after the display range is changed
-- [x] Focuses on the focused cell when the control gets focus
-- [ ] Focuses on the focused cell, if `MaxDate`, `MinDate`, `FirstDayOfWeek` are changed or the display range is changed via the "Next"/"Previous" buttons
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-</br>
-
-- [x] Announces dates when moving through them
-- [x] Moves through all the accessibility tree nodes in the "Scan" mode
-- [ ] Moves through all the accessibility tree nodes in the "Scan" mode after the display range is changed
-- [x] Focuses on the focused cell when the control gets focus
-- [ ] Focuses on the focused cell, if `MaxDate`, `MinDate`, `FirstDayOfWeek` are changed or the display range is changed via the "Next"/"Previous" buttons
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-</br>
-
-- [x] Announces dates when moving through them
-- [x] Moves through all the accessibility tree nodes in the "Scan" mode
-- [ ] Moves through all the accessibility tree nodes in the "Scan" mode after the display range is changed
-- [x] Focuses on the focused cell when the control gets focus
-- [ ] Focuses on the focused cell, if `MaxDate`, `MinDate`, `FirstDayOfWeek` are changed or the display range is changed via the "Next"/"Previous" buttons
-
-</details>
-</br>
-
-## AccessibilityInsights
-
-<details>
-<summary>1. Month view</summary>
-</br>
-
-- [x] There are no any AI errors
-- [x] The accessibility tree is correct
-- [x] AI gets a correct visible accessible object when hovering the mouse (an element from the point)
-- [x] AI sees correct item patterns and does supported pattern Actions correctly
-
-MonthCalendar:
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Invoke.Invoke - clicks the button (moves to the previous/next month)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Cell of the header row (day of week):
-- [x] LegacyIAccessible.Select - does nothing, because the header cell is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-The first cell of date rows (week numbers):
-- [x] LegacyIAccessible.Select - does nothing, because the header cell is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Date cell:
-- [x] Invoke.Invoke - clicks the cell (select it)
-- [x] LegacyIAccessible.Select - selects the cell
-- [ ] LegacyIAccessible.DoDefaultAction - selects the cell (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-</br>
-
-- [x] There are no any AI errors
-- [x] The accessibility tree is correct.
-- [x] AI gets a correct visible accessible object when hovering the mouse (an element from the point).
-- [x] AI sees correct items patterns and does supported pattern Actions correctly:
-
-MonthCalendar:
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Invoke.Invoke - clicks the button (moves to the previous/next month) (AI issue)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Month cell:
-- [x] Invoke.Invoke - clicks the cell (select it)
-- [x] LegacyIAccessible.Select - selects the cell
-- [ ] LegacyIAccessible.DoDefaultAction - selects the cell (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-</br>
-
-- [x] There are no any AI errors
-- [x] The accessibility tree is correct.
-- [x] AI gets a correct visible accessible object when hovering the mouse (an element from the point).
-- [x] AI sees correct items patterns and does supported pattern Actions correctly:
-
-MonthCalendar:
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Invoke.Invoke - clicks the button (moves to the previous/next month) (AI issue)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Year cell:
-- [x] Invoke.Invoke - clicks the cell (select it)
-- [x] LegacyIAccessible.Select - selects the cell
-- [ ] LegacyIAccessible.DoDefaultAction - selects the cell (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-</br>
-
-- [x] There are no any AI errors
-- [x] The accessibility tree is correct.
-- [x] AI gets a correct visible accessible object when hovering the mouse (an element from the point).
-- [x] AI sees correct items patterns and does supported pattern Actions correctly:
-
-MonthCalendar:
-- [ ] Grid.GetItem- returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] Value.SetValue - does nothing
-- [x] LegacyIAccessible.Select - does nothing, because the MonthCalendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Previous/Next buttons:
-- [ ] Invoke.Invoke - clicks the button (moves to the previous/next month) (AI issue)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [ ] LegacyIAccessible.DoDefaultAction - clicks the button (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Today button:
-- [x] Invoke.Invoke - clicks the button (moves to the today cell)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar:
-- [x] LegacyIAccessible.Select - does nothing, because the calendar is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar header button:
-- [x] Invoke.Invoke - clicks the button (changes the calendar view)
-- [x] LegacyIAccessible.Select - does nothing, because the button is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - clicks the button (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar body:
-- [ ] Grid.GetItem - returns OK for the correct row and column, returns FAIL for incorrect arguments (doesn't work, it's Inspect Issue)
-- [x] LegacyIAccessible.Select - does nothing, because the body is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Calendar row:
-- [x] LegacyIAccessible.Select - does nothing, because the row is not selectable
-- [x] LegacyIAccessible.DoDefaultAction - does nothing
-- [x] LegacyIAccessible.SetValue - does nothing
-
-Decade cell:
-- [x] Invoke.Invoke - clicks the cell (select it)
-- [x] LegacyIAccessible.Select - selects the cell
-- [ ] LegacyIAccessible.DoDefaultAction - selects the cell (AI issue)
-- [x] LegacyIAccessible.SetValue - does nothing
-
-</details>
-</br>
-
-# Behavior test cases
-
-<details>
-<summary>1. Month view</summary>
-</br>
-
-- [x] **Case:** Change the Today date (set `TodayDate` of a MonthCalendar)
-</br>**Expected:** Nothing happens
-- [x] **Case:** Click on a gray date cell (of the next or previous calendars)
-</br>**Expected:** The monthCalendar changes the display range. Its accessibility tree rebuilds.
-- [x] **Case:** Size of the control is changed that the control changes calendars count
-</br>**Expected:** The accessibility tree is rebuilt. ElementProviderFromPoint returns visible items correctly
-- [x] **Case:** A calendar of a MonthCalendar has non-full rows
-</br>**Expected:** Inspect sees only visible items in that row
-- [x] **Case:** A calendar of a MonthCalendar has some empty rows
-</br>**Expected:** These rows are not in the accessibility tree
-- [x] **Case:** The first week number cell in the first calendar in a MonthCalendar is in a non-full row
-</br>**Expected:** Inspect sees that cell correctly with the correct name
-- [x] **Case:** The last week number cells of the last non-full calendar have the same values for empty rows
-</br>**Expected:** They are not in the accessibility tree
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to right, thereby the focused cell 
-will be in right (e.g. 15th of September). Set `MinDate` of the calendar less then the selected range (e.g. 1st of September).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to left, thereby the focused cell 
-will be in left (e.g. 10th of September). Set `MinDate` of the calendar less then the selected range (e.g. 1st of September).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to right, thereby the focused cell 
-will be in right (e.g. 15th of September). Set `MaxDate` of the calendar more then the selected range (e.g. 20th of September).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to left, thereby the focused cell 
-will be in left (e.g. 10th of September). Set `MaxDate` of the calendar more then the selected range (e.g. 20th of September).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to right, thereby the focused cell 
-will be in right (e.g. 15th of September). Set `MinDate` of the calendar more then the start of the selected range, 
-but less then the end of the selected range (e.g. 13th of September).
-</br>**Expected:** The selected range changes. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to left, thereby the focused cell 
-will be in left (e.g. 10th of September). Set `MinDate` of the calendar more then the start of the selected range, 
-but less then the end of the selected range (e.g. 13th of September).
-</br>**Expected:** The selected range changes. The focused cell changes (13th of September). 
-The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to right, thereby the focused cell 
-will be in right (e.g. 15th of September). Set `MaxDate` of the calendar more then the start of the selected range, 
-but less then the end of the selected range (e.g. 13th of September).
-</br>**Expected:** The selected range changes. The focused cell changes (13th of September). 
-The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to left, thereby the focused cell 
-will be in left (e.g. 10th of September). Set `MaxDate` of the calendar more then the start of the selected range, 
-but less then the end of the selected range (e.g. 13th of September).
-</br>**Expected:** The selected range changes. The focused cell cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to right, thereby the focused cell 
-will be in right (e.g. 15th of September). Set new `FirstDayOfWeek` (e.g. Friday).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select some dates (e.g. 10-15th of September), move to left, thereby the focused cell 
-will be in left (e.g. 10th of September). Set new `FirstDayOfWeek` (e.g. Friday).
-</br>**Expected:** The selected range doesn't change. The focused cell doesn't change. 
-The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** `MinDate` is more then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** `MaxDate` is less then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** A MonthCalendar has 1 calendar.
-</br>**Expected:** Accessibility tree has 1 calendar.
-- [x] **Case:** A MonthCalendar has several calendars. 
-</br>**Expected:** Accessibility tree has the same count of calendars.
-- [x] **Case:** `MinDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates before `MinDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates after `MaxDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a more date range then the display range of the MonthCalendar.
-</br>**Expected:** Accessibility tree has all visible calendars. All dates are accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a less date range then the display range of the MonthCalendar. 
-Thereby the MonthCalendar has several partially visible calendars 
-(e.g. the MonthCalendar can contain 6 calendars, but 3 of them are visible due `MinDate` and `MinDate`). 
-</br>**Expected:** Accessibility tree has the count of visible calendars only (e.g. 3).
-Invisible calendars are not accessible. Invisible dates of partial calendars are not accessible.
-
-</details>
-</br>
-
-<details>
-<summary>2. Year view</summary>
-</br>
-
-- [x] **Case:** Change the Today date (set `TodayDate` of a MonthCalendar)
-</br>**Expected:** Nothing happens
-- [x] **Case:** Click on a gray month cell (of the next or previous calendars)
-</br>**Expected:** The monthCalendar changes the display range. It accessibility tree rebuilds.
-- [x] **Case:** Size of the control is changed that the control changes calendars count
-</br>**Expected:** The accessibility tree is rebuilt. ElementProviderFromPoint returns visible items correctly
-- [x] **Case:** A calendar of a MonthCalendar has non-full rows
-</br>**Expected:** Inspect sees only visible items in that row
-- [x] **Case:** A calendar of a MonthCalendar has some empty rows
-</br>**Expected:** These rows are not in the accessibility tree
-- [x] **Case:** There are no week number and day of week cells in calendars
-</br>**Expected:** There are no any invisible items (week number and day of week cells) in the accessibility tree
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar less then the selected cell (e.g. 1st of June).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar more then the selected cell (e.g. 1st of December).
-</br>**Expected:** The focused cell changes (e.g. December). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar less then the selected cell (e.g. 1st of June).
-</br>**Expected:** The focused cell changes (e.g. June). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar more then the selected cell (e.g. 1st of December).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar with the same month (e.g. 30th of September).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. September), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar with the same month (e.g. 1st of September).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** `MinDate` is more then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** `MaxDate` is less then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** A MonthCalendar has 1 calendar.
-</br>**Expected:** Accessibility tree has 1 calendar.
-- [x] **Case:** A MonthCalendar has several calendars. 
-</br>**Expected:** Accessibility tree has the same count of calendars.
-- [x]  **Case:** `MinDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates before `MinDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates after `MaxDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a more date range then the display range of the MonthCalendar.
-</br>**Expected:** Accessibility tree has all visible calendars. All dates are accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a less date range then the display range of the MonthCalendar. 
-Thereby the MonthCalendar has several partially visible calendars 
-(e.g. the MonthCalendar can contain 6 calendars, but 3 of them are visible due `MinDate` and `MinDate`). 
-</br>**Expected:** Accessibility tree has the count of visible calendars only (e.g. 3).
-Invisible calendars are not accessible. Invisible dates of partial calendars are not accessible.
-
-</details>
-</br>
-
-<details>
-<summary>3. Decade view</summary>
-</br>
-
-- [x] **Case:** Change the Today date (set `TodayDate` of a MonthCalendar)
-</br>**Expected:** Nothing happens
-- [x] **Case:** Click on a gray year cell (of the next or previous calendars)
-</br>**Expected:** The monthCalendar changes the display range. It accessibility tree rebuilds.
-- [x] **Case:** Size of the control is changed that the control changes calendars count
-</br>**Expected:** The accessibility tree is rebuilt. ElementProviderFromPoint returns visible items correctly
-- [x] **Case:** A calendar of a MonthCalendar has non-full rows
-</br>**Expected:** Inspect sees only visible items in that row
-- [x] **Case:** A calendar of a MonthCalendar has some empty rows
-</br>**Expected:** These rows are not in the accessibility tree
-- [x] **Case:** There are no week number and day of week cells in calendars
-</br>**Expected:** There are no any invisible items (week number and day of week cells) in the accessibility tree
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar less then the selected cell (e.g. 1st of June 2019).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar more then the selected cell (e.g. 1st of December 2021).
-</br>**Expected:** The focused cell changes (e.g. 2021). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar less then the selected cell (e.g. 1st of June 2019).
-</br>**Expected:** The focused cell changes (e.g. 2019). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar more then the selected cell (e.g. 1st of December 2021).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar with the same year (e.g. 31th of December 2020).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar with the same year (e.g. 1st of January 2020).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** `MinDate` is more then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** `MaxDate` is less then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** A MonthCalendar has 1 calendar.
-</br>**Expected:** Accessibility tree has 1 calendar.
-- [x] **Case:** A MonthCalendar has several calendars. 
-</br>**Expected:** Accessibility tree has the same count of calendars.
-- [x] **Case:** `MinDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates before `MinDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates after `MaxDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a more date range then the display range of the MonthCalendar.
-</br>**Expected:** Accessibility tree has all visible calendars. All dates are accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a less date range then the display range of the MonthCalendar. 
-Thereby the MonthCalendar has several partially visible calendars 
-(e.g. the MonthCalendar can contain 6 calendars, but 3 of them are visible due `MinDate` and `MinDate`). 
-</br>**Expected:** Accessibility tree has the count of visible calendars only (e.g. 3).
-Invisible calendars are not accessible. Invisible dates of partial calendars are not accessible.
-
-</details>
-</br>
-
-<details>
-<summary>4. Century view</summary>
-</br>
-
-- [x] **Case:** Change the Today date (set `TodayDate` of a MonthCalendar)
-</br>**Expected:** Nothing happens
-- [x] **Case:** Click on a gray decade cell (of the next or previous calendars)
-</br>**Expected:** The monthCalendar changes the display range. It accessibility tree rebuilds.
-- [x] **Case:** Size of the control is changed that the control changes calendars count
-</br>**Expected:** The accessibility tree is rebuilt. ElementProviderFromPoint returns visible items correctly
-- [x] **Case:** A calendar of a MonthCalendar has non-full rows
-</br>**Expected:** Inspect sees only visible items in that row
-- [x] **Case:** A calendar of a MonthCalendar has some empty rows
-</br>**Expected:** These rows are not in the accessibility tree
-- [x] **Case:** There are no week number and day of week cells in calendars
-</br>**Expected:** There are no any invisible items (week number and day of week cells) in the accessibility tree
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar less then the selected cell (e.g. 1st of June 2019).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar more then the selected cell (e.g. 1st of December 2021).
-</br>**Expected:** The focused cell changes (e.g. 2021). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar less then the selected cell (e.g. 1st of June 2019).
-</br>**Expected:** The focused cell changes (e.g. 2019). The new focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar more then the selected cell (e.g. 1st of December 2021).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MinDate` of the calendar with the same year (e.g. 31th of December 2020).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** Select one month cell (e.g. 2020), user can't select several cell in this view, 
-so the selected cell is focused. Set `MaxDate` of the calendar with the same year (e.g. 1st of January 2020).
-</br>**Expected:** The focused cell doesn't change. The focused cell has "focused" accessibility state (check Inspect).
-- [x] **Case:** `MinDate` is more then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** `MaxDate` is less then the selected range. 
-</br>**Expected:** The focused cell changes. The new focused cell has "focused" accessibility state.
-- [x] **Case:** A MonthCalendar has 1 calendar.
-</br>**Expected:** Accessibility tree has 1 calendar.
-- [x] **Case:** A MonthCalendar has several calendars. 
-</br>**Expected:** Accessibility tree has the same count of calendars.
-- [x] **Case:** `MinDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates before `MinDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` is set for a MonthCalendar. 
-</br>**Expected:** Dates after `MaxDate` are invisible and are not accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a more date range then the display range of the MonthCalendar.
-</br>**Expected:** Accessibility tree has all visible calendars. All dates are accessible.
-- [x] **Case:** `MaxDate` and `MinDate` are set for a MonthCalendar. 
-They are has a less date range then the display range of the MonthCalendar. 
-Thereby the MonthCalendar has several partially visible calendars 
-(e.g. the MonthCalendar can contain 6 calendars, but 3 of them are visible due `MinDate` and `MinDate`). 
-</br>**Expected:** Accessibility tree has the count of visible calendars only (e.g. 3).
-Invisible calendars are not accessible. Invisible dates of partial calendars are not accessible.
-
-</details>
-</br>
-
-# Additional dev points that don't affect users
-
-- Rebuild the accessibility tree, if the calendar `View`, `MaxDate`, `MinDate`, `TodayDate`, `Size` are changed
-or Next or Previous buttons are clicked (i.e. the display range is changed).
-- Invoke method of button accessible objects of MonthCalendar simulates mouse moving, clicks and then returns the mouse position back.
-Windows doesn't provide API to simulate  MonthCalendar buttons clicks via messages.
-
-[monthcalendar-inspect-month-view-tree]: ../images/monthcalendar-inspect-month-view-tree.png
-[monthcalendar-inspect-year-view-tree]: ../images/monthcalendar-inspect-year-view-tree.png
-[monthcalendar-inspect-decade-view-tree]: ../images/monthcalendar-inspect-decade-view-tree.png
-[monthcalendar-inspect-century-view-tree]: ../images/monthcalendar-inspect-century-view-tree.png
-[monthcalendar-gray-dates-accessible-from-point]: ../images/monthcalendar-gray-dates-accessible-from-point.png
-[monthcalendar-calendar-accessible-from-point]: ../images/monthcalendar-calendar-accessible-from-point.png
-[monthcalendar-control-accessible-from-point]: ../images/monthcalendar-control-accessible-from-point.png
-[monthcalendar-first-weeknumber-accessible-from-point]: ../images/monthcalendar-first-weeknumber-accessible-from-point.png
-[monthcalendar-last-weeknumbers-accessible-from-point]: ../images/monthcalendar-last-weeknumbers-accessible-from-point.png
\ No newline at end of file
diff --git a/docs/building.md b/docs/building.md
deleted file mode 100644
index 25f26541301..00000000000
--- a/docs/building.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# Building Windows Forms
-
-## Prerequisites
-
-Follow the prerequisites listed at [Developer Guide](developer-guide.md).
-
-## Building
-
-### Building from command line (Preferred)
-
-* Run `.\build.cmd` from the repository root. This builds the `Winforms.sln` using the default config (Debug|Any CPU).
-* To specify a build configuration, add `-configuration` followed by the config such as `.\build -configuration Release`.
-
-Note that this does **not** build using your machine-wide installed version of the dotnet sdk. It builds using the repo-local .NET SDK specified in the global.json in the repository root.
-
-### Building from Visual Studio
-
-1. .NET 6.0 and above branches need VisualStudio 2022 to build.
-2. Run `.\restore.cmd` from the repository root.
-3. Run `.\start-vs.cmd` from the repository root. This will prepend the repo-local .NET SDK to the path, and open `Winforms.sln` in Visual Studio.
-4. You should now be able to build as you normally would.
-
-### Building from Visual Studio Code
-
-1. (Optional) Run `.\restore.cmd` from the repository root.
-1. Run `.\start-code.cmd` from the repository root. This will prepend the repo-local .NET SDK to the path, and open `Winforms.sln` in Visual Studio Code.
-1. You should now be able to build and test as you normally would from command line (or VS Code, if you have set it).
-
-## Build outputs
-
-* All build outputs are generated under the `artifacts` folder.
-* Binaries are under `artifacts\bin`.
-  * For example, `System.Windows.Forms.dll` can be found under `artifacts\bin\System.Windows.Forms\Debug\net6.0`.
-* Logs are found under `artifacts\log`.
-* Packages are found under `artifacts\packages`.
-
-## Running apps from VS
-
-1. Right click on the project you wish to run and select 'Set as startup project'.
-2. <kbd>F5</kbd>.
-
-## Running apps from command line
-
-1. Build the solution: `.\build.cmd`
-2. Navigate to the project you wish to run, e.g. to run AccessibilityTests test app:
-    ```
-    winforms> pushd .\src\System.Windows.Forms\tests\AccessibilityTests
-    winforms\src\System.Windows.Forms\tests\AccessibilityTests> dotnet run
-    ```
-3. (Alternatively) Navigate to `.\artifacts\bin\AccessibilityTests\Debug\net6.0` and run the app manually.
-
-## Troubleshooting build errors
-
-* Most build errors are compile errors and can be dealt with accordingly.
-* Other error may be from MSBuild tasks. You need to examine the build logs to investigate.
-  * The logs are generated at `.\artifacts\log\Debug\Build.binlog`
-  * The file format is an MSBuild Binary Log. Install the [MSBuild Structured Log Viewer][msbuild-log-viewer] to view them.
-* Windows Forms uses Visual Studio MSBuild but for certain features we require the latest MSBuild from .NET Core/.NET SDK. If you are on an official version of [Visual Studio][VS-download] (i.e. not a Preview version), then you may need to enable previews for .NET Core/.NET SDKs in VS.
-  * you can do this in VS under Tools->Options->Environment->Preview Features->Use previews of the .Net Core SDK (Requires restart)
-
-## Creating a package
-
-To create the Microsoft.Private.Winforms package, run `.\build -pack`
-
-## Localization
-
-If you need to add a new localization string or update an existing one, follow these steps:
-
-- Modify `Resource\SR.resx` file adding or updating necessary strings in the project that contains the said strings. (It is often faster/easier to open SR.resx in an XML editor).
-- Regenerate the localization files by rebuilding the solution/project from Visual Studio, or by executing `.\build.cmd` command. You can also build just the modified project by running  `dotnet build` from the project's root.
-
-[comment]: <> (URI Links)
-
-[corefx-windows-instructions]: https://github.com/dotnet/corefx/blob/master/Documentation/building/windows-instructions.md
-[latest-core-build]: https://github.com/dotnet/core/blob/master/daily-builds.md
-[msbuild-log-viewer]: https://msbuildlog.com/
-[VS-download]: https://visualstudio.microsoft.com/downloads/
diff --git a/docs/debugging.md b/docs/debugging.md
deleted file mode 100644
index 89c6cdd500e..00000000000
--- a/docs/debugging.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Debugging
-
-There are two recommended ways to debug Windows Forms binaries. Both require that you first [build from source](building.md).
-
-Once you are ready to debug your changes on an existing Windows Forms application, please follow one of the two following recommended techniques for relating your changes back to your project. You should then be able to set breakpoints and debug as expected.
-
-If you do not want to modify your local SDK, you may with to perform technique 2. However if you do not want to add an additional reference to your project, technique 1 may be better for you.
-
-## 1. Copy your changes into the SDK
-
-Copy the resulting assembly(-ies) from your local build.
-
-- They are located at `[Path-to-repo]\winforms\artifacts\bin\System.Windows.Forms\Debug\net7.0`
-- And need to be copied to the system dotnet folder `[Drive]:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App\[Version]`
-
-:warning: If you have updated any public APIs, you'll need to overwrite the ref assemblies too (since that's what VS uses when resolving types):
-- The ref assemblies compile to `[Path-to-repo]\winforms\artifacts\bin\System.Windows.Forms\Debug\net7.0\ref`
-- These need to be copied to `[Drive]:\Program Files\dotnet\packs\Microsoft.WindowsDesktop.App.Ref\[Version]`
-
-where:
-- **[Drive]** is your OS drive (for example, C:),
-- **[Path-to-repo]** is the additional path to our repository from the base drive, and
-- **[Version]** is your WindowsDesktop version directory (for example, 5.0.0-rc.2.20464.5).
-
-
-
-**NOTE** Make sure to make a backup copy of assemblies you replace, you will modify your SDK. Alternatively you can repair the install or reinstall.
-
-## 2. Point your project to your experimental binary(-ies)
-
-Add references to the binary(-ies) to your project ported to .NET. For example, for System.Windows.Forms, you should add the following reference:
-
-```xml
-<ItemGroup>
-    <Reference Include="[Drive]:[Path-to-repo]\winforms\artifacts\bin\System.Windows.Forms\Debug\net7.0\System.Windows.Forms.dll" />
-    <Reference Include="[Drive]:[Path-to-repo]\winforms\artifacts\bin\System.Windows.Forms.Primitives\Debug\net7.0\System.Windows.Forms.Primitives.dll" />
-    <!-- Optionally you may need designer -->
-    <Reference Include="[Drive]:[Path-to-repo]\winforms\artifacts\bin\System.Windows.Forms.Design\Debug\net7.0\System.Windows.Forms.Design.dll" />
-</ItemGroup>
-```
-
-where:
-- **[Drive]** is the drive you have our repository in, and
-- **[Path-to-repo]** is the additional path to our repository from the base drive. 
diff --git a/docs/design/anchor-layout-changes-in-net80.md b/docs/design/anchor-layout-changes-in-net80.md
deleted file mode 100644
index adcd7695157..00000000000
--- a/docs/design/anchor-layout-changes-in-net80.md
+++ /dev/null
@@ -1,126 +0,0 @@
-# Anchor layout changes in .NET 8.0
-
-
-## Description
-
-We have multiple [issues](https://github.com/dotnet/winforms/issues?q=is%3Aissue+is%3Aopen+anchor+label%3A%22area%3A+anchor%2Fscaling%22) reported in WinForms around the anchor layout being problematic on higher DPI scale monitors, irrespective of application DPI mode. This document outlines the changes being made in .NET 8.0 to address these issues, which is aligned with the larger goal to support all supported application DPI modes in WinForms.
-
-## Problem in Scope
-
-The position of an anchored control with respect to its parent should be able to be determined at design time and should only need to be changed if there were explicit changes in the control's bounds or when the control is scaled in response to a DPI changed event. Bounds changes that happen as result of the parent control's bounds changing shouldn't alter a control's relative position in the parent's rectangle. However, currently the layout engine computes the anchored control's relative position every time there are changes to the control's bounds or the control's location-related properties.
-
-For example, the following simple code snippet copied from a Control's `InitializeComponent` method demonstrates the impact of the "over-eager" computations. The number of unnecessary computations can increase quite dramatically for nested layouts.
-
-```CS
-// The following line triggers layout to compute anchors with the default button size and without a parent control.
-this.button7.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
-
-// The following line triggers layout again to compute anchors with the default button size with a new location but still without a parent control.
-this.button7.Location = new System.Drawing.Point(9, 47);
-
-// The following line triggers layout once again to compute anchors with the button's new size but still without a parent control.
-this.button7.Size = new System.Drawing.Size(134, 23);
-
-// The following line triggers layout to compute anchors with button's current size and the default size for the parent control.
-this.Controls.Add(button7);
-
-// The following line triggers layout to compute anchors with the button's current size and a new size for the parent control.
-// These sizes still may be changed for the current DPI depending on application's DPI mode.
-this.Size = new System.Drawing.Size(828, 146);
-
-// The following line triggers layout to compute anchors with the button's current size and new size for the parent control.
-// The current DPI is still not applied.
-this.ResumeLayout(false);
-```
-The above snippet does not represent the complete set of instances where anchor computations are unnecessary and may hold invalid anchor values. It gets even more complicated when nested UserControls are involved.
-
-In addition, the original anchor calculation implementation was designed prior to adding high DPI support to WinForms.
-
-## Known issues
-
-Customer reported issues can be largely grouped as follows:
-
-
-### Missing controls
-
-Calculation of control's anchors with default sizes may result in negative anchors and, thus, result in an invalid location for the anchored controls.
-
-![MissingControls](../images/AnchorLayoutKnownIssue_MissingControl.png)
-
-
-### Overlapped Controls
-
-Related to the "Missing controls" issue above, if the parent control is scaled to match the current monitor's DPI, and the control's anchor calculations happen out of sync with this scaling, controls may overlap:
-
-![OverlappedControls](../images/AnchorLayoutKnownIssue_OverlappedControl.png)
-
-
-## Proposed solution
-
- The proposal is that we calculate anchors for a control only if the following conditions are met:
-
-- The control is parented.
-- The control's parent's layout is resumed.
-
- The initial anchor calculations would now happen whenever parent's layout is resumed, or when control is parented/resized and parent's layout is not suspended. The anchors will be recalculated whenever there are changes in geometry (`Size`, `Location`, etc.) or hierarchy (`ParentChanged`).
-
-### Anchor calculations
-
-The following image illustrates anchors calculation with respect to a control's parent's display rectangle. The "orange" rectangle is the parent's display rectangle, and the "blue" rectangle is the anchored control's (button) bounds.
-- `Left` arrow indicates the X coordinate of the button location with respect to the parent's display rectangle.
-- `Top` arrow indicates the Y coordinate of the button location with respect to the parent's display rectangle.
-- `Right` arrow indicates the distance from right edge of the parent's rectangle where button is placed.
-- `Right` arrow indicates the distance from the bottom edge of the parent's rectangle where the button is placed.
-
-    ![AnchorCalculations](../images/AnchorCalculations.png)
-
-
-In the above image the boundary marked in "orange" is a container hosting the control (boundary marked with "blue"). The control can define its anchor property to explicitly tell the layout engine how its bounds change relative to its parent's bounds.
-
-For example:
-```CS
-this.button14.Anchor = (System.Windows.Forms.AnchorStyles.Bottom
- | System.Windows.Forms.AnchorStyles.Left
- | System.Windows.Forms.AnchorStyles.Top
- | System.Windows.Forms.AnchorStyles.Right );
-```
-When the control's `Anchor` property is set, the anchors (that is, left, top, right, bottom values) are computed and stored in an internal struct `AnchorInfo`. The only time the anchor values can be negative is when the control is placed/position outside/overlapped with the hosting control's bounds.
-
-The following code snippet demonstrates anchor calculations:
-
-```CS
-private static void ComputeAnchorInfo(IArrangedElement element)
-{
-    AnchorInfo? anchorInfo = GetAnchorInfo(element);
-    if (anchorInfo is null)
-    {
-        anchorInfo = new();
-        SetAnchorInfo(element, anchorInfo);
-    }
-    Rectangle displayRect = element.Container.DisplayRectangle;
-    Rectangle elementBounds = GetCachedBounds(element);
-    int x = elementBounds.X;
-    int y = elementBounds.Y;
-    anchorInfo.Left = x;
-    anchorInfo.Top = y;
-    anchorInfo.Right = displayRect.Width - (x + elementBounds.Width);
-    anchorInfo.Bottom = displayRect.Height - (y + elementBounds.Height);
-}
-```
-
-## Risk mitigation
-
-The layout engine, in general, is quite complex, and any changes in it carry a very high risk. In order to reduce the risks and to provide backward compatibility, the new anchor calculations are put behind a feature switch `System.Windows.Forms.AnchorLayoutV2`. The switch is disabled by default for Windows Forms applications.
-
-Developers need to opt-in to get this new feature by setting the switch value to `true` in the [runtimeconfig.json](https://learn.microsoft.com/dotnet/core/runtime-config/#runtimeconfigjson).
-Snippet for runtimeconfig.template.json:
-```JSON
-{
-  "configProperties": {
-    "System.Windows.Forms.AnchorLayoutV2": true
-  }
-}
-```
-
-
-
diff --git a/docs/designer-accessibility.md b/docs/designer-accessibility.md
deleted file mode 100644
index d2b8778ddf2..00000000000
--- a/docs/designer-accessibility.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# Working around accessibility issues in the Windows Forms Out of Process Designer
-
-The introduction of Windows Forms (WinForms) to .NET Core 3.1 and beyond is enabling developers to migrate their  applications from .NET Framework to the more modern .NET versions. In order to support the designing of these applications within Visual Studio the team was required to create an entirely new Out of Process (OOP) Designer, which is currently still in a preview state. For more information on the technical reasons for this change, and the current status of the designer, see [our recent blog post](https://devblogs.microsoft.com/dotnet/state-of-the-windows-forms-designer-for-net-applications/).
-
-There are several features that still need to be implemented in the OOP designer, foremost of which is supporting the use of Assistive Technologies such as NVDA, Narrator, and Jaws while using the OOP designer. As much as the team wanted to fully support accessibility right out of the gate with this new designer, technical reasons prevented getting an early start on this feature, and resulted in unfortunate user experiences and deadlocks under assistive technology tooling in certain scenarios.
-
-While the team is rebuilding the experience under the new model, it is straightforward to work around the current accessibility issues by using the classic .NET Framework in-process designer and building output assemblies in both .NET and .NET Framework 4.7.2 (or 4.8). In order to multi-target and use the .NET Framework designer use the following steps:
-
-1.  Create your .NET WinForms 3.1 (C\# only), 5 or 6 app (both VB and C\#).
-
-2.  Before the designer by opening a Form or a UserControl, edit the *.csproj*
-    file.
-
-3.  In that file you will find the following entry, telling the compiler what
-    .NET version to build against:
-
-```<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net6.0-windows</TargetFramework>
-    <Nullable>enable</Nullable>
-    <UseWindowsForms>true</UseWindowsForms>
-    <ImplicitUsings>enable</ImplicitUsings>
-  </PropertyGroup>
-</Project>
-```
-4.  Change the `<TargetFramework>net6.0-windows</TargetFramework>` to the following: `<TargetFrameworks>net472;net6.0-windows</TargetFrameworks>`
-
-**Note:** it is important to use **net472** (or net48 if you want to target against .NET Framework 4.8) **first** in the  list of targeted frameworks. This tells Visual Studio to load the in-process .NET Framework rather than the .NET OOP WinForms designer.
-
-Once you’ve completed the above steps, you can build your application and interact with the forms directly as you have always done. When you build binaries, they will be built targeting both .NET 6 and .NET Framework 4.7.2. 
-
-:warning: There are limitations around only using the features and types available in both .NET Framework 4.7.2 and .NET 6. If you want to use .NET 6 features, you will need to use C\# preprocessor directives.
-
-We will be communicating out as soon as full accessibility support is available in the WinForms .NET OOP designer so that you can remove the need to multi-target. In the meantime, this workaround should allow you to build your .NET Windows Forms  applications with the respective accessibility features supported at design time.
-
-Happy Coding!
diff --git a/docs/designer/designer-high-dpi-mode.md b/docs/designer/designer-high-dpi-mode.md
deleted file mode 100644
index 1fd8266cff5..00000000000
--- a/docs/designer/designer-high-dpi-mode.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Designer HighDpi mode
-Visual Studio 2022 and beyond by default launch in PerMonitor DpiAwareness mode but it also supports SystemAware and Unaware DpiAwareness modes when users launch it with [custom settings](https://docs.microsoft.com/visualstudio/designers/disable-dpi-awareness?view=vs-2022). The WinForms designer does not fully support PerMonitor DpiAwareness mode yet and by default launches in SystemAware mode.
-
-In .NET 6, as part of unifying the information sharing between WinForms designer and WinForms runtime, we added [support](https://aka.ms/applicationconfiguration) for specifying the application dpi mode as a build time property on the project and share it for both designtime and at runtime.
-
-## Issues
- The Winforms designer, when operating in SystemAware/PermonitorV2 mode, serializes layout metrics into the source file based on the Dpi setting of the current display device on which it is being rendered. This may lead to two kinds of problems.
-
- 1. WinForms applications developed on a machine with DPI settings different from the machine where they are executed may encounter layout inconsistencies. 
- 
- 2. Within a team of multiple developers collaborating on the same project, this situation can lead to unintentional modifications in the serialized source code, even if they are unrelated to the intended changes. As a consequence, it introduces additional overhead in the code review and merging process.
-
-The following example demonstrates an undesired modification in the serialized WinForms source code.
-
-![Unwanted Serialization changes](../images/Serialization.png)
-
-
-Up until now, developers have been advised to adhere to the instructions given [here](https://go.microsoft.com/fwlink/?linkid=875609) and restart Visual Studio in DpiUnAware mode to resolve these problems. Nevertheless, this process requires individual developers to do it every time they work on the project, adding inconvenience. Additionally, the entire Visual Studio IDE would be launched as DPI Unaware resulting in a blurry IDE experience.
-
-## Solution
-
-In Visual Studio 2022 Version 17.8, we are introducing a new [configuration]((https://aka.ms/applicationconfiguration)) option called `ForceDesignerDpiUnaware`, distinct from `ApplicationHighDpiMode`. This option enables developers to enforce DpiUnAware mode for all WinForms designers in the project, regardless of the `ApplicationHighDpiMode`, which continues to take effect during runtime. The rest of the Visual Studio environment remains in PerMonitor mode and renders crisply.
-
-
-```CS
-
- <Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows</TargetFramework>
-    <Nullable>enable</Nullable>
-    <UseWindowsForms>true</UseWindowsForms>
-    <ImplicitUsings>enable</ImplicitUsings>
-	<ApplicationHighDpiMode>SystemAware</ApplicationHighDpiMode>
-    <ForceDesignerDpiUnaware>true</ForceDesignerDpiUnaware>
-  </PropertyGroup>
-```
-
diff --git a/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-C#-comparison.png b/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-C#-comparison.png
deleted file mode 100644
index 8350c22fd1d..00000000000
Binary files a/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-C#-comparison.png and /dev/null differ
diff --git a/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-VB-comparison.png b/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-VB-comparison.png
deleted file mode 100644
index 3008da0acda..00000000000
Binary files a/docs/designer/modernization-of-code-behind-in-OOP-designer/images/Form1-Designer-VB-comparison.png and /dev/null differ
diff --git a/docs/designer/modernization-of-code-behind-in-OOP-designer/modernization-of-code-behind-in-oop-designer.md b/docs/designer/modernization-of-code-behind-in-OOP-designer/modernization-of-code-behind-in-oop-designer.md
deleted file mode 100644
index 8fe91b18459..00000000000
--- a/docs/designer/modernization-of-code-behind-in-OOP-designer/modernization-of-code-behind-in-oop-designer.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# Modernization of code-behind in WinForms OOP designer
-
-## Background
-
-The WinForms designer saves visual representations of user controls or forms on the design surface to code-behind file (`Form1.Designer.cs` or `Form1.Designer.vb`). Control instances that developer sees on the design surface are represented as a CodeDOM tree (see [Using the CodeDOM](https://learn.microsoft.com/dotnet/framework/reflection-and-codedom/using-the-codedom)), that tree is saved to the generated code-behind file in the `InitializeComponent` method. We call this feature design time serialization.
-
-Previously COM-based [CodeModel interface](https://learn.microsoft.com/dotnet/api/envdte.codemodel?view=visualstudiosdk-2022) was used to write code into the editor's buffer as well as to generate CodeDOM tree from the source code when designer was loading. This COM object was accessible from the main thread only, which prevented parallelization in source code processing. Also, being more than 20 years old, it did not support some of the newer language features, for example the `nameof()` expression.
-
-## What's different
-
-Starting with [Visual Studio 2022 v17.5 Preview 3](https://visualstudio.microsoft.com/vs/preview/), the WinForms out-of-process designer uses [Roslyn](https://github.com/dotnet/roslyn) for design time serialization.
-
-In Preview 3, designer serializes more modern code into `InitializeComponent`. We have worked hard to ensure that you can take projects between this version of Visual Studio and earlier versions. Someday in the future, we may build on the improvements in our serialization to enable performance enhancements and use newer language features. These potential future investments may break the backwards compatibility with earlier VS versions - but we will be sure to inform our developers well ahead of such changes so that you can prepare.
-
-## Why change it
-
-* The use of Roslyn unblocks multithreaded serialization and deserialization to solve performance delays in designer load and unload scenarios.
-* Code-behind generation now respects `.editorconfig` settings and thus matches code style in the source files.
-* If implicit usings feature is enabled in project properties, global namespaces are not repeated in type names.
-* Further modernization of code-behind is unblocked.
-* Newly generated code will work with modern Roslyn analyzers.
-
-## How the new code looks like
-
-While `InitializeComponent` method is meant for the designer use only, and manual modifications to this method are not supported, developers might see some unexpected changes in `Form1.Designer.cs` and `Form1.designer.vb` files when comparing versions in the source control tools. This is a one-time code churn. Once the designer file is regenerated in v17.5 Preview 3 or newer and saved, designer will generate code only for controls modified in the design surface.
-
-For example, `InitializeComponent` method for a form with a button will be modified like this on the first save:
-
-![Comparison of Form1.Designer.cs as generated by Visual Studio 2022 v17.4 or earlier against the same file generated by v17.5 Preview 3](./images/Form1-Designer-C%23-comparison.png)
-
-Code generated by VisualStudio v17.4 or earlier:
-
-```cs
-private void InitializeComponent()
-{
-    this.button1 = new System.Windows.Forms.Button();
-    this.SuspendLayout();
-    // 
-    // button1
-    // 
-    this.button1.Location = new System.Drawing.Point(58, 60);
-    this.button1.Name = "button1";
-    this.button1.Size = new System.Drawing.Size(136, 69);
-    this.button1.TabIndex = 0;
-    this.button1.Text = "button1";
-    this.button1.UseVisualStyleBackColor = true;
-    // 
-    // Form1
-    // 
-    this.AutoScaleDimensions = new System.Drawing.SizeF(10F, 25F);
-    this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-    this.ClientSize = new System.Drawing.Size(270, 208);
-    this.Controls.Add(this.button1);
-    this.Name = "Form1";
-    this.Text = "Form1";
-    this.ResumeLayout(false);
-
-}
-```
-
-Code generated by VisualStudio v17.5 Preview 3, or newer:
-
-```cs
-private void InitializeComponent()
-{
-    button1 = new Button();
-    SuspendLayout();
-    // 
-    // button1
-    // 
-    button1.Location = new Point(58, 60);
-    button1.Name = "button1";
-    button1.Size = new Size(136, 69);
-    button1.TabIndex = 0;
-    button1.Text = "button1";
-    button1.UseVisualStyleBackColor = true;
-    // 
-    // Form1
-    // 
-    AutoScaleDimensions = new SizeF(10F, 25F);
-    AutoScaleMode = AutoScaleMode.Font;
-    ClientSize = new Size(270, 208);
-    Controls.Add(button1);
-    Name = "Form1";
-    Text = "Form1";
-    ResumeLayout(false);
-}
-```
-
-### Support for code style settings
-
-The above code was generated for default C# code style settings, thus `this` access qualifier was removed in the Preview 3 version.
-
-To preserve legacy code generation style in `InitializeComponent` method, set style preferences to legacy values in [`.editorconfig` file](https://learn.microsoft.com/visualstudio/ide/create-portable-custom-editor-options).
-
-```ini
-[*.designer.cs]
-
-# this. preferences
-dotnet_style_qualification_for_event = true
-dotnet_style_qualification_for_field = true
-dotnet_style_qualification_for_method = true
-dotnet_style_qualification_for_property = true
-
-[*.vb]
-
-# Me. preferences
-dotnet_style_qualification_for_event = true
-dotnet_style_qualification_for_field = true
-dotnet_style_qualification_for_method = true
-dotnet_style_qualification_for_property = true
-```
-
-### Support for implicit usings property
-
-Namespace names were removed from the type names in Preview 3 version. They are not needed for type resolution because design time serialization looks up the [implicit usings](https://learn.microsoft.com/dotnet/core/tutorials/top-level-templates#implicit-using-directives) property, available in C# starting with .NET 6 for C#, from the project file:
-
-```xml
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net8.0-windows</TargetFramework>
-    <Nullable>enable</Nullable>
-    <UseWindowsForms>true</UseWindowsForms>
-    <ImplicitUsings>enable</ImplicitUsings>
-  </PropertyGroup>
-
-</Project>
-```
-
-When implicit usings property is disabled in the C# project file, namespace names are generated.
-
-### Similar changes are present in Visual Basic
-
-![Comparison of Form1.Designer.vb as generated by Visual Studio 2022 v17.4 or earlier against the same file generated by v17.5 Preview 3](./images/Form1-Designer-VB-comparison.png)
-
-Code generated by VisualStudio v17.4 or earlier:
-
-```vb
-<System.Diagnostics.DebuggerStepThrough()>
-Private Sub InitializeComponent()
-    Me.Button1 = New System.Windows.Forms.Button()
-    Me.SuspendLayout()
-    '
-    'Button1
-    '
-    Me.Button1.Location = New System.Drawing.Point(58, 60)
-    Me.Button1.Name = "Button1"
-    Me.Button1.Size = New System.Drawing.Size(136, 69)
-    Me.Button1.TabIndex = 0
-    Me.Button1.Text = "Button1"
-    Me.Button1.UseVisualStyleBackColor = True
-    '
-    'Form1
-    '
-    Me.AutoScaleDimensions = New System.Drawing.SizeF(10.0!, 25.0!)
-    Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
-    Me.ClientSize = New System.Drawing.Size(270, 208)
-    Me.Controls.Add(Me.Button1)
-    Me.Name = "Form1"
-    Me.Text = "Form1"
-    Me.ResumeLayout(False)
-
-End Sub
-```
-
-Code generated by VisualStudio v17.5 Preview 3, or newer:
-
-```vb
-<System.Diagnostics.DebuggerStepThrough()>
-Private Sub InitializeComponent()
-    Button1 = New Button()
-    SuspendLayout()
-    ' 
-    ' Button1
-    ' 
-    Button1.Location = New Point(58, 60)
-    Button1.Name = "Button1"
-    Button1.Size = New Size(136, 69)
-    Button1.TabIndex = 0
-    Button1.Text = "Button1"
-    Button1.UseVisualStyleBackColor = True
-    ' 
-    ' Form1
-    ' 
-    AutoScaleDimensions = New SizeF(10.0F, 25.0F)
-    AutoScaleMode = AutoScaleMode.Font
-    ClientSize = New Size(270, 208)
-    Controls.Add(Button1)
-    Name = "Form1"
-    Text = "Form1"
-    ResumeLayout(False)
-End Sub
-```
-
-## Summary
-
-New code-behind in WinForm apps looks differently because it follows code style settings defined for the project. Under the covers, the design time serialization was redesigned in order to move from `EnvDTE.CodeModel` to `Roslyn`. We are planning to build upon this foundation in the future Visual Studio releases. Code-behind generated by the older releases will load into v17.5 Preview 3 or later releases and will work as expected. Code-behind generated by v17.5 Preview 3 can be loaded in the previous releases of the Visual Studio, but we are considering generating modern code that might not be supported by the previous versions of deserializer.
diff --git a/docs/designer/net-inproc-designer.md b/docs/designer/net-inproc-designer.md
deleted file mode 100644
index 0b6e9d0cfa1..00000000000
--- a/docs/designer/net-inproc-designer.md
+++ /dev/null
@@ -1,142 +0,0 @@
-# How to use Windows Forms .NET Framework designer for .NET applications
-
-The OOP designer is a port of the original .NET Framework Windows Forms designer that was run inside the Visual Studio's process. And whilst the team is aiming for parity there are still functional gaps between the original designer and the new OOP designer. With that it is possible that you may find yourself in a situtation where the OOP designer is not working as expected, and you'd want to use the .NET Framework designer to carry you on.
-
-This guide will walk you through the steps that enable a substantial use of the .NET Framework designer to design Windows Forms .NET applications. Please note, that due to the changes in the default font and new APIs in Windows Forms .NET, the .NET Framework designer won't be able to provide 100% parity.
-
-## 1. Create Windows Forms .NET app
-
-Create a new Windows Forms application targeting .NET from Visual Studio or your favorite command line interface.
-
-### Create in Visual Studio
-
-`VS2022`:
-
-1. _File > Add > New Project... > Windows Forms App (.NET Core)_, choose C# or Visual Basic
-2. Specify project name, e.g. `SimpleWinForms`
-
-
-
-### Create from command line
-
-Open your favorite console, create a new folder for your application:
-
-```cmd
-md SimpleWinForms
-cd SimpleWinForms
-dotnet new winforms -n SimpleWinForms
-dotnet new sln
-dotnet sln add SimpleWinForms
-```
-
-:point_up: **TIP:** You can have the folder name different from the project's name. Use the option `-n` (or `-name`) for that when using `dotnet new`.
-
-:point_up: **TIP:** For Visual Basic projects use the option `-lang vb` when using `dotnet new`.
-
-After creating the project, you can run the application:
-```cmd
-dotnet run --project SimpleWinForms\SimpleWinForms.csproj
-```
-
-
-## 2. Enable .NET Framework designer support
-
-There are few options available to help you to design UI for your .NET Core project.
-
-
-### Option 1: multi-target your app
-
-1. Open `SimpleWinForms.sln`
-
-2. Open the `SimpleWinForms` project file by double clicking on it in Solution Explorer. Change the ``TargetFramework`` property from:
-
-    ```diff
-    -    <TargetFramework>net6.0-windows</TargetFramework>
-    +    <TargetFrameworks>net472;net6.0-windows</TargetFrameworks>
-    ```
-
-3. Add for any and every form file you have in this ``ItemGroup``:
-
-    ```xml
-     <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
-       <Compile Update="Form1.cs">
-         <SubType>Form</SubType>
-       </Compile>
-       <Compile Update="Form1.Designer.cs">
-         <DependentUpon>Form1.cs</DependentUpon>
-       </Compile>
-     </ItemGroup>
-    ```
-
-    After doing these steps this is what you should end up with:
-
-    ![edit-project-file][edit-project-file]
-
-
-### Option 2: Shadow .NET Frameowk project
-
-1. Open `SimpleWinForms.sln`
-
-2. Add a new **Windows Forms App (.NET Framework)** project (VS2017: _Visual C# > Windows Desktop_ / VS2019+: _C# : Windows : Desktop_) to the solution (_File > Add > New Project..._)
-
-    ![add-netfx-project][add-netfx-project]
-
-3. Name the new .NET Framework project as the .NET project, but add ".Designer" to it (e.g. `SimpleWinForms.Designer`)
-
-4. Go to the .NET Framework project properties and set the default namespace to the .NET project's namespace
-
-    ![edit-namespace][edit-namespace]
-
-5. Delete the existing Form files in both projects
-
-6. Add a new Windows Form in the .NET Framework project's context menu _Add > Windows Form..._
-
-    ![add-new-form][add-new-form]
-
-7. In the section list, click on *Windows Forms*, and chose *Windows Form* from the installed templates
-
-    ![add-new-form-dialog][add-new-form-dialog]
-
-8. Give the name and click `[Add]`.
-
-   :exclamation: **IMPORTANT**: You need to trigger a form change event for the Designer to create a `resx` file. You can do it by resizing the form for a couple of pixels or changing the form's `Text` property. Don't forget to save.
-
-9. Now we move the form to the .NET project.<br />
-In the Solution Explorer click on the form and press <kbd>CTRL</kbd>+<kbd>X</kbd> to cut it; and then paste it in to the .NET project (<kbd>CTRL</kbd>+<kbd>V</kbd>). Check that the main form file, the .designer file and the resource file for the form are all present.
-
-10. Then we link the form back into the .NET Framework project back.<br />
-Remember: We can only use the .NET Framework designer, but we want to have only one set of files. So the form files, of course, belong to the .NET project but we want to edit them in the context of the .NET Framework project (thus using the .NET Framework designer).
-
-    * To do this open the context menu on the .NET Framework project in the Solution Explorer, and pick _Add > Existing Item_
-
-    * In the File Open Dialog, navigate to the .NET project, select the *Form.cs*, *Form.Designer.cs* and *Form.resx* files and choose *Add as Link* option.
-
-    ![add-as-link][add-as-link]
-
-11. Compile the solution to see if the file references were set up correctly
-
-1. As the last but important step, we need to re-nest the linked form files.<br/>
-If you installed the [File Nesting Visual Studio Extension][file-nesting-extension] then that is done easily: Select both the *Form.Designer.cs* and *Form.resx* file, and from the context menu click _File Nesting > Nest Items_. In the dialog, pick the main form file (Form.cs), and click OK.
-
-Now, whenever you need to use the Designer on one of the .NET Form or UserControl files, simply open the linked files in the .NET Framework project with the Windows Forms Designer.
-
-
-### More information
-
-If you are porting an existing .NET Framework application to .NET you may wish to read the following blog posts:
-* [Porting desktop apps to .NET](https://devblogs.microsoft.com/dotnet/porting-desktop-apps-to-net-core/)
-* [.NET Upgrade Assistant](https://devblogs.microsoft.com/dotnet/introducing-the-net-upgrade-assistant-preview/)
-* [Using the Windows Forms designer for .NET projects](https://devblogs.microsoft.com/dotnet/how-to-port-desktop-applications-to-net-core-3-0/#user-content-using-the-winforms-designer-for-net-core-projects)
-
-[comment]: <> (URI Links)
-
-[file-nesting-extension]: https://marketplace.visualstudio.com/items?itemName=MadsKristensen.FileNesting
-
-[comment]: <> (Images)
-
-[add-netfx-project]: ../images/add-netfx-project.png
-[edit-namespace]: ../images/edit-namespace.png
-[add-new-form]: ../images/add-new-form.png
-[add-new-form-dialog]: ../images/add-new-form-dialog.png
-[add-as-link]: ../images/add-as-link.png
-[edit-project-file]: ../images/edit-project-file.png
diff --git a/docs/designer/readme.md b/docs/designer/readme.md
deleted file mode 100644
index c3304536cb3..00000000000
--- a/docs/designer/readme.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Windows Forms Out-Of-Process Designer
-
-The Windows Forms out-of-process designer is currently available as a preview Visual Studio feature in [Visual Studio 2019 or later](https://visualstudio.microsoft.com/vs/preview/). It can be enabled in **Tools -> Options -> Environment -> Preview Features** dialog by checking the **Use the preview Windows Forms out-of-process designer for .NET apps** checkbox.
- Releases of .NET Windows Forms Designer are tied to Visual Studio Preview releases, so update to the latest Visual Studio Preview version to get the newest designer features.
-
-:heavy_exclamation_mark: The latest designer feature shipped in `Visual Studio 2022 v17.5 Preview 3` is [Modernization of code-behind generation](./modernization-of-code-behind-in-OOP-designer/modernization-of-code-behind-in-oop-designer.md).
-
-For the latest news on the designer please refer to [the series of blogs](https://devblogs.microsoft.com/search?query=winforms&blog=%2Fdotnet%2F):
-
-* [Custom Controls for WinForms' Out-Of-Process Designer](https://devblogs.microsoft.com/dotnet/custom-controls-for-winforms-out-of-process-designer/)
-* [Visual Basic WinForms Apps in .NET 5 and Visual Studio 16.8](https://devblogs.microsoft.com/dotnet/visual-basic-winforms-apps-in-net-5-and-visual-studio-16-8/)
-* [Databinding with the OOP Windows Forms Designer](https://devblogs.microsoft.com/dotnet/databinding-with-the-oop-windows-forms-designer/)
-* [State of the Windows Forms Designer for .NET Applications as of 01/13/2022](https://devblogs.microsoft.com/dotnet/state-of-the-windows-forms-designer-for-net-applications/)
-
-### WinForms out of process designer SDK
-
-For more information about creating custom control libraries, including sample code and templates refer to the [WinForms Designer Extensibility Repo](https://github.com/microsoft/winforms-designer-extensibility/). Details about how to use the WinForms Designer Extensibility SDK and structure a control library nuget package can be found there as well. Download the Extensibility SDK from [NuGet](https://www.nuget.org/packages/Microsoft.WinForms.Designer.SDK).
-
-## Table of Content
-
-* [How to use .NET Framework designer for .NET applications](net-inproc-designer.md)
-* [How to troubleshoot the out-of-process designer](troubleshooting.md)
diff --git a/docs/designer/troubleshooting.md b/docs/designer/troubleshooting.md
deleted file mode 100644
index 48a0b833413..00000000000
--- a/docs/designer/troubleshooting.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# How to troubleshoot the Windows Forms Out-Of-Process designer
-
-Whilst the Windows Forms Out-Of-Process Designer (or the OOP designer) is by far and large is a black box to the users, it is still possible to find out more information on its state.
-
-## Logging 
-
-Once the OOP designer is started, its log is available in the Visual Studio Output window:
-
-![image](https://user-images.githubusercontent.com/4403806/154604523-081f6197-d597-4416-9877-72fb61d12b8a.png)
-
-The default verbosity is set to  _Warnings_, which includes Warnings and Errors (prior to VS 2022 17.2 was _None_, i.e. logging disabled). You can change the logging level to terser or more verbose under **Tools -> Options -> Windows Forms Designer -> General -> Logging Level**, e.g.:
-
-![image](https://user-images.githubusercontent.com/4403806/154607481-44fa404a-894e-4656-95b8-efdeced2ace0.png)
-
-## "Designer never loads" problems and possible ways to resolve those
-
-### Connection Timeouts
-
-When the OOP designer starts it launches the designer server process (aka DesignToolsServer.exe). If the server process fails to launch or connect to the Visual Studio, you may see the following error:
-
-```
-[02:59:20.7198643] [MyProj]: Timed out waiting for the design tools server process launch to complete.
-[02:59:20.7668637] Microsoft.DotNet.DesignTools.Client.ServerException: Timed out waiting for the design tools server process launch to complete.
-```
-
-The default connection timeout is set to _2 minutes_ (prior to VS 2022 17.1p5 was _10 seconds_). VS 2022 17.2 introduces the ability to increase the connection timeout, if necessary. You can change it under **Tools -> Options -> Windows Forms Designer -> General -> Connection timeout**, e.g.:
-
-![image](https://user-images.githubusercontent.com/4403806/154607521-8665597b-b2e5-448b-adcb-a2c147570501.png)
-
-There can be various reasons why the server process may be taking longer than the allocated time. For example, some users have reported to have solutions with a large number of projects. The designer performs a shadow copying of the necessary files and folders before it can render your form or control, and if you have a slow hard drive, or the project files are located on a network drive, it can have a significant effect on how fast files are copied to the shadow cache folder.
-
-### Antivirus is blocking the server process executables
-
-Some customers have reported that the connection timeouts were caused by configurations of their antivirus services. In such cases it is recommended to add exclusion rules for `devevn.exe` and `DesignToolsServer.exe`, and this can unblock these executables and can increase the I/O of the shadow cache. For example, to add an exception to the Windows Defender so that it is not slowed down by the system call hooks Defender uses to provide real-time protection can be done with the following PowerShell command:
-
-```powershell
-Add-MpPreference -ExclusionProcess 'devenv.exe'
-Add-MpPreference -ExclusionProcess 'DesignToolsServer.exe'
-```
-
-### `Switch.System.IO.UseLegacyPathHandling` override is enabled
-
-The designer server process uses [long paths](https://docs.microsoft.com/windows/win32/fileio/maximum-file-path-limitation) and requires [path normalizations](https://docs.microsoft.com/dotnet/framework/migration-guide/mitigation-path-normalization), the behaviours that can be altered by `Switch.System.IO.UseLegacyPathHandling` appcontext switch. The default value of the switch is `false`, and if the value is set to `true` either in devenv.exe.config (which is located somewhere like C:\Program Files\Microsoft Visual Studio\2022\Common7\IDE) or in the [registry](https://docs.microsoft.com/dotnet/api/system.appcontext?view=net-6.0#appcontext-for-library-consumers) it will prevent the designer from loading with `Argument Exception: Illegal characters in path` error.
diff --git a/docs/developer-guide.md b/docs/developer-guide.md
deleted file mode 100644
index 17cc4a88de9..00000000000
--- a/docs/developer-guide.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# Developer Guide
-
-The following document describes the setup and workflow that is recommended for working on the Windows Forms project. It assumes that you have read the [Contributing Guide](../CONTRIBUTING.md).
-
-The [Issue Guide](issue-guide.md) describes our approach to using GitHub issues.
-
-## Machine Setup
-
-Windows Forms requires the following workloads and components be selected when installing Visual Studio 2022 (17.0.0):
-
-* Required Workloads:
-  * .NET Desktop Development
-  * Desktop development with C++
-* [Required Individual Components][required-individual-components]:
-  * Windows 10 SDK
-  * C++/CLI support
-
-
-  :warning: CMake 3.21.0 or later is required. Install CMake from the [official website][cmake-download] or via [Chocolatey][chocolatey]:
-  ```
-  choco install cmake --installargs 'ADD_CMAKE_TO_PATH=System'
-  ```
-  
-* Useful Visual Studio extensions:  
-  * [Editor guidelines](https://marketplace.visualstudio.com/items?itemName=PaulHarrington.EditorGuidelines), see https://github.com/dotnet/winforms/pull/4836 for more information
-  * [VS Color Output](https://marketplace.visualstudio.com/items?itemName=MikeWard-AnnArbor.VSColorOutput64)
-  * [Productivity Power Tools](https://marketplace.visualstudio.com/items?itemName=VisualStudioPlatformTeam.ProductivityPowerPack2022)
-
-## Workflow
-
-We use the following workflow for building as well as testing features and fixes.
-
-You first need to [fork][fork] then [clone][clone] this Windows Forms repository. This is a one-time task.
-
-1. [Build](building.md) the repository.
-2. [Debug](debugging.md) the change, as needed.
-3. [Test](testing.md) the change, to validate quality.
-
-## More Information
-
-* [How to write good docs for .NET](https://review.docs.microsoft.com/help/contribute-ref/how-to-write-net-docs?branch=main)
-* [.NET Docs and Guidelines][net-runtime-instructions]
-* ["help wanted" issues][help wanted]
-
-[comment]: <> (URI Links)
-
-[net-runtime-instructions]: https://github.com/dotnet/runtime/tree/master/docs
-[fork]: https://guides.github.com/activities/forking/
-[clone]: https://www.git-scm.com/docs/git-clone
-[help wanted]: https://github.com/dotnet/winforms/issues?q=is%3Aopen+is%3Aissue+label%3A"help%20wanted"
-[chocolatey]: https://chocolatey.org/
-[cmake-download]: https://cmake.org/download/
-[required-individual-components]: ../WinForms.vsconfig
diff --git a/docs/getting-started.md b/docs/getting-started.md
deleted file mode 100644
index 5fd9c988107..00000000000
--- a/docs/getting-started.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# Getting started with Windows Forms for .NET
-
-This document describes the experience of using Windows Forms on .NET. The [Developer Guide](developer-guide.md) describes how to develop features and fixes for Windows Forms.
-
-## Installation
-
-Choose one of these options:
-
-1. [.NET 7.0 SDK (recommended)][.net-7.0-sdk]
-
-1. [.NET 8.0 daily build (latest changes, could be less stable)][.net-daily]
-
-## Creating new applications
-
-You can create a new WinForms application with `dotnet new` command, using the following commands:
-
-```cmd
-dotnet new winforms -o MyWinFormsApp
-cd MyWinFormsApp
-dotnet run
-```
-
-## Designing Forms
-
-You can try the Windows Forms Core Designer Visual Studio extension, see [Windows Forms Designer documentation](designer-releases/readme.md). As an alternative, you can use [this workaround](winforms-designer.md).
-
-## Samples
-
-Check out the [.NET Windows Forms samples][.net-samples] for both basic and advanced scenarios. Additionally, there is a collection of [Windows Forms sample applications on Microsoft Learn][MSDN-winforms-samples].
-
-## Porting existing applications
-
-To port your existing Windows Forms application from .NET Framework to .NET 6 or .NET 7, refer to our [porting guidelines](porting-guidelines.md).
-
-[comment]: <> (URI Links)
-
-[.net-7.0-sdk]: https://dotnet.microsoft.com/download/dotnet/7.0
-[.net-daily]: https://github.com/dotnet/installer/blob/master/README.md#installers-and-binaries
-[.net-samples]: https://github.com/dotnet/samples/tree/main/windowsforms
-[MSDN-winforms-samples]: https://learn.microsoft.com/samples/browse/?terms=windows%20forms
diff --git a/docs/images/AnchorCalculations.png b/docs/images/AnchorCalculations.png
deleted file mode 100644
index 045f35cc0fe..00000000000
Binary files a/docs/images/AnchorCalculations.png and /dev/null differ
diff --git a/docs/images/AnchorLayoutKnownIssue_MissingControl.png b/docs/images/AnchorLayoutKnownIssue_MissingControl.png
deleted file mode 100644
index d05148183be..00000000000
Binary files a/docs/images/AnchorLayoutKnownIssue_MissingControl.png and /dev/null differ
diff --git a/docs/images/AnchorLayoutKnownIssue_OverlappedControl.png b/docs/images/AnchorLayoutKnownIssue_OverlappedControl.png
deleted file mode 100644
index 5f000e99f22..00000000000
Binary files a/docs/images/AnchorLayoutKnownIssue_OverlappedControl.png and /dev/null differ
diff --git a/docs/images/RuntimeOptionsDemo.gif b/docs/images/RuntimeOptionsDemo.gif
deleted file mode 100644
index 4a8c951d789..00000000000
Binary files a/docs/images/RuntimeOptionsDemo.gif and /dev/null differ
diff --git a/docs/images/Serialization.png b/docs/images/Serialization.png
deleted file mode 100644
index cfc6dfbb5cd..00000000000
Binary files a/docs/images/Serialization.png and /dev/null differ
diff --git a/docs/images/accessibleobject-getpropertyvalue-implementation.png b/docs/images/accessibleobject-getpropertyvalue-implementation.png
deleted file mode 100644
index a5241c640f4..00000000000
Binary files a/docs/images/accessibleobject-getpropertyvalue-implementation.png and /dev/null differ
diff --git a/docs/images/accessibleobject-role-implementation.png b/docs/images/accessibleobject-role-implementation.png
deleted file mode 100644
index 4e990f4b23d..00000000000
Binary files a/docs/images/accessibleobject-role-implementation.png and /dev/null differ
diff --git a/docs/images/add-as-link.png b/docs/images/add-as-link.png
deleted file mode 100644
index 273467c8aa8..00000000000
Binary files a/docs/images/add-as-link.png and /dev/null differ
diff --git a/docs/images/add-netfx-project.png b/docs/images/add-netfx-project.png
deleted file mode 100644
index 16cfb0ded1c..00000000000
Binary files a/docs/images/add-netfx-project.png and /dev/null differ
diff --git a/docs/images/add-new-form-dialog.png b/docs/images/add-new-form-dialog.png
deleted file mode 100644
index 3097558d4b2..00000000000
Binary files a/docs/images/add-new-form-dialog.png and /dev/null differ
diff --git a/docs/images/add-new-form.png b/docs/images/add-new-form.png
deleted file mode 100644
index 0ad61cab4cb..00000000000
Binary files a/docs/images/add-new-form.png and /dev/null differ
diff --git a/docs/images/edit-namespace.png b/docs/images/edit-namespace.png
deleted file mode 100644
index 0f711c2468b..00000000000
Binary files a/docs/images/edit-namespace.png and /dev/null differ
diff --git a/docs/images/edit-project-file.png b/docs/images/edit-project-file.png
deleted file mode 100644
index f8ed8fa1d98..00000000000
Binary files a/docs/images/edit-project-file.png and /dev/null differ
diff --git a/docs/images/inspect-accessibility-properties.png b/docs/images/inspect-accessibility-properties.png
deleted file mode 100644
index 044e98598b6..00000000000
Binary files a/docs/images/inspect-accessibility-properties.png and /dev/null differ
diff --git a/docs/images/listview-disabledstyles-inspect-details-view-tree.png b/docs/images/listview-disabledstyles-inspect-details-view-tree.png
deleted file mode 100644
index 3eee33ed84f..00000000000
Binary files a/docs/images/listview-disabledstyles-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-disabledstyles-inspect-largeicon-view-tree.png b/docs/images/listview-disabledstyles-inspect-largeicon-view-tree.png
deleted file mode 100644
index 121407d7c82..00000000000
Binary files a/docs/images/listview-disabledstyles-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-disabledstyles-inspect-list-view-tree.png b/docs/images/listview-disabledstyles-inspect-list-view-tree.png
deleted file mode 100644
index 46a7fa1179d..00000000000
Binary files a/docs/images/listview-disabledstyles-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-disabledstyles-inspect-smallicon-view-tree.png b/docs/images/listview-disabledstyles-inspect-smallicon-view-tree.png
deleted file mode 100644
index 0b77a98ca1e..00000000000
Binary files a/docs/images/listview-disabledstyles-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-disabledstyles-inspect-tile-view-tree.png b/docs/images/listview-disabledstyles-inspect-tile-view-tree.png
deleted file mode 100644
index 9464c7841c3..00000000000
Binary files a/docs/images/listview-disabledstyles-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-inspect-details-view-tree.png b/docs/images/listview-inspect-details-view-tree.png
deleted file mode 100644
index be04669913f..00000000000
Binary files a/docs/images/listview-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-inspect-largeicon-view-tree.png b/docs/images/listview-inspect-largeicon-view-tree.png
deleted file mode 100644
index bcddd7edbd8..00000000000
Binary files a/docs/images/listview-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-inspect-list-view-tree.png b/docs/images/listview-inspect-list-view-tree.png
deleted file mode 100644
index 5b72d1053f6..00000000000
Binary files a/docs/images/listview-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-inspect-smallicon-view-tree.png b/docs/images/listview-inspect-smallicon-view-tree.png
deleted file mode 100644
index 11bbe975cad..00000000000
Binary files a/docs/images/listview-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-inspect-tile-view-tree.png b/docs/images/listview-inspect-tile-view-tree.png
deleted file mode 100644
index 5f2c3ae60ef..00000000000
Binary files a/docs/images/listview-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-showgroupdisabled-inspect-details-view-tree.png b/docs/images/listview-showgroupdisabled-inspect-details-view-tree.png
deleted file mode 100644
index 45fa6d51261..00000000000
Binary files a/docs/images/listview-showgroupdisabled-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-showgroupdisabled-inspect-largeicon-view-tree.png b/docs/images/listview-showgroupdisabled-inspect-largeicon-view-tree.png
deleted file mode 100644
index 9fbb8067bcf..00000000000
Binary files a/docs/images/listview-showgroupdisabled-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-showgroupdisabled-inspect-list-view-tree.png b/docs/images/listview-showgroupdisabled-inspect-list-view-tree.png
deleted file mode 100644
index 1af9c8e64e8..00000000000
Binary files a/docs/images/listview-showgroupdisabled-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-showgroupdisabled-inspect-smallicon-view-tree.png b/docs/images/listview-showgroupdisabled-inspect-smallicon-view-tree.png
deleted file mode 100644
index ce75f72e289..00000000000
Binary files a/docs/images/listview-showgroupdisabled-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-showgroupdisabled-inspect-tile-view-tree.png b/docs/images/listview-showgroupdisabled-inspect-tile-view-tree.png
deleted file mode 100644
index f1cb002e778..00000000000
Binary files a/docs/images/listview-showgroupdisabled-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-virtualmode-inspect-details-view-tree.png b/docs/images/listview-virtualmode-inspect-details-view-tree.png
deleted file mode 100644
index 8d8a31fb784..00000000000
Binary files a/docs/images/listview-virtualmode-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-virtualmode-inspect-largeicon-view-tree.png b/docs/images/listview-virtualmode-inspect-largeicon-view-tree.png
deleted file mode 100644
index 34d9f72bbcf..00000000000
Binary files a/docs/images/listview-virtualmode-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-virtualmode-inspect-list-view-tree.png b/docs/images/listview-virtualmode-inspect-list-view-tree.png
deleted file mode 100644
index 11c8c008e98..00000000000
Binary files a/docs/images/listview-virtualmode-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-virtualmode-inspect-smallicon-view-tree.png b/docs/images/listview-virtualmode-inspect-smallicon-view-tree.png
deleted file mode 100644
index cb5479b9738..00000000000
Binary files a/docs/images/listview-virtualmode-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withgroup-inspect-details-view-tree.png b/docs/images/listview-withgroup-inspect-details-view-tree.png
deleted file mode 100644
index 40cfd5a8fa6..00000000000
Binary files a/docs/images/listview-withgroup-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withgroup-inspect-largeicon-view-tree.png b/docs/images/listview-withgroup-inspect-largeicon-view-tree.png
deleted file mode 100644
index c972260088a..00000000000
Binary files a/docs/images/listview-withgroup-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withgroup-inspect-list-view-tree.png b/docs/images/listview-withgroup-inspect-list-view-tree.png
deleted file mode 100644
index 2a121373c24..00000000000
Binary files a/docs/images/listview-withgroup-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withgroup-inspect-smallicon-view-tree.png b/docs/images/listview-withgroup-inspect-smallicon-view-tree.png
deleted file mode 100644
index 2496ea168e3..00000000000
Binary files a/docs/images/listview-withgroup-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withgroup-inspect-tile-view-tree.png b/docs/images/listview-withgroup-inspect-tile-view-tree.png
deleted file mode 100644
index 01cd4a9d870..00000000000
Binary files a/docs/images/listview-withgroup-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withoutgroup-inspect-details-view-tree.png b/docs/images/listview-withoutgroup-inspect-details-view-tree.png
deleted file mode 100644
index 8acee9cd7eb..00000000000
Binary files a/docs/images/listview-withoutgroup-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withoutgroup-inspect-largeicon-view-tree.png b/docs/images/listview-withoutgroup-inspect-largeicon-view-tree.png
deleted file mode 100644
index 0930c8f2b14..00000000000
Binary files a/docs/images/listview-withoutgroup-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withoutgroup-inspect-list-view-tree.png b/docs/images/listview-withoutgroup-inspect-list-view-tree.png
deleted file mode 100644
index 59c95ce176f..00000000000
Binary files a/docs/images/listview-withoutgroup-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withoutgroup-inspect-smallicon-view-tree.png b/docs/images/listview-withoutgroup-inspect-smallicon-view-tree.png
deleted file mode 100644
index 19399a8e997..00000000000
Binary files a/docs/images/listview-withoutgroup-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listview-withoutgroup-inspect-tile-view-tree.png b/docs/images/listview-withoutgroup-inspect-tile-view-tree.png
deleted file mode 100644
index 0d6cffd12b7..00000000000
Binary files a/docs/images/listview-withoutgroup-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-disabledvisualstyles-inspect-tile-view-tree.png b/docs/images/listviewsubitem-disabledvisualstyles-inspect-tile-view-tree.png
deleted file mode 100644
index 654e370bed1..00000000000
Binary files a/docs/images/listviewsubitem-disabledvisualstyles-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-inspect-details-view-tree.png b/docs/images/listviewsubitem-inspect-details-view-tree.png
deleted file mode 100644
index e071d578122..00000000000
Binary files a/docs/images/listviewsubitem-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-inspect-largeicon-view-tree.png b/docs/images/listviewsubitem-inspect-largeicon-view-tree.png
deleted file mode 100644
index cd6f82e192a..00000000000
Binary files a/docs/images/listviewsubitem-inspect-largeicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-inspect-list-view-tree.png b/docs/images/listviewsubitem-inspect-list-view-tree.png
deleted file mode 100644
index d9b47c5718c..00000000000
Binary files a/docs/images/listviewsubitem-inspect-list-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-inspect-smallicon-view-tree.png b/docs/images/listviewsubitem-inspect-smallicon-view-tree.png
deleted file mode 100644
index 268611c9f73..00000000000
Binary files a/docs/images/listviewsubitem-inspect-smallicon-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-inspect-tile-view-tree.png b/docs/images/listviewsubitem-inspect-tile-view-tree.png
deleted file mode 100644
index fc4823974d6..00000000000
Binary files a/docs/images/listviewsubitem-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-smallsize-inspect-tile-view-tree.png b/docs/images/listviewsubitem-smallsize-inspect-tile-view-tree.png
deleted file mode 100644
index 6937a27b169..00000000000
Binary files a/docs/images/listviewsubitem-smallsize-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-threeitems-inspect-tile-view-tree.png b/docs/images/listviewsubitem-threeitems-inspect-tile-view-tree.png
deleted file mode 100644
index 378b9218f34..00000000000
Binary files a/docs/images/listviewsubitem-threeitems-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-twocolumns-inspect-details-view-tree.png b/docs/images/listviewsubitem-twocolumns-inspect-details-view-tree.png
deleted file mode 100644
index 2293cec2e86..00000000000
Binary files a/docs/images/listviewsubitem-twocolumns-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-twocolumns-inspect-tile-view-tree.png b/docs/images/listviewsubitem-twocolumns-inspect-tile-view-tree.png
deleted file mode 100644
index f9742c7377c..00000000000
Binary files a/docs/images/listviewsubitem-twocolumns-inspect-tile-view-tree.png and /dev/null differ
diff --git a/docs/images/listviewsubitem-twosubitems-inspect-details-view-tree.png b/docs/images/listviewsubitem-twosubitems-inspect-details-view-tree.png
deleted file mode 100644
index 3123cbfc417..00000000000
Binary files a/docs/images/listviewsubitem-twosubitems-inspect-details-view-tree.png and /dev/null differ
diff --git a/docs/images/monthcalendar-calendar-accessible-from-point.png b/docs/images/monthcalendar-calendar-accessible-from-point.png
deleted file mode 100644
index 351b7317f18..00000000000
Binary files a/docs/images/monthcalendar-calendar-accessible-from-point.png and /dev/null differ
diff --git a/docs/images/monthcalendar-control-accessible-from-point.png b/docs/images/monthcalendar-control-accessible-from-point.png
deleted file mode 100644
index 3ee32846fc9..00000000000
Binary files a/docs/images/monthcalendar-control-accessible-from-point.png and /dev/null differ
diff --git a/docs/images/monthcalendar-first-weeknumber-accessible-from-point.png b/docs/images/monthcalendar-first-weeknumber-accessible-from-point.png
deleted file mode 100644
index 71b3c1c5901..00000000000
Binary files a/docs/images/monthcalendar-first-weeknumber-accessible-from-point.png and /dev/null differ
diff --git a/docs/images/monthcalendar-gray-dates-accessible-from-point.png b/docs/images/monthcalendar-gray-dates-accessible-from-point.png
deleted file mode 100644
index f8c8989a28c..00000000000
Binary files a/docs/images/monthcalendar-gray-dates-accessible-from-point.png and /dev/null differ
diff --git a/docs/images/monthcalendar-inspect-century-view-tree.png b/docs/images/monthcalendar-inspect-century-view-tree.png
deleted file mode 100644
index 52848915eeb..00000000000
Binary files a/docs/images/monthcalendar-inspect-century-view-tree.png and /dev/null differ
diff --git a/docs/images/monthcalendar-inspect-decade-view-tree.png b/docs/images/monthcalendar-inspect-decade-view-tree.png
deleted file mode 100644
index 1c127bbc6c7..00000000000
Binary files a/docs/images/monthcalendar-inspect-decade-view-tree.png and /dev/null differ
diff --git a/docs/images/monthcalendar-inspect-month-view-tree.png b/docs/images/monthcalendar-inspect-month-view-tree.png
deleted file mode 100644
index df77fca6dc4..00000000000
Binary files a/docs/images/monthcalendar-inspect-month-view-tree.png and /dev/null differ
diff --git a/docs/images/monthcalendar-inspect-year-view-tree.png b/docs/images/monthcalendar-inspect-year-view-tree.png
deleted file mode 100644
index cb5ef726d42..00000000000
Binary files a/docs/images/monthcalendar-inspect-year-view-tree.png and /dev/null differ
diff --git a/docs/images/monthcalendar-last-weeknumbers-accessible-from-point.png b/docs/images/monthcalendar-last-weeknumbers-accessible-from-point.png
deleted file mode 100644
index a198818096a..00000000000
Binary files a/docs/images/monthcalendar-last-weeknumbers-accessible-from-point.png and /dev/null differ
diff --git a/docs/images/templates-check-installed.png b/docs/images/templates-check-installed.png
deleted file mode 100644
index b10c4c9487a..00000000000
Binary files a/docs/images/templates-check-installed.png and /dev/null differ
diff --git a/docs/infra/automation.md b/docs/infra/automation.md
deleted file mode 100644
index 23af9d9e4a2..00000000000
--- a/docs/infra/automation.md
+++ /dev/null
@@ -1,7 +0,0 @@
-## Automation
-
-### Fabric Bot
-
-This repository uses Fabric Bot to automate issue and pull request management. All automation rules are defined in the [`.github/fabricbot.json`](.github/fabricbot.json) file.
-
-At this moment Fabric Bot has not published a JSON schema for the configuration format. In order to make changes to the configuration file, you should use the [`Fabric Bot portal`](https://portal.fabricbot.ms/bot/) to load the configuration file via the "Import Configuration" option and make changes using the editor. You need to be signed out from the portal in order for this option to appear.
diff --git a/docs/issue-guide.md b/docs/issue-guide.md
deleted file mode 100644
index 7a8c8211aef..00000000000
--- a/docs/issue-guide.md
+++ /dev/null
@@ -1,124 +0,0 @@
-# Issue Guide
-
-This page outlines how WinForms team thinks about and handles issues.
-For us, issues on GitHub represent actionable work that should be done at some future point.
-It may be as simple as a small product or test bug or as large as the work tracking the design of a new feature.
-
-We will keep issues open even if the WinForms team internally has no plans to address them in an upcoming release, as long as we believe they are in line with our direction.
-
-# How to file issues
-
-You can help us streamline our response time to your feedback and ideas by filing high-quality reports.
-
-### Known Issues
-
-If you encounter an issue using the latest .NET 5.0 SDK, please:
-
-1. Explore [this repositories issues][winforms-issues], and then
-1. [Open a new issue][new-issue] if there is none.
-
-### Bug reports
-
-In general, try to be specific. Get straight to the main point. Leave additional details, options, and alternatives to the end (hint: separate them visually). Don't write long bug reports, unless you have to.
-
-* Include a minimal reproduction (repro) in your bug if at all possible (chop off dependencies, remove as much code as possible). If it is not possible, say why.<br />
-  :warning: Note: Yes, it may take some time to minimize a repro from your larger app - but that is exactly what we would do in most cases anyway. Issues with clear, concise reproduction guidelines are easier for us to investigate; such issues will have higher chance of being addressed quickly.
-* Include call-stacks, symptom descriptions, and differences between actual and expected behaviors.
-
-### Feature and API suggestions
-
-Assume that the reader has minimal knowledge and experience with writing apps/libraries that would benefit from the feature, so try and write to that audience. Provide clear description of your suggestion, and explain scenarios in which it would be helpful and why (motivation).
-
-Prepare code examples that showcase the need and general usefulness of the proposal. Specifically:
-* Code that shows the surface area of the API.
-* Code that shows real world scenarios, and how they would otherwise be handled.
-* Details showing the usage/consumption of the proposed new package, and alternatives (e.g. not having this be a separate package).
-
-:warning: All new API or changes to public API must undergo an API review process. Learn more what the [API review process][api-review-process] entails.
-
-Here are few example of a good API proposal: 
-* https://github.com/dotnet/runtime/issues/15725
-* https://github.com/dotnet/runtime/issues/15725
-
-
-## Assignee
-
-We assign each issue to assignee, when the assignee is ready to pick up the work and start working on it.
-If the issue is not assigned to anyone and you want to pick it up, please say so - we will assign the issue to you.
-If the issue is already assigned to someone, please coordinate with the assignee before you start working on it.
-
-## Up-votes on issues
-
-Up-votes on first post of each issue are useful hint for our prioritization.
-We can [sort issues by number of up-votes][up-votes], and we will review the top list on a regular basis.
-
-## Triage rules
-
-Guidance for triage of issues for Windows Forms team members:
-
-1. Issue has no **Assignee**, unless someone is working on the issue at the moment.
-1. Use **help wanted** as much as possible, ideally with a quick note about next steps / complexity of the issue.
-1. Set milestone to **Future**, unless you can 95%-commit you can fund the issue in specific milestone.
-1. Each issue has exactly one "*issue type*" label (**bug**, **enhancement**, **api-suggestion**, **test-bug**, **test-enhancement**, **question**, **documentation**, etc.).
-1. Don't be afraid to say no, or close issues — just explain why and be polite.
-1. Don't be afraid to be wrong - just be flexible when new information appears.
-
-Feel free to use other labels if it helps your triage efforts (for example, **needs-more-info**, **design-discussion**, **tenet-compatibility**, etc.).
-
-### Motivation for triage rules
-
-1. Issue has no **Assignee**, unless someone is working on the issue at the moment.
-    * Motivation: Observation is that contributors are less likely to grab assigned issues, no matter what the repository rules say.
-
-1. Use **help wanted** as much as possible, ideally with a quick note about next steps / complexity of the issue.<br />
-    NB: Per [https://up-for-grabs.net][up-for-grabs-net], such issues should be no longer than few nights' worth of work. They should be actionable (that is, no mysterious CI failures that can't be tested in the open).
-
-1. Set milestone to **Future**, unless you can 95%-commit you can fund the issue in specific milestone.
-    * Motivation: Helps communicate desire/timeline to community. Can spark further priority/impact discussion.
-
-1. Each issue has exactly one "*issue type*" label (**bug**, **enhancement**, **api-suggestion**, **test-bug**, **test-enhancement**, **question**, **documentation**, etc.).
-    * Don't be afraid to be wrong when deciding 'bug' vs. 'test-bug' (flip a coin if you must). The most useful values for tracking are 'api-&#42;' vs. 'enhancement', 'question', and 'documentation'.
-
-
-# Pull-Request (PR) Guide
-
-Each PR has to have reviewer approval from at least one Windows Forms team member who is not author of the change, before it can be merged.
-
-
-1. Please don't set any labels on PRs. 
-    * exceptions:
-      * **NO-MERGE** may be supplied by the WinForms team in order to indicate that the PR should be halted; a reason should be given in the comments
-      * **waiting-on-testing** may be supplied by the WinForms team to inform the PR author(s) that their PR is being delayed due to internal, manual testing; this action does not require action by the author(s).
-    * Motivation: All the important info (*issue type* label, API approval label, etc.) is already captured on the associated issue.
-
-1. Push PRs forward, don't let them go stale (response every 5+ days, ideally no PRs older than 2 weeks).
-
-1. Close stuck or long-term blocked PRs (for example, due to missing API approval, etc.) and reopen them once they are unstuck.
-    * **Motivation: Keep only active PRs. WIP (work-in-progress) PRs should be rare and should not become stale (2+ weeks old). If a PR is stale and there is not immediate path forward, consider closing the PR until it is unblocked/unstuck.
-
-1. Link PR to related issue via [auto-closing][auto-closing] (add "Fixes #12345" into your PR description).
-
-[comment]: <> (URI Links)
-
-
-[winforms-issues]: https://github.com/dotnet/winforms/issues
-[new-issue]: https://github.com/dotnet/winforms/issues/new/choose
-[api-review-process]: https://github.com/dotnet/runtime/blob/master/docs/project/api-review-process.md
-[labels]: https://github.com/dotnet/winforms/labels
-[api-suggestion]: https://github.com/dotnet/winforms/labels/api-suggestion
-[API Review process]: https://github.com/dotnet/corefx/blob/master/Documentation/project-docs/api-review-process.md
-[bug]: https://github.com/dotnet/winforms/labels/bug
-[enhancement]: https://github.com/dotnet/winforms/labels/enhancement
-[test-bug]: https://github.com/dotnet/winforms/labels/test-bug
-[test-enhancement]: https://github.com/dotnet/winforms/labels/test-enhancement
-[question]: https://github.com/dotnet/winforms/labels/question
-[documentation]: https://github.com/dotnet/winforms/labels/documentation
-[label-description]: https://github.com/dotnet/winforms/labels
-[help wanted]: https://github.com/dotnet/winforms/labels/help%20wanted
-[needs-more-info]: https://github.com/dotnet/winforms/labels/needs-more-info
-[tenet-compatibility]: https://github.com/dotnet/winforms/labels/tenet-compatibility
-[milestones]: https://github.com/dotnet/winforms/milestones
-[up-votes]: #upvotes-on-issues
-[sort issues by number of up-votes]: https://github.com/dotnet/winforms/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc
-[up-for-grabs-net]: https://up-for-grabs.net
-[auto-closing]: https://help.github.com/articles/closing-issues-via-commit-messages/
\ No newline at end of file
diff --git a/docs/list-of-diagnostics.md b/docs/list-of-diagnostics.md
deleted file mode 100644
index a64334ad409..00000000000
--- a/docs/list-of-diagnostics.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# List of Diagnostics Produced by Windows Forms .NET APIs
-
-## Obsoletions
-
-Per https://github.com/dotnet/designs/blob/main/accepted/2020/better-obsoletion/better-obsoletion.md and similar to https://github.com/dotnet/runtime/blob/main/docs/project/list-of-diagnostics.md, we now have a strategy for marking existing APIs as `[Obsolete]`. This takes advantage of the new diagnostic id and URL template mechanisms introduced to `ObsoleteAttribute` in .NET 5.
-
-The diagnostic id values reserved for obsoletions are `WFDEV001` through `WFDEV999`. When obsoleting an API, claim the next three-digit identifier in the `WFDEV###` sequence and add it to the list below. The URL template for all obsoletions is `https://aka.ms/winforms-warnings/{0}`. The `{0}` placeholder is replaced by the compiler with the `WFDEV###` identifier.
-
-The acceptance criteria for adding an obsoletion includes:
-
-* Add the obsoletion to the table below, claiming the next diagnostic id
-    * Ensure the description is meaningful within the context of this table, and without requiring the context of the calling code
-* Add new constants to `src\Common\src\Obsoletions.cs`, following the existing conventions
-    * A `...Message` const using the same description added to the table below
-    * A `...DiagnosticId` const for the `WFDEV###` id
-* Annotate `src` files by referring to the constants defined from `Obsoletions.cs`
-    * Specify the `UrlFormat = Obsoletions.SharedUrlFormat`
-    * Example: `[Obsolete(Obsoletions.DomainUpDownAccessibleObjectMessage, DiagnosticId = Obsoletions.DomainUpDownAccessibleObjectDiagnosticId, UrlFormat = Obsoletions.SharedUrlFormat)]`
-    * If the `Obsoletions` type is not available in the project, link it into the project
-        * `<Compile Include="..\..\Common\src\Obsoletions.cs" Link="Common\Obsoletions.cs" />`
-* Apply the `:book: documentation: breaking` label to the PR that introduces the obsoletion
-* Follow up with the breaking change process to communicate and document the breaking change
-    * In the breaking-change issue filed in [dotnet/docs](https://github.com/dotnet/docs), specifically mention that this breaking change is an obsoletion with a `WFDEV` diagnostic id
-    * The documentation team will produce a PR that adds the obsoletion to the [WFDEV warnings](https://learn.microsoft.com/dotnet/desktop/winforms/wfdev-diagnostics/obsoletions-overview) page
-    * That PR will also add a new URL specific to this diagnostic ID; e.g. [WFDEV001](https://learn.microsoft.com/dotnet/desktop/winforms/wfdev-diagnostics/wfdev001)
-    * Connect with `@gewarren` or `@BillWagner` with any questions
-* Register the `WFDEV###` URL in `aka.ms`
-    * The vanity name will be `winforms-warnings/WFDEV###`
-    * Ensure the link's group owner matches the group owner of `winforms-warnings/WFDEV001`
-    * Connect with `@igveliko` or `@gewarren` with any questions
-
-### Obsoletion Diagnostics (`WFDEV001` - `WFDEV999`)
-
-| Diagnostic ID     | Description |
-| :---------------- | :---------- |
-|  __`WFDEV001`__ | Casting to/from IntPtr is unsafe, use `WParamInternal`. |
-|  __`WFDEV001`__ | Casting to/from IntPtr is unsafe, use `LParamInternal`. |
-|  __`WFDEV001`__ | Casting to/from IntPtr is unsafe, use `ResultInternal`. |
-|  __`WFDEV002`__ | `DomainUpDown.DomainUpDownAccessibleObject` is no longer used to provide accessible support for `DomainUpDown` controls. Use `ControlAccessibleObject` instead. |
-|  __`WFDEV003`__ | `DomainUpDown.DomainItemAccessibleObject` is no longer used to provide accessible support for `DomainUpDown` items. |
-
-
-## Analyzer Warnings
-
-The diagnostic id values reserved for Windows Forms .NET analyzer warnings are WF??001 through WF??999. 
-
-### Analyzer Diagnostics (`WF??001` - `WF??999`)
-
-| Diagnostic ID     | Description |
-| :---------------- | :---------- |
-|  __`WFAC001`__ | Unsupported project type. |
-|  __`WFAC002`__ | Unsupported property value. |
-|  __`WFAC010`__ | Unsupported high DPI configuration. |
-
diff --git a/docs/porting-guidelines.md b/docs/porting-guidelines.md
deleted file mode 100644
index 4f9c793613a..00000000000
--- a/docs/porting-guidelines.md
+++ /dev/null
@@ -1,149 +0,0 @@
-# Port existing applications to .NET 5.0
-
->We suggest doing migration in a separate branch or, if you're not using version
->control, creating a copy of your project so you have a clean state to go back
->to if necessary.
-
-The migration process includes two steps: **preparing your project for porting** to
-.NET and **porting** itself.
-
-For additional information and assistance, we recommend checking out [this article on the dotnet blog][dotnet-blog-port-guide] as well as the [accompanying video tutorial][dotnet-blog-port-video].
-
-
-## Breaking changes
-
-Review the following resources that describe breaking changes between Windows Forms on .NET Framework and .NET:
-
-* The [Breaking changes in Windows Forms (.NET Framework to .NET Core)](https://docs.microsoft.com/dotnet/core/porting/winforms-breaking-changes) describes breaking changes you need to be aware of when migrating your applications from .NET Framework
-* The [Breaking changes in Windows Forms (.NET Core to .NET)](https://docs.microsoft.com/dotnet/core/compatibility/winforms) describes breaking changes you need to be aware of when migrating your applications from .NET Core 3.x versions to .NET 5.0 onwards.
-
-## Prepare your project for porting
-
-1. **Run [.NET Portability Analyzer][api-port]** first to determine if there are
-   any APIs your application depends on that are missing in .NET. If there
-   are, you have a few options.
-    * Remove not supported APIs or replace them with those, that are included in
-      .NET
-    * Separate your code into different projects: the one that contains only
-      .NET supported APIs and another with APIs not supported in .NET.
-      Migrate only the first project.
-
-1. **Start from a working solution**. Ensure the solution opens, builds, and runs without any issues.
-
-1. **Replace `packages.config` with `PackageReference`**. If your project uses
-   NuGet packages, you will need to add the same NuGet packages to the new .NET
-   project. .NET projects support only `PackageReference` for adding
-   NuGet packages. To move your NuGet references from `packages.config` to your
-   project file, right-click on `packages.config` -> **Migrate packages.config
-   to PackageReference...**.
-
-   You can learn more about this migration in our [docs][pkg-config].
-
-1. **Migrate to the SDK-style .csproj file**. The new SDK-style `.csproj` format is leaner and easier to read. To be able to simply copy-paste your references from the old project to the new one, you first need to migrate your old project file to SDK-style so both project are in the same format. You can either do it by hand or use a third-party tool [CsprojToVs2017][sdk-tool].
-
-   After using the tool you still might need to delete some reference by hand; for example:
-
-    ```xml
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Net.Http" />
-    ```
-
-   After you've migrated to the new SDK-style format, ensure your project builds and runs successfully.
-
-1. **Configure assembly file generation**. Most existing projects include an `AssemblyInfo.cs` file in the Properties folder. The new project style uses a different approach and generates the same assembly attributes as part of the build process. As a result, you might end up with two `AssemblyInfo.cs` files and your build will fail. There are two ways to resolve this problem. You can either:
-    * Disable `AssemblyInfo.cs` generation on build by setting the property:
-
-        ```xml
-        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-        ```
-    * Move the static values from `AssemblyInfo.cs` to properties in the new `.csproj` file.
-
-    Build and run to make sure you did not introduce any issues while preparing your project. Now it is time to port it.
-
-
-
-## Port your project
-
-### Automated porting
-
-1. Try porting your project using [`try-convert` tool](https://github.com/dotnet/try-convert), which we built to help migrations. <br />
-NB: The tool may not work for all possible projects, in that case please read on.
-
-### Manual porting
-
-1. **Add .NET Windows Forms project**. Add a new .NET 5.0 Windows Forms project to the solution.
-
-1. **Add `<ProjectReference>`**. Copy the `<ProjectReference>` elements from the `.csproj` file of the original project to the new project's `.csproj` file.<br />
-Note: The new project format does not use the `Name` and `ProjectGuid` elements, so you can safely delete those.
-
-1. **Restore/Build**. At this point, it's a good idea to restore/build to make sure all dependencies are properly configured.
-
-1. **Link files**. Link all files from your existing .NET Framework WinForms project to the .NET 5.0 WinForms project by adding following to the `.csproj` file.
-
-    ```xml
-    <ItemGroup>
-        <Compile Include="..\<Your .NET Framework Project Name>\**\*.cs" />
-        <EmbeddedResource Include="..\<Your .NET Framework Project Name>\**\*.resx" />
-    </ItemGroup>
-    ```
-
-1. **Align default namespace and assembly name**. Since you're linking to designer generated files (for example, `Resources.Designer.cs`) you generally want to make sure that the .NET version of your application uses the same namespace and the same assembly name. Copy the following settings from your .NET Framework project:
-
-    ```xml
-    <PropertyGroup>
-        <RootNamespace><!-- (Your default namespace) --></RootNamespace>
-        <AssemblyName><!-- (Your assembly name) --></AssemblyName>
-    </PropertyGroup>
-    ```
-
-1. **Run new project**. Set your new .NET project as StartUp Project and run it. Make sure everything works.
-
-1. **Copy or leave linked**. Now instead of linking the files, you can actually copy them from the old .NET Framework WinForms project to the new .NET 5.0 WinForms project. After that you can get rid of the old project.
-
-## Migration tips
-
-### Include the System.Windows.Forms.Datavisualization Pack
-
-If you wish to use types previously associated with the [Charting control in the .NET Framework][framework-charting], you should add a package reference to the [NuGet package of Data Visualization][nuget-dataviz] ported to .NET. For more information about Data Visualization and the Charting control in .NET, including a sample application demonstrating its use, see the [winforms-datavisualization repository][dataviz]
-
-### Include the Windows.Compatibility Pack
-
-Windows applications like Windows Forms and WPF often use APIs that aren't referenced by default in .NET. The reason is that .NET tries to reduce the risk that new applications accidentally depend on legacy technologies or on APIs that are Windows-only. However, when porting existing Windows applications, neither of these two aspects is a concern. To simplify your porting efforts, you can simply reference the [Windows Compatibility Pack][compat-pack], which will give
-you access to many more APIs.
-
-```cmd
-dotnet add package Microsoft.Windows.Compatibility
-```
-
-### Migrating WCF clients
-
-.NET has its own implementation of `System.ServiceModel` with some
-differences:
-
-* It is available as a set of NuGet packages (also included in the [Windows
-  Compatibility Pack][compat-pack]).
-* There are [unsupported features][wcf-supported] that you should review.
-* The binding and endpoint address must be specified in the service client constructor. Otherwise, if you reuse the `ServiceReference` created by Visual Studio, you may get the following error:
-
-```cs
-System.PlatformNotSupportedException: 'Configuration files are not supported.'
-```
-
-### Additional Types and Namespaces
-
-You can search for additional types which you may need in porting your apps to .NET on [APIs of DotNet][apisofnet]. For example, when you search for the type `System.AppDomain`, you will see that the type has been moved to `System.Runtime.Extensions` namespace starting in .NET 2.0.
-
-[comment]: <> (URI Links)
-
-[dotnet-blog-port-guide]: https://devblogs.microsoft.com/dotnet/how-to-port-desktop-applications-to-net-core-3-0/
-[dotnet-blog-port-video]: https://www.youtube.com/watch?v=upVQEUc_KwU
-[api-port]: https://blogs.msdn.microsoft.com/dotnet/2018/08/08/are-your-windows-forms-and-wpf-applications-ready-for-net-core-3-0/
-[pkg-config]: https://docs.microsoft.com/en-us/nuget/reference/migrate-packages-config-to-package-reference
-[sdk-tool]:https://github.com/hvanbakel/CsprojToVs2017
-[framework-charting]: https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.datavisualization.charting
-[nuget-dataviz]: https://www.nuget.org/packages/System.windows.forms.datavisualization
-[dataviz]: https://github.com/dotnet/winforms-datavisualization
-[compat-pack]: https://docs.microsoft.com/en-us/dotnet/core/porting/windows-compat-pack
-[wcf-supported]: https://github.com/dotnet/wcf/blob/master/release-notes/SupportedFeatures-v2.1.0.md
-[apisofnet]: https://apisof.net/
diff --git a/docs/release-activity.md b/docs/release-activity.md
deleted file mode 100644
index f21cc7240ad..00000000000
--- a/docs/release-activity.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Runtime release procedures
-
-## Milestone releases (dotnet/winforms + dotnet/windowsdesktop)
-
-1. Merge any outstanding PRs, if necessary
-2. Ensure the HEAD of the main branch builds successfully and all tests pass
-3. Publish any unpublished API - run [.\eng\ApiCompatibility\mark-shipped.cmd](https://github.com/dotnet/winforms/blob/main/eng/ApiCompatibility/mark-shipped.cmd)
-
-4. Commit and wait for a successful build
-
-5. (Milestone releases) Create "release/X.Y-qwe" branch (e.g. release/6.0-preview5) and push it into the main public trunk and the internal trunk.
-Wait for both build successfully.
-* Main public trunk: https://github.com/dotnet/winforms/
-* Internal trunk: <need url>
-6. Disable loc on "release/X.Y-qwe" branch (e.g.: https://github.com/dotnet/winforms/pull/6753)
-7. Switch back to the main branch
-8. Update the Service Fabric bot with the new release label in .\github\fabricbot.json. Refer to .\docs\infra\automation.md, if have questions.
-9. Update the branding (e.g.: https://github.com/dotnet/winforms/commit/719b2112778ffd1e7ded559ea2736b4011428117)
-10. Commit and wait for a successful build.
-
-11. Create new [milestone](https://github.com/dotnet/winforms/milestones) for the new release before updating following bot service.  
-
-12. Move work items to this new milestone if they were on previous milestone and close the previous milestone.
-
-13. Update necessary reports with the progress
-
-14. If you are responsible for [dotnet/windowsdesktop](https://github.com/dotnet/windowsdesktop) repo, make sure you change the branding there too.
-
-## Servicing releases (dotnet/winforms + dotnet/windowsdesktop)
-
-[NET Servicing - Overview (azure.com)](https://dev.azure.com/devdiv/DevDiv/_wiki/wikis/DevDiv.wiki/545/NET-Servicing)
-
-1. Merge internal servicing branch (i.e. internal/internal/release/*) into the public branch, if necessary.  
-
-2. Update the branding (e.g.: https://github.com/dotnet/winforms/commit/480bd703c5af93b9e23dc7435c6029d685be7097)
-3. Commit and wait for a successful build.
-
-4. Ensure the HEAD of the servicing branch builds successfully and all tests pass
-
-5. Update [dotnet/installer](https://github.com/dotnet/installer) with the released version (e.g.: https://github.com/dotnet/installer/commit/34ed90f436809631e254b9e15628cbcad7307629)
-
-6. Create a new [milestone](https://github.com/dotnet/winforms/milestones).
-
-7. Close the current milestone on the GitHub, ensuring all open issues/PRs are either closed or bumped to the following milestone
-
-8. Merge any outstanding PRs, if necessary
diff --git a/docs/roadmap.md b/docs/roadmap.md
deleted file mode 100644
index 4c5da68a7a9..00000000000
--- a/docs/roadmap.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# Windows Forms Roadmap
-
-This roadmap communicates priorities for evolving and extending the scope of Windows Forms. For general information regarding .NET plans, see [.NET roadmap](https://github.com/dotnet/core/blob/master/roadmap.md).
-
-* [Future](#future)
-* [Present](#present)
-
-This repository is a community effort and we welcome community feedback on our plans. The best way to give your feedback is to open an issue in this repo.
-We also invite contributions. The [help wanted issues](https://github.com/dotnet/winforms/issues?q=is%3Aopen+is%3Aissue+label%3A"help%20wanted") on GitHub are a good place to start.
-
-## Future
-
-Here is the list of improvements we are planning to work on in the future.
-
-### Accessibility improvements
-
-Including support for standard [WCAG2.1]( https://www.w3.org/TR/WCAG21/), such as enabling tooltips for controls on `Tab` ([#2726](https://github.com/dotnet/winforms/issues/2726)), etc.
-
-### High DPI improvements
-
-* Fix existing scaling bugs in Per Monitor DPI aware applications
-* Enable all controls to support Per Monitor V2 mode
-* Add a new "clean" way of calculating location/size information in PMA mode
-
-### Performance improvements
-
-Establish a base line and improve runtime and designer performance.
-
-### Testing infrastructure
-
-Add testing infrastructure and improve test coverage.
-
-## Some potential features
-
-We also are gathering feedback regarding what other features you'd like to see in WinForms. Please let us know if any of those or something else would be useful for your applications. You an create a feature request in this repo or vote for an existing one.
-
-### Add and improve wrappers for missing Win32 controls
-
-Such as Ribbon Control, Balloons, SearchBox, improvements around ListView, etc.
-
-### Add support for OS themes in WinForms applications
-
-Enable dark theme, etc.
-
-## Present
-
-### Windows Forms runtime
-
-**Under considerations**.<br/>A number of aspects are being considered including (but not limited to) layout engine and high DPI support, theming, new controls and components.
-
-### Windows Forms Designer
-
-We continue the work on the designer to to achieve the parity with the .NET Framework designer.
-This involves adding the remaining controls and features and improving stability and performance for the designer.
diff --git a/docs/runtime-configuration.md b/docs/runtime-configuration.md
deleted file mode 100644
index a578b6a7eac..00000000000
--- a/docs/runtime-configuration.md
+++ /dev/null
@@ -1,294 +0,0 @@
-# Support for application runtime configuration in Windows Forms applications
-
-## Overview
-
-.NET Windows Forms applications currently have limited [application
-configurations](https://aka.ms/applicationconfiguration) capabilities that are defined via MSBuils properties and are emitted into source code using source
-generators at compile time. This document outlines expansion of those application-wide configurations further to cover runtime config options for .NET Windows Forms applications.
-
-## .NET Framework runtime configuration
-
-.NET Framework Windows Forms applications use `app.config` to define runtime configurations and application-wide settings. The following are the various sections in the app.config that define the application's runtime behavior.
-
-### AppContext switches
-
-These settings are used to opt-in or opt-out of a particular feature from Windows Forms runtime. Refer to the [AppContext Switches](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/runtime/appcontextswitchoverrides-element) documentation for more information.
-
-```xml
-<configuration>
-  <runtime>
-    <AppContextSwitchOverrides value="Switch.System.Globalization.NoAsyncCurrentCulture=true" />
-  </runtime>
-</configuration>
-```
-### `System.Windows.Forms.ApplicationConfigurationSection` section
-
-This was introduced in .NET Framework 4.7, and it is primarily used by Windows Forms runtime to enable high DPI and other accessibility improvements. Please refer to the [ApplicationConfigurationSection](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/winforms/windows-forms-add-configuration-element) documentation for more information.
-
-```xml
-<configuration>
-  <System.Windows.Forms.ApplicationConfigurationSection>
-    <!-- content -->
-  </System.Windows.Forms.ApplicationConfigurationSection>
-</configuration>
-```
-
-### Application-wide and user-specific settings
-
-These are commonly defined via the Settings designer in Visual Studio, which serializes those into `app.config`. Refer to the [Application Settings](https://docs.microsoft.com/dotnet/desktop/winforms/advanced/using-application-settings-and-user-settings) documentation for more information.
-
-```xml
-<userSettings>
-  <WinFormsApp2.Properties.Settings>
-    <setting name="ButtonName" serializeAs="String">
-      <value>LocalButton</value>
-    </setting>
-  </WinFormsApp2.Properties.Settings>
-</userSettings>
-
-<applicationSettings>
-  <WinFormsApp2.Properties.Settings>
-    <setting name="BoxName" serializeAs="String">
-      <value>LocalBox</value>
-    </setting>
-  </WinFormsApp2.Properties.Settings>
-</applicationSettings>
-```
-
-
-## .NET 7+ runtime configuration
-
-`app.config` has limited support in .NET due to performance and reliability reasons. .NET runtime and other .NET teams use `runtimeconfig.json` to define .NET runtime configurations and `appsettings.json` to define application-level settings. In this proposal, we are leveraging `runtimeconfig.json` to define Windows Forms runtime configurations.
-
-While this proposal is focusing on providing an alternative solution for existing configuration sections `AppContextSwitchOverrides` and `System.Windows.Forms.ApplicationConfigurationSection` that are primarily used for specifying feature flags impacting Windows Forms runtime behavior, we will be looking into alternatives for `Application Settings` that doesn't require `app.config` in the future releases of .NET.
-
-
-### Goals:
-
-- A replacement for `AppContextSwitchOverrides` and `System.Windows.Forms.ApplicationConfigurationSection` of `app.config`.
-- Users should be able to update/modify Windows Forms applications runtime configurations without recompiling the application.
-- The existing applications should be able to seamlessly upgrade to the new configuration model when targeting .NET 7+ runtime.
-- The existing [application configuration MSBuild properties](https://aka.ms/applicationconfiguration) continue to work.
-
-### Out of scope:
-
-- App settings that are serialized by the Settings designer/editor page. Applications should continue to use the current model.
-- Dynamic/real-time (re-)loading of configuration values from `runtimeconfig.json`.
-- Unification of comple/runtime configurations into one place, e.g., `runtimeconfig.json`.
-
-
-### Design proposal
-
-Windows Forms switches will be added to **`runtimeConfig.template.json`** to the [`configProperties` section](https://docs.microsoft.com/dotnet/core/runtime-config) with the rest of the .NET switches. To avoid name conflics Windows Forms specific switches will be prefixed with `System.Windows.Forms`:
-
-```json
-{
-  "configProperties": {
-      "System.Globalization.UseNls": true,
-      "System.Net.DisableIPv6": true,
-      "System.GC.Concurrent": false,
-      "System.Threading.ThreadPool.MinThreads": 4,
-      "System.Threading.ThreadPool.MaxThreads": 25,
-      
-      // Windows Forms specific switches
-      "System.Windows.Forms.ScaleTopLevelFormMinMaxSizeForDpi": true,
-      "System.Windows.Forms.CustomEnumProperty": "EnumValue"
-    }
-}
-```
-
-
-#### Reading Windows Forms runtime configurations
-
-When a project is [built](https://docs.microsoft.com/dotnet/core/runtime-config/#runtimeconfigjson), an `[appname].runtimeconfig.json` file is generated in the output directory. If a `runtimeconfig.template.json` file exists in the same folder as the project file, any configuration options it contains are inserted into the `[appname].runtimeconfig.json` file.
-
-This proposal focuses primarily on enabling the runtime configurations for Windows Forms applications. A support for analyzers and source generators may be considered in the future .NET releases. We will revisit this implementation to improve user-experience further, as we make progress.
-
-For example, the content of `[appname].runtimeconfig.json` generated from above content:
-
-```json
-{
-  "runtimeOptions": {
-    "tfm": "net7.0",
-    "frameworks": [
-      {
-        "name": "Microsoft.NETCore.App",
-        "version": "7.0.0-preview.7.22375.6"
-      },
-      {
-        "name": "Microsoft.WindowsDesktop.App",
-        "version": "7.0.0-preview.7.22377.1"
-      }
-    ],
-    "configProperties": {
-      "System.Globalization.UseNls": true,
-      "System.Net.DisableIPv6": true,
-      "System.GC.Concurrent": false,
-      "System.Threading.ThreadPool.MinThreads": 4,
-      "System.Threading.ThreadPool.MaxThreads": 25,
-
-      "System.Windows.Forms.ScaleTopLevelFormMinMaxSizeForDpi": true,
-      "System.Windows.Forms.StringProperty": "string",
-      "System.Windows.Forms.CustomProperty": "CustomValue"
-    }
-  }
-}
-```
-
-The target framework information added to `[appname].runtimeconfig.json` file always match with the application target framework irrespective of runtime/SDK installed on the machine or runtime used ([roll-forward scenarios](https://docs.microsoft.com/dotnet/core/versions/selection#framework-dependent-apps-roll-forward)) by the Windows Forms application.
-
-#### .NET runtime support in reading `runtimeconfig.json`
-
-The Windows Forms runtime is leveraging the [support](https://github.com/dotnet/runtime/blob/5098d45cc1bf9649fab5df21f227da4b80daa084/src/native/corehost/runtime_config.cpp) provided by .NET runtime in reading `[appname].runtimeconfig.json` file, and thus get all plumbing required for various hosting and environment scenarios. The Windows Forms runtime adds the following wrapper on top of .NET runtime implementation to improve the performance by caching configuration options, and also by defining custom defaults values for the Windows Forms specific feature flags. This wrapper is very similar to the [.NET runtime's implementation](https://github.com/dotnet/runtime/blob/04dac7b0fede29d44f896c5fd793754f83974175/src/libraries/System.Private.CoreLib/src/System/AppContextConfigHelper.cs).
-
-The below example illustrates how to define `ScaleTopLevelFormMinMaxSizeForDpi` feature flag, opt-in by default, for an application targeting .NET 8 or later running on Windows 10:
-
-```cs
-internal static partial class LocalAppContextSwitches
-{
-    private const string ScaleTopLevelFormMinMaxSizeForDpiSwitchName = "System.Windows.Forms.ScaleTopLevelFormMinMaxSizeForDpi";
-
-    private static readonly FrameworkName? s_targetFrameworkName = GetTargetFrameworkName();
-    private static readonly bool s_isNetCoreApp = (s_targetFrameworkName?.Identifier) == ".NETCoreApp";
-
-    private static int s_scaleTopLevelFormMinMaxSize;
-
-    public static bool ScaleTopLevelFormMinMaxSizeForDpi
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        get => GetCachedSwitchValue(ScaleTopLevelFormMinMaxSizeForDpiSwitchName, ref s_scaleTopLevelFormMinMaxSize);
-    }
-
-    private static FrameworkName? GetTargetFrameworkName()
-    {
-        string? targetFrameworkName = AppContext.TargetFrameworkName;
-        return targetFrameworkName is null ? null : new FrameworkName(targetFrameworkName);
-    }
-
-    private static bool GetCachedSwitchValue(string switchName, ref int cachedSwitchValue)
-    {
-        // The cached switch value has 3 states: 0 - unknown, 1 - true, -1 - false
-        if (cachedSwitchValue < 0)
-            return false;
-        if (cachedSwitchValue > 0)
-            return true;
-
-        return GetSwitchValue(switchName, ref cachedSwitchValue);
-    }
-
-    private static bool GetSwitchValue(string switchName, ref int cachedSwitchValue)
-    {
-        bool hasSwitch = AppContext.TryGetSwitch(switchName, out bool isSwitchEnabled);
-        if (!hasSwitch)
-        {
-            isSwitchEnabled = GetSwitchDefaultValue(switchName);
-        }
-
-        // Is caching switches disabled?.
-        AppContext.TryGetSwitch("TestSwitch.LocalAppContext.DisableCaching", out bool disableCaching);
-        if (!disableCaching)
-        {
-            cachedSwitchValue = isSwitchEnabled ? 1 /*true*/ : -1 /*false*/;
-        }
-
-        return isSwitchEnabled;
-    }
-
-    // Provides default values for switches based on OS and Targetframework versions.
-    private static bool GetSwitchDefaultValue(string switchName)
-    {
-        if (!s_isNetCoreApp)
-        {
-            return false;
-        }
-
-        if (OsVersion.IsWindows10_1703OrGreater)
-        {
-            if (s_targetFrameworkName!.Version.CompareTo(new Version("8.0")) >= 0)
-            {
-                if (switchName == ScaleTopLevelFormMinMaxSizeForDpiSwitchName)
-                {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-}
-```
-
-
-The Windows Forms runtime then uses the static `LocalAppContextSwitches` class to access the runtime configurations. The below sample demonstrates the use of the feature switch `System.Windows.Forms.ScaleTopLevelFormMinMaxSizeForDpi` to scale min/max size of a container control:
-
-```cs
-internal void ScaleContainerForDpi(int deviceDpiNew, int deviceDpiOld, Rectangle suggestedRectangle)
-{
-    CommonProperties.xClearAllPreferredSizeCaches(this);
-    SuspendAllLayout(this);
-    try
-    {
-        if (LocalAppContextSwitches.ScaleTopLevelFormMinMaxSizeForDpi)
-        {
-            // The suggested rectangle comes from Windows, and it does not match with our calculations for scaling controls by AutoscaleFactor.
-            // Hence, we cannot use AutoscaleFactor here for scaling the control properties. See the below description for more details.
-            float xScaleFactor = (float)suggestedRectangle.Width / Width;
-            float yScaleFactor = (float)suggestedRectangle.Height / Height;
-            ScaleMinMaxSize(xScaleFactor, yScaleFactor, updateFormSize: false);
-        }
-
-        // If this container is a top-level window, we would receive WM_DPICHANGED message that
-        // has SuggestedRectangle for the control. We are forced to use this in such cases to
-        // make the control placed in right location with respect to the new monitor that triggered
-        // WM_DPICHANGED event. Failing to apply SuggestedRectangle will result in a circular WM_DPICHANGED
-        // events on the control.
-
-        // Note: SuggestedRectangle supplied  by WM_DPICHANGED event is DPI (not Font) scaled. if top-level window is
-        // Font scaled, we might see deviations in the expected bounds and may result in adding Scrollbars (horizontal/vertical)
-        User32.SetWindowPos(
-            new HandleRef(this, HandleInternal),
-            User32.HWND_TOP,
-            suggestedRectangle.X,
-            suggestedRectangle.Y,
-            suggestedRectangle.Width,
-            suggestedRectangle.Height,
-            User32.SWP.NOZORDER | User32.SWP.NOACTIVATE);
-
-        // Bounds are already scaled for the top-level window. We would need to skip scaling of
-        // this control further by the 'OnFontChanged' event.
-        _isScaledByDpiChangedEvent = true;
-
-        // Factor is used only to scale Font. After that AutoscaleFactor kicks in to scale controls.
-        var factor = ((float)deviceDpiNew) / deviceDpiOld;
-
-        // DpiFontscache is available only in PermonitorV2 mode applications.
-        if (!TryGetDpiFont(deviceDpiNew, out Font? fontForDpi))
-        {
-            Font currentFont = Font;
-            fontForDpi = currentFont.WithSize(currentFont.Size * factor);
-            AddToDpiFonts(deviceDpiNew, fontForDpi);
-        }
-
-        ScaledControlFont = fontForDpi;
-        if (IsFontSet())
-        {
-            SetScaledFont(fontForDpi);
-        }
-        else
-        {
-            using (new LayoutTransaction(ParentInternal, this, PropertyNames.Font))
-            {
-                OnFontChanged(EventArgs.Empty);
-            }
-        }
-    }
-    finally
-    {
-        // We want to perform layout for DPI-changed high DPI improvements - setting the second parameter to 'true'
-        ResumeAllLayout(this, true);
-        _isScaledByDpiChangedEvent = false;
-    }
-}
-```
-
-![OptinSwitch](images/RuntimeOptionsDemo.gif)
\ No newline at end of file
diff --git a/docs/serialization/register-custom-type-converter.md b/docs/serialization/register-custom-type-converter.md
deleted file mode 100644
index 47b4bb80c8b..00000000000
--- a/docs/serialization/register-custom-type-converter.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Manually Registering a TypeConverter to a Class
-A [type converter](https://learn.microsoft.com/dotnet/api/system.componentmodel.typeconverter) is usually bound to a class by adding the [`TypeConverterAttribute`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typeconverterattribute) to the class. When you cannot apply this attribute or want to override it you can programmatically assign a converter instead. This document outlines how to accomplish this.
-
-## Prerequisite
-Follow the steps to implement your own custom type converter listed [here](https://learn.microsoft.com/dotnet/api/system.componentmodel.typeconverter#notes-to-inheritors).
-
-## Registering Your TypeConverter
-
-### Background
-A [`TypeConverter`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typeconverter) for a given type is found via the `TypeDescriptor` static method [`GetConverter()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor.getconverter). To provide custom `TypeDescriptor` behavior you must create and register a custom type descriptor ([`ICustomTypeDescriptor`](https://learn.microsoft.com/dotnet/api/system.componentmodel.icustomtypedescriptor)) via a [`TypeDescriptionProvider`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptionprovider).
-
-### Implementing An ICustomTypeDescriptor
-Inherit from [`CustomTypeDescriptor`](https://learn.microsoft.com/dotnet/api/system.componentmodel.customtypedescriptor) to get default [`ICustomTypeDescriptor`](https://learn.microsoft.com/dotnet/api/system.componentmodel.icustomtypedescriptor) behavior and override [`GetConverter()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.customtypedescriptor.getconverter) to return your custom type converter.
-```c#
-private class CustomConverterDescriptor : CustomTypeDescriptor
-{
-    private TypeConverter _converter;
-
-    public CustomConverterDescriptor(ICustomTypeDescriptor parent, TypeConverter converter) : base(parent)
-        => _converter = converter;
-
-    public override TypeConverter GetConverter() => _converter;
-}
-```
-
-An `ICustomTypeDescriptor` is accessed through [`TypeDescriptionProvider.GetTypeDescriptor()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptionprovider.gettypedescriptor). This method needs to be overridden to provide your newly created `ICustomTypeDescriptor`. Have another class inherit from `TypeDescriptionProvider` to preserve the default behavior and override `GetTypeDescriptor()` to provide `CustomConverterDescriptor`.
-
-```c#
-public class CustomConverterProvider : TypeDescriptionProvider
-{
-    private TypeConverter _converter;
-
-    public CustomConverterProvider(TypeDescriptionProvider parent, TypeConverter converter) : base(parent)
-        => _converter = converter;
-
-    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance) 
-        => new CustomConverterDescriptor(base.GetTypeDescriptor(objectType, instance), _converter);
-
-    // Consider nesting CustomConverterDescriptor here
-}
-```
-Note: The parent `TypeDescriptionProvider` to be passed to the constructor can be found via [`TypeDescriptor.GetProvider()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor.getprovider) and passing in the type that is intended to be associated to your custom type converter. An example of this will follow.
-
-### Registration/Deregistration
-Once you have `CustomConverterProvider` and `CustomConverterDescriptor` as outlined above, finish up registering your custom `TypeConverter` to a type by calling [`TypeDescriptor.AddProvider()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor.addprovider) with parameters `CustomConverterProvider` and the type you want your custom converter to be associated with. 
-```c#
-TypeDescriptionProvider parentProvider = TypeDescriptor.GetProvider(type);
-CustomConverterProvider newProvider = new(parentProvider, converter);
-TypeDescriptor.AddProvider(newProvider, type);
-```
-
-At this point, calling [`TypeDescriptor.GetConverter()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor.getconverter) with the same type that was passed to `TypeDescriptor.AddProvider()` will now return your custom type converter. To restore the previous behavior call [`TypeDescriptor.RemoveProvider()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor.removeprovider).
-```c#
-TypeDescriptor.RemoveProvider(newProvider, type);
-```
-
-## Additional Information
-
-### TypeDescriptor.GetConverter() Details
-This is a static method on [`TypeDescriptor`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptor) that will run through its private list of [`TypeDescriptionProviders`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptionprovider) and get the provider associated with the type. Once the right provider is found, it will then call [`TypeDescriptionProvider.GetTypeDescriptor()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typedescriptionprovider.gettypedescriptor) to get an [ICustomTypeDescriptor](https://learn.microsoft.com/dotnet/api/system.componentmodel.icustomtypedescriptor) and call [`ICustomTypeDescriptor.GetConverter()`](https://learn.microsoft.com/dotnet/api/system.componentmodel.icustomtypedescriptor.getconverter) to grab the [`TypeConverter`](https://learn.microsoft.com/dotnet/api/system.componentmodel.typeconverter). 
-```mermaid
-sequenceDiagram
-title TypeDescriptor.GetConverter() Flow
-
-participant TypeDescriptor
-participant CustomConverterProvider#58;TypeDescriptionProvider
-participant CustomConverterDescriptor#58;CustomTypeDescriptor
-participant CustomTypeConverter#58;TypeConverter
-note right of CustomConverterProvider#58;TypeDescriptionProvider: Call TypeDescriptor.RemoveProvider() to no longer associate your custom type converter with a given type
-TypeDescriptor->>CustomConverterProvider#58;TypeDescriptionProvider: TypeDescriptor.GetConverter()
-note over TypeDescriptor,CustomConverterProvider#58;TypeDescriptionProvider: Must call TypeDescriptor.AddProvider() with a given type first
-CustomConverterProvider#58;TypeDescriptionProvider->>CustomConverterDescriptor#58;CustomTypeDescriptor: CustomConverterProvider.GetTypeDescriptor()
-note over CustomConverterProvider#58;TypeDescriptionProvider,CustomConverterDescriptor#58;CustomTypeDescriptor: Must override GetTypeDescriptor() to return CustomConverterDescriptor first
-CustomConverterDescriptor#58;CustomTypeDescriptor->>CustomTypeConverter#58;TypeConverter: CustomConverterDescriptor.GetConverter()
-note over CustomConverterDescriptor#58;CustomTypeDescriptor,CustomTypeConverter#58;TypeConverter: Must override GetConverter() to return CustomTypeConverter first
-```
\ No newline at end of file
diff --git a/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInButtonClicked.md b/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInButtonClicked.md
deleted file mode 100644
index 31a525b6be0..00000000000
--- a/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInButtonClicked.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Windows Task Dialog Issue
-
-## Access Violation when receiving [`TDN_NAVIGATED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-navigated) within [`TDN_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-button-clicked)
-
-An Access violation can occur when receiving a navigation notification ([`TDN_NAVIGATED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-navigated))
-within a [`TDN_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-button-clicked)
-notification (e.g. due to running the message loop) and then returning `S_OK`.
- 
-* Run the code.
-* Click on the "My Custom Button" button.
-* Notice that the dialog navigates and an inner dialog shows.
-* Close the inner dialog by clicking the OK button.
-* **Issue:** In most cases, an access violation occurs now (if not, try again a
-  few times).
-* Notice the problem also occurs when you (after the navigation) first close
-  the original dialog, and then close the inner dialog.
-* The problem can be avoided by returning `S_FALSE` from the `TDN_BUTTON_CLICKED`
-  notification.
-
-```cpp
-#include "stdafx.h"
-#include "CommCtrl.h"
-
-HRESULT WINAPI TaskDialogCallbackProc(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ LONG_PTR lpRefData)
-{
-    switch (msg) {
-    case TDN_BUTTON_CLICKED:
-        if (wParam == 100) {
-            TASKDIALOGCONFIG* navigationConfig = new TASKDIALOGCONFIG;
-            *navigationConfig = { 0 };
-            navigationConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-            navigationConfig->pszMainInstruction = L"After navigation !!!";
-            navigationConfig->pszContent = L"Text";
-            navigationConfig->pszMainIcon = MAKEINTRESOURCEW(0xFFF7);
-
-            // Navigate the dialog.
-            SendMessageW(hwnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)navigationConfig);
-            delete navigationConfig;
-
-            // After that, run the event loop by show an inner dialog.
-            TaskDialog(nullptr, nullptr, L"Inner Dialog", L"Inner Dialog", nullptr, 0, 0, nullptr);
-        }
-
-        break;
-    }
-
-    return S_OK;
-}
-
-void ShowTaskDialogNavigationInButtonClickedNotification()
-{
-    TASKDIALOGCONFIG* tConfig = new TASKDIALOGCONFIG;
-    *tConfig = { 0 };
-    tConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-    tConfig->nDefaultRadioButton = 100;
-    tConfig->pszMainInstruction = L"Before navigation";
-    tConfig->pfCallback = TaskDialogCallbackProc;
-
-    // Create 50 radio buttons.
-    int radioButtonCount = 50;
-    TASKDIALOG_BUTTON* radioButtons = new TASKDIALOG_BUTTON[radioButtonCount];
-    for (int i = 0; i < radioButtonCount; i++) {
-        radioButtons[i].nButtonID = 100 + i;
-        radioButtons[i].pszButtonText = L"My Radio Button";
-    }
-    tConfig->pRadioButtons = radioButtons;
-    tConfig->cRadioButtons = radioButtonCount;
-
-    // Create a custom button.
-    TASKDIALOG_BUTTON* customButton = new TASKDIALOG_BUTTON;
-    customButton->nButtonID = 100;
-    customButton->pszButtonText = L"My Custom Button";
-    tConfig->pButtons = customButton;
-    tConfig->cButtons = 1;
-
-    int nButton, nRadioButton;
-    BOOL checkboxSelected;
-    TaskDialogIndirect(tConfig, &nButton, &nRadioButton, &checkboxSelected);
-
-    delete customButton;
-    delete radioButtons;
-    delete tConfig;
-}
-
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-    _In_opt_ HINSTANCE hPrevInstance,
-    _In_ LPWSTR    lpCmdLine,
-    _In_ int       nCmdShow)
-{
-    UNREFERENCED_PARAMETER(hPrevInstance);
-    UNREFERENCED_PARAMETER(lpCmdLine);
-
-    ShowTaskDialogNavigationInButtonClickedNotification();
-
-    return 0;
-}
-```
\ No newline at end of file
diff --git a/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInRadioButtonClicked.md b/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInRadioButtonClicked.md
deleted file mode 100644
index 37519e57cd6..00000000000
--- a/docs/src/System/Windows/Forms/TaskDialog/Issue_AccessViolation_NavigationInRadioButtonClicked.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Windows Task Dialog Issue
-
-## Access Violation when receiving [`TDN_NAVIGATED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-navigated) within [`TDN_RADIO_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-radio-button-clicked)
-
-An Access Violation occurs when receiving a navigation notification
-([`TDN_NAVIGATED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-navigated))
-within a [`TDN_RADIO_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-radio-button-clicked)
-notification (e.g. due to running the message loop).
- 
-* Run the code and select one of the radio buttons.
-* Notice the dialog has navigated and an inner dialog is opened.
-* Close the inner dialog.
-* **Issue:** Notice the application crashes with an access violation.
-
-```cpp
-#include "stdafx.h"
-#include "CommCtrl.h"
-
-HRESULT WINAPI TaskDialogCallbackProc(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ LONG_PTR lpRefData)
-{
-    switch (msg) {
-    case TDN_RADIO_BUTTON_CLICKED:
-        // When the user clicked the second radio button, navigate the dialog, then show an inner dialog.
-
-        // Navigate
-        TASKDIALOGCONFIG* navigationConfig = new TASKDIALOGCONFIG;
-        *navigationConfig = { 0 };
-        navigationConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-        navigationConfig->pszMainInstruction = L"After navigation !!";
-
-        SendMessageW(hwnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)navigationConfig);
-        delete navigationConfig;
-
-        // After navigating, run the event loop by showing an inner dialog.
-        TaskDialog(nullptr, nullptr, L"Inner Dialog", L"Inner Dialog", nullptr, 0, 0, nullptr);
-
-        break;
-    }
-
-    return S_OK;
-}
-
-void ShowTaskDialogRadioButtonsBehavior()
-{
-    TASKDIALOGCONFIG* tConfig = new TASKDIALOGCONFIG;
-    *tConfig = { 0 };
-    tConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-    tConfig->dwFlags = TDF_NO_DEFAULT_RADIO_BUTTON;
-    tConfig->pszMainInstruction = L"Before Navigation";
-    tConfig->pfCallback = TaskDialogCallbackProc;
-
-    // Create 2 radio buttons.
-    int radioButtonCount = 2;
-
-    TASKDIALOG_BUTTON* radioButtons = new TASKDIALOG_BUTTON[radioButtonCount];
-    for (int i = 0; i < radioButtonCount; i++) {
-        radioButtons[i].nButtonID = 100 + i;
-        radioButtons[i].pszButtonText = i == 0 ? L"Radio Button 1" : L"Radio Button 2";
-    }
-    tConfig->pRadioButtons = radioButtons;
-    tConfig->cRadioButtons = radioButtonCount;
-
-    int nButton, nRadioButton;
-    BOOL checkboxSelected;
-    TaskDialogIndirect(tConfig, &nButton, &nRadioButton, &checkboxSelected);
-
-    delete radioButtons;
-    delete tConfig;
-}
-
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-    _In_opt_ HINSTANCE hPrevInstance,
-    _In_ LPWSTR    lpCmdLine,
-    _In_ int       nCmdShow)
-{
-    UNREFERENCED_PARAMETER(hPrevInstance);
-    UNREFERENCED_PARAMETER(lpCmdLine);
-
-    ShowTaskDialogRadioButtonsBehavior();
-
-    return 0;
-}
-```
\ No newline at end of file
diff --git a/docs/src/System/Windows/Forms/TaskDialog/Issue_ButtonClickHandlerCalledTwice.md b/docs/src/System/Windows/Forms/TaskDialog/Issue_ButtonClickHandlerCalledTwice.md
deleted file mode 100644
index 5fe0db805f9..00000000000
--- a/docs/src/System/Windows/Forms/TaskDialog/Issue_ButtonClickHandlerCalledTwice.md
+++ /dev/null
@@ -1,95 +0,0 @@
-# Windows Task Dialog Issue
-
-## [`TDN_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-button-clicked) notification sent twice when pressing a button with its access key
-
-When you "click" a button by pressing its access key (mnemonic) and the dialog
-is still open when the message loop continues, the [`TDN_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-button-clicked)
-notification is sent twice instead of once.
- 
-* Run the code.
-* Click one of the buttons with the mouse, or press space or enter, and notice
-  that the counter increments by 1.
-* **Issue:** Press <kbd>Alt</kbd>+<kbd>M</kbd> or <kbd>Alt</kbd>+<kbd>N</kbd> and 
-  notice the counter increments by 2.
-
-```cpp
-#include "stdafx.h"
-#include "CommCtrl.h"
-
-int counter = 0;
-wchar_t* counterTextBuffer;
-HRESULT WINAPI ShowTaskDialogButtonClickHandlerCalledTwice_Callback(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ LONG_PTR lpRefData) {
-    switch (msg) {
-    case TDN_BUTTON_CLICKED:
-        // Increment the counter.
-        counter++;
-        swprintf_s(counterTextBuffer, 100, L"Counter: %d", counter);
-        SendMessageW(hwnd, TDM_SET_ELEMENT_TEXT, TDE_MAIN_INSTRUCTION, (LPARAM)counterTextBuffer);
-
-        // When the user clicks the custom button, return false so that the dialog
-        // stays open.
-        if (wParam == 100) {
-            return S_FALSE;
-        }
-        else if (wParam == IDNO) {
-            // Otherwise, when the user clicks the common button, run the message loop.
-            MSG msg;
-            int bRet;
-            while ((bRet = GetMessageW(&msg, nullptr, 0, 0)) != 0) {
-                if (bRet == -1) {
-                    // Error
-                }
-                else {
-                    TranslateMessage(&msg);
-                    DispatchMessageW(&msg);
-                }
-            }
-        }
-
-        break;
-    }
-
-    return S_OK;
-}
-
-void ShowTaskDialogButtonClickHandlerCalledTwice() {
-    counterTextBuffer = new wchar_t[100];
-
-    TASKDIALOGCONFIG* tConfig = new TASKDIALOGCONFIG;
-    *tConfig = { 0 };
-    tConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-    tConfig->dwFlags = TDF_USE_COMMAND_LINKS;
-    tConfig->pszMainInstruction = L"Text...";
-    tConfig->pfCallback = ShowTaskDialogButtonClickHandlerCalledTwice_Callback;
-
-    // Create a custom button and a common ("No") button.
-    tConfig->dwCommonButtons = TDCBF_NO_BUTTON;    
-
-    TASKDIALOG_BUTTON customButton = { 0 };
-    customButton.nButtonID = 100;
-    customButton.pszButtonText = L"&My Button";
-    tConfig->pButtons = &customButton;
-    tConfig->cButtons = 1;
-
-    int nButton, nRadioButton;
-    BOOL checkboxSelected;
-    TaskDialogIndirect(tConfig, &nButton, &nRadioButton, &checkboxSelected);
-
-    delete tConfig;
-    delete[] counterTextBuffer;
-}
-
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-    _In_opt_ HINSTANCE hPrevInstance,
-    _In_ LPWSTR    lpCmdLine,
-    _In_ int       nCmdShow)
-{
-    UNREFERENCED_PARAMETER(hPrevInstance);
-    UNREFERENCED_PARAMETER(lpCmdLine);
-
-    ShowTaskDialogButtonClickHandlerCalledTwice();
-
-    return 0;
-}
-```
\ No newline at end of file
diff --git a/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_InfiniteLoop.md b/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_InfiniteLoop.md
deleted file mode 100644
index f728f9e9d74..00000000000
--- a/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_InfiniteLoop.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Windows Task Dialog Issue
-
-## Infinite loop with radio buttons
-
-An infinite loop occurs when sending a
-[`TDM_CLICK_RADIO_BUTTON`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdm-click-radio-button) message within a
-[`TDN_RADIO_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-radio-button-clicked) notification.
- 
-* Run the code and select the second radio button.
-* **Issue:** Notice that the GUI doesn't respond any more. When debugging, you can see that
-  the callback is flooded with `TDN_RADIO_BUTTON_CLICKED` notifications even though we
-  don't send any more messages to the dialog.
-
-```cpp
-#include "stdafx.h"
-#include "CommCtrl.h"
-
-bool done = false;
-HRESULT WINAPI TaskDialogCallbackProc(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ LONG_PTR lpRefData)
-{
-    switch (msg) {
-    case TDN_RADIO_BUTTON_CLICKED:
-        // When the user clicked the second radio button, select the first one.
-        // However, do this only once.
-        if (wParam == 101 && !done) {
-            done = true;
-            SendMessageW(hwnd, TDM_CLICK_RADIO_BUTTON, 100, 0);
-        }
-        break;
-    }
-
-    return S_OK;
-}
-
-void ShowTaskDialogRadioButtonsBehavior()
-{
-    TASKDIALOGCONFIG* tConfig = new TASKDIALOGCONFIG;
-    *tConfig = { 0 };
-    tConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-    tConfig->dwFlags = TDF_NO_DEFAULT_RADIO_BUTTON;
-    tConfig->pszMainInstruction = L"Radio Button Example";
-    tConfig->pfCallback = TaskDialogCallbackProc;
-
-    // Create 2 radio buttons.
-    int radioButtonCount = 2;
-
-    TASKDIALOG_BUTTON* radioButtons = new TASKDIALOG_BUTTON[radioButtonCount];
-    for (int i = 0; i < radioButtonCount; i++) {
-        radioButtons[i].nButtonID = 100 + i;
-        radioButtons[i].pszButtonText = i == 0 ? L"Radio Button 1" : L"Radio Button 2";
-    }
-    tConfig->pRadioButtons = radioButtons;
-    tConfig->cRadioButtons = radioButtonCount;
-
-    int nButton, nRadioButton;
-    BOOL checkboxSelected;
-    TaskDialogIndirect(tConfig, &nButton, &nRadioButton, &checkboxSelected);
-
-    delete radioButtons;
-    delete tConfig;
-}
-
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-    _In_opt_ HINSTANCE hPrevInstance,
-    _In_ LPWSTR    lpCmdLine,
-    _In_ int       nCmdShow)
-{
-    UNREFERENCED_PARAMETER(hPrevInstance);
-    UNREFERENCED_PARAMETER(lpCmdLine);
-
-    ShowTaskDialogRadioButtonsBehavior();
-
-    return 0;
-}
-```
\ No newline at end of file
diff --git a/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_WeirdBehavior.md b/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_WeirdBehavior.md
deleted file mode 100644
index e4b3ce23614..00000000000
--- a/docs/src/System/Windows/Forms/TaskDialog/Issue_RadioButton_WeirdBehavior.md
+++ /dev/null
@@ -1,115 +0,0 @@
-# Windows Task Dialog Issue
-
-## Weird behavior with radio buttons
-
-Weird behavior occurs when running the message loop within an
-[`TDN_RADIO_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-radio-button-clicked)
-notification.
-
-* Run the code.
-* Notice that within the
-  [`TDN_TIMER`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-timer) notification, a
-  [`TDM_CLICK_RADIO_BUTTON`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdm-click-radio-button) is
-  sent to select the second radio button which causes an inner dialog to be shown within
-  the [`TDN_RADIO_BUTTON_CLICKED`](https://docs.microsoft.com/en-us/windows/desktop/Controls/tdn-radio-button-clicked)
-  notification, but the radio button is only selected after 
-  the inner dialog is closed (and therefore the notification handler returns).<br>
-  While that seems like a strange/undesired behavior, it is actually the documented behavior:
-  > "The specified radio button ID is sent to the TaskDialogCallbackProc callback function
-  as part of a TDN_RADIO_BUTTON_CLICKED notification code. After the callback function
-  returns, the radio button will be selected."
-
-  (For the .NET implementation that has the `TaskDialogRadioButton.CheckedChanged` event
-  that is expected to show already the new state, this can be worked-around by ignoring
-  `TDN_RADIO_BUTTON_CLICKED` notifications caused by the code itself, and instead raising
-  the events after sending the `TDM_CLICK_RADIO_BUTTON` message.)
-  However, this special behavior might be related to the following issue (and the other
-  code samples regarding radio buttons):  
-* When you click one of the radio buttons and then immediately close the inner dialog,
-  everything works.
-* Now try the following: Click the first radio button (but do NOT close the inner dialog),
-  then click the second radio button.
-* Now close the most inner dialog (showing call count 2), and then the other inner dialog.
-* **Issue:** Notice that the dialog changed the selection of the radio button and shows the inner
-  dialog again. When you close it, even more inner dialogs open.
-* During that time, when you focus the original dialog, it will switch the selected radio
-  button again.
-
-```cpp
-#include "stdafx.h"
-#include "CommCtrl.h"
-
-int callCount = 0;
-int timerCounter = 0;
-HRESULT WINAPI TaskDialogCallbackProc(_In_ HWND hwnd, _In_ UINT msg, _In_ WPARAM wParam, _In_ LPARAM lParam, _In_ LONG_PTR lpRefData)
-{
-    switch (msg) {
-    case TDN_TIMER:
-        if (timerCounter < 4) {
-            timerCounter++;
-        }
-        else if (timerCounter == 4) {
-            timerCounter++;
-
-            // Select the second radio button.
-            SendMessageW(hwnd, TDM_CLICK_RADIO_BUTTON, 101, 0);
-        }
-
-        break;
-
-    case TDN_RADIO_BUTTON_CLICKED:
-        callCount++;
-        wchar_t* instruction = new wchar_t[200];
-        swprintf_s(instruction, 100, L"InnerDialog - CallCount: %d", callCount);
-        TaskDialog(nullptr, nullptr, L"Inner Dialog", instruction, nullptr, 0, 0, nullptr);
-        delete instruction;
-        callCount--;
-
-        break;
-    }
-
-    return S_OK;
-}
-
-void ShowTaskDialogRadioButtonsBehavior()
-{
-    TASKDIALOGCONFIG* tConfig = new TASKDIALOGCONFIG;
-    *tConfig = { 0 };
-    tConfig->cbSize = sizeof(TASKDIALOGCONFIG);
-
-    tConfig->dwFlags = TDF_NO_DEFAULT_RADIO_BUTTON | TDF_CALLBACK_TIMER;
-    tConfig->pszMainInstruction = L"Radio Button Example";
-    tConfig->pfCallback = TaskDialogCallbackProc;
-
-    // Create 2 radio buttons.
-    int radioButtonCount = 2;
-
-    TASKDIALOG_BUTTON* radioButtons = new TASKDIALOG_BUTTON[radioButtonCount];
-    for (int i = 0; i < radioButtonCount; i++) {
-        radioButtons[i].nButtonID = 100 + i;
-        radioButtons[i].pszButtonText = i == 0 ? L"Radio Button 1" : L"Radio Button 2";
-    }
-    tConfig->pRadioButtons = radioButtons;
-    tConfig->cRadioButtons = radioButtonCount;
-
-    int nButton, nRadioButton;
-    BOOL checkboxSelected;
-    TaskDialogIndirect(tConfig, &nButton, &nRadioButton, &checkboxSelected);
-
-    delete radioButtons;
-    delete tConfig;
-}
-
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-    _In_opt_ HINSTANCE hPrevInstance,
-    _In_ LPWSTR    lpCmdLine,
-    _In_ int       nCmdShow)
-{
-    UNREFERENCED_PARAMETER(hPrevInstance);
-    UNREFERENCED_PARAMETER(lpCmdLine);
-
-    ShowTaskDialogRadioButtonsBehavior();
-
-    return 0;
-}
-```
\ No newline at end of file
diff --git a/docs/testing-in-vs.md b/docs/testing-in-vs.md
deleted file mode 100644
index 16b846dc5fd..00000000000
--- a/docs/testing-in-vs.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# Windows Forms Testing in Visual Studio
-
-Visual Studio executes unit tests differently from the command line. This page describes some of those differences and covers common problems and workarounds.
-
-## Assert.Same() failures
-
-### Problem
-
-`Assert.Same()` calls that pass when running tests from the command line can often fail when running through Visual Studio. This has to do with a quirk in the xUnit Visual Studio test adapter.
-
-### Cause
-
-* When using `[Theory]` combined with `[InlineData]`, `[ClassData]`, or `[MemberData]`, the xUnit VS test adapter does performs "discovery enumeration", before the test is actually executed
-    * It does this to populate the Test Explorer window with all the test cases before they run
-* The process running this enumeration executes in a **different App domain** than the tests themselves
-* This means objects passed in to the test methods have **different references** than expected (when comparing strings, for example)
-
-### Solution(s)
-
-There are two ways to get around this problem:
-
-1. Use a custom *DataAttribute (inheriting from the appropriate *DataAttributeBase class) and set `DisableDiscoveryEnumeration = true` in the constructor
-    * For an example of this, see [MauiDataAttribute.cs](https://github.com/dotnet/winforms/blob/afa8a0779f261e46fe7eb1611142bea143622578/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiDataAttribute.cs#L42)
-    * This is not really preferred, and should only be used when your test data can't be resolved at compile-time
-
-    OR
-
-1. Use Assert.Equal() when comparing against objects created by `[InlineData]`, `[ClassData]`, or `[MemberData]`
-    * You can still use Assert.Same() in all other cases
-
-## Tests don't execute
-
-### Problem
-
-* When launching tests through Visual Studio, no tests execute
-* Click on `View -> Output` and select `Tests` from the `Show output from:` dropdown
-* You might see an error that looks like `Testhost process exited with error: It was not possible to find any compatible framework version. The specified framework 'Microsoft.NETCore.App', version 'XXX' was not found`
-
-### Cause (long)
-
-* The .net core SDK and the .net core runtime (Microsoft.NetCore.App) are two different things.
-* The SDK targets a specific NetCore.App. This version is automatically downloaded into your local .dotnet folder when you build from command line, and is also installed when you install a dotnet sdk machine-wide.
-    * If you don’t specify an explicit NetCore.App version, you will use the one that the SDK targets.
-    * If you’re interested in seeing what this version is, look at `<yourRepoRoot>\.dotnet\sdk\<yourSdkVersion>\dotnet.runtimeconfig.json`
-* The winforms (runtime) repo DOES specify an explicit NetCore.App version, and we use the one published by the core-setup repo.
-    * If you look at [Directory.Build.Targets](https://github.com/dotnet/winforms/blob/ac0426561b158522eb8564de2bedd28f28148f8d/Directory.Build.targets#L35), you can see where this is set 
-* `$(VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion)` is set in [Versions.props](https://github.com/dotnet/winforms/blob/ac0426561b158522eb8564de2bedd28f28148f8d/eng/Versions.props#L19), and gets automatically updated when we ingest dependencies from core-setup. (These PR's are automatically merged in if the build passes)
-    * You can see where the dependency comes from by looking at [Version.Details.xml](https://github.com/dotnet/winforms/blob/ac0426561b158522eb8564de2bedd28f28148f8d/eng/Version.Details.xml#L13)
-    * The reason we use the version from core-setup instead of the version built-in to the SDK is we don’t want to wait for the runtime to come all the way through the SDK repo to consume it
-* Running tests from the command line (.\build -test) works because the build scripts automatically download both the sdk AND the NetCore.App that you need AND add the .dotnet folder to your PATH when running.
-    * You can verify this by checking the .dotnet folder in your repo root. The NetCore.App is in the shared folder.
-* However, Visual Studio doesn’t care about your local .dotnet folder. It always looks at your machine-wide installs (unless you manually add things to your PATH before launching VS)
-    * If you don’t have the required SDK installed machine-wide, your code won’t build (through VS). 
-    * If you don’t have the required NetCore.App installed machine-wide, your code won’t run (through VS). 
-* **This is why unit tests can fail immediately through VS.**
-    * Note that just installing the SDK **IS NOT ENOUGH** if you are using an explicit NetCore.App version.
-* Since the command line builds automatically download everything you need, we just have to tell VS where this stuff lives
-
-### Solution(s)
-
-There are two ways to get around this problem:
-
-1. Add your local `<repoRoot>\.dotnet` folder to the front of your PATH variable
-    * This is **not preferred** because Visual Studio will always look here first, and can break other things, like if you need to build against a higher version of the SDK
-
-    OR
-
-1. Close VS, run `<repoRoot>\build-local.ps1`, then re-open VS
-    * This will do a restore (to download the stuff), do a build, then symlink the stuff you need from your local .dotnet folder to your machine-wide SDK install folder `(C:\Program Files\dotnet\...)`. Then VS will know about it too 😊
diff --git a/docs/testing.md b/docs/testing.md
deleted file mode 100644
index 957d524b48e..00000000000
--- a/docs/testing.md
+++ /dev/null
@@ -1,335 +0,0 @@
-# Windows Forms Testing
-
-This document describes our approach to testing.
-
-* [Building tests](#building-tests)
-* [Unit Tests](#unit-tests)
-    * [Running unit tests](#running-unit-tests)
-        - [Unit testing from the command line](#unit-testing-from-the-command-line)
-        - [Troubleshooting command-line unit test errors](#troubleshooting-command-line-unit-test-errors)
-        - [Unit testing from Visual Studio](#unit-testing-from-visual-studio)
-        - [Troubleshooting Visual Studio unit test errors](#troubleshooting-visual-studio-unit-test-errors)
-    * [Adding new unit tests](#adding-new-unit-tests)
-        - [Test placement](#therefore-you-just-need-to-put-your-tests-in-the-right-place-in-order-for-them-to-run)
-        - [Unit Test best practices](#unit-test-best-practices)
-            - [Naming](#naming)
-            - [Decoration](#decoration)
-            - [Disposal](#dispose-created-objects)
-            - [Theory tests](#theory-tests#theory-tests)
-        - [Throw unhandled exceptions](#throw-unhandled-exceptions)
-* [Rendering Tests](#rendering-tests)
-* [Functional Tests](#functional-tests)
-    * [Running functional tests](#running-functional-tests)
-        - [Functional testing from the command line](#functional-testing-from-the-command-line)
-        - [Troubleshooting command-line functional test errors](#troubleshooting-command-line-functional-test-errors)
-        - [Functional testing from Visual Studio](#functional-testing-from-visual-studio)
-        - [Troubleshooting Visual Studio functional test errors](#troubleshooting-visual-studio-functional-test-errors)
-    * [Adding new functional tests](#adding-new-functional-tests)
-        - [Test placement](#therefore-you-just-need-to-put-your-tests-in-the-right-place-in-order-for-them-to-run-1)
- * [Testing for Accessibility](#testing-for-accessibility)
- * [Running and debugging crashed tests](#running-and-debugging-crashed-tests)
-    
-
-# Building tests
-
-Tests are automatically built when running `.\build` since all test projects are referenced in `Winforms.sln` at the repository root.
-
-# Unit Tests
-
-## Running unit tests
-
-### Unit testing from the command line
-
-To execute unit tests, run `.\build -test`
-
-If all the tests are successful, you should see something like this:
-
-```console
-  Running tests: E:\src\repos\github\winforms\artifacts\bin\System.Windows.Forms.Tests\Debug\net6.0\System.Windows.Forms.Tests.dll [net6.0|x64]
-  Tests succeeded: E:\src\repos\github\winforms\artifacts\bin\System.Windows.Forms.Tests\Debug\net6.0\System.Windows.Forms.Tests.dll [net6.0|x64]
-
-Build succeeded.
-    0 Warning(s)
-    0 Error(s)
-```
-
-### Troubleshooting command-line unit test errors
-
-When testing from the command line, a failed test should look something like this:
-
-```console
-Running tests: E:\src\repos\github\winforms\artifacts\bin\System.Windows.Forms.Tests\Debug\net6.0\System.Windows.Forms.Tests.dll [net6.0|x64]
-XUnit : error : Tests failed: E:\src\repos\github\winforms\artifacts\TestResults\Debug\System.Windows.Forms.Tests_net6.0_x64.html [net6.0|x64] [E:\src\repos\github\winforms\src\System.Windows.Forms\tests\UnitTests\System.Windows.Forms.Tests.csproj]
-XUnit : error : Tests failed: E:\src\repos\github\winforms\artifacts\TestResults\Debug\System.Windows.Forms.Tests_net6.0_x64.html [net6.0|x64] [E:\src\repos\github\winforms\src\System.Windows.Forms\tests\UnitTests\System.Windows.Forms.Tests.csproj]
-
-Build FAILED.
-```
-
-* The test summary can be found under artifacts\log
-* To see the actual test(s) that failed, along with their error message(s), open the .html file that is displayed in the error message (which is always under `artifacts\TestResults`)
-
-### Unit testing from Visual Studio
-
-To test from Visual Studio, start Visual Studio via `.\start-vs.cmd`, and test how you normally would (using the Test Explorer, for example)
-
-### Troubleshooting Visual Studio unit test errors
-
-* When testing from Visual Studio, test errors show up as normal in the Test Explorer.
-* To troubleshoot, debug the selected test and set breakpoints as you normally would.
-* For common issues when running tests through Visual Studio, see [Testing in Visual Studio](testing-in-vs.md)
-
-## Adding new unit tests
-
-Tests are built and executed by file name convention
-
-* Every WinForms binary has its own folder under src in the repository root (src\System.Windows.Forms, for example)
-* Each of those folders has a tests folder under it (src\System.Windows.Forms\tests, for example)
-* Each tests folder contains an xUnit test project (System.Windows.Forms.Tests.csproj)
-  * These test projects automatically build when running `.\build`
-  * The tests from these projects automatically execute when running `.\build -test`.<br/>
-    It is also possible to execute individual tests via `dotnet test --filter <filter expression>` command by switching to the desired test project directory first.
-  
-
-### Therefore, you just need to put your tests in the right place in order for them to run
-
-* Browse to the tests folder for the binary you are testing.
-* There should be one file per class being tested, and the file name should match the class name followed by a "**Tests**" suffix.
-  * For example, if I wanted to test the `Button` class in System.Windows.Forms.dll, I would look for a **ButtonTests.cs** under src\System.Windows.Forms\tests.
-  * For example, if I wanted to test the `Button.ButtonAccessibleObject` class in System.Windows.Forms.dll, I would look for a **Button.ButtonAccessibleObjectTests.cs** under src\System.Windows.Forms\tests.
-* If the file exists, add your tests there. If it doesn't exist, feel free to create it.
-  * **Note that you don't have to modify the csproj at all.** Since the project is a Microsoft.NET.Sdk project, all source files next to it are automatically included.
-
-### Unit Test best practices
-
-#### Naming
-
-* Test files names should match the class they are testing followed by a "**Tests**" suffix.
-  * For example, tests for the `Button` class should be in ButtonTests.cs.
-  * For example, tests for the `Button.ButtonAccessibleObject` class should be in **Button.ButtonAccessibleObjectTests.cs**.
-* Test class names should match the class they are testing, followed by a "**Tests**" suffix.
-  * For example, tests for the `Button` class should in the `ButtonTests` class.
-  * For example, tests for the `Button.ButtonAccessibleObject` class should in the `Button_ButtonAccessibleObjectTests` class.
-* Test names should start with the class they are testing.
-  * For example, all tests for the `Button` class should start with "Button".
-* Test names should end with a description of what the test does - this is very useful when viewing test results, and when browsing in the test explorer. As far as naming conventions are concerned we don't mandate a specific one, as long as a test name clearly communicates its purpose.
-  * For example, `Button_AutoSizeModeGetSet` or `MyButton_Click_should_throw_ArgumentNullException`.
-
-#### Decoration
-
-* All tests that deal with UI controls or types that require synchronization context must be decorated with `WinFormsFact` or `WinFormsTheory` attributes.
-* Other tests can be decorated with `StaFact`, `StaTheory`, `Fact` or `Theory`
-
-#### Dispose created objects
-
-* All tests creating disposable objects (e.g. UI controls) must dispose them. Otherwise it could lead to memory leaks (bad but not terminal) and race conditions that could lead to deadlocked tests (terminal).
-  ```cs
-    [WinFormsFact]
-    public void ButtonBase_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using SubButtonBase control = new();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }  
-  ```
-  
-#### Theory tests
-
-Quite often there may be multiple tests that test exactly the same functionality but with different input parameters (e.g. `null`, `""`, `" "` for a `string` argument). 
-In such cases instead of creating multiple tests it is preferred to have a theory test, which is in another words a data-driven test.
-
-When writing theories note the following:
-
-1. theory test must be [correctly decorated](#Decoration)
-
-2. theories must avoid creating UI controls. E.g. instead of writing:
-    ```cs
-    public static IEnumerable<object[]> GetButton_TestData()
-    {
-        yield return new object[] { new Button() };
-        yield return new object[] { new Button() { Text = "bla" } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetButton_TestData))]
-    public void Ctor_Control_DataGridViewCellStyle(Button button) { ... }
-    ```
-    prefer the following:
-    ```cs
-    public static IEnumerable<object[]> GetButton_TestData()
-    {
-        yield return new object[] { string.Empty };
-        yield return new object[] { "bla" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetButton_TestData))]
-    public void Ctor_Control_DataGridViewCellStyle(string buttonText) 
-    {
-        using Button button = new() { Text = buttonText };
-        ...
-    }    
-    ```
-  
-3. theories must not reuse disposable components.<br />
-  In situations where following the above recommendation could be impractical, it is maybe acceptable to create disposable controls for each theory data, e.g.:
-    ```cs
-    public static IEnumerable<object[]> GetButton_TestData()
-    {
-        yield return new object[] { new Button(), new DataGridViewCellStyle() };
-        yield return new object[] { new Button() { Text = "bla" }, new DataGridViewCellStyle() };
-    }
-    ```
-    xUnit tries its best to [dispose](https://github.com/xunit/xunit/blob/56476a9691bb061661190b183733c5d8a2c6ef4d/src/xunit.execution/Sdk/Frameworks/TestMethodTestCase.cs#L191-L197) of disposable objects.
-    However objects must not be shared across theories, as it could lead to unknown state, e.g.
-    ```cs
-    // ** DO NOT DO THIS! **
-    public static IEnumerable<object[]> GetButton_TestData()
-    {
-        Button button = new();
-        yield return new object[] { button, new DataGridViewCellStyle() };
-        yield return new object[] { button { Text = "bla" }, new DataGridViewCellStyle() }; // the button could already be disposed by the time this theory runs
-    }
-    ```
-
-
-Also be beware and be mindful of VS-specific behaviours: https://xunit.net/faq/theory-data-stability-in-vs
-
-
-#### Strategy
-
-##### Unit tests should be part of the same PR as code changes
-
-* Unit tests must be added for any change to public APIs. 
-* We will accept unit tests for internal/private methods as well. Some non-public API can be accessed directly (e.g. `internal`), some via subclassing (e.g. `virtual`) or via the public surface. However there are plenty of instances where a non-public API can't be easily accessed or arranged for. In this cases we use [`TestAccessor` pattern](https://github.com/dotnet/winforms/blob/main/src/System.Windows.Forms.Primitives/tests/TestUtilities/TestAccessor.cs) to arrange, act and assert.
-
-##### Code Coverage
-
-* In Visual Studio Test Explorer, select all tests, right click and execute 'Analyze code coverage for selected tests' command. This will run all tests and give a summary of blocks covered in 'Code Coverage Results' window. The summary can be drilled down to method level.
-* Any code change accompanied with unit tests is expected to increase code coverage for the code modified.
-
-##### Avoid duplicating tests just for different inputs
-
-* Use `WinFormsTheory`, `StaTheory` or `Theory` attributes for this, followed by either `[InlineData]` or `[MemberData]`. See existing tests for examples on how to use these attributes
-* The exception to this is if the code behavior is fundamentally different based on the inputs. For example, if a method throws an `ArgumentException` for invalid inputs, that should be a separate test.
-
-##### One test (or test data) per code path please
-
-* The most common exception to this is when testing a property, most people test get/set together
-
-##### Whenever possible, mock up dependencies to run tests in isolation
-  
-* For example, if your method accepts an abstraction, use Moq to mock it up
-* Search for Mock in the existing tests for examples, and see [Moq](https://github.com/Moq/moq4/wiki/Quickstart) for details on how to use Moq.
-
-
-# Rendering Tests
-
-We use [Enhance Metafiles](https://docs.microsoft.com/windows/win32/gdi/enhanced-format-metafiles) (or EMF for short) to validate rendering operations, i.e. assert that correct shapes were drawn with expected colours and brushes.
-
-A typical "rendering" assertion test would looks something like this:
-```cs
-[WinFormsFact]
-public void MyControl_Rendering()
-{
-    // 1. Create a control to validate rendering for.
-    // 2. Add the control to a form, and make sure the form is created
-    using Form form = new Form();
-    using MyControl control = new() { ... };
-    form.Controls.Add(control);
-    Assert.NotEqual(IntPtr.Zero, form.Handle);
-
-    // Create an Enhance Metafile into which we will render the control
-    using EmfScope emf = new();
-    DeviceContextState state = new DeviceContextState(emf);
-
-    // Render the control
-    control.PrintToMetafile(emf);
-
-    // We can see the rendering steps by invoking this command:
-    // string records = emf.RecordsToString();
-
-    // Assert the rendering was as expected
-    emf.Validate(
-        state,
-        ...
-        );
-}
-```
-
-
-# Functional Tests
-
-> :warning: There is a very blurry line between unit and functional tests in Windows Forms realm. A lot of our implementations depend on ambient contexts (such as Win32, COM, etc.). We classify tests as "functional" or "integration" that require process-wide settings (such as visual styles) or require user-like interactions (e.g. mouse gestures).
-
-Currently, there is a single functional test suite in the repository: the **WinformsControlsTest**. There is an xUnit project that executes various commands against this binary.
-
-## Running functional tests
-
-### Functional testing from the command line
-
-To execute functional tests, run `.\build -integrationTest`
-
-You will see various windows open and close very quickly. If all the tests are successful, you should see something like this:
-
-```console
-  Running tests: E:\src\repos\github\winforms\artifacts\bin\System.Windows.Forms.IntegrationTests\Debug\net6.0\System.Windows.Forms.IntegrationTests.dll [net6.0|x64]
-  Tests succeeded: E:\src\repos\github\winforms\artifacts\bin\System.Windows.Forms.IntegrationTests\Debug\net6.0\System.Windows.Forms.IntegrationTests.dll [net6.0|x64]
-
-Build succeeded.
-    0 Warning(s)
-    0 Error(s)
-```
-
-
-
-### Troubleshooting command-line functional test errors
-
-Since these run in xUnit, functional test errors can be examined in the same way as unit test failures.
-
-### Functional testing from Visual Studio
-
-To test from Visual Studio, open Winforms.sln in Visual Studio and test how you normally would (using the Test Explorer, for example)
-
-### Troubleshooting Visual Studio functional test errors
-
-* When testing from Visual Studio, test errors show up as normal in the test explorer.
-* To troubleshoot, debug the selected test and set breakpoints as you normally would.
-
-## Adding new functional tests
-
-Functional tests are built and executed by file name convention
-
-* Every WinForms binary has its own folder under src in the repository root (src\System.Windows.Forms, for example)
-* Each of those folders has a tests folder under it (src\System.Windows.Forms\tests, for example), each of which may contain an IntegrationTests folder
-* Each of these folders contains an IntegrationTest xUnit project (System.Windows.Forms.IntegrationTests.csproj)
-  * These test projects automatically build when running `.\build`
-  * The tests from these projects automatically execute when running `.\build -integrationTest`
-
-### Therefore, you just need to put your tests in the right place in order for them to run
-
-* Browse to the tests folder for the binary you are testing
-* There should be one file per class being tested, and the file name should match the class name.
-  * For example, if I wanted to test the `Button` class in System.Windows.Forms.dll, I would look for a Button.cs under src\System.Windows.Forms\tests
-* If the file exists, add your tests there. If it doesn't exist, feel free to create it.
-  * **Note that you don't have to modify the csproj at all.** Since the project is a Microsoft.NET.Sdk project, all source files next to it are automatically included
- 
-  
-# Testing for Accessibility
-
-Our goal is to make writing accessible WinForms applications easy. Specifically, all default property values should yield accessible experience. To test that controls are accessible, find or add the changed control to [AccessibilityTests application](https://github.com/dotnet/winforms/tree/main/src/System.Windows.Forms/tests/AccessibilityTests) and run [Accessibility Insights for Windows](https://accessibilityinsights.io/docs/en/windows/overview) on it. 
-
-
-# Running and debugging crashed tests
-
-At times tests may fail in way that makes it difficult to debug (e.g., the [test runner process crashes](https://github.com/dotnet/runtime/issues/76219)). In this case, it's good to replicate the issue locally and collect a memory dump to have a better understanding whether the issue is caused by the change in Windows Forms SDK, or, for example, by the .NET runtime.
-
-* Configure your workstation to automatically collect memory dumps following [Collecting User-Mode Dumps guide](https://learn.microsoft.com/windows/win32/wer/collecting-user-mode-dumps) guide.
-* Run `.\start-code.cmd`
-* In the VS Code terminal run the following commands to run the tests:
-    ```
-    .\restore.cmd
-    pushd .\src\System.Windows.Forms\tests\UnitTests
-    dotnet test 
-    ```
-* Upon the test process crash, navigate to the collected memory dump and inspect it in [WinDbg](https://learn.microsoft.com/windows-hardware/drivers/debugger/debugger-download-tools) (or [MSFT internal](https://www.osgwiki.com/wiki/WinDbg)) (or another tool of your choice).
-
-❕If you need to debug an x86-related issue, run tests with `-a x86` argument, e.g., `dotnet test -a x86`, and then use the 32-bit version of WinDbg to open the dump.
diff --git a/eng/CustomPackaging.targets b/eng/CustomPackaging.targets
new file mode 100644
index 00000000000..438d669e6f5
--- /dev/null
+++ b/eng/CustomPackaging.targets
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  
+  <!-- Custom packaging target that runs after the main package is created -->
+  <Target Name="CreateCustomNuGetPackage" 
+          AfterTargets="Build" 
+          Condition="'$(Configuration)' == 'Release' AND '$(MSBuildProjectName)' == 'System.Windows.Forms.Design'">
+    
+    <PropertyGroup>
+      <!-- Base paths -->
+      <PackagesOutputDir>$(ArtifactsDir)packages\$(Configuration)\Shipping</PackagesOutputDir>
+      <OriginalPackageName>WTG.System.Windows.Forms.$(PackageVersion).nupkg</OriginalPackageName>
+      <OriginalPackagePath>$(PackagesOutputDir)\$(OriginalPackageName)</OriginalPackagePath>
+      <CustomPackageName>System.Windows.Forms.$(PackageVersion).nupkg</CustomPackageName>
+      <CustomPackagePath>$(RepoRoot)\bin\$(CustomPackageName)</CustomPackagePath>
+      
+      <!-- Source directories for additional files -->
+      <DesignBinDir>$(ArtifactsDir)bin\System.Windows.Forms.Design\$(Configuration)\net8.0</DesignBinDir>
+      
+      <!-- PowerShell script path -->
+      <PowerShellScriptPath>$(RepoRoot)CreateCustomPackage.ps1</PowerShellScriptPath>
+    </PropertyGroup>
+
+    <Message Text="Starting custom NuGet package creation for System.Windows.Forms..." Importance="high" />
+    <Message Text="Original package: $(OriginalPackagePath)" Importance="normal" />
+    <Message Text="Target package: $(CustomPackagePath)" Importance="normal" />
+    <Message Text="Design bin directory: $(DesignBinDir)" Importance="normal" />
+
+    <!-- Ensure the original package exists -->
+    <Error Condition="!Exists('$(OriginalPackagePath)')" 
+           Text="Original package not found at: $(OriginalPackagePath)" />
+
+    <!-- Ensure the PowerShell script exists -->
+    <Error Condition="!Exists('$(PowerShellScriptPath)')" 
+           Text="PowerShell script not found at: $(PowerShellScriptPath)" />
+    
+    <!-- Call the PowerShell script to do the actual work -->
+    <Exec Command="powershell.exe -NoProfile -ExecutionPolicy Bypass -File &quot;$(PowerShellScriptPath)&quot; -OriginalPackagePath &quot;$(OriginalPackagePath)&quot; -CustomPackagePath &quot;$(CustomPackagePath)&quot; -DesignBinDir &quot;$(DesignBinDir)&quot;" 
+          ContinueOnError="false" />
+    
+    <Message Text="Custom NuGet package created successfully: $(CustomPackagePath)" Importance="high" />
+    
+  </Target>
+
+</Project>
diff --git a/eng/Publishing.props b/eng/Publishing.props
index 10bc8c8684d..579a1360d90 100644
--- a/eng/Publishing.props
+++ b/eng/Publishing.props
@@ -2,5 +2,6 @@
 <Project>
    <PropertyGroup>
       <PublishingVersion>3</PublishingVersion>
+      <ProducesDotNetReleaseShippingAssets>true</ProducesDotNetReleaseShippingAssets>
    </PropertyGroup>
 </Project>
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 680e2a75825..0e8106a31ad 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -179,29 +179,29 @@ Note: if the Uri is a new place, you will need to add a subscription from that p
   </ProductDependencies>
   <ToolsetDependencies>
     <!-- Arcade -->
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.GenFacades" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.GenFacades" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.CMake.Sdk" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.CMake.Sdk" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.RemoteExecutor" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="8.0.0-beta.24113.2">
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="8.0.0-beta.24165.4">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>da98edc4c3ea539f109ea320672136ceb32591a7</Sha>
+      <Sha>f311667e0587f19c3fa9553a909975662107a351</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>
diff --git a/eng/Versions.props b/eng/Versions.props
index b691f7fc423..c015d3879be 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -1,49 +1,52 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <MajorVersion>8</MajorVersion>
+    <MajorVersion>0</MajorVersion>
     <MinorVersion>0</MinorVersion>
-    <PatchVersion>3</PatchVersion>
+    <PatchVersion>24</PatchVersion>
     <!-- version in our package name #.#.#-below.#####.## -->
-    <PreReleaseVersionLabel>servicing</PreReleaseVersionLabel>
-    <PreReleaseVersionIteration>
-    </PreReleaseVersionIteration>
+    <PreReleaseVersionLabel>preview</PreReleaseVersionLabel>
+    <PreReleaseVersionIteration>1</PreReleaseVersionIteration>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <UsingToolMicrosoftNetCompilers>true</UsingToolMicrosoftNetCompilers>
     <!-- StabilizePackageVersion should be switched to true for rtm -->
     <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">true</StabilizePackageVersion>
-    <DotNetFinalVersionKind Condition="'$(StabilizePackageVersion)' == 'true'">release</DotNetFinalVersionKind>
+    
+    <!-- change this to 'release' when ready-->    
+    <DotNetFinalVersionKind Condition="'$(StabilizePackageVersion)' == 'true'">prerelease</DotNetFinalVersionKind>
+  
   </PropertyGroup>
   <!-- Below have corresponding entries in Versions.Details.XML because they are updated via Maestro -->
   <PropertyGroup>
-    <VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion>8.0.3-servicing.24114.23</VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion>
+    <VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion>8.0.1-servicing.23580.1</VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion>
     <SystemDiagnosticsEventLogPackageVersion>8.0.0</SystemDiagnosticsEventLogPackageVersion>
     <SystemDirectoryServicesPackageVersion>8.0.0</SystemDirectoryServicesPackageVersion>
+    <SystemDrawingCommonPackageVersion>8.0.0</SystemDrawingCommonPackageVersion>
     <SystemReflectionMetadataLoadContextPackageVersion>8.0.0</SystemReflectionMetadataLoadContextPackageVersion>
     <SystemSecurityCryptographyXmlPackageVersion>8.0.0</SystemSecurityCryptographyXmlPackageVersion>
     <SystemIOPackagingPackageVersion>8.0.0</SystemIOPackagingPackageVersion>
     <MicrosoftNETCoreRuntimeCoreCLRPackageVersion>5.0.0-preview.7.20320.5</MicrosoftNETCoreRuntimeCoreCLRPackageVersion>
-    <MicrosoftNETCoreILDAsmPackageVersion>8.0.3-servicing.24114.23</MicrosoftNETCoreILDAsmPackageVersion>
+    <MicrosoftNETCoreILDAsmPackageVersion>8.0.1-servicing.23580.1</MicrosoftNETCoreILDAsmPackageVersion>
     <SystemDiagnosticsPerformanceCounterPackageVersion>8.0.0</SystemDiagnosticsPerformanceCounterPackageVersion>
     <SystemRuntimeCompilerServicesUnsafePackageVersion>6.0.0</SystemRuntimeCompilerServicesUnsafePackageVersion>
     <SystemSecurityCryptographyPkcsPackageVersion>8.0.0</SystemSecurityCryptographyPkcsPackageVersion>
     <SystemSecurityCryptographyProtectedDataPackageVersion>8.0.0</SystemSecurityCryptographyProtectedDataPackageVersion>
     <SystemTextEncodingsWebPackageVersion>8.0.0</SystemTextEncodingsWebPackageVersion>
-    <SystemTextJsonPackageVersion>8.0.3</SystemTextJsonPackageVersion>
+    <SystemTextJsonPackageVersion>8.0.1</SystemTextJsonPackageVersion>
     <SystemThreadingAccessControlPackageVersion>8.0.0</SystemThreadingAccessControlPackageVersion>
     <MicrosoftWin32RegistryAccessControlPackageVersion>8.0.0</MicrosoftWin32RegistryAccessControlPackageVersion>
-    <MicrosoftNETCoreAppRefPackageVersion>8.0.3</MicrosoftNETCoreAppRefPackageVersion>
-    <MicrosoftNETCoreAppRuntimewinx64PackageVersion>8.0.3</MicrosoftNETCoreAppRuntimewinx64PackageVersion>
-    <MicrosoftNETCorePlatformsPackageVersion>8.0.3-servicing.24114.23</MicrosoftNETCorePlatformsPackageVersion>
+    <MicrosoftNETCoreAppRefPackageVersion>8.0.1</MicrosoftNETCoreAppRefPackageVersion>
+    <MicrosoftNETCoreAppRuntimewinx64PackageVersion>8.0.0</MicrosoftNETCoreAppRuntimewinx64PackageVersion>
+    <MicrosoftNETCorePlatformsPackageVersion>8.0.1-servicing.23580.1</MicrosoftNETCorePlatformsPackageVersion>
     <MicrosoftWin32SystemEventsPackageVersion>8.0.0</MicrosoftWin32SystemEventsPackageVersion>
     <SystemCodeDomPackageVersion>8.0.0</SystemCodeDomPackageVersion>
     <SystemConfigurationConfigurationManagerPackageVersion>8.0.0</SystemConfigurationConfigurationManagerPackageVersion>
     <SystemResourcesExtensionsPackageVersion>8.0.0</SystemResourcesExtensionsPackageVersion>
     <SystemSecurityPermissionsPackageVersion>8.0.0</SystemSecurityPermissionsPackageVersion>
     <SystemWindowsExtensionsPackageVersion>8.0.0</SystemWindowsExtensionsPackageVersion>
-    <MicrosoftNETCoreILAsmPackageVersion>8.0.3-servicing.24114.23</MicrosoftNETCoreILAsmPackageVersion>
-    <runtimewinx64MicrosoftNETCoreILAsmPackageVersion>8.0.3-servicing.24114.23</runtimewinx64MicrosoftNETCoreILAsmPackageVersion>
-    <runtimewinx86MicrosoftNETCoreILAsmPackageVersion>8.0.3-servicing.24114.23</runtimewinx86MicrosoftNETCoreILAsmPackageVersion>
+    <MicrosoftNETCoreILAsmPackageVersion>8.0.1-servicing.23580.1</MicrosoftNETCoreILAsmPackageVersion>
+    <runtimewinx64MicrosoftNETCoreILAsmPackageVersion>8.0.1-servicing.23580.1</runtimewinx64MicrosoftNETCoreILAsmPackageVersion>
+    <runtimewinx86MicrosoftNETCoreILAsmPackageVersion>8.0.1-servicing.23580.1</runtimewinx86MicrosoftNETCoreILAsmPackageVersion>
     <!-- 
       Microsoft.NET.Sdk.IL.targets requires definition of MicrosoftNETCoreILAsmVersion
     -->
@@ -56,9 +59,9 @@
   </PropertyGroup>
   <!-- Arcade -->
   <PropertyGroup>
-    <MicrosoftDotNetGenFacadesPackageVersion>8.0.0-beta.24113.2</MicrosoftDotNetGenFacadesPackageVersion>
-    <MicrosoftDotNetRemoteExecutorVersion>8.0.0-beta.24113.2</MicrosoftDotNetRemoteExecutorVersion>
-    <MicrosoftDotNetXUnitExtensionsPackageVersion>8.0.0-beta.24113.2</MicrosoftDotNetXUnitExtensionsPackageVersion>
+    <MicrosoftDotNetGenFacadesPackageVersion>8.0.0-beta.23564.4</MicrosoftDotNetGenFacadesPackageVersion>
+    <MicrosoftDotNetRemoteExecutorVersion>8.0.0-beta.23564.4</MicrosoftDotNetRemoteExecutorVersion>
+    <MicrosoftDotNetXUnitExtensionsPackageVersion>8.0.0-beta.23564.4</MicrosoftDotNetXUnitExtensionsPackageVersion>
     <MicrosoftNETTestSdkVersion>17.4.0-preview-20220707-01</MicrosoftNETTestSdkVersion>
   </PropertyGroup>
   <!-- Below have no corresponding entries in Versions.Details.XML because they are not updated via Maestro -->
diff --git a/eng/common/SetupNugetSources.ps1 b/eng/common/SetupNugetSources.ps1
index 6c65e81925f..efa2fd72bfa 100644
--- a/eng/common/SetupNugetSources.ps1
+++ b/eng/common/SetupNugetSources.ps1
@@ -35,7 +35,7 @@ Set-StrictMode -Version 2.0
 . $PSScriptRoot\tools.ps1
 
 # Add source entry to PackageSources
-function AddPackageSource($sources, $SourceName, $SourceEndPoint, $creds, $Username, $Password) {
+function AddPackageSource($sources, $SourceName, $SourceEndPoint, $creds, $Username, $pwd) {
     $packageSource = $sources.SelectSingleNode("add[@key='$SourceName']")
     
     if ($packageSource -eq $null)
@@ -48,12 +48,11 @@ function AddPackageSource($sources, $SourceName, $SourceEndPoint, $creds, $Usern
     else {
         Write-Host "Package source $SourceName already present."
     }
-    
-    AddCredential -Creds $creds -Source $SourceName -Username $Username -Password $Password
+    AddCredential -Creds $creds -Source $SourceName -Username $Username -pwd $pwd
 }
 
 # Add a credential node for the specified source
-function AddCredential($creds, $source, $username, $password) {
+function AddCredential($creds, $source, $username, $pwd) {
     # Looks for credential configuration for the given SourceName. Create it if none is found.
     $sourceElement = $creds.SelectSingleNode($Source)
     if ($sourceElement -eq $null)
@@ -82,17 +81,18 @@ function AddCredential($creds, $source, $username, $password) {
         $passwordElement.SetAttribute("key", "ClearTextPassword")
         $sourceElement.AppendChild($passwordElement) | Out-Null
     }
-    $passwordElement.SetAttribute("value", $Password)
+    
+    $passwordElement.SetAttribute("value", $pwd)
 }
 
-function InsertMaestroPrivateFeedCredentials($Sources, $Creds, $Username, $Password) {
+function InsertMaestroPrivateFeedCredentials($Sources, $Creds, $Username, $pwd) {
     $maestroPrivateSources = $Sources.SelectNodes("add[contains(@key,'darc-int')]")
 
     Write-Host "Inserting credentials for $($maestroPrivateSources.Count) Maestro's private feeds."
     
     ForEach ($PackageSource in $maestroPrivateSources) {
         Write-Host "`tInserting credential for Maestro's feed:" $PackageSource.Key
-        AddCredential -Creds $creds -Source $PackageSource.Key -Username $Username -Password $Password
+        AddCredential -Creds $creds -Source $PackageSource.Key -Username $Username -pwd $pwd
     }
 }
 
@@ -144,13 +144,13 @@ if ($disabledSources -ne $null) {
 $userName = "dn-bot"
 
 # Insert credential nodes for Maestro's private feeds
-InsertMaestroPrivateFeedCredentials -Sources $sources -Creds $creds -Username $userName -Password $Password
+InsertMaestroPrivateFeedCredentials -Sources $sources -Creds $creds -Username $userName -pwd $Password
 
 # 3.1 uses a different feed url format so it's handled differently here
 $dotnet31Source = $sources.SelectSingleNode("add[@key='dotnet3.1']")
 if ($dotnet31Source -ne $null) {
-    AddPackageSource -Sources $sources -SourceName "dotnet3.1-internal" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal/nuget/v2" -Creds $creds -Username $userName -Password $Password
-    AddPackageSource -Sources $sources -SourceName "dotnet3.1-internal-transport" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-transport/nuget/v2" -Creds $creds -Username $userName -Password $Password
+    AddPackageSource -Sources $sources -SourceName "dotnet3.1-internal" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal/nuget/v2" -Creds $creds -Username $userName -pwd $Password
+    AddPackageSource -Sources $sources -SourceName "dotnet3.1-internal-transport" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-transport/nuget/v2" -Creds $creds -Username $userName -pwd $Password
 }
 
 $dotnetVersions = @('5','6','7','8')
@@ -159,9 +159,9 @@ foreach ($dotnetVersion in $dotnetVersions) {
     $feedPrefix = "dotnet" + $dotnetVersion;
     $dotnetSource = $sources.SelectSingleNode("add[@key='$feedPrefix']")
     if ($dotnetSource -ne $null) {
-        AddPackageSource -Sources $sources -SourceName "$feedPrefix-internal" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/internal/_packaging/$feedPrefix-internal/nuget/v2" -Creds $creds -Username $userName -Password $Password
-        AddPackageSource -Sources $sources -SourceName "$feedPrefix-internal-transport" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/internal/_packaging/$feedPrefix-internal-transport/nuget/v2" -Creds $creds -Username $userName -Password $Password
+        AddPackageSource -Sources $sources -SourceName "$feedPrefix-internal" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/internal/_packaging/$feedPrefix-internal/nuget/v2" -Creds $creds -Username $userName -pwd $Password
+        AddPackageSource -Sources $sources -SourceName "$feedPrefix-internal-transport" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/internal/_packaging/$feedPrefix-internal-transport/nuget/v2" -Creds $creds -Username $userName -pwd $Password
     }
 }
 
-$doc.Save($filename)
+$doc.Save($filename)
\ No newline at end of file
diff --git a/eng/common/templates-official/job/job.yml b/eng/common/templates-official/job/job.yml
new file mode 100644
index 00000000000..a2709d10562
--- /dev/null
+++ b/eng/common/templates-official/job/job.yml
@@ -0,0 +1,263 @@
+# Internal resources (telemetry, microbuild) can only be accessed from non-public projects,
+# and some (Microbuild) should only be applied to non-PR cases for internal builds.
+
+parameters:
+# Job schema parameters - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  cancelTimeoutInMinutes: ''
+  condition: ''
+  container: ''
+  continueOnError: false
+  dependsOn: ''
+  displayName: ''
+  pool: ''
+  steps: []
+  strategy: ''
+  timeoutInMinutes: ''
+  variables: []
+  workspace: ''
+  templateContext: ''
+
+# Job base template specific parameters
+  # See schema documentation - https://github.com/dotnet/arcade/blob/master/Documentation/AzureDevOps/TemplateSchema.md
+  artifacts: ''
+  enableMicrobuild: false
+  enablePublishBuildArtifacts: false
+  enablePublishBuildAssets: false
+  enablePublishTestResults: false
+  enablePublishUsingPipelines: false
+  enableBuildRetry: false
+  disableComponentGovernance: ''
+  componentGovernanceIgnoreDirectories: ''
+  mergeTestResults: false
+  testRunTitle: ''
+  testResultsFormat: ''
+  name: ''
+  preSteps: []
+  runAsPublic: false
+# Sbom related params
+  enableSbom: true
+  PackageVersion: 7.0.0
+  BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+
+jobs:
+- job: ${{ parameters.name }}
+
+  ${{ if ne(parameters.cancelTimeoutInMinutes, '') }}:
+    cancelTimeoutInMinutes: ${{ parameters.cancelTimeoutInMinutes }}
+
+  ${{ if ne(parameters.condition, '') }}:
+    condition: ${{ parameters.condition }}
+
+  ${{ if ne(parameters.container, '') }}:
+    container: ${{ parameters.container }}
+
+  ${{ if ne(parameters.continueOnError, '') }}:
+    continueOnError: ${{ parameters.continueOnError }}
+
+  ${{ if ne(parameters.dependsOn, '') }}:
+    dependsOn: ${{ parameters.dependsOn }}
+
+  ${{ if ne(parameters.displayName, '') }}:
+    displayName: ${{ parameters.displayName }}
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+
+  ${{ if ne(parameters.strategy, '') }}:
+    strategy: ${{ parameters.strategy }}
+
+  ${{ if ne(parameters.timeoutInMinutes, '') }}:
+    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+
+  ${{ if ne(parameters.templateContext, '') }}:
+    templateContext: ${{ parameters.templateContext }}
+
+  variables:
+  - ${{ if ne(parameters.enableTelemetry, 'false') }}:
+    - name: DOTNET_CLI_TELEMETRY_PROFILE
+      value: '$(Build.Repository.Uri)'
+  - ${{ if eq(parameters.enableRichCodeNavigation, 'true') }}:
+    - name: EnableRichCodeNavigation
+      value: 'true'
+  # Retry signature validation up to three times, waiting 2 seconds between attempts.
+  # See https://learn.microsoft.com/en-us/nuget/reference/errors-and-warnings/nu3028#retry-untrusted-root-failures
+  - name: NUGET_EXPERIMENTAL_CHAIN_BUILD_RETRY_POLICY
+    value: 3,2000
+  - ${{ each variable in parameters.variables }}:
+    # handle name-value variable syntax
+    # example:
+    # - name: [key]
+    #   value: [value]
+    - ${{ if ne(variable.name, '') }}:
+      - name: ${{ variable.name }}
+        value: ${{ variable.value }}
+
+    # handle variable groups
+    - ${{ if ne(variable.group, '') }}:
+      - group: ${{ variable.group }}
+
+    # handle template variable syntax
+    # example:
+    # - template: path/to/template.yml
+    #   parameters:
+    #     [key]: [value]
+    - ${{ if ne(variable.template, '') }}:
+      - template: ${{ variable.template }}
+        ${{ if ne(variable.parameters, '') }}:
+          parameters: ${{ variable.parameters }}
+
+    # handle key-value variable syntax.
+    # example:
+    # - [key]: [value]
+    - ${{ if and(eq(variable.name, ''), eq(variable.group, ''), eq(variable.template, '')) }}:
+      - ${{ each pair in variable }}:
+        - name: ${{ pair.key }}
+          value: ${{ pair.value }}
+
+  # DotNet-HelixApi-Access provides 'HelixApiAccessToken' for internal builds
+  - ${{ if and(eq(parameters.enableTelemetry, 'true'), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: DotNet-HelixApi-Access
+
+  ${{ if ne(parameters.workspace, '') }}:
+    workspace: ${{ parameters.workspace }}
+
+  steps:
+  - ${{ if ne(parameters.preSteps, '') }}:
+    - ${{ each preStep in parameters.preSteps }}:
+      - ${{ preStep }}
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - ${{ if eq(parameters.enableMicrobuild, 'true') }}:
+      - task: MicroBuildSigningPlugin@3
+        displayName: Install MicroBuild plugin
+        inputs:
+          signType: $(_SignType)
+          zipSources: false
+          feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+        env:
+          TeamName: $(_TeamName)
+        continueOnError: ${{ parameters.continueOnError }}
+        condition: and(succeeded(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT'))
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), eq(variables['System.TeamProject'], 'internal')) }}:
+    - task: NuGetAuthenticate@1
+
+  - ${{ if and(ne(parameters.artifacts.download, 'false'), ne(parameters.artifacts.download, '')) }}:
+    - task: DownloadPipelineArtifact@2
+      inputs:
+        buildType: current
+        artifactName: ${{ coalesce(parameters.artifacts.download.name, 'Artifacts_$(Agent.OS)_$(_BuildConfig)') }}
+        targetPath: ${{ coalesce(parameters.artifacts.download.path, 'artifacts') }}
+        itemPattern: ${{ coalesce(parameters.artifacts.download.pattern, '**') }}
+
+  - ${{ each step in parameters.steps }}:
+    - ${{ step }}
+
+  - ${{ if eq(parameters.enableRichCodeNavigation, true) }}:
+    - task: RichCodeNavIndexer@0
+      displayName: RichCodeNav Upload
+      inputs:
+        languages: ${{ coalesce(parameters.richCodeNavigationLanguage, 'csharp') }}
+        environment: ${{ coalesce(parameters.richCodeNavigationEnvironment, 'production') }}
+        richNavLogOutputDirectory: $(Build.SourcesDirectory)/artifacts/bin
+        uploadRichNavArtifacts: ${{ coalesce(parameters.richCodeNavigationUploadArtifacts, false) }}
+      continueOnError: true
+
+  - template: /eng/common/templates-official/steps/component-governance.yml
+    parameters:
+      ${{ if eq(parameters.disableComponentGovernance, '') }}:
+        ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.runAsPublic, 'false'), or(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/dotnet/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/microsoft/'), eq(variables['Build.SourceBranch'], 'refs/heads/main'))) }}:
+          disableComponentGovernance: false
+        ${{ else }}:
+          disableComponentGovernance: true
+      ${{ else }}:
+        disableComponentGovernance: ${{ parameters.disableComponentGovernance }}
+      componentGovernanceIgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
+
+  - ${{ if eq(parameters.enableMicrobuild, 'true') }}:
+    - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+      - task: MicroBuildCleanup@1
+        displayName: Execute Microbuild cleanup tasks
+        condition: and(always(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT'))
+        continueOnError: ${{ parameters.continueOnError }}
+        env:
+          TeamName: $(_TeamName)
+
+  - ${{ if ne(parameters.artifacts.publish, '') }}:
+    - ${{ if and(ne(parameters.artifacts.publish.artifacts, 'false'), ne(parameters.artifacts.publish.artifacts, '')) }}:
+      - task: CopyFiles@2
+        displayName: Gather binaries for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/bin'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/bin'
+      - task: CopyFiles@2
+        displayName: Gather packages for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/packages'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/packages'
+      - task: 1ES.PublishBuildArtifacts@1
+        displayName: Publish pipeline artifacts
+        inputs:
+          PathtoPublish: '$(Build.ArtifactStagingDirectory)/artifacts'
+          PublishLocation: Container
+          ArtifactName: ${{ coalesce(parameters.artifacts.publish.artifacts.name , 'Artifacts_$(Agent.Os)_$(_BuildConfig)') }}
+        continueOnError: true
+        condition: always()
+    - ${{ if and(ne(parameters.artifacts.publish.logs, 'false'), ne(parameters.artifacts.publish.logs, '')) }}:
+      - task: 1ES.PublishPipelineArtifact@1
+        inputs:
+          targetPath: 'artifacts/log'
+          artifactName: ${{ coalesce(parameters.artifacts.publish.logs.name, 'Logs_Build_$(Agent.Os)_$(_BuildConfig)') }}
+        displayName: 'Publish logs'
+        continueOnError: true
+        condition: always()
+
+  - ${{ if ne(parameters.enablePublishBuildArtifacts, 'false') }}:
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish Logs
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)'
+        PublishLocation: Container
+        ArtifactName: ${{ coalesce(parameters.enablePublishBuildArtifacts.artifactName, '$(Agent.Os)_$(Agent.JobName)' ) }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'xunit')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish XUnit Test Results
+      inputs:
+        testResultsFormat: 'xUnit'
+        testResultsFiles: '*.xml'
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-xunit
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'vstest')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish TRX Test Results
+      inputs:
+        testResultsFormat: 'VSTest'
+        testResultsFiles: '*.trx'
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-trx
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.enableSbom, 'true')) }}:
+    - template: /eng/common/templates-official/steps/generate-sbom.yml
+      parameters:
+        PackageVersion: ${{ parameters.packageVersion}}
+        BuildDropPath: ${{ parameters.buildDropPath }}
+        IgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
+
+  - ${{ if eq(parameters.enableBuildRetry, 'true') }}:
+    - task: 1ES.PublishPipelineArtifact@1
+      inputs:
+        targetPath: '$(Build.SourcesDirectory)\eng\common\BuildConfiguration'
+        artifactName: 'BuildConfiguration'
+      displayName: 'Publish build retry configuration'
+      continueOnError: true
\ No newline at end of file
diff --git a/eng/common/templates-official/job/onelocbuild.yml b/eng/common/templates-official/job/onelocbuild.yml
new file mode 100644
index 00000000000..ba9ba493032
--- /dev/null
+++ b/eng/common/templates-official/job/onelocbuild.yml
@@ -0,0 +1,112 @@
+parameters:
+  # Optional: dependencies of the job
+  dependsOn: ''
+
+  # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
+  pool: ''
+    
+  CeapexPat: $(dn-bot-ceapex-package-r) # PAT for the loc AzDO instance https://dev.azure.com/ceapex
+  GithubPat: $(BotAccount-dotnet-bot-repo-PAT)
+
+  SourcesDirectory: $(Build.SourcesDirectory)
+  CreatePr: true
+  AutoCompletePr: false
+  ReusePr: true
+  UseLfLineEndings: true
+  UseCheckedInLocProjectJson: false
+  SkipLocProjectJsonGeneration: false
+  LanguageSet: VS_Main_Languages
+  LclSource: lclFilesInRepo
+  LclPackageId: ''
+  RepoType: gitHub
+  GitHubOrg: dotnet
+  MirrorRepo: ''
+  MirrorBranch: main
+  condition: ''
+  JobNameSuffix: ''
+
+jobs:
+- job: OneLocBuild${{ parameters.JobNameSuffix }}
+  
+  dependsOn: ${{ parameters.dependsOn }}
+
+  displayName: OneLocBuild${{ parameters.JobNameSuffix }}
+
+  variables:
+    - group: OneLocBuildVariables # Contains the CeapexPat and GithubPat
+    - name: _GenerateLocProjectArguments
+      value: -SourcesDirectory ${{ parameters.SourcesDirectory }}
+        -LanguageSet "${{ parameters.LanguageSet }}"
+        -CreateNeutralXlfs
+    - ${{ if eq(parameters.UseCheckedInLocProjectJson, 'true') }}:
+      - name: _GenerateLocProjectArguments
+        value: ${{ variables._GenerateLocProjectArguments }} -UseCheckedInLocProjectJson
+    - template: /eng/common/templates-official/variables/pool-providers.yml
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+  ${{ if eq(parameters.pool, '') }}:
+    pool:
+      # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+        name: AzurePipelines-EO
+        image: 1ESPT-Windows2022
+        demands: Cmd
+        os: windows
+      # If it's not devdiv, it's dnceng
+      ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+        name: $(DncEngInternalBuildPool)
+        image: 1es-windows-2022-pt
+        os: windows
+
+  steps:
+    - ${{ if ne(parameters.SkipLocProjectJsonGeneration, 'true') }}:
+      - task: Powershell@2
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/generate-locproject.ps1
+          arguments: $(_GenerateLocProjectArguments)
+        displayName: Generate LocProject.json
+        condition: ${{ parameters.condition }}
+
+    - task: OneLocBuild@2
+      displayName: OneLocBuild
+      env:
+        SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      inputs:
+        locProj: eng/Localize/LocProject.json
+        outDir: $(Build.ArtifactStagingDirectory)
+        lclSource: ${{ parameters.LclSource }}
+        lclPackageId: ${{ parameters.LclPackageId }}
+        isCreatePrSelected: ${{ parameters.CreatePr }}
+        isAutoCompletePrSelected: ${{ parameters.AutoCompletePr }}
+        ${{ if eq(parameters.CreatePr, true) }}:
+          isUseLfLineEndingsSelected: ${{ parameters.UseLfLineEndings }}
+          ${{ if eq(parameters.RepoType, 'gitHub') }}:
+            isShouldReusePrSelected: ${{ parameters.ReusePr }}
+        packageSourceAuth: patAuth
+        patVariable: ${{ parameters.CeapexPat }}
+        ${{ if eq(parameters.RepoType, 'gitHub') }}:
+          repoType: ${{ parameters.RepoType }}
+          gitHubPatVariable: "${{ parameters.GithubPat }}"
+        ${{ if ne(parameters.MirrorRepo, '') }}:
+          isMirrorRepoSelected: true
+          gitHubOrganization: ${{ parameters.GitHubOrg }}
+          mirrorRepo: ${{ parameters.MirrorRepo }}
+          mirrorBranch: ${{ parameters.MirrorBranch }}
+      condition: ${{ parameters.condition }}
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish Localization Files
+      inputs:
+        PathtoPublish: '$(Build.ArtifactStagingDirectory)/loc'
+        PublishLocation: Container
+        ArtifactName: Loc
+      condition: ${{ parameters.condition }}
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish LocProject.json
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/eng/Localize/'
+        PublishLocation: Container
+        ArtifactName: Loc
+      condition: ${{ parameters.condition }}
\ No newline at end of file
diff --git a/eng/common/templates-official/job/publish-build-assets.yml b/eng/common/templates-official/job/publish-build-assets.yml
new file mode 100644
index 00000000000..53138622fe7
--- /dev/null
+++ b/eng/common/templates-official/job/publish-build-assets.yml
@@ -0,0 +1,155 @@
+parameters:
+  configuration: 'Debug'
+
+  # Optional: condition for the job to run
+  condition: ''
+
+  # Optional: 'true' if future jobs should run even if this job fails
+  continueOnError: false
+
+  # Optional: dependencies of the job
+  dependsOn: ''
+
+  # Optional: Include PublishBuildArtifacts task
+  enablePublishBuildArtifacts: false
+
+  # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool
+  pool: {}
+
+  # Optional: should run as a public build even in the internal project
+  #           if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects.
+  runAsPublic: false
+
+  # Optional: whether the build's artifacts will be published using release pipelines or direct feed publishing
+  publishUsingPipelines: false
+
+  # Optional: whether the build's artifacts will be published using release pipelines or direct feed publishing
+  publishAssetsImmediately: false
+
+  artifactsPublishingAdditionalParameters: ''
+
+  signingValidationAdditionalParameters: ''
+
+jobs:
+- job: Asset_Registry_Publish
+
+  dependsOn: ${{ parameters.dependsOn }}
+  timeoutInMinutes: 150
+
+  ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+    displayName: Publish Assets
+  ${{ else }}:
+    displayName: Publish to Build Asset Registry
+
+  variables:
+  - template: /eng/common/templates-official/variables/pool-providers.yml
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: Publish-Build-Assets
+    - group: AzureDevOps-Artifact-Feeds-Pats
+    - name: runCodesignValidationInjection
+      value: false
+    - ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+      - template: /eng/common/templates-official/post-build/common-variables.yml
+
+  pool:
+    # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+    ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+      name: AzurePipelines-EO
+      image: 1ESPT-Windows2022
+      demands: Cmd
+      os: windows
+    # If it's not devdiv, it's dnceng
+    ${{ if ne(variables['System.TeamProject'], 'DevDiv') }}:
+      name: $(DncEngInternalBuildPool)
+      image: 1es-windows-2022-pt
+      os: windows
+  steps:
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download artifact
+      inputs:
+        artifactName: AssetManifests
+        downloadPath: '$(Build.StagingDirectory)/Download'
+        checkDownloadedFiles: true
+      condition: ${{ parameters.condition }}
+      continueOnError: ${{ parameters.continueOnError }}
+    
+    - task: NuGetAuthenticate@1
+
+    - task: PowerShell@2
+      displayName: Publish Build Assets
+      inputs:
+        filePath: eng\common\sdk-task.ps1
+        arguments: -task PublishBuildAssets -restore -msbuildEngine dotnet
+          /p:ManifestsPath='$(Build.StagingDirectory)/Download/AssetManifests'
+          /p:BuildAssetRegistryToken=$(MaestroAccessToken)
+          /p:MaestroApiEndpoint=https://maestro-prod.westus2.cloudapp.azure.com
+          /p:PublishUsingPipelines=${{ parameters.publishUsingPipelines }}
+          /p:OfficialBuildId=$(Build.BuildNumber)
+      condition: ${{ parameters.condition }}
+      continueOnError: ${{ parameters.continueOnError }}
+    
+    - task: powershell@2
+      displayName: Create ReleaseConfigs Artifact
+      inputs:
+        targetType: inline
+        script: |
+          New-Item -Path "$(Build.StagingDirectory)/ReleaseConfigs" -ItemType Directory -Force
+          $filePath = "$(Build.StagingDirectory)/ReleaseConfigs/ReleaseConfigs.txt"
+          Add-Content -Path $filePath -Value $(BARBuildId)
+          Add-Content -Path $filePath -Value "$(DefaultChannels)"
+          Add-Content -Path $filePath -Value $(IsStableBuild)
+    
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish ReleaseConfigs Artifact
+      inputs:
+        PathtoPublish: '$(Build.StagingDirectory)/ReleaseConfigs'
+        PublishLocation: Container
+        ArtifactName: ReleaseConfigs
+
+    - task: powershell@2
+      displayName: Check if SymbolPublishingExclusionsFile.txt exists
+      inputs:
+        targetType: inline
+        script: |
+          $symbolExclusionfile = "$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt"
+          if(Test-Path -Path $symbolExclusionfile)
+          {
+            Write-Host "SymbolExclusionFile exists"
+            Write-Host "##vso[task.setvariable variable=SymbolExclusionFile]true"
+          }
+          else{
+           Write-Host "Symbols Exclusion file does not exists"
+           Write-Host "##vso[task.setvariable variable=SymbolExclusionFile]false"
+          }
+
+    - task: 1ES.PublishBuildArtifacts@1
+      displayName: Publish SymbolPublishingExclusionsFile Artifact
+      condition: eq(variables['SymbolExclusionFile'], 'true') 
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/eng/SymbolPublishingExclusionsFile.txt'
+        PublishLocation: Container
+        ArtifactName: ReleaseConfigs
+
+    - ${{ if eq(parameters.publishAssetsImmediately, 'true') }}:
+      - template: /eng/common/templates-official/post-build/setup-maestro-vars.yml
+        parameters:
+          BARBuildId: ${{ parameters.BARBuildId }}
+          PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+      - task: PowerShell@2
+        displayName: Publish Using Darc
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+          arguments: -BuildId $(BARBuildId) 
+            -PublishingInfraVersion 3
+            -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
+            -MaestroToken '$(MaestroApiAccessToken)'
+            -WaitPublishingFinish true
+            -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
+            -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
+
+    - ${{ if eq(parameters.enablePublishBuildArtifacts, 'true') }}:
+      - template: /eng/common/templates-official/steps/publish-logs.yml
+        parameters:
+          JobLabel: 'Publish_Artifacts_Logs'     
diff --git a/eng/common/templates-official/job/source-build.yml b/eng/common/templates-official/job/source-build.yml
new file mode 100644
index 00000000000..8aba3b44bb2
--- /dev/null
+++ b/eng/common/templates-official/job/source-build.yml
@@ -0,0 +1,67 @@
+parameters:
+  # This template adds arcade-powered source-build to CI. The template produces a server job with a
+  # default ID 'Source_Build_Complete' to put in a dependency list if necessary.
+
+  # Specifies the prefix for source-build jobs added to pipeline. Use this if disambiguation needed.
+  jobNamePrefix: 'Source_Build'
+
+  # Defines the platform on which to run the job. By default, a linux-x64 machine, suitable for
+  # managed-only repositories. This is an object with these properties:
+  #
+  # name: ''
+  #   The name of the job. This is included in the job ID.
+  # targetRID: ''
+  #   The name of the target RID to use, instead of the one auto-detected by Arcade.
+  # nonPortable: false
+  #   Enables non-portable mode. This means a more specific RID (e.g. fedora.32-x64 rather than
+  #   linux-x64), and compiling against distro-provided packages rather than portable ones.
+  # skipPublishValidation: false
+  #   Disables publishing validation.  By default, a check is performed to ensure no packages are
+  #   published by source-build.
+  # container: ''
+  #   A container to use. Runs in docker.
+  # pool: {}
+  #   A pool to use. Runs directly on an agent.
+  # buildScript: ''
+  #   Specifies the build script to invoke to perform the build in the repo. The default
+  #   './build.sh' should work for typical Arcade repositories, but this is customizable for
+  #   difficult situations.
+  # jobProperties: {}
+  #   A list of job properties to inject at the top level, for potential extensibility beyond
+  #   container and pool.
+  platform: {}
+
+jobs:
+- job: ${{ parameters.jobNamePrefix }}_${{ parameters.platform.name }}
+  displayName: Source-Build (${{ parameters.platform.name }})
+
+  ${{ each property in parameters.platform.jobProperties }}:
+    ${{ property.key }}: ${{ property.value }}
+
+  ${{ if ne(parameters.platform.container, '') }}:
+    container: ${{ parameters.platform.container }}
+
+  ${{ if eq(parameters.platform.pool, '') }}:
+    # The default VM host AzDO pool. This should be capable of running Docker containers: almost all
+    # source-build builds run in Docker, including the default managed platform.
+    # /eng/common/templates-official/variables/pool-providers.yml can't be used here (some customers declare variables already), so duplicate its logic
+    pool:
+      ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        name: $[replace(replace(eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'), True, 'NetCore-Svc-Public' ), False, 'NetCore-Public')]
+        demands: ImageOverride -equals Build.Ubuntu.1804.Amd64.Open
+
+      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        name: $[replace(replace(eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'), True, 'NetCore1ESPool-Svc-Internal'), False, 'NetCore1ESPool-Internal')]
+        image: 1es-mariner-2-pt
+        os: linux
+
+  ${{ if ne(parameters.platform.pool, '') }}:
+    pool: ${{ parameters.platform.pool }}
+
+  workspace:
+    clean: all
+
+  steps:
+  - template: /eng/common/templates-official/steps/source-build.yml
+    parameters:
+      platform: ${{ parameters.platform }}
diff --git a/eng/common/templates-official/job/source-index-stage1.yml b/eng/common/templates-official/job/source-index-stage1.yml
new file mode 100644
index 00000000000..4b633739170
--- /dev/null
+++ b/eng/common/templates-official/job/source-index-stage1.yml
@@ -0,0 +1,68 @@
+parameters:
+  runAsPublic: false
+  sourceIndexPackageVersion: 1.0.1-20230228.2
+  sourceIndexPackageSource: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json
+  sourceIndexBuildCommand: powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -Command "eng/common/build.ps1 -restore -build -binarylog -ci"
+  preSteps: []
+  binlogPath: artifacts/log/Debug/Build.binlog
+  condition: ''
+  dependsOn: ''
+  pool: ''
+
+jobs:
+- job: SourceIndexStage1
+  dependsOn: ${{ parameters.dependsOn }}
+  condition: ${{ parameters.condition }}
+  variables:
+  - name: SourceIndexPackageVersion
+    value: ${{ parameters.sourceIndexPackageVersion }}
+  - name: SourceIndexPackageSource
+    value: ${{ parameters.sourceIndexPackageSource }}
+  - name: BinlogPath
+    value: ${{ parameters.binlogPath }}
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - group: source-dot-net stage1 variables
+  - template: /eng/common/templates-official/variables/pool-providers.yml
+
+  ${{ if ne(parameters.pool, '') }}:
+    pool: ${{ parameters.pool }}
+  ${{ if eq(parameters.pool, '') }}:
+    pool:
+      ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        name: $(DncEngPublicBuildPool)
+        demands: ImageOverride -equals windows.vs2019.amd64.open
+      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        name: $(DncEngInternalBuildPool)
+        image: 1es-windows-2022-pt
+        os: windows
+
+  steps:
+  - ${{ each preStep in parameters.preSteps }}:
+    - ${{ preStep }}
+
+  - task: UseDotNet@2
+    displayName: Use .NET Core SDK 6
+    inputs:
+      packageType: sdk
+      version: 6.0.x
+      installationPath: $(Agent.TempDirectory)/dotnet
+      workingDirectory: $(Agent.TempDirectory)
+
+  - script: |
+      $(Agent.TempDirectory)/dotnet/dotnet tool install BinLogToSln --version $(SourceIndexPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools
+      $(Agent.TempDirectory)/dotnet/dotnet tool install UploadIndexStage1 --version $(SourceIndexPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools
+    displayName: Download Tools
+    # Set working directory to temp directory so 'dotnet' doesn't try to use global.json and use the repo's sdk.
+    workingDirectory: $(Agent.TempDirectory)
+
+  - script: ${{ parameters.sourceIndexBuildCommand }}
+    displayName: Build Repository
+
+  - script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i $(BinlogPath) -r $(Build.SourcesDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output
+    displayName: Process Binlog into indexable sln
+
+  - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+    - script: $(Agent.TempDirectory)/.source-index/tools/UploadIndexStage1 -i .source-index/stage1output -n $(Build.Repository.Name)
+      displayName: Upload stage1 artifacts to source index
+      env:
+        BLOB_CONTAINER_URL: $(source-dot-net-stage1-blob-container-url)
diff --git a/eng/common/templates-official/jobs/codeql-build.yml b/eng/common/templates-official/jobs/codeql-build.yml
new file mode 100644
index 00000000000..b68d3c2f319
--- /dev/null
+++ b/eng/common/templates-official/jobs/codeql-build.yml
@@ -0,0 +1,31 @@
+parameters:
+  # See schema documentation in /Documentation/AzureDevOps/TemplateSchema.md
+  continueOnError: false
+  # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  jobs: []
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+
+jobs:
+- template: /eng/common/templates-official/jobs/jobs.yml
+  parameters:
+    enableMicrobuild: false
+    enablePublishBuildArtifacts: false
+    enablePublishTestResults: false
+    enablePublishBuildAssets: false
+    enablePublishUsingPipelines: false
+    enableTelemetry: true
+
+    variables:
+      - group: Publish-Build-Assets
+      # The Guardian version specified in 'eng/common/sdl/packages.config'. This value must be kept in
+      # sync with the packages.config file.
+      - name: DefaultGuardianVersion
+        value: 0.109.0
+      - name: GuardianPackagesConfigFile
+        value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
+      - name: GuardianVersion
+        value: ${{ coalesce(parameters.overrideGuardianVersion, '$(DefaultGuardianVersion)') }}
+  
+    jobs: ${{ parameters.jobs }}
+        
diff --git a/eng/common/templates-official/jobs/jobs.yml b/eng/common/templates-official/jobs/jobs.yml
new file mode 100644
index 00000000000..857a0f8ba43
--- /dev/null
+++ b/eng/common/templates-official/jobs/jobs.yml
@@ -0,0 +1,97 @@
+parameters:
+  # See schema documentation in /Documentation/AzureDevOps/TemplateSchema.md
+  continueOnError: false
+
+  # Optional: Include PublishBuildArtifacts task
+  enablePublishBuildArtifacts: false
+
+  # Optional: Enable publishing using release pipelines
+  enablePublishUsingPipelines: false
+
+  # Optional: Enable running the source-build jobs to build repo from source
+  enableSourceBuild: false
+
+  # Optional: Parameters for source-build template.
+  #           See /eng/common/templates-official/jobs/source-build.yml for options
+  sourceBuildParameters: []
+
+  graphFileGeneration:
+    # Optional: Enable generating the graph files at the end of the build
+    enabled: false
+    # Optional: Include toolset dependencies in the generated graph files
+    includeToolset: false
+    
+  # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job
+  jobs: []
+
+  # Optional: Override automatically derived dependsOn value for "publish build assets" job
+  publishBuildAssetsDependsOn: ''
+
+  # Optional: Publish the assets as soon as the publish to BAR stage is complete, rather doing so in a separate stage.
+  publishAssetsImmediately: false
+
+  # Optional: If using publishAssetsImmediately and additional parameters are needed, can be used to send along additional parameters (normally sent to post-build.yml)
+  artifactsPublishingAdditionalParameters: ''
+  signingValidationAdditionalParameters: ''
+
+  # Optional: should run as a public build even in the internal project
+  #           if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects.
+  runAsPublic: false
+
+  enableSourceIndex: false
+  sourceIndexParams: {}
+
+# Internal resources (telemetry, microbuild) can only be accessed from non-public projects,
+# and some (Microbuild) should only be applied to non-PR cases for internal builds.
+
+jobs:
+- ${{ each job in parameters.jobs }}:
+  - template: ../job/job.yml
+    parameters: 
+      # pass along parameters
+      ${{ each parameter in parameters }}:
+        ${{ if ne(parameter.key, 'jobs') }}:
+          ${{ parameter.key }}: ${{ parameter.value }}
+
+      # pass along job properties
+      ${{ each property in job }}:
+        ${{ if ne(property.key, 'job') }}:
+          ${{ property.key }}: ${{ property.value }}
+
+      name: ${{ job.job }}
+
+- ${{ if eq(parameters.enableSourceBuild, true) }}:
+  - template: /eng/common/templates-official/jobs/source-build.yml
+    parameters:
+      allCompletedJobId: Source_Build_Complete
+      ${{ each parameter in parameters.sourceBuildParameters }}:
+        ${{ parameter.key }}: ${{ parameter.value }}
+
+- ${{ if eq(parameters.enableSourceIndex, 'true') }}:
+  - template: ../job/source-index-stage1.yml
+    parameters:
+      runAsPublic: ${{ parameters.runAsPublic }}
+      ${{ each parameter in parameters.sourceIndexParams }}:
+        ${{ parameter.key }}: ${{ parameter.value }}
+
+- ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+  - ${{ if or(eq(parameters.enablePublishBuildAssets, true), eq(parameters.artifacts.publish.manifests, 'true'), ne(parameters.artifacts.publish.manifests, '')) }}:
+    - template: ../job/publish-build-assets.yml
+      parameters:
+        continueOnError: ${{ parameters.continueOnError }}
+        dependsOn:
+        - ${{ if ne(parameters.publishBuildAssetsDependsOn, '') }}:
+          - ${{ each job in parameters.publishBuildAssetsDependsOn }}:
+            - ${{ job.job }}
+        - ${{ if eq(parameters.publishBuildAssetsDependsOn, '') }}:
+          - ${{ each job in parameters.jobs }}:
+            - ${{ job.job }}
+        - ${{ if eq(parameters.enableSourceBuild, true) }}:
+          - Source_Build_Complete
+
+        runAsPublic: ${{ parameters.runAsPublic }}
+        publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }}
+        publishAssetsImmediately: ${{ parameters.publishAssetsImmediately }}
+        enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }}
+        artifactsPublishingAdditionalParameters: ${{ parameters.artifactsPublishingAdditionalParameters }}
+        signingValidationAdditionalParameters: ${{ parameters.signingValidationAdditionalParameters }}
diff --git a/eng/common/templates-official/jobs/source-build.yml b/eng/common/templates-official/jobs/source-build.yml
new file mode 100644
index 00000000000..08e5db9bb11
--- /dev/null
+++ b/eng/common/templates-official/jobs/source-build.yml
@@ -0,0 +1,46 @@
+parameters:
+  # This template adds arcade-powered source-build to CI. A job is created for each platform, as
+  # well as an optional server job that completes when all platform jobs complete.
+
+  # The name of the "join" job for all source-build platforms. If set to empty string, the job is
+  # not included. Existing repo pipelines can use this job depend on all source-build jobs
+  # completing without maintaining a separate list of every single job ID: just depend on this one
+  # server job. By default, not included. Recommended name if used: 'Source_Build_Complete'.
+  allCompletedJobId: ''
+
+  # See /eng/common/templates-official/job/source-build.yml
+  jobNamePrefix: 'Source_Build'
+
+  # This is the default platform provided by Arcade, intended for use by a managed-only repo.
+  defaultManagedPlatform:
+    name: 'Managed'
+    container: 'mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream8'
+
+  # Defines the platforms on which to run build jobs. One job is created for each platform, and the
+  # object in this array is sent to the job template as 'platform'. If no platforms are specified,
+  # one job runs on 'defaultManagedPlatform'.
+  platforms: []
+
+jobs:
+
+- ${{ if ne(parameters.allCompletedJobId, '') }}:
+  - job: ${{ parameters.allCompletedJobId }}
+    displayName: Source-Build Complete
+    pool: server
+    dependsOn:
+    - ${{ each platform in parameters.platforms }}:
+      - ${{ parameters.jobNamePrefix }}_${{ platform.name }}
+    - ${{ if eq(length(parameters.platforms), 0) }}:
+      - ${{ parameters.jobNamePrefix }}_${{ parameters.defaultManagedPlatform.name }}
+
+- ${{ each platform in parameters.platforms }}:
+  - template: /eng/common/templates-official/job/source-build.yml
+    parameters:
+      jobNamePrefix: ${{ parameters.jobNamePrefix }}
+      platform: ${{ platform }}
+
+- ${{ if eq(length(parameters.platforms), 0) }}:
+  - template: /eng/common/templates-official/job/source-build.yml
+    parameters:
+      jobNamePrefix: ${{ parameters.jobNamePrefix }}
+      platform: ${{ parameters.defaultManagedPlatform }}
diff --git a/eng/common/templates-official/post-build/common-variables.yml b/eng/common/templates-official/post-build/common-variables.yml
new file mode 100644
index 00000000000..c24193acfc9
--- /dev/null
+++ b/eng/common/templates-official/post-build/common-variables.yml
@@ -0,0 +1,22 @@
+variables:
+  - group: Publish-Build-Assets
+
+  # Whether the build is internal or not
+  - name: IsInternalBuild
+    value: ${{ and(ne(variables['System.TeamProject'], 'public'), contains(variables['Build.SourceBranch'], 'internal')) }}
+
+  # Default Maestro++ API Endpoint and API Version
+  - name: MaestroApiEndPoint
+    value: "https://maestro-prod.westus2.cloudapp.azure.com"
+  - name: MaestroApiAccessToken
+    value: $(MaestroAccessToken)
+  - name: MaestroApiVersion
+    value: "2020-02-20"
+
+  - name: SourceLinkCLIVersion
+    value: 3.0.0
+  - name: SymbolToolVersion
+    value: 1.0.1
+
+  - name: runCodesignValidationInjection
+    value: false
diff --git a/eng/common/templates-official/post-build/post-build.yml b/eng/common/templates-official/post-build/post-build.yml
new file mode 100644
index 00000000000..5c98fe1c0f3
--- /dev/null
+++ b/eng/common/templates-official/post-build/post-build.yml
@@ -0,0 +1,285 @@
+parameters:
+  # Which publishing infra should be used. THIS SHOULD MATCH THE VERSION ON THE BUILD MANIFEST.
+  # Publishing V1 is no longer supported
+  # Publishing V2 is no longer supported
+  # Publishing V3 is the default
+  - name: publishingInfraVersion
+    displayName: Which version of publishing should be used to promote the build definition?
+    type: number
+    default: 3
+    values:
+    - 3
+
+  - name: BARBuildId
+    displayName: BAR Build Id
+    type: number
+    default: 0
+
+  - name: PromoteToChannelIds
+    displayName: Channel to promote BARBuildId to
+    type: string
+    default: ''
+
+  - name: enableSourceLinkValidation
+    displayName: Enable SourceLink validation
+    type: boolean
+    default: false
+
+  - name: enableSigningValidation
+    displayName: Enable signing validation
+    type: boolean
+    default: true
+
+  - name: enableSymbolValidation
+    displayName: Enable symbol validation
+    type: boolean
+    default: false
+
+  - name: enableNugetValidation
+    displayName: Enable NuGet validation
+    type: boolean
+    default: true
+    
+  - name: publishInstallersAndChecksums
+    displayName: Publish installers and checksums
+    type: boolean
+    default: true
+
+  - name: SDLValidationParameters
+    type: object
+    default:
+      enable: false
+      publishGdn: false
+      continueOnError: false
+      params: ''
+      artifactNames: ''
+      downloadArtifacts: true
+
+  # These parameters let the user customize the call to sdk-task.ps1 for publishing
+  # symbols & general artifacts as well as for signing validation
+  - name: symbolPublishingAdditionalParameters
+    displayName: Symbol publishing additional parameters
+    type: string
+    default: ''
+
+  - name: artifactsPublishingAdditionalParameters
+    displayName: Artifact publishing additional parameters
+    type: string
+    default: ''
+
+  - name: signingValidationAdditionalParameters
+    displayName: Signing validation additional parameters
+    type: string
+    default: ''
+
+  # Which stages should finish execution before post-build stages start
+  - name: validateDependsOn
+    type: object
+    default:
+    - build
+
+  - name: publishDependsOn
+    type: object
+    default:
+    - Validate
+
+  # Optional: Call asset publishing rather than running in a separate stage
+  - name: publishAssetsImmediately
+    type: boolean
+    default: false
+
+stages:
+- ${{ if or(eq( parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+  - stage: Validate
+    dependsOn: ${{ parameters.validateDependsOn }}
+    displayName: Validate Build Assets
+    variables:
+      - template: common-variables.yml
+      - template: /eng/common/templates-official/variables/pool-providers.yml
+    jobs:
+    - job:
+      displayName: NuGet Validation
+      condition: and(succeededOrFailed(), eq( ${{ parameters.enableNugetValidation }}, 'true'))
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Package Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: PackageArtifacts
+            checkDownloadedFiles: true
+
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/nuget-validation.ps1
+            arguments: -PackagesPath $(Build.ArtifactStagingDirectory)/PackageArtifacts/ 
+              -ToolDestinationPath $(Agent.BuildDirectory)/Extract/ 
+
+    - job:
+      displayName: Signing Validation
+      condition: and( eq( ${{ parameters.enableSigningValidation }}, 'true'), ne( variables['PostBuildSign'], 'true'))
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Package Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: PackageArtifacts
+            checkDownloadedFiles: true
+            itemPattern: |
+              **
+              !**/Microsoft.SourceBuild.Intermediate.*.nupkg
+
+        # This is necessary whenever we want to publish/restore to an AzDO private feed
+        # Since sdk-task.ps1 tries to restore packages we need to do this authentication here
+        # otherwise it'll complain about accessing a private feed.
+        - task: NuGetAuthenticate@1
+          displayName: 'Authenticate to AzDO Feeds'
+
+        # Signing validation will optionally work with the buildmanifest file which is downloaded from
+        # Azure DevOps above.
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: eng\common\sdk-task.ps1
+            arguments: -task SigningValidation -restore -msbuildEngine vs
+              /p:PackageBasePath='$(Build.ArtifactStagingDirectory)/PackageArtifacts'
+              /p:SignCheckExclusionsFile='$(Build.SourcesDirectory)/eng/SignCheckExclusionsFile.txt'
+              ${{ parameters.signingValidationAdditionalParameters }}
+
+        - template: ../steps/publish-logs.yml
+          parameters:
+            StageLabel: 'Validation'
+            JobLabel: 'Signing'
+            BinlogToolVersion: $(BinlogToolVersion)
+
+    - job:
+      displayName: SourceLink Validation
+      condition: eq( ${{ parameters.enableSourceLinkValidation }}, 'true')
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: DownloadBuildArtifacts@0
+          displayName: Download Blob Artifacts
+          inputs:
+            buildType: specific
+            buildVersionToDownload: specific
+            project: $(AzDOProjectName)
+            pipeline: $(AzDOPipelineId)
+            buildId: $(AzDOBuildId)
+            artifactName: BlobArtifacts
+            checkDownloadedFiles: true
+
+        - task: PowerShell@2
+          displayName: Validate
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/sourcelink-validation.ps1
+            arguments: -InputPath $(Build.ArtifactStagingDirectory)/BlobArtifacts/ 
+              -ExtractPath $(Agent.BuildDirectory)/Extract/ 
+              -GHRepoName $(Build.Repository.Name) 
+              -GHCommit $(Build.SourceVersion)
+              -SourcelinkCliVersion $(SourceLinkCLIVersion)
+          continueOnError: true
+
+- ${{ if ne(parameters.publishAssetsImmediately, 'true') }}:
+  - stage: publish_using_darc
+    ${{ if or(eq(parameters.enableNugetValidation, 'true'), eq(parameters.enableSigningValidation, 'true'), eq(parameters.enableSourceLinkValidation, 'true'), eq(parameters.SDLValidationParameters.enable, 'true')) }}:
+      dependsOn: ${{ parameters.publishDependsOn }}
+    ${{ else }}:
+      dependsOn: ${{ parameters.validateDependsOn }}
+    displayName: Publish using Darc
+    variables:
+      - template: common-variables.yml
+      - template: /eng/common/templates-official/variables/pool-providers.yml
+    jobs:
+    - job:
+      displayName: Publish Using Darc
+      timeoutInMinutes: 120
+      pool:
+        # We don't use the collection uri here because it might vary (.visualstudio.com vs. dev.azure.com)
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          name: AzurePipelines-EO
+          image: 1ESPT-Windows2022
+          demands: Cmd
+          os: windows
+        # If it's not devdiv, it's dnceng
+        ${{ else }}:
+          name: $(DncEngInternalBuildPool)
+          image: 1es-windows-2022-pt
+          os: windows
+      steps:
+        - template: setup-maestro-vars.yml
+          parameters:
+            BARBuildId: ${{ parameters.BARBuildId }}
+            PromoteToChannelIds: ${{ parameters.PromoteToChannelIds }}
+
+        - task: NuGetAuthenticate@1
+
+        - task: PowerShell@2
+          displayName: Publish Using Darc
+          inputs:
+            filePath: $(Build.SourcesDirectory)/eng/common/post-build/publish-using-darc.ps1
+            arguments: -BuildId $(BARBuildId) 
+              -PublishingInfraVersion ${{ parameters.publishingInfraVersion }}
+              -AzdoToken '$(publishing-dnceng-devdiv-code-r-build-re)'
+              -MaestroToken '$(MaestroApiAccessToken)'
+              -WaitPublishingFinish true
+              -ArtifactsPublishingAdditionalParameters '${{ parameters.artifactsPublishingAdditionalParameters }}'
+              -SymbolPublishingAdditionalParameters '${{ parameters.symbolPublishingAdditionalParameters }}'
diff --git a/eng/common/templates-official/post-build/setup-maestro-vars.yml b/eng/common/templates-official/post-build/setup-maestro-vars.yml
new file mode 100644
index 00000000000..0c87f149a4a
--- /dev/null
+++ b/eng/common/templates-official/post-build/setup-maestro-vars.yml
@@ -0,0 +1,70 @@
+parameters:
+  BARBuildId: ''
+  PromoteToChannelIds: ''
+
+steps:
+  - ${{ if eq(coalesce(parameters.PromoteToChannelIds, 0), 0) }}:
+    - task: DownloadBuildArtifacts@0
+      displayName: Download Release Configs
+      inputs:
+        buildType: current
+        artifactName: ReleaseConfigs
+        checkDownloadedFiles: true
+
+  - task: PowerShell@2
+    name: setReleaseVars
+    displayName: Set Release Configs Vars
+    inputs:
+      targetType: inline
+      pwsh: true
+      script: |
+        try {
+          if (!$Env:PromoteToMaestroChannels -or $Env:PromoteToMaestroChannels.Trim() -eq '') {
+            $Content = Get-Content $(Build.StagingDirectory)/ReleaseConfigs/ReleaseConfigs.txt
+
+            $BarId = $Content | Select -Index 0
+            $Channels = $Content | Select -Index 1             
+            $IsStableBuild = $Content | Select -Index 2
+
+            $AzureDevOpsProject = $Env:System_TeamProject
+            $AzureDevOpsBuildDefinitionId = $Env:System_DefinitionId
+            $AzureDevOpsBuildId = $Env:Build_BuildId
+          }
+          else {
+            $buildApiEndpoint = "${Env:MaestroApiEndPoint}/api/builds/${Env:BARBuildId}?api-version=${Env:MaestroApiVersion}"
+
+            $apiHeaders = New-Object 'System.Collections.Generic.Dictionary[[String],[String]]'
+            $apiHeaders.Add('Accept', 'application/json')
+            $apiHeaders.Add('Authorization',"Bearer ${Env:MAESTRO_API_TOKEN}")
+
+            $buildInfo = try { Invoke-WebRequest -Method Get -Uri $buildApiEndpoint -Headers $apiHeaders | ConvertFrom-Json } catch { Write-Host "Error: $_" }
+            
+            $BarId = $Env:BARBuildId
+            $Channels = $Env:PromoteToMaestroChannels -split ","
+            $Channels = $Channels -join "]["
+            $Channels = "[$Channels]"
+
+            $IsStableBuild = $buildInfo.stable
+            $AzureDevOpsProject = $buildInfo.azureDevOpsProject
+            $AzureDevOpsBuildDefinitionId = $buildInfo.azureDevOpsBuildDefinitionId
+            $AzureDevOpsBuildId = $buildInfo.azureDevOpsBuildId
+          }
+
+          Write-Host "##vso[task.setvariable variable=BARBuildId]$BarId"
+          Write-Host "##vso[task.setvariable variable=TargetChannels]$Channels"
+          Write-Host "##vso[task.setvariable variable=IsStableBuild]$IsStableBuild"
+
+          Write-Host "##vso[task.setvariable variable=AzDOProjectName]$AzureDevOpsProject"
+          Write-Host "##vso[task.setvariable variable=AzDOPipelineId]$AzureDevOpsBuildDefinitionId"
+          Write-Host "##vso[task.setvariable variable=AzDOBuildId]$AzureDevOpsBuildId"
+        }
+        catch {
+          Write-Host $_
+          Write-Host $_.Exception
+          Write-Host $_.ScriptStackTrace
+          exit 1
+        }
+    env:
+      MAESTRO_API_TOKEN: $(MaestroApiAccessToken)
+      BARBuildId: ${{ parameters.BARBuildId }}
+      PromoteToMaestroChannels: ${{ parameters.PromoteToChannelIds }}
diff --git a/eng/common/templates-official/post-build/trigger-subscription.yml b/eng/common/templates-official/post-build/trigger-subscription.yml
new file mode 100644
index 00000000000..da669030daf
--- /dev/null
+++ b/eng/common/templates-official/post-build/trigger-subscription.yml
@@ -0,0 +1,13 @@
+parameters:
+  ChannelId: 0
+
+steps:
+- task: PowerShell@2
+  displayName: Triggering subscriptions
+  inputs:
+    filePath: $(Build.SourcesDirectory)/eng/common/post-build/trigger-subscriptions.ps1
+    arguments: -SourceRepo $(Build.Repository.Uri)
+      -ChannelId ${{ parameters.ChannelId }}
+      -MaestroApiAccessToken $(MaestroAccessToken)
+      -MaestroApiEndPoint $(MaestroApiEndPoint)
+      -MaestroApiVersion $(MaestroApiVersion)
diff --git a/eng/common/templates-official/steps/add-build-to-channel.yml b/eng/common/templates-official/steps/add-build-to-channel.yml
new file mode 100644
index 00000000000..f67a210d62f
--- /dev/null
+++ b/eng/common/templates-official/steps/add-build-to-channel.yml
@@ -0,0 +1,13 @@
+parameters:
+  ChannelId: 0
+
+steps:
+- task: PowerShell@2
+  displayName: Add Build to Channel
+  inputs:
+    filePath: $(Build.SourcesDirectory)/eng/common/post-build/add-build-to-channel.ps1
+    arguments: -BuildId $(BARBuildId) 
+      -ChannelId ${{ parameters.ChannelId }}
+      -MaestroApiAccessToken $(MaestroApiAccessToken)
+      -MaestroApiEndPoint $(MaestroApiEndPoint)
+      -MaestroApiVersion $(MaestroApiVersion) 
diff --git a/eng/common/templates-official/steps/build-reason.yml b/eng/common/templates-official/steps/build-reason.yml
new file mode 100644
index 00000000000..eba58109b52
--- /dev/null
+++ b/eng/common/templates-official/steps/build-reason.yml
@@ -0,0 +1,12 @@
+# build-reason.yml
+# Description: runs steps if build.reason condition is valid.  conditions is a string of valid build reasons 
+# to include steps (',' separated).
+parameters:
+  conditions: ''
+  steps: []
+
+steps:
+  - ${{ if and( not(startsWith(parameters.conditions, 'not')), contains(parameters.conditions, variables['build.reason'])) }}:
+    - ${{ parameters.steps }}
+  - ${{ if and( startsWith(parameters.conditions, 'not'), not(contains(parameters.conditions, variables['build.reason']))) }}:
+    - ${{ parameters.steps }}
diff --git a/eng/common/templates-official/steps/component-governance.yml b/eng/common/templates-official/steps/component-governance.yml
new file mode 100644
index 00000000000..0ecec47b0c9
--- /dev/null
+++ b/eng/common/templates-official/steps/component-governance.yml
@@ -0,0 +1,13 @@
+parameters:
+  disableComponentGovernance: false
+  componentGovernanceIgnoreDirectories: ''
+
+steps:
+- ${{ if eq(parameters.disableComponentGovernance, 'true') }}:
+  - script: "echo ##vso[task.setvariable variable=skipComponentGovernanceDetection]true"
+    displayName: Set skipComponentGovernanceDetection variable
+- ${{ if ne(parameters.disableComponentGovernance, 'true') }}:
+  - task: ComponentGovernanceComponentDetection@0
+    continueOnError: true
+    inputs:
+      ignoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }}
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/execute-codeql.yml b/eng/common/templates-official/steps/execute-codeql.yml
new file mode 100644
index 00000000000..9b4a5ffa30a
--- /dev/null
+++ b/eng/common/templates-official/steps/execute-codeql.yml
@@ -0,0 +1,32 @@
+parameters:
+  # Language that should be analyzed. Defaults to csharp
+  language: csharp
+  # Build Commands
+  buildCommands: ''
+  overrideParameters: ''                                       # Optional: to override values for parameters.
+  additionalParameters: ''                                     # Optional: parameters that need user specific values eg: '-SourceToolsList @("abc","def") -ArtifactToolsList @("ghi","jkl")'
+  # Optional: if specified, restore and use this version of Guardian instead of the default.
+  overrideGuardianVersion: ''
+  # Optional: if true, publish the '.gdn' folder as a pipeline artifact. This can help with in-depth
+  # diagnosis of problems with specific tool configurations.
+  publishGuardianDirectoryToPipeline: false
+  # The script to run to execute all SDL tools. Use this if you want to use a script to define SDL
+  # parameters rather than relying on YAML. It may be better to use a local script, because you can
+  # reproduce results locally without piecing together a command based on the YAML.
+  executeAllSdlToolsScript: 'eng/common/sdl/execute-all-sdl-tools.ps1'
+  # There is some sort of bug (has been reported) in Azure DevOps where if this parameter is named
+  # 'continueOnError', the parameter value is not correctly picked up.
+  # This can also be remedied by the caller (post-build.yml) if it does not use a nested parameter
+  # optional: determines whether to continue the build if the step errors;
+  sdlContinueOnError: false
+
+steps:
+- template: /eng/common/templates-official/steps/execute-sdl.yml
+  parameters:
+    overrideGuardianVersion: ${{ parameters.overrideGuardianVersion }}
+    executeAllSdlToolsScript: ${{ parameters.executeAllSdlToolsScript }}
+    overrideParameters: ${{ parameters.overrideParameters }}
+    additionalParameters: '${{ parameters.additionalParameters }}
+      -CodeQLAdditionalRunConfigParams @("BuildCommands < ${{ parameters.buildCommands }}", "Language < ${{ parameters.language }}")'
+    publishGuardianDirectoryToPipeline: ${{ parameters.publishGuardianDirectoryToPipeline }}
+    sdlContinueOnError: ${{ parameters.sdlContinueOnError }}
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/execute-sdl.yml b/eng/common/templates-official/steps/execute-sdl.yml
new file mode 100644
index 00000000000..07426fde05d
--- /dev/null
+++ b/eng/common/templates-official/steps/execute-sdl.yml
@@ -0,0 +1,88 @@
+parameters:
+  overrideGuardianVersion: ''
+  executeAllSdlToolsScript: ''
+  overrideParameters: ''
+  additionalParameters: ''
+  publishGuardianDirectoryToPipeline: false
+  sdlContinueOnError: false
+  condition: ''
+
+steps:
+- task: NuGetAuthenticate@1
+  inputs:
+    nuGetServiceConnections: GuardianConnect
+
+- task: NuGetToolInstaller@1
+  displayName: 'Install NuGet.exe'
+  
+- ${{ if ne(parameters.overrideGuardianVersion, '') }}:
+  - pwsh: |
+      Set-Location -Path $(Build.SourcesDirectory)\eng\common\sdl
+      . .\sdl.ps1
+      $guardianCliLocation = Install-Gdn -Path $(Build.SourcesDirectory)\.artifacts -Version ${{ parameters.overrideGuardianVersion }}
+      Write-Host "##vso[task.setvariable variable=GuardianCliLocation]$guardianCliLocation"
+    displayName: Install Guardian (Overridden)
+
+- ${{ if eq(parameters.overrideGuardianVersion, '') }}:
+  - pwsh: |
+      Set-Location -Path $(Build.SourcesDirectory)\eng\common\sdl
+      . .\sdl.ps1
+      $guardianCliLocation = Install-Gdn -Path $(Build.SourcesDirectory)\.artifacts
+      Write-Host "##vso[task.setvariable variable=GuardianCliLocation]$guardianCliLocation"
+    displayName: Install Guardian
+
+- ${{ if ne(parameters.overrideParameters, '') }}:
+  - powershell: ${{ parameters.executeAllSdlToolsScript }} ${{ parameters.overrideParameters }}
+    displayName: Execute SDL (Overridden)
+    continueOnError: ${{ parameters.sdlContinueOnError }}
+    condition: ${{ parameters.condition }}
+
+- ${{ if eq(parameters.overrideParameters, '') }}:
+  - powershell: ${{ parameters.executeAllSdlToolsScript }}
+      -GuardianCliLocation $(GuardianCliLocation)
+      -NugetPackageDirectory $(Build.SourcesDirectory)\.packages
+      -AzureDevOpsAccessToken $(dn-bot-dotnet-build-rw-code-rw)
+      ${{ parameters.additionalParameters }}
+    displayName: Execute SDL
+    continueOnError: ${{ parameters.sdlContinueOnError }}
+    condition: ${{ parameters.condition }}
+
+- ${{ if ne(parameters.publishGuardianDirectoryToPipeline, 'false') }}:
+  # We want to publish the Guardian results and configuration for easy diagnosis. However, the
+  # '.gdn' dir is a mix of configuration, results, extracted dependencies, and Guardian default
+  # tooling files. Some of these files are large and aren't useful during an investigation, so
+  # exclude them by simply deleting them before publishing. (As of writing, there is no documented
+  # way to selectively exclude a dir from the pipeline artifact publish task.)
+  - task: DeleteFiles@1
+    displayName: Delete Guardian dependencies to avoid uploading
+    inputs:
+      SourceFolder: $(Agent.BuildDirectory)/.gdn
+      Contents: |
+        c
+        i
+    condition: succeededOrFailed()
+
+  - publish: $(Agent.BuildDirectory)/.gdn
+    artifact: GuardianConfiguration
+    displayName: Publish GuardianConfiguration
+    condition: succeededOrFailed()
+
+  # Publish the SARIF files in a container named CodeAnalysisLogs to enable integration
+  # with the "SARIF SAST Scans Tab" Azure DevOps extension
+  - task: CopyFiles@2
+    displayName: Copy SARIF files
+    inputs:
+      flattenFolders: true
+      sourceFolder:  $(Agent.BuildDirectory)/.gdn/rc/
+      contents: '**/*.sarif'
+      targetFolder: $(Build.SourcesDirectory)/CodeAnalysisLogs
+    condition: succeededOrFailed()
+
+  # Use PublishBuildArtifacts because the SARIF extension only checks this case
+  # see microsoft/sarif-azuredevops-extension#4
+  - task: PublishBuildArtifacts@1
+    displayName: Publish SARIF files to CodeAnalysisLogs container
+    inputs:
+      pathToPublish:  $(Build.SourcesDirectory)/CodeAnalysisLogs
+      artifactName: CodeAnalysisLogs
+    condition: succeededOrFailed()
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/generate-sbom.yml b/eng/common/templates-official/steps/generate-sbom.yml
new file mode 100644
index 00000000000..1bf43bf807a
--- /dev/null
+++ b/eng/common/templates-official/steps/generate-sbom.yml
@@ -0,0 +1,48 @@
+# BuildDropPath - The root folder of the drop directory for which the manifest file will be generated.
+# PackageName - The name of the package this SBOM represents.
+# PackageVersion - The version of the package this SBOM represents. 
+# ManifestDirPath - The path of the directory where the generated manifest files will be placed
+# IgnoreDirectories - Directories to ignore for SBOM generation. This will be passed through to the CG component detector.
+
+parameters:
+  PackageVersion: 8.0.0
+  BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
+  PackageName: '.NET'
+  ManifestDirPath: $(Build.ArtifactStagingDirectory)/sbom
+  IgnoreDirectories: ''
+  sbomContinueOnError: true
+
+steps:
+- task: PowerShell@2 
+  displayName: Prep for SBOM generation in (Non-linux)
+  condition: or(eq(variables['Agent.Os'], 'Windows_NT'), eq(variables['Agent.Os'], 'Darwin'))
+  inputs: 
+    filePath: ./eng/common/generate-sbom-prep.ps1
+    arguments: ${{parameters.manifestDirPath}}
+
+# Chmodding is a workaround for https://github.com/dotnet/arcade/issues/8461
+- script: |
+    chmod +x ./eng/common/generate-sbom-prep.sh
+    ./eng/common/generate-sbom-prep.sh ${{parameters.manifestDirPath}}
+  displayName: Prep for SBOM generation in (Linux)
+  condition: eq(variables['Agent.Os'], 'Linux')
+  continueOnError: ${{ parameters.sbomContinueOnError }}
+
+- task: AzureArtifacts.manifest-generator-task.manifest-generator-task.ManifestGeneratorTask@0
+  displayName: 'Generate SBOM manifest'
+  continueOnError: ${{ parameters.sbomContinueOnError }}
+  inputs:
+      PackageName: ${{ parameters.packageName }}
+      BuildDropPath: ${{ parameters.buildDropPath }}
+      PackageVersion: ${{ parameters.packageVersion }}
+      ManifestDirPath: ${{ parameters.manifestDirPath }}
+      ${{ if ne(parameters.IgnoreDirectories, '') }}:
+        AdditionalComponentDetectorArgs: '--IgnoreDirectories ${{ parameters.IgnoreDirectories }}'
+
+- task: 1ES.PublishPipelineArtifact@1
+  displayName: Publish SBOM manifest
+  continueOnError: ${{parameters.sbomContinueOnError}}
+  inputs:
+    targetPath: '${{parameters.manifestDirPath}}'
+    artifactName: $(ARTIFACT_NAME)
+
diff --git a/eng/common/templates-official/steps/publish-logs.yml b/eng/common/templates-official/steps/publish-logs.yml
new file mode 100644
index 00000000000..04012fed182
--- /dev/null
+++ b/eng/common/templates-official/steps/publish-logs.yml
@@ -0,0 +1,23 @@
+parameters:
+  StageLabel: ''
+  JobLabel: ''
+
+steps:
+- task: Powershell@2
+  displayName: Prepare Binlogs to Upload
+  inputs:
+    targetType: inline
+    script: |
+      New-Item -ItemType Directory $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+      Move-Item -Path $(Build.SourcesDirectory)/artifacts/log/Debug/* $(Build.SourcesDirectory)/PostBuildLogs/${{parameters.StageLabel}}/${{parameters.JobLabel}}/
+  continueOnError: true
+  condition: always()
+
+- task: 1ES.PublishBuildArtifacts@1
+  displayName: Publish Logs
+  inputs:
+    PathtoPublish: '$(Build.SourcesDirectory)/PostBuildLogs'
+    PublishLocation: Container
+    ArtifactName: PostBuildLogs
+  continueOnError: true
+  condition: always()
diff --git a/eng/common/templates-official/steps/retain-build.yml b/eng/common/templates-official/steps/retain-build.yml
new file mode 100644
index 00000000000..83d97a26a01
--- /dev/null
+++ b/eng/common/templates-official/steps/retain-build.yml
@@ -0,0 +1,28 @@
+parameters:
+  # Optional azure devops PAT with build execute permissions for the build's organization,
+  # only needed if the build that should be retained ran on a different organization than 
+  # the pipeline where this template is executing from
+  Token: ''
+  # Optional BuildId to retain, defaults to the current running build
+  BuildId: ''
+  # Azure devops Organization URI for the build in the https://dev.azure.com/<organization> format.
+  # Defaults to the organization the current pipeline is running on
+  AzdoOrgUri: '$(System.CollectionUri)'
+  # Azure devops project for the build. Defaults to the project the current pipeline is running on
+  AzdoProject: '$(System.TeamProject)'
+
+steps:
+  - task: powershell@2
+    inputs:
+      targetType: 'filePath'
+      filePath: eng/common/retain-build.ps1
+      pwsh: true
+      arguments: >
+        -AzdoOrgUri: ${{parameters.AzdoOrgUri}}
+        -AzdoProject ${{parameters.AzdoProject}}
+        -Token ${{coalesce(parameters.Token, '$env:SYSTEM_ACCESSTOKEN') }}
+        -BuildId ${{coalesce(parameters.BuildId, '$env:BUILD_ID')}}
+    displayName: Enable permanent build retention
+    env:
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+      BUILD_ID: $(Build.BuildId)
\ No newline at end of file
diff --git a/eng/common/templates-official/steps/send-to-helix.yml b/eng/common/templates-official/steps/send-to-helix.yml
new file mode 100644
index 00000000000..3eb7e2d5f84
--- /dev/null
+++ b/eng/common/templates-official/steps/send-to-helix.yml
@@ -0,0 +1,91 @@
+# Please remember to update the documentation if you make changes to these parameters!
+parameters:
+  HelixSource: 'pr/default'              # required -- sources must start with pr/, official/, prodcon/, or agent/
+  HelixType: 'tests/default/'            # required -- Helix telemetry which identifies what type of data this is; should include "test" for clarity and must end in '/'
+  HelixBuild: $(Build.BuildNumber)       # required -- the build number Helix will use to identify this -- automatically set to the AzDO build number
+  HelixTargetQueues: ''                  # required -- semicolon-delimited list of Helix queues to test on; see https://helix.dot.net/ for a list of queues
+  HelixAccessToken: ''                   # required -- access token to make Helix API requests; should be provided by the appropriate variable group
+  HelixConfiguration: ''                 # optional -- additional property attached to a job
+  HelixPreCommands: ''                   # optional -- commands to run before Helix work item execution
+  HelixPostCommands: ''                  # optional -- commands to run after Helix work item execution
+  WorkItemDirectory: ''                  # optional -- a payload directory to zip up and send to Helix; requires WorkItemCommand; incompatible with XUnitProjects
+  WorkItemCommand: ''                    # optional -- a command to execute on the payload; requires WorkItemDirectory; incompatible with XUnitProjects
+  WorkItemTimeout: ''                    # optional -- a timeout in TimeSpan.Parse-ready value (e.g. 00:02:00) for the work item command; requires WorkItemDirectory; incompatible with XUnitProjects
+  CorrelationPayloadDirectory: ''        # optional -- a directory to zip up and send to Helix as a correlation payload
+  XUnitProjects: ''                      # optional -- semicolon-delimited list of XUnitProjects to parse and send to Helix; requires XUnitRuntimeTargetFramework, XUnitPublishTargetFramework, XUnitRunnerVersion, and IncludeDotNetCli=true
+  XUnitWorkItemTimeout: ''               # optional -- the workitem timeout in seconds for all workitems created from the xUnit projects specified by XUnitProjects
+  XUnitPublishTargetFramework: ''        # optional -- framework to use to publish your xUnit projects
+  XUnitRuntimeTargetFramework: ''        # optional -- framework to use for the xUnit console runner
+  XUnitRunnerVersion: ''                 # optional -- version of the xUnit nuget package you wish to use on Helix; required for XUnitProjects
+  IncludeDotNetCli: false                # optional -- true will download a version of the .NET CLI onto the Helix machine as a correlation payload; requires DotNetCliPackageType and DotNetCliVersion
+  DotNetCliPackageType: ''               # optional -- either 'sdk', 'runtime' or 'aspnetcore-runtime'; determines whether the sdk or runtime will be sent to Helix; see https://raw.githubusercontent.com/dotnet/core/main/release-notes/releases-index.json
+  DotNetCliVersion: ''                   # optional -- version of the CLI to send to Helix; based on this: https://raw.githubusercontent.com/dotnet/core/main/release-notes/releases-index.json
+  WaitForWorkItemCompletion: true        # optional -- true will make the task wait until work items have been completed and fail the build if work items fail. False is "fire and forget."
+  IsExternal: false                      # [DEPRECATED] -- doesn't do anything, jobs are external if HelixAccessToken is empty and Creator is set
+  HelixBaseUri: 'https://helix.dot.net/' # optional -- sets the Helix API base URI (allows targeting https://helix.int-dot.net )
+  Creator: ''                            # optional -- if the build is external, use this to specify who is sending the job
+  DisplayNamePrefix: 'Run Tests'         # optional -- rename the beginning of the displayName of the steps in AzDO 
+  condition: succeeded()                 # optional -- condition for step to execute; defaults to succeeded()
+  continueOnError: false                 # optional -- determines whether to continue the build if the step errors; defaults to false
+
+steps:
+  - powershell: 'powershell "$env:BUILD_SOURCESDIRECTORY\eng\common\msbuild.ps1 $env:BUILD_SOURCESDIRECTORY\eng\common\helixpublish.proj /restore /p:TreatWarningsAsErrors=false /t:Test /bl:$env:BUILD_SOURCESDIRECTORY\artifacts\log\$env:BuildConfig\SendToHelix.binlog"'
+    displayName: ${{ parameters.DisplayNamePrefix }} (Windows)
+    env:
+      BuildConfig: $(_BuildConfig)
+      HelixSource: ${{ parameters.HelixSource }}
+      HelixType: ${{ parameters.HelixType }}
+      HelixBuild: ${{ parameters.HelixBuild }}
+      HelixConfiguration:  ${{ parameters.HelixConfiguration }}
+      HelixTargetQueues: ${{ parameters.HelixTargetQueues }}
+      HelixAccessToken: ${{ parameters.HelixAccessToken }}
+      HelixPreCommands: ${{ parameters.HelixPreCommands }}
+      HelixPostCommands: ${{ parameters.HelixPostCommands }}
+      WorkItemDirectory: ${{ parameters.WorkItemDirectory }}
+      WorkItemCommand: ${{ parameters.WorkItemCommand }}
+      WorkItemTimeout: ${{ parameters.WorkItemTimeout }}
+      CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }}
+      XUnitProjects: ${{ parameters.XUnitProjects }}
+      XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }}
+      XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }}
+      XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }}
+      XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }}
+      IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }}
+      DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }}
+      DotNetCliVersion: ${{ parameters.DotNetCliVersion }}
+      WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }}
+      HelixBaseUri: ${{ parameters.HelixBaseUri }}
+      Creator: ${{ parameters.Creator }}
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    condition: and(${{ parameters.condition }}, eq(variables['Agent.Os'], 'Windows_NT'))
+    continueOnError: ${{ parameters.continueOnError }}
+  - script: $BUILD_SOURCESDIRECTORY/eng/common/msbuild.sh $BUILD_SOURCESDIRECTORY/eng/common/helixpublish.proj /restore /p:TreatWarningsAsErrors=false /t:Test /bl:$BUILD_SOURCESDIRECTORY/artifacts/log/$BuildConfig/SendToHelix.binlog
+    displayName: ${{ parameters.DisplayNamePrefix }} (Unix)
+    env:
+      BuildConfig: $(_BuildConfig)
+      HelixSource: ${{ parameters.HelixSource }}
+      HelixType: ${{ parameters.HelixType }}
+      HelixBuild: ${{ parameters.HelixBuild }}
+      HelixConfiguration:  ${{ parameters.HelixConfiguration }}
+      HelixTargetQueues: ${{ parameters.HelixTargetQueues }}
+      HelixAccessToken: ${{ parameters.HelixAccessToken }}
+      HelixPreCommands: ${{ parameters.HelixPreCommands }}
+      HelixPostCommands: ${{ parameters.HelixPostCommands }}
+      WorkItemDirectory: ${{ parameters.WorkItemDirectory }}
+      WorkItemCommand: ${{ parameters.WorkItemCommand }}
+      WorkItemTimeout: ${{ parameters.WorkItemTimeout }}
+      CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }}
+      XUnitProjects: ${{ parameters.XUnitProjects }}
+      XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }}
+      XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }}
+      XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }}
+      XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }}
+      IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }}
+      DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }}
+      DotNetCliVersion: ${{ parameters.DotNetCliVersion }}
+      WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }}
+      HelixBaseUri: ${{ parameters.HelixBaseUri }}
+      Creator: ${{ parameters.Creator }}
+      SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+    condition: and(${{ parameters.condition }}, ne(variables['Agent.Os'], 'Windows_NT'))
+    continueOnError: ${{ parameters.continueOnError }}
diff --git a/eng/common/templates-official/steps/source-build.yml b/eng/common/templates-official/steps/source-build.yml
new file mode 100644
index 00000000000..829f17c34d1
--- /dev/null
+++ b/eng/common/templates-official/steps/source-build.yml
@@ -0,0 +1,129 @@
+parameters:
+  # This template adds arcade-powered source-build to CI.
+
+  # This is a 'steps' template, and is intended for advanced scenarios where the existing build
+  # infra has a careful build methodology that must be followed. For example, a repo
+  # (dotnet/runtime) might choose to clone the GitHub repo only once and store it as a pipeline
+  # artifact for all subsequent jobs to use, to reduce dependence on a strong network connection to
+  # GitHub. Using this steps template leaves room for that infra to be included.
+
+  # Defines the platform on which to run the steps. See 'eng/common/templates-official/job/source-build.yml'
+  # for details. The entire object is described in the 'job' template for simplicity, even though
+  # the usage of the properties on this object is split between the 'job' and 'steps' templates.
+  platform: {}
+
+steps:
+# Build. Keep it self-contained for simple reusability. (No source-build-specific job variables.)
+- script: |
+    set -x
+    df -h
+
+    # If building on the internal project, the artifact feeds variable may be available (usually only if needed)
+    # In that case, call the feed setup script to add internal feeds corresponding to public ones.
+    # In addition, add an msbuild argument to copy the WIP from the repo to the target build location.
+    # This is because SetupNuGetSources.sh will alter the current NuGet.config file, and we need to preserve those
+    # changes.
+    internalRestoreArgs=
+    if [ '$(dn-bot-dnceng-artifact-feeds-rw)' != '$''(dn-bot-dnceng-artifact-feeds-rw)' ]; then
+      # Temporarily work around https://github.com/dotnet/arcade/issues/7709
+      chmod +x $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh
+      $(Build.SourcesDirectory)/eng/common/SetupNugetSources.sh $(Build.SourcesDirectory)/NuGet.config $(dn-bot-dnceng-artifact-feeds-rw)
+      internalRestoreArgs='/p:CopyWipIntoInnerSourceBuildRepo=true'
+
+      # The 'Copy WIP' feature of source build uses git stash to apply changes from the original repo.
+      # This only works if there is a username/email configured, which won't be the case in most CI runs.
+      git config --get user.email
+      if [ $? -ne 0 ]; then
+        git config user.email dn-bot@microsoft.com
+        git config user.name dn-bot
+      fi
+    fi
+
+    # If building on the internal project, the internal storage variable may be available (usually only if needed)
+    # In that case, add variables to allow the download of internal runtimes if the specified versions are not found
+    # in the default public locations.
+    internalRuntimeDownloadArgs=
+    if [ '$(dotnetbuilds-internal-container-read-token-base64)' != '$''(dotnetbuilds-internal-container-read-token-base64)' ]; then
+      internalRuntimeDownloadArgs='/p:DotNetRuntimeSourceFeed=https://dotnetbuilds.blob.core.windows.net/internal /p:DotNetRuntimeSourceFeedKey=$(dotnetbuilds-internal-container-read-token-base64) --runtimesourcefeed https://dotnetbuilds.blob.core.windows.net/internal --runtimesourcefeedkey $(dotnetbuilds-internal-container-read-token-base64)'
+    fi
+
+    buildConfig=Release
+    # Check if AzDO substitutes in a build config from a variable, and use it if so.
+    if [ '$(_BuildConfig)' != '$''(_BuildConfig)' ]; then
+      buildConfig='$(_BuildConfig)'
+    fi
+
+    officialBuildArgs=
+    if [ '${{ and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}' = 'True' ]; then
+      officialBuildArgs='/p:DotNetPublishUsingPipelines=true /p:OfficialBuildId=$(BUILD.BUILDNUMBER)'
+    fi
+
+    targetRidArgs=
+    if [ '${{ parameters.platform.targetRID }}' != '' ]; then
+      targetRidArgs='/p:TargetRid=${{ parameters.platform.targetRID }}'
+    fi
+
+    runtimeOsArgs=
+    if [ '${{ parameters.platform.runtimeOS }}' != '' ]; then
+      runtimeOsArgs='/p:RuntimeOS=${{ parameters.platform.runtimeOS }}'
+    fi
+
+    baseOsArgs=
+    if [ '${{ parameters.platform.baseOS }}' != '' ]; then
+      baseOsArgs='/p:BaseOS=${{ parameters.platform.baseOS }}'
+    fi
+
+    publishArgs=
+    if [ '${{ parameters.platform.skipPublishValidation }}' != 'true' ]; then
+      publishArgs='--publish'
+    fi
+
+    assetManifestFileName=SourceBuild_RidSpecific.xml
+    if [ '${{ parameters.platform.name }}' != '' ]; then
+      assetManifestFileName=SourceBuild_${{ parameters.platform.name }}.xml
+    fi
+
+    ${{ coalesce(parameters.platform.buildScript, './build.sh') }} --ci \
+      --configuration $buildConfig \
+      --restore --build --pack $publishArgs -bl \
+      $officialBuildArgs \
+      $internalRuntimeDownloadArgs \
+      $internalRestoreArgs \
+      $targetRidArgs \
+      $runtimeOsArgs \
+      $baseOsArgs \
+      /p:SourceBuildNonPortable=${{ parameters.platform.nonPortable }} \
+      /p:ArcadeBuildFromSource=true \
+      /p:AssetManifestFileName=$assetManifestFileName
+  displayName: Build
+
+# Upload build logs for diagnosis.
+- task: CopyFiles@2
+  displayName: Prepare BuildLogs staging directory
+  inputs:
+    SourceFolder: '$(Build.SourcesDirectory)'
+    Contents: |
+      **/*.log
+      **/*.binlog
+      artifacts/source-build/self/prebuilt-report/**
+    TargetFolder: '$(Build.StagingDirectory)/BuildLogs'
+    CleanTargetFolder: true
+  continueOnError: true
+  condition: succeededOrFailed()
+
+- task: 1ES.PublishPipelineArtifact@1
+  displayName: Publish BuildLogs
+  inputs:
+    targetPath: '$(Build.StagingDirectory)/BuildLogs'
+    artifactName: BuildLogs_SourceBuild_${{ parameters.platform.name }}_Attempt$(System.JobAttempt)
+  continueOnError: true
+  condition: succeededOrFailed()
+
+# Manually inject component detection so that we can ignore the source build upstream cache, which contains
+# a nupkg cache of input packages (a local feed).
+# This path must match the upstream cache path in property 'CurrentRepoSourceBuiltNupkgCacheDir'
+# in src\Microsoft.DotNet.Arcade.Sdk\tools\SourceBuild\SourceBuildArcade.targets
+- task: ComponentGovernanceComponentDetection@0
+  displayName: Component Detection (Exclude upstream cache)
+  inputs:
+    ignoreDirectories: '$(Build.SourcesDirectory)/artifacts/source-build/self/src/artifacts/obj/source-built-upstream-cache'
diff --git a/eng/common/templates-official/variables/pool-providers.yml b/eng/common/templates-official/variables/pool-providers.yml
new file mode 100644
index 00000000000..beab7d1bfba
--- /dev/null
+++ b/eng/common/templates-official/variables/pool-providers.yml
@@ -0,0 +1,45 @@
+# Select a pool provider based off branch name. Anything with branch name containing 'release' must go into an -Svc pool, 
+# otherwise it should go into the "normal" pools. This separates out the queueing and billing of released branches.
+
+# Motivation: 
+#   Once a given branch of a repository's output has been officially "shipped" once, it is then considered to be COGS
+#   (Cost of goods sold) and should be moved to a servicing pool provider. This allows both separation of queueing
+#   (allowing release builds and main PR builds to not intefere with each other) and billing (required for COGS.
+#   Additionally, the pool provider name itself may be subject to change when the .NET Core Engineering Services 
+#   team needs to move resources around and create new and potentially differently-named pools. Using this template 
+#   file from an Arcade-ified repo helps guard against both having to update one's release/* branches and renaming.
+
+# How to use: 
+#  This yaml assumes your shipped product branches use the naming convention "release/..." (which many do).
+#  If we find alternate naming conventions in broad usage it can be added to the condition below.
+#
+#  First, import the template in an arcade-ified repo to pick up the variables, e.g.:
+#
+#  variables:
+#  - template: /eng/common/templates-official/variables/pool-providers.yml
+#
+#  ... then anywhere specifying the pool provider use the runtime variables,
+#      $(DncEngInternalBuildPool)
+#
+#        pool:
+#           name: $(DncEngInternalBuildPool)
+#           image: 1es-windows-2022-pt
+
+variables:
+  # Coalesce the target and source branches so we know when a PR targets a release branch
+  # If these variables are somehow missing, fall back to main (tends to have more capacity)
+
+  # Any new -Svc alternative pools should have variables added here to allow for splitting work
+
+  - name: DncEngInternalBuildPool
+    value: $[
+        replace(
+          replace(
+            eq(contains(coalesce(variables['System.PullRequest.TargetBranch'], variables['Build.SourceBranch'], 'refs/heads/main'), 'release'), 'true'),
+            True,
+            'NetCore1ESPool-Svc-Internal'
+          ),
+          False,
+          'NetCore1ESPool-Internal'
+        )
+      ]
\ No newline at end of file
diff --git a/eng/common/templates-official/variables/sdl-variables.yml b/eng/common/templates-official/variables/sdl-variables.yml
new file mode 100644
index 00000000000..dbdd66d4a4b
--- /dev/null
+++ b/eng/common/templates-official/variables/sdl-variables.yml
@@ -0,0 +1,7 @@
+variables:
+# The Guardian version specified in 'eng/common/sdl/packages.config'. This value must be kept in
+# sync with the packages.config file.
+- name: DefaultGuardianVersion
+  value: 0.109.0
+- name: GuardianPackagesConfigFile
+  value: $(Build.SourcesDirectory)\eng\common\sdl\packages.config
\ No newline at end of file
diff --git a/eng/common/templates/job/job.yml b/eng/common/templates/job/job.yml
index e24ca2f46f9..8ec5c4f2d9f 100644
--- a/eng/common/templates/job/job.yml
+++ b/eng/common/templates/job/job.yml
@@ -15,6 +15,7 @@ parameters:
   timeoutInMinutes: ''
   variables: []
   workspace: ''
+  templateContext: ''
 
 # Job base template specific parameters
   # See schema documentation - https://github.com/dotnet/arcade/blob/master/Documentation/AzureDevOps/TemplateSchema.md
@@ -68,6 +69,9 @@ jobs:
   ${{ if ne(parameters.timeoutInMinutes, '') }}:
     timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
 
+  ${{ if ne(parameters.templateContext, '') }}:
+    templateContext: ${{ parameters.templateContext }}
+
   variables:
   - ${{ if ne(parameters.enableTelemetry, 'false') }}:
     - name: DOTNET_CLI_TELEMETRY_PROFILE
diff --git a/eng/common/templates/steps/generate-sbom.yml b/eng/common/templates/steps/generate-sbom.yml
index a06373f38fa..2b21eae4273 100644
--- a/eng/common/templates/steps/generate-sbom.yml
+++ b/eng/common/templates/steps/generate-sbom.yml
@@ -5,7 +5,7 @@
 # IgnoreDirectories - Directories to ignore for SBOM generation. This will be passed through to the CG component detector.
 
 parameters:
-  PackageVersion: 7.0.0
+  PackageVersion: 8.0.0
   BuildDropPath: '$(Build.SourcesDirectory)/artifacts'
   PackageName: '.NET'
   ManifestDirPath: $(Build.ArtifactStagingDirectory)/sbom
diff --git a/eng/packageContent.targets b/eng/packageContent.targets
index 15ab175e45f..3bae9d4bd4a 100644
--- a/eng/packageContent.targets
+++ b/eng/packageContent.targets
@@ -42,7 +42,7 @@
 
     <PropertyGroup>
       <!-- The intellisense provided by the Docs system -->
-      <IntellisenseXmlFileSource>$([MSBuild]::NormalizePath('$(_DotnetApiDocsFilesRoot)', '$(AssemblyName).xml'))</IntellisenseXmlFileSource>
+      <IntellisenseXmlFileSource>$([MSBuild]::NormalizePath('$(_DotnetApiDocsFilesRoot)', 'System.Windows.Forms.xml'))</IntellisenseXmlFileSource>
 
       <!-- Set the xml destination (for a later step that copies files from the $(_DotnetApiDocsPackageName) package to local build artifacts) -->
       <IntellisenseXmlDest Condition="'$(ProduceReferenceAssembly)' == 'true' And '$(PackageAsRefAndLib)' != 'true'" >$([System.IO.Path]::ChangeExtension('$(TargetRefPath)', '.xml'))</IntellisenseXmlDest>
@@ -56,9 +56,9 @@
       This means we build a real assembly that has no associated official intellisense docs.
       Contact the intellisense team for guidance.
     -->
-    <Error  Condition="!Exists('$(IntellisenseXmlFileSource)') and '$(IsFacadeAssembly)' != 'true' and '$(IsAnalyzerProject)' != 'true'" 
+    <!--<Error  Condition="!Exists('$(IntellisenseXmlFileSource)') and '$(IsFacadeAssembly)' != 'true' and '$(IsAnalyzerProject)' != 'true'" 
             Text="$(AssemblyName).xml was not found in $(_DotnetApiDocsPackageName) package. Contact the intellisense team about adding the docs for this assembly."
-    />
+    />> -->
 
     <ItemGroup>
       <PackageFile Include="$(TargetPath)" PackagePath="$(PackagePath)" />
diff --git a/eng/pipelines/build-PR.yml b/eng/pipelines/build-PR.yml
new file mode 100644
index 00000000000..ac8d2fa3f02
--- /dev/null
+++ b/eng/pipelines/build-PR.yml
@@ -0,0 +1,154 @@
+parameters:
+  name: ''
+  targetArchitecture: null
+  timeoutInMinutes: 120
+  enableMicrobuild: true
+  enablePublishBuildArtifacts: true
+  enablePublishTestResults: true
+  enablePublishBuildAssets: true
+  enablePublishUsingPipelines: true
+
+jobs:
+  - job: ${{ parameters.name }}
+    displayName: ${{ parameters.name }}
+    timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+    variables:
+    - template: /eng/common/templates/variables/pool-providers.yml
+    pool:
+      ${{ if eq(variables['System.TeamProject'], 'public') }}:
+        name: $(DncEngPublicBuildPool)
+        demands: ImageOverride -equals windows.vs2022preview.amd64.open
+      ${{ if ne(variables['System.TeamProject'], 'public') }}:
+        name: $(DncEngInternalBuildPool)
+        demands: ImageOverride -equals windows.vs2022preview.amd64
+    strategy:
+      matrix:
+        ${{ if or(eq(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'PullRequest')) }}:
+          Debug:
+            _BuildConfig: Debug
+            # override some variables for debug
+            _SignType: test
+            # Code coverage uploads fail on internal PRs
+            ${{ if eq(variables['System.TeamProject'], 'public') }}:
+              _Coverage: false
+        Release:
+          _BuildConfig: Release
+          _Coverage: false
+    workspace:
+      clean: all
+
+    steps:
+    - checkout: self
+      clean: true
+
+    - ${{ if ne(variables['System.TeamProject'], 'public') }}:
+      - task: PowerShell@2
+        displayName: Setup Private Feeds Credentials
+        inputs:
+          filePath: $(Build.SourcesDirectory)/eng/common/SetupNugetSources.ps1
+          arguments: -ConfigFile $(Build.SourcesDirectory)/NuGet.config -Password $Env:Token
+        env:
+          Token: $(dn-bot-dnceng-artifact-feeds-rw)
+
+      - task: MicroBuildSigningPlugin@2
+        displayName: Install MicroBuild plugin for Signing
+        inputs:
+          signType: $(_SignType)
+          zipSources: false
+          feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+        continueOnError: false
+        condition: and(succeeded(), 
+                       in(variables['_SignType'], 'real', 'test'))
+    # NuGet's http cache lasts 30 minutes. If we're on a static machine, this may interfere with
+    # auto-update PRs by preventing the CI build from fetching the new version. Delete the cache.
+    - powershell: Remove-Item -Recurse -ErrorAction Ignore "$env:LocalAppData\NuGet\v3-cache"
+      displayName: Clear NuGet http cache (if exists)
+
+    - script: C:\Windows\Microsoft.NET\Framework\v4.0.30319\ngen.exe queue pause
+      displayName: Pause NGEN x86
+
+    - script: C:\Windows\Microsoft.NET\Framework64\v4.0.30319\ngen.exe queue pause
+      displayName: Pause NGEN x64
+
+    # Build and rename binlog
+    # The /p:Coverage argument is passed here since some build properties change to accommodate running with
+    # coverage. This is part of the workarounds for https://github.com/tonerdo/coverlet/issues/362 and
+    # https://github.com/tonerdo/coverlet/issues/363.
+    - script: eng\cibuild.cmd
+        -restore
+        -build
+        -configuration $(_BuildConfig)
+        /p:Platform=${{ parameters.targetArchitecture }}
+        /p:TargetArchitecture=${{ parameters.targetArchitecture }}
+        $(_OfficialBuildIdArgs)
+        $(_InternalRuntimeDownloadArgs)
+        /p:Coverage=$(_Coverage)
+        /bl:$(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)\BuildSrc-${{ parameters.targetArchitecture }}.binlog
+      displayName: Build
+
+    # Run Unit Tests
+    # Tests are run with /m:1 to work around https://github.com/tonerdo/coverlet/issues/364
+    - script: eng\cibuild.cmd
+        -test
+        -configuration $(_BuildConfig)
+        /p:Platform=${{ parameters.targetArchitecture }}
+        /p:TargetArchitecture=${{ parameters.targetArchitecture }}
+        $(_OfficialBuildIdArgs)
+        $(_InternalRuntimeDownloadArgs)
+        /p:Coverage=$(_Coverage)
+        /p:TestRunnerAdditionalArguments='-notrait Category=IgnoreForCI -notrait Category=failing'
+        /bl:$(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)\Test-${{ parameters.targetArchitecture }}.binlog
+        /m:1
+      displayName: Run Unit Tests
+      condition: and(eq(variables['System.TeamProject'], 'public'), ne('${{ parameters.targetArchitecture }}', 'arm64'))
+
+    # Run Integration Tests
+    # Tests are run with /m:1 to avoid parallelism across different assemblies which can lead to
+    # UI race conditions
+    - script: eng\cibuild.cmd
+        -integrationTest
+        -configuration $(_BuildConfig)
+        /p:Platform=${{ parameters.targetArchitecture }}
+        /p:TargetArchitecture=${{ parameters.targetArchitecture }}
+        $(_OfficialBuildIdArgs)
+        $(_InternalRuntimeDownloadArgs)
+        /p:TestRunnerAdditionalArguments='-notrait Category=IgnoreForCI -notrait Category=failing'
+        /bl:$(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)\IntegrationTest-${{ parameters.targetArchitecture }}.binlog
+        /m:1
+      env:
+        XUNIT_LOGS: $(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)
+      displayName: Run Integration Tests
+      # UI tests are blocked from execution until we find solution for https://github.com/dotnet/winforms/issues/9318.
+      condition: and(eq(variables['System.TeamProject'], 'public'), ne('${{ parameters.targetArchitecture }}', 'arm64'), contains(variables['System.PullRequest.TargetBranch'], 'main'), false)
+      retryCountOnTaskFailure: 3
+
+    # Create Nuget package, sign, and publish
+    - script: eng\cibuild.cmd
+        -restore
+        -pack
+        -sign $(_SignArgs)
+        -publish $(_PublishArgs)
+        -configuration $(_BuildConfig)
+        $(_OfficialBuildIdArgs)
+        $(_InternalRuntimeDownloadArgs)
+        /bl:$(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)\PackSignPublish-${{ parameters.targetArchitecture }}.binlog
+      displayName: Pack, Sign, and Publish
+
+    # Upload code coverage data
+    - script: $(Build.SourcesDirectory)/.dotnet/dotnet msbuild -restore
+        eng/CodeCoverage.proj
+        /p:Configuration=$(_BuildConfig)
+        $(_InternalRuntimeDownloadArgs)
+        /bl:$(BUILD.SOURCESDIRECTORY)\artifacts\log\$(_BuildConfig)\CodeCoverage-${{ parameters.targetArchitecture }}.binlog
+      displayName: Upload coverage to codecov.io
+      condition: and(succeeded(), eq(variables._Coverage, 'true'))
+
+    # Generate SBOM for the internal leg only
+    - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+      - template: ..\common\templates\steps\generate-sbom.yml
+        parameters:
+          name: Generate_SBOM_${{ parameters.name }}
+
+    - template: post-build-PR.yml
+      parameters:
+        name: ${{ parameters.name }}
diff --git a/eng/pipelines/post-build-PR.yml b/eng/pipelines/post-build-PR.yml
new file mode 100644
index 00000000000..38565cb561d
--- /dev/null
+++ b/eng/pipelines/post-build-PR.yml
@@ -0,0 +1,92 @@
+
+parameters:
+  name: ''
+  enableMicrobuild: true
+  enablePublishBuildArtifacts: true
+  enablePublishTestResults: true
+  enablePublishBuildAssets: true
+  enablePublishUsingPipelines: true
+  testResultsFormat: 'xunit'
+
+steps:
+  - ${{ if eq(parameters.enableRichCodeNavigation, true) }}:
+    - task: RichCodeNavIndexer@0
+      displayName: RichCodeNav Upload
+      inputs:
+        languages: ${{ coalesce(parameters.richCodeNavigationLanguage, 'csharp') }}
+        environment: ${{ coalesce(parameters.richCodeNavigationEnvironment, 'production') }}
+        richNavLogOutputDirectory: $(Build.SourcesDirectory)/artifacts/bin
+      continueOnError: true
+
+  - ${{ if eq(parameters.enableMicrobuild, 'true') }}:
+    - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+      - task: MicroBuildCleanup@1
+        displayName: Execute Microbuild cleanup tasks  
+        condition: and(always(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT'))
+        continueOnError: ${{ parameters.continueOnError }}
+        env:
+          TeamName: $(_TeamName)
+
+  - ${{ if ne(parameters.artifacts.publish, '') }}:
+    - ${{ if or(eq(parameters.artifacts.publish.artifacts, 'true'), ne(parameters.artifacts.publish.artifacts, '')) }}:
+      - task: CopyFiles@2
+        displayName: Gather binaries for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/bin'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/bin'
+      - task: CopyFiles@2
+        displayName: Gather packages for publish to artifacts
+        inputs:
+          SourceFolder: 'artifacts/packages'
+          Contents: '**'
+          TargetFolder: '$(Build.ArtifactStagingDirectory)/artifacts/packages'
+      - task: PublishBuildArtifacts@1
+        displayName: Publish pipeline artifacts
+        inputs:
+          PathtoPublish: '$(Build.ArtifactStagingDirectory)/artifacts'
+          PublishLocation: Container
+          ArtifactName: ${{ coalesce(parameters.artifacts.publish.artifacts.name , 'Artifacts_$(Agent.Os)_$(_BuildConfig)') }}
+        continueOnError: true
+        condition: always()
+    - ${{ if or(eq(parameters.artifacts.publish.logs, 'true'), ne(parameters.artifacts.publish.logs, '')) }}:
+      - publish: artifacts/log
+        artifact: ${{ coalesce(parameters.artifacts.publish.logs.name, 'Logs_Build_$(Agent.Os)_$(_BuildConfig)') }}
+        displayName: Publish logs
+        continueOnError: true
+        condition: always()
+
+  - ${{ if ne(parameters.enablePublishBuildArtifacts, 'false') }}:
+    - task: PublishBuildArtifacts@1
+      displayName: Publish Logs
+      inputs:
+        PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)'
+        PublishLocation: Container
+        ArtifactName: ${{ coalesce(parameters.enablePublishBuildArtifacts.artifactName, '$(Agent.Os)_$(Agent.JobName)' ) }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'xunit')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish XUnit Test Results
+      inputs:
+        testResultsFormat: 'xUnit'
+        testResultsFiles: '*.xml' 
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-xunit
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+
+  - ${{ if or(and(eq(parameters.enablePublishTestResults, 'true'), eq(parameters.testResultsFormat, '')), eq(parameters.testResultsFormat, 'vstest')) }}:
+    - task: PublishTestResults@2
+      displayName: Publish TRX Test Results
+      inputs:
+        testResultsFormat: 'VSTest'
+        testResultsFiles: '*.trx' 
+        searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)'
+        testRunTitle: ${{ coalesce(parameters.testRunTitle, parameters.name, '$(System.JobName)') }}-trx
+        mergeTestResults: ${{ parameters.mergeTestResults }}
+      continueOnError: true
+      condition: always()
+
diff --git a/global.json b/global.json
index 4663c0d6bec..047880b6f70 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
   "tools": {
-    "dotnet": "8.0.101",
+    "dotnet": "8.0.100",
     "runtimes": {
       "dotnet/x64": [
         "$(VSRedistCommonNetCoreSharedFrameworkx6480PackageVersion)"
@@ -11,16 +11,16 @@
     }
   },
   "sdk": {
-    "version": "8.0.101"
+    "version": "8.0.100"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.24113.2",
-    "Microsoft.DotNet.CMake.Sdk": "8.0.0-beta.24113.2",
-    "Microsoft.DotNet.Helix.Sdk": "8.0.0-beta.24113.2",
+    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.23564.4",
+    "Microsoft.DotNet.CMake.Sdk": "8.0.0-beta.23564.4",
+    "Microsoft.DotNet.Helix.Sdk": "8.0.0-beta.23564.4",
     "FIX-85B6-MERGE-9C38-CONFLICT": "1.0.0",
-    "Microsoft.NET.Sdk.IL": "8.0.3-servicing.24114.23"
+    "Microsoft.NET.Sdk.IL": "8.0.1-servicing.23580.1"
   },
   "native-tools": {
     "cmake": "latest"
   }
-}
+}
\ No newline at end of file
diff --git a/pkg/Microsoft.Private.Winforms/Microsoft.Private.Winforms.csproj b/pkg/Microsoft.Private.Winforms/Microsoft.Private.Winforms.csproj
index 7b6046ee57b..2e658e683cd 100644
--- a/pkg/Microsoft.Private.Winforms/Microsoft.Private.Winforms.csproj
+++ b/pkg/Microsoft.Private.Winforms/Microsoft.Private.Winforms.csproj
@@ -80,7 +80,7 @@
     <ProjectReference Include="..\..\src\System.Drawing.Common\src\System.Drawing.Common.csproj" />
 
     <!-- Reference and Source System.Windows.Forms -->
-    <ProjectReference Include="..\..\src\System.Windows.Forms\src\System.Windows.Forms.csproj" />
+    <ProjectReference Include="..\..\src\System.Windows.Forms\src\WTG.System.Windows.Forms.csproj" />
 
     <!-- Reference and Source System.Windows.Forms.Primitives -->
     <ProjectReference Include="..\..\src\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
@@ -91,13 +91,11 @@
     <!-- Facade for System.Windows.Forms.Design.Editors -->
     <ProjectReference Include="..\..\src\System.Windows.Forms.Design.Editors\src\System.Windows.Forms.Design.Editors.Facade3x.csproj" />
     
-    <!-- Facade for Microsoft.VisualBasic -->
+    <!-- Facade for Microsoft.VisualBasic --><!--
     <ProjectReference Include="..\..\src\Microsoft.VisualBasic\src\Microsoft.VisualBasic.Facade.csproj" />
 
-    <!-- Reference and Source Microsoft.VisualBasic.Forms -->
-    <ProjectReference Include="..\..\src\Microsoft.VisualBasic.Forms\src\Microsoft.VisualBasic.Forms.vbproj" />
-
-    <ProjectReference Include="..\..\src\Accessibility\src\Accessibility.ilproj" />
+    --><!-- Reference and Source Microsoft.VisualBasic.Forms --><!--
+    <ProjectReference Include="..\..\src\Microsoft.VisualBasic.Forms\src\Microsoft.VisualBasic.Forms.vbproj" />-->
 
     <!-- 
       Analyzers
@@ -106,6 +104,11 @@
     <ProjectReference Include="..\..\src\System.Windows.Forms.Analyzers.CSharp\src\System.Windows.Forms.Analyzers.CSharp.csproj" />
 
   </ItemGroup>
+  <ItemGroup>
+    <Reference Include="Accessibility">
+      <HintPath>..\..\Accessibility.dll</HintPath>
+    </Reference>
+  </ItemGroup>
 
   <!-- Force the output item type for all project references to "TfmSpecificPackageFile", which makes them get packed -->
   <Target Name="SetOutputItemType">
diff --git a/src/Common/tests/TestUtilities/AppContextSwitchNames.cs b/src/Common/tests/TestUtilities/AppContextSwitchNames.cs
deleted file mode 100644
index cfff428ac46..00000000000
--- a/src/Common/tests/TestUtilities/AppContextSwitchNames.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System;
-
-public static class AppContextSwitchNames
-{
-    /// <summary>
-    ///  The switch that controls whether or not the <see cref="BinaryFormatter"/> is enabled.
-    /// </summary>
-    public static string EnableUnsafeBinaryFormatterSerialization { get; }
-        = "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization";
-
-    /// <summary>
-    ///  Switch that controls <see cref="AppContext"/> switch caching.
-    /// </summary>
-    public static string LocalAppContext_DisableCaching { get; }
-        = "TestSwitch.LocalAppContext.DisableCaching";
-}
diff --git a/src/Common/tests/TestUtilities/AppContextSwitchScope.cs b/src/Common/tests/TestUtilities/AppContextSwitchScope.cs
deleted file mode 100644
index ff771db020b..00000000000
--- a/src/Common/tests/TestUtilities/AppContextSwitchScope.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-/// <summary>
-///  Scope for temporarily setting an <see cref="AppContext"/> switch. Use in a <see langword="using"/> statement.
-/// </summary>
-/// <remarks>
-///  <para>
-///   It is recommended to create wrappers for this struct for both simplicity and to allow adding synchronization.
-///   See <see cref="BinaryFormatterScope"/> for an example of doing this.
-///  </para>
-/// </remarks>
-public readonly ref struct AppContextSwitchScope
-{
-    private readonly string _switchName;
-    private readonly bool _originalState;
-
-    public AppContextSwitchScope(string switchName, bool enable)
-    {
-        if (!AppContext.TryGetSwitch(AppContextSwitchNames.LocalAppContext_DisableCaching, out bool isEnabled)
-            || !isEnabled)
-        {
-            // It doesn't make sense to try messing with AppContext switches if they are going to be cached.
-            throw new InvalidOperationException("LocalAppContext switch caching is not disabled.");
-        }
-
-        AppContext.TryGetSwitch(switchName, out _originalState);
-
-        AppContext.SetSwitch(switchName, enable);
-        if (!AppContext.TryGetSwitch(switchName, out isEnabled) || isEnabled != enable)
-        {
-            throw new InvalidOperationException($"Could not set {switchName} to {enable}.");
-        }
-
-        _switchName = switchName;
-    }
-
-    public void Dispose()
-    {
-        AppContext.SetSwitch(_switchName, _originalState);
-        if (!AppContext.TryGetSwitch(_switchName, out bool isEnabled) || isEnabled != _originalState)
-        {
-            throw new InvalidOperationException($"Could not reset {_switchName} to {_originalState}.");
-        }
-    }
-}
diff --git a/src/Common/tests/TestUtilities/BinaryFormatterScope.cs b/src/Common/tests/TestUtilities/BinaryFormatterScope.cs
deleted file mode 100644
index ba22e532693..00000000000
--- a/src/Common/tests/TestUtilities/BinaryFormatterScope.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System;
-
-/// <summary>
-///  Scope for enabling / disabling the <see cref="BinaryFormatter"/>. Use in a <see langword="using"/> statement.
-/// </summary>
-public readonly ref struct BinaryFormatterScope
-{
-    private readonly AppContextSwitchScope _switchScope;
-
-    public BinaryFormatterScope(bool enable)
-    {
-        // Prevent multiple BinaryFormatterScopes from running simultaneously. Using Monitor to allow recursion on
-        // the same thread.
-        Monitor.Enter(typeof(BinaryFormatterScope));
-        _switchScope = new AppContextSwitchScope(AppContextSwitchNames.EnableUnsafeBinaryFormatterSerialization, enable);
-    }
-
-    public void Dispose()
-    {
-        try
-        {
-            _switchScope.Dispose();
-        }
-        finally
-        {
-            Monitor.Exit(typeof(BinaryFormatterScope));
-        }
-    }
-
-    static BinaryFormatterScope()
-    {
-        // Need to explicitly set the switch to whatever the default is as its default value is in transition.
-
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        try
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            formatter.Serialize(null!, null!);
-#pragma warning restore SYSLIB0011
-        }
-        catch (NotSupportedException)
-        {
-            AppContext.SetSwitch(AppContextSwitchNames.EnableUnsafeBinaryFormatterSerialization, false);
-            return;
-        }
-        catch (ArgumentNullException)
-        {
-            AppContext.SetSwitch(AppContextSwitchNames.EnableUnsafeBinaryFormatterSerialization, true);
-            return;
-        }
-
-        throw new InvalidOperationException();
-    }
-}
diff --git a/src/Common/tests/TestUtilities/BinarySerialization.cs b/src/Common/tests/TestUtilities/BinarySerialization.cs
deleted file mode 100644
index 02e2e5a3a20..00000000000
--- a/src/Common/tests/TestUtilities/BinarySerialization.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.Serialization.Formatters;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System;
-
-public static class BinarySerialization
-{
-    public static void EnsureSerializableAttribute(Assembly assemblyUnderTest, HashSet<string> serializableTypes)
-    {
-        foreach (Type type in assemblyUnderTest.GetTypes())
-        {
-            var attributes = Attribute.GetCustomAttributes(type);
-            string? fullName = type.FullName;
-            if (fullName is null)
-            {
-                continue;
-            }
-
-            if (!attributes.Any(a => a is SerializableAttribute))
-            {
-                // the type isn't marked as serializable, verify it is not one of the types
-                // that we expect to be serializable
-                if (serializableTypes.Contains(fullName))
-                {
-                    throw new NotSupportedException($"Serializable attribute is expected on {fullName}");
-                }
-
-                continue;
-            }
-
-            if (attributes.Any(a => a is CompilerGeneratedAttribute))
-            {
-                // ignore compiler generated types, we have no control over them
-                continue;
-            }
-
-            // Ensure SerializableAttribute is not added to any types not in the known list.
-            if (serializableTypes.Contains(fullName))
-            {
-                // we have marked the type as serializable, all good
-                continue;
-            }
-
-            throw new NotSupportedException($"Serializable attribute is not expected on {type.FullName}");
-        }
-    }
-
-#pragma warning disable SYSLIB0050 // Type or member is obsolete
-    public static T EnsureDeserialize<T>(string blob)
-    {
-        var @object = FromBase64String(blob);
-        Assert.NotNull(@object);
-        return Assert.IsType<T>(@object);
-
-        static object FromBase64String(string base64String,
-            FormatterAssemblyStyle assemblyStyle = FormatterAssemblyStyle.Simple)
-        {
-            byte[] raw = Convert.FromBase64String(base64String);
-            return FromByteArray(raw, assemblyStyle);
-        }
-
-        static object FromByteArray(byte[] raw,
-            FormatterAssemblyStyle assemblyStyle = FormatterAssemblyStyle.Simple)
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            BinaryFormatter binaryFormatter = new()
-            {
-                AssemblyFormat = assemblyStyle
-            };
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-
-            using MemoryStream serializedStream = new(raw);
-            return binaryFormatter.Deserialize(serializedStream);
-        }
-    }
-
-    public static string ToBase64String(object @object,
-        FormatterAssemblyStyle assemblyStyle = FormatterAssemblyStyle.Simple)
-    {
-        byte[] raw = ToByteArray(@object, assemblyStyle);
-        return Convert.ToBase64String(raw);
-
-        static byte[] ToByteArray(object obj,
-            FormatterAssemblyStyle assemblyStyle = FormatterAssemblyStyle.Simple)
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            BinaryFormatter binaryFormatter = new()
-            {
-                AssemblyFormat = assemblyStyle
-            };
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-
-            using MemoryStream stream = new();
-            binaryFormatter.Serialize(stream, obj);
-            return stream.ToArray();
-        }
-    }
-#pragma warning restore SYSLIB0050 // Type or member is obsolete
-}
diff --git a/src/Common/tests/TestUtilities/CommonTestHelper.cs b/src/Common/tests/TestUtilities/CommonTestHelper.cs
deleted file mode 100644
index a70c320a385..00000000000
--- a/src/Common/tests/TestUtilities/CommonTestHelper.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Drawing;
-
-namespace System.Windows.Forms.TestUtilities;
-
-public static class CommonTestHelper
-{
-    #region Primitives
-
-    public static TheoryData<string, string, int> GetCtrlBackspaceData()
-        => new()
-        {
-            { "aaa", "", 0 },
-            { "---", "", 0 },
-            { " aaa", "", 0 },
-            { " ---", "", 0 },
-            { "aaa---", "", 0 },
-            { "---aaa", "---", 0 },
-            { "aaa---aaa", "aaa---", 0 },
-            { "---aaa---", "---", 0 },
-            { "a-a", "a-", 0 },
-            { "-a-", "", 0 },
-            { "--a-", "--", 0 },
-            { "abc", "c", -1 },
-            { "a,1-b", "a,b", -1 }
-        };
-
-    public static TheoryData<string, string, int> GetCtrlBackspaceRepeatedData()
-        => new()
-        {
-            { "aaa", "", 2 },
-            { "---", "", 2 },
-            { "aaa---aaa", "", 2 },
-            { "---aaa---", "", 2 },
-            { "aaa bbb", "", 2 },
-            { "aaa bbb ccc", "aaa ", 2 },
-            { "aaa --- ccc", "", 2 },
-            { "1 2 3 4 5 6 7 8 9 0", "1 ", 9 }
-        };
-
-    public static TheoryData<char> GetCharTheoryData()
-        => new()
-        {
-            '\0',
-            'a'
-        };
-
-    public static TheoryData<IntPtr> GetIntPtrTheoryData()
-        => new()
-        {
-            (IntPtr)(-1),
-            IntPtr.Zero,
-            (IntPtr)1
-        };
-
-    public static TheoryData<Color> GetColorTheoryData()
-        => new()
-        {
-            Color.Red,
-            Color.Blue,
-            Color.Black
-        };
-
-    public static TheoryData<Color> GetColorWithEmptyTheoryData()
-        => new()
-        {
-            Color.Red,
-            Color.Empty
-        };
-
-    public static TheoryData<Point> GetPointTheoryData() => GetPointTheoryData(TestIncludeType.All);
-
-    public static TheoryData<Point> GetPointTheoryData(TestIncludeType includeType)
-    {
-        TheoryData<Point> data = new();
-        if (!includeType.HasFlag(TestIncludeType.NoPositives))
-        {
-            data.Add(new Point());
-            data.Add(new Point(10));
-            data.Add(new Point(1, 2));
-        }
-
-        if (!includeType.HasFlag(TestIncludeType.NoNegatives))
-        {
-            data.Add(new Point(int.MaxValue, int.MinValue));
-            data.Add(new Point(-1, -2));
-        }
-
-        return data;
-    }
-
-    public static TheoryData<Size> GetSizeTheoryData() => GetSizeTheoryData(TestIncludeType.All);
-
-    public static TheoryData<Size> GetSizeTheoryData(TestIncludeType includeType)
-    {
-        TheoryData<Size> data = new();
-        if (!includeType.HasFlag(TestIncludeType.NoPositives))
-        {
-            data.Add(new Size());
-            data.Add(new Size(new Point(1, 1)));
-            data.Add(new Size(1, 2));
-        }
-
-        if (!includeType.HasFlag(TestIncludeType.NoNegatives))
-        {
-            data.Add(new Size(-1, 1));
-            data.Add(new Size(1, -1));
-        }
-
-        return data;
-    }
-
-    public static TheoryData<Type?, bool> GetConvertFromTheoryData()
-        => new()
-        {
-            { typeof(bool), false },
-            { typeof(InstanceDescriptor), true },
-            { typeof(int), false },
-            { typeof(double), false },
-            { null, false }
-        };
-
-    public static TheoryData<EventArgs?> GetEventArgsTheoryData()
-        => new()
-        {
-            null,
-            new EventArgs()
-        };
-
-    #endregion
-}
diff --git a/src/Common/tests/TestUtilities/ComparisonHelpers.cs b/src/Common/tests/TestUtilities/ComparisonHelpers.cs
deleted file mode 100644
index a80634fa30d..00000000000
--- a/src/Common/tests/TestUtilities/ComparisonHelpers.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace System;
-
-public static class ComparisonHelpers
-{
-    public static bool EqualsInteger<T>(T x, T y, T variance)
-        where T : struct, IBinaryInteger<T>
-    {
-        ArgumentOutOfRangeException.ThrowIfLessThan(variance, T.Zero);
-
-        return T.Abs(x > y ? x - y : y - x) <= variance;
-    }
-
-    public static bool EqualsFloating<T>(T x, T y, T variance)
-        where T : struct, IFloatingPoint<T>
-    {
-        ArgumentOutOfRangeException.ThrowIfLessThan(variance, T.Zero);
-
-        if (T.IsNaN(x))
-        {
-            return T.IsNaN(y);
-        }
-        else if (T.IsNaN(y))
-        {
-            return false;
-        }
-
-        if (T.IsNegativeInfinity(x))
-        {
-            return T.IsNegativeInfinity(y);
-        }
-        else if (T.IsNegativeInfinity(y))
-        {
-            return false;
-        }
-
-        if (T.IsPositiveInfinity(x))
-        {
-            return T.IsPositiveInfinity(y);
-        }
-        else if (T.IsPositiveInfinity(y))
-        {
-            return false;
-        }
-
-        if (IsNegativeZero(x))
-        {
-            if (IsNegativeZero(y))
-            {
-                return true;
-            }
-
-            if (IsPositiveZero(variance) || IsNegativeZero(variance))
-            {
-                return false;
-            }
-
-            // When the variance is not +-0.0, then we are handling a case where
-            // the actual result is expected to not be exactly -0.0 on some platforms
-            // and we should fallback to checking if it is within the allowed variance instead.
-        }
-        else if (IsNegativeZero(y))
-        {
-            if (IsPositiveZero(variance) || IsNegativeZero(variance))
-            {
-                return false;
-            }
-
-            // When the variance is not +-0.0, then we are handling a case where
-            // the actual result is expected to not be exactly -0.0 on some platforms
-            // and we should fallback to checking if it is within the allowed variance instead.
-        }
-
-        if (IsPositiveZero(x))
-        {
-            if (IsPositiveZero(y))
-            {
-                return true;
-            }
-
-            if (IsPositiveZero(variance) || IsNegativeZero(variance))
-            {
-                return false;
-            }
-
-            // When the variance is not +-0.0, then we are handling a case where
-            // the actual result is expected to not be exactly +0.0 on some platforms
-            // and we should fallback to checking if it is within the allowed variance instead.
-        }
-        else if (IsPositiveZero(y))
-        {
-            if (IsPositiveZero(variance) || IsNegativeZero(variance))
-            {
-                return false;
-            }
-
-            // When the variance is not +-0.0, then we are handling a case where
-            // the actual result is expected to not be exactly +0.0 on some platforms
-            // and we should fallback to checking if it is within the allowed variance instead.
-        }
-
-        return T.Abs(x > y ? x - y : y - x) <= variance;
-
-        static unsafe bool IsNegativeZero(T value) => T.IsZero(value) && T.IsNegative(value);
-
-        static unsafe bool IsPositiveZero(T value) => T.IsZero(value) && T.IsPositive(value);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/CustomConverter.cs b/src/Common/tests/TestUtilities/CustomConverter.cs
deleted file mode 100644
index aa71a40908d..00000000000
--- a/src/Common/tests/TestUtilities/CustomConverter.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System;
-
-public static class CustomConverter
-{
-    /// <summary>
-    ///  Registers a TypeConverter with the specified type.
-    /// </summary>
-    public static RegistrationScope RegisterConverter(Type type, TypeConverter converter)
-    {
-        ArgumentNullException.ThrowIfNull(type);
-        ArgumentNullException.ThrowIfNull(converter);
-
-        TypeDescriptionProvider parentProvider = TypeDescriptor.GetProvider(type);
-        CustomTypeDescriptionProvider newProvider = new(parentProvider, converter);
-        TypeDescriptor.AddProvider(newProvider, type);
-        return new RegistrationScope(type, newProvider);
-    }
-
-    /// <summary>
-    ///  Manages the registration lifetime of a TypeConverter to a type.
-    ///  This is meant to be utilized in a <see langword="using"/> statement to ensure
-    ///  <see cref="TypeDescriptor.RemoveProvider(TypeDescriptionProvider, Type)"/> is called when going out of scope with the using.
-    /// </summary>
-    public readonly ref struct RegistrationScope
-    {
-        private readonly Type _type;
-        private readonly TypeDescriptionProvider _provider;
-
-        public RegistrationScope(Type type, TypeDescriptionProvider provider)
-        {
-            _type = type;
-            _provider = provider;
-        }
-
-        public void Dispose() => TypeDescriptor.RemoveProvider(_provider, _type);
-    }
-
-    public class CustomTypeDescriptionProvider : TypeDescriptionProvider
-    {
-        private TypeConverter _converter;
-
-        public CustomTypeDescriptionProvider(TypeDescriptionProvider parent, TypeConverter converter) : base(parent)
-            => _converter = converter;
-
-        public override ICustomTypeDescriptor GetTypeDescriptor(
-            [DynamicallyAccessedMembers((DynamicallyAccessedMemberTypes)(-1))] Type objectType,
-            object? instance) => new TypeConverterProvider(base.GetTypeDescriptor(objectType, instance), _converter);
-
-        private class TypeConverterProvider : CustomTypeDescriptor
-        {
-            private TypeConverter _converter;
-
-            public TypeConverterProvider(ICustomTypeDescriptor? parent, TypeConverter converter) : base(parent)
-                => _converter = converter;
-
-            public override TypeConverter GetConverter() => _converter;
-        }
-    }
-}
diff --git a/src/Common/tests/TestUtilities/DebuggerAttributes.cs b/src/Common/tests/TestUtilities/DebuggerAttributes.cs
deleted file mode 100644
index fcfd25b495f..00000000000
--- a/src/Common/tests/TestUtilities/DebuggerAttributes.cs
+++ /dev/null
@@ -1,232 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Reflection;
-using System.Text;
-
-namespace System.Diagnostics;
-
-internal class DebuggerAttributeInfo
-{
-    public object Instance { get; set; }
-    public IEnumerable<PropertyInfo> Properties { get; set; }
-}
-
-internal static class DebuggerAttributes
-{
-    internal static object GetFieldValue(object obj, string fieldName)
-    {
-        return GetField(obj, fieldName).GetValue(obj);
-    }
-
-    internal static void InvokeDebuggerTypeProxyProperties(object obj)
-    {
-        DebuggerAttributeInfo info = ValidateDebuggerTypeProxyProperties(obj.GetType(), obj);
-        foreach (PropertyInfo pi in info.Properties)
-        {
-            pi.GetValue(info.Instance, null);
-        }
-    }
-
-    internal static DebuggerAttributeInfo ValidateDebuggerTypeProxyProperties(object obj)
-    {
-        return ValidateDebuggerTypeProxyProperties(obj.GetType(), obj);
-    }
-
-    internal static DebuggerAttributeInfo ValidateDebuggerTypeProxyProperties(Type type, object obj)
-    {
-        return ValidateDebuggerTypeProxyProperties(type, type.GenericTypeArguments, obj);
-    }
-
-    internal static DebuggerAttributeInfo ValidateDebuggerTypeProxyProperties(Type type, Type[] genericTypeArguments, object obj)
-    {
-        Type proxyType = GetProxyType(type, genericTypeArguments);
-
-        // Create an instance of the proxy type, and make sure we can access all of the instance properties
-        // on the type without exception
-        object proxyInstance = Activator.CreateInstance(proxyType, obj);
-        IEnumerable<PropertyInfo> properties = GetDebuggerVisibleProperties(proxyType);
-        return new DebuggerAttributeInfo
-        {
-            Instance = proxyInstance,
-            Properties = properties
-        };
-    }
-
-    public static DebuggerBrowsableState? GetDebuggerBrowsableState(MemberInfo info)
-    {
-        CustomAttributeData debuggerBrowsableAttribute = info.CustomAttributes
-            .SingleOrDefault(a => a.AttributeType == typeof(DebuggerBrowsableAttribute));
-        // Enums in attribute constructors are boxed as ints, so cast to int? first.
-        return (DebuggerBrowsableState?)(int?)debuggerBrowsableAttribute?.ConstructorArguments.Single().Value;
-    }
-
-    public static IEnumerable<FieldInfo> GetDebuggerVisibleFields(Type debuggerAttributeType)
-    {
-        // The debugger doesn't evaluate non-public members of type proxies.
-        IEnumerable<FieldInfo> visibleFields = debuggerAttributeType.GetFields()
-            .Where(fi => fi.IsPublic && GetDebuggerBrowsableState(fi) != DebuggerBrowsableState.Never);
-        return visibleFields;
-    }
-
-    public static IEnumerable<PropertyInfo> GetDebuggerVisibleProperties(Type debuggerAttributeType)
-    {
-        // The debugger doesn't evaluate non-public members of type proxies. GetGetMethod returns null if the getter is non-public.
-        IEnumerable<PropertyInfo> visibleProperties = debuggerAttributeType.GetProperties()
-            .Where(pi => pi.GetGetMethod() is object && GetDebuggerBrowsableState(pi) != DebuggerBrowsableState.Never);
-        return visibleProperties;
-    }
-
-    public static object GetProxyObject(object obj) => Activator.CreateInstance(GetProxyType(obj), obj);
-
-    public static Type GetProxyType(object obj) => GetProxyType(obj.GetType());
-
-    public static Type GetProxyType(Type type) => GetProxyType(type, type.GenericTypeArguments);
-
-    private static Type GetProxyType(Type type, Type[] genericTypeArguments)
-    {
-        // Get the DebuggerTypeProxyAttribute for obj
-        CustomAttributeData[] attrs =
-            type.GetTypeInfo().CustomAttributes
-            .Where(a => a.AttributeType == typeof(DebuggerTypeProxyAttribute))
-            .ToArray();
-        if (attrs.Length != 1)
-        {
-            throw new InvalidOperationException($"Expected one DebuggerTypeProxyAttribute on {type}.");
-        }
-
-        CustomAttributeData cad = attrs[0];
-
-        Type proxyType = cad.ConstructorArguments[0].ArgumentType == typeof(Type) ?
-            (Type)cad.ConstructorArguments[0].Value :
-            Type.GetType((string)cad.ConstructorArguments[0].Value);
-        if (genericTypeArguments.Length > 0)
-        {
-            proxyType = proxyType.MakeGenericType(genericTypeArguments);
-        }
-
-        return proxyType;
-    }
-
-    internal static string ValidateDebuggerDisplayReferences(object obj)
-    {
-        // Get the DebuggerDisplayAttribute for obj
-        Type objType = obj.GetType();
-        CustomAttributeData[] attrs =
-            objType.GetTypeInfo().CustomAttributes
-            .Where(a => a.AttributeType == typeof(DebuggerDisplayAttribute))
-            .ToArray();
-        if (attrs.Length != 1)
-        {
-            throw new InvalidOperationException($"Expected one DebuggerDisplayAttribute on {objType}.");
-        }
-
-        CustomAttributeData cad = attrs[0];
-
-        // Get the text of the DebuggerDisplayAttribute
-        string attrText = (string)cad.ConstructorArguments[0].Value;
-
-        string[] segments = attrText.Split(new[] { '{', '}' });
-
-        if (segments.Length % 2 == 0)
-        {
-            throw new InvalidOperationException($"The DebuggerDisplayAttribute for {objType} lacks a closing brace.");
-        }
-
-        if (segments.Length == 1)
-        {
-            throw new InvalidOperationException($"The DebuggerDisplayAttribute for {objType} doesn't reference any expressions.");
-        }
-
-        StringBuilder sb = new();
-
-        for (int i = 0; i < segments.Length; i += 2)
-        {
-            string literal = segments[i];
-            sb.Append(literal);
-
-            if (i + 1 < segments.Length)
-            {
-                string reference = segments[i + 1];
-                bool noQuotes = reference.EndsWith(",nq");
-
-                reference = reference.Replace(",nq", string.Empty);
-
-                // Evaluate the reference.
-                object member;
-                if (!TryEvaluateReference(obj, reference, out member))
-                {
-                    throw new InvalidOperationException($"The DebuggerDisplayAttribute for {objType} contains the expression \"{reference}\".");
-                }
-
-                string memberString = GetDebuggerMemberString(member, noQuotes);
-
-                sb.Append(memberString);
-            }
-        }
-
-        return sb.ToString();
-    }
-
-    private static string GetDebuggerMemberString(object member, bool noQuotes)
-    {
-        return member switch
-        {
-            null => "null",
-            byte or sbyte or short or ushort or int or uint or long or ulong or float or double => member.ToString(),
-            string _ when noQuotes => member.ToString(),
-            string => $"\"{member}\"",
-            _ => $"{{{member}}}"
-        };
-    }
-
-    private static bool TryEvaluateReference(object obj, string reference, out object member)
-    {
-        PropertyInfo pi = GetProperty(obj, reference);
-        if (pi is object)
-        {
-            member = pi.GetValue(obj);
-            return true;
-        }
-
-        FieldInfo fi = GetField(obj, reference);
-        if (fi is object)
-        {
-            member = fi.GetValue(obj);
-            return true;
-        }
-
-        member = null;
-        return false;
-    }
-
-    private static FieldInfo GetField(object obj, string fieldName)
-    {
-        for (Type t = obj.GetType(); t is object; t = t.GetTypeInfo().BaseType)
-        {
-            FieldInfo fi = t.GetTypeInfo().GetDeclaredField(fieldName);
-            if (fi is object)
-            {
-                return fi;
-            }
-        }
-
-        return null;
-    }
-
-    private static PropertyInfo GetProperty(object obj, string propertyName)
-    {
-        for (Type t = obj.GetType(); t is object; t = t.GetTypeInfo().BaseType)
-        {
-            PropertyInfo pi = t.GetTypeInfo().GetDeclaredProperty(propertyName);
-            if (pi is object)
-            {
-                return pi;
-            }
-        }
-
-        return null;
-    }
-}
diff --git a/src/Common/tests/TestUtilities/FileCleanupTestBase.cs b/src/Common/tests/TestUtilities/FileCleanupTestBase.cs
deleted file mode 100644
index 1dfb32d0278..00000000000
--- a/src/Common/tests/TestUtilities/FileCleanupTestBase.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public abstract class FileCleanupTestBase : IDisposable
-{
-    public readonly string TestDirectory;
-
-    protected FileCleanupTestBase()
-    {
-        TestDirectory = Path.Combine(Path.GetTempPath(), GetUniqueName());
-        Directory.CreateDirectory(TestDirectory);
-    }
-
-    ~FileCleanupTestBase()
-    {
-        Dispose(false);
-    }
-
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    private void Dispose(bool disposing)
-    {
-        try
-        {
-            Directory.Delete(TestDirectory);
-        }
-        catch
-        {
-        }
-    }
-
-    public string GetTestFilePath() => Path.Combine(TestDirectory, GetTestFileName());
-
-    public string GetTestFileName() => GetUniqueName();
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString("D");
-}
diff --git a/src/Common/tests/TestUtilities/GlobalUsings.cs b/src/Common/tests/TestUtilities/GlobalUsings.cs
deleted file mode 100644
index 581f24df927..00000000000
--- a/src/Common/tests/TestUtilities/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics.CodeAnalysis;
-global using Xunit;
diff --git a/src/Common/tests/TestUtilities/ITestAccessor.cs b/src/Common/tests/TestUtilities/ITestAccessor.cs
deleted file mode 100644
index d9f706c29e6..00000000000
--- a/src/Common/tests/TestUtilities/ITestAccessor.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-/// <summary>
-///  Interface for accessing internals from tests.
-/// </summary>
-/// <remarks>
-///  <para>
-///   A non generic representation of the accessor functionality is needed to
-///   allow dynamically creating arbitrary <see cref="TestAccessor{T}"/> from
-///   helper methods.
-///  </para>
-/// </remarks>
-public interface ITestAccessor
-{
-    /// <summary>
-    ///  Gets a dynamic accessor to internals on the test object.
-    /// </summary>
-    /// <remarks>
-    ///  <para>
-    ///   This does not work for ref structs as they are not yet accessible via reflection.
-    ///   See https://github.com/dotnet/runtime/issues/10057.
-    ///  </para>
-    /// </remarks>
-    dynamic Dynamic { get; }
-
-    /// <summary>
-    ///  Creates a delegate for the given non-public method.
-    /// </summary>
-    /// <param name="methodName">
-    ///  The method name. If null, uses the name of the delegate for the method.
-    /// </param>
-    /// <remarks>
-    ///  <para>
-    ///   This provides a way to access methods that take ref structs.
-    ///  </para>
-    /// </remarks>
-    /// <example>
-    ///  <![CDATA[
-    ///   // For ref structs you have to define a delegate as ref struct types
-    ///   // cannot be used as generic arguments (e.g. to Func/Span)
-    ///
-    ///   private delegate int GetDirectoryNameOffset(ReadOnlySpan<char> path);
-    ///
-    ///   public int InternalGetDirectoryNameOffset(ReadOnlySpan<char> path)
-    ///   {
-    ///       var accessor = typeof(System.IO.Path).TestAccessor();
-    ///       return accessor.CreateDelegate<GetDirectoryNameOffset>()(@"C:\Foo");
-    ///   }
-    ///
-    ///   // Without ref structs you can just use Func/Action
-    ///   var accessor = typeof(Color).TestAccessor();
-    ///   bool result = accessor.CreateDelegate<Func<KnownColor, bool>>("IsKnownColorSystem")(KnownColor.Window);
-    ///  ]]>
-    /// </example>
-    TDelegate CreateDelegate<TDelegate>(string? methodName = null)
-        where TDelegate : Delegate;
-}
diff --git a/src/Common/tests/TestUtilities/ModuleInitializer.cs b/src/Common/tests/TestUtilities/ModuleInitializer.cs
deleted file mode 100644
index 2cb757018d6..00000000000
--- a/src/Common/tests/TestUtilities/ModuleInitializer.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace System;
-
-internal static class ModuleInitializer
-{
-    [ModuleInitializer]
-    [SuppressMessage("Usage", "CA2255:The 'ModuleInitializer' attribute should not be used in libraries", Justification = "Intentional use of module initializer to register trace listener.")]
-    internal static void Initialize()
-    {
-        Trace.Listeners.Clear();
-        Trace.Listeners.Add(ThrowingTraceListener.Instance);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/ReflectionHelper.cs b/src/Common/tests/TestUtilities/ReflectionHelper.cs
deleted file mode 100644
index f5395289855..00000000000
--- a/src/Common/tests/TestUtilities/ReflectionHelper.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-
-namespace System;
-
-public static class ReflectionHelper
-{
-    public static IEnumerable<Type> GetPublicNotAbstractClasses<T>()
-    {
-        var types = typeof(T).Assembly.GetTypes().Where(type => IsPublicNonAbstract<T>(type));
-        foreach (var type in types)
-        {
-            if (type.GetConstructor(
-                bindingAttr: BindingFlags.Public | BindingFlags.Instance,
-                binder: null,
-                types: Array.Empty<Type>(),
-                modifiers: null) is null)
-            {
-                continue;
-            }
-
-            yield return type;
-        }
-    }
-
-    public static T? InvokePublicConstructor<T>(Type type)
-    {
-        var ctor = type.GetConstructor(
-            bindingAttr: BindingFlags.Public | BindingFlags.Instance,
-            binder: null,
-            types: Array.Empty<Type>(),
-            modifiers: null);
-
-        if (ctor is null)
-        {
-            return default;
-        }
-
-        T obj = (T)ctor.Invoke(Array.Empty<object>());
-        Assert.NotNull(obj);
-        return obj;
-    }
-
-    private static bool IsPublicNonAbstract<T>(Type type)
-    {
-        return !type.IsAbstract && type.IsPublic && typeof(T).IsAssignableFrom(type);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/System.Windows.Forms.Common.TestUtilities.csproj b/src/Common/tests/TestUtilities/System.Windows.Forms.Common.TestUtilities.csproj
deleted file mode 100644
index 21e788b7cfe..00000000000
--- a/src/Common/tests/TestUtilities/System.Windows.Forms.Common.TestUtilities.csproj
+++ /dev/null
@@ -1,18 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <AssemblyName>System.Windows.Forms.Common.TestUtilities</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <RootNamespace>System</RootNamespace>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="xunit.assert" Version="$(XUnitAssertVersion)" />
-    <PackageReference Include="Microsoft.DotNet.RemoteExecutor" Version="$(MicrosoftDotNetRemoteExecutorVersion)" />
-    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsPackageVersion)" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Common/tests/TestUtilities/TempFile.cs b/src/Common/tests/TestUtilities/TempFile.cs
deleted file mode 100644
index 1a0d0cfa2e5..00000000000
--- a/src/Common/tests/TestUtilities/TempFile.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-namespace System.IO;
-
-/// <summary>
-/// Represents a temporary file. Creating an instance creates a file at the specified path,
-/// and disposing the instance deletes the file.
-/// </summary>
-/// <remarks>
-/// This is copied verbatim from TempFile.cs in dotnet/runtime (https://github.com/dotnet/runtime/blob/master/src/libraries/Common/tests/System/IO/TempFile.cs)
-/// </remarks>
-public sealed class TempFile : IDisposable
-{
-    /// <summary>Gets the created file's path.</summary>
-    public string Path { get; }
-
-    public TempFile(string path, long length = 0) : this(path, length > -1 ? new byte[length] : null)
-    {
-    }
-
-    public TempFile(string path, byte[]? data)
-    {
-        Path = path;
-
-        if (data is not null)
-        {
-            File.WriteAllBytes(path, data);
-        }
-    }
-
-    public TempFile(string path, string text)
-    {
-        Path = path;
-
-        File.WriteAllText(path, text);
-    }
-
-    ~TempFile() => DeleteFile();
-
-    public static TempFile Create(
-        byte[] bytes,
-        [CallerMemberName] string? memberName = null,
-        [CallerLineNumber] int lineNumber = 0)
-        => new(GetFilePath(memberName, lineNumber), bytes);
-
-    public static TempFile Create(
-        string text,
-        [CallerMemberName] string? memberName = null,
-        [CallerLineNumber] int lineNumber = 0)
-        => new(GetFilePath(memberName, lineNumber), text);
-
-    public static TempFile Create(
-        long length = -1,
-        [CallerMemberName] string? memberName = null,
-        [CallerLineNumber] int lineNumber = 0)
-        => new(GetFilePath(memberName, lineNumber), length);
-
-    public void AssertExists() => Assert.True(File.Exists(Path));
-
-    public string ReadAllText() => File.ReadAllText(Path);
-
-    public void Dispose()
-    {
-        GC.SuppressFinalize(this);
-        DeleteFile();
-    }
-
-    private void DeleteFile()
-    {
-        try
-        { File.Delete(Path); }
-        catch { /* Ignore exceptions on disposal paths */ }
-    }
-
-    private static string GetFilePath(string? memberName, int lineNumber)
-    {
-        string file = $"{IO.Path.GetRandomFileName()}_{memberName}_{lineNumber}";
-        return IO.Path.Combine(IO.Path.GetTempPath(), file);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/TestAccessor.cs b/src/Common/tests/TestUtilities/TestAccessor.cs
deleted file mode 100644
index e5a91cd1982..00000000000
--- a/src/Common/tests/TestUtilities/TestAccessor.cs
+++ /dev/null
@@ -1,214 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Dynamic;
-using System.Reflection;
-
-namespace System;
-
-/// <summary>
-///  Internals (including privates) access wrapper for tests.
-/// </summary>
-/// <typeparam name="T">The type of the class being accessed.</typeparam>
-/// <remarks>
-///  Does not allow access to public members- use the object directly.
-///
-///  One should strive to *not* access internal state where otherwise avoidable.
-///  Ask yourself if you can test the contract of the object in question
-///  *without* manipulating internals directly. Often you can.
-///
-///  Where internals access is more useful are testing building blocks of more
-///  complicated objects, such as internal helper methods or classes.
-///
-///  This can be used to access private/internal objects as well via
-/// </remarks>
-/// <example>
-///  This class can also be derived from to create a strongly typed wrapper
-///  that can then be associated via an extension method for the given type
-///  to provide consistent discovery and access.
-///
-///  <![CDATA[
-///   public class GuidTestAccessor : TestAccessor<Guid>
-///   {
-///     public TestAccessor(Guid instance) : base(instance) {}
-///
-///     public int A => Dynamic._a;
-///   }
-///
-///   public static partial class TestAccessors
-///   {
-///       public static GuidTestAccessor TestAccessor(this Guid guid)
-///           => new GuidTestAccessor(guid);
-///   }
-///  ]]>
-/// </example>
-public class TestAccessor<T> : ITestAccessor
-{
-    private static readonly Type s_type = typeof(T);
-    protected readonly T? _instance;
-    private readonly DynamicWrapper _dynamicWrapper;
-
-    /// <param name="instance">The type instance, can be null for statics.</param>
-    public TestAccessor(T? instance)
-    {
-        _instance = instance;
-        _dynamicWrapper = new DynamicWrapper(_instance);
-    }
-
-    /// <inheritdoc/>
-    public TDelegate CreateDelegate<TDelegate>(string? methodName = null)
-        where TDelegate : Delegate
-    {
-        Type type = typeof(TDelegate);
-        MethodInfo? invokeMethodInfo = type.GetMethod("Invoke");
-        Type[] types = invokeMethodInfo is null ? Array.Empty<Type>() : invokeMethodInfo.GetParameters().Select(pi => pi.ParameterType).ToArray();
-
-        // To make it easier to write a class wrapper with a number of delegates,
-        // we'll take the name from the delegate itself when unspecified.
-        methodName ??= type.Name;
-
-        MethodInfo? methodInfo = s_type.GetMethod(
-            methodName,
-            BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static,
-            binder: null,
-            types,
-            modifiers: null);
-
-        if (methodInfo is null)
-            throw new ArgumentException($"Could not find non public method {methodName}.");
-
-        return (TDelegate)methodInfo.CreateDelegate(type, methodInfo.IsStatic ? null : _instance);
-    }
-
-    /// <inheritdoc/>
-    public dynamic Dynamic => _dynamicWrapper;
-
-    private class DynamicWrapper : DynamicObject
-    {
-        private readonly object? _instance;
-
-        public DynamicWrapper(object? instance)
-            => _instance = instance;
-
-        public override bool TryInvokeMember(InvokeMemberBinder binder, object?[]? args, out object? result)
-        {
-            result = null;
-            ArgumentNullException.ThrowIfNull(args);
-            ArgumentNullException.ThrowIfNull(binder);
-
-            MethodInfo? methodInfo = null;
-            Type? type = s_type;
-
-            do
-            {
-                try
-                {
-                    methodInfo = type?.GetMethod(
-                        binder.Name,
-                        BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
-                }
-                catch (AmbiguousMatchException)
-                {
-                    // More than one match for the name, specify the arguments.
-                    // We currently do not have a scenario where we are trying to pass null as an argument
-                    // to an overloaded method. This will need to be updated once we have a scenario.
-                    methodInfo = type?.GetMethod(
-                        binder.Name,
-                        BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static,
-                        binder: null,
-                        args.Select(a => a!.GetType()).ToArray(),
-                        modifiers: null);
-                }
-
-                if (methodInfo is not null || type == typeof(object))
-                {
-                    // Found something, or already at the top of the type heirarchy
-                    break;
-                }
-
-                // Walk up the heirarchy
-                type = type?.BaseType;
-            }
-            while (true);
-
-            if (methodInfo is null)
-                return false;
-
-            result = methodInfo.Invoke(_instance, args);
-            return true;
-        }
-
-        public override bool TrySetMember(SetMemberBinder binder, object? value)
-        {
-            MemberInfo? info = GetFieldOrPropertyInfo(binder.Name);
-            if (info is null)
-                return false;
-
-            SetValue(info, value);
-            return true;
-        }
-
-        public override bool TryGetMember(GetMemberBinder binder, out object? result)
-        {
-            result = null;
-
-            MemberInfo? info = GetFieldOrPropertyInfo(binder.Name);
-            if (info is null)
-                return false;
-
-            result = GetValue(info);
-            return true;
-        }
-
-        private MemberInfo? GetFieldOrPropertyInfo(string memberName)
-        {
-            Type? type = s_type;
-            MemberInfo? info;
-
-            do
-            {
-                info = (MemberInfo?)type?.GetField(
-                    memberName,
-                    BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)
-                    ?? type?.GetProperty(
-                        memberName,
-                        BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
-
-                if (info is not null || type == typeof(object))
-                {
-                    // Found something, or already at the top of the type heirarchy
-                    break;
-                }
-
-                // Walk up the type heirarchy
-                type = type?.BaseType;
-            }
-            while (true);
-
-            return info;
-        }
-
-        private object? GetValue(MemberInfo memberInfo)
-            => memberInfo switch
-            {
-                FieldInfo fieldInfo => fieldInfo.GetValue(_instance),
-                PropertyInfo propertyInfo => propertyInfo.GetValue(_instance),
-                _ => throw new InvalidOperationException()
-            };
-
-        private void SetValue(MemberInfo memberInfo, object? value)
-        {
-            switch (memberInfo)
-            {
-                case FieldInfo fieldInfo:
-                    fieldInfo.SetValue(_instance, value);
-                    break;
-                case PropertyInfo propertyInfo:
-                    propertyInfo.SetValue(_instance, value);
-                    break;
-                default:
-                    throw new InvalidOperationException();
-            }
-        }
-    }
-}
diff --git a/src/Common/tests/TestUtilities/TestAccessors.cs b/src/Common/tests/TestUtilities/TestAccessors.cs
deleted file mode 100644
index 50250220628..00000000000
--- a/src/Common/tests/TestUtilities/TestAccessors.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-/// <summary>
-///  Extension methods for associating internals test accessors with
-///  types being tested.
-/// </summary>
-/// <remarks>
-///  In the System namespace for implicit discovery.
-/// </remarks>
-public static partial class TestAccessors
-{
-    // Need to pass a null parameter when constructing a static instance
-    // of TestAccessor. As this is pretty common and never changes, caching
-    // the array here.
-    private static object?[] s_nullObjectParam = { null };
-
-    /// <summary>
-    ///  Extension that creates a generic internals test accessor for a
-    ///  given instance or Type class (if only accessing statics).
-    /// </summary>
-    /// <param name="instanceOrType">
-    ///  Instance or Type class (if only accessing statics).
-    /// </param>
-    /// <example>
-    /// <![CDATA[
-    ///  Version version = new Version(4, 1);
-    ///  Assert.Equal(4, version.TestAccessor().Dynamic._Major));
-    ///
-    ///  // Or
-    ///
-    ///  dynamic accessor = version.TestAccessor().Dynamic;
-    ///  Assert.Equal(4, accessor._Major));
-    /// ]]>
-    /// </example>
-    public static ITestAccessor TestAccessor(this object instanceOrType)
-    {
-        ITestAccessor? testAccessor = instanceOrType is Type type
-            ? (ITestAccessor?)Activator.CreateInstance(
-                typeof(TestAccessor<>).MakeGenericType(type),
-                s_nullObjectParam)
-            : (ITestAccessor?)Activator.CreateInstance(
-                typeof(TestAccessor<>).MakeGenericType(instanceOrType.GetType()),
-                instanceOrType);
-
-        if (testAccessor is null)
-        {
-            throw new ArgumentException("Cannot create TestAccessor for Nullable<T> instances with no value.");
-        }
-
-        return testAccessor;
-    }
-}
diff --git a/src/Common/tests/TestUtilities/TestIncludeType.cs b/src/Common/tests/TestUtilities/TestIncludeType.cs
deleted file mode 100644
index f65421e8124..00000000000
--- a/src/Common/tests/TestUtilities/TestIncludeType.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.TestUtilities;
-
-[Flags]
-public enum TestIncludeType
-{
-    All,
-    NoPositives,
-    NoNegatives
-}
diff --git a/src/Common/tests/TestUtilities/ThreadCultureChange.cs b/src/Common/tests/TestUtilities/ThreadCultureChange.cs
deleted file mode 100644
index 715586673af..00000000000
--- a/src/Common/tests/TestUtilities/ThreadCultureChange.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-
-namespace System;
-
-public sealed class ThreadCultureChange : IDisposable
-{
-    private readonly CultureInfo _origCulture = CultureInfo.CurrentCulture;
-    private readonly CultureInfo _origUICulture = CultureInfo.CurrentUICulture;
-
-    public ThreadCultureChange(string? cultureName) :
-        this(cultureName is object ? new CultureInfo(cultureName) : null)
-    {
-    }
-
-    public ThreadCultureChange(CultureInfo? newCulture) :
-        this(newCulture, null)
-    {
-    }
-
-    public ThreadCultureChange(CultureInfo? newCulture, CultureInfo? newUICulture)
-    {
-        if (newCulture is object)
-        {
-            _origCulture = CultureInfo.CurrentCulture;
-            CultureInfo.CurrentCulture = newCulture;
-        }
-
-        if (newUICulture is object)
-        {
-            _origUICulture = CultureInfo.CurrentUICulture;
-            CultureInfo.CurrentUICulture = newUICulture;
-        }
-    }
-
-    public void Dispose()
-    {
-        CultureInfo.CurrentCulture = _origCulture;
-        CultureInfo.CurrentUICulture = _origUICulture;
-    }
-}
diff --git a/src/Common/tests/TestUtilities/ThrowingTraceListener.cs b/src/Common/tests/TestUtilities/ThrowingTraceListener.cs
deleted file mode 100644
index f85b1a03788..00000000000
--- a/src/Common/tests/TestUtilities/ThrowingTraceListener.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Diagnostics;
-
-namespace System;
-
-public sealed class ThrowingTraceListener : TraceListener
-{
-    public static ThrowingTraceListener Instance { get; } = new();
-
-    public override void Fail(string? message, string? detailMessage)
-    {
-        throw new InvalidOperationException(
-            (string.IsNullOrEmpty(message) ? "Assertion failed" : message) +
-            (string.IsNullOrEmpty(detailMessage) ? "" : Environment.NewLine + detailMessage));
-    }
-
-    public override void Write(object? o)
-    {
-    }
-
-    public override void Write(object? o, string? category)
-    {
-    }
-
-    public override void Write(string? message)
-    {
-    }
-
-    public override void Write(string? message, string? category)
-    {
-    }
-
-    public override void WriteLine(object? o)
-    {
-    }
-
-    public override void WriteLine(object? o, string? category)
-    {
-    }
-
-    public override void WriteLine(string? message)
-    {
-    }
-
-    public override void WriteLine(string? message, string? category)
-    {
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/BoolDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/BoolDataAttribute.cs
deleted file mode 100644
index fe5f3e085e8..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/BoolDataAttribute.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for true/false.
-/// </summary>
-public class BoolDataAttribute : CommonMemberDataAttribute
-{
-    public BoolDataAttribute() : base(typeof(BoolDataAttribute), nameof(TheoryData)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(true, false);
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/CommonMemberDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/CommonMemberDataAttribute.cs
deleted file mode 100644
index 953f4837f4a..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/CommonMemberDataAttribute.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-
-namespace Xunit;
-
-/// <summary>
-///  A custom MemberData attribute that is specialized for the CommonTestHelper type.
-///  Useful to remove the need to suffix all attributes with "MemberType = ..."
-///  We cannot inherit from <see cref="MemberDataAttribute"/> as it is sealed, so we have to reimplement
-///  ConvertDataItem inheriting from MemberDataAttributeBase.
-/// </summary>
-public class CommonMemberDataAttribute : MemberDataAttributeBase
-{
-    public CommonMemberDataAttribute(Type memberType, string memberName = "TheoryData")
-        : this(memberType, memberName, null) { }
-
-    public CommonMemberDataAttribute(Type memberType, string memberName, params object[]? parameters)
-        : base(memberName, parameters)
-    {
-        MemberType = memberType;
-    }
-
-    protected override object[]? ConvertDataItem(MethodInfo testMethod, object? item)
-    {
-        if (item is null)
-        {
-            return null;
-        }
-
-        if (item is not object[] array)
-        {
-            throw new ArgumentException($"Property {MemberName} on {MemberType ?? testMethod.DeclaringType} yielded an item that is not an object[], but {item.GetType().Name}");
-        }
-
-        return array;
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/EnumDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/EnumDataAttribute.cs
deleted file mode 100644
index a7658589eff..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/EnumDataAttribute.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for all defined values for the specified enum type.
-/// </summary>
-public class EnumDataAttribute<TEnum> : CommonMemberDataAttribute where TEnum : struct, Enum
-{
-    public EnumDataAttribute() : base(typeof(EnumDataAttribute<TEnum>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(Enum.GetValues<TEnum>());
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/FloatingPointDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/FloatingPointDataAttribute.cs
deleted file mode 100644
index bace832f5d1..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/FloatingPointDataAttribute.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for a set of floating point number values.
-/// </summary>
-public class FloatingPointDataAttribute<TNumber> : CommonMemberDataAttribute
-    where TNumber : struct, IBinaryFloatingPointIeee754<TNumber>, IMinMaxValue<TNumber>
-{
-    public FloatingPointDataAttribute() : base(typeof(FloatingPointDataAttribute<TNumber>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(TestData.GetFloatingPointData<TNumber>());
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/FloatingPointToleranceComparerer.cs b/src/Common/tests/TestUtilities/XUnit/FloatingPointToleranceComparerer.cs
deleted file mode 100644
index 520a0c7d18e..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/FloatingPointToleranceComparerer.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace System.XUnit;
-
-/// <summary>
-///  Equality comparer for numbers that checks whether two values are within a specifed tolerance.
-/// </summary>
-public class FloatingPointToleranceComparerer<T> : IEqualityComparer<T>
-    where T : struct, IFloatingPoint<T>
-{
-    private T _tolerance;
-
-    /// <param name="tolerance">The difference must be less than or equal to this number.</param>
-    public FloatingPointToleranceComparerer(T tolerance) => _tolerance = T.Abs(tolerance);
-
-    public bool Equals(T x, T y) => ComparisonHelpers.EqualsFloating(x, y, _tolerance);
-
-    public int GetHashCode([DisallowNull] T obj) => obj.GetHashCode();
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/IntegerDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/IntegerDataAttribute.cs
deleted file mode 100644
index 2c3a4d0d54b..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/IntegerDataAttribute.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for a representative set of number values.
-/// </summary>
-public class IntegerDataAttribute<TNumber> : CommonMemberDataAttribute
-    where TNumber : struct, IBinaryInteger<TNumber>, IMinMaxValue<TNumber>
-{
-    public IntegerDataAttribute() : base(typeof(IntegerDataAttribute<TNumber>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(TestData.GetIntegerData<TNumber>());
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/InvalidEnumDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/InvalidEnumDataAttribute.cs
deleted file mode 100644
index e382fb92680..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/InvalidEnumDataAttribute.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for an invalid enum value.
-/// </summary>
-public class InvalidEnumDataAttribute<TEnum> : CommonMemberDataAttribute where TEnum : unmanaged, Enum
-{
-    public InvalidEnumDataAttribute() : base(typeof(InvalidEnumDataAttribute<TEnum>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = InitializeData();
-
-    private static unsafe ReadOnlyTheoryData InitializeData()
-    {
-        ulong maxValue = ulong.MaxValue >>> ((sizeof(ulong) - sizeof(TEnum)) * 8);
-        TEnum currentValue = default;
-        bool defined;
-
-        List<TEnum> data = new();
-
-        if (typeof(TEnum).GetCustomAttribute<FlagsAttribute>() is not null)
-        {
-            // Bit flags, pull the first flag from the top.
-            ulong currentFlagValue = 1ul << (sizeof(TEnum) * 8) - 1;
-            do
-            {
-                currentValue = Unsafe.As<ulong, TEnum>(ref currentFlagValue);
-                defined = Enum.IsDefined(currentValue);
-                currentFlagValue >>>= 1;
-            }
-            while (defined && currentFlagValue > 0);
-
-            if (defined)
-            {
-                throw new InvalidOperationException("Enum has all flags defined");
-            }
-
-            data.Add(currentValue);
-            return new(data);
-        }
-
-        // Not a flags enum, add the smallest and largest undefined value.
-        ulong minValue = 0;
-
-        do
-        {
-            currentValue = Unsafe.As<ulong, TEnum>(ref minValue);
-            defined = Enum.IsDefined(currentValue);
-            minValue++;
-        }
-        while (defined);
-
-        data.Add(currentValue);
-
-        do
-        {
-            currentValue = Unsafe.As<ulong, TEnum>(ref maxValue);
-            defined = Enum.IsDefined(currentValue);
-            maxValue--;
-        }
-        while (defined);
-
-        data.Add(currentValue);
-        return new(data);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/NewAndDefaultDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/NewAndDefaultDataAttribute.cs
deleted file mode 100644
index cec932e0059..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/NewAndDefaultDataAttribute.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for <see langword="default"/> and the default constructor
-///  for the given class type.
-/// </summary>
-public class NewAndDefaultDataAttribute<TClass> : CommonMemberDataAttribute where TClass : new()
-{
-    public NewAndDefaultDataAttribute() : base(typeof(NewAndDefaultDataAttribute<TClass>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(new TClass(), default);
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/NormalizedStringDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/NormalizedStringDataAttribute.cs
deleted file mode 100644
index 46526385344..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/NormalizedStringDataAttribute.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data to test normalization of <see langword="null"/> to
-///  <see cref="string.Empty"/>.
-/// </summary>
-public class NormalizedStringDataAttribute : CommonMemberDataAttribute
-{
-    public NormalizedStringDataAttribute() : base(typeof(NormalizedStringDataAttribute)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(new TheoryData<string?, string>()
-    {
-        { null, string.Empty },
-        { string.Empty, string.Empty },
-        { "teststring", "teststring" }
-    });
-}
-
diff --git a/src/Common/tests/TestUtilities/XUnit/NullAndEmptyStringDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/NullAndEmptyStringDataAttribute.cs
deleted file mode 100644
index 866f289af99..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/NullAndEmptyStringDataAttribute.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for <see langword="null"/> and <see cref="string.Empty"/>.
-/// </summary>
-public class NullAndEmptyStringDataAttribute : CommonMemberDataAttribute
-{
-    public NullAndEmptyStringDataAttribute() : base(typeof(NullAndEmptyStringDataAttribute)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(null, string.Empty);
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/PositiveNumberDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/PositiveNumberDataAttribute.cs
deleted file mode 100644
index 0214e957a8c..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/PositiveNumberDataAttribute.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for a representative set of positive number values.
-/// </summary>
-public class PositiveIntegerDataAttribute<TNumber>
-    : CommonMemberDataAttribute where TNumber : struct, IBinaryInteger<TNumber>, IMinMaxValue<TNumber>
-{
-    public PositiveIntegerDataAttribute() : base(typeof(PositiveIntegerDataAttribute<TNumber>)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(TestData.GetPositiveIntegerData<TNumber>());
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/ReadOnlyTheoryData.cs b/src/Common/tests/TestUtilities/XUnit/ReadOnlyTheoryData.cs
deleted file mode 100644
index 52365efabde..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/ReadOnlyTheoryData.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace Xunit;
-
-/// <summary>
-///  Xunit compatible readonly theory data. Can be constructed around <see cref="TheoryData"/>.
-/// </summary>
-/// <remarks>
-///  <para>
-///   This type avoids inadvertently adding data, which is of a particular concern when broadly sharing test data.
-///  </para>
-/// </remarks>
-public class ReadOnlyTheoryData : IEnumerable<object?[]>
-{
-    private readonly IEnumerable<object?[]> _data;
-
-    public ReadOnlyTheoryData(IEnumerable<object?[]> data) => _data = data;
-
-    public ReadOnlyTheoryData(IEnumerable data)
-        => _data = data.Cast<object>().Select(i => new object?[] { i }).ToArray();
-
-    public ReadOnlyTheoryData(IEnumerable<object> data)
-        => _data = data.Select(i => new object?[] { i }).ToArray();
-
-    public ReadOnlyTheoryData(params object?[] data)
-        => _data = data.Select(i => new object?[] { i }).ToArray();
-
-    IEnumerator<object?[]> IEnumerable<object?[]>.GetEnumerator() => _data.GetEnumerator();
-
-    IEnumerator IEnumerable.GetEnumerator() => _data.GetEnumerator();
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureAttribute.cs b/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureAttribute.cs
deleted file mode 100644
index 415907fe649..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureAttribute.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Sdk;
-
-namespace Xunit;
-
-/// <summary>
-///  Apply this attribute to your test method or class to skip it on a certain architecture.
-/// </summary>
-/// <remarks>
-///  <para>
-///   This attribute isn't able to distinguish Arm64 from x64. To skip tests on Arm64 use
-///   <see cref="TestArchitectures.X64"/>. See https://github.com/dotnet/winforms/issues/7013.
-///  </para>
-/// </remarks>
-[TraitDiscoverer("System.SkipOnArchitectureDiscoverer", "System.Windows.Forms.TestUtilities")]
-[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
-public class SkipOnArchitectureAttribute : Attribute, ITraitAttribute
-{
-    public SkipOnArchitectureAttribute(TestArchitectures testArchitectures, string reason) { }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureDiscoverer.cs b/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureDiscoverer.cs
deleted file mode 100644
index 9b395d7f916..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/SkipOnArchitectureDiscoverer.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.XUnitExtensions;
-using Xunit.Abstractions;
-using Xunit.Sdk;
-
-namespace Xunit;
-
-/// <summary>
-///  This class discovers all of the tests and test classes that have
-///  applied the <see cref="SkipOnArchitectureAttribute"/>.
-/// </summary>
-public class SkipOnArchitectureDiscoverer : ITraitDiscoverer
-{
-    /// <summary>
-    ///  Gets the trait values from the Category attribute.
-    /// </summary>
-    /// <param name="traitAttribute">The trait attribute containing the trait values.</param>
-    /// <returns>The trait values.</returns>
-    public IEnumerable<KeyValuePair<string, string>> GetTraits(IAttributeInfo traitAttribute)
-    {
-        TestArchitectures testArchitectures = 0;
-
-        if (traitAttribute.GetConstructorArguments().FirstOrDefault() is TestArchitectures architectures)
-        {
-            testArchitectures = architectures;
-        }
-
-        if ((testArchitectures.HasFlag(TestArchitectures.X86) && RuntimeInformation.ProcessArchitecture == Architecture.X86) ||
-            (testArchitectures.HasFlag(TestArchitectures.X64) && RuntimeInformation.ProcessArchitecture == Architecture.X64))
-        {
-            return new[] { new KeyValuePair<string, string>(XunitConstants.Category, XunitConstants.IgnoreForCI) };
-        }
-
-        return Array.Empty<KeyValuePair<string, string>>();
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/StringDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/StringDataAttribute.cs
deleted file mode 100644
index 55b91582a22..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/StringDataAttribute.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data with <see cref="string.Empty"/> and
-///  a sample <see langword="string"/>.
-/// </summary>
-public class StringDataAttribute : CommonMemberDataAttribute
-{
-    public StringDataAttribute() : base(typeof(StringDataAttribute)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(string.Empty, "teststring");
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/StringWithNullDataAttribute.cs b/src/Common/tests/TestUtilities/XUnit/StringWithNullDataAttribute.cs
deleted file mode 100644
index 90933b49959..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/StringWithNullDataAttribute.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-/// <summary>
-///  Generates <see cref="TheoryAttribute"/> data for <see langword="null"/>, <see cref="string.Empty"/>, and
-///  a sample <see langword="string"/>.
-/// </summary>
-public class StringWithNullDataAttribute : CommonMemberDataAttribute
-{
-    public StringWithNullDataAttribute() : base(typeof(StringWithNullDataAttribute)) { }
-
-    public static ReadOnlyTheoryData TheoryData { get; } = new(null, string.Empty, "teststring");
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/TestArchitectures.cs b/src/Common/tests/TestUtilities/XUnit/TestArchitectures.cs
deleted file mode 100644
index 4b89411a692..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/TestArchitectures.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Xunit;
-
-[Flags]
-public enum TestArchitectures
-{
-    X86 = 1,
-    X64 = 2,
-    Any = ~0
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/TestData.cs b/src/Common/tests/TestUtilities/XUnit/TestData.cs
deleted file mode 100644
index 30cf86dd4fb..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/TestData.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.Numerics;
-namespace Xunit;
-
-/// <summary>
-///  Raw, cached test data.
-/// </summary>
-public static class TestData
-{
-    /// <summary>
-    ///  Returns a variety of floating point test cases.
-    /// </summary>
-    public static ImmutableArray<T> GetFloatingPointData<T>()
-        where T : struct, IBinaryFloatingPointIeee754<T>, IMinMaxValue<T>
-        => FloatingPointData<T>.Data;
-
-    /// <summary>
-    ///  Returns a variety of integer test cases.
-    /// </summary>
-    public static ImmutableArray<T> GetIntegerData<T>()
-        where T : struct, IBinaryInteger<T>, IMinMaxValue<T>
-        => IntegerData<T>.Data;
-
-    /// <summary>
-    ///  Returns a variety of positive integer test cases.
-    /// </summary>
-    public static ImmutableArray<T> GetPositiveIntegerData<T>()
-        where T : struct, IBinaryInteger<T>, IMinMaxValue<T>
-        => PositiveIntegerData<T>.Data;
-
-    private static class FloatingPointData<T>
-        where T : struct, IBinaryFloatingPointIeee754<T>, IMinMaxValue<T>
-    {
-        public static ImmutableArray<T> Data { get; } = ImmutableArray.Create(new T[]
-        {
-            T.MinValue,
-            T.MaxValue,
-            T.One,
-            T.Zero,
-            T.NegativeOne,
-            T.MaxValue / (T.One + T.One),
-            T.NaN,
-            T.NegativeInfinity,
-            T.Epsilon,
-            T.Epsilon * T.NegativeOne
-        });
-    }
-
-    private static class IntegerData<T>
-        where T : struct, IBinaryInteger<T>, IMinMaxValue<T>
-    {
-        public static ImmutableArray<T> Data { get; }
-            = ImmutableArray.Create(T.MinValue == T.Zero
-                ? new T[]
-                    {
-                        T.MinValue,
-                        T.MaxValue,
-                        T.One,
-                        T.MaxValue / (T.One + T.One)
-                    }
-                : new T[]
-                    {
-                        T.MinValue,
-                        T.MaxValue,
-                        T.One,
-                        T.Zero,
-                        T.Zero - T.One,
-                        T.MaxValue / (T.One + T.One)
-                    });
-    }
-
-    private static class PositiveIntegerData<T>
-        where T : struct, IBinaryInteger<T>, IMinMaxValue<T>
-    {
-        public static ImmutableArray<T> Data { get; } = ImmutableArray.Create(new T[]
-        {
-            T.Zero,
-            T.MaxValue,
-            T.One,
-            T.MaxValue / (T.One + T.One)
-        });
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/UseCultureAttribute.cs b/src/Common/tests/TestUtilities/XUnit/UseCultureAttribute.cs
deleted file mode 100644
index 99509da412b..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/UseCultureAttribute.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-// The original code was borrowed from https://github.com/xunit/samples.xunit/blob/93f87d5/UseCulture/UseCultureAttribute.cs
-// Licensed under http://www.apache.org/licenses/LICENSE-2.0.
-
-using System.Globalization;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using Xunit.Sdk;
-
-namespace Xunit;
-
-/// <summary>
-///  Apply this attribute to your test method to replace the <see cref="Thread.CurrentThread" /> <see cref="CultureInfo.CurrentCulture" /> and
-///  <see cref="CultureInfo.CurrentUICulture" /> with another culture.
-/// </summary>
-[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-public class UseCultureAttribute : BeforeAfterTestAttribute
-{
-    private readonly Lazy<CultureInfo> _culture;
-    private readonly Lazy<CultureInfo> _uiCulture;
-
-    // These will be set to a value that is never null in the Before method
-    // which will always run before it is used in the After method.
-    private CultureInfo _originalCulture = null!;
-    private CultureInfo _originalUICulture = null!;
-
-    private bool _updateUnmanagedUiThreadCulture;
-
-    /// <summary>
-    ///  Replaces the culture and UI culture of the current thread with <paramref name="culture" />.
-    /// </summary>
-    /// <param name="culture">The name of the culture to set for both <see cref="Culture" /> and <see cref="UICulture" />.</param>
-    public UseCultureAttribute(string culture)
-        : this(culture, culture)
-    {
-    }
-
-    /// <summary>
-    ///  Replaces the culture and UI culture of the current thread with <paramref name="culture" /> and <paramref name="uiCulture" />.
-    /// </summary>
-    /// <param name="culture">The name of the culture.</param>
-    /// <param name="uiCulture">The name of the UI culture.</param>
-    public UseCultureAttribute(string culture, string uiCulture)
-    {
-        _culture = new Lazy<CultureInfo>(() => new(culture, useUserOverride: false));
-        _uiCulture = new Lazy<CultureInfo>(() => new(uiCulture, useUserOverride: false));
-    }
-
-    /// <summary>
-    /// Gets the culture.
-    /// </summary>
-    public CultureInfo Culture => _culture.Value;
-
-    /// <summary>
-    ///  Indicates whether the native thread UI culture should also be set.
-    /// </summary>
-    public bool SetUnmanagedUiThreadCulture { get; set; }
-
-    /// <summary>
-    /// Gets the UI culture.
-    /// </summary>
-    public CultureInfo UICulture => _uiCulture.Value;
-
-    /// <summary>
-    /// Stores the current <see cref="Thread.CurrentPrincipal" />
-    /// <see cref="CultureInfo.CurrentCulture" /> and <see cref="CultureInfo.CurrentUICulture" />
-    /// and replaces them with the new cultures defined in the constructor.
-    /// </summary>
-    /// <param name="methodUnderTest">The method under test</param>
-    public override unsafe void Before(MethodInfo methodUnderTest)
-    {
-        _originalCulture = Thread.CurrentThread.CurrentCulture;
-        _originalUICulture = Thread.CurrentThread.CurrentUICulture;
-
-        CultureInfo.DefaultThreadCurrentCulture = Culture;
-        Thread.CurrentThread.CurrentCulture = Culture;
-        Thread.CurrentThread.CurrentUICulture = UICulture;
-
-        _updateUnmanagedUiThreadCulture = !_originalUICulture.Equals(UICulture);
-        if (SetUnmanagedUiThreadCulture && _updateUnmanagedUiThreadCulture)
-        {
-            SetNativeUiThreadCulture(UICulture);
-        }
-
-        CultureInfo.CurrentCulture.ClearCachedData();
-        CultureInfo.CurrentUICulture.ClearCachedData();
-    }
-
-    /// <summary>
-    /// Restores the original <see cref="CultureInfo.CurrentCulture" /> and
-    /// <see cref="CultureInfo.CurrentUICulture" /> to <see cref="Thread.CurrentPrincipal" />
-    /// </summary>
-    /// <param name="methodUnderTest">The method under test</param>
-    public override void After(MethodInfo methodUnderTest)
-    {
-        Thread.CurrentThread.CurrentCulture = _originalCulture;
-        Thread.CurrentThread.CurrentUICulture = _originalUICulture;
-
-        if (SetUnmanagedUiThreadCulture && _updateUnmanagedUiThreadCulture)
-        {
-            SetNativeUiThreadCulture(_originalUICulture);
-        }
-
-        CultureInfo.CurrentCulture.ClearCachedData();
-        CultureInfo.CurrentUICulture.ClearCachedData();
-    }
-
-    // Thread.CurrentThread.CurrentUICulture only sets the UI culture for the managed resources.
-    private static unsafe void SetNativeUiThreadCulture(CultureInfo uiCulture)
-    {
-        uint pulNumLanguages = 0;
-        string lcid = uiCulture.LCID.ToString("X4");
-        fixed (char* plcid = lcid)
-        {
-            if (Interop.SetThreadPreferredUILanguages(Interop.MUI_LANGUAGE_ID, plcid, &pulNumLanguages) == Interop.BOOL.FALSE)
-            {
-                throw new InvalidOperationException("Unable to set the desired UI language.");
-            }
-        }
-    }
-
-    private static class Interop
-    {
-        internal const uint MUI_LANGUAGE_ID = 0x4;
-
-        internal enum BOOL : int
-        {
-            FALSE = 0,
-            TRUE = 1,
-        }
-
-        [DllImport("Kernel32.dll", ExactSpelling = true, CharSet = CharSet.Unicode)]
-        internal static extern unsafe BOOL SetThreadPreferredUILanguages(
-            uint dwFlags,
-            char* pwszLanguagesBuffer,
-            uint* pulNumLanguages);
-    }
-}
diff --git a/src/Common/tests/TestUtilities/XUnit/UseDefaultXunitCultureAttribute.cs b/src/Common/tests/TestUtilities/XUnit/UseDefaultXunitCultureAttribute.cs
deleted file mode 100644
index bd89f93dc46..00000000000
--- a/src/Common/tests/TestUtilities/XUnit/UseDefaultXunitCultureAttribute.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-
-namespace Xunit;
-
-/// <summary>
-///  Apply this attribute to your test method to replace the <see cref="Thread.CurrentThread" /> <see cref="CultureInfo.CurrentCulture" /> and
-///  <see cref="CultureInfo.CurrentUICulture" /> with another culture.
-/// </summary>
-[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
-public class UseDefaultXunitCultureAttribute : UseCultureAttribute
-{
-    public const string DefaultXunitCultureAttribute = "en-US";
-
-    /// <summary>
-    ///  Replaces the culture and UI culture of the current thread with the <see cref="DefaultXunitCultureAttribute"/>.
-    /// </summary>
-    public UseDefaultXunitCultureAttribute()
-        : base(DefaultXunitCultureAttribute, DefaultXunitCultureAttribute)
-    {
-    }
-}
diff --git a/src/Microsoft.VisualBasic.Forms/Directory.Build.props b/src/Microsoft.VisualBasic.Forms/Directory.Build.props
deleted file mode 100644
index c76d0308b56..00000000000
--- a/src/Microsoft.VisualBasic.Forms/Directory.Build.props
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project>
-  <Import Project="..\..\Directory.Build.props" />
-  <PropertyGroup>
-    <StrongNameKeyId>Microsoft</StrongNameKeyId>
-  </PropertyGroup>
-</Project>
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft.VisualBasic.Forms.vbproj b/src/Microsoft.VisualBasic.Forms/src/Microsoft.VisualBasic.Forms.vbproj
deleted file mode 100644
index e57cd2e7598..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft.VisualBasic.Forms.vbproj
+++ /dev/null
@@ -1,54 +0,0 @@
-<Project>
-  <!--
-    https://github.com/dotnet/winforms/issues/2107#issuecomment-559289716
-    https://github.com/microsoft/msbuild/issues/4923#issuecomment-554265394
-    -->
-  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
-  
-  <PropertyGroup>
-    <AssemblyName>Microsoft.VisualBasic.Forms</AssemblyName>
-    <Deterministic>true</Deterministic>
-    <RootNamespace></RootNamespace>
-    <LangVersion>15.0</LangVersion>
-    <VBRuntime>None</VBRuntime>
-    <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
-    <UsePublicApiAnalyzers>true</UsePublicApiAnalyzers>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\System.Windows.Forms\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Update="Resources\Microsoft\VisualBasic\ProgressDialog.Designer.vb">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>ProgressDialog.resx</DependentUpon>
-    </Compile>
-    <Compile Update="Resources\Microsoft\VisualBasic\CompilerServices\VBInputBox.Designer.vb">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>VBInputBox.resx</DependentUpon>
-    </Compile>
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Update="Resources\SR.resx">
-      <GenerateSource>true</GenerateSource>
-      <Namespace>System</Namespace>
-    </EmbeddedResource>
-    <EmbeddedResource Update="Resources\Microsoft\VisualBasic\MyServices\Internal\ProgressDialog.resx">
-      <LogicalName>Microsoft.VisualBasic.MyServices.Internal.ProgressDialog.resources</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Update="Resources\Microsoft\VisualBasic\CompilerServices\VBInputBox.resx">
-      <LogicalName>Microsoft.VisualBasic.CompilerServices.VBInputBox.resources</LogicalName>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
-
-  <PropertyGroup>
-    <GetCopyToOutputDirectoryItemsDependsOn>AssignProjectConfiguration;$(GetCopyToOutputDirectoryItemsDependsOn)</GetCopyToOutputDirectoryItemsDependsOn>
-  </PropertyGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplicationBase.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplicationBase.vb
deleted file mode 100644
index 3ca6a80b3f3..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplicationBase.vb
+++ /dev/null
@@ -1,120 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports ExUtils = Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Abstract class that defines the application Startup/Shutdown model for VB
-    ''' Windows Applications such as console, WinForms, dll, service.
-    ''' </summary>
-    Public Class ApplicationBase
-
-        Public Sub New()
-        End Sub
-
-        ''' <summary>
-        ''' Returns the value of the specified environment variable.
-        ''' </summary>
-        ''' <param name="Name">A String containing the name of the environment variable.</param>
-        ''' <returns>A string containing the value of the environment variable.</returns>
-        ''' <exception cref="ArgumentNullException">if name is Nothing.</exception>
-        ''' <exception cref="ArgumentException">if the specified environment variable does not exist.</exception>
-        Public Function GetEnvironmentVariable(name As String) As String
-
-            ' Framework returns Null if not found.
-            Dim VariableValue As String = Environment.GetEnvironmentVariable(name)
-
-            ' Since the explicitly requested a specific environment variable and we couldn't find it, throw
-            If VariableValue Is Nothing Then
-                Throw ExUtils.GetArgumentExceptionWithArgName("name", SR.EnvVarNotFound_Name, name)
-            End If
-
-            Return VariableValue
-        End Function
-
-        ''' <summary>
-        ''' Provides access to logging capability.
-        ''' </summary>
-        ''' <value>Returns a Microsoft.VisualBasic.Windows.Log object used for logging to OS log, debug window
-        ''' and a delimited text file or xml log.</value>
-        Public ReadOnly Property Log() As Logging.Log
-            Get
-                If _log Is Nothing Then
-                    _log = New Logging.Log
-                End If
-                Return _log
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Returns the info about the application.  If we are executing in a DLL, we still return the info
-        ''' about the application, not the DLL.
-        ''' </summary>
-        Public ReadOnly Property Info() As AssemblyInfo
-            Get
-                If _info Is Nothing Then
-                    Dim Assembly As Reflection.Assembly = Reflection.Assembly.GetEntryAssembly()
-                    If Assembly Is Nothing Then 'It can be nothing if we are an add-in or a dll on the web
-                        Assembly = Reflection.Assembly.GetCallingAssembly()
-                    End If
-                    _info = New AssemblyInfo(Assembly)
-                End If
-                Return _info
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the information about the current culture used by the current thread.
-        ''' </summary>
-        Public ReadOnly Property Culture() As Globalization.CultureInfo
-            Get
-                Return Threading.Thread.CurrentThread.CurrentCulture
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the information about the current culture used by the Resource
-        ''' Manager to look up culture-specific resource at run time.
-        ''' </summary>
-        ''' <returns>
-        ''' The CultureInfo object that represents the culture used by the
-        ''' Resource Manager to look up culture-specific resources at run time.
-        ''' </returns>
-        Public ReadOnly Property UICulture() As Globalization.CultureInfo
-            Get
-                Return Threading.Thread.CurrentThread.CurrentUICulture
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Changes the culture currently in used by the current thread.
-        ''' </summary>
-        ''' <remarks>
-        ''' CultureInfo constructor will throw exceptions if cultureName is Nothing
-        ''' or an invalid CultureInfo ID. We are not catching those exceptions.
-        ''' </remarks>
-        Public Sub ChangeCulture(cultureName As String)
-            Threading.Thread.CurrentThread.CurrentCulture = New Globalization.CultureInfo(cultureName)
-        End Sub
-
-        ''' <summary>
-        ''' Changes the culture currently used by the Resource Manager to look
-        ''' up culture-specific resource at runtime.
-        ''' </summary>
-        ''' <remarks>
-        ''' CultureInfo constructor will throw exceptions if cultureName is Nothing
-        ''' or an invalid CultureInfo ID. We are not catching those exceptions.
-        ''' </remarks>
-        Public Sub ChangeUICulture(cultureName As String)
-            Threading.Thread.CurrentThread.CurrentUICulture = New Globalization.CultureInfo(cultureName)
-        End Sub
-
-        Private _log As Logging.Log 'Lazy-initialized and cached log object.
-        Private _info As AssemblyInfo ' The executing application (the EntryAssembly)
-    End Class 'ApplicationBase
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplyApplicationDefaultsEventArgs.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplyApplicationDefaultsEventArgs.vb
deleted file mode 100644
index cb198ad556f..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ApplyApplicationDefaultsEventArgs.vb
+++ /dev/null
@@ -1,52 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.ComponentModel
-Imports System.Drawing
-Imports System.Runtime.InteropServices
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Provides context for the ApplyApplicationDefaults event.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced), ComVisible(False)>
-    Public Class ApplyApplicationDefaultsEventArgs
-        Inherits EventArgs
-
-        Friend Sub New(minimumSplashScreenDisplayTime As Integer,
-                highDpiMode As HighDpiMode)
-            Me.MinimumSplashScreenDisplayTime = minimumSplashScreenDisplayTime
-            Me.HighDpiMode = highDpiMode
-        End Sub
-
-        ''' <summary>
-        ''' Setting this property inside the event handler causes a new default Font for Forms and UserControls to be set.
-        ''' </summary>
-        ''' <remarks>
-        ''' When the ApplyApplicationDefault event is raised, this property contains nothing. A new default Font for the
-        ''' application is applied by setting this property with a value different than nothing.
-        ''' </remarks>
-        Public Property Font As Font
-
-        ''' <summary>
-        ''' Setting this Property inside the event handler determines how long an application's Splash dialog is displayed at a minimum.
-        ''' </summary>
-        Public Property MinimumSplashScreenDisplayTime As Integer =
-            WindowsFormsApplicationBase.MINIMUM_SPLASH_EXPOSURE_DEFAULT
-
-        ''' <summary>
-        ''' Setting this Property inside the event handler determines the general HighDpiMode for the application.
-        ''' </summary>
-        ''' <remarks>
-        ''' The default value for this property is SystemAware.
-        ''' </remarks>
-        Public Property HighDpiMode As HighDpiMode
-
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/AssemblyInfo.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/AssemblyInfo.vb
deleted file mode 100644
index faa2a2ed6c2..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/AssemblyInfo.vb
+++ /dev/null
@@ -1,248 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.Collections.ObjectModel
-Imports System.Reflection
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    '''  A class that contains the information about an Application. This information can be
-    '''  specified using the assembly attributes (contained in AssemblyInfo.vb file in case of
-    '''  a VB project in Visual Studio .NET).
-    ''' </summary>
-    ''' <remarks>This class is based on the FileVersionInfo class of the framework, but
-    ''' reduced to a number of relevant properties.</remarks>
-    Public Class AssemblyInfo
-
-        ''' <summary>
-        ''' Creates an AssemblyInfo from an assembly
-        ''' </summary>
-        ''' <param name="CurrentAssembly">The assembly for which we want to obtain the information.</param>
-        Public Sub New(currentAssembly As Assembly)
-            If currentAssembly Is Nothing Then
-                Throw GetArgumentNullException("CurrentAssembly")
-            End If
-            _assembly = currentAssembly
-        End Sub
-
-        ''' <summary>
-        ''' Gets the description associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyDescriptionAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyDescriptionAttribute is not defined.</exception>
-        Public ReadOnly Property Description() As String
-            Get
-                If _description Is Nothing Then
-                    Dim Attribute As AssemblyDescriptionAttribute =
-                        CType(GetAttribute(GetType(AssemblyDescriptionAttribute)), AssemblyDescriptionAttribute)
-                    If Attribute Is Nothing Then
-                        _description = ""
-                    Else
-                        _description = Attribute.Description
-                    End If
-                End If
-                Return _description
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the company name associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyCompanyAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyCompanyAttribute is not defined.</exception>
-        Public ReadOnly Property CompanyName() As String
-            Get
-                If _companyName Is Nothing Then
-                    Dim Attribute As AssemblyCompanyAttribute =
-                        CType(GetAttribute(GetType(AssemblyCompanyAttribute)), AssemblyCompanyAttribute)
-                    If Attribute Is Nothing Then
-                        _companyName = ""
-                    Else
-                        _companyName = Attribute.Company
-                    End If
-                End If
-                Return _companyName
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the title associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyTitleAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyTitleAttribute is not defined.</exception>
-        Public ReadOnly Property Title() As String
-            Get
-                If _title Is Nothing Then
-                    Dim Attribute As AssemblyTitleAttribute =
-                        CType(GetAttribute(GetType(AssemblyTitleAttribute)), AssemblyTitleAttribute)
-                    If Attribute Is Nothing Then
-                        _title = ""
-                    Else
-                        _title = Attribute.Title
-                    End If
-                End If
-                Return _title
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the copyright notices associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyCopyrightAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyCopyrightAttribute is not defined.</exception>
-        Public ReadOnly Property Copyright() As String
-            Get
-                If _copyright Is Nothing Then
-                    Dim Attribute As AssemblyCopyrightAttribute = CType(GetAttribute(GetType(AssemblyCopyrightAttribute)), AssemblyCopyrightAttribute)
-                    If Attribute Is Nothing Then
-                        _copyright = ""
-                    Else
-                        _copyright = Attribute.Copyright
-                    End If
-                End If
-                Return _copyright
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the trademark notices associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyTrademarkAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyTrademarkAttribute is not defined.</exception>
-        Public ReadOnly Property Trademark() As String
-            Get
-                If _trademark Is Nothing Then
-                    Dim Attribute As AssemblyTrademarkAttribute = CType(GetAttribute(GetType(AssemblyTrademarkAttribute)), AssemblyTrademarkAttribute)
-                    If Attribute Is Nothing Then
-                        _trademark = ""
-                    Else
-                        _trademark = Attribute.Trademark
-                    End If
-                End If
-                Return _trademark
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the product name associated with the assembly.
-        ''' </summary>
-        ''' <value>A String containing the AssemblyProductAttribute associated with the assembly.</value>
-        ''' <exception cref="InvalidOperationException">if the AssemblyProductAttribute is not defined.</exception>
-        Public ReadOnly Property ProductName() As String
-            Get
-                If _productName Is Nothing Then
-                    Dim Attribute As AssemblyProductAttribute = CType(GetAttribute(GetType(AssemblyProductAttribute)), AssemblyProductAttribute)
-                    If Attribute Is Nothing Then
-                        _productName = ""
-                    Else
-                        _productName = Attribute.Product
-                    End If
-                End If
-                Return _productName
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the version number of the assembly.
-        ''' </summary>
-        ''' <value>A System.Version class containing the version number of the assembly</value>
-        ''' <remarks>Cannot use AssemblyVersionAttribute since it always return Nothing.</remarks>
-        Public ReadOnly Property Version() As Version
-            Get
-                Return _assembly.GetName().Version
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the name of the file containing the manifest (usually the .exe file).
-        ''' </summary>
-        ''' <value>A String containing the file name.</value>
-        Public ReadOnly Property AssemblyName() As String
-            Get
-                Return _assembly.GetName.Name
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the directory where the assembly lives.
-        ''' </summary>
-        Public ReadOnly Property DirectoryPath() As String
-            Get
-                Return IO.Path.GetDirectoryName(_assembly.Location)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Returns the names of all assemblies loaded by the current application.
-        ''' </summary>
-        ''' <value>A ReadOnlyCollection(Of Assembly) containing all the loaded assemblies.</value>
-        ''' <exception cref="AppDomainUnloadedException">attempt on an unloaded application domain.</exception>
-        Public ReadOnly Property LoadedAssemblies() As ReadOnlyCollection(Of Assembly)
-            Get
-                Dim Result As New Collection(Of Assembly)
-                For Each Assembly As Assembly In AppDomain.CurrentDomain.GetAssemblies()
-                    Result.Add(Assembly)
-                Next
-                Return New ReadOnlyCollection(Of Assembly)(Result)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Returns the current stack trace information.
-        ''' </summary>
-        ''' <value>A string containing stack trace information. Value can be String.Empty.</value>
-        ''' <exception cref="ArgumentOutOfRangeException">The requested stack trace information is out of range.</exception>
-        Public ReadOnly Property StackTrace() As String
-            Get
-                Return Environment.StackTrace
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the amount of physical memory mapped to the process context.
-        ''' </summary>
-        ''' <value>
-        ''' A 64-bit signed integer containing the size of physical memory mapped to the process context, in bytes.
-        ''' </value>
-        Public ReadOnly Property WorkingSet() As Long
-            Get
-                Return Environment.WorkingSet
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets an attribute from the assembly and throw exception if the attribute does not exist.
-        ''' </summary>
-        ''' <param name="AttributeType">The type of the required attribute.</param>
-        ''' <returns>The attribute with the given type gotten from the assembly, or Nothing.</returns>
-        Private Function GetAttribute(AttributeType As Type) As Object
-
-            Debug.Assert(_assembly IsNot Nothing, "Null m_Assembly")
-
-            Dim Attributes() As Object = _assembly.GetCustomAttributes(AttributeType, inherit:=True)
-
-            If Attributes.Length = 0 Then
-                Return Nothing
-            Else
-                Return Attributes(0)
-            End If
-        End Function
-
-        ' Private fields.
-        Private ReadOnly _assembly As Assembly ' The assembly with the information.
-
-        ' Since these properties will not change during runtime, they're cached.
-        ' "" is not Nothing so use Nothing to mark an un-accessed property.
-        Private _description As String ' Cache the assembly's description.
-        Private _title As String ' Cache the assembly's title.
-        Private _productName As String ' Cache the assembly's product name.
-        Private _companyName As String ' Cache the assembly's company name.
-        Private _trademark As String ' Cache the assembly's trademark.
-        Private _copyright As String ' Cache the assembly's copyright.
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/CantStartSingleInstanceException.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/CantStartSingleInstanceException.vb
deleted file mode 100644
index f6a9d71e011..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/CantStartSingleInstanceException.vb
+++ /dev/null
@@ -1,43 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.ComponentModel
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Exception for when we launch a single-instance application and it can't connect with the 
-    ''' original instance.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    <Serializable()>
-    Public Class CantStartSingleInstanceException : Inherits Exception
-
-        ''' <summary>
-        '''  Creates a new exception
-        ''' </summary>
-        Public Sub New()
-            MyBase.New(GetResourceString(SR.AppModel_SingleInstanceCantConnect))
-        End Sub
-
-        Public Sub New(ByVal message As String)
-            MyBase.New(message)
-        End Sub
-
-        Public Sub New(ByVal message As String, ByVal inner As Exception)
-            MyBase.New(message, inner)
-        End Sub
-
-        ' Deserialization constructor must be defined since we are serializable
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        <Obsolete("Type or member is obsolete", DiagnosticId:="SYSLIB0051")>
-        Protected Sub New(ByVal info As Runtime.Serialization.SerializationInfo, ByVal context As Runtime.Serialization.StreamingContext)
-            MyBase.New(info, context)
-        End Sub
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBase.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBase.vb
deleted file mode 100644
index e438449ab72..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBase.vb
+++ /dev/null
@@ -1,62 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.ComponentModel
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Abstract class that defines the application Startup/Shutdown model for VB 
-    ''' Windows Applications such as console, winforms, dll, service.
-    ''' </summary>
-    Public Class ConsoleApplicationBase : Inherits ApplicationBase
-
-        ''' <summary>
-        ''' Constructs the application Shutdown/Startup model object
-        ''' </summary>
-        ''' <remarks>We have to have a parameterless constructor because the platform specific Application 
-        ''' object derives from this one and it doesn't define a constructor.  The partial class generated by the
-        ''' designer defines the constructor in order to configure the application.</remarks>
-        Public Sub New()
-            MyBase.New()
-        End Sub
-
-        ''' <summary>
-        '''  Returns the command line arguments for the current application.
-        ''' </summary>
-        ''' <remarks>This function differs from System.Environment.GetCommandLineArgs in that the
-        ''' path of the executing file (the 0th entry) is omitted from the returned collection</remarks>
-        Public ReadOnly Property CommandLineArgs() As ObjectModel.ReadOnlyCollection(Of String)
-            Get
-                If _commandLineArgs Is Nothing Then
-                    'Get rid of Arg(0) which is the path of the executing program.  Main(args() as string) doesn't report the name of the app and neither will we
-                    Dim EnvArgs As String() = System.Environment.GetCommandLineArgs
-                    If EnvArgs.GetLength(0) >= 2 Then '1 element means no args, just the executing program.  >= 2 means executing program + one or more command line arguments
-                        Dim NewArgs(EnvArgs.GetLength(0) - 2) As String 'dimming z(0) gives a z() of 1 element.
-                        Array.Copy(EnvArgs, 1, NewArgs, 0, EnvArgs.GetLength(0) - 1) 'copy everything but the 0th element (the path of the executing program)
-                        _commandLineArgs = New ObjectModel.ReadOnlyCollection(Of String)(NewArgs)
-                    Else
-                        _commandLineArgs = New ObjectModel.ReadOnlyCollection(Of String)(Array.Empty(Of String)())  'provide the empty set
-                    End If
-                End If
-                Return _commandLineArgs
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Allows derived classes to set what the command line should look like.  WindowsFormsApplicationBase calls this
-        ''' for instance because we snag the command line from Main().
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected WriteOnly Property InternalCommandLine() As ObjectModel.ReadOnlyCollection(Of String)
-            Set(value As ObjectModel.ReadOnlyCollection(Of String))
-                _commandLineArgs = value
-            End Set
-        End Property
-
-        Private _commandLineArgs As ObjectModel.ReadOnlyCollection(Of String) ' Lazy-initialized and cached collection of command line arguments.
-    End Class 'ApplicationBase
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/NoStartupFormException.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/NoStartupFormException.vb
deleted file mode 100644
index 967c9c805c7..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/NoStartupFormException.vb
+++ /dev/null
@@ -1,42 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.ComponentModel
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Exception for when the WinForms VB application model isn't supplied with a startup form
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    <Serializable()>
-    Public Class NoStartupFormException : Inherits Exception
-
-        ''' <summary>
-        '''  Creates a new exception
-        ''' </summary>
-        Public Sub New()
-            MyBase.New(GetResourceString(SR.AppModel_NoStartupForm))
-        End Sub
-
-        Public Sub New(message As String)
-            MyBase.New(message)
-        End Sub
-
-        Public Sub New(message As String, inner As Exception)
-            MyBase.New(message, inner)
-        End Sub
-
-        ' De-serialization constructor must be defined since we are serializable
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        <Obsolete("Type or member obsolete.", DiagnosticId:="SYSLIB0051")>
-        Protected Sub New(info As Runtime.Serialization.SerializationInfo, context As Runtime.Serialization.StreamingContext)
-            MyBase.New(info, context)
-        End Sub
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/SingleInstanceHelpers.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/SingleInstanceHelpers.vb
deleted file mode 100644
index 2e9ad84e522..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/SingleInstanceHelpers.vb
+++ /dev/null
@@ -1,93 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System
-Imports System.IO
-Imports System.IO.Pipes
-Imports System.Runtime.InteropServices
-Imports System.Runtime.Serialization
-Imports System.Threading
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    Friend Module SingleInstanceHelpers
-        Private Const NamedPipeOptions As PipeOptions = PipeOptions.Asynchronous Or PipeOptions.CurrentUserOnly
-
-        Friend Function TryCreatePipeServer(pipeName As String, <Out> ByRef pipeServer As NamedPipeServerStream) As Boolean
-            Try
-                pipeServer = New NamedPipeServerStream(
-                        pipeName:=pipeName,
-                        direction:=PipeDirection.In,
-                        maxNumberOfServerInstances:=1,
-                        transmissionMode:=PipeTransmissionMode.Byte,
-                        options:=NamedPipeOptions)
-                Return True
-            Catch ex As Exception
-                pipeServer = Nothing
-                Return False
-            End Try
-        End Function
-
-        Friend Async Function WaitForClientConnectionsAsync(pipeServer As NamedPipeServerStream, callback As Action(Of String()), cancellationToken As CancellationToken) As Task
-            While True
-                cancellationToken.ThrowIfCancellationRequested()
-                Await pipeServer.WaitForConnectionAsync(cancellationToken).ConfigureAwait(False)
-                Try
-                    Dim args = Await ReadArgsAsync(pipeServer, cancellationToken).ConfigureAwait(False)
-                    If args IsNot Nothing Then
-                        callback(args)
-                    End If
-                Finally
-                    pipeServer.Disconnect()
-                End Try
-            End While
-        End Function
-
-        Friend Async Function SendSecondInstanceArgsAsync(pipeName As String, args As String(), cancellationToken As CancellationToken) As Task
-            Using pipeClient As New NamedPipeClientStream(
-                            serverName:=".",
-                            pipeName:=pipeName,
-                            direction:=PipeDirection.Out,
-                            options:=NamedPipeOptions)
-                Await pipeClient.ConnectAsync(cancellationToken).ConfigureAwait(False)
-                Await WriteArgsAsync(pipeClient, args, cancellationToken).ConfigureAwait(False)
-            End Using
-        End Function
-
-        Private Async Function ReadArgsAsync(pipeServer As NamedPipeServerStream, cancellationToken As CancellationToken) As Task(Of String())
-            Const bufferLength = 1024
-            Dim buffer = New Byte(bufferLength - 1) {}
-            Using stream As New MemoryStream
-                While True
-                    Dim bytesRead = Await pipeServer.ReadAsync(buffer.AsMemory(0, bufferLength), cancellationToken).ConfigureAwait(False)
-                    If bytesRead = 0 Then
-                        Exit While
-                    End If
-                    stream.Write(buffer, 0, bytesRead)
-                End While
-                stream.Seek(0, SeekOrigin.Begin)
-                Dim serializer = New DataContractSerializer(GetType(String()))
-                Try
-                    Return DirectCast(serializer.ReadObject(stream), String())
-                Catch ex As Exception
-                    Return Nothing
-                End Try
-            End Using
-        End Function
-
-        Private Async Function WriteArgsAsync(pipeClient As NamedPipeClientStream, args As String(), cancellationToken As CancellationToken) As Task
-            Dim content As Byte()
-            Using stream As New MemoryStream
-                Dim serializer = New DataContractSerializer(GetType(String()))
-                serializer.WriteObject(stream, args)
-                content = stream.ToArray()
-            End Using
-            Await pipeClient.WriteAsync(content.AsMemory(0, content.Length), cancellationToken).ConfigureAwait(False)
-        End Function
-
-    End Module
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupEventArgs.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupEventArgs.vb
deleted file mode 100644
index 1520b75763e..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupEventArgs.vb
+++ /dev/null
@@ -1,37 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.Collections.ObjectModel
-Imports System.ComponentModel
-Imports System.Runtime.InteropServices
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Provides context for the Startup event.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced), ComVisible(False)>
-    Public Class StartupEventArgs
-        Inherits CancelEventArgs
-
-        ''' <summary>
-        ''' Creates a new instance of the StartupEventArgs.
-        ''' </summary>
-        Public Sub New(args As ReadOnlyCollection(Of String))
-            If args Is Nothing Then
-                args = New ReadOnlyCollection(Of String)(Nothing)
-            End If
-
-            CommandLine = args
-        End Sub
-
-        ''' <summary>
-        ''' Returns the command line sent to this application
-        ''' </summary>
-        Public ReadOnly Property CommandLine() As ReadOnlyCollection(Of String)
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgs.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgs.vb
deleted file mode 100644
index fc1f473fb1d..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgs.vb
+++ /dev/null
@@ -1,45 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.Collections.ObjectModel
-Imports System.ComponentModel
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Provides context for the StartupNextInstance event.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Class StartupNextInstanceEventArgs
-        Inherits EventArgs
-
-        ''' <summary>
-        ''' Creates a new instance of the StartupNextInstanceEventArgs.
-        ''' </summary>
-        Public Sub New(args As ReadOnlyCollection(Of String), bringToForegroundFlag As Boolean)
-            If args Is Nothing Then
-                args = New ReadOnlyCollection(Of String)(Nothing)
-            End If
-
-            CommandLine = args
-            BringToForeground = bringToForegroundFlag
-        End Sub
-
-        ''' <summary>
-        ''' Indicates whether we will bring the application to the foreground when processing the
-        ''' StartupNextInstance event.
-        ''' </summary>
-        Public Property BringToForeground() As Boolean
-
-        ''' <summary>
-        ''' Returns the command line sent to this application
-        ''' </summary>
-        ''' <remarks>I'm using Me.CommandLine so that it is consistent with my.net and to assure they
-        ''' always return the same values</remarks>
-        Public ReadOnly Property CommandLine() As ReadOnlyCollection(Of String)
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgs.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgs.vb
deleted file mode 100644
index efbf9f7eac3..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgs.vb
+++ /dev/null
@@ -1,31 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.ComponentModel
-Imports System.Runtime.InteropServices
-Imports System.Threading
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Provides the exception encountered along with a flag on whether to abort the program
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced), ComVisible(False)>
-    Public Class UnhandledExceptionEventArgs
-        Inherits ThreadExceptionEventArgs
-
-        Sub New(exitApplication As Boolean, exception As Exception)
-            MyBase.New(exception)
-            Me.ExitApplication = exitApplication
-        End Sub
-
-        ''' <summary>
-        ''' Indicates whether the application should exit upon exiting the exception handler
-        ''' </summary>
-        Public Property ExitApplication() As Boolean
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/User.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/User.vb
deleted file mode 100644
index 99acb320540..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/User.vb
+++ /dev/null
@@ -1,84 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.ComponentModel
-Imports System.Security.Principal
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ''' <summary>
-    ''' Class abstracting the computer user
-    ''' </summary>
-    Public Class User
-
-        ''' <summary>
-        ''' Creates an instance of User
-        ''' </summary>
-        Public Sub New()
-        End Sub
-
-        ''' <summary>
-        ''' The name of the current user
-        ''' </summary>
-        Public ReadOnly Property Name() As String
-            Get
-                Return InternalPrincipal.Identity.Name
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' The current IPrincipal which represents the current user
-        ''' </summary>
-        ''' <value>An IPrincipal representing the current user</value>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Public Property CurrentPrincipal() As IPrincipal
-            Get
-                Return InternalPrincipal
-            End Get
-            Set(value As IPrincipal)
-                InternalPrincipal = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Indicates whether or not the current user has been authenticated.
-        ''' </summary>
-        Public ReadOnly Property IsAuthenticated() As Boolean
-            Get
-                Return InternalPrincipal.Identity.IsAuthenticated
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Indicates whether or not the current user is a member of the passed in role
-        ''' </summary>
-        ''' <param name="role">The name of the role</param>
-        ''' <returns>True if the user is a member of the role otherwise False</returns>
-        Public Function IsInRole(role As String) As Boolean
-            Return InternalPrincipal.IsInRole(role)
-        End Function
-
-        ''' <summary>
-        ''' The principal representing the current user.
-        ''' </summary>
-        ''' <value>An IPrincipal representing the current user</value>
-        ''' <remarks> 
-        ''' This should be overridden by derived classes that don't get the current
-        ''' user from the current thread
-        ''' </remarks>
-        Protected Overridable Property InternalPrincipal() As IPrincipal
-            Get
-                Return System.Threading.Thread.CurrentPrincipal
-            End Get
-            Set(value As IPrincipal)
-                System.Threading.Thread.CurrentPrincipal = value
-            End Set
-        End Property
-
-    End Class 'User
-
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.WinFormsAppContext.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.WinFormsAppContext.vb
deleted file mode 100644
index 75cdbcfee4b..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.WinFormsAppContext.vb
+++ /dev/null
@@ -1,57 +0,0 @@
-Option Strict On
-Option Explicit On
-Option Infer On
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Security
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    Partial Public Class WindowsFormsApplicationBase
-
-        ''' <summary>
-        ''' Encapsulates an ApplicationContext.  We have our own to get the shutdown behaviors we
-        ''' offer in the application model.  This derivation of the ApplicationContext listens for when
-        ''' the main form closes and provides for shutting down when the main form closes or the
-        ''' last form closes, depending on the mode this application is running in.
-        ''' </summary>
-        Private NotInheritable Class WinFormsAppContext
-            Inherits ApplicationContext
-
-            Private ReadOnly _app As WindowsFormsApplicationBase
-
-            Sub New(App As WindowsFormsApplicationBase)
-                _app = App
-            End Sub
-
-            ''' <summary>
-            ''' Handles the two types of application shutdown:
-            '''   1 - shutdown when the main form closes
-            '''   2 - shutdown only after the last form closes
-            ''' </summary>
-            ''' <param name="sender"></param>
-            ''' <param name="e"></param>
-            <SecuritySafeCritical()>
-            Protected Overrides Sub OnMainFormClosed(sender As Object, e As EventArgs)
-                If _app.ShutdownStyle = ShutdownMode.AfterMainFormCloses Then
-                    MyBase.OnMainFormClosed(sender, e)
-                Else 'identify a new main form so we can keep running
-                    Dim forms As FormCollection = Application.OpenForms
-
-                    If forms.Count > 0 Then
-                        'Note: Initially I used Process::MainWindowHandle to obtain an open form.  But that is bad for two reasons:
-                        '1 - It appears to be broken and returns NULL sometimes even when there is still a window around.  WinForms people are looking at that issue.
-                        '2 - It returns the first window it hits from enum thread windows, which is not necessarily a windows forms form, so that doesn't help us even if it did work
-                        'all the time.  So I'll use one of our open forms.  We may not necessarily get a visible form here but that's OK.  Some apps may run on an invisible window
-                        'and we need to keep them going until all windows close.
-                        MainForm = forms(0)
-                    Else
-                        MyBase.OnMainFormClosed(sender, e)
-                    End If
-                End If
-            End Sub
-        End Class
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.vb
deleted file mode 100644
index d33cfb1fae5..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBase.vb
+++ /dev/null
@@ -1,1031 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-Option Infer On
-
-Imports System.Collections.ObjectModel
-Imports System.ComponentModel
-Imports System.IO.Pipes
-Imports System.Reflection
-Imports System.Runtime.InteropServices
-Imports System.Security
-Imports System.Threading
-Imports System.Windows.Forms
-Imports Microsoft.VisualBasic.CompilerServices
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic.ApplicationServices
-
-    ' Any changes to this enum must be reflected in ValidateAuthenticationModeEnumValue().
-    Public Enum AuthenticationMode
-        Windows
-        ApplicationDefined
-    End Enum
-
-    ' Any changes to this enum must be reflected in ValidateShutdownModeEnumValue().
-    Public Enum ShutdownMode
-        AfterMainFormCloses
-        AfterAllFormsClose
-    End Enum
-
-    ''' <summary>
-    ''' Signature for the ApplyApplicationDefaults event handler.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub ApplyApplicationDefaultsEventHandler(sender As Object, e As ApplyApplicationDefaultsEventArgs)
-
-    ''' <summary>
-    ''' Signature for the Startup event handler.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub StartupEventHandler(sender As Object, e As StartupEventArgs)
-
-    ''' <summary>
-    ''' Signature for the StartupNextInstance event handler.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub StartupNextInstanceEventHandler(sender As Object, e As StartupNextInstanceEventArgs)
-
-    ''' <summary>
-    ''' Signature for the Shutdown event handler.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub ShutdownEventHandler(sender As Object, e As EventArgs)
-
-    ''' <summary>
-    ''' Signature for the UnhandledException event handler.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub UnhandledExceptionEventHandler(sender As Object, e As UnhandledExceptionEventArgs)
-
-    ''' <summary>
-    ''' Provides the infrastructure for the VB Windows Forms application model.
-    ''' </summary>
-    ''' <remarks>Don't put access on this definition.</remarks>
-    Partial Public Class WindowsFormsApplicationBase : Inherits ConsoleApplicationBase
-
-        ''' <summary>
-        ''' Occurs when the application is ready to accept default values for various application areas.
-        ''' </summary>
-        Public Event ApplyApplicationDefaults As ApplyApplicationDefaultsEventHandler
-
-        ''' <summary>
-        ''' Occurs when the application starts.
-        ''' </summary>
-        Public Event Startup As StartupEventHandler
-
-        ''' <summary>
-        ''' Occurs when attempting to start a single-instance application and the application is already active.
-        ''' </summary>
-        Public Event StartupNextInstance As StartupNextInstanceEventHandler
-
-        ''' <summary>
-        ''' Occurs when the application shuts down.
-        ''' </summary>
-        Public Event Shutdown As ShutdownEventHandler
-
-        ' Used to marshal a call to Dispose on the Splash Screen.
-        Private Delegate Sub DisposeDelegate()
-
-        ' How long a subsequent instance will wait for the original instance to get on its feet.
-        Private Const SECOND_INSTANCE_TIMEOUT As Integer = 2500 ' milliseconds.
-        Friend Const MINIMUM_SPLASH_EXPOSURE_DEFAULT As Integer = 2000 ' milliseconds.
-
-        Private ReadOnly _splashLock As New Object
-        Private ReadOnly _appContext As WinFormsAppContext
-
-        ' Sync object
-        Private ReadOnly _networkAvailabilityChangeLock As New Object
-
-        Private _unhandledExceptionHandlers As List(Of UnhandledExceptionEventHandler)
-        Private _processingUnhandledExceptionEvent As Boolean
-
-        ' Tracks whether we need to create the network object so we can listen to the NetworkAvailabilityChanged event.
-        Private _turnOnNetworkListener As Boolean
-
-        ' Whether we have made it through the processing of OnInitialize.
-        Private _finishedOnInitialize As Boolean
-        Private _networkAvailabilityEventHandlers As List(Of Devices.NetworkAvailableEventHandler)
-        Private _networkObject As Devices.Network
-
-#Disable Warning IDE0032 ' Use auto property, Justification:=<Public API>
-
-        ' Whether this app runs using Word like instancing behavior.
-        Private _isSingleInstance As Boolean
-
-        ' Defines when the application decides to close.
-        Private _shutdownStyle As ShutdownMode
-
-        ' Whether to use Windows XP styles.
-        Private _enableVisualStyles As Boolean
-
-        ' We only need to show the splash screen once.
-        ' Protect the user from himself if they are overriding our app model.
-        Private _didSplashScreen As Boolean
-
-        ' For splash screens with a minimum display time, this let's us know when that time
-        ' has expired and it is OK to close the splash screen.
-        Private _splashScreenCompletionSource As TaskCompletionSource(Of Boolean)
-        Private _formLoadWaiter As AutoResetEvent
-        Private _splashScreen As Form
-
-        ' Minimum amount of time to show the splash screen.  0 means hide as soon as the app comes up.
-        Private _minimumSplashExposure As Integer = MINIMUM_SPLASH_EXPOSURE_DEFAULT
-        Private _splashTimer As Timers.Timer
-        Private _appSynchronizationContext As SynchronizationContext
-
-        ' Informs My.Settings whether to save the settings on exit or not.
-        Private _saveMySettingsOnExit As Boolean
-
-        ' The HighDpiMode the user picked from the AppDesigner or assigned to the ApplyHighDpiMode's Event.
-        Private _highDpiMode As HighDpiMode = HighDpiMode.SystemAware
-
-#Enable Warning IDE0032 ' Use auto property
-
-        ''' <summary>
-        ''' Occurs when the network availability changes.
-        ''' </summary>
-        Public Custom Event NetworkAvailabilityChanged As Devices.NetworkAvailableEventHandler
-            ' This is a custom event because we want to hook up the NetworkAvailabilityChanged event only
-            ' if the user writes a handler for it.
-            ' The reason being that it is very expensive to handle and kills our application startup performance.
-            AddHandler(value As Devices.NetworkAvailableEventHandler)
-                SyncLock _networkAvailabilityChangeLock
-                    If _networkAvailabilityEventHandlers Is Nothing Then
-                        _networkAvailabilityEventHandlers = New List(Of Devices.NetworkAvailableEventHandler)
-                    End If
-
-                    _networkAvailabilityEventHandlers.Add(value)
-
-                    ' We don't want to create the network object now - it takes a snapshot
-                    ' of the executionContext and our IPrincipal isn't on the thread yet.
-                    ' We know we need to create it and we will at the appropriate time
-                    _turnOnNetworkListener = True
-
-                    ' But the user may be doing an AddHandler of their own in which case we need
-                    ' to make sure to honor the request.  If we aren't past OnInitialize() yet
-                    ' we shouldn't do it but the flag above catches that case.
-                    If _networkObject Is Nothing AndAlso _finishedOnInitialize Then
-                        _networkObject = New Devices.Network
-                        Dim windowsFormsApplicationBase As WindowsFormsApplicationBase = Me
-                        AddHandler _networkObject.NetworkAvailabilityChanged,
-                            AddressOf windowsFormsApplicationBase.NetworkAvailableEventAdaptor
-                    End If
-                End SyncLock
-            End AddHandler
-
-            RemoveHandler(value As Devices.NetworkAvailableEventHandler)
-                If _networkAvailabilityEventHandlers IsNot Nothing AndAlso
-                    _networkAvailabilityEventHandlers.Count > 0 Then
-
-                    _networkAvailabilityEventHandlers.Remove(value)
-
-                    ' Last one to leave - turn out the lights...
-                    If _networkAvailabilityEventHandlers.Count = 0 Then
-                        RemoveHandler _networkObject.NetworkAvailabilityChanged, AddressOf NetworkAvailableEventAdaptor
-                        If _networkObject IsNot Nothing Then
-
-                            ' Stop listening to network change events because we are going to go away.
-                            _networkObject.DisconnectListener()
-
-                            ' No sense holding on to this if nobody is listening.
-                            _networkObject = Nothing
-                        End If
-                    End If
-                End If
-            End RemoveHandler
-
-            RaiseEvent(sender As Object, e As Devices.NetworkAvailableEventArgs)
-                If _networkAvailabilityEventHandlers IsNot Nothing Then
-                    For Each handler As Devices.NetworkAvailableEventHandler In _networkAvailabilityEventHandlers
-                        Try
-                            If handler IsNot Nothing Then handler.Invoke(sender, e)
-                        Catch ex As Exception
-                            If Not OnUnhandledException(New UnhandledExceptionEventArgs(True, ex)) Then
-
-                                ' The user didn't write a handler so throw the error up the chain.
-                                Throw
-                            End If
-                        End Try
-                    Next
-                End If
-            End RaiseEvent
-        End Event
-
-        ''' <summary>
-        ''' Occurs when the application encounters an unhandled exception.
-        ''' </summary>
-        Public Custom Event UnhandledException As UnhandledExceptionEventHandler
-
-            ' This is a custom event because we want to hook up System.Windows.Forms.Application.ThreadException
-            ' only if the user writes a handler for this event.  We only want to hook the ThreadException event
-            ' if the user is handling this event because the act of listening to Application.ThreadException
-            ' causes WinForms to snuff exceptions and we only want WinForms to do that if we are assured that
-            ' the user wrote their own handler to deal with the error instead.
-            AddHandler(value As UnhandledExceptionEventHandler)
-                If _unhandledExceptionHandlers Is Nothing Then
-                    _unhandledExceptionHandlers = New List(Of UnhandledExceptionEventHandler)
-                End If
-
-                _unhandledExceptionHandlers.Add(value)
-
-                ' Only add the listener once so we don't fire the UnHandledException event over and over for the same exception
-                If _unhandledExceptionHandlers.Count = 1 Then
-                    AddHandler Application.ThreadException, AddressOf OnUnhandledExceptionEventAdaptor
-                End If
-            End AddHandler
-
-            RemoveHandler(value As UnhandledExceptionEventHandler)
-                If _unhandledExceptionHandlers IsNot Nothing AndAlso
-                    _unhandledExceptionHandlers.Count > 0 Then
-                    _unhandledExceptionHandlers.Remove(value)
-
-                    ' Last one to leave, turn out the lights...
-                    If _unhandledExceptionHandlers.Count = 0 Then
-                        RemoveHandler Application.ThreadException, AddressOf OnUnhandledExceptionEventAdaptor
-                    End If
-                End If
-            End RemoveHandler
-
-            RaiseEvent(sender As Object, e As UnhandledExceptionEventArgs)
-                If _unhandledExceptionHandlers IsNot Nothing Then
-
-                    ' In the case that we throw from the unhandled exception handler, we don't want to
-                    ' run the unhandled exception handler again.
-                    _processingUnhandledExceptionEvent = True
-
-                    For Each handler As UnhandledExceptionEventHandler In _unhandledExceptionHandlers
-                        handler?.Invoke(sender, e)
-                    Next
-
-                    ' Now that we are out of the unhandled exception handler, treat exceptions normally again.
-                    _processingUnhandledExceptionEvent = False
-                End If
-            End RaiseEvent
-        End Event
-
-        ''' <summary>
-        ''' Constructs the application Shutdown/Startup model object
-        ''' </summary>
-        ''' <remarks>
-        ''' We have to have a parameterless ctor because the platform specific Application object
-        ''' derives from this one and it doesn't define a ctor because the partial class generated by the
-        ''' designer does that to configure the application. </remarks>
-        Public Sub New()
-            Me.New(AuthenticationMode.Windows)
-        End Sub
-
-        ''' <summary>
-        ''' Constructs the application Shutdown/Startup model object
-        ''' </summary>
-        <SecuritySafeCritical()>
-        Public Sub New(authenticationMode As AuthenticationMode)
-            MyBase.New()
-
-            ValidateAuthenticationModeEnumValue(authenticationMode, NameOf(authenticationMode))
-
-            ' Setup Windows Authentication if that's what the user wanted.  Note, we want to do this now,
-            ' before the Network object gets created because the network object will be doing a
-            ' AsyncOperationsManager.CreateOperation() which captures the execution context.  So we have 
-            ' to have our principal on the thread before that happens.
-            If authenticationMode = AuthenticationMode.Windows Then
-                Try
-                    ' Consider: Sadly, a call to: System.Security.SecurityManager.IsGranted(New SecurityPermission(SecurityPermissionFlag.ControlPrincipal))
-                    ' Will only check THIS caller so you'll always get TRUE.
-                    ' What is needed is a way to get to the value of this on a demand basis.
-                    ' So I try/catch instead for now but would rather be able to IF my way around this block.
-                    Thread.CurrentPrincipal = New Principal.WindowsPrincipal(Principal.WindowsIdentity.GetCurrent)
-                Catch ex As SecurityException
-                End Try
-            End If
-
-            _appContext = New WinFormsAppContext(Me)
-
-            ' We need to set the WindowsFormsSynchronizationContext because the network object is going to
-            ' get created after this ctor runs (network gets created during event hookup) and we need the
-            ' context in place for it to latch on to.  The WindowsFormsSynchronizationContext won't otherwise
-            ' get created until OnCreateMainForm() when the startup form is created and by then it is too late.
-            ' When the startup form gets created, WinForms is going to push our context into the previous context
-            ' and then restore it when Application.Run() exits.
-            _appSynchronizationContext = AsyncOperationManager.SynchronizationContext
-        End Sub
-
-        ''' <summary>
-        ''' Entry point to kick off the VB Startup/Shutdown Application model
-        ''' </summary>
-        ''' <param name="commandLine">The command line from Main()</param>
-        <SecuritySafeCritical()>
-        Public Sub Run(commandLine As String())
-
-            ' Prime the command line args with what we receive from Main() so that Click-Once windows
-            ' apps don't have to do a System.Environment call which would require permissions.
-            InternalCommandLine = New ReadOnlyCollection(Of String)(commandLine)
-
-            If Not IsSingleInstance Then
-                DoApplicationModel()
-            Else
-                ' This is a Single-Instance application
-
-                ' Note: Must pass the calling assembly from here so we can get the running app.
-                ' Otherwise, can break single instance.
-                Dim ApplicationInstanceID As String = GetApplicationInstanceID(Assembly.GetCallingAssembly)
-                Dim pipeServer As NamedPipeServerStream = Nothing
-
-                If TryCreatePipeServer(ApplicationInstanceID, pipeServer) Then
-
-                    ' --- This is the first instance of a single-instance application to run.
-                    ' This is the instance that subsequent instances will attach to.
-                    Using pipeServer
-                        Dim tokenSource = New CancellationTokenSource()
-#Disable Warning BC42358 ' Call is not awaited.
-                        WaitForClientConnectionsAsync(pipeServer, AddressOf OnStartupNextInstanceMarshallingAdaptor, cancellationToken:=tokenSource.Token)
-#Enable Warning BC42358
-                        DoApplicationModel()
-                        tokenSource.Cancel()
-                    End Using
-                Else
-
-                    ' --- We are launching a subsequent instance.
-                    Dim tokenSource = New CancellationTokenSource()
-                    tokenSource.CancelAfter(SECOND_INSTANCE_TIMEOUT)
-                    Try
-                        Dim awaitable = SendSecondInstanceArgsAsync(ApplicationInstanceID, commandLine, cancellationToken:=tokenSource.Token).ConfigureAwait(False)
-                        awaitable.GetAwaiter().GetResult()
-                    Catch ex As Exception
-                        Throw New CantStartSingleInstanceException()
-                    End Try
-                End If
-            End If 'Single-Instance application
-        End Sub
-
-        ''' <summary>
-        ''' Returns the collection of forms that are open.  We no longer have thread
-        ''' affinity meaning that this is the WinForms collection that contains Forms that may
-        ''' have been opened on another thread then the one we are calling in on right now.
-        ''' </summary>
-        Public ReadOnly Property OpenForms() As FormCollection
-            Get
-                Return Application.OpenForms
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Provides access to the main form for this application
-        ''' </summary>
-        Protected Property MainForm() As Form
-            Get
-                Return _appContext?.MainForm
-            End Get
-            Set(value As Form)
-                If value Is Nothing Then
-                    Throw ExceptionUtils.GetArgumentNullException("MainForm", SR.General_PropertyNothing, "MainForm")
-                End If
-                If value Is _splashScreen Then
-                    Throw New ArgumentException(GetResourceString(SR.AppModel_SplashAndMainFormTheSame))
-                End If
-                _appContext.MainForm = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Provides access to the splash screen for this application
-        ''' </summary>
-        Public Property SplashScreen() As Form
-            Get
-                Return _splashScreen
-            End Get
-            Set(value As Form)
-
-                ' Allow for the case where they set splash screen = nothing and mainForm is currently nothing.
-                If value IsNot Nothing AndAlso value Is _appContext.MainForm Then
-                    Throw New ArgumentException(GetResourceString(SR.AppModel_SplashAndMainFormTheSame))
-                End If
-
-                _splashScreen = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The splash screen timeout specifies whether there is a minimum time that the splash
-        ''' screen should be displayed for.  When not set then the splash screen is hidden
-        ''' as soon as the main form becomes active.
-        ''' </summary>
-        ''' <value>The minimum amount of time, in milliseconds, to display the splash screen.</value>
-        ''' <remarks>
-        ''' This property, although public, used to be set in an `Overrides Function OnInitialize` _before_
-        ''' calling `MyBase.OnInitialize`. We want to phase this out, and with the introduction of the
-        ''' ApplyApplicationDefaults events have it handled in that event, rather than as awkwardly 
-        ''' as it is currently suggested to be used in the docs.
-        ''' First step for that is to make it hidden in IntelliSense.
-        ''' </remarks>
-        <EditorBrowsable(EditorBrowsableState.Never)>
-        Public Property MinimumSplashScreenDisplayTime() As Integer
-            Get
-                Return _minimumSplashExposure
-            End Get
-            Set(value As Integer)
-                _minimumSplashExposure = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Use GDI for the text rendering engine by default.
-        ''' The user can shadow this function to return True if they want their app
-        ''' to use the GDI+ render.  We read this function in Main() (My template) to
-        ''' determine how to set the text rendering flag on the WinForms application object.
-        ''' </summary>
-        ''' <returns>True - Use GDI+ renderer.  False - use GDI renderer</returns>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Shared ReadOnly Property UseCompatibleTextRendering() As Boolean
-            Get
-                Return False
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Provides the WinForms application context that we are running on
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Public ReadOnly Property ApplicationContext() As ApplicationContext
-            Get
-                Return _appContext
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Informs My.Settings whether to save the settings on exit or not
-        ''' </summary>
-        Public Property SaveMySettingsOnExit() As Boolean
-            Get
-                Return _saveMySettingsOnExit
-            End Get
-            Set(value As Boolean)
-                _saveMySettingsOnExit = value
-            End Set
-        End Property
-
-        ''' <summary>
-        '''  Processes all windows messages currently in the message queue
-        ''' </summary>
-        Public Sub DoEvents()
-            Application.DoEvents()
-        End Sub
-
-        ''' <summary>
-        ''' This exposes the first in a series of extensibility points for the Startup process.  By default, it shows
-        ''' the splash screen and does rudimentary processing of the command line to see if /nosplash or its
-        ''' variants was passed in.
-        ''' </summary>
-        ''' <param name="commandLineArgs"></param>
-        ''' <returns>Returning True indicates that we should continue on with the application Startup sequence</returns>
-        ''' <remarks>This extensibility point is exposed for people who want to override the Startup sequence at the earliest possible point
-        ''' to </remarks>
-        <EditorBrowsable(EditorBrowsableState.Advanced), STAThread()>
-        Protected Overridable Function OnInitialize(commandLineArgs As ReadOnlyCollection(Of String)) As Boolean
-
-            ' Rationale for how we process the default values and how we let the user modify 
-            ' them on demand via the ApplyApplicationDefaults event.
-            ' ===========================================================================================
-            ' a) Users used to be able to set MinimumSplashScreenDisplayTime _only_ by overriding OnInitialize
-            '    in a derived class and setting `MyBase.MinimumSplashScreenDisplayTime` there.
-            '    We are picking this (probably) changed value up, and pass it to the ApplyDefaultsEvents
-            '    where it could be modified (again). So event wins over Override over default value (2 seconds).
-            ' b) We feed the default HighDpiMode (SystemAware) to the EventArgs. With the introduction of
-            '    the HighDpiMode property, we give Project System the chance to reflect the HighDpiMode
-            '    in the App Designer UI and have it code-generated based on a modified Application.myapp, which
-            '    would result it to be set in the derived constructor. (See the hidden file in the Solution Explorer
-            '    "My Project\Application.myapp\Application.Designer.vb for how those UI-set values get applied.)
-            '    Once all this is done, we give the User another chance to change the value by code through
-            '    the ApplyDefaults event.
-            Dim applicationDefaultsEventArgs = New ApplyApplicationDefaultsEventArgs(
-                MinimumSplashScreenDisplayTime,
-                HighDpiMode)
-
-            ' Overriding MinimumSplashScreenDisplayTime needs still to keep working!
-            applicationDefaultsEventArgs.MinimumSplashScreenDisplayTime = MinimumSplashScreenDisplayTime
-            RaiseEvent ApplyApplicationDefaults(Me, applicationDefaultsEventArgs)
-
-            If (applicationDefaultsEventArgs.Font IsNot Nothing) Then
-                Application.SetDefaultFont(applicationDefaultsEventArgs.Font)
-            End If
-
-            MinimumSplashScreenDisplayTime = applicationDefaultsEventArgs.MinimumSplashScreenDisplayTime
-
-            ' This creates the native window, and that means, we can no longer apply a different Default Font.
-            ' So, this is the earliest point in time to set the AsyncOperationManager's SyncContext.
-            AsyncOperationManager.SynchronizationContext = New WindowsFormsSynchronizationContext()
-
-            _highDpiMode = applicationDefaultsEventArgs.HighDpiMode
-
-            ' Then, it's applying what we got back as HighDpiMode.
-            Dim dpiSetResult = Application.SetHighDpiMode(_highDpiMode)
-            If dpiSetResult Then
-                _highDpiMode = Application.HighDpiMode
-            End If
-            Debug.Assert(dpiSetResult, "We could net set the HighDpiMode.")
-
-            ' And finally we take care of EnableVisualStyles.
-            If _enableVisualStyles Then
-                Application.EnableVisualStyles()
-            End If
-
-            ' We'll handle "/nosplash" for you.
-            If Not (commandLineArgs.Contains("/nosplash") OrElse Me.CommandLineArgs.Contains("-nosplash")) Then
-                ShowSplashScreen()
-            End If
-
-            _finishedOnInitialize = True
-
-            ' We are now at a point where we can allow the network object
-            ' to be created since the iPrincipal is on the thread by now.
-
-            ' True means to not bail out but keep on running after OnInitialize() finishes
-            Return True
-        End Function
-
-        ''' <summary>
-        ''' Extensibility point which raises the Startup event
-        ''' </summary>
-        ''' <param name="eventArgs"></param>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Function OnStartup(eventArgs As StartupEventArgs) As Boolean
-
-            eventArgs.Cancel = False
-
-            ' It is important not to create the network object until the ExecutionContext has everything on it.
-            ' By now the principal will be on the thread so we can create the network object.
-            ' The timing is important because the network object has an AsyncOperationsManager in it that marshals
-            ' the network changed event to the main thread.  The asycnOperationsManager does a CreateOperation()
-            ' which makes a copy of the executionContext. That execution context shows up on your thread during
-            ' the callback so I delay creating the network object (and consequently the capturing of the execution context)
-            ' until the principal has been set on the thread. This avoids the problem where My.User isn't set
-            ' during the NetworkAvailabilityChanged event.  This problem would just extend itself to any future
-            ' callback that involved the asyncOperationsManager so this is where we need to create objects that
-            ' have a asyncOperationsContext in them.
-            If _turnOnNetworkListener And _networkObject Is Nothing Then
-
-                ' The is-nothing-check is to avoid hooking the object more than once.
-                _networkObject = New Devices.Network
-                AddHandler _networkObject.NetworkAvailabilityChanged, AddressOf NetworkAvailableEventAdaptor
-            End If
-
-            RaiseEvent Startup(Me, eventArgs)
-
-            Return Not eventArgs.Cancel
-        End Function
-
-        ''' <summary>
-        ''' Extensibility point which raises the StartupNextInstance
-        ''' </summary>
-        ''' <param name="eventArgs"></param>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        <SecuritySafeCritical()>
-        Protected Overridable Sub OnStartupNextInstance(eventArgs As StartupNextInstanceEventArgs)
-
-            RaiseEvent StartupNextInstance(Me, eventArgs)
-
-            ' Activate the original instance.
-            If eventArgs.BringToForeground AndAlso MainForm IsNot Nothing Then
-                If MainForm.WindowState = FormWindowState.Minimized Then
-                    MainForm.WindowState = FormWindowState.Normal
-                End If
-
-                MainForm.Activate()
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' At this point, the command line args should have been processed and the application will create the
-        ''' main form and enter the message loop.
-        ''' </summary>
-        <SecuritySafeCritical()>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Sub OnRun()
-
-            If MainForm Is Nothing Then
-
-                ' A designer overrides OnCreateMainForm() to set the main form we are supposed to use.
-                OnCreateMainForm()
-
-                If MainForm Is Nothing Then
-                    Throw New NoStartupFormException
-                End If
-
-                ' When we have a splash screen that hasn't timed out before the main form is ready to paint, we want to
-                ' block the main form from painting.  To do that I let the form get past the Load() event and hold it until
-                ' the splash screen goes down.  Then I let the main form continue it's startup sequence.  The ordering of
-                ' Form startup events for reference is: Ctor(), Load Event, Layout event, Shown event, Activated event, Paint event.
-                AddHandler MainForm.Load, AddressOf MainFormLoadingDone
-            End If
-
-            ' Run() eats all exceptions (unless running under the debugger). If the user wrote an
-            ' UnhandledException handler we will hook the System.Windows.Forms.Application.ThreadException event
-            ' (see Public Custom Event UnhandledException) which will raise our UnhandledException Event.
-            ' If our user didn't write an UnhandledException event, then we land in the try/catch handler for Forms.Application.Run().
-            Try
-                Application.Run(_appContext)
-            Finally
-
-                ' When Run() returns, the context we pushed in our ctor (which was a WindowsFormsSynchronizationContext)
-                ' is restored.  But we are going to dispose it so we need to disconnect the network listener so that it
-                ' can't fire any events in response to changing network availability conditions through a dead context.
-                If _networkObject IsNot Nothing Then _networkObject.DisconnectListener()
-
-                'Restore the prior sync context.
-                AsyncOperationManager.SynchronizationContext = _appSynchronizationContext
-                _appSynchronizationContext = Nothing
-            End Try
-        End Sub
-
-        ''' <summary>
-        ''' A designer will override this method and provide a splash screen if this application has one.
-        ''' </summary>
-        ''' <remarks>For instance, a designer would override this method and emit: Me.Splash = new Splash
-        ''' where Splash was designated in the application designer as being the splash screen for this app</remarks>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Sub OnCreateSplashScreen()
-        End Sub
-
-        ''' <summary>
-        ''' Provides a hook that designers will override to set the main form.
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Sub OnCreateMainForm()
-        End Sub
-
-        ''' <summary>
-        ''' The last in a series of extensibility points for the Shutdown process
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Sub OnShutdown()
-            RaiseEvent Shutdown(Me, EventArgs.Empty)
-        End Sub
-
-        ''' <summary>
-        ''' Raises the UnHandled exception event and exits the application if the event handler indicated
-        ''' that execution shouldn't continue
-        ''' </summary>
-        ''' <param name="e"></param>
-        ''' <returns>True indicates the exception event was raised / False it was not</returns>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Overridable Function OnUnhandledException(e As UnhandledExceptionEventArgs) As Boolean
-
-            ' Does the user have a handler for this event?
-            If _unhandledExceptionHandlers IsNot Nothing AndAlso _unhandledExceptionHandlers.Count > 0 Then
-
-                ' We don't put a try/catch around the handler event so that exceptions in there will
-                ' bubble out - else we will have a recursive exception handler.
-                RaiseEvent UnhandledException(Me, e)
-                If e.ExitApplication Then Application.Exit()
-
-                ' User handled the event.
-                Return True
-            End If
-
-            ' Nobody was listening to the UnhandledException event.
-            Return False
-        End Function
-
-        ''' <summary>
-        ''' Uses the extensibility model to see if there is a splash screen provided for this app and if there is,
-        ''' displays it.
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Sub ShowSplashScreen()
-            If Not _didSplashScreen Then
-                _didSplashScreen = True
-
-                If _splashScreen Is Nothing Then
-
-                    ' If the user specified a splash screen, the designer will have overridden this method to set it.
-                    OnCreateSplashScreen()
-                End If
-
-                If _splashScreen IsNot Nothing Then
-
-                    ' Some splash screens have minimum face time they are supposed to get.
-                    ' We'll set up a time to let us know when we can take it down.
-                    If _minimumSplashExposure > 0 Then
-
-                        ' Don't close until the timer expires.
-                        _splashTimer = New Timers.Timer(_minimumSplashExposure)
-                        AddHandler _splashTimer.Elapsed, AddressOf MinimumSplashExposureTimeIsUp
-                        _splashTimer.AutoReset = False
-
-                        ' We only need this, when we actually need to wait for it.
-                        _splashScreenCompletionSource = New TaskCompletionSource(Of Boolean)
-
-                        ' We'll enable it in DisplaySplash() once the splash screen thread gets running.
-                    End If
-
-                    ' Run the splash screen on another thread so we don't starve it for events and painting
-                    ' while the main form gets its act together.
-                    Task.Run(AddressOf DisplaySplash)
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Hide the splash screen.  The splash screen was created on another thread
-        ''' thread (main thread) than the one it was run on (secondary thread for the
-        ''' splash screen so it doesn't block app startup. We need to invoke the close.
-        ''' This function gets called from the main thread by the app fx.
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        <SecuritySafeCritical()>
-        Protected Sub HideSplashScreen()
-
-            'This ultimately wasn't necessary.  I suppose we better keep it for backwards compatibility.
-            SyncLock _splashLock
-
-                ' .NET Framework 4.0 (Dev10 #590587) - we now activate the main form before calling
-                ' Dispose on the Splash screen. (we're just swapping the order of the two If blocks.)
-                ' This is to fix the issue where the main form doesn't come to the front after the
-                ' Splash screen disappears.
-                MainForm?.Activate()
-
-                If _splashScreen IsNot Nothing AndAlso Not _splashScreen.IsDisposed Then
-                    Dim disposeSplashDelegate As New DisposeDelegate(AddressOf _splashScreen.Dispose)
-                    _splashScreen.Invoke(disposeSplashDelegate)
-                    _splashScreen = Nothing
-                End If
-            End SyncLock
-        End Sub
-
-        ''' <summary>
-        '''  Determines when this application will terminate (when the main form goes down, all forms)
-        ''' </summary>
-        Protected Friend Property ShutdownStyle() As ShutdownMode
-            Get
-                Return _shutdownStyle
-            End Get
-            Set(value As ShutdownMode)
-                ValidateShutdownModeEnumValue(value, NameOf(value))
-                _shutdownStyle = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Determines whether this application will use the XP Windows styles for windows, controls, etc.
-        ''' </summary>
-        Protected Property EnableVisualStyles() As Boolean
-            Get
-                Return _enableVisualStyles
-            End Get
-            Set(value As Boolean)
-                _enableVisualStyles = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Gets or sets the HighDpiMode for the Application.
-        ''' </summary>
-        <EditorBrowsable(EditorBrowsableState.Never)>
-        Protected Property HighDpiMode() As HighDpiMode
-            Get
-                Return _highDpiMode
-            End Get
-            Set(value As HighDpiMode)
-                _highDpiMode = value
-            End Set
-        End Property
-
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Protected Property IsSingleInstance() As Boolean
-            Get
-                Return _isSingleInstance
-            End Get
-            Set(value As Boolean)
-                _isSingleInstance = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Validates that the value being passed as an AuthenticationMode enum is a legal value
-        ''' </summary>
-        ''' <param name="value"></param>
-        Private Shared Sub ValidateAuthenticationModeEnumValue(value As AuthenticationMode, paramName As String)
-            If value < AuthenticationMode.Windows OrElse value > AuthenticationMode.ApplicationDefined Then
-                Throw New InvalidEnumArgumentException(paramName, value, GetType(AuthenticationMode))
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Validates that the value being passed as an ShutdownMode enum is a legal value
-        ''' </summary>
-        ''' <param name="value"></param>
-        Private Shared Sub ValidateShutdownModeEnumValue(value As ShutdownMode, paramName As String)
-            If value < ShutdownMode.AfterMainFormCloses OrElse value > ShutdownMode.AfterAllFormsClose Then
-                Throw New InvalidEnumArgumentException(paramName, value, GetType(ShutdownMode))
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Displays the splash screen.  We get called here from a different thread than what the 
-        ''' main form is starting up on.  This allows us to process events for the Splash screen so 
-        ''' it doesn't freeze up while the main form is getting it together.
-        ''' </summary>
-        Private Sub DisplaySplash()
-            Debug.Assert(_splashScreen IsNot Nothing, "We should have never get here if there is no splash screen")
-
-            If _splashTimer IsNot Nothing Then
-
-                ' We only have a timer if there is a minimum time that the splash screen is supposed to be displayed.
-                ' Enable the timer now that we are about to show the splash screen.
-                _splashTimer.Enabled = True
-            End If
-
-            Application.Run(_splashScreen)
-        End Sub
-
-        ''' <summary>
-        ''' If a splash screen has a minimum time out, then once that is up we check to see whether
-        ''' we should close the splash screen.  If the main form has activated then we close it.
-        ''' Note that we are getting called on a secondary thread here which isn't necessarily
-        ''' associated with any form.  Don't touch forms from this function.
-        ''' </summary>
-        Private Sub MinimumSplashExposureTimeIsUp(sender As Object, e As Timers.ElapsedEventArgs)
-
-            If _splashTimer IsNot Nothing Then
-
-                'We only have a timer if there was a minimum timeout on the splash screen.
-                _splashTimer.Dispose()
-                _splashTimer = Nothing
-            End If
-
-            _splashScreenCompletionSource.SetResult(True)
-        End Sub
-
-        ''' <summary>
-        ''' The Load() event happens before the Shown and Paint events.  When we get called here
-        ''' we know that the form load event is done and that the form is about to paint
-        ''' itself for the first time.
-        ''' We can now hide the splash screen.
-        ''' Note that this function gets called from the main thread - the same thread
-        ''' that creates the startup form.
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        Private Sub MainFormLoadingDone(sender As Object, e As EventArgs)
-
-            ' We don't want this event to call us again.
-            RemoveHandler MainForm.Load, AddressOf MainFormLoadingDone
-
-            ' Now, we don't want to eat up a complete Processor Core just for waiting on the main form,
-            ' since this is eating up a LOT of enegery and workload, espacially on Notebooks and tablets.
-            If _splashScreenCompletionSource IsNot Nothing Then
-
-                _formLoadWaiter = New AutoResetEvent(False)
-
-                Task.Run(Async Function() As Task
-                             Await _splashScreenCompletionSource.Task.ConfigureAwait(False)
-                             _formLoadWaiter.Set()
-                         End Function)
-
-                ' Block until the splash screen time is up.
-                ' See MinimumSplashExposureTimeIsUp() which releases us.
-                _formLoadWaiter.WaitOne()
-            End If
-
-            HideSplashScreen()
-        End Sub
-
-        ''' <summary>
-        ''' Handles the Windows.Forms.Application.ThreadException event and raises our Unhandled
-        ''' exception event
-        ''' </summary>
-        ''' <param name="e"></param>
-        ''' <remarks>Our UnHandledException event has a different signature then the Windows.Forms.Application
-        ''' unhandled exception event so we do the translation here before raising our event.
-        ''' </remarks>
-        Private Sub OnUnhandledExceptionEventAdaptor(sender As Object, e As ThreadExceptionEventArgs)
-            OnUnhandledException(New UnhandledExceptionEventArgs(True, e.Exception))
-        End Sub
-
-        Private Sub OnStartupNextInstanceMarshallingAdaptor(ByVal args As String())
-
-            Dim invoked = False
-
-            Try
-                Dim handleNextInstance As New Action(
-                    Sub()
-                        invoked = True
-                        OnStartupNextInstance(New StartupNextInstanceEventArgs(
-                                        New ReadOnlyCollection(Of String)(args),
-                                        bringToForegroundFlag:=True))
-                    End Sub)
-
-                ' If we have a Main form, we need to make sure that we are on _its_ UI thread
-                ' before we call OnStartupNextInstance.
-                If MainForm IsNot Nothing Then
-                    MainForm.Invoke(handleNextInstance)
-                Else
-                    ' Otherwise, we need to make sure that we are on the thread
-                    ' provided by the SynchronizationContext.
-                    AsyncOperationManager.
-                        SynchronizationContext.
-                        Send(Sub() handleNextInstance(), Nothing)
-                End If
-
-            Catch ex As Exception When Not invoked
-                ' Only catch exceptions thrown when the UI thread is not available, before
-                ' the UI thread has been created or after it has been terminated. Exceptions
-                ' thrown from OnStartupNextInstance() should be allowed to propagate.
-            End Try
-        End Sub
-
-        ''' <summary>
-        ''' Handles the Network.NetworkAvailability event (on the correct thread) and raises the
-        ''' NetworkAvailabilityChanged event
-        ''' </summary>
-        ''' <param name="Sender">Contains the Network instance that raised the event</param>
-        ''' <param name="e">Contains whether the network is available or not</param>
-        Private Sub NetworkAvailableEventAdaptor(sender As Object, e As Devices.NetworkAvailableEventArgs)
-            RaiseEvent NetworkAvailabilityChanged(sender, e)
-        End Sub
-
-        ''' <summary>
-        ''' Runs the user's program through the VB Startup/Shutdown application model
-        ''' </summary>
-        Private Sub DoApplicationModel()
-
-            Dim EventArgs As New StartupEventArgs(CommandLineArgs)
-
-            ' Only do the try/catch if we aren't running under the debugger.
-            ' If we do try/catch under the debugger the debugger never gets
-            ' a crack at exceptions which breaks the exception helper.
-            If Not Debugger.IsAttached Then
-
-                ' NO DEBUGGER ATTACHED - we use a catch so that we can run our UnhandledException code
-                ' Note - Sadly, code changes within this IF (that don't pertain to exception handling)
-                ' need to be mirrored in the ELSE debugger attached clause below.
-                Try
-                    If OnInitialize(CommandLineArgs) Then
-                        If OnStartup(EventArgs) Then
-                            OnRun()
-                            OnShutdown()
-                        End If
-                    End If
-                Catch ex As Exception
-
-                    ' This catch is for exceptions that happen during the On* methods above,
-                    ' but have occurred outside of the message pump (which exceptions we would
-                    ' have already seen via our hook of System.Windows.Forms.Application.ThreadException).
-                    If _processingUnhandledExceptionEvent Then
-
-                        ' If the UnhandledException handler threw for some reason, throw that error out to the system.
-                        Throw
-                    Else
-
-                        ' We had an exception, but not during the OnUnhandledException handler so give the user
-                        ' a chance to look at what happened in the UnhandledException event handler
-                        If Not OnUnhandledException(New UnhandledExceptionEventArgs(True, ex)) Then
-
-                            ' The user didn't write a handler so throw the error out to the system
-                            Throw
-                        End If
-                    End If
-                End Try
-            Else
-                ' DEBUGGER ATTACHED - we don't have an uber catch when debugging so the exception
-                ' will bubble out to the exception helper.
-                ' We also don't hook up the Application.ThreadException event because WinForms ignores it
-                ' when we are running under the debugger.
-                If OnInitialize(CommandLineArgs) Then
-                    If OnStartup(EventArgs) Then
-                        OnRun()
-                        OnShutdown()
-                    End If
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Generates the name for the remote singleton that we use to channel multiple instances
-        ''' to the same application model thread.
-        ''' </summary>
-        ''' <returns>A string unique to the application that should be the same for versions of
-        '''  the application that have the same Major and Minor Version Number
-        ''' </returns>
-        ''' <remarks>If GUID Attribute does not exist fall back to unique ModuleVersionId</remarks>
-        Private Shared Function GetApplicationInstanceID(ByVal Entry As Assembly) As String
-
-            Dim guidAttrib As GuidAttribute = Entry.GetCustomAttribute(Of GuidAttribute)()
-
-            If guidAttrib IsNot Nothing Then
-
-                Dim version As Version = Entry.GetName.Version
-
-                If version IsNot Nothing Then
-                    Return $"{guidAttrib.Value}{version.Major}.{version.Minor}"
-                Else
-                    Return guidAttrib.Value
-                End If
-            End If
-
-            Return Entry.ManifestModule.ModuleVersionId.ToString()
-        End Function
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/ExceptionUtils.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/ExceptionUtils.vb
deleted file mode 100644
index e54eda83619..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/ExceptionUtils.vb
+++ /dev/null
@@ -1,172 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    Friend Enum vbErrors
-        None = 0
-        FileNotFound = 53
-        PermissionDenied = 70
-    End Enum
-
-    ' Implements error utilities for Basic
-    Friend NotInheritable Class ExceptionUtils
-
-        ' Prevent creation.
-        Private Sub New()
-        End Sub
-
-        Friend Shared Function VbMakeException(hr As Integer) As Exception
-            Dim sMsg As String
-
-            If hr > 0 AndAlso hr <= &HFFFFI Then
-                sMsg = GetResourceString(CType(hr, vbErrors))
-            Else
-                sMsg = ""
-            End If
-            VbMakeException = VbMakeExceptionEx(hr, sMsg)
-        End Function
-
-        Friend Shared Function VbMakeExceptionEx(number As Integer, sMsg As String) As Exception
-            Dim vBDefinedError As Boolean
-
-            VbMakeExceptionEx = BuildException(number, sMsg, vBDefinedError)
-
-            If vBDefinedError Then
-                ' .NET Framework implementation calls:
-                ' Err().SetUnmappedError(number)
-            End If
-
-        End Function
-
-        Friend Shared Function BuildException(Number As Integer, Description As String, ByRef VBDefinedError As Boolean) As Exception
-
-            VBDefinedError = True
-
-            Select Case Number
-
-                Case vbErrors.None
-
-                Case vbErrors.FileNotFound
-                    Return New IO.FileNotFoundException(Description)
-
-                Case vbErrors.PermissionDenied
-                    Return New IO.IOException(Description)
-
-                Case Else
-                    'Fall below to default
-                    VBDefinedError = False
-                    Return New Exception(Description)
-            End Select
-
-            VBDefinedError = False
-            Return New Exception(Description)
-
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of ArgumentException with the message from resource file and the Exception.ArgumentName property set.
-        ''' </summary>
-        ''' <param name="ArgumentName">The name of the argument (parameter). Not localized.</param>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of ArgumentException.</returns>
-        ''' <remarks>This is the preferred way to construct an argument exception.</remarks>
-        Friend Shared Function GetArgumentExceptionWithArgName(ArgumentName As String,
-            ResourceID As String, ParamArray PlaceHolders() As String) As ArgumentException
-
-            Return New ArgumentException(GetResourceString(ResourceID, PlaceHolders), ArgumentName)
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of ArgumentNullException with message: "Argument cannot be Nothing."
-        ''' </summary>
-        ''' <param name="ArgumentName">The name of the argument (parameter). Not localized.</param>
-        ''' <returns>A new instance of ArgumentNullException.</returns>
-        Friend Shared Function GetArgumentNullException(ArgumentName As String) As ArgumentNullException
-
-            Return New ArgumentNullException(ArgumentName, GetResourceString(SR.General_ArgumentNullException))
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of ArgumentNullException with the message from resource file.
-        ''' </summary>
-        ''' <param name="ArgumentName">The name of the argument (parameter). Not localized.</param>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of ArgumentNullException.</returns>
-        Friend Shared Function GetArgumentNullException(ArgumentName As String,
-            ResourceID As String, ParamArray PlaceHolders() As String) As ArgumentNullException
-
-            Return New ArgumentNullException(ArgumentName, GetResourceString(ResourceID, PlaceHolders))
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of IO.DirectoryNotFoundException with the message from resource file.
-        ''' </summary>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of IO.DirectoryNotFoundException.</returns>
-        Friend Shared Function GetDirectoryNotFoundException(
-            ResourceID As String, ParamArray PlaceHolders() As String) As IO.DirectoryNotFoundException
-
-            Return New IO.DirectoryNotFoundException(GetResourceString(ResourceID, PlaceHolders))
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of IO.FileNotFoundException with the message from resource file.
-        ''' </summary>
-        ''' <param name="FileName">The file name (path) of the not found file.</param>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of IO.FileNotFoundException.</returns>
-        Friend Shared Function GetFileNotFoundException(FileName As String,
-            ResourceID As String, ParamArray PlaceHolders() As String) As IO.FileNotFoundException
-
-            Return New IO.FileNotFoundException(GetResourceString(ResourceID, PlaceHolders), FileName)
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of InvalidOperationException with the message from resource file.
-        ''' </summary>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of InvalidOperationException.</returns>
-        Friend Shared Function GetInvalidOperationException(
-            ResourceID As String, ParamArray PlaceHolders() As String) As InvalidOperationException
-
-            Return New InvalidOperationException(GetResourceString(ResourceID, PlaceHolders))
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of IO.IOException with the message from resource file.
-        ''' </summary>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of IO.IOException.</returns>
-        Friend Shared Function GetIOException(ResourceID As String, ParamArray PlaceHolders() As String) As IO.IOException
-
-            Return New IO.IOException(GetResourceString(ResourceID, PlaceHolders))
-        End Function
-
-        ''' <summary>
-        ''' Returns a new instance of Win32Exception with the message from resource file and the last Win32 error.
-        ''' </summary>
-        ''' <param name="ResourceID">The resource ID.</param>
-        ''' <param name="PlaceHolders">Strings that will replace place holders in the resource string, if any.</param>
-        ''' <returns>A new instance of Win32Exception.</returns>
-        ''' <remarks>There is no way to exclude the Win32 error so this function will call Marshal.GetLastWin32Error all the time.</remarks>
-
-        Friend Shared Function GetWin32Exception(
-            ResourceID As String, ParamArray PlaceHolders() As String) As ComponentModel.Win32Exception
-
-            Return New ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error(), GetResourceString(ResourceID, PlaceHolders))
-        End Function
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/Utils.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/Utils.vb
deleted file mode 100644
index 4f4c8eeab82..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/CompilerServices/Utils.vb
+++ /dev/null
@@ -1,27 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Globalization
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    ' Purpose: various helpers for the vb runtime functions
-    Friend NotInheritable Class Utils
-
-        Friend Shared Function GetResourceString(ResourceId As vbErrors) As String
-            Dim id As String = "ID" & CStr(ResourceId)
-            Return SR.GetResourceString(id, id)
-        End Function
-
-        Friend Shared Function GetResourceString(resourceKey As String, ParamArray args() As String) As String
-            Return String.Format(GetCultureInfo(), resourceKey, args)
-        End Function
-
-        Friend Shared Function GetCultureInfo() As CultureInfo
-            Return System.Threading.Thread.CurrentThread.CurrentCulture
-        End Function
-
-    End Class
-
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Audio.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Audio.vb
deleted file mode 100644
index 341112efb86..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Audio.vb
+++ /dev/null
@@ -1,165 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-Imports System.IO
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic
-
-    ''' <summary>
-    '''  Enum for three ways to play a .wav file
-    ''' </summary>
-    Public Enum AudioPlayMode
-        ' Any changes to this enum must be reflected in ValidateAudioPlayModeEnum()
-        WaitToComplete = 0 'Synchronous
-        Background = 1     'Asynchronous
-        BackgroundLoop = 2 'Asynchronous and looping
-    End Enum
-
-    Namespace Devices
-
-        ''' <summary>
-        '''  An object that makes it easy to play wav files
-        ''' </summary>
-        Public Class Audio
-
-            ''' <summary>
-            '''  Creates a new Audio object
-            ''' </summary>
-            Public Sub New()
-            End Sub
-
-            ''' <summary>
-            '''  Plays a .wav file in background mode
-            ''' </summary>
-            ''' <param name="location">The name of the file</param>
-            Public Sub Play(location As String)
-                Play(location, AudioPlayMode.Background)
-            End Sub
-
-            ''' <summary>
-            ''' Plays a .wav file in the passed in mode
-            ''' </summary>
-            ''' <param name="location">The name of the file</param>
-            ''' <param name="playMode">
-            ''' An enum value representing the mode, Background (async), 
-            ''' WaitToComplete (sync) or BackgroundLoop
-            ''' </param>
-            Public Sub Play(location As String, playMode As AudioPlayMode)
-                ValidateAudioPlayModeEnum(playMode, NameOf(playMode))
-                Dim safeFilename As String = ValidateFilename(location)
-                Dim sound As Media.SoundPlayer = New Media.SoundPlayer(safeFilename)
-                Play(sound, playMode)
-            End Sub
-
-            ''' <summary>
-            '''   Plays a Byte array representation of a .wav file in the passed in mode
-            ''' </summary>
-            ''' <param name="data">The array representing the .wav file</param>
-            ''' <param name="playMode">The mode in which the array should be played</param>
-            Public Sub Play(data() As Byte, playMode As AudioPlayMode)
-                If data Is Nothing Then
-                    Throw GetArgumentNullException("data")
-                End If
-                ValidateAudioPlayModeEnum(playMode, NameOf(playMode))
-
-                Dim soundStream As MemoryStream = New MemoryStream(data)
-                Play(soundStream, playMode)
-                soundStream.Close()
-            End Sub
-
-            ''' <summary>
-            '''  Plays a stream representation of a .wav file in the passed in mode
-            ''' </summary>
-            ''' <param name="stream">The stream representing the .wav file</param>
-            ''' <param name="playMode">The mode in which the stream should be played</param>
-            Public Sub Play(stream As Stream, playMode As AudioPlayMode)
-                ValidateAudioPlayModeEnum(playMode, NameOf(playMode))
-                If stream Is Nothing Then
-                    Throw GetArgumentNullException("stream")
-                End If
-
-                Play(New Media.SoundPlayer(stream), playMode)
-            End Sub
-
-            ''' <summary>
-            '''   Plays a system messageBeep sound.
-            ''' </summary>
-            ''' <param name="systemSound">The sound to be played</param>
-            ''' <remarks>Plays the sound asynchronously</remarks>
-            Public Sub PlaySystemSound(systemSound As Media.SystemSound)
-                If systemSound Is Nothing Then
-                    Throw GetArgumentNullException("systemSound")
-                End If
-
-                systemSound.Play()
-
-            End Sub
-
-            ''' <summary>
-            '''  Stops the play of any playing sound
-            ''' </summary>
-            Public Sub [Stop]()
-                Dim sound As New Media.SoundPlayer()
-                sound.Stop()
-            End Sub
-
-            ''' <summary>
-            '''  Plays the passed in SoundPlayer in the passed in mode
-            ''' </summary>
-            ''' <param name="sound">The SoundPlayer to play</param>
-            ''' <param name="mode">The mode in which to play the sound</param>
-            Private Sub Play(sound As Media.SoundPlayer, mode As AudioPlayMode)
-
-                Debug.Assert(sound IsNot Nothing, "There's no SoundPlayer")
-                Debug.Assert([Enum].IsDefined(GetType(AudioPlayMode), mode), "Enum value is out of range")
-
-                ' Stopping the sound ensures it's safe to dispose it. This could happen when we change the value of m_Sound below
-                _sound?.Stop()
-
-                _sound = sound
-
-                Select Case mode
-                    Case AudioPlayMode.WaitToComplete
-                        _sound.PlaySync()
-                    Case AudioPlayMode.Background
-                        _sound.Play()
-                    Case AudioPlayMode.BackgroundLoop
-                        _sound.PlayLooping()
-                    Case Else
-                        Debug.Fail("Unknown AudioPlayMode")
-                End Select
-
-            End Sub
-
-            ''' <summary>
-            '''  Gets the full name and path for the file. Throws if unable to get full name and path
-            ''' </summary>
-            ''' <param name="location">The filename being tested</param>
-            ''' <returns>A full name and path of the file</returns>
-            Private Shared Function ValidateFilename(location As String) As String
-                If String.IsNullOrEmpty(location) Then
-                    Throw GetArgumentNullException("location")
-                End If
-
-                Return location
-            End Function
-
-            ''' <summary>
-            ''' Validates that the value being passed as an AudioPlayMode enum is a legal value
-            ''' </summary>
-            ''' <param name="value"></param>
-            Private Shared Sub ValidateAudioPlayModeEnum(value As AudioPlayMode, paramName As String)
-                If value < AudioPlayMode.WaitToComplete OrElse value > AudioPlayMode.BackgroundLoop Then
-                    Throw New ComponentModel.InvalidEnumArgumentException(paramName, DirectCast(value, Integer), GetType(AudioPlayMode))
-                End If
-            End Sub
-
-            ' Object that plays the sounds. We use a private member so we can ensure we have a reference for async plays
-            Private _sound As Media.SoundPlayer
-
-        End Class 'Audio
-    End Namespace
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Clock.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Clock.vb
deleted file mode 100644
index c7ea5c6fb79..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Clock.vb
+++ /dev/null
@@ -1,51 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    ''' A wrapper object that acts as a discovery mechanism to quickly find out
-    ''' the current local time of the machine and the GMT time.
-    ''' </summary>
-    Public Class Clock
-
-        ''' <summary>
-        ''' Gets a Date that is the current local date and time on this computer.
-        ''' </summary>
-        ''' <value>A Date whose value is the current date and time.</value>
-#Disable Warning IDE0049 ' Simplify Names, Justification:=<Public API>
-        Public ReadOnly Property LocalTime() As DateTime
-            Get
-                Return DateTime.Now
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets a DateTime that is the current local date and time on this
-        ''' computer expressed as GMT time.
-        ''' </summary>
-        ''' <value>A Date whose value is the current date and time expressed as GMT time.</value>
-        Public ReadOnly Property GmtTime() As DateTime
-            Get
-                Return DateTime.UtcNow
-            End Get
-        End Property
-#Enable Warning IDE0049 ' Simplify Names
-
-        ''' <summary>
-        ''' This property wraps the Environment.TickCount property to get the
-        ''' number of milliseconds elapsed since the system started.
-        ''' </summary>
-        ''' <value>An Integer containing the amount of time in milliseconds.</value>
-        Public ReadOnly Property TickCount() As Integer
-            Get
-                Return Environment.TickCount
-            End Get
-        End Property
-
-    End Class 'Clock
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Computer.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Computer.vb
deleted file mode 100644
index f4098d32bad..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Computer.vb
+++ /dev/null
@@ -1,100 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports Microsoft.VisualBasic.MyServices
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    '''   A RAD object representing the 'computer' that serves as a discovery
-    '''   mechanism for finding principle abstractions in the system that you can
-    '''   code against such as the file system, the clipboard, performance
-    '''   counters, etc. It also provides functionality you would expect to see
-    '''   associated with the computer such as playing sound, timers, access to
-    '''   environment variables, etc. This class represent a general computer
-    '''   available from a Windows Application, Web app, Dll library, etc.
-    ''' </summary>
-    Public Class Computer : Inherits ServerComputer
-
-        'NOTE: The .Net design guidelines state that access to Instance members does not have to be thread-safe.  Access to Shared members does have to be thread-safe.
-        'Since My.Computer creates the instance of Computer in a thread-safe way, access to the Computer will necessarily be thread-safe.
-        'There is nothing to prevent a user from passing our computer object across threads or creating their own instance and then getting into trouble.
-        ' But that is completely consistent with the rest of the FX design.  It is MY.* that is thread safe and leads to best practice access to these objects.
-        '  If you dim them up yourself, you are responsible for managing the threading.
-
-        ''' <summary>
-        ''' Gets an Audio object which can play sound files or resources.
-        ''' </summary>
-        ''' <value>A sound object.</value>
-        Public ReadOnly Property Audio() As Audio
-            Get
-                If _audio IsNot Nothing Then Return _audio
-                _audio = New Audio()
-                Return _audio
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' A thin wrapper for System.Windows.Forms.Clipboard
-        ''' </summary>
-        ''' <value>An object representing the clipboard</value>
-        Public ReadOnly Property Clipboard() As ClipboardProxy
-            Get
-                If s_clipboard Is Nothing Then
-                    s_clipboard = New ClipboardProxy()
-                End If
-
-                Return s_clipboard
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This property returns the Mouse object containing information about
-        ''' the physical mouse installed to the machine.
-        ''' </summary>
-        ''' <value>An instance of the Mouse class.</value>
-        Public ReadOnly Property Mouse() As Mouse
-            Get
-                If s_mouse IsNot Nothing Then Return s_mouse
-                s_mouse = New Mouse
-                Return s_mouse
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This property returns the Keyboard object representing some
-        ''' keyboard properties and a send keys method
-        ''' </summary>
-        ''' <value>An instance of the Keyboard class.</value>
-        Public ReadOnly Property Keyboard() As Keyboard
-            Get
-                If s_keyboardInstance IsNot Nothing Then Return s_keyboardInstance
-                s_keyboardInstance = New Keyboard
-                Return s_keyboardInstance
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This property returns the primary display screen.
-        ''' </summary>
-        ''' <value>A System.Windows.Forms.Screen object as the primary screen.</value>
-        Public ReadOnly Property Screen() As Screen
-            Get
-                'Don't cache this.  The Screen class responds to display resolution changes by nulling out AllScreens, which
-                'PrimaryScreen relies on to find the primary.  So we always need to access the latest PrimaryScreen so we
-                'will get the current resolution reported.
-                Return Screen.PrimaryScreen
-            End Get
-        End Property
-
-        Private _audio As Audio 'Lazy initialized cache for the Audio class.
-        Private Shared s_clipboard As ClipboardProxy 'Lazy initialized cache for the clipboard class. (proxies can be shared - they have no state)
-        Private Shared s_mouse As Mouse 'Lazy initialized cache for the Mouse class. SHARED because Mouse behaves as a ReadOnly singleton class
-        Private Shared s_keyboardInstance As Keyboard 'Lazy initialized cache for the Keyboard class.  SHARED because Keyboard behaves as a ReadOnly singleton class
-
-    End Class 'Computer
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ComputerInfo.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ComputerInfo.vb
deleted file mode 100644
index 775801fb383..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ComputerInfo.vb
+++ /dev/null
@@ -1,245 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Runtime.InteropServices
-Imports Microsoft.VisualBasic.CompilerServices
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    ''' Provides configuration information about the current computer and the current process.
-    ''' </summary>
-    <DebuggerTypeProxy(GetType(ComputerInfo.ComputerInfoDebugView))>
-    Public Class ComputerInfo
-
-        ' Keep the debugger proxy current as you change this class - see the nested ComputerInfoDebugView below.
-
-        ''' <summary>
-        ''' Default constructor
-        ''' </summary>
-        Sub New()
-        End Sub
-
-#Disable Warning IDE0049 ' Simplify Names, Justification:="<Public API>
-        ''' <summary>
-        ''' Gets the total size of physical memory on the machine.
-        ''' </summary>
-        ''' <value>A 64-bit unsigned integer containing the size of total physical memory on the machine, in bytes.</value>
-        ''' <exception cref="ComponentModel.Win32Exception">If we are unable to obtain the memory status.</exception>
-        <CLSCompliant(False)>
-        Public ReadOnly Property TotalPhysicalMemory() As UInt64
-            Get
-                Return MemoryStatus.TotalPhysicalMemory
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the total size of free physical memory on the machine.
-        ''' </summary>
-        ''' <value>A 64-bit unsigned integer containing the size of free physical memory on the machine, in bytes.</value>
-        ''' <exception cref="ComponentModel.Win32Exception">If we are unable to obtain the memory status.</exception>
-        <CLSCompliant(False)>
-        Public ReadOnly Property AvailablePhysicalMemory() As UInt64
-            Get
-                Return MemoryStatus.AvailablePhysicalMemory
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the total size of user potion of virtual address space for calling process.
-        ''' </summary>
-        ''' <value>A 64-bit unsigned integer containing the size of user potion of virtual address space for calling process, 
-        '''          in bytes.</value>
-        ''' <exception cref="ComponentModel.Win32Exception">If we are unable to obtain the memory status.</exception>
-        <CLSCompliant(False)>
-        Public ReadOnly Property TotalVirtualMemory() As UInt64
-            Get
-                Return MemoryStatus.TotalVirtualMemory
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the total size of free user potion of virtual address space for calling process.
-        ''' </summary>
-        ''' <value>A 64-bit unsigned integer containing the size of free user potion of virtual address space for calling process, 
-        '''          in bytes.</value>
-        ''' <exception cref="ComponentModel.Win32Exception">If we are unable to obtain the memory status.</exception>
-        <CLSCompliant(False)>
-        Public ReadOnly Property AvailableVirtualMemory() As UInt64
-            Get
-                Return MemoryStatus.AvailableVirtualMemory
-            End Get
-        End Property
-#Enable Warning IDE0049 ' Simplify Names
-
-        ''' <summary>
-        ''' Gets the current UICulture installed on the machine.
-        ''' </summary>
-        ''' <value>A CultureInfo object represents the UI culture installed on the machine.</value>
-        Public ReadOnly Property InstalledUICulture() As Globalization.CultureInfo
-            Get
-                Return Globalization.CultureInfo.InstalledUICulture
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the full operating system name.
-        ''' </summary>
-        ''' <value>A string contains the operating system name.</value>
-        Public ReadOnly Property OSFullName() As String
-            Get
-                Return RuntimeInformation.OSDescription
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the platform OS name.
-        ''' </summary>
-        ''' <value>A string containing a Platform ID like "Win32NT", "Win32S", "Win32Windows". See PlatformID enum.</value>
-        ''' <exception cref="ExecutionEngineException">If cannot obtain the OS Version information.</exception>
-        Public ReadOnly Property OSPlatform() As String
-            Get
-                Return Environment.OSVersion.Platform.ToString
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the current version number of the operating system.
-        ''' </summary>
-        ''' <value>A string contains the current version number of the operating system.</value>
-        ''' <exception cref="ExecutionEngineException">If cannot obtain the OS Version information.</exception>
-        Public ReadOnly Property OSVersion() As String
-            Get
-                Return Environment.OSVersion.Version.ToString
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Debugger proxy for the ComputerInfo class.  The problem is that OSFullName can time out the debugger
-        ''' so we offer a view that doesn't have that field.
-        ''' </summary>
-        Friend NotInheritable Class ComputerInfoDebugView
-            Public Sub New(RealClass As ComputerInfo)
-                _instanceBeingWatched = RealClass
-            End Sub
-
-#Disable Warning IDE0049 ' Simplify Names, Justification:=<Public API>
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property TotalPhysicalMemory() As UInt64
-                Get
-                    Return _instanceBeingWatched.TotalPhysicalMemory
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property AvailablePhysicalMemory() As UInt64
-                Get
-                    Return _instanceBeingWatched.AvailablePhysicalMemory
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property TotalVirtualMemory() As UInt64
-                Get
-                    Return _instanceBeingWatched.TotalVirtualMemory
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property AvailableVirtualMemory() As UInt64
-                Get
-                    Return _instanceBeingWatched.AvailableVirtualMemory
-                End Get
-            End Property
-#Enable Warning IDE0049 ' Simplify Names
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property InstalledUICulture() As Globalization.CultureInfo
-                Get
-                    Return _instanceBeingWatched.InstalledUICulture
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property OSPlatform() As String
-                Get
-                    Return _instanceBeingWatched.OSPlatform
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)>
-            Public ReadOnly Property OSVersion() As String
-                Get
-                    Return _instanceBeingWatched.OSVersion
-                End Get
-            End Property
-
-            <DebuggerBrowsable(DebuggerBrowsableState.Never)>
-            Private ReadOnly _instanceBeingWatched As ComputerInfo
-        End Class
-
-        ''' <summary>
-        ''' Gets the whole memory information details.
-        ''' </summary>
-        ''' <value>An InternalMemoryStatus class.</value>
-        Private ReadOnly Property MemoryStatus() As InternalMemoryStatus
-            Get
-                If _internalMemoryStatus Is Nothing Then
-                    _internalMemoryStatus = New InternalMemoryStatus
-                End If
-                Return _internalMemoryStatus
-            End Get
-        End Property
-
-        Private _internalMemoryStatus As InternalMemoryStatus ' Cache our InternalMemoryStatus
-
-        ''' <summary>
-        ''' Calls GlobalMemoryStatusEx and returns the correct value.
-        ''' </summary>
-        Private NotInheritable Class InternalMemoryStatus
-            Friend Sub New()
-            End Sub
-
-#Disable Warning IDE0049 ' Simplify Names, Justification:=<Public API>
-            Friend ReadOnly Property TotalPhysicalMemory() As UInt64
-                Get
-                    Refresh()
-                    Return _memoryStatusEx.ullTotalPhys
-                End Get
-            End Property
-
-            Friend ReadOnly Property AvailablePhysicalMemory() As UInt64
-                Get
-                    Refresh()
-                    Return _memoryStatusEx.ullAvailPhys
-                End Get
-            End Property
-
-            Friend ReadOnly Property TotalVirtualMemory() As UInt64
-                Get
-                    Refresh()
-                    Return _memoryStatusEx.ullTotalVirtual
-                End Get
-            End Property
-
-            Friend ReadOnly Property AvailableVirtualMemory() As UInt64
-                Get
-                    Refresh()
-                    Return _memoryStatusEx.ullAvailVirtual
-                End Get
-            End Property
-#Enable Warning IDE0049 ' Simplify Names
-
-            Private Sub Refresh()
-                _memoryStatusEx = New NativeMethods.MEMORYSTATUSEX
-                _memoryStatusEx.Init()
-                If (Not NativeMethods.GlobalMemoryStatusEx(_memoryStatusEx)) Then
-                    Throw ExceptionUtils.GetWin32Exception(SR.DiagnosticInfo_Memory)
-                End If
-            End Sub
-
-            Private _memoryStatusEx As NativeMethods.MEMORYSTATUSEX
-        End Class
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Keyboard.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Keyboard.vb
deleted file mode 100644
index bb5d1689ba5..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Keyboard.vb
+++ /dev/null
@@ -1,117 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Windows.Forms
-Imports Microsoft.VisualBasic.CompilerServices
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    '''  A class representing a computer keyboard. Enables discovery of key
-    '''  state information for the most common scenarios and enables SendKeys
-    ''' </summary>
-    Public Class Keyboard
-
-        ''' <summary>
-        ''' Sends keys to the active window as if typed as keyboard with wait = false.
-        ''' </summary>
-        ''' <param name="keys">A string containing the keys to be sent (typed).</param>
-        Public Sub SendKeys(keys As String)
-            SendKeys(keys, False)
-        End Sub
-
-        ''' <summary>
-        ''' Sends keys to the active window as if typed at keyboard. This overloaded
-        ''' version uses the same conventions as the VB6 SendKeys.
-        ''' </summary>
-        ''' <param name="keys">A string containing the keys to be sent (typed).</param>
-        ''' <param name="wait">Wait for messages to be processed before returning.</param>
-        Public Sub SendKeys(keys As String, wait As Boolean)
-            If wait Then
-                System.Windows.Forms.SendKeys.SendWait(keys)
-            Else
-                System.Windows.Forms.SendKeys.Send(keys)
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Gets the state (up or down) of the Shift key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property ShiftKeyDown() As Boolean
-            Get
-                Dim Keys As Keys = Control.ModifierKeys
-                Return CType(Keys And Keys.Shift, Boolean)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the state (up or down) of the Alt key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property AltKeyDown() As Boolean
-            Get
-                Dim Keys As Keys = Control.ModifierKeys
-                Return CType(Keys And Keys.Alt, Boolean)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the state (up or down) of the Ctrl key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property CtrlKeyDown() As Boolean
-            Get
-                Dim Keys As Keys = Control.ModifierKeys
-                Return CType(Keys And Keys.Control, Boolean)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the toggle state of the Caps Lock key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property CapsLock() As Boolean
-            Get
-                'Security Note: Only the state of the Caps Lock is returned
-
-                'The low order byte of the return value from GetKeyState is 1 if the key is
-                'toggled on.
-                Return CType((UnsafeNativeMethods.GetKeyState(Keys.CapsLock) And 1), Boolean)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the toggle state of the Num Lock key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property NumLock() As Boolean
-            Get
-                'Security Note: Only the state of the Num Lock is returned
-
-                'The low order byte of the return value from GetKeyState is 1 if the key is
-                'toggled on.
-                Return CType((UnsafeNativeMethods.GetKeyState(Keys.NumLock) And 1), Boolean)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the toggle state of the Scroll Lock key.
-        ''' </summary>
-        ''' <returns>True if the key is down otherwise false.</returns>
-        Public ReadOnly Property ScrollLock() As Boolean
-            Get
-                'Security Note: Only the state of the Scroll Lock is returned
-
-                'The low order byte of the return value from GetKeyState is 1 if the key is
-                'toggled on.
-                Return CType((UnsafeNativeMethods.GetKeyState(Keys.Scroll) And 1), Boolean)
-            End Get
-        End Property
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Mouse.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Mouse.vb
deleted file mode 100644
index 0f3ca96b6d1..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Mouse.vb
+++ /dev/null
@@ -1,70 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.Windows.Forms
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    ''' A wrapper object that acts as a discovery mechanism for finding 
-    ''' information about the mouse on your computer such as whether the mouse
-    ''' exists, the number of buttons, WheelScrolls details.
-    '''
-    ''' This class is a Singleton Class. See Common.Computer for details.
-    ''' </summary>
-    Public Class Mouse
-
-        ''' <summary>
-        ''' Gets a value indicating whether the functions of the left and right
-        ''' mouses buttons have been swapped.
-        ''' </summary>
-        ''' <value>
-        ''' true if the functions of the left and right mouse buttons are swapped. false otherwise. 
-        ''' </value>
-        ''' <exception cref="InvalidOperationException">If no mouse is installed.</exception>
-        Public ReadOnly Property ButtonsSwapped() As Boolean
-            Get
-                If System.Windows.Forms.SystemInformation.MousePresent Then
-                    Return SystemInformation.MouseButtonsSwapped
-                Else
-                    Throw GetInvalidOperationException(SR.Mouse_NoMouseIsPresent)
-                End If
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets a value indicating whether a mouse with a mouse wheel is installed
-        ''' </summary>
-        ''' <value>true if a mouse with a mouse wheel is installed, false otherwise.</value>
-        ''' <exception cref="InvalidOperationException">If no mouse is installed.</exception>
-        Public ReadOnly Property WheelExists() As Boolean
-            Get
-                If System.Windows.Forms.SystemInformation.MousePresent Then
-                    Return SystemInformation.MouseWheelPresent
-                Else
-                    Throw GetInvalidOperationException(SR.Mouse_NoMouseIsPresent)
-                End If
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the number of lines to scroll when the mouse wheel is rotated.
-        ''' </summary>
-        ''' <value>The number of lines to scroll.</value>
-        ''' <exception cref="InvalidOperationException">if no mouse is installed or no wheels exists.</exception>
-        Public ReadOnly Property WheelScrollLines() As Integer
-            Get
-                If WheelExists Then
-                    Return SystemInformation.MouseWheelScrollLines
-                Else
-                    Throw GetInvalidOperationException(SR.Mouse_NoWheelIsPresent)
-                End If
-            End Get
-        End Property
-
-    End Class 'Mouse
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Network.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Network.vb
deleted file mode 100644
index 123d1319407..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/Network.vb
+++ /dev/null
@@ -1,820 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-Imports System.ComponentModel
-Imports System.Net
-Imports System.Security
-Imports System.Threading
-Imports Microsoft.VisualBasic.CompilerServices
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-Imports Microsoft.VisualBasic.FileIO
-Imports Microsoft.VisualBasic.MyServices.Internal
-Imports NetInfoAlias = System.Net.NetworkInformation
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    '''  Used to pass network connectivity status.
-    ''' </summary>
-    Public Class NetworkAvailableEventArgs
-        Inherits EventArgs
-        Public Sub New(networkAvailable As Boolean)
-            IsNetworkAvailable = networkAvailable
-        End Sub
-
-        Public ReadOnly Property IsNetworkAvailable() As Boolean
-    End Class
-
-    <EditorBrowsable(EditorBrowsableState.Advanced)>
-    Public Delegate Sub NetworkAvailableEventHandler(sender As Object, e As NetworkAvailableEventArgs)
-
-    ''' <summary>
-    '''  An object that allows easy access to some simple network properties and functionality.
-    ''' </summary>
-    Public Class Network
-
-        ''' <summary>
-        '''  Event fired when connected to the network
-        ''' </summary>
-        ''' <param name="Sender">Has no meaning for this event</param>
-        ''' <param name="e">Has no meaning for this event</param>
-        Public Custom Event NetworkAvailabilityChanged As NetworkAvailableEventHandler
-            'This is a custom event because we want to hook up the NetworkAvailabilityChanged event only if the user writes a handler for it.
-            'The reason being that it is very expensive to handle and kills our application startup perf.
-            AddHandler(handler As NetworkAvailableEventHandler)
-
-                ' Set the current state of connectedness, swallow known exceptions since user won't be able to correct problem
-                Try
-                    _connected = IsAvailable
-                Catch ex As SecurityException
-                    Return
-                Catch ex As PlatformNotSupportedException
-                    Return
-                End Try
-                SyncLock _syncObject 'we don't want our event firing before we've finished setting up the infrastructure.  Also, need to assure there are no races in here so we don't hook up the OS listener twice, etc.
-                    If _networkAvailabilityEventHandlers Is Nothing Then _networkAvailabilityEventHandlers = New List(Of NetworkAvailableEventHandler)
-                    _networkAvailabilityEventHandlers.Add(handler)
-
-                    'Only setup the event Marshalling infrastructure once
-                    If _networkAvailabilityEventHandlers.Count = 1 Then
-                        _networkAvailabilityChangedCallback = New SendOrPostCallback(AddressOf NetworkAvailabilityChangedHandler) 'the async operation posts to this delegate
-                        If AsyncOperationManager.SynchronizationContext IsNot Nothing Then
-                            _synchronizationContext = AsyncOperationManager.SynchronizationContext 'We need to hang on to the synchronization context associated with the thread the network object is created on
-                            Try ' Exceptions are thrown if the user isn't an admin.
-                                AddHandler NetInfoAlias.NetworkChange.NetworkAddressChanged, New NetInfoAlias.NetworkAddressChangedEventHandler(AddressOf OS_NetworkAvailabilityChangedListener) 'listen to the OS event
-                            Catch ex As PlatformNotSupportedException
-                            Catch ex As NetInfoAlias.NetworkInformationException
-                            End Try
-                        End If
-                    End If
-                End SyncLock
-            End AddHandler
-
-            RemoveHandler(handler As NetworkAvailableEventHandler)
-                If _networkAvailabilityEventHandlers IsNot Nothing AndAlso _networkAvailabilityEventHandlers.Count > 0 Then
-                    _networkAvailabilityEventHandlers.Remove(handler)
-                    'Last one to leave, turn out the lights...
-                    If _networkAvailabilityEventHandlers.Count = 0 Then
-                        RemoveHandler NetInfoAlias.NetworkChange.NetworkAddressChanged, New NetInfoAlias.NetworkAddressChangedEventHandler(AddressOf OS_NetworkAvailabilityChangedListener) 'listen to the OS event
-                        DisconnectListener() 'Stop listening to network change events since nobody is listening to us anymore
-                    End If
-                End If
-            End RemoveHandler
-
-            RaiseEvent(sender As Object, e As NetworkAvailableEventArgs)
-                If _networkAvailabilityEventHandlers IsNot Nothing Then
-                    For Each handler As NetworkAvailableEventHandler In _networkAvailabilityEventHandlers
-                        If handler IsNot Nothing Then handler.Invoke(sender, e)
-                    Next
-                End If
-            End RaiseEvent
-        End Event
-
-        ''' <summary>
-        '''  Creates class and hooks up events
-        ''' </summary>
-        Public Sub New()
-        End Sub
-
-        ''' <summary>
-        '''  Indicates whether or not the local machine is connected to an IP network.
-        ''' </summary>
-        ''' <value>True if connected, otherwise False</value>
-        Public ReadOnly Property IsAvailable() As Boolean
-            Get
-
-                Return NetInfoAlias.NetworkInterface.GetIsNetworkAvailable()
-
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Sends and receives a packet to and from the passed in address.
-        ''' </summary>
-        ''' <param name="hostNameOrAddress"></param>
-        ''' <returns>True if ping was successful, otherwise False</returns>
-        Public Function Ping(hostNameOrAddress As String) As Boolean
-            Return Ping(hostNameOrAddress, DEFAULT_PING_TIMEOUT)
-        End Function
-
-        ''' <summary>
-        ''' Sends and receives a packet to and from the passed in Uri.
-        ''' </summary>
-        ''' <param name="address">A Uri representing the host</param>
-        ''' <returns>True if ping was successful, otherwise False</returns>
-        Public Function Ping(address As Uri) As Boolean
-            ' We're safe from Ping(Nothing, ...) due to overload failure (Ping(String,...) vs. Ping(Uri,...)).
-            ' However, it is good practice to verify address before calling address.Host.
-            If address Is Nothing Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-            Return Ping(address.Host, DEFAULT_PING_TIMEOUT)
-        End Function
-
-        ''' <summary>
-        '''  Sends and receives a packet to and from the passed in address.
-        ''' </summary>
-        ''' <param name="hostNameOrAddress">The name of the host as a Url or IP Address</param>
-        ''' <param name="timeout">Time to wait before aborting ping</param>
-        ''' <returns>True if ping was successful, otherwise False</returns>
-        Public Function Ping(hostNameOrAddress As String, timeout As Integer) As Boolean
-
-            ' Make sure a network is available
-            If Not IsAvailable Then
-                Throw ExceptionUtils.GetInvalidOperationException(SR.Network_NetworkNotAvailable)
-            End If
-
-            Dim PingMaker As New NetInfoAlias.Ping
-            Dim Reply As NetInfoAlias.PingReply = PingMaker.Send(hostNameOrAddress, timeout, PingBuffer)
-            If Reply.Status = NetInfoAlias.IPStatus.Success Then
-                Return True
-            End If
-            Return False
-        End Function
-
-        ''' <summary>
-        ''' Sends and receives a packet to and from the passed in Uri.
-        ''' </summary>
-        ''' <param name="address">A Uri representing the host</param>
-        ''' <param name="timeout">Time to wait before aborting ping</param>
-        ''' <returns>True if ping was successful, otherwise False</returns>
-        Public Function Ping(address As Uri, timeout As Integer) As Boolean
-            ' We're safe from Ping(Nothing, ...) due to overload failure (Ping(String,...) vs. Ping(Uri,...)).
-            ' However, it is good practice to verify address before calling address.Host.
-            If address Is Nothing Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-            Return Ping(address.Host, timeout)
-        End Function
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Address to the remote file, http, ftp etc...</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        Public Sub DownloadFile(address As String, destinationFileName As String)
-            DownloadFile(address, destinationFileName, DEFAULT_USERNAME, DEFAULT_PASSWORD, False, DEFAULT_TIMEOUT, False)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        Public Sub DownloadFile(address As Uri, destinationFileName As String)
-            DownloadFile(address, destinationFileName, DEFAULT_USERNAME, DEFAULT_PASSWORD, False, DEFAULT_TIMEOUT, False)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Address to the remote file, http, ftp etc...</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        Public Sub DownloadFile(address As String, destinationFileName As String, userName As String, password As String)
-            DownloadFile(address, destinationFileName, userName, password, False, DEFAULT_TIMEOUT, False)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        Public Sub DownloadFile(address As Uri, destinationFileName As String, userName As String, password As String)
-            DownloadFile(address, destinationFileName, userName, password, False, DEFAULT_TIMEOUT, False)
-        End Sub
-
-        ''' <summary>
-        '''  Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Address to the remote file, http, ftp etc...</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        Public Sub DownloadFile(address As String,
-                             destinationFileName As String,
-                             userName As String,
-                             password As String,
-                             showUI As Boolean,
-                             connectionTimeout As Integer,
-                             overwrite As Boolean)
-
-            DownloadFile(address, destinationFileName, userName, password, showUI, connectionTimeout, overwrite, UICancelOption.ThrowException)
-        End Sub
-
-        ''' <summary>
-        '''  Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Address to the remote file, http, ftp etc...</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        Public Sub DownloadFile(address As String,
-                             destinationFileName As String,
-                             userName As String,
-                             password As String,
-                             showUI As Boolean,
-                             connectionTimeout As Integer,
-                             overwrite As Boolean,
-                             onUserCancel As UICancelOption)
-
-            ' We're safe from DownloadFile(Nothing, ...) due to overload failure (DownloadFile(String,...) vs. DownloadFile(Uri,...)).
-            ' However, it is good practice to verify address before calling Trim.
-            If String.IsNullOrWhiteSpace(address) Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-
-            Dim addressUri As Uri = GetUri(address.Trim())
-
-            ' Get network credentials
-            Dim networkCredentials As ICredentials = GetNetworkCredentials(userName, password)
-
-            DownloadFile(addressUri, destinationFileName, networkCredentials, showUI, connectionTimeout, overwrite, onUserCancel)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        Sub DownloadFile(address As Uri,
-                     destinationFileName As String,
-                     userName As String,
-                     password As String,
-                     showUI As Boolean,
-                     connectionTimeout As Integer,
-                     overwrite As Boolean)
-
-            DownloadFile(address, destinationFileName, userName, password, showUI, connectionTimeout, overwrite, UICancelOption.ThrowException)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="userName">The name of the user performing the download</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        Sub DownloadFile(address As Uri,
-                     destinationFileName As String,
-                     userName As String,
-                     password As String,
-                     showUI As Boolean,
-                     connectionTimeout As Integer,
-                     overwrite As Boolean,
-                     onUserCancel As UICancelOption)
-
-            ' Get network credentials
-            Dim networkCredentials As ICredentials = GetNetworkCredentials(userName, password)
-
-            DownloadFile(address, destinationFileName, networkCredentials, showUI, connectionTimeout, overwrite, onUserCancel)
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="networkCredentials">The credentials of the user performing the download</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        ''' <remarks>Calls to all the other overloads will come through here</remarks>
-        Sub DownloadFile(address As Uri,
-                    destinationFileName As String,
-                    networkCredentials As ICredentials,
-                    showUI As Boolean,
-                    connectionTimeout As Integer,
-                    overwrite As Boolean)
-
-            DownloadFile(address, destinationFileName, networkCredentials, showUI, connectionTimeout, overwrite, UICancelOption.ThrowException)
-
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file from the network to the specified path
-        ''' </summary>
-        ''' <param name="address">Uri to the remote file</param>
-        ''' <param name="destinationFileName">Name and path of file where download is saved</param>
-        ''' <param name="networkCredentials">The credentials of the user performing the download</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="overwrite">Indicates whether or not the file should be overwritten if local file already exists</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        ''' <remarks>Calls to all the other overloads will come through here</remarks>
-        Sub DownloadFile(address As Uri,
-                    destinationFileName As String,
-                    networkCredentials As ICredentials,
-                    showUI As Boolean,
-                    connectionTimeout As Integer,
-                    overwrite As Boolean,
-                    onUserCancel As UICancelOption)
-            If connectionTimeout <= 0 Then
-                Throw GetArgumentExceptionWithArgName("connectionTimeOut", SR.Network_BadConnectionTimeout)
-            End If
-
-            If address Is Nothing Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-
-            Using client As New WebClientExtended
-                client.Timeout = connectionTimeout
-
-                ' Don't use passive mode if we're showing UI
-                client.UseNonPassiveFtp = showUI
-
-                'Construct the local file. This will validate the full name and path
-                Dim fullFilename As String = FileSystemUtils.NormalizeFilePath(destinationFileName, "destinationFileName")
-
-                ' Sometime a path that can't be parsed is normalized to the current directory. This makes sure we really
-                ' have a file and path
-                If System.IO.Directory.Exists(fullFilename) Then
-                    Throw ExceptionUtils.GetInvalidOperationException(SR.Network_DownloadNeedsFilename)
-                End If
-
-                'Throw if the file exists and the user doesn't want to overwrite
-                If IO.File.Exists(fullFilename) And Not overwrite Then
-                    Throw New IO.IOException(GetResourceString(SR.IO_FileExists_Path, destinationFileName))
-                End If
-
-                ' Set credentials if we have any
-                If networkCredentials IsNot Nothing Then
-                    client.Credentials = networkCredentials
-                End If
-
-                Dim dialog As ProgressDialog = Nothing
-                If showUI AndAlso System.Environment.UserInteractive Then
-                    dialog = New ProgressDialog With {
-                        .Text = GetResourceString(SR.ProgressDialogDownloadingTitle, address.AbsolutePath),
-                        .LabelText = GetResourceString(SR.ProgressDialogDownloadingLabel, address.AbsolutePath, fullFilename)
-                    }
-                End If
-
-                'Check to see if the target directory exists. If it doesn't, create it
-                Dim targetDirectory As String = System.IO.Path.GetDirectoryName(fullFilename)
-
-                ' Make sure we have a meaningful directory. If we don't, the destinationFileName is suspect
-                If String.IsNullOrEmpty(targetDirectory) Then
-                    Throw ExceptionUtils.GetInvalidOperationException(SR.Network_DownloadNeedsFilename)
-                End If
-
-                If Not IO.Directory.Exists(targetDirectory) Then
-                    IO.Directory.CreateDirectory(targetDirectory)
-                End If
-
-                'Create the copier
-                Dim copier As New WebClientCopy(client, dialog)
-
-                'Download the file
-                copier.DownloadFile(address, fullFilename)
-
-                'Handle a dialog cancel
-                If showUI AndAlso System.Environment.UserInteractive Then
-                    If onUserCancel = UICancelOption.ThrowException And dialog.UserCanceledTheDialog Then
-                        Throw New OperationCanceledException()
-                    End If
-                End If
-
-            End Using
-
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">The full name and path of the host destination</param>
-        Public Sub UploadFile(sourceFileName As String, address As String)
-            UploadFile(sourceFileName, address, DEFAULT_USERNAME, DEFAULT_PASSWORD, False, DEFAULT_TIMEOUT)
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        Public Sub UploadFile(sourceFileName As String, address As Uri)
-            UploadFile(sourceFileName, address, DEFAULT_USERNAME, DEFAULT_PASSWORD, False, DEFAULT_TIMEOUT)
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">The full name and path of the host destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="password">The user's password</param>
-        Public Sub UploadFile(sourceFileName As String, address As String, userName As String, password As String)
-            UploadFile(sourceFileName, address, userName, password, False, DEFAULT_TIMEOUT)
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="password">The user's password</param>
-        Public Sub UploadFile(sourceFileName As String, address As Uri, userName As String, password As String)
-            UploadFile(sourceFileName, address, userName, password, False, DEFAULT_TIMEOUT)
-        End Sub
-
-        ''' <summary>
-        '''  Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">The full name and path of the host destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="Password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        Public Sub UploadFile(sourceFileName As String,
-                      address As String,
-                      userName As String,
-                      password As String,
-                      showUI As Boolean,
-                      connectionTimeout As Integer)
-
-            UploadFile(sourceFileName, address, userName, password, showUI, connectionTimeout, UICancelOption.ThrowException)
-        End Sub
-
-        ''' <summary>
-        '''  Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">The full name and path of the host destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="Password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        Public Sub UploadFile(sourceFileName As String,
-                      address As String,
-                      userName As String,
-                      password As String,
-                      showUI As Boolean,
-                      connectionTimeout As Integer,
-                      onUserCancel As UICancelOption)
-
-            ' We're safe from UploadFile(Nothing, ...) due to overload failure (UploadFile(String,...) vs. UploadFile(Uri,...)).
-            ' However, it is good practice to verify address before calling address.Trim.
-            If String.IsNullOrWhiteSpace(address) Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-
-            ' Getting a uri will validate the form of the host address
-            Dim addressUri As Uri = GetUri(address.Trim())
-
-            ' For uploads, we need to make sure the address includes the filename
-            If String.IsNullOrEmpty(IO.Path.GetFileName(addressUri.AbsolutePath)) Then
-                Throw ExceptionUtils.GetInvalidOperationException(SR.Network_UploadAddressNeedsFilename)
-            End If
-
-            UploadFile(sourceFileName, addressUri, userName, password, showUI, connectionTimeout, onUserCancel)
-
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        Public Sub UploadFile(sourceFileName As String,
-                              address As Uri,
-                              userName As String,
-                              password As String,
-                              showUI As Boolean,
-                              connectionTimeout As Integer)
-
-            UploadFile(sourceFileName, address, userName, password, showUI, connectionTimeout, UICancelOption.ThrowException)
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        ''' <param name="userName">The name of the user performing the upload</param>
-        ''' <param name="password">The user's password</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        Public Sub UploadFile(sourceFileName As String,
-                              address As Uri,
-                              userName As String,
-                              password As String,
-                              showUI As Boolean,
-                              connectionTimeout As Integer,
-                              onUserCancel As UICancelOption)
-
-            ' Get network credentials
-            Dim networkCredentials As ICredentials = GetNetworkCredentials(userName, password)
-
-            UploadFile(sourceFileName, address, networkCredentials, showUI, connectionTimeout, onUserCancel)
-
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        ''' <param name="networkCredentials">The credentials of the user performing the upload</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        Public Sub UploadFile(sourceFileName As String,
-                              address As Uri,
-                              networkCredentials As ICredentials,
-                              showUI As Boolean,
-                              connectionTimeout As Integer)
-
-            UploadFile(sourceFileName, address, networkCredentials, showUI, connectionTimeout, UICancelOption.ThrowException)
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file from the local machine to the specified host
-        ''' </summary>
-        ''' <param name="sourceFileName">The file to be uploaded</param>
-        ''' <param name="address">Uri representing the destination</param>
-        ''' <param name="networkCredentials">The credentials of the user performing the upload</param>
-        ''' <param name="showUI">Indicates whether or not to show a progress bar</param>
-        ''' <param name="connectionTimeout">Time alloted before giving up on a connection</param>
-        ''' <param name="onUserCancel">Indicates what to do if user cancels dialog (either throw or do nothing)</param>
-        Public Sub UploadFile(sourceFileName As String,
-                              address As Uri,
-                              networkCredentials As ICredentials,
-                              showUI As Boolean,
-                              connectionTimeout As Integer,
-                              onUserCancel As UICancelOption)
-            sourceFileName = FileSystemUtils.NormalizeFilePath(sourceFileName, "sourceFileName")
-
-            'Make sure the file exists
-            If Not IO.File.Exists(sourceFileName) Then
-                Throw New IO.FileNotFoundException(GetResourceString(SR.IO_FileNotFound_Path, sourceFileName))
-            End If
-
-            If connectionTimeout <= 0 Then
-                Throw GetArgumentExceptionWithArgName("connectionTimeout", SR.Network_BadConnectionTimeout)
-            End If
-
-            If address Is Nothing Then
-                Throw ExceptionUtils.GetArgumentNullException("address")
-            End If
-
-            Using client As New WebClientExtended()
-                client.Timeout = connectionTimeout
-
-                ' Set credentials if we have any
-                If networkCredentials IsNot Nothing Then
-                    client.Credentials = networkCredentials
-                End If
-
-                Dim Dialog As ProgressDialog = Nothing
-                If showUI AndAlso System.Environment.UserInteractive Then
-                    Dialog = New ProgressDialog With {
-                        .Text = GetResourceString(SR.ProgressDialogUploadingTitle, sourceFileName),
-                        .LabelText = GetResourceString(SR.ProgressDialogUploadingLabel, sourceFileName, address.AbsolutePath)
-                    }
-                End If
-
-                'Create the copier
-                Dim copier As New WebClientCopy(client, Dialog)
-
-                'Download the file
-                copier.UploadFile(sourceFileName, address)
-
-                'Handle a dialog cancel
-                If showUI AndAlso System.Environment.UserInteractive Then
-                    If onUserCancel = UICancelOption.ThrowException And Dialog.UserCanceledTheDialog Then
-                        Throw New OperationCanceledException()
-                    End If
-                End If
-            End Using
-
-        End Sub
-
-        Friend Sub DisconnectListener()
-            RemoveHandler NetInfoAlias.NetworkChange.NetworkAddressChanged, New NetInfoAlias.NetworkAddressChangedEventHandler(AddressOf OS_NetworkAvailabilityChangedListener)
-        End Sub
-
-        'Listens to the AddressChanged event from the OS which comes in on an arbitrary thread
-        Private Sub OS_NetworkAvailabilityChangedListener(sender As Object, e As EventArgs)
-            SyncLock _syncObject 'Ensure we don't handle events until after we've finished setting up the event marshalling infrastructure
-                'Don't call AsyncOperationManager.OperationSynchronizationContext.Post.  The reason we want to go through m_SynchronizationContext is that
-                'the OperationSyncronizationContext is thread static.  Since we are getting called on some random thread, the context that was
-                'in place when the Network object was created won't be available (it is on the original thread).  To hang on to the original
-                'context associated with the thread that the network object is created on, I use m_SynchronizationContext.
-                _synchronizationContext.Post(_networkAvailabilityChangedCallback, Nothing)
-            End SyncLock
-        End Sub
-
-        'Listens to the AddressChanged event which will come on the same thread that this class was created on (AsyncEventManager is responsible for getting the event here)
-        Private Sub NetworkAvailabilityChangedHandler(state As Object)
-            Dim Connected As Boolean = IsAvailable
-            ' Fire an event only if the connected state has changed
-            If _connected <> Connected Then
-                _connected = Connected
-                RaiseEvent NetworkAvailabilityChanged(Me, New NetworkAvailableEventArgs(Connected))
-            End If
-        End Sub
-
-        ''' <summary>
-        '''  A buffer for pinging. This imitates the buffer used by Ping.Exe
-        ''' </summary>
-        ''' <value>A buffer</value>
-        Private ReadOnly Property PingBuffer() As Byte()
-            Get
-                If _pingBuffer Is Nothing Then
-                    ReDim _pingBuffer(BUFFER_SIZE - 1)
-                    For i As Integer = 0 To BUFFER_SIZE - 1
-                        'This is the same logic Ping.exe uses to fill it's buffer
-                        _pingBuffer(i) = System.Convert.ToByte(Asc("a"c) + i Mod 23, System.Globalization.CultureInfo.InvariantCulture)
-                    Next
-                End If
-
-                Return _pingBuffer
-            End Get
-        End Property
-
-        ''' <summary>
-        '''  Gets a Uri from a uri string. We also use this function to validate the UriString (remote file address)
-        ''' </summary>
-        ''' <param name="address">The remote file address</param>
-        ''' <returns>A Uri if successful, otherwise it throws an exception</returns>
-        Private Shared Function GetUri(address As String) As Uri
-            Try
-                Return New Uri(address)
-            Catch ex As UriFormatException
-                'Throw an exception with an error message more appropriate to our API
-                Throw GetArgumentExceptionWithArgName("address", SR.Network_InvalidUriString, address)
-            End Try
-        End Function
-
-        ''' <summary>
-        ''' Gets network credentials from a userName and password
-        ''' </summary>
-        ''' <param name="userName">The name of the user</param>
-        ''' <param name="password">The password of the user</param>
-        ''' <returns>A NetworkCredentials</returns>
-        Private Shared Function GetNetworkCredentials(userName As String, password As String) As ICredentials
-
-            ' Make sure all nulls are empty strings
-            If userName Is Nothing Then
-                userName = ""
-            End If
-
-            If password Is Nothing Then
-                password = ""
-            End If
-
-            If userName.Length = 0 And password.Length = 0 Then
-                Return Nothing
-            End If
-
-            Return New NetworkCredential(userName, password)
-        End Function
-
-        'Holds the buffer for pinging. We lazy initialize on first use
-        Private _pingBuffer() As Byte
-
-        'Size of Ping.exe buffer
-        Private Const BUFFER_SIZE As Integer = 32
-
-        ' Default timeout value
-        Private Const DEFAULT_TIMEOUT As Integer = 100000
-
-        ' Default timeout for Ping
-        Private Const DEFAULT_PING_TIMEOUT As Integer = 1000
-
-        ' UserName used in overloads where there is no userName parameter
-        Private Const DEFAULT_USERNAME As String = ""
-
-        ' Password used in overloads where there is no password parameter
-        Private Const DEFAULT_PASSWORD As String = ""
-
-        ' Indicates last known connection state
-        Private _connected As Boolean
-
-        ' Object for syncing
-        Private ReadOnly _syncObject As New Object()
-
-        Private _networkAvailabilityEventHandlers As List(Of NetworkAvailableEventHandler) 'Holds the listeners to our NetworkAvailability changed event
-
-        Private _synchronizationContext As SynchronizationContext
-        Private _networkAvailabilityChangedCallback As SendOrPostCallback 'Used for marshalling the network address changed event to the foreground thread
-    End Class
-
-    ''' <summary>
-    ''' Temporary class used to provide WebClient with a timeout property.
-    ''' </summary>
-    ''' <remarks>This class will be deleted when Timeout is added to WebClient</remarks>
-    Friend NotInheritable Class WebClientExtended
-        Inherits WebClient
-
-        ''' <summary>
-        ''' Sets or indicates the timeout used by WebRequest used by WebClient
-        ''' </summary>
-        Public WriteOnly Property Timeout() As Integer
-            Set(value As Integer)
-                Debug.Assert(value > 0, "illegal value for timeout")
-                _timeout = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Enables switching the server to non passive mode.
-        ''' </summary>
-        ''' <remarks>We need this in order for the progress UI on a download to work</remarks>
-        Public WriteOnly Property UseNonPassiveFtp() As Boolean
-            Set(value As Boolean)
-                _useNonPassiveFtp = value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Makes sure that the timeout value for WebRequests (used for all Download and Upload methods) is set
-        ''' to the Timeout value
-        ''' </summary>
-        ''' <param name="address"></param>
-        Protected Overrides Function GetWebRequest(address As Uri) As WebRequest
-            Dim request As WebRequest = MyBase.GetWebRequest(address)
-
-            Debug.Assert(request IsNot Nothing, "Unable to get WebRequest from base class")
-            If request IsNot Nothing Then
-                request.Timeout = _timeout
-                If _useNonPassiveFtp Then
-                    Dim ftpRequest As FtpWebRequest = TryCast(request, FtpWebRequest)
-                    If ftpRequest IsNot Nothing Then
-                        ftpRequest.UsePassive = False
-                    End If
-                End If
-
-                Dim httpRequest As HttpWebRequest = TryCast(request, HttpWebRequest)
-                If httpRequest IsNot Nothing Then
-                    httpRequest.AllowAutoRedirect = False
-                End If
-
-            End If
-
-            Return request
-        End Function
-
-#Disable Warning BC41004 ' First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the constructor in the base class is marked obsolete
-        Friend Sub New()
-        End Sub
-#Enable Warning BC41004 ' First statement of this 'Sub New' should be an explicit call to 'MyBase.New' or 'MyClass.New' because the constructor in the base class is marked obsolete
-
-        ' The Timeout value to be used by WebClient's WebRequest for Downloading or Uploading a file
-        Private _timeout As Integer = 100000
-
-        ' Flag used to indicate whether or not we should use passive mode when ftp downloading
-        Private _useNonPassiveFtp As Boolean
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ServerComputer.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ServerComputer.vb
deleted file mode 100644
index 063073676b0..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Devices/ServerComputer.vb
+++ /dev/null
@@ -1,107 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports Microsoft.VisualBasic.MyServices
-
-Namespace Microsoft.VisualBasic.Devices
-
-    ''' <summary>
-    ''' A RAD object representing the server 'computer' for the web/Windows Services
-    ''' that serves as a discovery mechanism for finding principle abstractions in
-    ''' the system that you can code against
-    ''' </summary>
-    Public Class ServerComputer
-
-        'NOTE: The .Net design guidelines state that access to Instance members does not have to be thread-safe.  Access to Shared members does have to be thread-safe.
-        'Since My.Computer creates the instance of Computer in a thread-safe way, access to the Computer will necessarily be thread-safe.
-        'There is nothing to prevent a user from passing our computer object across threads or creating their own instance and then getting into trouble.
-        'But that is completely consistent with the rest of the FX design.  It is MY.* that is thread safe and leads to best practice access to these objects.
-        'If you dim them up yourself, you are responsible for managing the threading.
-
-        ''' <summary>
-        ''' Returns the Clock object which contains the LocalTime and GMTTime.
-        ''' </summary>
-        Public ReadOnly Property Clock() As Clock
-            Get
-                If s_clock IsNot Nothing Then Return s_clock
-                s_clock = New Clock
-                Return s_clock
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the object representing the file system of the computer.
-        ''' </summary>
-        ''' <value>A System.IO.FileSystem object.</value>
-        ''' <remarks>The instance returned by this property is lazy initialized and cached.</remarks>
-        Public ReadOnly Property FileSystem() As FileSystemProxy
-            Get
-                If _fileIO Is Nothing Then
-                    _fileIO = New FileSystemProxy
-                End If
-                Return _fileIO
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the object representing information about the computer's state
-        ''' </summary>
-        ''' <value>A Microsoft.VisualBasic.MyServices.ComputerInfo object.</value>
-        ''' <remarks>The instance returned by this property is lazy initialized and cached.</remarks>
-        Public ReadOnly Property Info() As ComputerInfo
-            Get
-                If _computerInfo Is Nothing Then
-                    _computerInfo = New ComputerInfo
-                End If
-                Return _computerInfo
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This property returns the Network object containing information about
-        ''' the network the machine is part of.
-        ''' </summary>
-        ''' <value>An instance of the Network.Network class.</value>
-        Public ReadOnly Property Network() As Network
-            Get
-                If _network IsNot Nothing Then Return _network
-                _network = New Network
-                Return _network
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This property wraps the System.Environment.MachineName property
-        ''' in the .NET framework to return the name of the computer.
-        ''' </summary>
-        ''' <value>A string containing the name of the computer.</value>
-        Public ReadOnly Property Name() As String
-            Get
-                Return System.Environment.MachineName
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the Registry object, which can be used to read, set and
-        ''' enumerate keys and values in the system registry.
-        ''' </summary>
-        ''' <value>An instance of the RegistryProxy object</value>
-        Public ReadOnly Property Registry() As RegistryProxy
-            Get
-                If _registryInstance IsNot Nothing Then Return _registryInstance
-                _registryInstance = New RegistryProxy
-                Return _registryInstance
-            End Get
-        End Property
-
-        Private _computerInfo As ComputerInfo 'Lazy initialized cache for ComputerInfo
-        Private _fileIO As FileSystemProxy 'Lazy initialized cache for the FileSystem.
-        Private _network As Network 'Lazy initialized cache for the Network class.
-        Private _registryInstance As RegistryProxy 'Lazy initialized cache for the Registry class
-        Private Shared s_clock As Clock 'Lazy initialized cache for the Clock class.  SHARED because Clock behaves as a readonly singleton class
-
-    End Class 'MyServerComputer
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/FileSystemUtils.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/FileSystemUtils.vb
deleted file mode 100644
index 10357a7ae66..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/FileSystemUtils.vb
+++ /dev/null
@@ -1,154 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.Security
-
-Imports ExUtils = Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    ''' <summary>
-    '''  Internal utilities from Microsoft.VisualBasic.FileIO.FileSystem.
-    ''' </summary>
-    Friend NotInheritable Class FileSystemUtils
-
-        ''' <summary>
-        ''' Normalize the path, but throw exception if the path ends with separator.
-        ''' </summary>
-        ''' <param name="Path">The input path.</param>
-        ''' <param name="ParamName">The parameter name to include in the exception if one is raised.</param>
-        ''' <returns>The normalized path.</returns>
-        Friend Shared Function NormalizeFilePath(Path As String, ParamName As String) As String
-            CheckFilePathTrailingSeparator(Path, ParamName)
-            Return NormalizePath(Path)
-        End Function
-
-        ''' <summary>
-        ''' Get full path, get long format, and remove any pending separator.
-        ''' </summary>
-        ''' <param name="Path">The path to be normalized.</param>
-        ''' <returns>The normalized path.</returns>
-        ''' <exception cref="IO.Path.GetFullPath">See IO.Path.GetFullPath for possible exceptions.</exception>
-        ''' <remarks>Keep this function since we might change the implementation / behavior later.</remarks>
-        Friend Shared Function NormalizePath(Path As String) As String
-            Return GetLongPath(RemoveEndingSeparator(IO.Path.GetFullPath(Path)))
-        End Function
-
-        ''' <summary>
-        ''' Throw ArgumentException if the file path ends with a separator.
-        ''' </summary>
-        ''' <param name="path">The file path.</param>
-        ''' <param name="paramName">The parameter name to include in ArgumentException.</param>
-        Friend Shared Sub CheckFilePathTrailingSeparator(path As String, paramName As String)
-            If String.IsNullOrEmpty(path) Then ' Check for argument null
-                Throw ExUtils.GetArgumentNullException(paramName)
-            End If
-            If path.EndsWith(IO.Path.DirectorySeparatorChar, StringComparison.Ordinal) Or
-                path.EndsWith(IO.Path.AltDirectorySeparatorChar, StringComparison.Ordinal) Then
-                Throw ExUtils.GetArgumentExceptionWithArgName(paramName, SR.IO_FilePathException)
-            End If
-        End Sub
-
-        ''' <summary>
-        '''  Returns the given path in long format (v.s 8.3 format) if the path exists.
-        ''' </summary>
-        ''' <param name="FullPath">The path to resolve to long format.</param>
-        ''' <returns>The given path in long format if the path exists.</returns>
-        ''' <remarks>
-        '''  GetLongPathName is a PInvoke call and requires unmanaged code permission.
-        '''  Use DirectoryInfo.GetFiles and GetDirectories (which call FindFirstFile) so that we always have permission.
-        '''</remarks>
-        Private Shared Function GetLongPath(FullPath As String) As String
-            Debug.Assert(Not String.IsNullOrEmpty(FullPath) AndAlso IO.Path.IsPathRooted(FullPath), "Must be full path")
-            Try
-                ' If root path, return itself. UNC path do not recognize 8.3 format in root path, so this is fine.
-                If IsRoot(FullPath) Then
-                    Return FullPath
-                End If
-
-                ' DirectoryInfo.GetFiles and GetDirectories call FindFirstFile which resolves 8.3 path.
-                ' Get the DirectoryInfo (user must have code permission or access permission).
-                Dim DInfo As New IO.DirectoryInfo(FileIO.FileSystem.GetParentPath(FullPath))
-
-                If IO.File.Exists(FullPath) Then
-                    Debug.Assert(DInfo.GetFiles(IO.Path.GetFileName(FullPath)).Length = 1, "Must found exactly 1")
-                    Return DInfo.GetFiles(IO.Path.GetFileName(FullPath))(0).FullName
-                ElseIf IO.Directory.Exists(FullPath) Then
-                    Debug.Assert(DInfo.GetDirectories(IO.Path.GetFileName(FullPath)).Length = 1,
-                                 "Must found exactly 1")
-                    Return DInfo.GetDirectories(IO.Path.GetFileName(FullPath))(0).FullName
-                Else
-                    Return FullPath ' Path does not exist, cannot resolve.
-                End If
-            Catch ex As Exception
-                ' Ignore these type of exceptions and return FullPath. These type of exceptions should either be caught by calling functions
-                ' or indicate that caller does not have enough permission and should get back the 8.3 path.
-                If TypeOf ex Is ArgumentException OrElse
-                    TypeOf ex Is ArgumentNullException OrElse
-                    TypeOf ex Is IO.PathTooLongException OrElse
-                    TypeOf ex Is NotSupportedException OrElse
-                    TypeOf ex Is IO.DirectoryNotFoundException OrElse
-                    TypeOf ex Is SecurityException OrElse
-                    TypeOf ex Is UnauthorizedAccessException Then
-
-                    Debug.Assert(Not (TypeOf ex Is ArgumentException OrElse
-                        TypeOf ex Is ArgumentNullException OrElse
-                        TypeOf ex Is IO.PathTooLongException OrElse
-                        TypeOf ex Is NotSupportedException), "These exceptions should be caught above")
-
-                    Return FullPath
-                Else
-                    Throw
-                End If
-            End Try
-        End Function
-
-        ''' <summary>
-        ''' Checks if the full path is a root path.
-        ''' </summary>
-        ''' <param name="Path">The path to check.</param>
-        ''' <returns>True if FullPath is a root path, False otherwise.</returns>
-        ''' <remarks>
-        '''   IO.Path.GetPathRoot: C: -> C:, C:\ -> C:\, \\machine\share -> \\machine\share,
-        '''           BUT \\machine\share\ -> \\machine\share (No separator here).
-        '''   Therefore, remove any separators at the end to have correct result.
-        ''' </remarks>
-        Private Shared Function IsRoot(Path As String) As Boolean
-            ' This function accepts a relative path since GetParentPath will call this,
-            ' and GetParentPath accept relative paths.
-            If Not IO.Path.IsPathRooted(Path) Then
-                Return False
-            End If
-
-            Path = Path.TrimEnd(IO.Path.DirectorySeparatorChar, IO.Path.AltDirectorySeparatorChar)
-            Return String.Equals(Path, IO.Path.GetPathRoot(Path),
-                    StringComparison.OrdinalIgnoreCase)
-        End Function
-
-        ''' <summary>
-        ''' Removes all directory separators at the end of a path.
-        ''' </summary>
-        ''' <param name="Path">a full or relative path.</param>
-        ''' <returns>If Path is a root path, the same value. Otherwise, removes any directory separators at the end.</returns>
-        ''' <remarks>We decided not to return path with separators at the end.</remarks>
-        Private Shared Function RemoveEndingSeparator(Path As String) As String
-            If IO.Path.IsPathRooted(Path) Then
-                ' If the path is rooted, attempt to check if it is a root path.
-                ' Note: IO.Path.GetPathRoot: C: -> C:, C:\ -> C:\, \\myshare\mydir -> \\myshare\mydir
-                ' BUT \\myshare\mydir\ -> \\myshare\mydir!!! This function will remove the ending separator of
-                ' \\myshare\mydir\ as well. Do not use IsRoot here.
-                If Path.Equals(IO.Path.GetPathRoot(Path), StringComparison.OrdinalIgnoreCase) Then
-                    Return Path
-                End If
-            End If
-
-            ' Otherwise, remove all separators at the end.
-            Return Path.TrimEnd(IO.Path.DirectorySeparatorChar, IO.Path.AltDirectorySeparatorChar)
-        End Function
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/Hosting.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/Hosting.vb
deleted file mode 100644
index 50af821b5cd..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/Hosting.vb
+++ /dev/null
@@ -1,33 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    <ComponentModel.EditorBrowsable(ComponentModel.EditorBrowsableState.Never)>
-    Public Interface IVbHost
-        Function GetParentWindow() As System.Windows.Forms.IWin32Window
-        Function GetWindowTitle() As String
-    End Interface
-
-    <ComponentModel.EditorBrowsable(ComponentModel.EditorBrowsableState.Never)>
-    Public NotInheritable Class HostServices
-
-#Disable Warning IDE0032 ' Use auto property, Justification:=<Public API>
-        Private Shared s_host As IVbHost
-#Enable Warning IDE0032 ' Use auto property
-
-        Public Shared Property VBHost() As IVbHost
-            Get
-                Return s_host
-            End Get
-
-            Set(Value As IVbHost)
-                s_host = Value
-            End Set
-        End Property
-
-    End Class
-
-End Namespace
-
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeMethods.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeMethods.vb
deleted file mode 100644
index 7c9780356c0..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeMethods.vb
+++ /dev/null
@@ -1,147 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.Runtime.InteropServices
-Imports System.Text
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    <ComVisible(False)>
-    Friend NotInheritable Class NativeMethods
-
-        <PreserveSig()>
-        Friend Declare Auto Function _
-            WaitForInputIdle _
-                Lib "user32" (Process As NativeTypes.LateInitSafeHandleZeroOrMinusOneIsInvalid, Milliseconds As Integer) As Integer
-
-        <PreserveSig()>
-        Friend Declare Function _
-            GetWindow _
-                Lib "user32" (hwnd As IntPtr, wFlag As Integer) As IntPtr
-
-        <PreserveSig()>
-        Friend Declare Function _
-            GetDesktopWindow _
-                Lib "user32" () As IntPtr
-
-#Disable Warning CA1838 ' Avoid 'StringBuilder' parameters for P/Invokes
-        <DllImport("user32", CharSet:=CharSet.Auto, PreserveSig:=True, SetLastError:=True)>
-        Friend Shared Function GetWindowText(hWnd As IntPtr, <Out(), MarshalAs(UnmanagedType.LPTStr)> lpString As StringBuilder, nMaxCount As Integer) As Integer
-#Enable Warning CA1838 ' Avoid 'StringBuilder' parameters for P/Invokes
-        End Function
-
-        <PreserveSig()>
-        Friend Declare Function _
-            AttachThreadInput _
-                Lib "user32" (idAttach As Integer, idAttachTo As Integer, fAttach As Integer) As Integer
-
-        <PreserveSig()>
-        Friend Declare Function _
-            SetForegroundWindow _
-                Lib "user32" (hwnd As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
-
-        <PreserveSig()>
-        Friend Declare Function _
-            SetFocus _
-                Lib "user32" (hwnd As IntPtr) As IntPtr
-
-        <PreserveSig()>
-        Friend Declare Auto Function _
-            FindWindow _
-                Lib "user32" (lpClassName As String, lpWindowName As String) As IntPtr
-
-        <PreserveSig()>
-        Friend Declare Function _
-            CloseHandle _
-                Lib "kernel32" (hObject As IntPtr) As Integer
-
-        <PreserveSig()>
-        Friend Declare Function _
-            WaitForSingleObject _
-                Lib "kernel32" (hHandle As NativeTypes.LateInitSafeHandleZeroOrMinusOneIsInvalid, dwMilliseconds As Integer) As Integer
-
-        <DllImport(
-             "kernel32",
-             CharSet:=CharSet.Auto,
-             PreserveSig:=True,
-             BestFitMapping:=False,
-             ThrowOnUnmappableChar:=True)>
-        Friend Shared Sub GetStartupInfo(<[In](), Out()> lpStartupInfo As NativeTypes.STARTUPINFO)
-        End Sub
-
-        <DllImport(
-             "kernel32",
-             CharSet:=CharSet.Auto,
-             PreserveSig:=True,
-             BestFitMapping:=False,
-             ThrowOnUnmappableChar:=True)>
-        Friend Shared Function CreateProcess(
-            lpApplicationName As String,
-            lpCommandLine As String,
-            lpProcessAttributes As NativeTypes.SECURITY_ATTRIBUTES,
-            lpThreadAttributes As NativeTypes.SECURITY_ATTRIBUTES,
-            <MarshalAs(UnmanagedType.Bool)> bInheritHandles As Boolean,
-            dwCreationFlags As Integer,
-            lpEnvironment As IntPtr,
-            lpCurrentDirectory As String,
-            lpStartupInfo As NativeTypes.STARTUPINFO,
-            lpProcessInformation As NativeTypes.PROCESS_INFORMATION) As Integer
-        End Function
-
-#Disable Warning IDE0049 ' Simplify Names, Justification:=<Types come from Windows Native API>
-#Disable Warning IDE1006 ' Naming Styles, Justification:=<Names come from Windows Native API>
-        ''' <summary>
-        ''' Contains information about the current state of both physical and virtual memory, including extended memory.
-        ''' </summary>
-        <StructLayout(LayoutKind.Sequential)>
-        Friend Structure MEMORYSTATUSEX
-            'typedef struct _MEMORYSTATUSEX {
-            '   DWORD dwLength;                     Size of the structure. Must set before calling GlobalMemoryStatusEx.
-            '   DWORD dwMemoryLoad;                 Number between 0 and 100 on current memory utilization.
-            '   DWORDLONG ullTotalPhys;             Total size of physical memory.
-            '   DWORDLONG ullAvailPhys;             Total size of available physical memory.
-            '   DWORDLONG ullTotalPageFile;         Size of committed memory limit.
-            '   DWORDLONG ullAvailPageFile;         Size of available memory to committed (ullTotalPageFile max).
-            '   DWORDLONG ullTotalVirtual;          Total size of user potion of virtual address space of calling process.
-            '   DWORDLONG ullAvailVirtual;          Total size of unreserved and uncommitted memory in virtual address space.
-            '   DWORDLONG ullAvailExtendedVirtual;  Total size of unreserved and uncommitted memory in extended portion of virtual address.
-            '} MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
-
-            Friend dwLength As UInt32
-            Friend dwMemoryLoad As UInt32
-            Friend ullTotalPhys As UInt64
-            Friend ullAvailPhys As UInt64
-            Friend ullTotalPageFile As UInt64
-            Friend ullAvailPageFile As UInt64
-            Friend ullTotalVirtual As UInt64
-            Friend ullAvailVirtual As UInt64
-            Friend ullAvailExtendedVirtual As UInt64
-#Enable Warning IDE1006 ' Naming Styles
-
-            Friend Sub Init()
-                dwLength = CType(Marshal.SizeOf(GetType(MEMORYSTATUSEX)), UInt32)
-            End Sub
-        End Structure
-#Enable Warning IDE0049 ' Simplify Names
-
-        ''' <summary>
-        ''' Obtains information about the system's current usage of both physical and virtual memory.
-        ''' </summary>
-        ''' <param name="lpBuffer">Pointer to a MEMORYSTATUSEX structure.</param>
-        ''' <returns>True if the function succeeds. Otherwise, False.</returns>
-        <DllImport("Kernel32.dll", CharSet:=CharSet.Auto, SetLastError:=True)>
-        Friend Shared Function GlobalMemoryStatusEx(ByRef lpBuffer As MEMORYSTATUSEX) As <MarshalAs(UnmanagedType.Bool)> Boolean
-        End Function
-
-        ''' <summary>
-        ''' Adding a private constructor to prevent the compiler from generating a default constructor.
-        ''' </summary>
-        Private Sub New()
-        End Sub
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeTypes.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeTypes.vb
deleted file mode 100644
index f5986f5564b..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/NativeTypes.vb
+++ /dev/null
@@ -1,178 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Runtime.InteropServices
-Imports Microsoft.Win32.SafeHandles
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    <ComponentModel.EditorBrowsable(ComponentModel.EditorBrowsableState.Never)>
-    Friend NotInheritable Class NativeTypes
-
-#Disable Warning CA1812 ' Supress warning as this is a type used in PInvoke and shouldn't be changed.
-        <StructLayout(LayoutKind.Sequential)>
-        Friend NotInheritable Class SECURITY_ATTRIBUTES
-#Enable Warning CA1812
-            Implements IDisposable
-
-            Friend Sub New()
-                nLength = Marshal.SizeOf(GetType(SECURITY_ATTRIBUTES))
-            End Sub
-
-            Public nLength As Integer
-            Public lpSecurityDescriptor As IntPtr
-            Public bInheritHandle As Boolean
-
-            Public Overloads Sub Dispose() Implements IDisposable.Dispose
-                If lpSecurityDescriptor <> IntPtr.Zero Then
-                    UnsafeNativeMethods.LocalFree(lpSecurityDescriptor)
-                    lpSecurityDescriptor = IntPtr.Zero
-                End If
-                GC.SuppressFinalize(Me)
-            End Sub
-
-            Protected Overrides Sub Finalize()
-                Dispose()
-                MyBase.Finalize()
-            End Sub
-        End Class
-
-        ''' <summary>
-        ''' Inherits SafeHandleZeroOrMinusOneIsInvalid, with additional InitialSetHandle method.
-        ''' This is required because call to constructor of SafeHandle is not allowed in constrained region.
-        ''' </summary>
-        Friend NotInheritable Class LateInitSafeHandleZeroOrMinusOneIsInvalid
-            Inherits SafeHandleZeroOrMinusOneIsInvalid
-
-            Friend Sub New()
-                MyBase.New(True)
-            End Sub
-
-            Friend Sub InitialSetHandle(h As IntPtr)
-                Debug.Assert(MyBase.IsInvalid, "Safe handle should only be set once.")
-                MyBase.SetHandle(h)
-            End Sub
-
-            Protected Overrides Function ReleaseHandle() As Boolean
-                Return NativeMethods.CloseHandle(handle) <> 0
-            End Function
-        End Class
-
-        ''' <summary>
-        ''' Represent Win32 PROCESS_INFORMATION structure. IMPORTANT: Copy the handles to a SafeHandle before use them.
-        ''' </summary>
-        ''' <remarks>
-        ''' The handles in PROCESS_INFORMATION are initialized in unmanaged function.
-        ''' We can't use SafeHandle here because Interop doesn't support [out] SafeHandles in structure / classes yet.
-        ''' This class makes no attempt to free the handles. To use the handle, first copy it to a SafeHandle class
-        ''' (using LateInitSafeHandleZeroOrMinusOneIsInvalid.InitialSetHandle) to correctly use and dispose the handle.
-        ''' </remarks>
-        <StructLayout(LayoutKind.Sequential)>
-        Friend NotInheritable Class PROCESS_INFORMATION
-            Public hProcess As IntPtr = IntPtr.Zero
-            Public hThread As IntPtr = IntPtr.Zero
-            Public dwProcessId As Integer
-            Public dwThreadId As Integer
-
-            Friend Sub New()
-            End Sub
-        End Class
-
-        ''' <summary>
-        ''' Important!  This class should be used where the API being called has allocated the strings.  That is why lpReserved, etc. are declared as IntPtrs instead
-        ''' of Strings - so that the marshaling layer won't release the memory.  This caused us problems in the shell() functions.  We would call GetStartupInfo()
-        ''' which doesn't expect the memory for the strings to be freed.  But because the strings were previously defined as type String, the marshaller would
-        ''' and we got memory corruption problems detectable while running AppVerifier.
-        ''' If you use this structure with an API like CreateProcess() then you are supplying the strings so you'll need another version of this class that defines lpReserved, etc.
-        ''' as String so that the memory will get cleaned up.
-        ''' </summary>
-        <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Auto)>
-        Friend NotInheritable Class STARTUPINFO
-            Implements IDisposable
-
-            Public cb As Integer
-            Public lpReserved As IntPtr = IntPtr.Zero 'not string - see summary
-            Public lpDesktop As IntPtr = IntPtr.Zero 'not string - see summary
-            Public lpTitle As IntPtr = IntPtr.Zero 'not string - see summary
-            Public dwX As Integer
-            Public dwY As Integer
-            Public dwXSize As Integer
-            Public dwYSize As Integer
-            Public dwXCountChars As Integer
-            Public dwYCountChars As Integer
-            Public dwFillAttribute As Integer
-            Public dwFlags As Integer
-            Public wShowWindow As Short
-            Public cbReserved2 As Short
-            Public lpReserved2 As IntPtr = IntPtr.Zero
-            Public hStdInput As IntPtr = IntPtr.Zero
-            Public hStdOutput As IntPtr = IntPtr.Zero
-            Public hStdError As IntPtr = IntPtr.Zero
-
-            Friend Sub New()
-            End Sub
-
-            Private _hasBeenDisposed As Boolean ' To detect redundant calls. Default initialize = False.
-
-            Protected Overrides Sub Finalize()
-                Dispose(False)
-            End Sub
-
-            ' IDisposable
-            Private Sub Dispose(disposing As Boolean)
-                If Not _hasBeenDisposed Then
-                    If disposing Then
-                        _hasBeenDisposed = True
-
-                        Const STARTF_USESTDHANDLES As Integer = 256 'Defined in windows.h
-                        If (dwFlags And STARTF_USESTDHANDLES) <> 0 Then
-                            If hStdInput <> IntPtr.Zero AndAlso hStdInput <> s_invalidHandle Then
-                                NativeMethods.CloseHandle(hStdInput)
-                                hStdInput = s_invalidHandle
-                            End If
-
-                            If hStdOutput <> IntPtr.Zero AndAlso hStdOutput <> s_invalidHandle Then
-                                NativeMethods.CloseHandle(hStdOutput)
-                                hStdOutput = s_invalidHandle
-                            End If
-
-                            If hStdError <> IntPtr.Zero AndAlso hStdError <> s_invalidHandle Then
-                                NativeMethods.CloseHandle(hStdError)
-                                hStdError = s_invalidHandle
-                            End If
-                        End If 'Me.dwFlags and STARTF_USESTDHANDLES
-
-                    End If
-                End If
-            End Sub
-
-            ' This code correctly implements the disposable pattern.
-            Friend Sub Dispose() Implements IDisposable.Dispose
-                ' Do not change this code.  Put cleanup code in Dispose(disposing As Boolean) above.
-                Dispose(True)
-                GC.SuppressFinalize(Me)
-            End Sub
-        End Class
-
-        ' Handle Values
-        Friend Shared ReadOnly s_invalidHandle As IntPtr = New IntPtr(-1)
-
-        ' GetWindow() Constants
-        Friend Const GW_HWNDFIRST As Integer = 0
-        Friend Const GW_HWNDLAST As Integer = 1
-        Friend Const GW_HWNDNEXT As Integer = 2
-        Friend Const GW_HWNDPREV As Integer = 3
-        Friend Const GW_OWNER As Integer = 4
-        Friend Const GW_CHILD As Integer = 5
-        Friend Const GW_MAX As Integer = 5
-
-        Friend Const STARTF_USESHOWWINDOW As Integer = 1
-
-        Friend Const NORMAL_PRIORITY_CLASS As Integer = &H20
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/SafeNativeMethods.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/SafeNativeMethods.vb
deleted file mode 100644
index e9445f00f5e..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/SafeNativeMethods.vb
+++ /dev/null
@@ -1,33 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Runtime.InteropServices
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    <ComponentModel.EditorBrowsable(ComponentModel.EditorBrowsableState.Never)>
-    <ComVisible(False)>
-    Friend NotInheritable Class _
-        SafeNativeMethods
-
-        <PreserveSig()> Friend Declare Function _
-            IsWindowEnabled _
-                Lib "user32" (hwnd As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
-
-        <PreserveSig()> Friend Declare Function _
-            IsWindowVisible _
-                Lib "user32" (hwnd As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
-
-        <PreserveSig()> Friend Declare Function _
-            GetWindowThreadProcessId _
-                Lib "user32" (hwnd As IntPtr, ByRef lpdwProcessId As Integer) As Integer
-
-        ''' <summary>
-        ''' Adding a private constructor to prevent the compiler from generating a default constructor.
-        ''' </summary>
-        Private Sub New()
-        End Sub
-    End Class
-
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/UnsafeNativeMethods.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/UnsafeNativeMethods.vb
deleted file mode 100644
index c1eee7c5e2f..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/UnsafeNativeMethods.vb
+++ /dev/null
@@ -1,50 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Runtime.InteropServices
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    <ComVisible(False)>
-    Friend NotInheritable Class UnsafeNativeMethods
-
-        ''' <summary>
-        ''' Gets the state of the specified key on the keyboard when the function
-        ''' is called.
-        ''' </summary>
-        ''' <param name="KeyCode">Integer representing the key in question.</param>
-        ''' <returns>
-        ''' The high order byte is 1 if the key is down. The low order byte is one
-        ''' if the key is toggled on (i.e. for keys like CapsLock)
-        ''' </returns>
-        <DllImport("User32.dll", ExactSpelling:=True, CharSet:=CharSet.Auto)>
-        Friend Shared Function GetKeyState(KeyCode As Integer) As Short
-        End Function
-
-        ''' <summary>
-        ''' Frees memory allocated from the local heap. i.e. frees memory allocated
-        ''' by LocalAlloc or LocalReAlloc.
-        ''' </summary>
-        <DllImport("kernel32", ExactSpelling:=True, SetLastError:=True)>
-        Friend Shared Function LocalFree(LocalHandle As IntPtr) As IntPtr
-        End Function
-
-        ''' <summary>
-        ''' Used to determine how much free space is on a disk
-        ''' </summary>
-        ''' <param name="Directory">Path including drive we're getting information about</param>
-        ''' <param name="UserSpaceFree">The amount of free space available to the current user</param>
-        ''' <param name="TotalUserSpace">The total amount of space on the disk relative to the current user</param>
-        ''' <param name="TotalFreeSpace">The amount of free spave on the disk.</param>
-        ''' <returns>True if function succeeds in getting info otherwise False</returns>
-        <DllImport("Kernel32.dll", CharSet:=CharSet.Auto, BestFitMapping:=False, SetLastError:=True)>
-        Friend Shared Function GetDiskFreeSpaceEx(Directory As String, ByRef UserSpaceFree As Long, ByRef TotalUserSpace As Long, ByRef TotalFreeSpace As Long) As <MarshalAs(UnmanagedType.Bool)> Boolean
-        End Function
-
-        ''' <summary>
-        ''' Adding a private constructor to prevent the compiler from generating a default constructor.
-        ''' </summary>
-        Private Sub New()
-        End Sub
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/VBInputBox.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/VBInputBox.vb
deleted file mode 100644
index 62fb8bbb7e2..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Helpers/VBInputBox.vb
+++ /dev/null
@@ -1,131 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.ComponentModel
-Imports System.Drawing
-Imports System.Globalization
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.CompilerServices
-
-    Friend NotInheritable Class VBInputBox
-        Inherits Form
-
-#Disable Warning IDE1006 ' Naming Styles, Justification:=<VBInputBox.resx depends on these names>
-        Private ReadOnly components As Container
-        Private TextBox As TextBox
-        Private Label As Label
-        Private OKButton As Button
-        Private MyCancelButton As Button
-#Enable Warning IDE1006 ' Naming Styles
-        Public Output As String = ""
-
-        'This constructor needed to be able to show the designer at design-time.
-        Friend Sub New()
-            MyBase.New()
-            InitializeComponent()
-        End Sub
-
-        Friend Sub New(Prompt As String, Title As String, DefaultResponse As String, XPos As Integer, YPos As Integer)
-            MyBase.New()
-            InitializeComponent()
-            InitializeInputBox(Prompt, Title, DefaultResponse, XPos, YPos)
-        End Sub
-
-        Protected Overloads Overrides Sub Dispose(disposing As Boolean)
-            If disposing Then
-                components?.Dispose()
-            End If
-            MyBase.Dispose(disposing)
-        End Sub
-
-        Private Sub InitializeComponent()
-            Dim resources As ComponentResourceManager = New ComponentResourceManager(GetType(VBInputBox))
-            OKButton = New Button
-            MyCancelButton = New Button
-            TextBox = New TextBox
-            Label = New Label
-            SuspendLayout()
-            '
-            'OKButton
-            '
-            resources.ApplyResources(OKButton, "OKButton", CultureInfo.CurrentUICulture)
-            OKButton.Name = "OKButton"
-            '
-            'MyCancelButton
-            '
-            MyCancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel
-            resources.ApplyResources(MyCancelButton, "MyCancelButton", CultureInfo.CurrentUICulture)
-            MyCancelButton.Name = "MyCancelButton"
-            '
-            'TextBox
-            '
-            resources.ApplyResources(TextBox, "TextBox", CultureInfo.CurrentUICulture)
-            TextBox.Name = "TextBox"
-            '
-            'Label
-            '
-            resources.ApplyResources(Label, "Label", CultureInfo.CurrentUICulture)
-            Label.Name = "Label"
-            '
-            'VBInputBox
-            '
-            AcceptButton = OKButton
-            resources.ApplyResources(Me, "$this", CultureInfo.CurrentUICulture)
-            CancelButton = MyCancelButton
-            Controls.Add(TextBox)
-            Controls.Add(Label)
-            Controls.Add(OKButton)
-            Controls.Add(MyCancelButton)
-            FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog
-            MaximizeBox = False
-            MinimizeBox = False
-            Name = "VBInputBox"
-            ResumeLayout(False)
-            PerformLayout()
-
-        End Sub
-
-        'Initialize labels etc from the args passed in to InputBox()
-        Private Sub InitializeInputBox(Prompt As String, Title As String, DefaultResponse As String, XPos As Integer, YPos As Integer)
-            Text = Title
-            Label.Text = Prompt
-            TextBox.Text = DefaultResponse
-            AddHandler OKButton.Click, AddressOf OKButton_Click
-            AddHandler MyCancelButton.Click, AddressOf MyCancelButton_Click
-
-            'Re-size the dialog if the prompt is too large
-            Dim LabelGraphics As Graphics = Label.CreateGraphics
-            Dim LabelSizeNeeded As SizeF = LabelGraphics.MeasureString(Prompt, Label.Font, Label.Width)
-            LabelGraphics.Dispose()
-            If LabelSizeNeeded.Height > Label.Height Then
-                'The current label size is not large enough to accommodate the prompt.  We need
-                '  to expand the label and the dialog, and move the textbox to make room.
-                Dim DialogHeightChange As Integer = CInt(LabelSizeNeeded.Height) - Label.Height
-                Label.Height += DialogHeightChange
-                TextBox.Top += DialogHeightChange
-                Height += DialogHeightChange
-            End If
-
-            'Position the form
-            If (XPos = -1) AndAlso (YPos = -1) Then
-                StartPosition = FormStartPosition.CenterScreen
-            Else
-                If (XPos = -1) Then XPos = 600
-                If (YPos = -1) Then YPos = 350
-                StartPosition = FormStartPosition.Manual
-                DesktopLocation = New Point(XPos, YPos)
-            End If
-        End Sub
-
-        Private Sub OKButton_Click(sender As Object, e As EventArgs)
-            Output = TextBox.Text
-            Close()
-        End Sub
-
-        Private Sub MyCancelButton_Click(sender As Object, e As EventArgs)
-            Close()
-        End Sub
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Interaction.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Interaction.vb
deleted file mode 100644
index 8d958ecc515..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Interaction.vb
+++ /dev/null
@@ -1,418 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Runtime.InteropServices
-Imports System.Security
-Imports System.Text
-Imports System.Threading
-Imports System.Windows.Forms
-Imports Microsoft.VisualBasic.CompilerServices
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic
-
-    ' Helper methods invoked through reflection from Microsoft.VisualBasic.Interaction in Microsoft.VisualBasic.Core.dll. 
-    ' Do not change this API without also updating that dependent module.
-    Friend Module _Interaction
-
-        Public Function Shell(PathName As String, Style As AppWinStyle, Wait As Boolean, Timeout As Integer) As Integer
-            Dim StartupInfo As New NativeTypes.STARTUPINFO
-            Dim ProcessInfo As New NativeTypes.PROCESS_INFORMATION
-            Dim ok As Integer
-            Dim safeProcessHandle As New NativeTypes.LateInitSafeHandleZeroOrMinusOneIsInvalid()
-            Dim safeThreadHandle As New NativeTypes.LateInitSafeHandleZeroOrMinusOneIsInvalid()
-            Dim ErrorCode As Integer = 0
-
-            If (PathName Is Nothing) Then
-                Throw New NullReferenceException(GetResourceString(SR.Argument_InvalidNullValue1, "Pathname"))
-            End If
-
-            If (Style < 0 OrElse Style > 9) Then
-                Throw New ArgumentException(GetResourceString(SR.Argument_InvalidValue1, "Style"))
-            End If
-
-            NativeMethods.GetStartupInfo(StartupInfo)
-            Try
-                StartupInfo.dwFlags = NativeTypes.STARTF_USESHOWWINDOW  ' we want to specify the initial window style (minimized, etc) so set this bit.
-                StartupInfo.wShowWindow = Style
-
-                'We have to have unmanaged permissions to do this, so asking for path permissions would be redundant
-                'Note: We are using the StartupInfo (defined in NativeTypes.StartupInfo) in CreateProcess() even though this version
-                'of the StartupInfo type uses IntPtr instead of String because GetStartupInfo() above requires that version so we don't
-                'free the string fields since the API manages it instead.  But its OK here because we are just passing along the memory
-                'that GetStartupInfo() allocated along to CreateProcess() which just reads the string fields.
-
-                ok = NativeMethods.CreateProcess(Nothing, PathName, Nothing, Nothing, False, NativeTypes.NORMAL_PRIORITY_CLASS, Nothing, Nothing, StartupInfo, ProcessInfo)
-                If ok = 0 Then
-                    ErrorCode = Marshal.GetLastWin32Error()
-                End If
-                If ProcessInfo.hProcess <> IntPtr.Zero AndAlso ProcessInfo.hProcess <> NativeTypes.s_invalidHandle Then
-                    safeProcessHandle.InitialSetHandle(ProcessInfo.hProcess)
-                End If
-                If ProcessInfo.hThread <> IntPtr.Zero AndAlso ProcessInfo.hThread <> NativeTypes.s_invalidHandle Then
-                    safeThreadHandle.InitialSetHandle(ProcessInfo.hThread)
-                End If
-
-                Try
-                    If (ok <> 0) Then
-                        If Wait Then
-                            ' Is infinite wait okay here ?
-                            ' This is okay since this is marked as requiring the HostPermission with ExternalProcessMgmt rights
-                            ok = NativeMethods.WaitForSingleObject(safeProcessHandle, Timeout)
-
-                            If ok = 0 Then 'succeeded
-                                'Process ran to completion
-                                Shell = 0
-                            Else
-                                'Wait timed out
-                                Shell = ProcessInfo.dwProcessId
-                            End If
-                        Else
-                            NativeMethods.WaitForInputIdle(safeProcessHandle, 10000)
-                            Shell = ProcessInfo.dwProcessId
-                        End If
-                    Else
-                        'Check for a win32 error access denied. If it is, make and throw the exception.
-                        'If not, throw FileNotFound
-                        Const ERROR_ACCESS_DENIED As Integer = 5
-                        If ErrorCode = ERROR_ACCESS_DENIED Then
-                            Throw VbMakeException(vbErrors.PermissionDenied)
-                        End If
-
-                        Throw VbMakeException(vbErrors.FileNotFound)
-                    End If
-                Finally
-                    safeProcessHandle.Close() ' Close the process handle will not cause the process to stop.
-                    safeThreadHandle.Close()
-                End Try
-            Finally
-                StartupInfo.Dispose()
-            End Try
-        End Function
-
-        Public Sub AppActivateByProcessId(ProcessId As Integer)
-            'As an optimization, we will only check the UI permission once we actually know we found the app to activate - we'll do that in AppActivateHelper
-
-            Dim ProcessIdOwningWindow As Integer
-            'Note, a process can have multiple windows.  What we want to do is dig through to find one
-            'that we can actually activate.  So first ignore all the ones that are not visible and don't support mouse
-            'or keyboard input
-            Dim WindowHandle As IntPtr = NativeMethods.GetWindow(NativeMethods.GetDesktopWindow(), NativeTypes.GW_CHILD)
-
-            Do While (IntPtr.op_Inequality(WindowHandle, IntPtr.Zero))
-                SafeNativeMethods.GetWindowThreadProcessId(WindowHandle, ProcessIdOwningWindow)
-                If (ProcessIdOwningWindow = ProcessId) AndAlso SafeNativeMethods.IsWindowEnabled(WindowHandle) AndAlso SafeNativeMethods.IsWindowVisible(WindowHandle) Then
-                    Exit Do 'We found a window belonging to the desired process that we can actually activate and will support user input
-                End If
-
-                'keep rummaging through windows looking for one that belongs to the process we are after
-                WindowHandle = NativeMethods.GetWindow(WindowHandle, NativeTypes.GW_HWNDNEXT)
-            Loop
-
-            'If we didn't find a window during the pass above, try the less desirable route of finding any window that belongs to the process
-            If IntPtr.op_Equality(WindowHandle, IntPtr.Zero) Then
-                WindowHandle = NativeMethods.GetWindow(NativeMethods.GetDesktopWindow(), NativeTypes.GW_CHILD)
-
-                Do While IntPtr.op_Inequality(WindowHandle, IntPtr.Zero)
-                    SafeNativeMethods.GetWindowThreadProcessId(WindowHandle, ProcessIdOwningWindow)
-                    If (ProcessIdOwningWindow = ProcessId) Then
-                        Exit Do
-                    End If
-
-                    'keep rummaging through windows looking for one that belongs to the process we are after
-                    WindowHandle = NativeMethods.GetWindow(WindowHandle, NativeTypes.GW_HWNDNEXT)
-                Loop
-            End If
-
-            If IntPtr.op_Equality(WindowHandle, IntPtr.Zero) Then 'we never found a window belonging to the desired process
-                Throw New ArgumentException(GetResourceString(SR.ProcessNotFound, CStr(ProcessId)))
-            Else
-                AppActivateHelper(WindowHandle, CStr(ProcessId))
-            End If
-        End Sub
-
-        Public Sub AppActivateByTitle(Title As String)
-            'As an optimization, we will only check the UI permission once we actually know we found the app to activate - we'll do that in AppActivateHelper
-            Dim WindowHandle As IntPtr = NativeMethods.FindWindow(Nothing, Title) 'see if we can find the window using an exact match on the title
-            Const MAX_TITLE_LENGTH As Integer = 511
-
-            '  if no match, search through all parent windows
-            If IntPtr.op_Equality(WindowHandle, IntPtr.Zero) Then
-                Dim AppTitle As String
-                ' Old implementation uses MAX_TITLE_LENGTH characters, INCLUDING NULL character.
-                ' Interop code will extend string builder to handle NULL character.
-                Dim AppTitleBuilder As New StringBuilder(MAX_TITLE_LENGTH)
-                Dim AppTitleLength As Integer
-                Dim TitleLength As Integer = Len(Title)
-
-                'Loop through all children of the desktop
-                WindowHandle = NativeMethods.GetWindow(NativeMethods.GetDesktopWindow(), NativeTypes.GW_CHILD)
-                Do While IntPtr.op_Inequality(WindowHandle, IntPtr.Zero)
-                    '  get the window caption and test for a left-aligned substring
-                    AppTitleLength = NativeMethods.GetWindowText(WindowHandle, AppTitleBuilder, AppTitleBuilder.Capacity)
-                    AppTitle = AppTitleBuilder.ToString()
-
-                    If AppTitleLength >= TitleLength Then
-                        If String.Compare(AppTitle, 0, Title, 0, TitleLength, StringComparison.OrdinalIgnoreCase) = 0 Then
-                            Exit Do 'found one
-                        End If
-                    End If
-
-                    'keep looking
-                    WindowHandle = NativeMethods.GetWindow(WindowHandle, NativeTypes.GW_HWNDNEXT)
-                Loop
-
-                If IntPtr.op_Equality(WindowHandle, IntPtr.Zero) Then
-                    ' We didn't find it so try right aligned
-                    WindowHandle = NativeMethods.GetWindow(NativeMethods.GetDesktopWindow(), NativeTypes.GW_CHILD)
-
-                    Do While IntPtr.op_Inequality(WindowHandle, IntPtr.Zero)
-                        '  get the window caption and test for a right-aligned substring
-                        AppTitleLength = NativeMethods.GetWindowText(WindowHandle, AppTitleBuilder, AppTitleBuilder.Capacity)
-                        AppTitle = AppTitleBuilder.ToString()
-
-                        If AppTitleLength >= TitleLength Then
-                            If String.Compare(Right(AppTitle, TitleLength), 0, Title, 0, TitleLength, StringComparison.OrdinalIgnoreCase) = 0 Then
-                                Exit Do 'found a match
-                            End If
-                        End If
-
-                        'keep looking
-                        WindowHandle = NativeMethods.GetWindow(WindowHandle, NativeTypes.GW_HWNDNEXT)
-                    Loop
-                End If
-            End If
-
-            If IntPtr.op_Equality(WindowHandle, IntPtr.Zero) Then 'no match
-                Throw New ArgumentException(GetResourceString(SR.ProcessNotFound, Title))
-            Else
-                AppActivateHelper(WindowHandle, Title)
-            End If
-        End Sub
-
-        Private Sub AppActivateHelper(hwndApp As IntPtr, ProcessId As String)
-            '  if no window with name (full or truncated) or task id, return an error
-            '  if the window is not enabled or not visible, get the first window owned by it that is not enabled or not visible
-            Dim hwndOwned As IntPtr
-            If (Not SafeNativeMethods.IsWindowEnabled(hwndApp) OrElse Not SafeNativeMethods.IsWindowVisible(hwndApp)) Then
-                '  scan to the next window until failure
-                hwndOwned = NativeMethods.GetWindow(hwndApp, NativeTypes.GW_HWNDFIRST)
-                Do While IntPtr.op_Inequality(hwndOwned, IntPtr.Zero)
-                    If IntPtr.op_Equality(NativeMethods.GetWindow(hwndOwned, NativeTypes.GW_OWNER), hwndApp) Then
-                        If (Not SafeNativeMethods.IsWindowEnabled(hwndOwned) OrElse Not SafeNativeMethods.IsWindowVisible(hwndOwned)) Then
-                            hwndApp = hwndOwned
-                            hwndOwned = NativeMethods.GetWindow(hwndApp, NativeTypes.GW_HWNDFIRST)
-                        Else
-                            Exit Do
-                        End If
-                    End If
-                    hwndOwned = NativeMethods.GetWindow(hwndOwned, NativeTypes.GW_HWNDNEXT)
-                Loop
-
-                '  if scan failed, return an error
-                If IntPtr.op_Equality(hwndOwned, IntPtr.Zero) Then
-                    Throw New ArgumentException(GetResourceString(SR.ProcessNotFound, ProcessId))
-                End If
-
-                '  set active window to the owned one
-                hwndApp = hwndOwned
-            End If
-
-            ' SetActiveWindow on Win32 only activates the Window - it does
-            ' not bring to to the foreground unless the window belongs to
-            ' the current thread.  NativeMethods.SetForegroundWindow() activates the
-            ' window, moves it to the foreground, and bumps the priority
-            ' of the thread which owns the window.
-
-            Dim dwDummy As Integer ' dummy arg for SafeNativeMethods.GetWindowThreadProcessId
-
-            ' Attach ourselves to the window we want to set focus to
-            NativeMethods.AttachThreadInput(0, SafeNativeMethods.GetWindowThreadProcessId(hwndApp, dwDummy), 1)
-            ' Make it foreground and give it focus, this will occur
-            ' synchronously because we are attached.
-            NativeMethods.SetForegroundWindow(hwndApp)
-            NativeMethods.SetFocus(hwndApp)
-            ' Unattached ourselves from the window
-            NativeMethods.AttachThreadInput(0, SafeNativeMethods.GetWindowThreadProcessId(hwndApp, dwDummy), 0)
-        End Sub
-
-        Private NotInheritable Class InputBoxHandler
-            Private ReadOnly _prompt As String
-            Private ReadOnly _title As String
-            Private ReadOnly _defaultResponse As String
-            Private ReadOnly _xPos As Integer
-            Private ReadOnly _yPos As Integer
-            Private _result As String
-            Private ReadOnly _parentWindow As IWin32Window
-            Private _exception As Exception
-
-            Sub New(Prompt As String, Title As String, DefaultResponse As String, XPos As Integer, YPos As Integer, ParentWindow As IWin32Window)
-                _prompt = Prompt
-                _title = Title
-                _defaultResponse = DefaultResponse
-                _xPos = XPos
-                _yPos = YPos
-                _parentWindow = ParentWindow
-            End Sub
-
-            Public Sub StartHere()
-                Try
-                    _result = InternalInputBox(_prompt, _title, _defaultResponse, _xPos, _yPos, _parentWindow)
-                Catch ex As Exception
-                    _exception = ex
-                End Try
-            End Sub
-
-            Public ReadOnly Property Result() As String
-                Get
-                    Return _result
-                End Get
-            End Property
-
-            Friend ReadOnly Property Exception As Exception
-                Get
-                    Return _exception
-                End Get
-            End Property
-        End Class
-
-        Public Function InputBox(Prompt As String, Title As String, DefaultResponse As String, XPos As Integer, YPos As Integer) As String
-            Dim vbhost As IVbHost
-            Dim ParentWindow As IWin32Window = Nothing
-
-            vbhost = CompilerServices.HostServices.VBHost
-            If vbhost IsNot Nothing Then 'If we are hosted then we want to use the host as the parent window.  If no parent window that's fine.
-                ParentWindow = vbhost.GetParentWindow()
-            End If
-
-            If String.IsNullOrEmpty(Title) Then
-                If vbhost Is Nothing Then
-                    Title = GetTitleFromAssembly(System.Reflection.Assembly.GetCallingAssembly())
-                Else
-                    Title = vbhost.GetWindowTitle()
-                End If
-            End If
-
-            'Threading state can only be set once, and will most often be already set
-            'but set to STA and check if it isn't STA, then we need to start another thread
-            'to display the InputBox
-            If System.Threading.Thread.CurrentThread.GetApartmentState() <> Threading.ApartmentState.STA Then
-                Dim InputHandler As New InputBoxHandler(Prompt, Title, DefaultResponse, XPos, YPos, ParentWindow)
-                Dim thread As New Thread(New ThreadStart(AddressOf InputHandler.StartHere))
-                thread.Start()
-                thread.Join()
-
-                If InputHandler.Exception IsNot Nothing Then
-                    Throw InputHandler.Exception
-                End If
-
-                Return InputHandler.Result
-            Else
-                Return InternalInputBox(Prompt, Title, DefaultResponse, XPos, YPos, ParentWindow)
-            End If
-        End Function
-
-        Private Function GetTitleFromAssembly(CallingAssembly As Reflection.Assembly) As String
-
-            Dim Title As String
-
-            'Get the Assembly name of the calling assembly 
-            'Assembly.GetName requires PathDiscovery permission so we try this first
-            'and if it throws we catch the security exception and parse the name
-            'from the full assembly name
-            Try
-                Title = CallingAssembly.GetName().Name
-            Catch ex As SecurityException
-                Dim FullName As String = CallingAssembly.FullName
-
-                'Find the text up to the first comma. Note, this fails if the assembly has
-                'a comma in its name
-                Dim FirstCommaLocation As Integer = FullName.IndexOf(","c)
-                If FirstCommaLocation >= 0 Then
-                    Title = FullName.Substring(0, FirstCommaLocation)
-                Else
-                    'The name is not in the format we're expecting so return an empty string
-                    Title = ""
-                End If
-            End Try
-
-            Return Title
-
-        End Function
-
-        Private Function InternalInputBox(Prompt As String, Title As String, DefaultResponse As String, XPos As Integer, YPos As Integer, ParentWindow As IWin32Window) As String
-            Dim Box As VBInputBox = New VBInputBox(Prompt, Title, DefaultResponse, XPos, YPos)
-            Box.ShowDialog(ParentWindow)
-
-            InternalInputBox = Box.Output
-            Box.Dispose()
-        End Function
-
-        Public Function MsgBox(Prompt As Object, Buttons As MsgBoxStyle, Title As Object) As MsgBoxResult
-            Dim sPrompt As String = Nothing
-            Dim sTitle As String
-            Dim vbhost As IVbHost
-            Dim ParentWindow As IWin32Window = Nothing
-
-            vbhost = CompilerServices.HostServices.VBHost
-            If vbhost IsNot Nothing Then
-                ParentWindow = vbhost.GetParentWindow()
-            End If
-
-            'Only allow legal button combinations to be set, one choice from each group
-            'These bit constants are defined in System.Windows.Forms.MessageBox
-            'Low-order 4 bits (0x000f), legal values: 0, 1, 2, 3, 4, 5
-            '     next 4 bits (0x00f0), legal values: 0, &H10, &H20, &H30, &H40
-            '     next 4 bits (0x0f00), legal values: 0, &H100, &H200
-            If ((Buttons And &HFI) > MsgBoxStyle.RetryCancel) OrElse ((Buttons And &HF0I) > MsgBoxStyle.Information) _
-                OrElse ((Buttons And &HF00I) > MsgBoxStyle.DefaultButton3) Then
-                Buttons = MsgBoxStyle.OkOnly
-            End If
-
-            Try
-                If Prompt IsNot Nothing Then
-                    sPrompt = DirectCast(Conversions.ChangeType(Prompt, GetType(String)), String)
-                End If
-            Catch ex As StackOverflowException
-                Throw
-            Catch ex As OutOfMemoryException
-                Throw
-            Catch ex As ThreadAbortException
-                Throw
-            Catch
-                Throw New ArgumentException(GetResourceString(SR.Argument_InvalidValueType2, "Prompt", "String"))
-            End Try
-
-            Try
-                If Title Is Nothing Then
-                    If vbhost Is Nothing Then
-                        sTitle = GetTitleFromAssembly(System.Reflection.Assembly.GetCallingAssembly())
-                    Else
-                        sTitle = vbhost.GetWindowTitle()
-                    End If
-                Else
-                    sTitle = CStr(Title) 'allows the title to be an expression, e.g. msgbox(prompt, Title:=1+5)
-                End If
-            Catch ex As StackOverflowException
-                Throw
-            Catch ex As OutOfMemoryException
-                Throw
-            Catch ex As ThreadAbortException
-                Throw
-            Catch
-                Throw New ArgumentException(GetResourceString(SR.Argument_InvalidValueType2, "Title", "String"))
-            End Try
-
-            Return CType(System.Windows.Forms.MessageBox.Show(ParentWindow, sPrompt, sTitle,
-                 CType(Buttons And &HF, MessageBoxButtons),
-                 CType(Buttons And &HF0, MessageBoxIcon),
-                 CType(Buttons And &HF00, MessageBoxDefaultButton),
-                 CType(Buttons And &HFFFFF000, MessageBoxOptions)),
-                 MsgBoxResult)
-        End Function
-
-    End Module
-
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/FileLogTraceListener.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/FileLogTraceListener.vb
deleted file mode 100644
index 8413e3e3bbd..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/FileLogTraceListener.vb
+++ /dev/null
@@ -1,1265 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.ComponentModel
-Imports System.Globalization
-Imports System.IO
-Imports System.Text
-Imports System.Windows.Forms
-Imports Microsoft.VisualBasic.CompilerServices
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-Imports Microsoft.VisualBasic.CompilerServices.Utils
-
-Namespace Microsoft.VisualBasic.Logging
-
-    ''' <summary>
-    ''' Options for the location of a log's directory
-    ''' </summary>
-    Public Enum LogFileLocation As Integer
-        ' Changes to this enum must be reflected in ValidateLogfileLocationEnumValue()
-        TempDirectory
-        LocalUserApplicationDirectory
-        CommonApplicationDirectory
-        ExecutableDirectory
-        Custom
-    End Enum
-
-    ''' <summary>
-    ''' Options for the date stamp in the name of a log file
-    ''' </summary>
-    Public Enum LogFileCreationScheduleOption As Integer
-        None        '(default)
-        Daily       'YYYY-MM-DD for today
-        Weekly      'YYYY-MM-DD for first day of this week
-    End Enum
-
-    ''' <summary>
-    ''' Options for behavior when resources are exhausted
-    ''' </summary>
-    Public Enum DiskSpaceExhaustedOption As Integer
-        ThrowException
-        DiscardMessages
-    End Enum
-
-    ''' <summary>
-    ''' Class for logging to a text file
-    ''' </summary>
-    ''' <remarks>
-    ''' TraceListener is ComVisible(False), Microsoft.VisualBasic.dll is ComVisible(True).
-    ''' Therefore, mark FileLogTraceListener as ComVisible(False).
-    ''' </remarks>
-    <Runtime.InteropServices.ComVisible(False)>
-    Public Class FileLogTraceListener
-        Inherits TraceListener
-
-        ''' <summary>
-        ''' Creates a FileLogTraceListener with the passed in name
-        ''' </summary>
-        ''' <param name="name">The name of the listener</param>
-        Public Sub New(name As String)
-            MyBase.New(name)
-        End Sub
-
-        ''' <summary>
-        ''' Creates a FileLogTraceListener with default name
-        ''' </summary>
-        Public Sub New()
-            Me.New(DEFAULT_NAME)
-        End Sub
-
-        ''' <summary>
-        ''' Indicates the log's directory
-        ''' </summary>
-        ''' <value>An enum which can indicate one of several logical locations for the log</value>
-        Public Property Location() As LogFileLocation
-            Get
-                If Not _propertiesSet(LOCATION_INDEX) Then
-                    If Attributes.ContainsKey(KEY_LOCATION) Then
-                        Dim converter As TypeConverter = TypeDescriptor.GetConverter(GetType(LogFileLocation))
-                        Me.Location = DirectCast(converter.ConvertFromInvariantString(Attributes(KEY_LOCATION)), LogFileLocation)
-                    End If
-                End If
-                Return _location
-            End Get
-            Set(value As LogFileLocation)
-                ValidateLogFileLocationEnumValue(value, NameOf(value))
-
-                ' If the location is changing we need to close the current file
-                If _location <> value Then
-                    CloseCurrentStream()
-                End If
-                _location = value
-                _propertiesSet(LOCATION_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Indicates whether or not the stream should be flushed after every write
-        ''' </summary>
-        ''' <value>True if the stream should be flushed after every write, otherwise False</value>
-        Public Property AutoFlush() As Boolean
-            Get
-                If Not _propertiesSet(AUTOFLUSH_INDEX) Then
-                    If Attributes.ContainsKey(KEY_AUTOFLUSH) Then
-                        Me.AutoFlush = Convert.ToBoolean(Attributes(KEY_AUTOFLUSH), CultureInfo.InvariantCulture)
-                    End If
-                End If
-
-                Return _autoFlush
-            End Get
-            Set(value As Boolean)
-                DemandWritePermission()
-                _autoFlush = value
-                _propertiesSet(AUTOFLUSH_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Indicates whether or not the host name of the logging machine should
-        ''' be included in the output.
-        ''' </summary>
-        ''' <value>True if the HostId should be included, otherwise False</value>
-        Public Property IncludeHostName() As Boolean
-            Get
-                If Not _propertiesSet(INCLUDEHOSTNAME_INDEX) Then
-                    If Attributes.ContainsKey(KEY_INCLUDEHOSTNAME) Then
-                        Me.IncludeHostName = Convert.ToBoolean(Attributes(KEY_INCLUDEHOSTNAME), CultureInfo.InvariantCulture)
-                    End If
-                End If
-                Return _includeHostName
-            End Get
-            Set(value As Boolean)
-                DemandWritePermission()
-                _includeHostName = value
-                _propertiesSet(INCLUDEHOSTNAME_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Indicates whether or not the file should be appended to or overwritten
-        ''' </summary>
-        ''' <value>True if the file should be appended to, otherwise False</value>
-        Public Property Append() As Boolean
-            Get
-                If Not _propertiesSet(APPEND_INDEX) Then
-                    If Attributes.ContainsKey(KEY_APPEND) Then
-                        Me.Append = Convert.ToBoolean(Attributes(KEY_APPEND), CultureInfo.InvariantCulture)
-                    End If
-                End If
-
-                Return _append
-            End Get
-            Set(value As Boolean)
-
-                DemandWritePermission()
-
-                ' If this property is changing, we need to close the current file
-                If value <> _append Then
-                    CloseCurrentStream()
-                End If
-                _append = value
-                _propertiesSet(APPEND_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Indicates what to do when the size of the log trespasses on the MaxFileSize
-        ''' or the ReserveDiskSpace set by the user
-        ''' </summary>
-        ''' <value>An enum indicating the desired behavior (do nothing, throw)</value>
-        Public Property DiskSpaceExhaustedBehavior() As DiskSpaceExhaustedOption
-            Get
-                If Not _propertiesSet(DISKSPACEEXHAUSTEDBEHAVIOR_INDEX) Then
-                    If Attributes.ContainsKey(KEY_DISKSPACEEXHAUSTEDBEHAVIOR) Then
-                        Dim converter As TypeConverter = TypeDescriptor.GetConverter(GetType(DiskSpaceExhaustedOption))
-                        Me.DiskSpaceExhaustedBehavior = DirectCast(converter.ConvertFromInvariantString(Attributes(KEY_DISKSPACEEXHAUSTEDBEHAVIOR)), DiskSpaceExhaustedOption)
-                    End If
-                End If
-                Return _diskSpaceExhaustedBehavior
-            End Get
-            Set(value As DiskSpaceExhaustedOption)
-                DemandWritePermission()
-                ValidateDiskSpaceExhaustedOptionEnumValue(value, NameOf(value))
-                _diskSpaceExhaustedBehavior = value
-                _propertiesSet(DISKSPACEEXHAUSTEDBEHAVIOR_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The name of the log file not including DateStamp, file number, Path or extension
-        ''' </summary>
-        ''' <value>The name of the log file</value>
-        Public Property BaseFileName() As String
-            Get
-                If Not _propertiesSet(BASEFILENAME_INDEX) Then
-                    If Attributes.ContainsKey(KEY_BASEFILENAME) Then
-                        Me.BaseFileName = Attributes(KEY_BASEFILENAME)
-                    End If
-                End If
-                Return _baseFileName
-            End Get
-            Set(value As String)
-                If String.IsNullOrEmpty(value) Then
-                    Throw GetArgumentNullException("value", SR.ApplicationLogBaseNameNull)
-                End If
-
-                ' Test the file name. This will throw if the name is invalid.
-                Path.GetFullPath(value)
-
-                If Not String.Equals(value, _baseFileName, StringComparison.OrdinalIgnoreCase) Then
-                    CloseCurrentStream()
-                    _baseFileName = value
-                End If
-
-                _propertiesSet(BASEFILENAME_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        '''  The full name and path of the actual log file including DateStamp and file number
-        ''' </summary>
-        ''' <value>The full name and path</value>
-        ''' <remarks>Calling this method will open the log file if it's not already open</remarks>
-        Public ReadOnly Property FullLogFileName() As String
-            Get
-                ' The only way to reliably know the file name is to open the file. If we
-                ' don't have a stream, get one (this will open the file)
-                EnsureStreamIsOpen()
-
-                ' We shouldn't use fields for demands so we use a local variable
-                Dim returnPath As String = _fullFileName
-
-                Return returnPath
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Indicates what Date to stamp the log file with (none, first day of week, day)
-        ''' </summary>
-        ''' <value>An enum indicating how to stamp the file</value>
-        Public Property LogFileCreationSchedule() As LogFileCreationScheduleOption
-            Get
-                If Not _propertiesSet(LOGFILECREATIONSCHEDULE_INDEX) Then
-                    If Attributes.ContainsKey(KEY_LOGFILECREATIONSCHEDULE) Then
-                        Dim converter As TypeConverter = TypeDescriptor.GetConverter(GetType(LogFileCreationScheduleOption))
-                        Me.LogFileCreationSchedule = DirectCast(converter.ConvertFromInvariantString(Attributes(KEY_LOGFILECREATIONSCHEDULE)), LogFileCreationScheduleOption)
-                    End If
-                End If
-                Return _logFileDateStamp
-            End Get
-            Set(value As LogFileCreationScheduleOption)
-                ValidateLogFileCreationScheduleOptionEnumValue(value, NameOf(value))
-
-                If value <> _logFileDateStamp Then
-                    CloseCurrentStream()
-                    _logFileDateStamp = value
-                End If
-
-                _propertiesSet(LOGFILECREATIONSCHEDULE_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The maximum size in bytes the log file is allowed to grow to
-        ''' </summary>
-        ''' <value>The maximum size</value>
-        Public Property MaxFileSize() As Long
-            Get
-                If Not _propertiesSet(MAXFILESIZE_INDEX) Then
-                    If Attributes.ContainsKey(KEY_MAXFILESIZE) Then
-                        Me.MaxFileSize = Convert.ToInt64(Attributes(KEY_MAXFILESIZE), CultureInfo.InvariantCulture)
-                    End If
-                End If
-                Return _maxFileSize
-            End Get
-            Set(value As Long)
-                DemandWritePermission()
-                If value < MIN_FILE_SIZE Then
-                    Throw GetArgumentExceptionWithArgName("value", SR.ApplicationLogNumberTooSmall, "MaxFileSize")
-                End If
-                _maxFileSize = value
-                _propertiesSet(MAXFILESIZE_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The amount of disk space, in bytes, that must be available after a write
-        ''' </summary>
-        ''' <value>The reserved disk space</value>
-        Public Property ReserveDiskSpace() As Long
-            Get
-                If Not _propertiesSet(RESERVEDISKSPACE_INDEX) Then
-                    If Attributes.ContainsKey(KEY_RESERVEDISKSPACE) Then
-                        Me.ReserveDiskSpace = Convert.ToInt64(Attributes(KEY_RESERVEDISKSPACE), CultureInfo.InvariantCulture)
-                    End If
-                End If
-                Return _reserveDiskSpace
-            End Get
-            Set(value As Long)
-                DemandWritePermission()
-                If value < 0 Then
-                    Throw GetArgumentExceptionWithArgName("value", SR.ApplicationLog_NegativeNumber, "ReserveDiskSpace")
-                End If
-                _reserveDiskSpace = value
-                _propertiesSet(RESERVEDISKSPACE_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The delimiter to be used to delimit fields in a line of output
-        ''' </summary>
-        ''' <value>The delimiter</value>
-        Public Property Delimiter() As String
-            Get
-                If Not _propertiesSet(DELIMITER_INDEX) Then
-                    If Attributes.ContainsKey(KEY_DELIMITER) Then
-                        Me.Delimiter = Attributes(KEY_DELIMITER)
-                    End If
-                End If
-                Return _delimiter
-            End Get
-            Set(value As String)
-                _delimiter = value
-                _propertiesSet(DELIMITER_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The encoding to try when opening a file.
-        ''' </summary>
-        ''' <value>The encoding</value>
-        ''' <remarks>
-        ''' If Append is true then this value will be trumped by the actual encoding value
-        ''' of the file
-        ''' </remarks>
-        Public Property Encoding() As Encoding
-            Get
-                If Not _propertiesSet(ENCODING_INDEX) Then
-                    If Attributes.ContainsKey(KEY_ENCODING) Then
-                        Me.Encoding = System.Text.Encoding.GetEncoding(Attributes(KEY_ENCODING))
-                    End If
-                End If
-                Return _encoding
-            End Get
-            Set(value As Encoding)
-                If value Is Nothing Then
-                    Throw GetArgumentNullException("value")
-                End If
-                _encoding = value
-                _propertiesSet(ENCODING_INDEX) = True
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' The directory to be used if Location is set to Custom
-        ''' </summary>
-        ''' <value>The name of the directory</value>
-        ''' <remarks>This will throw if the path cannot be resolved</remarks>
-        Public Property CustomLocation() As String
-            Get
-                If Not _propertiesSet(CUSTOMLOCATION_INDEX) Then
-                    If Attributes.ContainsKey(KEY_CUSTOMLOCATION) Then
-                        Me.CustomLocation = Attributes(KEY_CUSTOMLOCATION)
-                    End If
-                End If
-
-                Dim fileName As String = Path.GetFullPath(_customLocation)
-                Return fileName
-            End Get
-            Set(value As String)
-
-                ' Validate the path
-                Dim tempPath As String = Path.GetFullPath(value)
-
-                If Not Directory.Exists(tempPath) Then
-                    Directory.CreateDirectory(tempPath)
-                End If
-
-                ' If we're using custom location and the value is changing we need to
-                ' close the stream
-                If Me.Location = LogFileLocation.Custom And Not String.Equals(tempPath, _customLocation, StringComparison.OrdinalIgnoreCase) Then
-                    CloseCurrentStream()
-                End If
-
-                ' Since the user is setting a custom path, set Location to custom
-                Location = LogFileLocation.Custom
-
-                _customLocation = tempPath
-                _propertiesSet(CUSTOMLOCATION_INDEX) = True
-
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Writes the message to the log
-        ''' </summary>
-        ''' <param name="message">The message to be written</param>
-        Public Overloads Overrides Sub Write(message As String)
-
-            ' Use Try block to attempt to close stream if an exception is thrown
-            Try
-                HandleDateChange()
-
-                ' Check resources
-                Dim NewEntrySize As Long = Encoding.GetByteCount(message)
-
-                If ResourcesAvailable(NewEntrySize) Then
-                    ListenerStream.Write(message)
-                    If AutoFlush Then
-                        ListenerStream.Flush()
-                    End If
-                End If
-            Catch
-                CloseCurrentStream()
-                Throw
-            End Try
-
-        End Sub
-
-        ''' <summary>
-        ''' Writes the message to the log as a line
-        ''' </summary>
-        ''' <param name="message">The message to be written</param>
-        Public Overloads Overrides Sub WriteLine(message As String)
-
-            ' Use Try block to attempt to close stream if an exception is thrown
-            Try
-                HandleDateChange()
-
-                ' Check resources
-                Dim NewEntrySize As Long = Encoding.GetByteCount(message & vbCrLf)
-
-                If ResourcesAvailable(NewEntrySize) Then
-                    ListenerStream.WriteLine(message)
-                    If AutoFlush Then
-                        ListenerStream.Flush()
-                    End If
-                End If
-            Catch
-                CloseCurrentStream()
-                Throw
-            End Try
-        End Sub
-
-        ''' <summary>
-        ''' Event fired by TraceSourceListener resulting in writing to the log
-        ''' </summary>
-        ''' <param name="eventCache">Cache of information</param>
-        ''' <param name="source">The name of the TraceSourceListener</param>
-        ''' <param name="eventType">The eventType of the message</param>
-        ''' <param name="id">The id of the message</param>
-        ''' <param name="message">The message</param>
-        Public Overrides Sub TraceEvent(eventCache As TraceEventCache, source As String, eventType As TraceEventType, id As Integer, message As String)
-
-            If Filter IsNot Nothing Then
-                If Not Filter.ShouldTrace(eventCache, source, eventType, id, message, Nothing, Nothing, Nothing) Then
-                    Return
-                End If
-            End If
-            Dim outBuilder As New StringBuilder
-
-            ' Add fields that always appear (source, eventType, id, message)
-            ' source
-            outBuilder.Append(source & Delimiter)
-
-            ' eventType
-            outBuilder.Append([Enum].GetName(GetType(TraceEventType), eventType) & Delimiter)
-
-            ' id
-            outBuilder.Append(id.ToString(CultureInfo.InvariantCulture) & Delimiter)
-
-            ' message
-            outBuilder.Append(message)
-
-            ' Add optional fields
-            ' Callstack
-            If (Me.TraceOutputOptions And TraceOptions.Callstack) = TraceOptions.Callstack Then
-                outBuilder.Append(Delimiter & eventCache.Callstack)
-            End If
-
-            ' LogicalOperationStack
-            If (Me.TraceOutputOptions And TraceOptions.LogicalOperationStack) = TraceOptions.LogicalOperationStack Then
-                outBuilder.Append(Delimiter & StackToString(eventCache.LogicalOperationStack))
-            End If
-
-            ' DateTime
-            If (Me.TraceOutputOptions And TraceOptions.DateTime) = TraceOptions.DateTime Then
-                ' Add DateTime. Time will be in GMT.
-                outBuilder.Append(Delimiter & eventCache.DateTime.ToString("u", CultureInfo.InvariantCulture))
-            End If
-
-            ' ProcessId
-            If (Me.TraceOutputOptions And TraceOptions.ProcessId) = TraceOptions.ProcessId Then
-                outBuilder.Append(Delimiter & eventCache.ProcessId.ToString(CultureInfo.InvariantCulture))
-            End If
-
-            ' ThreadId
-            If (Me.TraceOutputOptions And TraceOptions.ThreadId) = TraceOptions.ThreadId Then
-                outBuilder.Append(Delimiter & eventCache.ThreadId)
-            End If
-
-            ' Timestamp
-            If (Me.TraceOutputOptions And TraceOptions.Timestamp) = TraceOptions.Timestamp Then
-                outBuilder.Append(Delimiter & eventCache.Timestamp.ToString(CultureInfo.InvariantCulture))
-            End If
-
-            ' HostName
-            If IncludeHostName Then
-                outBuilder.Append(Delimiter & HostName)
-            End If
-
-            WriteLine(outBuilder.ToString())
-
-        End Sub
-
-        ''' <summary>
-        ''' Event fired by TraceSourceListener resulting in writing to the log
-        ''' </summary>
-        ''' <param name="eventCache">Cache of information</param>
-        ''' <param name="source">The name of the TraceSourceListener</param>
-        ''' <param name="eventType">The eventType of the message</param>
-        ''' <param name="id">The id of the message</param>
-        ''' <param name="format">A string with placeholders that serves as a format for the message</param>
-        ''' <param name="args">The values for the placeholders in format</param>
-        Public Overrides Sub TraceEvent(eventCache As TraceEventCache, source As String, eventType As TraceEventType, id As Integer, format As String, ParamArray args() As Object)
-
-            ' Create the message
-            Dim message As String
-            If args IsNot Nothing Then
-                message = String.Format(CultureInfo.InvariantCulture, format, args)
-            Else
-                message = format
-            End If
-
-            TraceEvent(eventCache, source, eventType, id, message)
-        End Sub
-
-        ''' <summary>
-        ''' Method of the base class we override to keep message format consistent
-        ''' </summary>
-        ''' <param name="eventCache">Cache of information</param>
-        ''' <param name="source">The name of the TraceSourceListener</param>
-        ''' <param name="eventType">The eventType of the message</param>
-        ''' <param name="id">The id of the message</param>
-        ''' <param name="data">An object containing the message to be logged</param>
-        Public Overrides Sub TraceData(eventCache As TraceEventCache, source As String, eventType As TraceEventType, id As Integer, data As Object)
-
-            Dim message As String = ""
-            If data IsNot Nothing Then
-                message = data.ToString()
-            End If
-
-            TraceEvent(eventCache, source, eventType, id, message)
-        End Sub
-
-        ''' <summary>
-        ''' Method of the base class we override to keep message format consistent
-        ''' </summary>
-        ''' <param name="eventCache">Cache of information</param>
-        ''' <param name="source">The name of the TraceSourceListener</param>
-        ''' <param name="eventType">The eventType of the message</param>
-        ''' <param name="id">The id of the message</param>
-        ''' <param name="data">A list of objects making up the message to be logged</param>
-        Public Overrides Sub TraceData(eventCache As TraceEventCache, source As String, eventType As TraceEventType, id As Integer, ParamArray data As Object())
-
-            Dim messageBuilder As New StringBuilder()
-            If data IsNot Nothing Then
-                Dim bound As Integer = data.Length - 1
-                For i As Integer = 0 To bound
-                    messageBuilder.Append(data(i).ToString())
-                    If i <> bound Then
-                        messageBuilder.Append(Delimiter)
-                    End If
-                Next i
-            End If
-
-            TraceEvent(eventCache, source, eventType, id, messageBuilder.ToString())
-        End Sub
-
-        ''' <summary>
-        ''' Flushes the underlying stream
-        ''' </summary>
-        Public Overrides Sub Flush()
-            _stream?.Flush()
-        End Sub
-
-        ''' <summary>
-        ''' Closes the underlying stream
-        ''' </summary>
-        Public Overrides Sub Close()
-            Dispose(True)
-        End Sub
-
-        ''' <summary>
-        ''' Gets a list of all the attributes recognized by the this listener. Trying to use an item not in this list
-        ''' in a config file will cause a configuration exception
-        ''' </summary>
-        ''' <returns>An array of attribute names</returns>
-        Protected Overrides Function GetSupportedAttributes() As String()
-            Return _supportedAttributes
-        End Function
-
-        ''' <summary>
-        ''' Makes sure stream is flushed
-        ''' </summary>
-        ''' <param name="disposing"></param>
-        Protected Overrides Sub Dispose(disposing As Boolean)
-            If disposing Then
-                CloseCurrentStream()
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Gets the log file name under the current configuration.
-        ''' </summary>
-        ''' <value>The log file name</value>
-        ''' <remarks>
-        ''' Includes the full path and the DateStamp, but does not include the
-        ''' file number or the extension.
-        ''' </remarks>
-        Private ReadOnly Property LogFileName() As String
-            Get
-                Dim basePath As String
-
-                ' Get the directory
-                Select Case Location
-                    Case LogFileLocation.CommonApplicationDirectory
-                        basePath = Application.CommonAppDataPath
-                    Case LogFileLocation.ExecutableDirectory
-                        basePath = Path.GetDirectoryName(Application.ExecutablePath)
-                    Case LogFileLocation.LocalUserApplicationDirectory
-                        basePath = Application.UserAppDataPath
-                    Case LogFileLocation.TempDirectory
-                        basePath = Path.GetTempPath()
-                    Case LogFileLocation.Custom
-                        If String.IsNullOrEmpty(CustomLocation) Then
-                            basePath = Application.UserAppDataPath
-                        Else
-                            basePath = CustomLocation
-                        End If
-                    Case Else
-                        Debug.Fail("Unrecognized location")
-                        basePath = Application.UserAppDataPath
-                End Select
-
-                ' Add the base name
-                Dim fileName As String = BaseFileName
-
-                ' Add DateTime Stamp
-                Select Case LogFileCreationSchedule
-                    Case LogFileCreationScheduleOption.Daily
-                        fileName += "-" & Now.Date.ToString(DATE_FORMAT, CultureInfo.InvariantCulture)
-                    Case LogFileCreationScheduleOption.Weekly
-                        ' Get first day of week
-                        _firstDayOfWeek = Now.AddDays(-Now.DayOfWeek)
-                        fileName += "-" & _firstDayOfWeek.Date.ToString(DATE_FORMAT, CultureInfo.InvariantCulture)
-                    Case LogFileCreationScheduleOption.None
-                    Case Else
-                        Debug.Fail("Unrecognized LogFileCreationSchedule")
-                End Select
-
-                Return Path.Combine(basePath, fileName)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets the stream to use for writing to the log
-        ''' </summary>
-        ''' <value>The stream</value>
-        Private ReadOnly Property ListenerStream() As ReferencedStream
-            Get
-                EnsureStreamIsOpen()
-
-                Debug.Assert(_stream IsNot Nothing, "Unable to get stream")
-                Return _stream
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Gets or creates the stream used for writing to the log
-        ''' </summary>
-        ''' <returns>The stream</returns>
-        Private Function GetStream() As ReferencedStream
-
-            ' Check the hash table to see if this file is already opened by another
-            ' FileLogTraceListener in the same process
-            Dim i As Integer = 0
-            Dim refStream As ReferencedStream = Nothing
-            Dim BaseStreamName As String = Path.GetFullPath(LogFileName & FILE_EXTENSION)
-
-            While refStream Is Nothing AndAlso i < MAX_OPEN_ATTEMPTS
-                ' This should only be true if processes outside our process have
-                ' MAX_OPEN_ATTEMPTS files open using the naming schema (file-1.log, file-2.log ... file-MAX_OPEN_ATTEMPTS.log)
-
-                Dim fileName As String
-                If i = 0 Then
-                    fileName = Path.GetFullPath(LogFileName & FILE_EXTENSION)
-                Else
-                    fileName = Path.GetFullPath(LogFileName & "-" & i.ToString(CultureInfo.InvariantCulture) & FILE_EXTENSION)
-                End If
-
-                Dim caseInsensitiveKey As String = fileName.ToUpper(CultureInfo.InvariantCulture)
-                SyncLock s_streams
-
-                    Dim value As ReferencedStream = Nothing
-                    If s_streams.TryGetValue(caseInsensitiveKey, value) Then
-                        refStream = value
-                        If Not refStream.IsInUse Then
-                            ' This means that the referenced stream has somehow entered an invalid state so remove it
-                            Debug.Fail("Referenced stream is in invalid state")
-                            s_streams.Remove(caseInsensitiveKey)
-                            refStream = Nothing
-                        Else
-                            If Append Then
-                                refStream.AddReference()
-                                _fullFileName = fileName
-                                Return refStream
-                            Else
-                                ' The user wants to overwrite, so we need to open a new stream
-                                i += 1
-                                refStream = Nothing
-                                Continue While
-                            End If
-                        End If
-                    End If
-
-                    ' Try to open the file
-                    Dim fileEncoding As Encoding = Encoding
-                    Try
-                        If Append Then
-                            ' Try to get the file's actual encoding. If we get it, that trumps
-                            ' the user specified value
-                            fileEncoding = GetFileEncoding(fileName)
-                            If fileEncoding Is Nothing Then
-                                fileEncoding = Encoding
-                            End If
-                        End If
-
-                        Dim baseStreamWriter As New StreamWriter(fileName, Append, fileEncoding)
-                        refStream = New ReferencedStream(baseStreamWriter)
-                        refStream.AddReference()
-                        s_streams.Add(caseInsensitiveKey, refStream)
-                        _fullFileName = fileName
-                        Return refStream
-                    Catch ex As IOException
-                    End Try
-
-                    i += 1
-                End SyncLock
-            End While
-            'If we fall out the loop, we have failed to obtain a valid stream name.  This occurs if there are files on your system
-            'ranging from BaseStreamName0..BaseStreamName{integer.MaxValue} which is pretty unlikely but hey.
-            Throw GetInvalidOperationException(SR.ApplicationLog_ExhaustedPossibleStreamNames, BaseStreamName)
-        End Function
-
-        ''' <summary>
-        ''' Makes sure we have an open stream
-        ''' </summary>
-        Private Sub EnsureStreamIsOpen()
-            If _stream Is Nothing Then
-                _stream = GetStream()
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Closes the stream.
-        ''' </summary>
-        ''' <remarks>This method should be safe to call whether or not there is a stream</remarks>
-        Private Sub CloseCurrentStream()
-            If _stream IsNot Nothing Then
-                SyncLock s_streams
-                    _stream.CloseStream()
-                    If Not _stream.IsInUse Then
-                        s_streams.Remove(_fullFileName.ToUpper(CultureInfo.InvariantCulture))
-                    End If
-                    _stream = Nothing
-                End SyncLock
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Indicates whether or not the current date has changed to new day
-        ''' </summary>
-        ''' <returns>True if the date has changed, otherwise False</returns>
-        Private Function DayChanged() As Boolean
-            Return _day.Date <> Now.Date
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not the date has changed to a new week
-        ''' </summary>
-        ''' <returns>True if the date has changed, otherwise False</returns>
-        Private Function WeekChanged() As Boolean
-            Return _firstDayOfWeek.Date <> GetFirstDayOfWeek(Now.Date)
-        End Function
-
-        ''' <summary>
-        ''' Utility to get the date of the first day of the week from the passed in date
-        ''' </summary>
-        ''' <param name="checkDate">The date being checked</param>
-        Private Shared Function GetFirstDayOfWeek(checkDate As Date) As Date
-            Return checkDate.AddDays(-checkDate.DayOfWeek).Date
-        End Function
-
-        ''' <summary>
-        ''' Checks for date changes and carries out appropriate actions
-        ''' </summary>
-        ''' <remarks>
-        ''' If the user has selected a DateStamp option then a change of
-        ''' date means we need to open a new file.
-        ''' </remarks>
-        Private Sub HandleDateChange()
-            If Me.LogFileCreationSchedule = LogFileCreationScheduleOption.Daily Then
-                If DayChanged() Then
-                    CloseCurrentStream()
-                End If
-            ElseIf Me.LogFileCreationSchedule = LogFileCreationScheduleOption.Weekly Then
-                If WeekChanged() Then
-                    CloseCurrentStream()
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Checks the size of the current log plus the new entry and the free disk space against
-        ''' the user's limits.
-        ''' </summary>
-        ''' <param name="newEntrySize">The size of what's about to be written to the file</param>
-        ''' <returns>True if the limits aren't trespassed, otherwise False</returns>
-        ''' <remarks>This method is not 100% accurate if AutoFlush is False</remarks>
-        Private Function ResourcesAvailable(newEntrySize As Long) As Boolean
-
-            If ListenerStream.FileSize + newEntrySize > MaxFileSize Then
-                If Me.DiskSpaceExhaustedBehavior = DiskSpaceExhaustedOption.ThrowException Then
-                    Throw New InvalidOperationException(GetResourceString(SR.ApplicationLog_FileExceedsMaximumSize))
-                End If
-                Return False
-            End If
-
-            If GetFreeDiskSpace() - newEntrySize < ReserveDiskSpace Then
-                If Me.DiskSpaceExhaustedBehavior = DiskSpaceExhaustedOption.ThrowException Then
-                    Throw New InvalidOperationException(GetResourceString(SR.ApplicationLog_ReservedSpaceEncroached))
-                End If
-                Return False
-            End If
-
-            Return True
-        End Function
-
-        ''' <summary>
-        ''' Returns the total amount of free disk space available to the current user
-        ''' </summary>
-        ''' <returns>The total amount, in bytes, of free disk space available to the current user</returns>
-        ''' <remarks>Throws an exception if API fails</remarks>
-        Private Function GetFreeDiskSpace() As Long
-            Dim PathName As String = Path.GetPathRoot(Path.GetFullPath(FullLogFileName))
-
-            'Initialize FreeUserSpace so we can determine if its value is changed by the API call
-            Dim FreeUserSpace As Long = -1
-            Dim TotalUserSpace As Long
-            Dim TotalFreeSpace As Long
-
-            If UnsafeNativeMethods.GetDiskFreeSpaceEx(PathName, FreeUserSpace, TotalUserSpace, TotalFreeSpace) Then
-                If FreeUserSpace > -1 Then
-                    Return FreeUserSpace
-                End If
-            End If
-
-            Throw GetWin32Exception(SR.ApplicationLog_FreeSpaceError)
-        End Function
-
-        ''' <summary>
-        ''' Opens a file and attempts to determine the file's encoding
-        ''' </summary>
-        ''' <returns>The encoding or Nothing</returns>
-        Private Function GetFileEncoding(fileName As String) As Encoding
-
-            If File.Exists(fileName) Then
-                Dim Reader As StreamReader = Nothing
-                Try
-
-                    'Attempt to determine the encoding of the file. The call to Reader.ReadLine
-                    'will change the current encoding of Reader to that of the file.
-                    Reader = New StreamReader(fileName, Encoding, True)
-
-                    'Ignore 0 length file
-                    If Reader.BaseStream.Length > 0 Then
-                        Reader.ReadLine()
-
-                        Return Reader.CurrentEncoding
-                    End If
-                Finally
-                    Reader?.Close()
-                End Try
-            End If
-
-            Return Nothing
-        End Function
-
-        ''' <summary>
-        ''' Gets the host name
-        ''' </summary>
-        ''' <value>The host name</value>
-        ''' <remarks>We use the machine name because we can get that even if not hooked up to a network</remarks>
-        Private ReadOnly Property HostName() As String
-            Get
-                If String.IsNullOrEmpty(_hostName) Then
-                    ' Use the machine name
-                    _hostName = System.Environment.MachineName
-                End If
-                Return _hostName
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Demands a FileIO write permission.
-        ''' </summary>
-        ''' <remarks>This method should be called by public API that doesn't map to TraceListener.
-        ''' This ensures these API cannot be used to circumvent CAS
-        '''</remarks>
-        Private Sub DemandWritePermission()
-            Debug.Assert(Not String.IsNullOrWhiteSpace(Path.GetDirectoryName(LogFileName)), "The log directory shouldn't be empty.")
-            Dim fileName As String = Path.GetDirectoryName(LogFileName)
-        End Sub
-
-        ''' <summary>
-        ''' Validates that the value being passed as an LogFileLocation enum is a legal value
-        ''' </summary>
-        ''' <param name="value"></param>
-        Private Shared Sub ValidateLogFileLocationEnumValue(value As LogFileLocation, paramName As String)
-            If value < LogFileLocation.TempDirectory OrElse value > LogFileLocation.Custom Then
-                Throw New InvalidEnumArgumentException(paramName, DirectCast(value, Integer), GetType(LogFileLocation))
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Validates that the value being passed as an DiskSpaceExhaustedOption enum is a legal value
-        ''' </summary>
-        ''' <param name="value"></param>
-        Private Shared Sub ValidateDiskSpaceExhaustedOptionEnumValue(value As DiskSpaceExhaustedOption, paramName As String)
-            If value < DiskSpaceExhaustedOption.ThrowException OrElse value > DiskSpaceExhaustedOption.DiscardMessages Then
-                Throw New InvalidEnumArgumentException(paramName, DirectCast(value, Integer), GetType(DiskSpaceExhaustedOption))
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Validates that the value being passed as an LogFileCreationScheduleOption enum is a legal value
-        ''' </summary>
-        ''' <param name="value"></param>
-        Private Shared Sub ValidateLogFileCreationScheduleOptionEnumValue(value As LogFileCreationScheduleOption, paramName As String)
-            If value < LogFileCreationScheduleOption.None OrElse value > LogFileCreationScheduleOption.Weekly Then
-                Throw New InvalidEnumArgumentException(paramName, DirectCast(value, Integer), GetType(LogFileCreationScheduleOption))
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Convert a stack into a string
-        ''' </summary>
-        ''' <param name="stack"></param>
-        ''' <returns>Returns the stack as a .csv string</returns>
-        Private Shared Function StackToString(stack As Stack) As String
-            Debug.Assert(stack IsNot Nothing, "Stack wasn't created.")
-
-            Dim length As Integer = STACK_DELIMITER.Length
-            Dim sb As New StringBuilder()
-
-            For Each obj As Object In stack
-                sb.Append(obj.ToString() & STACK_DELIMITER)
-            Next
-
-            ' Escape the quotes
-            sb.Replace("""", """""")
-
-            ' Remove trailing delimiter
-            If sb.Length >= length Then
-                sb.Remove(sb.Length - length, length)
-            End If
-
-            Return """" & sb.ToString() & """"
-
-        End Function
-
-        ' Indicates the location of the log's directory
-        Private _location As LogFileLocation = LogFileLocation.LocalUserApplicationDirectory
-
-        ' Indicates whether or not to flush after every write
-        Private _autoFlush As Boolean
-
-        ' Indicates whether to append to or overwrite the log file
-        Private _append As Boolean = True
-
-        ' Indicates whether or not to include the host id in the output
-        Private _includeHostName As Boolean
-
-        ' Indicates what behavior should take place when a resource level has been passed
-        Private _diskSpaceExhaustedBehavior As DiskSpaceExhaustedOption = DiskSpaceExhaustedOption.DiscardMessages
-
-        ' Stores the name of the file minus the path, date stamp, and file number
-        Private _baseFileName As String = Path.GetFileNameWithoutExtension(Application.ExecutablePath)
-
-        ' Indicate which date stamp should be used in the log file name
-        Private _logFileDateStamp As LogFileCreationScheduleOption = LogFileCreationScheduleOption.None
-
-        ' The maximum size of the log file
-        Private _maxFileSize As Long = 5000000L
-
-        ' The amount of free disk space there needs to be on the drive of the log file
-        Private _reserveDiskSpace As Long = 10000000L
-
-        ' The delimiter to be used to separate fields in a line of output
-        Private _delimiter As String = vbTab
-
-        ' The encoding of the log file
-        Private _encoding As Encoding = System.Text.Encoding.UTF8
-
-        ' The full name and path of the log file
-        Private _fullFileName As String
-
-        ' Directory to be used for the log file if Location is set to Custom
-        Private _customLocation As String = Application.UserAppDataPath
-
-        ' Reference counted stream used for writing to the log file
-        Private _stream As ReferencedStream
-
-        Private ReadOnly _day As Date = Now.Date
-
-        Private _firstDayOfWeek As Date = GetFirstDayOfWeek(Now.Date)
-
-        Private _hostName As String
-
-        ' Indicates whether or not properties have been set
-        ' Note: Properties that use m_PropertiesSet to track whether or not
-        '       they've been set should always be set through the property setter and not
-        '       by directly changing the corresponding private field.
-        Private ReadOnly _propertiesSet As New BitArray(PROPERTY_COUNT, False)
-
-        ' Table of all of the files opened by any FileLogTraceListener in the current process
-        Private Shared ReadOnly s_streams As New Dictionary(Of String, ReferencedStream)
-
-        ' A list of supported attributes
-        Private ReadOnly _supportedAttributes() As String = New String() {KEY_APPEND, KEY_APPEND_PASCAL, KEY_AUTOFLUSH, KEY_AUTOFLUSH_PASCAL, KEY_AUTOFLUSH_CAMEL,
-                                                                  KEY_BASEFILENAME, KEY_BASEFILENAME_PASCAL, KEY_BASEFILENAME_CAMEL, KEY_BASEFILENAME_PASCAL_ALT, KEY_BASEFILENAME_CAMEL_ALT,
-                                                                  KEY_CUSTOMLOCATION, KEY_CUSTOMLOCATION_PASCAL, KEY_CUSTOMLOCATION_CAMEL, KEY_DELIMITER, KEY_DELIMITER_PASCAL,
-                                                                  KEY_DISKSPACEEXHAUSTEDBEHAVIOR, KEY_DISKSPACEEXHAUSTEDBEHAVIOR_PASCAL, KEY_DISKSPACEEXHAUSTEDBEHAVIOR_CAMEL,
-                                                                  KEY_ENCODING, KEY_ENCODING_PASCAL, KEY_INCLUDEHOSTNAME, KEY_INCLUDEHOSTNAME_PASCAL, KEY_INCLUDEHOSTNAME_CAMEL, KEY_LOCATION, KEY_LOCATION_PASCAL,
-                                                                  KEY_LOGFILECREATIONSCHEDULE, KEY_LOGFILECREATIONSCHEDULE_PASCAL, KEY_LOGFILECREATIONSCHEDULE_CAMEL,
-                                                                  KEY_MAXFILESIZE, KEY_MAXFILESIZE_PASCAL, KEY_MAXFILESIZE_CAMEL, KEY_RESERVEDISKSPACE, KEY_RESERVEDISKSPACE_PASCAL, KEY_RESERVEDISKSPACE_CAMEL}
-
-        ' Identifies properties in the BitArray
-        Private Const PROPERTY_COUNT As Integer = 12
-        Private Const APPEND_INDEX As Integer = 0
-        Private Const AUTOFLUSH_INDEX As Integer = 1
-        Private Const BASEFILENAME_INDEX As Integer = 2
-        Private Const CUSTOMLOCATION_INDEX As Integer = 3
-        Private Const DELIMITER_INDEX As Integer = 4
-        Private Const DISKSPACEEXHAUSTEDBEHAVIOR_INDEX As Integer = 5
-        Private Const ENCODING_INDEX As Integer = 6
-        Private Const INCLUDEHOSTNAME_INDEX As Integer = 7
-        Private Const LOCATION_INDEX As Integer = 8
-        Private Const LOGFILECREATIONSCHEDULE_INDEX As Integer = 9
-        Private Const MAXFILESIZE_INDEX As Integer = 10
-        Private Const RESERVEDISKSPACE_INDEX As Integer = 11
-
-        Private Const DATE_FORMAT As String = "yyyy-MM-dd"
-        Private Const FILE_EXTENSION As String = ".log"
-        Private Const MAX_OPEN_ATTEMPTS As Integer = Integer.MaxValue
-
-        ' Name to be used when parameterless constructor is called
-        Private Const DEFAULT_NAME As String = "FileLogTraceListener"
-
-        ' The minimum setting allowed for maximum file size
-        Private Const MIN_FILE_SIZE As Integer = 1000
-
-        ' Attribute keys used to access properties set in the config file
-        Private Const KEY_APPEND As String = "append"
-        Private Const KEY_APPEND_PASCAL As String = "Append"
-
-        Private Const KEY_AUTOFLUSH As String = "autoflush"
-        Private Const KEY_AUTOFLUSH_PASCAL As String = "AutoFlush"
-        Private Const KEY_AUTOFLUSH_CAMEL As String = "autoFlush"
-
-        Private Const KEY_BASEFILENAME As String = "basefilename"
-        Private Const KEY_BASEFILENAME_PASCAL As String = "BaseFilename"
-        Private Const KEY_BASEFILENAME_CAMEL As String = "baseFilename"
-        Private Const KEY_BASEFILENAME_PASCAL_ALT As String = "BaseFileName"
-        Private Const KEY_BASEFILENAME_CAMEL_ALT As String = "baseFileName"
-
-        Private Const KEY_CUSTOMLOCATION As String = "customlocation"
-        Private Const KEY_CUSTOMLOCATION_PASCAL As String = "CustomLocation"
-        Private Const KEY_CUSTOMLOCATION_CAMEL As String = "customLocation"
-
-        Private Const KEY_DELIMITER As String = "delimiter"
-        Private Const KEY_DELIMITER_PASCAL As String = "Delimiter"
-
-        Private Const KEY_DISKSPACEEXHAUSTEDBEHAVIOR As String = "diskspaceexhaustedbehavior"
-        Private Const KEY_DISKSPACEEXHAUSTEDBEHAVIOR_PASCAL As String = "DiskSpaceExhaustedBehavior"
-        Private Const KEY_DISKSPACEEXHAUSTEDBEHAVIOR_CAMEL As String = "diskSpaceExhaustedBehavior"
-
-        Private Const KEY_ENCODING As String = "encoding"
-        Private Const KEY_ENCODING_PASCAL As String = "Encoding"
-
-        Private Const KEY_INCLUDEHOSTNAME As String = "includehostname"
-        Private Const KEY_INCLUDEHOSTNAME_PASCAL As String = "IncludeHostName"
-        Private Const KEY_INCLUDEHOSTNAME_CAMEL As String = "includeHostName"
-
-        Private Const KEY_LOCATION As String = "location"
-        Private Const KEY_LOCATION_PASCAL As String = "Location"
-
-        Private Const KEY_LOGFILECREATIONSCHEDULE As String = "logfilecreationschedule"
-        Private Const KEY_LOGFILECREATIONSCHEDULE_PASCAL As String = "LogFileCreationSchedule"
-        Private Const KEY_LOGFILECREATIONSCHEDULE_CAMEL As String = "logFileCreationSchedule"
-
-        Private Const KEY_MAXFILESIZE As String = "maxfilesize"
-        Private Const KEY_MAXFILESIZE_PASCAL As String = "MaxFileSize"
-        Private Const KEY_MAXFILESIZE_CAMEL As String = "maxFileSize"
-
-        Private Const KEY_RESERVEDISKSPACE As String = "reservediskspace"
-        Private Const KEY_RESERVEDISKSPACE_PASCAL As String = "ReserveDiskSpace"
-        Private Const KEY_RESERVEDISKSPACE_CAMEL As String = "reserveDiskSpace"
-
-        ' Delimiter used when converting a stack to a string
-        Private Const STACK_DELIMITER As String = ", "
-
-        ''' <summary>
-        ''' Wraps a StreamWriter and keeps a reference count. This enables multiple
-        ''' FileLogTraceListeners on multiple threads to access the same file.
-        ''' </summary>
-        Friend NotInheritable Class ReferencedStream
-            Implements IDisposable
-
-            ''' <summary>
-            ''' Creates a new referenced stream
-            ''' </summary>
-            ''' <param name="stream">The stream that does the actual writing</param>
-            Friend Sub New(stream As StreamWriter)
-                _stream = stream
-            End Sub
-
-            ''' <summary>
-            ''' Writes a message to the stream
-            ''' </summary>
-            ''' <param name="message">The message to write</param>
-            Friend Sub Write(message As String)
-                SyncLock _syncObject
-                    _stream.Write(message)
-                End SyncLock
-            End Sub
-
-            ''' <summary>
-            ''' Writes a message to the stream as a line
-            ''' </summary>
-            ''' <param name="message">The message to write</param>
-            Friend Sub WriteLine(message As String)
-                SyncLock _syncObject
-                    _stream.WriteLine(message)
-                End SyncLock
-            End Sub
-
-            ''' <summary>
-            ''' Increments the reference count for the stream
-            ''' </summary>
-            Friend Sub AddReference()
-                SyncLock _syncObject
-                    _referenceCount += 1
-                End SyncLock
-            End Sub
-
-            ''' <summary>
-            ''' Flushes the stream
-            ''' </summary>
-            Friend Sub Flush()
-                SyncLock _syncObject
-                    _stream.Flush()
-                End SyncLock
-            End Sub
-
-            ''' <summary>
-            ''' Decrements the reference count to the stream and closes the stream if the reference count
-            ''' is zero
-            ''' </summary>
-            Friend Sub CloseStream()
-                SyncLock _syncObject
-                    Try
-                        _referenceCount -= 1
-                        _stream.Flush()
-                        Debug.Assert(_referenceCount >= 0, "Ref count is below 0")
-                    Finally
-                        If _referenceCount <= 0 Then
-                            _stream.Close()
-                            _stream = Nothing
-                        End If
-                    End Try
-                End SyncLock
-            End Sub
-
-            ''' <summary>
-            ''' Indicates whether or not the stream is still in use by a FileLogTraceListener
-            ''' </summary>
-            ''' <value>True if the stream is being used, otherwise False</value>
-            Friend ReadOnly Property IsInUse() As Boolean
-                Get
-                    Return _stream IsNot Nothing
-                End Get
-            End Property
-
-            ''' <summary>
-            ''' The size of the log file
-            ''' </summary>
-            ''' <value>The size</value>
-            Friend ReadOnly Property FileSize() As Long
-                Get
-                    Return _stream.BaseStream.Length
-                End Get
-            End Property
-
-            ''' <summary>
-            ''' Ensures the stream is closed (flushed) no matter how we are closed
-            ''' </summary>
-            ''' <param name="disposing">Indicates who called dispose</param>
-            Private Overloads Sub Dispose(disposing As Boolean)
-                If disposing Then
-                    If Not _disposed Then
-                        _stream?.Close()
-                        _disposed = True
-                    End If
-                End If
-            End Sub
-
-            ''' <summary>
-            ''' Standard implementation of IDisposable
-            ''' </summary>
-            Public Overloads Sub Dispose() Implements IDisposable.Dispose
-                ' Do not change this code.  Put cleanup code in Dispose(disposing As Boolean) above.
-                Dispose(True)
-                GC.SuppressFinalize(Me)
-            End Sub
-
-            ''' <summary>
-            ''' Ensures stream is closed at GC
-            ''' </summary>
-            Protected Overrides Sub Finalize()
-                ' Do not change this code.  Put cleanup code in Dispose(disposing As Boolean) above.
-                Dispose(False)
-                MyBase.Finalize()
-            End Sub
-
-            ' The stream that does the writing
-            Private _stream As StreamWriter
-
-            ' The number of FileLogTraceListeners using the stream
-            Private _referenceCount As Integer
-
-            ' Used for synchronizing writing and reference counting
-            Private ReadOnly _syncObject As Object = New Object
-
-            ' Indicates whether or not the object has been disposed
-            Private _disposed As Boolean
-
-        End Class 'ReferencedStream
-
-    End Class 'FileLogTraceListener
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/Log.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/Log.vb
deleted file mode 100644
index 49ea2c047d3..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/Logging/Log.vb
+++ /dev/null
@@ -1,240 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Collections.Specialized
-Imports System.ComponentModel
-Imports System.Text
-Imports Microsoft.VisualBasic.CompilerServices.ExceptionUtils
-
-Namespace Microsoft.VisualBasic.Logging
-
-    ''' <summary>
-    ''' Enables logging to configured TraceListeners
-    ''' </summary>
-    Public Class Log
-
-        ''' <summary>
-        ''' Creates a Log and the underlying TraceSource based on the platform
-        ''' </summary>
-        ''' <remarks>Right now we only support WinApp as an application platform</remarks>
-        Public Sub New()
-            ' Set trace source for platform. Right now we only support WinApp
-            _traceSource = New DefaultTraceSource(WINAPP_SOURCE_NAME)
-            If Not _traceSource.HasBeenConfigured Then
-                InitializeWithDefaultsSinceNoConfigExists()
-            End If
-            ' Make sure to flush the log when the application closes
-            AddHandler System.AppDomain.CurrentDomain.ProcessExit, AddressOf CloseOnProcessExit
-        End Sub
-
-        ''' <summary>
-        ''' Creates a Log and the underlying TraceSource based on the passed in name
-        ''' </summary>
-        ''' <param name="name">The name of the TraceSource to be created</param>
-        Public Sub New(name As String)
-            _traceSource = New DefaultTraceSource(name)
-            If Not _traceSource.HasBeenConfigured Then
-                InitializeWithDefaultsSinceNoConfigExists()
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all of its listeners
-        ''' </summary>
-        ''' <param name="message">The message to be logged</param>
-        Public Sub WriteEntry(message As String)
-            WriteEntry(message, TraceEventType.Information, TraceEventTypeToId(TraceEventType.Information))
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all of its listeners
-        ''' </summary>
-        ''' <param name="message">The message to be logged</param>
-        ''' <param name="severity">The type of message (error, info, etc...)</param>
-        Public Sub WriteEntry(message As String, severity As TraceEventType)
-            WriteEntry(message, severity, TraceEventTypeToId(severity))
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all of its listeners
-        ''' </summary>
-        ''' <param name="message">The message to be logged</param>
-        ''' <param name="severity">The type of message (error, info, etc...)</param>
-        ''' <param name="id">An id for the message (used for correlation)</param>
-        Public Sub WriteEntry(message As String, severity As TraceEventType, id As Integer)
-            If message Is Nothing Then
-                message = ""
-            End If
-            _traceSource.TraceEvent(severity, id, message)
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all listeners using information in an exception to form the message
-        ''' </summary>
-        ''' <param name="ex">The exception being logged</param>
-        Public Sub WriteException(ex As Exception)
-            WriteException(ex, TraceEventType.Error, "", TraceEventTypeToId(TraceEventType.Error))
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all listeners using information in an exception to form the message
-        ''' and appending additional info
-        ''' </summary>
-        ''' <param name="ex">The exception being logged</param>
-        ''' <param name="severity">The type of message (error, info, etc...)</param>
-        ''' <param name="additionalInfo">Extra information to append to the message</param>
-        Public Sub WriteException(ex As Exception, severity As TraceEventType, additionalInfo As String)
-            WriteException(ex, severity, additionalInfo, TraceEventTypeToId(severity))
-        End Sub
-
-        ''' <summary>
-        ''' Has the TraceSource fire a TraceEvent for all listeners using information in an exception to form the message
-        ''' and appending additional info
-        ''' </summary>
-        ''' <param name="ex">The exception being logged</param>
-        ''' <param name="severity">The type of message (error, info, etc...)</param>
-        ''' <param name="additionalInfo">Extra information to append to the message</param>
-        ''' <param name="id">An id for the message (used for correlation)</param>
-        Public Sub WriteException(ex As Exception, severity As TraceEventType, additionalInfo As String, id As Integer)
-
-            If ex Is Nothing Then
-                Throw GetArgumentNullException("ex")
-            End If
-
-            Dim builder As New StringBuilder()
-            builder.Append(ex.Message)
-
-            If Not String.IsNullOrEmpty(additionalInfo) Then
-                builder.Append(" "c)
-                builder.Append(additionalInfo)
-            End If
-
-            _traceSource.TraceEvent(severity, id, builder.ToString())
-
-        End Sub
-
-        ''' <summary>
-        ''' Gives access to the log's underlying TraceSource
-        ''' </summary>
-        ''' <value>The log's underlying TraceSource</value>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Public ReadOnly Property TraceSource() As TraceSource
-            Get
-                Return _traceSource 'Note, this is a downcast from the DefaultTraceSource class we are using
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Returns the file log trace listener we create for the Log
-        ''' </summary>
-        ''' <value>The file log trace listener</value>
-        Public ReadOnly Property DefaultFileLogWriter() As FileLogTraceListener
-            Get
-                Return CType(TraceSource.Listeners(DEFAULT_FILE_LOG_TRACE_LISTENER_NAME), FileLogTraceListener)
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Encapsulates a System.Diagnostics.TraceSource.  The value add is that it knows if it was initialized
-        ''' using a config file or not.
-        ''' </summary>
-        Friend NotInheritable Class DefaultTraceSource
-            Inherits TraceSource
-
-            ''' <summary>
-            ''' TraceSource has other constructors, this is the only one we care about for this internal class
-            ''' </summary>
-            ''' <param name="name"></param>
-            Sub New(name As String)
-                MyBase.New(name)
-            End Sub
-
-            ''' <summary>
-            ''' Tells us whether this TraceSource found a config file to configure itself from
-            ''' </summary>
-            ''' <value>True - The TraceSource was configured from a config file</value>
-            Public ReadOnly Property HasBeenConfigured() As Boolean
-                Get
-                    ' This forces initialization of the attributes list
-                    If _listenerAttributes Is Nothing Then
-                        _listenerAttributes = Attributes
-                    End If
-
-                    ' TODO: This is a tempory fix, which will break configuring logging via file for the time being. See: https://github.com/dotnet/winforms/pull/7590
-                    Return False
-                End Get
-            End Property
-
-            Private _listenerAttributes As StringDictionary
-
-        End Class
-
-        ''' <summary>
-        ''' When there is no config file to configure the trace source, this function is called in order to
-        ''' configure the trace source according to the defaults they would have had in a default AppConfig
-        ''' </summary>
-        Protected Friend Overridable Sub InitializeWithDefaultsSinceNoConfigExists()
-            'By default, you get a file log listener that picks everything from level Information on up.
-            _traceSource.Listeners.Add(New FileLogTraceListener(DEFAULT_FILE_LOG_TRACE_LISTENER_NAME))
-            _traceSource.Switch.Level = SourceLevels.Information
-        End Sub
-
-        ''' <summary>
-        ''' Make sure we flush the log on exit
-        ''' </summary>
-        Private Sub CloseOnProcessExit(sender As Object, e As EventArgs)
-            RemoveHandler System.AppDomain.CurrentDomain.ProcessExit, AddressOf CloseOnProcessExit
-            TraceSource.Close()
-        End Sub
-
-        ''' <summary>
-        ''' Adds the default id values
-        ''' </summary>
-        ''' <remarks>Fix FxCop violation InitializeReferenceTypeStaticFieldsInline</remarks>
-        Private Shared Function InitializeIDHash() As Dictionary(Of TraceEventType, Integer)
-            Dim result As New Dictionary(Of TraceEventType, Integer)(10)
-
-            ' Populate table with the fx pre defined ids
-            With result
-                .Add(TraceEventType.Information, 0)
-                .Add(TraceEventType.Warning, 1)
-                .Add(TraceEventType.Error, 2)
-                .Add(TraceEventType.Critical, 3)
-                .Add(TraceEventType.Start, 4)
-                .Add(TraceEventType.Stop, 5)
-                .Add(TraceEventType.Suspend, 6)
-                .Add(TraceEventType.Resume, 7)
-                .Add(TraceEventType.Verbose, 8)
-                .Add(TraceEventType.Transfer, 9)
-            End With
-
-            Return result
-        End Function
-
-        ''' <summary>
-        ''' Converts a TraceEventType to an Id
-        ''' </summary>
-        ''' <param name="traceEventValue"></param>
-        ''' <returns>The Id</returns>
-        Private Shared Function TraceEventTypeToId(traceEventValue As TraceEventType) As Integer
-            Dim Id As Integer = 0
-            s_idHash.TryGetValue(traceEventValue, Id)
-            Return Id
-        End Function
-
-        ' The underlying TraceSource for the log
-        Private ReadOnly _traceSource As DefaultTraceSource
-
-        ' A table of default id values
-        Private Shared ReadOnly s_idHash As Dictionary(Of TraceEventType, Integer) = InitializeIDHash()
-
-        ' Names of TraceSources
-        Private Const WINAPP_SOURCE_NAME As String = "DefaultSource"
-        Private Const DEFAULT_FILE_LOG_TRACE_LISTENER_NAME As String = "FileLog" 'taken from appconfig
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/ClipboardProxy.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/ClipboardProxy.vb
deleted file mode 100644
index b60616852ca..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/ClipboardProxy.vb
+++ /dev/null
@@ -1,214 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Collections.Specialized
-Imports System.ComponentModel
-Imports System.Drawing
-Imports System.IO
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.MyServices
-
-    ''' <summary>
-    ''' A class that wraps System.Windows.Forms.Clipboard so that
-    ''' a clipboard can be instanced.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    Public Class ClipboardProxy
-
-        ''' <summary>
-        ''' Only Allows instantiation of the class
-        ''' </summary>
-        Friend Sub New()
-        End Sub
-
-        ''' <summary>
-        ''' Gets text from the clipboard
-        ''' </summary>
-        ''' <returns>The text as a String</returns>
-        Public Function GetText() As String
-            Return Clipboard.GetText()
-        End Function
-
-        ''' <summary>
-        ''' Gets text from the clipboard saved in the passed in format
-        ''' </summary>
-        ''' <param name="format">The type of text to get</param>
-        ''' <returns>The text as a String</returns>
-        Public Function GetText(format As System.Windows.Forms.TextDataFormat) As String
-            Return Clipboard.GetText(format)
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not text is available on the clipboard
-        ''' </summary>
-        ''' <returns>True if text is available, otherwise False</returns>
-        Public Function ContainsText() As Boolean
-            Return Clipboard.ContainsText
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not text is available on the clipboard in 
-        ''' the passed in format
-        ''' </summary>
-        ''' <param name="format">The type of text being checked for</param>
-        ''' <returns>True if text is available, otherwise False</returns>
-        Public Function ContainsText(format As System.Windows.Forms.TextDataFormat) As Boolean
-            Return Clipboard.ContainsText(format)
-        End Function
-
-        ''' <summary>
-        ''' Saves the passed in String to the clipboard
-        ''' </summary>
-        ''' <param name="text">The String to save</param>
-        Public Sub SetText(text As String)
-            Clipboard.SetText(text)
-        End Sub
-
-        ''' <summary>
-        ''' Saves the passed in String to the clipboard in the passed in format
-        ''' </summary>
-        ''' <param name="text">The String to save</param>
-        ''' <param name="format">The format in which to save the String</param>
-        Public Sub SetText(text As String, format As System.Windows.Forms.TextDataFormat)
-            Clipboard.SetText(text, format)
-        End Sub
-
-        ''' <summary>
-        ''' Gets an Image from the clipboard
-        ''' </summary>
-        ''' <returns>The image</returns>
-        Public Function GetImage() As Image
-            Return Clipboard.GetImage()
-        End Function
-
-        ''' <summary>
-        ''' Indicate whether or not an image has been saved to the clipboard
-        ''' </summary>
-        ''' <returns>True if an image is available, otherwise False</returns>
-        Public Function ContainsImage() As Boolean
-            Return Clipboard.ContainsImage()
-        End Function
-
-        ''' <summary>
-        ''' Saves the passed in image to the clipboard
-        ''' </summary>
-        ''' <param name="image">The image to be saved</param>
-        Public Sub SetImage(image As Image)
-            Clipboard.SetImage(image)
-        End Sub
-
-        ''' <summary>
-        ''' Gets an audio stream from the clipboard
-        ''' </summary>
-        ''' <returns>The audio stream as a Stream</returns>
-        Public Function GetAudioStream() As Stream
-            Return Clipboard.GetAudioStream()
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not there's an audio stream saved to the clipboard
-        ''' </summary>
-        ''' <returns>True if an audio stream is available, otherwise False</returns>
-        Public Function ContainsAudio() As Boolean
-            Return Clipboard.ContainsAudio()
-        End Function
-
-        ''' <summary>
-        ''' Saves the passed in audio byte array to the clipboard
-        ''' </summary>
-        ''' <param name="audioBytes">The byte array to be saved</param>
-        Public Sub SetAudio(audioBytes As Byte())
-            Clipboard.SetAudio(audioBytes)
-        End Sub
-
-        ''' <summary>
-        ''' Saves the passed in audio stream to the clipboard
-        ''' </summary>
-        ''' <param name="audioStream">The stream to be saved</param>
-        Public Sub SetAudio(audioStream As Stream)
-            Clipboard.SetAudio(audioStream)
-        End Sub
-
-        ''' <summary>
-        ''' Gets a file drop list from the clipboard
-        ''' </summary>
-        ''' <returns>The list of file paths as a StringCollection</returns>
-        Public Function GetFileDropList() As StringCollection
-            Return Clipboard.GetFileDropList()
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not a file drop list has been saved to the clipboard
-        ''' </summary>
-        ''' <returns>True if a file drop list is available, otherwise False</returns>
-        Public Function ContainsFileDropList() As Boolean
-            Return Clipboard.ContainsFileDropList()
-        End Function
-
-        ''' <summary>
-        ''' Saves the passed in file drop list to the clipboard
-        ''' </summary>
-        ''' <param name="filePaths">The file drop list as a StringCollection</param>
-        Public Sub SetFileDropList(filePaths As StringCollection)
-            Clipboard.SetFileDropList(filePaths)
-        End Sub
-
-        ''' <summary>
-        ''' Gets data from the clipboard that's been saved in the passed in format.
-        ''' </summary>
-        ''' <param name="format">The type of data being sought</param>
-        ''' <returns>The data</returns>
-        Public Function GetData(format As String) As Object
-            Return Clipboard.GetData(format)
-        End Function
-
-        ''' <summary>
-        ''' Indicates whether or not there is data on the clipboard in the passed in format
-        ''' </summary>
-        ''' <param name="format"></param>
-        ''' <returns>True if there's data in the passed in format, otherwise False</returns>
-        Public Function ContainsData(format As String) As Boolean
-            Return Clipboard.ContainsData(format)
-        End Function
-
-        ''' <summary>
-        ''' Saves the passed in data to the clipboard in the passed in format
-        ''' </summary>
-        ''' <param name="format">The format in which to save the data</param>
-        ''' <param name="data">The data to be saved</param>
-        Public Sub SetData(format As String, data As Object)
-            Clipboard.SetData(format, data)
-        End Sub
-
-        ''' <summary>
-        ''' Removes everything from the clipboard
-        ''' </summary>
-        Public Sub Clear()
-            Clipboard.Clear()
-        End Sub
-
-        ''' <summary>
-        ''' Gets a Data Object from the clipboard.
-        ''' </summary>
-        ''' <returns>The data object</returns>
-        ''' <remarks>This gives the ability to save an object in multiple formats</remarks>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Public Function GetDataObject() As System.Windows.Forms.IDataObject
-            Return Clipboard.GetDataObject()
-        End Function
-
-        ''' <summary>
-        ''' Saves a DataObject to the clipboard
-        ''' </summary>
-        ''' <param name="data">The data object to be saved</param>
-        ''' <remarks>This gives the ability to save an object in multiple formats</remarks>
-        <EditorBrowsable(EditorBrowsableState.Advanced)>
-        Public Sub SetDataObject(data As System.Windows.Forms.DataObject)
-            Clipboard.SetDataObject(data)
-        End Sub
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/FileSystemProxy.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/FileSystemProxy.vb
deleted file mode 100644
index b4a14a98322..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/FileSystemProxy.vb
+++ /dev/null
@@ -1,281 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Strict On
-Option Explicit On
-
-Imports System.Collections.ObjectModel
-Imports System.ComponentModel
-Imports System.Text
-Imports Microsoft.VisualBasic.FileIO
-
-Namespace Microsoft.VisualBasic.MyServices
-
-    ''' <summary>
-    ''' An extremely thin wrapper around Microsoft.VisualBasic.FileIO.FileSystem to expose the type through My.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    Public Class FileSystemProxy
-
-        Public ReadOnly Property Drives() As ReadOnlyCollection(Of IO.DriveInfo)
-            Get
-                Return FileIO.FileSystem.Drives
-            End Get
-        End Property
-
-        Public ReadOnly Property SpecialDirectories() As SpecialDirectoriesProxy
-            Get
-                If _specialDirectoriesProxy Is Nothing Then
-                    _specialDirectoriesProxy = New SpecialDirectoriesProxy
-                End If
-                Return _specialDirectoriesProxy
-            End Get
-        End Property
-
-        Public Property CurrentDirectory() As String
-            Get
-                Return FileIO.FileSystem.CurrentDirectory
-            End Get
-            Set(value As String)
-                FileIO.FileSystem.CurrentDirectory = value
-            End Set
-        End Property
-
-        Public Function DirectoryExists(directory As String) As Boolean
-            Return FileIO.FileSystem.DirectoryExists(directory)
-        End Function
-
-        Public Function FileExists(file As String) As Boolean
-            Return FileIO.FileSystem.FileExists(file)
-        End Function
-
-        Public Sub CreateDirectory(directory As String)
-            FileIO.FileSystem.CreateDirectory(directory)
-        End Sub
-
-        Public Function GetDirectoryInfo(directory As String) As IO.DirectoryInfo
-            Return FileIO.FileSystem.GetDirectoryInfo(directory)
-        End Function
-
-        Public Function GetFileInfo(file As String) As IO.FileInfo
-            Return FileIO.FileSystem.GetFileInfo(file)
-        End Function
-
-        Public Function GetDriveInfo(drive As String) As IO.DriveInfo
-            Return FileIO.FileSystem.GetDriveInfo(drive)
-        End Function
-
-        Public Function GetFiles(directory As String) As ReadOnlyCollection(Of String)
-            Return FileIO.FileSystem.GetFiles(directory)
-        End Function
-
-        Public Function GetFiles(directory As String, searchType As SearchOption,
-            ParamArray wildcards() As String) As ReadOnlyCollection(Of String)
-
-            Return FileIO.FileSystem.GetFiles(directory, searchType, wildcards)
-        End Function
-
-        Public Function GetDirectories(directory As String) As ReadOnlyCollection(Of String)
-            Return FileIO.FileSystem.GetDirectories(directory)
-        End Function
-
-        Public Function GetDirectories(directory As String, searchType As SearchOption,
-            ParamArray wildcards() As String) As ReadOnlyCollection(Of String)
-
-            Return FileIO.FileSystem.GetDirectories(directory, searchType, wildcards)
-        End Function
-
-        Public Function FindInFiles(directory As String,
-            containsText As String, ignoreCase As Boolean, searchType As SearchOption) As ReadOnlyCollection(Of String)
-
-            Return FileIO.FileSystem.FindInFiles(directory, containsText, ignoreCase, searchType)
-        End Function
-
-        Public Function FindInFiles(directory As String, containsText As String, ignoreCase As Boolean,
-            searchType As SearchOption, ParamArray fileWildcards() As String) As ReadOnlyCollection(Of String)
-
-            Return FileIO.FileSystem.FindInFiles(directory, containsText, ignoreCase, searchType, fileWildcards)
-        End Function
-
-        Public Function GetParentPath(path As String) As String
-            Return FileIO.FileSystem.GetParentPath(path)
-        End Function
-
-        Public Function CombinePath(baseDirectory As String, relativePath As String) As String
-            Return FileIO.FileSystem.CombinePath(baseDirectory, relativePath)
-        End Function
-
-        Public Function GetName(path As String) As String
-            Return FileIO.FileSystem.GetName(path)
-        End Function
-
-        Public Function GetTempFileName() As String
-            Return FileIO.FileSystem.GetTempFileName()
-        End Function
-
-        Public Function ReadAllText(file As String) As String
-            Return FileIO.FileSystem.ReadAllText(file)
-        End Function
-
-        Public Function ReadAllText(file As String, encoding As Encoding) As String
-            Return FileIO.FileSystem.ReadAllText(file, encoding)
-        End Function
-
-        Public Function ReadAllBytes(file As String) As Byte()
-            Return FileIO.FileSystem.ReadAllBytes(file)
-        End Function
-
-        Public Sub WriteAllText(file As String, text As String, append As Boolean)
-            FileIO.FileSystem.WriteAllText(file, text, append)
-        End Sub
-
-        Public Sub WriteAllText(file As String, text As String, append As Boolean,
-            encoding As Encoding)
-
-            FileIO.FileSystem.WriteAllText(file, text, append, encoding)
-        End Sub
-
-        Public Sub WriteAllBytes(file As String, data() As Byte, append As Boolean)
-            FileIO.FileSystem.WriteAllBytes(file, data, append)
-        End Sub
-
-        Public Sub CopyFile(sourceFileName As String, destinationFileName As String)
-            FileIO.FileSystem.CopyFile(sourceFileName, destinationFileName)
-        End Sub
-
-        Public Sub CopyFile(sourceFileName As String, destinationFileName As String, overwrite As Boolean)
-            FileIO.FileSystem.CopyFile(sourceFileName, destinationFileName, overwrite)
-        End Sub
-
-        Public Sub CopyFile(sourceFileName As String, destinationFileName As String, showUI As UIOption)
-            FileIO.FileSystem.CopyFile(sourceFileName, destinationFileName, showUI)
-        End Sub
-
-        Public Sub CopyFile(sourceFileName As String, destinationFileName As String, showUI As UIOption, onUserCancel As UICancelOption)
-            FileIO.FileSystem.CopyFile(sourceFileName, destinationFileName, showUI, onUserCancel)
-        End Sub
-
-        Public Sub MoveFile(sourceFileName As String, destinationFileName As String)
-            FileIO.FileSystem.MoveFile(sourceFileName, destinationFileName)
-        End Sub
-
-        Public Sub MoveFile(sourceFileName As String, destinationFileName As String, overwrite As Boolean)
-            FileIO.FileSystem.MoveFile(sourceFileName, destinationFileName, overwrite)
-        End Sub
-
-        Public Sub MoveFile(sourceFileName As String, destinationFileName As String, showUI As UIOption)
-            FileIO.FileSystem.MoveFile(sourceFileName, destinationFileName, showUI)
-        End Sub
-
-        Public Sub MoveFile(sourceFileName As String, destinationFileName As String, showUI As UIOption, onUserCancel As UICancelOption)
-            FileIO.FileSystem.MoveFile(sourceFileName, destinationFileName, showUI, onUserCancel)
-        End Sub
-
-        Public Sub CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String)
-            FileIO.FileSystem.CopyDirectory(sourceDirectoryName, destinationDirectoryName)
-        End Sub
-
-        Public Sub CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, overwrite As Boolean)
-            FileIO.FileSystem.CopyDirectory(sourceDirectoryName, destinationDirectoryName, overwrite)
-        End Sub
-
-        Public Sub CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As UIOption)
-            FileIO.FileSystem.CopyDirectory(sourceDirectoryName, destinationDirectoryName, showUI)
-        End Sub
-
-        Public Sub CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As UIOption, onUserCancel As UICancelOption)
-            FileIO.FileSystem.CopyDirectory(sourceDirectoryName, destinationDirectoryName, showUI, onUserCancel)
-        End Sub
-
-        Public Sub MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String)
-            FileIO.FileSystem.MoveDirectory(sourceDirectoryName, destinationDirectoryName)
-        End Sub
-
-        Public Sub MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, overwrite As Boolean)
-            FileIO.FileSystem.MoveDirectory(sourceDirectoryName, destinationDirectoryName, overwrite)
-        End Sub
-
-        Public Sub MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As UIOption)
-            FileIO.FileSystem.MoveDirectory(sourceDirectoryName, destinationDirectoryName, showUI)
-        End Sub
-
-        Public Sub MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As UIOption, onUserCancel As UICancelOption)
-            FileIO.FileSystem.MoveDirectory(sourceDirectoryName, destinationDirectoryName, showUI, onUserCancel)
-        End Sub
-
-        Public Sub DeleteFile(file As String)
-            FileIO.FileSystem.DeleteFile(file)
-        End Sub
-
-        Public Sub DeleteFile(file As String, showUI As UIOption, recycle As RecycleOption)
-            FileIO.FileSystem.DeleteFile(file, showUI, recycle)
-        End Sub
-
-        Public Sub DeleteFile(file As String, showUI As UIOption, recycle As RecycleOption,
-            onUserCancel As UICancelOption)
-
-            FileIO.FileSystem.DeleteFile(file, showUI, recycle, onUserCancel)
-        End Sub
-
-        Public Sub DeleteDirectory(directory As String, onDirectoryNotEmpty As DeleteDirectoryOption)
-            FileIO.FileSystem.DeleteDirectory(directory, onDirectoryNotEmpty)
-        End Sub
-
-        Public Sub DeleteDirectory(directory As String, showUI As UIOption, recycle As RecycleOption)
-
-            FileIO.FileSystem.DeleteDirectory(directory, showUI, recycle)
-        End Sub
-
-        Public Sub DeleteDirectory(directory As String,
-            showUI As UIOption, recycle As RecycleOption, onUserCancel As UICancelOption)
-
-            FileIO.FileSystem.DeleteDirectory(directory, showUI, recycle, onUserCancel)
-        End Sub
-
-        Public Sub RenameFile(file As String, newName As String)
-            FileIO.FileSystem.RenameFile(file, newName)
-        End Sub
-
-        Public Sub RenameDirectory(directory As String, newName As String)
-            FileIO.FileSystem.RenameDirectory(directory, newName)
-        End Sub
-
-        Public Function OpenTextFieldParser(file As String) As TextFieldParser
-            Return FileIO.FileSystem.OpenTextFieldParser(file)
-        End Function
-
-        Public Function OpenTextFieldParser(file As String, ParamArray delimiters As String()) As TextFieldParser
-            Return FileIO.FileSystem.OpenTextFieldParser(file, delimiters)
-        End Function
-
-        Public Function OpenTextFieldParser(file As String, ParamArray fieldWidths As Integer()) As TextFieldParser
-            Return FileIO.FileSystem.OpenTextFieldParser(file, fieldWidths)
-        End Function
-
-        Public Function OpenTextFileReader(file As String) As IO.StreamReader
-            Return FileIO.FileSystem.OpenTextFileReader(file)
-        End Function
-
-        Public Function OpenTextFileReader(file As String, encoding As Encoding) As IO.StreamReader
-            Return FileIO.FileSystem.OpenTextFileReader(file, encoding)
-        End Function
-
-        Public Function OpenTextFileWriter(file As String, append As Boolean) As IO.StreamWriter
-            Return FileIO.FileSystem.OpenTextFileWriter(file, append)
-        End Function
-
-        Public Function OpenTextFileWriter(file As String, append As Boolean,
-            encoding As Encoding) As IO.StreamWriter
-
-            Return FileIO.FileSystem.OpenTextFileWriter(file, append, encoding)
-        End Function
-
-        ''' <summary>
-        ''' Proxy class can only created by internal classes.
-        ''' </summary>
-        Friend Sub New()
-        End Sub
-
-        Private _specialDirectoriesProxy As SpecialDirectoriesProxy
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ContextValue.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ContextValue.vb
deleted file mode 100644
index 8963ff68ccd..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ContextValue.vb
+++ /dev/null
@@ -1,55 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Threading
-
-Namespace Microsoft.VisualBasic.MyServices.Internal
-
-    ''' <summary>
-    ''' Stores an object in a context appropriate for the environment we are 
-    ''' running in (web/windows)
-    ''' </summary>
-    ''' <typeparam name="T"></typeparam>
-    ''' <remarks>
-    ''' "Thread appropriate" means that if we are running on ASP.Net the object will be stored in the 
-    ''' context of the current request (meaning the object is stored per request on the web).
-    ''' Note that an instance of this class can only be associated
-    ''' with the one item to be stored/retrieved at a time.
-    ''' </remarks>
-    <ComponentModel.EditorBrowsable(ComponentModel.EditorBrowsableState.Never)>
-    Public Class ContextValue(Of T)
-        Public Sub New()
-            _contextKey = System.Guid.NewGuid.ToString
-        End Sub
-
-        ''' <summary>
-        ''' Get the object from the correct thread-appropriate location
-        ''' </summary>
-        Public Property Value() As T 'No SyncLocks required because we are operating upon instance data and the object is not shared across threads
-            Get
-                Dim dictionary As IDictionary = GetDictionary()
-                Return DirectCast(dictionary(_contextKey), T) 'Note, IDictionary(key) can return Nothing and that's OK
-            End Get
-            Set(value As T)
-                Dim dictionary As IDictionary = GetDictionary()
-                dictionary(_contextKey) = value
-            End Set
-        End Property
-
-        Private Shared Function GetDictionary() As IDictionary
-            If s_threadLocal Is Nothing Then
-                Interlocked.CompareExchange(s_threadLocal, New ThreadLocal(Of IDictionary)(Function() New Dictionary(Of String, T)), Nothing)
-            End If
-            Return s_threadLocal.Value
-        End Function
-
-        Private ReadOnly _contextKey As String 'An item is stored in the dictionary by a GUID which this string maintains
-
-        Private Shared s_threadLocal As ThreadLocal(Of IDictionary)
-
-    End Class 'ContextValue
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.vb
deleted file mode 100644
index c7b97f8f532..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.vb
+++ /dev/null
@@ -1,277 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.Drawing
-Imports System.Globalization
-Imports System.Threading
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.MyServices.Internal
-
-    ''' <summary>
-    '''  A dialog that shows progress used for Network.Download and Network.Upload
-    ''' </summary>
-    Friend NotInheritable Class ProgressDialog
-        Inherits Form
-
-        ''' <summary>
-        ''' Event raised when user cancels the dialog or closes it before the operation is completed
-        ''' </summary>
-        Public Event UserHitCancel()
-
-        ''' <summary>
-        '''  Constructor
-        ''' </summary>
-        Friend Sub New()
-            MyBase.New()
-            InitializeComponent()
-        End Sub
-
-        ''' <summary>
-        '''  Increments the progress bar by the passed in amount
-        ''' </summary>
-        ''' <param name="incrementAmount">The amount to increment the bar</param>
-        ''' <remarks>
-        '''  This method should never be called directly. It should be called with
-        '''  an InvokeBegin by a secondary thread.
-        '''</remarks>
-        Public Sub Increment(incrementAmount As Integer)
-            ProgressBarWork.Increment(incrementAmount)
-        End Sub
-
-        ''' <summary>
-        '''  Closes the Progress Dialog
-        ''' </summary>
-        ''' <remarks>
-        '''  This method should never be called directly. It should be called with
-        '''  an InvokeBegin by a secondary thread.
-        '''</remarks>
-        Public Sub CloseDialog()
-            _closeDialogInvoked = True
-            Close()
-        End Sub
-
-        ''' <summary>
-        '''  Displays the progress dialog modally
-        ''' </summary>
-        ''' <remarks>This method should be called on the main thread after the worker thread has been started</remarks>
-        Public Sub ShowProgressDialog()
-            Try
-                If Not _closing Then
-                    ShowDialog()
-                End If
-            Finally
-                FormClosableSemaphore.Set()
-            End Try
-        End Sub
-
-        ''' <summary>
-        '''  Sets the text of the label (usually something like Copying x to y)
-        ''' </summary>
-        ''' <value>The value to set the label to</value>
-        ''' <remarks>This should only be called on the main thread before showing the dialog</remarks>
-        Public Property LabelText() As String
-            Get
-                Return LabelInfo.Text
-            End Get
-            Set(Value As String)
-                LabelInfo.Text = Value
-            End Set
-        End Property
-
-        ''' <summary>
-        ''' Used to set or get the semaphore which signals when the dialog
-        ''' is in a closable state.
-        ''' </summary>
-        ''' <value>The ManualResetEvent</value>
-        Public ReadOnly Property FormClosableSemaphore() As ManualResetEvent
-            Get
-                Return _formClosableSemaphore
-            End Get
-        End Property
-
-        ''' <summary>
-        '''  Inform the dialog that CloseDialog will soon be called
-        ''' </summary>
-        ''' <remarks>
-        '''  This method should be called directly from the secondary thread. We want
-        '''  to indicate we're closing as soon as we can so w don't show the dialog when we
-        '''  don't need to (when the work is finished before we can show the dialog)
-        '''</remarks>
-        Public Sub IndicateClosing()
-            _closing = True
-        End Sub
-
-        ''' <summary>
-        '''  Indicated if the user has clicked the cancel button
-        ''' </summary>
-        ''' <value>True if the user has canceled, otherwise False</value>
-        ''' <remarks>
-        '''  The secondary thread checks this property directly. If it's True, the thread
-        '''  breaks out of its loop.
-        '''</remarks>
-        Public ReadOnly Property UserCanceledTheDialog() As Boolean
-            Get
-                Return _canceled
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' This enables a dialog with a close button, sizable borders, and no icon
-        ''' </summary>
-        Protected Overrides ReadOnly Property CreateParams() As CreateParams
-            Get
-                Dim cp As CreateParams = MyBase.CreateParams
-                cp.Style = cp.Style Or WS_THICKFRAME
-                Return cp
-            End Get
-        End Property
-
-        ''' <summary>
-        '''  Handles user clicking Cancel. Sets a flag read by secondary thread.
-        ''' </summary>
-        ''' <param name="sender">The cancel button</param>
-        ''' <param name="e">Arguments</param>
-        Private Sub ButtonCloseDialog_Click(sender As Object, e As EventArgs) Handles ButtonCloseDialog.Click
-            ButtonCloseDialog.Enabled = False
-            _canceled = True
-            RaiseEvent UserHitCancel()
-        End Sub
-
-        ''' <summary>
-        ''' Indicates the form is closing
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        ''' <remarks>
-        ''' We listen for this event since we want to make closing the dialog before it's
-        ''' finished behave the same as a cancel
-        '''</remarks>
-        Private Sub ProgressDialog_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing
-            If e.CloseReason = CloseReason.UserClosing And Not _closeDialogInvoked Then
-                ' If the progress bar isn't finished and the user hasn't already canceled
-                If ProgressBarWork.Value < 100 And Not _canceled Then
-                    ' Cancel the Close since we want the dialog to be closed from a call from the
-                    ' secondary thread
-                    e.Cancel = True
-
-                    ' Indicate the user has canceled. We'll actually close the dialog from WebClientCopy
-                    _canceled = True
-                    RaiseEvent UserHitCancel()
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Ensure the label resizes with the dialog
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        ''' <remarks>
-        ''' Since the label has AutoSize set to True we have to set the maximum size so the label
-        ''' will grow down rather than off the dialog. As the size of the dialog changes, the maximum
-        ''' size needs to be adjusted.
-        ''' </remarks>
-        Private Sub ProgressDialog_Resize(sender As Object, e As EventArgs) Handles Me.Resize
-            LabelInfo.MaximumSize = New Size(ClientSize.Width - BORDER_SIZE, 0)
-        End Sub
-
-        ''' <summary>
-        '''  Exits the monitor when we're activated
-        ''' </summary>
-        ''' <param name="sender">Dialog</param>
-        ''' <param name="e">Arguments</param>
-        Private Sub ProgressDialog_Activated(sender As Object, e As EventArgs) Handles Me.Shown
-            _formClosableSemaphore.Set()
-        End Sub
-
-        ' Indicates whether or not the dialog is closing
-        Private _closing As Boolean
-
-        ' Indicates whether or not the user has canceled the copy
-        Private _canceled As Boolean
-
-        ' Used to signal when the dialog is in a closable state. The dialog is in a closable
-        ' state when it has been activated or when it has been flagged to be closed before
-        ' ShowDialog has been called
-        Private _formClosableSemaphore As ManualResetEvent = New ManualResetEvent(False)
-
-        ' Indicates CloseDialog has been called
-        Private _closeDialogInvoked As Boolean
-
-        ' Constant used to get re-sizable dialog with border style set to fixed dialog.
-        Private Const WS_THICKFRAME As Integer = &H40000
-
-        ' Border area for label (10 pixels on each side)
-        Private Const BORDER_SIZE As Integer = 20
-
-#Region " Windows Form Designer generated code "
-
-        'Form overrides dispose to clean up the component list.
-        Protected Overloads Overrides Sub Dispose(disposing As Boolean)
-            If disposing Then
-                _components?.Dispose()
-                If _formClosableSemaphore IsNot Nothing Then
-                    _formClosableSemaphore.Dispose()
-                    _formClosableSemaphore = Nothing
-                End If
-            End If
-            MyBase.Dispose(disposing)
-        End Sub
-        Friend WithEvents LabelInfo As Label
-        Friend WithEvents ProgressBarWork As ProgressBar
-        Friend WithEvents ButtonCloseDialog As Button
-
-        'Required by the Windows Form Designer
-        Private ReadOnly _components As System.ComponentModel.IContainer
-
-        'NOTE: The following procedure is required by the Windows Form Designer
-        'It can be modified using the Windows Form Designer.
-        'Do not modify it using the code editor.
-        <DebuggerStepThrough()>
-        Private Sub InitializeComponent()
-            Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(ProgressDialog))
-            LabelInfo = New Label
-            ProgressBarWork = New ProgressBar
-            ButtonCloseDialog = New Button
-            SuspendLayout()
-            '
-            'LabelInfo
-            '
-            resources.ApplyResources(LabelInfo, "LabelInfo", CultureInfo.CurrentUICulture)
-            LabelInfo.MaximumSize = New Size(300, 0)
-            LabelInfo.Name = "LabelInfo"
-            '
-            'ProgressBarWork
-            '
-            resources.ApplyResources(ProgressBarWork, "ProgressBarWork", CultureInfo.CurrentUICulture)
-            ProgressBarWork.Name = "ProgressBarWork"
-            '
-            'ButtonCloseDialog
-            '
-            resources.ApplyResources(ButtonCloseDialog, "ButtonCloseDialog", CultureInfo.CurrentUICulture)
-            ButtonCloseDialog.Name = "ButtonCloseDialog"
-            '
-            'ProgressDialog
-            '
-            resources.ApplyResources(Me, "$this", CultureInfo.CurrentUICulture)
-            Controls.Add(ButtonCloseDialog)
-            Controls.Add(ProgressBarWork)
-            Controls.Add(LabelInfo)
-            FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog
-            MaximizeBox = False
-            MinimizeBox = False
-            Name = "ProgressDialog"
-            ShowInTaskbar = False
-            ResumeLayout(False)
-            PerformLayout()
-
-        End Sub
-
-#End Region
-
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/WebClientCopy.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/WebClientCopy.vb
deleted file mode 100644
index 539204e84a8..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/Internal/WebClientCopy.vb
+++ /dev/null
@@ -1,212 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Option Explicit On
-Option Strict On
-
-Imports System.IO
-Imports System.Net
-Imports System.Windows.Forms
-
-Namespace Microsoft.VisualBasic.MyServices.Internal
-
-    ''' <summary>
-    '''  Class that controls the thread that does the actual work of downloading or uploading.
-    ''' </summary>
-    Friend NotInheritable Class WebClientCopy
-
-        ''' <summary>
-        ''' Creates an instance of a WebClientCopy, used to download or upload a file
-        ''' </summary>
-        ''' <param name="client">The WebClient used to do the downloading or uploading</param>
-        ''' <param name="dialog">UI for indicating progress</param>
-        Public Sub New(client As WebClient, dialog As ProgressDialog)
-
-            Debug.Assert(client IsNot Nothing, "No WebClient")
-
-            m_WebClient = client
-            m_ProgressDialog = dialog
-
-        End Sub
-
-        ''' <summary>
-        ''' Downloads a file
-        ''' </summary>
-        ''' <param name="address">The source for the file</param>
-        ''' <param name="destinationFileName">The path and name where the file is saved</param>
-        Public Sub DownloadFile(address As Uri, destinationFileName As String)
-            Debug.Assert(m_WebClient IsNot Nothing, "No WebClient")
-            Debug.Assert(address IsNot Nothing, "No address")
-            Debug.Assert((Not String.IsNullOrWhiteSpace(destinationFileName)) AndAlso Directory.Exists(Path.GetDirectoryName(Path.GetFullPath(destinationFileName))), "Invalid path")
-
-            ' If we have a dialog we need to set up an async download
-            If m_ProgressDialog IsNot Nothing Then
-                m_WebClient.DownloadFileAsync(address, destinationFileName)
-                m_ProgressDialog.ShowProgressDialog() 'returns when the download sequence is over, whether due to success, error, or being canceled
-            Else
-                m_WebClient.DownloadFile(address, destinationFileName)
-            End If
-
-            'Now that we are back on the main thread, throw the exception we encountered if the user didn't cancel.
-            If _exceptionEncounteredDuringFileTransfer IsNot Nothing Then
-                If m_ProgressDialog Is Nothing OrElse Not m_ProgressDialog.UserCanceledTheDialog Then
-                    Throw _exceptionEncounteredDuringFileTransfer
-                End If
-            End If
-
-        End Sub
-
-        ''' <summary>
-        ''' Uploads a file
-        ''' </summary>
-        ''' <param name="sourceFileName">The name and path of the source file</param>
-        ''' <param name="address">The address to which the file is uploaded</param>
-        Public Sub UploadFile(sourceFileName As String, address As Uri)
-            Debug.Assert(m_WebClient IsNot Nothing, "No WebClient")
-            Debug.Assert(address IsNot Nothing, "No address")
-            Debug.Assert((Not String.IsNullOrWhiteSpace(sourceFileName)) AndAlso File.Exists(sourceFileName), "Invalid file")
-
-            ' If we have a dialog we need to set up an async download
-            If m_ProgressDialog IsNot Nothing Then
-                m_WebClient.UploadFileAsync(address, sourceFileName)
-                m_ProgressDialog.ShowProgressDialog() 'returns when the download sequence is over, whether due to success, error, or being canceled
-            Else
-                m_WebClient.UploadFile(address, sourceFileName)
-            End If
-
-            'Now that we are back on the main thread, throw the exception we encountered if the user didn't cancel.
-            If _exceptionEncounteredDuringFileTransfer IsNot Nothing Then
-                If m_ProgressDialog Is Nothing OrElse Not m_ProgressDialog.UserCanceledTheDialog Then
-                    Throw _exceptionEncounteredDuringFileTransfer
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        '''  Notifies the progress dialog to increment the progress bar
-        ''' </summary>
-        ''' <param name="progressPercentage">The percentage of bytes read</param>
-        Private Sub InvokeIncrement(progressPercentage As Integer)
-            ' Don't invoke unless dialog is up and running
-            If m_ProgressDialog IsNot Nothing Then
-                If m_ProgressDialog.IsHandleCreated Then
-
-                    ' For performance, don't invoke if increment is 0
-                    Dim increment As Integer = progressPercentage - _percentage
-                    _percentage = progressPercentage
-                    If increment > 0 Then
-                        m_ProgressDialog.BeginInvoke(New DoIncrement(AddressOf m_ProgressDialog.Increment), increment)
-                    End If
-
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        '''  Posts a message to close the progress dialog
-        ''' </summary>
-        Private Sub CloseProgressDialog()
-            ' Don't invoke unless dialog is up and running
-            If m_ProgressDialog IsNot Nothing Then
-                m_ProgressDialog.IndicateClosing()
-
-                If m_ProgressDialog.IsHandleCreated Then
-                    m_ProgressDialog.BeginInvoke(New MethodInvoker(AddressOf m_ProgressDialog.CloseDialog))
-                Else
-                    ' Ensure dialog is closed. If we get here it means the file was copied before the handle for
-                    ' the progress dialog was created.
-                    m_ProgressDialog.Close()
-                End If
-            End If
-        End Sub
-
-        ''' <summary>
-        ''' Handles the WebClient's DownloadFileCompleted event
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        Private Sub m_WebClient_DownloadFileCompleted(sender As Object, e As System.ComponentModel.AsyncCompletedEventArgs) Handles m_WebClient.DownloadFileCompleted
-            Try
-                ' If the download was interrupted by an exception, keep track of the exception, which we'll throw from the main thread
-                If e.Error IsNot Nothing Then
-                    _exceptionEncounteredDuringFileTransfer = e.Error
-                End If
-
-                If Not e.Cancelled AndAlso e.Error Is Nothing Then
-                    InvokeIncrement(100)
-                End If
-            Finally
-                'We don't close the dialog until we receive the WebClient.DownloadFileCompleted event
-                CloseProgressDialog()
-            End Try
-        End Sub
-
-        ''' <summary>
-        ''' Handles event WebClient fires whenever progress of download changes
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        Private Sub m_WebClient_DownloadProgressChanged(sender As Object, e As DownloadProgressChangedEventArgs) Handles m_WebClient.DownloadProgressChanged
-            InvokeIncrement(e.ProgressPercentage)
-        End Sub
-
-        ''' <summary>
-        ''' Handles the WebClient's UploadFileCompleted event
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        Private Sub m_WebClient_UploadFileCompleted(sender As Object, e As UploadFileCompletedEventArgs) Handles m_WebClient.UploadFileCompleted
-
-            ' If the upload was interrupted by an exception, keep track of the exception, which we'll throw from the main thread
-            Try
-                If e.Error IsNot Nothing Then
-                    _exceptionEncounteredDuringFileTransfer = e.Error
-                End If
-                If Not e.Cancelled AndAlso e.Error Is Nothing Then
-                    InvokeIncrement(100)
-                End If
-            Finally
-                'We don't close the dialog until we receive the WebClient.DownloadFileCompleted event
-                CloseProgressDialog()
-            End Try
-        End Sub
-
-        ''' <summary>
-        ''' Handles event WebClient fires whenever progress of upload changes
-        ''' </summary>
-        ''' <param name="sender"></param>
-        ''' <param name="e"></param>
-        Private Sub m_WebClient_UploadProgressChanged(sender As Object, e As UploadProgressChangedEventArgs) Handles m_WebClient.UploadProgressChanged
-            Dim increment As Long = (e.BytesSent * 100) \ e.TotalBytesToSend
-            InvokeIncrement(CInt(increment))
-        End Sub
-
-        ''' <summary>
-        ''' If the user clicks cancel on the Progress dialog, we need to cancel
-        ''' the current async file transfer operation
-        ''' </summary>
-        ''' <remarks>
-        ''' Note that we don't want to close the progress dialog here.  Wait until
-        ''' the actual file transfer cancel event comes through and do it there.
-        ''' </remarks>
-        Private Sub m_ProgressDialog_UserCancelledEvent() Handles m_ProgressDialog.UserHitCancel
-            m_WebClient.CancelAsync() 'cancel the upload/download transfer.  We'll close the ProgressDialog as soon as the WebClient cancels the xfer.
-        End Sub
-
-        ' The WebClient performs the downloading or uploading operations for us
-        Private WithEvents m_WebClient As WebClient
-
-        ' Dialog shown if user wants to see progress UI.  Allows the user to cancel the file transfer.
-        Private WithEvents m_ProgressDialog As ProgressDialog
-
-        'Keeps track of the error that happened during upload/download so we can throw it once we can guarantee we are back on the main thread
-        Private _exceptionEncounteredDuringFileTransfer As Exception
-
-        ' Used for invoking ProgressDialog.Increment
-        Private Delegate Sub DoIncrement(Increment As Integer)
-
-        ' The percentage of the operation completed
-        Private _percentage As Integer
-
-    End Class
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/RegistryProxy.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/RegistryProxy.vb
deleted file mode 100644
index e981b1c5316..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/RegistryProxy.vb
+++ /dev/null
@@ -1,75 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.ComponentModel
-Imports Microsoft.Win32
-
-Namespace Microsoft.VisualBasic.MyServices
-
-    ''' <summary>
-    ''' An extremely thin wrapper around Microsoft.Win32.Registry to expose the type through My.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    Public Class RegistryProxy
-
-        Public ReadOnly Property CurrentUser() As RegistryKey
-            Get
-                Return Registry.CurrentUser
-            End Get
-        End Property
-
-        Public ReadOnly Property LocalMachine() As RegistryKey
-            Get
-                Return Registry.LocalMachine
-            End Get
-        End Property
-
-        Public ReadOnly Property ClassesRoot() As RegistryKey
-            Get
-                Return Registry.ClassesRoot
-            End Get
-        End Property
-
-        Public ReadOnly Property Users() As RegistryKey
-            Get
-                Return Registry.Users
-            End Get
-        End Property
-
-        Public ReadOnly Property PerformanceData() As RegistryKey
-            Get
-                Return Registry.PerformanceData
-            End Get
-        End Property
-
-        Public ReadOnly Property CurrentConfig() As RegistryKey
-            Get
-                Return Registry.CurrentConfig
-            End Get
-        End Property
-
-        Public Function GetValue(keyName As String, valueName As String,
-            defaultValue As Object) As Object
-
-            Return Registry.GetValue(keyName, valueName, defaultValue)
-        End Function
-
-        Public Sub SetValue(keyName As String, valueName As String, value As Object)
-            Registry.SetValue(keyName, valueName, value)
-        End Sub
-
-        Public Sub SetValue(keyName As String, valueName As String, value As Object,
-            valueKind As RegistryValueKind)
-
-            Registry.SetValue(keyName, valueName, value, valueKind)
-        End Sub
-
-        ''' <summary>
-        ''' Proxy class can only created by internal classes.
-        ''' </summary>
-        Friend Sub New()
-        End Sub
-
-    End Class
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxy.vb b/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxy.vb
deleted file mode 100644
index a28c07a16b3..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxy.vb
+++ /dev/null
@@ -1,77 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.ComponentModel
-Imports Microsoft.VisualBasic.FileIO
-
-Namespace Microsoft.VisualBasic.MyServices
-
-    ''' <summary>
-    ''' An extremely thin wrapper around Microsoft.VisualBasic.FileIO.SpecialDirectories to expose the type through My.
-    ''' </summary>
-    <EditorBrowsable(EditorBrowsableState.Never)>
-    Public Class SpecialDirectoriesProxy
-
-        Public ReadOnly Property MyDocuments() As String
-            Get
-                Return SpecialDirectories.MyDocuments
-            End Get
-        End Property
-
-        Public ReadOnly Property MyMusic() As String
-            Get
-                Return SpecialDirectories.MyMusic
-            End Get
-        End Property
-
-        Public ReadOnly Property MyPictures() As String
-            Get
-                Return SpecialDirectories.MyPictures
-            End Get
-        End Property
-
-        Public ReadOnly Property Desktop() As String
-            Get
-                Return SpecialDirectories.Desktop
-            End Get
-        End Property
-
-        Public ReadOnly Property Programs() As String
-            Get
-                Return SpecialDirectories.Programs
-            End Get
-        End Property
-
-        Public ReadOnly Property ProgramFiles() As String
-            Get
-                Return SpecialDirectories.ProgramFiles
-            End Get
-        End Property
-
-        Public ReadOnly Property Temp() As String
-            Get
-                Return SpecialDirectories.Temp
-            End Get
-        End Property
-
-        Public ReadOnly Property CurrentUserApplicationData() As String
-            Get
-                Return SpecialDirectories.CurrentUserApplicationData
-            End Get
-        End Property
-
-        Public ReadOnly Property AllUsersApplicationData() As String
-            Get
-                Return SpecialDirectories.AllUsersApplicationData
-            End Get
-        End Property
-
-        ''' <summary>
-        ''' Proxy class can only created by internal classes.
-        ''' </summary>
-        Friend Sub New()
-        End Sub
-
-    End Class
-
-End Namespace
diff --git a/src/Microsoft.VisualBasic.Forms/src/PublicAPI.Shipped.txt b/src/Microsoft.VisualBasic.Forms/src/PublicAPI.Shipped.txt
deleted file mode 100644
index 0e4c9c9b678..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/PublicAPI.Shipped.txt
+++ /dev/null
@@ -1,380 +0,0 @@
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.ChangeCulture(cultureName As String) -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.ChangeUICulture(cultureName As String) -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.Culture() -> System.Globalization.CultureInfo
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.GetEnvironmentVariable(name As String) -> String
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.Info() -> Microsoft.VisualBasic.ApplicationServices.AssemblyInfo
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.Log() -> Microsoft.VisualBasic.Logging.Log
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplicationBase.UICulture() -> System.Globalization.CultureInfo
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.Font() -> System.Drawing.Font
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.Font(AutoPropertyValue As System.Drawing.Font) -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.HighDpiMode() -> System.Windows.Forms.HighDpiMode
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.HighDpiMode(AutoPropertyValue As System.Windows.Forms.HighDpiMode) -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.MinimumSplashScreenDisplayTime() -> Integer
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventArgs.MinimumSplashScreenDisplayTime(AutoPropertyValue As Integer) -> Void
-Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventHandler
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.AssemblyName() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.CompanyName() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.Copyright() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.Description() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.DirectoryPath() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.LoadedAssemblies() -> System.Collections.ObjectModel.ReadOnlyCollection(Of System.Reflection.Assembly)
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.New(currentAssembly As System.Reflection.Assembly) -> Void
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.ProductName() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.StackTrace() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.Title() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.Trademark() -> String
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.Version() -> System.Version
-Microsoft.VisualBasic.ApplicationServices.AssemblyInfo.WorkingSet() -> Long
-Microsoft.VisualBasic.ApplicationServices.AuthenticationMode
-Microsoft.VisualBasic.ApplicationServices.AuthenticationMode.ApplicationDefined = 1 -> Microsoft.VisualBasic.ApplicationServices.AuthenticationMode
-Microsoft.VisualBasic.ApplicationServices.AuthenticationMode.Windows = 0 -> Microsoft.VisualBasic.ApplicationServices.AuthenticationMode
-Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException
-Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException.New(info As System.Runtime.Serialization.SerializationInfo, context As System.Runtime.Serialization.StreamingContext) -> Void
-Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException.New(message As String) -> Void
-Microsoft.VisualBasic.ApplicationServices.CantStartSingleInstanceException.New(message As String, inner As System.Exception) -> Void
-Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase
-Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase.CommandLineArgs() -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase.InternalCommandLine(value As System.Collections.ObjectModel.ReadOnlyCollection(Of String)) -> Void
-Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.NoStartupFormException
-Microsoft.VisualBasic.ApplicationServices.NoStartupFormException.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.NoStartupFormException.New(info As System.Runtime.Serialization.SerializationInfo, context As System.Runtime.Serialization.StreamingContext) -> Void
-Microsoft.VisualBasic.ApplicationServices.NoStartupFormException.New(message As String) -> Void
-Microsoft.VisualBasic.ApplicationServices.NoStartupFormException.New(message As String, inner As System.Exception) -> Void
-Microsoft.VisualBasic.ApplicationServices.ShutdownEventHandler
-Microsoft.VisualBasic.ApplicationServices.ShutdownMode
-Microsoft.VisualBasic.ApplicationServices.ShutdownMode.AfterAllFormsClose = 1 -> Microsoft.VisualBasic.ApplicationServices.ShutdownMode
-Microsoft.VisualBasic.ApplicationServices.ShutdownMode.AfterMainFormCloses = 0 -> Microsoft.VisualBasic.ApplicationServices.ShutdownMode
-Microsoft.VisualBasic.ApplicationServices.StartupEventArgs
-Microsoft.VisualBasic.ApplicationServices.StartupEventArgs.CommandLine() -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.ApplicationServices.StartupEventArgs.New(args As System.Collections.ObjectModel.ReadOnlyCollection(Of String)) -> Void
-Microsoft.VisualBasic.ApplicationServices.StartupEventHandler
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs.BringToForeground() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs.BringToForeground(AutoPropertyValue As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs.CommandLine() -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs.New(args As System.Collections.ObjectModel.ReadOnlyCollection(Of String), bringToForegroundFlag As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventHandler
-Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs
-Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs.ExitApplication() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs.ExitApplication(AutoPropertyValue As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs.New(exitApplication As Boolean, exception As System.Exception) -> Void
-Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventHandler
-Microsoft.VisualBasic.ApplicationServices.User
-Microsoft.VisualBasic.ApplicationServices.User.CurrentPrincipal() -> System.Security.Principal.IPrincipal
-Microsoft.VisualBasic.ApplicationServices.User.CurrentPrincipal(value As System.Security.Principal.IPrincipal) -> Void
-Microsoft.VisualBasic.ApplicationServices.User.IsAuthenticated() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.User.IsInRole(role As String) -> Boolean
-Microsoft.VisualBasic.ApplicationServices.User.Name() -> String
-Microsoft.VisualBasic.ApplicationServices.User.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.ApplicationContext() -> System.Windows.Forms.ApplicationContext
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.ApplyApplicationDefaults -> Microsoft.VisualBasic.ApplicationServices.ApplyApplicationDefaultsEventHandler
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.DoEvents() -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.EnableVisualStyles() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.EnableVisualStyles(value As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.HideSplashScreen() -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.HighDpiMode() -> System.Windows.Forms.HighDpiMode
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.HighDpiMode(value As System.Windows.Forms.HighDpiMode) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.IsSingleInstance() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.IsSingleInstance(value As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.MainForm() -> System.Windows.Forms.Form
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.MainForm(value As System.Windows.Forms.Form) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.MinimumSplashScreenDisplayTime() -> Integer
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.MinimumSplashScreenDisplayTime(value As Integer) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.NetworkAvailabilityChanged -> Microsoft.VisualBasic.Devices.NetworkAvailableEventHandler
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.New() -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.New(authenticationMode As Microsoft.VisualBasic.ApplicationServices.AuthenticationMode) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OpenForms() -> System.Windows.Forms.FormCollection
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.Run(commandLine As String()) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.SaveMySettingsOnExit() -> Boolean
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.SaveMySettingsOnExit(value As Boolean) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.ShowSplashScreen() -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.Shutdown -> Microsoft.VisualBasic.ApplicationServices.ShutdownEventHandler
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.ShutdownStyle() -> Microsoft.VisualBasic.ApplicationServices.ShutdownMode
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.ShutdownStyle(value As Microsoft.VisualBasic.ApplicationServices.ShutdownMode) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.SplashScreen() -> System.Windows.Forms.Form
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.SplashScreen(value As System.Windows.Forms.Form) -> Void
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.Startup -> Microsoft.VisualBasic.ApplicationServices.StartupEventHandler
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.StartupNextInstance -> Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventHandler
-Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.UnhandledException -> Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventHandler
-Microsoft.VisualBasic.AudioPlayMode
-Microsoft.VisualBasic.AudioPlayMode.Background = 1 -> Microsoft.VisualBasic.AudioPlayMode
-Microsoft.VisualBasic.AudioPlayMode.BackgroundLoop = 2 -> Microsoft.VisualBasic.AudioPlayMode
-Microsoft.VisualBasic.AudioPlayMode.WaitToComplete = 0 -> Microsoft.VisualBasic.AudioPlayMode
-Microsoft.VisualBasic.CompilerServices.HostServices
-Microsoft.VisualBasic.CompilerServices.HostServices.New() -> Void
-Microsoft.VisualBasic.CompilerServices.IVbHost
-Microsoft.VisualBasic.CompilerServices.IVbHost.GetParentWindow() -> System.Windows.Forms.IWin32Window
-Microsoft.VisualBasic.CompilerServices.IVbHost.GetWindowTitle() -> String
-Microsoft.VisualBasic.Devices.Audio
-Microsoft.VisualBasic.Devices.Audio.New() -> Void
-Microsoft.VisualBasic.Devices.Audio.Play(data As Byte(), playMode As Microsoft.VisualBasic.AudioPlayMode) -> Void
-Microsoft.VisualBasic.Devices.Audio.Play(location As String) -> Void
-Microsoft.VisualBasic.Devices.Audio.Play(location As String, playMode As Microsoft.VisualBasic.AudioPlayMode) -> Void
-Microsoft.VisualBasic.Devices.Audio.Play(stream As System.IO.Stream, playMode As Microsoft.VisualBasic.AudioPlayMode) -> Void
-Microsoft.VisualBasic.Devices.Audio.PlaySystemSound(systemSound As System.Media.SystemSound) -> Void
-Microsoft.VisualBasic.Devices.Audio.Stop() -> Void
-Microsoft.VisualBasic.Devices.Clock
-Microsoft.VisualBasic.Devices.Clock.GmtTime() -> Date
-Microsoft.VisualBasic.Devices.Clock.LocalTime() -> Date
-Microsoft.VisualBasic.Devices.Clock.New() -> Void
-Microsoft.VisualBasic.Devices.Clock.TickCount() -> Integer
-Microsoft.VisualBasic.Devices.Computer
-Microsoft.VisualBasic.Devices.Computer.Audio() -> Microsoft.VisualBasic.Devices.Audio
-Microsoft.VisualBasic.Devices.Computer.Clipboard() -> Microsoft.VisualBasic.MyServices.ClipboardProxy
-Microsoft.VisualBasic.Devices.Computer.Keyboard() -> Microsoft.VisualBasic.Devices.Keyboard
-Microsoft.VisualBasic.Devices.Computer.Mouse() -> Microsoft.VisualBasic.Devices.Mouse
-Microsoft.VisualBasic.Devices.Computer.New() -> Void
-Microsoft.VisualBasic.Devices.Computer.Screen() -> System.Windows.Forms.Screen
-Microsoft.VisualBasic.Devices.ComputerInfo
-Microsoft.VisualBasic.Devices.ComputerInfo.AvailablePhysicalMemory() -> ULong
-Microsoft.VisualBasic.Devices.ComputerInfo.AvailableVirtualMemory() -> ULong
-Microsoft.VisualBasic.Devices.ComputerInfo.InstalledUICulture() -> System.Globalization.CultureInfo
-Microsoft.VisualBasic.Devices.ComputerInfo.New() -> Void
-Microsoft.VisualBasic.Devices.ComputerInfo.OSFullName() -> String
-Microsoft.VisualBasic.Devices.ComputerInfo.OSPlatform() -> String
-Microsoft.VisualBasic.Devices.ComputerInfo.OSVersion() -> String
-Microsoft.VisualBasic.Devices.ComputerInfo.TotalPhysicalMemory() -> ULong
-Microsoft.VisualBasic.Devices.ComputerInfo.TotalVirtualMemory() -> ULong
-Microsoft.VisualBasic.Devices.Keyboard
-Microsoft.VisualBasic.Devices.Keyboard.AltKeyDown() -> Boolean
-Microsoft.VisualBasic.Devices.Keyboard.CapsLock() -> Boolean
-Microsoft.VisualBasic.Devices.Keyboard.CtrlKeyDown() -> Boolean
-Microsoft.VisualBasic.Devices.Keyboard.New() -> Void
-Microsoft.VisualBasic.Devices.Keyboard.NumLock() -> Boolean
-Microsoft.VisualBasic.Devices.Keyboard.ScrollLock() -> Boolean
-Microsoft.VisualBasic.Devices.Keyboard.SendKeys(keys As String) -> Void
-Microsoft.VisualBasic.Devices.Keyboard.SendKeys(keys As String, wait As Boolean) -> Void
-Microsoft.VisualBasic.Devices.Keyboard.ShiftKeyDown() -> Boolean
-Microsoft.VisualBasic.Devices.Mouse
-Microsoft.VisualBasic.Devices.Mouse.ButtonsSwapped() -> Boolean
-Microsoft.VisualBasic.Devices.Mouse.New() -> Void
-Microsoft.VisualBasic.Devices.Mouse.WheelExists() -> Boolean
-Microsoft.VisualBasic.Devices.Mouse.WheelScrollLines() -> Integer
-Microsoft.VisualBasic.Devices.Network
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As String, destinationFileName As String) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As String, destinationFileName As String, userName As String, password As String) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As String, destinationFileName As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As String, destinationFileName As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String, networkCredentials As System.Net.ICredentials, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String, networkCredentials As System.Net.ICredentials, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String, userName As String, password As String) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.Devices.Network.DownloadFile(address As System.Uri, destinationFileName As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, overwrite As Boolean, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.Network.IsAvailable() -> Boolean
-Microsoft.VisualBasic.Devices.Network.NetworkAvailabilityChanged -> Microsoft.VisualBasic.Devices.NetworkAvailableEventHandler
-Microsoft.VisualBasic.Devices.Network.New() -> Void
-Microsoft.VisualBasic.Devices.Network.Ping(address As System.Uri) -> Boolean
-Microsoft.VisualBasic.Devices.Network.Ping(address As System.Uri, timeout As Integer) -> Boolean
-Microsoft.VisualBasic.Devices.Network.Ping(hostNameOrAddress As String) -> Boolean
-Microsoft.VisualBasic.Devices.Network.Ping(hostNameOrAddress As String, timeout As Integer) -> Boolean
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As String) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As String, userName As String, password As String) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As String, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri, networkCredentials As System.Net.ICredentials, showUI As Boolean, connectionTimeout As Integer) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri, networkCredentials As System.Net.ICredentials, showUI As Boolean, connectionTimeout As Integer, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri, userName As String, password As String) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer) -> Void
-Microsoft.VisualBasic.Devices.Network.UploadFile(sourceFileName As String, address As System.Uri, userName As String, password As String, showUI As Boolean, connectionTimeout As Integer, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.Devices.NetworkAvailableEventArgs
-Microsoft.VisualBasic.Devices.NetworkAvailableEventArgs.IsNetworkAvailable() -> Boolean
-Microsoft.VisualBasic.Devices.NetworkAvailableEventArgs.New(networkAvailable As Boolean) -> Void
-Microsoft.VisualBasic.Devices.NetworkAvailableEventHandler
-Microsoft.VisualBasic.Devices.ServerComputer
-Microsoft.VisualBasic.Devices.ServerComputer.Clock() -> Microsoft.VisualBasic.Devices.Clock
-Microsoft.VisualBasic.Devices.ServerComputer.FileSystem() -> Microsoft.VisualBasic.MyServices.FileSystemProxy
-Microsoft.VisualBasic.Devices.ServerComputer.Info() -> Microsoft.VisualBasic.Devices.ComputerInfo
-Microsoft.VisualBasic.Devices.ServerComputer.Name() -> String
-Microsoft.VisualBasic.Devices.ServerComputer.Network() -> Microsoft.VisualBasic.Devices.Network
-Microsoft.VisualBasic.Devices.ServerComputer.New() -> Void
-Microsoft.VisualBasic.Devices.ServerComputer.Registry() -> Microsoft.VisualBasic.MyServices.RegistryProxy
-Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption
-Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption.DiscardMessages = 1 -> Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption
-Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption.ThrowException = 0 -> Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption
-Microsoft.VisualBasic.Logging.FileLogTraceListener
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Append() -> Boolean
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Append(value As Boolean) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.AutoFlush() -> Boolean
-Microsoft.VisualBasic.Logging.FileLogTraceListener.AutoFlush(value As Boolean) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.BaseFileName() -> String
-Microsoft.VisualBasic.Logging.FileLogTraceListener.BaseFileName(value As String) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.CustomLocation() -> String
-Microsoft.VisualBasic.Logging.FileLogTraceListener.CustomLocation(value As String) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Delimiter() -> String
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Delimiter(value As String) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.DiskSpaceExhaustedBehavior() -> Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption
-Microsoft.VisualBasic.Logging.FileLogTraceListener.DiskSpaceExhaustedBehavior(value As Microsoft.VisualBasic.Logging.DiskSpaceExhaustedOption) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Encoding() -> System.Text.Encoding
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Encoding(value As System.Text.Encoding) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.FullLogFileName() -> String
-Microsoft.VisualBasic.Logging.FileLogTraceListener.IncludeHostName() -> Boolean
-Microsoft.VisualBasic.Logging.FileLogTraceListener.IncludeHostName(value As Boolean) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Location() -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.FileLogTraceListener.Location(value As Microsoft.VisualBasic.Logging.LogFileLocation) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.LogFileCreationSchedule() -> Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption
-Microsoft.VisualBasic.Logging.FileLogTraceListener.LogFileCreationSchedule(value As Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.MaxFileSize() -> Long
-Microsoft.VisualBasic.Logging.FileLogTraceListener.MaxFileSize(value As Long) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.New() -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.New(name As String) -> Void
-Microsoft.VisualBasic.Logging.FileLogTraceListener.ReserveDiskSpace() -> Long
-Microsoft.VisualBasic.Logging.FileLogTraceListener.ReserveDiskSpace(value As Long) -> Void
-Microsoft.VisualBasic.Logging.Log
-Microsoft.VisualBasic.Logging.Log.DefaultFileLogWriter() -> Microsoft.VisualBasic.Logging.FileLogTraceListener
-Microsoft.VisualBasic.Logging.Log.New() -> Void
-Microsoft.VisualBasic.Logging.Log.New(name As String) -> Void
-Microsoft.VisualBasic.Logging.Log.TraceSource() -> System.Diagnostics.TraceSource
-Microsoft.VisualBasic.Logging.Log.WriteEntry(message As String) -> Void
-Microsoft.VisualBasic.Logging.Log.WriteEntry(message As String, severity As System.Diagnostics.TraceEventType) -> Void
-Microsoft.VisualBasic.Logging.Log.WriteEntry(message As String, severity As System.Diagnostics.TraceEventType, id As Integer) -> Void
-Microsoft.VisualBasic.Logging.Log.WriteException(ex As System.Exception) -> Void
-Microsoft.VisualBasic.Logging.Log.WriteException(ex As System.Exception, severity As System.Diagnostics.TraceEventType, additionalInfo As String) -> Void
-Microsoft.VisualBasic.Logging.Log.WriteException(ex As System.Exception, severity As System.Diagnostics.TraceEventType, additionalInfo As String, id As Integer) -> Void
-Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption
-Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption.Daily = 1 -> Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption
-Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption.None = 0 -> Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption
-Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption.Weekly = 2 -> Microsoft.VisualBasic.Logging.LogFileCreationScheduleOption
-Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.LogFileLocation.CommonApplicationDirectory = 2 -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.LogFileLocation.Custom = 4 -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.LogFileLocation.ExecutableDirectory = 3 -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.LogFileLocation.LocalUserApplicationDirectory = 1 -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.Logging.LogFileLocation.TempDirectory = 0 -> Microsoft.VisualBasic.Logging.LogFileLocation
-Microsoft.VisualBasic.MyServices.ClipboardProxy
-Microsoft.VisualBasic.MyServices.ClipboardProxy.Clear() -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsAudio() -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsData(format As String) -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsFileDropList() -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsImage() -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsText() -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.ContainsText(format As System.Windows.Forms.TextDataFormat) -> Boolean
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetAudioStream() -> System.IO.Stream
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetData(format As String) -> Object
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetDataObject() -> System.Windows.Forms.IDataObject
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetFileDropList() -> System.Collections.Specialized.StringCollection
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetImage() -> System.Drawing.Image
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetText() -> String
-Microsoft.VisualBasic.MyServices.ClipboardProxy.GetText(format As System.Windows.Forms.TextDataFormat) -> String
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetAudio(audioBytes As Byte()) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetAudio(audioStream As System.IO.Stream) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetData(format As String, data As Object) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetDataObject(data As System.Windows.Forms.DataObject) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetFileDropList(filePaths As System.Collections.Specialized.StringCollection) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetImage(image As System.Drawing.Image) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetText(text As String) -> Void
-Microsoft.VisualBasic.MyServices.ClipboardProxy.SetText(text As String, format As System.Windows.Forms.TextDataFormat) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CombinePath(baseDirectory As String, relativePath As String) -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyFile(sourceFileName As String, destinationFileName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyFile(sourceFileName As String, destinationFileName As String, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyFile(sourceFileName As String, destinationFileName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CopyFile(sourceFileName As String, destinationFileName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CreateDirectory(directory As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CurrentDirectory() -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.CurrentDirectory(value As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteDirectory(directory As String, onDirectoryNotEmpty As Microsoft.VisualBasic.FileIO.DeleteDirectoryOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteDirectory(directory As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, recycle As Microsoft.VisualBasic.FileIO.RecycleOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteDirectory(directory As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, recycle As Microsoft.VisualBasic.FileIO.RecycleOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteFile(file As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteFile(file As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, recycle As Microsoft.VisualBasic.FileIO.RecycleOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DeleteFile(file As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, recycle As Microsoft.VisualBasic.FileIO.RecycleOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.DirectoryExists(directory As String) -> Boolean
-Microsoft.VisualBasic.MyServices.FileSystemProxy.Drives() -> System.Collections.ObjectModel.ReadOnlyCollection(Of System.IO.DriveInfo)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.FileExists(file As String) -> Boolean
-Microsoft.VisualBasic.MyServices.FileSystemProxy.FindInFiles(directory As String, containsText As String, ignoreCase As Boolean, searchType As Microsoft.VisualBasic.FileIO.SearchOption) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.FindInFiles(directory As String, containsText As String, ignoreCase As Boolean, searchType As Microsoft.VisualBasic.FileIO.SearchOption, ParamArray fileWildcards As String()) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetDirectories(directory As String) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetDirectories(directory As String, searchType As Microsoft.VisualBasic.FileIO.SearchOption, ParamArray wildcards As String()) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetDirectoryInfo(directory As String) -> System.IO.DirectoryInfo
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetDriveInfo(drive As String) -> System.IO.DriveInfo
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetFileInfo(file As String) -> System.IO.FileInfo
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetFiles(directory As String) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetFiles(directory As String, searchType As Microsoft.VisualBasic.FileIO.SearchOption, ParamArray wildcards As String()) -> System.Collections.ObjectModel.ReadOnlyCollection(Of String)
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetName(path As String) -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetParentPath(path As String) -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.GetTempFileName() -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveDirectory(sourceDirectoryName As String, destinationDirectoryName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveFile(sourceFileName As String, destinationFileName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveFile(sourceFileName As String, destinationFileName As String, overwrite As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveFile(sourceFileName As String, destinationFileName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.MoveFile(sourceFileName As String, destinationFileName As String, showUI As Microsoft.VisualBasic.FileIO.UIOption, onUserCancel As Microsoft.VisualBasic.FileIO.UICancelOption) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFieldParser(file As String) -> Microsoft.VisualBasic.FileIO.TextFieldParser
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFieldParser(file As String, ParamArray delimiters As String()) -> Microsoft.VisualBasic.FileIO.TextFieldParser
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFieldParser(file As String, ParamArray fieldWidths As Integer()) -> Microsoft.VisualBasic.FileIO.TextFieldParser
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFileReader(file As String) -> System.IO.StreamReader
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFileReader(file As String, encoding As System.Text.Encoding) -> System.IO.StreamReader
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFileWriter(file As String, append As Boolean) -> System.IO.StreamWriter
-Microsoft.VisualBasic.MyServices.FileSystemProxy.OpenTextFileWriter(file As String, append As Boolean, encoding As System.Text.Encoding) -> System.IO.StreamWriter
-Microsoft.VisualBasic.MyServices.FileSystemProxy.ReadAllBytes(file As String) -> Byte()
-Microsoft.VisualBasic.MyServices.FileSystemProxy.ReadAllText(file As String) -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.ReadAllText(file As String, encoding As System.Text.Encoding) -> String
-Microsoft.VisualBasic.MyServices.FileSystemProxy.RenameDirectory(directory As String, newName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.RenameFile(file As String, newName As String) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.SpecialDirectories() -> Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy
-Microsoft.VisualBasic.MyServices.FileSystemProxy.WriteAllBytes(file As String, data As Byte(), append As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.WriteAllText(file As String, text As String, append As Boolean) -> Void
-Microsoft.VisualBasic.MyServices.FileSystemProxy.WriteAllText(file As String, text As String, append As Boolean, encoding As System.Text.Encoding) -> Void
-Microsoft.VisualBasic.MyServices.Internal.ContextValue(Of T)
-Microsoft.VisualBasic.MyServices.Internal.ContextValue(Of T).New() -> Void
-Microsoft.VisualBasic.MyServices.Internal.ContextValue(Of T).Value() -> T
-Microsoft.VisualBasic.MyServices.Internal.ContextValue(Of T).Value(value As T) -> Void
-Microsoft.VisualBasic.MyServices.RegistryProxy
-Microsoft.VisualBasic.MyServices.RegistryProxy.ClassesRoot() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.RegistryProxy.CurrentConfig() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.RegistryProxy.CurrentUser() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.RegistryProxy.GetValue(keyName As String, valueName As String, defaultValue As Object) -> Object
-Microsoft.VisualBasic.MyServices.RegistryProxy.LocalMachine() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.RegistryProxy.PerformanceData() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.RegistryProxy.SetValue(keyName As String, valueName As String, value As Object) -> Void
-Microsoft.VisualBasic.MyServices.RegistryProxy.SetValue(keyName As String, valueName As String, value As Object, valueKind As Microsoft.Win32.RegistryValueKind) -> Void
-Microsoft.VisualBasic.MyServices.RegistryProxy.Users() -> Microsoft.Win32.RegistryKey
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.AllUsersApplicationData() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.CurrentUserApplicationData() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.Desktop() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.MyDocuments() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.MyMusic() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.MyPictures() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.ProgramFiles() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.Programs() -> String
-Microsoft.VisualBasic.MyServices.SpecialDirectoriesProxy.Temp() -> String
-Overridable Microsoft.VisualBasic.ApplicationServices.User.InternalPrincipal() -> System.Security.Principal.IPrincipal
-Overridable Microsoft.VisualBasic.ApplicationServices.User.InternalPrincipal(value As System.Security.Principal.IPrincipal) -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnCreateMainForm() -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnCreateSplashScreen() -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnInitialize(commandLineArgs As System.Collections.ObjectModel.ReadOnlyCollection(Of String)) -> Boolean
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnRun() -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnShutdown() -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnStartup(eventArgs As Microsoft.VisualBasic.ApplicationServices.StartupEventArgs) -> Boolean
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnStartupNextInstance(eventArgs As Microsoft.VisualBasic.ApplicationServices.StartupNextInstanceEventArgs) -> Void
-Overridable Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.OnUnhandledException(e As Microsoft.VisualBasic.ApplicationServices.UnhandledExceptionEventArgs) -> Boolean
-Overridable Microsoft.VisualBasic.Logging.Log.InitializeWithDefaultsSinceNoConfigExists() -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.Close() -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.Dispose(disposing As Boolean) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.Flush() -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.GetSupportedAttributes() -> String()
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.TraceData(eventCache As System.Diagnostics.TraceEventCache, source As String, eventType As System.Diagnostics.TraceEventType, id As Integer, data As Object) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.TraceData(eventCache As System.Diagnostics.TraceEventCache, source As String, eventType As System.Diagnostics.TraceEventType, id As Integer, ParamArray data As Object()) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.TraceEvent(eventCache As System.Diagnostics.TraceEventCache, source As String, eventType As System.Diagnostics.TraceEventType, id As Integer, format As String, ParamArray args As Object()) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.TraceEvent(eventCache As System.Diagnostics.TraceEventCache, source As String, eventType As System.Diagnostics.TraceEventType, id As Integer, message As String) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.Write(message As String) -> Void
-Overrides Microsoft.VisualBasic.Logging.FileLogTraceListener.WriteLine(message As String) -> Void
-Shared Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase.UseCompatibleTextRendering() -> Boolean
-Shared Microsoft.VisualBasic.CompilerServices.HostServices.VBHost() -> Microsoft.VisualBasic.CompilerServices.IVbHost
-Shared Microsoft.VisualBasic.CompilerServices.HostServices.VBHost(Value As Microsoft.VisualBasic.CompilerServices.IVbHost) -> Void
diff --git a/src/Microsoft.VisualBasic.Forms/src/PublicAPI.Unshipped.txt b/src/Microsoft.VisualBasic.Forms/src/PublicAPI.Unshipped.txt
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/VBInputBox.resx b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/VBInputBox.resx
deleted file mode 100644
index 09f45adb611..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/VBInputBox.resx
+++ /dev/null
@@ -1,261 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="OKButton.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>Assembly</value>
-    <comment />
-  </metadata>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="OKButton.Location" type="System.Drawing.Point, System.Drawing">
-    <value>290, 12</value>
-    <comment />
-  </data>
-  <data name="OKButton.Size" type="System.Drawing.Size, System.Drawing">
-    <value>60, 22</value>
-    <comment />
-  </data>
-  <assembly alias="mscorlib" name="mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="OKButton.TabIndex" type="System.Int32, mscorlib">
-    <value>2</value>
-    <comment />
-  </data>
-  <data name="OKButton.Text">
-    <value>OK</value>
-  </data>
-  <data name="&gt;&gt;OKButton.Name">
-    <value>OKButton</value>
-  </data>
-  <data name="&gt;&gt;OKButton.Type">
-    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;OKButton.Parent">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;OKButton.ZOrder">
-    <value>2</value>
-  </data>
-  <metadata name="MyCancelButton.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>Assembly</value>
-    <comment />
-  </metadata>
-  <data name="MyCancelButton.Location" type="System.Drawing.Point, System.Drawing">
-    <value>290, 40</value>
-    <comment />
-  </data>
-  <data name="MyCancelButton.Size" type="System.Drawing.Size, System.Drawing">
-    <value>60, 22</value>
-    <comment />
-  </data>
-  <data name="MyCancelButton.TabIndex" type="System.Int32, mscorlib">
-    <value>3</value>
-    <comment />
-  </data>
-  <data name="MyCancelButton.Text">
-    <value>Cancel</value>
-  </data>
-  <data name="&gt;&gt;MyCancelButton.Name">
-    <value>MyCancelButton</value>
-  </data>
-  <data name="&gt;&gt;MyCancelButton.Type">
-    <value>System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;MyCancelButton.Parent">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;MyCancelButton.ZOrder">
-    <value>3</value>
-  </data>
-  <metadata name="TextBox.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>Assembly</value>
-    <comment />
-  </metadata>
-  <data name="TextBox.Location" type="System.Drawing.Point, System.Drawing">
-    <value>10, 90</value>
-    <comment />
-  </data>
-  <data name="TextBox.Size" type="System.Drawing.Size, System.Drawing">
-    <value>335, 20</value>
-    <comment />
-  </data>
-  <data name="TextBox.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-    <comment />
-  </data>
-  <data name="&gt;&gt;TextBox.Name">
-    <value>TextBox</value>
-  </data>
-  <data name="&gt;&gt;TextBox.Type">
-    <value>System.Windows.Forms.TextBox, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;TextBox.Parent">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;TextBox.ZOrder">
-    <value>0</value>
-  </data>
-  <metadata name="Label.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>Assembly</value>
-    <comment />
-  </metadata>
-  <data name="Label.Location" type="System.Drawing.Point, System.Drawing">
-    <value>10, 10</value>
-    <comment />
-  </data>
-  <data name="Label.Size" type="System.Drawing.Size, System.Drawing">
-    <value>250, 70</value>
-    <comment />
-  </data>
-  <data name="Label.TabIndex" type="System.Int32, mscorlib">
-    <value>1</value>
-    <comment />
-  </data>
-  <data name="&gt;&gt;Label.Name">
-    <value>Label</value>
-  </data>
-  <data name="&gt;&gt;Label.Type">
-    <value>System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;Label.Parent">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;Label.ZOrder">
-    <value>1</value>
-  </data>
-  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-    <comment />
-  </metadata>
-  <data name="$this.AutoScaleBaseSize" type="System.Drawing.Size, System.Drawing">
-    <value>5, 13</value>
-    <comment />
-  </data>
-  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
-    <value>353, 120</value>
-    <comment />
-  </data>
-  <data name="&gt;&gt;$this.Name">
-    <value>VBInputBox</value>
-  </data>
-  <data name="&gt;&gt;$this.Type">
-    <value>System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="Label.Text">
-    <value>#</value>
-  </data>
-  <data name="$this.Text">
-    <value>#</value>
-  </data>
-</root>
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.cs.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.cs.xlf
deleted file mode 100644
index 1595dc80b9b..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.cs.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">Počet</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">Počet</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Storno</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.de.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.de.xlf
deleted file mode 100644
index 09475693772..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.de.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Abbrechen</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.es.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.es.xlf
deleted file mode 100644
index e3e0a82d4f4..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.es.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Cancelar</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">Aceptar</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.fr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.fr.xlf
deleted file mode 100644
index 68325a22abf..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.fr.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Annuler</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.it.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.it.xlf
deleted file mode 100644
index 6a1faa9c4a0..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.it.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Annulla</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ja.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ja.xlf
deleted file mode 100644
index 443ddf1b5dd..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ja.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">キャンセル</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ko.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ko.xlf
deleted file mode 100644
index db627da614c..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ko.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">취소</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">확인</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pl.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pl.xlf
deleted file mode 100644
index 844f80b32c1..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pl.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Anuluj</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pt-BR.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pt-BR.xlf
deleted file mode 100644
index 49bd9d75d52..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.pt-BR.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Cancelar</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">OK</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ru.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ru.xlf
deleted file mode 100644
index 2b53f680dda..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.ru.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">№</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">№</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">Отмена</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">ОК</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.tr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.tr.xlf
deleted file mode 100644
index 86996f05dae..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.tr.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">İptal</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">Tamam</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hans.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hans.xlf
deleted file mode 100644
index 5de0b4812e9..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hans.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">取消</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">确定</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hant.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hant.xlf
deleted file mode 100644
index 401c9857792..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/CompilerServices/xlf/VBInputBox.zh-Hant.xlf
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../VBInputBox.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Label.Text">
-        <source>#</source>
-        <target state="translated">#</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MyCancelButton.Text">
-        <source>Cancel</source>
-        <target state="translated">取消</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="OKButton.Text">
-        <source>OK</source>
-        <target state="translated">確定</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.resx b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.resx
deleted file mode 100644
index f7a3ca9ebda..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/ProgressDialog.resx
+++ /dev/null
@@ -1,218 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="LabelInfo.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
-    <value>Top, Left, Right</value>
-  </data>
-  <assembly alias="mscorlib" name="mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="LabelInfo.AutoSize" type="System.Boolean, mscorlib">
-    <value>True</value>
-  </data>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="LabelInfo.Location" type="System.Drawing.Point, System.Drawing">
-    <value>10, 23</value>
-  </data>
-  <data name="LabelInfo.Size" type="System.Drawing.Size, System.Drawing">
-    <value>350, 39</value>
-  </data>
-  <data name="LabelInfo.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="LabelInfo.Text">
-    <value xml:space="preserve">Progress Dialog</value>
-  </data>
-  <data name="&gt;&gt;LabelInfo.Name">
-    <value xml:space="preserve">LabelInfo</value>
-  </data>
-  <data name="&gt;&gt;LabelInfo.Type">
-    <value xml:space="preserve">System.Windows.Forms.Label, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;LabelInfo.Parent">
-    <value xml:space="preserve">$this</value>
-  </data>
-  <data name="&gt;&gt;LabelInfo.ZOrder">
-    <value xml:space="preserve">2</value>
-  </data>
-  <data name="ProgressBarWork.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
-    <value>Top, Left, Right</value>
-  </data>
-  <data name="ProgressBarWork.Location" type="System.Drawing.Point, System.Drawing">
-    <value>10, 78</value>
-  </data>
-  <data name="ProgressBarWork.Size" type="System.Drawing.Size, System.Drawing">
-    <value>268, 12</value>
-  </data>
-  <data name="ProgressBarWork.TabIndex" type="System.Int32, mscorlib">
-    <value>1</value>
-  </data>
-  <data name="&gt;&gt;ProgressBarWork.Name">
-    <value xml:space="preserve">ProgressBarWork</value>
-  </data>
-  <data name="&gt;&gt;ProgressBarWork.Type">
-    <value xml:space="preserve">System.Windows.Forms.ProgressBar, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;ProgressBarWork.Parent">
-    <value xml:space="preserve">$this</value>
-  </data>
-  <data name="&gt;&gt;ProgressBarWork.ZOrder">
-    <value xml:space="preserve">1</value>
-  </data>
-  <data name="ButtonCloseDialog.Anchor" type="System.Windows.Forms.AnchorStyles, System.Windows.Forms">
-    <value>Top, Right</value>
-  </data>
-  <data name="ButtonCloseDialog.AutoSize" type="System.Boolean, mscorlib">
-    <value>True</value>
-  </data>
-  <data name="ButtonCloseDialog.Location" type="System.Drawing.Point, System.Drawing">
-    <value>286, 78</value>
-  </data>
-  <data name="ButtonCloseDialog.TabIndex" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="ButtonCloseDialog.Text">
-    <value xml:space="preserve">&amp;Cancel</value>
-  </data>
-  <data name="&gt;&gt;ButtonCloseDialog.Name">
-    <value xml:space="preserve">ButtonCloseDialog</value>
-  </data>
-  <data name="&gt;&gt;ButtonCloseDialog.Type">
-    <value xml:space="preserve">System.Windows.Forms.Button, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;ButtonCloseDialog.Parent">
-    <value xml:space="preserve">$this</value>
-  </data>
-  <data name="&gt;&gt;ButtonCloseDialog.ZOrder">
-    <value xml:space="preserve">0</value>
-  </data>
-  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <data name="$this.AutoScaleBaseSize" type="System.Drawing.Size, System.Drawing">
-    <value>5, 13</value>
-  </data>
-  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
-    <value>373, 109</value>
-  </data>
-  <data name="$this.Text">
-    <value xml:space="preserve">ProgressDialog</value>
-  </data>
-  <data name="&gt;&gt;$this.Name">
-    <value xml:space="preserve">ProgressDialog</value>
-  </data>
-  <data name="&gt;&gt;$this.Type">
-    <value xml:space="preserve">System.Windows.Forms.Form, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-</root>
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.cs.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.cs.xlf
deleted file mode 100644
index 913b35d1e16..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.cs.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Zrušit</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Dialogové okno průběhu</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.de.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.de.xlf
deleted file mode 100644
index 4e598b49b87..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.de.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">Abbre&amp;chen</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Fortschrittsdialogfeld</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.es.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.es.xlf
deleted file mode 100644
index e57c421f31d..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.es.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Cancelar</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Cuadro de diálogo de progreso</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.fr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.fr.xlf
deleted file mode 100644
index a872b4dc181..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.fr.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Annuler</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Boîte de dialogue Avancement</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.it.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.it.xlf
deleted file mode 100644
index df0031893e3..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.it.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Annulla</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Finestra di dialogo Stato</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ja.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ja.xlf
deleted file mode 100644
index 14c63ad209b..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ja.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">キャンセル(&amp;C)</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">進行状況ダイアログ</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ko.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ko.xlf
deleted file mode 100644
index 830107eee30..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ko.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">취소(&amp;C)</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">진행률 대화 상자</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pl.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pl.xlf
deleted file mode 100644
index 7742cd3e772..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pl.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Anuluj</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Okno dialogowe postępu</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pt-BR.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pt-BR.xlf
deleted file mode 100644
index 57dca7cd4fd..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.pt-BR.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Cancelar</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Caixa de Diálogo de Progresso</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ru.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ru.xlf
deleted file mode 100644
index 7f6918a0b35..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.ru.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;Отмена</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">Индикатор выполнения</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.tr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.tr.xlf
deleted file mode 100644
index d3797593724..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.tr.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">&amp;İptal</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">İlerleme İletişim Kutusu</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hans.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hans.xlf
deleted file mode 100644
index 02995022f7a..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hans.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">取消(&amp;C)</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">进度对话框</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hant.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hant.xlf
deleted file mode 100644
index 8024e79328a..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/Microsoft/VisualBasic/MyServices/Internal/xlf/ProgressDialog.zh-Hant.xlf
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../ProgressDialog.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>ProgressDialog</source>
-        <target state="translated">ProgressDialog</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ButtonCloseDialog.Text">
-        <source>&amp;Cancel</source>
-        <target state="translated">取消(&amp;C)</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="LabelInfo.Text">
-        <source>Progress Dialog</source>
-        <target state="translated">進度對話方塊</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/SR.resx b/src/Microsoft.VisualBasic.Forms/src/Resources/SR.resx
deleted file mode 100644
index ff406c3aee6..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/SR.resx
+++ /dev/null
@@ -1,224 +0,0 @@
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="ID53" xml:space="preserve">
-    <value>File not found.</value>
-  </data>
-  <data name="ID70" xml:space="preserve">
-    <value>Permission denied.</value>
-  </data>
-  <data name="Argument_InvalidValue1" xml:space="preserve">
-    <value>Argument '{0}' is not a valid value.</value>
-  </data>
-  <data name="Argument_InvalidValueType2" xml:space="preserve">
-    <value>Argument '{0}' cannot be converted to type '{1}'.</value>
-  </data>
-  <data name="Argument_InvalidNullValue1" xml:space="preserve">
-    <value>Argument '{0}' is Nothing.</value>
-  </data>
-  <data name="ProcessNotFound" xml:space="preserve">
-    <value>Process '{0}' was not found.</value>
-  </data>
-  <data name="Mouse_NoMouseIsPresent" xml:space="preserve">
-    <value>No mouse is present.</value>
-  </data>
-  <data name="Mouse_NoWheelIsPresent" xml:space="preserve">
-    <value>No mouse wheel is present.</value>
-  </data>
-  <data name="IO_FileExists_Path" xml:space="preserve">
-    <value>Could not complete operation since a file already exists in this path '{0}'.</value>
-  </data>
-  <data name="IO_FileNotFound_Path" xml:space="preserve">
-    <value>Could not find file '{0}'.</value>
-  </data>
-  <data name="IO_FilePathException" xml:space="preserve">
-    <value>The given file path ends with a directory separator character.</value>
-  </data>
-  <data name="General_ArgumentNullException" xml:space="preserve">
-    <value>Argument cannot be Nothing.</value>
-  </data>
-  <data name="General_PropertyNothing" xml:space="preserve">
-    <value>Property {0} cannot be set to Nothing.</value>
-  </data>
-  <data name="ApplicationLog_FreeSpaceError" xml:space="preserve">
-    <value>Cannot determine the amount of available disk space.</value>
-  </data>
-  <data name="ApplicationLog_FileExceedsMaximumSize" xml:space="preserve">
-    <value>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</value>
-  </data>
-  <data name="ApplicationLog_ReservedSpaceEncroached" xml:space="preserve">
-    <value>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</value>
-  </data>
-  <data name="ApplicationLog_NegativeNumber" xml:space="preserve">
-    <value>The value of {0} must be a positive number.</value>
-  </data>
-  <data name="ApplicationLogBaseNameNull" xml:space="preserve">
-    <value>BaseFileName cannot be Nothing or an empty String.</value>
-  </data>
-  <data name="ApplicationLogNumberTooSmall" xml:space="preserve">
-    <value>The value of {0} must be greater than or equal to 1000.</value>
-  </data>
-  <data name="ApplicationLog_ExhaustedPossibleStreamNames" xml:space="preserve">
-    <value>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</value>
-  </data>
-  <data name="Network_InvalidUriString" xml:space="preserve">
-    <value>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</value>
-  </data>
-  <data name="Network_BadConnectionTimeout" xml:space="preserve">
-    <value>The ConnectionTimeout must be greater than 0.</value>
-  </data>
-  <data name="Network_NetworkNotAvailable" xml:space="preserve">
-    <value>Unable to ping because a network connection is not available.</value>
-  </data>
-  <data name="Network_UploadAddressNeedsFilename" xml:space="preserve">
-    <value>The address for UploadFile needs to include a file name.</value>
-  </data>
-  <data name="Network_DownloadNeedsFilename" xml:space="preserve">
-    <value>destinationFileName needs to include a file name.</value>
-  </data>
-  <data name="ProgressDialogDownloadingTitle" xml:space="preserve">
-    <value>Downloading {0}</value>
-  </data>
-  <data name="ProgressDialogUploadingTitle" xml:space="preserve">
-    <value>Uploading {0}</value>
-  </data>
-  <data name="ProgressDialogDownloadingLabel" xml:space="preserve">
-    <value>Downloading {0} to {1}</value>
-  </data>
-  <data name="ProgressDialogUploadingLabel" xml:space="preserve">
-    <value>Uploading {0} to {1}</value>
-  </data>
-  <data name="DiagnosticInfo_Memory" xml:space="preserve">
-    <value>Could not obtain memory information due to internal error.</value>
-  </data>
-  <data name="DiagnosticInfo_FullOSName" xml:space="preserve">
-    <value>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</value>
-  </data>
-  <data name="AppModel_NoStartupForm" xml:space="preserve">
-    <value>A startup form has not been specified.</value>
-  </data>
-  <data name="AppModel_SingleInstanceCantConnect" xml:space="preserve">
-    <value>This single-instance application could not connect to the original instance.</value>
-  </data>
-  <data name="AppModel_SplashAndMainFormTheSame" xml:space="preserve">
-    <value>Splash screen and main form cannot be the same form.</value>
-  </data>
-  <data name="EnvVarNotFound_Name" xml:space="preserve">
-    <value>Environment variable is not defined: '{0}'.</value>
-  </data>
-</root>
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.cs.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.cs.xlf
deleted file mode 100644
index f737611c412..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.cs.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Nebyl zadán formulář spuštění.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Tato aplikace s jedinou instancí se nemůže připojit k původní instanci.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Formulář úvodní obrazovky a hlavní formulář nemohou být stejné.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName nemůže být prázdná hodnota (Nothing) nebo prázdný řetězec (String).</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">Hodnota {0} musí být větší nebo rovna 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Nelze získat datový proud pro protokol. Potenciální názvy souborů založené na {0} se již používají.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Nelze zapisovat do souboru protokolu, protože při zápisu by došlo k překročení hodnoty MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Nelze určit velikost dostupného místa na disku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">Hodnota {0} musí být kladné číslo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Nelze zapisovat do souboru protokolu, protože při zápisu by došlo ke snížení volného místa na disku určeného hodnotou ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">Argument {0} má hodnotu Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">Argument {0} nemá platnou hodnotu.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">Argument {0} nelze převést na typ {1}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Nelze získat úplný název operačního systému, protože došlo k vnitřní chybě. Pravděpodobnou příčinou je to, že v počítači není nainstalována služba WMI.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Nelze získat informace o paměti, protože došlo k vnitřní chybě.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Není definována proměnná prostředí: {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">Argument nemůže být prázdná hodnota (Nothing).</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">Vlastnost {0} nemůže být nastavena na hodnotu Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Soubor se nepovedlo najít.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Oprávnění byla odepřena.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Nelze provést operaci, protože soubor již existuje v této cestě {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Soubor {0} nebyl nalezen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Zadaná cesta k souboru končí znakem oddělovače adresářů.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Není připojena myš.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Nebylo nalezeno kolečko myši.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">Hodnota ConnectionTimeout musí být větší než 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName musí obsahovat název souboru.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">{0} není platná adresa vzdáleného souboru. Platná adresa musí obsahovat protokol, cestu a název k souboru.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Nelze provést test pomocí příkazu ping, protože k dispozici není připojení k síti.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">Adresa pro UploadFile musí zahrnovat název souboru.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Proces {0} nebyl nalezen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Stahování {0} do {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Stahuje se {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Ukládání {0} do {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Ukládání {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.de.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.de.xlf
deleted file mode 100644
index e4e2a7e5e3e..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.de.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Es wurde kein Startformular angegeben.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Diese Einzelinstanzanwendung konnte keine Verbindung zur ursprünglichen Instanz herstellen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Das Formular für den Begrüßungsbildschirm und das Hauptformular dürfen nicht identisch sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName kann nicht "Nothing" oder eine leere Zeichenfolge sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">Der Wert von {0} muss größer als oder gleich 1000 sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Für das Protokoll kann kein Stream abgerufen werden. Die auf {0} basierenden potenziellen Dateinamen werden bereits verwendet.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">In der Protokolldatei kann nicht geschrieben werden, weil dies dazu führen würde, dass sie den MaxFileSize-Wert überschreitet.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Der freie Speicherplatz auf dem Datenträger kann nicht bestimmt werden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">Der Wert von {0} muss eine positive Zahl sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Die Protokolldatei kann nicht geschrieben werden, weil das Schreiben in dieser Datei dazu führen würde, dass der freie Speicherplatz auf dem Datenträger unter den ReservedSpace-Wert absinkt.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">Das Argument {0} ist "Nothing".</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">Das Argument {0} ist kein gültiger Wert.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">Das Argument {0} kann nicht in den Typ {1} umgewandelt werden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Interner Fehler. Der vollständige Betriebssystemname konnte nicht abgerufen werden. Mögliche Ursache: Auf dem aktuellen Computer ist keine WMI vorhanden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Interner Fehler. Die Speicherinformationen konnten nicht abgerufen werden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Die Umgebungsvariable wurde nicht definiert: {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">Das Argument kann nicht "Nothing" sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">Die Eigenschaft {0} kann nicht auf "Nothing" festgelegt werden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Datei nicht gefunden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Berechtigung verweigert.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Der Vorgang konnte nicht abgeschlossen werden, da bereits eine Datei im Pfad {0} vorhanden ist.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Die Datei "{0}" konnte nicht gefunden werden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Der angegebene Pfad endet mit einem Verzeichnistrennzeichen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Es ist keine Maus vorhanden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Es ist kein Mausrad vorhanden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">Der Verbindungstimeout-Wert muss größer als 0 sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">In destinationFileName muss ein Dateiname enthalten sein.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">"{0}" ist keine gültige Remotedateiadresse. Eine gültige Adresse muss ein Protokoll, einen Pfad und einen Dateinamen enthalten.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Pingfehler. Es ist keine Netzwerkverbindung verfügbar.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">Die Adresse für UploadFile muss einen Dateinamen enthalten.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Der Prozess {0} wurde nicht gefunden.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">{0} wird nach {1} heruntergeladen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">{0} wird heruntergeladen</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">{0} wird nach {1} hochgeladen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">{0} wird hochgeladen</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.es.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.es.xlf
deleted file mode 100644
index 006fe62ea7d..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.es.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">No se ha especificado un formulario de inicio.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Esta aplicación de una sola instancia no pudo conectar con la instancia original.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">La pantalla de presentación y el formulario principal no pueden ser el mismo formulario.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName no puede ser Nothing o un tipo String vacío.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">El valor de {0} debe ser mayor o igual que 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">No se pudo obtener una secuencia para el registro. Los nombres de archivo potenciales que se basan en {0} ya están en uso.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">No se puede escribir en el archivo de registro porque se superaría el valor MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">No se puede determinar la cantidad de espacio en disco disponible.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">El valor de {0} debe ser un número positivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">No se puede escribir en el archivo de registro porque el espacio en disco disponible pasaría a ser inferior al valor ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">El argumento '{0}' tiene un valor Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">El argumento '{0}' es un valor no válido.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">El argumento '{0}' no se puede convertir en el tipo '{1}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">No se pudo obtener el nombre del sistema operativo completo debido a un error interno. La causa puede deberse a que WMI no existe en el equipo actual.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">No se pudo obtener la información de memoria debido a un error interno.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Variable de entorno no definida: '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">El argumento no puede ser Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">La propiedad {0} no se puede establecer en Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">No se encontró el archivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Permiso denegado.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">No se pudo completar la operación porque ya existe un archivo en esta ruta de acceso '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">No se pudo encontrar el archivo '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">La ruta de acceso de archivo dada termina con un carácter separador de directorio.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">No hay un mouse presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">No hay rueda de mouse presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout debe ser mayor que 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">Es necesario incluir un nombre de archivo en destinationFileName.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' no es una dirección de archivo remoto válida. Una dirección válida debe incluir un protocolo, una ruta de acceso y un nombre de archivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">No se puede ejecutar el comando ping porque no hay disponible ninguna conexión de red.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">La dirección de UploadFile necesita incluir un nombre de archivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">No se encuentra el proceso '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Descargando {0} en {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Descargando {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Cargando {0} en {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Cargando {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.fr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.fr.xlf
deleted file mode 100644
index 3e06f665f6a..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.fr.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Un formulaire de démarrage n'a pas été spécifié.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Impossible de connecter cette application à instance unique à l'instance d'origine.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">L'écran de démarrage et le formulaire principal ne peuvent pas être le même formulaire.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName ne peut pas être Nothing ou un String vide.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">La valeur de {0} doit être supérieure ou égale à 1 000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Impossible d'obtenir un flux pour le journal. Des noms de fichiers éventuels fondés sur {0} sont déjà utilisés.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Impossible d'écrire dans le fichier journal, car cette opération entraînerait un dépassement de la valeur MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Impossible de déterminer la quantité d'espace disque disponible.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">La valeur de {0} doit être un nombre positif.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Impossible d'écrire dans le fichier journal, car la quantité d'espace disque libre deviendrait alors inférieure à la valeur ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">L'argument '{0}' a la valeur Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">L'argument '{0}' n'est pas une valeur valide.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">L'argument '{0}' ne peut pas être converti en type '{1}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Impossible d'obtenir le nom complet du système d'exploitation en raison d'une erreur interne. Ceci peut être dû au fait que WMI est absent de l'ordinateur actuel.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Impossible d'obtenir des informations sur la mémoire en raison d'une erreur interne.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Variable d'environnement non définie : '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">L'argument ne peut pas avoir la valeur Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">La propriété {0} ne peut pas avoir la valeur Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Fichier introuvable.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Autorisation refusée.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Impossible d'achever l'opération, car un fichier figure déjà dans ce chemin d'accès '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Impossible de trouver le fichier '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Le chemin d'accès de fichier spécifié se termine par un caractère de séparation de répertoire.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Absence de souris.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Absence de roulette de souris.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">Le ConnectionTimeout doit être supérieur à 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName doit inclure un nom de fichier.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' n'est pas une adresse valide de fichier distant. Une adresse valide doit inclure un protocole, un chemin d'accès et un nom de fichier.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Impossible d'exécuter la commande PING, car une connexion réseau n'est pas disponible.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">L'adresse de UploadFile doit inclure un nom de fichier.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Le processus '{0}' est introuvable.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Téléchargement de {0} sur {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Téléchargement de {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Transfert de {0} sur {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Chargement de {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.it.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.it.xlf
deleted file mode 100644
index cc73272c979..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.it.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Non è stato specificato un form di avvio.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Impossibile connettere l'applicazione a istanza singola con l'istanza originale.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">La schermata iniziale e il form principale non possono avere lo stesso formato.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName non può essere Nothing o una stringa vuota.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">Il valore di {0} deve essere maggiore o uguale a 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Impossibile ottenere un flusso per il log. I possibili nome di file basati su {0} sono già in uso.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Impossibile scrivere nel file di log. Verrebbe superato il valore MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Impossibile determinare la quantità di spazio libero su disco.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">Il valore di {0} deve essere un numero positivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Impossibile scrivere nel file di log. Lo spazio libero su disco risulterebbe inferiore al valore ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">L'argomento '{0}' è Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">L'argomento '{0}' non è un valore valido.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">Impossibile convertire l'argomento '{0}' nel tipo '{1}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Errore interno. Impossibile ottenere il nome completo del sistema operativo. WMI potrebbe non essere presente sul computer in uso.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Errore interno. Impossibile ottenere informazioni sulla memoria.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Variabile di ambiente non definita: '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">L'argomento non può essere Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">La proprietà {0} non può essere impostata su Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Il file non è stato trovato.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Autorizzazione negata.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Impossibile completare l'operazione. Nel percorso '{0}' è già presente un file.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Il file '{0}' non è stato trovato. </target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Il percorso di file fornito termina con un carattere di separatore di directory.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Mouse non presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Rotellina del mouse non presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout deve essere maggiore di 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName deve includere un nome file.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' non è un indirizzo di file remoto valido. Un indirizzo valido deve includere un protocollo, un percorso e un nome di file.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Impossibile effettuare il ping. La connessione di rete non è disponibile.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">L'indirizzo di UploadFile deve includere un nome file.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Impossibile trovare il processo '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Download di {0} in {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Download di {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Upload di {0} in {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Caricamento di {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ja.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ja.xlf
deleted file mode 100644
index d9c1b872741..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ja.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">スタートアップ フォームが指定されていません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">この単一インスタンス アプリケーションは元のインスタンスに接続できませんでした。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">スプラッシュ スクリーンとメイン フォームは同じフォームであることはできません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName は、Nothing または空文字列にできません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">{0} の値は 1000 以上でなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">ログのストリームを取得できません。  {0} に基づく、可能性のあるファイル名は既に使用中です。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">書き込みを行うと MaxFileSize 値を超えてしまうため、ログ ファイルに書き込めません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">利用可能な空きディスク領域を確認できません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">{0} の値は正数でなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">書き込みを行うと、空きディスク領域が ReservedSpace 値よりも少なくなるため、ログ ファイルに書き込めません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">引数 '{0}' は Nothing です。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">引数 '{0}' は有効な値ではありません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">引数 '{0}' は型 '{1}' に変換できません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">内部エラーのため、完全なオペレーション システム名を取得できませんでした。現在のコンピューター上に WMI が存在していないことが原因と考えられます。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">内部エラーのため、メモリ情報を取得できませんでした。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">環境変数は定義されていません: '{0}'</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">引数には Nothing を使用できません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">プロパティ {0} は Nothing に設定できません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">ファイルが見つかりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">アクセス許可が拒否されました。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">ファイルがこのパス '{0}' 内に既に存在するため、操作を完了できませんでした。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">ファイル '{0}' は見つかりませんでした。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">指定されたファイル パスの終わりにはディレクトリの区切り記号が指定されています。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">マウスが存在しません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">マウスのホイールが存在しません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout は 0 より大きくなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName はファイル名を含んでいなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' は無効なリモート ファイル アドレスです。有効なアドレスはプロトコル、パスおよびファイル名を含んでいなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">ネットワーク接続が利用できないため、ping を実行できません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">UploadFile のアドレスにはファイル名が含まれていなければなりません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">プロセス '{0}' が見つかりませんでした。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">{0} を {1} にダウンロードしています。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">{0} をダウンロードしています</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">{0} を {1} にアップロードしています。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">{0} のアップロード中</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ko.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ko.xlf
deleted file mode 100644
index 5546130053f..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ko.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">시작 폼이 지정되지 않았습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">이 단일 인스턴스 응용 프로그램을 원본 인스턴스에 연결할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">시작 화면과 기본 폼은 같은 폼일 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName은 Nothing이나 빈 문자열일 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">{0}의 값은 1000보다 크거나 같아야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">로그의 스트림을 가져올 수 없습니다. {0}에 기반한 파일 이름이 이미 사용 중입니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">MaxFileSize 값을 초과할 수 있기 때문에 로그 파일에 쓸 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">사용 가능한 디스크 공간을 확인할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">{0}의 값은 양수여야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">사용 가능한 디스크 공간이 ReservedSpace 값 미만으로 줄어들 수 있기 때문에 로그 파일에 쓸 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">'{0}' 인수가 Nothing입니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">'{0}' 인수는 잘못된 값입니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">'{0}' 인수를 '{1}' 형식으로 변환할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">내부 오류 때문에 작업 시스템의 전체 이름을 가져올 수 없습니다. 이 오류는 현재 컴퓨터에 WMI가 없기 때문에 발생할 수 있습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">내부 오류 때문에 메모리 정보를 가져올 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">환경 변수가 정의되지 않았습니다. '{0}'</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">인수는 Nothing일 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">{0} 속성을 Nothing으로 설정할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">파일을 찾을 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">사용 권한이 거부되었습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">파일이 이 '{0}' 경로에 이미 있기 때문에 작업을 완료할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">'{0}' 파일을 찾을 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">지정한 파일 경로가 디렉터리 구분 문자로 끝납니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">마우스가 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">마우스 휠이 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout은 0보다 커야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName에는 파일 이름이 포함되어야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}'은(는) 올바른 원격 파일 주소가 아닙니다. 올바른 주소에는 프로토콜, 경로 및 파일 이름이 포함되어야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">네트워크 연결을 사용할 수 없어 ping을 실행할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">UploadFile의 주소에는 파일 이름이 포함되어야 합니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">프로세스 '{0}'을(를) 찾을 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">{0}을(를) {1}(으)로 다운로드하고 있습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">{0}을(를) 다운로드하는 중</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">{0}을(를) {1}(으)로 업로드하고 있습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">{0} 업로드 중</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pl.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pl.xlf
deleted file mode 100644
index 35284bb512e..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pl.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Formularz początkowy nie został określony.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">To pojedyncze wystąpienie aplikacji nie może połączyć się z wystąpieniem oryginalnym.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Ekran powitalny i ekran główny nie mogą być tym samym formularzem.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">Parametr BaseFileName nie może mieć wartości Nothing ani nie może być pustym ciągiem.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">Wartość {0} musi być większa lub równa 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Nie można uzyskać strumienia dla dziennika. Potencjalne nazwy plików oparte na {0} są już używane.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Nie można zapisać w pliku dziennika, ponieważ zapisanie może spowodować przekroczenie wartości MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Nie można określić ilości dostępnego miejsca na dysku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">Wartość {0} musi być liczbą dodatnią.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Nie można zapisać w pliku dziennika, ponieważ zapisanie może spowodować zmniejszenie ilości wolnego miejsca na dysku poniżej wartości ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">Argument '{0}' ma wartość Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">Argument '{0}' nie ma prawidłowej wartości.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">Nie można przekonwertować argumentu '{0}' na typ '{1}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Nie można uzyskać pełnej nazwy systemu operacyjnego z powodu błędu wewnętrznego. Przyczyną może być interfejs WMI nie istniejący na bieżącym komputerze.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Nie można uzyskać informacji o pamięci z powodu błędu wewnętrznego.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Zmienna środowiskowa nie została zdefiniowana: '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">Argument nie może mieć wartości Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">Właściwość {0} nie może być ustawiona na wartość Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Nie znaleziono pliku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Odmowa uprawnień.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Nie można wykonać operacji, ponieważ plik już istnieje w tej ścieżce '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Nie można odnaleźć pliku '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Podana ścieżka pliku kończy się znakiem separatora katalogu.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Nie ma myszy.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Nie ma kółka myszy.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">Wartość parametru ConnectionTimeout musi być większa niż 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">Parametr destinationFileName musi zawierać nazwę pliku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' nie jest prawidłowym adresem pliku zdalnego. prawidłowy adres powinien zawierać protokół, ścieżkę i nazwę pliku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Nie można użyć polecenia ping, ponieważ połączenie sieciowe jest niedostępne.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">Adres parametru UploadFile musi zawierać nazwę pliku.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Nie można odnaleźć procesu '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Pobieranie {0} do {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Pobieranie {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Przekazywanie {0} do {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Przekazywanie: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pt-BR.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pt-BR.xlf
deleted file mode 100644
index 1e1b8f1416f..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.pt-BR.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Não foi especificado um formulário de inicialização.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Este aplicativo de instância única não pôde se conectar à instância original.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Tela inicial e formulário principal não podem ser o mesmo formulário.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName não pode ser Nothing ou uma cadeia de caracteres vazia.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">O valor de {0} deve ser maior ou igual a 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Não é possível obter um fluxo para o log. Os possíveis nomes de arquivo baseados em {0} já estão em uso.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Não é possível gravar no arquivo de log porque isso faria com que o valor de MaxFileSize fosse excedido.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Não é possível determinar a quantidade de espaço em disco disponível.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">O valor de {0} deve ser um número positivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Não é possível gravar no arquivo de log porque isso reduziria o espaço livre em disco abaixo do valor de ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">O argumento '{0}' é Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">O argumento '{0}' é um valor inválido.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">O argumento '{0}' não pode ser convertido no tipo '{1}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Não foi possível obter o nome completo do sistema operacional devido a um erro interno. Possível causa: ausência de WMI na máquina atual.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Não foi possível obter informações sobre memória devido a um erro interno.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Variável de ambiente não definida: '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">O argumento não pode ser Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">A propriedade {0} não pode ser Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Arquivo não encontrado.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">Permissão negada.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Não foi possível concluir a operação porque já existe um arquivo neste caminho '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Não foi possível encontrar o arquivo '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">O caminho de arquivo fornecido termina com um caractere separador de diretório.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Nenhum mouse presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Nenhuma roda de mouse presente.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout deve ser maior que 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName precisa incluir um nome de arquivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' não é um endereço de arquivo remoto válido. Um endereço válido deve incluir um protocolo, um caminho e um nome de arquivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Não é possível executar ping porque a conexão com a rede não está disponível.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">O endereço para UploadFile precisa incluir um nome de arquivo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">O processo '{0}' não foi encontrado.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Baixando {0} para {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Baixando {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Carregando {0} para {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Carregando {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ru.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ru.xlf
deleted file mode 100644
index e400e684656..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.ru.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Форма запуска не указана.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Данное приложение, допускающее только один экземпляр, не может подключиться к первоначальному экземпляру.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Заставка и главная форма не могут быть одной и той же формой.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">Параметр BaseFileName не может принимать значение Nothing или оставаться пустым.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">Значение {0} должно быть больше или равно 1000.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Невозможно получить поток для журнала.  Потенциальные имена файлов, основанные на {0}, уже используются.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Невозможно произвести запись в файл журнала, это приведет к превышению значения MaxFileSize.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Не удается определить объем свободного дискового пространства.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">Значение {0} должно быть положительным числом.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Невозможно произвести запись в файл журнала, на диске останется менее ReservedSpace.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">Аргумент "{0}" имеет значение Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">Аргумент "{0}" не является допустимым значением.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">Невозможно привести аргумент "{0}" к типу "{1}".</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">Не удается получить полное имя операционной системы из-за внутренней ошибки. Возможно, на данном компьютере отсутствует WMI.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">Невозможно получить информацию о памяти из-за внутренней ошибки.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Не задана переменная окружения: "{0}".</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">Аргумент не может принимать значение Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">Свойству {0} нельзя присвоить значение Nothing.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Файл не найден.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">В разрешении отказано.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Не удалось завершить операцию: файл "{0}" уже существует.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">Не удалось найти файл "{0}".</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Данный путь к файлу заканчивается символом разделителя каталогов.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Не обнаружена мышь.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Не обнаружено колесо мыши.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">Значение ConnectionTimeout должно быть больше 0.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName должен включать имя файла.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">"{0}" является недопустимым адресом удаленного файла. Допустимый адрес должен включать протокол, путь и имя файла.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Не удается отправить запрос отклика: отсутствует сетевое соединение.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">Адрес UploadFile должен включать имя файла.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">Процесс "{0}" не найден.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">Скачивание {0} в {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">Загрузка {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">Загрузка {0} в {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">Идет отправка {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.tr.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.tr.xlf
deleted file mode 100644
index 751c15e6832..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.tr.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">Başlangıç formu belirtilmedi.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">Bu tek örnekli uygulama özgün örneğe bağlanamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">Giriş ekranı ve ana form aynı form olamaz.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName Nothing veya boş Dize olamaz.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">{0} değeri 1000'den büyük veya eşit olmalıdır.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">Günlük için akış alınamıyor. {0} öğesini temel alan olası dosya adları zaten kullanılıyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">Günlük dosyalarına yazılması MaxFileSize değerinin aşmasına neden olacağından günlük dosyasına yazılamıyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">Kullanılabilir disk alanı miktarı belirlenemiyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">{0} değeri artı sayı olmalıdır.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">Günlük dosyasına yazmak boş dik alanını ReservedSpace değerinin altına düşüreceğinden günlük dosyasına yazılamıyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">'{0}' bağımsız değişkeni Nothing olarak belirlenmiş.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">'{0}' bağımsız değişkeninin değeri geçerli değil.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">'{0}' bağımsız değişkeni '{1}' türüne dönüştürülemez.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">İç hata nedeniyle işletim sistemi tam adı alınamadı. Geçerli bilgisayarda WMI'nın olmaması buna neden olabilir.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">İç hata nedeniyle bellek bilgileri alınamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">Ortam değişkeni tanımlanmamış: '{0}'.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">Bağımsız değişken Nothing olamaz.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">{0} özelliği Nothing olarak ayarlanamaz.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">Dosya bulunamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">İzin reddedildi.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">Bu '{0}' yolunda zaten bir dosya olduğundan işlem tamamlanamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">'{0}' adlı dosya bulunamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">Verilen dosya yolu bir dizinle veya ayırıcı karakterle sona eriyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">Fare yok.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">Fare tekerleği yok.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout sıfırdan büyük olmalıdır.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName öğesinin bir dosya adı içermesi gerekir.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' geçerli bir uzak dosya adresi değil. Geçerli adres bir protokol, yol ve dosya adı içermelidir.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">Kullanılabilir ağ bağlantısı olmadığından ping işlemi yapılamıyor.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">UploadFile adresinin bir dosya adı içermesi gerekir.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">'{0}' işlemi bulunamadı.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">{0}, {1} konumuna indiriliyor</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">{0} indiriliyor</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">{0}, {1} konumuna yükleniyor</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">{0} karşıya yükleniyor</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hans.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hans.xlf
deleted file mode 100644
index af55164f9e7..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hans.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">未指定启动窗体。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">此单实例应用程序未能连接到原始实例。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">初始屏幕和主窗体不能是同一个窗体。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName 不能为 Nothing 或空字符串。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">{0} 的值必须大于或等于 1000。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">无法获取日志的流。可能基于 {0} 的文件名已在使用中。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">无法写入日志文件，原因是写入将导致日志文件超过 MaxFileSize 值。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">无法确定可用磁盘空间量。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">{0} 的值必须是正数。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">无法写入日志文件，因为写入日志文件会使可用磁盘空间低于 ReservedSpace 值。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">参数“{0}”为 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">参数“{0}”不是有效值。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">参数“{0}”无法转换为类型“{1}”。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">由于内部错误，未能获取完整的操作系统名称。这可能是由于当前计算机上不存在 WMI 造成的。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">由于内部错误，未能获取内存信息。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">未定义环境变量:“{0}”。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">参数不能为 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">属性 {0} 不能设置为 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">找不到文件。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">权限被拒绝。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">未能完成操作，因为此路径“{0}”中已存在文件。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">找不到文件“{0}”。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">给定的文件路径以目录分隔符字符结尾。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">没有鼠标。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">没有鼠标轮。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout 必须大于 0。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName 需要包括文件名。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">“{0}”不是有效的远程文件地址。有效的地址应包括协议、路径和文件名。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">由于网络连接不可用，无法使用 ping 命令。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">UploadFile 的地址中需要包括文件名。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">未找到进程“{0}”。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">正在将 {0} 下载到 {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">正在下载 {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">正在将 {0} 上载到 {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">正在上传 {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hant.xlf b/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hant.xlf
deleted file mode 100644
index c3df5ab1fb7..00000000000
--- a/src/Microsoft.VisualBasic.Forms/src/Resources/xlf/SR.zh-Hant.xlf
+++ /dev/null
@@ -1,182 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../SR.resx">
-    <body>
-      <trans-unit id="AppModel_NoStartupForm">
-        <source>A startup form has not been specified.</source>
-        <target state="translated">尚未指定啟動表單。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SingleInstanceCantConnect">
-        <source>This single-instance application could not connect to the original instance.</source>
-        <target state="translated">此單一執行個體應用程式無法連接到原始執行個體。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="AppModel_SplashAndMainFormTheSame">
-        <source>Splash screen and main form cannot be the same form.</source>
-        <target state="translated">啟動顯示畫面和主要表單不能是同樣的表單。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogBaseNameNull">
-        <source>BaseFileName cannot be Nothing or an empty String.</source>
-        <target state="translated">BaseFileName 不能為 Nothing 或空字串。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLogNumberTooSmall">
-        <source>The value of {0} must be greater than or equal to 1000.</source>
-        <target state="translated">{0} 的值必須大於或等於 1000。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ExhaustedPossibleStreamNames">
-        <source>Unable to obtain a stream for the log.  Potential file names based on {0} are already in use.</source>
-        <target state="translated">無法取得記錄檔的資料流。以 {0} 為主的檔名已經在使用中。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FileExceedsMaximumSize">
-        <source>Unable to write to log file because writing to it would cause it to exceed the MaxFileSize value.</source>
-        <target state="translated">無法寫入記錄檔，因為如果寫入，會使它超過 MaxFileSize 值。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_FreeSpaceError">
-        <source>Cannot determine the amount of available disk space.</source>
-        <target state="translated">無法判斷可用磁碟空間量。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_NegativeNumber">
-        <source>The value of {0} must be a positive number.</source>
-        <target state="translated">{0} 的值必須為正數。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ApplicationLog_ReservedSpaceEncroached">
-        <source>Unable to write to log file because writing to it would reduce free disk space below ReservedSpace value.</source>
-        <target state="translated">無法寫入記錄檔，因為如果寫入，可用磁碟空間會減少到 ReservedSpace 值以下。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidNullValue1">
-        <source>Argument '{0}' is Nothing.</source>
-        <target state="translated">引數 '{0}' 為 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValue1">
-        <source>Argument '{0}' is not a valid value.</source>
-        <target state="translated">引數 '{0}' 不是一個有效的值。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Argument_InvalidValueType2">
-        <source>Argument '{0}' cannot be converted to type '{1}'.</source>
-        <target state="translated">引數 '{0}' 無法轉換為類型 '{1}'。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_FullOSName">
-        <source>Could not obtain full operation system name due to internal error. This might be caused by WMI not existing on the current machine.</source>
-        <target state="translated">由於內部錯誤，無法取得完整作業系統名稱。這可能是因為目前電腦上沒有 WMI 存在所造成。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="DiagnosticInfo_Memory">
-        <source>Could not obtain memory information due to internal error.</source>
-        <target state="translated">由於內部錯誤，無法取得記憶體資訊。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="EnvVarNotFound_Name">
-        <source>Environment variable is not defined: '{0}'.</source>
-        <target state="translated">環境變數未定義: '{0}'。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_ArgumentNullException">
-        <source>Argument cannot be Nothing.</source>
-        <target state="translated">引數不能為 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="General_PropertyNothing">
-        <source>Property {0} cannot be set to Nothing.</source>
-        <target state="translated">屬性 {0} 不能設定為 Nothing。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID53">
-        <source>File not found.</source>
-        <target state="translated">找不到檔案。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ID70">
-        <source>Permission denied.</source>
-        <target state="translated">使用權限遭拒。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileExists_Path">
-        <source>Could not complete operation since a file already exists in this path '{0}'.</source>
-        <target state="translated">無法完成作業，因為檔案已經存在於此路徑 '{0}'。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FileNotFound_Path">
-        <source>Could not find file '{0}'.</source>
-        <target state="translated">找不到檔案 '{0}'。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="IO_FilePathException">
-        <source>The given file path ends with a directory separator character.</source>
-        <target state="translated">指定的檔案路徑以目錄分隔符號結束。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoMouseIsPresent">
-        <source>No mouse is present.</source>
-        <target state="translated">滑鼠不存在。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Mouse_NoWheelIsPresent">
-        <source>No mouse wheel is present.</source>
-        <target state="translated">滑鼠滾輪不存在。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_BadConnectionTimeout">
-        <source>The ConnectionTimeout must be greater than 0.</source>
-        <target state="translated">ConnectionTimeout 必須大於 0。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_DownloadNeedsFilename">
-        <source>destinationFileName needs to include a file name.</source>
-        <target state="translated">destinationFileName 需要包含檔案名稱。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_InvalidUriString">
-        <source>'{0}' is not a valid remote file address. A valid address should include a protocol, a path and a file name.</source>
-        <target state="translated">'{0}' 不是有效的遠端檔案位址。有效位址應該包含通訊協定、路徑和檔案名稱。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_NetworkNotAvailable">
-        <source>Unable to ping because a network connection is not available.</source>
-        <target state="translated">無法 Ping，因為有一個網路連接無法使用。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="Network_UploadAddressNeedsFilename">
-        <source>The address for UploadFile needs to include a file name.</source>
-        <target state="translated">UploadFile 的位址必須包含檔名。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProcessNotFound">
-        <source>Process '{0}' was not found.</source>
-        <target state="translated">找不到處理序 '{0}'。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingLabel">
-        <source>Downloading {0} to {1}</source>
-        <target state="translated">下載 {0} 至 {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogDownloadingTitle">
-        <source>Downloading {0}</source>
-        <target state="translated">正在下載 {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingLabel">
-        <source>Uploading {0} to {1}</source>
-        <target state="translated">上傳 {0} 至 {1}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="ProgressDialogUploadingTitle">
-        <source>Uploading {0}</source>
-        <target state="translated">正在上傳 {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/Microsoft.VisualBasic.Forms.Tests.vbproj b/src/Microsoft.VisualBasic.Forms/tests/UnitTests/Microsoft.VisualBasic.Forms.Tests.vbproj
deleted file mode 100644
index 75a84335a78..00000000000
--- a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/Microsoft.VisualBasic.Forms.Tests.vbproj
+++ /dev/null
@@ -1,30 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <SourceTargetFramework>$(TargetFramework)</SourceTargetFramework>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <RootNamespace>Microsoft.VisualBasic.Forms.Tests</RootNamespace>
-    <LangVersion>latest</LangVersion>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing\src\System.Drawing.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Windows.Forms.Primitives\tests\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\..\System.Windows.Forms\tests\TestUtilities\System.Windows.Forms.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\Microsoft.VisualBasic.Forms.vbproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- workaround for https://github.com/dotnet/sdk/issues/3254 -->
-    <Reference Include="$(BaseOutputPath)..\System.Drawing.Facade\$(Configuration)\$(SourceTargetFramework)\System.Drawing.dll" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.vb b/src/Microsoft.VisualBasic.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.vb
deleted file mode 100644
index b8df093183f..00000000000
--- a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.vb
+++ /dev/null
@@ -1,105 +0,0 @@
-' Licensed to the .NET Foundation under one or more agreements.
-' The .NET Foundation licenses this file to you under the MIT license.
-
-Imports System.Windows.Forms
-Imports Xunit
-
-Namespace Microsoft.VisualBasic.Forms.Tests
-    Partial Public Class ControlTests
-
-        <WinFormsFact>
-        Public Sub Control_Invoke_Action_calls_correct_method()
-            Using _control As New Control
-                _control.CreateControl()
-
-                Dim invoker As Action = AddressOf FaultingMethod
-                Dim exception = Assert.Throws(Of DivideByZeroException)(
-                    Sub() _control.Invoke(invoker))
-
-                '    Expecting something Like the following.
-                '    The first frame must be the this method, followed by MarshaledInvoke at previous location.
-                '
-                '    at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests.FaultingMethod() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 28
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6511
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6487
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6459
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6563
-                '    --- End of stack trace from previous location ---
-                '       at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6951
-                '       at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6413
-                '       at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6393
-                '       at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests._Closure$__1-1._Lambda$__0() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 18
-
-                Assert.Contains(NameOf(FaultingMethod), exception.StackTrace)
-                Assert.Contains(" System.Windows.Forms.Control.Invoke(Action method) ", exception.StackTrace)
-            End Using
-        End Sub
-
-        <WinFormsFact>
-        Public Sub Control_Invoke_Delegate_MethodInvoker_calls_correct_method()
-            Using _control As New Control
-                _control.CreateControl()
-
-                Dim invoker As New MethodInvoker(AddressOf FaultingMethod)
-                Dim exception = Assert.Throws(Of DivideByZeroException)(
-                    Sub() _control.Invoke(invoker))
-
-                '    Expecting something Like the following.
-                '    The first frame must be the this method, followed by MarshaledInvoke at previous location.
-                '
-                '    at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests.FaultingMethod() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 28
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6511
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6487
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6459
-                '       at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6563
-                '    --- End of stack trace from previous location ---
-                '       at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6951
-                '       at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6413
-                '       at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6393
-                '       at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests._Closure$__1-1._Lambda$__0() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 18
-
-                Assert.Contains(NameOf(FaultingMethod), exception.StackTrace)
-                Assert.Contains(" System.Windows.Forms.Control.Invoke(Delegate method) ", exception.StackTrace)
-            End Using
-        End Sub
-
-        <WinFormsFact>
-        Public Sub Control_Invoke_Func_calls_correct_method()
-            Using _control As New Control
-                _control.CreateControl()
-
-                Dim invoker As Func(Of Integer, Integer) = AddressOf FaultingFunc
-                Dim exception = Assert.Throws(Of DivideByZeroException)(
-                    Sub()
-                        Dim result = _control.Invoke(Function() invoker(19))
-                    End Sub)
-
-                '    Expecting something Like the following.
-                '    The first frame must be the this method, followed by MarshaledInvoke at previous location.
-                '
-                '    at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests.FaultingFunc(Int32 a) in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 144
-                '       at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests._Closure$__4-1._Lambda$__1() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 112
-                '    --- End of stack trace from previous location ---
-                '       at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6951
-                '       at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6413
-                '       at System.Windows.Forms.Control.Invoke[T](Func`1 method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6422
-                '       at Microsoft.VisualBasic.Forms.Tests.Microsoft.VisualBasic.Forms.Tests.ControlTests._Closure$__4-1._Lambda$__0() in ...\winforms\src\Microsoft.VisualBasic.Forms\tests\UnitTests\ControlTests.vb:line 111
-                '       at Xunit.Assert.RecordException(Action testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 27
-
-                Assert.Contains(NameOf(FaultingFunc), exception.StackTrace)
-                Assert.Contains(" System.Windows.Forms.Control.Invoke[T](Func`1 method) ", exception.StackTrace)
-            End Using
-        End Sub
-
-        Shared Sub FaultingMethod()
-            Throw New DivideByZeroException()
-        End Sub
-
-        Shared Function FaultingFunc(a As Integer) As Integer
-            Return a \ 0
-        End Function
-
-    End Class
-
-End Namespace
-
diff --git a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/runtimeconfig.template.json b/src/Microsoft.VisualBasic.Forms/tests/UnitTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/Microsoft.VisualBasic.Forms/tests/UnitTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic/Directory.Build.props b/src/Microsoft.VisualBasic/Directory.Build.props
deleted file mode 100644
index 4691d3cd770..00000000000
--- a/src/Microsoft.VisualBasic/Directory.Build.props
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project>
-  <Import Project="..\..\Directory.Build.props" />
-  <PropertyGroup>
-    <!-- Version must be >= desktop version and > Microsoft.VisualBasic.Core.dll version. -->
-    <AssemblyVersion>10.1.0.0</AssemblyVersion>
-    <StrongNameKeyId>Microsoft</StrongNameKeyId>
-  </PropertyGroup>
-</Project>
diff --git a/src/Microsoft.VisualBasic/src/Microsoft.VisualBasic.Facade.csproj b/src/Microsoft.VisualBasic/src/Microsoft.VisualBasic.Facade.csproj
deleted file mode 100644
index 2fca69fd6aa..00000000000
--- a/src/Microsoft.VisualBasic/src/Microsoft.VisualBasic.Facade.csproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>Microsoft.VisualBasic</AssemblyName>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Microsoft.VisualBasic.Forms\src\Microsoft.VisualBasic.Forms.vbproj" />
-    <ProjectReference Include="..\..\System.Windows.Forms\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic/tests/Directory.Build.targets b/src/Microsoft.VisualBasic/tests/Directory.Build.targets
deleted file mode 100644
index 4cdd168b9a6..00000000000
--- a/src/Microsoft.VisualBasic/tests/Directory.Build.targets
+++ /dev/null
@@ -1,15 +0,0 @@
-<Project>
-
-  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.targets', '$(MSBuildThisFileDirectory)\..'))"/>
-
-  <!--
-    SDK doesn't support conflict resolution with project references (see https://github.com/dotnet/sdk/issues/2674).
-    Remove Microsoft.VisualBasic from netcoreapp shared framework to use the project reference instead.
-  -->
-  <Target Name="RemoveVBNetCoreAppReference" AfterTargets="ResolveTargetingPackAssets">
-    <ItemGroup>
-      <Reference Remove="@(Reference)" Condition="'%(FileName)'=='Microsoft.VisualBasic' and '%(Reference.ResolvedFrom)'!='ProjectReference'" />
-    </ItemGroup>
-  </Target>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/GlobalUsings.cs b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/GlobalUsings.cs
deleted file mode 100644
index 5abc35b2162..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using Xunit;
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/InteractionTests.cs b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/InteractionTests.cs
deleted file mode 100644
index cb4cb2065d2..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/InteractionTests.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.IntegrationTests.Common;
-
-namespace Microsoft.VisualBasic.IntegrationTests;
-
-public class InteractionTests
-{
-    [Fact]
-    public void AppActivate_ProcessId()
-    {
-        Process process = StartTestProcess("Interaction.MsgBox");
-        try
-        {
-            Interaction.AppActivate(process.Id);
-        }
-        catch (ArgumentException)
-        {
-            // Modal dialog may be closed automatically on build machine.
-        }
-
-        EndProcess(process);
-    }
-
-    [Fact]
-    public void AppActivate_Title_ArgumentException()
-    {
-        // Exception.ToString() called to verify message is constructed successfully.
-        _ = Assert.Throws<ArgumentException>(() => Interaction.AppActivate(GetUniqueName())).ToString();
-    }
-
-    [Fact]
-    public void InputBox()
-    {
-        Process process = StartTestProcess("Interaction.InputBox");
-        EndProcess(process);
-    }
-
-    [Fact]
-    public void InputBox_VbHost()
-    {
-        Process process = StartTestProcess("Interaction.InputBox_VbHost");
-        EndProcess(process);
-    }
-
-    [Fact]
-    public void VBInputBox_ShowDialog()
-    {
-        Process process = StartTestProcess("VBInputBox.ShowDialog");
-        EndProcess(process);
-        Assert.True(process.HasExited);
-        Assert.NotEqual(2, process.ExitCode);
-    }
-
-    [Fact]
-    public void MsgBox()
-    {
-        Process process = StartTestProcess("Interaction.MsgBox");
-        try
-        {
-            TestHelpers.SendEnterKeyToProcess(process);
-        }
-        catch (ArgumentException)
-        {
-            // Modal dialog may be closed automatically on build machine.
-        }
-
-        EndProcess(process);
-    }
-
-    [Fact]
-    public void MsgBox_VbHost()
-    {
-        Process process = StartTestProcess("Interaction.MsgBox_VbHost");
-        try
-        {
-            TestHelpers.SendEnterKeyToProcess(process);
-        }
-        catch (ArgumentException)
-        {
-            // Modal dialog may be closed automatically on build machine.
-        }
-
-        EndProcess(process);
-    }
-
-    [Fact]
-    public void Shell()
-    {
-        int processId = Interaction.Shell(_exePath);
-        Process process = Process.GetProcessById(processId);
-        process.Kill();
-        process.WaitForExit();
-    }
-
-    [Fact]
-    public void Shell_NullReferenceException()
-    {
-        // Exception.ToString() called to verify message is constructed successfully.
-        _ = Assert.Throws<NullReferenceException>(() => Interaction.Shell(null)).ToString();
-    }
-
-    [Fact]
-    public void Shell_FileNotFoundException()
-    {
-        var path = Path.Combine(Path.GetTempPath(), GetUniqueName());
-        // Exception.ToString() called to verify message is constructed successfully.
-        _ = Assert.Throws<FileNotFoundException>(() => Interaction.Shell(path)).ToString();
-    }
-
-    private static readonly string _exePath = TestHelpers.GetExePath("VisualBasicRuntimeTest");
-
-    private static Process StartTestProcess(string arguments)
-    {
-        ProcessStartInfo startInfo = new() { FileName = _exePath, Arguments = arguments };
-        return TestHelpers.StartProcess(startInfo);
-    }
-
-    private static void EndProcess(Process process)
-    {
-        TestHelpers.EndProcess(process, 1000);
-    }
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString("D");
-}
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft.VisualBasic.IntegrationTests.csproj b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft.VisualBasic.IntegrationTests.csproj
deleted file mode 100644
index c0f023ecd50..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft.VisualBasic.IntegrationTests.csproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\src\Microsoft.VisualBasic.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms\tests\IntegrationTests\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-    <ProjectReference Include="..\VisualBasicRuntimeTest\VisualBasicRuntimeTest.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs
deleted file mode 100644
index 194ffecfd7a..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.IntegrationTests.Common;
-using Microsoft.VisualBasic.ApplicationServices;
-
-namespace Microsoft.VisualBasic.IntegrationTests;
-
-public class WindowsFormsApplicationBaseTests
-{
-    [Fact]
-    public void Run()
-    {
-        string exePath = TestHelpers.GetExePath("VisualBasicRuntimeTest");
-        ProcessStartInfo startInfo = new() { FileName = exePath, Arguments = "WindowsFormsApplicationBase.Run" };
-        Process process = TestHelpers.StartProcess(startInfo);
-        TestHelpers.EndProcess(process, timeout: 1000);
-        Assert.True(process.HasExited);
-    }
-
-    [Fact]
-    public void RunSingleInstance()
-    {
-        string exePath = TestHelpers.GetExePath("VisualBasicRuntimeTest");
-        Process process0 = TestHelpers.StartProcess(new ProcessStartInfo { FileName = exePath, Arguments = "WindowsFormsApplicationBase.RunSingleInstance0" });
-        Process process1 = TestHelpers.StartProcess(new ProcessStartInfo { FileName = exePath, Arguments = "WindowsFormsApplicationBase.RunSingleInstance1" });
-        TestHelpers.EndProcess(process0, timeout: 1000);
-        TestHelpers.EndProcess(process1, timeout: 1000);
-        Assert.True(process0.HasExited);
-        Assert.True(process1.HasExited);
-    }
-
-    [Fact]
-    public void Run_NoStartupFormException()
-    {
-        WindowsFormsApplicationBase application = new();
-        // Exception.ToString() called to verify message is constructed successfully.
-        _ = Assert.Throws<NoStartupFormException>(() => application.Run(Array.Empty<string>())).ToString();
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/MyServices/Internal/ProgressDialogTests.cs b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/MyServices/Internal/ProgressDialogTests.cs
deleted file mode 100644
index 3483da4641e..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/Microsoft/VisualBasic/MyServices/Internal/ProgressDialogTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.IntegrationTests.Common;
-
-namespace Microsoft.VisualBasic.MyServices.Internal.Tests;
-
-public class ProgressDialogTests
-{
-    [Fact]
-    public void ShowProgressDialog()
-    {
-        string exePath = TestHelpers.GetExePath("VisualBasicRuntimeTest");
-        ProcessStartInfo startInfo = new() { FileName = exePath, Arguments = "ProgressDialog.ShowProgressDialog" };
-        Process process = TestHelpers.StartProcess(startInfo);
-        TestHelpers.EndProcess(process, timeout: 1000);
-        Assert.True(process.HasExited);
-        Assert.NotEqual(2, process.ExitCode);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/runtimeconfig.template.json b/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/Microsoft.VisualBasic.IntegrationTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/Program.cs b/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/Program.cs
deleted file mode 100644
index 2e299db7c69..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/Program.cs
+++ /dev/null
@@ -1,194 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using System.Resources;
-using System.Windows.Forms;
-using Microsoft.VisualBasic;
-using Microsoft.VisualBasic.ApplicationServices;
-using Microsoft.VisualBasic.CompilerServices;
-
-namespace VisualBasicRuntimeTest;
-
-internal class Program
-{
-    [STAThread]
-    static void Main(string[] args)
-    {
-        try
-        {
-            if (args.Length != 1)
-            {
-                throw new ArgumentException();
-            }
-
-            switch (args[0])
-            {
-                case "Interaction.InputBox":
-                    Interaction_InputBox(useVbHost: false);
-                    break;
-                case "Interaction.InputBox_VbHost":
-                    Interaction_InputBox(useVbHost: true);
-                    break;
-                case "Interaction.MsgBox":
-                    Interaction_MsgBox(useVbHost: false);
-                    break;
-                case "Interaction.MsgBox_VbHost":
-                    Interaction_MsgBox(useVbHost: true);
-                    break;
-                case "WindowsFormsApplicationBase.Run":
-                    WindowsFormsApplicationBase_Run(isSingleInstance: false, isFirstInstance: true);
-                    break;
-                case "WindowsFormsApplicationBase.RunSingleInstance0":
-                    WindowsFormsApplicationBase_Run(isSingleInstance: true, isFirstInstance: true);
-                    break;
-                case "WindowsFormsApplicationBase.RunSingleInstance1":
-                    WindowsFormsApplicationBase_Run(isSingleInstance: true, isFirstInstance: false);
-                    break;
-                case "ProgressDialog.ShowProgressDialog":
-                    ProgressDialog_ShowProgressDialog();
-                    break;
-                case "VBInputBox.ShowDialog":
-                    VBInputBox_ShowDialog();
-                    break;
-                default:
-                    throw new ArgumentException();
-            }
-        }
-        catch (Exception)
-        {
-            Environment.Exit(2);
-        }
-    }
-
-    private static void Interaction_InputBox(bool useVbHost)
-    {
-        VbHost host = useVbHost ? new VbHost() : null;
-        HostServices.VBHost = host;
-        Interaction.InputBox(Prompt: "Prompt", Title: "Title");
-    }
-
-    private static void Interaction_MsgBox(bool useVbHost)
-    {
-        VbHost host = useVbHost ? new VbHost() : null;
-        HostServices.VBHost = host;
-        Interaction.MsgBox(Prompt: "Message", Buttons: MsgBoxStyle.OkCancel, Title: "Title");
-    }
-
-    private static void WindowsFormsApplicationBase_Run(bool isSingleInstance, bool isFirstInstance)
-    {
-        Form mainForm = new();
-        WindowsApplication application = new(mainForm, isSingleInstance);
-
-        bool valid = false;
-        bool loaded = false;
-        bool startUpNextInstance = false;
-
-        application.StartupNextInstance += (object sender, StartupNextInstanceEventArgs e) =>
-        {
-            startUpNextInstance = true;
-            if (!isFirstInstance)
-            {
-                mainForm.Close();
-            }
-        };
-
-        mainForm.Load += (object sender, EventArgs e) =>
-        {
-            loaded = true;
-            var forms = application.OpenForms;
-            valid = forms.Count == 1 &&
-                forms[0] == mainForm &&
-                application.ApplicationContext.MainForm == mainForm;
-            if (!valid)
-            {
-                mainForm.Close();
-            }
-        };
-
-        application.Run(Array.Empty<string>());
-
-        if (startUpNextInstance)
-        {
-            throw new InvalidOperationException();
-        }
-
-        if (!loaded && !isFirstInstance)
-        {
-            throw new InvalidOperationException();
-        }
-
-        if (!valid)
-        {
-            throw new InvalidOperationException();
-        }
-    }
-
-    private static void ProgressDialog_ShowProgressDialog()
-    {
-        Type dialogType = typeof(ApplicationBase).Assembly.GetType("Microsoft.VisualBasic.MyServices.Internal.ProgressDialog");
-        var dialog = (Form)Activator.CreateInstance(dialogType, nonPublic: true);
-
-        ResourceManager resources = new(dialogType);
-        var expectedValue = (Point)resources.GetObject("ProgressBarWork.Location");
-        if (expectedValue == new Point(0, 0))
-        {
-            throw new InvalidOperationException();
-        }
-
-        PropertyInfo controlProperty = dialogType.GetProperty("ProgressBarWork", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
-        var control = (Control)controlProperty.GetValue(dialog);
-        Point actualValue = control.Location;
-        if (actualValue != expectedValue)
-        {
-            throw new InvalidOperationException();
-        }
-
-        MethodInfo showMethod = dialogType.GetMethod("ShowProgressDialog");
-        showMethod.Invoke(dialog, null);
-    }
-
-    private static void VBInputBox_ShowDialog()
-    {
-        Type formType = typeof(ApplicationBase).Assembly.GetType("Microsoft.VisualBasic.CompilerServices.VBInputBox");
-        var form = (Form)Activator.CreateInstance(formType, nonPublic: true);
-
-        ResourceManager resources = new(formType);
-        var expectedValue = (Point)resources.GetObject("TextBox.Location");
-        if (expectedValue == new Point(0, 0))
-        {
-            throw new InvalidOperationException();
-        }
-
-        FieldInfo controlField = formType.GetField("TextBox", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
-        var control = (Control)controlField.GetValue(form);
-        Point actualValue = control.Location;
-        if (actualValue != expectedValue)
-        {
-            throw new InvalidOperationException();
-        }
-
-        form.ShowDialog();
-    }
-
-    private sealed class WindowsApplication : WindowsFormsApplicationBase
-    {
-        internal WindowsApplication(Form mainForm, bool isSingleInstance)
-        {
-            MainForm = mainForm;
-            IsSingleInstance = isSingleInstance;
-        }
-    }
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString("D");
-
-    private sealed class VbHost : IVbHost
-    {
-        private readonly string _title = GetUniqueName();
-
-        public IWin32Window GetParentWindow() => null;
-
-        public string GetWindowTitle() => _title;
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/VisualBasicRuntimeTest.csproj b/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/VisualBasicRuntimeTest.csproj
deleted file mode 100644
index 8f3ddde355d..00000000000
--- a/src/Microsoft.VisualBasic/tests/IntegrationTests/VisualBasicRuntimeTest/VisualBasicRuntimeTest.csproj
+++ /dev/null
@@ -1,11 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\src\Microsoft.VisualBasic.Facade.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/GlobalUsings.cs b/src/Microsoft.VisualBasic/tests/UnitTests/GlobalUsings.cs
deleted file mode 100644
index 5abc35b2162..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using Xunit;
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft.VisualBasic.Tests.csproj b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft.VisualBasic.Tests.csproj
deleted file mode 100644
index ac5c446edca..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft.VisualBasic.Tests.csproj
+++ /dev/null
@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsPackageVersion)" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\System.Windows.Forms.Primitives\tests\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\Microsoft.VisualBasic.Facade.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ApplicationBaseTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ApplicationBaseTests.cs
deleted file mode 100644
index 87fbe88925c..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ApplicationBaseTests.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class ApplicationBaseTests
-{
-    [Fact]
-    public void Culture()
-    {
-        var app = new ApplicationBase();
-        var culture = app.Culture;
-        Assert.Equal(System.Threading.Thread.CurrentThread.CurrentCulture, culture);
-        try
-        {
-            app.ChangeCulture("en-US");
-            Assert.Equal(System.Threading.Thread.CurrentThread.CurrentCulture, app.Culture);
-            Assert.Equal("en-US", app.Culture.Name);
-        }
-        finally
-        {
-            System.Threading.Thread.CurrentThread.CurrentCulture = culture;
-        }
-    }
-
-    [Fact]
-    public void UICulture()
-    {
-        var app = new ApplicationBase();
-        var culture = app.UICulture;
-        Assert.Equal(System.Threading.Thread.CurrentThread.CurrentUICulture, culture);
-        try
-        {
-            app.ChangeUICulture("en-US");
-            Assert.Equal(System.Threading.Thread.CurrentThread.CurrentUICulture, app.UICulture);
-            Assert.Equal("en-US", app.UICulture.Name);
-        }
-        finally
-        {
-            System.Threading.Thread.CurrentThread.CurrentUICulture = culture;
-        }
-    }
-
-    [Fact]
-    public void GetEnvironmentVariable()
-    {
-        var app = new ApplicationBase();
-        foreach (var (key, value) in GetEnvironmentVariables())
-        {
-            Assert.Equal(value, app.GetEnvironmentVariable(key));
-        }
-    }
-
-    [Fact]
-    public void GetEnvironmentVariable_ArgumentException()
-    {
-        var app = new ApplicationBase();
-        var key = GetEnvironmentVariables().LastOrDefault().Item1 ?? "";
-        var ex = Assert.Throws<ArgumentException>(() => app.GetEnvironmentVariable($"{key}z"));
-        _ = ex.ToString(); // ensure message can be formatted
-    }
-
-    private static (string, string)[] GetEnvironmentVariables()
-    {
-        var pairs = new List<(string, string)>();
-        var vars = Environment.GetEnvironmentVariables();
-        foreach (var key in vars.Keys)
-        {
-            pairs.Add(((string)key, (string)vars[key]));
-        }
-
-        return pairs.OrderBy(pair => pair.Item1).ToArray();
-    }
-
-    [Fact]
-    [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Different entry assembly")]
-    public void Info()
-    {
-        var app = new ApplicationBase();
-        var assembly = System.Reflection.Assembly.GetEntryAssembly() ?? System.Reflection.Assembly.GetCallingAssembly();
-        var assemblyName = assembly.GetName();
-        Assert.Equal(assemblyName.Name, app.Info.AssemblyName);
-        Assert.Equal(assemblyName.Version, app.Info.Version);
-    }
-
-    [Fact]
-    public void Log()
-    {
-        var app = new ApplicationBase();
-        var log = app.Log;
-        _ = log.TraceSource;
-        _ = log.DefaultFileLogWriter;
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/AssemblyInfoTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/AssemblyInfoTests.cs
deleted file mode 100644
index 133883b16c6..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/AssemblyInfoTests.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class AssemblyInfoTests
-{
-    [Fact]
-    public void Constructor_ArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new AssemblyInfo(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(AssemblyProperties_TestData))]
-    public void AssemblyProperties(System.Reflection.Assembly assembly)
-    {
-        var assemblyInfo = new AssemblyInfo(assembly);
-        var assemblyName = assembly.GetName();
-        Assert.Equal(assemblyName.Name, assemblyInfo.AssemblyName);
-        Assert.Equal(System.IO.Path.GetDirectoryName(assembly.Location), assemblyInfo.DirectoryPath);
-        Assert.Equal(GetAttributeValue<AssemblyCompanyAttribute>(assembly, attr => attr.Company), assemblyInfo.CompanyName);
-        Assert.Equal(GetAttributeValue<AssemblyCopyrightAttribute>(assembly, attr => attr.Copyright), assemblyInfo.Copyright);
-        Assert.Equal(GetAttributeValue<AssemblyDescriptionAttribute>(assembly, attr => attr.Description), assemblyInfo.Description);
-        Assert.Equal(GetAttributeValue<AssemblyProductAttribute>(assembly, attr => attr.Product), assemblyInfo.ProductName);
-        Assert.Equal(GetAttributeValue<AssemblyTitleAttribute>(assembly, attr => attr.Title), assemblyInfo.Title);
-        Assert.Equal(GetAttributeValue<AssemblyTrademarkAttribute>(assembly, attr => attr.Trademark), assemblyInfo.Trademark);
-        Assert.Equal(assemblyName.Version, assemblyInfo.Version);
-    }
-
-    public static IEnumerable<object[]> AssemblyProperties_TestData()
-    {
-        yield return new object[] { typeof(object).Assembly };
-        yield return new object[] { Assembly.GetExecutingAssembly() };
-    }
-
-    [Fact]
-    public void LoadedAssemblies()
-    {
-        var executingAssembly = Assembly.GetExecutingAssembly();
-        var assemblyInfo = new AssemblyInfo(executingAssembly);
-        var loadedAssemblies = assemblyInfo.LoadedAssemblies;
-        Assert.Contains(executingAssembly, loadedAssemblies);
-    }
-
-    [Fact]
-    public void StackTrace()
-    {
-        // Property is independent of the actual assembly.
-        var assemblyInfo = new AssemblyInfo(Assembly.GetExecutingAssembly());
-        var stackTrace = assemblyInfo.StackTrace;
-        Assert.Contains(nameof(AssemblyInfoTests), stackTrace);
-    }
-
-    [Fact]
-    public void WorkingSet()
-    {
-        // Property is independent of the actual assembly.
-        var assemblyInfo = new AssemblyInfo(Assembly.GetExecutingAssembly());
-        var workingSet = assemblyInfo.WorkingSet;
-        Assert.True(workingSet > 0);
-    }
-
-    private static string GetAttributeValue<TAttribute>(System.Reflection.Assembly assembly, Func<TAttribute, string> getAttributeValue)
-        where TAttribute : Attribute
-    {
-        var attribute = (TAttribute)assembly.GetCustomAttribute(typeof(TAttribute));
-        return (attribute is null) ? "" : getAttributeValue(attribute);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBaseTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBaseTests.cs
deleted file mode 100644
index 99e0922eecb..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/ConsoleApplicationBaseTests.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class ConsoleApplicationBaseTests
-{
-    [Fact]
-    public void CommandLineArgs()
-    {
-        var app = new ConsoleApplicationBase();
-        var expected = System.Environment.GetCommandLineArgs().Skip(1).ToArray();
-        Assert.Equal(expected, app.CommandLineArgs);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/SingleInstanceTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/SingleInstanceTests.cs
deleted file mode 100644
index 5d19f76c2fd..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/SingleInstanceTests.cs
+++ /dev/null
@@ -1,374 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.IO.Pipes;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class SingleInstanceTests
-{
-    private const int SendTimeout = 10000;
-
-    private sealed class ReceivedArgs
-    {
-        private List<string[]> _received = new();
-
-        internal void Add(string[] args)
-        {
-            _received.Add(args);
-        }
-
-        internal ImmutableArray<string[]> Freeze()
-        {
-            var received = _received;
-            Interlocked.CompareExchange(ref _received, null, received);
-            return received.ToImmutableArray();
-        }
-    }
-
-    private readonly dynamic _testAccessor = GetTestHelper();
-
-    private static dynamic GetTestHelper()
-    {
-        var assembly = typeof(Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase).Assembly;
-        var type = assembly.GetType("Microsoft.VisualBasic.ApplicationServices.SingleInstanceHelpers");
-        return type.TestAccessor().Dynamic;
-    }
-
-    private bool TryCreatePipeServer(string pipeName, out NamedPipeServerStream pipeServer)
-    {
-        return _testAccessor.TryCreatePipeServer(pipeName, out pipeServer);
-    }
-
-    private Task WaitForClientConnectionsAsync(NamedPipeServerStream pipeServer, Action<string[]> callback, CancellationToken cancellationToken = default)
-    {
-        return _testAccessor.WaitForClientConnectionsAsync(pipeServer, callback, cancellationToken);
-    }
-
-    private Task SendSecondInstanceArgsAsync(string pipeName, string[] args, CancellationToken cancellationToken)
-    {
-        return _testAccessor.SendSecondInstanceArgsAsync(pipeName, args, cancellationToken);
-    }
-
-    private bool SendSecondInstanceArgs(string pipeName, int timeout, string[] args)
-    {
-        var tokenSource = new CancellationTokenSource();
-        tokenSource.CancelAfter(timeout);
-        try
-        {
-            var awaitable = SendSecondInstanceArgsAsync(pipeName, args, tokenSource.Token).ConfigureAwait(false);
-            awaitable.GetAwaiter().GetResult();
-        }
-        catch (Exception)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString();
-
-    [Fact]
-    public void MultipleDistinctServers()
-    {
-        var pipeServers = new List<NamedPipeServerStream>();
-        int n = 5;
-        try
-        {
-            for (int i = 0; i < n; i++)
-            {
-                Assert.True(TryCreatePipeServer(GetUniqueName(), out var pipeServer));
-                Assert.NotNull(pipeServer);
-                pipeServers.Add(pipeServer);
-            }
-        }
-        finally
-        {
-            foreach (var pipeServer in pipeServers)
-            {
-                pipeServer.Dispose();
-            }
-        }
-    }
-
-    [Fact]
-    public void MultipleServers_Overlapping()
-    {
-        var pipeName = GetUniqueName();
-        const int n = 10;
-        int completed = 0;
-        int created = 0;
-        var tasks = Enumerable.Range(0, n).Select(i => Task.Factory.StartNew(() =>
-        {
-            Thread.Sleep(100);
-            if (TryCreatePipeServer(pipeName, out var pipeServer))
-            {
-                Interlocked.Increment(ref created);
-            }
-
-            using (pipeServer)
-            {
-                Thread.Sleep(10);
-            }
-
-            Interlocked.Increment(ref completed);
-        }, cancellationToken: default, creationOptions: default, scheduler: TaskScheduler.Default)).ToArray();
-        Task.WaitAll(tasks);
-        Assert.Equal(n, completed);
-        Assert.True(created >= 1);
-    }
-
-    [Fact]
-    public void MultipleClients_Sequential()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            const int n = 5;
-            var sentArgs = Enumerable.Range(0, n).Select(i => Enumerable.Range(0, i).Select(i => i.ToString()).ToArray()).ToArray();
-            var receivedArgs = new ReceivedArgs();
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-            for (int i = 0; i < n; i++)
-            {
-                Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, sentArgs[i]));
-            }
-
-            FlushLastConnection(pipeName);
-            Assert.Equal(sentArgs, receivedArgs.Freeze());
-        }
-    }
-
-    [Fact]
-    public void MultipleClients_Overlapping()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            const int n = 5;
-            var sentArgs = Enumerable.Range(0, n).Select(i => Enumerable.Range(0, i).Select(i => i.ToString()).ToArray()).ToArray();
-            var receivedArgs = new ReceivedArgs();
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-            var tasks = Enumerable.Range(0, n).Select(i => Task.Factory.StartNew(() => { Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, sentArgs[i])); }, cancellationToken: default, creationOptions: default, scheduler: TaskScheduler.Default)).ToArray();
-            Task.WaitAll(tasks);
-            FlushLastConnection(pipeName);
-            var receivedSorted = receivedArgs.Freeze().Sort((x, y) => x.Length - y.Length);
-            Assert.Equal(sentArgs, receivedSorted);
-        }
-    }
-
-    // Message that exceeds the buffer size in SingleInstanceHelpers.ReadArgsAsync.
-    [Fact]
-    public void ManyArgs()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            var expectedArgs = getStrings(20000).ToArray();
-            var receivedArgs = new ReceivedArgs();
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-            Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, expectedArgs));
-            FlushLastConnection(pipeName);
-            var actualArgs = receivedArgs.Freeze().Single();
-            Assert.Equal(expectedArgs, actualArgs);
-        }
-
-        static IEnumerable<string> getStrings(int maxTotalLength)
-        {
-            var r = new Random();
-            int n = 0;
-            while (n < maxTotalLength)
-            {
-                var str = getString(r);
-                n += str.Length;
-                yield return str;
-            }
-        }
-
-        static string getString(Random r)
-        {
-            int n = r.Next(1000);
-            var builder = new StringBuilder();
-            for (int i = 0; i < n; i++)
-            {
-                builder.Append((char)('a' + r.Next(26)));
-            }
-
-            return builder.ToString();
-        }
-    }
-
-    [Fact]
-    public void ClientConnectionTimeout()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            var task = Task.Factory.StartNew<bool>(() => SendSecondInstanceArgs(pipeName, timeout: 300, Array.Empty<string>()), cancellationToken: default, creationOptions: default, scheduler: TaskScheduler.Default);
-            bool result = task.Result;
-            Assert.False(result);
-        }
-    }
-
-    // Corresponds to second instance crash sending incomplete args.
-    [Fact]
-    public void ClientConnectBeforeWaitForClientConnection()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            var receivedArgs = new ReceivedArgs();
-            var task = Task.Factory.StartNew<bool>(() => SendSecondInstanceArgs(pipeName, SendTimeout, new[] { "1", "ABC" }), cancellationToken: default, creationOptions: default, scheduler: TaskScheduler.Default);
-            // Allow time for connection.
-            Thread.Sleep(100);
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-            task.Wait();
-            FlushLastConnection(pipeName);
-            Assert.Equal(new[] { new[] { "1", "ABC" } }, receivedArgs.Freeze());
-        }
-    }
-
-    // Send data other than string[].
-    [Fact]
-    public void InvalidClientData()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            var receivedArgs = new ReceivedArgs();
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-
-            sendData(pipeName, Array.Empty<string>()); // valid
-            sendData(pipeName, (int)3); // invalid
-            sendData(pipeName, new[] { "ABC" }); // valid
-            sendData(pipeName, new int[] { 1, 2, 3 }); // invalid
-            sendData(pipeName, new[] { "", "" }); // valid
-            sendData(pipeName, new char[] { '1', '2', '3' }); // invalid
-
-            FlushLastConnection(pipeName);
-
-            Assert.Equal(new[] { Array.Empty<string>(), new[] { "ABC" }, new[] { "", "" } }, receivedArgs.Freeze());
-        }
-
-        static void sendData<T>(string pipeName, T obj)
-        {
-            var pipeClient = CreateClientConnection(pipeName, SendTimeout);
-            if (pipeClient is null)
-            {
-                return;
-            }
-
-            using (pipeClient)
-            {
-                var serializer = new DataContractSerializer(typeof(T));
-                serializer.WriteObject(pipeClient, obj);
-            }
-        }
-    }
-
-    // Corresponds to second instance crash sending incomplete args.
-    [Fact]
-    public void CloseClientAfterClientConnect()
-    {
-        var pipeName = GetUniqueName();
-        Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-        using (pipeServer)
-        {
-            var receivedArgs = new ReceivedArgs();
-            WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-
-            // Send valid args.
-            Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, Array.Empty<string>()));
-            Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, new[] { "1", "ABC" }));
-
-            // Send bad args: close client after connect.
-            closeAfterConnect(pipeName);
-
-            // Send invalid args.
-            sendUnexpectedArgs(pipeName);
-
-            // Send valid args.
-            Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, new[] { "DEF", "2" }));
-
-            FlushLastConnection(pipeName);
-
-            Assert.Equal(new[] { Array.Empty<string>(), new[] { "1", "ABC" }, new[] { "DEF", "2" } }, receivedArgs.Freeze());
-        }
-
-        static void closeAfterConnect(string pipeName)
-        {
-            using var pipeClient = CreateClientConnection(pipeName, SendTimeout);
-        }
-
-        static void sendUnexpectedArgs(string pipeName)
-        {
-            var pipeClient = CreateClientConnection(pipeName, SendTimeout);
-            if (pipeClient is null)
-            {
-                return;
-            }
-
-            using (pipeClient)
-            {
-                pipeClient.Write(new byte[] { 1, 2, 3 }, 0, 3);
-            }
-        }
-    }
-
-    // Corresponds to first instance closing while second instance is sending args.
-    [Fact]
-    public void CloseServerAfterClientConnect()
-    {
-        var pipeName = GetUniqueName();
-        NamedPipeClientStream pipeClient = null;
-        try
-        {
-            var receivedArgs = new ReceivedArgs();
-            Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
-            using (pipeServer)
-            {
-                WaitForClientConnectionsAsync(pipeServer, receivedArgs.Add);
-                pipeClient = CreateClientConnection(pipeName, SendTimeout);
-            }
-
-            Thread.Sleep(500);
-            Assert.Empty(receivedArgs.Freeze());
-        }
-        finally
-        {
-            pipeClient?.Dispose();
-        }
-    }
-
-    // Ensure the previous client connection has been consumed completely by the
-    // server by creating an extra client connection that closes after connecting.
-    private static void FlushLastConnection(string pipeName)
-    {
-        using var _ = CreateClientConnection(pipeName, SendTimeout);
-    }
-
-    private static NamedPipeClientStream CreateClientConnection(string pipeName, int timeout)
-    {
-        var pipeClient = new NamedPipeClientStream(".", pipeName, PipeDirection.Out);
-        try
-        {
-            pipeClient.Connect(timeout);
-        }
-        catch (TimeoutException)
-        {
-            pipeClient.Dispose();
-            return null;
-        }
-
-        return pipeClient;
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupEventArgsTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupEventArgsTests.cs
deleted file mode 100644
index 5cea119d70e..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.ObjectModel;
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class StartupEventArgsTests
-{
-    [Fact]
-    public void Ctor_ReadOnlyCollection()
-    {
-        var collection = new ReadOnlyCollection<string>(new string[] { "a" });
-        var args = new StartupEventArgs(collection);
-        Assert.Same(collection, args.CommandLine);
-    }
-
-    [Fact]
-    public void Ctor_NullCommandLine_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("list", () => new StartupEventArgs(null));
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgsTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgsTests.cs
deleted file mode 100644
index 833937e9d5f..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/StartupNextInstanceEventArgsTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.ObjectModel;
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class StartupNextInstanceEventArgsTests
-{
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Ctor_ReadOnlyCollection_Boolean(bool bringToForeground)
-    {
-        var collection = new ReadOnlyCollection<string>(new string[] { "a" });
-        var args = new StartupNextInstanceEventArgs(collection, bringToForeground);
-        Assert.Same(collection, args.CommandLine);
-        Assert.Equal(bringToForeground, args.BringToForeground);
-    }
-
-    [Fact]
-    public void Ctor_NullCommandLine_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("list", () => new StartupNextInstanceEventArgs(null, bringToForegroundFlag: true));
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void BringToForeground_Set_GetReturnsExpected(bool value)
-    {
-        var collection = new ReadOnlyCollection<string>(new string[] { "a" });
-        var args = new StartupNextInstanceEventArgs(collection, bringToForegroundFlag: true)
-        {
-            BringToForeground = value
-        };
-        Assert.Equal(value, args.BringToForeground);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgsTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgsTests.cs
deleted file mode 100644
index 2ecd2d153c4..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UnhandledExceptionEventArgsTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class UnhandledExceptionEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Bool_Exception_TestData()
-    {
-        yield return new object[] { true, null };
-        yield return new object[] { false, new Exception() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Bool_Exception_TestData))]
-    public void Ctor_Bool_Exception(bool exitApplication, Exception exception)
-    {
-        var args = new UnhandledExceptionEventArgs(exitApplication, exception);
-        Assert.Same(exception, args.Exception);
-        Assert.Equal(exitApplication, args.ExitApplication);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ExitApplication_Set_GetReturnsExpected(bool value)
-    {
-        var args = new UnhandledExceptionEventArgs(true, null);
-        args.ExitApplication = value;
-        Assert.Equal(value, args.ExitApplication);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UserTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UserTests.cs
deleted file mode 100644
index bf143be283f..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/UserTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class UserTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var user = new User();
-        Assert.Equal(System.Threading.Thread.CurrentPrincipal, user.CurrentPrincipal);
-        if (user.CurrentPrincipal is not null)
-        {
-            Assert.Equal(System.Threading.Thread.CurrentPrincipal.Identity.Name, user.Name);
-            Assert.Equal(System.Threading.Thread.CurrentPrincipal.Identity.IsAuthenticated, user.IsAuthenticated);
-            Assert.Equal(System.Threading.Thread.CurrentPrincipal.IsInRole("Guest"), user.IsInRole("Guest"));
-        }
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs
deleted file mode 100644
index 368ded09eab..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/ApplicationServices/WindowsFormsApplicationBaseTests.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using System.Reflection.Emit;
-using System.Runtime.InteropServices;
-
-namespace Microsoft.VisualBasic.ApplicationServices.Tests;
-
-public class WindowsFormsApplicationBaseTests
-{
-    private static string GetAppID(Assembly assembly)
-    {
-        var testAccessor = typeof(WindowsFormsApplicationBase).TestAccessor();
-        return testAccessor.Dynamic.GetApplicationInstanceID(assembly);
-    }
-
-    [Fact]
-    public void GetApplicationInstanceID()
-    {
-        var assembly = typeof(WindowsFormsApplicationBaseTests).Assembly;
-        var expectedId = assembly.ManifestModule.ModuleVersionId.ToString();
-        Assert.Equal(expectedId, GetAppID(assembly));
-    }
-
-    private static string GetUniqueIDFromAssembly(string guid, Version version)
-    {
-        var attributeBuilder = new CustomAttributeBuilder(
-            typeof(GuidAttribute).GetConstructor(new[] { typeof(string) }), new[] { guid });
-        var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
-            new AssemblyName(Guid.NewGuid().ToString()) { Version = version },
-            AssemblyBuilderAccess.RunAndCollect,
-            new[] { attributeBuilder });
-        assemblyBuilder.DefineDynamicModule(Guid.NewGuid().ToString());
-        return GetAppID(assemblyBuilder);
-    }
-
-    [Fact]
-    public void GetApplicationInstanceID_GuidAttribute()
-    {
-        var guid = Guid.NewGuid().ToString();
-        Assert.Equal($"{guid}1.2", GetUniqueIDFromAssembly(guid, new Version(1, 2, 3, 4)));
-    }
-
-    [Fact]
-    public void GetApplicationInstanceID_GuidAttributeNewVersion()
-    {
-        var guid = Guid.NewGuid().ToString();
-        Assert.Equal($"{guid}0.0", GetUniqueIDFromAssembly(guid, new Version()));
-    }
-
-    [Fact]
-    public void GetApplicationInstanceID_GuidAttributeNullVersion()
-    {
-        var guid = Guid.NewGuid().ToString();
-        Assert.Equal($"{guid}0.0", GetUniqueIDFromAssembly(guid, version: null));
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/AudioTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/AudioTests.cs
deleted file mode 100644
index 116a7efc5fb..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/AudioTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class AudioTests
-{
-    [Fact]
-    public void Play()
-    {
-        var location = Path.Combine(Path.GetTempPath(), GetUniqueName());
-        var audio = new Audio();
-        Assert.Throws<FileNotFoundException>(() => audio.Play(location));
-    }
-
-    // Not tested:
-    //    Public Sub PlaySystemSound(ByVal systemSound As System.Media.SystemSound)
-
-    [Fact]
-    public void Stop()
-    {
-        var audio = new Audio();
-        audio.Stop();
-    }
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString("D");
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ClockTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ClockTests.cs
deleted file mode 100644
index 6b2be555f59..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ClockTests.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class ClockTests
-{
-    [Fact]
-    public void LocalTime()
-    {
-        var clock = new Clock();
-
-        var before = clock.LocalTime;
-        System.Threading.Thread.Sleep(10);
-
-        var now = DateTime.Now;
-        System.Threading.Thread.Sleep(10);
-
-        var after = clock.LocalTime;
-
-        Assert.True(before <= now);
-        Assert.True(now <= after);
-    }
-
-    [Fact]
-    public void GmtTime()
-    {
-        var clock = new Clock();
-
-        var before = clock.GmtTime;
-        System.Threading.Thread.Sleep(10);
-
-        var now = DateTime.UtcNow;
-        System.Threading.Thread.Sleep(10);
-
-        var after = clock.GmtTime;
-
-        Assert.True(before <= now);
-        Assert.True(now <= after);
-    }
-
-    [Fact]
-    public void TickCount()
-    {
-        var clock = new Clock();
-
-        var before = clock.TickCount;
-        System.Threading.Thread.Sleep(10);
-
-        var after = clock.TickCount;
-        Assert.True(before <= after);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerInfoTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerInfoTests.cs
deleted file mode 100644
index 2b0d7cfd049..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerInfoTests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class ComputerInfoTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var info = new ComputerInfo();
-        Assert.Equal(System.Globalization.CultureInfo.InstalledUICulture, info.InstalledUICulture);
-        Assert.Equal(System.Environment.OSVersion.Platform.ToString(), info.OSPlatform);
-        Assert.Equal(System.Environment.OSVersion.Version.ToString(), info.OSVersion);
-    }
-
-    [Fact]
-    public void Memory()
-    {
-        var info = new ComputerInfo();
-        if (PlatformDetection.IsWindows)
-        {
-            Assert.NotEqual(0u, info.AvailablePhysicalMemory);
-            Assert.NotEqual(0u, info.AvailableVirtualMemory);
-            Assert.NotEqual(0u, info.TotalPhysicalMemory);
-            Assert.NotEqual(0u, info.TotalVirtualMemory);
-        }
-        else
-        {
-            Assert.Throws<PlatformNotSupportedException>(() => info.AvailablePhysicalMemory);
-            Assert.Throws<PlatformNotSupportedException>(() => info.AvailableVirtualMemory);
-            Assert.Throws<PlatformNotSupportedException>(() => info.TotalPhysicalMemory);
-            Assert.Throws<PlatformNotSupportedException>(() => info.TotalVirtualMemory);
-        }
-    }
-
-    [Fact]
-    public void OSFullName()
-    {
-        var info = new ComputerInfo();
-        var fullName = info.OSFullName;
-        Assert.False(string.IsNullOrEmpty(fullName));
-        Assert.Equal(System.Runtime.InteropServices.RuntimeInformation.OSDescription, fullName);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerTests.cs
deleted file mode 100644
index f0614cb1758..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ComputerTests.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class ComputerTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var computer = new Computer();
-
-        var audio = computer.Audio;
-        Assert.NotNull(audio);
-        Assert.Same(audio, computer.Audio);
-
-        var clipboard = computer.Clipboard;
-        Assert.NotNull(clipboard);
-        Assert.Same(clipboard, computer.Clipboard);
-
-        var keyboard = computer.Keyboard;
-        Assert.NotNull(keyboard);
-        Assert.Same(keyboard, computer.Keyboard);
-
-        var mouse = computer.Mouse;
-        Assert.NotNull(mouse);
-        Assert.Same(mouse, computer.Mouse);
-    }
-
-    [Fact]
-    public void Screen()
-    {
-        var computer = new Computer();
-        Assert.Equal(System.Windows.Forms.Screen.PrimaryScreen, computer.Screen);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/KeyboardTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/KeyboardTests.cs
deleted file mode 100644
index 6dde1beacef..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/KeyboardTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class KeyboardTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var keyboard = new Keyboard();
-        _ = keyboard.ShiftKeyDown;
-        _ = keyboard.AltKeyDown;
-        _ = keyboard.CtrlKeyDown;
-        _ = keyboard.CapsLock;
-        _ = keyboard.NumLock;
-        _ = keyboard.ScrollLock;
-    }
-
-    // Not tested:
-    //    Public Sub SendKeys(ByVal keys As String)
-    //    Public Sub SendKeys(ByVal keys As String, ByVal wait As Boolean)
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/MouseTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/MouseTests.cs
deleted file mode 100644
index 294c38cd441..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/MouseTests.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class MouseTests
-{
-    public static bool NoMousePresent => !SystemInformation.MousePresent;
-
-    public static bool NoMouseWheelPresent => NoMousePresent || !SystemInformation.MouseWheelPresent;
-
-    [ConditionalFact(typeof(SystemInformation), nameof(SystemInformation.MousePresent))]
-    public void Mouse_ButtonsSwapped_Get_ReturnsExpected()
-    {
-        var mouse = new Mouse();
-        Assert.Equal(SystemInformation.MouseButtonsSwapped, mouse.ButtonsSwapped);
-        Assert.Equal(mouse.ButtonsSwapped, mouse.ButtonsSwapped);
-    }
-
-    [ConditionalFact(nameof(NoMousePresent))]
-    public void Mouse_ButtonsSwapped_GetNoMousePresent_ThrowsInvalidOperationException()
-    {
-        if (NoMousePresent)
-        {
-            var mouse = new Mouse();
-            Assert.Throws<InvalidOperationException>(() => mouse.ButtonsSwapped);
-        }
-    }
-
-    [ConditionalFact(typeof(SystemInformation), nameof(SystemInformation.MousePresent))]
-    public void Mouse_WheelExists_Get_ReturnsExpected()
-    {
-        var mouse = new Mouse();
-        Assert.Equal(SystemInformation.MouseWheelPresent, mouse.WheelExists);
-        Assert.Equal(mouse.WheelExists, mouse.WheelExists);
-    }
-
-    [ConditionalFact(nameof(NoMousePresent))]
-    public void Mouse_WheelExists_GetNoMousePresent_ThrowsInvalidOperationException()
-    {
-        if (NoMousePresent)
-        {
-            var mouse = new Mouse();
-            Assert.Throws<InvalidOperationException>(() => mouse.WheelExists);
-        }
-    }
-
-    [ConditionalFact(typeof(SystemInformation), nameof(SystemInformation.MousePresent), nameof(SystemInformation.MouseWheelPresent))]
-    public void Mouse_WheelScrollLines_Get_ReturnsExpected()
-    {
-        if (SystemInformation.MouseWheelPresent)
-        {
-            var mouse = new Mouse();
-            Assert.Equal(SystemInformation.MouseWheelScrollLines, mouse.WheelScrollLines);
-            Assert.Equal(mouse.WheelScrollLines, mouse.WheelScrollLines);
-        }
-    }
-
-    [ConditionalFact(nameof(NoMouseWheelPresent))]
-    public void Mouse_WheelScrollLines_GetNoMouseWheelPresent_ThrowsInvalidOperationException()
-    {
-        if (NoMouseWheelPresent)
-        {
-            var mouse = new Mouse();
-            Assert.Throws<InvalidOperationException>(() => mouse.WheelScrollLines);
-        }
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkAvailableEventArgsTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkAvailableEventArgsTests.cs
deleted file mode 100644
index 57440a76fad..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkAvailableEventArgsTests.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class NetworkAvailableEventArgsTests
-{
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Ctor_Bool(bool networkAvailable)
-    {
-        var args = new NetworkAvailableEventArgs(networkAvailable);
-        Assert.Equal(networkAvailable, args.IsNetworkAvailable);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkTests.cs
deleted file mode 100644
index 47879b54643..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/NetworkTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class NetworkTests
-{
-    [Fact]
-    public void IsAvailable()
-    {
-        var network = new Network();
-        Assert.Equal(System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable(), network.IsAvailable);
-    }
-
-    [Fact]
-    public void Ping()
-    {
-        var network = new Network();
-        Assert.True(network.Ping("127.0.0.1"));
-    }
-
-    // Not tested:
-    //    Public Sub DownloadFile(...) [multiple overloads]
-    //    Public Sub UploadFile(...) [multiple overloads]
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ServerComputerTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ServerComputerTests.cs
deleted file mode 100644
index 8311b2561fd..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Devices/ServerComputerTests.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Devices.Tests;
-
-public class ServerComputerTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var computer = new ServerComputer();
-
-        Assert.Equal(System.Environment.MachineName, computer.Name);
-
-        var clock = computer.Clock;
-        Assert.NotNull(clock);
-        Assert.Same(clock, computer.Clock);
-
-        var fileSystem = computer.FileSystem;
-        Assert.NotNull(fileSystem);
-        Assert.Same(fileSystem, computer.FileSystem);
-
-        var info = computer.Info;
-        Assert.NotNull(info);
-        Assert.Same(info, computer.Info);
-
-        var network = computer.Network;
-        Assert.NotNull(network);
-        Assert.Same(network, computer.Network);
-
-        var registry = computer.Registry;
-        Assert.NotNull(registry);
-        Assert.Same(registry, computer.Registry);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/FileLogTraceListenerTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/FileLogTraceListenerTests.cs
deleted file mode 100644
index 54975475a41..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/FileLogTraceListenerTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Logging.Tests;
-
-public class FileLogTraceListenerTests : FileCleanupTestBase
-{
-    [Fact]
-    public void Properties()
-    {
-        var listener = new FileLogTraceListener();
-        _ = listener.Location;
-        _ = listener.AutoFlush;
-        _ = listener.IncludeHostName;
-        _ = listener.Append;
-        _ = listener.DiskSpaceExhaustedBehavior;
-        _ = listener.BaseFileName;
-        _ = listener.FullLogFileName;
-        _ = listener.LogFileCreationSchedule;
-        _ = listener.MaxFileSize;
-        _ = listener.ReserveDiskSpace;
-        _ = listener.Delimiter;
-        _ = listener.Encoding;
-        _ = listener.CustomLocation;
-    }
-
-    [Fact]
-    public void Write()
-    {
-        var cache = new TraceEventCache();
-        var listener = new FileLogTraceListener();
-        listener.Location = LogFileLocation.Custom;
-        listener.CustomLocation = GetTestFilePath();
-
-        listener.Write("Write");
-        listener.WriteLine("WriteLine");
-        listener.TraceEvent(eventCache: cache, source: "Source", eventType: TraceEventType.Warning, id: 3, message: "TraceEvent");
-        listener.TraceData(eventCache: cache, source: "Source", eventType: TraceEventType.Error, id: 4, data: "TraceData");
-        listener.Flush();
-        listener.Close();
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/LogTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/LogTests.cs
deleted file mode 100644
index b066f6e40c8..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/Logging/LogTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.Logging.Tests;
-
-public class LogTests : FileCleanupTestBase
-{
-    [Fact]
-    public void Properties()
-    {
-        var log = new Log();
-        _ = log.TraceSource;
-        _ = log.DefaultFileLogWriter;
-    }
-
-    [Fact]
-    public void Write()
-    {
-        var log = new Log();
-        var listener = log.DefaultFileLogWriter;
-        listener.Location = LogFileLocation.Custom;
-        listener.CustomLocation = GetTestFilePath();
-
-        log.WriteEntry("WriteEntry");
-        log.WriteEntry("WriteEntry", severity: System.Diagnostics.TraceEventType.Warning);
-        log.WriteEntry("WriteEntry", severity: System.Diagnostics.TraceEventType.Error, id: 3);
-
-        log.WriteException(new System.ArgumentException());
-        log.WriteException(new System.ArgumentException(), severity: System.Diagnostics.TraceEventType.Warning, additionalInfo: "AdditionalInfo");
-        log.WriteException(new System.ArgumentException(), severity: System.Diagnostics.TraceEventType.Warning, additionalInfo: "AdditionalInfo", id: 6);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/ClipboardProxyTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/ClipboardProxyTests.cs
deleted file mode 100644
index aa95e0afc5a..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/ClipboardProxyTests.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Microsoft.VisualBasic.Devices;
-using DataFormats = System.Windows.Forms.DataFormats;
-using TextDataFormat = System.Windows.Forms.TextDataFormat;
-
-namespace Microsoft.VisualBasic.MyServices.Tests;
-
-public class ClipboardProxyTests
-{
-    [WinFormsFact]
-    public void Clear()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        var text = GetUniqueText();
-        clipboard.SetText(text);
-        Assert.True(System.Windows.Forms.Clipboard.ContainsText());
-        clipboard.Clear();
-        Assert.False(System.Windows.Forms.Clipboard.ContainsText());
-    }
-
-    [WinFormsFact]
-    public void Text()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        var text = GetUniqueText();
-        clipboard.SetText(text, TextDataFormat.UnicodeText);
-        Assert.Equal(System.Windows.Forms.Clipboard.ContainsText(), clipboard.ContainsText());
-        Assert.Equal(System.Windows.Forms.Clipboard.GetText(), clipboard.GetText());
-        Assert.Equal(System.Windows.Forms.Clipboard.GetText(TextDataFormat.UnicodeText), clipboard.GetText(TextDataFormat.UnicodeText));
-        Assert.Equal(text, clipboard.GetText(TextDataFormat.UnicodeText));
-    }
-
-    [WinFormsFact]
-    public void Image()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        var image = new Bitmap(2, 2);
-        Assert.Equal(System.Windows.Forms.Clipboard.ContainsImage(), clipboard.ContainsImage());
-        Assert.Equal(System.Windows.Forms.Clipboard.GetImage(), clipboard.GetImage());
-        clipboard.SetImage(image);
-    }
-
-    [WinFormsFact]
-    public void Audio()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        Assert.Equal(System.Windows.Forms.Clipboard.ContainsAudio(), clipboard.ContainsAudio());
-        // Not tested:
-        //   Public Function GetAudioStream() As Stream
-        //   Public Sub SetAudio(ByVal audioBytes As Byte())
-        //   Public Sub SetAudio(ByVal audioStream As Stream)
-    }
-
-    [WinFormsFact]
-    public void FileDropList()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        Assert.Equal(System.Windows.Forms.Clipboard.ContainsFileDropList(), clipboard.ContainsFileDropList());
-        // Not tested:
-        //   Public Function GetFileDropList() As StringCollection
-        //   Public Sub SetFileDropList(ByVal filePaths As StringCollection)
-    }
-
-    [WinFormsFact]
-    public void Data()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        object data = GetUniqueText();
-        Assert.Equal(System.Windows.Forms.Clipboard.ContainsData(DataFormats.UnicodeText), clipboard.ContainsData(DataFormats.UnicodeText));
-        Assert.Equal(System.Windows.Forms.Clipboard.GetData(DataFormats.UnicodeText), clipboard.GetData(DataFormats.UnicodeText));
-        clipboard.SetData(DataFormats.UnicodeText, data);
-    }
-
-    [WinFormsFact]
-    public void DataObject()
-    {
-        var clipboard = (new Computer()).Clipboard;
-        object data = GetUniqueText();
-        Assert.Equal(System.Windows.Forms.Clipboard.GetDataObject().GetData(DataFormats.UnicodeText), clipboard.GetDataObject().GetData(DataFormats.UnicodeText));
-        clipboard.SetDataObject(new System.Windows.Forms.DataObject(data));
-    }
-
-    private static string GetUniqueText() => Guid.NewGuid().ToString("D");
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/FileSystemProxyTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/FileSystemProxyTests.cs
deleted file mode 100644
index d288e9a57f1..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/FileSystemProxyTests.cs
+++ /dev/null
@@ -1,706 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.VisualBasic.FileIO;
-using SearchOption = Microsoft.VisualBasic.FileIO.SearchOption;
-
-namespace Microsoft.VisualBasic.MyServices.Tests;
-
-// File tests cloned from Microsoft.VisualBasic.FileIO.Tests.FileSystemTests.
-public class FileSystemProxyTests : FileCleanupTestBase
-{
-    private const string DestData = "xXy";
-    private const string SourceData = "aAb";
-
-    private readonly FileSystemProxy _fileSystem = new Microsoft.VisualBasic.Devices.ServerComputer().FileSystem;
-
-    private static bool HasExpectedData(string FileNameWithPath, string ExpectedData)
-    {
-        string actualData = System.IO.File.ReadAllText(FileNameWithPath);
-        return ExpectedData == actualData;
-    }
-
-    private static void WriteFile(string FileName, string TestData)
-    {
-        System.IO.File.WriteAllText(FileName, TestData);
-    }
-
-    [Fact]
-    public void CombinePathTest_BadBaseDirectory_RelativePath()
-    {
-        Assert.Throws<ArgumentNullException>(() => _fileSystem.CombinePath(null, "Test2"));
-        Assert.Throws<ArgumentNullException>(() => _fileSystem.CombinePath("", "Test2"));
-    }
-
-    [Fact]
-    public void CombinePathTest_BaseDirectory_RelativePath()
-    {
-        var TestDirInfo = new System.IO.DirectoryInfo(TestDirectory);
-        var Root = TestDirInfo.Root.Name;
-        Assert.Equal(_fileSystem.CombinePath(Root, "Test2"), System.IO.Path.Combine(Root, "Test2"));
-    }
-
-    [Fact]
-    public void CombinePathTest_RootDirectory_RelativePath()
-    {
-        Assert.Equal(_fileSystem.CombinePath(TestDirectory, null), TestDirectory);
-        Assert.Equal(_fileSystem.CombinePath(TestDirectory, ""), TestDirectory);
-        Assert.Equal(_fileSystem.CombinePath(TestDirectory, "Test"), System.IO.Path.Combine(TestDirectory, "Test"));
-    }
-
-    [Fact]
-    public void CopyDirectory_SourceDirectoryName_DestinationDirectoryName()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        _fileSystem.CopyDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory);
-        Assert.Equal(System.IO.Directory.GetFiles(FullPathToSourceDirectory).Length, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure copy transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-
-        System.IO.Directory.Delete(FullPathToTargetDirectory, recursive: true);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        CreateTestFile(TestData: SourceData, PathFromBase: "TargetDirectory", TestFileName: $"NewFile0");
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.CopyDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory));
-    }
-
-    [Fact]
-    public void CopyDirectory_SourceDirectoryName_DestinationDirectoryName_OverwriteFalse()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        _fileSystem.CopyDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: false);
-        Assert.Equal(System.IO.Directory.GetFiles(FullPathToSourceDirectory).Length, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure copy transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-
-        System.IO.Directory.Delete(FullPathToTargetDirectory, recursive: true);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        CreateTestFile(DestData, PathFromBase: "TargetDirectory", TestFileName: $"NewFile0");
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.CopyDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: false));
-        Assert.Equal(System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length, System.IO.Directory.GetFiles(FullPathToSourceDirectory).Length);
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            Assert.True(HasExpectedData(CurrentFile, CurrentFile.EndsWith("0") ? DestData : SourceData));
-        }
-    }
-
-    [Fact]
-    public void CopyDirectory_SourceDirectoryName_DestinationDirectoryName_OverwriteTrue()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        _fileSystem.CopyDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: true);
-        Assert.Equal(System.IO.Directory.GetFiles(FullPathToSourceDirectory).Length, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure copy transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-    }
-
-    [Fact]
-    public void CopyFile_FileSourceFileName_DestinationFileName()
-    {
-        var testFileSource = GetTestFilePath();
-        var testFileDest = GetTestFilePath();
-
-        // Write and copy file
-        WriteFile(testFileSource, SourceData);
-        WriteFile(testFileDest, DestData);
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.CopyFile(testFileSource, testFileDest));
-
-        // Ensure copy didn't overwrite existing data
-        Assert.True(HasExpectedData(testFileDest, DestData));
-
-        // Get a new destination name
-        testFileDest = GetTestFilePath();
-        _fileSystem.CopyFile(testFileSource, testFileDest);
-
-        // Ensure copy transferred written data
-        Assert.True(HasExpectedData(testFileDest, SourceData));
-    }
-
-    [Fact]
-    public void CopyFile_FileSourceFileName_DestinationFileName_OverwriteFalse()
-    {
-        var testFileSource = GetTestFilePath();
-        var testFileDest = GetTestFilePath();
-
-        // Write and copy file
-        WriteFile(testFileSource, SourceData);
-        WriteFile(testFileDest, DestData);
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.CopyFile(testFileSource, testFileDest, overwrite: false));
-
-        // Ensure copy didn't overwrite existing data
-        Assert.True(HasExpectedData(testFileDest, DestData));
-    }
-
-    [Fact]
-    public void CopyFile_FileSourceFileName_DestinationFileName_OverwriteTrue()
-    {
-        var testFileSource = GetTestFilePath();
-        var testFileDest = GetTestFilePath();
-
-        // Write and copy file
-        WriteFile(testFileSource, SourceData);
-        WriteFile(testFileDest, DestData);
-        _fileSystem.CopyFile(testFileSource, testFileDest, overwrite: true);
-
-        // Ensure copy transferred written data
-        Assert.True(HasExpectedData(testFileDest, SourceData));
-    }
-
-    [Fact]
-    public void CreateDirectory_Directory()
-    {
-        var FullPathToNewDirectory = System.IO.Path.Combine(TestDirectory, "NewDirectory");
-        Assert.False(System.IO.Directory.Exists(FullPathToNewDirectory));
-        _fileSystem.CreateDirectory(FullPathToNewDirectory);
-        Assert.True(System.IO.Directory.Exists(FullPathToNewDirectory));
-    }
-
-    [Fact]
-    public void CurrentDirectoryGet()
-    {
-        var CurrentDirectory = System.IO.Directory.GetCurrentDirectory();
-        Assert.Equal(_fileSystem.CurrentDirectory, CurrentDirectory);
-    }
-
-    [Fact]
-    public void CurrentDirectorySet()
-    {
-        var SavedCurrentDirectory = System.IO.Directory.GetCurrentDirectory();
-        _fileSystem.CurrentDirectory = TestDirectory;
-        Assert.Equal(TestDirectory, _fileSystem.CurrentDirectory);
-        _fileSystem.CurrentDirectory = SavedCurrentDirectory;
-        Assert.Equal(_fileSystem.CurrentDirectory, SavedCurrentDirectory);
-    }
-
-    [Fact]
-    public void DeleteDirectory_Directory_DeleteAllContents()
-    {
-        var FullPathToNewDirectory = System.IO.Path.Combine(TestDirectory, "NewDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToNewDirectory);
-        Assert.True(System.IO.Directory.Exists(FullPathToNewDirectory));
-        var testFileSource = CreateTestFile(SourceData, PathFromBase: "NewDirectory", TestFileName: "TestFile");
-        Assert.True(System.IO.File.Exists(testFileSource));
-        _fileSystem.DeleteDirectory(FullPathToNewDirectory, DeleteDirectoryOption.DeleteAllContents);
-        Assert.False(System.IO.Directory.Exists(FullPathToNewDirectory));
-    }
-
-    [Fact]
-    public void DeleteDirectory_Directory_ThrowIfDirectoryNonEmpty()
-    {
-        var FullPathToNewDirectory = System.IO.Path.Combine(TestDirectory, "NewDirectory");
-        _fileSystem.CreateDirectory(FullPathToNewDirectory);
-        Assert.True(System.IO.Directory.Exists(FullPathToNewDirectory));
-        var testFileSource = CreateTestFile(SourceData, PathFromBase: "NewDirectory", TestFileName: "TestFile");
-
-        Assert.True(System.IO.File.Exists(testFileSource));
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.DeleteDirectory(FullPathToNewDirectory, DeleteDirectoryOption.ThrowIfDirectoryNonEmpty));
-        Assert.True(System.IO.Directory.Exists(FullPathToNewDirectory));
-        Assert.True(System.IO.File.Exists(testFileSource));
-    }
-
-    [Fact]
-    public void DeleteFile_File()
-    {
-        var testFileSource = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-
-        Assert.True(System.IO.File.Exists(testFileSource));
-        _fileSystem.DeleteFile(testFileSource);
-        Assert.False(System.IO.File.Exists(testFileSource));
-    }
-
-    [Fact]
-    public void DirectoryExists_Directory()
-    {
-        Assert.True(_fileSystem.DirectoryExists(TestDirectory));
-        Assert.False(_fileSystem.DirectoryExists(System.IO.Path.Combine(TestDirectory, "NewDirectory")));
-    }
-
-    // Not tested:
-    //   public System.Collections.ObjectModel.ReadOnlyCollection<System.IO.DriveInfo> Drives { get { throw null; } }
-
-    [Fact]
-    public void FileExists_File()
-    {
-        var testFileSource = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-        Assert.True(_fileSystem.FileExists(testFileSource));
-        _fileSystem.FileExists(testFileSource);
-        System.IO.File.Delete(testFileSource);
-        Assert.False(_fileSystem.FileExists(testFileSource));
-    }
-
-    // Not tested:
-    //   public System.Collections.ObjectModel.ReadOnlyCollection<string> FindInFiles(string directory, string containsText, bool ignoreCase, FileIO.SearchOption searchType) { throw null; }
-    //   public System.Collections.ObjectModel.ReadOnlyCollection<string> FindInFiles(string directory, string containsText, bool ignoreCase, FileIO.SearchOption searchType, params string[] fileWildcards) { throw null; }
-
-    [Fact]
-    public void GetDirectories_Directory()
-    {
-        var DirectoryList = _fileSystem.GetDirectories(TestDirectory);
-        Assert.Empty(DirectoryList);
-        for (int i = 0; i < 6; i++)
-        {
-            System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}"));
-        }
-
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory);
-        Assert.Equal(6, DirectoryList.Count);
-        for (int i = 0; i < 6; i++)
-        {
-            Assert.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}"), DirectoryList);
-        }
-
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory0", $"NewSubSubDirectory"));
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory);
-        Assert.Equal(6, DirectoryList.Count);
-    }
-
-    [Fact]
-    public void GetDirectories_Directory_SearchOption()
-    {
-        var DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
-        Assert.Empty(DirectoryList);
-        for (int i = 0; i < 6; i++)
-        {
-            System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}"));
-        }
-
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
-        Assert.Equal(6, DirectoryList.Count);
-        for (int i = 0; i < 6; i++)
-        {
-            Assert.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}"), DirectoryList);
-        }
-
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory0", $"NewSubSubDirectory"));
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
-        Assert.Equal(6, DirectoryList.Count);
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories);
-        Assert.Equal(7, DirectoryList.Count);
-    }
-
-    [Fact]
-    public void GetDirectories_Directory_SearchOption_Wildcards()
-    {
-        var DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*");
-        Assert.Empty(DirectoryList);
-        var CreatedDirectories = new List<string>();
-        for (int i = 0; i < 6; i++)
-        {
-            CreatedDirectories.Add(System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}")).Name);
-        }
-
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000", "*001");
-        Assert.Equal(2, DirectoryList.Count);
-        for (int i = 0; i < 2; i++)
-        {
-            var DirectoryName = System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}");
-            Assert.Contains(DirectoryName, DirectoryList);
-        }
-
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory000", $"NewSubSubDirectory000"));
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000");
-        Assert.Single(DirectoryList);
-        DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories, "*000");
-        Assert.Equal(2, DirectoryList.Count);
-    }
-
-    [Fact]
-    public void GetDirectoryInfo_Directory()
-    {
-        for (int i = 0; i < 6; i++)
-        {
-            System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory{i}"));
-        }
-
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory0", $"NewSubSubDirectory"));
-        var info = _fileSystem.GetDirectoryInfo(TestDirectory);
-        var infoFromIO = new System.IO.DirectoryInfo(TestDirectory);
-        Assert.Equal(info.CreationTime, infoFromIO.CreationTime);
-        Assert.Equal(info.Extension, infoFromIO.Extension);
-        Assert.Equal(info.FullName, TestDirectory);
-        Assert.Equal(info.LastAccessTime, infoFromIO.LastAccessTime);
-        Assert.Equal(info.Name, infoFromIO.Name);
-        Assert.Equal(info.Parent.ToString(), infoFromIO.Parent.ToString());
-        Assert.Equal(info.Root.Name, infoFromIO.Root.Name);
-    }
-
-    [Fact]
-    public void GetDriveInfo_Drive()
-    {
-        var Drives = System.IO.DriveInfo.GetDrives();
-        Assert.True(Drives.Length > 0);
-        Assert.Equal(_fileSystem.GetDriveInfo(Drives[0].Name).Name, new System.IO.DriveInfo(Drives[0].Name).Name);
-    }
-
-    [Fact]
-    public void GetFileInfo_File()
-    {
-        var TestFile = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-
-        var FileInfoFromSystemIO = new System.IO.FileInfo(TestFile);
-        Assert.NotNull(FileInfoFromSystemIO);
-
-        var info = _fileSystem.GetFileInfo(TestFile);
-        Assert.NotNull(info);
-        Assert.True(info.Exists);
-        Assert.Equal(info.Attributes, FileInfoFromSystemIO.Attributes);
-        Assert.Equal(info.CreationTime, FileInfoFromSystemIO.CreationTime);
-        Assert.True(info.CreationTime > DateTime.MinValue);
-        Assert.Equal(info.DirectoryName, FileInfoFromSystemIO.DirectoryName);
-        Assert.Equal(info.Extension, FileInfoFromSystemIO.Extension);
-        Assert.Equal(info.FullName, FileInfoFromSystemIO.FullName);
-        Assert.Equal(info.IsReadOnly, FileInfoFromSystemIO.IsReadOnly);
-        Assert.Equal(info.LastAccessTime, FileInfoFromSystemIO.LastAccessTime);
-        Assert.Equal(info.LastWriteTime, FileInfoFromSystemIO.LastWriteTime);
-        Assert.Equal(info.Length, FileInfoFromSystemIO.Length);
-        Assert.Equal(info.Name, FileInfoFromSystemIO.Name);
-    }
-
-    [Fact]
-    public void GetFiles_Directory()
-    {
-        var FileList = _fileSystem.GetFiles(TestDirectory);
-        Assert.Empty(FileList);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
-        }
-
-        FileList = _fileSystem.GetFiles(TestDirectory);
-        Assert.Equal(6, FileList.Count);
-        for (int i = 0; i < 6; i++)
-        {
-            Assert.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}"), FileList);
-        }
-
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, "GetFiles_DirectoryNewSubDirectory"));
-        CreateTestFile(SourceData, PathFromBase: "GetFiles_DirectoryNewSubDirectory", TestFileName: "NewFile");
-        FileList = _fileSystem.GetFiles(TestDirectory);
-        Assert.Equal(6, FileList.Count);
-    }
-
-    [Fact]
-    public void GetFiles_Directory_SearchOption()
-    {
-        var NewSubDirectoryPath = System.IO.Path.Combine(TestDirectory, "GetFiles_Directory_SearchOptionNewSubDirectory");
-        System.IO.Directory.CreateDirectory(NewSubDirectoryPath);
-        CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOptionNewSubDirectory", TestFileName: "NewFile");
-        var FileList = _fileSystem.GetFiles(TestDirectory);
-        Assert.Empty(FileList);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
-        }
-
-        FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly);
-        CreateTestFile(SourceData, PathFromBase: null, TestFileName: "NewFile");
-        Assert.Equal(6, FileList.Count);
-        for (int i = 0; i < 6; i++)
-        {
-            Assert.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}"), FileList);
-        }
-
-        FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories);
-        Assert.Equal(8, FileList.Count);
-        for (int i = 0; i < 7; i++)
-        {
-            Assert.True(System.IO.File.Exists(FileList[i]));
-        }
-    }
-
-    [Fact]
-    public void GetFiles_Directory_SearchOption_Wildcards()
-    {
-        var FileList = _fileSystem.GetFiles(TestDirectory);
-        Assert.Empty(FileList);
-        var TestFileList = new List<string>();
-        for (int i = 0; i < 6; i++)
-        {
-            TestFileList.Add(CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}{(i % 2 == 0 ? ".vb" : ".cs")}"));
-        }
-
-        FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly, "*.vb");
-        Assert.Equal(3, FileList.Count);
-        for (int i = 0; i < 3; i++)
-        {
-            Assert.Contains(FileList[i], TestFileList);
-        }
-
-        var NewSubDirectoryPath = System.IO.Path.Combine(TestDirectory, "GetFiles_Directory_SearchOption_WildcardsNewSubDirectory");
-        System.IO.Directory.CreateDirectory(NewSubDirectoryPath);
-        TestFileList.Add(CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOption_WildcardsNewSubDirectory", TestFileName: "NewFile.cs"));
-        FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories, "*.cs");
-        Assert.Contains(TestFileList[TestFileList.Count - 1], FileList);
-        Assert.Equal(4, FileList.Count);
-    }
-
-    [Fact]
-    public void GetName_Path()
-    {
-        Assert.Equal(_fileSystem.GetName(TestDirectory), System.IO.Path.GetFileName(TestDirectory));
-    }
-
-    [Fact]
-    public void GetParentPath_Path()
-    {
-        Assert.Equal(_fileSystem.GetParentPath(TestDirectory), System.IO.Path.GetDirectoryName(TestDirectory));
-    }
-
-    [Fact]
-    public void GetTempFileName()
-    {
-        var TempFile = _fileSystem.GetTempFileName();
-        Assert.True(System.IO.File.Exists(TempFile));
-        Assert.Equal(0, (new System.IO.FileInfo(TempFile)).Length);
-        System.IO.File.Delete(TempFile);
-    }
-
-    [Fact]
-    public void MoveDirectory_SourceDirectoryName_DestinationDirectoryName()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        _fileSystem.MoveDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory);
-        Assert.Equal(6, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        Assert.False(System.IO.Directory.Exists(FullPathToSourceDirectory));
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure move transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-
-        System.IO.Directory.Move(FullPathToTargetDirectory, FullPathToSourceDirectory);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        CreateTestFile(SourceData, PathFromBase: "TargetDirectory", TestFileName: "NewFile0");
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.MoveDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory));
-    }
-
-    [Fact]
-    public void MoveDirectory_SourceDirectoryName_DestinationDirectoryName_OverwriteFalse()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        _fileSystem.MoveDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: false);
-        Assert.Equal(6, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        Assert.False(System.IO.Directory.Exists(FullPathToSourceDirectory));
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure move transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-
-        System.IO.Directory.Move(FullPathToTargetDirectory, FullPathToSourceDirectory);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        var NewFile0WithPath = CreateTestFile(DestData, PathFromBase: "TargetDirectory", TestFileName: "NewFile0");
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.MoveDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: false));
-        string[] RemainingSourceFilesWithPath = System.IO.Directory.GetFiles(FullPathToSourceDirectory);
-        // We couldn't move one file
-        Assert.Single(RemainingSourceFilesWithPath);
-        // Ensure the file left has correct data
-        Assert.True(HasExpectedData(RemainingSourceFilesWithPath[0], SourceData));
-
-        string[] DestinationFilesWithPath = System.IO.Directory.GetFiles(FullPathToTargetDirectory);
-        Assert.Equal(6, DestinationFilesWithPath.Length);
-        foreach (var CurrentFile in DestinationFilesWithPath)
-        {
-            Assert.True(HasExpectedData(CurrentFile, CurrentFile.EndsWith("0") ? DestData : SourceData));
-        }
-    }
-
-    [Fact]
-    public void MoveDirectory_SourceDirectoryName_DestinationDirectoryName_OverwriteTrue()
-    {
-        var FullPathToSourceDirectory = System.IO.Path.Combine(TestDirectory, "SourceDirectory");
-        var FullPathToTargetDirectory = System.IO.Path.Combine(TestDirectory, "TargetDirectory");
-        System.IO.Directory.CreateDirectory(FullPathToSourceDirectory);
-        System.IO.Directory.CreateDirectory(FullPathToTargetDirectory);
-        for (int i = 0; i < 6; i++)
-        {
-            CreateTestFile(SourceData, PathFromBase: "SourceDirectory", TestFileName: $"NewFile{i}");
-        }
-
-        _fileSystem.MoveDirectory(FullPathToSourceDirectory, FullPathToTargetDirectory, overwrite: true);
-        Assert.False(System.IO.Directory.Exists(FullPathToSourceDirectory));
-        Assert.Equal(6, System.IO.Directory.GetFiles(FullPathToTargetDirectory).Length);
-        foreach (var CurrentFile in System.IO.Directory.GetFiles(FullPathToTargetDirectory))
-        {
-            // Ensure copy transferred written data
-            Assert.True(HasExpectedData(CurrentFile, SourceData));
-        }
-    }
-
-    [Fact]
-    public void MoveFile_SourceFileName_DestinationFileName()
-    {
-        var SourceFileNameWithPath = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-        var DestinationFileNameWithPath = System.IO.Path.Combine(TestDirectory, "NewName");
-        _fileSystem.MoveFile(SourceFileNameWithPath, DestinationFileNameWithPath);
-        Assert.False(System.IO.File.Exists(SourceFileNameWithPath));
-        Assert.True(System.IO.File.Exists(DestinationFileNameWithPath));
-        Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
-
-        SourceFileNameWithPath = DestinationFileNameWithPath;
-        DestinationFileNameWithPath = CreateTestFile(DestData, TestFileName: GetTestFileName());
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.MoveFile(SourceFileNameWithPath, DestinationFileNameWithPath));
-        // Make sure we did not override existing file
-        Assert.True(HasExpectedData(DestinationFileNameWithPath, DestData));
-        Assert.True(System.IO.File.Exists(SourceFileNameWithPath));
-    }
-
-    [Fact]
-    public void MoveFile_SourceFileName_DestinationFileName_OverwriteFalse()
-    {
-        var SourceFileNameWithPath = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-        var DestinationFileNameWithPath = System.IO.Path.Combine(TestDirectory, "NewName");
-        _fileSystem.MoveFile(SourceFileNameWithPath, DestinationFileNameWithPath, overwrite: false);
-        Assert.False(System.IO.File.Exists(SourceFileNameWithPath));
-        Assert.True(System.IO.File.Exists(DestinationFileNameWithPath));
-        Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
-        SourceFileNameWithPath = DestinationFileNameWithPath;
-        DestinationFileNameWithPath = CreateTestFile(DestData, TestFileName: GetTestFileName());
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.MoveFile(SourceFileNameWithPath, DestinationFileNameWithPath, overwrite: false));
-        // Make sure we did not override existing file
-        Assert.True(HasExpectedData(DestinationFileNameWithPath, DestData));
-        Assert.True(System.IO.File.Exists(SourceFileNameWithPath));
-    }
-
-    [Fact]
-    public void MoveFile_SourceFileName_DestinationFileName_OverwriteTrue()
-    {
-        var SourceFileNameWithPath = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-        var DestinationFileNameWithPath = System.IO.Path.Combine(TestDirectory, "NewName");
-        _fileSystem.MoveFile(SourceFileNameWithPath, DestinationFileNameWithPath, overwrite: true);
-        Assert.False(System.IO.File.Exists(SourceFileNameWithPath));
-        Assert.True(System.IO.File.Exists(DestinationFileNameWithPath));
-        Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
-        CreateTestFile(DestData, PathFromBase: null, TestFileName: (new System.IO.FileInfo(SourceFileNameWithPath)).Name);
-        _fileSystem.MoveFile(sourceFileName: DestinationFileNameWithPath, destinationFileName: SourceFileNameWithPath, overwrite: true);
-        Assert.True(System.IO.File.Exists(SourceFileNameWithPath));
-        Assert.False(System.IO.File.Exists(DestinationFileNameWithPath));
-        Assert.True(HasExpectedData(SourceFileNameWithPath, SourceData));
-    }
-
-    // Not tested:
-    //   public Microsoft.VisualBasic.FileIO.TextFieldParser OpenTextFieldParser(string file) { throw null; }
-    //   public Microsoft.VisualBasic.FileIO.TextFieldParser OpenTextFieldParser(string file, params int[] fieldWidths) { throw null; }
-    //   public Microsoft.VisualBasic.FileIO.TextFieldParser OpenTextFieldParser(string file, params string[] delimiters) { throw null; }
-    //   public System.IO.StreamReader OpenTextFileReader(string file) { throw null; }
-    //   public System.IO.StreamReader OpenTextFileReader(string file, System.Text.Encoding encoding) { throw null; }
-    //   public System.IO.StreamWriter OpenTextFileWriter(string file, bool append) { throw null; }
-    //   public System.IO.StreamWriter OpenTextFileWriter(string file, bool append, System.Text.Encoding encoding) { throw null; }
-    //   public byte[] ReadAllBytes(string file) { throw null; }
-    //   public string ReadAllText(string file) { throw null; }
-    //   public string ReadAllText(string file, System.Text.Encoding encoding) { throw null; }
-
-    [Fact]
-    public void RenameDirectory_Directory_NewName()
-    {
-        // <exception cref="IO.FileNotFoundException">If directory does not point to an existing directory.</exception>
-        Assert.Throws<System.IO.DirectoryNotFoundException>(() => _fileSystem.RenameDirectory(System.IO.Path.Combine(TestDirectory, "DoesNotExistDirectory"), "NewDirectory"));
-        var OrigDirectoryWithPath = System.IO.Path.Combine(TestDirectory, "OriginalDirectory");
-        System.IO.Directory.CreateDirectory(OrigDirectoryWithPath);
-        // <exception cref="System.ArgumentException">If newName is null or Empty String.</exception>
-        Assert.Throws<ArgumentNullException>(() => _fileSystem.RenameDirectory(OrigDirectoryWithPath, ""));
-        var DirectoryNameWithPath = System.IO.Path.Combine(TestDirectory, "DoesNotExist");
-        // <exception cref="System.ArgumentException">If contains path information.</exception>
-        Assert.Throws<ArgumentException>(() => _fileSystem.RenameDirectory(OrigDirectoryWithPath, DirectoryNameWithPath));
-        _fileSystem.RenameDirectory(OrigDirectoryWithPath, "NewFDirectory");
-        var NewFDirectoryPath = System.IO.Path.Combine(TestDirectory, "NewFDirectory");
-        Assert.True(System.IO.Directory.Exists(NewFDirectoryPath));
-        Assert.False(System.IO.Directory.Exists(OrigDirectoryWithPath));
-        // <exception cref="IO.IOException">If directory points to a root directory or if there's an existing directory or an existing file with the same name.</exception>
-        System.IO.Directory.CreateDirectory(OrigDirectoryWithPath);
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.RenameDirectory(NewFDirectoryPath, "OriginalDirectory"));
-    }
-
-    [Fact]
-    public void RenameFile_File_NewName()
-    {
-        // <exception cref="IO.FileNotFoundException">If file does not point to an existing file.</exception>
-        Assert.Throws<System.IO.FileNotFoundException>(() => _fileSystem.RenameFile(System.IO.Path.Combine(TestDirectory, "DoesNotExistFile"), "NewFile"));
-        var OrigFileWithPath = CreateTestFile(SourceData, TestFileName: GetTestFileName());
-        var ExistingFileWithPath = CreateTestFile(DestData, TestFileName: GetTestFileName());
-        // <exception cref="System.ArgumentException">If newName is null or Empty String.</exception>
-        Assert.Throws<ArgumentNullException>(() => _fileSystem.RenameFile(OrigFileWithPath, ""));
-        // <exception cref="System.ArgumentException">If contains path information.</exception>
-        Assert.Throws<ArgumentException>(() => _fileSystem.RenameFile(OrigFileWithPath, ExistingFileWithPath));
-        _fileSystem.RenameFile(OrigFileWithPath, "NewFile");
-        var NewFileWithPath = System.IO.Path.Combine(TestDirectory, "NewFile");
-        Assert.True(System.IO.File.Exists(NewFileWithPath));
-        Assert.False(System.IO.File.Exists(OrigFileWithPath));
-        // <exception cref="IO.IOException">If there's an existing directory or an existing file with the same name.</exception>
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.RenameFile(NewFileWithPath, "NewFile"));
-        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, "NewFDirectory"));
-        Assert.Throws<System.IO.IOException>(() => _fileSystem.RenameFile(NewFileWithPath, "NewFDirectory"));
-    }
-
-    [Fact]
-    public void SpecialDirectories()
-    {
-        var specialDirectories = _fileSystem.SpecialDirectories;
-        Assert.NotNull(specialDirectories);
-        Assert.Same(specialDirectories, _fileSystem.SpecialDirectories);
-    }
-
-    // Not tested:
-    //   public void WriteAllBytes(string file, byte[] data, bool append) { }
-    //   public void WriteAllText(string file, string text, bool append) { }
-    //   public void WriteAllText(string file, string text, bool append, System.Text.Encoding encoding) { }
-
-    private string CreateTestFile(string TestData, string TestFileName, string PathFromBase = null)
-    {
-        Assert.False(String.IsNullOrEmpty(TestFileName));
-        var TempFileNameWithPath = TestDirectory;
-        if (!string.IsNullOrEmpty(PathFromBase))
-        {
-            TempFileNameWithPath = System.IO.Path.Combine(TempFileNameWithPath, PathFromBase);
-        }
-
-        TempFileNameWithPath = System.IO.Path.Combine(TempFileNameWithPath, TestFileName);
-        Assert.False(System.IO.File.Exists(TempFileNameWithPath), $"File {TempFileNameWithPath} should not exist!");
-        WriteFile(TempFileNameWithPath, TestData);
-        return TempFileNameWithPath;
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/Internal/ContextValueTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/Internal/ContextValueTests.cs
deleted file mode 100644
index 1ecdfd27a7f..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/Internal/ContextValueTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Microsoft.VisualBasic.MyServices.Internal.Tests;
-
-public class ContextValueTests
-{
-    [Fact]
-    public void NoValue()
-    {
-        Assert.Null((new ContextValue<string>()).Value);
-        Assert.Throws<NullReferenceException>(() => (new ContextValue<int>()).Value);
-    }
-
-    [Fact]
-    public void MultipleInstances()
-    {
-        var context1 = new ContextValue<int>();
-        context1.Value = 1;
-        var context2 = new ContextValue<int>();
-        context2.Value = 2;
-        Assert.Equal(1, context1.Value);
-        Assert.Equal(2, context2.Value);
-    }
-
-    [Fact]
-    public void MultipleThreads()
-    {
-        var context = new ContextValue<string>();
-        context.Value = "Hello";
-        var thread = new Thread(() =>
-        {
-            Assert.Null(context.Value);
-            context.Value = "World";
-            Assert.Equal("World", context.Value);
-        });
-        thread.Start();
-        thread.Join();
-        Assert.Equal("Hello", context.Value);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/RegistryProxyTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/RegistryProxyTests.cs
deleted file mode 100644
index 06713c81d60..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/RegistryProxyTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.VisualBasic.Devices;
-
-namespace Microsoft.VisualBasic.MyServices.Tests;
-
-public class RegistryProxyTests
-{
-    [Fact]
-    public void Properties()
-    {
-        var registry = (new ServerComputer()).Registry;
-        Assert.Equal(Microsoft.Win32.Registry.CurrentUser, registry.CurrentUser);
-        Assert.Equal(Microsoft.Win32.Registry.LocalMachine, registry.LocalMachine);
-        Assert.Equal(Microsoft.Win32.Registry.ClassesRoot, registry.ClassesRoot);
-        Assert.Equal(Microsoft.Win32.Registry.Users, registry.Users);
-        Assert.Equal(Microsoft.Win32.Registry.PerformanceData, registry.PerformanceData);
-        Assert.Equal(Microsoft.Win32.Registry.CurrentConfig, registry.CurrentConfig);
-    }
-
-    [Fact]
-    public void GetValue_ArgumentException()
-    {
-        var keyName = GetUniqueName();
-        var registry = (new ServerComputer()).Registry;
-        Assert.Throws<ArgumentException>(() => registry.GetValue(keyName, "", null));
-    }
-
-    [Fact]
-    public void SetValue_ArgumentException()
-    {
-        var keyName = GetUniqueName();
-        var valueName = GetUniqueName();
-        var registry = (new ServerComputer()).Registry;
-        Assert.Throws<ArgumentException>(() => registry.SetValue(keyName, valueName, ""));
-        Assert.Throws<ArgumentException>(() => registry.SetValue(keyName, valueName, "", Microsoft.Win32.RegistryValueKind.String));
-    }
-
-    private static string GetUniqueName() => Guid.NewGuid().ToString("D");
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxyTests.cs b/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxyTests.cs
deleted file mode 100644
index 5868f530c06..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/Microsoft/VisualBasic/MyServices/SpecialDirectoriesProxyTests.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.VisualBasic.Devices;
-
-namespace Microsoft.VisualBasic.MyServices.Tests;
-
-public class SpecialDirectoriesProxyTests
-{
-    [Fact]
-    public void Properties()
-    {
-        SpecialDirectoriesProxy specialDirectories = new ServerComputer().FileSystem.SpecialDirectories;
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.AllUsersApplicationData, () => specialDirectories.AllUsersApplicationData);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.CurrentUserApplicationData, () => specialDirectories.CurrentUserApplicationData);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.Desktop, () => specialDirectories.Desktop);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.MyDocuments, () => specialDirectories.MyDocuments);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.MyMusic, () => specialDirectories.MyMusic);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.MyPictures, () => specialDirectories.MyPictures);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.Programs, () => specialDirectories.Programs);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.ProgramFiles, () => specialDirectories.ProgramFiles);
-        VerifySpecialDirectory(() => Microsoft.VisualBasic.FileIO.SpecialDirectories.Temp, () => specialDirectories.Temp);
-    }
-
-    private static void VerifySpecialDirectory(Func<string> getExpected, Func<string> getActual)
-    {
-        string expected;
-        try
-        {
-            expected = getExpected();
-        }
-        catch (Exception)
-        {
-            return;
-        }
-
-        string actual = getActual();
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/Microsoft.VisualBasic/tests/UnitTests/runtimeconfig.template.json b/src/Microsoft.VisualBasic/tests/UnitTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/Microsoft.VisualBasic/tests/UnitTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/System.Drawing.Common/src/AssemblyRef.cs b/src/System.Drawing.Common/src/AssemblyRef.cs
index 0d07cb8bca4..c1640f412f2 100644
--- a/src/System.Drawing.Common/src/AssemblyRef.cs
+++ b/src/System.Drawing.Common/src/AssemblyRef.cs
@@ -5,7 +5,7 @@ internal static class FXAssembly
 {
     // NB: this must never-ever change to facilitate type-forwarding from
     // .NET Framework, if those are referenced in .NET project.
-    internal const string Version = "4.0.0.0";
+    internal const string Version = "8.0.0.0";
 }
 
 internal static class AssemblyRef
diff --git a/src/System.Drawing.Common/src/CompatibilitySuppressions.xml b/src/System.Drawing.Common/src/CompatibilitySuppressions.xml
index f182e5528b0..3ecaeb47651 100644
--- a/src/System.Drawing.Common/src/CompatibilitySuppressions.xml
+++ b/src/System.Drawing.Common/src/CompatibilitySuppressions.xml
@@ -97,4 +97,46 @@
     <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
     <Right>lib/net462/System.Drawing.Common.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>P:System.Drawing.Font.Name:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.Bitmap:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.ContentAlignment:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.Font:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.Icon:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.Image:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0015</DiagnosticId>
+    <Target>T:System.Drawing.Imaging.Metafile:[T:System.ComponentModel.EditorAttribute]</Target>
+    <Left>lib/netstandard2.0/System.Drawing.Common.dll</Left>
+    <Right>lib/net6.0/System.Drawing.Common.dll</Right>
+  </Suppression>
 </Suppressions>
\ No newline at end of file
diff --git a/src/System.Drawing.Common/src/System.Drawing.Common.csproj b/src/System.Drawing.Common/src/System.Drawing.Common.csproj
index 6aaf4860002..3e5b8e3921f 100644
--- a/src/System.Drawing.Common/src/System.Drawing.Common.csproj
+++ b/src/System.Drawing.Common/src/System.Drawing.Common.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <TargetFrameworks>$(NetCurrent);$(NetPrevious);$(NetMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <TargetFramework />
+    <AssemblyVersion>8.0.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <WarningsNotAsErrors>CS0618</WarningsNotAsErrors>
     <EnableAOTAnalyzer>false</EnableAOTAnalyzer>
@@ -13,10 +14,15 @@
     <IsShipping>true</IsShipping>
     <IsShippingPackage>true</IsShippingPackage>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+
+    <!-- MG8: commented out for now. it clashes with the fact we have manually set
+      the assembly version to v4.0.0.0 above
+    -->
     <!-- This should point to the last stable released version of this package. -->
-    <PackageValidationBaselineVersion>7.0.0</PackageValidationBaselineVersion>
+    <!--<PackageValidationBaselineVersion>7.0.0</PackageValidationBaselineVersion>-->
+
     <AddXamarinPlaceholderFilesToPackage>true</AddXamarinPlaceholderFilesToPackage>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
+    <NoWarn>$(NoWarn);IDE0090;CS0672;SYSLIB0051</NoWarn>
     <PackageDescription>Provides access to GDI+ graphics functionality.
 
 Commonly Used Types:
diff --git a/src/System.Drawing.Common/src/System/Drawing/GdiplusNative.cs b/src/System.Drawing.Common/src/System/Drawing/GdiplusNative.cs
index 59775b95200..70444a5b638 100644
--- a/src/System.Drawing.Common/src/System/Drawing/GdiplusNative.cs
+++ b/src/System.Drawing.Common/src/System/Drawing/GdiplusNative.cs
@@ -20,6 +20,9 @@ internal static unsafe partial class Gdip
     {
         private const string LibraryName = "gdiplus.dll";
 
+        //[LibraryImport(LibraryName)]
+        //public static extern bool TrackPopupMenuEx(HandleRef hmenu, int fuFlags, int x, int y, HandleRef hwnd, NativeMethods.TPMPARAMS tpm);
+
         // Imported functions
         [LibraryImport(LibraryName)]
         private static partial int GdiplusStartup(out IntPtr token, in StartupInputEx input, out StartupOutput output);
diff --git a/src/System.Drawing.Common/src/System/Drawing/NativeMethods.cs b/src/System.Drawing.Common/src/System/Drawing/NativeMethods.cs
index d96eab2c4c1..1d2486c7647 100644
--- a/src/System.Drawing.Common/src/System/Drawing/NativeMethods.cs
+++ b/src/System.Drawing.Common/src/System/Drawing/NativeMethods.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Runtime.InteropServices;
diff --git a/src/System.Drawing.Common/src/System/Drawing/Printing/InvalidPrinterException.Core.cs b/src/System.Drawing.Common/src/System/Drawing/Printing/InvalidPrinterException.Core.cs
index 18dfd00a6c6..d9f83511b3b 100644
--- a/src/System.Drawing.Common/src/System/Drawing/Printing/InvalidPrinterException.Core.cs
+++ b/src/System.Drawing.Common/src/System/Drawing/Printing/InvalidPrinterException.Core.cs
@@ -13,7 +13,7 @@ namespace System.Drawing.Printing;
 [Runtime.CompilerServices.TypeForwardedFrom(AssemblyRef.SystemDrawing)]
 public partial class InvalidPrinterException
 {
-#if NET8_0_OR_GREATER
+#if NET6_0_OR_GREATER
     [Obsolete(DiagnosticId = "SYSLIB0051")]
 #endif
     protected InvalidPrinterException(SerializationInfo info, StreamingContext context) : base(info, context)
@@ -21,7 +21,7 @@ protected InvalidPrinterException(SerializationInfo info, StreamingContext conte
         // Ignoring not deserializable input
     }
 
-#if NET8_0_OR_GREATER
+#if NET6_0_OR_GREATER
     [Obsolete(DiagnosticId = "SYSLIB0051")]
 #endif
     public override void GetObjectData(SerializationInfo info, StreamingContext context)
diff --git a/src/System.Drawing.Common/src/System/Drawing/ScreenDC.cs b/src/System.Drawing.Common/src/System/Drawing/ScreenDC.cs
index 5c28158d5e6..ad683c4e0c7 100644
--- a/src/System.Drawing.Common/src/System/Drawing/ScreenDC.cs
+++ b/src/System.Drawing.Common/src/System/Drawing/ScreenDC.cs
@@ -8,7 +8,7 @@ namespace System.Drawing;
 /// <summary>
 /// Simple wrapper to create a screen HDC within a using statement.
 /// </summary>
-internal struct ScreenDC : IDisposable
+public struct ScreenDC : IDisposable
 {
     private IntPtr _handle;
 
diff --git a/src/System.Drawing.Common/tests/BitmapTests.cs b/src/System.Drawing.Common/tests/BitmapTests.cs
deleted file mode 100644
index f429838ce85..00000000000
--- a/src/System.Drawing.Common/tests/BitmapTests.cs
+++ /dev/null
@@ -1,1746 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// (C) 2004 Ximian, Inc.  http://www.ximian.com
-// Copyright (C) 2004,2006-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-using System.Drawing.Imaging;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.XUnitExtensions;
-
-namespace System.Drawing.Tests;
-
-public class BitmapTests : FileCleanupTestBase
-{
-    public static IEnumerable<object[]> Ctor_FilePath_TestData()
-    {
-        yield return new object[] { "16x16_one_entry_4bit.ico", 16, 16, PixelFormat.Format32bppArgb, ImageFormat.Icon };
-        yield return new object[] { "bitmap_173x183_indexed_8bit.bmp", 173, 183, PixelFormat.Format8bppIndexed, ImageFormat.Bmp };
-        yield return new object[] { "16x16_nonindexed_24bit.png", 16, 16, PixelFormat.Format24bppRgb, ImageFormat.Png };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_FilePath_TestData))]
-    public void Ctor_FilePath(string filename, int width, int height, PixelFormat pixelFormat, ImageFormat rawFormat)
-    {
-        using (var bitmap = new Bitmap(Helpers.GetTestBitmapPath(filename)))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(pixelFormat, bitmap.PixelFormat);
-            Assert.Equal(rawFormat, bitmap.RawFormat);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_FilePath_TestData))]
-    public void Ctor_FilePath_UseIcm(string filename, int width, int height, PixelFormat pixelFormat, ImageFormat rawFormat)
-    {
-        foreach (bool useIcm in new bool[] { true, false })
-        {
-            using (var bitmap = new Bitmap(Helpers.GetTestBitmapPath(filename), useIcm))
-            {
-                Assert.Equal(width, bitmap.Width);
-                Assert.Equal(height, bitmap.Height);
-                Assert.Equal(pixelFormat, bitmap.PixelFormat);
-                Assert.Equal(rawFormat, bitmap.RawFormat);
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullFilePath_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Bitmap((string)null));
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Bitmap((string)null, false));
-    }
-
-    [Theory]
-    [InlineData("", "path")]
-    [InlineData("\0", "path")]
-    [InlineData("NoSuchPath", null)]
-    public void Ctor_InvalidFilePath_ThrowsArgumentException(string filename, string paramName)
-    {
-        AssertExtensions.Throws<ArgumentException>(paramName, null, () => new Bitmap(filename));
-        AssertExtensions.Throws<ArgumentException>(paramName, null, () => new Bitmap(filename, false));
-        AssertExtensions.Throws<ArgumentException>(paramName, null, () => new Bitmap(filename, true));
-    }
-
-    [Fact]
-    public void Ctor_Type_ResourceName()
-    {
-        using (var bitmap = new Bitmap(typeof(BitmapTests), "bitmap_173x183_indexed_8bit.bmp"))
-        {
-            Assert.Equal(173, bitmap.Width);
-            Assert.Equal(183, bitmap.Height);
-            Assert.Equal(PixelFormat.Format8bppIndexed, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.Bmp, bitmap.RawFormat);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullType_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, NullReferenceException>("type", () => new Bitmap(null, "name"));
-    }
-
-    [Theory]
-    [InlineData(typeof(Bitmap), "")]
-    [InlineData(typeof(Bitmap), "bitmap_173x183_indexed_8bit.bmp")]
-    [InlineData(typeof(BitmapTests), "bitmap_173x183_INDEXED_8bit.bmp")]
-    [InlineData(typeof(BitmapTests), "empty.file")]
-    public void Ctor_InvalidResource_ThrowsArgumentException(Type type, string resource)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(type, resource));
-    }
-
-    [Fact]
-    public void Ctor_InvalidResource_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("resource", null, () => new Bitmap(typeof(Bitmap), null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_FilePath_TestData))]
-    public void Ctor_Stream(string filename, int width, int height, PixelFormat pixelFormat, ImageFormat rawFormat)
-    {
-        using (Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)))
-        using (var bitmap = new Bitmap(stream))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(pixelFormat, bitmap.PixelFormat);
-            Assert.Equal(rawFormat, bitmap.RawFormat);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_FilePath_TestData))]
-    public void Ctor_Stream_UseIcm(string filename, int width, int height, PixelFormat pixelFormat, ImageFormat rawFormat)
-    {
-        foreach (bool useIcm in new bool[] { true, false })
-        {
-            using (Stream stream = File.OpenRead(Helpers.GetTestBitmapPath(filename)))
-            using (var bitmap = new Bitmap(stream, useIcm))
-            {
-                Assert.Equal(width, bitmap.Width);
-                Assert.Equal(height, bitmap.Height);
-                Assert.Equal(pixelFormat, bitmap.PixelFormat);
-                Assert.Equal(rawFormat, bitmap.RawFormat);
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullStream_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Bitmap((Stream)null));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Bitmap((Stream)null, false));
-    }
-
-    [Fact]
-    public void Ctor_InvalidBytesInStream_ThrowsArgumentException()
-    {
-        using (var stream = new MemoryStream(new byte[0]))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(stream));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(stream, false));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(stream, true));
-        }
-    }
-
-    [Theory]
-    [InlineData(10, 10)]
-    [InlineData(5, 15)]
-    public void Ctor_Width_Height(int width, int height)
-    {
-        using (var bitmap = new Bitmap(width, height))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Theory]
-    [InlineData(10, 10, PixelFormat.Format1bppIndexed)]
-    [InlineData(10, 10, PixelFormat.Format8bppIndexed)]
-    [InlineData(1, 1, PixelFormat.Format16bppArgb1555)]
-    [InlineData(1, 1, PixelFormat.Format16bppRgb555)]
-    [InlineData(1, 1, PixelFormat.Format16bppRgb565)]
-    [InlineData(1, 1, PixelFormat.Format16bppGrayScale)]
-    [InlineData(1, 1, PixelFormat.Format24bppRgb)]
-    [InlineData(1, 1, PixelFormat.Format32bppRgb)]
-    [InlineData(5, 15, PixelFormat.Format32bppArgb)]
-    [InlineData(1, 1, PixelFormat.Format32bppPArgb)]
-    [InlineData(10, 10, PixelFormat.Format48bppRgb)]
-    [InlineData(10, 10, PixelFormat.Format4bppIndexed)]
-    [InlineData(1, 1, PixelFormat.Format64bppArgb)]
-    [InlineData(1, 1, PixelFormat.Format64bppPArgb)]
-    public void Ctor_Width_Height_PixelFormat(int width, int height, PixelFormat pixelFormat)
-    {
-        using (var bitmap = new Bitmap(width, height, pixelFormat))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(pixelFormat, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Width_Height_Stride_PixelFormat_Scan0_TestData()
-    {
-        yield return new object[] { 10, 10, 0, PixelFormat.Format8bppIndexed, IntPtr.Zero };
-        yield return new object[] { 5, 15, int.MaxValue, PixelFormat.Format32bppArgb, IntPtr.Zero };
-        yield return new object[] { 5, 15, int.MinValue, PixelFormat.Format24bppRgb, IntPtr.Zero };
-        yield return new object[] { 1, 1, 1, PixelFormat.Format1bppIndexed, IntPtr.Zero };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Width_Height_Stride_PixelFormat_Scan0_TestData))]
-    public void Ctor_Width_Height_Stride_PixelFormat_Scan0(int width, int height, int stride, PixelFormat pixelFormat, IntPtr scan0)
-    {
-        using (var bitmap = new Bitmap(width, height, stride, pixelFormat, scan0))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(pixelFormat, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(ushort.MaxValue * 513)]
-    [InlineData(int.MaxValue)]
-    public void Ctor_InvalidWidth_ThrowsArgumentException(int width)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(width, 1));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(width, 1, Graphics.FromImage(new Bitmap(1, 1))));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(new Bitmap(1, 1), width, 1));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(new Bitmap(1, 1), new Size(width, 1)));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(width, 1, PixelFormat.Format16bppArgb1555));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(width, 1, 0, PixelFormat.Format16bppArgb1555, IntPtr.Zero));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(ushort.MaxValue * 513)]
-    [InlineData(int.MaxValue)]
-    public void Ctor_InvalidHeight_ThrowsArgumentException(int height)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, height));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, height, Graphics.FromImage(new Bitmap(1, 1))));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(new Bitmap(1, 1), 1, height));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(new Bitmap(1, 1), new Size(1, height)));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, height, PixelFormat.Format16bppArgb1555));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, height, 0, PixelFormat.Format16bppArgb1555, IntPtr.Zero));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Undefined - 1)]
-    [InlineData(PixelFormat.Undefined)]
-    [InlineData(PixelFormat.Gdi - 1)]
-    [InlineData(PixelFormat.Max)]
-    [InlineData(PixelFormat.Indexed)]
-    [InlineData(PixelFormat.Gdi)]
-    [InlineData(PixelFormat.Alpha)]
-    [InlineData(PixelFormat.PAlpha)]
-    [InlineData(PixelFormat.Extended)]
-    [InlineData(PixelFormat.Canonical)]
-    public void Ctor_InvalidPixelFormat_ThrowsArgumentException(PixelFormat format)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, 1, format));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, 1, 0, format, IntPtr.Zero));
-    }
-
-    [Fact]
-    public void Ctor_InvalidScan0_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(1, 1, 0, PixelFormat.Format16bppArgb1555, (IntPtr)10));
-    }
-
-    public static IEnumerable<object[]> Image_TestData()
-    {
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format16bppRgb555), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format16bppRgb565), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format24bppRgb), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format32bppArgb), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format32bppPArgb), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format48bppRgb), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format64bppArgb), 1, 1 };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format64bppPArgb), 1, 1 };
-
-        yield return new object[] { new Bitmap(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")), 16, 16 };
-        yield return new object[] { new Bitmap(Helpers.GetTestBitmapPath("16x16_nonindexed_24bit.png")), 32, 48 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Image_TestData))]
-    public void Ctor_Width_Height_Graphics(Bitmap image, int width, int height)
-    {
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var bitmap = new Bitmap(width, height, graphics))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(PixelFormat.Format32bppPArgb, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("g", null, () => new Bitmap(1, 1, null));
-    }
-
-    [Fact]
-    public void Ctor_Image()
-    {
-        using (var image = new Bitmap(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        using (var bitmap = new Bitmap(image))
-        {
-            Assert.Equal(16, bitmap.Width);
-            Assert.Equal(16, bitmap.Height);
-            Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullImageWithoutSize_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new Bitmap((Image)null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Image_TestData))]
-    public void Ctor_Image_Width_Height(Image image, int width, int height)
-    {
-        using (var bitmap = new Bitmap(image, width, height))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Image_TestData))]
-    public void Ctor_Size(Image image, int width, int height)
-    {
-        using (var bitmap = new Bitmap(image, new Size(width, height)))
-        {
-            Assert.Equal(width, bitmap.Width);
-            Assert.Equal(height, bitmap.Height);
-            Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullImageWithSize_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("original", "image", () => new Bitmap(null, new Size(1, 2)));
-        AssertExtensions.Throws<ArgumentNullException>("original", "image", () => new Bitmap(null, 1, 2));
-    }
-
-    [Fact]
-    public void Ctor_DisposedImage_ThrowsArgumentException()
-    {
-        var image = new Bitmap(1, 1);
-        image.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(image));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(image, 1, 1));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Bitmap(image, new Size(1, 1)));
-    }
-
-    public static IEnumerable<object[]> Clone_TestData()
-    {
-        yield return new object[] { new Bitmap(3, 3, PixelFormat.Format32bppArgb), new Rectangle(0, 0, 3, 3), PixelFormat.Format32bppArgb };
-        yield return new object[] { new Bitmap(3, 3, PixelFormat.Format32bppArgb), new Rectangle(0, 0, 3, 3), PixelFormat.Format24bppRgb };
-        yield return new object[] { new Bitmap(3, 3, PixelFormat.Format1bppIndexed), new Rectangle(1, 1, 1, 1), PixelFormat.Format64bppArgb };
-        yield return new object[] { new Bitmap(3, 3, PixelFormat.Format64bppPArgb), new Rectangle(1, 1, 1, 1), PixelFormat.Format16bppRgb565 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Clone_TestData))]
-    public void Clone_Rectangle_ReturnsExpected(Bitmap bitmap, Rectangle rectangle, PixelFormat targetFormat)
-    {
-        try
-        {
-            using (Bitmap clone = bitmap.Clone(rectangle, targetFormat))
-            {
-                Assert.NotSame(bitmap, clone);
-
-                Assert.Equal(rectangle.Width, clone.Width);
-                Assert.Equal(rectangle.Height, clone.Height);
-                Assert.Equal(targetFormat, clone.PixelFormat);
-                Assert.Equal(bitmap.RawFormat, clone.RawFormat);
-
-                for (int x = 0; x < rectangle.Width; x++)
-                {
-                    for (int y = 0; y < rectangle.Height; y++)
-                    {
-                        Color expectedColor = bitmap.GetPixel(rectangle.X + x, rectangle.Y + y);
-                        if (Image.IsAlphaPixelFormat(targetFormat))
-                        {
-                            Assert.Equal(expectedColor, clone.GetPixel(x, y));
-                        }
-                        else
-                        {
-                            Assert.Equal(Color.FromArgb(255, expectedColor.R, expectedColor.G, expectedColor.B), clone.GetPixel(x, y));
-                        }
-                    }
-                }
-            }
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Clone_TestData))]
-    public void Clone_RectangleF_ReturnsExpected(Bitmap bitmap, Rectangle rectangle, PixelFormat format)
-    {
-        try
-        {
-            using (Bitmap clone = bitmap.Clone((RectangleF)rectangle, format))
-            {
-                Assert.NotSame(bitmap, clone);
-
-                Assert.Equal(rectangle.Width, clone.Width);
-                Assert.Equal(rectangle.Height, clone.Height);
-                Assert.Equal(format, clone.PixelFormat);
-            }
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 1)]
-    [InlineData(1, 0)]
-    public void Clone_ZeroWidthOrHeightRect_ThrowsArgumentException(int width, int height)
-    {
-        using (var bitmap = new Bitmap(3, 3))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Clone(new Rectangle(0, 0, width, height), bitmap.PixelFormat));
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Clone(new RectangleF(0, 0, width, height), bitmap.PixelFormat));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0, 4, 1)]
-    [InlineData(0, 0, 1, 4)]
-    [InlineData(1, 0, 3, 1)]
-    [InlineData(0, 1, 1, 3)]
-    [InlineData(4, 1, 1, 1)]
-    [InlineData(1, 4, 1, 1)]
-    public void Clone_InvalidRect_ThrowsOutOfMemoryException(int x, int y, int width, int height)
-    {
-        using (var bitmap = new Bitmap(3, 3))
-        {
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new Rectangle(x, y, width, height), bitmap.PixelFormat));
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new RectangleF(x, y, width, height), bitmap.PixelFormat));
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Max)]
-    [InlineData(PixelFormat.Indexed)]
-    [InlineData(PixelFormat.Gdi)]
-    [InlineData(PixelFormat.Alpha)]
-    [InlineData(PixelFormat.PAlpha)]
-    [InlineData(PixelFormat.Extended)]
-    [InlineData(PixelFormat.Format16bppGrayScale)]
-    [InlineData(PixelFormat.Canonical)]
-    public void Clone_InvalidPixelFormat_ThrowsOutOfMemoryException(PixelFormat format)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new Rectangle(0, 0, 1, 1), format));
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new RectangleF(0, 0, 1, 1), format));
-        }
-    }
-
-    [Fact]
-    public void Clone_GrayscaleFormat_ThrowsOutOfMemoryException()
-    {
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format16bppGrayScale))
-        {
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new Rectangle(0, 0, 1, 1), PixelFormat.Format32bppArgb));
-            Assert.Throws<OutOfMemoryException>(() => bitmap.Clone(new RectangleF(0, 0, 1, 1), PixelFormat.Format32bppArgb));
-        }
-    }
-
-    [Fact]
-    public void Clone_ValidBitmap_Success()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        using (Bitmap clone = Assert.IsType<Bitmap>(bitmap.Clone()))
-        {
-            Assert.NotSame(bitmap, clone);
-            Assert.Equal(1, clone.Width);
-            Assert.Equal(1, clone.Height);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Clone());
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Clone(new Rectangle(0, 0, 1, 1), PixelFormat.Format32bppArgb));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Clone(new RectangleF(0, 0, 1, 1), PixelFormat.Format32bppArgb));
-    }
-
-    [Fact]
-    public void GetFrameCount_NewBitmap_ReturnsZero()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            Assert.Equal(1, bitmap.GetFrameCount(FrameDimension.Page));
-            Assert.Equal(1, bitmap.GetFrameCount(FrameDimension.Resolution));
-            Assert.Equal(1, bitmap.GetFrameCount(FrameDimension.Time));
-            Assert.Equal(1, bitmap.GetFrameCount(new FrameDimension(Guid.Empty)));
-        }
-    }
-
-    [Fact]
-    public void GetFrameCount_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetFrameCount(FrameDimension.Page));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SelectActiveFrame_InvalidFrameIndex_ThrowsArgumentException(int index)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            Assert.Equal(0, bitmap.SelectActiveFrame(FrameDimension.Page, index));
-            Assert.Equal(0, bitmap.SelectActiveFrame(FrameDimension.Resolution, index));
-            Assert.Equal(0, bitmap.SelectActiveFrame(FrameDimension.Time, index));
-            Assert.Equal(0, bitmap.SelectActiveFrame(new FrameDimension(Guid.Empty), index));
-        }
-    }
-
-    [Fact]
-    public void SelectActiveFrame_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SelectActiveFrame(FrameDimension.Page, 0));
-    }
-
-    public static IEnumerable<object[]> GetPixel_TestData()
-    {
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format1bppIndexed), 0, 0, Color.FromArgb(0, 0, 0) };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format4bppIndexed), 0, 0, Color.FromArgb(0, 0, 0) };
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format8bppIndexed), 0, 0, Color.FromArgb(0, 0, 0) };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), 0, 0, Color.FromArgb(0, 0, 0) };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), 99, 99, Color.FromArgb(0, 0, 0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetPixel_TestData))]
-    public void GetPixel_ValidPixelFormat_Success(Bitmap bitmap, int x, int y, Color color)
-    {
-        try
-        {
-            Assert.Equal(color, bitmap.GetPixel(x, y));
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void GetPixel_InvalidX_ThrowsArgumentOutOfRangeException(int x)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("x", () => bitmap.GetPixel(x, 0));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void GetPixel_InvalidY_ThrowsArgumentOutOfRangeException(int y)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("y", () => bitmap.GetPixel(0, y));
-        }
-    }
-
-    [Fact]
-    public void GetPixel_GrayScalePixelFormat_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format16bppGrayScale))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void GetPixel_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPixel(0, 0));
-    }
-
-    public static IEnumerable<object[]> GetHbitmap_TestData()
-    {
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format32bppRgb), 1, 1 };
-        yield return new object[] { new Bitmap(32, 32, PixelFormat.Format32bppArgb), 32, 32 };
-        yield return new object[] { new Bitmap(512, 512, PixelFormat.Format16bppRgb555), 512, 512 };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetHbitmap_TestData))]
-    public void GetHbitmap_FromHbitmap_ReturnsExpected(Bitmap bitmap, int width, int height)
-    {
-        IntPtr handle = bitmap.GetHbitmap();
-        try
-        {
-            Assert.NotEqual(IntPtr.Zero, handle);
-
-            using (Bitmap result = Image.FromHbitmap(handle))
-            {
-                Assert.Equal(width, result.Width);
-                Assert.Equal(height, result.Height);
-                Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-                Assert.Equal(ImageFormat.MemoryBmp, result.RawFormat);
-            }
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-
-        // Hbitmap survives original bitmap disposal.
-        using (Bitmap result = Image.FromHbitmap(handle))
-        {
-            Assert.Equal(width, result.Width);
-            Assert.Equal(height, result.Height);
-            Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, result.RawFormat);
-        }
-
-        // Hbitmap can be used multiple times.
-        using (Bitmap result = Image.FromHbitmap(handle))
-        {
-            Assert.Equal(width, result.Width);
-            Assert.Equal(height, result.Height);
-            Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-            Assert.Equal(ImageFormat.MemoryBmp, result.RawFormat);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 1)]
-    [InlineData(short.MaxValue, 1)]
-    [InlineData(1, short.MaxValue)]
-    public void GetHbitmap_Grayscale_ThrowsArgumentException(int width, int height)
-    {
-        using (var bitmap = new Bitmap(width, height, PixelFormat.Format16bppGrayScale))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetHbitmap());
-        }
-    }
-
-    [Fact]
-    public void GetHbitmap_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetHbitmap());
-    }
-
-    [Fact]
-    public void FromHbitmap_InvalidHandle_ThrowsExternalException()
-    {
-        Assert.Throws<ExternalException>(() => Image.FromHbitmap(IntPtr.Zero));
-        Assert.Throws<ExternalException>(() => Image.FromHbitmap((IntPtr)10));
-    }
-
-    public static IEnumerable<object[]> FromHicon_Icon_TestData()
-    {
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")), 16, 16 };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("32x32_one_entry_4bit.ico")), 32, 32 };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico")), 64, 64 };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico")), 96, 96 };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHicon_Icon_TestData))]
-    public void FromHicon_IconHandle_ReturnsExpected(Icon icon, int width, int height)
-    {
-        IntPtr handle;
-        try
-        {
-            using (Bitmap bitmap = GetHicon_FromHicon_ReturnsExpected(icon.Handle, width, height))
-            {
-                handle = bitmap.GetHicon();
-            }
-        }
-        finally
-        {
-            icon.Dispose();
-        }
-
-        // Hicon survives bitmap and icon disposal.
-        GetHicon_FromHicon_ReturnsExpected(handle, width, height);
-    }
-
-    public static IEnumerable<object[]> FromHicon_TestData()
-    {
-        yield return new object[] { new Bitmap(1, 1, PixelFormat.Format32bppRgb).GetHicon(), 1, 1 };
-        yield return new object[] { new Bitmap(32, 32, PixelFormat.Format32bppRgb).GetHicon(), 32, 32 };
-        yield return new object[] { new Bitmap(512, 512, PixelFormat.Format16bppRgb555).GetHicon(), 512, 512 };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHicon_TestData))]
-    public Bitmap GetHicon_FromHicon_ReturnsExpected(IntPtr handle, int width, int height)
-    {
-        Assert.NotEqual(IntPtr.Zero, handle);
-
-        Bitmap result = Bitmap.FromHicon(handle);
-        Assert.Equal(width, result.Width);
-        Assert.Equal(height, result.Height);
-        Assert.Equal(PixelFormat.Format32bppArgb, result.PixelFormat);
-        Assert.Equal(ImageFormat.MemoryBmp, result.RawFormat);
-        Assert.Equal(335888, result.Flags);
-        Assert.Empty(result.Palette.Entries);
-
-        return result;
-    }
-
-    [Fact]
-    public void GetHicon_Grayscale_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format16bppGrayScale))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetHicon());
-        }
-    }
-
-    [Fact]
-    public void GetHicon_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetHicon());
-    }
-
-    [Fact]
-    public void SaveWmfAsPngDoesntChangeImageBoundaries()
-    {
-        if (PlatformDetection.IsWindows7)
-        {
-            throw new SkipTestException("GDI+ 1.1 is not supported");
-        }
-
-        if (PlatformDetection.IsArmOrArm64Process)
-        {
-            // https://github.com/dotnet/winforms/issues/8817
-            throw new SkipTestException("Arm precision");
-        }
-
-        string output = $"{GetTestFilePath()}.png";
-        using Stream wmfStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug.wmf"));
-        using Image bitmapFromWmf = Image.FromStream(wmfStream);
-        bitmapFromWmf.Save(output, ImageFormat.Png);
-
-        using Stream expectedPngStream = File.OpenRead(Helpers.GetTestBitmapPath("gdiwmfboundariesbug-output.png"));
-        using Image expectedPngBitmap = Image.FromStream(expectedPngStream);
-
-        using Stream outputPngStream = File.OpenRead(output);
-        using Image outputPngBitmap = Image.FromStream(outputPngStream);
-
-        Assert.Equal(expectedPngBitmap.HorizontalResolution, outputPngBitmap.HorizontalResolution);
-        Assert.Equal(expectedPngBitmap.VerticalResolution, outputPngBitmap.VerticalResolution);
-        Assert.Equal(expectedPngBitmap.Size, outputPngBitmap.Size);
-        Assert.Equal(expectedPngBitmap.PhysicalDimension, outputPngBitmap.PhysicalDimension);
-        Assert.Equal(expectedPngBitmap.PixelFormat, outputPngBitmap.PixelFormat);
-    }
-
-    [Fact]
-    public void FromHicon_InvalidHandle_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromHicon(IntPtr.Zero));
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromHicon((IntPtr)10));
-    }
-
-    [Fact]
-    public void FromHicon_1bppIcon_ThrowsArgumentException()
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico")))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromHicon(icon.Handle));
-        }
-    }
-
-    [Fact]
-    public void FromResource_InvalidHandle_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromResource(IntPtr.Zero, "Name"));
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromResource((IntPtr)10, "Name"));
-    }
-
-    [Fact]
-    public void FromResource_InvalidBitmapName_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromResource(IntPtr.Zero, "Name"));
-        AssertExtensions.Throws<ArgumentException>(null, () => Bitmap.FromResource((IntPtr)10, "Name"));
-    }
-
-    [Fact]
-    public void MakeTransparent_NoColorWithMatches_SetsMatchingPixelsToTransparent()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    if (y % 2 == 0)
-                    {
-                        bitmap.SetPixel(x, y, Color.LightGray);
-                    }
-                    else
-                    {
-                        bitmap.SetPixel(x, y, Color.Red);
-                    }
-                }
-            }
-
-            bitmap.MakeTransparent();
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    if (y % 2 == 0)
-                    {
-                        Assert.Equal(Color.FromArgb(255, 211, 211, 211), bitmap.GetPixel(x, y));
-                    }
-                    else
-                    {
-                        Assert.Equal(Color.FromArgb(0, 0, 0, 0), bitmap.GetPixel(x, y));
-                    }
-                }
-            }
-        }
-    }
-
-    [Fact]
-    public void MakeTransparent_CustomColorExists_SetsMatchingPixelsToTransparent()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    if (y % 2 == 0)
-                    {
-                        bitmap.SetPixel(x, y, Color.Blue);
-                    }
-                    else
-                    {
-                        bitmap.SetPixel(x, y, Color.Red);
-                    }
-                }
-            }
-
-            bitmap.MakeTransparent(Color.Blue);
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    if (y % 2 == 0)
-                    {
-                        Assert.Equal(Color.FromArgb(0, 0, 0, 0), bitmap.GetPixel(x, y));
-                    }
-                    else
-                    {
-                        Assert.Equal(Color.FromArgb(255, 255, 0, 0), bitmap.GetPixel(x, y));
-                    }
-                }
-            }
-        }
-    }
-
-    [Fact]
-    public void MakeTransparent_CustomColorDoesntExist_DoesNothing()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    bitmap.SetPixel(x, y, Color.Blue);
-                }
-            }
-
-            bitmap.MakeTransparent(Color.Red);
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                for (int y = 0; y < bitmap.Height; y++)
-                {
-                    Assert.Equal(Color.FromArgb(255, 0, 0, 255), bitmap.GetPixel(x, y));
-                }
-            }
-        }
-    }
-
-    [Fact]
-    public void MakeTransparent_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.MakeTransparent());
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.MakeTransparent(Color.Red));
-    }
-
-    [Fact]
-    public void MakeTransparent_GrayscalePixelFormat_ThrowsArgumentException()
-    {
-        using var bitmap = new Bitmap(1, 1, PixelFormat.Format16bppGrayScale);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.MakeTransparent());
-
-        if (PlatformDetection.IsWindows11OrHigher)
-        {
-            bitmap.MakeTransparent(Color.Red);
-        }
-        else
-        {
-            Assert.Throws<ExternalException>(() => bitmap.MakeTransparent(Color.Red));
-        }
-    }
-
-    [Fact]
-    public void MakeTransparent_Icon_ThrowsInvalidOperationException()
-    {
-        using (var bitmap = new Bitmap(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        {
-            Assert.Throws<InvalidOperationException>(() => bitmap.MakeTransparent(Color.Red));
-        }
-    }
-
-    public static IEnumerable<object[]> SetPixel_TestData()
-    {
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), 0, 0, Color.FromArgb(255, 128, 128, 128) };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), 99, 99, Color.FromArgb(255, 128, 128, 128) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetPixel_TestData))]
-    public void SetPixel_ValidPixelFormat_Success(Bitmap bitmap, int x, int y, Color color)
-    {
-        bitmap.SetPixel(x, y, color);
-        Assert.Equal(color, bitmap.GetPixel(x, y));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format1bppIndexed)]
-    [InlineData(PixelFormat.Format4bppIndexed)]
-    [InlineData(PixelFormat.Format8bppIndexed)]
-    public void SetPixel_IndexedPixelFormat_ThrowsInvalidOperationException(PixelFormat format)
-    {
-        using (var bitmap = new Bitmap(1, 1, format))
-        {
-            Assert.Throws<InvalidOperationException>(() => bitmap.SetPixel(0, 0, Color.Red));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void SetPixel_InvalidX_ThrowsArgumentOutOfRangeException(int x)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("x", () => bitmap.SetPixel(x, 0, Color.Red));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void SetPixel_InvalidY_ThrowsArgumentOutOfRangeException(int y)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("y", () => bitmap.SetPixel(0, y, Color.Red));
-        }
-    }
-
-    [Fact]
-    public void SetPixel_GrayScalePixelFormat_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format16bppGrayScale))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SetPixel(0, 0, Color.Red));
-        }
-    }
-
-    [Fact]
-    public void SetPixel_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SetPixel(0, 0, Color.Red));
-    }
-
-    [Theory]
-    [InlineData(1, 1)]
-    [InlineData(float.PositiveInfinity, float.PositiveInfinity)]
-    [InlineData(float.MaxValue, float.MaxValue)]
-    public void SetResolution_ValidDpi_Success(float xDpi, float yDpi)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            bitmap.SetResolution(xDpi, yDpi);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(float.NaN)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetResolution_InvalidXDpi_ThrowsArgumentException(float xDpi)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SetResolution(xDpi, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(float.NaN)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetResolution_InvalidYDpi_ThrowsArgumentException(float yDpi)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SetResolution(1, yDpi));
-        }
-    }
-
-    [Fact]
-    public void SetResolution_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.SetResolution(1, 1));
-    }
-
-    public static IEnumerable<object[]> LockBits_TestData()
-    {
-        Bitmap bitmap() => new(2, 2, PixelFormat.Format32bppArgb);
-        yield return new object[] { bitmap(), new Rectangle(0, 0, 2, 2), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb, 8, 1 };
-        yield return new object[] { bitmap(), new Rectangle(0, 0, 2, 2), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb, 8, 3 };
-        yield return new object[] { bitmap(), new Rectangle(0, 0, 2, 2), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb, 8, 2 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format32bppRgb, 400, 1 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb, 400, 3 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb, 400, 2 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, 300, 65537 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb, 300, 65539 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb, 300, 65538 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, 300, 1 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb, 300, 3 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb, 300, 2 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format32bppRgb, 400, 65537 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb, 400, 65539 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format24bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb, 400, 65538 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, 300, 65537 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed, 100, 1 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed, 100, 3 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed, 100, 2 };
-
-
-        yield return new object[] { new Bitmap(184, 184, PixelFormat.Format1bppIndexed), new Rectangle(0, 0, 184, 184), ImageLockMode.ReadOnly, PixelFormat.Format1bppIndexed, 24, 1 };
-        yield return new object[] { new Bitmap(184, 184, PixelFormat.Format1bppIndexed), new Rectangle(0, 0, 184, 184), ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed, 24, 3 };
-        yield return new object[] { new Bitmap(184, 184, PixelFormat.Format1bppIndexed), new Rectangle(0, 0, 184, 184), ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed, 24, 2 };
-
-        yield return new object[] { bitmap(), new Rectangle(1, 1, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb, 8, 1 };
-        yield return new object[] { bitmap(), new Rectangle(1, 1, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb, 8, 3 };
-        yield return new object[] { bitmap(), new Rectangle(1, 1, 1, 1), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb, 8, 2 };
-
-        yield return new object[] { bitmap(), new Rectangle(1, 1, 1, 1), ImageLockMode.ReadOnly - 1, PixelFormat.Format32bppArgb, 8, 0 };
-
-        yield return new object[] { bitmap(), new Rectangle(0, 0, 2, 2), ImageLockMode.WriteOnly, PixelFormat.Format16bppGrayScale, 4, 65538 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed, 100, 65537 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed, 100, 65539 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format32bppRgb), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed, 100, 65538 };
-
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb, 300, 65539 };
-        yield return new object[] { new Bitmap(100, 100, PixelFormat.Format8bppIndexed), new Rectangle(0, 0, 100, 100), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb, 300, 65538 };
-    }
-
-    [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    [MemberData(nameof(LockBits_TestData))]
-    public void LockBits_Invoke_Success(Bitmap bitmap, Rectangle rectangle, ImageLockMode lockMode, PixelFormat pixelFormat, int expectedStride, int expectedReserved)
-    {
-        try
-        {
-            BitmapData data = bitmap.LockBits(rectangle, lockMode, pixelFormat);
-            Assert.Equal(pixelFormat, data.PixelFormat);
-            Assert.Equal(rectangle.Width, data.Width);
-            Assert.Equal(rectangle.Height, data.Height);
-            Assert.Equal(expectedStride, data.Stride);
-
-            // "Reserved" is documented as "Reserved. Do not use.", so it's not clear whether we actually need to test this in any unit tests.
-            Assert.Equal(expectedReserved, data.Reserved);
-
-            // Locking with 16bppGrayscale succeeds, but the data can't be unlocked.
-            if (pixelFormat == PixelFormat.Format16bppGrayScale)
-            {
-                AssertExtensions.Throws<ArgumentException>(null, () => bitmap.UnlockBits(data));
-            }
-            else
-            {
-                bitmap.UnlockBits(data);
-            }
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void LockBits_NullBitmapData_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(Rectangle.Empty, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb, null));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, 0, 1, 1)]
-    [InlineData(2, 0, 1, 1)]
-    [InlineData(0, -1, 1, 1)]
-    [InlineData(0, 2, 1, 1)]
-    [InlineData(0, 0, -1, 1)]
-    [InlineData(0, 0, 3, 1)]
-    [InlineData(0, 0, 1, -1)]
-    [InlineData(0, 0, 1, 3)]
-    [InlineData(1, 0, 2, 1)]
-    [InlineData(1, 1, 1, 0)]
-    [InlineData(1, 1, 0, 1)]
-    public void LockBits_InvalidRect_ThrowsArgumentException(int x, int y, int width, int height)
-    {
-        using (var bitmap = new Bitmap(2, 2))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(x, y, width, height), ImageLockMode.ReadOnly, bitmap.PixelFormat));
-
-            var bitmapData = new BitmapData();
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(x, y, width, height), ImageLockMode.ReadOnly, bitmap.PixelFormat, bitmapData));
-            Assert.Equal(IntPtr.Zero, bitmapData.Scan0);
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.DontCare)]
-    [InlineData(PixelFormat.Max)]
-    [InlineData(PixelFormat.Indexed)]
-    [InlineData(PixelFormat.Gdi)]
-    [InlineData(PixelFormat.Alpha)]
-    [InlineData(PixelFormat.PAlpha)]
-    [InlineData(PixelFormat.Extended)]
-    [InlineData(PixelFormat.Canonical)]
-    public void LockBits_InvalidPixelFormat_ThrowsArgumentException(PixelFormat format)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            foreach (ImageLockMode lockMode in Enum.GetValues(typeof(ImageLockMode)))
-            {
-                AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), lockMode, format));
-
-                var bitmapData = new BitmapData();
-                AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), lockMode, format, bitmapData));
-                Assert.Equal(IntPtr.Zero, bitmapData.Scan0);
-            }
-        }
-    }
-
-    [Fact]
-    public void LockBits_ReadOnlyGrayscale_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format16bppGrayScale));
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format16bppGrayScale, new BitmapData()));
-
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format16bppGrayScale));
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format16bppGrayScale, new BitmapData()));
-
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.WriteOnly, PixelFormat.Format16bppGrayScale);
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.UnlockBits(data));
-        }
-    }
-
-    [Theory]
-    [InlineData((ImageLockMode)(-1))]
-    [InlineData(ImageLockMode.UserInputBuffer + 1)]
-    [InlineData(ImageLockMode.UserInputBuffer)]
-    public void LockBits_InvalidLockMode_ThrowsArgumentException(ImageLockMode lockMode)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), lockMode, bitmap.PixelFormat));
-
-            var bitmapData = new BitmapData();
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), lockMode, bitmap.PixelFormat, bitmapData));
-            Assert.Equal(IntPtr.Zero, bitmapData.Scan0);
-        }
-    }
-
-    [Fact]
-    public void LockBits_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb));
-
-        var bitmapData = new BitmapData();
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb, bitmapData));
-        Assert.Equal(IntPtr.Zero, bitmapData.Scan0);
-    }
-
-    [Fact]
-    public void LockBits_AlreadyLocked_ThrowsInvalidOperationException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat);
-
-            Assert.Throws<InvalidOperationException>(() => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat));
-            Assert.Throws<InvalidOperationException>(() => bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat, new BitmapData()));
-
-            Assert.Throws<InvalidOperationException>(() => bitmap.LockBits(new Rectangle(1, 1, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat));
-            Assert.Throws<InvalidOperationException>(() => bitmap.LockBits(new Rectangle(1, 1, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat, new BitmapData()));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, -1)]
-    [InlineData(0, 2)]
-    [InlineData(1, 2)]
-    public void UnlockBits_InvalidHeightWidth_Nop(int offset, int invalidParameter)
-    {
-        using (var bitmap = new Bitmap(2, 2))
-        {
-            BitmapData data = bitmap.LockBits(new Rectangle(offset, offset, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat);
-            data.Height = invalidParameter;
-            data.Width = invalidParameter;
-
-            bitmap.UnlockBits(data);
-        }
-    }
-
-    [Fact]
-    public void UnlockBits_Scan0Zero_Nop()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat);
-            data.Scan0 = IntPtr.Zero;
-
-            bitmap.UnlockBits(data);
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Indexed)]
-    [InlineData(PixelFormat.Gdi)]
-    public void UnlockBits_InvalidPixelFormat_Nop(PixelFormat format)
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat);
-            data.PixelFormat = format;
-
-            bitmap.UnlockBits(data);
-        }
-    }
-
-    [Fact]
-    public void UnlockBits_NullBitmapData_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => bitmap.UnlockBits(null));
-        }
-    }
-
-    [Fact]
-    public void UnlockBits_NotLocked_ThrowsExternalException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            Assert.Throws<ExternalException>(() => bitmap.UnlockBits(new BitmapData()));
-        }
-    }
-
-    [Fact]
-    public void UnlockBits_AlreadyUnlocked_ThrowsExternalException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, bitmap.PixelFormat);
-            bitmap.UnlockBits(data);
-
-            Assert.Throws<ExternalException>(() => bitmap.UnlockBits(new BitmapData()));
-        }
-    }
-
-    [Fact]
-    public void UnlockBits_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.UnlockBits(new BitmapData()));
-    }
-
-    [Fact]
-    public void Size_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Width);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Height);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Size);
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format16bppArgb1555)]
-    [InlineData(PixelFormat.Format16bppRgb555)]
-    [InlineData(PixelFormat.Format16bppRgb565)]
-    [InlineData(PixelFormat.Format32bppArgb)]
-    [InlineData(PixelFormat.Format32bppPArgb)]
-    [InlineData(PixelFormat.Format32bppRgb)]
-    [InlineData(PixelFormat.Format24bppRgb)]
-    public void CustomPixelFormat_GetPixels_ReturnsExpected(PixelFormat format)
-    {
-        bool alpha = Image.IsAlphaPixelFormat(format);
-        int size = Image.GetPixelFormatSize(format) / 8 * 2;
-        using (var bitmap = new Bitmap(2, 1, format))
-        {
-            Color a = Color.FromArgb(128, 64, 32, 16);
-            Color b = Color.FromArgb(192, 96, 48, 24);
-            bitmap.SetPixel(0, 0, a);
-            bitmap.SetPixel(1, 0, b);
-            Color c = bitmap.GetPixel(0, 0);
-            Color d = bitmap.GetPixel(1, 0);
-            if (size == 4)
-            {
-                Assert.Equal(255, c.A);
-                Assert.Equal(66, c.R);
-                if (format == PixelFormat.Format16bppRgb565)
-                {
-                    Assert.Equal(32, c.G);
-                }
-                else
-                {
-                    Assert.Equal(33, c.G);
-                }
-                Assert.Equal(16, c.B);
-
-                Assert.Equal(255, d.A);
-                Assert.Equal(99, d.R);
-                if (format == PixelFormat.Format16bppRgb565)
-                {
-                    Assert.Equal(48, d.G);
-                }
-                else
-                {
-                    Assert.Equal(49, d.G);
-                }
-                Assert.Equal(24, d.B);
-            }
-            else if (alpha)
-            {
-                if (format == PixelFormat.Format32bppPArgb)
-                {
-                    Assert.Equal(a.A, c.A);
-                    Assert.Equal(a.R - 1, c.R);
-                    Assert.Equal(a.G - 1, c.G);
-                    Assert.Equal(a.B - 1, c.B);
-
-                    Assert.Equal(b.A, d.A);
-                    Assert.Equal(b.R - 1, d.R);
-                    Assert.Equal(b.G - 1, d.G);
-                    Assert.Equal(b.B - 1, d.B);
-                }
-                else
-                {
-                    Assert.Equal(a, c);
-                    Assert.Equal(b, d);
-                }
-            }
-            else
-            {
-                Assert.Equal(Color.FromArgb(255, 64, 32, 16), c);
-                Assert.Equal(Color.FromArgb(255, 96, 48, 24), d);
-            }
-            BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, 2, 1), ImageLockMode.ReadOnly, format);
-            try
-            {
-                byte[] data = new byte[size];
-                Marshal.Copy(bitmapData.Scan0, data, 0, size);
-                if (format == PixelFormat.Format32bppPArgb)
-                {
-                    Assert.Equal(Math.Ceiling((float)c.B * c.A / 255), data[0]);
-                    Assert.Equal(Math.Ceiling((float)c.G * c.A / 255), data[1]);
-                    Assert.Equal(Math.Ceiling((float)c.R * c.A / 255), data[2]);
-                    Assert.Equal(c.A, data[3]);
-                    Assert.Equal(Math.Ceiling((float)d.B * d.A / 255), data[4]);
-                    Assert.Equal(Math.Ceiling((float)d.G * d.A / 255), data[5]);
-                    Assert.Equal(Math.Ceiling((float)d.R * d.A / 255), data[6]);
-                    Assert.Equal(d.A, data[7]);
-                }
-                else if (size == 4)
-                {
-                    switch (format)
-                    {
-                        case PixelFormat.Format16bppRgb565:
-                            Assert.Equal(2, data[0]);
-                            Assert.Equal(65, data[1]);
-                            Assert.Equal(131, data[2]);
-                            Assert.Equal(97, data[3]);
-                            break;
-                        case PixelFormat.Format16bppArgb1555:
-                            Assert.Equal(130, data[0]);
-                            Assert.Equal(160, data[1]);
-                            Assert.Equal(195, data[2]);
-                            Assert.Equal(176, data[3]);
-                            break;
-                        case PixelFormat.Format16bppRgb555:
-                            Assert.Equal(130, data[0]);
-                            Assert.Equal(32, data[1]);
-                            Assert.Equal(195, data[2]);
-                            Assert.Equal(48, data[3]);
-                            break;
-                    }
-                }
-                else
-                {
-                    int n = 0;
-                    Assert.Equal(c.B, data[n++]);
-                    Assert.Equal(c.G, data[n++]);
-                    Assert.Equal(c.R, data[n++]);
-                    if (size % 4 == 0)
-                    {
-                        if (format == PixelFormat.Format32bppRgb)
-                        {
-                            Assert.Equal(128, data[n++]);
-                        }
-                        else
-                        {
-                            Assert.Equal(c.A, data[n++]);
-                        }
-                    }
-                    Assert.Equal(d.B, data[n++]);
-                    Assert.Equal(d.G, data[n++]);
-                    Assert.Equal(d.R, data[n++]);
-                    if (size % 4 == 0)
-                    {
-                        if (format == PixelFormat.Format32bppRgb)
-                        {
-                            Assert.Equal(192, data[n++]);
-                        }
-                        else
-                        {
-                            Assert.Equal(d.A, data[n++]);
-                        }
-                    }
-                }
-            }
-            finally
-            {
-                bitmap.UnlockBits(bitmapData);
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> Palette_TestData()
-    {
-        yield return new object[] { PixelFormat.Format1bppIndexed, new int[] { -16777216, -1 } };
-        yield return new object[] { PixelFormat.Format4bppIndexed, new int[] { -16777216, -8388608, -16744448, -8355840, -16777088, -8388480, -16744320, -8355712, -4144960, -65536, -16711936, -256, -16776961, -65281, -16711681, -1, } };
-        yield return new object[] { PixelFormat.Format8bppIndexed, new int[] { -16777216, -8388608, -16744448, -8355840, -16777088, -8388480, -16744320, -8355712, -4144960, -65536, -16711936, -256, -16776961, -65281, -16711681, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16777216, -16777165, -16777114, -16777063, -16777012, -16776961, -16764160, -16764109, -16764058, -16764007, -16763956, -16763905, -16751104, -16751053, -16751002, -16750951, -16750900, -16750849, -16738048, -16737997, -16737946, -16737895, -16737844, -16737793, -16724992, -16724941, -16724890, -16724839, -16724788, -16724737, -16711936, -16711885, -16711834, -16711783, -16711732, -16711681, -13434880, -13434829, -13434778, -13434727, -13434676, -13434625, -13421824, -13421773, -13421722, -13421671, -13421620, -13421569, -13408768, -13408717, -13408666, -13408615, -13408564, -13408513, -13395712, -13395661, -13395610, -13395559, -13395508, -13395457, -13382656, -13382605, -13382554, -13382503, -13382452, -13382401, -13369600, -13369549, -13369498, -13369447, -13369396, -13369345, -10092544, -10092493, -10092442, -10092391, -10092340, -10092289, -10079488, -10079437, -10079386, -10079335, -10079284, -10079233, -10066432, -10066381, -10066330, -10066279, -10066228, -10066177, -10053376, -10053325, -10053274, -10053223, -10053172, -10053121, -10040320, -10040269, -10040218, -10040167, -10040116, -10040065, -10027264, -10027213, -10027162, -10027111, -10027060, -10027009, -6750208, -6750157, -6750106, -6750055, -6750004, -6749953, -6737152, -6737101, -6737050, -6736999, -6736948, -6736897, -6724096, -6724045, -6723994, -6723943, -6723892, -6723841, -6711040, -6710989, -6710938, -6710887, -6710836, -6710785, -6697984, -6697933, -6697882, -6697831, -6697780, -6697729, -6684928, -6684877, -6684826, -6684775, -6684724, -6684673, -3407872, -3407821, -3407770, -3407719, -3407668, -3407617, -3394816, -3394765, -3394714, -3394663, -3394612, -3394561, -3381760, -3381709, -3381658, -3381607, -3381556, -3381505, -3368704, -3368653, -3368602, -3368551, -3368500, -3368449, -3355648, -3355597, -3355546, -3355495, -3355444, -3355393, -3342592, -3342541, -3342490, -3342439, -3342388, -3342337, -65536, -65485, -65434, -65383, -65332, -65281, -52480, -52429, -52378, -52327, -52276, -52225, -39424, -39373, -39322, -39271, -39220, -39169, -26368, -26317, -26266, -26215, -26164, -26113, -13312, -13261, -13210, -13159, -13108, -13057, -256, -205, -154, -103, -52, -1 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Palette_TestData))]
-    public void Palette_Get_ReturnsExpected(PixelFormat pixelFormat, int[] expectedEntries)
-    {
-        using (var bitmap = new Bitmap(1, 1, pixelFormat))
-        {
-            Assert.Equal(expectedEntries, bitmap.Palette.Entries.Select(c => c.ToArgb()));
-        }
-    }
-
-    [Fact]
-    public void Palette_SetNull_ThrowsNullReferenceException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            Assert.Throws<NullReferenceException>(() => bitmap.Palette = null);
-        }
-    }
-
-    [Fact]
-    public void Palette_Disposed_ThrowsArgumentException()
-    {
-        var bitmap = new Bitmap(1, 1);
-        ColorPalette palette = bitmap.Palette;
-        bitmap.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Palette);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Palette = palette);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.Size);
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBits_Marshalling_Success()
-    {
-        Color red = Color.FromArgb(Color.Red.ToArgb());
-        Color blue = Color.FromArgb(Color.Blue.ToArgb());
-
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format32bppRgb))
-        {
-            bitmap.SetPixel(0, 0, red);
-            Color pixelColor = bitmap.GetPixel(0, 0);
-            Assert.Equal(red, pixelColor);
-
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
-            try
-            {
-                int pixelValue = Marshal.ReadByte(data.Scan0, 0);
-                pixelValue |= Marshal.ReadByte(data.Scan0, 1) << 8;
-                pixelValue |= Marshal.ReadByte(data.Scan0, 2) << 16;
-                pixelValue |= Marshal.ReadByte(data.Scan0, 3) << 24;
-
-                pixelColor = Color.FromArgb(pixelValue);
-                // Disregard alpha information in the test
-                pixelColor = Color.FromArgb(red.A, pixelColor.R, pixelColor.G, pixelColor.B);
-                Assert.Equal(red, pixelColor);
-
-                // write blue but we're locked in read-only...
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-                Marshal.WriteByte(data.Scan0, 3, blue.A);
-            }
-            finally
-            {
-                bitmap.UnlockBits(data);
-                pixelColor = bitmap.GetPixel(0, 0);
-                // Disregard alpha information in the test
-                pixelColor = Color.FromArgb(red.A, pixelColor.R, pixelColor.G, pixelColor.B);
-                // ...so we still read red after unlocking
-                Assert.Equal(red, pixelColor);
-            }
-
-            data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
-            try
-            {
-                // write blue
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-                Marshal.WriteByte(data.Scan0, 3, blue.A);
-            }
-            finally
-            {
-                bitmap.UnlockBits(data);
-                pixelColor = bitmap.GetPixel(0, 0);
-                // Disregard alpha information in the test
-                pixelColor = Color.FromArgb(blue.A, pixelColor.R, pixelColor.G, pixelColor.B);
-                // read blue
-                Assert.Equal(blue, pixelColor);
-            }
-        }
-
-        using (var bitmap = new Bitmap(1, 1, PixelFormat.Format32bppArgb))
-        {
-            bitmap.SetPixel(0, 0, red);
-
-            BitmapData data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                byte b = Marshal.ReadByte(data.Scan0, 0);
-                byte g = Marshal.ReadByte(data.Scan0, 1);
-                byte r = Marshal.ReadByte(data.Scan0, 2);
-                Assert.Equal(red, Color.FromArgb(red.A, r, g, b));
-                // write blue but we're locked in read-only...
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-            }
-            finally
-            {
-                bitmap.UnlockBits(data);
-                // ...so we still read red after unlocking
-                Assert.Equal(red, bitmap.GetPixel(0, 0));
-            }
-
-            data = bitmap.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
-            try
-            {
-                // write blue
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-            }
-            finally
-            {
-                bitmap.UnlockBits(data);
-                // read blue
-                Assert.Equal(blue, bitmap.GetPixel(0, 0));
-            }
-        }
-    }
-
-    [Fact]
-    public void FromNonSeekableStream()
-    {
-        string path = GetTestFilePath();
-        using (Bitmap bitmap = new Bitmap(100, 100))
-        {
-            bitmap.Save(path, ImageFormat.Png);
-        }
-
-        using (FileStream stream = new FileStream(path, FileMode.Open))
-        {
-            using (Bitmap bitmap = new Bitmap(new TestStream(stream, canSeek: false)))
-            {
-                Assert.Equal(100, bitmap.Height);
-                Assert.Equal(100, bitmap.Width);
-                Assert.Equal(ImageFormat.Png, bitmap.RawFormat);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(true, false)]
-    [InlineData(false, false)]
-    [InlineData(false, true)]
-    public void SaveToRestrictiveStream(bool canRead, bool canSeek)
-    {
-        using (Stream backingStream = new MemoryStream())
-        using (Stream restrictiveStream = new TestStream(backingStream, canRead, canSeek))
-        {
-            using (Bitmap bitmap = new Bitmap(100, 100))
-            {
-                bitmap.Save(restrictiveStream, ImageFormat.Png);
-            }
-
-            backingStream.Position = 0;
-
-            using (Bitmap bitmap = new Bitmap(backingStream))
-            {
-                Assert.Equal(100, bitmap.Height);
-                Assert.Equal(100, bitmap.Width);
-                Assert.Equal(ImageFormat.Png, bitmap.RawFormat);
-            }
-        }
-    }
-
-    private class TestStream : Stream
-    {
-        private Stream _stream;
-        private bool _canRead;
-        private bool _canSeek;
-
-        public TestStream(Stream stream, bool canRead = true, bool canSeek = true)
-        {
-            _stream = stream;
-            _canRead = canRead;
-            _canSeek = canSeek;
-        }
-
-        public override bool CanRead => _canRead && _stream.CanRead;
-        public override bool CanSeek => _canSeek && _stream.CanSeek;
-        public override bool CanWrite => _stream.CanWrite;
-        public override long Length => _stream.Length;
-        public override long Position
-        {
-            get => _stream.Position;
-            set => _stream.Position = _canSeek ? value : throw new NotSupportedException();
-        }
-        public override void Flush() => _stream.Flush();
-        public override int Read(byte[] buffer, int offset, int count) => _canRead ?  _stream.Read(buffer, offset, count) : throw new NotSupportedException();
-        public override long Seek(long offset, SeekOrigin origin) => _stream.Seek(offset, origin);
-        public override void SetLength(long value) => _stream.SetLength(value);
-        public override void Write(byte[] buffer, int offset, int count) => _stream.Write(buffer, offset, count);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/BrushTests.cs b/src/System.Drawing.Common/tests/BrushTests.cs
deleted file mode 100644
index 3c8903b53ab..00000000000
--- a/src/System.Drawing.Common/tests/BrushTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class BrushTests
-{
-    [Fact]
-    public void SetNativeBrush_Brush_Success()
-    {
-        using (var brush = new SubBrush())
-        {
-            brush.PublicSetNativeBrush(10);
-            brush.PublicSetNativeBrush(IntPtr.Zero);
-
-            brush.PublicSetNativeBrush(10);
-            brush.PublicSetNativeBrush(IntPtr.Zero);
-        }
-    }
-
-    [Fact]
-    public void Dispose_NoSuchEntryPoint_SilentyCatchesException()
-    {
-        var brush = new SubBrush();
-        brush.PublicSetNativeBrush(10);
-        brush.Dispose();
-    }
-
-    private class SubBrush : Brush
-    {
-        public override object Clone() => this;
-        public void PublicSetNativeBrush(nint brush) => SetNativeBrush(brush);
-
-        protected override void Dispose(bool disposing)
-        {
-            // The pointers we're creating here are invalid and dangerous to dereference.
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/BrushesTests.cs b/src/System.Drawing.Common/tests/BrushesTests.cs
deleted file mode 100644
index 5877acd8530..00000000000
--- a/src/System.Drawing.Common/tests/BrushesTests.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class BrushesTests
-{
-    public static IEnumerable<object[]> Brushes_TestData()
-    {
-        yield return Brush(() => Brushes.AliceBlue, Color.AliceBlue);
-        yield return Brush(() => Brushes.AntiqueWhite, Color.AntiqueWhite);
-        yield return Brush(() => Brushes.Aqua, Color.Aqua);
-        yield return Brush(() => Brushes.Aquamarine, Color.Aquamarine);
-        yield return Brush(() => Brushes.Azure, Color.Azure);
-        yield return Brush(() => Brushes.Beige, Color.Beige);
-        yield return Brush(() => Brushes.Bisque, Color.Bisque);
-        yield return Brush(() => Brushes.Black, Color.Black);
-        yield return Brush(() => Brushes.BlanchedAlmond, Color.BlanchedAlmond);
-        yield return Brush(() => Brushes.Blue, Color.Blue);
-        yield return Brush(() => Brushes.BlueViolet, Color.BlueViolet);
-        yield return Brush(() => Brushes.Brown, Color.Brown);
-        yield return Brush(() => Brushes.BurlyWood, Color.BurlyWood);
-        yield return Brush(() => Brushes.CadetBlue, Color.CadetBlue);
-        yield return Brush(() => Brushes.Chartreuse, Color.Chartreuse);
-        yield return Brush(() => Brushes.Chocolate, Color.Chocolate);
-        yield return Brush(() => Brushes.Coral, Color.Coral);
-        yield return Brush(() => Brushes.CornflowerBlue, Color.CornflowerBlue);
-        yield return Brush(() => Brushes.Cornsilk, Color.Cornsilk);
-        yield return Brush(() => Brushes.Crimson, Color.Crimson);
-        yield return Brush(() => Brushes.Cyan, Color.Cyan);
-        yield return Brush(() => Brushes.DarkBlue, Color.DarkBlue);
-        yield return Brush(() => Brushes.DarkCyan, Color.DarkCyan);
-        yield return Brush(() => Brushes.DarkGoldenrod, Color.DarkGoldenrod);
-        yield return Brush(() => Brushes.DarkGray, Color.DarkGray);
-        yield return Brush(() => Brushes.DarkGreen, Color.DarkGreen);
-        yield return Brush(() => Brushes.DarkKhaki, Color.DarkKhaki);
-        yield return Brush(() => Brushes.DarkMagenta, Color.DarkMagenta);
-        yield return Brush(() => Brushes.DarkOliveGreen, Color.DarkOliveGreen);
-        yield return Brush(() => Brushes.DarkOrange, Color.DarkOrange);
-        yield return Brush(() => Brushes.DarkOrchid, Color.DarkOrchid);
-        yield return Brush(() => Brushes.DarkRed, Color.DarkRed);
-        yield return Brush(() => Brushes.DarkSalmon, Color.DarkSalmon);
-        yield return Brush(() => Brushes.DarkSeaGreen, Color.DarkSeaGreen);
-        yield return Brush(() => Brushes.DarkSlateBlue, Color.DarkSlateBlue);
-        yield return Brush(() => Brushes.DarkSlateGray, Color.DarkSlateGray);
-        yield return Brush(() => Brushes.DarkTurquoise, Color.DarkTurquoise);
-        yield return Brush(() => Brushes.DarkViolet, Color.DarkViolet);
-        yield return Brush(() => Brushes.DeepPink, Color.DeepPink);
-        yield return Brush(() => Brushes.DeepSkyBlue, Color.DeepSkyBlue);
-        yield return Brush(() => Brushes.DimGray, Color.DimGray);
-        yield return Brush(() => Brushes.DodgerBlue, Color.DodgerBlue);
-        yield return Brush(() => Brushes.Firebrick, Color.Firebrick);
-        yield return Brush(() => Brushes.FloralWhite, Color.FloralWhite);
-        yield return Brush(() => Brushes.ForestGreen, Color.ForestGreen);
-        yield return Brush(() => Brushes.Fuchsia, Color.Fuchsia);
-        yield return Brush(() => Brushes.Gainsboro, Color.Gainsboro);
-        yield return Brush(() => Brushes.GhostWhite, Color.GhostWhite);
-        yield return Brush(() => Brushes.Gold, Color.Gold);
-        yield return Brush(() => Brushes.Goldenrod, Color.Goldenrod);
-        yield return Brush(() => Brushes.Gray, Color.Gray);
-        yield return Brush(() => Brushes.Green, Color.Green);
-        yield return Brush(() => Brushes.GreenYellow, Color.GreenYellow);
-        yield return Brush(() => Brushes.Honeydew, Color.Honeydew);
-        yield return Brush(() => Brushes.HotPink, Color.HotPink);
-        yield return Brush(() => Brushes.IndianRed, Color.IndianRed);
-        yield return Brush(() => Brushes.Indigo, Color.Indigo);
-        yield return Brush(() => Brushes.Ivory, Color.Ivory);
-        yield return Brush(() => Brushes.Khaki, Color.Khaki);
-        yield return Brush(() => Brushes.Lavender, Color.Lavender);
-        yield return Brush(() => Brushes.LavenderBlush, Color.LavenderBlush);
-        yield return Brush(() => Brushes.LawnGreen, Color.LawnGreen);
-        yield return Brush(() => Brushes.LemonChiffon, Color.LemonChiffon);
-        yield return Brush(() => Brushes.LightBlue, Color.LightBlue);
-        yield return Brush(() => Brushes.LightCoral, Color.LightCoral);
-        yield return Brush(() => Brushes.LightCyan, Color.LightCyan);
-        yield return Brush(() => Brushes.LightGoldenrodYellow, Color.LightGoldenrodYellow);
-        yield return Brush(() => Brushes.LightGray, Color.LightGray);
-        yield return Brush(() => Brushes.LightGreen, Color.LightGreen);
-        yield return Brush(() => Brushes.LightPink, Color.LightPink);
-        yield return Brush(() => Brushes.LightSalmon, Color.LightSalmon);
-        yield return Brush(() => Brushes.LightSeaGreen, Color.LightSeaGreen);
-        yield return Brush(() => Brushes.LightSkyBlue, Color.LightSkyBlue);
-        yield return Brush(() => Brushes.LightSlateGray, Color.LightSlateGray);
-        yield return Brush(() => Brushes.LightSteelBlue, Color.LightSteelBlue);
-        yield return Brush(() => Brushes.LightYellow, Color.LightYellow);
-        yield return Brush(() => Brushes.Lime, Color.Lime);
-        yield return Brush(() => Brushes.LimeGreen, Color.LimeGreen);
-        yield return Brush(() => Brushes.Linen, Color.Linen);
-        yield return Brush(() => Brushes.Magenta, Color.Magenta);
-        yield return Brush(() => Brushes.Maroon, Color.Maroon);
-        yield return Brush(() => Brushes.MediumAquamarine, Color.MediumAquamarine);
-        yield return Brush(() => Brushes.MediumBlue, Color.MediumBlue);
-        yield return Brush(() => Brushes.MediumOrchid, Color.MediumOrchid);
-        yield return Brush(() => Brushes.MediumPurple, Color.MediumPurple);
-        yield return Brush(() => Brushes.MediumSeaGreen, Color.MediumSeaGreen);
-        yield return Brush(() => Brushes.MediumSlateBlue, Color.MediumSlateBlue);
-        yield return Brush(() => Brushes.MediumSpringGreen, Color.MediumSpringGreen);
-        yield return Brush(() => Brushes.MediumTurquoise, Color.MediumTurquoise);
-        yield return Brush(() => Brushes.MediumVioletRed, Color.MediumVioletRed);
-        yield return Brush(() => Brushes.MidnightBlue, Color.MidnightBlue);
-        yield return Brush(() => Brushes.MintCream, Color.MintCream);
-        yield return Brush(() => Brushes.MistyRose, Color.MistyRose);
-        yield return Brush(() => Brushes.Moccasin, Color.Moccasin);
-        yield return Brush(() => Brushes.NavajoWhite, Color.NavajoWhite);
-        yield return Brush(() => Brushes.Navy, Color.Navy);
-        yield return Brush(() => Brushes.OldLace, Color.OldLace);
-        yield return Brush(() => Brushes.Olive, Color.Olive);
-        yield return Brush(() => Brushes.OliveDrab, Color.OliveDrab);
-        yield return Brush(() => Brushes.Orange, Color.Orange);
-        yield return Brush(() => Brushes.OrangeRed, Color.OrangeRed);
-        yield return Brush(() => Brushes.Orchid, Color.Orchid);
-        yield return Brush(() => Brushes.PaleGoldenrod, Color.PaleGoldenrod);
-        yield return Brush(() => Brushes.PaleGreen, Color.PaleGreen);
-        yield return Brush(() => Brushes.PaleTurquoise, Color.PaleTurquoise);
-        yield return Brush(() => Brushes.PaleVioletRed, Color.PaleVioletRed);
-        yield return Brush(() => Brushes.PapayaWhip, Color.PapayaWhip);
-        yield return Brush(() => Brushes.PeachPuff, Color.PeachPuff);
-        yield return Brush(() => Brushes.Peru, Color.Peru);
-        yield return Brush(() => Brushes.Pink, Color.Pink);
-        yield return Brush(() => Brushes.Plum, Color.Plum);
-        yield return Brush(() => Brushes.PowderBlue, Color.PowderBlue);
-        yield return Brush(() => Brushes.Purple, Color.Purple);
-        yield return Brush(() => Brushes.Red, Color.Red);
-        yield return Brush(() => Brushes.RosyBrown, Color.RosyBrown);
-        yield return Brush(() => Brushes.RoyalBlue, Color.RoyalBlue);
-        yield return Brush(() => Brushes.SaddleBrown, Color.SaddleBrown);
-        yield return Brush(() => Brushes.Salmon, Color.Salmon);
-        yield return Brush(() => Brushes.SandyBrown, Color.SandyBrown);
-        yield return Brush(() => Brushes.SeaGreen, Color.SeaGreen);
-        yield return Brush(() => Brushes.SeaShell, Color.SeaShell);
-        yield return Brush(() => Brushes.Sienna, Color.Sienna);
-        yield return Brush(() => Brushes.Silver, Color.Silver);
-        yield return Brush(() => Brushes.SkyBlue, Color.SkyBlue);
-        yield return Brush(() => Brushes.SlateBlue, Color.SlateBlue);
-        yield return Brush(() => Brushes.SlateGray, Color.SlateGray);
-        yield return Brush(() => Brushes.Snow, Color.Snow);
-        yield return Brush(() => Brushes.SpringGreen, Color.SpringGreen);
-        yield return Brush(() => Brushes.SteelBlue, Color.SteelBlue);
-        yield return Brush(() => Brushes.Tan, Color.Tan);
-        yield return Brush(() => Brushes.Teal, Color.Teal);
-        yield return Brush(() => Brushes.Thistle, Color.Thistle);
-        yield return Brush(() => Brushes.Tomato, Color.Tomato);
-        yield return Brush(() => Brushes.Transparent, Color.Transparent);
-        yield return Brush(() => Brushes.Turquoise, Color.Turquoise);
-        yield return Brush(() => Brushes.Violet, Color.Violet);
-        yield return Brush(() => Brushes.Wheat, Color.Wheat);
-        yield return Brush(() => Brushes.White, Color.White);
-        yield return Brush(() => Brushes.WhiteSmoke, Color.WhiteSmoke);
-        yield return Brush(() => Brushes.Yellow, Color.Yellow);
-        yield return Brush(() => Brushes.YellowGreen, Color.YellowGreen);
-    }
-
-    public static object[] Brush(Func<Brush> getBrush, Color expectedColor) => new object[] { getBrush, expectedColor };
-
-    [Theory]
-    [MemberData(nameof(Brushes_TestData))]
-    public void Brushes_Get_ReturnsExpected(Func<Brush> getBrush, Color expectedColor)
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(getBrush());
-        Assert.Equal(expectedColor, brush.Color);
-
-        Assert.Same(brush, getBrush());
-
-        // Brushes are not immutable.
-        Color color = brush.Color;
-        try
-        {
-            brush.Color = Color.Red;
-            Assert.Equal(Color.Red, brush.Color);
-        }
-        finally
-        {
-            brush.Color = color;
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/BufferedGraphicsContextTests.cs b/src/System.Drawing.Common/tests/BufferedGraphicsContextTests.cs
deleted file mode 100644
index facc4867a67..00000000000
--- a/src/System.Drawing.Common/tests/BufferedGraphicsContextTests.cs
+++ /dev/null
@@ -1,286 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-namespace System.Drawing.Tests;
-
-public class BufferedGraphicsContextTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            Assert.Equal(new Size(225, 96), context.MaximumBuffer);
-        }
-    }
-
-    [Fact]
-    public void Allocate_ValidTargetGraphics_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, Rectangle.Empty))
-        {
-            Assert.NotNull(bufferedGraphics.Graphics);
-
-            context.Invalidate();
-        }
-    }
-
-    [Fact]
-    public void Allocate_SmallRectWithTargetGraphics_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, context.MaximumBuffer.Width - 1, context.MaximumBuffer.Height - 1)))
-        {
-            Assert.NotNull(bufferedGraphics.Graphics);
-
-            context.Invalidate();
-        }
-    }
-
-    [Fact]
-    public void Allocate_LargeRectWithTargetGraphics_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1)))
-        {
-            Assert.NotNull(bufferedGraphics.Graphics);
-
-            context.Invalidate();
-        }
-    }
-
-    [Fact]
-    public void Allocate_ValidTargetHdc_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            try
-            {
-                IntPtr hdc = graphics.GetHdc();
-                using (BufferedGraphics bufferedGraphics = context.Allocate(hdc, Rectangle.Empty))
-                {
-                    Assert.NotNull(bufferedGraphics.Graphics);
-                }
-
-                context.Invalidate();
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Allocate_SmallRectWithTargetHdc_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            try
-            {
-                IntPtr hdc = graphics.GetHdc();
-                using (BufferedGraphics bufferedGraphics = context.Allocate(hdc, new Rectangle(0, 0, context.MaximumBuffer.Width - 1, context.MaximumBuffer.Height - 1)))
-                {
-                    Assert.NotNull(bufferedGraphics.Graphics);
-                }
-
-                context.Invalidate();
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Allocate_LargeRectWithTargetHdc_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            try
-            {
-                IntPtr hdc = graphics.GetHdc();
-                using (BufferedGraphics bufferedGraphics = context.Allocate(hdc, new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1)))
-                {
-                    Assert.NotNull(bufferedGraphics.Graphics);
-                }
-
-                context.Invalidate();
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Allocate_InvalidHdc_ThrowsArgumentException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => context.Allocate((IntPtr)(-1), new Rectangle(0, 0, 10, 10)));
-        }
-    }
-
-    [Fact]
-    public void Allocate_NullGraphicsZeroSize_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (BufferedGraphics graphics = context.Allocate(null, Rectangle.Empty))
-        {
-            Assert.NotNull(graphics.Graphics);
-        }
-    }
-
-    [Fact]
-    public void Allocate_NullGraphicsNonZeroSize_ThrowsArgumentNullException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        {
-            Assert.Throws<ArgumentNullException>("hdc", () => context.Allocate(null, new Rectangle(0, 0, 10, 10)));
-        }
-    }
-
-    [Fact]
-    public void Allocate_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            Rectangle largeRectangle = new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1);
-            AssertExtensions.Throws<ArgumentException>(null, () => context.Allocate(graphics, largeRectangle));
-            AssertExtensions.Throws<ArgumentException>(null, () => context.Allocate(graphics, Rectangle.Empty));
-        }
-    }
-
-    [Fact]
-    public void Allocate_BusyGraphics_ThrowsInvalidOperationException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            try
-            {
-                graphics.GetHdc();
-
-                Rectangle largeRectangle = new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1);
-                Assert.Throws<InvalidOperationException>(() => context.Allocate(graphics, largeRectangle));
-                Assert.Throws<InvalidOperationException>(() => context.Allocate(graphics, Rectangle.Empty));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Invalidate_CallMultipleTimes_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            context.Invalidate();
-            context.Invalidate();
-        }
-    }
-
-    [Fact]
-    public void MaximumBuffer_SetValid_ReturnsExpected()
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            context.MaximumBuffer = new Size(10, 10);
-            Assert.Equal(new Size(10, 10), context.MaximumBuffer);
-
-            context.MaximumBuffer = new Size(255, 255);
-            Assert.Equal(new Size(255, 255), context.MaximumBuffer);
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void MaximumBuffer_SetInvalidWidth_ThrowsArgumentException(int width)
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            AssertExtensions.Throws<ArgumentException>("value", null, () => context.MaximumBuffer = new Size(width, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void MaximumBuffer_SetInvalidHeight_ThrowsArgumentException(int height)
-    {
-        using (var context = new BufferedGraphicsContext())
-        {
-            AssertExtensions.Throws<ArgumentException>("value", null, () => context.MaximumBuffer = new Size(1, height));
-        }
-    }
-
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    private static void AllocateBufferedGraphicsContext() => new BufferedGraphicsContext();
-
-
-    [Fact]
-    public void Finalize_Invoke_Success()
-    {
-        // This makes sure than finalization doesn't cause any errors or debug assertions.
-        AllocateBufferedGraphicsContext();
-
-        GC.Collect();
-        GC.WaitForPendingFinalizers();
-    }
-
-    [Fact]
-    public void Dispose_BusyAndValidated_ThrowsInvalidOperationException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using (context.Allocate(graphics, Rectangle.Empty))
-            {
-                Assert.Throws<InvalidOperationException>(() => context.Dispose());
-            }
-        }
-    }
-
-    [Fact]
-    public void Dispose_BusyAndInvalidated_ThrowsInvalidOperationException()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using (context.Allocate(graphics, Rectangle.Empty))
-            {
-                context.Invalidate();
-                Assert.Throws<InvalidOperationException>(() => context.Dispose());
-            }
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/BufferedGraphicsManagerTests.cs b/src/System.Drawing.Common/tests/BufferedGraphicsManagerTests.cs
deleted file mode 100644
index e0ff3567fc3..00000000000
--- a/src/System.Drawing.Common/tests/BufferedGraphicsManagerTests.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class BufferedGraphicsManagerTests
-{
-    [Fact]
-    public void Current_Get_ReturnsSameInstance()
-    {
-        Assert.Same(BufferedGraphicsManager.Current, BufferedGraphicsManager.Current);
-        Assert.NotNull(BufferedGraphicsManager.Current);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/BufferedGraphicsTests.cs b/src/System.Drawing.Common/tests/BufferedGraphicsTests.cs
deleted file mode 100644
index 650135f64d3..00000000000
--- a/src/System.Drawing.Common/tests/BufferedGraphicsTests.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class BufferedGraphicsTests
-{
-    [Fact]
-    public void Dispose_TempMultipleTimes_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(3, 3))
-        using (Graphics targetGraphics = Graphics.FromImage(image))
-        {
-            BufferedGraphics graphics = context.Allocate(targetGraphics, new Rectangle(0, 0, 1, 1));
-            Assert.NotNull(graphics.Graphics);
-
-            graphics.Dispose();
-            Assert.Null(graphics.Graphics);
-
-            graphics.Dispose();
-        }
-    }
-
-    [Fact]
-    public void Dispose_ActualMultipleTimes_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(3, 3))
-        using (Graphics targetGraphics = Graphics.FromImage(image))
-        {
-            BufferedGraphics graphics = context.Allocate(targetGraphics, new Rectangle(0, 0, context.MaximumBuffer.Width + 1, context.MaximumBuffer.Height + 1));
-            Assert.NotNull(graphics.Graphics);
-
-            graphics.Dispose();
-            Assert.Null(graphics.Graphics);
-
-            graphics.Dispose();
-        }
-    }
-
-    [Fact]
-    public void Render_ParameterlessWithTargetGraphics_Success()
-    {
-        Color color = Color.FromArgb(255, 0, 0, 0);
-
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));
-
-            using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, 3, 3)))
-            {
-                bufferedGraphics.Render();
-
-                Helpers.VerifyBitmap(image, new Color[][]
-                {
-                    new Color[] { color, color, color },
-                    new Color[] { color, color, color },
-                    new Color[] { color, color, color }
-                });
-            }
-        }
-    }
-
-    [Fact]
-    public void Render_ParameterlessWithNullTargetGraphics_Success()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));
-            try
-            {
-                IntPtr hdc = graphics.GetHdc();
-
-                using (BufferedGraphics bufferedGraphics = context.Allocate(hdc, new Rectangle(0, 0, 3, 3)))
-                {
-                    bufferedGraphics.Render();
-                }
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Render_TargetGraphics_Success()
-    {
-        Color color = Color.FromArgb(255, 0, 0, 0);
-
-        using (var context = new BufferedGraphicsContext())
-        using (var originalImage = new Bitmap(3, 3))
-        using (var targetImage = new Bitmap(3, 3))
-        using (Graphics originalGraphics = Graphics.FromImage(originalImage))
-        using (Graphics targetGraphics = Graphics.FromImage(targetImage))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            originalGraphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));
-
-            using (BufferedGraphics graphics = context.Allocate(originalGraphics, new Rectangle(0, 0, 3, 3)))
-            {
-                graphics.Render(targetGraphics);
-
-                Helpers.VerifyBitmap(targetImage, new Color[][]
-                {
-                    new Color[] { color, color, color },
-                    new Color[] { color, color, color },
-                    new Color[] { color, color, color }
-                });
-            }
-        }
-    }
-
-    [Fact]
-    public void Render_NullGraphics_Nop()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (BufferedGraphics bufferedGraphics = context.Allocate(graphics, new Rectangle(0, 0, 1, 1)))
-        {
-            bufferedGraphics.Render(null);
-        }
-    }
-
-    [Fact]
-    public void Render_InvalidTargetDC_Nop()
-    {
-        using (var context = new BufferedGraphicsContext())
-        using (BufferedGraphics graphics = context.Allocate(null, Rectangle.Empty))
-        {
-            graphics.Render(IntPtr.Zero);
-            graphics.Render((IntPtr)(-1));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/CharacterRangeTests.cs b/src/System.Drawing.Common/tests/CharacterRangeTests.cs
deleted file mode 100644
index 49fc8d408f4..00000000000
--- a/src/System.Drawing.Common/tests/CharacterRangeTests.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class CharacterRangeTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var range = new CharacterRange();
-        Assert.Equal(0, range.First);
-        Assert.Equal(0, range.Length);
-    }
-
-    [Theory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int First, int Length)
-    {
-        var range = new CharacterRange(First, Length);
-        Assert.Equal(First, range.First);
-        Assert.Equal(Length, range.Length);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(10)]
-    public void First_Set_GetReturnsExpected(int value)
-    {
-        var range = new CharacterRange
-        {
-            First = value
-        };
-        Assert.Equal(value, range.First);
-
-        // Set same.
-        range.First = value;
-        Assert.Equal(value, range.First);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(10)]
-    public void Length_Set_GetReturnsExpected(int value)
-    {
-        var range = new CharacterRange
-        {
-            Length = value
-        };
-        Assert.Equal(value, range.Length);
-
-        // Set same.
-        range.Length = value;
-        Assert.Equal(value, range.Length);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new CharacterRange(1, 2), new CharacterRange(1, 2), true };
-        yield return new object[] { new CharacterRange(1, 2), new CharacterRange(2, 2), false };
-        yield return new object[] { new CharacterRange(1, 2), new CharacterRange(1, 1), false };
-        yield return new object[] { new CharacterRange(1, 2), new object(), false };
-
-        // .NET Framework throws NullReferenceException.
-        if (!PlatformDetection.IsNetFramework)
-        {
-            yield return new object[] { new CharacterRange(1, 2), null, false };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Invoke_ReturnsExpected(CharacterRange range, object obj, bool expected)
-    {
-        Assert.Equal(expected, range.Equals(obj));
-        if (obj is CharacterRange otherRange)
-        {
-            Assert.Equal(expected, range.Equals(otherRange));
-            Assert.Equal(expected, range == otherRange);
-            Assert.Equal(!expected, range != otherRange);
-            Assert.Equal(expected, range.GetHashCode().Equals(otherRange.GetHashCode()));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/ColorTranslatorTests.cs b/src/System.Drawing.Common/tests/ColorTranslatorTests.cs
deleted file mode 100644
index 0d584ce3fe4..00000000000
--- a/src/System.Drawing.Common/tests/ColorTranslatorTests.cs
+++ /dev/null
@@ -1,261 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-
-namespace System.Drawing.Tests;
-
-public class ColorTranslatorTests
-{
-    public static IEnumerable<(int, Color)> SystemColors_TestData()
-    {
-        yield return (unchecked((int)0x8000000A), SystemColors.ActiveBorder);
-        yield return (unchecked((int)0x80000002), SystemColors.ActiveCaption);
-        yield return (unchecked((int)0x80000009), SystemColors.ActiveCaptionText);
-        yield return (unchecked((int)0x8000000C), SystemColors.AppWorkspace);
-        yield return (unchecked((int)0x8000000F), SystemColors.Control);
-        yield return (unchecked((int)0x80000010), SystemColors.ControlDark);
-        yield return (unchecked((int)0x80000015), SystemColors.ControlDarkDark);
-        yield return (unchecked((int)0x80000016), SystemColors.ControlLight);
-        yield return (unchecked((int)0x80000014), SystemColors.ControlLightLight);
-        yield return (unchecked((int)0x80000012), SystemColors.ControlText);
-        yield return (unchecked((int)0x80000001), SystemColors.Desktop);
-        yield return (unchecked((int)0x8000001B), SystemColors.GradientActiveCaption);
-        yield return (unchecked((int)0x8000001C), SystemColors.GradientInactiveCaption);
-        yield return (unchecked((int)0x80000011), SystemColors.GrayText);
-        yield return (unchecked((int)0x8000000D), SystemColors.Highlight);
-        yield return (unchecked((int)0x8000000E), SystemColors.HighlightText);
-        yield return (unchecked((int)0x8000001A), SystemColors.HotTrack);
-        yield return (unchecked((int)0x8000000B), SystemColors.InactiveBorder);
-        yield return (unchecked((int)0x80000003), SystemColors.InactiveCaption);
-        yield return (unchecked((int)0x80000013), SystemColors.InactiveCaptionText);
-        yield return (unchecked((int)0x80000018), SystemColors.Info);
-        yield return (unchecked((int)0x80000017), SystemColors.InfoText);
-        yield return (unchecked((int)0x80000004), SystemColors.Menu);
-        yield return (unchecked((int)0x8000001E), SystemColors.MenuBar);
-        yield return (unchecked((int)0x8000001D), SystemColors.MenuHighlight);
-        yield return (unchecked((int)0x80000007), SystemColors.MenuText);
-        yield return (unchecked((int)0x80000000), SystemColors.ScrollBar);
-        yield return (unchecked((int)0x80000005), SystemColors.Window);
-        yield return (unchecked((int)0x80000006), SystemColors.WindowFrame);
-        yield return (unchecked((int)0x80000008), SystemColors.WindowText);
-    }
-
-    public static IEnumerable<object[]> ToWin32Color_TestData()
-    {
-        yield return new object[] { new Color(), 0 };
-        yield return new object[] { Color.Red, 255 };
-        yield return new object[] { Color.White, 16777215 };
-        yield return new object[] { Color.FromArgb(1, 2, 3), 197121 };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToWin32Color_TestData))]
-    public void ToWin32Color_Color_ReturnsExpected(Color color, int expected)
-    {
-        Assert.Equal(expected, ColorTranslator.ToWin32(color));
-    }
-
-    public static IEnumerable<object[]> FromOle_TestData()
-    {
-        yield return new object[] { int.MinValue, SystemColors.ScrollBar };
-        yield return new object[] { -1, Color.White };
-        yield return new object[] { 0, Color.Black };
-        yield return new object[] { 197121, Color.FromArgb(1, 2, 3) };
-        yield return new object[] { 16777215, Color.White };
-        yield return new object[] { int.MaxValue, Color.White };
-        yield return new object[] { unchecked((int)0x8000001F), Color.FromArgb(255, 31, 0, 0) };
-        yield return new object[] { unchecked((int)0x80000019), Color.FromArgb(255, 25, 0, 0) };
-
-        foreach ((int oleColor, Color color) in SystemColors_TestData())
-        {
-            yield return new object[] { oleColor, color };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(FromOle_TestData))]
-    public void FromOle_Color_ReturnsExpected(int oleColor, Color color)
-    {
-        Assert.Equal(color, ColorTranslator.FromOle(oleColor));
-        Assert.Equal(color, ColorTranslator.FromWin32(oleColor));
-    }
-
-    public static IEnumerable<object[]> ToOle_TestData()
-    {
-        yield return new object[] { new Color(), 0 };
-        yield return new object[] { Color.Red, 255 };
-        yield return new object[] { Color.White, 16777215 };
-        yield return new object[] { Color.FromArgb(1, 2, 3), 197121 };
-
-        foreach ((int oleColor, Color color) in SystemColors_TestData())
-        {
-            yield return new object[] { color, oleColor };
-        }
-
-
-        // These system colors are equivalent to Control, ControlLight and ControlDark.
-        yield return new object[] { SystemColors.ButtonFace, unchecked((int)0x8000000F) };
-        yield return new object[] { SystemColors.ButtonHighlight, unchecked((int)0x80000014) };
-        yield return new object[] { SystemColors.ButtonShadow, unchecked((int)0x80000010) };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToOle_TestData))]
-    public void ToOle_Color_ReturnsExpected(Color color, int oleColor)
-    {
-        Assert.Equal(oleColor, ColorTranslator.ToOle(color));
-    }
-
-    public static IEnumerable<(string, Color)> HtmlColors_TestData()
-    {
-        yield return ("activeborder", SystemColors.ActiveBorder);
-        yield return ("activecaption", SystemColors.ActiveCaption);
-        yield return ("appworkspace", SystemColors.AppWorkspace);
-        yield return ("background", SystemColors.Desktop);
-        yield return ("buttonface", SystemColors.Control);
-        yield return ("buttonhighlight", SystemColors.ControlLightLight);
-        yield return ("buttonshadow", SystemColors.ControlDark);
-        yield return ("buttontext", SystemColors.ControlText);
-        yield return ("captiontext", SystemColors.ActiveCaptionText);
-        yield return ("graytext", SystemColors.GrayText);
-        yield return ("highlight", SystemColors.Highlight);
-        yield return ("highlighttext", SystemColors.HighlightText);
-        yield return ("inactiveborder", SystemColors.InactiveBorder);
-        yield return ("inactivecaption", SystemColors.InactiveCaption);
-        yield return ("inactivecaptiontext", SystemColors.InactiveCaptionText);
-        yield return ("infobackground", SystemColors.Info);
-        yield return ("infotext", SystemColors.InfoText);
-        yield return ("menu", SystemColors.Menu);
-        yield return ("menutext", SystemColors.MenuText);
-        yield return ("scrollbar", SystemColors.ScrollBar);
-        yield return ("window", SystemColors.Window);
-        yield return ("windowframe", SystemColors.WindowFrame);
-        yield return ("windowtext", SystemColors.WindowText);
-        yield return ("threeddarkshadow", SystemColors.ControlDarkDark);
-
-        yield return ("LightGrey", Color.LightGray);
-        yield return ("Blue", Color.Blue);
-        yield return ("#1F2E3D", Color.FromArgb(31, 46, 61));
-    }
-
-    public static IEnumerable<object[]> FromHtml_TestData()
-    {
-        yield return new object[] { null, Color.Empty };
-        yield return new object[] { "", Color.Empty };
-        yield return new object[] { "  ", Color.Empty };
-        yield return new object[] { "''", Color.FromName("") };
-        yield return new object[] { "\"\"", Color.FromName("") };
-
-        yield return new object[] { "#1B3", Color.FromArgb(17, 187, 51) };
-        yield return new object[] { "  #1F2E3D  ", Color.FromArgb(31, 46, 61) };
-
-        yield return new object[] { "ActiveBorder", SystemColors.ActiveBorder };
-        yield return new object[] { "ACTIVEBORDER", SystemColors.ActiveBorder };
-        yield return new object[] { "  Blue  ", Color.Blue };
-        yield return new object[] { "'Blue'", Color.Blue };
-        yield return new object[] { "\"Blue\"", Color.Blue };
-        yield return new object[] { "'None'", Color.FromName("None") };
-        yield return new object[] { "\"None\"", Color.FromName("None") };
-        yield return new object[] { "255,0,0", Color.Red };
-
-        // Color(argb)
-        yield return new object[] { 498, Color.FromArgb(0, 0, 1, 242) };
-        yield return new object[] { "&h1F2", Color.FromArgb(0, 0, 1, 242) };
-        yield return new object[] { "&h1F2", Color.FromArgb(0, 0, 1, 242) };
-
-        // Color(red, green, blue)
-        yield return new object[] { "1, 0x2, &h3", Color.FromArgb(1, 2, 3) };
-
-        // Color(alpha, red, green, blue)
-        yield return new object[] { "1, 2, 0x3, &h4", Color.FromArgb(1, 2, 3, 4) };
-
-        foreach ((string htmlColor, Color color) in HtmlColors_TestData())
-        {
-            yield return new object[] { htmlColor, color };
-        }
-
-        // Some of the SystemColors.Control colors don't roundtrip.
-        yield return new object[] { "threedface", SystemColors.Control };
-        yield return new object[] { "threedhighlight", SystemColors.ControlLight };
-        yield return new object[] { "threedlightshadow", SystemColors.ControlLightLight };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHtml_TestData))]
-    public void FromHtml_String_ReturnsExpected(string htmlColor, Color expected)
-    {
-        using (new ThreadCultureChange(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture))
-        {
-            Assert.Equal(expected, ColorTranslator.FromHtml(htmlColor));
-        }
-    }
-
-    [Theory]
-    [InlineData("'")]
-    [InlineData("'\"")]
-    [InlineData("\"'")]
-    [InlineData("#")]
-    [InlineData("  #G12  ")]
-    [InlineData("  #G12345  ")]
-    [InlineData("#FFFFFFFFF")]
-    [InlineData("0x")]
-    [InlineData("0xFFFFFFFFF")]
-    [InlineData("0xG12")]
-    [InlineData("&h")]
-    [InlineData("&hG12")]
-    public void FromHtml_Invalid_Throws(string htmlColor)
-    {
-        using (new ThreadCultureChange(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture))
-        {
-            Exception exception = AssertExtensions.Throws<ArgumentException, Exception>(() => ColorTranslator.FromHtml(htmlColor));
-            if (exception is ArgumentException argumentException)
-                Assert.Equal("htmlColor", argumentException.ParamName);
-        }
-    }
-
-    [Theory]
-    [InlineData("#G12", typeof(FormatException))]
-    [InlineData("#G12345", typeof(FormatException))]
-    [InlineData("1,2", typeof(ArgumentException))]
-    [InlineData("1,2,3,4,5", typeof(ArgumentException))]
-    [InlineData("-1,2,3", typeof(ArgumentException))]
-    [InlineData("256,2,3", typeof(ArgumentException))]
-    [InlineData("1,-1,3", typeof(ArgumentException))]
-    [InlineData("1,256,3", typeof(ArgumentException))]
-    [InlineData("1,2,-1", typeof(ArgumentException))]
-    [InlineData("1,2,256", typeof(ArgumentException))]
-    public void FromHtml_Invalid_Throw(string htmlColor, Type exception)
-    {
-        using (new ThreadCultureChange(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture))
-        {
-            Assert.Throws(exception, () => ColorTranslator.FromHtml(htmlColor));
-        }
-    }
-
-    public static IEnumerable<object[]> ToHtml_TestData()
-    {
-        yield return new object[] { Color.Empty, "" };
-
-        foreach ((string htmlColor, Color color) in HtmlColors_TestData())
-        {
-            yield return new object[] { color, htmlColor };
-        }
-
-        // SystemColors.ControlLight don't roundtrip.
-        yield return new object[] { SystemColors.ControlLight, "buttonface" };
-        yield return new object[] { SystemColors.GradientActiveCaption, "activecaption" };
-        yield return new object[] { SystemColors.HotTrack, "highlight" };
-        yield return new object[] { SystemColors.MenuHighlight, "highlighttext" };
-        yield return new object[] { SystemColors.GradientInactiveCaption, "inactivecaption" };
-        yield return new object[] { SystemColors.MenuBar, "menu" };
-        yield return new object[] { SystemColors.ButtonShadow, "" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToHtml_TestData))]
-    public void ToHtml_Color_ReturnsExpected(Color color, string expected)
-    {
-        Assert.Equal(expected, ColorTranslator.ToHtml(color));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Design/CategoryNameCollectionTests.cs b/src/System.Drawing.Common/tests/Design/CategoryNameCollectionTests.cs
deleted file mode 100644
index fefaac368e8..00000000000
--- a/src/System.Drawing.Common/tests/Design/CategoryNameCollectionTests.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Design.Tests;
-
-public class CategoryNameCollectionTests
-{
-    [Fact]
-    public void Ctor_StringArray()
-    {
-        var value = new string[] { "1", "2", "3" };
-        var collection = new CategoryNameCollection(value);
-        Assert.Equal(value, collection.Cast<string>());
-    }
-
-    [Fact]
-    public void Ctor_CategoryNameCollection()
-    {
-        var value = new string[] { "1", "2", "3" };
-        var sourceCollection = new CategoryNameCollection(value);
-
-        var collection = new CategoryNameCollection(sourceCollection);
-        Assert.Equal(value, collection.Cast<string>());
-    }
-
-    [Fact]
-    public void Indexer_Get_ReturnsExpected()
-    {
-        var value = new string[] { "1", "2", "3" };
-        var sourceCollection = new CategoryNameCollection(value);
-
-        for (int i = 0; i < sourceCollection.Count; i++)
-        {
-            string expectedValue = value[i];
-            Assert.Equal(expectedValue, sourceCollection[i]);
-            Assert.True(sourceCollection.Contains(expectedValue));
-            Assert.Equal(i, sourceCollection.IndexOf(expectedValue));
-        }
-    }
-
-    [Fact]
-    public void CopyTo_Valid_Success()
-    {
-        var value = new string[] { "1", "2", "3" };
-        var sourceCollection = new CategoryNameCollection(value);
-
-        var destination = new string[5];
-        sourceCollection.CopyTo(destination, 1);
-
-        Assert.Equal(new string[] { null, "1", "2", "3", null }, destination);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/AdjustableArrowCapTests.cs b/src/System.Drawing.Common/tests/Drawing2D/AdjustableArrowCapTests.cs
deleted file mode 100644
index 80741c4bed1..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/AdjustableArrowCapTests.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class AdjustableArrowCapTests
-{
-    public static IEnumerable<object[]> Ctor_Float_Float_TestData()
-    {
-        yield return new object[] { 1f, 1f };
-        yield return new object[] { 50f, 50f };
-        yield return new object[] { float.MaxValue, float.MaxValue };
-        // Nonsensical values -- but still permitted.
-        yield return new object[] { -1f, 1f };
-        yield return new object[] { float.PositiveInfinity, 1f };
-        yield return new object[] { float.NegativeInfinity, 1f };
-        yield return new object[] { float.NaN, 1f };
-        yield return new object[] { 0f, 1f };
-        yield return new object[] { 0f, 0f };
-        yield return new object[] { 1f, -1f };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Float_Float_TestData))]
-    public void Ctor_Float_Float(float width, float height)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(width, height))
-        {
-            Assert.Equal(width, arrowCap.Width);
-            Assert.Equal(height, arrowCap.Height);
-            Assert.True(arrowCap.Filled);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Float_Float_Bool_TestData()
-    {
-        foreach (object[] data in Ctor_Float_Float_TestData())
-        {
-            yield return new object[] { data[0], data[1], true };
-            yield return new object[] { data[0], data[1], false };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Float_Float_Bool_TestData))]
-    public void Ctor_Float_Float_Bool(float width, float height, bool filled)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(width, height, filled))
-        {
-            Assert.Equal(width, arrowCap.Width);
-            Assert.Equal(height, arrowCap.Height);
-            Assert.Equal(filled, arrowCap.Filled);
-        }
-    }
-
-    public static IEnumerable<object[]> Properties_TestData()
-    {
-        yield return new object[] { -1 };
-        yield return new object[] { 0 };
-        yield return new object[] { 10 };
-        yield return new object[] { 5000 };
-        yield return new object[] { float.MaxValue };
-        yield return new object[] { float.PositiveInfinity };
-        yield return new object[] { float.NegativeInfinity };
-        yield return new object[] { float.NaN };
-    }
-
-    [Theory]
-    [MemberData(nameof(Properties_TestData))]
-    public void Width_Set_GetReturnsExpected(float width)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        {
-            arrowCap.Width = width;
-            Assert.Equal(width, arrowCap.Width);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Properties_TestData))]
-    public void Height_Set_GetReturnsExpected(float height)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        {
-            arrowCap.Height = height;
-            Assert.Equal(height, arrowCap.Height);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Properties_TestData))]
-    public void MiddleInset_Set_GetReturnsExpected(float middleInset)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        {
-            arrowCap.MiddleInset = middleInset;
-            Assert.Equal(middleInset, arrowCap.MiddleInset);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Filled_Set_GetReturnsExpected(bool filled)
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        {
-            arrowCap.Filled = filled;
-            Assert.Equal(filled, arrowCap.Filled);
-        }
-    }
-
-    [Fact]
-    public void Clone_Success()
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        using (AdjustableArrowCap clone = Assert.IsType<AdjustableArrowCap>(arrowCap.Clone()))
-        {
-            Assert.NotSame(clone, arrowCap);
-            Assert.Equal(clone.Width, arrowCap.Width);
-            Assert.Equal(clone.Height, arrowCap.Height);
-            Assert.Equal(clone.MiddleInset, arrowCap.MiddleInset);
-            Assert.Equal(clone.Filled, arrowCap.Filled);
-        }
-    }
-
-    [Fact]
-    public void BaseCap_ReturnsTriangle()
-    {
-        using (AdjustableArrowCap arrowCap = new AdjustableArrowCap(1, 1))
-        {
-            Assert.Equal(LineCap.Triangle, arrowCap.BaseCap);
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/BlendTests.cs b/src/System.Drawing.Common/tests/Drawing2D/BlendTests.cs
deleted file mode 100644
index 47aee4f5c19..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/BlendTests.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class BlendTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var blend = new Blend();
-        Assert.Equal(new float[1], blend.Factors);
-        Assert.Equal(new float[1], blend.Positions);
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(2)]
-    public void Ctor_Count(int count)
-    {
-        var blend = new Blend(count);
-        Assert.Equal(new float[count], blend.Factors);
-        Assert.Equal(new float[count], blend.Positions);
-    }
-
-    [Fact]
-    public void Ctor_InvalidCount_ThrowsOverflowException()
-    {
-        Assert.Throws<OverflowException>(() => new Blend(-1));
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotIntMaxValueArrayIndexSupported))]
-    public void Ctor_LargeCount_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => new Blend(int.MaxValue));
-    }
-
-    [Fact]
-    public void Factors_Set_GetReturnsExpected()
-    {
-        var blend = new Blend { Factors = null };
-        Assert.Null(blend.Factors);
-
-        blend.Factors = new float[10];
-        Assert.Equal(new float[10], blend.Factors);
-    }
-
-    [Fact]
-    public void Positions_Set_GetReturnsExpected()
-    {
-        var blend = new Blend { Positions = null };
-        Assert.Null(blend.Positions);
-
-        blend.Positions = new float[10];
-        Assert.Equal(new float[10], blend.Positions);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/ColorBlendTests.cs b/src/System.Drawing.Common/tests/Drawing2D/ColorBlendTests.cs
deleted file mode 100644
index 9d7ec9d8a0c..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/ColorBlendTests.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class ColorBlendTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var blend = new ColorBlend();
-        Assert.Equal(new Color[1], blend.Colors);
-        Assert.Equal(new float[1], blend.Positions);
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(2)]
-    public void Ctor_Count(int count)
-    {
-        var blend = new ColorBlend(count);
-        Assert.Equal(new Color[count], blend.Colors);
-        Assert.Equal(new float[count], blend.Positions);
-    }
-
-    [Fact]
-    public void Ctor_InvalidCount_ThrowsOverflowException()
-    {
-        Assert.Throws<OverflowException>(() => new ColorBlend(-1));
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotIntMaxValueArrayIndexSupported))]
-    public void Ctor_LargeCount_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => new ColorBlend(int.MaxValue));
-    }
-
-    [Fact]
-    public void Colors_Set_GetReturnsExpected()
-    {
-        var blend = new ColorBlend { Colors = null };
-        Assert.Null(blend.Colors);
-
-        blend.Colors = new Color[10];
-        Assert.Equal(new Color[10], blend.Colors);
-    }
-
-    [Fact]
-    public void Positions_Set_GetReturnsExpected()
-    {
-        var blend = new ColorBlend { Positions = null };
-        Assert.Null(blend.Positions);
-
-        blend.Positions = new float[10];
-        Assert.Equal(new float[10], blend.Positions);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/CustomLineCapTests.cs b/src/System.Drawing.Common/tests/Drawing2D/CustomLineCapTests.cs
deleted file mode 100644
index 9428f5aae9c..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/CustomLineCapTests.cs
+++ /dev/null
@@ -1,243 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class CustomLineCapTests
-{
-    public static IEnumerable<object[]> Ctor_Path_Path_LineCap_Float_TestData()
-    {
-        yield return new object[] { new GraphicsPath(), null, LineCap.Flat, 0f, LineCap.Flat };
-        yield return new object[] { new GraphicsPath(), null, LineCap.Square, 1f, LineCap.Square };
-        yield return new object[] { new GraphicsPath(), null, LineCap.Round, -1f, LineCap.Round };
-        yield return new object[] { new GraphicsPath(), null, LineCap.Triangle, float.MaxValue, LineCap.Triangle };
-        // All of these "anchor" values yield a "Flat" LineCap.
-        yield return new object[] { new GraphicsPath(), null, LineCap.NoAnchor, 0f, LineCap.Flat };
-        yield return new object[] { new GraphicsPath(), null, LineCap.SquareAnchor, 0f, LineCap.Flat };
-        yield return new object[] { new GraphicsPath(), null, LineCap.DiamondAnchor, 0f, LineCap.Flat };
-        yield return new object[] { new GraphicsPath(), null, LineCap.ArrowAnchor, 0f, LineCap.Flat };
-
-        // Boxy cap
-        GraphicsPath strokePath = new GraphicsPath();
-        strokePath.AddRectangle(new Rectangle(0, 0, 10, 10));
-        yield return new object[] { null, strokePath, LineCap.Square, 0f, LineCap.Square };
-
-        // Hook-shaped cap
-        strokePath = new GraphicsPath();
-        strokePath.AddLine(new Point(0, 0), new Point(0, 5));
-        strokePath.AddLine(new Point(0, 5), new Point(5, 1));
-        strokePath.AddLine(new Point(5, 1), new Point(3, 1));
-        yield return new object[] { null, strokePath, LineCap.Flat, 0f, LineCap.Flat };
-
-        // Fill path -- Must intercept the Y-axis.
-        GraphicsPath fillPath = new GraphicsPath();
-        fillPath.AddLine(new Point(-5, -10), new Point(0, 10));
-        fillPath.AddLine(new Point(0, 10), new Point(5, -10));
-        fillPath.AddLine(new Point(5, -10), new Point(-5, -10));
-        yield return new object[] { fillPath, null, LineCap.Flat, 0f, LineCap.Flat };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Path_Path_LineCap_Float_TestData))]
-    public void Ctor_Path_Path_LineCap_Float(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset, LineCap expectedCap)
-    {
-        using (fillPath)
-        using (strokePath)
-        using (CustomLineCap customLineCap = new CustomLineCap(fillPath, strokePath, baseCap, baseInset))
-        {
-            Assert.Equal(expectedCap, customLineCap.BaseCap);
-            Assert.Equal(baseInset, customLineCap.BaseInset);
-            Assert.Equal(LineJoin.Miter, customLineCap.StrokeJoin);
-            Assert.Equal(1f, customLineCap.WidthScale);
-        }
-    }
-
-    [Theory]
-    // These values are outside the valid range of the LineCap enum.
-    [InlineData(LineCap.Flat - 1)]
-    [InlineData(LineCap.Custom + 1)]
-    public void Ctor_InvalidLineCap_ReturnsFlat(LineCap baseCap)
-    {
-        using (GraphicsPath fillPath = new GraphicsPath())
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(fillPath, strokePath, baseCap, 0f))
-        {
-            Assert.Equal(LineCap.Flat, customLineCap.BaseCap);
-        }
-    }
-
-    [Fact]
-    public void Ctor_FillPath_Incomplete_ThrowsArgumentException()
-    {
-        using (GraphicsPath fillPath = new GraphicsPath())
-        {
-            fillPath.AddLine(new Point(0, -10), new Point(0, 10));
-            AssertExtensions.Throws<ArgumentException>(null, () => new CustomLineCap(fillPath, null));
-        }
-    }
-
-    [Fact]
-    public void Ctor_FillPath_DoesNotCrossYAxis_ThrowsNotImplementedException()
-    {
-        // Closed fillPath, but does not cross the Y-axis.
-        using (GraphicsPath fillPath = new GraphicsPath())
-        {
-            fillPath.AddLine(new Point(-5, 5), new Point(5, 5));
-            fillPath.AddLine(new Point(5, 5), new Point(5, 1));
-            fillPath.AddLine(new Point(5, 1), new Point(-5, 5));
-            Assert.Throws<NotImplementedException>(() => new CustomLineCap(fillPath, null));
-        }
-    }
-
-    [Theory]
-    [InlineData(LineCap.Square, LineCap.Square)]
-    [InlineData(LineCap.Round, LineCap.Round)]
-    [InlineData(LineCap.Triangle, LineCap.Triangle)]
-    public void SetThenGetStrokeCaps_Success(LineCap startCap, LineCap endCap)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.SetStrokeCaps(startCap, endCap);
-            customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap);
-
-            Assert.Equal(startCap, retrievedStartCap);
-            Assert.Equal(endCap, retrievedEndCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineCap.SquareAnchor, LineCap.SquareAnchor)]
-    [InlineData(LineCap.Custom, LineCap.Custom)]
-    [InlineData(LineCap.Square, LineCap.Custom)]
-    [InlineData(LineCap.Custom, LineCap.SquareAnchor)]
-    [InlineData(LineCap.Flat - 1, LineCap.Flat)] // Below valid enum range
-    [InlineData(LineCap.Custom + 1, LineCap.Flat)] // Above valid enum range
-    public void SetStrokeCaps_InvalidLineCap_ThrowsArgumentException(LineCap startCap, LineCap endCap)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.SetStrokeCaps(startCap, endCap));
-
-            // start and end cap should be unchanged.
-            customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap);
-            Assert.Equal(LineCap.Flat, retrievedStartCap);
-            Assert.Equal(LineCap.Flat, retrievedEndCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineJoin.Miter)] // Default value
-    [InlineData(LineJoin.Bevel)]
-    [InlineData(LineJoin.Round)]
-    [InlineData(LineJoin.MiterClipped)]
-    // Invalid (non-enum) values are allowed. Their values are stored and returned unchanged.
-    [InlineData(LineJoin.Miter - 1)]
-    [InlineData(LineJoin.MiterClipped + 1)]
-    public void StrokeJoin_SetThenGet_Success(LineJoin lineJoin)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.StrokeJoin = lineJoin;
-            Assert.Equal(lineJoin, customLineCap.StrokeJoin);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineCap.Flat)] // Default value
-    [InlineData(LineCap.Square)]
-    [InlineData(LineCap.Round)]
-    [InlineData(LineCap.Triangle)]
-    public void BaseCap_SetThenGet_Success(LineCap baseCap)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.BaseCap = baseCap;
-            Assert.Equal(baseCap, customLineCap.BaseCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineCap.NoAnchor)]
-    [InlineData(LineCap.SquareAnchor)]
-    [InlineData(LineCap.RoundAnchor)]
-    [InlineData(LineCap.DiamondAnchor)]
-    [InlineData(LineCap.Custom)]
-    [InlineData(LineCap.Flat - 1)]
-    [InlineData(LineCap.Custom + 1)]
-    public void BaseCap_Set_InvalidLineCap_ThrowsArgumentException(LineCap baseCap)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.BaseCap = baseCap);
-            Assert.Equal(LineCap.Flat, customLineCap.BaseCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(0f)]
-    [InlineData(1f)]
-    [InlineData(10f)]
-    [InlineData(10000f)]
-    [InlineData(-1f)]
-    [InlineData(-10f)]
-    [InlineData(-10000f)]
-    [InlineData(float.MaxValue)]
-    [InlineData(float.MinValue)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.NaN)]
-    public void BaseInset_SetThenGet_Success(float value)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.BaseInset = value;
-            Assert.Equal(value, customLineCap.BaseInset);
-        }
-    }
-
-    [Theory]
-    [InlineData(0f)]
-    [InlineData(1f)]
-    [InlineData(10f)]
-    [InlineData(10000f)]
-    [InlineData(-1f)]
-    [InlineData(-10f)]
-    [InlineData(-10000f)]
-    [InlineData(float.MaxValue)]
-    [InlineData(float.MinValue)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.NaN)]
-    public void WidthScale_SetThenGet_Success(float value)
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.WidthScale = value;
-            Assert.Equal(value, customLineCap.WidthScale);
-        }
-    }
-
-    [Fact]
-    public void Disposed_MembersThrow()
-    {
-        using (GraphicsPath strokePath = new GraphicsPath())
-        using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath))
-        {
-            customLineCap.Dispose();
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.StrokeJoin);
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.BaseCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.BaseInset);
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.WidthScale);
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.Clone());
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.SetStrokeCaps(LineCap.Flat, LineCap.Flat));
-            AssertExtensions.Throws<ArgumentException>(null, () => customLineCap.GetStrokeCaps(out LineCap startCap, out LineCap endCap));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathIteratorTests.cs b/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathIteratorTests.cs
deleted file mode 100644
index 34850f23f65..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathIteratorTests.cs
+++ /dev/null
@@ -1,420 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class GraphicsPathIteratorTests
-{
-    private readonly PointF[] _twoPoints = new PointF[2] { new PointF(1, 2), new PointF(20, 30) };
-
-    [Fact]
-    public void Ctor_Path_Success()
-    {
-        byte[] types = new byte[] { 0, 1 };
-
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, types))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(2, gpi.Count);
-        }
-    }
-
-    [Fact]
-    public void Ctor_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(0, gpi.Count);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullPath_Success()
-    {
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(null))
-        {
-            Assert.Equal(0, gpi.Count);
-        }
-    }
-
-    [Fact]
-    public void NextSubpath_PathFigureNotClosed_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            gp.AddLines(_twoPoints);
-            Assert.Equal(0, gpi.NextSubpath(gp, out bool isClosed));
-            Assert.False(isClosed);
-        }
-    }
-
-    [Fact]
-    public void NextSubpath_PathFigureClosed_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, new byte[] { 0, 129 }))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(2, gpi.NextSubpath(gp, out bool isClosed));
-            Assert.True(isClosed);
-        }
-    }
-
-    [Fact]
-    public void NextSubpath_NullPath_ReturnsExpected()
-    {
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(null))
-        {
-            Assert.Equal(0, gpi.NextSubpath(null, out bool isClosed));
-            Assert.False(isClosed);
-        }
-    }
-
-    [Fact]
-    public void NextSubpath_FigureNotClosed_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            gp.AddLines(_twoPoints);
-            Assert.Equal(0, gpi.NextSubpath(out int startIndex, out int endIndex, out bool isClosed));
-            Assert.False(isClosed);
-            Assert.Equal(0, startIndex);
-            Assert.Equal(0, endIndex);
-        }
-    }
-
-    [Fact]
-    public void NextSubpath_FigureClosed_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, new byte[] { 0, 129 }))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(2, gpi.NextSubpath(out int startIndex, out int endIndex, out bool isClosed));
-            Assert.True(isClosed);
-            Assert.Equal(0, startIndex);
-            Assert.Equal(1, endIndex);
-        }
-    }
-
-    [Fact]
-    public void NextMarker_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, new byte[] { 0, 1 }))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(2, gpi.NextMarker(out int startIndex, out int endIndex));
-            Assert.Equal(0, startIndex);
-            Assert.Equal(1, endIndex);
-        }
-    }
-
-    [Fact]
-    public void NextMarker_Empty_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            gp.AddLines(_twoPoints);
-            Assert.Equal(0, gpi.NextMarker(out int startIndex, out int endIndex));
-            Assert.Equal(0, startIndex);
-            Assert.Equal(0, endIndex);
-        }
-    }
-
-    [Fact]
-    public void NextMarker_NullPath_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            gp.AddLines(_twoPoints);
-            Assert.Equal(0, gpi.NextMarker(null));
-        }
-    }
-
-    [Fact]
-    public void NextMarker_EmptyPath_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            gp.AddLines(_twoPoints);
-            Assert.Equal(0, gpi.NextMarker(gp));
-        }
-    }
-
-    [Fact]
-    public void NextMarker_Path_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, new byte[] { 0, 1 }))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(2, gpi.NextMarker(gp));
-        }
-    }
-
-    [Fact]
-    public void Count_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath(_twoPoints, new byte[] { 0, 1 }))
-        using (GraphicsPath gpEmpty = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        using (GraphicsPathIterator gpiEmpty = new GraphicsPathIterator(gpEmpty))
-        using (GraphicsPathIterator gpiNull = new GraphicsPathIterator(null))
-        {
-            Assert.Equal(2, gpi.Count);
-            Assert.Equal(0, gpiEmpty.Count);
-            Assert.Equal(0, gpiNull.Count);
-        }
-    }
-
-    [Fact]
-    public void SubpathCount_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        using (GraphicsPathIterator gpiNull = new GraphicsPathIterator(null))
-        {
-            Assert.Equal(0, gpi.SubpathCount);
-            Assert.Equal(0, gpiNull.SubpathCount);
-
-            gp.AddLine(0, 1, 2, 3);
-            gp.SetMarkers();
-            gp.StartFigure();
-            gp.AddLine(20, 21, 22, 23);
-            gp.AddBezier(5, 6, 7, 8, 9, 10, 11, 12);
-
-            using (GraphicsPathIterator gpiWithSubpaths = new GraphicsPathIterator(gp))
-            {
-                Assert.Equal(2, gpiWithSubpaths.SubpathCount);
-            }
-        }
-    }
-
-    [Fact]
-    public void HasCurve_ReturnsExpected()
-    {
-        Point[] points = new Point[] { new Point(1, 1), new Point(2, 2), new Point(3, 3), new Point(4, 4) };
-        byte[] types = new byte[] { 0, 3, 3, 3 };
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPath gpEmpty = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        using (GraphicsPathIterator gpiEmpty = new GraphicsPathIterator(gpEmpty))
-        using (GraphicsPathIterator gpiNull = new GraphicsPathIterator(null))
-        {
-            Assert.True(gpi.HasCurve());
-            Assert.False(gpiEmpty.HasCurve());
-            Assert.False(gpiNull.HasCurve());
-        }
-    }
-
-    [Fact]
-    public void Rewind_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath inner = new GraphicsPath())
-        {
-            gp.AddLine(0, 1, 2, 3);
-            gp.SetMarkers();
-            gp.StartFigure();
-            gp.AddLine(20, 21, 22, 23);
-            gp.AddBezier(5, 6, 7, 8, 9, 10, 11, 12);
-
-            using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-            {
-                Assert.Equal(2, gpi.SubpathCount);
-                Assert.Equal(2, gpi.NextMarker(gp));
-                Assert.Equal(6, gpi.NextMarker(gp));
-                Assert.Equal(0, gpi.NextMarker(gp));
-                gpi.Rewind();
-                Assert.Equal(8, gpi.NextMarker(gp));
-                Assert.Equal(0, gpi.NextMarker(gp));
-            }
-        }
-    }
-
-    [Fact]
-    public void Enumerate_ZeroPoints_ReturnsExpected()
-    {
-        PointF[] points = new PointF[0];
-        byte[] types = new byte[0];
-
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(0, gpi.Enumerate(ref points, ref types));
-            Assert.Equal(0, points.Length);
-            Assert.Equal(0, types.Length);
-        }
-    }
-
-    [Fact]
-    public void Enumerate_ReturnsExpected()
-    {
-        PointF[] points = new PointF[] { new PointF(1f, 1f), new PointF(2f, 2f), new PointF(3f, 3f), new PointF(4f, 4f) };
-        byte[] types = new byte[] { 0, 3, 3, 3 };
-
-        PointF[] actualPoints = new PointF[4];
-        byte[] actualTypes = new byte[4];
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(4, gpi.Enumerate(ref actualPoints, ref actualTypes));
-            Assert.Equal(gp.PathPoints, actualPoints);
-            Assert.Equal(gp.PathTypes, actualTypes);
-        }
-    }
-
-    public static IEnumerable<object[]> PointsTypesLengthMismatch_TestData()
-    {
-        yield return new object[] { new PointF[1], new byte[2] };
-        yield return new object[] { new PointF[2], new byte[1] };
-    }
-
-    [Theory]
-    [MemberData(nameof(PointsTypesLengthMismatch_TestData))]
-    public void Enumerate_PointsTypesMismatch_ThrowsArgumentException(PointF[] points, byte[] types)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gpi.Enumerate(ref points, ref types));
-        }
-    }
-
-    public static IEnumerable<object[]> NullPointsTypes_TestData()
-    {
-        yield return new object[] { null, new byte[1] };
-        yield return new object[] { new PointF[1], null };
-        yield return new object[] { null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(NullPointsTypes_TestData))]
-    public void Enumerate_NullPointsTypes_ThrowsNullReferenceException(PointF[] points, byte[] types)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Throws<NullReferenceException>(() => gpi.Enumerate(ref points, ref types));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(PointsTypesLengthMismatch_TestData))]
-    public void CopyData_PointsTypesMismatch_ThrowsArgumentException(PointF[] points, byte[] types)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gpi.CopyData(ref points, ref types, 0, points.Length));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(NullPointsTypes_TestData))]
-    public void CopyData_NullPointsTypes_ThrowsNullReferenceException(PointF[] points, byte[] types)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Throws<NullReferenceException>(() => gpi.CopyData(ref points, ref types, 0, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, 2)]
-    [InlineData(0, 3)]
-    public void CopyData_StartEndIndexesOutOfRange_ThrowsArgumentException(int startIndex, int endIndex)
-    {
-        PointF[] resultPoints = new PointF[0];
-        byte[] resultTypes = new byte[0];
-
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gpi.CopyData(ref resultPoints, ref resultTypes, startIndex, endIndex));
-        }
-    }
-
-    public static IEnumerable<object[]> CopyData_StartEndIndexesOutOfRange_TestData()
-    {
-        yield return new object[] { new PointF[3], new byte[3], int.MinValue, 2 };
-        yield return new object[] { new PointF[3], new byte[3], 0, int.MaxValue };
-        yield return new object[] { new PointF[3], new byte[3], 2, 0 };
-    }
-
-    [Theory]
-    [MemberData(nameof(CopyData_StartEndIndexesOutOfRange_TestData))]
-    public void CopyData_StartEndIndexesOutOfRange_ReturnsExpected(PointF[] points, byte[] types, int startIndex, int endIndex)
-    {
-        PointF[] resultPoints = new PointF[points.Length];
-        byte[] resultTypes = new byte[points.Length];
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(0, gpi.CopyData(ref resultPoints, ref resultTypes, startIndex, endIndex));
-        }
-    }
-
-    [Fact]
-    public void CopyData_EqualStartEndIndexes_ReturnsExpected()
-    {
-        PointF[] points = new PointF[] { new PointF(1f, 1f), new PointF(2f, 2f), new PointF(3f, 3f), new PointF(4f, 4f) };
-        byte[] types = new byte[] { 0, 3, 3, 3 };
-
-        PointF[] actualPoints = new PointF[1];
-        byte[] actualTypes = new byte[1];
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(1, gpi.CopyData(ref actualPoints, ref actualTypes, 0, 0));
-            Assert.Equal(gp.PathPoints[0], actualPoints[0]);
-            Assert.Equal(gp.PathTypes[0], actualTypes[0]);
-        }
-    }
-
-    [Fact]
-    public void CopyData_ReturnsExpected()
-    {
-        PointF[] points = new PointF[] { new PointF(1f, 1f), new PointF(2f, 2f), new PointF(3f, 3f), new PointF(4f, 4f) };
-        byte[] types = new byte[] { 0, 3, 3, 3 };
-
-        PointF[] actualPoints = new PointF[3];
-        byte[] actualTypes = new byte[3];
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPathIterator gpi = new GraphicsPathIterator(gp))
-        {
-            Assert.Equal(3, gpi.CopyData(ref actualPoints, ref actualTypes, 0, 2));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathTests.cs b/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathTests.cs
deleted file mode 100644
index a23b8e50829..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/GraphicsPathTests.cs
+++ /dev/null
@@ -1,2684 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class GraphicsPathTests
-{
-    private const float Pi4 = (float)(Math.PI / 4);
-    private const float Delta = 0.0003f;
-
-    [Fact]
-    public void Ctor_Default_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Equal(FillMode.Alternate, gp.FillMode);
-            AssertEmptyGraphicsPath(gp);
-        }
-    }
-
-    [Fact]
-    public void Ctor_FillMode_Success()
-    {
-        using (GraphicsPath gpa = new GraphicsPath(FillMode.Alternate))
-        using (GraphicsPath gpw = new GraphicsPath(FillMode.Winding))
-        {
-            Assert.Equal(FillMode.Alternate, gpa.FillMode);
-            AssertEmptyGraphicsPath(gpa);
-            Assert.Equal(FillMode.Winding, gpw.FillMode);
-            AssertEmptyGraphicsPath(gpw);
-        }
-    }
-
-    [Fact]
-    public void Ctor_SamePoints_Success()
-    {
-        byte[] types = new byte[6] { 0, 1, 1, 1, 1, 1 };
-        Point[] points = new Point[]
-        {
-            new Point (1, 1), new Point (1, 1), new Point (1, 1),
-            new Point (1, 1), new Point (1, 1), new Point (1, 1),
-        };
-
-        PointF[] fPoints = new PointF[]
-        {
-            new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f),
-            new PointF (1f, 1f), new PointF (1f, 1f), new PointF (1f, 1f),
-        };
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        using (GraphicsPath gpf = new GraphicsPath(fPoints, types))
-        {
-            Assert.Equal(FillMode.Alternate, gp.FillMode);
-            Assert.Equal(6, gp.PointCount);
-            Assert.Equal(FillMode.Alternate, gpf.FillMode);
-            Assert.Equal(6, gpf.PointCount);
-            types[0] = 1;
-            Assert.Equal(FillMode.Alternate, gp.FillMode);
-            Assert.Equal(6, gp.PointCount);
-            Assert.Equal(FillMode.Alternate, gpf.FillMode);
-            Assert.Equal(6, gpf.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Ctor_PointsNull_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("pts", () => new GraphicsPath((Point[])null, new byte[1]));
-    }
-
-    public static IEnumerable<object[]> AddCurve_PointsTypesLengthMismatch_TestData()
-    {
-        yield return new object[] { 1, 2 };
-        yield return new object[] { 2, 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddCurve_PointsTypesLengthMismatch_TestData))]
-    public void Ctor_PointsTypesLengthMismatch_ThrowsArgumentException(int pointsLength, int typesLength)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new GraphicsPath(new Point[pointsLength], new byte[typesLength]));
-        AssertExtensions.Throws<ArgumentException>(null, () => new GraphicsPath(new PointF[pointsLength], new byte[typesLength]));
-    }
-
-    [Fact]
-    public void Clone_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            Assert.Equal(FillMode.Alternate, clone.FillMode);
-            AssertEmptyGraphicsPath(clone);
-        }
-    }
-
-    [Fact]
-    public void Reset_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.Reset();
-
-            Assert.Equal(FillMode.Alternate, gp.FillMode);
-            AssertEmptyGraphicsPath(gp);
-        }
-    }
-
-    [Fact]
-    public void GraphicsPath_FillModeChange()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.FillMode = FillMode.Winding;
-            Assert.Equal(FillMode.Winding, gp.FillMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(FillMode.Alternate - 1)]
-    [InlineData(FillMode.Winding + 1)]
-    public void GraphicsPath_InvalidFillMode_ThrowsInvalidEnumArgumentException(FillMode fillMode)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.ThrowsAny<ArgumentException>(() => gp.FillMode = fillMode);
-        }
-    }
-
-    [Fact]
-    public void PathData_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Equal(0, gp.PathData.Points.Length);
-            Assert.Equal(0, gp.PathData.Types.Length);
-        }
-    }
-
-    [Fact]
-    public void PathData_CannotChange()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(1, 1, 2, 2));
-            Assert.Equal(1f, gp.PathData.Points[0].X);
-            Assert.Equal(1f, gp.PathData.Points[0].Y);
-
-            gp.PathData.Points[0] = new Point(0, 0);
-            Assert.Equal(1f, gp.PathData.Points[0].X);
-            Assert.Equal(1f, gp.PathData.Points[0].Y);
-        }
-    }
-
-    [Fact]
-    public void PathPoints_CannotChange()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(1, 1, 2, 2));
-            Assert.Equal(1f, gp.PathPoints[0].X);
-            Assert.Equal(1f, gp.PathPoints[0].Y);
-
-            gp.PathPoints[0] = new Point(0, 0);
-            Assert.Equal(1f, gp.PathPoints[0].X);
-            Assert.Equal(1f, gp.PathPoints[0].Y);
-        }
-    }
-
-    [Fact]
-    public void PathPoints_EmptyPath_ThrowsArgumentException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Throws<ArgumentException>(() => gp.PathPoints);
-        }
-    }
-
-    [Fact]
-    public void PathTypes_CannotChange()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(1, 1, 2, 2));
-            Assert.Equal(0, gp.PathTypes[0]);
-
-            gp.PathTypes[0] = 1;
-            Assert.Equal(0, gp.PathTypes[0]);
-        }
-    }
-
-    [Fact]
-    public void PathTypes_EmptyPath_ThrowsArgumentException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Throws<ArgumentException>(() => gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void GetLastPoint_ReturnsExpected()
-    {
-        byte[] types = new byte[3] { 0, 1, 1 };
-        PointF[] points = new PointF[]
-        {
-            new PointF (1f, 1f), new PointF (2f, 2f), new PointF (3f, 3f),
-        };
-
-        using (GraphicsPath gp = new GraphicsPath(points, types))
-        {
-            Assert.Equal(gp.GetLastPoint(), points[2]);
-        }
-    }
-
-    [Fact]
-    public void AddLine_Success()
-    {
-        using (GraphicsPath gpInt = new GraphicsPath())
-        using (GraphicsPath gpFloat = new GraphicsPath())
-        using (GraphicsPath gpPointsInt = new GraphicsPath())
-        using (GraphicsPath gpfPointsloat = new GraphicsPath())
-        {
-            gpInt.AddLine(1, 1, 2, 2);
-            // AssertLine() method expects line drawn between points with coordinates 1, 1 and 2, 2, here and below.
-            AssertLine(gpInt);
-
-            gpFloat.AddLine(1, 1, 2, 2);
-            AssertLine(gpFloat);
-
-            gpPointsInt.AddLine(new Point(1, 1), new Point(2, 2));
-            AssertLine(gpPointsInt);
-
-            gpfPointsloat.AddLine(new PointF(1, 1), new PointF(2, 2));
-            AssertLine(gpfPointsloat);
-        }
-    }
-
-    [Fact]
-    public void AddLine_SamePoints_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddLine(new Point(49, 157), new Point(75, 196));
-            gpi.AddLine(new Point(75, 196), new Point(102, 209));
-            Assert.Equal(3, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1 }, gpi.PathTypes);
-
-            gpi.AddLine(new Point(102, 209), new Point(75, 196));
-            Assert.Equal(4, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 1 }, gpi.PathTypes);
-
-            gpf.AddLine(new PointF(49, 157), new PointF(75, 196));
-            gpf.AddLine(new PointF(75, 196), new PointF(102, 209));
-            Assert.Equal(3, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1 }, gpf.PathTypes);
-
-            gpf.AddLine(new PointF(102, 209), new PointF(75, 196));
-            Assert.Equal(4, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 1 }, gpf.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void AddLines_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddLines(new Point[] { new Point(1, 1), new Point(2, 2) });
-            AssertLine(gpi);
-
-            gpf.AddLines(new PointF[] { new PointF(1, 1), new PointF(2, 2) });
-            AssertLine(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddLines_SinglePoint_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddLines(new PointF[] { new PointF(1, 1) });
-            Assert.Equal(1, gpi.PointCount);
-            Assert.Equal(0, gpi.PathTypes[0]);
-
-            gpf.AddLines(new PointF[] { new PointF(1, 1) });
-            Assert.Equal(1, gpf.PointCount);
-            Assert.Equal(0, gpf.PathTypes[0]);
-        }
-    }
-
-    [Fact]
-    public void AddLines_SamePoint_Success()
-    {
-        Point[] intPoints = new Point[]
-        {
-            new Point(49, 157), new Point(49, 157)
-        };
-
-        PointF[] floatPoints = new PointF[]
-        {
-            new PointF(49, 57), new PointF(49, 57),
-            new PointF(49, 57), new PointF(49, 57)
-        };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddLines(intPoints);
-            Assert.Equal(2, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1 }, gpi.PathTypes);
-
-            gpi.AddLines(intPoints);
-            Assert.Equal(3, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1 }, gpi.PathTypes);
-
-            gpi.AddLines(intPoints);
-            Assert.Equal(4, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 1 }, gpi.PathTypes);
-
-            gpf.AddLines(floatPoints);
-            Assert.Equal(4, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 1 }, gpf.PathTypes);
-
-            gpf.AddLines(floatPoints);
-            Assert.Equal(7, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 1, 1, 1, 1 }, gpf.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void AddLines_PointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => new GraphicsPath().AddLines((Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => new GraphicsPath().AddLines((PointF[])null));
-        }
-    }
-
-    [Fact]
-    public void AddLines_ZeroPoints_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>("points", null, () => new GraphicsPath().AddLines(new Point[0]));
-        AssertExtensions.Throws<ArgumentException>("points", null, () => new GraphicsPath().AddLines(new PointF[0]));
-    }
-
-    [Fact]
-    public void AddArc_Values_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddArc(1, 1, 2, 2, Pi4, Pi4);
-            // AssertArc() method expects added Arc with parameters
-            // x=1, y=1, width=2, height=2, startAngle=Pi4, seewpAngle=Pi4 here and below.
-            AssertArc(gpi);
-
-            gpf.AddArc(1f, 1f, 2f, 2f, Pi4, Pi4);
-            AssertArc(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddArc_Rectangle_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddArc(new Rectangle(1, 1, 2, 2), Pi4, Pi4);
-            AssertArc(gpi);
-
-            gpf.AddArc(new RectangleF(1, 1, 2, 2), Pi4, Pi4);
-            AssertArc(gpf);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(0, 1)]
-    public void AddArc_ZeroWidthHeight_ThrowsArgumentException(int width, int height)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddArc(1, 1, width, height, Pi4, Pi4));
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddArc(1.0f, 1.0f, (float)width, (float)height, Pi4, Pi4));
-        }
-    }
-
-    [Fact]
-    public void AddBezier_Points_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddBezier(new Point(1, 1), new Point(2, 2), new Point(3, 3), new Point(4, 4));
-            // AssertBezier() method expects added Bezier with points (1, 1), (2, 2), (3, 3), (4, 4), here and below.
-            AssertBezier(gpi);
-
-            gpf.AddBezier(new PointF(1, 1), new PointF(2, 2), new PointF(3, 3), new PointF(4, 4));
-            AssertBezier(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddBezier_SamePoints_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gp.AddBezier(new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0));
-            Assert.Equal(4, gp.PointCount);
-            Assert.Equal(new byte[] { 0, 3, 3, 3 }, gp.PathTypes);
-
-            gp.AddBezier(new Point(0, 0), new Point(0, 0), new Point(0, 0), new Point(0, 0));
-            Assert.Equal(7, gp.PointCount);
-            Assert.Equal(new byte[] { 0, 3, 3, 3, 3, 3, 3 }, gp.PathTypes);
-
-            gpf.AddBezier(new PointF(0, 0), new PointF(0, 0), new PointF(0, 0), new PointF(0, 0));
-            Assert.Equal(4, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 3, 3, 3 }, gpf.PathTypes);
-
-            gpf.AddBezier(new PointF(0, 0), new PointF(0, 0), new PointF(0, 0), new PointF(0, 0));
-            Assert.Equal(7, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 3, 3, 3, 3, 3, 3 }, gpf.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void AddBezier_Values_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddBezier(1, 1, 2, 2, 3, 3, 4, 4);
-            AssertBezier(gpi);
-
-            gpf.AddBezier(1f, 1f, 2f, 2f, 3f, 3f, 4f, 4f);
-            AssertBezier(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddBeziers_Points_Success()
-    {
-        PointF[] points = new PointF[]
-        {
-            new PointF(1, 1), new PointF(2, 2), new PointF(3, 3), new PointF(4, 4)
-        };
-
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpf.AddBeziers(points);
-            AssertBezier(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddBeziers_PointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddBeziers((PointF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddBeziers((Point[])null));
-        }
-    }
-
-    public static IEnumerable<object[]> AddBeziers_InvalidFloatPointsLength_TestData()
-    {
-        yield return new object[] { new PointF[0] };
-        yield return new object[] { new PointF[1] { new PointF(1f, 1f) } };
-        yield return new object[] { new PointF[2] { new PointF(1f, 1f), new PointF(2f, 2f) } };
-        yield return new object[] { new PointF[3] { new PointF(1f, 1f), new PointF(2f, 2f), new PointF(3f, 3f) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddBeziers_InvalidFloatPointsLength_TestData))]
-    public void AddBeziers_InvalidFloatPointsLength_ThrowsArgumentException(PointF[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddBeziers(points));
-        }
-    }
-
-    [Fact]
-    public void AddCurve_TwoPoints_Success()
-    {
-        Point[] intPoints = new Point[] { new Point(1, 1), new Point(2, 2) };
-        PointF[] floatPoints = new PointF[] { new PointF(1, 1), new PointF(2, 2) };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpf.AddCurve(floatPoints);
-            // AssertCurve() method expects added Curve with points (1, 1), (2, 2), here and below.
-            AssertCurve(gpf);
-
-            gpi.AddCurve(intPoints);
-            AssertCurve(gpi);
-        }
-    }
-
-    [Fact]
-    public void AddCurve_TwoPointsWithTension_Success()
-    {
-        Point[] intPoints = new Point[] { new Point(1, 1), new Point(2, 2) };
-        PointF[] floatPoints = new PointF[] { new PointF(1, 1), new PointF(2, 2) };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddCurve(intPoints, 0.5f);
-            AssertCurve(gpi);
-
-            gpf.AddCurve(floatPoints, 0.5f);
-            AssertCurve(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddCurve_SamePoints_Success()
-    {
-        Point[] intPoints = new Point[] { new Point(1, 1), new Point(1, 1) };
-        PointF[] floatPoints = new PointF[] { new PointF(1, 1), new PointF(1, 1) };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddCurve(intPoints);
-            Assert.Equal(4, gpi.PointCount);
-            gpi.AddCurve(intPoints);
-            Assert.Equal(7, gpi.PointCount);
-
-            gpf.AddCurve(floatPoints);
-            Assert.Equal(4, gpf.PointCount);
-            gpf.AddCurve(floatPoints);
-            Assert.Equal(7, gpf.PointCount);
-        }
-    }
-
-    [Fact]
-    public void AddCurve_LargeTension_Success()
-    {
-        Point[] intPoints = new Point[] { new Point(1, 1), new Point(2, 2) };
-        PointF[] floatPoints = new PointF[] { new PointF(1, 1), new PointF(2, 2) };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddCurve(intPoints, float.MaxValue);
-            Assert.Equal(4, gpi.PointCount);
-
-            gpf.AddCurve(floatPoints, float.MaxValue);
-            Assert.Equal(4, gpf.PointCount);
-        }
-    }
-
-    [Fact]
-    public void AddCurve_Success()
-    {
-        PointF[] points = new PointF[]
-        {
-            new PointF (37f, 185f),
-            new PointF (99f, 185f),
-            new PointF (161f, 159f),
-            new PointF (223f, 185f),
-            new PointF (285f, 54f),
-        };
-
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF (37f, 185f),
-            new PointF (47.33333f, 185f),
-            new PointF (78.3333f, 189.3333f),
-            new PointF (99f, 185f),
-            new PointF (119.6667f, 180.6667f),
-            new PointF (140.3333f, 159f),
-            new PointF (161f, 159f),
-            new PointF (181.6667f, 159f),
-            new PointF (202.3333f, 202.5f),
-            new PointF (223f, 185f),
-            new PointF (243.6667f, 167.5f),
-            new PointF (274.6667f, 75.8333f),
-            new PointF (285f, 54f),
-        };
-
-        byte[] expectedTypes = new byte[] { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
-        int[] pointsCount = { 4, 7, 10, 13 };
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            for (int i = 0; i < points.Length - 1; i++)
-            {
-                gp.AddCurve(points, i, 1, 0.5f);
-                Assert.Equal(pointsCount[i], gp.PointCount);
-            }
-
-            AssertPointsSequenceEqual(expectedPoints, gp.PathPoints, Delta);
-            Assert.Equal(expectedTypes, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void AddCurve_PointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddCurve((PointF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddCurve((Point[])null));
-        }
-    }
-
-    public static IEnumerable<object[]> AddCurve_InvalidFloatPointsLength_TestData()
-    {
-        yield return new object[] { new PointF[0] };
-        yield return new object[] { new PointF[1] { new PointF(1f, 1f) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddCurve_InvalidFloatPointsLength_TestData))]
-    public void AddCurve_InvalidFloatPointsLength_ThrowsArgumentException(PointF[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(points));
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(points, 0, 2, 0.5f));
-        }
-    }
-
-    public static IEnumerable<object[]> AddCurve_InvalidPointsLength_TestData()
-    {
-        yield return new object[] { new Point[0] };
-        yield return new object[] { new Point[1] { new Point(1, 1) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddCurve_InvalidPointsLength_TestData))]
-    public void AddCurve_InvalidPointsLength_ThrowsArgumentException(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(points));
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(points, 0, 2, 0.5f));
-        }
-    }
-
-    public static IEnumerable<object[]> AddCurve_InvalidSegment_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { -1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddCurve_InvalidSegment_TestData))]
-    public void AddCurve_InvalidSegment_ThrowsArgumentException(int segment)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(
-                new PointF[2] { new PointF(1f, 1f), new PointF(2f, 2f) }, 0, segment, 0.5f));
-
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(
-                new Point[2] { new Point(1, 1), new Point(2, 2) }, 0, segment, 0.5f));
-        }
-    }
-
-    [Fact]
-    public void AddCurve_OffsetTooLarge_ThrowsArgumentException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(
-                new PointF[3] { new PointF(1f, 1f), new PointF(0f, 20f), new PointF(20f, 0f) }, 1, 2, 0.5f));
-
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddCurve(
-                new Point[3] { new Point(1, 1), new Point(0, 20), new Point(20, 0) }, 1, 2, 0.5f));
-        }
-    }
-
-    [Fact]
-    public void AddClosedCurve_Points_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddClosedCurve(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            // AssertClosedCurve() method expects added ClosedCurve with points (1, 1), (2, 2), (3, 3), here and below.
-            AssertClosedCurve(gpi);
-
-            gpf.AddClosedCurve(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            AssertClosedCurve(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddClosedCurve_SamePoints_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddClosedCurve(new Point[3] { new Point(1, 1), new Point(1, 1), new Point(1, 1) });
-            Assert.Equal(10, gpi.PointCount);
-            gpi.AddClosedCurve(new Point[3] { new Point(1, 1), new Point(1, 1), new Point(1, 1) });
-            Assert.Equal(20, gpi.PointCount);
-
-            gpf.AddClosedCurve(new PointF[3] { new PointF(1, 1), new PointF(1, 1), new PointF(1, 1) });
-            Assert.Equal(10, gpf.PointCount);
-            gpf.AddClosedCurve(new PointF[3] { new PointF(1, 1), new PointF(1, 1), new PointF(1, 1) });
-            Assert.Equal(20, gpf.PointCount);
-        }
-    }
-
-    [Fact]
-    public void AddClosedCurve_Tension_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddClosedCurve(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) }, 0.5f);
-            AssertClosedCurve(gpi);
-
-            gpf.AddClosedCurve(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) }, 0.5f);
-            AssertClosedCurve(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddClosedCurve_PointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddClosedCurve((PointF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => gp.AddClosedCurve((Point[])null));
-        }
-    }
-
-    public static IEnumerable<object[]> AddClosedCurve_InvalidPointsLength_TestData()
-    {
-        yield return new object[] { new Point[0] };
-        yield return new object[] { new Point[1] { new Point(1, 1) } };
-        yield return new object[] { new Point[2] { new Point(1, 1), new Point(2, 2) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddCurve_InvalidPointsLength_TestData))]
-    public void AddClosedCurve_InvalidPointsLength_ThrowsArgumentException(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddClosedCurve(points));
-        }
-    }
-
-    public static IEnumerable<object[]> AddClosedCurve_InvalidFloatPointsLength_TestData()
-    {
-        yield return new object[] { new PointF[0] };
-        yield return new object[] { new PointF[1] { new PointF(1f, 1f) } };
-        yield return new object[] { new PointF[2] { new PointF(1f, 1f), new PointF(2f, 2f) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddClosedCurve_InvalidFloatPointsLength_TestData))]
-    public void AddClosedCurve_InvalidFloatPointsLength_ThrowsArgumentException(PointF[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddClosedCurve(points));
-        }
-    }
-
-    [Fact]
-    public void AddRectangle_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddRectangle(new Rectangle(1, 1, 2, 2));
-            // AssertRectangle() method expects added Rectangle with parameters x=1, y=1, width=2, height=2, here and below.
-            AssertRectangle(gpi);
-
-            gpf.AddRectangle(new RectangleF(1, 1, 2, 2));
-            AssertRectangle(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddRectangle_SameRectangles_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddRectangle(new Rectangle(1, 1, 1, 1));
-            Assert.Equal(4, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 129 }, gpi.PathTypes);
-
-            PointF endI = gpi.PathPoints[3];
-
-            gpi.AddRectangle(new Rectangle((int)endI.X, (int)endI.Y, 1, 1));
-            Assert.Equal(8, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 129, 0, 1, 1, 129 }, gpi.PathTypes);
-
-            gpf.AddRectangle(new RectangleF(1, 1, 1, 1));
-            Assert.Equal(4, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 129 }, gpf.PathTypes);
-            Assert.Equal(129, gpf.PathTypes[3]);
-
-            PointF endF = gpf.PathPoints[3];
-
-            gpf.AddRectangle(new RectangleF(endF.X, endF.Y, 1, 1));
-            Assert.Equal(8, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 1, 129, 0, 1, 1, 129 }, gpf.PathTypes);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(3, 0)]
-    [InlineData(0, 4)]
-    public void AddRectangle_ZeroWidthHeight_Success(int width, int height)
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddRectangle(new Rectangle(1, 2, width, height));
-            Assert.Equal(0, gpi.PathData.Points.Length);
-
-            gpf.AddRectangle(new RectangleF(1f, 2f, (float)width, (float)height));
-            Assert.Equal(0, gpf.PathData.Points.Length);
-        }
-    }
-
-    [Fact]
-    public void AddRectangles_Success()
-    {
-        Rectangle[] rectInt = new Rectangle[] { new Rectangle(1, 1, 2, 2), new Rectangle(3, 3, 4, 4) };
-        RectangleF[] rectFloat = new RectangleF[] { new RectangleF(1, 1, 2, 2), new RectangleF(3, 3, 4, 4) };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddRectangles(rectInt);
-            Assert.Equal(8, gpi.PathPoints.Length);
-            Assert.Equal(8, gpi.PathTypes.Length);
-            Assert.Equal(8, gpi.PathData.Points.Length);
-
-            gpf.AddRectangles(rectFloat);
-            Assert.Equal(8, gpf.PathPoints.Length);
-            Assert.Equal(8, gpf.PathTypes.Length);
-            Assert.Equal(8, gpf.PathData.Points.Length);
-        }
-    }
-
-    [Fact]
-    public void AddRectangles_SamePoints_Success()
-    {
-        Rectangle[] rectInt = new Rectangle[]
-        {
-            new Rectangle(1, 1, 0, 0),
-            new Rectangle(1, 1, 2, 2),
-            new Rectangle(1, 1, 2, 2)
-        };
-
-        RectangleF[] rectFloat = new RectangleF[]
-        {
-            new RectangleF(1, 1, 0f, 0f),
-            new RectangleF(1, 1, 2, 2),
-            new RectangleF(1, 1, 2, 2)
-        };
-
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddRectangles(rectInt);
-            Assert.Equal(8, gpi.PathPoints.Length);
-            Assert.Equal(8, gpi.PathTypes.Length);
-            Assert.Equal(8, gpi.PathData.Points.Length);
-
-            gpf.AddRectangles(rectFloat);
-            Assert.Equal(8, gpf.PathPoints.Length);
-            Assert.Equal(8, gpf.PathTypes.Length);
-            Assert.Equal(8, gpf.PathData.Points.Length);
-        }
-    }
-
-    [Fact]
-    public void AddRectangles_RectangleNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("rects", () => gp.AddRectangles((RectangleF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("rects", () => gp.AddRectangles((Rectangle[])null));
-        }
-    }
-
-    [Fact]
-    public void AddEllipse_Rectangle_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddEllipse(new Rectangle(1, 1, 2, 2));
-            // AssertEllipse() method expects added Ellipse with parameters x=1, y=1, width=2, height=2, here and below.
-            AssertEllipse(gpi);
-
-            gpf.AddEllipse(new RectangleF(1, 1, 2, 2));
-            AssertEllipse(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddEllipse_Values_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddEllipse(1, 1, 2, 2);
-            AssertEllipse(gpi);
-
-            gpf.AddEllipse(1f, 1f, 2f, 2f);
-            AssertEllipse(gpf);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(2, 0)]
-    [InlineData(0, 2)]
-    public void AddEllipse_ZeroWidthHeight_Success(int width, int height)
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddEllipse(1, 1, width, height);
-            Assert.Equal(13, gpi.PathData.Points.Length);
-
-            gpf.AddEllipse(1f, 2f, (float)width, (float)height);
-            Assert.Equal(13, gpf.PathData.Points.Length);
-        }
-    }
-
-    [Fact]
-    public void AddPie_Rectangle_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        {
-            gpi.AddPie(new Rectangle(1, 1, 2, 2), Pi4, Pi4);
-            // AssertPie() method expects added Pie with parameters
-            // x=1, y=1, width=2, height=2, startAngle=Pi4, seewpAngle=Pi4 here and below.
-            AssertPie(gpi);
-        }
-    }
-
-    [Fact]
-    public void AddPie_Values_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddPie(1, 1, 2, 2, Pi4, Pi4);
-            AssertPie(gpi);
-
-            gpf.AddPie(1f, 1f, 2f, 2f, Pi4, Pi4);
-            AssertPie(gpf);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(2, 0)]
-    [InlineData(0, 2)]
-    public void AddPie_ZeroWidthHeight_ThrowsArgumentException(int width, int height)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddPie(1, 1, height, width, Pi4, Pi4));
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddPie(1f, 1f, height, width, Pi4, Pi4));
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddPie(new Rectangle(1, 1, height, width), Pi4, Pi4));
-        }
-    }
-
-    [Fact]
-    public void AddPolygon_Points_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            // AssertPolygon() method expects added Polygon with points (1, 1), (2, 2), (3, 3), here and below.
-            AssertPolygon(gpi);
-
-            gpf.AddPolygon(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            AssertPolygon(gpf);
-        }
-    }
-
-    [Fact]
-    public void AddPolygon_SamePoints_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            Assert.Equal(3, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129 }, gpi.PathTypes);
-
-            gpi.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            Assert.Equal(6, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129 }, gpi.PathTypes);
-
-            gpi.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            Assert.Equal(9, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129, 0, 1, 129 }, gpi.PathTypes);
-
-            gpi.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            Assert.Equal(12, gpi.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129, 0, 1, 129, 0, 1, 129 }, gpi.PathTypes);
-
-            gpf.AddPolygon(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            Assert.Equal(3, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129 }, gpf.PathTypes);
-
-            gpf.AddPolygon(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            Assert.Equal(6, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129 }, gpf.PathTypes);
-
-            gpf.AddPolygon(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            Assert.Equal(9, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129, 0, 1, 129 }, gpf.PathTypes);
-
-            gpf.AddPolygon(new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) });
-            Assert.Equal(12, gpf.PointCount);
-            Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 129, 0, 1, 129, 0, 1, 129 }, gpf.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void AddPolygon_PointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => new GraphicsPath().AddPolygon((Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => new GraphicsPath().AddPolygon((PointF[])null));
-        }
-    }
-
-    public static IEnumerable<object[]> AddPolygon_InvalidFloadPointsLength_TestData()
-    {
-        yield return new object[] { new PointF[0] };
-        yield return new object[] { new PointF[1] { new PointF(1f, 1f) } };
-        yield return new object[] { new PointF[2] { new PointF(1f, 1f), new PointF(2f, 2f) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddPolygon_InvalidFloadPointsLength_TestData))]
-    public void AddPolygon_InvalidFloadPointsLength_ThrowsArgumentException(PointF[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddPolygon(points));
-        }
-    }
-
-    public static IEnumerable<object[]> AddPolygon_InvalidPointsLength_TestData()
-    {
-        yield return new object[] { new Point[0] };
-        yield return new object[] { new Point[1] { new Point(1, 1) } };
-        yield return new object[] { new Point[2] { new Point(1, 1), new Point(2, 2) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddPolygon_InvalidPointsLength_TestData))]
-    public void AddPolygon_InvalidPointsLength_ThrowsArgumentException(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => gp.AddPolygon(points));
-        }
-    }
-
-    [Fact]
-    public void AddPath_Success()
-    {
-        using (GraphicsPath inner = new GraphicsPath())
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            inner.AddRectangle(new Rectangle(1, 1, 2, 2));
-            gp.AddPath(inner, true);
-            AssertRectangle(gp);
-        }
-    }
-
-    [Fact]
-    public void AddPath_PathNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("addingPath", () => new GraphicsPath().AddPath(null, false));
-        }
-    }
-
-    [Fact]
-    public void AddString_Point_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddString("mono", FontFamily.GenericMonospace, 0, 10, new Point(10, 10), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpi.PointCount, 0);
-
-            gpf.AddString("mono", FontFamily.GenericMonospace, 0, 10, new PointF(10f, 10f), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpf.PointCount, 0);
-        }
-    }
-
-    [Fact]
-    public void AddString_Rectangle_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddString("mono", FontFamily.GenericMonospace, 0, 10, new Rectangle(10, 10, 10, 10), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpi.PointCount, 0);
-
-            gpf.AddString("mono", FontFamily.GenericMonospace, 0, 10, new RectangleF(10f, 10f, 10f, 10f), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpf.PointCount, 0);
-        }
-    }
-
-    [Fact]
-    public void AddString_NegativeSize_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddString("mono", FontFamily.GenericMonospace, 0, -10, new Point(10, 10), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpi.PointCount, 0);
-
-            int gpiLengthOld = gpi.PathPoints.Length;
-            gpi.AddString("mono", FontFamily.GenericMonospace, 0, -10, new Rectangle(10, 10, 10, 10), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpi.PointCount, gpiLengthOld);
-
-            gpf.AddString("mono", FontFamily.GenericMonospace, 0, -10, new PointF(10f, 10f), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpf.PointCount, 0);
-
-            int pgfLengthOld = gpf.PathPoints.Length;
-            gpf.AddString("mono", FontFamily.GenericMonospace, 0, -10, new RectangleF(10f, 10f, 10f, 10f), StringFormat.GenericDefault);
-            AssertExtensions.GreaterThan(gpf.PointCount, pgfLengthOld);
-        }
-    }
-
-    [Fact]
-    public void AddString_StringFormat_Success()
-    {
-        using (GraphicsPath gp1 = new GraphicsPath())
-        using (GraphicsPath gp2 = new GraphicsPath())
-        using (GraphicsPath gp3 = new GraphicsPath())
-        {
-            gp1.AddString("mono", FontFamily.GenericMonospace, 0, 10, new RectangleF(10f, 10f, 10f, 10f), null);
-            AssertExtensions.GreaterThan(gp1.PointCount, 0);
-
-            gp2.AddString("mono", FontFamily.GenericMonospace, 0, 10, new RectangleF(10f, 10f, 10f, 10f), StringFormat.GenericDefault);
-            Assert.Equal(gp1.PointCount, gp2.PointCount);
-
-            gp3.AddString("mono", FontFamily.GenericMonospace, 0, 10, new RectangleF(10f, 10f, 10f, 10f), StringFormat.GenericTypographic);
-            Assert.NotEqual(gp1.PointCount, gp3.PointCount);
-        }
-    }
-
-    [Fact]
-    public void AddString_EmptyString_Success()
-    {
-        using (GraphicsPath gpi = new GraphicsPath())
-        using (GraphicsPath gpf = new GraphicsPath())
-        {
-            gpi.AddString(string.Empty, FontFamily.GenericMonospace, 0, 10, new Point(10, 10), StringFormat.GenericDefault);
-            Assert.Equal(0, gpi.PointCount);
-
-            gpi.AddString(string.Empty, FontFamily.GenericMonospace, 0, 10, new PointF(10f, 10f), StringFormat.GenericDefault);
-            Assert.Equal(0, gpf.PointCount);
-        }
-    }
-
-    [Fact]
-    public void AddString_StringNull_ThrowsNullReferenceException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Throws<NullReferenceException>(() =>
-                gp.AddString(null, FontFamily.GenericMonospace, 0, 10, new Point(10, 10), StringFormat.GenericDefault));
-            Assert.Throws<NullReferenceException>(() =>
-                gp.AddString(null, FontFamily.GenericMonospace, 0, 10, new PointF(10f, 10f), StringFormat.GenericDefault));
-            Assert.Throws<NullReferenceException>(() =>
-                gp.AddString(null, FontFamily.GenericMonospace, 0, 10, new Rectangle(10, 10, 10, 10), StringFormat.GenericDefault));
-            Assert.Throws<NullReferenceException>(() =>
-                gp.AddString(null, FontFamily.GenericMonospace, 0, 10, new RectangleF(10f, 10f, 10f, 10f), StringFormat.GenericDefault));
-        }
-    }
-
-    [Fact]
-    public void AddString_FontFamilyNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException, ArgumentException>("family", null, () =>
-                new GraphicsPath().AddString("mono", null, 0, 10, new Point(10, 10), StringFormat.GenericDefault));
-        }
-    }
-
-    [Fact]
-    public void Transform_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix(1f, 1f, 2f, 2f, 3f, 3f))
-        {
-            gp.AddRectangle(new Rectangle(1, 1, 2, 2));
-            AssertRectangle(gp);
-            gp.Transform(matrix);
-            Assert.Equal(new float[] { 1f, 1f, 2f, 2f, 3f, 3f }, matrix.Elements);
-            Assert.Equal(new RectangleF(6f, 6f, 6f, 6f), gp.GetBounds());
-            Assert.Equal(new PointF[] { new PointF(6f, 6f), new PointF(8f, 8f), new PointF(12f, 12f), new PointF(10f, 10f) }, gp.PathPoints);
-            Assert.Equal(new byte[] { 0, 1, 1, 129 }, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Transform_PathEmpty_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix(1f, 1f, 2f, 2f, 3f, 3f))
-        {
-            gp.Transform(matrix);
-            Assert.Equal(new float[] { 1f, 1f, 2f, 2f, 3f, 3f }, matrix.Elements);
-            AssertEmptyGraphicsPath(gp);
-        }
-    }
-
-    [Fact]
-    public void Transform_MatrixNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => gp.Transform(null));
-        }
-    }
-
-    [Fact]
-    public void GetBounds_PathEmpty_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Assert.Equal(new RectangleF(0f, 0f, 0f, 0f), gp.GetBounds());
-        }
-    }
-
-    [Fact]
-    public void GetBounds_Rectangle_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix())
-        {
-            RectangleF rectangle = new RectangleF(1f, 1f, 2f, 2f);
-            gp.AddRectangle(rectangle);
-            Assert.Equal(rectangle, gp.GetBounds());
-            Assert.Equal(rectangle, gp.GetBounds(null));
-            Assert.Equal(rectangle, gp.GetBounds(matrix));
-            Assert.Equal(rectangle, gp.GetBounds(null, null));
-        }
-    }
-
-    [Fact]
-    public void GetBounds_Pie_ReturnsExpected()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix())
-        {
-            Rectangle rectangle = new Rectangle(10, 10, 100, 100);
-            gp.AddPie(rectangle, 30, 45);
-            AssertRectangleEqual(new RectangleF(60f, 60f, 43.3f, 48.3f), gp.GetBounds(), 0.1f);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Empty_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.Flatten();
-            Assert.Equal(gp.PointCount, clone.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Flatten_MatrixNull_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.Flatten(null);
-            Assert.Equal(gp.PointCount, clone.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Flatten_MatrixNullFloat_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.Flatten(null, 1f);
-            Assert.Equal(gp.PointCount, clone.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Arc_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddArc(0f, 0f, 100f, 100f, 30, 30);
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Bezier_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddBezier(0, 0, 100, 100, 30, 30, 60, 60);
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_ClosedCurve_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddClosedCurve(new Point[4]
-            {
-                new Point (0, 0), new Point (40, 20),
-                new Point (20, 40), new Point (40, 40)
-            });
-
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Curve_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddCurve(new Point[4]
-            {
-                new Point (0, 0), new Point (40, 20),
-                new Point (20, 40), new Point (40, 40)
-            });
-
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Ellipse_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddEllipse(10f, 10f, 100f, 100f);
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Line_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddLine(10f, 10f, 100f, 100f);
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Pie_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddPie(0, 0, 100, 100, 30, 30);
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Polygon_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddPolygon(new Point[4]
-            {
-                new Point (0, 0), new Point (10, 10),
-                new Point (20, 20), new Point (40, 40)
-            });
-
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Flatten_Rectangle_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath clone = Assert.IsType<GraphicsPath>(gp.Clone()))
-        {
-            gp.AddRectangle(new Rectangle(0, 0, 100, 100));
-            gp.Flatten();
-            AssertFlats(gp, clone);
-        }
-    }
-
-    [Fact]
-    public void Warp_DestinationPointsNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("destPoints", () => gp.Warp(null, new RectangleF()));
-        }
-    }
-
-    [Fact]
-    public void Warp_DestinationPointsZero_ThrowsArgumentException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new GraphicsPath().Warp(new PointF[0], new RectangleF()));
-        }
-    }
-
-    [Fact]
-    public void Warp_PathEmpty_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix())
-        {
-            Assert.Equal(0, gp.PointCount);
-            gp.Warp(new PointF[1] { new PointF(0, 0) }, new RectangleF(10, 20, 30, 40), matrix);
-            Assert.Equal(0, gp.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Warp_WarpModeInvalid_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Matrix matrix = new Matrix())
-        {
-            gp.AddPolygon(new Point[3] { new Point(5, 5), new Point(15, 5), new Point(10, 15) });
-            gp.Warp(new PointF[1] { new PointF(0, 0) }, new RectangleF(10, 20, 30, 40), matrix, (WarpMode)int.MinValue);
-            Assert.Equal(0, gp.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Warp_RectangleEmpty_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddPolygon(new Point[3] { new Point(5, 5), new Point(15, 5), new Point(10, 15) });
-            gp.Warp(new PointF[1] { new PointF(0, 0) }, new Rectangle(), null);
-            AssertWrapNaN(gp);
-        }
-    }
-
-
-    [Fact]
-    public void SetMarkers_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.SetMarkers();
-        }
-    }
-
-    [Fact]
-    public void SetMarkers_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(new Point(1, 1), new Point(2, 2));
-            Assert.Equal(1, gp.PathTypes[1]);
-
-            gp.SetMarkers();
-            Assert.Equal(33, gp.PathTypes[1]);
-        }
-    }
-
-    [Fact]
-    public void ClearMarkers_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(new Point(1, 1), new Point(2, 2));
-            Assert.Equal(1, gp.PathTypes[1]);
-
-            gp.SetMarkers();
-            Assert.Equal(33, gp.PathTypes[1]);
-
-            gp.ClearMarkers();
-            Assert.Equal(1, gp.PathTypes[1]);
-        }
-    }
-
-    [Fact]
-    public void ClearMarkers_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.ClearMarkers();
-        }
-    }
-
-    [Fact]
-    public void CloseFigure_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(new Point(1, 1), new Point(2, 2));
-            Assert.Equal(1, gp.PathTypes[1]);
-
-            gp.CloseFigure();
-            Assert.Equal(129, gp.PathTypes[1]);
-        }
-    }
-
-    [Fact]
-    public void CloseFigure_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.CloseFigure();
-        }
-    }
-
-    [Fact]
-    public void CloseAllFigures_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(new Point(1, 1), new Point(2, 2));
-            gp.StartFigure();
-            gp.AddLine(new Point(3, 3), new Point(4, 4));
-            Assert.Equal(1, gp.PathTypes[1]);
-            Assert.Equal(1, gp.PathTypes[3]);
-
-            gp.CloseAllFigures();
-            Assert.Equal(129, gp.PathTypes[1]);
-            Assert.Equal(129, gp.PathTypes[3]);
-        }
-    }
-
-    [Fact]
-    public void CloseAllFigures_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.CloseAllFigures();
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddArc()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddArc(10, 10, 100, 100, 90, 180);
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(3, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddBezier()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddBezier(10, 10, 100, 100, 20, 20, 200, 200);
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(3, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddBeziers()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddBeziers(new Point[7]
-            {
-                new Point (10, 10), new Point (20, 10), new Point (20, 20),
-                new Point (30, 20), new Point (40, 40), new Point (50, 40),
-                new Point (50, 50)
-            });
-
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(3, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddClosedCurve()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddClosedCurve(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(131, types[gp.PointCount - 3]);
-            Assert.Equal(0, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddCurve()
-    {
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            path.AddLine(1, 1, 2, 2);
-            path.AddCurve(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            path.AddLine(10, 10, 20, 20);
-            byte[] types = path.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(3, types[path.PointCount - 3]);
-            Assert.Equal(1, types[path.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddEllipse()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddEllipse(10, 10, 100, 100);
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(131, types[gp.PointCount - 3]);
-            Assert.Equal(0, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddLine()
-    {
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            path.AddLine(1, 1, 2, 2);
-            path.AddLine(5, 5, 10, 10);
-            path.AddLine(10, 10, 20, 20);
-            byte[] types = path.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(1, types[path.PointCount - 3]);
-            Assert.Equal(1, types[path.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddLines()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddLines(new Point[4] { new Point(10, 10), new Point(20, 10), new Point(20, 20), new Point(30, 20) });
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(1, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddPath_Connect()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (GraphicsPath inner = new GraphicsPath())
-        {
-            inner.AddArc(10, 10, 100, 100, 90, 180);
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddPath(inner, true);
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(1, types[2]);
-            Assert.Equal(3, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddPath_NoConnect()
-    {
-        using (GraphicsPath inner = new GraphicsPath())
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            inner.AddArc(10, 10, 100, 100, 90, 180);
-            path.AddLine(1, 1, 2, 2);
-            path.AddPath(inner, false);
-            path.AddLine(10, 10, 20, 20);
-            byte[] types = path.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(3, types[path.PointCount - 3]);
-            Assert.Equal(1, types[path.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddPie()
-    {
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            path.AddLine(1, 1, 2, 2);
-            path.AddPie(10, 10, 10, 10, 90, 180);
-            path.AddLine(10, 10, 20, 20);
-            byte[] types = path.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-
-            Assert.Equal(128, (types[path.PointCount - 3] & 128));
-            Assert.Equal(0, types[path.PointCount - 2]);
-            Assert.Equal(1, types[path.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddPolygon()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddPolygon(new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) });
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(129, types[gp.PointCount - 3]);
-            Assert.Equal(0, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddRectangle()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddRectangle(new RectangleF(10, 10, 20, 20));
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(129, types[gp.PointCount - 3]);
-            Assert.Equal(0, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddRectangles()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddRectangles(new RectangleF[2]
-            {
-            new RectangleF (10, 10, 20, 20),
-            new RectangleF (20, 20, 10, 10)
-            });
-
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(129, types[gp.PointCount - 3]);
-            Assert.Equal(0, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void StartClose_AddString()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 1, 2, 2);
-            gp.AddString("mono", FontFamily.GenericMonospace, 0, 10, new Point(20, 20), StringFormat.GenericDefault);
-            gp.AddLine(10, 10, 20, 20);
-            byte[] types = gp.PathTypes;
-
-            Assert.Equal(0, types[0]);
-            Assert.Equal(0, types[2]);
-            Assert.Equal(163, types[gp.PointCount - 3]);
-            Assert.Equal(1, types[gp.PointCount - 2]);
-            Assert.Equal(1, types[gp.PointCount - 1]);
-        }
-    }
-
-    [Fact]
-    public void Widen_Pen_Success()
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(0.5f, 0.5f), new PointF(3.5f, 0.5f), new PointF(3.5f, 3.5f),
-            new PointF(0.5f, 3.5f), new PointF(1.5f, 3.0f), new PointF(1.0f, 2.5f),
-            new PointF(3.0f, 2.5f), new PointF(2.5f, 3.0f), new PointF(2.5f, 1.0f),
-            new PointF(3.0f, 1.5f), new PointF(1.0f, 1.5f), new PointF(1.5f, 1.0f),
-        };
-
-        byte[] expectedTypes = new byte[] { 0, 1, 1, 129, 0, 1, 1, 1, 1, 1, 1, 129 };
-
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Blue))
-        {
-            gp.AddRectangle(new Rectangle(1, 1, 2, 2));
-            Assert.Equal(4, gp.PointCount);
-            gp.Widen(pen);
-            Assert.Equal(12, gp.PointCount);
-            AssertPointsSequenceEqual(expectedPoints, gp.PathPoints, Delta);
-            Assert.Equal(expectedTypes, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Widen_EmptyPath_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Blue))
-        {
-            Assert.Equal(0, gp.PointCount);
-            gp.Widen(pen);
-            Assert.Equal(0, gp.PointCount);
-        }
-    }
-
-    [Fact]
-    public void Widen_PenNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.Widen(null));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.Widen(null, new Matrix()));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.Widen(null, new Matrix(), 0.67f));
-        }
-    }
-
-    [Fact]
-    public void Widen_MatrixNull_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Blue))
-        {
-            gp.AddPolygon(new Point[3] { new Point(5, 5), new Point(15, 5), new Point(10, 15) });
-            gp.Widen(pen, null);
-            Assert.Equal(9, gp.PointCount);
-            AssertWiden3(gp);
-        }
-    }
-
-    [Fact]
-    public void Widen_MatrixEmpty_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Blue))
-        using (Matrix matrix = new Matrix())
-        {
-            gp.AddPolygon(new Point[3] { new Point(5, 5), new Point(15, 5), new Point(10, 15) });
-            gp.Widen(pen, new Matrix());
-            Assert.Equal(9, gp.PointCount);
-            AssertWiden3(gp);
-        }
-
-    }
-
-    public static IEnumerable<object[]> Widen_PenSmallWidth_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 1, 2, 2), 0f, new RectangleF(0.5f, 0.5f, 3.0f, 3.0f) };
-        yield return new object[] { new Rectangle(1, 1, 2, 2), 0.5f, new RectangleF(0.5f, 0.5f, 3.0f, 3.0f) };
-        yield return new object[] { new Rectangle(1, 1, 2, 2), 1.0f, new RectangleF(0.5f, 0.5f, 3.0f, 3.0f) };
-        yield return new object[] { new Rectangle(1, 1, 2, 2), 1.1f, new RectangleF(0.45f, 0.45f, 3.10f, 3.10f) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Widen_PenSmallWidth_TestData))]
-    public void Widen_Pen_SmallWidth_Success(
-        Rectangle rectangle, float penWidth, RectangleF expectedBounds)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Aqua, 0))
-        using (Matrix matrix = new Matrix())
-        {
-            pen.Width = penWidth;
-            gp.AddRectangle(rectangle);
-            gp.Widen(pen);
-            AssertRectangleEqual(expectedBounds, gp.GetBounds(null), Delta);
-            AssertRectangleEqual(expectedBounds, gp.GetBounds(matrix), Delta);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_PenNull_ThrowsArgumentNullException()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.IsOutlineVisible(1, 1, null));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.IsOutlineVisible(1.0f, 1.0f, null));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.IsOutlineVisible(new Point(), null));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => gp.IsOutlineVisible(new PointF(), null));
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineWithoutGraphics_ReturnsExpected()
-    {
-        AssertIsOutlineVisibleLine(null);
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineInsideGraphics_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            AssertIsOutlineVisibleLine(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineOutsideGraphics_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(5, 5))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            AssertIsOutlineVisibleLine(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineWithGraphicsTransform_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        using (Matrix matrix = new Matrix(2, 0, 0, 2, 50, -50))
-        {
-            graphics.Transform = matrix;
-            AssertIsOutlineVisibleLine(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineWithGraphicsPageUnit_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            graphics.PageUnit = GraphicsUnit.Millimeter;
-            AssertIsOutlineVisibleLine(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_LineWithGraphicsPageScale_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            graphics.PageScale = 2.0f;
-            AssertIsOutlineVisibleLine(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsOutlineVisible_RectangleWithoutGraphics_ReturnsExpected()
-    {
-        AssertIsOutlineVisibleRectangle(null);
-    }
-
-    [Fact]
-    public void IsVisible_RectangleWithoutGraphics_ReturnsExpected()
-    {
-        AssertIsVisibleRectangle(null);
-    }
-
-    [Fact]
-    public void IsVisible_RectangleWithGraphics_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(40, 40))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            AssertIsVisibleRectangle(graphics);
-        }
-    }
-
-    [Fact]
-    public void IsVisible_EllipseWithoutGraphics_ReturnsExpected()
-    {
-        AssertIsVisibleEllipse(null);
-    }
-
-    [Fact]
-    public void IsVisible_EllipseWithGraphics_ReturnsExpected()
-    {
-        using (Bitmap bitmap = new Bitmap(40, 40))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            AssertIsVisibleEllipse(graphics);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Arc_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddArc(1f, 1f, 2f, 2f, Pi4, Pi4);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Bezier_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddBezier(1, 2, 3, 4, 5, 6, 7, 8);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    public static IEnumerable<object[]> Reverse_TestData()
-    {
-        yield return new object[]
-        {
-            new Point[]
-            {
-                new Point (1,2), new Point (3,4), new Point (5,6), new Point (7,8),
-                new Point (9,10), new Point (11,12), new Point (13,14)
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Reverse_TestData))]
-    public void Reverse_Beziers_Success(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddBeziers(points);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Reverse_TestData))]
-    public void Reverse_ClosedCurve_Success(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddClosedCurve(points);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Reverse_TestData))]
-    public void Reverse_Curve_Success(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddCurve(points);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Ellipse_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddEllipse(1, 2, 3, 4);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Line_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 2, 3, 4);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_LineClosed_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(1, 2, 3, 4);
-            gp.CloseFigure();
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Reverse_TestData))]
-    public void Reverse_Lines_Success(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLines(points);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Reverse_TestData))]
-    public void Reverse_Polygon_Success(Point[] points)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddPolygon(points);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Rectangle_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(1, 2, 3, 4));
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Rectangles_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            Rectangle[] rects = new Rectangle[] { new Rectangle(1, 2, 3, 4), new Rectangle(5, 6, 7, 8) };
-            gp.AddRectangles(rects);
-            AssertReverse(gp, gp.PathPoints, gp.PathTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Pie_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddPie(1, 2, 3, 4, 10, 20);
-            byte[] expectedTypes = new byte[] { 0, 3, 3, 3, 129 };
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_ArcLineInnerPath_Success()
-    {
-        using (GraphicsPath inner = new GraphicsPath())
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            inner.AddArc(1f, 1f, 2f, 2f, Pi4, Pi4);
-            inner.AddLine(1, 2, 3, 4);
-            byte[] expectedTypes = new byte[] { 0, 1, 1, 3, 3, 3 };
-            gp.AddPath(inner, true);
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_EllipseRectangle_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddEllipse(50, 51, 50, 100);
-            gp.AddRectangle(new Rectangle(200, 201, 60, 61));
-            byte[] expectedTypes = new byte[] { 0, 1, 1, 129, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 131 };
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_String_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddString("Mono::", FontFamily.GenericMonospace, 0, 10, new Point(10, 10), StringFormat.GenericDefault);
-            byte[] expectedTypes = new byte[]
-            {
-                0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,129,
-                0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,161,
-                0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,129,
-                0,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,161,
-                0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,131,0,3,
-                3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,163,0,3,3,3,
-                3,3,3,3,3,3,3,3,3,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,3,
-                3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,
-                3,3,3,3,3,3,3,3,3,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,3,3,3,3,
-                3,3,3,3,3,3,3,3,3,3,3,161,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
-                3,3,3,3,3,3,3,3,3,131,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
-                3,3,3,3,3,3,3,163,0,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,3,3,
-                3,3,3,3,3,3,3,3,3,3,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,
-                1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,
-                1,3,3,3,3,3,3,3,3,3,3,3,3,1,1,1,1,129
-            };
-
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_Marker_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(200, 201, 60, 61));
-            gp.SetMarkers();
-            byte[] expectedTypes = new byte[] { 0, 1, 1, 129 };
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Reverse_SubpathMarker_Success()
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(0, 1, 2, 3);
-            gp.SetMarkers();
-            gp.CloseFigure();
-            gp.AddBezier(5, 6, 7, 8, 9, 10, 11, 12);
-            gp.CloseFigure();
-            byte[] expectedTypes = new byte[] { 0, 3, 3, 163, 0, 129 };
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddLine(0, 1, 2, 3);
-            gp.SetMarkers();
-            gp.StartFigure();
-            gp.AddLine(20, 21, 22, 23);
-            gp.AddBezier(5, 6, 7, 8, 9, 10, 11, 12);
-            byte[] expectedTypes = new byte[] { 0, 3, 3, 3, 1, 33, 0, 1 };
-            AssertReverse(gp, gp.PathPoints, expectedTypes);
-        }
-    }
-
-    [Fact]
-    public void Ctor_PointsTypes_Success()
-    {
-        int dX = 520;
-        int dY = 320;
-        Point[] expectedPoints = new Point[]
-        {
-            new Point(dX-64, dY-24), new Point(dX-59, dY-34), new Point(dX-52, dY-54),
-            new Point(dX-18, dY-66), new Point(dX-34, dY-47), new Point(dX-43, dY-27),
-            new Point(dX-44, dY-8),
-        };
-
-        byte[] expectedTypes = new byte[]
-        {
-            (byte)PathPointType.Start, (byte)PathPointType.Bezier, (byte)PathPointType.Bezier,
-            (byte)PathPointType.Bezier, (byte)PathPointType.Bezier, (byte)PathPointType.Bezier,
-            (byte)PathPointType.Bezier
-        };
-
-        using (GraphicsPath path = new GraphicsPath(expectedPoints, expectedTypes))
-        {
-            Assert.Equal(7, path.PointCount);
-            byte[] actualTypes = path.PathTypes;
-            Assert.Equal(expectedTypes, actualTypes);
-        }
-    }
-
-    private void AssertEmptyGraphicsPath(GraphicsPath gp)
-    {
-        Assert.Equal(0, gp.PathData.Points.Length);
-        Assert.Equal(0, gp.PathData.Types.Length);
-        Assert.Equal(0, gp.PointCount);
-    }
-
-    private void AssertEqual(float expexted, float actual, float tollerance)
-    {
-        AssertExtensions.LessThanOrEqualTo(Math.Abs(expexted - actual), tollerance);
-    }
-
-    private void AssertLine(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(1f, 1f), new PointF(2f, 2f)
-        };
-
-        Assert.Equal(2, path.PathPoints.Length);
-        Assert.Equal(2, path.PathTypes.Length);
-        Assert.Equal(2, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 1f, 1f), path.GetBounds(), variance: 0.000001f);
-        Assert.Equal(expectedPoints, path.PathPoints);
-        Assert.Equal(new byte[] { 0, 1 }, path.PathTypes);
-    }
-
-    private void AssertArc(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(2.99990582f, 2.01370716f), new PointF(2.99984312f, 2.018276f),
-            new PointF(2.99974918f, 2.02284455f), new PointF(2.999624f, 2.027412f),
-        };
-
-        Assert.Equal(4, path.PathPoints.Length);
-        Assert.Equal(4, path.PathTypes.Length);
-        Assert.Equal(4, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(2.99962401f, 2.01370716f, 0f, 0.0137047768f), path.GetBounds(), variance: Delta);
-        Assert.Equal(expectedPoints, path.PathPoints);
-        Assert.Equal(new byte[] { 0, 3, 3, 3 }, path.PathTypes);
-    }
-
-    private void AssertBezier(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(1f, 1f), new PointF(2f, 2f),
-            new PointF(3f, 3f), new PointF(4f, 4f),
-        };
-
-        Assert.Equal(4, path.PointCount);
-        Assert.Equal(4, path.PathPoints.Length);
-        Assert.Equal(4, path.PathTypes.Length);
-        Assert.Equal(4, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 3f, 3f), path.GetBounds(), Delta);
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, Delta);
-        Assert.Equal(new byte[] { 0, 3, 3, 3 }, path.PathTypes);
-    }
-
-    private void AssertCurve(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(1f, 1f), new PointF(1.16666663f, 1.16666663f),
-            new PointF(1.83333325f, 1.83333325f), new PointF(2f, 2f)
-        };
-
-        Assert.Equal(4, path.PathPoints.Length);
-        Assert.Equal(4, path.PathTypes.Length);
-        Assert.Equal(4, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 1f, 1f), path.GetBounds(), Delta);
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, Delta);
-        Assert.Equal(new byte[] { 0, 3, 3, 3 }, path.PathTypes);
-    }
-
-    private void AssertClosedCurve(GraphicsPath path)
-    {
-        Assert.Equal(10, path.PathPoints.Length);
-        Assert.Equal(10, path.PathTypes.Length);
-        Assert.Equal(10, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(0.8333333f, 0.8333333f, 2.33333278f, 2.33333278f), path.GetBounds(), Delta);
-        Assert.Equal(new byte[] { 0, 3, 3, 3, 3, 3, 3, 3, 3, 131 }, path.PathTypes);
-    }
-
-    private void AssertRectangle(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(1f, 1f), new PointF(3f, 1f),
-            new PointF(3f, 3f), new PointF(1f, 3f)
-        };
-
-        Assert.Equal(4, path.PathPoints.Length);
-        Assert.Equal(4, path.PathTypes.Length);
-        Assert.Equal(4, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 2f, 2f), path.GetBounds(), Delta);
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, Delta);
-        Assert.Equal(new byte[] { 0, 1, 1, 129 }, path.PathTypes);
-    }
-
-    private void AssertEllipse(GraphicsPath path)
-    {
-        Assert.Equal(13, path.PathPoints.Length);
-        Assert.Equal(13, path.PathTypes.Length);
-        Assert.Equal(13, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 2f, 2f), path.GetBounds(), Delta);
-        Assert.Equal(new byte[] { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 131 }, path.PathTypes);
-    }
-
-    private void AssertPie(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(2f, 2f), new PointF(2.99990582f, 2.01370716f),
-            new PointF(2.99984312f, 2.018276f), new PointF(2.99974918f, 2.02284455f),
-            new PointF(2.999624f, 2.027412f)
-        };
-
-        Assert.Equal(5, path.PathPoints.Length);
-        Assert.Equal(5, path.PathTypes.Length);
-        Assert.Equal(5, path.PathData.Points.Length);
-        AssertRectangleEqual(new RectangleF(2f, 2f, 0.9999058f, 0.0274119377f), path.GetBounds(), Delta);
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, Delta);
-        Assert.Equal(new byte[] { 0, 1, 3, 3, 131 }, path.PathTypes);
-    }
-
-    private void AssertPolygon(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(1f, 1f),
-            new PointF(2f, 2f),
-            new PointF(3f, 3f)
-        };
-
-        Assert.Equal(3, path.PathPoints.Length);
-        Assert.Equal(3, path.PathTypes.Length);
-        Assert.Equal(3, path.PathData.Points.Length);
-        AssertExtensions.Equal(new RectangleF(1f, 1f, 2f, 2f), path.GetBounds(), Delta);
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, Delta);
-        Assert.Equal(new byte[] { 0, 1, 129 }, path.PathTypes);
-    }
-
-    private void AssertFlats(GraphicsPath flat, GraphicsPath original)
-    {
-        AssertExtensions.GreaterThanOrEqualTo(flat.PointCount, original.PointCount);
-        for (int i = 0; i < flat.PointCount; i++)
-        {
-            Assert.NotEqual(3, flat.PathTypes[i]);
-        }
-    }
-
-    private void AssertWrapNaN(GraphicsPath path)
-    {
-        byte[] expectedTypes = new byte[] { 0, 1, 129 };
-
-        Assert.Equal(3, path.PointCount);
-        Assert.Equal(float.NaN, path.PathPoints[0].X);
-        Assert.Equal(float.NaN, path.PathPoints[0].Y);
-        Assert.Equal(float.NaN, path.PathPoints[1].X);
-        Assert.Equal(float.NaN, path.PathPoints[1].Y);
-        Assert.Equal(float.NaN, path.PathPoints[2].X);
-        Assert.Equal(float.NaN, path.PathPoints[2].Y);
-        Assert.Equal(expectedTypes, path.PathTypes);
-    }
-
-    private void AssertWiden3(GraphicsPath path)
-    {
-        PointF[] expectedPoints = new PointF[]
-        {
-            new PointF(4.2f, 4.5f), new PointF(15.8f, 4.5f),
-            new PointF(10.0f, 16.1f), new PointF(10.4f, 14.8f),
-            new PointF(9.6f, 14.8f), new PointF(14.6f, 4.8f),
-            new PointF(15.0f, 5.5f), new PointF(5.0f, 5.5f),
-            new PointF(5.4f, 4.8f)
-        };
-
-        AssertPointsSequenceEqual(expectedPoints, path.PathPoints, 0.25f);
-        Assert.Equal(new byte[] { 0, 1, 129, 0, 1, 1, 1, 1, 129 }, path.PathTypes);
-    }
-
-    private void AssertIsOutlineVisibleLine(Graphics graphics)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        using (Pen pen = new Pen(Color.Red, 3.0f))
-        {
-            gp.AddLine(10, 1, 14, 1);
-            Assert.True(gp.IsOutlineVisible(10, 1, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(10, 2, pen, graphics));
-            Assert.False(gp.IsOutlineVisible(10, 2, Pens.Red, graphics));
-
-            Assert.True(gp.IsOutlineVisible(11.0f, 1.0f, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(11.0f, 1.0f, pen, graphics));
-            Assert.False(gp.IsOutlineVisible(11.0f, 2.0f, Pens.Red, graphics));
-
-            Point point = new Point(12, 2);
-            Assert.False(gp.IsOutlineVisible(point, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(point, pen, graphics));
-
-            point.Y = 1;
-            Assert.True(gp.IsOutlineVisible(point, Pens.Red, graphics));
-
-            PointF fPoint = new PointF(13.0f, 2.0f);
-            Assert.False(gp.IsOutlineVisible(fPoint, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
-
-            fPoint.Y = 1;
-            Assert.True(gp.IsOutlineVisible(fPoint, Pens.Red, graphics));
-        }
-    }
-
-    private void AssertIsOutlineVisibleRectangle(Graphics graphics)
-    {
-        using (Pen pen = new Pen(Color.Red, 3.0f))
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(10, 10, 20, 20));
-            Assert.True(gp.IsOutlineVisible(10, 10, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(10, 11, pen, graphics));
-            Assert.False(gp.IsOutlineVisible(11, 11, Pens.Red, graphics));
-
-            Assert.True(gp.IsOutlineVisible(11.0f, 10.0f, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(11.0f, 11.0f, pen, graphics));
-            Assert.False(gp.IsOutlineVisible(11.0f, 11.0f, Pens.Red, graphics));
-
-            Point point = new Point(15, 10);
-            Assert.True(gp.IsOutlineVisible(point, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(point, pen, graphics));
-
-            point.Y = 15;
-            Assert.False(gp.IsOutlineVisible(point, Pens.Red, graphics));
-
-            PointF fPoint = new PointF(29.0f, 29.0f);
-            Assert.False(gp.IsOutlineVisible(fPoint, Pens.Red, graphics));
-            Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
-
-            fPoint.Y = 31.0f;
-            Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
-        }
-    }
-
-    private void AssertIsVisibleRectangle(Graphics graphics)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddRectangle(new Rectangle(10, 10, 20, 20));
-            Assert.False(gp.IsVisible(9, 9, graphics));
-            Assert.True(gp.IsVisible(10, 10, graphics));
-            Assert.True(gp.IsVisible(20, 20, graphics));
-            Assert.True(gp.IsVisible(29, 29, graphics));
-            Assert.False(gp.IsVisible(30, 29, graphics));
-            Assert.False(gp.IsVisible(29, 30, graphics));
-            Assert.False(gp.IsVisible(30, 30, graphics));
-            Assert.False(gp.IsVisible(9.4f, 9.4f, graphics));
-            Assert.True(gp.IsVisible(9.5f, 9.5f, graphics));
-            Assert.True(gp.IsVisible(10f, 10f, graphics));
-            Assert.True(gp.IsVisible(20f, 20f, graphics));
-            Assert.True(gp.IsVisible(29.4f, 29.4f, graphics));
-            Assert.False(gp.IsVisible(29.5f, 29.5f, graphics));
-            Assert.False(gp.IsVisible(29.5f, 29.4f, graphics));
-            Assert.False(gp.IsVisible(29.4f, 29.5f, graphics));
-        }
-    }
-
-    private void AssertIsVisibleEllipse(Graphics graphics)
-    {
-        using (GraphicsPath gp = new GraphicsPath())
-        {
-            gp.AddEllipse(new Rectangle(10, 10, 20, 20));
-            Assert.False(gp.IsVisible(10, 10, graphics));
-            Assert.True(gp.IsVisible(20, 20, graphics));
-            Assert.False(gp.IsVisible(29, 29, graphics));
-            Assert.False(gp.IsVisible(10f, 10f, graphics));
-            Assert.True(gp.IsVisible(20f, 20f, graphics));
-            Assert.False(gp.IsVisible(29.4f, 29.4f, graphics));
-        }
-    }
-
-    private void AssertReverse(GraphicsPath gp, PointF[] expectedPoints, byte[] expectedTypes)
-    {
-        gp.Reverse();
-        PointF[] reversedPoints = gp.PathPoints;
-        byte[] reversedTypes = gp.PathTypes;
-
-        int count = gp.PointCount;
-        Assert.Equal(expectedPoints.Length, gp.PointCount);
-        Assert.Equal(expectedTypes, gp.PathTypes);
-        for (int i = 0; i < count; i++)
-        {
-            Assert.Equal(expectedPoints[i], reversedPoints[count - i - 1]);
-            Assert.Equal(expectedTypes[i], reversedTypes[i]);
-        }
-    }
-
-    private void AssertPointsSequenceEqual(PointF[] expected, PointF[] actual, float tolerance)
-    {
-        int count = expected.Length;
-        Assert.Equal(expected.Length, actual.Length);
-        for (int i = 0; i < count; i++)
-        {
-            AssertExtensions.LessThanOrEqualTo(Math.Abs(expected[i].X - actual[i].X), tolerance);
-            AssertExtensions.LessThanOrEqualTo(Math.Abs(expected[i].Y - actual[i].Y), tolerance);
-        }
-    }
-
-    private void AssertRectangleEqual(RectangleF expected, RectangleF actual, float tolerance)
-    {
-        AssertExtensions.LessThanOrEqualTo(Math.Abs(expected.X - actual.X), tolerance);
-        AssertExtensions.LessThanOrEqualTo(Math.Abs(expected.Y - actual.Y), tolerance);
-        AssertExtensions.LessThanOrEqualTo(Math.Abs(expected.Width - actual.Width), tolerance);
-        AssertExtensions.LessThanOrEqualTo(Math.Abs(expected.Height - actual.Height), tolerance);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/HatchBrushTests.cs b/src/System.Drawing.Common/tests/Drawing2D/HatchBrushTests.cs
deleted file mode 100644
index bee95f4bce3..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/HatchBrushTests.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class HatchBrushTests
-{
-    public static IEnumerable<object[]> Ctor_HatchStyle_ForeColor_TestData()
-    {
-        yield return new object[] { HatchStyle.Horizontal, new Color() };
-        yield return new object[] { HatchStyle.SolidDiamond, Color.PapayaWhip };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_HatchStyle_ForeColor_TestData))]
-    public void Ctor_HatchStyle_ForeColor(HatchStyle hatchStyle, Color foreColor)
-    {
-        using (var brush = new HatchBrush(hatchStyle, foreColor))
-        {
-            Assert.Equal(hatchStyle, brush.HatchStyle);
-
-            Assert.NotEqual(foreColor, brush.ForegroundColor);
-            Assert.Equal(foreColor.ToArgb(), brush.ForegroundColor.ToArgb());
-
-            Assert.Equal(Color.FromArgb(255, 0, 0, 0), brush.BackgroundColor);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_HatchStyle_ForeColor_BackColor_TestData()
-    {
-        yield return new object[] { HatchStyle.Horizontal, new Color(), new Color() };
-        yield return new object[] { HatchStyle.SolidDiamond, Color.PapayaWhip, Color.Plum };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_HatchStyle_ForeColor_BackColor_TestData))]
-    public void Ctor_HatchStyle_ForeColor_BackColor(HatchStyle hatchStyle, Color foreColor, Color backColor)
-    {
-        using (var brush = new HatchBrush(hatchStyle, foreColor, backColor))
-        {
-            Assert.Equal(hatchStyle, brush.HatchStyle);
-
-            Assert.NotEqual(foreColor, brush.ForegroundColor);
-            Assert.Equal(foreColor.ToArgb(), brush.ForegroundColor.ToArgb());
-
-            Assert.NotEqual(backColor, brush.BackgroundColor);
-            Assert.Equal(backColor.ToArgb(), brush.BackgroundColor.ToArgb());
-        }
-    }
-
-    [Theory]
-    [InlineData(HatchStyle.Horizontal -1 )]
-    [InlineData(HatchStyle.SolidDiamond + 1)]
-    public void Ctor_InvalidHatchStyle_ThrowsArgumentException(HatchStyle hatchStyle)
-    {
-        AssertExtensions.Throws<ArgumentException>("hatchstyle", null, () => new HatchBrush(hatchStyle, Color.Empty));
-        AssertExtensions.Throws<ArgumentException>("hatchstyle", null, () => new HatchBrush(hatchStyle, Color.Empty, Color.Empty));
-    }
-
-    [Fact]
-    public void Clone_Brush_ReturnsClone()
-    {
-        using (var brush = new HatchBrush(HatchStyle.DarkDownwardDiagonal, Color.Magenta, Color.Peru))
-        {
-            HatchBrush clone = Assert.IsType<HatchBrush>(brush.Clone());
-
-            Assert.NotSame(clone, brush);
-            Assert.Equal(brush.HatchStyle, clone.HatchStyle);
-            Assert.Equal(brush.ForegroundColor, clone.ForegroundColor);
-            Assert.Equal(brush.BackgroundColor, clone.BackgroundColor);
-        }
-    }
-
-    [Fact]
-    public void Clone_ImmutableColor_ReturnsMutableClone()
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(Brushes.Bisque);
-        SolidBrush clone = Assert.IsType<SolidBrush>(brush.Clone());
-
-        clone.Color = SystemColors.AppWorkspace;
-        Assert.Equal(SystemColors.AppWorkspace, clone.Color);
-        Assert.Equal(Color.Bisque, brush.Color);
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var brush = new HatchBrush(HatchStyle.DarkHorizontal, Color.PeachPuff, Color.Purple);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Clone());
-    }
-
-    [Fact]
-    public void HatchStyle_EmptyAndGetDisposed_ThrowsArgumentException()
-    {
-        var brush = new HatchBrush(HatchStyle.DarkHorizontal, Color.PeachPuff, Color.Purple);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.HatchStyle);
-    }
-
-    [Fact]
-    public void ForegroundColor_EmptyAndGetDisposed_ThrowsArgumentException()
-    {
-        var brush = new HatchBrush(HatchStyle.DarkHorizontal, Color.PeachPuff, Color.Purple);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ForegroundColor);
-    }
-
-    [Fact]
-    public void BackgroundColor_EmptyAndGetDisposed_ThrowsArgumentException()
-    {
-        var brush = new HatchBrush(HatchStyle.DarkHorizontal, Color.PeachPuff, Color.Purple);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.BackgroundColor);
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Success()
-    {
-        var brush = new HatchBrush(HatchStyle.DarkHorizontal, Color.PeachPuff, Color.Purple);
-        brush.Dispose();
-        brush.Dispose();
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/LinearGradientBrushTests.cs b/src/System.Drawing.Common/tests/Drawing2D/LinearGradientBrushTests.cs
deleted file mode 100644
index 3f191433363..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/LinearGradientBrushTests.cs
+++ /dev/null
@@ -1,1104 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class LinearGradientBrushTests
-{
-    public static IEnumerable<object[]> Ctor_Point_TestData()
-    {
-        yield return new object[] { new Point(0, 0), new Point(2, 2), Color.Empty, Color.Empty, new RectangleF(0, 0, 2, 2) };
-        yield return new object[] { new Point(1, 0), new Point(0, 0), Color.Empty, Color.Red, new RectangleF(0, -0.5f, 1, 1) };
-        yield return new object[] { new Point(1, 2), new Point(4, 6), Color.Plum, Color.Red, new RectangleF(1, 2, 3, 4) };
-        yield return new object[] { new Point(1, 2), new Point(4, 6), Color.Red, Color.Red, new RectangleF(1, 2, 3, 4) };
-        yield return new object[] { new Point(-1, -2), new Point(4, 6), Color.Red, Color.Plum, new RectangleF(-1, -2, 5, 8) };
-        yield return new object[] { new Point(-4, -6), new Point(1, 2), Color.Black, Color.Wheat, new RectangleF(-4, -6, 5, 8) };
-        yield return new object[] { new Point(4, 6), new Point(-1, -2), Color.Black, Color.Wheat, new RectangleF(-1, -2, 5, 8) };
-        yield return new object[] { new Point(4, 6), new Point(1, 2), Color.Black, Color.Wheat, new RectangleF(1, 2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Point_TestData))]
-    public void Ctor_PointF_PointF_Color_Color(Point point1, Point point2, Color color1, Color color2, RectangleF expectedRectangle)
-    {
-        using (var brush = new LinearGradientBrush((PointF)point1, point2, color1, color2))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(expectedRectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.False(brush.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void Ctor_PointF_PointF_Color_Color_FloatRanges()
-    {
-        using (var brush = new LinearGradientBrush(new PointF(float.NaN, float.NaN), new PointF(float.PositiveInfinity, float.NegativeInfinity), Color.Plum, Color.Red))
-        {
-            Assert.Equal(float.PositiveInfinity, brush.Rectangle.X);
-            Assert.Equal(float.NegativeInfinity, brush.Rectangle.Y);
-            Assert.Equal(float.NaN, brush.Rectangle.Width);
-            Assert.Equal(float.NaN, brush.Rectangle.Height);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Point_TestData))]
-    public void Ctor_Point_Point_Color_Color(Point point1, Point point2, Color color1, Color color2, RectangleF expectedRectangle)
-    {
-        using (var brush = new LinearGradientBrush(point1, point2, color1, color2))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(expectedRectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.False(brush.Transform.IsIdentity);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void Ctor_EqualPoints_ThrowsOutOfMemoryException(int x, int y)
-    {
-        Assert.Throws<OutOfMemoryException>(() => new LinearGradientBrush(new Point(x, y), new Point(x, y), Color.Fuchsia, Color.GhostWhite));
-        Assert.Throws<OutOfMemoryException>(() => new LinearGradientBrush(new PointF(x, y), new PointF(x, y), Color.Fuchsia, Color.GhostWhite));
-    }
-
-    public static IEnumerable<object[]> Ctor_Rectangle_LinearGradientMode_TestData()
-    {
-        yield return new object[] { new Rectangle(0, 0, 1, 2), Color.Empty, Color.Red, LinearGradientMode.BackwardDiagonal };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, LinearGradientMode.ForwardDiagonal };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), Color.Red, Color.Red, LinearGradientMode.Horizontal };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Plum, LinearGradientMode.Vertical };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_LinearGradientMode_TestData))]
-    public void Ctor_Rectangle_Color_Color_LinearGradientMode(Rectangle rectangle, Color color1, Color color2, LinearGradientMode linearGradientMode)
-    {
-        using (var brush = new LinearGradientBrush(rectangle, color1, color2, linearGradientMode))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal(linearGradientMode == LinearGradientMode.Horizontal, brush.Transform.IsIdentity);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_LinearGradientMode_TestData))]
-    public void Ctor_RectangleF_Color_Color_LinearGradientMode(Rectangle rectangle, Color color1, Color color2, LinearGradientMode linearGradientMode)
-    {
-        using (var brush = new LinearGradientBrush((RectangleF)rectangle, color1, color2, linearGradientMode))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal(linearGradientMode == LinearGradientMode.Horizontal, brush.Transform.IsIdentity);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Rectangle_Angle_TestData()
-    {
-        yield return new object[] { new Rectangle(0, 0, 1, 2), Color.Empty, Color.Red, 90 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 180 };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), Color.Red, Color.Red, 0 };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), Color.Red, Color.Red, 360 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Plum, 90 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Angle_TestData))]
-    public void Ctor_Rectangle_Color_Color_Angle(Rectangle rectangle, Color color1, Color color2, float angle)
-    {
-        using (var brush = new LinearGradientBrush(rectangle, color1, color2, angle))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal((angle % 360) == 0, brush.Transform.IsIdentity);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Angle_TestData))]
-    public void Ctor_RectangleF_Color_Color_Angle(Rectangle rectangle, Color color1, Color color2, float angle)
-    {
-        using (var brush = new LinearGradientBrush((RectangleF)rectangle, color1, color2, angle))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal((angle % 360) == 0, brush.Transform.IsIdentity);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Rectangle_Angle_IsAngleScalable_TestData()
-    {
-        foreach (object[] testData in Ctor_Rectangle_Angle_TestData())
-        {
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], true };
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], false };
-        }
-    }
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Angle_IsAngleScalable_TestData))]
-    public void Ctor_Rectangle_Color_Color_Angle_IsAngleScalable(Rectangle rectangle, Color color1, Color color2, float angle, bool isAngleScalable)
-    {
-        using (var brush = new LinearGradientBrush(rectangle, color1, color2, angle, isAngleScalable))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal((angle % 360) == 0, brush.Transform.IsIdentity);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Angle_IsAngleScalable_TestData))]
-    public void Ctor_RectangleF_Color_Color_Angle_IsAngleScalable(Rectangle rectangle, Color color1, Color color2, float angle, bool isAngleScalable)
-    {
-        using (var brush = new LinearGradientBrush((RectangleF)rectangle, color1, color2, angle, isAngleScalable))
-        {
-            Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-            Assert.Equal(1, brush.Blend.Positions.Length);
-
-            Assert.False(brush.GammaCorrection);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-            Assert.Equal(new Color[] { Color.FromArgb(color1.ToArgb()), Color.FromArgb(color2.ToArgb()) }, brush.LinearColors);
-            Assert.Equal(rectangle, brush.Rectangle);
-            Assert.Equal(WrapMode.Tile, brush.WrapMode);
-
-            Assert.Equal((angle % 360) == 0, brush.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void Ctor_ZeroWidth_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 0, 4), Color.Empty, Color.Empty, 0f));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 0, 4), Color.Empty, Color.Empty, 0f));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 0, 4), Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 0, 4), Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 0, 4), Color.Empty, Color.Empty, 0, true));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 0, 4), Color.Empty, Color.Empty, 0, true));
-    }
-
-    [Fact]
-    public void Ctor_ZeroHeight_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 3, 0), Color.Empty, Color.Empty, 0f));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 3, 0), Color.Empty, Color.Empty, 0f));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 3, 0), Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 3, 0), Color.Empty, Color.Empty, LinearGradientMode.BackwardDiagonal));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new Rectangle(1, 2, 3, 0), Color.Empty, Color.Empty, 0, true));
-        AssertExtensions.Throws<ArgumentException>(null, () => new LinearGradientBrush(new RectangleF(1, 2, 3, 0), Color.Empty, Color.Empty, 0, true));
-    }
-
-    [Theory]
-    [InlineData(LinearGradientMode.Horizontal - 1)]
-    [InlineData(LinearGradientMode.BackwardDiagonal + 1)]
-    public void Ctor_InvalidLinearGradientMode_ThrowsEnumArgumentException(LinearGradientMode linearGradientMode)
-    {
-        Assert.ThrowsAny<ArgumentException>(() => new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Empty, Color.Empty, linearGradientMode));
-        Assert.ThrowsAny<ArgumentException>(() => new LinearGradientBrush(new RectangleF(1, 2, 3, 4), Color.Empty, Color.Empty, linearGradientMode));
-    }
-
-    [Fact]
-    public void Clone_Brush_ReturnsClone()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            LinearGradientBrush clone = Assert.IsType<LinearGradientBrush>(brush.Clone());
-
-            Assert.NotSame(clone, brush);
-            Assert.Equal(brush.Blend.Factors, clone.Blend.Factors);
-            Assert.Equal(brush.Blend.Positions.Length, clone.Blend.Positions.Length);
-            Assert.Equal(brush.LinearColors, clone.LinearColors);
-            Assert.Equal(brush.Rectangle, clone.Rectangle);
-            Assert.Equal(brush.Transform, clone.Transform);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Clone());
-    }
-
-    [Fact]
-    public void Blend_GetWithInterpolationColorsSet_ReturnsNull()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            var blend = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 10, 1 }
-            };
-
-            brush.InterpolationColors = blend;
-            Assert.Null(brush.Blend);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { 1 }, new float[] { 1 })]
-    [InlineData(new float[] { 0 }, new float[] { 0 })]
-    [InlineData(new float[] { float.MaxValue }, new float[] { float.MaxValue })]
-    [InlineData(new float[] { float.MinValue }, new float[] { float.MinValue })]
-    [InlineData(new float[] { 0.5f, 0.5f }, new float[] { 0, 1 })]
-    [InlineData(new float[] { 0.4f, 0.3f, 0.2f }, new float[] { 0, 0.5f, 1 })]
-    [InlineData(new float[] { -1 }, new float[] { -1 })]
-    [InlineData(new float[] { float.NaN }, new float[] { float.NaN })]
-    [InlineData(new float[] { 1 }, new float[] { 1, 2 })]
-    public void Blend_Set_Success(float[] factors, float[] positions)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            var blend = new Blend
-            {
-                Factors = factors,
-                Positions = positions
-            };
-            brush.Blend = blend;
-
-            Assert.Equal(blend.Factors, brush.Blend.Factors);
-            Assert.Equal(factors.Length, brush.Blend.Positions.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { 1, 2 }, new float[] { 1, 2 })]
-    [InlineData(new float[] { 1, 2 }, new float[] { 1, 1 })]
-    [InlineData(new float[] { 1, 2 }, new float[] { 1, 0 })]
-    [InlineData(new float[] { 0, 0, 0 }, new float[] { 0, 0, 0 })]
-    public void Blend_InvalidBlend_ThrowsArgumentException(float[] factors, float[] positions)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            var blend = new Blend
-            {
-                Factors = factors,
-                Positions = positions
-            };
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend = blend);
-        }
-    }
-
-    [Fact]
-    public void Blend_SetNullBlend_ThrowsNullReferenceException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.Blend = null);
-        }
-    }
-
-    [Fact]
-    public void Blend_SetNullBlendFactors_ThrowsNullReferenceException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.Blend = new Blend { Factors = null });
-        }
-    }
-
-    [Fact]
-    public void Blend_SetNullBlendPositions_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException, ArgumentNullException>("value", "source", () => brush.Blend = new Blend { Factors = new float[2], Positions = null });
-        }
-    }
-
-    [Fact]
-    public void Blend_SetFactorsLengthGreaterThanPositionsLength_ThrowsArgumentOutOfRangeException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("value", null, () => brush.Blend = new Blend { Factors = new float[2], Positions = new float[1] });
-        }
-    }
-
-    [Fact]
-    public void Blend_SetInvalidBlendFactorsLength_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend = new Blend { Factors = new float[0], Positions = new float[0] });
-        }
-    }
-
-    [Fact]
-    public void Blend_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend = new Blend());
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void GammaCorrection_Set_GetReturnsExpected(bool gammaCorrection)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true) { GammaCorrection = gammaCorrection })
-        {
-            Assert.Equal(gammaCorrection, brush.GammaCorrection);
-        }
-    }
-
-    [Fact]
-    public void GammaCorrection_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.GammaCorrection);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.GammaCorrection = true);
-    }
-
-    [Fact]
-    public void InterpolationColors_SetValid_GetReturnsExpected()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            var blend = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 10, 1 }
-            };
-
-            brush.InterpolationColors = blend;
-            Assert.Equal(blend.Colors.Select(c => Color.FromArgb(c.ToArgb())), brush.InterpolationColors.Colors);
-            Assert.Equal(blend.Positions, brush.InterpolationColors.Positions);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_SetWithExistingInterpolationColors_OverwritesInterpolationColors()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true)
-        {
-            InterpolationColors = new ColorBlend
-            {
-                Colors = new Color[] { Color.Wheat, Color.Yellow },
-                Positions = new float[] { 0, 1 }
-            }
-        })
-        {
-            var blend = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 0.5f, 1f }
-            };
-            brush.InterpolationColors = blend;
-            Assert.Equal(blend.Colors.Select(c => Color.FromArgb(c.ToArgb())), brush.InterpolationColors.Colors);
-            Assert.Equal(blend.Positions, brush.InterpolationColors.Positions);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_SetNullBlend_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = null);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_SetBlendWithNullColors_ThrowsNullReferenceException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.InterpolationColors = new ColorBlend { Colors = null });
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void InterpolationColors_SetBlendWithTooFewColors_ThrowsArgumentException(int colorsLength)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = new ColorBlend { Colors = new Color[colorsLength] });
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_SetNullBlendPositions_ThrowsNullReferenceException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.InterpolationColors = new ColorBlend { Colors = new Color[2], Positions = null });
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(3)]
-    public void InterpolationColors_SetInvalidBlendPositionsLength_ThrowsArgumentException(int positionsLength)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = new ColorBlend
-            {
-                Colors = new Color[2],
-                Positions = new float[positionsLength]
-            });
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { 1, 0, 1 })]
-    [InlineData(new float[] { 0, 0, 0 })]
-    public void InterpolationColors_InvalidPositions_ThrowsArgumentException(float[] positions)
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = new ColorBlend
-        {
-            Colors = new Color[positions.Length],
-            Positions = positions
-        });
-    }
-
-    [Fact]
-    public void InterpolationColors_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true)
-        {
-            InterpolationColors = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 0.5f, 1 }
-            }
-        };
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = new ColorBlend
-        {
-            Colors = new Color[2],
-            Positions = new float[] { 0f, 1f }
-        });
-    }
-
-    [Fact]
-    public void InterpolationColors_SetBlendTriangularShape_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true)
-        {
-            InterpolationColors = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 0.5f, 1 }
-            }
-        })
-        {
-            Assert.NotNull(brush.InterpolationColors);
-
-            brush.SetBlendTriangularShape(0.5f);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_SetBlend_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true)
-        {
-            InterpolationColors = new ColorBlend
-            {
-                Colors = new Color[] { Color.Red, Color.PeachPuff, Color.PowderBlue },
-                Positions = new float[] { 0, 0.5f, 1 }
-            }
-        })
-        {
-            Assert.NotNull(brush.InterpolationColors);
-
-            brush.Blend = new Blend
-            {
-                Factors = new float[1],
-                Positions = new float[1]
-            };
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-        }
-    }
-
-    [Fact]
-    public void LinearColors_SetValid_GetReturnsExpected()
-    {
-        Color[] colors = new Color[] { Color.Red, Color.Blue, Color.AntiqueWhite };
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true) { LinearColors = colors })
-        {
-            Assert.Equal(colors.Take(2).Select(c => Color.FromArgb(c.ToArgb())), brush.LinearColors);
-        }
-    }
-
-    [Fact]
-    public void LinearColors_SetNull_ThrowsNullReferenceException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.LinearColors = null);
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void LinearColors_SetInvalidLength_ThrowsIndexOutOfRangeException(int length)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.Throws<IndexOutOfRangeException>(() => brush.LinearColors = new Color[length]);
-        }
-    }
-
-    [Fact]
-    public void LinearColors_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.LinearColors);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.LinearColors = new Color[] { Color.Red, Color.Wheat });
-    }
-
-    [Fact]
-    public void Rectangle_GetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Rectangle);
-    }
-
-    [Fact]
-    public void Transform_SetValid_GetReturnsExpected()
-    {
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true) { Transform = transform })
-        {
-            Assert.Equal(transform, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNull_ThrowsArgumentNullException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("value", "matrix", () => brush.Transform = null);
-        }
-    }
-
-    [Fact]
-    public void Transform_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform = new Matrix());
-    }
-
-    [Theory]
-    [InlineData(WrapMode.Tile)]
-    [InlineData(WrapMode.TileFlipX)]
-    [InlineData(WrapMode.TileFlipXY)]
-    [InlineData(WrapMode.TileFlipY)]
-    public void WrapMode_SetValid_GetReturnsExpected(WrapMode wrapMode)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true) { WrapMode = wrapMode })
-        {
-            Assert.Equal(wrapMode, brush.WrapMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(WrapMode.Tile - 1)]
-    [InlineData(WrapMode.Clamp + 1)]
-    public void WrapMode_SetInvalid_ThrowsInvalidEnumArgumentException(WrapMode wrapMode)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => brush.WrapMode = wrapMode);
-        }
-    }
-
-    [Fact]
-    public void WrapMode_Clamp_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode = WrapMode.Clamp);
-        }
-    }
-
-    [Fact]
-    public void WrapMode_GetSetDisposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode = WrapMode.TileFlipX);
-    }
-
-    [Fact]
-    public void ResetTransform_Invoke_SetsTransformToIdentity()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Assert.False(brush.Transform.IsIdentity);
-
-            brush.ResetTransform();
-            Assert.True(brush.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ResetTransform());
-    }
-
-    [Fact]
-    public void MultiplyTransform_NoOrder_Success()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Multiply(matrix);
-
-            brush.MultiplyTransform(matrix);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend)]
-    [InlineData(MatrixOrder.Append)]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void MultiplyTransform_Order_Success(MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            Matrix expectedTransform = brush.Transform;
-
-            if (order == MatrixOrder.Append || order == MatrixOrder.Prepend)
-            {
-                expectedTransform.Multiply(matrix, order);
-            }
-            else
-            {
-                // Invalid MatrixOrder is interpreted as MatrixOrder.Append.
-                expectedTransform.Multiply(matrix, MatrixOrder.Append);
-            }
-
-            brush.MultiplyTransform(matrix, order);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null));
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_DisposedMatrix_Nop()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        using (Matrix transform = brush.Transform)
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            brush.MultiplyTransform(matrix);
-            brush.MultiplyTransform(matrix, MatrixOrder.Append);
-
-            Assert.Equal(transform, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NonInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(new Matrix()));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(new Matrix(), MatrixOrder.Prepend));
-    }
-
-    [Theory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void TranslateTransform_NoOrder_Success(float dx, float dy)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Translate(dx, dy);
-
-            brush.TranslateTransform(dx, dy);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 1, MatrixOrder.Prepend)]
-    [InlineData(1, 1, MatrixOrder.Append)]
-    [InlineData(0, 0, MatrixOrder.Prepend)]
-    [InlineData(0, 0, MatrixOrder.Append)]
-    [InlineData(-1, -1, MatrixOrder.Prepend)]
-    [InlineData(-1, -1, MatrixOrder.Append)]
-    public void TranslateTransform_Order_Success(float dx, float dy, MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Translate(dx, dy, order);
-
-            brush.TranslateTransform(dx, dy, order);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void TranslateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(0, 0, order));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(0, 0));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(0, 0, MatrixOrder.Append));
-    }
-
-    [Theory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void ScaleTransform_NoOrder_Success(float sx, float sy)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Scale(sx, sy);
-
-            brush.ScaleTransform(sx, sy);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 1, MatrixOrder.Prepend)]
-    [InlineData(1, 1, MatrixOrder.Append)]
-    [InlineData(0, 0, MatrixOrder.Prepend)]
-    [InlineData(0, 0, MatrixOrder.Append)]
-    [InlineData(-1, -1, MatrixOrder.Prepend)]
-    [InlineData(-1, -1, MatrixOrder.Append)]
-    public void ScaleTransform_Order_Success(float sx, float sy, MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Scale(sx, sy, order);
-
-            brush.ScaleTransform(sx, sy, order);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void ScaleTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(0, 0, order));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(0, 0));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(0, 0, MatrixOrder.Append));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(360)]
-    public void RotateTransform_NoOrder_Success(float angle)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Rotate(angle);
-
-            brush.RotateTransform(angle);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, MatrixOrder.Prepend)]
-    [InlineData(1, MatrixOrder.Append)]
-    [InlineData(0, MatrixOrder.Prepend)]
-    [InlineData(360, MatrixOrder.Append)]
-    [InlineData(-1, MatrixOrder.Prepend)]
-    [InlineData(-1, MatrixOrder.Append)]
-    public void RotateTransform_Order_Success(float angle, MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            Matrix expectedTransform = brush.Transform;
-            expectedTransform.Rotate(angle, order);
-
-            brush.RotateTransform(angle, order);
-            Assert.Equal(expectedTransform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void RotateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(0, order));
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(0));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(0, MatrixOrder.Append));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(0.5)]
-    [InlineData(1)]
-    [InlineData(float.NaN)]
-    public void SetSigmalBellShape(float focus)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            brush.SetSigmaBellShape(focus);
-        }
-    }
-
-    [Theory]
-    [InlineData(-0.1)]
-    [InlineData(1.1)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetSigmalBellShape_InvalidFocus_ThrowsArgumentException(float focus)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetSigmaBellShape(focus));
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetSigmaBellShape(focus, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(-0.1)]
-    [InlineData(1.1)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetSigmalBellShape_InvalidScale_ThrowsArgumentException(float scale)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>("scale", null, () => brush.SetSigmaBellShape(0.1f, scale));
-        }
-    }
-
-    [Fact]
-    public void SetSigmalBellShape_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetSigmaBellShape(0));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetSigmaBellShape(0, 1));
-    }
-
-    [Theory]
-    [InlineData(0, new float[] { 1, 0 }, new float[] { 0, 1 })]
-    [InlineData(0.5, new float[] { 0, 1, 0 }, new float[] { 0, 0.5f, 1 })]
-    [InlineData(1, new float[] { 0, 1 }, new float[] { 0, 1 })]
-    public void SetBlendTriangularShape_Success(float focus, float[] expectedFactors, float[] expectedPositions)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 0, true))
-        {
-            brush.SetBlendTriangularShape(focus);
-
-            Assert.Equal(expectedFactors, brush.Blend.Factors);
-            Assert.Equal(expectedPositions, brush.Blend.Positions);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 1, new float[] { 1, 0 }, new float[] { 0, 1 })]
-    [InlineData(0.5, 0, new float[] { 0, 0, 0 }, new float[] { 0, 0.5f, 1 })]
-    [InlineData(0.5, 1, new float[] { 0, 1, 0 }, new float[] { 0, 0.5f, 1 })]
-    [InlineData(1, 0.5, new float[] { 0, 0.5f }, new float[] { 0, 1 })]
-    public void SetBlendTriangularShape_Scale_Success(float focus, float scale, float[] expectedFactors, float[] expectedPositions)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 0, true))
-        {
-            brush.SetBlendTriangularShape(focus, scale);
-
-            Assert.Equal(expectedFactors, brush.Blend.Factors);
-            Assert.Equal(expectedPositions, brush.Blend.Positions);
-        }
-    }
-
-    [Theory]
-    [InlineData(-0.1)]
-    [InlineData(1.1)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetBlendTriangularShape_InvalidFocus_ThrowsArgumentException(float focus)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetBlendTriangularShape(focus));
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetBlendTriangularShape(focus, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(-0.1)]
-    [InlineData(1.1)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void SetBlendTriangularShape_InvalidScale_ThrowsArgumentException(float scale)
-    {
-        using (var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true))
-        {
-            AssertExtensions.Throws<ArgumentException>("scale", null, () => brush.SetBlendTriangularShape(0.1f, scale));
-        }
-    }
-
-    [Fact]
-    public void SetBlendTriangularShape_Disposed_ThrowsArgumentException()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetBlendTriangularShape(0));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetBlendTriangularShape(0, 1));
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Success()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        brush.Dispose();
-        brush.Dispose();
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.Core.cs b/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.Core.cs
deleted file mode 100644
index b7c6a8186a9..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.Core.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Numerics;
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public partial class MatrixTests
-{
-    [Theory]
-    [MemberData(nameof(MatrixElements_TestData))]
-    public void Ctor_Matrix3x2(float m11, float m12, float m21, float m22, float dx, float dy, bool isIdentity, bool isInvertible)
-    {
-        Matrix3x2 matrix3X2 = new Matrix3x2(m11, m12, m21, m22, dx, dy);
-        using (var matrix = new Matrix(matrix3X2))
-        {
-            Assert.Equal(new float[] { m11, m12, m21, m22, dx, dy }, matrix.Elements);
-            Assert.Equal(matrix3X2, matrix.MatrixElements);
-            Assert.Equal(isIdentity, matrix.IsIdentity);
-            Assert.Equal(isInvertible, matrix.IsInvertible);
-            Assert.Equal(dx, matrix.OffsetX);
-            Assert.Equal(dy, matrix.OffsetY);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(MatrixElements_TestData))]
-    public void MatrixElements_RoundTrip(float m11, float m12, float m21, float m22, float dx, float dy, bool isIdentity, bool isInvertible)
-    {
-        Matrix3x2 matrix3X2 = new Matrix3x2(m11, m12, m21, m22, dx, dy);
-        using (var matrix = new Matrix())
-        {
-            matrix.MatrixElements = matrix3X2;
-            Assert.Equal(new float[] { m11, m12, m21, m22, dx, dy }, matrix.Elements);
-            Assert.Equal(matrix3X2, matrix.MatrixElements);
-            Assert.Equal(isIdentity, matrix.IsIdentity);
-            Assert.Equal(isInvertible, matrix.IsInvertible);
-            Assert.Equal(dx, matrix.OffsetX);
-            Assert.Equal(dy, matrix.OffsetY);
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.cs b/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.cs
deleted file mode 100644
index e302b52623c..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/MatrixTests.cs
+++ /dev/null
@@ -1,896 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.XUnit;
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public partial class MatrixTests
-{
-    private static Matrix CreateDisposedMatrix()
-    {
-        var matrix = new Matrix();
-        matrix.Dispose();
-        return matrix;
-    }
-
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var matrix = new Matrix())
-        {
-            Assert.Equal(new float[] { 1, 0, 0, 1, 0, 0 }, matrix.Elements);
-            Assert.True(matrix.IsIdentity);
-            Assert.True(matrix.IsInvertible);
-            Assert.Equal(0, matrix.OffsetX);
-            Assert.Equal(0, matrix.OffsetY);
-        }
-    }
-
-    [Theory]
-    [InlineData(float.NaN)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.PositiveInfinity)]
-    public void Ctor_FloatingPointBoundsInElements(float f)
-    {
-        Ctor_Elements(f, 0, 0, 1, 0, 0, false, false);
-        Ctor_Elements(1, f, 0, 1, 0, 0, false, false);
-        Ctor_Elements(1, 0, f, 1, 0, 0, false, false);
-        Ctor_Elements(1, 0, 0, f, 0, 0, false, false);
-        Ctor_Elements(1, 0, 0, 1, f, 0, false, false);
-        Ctor_Elements(1, 0, 0, 1, 0, f, false, false);
-    }
-
-    [Theory]
-    [MemberData(nameof(MatrixElements_TestData))]
-    public void Ctor_Elements(float m11, float m12, float m21, float m22, float dx, float dy, bool isIdentity, bool isInvertible)
-    {
-        using (var matrix = new Matrix(m11, m12, m21, m22, dx, dy))
-        {
-            Assert.Equal(new float[] { m11, m12, m21, m22, dx, dy }, matrix.Elements);
-            Assert.Equal(isIdentity, matrix.IsIdentity);
-            Assert.Equal(isInvertible, matrix.IsInvertible);
-            Assert.Equal(dx, matrix.OffsetX);
-            Assert.Equal(dy, matrix.OffsetY);
-        }
-    }
-
-    public static TheoryData<float, float, float, float, float, float, bool, bool> MatrixElements_TestData
-        => new()
-        {
-            { 1, 0, 0, 1, 0, 0, true, true },
-            { 0, 1, 2, 1, 3, 4, false, true },
-            { 0, 0, 0, 0, 0, 0, false, false },
-            { 1, 2, 3, 4, 5, 6, false, true },
-            { -1, -2, -3, -4, -5, -6, false, true },
-            { 123, 24, 82, 16, 47, 30, false, false },
-            { 156, 46, 0, 0, 106, 19, false, false },
-            { 146, 66, 158, 104, 42, 150, false, true },
-            { 119, 140, 145, 74, 102, 58, false, true },
-            { 1.1f, 0.1f, -0.1f, 0.9f, 0, 0, false, true },
-            { 1.01f, 0.01f, -0.01f, 0.99f, 0, 0, false, true },
-            { 1.001f, 0.001f, -0.001f, 0.999f, 0, 0, false, true },
-            { 1.0001f, 0.0001f, -0.0001f, 0.9999f, 0, 0, true, true },
-            { 1.0009f, 0.0009f, -0.0009f, 0.99995f, 0, 0, false, true }
-        };
-
-    public static IEnumerable<object[]> Ctor_Rectangle_Points_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 4, 8, 16), new Point[] { new Point(32, 64), new Point(128, 256), new Point(512, 1024) }, new float[] { 12, 24, 30, 60, -100, -200 }, false, false };
-        yield return new object[] { new Rectangle(0, 0, 2, 4), new Point[] { new Point(8, 16), new Point(32, 64), new Point(128, 256) }, new float[] { 12, 24, 30, 60, 8, 16 }, false, false };
-        yield return new object[] { new Rectangle(0, 0, 1, 1), new Point[] { new Point(0, 0), new Point(0, 0), new Point(0, 0) }, new float[] { 0, 0, 0, 0, 0, 0 }, false, false };
-        yield return new object[] { new Rectangle(0, 0, 1, 1), new Point[] { new Point(0, 0), new Point(1, 0), new Point(0, 1) }, new float[] { 1, 0, 0, 1, 0, 0 }, true, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Points_TestData))]
-    public void Ctor_Rectangle_Points(Rectangle rect, Point[] plgpnts, float[] expectedElements, bool isIdentity, bool isInvertible)
-    {
-        using (var matrix = new Matrix(rect, plgpnts))
-        {
-            Assert.Equal(expectedElements, matrix.Elements);
-            Assert.Equal(isIdentity, matrix.IsIdentity);
-            Assert.Equal(isInvertible, matrix.IsInvertible);
-            Assert.Equal(expectedElements[4], matrix.OffsetX);
-            Assert.Equal(expectedElements[5], matrix.OffsetY);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Points_TestData))]
-    public void Ctor_RectangleF_Points(Rectangle rect, Point[] plgpnts, float[] expectedElements, bool isIdentity, bool isInvertible)
-    {
-        using (var matrix = new Matrix(rect, plgpnts.Select(p => (PointF)p).ToArray()))
-        {
-            Assert.Equal(expectedElements, matrix.Elements);
-            Assert.Equal(isIdentity, matrix.IsIdentity);
-            Assert.Equal(isInvertible, matrix.IsInvertible);
-            Assert.Equal(expectedElements[4], matrix.OffsetX);
-            Assert.Equal(expectedElements[5], matrix.OffsetY);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullPoints_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("plgpts", () => new Matrix(new RectangleF(), null));
-        AssertExtensions.Throws<ArgumentNullException>("plgpts", () => new Matrix(new Rectangle(), null));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(2)]
-    [InlineData(4)]
-    public void Ctor_PointsLengthNotThree_ThrowsArgumentNullException(int length)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Matrix(new RectangleF(), new PointF[length]));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Matrix(new Rectangle(), new Point[length]));
-    }
-
-    [Fact]
-    public void Ctor_WidthZero_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => new Matrix(new Rectangle(1, 1, 0, 1), new Point[3]));
-        Assert.Throws<OutOfMemoryException>(() => new Matrix(new RectangleF(1, 1, 0, 1), new PointF[3]));
-    }
-
-    [Fact]
-    public void Ctor_HeightZero_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => new Matrix(new Rectangle(1, 1, 1, 0), new Point[3]));
-        Assert.Throws<OutOfMemoryException>(() => new Matrix(new RectangleF(1, 1, 1, 0), new PointF[3]));
-    }
-
-    [Fact]
-    public void Clone_Matrix_ReturnsExpected()
-    {
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        using (Matrix clone = Assert.IsType<Matrix>(matrix.Clone()))
-        {
-            Assert.NotSame(matrix, clone);
-            Assert.Equal(new float[] { 1, 2, 3, 4, 5, 6 }, clone.Elements);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Clone());
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new Matrix(), new Matrix(1, 0, 0, 1, 0, 0), true };
-        yield return new object[] { new Matrix(), new Matrix(123, 24, 82, 16, 47, 30), false };
-        yield return new object[] { new Matrix(), new Matrix(1.1f, 0.1f, -0.1f, 0.9f, 0, 0), false };
-        yield return new object[] { new Matrix(), new Matrix(1.01f, 0.01f, -0.01f, 0.99f, 0, 0), false };
-        yield return new object[] { new Matrix(), new Matrix(1.001f, 0.001f, -0.001f, 0.999f, 0, 0), false };
-        yield return new object[] { new Matrix(), new Matrix(1.0001f, 0.0001f, -0.0001f, 0.9999f, 0, 0), false };
-        yield return new object[] { new Matrix(), new Matrix(1.0009f, 0.0009f, -0.0009f, 0.99995f, 0, 0), false };
-
-        var matrix = new Matrix(1, 2, 3, 4, 5, 6);
-        yield return new object[] { matrix, matrix, true };
-        yield return new object[] { matrix.Clone(), matrix.Clone(), true };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 2, 3, 4, 5, 6), true };
-        yield return new object[] { matrix.Clone(), new Matrix(2, 2, 3, 4, 5, 6), false };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 3, 3, 4, 5, 6), false };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 2, 4, 4, 5, 6), false };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 2, 3, 5, 5, 6), false };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 2, 3, 4, 6, 6), false };
-        yield return new object[] { matrix.Clone(), new Matrix(1, 2, 3, 4, 5, 7), false };
-
-        yield return new object[] { new Matrix(), null, false };
-        yield return new object[] { new Matrix(), new object(), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Other_ReturnsExpected(Matrix matrix, object other, bool expected)
-    {
-        using (matrix)
-        using (other as IDisposable)
-        {
-            Assert.Equal(expected, matrix.Equals(other));
-            if (other is Matrix otherMatrix)
-            {
-                Assert.Equal(ReferenceEquals(matrix, other), matrix.GetHashCode().Equals(other.GetHashCode()));
-            }
-        }
-    }
-
-    [Fact]
-    public void Equals_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Equals(new Matrix()));
-    }
-
-    [Fact]
-    public void Equals_DisposedOther_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Matrix().Equals(CreateDisposedMatrix()));
-    }
-
-    [Fact]
-    public void Elements_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Elements);
-    }
-
-    public static IEnumerable<object[]> Invert_TestData()
-    {
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), new float[] { -2, 1, 1.5f, -0.5f, 1, -2 } };
-        yield return new object[] { new Matrix(1, 0, 0, 1, 8, 8), new float[] { 1, 0, 0, 1, -8, -8 } };
-        yield return new object[] { new Matrix(), new float[] { 1, 0, 0, 1, 0, 0 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Invert_TestData))]
-    public void Invert_Matrix_Success(Matrix matrix, float[] expectedElements)
-    {
-        using (matrix)
-        {
-            matrix.Invert();
-            Assert.Equal(expectedElements, matrix.Elements);
-        }
-    }
-
-    [Theory]
-    [InlineData(float.NaN)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void Invert_FloatBounds_ThrowsArgumentException(float f)
-    {
-        using (var matrix1 = new Matrix(f, 2, 3, 4, 5, 6))
-        using (var matrix2 = new Matrix(1, f, 3, 4, 5, 6))
-        using (var matrix3 = new Matrix(1, 2, f, 4, 5, 6))
-        using (var matrix4 = new Matrix(1, 2, 3, f, 5, 6))
-        using (var matrix5 = new Matrix(1, 2, 3, 4, f, 6))
-        using (var matrix6 = new Matrix(1, 2, 3, 4, 5, f))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix1.Invert());
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix2.Invert());
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix3.Invert());
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix4.Invert());
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix5.Invert());
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix6.Invert());
-        }
-    }
-
-    [Fact]
-    public void Invert_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Invert());
-    }
-
-    [Fact]
-    public void IsIdentity_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().IsIdentity);
-    }
-
-    [Fact]
-    public void IsInvertible_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().IsInvertible);
-    }
-
-    public static IEnumerable<object[]> Multiply_TestData()
-    {
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(10, 20, 30, 40, 50, 60), MatrixOrder.Prepend, new float[] { 700, 1000, 1500, 2200, 2350, 3460 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(10, 20, 30, 40, 50, 60), MatrixOrder.Append, new float[] { 700, 1000, 1500, 2200, 2350, 3460 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(), MatrixOrder.Prepend, new float[] { 10, 20, 30, 40, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(), MatrixOrder.Append, new float[] { 10, 20, 30, 40, 50, 60 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(0, 0, 0, 0, 0, 0), MatrixOrder.Prepend, new float[] { 0, 0, 0, 0, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(0, 0, 0, 0, 0, 0), MatrixOrder.Append, new float[] { 0, 0, 0, 0, 0, 0 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(1, 1, 1, 1, 1, 1), MatrixOrder.Prepend, new float[] { 40, 60, 40, 60, 90, 120 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(1, 1, 1, 1, 1, 1), MatrixOrder.Append, new float[] { 30, 30, 70, 70, 111, 111 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN), MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN), MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), MatrixOrder.Prepend, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), MatrixOrder.Append, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), MatrixOrder.Prepend, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), MatrixOrder.Append, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue), MatrixOrder.Prepend, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), new Matrix(float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue), MatrixOrder.Append, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Multiply_TestData))]
-    public void Multiply_Matrix_Success(Matrix matrix, Matrix multiple, MatrixOrder order, float[] expected)
-    {
-        using (matrix)
-        using (multiple)
-        {
-            if (order == MatrixOrder.Prepend)
-            {
-                using (Matrix clone1 = matrix.Clone())
-                {
-                    clone1.Multiply(multiple);
-                    Assert.Equal(expected, clone1.Elements, new FloatingPointToleranceComparerer<float>(0.00001f));
-                }
-            }
-            matrix.Multiply(multiple, order);
-            Assert.Equal(expected, matrix.Elements);
-        }
-    }
-
-    [Fact]
-    public void Multiply_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => matrix.Multiply(null));
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => matrix.Multiply(null, MatrixOrder.Prepend));
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void Multiply_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        using (var other = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Multiply(other, order));
-        }
-    }
-
-    [Fact]
-    public void Multiply_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        using (var other = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Multiply(other));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Multiply(other, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void Multiply_DisposedMatrix_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Multiply(disposedMatrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Multiply(disposedMatrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void Multiply_SameMatrix_ThrowsInvalidOperationException()
-    {
-        using (var matrix = new Matrix())
-        {
-            Assert.Throws<InvalidOperationException>(() => matrix.Multiply(matrix));
-            Assert.Throws<InvalidOperationException>(() => matrix.Multiply(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void Reset_Matrix_ReturnsExpected()
-    {
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            matrix.Reset();
-            Assert.Equal(new float[] { 1, 0, 0, 1, 0, 0 }, matrix.Elements);
-
-            matrix.Reset();
-            Assert.Equal(new float[] { 1, 0, 0, 1, 0, 0 }, matrix.Elements);
-        }
-    }
-
-    [Fact]
-    public void Reset_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Reset());
-    }
-
-    public static IEnumerable<object[]> Rotate_TestData()
-    {
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 180, PointF.Empty, MatrixOrder.Prepend, new float[] { -9.999996f, -19.9999943f, -30.0000019f, -40.0000038f, 50, 60 }, null, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 180, PointF.Empty, MatrixOrder.Append, new float[] { -9.999996f, -20, -30f, -40f, -50, -60 }, null, false };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 540, PointF.Empty, MatrixOrder.Prepend, new float[] { -9.999996f, -19.9999943f, -30.0000019f, -40.0000038f, 50, 60 }, null, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 540, PointF.Empty, MatrixOrder.Append, new float[] { -9.999996f, -20, -30f, -40f, -50, -60 }, null, false };
-
-        yield return new object[] { new Matrix(), 45, PointF.Empty, MatrixOrder.Prepend, new float[] { 0.707106769f, 0.707106769f, -0.707106829f, 0.707106769f, 0, 0 }, null, false };
-        yield return new object[] { new Matrix(), 45, PointF.Empty, MatrixOrder.Append, new float[] { 0.707106769f, 0.707106769f, -0.707106829f, 0.707106769f, 0, 0 }, null, false };
-
-        using (var rotated45 = new Matrix())
-        {
-            rotated45.Rotate(45);
-            yield return new object[] { rotated45.Clone(), 135, PointF.Empty, MatrixOrder.Prepend, new float[] { -1, 0, 0, -1, 0, 0 }, null, false };
-            yield return new object[] { rotated45.Clone(), 135, PointF.Empty, MatrixOrder.Append, new float[] { -1, 0, 0, -1, 0, 0 }, null, false };
-        }
-
-        yield return new object[] { new Matrix(), 90, PointF.Empty, MatrixOrder.Prepend, new float[] { 0, 1, -1, 0, 0, 0 }, null, false };
-        yield return new object[] { new Matrix(), 90, PointF.Empty, MatrixOrder.Append, new float[] { 0, 1, -1, 0, 0, 0 }, null, false };
-
-        using (var rotated90 = new Matrix())
-        {
-            rotated90.Rotate(90);
-            yield return new object[] { rotated90.Clone(), 270, PointF.Empty, MatrixOrder.Prepend, new float[] { 1, 0, 0, 1, 0, 0 }, null, true };
-            yield return new object[] { rotated90.Clone(), 270, PointF.Empty, MatrixOrder.Append, new float[] { 1, 0, 0, 1, 0, 0 }, null, true };
-        }
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 180, new PointF(10, 10), MatrixOrder.Prepend, new float[] { -10, -20, -30, -40, 850, 1260 }, null, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 180, new PointF(10, 10), MatrixOrder.Append, new float[] { -10, -20, -30, -40, -30, -40 }, null, false };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, PointF.Empty, MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, 50, 60 }, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, PointF.Empty, MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, null, false };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, PointF.Empty, MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, 50, 60 }, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, PointF.Empty, MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, null, false };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, PointF.Empty, MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, 50, 60 }, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, false };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, PointF.Empty, MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN }, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Rotate_TestData))]
-    public void Rotate_Matrix_Success(Matrix matrix, float angle, PointF point, MatrixOrder order, float[] expectedElements, float[] expectedElementsRotateAt, bool isIdentity)
-    {
-        using (matrix)
-        {
-            if (order == MatrixOrder.Prepend)
-            {
-                if (point == Point.Empty)
-                {
-                    using (Matrix clone1 = matrix.Clone())
-                    {
-                        clone1.Rotate(angle);
-                        AssertEqualFloatArray(expectedElements, clone1.Elements);
-                        Assert.Equal(isIdentity, clone1.IsIdentity);
-                    }
-                }
-
-                using (Matrix clone2 = matrix.Clone())
-                {
-                    clone2.RotateAt(angle, point);
-                    AssertEqualFloatArray(expectedElementsRotateAt ?? expectedElements, clone2.Elements);
-                    Assert.False(clone2.IsIdentity);
-                }
-            }
-
-            if (point == Point.Empty)
-            {
-                using (Matrix clone3 = matrix.Clone())
-                {
-                    clone3.Rotate(angle, order);
-                    AssertEqualFloatArray(expectedElements, clone3.Elements);
-                    Assert.Equal(isIdentity, clone3.IsIdentity);
-                }
-            }
-
-            using (Matrix clone4 = matrix.Clone())
-            {
-                clone4.RotateAt(angle, point, order);
-                AssertEqualFloatArray(expectedElementsRotateAt ?? expectedElements, clone4.Elements);
-                Assert.False(clone4.IsIdentity);
-            }
-        }
-    }
-
-    [Fact]
-    public void Rotate_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedMatrix().Rotate(1, MatrixOrder.Append));
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void Rotate_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Rotate(1, order));
-        }
-    }
-
-    [Fact]
-    public void RotateAt_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.RotateAt(1, PointF.Empty));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.RotateAt(1, PointF.Empty, MatrixOrder.Append));
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void RotateAt_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.RotateAt(1, PointF.Empty, order));
-        }
-    }
-
-    public static IEnumerable<object[]> Scale_TestData()
-    {
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 2, 4, MatrixOrder.Prepend, new float[] { 20, 40, 120, 160, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 2, 4, MatrixOrder.Append, new float[] { 20, 80, 60, 160, 100, 240 } };
-
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0.5, 0.25, MatrixOrder.Prepend, new float[] { 10, 20, 30, 40, 50, 60 } };
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0.5, 0.25, MatrixOrder.Append, new float[] { 10, 10, 60, 40, 25, 15 } };
-
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0, 0, MatrixOrder.Prepend, new float[] { 0, 0, 0, 0, 50, 60 } };
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0, 0, MatrixOrder.Append, new float[] { 0, 0, 0, 0, 0, 0 } };
-
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 1, 1, MatrixOrder.Prepend, new float[] { 20, 40, 120, 160, 50, 60 } };
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 1, 1, MatrixOrder.Append, new float[] { 20, 40, 120, 160, 50, 60 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), -2, -4, MatrixOrder.Prepend, new float[] { -20, -40, -120, -160, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), -2, -4, MatrixOrder.Append, new float[] { -20, -80, -60, -160, -100, -240 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, float.NaN, MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, float.NaN, MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Prepend, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Append, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Prepend, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Append, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.MaxValue, float.MaxValue, MatrixOrder.Prepend, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.MaxValue, float.MaxValue, MatrixOrder.Append, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Scale_TestData))]
-    public void Scale_Matrix_Succss(Matrix matrix, float scaleX, float scaleY, MatrixOrder order, float[] expectedElements)
-    {
-        using (matrix)
-        {
-            if (order == MatrixOrder.Prepend)
-            {
-                using (Matrix clone = matrix.Clone())
-                {
-                    clone.Scale(scaleX, scaleY);
-                    Assert.Equal(expectedElements, clone.Elements, new FloatingPointToleranceComparerer<float>(0.00001f));
-                }
-            }
-
-            matrix.Scale(scaleX, scaleY, order);
-            Assert.Equal(expectedElements, matrix.Elements);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void Scale_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Shear(1, 2, order));
-        }
-    }
-
-    [Fact]
-    public void Scale_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Scale(1, 2));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Scale(1, 2, MatrixOrder.Append));
-    }
-
-    public static IEnumerable<object[]> Shear_TestData()
-    {
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 2, 4, MatrixOrder.Prepend, new float[] { 130, 180, 50, 80, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), 2, 4, MatrixOrder.Append, new float[] { 50, 60, 110, 160, 170, 260 } };
-
-        yield return new object[] { new Matrix(5, 3, 9, 2, 2, 1), 10, 20, MatrixOrder.Prepend, new float[] { 185, 43, 59, 32, 2, 1 } };
-        yield return new object[] { new Matrix(5, 3, 9, 2, 2, 1), 10, 20, MatrixOrder.Append, new float[] { 35, 103, 29, 182, 12, 41 } };
-
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0, 0, MatrixOrder.Prepend, new float[] { 20, 40, 120, 160, 50, 60 } };
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 0, 0, MatrixOrder.Append, new float[] { 20, 40, 120, 160, 50, 60 } };
-
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 1, 1, MatrixOrder.Prepend, new float[] { 140, 200, 140, 200, 50, 60 } };
-        yield return new object[] { new Matrix(20, 40, 120, 160, 50, 60), 1, 1, MatrixOrder.Append, new float[] { 60, 60, 280, 280, 110, 110 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), -2, -4, MatrixOrder.Prepend, new float[] { -110, -140, 10, 0, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), -2, -4, MatrixOrder.Append, new float[] { -30, -20, -50, -80, -70, -140 } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, float.NaN, MatrixOrder.Prepend, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NaN, float.NaN, MatrixOrder.Append, new float[] { float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Prepend, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Append, new float[] { float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Prepend, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Append, new float[] { float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity } };
-
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.MaxValue, float.MaxValue, MatrixOrder.Prepend, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, 50, 60 } };
-        yield return new object[] { new Matrix(10, 20, 30, 40, 50, 60), float.MaxValue, float.MaxValue, MatrixOrder.Append, new float[] { float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Shear_TestData))]
-    public void Shear_Matrix_Succss(Matrix matrix, float shearX, float shearY, MatrixOrder order, float[] expectedElements)
-    {
-        using (matrix)
-        {
-            if (order == MatrixOrder.Prepend)
-            {
-                using (Matrix clone = matrix.Clone())
-                {
-                    clone.Shear(shearX, shearY);
-                    Assert.Equal(expectedElements, clone.Elements, new FloatingPointToleranceComparerer<float>(0.00001f));
-                }
-            }
-
-            matrix.Shear(shearX, shearY, order);
-            Assert.Equal(expectedElements, matrix.Elements);
-        }
-    }
-
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void Shear_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Shear(1, 2, order));
-        }
-    }
-
-    [Fact]
-    public void Shear_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Shear(1, 2));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Shear(1, 2, MatrixOrder.Append));
-    }
-
-    public static IEnumerable<object[]> Translate_TestData()
-    {
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), 5, 10, MatrixOrder.Prepend, new float[] { 2, 4, 6, 8, 80, 112 } };
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), 5, 10, MatrixOrder.Append, new float[] { 2, 4, 6, 8, 15, 22 } };
-
-        yield return new object[] { new Matrix(), 5, 10, MatrixOrder.Prepend, new float[] { 1, 0, 0, 1, 5, 10 } };
-        yield return new object[] { new Matrix(), 5, 10, MatrixOrder.Append, new float[] { 1, 0, 0, 1, 5, 10 } };
-
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.NaN, float.NaN, MatrixOrder.Prepend, new float[] { 1, 2, 3, 4, float.NaN, float.NaN } };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.NaN, float.NaN, MatrixOrder.Append, new float[] { 1, 2, 3, 4, float.NaN, float.NaN } };
-
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Prepend, new float[] { 1, 2, 3, 4, float.PositiveInfinity, float.PositiveInfinity } };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.PositiveInfinity, float.PositiveInfinity, MatrixOrder.Append, new float[] { 1, 2, 3, 4, float.PositiveInfinity, float.PositiveInfinity } };
-
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Prepend, new float[] { 1, 2, 3, 4, float.NegativeInfinity, float.NegativeInfinity } };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.NegativeInfinity, float.NegativeInfinity, MatrixOrder.Append, new float[] { 1, 2, 3, 4, float.NegativeInfinity, float.NegativeInfinity } };
-
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.MaxValue, float.MaxValue, MatrixOrder.Prepend, new float[] { 1, 2, 3, 4, float.MaxValue, float.MaxValue } };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), float.MaxValue, float.MaxValue, MatrixOrder.Append, new float[] { 1, 2, 3, 4, float.MaxValue, float.MaxValue } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Translate_TestData))]
-    public void Translate_Matrix_Success(Matrix matrix, float offsetX, float offsetY, MatrixOrder order, float[] expectedElements)
-    {
-        using (matrix)
-        {
-            if (order == MatrixOrder.Prepend)
-            {
-                using (Matrix clone = matrix.Clone())
-                {
-                    clone.Translate(offsetX, offsetY);
-                    Assert.Equal(expectedElements, clone.Elements, new FloatingPointToleranceComparerer<float>(0.00001f));
-                }
-            }
-
-            matrix.Translate(offsetX, offsetY, order);
-            Assert.Equal(expectedElements, matrix.Elements, new FloatingPointToleranceComparerer<float>(0.00001f));
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void Translate_InvalidMatrixOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.Translate(1, 2, order));
-        }
-    }
-
-    [Fact]
-    public void Translate_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Translate(1, 2));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.Translate(1, 2, MatrixOrder.Append));
-    }
-
-    public static IEnumerable<object[]> TransformPoints_TestData()
-    {
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), new Point[] { new Point(2, 4), new Point(4, 8) }, new Point[] { new Point(38, 52), new Point(66, 92) } };
-        yield return new object[] { new Matrix(), new Point[] { new Point(2, 4), new Point(4, 8) }, new Point[] { new Point(2, 4), new Point(4, 8) } };
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), new Point[1], new Point[] { new Point(10, 12) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformPoints_TestData))]
-    public void TransformPoints_Point_Success(Matrix matrix, Point[] points, Point[] expectedPoints)
-    {
-        using (matrix)
-        {
-            matrix.TransformPoints(points);
-            Assert.Equal(expectedPoints, points);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformPoints_TestData))]
-    public void TransformPoints_PointF_Success(Matrix matrix, Point[] points, Point[] expectedPoints)
-    {
-        using (matrix)
-        {
-            PointF[] pointFs = points.Select(p => (PointF)p).ToArray();
-            matrix.TransformPoints(pointFs);
-            Assert.Equal(expectedPoints.Select(p => (PointF)p), pointFs);
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => matrix.TransformPoints((Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => matrix.TransformPoints((PointF[])null));
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_EmptyPoints_ThrowsArgumentException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.TransformPoints(new Point[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.TransformPoints(new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.TransformPoints(new Point[1]));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.TransformPoints(new PointF[1]));
-    }
-
-    public static IEnumerable<object[]> TransformVectors_TestData()
-    {
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), new Point[] { new Point(2, 4), new Point(4, 8) }, new Point[] { new Point(28, 40), new Point(56, 80) } };
-        yield return new object[] { new Matrix(), new Point[] { new Point(2, 4), new Point(4, 8) }, new Point[] { new Point(2, 4), new Point(4, 8) } };
-        yield return new object[] { new Matrix(2, 4, 6, 8, 10, 12), new Point[1], new Point[1] };
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformVectors_TestData))]
-    public void TransformVectors_Point_Success(Matrix matrix, Point[] points, Point[] expectedPoints)
-    {
-        using (matrix)
-        {
-            matrix.TransformVectors(points);
-            Assert.Equal(expectedPoints, points);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformVectors_TestData))]
-    public void TransformVectors_PointF_Success(Matrix matrix, Point[] points, Point[] expectedPoints)
-    {
-        using (matrix)
-        {
-            PointF[] pointFs = points.Select(p => (PointF)p).ToArray();
-            matrix.TransformVectors(pointFs);
-            Assert.Equal(expectedPoints.Select(p => (PointF)p), pointFs);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformVectors_TestData))]
-    public void VectorTransformPoints_Points_Success(Matrix matrix, Point[] points, Point[] expectedPoints)
-    {
-        using (matrix)
-        {
-            matrix.VectorTransformPoints(points);
-            Assert.Equal(expectedPoints, points);
-        }
-    }
-
-    [Fact]
-    public void TransformVectors_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => matrix.VectorTransformPoints(null));
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => matrix.TransformVectors((Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => matrix.TransformVectors((PointF[])null));
-        }
-    }
-
-    [Fact]
-    public void TransformVectors_EmptyPoints_ThrowsArgumentException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.VectorTransformPoints(new Point[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.TransformVectors(new Point[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => matrix.TransformVectors(new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void TransformVectors_Disposed_ThrowsArgumentException()
-    {
-        Matrix disposedMatrix = CreateDisposedMatrix();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.VectorTransformPoints(new Point[1]));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.TransformPoints(new Point[1]));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedMatrix.TransformVectors(new PointF[1]));
-    }
-
-    private static void AssertEqualFloatArray(float[] expected, float[] actual)
-    {
-        Assert.Equal(expected.Length, actual.Length);
-        for (int i = 0; i < expected.Length; i++)
-        {
-            try
-            {
-                Assert.Equal(expected[i], actual[i], precision: 3);
-            }
-            catch
-            {
-                Console.WriteLine(i);
-                Console.WriteLine($"Expected: {string.Join(", ", expected)}");
-                Console.WriteLine($"Actual: {string.Join(", ", actual)}");
-                throw;
-            }
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Drawing2D/PathGradientBrushTests.cs b/src/System.Drawing.Common/tests/Drawing2D/PathGradientBrushTests.cs
deleted file mode 100644
index a329ae6c352..00000000000
--- a/src/System.Drawing.Common/tests/Drawing2D/PathGradientBrushTests.cs
+++ /dev/null
@@ -1,1069 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-namespace System.Drawing.Drawing2D.Tests;
-
-public class PathGradientBrushTests
-{
-    private readonly Point[] _defaultIntPoints = new Point[2] { new Point(1, 2), new Point(20, 30) };
-    private readonly PointF[] _defaultFloatPoints = new PointF[2] { new PointF(1, 2), new PointF(20, 30) };
-    private readonly RectangleF _defaultRectangle = new(1, 2, 19, 28);
-
-    [Fact]
-    public void Ctor_Points_ReturnsExpected()
-    {
-        using (PathGradientBrush bi = new PathGradientBrush(_defaultIntPoints))
-        using (PathGradientBrush bf = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertDefaults(bi);
-            Assert.Equal(WrapMode.Clamp, bi.WrapMode);
-            AssertDefaults(bf);
-            Assert.Equal(WrapMode.Clamp, bf.WrapMode);
-        }
-    }
-
-    public static IEnumerable<object[]> WrapMode_TestData()
-    {
-        yield return new object[] { WrapMode.Clamp };
-        yield return new object[] { WrapMode.Tile };
-        yield return new object[] { WrapMode.TileFlipX };
-        yield return new object[] { WrapMode.TileFlipXY };
-        yield return new object[] { WrapMode.TileFlipY };
-    }
-
-    [Theory]
-    [MemberData(nameof(WrapMode_TestData))]
-    public void Ctor_PointsWrapMode_ReturnsExpected(WrapMode wrapMode)
-    {
-        using (PathGradientBrush brushInt = new PathGradientBrush(_defaultIntPoints, wrapMode))
-        using (PathGradientBrush brushFloat = new PathGradientBrush(_defaultFloatPoints, wrapMode))
-        {
-            AssertDefaults(brushInt);
-            Assert.Equal(wrapMode, brushInt.WrapMode);
-            AssertDefaults(brushFloat);
-            Assert.Equal(wrapMode, brushFloat.WrapMode);
-        }
-    }
-
-    [Fact]
-    public void Ctor_PointsNull_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("points", () => new PathGradientBrush((Point[])null));
-        AssertExtensions.Throws<ArgumentNullException>("points", () => new PathGradientBrush((PointF[])null));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_PointsLengthLessThenTwo_ThrowsOutOfMemoryException(int pointsLength)
-    {
-        Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(new Point[pointsLength]));
-        Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(new Point[pointsLength], WrapMode.Clamp));
-        Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(new PointF[pointsLength]));
-        Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(new PointF[pointsLength], WrapMode.Clamp));
-    }
-
-    [Fact]
-    public void Ctor_InvalidWrapMode_ThrowsInvalidEnumArgumentException()
-    {
-        Assert.ThrowsAny<ArgumentException>(() =>
-            new PathGradientBrush(_defaultIntPoints, (WrapMode)int.MaxValue));
-
-        Assert.ThrowsAny<ArgumentException>(() =>
-            new PathGradientBrush(_defaultFloatPoints, (WrapMode)int.MaxValue));
-    }
-
-    [Fact]
-    public void Ctor_Path_ReturnsExpected()
-    {
-        using (GraphicsPath path = new GraphicsPath(_defaultFloatPoints, new byte[] { 0, 1 }))
-        using (PathGradientBrush brush = new PathGradientBrush(path))
-        {
-            AssertDefaults(brush);
-            Assert.Equal(WrapMode.Clamp, brush.WrapMode);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Path_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new PathGradientBrush((GraphicsPath)null));
-    }
-
-    [Fact]
-    public void Ctor_PathWithLessThenTwoPoints_ThrowsOutOfMemoryException()
-    {
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(path));
-            path.AddLines(new PointF[] { new PointF(1, 1) });
-            Assert.Throws<OutOfMemoryException>(() => new PathGradientBrush(path));
-        }
-    }
-
-    [Fact]
-    public void Clone_ReturnsExpected()
-    {
-        using (GraphicsPath path = new GraphicsPath(_defaultFloatPoints, new byte[] { 0, 1 }))
-        using (PathGradientBrush brush = new PathGradientBrush(path))
-        using (PathGradientBrush clone = Assert.IsType<PathGradientBrush>(brush.Clone()))
-        {
-            AssertDefaults(clone);
-            Assert.Equal(WrapMode.Clamp, clone.WrapMode);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Clone());
-    }
-
-    [Fact]
-    public void CenterColor_ReturnsExpected()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.Equal(Color.Black.ToArgb(), brush.CenterColor.ToArgb());
-            brush.CenterColor = Color.Blue;
-            Assert.Equal(Color.Blue.ToArgb(), brush.CenterColor.ToArgb());
-            brush.CenterColor = Color.Transparent;
-            Assert.Equal(Color.Transparent.ToArgb(), brush.CenterColor.ToArgb());
-        }
-    }
-
-    [Fact]
-    public void CenterColor_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.CenterColor = Color.Blue);
-    }
-
-    [Fact]
-    public void SurroundColors_ReturnsExpected()
-    {
-        Color[] expectedColors = new Color[2] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 255, 0, 0) };
-        Color[] sameColors = new Color[2] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 255, 255, 0) };
-        Color[] expectedSameColors = new Color[1] { Color.FromArgb(255, 255, 255, 0) };
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SurroundColors = expectedColors;
-            Assert.Equal(expectedColors, brush.SurroundColors);
-            brush.SurroundColors = sameColors;
-            Assert.Equal(expectedSameColors, brush.SurroundColors);
-        }
-    }
-
-    [Fact]
-    public void SurroundColors_CannotChange()
-    {
-        Color[] colors = new Color[2] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 255, 0, 0) };
-        Color[] defaultColors = new Color[1] { Color.FromArgb(255, 255, 255, 255) };
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SurroundColors.ToList().AddRange(colors);
-            Assert.Equal(defaultColors, brush.SurroundColors);
-            brush.SurroundColors[0] = Color.FromArgb(255, 0, 0, 255);
-            Assert.NotEqual(Color.FromArgb(255, 0, 0, 255), brush.SurroundColors[0]);
-            Assert.Equal(defaultColors, brush.SurroundColors);
-        }
-    }
-
-    [Fact]
-    public void SurroundColors_Disposed_ThrowsArgumentException()
-    {
-        Color[] colors = new Color[2] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 255, 0, 0) };
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SurroundColors = colors);
-    }
-
-    public static IEnumerable<object[]> SurroundColors_InvalidColorsLength_TestData()
-    {
-        yield return new object[] { new Point[2] { new Point(1, 1), new Point(2, 2) }, new Color[0] };
-        yield return new object[] { new Point[2] { new Point(1, 1), new Point(2, 2) }, new Color[3] };
-    }
-
-    [Theory]
-    [MemberData(nameof(SurroundColors_InvalidColorsLength_TestData))]
-    public void SurroundColors_InvalidColorsLength_ThrowsArgumentException(Point[] points, Color[] colors)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(points))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.SurroundColors = colors);
-        }
-    }
-
-    [Fact]
-    public void SurroundColors_Null_ThrowsNullReferenceException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<NullReferenceException>(() => brush.SurroundColors = null);
-        }
-    }
-
-    [Fact]
-    public void CenterPoint_ReturnsExpected()
-    {
-        PointF centralPoint = new PointF(float.MaxValue, float.MinValue);
-        PointF defaultCentralPoint = new PointF(10.5f, 16f);
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints, WrapMode.TileFlipXY))
-        {
-            Assert.Equal(defaultCentralPoint, brush.CenterPoint);
-            brush.CenterPoint = centralPoint;
-            Assert.Equal(centralPoint, brush.CenterPoint);
-
-            centralPoint.X = float.NaN;
-            centralPoint.Y = float.NegativeInfinity;
-            brush.CenterPoint = centralPoint;
-            Assert.Equal(float.NaN, brush.CenterPoint.X);
-            Assert.Equal(float.NegativeInfinity, brush.CenterPoint.Y);
-        }
-    }
-
-    [Fact]
-    public void CenterPoint_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.CenterPoint);
-    }
-
-    public static IEnumerable<object[]> Blend_FactorsPositions_TestData()
-    {
-        yield return new object[] { new float[1] { 1 }, new float[1] { 0 } };
-        yield return new object[] { new float[2] { 1, 1 }, new float[2] { 0, 1 } };
-        yield return new object[] { new float[3] { 1, 0, 1 }, new float[3] { 0, 3, 1 } };
-        yield return new object[] { new float[1] { 1 }, new float[3] { 0, 3, 1 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Blend_FactorsPositions_TestData))]
-    public void Blend_ReturnsExpected(float[] factors, float[] positions)
-    {
-        int expectedSize = factors.Length;
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints, WrapMode.TileFlipXY))
-        {
-            brush.Blend = new Blend { Factors = factors, Positions = positions };
-            Assert.Equal(factors, brush.Blend.Factors);
-            Assert.Equal(expectedSize, brush.Blend.Positions.Length);
-            if (expectedSize == positions.Length && expectedSize != 1)
-            {
-                Assert.Equal(factors, brush.Blend.Factors);
-                Assert.Equal(positions, brush.Blend.Positions);
-            }
-            else
-            {
-                Assert.Equal(factors, brush.Blend.Factors);
-                Assert.Equal(1, brush.Blend.Positions.Length);
-            }
-        }
-    }
-
-    [Fact]
-    public void Blend_CannotChange()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints, WrapMode.TileFlipXY))
-        {
-            brush.Blend.Factors = new float[0];
-            Assert.Equal(1, brush.Blend.Factors.Length);
-            brush.Blend.Factors = new float[2];
-            Assert.Equal(1, brush.Blend.Factors.Length);
-            brush.Blend.Positions = new float[0];
-            Assert.Equal(1, brush.Blend.Positions.Length);
-            brush.Blend.Positions = new float[2];
-            Assert.Equal(1, brush.Blend.Positions.Length);
-        }
-    }
-
-    [Fact]
-    public void Blend_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend);
-    }
-
-    public static IEnumerable<object[]> Blend_InvalidFactorsPositions_TestData()
-    {
-        yield return new object[] { new Blend() { Factors = new float[0], Positions = new float[0] } };
-        yield return new object[] { new Blend() { Factors = new float[2], Positions = new float[2] { 1, 1 } } };
-        yield return new object[] { new Blend() { Factors = new float[2], Positions = new float[2] { 0, 5 } } };
-        yield return new object[] { new Blend() { Factors = new float[3], Positions = new float[3] { 0, 1, 5 } } };
-        yield return new object[] { new Blend() { Factors = new float[3], Positions = new float[3] { 1, 1, 1 } } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Blend_InvalidFactorsPositions_TestData))]
-    public void Blend_InvalidFactorPositions_ThrowsArgumentException(Blend blend)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Blend = blend);
-        }
-    }
-
-    [Fact]
-    public void Blend_InvalidFactorPositionsLengthMismatch_ThrowsArgumentOutOfRangeException()
-    {
-        Blend invalidBlend = new Blend() { Factors = new float[2], Positions = new float[1] };
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException>("value", null, () => brush.Blend = invalidBlend);
-        }
-    }
-
-    [Fact]
-    public void Blend_Null_ThrowsNullReferenceException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.Blend = null);
-            Assert.Throws<NullReferenceException>(() => brush.Blend = new Blend() { Factors = null, Positions = null});
-            Assert.Throws<NullReferenceException>(() => brush.Blend = new Blend() { Factors = null, Positions = new float[0] });
-        }
-    }
-
-    [Fact]
-    public void Blend_NullBlendProperites_ThrowsArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException, ArgumentNullException>("value", "source", () =>
-                brush.Blend = new Blend() { Factors = new float[0], Positions = null });
-        }
-    }
-
-    [Theory]
-    [InlineData(1f)]
-    [InlineData(0f)]
-    [InlineData(0.5f)]
-    public void SetSigmaBellShape_Focus_Success(float focus)
-    {
-        float defaultScale = 1f;
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SetSigmaBellShape(focus);
-            Assert.True(brush.Transform.IsIdentity);
-            if (focus == 0f)
-            {
-                Assert.Equal(focus, brush.Blend.Positions[0]);
-                Assert.Equal(defaultScale, brush.Blend.Factors[0]);
-                Assert.Equal(1f, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(0f, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-            else if (focus == 1f)
-            {
-                Assert.Equal(0f, brush.Blend.Positions[0]);
-                Assert.Equal(0f, brush.Blend.Factors[0]);
-                Assert.Equal(focus, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(defaultScale, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-            else
-            {
-                Assert.Equal(0f, brush.Blend.Positions[0]);
-                Assert.Equal(0f, brush.Blend.Factors[0]);
-                Assert.Equal(1f, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(0f, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(1f)]
-    [InlineData(0f)]
-    [InlineData(0.5f)]
-    public void SetSigmaBellShape_FocusScale_Success(float focus)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SetSigmaBellShape(focus);
-            Assert.True(brush.Transform.IsIdentity);
-            if (focus == 0f)
-            {
-                Assert.Equal(256, brush.Blend.Positions.Length);
-                Assert.Equal(256, brush.Blend.Factors.Length);
-                Assert.Equal(focus, brush.Blend.Positions[0]);
-                Assert.Equal(1f, brush.Blend.Factors[0]);
-                Assert.Equal(1f, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(0f, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-            else if (focus == 1f)
-            {
-                Assert.Equal(256, brush.Blend.Positions.Length);
-                Assert.Equal(256, brush.Blend.Factors.Length);
-                Assert.Equal(0f, brush.Blend.Positions[0]);
-                Assert.Equal(0f, brush.Blend.Factors[0]);
-                Assert.Equal(focus, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(1f, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-            else
-            {
-                Assert.Equal(511, brush.Blend.Positions.Length);
-                Assert.Equal(511, brush.Blend.Factors.Length);
-                Assert.Equal(0f, brush.Blend.Positions[0]);
-                Assert.Equal(0f, brush.Blend.Factors[0]);
-                Assert.Equal(focus, brush.Blend.Positions[255]);
-                Assert.Equal(1f, brush.Blend.Factors[255]);
-                Assert.Equal(1f, brush.Blend.Positions[brush.Blend.Positions.Length - 1]);
-                Assert.Equal(0f, brush.Blend.Factors[brush.Blend.Factors.Length - 1]);
-            }
-        }
-    }
-
-    [Fact]
-    public void SetSigmaBellShape_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetSigmaBellShape(1f));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetSigmaBellShape(1f, 1f));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1.1f)]
-    public void SetSigmaBellShape_InvalidFocus_ThrowsArgumentException(float focus)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetSigmaBellShape(focus));
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetSigmaBellShape(focus, 1f));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1.1f)]
-    public void SetSigmaBellShape_InvalidScale_ThrowsArgumentException(float scale)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>("scale", null, () => brush.SetSigmaBellShape(1f, scale));
-        }
-    }
-
-    [Theory]
-    [InlineData(1f)]
-    [InlineData(0f)]
-    [InlineData(0.5f)]
-    public void SetBlendTriangularShape_Focus_Success(float focus)
-    {
-        float defaultScale = 1f;
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SetBlendTriangularShape(focus);
-            Assert.True(brush.Transform.IsIdentity);
-            if (focus == 0f)
-            {
-                Assert.Equal(new float[2] { defaultScale, 0f }, brush.Blend.Factors);
-                Assert.Equal(new float[2] { focus, 1f }, brush.Blend.Positions);
-            }
-            else if (focus == 1f)
-            {
-                Assert.Equal(new float[2] { 0f, defaultScale }, brush.Blend.Factors);
-                Assert.Equal(new float[2] { 0f, focus }, brush.Blend.Positions);
-            }
-            else
-            {
-                Assert.Equal(new float[3] { 0f, defaultScale, 0f }, brush.Blend.Factors);
-                Assert.Equal(new float[3] { 0f, focus, 1f }, brush.Blend.Positions);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(1f)]
-    [InlineData(0f)]
-    [InlineData(0.5f)]
-    public void SetBlendTriangularShape_FocusScale_Success(float focus)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.SetBlendTriangularShape(focus);
-            Assert.True(brush.Transform.IsIdentity);
-            Assert.True(brush.Transform.IsIdentity);
-            if (focus == 0f)
-            {
-                Assert.Equal(new float[2] { 1f, 0f }, brush.Blend.Factors);
-                Assert.Equal(new float[2] { focus, 1f }, brush.Blend.Positions);
-            }
-            else if (focus == 1f)
-            {
-                Assert.Equal(new float[2] { 0f, 1f }, brush.Blend.Factors);
-                Assert.Equal(new float[2] { 0f, focus }, brush.Blend.Positions);
-            }
-            else
-            {
-                Assert.Equal(new float[3] { 0f, 1f, 0f }, brush.Blend.Factors);
-                Assert.Equal(new float[3] { 0f, focus, 1f }, brush.Blend.Positions);
-            }
-        }
-    }
-
-    [Fact]
-    public void SetBlendTriangularShape_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetBlendTriangularShape(1f));
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.SetBlendTriangularShape(1f, 1f));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1.1f)]
-    public void SetBlendTriangularShape_InvalidFocus_ThrowsArgumentException(float focus)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetBlendTriangularShape(focus));
-            AssertExtensions.Throws<ArgumentException>("focus", null, () => brush.SetBlendTriangularShape(focus, 1f));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1.1f)]
-    public void SetBlendTriangularShape_InvalidScale_ThrowsArgumentException(float scale)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>("scale", null, () => brush.SetBlendTriangularShape(1f, scale));
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_ReturnsExpected()
-    {
-        Color[] expectedColors = new Color[2] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 255, 0, 0) };
-        float[] expectedPositions = new float[] { 0, 1 };
-        Color[] sameColors = new Color[2] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 255, 255, 0) };
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.InterpolationColors = new ColorBlend() { Colors = expectedColors, Positions = expectedPositions };
-            Assert.Equal(expectedColors, brush.InterpolationColors.Colors);
-            Assert.Equal(expectedPositions, brush.InterpolationColors.Positions);
-
-            brush.InterpolationColors = new ColorBlend() { Colors = sameColors, Positions = expectedPositions };
-            Assert.Equal(sameColors, brush.InterpolationColors.Colors);
-            Assert.Equal(expectedPositions, brush.InterpolationColors.Positions);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_CannotChange()
-    {
-        Color[] colors = new Color[2] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 255, 0, 0) };
-        Color[] defaultColors = new Color[1] { Color.Empty };
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.InterpolationColors.Colors.ToList().AddRange(colors);
-            Assert.Equal(defaultColors, brush.InterpolationColors.Colors);
-            brush.InterpolationColors.Colors = colors;
-            Assert.Equal(defaultColors, brush.InterpolationColors.Colors);
-            brush.InterpolationColors.Colors[0] = Color.Pink;
-            Assert.NotEqual(Color.Pink, brush.InterpolationColors.Colors[0]);
-            Assert.Equal(defaultColors, brush.InterpolationColors.Colors);
-            brush.InterpolationColors.Positions = new float[0];
-            Assert.Equal(1, brush.InterpolationColors.Positions.Length);
-            brush.InterpolationColors.Positions = new float[2];
-            Assert.Equal(1, brush.InterpolationColors.Positions.Length);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors);
-    }
-
-    [Fact]
-    public void InterpolationColors_Null_ThrowsNullReferenceException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.Throws<NullReferenceException>(() => brush.InterpolationColors = null);
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_NullColors_ThrowsNullReferenceException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.Throws<NullReferenceException>(() =>
-                brush.InterpolationColors = new ColorBlend() { Colors = null, Positions = null });
-
-            Assert.Throws<NullReferenceException>(() =>
-                brush.InterpolationColors = new ColorBlend() { Colors = null, Positions = new float[2] });
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_NullPoints_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException, ArgumentNullException>("value", "source", () =>
-                brush.InterpolationColors = new ColorBlend() { Colors = new Color[1], Positions = null });
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_Empty_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.InterpolationColors = new ColorBlend());
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_EmptyColors_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                brush.InterpolationColors = new ColorBlend() { Colors = new Color[0], Positions = new float[0] });
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_PointsLengthGreaterThenColorsLength_ArgumentOutOfRangeException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("value", null, () =>
-                brush.InterpolationColors = new ColorBlend() { Colors = new Color[1], Positions = new float[2] });
-        }
-    }
-
-    [Fact]
-    public void InterpolationColors_ColorsLengthGreaterThenPointsLength_ThrowsArgumentOutOfRangeException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.Throws<ArgumentOutOfRangeException>(() =>
-                brush.InterpolationColors = new ColorBlend() { Colors = new Color[2], Positions = new float[1] });
-        }
-    }
-
-    [Fact]
-    public void Transform_ReturnsExpected()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix defaultMatrix = new Matrix(1, 0, 0, 1, 0, 0))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 1, 1))
-        {
-            Assert.Equal(defaultMatrix, brush.Transform);
-            brush.Transform = matrix;
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void Transform_EmptyMatrix_ReturnsExpected()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix())
-        {
-            brush.Transform = matrix;
-            Assert.True(brush.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void Transform_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform);
-    }
-
-    [Fact]
-    public void Transform_Null_ArgumentNullException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("value", "matrix", () => brush.Transform = null);
-        }
-    }
-
-    [Fact]
-    public void Transform_NonInvertible_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix nonInvertible = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform = nonInvertible);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Success()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix defaultMatrix = new Matrix(1, 0, 0, 1, 0, 0))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 1, 1))
-        {
-            Assert.Equal(defaultMatrix, brush.Transform);
-            brush.Transform = matrix;
-            Assert.Equal(matrix, brush.Transform);
-            brush.ResetTransform();
-            Assert.Equal(defaultMatrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ResetTransform());
-    }
-
-    [Fact]
-    public void MultiplyTransform_Matrix_Success()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix defaultMatrix = new Matrix(1, 0, 0, 1, 0, 0))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 1, 1))
-        {
-            defaultMatrix.Multiply(matrix, MatrixOrder.Prepend);
-            brush.MultiplyTransform(matrix);
-            Assert.Equal(defaultMatrix, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Append)]
-    [InlineData(MatrixOrder.Prepend)]
-    public void MultiplyTransform_MatrixMatrixOrder_Success(MatrixOrder matrixOrder)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix defaultMatrix = new Matrix(1, 0, 0, 1, 0, 0))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 1, 1))
-        {
-            defaultMatrix.Multiply(matrix, matrixOrder);
-            brush.MultiplyTransform(matrix, matrixOrder);
-            Assert.Equal(defaultMatrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Disposed_ThrowsArgumentException()
-    {
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 1, 1))
-        {
-            PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null));
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_DisposedMatrix_Nop()
-    {
-        using (var brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix transform = brush.Transform)
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            brush.MultiplyTransform(matrix);
-            brush.MultiplyTransform(matrix, MatrixOrder.Append);
-
-            Assert.Equal(transform, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_InvalidMatrixOrder_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 1, 1, 1, 1, 1))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix, (MatrixOrder)int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NonInvertible_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix nonInvertible = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(nonInvertible));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(nonInvertible, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Offset_Success()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Translate(20f, 30f, MatrixOrder.Prepend);
-            brush.TranslateTransform(20f, 30f);
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Append)]
-    [InlineData(MatrixOrder.Prepend)]
-    public void TranslateTransform_OffsetMatrixOrder_Success(MatrixOrder matrixOrder)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Translate(20f, 30f, matrixOrder);
-            brush.TranslateTransform(20f, 30f, matrixOrder);
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(20f, 30f, MatrixOrder.Append));
-    }
-
-    [Fact]
-    public void TranslateTransform_InvalidMatrixOrder_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(20f, 30f, (MatrixOrder)int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Scale_Success()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Scale(2, 4, MatrixOrder.Prepend);
-            brush.ScaleTransform(2, 4);
-            Assert.Equal(matrix, brush.Transform);
-
-            matrix.Scale(0.5f, 0.25f, MatrixOrder.Prepend);
-            brush.ScaleTransform(0.5f, 0.25f);
-            Assert.True(brush.Transform.IsIdentity);
-
-            matrix.Scale(float.MaxValue, float.MinValue, MatrixOrder.Prepend);
-            brush.ScaleTransform(float.MaxValue, float.MinValue);
-            Assert.Equal(matrix, brush.Transform);
-
-            matrix.Scale(float.MinValue, float.MaxValue, MatrixOrder.Prepend);
-            brush.ScaleTransform(float.MinValue, float.MaxValue);
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Append)]
-    [InlineData(MatrixOrder.Prepend)]
-    public void ScaleTransform_ScaleMatrixOrder_Success(MatrixOrder matrixOrder)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Scale(0.25f, 2, matrixOrder);
-            brush.ScaleTransform(0.25f, 2, matrixOrder);
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(0.25f, 2, MatrixOrder.Append));
-    }
-
-    [Fact]
-    public void ScaleTransform_InvalidMatrixOrder_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(1, 1, (MatrixOrder)int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Angle_Success()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Rotate(90, MatrixOrder.Prepend);
-            brush.RotateTransform(90);
-            Assert.Equal(matrix, brush.Transform);
-
-            brush.RotateTransform(270);
-            Assert.True(brush.Transform.IsIdentity);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Append)]
-    [InlineData(MatrixOrder.Prepend)]
-    public void RotateTransform_AngleMatrixOrder_Success(MatrixOrder matrixOrder)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        using (Matrix matrix = new Matrix(1, 0, 0, 1, 0, 0))
-        {
-            matrix.Rotate(45, matrixOrder);
-            brush.RotateTransform(45, matrixOrder);
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(45, MatrixOrder.Append));
-    }
-
-    [Fact]
-    public void RotateTransform_InvalidMatrixOrder_ArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(45, (MatrixOrder)int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void FocusScales_ReturnsExpected()
-    {
-        var point = new PointF(2.5f, 3.4f);
-
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.FocusScales = point;
-            Assert.Equal(point, brush.FocusScales);
-        }
-    }
-
-    [Fact]
-    public void FocusScales_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.FocusScales);
-    }
-
-    [Theory]
-    [MemberData(nameof(WrapMode_TestData))]
-    public void WrapMode_ReturnsExpected(WrapMode wrapMode)
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            brush.WrapMode = wrapMode;
-            Assert.Equal(wrapMode, brush.WrapMode);
-        }
-    }
-
-    [Fact]
-    public void WrapMode_Disposed_ThrowsArgumentException()
-    {
-        PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode);
-    }
-
-    [Fact]
-    public void WrapMode_Invalid_InvalidEnumArgumentException()
-    {
-        using (PathGradientBrush brush = new PathGradientBrush(_defaultFloatPoints))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => brush.WrapMode = (WrapMode)int.MinValue);
-        }
-    }
-
-    private void AssertDefaults(PathGradientBrush brush)
-    {
-        Assert.Equal(_defaultRectangle, brush.Rectangle);
-        Assert.Equal(new float[] { 1 }, brush.Blend.Factors);
-        Assert.Equal(1, brush.Blend.Positions.Length);
-        Assert.Equal(new PointF(10.5f, 16f), brush.CenterPoint);
-        Assert.Equal(new Color[] { Color.Empty }, brush.InterpolationColors.Colors);
-        Assert.Equal(new Color[] { Color.FromArgb(255, 255, 255, 255) }, brush.SurroundColors);
-        Assert.Equal(new float[] { 0 }, brush.InterpolationColors.Positions);
-        Assert.True(brush.Transform.IsIdentity);
-        Assert.True(brush.FocusScales.IsEmpty);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/DrawingTest.cs b/src/System.Drawing.Common/tests/DrawingTest.cs
deleted file mode 100644
index aebef3cd9ff..00000000000
--- a/src/System.Drawing.Common/tests/DrawingTest.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Imaging;
-
-namespace System.Drawing.Tests;
-
-public abstract class DrawingTest
-{
-    private static Security.Cryptography.MD5 s_md5 = Security.Cryptography.MD5.Create();
-
-    protected unsafe void ValidateBitmapContent(Bitmap bitmap, params byte[] expectedHash)
-    {
-        BitmapData data = bitmap.LockBits(new Rectangle(default, bitmap.Size), ImageLockMode.ReadWrite, bitmap.PixelFormat);
-        try
-        {
-            byte[] hash = new byte[expectedHash.Length];
-            if (!s_md5.TryComputeHash(
-                new ReadOnlySpan<byte>((void*)data.Scan0, data.Stride * data.Height),
-                hash,
-                out _))
-            {
-                Assert.Fail("Could not compute hash.");
-            }
-
-            Assert.Equal(expectedHash, hash);
-        }
-        finally
-        {
-            bitmap.UnlockBits(data);
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/FontFamilyTests.cs b/src/System.Drawing.Common/tests/FontFamilyTests.cs
deleted file mode 100644
index 6c740802544..00000000000
--- a/src/System.Drawing.Common/tests/FontFamilyTests.cs
+++ /dev/null
@@ -1,297 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Text;
-
-namespace System.Drawing.Tests;
-
-public class FontFamilyTests
-{
-    [Theory]
-    [InlineData(GenericFontFamilies.Serif - 1, "Courier New")] // Value is outside the enum range.
-    [InlineData(GenericFontFamilies.Monospace + 1, "Courier New")] // Value is outside the enum range.
-    [InlineData(GenericFontFamilies.Monospace, "Courier New")]
-    [InlineData(GenericFontFamilies.SansSerif, "Microsoft Sans Serif")]
-    [InlineData(GenericFontFamilies.Serif, "Times New Roman")]
-    public void Ctor_GenericFamily(GenericFontFamilies genericFamily, string expectedName)
-    {
-        using (var fontFamily = new FontFamily(genericFamily))
-        {
-            Assert.Equal(expectedName, fontFamily.Name);
-        }
-    }
-
-    [Theory]
-    [InlineData("Courier New", "Courier New")]
-    [InlineData("Microsoft Sans Serif", "Microsoft Sans Serif")]
-    [InlineData("Times New Roman", "Times New Roman")]
-    [InlineData("times new roman", "Times New Roman")]
-    public void Ctor_Name(string name, string expectedName)
-    {
-        using (var fontFamily = new FontFamily(name))
-        {
-            Assert.Equal(expectedName, fontFamily.Name);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Name_FontCollection()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            using (var fontFamily = new FontFamily("Code New Roman", fontCollection))
-            {
-                Assert.Equal("Code New Roman", fontFamily.Name);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("NoSuchFont")]
-    [InlineData("Serif")]
-    public void Ctor_NoSuchFontName_ThrowsArgumentException(string name)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new FontFamily(name));
-        AssertExtensions.Throws<ArgumentException>(null, () => new FontFamily(name, null));
-    }
-
-    [Fact]
-    public void Ctor_NoSuchFontNameInCollection_ThrowsArgumentException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new FontFamily("Times New Roman", fontCollection));
-        }
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        yield return new object[] { fontFamily, fontFamily, true };
-        yield return new object[] { FontFamily.GenericMonospace, FontFamily.GenericMonospace, true };
-        yield return new object[] { FontFamily.GenericMonospace, FontFamily.GenericSansSerif, false };
-
-        yield return new object[] { FontFamily.GenericSansSerif, new object(), false };
-        yield return new object[] { FontFamily.GenericSansSerif, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Object_ReturnsExpected(FontFamily fontFamily, object other, bool expected)
-    {
-        try
-        {
-            Assert.Equal(expected, fontFamily.Equals(other));
-        }
-        finally
-        {
-            fontFamily.Dispose();
-            (other as IDisposable)?.Dispose();
-        }
-    }
-
-    // This will fail on any platform we use libgdiplus, with any
-    // installed system fonts whose name is longer than 31 chars.
-    // macOS 10.15+ ships out of the box with a problem font
-    [Fact]
-    public void Families_Get_ReturnsExpected()
-    {
-#pragma warning disable 0618 // FontFamily.GetFamilies is deprecated.
-        using (var image = new Bitmap(10, 10))
-        using (var graphics = Graphics.FromImage(image))
-        {
-            FontFamily[] families = FontFamily.Families;
-            FontFamily[] familiesWithGraphics = FontFamily.GetFamilies(graphics);
-
-            // FontFamily.Equals uses the native handle to determine equality. However, GDI+ does not always
-            // cache handles, so we cannot just Assert.Equal(families, familiesWithGraphics);
-            Assert.Equal(families.Length, familiesWithGraphics.Length);
-
-            for (int i = 0; i < families.Length; i++)
-            {
-                Assert.Equal(families[i].Name, familiesWithGraphics[i].Name);
-            }
-
-            foreach (FontFamily fontFamily in families)
-            {
-                using (FontFamily copy = new FontFamily(fontFamily.Name))
-                {
-                    Assert.Equal(fontFamily.Name, copy.Name);
-                }
-            }
-        }
-#pragma warning restore 0618
-    }
-
-    [Fact]
-    public void GenericMonospace_Get_ReturnsExpected()
-    {
-        using (FontFamily fontFamily1 = FontFamily.GenericMonospace)
-        {
-            using (FontFamily fontFamily2 = FontFamily.GenericMonospace)
-            {
-                Assert.NotSame(fontFamily1, fontFamily2);
-                Assert.Equal("Courier New", fontFamily2.Name);
-            }
-        }
-    }
-
-    [Fact]
-    public void GenericSansSerif_Get_ReturnsExpected()
-    {
-        using (FontFamily fontFamily1 = FontFamily.GenericSansSerif)
-        {
-            using (FontFamily fontFamily2 = FontFamily.GenericSansSerif)
-            {
-                Assert.NotSame(fontFamily1, fontFamily2);
-                Assert.Equal("Microsoft Sans Serif", fontFamily2.Name);
-            }
-        }
-    }
-
-    [Fact]
-    public void GenericSerif_Get_ReturnsExpected()
-    {
-        using (FontFamily fontFamily1 = FontFamily.GenericSerif)
-        {
-            using (FontFamily fontFamily2 = FontFamily.GenericSerif)
-            {
-                Assert.NotSame(fontFamily1, fontFamily2);
-                Assert.Equal("Times New Roman", fontFamily2.Name);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetFamilies_NullGraphics_ThrowsArgumentNullException()
-    {
-#pragma warning disable 0618 // FontFamily.GetFamilies is deprecated.
-        AssertExtensions.Throws<ArgumentNullException>("graphics", () => FontFamily.GetFamilies(null));
-#pragma warning restore 0618
-    }
-
-    [Fact]
-    public void GetHashCode_Invoke_ReturnsNameHashCode()
-    {
-        using (FontFamily fontFamily = FontFamily.GenericSansSerif)
-        {
-            Assert.Equal(fontFamily.GetName(0).GetHashCode(), fontFamily.GetHashCode());
-        }
-    }
-
-    public static IEnumerable<object[]> FontStyle_TestData()
-    {
-        yield return new object[] { FontStyle.Bold };
-        yield return new object[] { FontStyle.Italic };
-        yield return new object[] { FontStyle.Regular };
-        yield return new object[] { FontStyle.Strikeout };
-        yield return new object[] { FontStyle.Strikeout };
-        yield return new object[] { FontStyle.Regular - 1 };
-        yield return new object[] { FontStyle.Strikeout + 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(FontStyle_TestData))]
-    public void FontFamilyProperties_CustomFont_ReturnsExpected(FontStyle style)
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            using (var fontFamily = new FontFamily("Code New Roman", fontCollection))
-            {
-                Assert.True(fontFamily.IsStyleAvailable(style));
-                Assert.Equal(1884, fontFamily.GetCellAscent(style));
-                Assert.Equal(514, fontFamily.GetCellDescent(style));
-                Assert.Equal(2048, fontFamily.GetEmHeight(style));
-                Assert.Equal(2398, fontFamily.GetLineSpacing(style));
-            }
-        }
-    }
-
-    [Fact]
-    public void IsStyleAvailable_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.IsStyleAvailable(FontStyle.Italic));
-    }
-
-    [Fact]
-    public void GetEmHeight_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.GetEmHeight(FontStyle.Italic));
-    }
-
-    private const int FrenchLCID = 1036;
-
-    [Theory]
-    [InlineData(-1, "Code New Roman")]
-    [InlineData(0, "Code New Roman")]
-    [InlineData(int.MaxValue, "Code New Roman")]
-    // This font has been modified to change the name to "Bonjour" if the language is French.
-    [InlineData(FrenchLCID, "Bonjour")]
-    public void GetName_LanguageCode_ReturnsExpected(int languageCode, string expectedName)
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.ttf"));
-
-            using (var fontFamily = new FontFamily("Code New Roman", fontCollection))
-            {
-                Assert.Equal(expectedName, fontFamily.GetName(languageCode));
-            }
-        }
-    }
-
-    [Fact]
-    public void GetName_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.GetName(0));
-    }
-
-    [Fact]
-    public void GetCellAscent_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.GetCellAscent(FontStyle.Italic));
-    }
-
-    [Fact]
-    public void GetCellDescent_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.GetCellDescent(FontStyle.Italic));
-    }
-
-    [Fact]
-    public void GetLineSpacing_Disposed_ThrowsArgumentException()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontFamily.GetLineSpacing(FontStyle.Italic));
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Nop()
-    {
-        FontFamily fontFamily = FontFamily.GenericMonospace;
-        fontFamily.Dispose();
-        fontFamily.Dispose();
-    }
-}
diff --git a/src/System.Drawing.Common/tests/FontTests.cs b/src/System.Drawing.Common/tests/FontTests.cs
deleted file mode 100644
index abfdaa64524..00000000000
--- a/src/System.Drawing.Common/tests/FontTests.cs
+++ /dev/null
@@ -1,975 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Text;
-using System.Runtime.InteropServices;
-
-namespace System.Drawing.Tests;
-
-public class FontTests
-{
-    public static IEnumerable<object[]> Ctor_Family_Size_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1 };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue };
-    }
-
-    public static IEnumerable<object[]> FontFamily_Equals_SameFamily_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1 };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue };
-        yield return new object[] { FontFamily.GenericSansSerif, 10 };
-    }
-
-    public static IEnumerable<object[]> FontFamily_Equals_DifferentFamily_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, FontFamily.GenericSerif };
-        yield return new object[] { FontFamily.GenericSansSerif, FontFamily.GenericSerif };
-        yield return new object[] { FontFamily.GenericSansSerif, FontFamily.GenericMonospace };
-    }
-
-    [Theory]
-    [MemberData(nameof(FontFamily_Equals_SameFamily_TestData))]
-    public void Font_Equals_SameFontFamily(FontFamily fontFamily, float size)
-    {
-        using (var font1 = new Font(fontFamily, size))
-        using (var font2 = new Font(fontFamily, size))
-        {
-            Assert.True(font1.Equals(font2));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(FontFamily_Equals_DifferentFamily_TestData))]
-    public void Font_Equals_DifferentFontFamily(FontFamily fontFamily1, FontFamily fontFamily2)
-    {
-        using (var font1 = new Font(fontFamily1, 9))
-        using (var font2 = new Font(fontFamily2, 9))
-        {
-            // In some Linux distros all the default fonts live under the same family (Fedora, Centos, Redhat)
-            if (font1.FontFamily.GetHashCode() != font2.FontFamily.GetHashCode())
-                Assert.False(font1.Equals(font2));
-        }
-    }
-
-    [Fact]
-    public void FontFamily_Equals_NullObject()
-    {
-        FontFamily nullFamily = null;
-        Assert.False(FontFamily.GenericMonospace.Equals(nullFamily));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_TestData))]
-    public void Ctor_Family_Size(FontFamily fontFamily, float emSize)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, FontStyle.Regular, GraphicsUnit.Point, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_TestData))]
-    public void Ctor_FamilyName_Size(FontFamily fontFamily, float emSize)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, FontStyle.Regular, GraphicsUnit.Point, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Family_Size_Style_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1, FontStyle.Bold };
-        yield return new object[] { FontFamily.GenericSerif, 2, FontStyle.Italic };
-        yield return new object[] { FontFamily.GenericSansSerif, 3, FontStyle.Regular };
-        yield return new object[] { FontFamily.GenericSerif, 4, FontStyle.Strikeout };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue, FontStyle.Underline };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)(-1) };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MinValue };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_TestData))]
-    public void Ctor_Family_Size_Style(FontFamily fontFamily, float emSize, FontStyle style)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize, style))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, GraphicsUnit.Point, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_TestData))]
-    public void Ctor_FamilyName_Size_Style(FontFamily fontFamily, float emSize, FontStyle style)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize, style))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, GraphicsUnit.Point, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Family_Size_Unit_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1, GraphicsUnit.Document };
-        yield return new object[] { FontFamily.GenericSerif, 2, GraphicsUnit.Inch };
-        yield return new object[] { FontFamily.GenericSansSerif, 3, GraphicsUnit.Millimeter };
-        yield return new object[] { FontFamily.GenericSerif, 4, GraphicsUnit.Point };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue, GraphicsUnit.Pixel };
-        yield return new object[] { FontFamily.GenericSerif, 16, GraphicsUnit.World };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Unit_TestData))]
-    public void Ctor_Family_Size_Unit(FontFamily fontFamily, float emSize, GraphicsUnit unit)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize, unit))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, FontStyle.Regular, unit, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Unit_TestData))]
-    public void Ctor_FamilyName_Size_Unit(FontFamily fontFamily, float emSize, GraphicsUnit unit)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize, unit))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, FontStyle.Regular, unit, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Family_Size_Style_Unit_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1, FontStyle.Bold, GraphicsUnit.Document };
-        yield return new object[] { FontFamily.GenericSerif, 2, FontStyle.Italic, GraphicsUnit.Inch };
-        yield return new object[] { FontFamily.GenericSansSerif, 3, FontStyle.Regular, GraphicsUnit.Millimeter };
-        yield return new object[] { FontFamily.GenericSerif, 4, FontStyle.Strikeout, GraphicsUnit.Point };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue, FontStyle.Underline, GraphicsUnit.Pixel };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)(-1), GraphicsUnit.World };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MinValue, GraphicsUnit.Millimeter };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MaxValue, GraphicsUnit.Millimeter };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_TestData))]
-    public void Ctor_Family_Size_Style_Unit(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize, style, unit))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_TestData))]
-    public void Ctor_FamilyName_Size_Style_Unit(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize, style, unit))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, 1, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Family_Size_Style_Unit_GdiCharSet_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1, FontStyle.Bold, GraphicsUnit.Document, 0 };
-        yield return new object[] { FontFamily.GenericSerif, 2, FontStyle.Italic, GraphicsUnit.Inch, 1 };
-        yield return new object[] { FontFamily.GenericSansSerif, 3, FontStyle.Regular, GraphicsUnit.Millimeter, 255 };
-        yield return new object[] { FontFamily.GenericSerif, 4, FontStyle.Strikeout, GraphicsUnit.Point, 10 };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue, FontStyle.Underline, GraphicsUnit.Pixel, 10 };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)(-1), GraphicsUnit.World, 8 };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MinValue, GraphicsUnit.Millimeter, 127 };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MaxValue, GraphicsUnit.Millimeter, 200 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_GdiCharSet_TestData))]
-    public void Ctor_Family_Size_Style_Unit_GdiCharSet(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize, style, unit, gdiCharSet))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, gdiCharSet, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_GdiCharSet_TestData))]
-    public void Ctor_FamilyName_Size_Style_Unit_GdiCharSet(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize, style, unit, gdiCharSet))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, gdiCharSet, false);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Family_Size_Style_Unit_GdiCharSet_GdiVerticalFont_TestData()
-    {
-        yield return new object[] { FontFamily.GenericMonospace, 1, FontStyle.Bold, GraphicsUnit.Document, 0, true };
-        yield return new object[] { FontFamily.GenericSerif, 2, FontStyle.Italic, GraphicsUnit.Inch, 1, false };
-        yield return new object[] { FontFamily.GenericSansSerif, 3, FontStyle.Regular, GraphicsUnit.Millimeter, 255, true };
-        yield return new object[] { FontFamily.GenericSerif, 4, FontStyle.Strikeout, GraphicsUnit.Point, 10, false };
-        yield return new object[] { FontFamily.GenericSerif, float.MaxValue, FontStyle.Underline, GraphicsUnit.Pixel, 10, true };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)(-1), GraphicsUnit.World, 8, false };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MinValue, GraphicsUnit.Millimeter, 127, true };
-        yield return new object[] { FontFamily.GenericSerif, 16, (FontStyle)int.MaxValue, GraphicsUnit.Millimeter, 200, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_GdiCharSet_GdiVerticalFont_TestData))]
-    public void Ctor_Family_Size_Style_Unit_GdiCharSet_GdiVerticalFont(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, bool gdiVerticalFont)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily, emSize, style, unit, gdiCharSet, gdiVerticalFont))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, gdiCharSet, gdiVerticalFont);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Family_Size_Style_Unit_GdiCharSet_GdiVerticalFont_TestData))]
-    public void Ctor_FamilyName_Size_Style_Unit_GdiCharSet_GdiVerticalFont(FontFamily fontFamily, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, bool gdiVerticalFont)
-    {
-        try
-        {
-            using (var font = new Font(fontFamily.Name, emSize, style, unit, gdiCharSet, gdiVerticalFont))
-            {
-                VerifyFont(font, fontFamily.Name, emSize, style, unit, gdiCharSet, gdiVerticalFont);
-            }
-        }
-        finally
-        {
-            fontFamily.Dispose();
-        }
-    }
-
-    [Fact]
-    public void Ctor_FamilyNamePrefixedWithAtSign_StripsSign()
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font($"@{family.Name}", 10))
-        {
-            Assert.Equal(family.Name, font.Name);
-            Assert.Equal($"@{family.Name}", font.OriginalFontName);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullFont_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new Font(null, FontStyle.Regular));
-    }
-
-    [Fact]
-    public void Ctor_DisposedFont_Success()
-    {
-        using (FontFamily family = FontFamily.GenericSerif)
-        {
-            var font = new Font(family, 10);
-            font.Dispose();
-
-            using (var copy = new Font(font, FontStyle.Italic))
-            {
-                Assert.Equal(FontStyle.Italic, copy.Style);
-                Assert.Equal(family.Name, copy.Name);
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullFamily_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10));
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10, FontStyle.Italic));
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10, GraphicsUnit.Display));
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10, FontStyle.Italic, GraphicsUnit.Display));
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10, FontStyle.Italic, GraphicsUnit.Display, 10));
-        AssertExtensions.Throws<ArgumentNullException>("family", () => new Font((FontFamily)null, 10, FontStyle.Italic, GraphicsUnit.Display, 10, gdiVerticalFont: true));
-    }
-
-    [Fact]
-    public void Ctor_DisposedFamily_ThrowsArgumentException()
-    {
-        FontFamily family = FontFamily.GenericSansSerif;
-        family.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, GraphicsUnit.Display));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, GraphicsUnit.Display));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, GraphicsUnit.Display, 10));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, GraphicsUnit.Display, 10, gdiVerticalFont: true));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(float.NaN)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.PositiveInfinity)]
-    public void Ctor_InvalidEmSize_ThrowsArgumentException(float emSize)
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        {
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize, FontStyle.Italic));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize, FontStyle.Italic));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize, GraphicsUnit.Document));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize, GraphicsUnit.Document));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize, FontStyle.Italic, GraphicsUnit.Document));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize, FontStyle.Italic, GraphicsUnit.Document));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize, FontStyle.Italic, GraphicsUnit.Document, 10));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize, FontStyle.Italic, GraphicsUnit.Document, 10));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family, emSize, FontStyle.Italic, GraphicsUnit.Document, 10, gdiVerticalFont: true));
-            AssertExtensions.Throws<ArgumentException>("emSize", () => new Font(family.Name, emSize, FontStyle.Italic, GraphicsUnit.Document, 10, gdiVerticalFont: true));
-        }
-    }
-
-    [Theory]
-    [InlineData(GraphicsUnit.Display)]
-    [InlineData(GraphicsUnit.World - 1)]
-    [InlineData(GraphicsUnit.Millimeter + 1)]
-    public void Ctor_InvalidUnit_ThrowsArgumentException(GraphicsUnit unit)
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, unit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family.Name, 10, unit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, unit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family.Name, 10, FontStyle.Italic, unit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, unit, 10));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family.Name, 10, FontStyle.Italic, unit, 10));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family, 10, FontStyle.Italic, unit, 10, gdiVerticalFont: true));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Font(family.Name, 10, FontStyle.Italic, unit, 10, gdiVerticalFont: true));
-        }
-    }
-
-    [Fact]
-    public void Clone_Invoke_ReturnsExpected()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true))
-        {
-            Font clone = Assert.IsType<Font>(font.Clone());
-            Assert.NotSame(font, clone);
-
-            Assert.Equal(font.Name, clone.FontFamily.Name);
-            Assert.Equal(font.Size, clone.Size);
-            Assert.Equal(font.Style, clone.Style);
-            Assert.Equal(font.Unit, clone.Unit);
-            Assert.Equal(font.GdiCharSet, clone.GdiCharSet);
-            Assert.Equal(font.GdiVerticalFont, clone.GdiVerticalFont);
-        }
-    }
-
-    [Fact]
-    public void Clone_DisposedFont_ThrowsArgumentException()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        {
-            var font = new Font(family, 10);
-            font.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => font.Clone());
-        }
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        FontFamily family = FontFamily.GenericSansSerif;
-        var font = new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true);
-
-        yield return new object[] { font, font, true };
-        yield return new object[] { font.Clone(), new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true), false };
-        yield return new object[] { font.Clone(), new Font(family, 9, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true), false };
-        yield return new object[] { font.Clone(), new Font(family, 10, FontStyle.Italic, GraphicsUnit.Millimeter, 10, gdiVerticalFont: true), false };
-        yield return new object[] { font.Clone(), new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 9, gdiVerticalFont: true), false };
-        yield return new object[] { font.Clone(), new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: false), false };
-
-        yield return new object[] { new Font(family, 10), new object(), false };
-        yield return new object[] { new Font(family, 10), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Other_ReturnsExpected(Font font, object other, bool expected)
-    {
-        // Windows7 GDI+ returns different results than later versions of Windows.
-        if (PlatformDetection.IsWindows7)
-        {
-            return;
-        }
-
-        try
-        {
-            Assert.Equal(expected, font.Equals(other));
-            Assert.Equal(font.GetHashCode(), font.GetHashCode());
-        }
-        finally
-        {
-            font.Dispose();
-            if (other is Font otherFont && !ReferenceEquals(font, otherFont))
-            {
-                otherFont.Dispose();
-            }
-        }
-    }
-
-    [Fact]
-    public void FromHdc_ZeroHdc_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Font.FromHdc(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void FromHdc_GraphicsHdc_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                AssertExtensions.Throws<ArgumentException>(null, () => Font.FromHdc(hdc));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void FromHfont_Zero_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Font.FromHfont(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void GetHeight_Parameterless_ReturnsExpected()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10))
-        {
-            float height = font.GetHeight();
-            AssertExtensions.GreaterThan(height, 0);
-
-            Assert.Equal((int)Math.Ceiling(height), font.Height);
-        }
-    }
-
-    [Fact]
-    public void GetHeight_Graphics_ReturnsExpected()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10))
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Equal((double)font.GetHeight(graphics.DpiY), font.GetHeight(graphics), 5);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(-1, -0.1571995)]
-    [InlineData(1, 0.1571995)]
-    [InlineData(float.NaN, float.NaN)]
-    [InlineData(float.PositiveInfinity, float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity, float.NegativeInfinity)]
-    public void GetHeight_Dpi_ReturnsExpected(float dpi, float expected)
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10))
-        {
-            Assert.Equal((double)expected, font.GetHeight(dpi), 5);
-        }
-    }
-
-    [Fact]
-    public void GetHeight_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("graphics", () => font.GetHeight(null));
-        }
-    }
-
-    [Fact]
-    public void GetHeight_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10))
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => font.GetHeight(graphics));
-        }
-    }
-
-    [Fact]
-    public void GetHeight_Disposed_ThrowsArgumentException()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var font = new Font(family, 10);
-            font.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => font.GetHeight());
-            AssertExtensions.Throws<ArgumentException>(null, () => font.GetHeight(10));
-            AssertExtensions.Throws<ArgumentException>(null, () => font.GetHeight(graphics));
-        }
-    }
-
-    [Theory]
-    [InlineData(FontStyle.Bold, int.MinValue, 0)]
-    [InlineData(FontStyle.Bold, -2147483099, 0)]
-    [InlineData(FontStyle.Regular, -2147483098, 0)]
-    [InlineData(FontStyle.Regular, -1, 0)]
-    [InlineData(FontStyle.Regular, 0, 0)]
-    [InlineData(FontStyle.Regular, 300, 0)]
-    [InlineData(FontStyle.Regular, 400, 0)]
-    [InlineData(FontStyle.Strikeout | FontStyle.Underline | FontStyle.Italic, 549, 1)]
-    [InlineData(FontStyle.Strikeout | FontStyle.Underline | FontStyle.Italic | FontStyle.Bold, 550, 1)]
-    [InlineData(FontStyle.Strikeout | FontStyle.Underline | FontStyle.Bold | FontStyle.Italic, int.MaxValue, 1)]
-    public void FromLogFont_ValidLogFont_ReturnsExpected(FontStyle fontStyle, int weight, byte charSet)
-    {
-        // The boundary values of the weight that is considered Bold are different between Windows 7 and Windows 8.
-        if (PlatformDetection.IsWindows7 || PlatformDetection.IsWindows8x)
-        {
-            return;
-        }
-
-        using (FontFamily family = FontFamily.GenericMonospace)
-        {
-            var logFont = new LOGFONT
-            {
-                lfFaceName = family.Name,
-                lfWeight = weight,
-                lfItalic = (fontStyle & FontStyle.Italic) != 0 ? (byte)1 : (byte)0,
-                lfStrikeOut = (fontStyle & FontStyle.Strikeout) != 0 ? (byte)1 : (byte)0,
-                lfUnderline = (fontStyle & FontStyle.Underline) != 0 ? (byte)1 : (byte)0,
-                lfCharSet = charSet
-            };
-            using (Font font = Font.FromLogFont(logFont))
-            {
-                VerifyFont(font, family.Name, font.Size, fontStyle, GraphicsUnit.World, charSet, expectedGdiVerticalFont: false);
-            }
-        }
-    }
-
-    [Fact]
-    public void FromLogFont_NullLogFont_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                if (PlatformDetection.IsNetFramework)
-                {
-                    AssertExtensions.Throws<ArgumentException>(null, () => Font.FromLogFont(null));
-                    AssertExtensions.Throws<ArgumentException>(null, () => Font.FromLogFont(null, hdc));
-                }
-                else
-                {
-                    AssertExtensions.Throws<ArgumentNullException>("lf", () => Font.FromLogFont(null));
-                    AssertExtensions.Throws<ArgumentNullException>("lf", () => Font.FromLogFont(null, hdc));
-                }
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void FromLogFont_InvalidLogFont_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                var logFont = new LOGFONT();
-                AssertExtensions.Throws<ArgumentException>(null, () => Font.FromLogFont(logFont));
-                AssertExtensions.Throws<ArgumentException>(null, () => Font.FromLogFont(logFont, hdc));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void FromLogFont_UnblittableStruct()
-    {
-        const byte OUT_TT_ONLY_PRECIS = 7;
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                var logFont = new UnblittableLOGFONT
-                {
-                    lfOutPrecision = OUT_TT_ONLY_PRECIS
-                };
-
-                using (Font font = Font.FromLogFont(logFont))
-                {
-                    Assert.NotNull(font);
-                    Assert.NotEmpty(font.Name);
-                }
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Serializable()]
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
-    public struct UnblittableLOGFONT
-    {
-        public int lfHeight;
-        public int lfWidth;
-        public int lfEscapement;
-        public int lfOrientation;
-        public int lfWeight;
-        public byte lfItalic;
-        public byte lfUnderline;
-        public byte lfStrikeOut;
-        public byte lfCharSet;
-        public byte lfOutPrecision;
-        public byte lfClipPrecision;
-        public byte lfQuality;
-        public byte lfPitchAndFamily;
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
-        public string lfFaceName;
-    }
-
-    [Theory]
-    [InlineData(GraphicsUnit.Document)]
-    [InlineData(GraphicsUnit.Inch)]
-    [InlineData(GraphicsUnit.Millimeter)]
-    [InlineData(GraphicsUnit.Pixel)]
-    [InlineData(GraphicsUnit.Point)]
-    [InlineData(GraphicsUnit.World)]
-    public void SizeInPoints_Get_ReturnsExpected(GraphicsUnit unit)
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10, unit))
-        {
-            float sizeInPoints = font.SizeInPoints;
-            if (unit == GraphicsUnit.Point)
-            {
-                Assert.Equal(font.Size, sizeInPoints);
-            }
-            else
-            {
-                Assert.True(sizeInPoints > 0);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(FontStyle.Strikeout | FontStyle.Bold | FontStyle.Italic, 255, true, "@", 700)]
-    [InlineData(FontStyle.Regular, 0, false, "", 400)]
-    [InlineData(FontStyle.Regular, 10, false, "", 400)]
-    public void ToLogFont_Invoke_ReturnsExpected(FontStyle fontStyle, byte gdiCharSet, bool gdiVerticalFont, string expectedNamePrefix, int expectedWeight)
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10, fontStyle, GraphicsUnit.Point, gdiCharSet, gdiVerticalFont))
-        {
-            var logFont = new LOGFONT();
-            font.ToLogFont(logFont);
-
-            Assert.Equal(-13, logFont.lfHeight);
-            Assert.Equal(0, logFont.lfWidth);
-            Assert.Equal(0, logFont.lfEscapement);
-            Assert.Equal(0, logFont.lfOrientation);
-            Assert.Equal(expectedWeight, logFont.lfWeight);
-            Assert.Equal(font.Italic ? 1 : 0, logFont.lfItalic);
-            Assert.Equal(font.Underline ? 1 : 0, logFont.lfUnderline);
-            Assert.Equal(font.Strikeout ? 1 : 0, logFont.lfStrikeOut);
-            Assert.Equal(SystemFonts.DefaultFont.GdiCharSet <= 2 ? font.GdiCharSet : SystemFonts.DefaultFont.GdiCharSet, logFont.lfCharSet);
-            Assert.Equal(0, logFont.lfOutPrecision);
-            Assert.Equal(0, logFont.lfClipPrecision);
-            Assert.Equal(0, logFont.lfQuality);
-            Assert.Equal(0, logFont.lfPitchAndFamily);
-            Assert.Equal($"{expectedNamePrefix}{family.Name}", logFont.lfFaceName);
-        }
-    }
-
-    [Theory]
-    [InlineData(TextRenderingHint.SystemDefault)]
-    [InlineData(TextRenderingHint.AntiAlias)]
-    [InlineData(TextRenderingHint.AntiAliasGridFit)]
-    [InlineData(TextRenderingHint.SingleBitPerPixel)]
-    [InlineData(TextRenderingHint.SingleBitPerPixelGridFit)]
-    [InlineData(TextRenderingHint.ClearTypeGridFit)]
-    public void ToLogFont_InvokeGraphics_ReturnsExpected(TextRenderingHint textRenderingHint)
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10))
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.TextRenderingHint = textRenderingHint;
-
-            var logFont = new LOGFONT();
-            font.ToLogFont(logFont, graphics);
-
-            Assert.Equal(-13, logFont.lfHeight);
-            Assert.Equal(0, logFont.lfWidth);
-            Assert.Equal(0, logFont.lfEscapement);
-            Assert.Equal(0, logFont.lfOrientation);
-            Assert.Equal(400, logFont.lfWeight);
-            Assert.Equal(0, logFont.lfItalic);
-            Assert.Equal(0, logFont.lfUnderline);
-            Assert.Equal(0, logFont.lfStrikeOut);
-            Assert.Equal(SystemFonts.DefaultFont.GdiCharSet <= 2 ? font.GdiCharSet : SystemFonts.DefaultFont.GdiCharSet, logFont.lfCharSet);
-            Assert.Equal(0, logFont.lfOutPrecision);
-            Assert.Equal(0, logFont.lfClipPrecision);
-            Assert.Equal(0, logFont.lfQuality);
-            Assert.Equal(0, logFont.lfPitchAndFamily);
-            Assert.Equal(family.Name, logFont.lfFaceName);
-        }
-    }
-
-    [Fact]
-    public void ToLogFont_NullLogFont_ThrowsArgumentNullException()
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10))
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>(() => font.ToLogFont(null));
-            Assert.Throws<ArgumentNullException>(() => font.ToLogFont(null, graphics));
-        }
-    }
-
-    [Fact]
-    public void ToLogFont_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("graphics", () => font.ToLogFont(new LOGFONT(), null));
-        }
-    }
-
-    [Fact]
-    public void ToLogFont_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (FontFamily family = FontFamily.GenericMonospace)
-        using (var font = new Font(family, 10))
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            Assert.Throws<ArgumentException>(() => font.ToLogFont(new LOGFONT(), graphics));
-        }
-    }
-
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-    public class LOGFONT
-    {
-        public int lfHeight;
-        public int lfWidth;
-        public int lfEscapement;
-        public int lfOrientation;
-        public int lfWeight;
-        public byte lfItalic;
-        public byte lfUnderline;
-        public byte lfStrikeOut;
-        public byte lfCharSet;
-        public byte lfOutPrecision;
-        public byte lfClipPrecision;
-        public byte lfQuality;
-        public byte lfPitchAndFamily;
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
-        public string lfFaceName;
-    }
-
-    [Fact]
-    public void ToHfont_SimpleFont_Roundtrips()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10))
-        {
-            IntPtr hfont = font.ToHfont();
-            Assert.NotEqual(IntPtr.Zero, hfont);
-            Assert.NotEqual(hfont, font.ToHfont());
-
-            Font newFont = Font.FromHfont(hfont);
-            Assert.Equal(font.Name, newFont.Name);
-        }
-    }
-
-    [Fact]
-    public void ToHfont_ComplicatedFont_DoesNotRoundtrip()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true))
-        {
-            IntPtr hfont = font.ToHfont();
-            Assert.NotEqual(IntPtr.Zero, hfont);
-            Assert.NotEqual(hfont, font.ToHfont());
-
-            Font newFont = Font.FromHfont(hfont);
-            Assert.NotEqual(font.Name, newFont.Name);
-        }
-    }
-
-    [Fact]
-    public void ToHfont_Disposed_ThrowsArgumentException()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var font = new Font(family, 10);
-            font.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => font.ToHfont());
-        }
-    }
-
-    [Fact]
-    public void ToString_Invoke_ReturnsExpected()
-    {
-        using (FontFamily family = FontFamily.GenericSansSerif)
-        using (var font = new Font(family, 10, FontStyle.Bold, GraphicsUnit.Inch, 10, gdiVerticalFont: true))
-        {
-            Assert.Equal($"[Font: Name={family.Name}, Size=10, Units=4, GdiCharSet=10, GdiVerticalFont=True]", font.ToString());
-        }
-    }
-
-    private static void VerifyFont(Font font, string expectedName, float expectedEmSize, FontStyle expectedStyle, GraphicsUnit expectedUnit, byte expectedGdiCharset, bool expectedGdiVerticalFont)
-    {
-        Assert.Equal(expectedName, font.Name);
-        Assert.Equal(expectedEmSize, font.Size);
-
-        Assert.Equal(expectedStyle, font.Style);
-        Assert.Equal((expectedStyle & FontStyle.Bold) != 0, font.Bold);
-        Assert.Equal((expectedStyle & FontStyle.Italic) != 0, font.Italic);
-        Assert.Equal((expectedStyle & FontStyle.Strikeout) != 0, font.Strikeout);
-        Assert.Equal((expectedStyle & FontStyle.Underline) != 0, font.Underline);
-
-        Assert.Equal(expectedUnit, font.Unit);
-        Assert.Equal(expectedGdiCharset, font.GdiCharSet);
-        Assert.Equal(expectedGdiVerticalFont, font.GdiVerticalFont);
-
-        Assert.False(font.IsSystemFont);
-        Assert.Empty(font.SystemFontName);
-    }
-
-    [Fact]
-    public void GetHashCode_DifferentNameSameSizeStyleUnit_HashCodeIsNotSame()
-    {
-        using FontFamily family1 = FontFamily.GenericSansSerif;
-        using var font1 = new Font(family1, 1, FontStyle.Bold, GraphicsUnit.Point);
-
-        using FontFamily family2 = FontFamily.GenericMonospace;
-        using var font2 = new Font(family2, 1, FontStyle.Bold, GraphicsUnit.Point);
-        // This test depends on machine setup and whether the fonts we use are installed or not.
-        // If not installed we could get the same font for the two Font families we are testing for.
-        if (font1.Name.Equals(font2.Name, StringComparison.OrdinalIgnoreCase))
-            return;
-
-        Assert.NotEqual(font1.GetHashCode(), font2.GetHashCode());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/GdiPlusHandlesTests.cs b/src/System.Drawing.Common/tests/GdiPlusHandlesTests.cs
deleted file mode 100644
index 8480d47ec7d..00000000000
--- a/src/System.Drawing.Common/tests/GdiPlusHandlesTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.RemoteExecutor;
-using Xunit.Sdk;
-
-namespace System.Drawing.Tests;
-
-public static class GdiPlusHandlesTests
-{
-    public static bool IsDrawingAndRemoteExecutorSupported => RemoteExecutor.IsSupported;
-
-    [ConditionalFact(nameof(IsDrawingAndRemoteExecutorSupported))]
-    public static void GraphicsDrawIconDoesNotLeakHandles()
-    {
-        RemoteExecutor.Invoke(() =>
-        {
-            const int handleTreshold = 1;
-            using Bitmap bmp = new(100, 100);
-            using Icon ico = new(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico"));
-
-            IntPtr hdc = Helpers.GetDC(Helpers.GetForegroundWindow());
-            using Graphics graphicsFromHdc = Graphics.FromHdc(hdc);
-
-            using Process currentProcess = Process.GetCurrentProcess();
-            IntPtr processHandle = currentProcess.Handle;
-
-            int initialHandles = Helpers.GetGuiResources(processHandle, 0);
-            ValidateNoWin32Error(initialHandles);
-
-            for (int i = 0; i < 5000; i++)
-            {
-                graphicsFromHdc.DrawIcon(ico, 100, 100);
-            }
-
-            int finalHandles = Helpers.GetGuiResources(processHandle, 0);
-            ValidateNoWin32Error(finalHandles);
-
-            Assert.InRange(finalHandles, initialHandles - handleTreshold, initialHandles + handleTreshold);
-        }).Dispose();
-    }
-
-    private static void ValidateNoWin32Error(int handleCount)
-    {
-        if (handleCount == 0)
-        {
-            int error = Marshal.GetLastWin32Error();
-
-            if (error != 0)
-                throw new XunitException($"GetGuiResources failed with win32 error: {error}");
-        }
-    }
-
-}
diff --git a/src/System.Drawing.Common/tests/GlobalUsings.cs b/src/System.Drawing.Common/tests/GlobalUsings.cs
deleted file mode 100644
index af753dde135..00000000000
--- a/src/System.Drawing.Common/tests/GlobalUsings.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Drawing;
-global using System.Diagnostics;
-global using Xunit;
diff --git a/src/System.Drawing.Common/tests/GraphicsTests.Core.cs b/src/System.Drawing.Common/tests/GraphicsTests.Core.cs
deleted file mode 100644
index 400f7f4afb9..00000000000
--- a/src/System.Drawing.Common/tests/GraphicsTests.Core.cs
+++ /dev/null
@@ -1,223 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-using System.Numerics;
-
-namespace System.Drawing.Tests;
-
-public partial class GraphicsTests
-{
-    private static Matrix3x2 s_testMatrix = Matrix3x2.CreateRotation(45) * Matrix3x2.CreateScale(2) * Matrix3x2.CreateTranslation(new Vector2(10, 20));
-
-
-    [Fact]
-    public void TransformElements_SetNonInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(5, 5))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Matrix3x2 matrix = new Matrix3x2(123, 24, 82, 16, 47, 30);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformElements = matrix);
-        }
-    }
-
-    [Fact]
-    public void TransformElements_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.TransformElements);
-                Assert.Throws<InvalidOperationException>(() => graphics.TransformElements = Matrix3x2.Identity);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void TransformElements_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformElements);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformElements = Matrix3x2.Identity);
-        }
-    }
-
-    [Fact]
-    public void TransformElements_RoundTrip()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.TransformElements = s_testMatrix;
-            Assert.Equal(s_testMatrix, graphics.TransformElements);
-
-            using (Matrix matrix = graphics.Transform)
-            {
-                Assert.Equal(s_testMatrix, matrix.MatrixElements);
-            }
-
-            using (Matrix matrix = new Matrix())
-            {
-                graphics.Transform = matrix;
-                Assert.True(graphics.TransformElements.IsIdentity);
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_NullPen_ThrowsArgumentNullException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangle(null, new RectangleF(0f, 0f, 1f, 1f)));
-            // other DrawRectangle overloads tested in DrawRectangle_NullPen_ThrowsArgumentNullException()
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_DisposedPen_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, new RectangleF(0f, 0f, 1f, 1f)));
-            // other DrawRectangle overloads tested in DrawRectangle_DisposedPen_ThrowsArgumentException()
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_Busy_ThrowsInvalidOperationException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangle(pen, new RectangleF(0f, 0f, 1f, 1f)));
-                // other DrawRectangle overloads tested in DrawRectangle_Busy_ThrowsInvalidOperationException()
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_Disposed_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, new RectangleF(0f, 0f, 1f, 1f)));
-            // other DrawRectangle overloads tested in DrawRectangle_Disposed_ThrowsArgumentException()
-        }
-    }
-
-    [Fact]
-    public void FillPie_NullPen_ThrowsArgumentNullException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("brush", () => graphics.FillPie(null, new RectangleF(0, 0, 1, 1), 0, 90));
-            // other FillPie overloads tested in FillPie_NullPen_ThrowsArgumentNullException()
-        }
-    }
-
-    [Fact]
-    public void FillPie_DisposedPen_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var brush = new SolidBrush(Color.Red);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new RectangleF(0, 0, 1, 1), 0, 90));
-            // other FillPie overloads tested in FillPie_DisposedPen_ThrowsArgumentException()
-        }
-    }
-
-    [Fact]
-    public void FillPie_ZeroWidth_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new RectangleF(0, 0, 0, 1), 0, 90));
-            // other FillPie overloads tested in FillPie_ZeroWidth_ThrowsArgumentException()
-        }
-    }
-
-    [Fact]
-    public void FillPie_ZeroHeight_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new RectangleF(0, 0, 1, 0), 0, 90));
-            // other FillPie overloads tested in FillPie_ZeroHeight_ThrowsArgumentException()
-        }
-    }
-
-    [Fact]
-    public void FillPie_Busy_ThrowsInvalidOperationException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.FillPie(brush, new RectangleF(0, 0, 1, 1), 0, 90));
-                // other FillPie overloads tested in FillPie_Busy_ThrowsInvalidOperationException()
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void FillPie_Disposed_ThrowsArgumentException_Core()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new RectangleF(0, 0, 1, 1), 0, 90));
-            // other FillPie overloads tested in FillPie_Disposed_ThrowsArgumentException()
-        }
-    }
-
-
-
-}
diff --git a/src/System.Drawing.Common/tests/GraphicsTests.cs b/src/System.Drawing.Common/tests/GraphicsTests.cs
deleted file mode 100644
index 9b3919b818d..00000000000
--- a/src/System.Drawing.Common/tests/GraphicsTests.cs
+++ /dev/null
@@ -1,3278 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Drawing.Text;
-
-namespace System.Drawing.Tests;
-
-public partial class GraphicsTests
-{
-    public static bool IsWindows7OrWindowsArm64 => PlatformDetection.IsWindows7 || (PlatformDetection.IsWindows && PlatformDetection.IsArm64Process);
-
-    [Fact]
-    public void GetHdc_FromHdc_Roundtrips()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                Assert.NotEqual(IntPtr.Zero, hdc);
-
-                using (Graphics graphicsCopy = Graphics.FromHdc(hdc))
-                {
-                    VerifyGraphics(graphicsCopy, graphicsCopy.VisibleClipBounds);
-                }
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void GetHdc_SameImage_ReturnsSame()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics1 = Graphics.FromImage(bitmap))
-        using (Graphics graphics2 = Graphics.FromImage(bitmap))
-        {
-            try
-            {
-                Assert.Equal(graphics1.GetHdc(), graphics2.GetHdc());
-            }
-            finally
-            {
-                graphics1.ReleaseHdc();
-                graphics2.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void GetHdc_NotReleased_ThrowsInvalidOperationException()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.GetHdc());
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void GetHdc_Disposed_ThrowsObjectDisposedException()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(bitmap);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.GetHdc());
-        }
-    }
-
-    public static IEnumerable<object[]> FromHdc_TestData()
-    {
-        yield return new object[] { Helpers.GetDC(IntPtr.Zero) };
-        yield return new object[] { Helpers.GetWindowDC(IntPtr.Zero) };
-
-        // Likely the source of #51097- grabbing whatever the current foreground window is is not a great idea.
-        // Whatever that window is it could disappear at any time and what it's clipping info would be pretty
-        // random.
-        // https://github.com/dotnet/winforms/issues/8829
-
-        // IntPtr foregroundWindow = Helpers.GetForegroundWindow();
-        // yield return new object[] { Helpers.GetDC(foregroundWindow) };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHdc_TestData))]
-    public void FromHdc_ValidHdc_ReturnsExpected(IntPtr hdc)
-    {
-        using (Graphics graphics = Graphics.FromHdc(hdc))
-        {
-            Rectangle expected = Helpers.GetWindowDCRect(hdc);
-            VerifyGraphics(graphics, expected);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHdc_TestData))]
-    public void FromHdc_ValidHdcWithContext_ReturnsExpected(IntPtr hdc)
-    {
-        using (Graphics graphics = Graphics.FromHdc(hdc, IntPtr.Zero))
-        {
-            Rectangle expected = Helpers.GetWindowDCRect(hdc);
-            VerifyGraphics(graphics, expected);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHdc_TestData))]
-    public void FromHdcInternal_GetDC_ReturnsExpected(IntPtr hdc)
-    {
-        using (Graphics graphics = Graphics.FromHdcInternal(hdc))
-        {
-            Rectangle expected = Helpers.GetWindowDCRect(hdc);
-            VerifyGraphics(graphics, expected);
-        }
-    }
-
-    [Fact]
-    public void FromHdc_ZeroHdc_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("hdc", () => Graphics.FromHdc(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void FromHdcInternal_ZeroHdc_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHdcInternal(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void FromHdc_ZeroHdc_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHdc(IntPtr.Zero, (IntPtr)10));
-    }
-
-    [Fact]
-    public void FromHdc_InvalidHdc_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHwnd((IntPtr)10));
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHwndInternal((IntPtr)10));
-    }
-
-    [Fact]
-    public void ReleaseHdc_ValidHdc_ResetsHdc()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            graphics.ReleaseHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc(hdc));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal(hdc));
-
-            hdc = graphics.GetHdc();
-            graphics.ReleaseHdc(hdc);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc());
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal(hdc));
-
-            hdc = graphics.GetHdc();
-            graphics.ReleaseHdcInternal(hdc);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc());
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal(hdc));
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdc_NoSuchHdc_ResetsHdc()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            IntPtr hdc = graphics.GetHdc();
-            graphics.ReleaseHdc((IntPtr)10);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal((IntPtr)10));
-
-            hdc = graphics.GetHdc();
-            graphics.ReleaseHdcInternal((IntPtr)10);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc((IntPtr)10));
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdc_OtherGraphicsHdc_Success()
-    {
-        using (var bitmap1 = new Bitmap(10, 10))
-        using (var bitmap2 = new Bitmap(10, 10))
-        using (Graphics graphics1 = Graphics.FromImage(bitmap1))
-        using (Graphics graphics2 = Graphics.FromImage(bitmap2))
-        {
-            IntPtr hdc1 = graphics1.GetHdc();
-            IntPtr hdc2 = graphics2.GetHdc();
-            Assert.NotEqual(hdc1, hdc2);
-
-            graphics1.ReleaseHdc(hdc2);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics1.ReleaseHdc(hdc1));
-
-            graphics2.ReleaseHdc(hdc1);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics2.ReleaseHdc(hdc2));
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdc_NoHdc_ThrowsArgumentException()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(bitmap))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc());
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc(IntPtr.Zero));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal(IntPtr.Zero));
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdc_Disposed_ThrowsObjectDisposedException()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(bitmap);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc());
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdc(IntPtr.Zero));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ReleaseHdcInternal(IntPtr.Zero));
-        }
-    }
-
-    public static IEnumerable<object[]> Hwnd_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { Helpers.GetForegroundWindow() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Hwnd_TestData))]
-    public void FromHwnd_ValidHwnd_ReturnsExpected(IntPtr hWnd)
-    {
-        using (Graphics graphics = Graphics.FromHwnd(hWnd))
-        {
-            Rectangle expected = Helpers.GetHWndRect(hWnd);
-            VerifyGraphics(graphics, expected);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Hwnd_TestData))]
-    public void FromHwndInternal_ValidHwnd_ReturnsExpected(IntPtr hWnd)
-    {
-        using (Graphics graphics = Graphics.FromHwnd(hWnd))
-        {
-            Rectangle expected = Helpers.GetHWndRect(hWnd);
-            VerifyGraphics(graphics, expected);
-        }
-    }
-
-    [Fact]
-    public void FromHwnd_InvalidHwnd_ThrowsOutOfMemoryException()
-    {
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHdc((IntPtr)10));
-        Assert.Throws<OutOfMemoryException>(() => Graphics.FromHdcInternal((IntPtr)10));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format16bppRgb555)]
-    [InlineData(PixelFormat.Format16bppRgb565)]
-    [InlineData(PixelFormat.Format24bppRgb)]
-    [InlineData(PixelFormat.Format32bppArgb)]
-    [InlineData(PixelFormat.Format32bppPArgb)]
-    [InlineData(PixelFormat.Format32bppRgb)]
-    [InlineData(PixelFormat.Format48bppRgb)]
-    [InlineData(PixelFormat.Format64bppArgb)]
-    [InlineData(PixelFormat.Format64bppPArgb)]
-    public void FromImage_Bitmap_Success(PixelFormat format)
-    {
-        using (var image = new Bitmap(10, 10, format))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            VerifyGraphics(graphics, new Rectangle(Point.Empty, image.Size));
-        }
-    }
-
-    [Fact]
-    public void FromImage_NullImage_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("image", () => Graphics.FromImage(null));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format1bppIndexed)]
-    [InlineData(PixelFormat.Format4bppIndexed)]
-    [InlineData(PixelFormat.Format8bppIndexed)]
-    public void FromImage_IndexedImage_ThrowsException(PixelFormat format)
-    {
-        using (var image = new Bitmap(10, 10, format))
-        {
-            Exception exception = AssertExtensions.Throws<ArgumentException,Exception>(() => Graphics.FromImage(image));
-            if (exception is ArgumentException argumentException)
-                Assert.Equal("image", argumentException.ParamName);
-        }
-    }
-
-    [Fact]
-    public void FromImage_DisposedImage_ThrowsArgumentException()
-    {
-        var image = new Bitmap(10, 10);
-        image.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => Graphics.FromImage(image));
-    }
-
-    [Fact]
-    public void FromImage_Metafile_ThrowsOutOfMemoryException()
-    {
-        using (var image = new Metafile(Helpers.GetTestBitmapPath("telescope_01.wmf")))
-        {
-            Assert.Throws<OutOfMemoryException>(() => Graphics.FromImage(image));
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format16bppArgb1555)]
-    [InlineData(PixelFormat.Format16bppGrayScale)]
-    public void FromImage_Invalid16BitFormat_ThrowsOutOfMemoryException(PixelFormat format)
-    {
-        using (var image = new Bitmap(10, 10, format))
-        {
-            Assert.Throws<OutOfMemoryException>(() => Graphics.FromImage(image));
-        }
-    }
-
-    public static IEnumerable<object[]> CompositingMode_TestData()
-    {
-        yield return new object[] { CompositingMode.SourceCopy, Color.FromArgb(160, 255, 255, 255) };
-        yield return new object[] { CompositingMode.SourceOver, Color.FromArgb(220, 185, 185, 185) };
-    }
-
-    [Theory]
-    [MemberData(nameof(CompositingMode_TestData))]
-    public void CompositingMode_Set_GetReturnsExpected(CompositingMode mode, Color expectedOverlap)
-    {
-        Color transparentBlack = Color.FromArgb(160, 0, 0, 0);
-        Color transparentWhite = Color.FromArgb(160, 255, 255, 255);
-
-        using (var transparentBlackBrush = new SolidBrush(transparentBlack))
-        using (var transparentWhiteBrush = new SolidBrush(transparentWhite))
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var targetImage = new Bitmap(3, 3))
-        using (Graphics targetGraphics = Graphics.FromImage(targetImage))
-        {
-            graphics.CompositingMode = mode;
-            Assert.Equal(mode, graphics.CompositingMode);
-
-            graphics.FillRectangle(transparentBlackBrush, new Rectangle(0, 0, 2, 2));
-            graphics.FillRectangle(transparentWhiteBrush, new Rectangle(1, 1, 2, 2));
-
-            targetGraphics.DrawImage(image, Point.Empty);
-            Helpers.VerifyBitmap(targetImage, new Color[][]
-            {
-                new Color[] { transparentBlack,   transparentBlack, Helpers.EmptyColor },
-                new Color[] { transparentBlack,   expectedOverlap,  transparentWhite   },
-                new Color[] { Helpers.EmptyColor, transparentWhite, transparentWhite   }
-            });
-        }
-    }
-
-    [Theory]
-    [InlineData(CompositingMode.SourceOver - 1)]
-    [InlineData(CompositingMode.SourceCopy + 1)]
-    public void CompositingMode_SetInvalid_ThrowsInvalidEnumArgumentException(CompositingMode compositingMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.CompositingMode = compositingMode);
-        }
-    }
-
-    [Fact]
-    public void CompositingMode_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.CompositingMode);
-                Assert.Throws<InvalidOperationException>(() => graphics.CompositingMode = CompositingMode.SourceCopy);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void CompositingMode_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CompositingMode);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CompositingMode = CompositingMode.SourceCopy);
-        }
-    }
-
-    public static IEnumerable<object[]> CompositingQuality_TestData()
-    {
-        Color transparentBlack = Color.FromArgb(160, 0, 0, 0);
-        Color transparentWhite = Color.FromArgb(160, 255, 255, 255);
-        var basicExpectedColors = new Color[][]
-        {
-            new Color[] { transparentBlack,   transparentBlack,                   Helpers.EmptyColor },
-            new Color[] { transparentBlack,   Color.FromArgb(220, 185, 185, 185), transparentWhite   },
-            new Color[] { Helpers.EmptyColor, transparentWhite,                   transparentWhite   }
-        };
-
-        yield return new object[] { CompositingQuality.AssumeLinear, basicExpectedColors };
-        yield return new object[] { CompositingQuality.Default, basicExpectedColors };
-        yield return new object[] { CompositingQuality.HighSpeed, basicExpectedColors };
-        yield return new object[] { CompositingQuality.Invalid, basicExpectedColors };
-
-        var gammaCorrectedColors = new Color[][]
-        {
-            new Color[] { Color.FromArgb(159, 0, 0, 0), Color.FromArgb(159, 0, 0, 0),       Color.FromArgb(0, 0, 0, 0)         },
-            new Color[] { Color.FromArgb(159, 0, 0, 0), Color.FromArgb(219, 222, 222, 222), Color.FromArgb(159, 255, 255, 255) },
-            new Color[] { Color.FromArgb(0, 0, 0, 0),   Color.FromArgb(159, 255, 255, 255), Color.FromArgb(159, 255, 255, 255) }
-        };
-        yield return new object[] { CompositingQuality.GammaCorrected, gammaCorrectedColors };
-        yield return new object[] { CompositingQuality.HighQuality, gammaCorrectedColors };
-    }
-
-    [Theory]
-    [MemberData(nameof(CompositingQuality_TestData))]
-    public void CompositingQuality_Set_GetReturnsExpected(CompositingQuality quality, Color[][] expectedIntersectionColor)
-    {
-        Color transparentBlack = Color.FromArgb(160, 0, 0, 0);
-        Color transparentWhite = Color.FromArgb(160, 255, 255, 255);
-
-        using (var transparentBlackBrush = new SolidBrush(transparentBlack))
-        using (var transparentWhiteBrush = new SolidBrush(transparentWhite))
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.CompositingQuality = quality;
-            Assert.Equal(quality, graphics.CompositingQuality);
-
-            graphics.FillRectangle(transparentBlackBrush, new Rectangle(0, 0, 2, 2));
-            graphics.FillRectangle(transparentWhiteBrush, new Rectangle(1, 1, 2, 2));
-
-            Helpers.VerifyBitmap(image, expectedIntersectionColor);
-        }
-    }
-
-    [Theory]
-    [InlineData(CompositingQuality.Invalid - 1)]
-    [InlineData(CompositingQuality.AssumeLinear + 1)]
-    public void CompositingQuality_SetInvalid_ThrowsInvalidEnumArgumentException(CompositingQuality compositingQuality)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.CompositingQuality = compositingQuality);
-        }
-    }
-
-    [Fact]
-    public void CompositingQuality_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.CompositingQuality);
-                Assert.Throws<InvalidOperationException>(() => graphics.CompositingQuality = CompositingQuality.AssumeLinear);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void CompositingQuality_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CompositingQuality);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CompositingQuality = CompositingQuality.AssumeLinear);
-        }
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimesWithoutHdc_Success()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            var graphics = Graphics.FromImage(bitmap);
-            graphics.Dispose();
-            graphics.Dispose();
-
-            // The backing image is not disposed.
-            Assert.Equal(10, bitmap.Height);
-        }
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimesWithHdc_Success()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            var graphics = Graphics.FromImage(bitmap);
-            graphics.GetHdc();
-
-            graphics.Dispose();
-            graphics.Dispose();
-
-            // The backing image is not disposed.
-            Assert.Equal(10, bitmap.Height);
-        }
-    }
-
-    [Fact]
-    public void DpiX_GetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DpiX);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DpiX_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DpiX);
-        }
-    }
-
-    [Fact]
-    public void DpiY_GetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DpiX);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DpiY_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DpiX);
-        }
-    }
-
-    [Theory]
-    [InlineData(FlushIntention.Flush)]
-    [InlineData(FlushIntention.Sync)]
-    [InlineData(FlushIntention.Flush - 1)] // Not in the range of valid values of FlushIntention.
-    [InlineData(FlushIntention.Sync + 1)] // Not in the range of valid values of FlushIntention.
-    public void Flush_MultipleTimes_Success(FlushIntention intention)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            if (intention == FlushIntention.Flush)
-            {
-                graphics.Flush();
-                graphics.Flush();
-            }
-
-            graphics.Flush(intention);
-            graphics.Flush(intention);
-        }
-    }
-
-    [Fact]
-    public void Flush_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.Flush());
-                Assert.Throws<InvalidOperationException>(() => graphics.Flush(FlushIntention.Sync));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Flush_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Flush());
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Flush(FlushIntention.Flush));
-        }
-    }
-
-    [Theory]
-    [InlineData(InterpolationMode.Bicubic, InterpolationMode.Bicubic)]
-    [InlineData(InterpolationMode.Bilinear, InterpolationMode.Bilinear)]
-    [InlineData(InterpolationMode.Default, InterpolationMode.Bilinear)]
-    [InlineData(InterpolationMode.High, InterpolationMode.HighQualityBicubic)]
-    [InlineData(InterpolationMode.HighQualityBicubic, InterpolationMode.HighQualityBicubic)]
-    [InlineData(InterpolationMode.HighQualityBilinear, InterpolationMode.HighQualityBilinear)]
-    [InlineData(InterpolationMode.Low, InterpolationMode.Bilinear)]
-    [InlineData(InterpolationMode.NearestNeighbor, InterpolationMode.NearestNeighbor)]
-    public void InterpolationMode_SetValid_GetReturnsExpected(InterpolationMode interpolationMode, InterpolationMode expectedInterpolationMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.InterpolationMode = interpolationMode;
-            Assert.Equal(expectedInterpolationMode, graphics.InterpolationMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(InterpolationMode.Invalid - 1)]
-    [InlineData(InterpolationMode.HighQualityBicubic + 1)]
-    public void InterpolationMode_SetInvalid_ThrowsInvalidEnumArgumentException(InterpolationMode interpolationMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.InterpolationMode = interpolationMode);
-        }
-    }
-
-    [Fact]
-    public void InterpolationMode_SetToInvalid_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.InterpolationMode = InterpolationMode.Invalid);
-        }
-    }
-
-    [Fact]
-    public void InterpolationMode_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.InterpolationMode);
-                Assert.Throws<InvalidOperationException>(() => graphics.InterpolationMode = InterpolationMode.HighQualityBilinear);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void InterpolationMode_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.InterpolationMode);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.InterpolationMode = InterpolationMode.HighQualityBilinear);
-        }
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(1000000032)]
-    [InlineData(float.NaN)]
-    public void PageScale_SetValid_GetReturnsExpected(float pageScale)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.PageScale = pageScale;
-            Assert.Equal(pageScale, graphics.PageScale);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1000000033)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.PositiveInfinity)]
-    public void PageScale_SetInvalid_ThrowsArgumentException(float pageScale)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageScale = pageScale);
-        }
-    }
-
-    [Fact]
-    public void PageScale_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.PageScale);
-                Assert.Throws<InvalidOperationException>(() => graphics.PageScale = 10);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void PageScale_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageScale);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageScale = 10);
-        }
-    }
-
-    [Theory]
-    [InlineData(GraphicsUnit.Display)]
-    [InlineData(GraphicsUnit.Document)]
-    [InlineData(GraphicsUnit.Inch)]
-    [InlineData(GraphicsUnit.Millimeter)]
-    [InlineData(GraphicsUnit.Pixel)]
-    [InlineData(GraphicsUnit.Point)]
-    public void PageUnit_SetValid_GetReturnsExpected(GraphicsUnit pageUnit)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.PageUnit = pageUnit;
-            Assert.Equal(pageUnit, graphics.PageUnit);
-        }
-    }
-
-    [Theory]
-    [InlineData(GraphicsUnit.World - 1)]
-    [InlineData(GraphicsUnit.Millimeter + 1)]
-    public void PageUnit_SetInvalid_ThrowsInvalidEnumArgumentException(GraphicsUnit pageUnit)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.PageUnit = pageUnit);
-        }
-    }
-
-    [Fact]
-    public void PageUnit_SetWorld_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageUnit = GraphicsUnit.World);
-        }
-    }
-
-    [Fact]
-    public void PageUnit_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.PageUnit);
-                Assert.Throws<InvalidOperationException>(() => graphics.PageUnit = GraphicsUnit.Document);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void PageUnit_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageUnit);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PageUnit = GraphicsUnit.Document);
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelOffsetMode.Default)]
-    [InlineData(PixelOffsetMode.Half)]
-    [InlineData(PixelOffsetMode.HighQuality)]
-    [InlineData(PixelOffsetMode.HighSpeed)]
-    [InlineData(PixelOffsetMode.None)]
-    public void PixelOffsetMode_SetValid_GetReturnsExpected(PixelOffsetMode pixelOffsetMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.PixelOffsetMode = pixelOffsetMode;
-            Assert.Equal(pixelOffsetMode, graphics.PixelOffsetMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(PixelOffsetMode.Invalid - 1)]
-    [InlineData(PixelOffsetMode.Half + 1)]
-    public void PixelOffsetMode_SetInvalid_ThrowsInvalidEnumArgumentException(PixelOffsetMode pixelOffsetMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.PixelOffsetMode = pixelOffsetMode);
-        }
-    }
-
-    [Fact]
-    public void PixelOffsetMode_SetToInvalid_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PixelOffsetMode = PixelOffsetMode.Invalid);
-        }
-    }
-
-    [Fact]
-    public void PixelOffsetMode_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.PixelOffsetMode);
-                Assert.Throws<InvalidOperationException>(() => graphics.PixelOffsetMode = PixelOffsetMode.Default);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void PixelOffsetMode_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PixelOffsetMode);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.PixelOffsetMode = PixelOffsetMode.Default);
-        }
-    }
-
-    public static IEnumerable<object[]> RenderingOrigin_TestData()
-    {
-        Color empty = Color.FromArgb(255, 0, 0, 0);
-        Color red = Color.FromArgb(Color.Red.ToArgb());
-
-        yield return new object[]
-        {
-            new Point(0, 0),
-            new Color[][]
-            {
-                new Color[] { red, red,   red   },
-                new Color[] { red, empty, empty },
-                new Color[] { red, empty, empty }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Point(1, 1),
-            new Color[][]
-            {
-                new Color[] { empty, red, empty },
-                new Color[] { red,   red, red   },
-                new Color[] { empty, red, empty }
-            }
-        };
-
-        var allEmpty = new Color[][]
-        {
-            new Color[] { empty, empty, empty },
-            new Color[] { empty, empty, empty },
-            new Color[] { empty, empty, empty }
-        };
-
-        yield return new object[] { new Point(-3, -3), allEmpty };
-        yield return new object[] { new Point(3, 3), allEmpty };
-    }
-
-    [Theory]
-    [MemberData(nameof(RenderingOrigin_TestData))]
-    public void RenderingOrigin_SetToCustom_RendersExpected(Point renderingOrigin, Color[][] expectedRendering)
-    {
-        Color red = Color.FromArgb(Color.Red.ToArgb());
-
-        using (var image = new Bitmap(3, 3))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new HatchBrush(HatchStyle.Cross, red))
-        {
-            graphics.RenderingOrigin = renderingOrigin;
-            Assert.Equal(renderingOrigin, graphics.RenderingOrigin);
-
-            graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 3));
-            Helpers.VerifyBitmap(image, expectedRendering);
-        }
-    }
-
-    [Fact]
-    public void RenderingOrigin_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.RenderingOrigin);
-                Assert.Throws<InvalidOperationException>(() => graphics.RenderingOrigin = Point.Empty);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void RenderingOrigin_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.RenderingOrigin);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.RenderingOrigin = Point.Empty);
-        }
-    }
-
-    [Theory]
-    [InlineData(SmoothingMode.AntiAlias, SmoothingMode.AntiAlias)]
-    [InlineData(SmoothingMode.Default, SmoothingMode.None)]
-    [InlineData(SmoothingMode.HighQuality, SmoothingMode.AntiAlias)]
-    [InlineData(SmoothingMode.HighSpeed, SmoothingMode.None)]
-    [InlineData(SmoothingMode.None, SmoothingMode.None)]
-    public void SmoothingMode_SetValid_GetReturnsExpected(SmoothingMode smoothingMode, SmoothingMode expectedSmoothingMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.SmoothingMode = smoothingMode;
-            Assert.Equal(expectedSmoothingMode, graphics.SmoothingMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(SmoothingMode.Invalid - 1)]
-    [InlineData(SmoothingMode.AntiAlias + 1)]
-    public void SmoothingMode_SetInvalid_ThrowsInvalidEnumArgumentException(SmoothingMode smoothingMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.SmoothingMode = smoothingMode);
-        }
-    }
-
-    [Fact]
-    public void SmoothingMode_SetToInvalid_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.SmoothingMode = SmoothingMode.Invalid);
-        }
-    }
-
-    [Fact]
-    public void SmoothingMode_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.SmoothingMode);
-                Assert.Throws<InvalidOperationException>(() => graphics.SmoothingMode = SmoothingMode.AntiAlias);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void SmoothingMode_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.SmoothingMode);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.SmoothingMode = SmoothingMode.AntiAlias);
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(12)]
-    public void TextContrast_SetValid_GetReturnsExpected(int textContrast)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.TextContrast = textContrast;
-            Assert.Equal(textContrast, graphics.TextContrast);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(13)]
-    public void TextContrast_SetInvalid_ThrowsArgumentException(int textContrast)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TextContrast = textContrast);
-        }
-    }
-
-    [Fact]
-    public void TextContrast_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.TextContrast);
-                Assert.Throws<InvalidOperationException>(() => graphics.TextContrast = 5);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void TextContrast_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TextContrast);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TextContrast = 5);
-        }
-    }
-
-    [Theory]
-    [InlineData(TextRenderingHint.AntiAlias)]
-    [InlineData(TextRenderingHint.AntiAliasGridFit)]
-    [InlineData(TextRenderingHint.ClearTypeGridFit)]
-    [InlineData(TextRenderingHint.SingleBitPerPixel)]
-    [InlineData(TextRenderingHint.SingleBitPerPixelGridFit)]
-    [InlineData(TextRenderingHint.SystemDefault)]
-    public void TextRenderingHint_SetValid_GetReturnsExpected(TextRenderingHint textRenderingHint)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.TextRenderingHint = textRenderingHint;
-            Assert.Equal(textRenderingHint, graphics.TextRenderingHint);
-        }
-    }
-
-    [Theory]
-    [InlineData(TextRenderingHint.SystemDefault - 1)]
-    [InlineData(TextRenderingHint.ClearTypeGridFit + 1)]
-    public void TextRenderingHint_SetInvalid_ThrowsInvalidEnumArgumentException(TextRenderingHint textRenderingHint)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<InvalidEnumArgumentException>("value", () => graphics.TextRenderingHint = textRenderingHint);
-        }
-    }
-
-    [Fact]
-    public void TextRenderingHint_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.TextRenderingHint);
-                Assert.Throws<InvalidOperationException>(() => graphics.TextRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void TextRenderingHint_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TextRenderingHint);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TextRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetValid_GetReturnsExpected()
-    {
-        Color empty = Helpers.EmptyColor;
-        Color red = Color.FromArgb(Color.Red.ToArgb());
-
-        using (var image = new Bitmap(5, 5))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(red))
-        using (var matrix = new Matrix())
-        {
-            matrix.Scale(1f / 3, 2);
-            matrix.Translate(2, 1);
-            matrix.Rotate(270);
-
-            graphics.Transform = matrix;
-            graphics.FillRectangle(brush, new Rectangle(0, 0, 3, 2));
-            Helpers.VerifyBitmap(image, new Color[][]
-            {
-                new Color[] { empty, red,   empty, empty, empty },
-                new Color[] { empty, red,   empty, empty, empty },
-                new Color[] { empty, empty, empty, empty, empty },
-                new Color[] { empty, empty, empty, empty, empty },
-                new Color[] { empty, empty, empty, empty, empty }
-            });
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNull_ThrowsNullReferenceException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<NullReferenceException>(() => graphics.Transform = null);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetDisposedMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNonInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(5, 5))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void Transform_GetSetWhenBusy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var matrix = new Matrix())
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.Transform);
-                Assert.Throws<InvalidOperationException>(() => graphics.Transform = matrix);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Transform_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Transform);
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Invoke_SetsTransformToIdentity()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Assert.False(graphics.Transform.IsIdentity);
-
-            graphics.ResetTransform();
-            Assert.True(graphics.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.ResetTransform());
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ResetTransform());
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NoOrder_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Multiply(matrix);
-
-            graphics.MultiplyTransform(matrix);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend)]
-    [InlineData(MatrixOrder.Append)]
-    public void MultiplyTransform_Order_Success(MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Multiply(matrix, order);
-
-            graphics.MultiplyTransform(matrix, order);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => graphics.MultiplyTransform(null));
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => graphics.MultiplyTransform(null, MatrixOrder.Append));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_DisposedMatrix_Nop()
-    {
-        var brush = new LinearGradientBrush(new Rectangle(1, 2, 3, 4), Color.Plum, Color.Red, 45, true);
-        Matrix transform = brush.Transform;
-
-        var matrix = new Matrix();
-        matrix.Dispose();
-
-        brush.MultiplyTransform(matrix);
-        brush.MultiplyTransform(matrix, MatrixOrder.Append);
-
-        Assert.Equal(transform, brush.Transform);
-    }
-
-    [Fact]
-    public void MultiplyTransform_NonInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.MultiplyTransform(matrix, MatrixOrder.Append));
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void MultiplyTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.MultiplyTransform(matrix, order));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var matrix = new Matrix())
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.MultiplyTransform(matrix));
-                Assert.Throws<InvalidOperationException>(() => graphics.MultiplyTransform(matrix, MatrixOrder.Append));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.MultiplyTransform(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void TranslateTransform_NoOrder_Success(float dx, float dy)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Translate(dx, dy);
-
-            graphics.TranslateTransform(dx, dy);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 1, MatrixOrder.Prepend)]
-    [InlineData(1, 1, MatrixOrder.Append)]
-    [InlineData(0, 0, MatrixOrder.Prepend)]
-    [InlineData(0, 0, MatrixOrder.Append)]
-    [InlineData(-1, -1, MatrixOrder.Prepend)]
-    [InlineData(-1, -1, MatrixOrder.Append)]
-    public void TranslateTransform_Order_Success(float dx, float dy, MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Translate(dx, dy, order);
-
-            graphics.TranslateTransform(dx, dy, order);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void TranslateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TranslateTransform(0, 0, order));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.TranslateTransform(0, 0));
-                Assert.Throws<InvalidOperationException>(() => graphics.TranslateTransform(0, 0, MatrixOrder.Append));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TranslateTransform(0, 0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TranslateTransform(0, 0, MatrixOrder.Append));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, -2)]
-    [InlineData(1, 2)]
-    public void ScaleTransform_NoOrder_Success(float sx, float sy)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Scale(sx, sy);
-
-            graphics.ScaleTransform(sx, sy);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 1, MatrixOrder.Prepend)]
-    [InlineData(1, 1, MatrixOrder.Append)]
-    [InlineData(-1, -1, MatrixOrder.Prepend)]
-    [InlineData(-1, -1, MatrixOrder.Append)]
-    public void ScaleTransform_Order_Success(float sx, float sy, MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Scale(sx, sy, order);
-
-            graphics.ScaleTransform(sx, sy, order);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_ZeroZero_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ScaleTransform(0, 0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ScaleTransform(0, 0, MatrixOrder.Append));
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void ScaleTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ScaleTransform(0, 0, order));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.ScaleTransform(0, 0));
-                Assert.Throws<InvalidOperationException>(() => graphics.ScaleTransform(0, 0, MatrixOrder.Append));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ScaleTransform(0, 0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.ScaleTransform(0, 0, MatrixOrder.Append));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(360)]
-    public void RotateTransform_NoOrder_Success(float angle)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Rotate(angle);
-
-            graphics.RotateTransform(angle);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(1, MatrixOrder.Prepend)]
-    [InlineData(1, MatrixOrder.Append)]
-    [InlineData(0, MatrixOrder.Prepend)]
-    [InlineData(360, MatrixOrder.Append)]
-    [InlineData(-1, MatrixOrder.Prepend)]
-    [InlineData(-1, MatrixOrder.Append)]
-    public void RotateTransform_Order_Success(float angle, MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-            Matrix expectedTransform = graphics.Transform;
-            expectedTransform.Rotate(angle, order);
-
-            graphics.RotateTransform(angle, order);
-            Assert.Equal(expectedTransform, graphics.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void RotateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder order)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.RotateTransform(0, order));
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.RotateTransform(0));
-                Assert.Throws<InvalidOperationException>(() => graphics.RotateTransform(0, MatrixOrder.Append));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.RotateTransform(0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.RotateTransform(0, MatrixOrder.Append));
-        }
-    }
-
-    public static IEnumerable<object[]> CopyFromScreen_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, new Size(0, 0) };
-        yield return new object[] { int.MinValue, int.MinValue, 0, 0, new Size(1, 1) };
-        yield return new object[] { int.MaxValue, int.MaxValue, 0, 0, new Size(1, 1) };
-        yield return new object[] { int.MaxValue, int.MaxValue, 0, 0, new Size(1, 1) };
-        yield return new object[] { 0, 0, -1, -1, new Size(1, 1) };
-        yield return new object[] { 0, 0, int.MaxValue, int.MaxValue, new Size(1, 1) };
-        yield return new object[] { 0, 0, 0, 0, new Size(-1, -1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(CopyFromScreen_TestData))]
-    public void CopyFromScreen_OutOfRange_DoesNotAffectGraphics(int sourceX, int sourceY, int destinationX, int destinationY, Size size)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Color plum = Color.FromArgb(Color.Plum.ToArgb());
-            image.SetPixel(0, 0, plum);
-
-            graphics.CopyFromScreen(sourceX, sourceY, destinationX, destinationY, size);
-            graphics.CopyFromScreen(new Point(sourceX, sourceY), new Point(destinationX, destinationY), size);
-            Assert.Equal(plum, image.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0, 0, 0, 10, 10)]
-    [InlineData(0, 0, 0, 0, int.MaxValue, int.MaxValue)]
-    [InlineData(1, 1, 2, 2, 3, 3)]
-    public void CopyFromScreen_ValidRange_AffectsGraphics(int sourceX, int sourceY, int destinationX, int destinationY, int width, int height)
-    {
-        Color color = Color.FromArgb(2, 3, 4);
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using SolidBrush brush = new(color);
-
-        graphics.FillRectangle(brush, new Rectangle(0, 0, 10, 10));
-        graphics.CopyFromScreen(sourceX, sourceY, destinationX, destinationY, new Size(width, height));
-
-        Rectangle drawnRect = new Rectangle(destinationX, destinationY, width, height);
-        for (int y = 0; y < image.Height; y++)
-        {
-            for (int x = 0; x < image.Width; x++)
-            {
-                Color imageColor = image.GetPixel(x, y);
-                if (!drawnRect.Contains(x, y))
-                {
-                    Assert.Equal(color, imageColor);
-                }
-                else
-                {
-                    Assert.NotEqual(color, imageColor);
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> CopyPixelOperation_TestData()
-    {
-        yield return new object[] { CopyPixelOperation.NoMirrorBitmap };
-        yield return new object[] { CopyPixelOperation.Blackness };
-        yield return new object[] { CopyPixelOperation.NotSourceErase };
-        yield return new object[] { CopyPixelOperation.NotSourceCopy };
-        yield return new object[] { CopyPixelOperation.SourceErase };
-        yield return new object[] { CopyPixelOperation.DestinationInvert };
-        yield return new object[] { CopyPixelOperation.PatInvert };
-        yield return new object[] { CopyPixelOperation.SourceInvert };
-        yield return new object[] { CopyPixelOperation.SourceAnd };
-        yield return new object[] { CopyPixelOperation.MergePaint };
-        yield return new object[] { CopyPixelOperation.MergeCopy };
-        yield return new object[] { CopyPixelOperation.SourceCopy };
-        yield return new object[] { CopyPixelOperation.SourcePaint };
-        yield return new object[] { CopyPixelOperation.SourceCopy };
-        yield return new object[] { CopyPixelOperation.PatCopy };
-        yield return new object[] { CopyPixelOperation.PatPaint };
-        yield return new object[] { CopyPixelOperation.Whiteness };
-        yield return new object[] { CopyPixelOperation.CaptureBlt };
-        yield return new object[] { CopyPixelOperation.CaptureBlt };
-    }
-
-    [Theory]
-    [MemberData(nameof(CopyPixelOperation_TestData))]
-    public void CopyFromScreen_IntsAndValidCopyPixelOperation_Success(CopyPixelOperation copyPixelOperation)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            // We don't know what the screen looks like at this point in time, so
-            // just make sure that this doesn't fail.
-            graphics.CopyFromScreen(0, 0, 0, 0, new Size(1, 1), copyPixelOperation);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(CopyPixelOperation_TestData))]
-    public void CopyFromScreen_PointsAndValidCopyPixelOperation_Success(CopyPixelOperation copyPixelOperation)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            // We don't know what the screen looks like at this point in time, so
-            // just make sure that this doesn't fail.
-            graphics.CopyFromScreen(Point.Empty, Point.Empty, new Size(1, 1), copyPixelOperation);
-        }
-    }
-
-    [Theory]
-    [InlineData(CopyPixelOperation.NoMirrorBitmap + 1)]
-    [InlineData(CopyPixelOperation.Blackness - 1)]
-    [InlineData(CopyPixelOperation.NotSourceErase - 1)]
-    [InlineData(CopyPixelOperation.NotSourceCopy - 1)]
-    [InlineData(CopyPixelOperation.SourceErase - 1)]
-    [InlineData(CopyPixelOperation.DestinationInvert - 1)]
-    [InlineData(CopyPixelOperation.PatInvert - 1)]
-    [InlineData(CopyPixelOperation.SourceInvert - 1)]
-    [InlineData(CopyPixelOperation.SourceAnd - 1)]
-    [InlineData(CopyPixelOperation.MergePaint - 1)]
-    [InlineData(CopyPixelOperation.MergeCopy - 1)]
-    [InlineData(CopyPixelOperation.SourceCopy - 1)]
-    [InlineData(CopyPixelOperation.SourcePaint - 1)]
-    [InlineData(CopyPixelOperation.PatCopy - 1)]
-    [InlineData(CopyPixelOperation.PatPaint - 1)]
-    [InlineData(CopyPixelOperation.Whiteness - 1)]
-    [InlineData(CopyPixelOperation.CaptureBlt - 1)]
-    [InlineData(CopyPixelOperation.CaptureBlt + 1)]
-    public void CopyFromScreen_InvalidCopyPixelOperation_ThrowsInvalidEnumArgumentException(CopyPixelOperation copyPixelOperation)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => graphics.CopyFromScreen(1, 2, 3, 4, Size.Empty, copyPixelOperation));
-        }
-    }
-
-    [Fact]
-    public void CopyFromScreen_Busy_ThrowsInvalidOperationException()
-    {
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        nint hdc = graphics.GetHdc();
-        try
-        {
-            Assert.Throws<InvalidOperationException>(() => graphics.CopyFromScreen(0, 0, 0, 0, Size.Empty));
-            Assert.Throws<InvalidOperationException>(() => graphics.CopyFromScreen(0, 0, 0, 0, Size.Empty, CopyPixelOperation.DestinationInvert));
-            Assert.Throws<InvalidOperationException>(() => graphics.CopyFromScreen(Point.Empty, Point.Empty, Size.Empty));
-            Assert.Throws<InvalidOperationException>(() => graphics.CopyFromScreen(Point.Empty, Point.Empty, Size.Empty, CopyPixelOperation.DestinationInvert));
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [Fact]
-    public void CopyFromScreen_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CopyFromScreen(0, 0, 0, 0, Size.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CopyFromScreen(0, 0, 0, 0, Size.Empty, CopyPixelOperation.MergeCopy));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CopyFromScreen(Point.Empty, Point.Empty, Size.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.CopyFromScreen(Point.Empty, Point.Empty, Size.Empty, CopyPixelOperation.MergeCopy));
-        }
-    }
-
-    public static IEnumerable<object[]> TransformPoints_TestData()
-    {
-        yield return new object[]
-        {
-            CoordinateSpace.Device,
-            CoordinateSpace.Page,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(1, 1), new Point(2, 2) }
-        };
-
-        yield return new object[]
-        {
-           CoordinateSpace.Device,
-            CoordinateSpace.World,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(9, 12), new Point(13, 18) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.Page,
-            CoordinateSpace.Device,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(1, 1), new Point(2, 2) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.Page,
-            CoordinateSpace.World,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(9, 12), new Point(13, 18) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.World,
-            CoordinateSpace.Device,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(1, -1), new Point(0, -1) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.World,
-            CoordinateSpace.Page,
-            new Point[] { new Point(1, 1), new Point(2, 2) },
-            new Point[] { new Point(1, -1), new Point(0, -1) }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformPoints_TestData))]
-    public void TransformPoints_Points_Success(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] points, Point[] expected)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.PageScale = 10;
-            graphics.Transform = transform;
-
-            graphics.TransformPoints(destSpace, srcSpace, points);
-            Assert.Equal(expected, points);
-        }
-    }
-
-    public static IEnumerable<object[]> TransformPointFs_TestData()
-    {
-        yield return new object[]
-        {
-            CoordinateSpace.Device,
-            CoordinateSpace.Page,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new Point(1, 1), new Point(2, 2) }
-        };
-
-        yield return new object[]
-        {
-           CoordinateSpace.Device,
-            CoordinateSpace.World,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new Point(9, 12), new Point(13, 18) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.Page,
-            CoordinateSpace.Device,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new Point(1, 1), new Point(2, 2) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.Page,
-            CoordinateSpace.World,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new Point(9, 12), new Point(13, 18) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.World,
-            CoordinateSpace.Device,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new PointF(0.5f, -1.5f), new Point(0, -1) }
-        };
-
-        yield return new object[]
-        {
-            CoordinateSpace.World,
-            CoordinateSpace.Page,
-            new PointF[] { new Point(1, 1), new Point(2, 2) },
-            new PointF[] { new PointF(0.5f, -1.5f), new Point(0, -1) }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(TransformPointFs_TestData))]
-    public void TransformPoints_PointFs_Success(CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF[] points, PointF[] expected)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.PageScale = 10;
-            graphics.Transform = transform;
-
-            graphics.TransformPoints(destSpace, srcSpace, points);
-            Assert.Equal(expected, points);
-        }
-    }
-
-    [Theory]
-    [InlineData(CoordinateSpace.Device)]
-    [InlineData(CoordinateSpace.World)]
-    [InlineData(CoordinateSpace.Page)]
-    public void TransformPoints_PointsAndSameCoordinateSpace_DoesNothing(CoordinateSpace space)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-
-            var points = new Point[] { new Point(1, 1) };
-            graphics.TransformPoints(space, space, points);
-            Assert.Equal(new Point[] { new Point(1, 1) }, points);
-        }
-    }
-
-    [Theory]
-    [InlineData(CoordinateSpace.Device)]
-    [InlineData(CoordinateSpace.World)]
-    [InlineData(CoordinateSpace.Page)]
-    public void TransformPoints_PointFsAndSameCoordinateSpace_DoesNothing(CoordinateSpace space)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            graphics.Transform = transform;
-
-            var points = new PointF[] { new PointF(1, 1) };
-            graphics.TransformPoints(space, space, points);
-            Assert.Equal(new PointF[] { new PointF(1, 1) }, points);
-        }
-    }
-
-    [Theory]
-    [InlineData(CoordinateSpace.World - 1)]
-    [InlineData(CoordinateSpace.Device + 1)]
-    public void TransformPoints_InvalidDestSpace_ThrowsArgumentException(CoordinateSpace destSpace)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(destSpace, CoordinateSpace.World, new Point[] { new Point(1, 1) }));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(destSpace, CoordinateSpace.World, new PointF[] { new PointF(1, 1) }));
-        }
-    }
-
-    [Theory]
-    [InlineData(CoordinateSpace.World - 1)]
-    [InlineData(CoordinateSpace.Device + 1)]
-    public void TransformPoints_InvalidSourceSpace_ThrowsArgumentException(CoordinateSpace srcSpace)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.World, srcSpace, new Point[] { new Point(1, 1) }));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.World, srcSpace, new PointF[] { new PointF(1, 1) }));
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("pts", () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, (PointF[])null));
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_EmptyPoints_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new Point[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new Point[] { Point.Empty }));
-                Assert.Throws<InvalidOperationException>(() => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new PointF[] { PointF.Empty }));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void TransformPoints_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new Point[] { Point.Empty }));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Page, new PointF[] { PointF.Empty }));
-        }
-    }
-
-    public static IEnumerable<object[]> GetNearestColor_TestData()
-    {
-        yield return new object[] { PixelFormat.Format32bppArgb, Color.Red, Color.FromArgb(Color.Red.ToArgb()) };
-        yield return new object[] { PixelFormat.Format16bppRgb555, Color.Red, Color.FromArgb(255, 248, 0, 0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetNearestColor_TestData))]
-    public void GetNearestColor_Color_ReturnsExpected(PixelFormat pixelFormat, Color color, Color expected)
-    {
-        using (var image = new Bitmap(10, 10, pixelFormat))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Equal(expected, graphics.GetNearestColor(color));
-        }
-    }
-
-    [Fact]
-    public void GetNearestColor_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.GetNearestColor(Color.Red));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void GetNearestColor_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.GetNearestColor(Color.Red));
-        }
-    }
-
-    [Fact]
-    public void DrawArc_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawArc(null, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawArc(null, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawArc(null, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawArc(null, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawArc_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawArc_ZeroWidth_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 0, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 0, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 0, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 0f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawArc_ZeroHeight_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 0), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 1, 0, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 0), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 1f, 0f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawArc_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawArc(pen, 0, 0, 1, 1, 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawArc(pen, 0f, 0f, 1f, 1f, 0, 90));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawArc_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangle(null, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangle(null, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangle(null, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangle(pen, new Rectangle(0, 0, 1, 1)));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangle(pen, 0, 0, 1, 1));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangle(pen, 0f, 0f, 1f, 1f));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangle(pen, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangles(null, new Rectangle[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawRectangles(null, new RectangleF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new Rectangle[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new RectangleF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_NullRectangles_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("rects", () => graphics.DrawRectangles(pen, (Rectangle[])null));
-            AssertExtensions.Throws<ArgumentNullException>("rects", () => graphics.DrawRectangles(pen, (RectangleF[])null));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_EmptyRectangles_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new Rectangle[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new RectangleF[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangles(pen, new Rectangle[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawRectangles(pen, new RectangleF[2]));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new Rectangle[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawRectangles(pen, new RectangleF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawEllipse_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawEllipse(null, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawEllipse(null, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawEllipse(null, new RectangleF(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawEllipse(null, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawEllipse_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, new RectangleF(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawEllipse_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawEllipse(pen, new Rectangle(0, 0, 1, 1)));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawEllipse(pen, 0, 0, 1, 1));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawEllipse(pen, new RectangleF(0, 0, 1, 1)));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawEllipse(pen, 0f, 0f, 1f, 1f));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawEllipse_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, new Rectangle(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, 0, 0, 1, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, new RectangleF(0, 0, 1, 1)));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawEllipse(pen, 0f, 0f, 1f, 1f));
-        }
-    }
-
-    [Fact]
-    public void DrawPie_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPie(null, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPie(null, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPie(null, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPie(null, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawPie_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawPie_ZeroWidth_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new Rectangle(0, 0, 0, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0, 0, 0, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new RectangleF(0, 0, 0, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0f, 0f, 0f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawPie_ZeroHeight_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 0), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 1, 0, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 0), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 1f, 0f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawPie_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPie(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPie(pen, 0, 0, 1, 1, 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPie(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPie(pen, 0f, 0f, 1f, 1f, 0, 90));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawPie_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPie(pen, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawPolygon_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPolygon(null, new Point[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPolygon(null, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawPolygon_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawPolygon_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawPolygon(pen, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawPolygon(pen, (PointF[])null));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DrawPolygon_InvalidPointsLength_ThrowsArgumentException(int length)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new Point[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new PointF[length]));
-        }
-    }
-
-    [Fact]
-    public void DrawPolygon_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPolygon(pen, new Point[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPolygon(pen, new PointF[2]));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawPolygon_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPolygon(pen, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var graphicsPath = new GraphicsPath())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawPath(null, graphicsPath));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var graphicsPath = new GraphicsPath())
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPath(pen, graphicsPath));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_NullPath_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => graphics.DrawPath(pen, null));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_DisposedPath_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            var graphicsPath = new GraphicsPath();
-            graphicsPath.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPath(pen, graphicsPath));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        using (var graphicsPath = new GraphicsPath())
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawPath(pen, graphicsPath));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawPath_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        using (var graphicsPath = new GraphicsPath())
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawPath(pen, graphicsPath));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new Point[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new PointF[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new Point[2], 1));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new PointF[2], 1));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new PointF[2], 0, 2));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new Point[2], 0, 2, 1));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawCurve(null, new PointF[2], 0, 2, 1));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 0, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2], 0, 2, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 0, 2, 1));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (PointF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (Point[])null, 1));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (PointF[])null, 1));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (PointF[])null, 0, 2));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (Point[])null, 0, 2, 1));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawCurve(pen, (PointF[])null, 0, 2, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DrawCurve_InvalidPointsLength_ThrowsArgumentException(int length)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[length], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length], 0, length));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[length], 0, length, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length], 0, length, 1));
-        }
-    }
-
-    [Theory]
-    [InlineData(4, -1, 4)]
-    [InlineData(4, 0, -1)]
-    [InlineData(4, 4, 0)]
-    [InlineData(4, 0, 5)]
-    [InlineData(4, 3, 2)]
-    public void DrawCurve_InvalidOffsetCount_ThrowsArgumentException(int length, int offset, int numberOfSegments)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length], offset, numberOfSegments));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[length], offset, numberOfSegments, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[length], offset, numberOfSegments, 1));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new Point[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new PointF[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new Point[2], 1));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new PointF[2], 1));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new PointF[2], 0, 2));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new Point[2], 0, 2, 1));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawCurve(pen, new PointF[2], 0, 2, 1));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 0, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new Point[2], 0, 2, 1));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawCurve(pen, new PointF[2], 0, 2, 1));
-        }
-    }
-
-    [Fact]
-    public void DrawClosedCurve_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawClosedCurve(null, new Point[3]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawClosedCurve(null, new Point[3], 1, FillMode.Winding));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawClosedCurve(null, new PointF[3]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawClosedCurve(null, new PointF[3], 1, FillMode.Winding));
-        }
-    }
-
-    [Fact]
-    public void DrawClosedCurve_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[3]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[3], 1, FillMode.Winding));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[3]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[3], 1, FillMode.Winding));
-        }
-    }
-
-    [Fact]
-    public void DrawClosedCurve_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawClosedCurve(pen, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawClosedCurve(pen, (Point[])null, 1, FillMode.Winding));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawClosedCurve(pen, (PointF[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawClosedCurve(pen, (PointF[])null, 1, FillMode.Winding));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void DrawClosedCurve_InvalidPointsLength_ThrowsArgumentException(int length)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[length], 1, FillMode.Winding));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[length], 1, FillMode.Winding));
-        }
-    }
-
-    [Fact]
-    public void DrawClosedCurve_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawClosedCurve(pen, new Point[3]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawClosedCurve(pen, new Point[3], 1, FillMode.Winding));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawClosedCurve(pen, new PointF[3]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawClosedCurve(pen, new PointF[3], 1, FillMode.Winding));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawClosedCurve_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[3]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new Point[3], 1, FillMode.Alternate));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[3]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawClosedCurve(pen, new PointF[3], 1, FillMode.Alternate));
-        }
-    }
-
-    [Fact]
-    public void FillPie_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("brush", () => graphics.FillPie(null, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("brush", () => graphics.FillPie(null, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentNullException>("brush", () => graphics.FillPie(null, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void FillPie_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var brush = new SolidBrush(Color.Red);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void FillPie_ZeroWidth_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new Rectangle(0, 0, 0, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0, 0, 0, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0f, 0f, 0f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void FillPie_ZeroHeight_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new Rectangle(0, 0, 1, 0), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0, 0, 1, 0, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0f, 0f, 1f, 0f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void FillPie_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.FillPie(brush, new Rectangle(0, 0, 1, 1), 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.FillPie(brush, 0, 0, 1, 1, 0, 90));
-                Assert.Throws<InvalidOperationException>(() => graphics.FillPie(brush, 0f, 0f, 1f, 1f, 0, 90));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void FillPie_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.FillPie(brush, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void Clear_Color_Success()
-    {
-        Color color = Color.FromArgb(Color.Plum.ToArgb());
-
-        using (var image = new Bitmap(2, 2))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var brush = new SolidBrush(color))
-        {
-            graphics.FillRectangle(brush, new Rectangle(0, 0, 2, 2));
-
-            graphics.Clear(color);
-            Helpers.VerifyBitmap(image, new Color[][]
-            {
-                new Color[] { color, color },
-                new Color[] { color, color }
-            });
-        }
-    }
-
-    [Fact]
-    public void Clear_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.Clear(Color.Red));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void Clear_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.Clear(Color.Red));
-        }
-    }
-
-    [Fact]
-    public void DrawString_DefaultFont_Succeeds()
-    {
-        using (var image = new Bitmap(50, 50))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.DrawString("Test text", SystemFonts.DefaultFont, Brushes.White, new Point());
-            Helpers.VerifyBitmapNotBlank(image);
-        }
-    }
-
-    [Fact]
-    public void DrawString_CompositingModeSourceCopy_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.CompositingMode = CompositingMode.SourceCopy;
-            AssertExtensions.Throws<ArgumentException>(
-                null,
-                () => graphics.DrawString("Test text", SystemFonts.DefaultFont, Brushes.White, new Point()));
-        }
-    }
-
-    private static void VerifyGraphics(Graphics graphics, RectangleF expectedVisibleClipBounds)
-    {
-        Assert.NotNull(graphics.Clip);
-        Assert.Equal(new RectangleF(-4194304, -4194304, 8388608, 8388608), graphics.ClipBounds);
-        Assert.Equal(CompositingMode.SourceOver, graphics.CompositingMode);
-        Assert.Equal(CompositingQuality.Default, graphics.CompositingQuality);
-        Assert.Equal(96, graphics.DpiX);
-        Assert.Equal(96, graphics.DpiY);
-        Assert.Equal(InterpolationMode.Bilinear, graphics.InterpolationMode);
-        Assert.False(graphics.IsClipEmpty);
-        Assert.False(graphics.IsVisibleClipEmpty);
-        Assert.Equal(1, graphics.PageScale);
-        Assert.Equal(GraphicsUnit.Display, graphics.PageUnit);
-        Assert.Equal(PixelOffsetMode.Default, graphics.PixelOffsetMode);
-        Assert.Equal(Point.Empty, graphics.RenderingOrigin);
-        Assert.Equal(SmoothingMode.None, graphics.SmoothingMode);
-        Assert.Equal(4, graphics.TextContrast);
-        Assert.Equal(TextRenderingHint.SystemDefault, graphics.TextRenderingHint);
-        Assert.Equal(new Matrix(), graphics.Transform);
-        Assert.Equal(expectedVisibleClipBounds, graphics.VisibleClipBounds);
-    }
-
-#if NET8_0_OR_GREATER
-    [Fact]
-    public void DrawCachedBitmap_ThrowsArgumentNullException()
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-
-        Assert.Throws<ArgumentNullException>(() => graphics.DrawCachedBitmap(null!, 0, 0));
-    }
-
-    [Fact]
-    public void DrawCachedBitmap_DisposedBitmap_ThrowsArgumentException()
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        CachedBitmap cachedBitmap = new(bitmap, graphics);
-        cachedBitmap.Dispose();
-
-        Assert.Throws<ArgumentException>(() => graphics.DrawCachedBitmap(cachedBitmap, 0, 0));
-    }
-
-    [Fact]
-    public void DrawCachedBitmap_Simple()
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using CachedBitmap cachedBitmap = new(bitmap, graphics);
-
-        graphics.DrawCachedBitmap(cachedBitmap, 0, 0);
-    }
-
-    [Fact]
-    public void DrawCachedBitmap_Translate()
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        graphics.TranslateTransform(1.0f, 8.0f);
-        using CachedBitmap cachedBitmap = new(bitmap, graphics);
-
-        graphics.DrawCachedBitmap(cachedBitmap, 0, 0);
-    }
-
-    [Fact]
-    public void DrawCachedBitmap_Rotation_ThrowsInvalidOperation()
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        graphics.RotateTransform(36.0f);
-        using CachedBitmap cachedBitmap = new(bitmap, graphics);
-
-        Assert.Throws<InvalidOperationException>(() => graphics.DrawCachedBitmap(cachedBitmap, 0, 0));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format16bppRgb555, PixelFormat.Format32bppRgb, false)]
-    [InlineData(PixelFormat.Format32bppRgb, PixelFormat.Format16bppRgb555, true)]
-    [InlineData(PixelFormat.Format32bppArgb, PixelFormat.Format16bppRgb555, false)]
-    public void DrawCachedBitmap_ColorDepthChange_ThrowsInvalidOperation(
-        PixelFormat sourceFormat,
-        PixelFormat destinationFormat,
-        bool shouldSucceed)
-    {
-        using Bitmap bitmap = new(10, 10, sourceFormat);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using CachedBitmap cachedBitmap = new(bitmap, graphics);
-
-        using Bitmap bitmap2 = new(10, 10, destinationFormat);
-        using Graphics graphics2 = Graphics.FromImage(bitmap2);
-
-        if (shouldSucceed)
-        {
-            graphics2.DrawCachedBitmap(cachedBitmap, 0, 0);
-        }
-        else
-        {
-            Assert.Throws<InvalidOperationException>(() => graphics2.DrawCachedBitmap(cachedBitmap, 0, 0));
-        }
-    }
-#endif
-}
diff --git a/src/System.Drawing.Common/tests/Graphics_DrawBezierTests.cs b/src/System.Drawing.Common/tests/Graphics_DrawBezierTests.cs
deleted file mode 100644
index 8baed936268..00000000000
--- a/src/System.Drawing.Common/tests/Graphics_DrawBezierTests.cs
+++ /dev/null
@@ -1,203 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class Graphics_DrawBezierTests : DrawingTest
-{
-    [Fact]
-    public void DrawBezier_Point()
-    {
-        using Bitmap bitmap = new(100, 100);
-        using Pen pen = new(Color.White);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-
-        graphics.DrawBezier(pen, new(10, 10), new(20, 1), new(35, 5), new(50, 10));
-        ValidateBitmapContent(
-            bitmap,
-            0x35, 0xa8, 0x3a, 0x03, 0x1e, 0xbd, 0xd4, 0xc0, 0xa4, 0x70, 0x51, 0xba, 0x09, 0xc1, 0xc1, 0xf9);
-    }
-
-    [Fact]
-    public void DrawBezier_Points()
-    {
-        using Bitmap bitmap = new(100, 100);
-        using Pen pen = new(Color.Red);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Point[] points =
-        {
-            new(10, 10), new(20, 1), new(35, 5), new(50, 10),
-            new(60, 15), new(65, 25), new(50, 30)
-        };
-
-        graphics.DrawBeziers(pen, points);
-        ValidateBitmapContent(
-            bitmap,
-            0x7a, 0x02, 0x29, 0xa0, 0xc5, 0x21, 0x94, 0x31, 0xc8, 0x96, 0x31, 0x09, 0xcc, 0xd6, 0xec, 0x63);
-    }
-
-    [Fact]
-    public void DrawBezier_PointFs()
-    {
-        using Bitmap bitmap = new(100, 100);
-        using Pen pen = new(Color.Red);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        PointF[] points =
-        {
-            new(10.0f, 10.0f), new(20.0f, 1.0f), new(35.0f, 5.0f), new(50.0f, 10.0f),
-            new(60.0f, 15.0f), new(65.0f, 25.0f), new(50.0f, 30.0f)
-        };
-
-        graphics.DrawBeziers(pen, points);
-        ValidateBitmapContent(
-            bitmap,
-            0x7a, 0x02, 0x29, 0xa0, 0xc5, 0x21, 0x94, 0x31, 0xc8, 0x96, 0x31, 0x09, 0xcc, 0xd6, 0xec, 0x63);
-    }
-
-    [Fact]
-    public void DrawBezier_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawBezier(null, 1, 2, 3, 4, 5, 6, 7, 8));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawBezier(null, Point.Empty, Point.Empty, Point.Empty, Point.Empty));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawBezier(null, PointF.Empty, PointF.Empty, PointF.Empty, PointF.Empty));
-        }
-    }
-
-    [Fact]
-    public void DrawBezier_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBezier(pen, 1, 2, 3, 4, 5, 6, 7, 8));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBezier(pen, Point.Empty, Point.Empty, Point.Empty, Point.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBezier(pen, PointF.Empty, PointF.Empty, PointF.Empty, PointF.Empty));
-        }
-    }
-
-    [Fact]
-    public void DrawBezier_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, 1, 2, 3, 4, 5, 6, 7, 8));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, Point.Empty, Point.Empty, Point.Empty, Point.Empty));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawBezier(pen, PointF.Empty, PointF.Empty, PointF.Empty, PointF.Empty));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawBezier_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new Rectangle(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0, 0, 1, 1, 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, new RectangleF(0, 0, 1, 1), 0, 90));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawArc(pen, 0f, 0f, 1f, 1f, 0, 90));
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawBeziers(null, new Point[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawBeziers(null, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawBeziers(pen, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawBeziers(pen, (PointF[])null));
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_EmptyPoints_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new Point[0]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawBeziers(pen, new Point[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawBeziers(pen, new PointF[2]));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawBeziers_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawBeziers(pen, new PointF[2]));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Graphics_DrawLineTests.cs b/src/System.Drawing.Common/tests/Graphics_DrawLineTests.cs
deleted file mode 100644
index 8c091cc8b33..00000000000
--- a/src/System.Drawing.Common/tests/Graphics_DrawLineTests.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class Graphics_DrawLineTests : DrawingTest
-{
-    [Fact]
-    public void DrawLines_Points()
-    {
-        using Bitmap bitmap = new(100, 100);
-        using Pen pen = new(Color.White);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-
-        graphics.DrawLines(pen, new Point[] { new(1, 1), new(1, 10), new(20, 5), new(25, 30) });
-
-        ValidateBitmapContent(
-            bitmap,
-            0xeb, 0xc6, 0x1e, 0xbf, 0xc0, 0x42, 0xa7, 0xfd, 0xcd, 0x24, 0xbc, 0x1c, 0x79, 0x0a, 0x69, 0x07);
-    }
-
-    [Fact]
-    public void DrawLines_PointFs()
-    {
-        using Bitmap bitmap = new(100, 100);
-        using Pen pen = new(Color.White);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-
-        graphics.DrawLines(pen, new PointF[] { new(1.0f, 1.0f), new(1.0f, 10.0f), new(20.0f, 5.0f), new(25.0f, 30.0f) });
-
-        ValidateBitmapContent(
-            bitmap,
-            0xeb, 0xc6, 0x1e, 0xbf, 0xc0, 0x42, 0xa7, 0xfd, 0xcd, 0x24, 0xbc, 0x1c, 0x79, 0x0a, 0x69, 0x07);
-    }
-
-    [Fact]
-    public void DrawLine_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLine(null, Point.Empty, Point.Empty));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLine(null, 0, 0, 0, 0));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLine(null, PointF.Empty, PointF.Empty));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLine(null, 0f, 0f, 0f, 0f));
-        }
-    }
-
-    [Fact]
-    public void DrawLine_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, Point.Empty, Point.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, 0, 0, 0, 0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, PointF.Empty, PointF.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, 0f, 0f, 0f, 0f));
-        }
-    }
-
-    [Fact]
-    public void DrawLine_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, Point.Empty, Point.Empty));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, 0, 0, 0, 0));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, PointF.Empty, PointF.Empty));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLine(pen, 0f, 0f, 0f, 0f));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawLine_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, Point.Empty, Point.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, 0, 0, 0, 0));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, PointF.Empty, PointF.Empty));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLine(pen, 0f, 0f, 0f, 0f));
-        }
-    }
-
-    [Fact]
-    public void DrawLines_NullPen_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLines(null, new Point[2]));
-            AssertExtensions.Throws<ArgumentNullException>("pen", () => graphics.DrawLines(null, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawLines_DisposedPen_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var pen = new Pen(Color.Red);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new PointF[2]));
-        }
-    }
-
-    [Fact]
-    public void DrawLines_NullPoints_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawLines(pen, (Point[])null));
-            AssertExtensions.Throws<ArgumentNullException>("points", () => graphics.DrawLines(pen, (PointF[])null));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DrawLines_InvalidPointsLength_ThrowsArgumentException(int length)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new Point[length]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new PointF[length]));
-        }
-    }
-
-    [Fact]
-    public void DrawLines_Busy_ThrowsInvalidOperationException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (var pen = new Pen(Color.Red))
-        {
-            graphics.GetHdc();
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLines(pen, new Point[2]));
-                Assert.Throws<InvalidOperationException>(() => graphics.DrawLines(pen, new PointF[2]));
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawLines_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var pen = new Pen(Color.Red))
-        {
-            Graphics graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new Point[2]));
-            AssertExtensions.Throws<ArgumentException>(null, () => graphics.DrawLines(pen, new PointF[2]));
-        }
-    }
-
-}
diff --git a/src/System.Drawing.Common/tests/Graphics_GetContextTests.Core.cs b/src/System.Drawing.Common/tests/Graphics_GetContextTests.Core.cs
deleted file mode 100644
index 8852eedf660..00000000000
--- a/src/System.Drawing.Common/tests/Graphics_GetContextTests.Core.cs
+++ /dev/null
@@ -1,147 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-using System.Numerics;
-
-namespace System.Drawing.Tests;
-
-public partial class Graphics_GetContextTests
-{
-    [Fact]
-    public void GetContextInfo_New_DefaultGraphics()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.GetContextInfo(out PointF offset);
-            Assert.True(offset.IsEmpty);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.True(offset.IsEmpty);
-            Assert.Null(clip);
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_Clipping()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-
-            graphics.GetContextInfo(out PointF offset);
-            Assert.True(offset.IsEmpty);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.True(offset.IsEmpty);
-            Assert.NotNull(clip);
-            Assert.Equal(initialClip.GetBounds(graphics), clip.GetBounds(graphics));
-            clip.Dispose();
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_Transform()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.TransformElements = Matrix3x2.CreateTranslation(1, 2);
-
-            graphics.GetContextInfo(out PointF offset);
-            Assert.Equal(new PointF(1, 2), offset);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.Null(clip);
-            Assert.Equal(new PointF(1, 2), offset);
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_ClipAndTransform()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-            graphics.TransformElements = Matrix3x2.CreateTranslation(1, 2);
-
-            graphics.GetContextInfo(out PointF offset);
-            Assert.Equal(new PointF(1, 2), offset);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.NotNull(clip);
-            Assert.Equal(new RectangleF(0, 0, 9, 10), clip.GetBounds(graphics));
-            Assert.Equal(new PointF(1, 2), offset);
-            clip.Dispose();
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_TransformAndClip()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.TransformElements = Matrix3x2.CreateTranslation(1, 2);
-            graphics.Clip = initialClip;
-
-            graphics.GetContextInfo(out PointF offset);
-            Assert.Equal(new PointF(1, 2), offset);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.NotNull(clip);
-            Assert.Equal(new RectangleF(1, 2, 9, 10), clip.GetBounds(graphics));
-            Assert.Equal(new PointF(1, 2), offset);
-            clip.Dispose();
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_ClipAndTransformSaveState()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-            graphics.TransformElements = Matrix3x2.CreateTranslation(1, 2);
-
-            GraphicsState state = graphics.Save();
-
-            graphics.GetContextInfo(out PointF offset);
-            Assert.Equal(new PointF(2, 4), offset);
-
-            graphics.GetContextInfo(out offset, out Region? clip);
-            Assert.NotNull(clip);
-            Assert.Equal(new RectangleF(0, 0, 8, 8), clip.GetBounds(graphics));
-            Assert.Equal(new PointF(2, 4), offset);
-            clip.Dispose();
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_New_ClipAndTransformSaveAndRestoreState()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            graphics.SetClip(new Rectangle(1, 2, 9, 10));
-            graphics.TransformElements = Matrix3x2.CreateTranslation(1, 2);
-
-            GraphicsState state = graphics.Save();
-            graphics.GetContextInfo(out PointF offset, out Region? clip);
-            graphics.Restore(state);
-
-            Assert.NotNull(clip);
-            Assert.Equal(new RectangleF(0, 0, 8, 8), clip.GetBounds(graphics));
-            Assert.Equal(new PointF(2, 4), offset);
-            clip.Dispose();
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Graphics_GetContextTests.cs b/src/System.Drawing.Common/tests/Graphics_GetContextTests.cs
deleted file mode 100644
index efb949be4db..00000000000
--- a/src/System.Drawing.Common/tests/Graphics_GetContextTests.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-
-namespace System.Drawing.Tests;
-
-#pragma warning disable SYSLIB0016 // Type or member is obsolete
-public partial class Graphics_GetContextTests : DrawingTest
-{
-    [Fact]
-    public void GetContextInfo_DefaultGraphics()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            object info = graphics.GetContextInfo();
-            Assert.IsType<object[]>(info);
-            object[] infoArray = (object[])info;
-            Assert.Equal(2, infoArray.Length);
-            Assert.IsType<Region>(infoArray[0]);
-            Assert.IsType<Matrix>(infoArray[1]);
-            using (Region region = (Region)infoArray[0])
-            using (Matrix matrix = (Matrix)infoArray[1])
-            {
-                Assert.True(region.IsInfinite(graphics));
-                Assert.True(matrix.IsIdentity);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_Clipping()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-
-            object[] info = (object[])graphics.GetContextInfo();
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                Assert.Equal(initialClip.GetBounds(graphics), region.GetBounds(graphics));
-                Assert.True(matrix.IsIdentity);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_Transform()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Matrix initialTransform = new Matrix())
-        {
-            initialTransform.Translate(1, 2);
-            graphics.Transform = initialTransform;
-
-            object[] info = (object[])graphics.GetContextInfo();
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                Assert.True(region.IsInfinite(graphics));
-                Assert.Equal(initialTransform, matrix);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_ClipAndTransform()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Matrix initialTransform = new Matrix())
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-            initialTransform.Translate(1, 2);
-            graphics.Transform = initialTransform;
-
-            object[] info = (object[])graphics.GetContextInfo();
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                Assert.Equal(new RectangleF(0, 0, 9, 10), region.GetBounds(graphics));
-                Assert.Equal(initialTransform, matrix);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_TransformAndClip()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Matrix initialTransform = new Matrix())
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            initialTransform.Translate(1, 2);
-            graphics.Transform = initialTransform;
-            graphics.Clip = initialClip;
-
-            object[] info = (object[])graphics.GetContextInfo();
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                Assert.Equal(new RectangleF(1, 2, 9, 10), region.GetBounds(graphics));
-                Assert.Equal(initialTransform, matrix);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_ClipAndTransformSaveState()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Matrix initialTransform = new Matrix())
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-            initialTransform.Translate(1, 2);
-            graphics.Transform = initialTransform;
-
-            GraphicsState state = graphics.Save();
-            object[] info = (object[])graphics.GetContextInfo();
-
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                initialTransform.Translate(1, 2);
-                Assert.Equal(new RectangleF(0, 0, 8, 8), region.GetBounds(graphics));
-                Assert.Equal(initialTransform, matrix);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetContextInfo_ClipAndTransformSaveAndRestoreState()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        using (Matrix initialTransform = new Matrix())
-        using (Region initialClip = new Region(new Rectangle(1, 2, 9, 10)))
-        {
-            graphics.Clip = initialClip;
-            initialTransform.Translate(1, 2);
-            graphics.Transform = initialTransform;
-
-            GraphicsState state = graphics.Save();
-            object[] info = (object[])graphics.GetContextInfo();
-            graphics.Restore(state);
-
-            using (Region region = (Region)info[0])
-            using (Matrix matrix = (Matrix)info[1])
-            {
-                initialTransform.Translate(1, 2);
-                Assert.Equal(new RectangleF(0, 0, 8, 8), region.GetBounds(graphics));
-                Assert.Equal(initialTransform, matrix);
-            }
-        }
-    }
-}
-#pragma warning restore SYSLIB0016 // Type or member is obsolete
-
diff --git a/src/System.Drawing.Common/tests/Helpers.cs b/src/System.Drawing.Common/tests/Helpers.cs
deleted file mode 100644
index 4326249f10a..00000000000
--- a/src/System.Drawing.Common/tests/Helpers.cs
+++ /dev/null
@@ -1,179 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Printing;
-using System.Runtime.InteropServices;
-using System.Text;
-using Xunit.Sdk;
-
-namespace System.Drawing;
-
-public static class Helpers
-{
-    public const string AnyInstalledPrinters = $"{nameof(Helpers)}.{nameof(IsAnyInstalledPrinters)}";
-    public const string WindowsRS3OrEarlier = $"{nameof(Helpers)}.{nameof(IsWindowsRS3OrEarlier)}";
-
-    public static bool IsWindowsRS3OrEarlier => !PlatformDetection.IsWindows10Version1803OrGreater;
-
-    public static bool IsAnyInstalledPrinters()
-    {
-        return PrinterSettings.InstalledPrinters.Count > 0;
-    }
-
-    public static string GetTestBitmapPath(string fileName) => GetTestPath("bitmaps", fileName);
-    public static string GetTestFontPath(string fileName) => GetTestPath("fonts", fileName);
-    public static string GetTestColorProfilePath(string fileName) => GetTestPath("colorProfiles", fileName);
-
-    private static string GetTestPath(string directoryName, string fileName) => Path.Combine(AppContext.BaseDirectory, directoryName, fileName);
-
-    public static void VerifyBitmap(Bitmap bitmap, Color[][] colors)
-    {
-        for (int y = 0; y < colors.Length; y++)
-        {
-            for (int x = 0; x < colors[y].Length; x++)
-            {
-                Color expectedColor = Color.FromArgb(colors[y][x].ToArgb());
-                Color actualColor = bitmap.GetPixel(x, y);
-
-                if (expectedColor != actualColor)
-                {
-                    throw GetBitmapEqualFailureException(bitmap, colors, x, y);
-                }
-            }
-        }
-    }
-
-    private static Exception GetBitmapEqualFailureException(Bitmap bitmap, Color[][] colors, int firstFailureX, int firstFailureY)
-    {
-        // Print out the whole bitmap to provide a view of the whole image, rather than just the difference between
-        // a single pixel.
-        var actualStringBuilder = new StringBuilder();
-        var expectedStringBuilder = new StringBuilder();
-
-        actualStringBuilder.AppendLine();
-        expectedStringBuilder.AppendLine();
-
-        for (int y = 0; y < bitmap.Height; y++)
-        {
-            for (int x = 0; x < bitmap.Width; x++)
-            {
-                PrintColor(actualStringBuilder, bitmap.GetPixel(x, y));
-                PrintColor(expectedStringBuilder, colors[y][x]);
-                if (x != bitmap.Width - 1)
-                {
-                    actualStringBuilder.Append(", ");
-                    expectedStringBuilder.Append(", ");
-                }
-            }
-            actualStringBuilder.AppendLine();
-            expectedStringBuilder.AppendLine();
-        }
-
-        return new AssertActualExpectedException(expectedStringBuilder.ToString(), actualStringBuilder.ToString(), $"Bitmaps were different at {firstFailureX}, {firstFailureY}.");
-    }
-
-    private static void PrintColor(StringBuilder stringBuilder, Color color)
-    {
-        stringBuilder.Append($"Color.FromArgb({color.A}, {color.R}, {color.G}, {color.B})");
-    }
-
-    public static Color EmptyColor => Color.FromArgb(0, 0, 0, 0);
-
-    private static Rectangle GetRectangle(RECT rect)
-    {
-        return new Rectangle(rect.Left, rect.Top, rect.Right - rect.Left, rect.Bottom - rect.Top);
-    }
-
-    private const int MONITOR_DEFAULTTOPRIMARY = 1;
-
-    [DllImport("libgdiplus", ExactSpelling = true)]
-    internal static extern string GetLibgdiplusVersion();
-
-    [DllImport("user32.dll", SetLastError = true)]
-    private static extern IntPtr MonitorFromWindow(IntPtr hWnd, int dwFlags);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    private static extern int GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO monitorInfo);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    internal static extern IntPtr GetForegroundWindow();
-
-    [DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
-    internal static extern int GetGuiResources(IntPtr hProcess, uint flags);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    internal static extern IntPtr GetDC(IntPtr hWnd);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    internal static extern IntPtr GetWindowDC(IntPtr hWnd);
-
-    public static Rectangle GetWindowDCRect(IntPtr hdc) => GetHWndRect(WindowFromDC(hdc));
-
-    public static Rectangle GetHWndRect(IntPtr hWnd)
-    {
-        if (hWnd == IntPtr.Zero)
-        {
-            return GetMonitorRectForWindow(hWnd);
-        }
-
-        var rect = new RECT();
-        GetClientRect(hWnd, ref rect);
-
-        return GetRectangle(rect);
-    }
-
-    private static Rectangle GetMonitorRectForWindow(IntPtr hWnd)
-    {
-        IntPtr hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTOPRIMARY);
-        Assert.NotEqual(IntPtr.Zero, hMonitor);
-
-        var info = new MONITORINFO();
-        info.cbSize = Marshal.SizeOf(info);
-        int result = GetMonitorInfo(hMonitor, ref info);
-        Assert.NotEqual(0, result);
-
-        return GetRectangle(info.rcMonitor);
-    }
-
-    [DllImport("user32.dll", SetLastError = true)]
-    private static extern int GetClientRect(IntPtr hWnd, ref RECT lpRect);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    private static extern IntPtr WindowFromDC(IntPtr hdc);
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct MONITORINFO
-    {
-        public int cbSize;
-        public RECT rcMonitor;
-        public RECT rcWork;
-        public int dwFlags;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct RECT
-    {
-        public int Left;
-        public int Top;
-        public int Right;
-        public int Bottom;
-    }
-
-    public static void VerifyBitmapNotBlank(Bitmap bmp)
-    {
-        Color emptyColor = Color.FromArgb(0);
-        for (int y = 0; y < bmp.Height; y++)
-        {
-            for (int x = 0; x < bmp.Width; x++)
-            {
-                Color pixel = bmp.GetPixel(x, y);
-                if (!pixel.Equals(emptyColor))
-                {
-                    return;
-                }
-            }
-        }
-
-        throw new XunitException("The entire image was blank.");
-    }
-}
diff --git a/src/System.Drawing.Common/tests/IconTests.cs b/src/System.Drawing.Common/tests/IconTests.cs
deleted file mode 100644
index f326f980d13..00000000000
--- a/src/System.Drawing.Common/tests/IconTests.cs
+++ /dev/null
@@ -1,927 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2004,2006-2008 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-using System.ComponentModel;
-using System.Drawing.Imaging;
-using System.Reflection;
-using Microsoft.DotNet.RemoteExecutor;
-
-namespace System.Drawing.Tests;
-
-public class IconTests
-{
-    [Theory]
-    [InlineData("48x48_multiple_entries_4bit.ico")]
-    [InlineData("256x256_seven_entries_multiple_bits.ico")]
-    [InlineData("pngwithheight_icon.ico")]
-    public void Ctor_FilePath(string name)
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath(name)))
-        {
-            Assert.Equal(32, icon.Width);
-            Assert.Equal(32, icon.Height);
-            Assert.Equal(new Size(32, 32), icon.Size);
-        }
-    }
-
-    public static IEnumerable<object[]> Size_TestData()
-    {
-        // Normal size
-        yield return new object[] { "48x48_multiple_entries_4bit.ico", new Size(16, 16), new Size(16, 16) };
-        yield return new object[] { "48x48_multiple_entries_4bit.ico", new Size(-32, -32), new Size(16, 16) };
-        yield return new object[] { "48x48_multiple_entries_4bit.ico", new Size(32, 16), new Size(32, 32) };
-        yield return new object[] { "256x256_seven_entries_multiple_bits.ico", new Size(48, 48), new Size(48, 48) };
-        yield return new object[] { "256x256_seven_entries_multiple_bits.ico", new Size(0, 0), new Size(32, 32) };
-        yield return new object[] { "256x256_seven_entries_multiple_bits.ico", new Size(1, 1), new Size(256, 256) };
-
-        // Unusual size
-        yield return new object[] { "10x16_one_entry_32bit.ico", new Size(16, 16), new Size(10, 16) };
-        yield return new object[] { "10x16_one_entry_32bit.ico", new Size(32, 32), new Size(11, 22) };
-
-        // Only 256
-        yield return new object[] { "256x256_one_entry_32bit.ico", new Size(0, 0), new Size(256, 256) };
-
-        yield return new object[] { "256x256_one_entry_32bit.ico", new Size(int.MaxValue, int.MaxValue), new Size(256, 256) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_FilePath_Width_Height(string fileName, Size size, Size expectedSize)
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath(fileName), size.Width, size.Height))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_FilePath_Size(string fileName, Size size, Size expectedSize)
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath(fileName), size))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullFilePath_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Icon((string)null));
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Icon((string)null, new Size(32, 32)));
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Icon((string)null, 32, 32));
-    }
-
-    [Fact]
-    public void Ctor_Stream()
-    {
-        using (var stream = File.OpenRead(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        {
-            var icon = new Icon(stream);
-            Assert.Equal(32, icon.Width);
-            Assert.Equal(32, icon.Height);
-            Assert.Equal(new Size(32, 32), icon.Size);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Stream_Trickled()
-    {
-        var stream = new TrickleStream(File.ReadAllBytes(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")));
-        var icon = new Icon(stream);
-        Assert.Equal(32, icon.Width);
-        Assert.Equal(32, icon.Height);
-        Assert.Equal(new Size(32, 32), icon.Size);
-    }
-
-    private sealed class TrickleStream : MemoryStream
-    {
-        public TrickleStream(byte[] bytes) : base(bytes) { }
-        public override int Read(byte[] buffer, int offset, int count) => base.Read(buffer, offset, Math.Min(count, 1));
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_Stream_Width_Height(string fileName, Size size, Size expectedSize)
-    {
-        using (var stream = File.OpenRead(Helpers.GetTestBitmapPath(fileName)))
-        using (var icon = new Icon(stream, size.Width, size.Height))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_Stream_Size(string fileName, Size size, Size expectedSize)
-    {
-        using (var stream = File.OpenRead(Helpers.GetTestBitmapPath(fileName)))
-        using (var icon = new Icon(stream, size))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullStream_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null, 32, 32));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Icon((Stream)null, new Size(32, 32)));
-    }
-
-    public static IEnumerable<object[]> Ctor_InvalidBytesInStream_TestData()
-    {
-        // No start entry.
-        yield return new object[] { new byte[0], typeof(ArgumentException) };
-        yield return new object[] { new byte[6], typeof(ArgumentException) };
-        yield return new object[] { new byte[21], typeof(ArgumentException) };
-
-        // First two reserved bits are not zero.
-        yield return new object[] { new byte[] { 10, 0, 1, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-        yield return new object[] { new byte[] { 0, 10, 1, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-
-        // The type is not one.
-        yield return new object[] { new byte[] { 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-        yield return new object[] { new byte[] { 0, 0, 2, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-        yield return new object[] { new byte[] { 0, 0, 1, 2, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-
-        // The count is zero.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-
-        // No space for the number of entries specified.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(ArgumentException) };
-
-        // The number of entries specified is negative.
-        yield return new object[]
-        {
-            new byte[] { 0, 0, 1, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-
-            // There is no such thing as a negative number in the native struct, we're throwing ArgumentException
-            // here now as the data size doesn't match what is expected (as other inputs above).
-            PlatformDetection.IsNetFramework ? typeof(Win32Exception) : typeof(ArgumentException)
-        };
-
-        // The size of an entry is negative.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0 }, typeof(Win32Exception) };
-
-        // The offset of an entry is negative.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255 }, typeof(ArgumentException) };
-
-        // The size and offset of an entry refers to an invalid position in the list of entries.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 12, 0, 0, 0 }, typeof(ArgumentException) };
-
-        // The size and offset of an entry overflows.
-        yield return new object[]
-        {
-            new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127, 255, 255, 255, 127 },
-
-            // Another case where we weren't checking data integrity before invoking.
-            PlatformDetection.IsNetFramework ? typeof(Win32Exception) : typeof(ArgumentException)
-        };
-
-        // The offset and the size of the list of entries overflows.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 127 }, typeof(ArgumentException) };
-
-        // No handle can be created from this.
-        yield return new object[] { new byte[] { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, typeof(Win32Exception) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidBytesInStream_TestData))]
-    public void Ctor_InvalidBytesInStream_ThrowsException(byte[] bytes, Type exceptionType)
-    {
-        using (var stream = new MemoryStream())
-        {
-            stream.Write(bytes, 0, bytes.Length);
-
-            stream.Position = 0;
-            Assert.Throws(exceptionType, () => new Icon(stream));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_Icon_Width_Height(string fileName, Size size, Size expectedSize)
-    {
-        using (var sourceIcon = new Icon(Helpers.GetTestBitmapPath(fileName)))
-        using (var icon = new Icon(sourceIcon, size.Width, size.Height))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-            Assert.NotEqual(sourceIcon.Handle, icon.Handle);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Size_TestData))]
-    public void Ctor_Icon_Size(string fileName, Size size, Size expectedSize)
-    {
-        using (var sourceIcon = new Icon(Helpers.GetTestBitmapPath(fileName)))
-        using (var icon = new Icon(sourceIcon, size))
-        {
-            Assert.Equal(expectedSize.Width, icon.Width);
-            Assert.Equal(expectedSize.Height, icon.Height);
-            Assert.Equal(expectedSize, icon.Size);
-            Assert.NotEqual(sourceIcon.Handle, icon.Handle);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullIcon_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("original", null, () => new Icon((Icon)null, 32, 32));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("original", null, () => new Icon((Icon)null, new Size(32, 32)));
-    }
-
-    [Fact]
-    public void Ctor_Type_Resource()
-    {
-        using (var icon = new Icon(typeof(IconTests), "48x48_multiple_entries_4bit.ico"))
-        {
-            Assert.Equal(32, icon.Height);
-            Assert.Equal(32, icon.Width);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullType_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new Icon(null, "48x48_multiple_entries_4bit.ico"));
-    }
-
-    [Theory]
-    [InlineData(typeof(Icon), "")]
-    [InlineData(typeof(Icon), "48x48_multiple_entries_4bit.ico")]
-    [InlineData(typeof(IconTests), "48x48_MULTIPLE_entries_4bit.ico")]
-    public void Ctor_InvalidResource_ThrowsArgumentException(Type type, string resource)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Icon(type, resource));
-    }
-
-    [Fact]
-    public void Ctor_InvalidResource_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("resource", null, () => new Icon(typeof(Icon), null));
-    }
-
-    [Fact]
-    public void Clone_ConstructedIcon_Success()
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        using (Icon clone = Assert.IsType<Icon>(icon.Clone()))
-        {
-            Assert.NotSame(icon, clone);
-            Assert.NotEqual(icon.Handle, clone.Handle);
-            Assert.Equal(32, clone.Width);
-            Assert.Equal(32, clone.Height);
-            Assert.Equal(new Size(32, 32), clone.Size);
-        }
-    }
-
-    [Fact]
-    public void Clone_IconFromHandle_Success()
-    {
-        using (var icon = Icon.FromHandle(SystemIcons.Hand.Handle))
-        using (Icon clone = Assert.IsType<Icon>(icon.Clone()))
-        {
-            Assert.NotSame(icon, clone);
-            Assert.NotEqual(icon.Handle, clone.Handle);
-            Assert.Equal(SystemIcons.Hand.Width, clone.Width);
-            Assert.Equal(SystemIcons.Hand.Height, clone.Height);
-            Assert.Equal(SystemIcons.Hand.Size, clone.Size);
-        }
-    }
-
-    [Fact]
-    public void Dispose_IconData_DestroysHandle()
-    {
-        var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"));
-        icon.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => icon.Handle);
-    }
-
-    [Fact]
-    public void Dispose_OwnsHandle_DestroysHandle()
-    {
-        Icon icon = Icon.ExtractAssociatedIcon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"));
-        icon.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => icon.Handle);
-    }
-
-    [Fact]
-    public void Dispose_DoesNotOwnHandle_DoesNotDestroyHandle()
-    {
-        using (var source = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        using (var icon = Icon.FromHandle(source.Handle))
-        {
-            IntPtr handle = icon.Handle;
-            Assert.NotEqual(IntPtr.Zero, handle);
-
-            icon.Dispose();
-            Assert.Equal(handle, icon.Handle);
-        }
-    }
-
-    [Theory]
-    [InlineData(16)]
-    [InlineData(32)]
-    [InlineData(48)]
-    public void XpIcon_ToBitmap_Success(int size)
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_32bit.ico"), size, size))
-        {
-            Assert.Equal(size, icon.Width);
-            Assert.Equal(size, icon.Height);
-            Assert.Equal(new Size(size, size), icon.Size);
-
-            using (Bitmap bitmap = icon.ToBitmap())
-            {
-                Assert.Equal(size, bitmap.Width);
-                Assert.Equal(size, bitmap.Height);
-                Assert.Equal(new Size(size, size), bitmap.Size);
-            }
-        }
-    }
-
-    [Fact]
-    public void ExtractAssociatedIcon_FilePath_Success()
-    {
-        ExtractAssociatedIcon_FilePath_Success_Helper(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"));
-    }
-
-    [Fact]
-    public void ExtractAssociatedIcon_UNCFilePath_Success()
-    {
-        string bitmapPath = Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico");
-        string bitmapPathRoot = Path.GetPathRoot(bitmapPath);
-        string bitmapUncPath = $"\\\\{Environment.MachineName}\\{bitmapPath.Substring(0, bitmapPathRoot.IndexOf(":"))}$\\{bitmapPath.Replace(bitmapPathRoot, "")}";
-
-        // Some path could not be accessible
-        // if so we just pass the test
-        try
-        {
-            File.Open(bitmapUncPath, FileMode.Open, FileAccess.Read, FileShare.Read).Dispose();
-        }
-        catch (IOException)
-        {
-            return;
-        }
-
-        Assert.True(new Uri(bitmapUncPath).IsUnc);
-
-        ExtractAssociatedIcon_FilePath_Success_Helper(bitmapUncPath);
-    }
-
-    private void ExtractAssociatedIcon_FilePath_Success_Helper(string filePath)
-    {
-        using (Icon icon = Icon.ExtractAssociatedIcon(filePath))
-        {
-            Assert.Equal(32, icon.Width);
-            Assert.Equal(32, icon.Height);
-        }
-    }
-
-    [Fact]
-    public void ExtractAssociatedIcon_NonFilePath_ThrowsFileNotFound()
-    {
-        // Used to return null at the expense of creating a URI
-        if (PlatformDetection.IsNetFramework)
-        {
-            Assert.Null(Icon.ExtractAssociatedIcon("http://microsoft.com"));
-        }
-        else
-        {
-            Assert.Throws<FileNotFoundException>(() => Icon.ExtractAssociatedIcon("http://microsoft.com"));
-        }
-    }
-
-    [Fact]
-    public void ExtractAssociatedIcon_NullFilePath_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("filePath", null, () => Icon.ExtractAssociatedIcon(null));
-    }
-
-    [Fact]
-    public void ExtractAssociatedIcon_InvalidFilePath_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>("filePath", null, () => Icon.ExtractAssociatedIcon(""));
-    }
-
-
-    [Fact]
-    public void ExtractAssociatedIcon_NoSuchPath_ThrowsFileNotFoundException()
-    {
-        Assert.Throws<FileNotFoundException>(() => Icon.ExtractAssociatedIcon("no-such-file.png"));
-    }
-
-    [Theory]
-    [InlineData("16x16_one_entry_4bit.ico")]
-    [InlineData("32x32_one_entry_4bit.ico")]
-    [InlineData("48x48_one_entry_1bit.ico")]
-    [InlineData("64x64_one_entry_8bit.ico")]
-    [InlineData("96x96_one_entry_8bit.ico")]
-    [InlineData("256x256_seven_entries_multiple_bits.ico")]
-    public void Save_OutputStream_Success(string fileName)
-    {
-        SaveAndCompare(new Icon(Helpers.GetTestBitmapPath(fileName)), true);
-    }
-
-    [Fact]
-    public void Save_OutputStream_ProducesIdenticalBytes()
-    {
-        string filePath = Helpers.GetTestBitmapPath("256x256_seven_entries_multiple_bits.ico");
-        using (var icon = new Icon(filePath))
-        using (var outputStream = new MemoryStream())
-        {
-            icon.Save(outputStream);
-            Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray());
-        }
-    }
-
-    [Fact]
-    public void Save_HasIconDataAndDisposed_ProducesIdenticalBytes()
-    {
-        string filePath = Helpers.GetTestBitmapPath("256x256_seven_entries_multiple_bits.ico");
-        var icon = new Icon(filePath);
-        icon.Dispose();
-        using (var outputStream = new MemoryStream())
-        {
-            icon.Save(outputStream);
-            Assert.Equal(File.ReadAllBytes(filePath), outputStream.ToArray());
-        }
-    }
-
-    [Fact]
-    public void Save_NullOutputStreamIconData_ThrowsNullReferenceException()
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        {
-            Assert.Throws<NullReferenceException>(() => icon.Save(null));
-        }
-    }
-
-    [Fact]
-    public void Save_NullOutputStreamNoIconData_ThrowsArgumentNullException()
-    {
-        using (var source = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        {
-            var icon = Icon.FromHandle(source.Handle);
-            icon.Dispose();
-
-            AssertExtensions.Throws<ArgumentNullException>("outputStream", "dataStream", () => icon.Save(null));
-        }
-    }
-
-    [Fact]
-    public void Save_ClosedOutputStreamIconData_ThrowsException()
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        {
-            var stream = new MemoryStream();
-            stream.Close();
-
-            Assert.Throws<ObjectDisposedException>(() => icon.Save(stream));
-        }
-    }
-
-    [Fact]
-    public void Save_ClosedOutputStreamNoIconData()
-    {
-        using (var source = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico")))
-        using (var icon = Icon.FromHandle(source.Handle))
-        {
-            var stream = new MemoryStream();
-            stream.Close();
-
-            if (PlatformDetection.IsNetFramework)
-            {
-                // The ObjectDisposedException is ignored in previous .NET versions,
-                // so the following does nothing.
-                icon.Save(stream);
-            }
-            else
-            {
-                Assert.Throws<ObjectDisposedException>(() => icon.Save(stream));
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_NoIconDataOwnsHandleAndDisposed_ThrowsObjectDisposedException()
-    {
-        Icon icon = Icon.ExtractAssociatedIcon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"));
-        icon.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => icon.Save(new MemoryStream()));
-    }
-
-    public static IEnumerable<object[]> ToBitmap_TestData()
-    {
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("32x32_one_entry_4bit.ico")) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico")) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico")) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico")) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("256x256_two_entries_multiple_bits.ico"), 48, 48) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("256x256_two_entries_multiple_bits.ico"), 256, 256) };
-        yield return new object[] { new Icon(Helpers.GetTestBitmapPath("256x256_two_entries_multiple_bits.ico"), 0, 0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToBitmap_TestData))]
-    public void ToBitmap_BitmapIcon_ReturnsExpected(Icon icon)
-    {
-        try
-        {
-            using (Bitmap bitmap = icon.ToBitmap())
-            {
-                Assert.NotSame(icon.ToBitmap(), bitmap);
-                Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-                Assert.Empty(bitmap.Palette.Entries);
-                Assert.Equal(icon.Width, bitmap.Width);
-                Assert.Equal(icon.Height, bitmap.Height);
-
-                Assert.Equal(ImageFormat.MemoryBmp, bitmap.RawFormat);
-                Assert.Equal(2, bitmap.Flags);
-            }
-        }
-        finally
-        {
-            icon.Dispose();
-        }
-    }
-
-    [Fact]
-    public void ToBitmap_BitmapIconFromHandle_ReturnsExpected()
-    {
-        // Handle refers to an icon without any colour. This is not in ToBitmap_TestData as there is
-        // a chance that the original icon will be finalized as it is not kept alive in the iterator.
-        using (var originalIcon = new Icon(Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico")))
-        using (Icon icon = Icon.FromHandle(originalIcon.Handle))
-        {
-            ToBitmap_BitmapIcon_ReturnsExpected(icon);
-        }
-    }
-
-    private const string DontSupportPngFramesInIcons = "Switch.System.Drawing.DontSupportPngFramesInIcons";
-
-    [Fact]
-    public void ToBitmap_PngIconSupportedInSwitches_Success()
-    {
-        void VerifyPng()
-        {
-            using (Icon icon = GetPngIcon())
-            using (Bitmap bitmap = icon.ToBitmap())
-            {
-                using (Bitmap secondBitmap = icon.ToBitmap())
-                {
-                    Assert.NotSame(icon.ToBitmap(), bitmap);
-                }
-                Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-                Assert.Empty(bitmap.Palette.Entries);
-                Assert.Equal(icon.Width, bitmap.Width);
-                Assert.Equal(icon.Height, bitmap.Height);
-
-                Assert.Equal(ImageFormat.Png, bitmap.RawFormat);
-                Assert.Equal(77842, bitmap.Flags);
-            }
-        }
-
-        if (RemoteExecutor.IsSupported && (!AppContext.TryGetSwitch(DontSupportPngFramesInIcons, out bool isEnabled) || isEnabled))
-        {
-            RemoteExecutor.Invoke(() =>
-            {
-                AppContext.SetSwitch(DontSupportPngFramesInIcons, false);
-                VerifyPng();
-            }).Dispose();
-        }
-        else
-        {
-            VerifyPng();
-        }
-    }
-
-    [Fact]
-    public void ToBitmap_PngIconNotSupportedInSwitches_ThrowsArgumentOutOfRangeException()
-    {
-        void VerifyPngNotSupported()
-        {
-            using (Icon icon = GetPngIcon())
-            {
-                AssertExtensions.Throws<ArgumentOutOfRangeException>(null, () => icon.ToBitmap());
-            }
-        }
-
-        if (RemoteExecutor.IsSupported && (!AppContext.TryGetSwitch(DontSupportPngFramesInIcons, out bool isEnabled) || !isEnabled))
-        {
-            RemoteExecutor.Invoke(() =>
-            {
-                AppContext.SetSwitch(DontSupportPngFramesInIcons, true);
-                VerifyPngNotSupported();
-            }).Dispose();
-        }
-        else
-        {
-            if (AppContext.TryGetSwitch(DontSupportPngFramesInIcons, out bool enabled) && enabled)
-                VerifyPngNotSupported();
-        }
-    }
-
-    private static Icon GetPngIcon()
-    {
-        using (var stream = new MemoryStream())
-        {
-            // Create a PNG inside an ICO.
-            using (var bitmap = new Bitmap(10, 10))
-            {
-                stream.Write(new byte[] { 0, 0, 1, 0, 1, 0, (byte)bitmap.Width, (byte)bitmap.Height, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 22, 0, 0, 0 }, 0, 22);
-
-                // Writing actual data
-                bitmap.Save(stream, ImageFormat.Png);
-            }
-
-            // Getting data length (file length minus header)
-            long length = stream.Length - 22;
-            stream.Seek(14, SeekOrigin.Begin);
-            stream.WriteByte((byte)length);
-            stream.WriteByte((byte)(length >> 8));
-
-            // Read the PNG inside an ICO.
-            stream.Position = 0;
-            return new Icon(stream);
-        }
-    }
-
-    [Fact]
-    public void FromHandle_IconHandleOneTime_Success()
-    {
-        using (var icon1 = new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        using (Icon icon2 = Icon.FromHandle(icon1.Handle))
-        {
-            Assert.Equal(icon1.Handle, icon2.Handle);
-            Assert.Equal(icon1.Size, icon2.Size);
-            SaveAndCompare(icon2, false);
-        }
-    }
-
-    [Fact]
-    public void FromHandle_IconHandleMultipleTime_Success()
-    {
-        using (var icon1 = new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        {
-            using (Icon icon2 = Icon.FromHandle(icon1.Handle))
-            {
-                Assert.Equal(icon1.Handle, icon2.Handle);
-                Assert.Equal(icon1.Size, icon2.Size);
-                SaveAndCompare(icon2, false);
-            }
-            using (Icon icon3 = Icon.FromHandle(icon1.Handle))
-            {
-                Assert.Equal(icon1.Handle, icon3.Handle);
-                Assert.Equal(icon1.Size, icon3.Size);
-                SaveAndCompare(icon3, false);
-            }
-        }
-    }
-
-    [Fact]
-    public void FromHandle_BitmapHandleOneTime_Success()
-    {
-        IntPtr handle;
-        using (var icon1 = new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        {
-            handle = icon1.ToBitmap().GetHicon();
-        }
-        using (Icon icon2 = Icon.FromHandle(handle))
-        {
-            Assert.Equal(handle, icon2.Handle);
-            Assert.Equal(new Size(16, 16), icon2.Size);
-            SaveAndCompare(icon2, false);
-        }
-    }
-
-    [Fact]
-    public void FromHandle_BitmapHandleMultipleTime_Success()
-    {
-        IntPtr handle;
-        using (var icon1 = new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        {
-            handle = icon1.ToBitmap().GetHicon();
-        }
-        using (Icon icon2 = Icon.FromHandle(handle))
-        {
-            Assert.Equal(handle, icon2.Handle);
-            Assert.Equal(new Size(16, 16), icon2.Size);
-            SaveAndCompare(icon2, false);
-        }
-        using (Icon icon3 = Icon.FromHandle(handle))
-        {
-            Assert.Equal(handle, icon3.Handle);
-            Assert.Equal(new Size(16, 16), icon3.Size);
-            SaveAndCompare(icon3, false);
-        }
-    }
-
-    [Fact]
-    public void FromHandle_Zero_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>("handle", null, () => Icon.FromHandle(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void Size_GetWhenDisposed_ThrowsObjectDisposedException()
-    {
-        var icon = new Icon(Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"));
-        icon.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => icon.Width);
-        Assert.Throws<ObjectDisposedException>(() => icon.Height);
-        Assert.Throws<ObjectDisposedException>(() => icon.Size);
-    }
-
-    private static void SaveAndCompare(Icon icon, bool alpha)
-    {
-        using (MemoryStream outputStream = new MemoryStream())
-        {
-            icon.Save(outputStream);
-            outputStream.Position = 0;
-
-            using (Icon loaded = new Icon(outputStream))
-            {
-                Assert.Equal(icon.Height, loaded.Height);
-                Assert.Equal(icon.Width, loaded.Width);
-
-                using (Bitmap expected = icon.ToBitmap())
-                using (Bitmap actual = loaded.ToBitmap())
-                {
-                    Assert.Equal(expected.Height, actual.Height);
-                    Assert.Equal(expected.Width, actual.Width);
-
-                    for (int y = 0; y < expected.Height; y++)
-                    {
-                        for (int x = 0; x < expected.Width; x++)
-                        {
-                            Color e = expected.GetPixel(x, y);
-                            Color a = actual.GetPixel(x, y);
-                            if (alpha)
-                            {
-                                Assert.Equal(e.A, a.A);
-                            }
-                            Assert.Equal(e.R, a.R);
-                            Assert.Equal(e.G, a.G);
-                            Assert.Equal(e.B, a.B);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [Fact]
-    public void CorrectColorDepthExtracted()
-    {
-        using (var stream = File.OpenRead(Helpers.GetTestBitmapPath("pngwithheight_icon.ico")))
-        {
-            using (var icon = new Icon(stream, new Size(32, 32)))
-            {
-                // The first 32x32 icon isn't 32 bit. Checking a few pixels that are in the 32 bit entry.
-                using (Bitmap bitmap = icon.ToBitmap())
-                {
-                    Assert.Equal(new Size(32, 32), bitmap.Size);
-
-                    int expectedBitDepth;
-                    string fieldName = PlatformDetection.IsNetFramework ? "bitDepth" : "s_bitDepth";
-                    FieldInfo fi = typeof(Icon).GetField(fieldName, BindingFlags.Static | BindingFlags.NonPublic);
-                    expectedBitDepth = (int)fi.GetValue(null);
-
-                    // If the first icon entry was picked, the color would be black: 0xFF000000?
-
-                    switch (expectedBitDepth)
-                    {
-                        case 32:
-                            Assert.Equal(0x879EE532u, (uint)bitmap.GetPixel(0, 0).ToArgb());
-                            Assert.Equal(0x661CD8B7u, (uint)bitmap.GetPixel(0, 31).ToArgb());
-                            break;
-                        case 16:
-                        case 8:
-                            // There is no 16 bit 32x32 icon in this file, 8 will be picked
-                            // as the closest match.
-                            Assert.Equal(0x00000000u, (uint)bitmap.GetPixel(0, 0).ToArgb());
-                            Assert.Equal(0xFF000000u, (uint)bitmap.GetPixel(0, 31).ToArgb());
-                            break;
-                        default:
-                            Assert.False(true, $"Unexpected bitmap depth: {expectedBitDepth}");
-                            break;
-                    }
-                }
-            }
-        }
-    }
-
-#if NET8_0_OR_GREATER
-    [Fact]
-    public void ExtractIcon_NullPath_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => { Icon.ExtractIcon(null!, 0, 16); });
-        Assert.Throws<ArgumentNullException>(() => { Icon.ExtractIcon(null!, 0); });
-    }
-
-    [Fact]
-    public void ExtractIcon_EmptyPath_ThrowsIOException()
-    {
-        Assert.Throws<IOException>(() => { Icon.ExtractIcon(string.Empty, 0, 16); });
-        Assert.Throws<IOException>(() => { Icon.ExtractIcon(string.Empty, 0); });
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    [InlineData(ushort.MaxValue + 1)]
-    public void ExtractIcon_InvalidSize_ThrowsArgumentOutOfRange(int size)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>(() => { Icon.ExtractIcon("Foo", 0, size); });
-    }
-
-    [Fact]
-    public void ExtractIcon_FileDoesNotExist_ThrowsIOException()
-    {
-        Assert.Throws<IOException>(() =>
-        {
-            Icon.ExtractIcon(Path.GetRandomFileName() + ".ico", 0, 16);
-        });
-
-        Assert.Throws<IOException>(() =>
-        {
-            Icon.ExtractIcon(Path.GetRandomFileName() + ".ico", 0);
-        });
-    }
-
-    [Fact]
-    public void ExtractIcon_InvalidExistingFile_ReturnsNull()
-    {
-        using TempFile file = TempFile.Create("NotAnIcon");
-        Assert.Null(Icon.ExtractIcon(file.Path, 0, 16));
-        Assert.Null(Icon.ExtractIcon(file.Path, 0));
-    }
-
-    [Fact]
-    public void ExtractIcon_IterateRegeditByIndex()
-    {
-        Icon? icon;
-        int count = 0;
-        while ((icon = Icon.ExtractIcon("regedit.exe", count, 16)) is not null)
-        {
-            Assert.NotEqual(0, icon.Handle);
-            Assert.Equal(16, icon.Width);
-            Assert.Equal(16, icon.Height);
-            count++;
-            icon.Dispose();
-        }
-
-        // Recent builds of Windows have added a few more icons to regedit.
-        Assert.True(count == 7 || count == 5, $"count was {count}, expected 5 or 7");
-    }
-
-    [Fact]
-    public void ExtractIcon_RegeditByResourceId()
-    {
-        using Icon? icon = Icon.ExtractIcon("regedit.exe", -100, 256);
-        Assert.NotNull(icon);
-        Assert.Equal(256, icon.Width);
-        Assert.Equal(256, icon.Height);
-    }
-#endif
-}
diff --git a/src/System.Drawing.Common/tests/ImageTests.cs b/src/System.Drawing.Common/tests/ImageTests.cs
deleted file mode 100644
index 7b25bae6adc..00000000000
--- a/src/System.Drawing.Common/tests/ImageTests.cs
+++ /dev/null
@@ -1,674 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Imaging;
-using System.Runtime.InteropServices;
-using System.Text;
-using Microsoft.DotNet.XUnitExtensions;
-using Encoder = System.Drawing.Imaging.Encoder;
-
-namespace System.Drawing.Tests;
-
-public class ImageTests
-{
-    private const int PropertyTagLuminanceTable = 0x5090;
-    private const int PropertyTagChrominanceTable = 0x5091;
-    private const int PropertyTagExifUserComment = 0x9286;
-    private const int PropertyTagTypeASCII = 2;
-    private const int PropertyTagTypeShort = 3;
-
-    [Fact]
-    public void PropertyIdList_GetBitmapJpg_Success()
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        Assert.Equal(new int[] { PropertyTagExifUserComment, PropertyTagChrominanceTable, PropertyTagLuminanceTable }, bitmap.PropertyIdList);
-        Assert.NotSame(bitmap.PropertyIdList, bitmap.PropertyIdList);
-    }
-
-    [Fact]
-    public void PropertyIdList_GetEmptyMemoryBitmap_ReturnsExpected()
-    {
-        using var bitmap = new Bitmap(1, 1);
-        Assert.Empty(bitmap.PropertyIdList);
-        Assert.Same(bitmap.PropertyIdList, bitmap.PropertyIdList);
-    }
-
-    [Fact]
-    public void PropertyItems_GetBitmapJpg_Success()
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem[] items = bitmap.PropertyItems;
-        Assert.Equal(3, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(29, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("LEAD Technologies Inc. V1.01\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(PropertyTagChrominanceTable, items[1].Id);
-        Assert.Equal(128, items[1].Len);
-        Assert.Equal(PropertyTagTypeShort, items[1].Type);
-        Assert.Equal(new byte[]
-        {
-            0x16, 0x00, 0x17, 0x00, 0x1F, 0x00, 0x3E, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x17,
-            0x00, 0x1B, 0x00, 0x22, 0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x1F,
-            0x00, 0x22, 0x00, 0x49, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x3E,
-            0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00
-        }, items[1].Value);
-        Assert.Equal(PropertyTagLuminanceTable, items[2].Id);
-        Assert.Equal(128, items[2].Len);
-        Assert.Equal(PropertyTagTypeShort, items[2].Type);
-        Assert.Equal(new byte[]
-        {
-            0x15, 0x00, 0x0E, 0x00, 0x0D, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x43, 0x00, 0x50, 0x00, 0x0F,
-            0x00, 0x0F, 0x00, 0x12, 0x00, 0x19, 0x00, 0x22, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x48, 0x00, 0x12,
-            0x00, 0x11, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x4B, 0x00, 0x5B, 0x00, 0x49, 0x00, 0x12,
-            0x00, 0x16, 0x00, 0x1D, 0x00, 0x26, 0x00, 0x43, 0x00, 0x72, 0x00, 0x69, 0x00, 0x51, 0x00, 0x17,
-            0x00, 0x1D, 0x00, 0x30, 0x00, 0x49, 0x00, 0x59, 0x00, 0x8F, 0x00, 0x87, 0x00, 0x65, 0x00, 0x1F,
-            0x00, 0x2E, 0x00, 0x48, 0x00, 0x54, 0x00, 0x6A, 0x00, 0x89, 0x00, 0x95, 0x00, 0x79, 0x00, 0x40,
-            0x00, 0x54, 0x00, 0x66, 0x00, 0x72, 0x00, 0x87, 0x00, 0x9F, 0x00, 0x9E, 0x00, 0x85, 0x00, 0x5F,
-            0x00, 0x79, 0x00, 0x7D, 0x00, 0x81, 0x00, 0x93, 0x00, 0x84, 0x00, 0x87, 0x00, 0x82, 0x00,
-        }, items[2].Value);
-
-        Assert.NotSame(items, bitmap.PropertyItems);
-    }
-
-    [Fact]
-    public void PropertyItems_GetEmptyBitmapBmp_Success()
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("almogaver1bit.bmp"));
-        Assert.Empty(bitmap.PropertyItems);
-        Assert.Same(bitmap.PropertyItems, bitmap.PropertyItems);
-    }
-
-    [Fact]
-    public void PropertyItems_GetEmptyMemoryBitmap_ReturnsExpected()
-    {
-        using var bitmap = new Bitmap(1, 1);
-        Assert.Empty(bitmap.PropertyItems);
-        Assert.Same(bitmap.PropertyItems, bitmap.PropertyItems);
-    }
-
-    [Fact]
-    public void GetPropertyItem_InvokeExistsBitmapBmp_Success()
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagExifUserComment);
-        Assert.Equal(PropertyTagExifUserComment, item.Id);
-        Assert.Equal(29, item.Len);
-        Assert.Equal(PropertyTagTypeASCII, item.Type);
-        Assert.Equal("LEAD Technologies Inc. V1.01\0", Encoding.ASCII.GetString(item.Value));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void GetPropertyItem_NoSuchPropertyItemEmptyMemoryBitmap_ThrowsArgumentException(int propid)
-    {
-        using var bitmap = new Bitmap(1, 1);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(propid));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void GetPropertyItem_NoSuchPropertyItemEmptyImageBitmapBmp_ThrowsArgumentException(int propid)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("almogaver1bit.bmp"));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(propid));
-    }
-
-    [Fact]
-    public void RemovePropertyItem_InvokeMemoryBitmap_Success()
-    {
-        using var source = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item1 = source.GetPropertyItem(PropertyTagExifUserComment);
-        PropertyItem item2 = source.GetPropertyItem(PropertyTagChrominanceTable);
-        PropertyItem item3 = source.GetPropertyItem(PropertyTagLuminanceTable);
-        using var bitmap = new Bitmap(1, 1);
-        bitmap.SetPropertyItem(item1);
-        bitmap.SetPropertyItem(item2);
-        bitmap.SetPropertyItem(item3);
-
-        bitmap.RemovePropertyItem(PropertyTagExifUserComment);
-        Assert.Equal(new int[] { PropertyTagChrominanceTable, PropertyTagLuminanceTable }, bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagExifUserComment));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(PropertyTagExifUserComment));
-
-        bitmap.RemovePropertyItem(PropertyTagLuminanceTable);
-        Assert.Equal(new int[] { PropertyTagChrominanceTable }, bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagLuminanceTable));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(PropertyTagLuminanceTable));
-
-        bitmap.RemovePropertyItem(PropertyTagChrominanceTable);
-        Assert.Empty(bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagChrominanceTable));
-        Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(PropertyTagChrominanceTable));
-    }
-
-    [Fact]
-    public void RemovePropertyItem_InvokeBitmapJpg_Success()
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        bitmap.RemovePropertyItem(PropertyTagExifUserComment);
-        Assert.Equal(new int[] { PropertyTagChrominanceTable, PropertyTagLuminanceTable }, bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagExifUserComment));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(PropertyTagExifUserComment));
-
-        bitmap.RemovePropertyItem(PropertyTagLuminanceTable);
-        Assert.Equal(new int[] { PropertyTagChrominanceTable }, bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagLuminanceTable));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(PropertyTagLuminanceTable));
-
-        bitmap.RemovePropertyItem(PropertyTagChrominanceTable);
-        Assert.Empty(bitmap.PropertyIdList);
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.GetPropertyItem(PropertyTagChrominanceTable));
-        Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(PropertyTagChrominanceTable));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void RemovePropertyItem_NoSuchPropertyItemEmptyMemoryBitmap_ThrowsExternalException(int propid)
-    {
-        using var bitmap = new Bitmap(1, 1);
-        Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(propid));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void RemovePropertyItem_NoSuchPropertyItemEmptyImageBitmapBmp_ThrowsExternalException(int propid)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("almogaver1bit.bmp"));
-        Assert.Throws<ExternalException>(() => bitmap.RemovePropertyItem(propid));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void RemovePropertyItem_NoSuchPropertyNotEmptyMemoryBitmap_ThrowsArgumentException(int propid)
-    {
-        using var source = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item1 = source.GetPropertyItem(PropertyTagExifUserComment);
-        PropertyItem item2 = source.GetPropertyItem(PropertyTagChrominanceTable);
-        PropertyItem item3 = source.GetPropertyItem(PropertyTagLuminanceTable);
-        using var bitmap = new Bitmap(1, 1);
-        bitmap.SetPropertyItem(item1);
-        bitmap.SetPropertyItem(item2);
-        bitmap.SetPropertyItem(item3);
-
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(propid));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void RemovePropertyItem_NoSuchPropertyNotEmptyBitmapJpg_ThrowsArgumentException(int propid)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        AssertExtensions.Throws<ArgumentException>(null, () => bitmap.RemovePropertyItem(propid));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void SetPropertyItem_InvokeMemoryBitmap_Success(int propid)
-    {
-        using var source = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        using var bitmap = new Bitmap(1, 1);
-
-        // Change data.
-        PropertyItem item = source.GetPropertyItem(PropertyTagExifUserComment);
-        item.Value = "Hello World\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment }, bitmap.PropertyIdList);
-        PropertyItem[] items = bitmap.PropertyItems;
-        Assert.Single(items);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-
-        // New data.
-        item.Id = propid;
-        item.Value = "New Value\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(2, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(propid, items[1].Id);
-        Assert.Equal(10, items[1].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[1].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[1].Value));
-
-        // Set same.
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(2, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(propid, items[1].Id);
-        Assert.Equal(10, items[1].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[1].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[1].Value));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void SetPropertyItem_InvokeBitmapJpg_Success(int propid)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-
-        // Change data.
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagExifUserComment);
-        item.Value = "Hello World\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, PropertyTagChrominanceTable, PropertyTagLuminanceTable }, bitmap.PropertyIdList);
-        PropertyItem[] items = bitmap.PropertyItems;
-        Assert.Equal(3, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(PropertyTagChrominanceTable, items[1].Id);
-        Assert.Equal(128, items[1].Len);
-        Assert.Equal(PropertyTagTypeShort, items[1].Type);
-        Assert.Equal(new byte[]
-        {
-            0x16, 0x00, 0x17, 0x00, 0x1F, 0x00, 0x3E, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x17,
-            0x00, 0x1B, 0x00, 0x22, 0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x1F,
-            0x00, 0x22, 0x00, 0x49, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x3E,
-            0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00
-        }, items[1].Value);
-        Assert.Equal(PropertyTagLuminanceTable, items[2].Id);
-        Assert.Equal(128, items[2].Len);
-        Assert.Equal(PropertyTagTypeShort, items[2].Type);
-        Assert.Equal(new byte[]
-        {
-            0x15, 0x00, 0x0E, 0x00, 0x0D, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x43, 0x00, 0x50, 0x00, 0x0F,
-            0x00, 0x0F, 0x00, 0x12, 0x00, 0x19, 0x00, 0x22, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x48, 0x00, 0x12,
-            0x00, 0x11, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x4B, 0x00, 0x5B, 0x00, 0x49, 0x00, 0x12,
-            0x00, 0x16, 0x00, 0x1D, 0x00, 0x26, 0x00, 0x43, 0x00, 0x72, 0x00, 0x69, 0x00, 0x51, 0x00, 0x17,
-            0x00, 0x1D, 0x00, 0x30, 0x00, 0x49, 0x00, 0x59, 0x00, 0x8F, 0x00, 0x87, 0x00, 0x65, 0x00, 0x1F,
-            0x00, 0x2E, 0x00, 0x48, 0x00, 0x54, 0x00, 0x6A, 0x00, 0x89, 0x00, 0x95, 0x00, 0x79, 0x00, 0x40,
-            0x00, 0x54, 0x00, 0x66, 0x00, 0x72, 0x00, 0x87, 0x00, 0x9F, 0x00, 0x9E, 0x00, 0x85, 0x00, 0x5F,
-            0x00, 0x79, 0x00, 0x7D, 0x00, 0x81, 0x00, 0x93, 0x00, 0x84, 0x00, 0x87, 0x00, 0x82, 0x00,
-        }, items[2].Value);
-
-        // New data.
-        item.Id = propid;
-        item.Value = "New Value\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, PropertyTagChrominanceTable, PropertyTagLuminanceTable, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(4, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(PropertyTagChrominanceTable, items[1].Id);
-        Assert.Equal(128, items[1].Len);
-        Assert.Equal(PropertyTagTypeShort, items[1].Type);
-        Assert.Equal(new byte[]
-        {
-            0x16, 0x00, 0x17, 0x00, 0x1F, 0x00, 0x3E, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x17,
-            0x00, 0x1B, 0x00, 0x22, 0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x1F,
-            0x00, 0x22, 0x00, 0x49, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x3E,
-            0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00
-        }, items[1].Value);
-        Assert.Equal(PropertyTagLuminanceTable, items[2].Id);
-        Assert.Equal(128, items[2].Len);
-        Assert.Equal(PropertyTagTypeShort, items[2].Type);
-        Assert.Equal(new byte[]
-        {
-            0x15, 0x00, 0x0E, 0x00, 0x0D, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x43, 0x00, 0x50, 0x00, 0x0F,
-            0x00, 0x0F, 0x00, 0x12, 0x00, 0x19, 0x00, 0x22, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x48, 0x00, 0x12,
-            0x00, 0x11, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x4B, 0x00, 0x5B, 0x00, 0x49, 0x00, 0x12,
-            0x00, 0x16, 0x00, 0x1D, 0x00, 0x26, 0x00, 0x43, 0x00, 0x72, 0x00, 0x69, 0x00, 0x51, 0x00, 0x17,
-            0x00, 0x1D, 0x00, 0x30, 0x00, 0x49, 0x00, 0x59, 0x00, 0x8F, 0x00, 0x87, 0x00, 0x65, 0x00, 0x1F,
-            0x00, 0x2E, 0x00, 0x48, 0x00, 0x54, 0x00, 0x6A, 0x00, 0x89, 0x00, 0x95, 0x00, 0x79, 0x00, 0x40,
-            0x00, 0x54, 0x00, 0x66, 0x00, 0x72, 0x00, 0x87, 0x00, 0x9F, 0x00, 0x9E, 0x00, 0x85, 0x00, 0x5F,
-            0x00, 0x79, 0x00, 0x7D, 0x00, 0x81, 0x00, 0x93, 0x00, 0x84, 0x00, 0x87, 0x00, 0x82, 0x00,
-        }, items[2].Value);
-        Assert.Equal(propid, items[3].Id);
-        Assert.Equal(10, items[3].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[3].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[3].Value));
-
-        // Set same.
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, PropertyTagChrominanceTable, PropertyTagLuminanceTable, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(4, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(PropertyTagChrominanceTable, items[1].Id);
-        Assert.Equal(128, items[1].Len);
-        Assert.Equal(PropertyTagTypeShort, items[1].Type);
-        Assert.Equal(new byte[]
-        {
-            0x16, 0x00, 0x17, 0x00, 0x1F, 0x00, 0x3E, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x17,
-            0x00, 0x1B, 0x00, 0x22, 0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x1F,
-            0x00, 0x22, 0x00, 0x49, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x3E,
-            0x00, 0x57, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82,
-            0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00
-        }, items[1].Value);
-        Assert.Equal(PropertyTagLuminanceTable, items[2].Id);
-        Assert.Equal(128, items[2].Len);
-        Assert.Equal(PropertyTagTypeShort, items[2].Type);
-        Assert.Equal(new byte[]
-        {
-            0x15, 0x00, 0x0E, 0x00, 0x0D, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x43, 0x00, 0x50, 0x00, 0x0F,
-            0x00, 0x0F, 0x00, 0x12, 0x00, 0x19, 0x00, 0x22, 0x00, 0x4C, 0x00, 0x4F, 0x00, 0x48, 0x00, 0x12,
-            0x00, 0x11, 0x00, 0x15, 0x00, 0x1F, 0x00, 0x34, 0x00, 0x4B, 0x00, 0x5B, 0x00, 0x49, 0x00, 0x12,
-            0x00, 0x16, 0x00, 0x1D, 0x00, 0x26, 0x00, 0x43, 0x00, 0x72, 0x00, 0x69, 0x00, 0x51, 0x00, 0x17,
-            0x00, 0x1D, 0x00, 0x30, 0x00, 0x49, 0x00, 0x59, 0x00, 0x8F, 0x00, 0x87, 0x00, 0x65, 0x00, 0x1F,
-            0x00, 0x2E, 0x00, 0x48, 0x00, 0x54, 0x00, 0x6A, 0x00, 0x89, 0x00, 0x95, 0x00, 0x79, 0x00, 0x40,
-            0x00, 0x54, 0x00, 0x66, 0x00, 0x72, 0x00, 0x87, 0x00, 0x9F, 0x00, 0x9E, 0x00, 0x85, 0x00, 0x5F,
-            0x00, 0x79, 0x00, 0x7D, 0x00, 0x81, 0x00, 0x93, 0x00, 0x84, 0x00, 0x87, 0x00, 0x82, 0x00,
-        }, items[2].Value);
-        Assert.Equal(propid, items[3].Id);
-        Assert.Equal(10, items[3].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[3].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[3].Value));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(-1)]
-    public void SetPropertyItem_InvokeBitmapBmp_Success(int propid)
-    {
-        using var source = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("almogaver1bit.bmp"));
-
-        // Change data.
-        PropertyItem item = source.GetPropertyItem(PropertyTagExifUserComment);
-        item.Value = "Hello World\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment }, bitmap.PropertyIdList);
-        PropertyItem[] items = bitmap.PropertyItems;
-        Assert.Single(items);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-
-        // New data.
-        item.Id = propid;
-        item.Value = "New Value\0"u8.ToArray();
-        item.Len = item.Value.Length;
-
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(2, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(propid, items[1].Id);
-        Assert.Equal(10, items[1].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[1].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[1].Value));
-
-        // Set same.
-        bitmap.SetPropertyItem(item);
-
-        Assert.Equal(new int[] { PropertyTagExifUserComment, propid }, bitmap.PropertyIdList);
-        items = bitmap.PropertyItems;
-        Assert.Equal(2, items.Length);
-        Assert.Equal(PropertyTagExifUserComment, items[0].Id);
-        Assert.Equal(12, items[0].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[0].Type);
-        Assert.Equal("Hello World\0", Encoding.ASCII.GetString(items[0].Value));
-        Assert.Equal(propid, items[1].Id);
-        Assert.Equal(10, items[1].Len);
-        Assert.Equal(PropertyTagTypeASCII, items[1].Type);
-        Assert.Equal("New Value\0", Encoding.ASCII.GetString(items[1].Value));
-    }
-
-    public static IEnumerable<object[]> InvalidBytes_TestData()
-    {
-        // IconTests.Ctor_InvalidBytesInStream_TestData an array of 2 objects, but this test only uses the
-        // 1st object.
-        foreach (object[] data in IconTests.Ctor_InvalidBytesInStream_TestData())
-        {
-            yield return new object[] { data[0] };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidBytes_TestData))]
-    public void FromFile_InvalidBytes_ThrowsOutOfMemoryException(byte[] bytes)
-    {
-        using (var file = TempFile.Create(bytes))
-        {
-            Assert.Throws<OutOfMemoryException>(() => Image.FromFile(file.Path));
-            Assert.Throws<OutOfMemoryException>(() => Image.FromFile(file.Path, useEmbeddedColorManagement: true));
-        }
-    }
-
-    [Fact]
-    public void FromFile_NullFileName_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => Image.FromFile(null));
-        AssertExtensions.Throws<ArgumentNullException>("path", () => Image.FromFile(null, useEmbeddedColorManagement: true));
-    }
-
-    [Fact]
-    public void FromFile_EmptyFileName_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentException>("path", null, () => Image.FromFile(string.Empty));
-        AssertExtensions.Throws<ArgumentException>("path", null, () => Image.FromFile(string.Empty, useEmbeddedColorManagement: true));
-    }
-
-    [Fact]
-    public void FromFile_LongSegment_ThrowsException()
-    {
-        // Throws PathTooLongException on Desktop and FileNotFoundException elsewhere.
-        if (PlatformDetection.IsNetFramework)
-        {
-            string fileName = new('a', 261);
-
-            Assert.Throws<PathTooLongException>(() => Image.FromFile(fileName));
-            Assert.Throws<PathTooLongException>(() => Image.FromFile(fileName,
-                useEmbeddedColorManagement: true));
-        }
-        else
-        {
-            string fileName = new('a', 261);
-
-            Assert.Throws<FileNotFoundException>(() => Image.FromFile(fileName));
-            Assert.Throws<FileNotFoundException>(() => Image.FromFile(fileName,
-                useEmbeddedColorManagement: true));
-        }
-    }
-
-    [Fact]
-    public void FromFile_NoSuchFile_ThrowsFileNotFoundException()
-    {
-        Assert.Throws<FileNotFoundException>(() => Image.FromFile("NoSuchFile"));
-        Assert.Throws<FileNotFoundException>(() => Image.FromFile("NoSuchFile", useEmbeddedColorManagement: true));
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidBytes_TestData))]
-    public void FromStream_InvalidBytes_ThrowsArgumentException(byte[] bytes)
-    {
-        using (var stream = new MemoryStream())
-        {
-            stream.Write(bytes, 0, bytes.Length);
-            stream.Position = 0;
-
-            AssertExtensions.Throws<ArgumentException>(null, () => Image.FromStream(stream));
-            Assert.Equal(0, stream.Position);
-
-            AssertExtensions.Throws<ArgumentException>(null, () => Image.FromStream(stream, useEmbeddedColorManagement: true));
-            AssertExtensions.Throws<ArgumentException>(null, () => Image.FromStream(stream, useEmbeddedColorManagement: true, validateImageData: true));
-            Assert.Equal(0, stream.Position);
-        }
-    }
-
-    [Fact]
-    public void FromStream_NullStream_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => Image.FromStream(null));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => Image.FromStream(null, useEmbeddedColorManagement: true));
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => Image.FromStream(null, useEmbeddedColorManagement: true, validateImageData: true));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format1bppIndexed, 1)]
-    [InlineData(PixelFormat.Format4bppIndexed, 4)]
-    [InlineData(PixelFormat.Format8bppIndexed, 8)]
-    [InlineData(PixelFormat.Format16bppArgb1555, 16)]
-    [InlineData(PixelFormat.Format16bppGrayScale, 16)]
-    [InlineData(PixelFormat.Format16bppRgb555, 16)]
-    [InlineData(PixelFormat.Format16bppRgb565, 16)]
-    [InlineData(PixelFormat.Format24bppRgb, 24)]
-    [InlineData(PixelFormat.Format32bppArgb, 32)]
-    [InlineData(PixelFormat.Format32bppPArgb, 32)]
-    [InlineData(PixelFormat.Format32bppRgb, 32)]
-    [InlineData(PixelFormat.Format48bppRgb, 48)]
-    [InlineData(PixelFormat.Format64bppArgb, 64)]
-    [InlineData(PixelFormat.Format64bppPArgb, 64)]
-    public void GetPixelFormatSize_ReturnsExpected(PixelFormat format, int expectedSize)
-    {
-        Assert.Equal(expectedSize, Image.GetPixelFormatSize(format));
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.Format16bppArgb1555, true)]
-    [InlineData(PixelFormat.Format32bppArgb, true)]
-    [InlineData(PixelFormat.Format32bppPArgb, true)]
-    [InlineData(PixelFormat.Format64bppArgb, true)]
-    [InlineData(PixelFormat.Format64bppPArgb, true)]
-    [InlineData(PixelFormat.Format16bppGrayScale, false)]
-    [InlineData(PixelFormat.Format16bppRgb555, false)]
-    [InlineData(PixelFormat.Format16bppRgb565, false)]
-    [InlineData(PixelFormat.Format1bppIndexed, false)]
-    [InlineData(PixelFormat.Format24bppRgb, false)]
-    [InlineData(PixelFormat.Format32bppRgb, false)]
-    [InlineData(PixelFormat.Format48bppRgb, false)]
-    [InlineData(PixelFormat.Format4bppIndexed, false)]
-    [InlineData(PixelFormat.Format8bppIndexed, false)]
-    public void IsAlphaPixelFormat_ReturnsExpected(PixelFormat format, bool expected)
-    {
-        Assert.Equal(expected, Image.IsAlphaPixelFormat(format));
-    }
-
-    public static IEnumerable<object[]> GetEncoderParameterList_ReturnsExpected_TestData()
-    {
-        yield return new object[]
-        {
-            ImageFormat.Tiff,
-            new Guid[]
-            {
-                Encoder.Compression.Guid,
-                Encoder.ColorDepth.Guid,
-                Encoder.SaveFlag.Guid,
-                new Guid(unchecked((int)0xa219bbc9), unchecked((short)0x0a9d), unchecked((short)0x4005), new byte[] { 0xa3, 0xee, 0x3a, 0x42, 0x1b, 0x8b, 0xb0, 0x6c }) /* Encoder.SaveAsCmyk.Guid */
-            }
-        };
-
-#if !NETFRAMEWORK
-        // NetFX doesn't support pointer-type encoder parameters, and doesn't define Encoder.ImageItems. Skip this test
-        // on NetFX.
-        yield return new object[]
-        {
-            ImageFormat.Jpeg,
-            new Guid[]
-            {
-                Encoder.Transformation.Guid,
-                Encoder.Quality.Guid,
-                Encoder.LuminanceTable.Guid,
-                Encoder.ChrominanceTable.Guid,
-                Encoder.ImageItems.Guid
-            }
-        };
-#endif
-    }
-
-    [Theory]
-    [MemberData(nameof(GetEncoderParameterList_ReturnsExpected_TestData))]
-    public void GetEncoderParameterList_ReturnsExpected(ImageFormat format, Guid[] expectedParameters)
-    {
-        if (PlatformDetection.IsNetFramework)
-        {
-            throw new SkipTestException("This is a known bug for .NET Framework");
-        }
-
-        ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
-        ImageCodecInfo codec = codecs.Single(c => c.FormatID == format.Guid);
-
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            EncoderParameters paramList = bitmap.GetEncoderParameterList(codec.Clsid);
-
-            Assert.Equal(
-                expectedParameters,
-                paramList.Param.Select(p => p.Encoder.Guid));
-        }
-    }
-
-    [Fact]
-    public void Save_InvalidDirectory_ThrowsDirectoryNotFoundException()
-    {
-        using (var bitmap = new Bitmap(1, 1))
-        {
-            var badTarget = System.IO.Path.Combine("NoSuchDirectory", "NoSuchFile");
-            AssertExtensions.Throws<DirectoryNotFoundException>(() => bitmap.Save(badTarget), $"The directory NoSuchDirectory of the filename {badTarget} does not exist.");
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/BitmapDataTests.cs b/src/System.Drawing.Common/tests/Imaging/BitmapDataTests.cs
deleted file mode 100644
index 045cd4744ac..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/BitmapDataTests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class BitmapDataTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        BitmapData bd = new BitmapData();
-        Assert.Equal(0, bd.Height);
-        Assert.Equal(0, bd.Width);
-        Assert.Equal(0, bd.Reserved);
-        Assert.Equal(IntPtr.Zero, bd.Scan0);
-        Assert.Equal(0, bd.Stride);
-        Assert.Equal((PixelFormat)0, bd.PixelFormat);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void Height_SetValid_ReturnsExpected(int value)
-    {
-        BitmapData bd = new BitmapData();
-        bd.Height = value;
-        Assert.Equal(value, bd.Height);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void Width_SetValid_ReturnsExpected(int value)
-    {
-        BitmapData bd = new BitmapData();
-        bd.Width = value;
-        Assert.Equal(value, bd.Width);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void Reserved_SetValid_ReturnsExpected(int value)
-    {
-        BitmapData bd = new BitmapData();
-        bd.Reserved = value;
-        Assert.Equal(value, bd.Reserved);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void Scan0_SetValid_ReturnsExpected(int value)
-    {
-        BitmapData bd = new BitmapData();
-        bd.Scan0 = new IntPtr(value);
-        Assert.Equal(new IntPtr(value), bd.Scan0);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void Stride_SetValid_ReturnsExpected(int value)
-    {
-        BitmapData bd = new BitmapData();
-        bd.Stride = value;
-        Assert.Equal(value, bd.Stride);
-    }
-
-    [Theory]
-    [InlineData(PixelFormat.DontCare)]
-    [InlineData(PixelFormat.Max)]
-    [InlineData(PixelFormat.Indexed)]
-    [InlineData(PixelFormat.Gdi)]
-    [InlineData(PixelFormat.Format16bppRgb555)]
-    [InlineData(PixelFormat.Format16bppRgb565)]
-    [InlineData(PixelFormat.Format24bppRgb)]
-    [InlineData(PixelFormat.Format32bppRgb)]
-    [InlineData(PixelFormat.Format1bppIndexed)]
-    [InlineData(PixelFormat.Format4bppIndexed)]
-    [InlineData(PixelFormat.Format8bppIndexed)]
-    [InlineData(PixelFormat.Alpha)]
-    [InlineData(PixelFormat.Format16bppArgb1555)]
-    [InlineData(PixelFormat.PAlpha)]
-    [InlineData(PixelFormat.Format32bppPArgb)]
-    [InlineData(PixelFormat.Extended)]
-    [InlineData(PixelFormat.Format16bppGrayScale)]
-    [InlineData(PixelFormat.Format48bppRgb)]
-    [InlineData(PixelFormat.Format64bppPArgb)]
-    [InlineData(PixelFormat.Canonical)]
-    [InlineData(PixelFormat.Format32bppArgb)]
-    [InlineData(PixelFormat.Format64bppArgb)]
-    public void PixelFormat_SetValid_ReturnsExpected(PixelFormat pixelFormat)
-    {
-        BitmapData bd = new BitmapData();
-        bd.PixelFormat = pixelFormat;
-        Assert.Equal(pixelFormat, bd.PixelFormat);
-    }
-
-    [Fact]
-    public void PixelFormat_SetInvalid_ThrowsInvalidEnumException()
-    {
-        BitmapData bd = new BitmapData();
-        Assert.ThrowsAny<ArgumentException>(() => bd.PixelFormat = (PixelFormat)(-1));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/CachedBitmapTests.cs b/src/System.Drawing.Common/tests/Imaging/CachedBitmapTests.cs
deleted file mode 100644
index 3ad43b38e30..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/CachedBitmapTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-#if NET8_0_OR_GREATER
-public class CachedBitmapTests
-{
-    [Fact]
-    public void Ctor_Throws_ArgumentNullException()
-    {
-        using var bitmap = new Bitmap(10, 10);
-        using var graphics = Graphics.FromImage(bitmap);
-
-        Assert.Throws<ArgumentNullException>(() => new CachedBitmap(bitmap, null));
-        Assert.Throws<ArgumentNullException>(() => new CachedBitmap(null, graphics));
-    }
-}
-#endif
diff --git a/src/System.Drawing.Common/tests/Imaging/ColorMapTests.cs b/src/System.Drawing.Common/tests/Imaging/ColorMapTests.cs
deleted file mode 100644
index 2d29267b07f..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/ColorMapTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class ColorMapTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        ColorMap cm = new ColorMap();
-        Assert.Equal(new Color(), cm.OldColor);
-        Assert.Equal(new Color(), cm.NewColor);
-    }
-
-    [Fact]
-    public void NewColor_SetValid_ReturnsExpected()
-    {
-        ColorMap cm = new ColorMap();
-        cm.NewColor = Color.AliceBlue;
-        Assert.Equal(Color.AliceBlue, cm.NewColor);
-    }
-
-    [Fact]
-    public void OldColor_SetValid_ReturnsExpected()
-    {
-        ColorMap cm = new ColorMap();
-        cm.OldColor = Color.AliceBlue;
-        Assert.Equal(Color.AliceBlue, cm.OldColor);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/ColorMatrixTests.cs b/src/System.Drawing.Common/tests/Imaging/ColorMatrixTests.cs
deleted file mode 100644
index 5d6e006b82b..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/ColorMatrixTests.cs
+++ /dev/null
@@ -1,282 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-//
-// Authors:
-//   Jordi Mas i Hernandez (jordi@ximian.com)
-//   Sebastien Pouliot  <sebastien@ximian.com>
-//
-
-namespace System.Drawing.Imaging.Tests;
-
-public class ColorMatrixTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        ColorMatrix cm = new ColorMatrix();
-
-        Assert.Equal(1, cm.Matrix00);
-        Assert.Equal(1, cm.Matrix11);
-        Assert.Equal(1, cm.Matrix22);
-        Assert.Equal(1, cm.Matrix33);
-        Assert.Equal(1, cm.Matrix44);
-        Assert.Equal(0, cm.Matrix01);
-        Assert.Equal(0, cm.Matrix02);
-        Assert.Equal(0, cm.Matrix03);
-        Assert.Equal(0, cm.Matrix04);
-        Assert.Equal(0, cm.Matrix10);
-        Assert.Equal(0, cm.Matrix12);
-        Assert.Equal(0, cm.Matrix13);
-        Assert.Equal(0, cm.Matrix14);
-        Assert.Equal(0, cm.Matrix20);
-        Assert.Equal(0, cm.Matrix21);
-        Assert.Equal(0, cm.Matrix23);
-        Assert.Equal(0, cm.Matrix24);
-        Assert.Equal(0, cm.Matrix30);
-        Assert.Equal(0, cm.Matrix31);
-        Assert.Equal(0, cm.Matrix32);
-        Assert.Equal(0, cm.Matrix34);
-        Assert.Equal(0, cm.Matrix40);
-        Assert.Equal(0, cm.Matrix41);
-        Assert.Equal(0, cm.Matrix42);
-        Assert.Equal(0, cm.Matrix43);
-    }
-
-    public static IEnumerable<object[]> BadCtorParams
-    {
-        get
-        {
-            yield return new object[] { null, typeof(NullReferenceException) };
-            yield return new object[] { new float[][] { }, typeof(IndexOutOfRangeException) };
-            yield return new object[] { new float[][] { new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f } }, typeof(IndexOutOfRangeException) };
-            yield return new object[] { new float[][] {
-                new float[] { 0.0f },
-                new float[] { 1.0f },
-                new float[] { 2.0f },
-                new float[] { 3.0f },
-                new float[] { 4.0f },
-                new float[] { 5.0f } }
-            , typeof(IndexOutOfRangeException) };
-        }
-    }
-
-    public static float[][] IndexedColorMatrix
-    {
-        get
-        {
-            return new float[][] {
-            new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.4f},
-            new float[] { 1.0f, 1.1f, 1.2f, 1.3f, 1.4f},
-            new float[] { 2.0f, 2.1f, 2.2f, 2.3f, 2.4f},
-            new float[] { 3.0f, 3.1f, 3.2f, 3.3f, 3.4f},
-            new float[] { 4.0f, 4.1f, 4.2f, 4.3f, 4.4f},
-        };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(BadCtorParams))]
-    public void Ctor_BadValues_ThrowsExpectedException(float[][] newColorMatrix, Type expectedException)
-    {
-        Assert.Throws(expectedException, () => new ColorMatrix(newColorMatrix));
-    }
-
-    [Fact]
-    public void Ctor_TooBigArraySize_MapOnly4and4Elements()
-    {
-        ColorMatrix cm = new ColorMatrix(new float[][] {
-            new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f },
-            new float[] { 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f },
-            new float[] { 2.0f, 2.1f, 2.2f, 2.3f, 2.4f, 2.5f },
-            new float[] { 3.0f, 3.1f, 3.2f, 3.3f, 3.4f, 3.5f },
-            new float[] { 4.0f, 4.1f, 4.2f, 4.3f, 4.4f, 4.5f },
-            new float[] { 5.0f, 5.1f, 5.2f, 5.3f, 5.4f, 5.5f }
-        });
-
-        Assert.Equal(0.0f, cm.Matrix00);
-        Assert.Equal(0.1f, cm.Matrix01);
-        Assert.Equal(0.2f, cm.Matrix02);
-        Assert.Equal(0.3f, cm.Matrix03);
-        Assert.Equal(0.4f, cm.Matrix04);
-        Assert.Equal(1.0f, cm.Matrix10);
-        Assert.Equal(1.1f, cm.Matrix11);
-        Assert.Equal(1.2f, cm.Matrix12);
-        Assert.Equal(1.3f, cm.Matrix13);
-        Assert.Equal(1.4f, cm.Matrix14);
-        Assert.Equal(2.0f, cm.Matrix20);
-        Assert.Equal(2.1f, cm.Matrix21);
-        Assert.Equal(2.2f, cm.Matrix22);
-        Assert.Equal(2.3f, cm.Matrix23);
-        Assert.Equal(2.4f, cm.Matrix24);
-        Assert.Equal(3.0f, cm.Matrix30);
-        Assert.Equal(3.1f, cm.Matrix31);
-        Assert.Equal(3.2f, cm.Matrix32);
-        Assert.Equal(3.3f, cm.Matrix33);
-        Assert.Equal(3.4f, cm.Matrix34);
-        Assert.Equal(4.0f, cm.Matrix40);
-        Assert.Equal(4.1f, cm.Matrix41);
-        Assert.Equal(4.2f, cm.Matrix42);
-        Assert.Equal(4.3f, cm.Matrix43);
-        Assert.Equal(4.4f, cm.Matrix44);
-    }
-
-    [Fact]
-    public void AccessToNotExistingElement_ThrowsIndexOutOfRangeException()
-    {
-        ColorMatrix cm = new ColorMatrix(new float[][] {
-            new float[] { 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f },
-            new float[] { 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f },
-            new float[] { 2.0f, 2.1f, 2.2f, 2.3f, 2.4f, 2.5f },
-            new float[] { 3.0f, 3.1f, 3.2f, 3.3f, 3.4f, 3.5f },
-            new float[] { 4.0f, 4.1f, 4.2f, 4.3f, 4.4f, 4.5f },
-            new float[] { 5.0f, 5.1f, 5.2f, 5.3f, 5.4f, 5.5f }
-        });
-        Assert.Throws<IndexOutOfRangeException>(() => _ = cm[5, 5]);
-    }
-
-    [Fact]
-    public void Ctor_SetValue_ReturnsExpected()
-    {
-        ColorMatrix cm = new ColorMatrix(IndexedColorMatrix);
-
-        Assert.Equal(0.0f, cm.Matrix00);
-        Assert.Equal(1.0f, cm.Matrix10);
-        Assert.Equal(2.0f, cm.Matrix20);
-        Assert.Equal(3.0f, cm.Matrix30);
-        Assert.Equal(4.0f, cm.Matrix40);
-
-        Assert.Equal(0.1f, cm.Matrix01);
-        Assert.Equal(1.1f, cm.Matrix11);
-        Assert.Equal(2.1f, cm.Matrix21);
-        Assert.Equal(3.1f, cm.Matrix31);
-        Assert.Equal(4.1f, cm.Matrix41);
-
-        Assert.Equal(0.2f, cm.Matrix02);
-        Assert.Equal(1.2f, cm.Matrix12);
-        Assert.Equal(2.2f, cm.Matrix22);
-        Assert.Equal(3.2f, cm.Matrix32);
-        Assert.Equal(4.2f, cm.Matrix42);
-
-        Assert.Equal(0.3f, cm.Matrix03);
-        Assert.Equal(1.3f, cm.Matrix13);
-        Assert.Equal(2.3f, cm.Matrix23);
-        Assert.Equal(3.3f, cm.Matrix33);
-        Assert.Equal(4.3f, cm.Matrix43);
-
-        Assert.Equal(0.4f, cm.Matrix04);
-        Assert.Equal(1.4f, cm.Matrix14);
-        Assert.Equal(2.4f, cm.Matrix24);
-        Assert.Equal(3.4f, cm.Matrix34);
-        Assert.Equal(4.4f, cm.Matrix44);
-
-        for (int i = 0; i < 5; i++)
-        {
-            for (int j = 0; j < 5; j++)
-            {
-                Assert.Equal(IndexedColorMatrix[i][j], cm[i, j]);
-            }
-        }
-    }
-
-    [Fact]
-    public void MatrixElement_SetValues_ReturnsExpected()
-    {
-        ColorMatrix cm = new ColorMatrix();
-
-        cm.Matrix00 = 1;
-        cm.Matrix01 = 2;
-        cm.Matrix02 = 3;
-        cm.Matrix03 = 4;
-        cm.Matrix04 = 5;
-        cm.Matrix10 = 6;
-        cm.Matrix11 = 7;
-        cm.Matrix12 = 8;
-        cm.Matrix13 = 9;
-        cm.Matrix14 = 10;
-        cm.Matrix20 = 11;
-        cm.Matrix21 = 12;
-        cm.Matrix22 = 13;
-        cm.Matrix23 = 14;
-        cm.Matrix24 = 15;
-        cm.Matrix30 = 16;
-        cm.Matrix31 = 17;
-        cm.Matrix32 = 18;
-        cm.Matrix33 = 19;
-        cm.Matrix34 = 20;
-        cm.Matrix40 = 21;
-        cm.Matrix41 = 22;
-        cm.Matrix42 = 23;
-        cm.Matrix43 = 24;
-        cm.Matrix44 = 25;
-
-        Assert.Equal(1, cm.Matrix00);
-        Assert.Equal(2, cm.Matrix01);
-        Assert.Equal(3, cm.Matrix02);
-        Assert.Equal(4, cm.Matrix03);
-        Assert.Equal(5, cm.Matrix04);
-        Assert.Equal(6, cm.Matrix10);
-        Assert.Equal(7, cm.Matrix11);
-        Assert.Equal(8, cm.Matrix12);
-        Assert.Equal(9, cm.Matrix13);
-        Assert.Equal(10, cm.Matrix14);
-        Assert.Equal(11, cm.Matrix20);
-        Assert.Equal(12, cm.Matrix21);
-        Assert.Equal(13, cm.Matrix22);
-        Assert.Equal(14, cm.Matrix23);
-        Assert.Equal(15, cm.Matrix24);
-        Assert.Equal(16, cm.Matrix30);
-        Assert.Equal(17, cm.Matrix31);
-        Assert.Equal(18, cm.Matrix32);
-        Assert.Equal(19, cm.Matrix33);
-        Assert.Equal(20, cm.Matrix34);
-        Assert.Equal(21, cm.Matrix40);
-        Assert.Equal(22, cm.Matrix41);
-        Assert.Equal(23, cm.Matrix42);
-        Assert.Equal(24, cm.Matrix43);
-        Assert.Equal(25, cm.Matrix44);
-    }
-
-    [Fact]
-    public void MatrixElementByIndexer_SetValue_ReturnsExpetecd()
-    {
-        ColorMatrix cm = new ColorMatrix(IndexedColorMatrix);
-
-        for (int i = 0; i < 5; i++)
-        {
-            for (int j = 0; j < 5; j++)
-            {
-                cm[i, j] = IndexedColorMatrix[i][j];
-            }
-        }
-
-        for (int i = 0; i < 5; i++)
-        {
-            for (int j = 0; j < 5; j++)
-            {
-                Assert.Equal(IndexedColorMatrix[i][j], cm[i, j]);
-            }
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/EncoderParameterTests.cs b/src/System.Drawing.Common/tests/Imaging/EncoderParameterTests.cs
deleted file mode 100644
index dd0ebcf3bc3..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/EncoderParameterTests.cs
+++ /dev/null
@@ -1,358 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class EncoderParameterTests
-{
-    private static readonly Encoder s_anyEncoder = Encoder.ChrominanceTable;
-
-    private void CheckEncoderParameter(EncoderParameter encoderParameter, Encoder expectedEncoder, EncoderParameterValueType expectedType, int expectedNumberOfValues)
-    {
-        Assert.Equal(expectedEncoder.Guid, encoderParameter.Encoder.Guid);
-        Assert.Equal(expectedType, encoderParameter.ValueType);
-        Assert.Equal(expectedType, encoderParameter.Type);
-        Assert.Equal(expectedNumberOfValues, encoderParameter.NumberOfValues);
-    }
-
-    public static IEnumerable<object[]> Ctor_Encoder_Byte_TestData
-    {
-        get
-        {
-            yield return new object[] { Encoder.ChrominanceTable, byte.MinValue };
-            yield return new object[] { Encoder.ColorDepth, byte.MinValue };
-            yield return new object[] { Encoder.Compression, byte.MinValue };
-            yield return new object[] { Encoder.LuminanceTable, byte.MinValue };
-            yield return new object[] { Encoder.Quality, byte.MinValue };
-            yield return new object[] { Encoder.RenderMethod, byte.MinValue };
-            yield return new object[] { Encoder.SaveFlag, byte.MinValue };
-            yield return new object[] { Encoder.ScanMethod, byte.MinValue };
-            yield return new object[] { Encoder.Transformation, byte.MinValue };
-            yield return new object[] { Encoder.Version, byte.MinValue };
-            yield return new object[] { new Encoder(Guid.NewGuid()), byte.MinValue };
-            yield return new object[] { new Encoder(Guid.NewGuid()), 1 };
-            yield return new object[] { new Encoder(Guid.NewGuid()), byte.MaxValue };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Encoder_Byte_TestData))]
-    public void Ctor_Encoder_Byte(Encoder encoder, byte value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(encoder, value))
-        {
-            CheckEncoderParameter(ep, encoder, EncoderParameterValueType.ValueTypeByte, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(false, EncoderParameterValueType.ValueTypeByte)]
-    [InlineData(true, EncoderParameterValueType.ValueTypeUndefined)]
-    public void Ctor_Encoder_ByteValue_Bool(bool undefined, EncoderParameterValueType expected)
-    {
-        EncoderParameter ep = new EncoderParameter(s_anyEncoder, 0, undefined);
-        CheckEncoderParameter(ep, s_anyEncoder, expected, 1);
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(short.MinValue)]
-    [InlineData(short.MaxValue)]
-    public void Ctor_Encoder_Short(short value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeShort, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(long.MinValue)]
-    [InlineData(long.MaxValue)]
-    public void Ctor_Encoder_Long(long value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeLong, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue, int.MaxValue)]
-    [InlineData(10, 5)]
-    [InlineData(-10, -5)]
-    public void Ctor_Encoder_Numerator_Denominator(int numerator, int denominator)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, numerator, denominator))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeRational, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(1, 2, 3, 4)]
-    public void Ctor_Encoder_Numerator1_Denominator1_Numerator2_Denominator2(int numerator1, int denominator1, int numerator2, int denominator2)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, numerator1, denominator1, numerator2, denominator2))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeRationalRange, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Encoder_RangeBegin_RangeEnd(long rangeBegin, long rangeEnd)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, rangeBegin, rangeEnd))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeLongRange, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData("someStringValue")]
-    [InlineData("")]
-    public void Ctor_Encoder_String(string value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeAscii, value.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new byte[] { })]
-    [InlineData(new byte[] { 0, 1, 2, 3 })]
-    public void Ctor_Encoder_ByteArray(byte[] value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeByte, value.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new byte[] { 1, 2 }, false, EncoderParameterValueType.ValueTypeByte)]
-    [InlineData(new byte[] { 1, 2 }, true, EncoderParameterValueType.ValueTypeUndefined)]
-    public void Ctor_Encoder_ByteArray_Bool(byte[] value, bool undefined, EncoderParameterValueType expected)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value, undefined))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, expected, value.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new short[] { })]
-    [InlineData(new short[] { 0, 1, 2, 3 })]
-    public void Ctor_Encoder_ShortArray(short[] value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeShort, value.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new long[] { })]
-    [InlineData(new long[] { 0, 1, 2, 3 })]
-    public void Ctor_Encoder_LongArray(long[] value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeLong, value.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new int[] { 0, 1, 2, 3 }, new int[] { 5, 6, 7, 8 })]
-    public void Ctor_Encoder_NumeratorArray_DenominatorArray(int[] numerator, int[] denominator)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, numerator, denominator))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeRational, numerator.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new long[] { 0, 1, 2, 3 }, new long[] { 5, 6, 7, 8 })]
-    public void Ctor_Encoder_RangeBeginArray_RangeEndArray(long[] rangeBegin, long[] rangeEnd)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, rangeBegin, rangeEnd))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeLongRange, rangeBegin.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(new int[] { 0, 1, 2, 3 }, new int[] { 4, 5, 6, 7 }, new int[] { 8, 9, 10, 11 }, new int[] { 12, 13, 14, 15 })]
-    public void Ctor_Encoder_Numerator1Array_Denominator1Array_Numerator2Array_Denominator2Array(int[] numerator1, int[] denominator1, int[] numerator2, int[] denominator2)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, numerator1, denominator1, numerator2, denominator2))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, EncoderParameterValueType.ValueTypeRationalRange, numerator1.Length);
-        }
-    }
-
-    public static IEnumerable<object[]> Encoder_NumberOfValues_TestData
-    {
-        get
-        {
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeAscii, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeByte, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeLong, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeLongRange, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeRational, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeRationalRange, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeShort, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeUndefined, IntPtr.Zero };
-            yield return new object[] { 0, EncoderParameterValueType.ValueTypeUndefined, IntPtr.Zero };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Encoder_NumberOfValues_TestData))]
-    public void Ctor_Encoder_NumberOfValues_Type_Value(int numberOfValues, EncoderParameterValueType type, IntPtr value)
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, numberOfValues, type, value))
-        {
-            CheckEncoderParameter(ep, s_anyEncoder, type, numberOfValues);
-        }
-    }
-
-    [Fact]
-    public void Encoder_ReturnsExpecetd()
-    {
-        Encoder encoder = new Encoder(Guid.NewGuid());
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, 0)
-        {
-            Encoder = encoder
-        })
-        {
-            Assert.Equal(encoder.Guid, ep.Encoder.Guid);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Encoder_NumberOfValues_NotExistingType_ThrowsInvalidOperationException()
-    {
-        Assert.Throws<InvalidOperationException>(() => new EncoderParameter(s_anyEncoder, 1, (EncoderParameterValueType)999, IntPtr.Zero));
-    }
-
-    [Theory]
-    [InlineData(new int[] { 1, 2 }, new int[] { 1 }, new int[] { 1 }, new int[] { 1 }, typeof(ArgumentException))]
-    [InlineData(new int[] { 1 }, new int[] { 1, 2 }, new int[] { 1 }, new int[] { 1 }, typeof(ArgumentException))]
-    [InlineData(null, new int[] { 1 }, new int[] { 1 }, new int[] { 1 }, typeof(NullReferenceException))]
-    [InlineData(new int[] { 1 }, null, new int[] { 1 }, new int[] { 1 }, typeof(NullReferenceException))]
-    [InlineData(new int[] { 1 }, new int[] { 1 }, null, new int[] { 1 }, typeof(NullReferenceException))]
-    [InlineData(new int[] { 1 }, new int[] { 1 }, new int[] { 1 }, null, typeof(NullReferenceException))]
-    public void Ctor_Encoder_Numerator1Array_Denominator1Array_Numerator2Array_Denominator2Array_InvalidParameters_ThrowsExpected(int[] numerator1, int[] denominator1, int[] numerator2, int[] denominator2, Type expected)
-    {
-        Assert.Throws(expected, () => new EncoderParameter(s_anyEncoder, numerator1, denominator1, numerator2, denominator2));
-    }
-
-    [Fact]
-    public void Encoder_Null_ThrowsNullReferenceException()
-    {
-        using (EncoderParameter ep = new EncoderParameter(s_anyEncoder, 0))
-        {
-            Assert.Throws<NullReferenceException>(() => ep.Encoder = null);
-        }
-    }
-
-    [Theory]
-    [InlineData(new int[] { 0 }, new int[] { 0, 1 }, typeof(ArgumentException))]
-    [InlineData(new int[] { 0, 1 }, new int[] { 0 }, typeof(ArgumentException))]
-    [InlineData(new int[] { 0, 1 }, null, typeof(NullReferenceException))]
-    [InlineData(null, new int[] { 0, 1 }, typeof(NullReferenceException))]
-    public void Ctor_Numerator_Denominator_IvalidValues_ThrowsExpected(int[] numerator, int[] denominator, Type expected)
-    {
-        Assert.Throws(expected, () => new EncoderParameter(s_anyEncoder, numerator, denominator));
-    }
-
-    [Theory]
-    [InlineData(new long[] { 0 }, new long[] { 0, 1 }, typeof(ArgumentException))]
-    [InlineData(new long[] { 0, 1 }, new long[] { 0 }, typeof(ArgumentException))]
-    [InlineData(new long[] { 0, 1 }, null, typeof(NullReferenceException))]
-    [InlineData(null, new long[] { 0, 1 }, typeof(NullReferenceException))]
-    public void Ctor_RangeBegin_RangeEnd_InvalidValues_ThrowsExpected(long[] rangeBegin, long[] rangeEnd, Type expected)
-    {
-        Assert.Throws(expected, () => new EncoderParameter(s_anyEncoder, rangeBegin, rangeEnd));
-    }
-
-    [Fact]
-    public void Ctor_Encoder_NullString_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(s_anyEncoder, (string)null));
-    }
-
-    [Fact]
-    public void Ctor_Encoder_ByteArray_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(s_anyEncoder, (byte[])null));
-    }
-
-    public static IEnumerable<object[]> EncoderParameterCtor_NullEncoder_TestData
-    {
-        get
-        {
-            yield return new object[] { new Action(() => new EncoderParameter(null, (byte)0)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, (byte)0, false)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, (short)0)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, numerator: 0, denominator: 0)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, rangebegin: 0, rangeend: 0)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, 0, 0, 0, 0)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, "anyString")) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new byte[] { })) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new byte[] { }, false)) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new short[] { })) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new long[] { })) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new int[] { }, new int[] { })) };
-            yield return new object[] { new Action(() => new EncoderParameter(null, new long[] { }, new long[] { })) };
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullEncoder_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, (byte)0));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, (byte)0, false));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, (short)0));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, numerator: 0, denominator: 0));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, rangebegin: 0, rangeend: 0));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, 0, 0, 0, 0));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, "anyString"));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new byte[] { }));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new byte[] { }, false));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new short[] { }));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new long[] { }));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new int[] { }, new int[] { }));
-        Assert.Throws<NullReferenceException>(() => new EncoderParameter(null, new long[] { }, new long[] { }));
-    }
-
-    [Theory]
-    [InlineData(EncoderParameterValueType.ValueTypeShort, (int.MaxValue / 2) + 1, typeof(OverflowException))]
-    [InlineData(EncoderParameterValueType.ValueTypeLong, (int.MaxValue / 4) + 1, typeof(OverflowException))]
-    [InlineData(EncoderParameterValueType.ValueTypeRational, (int.MaxValue / 8) + 1, typeof(OverflowException))]
-    [InlineData(EncoderParameterValueType.ValueTypeLongRange, (int.MaxValue / 8) + 1, typeof(OverflowException))]
-    [InlineData(EncoderParameterValueType.ValueTypeRationalRange, (int.MaxValue / 16) + 1, typeof(OverflowException))]
-    public void Ctor_Encoder_TooBigNumberOfValues_Type_Value_AccessViolationException(EncoderParameterValueType type, int numberOfValues, Type expected)
-    {
-        Assert.Throws(expected, () => new EncoderParameter(s_anyEncoder, numberOfValues, type, IntPtr.Zero));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    [SkipOnArchitecture(TestArchitectures.X86, "backwards compatibility on 32 bit platforms may not throw")]
-    // This test may depend on amount of RAM and system configuration and load.
-    public void Ctor_Encoder_NegativeNumberOfValues_Type_Value_OutOfMemoryException(int numberOfValues)
-    {
-        IntPtr anyValue = IntPtr.Zero;
-        EncoderParameterValueType anyType = EncoderParameterValueType.ValueTypeAscii;
-        Assert.Throws<OutOfMemoryException>(() => new EncoderParameter(s_anyEncoder, numberOfValues, anyType, anyValue));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/EncoderParametersTests.cs b/src/System.Drawing.Common/tests/Imaging/EncoderParametersTests.cs
deleted file mode 100644
index b542737c707..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/EncoderParametersTests.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class EncoderParametersTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (EncoderParameters ep = new EncoderParameters())
-        {
-            Assert.NotNull(ep.Param);
-            Assert.Equal(new EncoderParameter[1], ep.Param);
-        }
-    }
-
-    [Theory]
-    [InlineData(1)]
-    public void Ctor_Count_Default(int count)
-    {
-        using (EncoderParameters ep = new EncoderParameters(count))
-        {
-            Assert.NotNull(ep.Param);
-            Assert.Equal(new EncoderParameter[count], ep.Param);
-        }
-    }
-
-    public static IEnumerable<object[]> Param_TestData
-    {
-        get
-        {
-            yield return new object[] { new EncoderParameter[1] };
-            yield return new object[] { new EncoderParameter[1] { new EncoderParameter(Encoder.ChrominanceTable, 0) } };
-            yield return new object[] { new EncoderParameter[1] { null } };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Param_TestData))]
-    public void Param_Success(EncoderParameter[] param)
-    {
-        using (EncoderParameters ep = new EncoderParameters())
-        {
-            ep.Param = param;
-            Assert.Equal(param, ep.Param);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Param_TestData))]
-    public void Dispose_Success(EncoderParameter[] param)
-    {
-        EncoderParameters ep = new EncoderParameters();
-        ep.Param = param;
-        ep.Dispose();
-        Assert.Null(ep.Param);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/EncoderTests.cs b/src/System.Drawing.Common/tests/Imaging/EncoderTests.cs
deleted file mode 100644
index 21335bde4fc..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/EncoderTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class EncoderTests
-{
-    [Fact]
-    public void Ctor_Guid()
-    {
-        Guid guid = Guid.NewGuid();
-        Encoder encoder = new Encoder(guid);
-        Assert.Equal(guid, encoder.Guid);
-    }
-
-    public static IEnumerable<object[]> EncoderTestData
-    {
-        get
-        {
-            yield return new object[] { Encoder.Compression.Guid, new Guid(unchecked((int)0xe09d739d), unchecked((short)0xccd4), unchecked((short)0x44ee), new byte[] { 0x8e, 0xba, 0x3f, 0xbf, 0x8b, 0xe4, 0xfc, 0x58 }) };
-            yield return new object[] { Encoder.ColorDepth.Guid, new Guid(0x66087055, unchecked((short)0xad66), unchecked((short)0x4c7c), new byte[] { 0x9a, 0x18, 0x38, 0xa2, 0x31, 0x0b, 0x83, 0x37 }) };
-            yield return new object[] { Encoder.ScanMethod.Guid, new Guid(0x3a4e2661, (short)0x3109, (short)0x4e56, new byte[] { 0x85, 0x36, 0x42, 0xc1, 0x56, 0xe7, 0xdc, 0xfa }) };
-            yield return new object[] { Encoder.Version.Guid, new Guid(0x24d18c76, unchecked((short)0x814a), unchecked((short)0x41a4), new byte[] { 0xbf, 0x53, 0x1c, 0x21, 0x9c, 0xcc, 0xf7, 0x97 }) };
-            yield return new object[] { Encoder.RenderMethod.Guid, new Guid(0x6d42c53a, (short)0x229a, (short)0x4825, new byte[] { 0x8b, 0xb7, 0x5c, 0x99, 0xe2, 0xb9, 0xa8, 0xb8 }) };
-            yield return new object[] { Encoder.Quality.Guid, new Guid(0x1d5be4b5, unchecked((short)0xfa4a), unchecked((short)0x452d), new byte[] { 0x9c, 0xdd, 0x5d, 0xb3, 0x51, 0x05, 0xe7, 0xeb }) };
-            yield return new object[] { Encoder.Transformation.Guid, new Guid(unchecked((int)0x8d0eb2d1), unchecked((short)0xa58e), unchecked((short)0x4ea8), new byte[] { 0xaa, 0x14, 0x10, 0x80, 0x74, 0xb7, 0xb6, 0xf9 }) };
-            yield return new object[] { Encoder.LuminanceTable.Guid, new Guid(unchecked((int)0xedb33bce), unchecked((short)0x0266), unchecked((short)0x4a77), new byte[] { 0xb9, 0x04, 0x27, 0x21, 0x60, 0x99, 0xe7, 0x17 }) };
-            yield return new object[] { Encoder.ChrominanceTable.Guid, new Guid(unchecked((int)0xf2e455dc), unchecked((short)0x09b3), unchecked((short)0x4316), new byte[] { 0x82, 0x60, 0x67, 0x6a, 0xda, 0x32, 0x48, 0x1c }) };
-            yield return new object[] { Encoder.SaveFlag.Guid, new Guid(unchecked((int)0x292266fc), unchecked((short)0xac40), unchecked((short)0x47bf), new byte[] { 0x8c, 0xfc, 0xa8, 0x5b, 0x89, 0xa6, 0x55, 0xde }) };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EncoderTestData))]
-    public void DefinedEncoders_ReturnsExpected(Guid defined, Guid expected)
-    {
-        Assert.Equal(expected, defined);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/FrameDimensionTests.cs b/src/System.Drawing.Common/tests/Imaging/FrameDimensionTests.cs
deleted file mode 100644
index 333da677dcc..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/FrameDimensionTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class FrameDimensionTests
-{
-    [Fact]
-    public void Ctor_Guid()
-    {
-        Guid guid = Guid.NewGuid();
-        FrameDimension fd = new FrameDimension(guid);
-        Assert.Equal(guid, fd.Guid);
-    }
-
-    public static IEnumerable<object[]> ImageFormatGuidTestData
-    {
-        get
-        {
-            yield return new object[] { new Guid("{6aedbd6d-3fb5-418a-83a6-7f45229dc872}"), FrameDimension.Time };
-            yield return new object[] { new Guid("{84236f7b-3bd3-428f-8dab-4ea1439ca315}"), FrameDimension.Resolution };
-            yield return new object[] { new Guid("{7462dc86-6180-4c7e-8e3f-ee7333a7a483}"), FrameDimension.Page };
-            yield return new object[] { new Guid("48749428-316f-496a-ab30-c819a92b3137"), new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")) };
-        }
-    }
-
-    public static IEnumerable<object[]> FrameDimensionEqualsTestData
-    {
-        get
-        {
-            yield return new object[] { new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")), true };
-            yield return new object[] { new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new FrameDimension(new Guid("b96b3cad-0728-11d3-9d7b-0000f81ef32e")), false };
-            yield return new object[] { new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")), null, false };
-            yield return new object[] { new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new object(), false };
-        }
-    }
-
-    public static IEnumerable<object[]> FrameDimensionToStringTestData
-    {
-        get
-        {
-            yield return new object[] { "Time", FrameDimension.Time };
-            yield return new object[] { "Resolution", FrameDimension.Resolution };
-            yield return new object[] { "Page", FrameDimension.Page };
-            yield return new object[] { "[FrameDimension: 48749428-316f-496a-ab30-c819a92b3137]", new FrameDimension(new Guid("48749428-316f-496a-ab30-c819a92b3137")) };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ImageFormatGuidTestData))]
-    public void Guid_ReturnsExpected(Guid expected, FrameDimension frameDimension)
-    {
-        Assert.Equal(expected, frameDimension.Guid);
-    }
-
-    [Theory]
-    [MemberData(nameof(FrameDimensionEqualsTestData))]
-    public void Equals_Object_ReturnsExpected(FrameDimension frameDimension, object obj, bool result)
-    {
-        Assert.Equal(result, frameDimension.Equals(obj));
-    }
-
-    [Fact]
-    public void GetHashCode_Success()
-    {
-        Guid guid = Guid.NewGuid();
-        Assert.Equal(guid.GetHashCode(), new FrameDimension(guid).GetHashCode());
-    }
-
-    [Theory]
-    [MemberData(nameof(FrameDimensionToStringTestData))]
-    public void ToString_ReturnsExpected(string expected, FrameDimension imageFormat)
-    {
-        Assert.Equal(expected, imageFormat.ToString());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/ImageAttributesTests.cs b/src/System.Drawing.Common/tests/Imaging/ImageAttributesTests.cs
deleted file mode 100644
index f87327c82b4..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/ImageAttributesTests.cs
+++ /dev/null
@@ -1,1475 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Drawing2D;
-
-namespace System.Drawing.Imaging.Tests;
-
-public class ImageAttributesTests
-{
-    private readonly Rectangle _rectangle = new(0, 0, 64, 64);
-    private readonly Color _actualYellow = Color.FromArgb(255, 255, 255, 0);
-    private readonly Color _actualGreen = Color.FromArgb(255, 0, 255, 0);
-    private readonly Color _expectedRed = Color.FromArgb(255, 255, 0, 0);
-    private readonly Color _expectedBlack = Color.FromArgb(255, 0, 0, 0);
-    private readonly ColorMatrix _greenComponentToZeroColorMatrix = new(new float[][]
-    {
-        new float[] {1, 0, 0, 0, 0},
-        new float[] {0, 0, 0, 0, 0},
-        new float[] {0, 0, 1, 0, 0},
-        new float[] {0, 0, 0, 1, 0},
-        new float[] {0, 0, 0, 0, 0},
-    });
-
-    private readonly ColorMatrix _grayMatrix = new(new float[][] {
-        new float[] {1, 0, 0, 0, 0},
-        new float[] {0, 2, 0, 0, 0},
-        new float[] {0, 0, 3, 0, 0},
-        new float[] {0, 0, 0, 1, 0},
-        new float[] {0, 0, 0, 0, 0},
-    });
-
-    private readonly ColorMap[] _yellowToRedColorMap = new ColorMap[]
-    {
-        new ColorMap() { OldColor = Color.FromArgb(255, 255, 255, 0), NewColor = Color.FromArgb(255, 255, 0, 0) }
-    };
-
-    [Fact]
-    public void Ctor_Default_Success()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-    }
-
-    [Fact]
-    public void Clone_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix);
-
-            using (ImageAttributes clone = Assert.IsAssignableFrom<ImageAttributes>(imageAttr.Clone()))
-            {
-                bitmap.SetPixel(0, 0, _actualYellow);
-                graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, clone);
-                Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-            }
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.Clone());
-    }
-
-    [Fact]
-    public void SetColorMatrix_ColorMatrix_Success()
-    {
-        using (var brush = new SolidBrush(_actualGreen))
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix);
-            bitmap.SetPixel(0, 0, _actualYellow);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-
-            graphics.FillRectangle(brush, _rectangle);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedBlack, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorMatrix_DropShadowRepaintWhenAreaIsSmallerThanTheFilteredElement_TestData()
-    {
-        yield return new object[] { Color.FromArgb(100, 255, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 155, 155) };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorMatrix_DropShadowRepaintWhenAreaIsSmallerThanTheFilteredElement_TestData))]
-    public void SetColorMatrix_ColorMatrixI_Success(Color color)
-    {
-        ColorMatrix colorMatrix = new ColorMatrix(new float[][]
-        {
-            new float[] {1, 0, 0, 0, 0},
-            new float[] {0, 1, 0, 0, 0},
-            new float[] {0, 0, 1, 0, 0},
-            new float[] {0, 0, 0, 0.5f, 0},
-            new float[] {0, 0, 0, 0, 1},
-        });
-
-        using (var brush = new SolidBrush(color))
-        using (var bitmapBig = new Bitmap(200, 100))
-        using (var bitmapSmall = new Bitmap(100, 100))
-        using (var graphicsSmallBitmap = Graphics.FromImage(bitmapSmall))
-        using (var graphicsBigBitmap = Graphics.FromImage(bitmapBig))
-        using (var imageAttr = new ImageAttributes())
-        {
-            graphicsSmallBitmap.FillRectangle(Brushes.White, 0, 0, 100, 100);
-            graphicsSmallBitmap.FillEllipse(brush, 0, 0, 100, 100);
-            graphicsBigBitmap.FillRectangle(Brushes.White, 0, 0, 200, 100);
-            imageAttr.SetColorMatrix(colorMatrix);
-            graphicsBigBitmap.DrawImage(bitmapSmall, new Rectangle(0, 0, 100, 100), 0, 0, 100, 100, GraphicsUnit.Pixel, null);
-            graphicsBigBitmap.DrawImage(bitmapSmall, new Rectangle(100, 0, 100, 100), 0, 0, 100, 100, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 255, 155, 155), bitmapBig.GetPixel(50, 50));
-            Assert.Equal(Color.FromArgb(255, 255, 205, 205), bitmapBig.GetPixel(150, 50));
-        }
-    }
-
-    [Fact]
-    public void SetColorMatrix_ColorMatrixFlags_Success()
-    {
-        var grayShade = Color.FromArgb(255, 100, 100, 100);
-
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            bitmap.SetPixel(0, 0, _actualYellow);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-
-            bitmap.SetPixel(0, 0, grayShade);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.SkipGrays);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(grayShade, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorAdjustType_TestData()
-    {
-        yield return new object[] { ColorAdjustType.Default };
-        yield return new object[] { ColorAdjustType.Bitmap };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void SetColorMatrix_ColorMatrixDefaultFlagType_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var brush = new SolidBrush(_actualYellow))
-        using (var pen = new Pen(brush))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedBlack, bitmap.GetPixel(0, 0));
-
-            graphics.FillRectangle(brush, _rectangle);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-
-            graphics.DrawRectangle(pen, _rectangle);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorAdjustTypeI_TestData()
-    {
-        yield return new object[] { ColorAdjustType.Brush };
-        yield return new object[] { ColorAdjustType.Pen };
-        yield return new object[] { ColorAdjustType.Text };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void SetColorMatrix_ColorMatrixDefaultFlagTypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var brush = new SolidBrush(_actualYellow))
-        using (var pen = new Pen(brush))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetColorMatrix_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Default));
-    }
-
-    [Fact]
-    public void SetColorMatrix_NullMatrix_ThrowsArgumentException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(null));
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(null, ColorMatrixFlag.Default));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorMatrix(null, ColorMatrixFlag.Default, ColorAdjustType.Default));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorAdjustType_InvalidTypes_TestData()
-    {
-        yield return new object[] { (ColorAdjustType.Default - 1) };
-        yield return new object[] { ColorAdjustType.Count };
-        yield return new object[] { ColorAdjustType.Any };
-        yield return new object[] { (ColorAdjustType.Any + 1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetColorMatrix_InvalidTypes_ThrowsInvalidEnumArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorMatrixFlag_InvalidFlags_TestData()
-    {
-        yield return new object[] { (ColorMatrixFlag.Default - 1) };
-        yield return new object[] { ColorMatrixFlag.AltGrays };
-        yield return new object[] { (ColorMatrixFlag.AltGrays + 1) };
-        yield return new object[] { (ColorMatrixFlag)int.MinValue };
-        yield return new object[] { (ColorMatrixFlag)int.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetColorMatrix_InvalidFlags_ThrowsArgumentException(ColorMatrixFlag flag)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, flag));
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, flag, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void ClearColorMatrix_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix);
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix);
-            imageAttr.ClearColorMatrix();
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> ColorAdjustType_AllTypesAllowed_TestData()
-    {
-        yield return new object[] { ColorAdjustType.Default };
-        yield return new object[] { ColorAdjustType.Bitmap };
-        yield return new object[] { ColorAdjustType.Brush };
-        yield return new object[] { ColorAdjustType.Pen };
-        yield return new object[] { ColorAdjustType.Text };
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearColorMatrix_DefaultFlagType_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var brush = new SolidBrush(_actualYellow))
-        using (var pen = new Pen(brush))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, ColorMatrixFlag.Default, type);
-            imageAttr.ClearColorMatrix(type);
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-
-            graphics.FillRectangle(brush, _rectangle);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualYellow, bitmap.GetPixel(0, 0));
-
-            graphics.DrawRectangle(pen, _rectangle);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualYellow, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearColorMatrix_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorMatrix());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorMatrix(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearColorMatrix_InvalidTypes_ThrowsInvalidEnumArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorMatrix(type));
-        }
-    }
-
-    [Fact]
-    public void SetColorMatrices_ColorMatrixGrayMatrix_Success()
-    {
-        using (var brush = new SolidBrush(_actualGreen))
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix);
-            bitmap.SetPixel(0, 0, _actualYellow);
-            bitmap.SetPixel(1, 1, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-            Assert.Equal(Color.FromArgb(255, 100, 0, 100), bitmap.GetPixel(1, 1));
-        }
-    }
-
-    public static IEnumerable<object[]> SetColorMatrices_Flags_TestData()
-    {
-        yield return new object[] { ColorMatrixFlag.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 0, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 200, 255) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetColorMatrices_Flags_TestData))]
-    public void SetColorMatrices_ColorMatrixGrayMatrixFlags_Success(ColorMatrixFlag flag, Color grayShade, Color expectedGrayShade)
-    {
-        using (var brush = new SolidBrush(_actualGreen))
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, flag);
-            bitmap.SetPixel(0, 0, _actualYellow);
-            bitmap.SetPixel(1, 1, grayShade);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-            Assert.Equal(expectedGrayShade, bitmap.GetPixel(1, 1));
-        }
-    }
-
-    public static IEnumerable<object[]> SetColorMatrices_FlagsTypes_TestData()
-    {
-        yield return new object[] { ColorMatrixFlag.Default, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 0, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 200, 255) };
-        yield return new object[] { ColorMatrixFlag.Default, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 0, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 100, 200, 255) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetColorMatrices_FlagsTypes_TestData))]
-    public void SetColorMatrices_ColorMatrixGrayMatrixFlagsTypes_Success
-        (ColorMatrixFlag flag, ColorAdjustType type, Color grayShade, Color expectedGrayShade)
-    {
-        using (var brush = new SolidBrush(_actualGreen))
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, flag, type);
-            bitmap.SetPixel(0, 0, _actualYellow);
-            bitmap.SetPixel(1, 1, grayShade);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedRed, bitmap.GetPixel(0, 0));
-            Assert.Equal(expectedGrayShade, bitmap.GetPixel(1, 1));
-        }
-    }
-
-    public static IEnumerable<object[]> SetColorMatrices_FlagsTypesI_TestData()
-    {
-        yield return new object[] { ColorMatrixFlag.Default, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.Default, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.Default, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.SkipGrays, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorMatrixFlag.AltGrays, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetColorMatrices_FlagsTypesI_TestData))]
-    public void SetColorMatrices_ColorMatrixGrayMatrixFlagsTypesI_Success(ColorMatrixFlag flag, ColorAdjustType type, Color grayShade)
-    {
-        using (var brush = new SolidBrush(_actualGreen))
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, flag, type);
-            bitmap.SetPixel(0, 0, _actualYellow);
-            bitmap.SetPixel(1, 1, grayShade);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualYellow, bitmap.GetPixel(0, 0));
-            Assert.Equal(grayShade, bitmap.GetPixel(1, 1));
-        }
-    }
-
-    [Fact]
-    public void SetColorMatrices_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, ColorMatrixFlag.Default));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, ColorMatrixFlag.Default, ColorAdjustType.Default));
-    }
-
-    [Fact]
-    public void SetColorMatrices_NullMatrices_ThrowsArgumentException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(null, _grayMatrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(null, _grayMatrix, ColorMatrixFlag.Default));
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, null, ColorMatrixFlag.AltGrays));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorMatrices(null, _grayMatrix, ColorMatrixFlag.Default, ColorAdjustType.Default));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, null, ColorMatrixFlag.AltGrays, ColorAdjustType.Default));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetColorMatrices_InvalidTypes_ThrowsInvalidEnumArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, ColorMatrixFlag.Default, type));
-        }
-    }
-
-    [Theory]
-    [InlineData(ColorMatrixFlag.Default - 1)]
-    [InlineData(ColorMatrixFlag.AltGrays + 1)]
-    [InlineData((ColorMatrixFlag)int.MinValue)]
-    [InlineData((ColorMatrixFlag)int.MaxValue)]
-    public void SetColorMatrices_InvalidFlags_ThrowsArgumentException(ColorMatrixFlag flag)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, flag));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorMatrices(_greenComponentToZeroColorMatrix, _grayMatrix, flag, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetThreshold_Threshold_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetThreshold(0.7f);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 230, 50, 220));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 255, 0, 255), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void SetThreshold_ThresholdType_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetThreshold(0.7f, type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 230, 50, 220));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 255, 0, 255), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void SetThreshold_ThresholdTypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetThreshold(0.7f, type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 230, 50, 220));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 230, 50, 220), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetThreshold_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetThreshold(0.5f));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetThreshold_InvalidType_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetThreshold(0.5f, type));
-        }
-    }
-
-    [Fact]
-    public void ClearThreshold_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetThreshold(0.7f);
-            imageAttr.ClearThreshold();
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 230, 50, 220));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 230, 50, 220), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearThreshold_ThresholdTypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetThreshold(0.7f, type);
-            imageAttr.ClearThreshold(type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 230, 50, 220));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 230, 50, 220), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearThreshold_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearThreshold(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearThreshold_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearThreshold(type));
-        }
-    }
-
-    [Fact]
-    public void SetGamma_Gamma_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 33, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void SetGamma_GammaType_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 33, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void SetGamma_GammaTypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetGamma_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetGamma(2.2f));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetGamma(2.2f, ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetGamma_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetGamma(2.2f, type));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearGamma_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            imageAttr.ClearGamma(type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearGamma_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearGamma(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearGamma_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearGamma(type));
-        }
-    }
-
-    [Fact]
-    public void SetNoOp_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix);
-            imageAttr.SetNoOp();
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void SetNoOp_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-            imageAttr.SetNoOp(type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetNoOp_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetNoOp());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetNoOp(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetNoOp_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetNoOp(type));
-        }
-    }
-
-    [Fact]
-    public void ClearNoOp_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix);
-            imageAttr.SetNoOp();
-            imageAttr.ClearNoOp();
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_expectedBlack, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void ClearNoOp_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-            imageAttr.SetNoOp(type);
-            imageAttr.ClearNoOp(type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 33, 0, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void ClearNoOp_TypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetGamma(2.2f, type);
-            imageAttr.SetColorMatrix(_greenComponentToZeroColorMatrix, ColorMatrixFlag.Default, type);
-            imageAttr.SetNoOp(type);
-            imageAttr.ClearNoOp(type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 255, 0));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 255, 0), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearNoOp_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearNoOp());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearNoOp(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearNoOp_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearNoOp(type));
-        }
-    }
-
-    [Fact]
-    public void SetColorKey_Success()
-    {
-        using var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height);
-        using var graphics = Graphics.FromImage(bitmap);
-        using var imageAttr = new ImageAttributes();
-
-        imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150));
-
-        bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-        graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-        Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void SetColorKey_Type_Success(ColorAdjustType type)
-    {
-        using var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height);
-        using var graphics = Graphics.FromImage(bitmap);
-        using var imageAttr = new ImageAttributes();
-
-        imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150), type);
-
-        bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-        graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-        Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void SetColorKey_TypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150), type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetColorKey_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150)));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150), ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetColorKey_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150), type));
-        }
-    }
-
-    [Fact]
-    public void ClearColorKey_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150));
-            imageAttr.ClearColorKey();
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearColorKey_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetColorKey(Color.FromArgb(50, 50, 50), Color.FromArgb(150, 150, 150), type);
-            imageAttr.ClearColorKey(type);
-
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearColorKey_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorKey());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorKey(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearColorKey_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearColorKey(type));
-        }
-    }
-
-    public static IEnumerable<object[]> SetOutputChannel_ColorChannelFlag_TestData()
-    {
-        yield return new object[] { ColorChannelFlag.ColorChannelC, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 198, 198, 198) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 108, 108, 108) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 204, 204, 204) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 207, 207, 207) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetOutputChannel_ColorChannelFlag_TestData))]
-    public void SetOutputChannel_Flag_Success(ColorChannelFlag flag, Color actualColor, Color expectedColor)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(flag);
-
-            bitmap.SetPixel(0, 0, actualColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(expectedColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> SetOutputChannel_ColorChannelFlagType_TestData()
-    {
-        yield return new object[] { ColorChannelFlag.ColorChannelC, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 198, 198, 198) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 108, 108, 108) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 204, 204, 204) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, ColorAdjustType.Default, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 207, 207, 207) };
-        yield return new object[] { ColorChannelFlag.ColorChannelC, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 198, 198, 198) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 108, 108, 108) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 204, 204, 204) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, ColorAdjustType.Bitmap, Color.FromArgb(255, 100, 100, 100), Color.FromArgb(255, 207, 207, 207) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetOutputChannel_ColorChannelFlagType_TestData))]
-    public void SetOutputChannel_FlagType_Success(ColorChannelFlag flag, ColorAdjustType type, Color actualColor, Color expectedColor)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(flag, type);
-
-            bitmap.SetPixel(0, 0, actualColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(expectedColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    public static IEnumerable<object[]> SetOutputChannel_ColorChannelFlagTypeI_TestData()
-    {
-        yield return new object[] { ColorChannelFlag.ColorChannelC, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, ColorAdjustType.Brush, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelC, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, ColorAdjustType.Pen, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelC, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelK, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelM, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-        yield return new object[] { ColorChannelFlag.ColorChannelY, ColorAdjustType.Text, Color.FromArgb(255, 100, 100, 100) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetOutputChannel_ColorChannelFlagTypeI_TestData))]
-    public void SetOutputChannel_FlagTypeI_Success(ColorChannelFlag flag, ColorAdjustType type, Color color)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(flag, type);
-
-            bitmap.SetPixel(0, 0, color);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(color, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannel_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelY));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelY, ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetOutputChannel_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelY, type));
-        }
-    }
-
-    public static IEnumerable<object[]> SetOutputChannel_InvalidColorChannelFlags_TestData()
-    {
-        yield return new object[] { (ColorChannelFlag)int.MinValue };
-        yield return new object[] { ColorChannelFlag.ColorChannelC - 1 };
-        yield return new object[] { ColorChannelFlag.ColorChannelLast };
-        yield return new object[] { ColorChannelFlag.ColorChannelLast + 1 };
-        yield return new object[] { (ColorChannelFlag)int.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetOutputChannel_InvalidColorChannelFlags_TestData))]
-    public void SetOutputChannel_InvalidFlags_ThrowsArgumentException(ColorChannelFlag flag)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannel(flag));
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannel(flag, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void ClearOutputChannel_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelC);
-            imageAttr.ClearOutputChannel();
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearOutputChannel_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelC, type);
-            imageAttr.ClearOutputChannel(type);
-
-            bitmap.SetPixel(0, 0, _actualGreen);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_actualGreen, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearOutputChannel_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannel());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannel(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearOutputChannel_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannel(type));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_Name_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelC);
-            imageAttr.SetOutputChannelColorProfile(Helpers.GetTestColorProfilePath("RSWOP.icm"));
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 198, 198, 198), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            imageAttr.SetOutputChannelColorProfile(Helpers.GetTestColorProfilePath("RSWOP.icm")));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            imageAttr.SetOutputChannelColorProfile(Helpers.GetTestColorProfilePath("RSWOP.icm"), ColorAdjustType.Default));
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_Null_ThrowsArgumentNullException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<ArgumentNullException>(() => imageAttr.SetOutputChannelColorProfile(null));
-            Assert.Throws<ArgumentNullException>(() => imageAttr.SetOutputChannelColorProfile(null, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_InvalidPath_ThrowsArgumentException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<ArgumentException>(() => imageAttr.SetOutputChannelColorProfile(string.Empty));
-            Assert.Throws<ArgumentException>(() => imageAttr.SetOutputChannelColorProfile(string.Empty, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_InvalidPath_ThrowsOutOfMemoryException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<OutOfMemoryException>(() => imageAttr.SetOutputChannelColorProfile("invalidPath"));
-            Assert.Throws<OutOfMemoryException>(() => imageAttr.SetOutputChannelColorProfile("invalidPath", ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetOutputChannelColorProfile_InvalidPath_ThrowsPathTooLongException()
-    {
-        string fileNameTooLong = new('a', short.MaxValue);
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<PathTooLongException>(() => imageAttr.SetOutputChannelColorProfile(fileNameTooLong));
-            Assert.Throws<PathTooLongException>(() => imageAttr.SetOutputChannelColorProfile(fileNameTooLong, ColorAdjustType.Default));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetOutputChannelColorProfile_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetOutputChannelColorProfile("path", type));
-        }
-    }
-
-    [Fact]
-    public void ClearOutputChannelColorProfile_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelC);
-            imageAttr.SetOutputChannelColorProfile(Helpers.GetTestColorProfilePath("RSWOP.icm"));
-            imageAttr.ClearOutputChannelColorProfile();
-            imageAttr.ClearOutputChannel();
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearOutputChannelColorProfile_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetOutputChannel(ColorChannelFlag.ColorChannelC, type);
-            imageAttr.SetOutputChannelColorProfile(Helpers.GetTestColorProfilePath("RSWOP.icm"), type);
-            imageAttr.ClearOutputChannelColorProfile(type);
-            imageAttr.ClearOutputChannel(type);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 100, 100, 100));
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(Color.FromArgb(255, 100, 100, 100), bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearOutputChannelColorProfile_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannelColorProfile());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannelColorProfile(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearOutputChannelColorProfile_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearOutputChannelColorProfile(type));
-        }
-    }
-
-    [Fact]
-    public void SetRemapTable_Map_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetRemapTable(_yellowToRedColorMap);
-            bitmap.SetPixel(0, 0, _yellowToRedColorMap[0].OldColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_yellowToRedColorMap[0].NewColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_TestData))]
-    public void SetRemapTable_MapType_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetRemapTable(_yellowToRedColorMap, type);
-            bitmap.SetPixel(0, 0, _yellowToRedColorMap[0].OldColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_yellowToRedColorMap[0].NewColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustTypeI_TestData))]
-    public void SetRemapTable_MapTypeI_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetRemapTable(_yellowToRedColorMap, type);
-            bitmap.SetPixel(0, 0, _yellowToRedColorMap[0].OldColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_yellowToRedColorMap[0].OldColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void SetRemapTable_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetRemapTable(_yellowToRedColorMap));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetRemapTable(_yellowToRedColorMap, ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void SetRemapTable_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetRemapTable(_yellowToRedColorMap, type));
-        }
-    }
-
-    [Fact]
-    public void SetRemapTable_NullMap_ThrowsNullReferenceException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<NullReferenceException>(() => imageAttr.SetRemapTable(null, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetRemapTable_NullMapMeber_ThrowsNullReferenceException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<NullReferenceException>(() => imageAttr.SetRemapTable(new ColorMap[1] { null }, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void SetRemapTable_EmptyMap_ThrowsArgumentException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetRemapTable(new ColorMap[0], ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void ClearRemapTable_Success()
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetRemapTable(_yellowToRedColorMap);
-            imageAttr.ClearRemapTable();
-            bitmap.SetPixel(0, 0, _yellowToRedColorMap[0].OldColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_yellowToRedColorMap[0].OldColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_AllTypesAllowed_TestData))]
-    public void ClearRemapTable_Type_Success(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var graphics = Graphics.FromImage(bitmap))
-        using (var imageAttr = new ImageAttributes())
-        {
-            imageAttr.SetRemapTable(_yellowToRedColorMap, type);
-            imageAttr.ClearRemapTable(type);
-            bitmap.SetPixel(0, 0, _yellowToRedColorMap[0].OldColor);
-            graphics.DrawImage(bitmap, _rectangle, _rectangle.X, _rectangle.Y, _rectangle.Width, _rectangle.Height, GraphicsUnit.Pixel, imageAttr);
-            Assert.Equal(_yellowToRedColorMap[0].OldColor, bitmap.GetPixel(0, 0));
-        }
-    }
-
-    [Fact]
-    public void ClearRemapTable_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearRemapTable());
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearRemapTable(ColorAdjustType.Default));
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void ClearRemapTable_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.ClearRemapTable(type));
-        }
-    }
-
-    [Fact]
-    public void SetWrapMode_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetWrapMode(WrapMode.Clamp));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetWrapMode(WrapMode.Clamp, Color.Black));
-        AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.SetWrapMode(WrapMode.Clamp, Color.Black, true));
-    }
-
-    [Fact]
-    public void GetAdjustedPalette_Disposed_ThrowsArgumentException()
-    {
-        var imageAttr = new ImageAttributes();
-        imageAttr.Dispose();
-
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.GetAdjustedPalette(bitmap.Palette, ColorAdjustType.Default));
-        }
-    }
-
-    [Fact]
-    public void GetAdjustedPalette_NullPallete_ThrowsNullReferenceException()
-    {
-        using (var imageAttr = new ImageAttributes())
-        {
-            Assert.Throws<NullReferenceException>(() => imageAttr.GetAdjustedPalette(null, ColorAdjustType.Default));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ColorAdjustType_InvalidTypes_TestData))]
-    public void GetAdjustedPalette_InvalidTypes_ThrowsArgumentException(ColorAdjustType type)
-    {
-        using (var bitmap = new Bitmap(_rectangle.Width, _rectangle.Height))
-        using (var imageAttr = new ImageAttributes())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => imageAttr.GetAdjustedPalette(bitmap.Palette, type));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/ImageCodecInfoTests.cs b/src/System.Drawing.Common/tests/Imaging/ImageCodecInfoTests.cs
deleted file mode 100644
index 5052ae22c59..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/ImageCodecInfoTests.cs
+++ /dev/null
@@ -1,215 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// (C) 2004 Ximian, Inc.  http://www.ximian.com
-// Copyright (C) 2004-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-using System.Collections;
-using System.Text.RegularExpressions;
-
-namespace System.Drawing.Imaging.Tests;
-
-public class ImageCodecInfoTests
-{
-    private const string GIF_CSID = "557cf402-1a04-11d3-9a73-0000f81ef32e";
-    private const string EMF_CSID = "557cf403-1a04-11d3-9a73-0000f81ef32e";
-    private const string BMP_DIB_RLE_CSID = "557cf400-1a04-11d3-9a73-0000f81ef32e";
-    private const string JPG_JPEG_JPE_JFIF_CSID = "557cf401-1a04-11d3-9a73-0000f81ef32e";
-    private const string PNG_CSID = "557cf406-1a04-11d3-9a73-0000f81ef32e";
-    private const string ICO_CSID = "557cf407-1a04-11d3-9a73-0000f81ef32e";
-    private const string WMF_CSID = "557cf404-1a04-11d3-9a73-0000f81ef32e";
-    private const string TIF_CSID = "557cf405-1a04-11d3-9a73-0000f81ef32e";
-
-    private Hashtable decoders;
-    private Hashtable encoders;
-
-    public ImageCodecInfoTests()
-    {
-        decoders = new Hashtable();
-        encoders = new Hashtable();
-
-        foreach (ImageCodecInfo decoder in ImageCodecInfo.GetImageDecoders())
-            decoders[decoder.Clsid] = decoder;
-
-        foreach (ImageCodecInfo encoder in ImageCodecInfo.GetImageEncoders())
-            encoders[encoder.Clsid] = encoder;
-    }
-
-    private ImageCodecInfo GetEncoder(string clsid)
-    {
-        return (ImageCodecInfo)encoders[new Guid(clsid)];
-    }
-
-    private ImageCodecInfo GetDecoder(string clsid)
-    {
-        return (ImageCodecInfo)decoders[new Guid(clsid)];
-    }
-
-    private void CheckDecoderAndEncoder(string clsid, ImageFormat format, string CodecName, string DllName,
-        string FilenameExtension, ImageCodecFlags Flags, string FormatDescription,
-        string MimeType, int Version, int signatureLength, string mask, string pattern, string pattern2)
-    {
-        ImageCodecInfo encoder = GetEncoder(clsid);
-        ImageCodecInfo decoder = GetDecoder(clsid);
-
-        if (encoder != null)
-        {
-            CheckImageCodecInfo(format, CodecName, DllName, FilenameExtension, Flags, FormatDescription, MimeType, signatureLength, mask, pattern, pattern2, encoder);
-        }
-        if (decoder != null)
-        {
-            CheckImageCodecInfo(format, CodecName, DllName, FilenameExtension, Flags, FormatDescription, MimeType, signatureLength, mask, pattern, pattern2, decoder);
-        }
-    }
-
-    private void CheckImageCodecInfo(ImageFormat format, string CodecName, string DllName, string FilenameExtension, ImageCodecFlags Flags, string FormatDescription, string MimeType, int signatureLength, string mask, string pattern, string pattern2, ImageCodecInfo codecInfo)
-    {
-        Regex extRegex = new Regex(@"^(\*\.\w+(;(\*\.\w+))*;)?" +
-            Regex.Escape(FilenameExtension) + @"(;\*\.\w+(;(\*\.\w+))*)?$",
-            RegexOptions.IgnoreCase | RegexOptions.Singleline);
-
-        Assert.Equal(format.Guid, codecInfo.FormatID);
-        Assert.Contains(CodecName, codecInfo.CodecName);
-        Assert.Equal(DllName, codecInfo.DllName);
-        Assert.Matches(extRegex, codecInfo.FilenameExtension);
-        Assert.Equal(Flags, codecInfo.Flags);
-        Assert.Contains(FormatDescription, codecInfo.FormatDescription);
-        Assert.Contains(MimeType, codecInfo.MimeType);
-        Assert.Equal(signatureLength, codecInfo.SignatureMasks.Length);
-
-        for (int i = 0; i < signatureLength; i++)
-        {
-            Assert.Equal(mask, BitConverter.ToString(codecInfo.SignatureMasks[i]));
-        }
-
-        Assert.Equal(signatureLength, codecInfo.SignaturePatterns.Length);
-        Assert.Equal(pattern, BitConverter.ToString(codecInfo.SignaturePatterns[0]));
-        if (pattern2 != null)
-            Assert.Equal(pattern2, BitConverter.ToString(codecInfo.SignaturePatterns[1]));
-    }
-
-    public static IEnumerable<object[]> CodecInfoTestData
-    {
-        get
-        {
-            yield return new object[] { WMF_CSID, ImageFormat.Wmf,
-            "WMF", null, "*.WMF",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "WMF", "image/x-wmf", 1, 1, "FF-FF-FF-FF", "D7-CD-C6-9A", null};
-
-            yield return new object[] { EMF_CSID, ImageFormat.Emf,
-            "EMF", null, "*.EMF",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "EMF", "image/x-emf", 1, 1, "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-FF-FF-FF-FF",
-            "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-20-45-4D-46", null};
-
-            yield return new object[] { ICO_CSID, ImageFormat.Icon,
-            "ICO", null, "*.ICO",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "ICO", "image/x-icon", 1, 1, "FF-FF-FF-FF", "00-00-01-00", null};
-
-            yield return new object[] { TIF_CSID, ImageFormat.Tiff,
-            "TIFF", null, "*.TIF;*.TIFF",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Encoder | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "TIFF", "image/tiff", 1, 2, "FF-FF", "49-49", "4D-4D" };
-
-            yield return new object[] { PNG_CSID, ImageFormat.Png,
-            "PNG", null, "*.PNG",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Encoder | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "PNG", "image/png", 1, 1, "FF-FF-FF-FF-FF-FF-FF-FF", "89-50-4E-47-0D-0A-1A-0A", null };
-
-            yield return new object[] { JPG_JPEG_JPE_JFIF_CSID, ImageFormat.Jpeg,
-            "JPEG", null, "*.JPG",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Encoder | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "JPEG", "image/jpeg", 1, 1, "FF-FF", "FF-D8", null};
-
-            yield return new object[] { GIF_CSID, ImageFormat.Gif,
-            "GIF", null, "*.GIF",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Encoder | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "GIF", "image/gif", 1, 2, "FF-FF-FF-FF-FF-FF", "47-49-46-38-39-61", "47-49-46-38-37-61"};
-
-            yield return new object[] { BMP_DIB_RLE_CSID, ImageFormat.Bmp,
-            "BMP", null, "*.BMP",
-            ImageCodecFlags.Builtin | ImageCodecFlags.Encoder | ImageCodecFlags.Decoder | ImageCodecFlags.SupportBitmap,
-            "BMP", "image/bmp", 1, 1, "FF-FF", "42-4D", null };
-        }
-    }
-
-    [Theory]
-    [InlineData(GIF_CSID)]
-    [InlineData(EMF_CSID)]
-    [InlineData(BMP_DIB_RLE_CSID)]
-    [InlineData(JPG_JPEG_JPE_JFIF_CSID)]
-    [InlineData(PNG_CSID)]
-    [InlineData(ICO_CSID)]
-    [InlineData(WMF_CSID)]
-    [InlineData(TIF_CSID)]
-    public void GetDecoder_Success(string csid)
-    {
-        Assert.NotNull(GetDecoder(csid));
-    }
-
-    [Theory]
-    [InlineData(GIF_CSID)]
-    [InlineData(BMP_DIB_RLE_CSID)]
-    [InlineData(JPG_JPEG_JPE_JFIF_CSID)]
-    [InlineData(PNG_CSID)]
-    [InlineData(TIF_CSID)]
-    public void GetEncoder_Success(string csid)
-    {
-        Assert.NotNull(GetEncoder(csid));
-    }
-
-    [Fact]
-    public void CountEncoders_ReturnsExcpected()
-    {
-        Assert.Equal(5, encoders.Count);
-    }
-
-    [Fact]
-    public void CountDecoders_ReturnsExcpected()
-    {
-        Assert.Equal(8, decoders.Count);
-    }
-
-    [Theory]
-    [MemberData(nameof(CodecInfoTestData))]
-    public void CheckDecoderAndEncoder_ReturnsExpecetd(string clsid, ImageFormat format, string codecName, string dllName,
-        string fileNameExtension, ImageCodecFlags flags, string formatDescription,
-        string mimeType, int version, int signatureLength, string mask, string pattern, string pattern2)
-    {
-        CheckDecoderAndEncoder(clsid, format, codecName, dllName, fileNameExtension, flags, formatDescription, mimeType, version, signatureLength, mask, pattern, pattern2);
-    }
-
-    [Theory]
-    [InlineData(WMF_CSID)]
-    [InlineData(EMF_CSID)]
-    [InlineData(ICO_CSID)]
-    public void GetEncoder_NoSuchEncoding_ReturnsNull(string clsid)
-    {
-        Assert.Null(GetEncoder(clsid));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/ImageFormatTests.cs b/src/System.Drawing.Common/tests/Imaging/ImageFormatTests.cs
deleted file mode 100644
index 2845c4bd09b..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/ImageFormatTests.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class ImageFormatTests
-{
-    private static ImageFormat BmpImageFormat = new(new Guid("b96b3cab-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat EmfImageFormat = new(new Guid("b96b3cac-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat ExifImageFormat = new(new Guid("b96b3cb2-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat GifImageFormat = new(new Guid("b96b3cb0-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat TiffImageFormat = new(new Guid("b96b3cb1-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat PngImageFormat = new(new Guid("b96b3caf-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat MemoryBmpImageFormat = new(new Guid("b96b3caa-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat IconImageFormat = new(new Guid("b96b3cb5-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat JpegImageFormat = new(new Guid("b96b3cae-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat WmfImageFormat = new(new Guid("b96b3cad-0728-11d3-9d7b-0000f81ef32e"));
-    private static ImageFormat HeifImageFormat = new(new Guid("{b96b3cb6-0728-11d3-9d7b-0000f81ef32e}"));
-    private static ImageFormat WebpImageFormat = new(new Guid("{b96b3cb7-0728-11d3-9d7b-0000f81ef32e}"));
-    private static ImageFormat CustomImageFormat = new(new Guid("48749428-316f-496a-ab30-c819a92b3137"));
-
-    public static IEnumerable<object[]> ImageFormatGuidTestData
-    {
-        get
-        {
-            yield return new object[] { BmpImageFormat.Guid, ImageFormat.Bmp };
-            yield return new object[] { EmfImageFormat.Guid, ImageFormat.Emf };
-            yield return new object[] { ExifImageFormat.Guid, ImageFormat.Exif };
-            yield return new object[] { GifImageFormat.Guid, ImageFormat.Gif };
-            yield return new object[] { TiffImageFormat.Guid, ImageFormat.Tiff };
-            yield return new object[] { PngImageFormat.Guid, ImageFormat.Png };
-            yield return new object[] { MemoryBmpImageFormat.Guid, ImageFormat.MemoryBmp };
-            yield return new object[] { IconImageFormat.Guid, ImageFormat.Icon };
-            yield return new object[] { JpegImageFormat.Guid, ImageFormat.Jpeg };
-            yield return new object[] { WmfImageFormat.Guid, ImageFormat.Wmf };
-#if NET
-            yield return new object[] { HeifImageFormat.Guid, ImageFormat.Heif };
-            yield return new object[] { WebpImageFormat.Guid, ImageFormat.Webp };
-#endif
-            yield return new object[] { new Guid("48749428-316f-496a-ab30-c819a92b3137"), CustomImageFormat };
-        }
-    }
-
-    public static IEnumerable<object[]> ImageFormatToStringTestData
-    {
-        get
-        {
-            yield return new object[] { "Bmp", ImageFormat.Bmp };
-            yield return new object[] { "Emf", ImageFormat.Emf };
-            yield return new object[] { "Exif", ImageFormat.Exif };
-            yield return new object[] { "Gif", ImageFormat.Gif };
-            yield return new object[] { "Tiff", ImageFormat.Tiff };
-            yield return new object[] { "Png", ImageFormat.Png };
-            yield return new object[] { "MemoryBMP", ImageFormat.MemoryBmp };
-            yield return new object[] { "Icon", ImageFormat.Icon };
-            yield return new object[] { "Jpeg", ImageFormat.Jpeg };
-            yield return new object[] { "Wmf", ImageFormat.Wmf };
-#if NET
-            yield return new object[] { "Heif", ImageFormat.Heif };
-            yield return new object[] { "Webp", ImageFormat.Webp };
-#endif
-            yield return new object[] { "[ImageFormat: 48749428-316f-496a-ab30-c819a92b3137]", CustomImageFormat };
-        }
-    }
-
-    public static IEnumerable<object[]> ImageFromFileToStringTestData
-    {
-        get
-        {
-            yield return new object[] { Path.Combine("bitmaps", "nature24bits.gif"), "Gif" };
-            yield return new object[] { Path.Combine("bitmaps", "nature24bits.jpg"), "Jpeg" };
-            yield return new object[] { Path.Combine("bitmaps", "VisualPng.ico"), "Icon"};
-            yield return new object[] { Path.Combine("bitmaps", "almogaver32bits.tif"), "Tiff" };
-        }
-    }
-
-    public static IEnumerable<object[]> ImageFormatEqualsTestData
-    {
-        get
-        {
-            yield return new object[] { new ImageFormat(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new ImageFormat(new Guid("48749428-316f-496a-ab30-c819a92b3137")), true };
-            yield return new object[] { new ImageFormat(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new ImageFormat(new Guid("b96b3cad-0728-11d3-9d7b-0000f81ef32e")), false };
-            yield return new object[] { new ImageFormat(new Guid("48749428-316f-496a-ab30-c819a92b3137")), null, false };
-            yield return new object[] { new ImageFormat(new Guid("48749428-316f-496a-ab30-c819a92b3137")), new object(), false };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ImageFormatGuidTestData))]
-    public void Guid_ReturnsExpected(Guid expectedGuid, ImageFormat imageFormat)
-    {
-        Assert.Equal(expectedGuid, imageFormat.Guid);
-    }
-
-    [Theory]
-    [MemberData(nameof(ImageFormatToStringTestData))]
-    public void ToString_ReturnsExpected(string expected, ImageFormat imageFormat)
-    {
-        Assert.Equal(expected, imageFormat.ToString());
-    }
-
-    [Theory]
-    [MemberData(nameof(ImageFromFileToStringTestData))]
-    public void Image_RawFormat_ToString(string path, string expected)
-    {
-        var img = Image.FromFile(path);
-        Assert.Equal(expected, img.RawFormat.ToString());
-    }
-
-    [Theory]
-    [MemberData(nameof(ImageFormatEqualsTestData))]
-    public void Equals_Object_ReturnsExpected(ImageFormat imageFormat, object obj, bool result)
-    {
-        Assert.Equal(result, imageFormat.Equals(obj));
-    }
-
-    [Fact]
-    public void GetHashCode_Success()
-    {
-        Guid guid = Guid.NewGuid();
-        Assert.Equal(guid.GetHashCode(), new ImageFormat(guid).GetHashCode());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/MetaHeaderTests.cs b/src/System.Drawing.Common/tests/Imaging/MetaHeaderTests.cs
deleted file mode 100644
index 7d6b3b3194a..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/MetaHeaderTests.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class MetaHeaderTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        MetaHeader mh = new MetaHeader();
-        Assert.Equal(0, mh.HeaderSize);
-        Assert.Equal(0, mh.MaxRecord);
-        Assert.Equal(0, mh.NoObjects);
-        Assert.Equal(0, mh.NoParameters);
-        Assert.Equal(0, mh.Size);
-        Assert.Equal(0, mh.Type);
-        Assert.Equal(0, mh.Version);
-    }
-
-    [Theory]
-    [InlineData(short.MaxValue)]
-    [InlineData(0)]
-    [InlineData(short.MinValue)]
-    public void ShortProperties_SetValues_ReturnsExpected(short value)
-    {
-        MetaHeader mh = new MetaHeader();
-        mh.HeaderSize = value;
-        mh.NoObjects = value;
-        mh.NoParameters = value;
-        mh.Type = value;
-        mh.Version = value;
-        Assert.Equal(value, mh.HeaderSize);
-        Assert.Equal(value, mh.NoObjects);
-        Assert.Equal(value, mh.NoParameters);
-        Assert.Equal(value, mh.Type);
-        Assert.Equal(value, mh.Version);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void IntProperties_SetValues_ReturnsExpected(int value)
-    {
-        MetaHeader mh = new MetaHeader();
-        mh.Size = value;
-        mh.MaxRecord = value;
-        Assert.Equal(value, mh.Size);
-        Assert.Equal(value, mh.MaxRecord);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/MetafileTests.cs b/src/System.Drawing.Common/tests/Imaging/MetafileTests.cs
deleted file mode 100644
index 9274ea35438..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/MetafileTests.cs
+++ /dev/null
@@ -1,1097 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Runtime.InteropServices;
-
-namespace System.Drawing.Imaging.Tests;
-
-public class MetafileTests
-{
-    private const string WmfFile = "telescope_01.wmf";
-    private const string BmpFile = "bitmap_173x183_indexed_8bit.bmp";
-    private readonly Rectangle _rectangle = new(0, 0, 64, 64);
-    private readonly RectangleF _rectangleF = new(0, 0, 64, 64);
-
-    [Fact]
-    public void Ctor_IntPtrZero_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, false));
-    }
-
-    [Fact]
-    public void Ctor_IntPtrToWmf_ThrowsExternalException()
-    {
-        using (var metafile = new Metafile(GetPath(WmfFile)))
-        {
-            Assert.Throws<ExternalException>(() => new Metafile(metafile.GetHenhmetafile(), false));
-        }
-    }
-
-    [Fact]
-    public void Ctor_String_Success()
-    {
-        using (var metafile = new Metafile(GetPath(WmfFile)))
-        {
-            AssertMetafile(metafile);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Bitmap_ThrowsExternalException()
-    {
-        Assert.Throws<ExternalException>(() => new Metafile(GetPath(BmpFile)));
-    }
-
-    [Fact]
-    public void Ctor_NullString_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Metafile((string)null));
-    }
-
-    [Fact]
-    public void Ctor_InvalidPath_ThrowsExternalException()
-    {
-        Assert.Throws<ExternalException>(() => new Metafile("fileNotExist"));
-    }
-
-    public static IEnumerable<object[]> InvalidPath_TestData()
-    {
-        yield return new object[] { new string('a', 261) };
-        yield return new object[] { @"fileNo*-//\\#@(found" };
-        yield return new object[] { string.Empty };
-    }
-
-    [Theory]
-    [InlineData("bad\0name")]
-    [InlineData("")]
-    public void Ctor_InvalidPath_ThrowsArgumentException(string path)
-    {
-        AssertExtensions.Throws<ArgumentException>("path", null, () => new Metafile(path));
-    }
-
-    [Fact]
-    public void Ctor_Stream_Success()
-    {
-        using (FileStream stream = File.OpenRead(GetPath(WmfFile)))
-        using (var metafile = new Metafile(stream))
-        {
-            AssertMetafile(metafile);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullStream_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentNullException, ArgumentException>("stream", null, () => new Metafile((Stream)null));
-    }
-
-    [Fact]
-    public void Ctor_EmptyStream_ThrowsExternalException()
-    {
-        using (var stream = new MemoryStream())
-        {
-            Assert.Throws<ExternalException>(() => new Metafile(stream));
-        }
-    }
-
-    public static IEnumerable<object[]> EmfType_TestData()
-    {
-        yield return new object[] { EmfType.EmfOnly };
-        yield return new object[] { EmfType.EmfPlusDual };
-        yield return new object[] { EmfType.EmfPlusOnly };
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_IntPtrEmfType_Success(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-        }
-    }
-
-    public static IEnumerable<object[]> EmfType_Invalid_TestData()
-    {
-        yield return new object[] { (EmfType.EmfOnly - 1) };
-        yield return new object[] { (EmfType.EmfPlusDual + 1) };
-        yield return new object[] { (EmfType)int.MaxValue };
-        yield return new object[] { (EmfType)int.MinValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_Invalid_TestData))]
-    public void Ctor_IntPtrInvalidEmfType_ThrowsArgumentException(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(g.GetHdc(), emfType));
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullEmfType_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile((IntPtr)null, EmfType.EmfOnly));
-    }
-
-    [Fact]
-    public void Ctor_ZeroPointerEmfType_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, EmfType.EmfOnly));
-    }
-
-    public static IEnumerable<object[]> Description_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "description" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_IntPtrEmfTypeString_Success(string description)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidPath_TestData))]
-    public void Ctor_ZeroPointerEmfTypeInvalidString_ThrowsArgumentException(string description)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, EmfType.EmfOnly, description));
-    }
-
-    [Fact]
-    public void Ctor_IntPtrRectangleF_Success()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangleF))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    public static IEnumerable<object[]> MetafileFrameUnit_TestData()
-    {
-        yield return new object[] { MetafileFrameUnit.Pixel };
-        yield return new object[] { MetafileFrameUnit.Point };
-        yield return new object[] { MetafileFrameUnit.Inch };
-        yield return new object[] { MetafileFrameUnit.Document };
-        yield return new object[] { MetafileFrameUnit.Millimeter };
-        yield return new object[] { MetafileFrameUnit.GdiCompatible };
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_TestData))]
-    public void Ctor_IntPtrRectangleFMetafileFrameUnit_Success(MetafileFrameUnit frameUnit)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangleF, frameUnit))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_IntPtrRectangleFMetafileFrameUnitEmfType_Success(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangleF, MetafileFrameUnit.Pixel, emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_IntPtrRectangleFMetafileFrameUnitEmfTypeString_Success(string description)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangleF, MetafileFrameUnit.Pixel, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Fact]
-    public void Ctor_IntPtrRectangle_Success()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangle))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_TestData))]
-    public void Ctor_IntPtrRectangleMetafileFrameUnit_Success(MetafileFrameUnit frameUnit)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangle, frameUnit))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_IntPtrRectangleMetafileFrameUnitEmfType_Success(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangle, MetafileFrameUnit.Pixel, emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_IntPtrRectangleMetafileFrameUnitEmfTypeString_Success(string description)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(g.GetHdc(), _rectangle, MetafileFrameUnit.Pixel, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Fact]
-    public void Ctor_IntPtrZeroI_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, _rectangleF));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, _rectangleF, MetafileFrameUnit.Pixel));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(IntPtr.Zero, _rectangleF, MetafileFrameUnit.Pixel, EmfType.EmfOnly));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(IntPtr.Zero, _rectangleF, MetafileFrameUnit.Pixel, EmfType.EmfOnly, "description"));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, _rectangle));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(IntPtr.Zero, _rectangle, MetafileFrameUnit.Pixel));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(IntPtr.Zero, _rectangle, MetafileFrameUnit.Pixel, EmfType.EmfOnly));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(IntPtr.Zero, _rectangle, MetafileFrameUnit.Pixel, EmfType.EmfOnly, "description"));
-    }
-
-    public static IEnumerable<object[]> MetafileFrameUnit_Invalid_TestData()
-    {
-        yield return new object[] { (MetafileFrameUnit.Pixel - 1) };
-        yield return new object[] { (MetafileFrameUnit.GdiCompatible + 1) };
-        yield return new object[] { (MetafileFrameUnit)int.MaxValue };
-        yield return new object[] { (MetafileFrameUnit)int.MinValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_Invalid_TestData))]
-    public void Ctor_InvalidMetafileFrameUnit_ThrowsArgumentException(MetafileFrameUnit farameUnit)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(referenceHdc, _rectangleF, farameUnit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(referenceHdc, _rectangleF, farameUnit, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangleF, farameUnit, EmfType.EmfOnly, "description"));
-
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(referenceHdc, _rectangle, farameUnit));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(referenceHdc, _rectangle, farameUnit, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangle, farameUnit, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_Invalid_TestData))]
-    public void Ctor_InvalidEmfType_ThrowsArgumentException(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, emfType, "description"));
-
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType, "description"));
-        }
-    }
-
-    [Fact]
-    public void Ctor_StringIntPtr_Success()
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc()))
-        {
-            AssertMetafileIsBlank(metafile);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_StringIntPtrEmfType_Success(EmfType emfType)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_StringIntPtrEmfTypeDescription_Success(string description)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), EmfType.EmfPlusDual, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfPlusDual);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Fact]
-    public void Ctor_IntPtrZeroII_ThrowsArgumentException()
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, EmfType.EmfOnly));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, EmfType.EmfOnly, "description"));
-        DeleteFile(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_Invalid_TestData))]
-    public void Ctor_InvalidEmfTypeI_ThrowsArgumentException(EmfType emfType)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, referenceHdc, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, referenceHdc, emfType, "description"));
-            DeleteFile(fileName);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullPath_ThrowsArgumentNullException()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentNullException>("path", () => new Metafile((string)null, referenceHdc));
-            AssertExtensions.Throws<ArgumentNullException>("path", () => new Metafile((string)null, referenceHdc, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentNullException>("path", () => new Metafile((string)null, referenceHdc, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Theory]
-    [InlineData("bad\0path")]
-    [InlineData("")]
-    public void Ctor_InvalidPathI_ThrowsArgumentException(string fileName)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>("path", null, () => new Metafile(fileName, referenceHdc));
-            AssertExtensions.Throws<ArgumentException>("path", null, () => new Metafile(fileName, referenceHdc, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>("path", null, () => new Metafile(fileName, referenceHdc, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Fact]
-    public void Ctor_PathTooLong_ThrowsPathTooLongException()
-    {
-        string fileName = GetPath(new string('a', short.MaxValue));
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            Assert.Throws<PathTooLongException>(() => new Metafile(fileName, referenceHdc));
-            Assert.Throws<PathTooLongException>(() => new Metafile(fileName, referenceHdc, EmfType.EmfOnly));
-            Assert.Throws<PathTooLongException>(() => new Metafile(fileName, referenceHdc, EmfType.EmfOnly, "description"));
-            DeleteFile(fileName);
-        }
-    }
-
-    [Fact]
-    public void Ctor_StringIntPtrRectangleF_Success()
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangleF))
-        {
-            AssertMetafileIsBlank(metafile);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_TestData))]
-    public void Ctor_StringIntPtrRectangleFMetafileFrameUnit_Success(MetafileFrameUnit frameUnit)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangleF, frameUnit))
-        {
-            AssertMetafileIsBlank(metafile);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_StringIntPtrRectangleFMetafileFrameUnitEmfType_Success(EmfType emfType)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangleF, MetafileFrameUnit.GdiCompatible, emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_StringIntPtrRectangleFMetafileFrameUnitEmfTypeString_Success(string description)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(
-            fileName, g.GetHdc(), _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_RectangleFEmpty_Success(string description)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(
-            fileName, g.GetHdc(), new RectangleF(), MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Fact]
-    public void Ctor_StringIntPtrRectangle_Success()
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangle))
-        {
-            AssertMetafileIsBlank(metafile);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_TestData))]
-    public void Ctor_StringIntPtrRectangleMetafileFrameUnit_Success(MetafileFrameUnit frameUnit)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangle, frameUnit))
-        {
-            AssertMetafileIsBlank(metafile);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_StringIntPtrRectangleMetafileFrameUnitEmfType_Success(EmfType emfType)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(fileName, g.GetHdc(), _rectangle, MetafileFrameUnit.GdiCompatible, emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_StringIntPtrRectangleMetafileFrameUnitEmfTypeString_Success(string description)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(
-            fileName, g.GetHdc(), _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_RectangleEmpty_Success(string description)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var metafile = new Metafile(
-            fileName, g.GetHdc(), new Rectangle(), MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-            Assert.True(File.Exists(fileName));
-        }
-
-        File.Delete(fileName);
-    }
-
-    [Fact]
-    public void Ctor_IntPtrZeroIII_ThrowsArgumentException()
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, _rectangleF));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, _rectangleF, MetafileFrameUnit.GdiCompatible));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(fileName, IntPtr.Zero, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(fileName, IntPtr.Zero, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, _rectangle));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(fileName, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            new Metafile(fileName, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-        DeleteFile(fileName);
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_Invalid_TestData))]
-    public void Ctor_InvalidFrameUnit_ThrowsArgumentException(MetafileFrameUnit frameUnit)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, referenceHdc, _rectangleF, frameUnit));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, frameUnit, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, frameUnit, EmfType.EmfOnly, "description"));
-
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(fileName, referenceHdc, _rectangle, frameUnit));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangle, frameUnit, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangle, frameUnit, EmfType.EmfOnly, "description"));
-            DeleteFile(fileName);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_Invalid_TestData))]
-    public void Ctor_InvalidEmfTypeII_ThrowsArgumentException(EmfType emfType)
-    {
-        string fileName = GetPath("newTestImage.wmf");
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, emfType, "description"));
-
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-               new Metafile(fileName, referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(fileName, referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType, "description"));
-            DeleteFile(fileName);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullPathI_ThrowsArgumentNullException()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentNullException>("path", () => new Metafile((string)null, referenceHdc, _rectangleF));
-            AssertExtensions.Throws<ArgumentNullException>("path", () =>
-                new Metafile((string)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible));
-            AssertExtensions.Throws<ArgumentNullException>("path", () =>
-                new Metafile((string)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentNullException>("path", () =>
-                new Metafile((string)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Theory]
-    [InlineData("bad\0path")]
-    [InlineData("")]
-    public void Ctor_InvalidPathII_ThrowsArgumentException(string fileName)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException, ArgumentException>("path", null, () => new Metafile(fileName, referenceHdc, _rectangleF));
-            AssertExtensions.Throws<ArgumentException, ArgumentException>("path", null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible));
-            AssertExtensions.Throws<ArgumentException, ArgumentException>("path", null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException, ArgumentException>("path", null, () =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Fact]
-    public void Ctor_PathTooLongI_ThrowsPathTooLongException()
-    {
-        string fileName = GetPath(new string('a', 261));
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            Assert.Throws<PathTooLongException>(() => new Metafile(fileName, referenceHdc, _rectangleF));
-            Assert.Throws<PathTooLongException>(() =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible));
-            Assert.Throws<PathTooLongException>(() =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-            Assert.Throws<PathTooLongException>(() =>
-                new Metafile(fileName, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-            DeleteFile(fileName);
-        }
-    }
-
-    [Fact]
-    public void Ctor_StreamIntPtrRectangle_Success()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var stream = new MemoryStream())
-        using (var metafile = new Metafile(stream, g.GetHdc(), _rectangle))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_TestData))]
-    public void Ctor_StreamIntPtrRectangleMetafileFrameUnit_Success(MetafileFrameUnit frameUnit)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var stream = new MemoryStream())
-        using (var metafile = new Metafile(stream, g.GetHdc(), _rectangle, frameUnit))
-        {
-            AssertMetafileIsBlank(metafile);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_TestData))]
-    public void Ctor_StreamIntPtrRectangleMetafileFrameUnitEmfType_Success(EmfType emfType)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var stream = new MemoryStream())
-        using (var metafile = new Metafile(stream, g.GetHdc(), _rectangle, MetafileFrameUnit.GdiCompatible, emfType))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), emfType);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_StreamIntPtrRectangleMetafileFrameUnitEmfTypeString_Success(string description)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var stream = new MemoryStream())
-        using (var metafile = new Metafile(
-            stream, g.GetHdc(), _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Description_TestData))]
-    public void Ctor_RectangleEmptyI_Success(string description)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (var stream = new MemoryStream())
-        using (var metafile = new Metafile(
-            stream, g.GetHdc(), new Rectangle(), MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, description))
-        {
-            AssertMetafileIsBlank(metafile);
-            AssertEmfType(metafile.GetMetafileHeader(), EmfType.EmfOnly);
-        }
-    }
-
-    [Fact]
-    public void Ctor_IntPtrZeroIV_ThrowsArgumentException()
-    {
-        using (var stream = new MemoryStream())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(stream, IntPtr.Zero, _rectangle));
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(stream, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(stream, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(stream, IntPtr.Zero, _rectangle, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(MetafileFrameUnit_Invalid_TestData))]
-    public void Ctor_InvalidFrameUnitIII_ThrowsArgumentException(MetafileFrameUnit frameUnit)
-    {
-        using (var stream = new MemoryStream())
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () => new Metafile(stream, referenceHdc, _rectangle, frameUnit));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(stream, referenceHdc, _rectangle, frameUnit, EmfType.EmfOnly));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(stream, referenceHdc, _rectangle, frameUnit, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(EmfType_Invalid_TestData))]
-    public void Ctor_InvalidEmfTypeIII_ThrowsArgumentException(EmfType emfType)
-    {
-        using (var stream = new MemoryStream())
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-               new Metafile(stream, referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType));
-            AssertExtensions.Throws<ArgumentException>(null, () =>
-                new Metafile(stream, referenceHdc, _rectangle, MetafileFrameUnit.GdiCompatible, emfType, "description"));
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullStream_ThrowsNullReferenceException()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr referenceHdc = g.GetHdc();
-            Assert.Throws<NullReferenceException>(() => new Metafile((Stream)null, referenceHdc, _rectangleF));
-            Assert.Throws<NullReferenceException>(() => new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible));
-            Assert.Throws<NullReferenceException>(() =>
-                new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly));
-            Assert.Throws<NullReferenceException>(() =>
-                new Metafile((Stream)null, referenceHdc, _rectangleF, MetafileFrameUnit.GdiCompatible, EmfType.EmfOnly, "description"));
-        }
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_String_ReturnsExpected()
-    {
-        MetafileHeader header = Metafile.GetMetafileHeader(GetPath(WmfFile));
-        AssertMetafileHeader(header);
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_IntPtr_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Metafile.GetMetafileHeader(IntPtr.Zero));
-        using (var metafile = new Metafile(GetPath(WmfFile)))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => Metafile.GetMetafileHeader(metafile.GetHenhmetafile()));
-        }
-    }
-
-    [Theory]
-    [InlineData("bad\0path")]
-    [InlineData("")]
-    public void Static_GetMetafileHeader_InvalidPath_ThrowsArgumentException(string fileName)
-    {
-        AssertExtensions.Throws<ArgumentException>("path", null, () => Metafile.GetMetafileHeader(fileName));
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_NullString_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => Metafile.GetMetafileHeader((string)null));
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_Stream_ReturnsExpected()
-    {
-        using (FileStream stream = File.OpenRead(GetPath(WmfFile)))
-        {
-            MetafileHeader header = Metafile.GetMetafileHeader(stream);
-            AssertMetafileHeader(header);
-        }
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_NullStream_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => Metafile.GetMetafileHeader((Stream)null));
-    }
-
-    [Fact]
-    public void Static_GetMetafileHeader_EmptyStream_ArgumentException()
-    {
-        using (var stream = new MemoryStream())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => Metafile.GetMetafileHeader(stream));
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_ReturnsExpected()
-    {
-        using (var metafile = new Metafile(GetPath(WmfFile)))
-        {
-            MetafileHeader headerA = metafile.GetMetafileHeader();
-            MetafileHeader headerB = metafile.GetMetafileHeader();
-            AssertMetafileHeader(headerA);
-            Assert.NotSame(headerA, headerB);
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_Disposed_ThrowsArgumentException()
-    {
-        var metafile = new Metafile(GetPath(WmfFile));
-        metafile.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => metafile.GetMetafileHeader());
-    }
-
-    [Fact]
-    public void GetHenhmetafile_ReturnsExpected()
-    {
-        using (var metafile = new Metafile(GetPath(WmfFile)))
-        {
-            Assert.NotEqual(IntPtr.Zero, metafile.GetHenhmetafile());
-        }
-    }
-
-    [Fact]
-    public void GetHenhmetafile_Disposed_ThrowsArgumentException()
-    {
-        var metafile = new Metafile(GetPath(WmfFile));
-        metafile.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => metafile.GetHenhmetafile());
-    }
-
-    [Fact]
-    public void PlayRecord_Disposed_ThrowsArgumentException()
-    {
-        var metafile = new Metafile(GetPath(WmfFile));
-        metafile.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () =>
-            metafile.PlayRecord(EmfPlusRecordType.BeginContainer, 0, 1, new byte[1]));
-    }
-
-    private void DeleteFile(string path)
-    {
-        if (File.Exists(path))
-        {
-            File.Delete(path);
-        }
-    }
-
-    private string GetPath(string fileName)
-    {
-        return Helpers.GetTestBitmapPath(fileName);
-    }
-
-    private void AssertEmfType(MetafileHeader metafileHeader, EmfType emfType)
-    {
-        switch (emfType)
-        {
-            case EmfType.EmfOnly:
-                Assert.True(metafileHeader.IsEmf());
-                break;
-            case EmfType.EmfPlusDual:
-                Assert.True(metafileHeader.IsEmfPlusDual());
-                break;
-            case EmfType.EmfPlusOnly:
-                Assert.True(metafileHeader.IsEmfPlusOnly());
-                break;
-        }
-    }
-
-    private void AssertMetafileIsBlank(Metafile metafile)
-    {
-        GraphicsUnit graphicsUnit = (GraphicsUnit)int.MaxValue;
-
-        AssertMetafileHeaderIsBlank(metafile.GetMetafileHeader());
-
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-        {
-            // This values are incorrect on libgdiplus.
-            Assert.Equal(new Rectangle(0, 0, 1, 1), metafile.GetBounds(ref graphicsUnit));
-            Assert.Equal(GraphicsUnit.Pixel, graphicsUnit);
-        }
-    }
-
-    private void AssertMetafileHeaderIsBlank(MetafileHeader metafileHeader)
-    {
-        Assert.Equal(new Rectangle(0, 0, 0, 0), metafileHeader.Bounds);
-        Assert.Equal(0, metafileHeader.MetafileSize);
-    }
-
-    private void AssertMetafile(Metafile metafile)
-    {
-        GraphicsUnit graphicsUnit = (GraphicsUnit)int.MaxValue;
-
-        AssertMetafileHeader(metafile.GetMetafileHeader());
-        Assert.Equal(new Rectangle(-30, -40, 3096, 4127), metafile.GetBounds(ref graphicsUnit));
-        Assert.Equal(GraphicsUnit.Pixel, graphicsUnit);
-    }
-
-    private void AssertMetafileHeader(MetafileHeader header)
-    {
-        Assert.Equal(MetafileType.WmfPlaceable, header.Type);
-        Assert.Equal(0x300, header.Version);
-        Assert.Equal(new Rectangle(-30, -40, 3096, 4127), header.Bounds);
-        Assert.Equal(606, header.DpiX);
-        Assert.Equal(606, header.DpiY);
-        Assert.Equal(0, header.EmfPlusHeaderSize);
-        Assert.Equal(0, header.LogicalDpiX);
-        Assert.Equal(0, header.LogicalDpiY);
-        Assert.Equal(3474, header.MetafileSize);
-        Assert.NotNull(header.WmfHeader);
-        Assert.False(header.IsDisplay());
-        Assert.False(header.IsEmf());
-        Assert.False(header.IsEmfOrEmfPlus());
-        Assert.False(header.IsEmfPlus());
-        Assert.False(header.IsEmfPlusDual());
-        Assert.False(header.IsEmfPlusOnly());
-        Assert.True(header.IsWmf());
-        Assert.True(header.IsWmfPlaceable());
-
-        Assert.Equal(9, header.WmfHeader.HeaderSize);
-        Assert.Equal(98, header.WmfHeader.MaxRecord);
-        Assert.Equal(3, header.WmfHeader.NoObjects);
-        Assert.Equal(0, header.WmfHeader.NoParameters);
-        Assert.Equal(1737, header.WmfHeader.Size);
-        Assert.Equal((int)MetafileType.Wmf, header.WmfHeader.Type);
-        Assert.Equal(0x300, header.WmfHeader.Version);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/PropertyItemTests.cs b/src/System.Drawing.Common/tests/Imaging/PropertyItemTests.cs
deleted file mode 100644
index 2a4fb076865..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/PropertyItemTests.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class PropertyItemTests
-{
-    private const int PropertyTagLuminanceTable = 0x5090;
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void Id_Set_GetReturnsExpected(int value)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagLuminanceTable);
-        item.Id = value;
-        Assert.Equal(value, item.Id);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void Len_Set_GetReturnsExpected(int value)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagLuminanceTable);
-        item.Len = value;
-        Assert.Equal(value, item.Len);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void Type_Set_GetReturnsExpected(short value)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagLuminanceTable);
-        item.Type = value;
-        Assert.Equal(value, item.Type);
-    }
-
-    public static IEnumerable<object[]> Value_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<byte>() };
-        yield return new object[] { new byte[] { 1, 2, 3 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void Value_Set_GetReturnsExpected(byte[] value)
-    {
-        using var bitmap = new Bitmap(Helpers.GetTestBitmapPath("nature24bits.jpg"));
-        PropertyItem item = bitmap.GetPropertyItem(PropertyTagLuminanceTable);
-        item.Value = value;
-        Assert.Same(value, item.Value);
-    }
-
-    public static IEnumerable<object[]> Properties_TestData()
-    {
-        yield return new object[] { int.MaxValue, int.MaxValue, short.MaxValue, new byte[1] { 0 } };
-        yield return new object[] { int.MinValue, int.MinValue, short.MinValue, new byte[2] { 1, 1} };
-        yield return new object[] { 0, 0, 0, new byte[0] };
-    }
-
-    [Theory]
-    [MemberData(nameof(Properties_TestData))]
-    public void Properties_SetValues_ReturnsExpected(int id, int len, short type, byte[] value)
-    {
-        using var image = new Bitmap(Helpers.GetTestBitmapPath("16x16_nonindexed_24bit.png"));
-        using Image clone = (Image)image.Clone();
-
-        PropertyItem[] propItems = clone.PropertyItems;
-        PropertyItem propItem = propItems[0];
-        Assert.Equal(771, propItem.Id);
-        Assert.Equal(1, propItem.Len);
-        Assert.Equal(1, propItem.Type);
-        Assert.Equal(new byte[1] { 0 }, propItem.Value);
-
-        propItem.Id = id;
-        propItem.Len = len;
-        propItem.Type = type;
-        propItem.Value = value;
-
-        Assert.Equal(id, propItem.Id);
-        Assert.Equal(len, propItem.Len);
-        Assert.Equal(type, propItem.Type);
-        Assert.Equal(value, propItem.Value);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Imaging/WmfPlaceableFileHeaderTests.cs b/src/System.Drawing.Common/tests/Imaging/WmfPlaceableFileHeaderTests.cs
deleted file mode 100644
index 529cc637294..00000000000
--- a/src/System.Drawing.Common/tests/Imaging/WmfPlaceableFileHeaderTests.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Imaging.Tests;
-
-public class WmfPlaceableFileHeaderTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        WmfPlaceableFileHeader fileHeader = new WmfPlaceableFileHeader();
-        Assert.Equal(0, fileHeader.BboxBottom);
-        Assert.Equal(0, fileHeader.BboxLeft);
-        Assert.Equal(0, fileHeader.BboxRight);
-        Assert.Equal(0, fileHeader.BboxTop);
-        Assert.Equal(0, fileHeader.Checksum);
-        Assert.Equal(0, fileHeader.Hmf);
-        Assert.Equal(0, fileHeader.Inch);
-        Assert.Equal(unchecked((int)0x9aC6CDD7), fileHeader.Key);
-        Assert.Equal(0, fileHeader.Reserved);
-    }
-
-    [Theory]
-    [InlineData(short.MaxValue)]
-    [InlineData(0)]
-    [InlineData(short.MinValue)]
-    public void ShortProperties_SetValues_ReturnsExpected(short value)
-    {
-        WmfPlaceableFileHeader fileHeader = new WmfPlaceableFileHeader();
-        fileHeader.BboxBottom = value;
-        fileHeader.BboxLeft = value;
-        fileHeader.BboxRight = value;
-        fileHeader.BboxTop = value;
-        fileHeader.Checksum = value;
-        fileHeader.Hmf = value;
-        fileHeader.Inch = value;
-        fileHeader.Key = value;
-        fileHeader.Reserved = value;
-        Assert.Equal(value, fileHeader.BboxBottom);
-        Assert.Equal(value, fileHeader.BboxLeft);
-        Assert.Equal(value, fileHeader.BboxRight);
-        Assert.Equal(value, fileHeader.BboxTop);
-        Assert.Equal(value, fileHeader.Checksum);
-        Assert.Equal(value, fileHeader.Hmf);
-        Assert.Equal(value, fileHeader.Inch);
-        Assert.Equal(value, fileHeader.Key);
-        Assert.Equal(value, fileHeader.Reserved);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(0)]
-    [InlineData(int.MinValue)]
-    public void IntProperties_SetValues_ReturnsExpected(int value)
-    {
-        WmfPlaceableFileHeader fileHeader = new WmfPlaceableFileHeader();
-        fileHeader.Key = value;
-        fileHeader.Reserved = value;
-        Assert.Equal(value, fileHeader.Key);
-        Assert.Equal(value, fileHeader.Reserved);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/PenTests.cs b/src/System.Drawing.Common/tests/PenTests.cs
deleted file mode 100644
index 389ca849cd9..00000000000
--- a/src/System.Drawing.Common/tests/PenTests.cs
+++ /dev/null
@@ -1,1385 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-using System.Globalization;
-
-namespace System.Drawing.Tests;
-
-public class PenTests
-{
-    public static IEnumerable<object[]> Ctor_Brush_TestData()
-    {
-        yield return new object[] { new SolidBrush(Color.Red), PenType.SolidColor };
-        yield return new object[] { new HatchBrush(HatchStyle.BackwardDiagonal, Color.Red), PenType.HatchFill };
-        yield return new object[] { new LinearGradientBrush(new Point(0, 0), new Point(0, 2), Color.Purple, Color.Plum), PenType.LinearGradient };
-        yield return new object[] { new TextureBrush(new Bitmap(1, 1)), PenType.TextureFill };
-        yield return new object[] { new PathGradientBrush(new Point[] { new Point(1, 2), new Point(2, 3) }), PenType.PathGradient };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Brush_TestData))]
-    public void Ctor_Brush<T>(T brush, PenType penType) where T : Brush
-    {
-        using (brush)
-        using (var pen = new Pen(brush))
-        {
-            VerifyPen<T>(pen, penType, expectedWidth: 1);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Brush_Width_TestData()
-    {
-        foreach (object[] data in Ctor_Brush_TestData())
-        {
-            yield return new object[] { data[0], 10, data[1] };
-        }
-
-        // Issue on Non-English Windows with brush width < 1. See https://github.com/dotnet/runtime/issues/60480
-        if (Environment.OSVersion.Platform != PlatformID.Win32NT || CultureInfo.InstalledUICulture.TwoLetterISOLanguageName == "en")
-        {
-            yield return new object[] { new SolidBrush(Color.Red), 0, PenType.SolidColor };
-
-            // GDI+ No longer allows negative pen width values (Windows PR6441324)
-            // yield return new object[] { new SolidBrush(Color.Red), -1, PenType.SolidColor };
-            // yield return new object[] { new SolidBrush(Color.Red), float.NegativeInfinity, PenType.SolidColor };
-        }
-
-        yield return new object[] { new SolidBrush(Color.Red), float.PositiveInfinity, PenType.SolidColor };
-        yield return new object[] { new SolidBrush(Color.Red), float.NaN, PenType.SolidColor };
-        yield return new object[] { new SolidBrush(Color.Red), float.MaxValue, PenType.SolidColor };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Brush_Width_TestData))]
-    public void Ctor_Brush_Width<T>(T brush, float width, PenType expectedPenType) where T : Brush
-    {
-        using (brush)
-        using (var pen = new Pen(brush, width))
-        {
-            VerifyPen<T>(pen, expectedPenType, width);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Brush_MakesClone()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            brush.Color = Color.Blue;
-            Assert.Equal(Color.FromArgb(Color.Red.ToArgb()), pen.Color);
-            Assert.Equal(pen.Color, Assert.IsType<SolidBrush>(pen.Brush).Color);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullBrush_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("brush", () => new Pen(null));
-        AssertExtensions.Throws<ArgumentNullException>("brush", () => new Pen(null, 0));
-    }
-
-    [Fact]
-    public void Ctor_DisposedBrush_ThrowsArgumentException()
-    {
-        var brush = new SolidBrush(Color.Red);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Pen(brush));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Pen(brush, 10));
-    }
-
-    [Fact]
-    public void Ctor_Color()
-    {
-        using (var pen = new Pen(Color.Red))
-        {
-            VerifyPen<SolidBrush>(pen, PenType.SolidColor, 1);
-            Assert.Equal(Color.Red, pen.Color);
-        }
-    }
-
-    [Theory]
-    // GDI+ No longer allows negative pen width values (Windows PR6441324)
-    // [InlineData(-1)]
-    // [InlineData(float.NegativeInfinity)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NaN)]
-    public void Ctor_Color_Width(float width)
-    {
-        using (var pen = new Pen(Color.Red, width))
-        {
-            VerifyPen<SolidBrush>(pen, PenType.SolidColor, width);
-            Assert.Equal(Color.Red, pen.Color);
-        }
-    }
-
-    [Theory]
-    [InlineData(PenAlignment.Center)]
-    [InlineData(PenAlignment.Inset)]
-    [InlineData(PenAlignment.Left)]
-    [InlineData(PenAlignment.Outset)]
-    [InlineData(PenAlignment.Right)]
-    public void Alignment_SetValid_GetReturnsExpected(PenAlignment alignment)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.Alignment = alignment;
-            Assert.Equal(alignment, pen.Alignment);
-        }
-    }
-
-    [Theory]
-    [InlineData(PenAlignment.Center - 1)]
-    [InlineData(PenAlignment.Right + 1)]
-    public void Alignment_SetInvalid_ThrowsInvalidEnumArgumentException(PenAlignment alignment)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.Alignment = alignment);
-        }
-    }
-
-    [Fact]
-    public void Alignment_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Alignment);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Alignment = PenAlignment.Center);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Brush_TestData))]
-    public void Brush_SetValid_GetReturnsExpected<T>(T brush, PenType penType) where  T : Brush
-    {
-        using (var pen = new Pen(Color.Red))
-        {
-            pen.Brush = brush;
-            Assert.IsType<T>(pen.Brush);
-            Assert.Equal(penType, pen.PenType);
-        }
-    }
-
-    [Fact]
-    public void Brush_SetCustomBrush_ThrowsArgumentException()
-    {
-        using (var pen = new Pen(Color.Red))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Brush = new SubBrush());
-        }
-    }
-
-    public class SubBrush : Brush
-    {
-        public override object Clone() => this;
-    }
-
-    [Fact]
-    public void Brush_SetNullBrush_ThrowsArgumentNullException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("value", () => pen.Brush = null);
-        }
-    }
-
-    [Fact]
-    public void Brush_SetDisposedBrush_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Brush = brush);
-        }
-    }
-
-    [Fact]
-    public void Brush_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Brush);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Brush = brush);
-        }
-    }
-
-    public static IEnumerable<object[]> Clone_TestData()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            yield return new object[] { new Pen(brush) };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Clone_TestData))]
-    public void Clone_Invoke_ReturnsExpected(Pen pen)
-    {
-        using (pen)
-        {
-            Pen clone = Assert.IsType<Pen>(pen.Clone());
-            Assert.NotSame(pen, clone);
-
-            Assert.Equal(pen.Color, clone.Color);
-            Assert.Equal(((SolidBrush)pen.Brush).Color, ((SolidBrush)clone.Brush).Color);
-            Assert.Equal(pen.DashOffset, clone.DashOffset);
-            Assert.Equal(pen.DashStyle, clone.DashStyle);
-            Assert.Equal(pen.EndCap, clone.EndCap);
-            Assert.Equal(pen.StartCap, clone.StartCap);
-            Assert.Equal(pen.Width, clone.Width);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Clone());
-        }
-    }
-
-    [Fact]
-    public void Color_SolidBrush_ReturnsExpected()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.Equal(Color.FromArgb(Color.Red.ToArgb()), pen.Color);
-        }
-    }
-
-    [Fact]
-    public void Color_HatchBrush_ThrowsArgumentException()
-    {
-        using (var brush = new HatchBrush(HatchStyle.BackwardDiagonal, Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            ValidateInitialPenColorState(pen);
-        }
-    }
-
-    [Fact]
-    public void Color_LinearGradientBrush_ThrowsArgumentException()
-    {
-        using (var brush = new LinearGradientBrush(Point.Empty, new Point(1, 2), Color.Blue, Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            ValidateInitialPenColorState(pen);
-        }
-    }
-
-    private void ValidateInitialPenColorState(Pen pen)
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Color);
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Brush_TestData))]
-    public void Color_Set_GetReturnsExpected(Brush brush, PenType penType)
-    {
-        _ = penType;
-        using (brush)
-        using (var pen = new Pen(brush))
-        {
-            pen.Color = Color.Red;
-            Assert.Equal(Color.Red, pen.Color);
-
-            pen.Color = Color.Red;
-            Assert.Equal(Color.Red, pen.Color);
-        }
-    }
-
-    [Fact]
-    public void Color_GetSetWhenDisposedWithoutBrush_Success()
-    {
-        var pen = new Pen(Color.Red);
-
-        pen.Dispose();
-        Assert.Equal(Color.Red, pen.Color);
-
-        pen.Color = Color.Red;
-        Assert.Equal(Color.Red, pen.Color);
-
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Color = Color.Black);
-    }
-
-    [Fact]
-    public void Color_GetSetWhenDisposedWithBrush_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Color);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Color = Color.Red);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { 0, 0 })]
-    [InlineData(new float[] { 1, 1 })]
-    [InlineData(new float[] { float.NaN, 0 })]
-    public void CompoundArray_SetValidPattern_GetReturnsExpected(float[] compoundArray)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.CompoundArray = compoundArray;
-            Assert.Equal(compoundArray, pen.CompoundArray);
-
-            // CompoundArray should be a clone of the original.
-            compoundArray[0] = 10;
-            Assert.NotEqual(compoundArray, pen.CompoundArray);
-        }
-    }
-
-    [Fact]
-    public void CompoundArray_SetNullPattern_ThrowsNullReferenceException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.Throws<NullReferenceException>(() => pen.CompoundArray = null);
-        }
-    }
-
-    [Fact]
-    public void CompoundArray_SetEmptyPattern_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CompoundArray = new float[0]);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { -1, 0 })]
-    [InlineData(new float[] { float.NegativeInfinity, 0 })]
-    [InlineData(new float[] { float.PositiveInfinity, 0 })]
-    [InlineData(new float[] { float.MaxValue, 0 })]
-    [InlineData(new float[] { 1024, 0 })]
-    [InlineData(new float[] { 2, 2 })]
-    [InlineData(new float[] { 1 })]
-    [InlineData(new float[] { 1, 2, 3 })]
-    public void CompoundArray_SetInvalidPattern_ThrowsArgumentException(float[] compoundArray)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CompoundArray = compoundArray);
-        }
-    }
-
-    [Fact]
-    public void CompoundArray_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CompoundArray);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CompoundArray = new float[] { 1 });
-        }
-    }
-
-    [Fact]
-    public void CustomEndCap_SetValid_GetReturnsExpected()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        using (var lineCap = new CustomLineCap(fillPath, strokePath))
-        {
-            lineCap.BaseInset = 100;
-            pen.CustomEndCap = lineCap;
-            Assert.Equal(100, pen.CustomEndCap.BaseInset);
-
-            // The CustomLineCap should be cloned.
-            lineCap.BaseInset = 10;
-            Assert.Equal(100, pen.CustomEndCap.BaseInset);
-        }
-    }
-
-    [Fact]
-    public void CustomEndCap_SetNull_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap = null);
-        }
-    }
-
-    [Fact]
-    public void CustomEndCap_SetDisposedLineCap_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        {
-            var lineCap = new CustomLineCap(fillPath, strokePath);
-            lineCap.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap = lineCap);
-        }
-    }
-
-    [Fact]
-    public void CustomEndCap_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        using (var lineCap = new CustomLineCap(fillPath, strokePath))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap = lineCap);
-        }
-    }
-
-    [Fact]
-    public void CustomStartCap_SetValid_GetReturnsExpected()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        using (var lineCap = new CustomLineCap(fillPath, strokePath))
-        {
-            lineCap.BaseInset = 100;
-            pen.CustomStartCap = lineCap;
-            Assert.Equal(100, pen.CustomStartCap.BaseInset);
-
-            // The CustomLineCap should be cloned.
-            lineCap.BaseInset = 10;
-            Assert.Equal(100, pen.CustomStartCap.BaseInset);
-        }
-    }
-
-    [Fact]
-    public void CustomStartCap_SetNull_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap = null);
-        }
-    }
-
-    [Fact]
-    public void CustomStartCap_SetDisposedLineCap_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        {
-            var lineCap = new CustomLineCap(fillPath, strokePath);
-            lineCap.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap = lineCap);
-        }
-    }
-
-    [Fact]
-    public void CustomStartCap_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var fillPath = new GraphicsPath())
-        using (var strokePath = new GraphicsPath())
-        using (var lineCap = new CustomLineCap(fillPath, strokePath))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap = lineCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(DashCap.Flat)]
-    [InlineData(DashCap.Round)]
-    [InlineData(DashCap.Triangle)]
-    public void DashCap_SetValid_GetReturnsExpected(DashCap dashCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.DashCap = dashCap;
-            Assert.Equal(dashCap, pen.DashCap);
-        }
-    }
-
-    [Theory]
-    [InlineData(DashCap.Flat - 1)]
-    [InlineData(DashCap.Round - 1)]
-    [InlineData(DashCap.Triangle + 1)]
-    public void DashCap_SetInvalid_ThrowsInvalidEnumArgumentException(DashCap dashCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.DashCap = dashCap);
-        }
-    }
-
-    [Fact]
-    public void DashCap_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashCap = DashCap.Triangle);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(10)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NaN)]
-    public void DashOffset_Set_GetReturnsExpected(float dashOffset)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.DashOffset = dashOffset;
-            Assert.Equal(dashOffset, pen.DashOffset);
-        }
-    }
-
-    [Fact]
-    public void DashOffset_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashOffset);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashOffset = 10);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { 1 })]
-    [InlineData(new float[] { 1, 1 })]
-    [InlineData(new float[] { float.MaxValue, float.NaN, float.PositiveInfinity })]
-    [InlineData(new float[] { float.MaxValue, float.NaN })]
-    public void DashPattern_SetValidPattern_GetReturnsExpected(float[] pattern)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.DashPattern = pattern;
-            Assert.Equal(pattern, pen.DashPattern);
-            Assert.Equal(DashStyle.Custom, pen.DashStyle);
-
-            // DashPattern should be a clone of the original.
-            pattern[0] = 10;
-            Assert.NotEqual(pattern, pen.DashPattern);
-        }
-    }
-
-    [Fact]
-    public void DashPattern_SetNullPattern_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern = null);
-        }
-    }
-
-    [Fact]
-    public void DashPattern_SetEmptyPattern_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern = new float[0]);
-        }
-    }
-
-    [Theory]
-    [InlineData(new float[] { -1 })]
-    [InlineData(new float[] { 0 })]
-    [InlineData(new float[] { 1, -1 })]
-    [InlineData(new float[] { float.NegativeInfinity })]
-    public void DashPattern_SetInvalidPattern_ThrowsArgumentException(float[] pattern)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern = pattern);
-        }
-    }
-
-    [Fact]
-    public void DashPattern_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern = new float[] { 1 });
-        }
-    }
-
-    [Theory]
-    [InlineData(DashStyle.Dash, new float[] { 3, 1 })]
-    [InlineData(DashStyle.DashDot, new float[] { 3, 1, 1, 1 })]
-    [InlineData(DashStyle.DashDotDot, new float[] { 3, 1, 1, 1, 1, 1 })]
-    [InlineData(DashStyle.Dot, new float[] { 1, 1 })]
-    [InlineData(DashStyle.Solid, null)]
-    [InlineData(DashStyle.Custom, new float[] { 1 })]
-    public void DashStyle_SetValid_GetReturnsExpected(DashStyle dashStyle, float[] expectedDashPattern)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.DashStyle = dashStyle;
-            Assert.Equal(dashStyle, pen.DashStyle);
-
-            if (expectedDashPattern == null)
-            {
-                Assert.Throws<OutOfMemoryException>(() => pen.DashPattern);
-            }
-            else
-            {
-                Assert.Equal(expectedDashPattern, pen.DashPattern);
-            }
-        }
-    }
-
-    [Fact]
-    public void DashStyle_SetCustomWithDashCount_DoeNotChangePattern()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.DashStyle = DashStyle.Dash;
-            pen.DashStyle = DashStyle.Custom;
-
-            Assert.Equal(DashStyle.Custom, pen.DashStyle);
-            Assert.Equal(new float[] { 3, 1 }, pen.DashPattern);
-        }
-    }
-
-    [Theory]
-    [InlineData(DashStyle.Solid - 1)]
-    [InlineData(DashStyle.Custom + 1)]
-    public void DashStyle_SetInvalid_ThrowsInvalidEnumArgumentException(DashStyle dashStyle)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.DashStyle = dashStyle);
-        }
-    }
-
-    [Fact]
-    public void DashStyle_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashStyle);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.DashStyle = DashStyle.Dash);
-        }
-    }
-
-    public static IEnumerable<object[]> LineCap_Valid_TestData()
-    {
-        yield return new object[] { LineCap.Flat };
-        yield return new object[] { LineCap.Square };
-        yield return new object[] { LineCap.Round };
-        yield return new object[] { LineCap.Triangle };
-        yield return new object[] { LineCap.NoAnchor };
-        yield return new object[] { LineCap.SquareAnchor };
-        yield return new object[] { LineCap.RoundAnchor };
-        yield return new object[] { LineCap.DiamondAnchor };
-        yield return new object[] { LineCap.ArrowAnchor };
-        yield return new object[] { LineCap.AnchorMask };
-        yield return new object[] { LineCap.Custom };
-    }
-
-    [Theory]
-    [MemberData(nameof(LineCap_Valid_TestData))]
-    public void EndCap_SetValid_GetReturnsExpected(LineCap lineCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.EndCap = lineCap;
-            Assert.Equal(lineCap, pen.EndCap);
-        }
-    }
-
-    public static IEnumerable<object[]> LineCap_Invalid_TestData()
-    {
-        yield return new object[] { LineCap.Flat - 1 };
-        yield return new object[] { LineCap.Triangle + 1 };
-        yield return new object[] { LineCap.ArrowAnchor + 1 };
-        yield return new object[] { LineCap.AnchorMask + 1 };
-        yield return new object[] { LineCap.Custom + 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(LineCap_Invalid_TestData))]
-    public void EndCap_SetInvalid_ThrowsInvalidEnumArgumentException(LineCap lineCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.EndCap = lineCap);
-        }
-    }
-
-    [Fact]
-    public void EndCap_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.EndCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.EndCap = LineCap.ArrowAnchor);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineJoin.Bevel)]
-    [InlineData(LineJoin.Miter)]
-    [InlineData(LineJoin.MiterClipped)]
-    [InlineData(LineJoin.Round)]
-    public void LineJoin_SetValid_GetReturnsExpected(LineJoin lineJoin)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.LineJoin = lineJoin;
-            Assert.Equal(lineJoin, pen.LineJoin);
-        }
-    }
-
-    [Theory]
-    [InlineData(LineJoin.Miter - 1)]
-    [InlineData(LineJoin.MiterClipped + 1)]
-    public void LineJoin_SetInvalid_ThrowsInvalidEnumArgumentException(LineJoin lineJoin)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.LineJoin = lineJoin);
-        }
-    }
-
-    [Fact]
-    public void LineJoin_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.LineJoin);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.LineJoin = LineJoin.Miter);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(10, 10)]
-    [InlineData(float.NegativeInfinity, 1)]
-    [InlineData(float.PositiveInfinity, float.PositiveInfinity)]
-    [InlineData(float.NaN, float.NaN)]
-    public void MiterLimit_Set_GetReturnsExpected(float miterLimit, float expectedMiterLimit)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.MiterLimit = miterLimit;
-            Assert.Equal(expectedMiterLimit, pen.MiterLimit);
-        }
-    }
-
-    [Fact]
-    public void MiterLimit_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MiterLimit);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MiterLimit = 10);
-        }
-    }
-
-    public static IEnumerable<object[]> MultiplyTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), new Matrix(1, 2, 3, 4, 5, 6), MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), new Matrix(1, 2, 3, 4, 5, 6), MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), new Matrix(2, 3, 4, 5, 6, 7), MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), new Matrix(2, 3, 4, 5, 6, 7), MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(MultiplyTransform_TestData))]
-    public void MultiplyTransform_Matrix_SetsTransformToExpected(Matrix originalTransform, Matrix matrix, MatrixOrder matrixOrder)
-    {
-        try
-        {
-            using (var brush = new SolidBrush(Color.Red))
-            using (var pen = new Pen(brush))
-            using (Matrix expected = originalTransform.Clone())
-            {
-                expected.Multiply(matrix, matrixOrder);
-                pen.Transform = originalTransform;
-
-                if (matrixOrder == MatrixOrder.Prepend)
-                {
-                    Pen clone = (Pen)pen.Clone();
-                    clone.MultiplyTransform(matrix);
-                    Assert.Equal(expected, clone.Transform);
-                }
-
-                pen.MultiplyTransform(matrix, matrixOrder);
-                Assert.Equal(expected, pen.Transform);
-            }
-        }
-        finally
-        {
-            originalTransform.Dispose();
-            matrix.Dispose();
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.Throws<ArgumentNullException>(() => pen.MultiplyTransform(null));
-            Assert.Throws<ArgumentNullException>(() => pen.MultiplyTransform(null, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NotInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MultiplyTransform(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_DisposedMatrix_Nop()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            pen.Transform = transform;
-
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            pen.MultiplyTransform(matrix);
-            pen.MultiplyTransform(matrix, MatrixOrder.Append);
-
-            Assert.Equal(transform, pen.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void MultiplyTransform_InvalidOrder_Nop(MatrixOrder matrixOrder)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix())
-        {
-            pen.Transform = transform;
-
-            pen.MultiplyTransform(matrix, matrixOrder);
-            Assert.Equal(transform, pen.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.MultiplyTransform(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Invoke_SetsTransformToZero()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix())
-        {
-            pen.Transform = transform;
-            pen.ResetTransform();
-            Assert.Equal(matrix, pen.Transform);
-
-            pen.ResetTransform();
-            Assert.Equal(matrix, pen.Transform);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.ResetTransform());
-        }
-    }
-    public static IEnumerable<object[]> RotateTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 90, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 90, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 360, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 360, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -45, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -45, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(RotateTransform_TestData))]
-    public void RotateTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float angle, MatrixOrder matrixOrder)
-    {
-        using (originalTransform)
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (Matrix expected = originalTransform.Clone())
-        {
-            expected.Rotate(angle, matrixOrder);
-            pen.Transform = originalTransform;
-
-            if (matrixOrder == MatrixOrder.Prepend)
-            {
-                Pen clone = (Pen)pen.Clone();
-                clone.RotateTransform(angle);
-                Assert.Equal(expected, clone.Transform);
-            }
-
-            pen.RotateTransform(angle, matrixOrder);
-            Assert.Equal(expected, pen.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void RotateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.RotateTransform(10, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.RotateTransform(1));
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.RotateTransform(1, MatrixOrder.Prepend));
-        }
-    }
-
-    public static IEnumerable<object[]> ScaleTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(ScaleTransform_TestData))]
-    public void ScaleTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float scaleX, float scaleY, MatrixOrder matrixOrder)
-    {
-        using (originalTransform)
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (Matrix expected = originalTransform.Clone())
-        {
-            expected.Scale(scaleX, scaleY, matrixOrder);
-            pen.Transform = originalTransform;
-
-            if (matrixOrder == MatrixOrder.Prepend)
-            {
-                Pen clone = (Pen)pen.Clone();
-                clone.ScaleTransform(scaleX, scaleY);
-                Assert.Equal(expected, clone.Transform);
-            }
-
-            pen.ScaleTransform(scaleX, scaleY, matrixOrder);
-            Assert.Equal(expected, pen.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void ScaleTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.ScaleTransform(1, 2, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.ScaleTransform(1, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.ScaleTransform(1, 2, MatrixOrder.Prepend));
-        }
-    }
-
-    [Theory]
-    [InlineData(LineCap.Flat, LineCap.Round, DashCap.Triangle)]
-    [InlineData(LineCap.Flat - 1, LineCap.Flat - 1, DashCap.Flat - 1)]
-    [InlineData((LineCap)int.MaxValue, (LineCap)int.MaxValue, (DashCap)int.MaxValue)]
-    public void SetLineCap_Invoke_Success(LineCap startCap, LineCap endCap, DashCap dashCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            // Make sure that if DashCap is invalid then it is reset to Flat.
-            if (Enum.IsDefined(typeof(DashCap), dashCap))
-            {
-                pen.DashCap = DashCap.Round;
-            }
-
-            pen.SetLineCap(startCap, endCap, dashCap);
-            Assert.Equal(startCap, pen.StartCap);
-            Assert.Equal(endCap, pen.EndCap);
-            Assert.Equal(Enum.IsDefined(typeof(DashCap), dashCap) ? dashCap : DashCap.Flat, pen.DashCap);
-        }
-    }
-
-    [Fact]
-    public void SetLineCap_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.SetLineCap(LineCap.AnchorMask, LineCap.ArrowAnchor, DashCap.Flat));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(LineCap_Valid_TestData))]
-    public void StartCap_SetValid_GetReturnsExpected(LineCap lineCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.StartCap = lineCap;
-            Assert.Equal(lineCap, pen.StartCap);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(LineCap_Invalid_TestData))]
-    public void StartCap_SetInvalid_ThrowsInvalidEnumArgumentException(LineCap lineCap)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => pen.StartCap = lineCap);
-        }
-    }
-
-    [Fact]
-    public void StartCap_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.StartCap);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.StartCap = LineCap.ArrowAnchor);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetValid_GetReturnsExpected()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5,6 ))
-        using (var expected = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            pen.Transform = matrix;
-            Assert.Equal(matrix, pen.Transform);
-
-            // The Matrix should be cloned.
-            matrix.Translate(1, 2);
-            Assert.Equal(expected, pen.Transform);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNull_ThrowsArgumentNullException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("value", () => pen.Transform = null);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNotInvertible_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetDisposedLineCap_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void Transform_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Transform);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Transform = matrix);
-        }
-    }
-
-    public static IEnumerable<object[]> TranslateTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(TranslateTransform_TestData))]
-    public void TranslateTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float dX, float dY, MatrixOrder matrixOrder)
-    {
-        using (originalTransform)
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        using (Matrix expected = originalTransform.Clone())
-        {
-            expected.Translate(dX, dY, matrixOrder);
-            pen.Transform = originalTransform;
-
-            if (matrixOrder == MatrixOrder.Prepend)
-            {
-                Pen clone = (Pen)pen.Clone();
-                clone.TranslateTransform(dX, dY);
-                Assert.Equal(expected, clone.Transform);
-            }
-
-            pen.TranslateTransform(dX, dY, matrixOrder);
-            Assert.Equal(expected, pen.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void TranslateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.TranslateTransform(1, 2, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var matrix = new Matrix())
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.TranslateTransform(1, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.TranslateTransform(1, 2, MatrixOrder.Prepend));
-        }
-    }
-
-    [Theory]
-    [InlineData(-10)]
-    [InlineData(0)]
-    [InlineData(10)]
-    [InlineData(float.NegativeInfinity)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NaN)]
-    public void Width_Set_GetReturnsExpected(float value)
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        using (var pen = new Pen(brush))
-        {
-            pen.Width = value;
-            Assert.Equal(value, pen.Width);
-        }
-    }
-
-    [Fact]
-    public void Width_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var brush = new SolidBrush(Color.Red))
-        {
-            var pen = new Pen(brush);
-            pen.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Width);
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Width = 10);
-        }
-    }
-
-    private void VerifyPen<T>(Pen pen, PenType expectedPenType, float expectedWidth) where T : Brush
-    {
-        Assert.Equal(PenAlignment.Center, pen.Alignment);
-
-        Assert.IsType<T>(pen.Brush);
-
-        Assert.Empty(pen.CompoundArray);
-
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap);
-
-        Assert.Equal(DashCap.Flat, pen.DashCap);
-        Assert.Equal(0, pen.DashOffset);
-
-        Assert.Throws<OutOfMemoryException>(() => pen.DashPattern);
-
-        Assert.Equal(DashStyle.Solid, pen.DashStyle);
-        Assert.Equal(LineCap.Flat, pen.EndCap);
-        Assert.Equal(LineJoin.Miter, pen.LineJoin);
-        Assert.Equal(10, pen.MiterLimit);
-        Assert.Equal(expectedPenType, pen.PenType);
-        Assert.Equal(LineCap.Flat, pen.StartCap);
-
-        using (var matrix = new Matrix())
-        {
-            Assert.Equal(new Matrix(), pen.Transform);
-        }
-        Assert.Equal(expectedWidth, pen.Width);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/PensTests.cs b/src/System.Drawing.Common/tests/PensTests.cs
deleted file mode 100644
index 4ba1f4a094c..00000000000
--- a/src/System.Drawing.Common/tests/PensTests.cs
+++ /dev/null
@@ -1,168 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-
-namespace System.Drawing.Tests;
-
-public class PensTests
-{
-    public static IEnumerable<object[]> Pens_TestData()
-    {
-        yield return Pen(() => Pens.AliceBlue, Color.AliceBlue);
-        yield return Pen(() => Pens.AntiqueWhite, Color.AntiqueWhite);
-        yield return Pen(() => Pens.Aqua, Color.Aqua);
-        yield return Pen(() => Pens.Aquamarine, Color.Aquamarine);
-        yield return Pen(() => Pens.Azure, Color.Azure);
-        yield return Pen(() => Pens.Beige, Color.Beige);
-        yield return Pen(() => Pens.Bisque, Color.Bisque);
-        yield return Pen(() => Pens.Black, Color.Black);
-        yield return Pen(() => Pens.BlanchedAlmond, Color.BlanchedAlmond);
-        yield return Pen(() => Pens.Blue, Color.Blue);
-        yield return Pen(() => Pens.BlueViolet, Color.BlueViolet);
-        yield return Pen(() => Pens.Brown, Color.Brown);
-        yield return Pen(() => Pens.BurlyWood, Color.BurlyWood);
-        yield return Pen(() => Pens.CadetBlue, Color.CadetBlue);
-        yield return Pen(() => Pens.Chartreuse, Color.Chartreuse);
-        yield return Pen(() => Pens.Chocolate, Color.Chocolate);
-        yield return Pen(() => Pens.Coral, Color.Coral);
-        yield return Pen(() => Pens.CornflowerBlue, Color.CornflowerBlue);
-        yield return Pen(() => Pens.Cornsilk, Color.Cornsilk);
-        yield return Pen(() => Pens.Crimson, Color.Crimson);
-        yield return Pen(() => Pens.Cyan, Color.Cyan);
-        yield return Pen(() => Pens.DarkBlue, Color.DarkBlue);
-        yield return Pen(() => Pens.DarkCyan, Color.DarkCyan);
-        yield return Pen(() => Pens.DarkGoldenrod, Color.DarkGoldenrod);
-        yield return Pen(() => Pens.DarkGray, Color.DarkGray);
-        yield return Pen(() => Pens.DarkGreen, Color.DarkGreen);
-        yield return Pen(() => Pens.DarkKhaki, Color.DarkKhaki);
-        yield return Pen(() => Pens.DarkMagenta, Color.DarkMagenta);
-        yield return Pen(() => Pens.DarkOliveGreen, Color.DarkOliveGreen);
-        yield return Pen(() => Pens.DarkOrange, Color.DarkOrange);
-        yield return Pen(() => Pens.DarkOrchid, Color.DarkOrchid);
-        yield return Pen(() => Pens.DarkRed, Color.DarkRed);
-        yield return Pen(() => Pens.DarkSalmon, Color.DarkSalmon);
-        yield return Pen(() => Pens.DarkSeaGreen, Color.DarkSeaGreen);
-        yield return Pen(() => Pens.DarkSlateBlue, Color.DarkSlateBlue);
-        yield return Pen(() => Pens.DarkSlateGray, Color.DarkSlateGray);
-        yield return Pen(() => Pens.DarkTurquoise, Color.DarkTurquoise);
-        yield return Pen(() => Pens.DarkViolet, Color.DarkViolet);
-        yield return Pen(() => Pens.DeepPink, Color.DeepPink);
-        yield return Pen(() => Pens.DeepSkyBlue, Color.DeepSkyBlue);
-        yield return Pen(() => Pens.DimGray, Color.DimGray);
-        yield return Pen(() => Pens.DodgerBlue, Color.DodgerBlue);
-        yield return Pen(() => Pens.Firebrick, Color.Firebrick);
-        yield return Pen(() => Pens.FloralWhite, Color.FloralWhite);
-        yield return Pen(() => Pens.ForestGreen, Color.ForestGreen);
-        yield return Pen(() => Pens.Fuchsia, Color.Fuchsia);
-        yield return Pen(() => Pens.Gainsboro, Color.Gainsboro);
-        yield return Pen(() => Pens.GhostWhite, Color.GhostWhite);
-        yield return Pen(() => Pens.Gold, Color.Gold);
-        yield return Pen(() => Pens.Goldenrod, Color.Goldenrod);
-        yield return Pen(() => Pens.Gray, Color.Gray);
-        yield return Pen(() => Pens.Green, Color.Green);
-        yield return Pen(() => Pens.GreenYellow, Color.GreenYellow);
-        yield return Pen(() => Pens.Honeydew, Color.Honeydew);
-        yield return Pen(() => Pens.HotPink, Color.HotPink);
-        yield return Pen(() => Pens.IndianRed, Color.IndianRed);
-        yield return Pen(() => Pens.Indigo, Color.Indigo);
-        yield return Pen(() => Pens.Ivory, Color.Ivory);
-        yield return Pen(() => Pens.Khaki, Color.Khaki);
-        yield return Pen(() => Pens.Lavender, Color.Lavender);
-        yield return Pen(() => Pens.LavenderBlush, Color.LavenderBlush);
-        yield return Pen(() => Pens.LawnGreen, Color.LawnGreen);
-        yield return Pen(() => Pens.LemonChiffon, Color.LemonChiffon);
-        yield return Pen(() => Pens.LightBlue, Color.LightBlue);
-        yield return Pen(() => Pens.LightCoral, Color.LightCoral);
-        yield return Pen(() => Pens.LightCyan, Color.LightCyan);
-        yield return Pen(() => Pens.LightGoldenrodYellow, Color.LightGoldenrodYellow);
-        yield return Pen(() => Pens.LightGray, Color.LightGray);
-        yield return Pen(() => Pens.LightGreen, Color.LightGreen);
-        yield return Pen(() => Pens.LightPink, Color.LightPink);
-        yield return Pen(() => Pens.LightSalmon, Color.LightSalmon);
-        yield return Pen(() => Pens.LightSeaGreen, Color.LightSeaGreen);
-        yield return Pen(() => Pens.LightSkyBlue, Color.LightSkyBlue);
-        yield return Pen(() => Pens.LightSlateGray, Color.LightSlateGray);
-        yield return Pen(() => Pens.LightSteelBlue, Color.LightSteelBlue);
-        yield return Pen(() => Pens.LightYellow, Color.LightYellow);
-        yield return Pen(() => Pens.Lime, Color.Lime);
-        yield return Pen(() => Pens.LimeGreen, Color.LimeGreen);
-        yield return Pen(() => Pens.Linen, Color.Linen);
-        yield return Pen(() => Pens.Magenta, Color.Magenta);
-        yield return Pen(() => Pens.Maroon, Color.Maroon);
-        yield return Pen(() => Pens.MediumAquamarine, Color.MediumAquamarine);
-        yield return Pen(() => Pens.MediumBlue, Color.MediumBlue);
-        yield return Pen(() => Pens.MediumOrchid, Color.MediumOrchid);
-        yield return Pen(() => Pens.MediumPurple, Color.MediumPurple);
-        yield return Pen(() => Pens.MediumSeaGreen, Color.MediumSeaGreen);
-        yield return Pen(() => Pens.MediumSlateBlue, Color.MediumSlateBlue);
-        yield return Pen(() => Pens.MediumSpringGreen, Color.MediumSpringGreen);
-        yield return Pen(() => Pens.MediumTurquoise, Color.MediumTurquoise);
-        yield return Pen(() => Pens.MediumVioletRed, Color.MediumVioletRed);
-        yield return Pen(() => Pens.MidnightBlue, Color.MidnightBlue);
-        yield return Pen(() => Pens.MintCream, Color.MintCream);
-        yield return Pen(() => Pens.MistyRose, Color.MistyRose);
-        yield return Pen(() => Pens.Moccasin, Color.Moccasin);
-        yield return Pen(() => Pens.NavajoWhite, Color.NavajoWhite);
-        yield return Pen(() => Pens.Navy, Color.Navy);
-        yield return Pen(() => Pens.OldLace, Color.OldLace);
-        yield return Pen(() => Pens.Olive, Color.Olive);
-        yield return Pen(() => Pens.OliveDrab, Color.OliveDrab);
-        yield return Pen(() => Pens.Orange, Color.Orange);
-        yield return Pen(() => Pens.OrangeRed, Color.OrangeRed);
-        yield return Pen(() => Pens.Orchid, Color.Orchid);
-        yield return Pen(() => Pens.PaleGoldenrod, Color.PaleGoldenrod);
-        yield return Pen(() => Pens.PaleGreen, Color.PaleGreen);
-        yield return Pen(() => Pens.PaleTurquoise, Color.PaleTurquoise);
-        yield return Pen(() => Pens.PaleVioletRed, Color.PaleVioletRed);
-        yield return Pen(() => Pens.PapayaWhip, Color.PapayaWhip);
-        yield return Pen(() => Pens.PeachPuff, Color.PeachPuff);
-        yield return Pen(() => Pens.Peru, Color.Peru);
-        yield return Pen(() => Pens.Pink, Color.Pink);
-        yield return Pen(() => Pens.Plum, Color.Plum);
-        yield return Pen(() => Pens.PowderBlue, Color.PowderBlue);
-        yield return Pen(() => Pens.Purple, Color.Purple);
-        yield return Pen(() => Pens.Red, Color.Red);
-        yield return Pen(() => Pens.RosyBrown, Color.RosyBrown);
-        yield return Pen(() => Pens.RoyalBlue, Color.RoyalBlue);
-        yield return Pen(() => Pens.SaddleBrown, Color.SaddleBrown);
-        yield return Pen(() => Pens.Salmon, Color.Salmon);
-        yield return Pen(() => Pens.SandyBrown, Color.SandyBrown);
-        yield return Pen(() => Pens.SeaGreen, Color.SeaGreen);
-        yield return Pen(() => Pens.SeaShell, Color.SeaShell);
-        yield return Pen(() => Pens.Sienna, Color.Sienna);
-        yield return Pen(() => Pens.Silver, Color.Silver);
-        yield return Pen(() => Pens.SkyBlue, Color.SkyBlue);
-        yield return Pen(() => Pens.SlateBlue, Color.SlateBlue);
-        yield return Pen(() => Pens.SlateGray, Color.SlateGray);
-        yield return Pen(() => Pens.Snow, Color.Snow);
-        yield return Pen(() => Pens.SpringGreen, Color.SpringGreen);
-        yield return Pen(() => Pens.SteelBlue, Color.SteelBlue);
-        yield return Pen(() => Pens.Tan, Color.Tan);
-        yield return Pen(() => Pens.Teal, Color.Teal);
-        yield return Pen(() => Pens.Thistle, Color.Thistle);
-        yield return Pen(() => Pens.Tomato, Color.Tomato);
-        yield return Pen(() => Pens.Transparent, Color.Transparent);
-        yield return Pen(() => Pens.Turquoise, Color.Turquoise);
-        yield return Pen(() => Pens.Violet, Color.Violet);
-        yield return Pen(() => Pens.Wheat, Color.Wheat);
-        yield return Pen(() => Pens.White, Color.White);
-        yield return Pen(() => Pens.WhiteSmoke, Color.WhiteSmoke);
-        yield return Pen(() => Pens.Yellow, Color.Yellow);
-        yield return Pen(() => Pens.YellowGreen, Color.YellowGreen);
-    }
-
-    public static object[] Pen(Func<Pen> getPen, Color expectedColor) => new object[] { getPen, expectedColor };
-
-    [Theory]
-    [MemberData(nameof(Pens_TestData))]
-    public void Pens_Get_ReturnsExpected(Func<Pen> getPen, Color expectedColor)
-    {
-        Pen pen = getPen();
-        Assert.Equal(expectedColor, pen.Color);
-        Assert.Equal(PenType.SolidColor, pen.PenType);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Color = Color.AliceBlue);
-
-        Assert.Same(pen, getPen());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/MarginsTests.cs b/src/System.Drawing.Common/tests/Printing/MarginsTests.cs
deleted file mode 100644
index 2847548673b..00000000000
--- a/src/System.Drawing.Common/tests/Printing/MarginsTests.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Authors:
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-namespace System.Drawing.Printing.Tests;
-
-public class MarginsTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var margins = new Margins();
-        Assert.Equal(100, margins.Left);
-        Assert.Equal(100, margins.Top);
-        Assert.Equal(100, margins.Right);
-        Assert.Equal(100, margins.Bottom);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue, int.MaxValue, int.MaxValue, int.MaxValue)]
-    [InlineData(0, 1, 2, 3)]
-    [InlineData(0, 0, 0, 0)]
-    public void Ctor_Bounds(int left, int right, int top, int bottom)
-    {
-        var margins = new Margins(left, right, top, bottom);
-        Assert.Equal(left, margins.Left);
-        Assert.Equal(right, margins.Right);
-        Assert.Equal(top, margins.Top);
-        Assert.Equal(bottom, margins.Bottom);
-    }
-
-    [Fact]
-    public void Ctor_NegativeLeft_ThrowsArgumentOutOfRangeException()
-    {
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("left", null, () => new Margins(-1, 2, 3, 4));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRight_ThrowsArgumentOutOfRangeException()
-    {
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("right", null, () => new Margins(1, -1, 3, 4));
-    }
-
-    [Fact]
-    public void Ctor_NegativeTop_ThrowsArgumentOutOfRangeException()
-    {
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("top", null, () => new Margins(1, 2, -1, 4));
-    }
-
-    [Fact]
-    public void Ctor_NegativeBottom_ThrowsArgumentOutOfRangeException()
-    {
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("bottom", null, () => new Margins(1, 2, 3, -1));
-    }
-
-    public static IEnumerable<object[]> Equals_Object_TestData()
-    {
-        var margins = new Margins(1, 2, 3, 4);
-        yield return new object[] { margins, margins, true };
-        yield return new object[] { margins, new Margins(1, 2, 3, 4), true };
-        yield return new object[] { margins, new Margins(2, 2, 3, 4), false };
-        yield return new object[] { margins, new Margins(1, 3, 3, 4), false };
-        yield return new object[] { margins, new Margins(1, 2, 4, 4), false };
-        yield return new object[] { margins, new Margins(1, 2, 3, 5), false };
-
-        yield return new object[] { margins, new object(), false };
-        yield return new object[] { margins, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Object_TestData))]
-    public void Equals_InvokeObject_ReturnsExpected(Margins margins, object obj, bool expected)
-    {
-        Assert.Equal(expected, margins.Equals(obj));
-        if (obj is Margins)
-        {
-            Assert.Equal(expected, margins.GetHashCode().Equals(obj.GetHashCode()));
-        }
-    }
-
-    public static IEnumerable<object[]> Equals_Margin_TestData()
-    {
-        var margins = new Margins(1, 2, 3, 4);
-        yield return new object[] { margins, margins, true };
-        yield return new object[] { margins, new Margins(1, 2, 3, 4), true };
-        yield return new object[] { margins, new Margins(2, 2, 3, 4), false };
-        yield return new object[] { margins, new Margins(1, 3, 3, 4), false };
-        yield return new object[] { margins, new Margins(1, 2, 4, 4), false };
-        yield return new object[] { margins, new Margins(1, 2, 3, 5), false };
-
-        yield return new object[] { null, null, true };
-        yield return new object[] { null, new Margins(1, 2, 3, 4), false };
-        yield return new object[] { new Margins(1, 2, 3, 4), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Margin_TestData))]
-    public void Equals_InvokeMargin_ReturnsExpected(Margins margins1, Margins margins2, bool expected)
-    {
-        Assert.Equal(expected, margins1 == margins2);
-        Assert.Equal(!expected, margins1 != margins2);
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new Margins(), "[Margins Left=100 Right=100 Top=100 Bottom=100]" };
-        yield return new object[] { new Margins(1, 2, 3, 4), "[Margins Left=1 Right=2 Top=3 Bottom=4]" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void ToString_Invoke_ReturnsExpected(Margins margins, string expected)
-    {
-        Assert.Equal(expected, margins.ToString());
-    }
-
-    [Fact]
-    public void Clone_Invoke_ReturnsExpected()
-    {
-        var margins = new Margins(1, 2, 3, 4);
-        Margins clonedMargins = Assert.IsType<Margins>(margins.Clone());
-        Assert.NotSame(margins, clonedMargins);
-        Assert.Equal(1, clonedMargins.Left);
-        Assert.Equal(2, clonedMargins.Right);
-        Assert.Equal(3, clonedMargins.Top);
-        Assert.Equal(4, clonedMargins.Bottom);
-    }
-
-    public static IEnumerable<object[]> Bounds_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 10 };
-        yield return new object[] { int.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(Bounds_Set_TestData))]
-    public void Left_Set_GetReturnsExpected(int value)
-    {
-        var margins = new Margins
-        {
-            Left = value
-        };
-        Assert.Equal(value, margins.Left);
-
-        // Set same.
-        margins.Left = value;
-        Assert.Equal(value, margins.Left);
-    }
-
-    [Fact]
-    public void Left_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var margins = new Margins();
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("value", null, () => margins.Left = -1);
-    }
-
-    [Theory]
-    [MemberData(nameof(Bounds_Set_TestData))]
-    public void Right_Set_GetReturnsExpected(int value)
-    {
-        var margins = new Margins
-        {
-            Right = value
-        };
-        Assert.Equal(value, margins.Right);
-
-        // Set same.
-        margins.Right = value;
-        Assert.Equal(value, margins.Right);
-    }
-
-    [Fact]
-    public void Right_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var margins = new Margins();
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("value", null, () => margins.Right = -1);
-    }
-
-    [Theory]
-    [MemberData(nameof(Bounds_Set_TestData))]
-    public void Top_Set_GetReturnsExpected(int value)
-    {
-        var margins = new Margins
-        {
-            Top = value
-        };
-        Assert.Equal(value, margins.Top);
-
-        // Set same.
-        margins.Top = value;
-        Assert.Equal(value, margins.Top);
-    }
-
-    [Fact]
-    public void Top_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var margins = new Margins();
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("value", null, () => margins.Top = -1);
-    }
-
-    [Theory]
-    [MemberData(nameof(Bounds_Set_TestData))]
-    public void Bottom_Set_GetReturnsExpected(int value)
-    {
-        var margins = new Margins
-        {
-            Bottom = value
-        };
-        Assert.Equal(value, margins.Bottom);
-
-        // Set same.
-        margins.Bottom = value;
-        Assert.Equal(value, margins.Bottom);
-    }
-
-    [Fact]
-    public void Bottom_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var margins = new Margins();
-        AssertExtensions.Throws<ArgumentOutOfRangeException, ArgumentException>("value", null, () => margins.Bottom = -1);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PageSettingsTests.cs b/src/System.Drawing.Common/tests/Printing/PageSettingsTests.cs
deleted file mode 100644
index 6020b8f96dd..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PageSettingsTests.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// Author:
-//
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//
-
-namespace System.Drawing.Printing.Tests;
-
-public class PageSettingsTests
-{
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void Clone_Success()
-    {
-        PageSettings ps = new PageSettings();
-        ps.Color = false;
-        ps.Landscape = true;
-        ps.Margins = new Margins(120, 130, 140, 150);
-        ps.PaperSize = new PaperSize("My Custom Size", 222, 333);
-        PageSettings clone = (PageSettings)ps.Clone();
-
-        Assert.Equal(ps.Color, clone.Color);
-        Assert.Equal(ps.Landscape, clone.Landscape);
-        Assert.Equal(ps.Margins, clone.Margins);
-        Assert.Same(ps.PrinterSettings, clone.PrinterSettings);
-
-        // PaperSize
-        Assert.Equal(ps.PaperSize.PaperName, clone.PaperSize.PaperName);
-        Assert.Equal(ps.PaperSize.Width, clone.PaperSize.Width);
-        Assert.Equal(ps.PaperSize.Height, clone.PaperSize.Height);
-        Assert.Equal(ps.PaperSize.Kind, clone.PaperSize.Kind);
-
-        // PrinterResolution
-        Assert.Equal(ps.PrinterResolution.X, clone.PrinterResolution.X);
-        Assert.Equal(ps.PrinterResolution.Y, clone.PrinterResolution.Y);
-        Assert.Equal(ps.PrinterResolution.Kind, clone.PrinterResolution.Kind);
-
-        // PaperSource
-        Assert.Equal(ps.PaperSource.Kind, clone.PaperSource.Kind);
-        Assert.Equal(ps.PaperSource.SourceName, clone.PaperSource.SourceName);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PaperSizeTests.cs b/src/System.Drawing.Common/tests/Printing/PaperSizeTests.cs
deleted file mode 100644
index 68b7a97cda9..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PaperSizeTests.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-// Copyright (C) 2009 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// Author:
-//  Andy Hume <andyhume32@yahoo.co.uk>
-//
-
-namespace System.Drawing.Printing.Tests;
-
-public class PaperSizeTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var size = new PaperSize();
-        Assert.Equal(PaperKind.Custom, size.Kind);
-        Assert.Equal(0, size.Height);
-        Assert.Empty(size.PaperName);
-        Assert.Equal(0, size.RawKind);
-        Assert.Equal(0, size.Width);
-    }
-
-    [Theory]
-    [InlineData(null, -1, -2)]
-    [InlineData("", 0, 0)]
-    [InlineData("name", 100, 200)]
-    public void Ctor_String_Int_Int(string name, int width, int height)
-    {
-        var size = new PaperSize(name, width, height);
-        Assert.Equal(PaperKind.Custom, size.Kind);
-        Assert.Equal(height, size.Height);
-        Assert.Equal(name, size.PaperName);
-        Assert.Equal(0, size.RawKind);
-        Assert.Equal(width, size.Width);
-    }
-
-    public static IEnumerable<object[]> RawKind_TestData()
-    {
-        yield return new object[] { (int)PaperKind.A4 };
-        yield return new object[] { (int)PaperKind.JapaneseEnvelopeKakuNumber3 };
-        yield return new object[] { (int)PaperKind.Custom };
-        yield return new object[] { 999999 };
-        yield return new object[] { int.MaxValue };
-        yield return new object[] { -1 };
-        yield return new object[] { int.MinValue };
-        yield return new object[] { 2 };
-        yield return new object[] { 1 + (int)PaperKind.PrcEnvelopeNumber10Rotated };
-    }
-
-    public static IEnumerable<object[]> Height_Set_TestData()
-    {
-        foreach (object[] testData in RawKind_TestData())
-        {
-            yield return new object[] { testData[0], -1 };
-            yield return new object[] { testData[0], 0 };
-            yield return new object[] { testData[0], 100 };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Height_Set_TestData))]
-    public void Height_Set_GetReturnsExpected(int rawKind, int value)
-    {
-        var size = new PaperSize
-        {
-            RawKind = rawKind,
-            Height = value
-        };
-        Assert.Equal(value, size.Height);
-
-        // Set same.
-        size.Height = value;
-        Assert.Equal(value, size.Height);
-    }
-
-    public static IEnumerable<object[]> NonCustomRawKind_TestData()
-    {
-        yield return new object[] { (int)PaperKind.A4 };
-        yield return new object[] { (int)PaperKind.JapaneseEnvelopeKakuNumber3 };
-        yield return new object[] { 999999 };
-        yield return new object[] { int.MaxValue };
-        yield return new object[] { -1 };
-        yield return new object[] { int.MinValue };
-        yield return new object[] { 1 + (int)PaperKind.PrcEnvelopeNumber10Rotated };
-    }
-
-    [Theory]
-    [MemberData(nameof(NonCustomRawKind_TestData))]
-    public void Height_SetNonCustomKindConstructor_ThrowsArgumentException(int rawKind)
-    {
-        var size = new PaperSize("name", 100, 200)
-        {
-            RawKind = rawKind
-        };
-        AssertExtensions.Throws<ArgumentException>("value", null, () => size.Height = 1);
-    }
-
-    public static IEnumerable<object[]> PaperName_Set_TestData()
-    {
-        foreach (object[] testData in RawKind_TestData())
-        {
-            yield return new object[] { testData[0], null };
-            yield return new object[] { testData[0], string.Empty };
-            yield return new object[] { testData[0], "name" };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(PaperName_Set_TestData))]
-    public void PaperName_Set_GetReturnsExpected(int rawKind, string value)
-    {
-        var size = new PaperSize
-        {
-            RawKind = rawKind,
-            PaperName = value
-        };
-        Assert.Equal(value, size.PaperName);
-
-        // Set same.
-        size.PaperName = value;
-        Assert.Equal(value, size.PaperName);
-    }
-
-    [Theory]
-    [MemberData(nameof(NonCustomRawKind_TestData))]
-    public void PaperName_SetNonCustomKindConstructor_ThrowsArgumentException(int rawKind)
-    {
-        var size = new PaperSize("name", 100, 200)
-        {
-            RawKind = rawKind
-        };
-        AssertExtensions.Throws<ArgumentException>("value", null, () => size.PaperName = "name");
-    }
-
-    [Theory]
-    [InlineData((int)PaperKind.Custom, PaperKind.Custom)]
-    [InlineData((int)PaperKind.A4, PaperKind.A4)]
-    [InlineData((int)PaperKind.JapaneseEnvelopeKakuNumber3, PaperKind.JapaneseEnvelopeKakuNumber3)]
-    [InlineData(999999, PaperKind.Custom)]
-    [InlineData(int.MaxValue, PaperKind.Custom)]
-    [InlineData(1 + (int)PaperKind.PrcEnvelopeNumber10Rotated, PaperKind.Custom)]
-    [InlineData(-1, (PaperKind)(-1))]
-    [InlineData(int.MinValue, (PaperKind)int.MinValue)]
-    public void RawKind_Set_GetReturnsExpected(int value, PaperKind expectedKind)
-    {
-        var size = new PaperSize
-        {
-            RawKind = value
-        };
-        Assert.Equal(value, size.RawKind);
-        Assert.Equal(expectedKind, size.Kind);
-
-        // Set same.
-        size.RawKind = value;
-        Assert.Equal(value, size.RawKind);
-        Assert.Equal(expectedKind, size.Kind);
-    }
-
-    public static IEnumerable<object[]> Width_Set_TestData()
-    {
-        foreach (object[] testData in RawKind_TestData())
-        {
-            yield return new object[] { testData[0], -1 };
-            yield return new object[] { testData[0], 0 };
-            yield return new object[] { testData[0], 100 };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Width_Set_TestData))]
-    public void Width_Set_GetReturnsExpected(int rawKind, int value)
-    {
-        var size = new PaperSize
-        {
-            RawKind = rawKind,
-            Width = value
-        };
-        Assert.Equal(value, size.Width);
-
-        // Set same.
-        size.Width = value;
-        Assert.Equal(value, size.Width);
-    }
-
-    [Theory]
-    [MemberData(nameof(NonCustomRawKind_TestData))]
-    public void Width_SetNonCustomKindConstructor_ThrowsArgumentException(int rawKind)
-    {
-        var size = new PaperSize("name", 100, 200)
-        {
-            RawKind = rawKind
-        };
-        AssertExtensions.Throws<ArgumentException>("value", null, () => size.Width = 1);
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new PaperSize(), "[PaperSize  Kind=Custom Height=0 Width=0]" };
-        yield return new object[] { new PaperSize("name", 1, 2), "[PaperSize name Kind=Custom Height=2 Width=1]" };
-        yield return new object[] { new PaperSize("name", -1, -2), "[PaperSize name Kind=Custom Height=-2 Width=-1]" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void ToString_Invoke_ReturnsExpected(PaperSize size, string expected)
-    {
-        Assert.Equal(expected, size.ToString());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PaperSourceTests.cs b/src/System.Drawing.Common/tests/Printing/PaperSourceTests.cs
deleted file mode 100644
index f0a84bcb425..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PaperSourceTests.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2009 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// Author:
-//  Andy Hume <andyhume32@yahoo.co.uk>
-//
-
-namespace System.Drawing.Printing.Tests;
-
-public class PaperSourceTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var source = new PaperSource();
-        Assert.Equal(PaperSourceKind.Custom, source.Kind);
-        Assert.Equal((int)PaperSourceKind.Custom, source.RawKind);
-        Assert.Empty(source.SourceName);
-    }
-
-    [Theory]
-    [InlineData((int)PaperSourceKind.Custom, PaperSourceKind.Custom)]
-    [InlineData((int)PaperSourceKind.Upper, PaperSourceKind.Upper)]
-    [InlineData((int)PaperSourceKind.TractorFeed, PaperSourceKind.TractorFeed)]
-    [InlineData((int)PaperSourceKind.SmallFormat, PaperSourceKind.SmallFormat)]
-    [InlineData((int)PaperSourceKind.Middle, PaperSourceKind.Middle)]
-    [InlineData((int)PaperSourceKind.ManualFeed, PaperSourceKind.ManualFeed)]
-    [InlineData((int)PaperSourceKind.Manual, PaperSourceKind.Manual)]
-    [InlineData((int)PaperSourceKind.Lower, PaperSourceKind.Lower)]
-    [InlineData((int)PaperSourceKind.LargeFormat, PaperSourceKind.LargeFormat)]
-    [InlineData((int)PaperSourceKind.LargeCapacity, PaperSourceKind.LargeCapacity)]
-    [InlineData((int)PaperSourceKind.FormSource, PaperSourceKind.FormSource)]
-    [InlineData((int)PaperSourceKind.Envelope, PaperSourceKind.Envelope)]
-    [InlineData((int)PaperSourceKind.Cassette, PaperSourceKind.Cassette)]
-    [InlineData((int)PaperSourceKind.AutomaticFeed, PaperSourceKind.AutomaticFeed)]
-    [InlineData(int.MaxValue, PaperSourceKind.Custom)]
-    [InlineData(int.MinValue, (PaperSourceKind)int.MinValue)]
-    [InlineData(0, (PaperSourceKind)0)]
-    [InlineData(256, PaperSourceKind.Custom)]
-    public void RawKind_Set_GetReturnsExpected(int value, PaperSourceKind expectedKind)
-    {
-        var source = new PaperSource
-        {
-            RawKind = value
-        };
-        Assert.Equal(value, source.RawKind);
-        Assert.Equal(expectedKind, source.Kind);
-
-        // Set same.
-        source.RawKind = value;
-        Assert.Equal(value, source.RawKind);
-        Assert.Equal(expectedKind, source.Kind);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("sourceName")]
-    public void SourceName_Set_GetReturnsExpected(string value)
-    {
-        var source = new PaperSource
-        {
-            SourceName = value
-        };
-        Assert.Equal(value, source.SourceName);
-
-        // Set same.
-        source.SourceName = value;
-        Assert.Equal(value, source.SourceName);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PreviewPrintControllerTests.cs b/src/System.Drawing.Common/tests/Printing/PreviewPrintControllerTests.cs
deleted file mode 100644
index 2aef7a3b73d..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PreviewPrintControllerTests.cs
+++ /dev/null
@@ -1,139 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Printing.Tests;
-
-public class PreviewPrintControllerTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var controller = new PreviewPrintController();
-        Assert.True(controller.IsPreview);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void OnStartPage_InvokeWithPrint_ReturnsNull()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnStartPrint(document, new PrintEventArgs());
-
-            var printEventArgs = new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, new PageSettings());
-            Assert.NotNull(controller.OnStartPage(document, printEventArgs));
-
-            // Call OnEndPage.
-            controller.OnEndPage(document, printEventArgs);
-
-            // Call EndPrint.
-            controller.OnEndPrint(document, new PrintEventArgs());
-        }
-    }
-
-    [Fact]
-    public void OnStartPage_InvokeNullDocument_ThrowsNullReferenceException()
-    {
-        var controller = new PreviewPrintController();
-        var e = new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null);
-        Assert.Throws<NullReferenceException>(() => controller.OnStartPage(null, e));
-    }
-
-    [Fact]
-    public void OnStartPage_InvokeNullEventArgs_ThrowsNullReferenceException()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, null));
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void OnStartPage_InvokeNullEventArgsPageSettings_ReturnsNull()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnStartPrint(document, new PrintEventArgs());
-
-            var printEventArgs = new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null);
-            Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, printEventArgs));
-        }
-    }
-
-    [Fact]
-    public void OnStartPage_PrintNotStarted_ThrowsNullReferenceException()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            var e = new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null);
-            Assert.Throws<NullReferenceException>(() => controller.OnStartPage(document, e));
-        }
-    }
-
-    [Fact]
-    public void OnEndPage_InvokeWithoutStarting_Nop()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnEndPage(document, new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null));
-            controller.OnEndPage(null, null);
-        }
-    }
-
-    public static IEnumerable<object[]> PrintEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new PrintEventArgs() };
-    }
-
-    [ConditionalTheory(Helpers.AnyInstalledPrinters)]
-    [MemberData(nameof(PrintEventArgs_TestData))]
-    public void OnStartPrint_InvokeWithDocument_Success(PrintEventArgs e)
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnStartPrint(document, e);
-
-            // Call OnEndPrint
-            controller.OnEndPrint(document, e);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void OnStartPrint_InvokeMultipleTimes_Success()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnStartPrint(document, new PrintEventArgs());
-            controller.OnStartPrint(document, new PrintEventArgs());
-
-            // Call OnEndPrint
-            controller.OnEndPrint(document, new PrintEventArgs());
-        }
-    }
-
-    [Fact]
-    public void OnStartPrint_InvokeNullDocument_ThrowsNullReferenceException()
-    {
-        var controller = new PreviewPrintController();
-        Assert.Throws<NullReferenceException>(() => controller.OnStartPrint(null, new PrintEventArgs()));
-    }
-
-    [Theory]
-    [MemberData(nameof(PrintEventArgs_TestData))]
-    public void OnEndPrint_InvokeWithoutStarting_Nop(PrintEventArgs e)
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new PreviewPrintController();
-            controller.OnEndPrint(document, e);
-            controller.OnEndPrint(null, e);
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PrintControllerTests.cs b/src/System.Drawing.Common/tests/Printing/PrintControllerTests.cs
deleted file mode 100644
index 343f37c24a8..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PrintControllerTests.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Printing.Tests;
-
-public class PrintControllerTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var controller = new SubPrintController();
-        Assert.False(controller.IsPreview);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void OnStartPage_InvokeWithPrint_ReturnsNull()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            controller.OnStartPrint(document, new PrintEventArgs());
-
-            var printEventArgs = new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null);
-            Assert.Null(controller.OnStartPage(document, printEventArgs));
-
-            // Call OnEndPage.
-            controller.OnEndPage(document, printEventArgs);
-
-            // Call EndPrint.
-            controller.OnEndPrint(document, new PrintEventArgs());
-        }
-    }
-
-    [Fact]
-    public void OnStartPage_Invoke_ReturnsNull()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            Assert.Null(controller.OnStartPage(document, new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null)));
-            Assert.Null(controller.OnStartPage(null, null));
-        }
-    }
-
-    [Fact]
-    public void OnEndPage_InvokeWithoutStarting_Nop()
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            controller.OnEndPage(document, new PrintPageEventArgs(null, Rectangle.Empty, Rectangle.Empty, null));
-            controller.OnEndPage(null, null);
-        }
-    }
-
-    public static IEnumerable<object[]> PrintEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new PrintEventArgs() };
-    }
-
-    [Theory]
-    [MemberData(nameof(PrintEventArgs_TestData))]
-    public void OnStartPrint_InvokeWithDocument_Success(PrintEventArgs e)
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            controller.OnStartPrint(document, e);
-
-            // Call OnEndPrint
-            controller.OnEndPrint(document, e);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(PrintEventArgs_TestData))]
-    public void OnStartPrint_InvokeWithDocumentSeveralTimes_Success(PrintEventArgs e)
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            controller.OnStartPrint(document, e);
-            controller.OnStartPrint(document, e);
-
-            // Call OnEndPrint
-            controller.OnEndPrint(document, e);
-        }
-    }
-
-    [Fact]
-    public void OnStartPrint_InvokeNullDocument_ThrowsNullReferenceException()
-    {
-        var controller = new SubPrintController();
-        Assert.Throws<NullReferenceException>(() => controller.OnStartPrint(null, new PrintEventArgs()));
-    }
-
-    [Theory]
-    [MemberData(nameof(PrintEventArgs_TestData))]
-    public void OnEndPrint_InvokeWithoutStarting_Nop(PrintEventArgs e)
-    {
-        using (var document = new PrintDocument())
-        {
-            var controller = new SubPrintController();
-            controller.OnEndPrint(document, e);
-            controller.OnEndPrint(null, e);
-        }
-    }
-
-    private class SubPrintController : PrintController
-    {
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PrintDocumentTests.cs b/src/System.Drawing.Common/tests/Printing/PrintDocumentTests.cs
deleted file mode 100644
index 9af2b3e48e7..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PrintDocumentTests.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2005-2006 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-namespace System.Drawing.Printing.Tests;
-
-public class PrintDocumentTests : FileCleanupTestBase
-{
-    private readonly PageSettings _pageSettings = new()
-    {
-        PaperSize = new PaperSize()
-        {
-            RawKind = (int)PaperKind.A3
-        }
-    };
-
-    [ConditionalFact(Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void Ctor_Default_Success()
-    {
-        using (var document = new PrintDocument())
-        {
-            Assert.Equal("document", document.DocumentName);
-            Assert.False(document.OriginAtMargins);
-            AssertDefaultPageSettings(document.DefaultPageSettings);
-        }
-    }
-
-    [ConditionalFact(Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void DefaultPageSettings_SetValue_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            document.DefaultPageSettings = null;
-            Assert.IsAssignableFrom<PageSettings>(document.DefaultPageSettings);
-
-            document.DefaultPageSettings = _pageSettings;
-            Assert.Equal(_pageSettings.PaperSize.Kind, _pageSettings.PaperSize.Kind);
-        }
-    }
-
-    [Fact]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/8812")]
-    public void DefaultPageSettings_Null_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            document.DefaultPageSettings = null;
-            AssertDefaultPageSettings(document.DefaultPageSettings);
-        }
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("newDocument")]
-    public void DocumentName_SetValue_ReturnsExpected(string documentName)
-    {
-        using (var document = new PrintDocument())
-        {
-            document.DocumentName = documentName;
-            Assert.Equal(documentName, document.DocumentName);
-        }
-    }
-
-    [Fact]
-    public void DocumentName_Null_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            document.DocumentName = null;
-            Assert.Equal(string.Empty, document.DocumentName);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void OriginAtMargins_SetValue_ReturnsExpected(bool originAtMargins)
-    {
-        using (var document = new PrintDocument())
-        {
-            document.OriginAtMargins = originAtMargins;
-            Assert.Equal(originAtMargins, document.OriginAtMargins);
-        }
-    }
-
-    [Fact]
-    public void PrintController_SetValue_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            document.PrintController = null;
-            Assert.NotNull(document.PrintController);
-
-            var printController = new StandardPrintController();
-            document.PrintController = printController;
-            Assert.Same(printController, document.PrintController);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void PrinterSettings_SetValue_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            document.PrinterSettings = null;
-            Assert.IsAssignableFrom<PrinterSettings>(document.PrinterSettings);
-
-            var printerSettings = new PrinterSettings();
-            document.PrinterSettings = printerSettings;
-            Assert.Same(printerSettings, document.PrinterSettings);
-            Assert.Equal(
-                document.PrinterSettings.DefaultPageSettings.PaperSize.Kind,
-                document.DefaultPageSettings.PaperSize.Kind);
-
-            document.DefaultPageSettings = _pageSettings;
-            document.PrinterSettings = printerSettings;
-            Assert.Equal(
-                _pageSettings.PaperSize.Kind,
-                document.DefaultPageSettings.PaperSize.Kind);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void BeginPrint_SetValue_ReturnsExpected()
-    {
-        bool flag = false;
-        var beginPrintHandler = new PrintEventHandler((sender, e) => flag = true);
-
-        using (var document = new PrintDocument())
-        {
-            document.PrintController = new TestPrintController();
-            document.BeginPrint += beginPrintHandler;
-            document.Print();
-            Assert.True(flag);
-
-            flag = false;
-            document.BeginPrint -= beginPrintHandler;
-            document.Print();
-            Assert.False(flag);
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/8815")]
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void EndPrint_SetValue_ReturnsExpected()
-    {
-        bool flag = false;
-        var endPrintHandler = new PrintEventHandler((sender, e) => flag = true);
-
-        using (var document = new PrintDocument())
-        {
-            document.PrintController = new TestPrintController();
-            document.EndPrint += endPrintHandler;
-            document.Print();
-            Assert.True(flag);
-
-            flag = false;
-            document.EndPrint -= endPrintHandler;
-            document.Print();
-            Assert.False(flag);
-        }
-    }
-
-    [ConditionalFact(nameof(CanPrintToPdf))]
-    public void Print_DefaultPrintController_Success()
-    {
-        bool endPrintCalled = false;
-        var endPrintHandler = new PrintEventHandler((sender, e) => endPrintCalled = true);
-        using (var document = new PrintDocument())
-        {
-            document.PrinterSettings.PrinterName = PrintToPdfPrinterName;
-            document.PrinterSettings.PrintFileName = GetTestFilePath();
-            document.PrinterSettings.PrintToFile = true;
-            document.EndPrint += endPrintHandler;
-            document.Print();
-            document.EndPrint -= endPrintHandler;
-        }
-
-        // File may not have finished saving to disk when Print returns,
-        // so we check for EndPrint being called instead of file existence.
-        Assert.True(endPrintCalled);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/8815")]
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void PrintPage_SetValue_ReturnsExpected()
-    {
-        bool flag = false;
-        var printPageHandler = new PrintPageEventHandler((sender, e) => flag = true);
-
-        using (var document = new PrintDocument())
-        {
-            document.PrintController = new TestPrintController();
-            document.PrintPage += printPageHandler;
-            document.Print();
-            Assert.True(flag);
-
-            flag = false;
-            document.PrintPage -= printPageHandler;
-            document.Print();
-            Assert.False(flag);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void QueryPageSettings_SetValue_ReturnsExpected()
-    {
-        bool flag = false;
-        var queryPageSettingsHandler = new QueryPageSettingsEventHandler((sender, e) => flag = true);
-
-        using (var document = new PrintDocument())
-        {
-            document.PrintController = new TestPrintController();
-            document.QueryPageSettings += queryPageSettingsHandler;
-            document.Print();
-            Assert.True(flag);
-
-            flag = false;
-            document.QueryPageSettings -= queryPageSettingsHandler;
-            document.Print();
-            Assert.False(flag);
-        }
-    }
-
-    [Fact]
-    public void ToString_ReturnsExpected()
-    {
-        using (var document = new PrintDocument())
-        {
-            var expected = $"[PrintDocument {document.DocumentName}]";
-            Assert.Equal(expected, document.ToString());
-        }
-    }
-
-    private void AssertDefaultPageSettings(PageSettings pageSettings)
-    {
-        // A4 and Letter are both common default sizes for systems to have.
-        switch (pageSettings.PaperSize.Kind)
-        {
-            case PaperKind.A4:
-                Assert.Equal(new Rectangle(0, 0, 827, 1169), pageSettings.Bounds);
-                break;
-
-            case PaperKind.Letter:
-                Assert.Equal(new Rectangle(0, 0, 850, 1100), pageSettings.Bounds);
-                break;
-        }
-
-        Assert.True(Enum.IsDefined(typeof(PrinterResolutionKind), pageSettings.PrinterResolution.Kind));
-        Assert.True(pageSettings.PrinterSettings.IsDefaultPrinter);
-    }
-
-    private const string PrintToPdfPrinterName = "Microsoft Print to PDF";
-    private static bool CanPrintToPdf()
-    {
-        if (!PlatformDetection.IsWindows || !PlatformDetection.IsDrawingSupported)
-            return false;
-
-        foreach (string name in PrinterSettings.InstalledPrinters)
-        {
-            if (name == PrintToPdfPrinterName)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private class TestPrintController : PrintController
-    {
-        public override Graphics OnStartPage(PrintDocument document, PrintPageEventArgs e)
-        {
-            using (var bitmap = new Bitmap(20, 20))
-            {
-                return Graphics.FromImage(bitmap);
-            }
-        }
-
-        public override void OnStartPrint(PrintDocument document, PrintEventArgs e)
-        {
-            base.OnStartPrint(document, e);
-        }
-
-        public override void OnEndPrint(PrintDocument document, PrintEventArgs e)
-        {
-            base.OnEndPrint(document, e);
-        }
-
-        public override void OnEndPage(PrintDocument document, PrintPageEventArgs e)
-        {
-            base.OnEndPage(document, e);
-            e.Graphics.Dispose();
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PrinterResolutionTests.cs b/src/System.Drawing.Common/tests/Printing/PrinterResolutionTests.cs
deleted file mode 100644
index 97795834a9a..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PrinterResolutionTests.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Drawing.Printing.Tests;
-
-public class PrinterResolutionTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var resolution = new PrinterResolution();
-        Assert.Equal(PrinterResolutionKind.Custom, resolution.Kind);
-        Assert.Equal(0, resolution.X);
-        Assert.Equal(0, resolution.Y);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(1)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void X_Value_ReturnsExpected(int value)
-    {
-        var resolution = new PrinterResolution
-        {
-            X = value
-        };
-        Assert.Equal(value, resolution.X);
-
-        // Set same.
-        resolution.X = value;
-        Assert.Equal(value, resolution.X);
-    }
-
-    [Theory]
-    [InlineData(int.MaxValue)]
-    [InlineData(1)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void Y_Value_ReturnsExpected(int value)
-    {
-        var resolution = new PrinterResolution
-        {
-            Y = value
-        };
-        Assert.Equal(value, resolution.Y);
-
-        // Set same.
-        resolution.Y = value;
-        Assert.Equal(value, resolution.Y);
-    }
-
-    [Theory]
-    [InlineData(PrinterResolutionKind.Custom)]
-    [InlineData(PrinterResolutionKind.Draft)]
-    [InlineData(PrinterResolutionKind.High)]
-    [InlineData(PrinterResolutionKind.Low)]
-    [InlineData(PrinterResolutionKind.Medium)]
-    public void Kind_Set_GetReturnsExpected(PrinterResolutionKind value)
-    {
-        var resolution = new PrinterResolution
-        {
-            Kind = value
-        };
-        Assert.Equal(value, resolution.Kind);
-
-        // Set same.
-        resolution.Kind = value;
-        Assert.Equal(value, resolution.Kind);
-    }
-
-    [Theory]
-    [InlineData(PrinterResolutionKind.Custom + 1)]
-    [InlineData(PrinterResolutionKind.High - 1)]
-    public void Kind_SetInvalid_ThrowsInvalidEnumArgumentException(PrinterResolutionKind value)
-    {
-        var resolution = new PrinterResolution();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => resolution.Kind = value);
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new PrinterResolution(), "[PrinterResolution X=0 Y=0]" };
-        yield return new object[] { new PrinterResolution { X = -1, Y = -2}, "[PrinterResolution X=-1 Y=-2]" };
-        yield return new object[] { new PrinterResolution { Kind = PrinterResolutionKind.High }, "[PrinterResolution High]" };
-        yield return new object[] { new PrinterResolution { X = 1, Y = 2, Kind = PrinterResolutionKind.High }, "[PrinterResolution High]" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void ToString_Invoke_ReturnsExpected(PrinterResolution resolution, string expected)
-    {
-        Assert.Equal(expected, resolution.ToString());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PrinterSettingsTests.cs b/src/System.Drawing.Common/tests/Printing/PrinterSettingsTests.cs
deleted file mode 100644
index 0b1f25d7e0a..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PrinterSettingsTests.cs
+++ /dev/null
@@ -1,626 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Authors:
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-using System.Drawing.Imaging;
-using System.Globalization;
-
-namespace System.Drawing.Printing.Tests;
-
-public class PrinterSettingsTests
-{
-    [Fact]
-    public void Ctor_Default_Success()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.NotNull(printerSettings.DefaultPageSettings);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void CanDuplex_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        bool canDuplex = printerSettings.CanDuplex;
-    }
-
-    [Fact]
-    public void Copies_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        int copies = printerSettings.Copies;
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(short.MaxValue)]
-    public void Copies_SetValue_ReturnsExpected(short copies)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            Copies = copies
-        };
-
-        Assert.Equal(copies, printerSettings.Copies);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(short.MinValue)]
-    public void Copies_SetValue_ThrowsArgumentException(short copies)
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.Copies = copies);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void Collate_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        bool collate = printerSettings.Collate;
-    }
-
-    [Fact]
-    public void Collate_SetValue_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            Collate = false
-        };
-
-        Assert.False(printerSettings.Collate);
-    }
-
-    [Fact]
-    public void DefaultPageSettings_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.NotNull(printerSettings.DefaultPageSettings);
-    }
-
-    [Theory]
-    [InlineData(Duplex.Simplex)]
-    [InlineData(Duplex.Vertical)]
-    [InlineData(Duplex.Horizontal)]
-    public void Duplex_SetValue_ReturnsExpected(Duplex duplex)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            Duplex = duplex
-        };
-
-        Assert.Equal(duplex, printerSettings.Duplex);
-    }
-
-    [Theory]
-    [InlineData(Duplex.Default - 1)]
-    [InlineData(Duplex.Horizontal + 1)]
-    [InlineData((Duplex)int.MaxValue)]
-    [InlineData((Duplex)int.MinValue)]
-    public void Duplex_Invalid_ThrowsInvalidEnumArgumentException(Duplex duplex)
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.ThrowsAny<ArgumentException>(() => printerSettings.Duplex = duplex);
-    }
-
-    [Fact]
-    public void FromPage_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-
-        Assert.Equal(0, printerSettings.FromPage);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(int.MaxValue)]
-    public void FromPage_SetValue_ReturnsExpected(int pageNumber)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            FromPage = pageNumber
-        };
-
-        Assert.Equal(pageNumber, printerSettings.FromPage);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void FromPage_Invalid_ThrowsArgumentException(int pageNumber)
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.FromPage = pageNumber);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void Static_InstalledPrinters_ReturnsExpected()
-    {
-        Assert.NotNull(PrinterSettings.InstalledPrinters);
-    }
-
-    [Fact]
-    public void IsDefaultPrinter_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.True(printerSettings.IsDefaultPrinter);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void IsPlotter_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.False(printerSettings.IsPlotter);
-    }
-
-    [Fact]
-    public void IsValid_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            PrinterName = "Invalid Printer"
-        };
-
-        Assert.False(printerSettings.IsValid);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void LandscapeAngle_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        int[] validValues = new[] { -90, 0, 90, 270 };
-        Assert.True(validValues.Contains(printerSettings.LandscapeAngle), $"PrinterSettings.LandscapeAngle ({printerSettings.LandscapeAngle}) must be 0, 90, or 270 degrees.");
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void MaximumCopies_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.True(printerSettings.MaximumCopies >= 0, $"PrinterSettings.MaximumCopies ({printerSettings.MaximumCopies}) should not be negative.");
-    }
-
-    [Fact]
-    public void MaximumPage_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-
-        Assert.Equal(9999, printerSettings.MaximumPage);
-    }
-
-    [Theory]
-    [InlineData(20)]
-    [InlineData(int.MaxValue)]
-    public void MaximumPage_SetValue_ReturnsExpected(int maximumPage)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            MaximumPage = maximumPage
-        };
-
-        Assert.Equal(maximumPage, printerSettings.MaximumPage);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void MaximumPage_Invalid_ThrowsArgumentException(int maximumPage)
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.MaximumPage = maximumPage);
-    }
-
-    [Fact]
-    public void MinimumPage_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.Equal(0, printerSettings.MinimumPage);
-    }
-
-    [Theory]
-    [InlineData(20)]
-    [InlineData(int.MaxValue)]
-    public void MinimumPage_SetValue_ReturnsExpected(int minimumPage)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            MinimumPage = minimumPage
-        };
-
-        Assert.Equal(minimumPage, printerSettings.MinimumPage);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void MinimumPage_Invalid_ThrowsArgumentException(int minimumPage)
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.MinimumPage = minimumPage);
-    }
-
-    [Fact]
-    public void PrintFileName_SetValue_ReturnsExpected()
-    {
-        var printFileName = "fileName";
-        var printerSettings = new PrinterSettings()
-        {
-            PrintFileName = printFileName
-        };
-
-        Assert.Equal(printFileName, printerSettings.PrintFileName);
-    }
-
-    [Fact]
-    public void PrintFileName_Null_ThrowsArgumentNullException()
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentNullException>(null, () => printerSettings.PrintFileName = null);
-    }
-
-    [Fact]
-    public void PrintFileName_Empty_ThrowsArgumentNullException()
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentNullException>(string.Empty, () => printerSettings.PrintFileName = string.Empty);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void PaperSizes_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.NotNull(printerSettings.PaperSizes);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void PaperSources_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.NotNull(printerSettings.PaperSources);
-    }
-
-    [Theory]
-    [InlineData(PrintRange.AllPages)]
-    [InlineData(PrintRange.CurrentPage)]
-    [InlineData(PrintRange.Selection)]
-    [InlineData(PrintRange.SomePages)]
-    public void PrintRange_SetValue_ReturnsExpected(PrintRange printRange)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            PrintRange = printRange
-        };
-
-        Assert.Equal(printRange, printerSettings.PrintRange);
-    }
-
-    [Theory]
-    [InlineData(PrintRange.AllPages - 1)]
-    [InlineData(PrintRange.SomePages + 1)]
-    [InlineData((PrintRange)int.MaxValue)]
-    [InlineData((PrintRange)int.MinValue)]
-    public void PrintRange_Invalid_ThrowsInvalidEnumArgumentException(PrintRange printRange)
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.ThrowsAny<ArgumentException>(() => printerSettings.PrintRange = printRange);
-    }
-
-    [Fact]
-    public void PrintToFile_SetValue_ReturnsExpected()
-    {
-        var printToFile = true;
-        var printerSettings = new PrinterSettings()
-        {
-            PrintToFile = printToFile
-        };
-
-        Assert.Equal(printToFile, printerSettings.PrintToFile);
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("My printer")]
-    public void PrinterName_SetValue_ReturnsExpected(string printerName)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            PrinterName = printerName
-        };
-
-        Assert.Equal(printerName, printerSettings.PrinterName);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void PrinterName_Null_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            PrinterName = null
-        };
-
-        Assert.NotNull(printerSettings.PrinterName);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters)]
-    public void PrinterResolutions_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.NotNull(printerSettings.PrinterResolutions);
-    }
-
-    public static IEnumerable<object[]> IsDirectPrintingSupported_ImageFormatSupported_TestData()
-    {
-        yield return new object[] { ImageFormat.Jpeg };
-        yield return new object[] { ImageFormat.Png };
-    }
-
-    [ConditionalTheory(Helpers.AnyInstalledPrinters)]
-    [MemberData(nameof(IsDirectPrintingSupported_ImageFormatSupported_TestData))]
-    public void IsDirectPrintingSupported_ImageFormatSupported_ReturnsExpected(ImageFormat imageFormat)
-    {
-        var printerSettings = new PrinterSettings();
-        bool supported = printerSettings.IsDirectPrintingSupported(imageFormat);
-    }
-
-    public static IEnumerable<object[]> IsDirectPrintingSupported_ImageFormatNotSupported_TestData()
-    {
-        yield return new object[] { ImageFormat.Emf };
-        yield return new object[] { ImageFormat.Exif };
-        yield return new object[] { ImageFormat.Gif };
-        yield return new object[] { ImageFormat.Icon };
-        yield return new object[] { ImageFormat.MemoryBmp };
-        yield return new object[] { ImageFormat.Tiff };
-        yield return new object[] { ImageFormat.Wmf };
-        yield return new object[] { ImageFormat.Bmp };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsDirectPrintingSupported_ImageFormatNotSupported_TestData))]
-    public void IsDirectPrintingSupported_ImageFormatNotSupported_ReturnsExpected(ImageFormat imageFormat)
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.False(printerSettings.IsDirectPrintingSupported(imageFormat));
-    }
-
-    [Fact]
-    public void IsDirectPrintingSupported_ImageNotSupported_ReturnsExpected()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            var printerSettings = new PrinterSettings();
-            Assert.False(printerSettings.IsDirectPrintingSupported(bitmap));
-        }
-    }
-
-    [ConditionalFact(typeof(PrinterSettingsTests), nameof(CanTestSetHdevmode_IntPtr_Success))]
-    public void SupportsColor_ReturnsExpected()
-    {
-        // XPS and PDF printers support color.
-        // docs.microsoft.com/en-us/windows-hardware/drivers/print/improved-color-printing
-        var printerSettings = new PrinterSettings() { PrinterName = GetNameOfTestPrinterSuitableForDevModeTesting() };
-        Assert.True(printerSettings.SupportsColor);
-    }
-
-    [Theory]
-    [InlineData(20)]
-    [InlineData(int.MaxValue)]
-    public void ToPage_SetValue_ReturnsExpected(int toPage)
-    {
-        var printerSettings = new PrinterSettings()
-        {
-            ToPage = toPage
-        };
-
-        Assert.Equal(toPage, printerSettings.ToPage);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(int.MinValue)]
-    public void ToPage_Invalid_ThrowsArgumentException(int toPage)
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.ToPage = toPage);
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void Clone_Success()
-    {
-        var printerSettings = new PrinterSettings();
-        PrinterSettings clone = Assert.IsAssignableFrom<PrinterSettings>(printerSettings.Clone());
-        Assert.False(ReferenceEquals(clone, printerSettings));
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void CreateMeasurementGraphics_Default_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        using (Graphics graphic = printerSettings.CreateMeasurementGraphics())
-        {
-            Assert.NotNull(graphic);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.Bounds.X, graphic.VisibleClipBounds.X, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.Bounds.Y, graphic.VisibleClipBounds.Y, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Height, graphic.VisibleClipBounds.Height, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Width, graphic.VisibleClipBounds.Width, 0);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void CreateMeasurementGraphics_Bool_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        using (Graphics graphic = printerSettings.CreateMeasurementGraphics(true))
-        {
-            Assert.NotNull(graphic);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Height, graphic.VisibleClipBounds.Height, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Width, graphic.VisibleClipBounds.Width, 0);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void CreateMeasurementGraphics_PageSettings_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        var pageSettings = new PageSettings();
-        using (Graphics graphic = printerSettings.CreateMeasurementGraphics(pageSettings))
-        {
-            Assert.NotNull(graphic);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.Bounds.X, graphic.VisibleClipBounds.X, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.Bounds.Y, graphic.VisibleClipBounds.Y, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Height, graphic.VisibleClipBounds.Height, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Width, graphic.VisibleClipBounds.Width, 0);
-        }
-    }
-
-    [ConditionalFact(Helpers.AnyInstalledPrinters, Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void CreateMeasurementGraphics_PageSettingsBool_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        var pageSettings = new PageSettings();
-        using (Graphics graphic = printerSettings.CreateMeasurementGraphics(pageSettings, true))
-        {
-            Assert.NotNull(graphic);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Height, graphic.VisibleClipBounds.Height, 0);
-            Assert.Equal((double)printerSettings.DefaultPageSettings.PrintableArea.Width, graphic.VisibleClipBounds.Width, 0);
-        }
-    }
-
-    [ConditionalFact(Helpers.WindowsRS3OrEarlier)] // RS4 failures: https://github.com/dotnet/winforms/issues/8816
-    public void CreateMeasurementGraphics_Null_ThrowsNullReferenceException()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.Throws<NullReferenceException>(() => printerSettings.CreateMeasurementGraphics(null));
-        Assert.Throws<NullReferenceException>(() => printerSettings.CreateMeasurementGraphics(null, true));
-    }
-
-    [Fact]
-    public void GetHdevmode_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        IntPtr handle = IntPtr.Zero;
-
-        handle = printerSettings.GetHdevmode();
-        Assert.NotEqual(IntPtr.Zero, handle);
-    }
-
-    [Fact]
-    public void GetHdevmode_PageSettings_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        var pageSettings = new PageSettings();
-        IntPtr handle = IntPtr.Zero;
-
-        handle = printerSettings.GetHdevmode(pageSettings);
-        Assert.NotEqual(IntPtr.Zero, handle);
-    }
-
-    [Fact]
-    public void GetHdevmode_Null_ThrowsNullReferenceException()
-    {
-        var printerSettings = new PrinterSettings();
-        Assert.Throws<NullReferenceException>(() => printerSettings.GetHdevmode(null));
-    }
-
-    [Fact]
-    public void GetHdevnames_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        IntPtr handle = IntPtr.Zero;
-
-        handle = printerSettings.GetHdevnames();
-        Assert.NotEqual(IntPtr.Zero, handle);
-    }
-
-    [ConditionalFact(typeof(PrinterSettingsTests), nameof(CanTestSetHdevmode_IntPtr_Success))]
-    public void SetHdevmode_IntPtr_Success()
-    {
-        string printerName = GetNameOfTestPrinterSuitableForDevModeTesting();
-        var printerSettings = new PrinterSettings() { PrinterName = printerName, Copies = 3 };
-        var newPrinterSettings = new PrinterSettings() { PrinterName = printerName, Copies = 6 };
-
-        IntPtr handle = printerSettings.GetHdevmode();
-        newPrinterSettings.SetHdevmode(handle);
-        Assert.Equal(printerSettings.Copies, newPrinterSettings.Copies);
-        Assert.Equal(printerSettings.Collate, newPrinterSettings.Collate);
-        Assert.Equal(printerSettings.Duplex, newPrinterSettings.Duplex);
-    }
-
-    public static bool CanTestSetHdevmode_IntPtr_Success => GetNameOfTestPrinterSuitableForDevModeTesting() != null;
-
-    private static string GetNameOfTestPrinterSuitableForDevModeTesting()
-    {
-        foreach (string candidate in s_TestPrinterNames)
-        {
-            PrinterSettings printerSettings = new PrinterSettings() { PrinterName = candidate };
-            if (printerSettings.IsValid)
-                return candidate;
-        }
-        return null;
-    }
-
-    private static readonly string[] s_TestPrinterNames =
-    {
-        // Our method of testing some apis requires a printer that supports multi-copy printing, collating, color and duplex settings. Not all printers
-        // support these so rather than trust the machine running the test to have configured such a printer as the default, use the name of
-        // a known compliant printer that ships with Windows 10.
-        "Microsoft Print to PDF",
-        "Microsoft XPS Document Writer", // Backup for older Windows
-    };
-
-    [Fact]
-    public void GetHdevmode_Zero_ThrowsArgumentException()
-    {
-        var printerSettings = new PrinterSettings();
-        AssertExtensions.Throws<ArgumentException>(null, () => printerSettings.SetHdevmode(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void SetHdevnames_IntPtr_Success()
-    {
-        var printerSettings = new PrinterSettings();
-        var newPrinterSettings = new PrinterSettings();
-        IntPtr handle = printerSettings.GetHdevnames();
-        newPrinterSettings.SetHdevnames(handle);
-        Assert.Equal(newPrinterSettings.PrinterName, printerSettings.PrinterName);
-    }
-
-    [Fact]
-    public void ToString_ReturnsExpected()
-    {
-        var printerSettings = new PrinterSettings();
-        var expected = "[PrinterSettings "
-            + printerSettings.PrinterName
-            + " Copies=" + printerSettings.Copies.ToString(CultureInfo.InvariantCulture)
-            + " Collate=" + printerSettings.Collate.ToString(CultureInfo.InvariantCulture)
-            + " Duplex=" + printerSettings.Duplex.ToString()
-            + " FromPage=" + printerSettings.FromPage.ToString(CultureInfo.InvariantCulture)
-            + " LandscapeAngle=" + printerSettings.LandscapeAngle.ToString(CultureInfo.InvariantCulture)
-            + " MaximumCopies=" + printerSettings.MaximumCopies.ToString(CultureInfo.InvariantCulture)
-            + " OutputPort=" + printerSettings.PrintFileName.ToString(CultureInfo.InvariantCulture)
-            + " ToPage=" + printerSettings.ToPage.ToString(CultureInfo.InvariantCulture)
-            + "]";
-
-        Assert.Equal(expected, printerSettings.ToString());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Printing/PrinterUnitConvertTests.cs b/src/System.Drawing.Common/tests/Printing/PrinterUnitConvertTests.cs
deleted file mode 100644
index abd4531f330..00000000000
--- a/src/System.Drawing.Common/tests/Printing/PrinterUnitConvertTests.cs
+++ /dev/null
@@ -1,148 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-// Author:
-//
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//
-
-namespace System.Drawing.Printing.Tests;
-
-public class PrinterUnitConvertTests
-{
-    [Theory]
-    [InlineData(PrinterUnit.Display, PrinterUnit.Display, 100)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter, 2540)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter, 254)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.ThousandthsOfAnInch, 1000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.Display, 4)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 100)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 10)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 39)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display, 39)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 1000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 100)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 394)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.Display, 10)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.HundredthsOfAMillimeter, 254)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.TenthsOfAMillimeter, 25)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.ThousandthsOfAnInch, 100)]
-    public void Convert_Int_ReturnsExpected(PrinterUnit fromUnit, PrinterUnit toUnit, int expectedResult)
-    {
-        var converted = PrinterUnitConvert.Convert(100, fromUnit, toUnit);
-        Assert.Equal(expectedResult, converted);
-    }
-
-    [Theory]
-    [InlineData(PrinterUnit.Display, PrinterUnit.Display, 100, 1000)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter, 2540, 25400)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.ThousandthsOfAnInch, 1000, 10000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.Display, 4, 39)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 10, 100)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 1000, 10000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 394, 3937)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.Display, 10, 100)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.HundredthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.TenthsOfAMillimeter, 25, 254)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.ThousandthsOfAnInch, 100, 1000)]
-    public void Convert_Point_ReturnsExpected(PrinterUnit fromUnit, PrinterUnit toUnit, int expectedX, int expectedY)
-    {
-        var converted = PrinterUnitConvert.Convert(new Point(100, 1000), fromUnit, toUnit);
-        Assert.Equal(new Point(expectedX, expectedY), converted);
-    }
-
-    [Theory]
-    [InlineData(PrinterUnit.Display, PrinterUnit.Display, 100, 1000)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter, 2540, 25400)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.ThousandthsOfAnInch, 1000, 10000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.Display, 4, 39)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 10, 100)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 1000, 10000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 394, 3937)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.Display, 10, 100)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.HundredthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.TenthsOfAMillimeter, 25, 254)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.ThousandthsOfAnInch, 100, 1000)]
-    public void Convert_Rectangle_ReturnsExpected(PrinterUnit fromUnit, PrinterUnit toUnit, int expectedLeftValue, int expectedRightValue)
-    {
-        var converted = PrinterUnitConvert.Convert(new Rectangle(100, 1000, 100, 1000), fromUnit, toUnit);
-        Assert.Equal(new Rectangle(expectedLeftValue, expectedRightValue, expectedLeftValue, expectedRightValue), converted);
-    }
-
-    [Theory]
-    [InlineData(PrinterUnit.Display, PrinterUnit.Display, 100, 1000)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter, 2540, 25400)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.ThousandthsOfAnInch, 1000, 10000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.Display, 4, 39)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 10, 100)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 1000, 10000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 100, 1000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 394, 3937)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.Display, 10, 100)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.HundredthsOfAMillimeter, 254, 2540)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.TenthsOfAMillimeter, 25, 254)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.ThousandthsOfAnInch, 100, 1000)]
-    public void Convert_Size_ReturnsExpected(PrinterUnit fromUnit, PrinterUnit toUnit, int expectedX, int expectedY)
-    {
-        var converted = PrinterUnitConvert.Convert(new Size(100, 1000), fromUnit, toUnit);
-        Assert.Equal(new Size(expectedX, expectedY), converted);
-    }
-
-    [Theory]
-    [InlineData(PrinterUnit.Display, PrinterUnit.Display, 100, 1000, 100, 1000)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.HundredthsOfAMillimeter, 2540, 25400, 2540, 25400)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.TenthsOfAMillimeter, 254, 2540, 254, 2540)]
-    [InlineData(PrinterUnit.Display, PrinterUnit.ThousandthsOfAnInch, 1000, 10000, 1000, 10000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.Display, 4, 39, 4, 39)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 100, 1000, 100, 1000)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 10, 100, 10, 100)]
-    [InlineData(PrinterUnit.HundredthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 39, 394, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.Display, 39, 394, 39, 394)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.HundredthsOfAMillimeter, 1000, 10000, 1000, 10000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.TenthsOfAMillimeter, 100, 1000, 100, 1000)]
-    [InlineData(PrinterUnit.TenthsOfAMillimeter, PrinterUnit.ThousandthsOfAnInch, 394, 3937, 394, 3937)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.Display, 10, 100, 10, 100)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.HundredthsOfAMillimeter, 254, 2540, 254, 2540)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.TenthsOfAMillimeter, 25, 254, 25, 254)]
-    [InlineData(PrinterUnit.ThousandthsOfAnInch, PrinterUnit.ThousandthsOfAnInch, 100, 1000, 100, 1000)]
-    public void Convert_Margins_ReturnsExpected(PrinterUnit fromUnit, PrinterUnit toUnit, int expectedLeft, int expectedRight, int expectedTop, int expectedBottom)
-    {
-        var converted = PrinterUnitConvert.Convert(new Margins(100, 1000, 100, 1000), fromUnit, toUnit);
-        Assert.Equal(new Margins(expectedLeft, expectedRight, expectedTop, expectedBottom), converted);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/RegionTests.cs b/src/System.Drawing.Common/tests/RegionTests.cs
deleted file mode 100644
index 9f9ecabaccb..00000000000
--- a/src/System.Drawing.Common/tests/RegionTests.cs
+++ /dev/null
@@ -1,2381 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Copyright (C) 2004-2008 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-using System.Drawing.Drawing2D;
-using System.Runtime.InteropServices;
-
-namespace System.Drawing.Tests;
-
-public class RegionTests
-{
-    private static readonly Graphics s_graphic = Graphics.FromImage(new Bitmap(1, 1));
-
-    private static Region CreateDisposedRegion()
-    {
-        var region = new Region();
-        region.Dispose();
-        return region;
-    }
-
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var region = new Region())
-        {
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.True(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF(-4194304, -4194304, 8388608, 8388608), region.GetBounds(s_graphic));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, -2, -3, -4, true)]
-    [InlineData(0, 0, 0, 0, true)]
-    [InlineData(1, 2, 3, 4, false)]
-    public void Ctor_Rectangle(int x, int y, int width, int height, bool isEmpty)
-    {
-        var rectangle = new Rectangle(x, y, width, height);
-
-        using (var region = new Region(rectangle))
-        {
-            Assert.Equal(isEmpty, region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF(x, y, width, height), region.GetBounds(s_graphic));
-        }
-    }
-
-    [Theory]
-    [InlineData(1, 2, 3, float.NegativeInfinity, true)]
-    [InlineData(-1, -2, -3, -4, true)]
-    [InlineData(0, 0, 0, 0, true)]
-    [InlineData(1, 2, 3, 4, false)]
-    [InlineData(float.MaxValue, float.MaxValue, float.MaxValue, float.MaxValue, true)]
-    public void Ctor_RectangleF(float x, float y, float width, float height, bool isEmpty)
-    {
-        var rectangle = new RectangleF(x, y, width, height);
-
-        using (var region = new Region(rectangle))
-        {
-            Assert.Equal(isEmpty, region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(rectangle, region.GetBounds(s_graphic));
-        }
-    }
-
-    public static IEnumerable<object[]> Region_TestData()
-    {
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(0, 0, 0, 0)) };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Region_TestData))]
-    public void Ctor_RegionData(Region region)
-    {
-        using (region)
-        {
-            using (var otherRegion = new Region(region.GetRegionData()))
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(region.GetBounds(s_graphic), otherRegion.GetBounds(s_graphic));
-                Assert.Equal(region.GetRegionScans(matrix), otherRegion.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_RegionDataOfRegionWithPath_Success()
-    {
-        using (var graphicsPath = new GraphicsPath())
-        {
-            graphicsPath.AddRectangle(new Rectangle(1, 2, 3, 4));
-
-            using (var region = new Region(graphicsPath))
-            {
-                Ctor_RegionData(region);
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_RegionDataOfRegionWithRegionData_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var other = new Region(region.GetRegionData()))
-        {
-            Ctor_RegionData(other);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullRegionData_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("rgnData", () => new Region((RegionData)null));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(7)]
-    [InlineData(256)]
-    public void Ctor_InvalidRegionData_ThrowsExternalException(int dataLength)
-    {
-        using (var region = new Region())
-        {
-            RegionData regionData = region.GetRegionData();
-            regionData.Data = new byte[dataLength];
-            Assert.Throws<ExternalException>(() => new Region(regionData));
-        }
-    }
-
-    [Fact]
-    public void Ctor_EmptyGraphicsPath_ThrowsExternalException()
-    {
-        using (var graphicsPath = new GraphicsPath())
-        using (var region = new Region(graphicsPath))
-        {
-            RegionData regionData = region.GetRegionData();
-            Assert.Throws<ExternalException>(() => new Region(regionData));
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullDataInRegionData_ThrowsNullReferenceException()
-    {
-        using (var region = new Region())
-        {
-            RegionData regionData = region.GetRegionData();
-            regionData.Data = null;
-            Assert.Throws<NullReferenceException>(() => new Region(regionData));
-        }
-    }
-
-    [Fact]
-    public void Ctor_GraphicsPath()
-    {
-        using (var graphicsPath = new GraphicsPath())
-        {
-            graphicsPath.AddRectangle(new Rectangle(1, 2, 3, 4));
-            graphicsPath.AddRectangle(new Rectangle(4, 5, 6, 7));
-
-            using (var region = new Region(graphicsPath))
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(new RectangleF[]
-                {
-                    new RectangleF(1, 2, 3, 3),
-                    new RectangleF(1, 5, 9, 1),
-                    new RectangleF(4, 6, 6, 6)
-                }, region.GetRegionScans(matrix));
-                Assert.Equal(new RectangleF(1, 2, 9, 10), region.GetBounds(s_graphic));
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_EmptyGraphicsPath()
-    {
-        using (var graphicsPath = new GraphicsPath())
-        using (var region = new Region(graphicsPath))
-        using (var matrix = new Matrix())
-        {
-            Assert.True(region.IsEmpty(s_graphic));
-            Assert.Empty(region.GetRegionScans(matrix));
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_InfiniteGraphicsPath_TestData()
-    {
-        var path1 = new GraphicsPath();
-        path1.AddRectangle(new Rectangle(-4194304, -4194304, 8388608, 8388608));
-        yield return new object[] { path1, true };
-
-        var path2 = new GraphicsPath();
-        path2.AddRectangle(new Rectangle(-4194304, -4194304, 8388608, 8388608));
-        path2.AddRectangle(Rectangle.Empty);
-        yield return new object[] { path2, true };
-
-        var path3 = new GraphicsPath();
-        path3.AddRectangle(new Rectangle(-4194304, -4194304, 8388608, 8388608));
-        path3.AddRectangle(new Rectangle(1, 2, 3, 4));
-        yield return new object[] { path3, false };
-
-        var path4 = new GraphicsPath();
-        path4.AddCurve(new Point[] { new Point(-4194304, -4194304), new Point(4194304, 4194304) });
-        yield return new object[] { path4, false };
-
-        var path5 = new GraphicsPath();
-        path5.AddPolygon(new Point[] { new Point(-4194304, -4194304), new Point(-4194304, 4194304), new Point(4194304, 4194304), new Point(4194304, -4194304) });
-        yield return new object[] { path5, true };
-
-        var path6 = new GraphicsPath();
-        path6.AddPolygon(new Point[] { new Point(-4194304, -4194304), new Point(-4194304, 4194304), new Point(4194304, 4194304), new Point(4194304, -4194304), new Point(-4194304, -4194304) });
-        yield return new object[] { path6, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InfiniteGraphicsPath_TestData))]
-    public void Ctor_InfiniteGraphicsPath_IsInfinite(GraphicsPath path, bool isInfinite)
-    {
-        using (path)
-        using (var region = new Region(path))
-        {
-            Assert.Equal(isInfinite, region.IsInfinite(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Ctor_GraphicsPathTooLarge_SetsToEmpty()
-    {
-        using (var path = new GraphicsPath())
-        {
-            path.AddCurve(new Point[] { new Point(-4194304, -4194304), new Point(4194304, 4194304) });
-
-            using (var region = new Region(path))
-            using (var matrix = new Matrix())
-            {
-                Assert.Empty(region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("path", () => new Region((GraphicsPath)null));
-    }
-
-    [Fact]
-    public void Ctor_DisposedGraphicsPath_ThrowsArgumentException()
-    {
-        var path = new GraphicsPath();
-        path.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new Region(path));
-    }
-
-    [Theory]
-    [MemberData(nameof(Region_TestData))]
-    public void Clone(Region region)
-    {
-        using (region)
-        using (Region clone = Assert.IsType<Region>(region.Clone()))
-        using (var matrix = new Matrix())
-        {
-            Assert.NotSame(region, clone);
-
-            Assert.Equal(region.GetBounds(s_graphic), clone.GetBounds(s_graphic));
-            Assert.Equal(region.GetRegionScans(matrix), clone.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().Clone());
-    }
-
-    public static IEnumerable<object[]> Complement_TestData()
-    {
-        yield return new object[]
-        {
-            new Region(new RectangleF(10, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[] { new RectangleF(110, 60, 30, 20) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(70, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[] { new RectangleF(40, 60, 30, 20) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(40, 100, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[] { new RectangleF(70, 80, 50, 20) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(40, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[] { new RectangleF(70, 110, 50, 10) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(30, 30, 80, 80)),
-            new RectangleF[]
-            {
-                new RectangleF(45, 45, 200, 200),
-                new RectangleF(160, 260, 10, 10),
-                new RectangleF(170, 260, 10, 10),
-            },
-            new RectangleF[] { new RectangleF(170, 260, 10, 10) }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { new RectangleF(1, 2, 3, 4) },
-            new RectangleF[0]
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Complement_TestData))]
-    public void Complement_Region_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var other = new Region(rect))
-                {
-                    region.Complement(other);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Complement_UnionRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(20, 20, 20, 20)))
-        using (var other = new Region(new Rectangle(20, 80, 20, 10)))
-        using (var matrix = new Matrix())
-        {
-            other.Union(new Rectangle(60, 60, 30, 10));
-
-            region.Complement(other);
-            Assert.Equal(new RectangleF[]
-            {
-                new RectangleF(60, 60, 30, 10),
-                new RectangleF(20, 80, 20, 10)
-            }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Complement_InfiniteAndWithIntersectRegion_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Intersect(new Rectangle(5, 5, -10, -10));
-            region.Complement(new Rectangle(-5, -5, 12, 12));
-
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[]
-            {
-                new RectangleF(5, -5, 2, 10),
-                new RectangleF(-5, 5, 12, 2)
-            }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Complement_InfiniteRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        using (var other = new Region())
-        {
-            region.Complement(other);
-
-            Assert.Equal(new RectangleF[]
-            {
-                new RectangleF(-4194304, -4194304, 8388608, 4194306),
-                new RectangleF(-4194304, 2, 4194305, 4),
-                new RectangleF(4, 2, 4194300, 4),
-                new RectangleF(-4194304, 6, 8388608, 4194298)
-            }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Complement_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Complement((Region)null));
-        }
-    }
-
-    [Fact]
-    public void Complement_DisposedRegion_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Region().Complement(CreateDisposedRegion()));
-    }
-
-    [Fact]
-    public void Complement_SameRegion_ThrowsInvalidOperationException()
-    {
-        using (var region = new Region())
-        {
-            Assert.Throws<InvalidOperationException>(() => region.Complement(region));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Complement_TestData))]
-    public void Complement_Rectangle_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Complement(new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Complement_TestData))]
-    public void Complement_RectangleF_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Complement(rect);
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Complement_TestData))]
-    public void Complement_GraphicsPath_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var path = new GraphicsPath())
-                {
-                    path.AddRectangle(rect);
-                    region.Complement(path);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Complement_GraphicsPathWithMultipleRectangles_Success()
-    {
-        var rect1 = new Rectangle(20, 30, 60, 80);
-        var rect2 = new Rectangle(50, 40, 60, 80);
-
-        using (Graphics graphics = Graphics.FromImage(new Bitmap(600, 800)))
-        using (var region1 = new Region(rect1))
-        using (var region2 = new Region(rect2))
-        using (var matrix = new Matrix())
-        {
-            graphics.DrawRectangle(Pens.Green, rect1);
-            graphics.DrawRectangle(Pens.Red, rect2);
-
-            region1.Complement(region2);
-            graphics.FillRegion(Brushes.Blue, region1);
-            graphics.DrawRectangles(Pens.Yellow, region1.GetRegionScans(matrix));
-
-            Assert.Equal(new RectangleF[]
-            {
-                new RectangleF(80, 40, 30, 70),
-                new RectangleF(50, 110, 60, 10)
-            }, region1.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Complement_EmptyPathWithInfiniteRegion_MakesEmpty()
-    {
-        using (var region = new Region())
-        using (var graphicsPath = new GraphicsPath())
-        {
-            region.Complement(graphicsPath);
-            Assert.True(region.IsEmpty(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Complement_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => region.Complement((GraphicsPath)null));
-        }
-    }
-
-    [Fact]
-    public void Complement_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        using (var graphicPath = new GraphicsPath())
-        using (var other = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Complement(graphicPath));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Complement(new Rectangle()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Complement(new RectangleF()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Complement(disposedRegion));
-        }
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        static Region Empty()
-        {
-            var emptyRegion = new Region();
-            emptyRegion.MakeEmpty();
-            return emptyRegion;
-        }
-
-        var createdRegion = new Region();
-        yield return new object[] { createdRegion, createdRegion, true };
-        yield return new object[] { new Region(), new Region(), true };
-        yield return new object[] { new Region(), Empty(), false };
-        yield return new object[] { new Region(), new Region(new Rectangle(1, 2, 3, 4)), false };
-
-        yield return new object[] { Empty(), Empty(), true };
-        yield return new object[] { Empty(), new Region(new Rectangle(0, 0, 0, 0)), true };
-        yield return new object[] { Empty(), new Region(new Rectangle(1, 2, 3, 3)), false };
-
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new Rectangle(1, 2, 3, 4)), true };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new RectangleF(1, 2, 3, 4)), true };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new Rectangle(2, 2, 3, 4)), false };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new Rectangle(1, 3, 3, 4)), false };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new Rectangle(1, 2, 4, 4)), false };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)), new Region(new Rectangle(1, 2, 3, 5)), false };
-
-        var graphics1 = new GraphicsPath();
-        graphics1.AddRectangle(new Rectangle(1, 2, 3, 4));
-
-        var graphics2 = new GraphicsPath();
-        graphics2.AddRectangle(new Rectangle(1, 2, 3, 4));
-
-        var graphics3 = new GraphicsPath();
-        graphics3.AddRectangle(new Rectangle(2, 2, 3, 4));
-
-        var graphics4 = new GraphicsPath();
-        graphics4.AddRectangle(new Rectangle(1, 3, 3, 4));
-
-        var graphics5 = new GraphicsPath();
-        graphics5.AddRectangle(new Rectangle(1, 2, 4, 4));
-
-        var graphics6 = new GraphicsPath();
-        graphics6.AddRectangle(new Rectangle(1, 2, 3, 5));
-
-        yield return new object[] { new Region(graphics1), new Region(graphics1), true };
-        yield return new object[] { new Region(graphics1), new Region(graphics2), true };
-        yield return new object[] { new Region(graphics1), new Region(graphics3), false };
-        yield return new object[] { new Region(graphics1), new Region(graphics4), false };
-        yield return new object[] { new Region(graphics1), new Region(graphics5), false };
-        yield return new object[] { new Region(graphics1), new Region(graphics6), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Valid_ReturnsExpected(Region region, Region other, bool expected)
-    {
-        using (region)
-        using (other)
-        {
-                Assert.Equal(expected, region.Equals(other, s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Equals_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Equals(null, s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Equals_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("g", () => region.Equals(region, null));
-        }
-    }
-
-    [Fact]
-    public void Equals_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        using (var other = new Region())
-        using (var image = new Bitmap(10, 10))
-        {
-            var graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-            AssertExtensions.Throws<ArgumentException>(null, () => region.Equals(region, graphics));
-        }
-    }
-
-    [Fact]
-    public void Equals_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Equals(new Region(), s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => new Region().Equals(disposedRegion, s_graphic));
-    }
-
-    public static IEnumerable<object[]> Exclude_TestData()
-    {
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { new RectangleF(520, 40, 60, 80) },
-            new RectangleF[]
-            {
-                new RectangleF(-4194304, -4194304, 8388608, 4194344),
-                new RectangleF(-4194304, 40, 4194824, 80),
-                new RectangleF(580, 40, 4193724, 80),
-                new RectangleF(-4194304, 120, 8388608, 4194184)
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new Rectangle(-4194304, -4194304, 8388608, 8388608) }
-        };
-
-        // Intersecting from the right.
-        yield return new object[]
-        {
-            new Region(new Rectangle(10, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[]
-            {
-                new RectangleF(10, 10, 100, 50),
-                new RectangleF(10, 60, 30, 20),
-                new RectangleF(10, 80, 100, 30)
-            }
-        };
-
-        // Intersecting from the left.
-        yield return new object[]
-        {
-            new Region(new Rectangle(70, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[]
-            {
-                new RectangleF(70, 10, 100, 50),
-                new RectangleF(140, 60, 30, 20),
-                new RectangleF(70, 80, 100, 30)
-            }
-        };
-
-        // Intersecting from the top.
-        yield return new object[]
-        {
-            new Region(new Rectangle(40, 100, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[]
-            {
-                new RectangleF(40, 100, 30, 20),
-                new RectangleF(120, 100, 20, 20),
-                new RectangleF(40, 120, 100, 80)
-            }
-        };
-
-        // Intersecting from the bottom.
-        yield return new object[]
-        {
-            new Region(new Rectangle(40, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[]
-            {
-                new RectangleF(40, 10, 100, 70),
-                new RectangleF(40, 80, 30, 30),
-                new RectangleF(120, 80, 20, 30)
-            }
-        };
-
-        // Multiple regions.
-        yield return new object[]
-        {
-            new Region(new Rectangle(30, 30, 80, 80)),
-            new RectangleF[]
-            {
-                new RectangleF(45, 45, 200, 200),
-                new RectangleF(160, 260, 10, 10),
-                new RectangleF(170, 260, 10, 10)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(30, 30, 80, 15),
-                new RectangleF(30, 45, 15, 65)
-            }
-        };
-
-        // Intersecting from the top with a larger rect.
-        yield return new object[]
-        {
-            new Region(new Rectangle(50, 100, 100, 100)),
-            new RectangleF[] { new RectangleF(30, 70, 150, 40) },
-            new RectangleF[] { new RectangleF(50, 110, 100, 90) }
-        };
-
-        // Intersecting from the right with a larger rect.
-        yield return new object[]
-        {
-            new Region(new Rectangle(70, 60, 100, 70)),
-            new RectangleF[] { new RectangleF(40, 10, 100, 150) },
-            new RectangleF[] { new RectangleF(140, 60, 30, 70) }
-        };
-
-        // Intersecting from the left with a larger rect.
-        yield return new object[]
-        {
-            new Region(new Rectangle(70, 60, 100, 70)),
-            new RectangleF[] { new RectangleF(100, 10, 100, 150) },
-            new RectangleF[] { new RectangleF(70, 60, 30, 70) }
-        };
-
-        // Intersecting from the bottom with a larger rect.
-        yield return new object[]
-        {
-            new Region(new Rectangle(20, 20, 100, 100)),
-            new RectangleF[] { new RectangleF(10, 80, 140, 150) },
-            new RectangleF[] { new RectangleF(20, 20, 100, 60) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(130, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(170, 40, 60, 80) },
-            new RectangleF[]
-            {
-                new RectangleF(130, 30, 60, 10),
-                new RectangleF(130, 40, 40, 70)
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Exclude_TestData))]
-    public void Exclude_Region_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var other = new Region(rect))
-                {
-                    region.Exclude(other);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Exclude_UnionRegion_Success()
-    {
-        using (var region = new Region(new RectangleF(20, 20, 20, 20)))
-        using (var union = new Region(new RectangleF(20, 80, 20, 10)))
-        using (var matrix = new Matrix())
-        {
-            union.Union(new RectangleF(60, 60, 30, 10));
-            region.Exclude(union);
-            Assert.Equal(new RectangleF[] { new RectangleF(20, 20, 20, 20) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Exclude_InfiniteRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var other = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Exclude(other);
-            Assert.Equal(new RectangleF[0], region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Exclude_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Exclude((Region)null));
-        }
-    }
-
-    [Fact]
-    public void Exclude_DisposedRegion_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Region().Exclude(CreateDisposedRegion()));
-    }
-
-    [Fact]
-    public void Exclude_SameRegion_ThrowsInvalidOperationException()
-    {
-        using (var region = new Region())
-        {
-            Assert.Throws<InvalidOperationException>(() => region.Exclude(region));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Exclude_TestData))]
-    public void Exclude_Rectangle_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Exclude(new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Exclude_TestData))]
-    public void Exclude_RectangleF_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Exclude(rect);
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Exclude_TestData))]
-    public void Exclude_GraphicsPath_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var path = new GraphicsPath())
-                {
-                    path.AddRectangle(rect);
-                    region.Exclude(path);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Exclude_EmptyPathWithInfiniteRegion_MakesInfinite()
-    {
-        using (var region = new Region())
-        using (var graphicsPath = new GraphicsPath())
-        {
-            region.Exclude(graphicsPath);
-            Assert.True(region.IsInfinite(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Exclude_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => region.Exclude((GraphicsPath)null));
-        }
-    }
-
-    [Fact]
-    public void Exclude_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        using (var graphicsPath = new GraphicsPath())
-        using (var other = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Exclude(graphicsPath));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Exclude(new Rectangle()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Exclude(new RectangleF()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Exclude(other));
-        }
-    }
-
-    [Fact]
-    public void FromHrgn_ValidHrgn_ReturnsExpected()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        {
-            IntPtr handle1 = region.GetHrgn(s_graphic);
-            IntPtr handle2 = region.GetHrgn(s_graphic);
-            Assert.NotEqual(IntPtr.Zero, handle1);
-            Assert.NotEqual(handle1, handle2);
-
-            Region newRegion = Region.FromHrgn(handle1);
-            IntPtr handle3 = newRegion.GetHrgn(s_graphic);
-            Assert.NotEqual(handle3, handle1);
-            Assert.Equal(new RectangleF(1, 2, 3, 4), newRegion.GetBounds(s_graphic));
-
-            region.ReleaseHrgn(handle1);
-            region.ReleaseHrgn(handle2);
-            newRegion.ReleaseHrgn(handle3);
-        }
-    }
-
-    [Fact]
-    public void FromHrgn_ZeroHrgn_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => Region.FromHrgn(IntPtr.Zero));
-    }
-
-    [Fact]
-    public void GetHrgn_Infinite_ReturnsZero()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        {
-            IntPtr handle = region.GetHrgn(s_graphic);
-            Assert.NotEqual(IntPtr.Zero, handle);
-            region.ReleaseHrgn(handle);
-
-            region.MakeInfinite();
-            Assert.Equal(IntPtr.Zero, region.GetHrgn(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void GetHrgn_Empty_ReturnsNonZero()
-    {
-        using (var region = new Region())
-        {
-            Assert.Equal(IntPtr.Zero, region.GetHrgn(s_graphic));
-
-            region.MakeEmpty();
-            IntPtr handle = region.GetHrgn(s_graphic);
-            Assert.NotEqual(IntPtr.Zero, handle);
-            region.ReleaseHrgn(handle);
-        }
-    }
-
-    [Fact]
-    public void GetHrgn_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("g", () => region.GetHrgn(null));
-        }
-    }
-
-    [Fact]
-    public void GetHrgn_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().GetHrgn(s_graphic));
-    }
-
-    [Fact]
-    public void ReleaseHrgn_ZeroHandle_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("regionHandle", () => region.ReleaseHrgn(IntPtr.Zero));
-        }
-    }
-
-    [Fact]
-    public void GetBounds_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("g", () => region.GetBounds(null));
-        }
-    }
-
-    [Fact]
-    public void GetBounds_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        using (var image = new Bitmap(10, 10))
-        {
-            var graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-            AssertExtensions.Throws<ArgumentException>(null, () => region.GetBounds(graphics));
-        }
-    }
-
-    [Fact]
-    public void GetBounds_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().GetBounds(s_graphic));
-    }
-
-    [Fact]
-    public void GetRegionData_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().GetRegionData());
-    }
-
-    [Fact]
-    public void GetRegionScans_CustomMatrix_TransformsRegionScans()
-    {
-        using (var matrix = new Matrix())
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var emptyMatrix = new Matrix())
-        {
-            matrix.Translate(10, 11);
-            matrix.Scale(5, 6);
-
-            Assert.Equal(new RectangleF[] { new RectangleF(1, 2, 3, 4) }, region.GetRegionScans(emptyMatrix));
-            Assert.Equal(new RectangleF[] { new RectangleF(15, 23, 15, 24) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void GetRegionScans_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => region.GetRegionScans(null));
-        }
-    }
-
-    [Fact]
-    public void GetRegionScans_Disposed_ThrowsArgumentException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void GetRegionScans_DisposedMatrix_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-            AssertExtensions.Throws<ArgumentException>(null, () => region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Intersect_SmallerRect_Success()
-    {
-        using (var clipRegion = new Region())
-        using (var matrix = new Matrix())
-        {
-            Rectangle smaller = new Rectangle(5, 5, -10, -10);
-
-            clipRegion.Intersect(smaller);
-            Assert.False(clipRegion.IsEmpty(s_graphic));
-            Assert.False(clipRegion.IsInfinite(s_graphic));
-
-            RectangleF[] rects = clipRegion.GetRegionScans(matrix);
-            Assert.Equal(1, rects.Length);
-            Assert.Equal(new RectangleF(-5, -5, 10, 10), rects[0]);
-        }
-    }
-
-    public static IEnumerable<object[]> Intersect_TestData()
-    {
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-        yield return new object[]
-        {
-            new Region(new Rectangle(0, 0, 0, 0)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { new RectangleF(520, 40, 60, 80) },
-            new RectangleF[] { new Rectangle(520, 40, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(260, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(290, 40, 60, 90) },
-            new RectangleF[] { new RectangleF(290, 40, 30, 70) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(20, 330, 40, 50)),
-            new RectangleF[]
-            {
-                new RectangleF(50, 340, 40, 50),
-                new RectangleF(70, 360, 30, 50),
-                new RectangleF(80, 400, 30, 10)
-            },
-            new RectangleF[0]
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Intersect_TestData))]
-    public void Intersect_Region_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var rectangleRegion = new Region(rect))
-                {
-                    region.Intersect(rectangleRegion);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Intersect_InfiniteRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        using (var infiniteRegion = new Region())
-        {
-            region.Intersect(infiniteRegion);
-
-            Assert.Equal(new RectangleF[] { new Rectangle(1, 2, 3, 4) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Intersect_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Intersect((Region)null));
-        }
-    }
-
-    [Fact]
-    public void Intersect_DisposedRegion_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => new Region().Intersect(CreateDisposedRegion()));
-    }
-
-    [Fact]
-    public void Intersect_SameRegion_ThrowsInvalidOperationException()
-    {
-        using (var region = new Region())
-        {
-            Assert.Throws<InvalidOperationException>(() => region.Intersect(region));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Intersect_TestData))]
-    public void Intersect_Rectangle_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Intersect(new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Intersect_InfiniteRegionWithSmallerRectangle_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Intersect(new Rectangle(5, 5, -10, -10));
-
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-5, -5, 10, 10) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Intersect_TestData))]
-    public void Intersect_RectangleF_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Intersect(rect);
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Intersect_InfiniteRegionWithSmallerRectangleF_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Intersect(new RectangleF(5, 5, -10, -10));
-
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-5, -5, 10, 10) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Intersect_TestData))]
-    public void Intersect_GraphicsPath_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var path = new GraphicsPath())
-                {
-                    path.AddRectangle(rect);
-                    region.Intersect(path);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Intersect_EmptyPathWithInfiniteRegion_MakesEmpty()
-    {
-        using (var region = new Region())
-        using (var graphicsPath = new GraphicsPath())
-        {
-            region.Intersect(graphicsPath);
-            Assert.True(region.IsEmpty(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Intersect_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => region.Intersect((GraphicsPath)null));
-        }
-    }
-
-    [Fact]
-    public void Intersect_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        using (var graphicsPath = new GraphicsPath())
-        using (var other = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Intersect(graphicsPath));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Intersect(new Rectangle()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Intersect(new RectangleF()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Intersect(other));
-        }
-    }
-
-    [Fact]
-    public void IsEmpty_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("g", () => region.IsEmpty(null));
-        }
-    }
-
-    [Fact]
-    public void IsEmpty_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().IsEmpty(s_graphic));
-    }
-
-    [Fact]
-    public void IsInfinite_NullGraphics_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("g", () => region.IsInfinite(null));
-        }
-    }
-
-    [Fact]
-    public void IsInfinite_DisposedGraphics_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        using (var image = new Bitmap(10, 10))
-        {
-            var graphics = Graphics.FromImage(image);
-            graphics.Dispose();
-            AssertExtensions.Throws<ArgumentException>(null, () => region.IsInfinite(graphics));
-        }
-    }
-
-    [Fact]
-    public void IsInfinite_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().IsInfinite(s_graphic));
-    }
-
-    public static IEnumerable<object[]> IsVisible_Rectangle_TestData()
-    {
-        var infiniteExclude = new Region();
-        infiniteExclude.Exclude(new Rectangle(387, 292, 189, 133));
-        infiniteExclude.Exclude(new Rectangle(387, 66, 189, 133));
-
-        yield return new object[] { infiniteExclude, new Rectangle(66, 292, 189, 133), true };
-        yield return new object[] { new Region(), Rectangle.Empty, false };
-
-        yield return new object[] { new Region(new Rectangle(0, 0, 10, 10)), new Rectangle(0, 0, 0, 1), false };
-        yield return new object[] { new Region(new Rectangle(500, 30, 60, 80)), new Rectangle(500, 30, 60, 80), true };
-        yield return new object[] { new Region(new Rectangle(500, 30, 60, 80)), new Rectangle(520, 40, 60, 80), true };
-
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(1, 1, 2, 1), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(1, 1, 2, 2), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(1, 1, 10, 10), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(1, 1, 1, 1), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(2, 2, 1, 1), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(0, 0, 1, 1), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Rectangle(3, 3, 1, 1), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsVisible_Rectangle_TestData))]
-    public void IsVisible_Rectangle_ReturnsExpected(Region region, Rectangle rectangle, bool expected)
-    {
-        using (region)
-        using (var image = new Bitmap(10, 10))
-        {
-            var disposedGraphics = Graphics.FromImage(image);
-            disposedGraphics.Dispose();
-
-            Assert.Equal(expected, region.IsVisible(rectangle));
-            Assert.Equal(expected, region.IsVisible((RectangleF)rectangle));
-            Assert.Equal(expected, region.IsVisible(rectangle, s_graphic));
-            Assert.Equal(expected, region.IsVisible(rectangle, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible(rectangle, null));
-            Assert.Equal(expected, region.IsVisible((RectangleF)rectangle, s_graphic));
-            Assert.Equal(expected, region.IsVisible((RectangleF)rectangle, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible((RectangleF)rectangle, null));
-
-            Assert.Equal(expected, region.IsVisible(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height));
-            Assert.Equal(expected, region.IsVisible((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height));
-            Assert.Equal(expected, region.IsVisible(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, s_graphic));
-            Assert.Equal(expected, region.IsVisible(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, null));
-            Assert.Equal(expected, region.IsVisible((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, s_graphic));
-            Assert.Equal(expected, region.IsVisible((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, null));
-        }
-    }
-
-    public static IEnumerable<object[]> IsVisible_Point_TestData()
-    {
-        var infiniteExclude = new Region();
-        infiniteExclude.Exclude(new Rectangle(387, 292, 189, 133));
-        infiniteExclude.Exclude(new Rectangle(387, 66, 189, 133));
-
-        yield return new object[] { infiniteExclude, new Point(66, 292), true };
-        yield return new object[] { new Region(), Point.Empty, true };
-
-        yield return new object[] { new Region(new Rectangle(500, 30, 60, 80)), new Point(500, 29), false };
-        yield return new object[] { new Region(new Rectangle(500, 30, 60, 80)), new Point(500, 30), true };
-
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(0, 1), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(1, 0), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(2, 0), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(3, 0), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(1, 1), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(2, 1), true };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(3, 1), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(0, 2), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(2, 2), false };
-        yield return new object[] { new Region(new Rectangle(1, 1, 2, 1)), new Point(3, 2), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsVisible_Point_TestData))]
-    public void IsVisible_Point_ReturnsExpected(Region region, Point point, bool expected)
-    {
-        using (region)
-        using (var image = new Bitmap(10, 10))
-        {
-            var disposedGraphics = Graphics.FromImage(image);
-            disposedGraphics.Dispose();
-
-            Assert.Equal(expected, region.IsVisible(point));
-            Assert.Equal(expected, region.IsVisible((PointF)point));
-            Assert.Equal(expected, region.IsVisible(point, s_graphic));
-            Assert.Equal(expected, region.IsVisible(point, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible(point, null));
-            Assert.Equal(expected, region.IsVisible((PointF)point, s_graphic));
-            Assert.Equal(expected, region.IsVisible((PointF)point, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible((PointF)point, null));
-
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y));
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, s_graphic));
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, null));
-
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, s_graphic));
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible(point.X, point.Y, null));
-            Assert.Equal(expected, region.IsVisible((float)point.X, point.Y, s_graphic));
-            Assert.Equal(expected, region.IsVisible((float)point.X, point.Y, disposedGraphics));
-            Assert.Equal(expected, region.IsVisible((float)point.X, point.Y, null));
-        }
-    }
-
-    [Fact]
-    public void IsVisible_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1f, 2f));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new PointF(1, 2)));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new Point(1, 2)));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1f, 2f, s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new PointF(1, 2), s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new Point(1, 2), s_graphic));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1f, 2f, 3f, 4f));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new Rectangle(1, 2, 3, 4)));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new RectangleF(1, 2, 3, 4)));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1f, 2f, 3f, 4f, s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new Rectangle(1, 2, 3, 4), s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(new RectangleF(1, 2, 3, 4), s_graphic));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1, 2, s_graphic));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1, 2, 3, 4));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.IsVisible(1, 2, 3, 4, s_graphic));
-    }
-
-    [Theory]
-    [MemberData(nameof(Region_TestData))]
-    public void MakeEmpty_NonEmpty_Success(Region region)
-    {
-        using (region)
-        {
-            region.MakeEmpty();
-            Assert.True(region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(RectangleF.Empty, region.GetBounds(s_graphic));
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Empty(region.GetRegionScans(matrix));
-            }
-
-            region.MakeEmpty();
-            Assert.True(region.IsEmpty(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void MakeEmpty_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().MakeEmpty());
-    }
-
-    [Theory]
-    [MemberData(nameof(Region_TestData))]
-    public void MakeInfinite_NonInfinity_Success(Region region)
-    {
-        using (region)
-        {
-            region.MakeInfinite();
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.True(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF(-4194304, -4194304, 8388608, 8388608), region.GetBounds(s_graphic));
-
-            region.MakeInfinite();
-            Assert.False(region.IsEmpty(s_graphic));
-            Assert.True(region.IsInfinite(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void MakeInfinite_Disposed_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().MakeInfinite());
-    }
-
-    public static IEnumerable<object[]> Union_TestData()
-    {
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(520, 30, 60, 80) },
-            new RectangleF[] { new RectangleF(500, 30, 80, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(520, 40, 60, 80) },
-            new RectangleF[]
-            {
-                new RectangleF(500, 30, 60, 10),
-                new RectangleF(500, 40, 80, 70),
-                new RectangleF(520, 110, 60, 10),
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { new RectangleF(520, 40, 60, 80) },
-            new RectangleF[] { new Rectangle(-4194304, -4194304, 8388608, 8388608) }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new Rectangle(-4194304, -4194304, 8388608, 8388608) }
-        };
-
-        // No intersecting rects.
-        yield return new object[]
-        {
-            new Region(new Rectangle(20, 20, 20, 20)),
-            new RectangleF[]
-            {
-                new RectangleF(20, 80, 20, 10),
-                new RectangleF(60, 60, 30, 10)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(20, 20, 20, 20),
-                new RectangleF(60, 60, 30, 10),
-                new RectangleF(20, 80, 20, 10)
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(20, 180, 40, 50)),
-            new RectangleF[]
-            {
-                new RectangleF(50, 190, 40, 50),
-                new RectangleF(70, 210, 30, 50)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(20, 180, 40, 10),
-                new RectangleF(20, 190, 70, 20),
-                new RectangleF(20, 210, 80, 20),
-                new RectangleF(50, 230, 50, 10),
-                new RectangleF(70, 240, 30, 20)
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(20, 330, 40, 50)),
-            new RectangleF[]
-            {
-                new RectangleF(50, 340, 40, 50),
-                new RectangleF(70, 360, 30, 50),
-                new RectangleF(80, 400, 30, 10)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(20, 330, 40, 10),
-                new RectangleF(20, 340, 70, 20),
-                new RectangleF(20, 360, 80, 20),
-                new RectangleF(50, 380, 50, 10),
-                new RectangleF(70, 390, 30, 10),
-                new RectangleF(70, 400, 40, 10)
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(new Rectangle(10, 20, 50, 50)),
-            new RectangleF[]
-            {
-                new RectangleF(100, 100, 60, 60),
-                new RectangleF(200, 200, 80, 80)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(10, 20, 50, 50),
-                new RectangleF(100, 100, 60, 60),
-                new RectangleF(200, 200, 80, 80)
-            }
-        };
-
-        // Intersecting from the right.
-        yield return new object[]
-        {
-            new Region(new Rectangle(10, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[]
-            {
-                new RectangleF(10, 10, 100, 50),
-                new RectangleF(10, 60, 130, 20),
-                new RectangleF(10, 80, 100, 30)
-            }
-        };
-
-        // Intersecting from the left.
-        yield return new object[]
-        {
-            new Region(new Rectangle(70, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(40, 60, 100, 20) },
-            new RectangleF[]
-            {
-                new RectangleF(70, 10, 100, 50),
-                new RectangleF(40, 60, 130, 20),
-                new RectangleF(70, 80, 100, 30)
-            }
-        };
-
-        // Intersecting from the top.
-        yield return new object[]
-        {
-            new Region(new Rectangle(40, 100, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[]
-            {
-                new RectangleF(70, 80, 50, 20),
-                new RectangleF(40, 100, 100, 100)
-            }
-        };
-
-        // Intersecting from the bottom.
-        yield return new object[]
-        {
-            new Region(new Rectangle(40, 10, 100, 100)),
-            new RectangleF[] { new RectangleF(70, 80, 50, 40) },
-            new RectangleF[]
-            {
-                new RectangleF(40, 10, 100, 100),
-                new RectangleF(70, 110, 50, 10)
-            }
-        };
-
-        // Multiple regions separated by 0 pixels.
-        yield return new object[]
-        {
-            new Region(new Rectangle(30, 30, 80, 80)),
-            new RectangleF[]
-            {
-                new RectangleF(45, 45, 200, 200),
-                new RectangleF(160, 260, 10, 10),
-                new RectangleF(170, 260, 10, 10)
-            },
-            new RectangleF[]
-            {
-                new RectangleF(30, 30, 80, 15),
-                new RectangleF(30, 45, 215, 65),
-                new RectangleF(45, 110, 200, 135),
-                new RectangleF(160, 260, 20, 10)
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Union_TestData))]
-    public void Union_Region_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var other = new Region(rect))
-                {
-                    region.Union(other);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Union_InfiniteRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var other = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Union(other);
-
-            Assert.Equal(new RectangleF[] { new Rectangle(-4194304, -4194304, 8388608, 8388608) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Union_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Union((Region)null));
-        }
-    }
-
-    [Fact]
-    public void Union_DisposedRegion_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => region.Union(CreateDisposedRegion()));
-        }
-    }
-
-    [Fact]
-    public void Union_SameRegion_ThrowsInvalidOperationException()
-    {
-        using (var region = new Region())
-        {
-            Assert.Throws<InvalidOperationException>(() => region.Union(region));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Union_TestData))]
-    public void Union_Rectangle_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Union(new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Union_TestData))]
-    public void Union_RectangleF_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Union(rect);
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Union_TestData))]
-    public void Union_GraphicsPath_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var path = new GraphicsPath())
-                {
-                    path.AddRectangle(rect);
-                    region.Union(path);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Union_EmptyPathWithInfiniteRegion_MakesInfinite()
-    {
-        using (var region = new Region())
-        using (var graphicsPath = new GraphicsPath())
-        {
-            region.Union(graphicsPath);
-            Assert.True(region.IsInfinite(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Union_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => region.Union((GraphicsPath)null));
-        }
-    }
-
-    [Fact]
-    public void Union_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        using (var graphicsPath = new GraphicsPath())
-        using (var other = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Union(graphicsPath));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Union(new Rectangle()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Union(new RectangleF()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Union(disposedRegion));
-        }
-    }
-
-    [Fact]
-    public void Transform_EmptyMatrix_Nop()
-    {
-        using (var region = new Region(new RectangleF(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        {
-            region.Transform(matrix);
-            Assert.Equal(new RectangleF[] { new RectangleF(1, 2, 3, 4) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Transform_CustomMatrix_Success()
-    {
-        using (var region = new Region(new RectangleF(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        using (var emptyMatrix = new Matrix())
-        {
-            matrix.Translate(10, 11);
-            matrix.Scale(5, 6);
-
-            region.Transform(matrix);
-            Assert.Equal(new RectangleF[] { new RectangleF(15, 23, 15, 24) }, region.GetRegionScans(emptyMatrix));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0, 0)]
-    [InlineData(2, 2, 0)]
-    [InlineData(0.5, 0.5, 0)]
-    [InlineData(1, 1, 45)]
-    public void Transform_Infinity_Nop(float scaleX, float scaleY, int angle)
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        using (var emptyMatrix = new Matrix())
-        {
-            matrix.Translate(10, 11);
-            matrix.Scale(scaleX, scaleY);
-            matrix.Rotate(angle);
-
-            region.Transform(matrix);
-            Assert.True(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-4194304, -4194304, 8388608, 8388608) }, region.GetRegionScans(emptyMatrix));
-        }
-    }
-
-    [Fact]
-    public void Transform_InfinityIntersectScale_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        using (var emptyMatrix = new Matrix())
-        {
-            matrix.Scale(2, 0.5f);
-
-            region.Intersect(new Rectangle(-10, -10, 20, 20));
-            region.Transform(matrix);
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-20, -5, 40, 10) }, region.GetRegionScans(emptyMatrix));
-        }
-    }
-
-    [Fact]
-    public void Transform_InfinityIntersectTransform_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix(2, 0, 0, 0.5f, 10, 10))
-        using (var emptyMatrix = new Matrix())
-        {
-            region.Intersect(new Rectangle(-10, -10, 20, 20));
-            region.Transform(matrix);
-
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-10, 5, 40, 10) }, region.GetRegionScans(emptyMatrix));
-        }
-    }
-
-    [Fact]
-    public void Transform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => region.Transform(null));
-        }
-    }
-
-    [Fact]
-    public void Transform_Disposed_ThrowsArgumentException()
-    {
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => CreateDisposedRegion().Transform(matrix));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(2, 3)]
-    [InlineData(-2, -3)]
-    public void Translate_Int_Success(float dx, float dy)
-    {
-        using (var region = new Region(new RectangleF(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        {
-            region.Translate(dx, dy);
-            Assert.Equal(new RectangleF[] { new RectangleF(1 + dx, 2 + dy, 3, 4) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Translate_IntInfinityIntersect_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Intersect(new Rectangle(-10, -10, 20, 20));
-            region.Translate(10, 10);
-
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(0, 0, 20, 20) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(2, 3)]
-    public void Translate_Float_Success(int dx, int dy)
-    {
-        using (var region = new Region(new RectangleF(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        {
-            region.Translate(dx, dy);
-            Assert.Equal(new RectangleF[] { new RectangleF(1 + dx, 2 + dy, 3, 4) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Translate_FloatInfinityIntersect_Success()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Intersect(new Rectangle(-10, -10, 20, 20));
-            region.Translate(10f, 10f);
-
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(0, 0, 20, 20) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Translate_Infinity_Nop()
-    {
-        using (var region = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Translate(10, 10);
-            region.Translate(10f, 10f);
-
-            Assert.True(region.IsInfinite(s_graphic));
-            Assert.Equal(new RectangleF[] { new RectangleF(-4194304, -4194304, 8388608, 8388608) }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Theory]
-    [InlineData(float.MaxValue)]
-    [InlineData(float.MinValue)]
-    [InlineData(float.NaN)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void Translate_InvalidFloatValue_EmptiesRegion(float f)
-    {
-        using (var region = new Region(new RectangleF(1, 2, 3, 4)))
-        using (var matrix = new Matrix())
-        {
-            region.Translate(f, 0);
-
-            Assert.True(region.IsEmpty(s_graphic));
-            Assert.False(region.IsInfinite(s_graphic));
-            Assert.Empty(region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Translate_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Translate(1, 2));
-        AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Translate(1f, 2f));
-    }
-
-    public static IEnumerable<object[]> Xor_TestData()
-    {
-        yield return new object[]
-        {
-            new Region(new RectangleF(500, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[0]
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(500, 30, 60, 80)),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(0, 0, 0, 0)),
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) },
-            new RectangleF[] { new RectangleF(500, 30, 60, 80) }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { new RectangleF(520, 40, 60, 80) },
-            new RectangleF[]
-            {
-                new RectangleF(-4194304, -4194304, 8388608, 4194344),
-                new RectangleF(-4194304, 40, 4194824, 80),
-                new RectangleF(580, 40, 4193724, 80),
-                new RectangleF(-4194304, 120, 8388608, 4194184)
-            }
-        };
-
-        yield return new object[]
-        {
-            new Region(),
-            new RectangleF[] { RectangleF.Empty },
-            new RectangleF[] { new Rectangle(-4194304, -4194304, 8388608, 8388608) }
-        };
-
-        yield return new object[]
-        {
-            new Region(new RectangleF(380, 30, 60, 80)),
-            new RectangleF[] { new RectangleF(410, 40, 60, 80) },
-            new RectangleF[]
-            {
-                new RectangleF(380, 30, 60, 10),
-                new RectangleF(380, 40, 30, 70),
-                new RectangleF(440, 40, 30, 70),
-                new RectangleF(410, 110, 60, 10)
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Xor_TestData))]
-    public void Xor_Region_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var other = new Region(rect))
-                {
-                    region.Xor(other);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Xor_InfiniteRegion_Success()
-    {
-        using (var region = new Region(new Rectangle(1, 2, 3, 4)))
-        using (var other = new Region())
-        using (var matrix = new Matrix())
-        {
-            region.Xor(other);
-
-            Assert.Equal(new RectangleF[]
-            {
-                new RectangleF(-4194304, -4194304, 8388608, 4194306),
-                new RectangleF(-4194304, 2, 4194305, 4),
-                new RectangleF(4, 2, 4194300, 4),
-                new RectangleF(-4194304, 6, 8388608, 4194298)
-            }, region.GetRegionScans(matrix));
-        }
-    }
-
-    [Fact]
-    public void Xor_NullRegion_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("region", () => region.Xor((Region)null));
-        }
-    }
-
-    [Fact]
-    public void Xor_DisposedRegion_ThrowsArgumentException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => region.Xor(CreateDisposedRegion()));
-        }
-    }
-
-    [Fact]
-    public void Xor_SameRegion_ThrowsInvalidOperationException()
-    {
-        using (var region = new Region())
-        {
-            Assert.Throws<InvalidOperationException>(() => region.Xor(region));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Xor_TestData))]
-    public void Xor_Rectangle_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Xor(new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Xor_TestData))]
-    public void Xor_RectangleF_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                region.Xor(rect);
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Xor_TestData))]
-    public void Xor_GraphicsPath_Success(Region region, RectangleF[] rectangles, RectangleF[] expectedScans)
-    {
-        using (region)
-        {
-            foreach (RectangleF rect in rectangles)
-            {
-                using (var path = new GraphicsPath())
-                {
-                    path.AddRectangle(rect);
-                    region.Xor(path);
-                }
-            }
-
-            using (var matrix = new Matrix())
-            {
-                Assert.Equal(expectedScans, region.GetRegionScans(matrix));
-            }
-        }
-    }
-
-    [Fact]
-    public void Xor_EmptyPathWithInfiniteRegion_MakesInfinite()
-    {
-        using (var region = new Region())
-        using (var graphicsPath = new GraphicsPath())
-        {
-            region.Xor(graphicsPath);
-            Assert.True(region.IsInfinite(s_graphic));
-        }
-    }
-
-    [Fact]
-    public void Xor_NullGraphicsPath_ThrowsArgumentNullException()
-    {
-        using (var region = new Region())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("path", () => region.Xor((GraphicsPath)null));
-        }
-    }
-
-    [Fact]
-    public void Xor_Disposed_ThrowsArgumentException()
-    {
-        Region disposedRegion = CreateDisposedRegion();
-
-        using (var graphicsPath = new GraphicsPath())
-        using (var other = new Region())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Xor(graphicsPath));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Xor(new Rectangle()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Xor(new RectangleF()));
-            AssertExtensions.Throws<ArgumentException>(null, () => disposedRegion.Xor(other));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/SolidBrushTests.cs b/src/System.Drawing.Common/tests/SolidBrushTests.cs
deleted file mode 100644
index 03102d662c4..00000000000
--- a/src/System.Drawing.Common/tests/SolidBrushTests.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class SolidBrushTests
-{
-    public static IEnumerable<object[]> Colors_TestData()
-    {
-        yield return new object[] { new Color(), Color.FromArgb(0) };
-        yield return new object[] { Color.PapayaWhip, Color.PapayaWhip };
-    }
-
-    [Theory]
-    [MemberData(nameof(Colors_TestData))]
-    public void Ctor_Color(Color color, Color expectedColor)
-    {
-        var brush = new SolidBrush(color);
-        Assert.Equal(expectedColor, brush.Color);
-    }
-
-    [Fact]
-    public void Clone_Color_ReturnsClone()
-    {
-        var brush = new SolidBrush(Color.PeachPuff);
-        SolidBrush clone = Assert.IsType<SolidBrush>(brush.Clone());
-
-        Assert.NotSame(clone, brush);
-        Assert.Equal(brush.Color.ToArgb(), clone.Color.ToArgb());
-
-        // Known colors are not preserved across clones.
-        Assert.NotEqual(Color.PeachPuff, clone.Color);
-
-        // Modifying the original brush should not modify the clone.
-        brush.Color = Color.PapayaWhip;
-        Assert.NotEqual(Color.PapayaWhip, clone.Color);
-    }
-
-    [Fact]
-    public void Clone_ImmutableColor_ReturnsMutableClone()
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(Brushes.Bisque);
-        SolidBrush clone = Assert.IsType<SolidBrush>(brush.Clone());
-
-        clone.Color = SystemColors.AppWorkspace;
-        Assert.Equal(SystemColors.AppWorkspace, clone.Color);
-        Assert.Equal(Color.Bisque, brush.Color);
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var brush = new SolidBrush(Color.LavenderBlush);
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Clone());
-    }
-
-    [Fact]
-    public void Color_EmptyAndGetDisposed_ThrowsArgumentException()
-    {
-        var brush = new SolidBrush(new Color());
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Color);
-    }
-
-    [Fact]
-    public void Color_NonEmptyAndGetDisposed_ReturnsExpected()
-    {
-        var brush = new SolidBrush(Color.Aquamarine);
-        brush.Dispose();
-
-        Assert.Equal(Color.Aquamarine, brush.Color);
-    }
-
-    [Fact]
-    public void Color_SetValid_GetReturnsExpected()
-    {
-        var brush = new SolidBrush(Color.Goldenrod) { Color = Color.GhostWhite };
-        Assert.Equal(Color.GhostWhite, brush.Color);
-    }
-
-    [Fact]
-    public void Color_SetDisposed_ThrowsArgumentException()
-    {
-        var brush = new SolidBrush(new Color());
-        brush.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Color = Color.WhiteSmoke);
-    }
-
-    [Fact]
-    public void Color_SetImmutable_ThrowsArgumentException()
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(SystemBrushes.ActiveBorder);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Color = Color.AntiqueWhite);
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Success()
-    {
-        var brush = new SolidBrush(Color.Plum);
-        brush.Dispose();
-        brush.Dispose();
-    }
-
-    [Fact]
-    public void Dispose_SetImmutable_ThrowsArgumentException()
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(SystemBrushes.ActiveBorder);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Dispose());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/StringFormatTests.cs b/src/System.Drawing.Common/tests/StringFormatTests.cs
deleted file mode 100644
index 17820389de7..00000000000
--- a/src/System.Drawing.Common/tests/StringFormatTests.cs
+++ /dev/null
@@ -1,481 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Text;
-
-namespace System.Drawing.Tests;
-
-public class StringFormatTests
-{
-    private const int RandomLanguageCode = 10;
-    private const int EnglishLanguageCode = 2057;
-
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.Equal(StringAlignment.Near, format.Alignment);
-            Assert.Equal(0, format.DigitSubstitutionLanguage);
-            Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-            Assert.Equal((StringFormatFlags)0, format.FormatFlags);
-            Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-            Assert.Equal(StringAlignment.Near, format.LineAlignment);
-            Assert.Equal(StringTrimming.Character, format.Trimming);
-        }
-    }
-
-    [Theory]
-    [InlineData(StringFormatFlags.DirectionRightToLeft | StringFormatFlags.DirectionVertical)]
-    [InlineData((StringFormatFlags)(-1))]
-    public void Ctor_Options(StringFormatFlags options)
-    {
-        using (var format = new StringFormat(options))
-        {
-            Assert.Equal(StringAlignment.Near, format.Alignment);
-            Assert.Equal(0, format.DigitSubstitutionLanguage);
-            Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-            Assert.Equal(options, format.FormatFlags);
-            Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-            Assert.Equal(StringAlignment.Near, format.LineAlignment);
-            Assert.Equal(StringTrimming.Character, format.Trimming);
-        }
-    }
-
-    [Theory]
-    [InlineData(StringFormatFlags.DirectionRightToLeft | StringFormatFlags.DirectionVertical, RandomLanguageCode)]
-    [InlineData(StringFormatFlags.NoClip, EnglishLanguageCode)]
-    [InlineData((StringFormatFlags)(-1), -1)]
-    public void Ctor_Options_Language(StringFormatFlags options, int language)
-    {
-        using (var format = new StringFormat(options, language))
-        {
-            Assert.Equal(StringAlignment.Near, format.Alignment);
-            Assert.Equal(0, format.DigitSubstitutionLanguage);
-            Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-            Assert.Equal(options, format.FormatFlags);
-            Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-            Assert.Equal(StringAlignment.Near, format.LineAlignment);
-            Assert.Equal(StringTrimming.Character, format.Trimming);
-        }
-    }
-
-    [Fact]
-    public void Ctor_Format()
-    {
-        using (var original = new StringFormat(StringFormatFlags.NoClip, EnglishLanguageCode))
-        using (var format = new StringFormat(original))
-        {
-            Assert.Equal(StringAlignment.Near, format.Alignment);
-            Assert.Equal(0, format.DigitSubstitutionLanguage);
-            Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-            Assert.Equal(StringFormatFlags.NoClip, format.FormatFlags);
-            Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-            Assert.Equal(StringAlignment.Near, format.LineAlignment);
-            Assert.Equal(StringTrimming.Character, format.Trimming);
-
-            // The new format is a clone.
-            original.FormatFlags = StringFormatFlags.NoFontFallback;
-            Assert.Equal(StringFormatFlags.NoClip, format.FormatFlags);
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullFormat_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("format", () => new StringFormat(null));
-    }
-
-    [Fact]
-    public void Ctor_DisposedFormat_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new StringFormat(format));
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Success()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-        format.Dispose();
-    }
-
-    [Fact]
-    public void Clone_Valid_Success()
-    {
-        using (var original = new StringFormat(StringFormatFlags.NoClip, EnglishLanguageCode))
-        using (StringFormat format = Assert.IsType<StringFormat>(original.Clone()))
-        {
-            Assert.Equal(StringAlignment.Near, format.Alignment);
-            Assert.Equal(0, format.DigitSubstitutionLanguage);
-            Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-            Assert.Equal(StringFormatFlags.NoClip, format.FormatFlags);
-            Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-            Assert.Equal(StringAlignment.Near, format.LineAlignment);
-            Assert.Equal(StringTrimming.Character, format.Trimming);
-
-            // The new format is a clone.
-            original.FormatFlags = StringFormatFlags.NoFontFallback;
-            Assert.Equal(StringFormatFlags.NoClip, format.FormatFlags);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.Clone());
-    }
-
-    [Theory]
-    [InlineData(0, StringDigitSubstitute.None, 0)]
-    [InlineData(EnglishLanguageCode, StringDigitSubstitute.Traditional, EnglishLanguageCode)]
-    [InlineData(int.MaxValue, StringDigitSubstitute.Traditional + 1, 65535)]
-    [InlineData(-1, StringDigitSubstitute.User - 1, 65535)]
-    public void SetDigitSubstitution_Invoke_SetsProperties(int language, StringDigitSubstitute substitute, int expectedLanguage)
-    {
-        using (var format = new StringFormat())
-        {
-            format.SetDigitSubstitution(language, substitute);
-            Assert.Equal(expectedLanguage, format.DigitSubstitutionLanguage);
-            Assert.Equal(substitute, format.DigitSubstitutionMethod);
-        }
-    }
-
-    [Fact]
-    public void SetDigitSubstitution_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.SetDigitSubstitution(0, StringDigitSubstitute.None));
-    }
-
-    [Theory]
-    [InlineData(0, new float[0])]
-    [InlineData(10, new float[] { 1, 2.3f, 4, float.PositiveInfinity, float.NaN })]
-    public void SetTabStops_GetTabStops_ReturnsExpected(float firstTabOffset, float[] tabStops)
-    {
-        using (var format = new StringFormat())
-        {
-            format.SetTabStops(firstTabOffset, tabStops);
-
-            Assert.Equal(tabStops, format.GetTabStops(out float actualFirstTabOffset));
-            Assert.Equal(firstTabOffset, actualFirstTabOffset);
-        }
-    }
-
-    [Fact]
-    public void SetTabStops_NullTabStops_ThrowsNullReferenceException()
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.Throws<NullReferenceException>(() => format.SetTabStops(0, null));
-        }
-    }
-
-    [Fact]
-    public void SetTabStops_NegativeFirstTabOffset_ThrowsArgumentException()
-    {
-        using (var format = new StringFormat())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => format.SetTabStops(-1, new float[0]));
-        }
-    }
-
-    [Fact]
-    public void SetTabStops_NegativeInfinityInTabStops_ThrowsNotImplementedException()
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.Throws<NotImplementedException>(() => format.SetTabStops(0, new float[] { float.NegativeInfinity }));
-        }
-    }
-
-    [Fact]
-    public void SetTabStops_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.SetTabStops(0, new float[0]));
-    }
-
-    [Fact]
-    public void GetTabStops_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.GetTabStops(out float firstTabOffset));
-    }
-
-    public static IEnumerable<object[]> SetMeasurableCharacterRanges_TestData()
-    {
-        yield return new object[] { new CharacterRange[0] };
-        yield return new object[] { new CharacterRange[] { new CharacterRange(1, 2) } };
-        yield return new object[] { new CharacterRange[] { new CharacterRange(-1, -1) } };
-        yield return new object[] { new CharacterRange[32] };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetMeasurableCharacterRanges_TestData))]
-    public void SetMeasurableCharacterRanges_Valid_Success(CharacterRange[] ranges)
-    {
-        using (var format = new StringFormat())
-        {
-            format.SetMeasurableCharacterRanges(ranges);
-        }
-    }
-
-    [Fact]
-    public void SetMeasurableCharacterRanges_NullRanges_ThrowsNullReferenceException()
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.Throws<NullReferenceException>(() => format.SetMeasurableCharacterRanges(null));
-        }
-    }
-
-    [Fact]
-    public void SetMeasurableCharacterRanges_RangesTooLarge_ThrowsOverflowException()
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.Throws<OverflowException>(() => format.SetMeasurableCharacterRanges(new CharacterRange[33]));
-        }
-    }
-
-    [Fact]
-    public void SetMeasurableCharacterRanges_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.SetMeasurableCharacterRanges(new CharacterRange[0]));
-    }
-
-    [Theory]
-    [InlineData(StringAlignment.Center)]
-    [InlineData(StringAlignment.Far)]
-    [InlineData(StringAlignment.Near)]
-    public void Alignment_SetValid_GetReturnsExpected(StringAlignment alignment)
-    {
-        using (var format = new StringFormat { Alignment = alignment })
-        {
-            Assert.Equal(alignment, format.Alignment);
-        }
-    }
-
-    [Theory]
-    [InlineData(StringAlignment.Near - 1)]
-    [InlineData(StringAlignment.Far + 1)]
-    public void Alignment_SetInvalid_ThrowsInvalidEnumArgumentException(StringAlignment alignment)
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.ThrowsAny<ArgumentException>(() => format.Alignment = alignment);
-        }
-    }
-
-    [Fact]
-    public void Alignment_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.Alignment);
-        AssertExtensions.Throws<ArgumentException>(null, () => format.Alignment = StringAlignment.Center);
-    }
-
-    [Fact]
-    public void DigitSubstitutionMethod_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.DigitSubstitutionMethod);
-    }
-
-    [Fact]
-    public void DigitSubstitutionLanguage_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.DigitSubstitutionLanguage);
-    }
-
-    [Theory]
-    [InlineData(StringFormatFlags.DirectionRightToLeft)]
-    [InlineData((StringFormatFlags)int.MinValue)]
-    [InlineData((StringFormatFlags)int.MaxValue)]
-    public void FormatFlags_Set_GetReturnsExpected(StringFormatFlags formatFlags)
-    {
-        using (var format = new StringFormat { FormatFlags = formatFlags })
-        {
-            Assert.Equal(formatFlags, format.FormatFlags);
-        }
-    }
-
-    [Fact]
-    public void FormatFlags_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.FormatFlags);
-        AssertExtensions.Throws<ArgumentException>(null, () => format.FormatFlags = StringFormatFlags.NoClip);
-    }
-
-    [Theory]
-    [InlineData(StringAlignment.Center)]
-    [InlineData(StringAlignment.Far)]
-    [InlineData(StringAlignment.Near)]
-    public void LineAlignment_SetValid_GetReturnsExpected(StringAlignment alignment)
-    {
-        using (var format = new StringFormat { LineAlignment = alignment })
-        {
-            Assert.Equal(alignment, format.LineAlignment);
-        }
-    }
-
-    [Theory]
-    [InlineData(StringAlignment.Near - 1)]
-    [InlineData(StringAlignment.Far + 1)]
-    public void LineAlignment_SetInvalid_ThrowsInvalidEnumArgumentException(StringAlignment alignment)
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.ThrowsAny<ArgumentException>(() => format.LineAlignment = alignment);
-        }
-    }
-
-    [Fact]
-    public void LineAlignment_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.LineAlignment);
-        AssertExtensions.Throws<ArgumentException>(null, () => format.LineAlignment = StringAlignment.Center);
-    }
-
-    [Theory]
-    [InlineData(HotkeyPrefix.Hide)]
-    [InlineData(HotkeyPrefix.None)]
-    [InlineData(HotkeyPrefix.Show)]
-    public void HotKeyPrefix_SetValid_GetReturnsExpected(HotkeyPrefix prefix)
-    {
-        using (var format = new StringFormat { HotkeyPrefix = prefix })
-        {
-            Assert.Equal(prefix, format.HotkeyPrefix);
-        }
-    }
-
-    [Theory]
-    [InlineData(HotkeyPrefix.None - 1)]
-    [InlineData(HotkeyPrefix.Hide + 1)]
-    public void HotKeyPrefix_SetInvalid_ThrowsInvalidEnumArgumentException(HotkeyPrefix prefix)
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.ThrowsAny<ArgumentException>(() => format.HotkeyPrefix = prefix);
-        }
-    }
-
-    [Fact]
-    public void HotkeyPrefix_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.HotkeyPrefix);
-        AssertExtensions.Throws<ArgumentException>(null, () => format.HotkeyPrefix = HotkeyPrefix.Hide);
-    }
-
-    [Theory]
-    [InlineData(StringTrimming.Word)]
-    public void Trimming_SetValid_GetReturnsExpected(StringTrimming trimming)
-    {
-        using (var format = new StringFormat { Trimming = trimming })
-        {
-            Assert.Equal(trimming, format.Trimming);
-        }
-    }
-
-    [Theory]
-    [InlineData(StringTrimming.None - 1)]
-    [InlineData(StringTrimming.EllipsisPath + 1)]
-    public void Trimming_SetInvalid_ThrowsInvalidEnumArgumentException(StringTrimming trimming)
-    {
-        using (var format = new StringFormat())
-        {
-            Assert.ThrowsAny<ArgumentException>(() => format.Trimming = trimming);
-        }
-    }
-
-    [Fact]
-    public void Trimming_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat();
-        format.Dispose();
-
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.Trimming);
-        AssertExtensions.Throws<ArgumentException>(null, () => format.Trimming = StringTrimming.Word);
-    }
-
-    [Fact]
-    public void GenericDefault_Get_ReturnsExpected()
-    {
-        StringFormat format = StringFormat.GenericDefault;
-        Assert.NotSame(format, StringFormat.GenericDefault);
-
-        Assert.Equal(StringAlignment.Near, format.Alignment);
-        Assert.Equal(0, format.DigitSubstitutionLanguage);
-        Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-        Assert.Equal((StringFormatFlags)0, format.FormatFlags);
-        Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-        Assert.Equal(StringAlignment.Near, format.LineAlignment);
-        Assert.Equal(StringTrimming.Character, format.Trimming);
-    }
-
-    [Fact]
-    public void GenericTypographic_Get_ReturnsExpected()
-    {
-        StringFormat format = StringFormat.GenericTypographic;
-        Assert.NotSame(format, StringFormat.GenericTypographic);
-
-        Assert.Equal(StringAlignment.Near, format.Alignment);
-        Assert.Equal(0, format.DigitSubstitutionLanguage);
-        Assert.Equal(StringDigitSubstitute.User, format.DigitSubstitutionMethod);
-        Assert.Equal(StringFormatFlags.FitBlackBox | StringFormatFlags.LineLimit | StringFormatFlags.NoClip, format.FormatFlags);
-        Assert.Equal(HotkeyPrefix.None, format.HotkeyPrefix);
-        Assert.Equal(StringAlignment.Near, format.LineAlignment);
-        Assert.Equal(StringTrimming.None, format.Trimming);
-    }
-
-    [Fact]
-    public void ToString_Flags_ReturnsExpected()
-    {
-        using (var format = new StringFormat(StringFormatFlags.DirectionVertical))
-        {
-            Assert.Equal("[StringFormat, FormatFlags=DirectionVertical]", format.ToString());
-        }
-    }
-
-    [Fact]
-    public void ToString_Disposed_ThrowsArgumentException()
-    {
-        var format = new StringFormat(StringFormatFlags.DirectionVertical);
-        format.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => format.ToString());
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System.Drawing.Common.Tests.csproj b/src/System.Drawing.Common/tests/System.Drawing.Common.Tests.csproj
deleted file mode 100644
index 856bcf159dc..00000000000
--- a/src/System.Drawing.Common/tests/System.Drawing.Common.Tests.csproj
+++ /dev/null
@@ -1,141 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Nullable>annotations</Nullable>
-    <!-- Code warnings that weren't enabled in dotnet/runtime but are raised in winforms.
-         TODO: Clean the code up and remove the NoWarns. -->
-    <NoWarn>$(NoWarn);CA1825;CA5351;CA1850</NoWarn>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <RdXmlFile Include="default.rd.xml" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Include="BitmapTests.cs" />
-    <Compile Include="BrushTests.cs" />
-    <Compile Include="BrushesTests.cs" />
-    <Compile Include="BufferedGraphicsTests.cs" />
-    <Compile Include="BufferedGraphicsContextTests.cs" />
-    <Compile Include="BufferedGraphicsManagerTests.cs" />
-    <Compile Include="CharacterRangeTests.cs" />
-    <Compile Include="ColorTranslatorTests.cs" />
-    <Compile Include="Drawing2D\AdjustableArrowCapTests.cs" />
-    <Compile Include="Drawing2D\CustomLineCapTests.cs" />
-    <Compile Include="Drawing2D\GraphicsPathIteratorTests.cs" />
-    <Compile Include="Drawing2D\GraphicsPathTests.cs" />
-    <Compile Include="Drawing2D\PathGradientBrushTests.cs" />
-    <Compile Include="DrawingTest.cs" />
-    <Compile Include="FontTests.cs" />
-    <Compile Include="FontFamilyTests.cs" />
-    <Compile Include="GdiPlusHandlesTests.cs" />
-    <Compile Include="GlobalUsings.cs" />
-    <Compile Include="GraphicsTests.cs" />
-    <Compile Include="Graphics_DrawBezierTests.cs" />
-    <Compile Include="Graphics_DrawLineTests.cs" />
-    <Compile Include="Graphics_GetContextTests.cs" />
-    <Compile Include="IconTests.cs" />
-    <Compile Include="ImageTests.cs" />
-    <Compile Include="Imaging\CachedBitmapTests.cs" />
-    <Compile Include="Imaging\ImageAttributesTests.cs" />
-    <Compile Include="Imaging\MetafileTests.cs" />
-    <Compile Include="Imaging\PropertyItemTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\BmpCodecTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\GifCodecTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\IconCodecTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\JpegCodecTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\PngCodecTests.cs" />
-    <Compile Include="mono\System.Drawing.Imaging\TiffCodecTests.cs" />
-    <Compile Include="mono\System.Drawing\GraphicsTests.cs" />
-    <Compile Include="mono\System.Imaging\MetafileTest.cs" />
-    <Compile Include="mono\System.Drawing\BitmapTests.cs" />
-    <Compile Include="PenTests.cs" />
-    <Compile Include="PensTests.cs" />
-    <Compile Include="Imaging\BitmapDataTests.cs" />
-    <Compile Include="Imaging\ColorMapTests.cs" />
-    <Compile Include="Imaging\ColorMatrixTests.cs" />
-    <Compile Include="Imaging\EncoderParametersTests.cs" />
-    <Compile Include="Imaging\EncoderParameterTests.cs" />
-    <Compile Include="Imaging\EncoderTests.cs" />
-    <Compile Include="Imaging\FrameDimensionTests.cs" />
-    <Compile Include="Imaging\ImageCodecInfoTests.cs" />
-    <Compile Include="Imaging\ImageFormatTests.cs" />
-    <Compile Include="Imaging\MetaHeaderTests.cs" />
-    <Compile Include="Imaging\WmfPlaceableFileHeaderTests.cs" />
-    <Compile Include="Printing\PrintControllerTests.cs" />
-    <Compile Include="Printing\PrintDocumentTests.cs" />
-    <Compile Include="Printing\PrinterSettingsTests.cs" />
-    <Compile Include="Printing\PreviewPrintControllerTests.cs" />
-    <Compile Include="RegionTests.cs" />
-    <Compile Include="SolidBrushTests.cs" />
-    <Compile Include="StringFormatTests.cs" />
-    <Compile Include="SystemBrushesTests.cs" />
-    <Compile Include="SystemFontsTests.cs" />
-    <Compile Include="SystemIconsTests.cs" />
-    <Compile Include="SystemPensTest.cs" />
-    <Compile Include="System\Drawing\ImageAnimator.ManualTests.cs" />
-    <Compile Include="System\Drawing\ImageAnimatorTests.cs" />
-    <Compile Include="TextureBrushTests.cs" />
-    <Compile Include="ToolboxBitmapAttributeTests.cs" />
-    <Compile Include="Design\CategoryNameCollectionTests.cs" />
-    <Compile Include="Drawing2D\BlendTests.cs" />
-    <Compile Include="Drawing2D\ColorBlendTests.cs" />
-    <Compile Include="Drawing2D\HatchBrushTests.cs" />
-    <Compile Include="Drawing2D\LinearGradientBrushTests.cs" />
-    <Compile Include="Drawing2D\MatrixTests.cs" />
-    <Compile Include="System\Drawing\FontConverterTests.cs" />
-    <Compile Include="System\Drawing\IconConverterTests.cs" />
-    <Compile Include="System\Drawing\ImageConverterTests.cs" />
-    <Compile Include="System\Drawing\ImageFormatConverterTests.cs" />
-    <Compile Include="System\Drawing\Printing\MarginsConverterTests.cs" />
-    <Compile Include="Text\InstalledFontCollectionTests.cs" />
-    <Compile Include="Text\PrivateFontCollectionTests.cs" />
-    <Compile Include="Printing\MarginsTests.cs" />
-    <Compile Include="Printing\PrinterResolutionTests.cs" />
-    <Compile Include="Printing\PageSettingsTests.cs" />
-    <Compile Include="Printing\PaperSizeTests.cs" />
-    <Compile Include="Printing\PaperSourceTests.cs" />
-    <Compile Include="Printing\PrinterUnitConvertTests.cs" />
-    <Compile Include="Helpers.cs" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Compile Include="GraphicsTests.Core.cs" />
-    <Compile Include="Graphics_GetContextTests.Core.cs" />
-    <Compile Include="Drawing2D\MatrixTests.Core.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Include="$(PkgSystem_Drawing_Common_TestData)\contentFiles\any\any\bitmaps\48x48_multiple_entries_4bit.ico">
-      <LogicalName>System.Drawing.Tests.48x48_multiple_entries_4bit.ico</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="$(PkgSystem_Drawing_Common_TestData)\contentFiles\any\any\bitmaps\bitmap_173x183_indexed_8bit.bmp">
-      <LogicalName>System.Drawing.Tests.bitmap_173x183_indexed_8bit.bmp</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="$(PkgSystem_Drawing_Common_TestData)\contentFiles\any\any\bitmaps\empty.file">
-      <LogicalName>System.Drawing.Tests.empty.file</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="$(PkgSystem_Drawing_Common_TestData)\contentFiles\any\any\bitmaps\invalid.ico">
-      <LogicalName>System.Drawing.Tests.invalid.ico</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="$(PkgSystem_Drawing_Common_TestData)\contentFiles\any\any\bitmaps\256x256_one_entry_32bit.ico">
-      <LogicalName>System.Drawing.Tests.Icon_toolboxBitmapAttributeTest</LogicalName>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="runtimeconfig.template.json" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\src\System.Drawing.Common.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.Primitives\tests\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-
-    <PackageReference Include="System.Drawing.Common.TestData" Version="$(SystemDrawingCommonTestDataVersion)" GeneratePathProperty="true" />
-    <PackageReference Include="System.ComponentModel.TypeConverter.TestData" Version="$(SystemComponentModelTypeConverterTestDataVersion)" />
-    <PackageReference Include="System.Windows.Extensions.TestData" Version="$(SystemWindowsExtensionsTestDataVersion)" />
-  </ItemGroup>
-</Project>
diff --git a/src/System.Drawing.Common/tests/System/Drawing/FontConverterTests.cs b/src/System.Drawing.Common/tests/System/Drawing/FontConverterTests.cs
deleted file mode 100644
index 083f7a4ef7a..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/FontConverterTests.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Drawing.Text;
-using System.Globalization;
-using static System.Drawing.FontConverter;
-
-namespace System.ComponentModel.TypeConverterTests;
-
-public class FontNameConverterTest
-{
-    [Fact]
-    public void TestConvertFrom()
-    {
-        FontConverter.FontNameConverter converter = new FontConverter.FontNameConverter();
-        // returns "Times" under Linux and "Times New Roman" under Windows
-        if (PlatformDetection.IsWindows)
-        {
-            Assert.Equal("Times New Roman", converter.ConvertFrom("Times") as string);
-        }
-        else
-        {
-            Assert.Equal("Times", converter.ConvertFrom("Times") as string);
-        }
-        Assert.True(converter.GetStandardValuesSupported(), "standard values supported");
-        Assert.False(converter.GetStandardValuesExclusive(), "standard values exclusive");
-    }
-
-    [Fact]
-    public void ExTestConvertFrom_ThrowsNotSupportedException()
-    {
-        FontConverter.FontNameConverter converter = new FontConverter.FontNameConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(null));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(1));
-    }
-}
-
-public class FontConverterTest
-{
-    public static char s_separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator[0];
-
-    [Theory]
-    [MemberData(nameof(TestConvertFormData))]
-    public void TestConvertFrom(string input, string expectedName, float expectedSize, GraphicsUnit expectedUnits, FontStyle expectedFontStyle)
-    {
-        FontConverter converter = new FontConverter();
-        Font font = (Font)converter.ConvertFrom(input);
-
-        // Unix fonts
-        Assert.Equal(expectedName, font.Name);
-        Assert.Equal(expectedSize, font.Size);
-        Assert.Equal(expectedUnits, font.Unit);
-        Assert.Equal(expectedFontStyle, font.Style);
-    }
-
-    [Theory]
-    [MemberData(nameof(ArgumentExceptionFontConverterData))]
-    public void InvalidInputThrowsArgumentException(string input, string paramName, string netfxParamName)
-    {
-        FontConverter converter = new FontConverter();
-        AssertExtensions.Throws<ArgumentException>(paramName, netfxParamName, () => converter.ConvertFrom(input));
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidEnumArgumentExceptionFontConverterData))]
-    public void InvalidInputThrowsInvalidEnumArgumentException(string input, string paramName)
-    {
-        FontConverter converter = new FontConverter();
-        Assert.Throws<InvalidEnumArgumentException>(paramName, () => converter.ConvertFrom(input));
-    }
-
-    [Fact]
-    public void EmptyStringInput()
-    {
-        FontConverter converter = new FontConverter();
-        Font font = (Font)converter.ConvertFrom(string.Empty);
-        Assert.Null(font);
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBuiltWithAggressiveTrimming))]
-    public void GetFontPropsSorted()
-    {
-        // The order provided since .NET Framework
-        string[] expectedPropNames = new[]
-        {
-            nameof(Font.Name),
-            nameof(Font.Size),
-            nameof(Font.Unit),
-            nameof(Font.Bold),
-            nameof(Font.GdiCharSet),
-            nameof(Font.GdiVerticalFont),
-            nameof(Font.Italic),
-            nameof(Font.Strikeout),
-            nameof(Font.Underline),
-        };
-
-        FontConverter converter = new FontConverter();
-        Font font = new($"Courier New", 8.25f, FontStyle.Regular, GraphicsUnit.Point);
-
-        PropertyDescriptorCollection props = converter.GetProperties(font);
-        string[] propNames = new string[props.Count];
-
-        int index = 0;
-        foreach (PropertyDescriptor prop in props)
-        {
-            propNames[index++] = prop.DisplayName;
-        }
-
-        Assert.True(propNames.SequenceEqual(expectedPropNames));
-    }
-
-    [Theory]
-    [MemberData(nameof(InstanceDescriptorTestData))]
-    public void ConvertToInstanceDescriptor(Font font, int expectedArguments)
-    {
-        try
-        {
-            FontConverter converter = new();
-            InstanceDescriptor descriptor = (InstanceDescriptor)converter.ConvertTo(font, typeof(InstanceDescriptor));
-            Assert.Equal(expectedArguments, descriptor.Arguments.Count);
-            using Font newFont = (Font)descriptor.Invoke();
-            Assert.Equal(font.Name, newFont.Name);
-            Assert.Equal(font.Size, newFont.Size);
-            Assert.Equal(font.Style, newFont.Style);
-            Assert.Equal(font.Unit, newFont.Unit);
-            Assert.Equal(font.GdiCharSet, newFont.GdiCharSet);
-            Assert.Equal(font.GdiVerticalFont, newFont.GdiVerticalFont);
-        }
-        finally
-        {
-            font.Dispose();
-        }
-    }
-
-    public static TheoryData<Font, int> InstanceDescriptorTestData => new()
-    {
-        { new Font("Arial", 12.0f), 2 },
-        { new Font("Arial", 12.0f, FontStyle.Regular), 2 },
-        { new Font("Courier", 8.0f, FontStyle.Italic), 3 },
-        { new Font("Courier", 1.0f, FontStyle.Regular, GraphicsUnit.Point), 2 },
-        { new Font("Courier", 1.0f, FontStyle.Regular, GraphicsUnit.Inch), 4 },
-        { new Font("Courier", 1.0f, FontStyle.Regular, GraphicsUnit.Pixel, gdiCharSet: 2 /* SYMBOL_CHARSET */), 5 },
-        { new Font("Courier", 1.0f, FontStyle.Regular, GraphicsUnit.Point, gdiCharSet: 1 /* DEFAULT_CHARSET */), 2 },
-        { new Font("Courier", 1.0f, FontStyle.Regular, GraphicsUnit.Pixel, gdiCharSet: 1 /* DEFAULT_CHARSET */, gdiVerticalFont: true), 6 },
-    };
-
-    public static TheoryData<string, string, float, GraphicsUnit, FontStyle> TestConvertFormData()
-    {
-        var data =
-            new TheoryData<string, string, float, GraphicsUnit, FontStyle>()
-            {
-                { $"Courier New", "Courier New", 8.25f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"Courier New{s_separator} 11", "Courier New", 11f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"Arial{s_separator} 11px", "Arial", 11f, GraphicsUnit.Pixel, FontStyle.Regular },
-                { $"Courier New{s_separator} 11 px", "Courier New", 11f, GraphicsUnit.Pixel, FontStyle.Regular },
-                { $"Courier New{s_separator} 11 px{s_separator} style=Regular", "Courier New", 11f, GraphicsUnit.Pixel, FontStyle.Regular },
-                { $"Courier New{s_separator} style=Bold", "Courier New", 8.25f, GraphicsUnit.Point, FontStyle.Bold },
-                { $"Courier New{s_separator} 11 px{s_separator} style=Bold{s_separator} Italic", "Courier New", 11f, GraphicsUnit.Pixel, FontStyle.Bold | FontStyle.Italic },
-                { $"Courier New{s_separator} 11 px{s_separator} style=Regular, Italic", "Courier New", 11f, GraphicsUnit.Pixel, FontStyle.Regular | FontStyle.Italic },
-                { $"Courier New{s_separator} 11 px{s_separator} style=Bold{s_separator} Italic{s_separator} Strikeout", "Courier New", 11f, GraphicsUnit.Pixel, FontStyle.Bold | FontStyle.Italic | FontStyle.Strikeout },
-                { $"Arial{s_separator} 11 px{s_separator} style=Bold, Italic, Strikeout", "Arial", 11f, GraphicsUnit.Pixel, FontStyle.Bold | FontStyle.Italic | FontStyle.Strikeout },
-                { $"11px", "Microsoft Sans Serif", 8.25f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"Style=Bold", "Microsoft Sans Serif", 8.25f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"arIAL{s_separator} 10{s_separator} style=bold", "Arial", 10f, GraphicsUnit.Point, FontStyle.Bold },
-                { $"Arial{s_separator} 10{s_separator}", "Arial", 10f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"Arial{s_separator}", "Arial", 8.25f, GraphicsUnit.Point, FontStyle.Regular },
-                { $"Arial{s_separator} 10{s_separator} style=12", "Arial", 10f, GraphicsUnit.Point, FontStyle.Underline | FontStyle.Strikeout },
-                { $"Courier New{s_separator} Style=Bold", "Courier New", 8.25f, GraphicsUnit.Point, FontStyle.Bold }, // FullFramework style keyword is case sensitive.
-                { $"11px{s_separator} Style=Bold", "Microsoft Sans Serif", 8.25f, GraphicsUnit.Point, FontStyle.Bold}
-            };
-
-        // FullFramework disregards all arguments if the font name is an empty string.
-        // Empty string is not an installed font on Windows 7, windows 8 and some versions of windows 10.
-        if (EmptyFontPresent)
-        {
-            data.Add($"{s_separator} 10{s_separator} style=bold", "", 10f, GraphicsUnit.Point, FontStyle.Bold);
-        }
-        else
-        {
-            data.Add($"{s_separator} 10{s_separator} style=bold", "Microsoft Sans Serif", 10f, GraphicsUnit.Point, FontStyle.Bold);
-        }
-
-        return data;
-    }
-
-    private static bool EmptyFontPresent
-    {
-        get
-        {
-            using (var installedFonts = new InstalledFontCollection())
-            {
-                return installedFonts.Families.Select(t => t.Name).Contains(string.Empty);
-            }
-        }
-    }
-
-    public static TheoryData<string, string, string> ArgumentExceptionFontConverterData() => new()
-    {
-        { $"Courier New{s_separator} 11 px{s_separator} type=Bold{s_separator} Italic", "units", null },
-        { $"Courier New{s_separator} {s_separator} Style=Bold", "value", null },
-        { $"Courier New{s_separator} 11{s_separator} Style=", "value", null },
-        { $"Courier New{s_separator} 11{s_separator} Style=RandomEnum", null, null },
-        { $"Arial{s_separator} 10{s_separator} style=bold{s_separator}", "value", null },
-        { $"Arial{s_separator} 10{s_separator} style=null", null, null },
-        { $"Arial{s_separator} 10{s_separator} style=abc#", null, null },
-        { $"Arial{s_separator} 10{s_separator} style=##", null, null },
-        { $"Arial{s_separator} 10display{s_separator} style=bold", null, null },
-        { $"Arial{s_separator} 10style{s_separator} style=bold", "units", null },
-    };
-
-    public static TheoryData<string, string> InvalidEnumArgumentExceptionFontConverterData() => new()
-    {
-        { $"Arial{s_separator} 10{s_separator} style=56", "style" },
-        { $"Arial{s_separator} 10{s_separator} style=-1", "style" },
-    };
-}
-
-public class FontUnitConverterTest
-{
-    [Fact]
-    public void GetStandardValuesTest()
-    {
-        FontUnitConverter converter = new FontUnitConverter();
-        var values = converter.GetStandardValues();
-        Assert.Equal(6, values.Count); // The six supported values of Graphics unit: World, Pixel, Point, Inch, Document, Millimeter.
-
-        foreach (var item in values)
-        {
-            Assert.NotEqual(GraphicsUnit.Display, (GraphicsUnit)item);
-        }
-    }
-
-    [Theory]
-    [InlineData("Display", GraphicsUnit.Display)]
-    [InlineData("Document", GraphicsUnit.Document)]
-    [InlineData("Inch", GraphicsUnit.Inch)]
-    [InlineData("Millimeter", GraphicsUnit.Millimeter)]
-    [InlineData("Pixel", GraphicsUnit.Pixel)]
-    [InlineData("Point", GraphicsUnit.Point)]
-    [InlineData("World", GraphicsUnit.World)]
-    public void CanConvertFrom(string input, GraphicsUnit expected)
-    {
-        FontUnitConverter converter = new FontUnitConverter();
-        GraphicsUnit value = (GraphicsUnit)converter.ConvertFrom(input);
-        Assert.Equal(expected, value);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/IconConverterTests.cs b/src/System.Drawing.Common/tests/System/Drawing/IconConverterTests.cs
deleted file mode 100644
index 1d843b08456..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/IconConverterTests.cs
+++ /dev/null
@@ -1,180 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Imaging;
-using System.Globalization;
-
-namespace System.ComponentModel.TypeConverterTests;
-
-// On IoT: "Unable to find an entry point named 'CreateIconFromResourceEx'"
-[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsIoTCore))]
-public class IconConverterTest
-{
-    private readonly Icon _icon;
-    private readonly IconConverter _icoConv;
-    private readonly IconConverter _icoConvFrmTD;
-    private readonly string _iconStr;
-    private readonly byte[] _iconBytes;
-
-    public IconConverterTest()
-    {
-        _icon = new Icon(Path.Combine("bitmaps", "TestIcon.ico"));
-        _iconStr = _icon.ToString();
-
-        using (MemoryStream destStream = new MemoryStream())
-        {
-            _icon.Save(destStream);
-            _iconBytes = destStream.ToArray();
-        }
-
-        _icoConv = new IconConverter();
-        _icoConvFrmTD = (IconConverter)TypeDescriptor.GetConverter(_icon);
-    }
-
-    [Fact]
-    public void TestCanConvertFrom()
-    {
-        Assert.True(_icoConv.CanConvertFrom(typeof(byte[])), "byte[] (no context)");
-        Assert.True(_icoConv.CanConvertFrom(null, typeof(byte[])), "byte[]");
-        Assert.True(_icoConv.CanConvertFrom(null, _iconBytes.GetType()), "_iconBytes.GetType()");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(string)), "string");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(Rectangle)), "Rectangle");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(Point)), "Point");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(PointF)), "PointF");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(Size)), "Size");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(SizeF)), "SizeF");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(object)), "object");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(int)), "int");
-        Assert.False(_icoConv.CanConvertFrom(null, typeof(Metafile)), "Metafile");
-
-        Assert.True(_icoConvFrmTD.CanConvertFrom(typeof(byte[])), "TD byte[] (no context)");
-        Assert.True(_icoConvFrmTD.CanConvertFrom(null, typeof(byte[])), "TD byte[]");
-        Assert.True(_icoConvFrmTD.CanConvertFrom(null, _iconBytes.GetType()), "TD _iconBytes.GetType()");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(string)), "TD string");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(Rectangle)), "TD Rectangle");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(Point)), "TD Point");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(PointF)), "TD PointF");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(Size)), "TD Size");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(SizeF)), "TD SizeF");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(object)), "TD object");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(int)), "TD int");
-        Assert.False(_icoConvFrmTD.CanConvertFrom(null, typeof(Metafile)), "TD Metafile");
-    }
-
-    [Fact]
-    public void TestCanConvertTo()
-    {
-        Assert.True(_icoConv.CanConvertTo(typeof(string)), "string (no context)");
-        Assert.True(_icoConv.CanConvertTo(null, typeof(string)), "string");
-        Assert.True(_icoConv.CanConvertTo(null, _iconStr.GetType()), "_iconStr.GetType()");
-        Assert.True(_icoConv.CanConvertTo(typeof(byte[])), "byte[] (no context)");
-        Assert.True(_icoConv.CanConvertTo(null, typeof(byte[])), "byte[]");
-        Assert.True(_icoConv.CanConvertTo(null, _iconBytes.GetType()), "_iconBytes.GetType()");
-        Assert.True(_icoConv.CanConvertTo(typeof(Image)), "Image (no context)");
-        Assert.True(_icoConv.CanConvertTo(null, typeof(Image)), "Image");
-        Assert.True(_icoConv.CanConvertTo(typeof(Bitmap)), "Bitmap (no context)");
-        Assert.True(_icoConv.CanConvertTo(null, typeof(Bitmap)), "Bitmap");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(Rectangle)), "Rectangle");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(Point)), "Point");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(PointF)), "PointF");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(Size)), "Size");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(SizeF)), "SizeF");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(object)), "object");
-        Assert.False(_icoConv.CanConvertTo(null, typeof(int)), "int");
-
-        Assert.True(_icoConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(string)), "TD string");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, _iconStr.GetType()), "TD _iconStr.GetType()");
-        Assert.True(_icoConvFrmTD.CanConvertTo(typeof(byte[])), "TD byte[] (no context)");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(byte[])), "TD byte[]");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, _iconBytes.GetType()), "TD _iconBytes.GetType()");
-        Assert.True(_icoConvFrmTD.CanConvertTo(typeof(Image)), "TD Image (no context)");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(Image)), "TD Image");
-        Assert.True(_icoConvFrmTD.CanConvertTo(typeof(Bitmap)), "TD Bitmap (no context)");
-        Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(Bitmap)), "TD Bitmap");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(Rectangle)), "TD Rectangle");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(Point)), "TD Point");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(PointF)), "TD PointF");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(Size)), "TD Size");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(SizeF)), "TD SizeF");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(object)), "TD object");
-        Assert.False(_icoConvFrmTD.CanConvertTo(null, typeof(int)), "TD int");
-    }
-
-    [Fact]
-    public void TestConvertFrom()
-    {
-        Icon newIcon = (Icon)_icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, _iconBytes);
-
-        Assert.Equal(_icon.Height, newIcon.Height);
-        Assert.Equal(_icon.Width, newIcon.Width);
-
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, new Bitmap(20, 20)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, new Point(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, new SizeF(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-
-
-        newIcon = (Icon)_icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, _iconBytes);
-
-        Assert.Equal(_icon.Height, newIcon.Height);
-        Assert.Equal(_icon.Width, newIcon.Width);
-
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new Bitmap(20, 20)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new Point(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new SizeF(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-    }
-
-    [Fact]
-    public void TestConvertTo()
-    {
-        Assert.Equal(_iconStr, (string)_icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(string)));
-        Assert.Equal(_iconStr, (string)_icoConv.ConvertTo(_icon, typeof(string)));
-
-        byte[] newIconBytes = (byte[])_icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, _iconBytes.GetType());
-        Assert.Equal(_iconBytes, newIconBytes);
-
-        newIconBytes = (byte[])_icoConv.ConvertTo(_icon, _iconBytes.GetType());
-        Assert.Equal(_iconBytes, newIconBytes);
-
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Rectangle)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, _icon.GetType()));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Size)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Point)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Metafile)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _icoConv.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(int)));
-
-        Assert.Equal(_iconStr, (string)_icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(string)));
-        Assert.Equal(_iconStr, (string)_icoConvFrmTD.ConvertTo(_icon, typeof(string)));
-
-
-        newIconBytes = (byte[])_icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, _iconBytes.GetType());
-        Assert.Equal(_iconBytes, newIconBytes);
-
-        newIconBytes = (byte[])_icoConvFrmTD.ConvertTo(_icon, _iconBytes.GetType());
-        Assert.Equal(_iconBytes, newIconBytes);
-
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Rectangle)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, _icon.GetType()));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Size)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Point)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(Metafile)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _icoConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _icon, typeof(int)));
-
-        using (new ThreadCultureChange(CultureInfo.CreateSpecificCulture("fr-FR"), CultureInfo.InvariantCulture))
-        {
-            Assert.Equal("(none)", (string)_icoConv.ConvertTo(null, typeof(string)));
-            Assert.Equal("(none)", (string)_icoConv.ConvertTo(null, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string)));
-
-            Assert.Equal("(none)", (string)_icoConvFrmTD.ConvertTo(null, typeof(string)));
-            Assert.Equal("(none)", (string)_icoConvFrmTD.ConvertTo(null, CultureInfo.CreateSpecificCulture("de-DE"), null, typeof(string)));
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/ImageAnimator.ManualTests.cs b/src/System.Drawing.Common/tests/System/Drawing/ImageAnimator.ManualTests.cs
deleted file mode 100644
index 1c6c0d1761b..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/ImageAnimator.ManualTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Imaging;
-
-namespace System.Drawing.Tests;
-
-public class ImageAnimatorManualTests
-{
-    public static string OutputFolder = Path.Combine(Environment.CurrentDirectory, "ImageAnimatorManualTests", DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"));
-
-    [Fact(Skip = "Manual Test")]
-    public void AnimateAndCaptureFrames()
-    {
-        // This test animates the test gifs that we have and waits 60 seconds
-        // for the animations to progress. As the frame change events occur, we
-        // capture snapshots of the current frame, essentially extracting the
-        // frames from the GIF.
-
-        // The animation should progress at the expected pace to stay synchronized
-        // with the wall clock, and the animated timer images show the time duration
-        // within the image itself, so this can be manually verified for accuracy.
-
-        // The captured frames are stored in the `artifacts/bin/System.Drawing.Common.Tests`
-        // folder for each configuration, and then under an `ImageAnimatorManualTests` folder
-        // with a timestamped folder under that. Each animation image gets its own folder too.
-
-        string[] images = new string[]
-        {
-            "animated-timer-1fps-repeat-2.gif",
-            "animated-timer-1fps-repeat-infinite.gif",
-            "animated-timer-10fps-repeat-2.gif",
-            "animated-timer-10fps-repeat-infinite.gif",
-            "animated-timer-100fps-repeat-2.gif",
-            "animated-timer-100fps-repeat-infinite.gif",
-            "animated-timer-0-delay-all-frames.gif",
-        };
-
-        Dictionary<string, EventHandler> handlers = new();
-        Dictionary<string, int> frameIndexes = new();
-        Dictionary<string, Bitmap> bitmaps = new();
-
-        Stopwatch stopwatch = new();
-
-        foreach (var imageName in images)
-        {
-            string testOutputFolder = Path.Combine(OutputFolder, Path.GetFileNameWithoutExtension(imageName));
-            Directory.CreateDirectory(testOutputFolder);
-            frameIndexes[imageName] = 0;
-
-            handlers[imageName] = new EventHandler(new Action<object, EventArgs>((object o, EventArgs e) =>
-            {
-                Bitmap animation = (Bitmap)o;
-                ImageAnimator.UpdateFrames(animation);
-
-                // We save captures using jpg so that:
-                // a) The images don't get saved as animated gifs again, and just a single frame is saved
-                // b) Saving pngs in this test on Linux was leading to sporadic GDI+ errors; Jpeg is more reliable
-                string timestamp = stopwatch.ElapsedMilliseconds.ToString("000000");
-                animation.Save(Path.Combine(testOutputFolder, $"{++frameIndexes[imageName]}_{timestamp}.jpg"), ImageFormat.Jpeg);
-            }));
-
-            bitmaps[imageName] = new Bitmap(Helpers.GetTestBitmapPath(imageName));
-            ImageAnimator.Animate(bitmaps[imageName], handlers[imageName]);
-        }
-
-        stopwatch.Start();
-        Thread.Sleep(60_000);
-
-        foreach (var imageName in images)
-        {
-            ImageAnimator.StopAnimate(bitmaps[imageName], handlers[imageName]);
-            bitmaps[imageName].Dispose();
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/ImageAnimatorTests.cs b/src/System.Drawing.Common/tests/System/Drawing/ImageAnimatorTests.cs
deleted file mode 100644
index 9d5701f0e89..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/ImageAnimatorTests.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class ImageAnimatorTests
-{
-    [Fact]
-    public void UpdateFrames_Succeeds_WithNothingAnimating()
-    {
-        ImageAnimator.UpdateFrames();
-    }
-
-    [Theory]
-    [InlineData("1bit.png")]
-    [InlineData("48x48_one_entry_1bit.ico")]
-    [InlineData("81773-interlaced.gif")]
-    public void CanAnimate_ReturnsFalse_ForNonAnimatedImages(string imageName)
-    {
-        using (var image = new Bitmap(Helpers.GetTestBitmapPath(imageName)))
-        {
-            Assert.False(ImageAnimator.CanAnimate(image));
-        }
-    }
-
-    [Fact]
-    public void Animate_Succeeds_ForNonAnimatedImages_WithNothingAnimating()
-    {
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.Animate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void Animate_Succeeds_ForNonAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.Animate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void UpdateFrames_Succeeds_ForNonAnimatedImages_WithNothingAnimating()
-    {
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.UpdateFrames(image);
-    }
-
-    [Fact]
-    public void UpdateFrames_Succeeds_ForNonAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.UpdateFrames(image);
-    }
-
-    [Fact]
-    public void StopAnimate_Succeeds_ForNonAnimatedImages_WithNothingAnimating()
-    {
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.StopAnimate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void StopAnimate_Succeeds_ForNonAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-
-        var image = new Bitmap(Helpers.GetTestBitmapPath("1bit.png"));
-        ImageAnimator.StopAnimate(image, (object o, EventArgs e) => { });
-    }
-
-    [Theory]
-    [InlineData("animated-timer-1fps-repeat-2.gif")]
-    [InlineData("animated-timer-1fps-repeat-infinite.gif")]
-    [InlineData("animated-timer-10fps-repeat-2.gif")]
-    [InlineData("animated-timer-10fps-repeat-infinite.gif")]
-    [InlineData("animated-timer-100fps-repeat-2.gif")]
-    [InlineData("animated-timer-100fps-repeat-infinite.gif")]
-    public void CanAnimate_ReturnsTrue_ForAnimatedImages(string imageName)
-    {
-        using (var image = new Bitmap(Helpers.GetTestBitmapPath(imageName)))
-        {
-            Assert.True(ImageAnimator.CanAnimate(image));
-        }
-    }
-
-    [Fact]
-    public void Animate_Succeeds_ForAnimatedImages_WithNothingAnimating()
-    {
-        var image = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void Animate_Succeeds_ForAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-
-        var image = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-infinite.gif"));
-        ImageAnimator.Animate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void UpdateFrames_Succeeds_ForAnimatedImages_WithNothingAnimating()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.UpdateFrames(animatedImage);
-    }
-
-    [Fact]
-    public void UpdateFrames_Succeeds_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-        ImageAnimator.UpdateFrames();
-    }
-
-    [Fact]
-    public void UpdateFrames_Succeeds_ForAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-        ImageAnimator.UpdateFrames(animatedImage);
-    }
-
-    [Fact]
-    public void StopAnimate_Succeeds_ForAnimatedImages_WithNothingAnimating()
-    {
-        var image = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.StopAnimate(image, (object o, EventArgs e) => { });
-    }
-
-    [Fact]
-    public void StopAnimate_Succeeds_ForAnimatedImages_WithCurrentAnimations()
-    {
-        var animatedImage = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-2.gif"));
-        ImageAnimator.Animate(animatedImage, (object o, EventArgs e) => { });
-
-        var image = new Bitmap(Helpers.GetTestBitmapPath("animated-timer-100fps-repeat-infinite.gif"));
-        ImageAnimator.StopAnimate(animatedImage, (object o, EventArgs e) => { });
-        ImageAnimator.StopAnimate(image, (object o, EventArgs e) => { });
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/ImageConverterTests.cs b/src/System.Drawing.Common/tests/System/Drawing/ImageConverterTests.cs
deleted file mode 100644
index fd4da940049..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/ImageConverterTests.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Imaging;
-using System.Globalization;
-
-namespace System.ComponentModel.TypeConverterTests;
-
-public class ImageConverterTest
-{
-    private readonly Image _image;
-    private readonly ImageConverter _imgConv;
-    private readonly ImageConverter _imgConvFrmTD;
-    private readonly string _imageStr;
-    private readonly byte[] _imageBytes;
-
-    public ImageConverterTest()
-    {
-        _image = Image.FromFile(Path.Combine("bitmaps", "TestImage.bmp"));
-        _imageStr = _image.ToString();
-
-        using (MemoryStream destStream = new MemoryStream())
-        {
-            _image.Save(destStream, _image.RawFormat);
-            _imageBytes = destStream.ToArray();
-        }
-
-        _imgConv = new ImageConverter();
-        _imgConvFrmTD = (ImageConverter)TypeDescriptor.GetConverter(_image);
-    }
-
-    [Theory]
-    [InlineData("48x48_multiple_entries_4bit.ico")]
-    [InlineData("256x256_seven_entries_multiple_bits.ico")]
-    [InlineData("pngwithheight_icon.ico")]
-    public void ImageConverterFromIconTest(string name)
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath(name)))
-        {
-            Bitmap IconBitmap = (Bitmap)_imgConv.ConvertFrom(icon);
-            Assert.NotNull(IconBitmap);
-            Assert.Equal(32, IconBitmap.Width);
-            Assert.Equal(32, IconBitmap.Height);
-            Assert.Equal(new Size(32, 32), IconBitmap.Size);
-        }
-    }
-
-    [Fact]
-    public void ImageWithOleHeader()
-    {
-        string path = Path.Combine("bitmaps", "TestImageWithOleHeader.bmp");
-        using (FileStream fileStream = File.Open(path, FileMode.Open))
-        {
-            using (var ms = new MemoryStream())
-            {
-                fileStream.CopyTo(ms);
-                var converter = new ImageConverter();
-                object image = converter.ConvertFrom(ms.ToArray());
-                Assert.NotNull(image);
-            }
-        }
-    }
-
-    [Fact]
-    public void TestCanConvertFrom()
-    {
-        Assert.True(_imgConv.CanConvertFrom(typeof(byte[])), "byte[] (no context)");
-        Assert.True(_imgConv.CanConvertFrom(null, typeof(byte[])), "byte[]");
-        Assert.True(_imgConv.CanConvertFrom(null, _imageBytes.GetType()), "_imageBytes.GetType()");
-        Assert.True(_imgConv.CanConvertFrom(typeof(Icon)), "Icon (no context)");
-        Assert.True(_imgConv.CanConvertFrom(null, typeof(Icon)), "Icon");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(string)), "string");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(Rectangle)), "Rectangle");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(Point)), "Point");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(PointF)), "PointF");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(Size)), "Size");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(SizeF)), "SizeF");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(object)), "object");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(int)), "int");
-        Assert.False(_imgConv.CanConvertFrom(null, typeof(Metafile)), "Mefafile");
-
-        Assert.True(_imgConvFrmTD.CanConvertFrom(typeof(byte[])), "TD byte[] (no context)");
-        Assert.True(_imgConvFrmTD.CanConvertFrom(null, typeof(byte[])), "TD byte[]");
-        Assert.True(_imgConvFrmTD.CanConvertFrom(null, _imageBytes.GetType()), "TD _imageBytes.GetType()");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(string)), "TD string");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(Rectangle)), "TD Rectangle");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(Point)), "TD Point");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(PointF)), "TD PointF");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(Size)), "TD Size");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(SizeF)), "TD SizeF");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(object)), "TD object");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(int)), "TD int");
-        Assert.False(_imgConvFrmTD.CanConvertFrom(null, typeof(Metafile)), "TD Metafile");
-    }
-
-    [Fact]
-    public void TestCanConvertTo()
-    {
-        Assert.True(_imgConv.CanConvertTo(typeof(string)), "stirng (no context)");
-        Assert.True(_imgConv.CanConvertTo(null, typeof(string)), "string");
-        Assert.True(_imgConv.CanConvertTo(null, _imageStr.GetType()), "_imageStr.GetType()");
-        Assert.True(_imgConv.CanConvertTo(typeof(byte[])), "byte[] (no context)");
-        Assert.True(_imgConv.CanConvertTo(null, typeof(byte[])), "byte[]");
-        Assert.True(_imgConv.CanConvertTo(null, _imageBytes.GetType()), "_imageBytes.GetType()");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(Rectangle)), "Rectangle");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(Point)), "Point");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(PointF)), "PointF");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(Size)), "Size");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(SizeF)), "SizeF");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(object)), "object");
-        Assert.False(_imgConv.CanConvertTo(null, typeof(int)), "int");
-
-        Assert.True(_imgConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)");
-        Assert.True(_imgConvFrmTD.CanConvertTo(null, typeof(string)), "TD string");
-        Assert.True(_imgConvFrmTD.CanConvertTo(null, _imageStr.GetType()), "TD _imageStr.GetType()");
-        Assert.True(_imgConvFrmTD.CanConvertTo(typeof(byte[])), "TD byte[] (no context)");
-        Assert.True(_imgConvFrmTD.CanConvertTo(null, typeof(byte[])), "TD byte[]");
-        Assert.True(_imgConvFrmTD.CanConvertTo(null, _imageBytes.GetType()), "TD _imageBytes.GetType()");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(Rectangle)), "TD Rectangle");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(Point)), "TD Point");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(PointF)), "TD PointF");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(Size)), "TD Size");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(SizeF)), "TD SizeF");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(object)), "TD object");
-        Assert.False(_imgConvFrmTD.CanConvertTo(null, typeof(int)), "TD int");
-    }
-
-    [Fact]
-    public void ConvertFrom()
-    {
-        Image newImage = (Image)_imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, _imageBytes);
-
-        Assert.Equal(_image.Height, newImage.Height);
-        Assert.Equal(_image.Width, newImage.Width);
-
-        newImage = (Image)_imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, _imageBytes);
-
-        Assert.Equal(_image.Height, newImage.Height);
-        Assert.Equal(_image.Width, newImage.Width);
-    }
-
-    [Fact]
-    public void ConvertFrom_ThrowsNotSupportedException()
-    {
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, new Bitmap(20, 20)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, new Point(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, new SizeF(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new Bitmap(20, 20)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new Point(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new SizeF(10, 10)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-    }
-
-    [Fact]
-    public void ConvertTo_String()
-    {
-        Assert.Equal(_imageStr, (string)_imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(string)));
-        Assert.Equal(_imageStr, (string)_imgConv.ConvertTo(_image, typeof(string)));
-        Assert.Equal(_imageStr, (string)_imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(string)));
-        Assert.Equal(_imageStr, (string)_imgConvFrmTD.ConvertTo(_image, typeof(string)));
-
-        using (new ThreadCultureChange(CultureInfo.CreateSpecificCulture("fr-FR"), CultureInfo.InvariantCulture))
-        {
-            Assert.Equal("(none)", (string)_imgConv.ConvertTo(null, typeof(string)));
-            Assert.Equal("(none)", (string)_imgConv.ConvertTo(null, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string)));
-
-            Assert.Equal("(none)", (string)_imgConvFrmTD.ConvertTo(null, typeof(string)));
-            Assert.Equal("(none)", (string)_imgConvFrmTD.ConvertTo(null, CultureInfo.CreateSpecificCulture("de-DE"), null, typeof(string)));
-        }
-    }
-
-    [Fact]
-    public void ConvertTo_ByteArray()
-    {
-        byte[] newImageBytes = (byte[])_imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, _imageBytes.GetType());
-        Assert.Equal(_imageBytes, newImageBytes);
-
-        newImageBytes = (byte[])_imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, _imageBytes.GetType());
-        Assert.Equal(_imageBytes, newImageBytes);
-
-        newImageBytes = (byte[])_imgConvFrmTD.ConvertTo(_image, _imageBytes.GetType());
-        Assert.Equal(_imageBytes, newImageBytes);
-    }
-
-    [Fact]
-    public void ConvertTo_FromBitmapToByteArray()
-    {
-        Bitmap value = new Bitmap(64, 64);
-        ImageConverter converter = new ImageConverter();
-        byte[] converted = (byte[])converter.ConvertTo(value, typeof(byte[]));
-        Assert.NotNull(converted);
-    }
-
-    [Fact]
-    public void ConvertTo_ThrowsNotSupportedException()
-    {
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Rectangle)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, _image.GetType()));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Size)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Bitmap)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Point)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Metafile)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _imgConv.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(int)));
-
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Rectangle)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, _image.GetType()));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Size)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Bitmap)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Point)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(Metafile)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _imgConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _image, typeof(int)));
-    }
-
-    [Fact]
-    public void TestGetPropertiesSupported()
-    {
-        Assert.True(_imgConv.GetPropertiesSupported(), "GetPropertiesSupported()");
-        Assert.True(_imgConv.GetPropertiesSupported(null), "GetPropertiesSupported(null)");
-    }
-
-    [Fact]
-    public void TestGetProperties()
-    {
-        const int allPropertiesCount = 14; // Count of all properties in Image class.
-        const int browsablePropertiesCount = 7; // Count of browsable properties in Image class (BrowsableAttribute.Yes).
-
-        PropertyDescriptorCollection propsColl;
-
-        // Internally calls TypeDescriptor.GetProperties(typeof(Image), null), which returns all properties.
-        propsColl = _imgConv.GetProperties(null, _image, null);
-        Assert.Equal(allPropertiesCount, propsColl.Count);
-
-        // Internally calls TypeDescriptor.GetProperties(typeof(Image), new Attribute[] { BrowsableAttribute.Yes }).
-        propsColl = _imgConv.GetProperties(null, _image);
-        Assert.Equal(browsablePropertiesCount, propsColl.Count);
-        propsColl = _imgConv.GetProperties(_image);
-        Assert.Equal(browsablePropertiesCount, propsColl.Count);
-
-
-        // Returns all properties of Image class.
-        propsColl = TypeDescriptor.GetProperties(typeof(Image));
-        Assert.Equal(allPropertiesCount, propsColl.Count);
-
-        // Internally calls TypeDescriptor.GetProperties(typeof(Image), null), which returns all properties.
-        propsColl = _imgConvFrmTD.GetProperties(null, _image, null);
-        Assert.Equal(allPropertiesCount, propsColl.Count);
-
-        // Internally calls TypeDescriptor.GetProperties(typeof(Image), new Attribute[] { BrowsableAttribute.Yes }).
-        propsColl = _imgConvFrmTD.GetProperties(null, _image);
-        Assert.Equal(browsablePropertiesCount, propsColl.Count);
-        propsColl = _imgConvFrmTD.GetProperties(_image);
-        Assert.Equal(browsablePropertiesCount, propsColl.Count);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/ImageFormatConverterTests.cs b/src/System.Drawing.Common/tests/System/Drawing/ImageFormatConverterTests.cs
deleted file mode 100644
index 09858c3d54f..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/ImageFormatConverterTests.cs
+++ /dev/null
@@ -1,249 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing.Imaging;
-using System.Globalization;
-
-namespace System.ComponentModel.TypeConverterTests;
-
-public class ImageFormatConverterTest
-{
-    private readonly ImageFormat _imageFmt;
-    private readonly ImageFormatConverter _imgFmtConv;
-    private readonly ImageFormatConverter _imgFmtConvFrmTD;
-    private readonly string _imageFmtStr;
-
-    public ImageFormatConverterTest()
-    {
-        _imageFmt = ImageFormat.Bmp;
-        _imageFmtStr = _imageFmt.ToString();
-
-        _imgFmtConv = new ImageFormatConverter();
-        _imgFmtConvFrmTD = (ImageFormatConverter)TypeDescriptor.GetConverter(_imageFmt);
-    }
-
-    [Fact]
-    public void TestCanConvertFrom()
-    {
-        Assert.True(_imgFmtConv.CanConvertFrom(typeof(string)), "string (no context)");
-        Assert.True(_imgFmtConv.CanConvertFrom(null, typeof(string)), "string");
-        Assert.False(_imgFmtConv.CanConvertFrom(null, typeof(ImageFormat)), "ImageFormat");
-        Assert.False(_imgFmtConv.CanConvertFrom(null, typeof(Guid)), "Guid");
-        Assert.False(_imgFmtConv.CanConvertFrom(null, typeof(object)), "object");
-        Assert.False(_imgFmtConv.CanConvertFrom(null, typeof(int)), "int");
-
-        Assert.True(_imgFmtConvFrmTD.CanConvertFrom(typeof(string)), "TD string (no context)");
-        Assert.True(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(string)), "TD string");
-        Assert.False(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(ImageFormat)), "TD ImageFormat");
-        Assert.False(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(Guid)), "TD Guid");
-        Assert.False(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(object)), "TD object");
-        Assert.False(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(int)), "TD int");
-    }
-
-    [Fact]
-    public void TestCanConvertTo()
-    {
-        Assert.True(_imgFmtConv.CanConvertTo(typeof(string)), "string (no context)");
-        Assert.True(_imgFmtConv.CanConvertTo(null, typeof(string)), "string");
-        Assert.False(_imgFmtConv.CanConvertTo(null, typeof(ImageFormat)), "ImageFormat");
-        Assert.False(_imgFmtConv.CanConvertTo(null, typeof(Guid)), "Guid");
-        Assert.False(_imgFmtConv.CanConvertTo(null, typeof(object)), "object");
-        Assert.False(_imgFmtConv.CanConvertTo(null, typeof(int)), "int");
-
-        Assert.True(_imgFmtConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)");
-        Assert.True(_imgFmtConvFrmTD.CanConvertTo(null, typeof(string)), "TD string");
-        Assert.False(_imgFmtConvFrmTD.CanConvertTo(null, typeof(ImageFormat)), "TD ImageFormat");
-        Assert.False(_imgFmtConvFrmTD.CanConvertTo(null, typeof(Guid)), "TD Guid");
-        Assert.False(_imgFmtConvFrmTD.CanConvertTo(null, typeof(object)), "TD object");
-        Assert.False(_imgFmtConvFrmTD.CanConvertTo(null, typeof(int)), "TD int");
-    }
-
-    [Fact]
-    public void TestConvertFrom_ImageFormatToString()
-    {
-        Assert.Equal(_imageFmt, (ImageFormat)_imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp.ToString()));
-        Assert.Equal(_imageFmt, (ImageFormat)_imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp.ToString()));
-    }
-
-    [Fact]
-    public void TestConvertFrom_ThrowsNotSupportedException()
-    {
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp.Guid));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, 10));
-
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, ImageFormat.Bmp.Guid));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, new object()));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, 10));
-    }
-
-    private ImageFormat ConvertFromName(string imgFormatName)
-    {
-        return (ImageFormat)_imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, imgFormatName);
-    }
-
-    [Fact]
-    public void ConvertFrom_ShortName()
-    {
-        Assert.Equal(ImageFormat.Bmp, ConvertFromName("Bmp"));
-        Assert.Equal(ImageFormat.Emf, ConvertFromName("Emf"));
-        Assert.Equal(ImageFormat.Exif, ConvertFromName("Exif"));
-        Assert.Equal(ImageFormat.Gif, ConvertFromName("Gif"));
-        Assert.Equal(ImageFormat.Tiff, ConvertFromName("Tiff"));
-        Assert.Equal(ImageFormat.Png, ConvertFromName("Png"));
-        Assert.Equal(ImageFormat.MemoryBmp, ConvertFromName("MemoryBmp"));
-        Assert.Equal(ImageFormat.Icon, ConvertFromName("Icon"));
-        Assert.Equal(ImageFormat.Jpeg, ConvertFromName("Jpeg"));
-        Assert.Equal(ImageFormat.Wmf, ConvertFromName("Wmf"));
-#if NET
-        Assert.Equal(ImageFormat.Heif, ConvertFromName("Heif"));
-        Assert.Equal(ImageFormat.Webp, ConvertFromName("Webp"));
-#endif
-    }
-
-    [Fact]
-    public void ConvertFrom_LongName()
-    {
-        Guid testGuid = Guid.NewGuid();
-        ImageFormat imageformat = ConvertFromName($"[ImageFormat: {testGuid}]");
-        Assert.Equal(testGuid, imageformat.Guid);
-    }
-
-    [Fact]
-    public void ConvertFrom_ThrowsFormatExceptionOnInvalidFormatString()
-    {
-        Assert.Throws<FormatException>(() => _imgFmtConv.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<FormatException>(() => _imgFmtConv.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<FormatException>(() => _imgFmtConv.ConvertFrom("[ImageFormat: abcdefgh-ijkl-mnop-qrst-uvwxyz012345]"));
-
-        Assert.Throws<FormatException>(() => _imgFmtConvFrmTD.ConvertFrom("System.Drawing.String"));
-        Assert.Throws<FormatException>(() => _imgFmtConvFrmTD.ConvertFrom(null, CultureInfo.InvariantCulture, "System.Drawing.String"));
-        Assert.Throws<FormatException>(() => _imgFmtConvFrmTD.ConvertFrom("[ImageFormat: abcdefgh-ijkl-mnop-qrst-uvwxyz012345]"));
-    }
-
-    [Fact]
-    public void TestConvertTo_String()
-    {
-        Assert.Equal(_imageFmtStr, (string)_imgFmtConv.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(string)));
-        Assert.Equal(_imageFmtStr, (string)_imgFmtConv.ConvertTo(_imageFmt, typeof(string)));
-
-        Assert.Equal(_imageFmtStr, (string)_imgFmtConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(string)));
-        Assert.Equal(_imageFmtStr, (string)_imgFmtConvFrmTD.ConvertTo(_imageFmt, typeof(string)));
-
-        Assert.Equal(string.Empty, (string)_imgFmtConv.ConvertTo(null, typeof(string)));
-        Assert.Equal(string.Empty, (string)_imgFmtConv.ConvertTo(null, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string)));
-
-        Assert.Equal(string.Empty, (string)_imgFmtConvFrmTD.ConvertTo(null, typeof(string)));
-        Assert.Equal(string.Empty, (string)_imgFmtConvFrmTD.ConvertTo(null, CultureInfo.CreateSpecificCulture("de-DE"), null, typeof(string)));
-    }
-
-    [Fact]
-    public void TestConvertTo_ThrowsNotSupportedException()
-    {
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(ImageFormat)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(Guid)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConv.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(int)));
-
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(ImageFormat)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(Guid)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(object)));
-        Assert.Throws<NotSupportedException>(() => _imgFmtConvFrmTD.ConvertTo(null, CultureInfo.InvariantCulture, _imageFmt, typeof(int)));
-    }
-
-    [Fact]
-    public void GetStandardValuesSupported()
-    {
-        Assert.True(_imgFmtConv.GetStandardValuesSupported(), "GetStandardValuesSupported()");
-        Assert.True(_imgFmtConv.GetStandardValuesSupported(null), "GetStandardValuesSupported(null)");
-    }
-
-    private void CheckStandardValues(ICollection values)
-    {
-        bool memorybmp = false;
-        bool bmp = false;
-        bool emf = false;
-        bool wmf = false;
-        bool gif = false;
-        bool jpeg = false;
-        bool png = false;
-        bool tiff = false;
-        bool exif = false;
-        bool icon = false;
-#if NET
-        bool heif = false;
-        bool webp = false;
-#endif
-
-        foreach (ImageFormat iformat in values)
-        {
-            switch (iformat.Guid.ToString())
-            {
-                case "b96b3caa-0728-11d3-9d7b-0000f81ef32e":
-                    memorybmp = true;
-                    break;
-                case "b96b3cab-0728-11d3-9d7b-0000f81ef32e":
-                    bmp = true;
-                    break;
-                case "b96b3cac-0728-11d3-9d7b-0000f81ef32e":
-                    emf = true;
-                    break;
-                case "b96b3cad-0728-11d3-9d7b-0000f81ef32e":
-                    wmf = true;
-                    break;
-                case "b96b3cb0-0728-11d3-9d7b-0000f81ef32e":
-                    gif = true;
-                    break;
-                case "b96b3cae-0728-11d3-9d7b-0000f81ef32e":
-                    jpeg = true;
-                    break;
-                case "b96b3caf-0728-11d3-9d7b-0000f81ef32e":
-                    png = true;
-                    break;
-                case "b96b3cb1-0728-11d3-9d7b-0000f81ef32e":
-                    tiff = true;
-                    break;
-                case "b96b3cb2-0728-11d3-9d7b-0000f81ef32e":
-                    exif = true;
-                    break;
-                case "b96b3cb5-0728-11d3-9d7b-0000f81ef32e":
-                    icon = true;
-                    break;
-#if NET
-                case "b96b3cb6-0728-11d3-9d7b-0000f81ef32e":
-                    heif = true;
-                    break;
-                case "b96b3cb7-0728-11d3-9d7b-0000f81ef32e":
-                    webp = true;
-                    break;
-#endif
-                default:
-                    throw new InvalidOperationException($"Unknown GUID {iformat.Guid}.");
-            }
-        }
-        Assert.True(memorybmp, "MemoryBMP");
-        Assert.True(bmp, "Bmp");
-        Assert.True(emf, "Emf");
-        Assert.True(wmf, "Wmf");
-        Assert.True(gif, "Gif");
-        Assert.True(jpeg, "Jpeg");
-        Assert.True(png, "Png");
-        Assert.True(tiff, "Tiff");
-        Assert.True(exif, "Exif");
-        Assert.True(icon, "Icon");
-#if NET
-        Assert.True(heif, "Heif");
-        Assert.True(webp, "Webp");
-#endif
-    }
-
-    [Fact]
-    public void GetStandardValues()
-    {
-        CheckStandardValues(_imgFmtConv.GetStandardValues());
-        CheckStandardValues(_imgFmtConv.GetStandardValues(null));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/System/Drawing/Printing/MarginsConverterTests.cs b/src/System.Drawing.Common/tests/System/Drawing/Printing/MarginsConverterTests.cs
deleted file mode 100644
index c5846ebcd2f..00000000000
--- a/src/System.Drawing.Common/tests/System/Drawing/Printing/MarginsConverterTests.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Globalization;
-
-namespace System.Drawing.Printing.Tests;
-
-public class MarginsConverterTests
-{
-    [Fact]
-    public void CanConvertFrom()
-    {
-        MarginsConverter mc = new MarginsConverter();
-
-        // try once with then once without context
-        for (var context = new MyTypeDescriptorContext(); context != null; context = null)
-        {
-            Assert.True(mc.CanConvertFrom(context, typeof(string)));
-            Assert.False(mc.CanConvertFrom(context, typeof(Guid)));
-            Assert.False(mc.CanConvertFrom(context, typeof(object)));
-            Assert.False(mc.CanConvertFrom(context, typeof(int)));
-        }
-    }
-
-    [Fact]
-    public void CanConvertTo()
-    {
-        MarginsConverter mc = new MarginsConverter();
-
-        // try once with then once without context
-        for (var context = new MyTypeDescriptorContext(); context != null; context = null)
-        {
-            Assert.True(mc.CanConvertTo(context, typeof(string)));
-            Assert.False(mc.CanConvertTo(context, typeof(Guid)));
-            Assert.False(mc.CanConvertTo(context, typeof(object)));
-            Assert.False(mc.CanConvertTo(context, typeof(int)));
-        }
-    }
-
-    [Fact]
-    public void CreateInstance()
-    {
-        MarginsConverter mc = new MarginsConverter();
-        MyTypeDescriptorContext context = new MyTypeDescriptorContext();
-
-        IDictionary values = new Dictionary<string, int>();
-        values.Add("Left", 1);
-        values.Add("Right", 2);
-        values.Add("Top", 3);
-        Assert.Throws<ArgumentException>(() => mc.CreateInstance(context, values));
-        values.Add("Bottom", 4);
-
-        object result = mc.CreateInstance(context, values);
-        Assert.NotNull(result);
-
-        Assert.IsType<Margins>(result);
-        Margins margins = result as Margins;
-        Assert.Equal(1, margins.Left);
-        Assert.Equal(2, margins.Right);
-        Assert.Equal(3, margins.Top);
-        Assert.Equal(4, margins.Bottom);
-    }
-
-    [Fact]
-    public void GetCreateInstanceSupported()
-    {
-        MarginsConverter mc = new MarginsConverter();
-        Assert.True(mc.GetCreateInstanceSupported(null));
-        Assert.True(mc.GetCreateInstanceSupported(new MyTypeDescriptorContext()));
-    }
-
-    [Fact]
-    public void ConvertFrom()
-    {
-        MarginsConverter mc = new MarginsConverter();
-        CultureInfo culture = CultureInfo.InvariantCulture;
-
-        // try once with then once without context
-        for (var context = new MyTypeDescriptorContext(); context != null; context = null)
-        {
-            object result;
-            Assert.Equal(',', culture.TextInfo.ListSeparator[0]);
-            AssertExtensions.Throws<ArgumentException, Exception>(() => mc.ConvertFrom(context, culture, "1;2;3;4"));
-            result = mc.ConvertFrom(context, culture, "1,2,3,4");
-            Assert.IsType<Margins>(result);
-            Margins margins = result as Margins;
-            Assert.Equal(1, margins.Left);
-            Assert.Equal(2, margins.Right);
-            Assert.Equal(3, margins.Top);
-            Assert.Equal(4, margins.Bottom);
-        }
-    }
-
-    [Fact]
-    public void ConvertFrom_Throws()
-    {
-        MarginsConverter mc = new MarginsConverter();
-        CultureInfo culture = CultureInfo.InvariantCulture;
-
-        // try once with then once without context
-        for (var context = new MyTypeDescriptorContext(); context != null; context = null)
-        {
-            Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, null, null));
-            Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, culture, null));
-            Assert.Throws<NotSupportedException>(() => mc.ConvertFrom(context, culture, Guid.NewGuid()));
-            AssertExtensions.Throws<ArgumentException, Exception>(() => mc.ConvertFrom(context, null, "wrong string format"));
-            AssertExtensions.Throws<ArgumentException, Exception>(() => mc.ConvertFrom(context, culture, "wrong string format"));
-        }
-    }
-
-    [Fact]
-    public void ConvertTo()
-    {
-        MarginsConverter mc = new MarginsConverter();
-        Guid guid = Guid.NewGuid();
-        CultureInfo culture = CultureInfo.InvariantCulture;
-        Margins margins = new Margins() { Left = 1, Right = 2, Top = 3, Bottom = 4 };
-
-        // try once with then once without context
-        for (var context = new MyTypeDescriptorContext(); context != null; context = null)
-        {
-            Assert.Equal("1;2;3;4", mc.ConvertTo(context, culture, "1;2;3;4", typeof(string)));
-
-            object converted = mc.ConvertTo(context, culture, margins, typeof(string));
-            Assert.IsType<string>(converted);
-            Assert.Equal(',', culture.TextInfo.ListSeparator[0]);
-            Assert.Equal("1, 2, 3, 4", converted);
-
-            converted = mc.ConvertTo(context, culture, margins, typeof(InstanceDescriptor));
-            Assert.IsType<InstanceDescriptor>(converted);
-            Assert.Equal(new object[] { 1, 2, 3, 4 }, ((InstanceDescriptor)converted).Arguments);
-
-            Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, new object(), typeof(object)));
-            Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, 12, typeof(int)));
-            Assert.Throws<NotSupportedException>(() => mc.ConvertTo(context, culture, guid, typeof(Guid)));
-
-            Assert.Equal(string.Empty, (string)mc.ConvertTo(null, typeof(string)));
-            Assert.Equal(string.Empty, (string)mc.ConvertTo(context, CultureInfo.CreateSpecificCulture("ru-RU"), null, typeof(string)));
-        }
-    }
-
-    private class MyTypeDescriptorContext : ITypeDescriptorContext
-    {
-        public IContainer Container => null;
-        public object Instance { get { return null; } }
-        public PropertyDescriptor PropertyDescriptor { get { return null; } }
-        public bool OnComponentChanging() { return true; }
-        public void OnComponentChanged() { }
-        public object GetService(Type serviceType) { return null; }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/SystemBrushesTests.cs b/src/System.Drawing.Common/tests/SystemBrushesTests.cs
deleted file mode 100644
index 208a2feaeb3..00000000000
--- a/src/System.Drawing.Common/tests/SystemBrushesTests.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class SystemBrushesTests
-{
-    public static IEnumerable<object[]> SystemBrushes_TestData()
-    {
-        yield return Brush(() => SystemBrushes.ActiveBorder, SystemColors.ActiveBorder);
-        yield return Brush(() => SystemBrushes.ActiveCaption, SystemColors.ActiveCaption);
-        yield return Brush(() => SystemBrushes.ActiveCaptionText, SystemColors.ActiveCaptionText);
-        yield return Brush(() => SystemBrushes.AppWorkspace, SystemColors.AppWorkspace);
-        yield return Brush(() => SystemBrushes.ButtonFace, SystemColors.ButtonFace);
-        yield return Brush(() => SystemBrushes.ButtonHighlight, SystemColors.ButtonHighlight);
-        yield return Brush(() => SystemBrushes.ButtonShadow, SystemColors.ButtonShadow);
-        yield return Brush(() => SystemBrushes.Control, SystemColors.Control);
-        yield return Brush(() => SystemBrushes.ControlDark, SystemColors.ControlDark);
-        yield return Brush(() => SystemBrushes.ControlDarkDark, SystemColors.ControlDarkDark);
-        yield return Brush(() => SystemBrushes.ControlLight, SystemColors.ControlLight);
-        yield return Brush(() => SystemBrushes.ControlLightLight, SystemColors.ControlLightLight);
-        yield return Brush(() => SystemBrushes.ControlText, SystemColors.ControlText);
-        yield return Brush(() => SystemBrushes.Desktop, SystemColors.Desktop);
-        yield return Brush(() => SystemBrushes.GradientActiveCaption, SystemColors.GradientActiveCaption);
-        yield return Brush(() => SystemBrushes.GradientInactiveCaption, SystemColors.GradientInactiveCaption);
-        yield return Brush(() => SystemBrushes.GrayText, SystemColors.GrayText);
-        yield return Brush(() => SystemBrushes.Highlight, SystemColors.Highlight);
-        yield return Brush(() => SystemBrushes.HighlightText, SystemColors.HighlightText);
-        yield return Brush(() => SystemBrushes.HotTrack, SystemColors.HotTrack);
-        yield return Brush(() => SystemBrushes.InactiveBorder, SystemColors.InactiveBorder);
-        yield return Brush(() => SystemBrushes.InactiveCaption, SystemColors.InactiveCaption);
-        yield return Brush(() => SystemBrushes.InactiveCaptionText, SystemColors.InactiveCaptionText);
-        yield return Brush(() => SystemBrushes.Info, SystemColors.Info);
-        yield return Brush(() => SystemBrushes.InfoText, SystemColors.InfoText);
-        yield return Brush(() => SystemBrushes.Menu, SystemColors.Menu);
-        yield return Brush(() => SystemBrushes.MenuBar, SystemColors.MenuBar);
-        yield return Brush(() => SystemBrushes.MenuHighlight, SystemColors.MenuHighlight);
-        yield return Brush(() => SystemBrushes.MenuText, SystemColors.MenuText);
-        yield return Brush(() => SystemBrushes.ScrollBar, SystemColors.ScrollBar);
-        yield return Brush(() => SystemBrushes.Window, SystemColors.Window);
-        yield return Brush(() => SystemBrushes.WindowFrame, SystemColors.WindowFrame);
-        yield return Brush(() => SystemBrushes.WindowText, SystemColors.WindowText);
-    }
-
-    public static object[] Brush(Func<Brush> getBrush, Color expectedColor) => new object[] { getBrush, expectedColor };
-
-    [Theory]
-    [MemberData(nameof(SystemBrushes_TestData))]
-    public void SystemBrushes_Get_ReturnsExpected(Func<Brush> getBrush, Color expectedColor)
-    {
-        SolidBrush brush = Assert.IsType<SolidBrush>(getBrush());
-        Assert.Equal(expectedColor, brush.Color);
-        AssertExtensions.Throws<ArgumentException>(null, () => brush.Color = Color.Red);
-
-        Assert.Same(brush, getBrush());
-    }
-
-    [Fact]
-    public void FromSystemColor_NotSystemColor_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => SystemBrushes.FromSystemColor(Color.Blue));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/SystemFontsTests.cs b/src/System.Drawing.Common/tests/SystemFontsTests.cs
deleted file mode 100644
index 4ba71824aa1..00000000000
--- a/src/System.Drawing.Common/tests/SystemFontsTests.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Drawing.Tests;
-
-public class SystemFontsTests
-{
-    public static IEnumerable<object[]> SystemFonts_TestData()
-    {
-        yield return new object[] { (Func<Font>)(() => SystemFonts.CaptionFont) };
-        yield return new object[] { (Func<Font>)(() => SystemFonts.IconTitleFont) };
-        yield return new object[] { (Func<Font>)(() => SystemFonts.MenuFont) };
-        yield return new object[] { (Func<Font>)(() => SystemFonts.MessageBoxFont) };
-        yield return new object[] { (Func<Font>)(() => SystemFonts.SmallCaptionFont) };
-        yield return new object[] { (Func<Font>)(() => SystemFonts.StatusFont) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SystemFonts_TestData))]
-    public void SystemFont_Get_ReturnsExpected(Func<Font> getFont)
-    {
-        using (Font font = getFont())
-        using (Font otherFont = getFont())
-        {
-            Assert.NotNull(font);
-            Assert.NotNull(otherFont);
-            Assert.NotSame(font, otherFont);
-
-            // Assert.Equal on a font will use the native handle to assert equality, which is not always guaranteed.
-            Assert.Equal(font.Name, otherFont.Name);
-        }
-    }
-
-    public static IEnumerable<object[]> SystemFonts_WindowsNames_TestData()
-    {
-        int userLangId = GetUserDefaultLCID();
-        SystemFontList fonts;
-
-        switch (userLangId & 0x3ff)
-        {
-            case 0x11: // ja-JP (Japanese)
-                fonts = new SystemFontList("Yu Gothic UI");
-                break;
-            case 0x5C: // chr-Cher-US (Cherokee)
-                fonts = new SystemFontList("Gadugi");
-                break;
-            case 0x12: // ko-KR (Korean)
-                fonts = new SystemFontList("\ub9d1\uc740\x20\uace0\ub515");
-                break;
-            case 0x4: // zh-TW (Traditional Chinese, Taiwan) or zh-CN (Simplified Chinese, PRC)
-                // Although the primary language ID is the same, the fonts are different
-                // So we have to determine by the full language ID
-                // https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/70feba9f-294e-491e-b6eb-56532684c37f
-                // Assuming this doc is correct AND the font only differs by whether it's traditional or not it should work
-                switch (userLangId & 0xFFFF)
-                {
-                    case 0x0004: // zh-Hans
-                    case 0x7804: // zh
-                    case 0x0804: // zh-CN
-                    case 0x1004: // zh-SG
-                        fonts = new SystemFontList("Microsoft JhengHei UI");
-                        break;
-                    case 0x7C04: // zh-Hant
-                    case 0x0C04: // zh-HK
-                    case 0x1404: // zh-MO
-                    case 0x0404: // zh-TW
-                        fonts = new SystemFontList("Microsoft YaHei UI");
-                        break;
-                    default:
-                        throw new InvalidOperationException("The primary language ID is Chinese, however it was not able to" +
-                                                            $" determine the user locale from the LCID with value: {userLangId & 0xFFFF:X4}.");
-                }
-                break;
-            case 0x1E: // th-TH
-            case 0x54: // lo-LA
-            case 0x53: // km-KH
-                fonts = new SystemFontList("Leelawadee UI");
-                break;
-            case 0x4A: // te-IN
-            case 0x49: // ta-IN
-            case 0x5B: // si-LK
-            case 0x48: // or-IN
-            case 0x4E: // mr-IN
-            case 0x4C: // ml-IN
-            case 0x57: // kok-IN
-            case 0x45: // bn-BD
-            case 0x4D: // as-IN
-                fonts = new SystemFontList("Nirmala UI");
-                break;
-            case 0x5E: // am-ET
-                fonts = new SystemFontList("Ebrima");
-                break;
-            default: // For now we assume everything else uses Segoe UI
-                // If there's other failure reported we can add it
-                fonts = new SystemFontList("Segoe UI");
-                break;
-        }
-
-        return fonts.ToTestData();
-    }
-
-    [Theory]
-    [MemberData(nameof(SystemFonts_WindowsNames_TestData))]
-    public void SystemFont_Get_ReturnsExpected_WindowsNames(Func<Font> getFont, string systemFontName, string windowsFontName)
-    {
-        using (Font font = getFont())
-        using (Font otherFont = getFont())
-        using (Font fontFromName = SystemFonts.GetFontByName(systemFontName))
-        {
-            Assert.NotSame(font, otherFont);
-            Assert.Equal(font, otherFont);
-            Assert.Equal(font, fontFromName);
-
-            Assert.Equal(systemFontName, font.SystemFontName);
-
-            // Windows 8 updated some system fonts.
-            if (!PlatformDetection.IsWindows7)
-            {
-                Assert.Equal(windowsFontName, font.Name);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("captionfont")]
-    public void GetFontByName_NoSuchName_ReturnsNull(string systemFontName)
-    {
-        Assert.Null(SystemFonts.GetFontByName(systemFontName));
-    }
-
-    [DllImport("kernel32.dll", SetLastError = false, CharSet = CharSet.Auto)]
-    internal static extern int GetUserDefaultLCID();
-
-    // Do not test DefaultFont and DialogFont, as we can't reliably determine from LCID
-    // https://github.com/dotnet/runtime/issues/28830#issuecomment-473556522
-    class SystemFontList
-    {
-        public SystemFontList(string c_it_m_mb_scFonts)
-        {
-            CaptionFont = c_it_m_mb_scFonts;
-            IconTitleFont = c_it_m_mb_scFonts;
-            MenuFont = c_it_m_mb_scFonts;
-            MessageBoxFont = c_it_m_mb_scFonts;
-            SmallCaptionFont = c_it_m_mb_scFonts;
-            StatusFont = c_it_m_mb_scFonts;
-        }
-
-        public string CaptionFont { get; set; }
-        public string IconTitleFont { get; set; }
-        public string MenuFont { get; set; }
-        public string MessageBoxFont { get; set; }
-        public string SmallCaptionFont { get; set; }
-        public string StatusFont { get; set; }
-
-        public IEnumerable<object[]> ToTestData()
-        {
-            return new []
-            {
-            new object[] {(Func<Font>)(() => SystemFonts.CaptionFont), nameof(CaptionFont), CaptionFont},
-            new object[] {(Func<Font>)(() => SystemFonts.IconTitleFont), nameof(IconTitleFont), IconTitleFont},
-            new object[] {(Func<Font>)(() => SystemFonts.MenuFont), nameof(MenuFont), MenuFont},
-            new object[] {(Func<Font>)(() => SystemFonts.MessageBoxFont), nameof(MessageBoxFont), MessageBoxFont},
-            new object[] {(Func<Font>)(() => SystemFonts.SmallCaptionFont), nameof(SmallCaptionFont), SmallCaptionFont},
-            new object[] {(Func<Font>)(() => SystemFonts.StatusFont), nameof(StatusFont), StatusFont}
-            };
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/SystemIconsTests.cs b/src/System.Drawing.Common/tests/SystemIconsTests.cs
deleted file mode 100644
index 26c84b6edee..00000000000
--- a/src/System.Drawing.Common/tests/SystemIconsTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Tests;
-
-public class SystemIconsTests
-{
-    public static IEnumerable<object[]> SystemIcons_TestData()
-    {
-        yield return Icon(() => SystemIcons.Application);
-        yield return Icon(() => SystemIcons.Asterisk);
-        yield return Icon(() => SystemIcons.Error);
-        yield return Icon(() => SystemIcons.Exclamation);
-        yield return Icon(() => SystemIcons.Hand);
-        yield return Icon(() => SystemIcons.Information);
-        yield return Icon(() => SystemIcons.Question);
-        yield return Icon(() => SystemIcons.Shield);
-        yield return Icon(() => SystemIcons.Warning);
-        yield return Icon(() => SystemIcons.WinLogo);
-    }
-
-    public static object[] Icon(Func<Icon> getIcon) => new object[] { getIcon };
-
-    [Theory]
-    [MemberData(nameof(SystemIcons_TestData))]
-    public void SystemIcons_Get_ReturnsExpected(Func<Icon> getIcon)
-    {
-        Icon icon = getIcon();
-        Assert.Same(icon, getIcon());
-    }
-
-    [Theory]
-    [EnumData<StockIconId>]
-    public void SystemIcons_GetStockIcon(StockIconId stockIcon)
-    {
-        using Icon icon = SystemIcons.GetStockIcon(stockIcon);
-        Assert.NotNull(icon);
-    }
-
-    [Fact]
-    public void SystemIcons_GetStockIcon_BySize()
-    {
-        using Icon icon = SystemIcons.GetStockIcon(StockIconId.Lock, size: 256);
-        Assert.NotNull(icon);
-        Assert.Equal(256, icon.Width);
-        Assert.Equal(256, icon.Height);
-    }
-
-    [Fact]
-    public void SystemIcons_GetStockIcon_InvalidId_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => SystemIcons.GetStockIcon((StockIconId)(-1)));
-    }
-
-    public static TheoryData<StockIconOptions> StockIconOptions_TestData => new()
-    {
-        StockIconOptions.LinkOverlay,
-        StockIconOptions.Selected,
-        StockIconOptions.ShellIconSize,
-        StockIconOptions.SmallIcon,
-        StockIconOptions.LinkOverlay | StockIconOptions.Selected | StockIconOptions.ShellIconSize | StockIconOptions.SmallIcon,
-    };
-
-    [Theory]
-    [MemberData(nameof(StockIconOptions_TestData))]
-    public void SystemIcons_GetStockIcon_Options(StockIconOptions options)
-    {
-        using Icon icon = SystemIcons.GetStockIcon(StockIconId.Shield, options);
-        Assert.NotNull(icon);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/SystemPensTest.cs b/src/System.Drawing.Common/tests/SystemPensTest.cs
deleted file mode 100644
index 9afb2aeb4f5..00000000000
--- a/src/System.Drawing.Common/tests/SystemPensTest.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-
-namespace System.Drawing.Tests;
-
-public class SystemPensTests
-{
-    public static IEnumerable<object[]> SystemPens_TestData()
-    {
-        yield return Pen(() => SystemPens.ActiveBorder, SystemColors.ActiveBorder);
-        yield return Pen(() => SystemPens.ActiveCaption, SystemColors.ActiveCaption);
-        yield return Pen(() => SystemPens.ActiveCaptionText, SystemColors.ActiveCaptionText);
-        yield return Pen(() => SystemPens.AppWorkspace, SystemColors.AppWorkspace);
-        yield return Pen(() => SystemPens.ButtonFace, SystemColors.ButtonFace);
-        yield return Pen(() => SystemPens.ButtonHighlight, SystemColors.ButtonHighlight);
-        yield return Pen(() => SystemPens.ButtonShadow, SystemColors.ButtonShadow);
-        yield return Pen(() => SystemPens.Control, SystemColors.Control);
-        yield return Pen(() => SystemPens.ControlDark, SystemColors.ControlDark);
-        yield return Pen(() => SystemPens.ControlDarkDark, SystemColors.ControlDarkDark);
-        yield return Pen(() => SystemPens.ControlLight, SystemColors.ControlLight);
-        yield return Pen(() => SystemPens.ControlLightLight, SystemColors.ControlLightLight);
-        yield return Pen(() => SystemPens.ControlText, SystemColors.ControlText);
-        yield return Pen(() => SystemPens.Desktop, SystemColors.Desktop);
-        yield return Pen(() => SystemPens.GradientActiveCaption, SystemColors.GradientActiveCaption);
-        yield return Pen(() => SystemPens.GradientInactiveCaption, SystemColors.GradientInactiveCaption);
-        yield return Pen(() => SystemPens.GrayText, SystemColors.GrayText);
-        yield return Pen(() => SystemPens.Highlight, SystemColors.Highlight);
-        yield return Pen(() => SystemPens.HighlightText, SystemColors.HighlightText);
-        yield return Pen(() => SystemPens.HotTrack, SystemColors.HotTrack);
-        yield return Pen(() => SystemPens.InactiveBorder, SystemColors.InactiveBorder);
-        yield return Pen(() => SystemPens.InactiveCaption, SystemColors.InactiveCaption);
-        yield return Pen(() => SystemPens.InactiveCaptionText, SystemColors.InactiveCaptionText);
-        yield return Pen(() => SystemPens.Info, SystemColors.Info);
-        yield return Pen(() => SystemPens.InfoText, SystemColors.InfoText);
-        yield return Pen(() => SystemPens.Menu, SystemColors.Menu);
-        yield return Pen(() => SystemPens.MenuBar, SystemColors.MenuBar);
-        yield return Pen(() => SystemPens.MenuHighlight, SystemColors.MenuHighlight);
-        yield return Pen(() => SystemPens.MenuText, SystemColors.MenuText);
-        yield return Pen(() => SystemPens.ScrollBar, SystemColors.ScrollBar);
-        yield return Pen(() => SystemPens.Window, SystemColors.Window);
-        yield return Pen(() => SystemPens.WindowFrame, SystemColors.WindowFrame);
-        yield return Pen(() => SystemPens.WindowText, SystemColors.WindowText);
-    }
-
-    public static object[] Pen(Func<Pen> getPen, Color expectedColor) => new object[] { getPen, expectedColor };
-
-    [Theory]
-    [MemberData(nameof(SystemPens_TestData))]
-    public void SystemPens_Get_ReturnsExpected(Func<Pen> getPen, Color expectedColor)
-    {
-        Pen pen = getPen();
-        Assert.Equal(expectedColor, pen.Color);
-        Assert.Equal(PenType.SolidColor, pen.PenType);
-        Assert.Same(pen, getPen());
-
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Dispose());
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.SetLineCap(LineCap.ArrowAnchor, LineCap.Custom, DashCap.Round));
-
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Alignment = PenAlignment.Center);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Brush = null);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Color = Color.AliceBlue);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.CompoundArray = null);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomEndCap = null);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.CustomStartCap = null);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.DashCap = DashCap.Flat);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.DashStyle = DashStyle.Custom);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.DashOffset = 10);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.DashPattern = null);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.EndCap = LineCap.RoundAnchor);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.LineJoin = LineJoin.MiterClipped);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.MiterLimit = 10);
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.StartCap = LineCap.RoundAnchor);
-        using (var matrix = new Matrix())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => pen.Transform = matrix);
-        }
-        AssertExtensions.Throws<ArgumentException>(null, () => pen.Width = 10);
-    }
-
-    [Fact]
-    public void FromSystemColor_NotSystemColor_ThrowsArgumentException()
-    {
-        AssertExtensions.Throws<ArgumentException>(null, () => SystemPens.FromSystemColor(Color.Blue));
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Text/InstalledFontCollectionTests.cs b/src/System.Drawing.Common/tests/Text/InstalledFontCollectionTests.cs
deleted file mode 100644
index 6c16f2a3e6d..00000000000
--- a/src/System.Drawing.Common/tests/Text/InstalledFontCollectionTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Text.Tests;
-
-[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported))]
-public class InstalledFontCollectionTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var fontCollection = new InstalledFontCollection())
-        {
-            Assert.NotEmpty(fontCollection.Families);
-        }
-    }
-
-    [Fact]
-    public void Families_GetWhenDisposed_ReturnsNonEmpty()
-    {
-        var fontCollection = new InstalledFontCollection();
-        fontCollection.Dispose();
-
-        Assert.NotEmpty(fontCollection.Families);
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Nop()
-    {
-        var fontCollection = new InstalledFontCollection();
-        fontCollection.Dispose();
-        fontCollection.Dispose();
-    }
-}
diff --git a/src/System.Drawing.Common/tests/Text/PrivateFontCollectionTests.cs b/src/System.Drawing.Common/tests/Text/PrivateFontCollectionTests.cs
deleted file mode 100644
index 82f2fdea9bc..00000000000
--- a/src/System.Drawing.Common/tests/Text/PrivateFontCollectionTests.cs
+++ /dev/null
@@ -1,237 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Drawing.Text.Tests;
-
-public class PrivateFontCollectionTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            Assert.Empty(fontCollection.Families);
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_AbsolutePath_Success()
-    {
-        // GDI+ on Windows 7 incorrectly throws a FileNotFoundException.
-        if (PlatformDetection.IsWindows7)
-        {
-            return;
-        }
-
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestBitmapPath("empty.file"));
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            FontFamily fontFamily = Assert.Single(fontCollection.Families);
-            Assert.Equal("Code New Roman", fontFamily.Name);
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_RelativePath_Success()
-    {
-        // GDI+ on Windows 7 incorrectly throws a FileNotFoundException.
-        if (PlatformDetection.IsWindows7)
-        {
-            return;
-        }
-
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            string relativePath = Path.Combine("fonts", "CodeNewRoman.ttf");
-            fontCollection.AddFontFile(relativePath);
-
-            FontFamily fontFamily = Assert.Single(fontCollection.Families);
-            Assert.Equal("Code New Roman", fontFamily.Name);
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_SamePathMultipleTimes_FamiliesContainsOnlyOneFont()
-    {
-        // GDI+ on Windows 7 incorrectly throws a FileNotFoundException.
-        if (PlatformDetection.IsWindows7)
-        {
-            return;
-        }
-
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.ttf"));
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.ttf"));
-
-            FontFamily fontFamily = Assert.Single(fontCollection.Families);
-            Assert.Equal("Code New Roman", fontFamily.Name);
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_SameNameMultipleTimes_FamiliesContainsFirstFontOnly()
-    {
-        // GDI+ on Windows 7 incorrectly throws a FileNotFoundException.
-        if (PlatformDetection.IsWindows7)
-        {
-            return;
-        }
-
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.ttf"));
-            fontCollection.AddFontFile(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            // Verify that the first file is used by checking that it contains metadata
-            // associated with CodeNewRoman.ttf.
-            const int FrenchLCID = 1036;
-            FontFamily fontFamily = Assert.Single(fontCollection.Families);
-            Assert.Equal("Code New Roman", fontFamily.Name);
-            Assert.Equal("Bonjour", fontFamily.GetName(FrenchLCID));
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_NullFileName_ThrowsArgumentNullException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            AssertExtensions.Throws<ArgumentNullException>("filename", "path", () => fontCollection.AddFontFile(null));
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_InvalidPath_ThrowsArgumentException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            AssertExtensions.Throws<ArgumentException>("path", null, () => fontCollection.AddFontFile(string.Empty));
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_NoSuchFilePath_ThrowsFileNotFoundException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            Assert.Throws<FileNotFoundException>(() => fontCollection.AddFontFile("fileName"));
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_LongFilePath_ThrowsException()
-    {
-        using var fontCollection = new PrivateFontCollection();
-        Assert.Throws<FileNotFoundException>(
-            () => fontCollection.AddFontFile(new string('a', 261)));
-    }
-
-    [Fact]
-    public void AddFontFile_Directory_ThrowsFileNotFoundException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            AssertExtensions.Throws<FileNotFoundException, ExternalException>(() => fontCollection.AddFontFile(AppContext.BaseDirectory));
-        }
-    }
-
-    [Fact]
-    public void AddFontFile_Disposed_ThrowsArgumentException()
-    {
-        var fontCollection = new PrivateFontCollection();
-        fontCollection.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontCollection.AddFontFile("fileName"));
-    }
-
-    [Fact]
-    public void AddMemoryFont_ValidMemory_Success()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            byte[] data = File.ReadAllBytes(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            IntPtr fontBuffer = Marshal.AllocCoTaskMem(data.Length);
-            try
-            {
-                Marshal.Copy(data, 0, fontBuffer, data.Length);
-                fontCollection.AddMemoryFont(fontBuffer, data.Length);
-
-                FontFamily font = Assert.Single(fontCollection.Families);
-                Assert.Equal("Code New Roman", font.Name);
-            }
-            finally
-            {
-                Marshal.FreeCoTaskMem(fontBuffer);
-            }
-        }
-    }
-
-    [Fact]
-    public void AddMemoryFont_ZeroMemory_ThrowsArgumentException()
-    {
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => fontCollection.AddMemoryFont(IntPtr.Zero, 100));
-        }
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void AddMemoryFont_InvalidLength_ThrowsArgumentException(int length)
-    {
-        // GDI+ on Windows 7 incorrectly throws a FileNotFoundException.
-        if (PlatformDetection.IsWindows)
-        {
-            return;
-        }
-
-        using (var fontCollection = new PrivateFontCollection())
-        {
-            byte[] data = File.ReadAllBytes(Helpers.GetTestFontPath("CodeNewRoman.otf"));
-
-            IntPtr fontBuffer = Marshal.AllocCoTaskMem(data.Length);
-            try
-            {
-                Marshal.Copy(data, 0, fontBuffer, data.Length);
-                AssertExtensions.Throws<ArgumentException>(null, () => fontCollection.AddMemoryFont(fontBuffer, length));
-            }
-            finally
-            {
-                Marshal.FreeCoTaskMem(fontBuffer);
-            }
-        }
-    }
-
-    [Fact]
-    public void AddMemoryFont_Disposed_ThrowsArgumentException()
-    {
-        var fontCollection = new PrivateFontCollection();
-        fontCollection.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontCollection.AddMemoryFont((IntPtr)10, 100));
-    }
-
-    [Fact]
-    public void Families_GetWhenDisposed_ThrowsArgumentException()
-    {
-        var fontCollection = new PrivateFontCollection();
-        fontCollection.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => fontCollection.Families);
-    }
-
-    [Fact]
-    public void Dispose_MultipleTimes_Nop()
-    {
-        var fontCollection = new PrivateFontCollection();
-        fontCollection.Dispose();
-        fontCollection.Dispose();
-    }
-}
diff --git a/src/System.Drawing.Common/tests/TextureBrushTests.cs b/src/System.Drawing.Common/tests/TextureBrushTests.cs
deleted file mode 100644
index 35bcd32821d..00000000000
--- a/src/System.Drawing.Common/tests/TextureBrushTests.cs
+++ /dev/null
@@ -1,898 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-
-namespace System.Drawing.Tests;
-
-public class TextureBrushTests
-{
-    public static IEnumerable<object[]> Ctor_Bitmap_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10), PixelFormat.Format32bppPArgb, new Size(10, 10) };
-        yield return new object[] { new Metafile(Helpers.GetTestBitmapPath("telescope_01.wmf")), PixelFormat.Format32bppArgb, new Size(490, 654) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Bitmap_TestData))]
-    public void Ctor_Bitmap(Image bitmap, PixelFormat expectedPixelFormat, Size expectedSize)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(bitmap))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(bitmap, brushImage);
-                Assert.Equal(expectedPixelFormat, brushImage.PixelFormat);
-                Assert.Equal(expectedSize, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(WrapMode.Tile, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void Ctor_BitmapFromIconHandle_Success()
-    {
-        using (var icon = new Icon(Helpers.GetTestBitmapPath("10x16_one_entry_32bit.ico")))
-        using (var image = Bitmap.FromHicon(icon.Handle))
-        {
-            Ctor_Bitmap(image, PixelFormat.Format32bppPArgb, new Size(11, 22));
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Image_WrapMode_TestData()
-    {
-        foreach (object[] data in Ctor_Bitmap_TestData())
-        {
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.Clamp, data[1], data[2] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.Tile, data[1], data[2] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipX, data[1], data[2] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipXY, data[1], data[2] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipY, data[1], data[2] };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_WrapMode_TestData))]
-    public void Ctor_Image_WrapMode(Image image, WrapMode wrapMode, PixelFormat expectedPixelFormat, Size expectedSize)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, wrapMode))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(expectedPixelFormat, brushImage.PixelFormat);
-                Assert.Equal(expectedSize, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(wrapMode, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Image_Rectangle_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10), new Rectangle(0, 0, 10, 10) };
-        yield return new object[] { new Bitmap(10, 10), new Rectangle(5, 5, 5, 5) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_Rectangle_TestData))]
-    public void Ctor_Image_Rectangle(Image image, Rectangle rectangle)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, rectangle))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(WrapMode.Tile, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_Rectangle_TestData))]
-    public void Ctor_Image_RectangleF(Image image, Rectangle rectangle)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, (RectangleF)rectangle))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(WrapMode.Tile, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Image_WrapMode_Rectangle_TestData()
-    {
-        foreach (object[] data in Ctor_Image_Rectangle_TestData())
-        {
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.Clamp, data[1] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.Tile, data[1] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipX, data[1] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipXY, data[1] };
-            yield return new object[] { ((Image)data[0]).Clone(), WrapMode.TileFlipY, data[1] };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_WrapMode_Rectangle_TestData))]
-    public void Ctor_Image_WrapMode_Rectangle(Image image, WrapMode wrapMode, Rectangle rectangle)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, wrapMode, rectangle))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(wrapMode, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_WrapMode_Rectangle_TestData))]
-    public void Ctor_Image_WrapMode_RectangleF(Image image, WrapMode wrapMode, Rectangle rectangle)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, wrapMode, (RectangleF)rectangle))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(wrapMode, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Image_Rectangle_ImageAttributes_TestData()
-    {
-        foreach (object[] data in Ctor_Image_Rectangle_TestData())
-        {
-            yield return new object[] { ((Image)data[0]).Clone(), data[1], null, WrapMode.Tile };
-            yield return new object[] { ((Image)data[0]).Clone(), data[1], new ImageAttributes(), WrapMode.Clamp };
-
-            var customWrapMode = new ImageAttributes();
-            customWrapMode.SetWrapMode(WrapMode.TileFlipXY);
-            yield return new object[] { ((Image)data[0]).Clone(), data[1], customWrapMode, WrapMode.TileFlipXY };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_Rectangle_ImageAttributes_TestData))]
-    public void Ctor_Image_Rectangle_ImageAttributes(Image image, Rectangle rectangle, ImageAttributes attributes, WrapMode expectedWrapMode)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, rectangle, attributes))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(expectedWrapMode, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-            attributes?.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_Rectangle_ImageAttributes_TestData))]
-    public void Ctor_Image_RectangleF_ImageAttributes(Image image, Rectangle rectangle, ImageAttributes attributes, WrapMode expectedWrapMode)
-    {
-        try
-        {
-            using (var brush = new TextureBrush(image, (RectangleF)rectangle, attributes))
-            using (var matrix = new Matrix())
-            {
-                Bitmap brushImage = Assert.IsType<Bitmap>(brush.Image);
-                Assert.NotSame(image, brushImage);
-                Assert.Equal(PixelFormat.Format32bppPArgb, brushImage.PixelFormat);
-                Assert.Equal(rectangle.Size, brushImage.Size);
-                Assert.Equal(matrix, brush.Transform);
-                Assert.Equal(expectedWrapMode, brush.WrapMode);
-            }
-        }
-        finally
-        {
-            image.Dispose();
-            attributes?.Dispose();
-        }
-    }
-
-    [Fact]
-    public void Ctor_NullImage_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, WrapMode.Tile));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, RectangleF.Empty));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, Rectangle.Empty));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, RectangleF.Empty, null));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, Rectangle.Empty, null));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, WrapMode.Tile, RectangleF.Empty));
-        AssertExtensions.Throws<ArgumentNullException>("image", () => new TextureBrush(null, WrapMode.Tile, Rectangle.Empty));
-    }
-
-    [Fact]
-    public void Ctor_DisposedImage_ThrowsArgumentException()
-    {
-        var image = new Bitmap(10, 10);
-        image.Dispose();
-
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, WrapMode.Tile));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, RectangleF.Empty));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, Rectangle.Empty));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, RectangleF.Empty, null));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, Rectangle.Empty, null));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, WrapMode.Tile, RectangleF.Empty));
-        AssertExtensions.Throws<ArgumentException>(null, () => new TextureBrush(image, WrapMode.Tile, Rectangle.Empty));
-    }
-
-    [Theory]
-    [InlineData(WrapMode.Tile - 1)]
-    [InlineData(WrapMode.Clamp + 1)]
-    public void Ctor_InvalidWrapMode_ThrowsInvalidEnumArgumentException(WrapMode wrapMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => new TextureBrush(image, wrapMode));
-            Assert.ThrowsAny<ArgumentException>(() => new TextureBrush(image, wrapMode, RectangleF.Empty));
-            Assert.ThrowsAny<ArgumentException>(() => new TextureBrush(image, wrapMode, Rectangle.Empty));
-        }
-    }
-
-    [Theory]
-    [InlineData(-1, 0, 1, 1)]
-    [InlineData(10, 0, 1, 1)]
-    [InlineData(5, 0, 6, 1)]
-    [InlineData(0, -1, 1, 1)]
-    [InlineData(0, 10, 1, 1)]
-    [InlineData(0, 5, 1, 6)]
-    [InlineData(0, 0, 1, 0)]
-    [InlineData(0, 0, 0, 1)]
-    public void Ctor_InvalidRectangle_ThrowsOutOfMemoryException(int x, int y, int width, int height)
-    {
-        var rectangle = new Rectangle(x, y, width, height);
-        using (var image = new Bitmap(10, 10))
-        {
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, rectangle));
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, (RectangleF)rectangle));
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, WrapMode.Tile, rectangle));
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, WrapMode.Tile, (RectangleF)rectangle));
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, rectangle, null));
-            Assert.Throws<OutOfMemoryException>(() => new TextureBrush(image, (RectangleF)rectangle, null));
-        }
-    }
-
-    [Fact]
-    public void Clone_Invoke_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image, WrapMode.Clamp))
-        {
-            TextureBrush clone = Assert.IsType<TextureBrush>(brush.Clone());
-            Assert.NotSame(brush, clone);
-
-            Assert.Equal(new Size(10, 10), brush.Image.Size);
-            Assert.Equal(WrapMode.Clamp, clone.WrapMode);
-        }
-    }
-
-    [Fact]
-    public void Clone_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Clone());
-        }
-    }
-
-    [Fact]
-    public void Image_GetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Image);
-        }
-    }
-
-    public static IEnumerable<object[]> MultiplyTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), new Matrix(1, 2, 3, 4, 5, 6), MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), new Matrix(1, 2, 3, 4, 5, 6), MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), new Matrix(2, 3, 4, 5, 6, 7), MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), new Matrix(2, 3, 4, 5, 6, 7), MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(MultiplyTransform_TestData))]
-    public void MultiplyTransform_Matrix_SetsTransformToExpected(Matrix originalTransform, Matrix matrix, MatrixOrder matrixOrder)
-    {
-        try
-        {
-            using (var image = new Bitmap(10, 10))
-            using (var brush = new TextureBrush(image))
-            using (var expected = (Matrix)originalTransform.Clone())
-            {
-                expected.Multiply(matrix, matrixOrder);
-                brush.Transform = originalTransform;
-
-                if (matrixOrder == MatrixOrder.Prepend)
-                {
-                    TextureBrush clone = (TextureBrush)brush.Clone();
-                    clone.MultiplyTransform(matrix);
-                    Assert.Equal(expected, clone.Transform);
-                }
-
-                brush.MultiplyTransform(matrix, matrixOrder);
-                Assert.Equal(expected, brush.Transform);
-            }
-        }
-        finally
-        {
-            originalTransform.Dispose();
-            matrix.Dispose();
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NullMatrix_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null));
-            AssertExtensions.Throws<ArgumentNullException>("matrix", () => brush.MultiplyTransform(null, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_NotInvertibleMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        using (var matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_DisposedMatrix_Nop()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            brush.Transform = transform;
-
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            brush.MultiplyTransform(matrix);
-            brush.MultiplyTransform(matrix, MatrixOrder.Append);
-
-            Assert.Equal(transform, brush.Transform);
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void MultiplyTransform_InvalidOrder_Nop(MatrixOrder matrixOrder)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix())
-        {
-            brush.Transform = transform;
-
-            brush.MultiplyTransform(matrix, matrixOrder);
-            Assert.Equal(transform, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void MultiplyTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.MultiplyTransform(matrix, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Invoke_SetsTransformToZero()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        using (var transform = new Matrix(1, 2, 3, 4, 5, 6))
-        using (var matrix = new Matrix())
-        {
-            brush.Transform = transform;
-            brush.ResetTransform();
-            Assert.Equal(matrix, brush.Transform);
-
-            brush.ResetTransform();
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void ResetTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ResetTransform());
-        }
-    }
-
-    public static IEnumerable<object[]> RotateTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 90, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 90, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 360, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 360, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -45, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -45, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(RotateTransform_TestData))]
-    public void RotateTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float angle, MatrixOrder matrixOrder)
-    {
-        try
-        {
-            using (var image = new Bitmap(10, 10))
-            using (var brush = new TextureBrush(image))
-            using (Matrix expected = originalTransform.Clone())
-            {
-                expected.Rotate(angle, matrixOrder);
-                brush.Transform = originalTransform;
-
-                if (matrixOrder == MatrixOrder.Prepend)
-                {
-                    TextureBrush clone = (TextureBrush)brush.Clone();
-                    clone.RotateTransform(angle);
-                    Assert.Equal(expected, clone.Transform);
-                }
-
-                brush.RotateTransform(angle, matrixOrder);
-                Assert.Equal(expected, brush.Transform);
-            }
-        }
-        finally
-        {
-            originalTransform.Dispose();
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void RotateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(10, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void RotateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(1));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.RotateTransform(1, MatrixOrder.Prepend));
-        }
-    }
-
-    public static IEnumerable<object[]> ScaleTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(ScaleTransform_TestData))]
-    public void ScaleTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float scaleX, float scaleY, MatrixOrder matrixOrder)
-    {
-        try
-        {
-            using (var image = new Bitmap(10, 10))
-            using (var brush = new TextureBrush(image))
-            using (Matrix expected = originalTransform.Clone())
-            {
-                expected.Scale(scaleX, scaleY, matrixOrder);
-                brush.Transform = originalTransform;
-
-                if (matrixOrder == MatrixOrder.Prepend)
-                {
-                    TextureBrush clone = (TextureBrush)brush.Clone();
-                    clone.ScaleTransform(scaleX, scaleY);
-                    Assert.Equal(expected, clone.Transform);
-                }
-
-                brush.ScaleTransform(scaleX, scaleY, matrixOrder);
-                Assert.Equal(expected, brush.Transform);
-            }
-        }
-        finally
-        {
-            originalTransform.Dispose();
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void ScaleTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(1, 2, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(1, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.ScaleTransform(1, 2, MatrixOrder.Prepend));
-        }
-    }
-
-    [Fact]
-    public void Transform_SetValid_GetReturnsExpected()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        using (var matrix = new Matrix(1, 2, 3, 4, 5, 6))
-        {
-            brush.Transform = matrix;
-            Assert.Equal(matrix, brush.Transform);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetNull_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            AssertExtensions.Throws<ArgumentNullException>("value", () => brush.Transform = null);
-        }
-    }
-
-    [Fact]
-    public void Transform_SetDisposedMatrix_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            var matrix = new Matrix();
-            matrix.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform = matrix);
-        }
-    }
-
-    [Fact]
-    public void Transform_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.Transform = matrix);
-        }
-    }
-
-    public static IEnumerable<object[]> TranslateTransform_TestData()
-    {
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(), 2, 3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0, 0, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 1, 1, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), -2, -3, MatrixOrder.Append };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Prepend };
-        yield return new object[] { new Matrix(1, 2, 3, 4, 5, 6), 0.5, 0.75, MatrixOrder.Append };
-    }
-
-    [Theory]
-    [MemberData(nameof(TranslateTransform_TestData))]
-    public void TranslateTransform_Invoke_SetsTransformToExpected(Matrix originalTransform, float dX, float dY, MatrixOrder matrixOrder)
-    {
-        try
-        {
-            using (var image = new Bitmap(10, 10))
-            using (var brush = new TextureBrush(image))
-            using (Matrix expected = originalTransform.Clone())
-            {
-                expected.Translate(dX, dY, matrixOrder);
-                brush.Transform = originalTransform;
-
-                if (matrixOrder == MatrixOrder.Prepend)
-                {
-                    TextureBrush clone = (TextureBrush)brush.Clone();
-                    clone.TranslateTransform(dX, dY);
-                    Assert.Equal(expected, clone.Transform);
-                }
-
-                brush.TranslateTransform(dX, dY, matrixOrder);
-                Assert.Equal(expected, brush.Transform);
-            }
-        }
-        finally
-        {
-            originalTransform.Dispose();
-        }
-    }
-
-    [Theory]
-    [InlineData(MatrixOrder.Prepend - 1)]
-    [InlineData(MatrixOrder.Append + 1)]
-    public void TranslateTransform_InvalidOrder_ThrowsArgumentException(MatrixOrder matrixOrder)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(1, 2, matrixOrder));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Disposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var matrix = new Matrix())
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(1, 2));
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.TranslateTransform(1, 2, MatrixOrder.Prepend));
-        }
-    }
-
-    [Theory]
-    [InlineData(WrapMode.Clamp)]
-    [InlineData(WrapMode.Tile)]
-    [InlineData(WrapMode.TileFlipX)]
-    [InlineData(WrapMode.TileFlipXY)]
-    [InlineData(WrapMode.TileFlipY)]
-    public void WrapMode_SetValid_GetReturnsExpected(WrapMode wrapMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            brush.WrapMode = wrapMode;
-            Assert.Equal(wrapMode, brush.WrapMode);
-        }
-    }
-
-    [Theory]
-    [InlineData(WrapMode.Tile - 1)]
-    [InlineData(WrapMode.Clamp + 1)]
-    public void WrapMode_SetInvalid_ThrowsInvalidEnumArgumentException(WrapMode wrapMode)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var brush = new TextureBrush(image))
-        {
-            Assert.ThrowsAny<ArgumentException>(() => brush.WrapMode = wrapMode);
-        }
-    }
-
-    [Fact]
-    public void WrapMode_GetSetWhenDisposed_ThrowsArgumentException()
-    {
-        using (var image = new Bitmap(10, 10))
-        {
-            var brush = new TextureBrush(image);
-            brush.Dispose();
-
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode);
-            AssertExtensions.Throws<ArgumentException>(null, () => brush.WrapMode = WrapMode.Tile);
-        }
-    }
-
-    [Fact]
-    public void WrapMode_Clamp_ReturnsExpected()
-    {
-        // R|G|_|_
-        // B|Y|_|_
-        // _|_|_|_
-        // _|_|_|_
-        Color empty = Color.FromArgb(0, 0, 0, 0);
-        VerifyFillRect(WrapMode.Clamp, new Color[][]
-        {
-            new Color[] { Color.Red,    Color.Green,    empty,  empty },
-            new Color[] { Color.Blue,   Color.Yellow,   empty,  empty },
-            new Color[] { empty,        empty,          empty,  empty },
-            new Color[] { empty,        empty,          empty,  empty }
-        });
-    }
-
-    [Fact]
-    public void WrapMode_Tile_ReturnsExpected()
-    {
-        // R|G|R|G
-        // B|Y|B|Y
-        // R|G|R|G
-        // B|Y|B|Y
-        VerifyFillRect(WrapMode.Tile, new Color[][]
-        {
-            new Color[] { Color.Red,  Color.Green,  Color.Red,  Color.Green  },
-            new Color[] { Color.Blue, Color.Yellow, Color.Blue, Color.Yellow },
-            new Color[] { Color.Red,  Color.Green,  Color.Red,  Color.Green  },
-            new Color[] { Color.Blue, Color.Yellow, Color.Blue, Color.Yellow }
-        });
-    }
-
-    [Fact]
-    public void WrapMode_TileFlipX_ReturnsExpected()
-    {
-        // R|G|G|R
-        // B|Y|Y|B
-        // R|G|G|R
-        // B|Y|Y|B
-        VerifyFillRect(WrapMode.TileFlipX, new Color[][]
-        {
-            new Color[] { Color.Red,    Color.Green,    Color.Green,    Color.Red  },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Yellow,   Color.Blue },
-            new Color[] { Color.Red,    Color.Green,    Color.Green,    Color.Red  },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Yellow,   Color.Blue }
-        });
-    }
-
-    [Fact]
-    public void WrapMode_TileFlipY_ReturnsExpected()
-    {
-        // R|G|R|G
-        // B|Y|B|Y
-        // B|Y|B|Y
-        // R|G|R|G
-        VerifyFillRect(WrapMode.TileFlipY, new Color[][]
-        {
-            new Color[] { Color.Red,    Color.Green,    Color.Red,    Color.Green  },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Blue,   Color.Yellow },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Blue,   Color.Yellow },
-            new Color[] { Color.Red,    Color.Green,    Color.Red,    Color.Green  }
-        });
-    }
-
-    [Fact]
-    public void WrapMode_TileFlipXY_ReturnsExpected()
-    {
-        // R|G|G|R
-        // B|Y|Y|B
-        // B|Y|Y|B
-        // R|G|G|R
-        VerifyFillRect(WrapMode.TileFlipXY, new Color[][]
-        {
-            new Color[] { Color.Red,    Color.Green,    Color.Green,    Color.Red  },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Yellow,   Color.Blue },
-            new Color[] { Color.Blue,   Color.Yellow,   Color.Yellow,   Color.Blue },
-            new Color[] { Color.Red,    Color.Green,    Color.Green,    Color.Red  }
-        });
-    }
-
-    private static void VerifyFillRect(WrapMode wrapMode, Color[][] expectedColors)
-    {
-        using (var brushBitmap = new Bitmap(2, 2))
-        {
-            brushBitmap.SetPixel(0, 0, Color.Red);
-            brushBitmap.SetPixel(1, 0, Color.Green);
-            brushBitmap.SetPixel(0, 1, Color.Blue);
-            brushBitmap.SetPixel(1, 1, Color.Yellow);
-
-            using (var brush = new TextureBrush(brushBitmap, wrapMode))
-            using (var targetImage = new Bitmap(4, 4))
-            using (Graphics targetGraphics = Graphics.FromImage(targetImage))
-            {
-                targetGraphics.FillRectangle(brush, new Rectangle(0, 0, 4, 4));
-
-                Helpers.VerifyBitmap(targetImage, expectedColors);
-            }
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/ToolboxBitmapAttributeTests.cs b/src/System.Drawing.Common/tests/ToolboxBitmapAttributeTests.cs
deleted file mode 100644
index 7b9e3438920..00000000000
--- a/src/System.Drawing.Common/tests/ToolboxBitmapAttributeTests.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-
-#pragma warning disable CA1050 // Declare types in namespaces
-public class ClassWithNoNamespace { }
-#pragma warning restore CA1050
-
-namespace System.Drawing.Tests
-{
-    public class bitmap_173x183_indexed_8bit { }
-
-    public class Icon_toolboxBitmapAttributeTest { }
-
-    public class ToolboxBitmapAttributeTests
-    {
-        private static Size DefaultSize = new(16, 16);
-        private void AssertDefaultSize(Image image)
-        {
-            Assert.Equal(DefaultSize, image.Size);
-        }
-
-        public static IEnumerable<object[]> Ctor_FileName_TestData()
-        {
-            yield return new object[] { null, new Size(0, 0) };
-            yield return new object[] { Helpers.GetTestBitmapPath("bitmap_173x183_indexed_8bit.bmp"), new Size(173, 183) };
-            yield return new object[] { Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico"), new Size(16, 16) };
-            yield return new object[] { Helpers.GetTestBitmapPath("invalid.ico"), new Size(0, 0) };
-        }
-
-        [Theory]
-        [MemberData(nameof(Ctor_FileName_TestData))]
-        public void Ctor_FileName(string fileName, Size size)
-        {
-            var attribute = new ToolboxBitmapAttribute(fileName);
-
-            using (Image image = attribute.GetImage(null))
-            {
-                if (size == Size.Empty)
-                {
-                    AssertDefaultSize(image);
-                }
-                else
-                {
-                    Assert.Equal(size, image.Size);
-                }
-            }
-        }
-
-        [Theory]
-        [InlineData(null, -1, -1)]
-        [InlineData(typeof(ClassWithNoNamespace), -1, -1)]
-        [InlineData(typeof(bitmap_173x183_indexed_8bit), 173, 183)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), -1, -1)]
-        public void Ctor_Type(Type type, int width, int height)
-        {
-            var attribute = new ToolboxBitmapAttribute(type);
-            using (Image image = attribute.GetImage(type))
-            {
-                if (width == -1 && height == -1)
-                {
-                    AssertDefaultSize(image);
-                }
-                else
-                {
-                    Assert.Equal(new Size(width, height), image.Size);
-                }
-            }
-        }
-
-        [Theory]
-        [InlineData(null, null, -1, -1)]
-        [InlineData(null, "invalid.ico", -1, -1)]
-        [InlineData(typeof(ClassWithNoNamespace), null, -1, -1)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "", -1, -1)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), null, -1, -1)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "invalid.ico", -1, -1)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "48x48_multiple_entries_4bit", 16, 16)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "48x48_multiple_entries_4bit.ico", 16, 16)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "empty.file", -1, -1)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "bitmap_173x183_indexed_8bit", 173, 183)]
-        [InlineData(typeof(ToolboxBitmapAttributeTests), "bitmap_173x183_indexed_8bit.bmp", 173, 183)]
-        public void Ctor_Type_String(Type type, string fileName, int width, int height)
-        {
-            var attribute = new ToolboxBitmapAttribute(type, fileName);
-
-            using (Image image = attribute.GetImage(type, fileName, false))
-            {
-                if (width == -1 && height == -1)
-                {
-                    AssertDefaultSize(image);
-                }
-                else
-                {
-                    Assert.Equal(new Size(width, height), image.Size);
-                }
-            }
-        }
-
-        [Theory]
-        [InlineData("bitmap_173x183_indexed_8bit.bmp", 173, 183)]
-        [InlineData("48x48_multiple_entries_4bit.ico", 16, 16)]
-        public void GetImage_TypeFileNameBool_ReturnsExpected(string fileName, int width, int height)
-        {
-            var attribute = new ToolboxBitmapAttribute((string)null);
-            using (Image image = attribute.GetImage(typeof(ToolboxBitmapAttributeTests), fileName, large: true))
-            {
-                Assert.Equal(new Size(32, 32), image.Size);
-            }
-
-            using (Image image = attribute.GetImage(typeof(ToolboxBitmapAttributeTests), fileName, large: false))
-            {
-                Assert.Equal(new Size(width, height), image.Size);
-            }
-        }
-
-        [Fact]
-        public void GetImage_NullComponent_ReturnsNull()
-        {
-            var attribute = new ToolboxBitmapAttribute((string)null);
-            Assert.Null(attribute.GetImage((object)null));
-            Assert.Null(attribute.GetImage((object)null, true));
-        }
-
-        [Fact]
-        public void GetImage_Component_ReturnsExpected()
-        {
-            ToolboxBitmapAttribute attribute = new ToolboxBitmapAttribute((string)null);
-
-            using (Image smallImage = attribute.GetImage(new bitmap_173x183_indexed_8bit(), large: false))
-            {
-                Assert.Equal(new Size(173, 183), smallImage.Size);
-
-                using (Image largeImage = attribute.GetImage(new bitmap_173x183_indexed_8bit(), large: true))
-                {
-                    Assert.Equal(new Size(32, 32), largeImage.Size);
-                }
-            }
-        }
-
-        [Fact]
-        public void GetImage_Default_ReturnsExpected()
-        {
-            ToolboxBitmapAttribute attribute = ToolboxBitmapAttribute.Default;
-
-            using (Image image = attribute.GetImage(typeof(ToolboxBitmapAttributeTests), "bitmap_173x183_indexed_8bit", large: true))
-            {
-                Assert.Equal(new Size(32, 32), image.Size);
-            }
-
-            using (Image image = attribute.GetImage(typeof(ToolboxBitmapAttributeTests), "bitmap_173x183_indexed_8bit", large: false))
-            {
-                Assert.Equal(new Size(173, 183), image.Size);
-            }
-        }
-
-        [Theory]
-        [InlineData(typeof(Icon_toolboxBitmapAttributeTest), 256, 256)]
-        public void GetImage_NoExtension(Type type, int width, int height)
-        {
-            var attribute = new ToolboxBitmapAttribute(type);
-            using (Image image = attribute.GetImage(type))
-            {
-                if (width == -1 && height == -1)
-                {
-                    AssertDefaultSize(image);
-                }
-                else
-                {
-                    Assert.Equal(new Size(width, height), image.Size);
-                }
-            }
-        }
-
-        public static IEnumerable<object[]> Equals_TestData()
-        {
-            yield return new object[] { ToolboxBitmapAttribute.Default, ToolboxBitmapAttribute.Default, true };
-            yield return new object[] { ToolboxBitmapAttribute.Default, new ToolboxBitmapAttribute(typeof(ToolboxBitmapAttribute), "bitmap_173x183_indexed_8bit"), true };
-
-            yield return new object[] { ToolboxBitmapAttribute.Default, new object(), false };
-            yield return new object[] { ToolboxBitmapAttribute.Default, null, false };
-        }
-
-        [Theory]
-        [MemberData(nameof(Equals_TestData))]
-        public void Equals_Other_ReturnsExpected(ToolboxBitmapAttribute attribute, object other, bool expected)
-        {
-            Assert.Equal(expected, attribute.Equals(other));
-            Assert.Equal(attribute.GetHashCode(), attribute.GetHashCode());
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/TrimmingTests/IconSave.cs b/src/System.Drawing.Common/tests/TrimmingTests/IconSave.cs
deleted file mode 100644
index 0e15a645c51..00000000000
--- a/src/System.Drawing.Common/tests/TrimmingTests/IconSave.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.IO;
-
-/// <summary>
-/// Tests that Icon.Save works when the Icon is loaded from an IntPtr.
-/// This causes COM to be used to save the Icon.
-/// </summary>
-class Program
-{
-    static int Main(string[] args)
-    {
-        Icon i = SystemIcons.WinLogo;
-        using MemoryStream stream = new();
-
-        i.Save(stream);
-
-        // ensure something was written to the stream
-        if (stream.Position == 0)
-        {
-            return -1;
-        }
-
-        return 100;
-    }
-}
diff --git a/src/System.Drawing.Common/tests/TrimmingTests/System.Drawing.Common.TrimmingTests.proj b/src/System.Drawing.Common/tests/TrimmingTests/System.Drawing.Common.TrimmingTests.proj
deleted file mode 100644
index 71883b846cb..00000000000
--- a/src/System.Drawing.Common/tests/TrimmingTests/System.Drawing.Common.TrimmingTests.proj
+++ /dev/null
@@ -1,15 +0,0 @@
-<Project DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
-
-  <PropertyGroup>
-    <AdditionalProjectReferences>System.Drawing.Common</AdditionalProjectReferences>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <TestConsoleAppSourceFiles Include="IconSave.cs"
-                               TargetOS="windows"
-                               SkipOnTestRuntimes="osx-x64;linux-x64;browser-wasm" />
-  </ItemGroup>
-
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
-</Project>
diff --git a/src/System.Drawing.Common/tests/default.rd.xml b/src/System.Drawing.Common/tests/default.rd.xml
deleted file mode 100644
index c2aeeadaf8e..00000000000
--- a/src/System.Drawing.Common/tests/default.rd.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-<Directives>
-  <Application>
-    <Assembly Name="System.Private.CoreLib">
-      <!-- called by xUnit's Assert.Equal -->
-      <Type Name="System.IEquatable`1[[System.Drawing.Color,System.Drawing.Primitives]]" Dynamic="Required All" />
-      <Type Name="System.IEquatable`1[[System.Drawing.RectangleF,System.Drawing.Primitives]]" Dynamic="Required All" />
-      <Type Name="System.IEquatable`1[[System.Drawing.PointF,System.Drawing.Primitives]]" Dynamic="Required All" />
-    </Assembly>
-    <Assembly Name="System.Drawing.Common.Tests">
-      <Type Name="System.Drawing.Tests.FontTests+LOGFONT" MarshalStructure="Required All" />
-      <Type Name="System.Drawing.Tests.FontTests+UnblittableLOGFONT" MarshalStructure="Required All" />
-    </Assembly>
-  </Application>
-</Directives>
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/BmpCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/BmpCodecTests.cs
deleted file mode 100644
index 741eeaa3881..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/BmpCodecTests.cs
+++ /dev/null
@@ -1,535 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// BMPCodec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// (C) 2004 Ximian, Inc.  http://www.ximian.com
-// Copyright (C) 2004-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class BmpCodecTest
-{
-    /* Checks bitmap features on a known 1bbp bitmap */
-    [Fact]
-    public void Bitmap1bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver1bit.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format4bppIndexed, bmp.PixelFormat);
-            Assert.Equal(173, bmp.Width);
-            Assert.Equal(183, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(173, rect.Width);
-            Assert.Equal(183, rect.Height);
-
-            Assert.Equal(173, bmp.Size.Width);
-            Assert.Equal(183, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap1bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver1bit.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-1, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-8355840, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-8355840, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    /* Checks bitmap features on a known 8bbp bitmap */
-    [Fact]
-    public void Bitmap8bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver8bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format8bppIndexed, bmp.PixelFormat);
-            Assert.Equal(173, bmp.Width);
-            Assert.Equal(183, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(173, rect.Width);
-            Assert.Equal(183, rect.Height);
-
-            Assert.Equal(173, bmp.Size.Width);
-            Assert.Equal(183, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap8bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver8bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-1040, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-6250304, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-12566464, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-6258560, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-8355776, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-12566464, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-2039680, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-4153280, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-12566464, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-6258560, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-12566464, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-1040, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-4144960, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-4137792, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-8355712, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    /* Checks bitmap features on a known 24-bits bitmap */
-    [Fact]
-    public void Bitmap24bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format24bppRgb, bmp.PixelFormat);
-            Assert.Equal(173, bmp.Width);
-            Assert.Equal(183, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(173, rect.Width);
-            Assert.Equal(183, rect.Height);
-
-            Assert.Equal(173, bmp.Size.Width);
-            Assert.Equal(183, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap24bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-1645353, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-461332, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-330005, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-2237489, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-1251105, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-3024947, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-2699070, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-2366734, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-4538413, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-6116681, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-7369076, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-13024729, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-7174020, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-51, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16053503, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-8224431, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16579326, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-2502457, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-9078395, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-12696508, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-70772, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-4346279, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-11583193, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-724763, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-7238268, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-2169612, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-3683883, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-12892867, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-3750464, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-3222844, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-65806, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-2961726, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-2435382, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-2501944, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-9211799, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap24bitData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(-3355456, bmp.GetPixel(163, 1).ToArgb());
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(520, data.Stride);
-                Assert.Equal(183, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(217, *(scan + 0));
-                    Assert.Equal(192, *(scan + 1009));
-                    Assert.Equal(210, *(scan + 2018));
-                    Assert.Equal(196, *(scan + 3027));
-                    Assert.Equal(216, *(scan + 4036));
-                    Assert.Equal(215, *(scan + 5045));
-                    Assert.Equal(218, *(scan + 6054));
-                    Assert.Equal(218, *(scan + 7063));
-                    Assert.Equal(95, *(scan + 8072));
-                    Assert.Equal(9, *(scan + 9081));
-                    Assert.Equal(247, *(scan + 10090));
-                    Assert.Equal(161, *(scan + 11099));
-                    Assert.Equal(130, *(scan + 12108));
-                    Assert.Equal(131, *(scan + 13117));
-                    Assert.Equal(175, *(scan + 14126));
-                    Assert.Equal(217, *(scan + 15135));
-                    Assert.Equal(201, *(scan + 16144));
-                    Assert.Equal(183, *(scan + 17153));
-                    Assert.Equal(236, *(scan + 18162));
-                    Assert.Equal(242, *(scan + 19171));
-                    Assert.Equal(125, *(scan + 20180));
-                    Assert.Equal(193, *(scan + 21189));
-                    Assert.Equal(227, *(scan + 22198));
-                    Assert.Equal(44, *(scan + 23207));
-                    Assert.Equal(230, *(scan + 24216));
-                    Assert.Equal(224, *(scan + 25225));
-                    Assert.Equal(164, *(scan + 26234));
-                    Assert.Equal(43, *(scan + 27243));
-                    Assert.Equal(200, *(scan + 28252));
-                    Assert.Equal(255, *(scan + 29261));
-                    Assert.Equal(226, *(scan + 30270));
-                    Assert.Equal(230, *(scan + 31279));
-                    Assert.Equal(178, *(scan + 32288));
-                    Assert.Equal(224, *(scan + 33297));
-                    Assert.Equal(233, *(scan + 34306));
-                    Assert.Equal(212, *(scan + 35315));
-                    Assert.Equal(153, *(scan + 36324));
-                    Assert.Equal(143, *(scan + 37333));
-                    Assert.Equal(215, *(scan + 38342));
-                    Assert.Equal(116, *(scan + 39351));
-                    Assert.Equal(26, *(scan + 40360));
-                    Assert.Equal(28, *(scan + 41369));
-                    Assert.Equal(75, *(scan + 42378));
-                    Assert.Equal(50, *(scan + 43387));
-                    Assert.Equal(244, *(scan + 44396));
-                    Assert.Equal(191, *(scan + 45405));
-                    Assert.Equal(200, *(scan + 46414));
-                    Assert.Equal(197, *(scan + 47423));
-                    Assert.Equal(232, *(scan + 48432));
-                    Assert.Equal(186, *(scan + 49441));
-                    Assert.Equal(210, *(scan + 50450));
-                    Assert.Equal(215, *(scan + 51459));
-                    Assert.Equal(155, *(scan + 52468));
-                    Assert.Equal(56, *(scan + 53477));
-                    Assert.Equal(149, *(scan + 54486));
-                    Assert.Equal(137, *(scan + 55495));
-                    Assert.Equal(141, *(scan + 56504));
-                    Assert.Equal(36, *(scan + 57513));
-                    Assert.Equal(39, *(scan + 58522));
-                    Assert.Equal(25, *(scan + 59531));
-                    Assert.Equal(44, *(scan + 60540));
-                    Assert.Equal(12, *(scan + 61549));
-                    Assert.Equal(161, *(scan + 62558));
-                    Assert.Equal(179, *(scan + 63567));
-                    Assert.Equal(181, *(scan + 64576));
-                    Assert.Equal(165, *(scan + 65585));
-                    Assert.Equal(182, *(scan + 66594));
-                    Assert.Equal(186, *(scan + 67603));
-                    Assert.Equal(201, *(scan + 68612));
-                    Assert.Equal(49, *(scan + 69621));
-                    Assert.Equal(161, *(scan + 70630));
-                    Assert.Equal(140, *(scan + 71639));
-                    Assert.Equal(2, *(scan + 72648));
-                    Assert.Equal(15, *(scan + 73657));
-                    Assert.Equal(33, *(scan + 74666));
-                    Assert.Equal(17, *(scan + 75675));
-                    Assert.Equal(0, *(scan + 76684));
-                    Assert.Equal(47, *(scan + 77693));
-                    Assert.Equal(4, *(scan + 78702));
-                    Assert.Equal(142, *(scan + 79711));
-                    Assert.Equal(151, *(scan + 80720));
-                    Assert.Equal(124, *(scan + 81729));
-                    Assert.Equal(81, *(scan + 82738));
-                    Assert.Equal(214, *(scan + 83747));
-                    Assert.Equal(217, *(scan + 84756));
-                    Assert.Equal(30, *(scan + 85765));
-                    Assert.Equal(185, *(scan + 86774));
-                    Assert.Equal(200, *(scan + 87783));
-                    Assert.Equal(37, *(scan + 88792));
-                    Assert.Equal(2, *(scan + 89801));
-                    Assert.Equal(41, *(scan + 90810));
-                    Assert.Equal(16, *(scan + 91819));
-                    Assert.Equal(0, *(scan + 92828));
-                    Assert.Equal(146, *(scan + 93837));
-                    Assert.Equal(163, *(scan + 94846));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    /* Checks bitmap features on a known 32-bits bitmap (codec)*/
-    [Fact]
-    public void Bitmap32bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(173, bmp.Width);
-            Assert.Equal(183, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(173, rect.Width);
-            Assert.Equal(183, rect.Height);
-
-            Assert.Equal(173, bmp.Size.Width);
-            Assert.Equal(183, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap32bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(PixelFormat.Format32bppRgb, bmp.PixelFormat);
-            // sampling values from a well known bitmap
-            Assert.Equal(-1579559, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-1645353, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-461332, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-330005, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-2237489, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-1251105, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-3024947, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-2699070, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-2366734, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-4538413, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-6116681, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-7369076, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-13024729, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-7174020, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-51, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16053503, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-8224431, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16579326, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-2502457, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-9078395, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-12696508, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-70772, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-4346279, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-11583193, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-724763, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-7238268, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-2169612, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-3683883, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-12892867, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-3750464, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-3222844, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-65806, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-2961726, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-2435382, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-2501944, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-9211799, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected, bool colorCheck)
-    {
-        string sOutFile = $"linerect-{expected}.bmp";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.BlueViolet, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            bmp.Save(sOutFile, ImageFormat.Bmp);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                if (colorCheck)
-                {
-                    Color color = bmpLoad.GetPixel(10, 10);
-                    Assert.Equal(Color.FromArgb(255, 138, 43, 226), color);
-                }
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format32bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format32bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format32bppRgb, true);
-    }
-
-    [Fact]
-    public void NonInvertedBitmap()
-    {
-        // regression check against http://bugzilla.ximian.com/show_bug.cgi?id=80751
-        string sInFile = Helpers.GetTestBitmapPath("non-inverted.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(90, bmp.Width);
-            Assert.Equal(60, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(90, rect.Width);
-            Assert.Equal(60, rect.Height);
-
-            Assert.Equal(90, bmp.Size.Width);
-            Assert.Equal(60, bmp.Size.Height);
-
-            // sampling values from a well known bitmap
-            Assert.Equal(-16777216, bmp.GetPixel(12, 21).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(21, 37).ToArgb());
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/GifCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/GifCodecTests.cs
deleted file mode 100644
index 5b1fb8f45b1..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/GifCodecTests.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// GIF Codec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class GifCodecTest
-{
-    /* Checks bitmap features on a known 1bbp bitmap */
-    private void Bitmap8bitsFeatures(string filename)
-    {
-        using (Bitmap bmp = new Bitmap(filename))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format8bppIndexed, bmp.PixelFormat);
-            Assert.Equal(110, bmp.Width);
-            Assert.Equal(100, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(110, rect.Width);
-            Assert.Equal(100, rect.Height);
-
-            Assert.Equal(110, bmp.Size.Width);
-            Assert.Equal(100, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap8bitsFeatures_Gif89()
-    {
-        Bitmap8bitsFeatures(Helpers.GetTestBitmapPath("nature24bits.gif"));
-    }
-
-    [Fact]
-    public void Bitmap8bitsFeatures_Gif87()
-    {
-        Bitmap8bitsFeatures(Helpers.GetTestBitmapPath("nature24bits87.gif"));
-    }
-
-    private void Bitmap8bitsPixels(string filename)
-    {
-        using (Bitmap bmp = new Bitmap(filename))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-10644802, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-12630705, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-14537409, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-14672099, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-526863, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-10263970, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-10461317, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-9722415, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-131076, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-2702435, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-6325922, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-12411924, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-131076, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-7766649, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-11512986, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-12616230, bmp.GetPixel(96, 96).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void Bitmap8bitsPixels_Gif89()
-    {
-        Bitmap8bitsPixels(Helpers.GetTestBitmapPath("nature24bits.gif"));
-    }
-
-    [Fact]
-    public void Bitmap8bitsPixels_Gif87()
-    {
-        Bitmap8bitsPixels(Helpers.GetTestBitmapPath("nature24bits87.gif"));
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap8bitsData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature24bits.gif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(332, data.Stride);
-                Assert.Equal(100, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(190, *(scan + 0));
-                    Assert.Equal(217, *(scan + 1009));
-                    Assert.Equal(120, *(scan + 2018));
-                    Assert.Equal(253, *(scan + 3027));
-                    Assert.Equal(233, *(scan + 4036));
-                    Assert.Equal(176, *(scan + 5045));
-                    Assert.Equal(151, *(scan + 6054));
-                    Assert.Equal(220, *(scan + 7063));
-                    Assert.Equal(139, *(scan + 8072));
-                    Assert.Equal(121, *(scan + 9081));
-                    Assert.Equal(160, *(scan + 10090));
-                    Assert.Equal(92, *(scan + 11099));
-                    Assert.Equal(96, *(scan + 12108));
-                    Assert.Equal(64, *(scan + 13117));
-                    Assert.Equal(156, *(scan + 14126));
-                    Assert.Equal(68, *(scan + 15135));
-                    Assert.Equal(156, *(scan + 16144));
-                    Assert.Equal(84, *(scan + 17153));
-                    Assert.Equal(55, *(scan + 18162));
-                    Assert.Equal(68, *(scan + 19171));
-                    Assert.Equal(116, *(scan + 20180));
-                    Assert.Equal(61, *(scan + 21189));
-                    Assert.Equal(69, *(scan + 22198));
-                    Assert.Equal(75, *(scan + 23207));
-                    Assert.Equal(61, *(scan + 24216));
-                    Assert.Equal(66, *(scan + 25225));
-                    Assert.Equal(40, *(scan + 26234));
-                    Assert.Equal(55, *(scan + 27243));
-                    Assert.Equal(53, *(scan + 28252));
-                    Assert.Equal(215, *(scan + 29261));
-                    Assert.Equal(99, *(scan + 30270));
-                    Assert.Equal(67, *(scan + 31279));
-                    Assert.Equal(142, *(scan + 32288));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    [Fact]
-    public void Interlaced()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("81773-interlaced.gif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            for (int i = 0; i < 255; i++)
-            {
-                Color c = bmp.GetPixel(0, i);
-                Assert.Equal(255, c.A);
-                Assert.Equal(i, c.R);
-                Assert.Equal(i, c.G);
-                Assert.Equal(i, c.B);
-            }
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected, bool exactColorCheck)
-    {
-        string sOutFile = $"linerect-{expected}.gif";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.Red, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            bmp.Save(sOutFile, ImageFormat.Gif);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                Color color = bmpLoad.GetPixel(10, 10);
-                if (exactColorCheck)
-                {
-                    Assert.Equal(Color.FromArgb(255, 255, 0, 0), color);
-                }
-                else
-                {
-                    // FIXME: we don't save a pure red (F8 instead of FF) into the file so the color-check assert will fail
-                    // this is due to libgif's QuantizeBuffer. An alternative would be to make our own that checks if less than 256 colors
-                    // are used in the bitmap (or else use QuantizeBuffer).
-                    Assert.Equal(255, color.A);
-                    Assert.True(color.R >= 248);
-                    Assert.Equal(0, color.G);
-                    Assert.Equal(0, color.B);
-                }
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format8bppIndexed, false);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format8bppIndexed, false);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format8bppIndexed, false);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format8bppIndexed, false);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/IconCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/IconCodecTests.cs
deleted file mode 100644
index d53cfb2ae3c..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/IconCodecTests.cs
+++ /dev/null
@@ -1,1979 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// ICO Codec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class IconCodecTest
-{
-    [Fact]
-    public void Image16()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico");
-        using (Image image = Image.FromFile(sInFile))
-        {
-            Assert.True(image.RawFormat.Equals(ImageFormat.Icon));
-            // note that image is "promoted" to 32bits
-            Assert.Equal(PixelFormat.Format32bppArgb, image.PixelFormat);
-            Assert.Equal(73746, image.Flags);
-
-            using (Bitmap bmp = new Bitmap(image))
-            {
-                Assert.True(bmp.RawFormat.Equals(ImageFormat.MemoryBmp));
-                Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-                Assert.Equal(2, bmp.Flags);
-                Assert.Equal(0, bmp.Palette.Entries.Length);
-            }
-        }
-    }
-
-    [Fact]
-    public void Image16_PaletteEntries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico");
-        using (Image image = Image.FromFile(sInFile))
-        {
-            Assert.Equal(0, image.Palette.Entries.Length);
-        }
-    }
-
-    // simley.ico has 48x48, 32x32 and 16x16 images (in that order)
-    [Fact]
-    public void Bitmap16Features()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            // note that image is "promoted" to 32bits
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(16, bmp.Width);
-            Assert.Equal(16, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(16, rect.Width);
-            Assert.Equal(16, rect.Height);
-
-            Assert.Equal(16, bmp.Size.Width);
-            Assert.Equal(16, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap16Features_Palette_Entries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap16Pixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(0, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 0).ToArgb());
-            Assert.Equal(-256, bmp.GetPixel(4, 4).ToArgb());
-            Assert.Equal(-256, bmp.GetPixel(4, 8).ToArgb());
-            Assert.Equal(-8355840, bmp.GetPixel(4, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 0).ToArgb());
-            Assert.Equal(-256, bmp.GetPixel(8, 4).ToArgb());
-            Assert.Equal(-256, bmp.GetPixel(8, 8).ToArgb());
-            Assert.Equal(-256, bmp.GetPixel(8, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 4).ToArgb());
-            Assert.Equal(-8355840, bmp.GetPixel(12, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 12).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap16Data()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_multiple_entries_4bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(16, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(0, *(scan + 0));
-                    Assert.Equal(0, *(scan + 13));
-                    Assert.Equal(0, *(scan + 26));
-                    Assert.Equal(0, *(scan + 39));
-                    Assert.Equal(0, *(scan + 52));
-                    Assert.Equal(0, *(scan + 65));
-                    Assert.Equal(0, *(scan + 78));
-                    Assert.Equal(0, *(scan + 91));
-                    Assert.Equal(0, *(scan + 104));
-                    Assert.Equal(0, *(scan + 117));
-                    Assert.Equal(0, *(scan + 130));
-                    Assert.Equal(0, *(scan + 143));
-                    Assert.Equal(0, *(scan + 156));
-                    Assert.Equal(255, *(scan + 169));
-                    Assert.Equal(0, *(scan + 182));
-                    Assert.Equal(0, *(scan + 195));
-                    Assert.Equal(255, *(scan + 208));
-                    Assert.Equal(255, *(scan + 221));
-                    Assert.Equal(0, *(scan + 234));
-                    Assert.Equal(128, *(scan + 247));
-                    Assert.Equal(0, *(scan + 260));
-                    Assert.Equal(0, *(scan + 273));
-                    Assert.Equal(0, *(scan + 286));
-                    Assert.Equal(255, *(scan + 299));
-                    Assert.Equal(0, *(scan + 312));
-                    Assert.Equal(128, *(scan + 325));
-                    Assert.Equal(0, *(scan + 338));
-                    Assert.Equal(0, *(scan + 351));
-                    Assert.Equal(255, *(scan + 364));
-                    Assert.Equal(0, *(scan + 377));
-                    Assert.Equal(0, *(scan + 390));
-                    Assert.Equal(255, *(scan + 403));
-                    Assert.Equal(255, *(scan + 416));
-                    Assert.Equal(0, *(scan + 429));
-                    Assert.Equal(255, *(scan + 442));
-                    Assert.Equal(0, *(scan + 455));
-                    Assert.Equal(0, *(scan + 468));
-                    Assert.Equal(0, *(scan + 481));
-                    Assert.Equal(255, *(scan + 494));
-                    Assert.Equal(0, *(scan + 507));
-                    Assert.Equal(0, *(scan + 520));
-                    Assert.Equal(0, *(scan + 533));
-                    Assert.Equal(0, *(scan + 546));
-                    Assert.Equal(255, *(scan + 559));
-                    Assert.Equal(0, *(scan + 572));
-                    Assert.Equal(0, *(scan + 585));
-                    Assert.Equal(255, *(scan + 598));
-                    Assert.Equal(0, *(scan + 611));
-                    Assert.Equal(0, *(scan + 624));
-                    Assert.Equal(0, *(scan + 637));
-                    Assert.Equal(128, *(scan + 650));
-                    Assert.Equal(0, *(scan + 663));
-                    Assert.Equal(0, *(scan + 676));
-                    Assert.Equal(0, *(scan + 689));
-                    Assert.Equal(0, *(scan + 702));
-                    Assert.Equal(0, *(scan + 715));
-                    Assert.Equal(0, *(scan + 728));
-                    Assert.Equal(0, *(scan + 741));
-                    Assert.Equal(0, *(scan + 754));
-                    Assert.Equal(0, *(scan + 767));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    // VisualPng.ico only has a 32x32 size available
-    [Fact]
-    public void Bitmap32Features()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("VisualPng.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(32, bmp.Width);
-            Assert.Equal(32, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(32, rect.Width);
-            Assert.Equal(32, rect.Height);
-
-            Assert.Equal(32, bmp.Size.Width);
-            Assert.Equal(32, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap32Features_PaletteEntries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("VisualPng.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap32Pixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("VisualPng.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(0, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-8388608, bmp.GetPixel(0, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 16).ToArgb());
-            Assert.Equal(-65536, bmp.GetPixel(8, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 4).ToArgb());
-            Assert.Equal(-8388608, bmp.GetPixel(12, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 16).ToArgb());
-            Assert.Equal(-65536, bmp.GetPixel(12, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 20).ToArgb());
-            Assert.Equal(-65536, bmp.GetPixel(16, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 4).ToArgb());
-            Assert.Equal(-8388608, bmp.GetPixel(20, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(24, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 20).ToArgb());
-            Assert.Equal(-8388608, bmp.GetPixel(28, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 28).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap32Data()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("VisualPng.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(32, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(0, *(scan + 0));
-                    Assert.Equal(0, *(scan + 13));
-                    Assert.Equal(0, *(scan + 26));
-                    Assert.Equal(0, *(scan + 39));
-                    Assert.Equal(0, *(scan + 52));
-                    Assert.Equal(0, *(scan + 65));
-                    Assert.Equal(0, *(scan + 78));
-                    Assert.Equal(0, *(scan + 91));
-                    Assert.Equal(0, *(scan + 104));
-                    Assert.Equal(0, *(scan + 117));
-                    Assert.Equal(0, *(scan + 130));
-                    Assert.Equal(0, *(scan + 143));
-                    Assert.Equal(0, *(scan + 156));
-                    Assert.Equal(0, *(scan + 169));
-                    Assert.Equal(0, *(scan + 182));
-                    Assert.Equal(0, *(scan + 195));
-                    Assert.Equal(0, *(scan + 208));
-                    Assert.Equal(0, *(scan + 221));
-                    Assert.Equal(0, *(scan + 234));
-                    Assert.Equal(0, *(scan + 247));
-                    Assert.Equal(0, *(scan + 260));
-                    Assert.Equal(0, *(scan + 273));
-                    Assert.Equal(0, *(scan + 286));
-                    Assert.Equal(0, *(scan + 299));
-                    Assert.Equal(0, *(scan + 312));
-                    Assert.Equal(0, *(scan + 325));
-                    Assert.Equal(0, *(scan + 338));
-                    Assert.Equal(0, *(scan + 351));
-                    Assert.Equal(0, *(scan + 364));
-                    Assert.Equal(0, *(scan + 377));
-                    Assert.Equal(0, *(scan + 390));
-                    Assert.Equal(0, *(scan + 403));
-                    Assert.Equal(0, *(scan + 416));
-                    Assert.Equal(0, *(scan + 429));
-                    Assert.Equal(0, *(scan + 442));
-                    Assert.Equal(0, *(scan + 455));
-                    Assert.Equal(0, *(scan + 468));
-                    Assert.Equal(0, *(scan + 481));
-                    Assert.Equal(128, *(scan + 494));
-                    Assert.Equal(0, *(scan + 507));
-                    Assert.Equal(0, *(scan + 520));
-                    Assert.Equal(0, *(scan + 533));
-                    Assert.Equal(0, *(scan + 546));
-                    Assert.Equal(0, *(scan + 559));
-                    Assert.Equal(128, *(scan + 572));
-                    Assert.Equal(0, *(scan + 585));
-                    Assert.Equal(0, *(scan + 598));
-                    Assert.Equal(0, *(scan + 611));
-                    Assert.Equal(0, *(scan + 624));
-                    Assert.Equal(0, *(scan + 637));
-                    Assert.Equal(128, *(scan + 650));
-                    Assert.Equal(0, *(scan + 663));
-                    Assert.Equal(0, *(scan + 676));
-                    Assert.Equal(0, *(scan + 689));
-                    Assert.Equal(0, *(scan + 702));
-                    Assert.Equal(0, *(scan + 715));
-                    Assert.Equal(0, *(scan + 728));
-                    Assert.Equal(0, *(scan + 741));
-                    Assert.Equal(0, *(scan + 754));
-                    Assert.Equal(0, *(scan + 767));
-                    Assert.Equal(0, *(scan + 780));
-                    Assert.Equal(0, *(scan + 793));
-                    Assert.Equal(128, *(scan + 806));
-                    Assert.Equal(0, *(scan + 819));
-                    Assert.Equal(0, *(scan + 832));
-                    Assert.Equal(128, *(scan + 845));
-                    Assert.Equal(0, *(scan + 858));
-                    Assert.Equal(0, *(scan + 871));
-                    Assert.Equal(0, *(scan + 884));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    // 48x48_one_entry_1bit.ico only has a 48x48 size available
-    [Fact]
-    public void Bitmap48Features()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(48, bmp.Width);
-            Assert.Equal(48, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(48, rect.Width);
-            Assert.Equal(48, rect.Height);
-
-            Assert.Equal(48, bmp.Size.Width);
-            Assert.Equal(48, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap48Features_Palette_Entries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap48Pixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-16777216, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 8).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 12).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 16).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 20).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 24).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 28).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 36).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 40).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(4, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 40).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(4, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 8).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 12).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 16).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 20).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 24).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 28).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 36).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(8, 40).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(8, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(12, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(12, 8).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 12).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 16).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 20).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 24).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 28).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 36).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(12, 40).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(12, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(16, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(16, 8).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(16, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 28).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(16, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 36).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(16, 40).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(16, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(20, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(20, 8).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(20, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 16).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(20, 20).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(20, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 28).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(20, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 36).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(20, 40).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(20, 44).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(24, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 4).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(24, 8).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(24, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 16).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap48Data()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_one_entry_1bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(48, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(0, *(scan + 0));
-                    Assert.Equal(0, *(scan + 13));
-                    Assert.Equal(0, *(scan + 26));
-                    Assert.Equal(0, *(scan + 39));
-                    Assert.Equal(0, *(scan + 52));
-                    Assert.Equal(0, *(scan + 65));
-                    Assert.Equal(0, *(scan + 78));
-                    Assert.Equal(0, *(scan + 91));
-                    Assert.Equal(0, *(scan + 104));
-                    Assert.Equal(0, *(scan + 117));
-                    Assert.Equal(0, *(scan + 130));
-                    Assert.Equal(0, *(scan + 143));
-                    Assert.Equal(0, *(scan + 156));
-                    Assert.Equal(0, *(scan + 169));
-                    Assert.Equal(0, *(scan + 182));
-                    Assert.Equal(0, *(scan + 195));
-                    Assert.Equal(0, *(scan + 208));
-                    Assert.Equal(0, *(scan + 221));
-                    Assert.Equal(0, *(scan + 234));
-                    Assert.Equal(0, *(scan + 247));
-                    Assert.Equal(0, *(scan + 260));
-                    Assert.Equal(0, *(scan + 273));
-                    Assert.Equal(0, *(scan + 286));
-                    Assert.Equal(255, *(scan + 299));
-                    Assert.Equal(255, *(scan + 312));
-                    Assert.Equal(255, *(scan + 325));
-                    Assert.Equal(255, *(scan + 338));
-                    Assert.Equal(255, *(scan + 351));
-                    Assert.Equal(255, *(scan + 364));
-                    Assert.Equal(255, *(scan + 377));
-                    Assert.Equal(255, *(scan + 390));
-                    Assert.Equal(255, *(scan + 403));
-                    Assert.Equal(255, *(scan + 416));
-                    Assert.Equal(0, *(scan + 429));
-                    Assert.Equal(255, *(scan + 442));
-                    Assert.Equal(255, *(scan + 455));
-                    Assert.Equal(255, *(scan + 468));
-                    Assert.Equal(255, *(scan + 481));
-                    Assert.Equal(255, *(scan + 494));
-                    Assert.Equal(255, *(scan + 507));
-                    Assert.Equal(255, *(scan + 520));
-                    Assert.Equal(255, *(scan + 533));
-                    Assert.Equal(255, *(scan + 546));
-                    Assert.Equal(255, *(scan + 559));
-                    Assert.Equal(0, *(scan + 572));
-                    Assert.Equal(255, *(scan + 585));
-                    Assert.Equal(0, *(scan + 598));
-                    Assert.Equal(0, *(scan + 611));
-                    Assert.Equal(0, *(scan + 624));
-                    Assert.Equal(0, *(scan + 637));
-                    Assert.Equal(0, *(scan + 650));
-                    Assert.Equal(0, *(scan + 663));
-                    Assert.Equal(0, *(scan + 676));
-                    Assert.Equal(0, *(scan + 689));
-                    Assert.Equal(0, *(scan + 702));
-                    Assert.Equal(0, *(scan + 715));
-                    Assert.Equal(255, *(scan + 728));
-                    Assert.Equal(0, *(scan + 741));
-                    Assert.Equal(0, *(scan + 754));
-                    Assert.Equal(0, *(scan + 767));
-                    Assert.Equal(0, *(scan + 780));
-                    Assert.Equal(0, *(scan + 793));
-                    Assert.Equal(0, *(scan + 806));
-                    Assert.Equal(0, *(scan + 819));
-                    Assert.Equal(0, *(scan + 832));
-                    Assert.Equal(0, *(scan + 845));
-                    Assert.Equal(0, *(scan + 858));
-                    Assert.Equal(255, *(scan + 871));
-                    Assert.Equal(0, *(scan + 884));
-                    Assert.Equal(0, *(scan + 897));
-                    Assert.Equal(0, *(scan + 910));
-                    Assert.Equal(0, *(scan + 923));
-                    Assert.Equal(0, *(scan + 936));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    // 64x64x256 only has a 64x64 size available
-    [Fact]
-    public void Bitmap64Features()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(64, bmp.Width);
-            Assert.Equal(64, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(64, rect.Width);
-            Assert.Equal(64, rect.Height);
-
-            Assert.Equal(64, bmp.Size.Width);
-            Assert.Equal(64, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap64Features_Palette_Entries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap64Pixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-65383, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 4).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 8).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 12).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 16).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 20).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 24).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 28).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 36).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 40).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 44).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 48).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 52).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 56).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(0, 60).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(4, 0).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 4).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 8).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 12).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 16).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 20).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 24).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 28).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 32).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 36).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 40).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 44).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 48).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 52).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(4, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 60).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(8, 0).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(8, 4).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 8).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 12).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 16).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 20).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 24).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 28).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 32).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 36).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 40).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 44).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 48).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(8, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 60).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(12, 0).ToArgb());
-            Assert.Equal(-10079335, bmp.GetPixel(12, 4).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(12, 8).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 12).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 16).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 20).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 24).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 28).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 32).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 36).ToArgb());
-            Assert.Equal(-33664, bmp.GetPixel(12, 40).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap64Data()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(64, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(153, *(scan + 0));
-                    Assert.Equal(0, *(scan + 97));
-                    Assert.Equal(255, *(scan + 194));
-                    Assert.Equal(0, *(scan + 291));
-                    Assert.Equal(0, *(scan + 388));
-                    Assert.Equal(204, *(scan + 485));
-                    Assert.Equal(204, *(scan + 582));
-                    Assert.Equal(0, *(scan + 679));
-                    Assert.Equal(204, *(scan + 776));
-                    Assert.Equal(153, *(scan + 873));
-                    Assert.Equal(0, *(scan + 970));
-                    Assert.Equal(0, *(scan + 1067));
-                    Assert.Equal(153, *(scan + 1164));
-                    Assert.Equal(153, *(scan + 1261));
-                    Assert.Equal(102, *(scan + 1358));
-                    Assert.Equal(0, *(scan + 1455));
-                    Assert.Equal(0, *(scan + 1552));
-                    Assert.Equal(204, *(scan + 1649));
-                    Assert.Equal(153, *(scan + 1746));
-                    Assert.Equal(0, *(scan + 1843));
-                    Assert.Equal(0, *(scan + 1940));
-                    Assert.Equal(51, *(scan + 2037));
-                    Assert.Equal(0, *(scan + 2134));
-                    Assert.Equal(0, *(scan + 2231));
-                    Assert.Equal(102, *(scan + 2328));
-                    Assert.Equal(124, *(scan + 2425));
-                    Assert.Equal(204, *(scan + 2522));
-                    Assert.Equal(0, *(scan + 2619));
-                    Assert.Equal(0, *(scan + 2716));
-                    Assert.Equal(204, *(scan + 2813));
-                    Assert.Equal(51, *(scan + 2910));
-                    Assert.Equal(0, *(scan + 3007));
-                    Assert.Equal(255, *(scan + 3104));
-                    Assert.Equal(0, *(scan + 3201));
-                    Assert.Equal(0, *(scan + 3298));
-                    Assert.Equal(0, *(scan + 3395));
-                    Assert.Equal(128, *(scan + 3492));
-                    Assert.Equal(0, *(scan + 3589));
-                    Assert.Equal(255, *(scan + 3686));
-                    Assert.Equal(128, *(scan + 3783));
-                    Assert.Equal(0, *(scan + 3880));
-                    Assert.Equal(128, *(scan + 3977));
-                    Assert.Equal(0, *(scan + 4074));
-                    Assert.Equal(0, *(scan + 4171));
-                    Assert.Equal(204, *(scan + 4268));
-                    Assert.Equal(0, *(scan + 4365));
-                    Assert.Equal(0, *(scan + 4462));
-                    Assert.Equal(102, *(scan + 4559));
-                    Assert.Equal(0, *(scan + 4656));
-                    Assert.Equal(0, *(scan + 4753));
-                    Assert.Equal(102, *(scan + 4850));
-                    Assert.Equal(0, *(scan + 4947));
-                    Assert.Equal(0, *(scan + 5044));
-                    Assert.Equal(204, *(scan + 5141));
-                    Assert.Equal(128, *(scan + 5238));
-                    Assert.Equal(0, *(scan + 5335));
-                    Assert.Equal(128, *(scan + 5432));
-                    Assert.Equal(128, *(scan + 5529));
-                    Assert.Equal(0, *(scan + 5626));
-                    Assert.Equal(255, *(scan + 5723));
-                    Assert.Equal(153, *(scan + 5820));
-                    Assert.Equal(0, *(scan + 5917));
-                    Assert.Equal(0, *(scan + 6014));
-                    Assert.Equal(51, *(scan + 6111));
-                    Assert.Equal(0, *(scan + 6208));
-                    Assert.Equal(255, *(scan + 6305));
-                    Assert.Equal(153, *(scan + 6402));
-                    Assert.Equal(0, *(scan + 6499));
-                    Assert.Equal(153, *(scan + 6596));
-                    Assert.Equal(102, *(scan + 6693));
-                    Assert.Equal(0, *(scan + 6790));
-                    Assert.Equal(204, *(scan + 6887));
-                    Assert.Equal(153, *(scan + 6984));
-                    Assert.Equal(0, *(scan + 7081));
-                    Assert.Equal(204, *(scan + 7178));
-                    Assert.Equal(153, *(scan + 7275));
-                    Assert.Equal(0, *(scan + 7372));
-                    Assert.Equal(0, *(scan + 7469));
-                    Assert.Equal(153, *(scan + 7566));
-                    Assert.Equal(0, *(scan + 7663));
-                    Assert.Equal(0, *(scan + 7760));
-                    Assert.Equal(153, *(scan + 7857));
-                    Assert.Equal(102, *(scan + 7954));
-                    Assert.Equal(102, *(scan + 8051));
-                    Assert.Equal(0, *(scan + 8148));
-                    Assert.Equal(0, *(scan + 8245));
-                    Assert.Equal(0, *(scan + 8342));
-                    Assert.Equal(204, *(scan + 8439));
-                    Assert.Equal(0, *(scan + 8536));
-                    Assert.Equal(204, *(scan + 8633));
-                    Assert.Equal(128, *(scan + 8730));
-                    Assert.Equal(0, *(scan + 8827));
-                    Assert.Equal(0, *(scan + 8924));
-                    Assert.Equal(153, *(scan + 9021));
-                    Assert.Equal(153, *(scan + 9118));
-                    Assert.Equal(255, *(scan + 9215));
-                    Assert.Equal(0, *(scan + 9312));
-                    Assert.Equal(0, *(scan + 9409));
-                    Assert.Equal(204, *(scan + 9506));
-                    Assert.Equal(0, *(scan + 9603));
-                    Assert.Equal(0, *(scan + 9700));
-                    Assert.Equal(0, *(scan + 9797));
-                    Assert.Equal(128, *(scan + 9894));
-                    Assert.Equal(0, *(scan + 9991));
-                    Assert.Equal(0, *(scan + 10088));
-                    Assert.Equal(0, *(scan + 10185));
-                    Assert.Equal(102, *(scan + 10282));
-                    Assert.Equal(0, *(scan + 10379));
-                    Assert.Equal(0, *(scan + 10476));
-                    Assert.Equal(51, *(scan + 10573));
-                    Assert.Equal(204, *(scan + 10670));
-                    Assert.Equal(0, *(scan + 10767));
-                    Assert.Equal(0, *(scan + 10864));
-                    Assert.Equal(0, *(scan + 10961));
-                    Assert.Equal(153, *(scan + 11058));
-                    Assert.Equal(0, *(scan + 11155));
-                    Assert.Equal(0, *(scan + 11252));
-                    Assert.Equal(153, *(scan + 11349));
-                    Assert.Equal(51, *(scan + 11446));
-                    Assert.Equal(0, *(scan + 11543));
-                    Assert.Equal(0, *(scan + 11640));
-                    Assert.Equal(0, *(scan + 11737));
-                    Assert.Equal(204, *(scan + 11834));
-                    Assert.Equal(0, *(scan + 11931));
-                    Assert.Equal(0, *(scan + 12028));
-                    Assert.Equal(255, *(scan + 12125));
-                    Assert.Equal(153, *(scan + 12222));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    // 96x96x256.ico only has a 96x96 size available
-    [Fact]
-    public void Bitmap96Features()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(96, bmp.Width);
-            Assert.Equal(96, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(96, rect.Width);
-            Assert.Equal(96, rect.Height);
-
-            Assert.Equal(96, bmp.Size.Width);
-            Assert.Equal(96, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap96Features_Palette_Entries()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap96Pixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(0, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 44).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 48).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(0, 68).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 80).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 84).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(0, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(4, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(4, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(4, 16).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(4, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(4, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(4, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(4, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(4, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 60).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(4, 64).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(4, 68).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(4, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(4, 80).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(4, 84).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(4, 88).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(4, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 0).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(8, 4).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(8, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(8, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(8, 16).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(8, 20).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(8, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(8, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 60).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(8, 64).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(8, 68).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(8, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(8, 80).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(8, 84).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(8, 88).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(8, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 0).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 4).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 16).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 20).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(12, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 28).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 56).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(12, 60).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(12, 64).ToArgb());
-            Assert.Equal(-3342541, bmp.GetPixel(12, 68).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(12, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(12, 80).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(12, 84).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(12, 88).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(12, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 0).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 4).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 16).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 20).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(16, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 28).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 56).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(16, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 64).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 68).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 76).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(16, 80).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 84).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(16, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(16, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 0).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(20, 4).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(20, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(20, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(20, 16).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(20, 20).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(20, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 28).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 56).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(20, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 64).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(20, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(20, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(20, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(20, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(20, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(20, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(24, 8).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(24, 12).ToArgb());
-            Assert.Equal(-3407872, bmp.GetPixel(24, 16).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(24, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 28).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 56).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(24, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(24, 64).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(24, 88).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(24, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(28, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 16).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(28, 20).ToArgb());
-            Assert.Equal(-16777012, bmp.GetPixel(28, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 28).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 56).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(28, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(28, 64).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 88).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(28, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(32, 4).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(32, 8).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(32, 12).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(32, 16).ToArgb());
-            Assert.Equal(-16777012, bmp.GetPixel(32, 20).ToArgb());
-            Assert.Equal(-16777012, bmp.GetPixel(32, 24).ToArgb());
-            Assert.Equal(-16777012, bmp.GetPixel(32, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 52).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(32, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(32, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 88).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(32, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 0).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(36, 4).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(36, 8).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(36, 12).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(36, 16).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(36, 20).ToArgb());
-            Assert.Equal(-16777012, bmp.GetPixel(36, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 28).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 36).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(36, 40).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(36, 44).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(36, 48).ToArgb());
-            Assert.Equal(-3368602, bmp.GetPixel(36, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(36, 64).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 88).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(36, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 0).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(40, 4).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(40, 8).ToArgb());
-            Assert.Equal(-10027264, bmp.GetPixel(40, 12).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(40, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 28).ToArgb());
-            Assert.Equal(-13408717, bmp.GetPixel(40, 32).ToArgb());
-            Assert.Equal(-13408717, bmp.GetPixel(40, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 44).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(40, 48).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 56).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(40, 60).ToArgb());
-            Assert.Equal(-26317, bmp.GetPixel(40, 64).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(40, 68).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(40, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(40, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(40, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(40, 84).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(40, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(40, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(44, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 12).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 16).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 20).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 24).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 28).ToArgb());
-            Assert.Equal(-13408717, bmp.GetPixel(44, 32).ToArgb());
-            Assert.Equal(-13408717, bmp.GetPixel(44, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 40).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(44, 44).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(44, 48).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(44, 52).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(44, 56).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(44, 60).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(44, 64).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 68).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(44, 72).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(44, 76).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(44, 80).ToArgb());
-            Assert.Equal(-13434829, bmp.GetPixel(44, 84).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(44, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(44, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 4).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(48, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(48, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(48, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(48, 28).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(48, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 36).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(48, 40).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(48, 44).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(48, 48).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(48, 52).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(48, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 60).ToArgb());
-            // Assert.Equal(1842204, bmp.GetPixel(48, 64).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(48, 68).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(48, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 80).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 84).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 88).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(48, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(52, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(52, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(52, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(52, 36).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(52, 40).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(52, 44).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(52, 48).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(52, 52).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(52, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(52, 60).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(52, 64).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(52, 68).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(52, 72).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(52, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(52, 80).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(52, 84).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(52, 88).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(52, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(56, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(56, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(56, 36).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(56, 40).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(56, 44).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(56, 48).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(56, 52).ToArgb());
-            Assert.Equal(-13312, bmp.GetPixel(56, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(56, 60).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(56, 64).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(56, 68).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(56, 72).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(56, 76).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(56, 80).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(56, 84).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(56, 88).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(56, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(60, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 44).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(60, 48).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 52).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 56).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 60).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 64).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(60, 68).ToArgb());
-            Assert.Equal(-3355546, bmp.GetPixel(60, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(60, 76).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(60, 80).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(60, 84).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(60, 88).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(60, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(64, 40).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(64, 44).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 48).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(64, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(64, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(64, 68).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(64, 80).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(64, 84).ToArgb());
-            Assert.Equal(-6737101, bmp.GetPixel(64, 88).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(64, 92).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(68, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 40).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(68, 44).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(68, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(68, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(68, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(68, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(68, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(68, 68).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(68, 72).ToArgb());
-            Assert.Equal(-16751002, bmp.GetPixel(68, 76).ToArgb());
-            Assert.Equal(-16751002, bmp.GetPixel(68, 80).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(68, 84).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(68, 88).ToArgb());
-            Assert.Equal(-39373, bmp.GetPixel(68, 92).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(72, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 40).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(72, 44).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(72, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 68).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(72, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(72, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(72, 80).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(72, 84).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(72, 88).ToArgb());
-            Assert.Equal(-39373, bmp.GetPixel(72, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(76, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(76, 40).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(76, 44).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 68).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(76, 72).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(76, 76).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(76, 80).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(76, 84).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(76, 88).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(76, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(80, 0).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 36).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(80, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(80, 44).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 68).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(80, 72).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(80, 76).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(80, 80).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(80, 84).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(80, 88).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(80, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(84, 0).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(84, 4).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(84, 36).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(84, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(84, 44).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(84, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 68).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(84, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(84, 76).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(84, 80).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(84, 84).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(84, 88).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(84, 92).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(88, 0).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(88, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(88, 8).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 28).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 32).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(88, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(88, 40).ToArgb());
-            Assert.Equal(-16777063, bmp.GetPixel(88, 44).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(88, 48).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 68).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(88, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(88, 76).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(88, 80).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(88, 84).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(88, 88).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(88, 92).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(92, 0).ToArgb());
-            Assert.Equal(-3342490, bmp.GetPixel(92, 4).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(92, 8).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 12).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(92, 16).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(92, 20).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(92, 24).ToArgb());
-            Assert.Equal(-52429, bmp.GetPixel(92, 28).ToArgb());
-            Assert.Equal(-14935012, bmp.GetPixel(92, 32).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 36).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 40).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 44).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 48).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 52).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(92, 56).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(92, 60).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(92, 64).ToArgb());
-            Assert.Equal(-6750157, bmp.GetPixel(92, 68).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 72).ToArgb());
-            Assert.Equal(0, bmp.GetPixel(92, 76).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(92, 80).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(92, 84).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(92, 88).ToArgb());
-            Assert.Equal(-65383, bmp.GetPixel(92, 92).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap96Data()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(96, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(0, *(scan + 0));
-                    Assert.Equal(0, *(scan + 97));
-                    Assert.Equal(0, *(scan + 194));
-                    Assert.Equal(0, *(scan + 291));
-                    Assert.Equal(0, *(scan + 388));
-                    Assert.Equal(28, *(scan + 485));
-                    Assert.Equal(0, *(scan + 582));
-                    Assert.Equal(28, *(scan + 679));
-                    Assert.Equal(255, *(scan + 776));
-                    Assert.Equal(0, *(scan + 873));
-                    Assert.Equal(255, *(scan + 970));
-                    Assert.Equal(255, *(scan + 1067));
-                    Assert.Equal(0, *(scan + 1164));
-                    Assert.Equal(255, *(scan + 1261));
-                    Assert.Equal(255, *(scan + 1358));
-                    Assert.Equal(0, *(scan + 1455));
-                    Assert.Equal(255, *(scan + 1552));
-                    Assert.Equal(255, *(scan + 1649));
-                    Assert.Equal(0, *(scan + 1746));
-                    Assert.Equal(255, *(scan + 1843));
-                    Assert.Equal(255, *(scan + 1940));
-                    Assert.Equal(0, *(scan + 2037));
-                    Assert.Equal(255, *(scan + 2134));
-                    Assert.Equal(255, *(scan + 2231));
-                    Assert.Equal(0, *(scan + 2328));
-                    Assert.Equal(255, *(scan + 2425));
-                    Assert.Equal(255, *(scan + 2522));
-                    Assert.Equal(0, *(scan + 2619));
-                    Assert.Equal(255, *(scan + 2716));
-                    Assert.Equal(255, *(scan + 2813));
-                    Assert.Equal(0, *(scan + 2910));
-                    Assert.Equal(255, *(scan + 3007));
-                    Assert.Equal(255, *(scan + 3104));
-                    Assert.Equal(0, *(scan + 3201));
-                    Assert.Equal(255, *(scan + 3298));
-                    Assert.Equal(255, *(scan + 3395));
-                    Assert.Equal(0, *(scan + 3492));
-                    Assert.Equal(0, *(scan + 3589));
-                    Assert.Equal(255, *(scan + 3686));
-                    Assert.Equal(0, *(scan + 3783));
-                    Assert.Equal(0, *(scan + 3880));
-                    Assert.Equal(255, *(scan + 3977));
-                    Assert.Equal(0, *(scan + 4074));
-                    Assert.Equal(0, *(scan + 4171));
-                    Assert.Equal(255, *(scan + 4268));
-                    Assert.Equal(0, *(scan + 4365));
-                    Assert.Equal(28, *(scan + 4462));
-                    Assert.Equal(255, *(scan + 4559));
-                    Assert.Equal(0, *(scan + 4656));
-                    Assert.Equal(51, *(scan + 4753));
-                    Assert.Equal(255, *(scan + 4850));
-                    Assert.Equal(0, *(scan + 4947));
-                    Assert.Equal(51, *(scan + 5044));
-                    Assert.Equal(255, *(scan + 5141));
-                    Assert.Equal(0, *(scan + 5238));
-                    Assert.Equal(51, *(scan + 5335));
-                    Assert.Equal(255, *(scan + 5432));
-                    Assert.Equal(0, *(scan + 5529));
-                    Assert.Equal(51, *(scan + 5626));
-                    Assert.Equal(255, *(scan + 5723));
-                    Assert.Equal(0, *(scan + 5820));
-                    Assert.Equal(51, *(scan + 5917));
-                    Assert.Equal(255, *(scan + 6014));
-                    Assert.Equal(0, *(scan + 6111));
-                    Assert.Equal(51, *(scan + 6208));
-                    Assert.Equal(255, *(scan + 6305));
-                    Assert.Equal(0, *(scan + 6402));
-                    Assert.Equal(51, *(scan + 6499));
-                    Assert.Equal(255, *(scan + 6596));
-                    Assert.Equal(0, *(scan + 6693));
-                    Assert.Equal(51, *(scan + 6790));
-                    Assert.Equal(255, *(scan + 6887));
-                    Assert.Equal(0, *(scan + 6984));
-                    Assert.Equal(51, *(scan + 7081));
-                    Assert.Equal(255, *(scan + 7178));
-                    Assert.Equal(0, *(scan + 7275));
-                    Assert.Equal(51, *(scan + 7372));
-                    Assert.Equal(255, *(scan + 7469));
-                    Assert.Equal(0, *(scan + 7566));
-                    Assert.Equal(51, *(scan + 7663));
-                    Assert.Equal(255, *(scan + 7760));
-                    Assert.Equal(0, *(scan + 7857));
-                    Assert.Equal(51, *(scan + 7954));
-                    Assert.Equal(255, *(scan + 8051));
-                    Assert.Equal(0, *(scan + 8148));
-                    Assert.Equal(51, *(scan + 8245));
-                    Assert.Equal(255, *(scan + 8342));
-                    Assert.Equal(0, *(scan + 8439));
-                    Assert.Equal(51, *(scan + 8536));
-                    Assert.Equal(28, *(scan + 8633));
-                    Assert.Equal(0, *(scan + 8730));
-                    Assert.Equal(51, *(scan + 8827));
-                    Assert.Equal(0, *(scan + 8924));
-                    Assert.Equal(0, *(scan + 9021));
-                    Assert.Equal(51, *(scan + 9118));
-                    Assert.Equal(0, *(scan + 9215));
-                    Assert.Equal(0, *(scan + 9312));
-                    Assert.Equal(51, *(scan + 9409));
-                    Assert.Equal(0, *(scan + 9506));
-                    Assert.Equal(0, *(scan + 9603));
-                    Assert.Equal(51, *(scan + 9700));
-                    Assert.Equal(0, *(scan + 9797));
-                    Assert.Equal(28, *(scan + 9894));
-                    Assert.Equal(51, *(scan + 9991));
-                    Assert.Equal(0, *(scan + 10088));
-                    Assert.Equal(0, *(scan + 10185));
-                    Assert.Equal(51, *(scan + 10282));
-                    Assert.Equal(0, *(scan + 10379));
-                    Assert.Equal(0, *(scan + 10476));
-                    Assert.Equal(51, *(scan + 10573));
-                    Assert.Equal(0, *(scan + 10670));
-                    Assert.Equal(0, *(scan + 10767));
-                    Assert.Equal(51, *(scan + 10864));
-                    Assert.Equal(204, *(scan + 10961));
-                    Assert.Equal(0, *(scan + 11058));
-                    Assert.Equal(51, *(scan + 11155));
-                    Assert.Equal(204, *(scan + 11252));
-                    Assert.Equal(0, *(scan + 11349));
-                    Assert.Equal(51, *(scan + 11446));
-                    Assert.Equal(204, *(scan + 11543));
-                    Assert.Equal(0, *(scan + 11640));
-                    Assert.Equal(51, *(scan + 11737));
-                    Assert.Equal(204, *(scan + 11834));
-                    Assert.Equal(0, *(scan + 11931));
-                    Assert.Equal(51, *(scan + 12028));
-                    Assert.Equal(204, *(scan + 12125));
-                    Assert.Equal(0, *(scan + 12222));
-                    Assert.Equal(51, *(scan + 12319));
-                    Assert.Equal(204, *(scan + 12416));
-                    Assert.Equal(28, *(scan + 12513));
-                    Assert.Equal(51, *(scan + 12610));
-                    Assert.Equal(204, *(scan + 12707));
-                    Assert.Equal(0, *(scan + 12804));
-                    Assert.Equal(28, *(scan + 12901));
-                    Assert.Equal(204, *(scan + 12998));
-                    Assert.Equal(0, *(scan + 13095));
-                    Assert.Equal(0, *(scan + 13192));
-                    Assert.Equal(204, *(scan + 13289));
-                    Assert.Equal(0, *(scan + 13386));
-                    Assert.Equal(0, *(scan + 13483));
-                    Assert.Equal(204, *(scan + 13580));
-                    Assert.Equal(0, *(scan + 13677));
-                    Assert.Equal(28, *(scan + 13774));
-                    Assert.Equal(204, *(scan + 13871));
-                    Assert.Equal(0, *(scan + 13968));
-                    Assert.Equal(0, *(scan + 14065));
-                    Assert.Equal(204, *(scan + 14162));
-                    Assert.Equal(0, *(scan + 14259));
-                    Assert.Equal(0, *(scan + 14356));
-                    Assert.Equal(204, *(scan + 14453));
-                    Assert.Equal(0, *(scan + 14550));
-                    Assert.Equal(0, *(scan + 14647));
-                    Assert.Equal(204, *(scan + 14744));
-                    Assert.Equal(0, *(scan + 14841));
-                    Assert.Equal(0, *(scan + 14938));
-                    Assert.Equal(204, *(scan + 15035));
-                    Assert.Equal(0, *(scan + 15132));
-                    Assert.Equal(0, *(scan + 15229));
-                    Assert.Equal(204, *(scan + 15326));
-                    Assert.Equal(0, *(scan + 15423));
-                    Assert.Equal(0, *(scan + 15520));
-                    Assert.Equal(204, *(scan + 15617));
-                    Assert.Equal(0, *(scan + 15714));
-                    Assert.Equal(0, *(scan + 15811));
-                    Assert.Equal(204, *(scan + 15908));
-                    Assert.Equal(0, *(scan + 16005));
-                    Assert.Equal(0, *(scan + 16102));
-                    Assert.Equal(204, *(scan + 16199));
-                    Assert.Equal(0, *(scan + 16296));
-                    Assert.Equal(0, *(scan + 16393));
-                    Assert.Equal(204, *(scan + 16490));
-                    Assert.Equal(0, *(scan + 16587));
-                    Assert.Equal(0, *(scan + 16684));
-                    Assert.Equal(204, *(scan + 16781));
-                    Assert.Equal(0, *(scan + 16878));
-                    Assert.Equal(0, *(scan + 16975));
-                    Assert.Equal(204, *(scan + 17072));
-                    Assert.Equal(0, *(scan + 17169));
-                    Assert.Equal(0, *(scan + 17266));
-                    Assert.Equal(204, *(scan + 17363));
-                    Assert.Equal(0, *(scan + 17460));
-                    Assert.Equal(0, *(scan + 17557));
-                    Assert.Equal(28, *(scan + 17654));
-                    Assert.Equal(0, *(scan + 17751));
-                    Assert.Equal(0, *(scan + 17848));
-                    Assert.Equal(0, *(scan + 17945));
-                    Assert.Equal(28, *(scan + 18042));
-                    Assert.Equal(0, *(scan + 18139));
-                    Assert.Equal(0, *(scan + 18236));
-                    Assert.Equal(51, *(scan + 18333));
-                    Assert.Equal(28, *(scan + 18430));
-                    Assert.Equal(0, *(scan + 18527));
-                    Assert.Equal(51, *(scan + 18624));
-                    Assert.Equal(0, *(scan + 18721));
-                    Assert.Equal(28, *(scan + 18818));
-                    Assert.Equal(51, *(scan + 18915));
-                    Assert.Equal(255, *(scan + 19012));
-                    Assert.Equal(51, *(scan + 19109));
-                    Assert.Equal(51, *(scan + 19206));
-                    Assert.Equal(255, *(scan + 19303));
-                    Assert.Equal(51, *(scan + 19400));
-                    Assert.Equal(51, *(scan + 19497));
-                    Assert.Equal(255, *(scan + 19594));
-                    Assert.Equal(51, *(scan + 19691));
-                    Assert.Equal(51, *(scan + 19788));
-                    Assert.Equal(255, *(scan + 19885));
-                    Assert.Equal(51, *(scan + 19982));
-                    Assert.Equal(51, *(scan + 20079));
-                    Assert.Equal(255, *(scan + 20176));
-                    Assert.Equal(51, *(scan + 20273));
-                    Assert.Equal(51, *(scan + 20370));
-                    Assert.Equal(255, *(scan + 20467));
-                    Assert.Equal(51, *(scan + 20564));
-                    Assert.Equal(51, *(scan + 20661));
-                    Assert.Equal(255, *(scan + 20758));
-                    Assert.Equal(51, *(scan + 20855));
-                    Assert.Equal(51, *(scan + 20952));
-                    Assert.Equal(255, *(scan + 21049));
-                    Assert.Equal(51, *(scan + 21146));
-                    Assert.Equal(51, *(scan + 21243));
-                    Assert.Equal(28, *(scan + 21340));
-                    Assert.Equal(51, *(scan + 21437));
-                    Assert.Equal(51, *(scan + 21534));
-                    Assert.Equal(0, *(scan + 21631));
-                    Assert.Equal(51, *(scan + 21728));
-                    Assert.Equal(28, *(scan + 21825));
-                    Assert.Equal(0, *(scan + 21922));
-                    Assert.Equal(51, *(scan + 22019));
-                    Assert.Equal(28, *(scan + 22116));
-                    Assert.Equal(0, *(scan + 22213));
-                    Assert.Equal(51, *(scan + 22310));
-                    Assert.Equal(0, *(scan + 22407));
-                    Assert.Equal(0, *(scan + 22504));
-                    Assert.Equal(51, *(scan + 22601));
-                    Assert.Equal(0, *(scan + 22698));
-                    Assert.Equal(0, *(scan + 22795));
-                    Assert.Equal(51, *(scan + 22892));
-                    Assert.Equal(28, *(scan + 22989));
-                    Assert.Equal(0, *(scan + 23086));
-                    Assert.Equal(28, *(scan + 23183));
-                    Assert.Equal(153, *(scan + 23280));
-                    Assert.Equal(28, *(scan + 23377));
-                    Assert.Equal(0, *(scan + 23474));
-                    Assert.Equal(153, *(scan + 23571));
-                    Assert.Equal(28, *(scan + 23668));
-                    Assert.Equal(0, *(scan + 23765));
-                    Assert.Equal(153, *(scan + 23862));
-                    Assert.Equal(0, *(scan + 23959));
-                    Assert.Equal(28, *(scan + 24056));
-                    Assert.Equal(153, *(scan + 24153));
-                    Assert.Equal(0, *(scan + 24250));
-                    Assert.Equal(153, *(scan + 24347));
-                    Assert.Equal(153, *(scan + 24444));
-                    Assert.Equal(0, *(scan + 24541));
-                    Assert.Equal(153, *(scan + 24638));
-                    Assert.Equal(153, *(scan + 24735));
-                    Assert.Equal(0, *(scan + 24832));
-                    Assert.Equal(153, *(scan + 24929));
-                    Assert.Equal(153, *(scan + 25026));
-                    Assert.Equal(0, *(scan + 25123));
-                    Assert.Equal(153, *(scan + 25220));
-                    Assert.Equal(153, *(scan + 25317));
-                    Assert.Equal(0, *(scan + 25414));
-                    Assert.Equal(153, *(scan + 25511));
-                    Assert.Equal(153, *(scan + 25608));
-                    Assert.Equal(0, *(scan + 25705));
-                    Assert.Equal(153, *(scan + 25802));
-                    Assert.Equal(153, *(scan + 25899));
-                    Assert.Equal(0, *(scan + 25996));
-                    Assert.Equal(153, *(scan + 26093));
-                    Assert.Equal(153, *(scan + 26190));
-                    Assert.Equal(0, *(scan + 26287));
-                    Assert.Equal(153, *(scan + 26384));
-                    Assert.Equal(153, *(scan + 26481));
-                    Assert.Equal(0, *(scan + 26578));
-                    Assert.Equal(153, *(scan + 26675));
-                    Assert.Equal(153, *(scan + 26772));
-                    Assert.Equal(28, *(scan + 26869));
-                    Assert.Equal(153, *(scan + 26966));
-                    Assert.Equal(28, *(scan + 27063));
-                    Assert.Equal(28, *(scan + 27160));
-                    Assert.Equal(28, *(scan + 27257));
-                    Assert.Equal(0, *(scan + 27354));
-                    Assert.Equal(0, *(scan + 27451));
-                    Assert.Equal(0, *(scan + 27548));
-                    Assert.Equal(0, *(scan + 27645));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    [Fact]
-    public void Xp32bppIconFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("48x48_multiple_entries_32bit.ico");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.True(bmp.RawFormat.Equals(ImageFormat.Icon));
-            // note that image is "promoted" to 32bits
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-            Assert.Equal(73746, bmp.Flags);
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-            Assert.Equal(1, bmp.FrameDimensionsList.Length);
-            Assert.Equal(0, bmp.PropertyIdList.Length);
-            Assert.Equal(0, bmp.PropertyItems.Length);
-            Assert.Null(bmp.Tag);
-            Assert.Equal(96.0f, bmp.HorizontalResolution);
-            Assert.Equal(96.0f, bmp.VerticalResolution);
-            Assert.Equal(16, bmp.Width);
-            Assert.Equal(16, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(16, rect.Width);
-            Assert.Equal(16, rect.Height);
-
-            Assert.Equal(16, bmp.Size.Width);
-            Assert.Equal(16, bmp.Size.Height);
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected, bool colorCheck)
-    {
-        string sOutFile = $"linerect-{expected}.ico";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.Red, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            // there's no encoder, so we're not saving a ICO but the alpha
-            // bit get sets so it's not like saving a bitmap either
-            bmp.Save(sOutFile, ImageFormat.Icon);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(ImageFormat.Png, bmpLoad.RawFormat);
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                if (colorCheck)
-                {
-                    Color color = bmpLoad.GetPixel(10, 10);
-                    Assert.Equal(Color.FromArgb(255, 255, 0, 0), color);
-                }
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format32bppArgb, true);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/JpegCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/JpegCodecTests.cs
deleted file mode 100644
index a6cc63d5613..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/JpegCodecTests.cs
+++ /dev/null
@@ -1,422 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// JpegCodec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// (C) 2004 Ximian, Inc.  http://www.ximian.com
-// Copyright (C) 2004-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class JpegCodecTest
-{
-    [Fact]
-    public void Bitmap8bbpIndexedGreyscaleFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature-greyscale.jpg");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format8bppIndexed, bmp.PixelFormat);
-            Assert.Equal(110, bmp.Width);
-            Assert.Equal(100, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(110, rect.Width);
-            Assert.Equal(100, rect.Height);
-
-            Assert.Equal(110, bmp.Size.Width);
-            Assert.Equal(100, bmp.Size.Height);
-
-            Assert.Equal(110, bmp.PhysicalDimension.Width);
-            Assert.Equal(100, bmp.PhysicalDimension.Height);
-
-            Assert.Equal(72, bmp.HorizontalResolution);
-            Assert.Equal(72, bmp.VerticalResolution);
-
-            // This value is not consistent across Windows & Unix
-            // Assert.Equal(77896, bmp.Flags);
-
-            ColorPalette cp = bmp.Palette;
-            Assert.Equal(256, cp.Entries.Length);
-
-            // This value is not consistent across Windows & Unix
-            // Assert.Equal(0, cp.Flags);
-            for (int i = 0; i < 256; i++)
-            {
-                Color c = cp.Entries[i];
-                Assert.Equal(0xFF, c.A);
-                Assert.Equal(i, c.R);
-                Assert.Equal(i, c.G);
-                Assert.Equal(i, c.B);
-            }
-        }
-    }
-
-    [Fact]
-    public void Bitmap8bbpIndexedGreyscalePixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature-greyscale.jpg");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-7697782, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-12171706, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-14013910, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-15132391, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-328966, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-9934744, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-10263709, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-7368817, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-4276546, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-9079435, bmp.GetPixel(64, 64).ToArgb());
-            // Assert.Equal(-7697782, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-8224126, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-11053225, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-9211021, bmp.GetPixel(96, 96).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindows7), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap8bbpIndexedGreyscaleData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature-greyscale.jpg");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(100, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(138, *(scan + 0));
-                    Assert.Equal(203, *(scan + 1009));
-                    Assert.Equal(156, *(scan + 2018));
-                    Assert.Equal(248, *(scan + 3027));
-                    Assert.Equal(221, *(scan + 4036));
-                    Assert.Equal(185, *(scan + 5045));
-                    Assert.Equal(128, *(scan + 6054));
-                    Assert.Equal(205, *(scan + 7063));
-                    Assert.Equal(153, *(scan + 8072));
-                    Assert.Equal(110, *(scan + 9081));
-                    Assert.Equal(163, *(scan + 10090));
-                    Assert.Equal(87, *(scan + 11099));
-                    Assert.Equal(90, *(scan + 12108));
-                    Assert.Equal(81, *(scan + 13117));
-                    // Assert.Equal(124, *(scan + 14126));
-                    Assert.Equal(99, *(scan + 15135));
-                    Assert.Equal(153, *(scan + 16144));
-                    Assert.Equal(57, *(scan + 17153));
-                    Assert.Equal(89, *(scan + 18162));
-                    Assert.Equal(71, *(scan + 19171));
-                    Assert.Equal(106, *(scan + 20180));
-                    Assert.Equal(55, *(scan + 21189));
-                    Assert.Equal(75, *(scan + 22198));
-                    Assert.Equal(77, *(scan + 23207));
-                    Assert.Equal(58, *(scan + 24216));
-                    Assert.Equal(69, *(scan + 25225));
-                    Assert.Equal(43, *(scan + 26234));
-                    Assert.Equal(55, *(scan + 27243));
-                    Assert.Equal(74, *(scan + 28252));
-                    Assert.Equal(145, *(scan + 29261));
-                    Assert.Equal(87, *(scan + 30270));
-                    Assert.Equal(85, *(scan + 31279));
-                    Assert.Equal(106, *(scan + 32288));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    /* Checks bitmap features on a known 24-bits bitmap */
-    [Fact]
-    public void Bitmap24bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature24bits.jpg");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format24bppRgb, bmp.PixelFormat);
-            Assert.Equal(110, bmp.Width);
-            Assert.Equal(100, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(110, rect.Width);
-            Assert.Equal(100, rect.Height);
-
-            Assert.Equal(110, bmp.Size.Width);
-            Assert.Equal(100, bmp.Size.Height);
-
-            Assert.Equal(110, bmp.PhysicalDimension.Width);
-            Assert.Equal(100, bmp.PhysicalDimension.Height);
-
-            Assert.Equal(72, bmp.HorizontalResolution);
-            Assert.Equal(72, bmp.VerticalResolution);
-
-            /* note: under MS flags aren't constant between executions in this case (no palette) */
-            // Assert.Equal(77960, bmp.Flags);
-
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-        }
-    }
-
-    [Fact]
-    public void Bitmap24bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("nature24bits.jpg");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-10447423, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-12171958, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-15192259, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-15131110, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-395272, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-10131359, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-10984322, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-11034683, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-3163242, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-7311538, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-12149780, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-8224378, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-11053718, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-12944166, bmp.GetPixel(96, 96).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap24bitData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(520, data.Stride);
-                Assert.Equal(183, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(217, *(scan + 0));
-                    Assert.Equal(192, *(scan + 1009));
-                    Assert.Equal(210, *(scan + 2018));
-                    Assert.Equal(196, *(scan + 3027));
-                    Assert.Equal(216, *(scan + 4036));
-                    Assert.Equal(215, *(scan + 5045));
-                    Assert.Equal(218, *(scan + 6054));
-                    Assert.Equal(218, *(scan + 7063));
-                    Assert.Equal(95, *(scan + 8072));
-                    Assert.Equal(9, *(scan + 9081));
-                    Assert.Equal(247, *(scan + 10090));
-                    Assert.Equal(161, *(scan + 11099));
-                    Assert.Equal(130, *(scan + 12108));
-                    Assert.Equal(131, *(scan + 13117));
-                    Assert.Equal(175, *(scan + 14126));
-                    Assert.Equal(217, *(scan + 15135));
-                    Assert.Equal(201, *(scan + 16144));
-                    Assert.Equal(183, *(scan + 17153));
-                    Assert.Equal(236, *(scan + 18162));
-                    Assert.Equal(242, *(scan + 19171));
-                    Assert.Equal(125, *(scan + 20180));
-                    Assert.Equal(193, *(scan + 21189));
-                    Assert.Equal(227, *(scan + 22198));
-                    Assert.Equal(44, *(scan + 23207));
-                    Assert.Equal(230, *(scan + 24216));
-                    Assert.Equal(224, *(scan + 25225));
-                    Assert.Equal(164, *(scan + 26234));
-                    Assert.Equal(43, *(scan + 27243));
-                    Assert.Equal(200, *(scan + 28252));
-                    Assert.Equal(255, *(scan + 29261));
-                    Assert.Equal(226, *(scan + 30270));
-                    Assert.Equal(230, *(scan + 31279));
-                    Assert.Equal(178, *(scan + 32288));
-                    Assert.Equal(224, *(scan + 33297));
-                    Assert.Equal(233, *(scan + 34306));
-                    Assert.Equal(212, *(scan + 35315));
-                    Assert.Equal(153, *(scan + 36324));
-                    Assert.Equal(143, *(scan + 37333));
-                    Assert.Equal(215, *(scan + 38342));
-                    Assert.Equal(116, *(scan + 39351));
-                    Assert.Equal(26, *(scan + 40360));
-                    Assert.Equal(28, *(scan + 41369));
-                    Assert.Equal(75, *(scan + 42378));
-                    Assert.Equal(50, *(scan + 43387));
-                    Assert.Equal(244, *(scan + 44396));
-                    Assert.Equal(191, *(scan + 45405));
-                    Assert.Equal(200, *(scan + 46414));
-                    Assert.Equal(197, *(scan + 47423));
-                    Assert.Equal(232, *(scan + 48432));
-                    Assert.Equal(186, *(scan + 49441));
-                    Assert.Equal(210, *(scan + 50450));
-                    Assert.Equal(215, *(scan + 51459));
-                    Assert.Equal(155, *(scan + 52468));
-                    Assert.Equal(56, *(scan + 53477));
-                    Assert.Equal(149, *(scan + 54486));
-                    Assert.Equal(137, *(scan + 55495));
-                    Assert.Equal(141, *(scan + 56504));
-                    Assert.Equal(36, *(scan + 57513));
-                    Assert.Equal(39, *(scan + 58522));
-                    Assert.Equal(25, *(scan + 59531));
-                    Assert.Equal(44, *(scan + 60540));
-                    Assert.Equal(12, *(scan + 61549));
-                    Assert.Equal(161, *(scan + 62558));
-                    Assert.Equal(179, *(scan + 63567));
-                    Assert.Equal(181, *(scan + 64576));
-                    Assert.Equal(165, *(scan + 65585));
-                    Assert.Equal(182, *(scan + 66594));
-                    Assert.Equal(186, *(scan + 67603));
-                    Assert.Equal(201, *(scan + 68612));
-                    Assert.Equal(49, *(scan + 69621));
-                    Assert.Equal(161, *(scan + 70630));
-                    Assert.Equal(140, *(scan + 71639));
-                    Assert.Equal(2, *(scan + 72648));
-                    Assert.Equal(15, *(scan + 73657));
-                    Assert.Equal(33, *(scan + 74666));
-                    Assert.Equal(17, *(scan + 75675));
-                    Assert.Equal(0, *(scan + 76684));
-                    Assert.Equal(47, *(scan + 77693));
-                    Assert.Equal(4, *(scan + 78702));
-                    Assert.Equal(142, *(scan + 79711));
-                    Assert.Equal(151, *(scan + 80720));
-                    Assert.Equal(124, *(scan + 81729));
-                    Assert.Equal(81, *(scan + 82738));
-                    Assert.Equal(214, *(scan + 83747));
-                    Assert.Equal(217, *(scan + 84756));
-                    Assert.Equal(30, *(scan + 85765));
-                    Assert.Equal(185, *(scan + 86774));
-                    Assert.Equal(200, *(scan + 87783));
-                    Assert.Equal(37, *(scan + 88792));
-                    Assert.Equal(2, *(scan + 89801));
-                    Assert.Equal(41, *(scan + 90810));
-                    Assert.Equal(16, *(scan + 91819));
-                    Assert.Equal(0, *(scan + 92828));
-                    Assert.Equal(146, *(scan + 93837));
-                    Assert.Equal(163, *(scan + 94846));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected)
-    {
-        string sOutFile = $"linerect-{expected}.jpeg";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.Red, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            bmp.Save(sOutFile, ImageFormat.Jpeg);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                Color color = bmpLoad.GetPixel(10, 10);
-                // by default JPEG isn't lossless - so value is "near" read
-                Assert.True(color.R >= 195);
-                Assert.True(color.G < 60);
-                Assert.True(color.B < 60);
-                Assert.Equal(0xFF, color.A);
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format24bppRgb);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format24bppRgb);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format24bppRgb);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/PngCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/PngCodecTests.cs
deleted file mode 100644
index 9357f568e8b..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/PngCodecTests.cs
+++ /dev/null
@@ -1,649 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// PNG Codec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported))]
-public class PngCodecTest
-{
-    /* Checks bitmap features on a known 1bbp bitmap */
-    [Fact]
-    public void Bitmap1bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("1bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format1bppIndexed, bmp.PixelFormat);
-
-            Assert.Equal(0, bmp.Palette.Flags);
-            Assert.Equal(2, bmp.Palette.Entries.Length);
-            Assert.Equal(-16777216, bmp.Palette.Entries[0].ToArgb());
-            Assert.Equal(-1, bmp.Palette.Entries[1].ToArgb());
-
-            Assert.Equal(288, bmp.Width);
-            Assert.Equal(384, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(288, rect.Width);
-            Assert.Equal(384, rect.Height);
-
-            Assert.Equal(288, bmp.Size.Width);
-            Assert.Equal(384, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap1bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("1bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-1, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 192).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 224).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 256).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 288).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(0, 320).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(0, 352).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 192).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 224).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 256).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 288).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 320).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(32, 352).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 192).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 224).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 256).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 288).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 320).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 352).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 192).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 224).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 256).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(96, 288).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 320).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(96, 352).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 192).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 224).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(128, 256).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 288).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 320).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(128, 352).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void Bitmap1bitData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("1bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(864, data.Stride);
-                Assert.Equal(384, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(255, *(scan + 0));
-                    Assert.Equal(255, *(scan + 1009));
-                    Assert.Equal(255, *(scan + 2018));
-                    Assert.Equal(255, *(scan + 3027));
-                    Assert.Equal(255, *(scan + 4036));
-                    Assert.Equal(255, *(scan + 5045));
-                    Assert.Equal(255, *(scan + 6054));
-                    Assert.Equal(255, *(scan + 7063));
-                    Assert.Equal(255, *(scan + 8072));
-                    Assert.Equal(255, *(scan + 9081));
-                    Assert.Equal(255, *(scan + 10090));
-                    Assert.Equal(0, *(scan + 11099));
-                    Assert.Equal(255, *(scan + 12108));
-                    Assert.Equal(255, *(scan + 13117));
-                    Assert.Equal(0, *(scan + 14126));
-                    Assert.Equal(255, *(scan + 15135));
-                    Assert.Equal(255, *(scan + 16144));
-                    Assert.Equal(0, *(scan + 17153));
-                    Assert.Equal(0, *(scan + 18162));
-                    Assert.Equal(255, *(scan + 19171));
-                    Assert.Equal(0, *(scan + 20180));
-                    Assert.Equal(255, *(scan + 21189));
-                    Assert.Equal(255, *(scan + 22198));
-                    Assert.Equal(0, *(scan + 23207));
-                    Assert.Equal(0, *(scan + 24216));
-                    Assert.Equal(0, *(scan + 25225));
-                    Assert.Equal(0, *(scan + 26234));
-                    Assert.Equal(255, *(scan + 27243));
-                    Assert.Equal(255, *(scan + 28252));
-                    Assert.Equal(0, *(scan + 29261));
-                    Assert.Equal(255, *(scan + 30270));
-                    Assert.Equal(0, *(scan + 31279));
-                    Assert.Equal(0, *(scan + 32288));
-                    Assert.Equal(255, *(scan + 33297));
-                    Assert.Equal(255, *(scan + 34306));
-                    Assert.Equal(255, *(scan + 35315));
-                    Assert.Equal(255, *(scan + 36324));
-                    Assert.Equal(0, *(scan + 37333));
-                    Assert.Equal(255, *(scan + 38342));
-                    Assert.Equal(255, *(scan + 39351));
-                    Assert.Equal(255, *(scan + 40360));
-                    Assert.Equal(255, *(scan + 41369));
-                    Assert.Equal(255, *(scan + 42378));
-                    Assert.Equal(0, *(scan + 43387));
-                    Assert.Equal(0, *(scan + 44396));
-                    Assert.Equal(255, *(scan + 45405));
-                    Assert.Equal(255, *(scan + 46414));
-                    Assert.Equal(255, *(scan + 47423));
-                    Assert.Equal(255, *(scan + 48432));
-                    Assert.Equal(255, *(scan + 49441));
-                    Assert.Equal(0, *(scan + 50450));
-                    Assert.Equal(0, *(scan + 51459));
-                    Assert.Equal(255, *(scan + 52468));
-                    Assert.Equal(255, *(scan + 53477));
-                    Assert.Equal(255, *(scan + 54486));
-                    Assert.Equal(0, *(scan + 55495));
-                    Assert.Equal(0, *(scan + 56504));
-                    Assert.Equal(0, *(scan + 57513));
-                    Assert.Equal(255, *(scan + 58522));
-                    Assert.Equal(255, *(scan + 59531));
-                    Assert.Equal(0, *(scan + 60540));
-                    Assert.Equal(0, *(scan + 61549));
-                    Assert.Equal(0, *(scan + 62558));
-                    Assert.Equal(0, *(scan + 63567));
-                    Assert.Equal(255, *(scan + 64576));
-                    Assert.Equal(0, *(scan + 65585));
-                    Assert.Equal(255, *(scan + 66594));
-                    Assert.Equal(255, *(scan + 67603));
-                    Assert.Equal(0, *(scan + 68612));
-                    Assert.Equal(0, *(scan + 69621));
-                    Assert.Equal(0, *(scan + 70630));
-                    Assert.Equal(0, *(scan + 71639));
-                    Assert.Equal(0, *(scan + 72648));
-                    Assert.Equal(255, *(scan + 73657));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    /* Checks bitmap features on a known 2bbp bitmap */
-    [Fact]
-    public void Bitmap2bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("81674-2bpp.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            // quite a promotion! (2 -> 32)
-            Assert.Equal(PixelFormat.Format32bppArgb, bmp.PixelFormat);
-
-            // MS returns a random Flags value (not a good sign)
-            //Assert.Equal (0, bmp.Palette.Flags);
-            Assert.Equal(0, bmp.Palette.Entries.Length);
-
-            Assert.Equal(100, bmp.Width);
-            Assert.Equal(100, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(100, rect.Width);
-            Assert.Equal(100, rect.Height);
-
-            Assert.Equal(100, bmp.Size.Width);
-            Assert.Equal(100, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap2bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("81674-2bpp.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-11249559, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-16777216, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-11249559, bmp.GetPixel(96, 96).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void Bitmap2bitData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("81674-2bpp.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(300, data.Stride);
-                Assert.Equal(100, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(105, *(scan + 0));
-                    Assert.Equal(88, *(scan + 1009));
-                    Assert.Equal(255, *(scan + 2018));
-                    Assert.Equal(105, *(scan + 3027));
-                    Assert.Equal(88, *(scan + 4036));
-                    Assert.Equal(84, *(scan + 5045));
-                    Assert.Equal(255, *(scan + 6054));
-                    Assert.Equal(88, *(scan + 7063));
-                    Assert.Equal(84, *(scan + 8072));
-                    Assert.Equal(0, *(scan + 9081));
-                    Assert.Equal(0, *(scan + 10090));
-                    Assert.Equal(84, *(scan + 11099));
-                    Assert.Equal(0, *(scan + 12108));
-                    Assert.Equal(88, *(scan + 13117));
-                    Assert.Equal(84, *(scan + 14126));
-                    Assert.Equal(105, *(scan + 15135));
-                    Assert.Equal(88, *(scan + 16144));
-                    Assert.Equal(84, *(scan + 17153));
-                    Assert.Equal(0, *(scan + 18162));
-                    Assert.Equal(88, *(scan + 19171));
-                    Assert.Equal(84, *(scan + 20180));
-                    Assert.Equal(0, *(scan + 21189));
-                    Assert.Equal(88, *(scan + 22198));
-                    Assert.Equal(84, *(scan + 23207));
-                    Assert.Equal(105, *(scan + 24216));
-                    Assert.Equal(88, *(scan + 25225));
-                    Assert.Equal(0, *(scan + 26234));
-                    Assert.Equal(105, *(scan + 27243));
-                    Assert.Equal(88, *(scan + 28252));
-                    Assert.Equal(84, *(scan + 29261));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    /* Checks bitmap features on a known 4bbp bitmap */
-    [Fact]
-    public void Bitmap4bitFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("4bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-
-            Assert.Equal(PixelFormat.Format4bppIndexed, bmp.PixelFormat);
-
-            Assert.Equal(0, bmp.Palette.Flags);
-            Assert.Equal(16, bmp.Palette.Entries.Length);
-            Assert.Equal(-12106173, bmp.Palette.Entries[0].ToArgb());
-            Assert.Equal(-10979957, bmp.Palette.Entries[1].ToArgb());
-            Assert.Equal(-8879241, bmp.Palette.Entries[2].ToArgb());
-            Assert.Equal(-10381134, bmp.Palette.Entries[3].ToArgb());
-            Assert.Equal(-7441574, bmp.Palette.Entries[4].ToArgb());
-            Assert.Equal(-6391673, bmp.Palette.Entries[5].ToArgb());
-            Assert.Equal(-5861009, bmp.Palette.Entries[6].ToArgb());
-            Assert.Equal(-3824008, bmp.Palette.Entries[7].ToArgb());
-            Assert.Equal(-5790569, bmp.Palette.Entries[8].ToArgb());
-            Assert.Equal(-6178617, bmp.Palette.Entries[9].ToArgb());
-            Assert.Equal(-4668490, bmp.Palette.Entries[10].ToArgb());
-            Assert.Equal(-5060143, bmp.Palette.Entries[11].ToArgb());
-            Assert.Equal(-3492461, bmp.Palette.Entries[12].ToArgb());
-            Assert.Equal(-2967099, bmp.Palette.Entries[13].ToArgb());
-            Assert.Equal(-2175574, bmp.Palette.Entries[14].ToArgb());
-            Assert.Equal(-1314578, bmp.Palette.Entries[15].ToArgb());
-
-            Assert.Equal(288, bmp.Width);
-            Assert.Equal(384, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(288, rect.Width);
-            Assert.Equal(384, rect.Height);
-
-            Assert.Equal(288, bmp.Size.Width);
-            Assert.Equal(384, bmp.Size.Height);
-        }
-    }
-
-    [Fact]
-    public void Bitmap4bitPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("4bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-10381134, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-3824008, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(0, 192).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(0, 224).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(0, 256).ToArgb());
-            Assert.Equal(-7441574, bmp.GetPixel(0, 288).ToArgb());
-            Assert.Equal(-3492461, bmp.GetPixel(0, 320).ToArgb());
-            Assert.Equal(-5861009, bmp.GetPixel(0, 352).ToArgb());
-            Assert.Equal(-10381134, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-7441574, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(32, 192).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(32, 224).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(32, 256).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(32, 288).ToArgb());
-            Assert.Equal(-3492461, bmp.GetPixel(32, 320).ToArgb());
-            Assert.Equal(-2175574, bmp.GetPixel(32, 352).ToArgb());
-            Assert.Equal(-6178617, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 192).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 224).ToArgb());
-            Assert.Equal(-5790569, bmp.GetPixel(64, 256).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 288).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(64, 320).ToArgb());
-            Assert.Equal(-5790569, bmp.GetPixel(64, 352).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-10381134, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-7441574, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-5790569, bmp.GetPixel(96, 192).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(96, 224).ToArgb());
-            Assert.Equal(-4668490, bmp.GetPixel(96, 256).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(96, 288).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(96, 320).ToArgb());
-            Assert.Equal(-3492461, bmp.GetPixel(96, 352).ToArgb());
-            Assert.Equal(-5861009, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-7441574, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-7441574, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 192).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 224).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 256).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 288).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 320).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(128, 352).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-1314578, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-5790569, bmp.GetPixel(160, 160).ToArgb());
-            Assert.Equal(-12106173, bmp.GetPixel(160, 192).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void Bitmap4bitData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("4bit.png");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(864, data.Stride);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(178, *(scan + 0));
-                    Assert.Equal(184, *(scan + 1009));
-                    Assert.Equal(235, *(scan + 2018));
-                    Assert.Equal(209, *(scan + 3027));
-                    Assert.Equal(240, *(scan + 4036));
-                    Assert.Equal(142, *(scan + 5045));
-                    Assert.Equal(139, *(scan + 6054));
-                    Assert.Equal(152, *(scan + 7063));
-                    Assert.Equal(235, *(scan + 8072));
-                    Assert.Equal(209, *(scan + 9081));
-                    Assert.Equal(240, *(scan + 10090));
-                    Assert.Equal(142, *(scan + 11099));
-                    Assert.Equal(199, *(scan + 12108));
-                    Assert.Equal(201, *(scan + 13117));
-                    Assert.Equal(97, *(scan + 14126));
-                    Assert.Equal(238, *(scan + 15135));
-                    Assert.Equal(240, *(scan + 16144));
-                    Assert.Equal(158, *(scan + 17153));
-                    Assert.Equal(119, *(scan + 18162));
-                    Assert.Equal(201, *(scan + 19171));
-                    Assert.Equal(88, *(scan + 20180));
-                    Assert.Equal(238, *(scan + 21189));
-                    Assert.Equal(240, *(scan + 22198));
-                    Assert.Equal(120, *(scan + 23207));
-                    Assert.Equal(182, *(scan + 24216));
-                    Assert.Equal(70, *(scan + 25225));
-                    Assert.Equal(71, *(scan + 26234));
-                    Assert.Equal(238, *(scan + 27243));
-                    Assert.Equal(240, *(scan + 28252));
-                    Assert.Equal(120, *(scan + 29261));
-                    Assert.Equal(238, *(scan + 30270));
-                    Assert.Equal(70, *(scan + 31279));
-                    Assert.Equal(71, *(scan + 32288));
-                    Assert.Equal(238, *(scan + 33297));
-                    Assert.Equal(240, *(scan + 34306));
-                    Assert.Equal(210, *(scan + 35315));
-                    Assert.Equal(238, *(scan + 36324));
-                    Assert.Equal(70, *(scan + 37333));
-                    Assert.Equal(97, *(scan + 38342));
-                    Assert.Equal(238, *(scan + 39351));
-                    Assert.Equal(240, *(scan + 40360));
-                    Assert.Equal(235, *(scan + 41369));
-                    Assert.Equal(238, *(scan + 42378));
-                    Assert.Equal(117, *(scan + 43387));
-                    Assert.Equal(158, *(scan + 44396));
-                    Assert.Equal(170, *(scan + 45405));
-                    Assert.Equal(240, *(scan + 46414));
-                    Assert.Equal(235, *(scan + 47423));
-                    Assert.Equal(209, *(scan + 48432));
-                    Assert.Equal(120, *(scan + 49441));
-                    Assert.Equal(71, *(scan + 50450));
-                    Assert.Equal(119, *(scan + 51459));
-                    Assert.Equal(240, *(scan + 52468));
-                    Assert.Equal(235, *(scan + 53477));
-                    Assert.Equal(209, *(scan + 54486));
-                    Assert.Equal(70, *(scan + 55495));
-                    Assert.Equal(71, *(scan + 56504));
-                    Assert.Equal(67, *(scan + 57513));
-                    Assert.Equal(240, *(scan + 58522));
-                    Assert.Equal(167, *(scan + 59531));
-                    Assert.Equal(67, *(scan + 60540));
-                    Assert.Equal(70, *(scan + 61549));
-                    Assert.Equal(71, *(scan + 62558));
-                    Assert.Equal(67, *(scan + 63567));
-                    Assert.Equal(240, *(scan + 64576));
-                    Assert.Equal(120, *(scan + 65585));
-                    Assert.Equal(182, *(scan + 66594));
-                    Assert.Equal(70, *(scan + 67603));
-                    Assert.Equal(120, *(scan + 68612));
-                    Assert.Equal(67, *(scan + 69621));
-                    Assert.Equal(70, *(scan + 70630));
-                    Assert.Equal(71, *(scan + 71639));
-                    Assert.Equal(90, *(scan + 72648));
-                    Assert.Equal(240, *(scan + 73657));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected, bool colorCheck)
-    {
-        string sOutFile = $"linerect-{expected}.png";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.BlueViolet, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            bmp.Save(sOutFile, ImageFormat.Png);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                if (colorCheck)
-                {
-                    Color color = bmpLoad.GetPixel(10, 10);
-                    Assert.Equal(Color.FromArgb(255, 138, 43, 226), color);
-                }
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format32bppArgb, true);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/TiffCodecTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/TiffCodecTests.cs
deleted file mode 100644
index e0a06e8dcc5..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing.Imaging/TiffCodecTests.cs
+++ /dev/null
@@ -1,309 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// TIFF Codec class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2006, 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class TiffCodecTest
-{
-    /* Checks bitmap features on a known 32bbp bitmap */
-    [Fact]
-    public void Bitmap32bitsFeatures()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.tif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            GraphicsUnit unit = GraphicsUnit.World;
-            RectangleF rect = bmp.GetBounds(ref unit);
-            // MS reports 24 bpp while we report 32 bpp
-            //                Assert.Equal (PixelFormat.Format24bppRgb, bmp.PixelFormat);
-            Assert.Equal(173, bmp.Width);
-            Assert.Equal(183, bmp.Height);
-
-            Assert.Equal(0, rect.X);
-            Assert.Equal(0, rect.Y);
-            Assert.Equal(173, rect.Width);
-            Assert.Equal(183, rect.Height);
-
-            Assert.Equal(173, bmp.Size.Width);
-            Assert.Equal(183, bmp.Size.Height);
-        }
-    }
-
-    /* Checks bitmap features on a known 32bbp bitmap */
-    [Fact]
-    public void Bitmap32bitsPixelFormat()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.tif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // GDI+ reports 24 bpp while libgdiplus reports 32 bpp
-            Assert.Equal (PixelFormat.Format24bppRgb, bmp.PixelFormat);
-        }
-    }
-
-    [Fact]
-    public void Bitmap32bitsPixels()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.tif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            // sampling values from a well known bitmap
-            Assert.Equal(-1579559, bmp.GetPixel(0, 0).ToArgb());
-            Assert.Equal(-1645353, bmp.GetPixel(0, 32).ToArgb());
-            Assert.Equal(-461332, bmp.GetPixel(0, 64).ToArgb());
-            Assert.Equal(-330005, bmp.GetPixel(0, 96).ToArgb());
-            Assert.Equal(-2237489, bmp.GetPixel(0, 128).ToArgb());
-            Assert.Equal(-1251105, bmp.GetPixel(0, 160).ToArgb());
-            Assert.Equal(-3024947, bmp.GetPixel(32, 0).ToArgb());
-            Assert.Equal(-2699070, bmp.GetPixel(32, 32).ToArgb());
-            Assert.Equal(-2366734, bmp.GetPixel(32, 64).ToArgb());
-            Assert.Equal(-4538413, bmp.GetPixel(32, 96).ToArgb());
-            Assert.Equal(-6116681, bmp.GetPixel(32, 128).ToArgb());
-            Assert.Equal(-7369076, bmp.GetPixel(32, 160).ToArgb());
-            Assert.Equal(-13024729, bmp.GetPixel(64, 0).ToArgb());
-            Assert.Equal(-7174020, bmp.GetPixel(64, 32).ToArgb());
-            Assert.Equal(-51, bmp.GetPixel(64, 64).ToArgb());
-            Assert.Equal(-16053503, bmp.GetPixel(64, 96).ToArgb());
-            Assert.Equal(-8224431, bmp.GetPixel(64, 128).ToArgb());
-            Assert.Equal(-16579326, bmp.GetPixel(64, 160).ToArgb());
-            Assert.Equal(-2502457, bmp.GetPixel(96, 0).ToArgb());
-            Assert.Equal(-9078395, bmp.GetPixel(96, 32).ToArgb());
-            Assert.Equal(-12696508, bmp.GetPixel(96, 64).ToArgb());
-            Assert.Equal(-70772, bmp.GetPixel(96, 96).ToArgb());
-            Assert.Equal(-4346279, bmp.GetPixel(96, 128).ToArgb());
-            Assert.Equal(-11583193, bmp.GetPixel(96, 160).ToArgb());
-            Assert.Equal(-724763, bmp.GetPixel(128, 0).ToArgb());
-            Assert.Equal(-7238268, bmp.GetPixel(128, 32).ToArgb());
-            Assert.Equal(-2169612, bmp.GetPixel(128, 64).ToArgb());
-            Assert.Equal(-3683883, bmp.GetPixel(128, 96).ToArgb());
-            Assert.Equal(-12892867, bmp.GetPixel(128, 128).ToArgb());
-            Assert.Equal(-3750464, bmp.GetPixel(128, 160).ToArgb());
-            Assert.Equal(-3222844, bmp.GetPixel(160, 0).ToArgb());
-            Assert.Equal(-65806, bmp.GetPixel(160, 32).ToArgb());
-            Assert.Equal(-2961726, bmp.GetPixel(160, 64).ToArgb());
-            Assert.Equal(-2435382, bmp.GetPixel(160, 96).ToArgb());
-            Assert.Equal(-2501944, bmp.GetPixel(160, 128).ToArgb());
-            Assert.Equal(-9211799, bmp.GetPixel(160, 160).ToArgb());
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void Bitmap32bitsData()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver32bits.tif");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(bmp.Height, data.Height);
-                Assert.Equal(bmp.Width, data.Width);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.Equal(520, data.Stride);
-                Assert.Equal(183, data.Height);
-
-                unsafe
-                {
-                    byte* scan = (byte*)data.Scan0;
-                    // sampling values from a well known bitmap
-                    Assert.Equal(217, *(scan + 0));
-                    Assert.Equal(192, *(scan + 1009));
-                    Assert.Equal(210, *(scan + 2018));
-                    Assert.Equal(196, *(scan + 3027));
-                    Assert.Equal(216, *(scan + 4036));
-                    Assert.Equal(215, *(scan + 5045));
-                    Assert.Equal(218, *(scan + 6054));
-                    Assert.Equal(218, *(scan + 7063));
-                    Assert.Equal(95, *(scan + 8072));
-                    Assert.Equal(9, *(scan + 9081));
-                    Assert.Equal(247, *(scan + 10090));
-                    Assert.Equal(161, *(scan + 11099));
-                    Assert.Equal(130, *(scan + 12108));
-                    Assert.Equal(131, *(scan + 13117));
-                    Assert.Equal(175, *(scan + 14126));
-                    Assert.Equal(217, *(scan + 15135));
-                    Assert.Equal(201, *(scan + 16144));
-                    Assert.Equal(183, *(scan + 17153));
-                    Assert.Equal(236, *(scan + 18162));
-                    Assert.Equal(242, *(scan + 19171));
-                    Assert.Equal(125, *(scan + 20180));
-                    Assert.Equal(193, *(scan + 21189));
-                    Assert.Equal(227, *(scan + 22198));
-                    Assert.Equal(44, *(scan + 23207));
-                    Assert.Equal(230, *(scan + 24216));
-                    Assert.Equal(224, *(scan + 25225));
-                    Assert.Equal(164, *(scan + 26234));
-                    Assert.Equal(43, *(scan + 27243));
-                    Assert.Equal(200, *(scan + 28252));
-                    Assert.Equal(255, *(scan + 29261));
-                    Assert.Equal(226, *(scan + 30270));
-                    Assert.Equal(230, *(scan + 31279));
-                    Assert.Equal(178, *(scan + 32288));
-                    Assert.Equal(224, *(scan + 33297));
-                    Assert.Equal(233, *(scan + 34306));
-                    Assert.Equal(212, *(scan + 35315));
-                    Assert.Equal(153, *(scan + 36324));
-                    Assert.Equal(143, *(scan + 37333));
-                    Assert.Equal(215, *(scan + 38342));
-                    Assert.Equal(116, *(scan + 39351));
-                    Assert.Equal(26, *(scan + 40360));
-                    Assert.Equal(28, *(scan + 41369));
-                    Assert.Equal(75, *(scan + 42378));
-                    Assert.Equal(50, *(scan + 43387));
-                    Assert.Equal(244, *(scan + 44396));
-                    Assert.Equal(191, *(scan + 45405));
-                    Assert.Equal(200, *(scan + 46414));
-                    Assert.Equal(197, *(scan + 47423));
-                    Assert.Equal(232, *(scan + 48432));
-                    Assert.Equal(186, *(scan + 49441));
-                    Assert.Equal(210, *(scan + 50450));
-                    Assert.Equal(215, *(scan + 51459));
-                    Assert.Equal(155, *(scan + 52468));
-                    Assert.Equal(56, *(scan + 53477));
-                    Assert.Equal(149, *(scan + 54486));
-                    Assert.Equal(137, *(scan + 55495));
-                    Assert.Equal(141, *(scan + 56504));
-                    Assert.Equal(36, *(scan + 57513));
-                    Assert.Equal(39, *(scan + 58522));
-                    Assert.Equal(25, *(scan + 59531));
-                    Assert.Equal(44, *(scan + 60540));
-                    Assert.Equal(12, *(scan + 61549));
-                    Assert.Equal(161, *(scan + 62558));
-                    Assert.Equal(179, *(scan + 63567));
-                    Assert.Equal(181, *(scan + 64576));
-                    Assert.Equal(165, *(scan + 65585));
-                    Assert.Equal(182, *(scan + 66594));
-                    Assert.Equal(186, *(scan + 67603));
-                    Assert.Equal(201, *(scan + 68612));
-                    Assert.Equal(49, *(scan + 69621));
-                    Assert.Equal(161, *(scan + 70630));
-                    Assert.Equal(140, *(scan + 71639));
-                    Assert.Equal(2, *(scan + 72648));
-                    Assert.Equal(15, *(scan + 73657));
-                    Assert.Equal(33, *(scan + 74666));
-                    Assert.Equal(17, *(scan + 75675));
-                    Assert.Equal(0, *(scan + 76684));
-                    Assert.Equal(47, *(scan + 77693));
-                    Assert.Equal(4, *(scan + 78702));
-                    Assert.Equal(142, *(scan + 79711));
-                    Assert.Equal(151, *(scan + 80720));
-                    Assert.Equal(124, *(scan + 81729));
-                    Assert.Equal(81, *(scan + 82738));
-                    Assert.Equal(214, *(scan + 83747));
-                    Assert.Equal(217, *(scan + 84756));
-                    Assert.Equal(30, *(scan + 85765));
-                    Assert.Equal(185, *(scan + 86774));
-                    Assert.Equal(200, *(scan + 87783));
-                    Assert.Equal(37, *(scan + 88792));
-                    Assert.Equal(2, *(scan + 89801));
-                    Assert.Equal(41, *(scan + 90810));
-                    Assert.Equal(16, *(scan + 91819));
-                    Assert.Equal(0, *(scan + 92828));
-                    Assert.Equal(146, *(scan + 93837));
-                    Assert.Equal(163, *(scan + 94846));
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    private void Save(PixelFormat original, PixelFormat expected, bool colorCheck)
-    {
-        string sOutFile = $"linerect-{expected}.tif";
-
-        // Save
-        Bitmap bmp = new Bitmap(100, 100, original);
-        Graphics gr = Graphics.FromImage(bmp);
-
-        using (Pen p = new Pen(Color.BlueViolet, 2))
-        {
-            gr.DrawLine(p, 10.0F, 10.0F, 90.0F, 90.0F);
-            gr.DrawRectangle(p, 10.0F, 10.0F, 80.0F, 80.0F);
-        }
-
-        try
-        {
-            bmp.Save(sOutFile, ImageFormat.Tiff);
-
-            // Load
-            using (Bitmap bmpLoad = new Bitmap(sOutFile))
-            {
-                Assert.Equal(expected, bmpLoad.PixelFormat);
-                if (colorCheck)
-                {
-                    Color color = bmpLoad.GetPixel(10, 10);
-                    Assert.Equal(Color.FromArgb(255, 138, 43, 226), color);
-                }
-            }
-        }
-        finally
-        {
-            gr.Dispose();
-            bmp.Dispose();
-            try
-            {
-                File.Delete(sOutFile);
-            }
-            catch
-            {
-            }
-        }
-    }
-
-    [Fact]
-    public void Save_24bppRgb()
-    {
-        Save(PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppRgb()
-    {
-        Save(PixelFormat.Format32bppRgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppArgb()
-    {
-        Save(PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, true);
-    }
-
-    [Fact]
-    public void Save_32bppPArgb()
-    {
-        Save(PixelFormat.Format32bppPArgb, PixelFormat.Format32bppArgb, true);
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing/BitmapTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing/BitmapTests.cs
deleted file mode 100644
index 0680a98ce8e..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing/BitmapTests.cs
+++ /dev/null
@@ -1,1407 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Bitmap class testing unit
-//
-// Authors:
-//  Jordi Mas i Hernandez (jordi@ximian.com)
-//  Jonathan Gilbert <logic@deltaq.org>
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// (C) 2004 Ximian, Inc.  http://www.ximian.com
-// Copyright (C) 2004,2006-2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Imaging;
-using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using System.Text;
-using System.Xml.Serialization;
-
-namespace MonoTests.System.Drawing;
-
-public class TestBitmap
-{
-    [Fact]
-    public void TestPixels()
-    {
-        // Tests GetSetPixel/SetPixel
-        Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format32bppRgb);
-        bmp.SetPixel(0, 0, Color.FromArgb(255, 128, 128, 128));
-        Color color = bmp.GetPixel(0, 0);
-
-        Assert.Equal(Color.FromArgb(255, 128, 128, 128), color);
-
-        bmp.SetPixel(99, 99, Color.FromArgb(255, 255, 0, 155));
-        Color color2 = bmp.GetPixel(99, 99);
-        Assert.Equal(Color.FromArgb(255, 255, 0, 155), color2);
-    }
-
-    [Fact]
-    public void LockBits_IndexedWrite_NonIndexed()
-    {
-        using Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format8bppIndexed);
-        Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
-        BitmapData bd = bmp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
-        bmp.UnlockBits(bd);
-    }
-
-    [Fact]
-    public void LockBits_NonIndexedWrite_ToIndexed()
-    {
-        using (Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format32bppRgb))
-        {
-            BitmapData bd = new BitmapData();
-            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
-            bd = bmp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed, bd);
-
-            try
-            {
-                Assert.NotEqual(IntPtr.Zero, bd.Scan0);
-            }
-            finally
-            {
-                bmp.UnlockBits(bd);
-            }
-        }
-    }
-
-    [Fact]
-    public void LockBits_ImageLockMode_Invalid()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format24bppRgb))
-        {
-            Rectangle r = new Rectangle(4, 4, 4, 4);
-            BitmapData data = bmp.LockBits(r, (ImageLockMode)0, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Equal(4, data.Height);
-                Assert.Equal(4, data.Width);
-                Assert.True(data.Stride >= 12);
-                Assert.Equal(PixelFormat.Format24bppRgb, data.PixelFormat);
-                Assert.False(IntPtr.Zero.Equals(data.Scan0));
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    [Fact]
-    public void LockBits_Double()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format24bppRgb))
-        {
-            Rectangle r = new Rectangle(4, 4, 4, 4);
-            BitmapData data = bmp.LockBits(r, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                Assert.Throws<InvalidOperationException>(() => bmp.LockBits(r, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb));
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-            }
-        }
-    }
-
-    [Fact]
-    public void Format1bppIndexed()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format1bppIndexed))
-        {
-            Color c = bmp.GetPixel(0, 0);
-            Assert.Equal(-16777216, c.ToArgb());
-            Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c));
-        }
-    }
-
-    [Fact]
-    public void Format4bppIndexed()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format4bppIndexed))
-        {
-            Color c = bmp.GetPixel(0, 0);
-            Assert.Equal(-16777216, c.ToArgb());
-            Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c));
-        }
-    }
-
-    [Fact]
-    public void Format8bppIndexed()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
-        {
-            Color c = bmp.GetPixel(0, 0);
-            Assert.Equal(-16777216, c.ToArgb());
-            Assert.Throws<InvalidOperationException>(() => bmp.SetPixel(0, 0, c));
-        }
-    }
-
-    private void FormatTest(PixelFormat format)
-    {
-        bool alpha = Image.IsAlphaPixelFormat(format);
-        int size = Image.GetPixelFormatSize(format) / 8 * 2;
-        using (Bitmap bmp = new Bitmap(2, 1, format))
-        {
-            Color a = Color.FromArgb(128, 64, 32, 16);
-            Color b = Color.FromArgb(192, 96, 48, 24);
-            bmp.SetPixel(0, 0, a);
-            bmp.SetPixel(1, 0, b);
-            Color c = bmp.GetPixel(0, 0);
-            Color d = bmp.GetPixel(1, 0);
-            if (size == 4)
-            {
-                Assert.Equal(255, c.A);
-                Assert.Equal(66, c.R);
-                if (format == PixelFormat.Format16bppRgb565)
-                {
-                    Assert.Equal(32, c.G);
-                }
-                else
-                {
-                    Assert.Equal(33, c.G);
-                }
-                Assert.Equal(16, c.B);
-
-                Assert.Equal(255, d.A);
-                Assert.Equal(99, d.R);
-                if (format == PixelFormat.Format16bppRgb565)
-                {
-                    Assert.Equal(48, d.G);
-                }
-                else
-                {
-                    Assert.Equal(49, d.G);
-                }
-                Assert.Equal(24, d.B);
-            }
-            else if (alpha)
-            {
-                if (format == PixelFormat.Format32bppPArgb)
-                {
-                    Assert.Equal(a.A, c.A);
-                    // note sure why the -1
-                    Assert.Equal(a.R - 1, c.R);
-                    Assert.Equal(a.G - 1, c.G);
-                    Assert.Equal(a.B - 1, c.B);
-
-                    Assert.Equal(b.A, d.A);
-                    // note sure why the -1
-                    Assert.Equal(b.R - 1, d.R);
-                    Assert.Equal(b.G - 1, d.G);
-                    Assert.Equal(b.B - 1, d.B);
-                }
-                else
-                {
-                    Assert.Equal(a, c);
-                    Assert.Equal(b, d);
-                }
-            }
-            else
-            {
-                Assert.Equal(Color.FromArgb(255, 64, 32, 16), c);
-                Assert.Equal(Color.FromArgb(255, 96, 48, 24), d);
-            }
-            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, 2, 1), ImageLockMode.ReadOnly, format);
-            try
-            {
-                byte[] data = new byte[size];
-                Marshal.Copy(bd.Scan0, data, 0, size);
-                if (format == PixelFormat.Format32bppPArgb)
-                {
-                    Assert.Equal(Math.Ceiling((float)c.B * c.A / 255), data[0]);
-                    Assert.Equal(Math.Ceiling((float)c.G * c.A / 255), data[1]);
-                    Assert.Equal(Math.Ceiling((float)c.R * c.A / 255), data[2]);
-                    Assert.Equal(c.A, data[3]);
-                    Assert.Equal(Math.Ceiling((float)d.B * d.A / 255), data[4]);
-                    Assert.Equal(Math.Ceiling((float)d.G * d.A / 255), data[5]);
-                    Assert.Equal(Math.Ceiling((float)d.R * d.A / 255), data[6]);
-                    Assert.Equal(d.A, data[7]);
-                }
-                else if (size == 4)
-                {
-                    int n = 0;
-                    switch (format)
-                    {
-                        case PixelFormat.Format16bppRgb565:
-                            Assert.Equal(2, data[n++]);
-                            Assert.Equal(65, data[n++]);
-                            Assert.Equal(131, data[n++]);
-                            Assert.Equal(97, data[n++]);
-                            break;
-                        case PixelFormat.Format16bppArgb1555:
-                            Assert.Equal(130, data[n++]);
-                            Assert.Equal(160, data[n++]);
-                            Assert.Equal(195, data[n++]);
-                            Assert.Equal(176, data[n++]);
-                            break;
-                        case PixelFormat.Format16bppRgb555:
-                            Assert.Equal(130, data[n++]);
-                            Assert.Equal(32, data[n++]);
-                            Assert.Equal(195, data[n++]);
-                            Assert.Equal(48, data[n++]);
-                            break;
-                    }
-                }
-                else
-                {
-                    int n = 0;
-                    Assert.Equal(c.B, data[n++]);
-                    Assert.Equal(c.G, data[n++]);
-                    Assert.Equal(c.R, data[n++]);
-                    if (format != PixelFormat.Format32bppRgb)
-                    {
-                        if (size % 4 == 0)
-                            Assert.Equal(c.A, data[n++]);
-                        Assert.Equal(d.B, data[n++]);
-                        Assert.Equal(d.G, data[n++]);
-                        Assert.Equal(d.R, data[n++]);
-                        if (size % 4 == 0)
-                            Assert.Equal(d.A, data[n++]);
-                    }
-                }
-            }
-            finally
-            {
-                bmp.UnlockBits(bd);
-            }
-        }
-    }
-
-    [Fact]
-    public void Format32bppArgb()
-    {
-        FormatTest(PixelFormat.Format32bppArgb);
-    }
-
-    [Fact]
-    public void Format32bppRgb()
-    {
-        FormatTest(PixelFormat.Format32bppRgb);
-    }
-
-    [Fact]
-    public void Format24bppRgb()
-    {
-        FormatTest(PixelFormat.Format24bppRgb);
-    }
-
-    /* Get the output directory depending on the runtime and location*/
-    public static string getOutSubDir()
-    {
-        string sSub, sRslt;
-
-        if (Environment.GetEnvironmentVariable("MSNet") == null)
-            sSub = "mono/";
-        else
-            sSub = "MSNet/";
-
-        sRslt = Path.GetFullPath(sSub);
-
-        if (!Directory.Exists(sRslt))
-        {
-            sRslt = "Test/System.Drawing/" + sSub;
-        }
-
-        if (sRslt.Length > 0)
-        {
-            if (sRslt[sRslt.Length - 1] != '\\' && sRslt[sRslt.Length - 1] != '/')
-            {
-                sRslt += "/";
-            }
-        }
-
-        return sRslt;
-    }
-
-    [Fact]
-    public void Clone()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        Rectangle rect = new Rectangle(0, 0, 50, 50);
-        using (Bitmap bmp = new Bitmap(sInFile))
-        using (Bitmap bmpNew = bmp.Clone(rect, PixelFormat.Format32bppArgb))
-        {
-            Color colororg0 = bmp.GetPixel(0, 0);
-            Color colororg50 = bmp.GetPixel(49, 49);
-            Color colornew0 = bmpNew.GetPixel(0, 0);
-            Color colornew50 = bmpNew.GetPixel(49, 49);
-
-            Assert.Equal(colororg0, colornew0);
-            Assert.Equal(colororg50, colornew50);
-        }
-    }
-
-    [Fact]
-    public void CloneImage()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        using (Bitmap bmpNew = (Bitmap)bmp.Clone())
-        {
-            Assert.Equal(bmp.Width, bmpNew.Width);
-            Assert.Equal(bmp.Height, bmpNew.Height);
-            Assert.Equal(bmp.PixelFormat, bmpNew.PixelFormat);
-        }
-    }
-
-    [Fact]
-    public void Frames()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            int cnt = bmp.GetFrameCount(FrameDimension.Page);
-            int active = bmp.SelectActiveFrame(FrameDimension.Page, 0);
-
-            Assert.Equal(1, cnt);
-            Assert.Equal(0, active);
-        }
-    }
-
-    [Fact]
-    public void FileDoesNotExists()
-    {
-        Assert.Throws<ArgumentException>(() => new Bitmap("FileDoesNotExists.jpg"));
-    }
-
-    static string ByteArrayToString(byte[] arrInput)
-    {
-        StringBuilder sOutput = new StringBuilder(arrInput.Length);
-        for (int i = 0; i < arrInput.Length; i++)
-        {
-            sOutput.Append(arrInput[i].ToString("X2"));
-        }
-        return sOutput.ToString();
-    }
-
-
-    public string RotateBmp(Bitmap src, RotateFlipType rotate)
-    {
-        int width = 150, height = 150, index = 0;
-        byte[] pixels = new byte[width * height * 3];
-        byte[] hash;
-        Color clr;
-
-        using (Bitmap bmp_rotate = src.Clone(new RectangleF(0, 0, width, height), PixelFormat.Format32bppArgb))
-        {
-            bmp_rotate.RotateFlip(rotate);
-
-            for (int y = 0; y < height; y++)
-            {
-                for (int x = 0; x < width; x++)
-                {
-                    clr = bmp_rotate.GetPixel(x, y);
-                    pixels[index++] = clr.R;
-                    pixels[index++] = clr.G;
-                    pixels[index++] = clr.B;
-                }
-            }
-
-            hash = MD5.Create().ComputeHash(pixels);
-            return ByteArrayToString(hash);
-        }
-    }
-    public string RotateIndexedBmp(Bitmap src, RotateFlipType type)
-    {
-        int pixels_per_byte;
-
-        switch (src.PixelFormat)
-        {
-            case PixelFormat.Format1bppIndexed:
-                pixels_per_byte = 8;
-                break;
-            case PixelFormat.Format4bppIndexed:
-                pixels_per_byte = 2;
-                break;
-            case PixelFormat.Format8bppIndexed:
-                pixels_per_byte = 1;
-                break;
-
-            default:
-                throw new Exception($"Cannot pass a bitmap of format {src.PixelFormat} to RotateIndexedBmp");
-        }
-
-        using (Bitmap test = src.Clone() as Bitmap)
-        {
-            test.RotateFlip(type);
-
-            BitmapData data = null;
-            byte[] pixel_data;
-
-            try
-            {
-                data = test.LockBits(new Rectangle(0, 0, test.Width, test.Height), ImageLockMode.ReadOnly, test.PixelFormat);
-
-                int scan_size = (data.Width + pixels_per_byte - 1) / pixels_per_byte;
-                pixel_data = new byte[data.Height * scan_size];
-
-                for (int y = 0; y < data.Height; y++)
-                {
-                    IntPtr src_ptr = (IntPtr)(y * data.Stride + data.Scan0.ToInt64());
-                    int dest_offset = y * scan_size;
-                    for (int x = 0; x < scan_size; x++)
-                        pixel_data[dest_offset + x] = Marshal.ReadByte(src_ptr, x);
-                }
-            }
-            finally
-            {
-                if (test != null && data != null)
-                {
-                    try
-                    { test.UnlockBits(data); }
-                    catch { }
-                }
-            }
-
-            if (pixel_data == null)
-                return "--ERROR--";
-
-            byte[] hash = MD5.Create().ComputeHash(pixel_data);
-            return ByteArrayToString(hash);
-        }
-    }
-
-
-    // Rotate bitmap in diffent ways, and check the result
-    // pixels using MD5
-    [Fact]
-    public void Rotate()
-    {
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bmp = new Bitmap(sInFile))
-        {
-            Assert.Equal("312958A3C67402E1299413794988A3C7", RotateBmp(bmp, RotateFlipType.Rotate90FlipNone));
-            Assert.Equal("BF70D8DA4F1545AEDD77D0296B47AE58", RotateBmp(bmp, RotateFlipType.Rotate180FlipNone));
-            Assert.Equal("15AD2ADBDC7090C0EC744D0F7ACE2FD4", RotateBmp(bmp, RotateFlipType.Rotate270FlipNone));
-            Assert.Equal("2E10FEC1F4FD64ECC51D7CE68AEB183F", RotateBmp(bmp, RotateFlipType.RotateNoneFlipX));
-            Assert.Equal("E63204779B566ED01162B90B49BD9EE9", RotateBmp(bmp, RotateFlipType.Rotate90FlipX));
-            Assert.Equal("B1ECB17B5093E13D04FF55CFCF7763C9", RotateBmp(bmp, RotateFlipType.Rotate180FlipX));
-            Assert.Equal("71A173882C16755D86F4BC2653237425", RotateBmp(bmp, RotateFlipType.Rotate270FlipX));
-        }
-    }
-
-    private Bitmap CreateBitmap(int width, int height, PixelFormat fmt)
-    {
-        Bitmap bmp = new Bitmap(width, height, fmt);
-        using (Graphics gr = Graphics.FromImage(bmp))
-        {
-            Color c = Color.FromArgb(255, 100, 200, 250);
-            for (int x = 1; x < 80; x++)
-            {
-                bmp.SetPixel(x, 1, c);
-                bmp.SetPixel(x, 2, c);
-                bmp.SetPixel(x, 78, c);
-                bmp.SetPixel(x, 79, c);
-            }
-            for (int y = 3; y < 78; y++)
-            {
-                bmp.SetPixel(1, y, c);
-                bmp.SetPixel(2, y, c);
-                bmp.SetPixel(78, y, c);
-                bmp.SetPixel(79, y, c);
-            }
-        }
-        return bmp;
-    }
-
-    private byte[] HashPixels(Bitmap bmp)
-    {
-        int len = bmp.Width * bmp.Height * 4;
-        int index = 0;
-        byte[] pixels = new byte[len];
-
-        for (int y = 0; y < bmp.Height; y++)
-        {
-            for (int x = 0; x < bmp.Width; x++)
-            {
-                Color clr = bmp.GetPixel(x, y);
-                pixels[index++] = clr.R;
-                pixels[index++] = clr.G;
-                pixels[index++] = clr.B;
-            }
-        }
-        return MD5.Create().ComputeHash(pixels);
-    }
-
-    private byte[] HashLock(Bitmap bmp, int width, int height, PixelFormat fmt, ImageLockMode mode)
-    {
-        int len = bmp.Width * bmp.Height * 4;
-        byte[] pixels = new byte[len];
-        BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), mode, fmt);
-        try
-        {
-            int index = 0;
-            int bbps = Image.GetPixelFormatSize(fmt);
-            long pos = bd.Scan0.ToInt64();
-            byte[] btv = new byte[1];
-            for (int y = 0; y < bd.Height; y++)
-            {
-                for (int x = 0; x < bd.Width; x++)
-                {
-                    /* Read the pixels*/
-                    for (int bt = 0; bt < bbps / 8; bt++, index++)
-                    {
-                        long cur = pos;
-                        cur += y * bd.Stride;
-                        cur += x * bbps / 8;
-                        cur += bt;
-                        Marshal.Copy((IntPtr)cur, btv, 0, 1);
-                        pixels[index] = btv[0];
-
-                        /* Make change of all the colours = 250 to 10*/
-                        if (btv[0] == 250)
-                        {
-                            btv[0] = 10;
-                            Marshal.Copy(btv, 0, (IntPtr)cur, 1);
-                        }
-                    }
-                }
-            }
-
-            for (int i = index; i < len; i++)
-                pixels[index] = 0;
-        }
-        finally
-        {
-            bmp.UnlockBits(bd);
-        }
-        return MD5.Create().ComputeHash(pixels);
-    }
-
-    //  Tests the LockBitmap functions. Makes a hash of the block of pixels that it returns
-    // firsts, changes them, and then using GetPixel does another check of the changes.
-    // The results match the .NET Framework
-    private static byte[] DefaultBitmapHash = new byte[] { 0xD8, 0xD3, 0x68, 0x9C, 0x86, 0x7F, 0xB6, 0xA0, 0x76, 0xD6, 0x00, 0xEF, 0xFF, 0xE5, 0x8E, 0x1B };
-    private static byte[] FinalWholeBitmapHash = new byte[] { 0x5F, 0x52, 0x98, 0x37, 0xE3, 0x94, 0xE1, 0xA6, 0x06, 0x6C, 0x5B, 0xF1, 0xA9, 0xC2, 0xA9, 0x43 };
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format32bppArgb_ReadWrite_Whole()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x89, 0x6A, 0x6B, 0x35, 0x5C, 0x89, 0xD9, 0xE9, 0xF4, 0x51, 0xD5, 0x89, 0xED, 0x28, 0x68, 0x5C };
-            byte[] actual = HashLock(bmp, bmp.Width, bmp.Height, PixelFormat.Format32bppArgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalWholeBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format32bppPArgb_ReadWrite_Whole()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x89, 0x6A, 0x6B, 0x35, 0x5C, 0x89, 0xD9, 0xE9, 0xF4, 0x51, 0xD5, 0x89, 0xED, 0x28, 0x68, 0x5C };
-            byte[] actual = HashLock(bmp, bmp.Width, bmp.Height, PixelFormat.Format32bppPArgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalWholeBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [Fact]
-    public void LockBitmap_Format32bppArgb_Format32bppRgb_ReadWrite_Whole()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x89, 0x6a, 0x6b, 0x35, 0x5c, 0x89, 0xd9, 0xe9, 0xf4, 0x51, 0xd5, 0x89, 0xed, 0x28, 0x68, 0x5c };
-            byte[] actual = HashLock(bmp, bmp.Width, bmp.Height, PixelFormat.Format32bppRgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalWholeBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format24bppRgb_ReadWrite_Whole()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0xA7, 0xB2, 0x50, 0x04, 0x11, 0x12, 0x64, 0x68, 0x6B, 0x7D, 0x2F, 0x6E, 0x69, 0x24, 0xCB, 0x14 };
-            byte[] actual = HashLock(bmp, bmp.Width, bmp.Height, PixelFormat.Format24bppRgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalWholeBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    private static byte[] FinalPartialBitmapHash = new byte[] { 0xED, 0xD8, 0xDC, 0x9B, 0x44, 0x00, 0x22, 0x9B, 0x07, 0x06, 0x4A, 0x21, 0x70, 0xA7, 0x31, 0x1D };
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format32bppArgb_ReadWrite_Partial()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x5D, 0xFF, 0x02, 0x34, 0xEB, 0x7C, 0xF7, 0x42, 0xD4, 0xB7, 0x70, 0x49, 0xB4, 0x06, 0x79, 0xBC };
-            byte[] actual = HashLock(bmp, 50, 50, PixelFormat.Format32bppArgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalPartialBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format32bppPArgb_ReadWrite_Partial()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x5D, 0xFF, 0x02, 0x34, 0xEB, 0x7C, 0xF7, 0x42, 0xD4, 0xB7, 0x70, 0x49, 0xB4, 0x06, 0x79, 0xBC };
-            byte[] actual = HashLock(bmp, 50, 50, PixelFormat.Format32bppPArgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalPartialBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [Fact]
-    public void LockBitmap_Format32bppArgb_Format32bppRgb_ReadWrite_Partial()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x5d, 0xFF, 0x02, 0x34, 0xeb, 0x7c, 0xf7, 0x42, 0xd4, 0xb7, 0x70, 0x49, 0xb4, 0x06, 0x79, 0xbc };
-            byte[] actual = HashLock(bmp, 50, 50, PixelFormat.Format32bppRgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalPartialBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockBitmap_Format32bppArgb_Format24bppRgb_ReadWrite_Partial()
-    {
-        using (Bitmap bmp = CreateBitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            Assert.Equal(DefaultBitmapHash, HashPixels(bmp));
-            byte[] expected = { 0x4D, 0x39, 0x21, 0x88, 0xC2, 0x17, 0x14, 0x5F, 0x89, 0x9E, 0x02, 0x75, 0xF3, 0x64, 0xD8, 0xF0 };
-            byte[] actual = HashLock(bmp, 50, 50, PixelFormat.Format24bppRgb, ImageLockMode.ReadWrite);
-            Assert.Equal(expected, actual);
-            Assert.Equal(FinalPartialBitmapHash, HashPixels(bmp));
-        }
-    }
-
-    // Tests the LockBitmap and UnlockBitmap functions, specifically the copying
-    // of bitmap data in the directions indicated by the ImageLockMode.
-    [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-    public void LockUnlockBitmap()
-    {
-        BitmapData data;
-        int pixel_value;
-        Color pixel_colour;
-
-        Color red = Color.FromArgb(Color.Red.A, Color.Red.R, Color.Red.G, Color.Red.B);
-        Color blue = Color.FromArgb(Color.Blue.A, Color.Blue.R, Color.Blue.G, Color.Blue.B);
-
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format32bppRgb))
-        {
-            bmp.SetPixel(0, 0, red);
-            pixel_colour = bmp.GetPixel(0, 0);
-            Assert.Equal(red, pixel_colour);
-
-            data = bmp.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
-            try
-            {
-                pixel_value = Marshal.ReadByte(data.Scan0, 0);
-                pixel_value |= Marshal.ReadByte(data.Scan0, 1) << 8;
-                pixel_value |= Marshal.ReadByte(data.Scan0, 2) << 16;
-                pixel_value |= Marshal.ReadByte(data.Scan0, 3) << 24;
-
-                pixel_colour = Color.FromArgb(pixel_value);
-                // Disregard alpha information in the test
-                pixel_colour = Color.FromArgb(red.A, pixel_colour.R, pixel_colour.G, pixel_colour.B);
-                Assert.Equal(red, pixel_colour);
-
-                // write blue but we're locked in read-only...
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-                Marshal.WriteByte(data.Scan0, 3, blue.A);
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-                pixel_colour = bmp.GetPixel(0, 0);
-                // Disregard alpha information in the test
-                pixel_colour = Color.FromArgb(red.A, pixel_colour.R, pixel_colour.G, pixel_colour.B);
-                // ...so we still read red after unlocking
-                Assert.Equal(red, pixel_colour);
-            }
-
-            data = bmp.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
-            try
-            {
-                // write blue
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-                Marshal.WriteByte(data.Scan0, 3, blue.A);
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-                pixel_colour = bmp.GetPixel(0, 0);
-                // Disregard alpha information in the test
-                pixel_colour = Color.FromArgb(blue.A, pixel_colour.R, pixel_colour.G, pixel_colour.B);
-                // read blue
-                Assert.Equal(blue, pixel_colour);
-            }
-        }
-
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format32bppArgb))
-        {
-            bmp.SetPixel(0, 0, red);
-
-            data = bmp.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
-            try
-            {
-                byte b = Marshal.ReadByte(data.Scan0, 0);
-                byte g = Marshal.ReadByte(data.Scan0, 1);
-                byte r = Marshal.ReadByte(data.Scan0, 2);
-                pixel_colour = Color.FromArgb(red.A, r, g, b);
-                Assert.Equal(red, pixel_colour);
-                // write blue but we're locked in read-only...
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-                // ...so we still read red after unlocking
-                Assert.Equal(red, bmp.GetPixel(0, 0));
-            }
-
-            data = bmp.LockBits(new Rectangle(0, 0, 1, 1), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
-            try
-            {
-                // write blue
-                Marshal.WriteByte(data.Scan0, 0, blue.B);
-                Marshal.WriteByte(data.Scan0, 1, blue.G);
-                Marshal.WriteByte(data.Scan0, 2, blue.R);
-            }
-            finally
-            {
-                bmp.UnlockBits(data);
-                // read blue
-                Assert.Equal(blue, bmp.GetPixel(0, 0));
-            }
-        }
-    }
-    [Fact]
-    public void DefaultFormat1()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        {
-            Assert.Equal(ImageFormat.MemoryBmp, bmp.RawFormat);
-        }
-    }
-
-    [Fact]
-    public void DefaultFormat2()
-    {
-        string filename = Path.GetTempFileName();
-        using (Bitmap bmp = new Bitmap(20, 20))
-        {
-            bmp.Save(filename);
-        }
-
-        using (Bitmap other = new Bitmap(filename))
-        {
-            Assert.Equal(ImageFormat.Png, other.RawFormat);
-        }
-        File.Delete(filename);
-    }
-
-    [Fact]
-    public void BmpDataStride1()
-    {
-        Bitmap bmp = new Bitmap(184, 184, PixelFormat.Format1bppIndexed);
-        BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed);
-        try
-        {
-            Assert.Equal(24, data.Stride);
-        }
-        finally
-        {
-            bmp.UnlockBits(data);
-            bmp.Dispose();
-        }
-    }
-
-    static int[] palette1 = {
-        -16777216,
-        -1,
-    };
-
-    [Fact]
-    public void Format1bppIndexed_Palette()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format1bppIndexed))
-        {
-            ColorPalette pal = bmp.Palette;
-            Assert.Equal(2, pal.Entries.Length);
-            for (int i = 0; i < pal.Entries.Length; i++)
-            {
-                Assert.Equal(palette1[i], pal.Entries[i].ToArgb());
-            }
-            Assert.Equal(2, pal.Flags);
-        }
-    }
-
-    static int[] palette16 = {
-        -16777216,
-        -8388608,
-        -16744448,
-        -8355840,
-        -16777088,
-        -8388480,
-        -16744320,
-        -8355712,
-        -4144960,
-        -65536,
-        -16711936,
-        -256,
-        -16776961,
-        -65281,
-        -16711681,
-        -1,
-    };
-
-    [Fact]
-    public void Format4bppIndexed_Palette()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format4bppIndexed))
-        {
-            ColorPalette pal = bmp.Palette;
-            Assert.Equal(16, pal.Entries.Length);
-            for (int i = 0; i < pal.Entries.Length; i++)
-            {
-                Assert.Equal(palette16[i], pal.Entries[i].ToArgb());
-            }
-            Assert.Equal(0, pal.Flags);
-        }
-    }
-
-    static int[] palette256 = {
-        -16777216,
-        -8388608,
-        -16744448,
-        -8355840,
-        -16777088,
-        -8388480,
-        -16744320,
-        -8355712,
-        -4144960,
-        -65536,
-        -16711936,
-        -256,
-        -16776961,
-        -65281,
-        -16711681,
-        -1,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        -16777216,
-        -16777165,
-        -16777114,
-        -16777063,
-        -16777012,
-        -16776961,
-        -16764160,
-        -16764109,
-        -16764058,
-        -16764007,
-        -16763956,
-        -16763905,
-        -16751104,
-        -16751053,
-        -16751002,
-        -16750951,
-        -16750900,
-        -16750849,
-        -16738048,
-        -16737997,
-        -16737946,
-        -16737895,
-        -16737844,
-        -16737793,
-        -16724992,
-        -16724941,
-        -16724890,
-        -16724839,
-        -16724788,
-        -16724737,
-        -16711936,
-        -16711885,
-        -16711834,
-        -16711783,
-        -16711732,
-        -16711681,
-        -13434880,
-        -13434829,
-        -13434778,
-        -13434727,
-        -13434676,
-        -13434625,
-        -13421824,
-        -13421773,
-        -13421722,
-        -13421671,
-        -13421620,
-        -13421569,
-        -13408768,
-        -13408717,
-        -13408666,
-        -13408615,
-        -13408564,
-        -13408513,
-        -13395712,
-        -13395661,
-        -13395610,
-        -13395559,
-        -13395508,
-        -13395457,
-        -13382656,
-        -13382605,
-        -13382554,
-        -13382503,
-        -13382452,
-        -13382401,
-        -13369600,
-        -13369549,
-        -13369498,
-        -13369447,
-        -13369396,
-        -13369345,
-        -10092544,
-        -10092493,
-        -10092442,
-        -10092391,
-        -10092340,
-        -10092289,
-        -10079488,
-        -10079437,
-        -10079386,
-        -10079335,
-        -10079284,
-        -10079233,
-        -10066432,
-        -10066381,
-        -10066330,
-        -10066279,
-        -10066228,
-        -10066177,
-        -10053376,
-        -10053325,
-        -10053274,
-        -10053223,
-        -10053172,
-        -10053121,
-        -10040320,
-        -10040269,
-        -10040218,
-        -10040167,
-        -10040116,
-        -10040065,
-        -10027264,
-        -10027213,
-        -10027162,
-        -10027111,
-        -10027060,
-        -10027009,
-        -6750208,
-        -6750157,
-        -6750106,
-        -6750055,
-        -6750004,
-        -6749953,
-        -6737152,
-        -6737101,
-        -6737050,
-        -6736999,
-        -6736948,
-        -6736897,
-        -6724096,
-        -6724045,
-        -6723994,
-        -6723943,
-        -6723892,
-        -6723841,
-        -6711040,
-        -6710989,
-        -6710938,
-        -6710887,
-        -6710836,
-        -6710785,
-        -6697984,
-        -6697933,
-        -6697882,
-        -6697831,
-        -6697780,
-        -6697729,
-        -6684928,
-        -6684877,
-        -6684826,
-        -6684775,
-        -6684724,
-        -6684673,
-        -3407872,
-        -3407821,
-        -3407770,
-        -3407719,
-        -3407668,
-        -3407617,
-        -3394816,
-        -3394765,
-        -3394714,
-        -3394663,
-        -3394612,
-        -3394561,
-        -3381760,
-        -3381709,
-        -3381658,
-        -3381607,
-        -3381556,
-        -3381505,
-        -3368704,
-        -3368653,
-        -3368602,
-        -3368551,
-        -3368500,
-        -3368449,
-        -3355648,
-        -3355597,
-        -3355546,
-        -3355495,
-        -3355444,
-        -3355393,
-        -3342592,
-        -3342541,
-        -3342490,
-        -3342439,
-        -3342388,
-        -3342337,
-        -65536,
-        -65485,
-        -65434,
-        -65383,
-        -65332,
-        -65281,
-        -52480,
-        -52429,
-        -52378,
-        -52327,
-        -52276,
-        -52225,
-        -39424,
-        -39373,
-        -39322,
-        -39271,
-        -39220,
-        -39169,
-        -26368,
-        -26317,
-        -26266,
-        -26215,
-        -26164,
-        -26113,
-        -13312,
-        -13261,
-        -13210,
-        -13159,
-        -13108,
-        -13057,
-        -256,
-        -205,
-        -154,
-        -103,
-        -52,
-        -1,
-    };
-
-    [Fact]
-    public void Format8bppIndexed_Palette()
-    {
-        using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
-        {
-            ColorPalette pal = bmp.Palette;
-            Assert.Equal(256, pal.Entries.Length);
-            for (int i = 0; i < pal.Entries.Length; i++)
-            {
-                Assert.Equal(palette256[i], pal.Entries[i].ToArgb());
-            }
-            Assert.Equal(4, pal.Flags);
-        }
-    }
-
-    [Fact]
-    public void XmlSerialization()
-    {
-        new XmlSerializer(typeof(Bitmap));
-    }
-
-    private void SetResolution(float x, float y)
-    {
-        using (Bitmap bmp = new Bitmap(1, 1))
-        {
-            bmp.SetResolution(x, y);
-        }
-    }
-
-    [Fact]
-    public void SetResolution_Zero()
-    {
-        Assert.Throws<ArgumentException>(() => SetResolution(0.0f, 0.0f));
-    }
-
-    [Fact]
-    public void SetResolution_Negative_X()
-    {
-        Assert.Throws<ArgumentException>(() => SetResolution(-1.0f, 1.0f));
-    }
-
-    [Fact]
-    public void SetResolution_Negative_Y()
-    {
-        Assert.Throws<ArgumentException>(() => SetResolution(1.0f, -1.0f));
-    }
-
-    [Fact]
-    public void SetResolution_MaxValue()
-    {
-        SetResolution(float.MaxValue, float.MaxValue);
-    }
-
-    [Fact]
-    public void SetResolution_PositiveInfinity()
-    {
-        SetResolution(float.PositiveInfinity, float.PositiveInfinity);
-    }
-
-    [Fact]
-    public void SetResolution_NaN()
-    {
-        Assert.Throws<ArgumentException>(() => SetResolution(float.NaN, float.NaN));
-    }
-
-    [Fact]
-    public void SetResolution_NegativeInfinity()
-    {
-        Assert.Throws<ArgumentException>(() => SetResolution(float.NegativeInfinity, float.NegativeInfinity));
-    }
-}
-
-public class BitmapFullTrustTest
-{
-    [Fact]
-    public void BitmapIntIntIntPixelFormatIntPtrCtor()
-    {
-        new Bitmap(1, 1, 1, PixelFormat.Format1bppIndexed, IntPtr.Zero);
-    }
-
-    // BitmapFromHicon## is *almost* the same as IconTest.Icon##ToBitmap except
-    // for the Flags property
-
-    private void HiconTest(string msg, Bitmap b, int size)
-    {
-        Assert.Equal(PixelFormat.Format32bppArgb, b.PixelFormat);
-        // unlike the GDI+ icon decoder the palette isn't kept
-        Assert.Equal(0, b.Palette.Entries.Length);
-        Assert.Equal(size, b.Height);
-        Assert.Equal(size, b.Width);
-        Assert.Equal(b.RawFormat, ImageFormat.MemoryBmp);
-        Assert.Equal(335888, b.Flags);
-    }
-
-    [Fact]
-    public void Hicon16()
-    {
-        IntPtr hicon;
-        int size;
-        using (Icon icon = new Icon(Helpers.GetTestBitmapPath("16x16_one_entry_4bit.ico")))
-        {
-            size = icon.Width;
-            using (Bitmap bitmap = Bitmap.FromHicon(icon.Handle))
-            {
-                HiconTest("Icon.Handle/FromHicon", bitmap, size);
-                hicon = bitmap.GetHicon();
-            }
-        }
-        using (Bitmap bitmap2 = Bitmap.FromHicon(hicon))
-        {
-            // hicon survives bitmap and icon disposal
-            HiconTest("GetHicon/FromHicon", bitmap2, size);
-        }
-    }
-
-    [Fact]
-    public void Hicon32()
-    {
-        IntPtr hicon;
-        int size;
-        using (Icon icon = new Icon(Helpers.GetTestBitmapPath("32x32_one_entry_4bit.ico")))
-        {
-            size = icon.Width;
-            using (Bitmap bitmap = Bitmap.FromHicon(icon.Handle))
-            {
-                HiconTest("Icon.Handle/FromHicon", bitmap, size);
-                hicon = bitmap.GetHicon();
-            }
-        }
-        using (Bitmap bitmap2 = Bitmap.FromHicon(hicon))
-        {
-            // hicon survives bitmap and icon disposal
-            HiconTest("GetHicon/FromHicon", bitmap2, size);
-        }
-    }
-
-    [Fact]
-    public void Hicon64()
-    {
-        IntPtr hicon;
-        int size;
-        using (Icon icon = new Icon(Helpers.GetTestBitmapPath("64x64_one_entry_8bit.ico")))
-        {
-            size = icon.Width;
-            using (Bitmap bitmap = Bitmap.FromHicon(icon.Handle))
-            {
-                HiconTest("Icon.Handle/FromHicon", bitmap, size);
-                hicon = bitmap.GetHicon();
-            }
-        }
-        using (Bitmap bitmap2 = Bitmap.FromHicon(hicon))
-        {
-            // hicon survives bitmap and icon disposal
-            HiconTest("GetHicon/FromHicon", bitmap2, size);
-        }
-    }
-
-    [Fact]
-    public void Hicon96()
-    {
-        IntPtr hicon;
-        int size;
-        using (Icon icon = new Icon(Helpers.GetTestBitmapPath("96x96_one_entry_8bit.ico")))
-        {
-            size = icon.Width;
-            using (Bitmap bitmap = Bitmap.FromHicon(icon.Handle))
-            {
-                HiconTest("Icon.Handle/FromHicon", bitmap, size);
-                hicon = bitmap.GetHicon();
-            }
-        }
-        using (Bitmap bitmap2 = Bitmap.FromHicon(hicon))
-        {
-            // hicon survives bitmap and icon disposal
-            HiconTest("GetHicon/FromHicon", bitmap2, size);
-        }
-    }
-
-    [Fact]
-    public void HBitmap()
-    {
-        IntPtr hbitmap;
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bitmap = new Bitmap(sInFile))
-        {
-            Assert.Equal(PixelFormat.Format24bppRgb, bitmap.PixelFormat);
-            Assert.Equal(0, bitmap.Palette.Entries.Length);
-            Assert.Equal(183, bitmap.Height);
-            Assert.Equal(173, bitmap.Width);
-            Assert.Equal(73744, bitmap.Flags);
-            Assert.Equal(bitmap.RawFormat, ImageFormat.Bmp);
-            hbitmap = bitmap.GetHbitmap();
-        }
-
-        // hbitmap survives original bitmap disposal
-        using (Image image = Image.FromHbitmap(hbitmap))
-        {
-            //Assert.Equal (PixelFormat.Format32bppRgb, image.PixelFormat);
-            Assert.Equal(0, image.Palette.Entries.Length);
-            Assert.Equal(183, image.Height);
-            Assert.Equal(173, image.Width);
-            Assert.Equal(335888, image.Flags);
-            Assert.Equal(image.RawFormat, ImageFormat.MemoryBmp);
-        }
-    }
-
-    [Fact]
-    public void CreateMultipleBitmapFromSameHBITMAP()
-    {
-        IntPtr hbitmap;
-        string sInFile = Helpers.GetTestBitmapPath("almogaver24bits.bmp");
-        using (Bitmap bitmap = new Bitmap(sInFile))
-        {
-            Assert.Equal(PixelFormat.Format24bppRgb, bitmap.PixelFormat);
-            Assert.Equal(0, bitmap.Palette.Entries.Length);
-            Assert.Equal(183, bitmap.Height);
-            Assert.Equal(173, bitmap.Width);
-            Assert.Equal(73744, bitmap.Flags);
-            Assert.Equal(bitmap.RawFormat, ImageFormat.Bmp);
-            hbitmap = bitmap.GetHbitmap();
-        }
-        // hbitmap survives original bitmap disposal
-        using (Image image = Image.FromHbitmap(hbitmap))
-        {
-            //Assert.Equal (PixelFormat.Format32bppRgb, image.PixelFormat);
-            Assert.Equal(0, image.Palette.Entries.Length);
-            Assert.Equal(183, image.Height);
-            Assert.Equal(173, image.Width);
-            Assert.Equal(335888, image.Flags);
-            Assert.Equal(image.RawFormat, ImageFormat.MemoryBmp);
-        }
-        using (Image image2 = Image.FromHbitmap(hbitmap))
-        {
-            //Assert.Equal (PixelFormat.Format32bppRgb, image2.PixelFormat);
-            Assert.Equal(0, image2.Palette.Entries.Length);
-            Assert.Equal(183, image2.Height);
-            Assert.Equal(173, image2.Width);
-            Assert.Equal(335888, image2.Flags);
-            Assert.Equal(image2.RawFormat, ImageFormat.MemoryBmp);
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Drawing/GraphicsTests.cs b/src/System.Drawing.Common/tests/mono/System.Drawing/GraphicsTests.cs
deleted file mode 100644
index 286fa8d2259..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Drawing/GraphicsTests.cs
+++ /dev/null
@@ -1,3319 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Graphics class testing unit
-//
-// Authors:
-//   Jordi Mas, jordi@ximian.com
-//   Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2005-2008 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Drawing.Text;
-using Microsoft.DotNet.XUnitExtensions;
-
-namespace MonoTests.System.Drawing;
-
-[ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.IsDrawingSupported))]
-public class GraphicsTest : IDisposable
-{
-    private RectangleF[] rects;
-    private Font font;
-
-    public GraphicsTest()
-    {
-        try
-        {
-            font = new Font("Arial", 12);
-        }
-        catch
-        {
-        }
-    }
-
-    public void Dispose()
-    {
-        if (font != null)
-            font.Dispose();
-    }
-
-    private bool IsEmptyBitmap(Bitmap bitmap, out int x, out int y)
-    {
-        bool result = true;
-        int empty = Color.Empty.ToArgb();
-        for (y = 0; y < bitmap.Height; y++)
-        {
-            for (x = 0; x < bitmap.Width; x++)
-            {
-                if (bitmap.GetPixel(x, y).ToArgb() != empty)
-                    return false;
-            }
-        }
-
-        x = -1;
-        y = -1;
-        return result;
-    }
-
-    private void CheckForEmptyBitmap(Bitmap bitmap)
-    {
-        int x, y;
-        if (!IsEmptyBitmap(bitmap, out x, out y))
-            Assert.True(false, $"Position {x},{y}");
-    }
-
-    private void CheckForNonEmptyBitmap(Bitmap bitmap)
-    {
-        int x, y;
-        if (IsEmptyBitmap(bitmap, out x, out y))
-            Assert.True(false);
-    }
-
-    private void AssertEquals(string msg, object expected, object actual)
-    {
-        Assert.Equal(expected, actual);
-    }
-
-    private void AssertEquals(string msg, double expected, double actual, int precision)
-    {
-        Assert.Equal(expected, actual, precision);
-    }
-
-    [Fact]
-    public void DefaultProperties()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (Region r = new Region())
-        {
-            Assert.Equal(r.GetBounds(g), g.ClipBounds);
-            Assert.Equal(CompositingMode.SourceOver, g.CompositingMode);
-            Assert.Equal(CompositingQuality.Default, g.CompositingQuality);
-            Assert.Equal(InterpolationMode.Bilinear, g.InterpolationMode);
-            Assert.Equal(1, g.PageScale);
-            Assert.Equal(GraphicsUnit.Display, g.PageUnit);
-            Assert.Equal(PixelOffsetMode.Default, g.PixelOffsetMode);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-            Assert.Equal(SmoothingMode.None, g.SmoothingMode);
-            Assert.Equal(TextRenderingHint.SystemDefault, g.TextRenderingHint);
-        }
-    }
-
-    [Fact]
-    public void SetGetProperties()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.GammaCorrected;
-            g.InterpolationMode = InterpolationMode.HighQualityBilinear;
-            g.PageScale = 2;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.RenderingOrigin = new Point(10, 20);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextRenderingHint = TextRenderingHint.SystemDefault;
-
-            //Clipping set/get tested in clipping functions
-            Assert.Equal(CompositingMode.SourceCopy, g.CompositingMode);
-            Assert.Equal(CompositingQuality.GammaCorrected, g.CompositingQuality);
-            Assert.Equal(InterpolationMode.HighQualityBilinear, g.InterpolationMode);
-            Assert.Equal(2, g.PageScale);
-            Assert.Equal(GraphicsUnit.Inch, g.PageUnit);
-            Assert.Equal(PixelOffsetMode.Half, g.PixelOffsetMode);
-            Assert.Equal(new Point(10, 20), g.RenderingOrigin);
-            Assert.Equal(SmoothingMode.AntiAlias, g.SmoothingMode);
-            Assert.Equal(TextRenderingHint.SystemDefault, g.TextRenderingHint);
-        }
-    }
-
-    // Properties
-    [Fact]
-    public void Clip()
-    {
-        RectangleF[] rects;
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.Clip = new Region(new Rectangle(50, 40, 210, 220));
-            rects = g.Clip.GetRegionScans(new Matrix());
-
-            Assert.Equal(1, rects.Length);
-            Assert.Equal(50, rects[0].X);
-            Assert.Equal(40, rects[0].Y);
-            Assert.Equal(210, rects[0].Width);
-            Assert.Equal(220, rects[0].Height);
-        }
-    }
-
-    [Fact]
-    public void Clip_NotAReference()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.True(g.Clip.IsInfinite(g));
-            g.Clip.IsEmpty(g);
-            Assert.False(g.Clip.IsEmpty(g));
-            Assert.True(g.Clip.IsInfinite(g));
-        }
-    }
-
-    [Fact]
-    public void ExcludeClip()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.Clip = new Region(new RectangleF(10, 10, 100, 100));
-            g.ExcludeClip(new Rectangle(40, 60, 100, 20));
-            rects = g.Clip.GetRegionScans(new Matrix());
-
-            Assert.Equal(3, rects.Length);
-
-            Assert.Equal(10, rects[0].X);
-            Assert.Equal(10, rects[0].Y);
-            Assert.Equal(100, rects[0].Width);
-            Assert.Equal(50, rects[0].Height);
-
-            Assert.Equal(10, rects[1].X);
-            Assert.Equal(60, rects[1].Y);
-            Assert.Equal(30, rects[1].Width);
-            Assert.Equal(20, rects[1].Height);
-
-            Assert.Equal(10, rects[2].X);
-            Assert.Equal(80, rects[2].Y);
-            Assert.Equal(100, rects[2].Width);
-            Assert.Equal(30, rects[2].Height);
-        }
-    }
-
-    [Fact]
-    public void IntersectClip()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.Clip = new Region(new RectangleF(260, 30, 60, 80));
-            g.IntersectClip(new Rectangle(290, 40, 60, 80));
-            rects = g.Clip.GetRegionScans(new Matrix());
-
-            Assert.Equal(1, rects.Length);
-
-            Assert.Equal(290, rects[0].X);
-            Assert.Equal(40, rects[0].Y);
-            Assert.Equal(30, rects[0].Width);
-            Assert.Equal(70, rects[0].Height);
-        }
-    }
-
-    [Fact]
-    public void ResetClip()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.Clip = new Region(new RectangleF(260, 30, 60, 80));
-            g.IntersectClip(new Rectangle(290, 40, 60, 80));
-            g.ResetClip();
-            rects = g.Clip.GetRegionScans(new Matrix());
-
-            Assert.Equal(1, rects.Length);
-
-            Assert.Equal(-4194304, rects[0].X);
-            Assert.Equal(-4194304, rects[0].Y);
-            Assert.Equal(8388608, rects[0].Width);
-            Assert.Equal(8388608, rects[0].Height);
-        }
-    }
-
-    [Fact]
-    public void SetClip()
-    {
-        RectangleF[] rects;
-        using (Bitmap bmp = new Bitmap(200, 200))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                // Region
-                g.SetClip(new Region(new Rectangle(50, 40, 210, 220)), CombineMode.Replace);
-                rects = g.Clip.GetRegionScans(new Matrix());
-                Assert.Equal(1, rects.Length);
-                Assert.Equal(50, rects[0].X);
-                Assert.Equal(40, rects[0].Y);
-                Assert.Equal(210, rects[0].Width);
-                Assert.Equal(220, rects[0].Height);
-            }
-
-            // RectangleF
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                g.SetClip(new RectangleF(50, 40, 210, 220));
-                rects = g.Clip.GetRegionScans(new Matrix());
-                Assert.Equal(1, rects.Length);
-                Assert.Equal(50, rects[0].X);
-                Assert.Equal(40, rects[0].Y);
-                Assert.Equal(210, rects[0].Width);
-                Assert.Equal(220, rects[0].Height);
-            }
-
-            // Rectangle
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                g.SetClip(new Rectangle(50, 40, 210, 220));
-                rects = g.Clip.GetRegionScans(new Matrix());
-                Assert.Equal(1, rects.Length);
-                Assert.Equal(50, rects[0].X);
-                Assert.Equal(40, rects[0].Y);
-                Assert.Equal(210, rects[0].Width);
-                Assert.Equal(220, rects[0].Height);
-            }
-        }
-    }
-
-    [Fact]
-    public void SetSaveReset()
-    {
-        using (Bitmap bmp = new Bitmap(200, 200))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            GraphicsState state_default, state_modified;
-
-            state_default = g.Save(); // Default
-
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.GammaCorrected;
-            g.InterpolationMode = InterpolationMode.HighQualityBilinear;
-            g.PageScale = 2;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.Clip = new Region(new Rectangle(0, 0, 100, 100));
-            g.RenderingOrigin = new Point(10, 20);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
-
-
-            state_modified = g.Save(); // Modified
-
-            g.CompositingMode = CompositingMode.SourceOver;
-            g.CompositingQuality = CompositingQuality.Default;
-            g.InterpolationMode = InterpolationMode.Bilinear;
-            g.PageScale = 5;
-            g.PageUnit = GraphicsUnit.Display;
-            g.PixelOffsetMode = PixelOffsetMode.Default;
-            g.Clip = new Region(new Rectangle(1, 2, 20, 25));
-            g.RenderingOrigin = new Point(5, 6);
-            g.SmoothingMode = SmoothingMode.None;
-            g.TextRenderingHint = TextRenderingHint.SystemDefault;
-
-            g.Restore(state_modified);
-
-            Assert.Equal(CompositingMode.SourceCopy, g.CompositingMode);
-            Assert.Equal(CompositingQuality.GammaCorrected, g.CompositingQuality);
-            Assert.Equal(InterpolationMode.HighQualityBilinear, g.InterpolationMode);
-            Assert.Equal(2, g.PageScale);
-            Assert.Equal(GraphicsUnit.Inch, g.PageUnit);
-            Assert.Equal(PixelOffsetMode.Half, g.PixelOffsetMode);
-            Assert.Equal(new Point(10, 20), g.RenderingOrigin);
-            Assert.Equal(SmoothingMode.AntiAlias, g.SmoothingMode);
-            Assert.Equal(TextRenderingHint.ClearTypeGridFit, g.TextRenderingHint);
-            Assert.Equal(0, (int)g.ClipBounds.X);
-            Assert.Equal(0, (int)g.ClipBounds.Y);
-
-            g.Restore(state_default);
-
-            Assert.Equal(CompositingMode.SourceOver, g.CompositingMode);
-            Assert.Equal(CompositingQuality.Default, g.CompositingQuality);
-            Assert.Equal(InterpolationMode.Bilinear, g.InterpolationMode);
-            Assert.Equal(1, g.PageScale);
-            Assert.Equal(GraphicsUnit.Display, g.PageUnit);
-            Assert.Equal(PixelOffsetMode.Default, g.PixelOffsetMode);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-            Assert.Equal(SmoothingMode.None, g.SmoothingMode);
-            Assert.Equal(TextRenderingHint.SystemDefault, g.TextRenderingHint);
-
-            Region r = new Region();
-            Assert.Equal(r.GetBounds(g), g.ClipBounds);
-        }
-    }
-
-    [Fact]
-    public void LoadIndexed_BmpFile()
-    {
-        // Tests that we can load an indexed file, but...
-        string sInFile = Helpers.GetTestBitmapPath("almogaver1bit.bmp");
-        // note: file is misnamed (it's a 4bpp bitmap)
-        using (Image img = Image.FromFile(sInFile))
-        {
-            Assert.Equal(PixelFormat.Format4bppIndexed, img.PixelFormat);
-            Exception exception = AssertExtensions.Throws<ArgumentException, Exception>(() => Graphics.FromImage(img));
-            if (exception is ArgumentException argumentException)
-                Assert.Equal("image", argumentException.ParamName);
-        }
-    }
-
-    class BitmapAndGraphics : IDisposable
-    {
-        private readonly Bitmap _bitmap;
-        public Graphics Graphics { get; }
-        public BitmapAndGraphics(int width, int height)
-        {
-            _bitmap = new Bitmap(width, height);
-            Graphics = Graphics.FromImage(_bitmap);
-            Graphics.Clip = new Region(new Rectangle(0, 0, width, height));
-        }
-        public void Dispose() { Graphics.Dispose(); _bitmap.Dispose(); }
-    }
-
-    private void Compare(string msg, RectangleF b1, RectangleF b2)
-    {
-        AssertEquals(msg + ".compare.X", b1.X, b2.X);
-        AssertEquals(msg + ".compare.Y", b1.Y, b2.Y);
-        AssertEquals(msg + ".compare.Width", b1.Width, b2.Width);
-        AssertEquals(msg + ".compare.Height", b1.Height, b2.Height);
-    }
-
-    [Fact]
-    public void Clip_GetBounds()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            RectangleF bounds = g.Clip.GetBounds(g);
-            Assert.Equal(0, bounds.X);
-            Assert.Equal(0, bounds.Y);
-            Assert.Equal(16, bounds.Width);
-            Assert.Equal(16, bounds.Height);
-            Assert.True(g.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void Clip_TranslateTransform()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.TranslateTransform(12.22f, 10.10f);
-            RectangleF bounds = g.Clip.GetBounds(g);
-            Compare("translate", bounds, g.ClipBounds);
-            Assert.Equal(-12.2200003f, bounds.X);
-            Assert.Equal(-10.1000004f, bounds.Y);
-            Assert.Equal(16, bounds.Width);
-            Assert.Equal(16, bounds.Height);
-            float[] elements = g.Transform.Elements;
-            Assert.Equal(1, elements[0]);
-            Assert.Equal(0, elements[1]);
-            Assert.Equal(0, elements[2]);
-            Assert.Equal(1, elements[3]);
-            Assert.Equal(12.2200003f, elements[4]);
-            Assert.Equal(10.1000004f, elements[5]);
-
-            g.ResetTransform();
-            bounds = g.Clip.GetBounds(g);
-            Compare("reset", bounds, g.ClipBounds);
-            Assert.Equal(0, bounds.X);
-            Assert.Equal(0, bounds.Y);
-            Assert.Equal(16, bounds.Width);
-            Assert.Equal(16, bounds.Height);
-            Assert.True(g.Transform.IsIdentity);
-        }
-    }
-
-    [Fact]
-    public void Transform_NonInvertibleMatrix()
-    {
-        using (Matrix matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            Assert.False(matrix.IsInvertible);
-
-            var g = b.Graphics;
-            Assert.Throws<ArgumentException>(() => g.Transform = matrix);
-        }
-    }
-
-
-    [Fact]
-    public void Multiply_NonInvertibleMatrix()
-    {
-        using (Matrix matrix = new Matrix(123, 24, 82, 16, 47, 30))
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            Assert.False(matrix.IsInvertible);
-
-            var g = b.Graphics;
-            Assert.Throws<ArgumentException>(() => g.MultiplyTransform(matrix));
-        }
-    }
-
-    private void CheckBounds(string msg, RectangleF bounds, float x, float y, float w, float h)
-    {
-        AssertEquals(msg + ".X", x, bounds.X, 1);
-        AssertEquals(msg + ".Y", y, bounds.Y, 1);
-        AssertEquals(msg + ".Width", w, bounds.Width, 1);
-        AssertEquals(msg + ".Height", h, bounds.Height, 1);
-    }
-
-    [Fact]
-    public void ClipBounds()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            CheckBounds("graphics.ClipBounds", g.ClipBounds, 0, 0, 16, 16);
-            CheckBounds("graphics.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 16);
-
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            CheckBounds("clip.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("clip.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Rotate()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            g.RotateTransform(90);
-            CheckBounds("rotate.ClipBounds", g.ClipBounds, 0, -8, 8, 8);
-            CheckBounds("rotate.Clip.GetBounds", g.Clip.GetBounds(g), 0, -8, 8, 8);
-
-            g.Transform = new Matrix();
-            CheckBounds("identity.ClipBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-            CheckBounds("identity.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Scale()
-    {
-        RectangleF clip = new Rectangle(0, 0, 8, 8);
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(clip);
-            g.ScaleTransform(0.25f, 0.5f);
-            CheckBounds("scale.ClipBounds", g.ClipBounds, 0, 0, 32, 16);
-            CheckBounds("scale.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 32, 16);
-
-            g.SetClip(clip);
-            CheckBounds("setclip.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("setclip.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Translate()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            using (Region clone = g.Clip.Clone())
-            {
-                g.TranslateTransform(8, 8);
-                CheckBounds("translate.ClipBounds", g.ClipBounds, -8, -8, 8, 8);
-                CheckBounds("translate.Clip.GetBounds", g.Clip.GetBounds(g), -8, -8, 8, 8);
-
-                g.SetClip(clone, CombineMode.Replace);
-                CheckBounds("setclip.ClipBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-                CheckBounds("setclip.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-            }
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Transform_Translation()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            g.Transform = new Matrix(1, 0, 0, 1, 8, 8);
-            CheckBounds("transform.ClipBounds", g.ClipBounds, -8, -8, 8, 8);
-            CheckBounds("transform.Clip.GetBounds", g.Clip.GetBounds(g), -8, -8, 8, 8);
-
-            g.ResetTransform();
-            CheckBounds("reset.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("reset.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Transform_Scale()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            g.Transform = new Matrix(0.5f, 0, 0, 0.25f, 0, 0);
-            CheckBounds("scale.ClipBounds", g.ClipBounds, 0, 0, 16, 32);
-            CheckBounds("scale.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 32);
-
-            g.ResetClip();
-            // see next test for ClipBounds
-            CheckBounds("resetclip.Clip.GetBounds", g.Clip.GetBounds(g), -4194304, -4194304, 8388608, 8388608);
-            Assert.True(g.Clip.IsInfinite(g));
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Multiply()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            g.Transform = new Matrix(1, 0, 0, 1, 8, 8);
-            g.MultiplyTransform(g.Transform);
-            CheckBounds("multiply.ClipBounds", g.ClipBounds, -16, -16, 8, 8);
-            CheckBounds("multiply.Clip.GetBounds", g.Clip.GetBounds(g), -16, -16, 8, 8);
-
-            g.ResetTransform();
-            CheckBounds("reset.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("reset.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void ClipBounds_Cumulative_Effects()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            CheckBounds("graphics.ClipBounds", g.ClipBounds, 0, 0, 16, 16);
-            CheckBounds("graphics.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 16);
-
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            CheckBounds("clip.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("clip.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-
-            g.RotateTransform(90);
-            CheckBounds("rotate.ClipBounds", g.ClipBounds, 0, -8, 8, 8);
-            CheckBounds("rotate.Clip.GetBounds", g.Clip.GetBounds(g), 0, -8, 8, 8);
-
-            g.ScaleTransform(0.25f, 0.5f);
-            CheckBounds("scale.ClipBounds", g.ClipBounds, 0, -16, 32, 16);
-            CheckBounds("scale.Clip.GetBounds", g.Clip.GetBounds(g), 0, -16, 32, 16);
-
-            g.TranslateTransform(8, 8);
-            CheckBounds("translate.ClipBounds", g.ClipBounds, -8, -24, 32, 16);
-            CheckBounds("translate.Clip.GetBounds", g.Clip.GetBounds(g), -8, -24, 32, 16);
-
-            g.MultiplyTransform(g.Transform);
-            CheckBounds("multiply.ClipBounds", g.ClipBounds, -104, -56, 64, 64);
-            CheckBounds("multiply.Clip.GetBounds", g.Clip.GetBounds(g), -104, -56, 64, 64);
-
-            g.ResetTransform();
-            CheckBounds("reset.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            CheckBounds("reset.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void Clip_TranslateTransform_BoundsChange()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            CheckBounds("graphics.ClipBounds", g.ClipBounds, 0, 0, 16, 16);
-            CheckBounds("graphics.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 16);
-            g.TranslateTransform(-16, -16);
-            CheckBounds("translated.ClipBounds", g.ClipBounds, 16, 16, 16, 16);
-            CheckBounds("translated.Clip.GetBounds", g.Clip.GetBounds(g), 16, 16, 16, 16);
-
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            // ClipBounds isn't affected by a previous translation
-            CheckBounds("rectangle.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            // Clip.GetBounds isn't affected by a previous translation
-            CheckBounds("rectangle.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-
-            g.ResetTransform();
-            CheckBounds("reseted.ClipBounds", g.ClipBounds, -16, -16, 8, 8);
-            CheckBounds("reseted.Clip.GetBounds", g.Clip.GetBounds(g), -16, -16, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void Clip_RotateTransform_BoundsChange()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            CheckBounds("graphics.ClipBounds", g.ClipBounds, 0, 0, 16, 16);
-            CheckBounds("graphics.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 16);
-            // we select a "simple" angle because the region will be converted into
-            // a bitmap (well for libgdiplus) and we would lose precision after that
-            g.RotateTransform(90);
-            CheckBounds("rotated.ClipBounds", g.ClipBounds, 0, -16, 16, 16);
-            CheckBounds("rotated.Clip.GetBounds", g.Clip.GetBounds(g), 0, -16, 16, 16);
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            // ClipBounds isn't affected by a previous rotation (90)
-            CheckBounds("rectangle.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            // Clip.GetBounds isn't affected by a previous rotation
-            CheckBounds("rectangle.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-
-            g.ResetTransform();
-            CheckBounds("reseted.ClipBounds", g.ClipBounds, -8, 0, 8, 8);
-            CheckBounds("reseted.Clip.GetBounds", g.Clip.GetBounds(g), -8, 0, 8, 8);
-        }
-    }
-
-    [Fact]
-    public void Clip_ScaleTransform_NoBoundsChange()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            CheckBounds("graphics.ClipBounds", g.ClipBounds, 0, 0, 16, 16);
-            CheckBounds("graphics.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 16);
-            g.ScaleTransform(2, 0.5f);
-            CheckBounds("scaled.ClipBounds", g.ClipBounds, 0, 0, 8, 32);
-            CheckBounds("scaled.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 32);
-            g.Clip = new Region(new Rectangle(0, 0, 8, 8));
-            // ClipBounds isn't affected by a previous scaling
-            CheckBounds("rectangle.ClipBounds", g.ClipBounds, 0, 0, 8, 8);
-            // Clip.GetBounds isn't affected by a previous scaling
-            CheckBounds("rectangle.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 8, 8);
-
-            g.ResetTransform();
-            CheckBounds("reseted.ClipBounds", g.ClipBounds, 0, 0, 16, 4);
-            CheckBounds("reseted.Clip.GetBounds", g.Clip.GetBounds(g), 0, 0, 16, 4);
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_X0()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            Assert.Throws<ArgumentException>(() => g.ScaleTransform(0, 1));
-        }
-    }
-
-    [Fact]
-    public void ScaleTransform_Y0()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            Assert.Throws<ArgumentException>(() => g.ScaleTransform(1, 0));
-        }
-    }
-
-    [Fact]
-    public void TranslateTransform_Order()
-    {
-        using (var b = new BitmapAndGraphics(16, 16))
-        {
-            var g = b.Graphics;
-            g.Transform = new Matrix(1, 2, 3, 4, 5, 6);
-            g.TranslateTransform(3, -3);
-            float[] elements = g.Transform.Elements;
-            Assert.Equal(1, elements[0]);
-            Assert.Equal(2, elements[1]);
-            Assert.Equal(3, elements[2]);
-            Assert.Equal(4, elements[3]);
-            Assert.Equal(-1, elements[4]);
-            Assert.Equal(0, elements[5]);
-
-            g.Transform = new Matrix(1, 2, 3, 4, 5, 6);
-            g.TranslateTransform(3, -3, MatrixOrder.Prepend);
-            elements = g.Transform.Elements;
-            Assert.Equal(1, elements[0]);
-            Assert.Equal(2, elements[1]);
-            Assert.Equal(3, elements[2]);
-            Assert.Equal(4, elements[3]);
-            Assert.Equal(-1, elements[4]);
-            Assert.Equal(0, elements[5]);
-
-            g.Transform = new Matrix(1, 2, 3, 4, 5, 6);
-            g.TranslateTransform(3, -3, MatrixOrder.Append);
-            elements = g.Transform.Elements;
-            Assert.Equal(1, elements[0]);
-            Assert.Equal(2, elements[1]);
-            Assert.Equal(3, elements[2]);
-            Assert.Equal(4, elements[3]);
-            Assert.Equal(8, elements[4]);
-            Assert.Equal(3, elements[5]);
-        }
-    }
-
-    static PointF[] SmallCurveF = new PointF[3] { new PointF(0, 0), new PointF(15, 5), new PointF(5, 15) };
-
-    static Point[] TooSmallCurve = new Point[2] { new Point(0, 0), new Point(15, 5) };
-    static PointF[] LargeCurveF = new PointF[4] { new PointF(0, 0), new PointF(15, 5), new PointF(5, 15), new PointF(0, 20) };
-
-    [Fact]
-    public void DrawCurve_NotEnoughPoints()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            CheckForEmptyBitmap(bitmap);
-            g.DrawCurve(Pens.Black, TooSmallCurve, 0.5f);
-            CheckForNonEmptyBitmap(bitmap);
-            // so a "curve" can be drawn with less than 3 points!
-            // actually I used to call that a line... (and it's not related to tension)
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_SinglePoint()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawCurve(Pens.Black, new Point[1] { new Point(10, 10) }, 0.5f));
-            // a single point isn't enough
-        }
-    }
-
-    [Fact]
-    public void DrawCurve3_NotEnoughPoints()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawCurve(Pens.Black, TooSmallCurve, 0, 2, 0.5f));
-            // aha, this is API dependent
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_NegativeTension()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            // documented as bigger (or equals) to 0
-            g.DrawCurve(Pens.Black, SmallCurveF, -0.9f);
-            CheckForNonEmptyBitmap(bitmap);
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_PositiveTension()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.DrawCurve(Pens.Black, SmallCurveF, 0.9f);
-            // this is not the same as -1
-            CheckForNonEmptyBitmap(bitmap);
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_ZeroSegments()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawCurve(Pens.Black, SmallCurveF, 0, 0));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_NegativeSegments()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawCurve(Pens.Black, SmallCurveF, 0, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_OffsetTooLarge()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            // starting offset 1 doesn't give 3 points to make a curve
-            Assert.Throws<ArgumentException>(() => g.DrawCurve(Pens.Black, SmallCurveF, 1, 2));
-            // and in this case 2 points aren't enough to draw something
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_Offset_0()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.DrawCurve(Pens.Black, LargeCurveF, 0, 2, 0.5f);
-            CheckForNonEmptyBitmap(bitmap);
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_Offset_1()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.DrawCurve(Pens.Black, LargeCurveF, 1, 2, 0.5f);
-            CheckForNonEmptyBitmap(bitmap);
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawCurve_Offset_2()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            // it works even with two points because we know the previous ones
-            g.DrawCurve(Pens.Black, LargeCurveF, 2, 1, 0.5f);
-            CheckForNonEmptyBitmap(bitmap);
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawRectangle_Negative()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (Pen pen = new Pen(Color.Red))
-        {
-            g.DrawRectangle(pen, 5, 5, -10, -10);
-            g.DrawRectangle(pen, 0.0f, 0.0f, 5.0f, -10.0f);
-            g.DrawRectangle(pen, new Rectangle(15, 0, -10, 5));
-            CheckForEmptyBitmap(bitmap);
-            pen.Dispose();
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void DrawRectangles_Negative()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (Pen pen = new Pen(Color.Red))
-        {
-            Rectangle[] rects = new Rectangle[2]
-            {
-                new Rectangle (5, 5, -10, -10),
-                new Rectangle (0, 0, 5, -10)
-            };
-            RectangleF[] rectf = new RectangleF[2]
-            {
-                new RectangleF (0.0f, 5.0f, -10.0f, -10.0f),
-                new RectangleF (15.0f, 0.0f, -10.0f, 5.0f)
-            };
-            g.DrawRectangles(pen, rects);
-            g.DrawRectangles(pen, rectf);
-            CheckForEmptyBitmap(bitmap);
-            pen.Dispose();
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void FillRectangle_Negative()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (SolidBrush brush = new SolidBrush(Color.Red))
-        {
-            g.FillRectangle(brush, 5, 5, -10, -10);
-            g.FillRectangle(brush, 0.0f, 0.0f, 5.0f, -10.0f);
-            g.FillRectangle(brush, new Rectangle(15, 0, -10, 5));
-            CheckForEmptyBitmap(bitmap);
-            brush.Dispose();
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_Negative()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (SolidBrush brush = new SolidBrush(Color.Red))
-        {
-            Rectangle[] rects = new Rectangle[2]
-            {
-                new Rectangle (5, 5, -10, -10),
-                new Rectangle (0, 0, 5, -10)
-            };
-
-            RectangleF[] rectf = new RectangleF[2]
-            {
-                new RectangleF (0.0f, 5.0f, -10.0f, -10.0f),
-                new RectangleF (15.0f, 0.0f, -10.0f, 5.0f)
-            };
-
-            g.FillRectangles(brush, rects);
-            g.FillRectangles(brush, rectf);
-            CheckForEmptyBitmap(bitmap);
-            brush.Dispose();
-            g.Dispose();
-            bitmap.Dispose();
-        }
-    }
-
-    private void CheckDefaultProperties(string message, Graphics g)
-    {
-        Assert.True(g.Clip.IsInfinite(g), message + ".Clip.IsInfinite");
-        AssertEquals(message + ".CompositingMode", CompositingMode.SourceOver, g.CompositingMode);
-        AssertEquals(message + ".CompositingQuality", CompositingQuality.Default, g.CompositingQuality);
-        AssertEquals(message + ".InterpolationMode", InterpolationMode.Bilinear, g.InterpolationMode);
-        AssertEquals(message + ".PageScale", 1.0f, g.PageScale);
-        AssertEquals(message + ".PageUnit", GraphicsUnit.Display, g.PageUnit);
-        AssertEquals(message + ".PixelOffsetMode", PixelOffsetMode.Default, g.PixelOffsetMode);
-        AssertEquals(message + ".SmoothingMode", SmoothingMode.None, g.SmoothingMode);
-        AssertEquals(message + ".TextContrast", 4, g.TextContrast);
-        AssertEquals(message + ".TextRenderingHint", TextRenderingHint.SystemDefault, g.TextRenderingHint);
-        Assert.True(g.Transform.IsIdentity, message + ".Transform.IsIdentity");
-    }
-
-    private void CheckCustomProperties(string message, Graphics g)
-    {
-        Assert.False(g.Clip.IsInfinite(g), message + ".Clip.IsInfinite");
-        AssertEquals(message + ".CompositingMode", CompositingMode.SourceCopy, g.CompositingMode);
-        AssertEquals(message + ".CompositingQuality", CompositingQuality.HighQuality, g.CompositingQuality);
-        AssertEquals(message + ".InterpolationMode", InterpolationMode.HighQualityBicubic, g.InterpolationMode);
-        AssertEquals(message + ".PageScale", 0.5f, g.PageScale);
-        AssertEquals(message + ".PageUnit", GraphicsUnit.Inch, g.PageUnit);
-        AssertEquals(message + ".PixelOffsetMode", PixelOffsetMode.Half, g.PixelOffsetMode);
-        AssertEquals(message + ".RenderingOrigin", new Point(-1, -1), g.RenderingOrigin);
-        AssertEquals(message + ".SmoothingMode", SmoothingMode.AntiAlias, g.SmoothingMode);
-        AssertEquals(message + ".TextContrast", 0, g.TextContrast);
-        AssertEquals(message + ".TextRenderingHint", TextRenderingHint.AntiAlias, g.TextRenderingHint);
-        Assert.False(g.Transform.IsIdentity, message + ".Transform.IsIdentity");
-    }
-
-    private void CheckMatrix(string message, Matrix m, float xx, float yx, float xy, float yy, float x0, float y0)
-    {
-        float[] elements = m.Elements;
-        AssertEquals(message + ".Matrix.xx", xx, elements[0], 2);
-        AssertEquals(message + ".Matrix.yx", yx, elements[1], 2);
-        AssertEquals(message + ".Matrix.xy", xy, elements[2], 2);
-        AssertEquals(message + ".Matrix.yy", yy, elements[3], 2);
-        AssertEquals(message + ".Matrix.x0", x0, elements[4], 2);
-        AssertEquals(message + ".Matrix.y0", y0, elements[5], 2);
-    }
-
-    [Fact]
-    public void BeginContainer()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            CheckDefaultProperties("default", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-
-            g.Clip = new Region(new Rectangle(10, 10, 10, 10));
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.HighQuality;
-            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
-            g.PageScale = 0.5f;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.RenderingOrigin = new Point(-1, -1);
-            g.RotateTransform(45);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextContrast = 0;
-            g.TextRenderingHint = TextRenderingHint.AntiAlias;
-            CheckCustomProperties("modified", g);
-            CheckMatrix("modified.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-
-            GraphicsContainer gc = g.BeginContainer();
-            // things gets reseted after calling BeginContainer
-            CheckDefaultProperties("BeginContainer", g);
-            // but not everything
-            Assert.Equal(new Point(-1, -1), g.RenderingOrigin);
-
-            g.EndContainer(gc);
-            CheckCustomProperties("EndContainer", g);
-        }
-    }
-
-    [Fact]
-    public void BeginContainer_Rect()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            CheckDefaultProperties("default", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-
-            g.Clip = new Region(new Rectangle(10, 10, 10, 10));
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.HighQuality;
-            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
-            g.PageScale = 0.5f;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.RenderingOrigin = new Point(-1, -1);
-            g.RotateTransform(45);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextContrast = 0;
-            g.TextRenderingHint = TextRenderingHint.AntiAlias;
-            CheckCustomProperties("modified", g);
-            CheckMatrix("modified.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-
-            GraphicsContainer gc = g.BeginContainer(new Rectangle(10, 20, 30, 40), new Rectangle(10, 20, 300, 400), GraphicsUnit.Millimeter);
-            // things gets reseted after calling BeginContainer
-            CheckDefaultProperties("BeginContainer", g);
-            // but not everything
-            Assert.Equal(new Point(-1, -1), g.RenderingOrigin);
-
-            g.EndContainer(gc);
-            CheckCustomProperties("EndContainer", g);
-            CheckMatrix("EndContainer.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-        }
-    }
-
-    [Fact]
-    public void BeginContainer_RectF()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            CheckDefaultProperties("default", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-
-            g.Clip = new Region(new Rectangle(10, 10, 10, 10));
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.HighQuality;
-            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
-            g.PageScale = 0.5f;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.RenderingOrigin = new Point(-1, -1);
-            g.RotateTransform(45);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextContrast = 0;
-            g.TextRenderingHint = TextRenderingHint.AntiAlias;
-            CheckCustomProperties("modified", g);
-            CheckMatrix("modified.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-
-            GraphicsContainer gc = g.BeginContainer(new RectangleF(40, 30, 20, 10), new RectangleF(10, 20, 30, 40), GraphicsUnit.Inch);
-            // things gets reseted after calling BeginContainer
-            CheckDefaultProperties("BeginContainer", g);
-            // but not everything
-            Assert.Equal(new Point(-1, -1), g.RenderingOrigin);
-
-            g.EndContainer(gc);
-            CheckCustomProperties("EndContainer", g);
-        }
-    }
-
-    private void BeginContainer_GraphicsUnit(GraphicsUnit unit)
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.BeginContainer(new RectangleF(40, 30, 20, 10), new RectangleF(10, 20, 30, 40), unit);
-        }
-    }
-
-    [Fact]
-    public void BeginContainer_GraphicsUnit_Display()
-    {
-        Assert.Throws<ArgumentException>(() => BeginContainer_GraphicsUnit(GraphicsUnit.Display));
-    }
-
-    [Fact]
-    public void BeginContainer_GraphicsUnit_Valid()
-    {
-        BeginContainer_GraphicsUnit(GraphicsUnit.Document);
-        BeginContainer_GraphicsUnit(GraphicsUnit.Inch);
-        BeginContainer_GraphicsUnit(GraphicsUnit.Millimeter);
-        BeginContainer_GraphicsUnit(GraphicsUnit.Pixel);
-        BeginContainer_GraphicsUnit(GraphicsUnit.Point);
-    }
-
-    [Fact]
-    public void BeginContainer_GraphicsUnit_World()
-    {
-        Assert.Throws<ArgumentException>(() => BeginContainer_GraphicsUnit(GraphicsUnit.World));
-    }
-
-    [Fact]
-    public void BeginContainer_GraphicsUnit_Bad()
-    {
-        Assert.Throws<ArgumentException>(() => BeginContainer_GraphicsUnit((GraphicsUnit)int.MinValue));
-    }
-
-    [Fact]
-    public void EndContainer_Null()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.EndContainer(null));
-        }
-    }
-
-    [Fact]
-    public void Save()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            CheckDefaultProperties("default", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-
-            GraphicsState gs1 = g.Save();
-            // nothing is changed after a save
-            CheckDefaultProperties("save1", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-
-            g.Clip = new Region(new Rectangle(10, 10, 10, 10));
-            g.CompositingMode = CompositingMode.SourceCopy;
-            g.CompositingQuality = CompositingQuality.HighQuality;
-            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
-            g.PageScale = 0.5f;
-            g.PageUnit = GraphicsUnit.Inch;
-            g.PixelOffsetMode = PixelOffsetMode.Half;
-            g.RenderingOrigin = new Point(-1, -1);
-            g.RotateTransform(45);
-            g.SmoothingMode = SmoothingMode.AntiAlias;
-            g.TextContrast = 0;
-            g.TextRenderingHint = TextRenderingHint.AntiAlias;
-            CheckCustomProperties("modified", g);
-            CheckMatrix("modified.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-
-            GraphicsState gs2 = g.Save();
-            CheckCustomProperties("save2", g);
-
-            g.Restore(gs2);
-            CheckCustomProperties("restored1", g);
-            CheckMatrix("restored1.Transform", g.Transform, 0.707f, 0.707f, -0.707f, 0.707f, 0, 0);
-
-            g.Restore(gs1);
-            CheckDefaultProperties("restored2", g);
-            Assert.Equal(new Point(0, 0), g.RenderingOrigin);
-        }
-    }
-
-    [Fact]
-    public void Restore_Null()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<NullReferenceException>(() => g.Restore(null));
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_BrushNull_Rectangle()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillRectangles(null, new Rectangle[1]));
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_Rectangle_Null()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillRectangles(Brushes.Red, (Rectangle[])null));
-        }
-    }
-
-    [Fact]
-    public void FillRectanglesZeroRectangle()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.FillRectangles(Brushes.Red, new Rectangle[0]));
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_BrushNull_RectangleF()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillRectangles(null, new RectangleF[1]));
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_RectangleF_Null()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillRectangles(Brushes.Red, (RectangleF[])null));
-        }
-    }
-
-    [Fact]
-    public void FillRectanglesZeroRectangleF()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.FillRectangles(Brushes.Red, new RectangleF[0]));
-        }
-    }
-
-    [Fact]
-    public void FillRectangles_NormalBehavior()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        {
-            using (Graphics g = Graphics.FromImage(bitmap))
-            {
-                g.Clear(Color.Fuchsia);
-                Rectangle rect = new Rectangle(5, 5, 10, 10);
-                g.Clip = new Region(rect);
-                g.FillRectangle(Brushes.Red, rect);
-            }
-            Assert.Equal(Color.Red.ToArgb(), bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(Color.Red.ToArgb(), bitmap.GetPixel(14, 5).ToArgb());
-            Assert.Equal(Color.Red.ToArgb(), bitmap.GetPixel(5, 14).ToArgb());
-            Assert.Equal(Color.Red.ToArgb(), bitmap.GetPixel(14, 14).ToArgb());
-
-            Assert.Equal(Color.Fuchsia.ToArgb(), bitmap.GetPixel(15, 5).ToArgb());
-            Assert.Equal(Color.Fuchsia.ToArgb(), bitmap.GetPixel(5, 15).ToArgb());
-            Assert.Equal(Color.Fuchsia.ToArgb(), bitmap.GetPixel(15, 15).ToArgb());
-        }
-    }
-
-    private Bitmap FillDrawRectangle(float width)
-    {
-        Bitmap bitmap = new Bitmap(20, 20);
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.Clear(Color.Red);
-            Rectangle rect = new Rectangle(5, 5, 10, 10);
-            g.FillRectangle(Brushes.Green, rect);
-            if (width >= 0)
-            {
-                using (Pen pen = new Pen(Color.Blue, width))
-                {
-                    g.DrawRectangle(pen, rect);
-                }
-            }
-            else
-            {
-                g.DrawRectangle(Pens.Blue, rect);
-            }
-        }
-        return bitmap;
-    }
-
-    [Fact]
-    public void FillDrawRectangle_Width_Default()
-    {
-        // default pen size
-        using (Bitmap bitmap = FillDrawRectangle(float.MinValue))
-        {
-            // NW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 6).ToArgb());
-            // N
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 6).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 6).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 14).ToArgb());
-            // W
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void FillDrawRectangle_Width_2()
-    {
-        // even pen size
-        using (Bitmap bitmap = FillDrawRectangle(2.0f))
-        {
-            // NW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 6).ToArgb());
-            // N
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 6).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 6).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 13).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 13).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 13).ToArgb());
-            // W
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void FillDrawRectangle_Width_3()
-    {
-        // odd pen size
-        using (Bitmap bitmap = FillDrawRectangle(3.0f))
-        {
-            // NW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(6, 6).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(7, 7).ToArgb());
-            // N
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 6).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 7).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 5).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 6).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 7).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(13, 13).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 13).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(6, 14).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(7, 13).ToArgb());
-            // W
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(6, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(7, 9).ToArgb());
-        }
-    }
-
-    // reverse, draw the fill over
-    private Bitmap DrawFillRectangle(float width)
-    {
-        Bitmap bitmap = new Bitmap(20, 20);
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.Clear(Color.Red);
-            Rectangle rect = new Rectangle(5, 5, 10, 10);
-            if (width >= 0)
-            {
-                using (Pen pen = new Pen(Color.Blue, width))
-                {
-                    g.DrawRectangle(pen, rect);
-                }
-            }
-            else
-            {
-                g.DrawRectangle(Pens.Blue, rect);
-            }
-            g.FillRectangle(Brushes.Green, rect);
-        }
-        return bitmap;
-    }
-
-    [Fact]
-    public void DrawFillRectangle_Width_Default()
-    {
-        // default pen size
-        using (Bitmap bitmap = DrawFillRectangle(float.MinValue))
-        {
-            // NW - no blue border
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 6).ToArgb());
-            // N - no blue border
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 6).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 5).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 6).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 14).ToArgb());
-            // W - no blue border
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void DrawFillRectangle_Width_2()
-    {
-        // even pen size
-        using (Bitmap bitmap = DrawFillRectangle(2.0f))
-        {
-            // looks like a one pixel border - but enlarged
-            // NW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            // N
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 5).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 14).ToArgb());
-            // W
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void DrawFillRectangle_Width_3()
-    {
-        // odd pen size
-        using (Bitmap bitmap = DrawFillRectangle(3.0f))
-        {
-            // NW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            // N
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 5).ToArgb());
-            // NE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 3).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 4).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 5).ToArgb());
-            // E
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 9).ToArgb());
-            // SE
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(17, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(16, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(14, 14).ToArgb());
-            // S
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(9, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(9, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(9, 14).ToArgb());
-            // SW
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 17).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 16).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 15).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(6, 14).ToArgb());
-            // W
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(3, 9).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(4, 9).ToArgb());
-            Assert.Equal(0xFF008000, (uint)bitmap.GetPixel(5, 9).ToArgb());
-        }
-    }
-
-    private Bitmap DrawLines(float width)
-    {
-        Bitmap bitmap = new Bitmap(20, 20);
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            g.Clear(Color.Red);
-            Point[] pts = new Point[3] { new Point(5, 5), new Point(15, 5), new Point(15, 15) };
-            if (width >= 0)
-            {
-                using (Pen pen = new Pen(Color.Blue, width))
-                {
-                    g.DrawLines(pen, pts);
-                }
-            }
-            else
-            {
-                g.DrawLines(Pens.Blue, pts);
-            }
-        }
-        return bitmap;
-    }
-
-    [Fact]
-    public void DrawLines_Width_Default()
-    {
-        // default pen size
-        using (Bitmap bitmap = DrawLines(float.MinValue))
-        {
-            // start
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 4).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 5).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(4, 6).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(5, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(5, 5).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(5, 6).ToArgb());
-            // middle
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(14, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(14, 5).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(14, 6).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(15, 4).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 5).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 6).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 4).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 5).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 6).ToArgb());
-            //end
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(14, 15).ToArgb());
-            Assert.Equal(0xFF0000FF, (uint)bitmap.GetPixel(15, 15).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 15).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(14, 16).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(15, 16).ToArgb());
-            Assert.Equal(0xFFFF0000, (uint)bitmap.GetPixel(16, 16).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void MeasureString_StringFont()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        {
-            using (Graphics g = Graphics.FromImage(bitmap))
-            {
-                SizeF size = g.MeasureString(null, font);
-                Assert.True(size.IsEmpty);
-                size = g.MeasureString(string.Empty, font);
-                Assert.True(size.IsEmpty);
-                g.MeasureString(string.Empty.AsSpan(), font);
-                Assert.True(size.IsEmpty);
-
-                // null font
-                size = g.MeasureString(null, null);
-                Assert.True(size.IsEmpty);
-                size = g.MeasureString(string.Empty, null);
-                Assert.True(size.IsEmpty);
-                g.MeasureString(string.Empty.AsSpan(), null);
-                Assert.True(size.IsEmpty);
-            }
-        }
-    }
-
-    [Fact]
-    public void MeasureString_StringFont_Null()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.MeasureString("a", null));
-            Assert.Throws<ArgumentNullException>(() => g.MeasureString("a".AsSpan(), null));
-        }
-    }
-
-    [Fact]
-    public void MeasureString_StringFontSizeF()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            SizeF size = g.MeasureString("a", font, SizeF.Empty);
-            Assert.False(size.IsEmpty);
-
-            size = g.MeasureString("a".AsSpan(), font, SizeF.Empty);
-            Assert.False(size.IsEmpty);
-
-            size = g.MeasureString(string.Empty, font, SizeF.Empty);
-            Assert.True(size.IsEmpty);
-
-            size = g.MeasureString(string.Empty.AsSpan(), font, SizeF.Empty);
-            Assert.True(size.IsEmpty);
-        }
-    }
-
-    private void MeasureString_StringFontInt(string s, bool useSpan)
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            SizeF size0 = useSpan ? g.MeasureString(s.AsSpan(), font, 0) : g.MeasureString(s, font, 0);
-            SizeF sizeN = useSpan ? g.MeasureString(s.AsSpan(), font, int.MinValue) : g.MeasureString(s, font, int.MinValue);
-            SizeF sizeP = useSpan ? g.MeasureString(s.AsSpan(), font, int.MaxValue) : g.MeasureString(s, font, int.MaxValue);
-            Assert.Equal(size0, sizeN);
-            Assert.Equal(size0, sizeP);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFontInt_ShortString(bool useSpan)
-    {
-        MeasureString_StringFontInt("a", useSpan);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFontInt_LongString(bool useSpan)
-    {
-        MeasureString_StringFontInt("A very long string...", useSpan);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFormat_Alignment(bool useSpan)
-    {
-        string text = "Hello Mono::";
-
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.Alignment = StringAlignment.Near;
-            SizeF near = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.Alignment = StringAlignment.Center;
-            SizeF center = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.Alignment = StringAlignment.Far;
-            SizeF far = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            Assert.Equal((double)near.Width, center.Width, 1);
-            Assert.Equal((double)near.Height, center.Height, 1);
-
-            Assert.Equal((double)center.Width, far.Width, 1);
-            Assert.Equal((double)center.Height, far.Height, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFormat_Alignment_DirectionVertical(bool useSpan)
-    {
-        string text = "Hello Mono::";
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.FormatFlags = StringFormatFlags.DirectionVertical;
-
-            string_format.Alignment = StringAlignment.Near;
-            SizeF near = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.Alignment = StringAlignment.Center;
-            SizeF center = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.Alignment = StringAlignment.Far;
-            SizeF far = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            Assert.Equal((double)near.Width, center.Width, 0);
-            Assert.Equal((double)near.Height, center.Height, 0);
-
-            Assert.Equal((double)center.Width, far.Width, 0);
-            Assert.Equal((double)center.Height, far.Height, 0);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFormat_LineAlignment(bool useSpan)
-    {
-        string text = "Hello Mono::";
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.LineAlignment = StringAlignment.Near;
-            SizeF near = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.LineAlignment = StringAlignment.Center;
-            SizeF center = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.LineAlignment = StringAlignment.Far;
-            SizeF far = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            Assert.Equal((double)near.Width, center.Width, 1);
-            Assert.Equal((double)near.Height, center.Height, 1);
-
-            Assert.Equal((double)center.Width, far.Width, 1);
-            Assert.Equal((double)center.Height, far.Height, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_StringFormat_LineAlignment_DirectionVertical(bool useSpan)
-    {
-        string text = "Hello Mono::";
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.FormatFlags = StringFormatFlags.DirectionVertical;
-
-            string_format.LineAlignment = StringAlignment.Near;
-            SizeF near = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.LineAlignment = StringAlignment.Center;
-            SizeF center = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            string_format.LineAlignment = StringAlignment.Far;
-            SizeF far = useSpan
-                ? g.MeasureString(text.AsSpan(), font, int.MaxValue, string_format)
-                : g.MeasureString(text, font, int.MaxValue, string_format);
-
-            Assert.Equal((double)near.Width, center.Width, 1);
-            Assert.Equal((double)near.Height, center.Height, 1);
-
-            Assert.Equal((double)center.Width, far.Width, 1);
-            Assert.Equal((double)center.Height, far.Height, 1);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_CharactersFitted(bool useSpan)
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string s = "aaa aa aaaa a aaa";
-            SizeF size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-
-            int chars, lines;
-            SizeF size2 = useSpan
-                ? g.MeasureString(s.AsSpan(), font, new SizeF(80, size.Height), null, out chars, out lines)
-                : g.MeasureString(s, font, new SizeF(80, size.Height), null, out chars, out lines);
-
-            // in pixels
-            Assert.True(size2.Width < size.Width);
-            Assert.Equal((double)size2.Height, size.Height);
-
-            Assert.Equal(1, lines);
-            // documentation seems to suggest chars is total length
-            Assert.True(chars < s.Length);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureString_Whitespace(bool useSpan)
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string s = string.Empty;
-            SizeF size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-            Assert.Equal(0, size.Height);
-            Assert.Equal(0, size.Width);
-
-            s += " ";
-            SizeF expected = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-            for (int i = 1; i < 10; i++)
-            {
-                s += " ";
-                size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-                Assert.Equal((double)expected.Height, size.Height, 1);
-                Assert.Equal((double)expected.Width, size.Width, 1);
-            }
-
-            s = "a";
-            expected = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-            s = " " + s;
-            size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-            float space_width = size.Width - expected.Width;
-            for (int i = 1; i < 10; i++)
-            {
-                size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-                Assert.Equal((double)expected.Height, size.Height, 1);
-                Assert.Equal((double)expected.Width + i * space_width, size.Width, 1);
-                s = " " + s;
-            }
-
-            s = "a";
-            expected = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-            for (int i = 1; i < 10; i++)
-            {
-                s = s + " ";
-                size = useSpan ? g.MeasureString(s.AsSpan(), font) : g.MeasureString(s, font);
-                Assert.Equal((double)expected.Height, size.Height, 1);
-                Assert.Equal((double)expected.Width, size.Width, 1);
-            }
-        }
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_NullOrEmptyText()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Region[] regions = g.MeasureCharacterRanges(null, font, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-
-            regions = g.MeasureCharacterRanges(string.Empty, font, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-            regions = g.MeasureCharacterRanges(string.Empty.AsSpan(), font, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-
-            // null font is ok with null or empty string
-            regions = g.MeasureCharacterRanges(null, null, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-
-            regions = g.MeasureCharacterRanges(string.Empty, null, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-            regions = g.MeasureCharacterRanges(string.Empty.AsSpan(), null, new RectangleF(), null);
-            Assert.Equal(0, regions.Length);
-        }
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_EmptyStringFormat()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            // string format without character ranges
-            Region[] regions = g.MeasureCharacterRanges("Mono", font, new RectangleF(), new StringFormat());
-            Assert.Equal(0, regions.Length);
-
-            g.MeasureCharacterRanges("Mono".AsSpan(), font, new RectangleF(), new StringFormat());
-            Assert.Equal(0, regions.Length);
-        }
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_FontNull()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.MeasureCharacterRanges("a", null, new RectangleF(), null));
-            Assert.Throws<ArgumentNullException>(() => g.MeasureCharacterRanges("a".AsSpan(), null, new RectangleF(), null));
-        }
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_TwoLines()
-    {
-        string text = "this\nis a test";
-        CharacterRange[] ranges = new CharacterRange[2];
-        ranges[0] = new CharacterRange(0, 5);
-        ranges[1] = new CharacterRange(5, 9);
-
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.FormatFlags = StringFormatFlags.NoClip;
-            string_format.SetMeasurableCharacterRanges(ranges);
-
-            SizeF size = g.MeasureString(text, font, new Point(0, 0), string_format);
-            RectangleF layout_rect = new RectangleF(0.0f, 0.0f, size.Width, size.Height);
-            Region[] regions = g.MeasureCharacterRanges(text, font, layout_rect, string_format);
-
-            Assert.Equal(2, regions.Length);
-            Assert.Equal(regions[0].GetBounds(g).Height, regions[1].GetBounds(g).Height);
-
-            regions = g.MeasureCharacterRanges(text.AsSpan(), font, layout_rect, string_format);
-
-            Assert.Equal(2, regions.Length);
-            Assert.Equal(regions[0].GetBounds(g).Height, regions[1].GetBounds(g).Height);
-        }
-    }
-
-    private void MeasureCharacterRanges(string text, int first, int length, bool useSpan)
-    {
-        CharacterRange[] ranges = new CharacterRange[1];
-        ranges[0] = new CharacterRange(first, length);
-
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.FormatFlags = StringFormatFlags.NoClip;
-            string_format.SetMeasurableCharacterRanges(ranges);
-
-            SizeF size = useSpan
-                ? g.MeasureString(text.AsSpan(), font, new Point(0, 0), string_format)
-                : g.MeasureString(text, font, new Point(0, 0), string_format);
-            RectangleF layout_rect = new RectangleF(0.0f, 0.0f, size.Width, size.Height);
-            if (useSpan)
-            {
-                g.MeasureCharacterRanges(text.AsSpan(), font, layout_rect, string_format);
-            }
-            else
-            {
-                g.MeasureCharacterRanges(text, font, layout_rect, string_format);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureCharacterRanges_FirstTooFar(bool useSpan)
-    {
-        string text = "this\nis a test";
-        Assert.Throws<ArgumentException>(() => MeasureCharacterRanges(text, text.Length, 1, useSpan));
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureCharacterRanges_LengthTooLong(bool useSpan)
-    {
-        string text = "this\nis a test";
-        Assert.Throws<ArgumentException>(() => MeasureCharacterRanges(text, 0, text.Length + 1, useSpan));
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_Prefix()
-    {
-        string text = "Hello &Mono::";
-        CharacterRange[] ranges = new CharacterRange[1];
-        ranges[0] = new CharacterRange(5, 4);
-
-        using (StringFormat string_format = new StringFormat())
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            string_format.SetMeasurableCharacterRanges(ranges);
-
-            SizeF size = g.MeasureString(text, font, new Point(0, 0), string_format);
-            RectangleF layout_rect = new RectangleF(0.0f, 0.0f, size.Width, size.Height);
-
-            // here & is part of the measure and visible
-            string_format.HotkeyPrefix = HotkeyPrefix.None;
-            Region[] regions = g.MeasureCharacterRanges(text, font, layout_rect, string_format);
-            RectangleF bounds_none = regions[0].GetBounds(g);
-
-            // here & is part of the measure (range) but visible as an underline
-            string_format.HotkeyPrefix = HotkeyPrefix.Show;
-            regions = g.MeasureCharacterRanges(text, font, layout_rect, string_format);
-            RectangleF bounds_show = regions[0].GetBounds(g);
-            Assert.True(bounds_show.Width < bounds_none.Width);
-
-            regions = g.MeasureCharacterRanges(text.AsSpan(), font, layout_rect, string_format);
-            bounds_show = regions[0].GetBounds(g);
-            Assert.True(bounds_show.Width < bounds_none.Width);
-
-            // here & is part of the measure (range) but invisible
-            string_format.HotkeyPrefix = HotkeyPrefix.Hide;
-            regions = g.MeasureCharacterRanges(text, font, layout_rect, string_format);
-            RectangleF bounds_hide = regions[0].GetBounds(g);
-            Assert.Equal((double)bounds_hide.Width, bounds_show.Width);
-
-            g.MeasureCharacterRanges(text.AsSpan(), font, layout_rect, string_format);
-            bounds_hide = regions[0].GetBounds(g);
-            Assert.Equal((double)bounds_hide.Width, bounds_show.Width);
-        }
-    }
-
-    [Fact]
-    public void MeasureCharacterRanges_NullStringFormat()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        {
-            Assert.Throws<ArgumentException>(() => g.MeasureCharacterRanges("Mono", font, new RectangleF(), null));
-            Assert.Throws<ArgumentException>(() => g.MeasureCharacterRanges("Mono".AsSpan(), font, new RectangleF(), null));
-        }
-    }
-
-    static CharacterRange[] ranges = new CharacterRange[] {
-                new CharacterRange (0, 1),
-                new CharacterRange (1, 1),
-                new CharacterRange (2, 1)
-            };
-
-    Region[] Measure_Helper(Graphics gfx, RectangleF rect, bool useSpan)
-    {
-        using (StringFormat format = StringFormat.GenericTypographic)
-        {
-            format.SetMeasurableCharacterRanges(ranges);
-
-            using (Font font = new Font(FontFamily.GenericSerif, 11.0f))
-            {
-                return useSpan
-                    ? gfx.MeasureCharacterRanges("abc".AsSpan(), font, rect, format)
-                    : gfx.MeasureCharacterRanges("abc", font, rect, format);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Measure(bool useSpan)
-    {
-        using (Graphics gfx = Graphics.FromImage(new Bitmap(1, 1)))
-        {
-            Region[] zero = Measure_Helper(gfx, new RectangleF(0, 0, 0, 0), useSpan);
-            Assert.Equal(3, zero.Length);
-
-            Region[] small = Measure_Helper(gfx, new RectangleF(0, 0, 100, 100), useSpan);
-            Assert.Equal(3, small.Length);
-            for (int i = 0; i < 3; i++)
-            {
-                RectangleF zb = zero[i].GetBounds(gfx);
-                RectangleF sb = small[i].GetBounds(gfx);
-                Assert.Equal(sb.X, zb.X);
-                Assert.Equal(sb.Y, zb.Y);
-                Assert.Equal((double)sb.Width, zb.Width);
-                Assert.Equal((double)sb.Height, zb.Height);
-            }
-
-            Region[] max = Measure_Helper(gfx, new RectangleF(0, 0, float.MaxValue, float.MaxValue), useSpan);
-            Assert.Equal(3, max.Length);
-            for (int i = 0; i < 3; i++)
-            {
-                RectangleF zb = zero[i].GetBounds(gfx);
-                RectangleF mb = max[i].GetBounds(gfx);
-                Assert.Equal(mb.X, zb.X);
-                Assert.Equal(mb.Y, zb.Y);
-                Assert.Equal((double)mb.Width, zb.Width);
-                Assert.Equal((double)mb.Height, zb.Height);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MeasureLimits(bool useSpan)
-    {
-        using (Graphics gfx = Graphics.FromImage(new Bitmap(1, 1)))
-        {
-            Region[] min = Measure_Helper(gfx, new RectangleF(0, 0, float.MinValue, float.MinValue), useSpan);
-            Assert.Equal(3, min.Length);
-            for (int i = 0; i < 3; i++)
-            {
-                RectangleF mb = min[i].GetBounds(gfx);
-                Assert.Equal(-4194304.0f, mb.X);
-                Assert.Equal(-4194304.0f, mb.Y);
-                Assert.Equal(8388608.0f, mb.Width);
-                Assert.Equal(8388608.0f, mb.Height);
-            }
-
-            Region[] neg = Measure_Helper(gfx, new RectangleF(0, 0, -20, -20), useSpan);
-            Assert.Equal(3, neg.Length);
-            for (int i = 0; i < 3; i++)
-            {
-                RectangleF mb = neg[i].GetBounds(gfx);
-                Assert.Equal(-4194304.0f, mb.X);
-                Assert.Equal(-4194304.0f, mb.Y);
-                Assert.Equal(8388608.0f, mb.Width);
-                Assert.Equal(8388608.0f, mb.Height);
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawString_EndlessLoop()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (StringFormat fmt = new StringFormat())
-        {
-            Rectangle rect = Rectangle.Empty;
-            rect.Location = new Point(10, 10);
-            rect.Size = new Size(1, 20);
-            fmt.Alignment = StringAlignment.Center;
-            fmt.LineAlignment = StringAlignment.Center;
-            fmt.FormatFlags = StringFormatFlags.NoWrap;
-            fmt.Trimming = StringTrimming.EllipsisWord;
-            g.DrawString("Test String", font, Brushes.Black, rect, fmt);
-            g.DrawString("Test String".AsSpan(), font, Brushes.Black, rect, fmt);
-        }
-    }
-
-    [Fact]
-    public void DrawString_EndlessLoop_Wrapping()
-    {
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (StringFormat fmt = new StringFormat())
-        {
-            Rectangle rect = Rectangle.Empty;
-            rect.Location = new Point(10, 10);
-            rect.Size = new Size(1, 20);
-            fmt.Alignment = StringAlignment.Center;
-            fmt.LineAlignment = StringAlignment.Center;
-            fmt.Trimming = StringTrimming.EllipsisWord;
-            g.DrawString("Test String", font, Brushes.Black, rect, fmt);
-            g.DrawString("Test String".AsSpan(), font, Brushes.Black, rect, fmt);
-        }
-    }
-
-    [Fact]
-    public void MeasureString_Wrapping_Dots()
-    {
-        string text = "this is really long text........................................... with a lot o periods.";
-        using (Bitmap bitmap = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bitmap))
-        using (StringFormat format = new StringFormat())
-        {
-            format.Alignment = StringAlignment.Center;
-            SizeF sz = g.MeasureString(text, font, 80, format);
-            Assert.True(sz.Width <= 80);
-            Assert.True(sz.Height > font.Height * 2);
-
-            sz = g.MeasureString(text.AsSpan(), font, 80, format);
-            Assert.True(sz.Width <= 80);
-            Assert.True(sz.Height > font.Height * 2);
-        }
-    }
-
-    [Fact]
-    public void GetReleaseHdcInternal()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            IntPtr hdc1 = g.GetHdc();
-            g.ReleaseHdcInternal(hdc1);
-            IntPtr hdc2 = g.GetHdc();
-            g.ReleaseHdcInternal(hdc2);
-            Assert.Equal(hdc1, hdc2);
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdcInternal_IntPtrZero()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            Assert.Throws<ArgumentException>(() => g.ReleaseHdcInternal(IntPtr.Zero));
-        }
-    }
-
-    [Fact]
-    public void ReleaseHdcInternal_TwoTimes()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            IntPtr hdc = g.GetHdc();
-            g.ReleaseHdcInternal(hdc);
-            Assert.Throws<ArgumentException>(() => g.ReleaseHdcInternal(hdc));
-        }
-    }
-    [Fact]
-    public void TestReleaseHdc()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            IntPtr hdc1 = g.GetHdc();
-            g.ReleaseHdc();
-            IntPtr hdc2 = g.GetHdc();
-            g.ReleaseHdc();
-            Assert.Equal(hdc1, hdc2);
-        }
-    }
-
-    [Fact]
-    public void TestReleaseHdcException()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            Assert.Throws<ArgumentException>(() => g.ReleaseHdc());
-        }
-    }
-
-    [Fact]
-    public void TestReleaseHdcException2()
-    {
-        using (Bitmap b = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(b))
-        {
-            g.GetHdc();
-            g.ReleaseHdc();
-            Assert.Throws<ArgumentException>(() => g.ReleaseHdc());
-        }
-    }
-    [ConditionalFact]
-    public void VisibleClipBound()
-    {
-        if (PlatformDetection.IsArmOrArm64Process)
-        {
-            // [ActiveIssue("https://github.com/dotnet/winforms/issues/8817")]
-            throw new SkipTestException("Precision on float numbers");
-        }
-
-        // see #78958
-        using (Bitmap bmp = new Bitmap(100, 100))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            RectangleF noclip = g.VisibleClipBounds;
-            Assert.Equal(0, noclip.X);
-            Assert.Equal(0, noclip.Y);
-            Assert.Equal(100, noclip.Width);
-            Assert.Equal(100, noclip.Height);
-
-            // note: libgdiplus regions are precise to multiple of multiple of 8
-            g.Clip = new Region(new RectangleF(0, 0, 32, 32));
-            RectangleF clip = g.VisibleClipBounds;
-            Assert.Equal(0, clip.X);
-            Assert.Equal(0, clip.Y);
-            Assert.Equal(32.0, clip.Width, 4);
-            Assert.Equal(32.0, clip.Height, 4);
-
-            g.RotateTransform(90);
-            RectangleF rotclip = g.VisibleClipBounds;
-            Assert.Equal(0, rotclip.X);
-            Assert.Equal(-32.0, rotclip.Y, 4);
-            Assert.Equal(32.0, rotclip.Width, 4);
-            Assert.Equal(32.0, rotclip.Height, 4);
-        }
-    }
-
-    [ConditionalFact]
-    public void VisibleClipBound_BigClip()
-    {
-        if (PlatformDetection.IsArmOrArm64Process)
-        {
-            //ActiveIssue: 35744
-            throw new SkipTestException("Precision on float numbers");
-        }
-
-        using (Bitmap bmp = new Bitmap(100, 100))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            RectangleF noclip = g.VisibleClipBounds;
-            Assert.Equal(0, noclip.X);
-            Assert.Equal(0, noclip.Y);
-            Assert.Equal(100, noclip.Width);
-            Assert.Equal(100, noclip.Height);
-
-            // clip is larger than bitmap
-            g.Clip = new Region(new RectangleF(0, 0, 200, 200));
-            RectangleF clipbound = g.ClipBounds;
-            Assert.Equal(0, clipbound.X);
-            Assert.Equal(0, clipbound.Y);
-            Assert.Equal(200, clipbound.Width);
-            Assert.Equal(200, clipbound.Height);
-
-            RectangleF clip = g.VisibleClipBounds;
-            Assert.Equal(0, clip.X);
-            Assert.Equal(0, clip.Y);
-            Assert.Equal(100, clip.Width);
-            Assert.Equal(100, clip.Height);
-
-            g.RotateTransform(90);
-            RectangleF rotclipbound = g.ClipBounds;
-            Assert.Equal(0, rotclipbound.X);
-            Assert.Equal(-200.0, rotclipbound.Y, 4);
-            Assert.Equal(200.0, rotclipbound.Width, 4);
-            Assert.Equal(200.0, rotclipbound.Height, 4);
-
-            RectangleF rotclip = g.VisibleClipBounds;
-            Assert.Equal(0, rotclip.X);
-            Assert.Equal(-100.0, rotclip.Y, 4);
-            Assert.Equal(100.0, rotclip.Width, 4);
-            Assert.Equal(100.0, rotclip.Height, 4);
-        }
-    }
-
-    [ConditionalFact]
-    public void Rotate()
-    {
-        if (PlatformDetection.IsArmOrArm64Process)
-        {
-            //ActiveIssue: 35744
-            throw new SkipTestException("Precision on float numbers");
-        }
-
-        using (Bitmap bmp = new Bitmap(100, 50))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            RectangleF vcb = g.VisibleClipBounds;
-            Assert.Equal(0, vcb.X);
-            Assert.Equal(0, vcb.Y);
-            Assert.Equal(100.0, vcb.Width, 4);
-            Assert.Equal(50.0, vcb.Height, 4);
-
-            g.RotateTransform(90);
-            RectangleF rvcb = g.VisibleClipBounds;
-            Assert.Equal(0, rvcb.X);
-            Assert.Equal(-100.0, rvcb.Y, 4);
-            Assert.Equal(50.0, rvcb.Width, 4);
-            Assert.Equal(100.0, rvcb.Height, 4);
-        }
-    }
-
-    [Fact]
-    public void Scale()
-    {
-        using (Bitmap bmp = new Bitmap(100, 50))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            RectangleF vcb = g.VisibleClipBounds;
-            Assert.Equal(0, vcb.X);
-            Assert.Equal(0, vcb.Y);
-            Assert.Equal(100, vcb.Width);
-            Assert.Equal(50, vcb.Height);
-
-            g.ScaleTransform(2, 0.5f);
-            RectangleF svcb = g.VisibleClipBounds;
-            Assert.Equal(0, svcb.X);
-            Assert.Equal(0, svcb.Y);
-            Assert.Equal(50, svcb.Width);
-            Assert.Equal(100, svcb.Height);
-        }
-    }
-
-    [Fact]
-    public void Translate()
-    {
-        using (Bitmap bmp = new Bitmap(100, 50))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            RectangleF vcb = g.VisibleClipBounds;
-            Assert.Equal(0, vcb.X);
-            Assert.Equal(0, vcb.Y);
-            Assert.Equal(100, vcb.Width);
-            Assert.Equal(50, vcb.Height);
-
-            g.TranslateTransform(-25, 25);
-            RectangleF tvcb = g.VisibleClipBounds;
-            Assert.Equal(25, tvcb.X);
-            Assert.Equal(-25, tvcb.Y);
-            Assert.Equal(100, tvcb.Width);
-            Assert.Equal(50, tvcb.Height);
-        }
-    }
-
-    [Fact]
-    public void DrawIcon_NullRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawIcon(null, new Rectangle(0, 0, 32, 32)));
-        }
-    }
-
-    [Fact]
-    public void DrawIcon_IconRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawIcon(SystemIcons.Application, new Rectangle(0, 0, 40, 20));
-            // Rectangle is empty when X, Y, Width and Height == 0
-            // (yep X and Y too, RectangleF only checks for Width and Height)
-            g.DrawIcon(SystemIcons.Asterisk, new Rectangle(0, 0, 0, 0));
-            // so this one is half-empty ;-)
-            g.DrawIcon(SystemIcons.Error, new Rectangle(20, 40, 0, 0));
-            // negative width or height isn't empty (for Rectangle)
-            g.DrawIconUnstretched(SystemIcons.WinLogo, new Rectangle(10, 20, -1, 0));
-            g.DrawIconUnstretched(SystemIcons.WinLogo, new Rectangle(20, 10, 0, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawIcon_NullIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawIcon(null, 4, 2));
-        }
-    }
-
-    [Fact]
-    public void DrawIcon_IconIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawIcon(SystemIcons.Exclamation, 4, 2);
-            g.DrawIcon(SystemIcons.Hand, 0, 0);
-        }
-    }
-
-    [Fact]
-    public void DrawIconUnstretched_NullRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawIconUnstretched(null, new Rectangle(0, 0, 40, 20)));
-        }
-    }
-
-    [Fact]
-    public void DrawIconUnstretched_IconRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawIconUnstretched(SystemIcons.Information, new Rectangle(0, 0, 40, 20));
-            // Rectangle is empty when X, Y, Width and Height == 0
-            // (yep X and Y too, RectangleF only checks for Width and Height)
-            g.DrawIconUnstretched(SystemIcons.Question, new Rectangle(0, 0, 0, 0));
-            // so this one is half-empty ;-)
-            g.DrawIconUnstretched(SystemIcons.Warning, new Rectangle(20, 40, 0, 0));
-            // negative width or height isn't empty (for Rectangle)
-            g.DrawIconUnstretched(SystemIcons.WinLogo, new Rectangle(10, 20, -1, 0));
-            g.DrawIconUnstretched(SystemIcons.WinLogo, new Rectangle(20, 10, 0, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullRectangleF()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new RectangleF(0, 0, 0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageRectangleF()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, new RectangleF(0, 0, 0, 0));
-            g.DrawImage(bmp, new RectangleF(20, 40, 0, 0));
-            g.DrawImage(bmp, new RectangleF(10, 20, -1, 0));
-            g.DrawImage(bmp, new RectangleF(20, 10, 0, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullPointF()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new PointF(0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, new PointF(0, 0));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullPointFArray()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointFArrayNull()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                Assert.Throws<ArgumentNullException>(() => g.DrawImage(bmp, (PointF[])null));
-            }
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointFArrayEmpty()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawImage(bmp, new PointF[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointFArray()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, new PointF[] {
-                    new PointF (0, 0), new PointF (1, 1), new PointF (2, 2) });
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new Rectangle(0, 0, 0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            // Rectangle is empty when X, Y, Width and Height == 0
-            // (yep X and Y too, RectangleF only checks for Width and Height)
-            g.DrawImage(bmp, new Rectangle(0, 0, 0, 0));
-            // so this one is half-empty ;-)
-            g.DrawImage(bmp, new Rectangle(20, 40, 0, 0));
-            // negative width or height isn't empty (for Rectangle)
-            g.DrawImage(bmp, new Rectangle(10, 20, -1, 0));
-            g.DrawImage(bmp, new Rectangle(20, 10, 0, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullPoint()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new Point(0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, new Point(0, 0));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullPointArray()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new Point[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointArrayNull()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(bmp, (Point[])null));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointArrayEmpty()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentException>(() => g.DrawImage(bmp, new Point[0]));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointArray()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, new Point[] {
-                    new Point (0, 0), new Point (1, 1), new Point (2, 2) });
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, int.MaxValue, int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageIntInt_Overflow()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<OverflowException>(() => g.DrawImage(bmp, int.MaxValue, int.MinValue));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, -40, -40);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullFloat()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, float.MaxValue, float.MinValue));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageFloatFloat_Overflow()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<OverflowException>(() => g.DrawImage(bmp, float.MaxValue, float.MinValue));
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageFloatFloat()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, -40.0f, -40.0f);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_NullRectangleRectangleGraphicsUnit()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, new Rectangle(), new Rectangle(), GraphicsUnit.Display));
-        }
-    }
-
-    private void DrawImage_ImageRectangleRectangleGraphicsUnit(GraphicsUnit unit)
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Rectangle r = new Rectangle(0, 0, 40, 40);
-            g.DrawImage(bmp, r, r, unit);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageRectangleRectangleGraphicsUnit_Display()
-    {
-        Assert.Throws<ArgumentException>(() => DrawImage_ImageRectangleRectangleGraphicsUnit(GraphicsUnit.Display));
-    }
-
-    [Fact]
-    public void DrawImage_ImageRectangleRectangleGraphicsUnit_Pixel()
-    {
-        // this unit works
-        DrawImage_ImageRectangleRectangleGraphicsUnit(GraphicsUnit.Pixel);
-    }
-
-    [Fact]
-    public void DrawImage_ImageRectangleRectangleGraphicsUnit_World()
-    {
-        Assert.Throws<ArgumentException>(() => DrawImage_ImageRectangleRectangleGraphicsUnit(GraphicsUnit.World));
-    }
-
-    [Fact]
-    public void DrawImage_NullPointRectangleGraphicsUnit()
-    {
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        Point[] pts = new Point[3] { new Point(1, 1), new Point(2, 2), new Point(3, 3) };
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, pts, r, GraphicsUnit.Pixel));
-        }
-    }
-
-    private void DrawImage_ImagePointRectangleGraphicsUnit(Point[] pts)
-    {
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, pts, r, GraphicsUnit.Pixel);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageNullRectangleGraphicsUnit()
-    {
-        Assert.Throws<ArgumentNullException>(() => DrawImage_ImagePointRectangleGraphicsUnit(null));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint0RectangleGraphicsUnit()
-    {
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointRectangleGraphicsUnit(new Point[0]));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint1RectangleGraphicsUnit()
-    {
-        Point p = new Point(1, 1);
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointRectangleGraphicsUnit(new Point[1] { p }));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint2RectangleGraphicsUnit()
-    {
-        Point p = new Point(1, 1);
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointRectangleGraphicsUnit(new Point[2] { p, p }));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint3RectangleGraphicsUnit()
-    {
-        Point p = new Point(1, 1);
-        DrawImage_ImagePointRectangleGraphicsUnit(new Point[3] { p, p, p });
-    }
-
-    [Fact]
-    public void DrawImage_ImagePoint4RectangleGraphicsUnit()
-    {
-        Point p = new Point(1, 1);
-        Assert.Throws<NotImplementedException>(() => DrawImage_ImagePointRectangleGraphicsUnit(new Point[4] { p, p, p, p }));
-    }
-
-    [Fact]
-    public void DrawImage_NullPointFRectangleGraphicsUnit()
-    {
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        PointF[] pts = new PointF[3] { new PointF(1, 1), new PointF(2, 2), new PointF(3, 3) };
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImage(null, pts, r, GraphicsUnit.Pixel));
-        }
-    }
-
-    private void DrawImage_ImagePointFRectangleGraphicsUnit(PointF[] pts)
-    {
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, pts, r, GraphicsUnit.Pixel);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImageNullFRectangleGraphicsUnit()
-    {
-        Assert.Throws<ArgumentNullException>(() => DrawImage_ImagePointFRectangleGraphicsUnit(null));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF0RectangleGraphicsUnit()
-    {
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointFRectangleGraphicsUnit(new PointF[0]));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF1RectangleGraphicsUnit()
-    {
-        PointF p = new PointF(1, 1);
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointFRectangleGraphicsUnit(new PointF[1] { p }));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF2RectangleGraphicsUnit()
-    {
-        PointF p = new PointF(1, 1);
-        Assert.Throws<ArgumentException>(() => DrawImage_ImagePointFRectangleGraphicsUnit(new PointF[2] { p, p }));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF3RectangleGraphicsUnit()
-    {
-        PointF p = new PointF(1, 1);
-        DrawImage_ImagePointFRectangleGraphicsUnit(new PointF[3] { p, p, p });
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointF4RectangleGraphicsUnit()
-    {
-        PointF p = new PointF(1, 1);
-        Assert.Throws<NotImplementedException>(() => DrawImage_ImagePointFRectangleGraphicsUnit(new PointF[4] { p, p, p, p }));
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointRectangleGraphicsUnitNull()
-    {
-        Point p = new Point(1, 1);
-        Point[] pts = new Point[3] { p, p, p };
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImage(bmp, pts, r, GraphicsUnit.Pixel, null);
-        }
-    }
-
-    [Fact]
-    public void DrawImage_ImagePointRectangleGraphicsUnitAttributes()
-    {
-        Point p = new Point(1, 1);
-        Point[] pts = new Point[3] { p, p, p };
-        Rectangle r = new Rectangle(1, 2, 3, 4);
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (ImageAttributes ia = new ImageAttributes())
-        {
-            g.DrawImage(bmp, pts, r, GraphicsUnit.Pixel, ia);
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_NullPoint()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImageUnscaled(null, new Point(0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_ImagePoint()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImageUnscaled(bmp, new Point(0, 0));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_NullRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImageUnscaled(null, new Rectangle(0, 0, -1, -1)));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_ImageRectangle()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImageUnscaled(bmp, new Rectangle(0, 0, -1, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_NullIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImageUnscaled(null, 0, 0));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_ImageIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImageUnscaled(bmp, 0, 0);
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_NullIntIntIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImageUnscaled(null, 0, 0, -1, -1));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaled_ImageIntIntIntInt()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            g.DrawImageUnscaled(bmp, 0, 0, -1, -1);
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaledAndClipped_Null()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawImageUnscaledAndClipped(null, new Rectangle(0, 0, 0, 0)));
-        }
-    }
-
-    [Fact]
-    public void DrawImageUnscaledAndClipped()
-    {
-        using (Bitmap bmp = new Bitmap(40, 40))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            // Rectangle is empty when X, Y, Width and Height == 0
-            // (yep X and Y too, RectangleF only checks for Width and Height)
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(0, 0, 0, 0));
-            // so this one is half-empty ;-)
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(20, 40, 0, 0));
-            // negative width or height isn't empty (for Rectangle)
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(10, 20, -1, 0));
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(20, 10, 0, -1));
-            // smaller
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(0, 0, 10, 20));
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(0, 0, 40, 10));
-            g.DrawImageUnscaledAndClipped(bmp, new Rectangle(0, 0, 80, 20));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_Pen_Null()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawPath(null, path));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_Path_Null()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.DrawPath(Pens.Black, null));
-        }
-    }
-
-    [Fact]
-    public void DrawPath_Arcs()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            int d = 5;
-            Rectangle baserect = new Rectangle(0, 0, 19, 19);
-            Rectangle arcrect = new Rectangle(baserect.Location, new Size(d, d));
-
-            path.AddArc(arcrect, 180, 90);
-            arcrect.X = baserect.Right - d;
-            path.AddArc(arcrect, 270, 90);
-            arcrect.Y = baserect.Bottom - d;
-            path.AddArc(arcrect, 0, 90);
-            arcrect.X = baserect.Left;
-            path.AddArc(arcrect, 90, 90);
-            path.CloseFigure();
-            g.Clear(Color.White);
-            g.DrawPath(Pens.SteelBlue, path);
-
-            Assert.Equal(-12156236, bmp.GetPixel(0, 9).ToArgb());
-            Assert.Equal(-1, bmp.GetPixel(1, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void FillPath_Brush_Null()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillPath(null, path));
-        }
-    }
-
-    [Fact]
-    public void FillPath_Path_Null()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Assert.Throws<ArgumentNullException>(() => g.FillPath(Brushes.Black, null));
-        }
-    }
-
-    [Fact]
-    public void FillPath_Arcs()
-    {
-        using (Bitmap bmp = new Bitmap(20, 20))
-        using (Graphics g = Graphics.FromImage(bmp))
-        using (GraphicsPath path = new GraphicsPath())
-        {
-            int d = 5;
-            Rectangle baserect = new Rectangle(0, 0, 19, 19);
-            Rectangle arcrect = new Rectangle(baserect.Location, new Size(d, d));
-
-            path.AddArc(arcrect, 180, 90);
-            arcrect.X = baserect.Right - d;
-            path.AddArc(arcrect, 270, 90);
-            arcrect.Y = baserect.Bottom - d;
-            path.AddArc(arcrect, 0, 90);
-            arcrect.X = baserect.Left;
-            path.AddArc(arcrect, 90, 90);
-            path.CloseFigure();
-            g.Clear(Color.White);
-            g.FillPath(Brushes.SteelBlue, path);
-
-            Assert.Equal(-12156236, bmp.GetPixel(0, 9).ToArgb());
-            Assert.Equal(-12156236, bmp.GetPixel(1, 9).ToArgb());
-        }
-    }
-
-    [Fact]
-    public void TransformPoints()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            Point[] pts = new Point[5];
-            PointF[] ptf = new PointF[5];
-            for (int i = 0; i < 5; i++)
-            {
-                pts[i] = new Point(i, i);
-                ptf[i] = new PointF(i, i);
-            }
-
-            g.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Device, pts);
-            g.TransformPoints(CoordinateSpace.Page, CoordinateSpace.Device, ptf);
-
-            for (int i = 0; i < 5; i++)
-            {
-                Assert.Equal(i, pts[i].X);
-                Assert.Equal(i, pts[i].Y);
-                Assert.Equal(i, ptf[i].X);
-                Assert.Equal(i, ptf[i].Y);
-            }
-        }
-    }
-
-    [Fact]
-    public void Dpi()
-    {
-        float x, y;
-        using (Bitmap bmp = new Bitmap(10, 10))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                x = g.DpiX - 10;
-                y = g.DpiY + 10;
-            }
-            bmp.SetResolution(x, y);
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                Assert.Equal(x, g.DpiX);
-                Assert.Equal(y, g.DpiY);
-            }
-        }
-    }
-
-    [Fact]
-    public void GetReleaseHdc()
-    {
-        using (Bitmap b = new Bitmap(100, 100))
-        {
-            using (Graphics g = Graphics.FromImage(b))
-            {
-                IntPtr hdc1 = g.GetHdc();
-                g.ReleaseHdc(hdc1);
-                IntPtr hdc2 = g.GetHdc();
-                g.ReleaseHdc(hdc2);
-                Assert.Equal(hdc1, hdc2);
-            }
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/mono/System.Imaging/MetafileTest.cs b/src/System.Drawing.Common/tests/mono/System.Imaging/MetafileTest.cs
deleted file mode 100644
index fd34ddd01dc..00000000000
--- a/src/System.Drawing.Common/tests/mono/System.Imaging/MetafileTest.cs
+++ /dev/null
@@ -1,461 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-//
-// Metafile class unit tests
-//
-// Authors:
-//  Sebastien Pouliot  <sebastien@ximian.com>
-//
-// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-
-namespace MonoTests.System.Drawing.Imaging;
-
-public class MetafileTest
-{
-    public const string Bitmap = "non-inverted.bmp";
-    public const string WmfPlaceable = "telescope_01.wmf";
-    public const string Emf = "milkmateya01.emf";
-
-    [Fact]
-    public void Metafile_String()
-    {
-        string filename = Helpers.GetTestBitmapPath(WmfPlaceable);
-        using (Metafile mf = new Metafile(filename))
-        using (Metafile clone = (Metafile)mf.Clone())
-        {
-        }
-    }
-
-    private static void Check_MetaHeader_WmfPlaceable(MetaHeader mh)
-    {
-        Assert.Equal(9, mh.HeaderSize);
-        Assert.Equal(98, mh.MaxRecord);
-        Assert.Equal(3, mh.NoObjects);
-        Assert.Equal(0, mh.NoParameters);
-        Assert.Equal(1737, mh.Size);
-        Assert.Equal(1, mh.Type);
-        Assert.Equal(0x300, mh.Version);
-    }
-
-    private static void Check_MetafileHeader_WmfPlaceable(MetafileHeader header)
-    {
-        Assert.Equal(MetafileType.WmfPlaceable, header.Type);
-        Assert.Equal(0x300, header.Version);
-        // filesize - 22, which happens to be the size (22) of a PLACEABLEMETAHEADER struct
-        Assert.Equal(3474, header.MetafileSize);
-
-        Assert.Equal(-30, header.Bounds.X);
-        Assert.Equal(-40, header.Bounds.Y);
-        Assert.Equal(3096, header.Bounds.Width);
-        Assert.Equal(4127, header.Bounds.Height);
-        Assert.Equal(606, header.DpiX);
-        Assert.Equal(606, header.DpiY);
-        Assert.Equal(0, header.EmfPlusHeaderSize);
-        Assert.Equal(0, header.LogicalDpiX);
-        Assert.Equal(0, header.LogicalDpiY);
-
-        Assert.NotNull(header.WmfHeader);
-        Check_MetaHeader_WmfPlaceable(header.WmfHeader);
-
-        Assert.False(header.IsDisplay());
-        Assert.False(header.IsEmf());
-        Assert.False(header.IsEmfOrEmfPlus());
-        Assert.False(header.IsEmfPlus());
-        Assert.False(header.IsEmfPlusDual());
-        Assert.False(header.IsEmfPlusOnly());
-        Assert.True(header.IsWmf());
-        Assert.True(header.IsWmfPlaceable());
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromFile_WmfPlaceable()
-    {
-        using (Metafile mf = new Metafile(Helpers.GetTestBitmapPath(WmfPlaceable)))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_WmfPlaceable(header1);
-
-            MetaHeader mh1 = header1.WmfHeader;
-            Check_MetaHeader_WmfPlaceable(mh1);
-
-            MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
-            Assert.NotSame(mh1, mh2);
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromFileStream_WmfPlaceable()
-    {
-        using (FileStream fs = File.OpenRead(Helpers.GetTestBitmapPath(WmfPlaceable)))
-        using (Metafile mf = new Metafile(fs))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_WmfPlaceable(header1);
-
-            MetaHeader mh1 = header1.WmfHeader;
-            Check_MetaHeader_WmfPlaceable(mh1);
-
-            MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
-            Assert.NotSame(mh1, mh2);
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromMemoryStream_WmfPlaceable()
-    {
-        string filename = Helpers.GetTestBitmapPath(WmfPlaceable);
-        using (MemoryStream ms = new MemoryStream(File.ReadAllBytes(filename)))
-        using (Metafile mf = new Metafile(ms))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_WmfPlaceable(header1);
-
-            MetaHeader mh1 = header1.WmfHeader;
-            Check_MetaHeader_WmfPlaceable(mh1);
-
-            MetaHeader mh2 = mf.GetMetafileHeader().WmfHeader;
-            Assert.NotSame(mh1, mh2);
-        }
-    }
-
-    private static void Check_MetafileHeader_Emf(MetafileHeader header)
-    {
-        Assert.Equal(MetafileType.Emf, header.Type);
-        Assert.Equal(65536, header.Version);
-        // exactly the filesize
-        Assert.Equal(20456, header.MetafileSize);
-
-        Assert.Equal(0, header.Bounds.X);
-        Assert.Equal(0, header.Bounds.Y);
-
-        Assert.Throws<ArgumentException>(() => header.WmfHeader);
-
-        Assert.False(header.IsDisplay());
-        Assert.True(header.IsEmf());
-        Assert.True(header.IsEmfOrEmfPlus());
-        Assert.False(header.IsEmfPlus());
-        Assert.False(header.IsEmfPlusDual());
-        Assert.False(header.IsEmfPlusOnly());
-        Assert.False(header.IsWmf());
-        Assert.False(header.IsWmfPlaceable());
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromFile_Emf()
-    {
-        using (Metafile mf = new Metafile(Helpers.GetTestBitmapPath(Emf)))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_Emf(header1);
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromFileStream_Emf()
-    {
-        using (FileStream fs = File.OpenRead(Helpers.GetTestBitmapPath(Emf)))
-        using (Metafile mf = new Metafile(fs))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_Emf(header1);
-        }
-    }
-
-    [Fact]
-    public void GetMetafileHeader_FromMemoryStream_Emf()
-    {
-        string filename = Helpers.GetTestBitmapPath(Emf);
-        using (MemoryStream ms = new MemoryStream(File.ReadAllBytes(filename)))
-        using (Metafile mf = new Metafile(ms))
-        {
-            MetafileHeader header1 = mf.GetMetafileHeader();
-            Check_MetafileHeader_Emf(header1);
-        }
-    }
-}
-
-public class MetafileFulltrustTest
-{
-    private void CheckEmptyHeader(Metafile mf, EmfType type)
-    {
-        MetafileHeader mh = mf.GetMetafileHeader();
-        Assert.Equal(0, mh.Bounds.X);
-        Assert.Equal(0, mh.Bounds.Y);
-        Assert.Equal(0, mh.Bounds.Width);
-        Assert.Equal(0, mh.Bounds.Height);
-        Assert.Equal(0, mh.MetafileSize);
-        switch (type)
-        {
-            case EmfType.EmfOnly:
-                Assert.Equal(MetafileType.Emf, mh.Type);
-                break;
-            case EmfType.EmfPlusDual:
-                Assert.Equal(MetafileType.EmfPlusDual, mh.Type);
-                break;
-            case EmfType.EmfPlusOnly:
-                Assert.Equal(MetafileType.EmfPlusOnly, mh.Type);
-                break;
-            default:
-                Assert.True(false, $"Unknown EmfType '{type}'");
-                break;
-        }
-    }
-
-    private void Metafile_IntPtrEmfType(EmfType type)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                IntPtr hdc = g.GetHdc();
-                try
-                {
-                    Metafile mf = new Metafile(hdc, type);
-                    CheckEmptyHeader(mf, type);
-                }
-                finally
-                {
-                    g.ReleaseHdc(hdc);
-                }
-            }
-        }
-    }
-
-    [Fact]
-    public void Metafile_IntPtrRectangle_Empty()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr hdc = g.GetHdc();
-            try
-            {
-                Metafile mf = new Metafile(hdc, new Rectangle());
-                CheckEmptyHeader(mf, EmfType.EmfPlusDual);
-            }
-            finally
-            {
-                g.ReleaseHdc(hdc);
-            }
-        }
-    }
-
-    [Fact]
-    public void Metafile_IntPtrRectangleF_Empty()
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr hdc = g.GetHdc();
-            try
-            {
-                Metafile mf = new Metafile(hdc, new RectangleF());
-                CheckEmptyHeader(mf, EmfType.EmfPlusDual);
-            }
-            finally
-            {
-                g.ReleaseHdc(hdc);
-            }
-        }
-    }
-
-    private void Metafile_StreamEmfType(Stream stream, EmfType type)
-    {
-        using (Bitmap bmp = new Bitmap(10, 10, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr hdc = g.GetHdc();
-            try
-            {
-                Metafile mf = new Metafile(stream, hdc, type);
-                CheckEmptyHeader(mf, type);
-            }
-            finally
-            {
-                g.ReleaseHdc(hdc);
-            }
-        }
-    }
-
-    [Fact]
-    public void Metafile_StreamIntPtrEmfType_Null()
-    {
-        Assert.Throws<NullReferenceException>(() => Metafile_StreamEmfType(null, EmfType.EmfOnly));
-    }
-
-    [Fact]
-    public void Metafile_StreamIntPtrEmfType_EmfOnly()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        {
-            Metafile_StreamEmfType(ms, EmfType.EmfOnly);
-        }
-    }
-
-    [Fact]
-    public void Metafile_StreamIntPtrEmfType_Invalid()
-    {
-        using (MemoryStream ms = new MemoryStream())
-        {
-            Assert.Throws<ArgumentException>(() => Metafile_StreamEmfType(ms, (EmfType)int.MinValue));
-        }
-    }
-
-    private void CreateFilename(EmfType type, bool single)
-    {
-        string name = $"{type}-{(single ? "Single" : "Multiple")}.emf";
-        string filename = Path.Combine(Path.GetTempPath(), name);
-        Metafile mf;
-        using (Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                IntPtr hdc = g.GetHdc();
-                try
-                {
-                    mf = new Metafile(filename, hdc, type);
-                    Assert.Equal(0, new FileInfo(filename).Length);
-                }
-                finally
-                {
-                    g.ReleaseHdc(hdc);
-                }
-            }
-            long size = 0;
-            using (Graphics g = Graphics.FromImage(mf))
-            {
-                g.FillRectangle(Brushes.BlueViolet, 10, 10, 80, 80);
-                size = new FileInfo(filename).Length;
-                Assert.Equal(0, size);
-            }
-
-            if (!single)
-            {
-                using (Graphics g = Graphics.FromImage(mf))
-                {
-                    g.DrawRectangle(Pens.Azure, 10, 10, 80, 80);
-                }
-            }
-            mf.Dispose();
-            Assert.Equal(size, new FileInfo(filename).Length);
-        }
-    }
-
-    [Fact]
-    public void Measure()
-    {
-        Font test_font = new Font(FontFamily.GenericMonospace, 12);
-
-        Metafile mf;
-        using (Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format32bppArgb))
-        using (Graphics g = Graphics.FromImage(bmp))
-        {
-            IntPtr hdc = g.GetHdc();
-            try
-            {
-                mf = new Metafile(hdc, EmfType.EmfPlusOnly);
-            }
-            finally
-            {
-                g.ReleaseHdc(hdc);
-            }
-        }
-        using (Graphics g = Graphics.FromImage(mf))
-        {
-            string text = "this\nis a test";
-            CharacterRange[] ranges = new CharacterRange[2];
-            ranges[0] = new CharacterRange(0, 5);
-            ranges[1] = new CharacterRange(5, 9);
-
-            SizeF size = g.MeasureString(text, test_font);
-            Assert.False(size.IsEmpty);
-
-            StringFormat sf = new StringFormat();
-            sf.FormatFlags = StringFormatFlags.NoClip;
-            sf.SetMeasurableCharacterRanges(ranges);
-
-            RectangleF rect = new RectangleF(0, 0, size.Width, size.Height);
-            Region[] region = g.MeasureCharacterRanges(text, test_font, rect, sf);
-            Assert.Equal(2, region.Length);
-
-            region = g.MeasureCharacterRanges(text.AsSpan(), test_font, rect, sf);
-            Assert.Equal(2, region.Length);
-            mf.Dispose();
-        }
-    }
-
-    [Fact]
-    public void WorldTransforms()
-    {
-        Metafile mf;
-        using (Bitmap bmp = new Bitmap(100, 100, PixelFormat.Format32bppArgb))
-        {
-            using (Graphics g = Graphics.FromImage(bmp))
-            {
-                IntPtr hdc = g.GetHdc();
-                try
-                {
-                    mf = new Metafile(hdc, EmfType.EmfPlusOnly);
-                }
-                finally
-                {
-                    g.ReleaseHdc(hdc);
-                }
-            }
-            using (Graphics g = Graphics.FromImage(mf))
-            {
-                Assert.True(g.Transform.IsIdentity);
-                g.ScaleTransform(2f, 0.5f);
-                Assert.False(g.Transform.IsIdentity);
-                g.RotateTransform(90);
-                g.TranslateTransform(-2, 2);
-                Matrix m = g.Transform;
-                g.MultiplyTransform(m);
-                // check
-                float[] elements = g.Transform.Elements;
-                Assert.Equal(-1.0, elements[0], 5);
-                Assert.Equal(0.0, elements[1], 5);
-                Assert.Equal(0.0, elements[2], 5);
-                Assert.Equal(-1.0, elements[3], 5);
-                Assert.Equal(-2.0, elements[4], 5);
-                Assert.Equal(-3.0, elements[5], 5);
-
-                g.Transform = m;
-                elements = g.Transform.Elements;
-                Assert.Equal(0.0, elements[0], 5);
-                Assert.Equal(0.5, elements[1], 5);
-                Assert.Equal(-2.0, elements[2], 5);
-                Assert.Equal(0.0, elements[3], 5);
-                Assert.Equal(-4.0, elements[4], 5);
-                Assert.Equal(-1.0, elements[5], 5);
-
-                g.ResetTransform();
-                Assert.True(g.Transform.IsIdentity);
-            }
-            mf.Dispose();
-        }
-    }
-}
diff --git a/src/System.Drawing.Common/tests/runtimeconfig.template.json b/src/System.Drawing.Common/tests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/System.Drawing.Common/tests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptions.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptions.cs
deleted file mode 100644
index ebeecf43bc1..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptions.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-// Borrowed from https://github.com/dotnet/roslyn/blob/main/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerConfigOptions.cs
-
-[ExcludeFromCodeCoverage]
-internal sealed class CompilerAnalyzerConfigOptions : AnalyzerConfigOptions
-{
-    public static CompilerAnalyzerConfigOptions Empty { get; } = new CompilerAnalyzerConfigOptions(ImmutableDictionary.Create<string, string>());
-
-    private readonly ImmutableDictionary<string, string> _backing;
-
-    public CompilerAnalyzerConfigOptions(ImmutableDictionary<string, string> properties)
-    {
-        _backing = properties;
-    }
-
-    public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) => _backing.TryGetValue(key, out value);
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptionsProvider.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptionsProvider.cs
deleted file mode 100644
index 691b01ba4d4..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/CompilerAnalyzerConfigOptionsProvider.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-// Borrowed from https://github.com/dotnet/roslyn/blob/main/src/Compilers/Core/Portable/DiagnosticAnalyzer/CompilerAnalyzerConfigOptionsProvider.cs
-
-[ExcludeFromCodeCoverage]
-internal sealed class CompilerAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
-{
-    private readonly ImmutableDictionary<object, AnalyzerConfigOptions> _treeDict;
-
-    public static CompilerAnalyzerConfigOptionsProvider Empty { get; }
-        = new CompilerAnalyzerConfigOptionsProvider(
-            ImmutableDictionary<object, AnalyzerConfigOptions>.Empty,
-            CompilerAnalyzerConfigOptions.Empty);
-
-    internal CompilerAnalyzerConfigOptionsProvider(
-        ImmutableDictionary<object, AnalyzerConfigOptions> treeDict,
-        AnalyzerConfigOptions globalOptions)
-    {
-        _treeDict = treeDict;
-        GlobalOptions = globalOptions;
-    }
-
-    public override AnalyzerConfigOptions GlobalOptions { get; }
-
-    public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
-        => _treeDict.TryGetValue(tree, out var options) ? options : CompilerAnalyzerConfigOptions.Empty;
-
-    public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
-        => _treeDict.TryGetValue(textFile, out var options) ? options : CompilerAnalyzerConfigOptions.Empty;
-
-    internal CompilerAnalyzerConfigOptionsProvider WithAdditionalTreeOptions(ImmutableDictionary<object, AnalyzerConfigOptions> treeDict)
-        => new(_treeDict.AddRange(treeDict), GlobalOptions);
-
-    internal CompilerAnalyzerConfigOptionsProvider WithGlobalOptions(AnalyzerConfigOptions globalOptions)
-        => new(_treeDict, globalOptions);
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System.Windows.Forms.Analyzers.CSharp.Tests.csproj b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System.Windows.Forms.Analyzers.CSharp.Tests.csproj
deleted file mode 100644
index dacf2b356ce..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System.Windows.Forms.Analyzers.CSharp.Tests.csproj
+++ /dev/null
@@ -1,32 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="$(MicrosoftCodeAnalysisAnalyzersVersion)">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpWorkspacesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeRefactoring.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Verify.Xunit" Version="$(VerifyXunitVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\Common\tests\TestUtilities\System.Windows.Forms.Common.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.Analyzers.CSharp.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Remove="System\Windows\Forms\Generators\MockData\*.cs" />
-    <None Include="System\Windows\Forms\Generators\MockData\*.*">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationGeneratorTests.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationGeneratorTests.cs
deleted file mode 100644
index 9f957a3e8d0..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationGeneratorTests.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Text;
-using System.Windows.Forms.Analyzers;
-using System.Windows.Forms.Analyzers.Tests;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Text;
-using Xunit;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Generators.Tests;
-
-public partial class ApplicationConfigurationGeneratorTests
-{
-    private const string SourceCompilable = @"
-namespace MyProject
-{
-    class Program
-    {
-        static void Main()
-        {
-             ApplicationConfiguration.Initialize();
-        }
-    }
-}";
-    private const string SourceCompilationFailed = @"
-namespace MyProject
-{
-    class Program
-    {
-        static void Main()
-        {
-             {|CS0103:ApplicationConfiguration|}.Initialize();
-        }
-    }
-}";
-
-    public static IEnumerable<object[]> UnsupportedProjectTypes_TestData()
-    {
-        foreach (OutputKind projectType in Enum.GetValues(typeof(OutputKind)))
-        {
-            if (projectType != OutputKind.ConsoleApplication &&
-                projectType != OutputKind.WindowsApplication)
-            {
-                yield return new object[] { projectType };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(UnsupportedProjectTypes_TestData))]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_fails_if_project_type_unsupported(OutputKind projectType)
-    {
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = projectType,
-                Sources = { SourceCompilationFailed },
-                ExpectedDiagnostics =
-                {
-                    DiagnosticResult.CompilerError("WFAC001").WithArguments("WindowsApplication"),
-                }
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    [Theory]
-    [InlineData(OutputKind.ConsoleApplication)]
-    [InlineData(OutputKind.WindowsApplication)]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_pass_if_supported_project_type(OutputKind projectType)
-    {
-        SourceText generatedCode = LoadFileContent("GenerateInitialize_default_boilerplate");
-
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = projectType,
-                Sources = { SourceCompilable },
-                GeneratedSources =
-                {
-                    (typeof(ApplicationConfigurationGenerator), "ApplicationConfiguration.g.cs", generatedCode),
-                },
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    [Fact]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_default_boilerplate()
-    {
-        SourceText generatedCode = LoadFileContent("GenerateInitialize_default_boilerplate");
-
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = OutputKind.WindowsApplication,
-                Sources = { SourceCompilable },
-                GeneratedSources =
-                {
-                    (typeof(ApplicationConfigurationGenerator), "ApplicationConfiguration.g.cs", generatedCode),
-                },
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    [Fact]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_user_settings_boilerplate()
-    {
-        SourceText generatedCode = LoadFileContent("GenerateInitialize_user_settings_boilerplate");
-
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = OutputKind.WindowsApplication,
-                Sources = { SourceCompilable },
-                AnalyzerConfigFiles =
-                {
-                    ("/.globalconfig", $@"is_global = true
-
-build_property.{PropertyNameCSharp.DefaultFont} = Microsoft Sans Serif, 8.25px
-build_property.{PropertyNameCSharp.EnableVisualStyles} =
-build_property.{PropertyNameCSharp.HighDpiMode} = {HighDpiMode.DpiUnawareGdiScaled}
-build_property.{PropertyNameCSharp.UseCompatibleTextRendering} = true
-"),
-                },
-                GeneratedSources =
-                {
-                    (typeof(ApplicationConfigurationGenerator), "ApplicationConfiguration.g.cs", generatedCode),
-                },
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    [Fact]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_default_top_level()
-    {
-        const string source = @"
-ApplicationConfiguration.Initialize();
-";
-
-        SourceText generatedCode = LoadFileContent("GenerateInitialize_default_top_level");
-
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = OutputKind.WindowsApplication,
-                Sources = { source },
-                GeneratedSources =
-                {
-                    (typeof(ApplicationConfigurationGenerator), "ApplicationConfiguration.g.cs", generatedCode),
-                },
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    [Fact]
-    public async Task ApplicationConfigurationGenerator_GenerateInitialize_user_settings_top_level()
-    {
-        const string source = @"
-ApplicationConfiguration.Initialize();
-";
-
-        SourceText generatedCode = LoadFileContent("GenerateInitialize_user_top_level");
-
-        var test = new CSharpIncrementalSourceGeneratorVerifier<ApplicationConfigurationGenerator>.Test
-        {
-            TestState =
-            {
-                OutputKind = OutputKind.WindowsApplication,
-                Sources = { source },
-                AnalyzerConfigFiles =
-                {
-                    ("/.globalconfig", $@"is_global = true
-
-build_property.{PropertyNameCSharp.DefaultFont} = Microsoft Sans Serif, 8.25px
-build_property.{PropertyNameCSharp.EnableVisualStyles} =
-build_property.{PropertyNameCSharp.HighDpiMode} = {HighDpiMode.DpiUnawareGdiScaled}
-build_property.{PropertyNameCSharp.UseCompatibleTextRendering} = true
-"),
-                },
-                GeneratedSources =
-                {
-                    (typeof(ApplicationConfigurationGenerator), "ApplicationConfiguration.g.cs", generatedCode),
-                },
-            },
-        };
-
-        await test.RunAsync().ConfigureAwait(false);
-    }
-
-    private SourceText LoadFileContent(string testName)
-        => SourceText.From(
-                File.ReadAllText($@"System\Windows\Forms\Generators\MockData\{GetType().Name}.{testName}.cs"),
-                Encoding.UTF8);
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=SansSerif.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=SansSerif.verified.txt
deleted file mode 100644
index f76e8661f6f..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=SansSerif.verified.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    ///  global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)3));
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)3));
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=Tahoma.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=Tahoma.verified.txt
deleted file mode 100644
index 97184b57304..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=Tahoma.verified.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    ///  global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Tahoma"), 12f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)3));
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Tahoma"), 12f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)3));
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=default.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=default.verified.txt
deleted file mode 100644
index f47084cb332..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=default.verified.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    ///  global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(global::System.Windows.Forms.Control.DefaultFont.FontFamily, 12f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)6));
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(global::System.Windows.Forms.Control.DefaultFont.FontFamily, 12f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)6));
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=null.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=null.verified.txt
deleted file mode 100644
index 4a0fdfa03df..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_DefaultFont=null.verified.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=false.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=false.verified.txt
deleted file mode 100644
index 1cb051c7d4b..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=false.verified.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=true.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=true.verified.txt
deleted file mode 100644
index 4a0fdfa03df..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_EnableVisualStyles=true.verified.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=false.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=false.verified.txt
deleted file mode 100644
index 4a0fdfa03df..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=false.verified.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=true.verified.txt b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=true.verified.txt
deleted file mode 100644
index c163b70a99a..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.GenerateInitialize_UseCompTextRendering=true.verified.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.cs
deleted file mode 100644
index 77fd3124ed9..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ApplicationConfigurationInitializeBuilderTests.cs
+++ /dev/null
@@ -1,165 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-using System.Windows.Forms.Analyzers;
-using VerifyXunit;
-using Xunit;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Generators.Tests;
-
-[UsesVerify]
-public partial class ApplicationConfigurationInitializeBuilderTests
-{
-    private static readonly string[] s_locales = new[]
-    {
-        "ar-SA",
-        "en-US",
-        "es-ES",
-        "fr-FR",
-        "hi-IN",
-        "ja-JP",
-        "ru-RU",
-        "tr-TR",
-        "zh-CN"
-    };
-
-    [Theory]
-    [InlineData(null, "default_top_level")]
-    [InlineData("", "default_top_level")]
-    [InlineData(" ", "default_top_level")]
-    [InlineData("\t", "default_top_level")]
-    [InlineData("MyProject", "default_boilerplate")]
-    public void ApplicationConfigurationInitializeBuilder_GenerateInitialize_can_handle_namespace(string ns, string expectedFileName)
-    {
-        string expected = File.ReadAllText($@"System\Windows\Forms\Generators\MockData\{GetType().Name}.{expectedFileName}.cs");
-
-        string output = ApplicationConfigurationInitializeBuilder.GenerateInitialize(ns,
-            new ApplicationConfig(
-                EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                DefaultFont: null,
-                HighDpiMode: PropertyDefaultValue.DpiMode,
-                UseCompatibleTextRendering: PropertyDefaultValue.UseCompatibleTextRendering
-            ));
-
-        Assert.Equal(expected, output);
-    }
-
-    public static IEnumerable<object[]> GenerateInitializeData()
-    {
-        foreach (string cultureName in s_locales)
-        {
-            CultureInfo culture = new CultureInfo(cultureName);
-
-            // EnableVisualStyles: false, true
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: false,
-                    DefaultFont: null,
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: PropertyDefaultValue.UseCompatibleTextRendering
-                ),
-                "EnableVisualStyles=false"
-            };
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: true,
-                    DefaultFont: null,
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: PropertyDefaultValue.UseCompatibleTextRendering
-                ),
-                "EnableVisualStyles=true"
-            };
-
-            // UseCompatibleTextRendering: false, true
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: null,
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: false
-                ),
-                "UseCompTextRendering=false"
-            };
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: null,
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: true
-                ),
-                "UseCompTextRendering=true"
-            };
-
-            // DefaultFont: null, FontDescriptor
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: null,
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: false
-                ),
-                "DefaultFont=null"
-            };
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: new FontDescriptor(string.Empty, 12, FontStyle.Bold | FontStyle.Italic, GraphicsUnit.Millimeter).ToString(),
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: true
-                ),
-                "DefaultFont=default"
-            };
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: new FontDescriptor("Tahoma", 12, FontStyle.Regular, GraphicsUnit.Point).ToString(),
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: true
-                ),
-                "DefaultFont=Tahoma"
-            };
-            yield return new object[]
-            {
-                culture,
-                new ApplicationConfig(
-                    EnableVisualStyles: PropertyDefaultValue.EnableVisualStyles,
-                    DefaultFont: new FontDescriptor("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point).ToString(),
-                    HighDpiMode: PropertyDefaultValue.DpiMode,
-                    UseCompatibleTextRendering: true
-                ),
-                "DefaultFont=SansSerif"
-            };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GenerateInitializeData))]
-    public Task ApplicationConfigurationInitializeBuilder_GenerateInitialize(CultureInfo culture, /* ApplicationConfig */object config, string testName)
-    {
-        Thread.CurrentThread.CurrentCulture = culture;
-
-        string output = ApplicationConfigurationInitializeBuilder.GenerateInitialize(null, (ApplicationConfig)config);
-
-        // Compare all locale tests against the same files - we expect the produced output to be the same
-        return Verifier.Verify(output)
-            .UseMethodName("GenerateInitialize")
-            .UseTextForParameters(testName)
-            .DisableRequireUniquePrefix();
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_boilerplate.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_boilerplate.cs
deleted file mode 100644
index 5fb1050cdc8..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_boilerplate.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Windows.Forms;
-
-namespace MyProject
-{
-    /// <summary>
-    ///  Bootstrap the application configuration.
-    /// </summary>
-    [CompilerGenerated]
-    internal static partial class ApplicationConfiguration
-    {
-        /// <summary>
-        ///  Bootstrap the application as follows:
-        ///  <code>
-        ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-        ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        /// </code>
-        /// </summary>
-        public static void Initialize()
-        {
-            global::System.Windows.Forms.Application.EnableVisualStyles();
-            global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-            global::System.Windows.Forms.Application.{|CS0117:SetHighDpiMode|}({|CS0103:HighDpiMode|}.SystemAware);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_top_level.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_top_level.cs
deleted file mode 100644
index 10c6ce18b1f..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_default_top_level.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.{|CS0117:SetHighDpiMode|}({|CS0103:HighDpiMode|}.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_settings_boilerplate.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_settings_boilerplate.cs
deleted file mode 100644
index 7e3e726507a..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_settings_boilerplate.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Windows.Forms;
-
-namespace MyProject
-{
-    /// <summary>
-    ///  Bootstrap the application configuration.
-    /// </summary>
-    [CompilerGenerated]
-    internal static partial class ApplicationConfiguration
-    {
-        /// <summary>
-        ///  Bootstrap the application as follows:
-        ///  <code>
-        ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-        ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.DpiUnawareGdiScaled);
-        ///  global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)2));
-        /// </code>
-        /// </summary>
-        public static void Initialize()
-        {
-            global::System.Windows.Forms.Application.EnableVisualStyles();
-            global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-            global::System.Windows.Forms.Application.{|CS0117:SetHighDpiMode|}({|CS0103:HighDpiMode|}.DpiUnawareGdiScaled);
-            global::System.Windows.Forms.Application.{|CS0117:SetDefaultFont|}(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)2));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_top_level.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_top_level.cs
deleted file mode 100644
index d030c8babd4..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationGeneratorTests.GenerateInitialize_user_top_level.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.DpiUnawareGdiScaled);
-    ///  global::System.Windows.Forms.Application.SetDefaultFont(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)2));
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(true);
-        global::System.Windows.Forms.Application.{|CS0117:SetHighDpiMode|}({|CS0103:HighDpiMode|}.DpiUnawareGdiScaled);
-        global::System.Windows.Forms.Application.{|CS0117:SetDefaultFont|}(new global::System.Drawing.Font(new global::System.Drawing.FontFamily("Microsoft Sans Serif"), 8.25f, (global::System.Drawing.FontStyle)0, (global::System.Drawing.GraphicsUnit)2));
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_boilerplate.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_boilerplate.cs
deleted file mode 100644
index 1b57f5db88a..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_boilerplate.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Windows.Forms;
-
-namespace MyProject
-{
-    /// <summary>
-    ///  Bootstrap the application configuration.
-    /// </summary>
-    [CompilerGenerated]
-    internal static partial class ApplicationConfiguration
-    {
-        /// <summary>
-        ///  Bootstrap the application as follows:
-        ///  <code>
-        ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-        ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        /// </code>
-        /// </summary>
-        public static void Initialize()
-        {
-            global::System.Windows.Forms.Application.EnableVisualStyles();
-            global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-            global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_top_level.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_top_level.cs
deleted file mode 100644
index 4a0fdfa03df..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/MockData/ApplicationConfigurationInitializeBuilderTests.default_top_level.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// <auto-generated />
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Windows.Forms;
-
-/// <summary>
-///  Bootstrap the application configuration.
-/// </summary>
-[CompilerGenerated]
-internal static partial class ApplicationConfiguration
-{
-    /// <summary>
-    ///  Bootstrap the application as follows:
-    ///  <code>
-    ///  global::System.Windows.Forms.Application.EnableVisualStyles();
-    ///  global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-    ///  global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    /// </code>
-    /// </summary>
-    public static void Initialize()
-    {
-        global::System.Windows.Forms.Application.EnableVisualStyles();
-        global::System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-        global::System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.FontConverter.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.FontConverter.cs
deleted file mode 100644
index 316fbc4022d..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.FontConverter.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Globalization;
-using Xunit;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-using static System.Windows.Forms.Generators.ProjectFileReader;
-
-namespace System.Windows.Forms.Generators.Tests;
-
-public partial class ProjectFileReaderTests
-{
-    public class FontConverterTest
-    {
-        private static readonly string[] s_locales = new[]
-        {
-            "ar-SA",
-            "en-US",
-            "es-ES",
-            "fr-FR",
-            "hi-IN",
-            "ja-JP",
-            "ru-RU",
-            "tr-TR",
-            "zh-CN"
-        };
-
-        public static IEnumerable<object[]> TestConvertFormData()
-        {
-            foreach (string cultureName in s_locales)
-            {
-                CultureInfo culture = new CultureInfo(cultureName);
-
-                yield return new object[] { culture, $"Courier New", "Courier New", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Courier New{s_separator} 11", "Courier New", 11f, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Arial{s_separator} 11px", "Arial", 11f, (int)GraphicsUnit.Pixel, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Courier New{s_separator} 11 px", "Courier New", 11f, (int)GraphicsUnit.Pixel, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Courier New{s_separator} 11 px{s_separator} style=Regular", "Courier New", 11f, (int)GraphicsUnit.Pixel, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Courier New{s_separator} style=Bold", "Courier New", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Bold };
-                yield return new object[] { culture, $"Courier New{s_separator} 11 px{s_separator} style=Bold{s_separator} Italic", "Courier New", 11f, (int)GraphicsUnit.Pixel, (int)(FontStyle.Bold | FontStyle.Italic) };
-                yield return new object[] { culture, $"Courier New{s_separator} 11 px{s_separator} style=Regular, Italic", "Courier New", 11f, (int)GraphicsUnit.Pixel, (int)(FontStyle.Regular | FontStyle.Italic) };
-                yield return new object[] { culture, $"Courier New{s_separator} 11 px{s_separator} style=Bold{s_separator} Italic{s_separator} Strikeout", "Courier New", 11f, (int)GraphicsUnit.Pixel, (int)(FontStyle.Bold | FontStyle.Italic | FontStyle.Strikeout) };
-                yield return new object[] { culture, $"Arial{s_separator} 11 px{s_separator} style=Bold, Italic, Strikeout", "Arial", 11f, (int)GraphicsUnit.Pixel, (int)(FontStyle.Bold | FontStyle.Italic | FontStyle.Strikeout) };
-                yield return new object[] { culture, $"arIAL{s_separator} 10{s_separator} style=bold", "arIAL", 10f, (int)GraphicsUnit.Point, (int)FontStyle.Bold };
-                yield return new object[] { culture, $"Arial{s_separator} 10{s_separator}", "Arial", 10f, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Arial{s_separator}", "Arial", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Arial{s_separator} 10{s_separator} style=12", "Arial", 10f, (int)GraphicsUnit.Point, (int)(FontStyle.Underline | FontStyle.Strikeout) };
-                yield return new object[] { culture, $"Courier New{s_separator} Style=Bold", "Courier New", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Bold }; // FullFramework style keyword is case sensitive.
-                yield return new object[] { culture, $"{s_separator} 10{s_separator} style=bold", "", 10f, (int)GraphicsUnit.Point, (int)FontStyle.Bold };
-
-                // NOTE: in .NET runtime these tests will result in FontName='', but the implementation relies on GDI+, which we don't have...
-                yield return new object[] { culture, $"11px{s_separator} Style=Bold", $"11px", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Bold };
-                yield return new object[] { culture, $"11px", "11px", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-                yield return new object[] { culture, $"Style=Bold", "Style=Bold", PropertyDefaultValue.FontSize, (int)GraphicsUnit.Point, (int)FontStyle.Regular };
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TestConvertFormData))]
-        internal void TestConvertFrom(CultureInfo culture, string input, string expectedName, float expectedSize, GraphicsUnit expectedUnits, FontStyle expectedFontStyle)
-        {
-            Thread.CurrentThread.CurrentCulture = culture;
-
-            FontDescriptor font = FontConverter.ConvertFrom(input)!;
-
-            Assert.Equal(expectedName, font.Name);
-            Assert.Equal(expectedSize, font.Size);
-            Assert.Equal(expectedUnits, font.Unit);
-            Assert.Equal(expectedFontStyle, font.Style);
-        }
-
-        public static TheoryData<string> ArgumentExceptionFontConverterData()
-            => new()
-            {
-                { $"Courier New{s_separator} 11 px{s_separator} type=Bold{s_separator} Italic" },
-                { $"Courier New{s_separator} {s_separator} Style=Bold" },
-                { $"Courier New{s_separator} 11{s_separator} Style=" },
-                { $"Courier New{s_separator} 11{s_separator} Style=RandomEnum" },
-                { $"Arial{s_separator} 10{s_separator} style=bold{s_separator}" },
-                { $"Arial{s_separator} 10{s_separator} style=null" },
-                { $"Arial{s_separator} 10{s_separator} style=abc#" },
-                { $"Arial{s_separator} 10{s_separator} style=##" },
-                { $"Arial{s_separator} 10display{s_separator} style=bold" },
-                { $"Arial{s_separator} 10style{s_separator} style=bold" },
-            };
-
-        [Theory]
-        [MemberData(nameof(ArgumentExceptionFontConverterData))]
-        public void InvalidInputThrowsArgumentException(string input)
-        {
-            Assert.Throws<ArgumentException>(() => FontConverter.ConvertFrom(input));
-        }
-
-        public static TheoryData<string, string> InvalidEnumArgumentExceptionFontConverterData()
-            => new()
-            {
-                { $"Arial{s_separator} 10{s_separator} style=56", "style" },
-                { $"Arial{s_separator} 10{s_separator} style=-1", "style" },
-            };
-
-        [Theory]
-        [MemberData(nameof(InvalidEnumArgumentExceptionFontConverterData))]
-        public void InvalidInputThrowsInvalidEnumArgumentException(string input, string paramName)
-        {
-            Assert.Throws<InvalidEnumArgumentException>(paramName, () => FontConverter.ConvertFrom(input));
-        }
-
-        [Fact]
-        public void EmptyStringInput()
-        {
-            FontDescriptor? font = FontConverter.ConvertFrom(string.Empty);
-            Assert.Null(font);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.cs
deleted file mode 100644
index 1ab65bba012..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/System/Windows/Forms/Generators/ProjectFileReaderTests.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.Globalization;
-using System.Windows.Forms.Analyzers;
-using System.Windows.Forms.Analyzers.Tests;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Xunit;
-using Xunit.Abstractions;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Generators.Tests;
-
-public partial class ProjectFileReaderTests
-{
-    private static readonly char s_separator = CultureInfo.CurrentCulture.TextInfo.ListSeparator[0];
-    private static readonly dynamic s_static = typeof(ProjectFileReader).TestAccessor().Dynamic;
-    private readonly ITestOutputHelper _output;
-
-    private static bool TryReadBool(AnalyzerConfigOptionsProvider configOptions, string propertyName, bool defaultValue, out bool value, out Diagnostic? diagnostic)
-        => (bool)s_static.TryReadBool(configOptions, propertyName, defaultValue, out value, out diagnostic);
-
-    private static bool TryReadFont(AnalyzerConfigOptionsProvider configOptions, out FontDescriptor? font, out Diagnostic? diagnostic)
-        => (bool)s_static.TryReadFont(configOptions, out font, out diagnostic);
-
-    private static bool TryReadHighDpiMode(AnalyzerConfigOptionsProvider configOptions, out HighDpiMode highDpiMode, out Diagnostic? diagnostic)
-        => (bool)s_static.TryReadHighDpiMode(configOptions, out highDpiMode, out diagnostic);
-
-    public ProjectFileReaderTests(ITestOutputHelper output)
-    {
-        _output = output;
-    }
-
-    [Theory]
-    [InlineData("a")]
-    [InlineData("@")]
-    [InlineData("yes")]
-    [InlineData("no")]
-    [InlineData("0")]
-    [InlineData("1")]
-    [InlineData("-1")]
-    public void ProjectFileReader_TryReadBool_value_invalid(string value)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.myvalue", value }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadBool(provider, "myvalue", defaultValue: false, out bool returnedValue, out Diagnostic? diagnostic);
-
-        Assert.False(result);
-        Assert.False(returnedValue);
-        Assert.NotNull(diagnostic);
-        Assert.Equal(DiagnosticDescriptors.s_propertyCantBeSetToValue, diagnostic!.Descriptor);
-        _output.WriteLine(diagnostic.ToString());
-    }
-
-    [Theory]
-    [InlineData("", true)] // default value
-    [InlineData("false", false)]
-    [InlineData("true", true)]
-    [InlineData("False", false)]
-    [InlineData("True", true)]
-    [InlineData("FALSE", false)]
-    [InlineData("TRUE", true)]
-    public void ProjectFileReader_TryReadBool_value_valid(string value, bool expected)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.myvalue", value }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadBool(provider, "myvalue", defaultValue: true, out bool returnedValue, out Diagnostic? diagnostic);
-
-        Assert.True(result);
-        Assert.Equal(expected, returnedValue);
-        Assert.Null(diagnostic);
-    }
-
-    public static TheoryData<string> ExceptionFontConverterData()
-       => new()
-       {
-           // ArgumentException
-           { $"Courier New{s_separator} 11 px{s_separator} type=Bold{s_separator} Italic" },
-           { $"Courier New{s_separator} {s_separator} Style=Bold" },
-           { $"Courier New{s_separator} 11{s_separator} Style=" },
-           { $"Courier New{s_separator} 11{s_separator} Style=RandomEnum" },
-           { $"Arial{s_separator} 10{s_separator} style=bold{s_separator}" },
-           { $"Arial{s_separator} 10{s_separator} style=null" },
-           { $"Arial{s_separator} 10{s_separator} style=abc#" },
-           { $"Arial{s_separator} 10{s_separator} style=##" },
-           { $"Arial{s_separator} 10display{s_separator} style=bold" },
-           { $"Arial{s_separator} 10style{s_separator} style=bold" },
-
-           // InvalidEnumArgumentException
-           { $"Arial{s_separator} 10{s_separator} style=56" },
-           { $"Arial{s_separator} 10{s_separator} style=-1" },
-       };
-
-    [Theory]
-    [MemberData(nameof(ExceptionFontConverterData))]
-    public void ProjectFileReader_TryReadFont_value_invalid(string font)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.{PropertyNameCSharp.DefaultFont}", font }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadFont(provider, out FontDescriptor? returnedValue, out Diagnostic? diagnostic);
-
-        Assert.False(result);
-        Assert.Null(returnedValue);
-        Assert.NotNull(diagnostic);
-        Assert.Equal(DiagnosticDescriptors.s_propertyCantBeSetToValueWithReason, diagnostic!.Descriptor);
-        _output.WriteLine(diagnostic.ToString());
-    }
-
-    public static TheoryData<string> TestConvertFormData()
-        => new()
-        {
-            { "Courier New" },
-            { $"Arial{s_separator} 11px" },
-            { $"Courier New{s_separator} style=Bold" },
-            { $"Courier New{s_separator} 11 px{s_separator} style=Regular, Italic" },
-            { $"arIAL{s_separator} 10{s_separator} style=bold" },
-            { $"Arial{s_separator}" },
-            { $"{s_separator} 10{s_separator} style=bold" },
-
-            // NOTE: in .NET runtime these tests will result in FontName='', but the implementation relies on GDI+, which we don't have...
-            { $"11px{s_separator} Style=Bold" },
-            { $"11px" },
-            { $"Style=Bold" },
-        };
-
-    [Theory]
-    [MemberData(nameof(TestConvertFormData))]
-    public void ProjectFileReader_TryReadFont_value_valid(string font)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.{PropertyNameCSharp.DefaultFont}", font }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadFont(provider, out _, out Diagnostic? diagnostic);
-
-        Assert.True(result);
-        Assert.Null(diagnostic);
-    }
-
-    [Theory]
-    [InlineData("@")]
-    [InlineData("yes")]
-    [InlineData("no")]
-    [InlineData("System")]
-    [InlineData("10")]
-    [InlineData("-1")]
-    public void ProjectFileReader_TryReadHighDpiMode_value_invalid(string value)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.{PropertyNameCSharp.HighDpiMode}", value }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadHighDpiMode(provider, out HighDpiMode returnedValue, out Diagnostic? diagnostic);
-
-        Assert.False(result);
-        Assert.Equal(PropertyDefaultValue.DpiMode, returnedValue);
-        Assert.NotNull(diagnostic);
-        Assert.Equal(DiagnosticDescriptors.s_propertyCantBeSetToValue, diagnostic!.Descriptor);
-        _output.WriteLine(diagnostic.ToString());
-    }
-
-    [Theory]
-    [EnumData<HighDpiMode>]
-    public void ProjectFileReader_TryReadHighDpiMode_value_valid(HighDpiMode value)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.{PropertyNameCSharp.HighDpiMode}", value.ToString() }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadHighDpiMode(provider, out HighDpiMode returnedValue, out Diagnostic? diagnostic);
-
-        Assert.True(result);
-        Assert.Equal(value, returnedValue);
-        Assert.Null(diagnostic);
-    }
-
-    [Theory]
-    [EnumData<HighDpiMode>]
-    public void ProjectFileReader_TryReadHighDpiMode_value_asint_valid(HighDpiMode value)
-    {
-        Dictionary<string, string> properties = new()
-        {
-            { $"build_property.{PropertyNameCSharp.HighDpiMode}", ((int)value).ToString() }
-        };
-        CompilerAnalyzerConfigOptions configOptions = new(properties.ToImmutableDictionary());
-        CompilerAnalyzerConfigOptionsProvider provider = new(ImmutableDictionary<object, AnalyzerConfigOptions>.Empty, configOptions);
-
-        bool result = TryReadHighDpiMode(provider, out HighDpiMode returnedValue, out Diagnostic? diagnostic);
-
-        Assert.True(result);
-        Assert.Equal(value, returnedValue);
-        Assert.Null(diagnostic);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/TestAdditionalText.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/TestAdditionalText.cs
deleted file mode 100644
index d2c3d139283..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/TestAdditionalText.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Diagnostics.CodeAnalysis;
-using System.Text;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Text;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-// Borrowed from https://github.com/dotnet/roslyn/blob/main/src/Compilers/Test/Core/Mocks/TestAdditionalText.cs
-
-[ExcludeFromCodeCoverage]
-public sealed class TestAdditionalText : AdditionalText
-{
-    private readonly SourceText _text;
-
-    public TestAdditionalText(string path, SourceText text)
-    {
-        Path = path;
-        _text = text;
-    }
-
-    public TestAdditionalText(string text = "", Encoding? encoding = null, string path = "dummy")
-        : this(path, SourceText.From(text, encoding))
-    {
-    }
-
-    public override string Path { get; }
-
-    public override SourceText GetText(CancellationToken cancellationToken = default) => _text;
-}
-
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpIncrementalSourceGeneratorVerifier.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpIncrementalSourceGeneratorVerifier.cs
deleted file mode 100644
index 530188736a5..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpIncrementalSourceGeneratorVerifier.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-// Note: this is bleeding edge, eventually this can be removed once it is all baked in to Roslyn SDK.
-public static partial class CSharpIncrementalSourceGeneratorVerifier<TIncrementalGenerator>
-    where TIncrementalGenerator : IIncrementalGenerator, new()
-{
-    public class Test : CSharpSourceGeneratorTest<EmptySourceGeneratorProvider>
-    {
-        public Test()
-        {
-            SolutionTransforms.Add((solution, projectId) =>
-            {
-                var compilationOptions = solution.GetProject(projectId)!.CompilationOptions;
-                compilationOptions = compilationOptions!.WithSpecificDiagnosticOptions(
-                    compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
-                solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
-
-                return solution;
-            });
-        }
-
-        protected override IEnumerable<Type> GetSourceGenerators()
-        {
-            yield return typeof(TIncrementalGenerator);
-        }
-
-        protected override ParseOptions CreateParseOptions()
-        {
-            var parseOptions = (CSharpParseOptions)base.CreateParseOptions();
-            return parseOptions.WithLanguageVersion(LanguageVersion.Preview);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpSourceGeneratorTest`1.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpSourceGeneratorTest`1.cs
deleted file mode 100644
index 7d1fbe564b6..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpSourceGeneratorTest`1.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public class CSharpSourceGeneratorTest<TSourceGenerator> : CSharpSourceGeneratorTest<TSourceGenerator, XUnitVerifier>
-    where TSourceGenerator : ISourceGenerator, new()
-{
-    public CSharpSourceGeneratorTest()
-    {
-        ReferenceAssemblies = NetFramework.Net472.WindowsForms;
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs b/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs
deleted file mode 100644
index 9d5eb03101f..00000000000
--- a/src/System.Windows.Forms.Analyzers.CSharp/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-internal static class CSharpVerifierHelper
-{
-    /// <summary>
-    /// By default, the compiler reports diagnostics for nullable reference types at
-    /// <see cref="DiagnosticSeverity.Warning"/>, and the analyzer test framework defaults to only validating
-    /// diagnostics at <see cref="DiagnosticSeverity.Error"/>. This map contains all compiler diagnostic IDs
-    /// related to nullability mapped to <see cref="ReportDiagnostic.Error"/>, which is then used to enable all
-    /// of these warnings for default validation during analyzer and code fix tests.
-    /// </summary>
-    internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler();
-
-    static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler()
-    {
-        string[] args = { "/warnaserror:nullable" };
-        var commandLineArguments = CSharpCommandLineParser.Default.Parse(args, baseDirectory: Environment.CurrentDirectory, sdkDirectory: Environment.CurrentDirectory);
-        return commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System.Windows.Forms.Analyzers.Tests.csproj b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System.Windows.Forms.Analyzers.Tests.csproj
deleted file mode 100644
index 60cd05a24b5..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System.Windows.Forms.Analyzers.Tests.csproj
+++ /dev/null
@@ -1,38 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Compile Remove="CompilerAnalyzerConfigOptions.cs" />
-    <Compile Remove="CompilerAnalyzerConfigOptionsProvider.cs" />
-    <Compile Remove="TestAdditionalText.cs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="$(MicrosoftCodeAnalysisAnalyzersVersion)">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpWorkspacesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeRefactoring.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.Workspaces" Version="$(MicrosoftCodeAnalysisVisualBasicWorkspacesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.Analyzer.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.CodeRefactoring.Testing.XUnit" Version="$(MicrosoftCodeAnalysisPackagesVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\Common\tests\TestUtilities\System.Windows.Forms.Common.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.Analyzers.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="System\Windows\Forms\Analyzers\MockData\*.*">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-</Project>
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/AppManifestAnalyzerTests.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/AppManifestAnalyzerTests.cs
deleted file mode 100644
index 800eaf6ee0c..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/AppManifestAnalyzerTests.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Text;
-using Xunit;
-using VerifyCS = System.Windows.Forms.Analyzers.Tests.CSharpAnalyzerVerifier<
-    System.Windows.Forms.Analyzers.AppManifestAnalyzer>;
-using VerifyVB = System.Windows.Forms.Analyzers.Tests.VisualBasicAnalyzerVerifier<
-    System.Windows.Forms.Analyzers.AppManifestAnalyzer>;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public class AppManifestAnalyzerTests
-{
-    private const string CSharCode = @"
-    namespace ConsoleApplication1
-    {
-        class {|#0:TypeName|}
-        {   
-        }
-    }";
-    private const string VbCode = @"
-Namespace ConsoleApplication1
-    Class {|#0:TypeName|}
-    End Class
-End Namespace";
-
-    [Fact]
-    public async Task AppManifestAnalyzer_noop_if_no_manifest_file()
-    {
-        await new VerifyCS.Test
-        {
-            TestCode = CSharCode,
-            TestState =
-            {
-                AdditionalFiles = { }
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_noop_if_manifest_file_has_no_dpi_info()
-    {
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\nodpi.manifest"));
-        await new VerifyCS.Test
-        {
-            TestCode = CSharCode,
-            TestState =
-            {
-                 AdditionalFiles = { (@"C:\temp\app.manifest", manifestFile) }
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_noop_if_manifest_file_corrupt()
-    {
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\invalid.manifest"));
-        await new VerifyCS.Test
-        {
-            TestCode = CSharCode,
-            TestState =
-            {
-                 AdditionalFiles = { (@"C:\temp\app.manifest", manifestFile) }
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_warn_if_manifest_file_has_dpi_info_CSharp()
-    {
-        const string manifestFilePath = @"C:\temp\app.manifest";
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\dpi.manifest"));
-        await new VerifyCS.Test
-        {
-            TestCode = CSharCode,
-            TestState =
-            {
-                 AdditionalFiles = { (manifestFilePath, manifestFile) }
-            },
-            ExpectedDiagnostics =
-            {
-                new DiagnosticResult(DiagnosticDescriptors.s_migrateHighDpiSettings_CSharp)
-                    .WithArguments(manifestFilePath, ApplicationConfig.PropertyNameCSharp.HighDpiMode)
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_warn_if_manifest_file_has_dpi_info_VB()
-    {
-        const string manifestFilePath = @"C:\temp\app.manifest";
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\dpi.manifest"));
-        await new VerifyVB.Test
-        {
-            TestCode = VbCode,
-            TestState =
-            {
-                 AdditionalFiles = { (manifestFilePath, manifestFile) }
-            },
-            ExpectedDiagnostics =
-            {
-                new DiagnosticResult(DiagnosticDescriptors.s_migrateHighDpiSettings_VB)
-                    .WithArguments(manifestFilePath, ApplicationConfig.PropertyNameVisualBasic.HighDpiMode)
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_can_suppressed_if_manifest_file_has_dpi_info_CSharp()
-    {
-        const string manifestFilePath = @"C:\temp\app.manifest";
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\dpi.manifest"));
-        await new VerifyCS.Test
-        {
-            TestCode = CSharCode,
-            TestState =
-            {
-                AdditionalFiles = { (manifestFilePath, manifestFile) },
-                AnalyzerConfigFiles = { ("/.globalconfig", $"is_global = true\r\ndotnet_diagnostic.WFAC010.severity = none") }
-            }
-        }.RunAsync();
-    }
-
-    [Fact]
-    public async Task AppManifestAnalyzer_can_suppressed_if_manifest_file_has_dpi_info_VB()
-    {
-        const string manifestFilePath = @"C:\temp\app.manifest";
-        SourceText manifestFile = SourceText.From(File.ReadAllText(@"System\Windows\Forms\Analyzers\MockData\dpi.manifest"));
-        await new VerifyVB.Test
-        {
-            TestCode = VbCode,
-            TestState =
-            {
-                AdditionalFiles = { (manifestFilePath, manifestFile) },
-                AnalyzerConfigFiles = { ("/.globalconfig", $"is_global = true\r\ndotnet_diagnostic.WFAC010.severity = none") }
-            }
-        }.RunAsync();
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontDescriptor.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontDescriptor.cs
deleted file mode 100644
index ffaa924630b..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontDescriptor.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-using Xunit;
-using Xunit.Abstractions;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public partial class ApplicationConfigTests
-{
-    public class FontDescriptorTests
-    {
-        private readonly ITestOutputHelper _output;
-
-        public FontDescriptorTests(ITestOutputHelper output)
-        {
-            _output = output;
-        }
-
-        [Fact]
-        public void FontDescriptor_ctor()
-        {
-            FontDescriptor descriptor = new("fontName", 10f, FontStyle.Bold | FontStyle.Italic, GraphicsUnit.Point);
-
-            Assert.Equal("fontName", descriptor.Name);
-            Assert.Equal(10f, descriptor.Size);
-            Assert.Equal(FontStyle.Bold | FontStyle.Italic, descriptor.Style);
-            Assert.Equal(GraphicsUnit.Point, descriptor.Unit);
-        }
-
-        [Theory]
-        [InlineData("", "new global::System.Drawing.Font(global::System.Windows.Forms.Control.DefaultFont.FontFamily, 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData(" ", "new global::System.Drawing.Font(global::System.Windows.Forms.Control.DefaultFont.FontFamily, 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("\t", "new global::System.Drawing.Font(global::System.Windows.Forms.Control.DefaultFont.FontFamily, 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("fontName", "new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"fontName\"), 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("\"fontName\"", "new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"fontName\"), 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("Name with \tspaces", "new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"Name with spaces\"), 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("Name with 'quotes'", "new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"Name with quotes\"), 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        [InlineData("Name with \r\n lines", "new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"Name with  lines\"), 10f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)")]
-        public void FontDescriptor_ToString(string fontName, string expected)
-        {
-            FontDescriptor descriptor = new(fontName, 10f, FontStyle.Bold | FontStyle.Italic, GraphicsUnit.Point);
-
-            _output.WriteLine(descriptor.ToString());
-            Assert.Equal(expected, descriptor.ToString());
-        }
-
-        [Theory]
-        [InlineData("ar-SA")]
-        [InlineData("en-US")]
-        [InlineData("es-ES")]
-        [InlineData("fr-FR")]
-        [InlineData("hi-IN")]
-        [InlineData("ja-JP")]
-        [InlineData("ru-RU")]
-        [InlineData("tr-TR")]
-        [InlineData("zh-CN")]
-        public void FontDescriptor_ToString_culture_agnostic(string cultureName)
-        {
-            Thread.CurrentThread.CurrentCulture = new CultureInfo(cultureName);
-
-            FontDescriptor descriptor = new("Microsoft Sans Serif", 8.25f, FontStyle.Bold | FontStyle.Italic, GraphicsUnit.Point);
-
-            _output.WriteLine(descriptor.ToString());
-            Assert.Equal("new global::System.Drawing.Font(new global::System.Drawing.FontFamily(\"Microsoft Sans Serif\"), 8.25f, (global::System.Drawing.FontStyle)3, (global::System.Drawing.GraphicsUnit)3)", descriptor.ToString());
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontStyle.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontStyle.cs
deleted file mode 100644
index 6d7dd0c1cdf..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.FontStyle.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public partial class ApplicationConfigTests
-{
-    public class FontStyleTests
-    {
-        [Fact]
-        public void GetStandardValuesTest()
-        {
-            var values = Enum.GetValues(typeof(FontStyle));
-            Assert.Equal(5, values.Length); // The values of Graphics unit: Regular, Bold, Italic, Underline, Strikeout.
-        }
-
-        [Theory]
-        [InlineData("Bold", FontStyle.Bold)]
-        [InlineData("Italic", FontStyle.Italic)]
-        [InlineData("Regular", FontStyle.Regular)]
-        [InlineData("Strikeout", FontStyle.Strikeout)]
-        [InlineData("Underline", FontStyle.Underline)]
-        internal void CanConvertFrom(string input, FontStyle expected)
-        {
-            FontStyle value = Enum.Parse<FontStyle>(input);
-            Assert.Equal(expected, value);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.GraphicsUnit.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.GraphicsUnit.cs
deleted file mode 100644
index a0be6ece1db..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.GraphicsUnit.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit;
-using static System.Windows.Forms.Analyzers.ApplicationConfig;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public partial class ApplicationConfigTests
-{
-    // Copied from https://github.com/dotnet/runtime/blob/00ee1c18715723e62484c9bc8a14f517455fc3b3/src/libraries/System.Drawing.Common/tests/System/Drawing/FontConverterTests.cs#L203
-    public class GraphicsUnitTests
-    {
-        [Fact]
-        public void GetStandardValuesTest()
-        {
-            var values = Enum.GetValues(typeof(GraphicsUnit));
-            Assert.Equal(7, values.Length); // The values of Graphics unit: World, Display, Pixel, Point, Inch, Document, Millimeter.
-        }
-
-        [Theory]
-        [InlineData("Display", GraphicsUnit.Display)]
-        [InlineData("Document", GraphicsUnit.Document)]
-        [InlineData("Inch", GraphicsUnit.Inch)]
-        [InlineData("Millimeter", GraphicsUnit.Millimeter)]
-        [InlineData("Pixel", GraphicsUnit.Pixel)]
-        [InlineData("Point", GraphicsUnit.Point)]
-        [InlineData("World", GraphicsUnit.World)]
-        internal void CanConvertFrom(string input, GraphicsUnit expected)
-        {
-            GraphicsUnit value = Enum.Parse<GraphicsUnit>(input);
-            Assert.Equal(expected, value);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.cs
deleted file mode 100644
index a725b5a116a..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/ApplicationConfigTests.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public partial class ApplicationConfigTests
-{
-    // See nested files
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/dpi.manifest b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/dpi.manifest
deleted file mode 100644
index ef80698dfef..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/dpi.manifest
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-            Specifying requestedExecutionLevel element will disable file and registry virtualization. 
-            Remove this element if your application requires this virtualization for backwards
-            compatibility.
-        -->
-        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- A list of the Windows versions that this application has been tested on
-           and is designed to work with. Uncomment the appropriate elements
-           and Windows will automatically select the most compatible environment. -->
-
-      <!-- Windows Vista -->
-      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
-
-      <!-- Windows 7 -->
-      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
-
-      <!-- Windows 8 -->
-      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
-
-      <!-- Windows 8.1 -->
-      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
-
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-
-    </application>
-  </compatibility>
-
-  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
-       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
-       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
-       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. -->
-  
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-    </windowsSettings>
-  </application>
-  
-
-  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/invalid.manifest b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/invalid.manifest
deleted file mode 100644
index e09f1115699..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/invalid.manifest
+++ /dev/null
@@ -1,45 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-
-    </application>
-  </compatibility>
-
-  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
-       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
-       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
-       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. -->
-  <!--
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-    </windowsSettings>
-  </application>
-  -->
-
-  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/nodpi.manifest b/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/nodpi.manifest
deleted file mode 100644
index d9bbc1e5f7b..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/System/Windows/Forms/Analyzers/MockData/nodpi.manifest
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-            Specifying requestedExecutionLevel element will disable file and registry virtualization. 
-            Remove this element if your application requires this virtualization for backwards
-            compatibility.
-        -->
-        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- A list of the Windows versions that this application has been tested on
-           and is designed to work with. Uncomment the appropriate elements
-           and Windows will automatically select the most compatible environment. -->
-
-      <!-- Windows Vista -->
-      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
-
-      <!-- Windows 7 -->
-      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
-
-      <!-- Windows 8 -->
-      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
-
-      <!-- Windows 8.1 -->
-      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
-
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-
-    </application>
-  </compatibility>
-
-  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
-       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
-       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
-       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. -->
-  <!--
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-    </windowsSettings>
-  </application>
-  -->
-
-  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1+Test.cs
deleted file mode 100644
index 6905e29ec43..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1+Test.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpAnalyzerVerifier<TAnalyzer>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-{
-    public class Test : CSharpAnalyzerTest<TAnalyzer, XUnitVerifier>
-    {
-        public Test()
-        {
-            ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.WindowsForms;
-
-            SolutionTransforms.Add((solution, projectId) =>
-            {
-                CompilationOptions compilationOptions = solution.GetProject(projectId)!.CompilationOptions!;
-                compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(
-                    compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
-                solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
-
-                return solution;
-            });
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1.cs
deleted file mode 100644
index e317183b963..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpAnalyzerVerifier`1.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpAnalyzerVerifier<TAnalyzer>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-{
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic()"/>
-    public static DiagnosticResult Diagnostic()
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic();
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(string)"/>
-    public static DiagnosticResult Diagnostic(string diagnosticId)
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(diagnosticId);
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
-    public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => CSharpAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(descriptor);
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
-    public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2+Test.cs
deleted file mode 100644
index 99626f17ae5..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2+Test.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-    where TCodeFix : CodeFixProvider, new()
-{
-    public class Test : CSharpCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
-    {
-        public Test()
-        {
-            ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.WindowsForms;
-
-            SolutionTransforms.Add((solution, projectId) =>
-            {
-                CompilationOptions? compilationOptions = solution.GetProject(projectId)!.CompilationOptions!;
-                compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(
-                    compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
-                solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
-
-                return solution;
-            });
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2.cs
deleted file mode 100644
index 3070478ab92..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeFixVerifier`2.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-    where TCodeFix : CodeFixProvider, new()
-{
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic()"/>
-    public static DiagnosticResult Diagnostic()
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic();
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(string)"/>
-    public static DiagnosticResult Diagnostic(string diagnosticId)
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(diagnosticId);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
-    public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => CSharpCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(descriptor);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
-    public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, string)"/>
-    public static async Task VerifyCodeFixAsync(string source, string fixedSource)
-        => await VerifyCodeFixAsync(source, DiagnosticResult.EmptyDiagnosticResults, fixedSource);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, DiagnosticResult, string)"/>
-    public static async Task VerifyCodeFixAsync(string source, DiagnosticResult expected, string fixedSource)
-        => await VerifyCodeFixAsync(source, new[] { expected }, fixedSource);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, DiagnosticResult[], string)"/>
-    public static async Task VerifyCodeFixAsync(string source, DiagnosticResult[] expected, string fixedSource)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-            FixedCode = fixedSource,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1+Test.cs
deleted file mode 100644
index 0922d3fcc2c..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1+Test.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.CSharp.Testing;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpCodeRefactoringVerifier<TCodeRefactoring>
-    where TCodeRefactoring : CodeRefactoringProvider, new()
-{
-    public class Test : CSharpCodeRefactoringTest<TCodeRefactoring, XUnitVerifier>
-    {
-        public Test()
-        {
-            ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.WindowsForms;
-
-            SolutionTransforms.Add((solution, projectId) =>
-            {
-                CompilationOptions compilationOptions = solution.GetProject(projectId)!.CompilationOptions!;
-                compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(
-                    compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
-                solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
-
-                return solution;
-            });
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1.cs
deleted file mode 100644
index 13d8999d867..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpCodeRefactoringVerifier`1.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class CSharpCodeRefactoringVerifier<TCodeRefactoring>
-    where TCodeRefactoring : CodeRefactoringProvider, new()
-{
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, string)"/>
-    public static async Task VerifyRefactoringAsync(string source, string fixedSource)
-    {
-        await VerifyRefactoringAsync(source, DiagnosticResult.EmptyDiagnosticResults, fixedSource);
-    }
-
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, DiagnosticResult, string)"/>
-    public static async Task VerifyRefactoringAsync(string source, DiagnosticResult expected, string fixedSource)
-    {
-        await VerifyRefactoringAsync(source, new[] { expected }, fixedSource);
-    }
-
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, DiagnosticResult[], string)"/>
-    public static async Task VerifyRefactoringAsync(string source, DiagnosticResult[] expected, string fixedSource)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-            FixedCode = fixedSource,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs
deleted file mode 100644
index ff766b66212..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/CSharpVerifierHelper.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using System.Collections.Immutable;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-internal static class CSharpVerifierHelper
-{
-    /// <summary>
-    /// By default, the compiler reports diagnostics for nullable reference types at
-    /// <see cref="DiagnosticSeverity.Warning"/>, and the analyzer test framework defaults to only validating
-    /// diagnostics at <see cref="DiagnosticSeverity.Error"/>. This map contains all compiler diagnostic IDs
-    /// related to nullability mapped to <see cref="ReportDiagnostic.Error"/>, which is then used to enable all
-    /// of these warnings for default validation during analyzer and code fix tests.
-    /// </summary>
-    internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler();
-
-    private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler()
-    {
-        string[] args = { "/warnaserror:nullable" };
-        var commandLineArguments = CSharpCommandLineParser.Default.Parse(args, baseDirectory: Environment.CurrentDirectory, sdkDirectory: Environment.CurrentDirectory);
-        var nullableWarnings = commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;
-
-        // Workaround for https://github.com/dotnet/roslyn/issues/41610
-        nullableWarnings = nullableWarnings
-            .SetItem("CS8632", ReportDiagnostic.Error)
-            .SetItem("CS8669", ReportDiagnostic.Error);
-
-        return nullableWarnings;
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1+Test.cs
deleted file mode 100644
index d4afd5bc2b7..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1+Test.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.VisualBasic.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicAnalyzerVerifier<TAnalyzer>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-{
-    public class Test : VisualBasicAnalyzerTest<TAnalyzer, XUnitVerifier>
-    {
-        public Test()
-        {
-            ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.WindowsForms;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1.cs
deleted file mode 100644
index a2791ca44c1..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicAnalyzerVerifier`1.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.VisualBasic.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicAnalyzerVerifier<TAnalyzer>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-{
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic()"/>
-    public static DiagnosticResult Diagnostic()
-        => VisualBasicAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic();
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(string)"/>
-    public static DiagnosticResult Diagnostic(string diagnosticId)
-        => VisualBasicAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(diagnosticId);
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
-    public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => VisualBasicAnalyzerVerifier<TAnalyzer, XUnitVerifier>.Diagnostic(descriptor);
-
-    /// <inheritdoc cref="AnalyzerVerifier{TAnalyzer, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
-    public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2+Test.cs
deleted file mode 100644
index 9e59d844bc6..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2+Test.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.VisualBasic.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-    where TCodeFix : CodeFixProvider, new()
-{
-    public class Test : VisualBasicCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2.cs
deleted file mode 100644
index e05c8fa0b53..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeFixVerifier`2.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Testing;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.VisualBasic.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix>
-    where TAnalyzer : DiagnosticAnalyzer, new()
-    where TCodeFix : CodeFixProvider, new()
-{
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic()"/>
-    public static DiagnosticResult Diagnostic()
-        => VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic();
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(string)"/>
-    public static DiagnosticResult Diagnostic(string diagnosticId)
-        => VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(diagnosticId);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.Diagnostic(DiagnosticDescriptor)"/>
-    public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor)
-        => VisualBasicCodeFixVerifier<TAnalyzer, TCodeFix, XUnitVerifier>.Diagnostic(descriptor);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyAnalyzerAsync(string, DiagnosticResult[])"/>
-    public static async Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, string)"/>
-    public static async Task VerifyCodeFixAsync(string source, string fixedSource)
-        => await VerifyCodeFixAsync(source, DiagnosticResult.EmptyDiagnosticResults, fixedSource);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, DiagnosticResult, string)"/>
-    public static async Task VerifyCodeFixAsync(string source, DiagnosticResult expected, string fixedSource)
-        => await VerifyCodeFixAsync(source, new[] { expected }, fixedSource);
-
-    /// <inheritdoc cref="CodeFixVerifier{TAnalyzer, TCodeFix, TTest, TVerifier}.VerifyCodeFixAsync(string, DiagnosticResult[], string)"/>
-    public static async Task VerifyCodeFixAsync(string source, DiagnosticResult[] expected, string fixedSource)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-            FixedCode = fixedSource,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1+Test.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1+Test.cs
deleted file mode 100644
index e4927138b71..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1+Test.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.Testing.Verifiers;
-using Microsoft.CodeAnalysis.VisualBasic.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicCodeRefactoringVerifier<TCodeRefactoring>
-    where TCodeRefactoring : CodeRefactoringProvider, new()
-{
-    public class Test : VisualBasicCodeRefactoringTest<TCodeRefactoring, XUnitVerifier>
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1.cs b/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1.cs
deleted file mode 100644
index 113bf6e2baa..00000000000
--- a/src/System.Windows.Forms.Analyzers/tests/UnitTests/Verifiers/VisualBasicCodeRefactoringVerifier`1.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CodeAnalysis.CodeRefactorings;
-using Microsoft.CodeAnalysis.Testing;
-
-namespace System.Windows.Forms.Analyzers.Tests;
-
-public static partial class VisualBasicCodeRefactoringVerifier<TCodeRefactoring>
-    where TCodeRefactoring : CodeRefactoringProvider, new()
-{
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, string)"/>
-    public static async Task VerifyRefactoringAsync(string source, string fixedSource)
-    {
-        await VerifyRefactoringAsync(source, DiagnosticResult.EmptyDiagnosticResults, fixedSource);
-    }
-
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, DiagnosticResult, string)"/>
-    public static async Task VerifyRefactoringAsync(string source, DiagnosticResult expected, string fixedSource)
-    {
-        await VerifyRefactoringAsync(source, new[] { expected }, fixedSource);
-    }
-
-    /// <inheritdoc cref="CodeRefactoringVerifier{TCodeRefactoring, TTest, TVerifier}.VerifyRefactoringAsync(string, DiagnosticResult[], string)"/>
-    public static async Task VerifyRefactoringAsync(string source, DiagnosticResult[] expected, string fixedSource)
-    {
-        var test = new Test
-        {
-            TestCode = source,
-            FixedCode = fixedSource,
-        };
-
-        test.ExpectedDiagnostics.AddRange(expected);
-        await test.RunAsync(CancellationToken.None);
-    }
-}
diff --git a/src/System.Windows.Forms.Design.Editors/src/System.Windows.Forms.Design.Editors.Facade3x.csproj b/src/System.Windows.Forms.Design.Editors/src/System.Windows.Forms.Design.Editors.Facade3x.csproj
index 2bef560b323..307ecaabce2 100644
--- a/src/System.Windows.Forms.Design.Editors/src/System.Windows.Forms.Design.Editors.Facade3x.csproj
+++ b/src/System.Windows.Forms.Design.Editors/src/System.Windows.Forms.Design.Editors.Facade3x.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <AssemblyName>System.Windows.Forms.Design.Editors</AssemblyName>
diff --git a/src/System.Windows.Forms.Design/src/AssemblyRef.cs b/src/System.Windows.Forms.Design/src/AssemblyRef.cs
index 926015f15c1..5e1feb99215 100644
--- a/src/System.Windows.Forms.Design/src/AssemblyRef.cs
+++ b/src/System.Windows.Forms.Design/src/AssemblyRef.cs
@@ -5,7 +5,7 @@ internal static class FXAssembly
 {
     // NB: this must never-ever change to facilitate type-forwarding from
     // .NET Framework, if those are referenced in .NET project.
-    internal const string Version = "4.0.0.0";
+    internal const string Version = "8.0.0.0";
 }
 
 internal static class AssemblyRef
diff --git a/src/System.Windows.Forms.Design/src/System.Windows.Forms.Design.csproj b/src/System.Windows.Forms.Design/src/System.Windows.Forms.Design.csproj
index e9926e0f264..bb4f9b05193 100644
--- a/src/System.Windows.Forms.Design/src/System.Windows.Forms.Design.csproj
+++ b/src/System.Windows.Forms.Design/src/System.Windows.Forms.Design.csproj
@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <AssemblyName>System.Windows.Forms.Design</AssemblyName>
+    <AssemblyVersion>8.0.0.0</AssemblyVersion>
     <CLSCompliant>true</CLSCompliant>
     <Deterministic>true</Deterministic>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -16,6 +17,7 @@
     <NoWarn>$(NoWarn);IDE0090</NoWarn>
     <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
     <UsePublicApiAnalyzers>true</UsePublicApiAnalyzers>
+    
   </PropertyGroup>
 
   <ItemGroup>
@@ -63,6 +65,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Accessibility" Version="4.6.0-preview3-27504-2" />
     <PackageReference Include="System.CodeDom" Version="$(SystemCodeDomPackageVersion)" />
   </ItemGroup>
 
@@ -103,4 +106,8 @@
     <Compile Update="System\Windows\Forms\Design\FormatControl.cs" />
     <Compile Update="System\Windows\Forms\Design\FormatStringDialog.cs" />
   </ItemGroup>
+
+
+  <!-- Import custom packaging targets -->
+  <Import Project="$(RepositoryEngineeringDir)CustomPackaging.targets" />
 </Project>
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/BinaryEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/BinaryEditorTests.cs
deleted file mode 100644
index f34461c5a53..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/BinaryEditorTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using Moq;
-
-namespace System.Windows.Forms.Design.Editors.Tests;
-
-public class BinaryEditorTests
-{
-    [WinFormsFact]
-    public void BinaryEditor_EditValue()
-    {
-        // Ensure that we can instantiate the modal editor.
-
-        BinaryEditor editor = new();
-        var editorService = new Mock<IWindowsFormsEditorService>();
-        editorService.Setup(e => e.ShowDialog(It.IsAny<Form>()))
-            .Callback<Form>(f => { f.Show(); f.Close(); })
-            .Returns(DialogResult.OK);
-        var serviceProvider = new Mock<IServiceProvider>();
-        serviceProvider.Setup(s => s.GetService(typeof(IWindowsFormsEditorService))).Returns(editorService.Object);
-
-        var result = editor.EditValue(serviceProvider.Object, new byte[10]);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/CodeDomHelpers.cs b/src/System.Windows.Forms.Design/tests/UnitTests/CodeDomHelpers.cs
deleted file mode 100644
index 93ed7c7938f..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/CodeDomHelpers.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-
-namespace System.Windows.Forms.TestUtilities;
-
-public static class CodeDomHelpers
-{
-    public static void AssertEqualCodeStatementCollection(CodeStatementCollection expected, CodeStatementCollection actual)
-    {
-        try
-        {
-            Assert.Equal(expected.Count, actual.Count);
-            for (int i = 0; i < expected.Count; i++)
-            {
-                Assert.Equal(GetConstructionString(expected[i]), GetConstructionString(actual[i]));
-            }
-        }
-        catch (Xunit.Sdk.AssertActualExpectedException)
-        {
-            Console.WriteLine($"Expected: {expected.Count} elements");
-            for (int i = 0; i < expected.Count; i++)
-            {
-                Console.WriteLine($"- [{i}] {GetConstructionString(expected[i])}");
-            }
-
-            Console.WriteLine("");
-
-            Console.WriteLine($"Actual: {actual.Count} elements");
-            for (int i = 0; i < actual.Count; i++)
-            {
-                Console.WriteLine($"- [{i}] {GetConstructionString(actual[i])}");
-            }
-
-            throw;
-        }
-    }
-
-    public static string GetConstructionString(CodeObject o)
-    {
-        if (o is CodeStatement cs)
-        {
-            if (cs.StartDirectives.Count != 0 || cs.EndDirectives.Count != 0)
-            {
-                throw new NotImplementedException("Directives not supported.");
-            }
-        }
-
-        switch (o)
-        {
-            case CodeVariableDeclarationStatement v:
-                if (v.InitExpression is null)
-                {
-                    return $"new CodeVariableDeclarationStatement({GetType(v.Type)}, {GetString(v.Name)});";
-                }
-
-                return $"new CodeVariableDeclarationStatement({GetType(v.Type)}, {GetString(v.Name)}, {GetConstructionString(v.InitExpression)});";
-            case CodeAssignStatement cas:
-                return $"new CodeAssignStatement({GetConstructionString(cas.Left)}, {GetConstructionString(cas.Right)})";
-            case CodeVariableReferenceExpression cvre:
-                return $"new CodeVariableReferenceExpression({GetString(cvre.VariableName)})";
-            case CodeObjectCreateExpression coce:
-                {
-                    if (coce.Parameters.Count == 0)
-                    {
-                        return $"new CodeObjectCreateExpression({GetType(coce.CreateType)})";
-                    }
-
-                    string parameters = string.Join(", ", coce.Parameters.Cast<CodeObject>().Select(o => GetConstructionString(o)));
-                    return $"new CodeObjectCreateExpression({GetType(coce.CreateType)}, {parameters})";
-                }
-
-            case CodeCommentStatement ccs:
-                if (ccs.Comment.DocComment)
-                {
-                    return $"new CodeCommentStatement({GetString(ccs.Comment.Text)}, true)";
-                }
-
-                return $"new CodeCommentStatement({GetString(ccs.Comment.Text)})";
-            case CodePropertyReferenceExpression cpre:
-                return $"new CodePropertyReferenceExpression({GetConstructionString(cpre.TargetObject)}, {GetString(cpre.PropertyName)})";
-            case CodePrimitiveExpression cpe:
-                {
-                    if (cpe.Value is null)
-                    {
-                        return "new CodePrimitiveExpression(null)";
-                    }
-                    else if (cpe.Value is string s)
-                    {
-                        return $"new CodePrimitiveExpression({GetString(s)})";
-                    }
-
-                    return $"new CodePrimitiveExpression({cpe.Value})";
-                }
-
-            default:
-                throw new NotImplementedException(o.ToString());
-        }
-
-        string GetString(string s)
-        {
-            if (s is null)
-            {
-                return "null";
-            }
-            else if (s.Length == 0)
-            {
-                return "string.Empty";
-            }
-
-            return $"\"{s}\"";
-        }
-
-        string GetType(CodeTypeReference reference)
-        {
-            Type result = Type.GetType(reference.BaseType);
-            if (result is not null)
-            {
-                return $"typeof({result.Name})";
-            }
-
-            return GetString(reference.BaseType);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ControlDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ControlDesignerTests.cs
deleted file mode 100644
index 4b591e25770..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ControlDesignerTests.cs
+++ /dev/null
@@ -1,243 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using System.Windows.Forms.Design.Tests.Mocks;
-using Moq;
-using Windows.Win32;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ControlDesignerTests
-{
-    [WinFormsFact]
-    public void ControlDesigner_Ctor_Default()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.False(controlDesigner.AutoResizeHandles);
-        Assert.Null(controlDesigner.Control);
-        Assert.True(controlDesigner.ControlSupportsSnaplines);
-        Assert.Null(controlDesigner.Component);
-        Assert.True(controlDesigner.ForceVisible);
-        Assert.Null(controlDesigner.GetParentComponentProperty());
-        Assert.False(controlDesigner.SerializePerformLayout);
-    }
-
-    [WinFormsFact]
-    public void ControlDesigner_PropertiesTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-        Assert.Empty(controlDesigner.AssociatedComponents);
-        Assert.False(controlDesigner.IsRootDesigner);
-        Assert.NotNull(controlDesigner.SnapLines);
-        Assert.Equal(8, controlDesigner.SnapLines.Count);
-        Assert.NotNull(controlDesigner.StandardBehavior);
-        Assert.Equal(Cursors.Default, controlDesigner.StandardBehavior.Cursor);
-    }
-
-    [Fact]
-    public void AccessibleObjectField()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.Null(controlDesigner.GetAccessibleObjectField());
-    }
-
-    [Fact]
-    public void BehaviorServiceProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.Null(controlDesigner.GetBehaviorServiceProperty());
-    }
-
-    [Fact]
-    public void AccessibilityObjectField()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.NotNull(controlDesigner.AccessibilityObject);
-    }
-
-    [Fact]
-    public void EnableDragRectProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.False(controlDesigner.GetEnableDragRectProperty());
-    }
-
-    [Fact]
-    public void ParticipatesWithSnapLinesProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.True(controlDesigner.ParticipatesWithSnapLines);
-    }
-
-    [Fact]
-    public void AutoResizeHandlesProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.True(controlDesigner.AutoResizeHandles = true);
-        Assert.True(controlDesigner.AutoResizeHandles);
-    }
-
-    [Fact]
-    public void SelectionRulesProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.Equal(SelectionRules.Visible, controlDesigner.SelectionRules);
-    }
-
-    [Fact]
-    public void InheritanceAttributeProperty()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-        Assert.NotNull(controlDesigner.GetInheritanceAttributeProperty());
-    }
-
-    [Fact]
-    public void NumberOfInternalControlDesignersTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.Equal(0, controlDesigner.NumberOfInternalControlDesigners());
-    }
-
-    [Fact]
-    public void BaseWndProcTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Message m = default;
-        controlDesigner.BaseWndProcMethod(ref m);
-    }
-
-    [Fact]
-    public void CanBeParentedToTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-        Assert.True(controlDesigner.CanBeParentedTo(new ParentControlDesigner()));
-    }
-
-    [Theory]
-    [BoolData]
-    public void EnableDragDropTest(bool val)
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        controlDesigner.EnableDragDropMethod(val);
-    }
-
-    [Fact]
-    public void GetHitTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        Assert.False(controlDesigner.GetHitTestMethod(new Drawing.Point()));
-    }
-
-    [Fact]
-    public void HookChildControlsTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-        controlDesigner.HookChildControlsMethod(new Control());
-    }
-
-    [Fact]
-    public void InitializeTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-    }
-
-    [Fact]
-    public void InitializeNewComponentTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-    }
-
-    [Fact]
-    public void OnSetComponentDefaultsTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-#pragma warning disable CS0618 // Type or member is obsolete
-        controlDesigner.OnSetComponentDefaults();
-#pragma warning restore CS0618
-    }
-
-    [Fact]
-    public void OnContextMenuTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        controlDesigner.OnContextMenuMethod(0, 0);
-    }
-
-    [Fact]
-    public void OnCreateHandleTest()
-    {
-        using TestControlDesigner controlDesigner = new TestControlDesigner();
-        using Button button = new Button();
-        controlDesigner.Initialize(button);
-        controlDesigner.OnCreateHandleMethod();
-    }
-
-    [WinFormsFact]
-    public void ControlDesigner_WndProc_InvokePaint_Success()
-    {
-        using ControlDesigner designer = new();
-        Message m = new Message
-        {
-            Msg = (int)PInvoke.WM_PAINT
-        };
-        designer.TestAccessor().Dynamic.WndProc(ref m);
-    }
-
-    [Fact]
-    public void ControlDesigner_AssociatedComponents_NullSite_Test()
-    {
-        using ControlDesigner controlDesigner = new();
-        using Control control = new();
-
-        using Control childControl = new();
-        controlDesigner.Initialize(control);
-
-        Assert.Empty(controlDesigner.AssociatedComponents);
-
-        control.Controls.Add(childControl);
-
-        Assert.Empty(controlDesigner.AssociatedComponents);
-    }
-
-    [WinFormsFact]
-    public void ControlDesigner_AssociatedComponentsTest()
-    {
-        using Control control = new();
-        using ControlDesigner controlDesigner = new();
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(control);
-        mockDesignerHost
-            .Setup(s => s.GetDesigner(It.IsAny<Control>()))
-            .Returns(() => null);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        control.Site = mockSite.Object;
-
-        controlDesigner.Initialize(control);
-
-        Assert.Empty(controlDesigner.AssociatedComponents);
-
-        using Control childControl = new();
-        childControl.Site = mockSite.Object;
-        control.Controls.Add(childControl);
-
-        Assert.Equal(1, controlDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/EnsureDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/EnsureDesignerTests.cs
deleted file mode 100644
index 2ee6b726208..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/EnsureDesignerTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-
-namespace System.Windows.Forms.Design.Editors.Tests;
-
-public class EnsureDesignerTests
-{
-    [WinFormsFact]
-    public void Ensure_designer_type_forwarded()
-    {
-        SystemDesignMetadataReader metadataReader = new();
-        IReadOnlyList<string> forwardedTypes = metadataReader.GetExportedTypeNames();
-
-        IEnumerable<Type> designers = typeof(ComponentDesigner).Assembly
-                            .GetTypes()
-                            .Where(t => t.IsSubclassOf(typeof(ComponentDesigner))
-                                    && !t.IsPublic);
-        foreach (Type designer in designers)
-        {
-            Assert.True(forwardedTypes.Contains(designer.FullName), $"{designer.FullName} must be type forwarded");
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/EnsureEditorsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/EnsureEditorsTests.cs
deleted file mode 100644
index 4b8b4f50823..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/EnsureEditorsTests.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Drawing.Design;
-using System.Drawing.Imaging;
-using System.Reflection;
-
-namespace System.Windows.Forms.Design.Editors.Tests;
-
-public class EnsureEditorsTests
-{
-    [WinFormsFact]
-    public void Ensure_editors_type_forwarded()
-    {
-        // The list of editors which either didn't exist in .NET Framework
-        Type[] nonTypeForwardedEditors =
-        {
-            typeof(InitialDirectoryEditor),     // introduced in .NET 6.0, https://github.com/dotnet/winforms/pull/4645
-        };
-
-        SystemDesignMetadataReader metadataReader = new();
-        IReadOnlyList<string> forwardedTypes = metadataReader.GetExportedTypeNames();
-
-        IEnumerable<Type> editors = typeof(ComponentDesigner).Assembly
-                            .GetTypes()
-                            .Where(t => t.IsSubclassOf(typeof(UITypeEditor))
-                                     && !t.IsPublic
-                                     && !nonTypeForwardedEditors.Contains(t));
-        foreach (Type editor in editors)
-        {
-            Assert.True(forwardedTypes.Contains(editor.FullName), $"{editor.FullName} must be type forwarded");
-        }
-    }
-
-    [WinFormsTheory]
-    // In Table
-    [InlineData(typeof(Array), typeof(ArrayEditor))]
-    [InlineData(typeof(IList), typeof(CollectionEditor))]
-    [InlineData(typeof(ICollection), typeof(CollectionEditor))]
-    [InlineData(typeof(byte[]), typeof(BinaryEditor))]
-    [InlineData(typeof(Stream), typeof(BinaryEditor))]
-    [InlineData(typeof(string[]), typeof(StringArrayEditor))]
-    [InlineData(typeof(Bitmap), typeof(BitmapEditor))]
-    [InlineData(typeof(Color), typeof(ColorEditor))]
-    [InlineData(typeof(ContentAlignment), typeof(ContentAlignmentEditor))]
-    [InlineData(typeof(Font), typeof(FontEditor))]
-    [InlineData(typeof(Icon), typeof(IconEditor))]
-    [InlineData(typeof(Image), typeof(ImageEditor))]
-    [InlineData(typeof(Metafile), typeof(MetafileEditor))]
-    [InlineData(typeof(AnchorStyles), typeof(AnchorEditor))]
-    [InlineData(typeof(DockStyle), typeof(DockEditor))]
-    [InlineData(typeof(ImageListImage), typeof(ImageListImageEditor))]
-    [InlineData(typeof(DateTime), typeof(DateTimeEditor))]
-    // With Editor Attribute
-    [InlineData(typeof(Cursor), typeof(CursorEditor))]
-    //[InlineData(typeof(GridColumnStylesCollection), typeof(DataGridColumnCollectionEditor))]
-    //[InlineData(typeof(DataGridView), typeof(DataGridViewComponentEditor))]
-    //[InlineData(typeof(DataGridViewCellStyle), typeof(DataGridViewCellStyleEditor))]
-    [InlineData(typeof(ImageList.ImageCollection), typeof(ImageCollectionEditor))]
-    [InlineData(typeof(Keys), typeof(ShortcutKeysEditor))]
-    //[InlineData(typeof(TableLayoutStyleCollection), typeof(StyleCollectionEditor))]
-    //[InlineData(typeof(ToolStripItemCollection), typeof(ToolStripCollectionEditor))]
-    [InlineData(typeof(ToolStripStatusLabelBorderSides), typeof(BorderSidesEditor))]
-    //[InlineData(typeof(TreeNodeCollection), typeof(TreeNodeCollectionEditor))]
-    public void EnsureUITypeEditorForType(Type type, Type expectedEditorType)
-    {
-        var editor = TypeDescriptor.GetEditor(type, typeof(UITypeEditor));
-
-        Assert.NotNull(editor);
-        Assert.Equal(expectedEditorType, editor.GetType());
-    }
-
-    [WinFormsTheory]
-    //[InlineData(typeof(BindingSource), "DataMember", typeof(DataMemberListEditor))]
-    [InlineData(typeof(ButtonBase), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ButtonBase), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ButtonBase), "Text", typeof(MultilineStringEditor))]
-    [InlineData(typeof(CheckedListBox), "Items", typeof(ListControlStringCollectionEditor))]
-    [InlineData(typeof(ColumnHeader), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ColumnHeader), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ComboBox), "AutoCompleteCustomSource", typeof(ListControlStringCollectionEditor))]
-    [InlineData(typeof(ComboBox), "Items", typeof(ListControlStringCollectionEditor))]
-    //[InlineData(typeof(DataGridView), "Columns", typeof(DataGridViewColumnCollectionEditor))]
-    //[InlineData(typeof(DataGridView), "DataMember", typeof(DataMemberListEditor))]
-    [InlineData(typeof(DataGridViewCellStyle), "Format", typeof(FormatStringEditor))]
-    //[InlineData(typeof(DataGridViewColumn), "DataPropertyName", typeof(DataGridViewColumnDataPropertyNameEditor))]
-    //[InlineData(typeof(DataGridViewComboBoxColumn), "DisplayMember", typeof(DataMemberFieldEditor))]
-    [InlineData(typeof(DataGridViewComboBoxColumn), "Items", typeof(StringCollectionEditor))]
-    //[InlineData(typeof(DataGridViewComboBoxColumn), "ValueMember", typeof(DataMemberFieldEditor))]
-    [InlineData(typeof(DateTimePicker), "MaxDate", typeof(DateTimeEditor))]
-    [InlineData(typeof(DateTimePicker), "MinDate", typeof(DateTimeEditor))]
-    [InlineData(typeof(DateTimePicker), "Value", typeof(DateTimeEditor))]
-    [InlineData(typeof(DomainUpDown), "Items", typeof(StringCollectionEditor))]
-    //[InlineData(typeof(ErrorProvider), "DataMember", typeof(DataMemberListEditor))]
-    [InlineData(typeof(FolderBrowserDialog), "SelectedPath", typeof(SelectedPathEditor))]
-    [InlineData(typeof(HelpProvider), "HelpNamespace", typeof(HelpNamespaceEditor))]
-    [InlineData(typeof(Label), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(Label), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(Label), "Text", typeof(MultilineStringEditor))]
-    [InlineData(typeof(LinkLabel), "LinkArea", typeof(LinkAreaEditor))]
-    [InlineData(typeof(ListBox), "Items", typeof(ListControlStringCollectionEditor))]
-    //[InlineData(typeof(ListControl), "DisplayMember", typeof(DataMemberFieldEditor))]
-    [InlineData(typeof(ListControl), "FormatString", typeof(FormatStringEditor))]
-    //[InlineData(typeof(ListControl), "ValueMember", typeof(DataMemberFieldEditor))]
-    //[InlineData(typeof(ListView), "Columns", typeof(ColumnHeaderCollectionEditor))]
-    [InlineData(typeof(ListView), "Groups", typeof(ListViewGroupCollectionEditor))]
-    [InlineData(typeof(ListView), "Items", typeof(ListViewItemCollectionEditor))]
-    [InlineData(typeof(ListViewItem), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ListViewItem), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ListViewItem), "StateImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(ListViewItem), "SubItems", typeof(ListViewSubItemCollectionEditor))]
-    [InlineData(typeof(MaskedTextBox), "Mask", typeof(MaskPropertyEditor))]
-    [InlineData(typeof(MaskedTextBox), "Text", typeof(MaskedTextBoxTextEditor))]
-    [InlineData(typeof(MonthCalendar), "MaxDate", typeof(DateTimeEditor))]
-    [InlineData(typeof(MonthCalendar), "MinDate", typeof(DateTimeEditor))]
-    [InlineData(typeof(MonthCalendar), "SelectionEnd", typeof(DateTimeEditor))]
-    [InlineData(typeof(MonthCalendar), "SelectionStart", typeof(DateTimeEditor))]
-    [InlineData(typeof(MonthCalendar), "TodayDate", typeof(DateTimeEditor))]
-    [InlineData(typeof(NotifyIcon), "BalloonTipText", typeof(MultilineStringEditor))]
-    [InlineData(typeof(NotifyIcon), "Text", typeof(MultilineStringEditor))]
-    [InlineData(typeof(TabControl), "TabPages", typeof(TabPageCollectionEditor))]
-    [InlineData(typeof(TabPage), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TabPage), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TextBox), "AutoCompleteCustomSource", typeof(ListControlStringCollectionEditor))]
-    [InlineData(typeof(TextBoxBase), "Lines", typeof(StringArrayEditor))]
-    [InlineData(typeof(TextBoxBase), "Text", typeof(MultilineStringEditor))]
-    [InlineData(typeof(ToolStripComboBox), "AutoCompleteCustomSource", typeof(ListControlStringCollectionEditor))]
-    [InlineData(typeof(ToolStripComboBox), "Items", typeof(ListControlStringCollectionEditor))]
-    //[InlineData(typeof(ToolStripItem), "ImageIndex", typeof(ToolStripImageIndexEditor))]
-    //[InlineData(typeof(ToolStripItem), "ImageKey", typeof(ToolStripImageIndexEditor))]
-    [InlineData(typeof(ToolStripItem), "ToolTipText", typeof(MultilineStringEditor))]
-    [InlineData(typeof(ToolStripTextBox), "AutoCompleteCustomSource", typeof(ListControlStringCollectionEditor))]
-    [InlineData(typeof(ToolStripTextBox), "Lines", typeof(StringArrayEditor))]
-    [InlineData(typeof(TreeNode), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeNode), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeNode), "SelectedImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeNode), "StateImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeNode), "StateImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeView), "ImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeView), "ImageKey", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeView), "SelectedImageIndex", typeof(ImageIndexEditor))]
-    [InlineData(typeof(TreeView), "SelectedImageKey", typeof(ImageIndexEditor))]
-    public void EnsureUITypeEditorForProperty(Type type, string propertyName, Type expectedEditorType)
-    {
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(type);
-        Assert.NotNull(properties);
-        Assert.NotEmpty(properties);
-
-        PropertyDescriptor propertyDescriptor = properties.Find(propertyName, true);
-        Assert.NotNull(propertyDescriptor);
-
-        var editor = propertyDescriptor.GetEditor(typeof(UITypeEditor));
-        Assert.NotNull(editor);
-        Assert.Equal(expectedEditorType, editor.GetType());
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(ToolTip), "GetToolTip", typeof(MultilineStringEditor))]
-    public void EnsureUITypeEditorForMethod(Type type, string methodName, Type expectedEditorType)
-    {
-        Type reflectType = TypeDescriptor.GetReflectionType(type);
-        Assert.NotNull(reflectType);
-
-        MethodInfo method = reflectType.GetMethod(methodName);
-        Assert.NotNull(method);
-
-        IEnumerable<EditorAttribute> attributes = method.GetCustomAttributes(typeof(EditorAttribute), false).Cast<EditorAttribute>();
-        Assert.NotNull(attributes);
-        Assert.NotEmpty(attributes);
-        Assert.Contains(attributes, editor => editor.EditorTypeName.StartsWith(expectedEditorType.FullName + ", "));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/GlobalUsings.cs b/src/System.Windows.Forms.Design/tests/UnitTests/GlobalUsings.cs
deleted file mode 100644
index 12febf7aa93..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Windows.Forms;
-global using Xunit;
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ListViewDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ListViewDesignerTests.cs
deleted file mode 100644
index 5a3aa0deef3..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ListViewDesignerTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ListViewDesignerTests
-{
-    [WinFormsFact]
-    public void ListViewDesigner_AssociatedComponentsTest()
-    {
-        using ListViewDesigner listViewDesigner = new();
-        using ListView listView = new();
-        listViewDesigner.Initialize(listView);
-
-        Assert.Empty(listViewDesigner.AssociatedComponents);
-
-        listView.Columns.Add("123");
-        listView.Columns.Add("abc");
-
-        Assert.Equal(2, listViewDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Mocks/MockSite.cs b/src/System.Windows.Forms.Design/tests/UnitTests/Mocks/MockSite.cs
deleted file mode 100644
index c995c284322..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Mocks/MockSite.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using System.ComponentModel.Design;
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Design.Tests.Mocks
-{
-    public class MockSite
-    {
-        public static Mock<ISite> CreateMockSiteWithDesignerHost(object designerHost)
-        {
-            Mock<ISite> mockSite = new(MockBehavior.Strict);
-            mockSite
-                .Setup(s => s.GetService(typeof(IDesignerHost)))
-                .Returns(designerHost);
-            mockSite
-                .Setup(s => s.GetService(typeof(IInheritanceService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(IDictionaryService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(IExtenderListService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(AmbientProperties)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(DesignerActionService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(IComponentChangeService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(ToolStripKeyboardHandlingService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(ISupportInSituService)))
-                .Returns(null);
-            mockSite
-                .Setup(s => s.GetService(typeof(INestedContainer)))
-                .Returns(null);
-
-            Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-
-            mockSite
-                .Setup(s => s.GetService(typeof(ISelectionService)))
-                .Returns(mockSelectionService.Object);
-            mockSite
-                .Setup(s => s.Container)
-                .Returns((IContainer)null);
-            mockSite
-                .Setup(s => s.Name)
-                .Returns("Site");
-            mockSite
-                .Setup(s => s.DesignMode)
-                .Returns(true);
-            mockSite
-                .Setup(s => s.GetService(typeof(UndoEngine)))
-                .Returns(null);
-
-            return mockSite;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Properties/launchSettings.json b/src/System.Windows.Forms.Design/tests/UnitTests/Properties/launchSettings.json
deleted file mode 100644
index 90729785053..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Properties/launchSettings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "System.Windows.Forms.Design.Tests": {
-      "commandName": "Project",
-      "nativeDebugging": true
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x16.bmp b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x16.bmp
deleted file mode 100644
index 8bf35136370..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x16.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x24.bmp b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x24.bmp
deleted file mode 100644
index 9fa2469f870..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/16x24.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/24x16.bmp b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/24x16.bmp
deleted file mode 100644
index d3fdc521f1f..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/24x16.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Audio1.wav b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Audio1.wav
deleted file mode 100644
index d9605cba788..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Audio1.wav
+++ /dev/null
@@ -1 +0,0 @@
-HELLO
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Icon1.ico b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Icon1.ico
deleted file mode 100644
index 5d06b9f2857..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Icon1.ico and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Image1.png b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Image1.png
deleted file mode 100644
index 8d4272efa7f..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/Image1.png and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/TextFile1.txt b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/TextFile1.txt
deleted file mode 100644
index 530c72a067f..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/TextFile1.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-hello test
-!
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/telescope_01.wmf b/src/System.Windows.Forms.Design/tests/UnitTests/Resources/telescope_01.wmf
deleted file mode 100644
index 453986c39c1..00000000000
Binary files a/src/System.Windows.Forms.Design/tests/UnitTests/Resources/telescope_01.wmf and /dev/null differ
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/SerializableAttributeTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/SerializableAttributeTests.cs
deleted file mode 100644
index c9bef24c0c8..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/SerializableAttributeTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests.Serialization;
-
-public class SerializableAttributeTests
-{
-    [Fact]
-    public void EnsureSerializableAttribute()
-    {
-        BinarySerialization.EnsureSerializableAttribute(
-            typeof(Behavior.Behavior).Assembly,
-            new HashSet<string>
-            {
-                typeof(OleDragDropHandler.CfCodeToolboxItem).FullName,
-                { "System.Windows.Forms.Design.Behavior.DesignerActionKeyboardBehavior+<>c" }
-            });
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CodeDomSerializerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CodeDomSerializerTests.cs
deleted file mode 100644
index bc74b9c8b43..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CodeDomSerializerTests.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-
-namespace System.Windows.Forms.Design.Serialization.Tests;
-
-public class CodeDomSerializerTests
-{
-    [Fact]
-    public void CodeDomSerializer_Constructor()
-    {
-        CodeDomSerializer underTest = new();
-        Assert.NotNull(underTest);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CollectionCodeDomSerializerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CollectionCodeDomSerializerTests.cs
deleted file mode 100644
index 462e562f7b6..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/CollectionCodeDomSerializerTests.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-
-namespace System.Windows.Forms.Design.Serialization.Tests;
-
-public class CollectionCodeDomSerializerTests
-{
-    [Fact]
-    public void CollectionCodeDomSerializer_Constructor()
-    {
-        CollectionCodeDomSerializer underTest = CollectionCodeDomSerializer.Default;
-        Assert.NotNull(underTest);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/PrimitiveCodeDomSerializerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/PrimitiveCodeDomSerializerTests.cs
deleted file mode 100644
index 7638edaf1ed..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/PrimitiveCodeDomSerializerTests.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-using System.ComponentModel.Design.Serialization;
-
-namespace System.Windows.Forms.Design.Serialization.Tests;
-
-public class PrimitiveCodeDomSerializerTests
-{
-    [Fact]
-    public void PrimitiveCodeDomSerializerTests_Constructor()
-    {
-        PrimitiveCodeDomSerializer underTest = new();
-        Assert.NotNull(underTest);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(false)]
-    [InlineData("some string")]
-    [InlineData('c')]
-    [InlineData(42)]
-    [InlineData(42F)]
-    [InlineData(42.123)]
-    public void PrimitiveCodeDomSerializerTests_Serialize(object input)
-    {
-        DesignerSerializationManager manager = new();
-        PrimitiveCodeDomSerializer underTest = PrimitiveCodeDomSerializer.Default;
-        Assert.NotNull(underTest);
-
-        var result = underTest.Serialize(manager, input) as CodePrimitiveExpression;
-        Assert.NotNull(result);
-        Assert.Equal(input, result.Value);
-        Assert.Empty(result.UserData);
-    }
-
-    [Fact]
-    public void PrimitiveCodeDomSerializerTests_Serialize_Cast()
-    {
-        DesignerSerializationManager manager = new();
-        PrimitiveCodeDomSerializer underTest = PrimitiveCodeDomSerializer.Default;
-        Assert.NotNull(underTest);
-
-        var cast = underTest.Serialize(manager, (byte)42) as CodeCastExpression;
-
-        Assert.NotNull(cast);
-        Assert.Equal(typeof(byte).ToString(), cast.TargetType.BaseType);
-        Assert.IsType<CodePrimitiveExpression>(cast.Expression);
-        var primitive = cast.Expression as CodePrimitiveExpression;
-        Assert.Equal((byte)42, primitive.Value);
-        Assert.Empty(cast.UserData);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/TypeCodeDomSerializerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/TypeCodeDomSerializerTests.cs
deleted file mode 100644
index 6cd6b565d6d..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/Serialization/TypeCodeDomSerializerTests.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class TypeCodeDomSerializerTests
-{
-    [Fact]
-    public void TypeCodeDomSerializer_Constructor()
-    {
-        TypeCodeDomSerializer underTest = new();
-        Assert.NotNull(underTest);
-    }
-
-    [Fact]
-    public void TypeCodeDomSerializer_Serialize_Manager_Null()
-    {
-        TypeCodeDomSerializer underTest = new();
-        Assert.Throws<ArgumentNullException>(() => underTest.Serialize(null, null, null));
-    }
-
-    [Fact]
-    public void TypeCodeDomSerializer_Serialize_Root_Null()
-    {
-        Mock<DesignerSerializationManager> mockSerializationManager = new(MockBehavior.Strict);
-        TypeCodeDomSerializer underTest = new();
-        Assert.Throws<ArgumentNullException>(() => underTest.Serialize(mockSerializationManager.Object, null, null));
-    }
-
-    [Fact]
-    public void TypeCodeDomSerializer_Deserialize_Manager_Null()
-    {
-        TypeCodeDomSerializer underTest = new();
-        Assert.Throws<ArgumentNullException>(() => underTest.Deserialize(null, null));
-    }
-
-    [Fact]
-    public void TypeCodeDomSerializer_Deserialize_CodeTypeDec_Null()
-    {
-        Mock<DesignerSerializationManager> mockSerializationManager = new(MockBehavior.Strict);
-        TypeCodeDomSerializer underTest = new();
-        Assert.Throws<ArgumentNullException>(() => underTest.Deserialize(mockSerializationManager.Object, null));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/SplitContainerDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/SplitContainerDesignerTests.cs
deleted file mode 100644
index c14736ffddd..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/SplitContainerDesignerTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using Moq;
-using System.Windows.Forms.Design.Tests.Mocks;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class SplitContainerDesignerTests
-{
-    [WinFormsFact]
-    public void SplitContainerDesigner_AssociatedComponentsTest()
-    {
-        using SplitContainer splitContainer = new();
-        using SplitContainerDesigner splitContainerDesigner = new();
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(splitContainer);
-        mockDesignerHost
-            .Setup(s => s.GetDesigner(It.IsAny<Control>()))
-            .Returns(splitContainerDesigner);
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        splitContainer.Site = mockSite.Object;
-
-        splitContainerDesigner.Initialize(splitContainer);
-
-        Assert.Empty(splitContainerDesigner.AssociatedComponents);
-
-        using Control control = new();
-        control.Parent = splitContainer.Panel1;
-
-        Assert.Equal(1, splitContainerDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System.Windows.Forms.Design.Tests.csproj b/src/System.Windows.Forms.Design/tests/UnitTests/System.Windows.Forms.Design.Tests.csproj
deleted file mode 100644
index d6f6e747ae9..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System.Windows.Forms.Design.Tests.csproj
+++ /dev/null
@@ -1,68 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <SourceTargetFramework>$(TargetFramework)</SourceTargetFramework>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <AssemblyName>System.Windows.Forms.Design.Tests</AssemblyName>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-    <NoWarn>$(NoWarn);SYSLIB0050;SYSLIB0051;SYSLIB0011</NoWarn>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <None Remove="Resources\telescope_01.wmf" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="$(MicrosoftCodeAnalysisCSharpPackageVersion)" />
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\System.Windows.Forms\tests\TestUtilities\System.Windows.Forms.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.Design.csproj" />
-    <ProjectReference Include="..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- workaround for https://github.com/dotnet/sdk/issues/3254 -->
-    <Reference Include="$(BaseOutputPath)..\System.Design.Facade\$(Configuration)\$(SourceTargetFramework)\System.Design.dll" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Content Include="Resources\telescope_01.wmf">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Include="Resources\16x16.bmp">
-      <LogicalName>System.Drawing.Design.Tests.16x16.bmp</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Resources\24x16.bmp">
-      <LogicalName>System.Drawing.Design.Tests.24x16.bmp</LogicalName>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Resources\16x24.bmp">
-      <LogicalName>System.Drawing.Design.Tests.16x24.bmp</LogicalName>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="Resources\*.*">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="AxInterop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\AxInterop.WMPLib.dll</HintPath>
-    </Reference>
-    <Reference Include="Interop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\Interop.WMPLib.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ArrayEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ArrayEditorTests.cs
deleted file mode 100644
index a7028015085..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ArrayEditorTests.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing.Design;
-using System.Reflection;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ArrayEditorTests
-{
-    [Theory]
-    [InlineData(typeof(object), null)]
-    [InlineData(typeof(string), null)]
-    [InlineData(typeof(int[]), typeof(int))]
-    [InlineData(typeof(IList<int>), null)]
-    [InlineData(typeof(IList), null)]
-    [InlineData(typeof(ClassWithItem), null)]
-    [InlineData(typeof(ClassWithPrivateItem), null)]
-    [InlineData(typeof(ClassWithStaticItem), null)]
-    [InlineData(typeof(ClassWithItems), null)]
-    [InlineData(typeof(ClassWithPrivateItems), null)]
-    [InlineData(typeof(ClassWithStaticItems), null)]
-    public void ArrayEditor_Ctor_Type(Type type, Type expectedItemType)
-    {
-        SubArrayEditor editor = new(type);
-        Assert.Equal(expectedItemType, editor.CollectionItemType);
-        Assert.Same(editor.CollectionItemType, editor.CollectionItemType);
-        Assert.Equal(type, editor.CollectionType);
-        Assert.Null(editor.Context);
-        Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic);
-        Assert.False(editor.IsDropDownResizable);
-        Assert.Equal(new Type[] { expectedItemType }, editor.NewItemTypes);
-    }
-
-    [Fact]
-    public void ArrayEditor_Ctor_NullType()
-    {
-        SubArrayEditor editor = new(null);
-        Assert.Null(editor.CollectionItemType);
-        Assert.Null(editor.CollectionType);
-        Assert.Null(editor.Context);
-        Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic);
-        Assert.False(editor.IsDropDownResizable);
-        Assert.Equal(new Type[] { null }, editor.NewItemTypes);
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_TestData()
-    {
-        yield return new object[] { "some string" };
-        yield return new object[] { 123 };
-        yield return new object[] { null };
-        yield return new object[] { new Component() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_TestData))]
-    public void ArrayEditor_CanRemoveInstance_Invoke_ReturnsExpected(object value)
-    {
-        SubArrayEditor editor = new(null);
-        Assert.True(editor.CanRemoveInstance(value));
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_InheritanceAttribute_TestData()
-    {
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited - 1), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.InheritedReadOnly), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited), true };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited + 1), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_InheritanceAttribute_TestData))]
-    public void ArrayEditor_CanRemoveInstance_InheritanceAttribute_ReturnsExpected(InheritanceAttribute attribute, bool expected)
-    {
-        using Component component = new();
-        TypeDescriptor.AddAttributes(component, attribute);
-        SubArrayEditor editor = new(null);
-        Assert.Equal(expected, editor.CanRemoveInstance(component));
-    }
-
-    [Fact]
-    public void ArrayEditor_CanSelectMultipleInstances_Invoke_ReturnsFalse()
-    {
-        SubArrayEditor editor = new(null);
-        Assert.True(editor.CanSelectMultipleInstances());
-    }
-
-    public static IEnumerable<Object[]> GetDisplayText_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { null, string.Empty, "String" };
-        yield return new object[] { null, "string", "string" };
-
-        yield return new object[] { null, new ClassWithStringName { Name = "CustomName" }, "CustomName" };
-        yield return new object[] { null, new ClassWithStringName { Name = string.Empty }, "ClassWithStringName" };
-        yield return new object[] { null, new ClassWithStringName { Name = null }, "ClassWithStringName" };
-        yield return new object[] { null, new ClassWithNonStringName { Name = 1 }, "ClassWithNonStringName" };
-        yield return new object[] { null, new ClassWithNullToString(), "ClassWithNullToString" };
-
-        yield return new object[] { typeof(int), null, string.Empty };
-        yield return new object[] { typeof(int), "", "String" };
-        yield return new object[] { typeof(int), "value", "value" };
-        yield return new object[] { typeof(int), 1, "1" };
-        yield return new object[] { typeof(int), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithStringDefaultProperty" };
-
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), null, string.Empty };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "CustomName" };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = string.Empty }, "ClassWithStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = null }, "ClassWithStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithNonStringDefaultProperty), new ClassWithNonStringDefaultProperty { DefaultProperty = 1 }, "ClassWithNonStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithNoSuchDefaultProperty), new ClassWithNoSuchDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithNoSuchDefaultProperty" };
-        yield return new object[] { typeof(List<ClassWithStringDefaultProperty>), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithStringDefaultProperty" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDisplayText_TestData))]
-    public void ArrayEditor_GetDisplayText_Invoke_ReturnsExpected(Type type, object value, string expected)
-    {
-        SubArrayEditor editor = new(type);
-        Assert.Equal(expected, editor.GetDisplayText(value));
-    }
-
-    [Fact]
-    public void ArrayEditor_GetDisplayText_ValueDoesntMatchCollectionType_ThrowsTargetException()
-    {
-        SubArrayEditor editor = new(typeof(ClassWithStringDefaultProperty));
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => editor.GetDisplayText(new ClassWithNonStringDefaultProperty()));
-        Assert.IsType<TargetException>(ex.InnerException);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ArrayEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        ArrayEditor editor = new(null);
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    public static IEnumerable<object[]> GetItems_TestData()
-    {
-        yield return new object[] { null, Array.Empty<object>() };
-        yield return new object[] { new object(), Array.Empty<object>() };
-        yield return new object[] { new int[] { 1, 2, 3 }, new object[] { 1, 2, 3, } };
-        yield return new object[] { new ArrayList { 1, 2, 3 }, Array.Empty<object>() };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetItems_TestData))]
-    public void ArrayEditor_GetItems_Invoke_ReturnsExpected(object editValue, object[] expected)
-    {
-        SubArrayEditor editor = new(null);
-        object[] items = editor.GetItems(editValue);
-        Assert.Equal(expected, items);
-        Assert.IsType(expected.GetType(), items);
-        Assert.NotSame(editValue, items);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ArrayEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        ArrayEditor editor = new(null);
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    public static IEnumerable<object[]> SetItems_Array_TestData()
-    {
-        yield return new object[] { null, Array.Empty<object>(), Array.Empty<object>() };
-        yield return new object[] { null, new object[] { 1, 2, 3 }, new object[] { 1, 2, 3 } };
-        yield return new object[] { new object[] { 4, 5 }, new object[] { 1, 2, 3 }, new object[] { 1, 2, 3 } };
-        yield return new object[] { new object[] { 4, 5, 6 }, new object[] { 1, 2, 3 }, new object[] { 1, 2, 3 } };
-        yield return new object[] { new object[] { 4, 5, 6, 7 }, new object[] { 1, 2, 3 }, new object[] { 1, 2, 3 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetItems_Array_TestData))]
-    public void ArrayEditor_SetItems_InvokeArray_ReturnsCopy(object editValue, object[] value, int[] expected)
-    {
-        SubArrayEditor editor = new(typeof(int[]));
-        int[] result = Assert.IsType<int[]>(editor.SetItems(editValue, value));
-        Assert.NotSame(value, expected);
-        Assert.Equal(expected, result);
-    }
-
-    public static IEnumerable<object[]> SetItems_NonArray_TestData()
-    {
-        object editValue = new();
-        yield return new object[] { editValue, null, editValue };
-        yield return new object[] { editValue, Array.Empty<object>(), editValue };
-        yield return new object[] { Array.Empty<object>(), null, null };
-        yield return new object[] { null, null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetItems_NonArray_TestData))]
-    public void ArrayEditor_SetItems_InvokeNonArrayValue_ReturnsExpected(object editValue, object[] value, object expected)
-    {
-        SubArrayEditor editor = new(typeof(int[]));
-        Assert.Same(expected, editor.SetItems(editValue, value));
-    }
-
-    [Theory]
-    [InlineData(typeof(object))]
-    [InlineData(null)]
-    public void ArrayEditor_SetItems_NullCollectionItemType_ThrowsArgumentNullException(Type type)
-    {
-        SubArrayEditor editor = new(type);
-        Assert.Null(editor.CollectionItemType);
-        Assert.Throws<ArgumentNullException>("elementType", () => editor.SetItems(null, Array.Empty<object>()));
-        Assert.Throws<ArgumentNullException>("elementType", () => editor.SetItems(Array.Empty<object>(), Array.Empty<object>()));
-    }
-
-    private class SubArrayEditor : ArrayEditor
-    {
-        public SubArrayEditor(Type type) : base(type)
-        {
-        }
-
-        public new Type CollectionItemType => base.CollectionItemType;
-
-        public new Type CollectionType => base.CollectionType;
-
-        public new ITypeDescriptorContext Context => base.Context;
-
-        public new string HelpTopic => base.HelpTopic;
-
-        public new Type[] NewItemTypes => base.NewItemTypes;
-
-        public new bool CanRemoveInstance(object value) => base.CanRemoveInstance(value);
-
-        public new bool CanSelectMultipleInstances() => base.CanSelectMultipleInstances();
-
-        public new string GetDisplayText(object value) => base.GetDisplayText(value);
-
-        public new object[] GetItems(object editValue) => base.GetItems(editValue);
-
-        public new object SetItems(object editValue, object[] value) => base.SetItems(editValue, value);
-    }
-
-    private class ClassWithItem
-    {
-        public int Item { get; set; }
-    }
-
-    private class ClassWithPrivateItem
-    {
-        private int Item { get; set; }
-    }
-
-    private class ClassWithStaticItem
-    {
-        public static int Item { get; set; }
-    }
-
-    private class ClassWithItems
-    {
-        public int Items { get; set; }
-    }
-
-    private class ClassWithPrivateItems
-    {
-        private int Items { get; set; }
-    }
-
-    private class ClassWithStaticItems
-    {
-        public static int Items { get; set; }
-    }
-
-    private class ClassWithStringName
-    {
-        public string Name { get; set; }
-
-        public override string ToString() => nameof(ClassWithStringName);
-    }
-
-    private class ClassWithNonStringName
-    {
-        public int Name { get; set; }
-
-        public override string ToString() => nameof(ClassWithNonStringName);
-    }
-
-    private class ClassWithNullToString
-    {
-        public int Name { get; set; }
-
-        public override string ToString() => null;
-    }
-
-    [DefaultProperty(nameof(ClassWithStringDefaultProperty.DefaultProperty))]
-    private class ClassWithStringDefaultProperty
-    {
-        public string DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithStringDefaultProperty);
-    }
-
-    [DefaultProperty(nameof(ClassWithNonStringDefaultProperty.DefaultProperty))]
-    private class ClassWithNonStringDefaultProperty
-    {
-        public int DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithNonStringDefaultProperty);
-    }
-
-    [DefaultProperty("NoSuchProperty")]
-    private class ClassWithNoSuchDefaultProperty
-    {
-        public string DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithNoSuchDefaultProperty);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ByteViewerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ByteViewerTests.cs
deleted file mode 100644
index 34499ca652e..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ByteViewerTests.cs
+++ /dev/null
@@ -1,1117 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ByteViewerTests
-{
-    [WinFormsFact]
-    public void ByteViewer_Ctor_Default()
-    {
-        using SubByteViewer control = new();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.True(control.Bottom > 0);
-        Assert.Equal(new Rectangle(0, 0, control.Width, control.Height), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(TableLayoutPanelCellBorderStyle.Inset, control.CellBorderStyle);
-        Assert.Equal(new Rectangle(0, 0, control.Width, control.Height), control.ClientRectangle);
-        Assert.Equal(new Size(control.Width, control.Height), control.ClientSize);
-        Assert.Equal(1, control.ColumnCount);
-        ColumnStyle columnStyle = Assert.IsType<ColumnStyle>(Assert.Single(control.ColumnStyles));
-        Assert.Equal(SizeType.Percent, columnStyle.SizeType);
-        Assert.Equal(100F, columnStyle.Width);
-        Assert.Same(control.LayoutSettings.ColumnStyles, control.ColumnStyles);
-        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(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, control.Width, control.Height), control.DisplayRectangle);
-        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.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(TableLayoutPanelGrowStyle.AddRows, control.GrowStyle);
-        Assert.True(control.HasChildren);
-        Assert.True(control.Height > 0);
-        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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.NotNull(control.LayoutSettings);
-        Assert.Same(control.LayoutSettings, control.LayoutSettings);
-        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(new Size(4, 4), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.True(control.Right > 0);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(1, control.RowCount);
-        RowStyle rowStyle = Assert.IsType<RowStyle>(Assert.Single(control.RowStyles));
-        Assert.Equal(SizeType.Percent, rowStyle.SizeType);
-        Assert.Equal(100F, rowStyle.Height);
-        Assert.Same(control.LayoutSettings.RowStyles, control.RowStyles);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Equal(new Size(control.Width, control.Height), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.True(control.Width > 0);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using SubByteViewer control = new();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(control.Width, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using SubByteViewer control = new();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_GetBytes_Invoke_ReturnsExpected()
-    {
-        using ByteViewer control = new();
-        Assert.Null(control.GetBytes());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_GetDisplayMode_Invoke_ReturnsExpected()
-    {
-        using ByteViewer control = new();
-        Assert.Equal(DisplayMode.Hexdump, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubByteViewer.ScrollStateAutoScrolling, false)]
-    [InlineData(SubByteViewer.ScrollStateFullDrag, false)]
-    [InlineData(SubByteViewer.ScrollStateHScrollVisible, false)]
-    [InlineData(SubByteViewer.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubByteViewer.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ByteViewer_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using SubByteViewer control = new();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ByteViewer_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using SubByteViewer control = new();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using SubByteViewer control = new();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ByteViewer_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ByteViewer_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ByteViewer_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        yield return new object[] { new LayoutEventArgs(null, null) };
-        yield return new object[] { new LayoutEventArgs(new Control(), null) };
-        yield return new object[] { new LayoutEventArgs(new Control(), string.Empty) };
-        yield return new object[] { new LayoutEventArgs(new Control(), "ChildIndex") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Visible") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Items") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Rows") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Columns") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "RowStyles") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "ColumnStyles") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "TableIndex") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "GrowStyle") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "CellBorderStyle") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "LayoutSettings") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "NoSuchProperty") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void ByteViewer_OnLayout_Invoke_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void ByteViewer_OnLayout_InvokeWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_OnLayout_InvokeNullE_ThrowsNullReferenceException()
-    {
-        using SubByteViewer control = new();
-        Assert.Throws<NullReferenceException>(() => control.OnLayout(null));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ByteViewer_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using SubByteViewer control = new();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_OnPaint_Invoke_CallsPaint()
-    {
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using PaintEventArgs eventArgs = new(graphics, Rectangle.Empty);
-
-        using SubByteViewer control = new();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnPaint_WithBytes_TestData()
-    {
-        foreach (DisplayMode displayMode in Enum.GetValues(typeof(DisplayMode)))
-        {
-            yield return new object[] { Array.Empty<byte>(), displayMode };
-            yield return new object[] { new byte[] { 1, 2, 3 }, displayMode };
-            yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, displayMode };
-            yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, displayMode };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_WithBytes_TestData))]
-    public void ByteViewer_OnPaint_InvokeWithBytes_CallsPaint(byte[] bytes, DisplayMode displayMode)
-    {
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using PaintEventArgs eventArgs = new(graphics, Rectangle.Empty);
-
-        using SubByteViewer control = new();
-        control.SetBytes(bytes);
-        control.SetDisplayMode(displayMode);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_OnPaint_InvokeWithHandle_CallsPaint()
-    {
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using PaintEventArgs eventArgs = new(graphics, Rectangle.Empty);
-
-        using SubByteViewer control = new();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_WithBytes_TestData))]
-    public void ByteViewer_OnPaint_InvokeWithBytesWithHandle_CallsPaint(byte[] bytes, DisplayMode displayMode)
-    {
-        using Bitmap image = new(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using PaintEventArgs eventArgs = new(graphics, Rectangle.Empty);
-
-        using SubByteViewer control = new();
-        control.SetBytes(bytes);
-        control.SetDisplayMode(displayMode);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_OnPaint_NullE_ThrowsNullReferenceException()
-    {
-        using SubByteViewer control = new();
-        Assert.Throws<NullReferenceException>(() => control.OnPaint(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("*")] // Invalid path
-    public void ByteViewer_SaveToFile_InvokeNoBytes_Nop(string path)
-    {
-        using ByteViewer control = new();
-        control.SaveToFile(path);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SaveToFile_InvokeWithBytes_Success()
-    {
-        using ByteViewer control = new();
-        control.SetBytes(new byte[] { 1, 2, 3 });
-        string path = "ByteViewerContent";
-        try
-        {
-            control.SaveToFile(path);
-            Assert.Equal(new byte[] { 1, 2, 3 }, File.ReadAllBytes(path));
-        }
-        finally
-        {
-            File.Delete(path);
-        }
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SaveToFile_InvokeNullPath_ThrowsArgumentNullException()
-    {
-        using ByteViewer control = new();
-        control.SetBytes(Array.Empty<byte>());
-        Assert.Throws<ArgumentNullException>("path", () => control.SaveToFile(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("\0")]
-    public void ByteViewer_SaveToFile_InvokeInvalidPath_ThrowsArgumentException(string path)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(Array.Empty<byte>());
-        Assert.Throws<ArgumentException>("path", () => control.SaveToFile(path));
-    }
-
-    public static IEnumerable<object[]> ScrollChanged_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { null, new EventArgs() };
-        yield return new object[] { new object(), null };
-        yield return new object[] { new object(), new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollChanged_TestData))]
-    public void ByteViewer_ScrollChanged_Invoke_Success(object source, EventArgs e)
-    {
-        using SubByteViewer control = new();
-        control.ScrollChanged(source, e);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ScrollChanged(source, e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollChanged_TestData))]
-    public void ByteViewer_ScrollChanged_InvokeWithHandle_Success(object source, EventArgs e)
-    {
-        using SubByteViewer control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ScrollChanged(source, e);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.ScrollChanged(source, e);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBytes_TestData()
-    {
-        yield return new object[] { Array.Empty<byte>() };
-        yield return new object[] { new byte[] { 1, 2, 3 } };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 } };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBytes_TestData))]
-    public void ByteViewer_SetBytes_Invoke_GetReturnExpected(byte[] bytes)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(bytes);
-        Assert.Same(bytes, control.GetBytes());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetBytes(bytes);
-        Assert.Same(bytes, control.GetBytes());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBytes_TestData))]
-    public void ByteViewer_SetBytes_InvokeWithBytes_GetReturnExpected(byte[] bytes)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(new byte[] { 1 });
-
-        control.SetBytes(bytes);
-        Assert.Same(bytes, control.GetBytes());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetBytes(bytes);
-        Assert.Same(bytes, control.GetBytes());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SetBytes_NullBytes_ThrowsArgumentNullException()
-    {
-        using ByteViewer control = new();
-        Assert.Throws<ArgumentNullException>("bytes", () => control.SetBytes(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DisplayMode.Auto)]
-    [InlineData(DisplayMode.Hexdump)]
-    public void ByteViewer_SetDisplayMode_InvokeNoBytes_GetReturnsExpected(DisplayMode value)
-    {
-        using ByteViewer control = new();
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DisplayMode>]
-    public void ByteViewer_SetDisplayMode_InvokeWithBytes_GetReturnsExpected(DisplayMode value)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(new byte[] { 1, 2, 3 });
-
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DisplayMode.Ansi, 2, 3)]
-    [InlineData(DisplayMode.Auto, 0, 0)]
-    [InlineData(DisplayMode.Hexdump, 0, 0)]
-    [InlineData(DisplayMode.Unicode, 2, 3)]
-    public void ByteViewer_SetDisplayMode_InvokeWithBytesWithHandle_GetReturnsExpected(DisplayMode value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(new byte[] { 1, 2, 3 });
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetDisplayMode(value);
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetDisplayMode_AnsiWithBytes_TestData()
-    {
-        yield return new object[] { new byte[] { 1, 2, 3 }, "\u0001\u0002\u0003" };
-        yield return new object[] { new byte[] { (byte)'a', (byte)'b', (byte)'c' }, "abc" };
-        yield return new object[] { new byte[] { (byte)'a', (byte)'b', (byte)'c', (byte)'\0', (byte)'d', (byte)'e', (byte)'f' }, $"abc\u000Bdef" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDisplayMode_AnsiWithBytes_TestData))]
-    public void ByteViewer_SetDisplayMode_AnsiWithBytes_EditReturnsExpected(byte[] bytes, string expected)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(bytes);
-        control.SetDisplayMode(DisplayMode.Ansi);
-
-        TextBox textBox = control.Controls.OfType<TextBox>().Single();
-        ScrollBar scrollBar = control.Controls.OfType<ScrollBar>().Single();
-        Assert.Equal(expected, textBox.Text);
-        Assert.True(textBox.Visible);
-        Assert.False(scrollBar.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SetBytes(new byte[] { (byte)'1', (byte)'2', (byte)'3' });
-        Assert.Equal("123", textBox.Text);
-        Assert.True(textBox.Visible);
-        Assert.False(scrollBar.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetDisplayMode_UnicodeWithBytes_TestData()
-    {
-        yield return new object[] { new byte[] { 1, 0, 2, 0, 3, 0 }, "\u0001\u0002\u0003" };
-        yield return new object[] { new byte[] { (byte)'a', 0, (byte)'b', 0, (byte)'c', 0 }, "abc" };
-        yield return new object[] { new byte[] { (byte)'a', 0, (byte)'b', 0, (byte)'c', 0, (byte)'\0', 0, (byte)'d', 0, (byte)'e', 0, (byte)'f', 0 }, $"abc\u000Bdef" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDisplayMode_UnicodeWithBytes_TestData))]
-    public void ByteViewer_SetDisplayMode_UnicodeWithBytes_EditReturnsExpected(byte[] bytes, string expected)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(bytes);
-        control.SetDisplayMode(DisplayMode.Unicode);
-
-        TextBox textBox = control.Controls.OfType<TextBox>().Single();
-        ScrollBar scrollBar = control.Controls.OfType<ScrollBar>().Single();
-        Assert.Equal(expected, textBox.Text);
-        Assert.True(textBox.Visible);
-        Assert.False(scrollBar.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SetBytes(new byte[] { (byte)'1', 0, (byte)'2', 0, (byte)'3', 0 });
-        Assert.Equal("123", textBox.Text);
-        Assert.True(textBox.Visible);
-        Assert.False(scrollBar.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DisplayMode.Ansi)]
-    [InlineData(DisplayMode.Unicode)]
-    public void ByteViewer_SetDisplayMode_InvokeNoBytes_ThrowsNullReferenceException(DisplayMode value)
-    {
-        using ByteViewer control = new();
-        Assert.Throws<NullReferenceException>(() => control.SetDisplayMode(value));
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        Assert.Throws<NullReferenceException>(() => control.SetDisplayMode(value));
-        Assert.Equal(value, control.GetDisplayMode());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DisplayMode>]
-    public void ByteViewer_SetDisplayMode_InvokeInvalidMode_ThrowsInvalidEnumArgumentException(DisplayMode value)
-    {
-        using ByteViewer control = new();
-        Assert.Throws<InvalidEnumArgumentException>("mode", () => control.SetDisplayMode(value));
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SetFile_InvokeNoBytes_Success()
-    {
-        using ByteViewer control = new();
-        using TempFile file = TempFile.Create(new byte[] { 1, 2, 3 });
-        control.SetFile(file.Path);
-        Assert.Equal(new byte[] { 1, 2, 3, 0 }, control.GetBytes());
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SetFile_InvokeWithBytes_Success()
-    {
-        using ByteViewer control = new();
-        control.SetBytes(new byte[] { 4, 5, 6 });
-
-        using TempFile file = TempFile.Create(new byte[] { 1, 2, 3 });
-        control.SetFile(file.Path);
-        Assert.Equal(new byte[] { 1, 2, 3, 0 }, control.GetBytes());
-    }
-
-    [WinFormsFact]
-    public void ByteViewer_SetFile_InvokeNullPath_ThrowsArgumentNullException()
-    {
-        using ByteViewer control = new();
-        control.SetBytes(Array.Empty<byte>());
-        Assert.Throws<ArgumentNullException>("path", () => control.SetFile(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("\0")]
-    public void ByteViewer_SetFile_InvokeInvalidPath_ThrowsArgumentException(string path)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(Array.Empty<byte>());
-        Assert.Throws<ArgumentException>("path", () => control.SetFile(path));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ByteViewer_SetStartLine_InvokeNoBytes_Success(int line)
-    {
-        using ByteViewer control = new();
-        control.SetStartLine(line);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetStartLine(line);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetStartLine_WithBytes_TestData()
-    {
-        yield return new object[] { Array.Empty<byte>(), -1 };
-        yield return new object[] { Array.Empty<byte>(), 0 };
-        yield return new object[] { Array.Empty<byte>(), 1 };
-        yield return new object[] { Array.Empty<byte>(), int.MaxValue };
-        yield return new object[] { new byte[] { 1, 2, 3 }, -1 };
-        yield return new object[] { new byte[] { 1, 2, 3 }, 0 };
-        yield return new object[] { new byte[] { 1, 2, 3 }, 1 };
-        yield return new object[] { new byte[] { 1, 2, 3 }, int.MaxValue };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, -1 };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0 };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 1 };
-        yield return new object[] { new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetStartLine_WithBytes_TestData))]
-    public void ByteViewer_SetStartLine_InvokeWithBytes_Success(byte[] bytes, int line)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(bytes);
-
-        control.SetStartLine(line);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetStartLine(line);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(int.MaxValue)]
-    public void ByteViewer_SetStartLine_InvokeNoBytesWithHandle_Success(int line)
-    {
-        using ByteViewer control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetStartLine(line);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetStartLine(line);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetStartLine_WithBytes_TestData))]
-    public void ByteViewer_SetStartLine_InvokeWithBytesWithHandle_Success(byte[] bytes, int line)
-    {
-        using ByteViewer control = new();
-        control.SetBytes(bytes);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetStartLine(line);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetStartLine(line);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubByteViewer : ByteViewer
-    {
-        public new const int ScrollStateAutoScrolling = ByteViewer.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ByteViewer.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ByteViewer.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ByteViewer.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ByteViewer.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnLayout(LayoutEventArgs levent) => base.OnLayout(levent);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void ScrollChanged(object source, EventArgs e) => base.ScrollChanged(source, e);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionEditorTests.cs
deleted file mode 100644
index 6cadb7e8fd8..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionEditorTests.cs
+++ /dev/null
@@ -1,1143 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing.Design;
-using System.Reflection;
-using System.Windows.Forms.Design;
-using Moq;
-using Moq.Protected;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class CollectionEditorTests
-{
-    [Theory]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(typeof(string), typeof(object))]
-    [InlineData(typeof(int[]), typeof(object))]
-    [InlineData(typeof(IList<int>), typeof(int))]
-    [InlineData(typeof(IList), typeof(object))]
-    [InlineData(typeof(ClassWithItem), typeof(int))]
-    [InlineData(typeof(ClassWithPrivateItem), typeof(object))]
-    [InlineData(typeof(ClassWithStaticItem), typeof(object))]
-    [InlineData(typeof(ClassWithItems), typeof(int))]
-    [InlineData(typeof(ClassWithPrivateItems), typeof(object))]
-    [InlineData(typeof(ClassWithStaticItems), typeof(object))]
-    public void CollectionEditor_Ctor_Type(Type type, Type expectedItemType)
-    {
-        SubCollectionEditor editor = new(type);
-        Assert.Equal(expectedItemType, editor.CollectionItemType);
-        Assert.Same(editor.CollectionItemType, editor.CollectionItemType);
-        Assert.Equal(type, editor.CollectionType);
-        Assert.Null(editor.Context);
-        Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic);
-        Assert.False(editor.IsDropDownResizable);
-        Assert.Equal(new Type[] { expectedItemType }, editor.NewItemTypes);
-    }
-
-    [Fact]
-    public void CollectionEditor_Ctor_NullType()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<ArgumentNullException>("type", () => editor.CollectionItemType);
-        Assert.Null(editor.CollectionType);
-        Assert.Null(editor.Context);
-        Assert.Equal("net.ComponentModel.CollectionEditor", editor.HelpTopic);
-        Assert.False(editor.IsDropDownResizable);
-        Assert.Throws<ArgumentNullException>("type", () => editor.NewItemTypes);
-    }
-
-    [Fact]
-    public void CollectionEditor_CollectionEditor_CancelChanges_Invoke_Nop()
-    {
-        SubCollectionEditor editor = new(null);
-        editor.CancelChanges();
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_TestData()
-    {
-        yield return new object[] { "some string" };
-        yield return new object[] { 123 };
-        yield return new object[] { null };
-        yield return new object[] { new Component() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_TestData))]
-    public void CollectionEditor_CanRemoveInstance_Invoke_ReturnsExpected(object value)
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.True(editor.CanRemoveInstance(value));
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_InheritanceAttribute_TestData()
-    {
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited - 1), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.InheritedReadOnly), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited), true };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited + 1), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_InheritanceAttribute_TestData))]
-    public void CollectionEditor_CanRemoveInstance_InheritanceAttribute_ReturnsExpected(InheritanceAttribute attribute, bool expected)
-    {
-        using Component component = new();
-        TypeDescriptor.AddAttributes(component, attribute);
-        SubCollectionEditor editor = new(null);
-        Assert.Equal(expected, editor.CanRemoveInstance(component));
-    }
-
-    [Fact]
-    public void CollectionEditor_CanSelectMultipleInstances_Invoke_ReturnsFalse()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.True(editor.CanSelectMultipleInstances());
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateCollectionForm_Invoke_Success()
-    {
-        SubCollectionEditor editor = new(typeof(List<int>));
-        Form form = editor.CreateCollectionForm();
-        Assert.NotSame(form, editor.CreateCollectionForm());
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateCollectionForm_NullCollectionType_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<ArgumentNullException>("type", () => editor.CreateCollectionForm());
-    }
-
-    [Theory]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(typeof(int[]), typeof(object))]
-    [InlineData(typeof(IList<int>), typeof(int))]
-    [InlineData(typeof(ClassWithItem), typeof(int))]
-    [InlineData(typeof(ClassWithPrivateItem), typeof(object))]
-    [InlineData(typeof(ClassWithStaticItem), typeof(object))]
-    [InlineData(typeof(ClassWithItems), typeof(int))]
-    [InlineData(typeof(ClassWithPrivateItems), typeof(object))]
-    [InlineData(typeof(ClassWithStaticItems), typeof(object))]
-    public void CollectionEditor_CreateCollectionItemType_Invoke_ReturnsExpected(Type type, Type expected)
-    {
-        SubCollectionEditor editor = new(type);
-        Type itemType = editor.CreateCollectionItemType();
-        Assert.Equal(expected, itemType);
-        Assert.Same(itemType, editor.CreateCollectionItemType());
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateCollectionItemType_NullType_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<ArgumentNullException>("type", () => editor.CreateCollectionItemType());
-    }
-
-    public static IEnumerable<object[]> InvalidDesignerHost_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionEditor_CreateInstance_WithContextWithInvalidDesignerHost_ReturnsExpected(object host)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(host);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Assert.IsType<Component>(editor.CreateInstance(typeof(Component)));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_HostDesigner_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Setup(d => d.Dispose());
-        yield return new object[] { mockDesigner.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_HostDesigner_TestData))]
-    public void CollectionEditor_CreateInstance_WithContextWithHostReturningComponent_CallsCreateComponent(IDesigner designer)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        using Component result = new();
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns(result);
-        mockHost
-            .Setup(h => h.GetDesigner(result))
-            .Returns(designer);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Assert.Same(result, editor.CreateInstance(typeof(Component)));
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_HostDesigner_TestData))]
-    public void CollectionEditor_CreateInstance_WithContextWithHostReturningNullComponent_CallsCreateComponent(IDesigner designer)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns((IComponent)null);
-        mockHost
-            .Setup(h => h.GetDesigner(null))
-            .Returns(designer);
-        mockHost
-            .Setup(c => c.GetService(typeof(TypeDescriptionProvider)))
-            .Returns(null);
-
-        object result = new();
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Assert.IsType<Component>(editor.CreateInstance(typeof(Component)));
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateInstance_WithContextWithHostReturningComponentWithIComponentInitializerDesigner_CallsInitializeNewComponent()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        using Component result = new();
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(d => d.InitializeNewComponent(null))
-            .Verifiable();
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns(result);
-        mockHost
-            .Setup(h => h.GetDesigner(result))
-            .Returns(mockDesigner.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Assert.Same(result, editor.CreateInstance(typeof(Component)));
-        mockComponentInitializer.Verify(d => d.InitializeNewComponent(null), Times.Once());
-    }
-
-    public static IEnumerable<object[]> CreateInstance_InvokeWithoutContext_TestData()
-    {
-        yield return new object[] { typeof(int), 0 };
-        yield return new object[] { typeof(string), string.Empty };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_InvokeWithoutContext_TestData))]
-    public void CollectionEditor_CreateInstance_InvokeWithoutContext_ReturnsExpected(Type type, object expected)
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Equal(expected, editor.CreateInstance(type));
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateInstance_NullItemType_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<ArgumentNullException>("objectType", () => editor.CreateInstance(null));
-    }
-
-    [Theory]
-    [InlineData(typeof(object), new Type[] { typeof(object) })]
-    [InlineData(typeof(int[]), new Type[] { typeof(object) })]
-    [InlineData(typeof(IList<int>), new Type[] { typeof(int) })]
-    [InlineData(typeof(ClassWithItem), new Type[] { typeof(int) })]
-    [InlineData(typeof(ClassWithPrivateItem), new Type[] { typeof(object) })]
-    [InlineData(typeof(ClassWithStaticItem), new Type[] { typeof(object) })]
-    [InlineData(typeof(ClassWithItems), new Type[] { typeof(int) })]
-    [InlineData(typeof(ClassWithPrivateItems), new Type[] { typeof(object) })]
-    [InlineData(typeof(ClassWithStaticItems), new Type[] { typeof(object) })]
-    public void CollectionEditor_CreateNewItemTypes_Invoke_ReturnsExpected(Type type, Type[] expected)
-    {
-        SubCollectionEditor editor = new(type);
-        Type[] itemTypes = editor.CreateNewItemTypes();
-        Assert.Equal(expected, itemTypes);
-        Assert.NotSame(itemTypes, editor.CreateNewItemTypes());
-    }
-
-    [Fact]
-    public void CollectionEditor_CreateNewItemTypes_NullType_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<ArgumentNullException>("type", () => editor.CreateNewItemTypes());
-    }
-
-    public static IEnumerable<object[]> DestroyInstance_NormalObject_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DestroyInstance_NormalObject_TestData))]
-    public void CollectionEditor_DestroyInstance_NormalObject_Nop(object instance)
-    {
-        SubCollectionEditor editor = new(null);
-        editor.DestroyInstance(instance);
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionEditor_DestroyInstance_WithContextWithInvalidDesignerHot_CallsDispose(object host)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(host);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Dispose())
-            .Verifiable();
-        editor.DestroyInstance(mockComponent.Object);
-        mockComponent.Verify(c => c.Dispose(), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_DestroyInstance_WithContextWithInvalidHost_CallsDestroyComponent()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Dispose())
-            .Verifiable();
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.DestroyComponent(mockComponent.Object))
-            .Verifiable();
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        editor.DestroyInstance(mockComponent.Object);
-        mockComponent.Verify(c => c.Dispose(), Times.Never());
-        mockHost.Verify(c => c.DestroyComponent(mockComponent.Object), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_DestroyInstance_IComponentWithoutHost_CallsDispose()
-    {
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Dispose())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(null);
-        editor.DestroyInstance(mockComponent.Object);
-        mockComponent.Verify(c => c.Dispose(), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_DestroyInstance_IDisposable_CallsDispose()
-    {
-        Mock<IDisposable> mockDisposable = new(MockBehavior.Strict);
-        mockDisposable
-            .Setup(d => d.Dispose())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(null);
-        editor.DestroyInstance(mockDisposable.Object);
-        mockDisposable.Verify(d => d.Dispose(), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionEditor_EditValue_ValidProviderInvalidHost_ReturnsValue(object host)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(host);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        mockEditorService.Verify(s => s.ShowDialog(It.IsAny<Form>()), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionEditor_EditValue_ValidProviderValidHost_ReturnsValue(object changeService)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(changeService);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(changeService);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        mockEditorService.Verify(s => s.ShowDialog(It.IsAny<Form>()), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_EditValue_ValidProviderValidHostWithTransactionOK_CallsOnCommit()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("Dispose", It.IsAny<bool>());
-        mockTransaction
-            .Protected()
-            .Setup("OnCommit")
-            .Verifiable();
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns(mockTransaction.Object);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        mockEditorService.Verify(s => s.ShowDialog(It.IsAny<Form>()), Times.Once());
-        mockTransaction.Protected().Verify("OnCommit", Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_EditValue_ValidProviderValidHostWithTransactionNotOK_CallsOnCancel()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.Cancel);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("Dispose", It.IsAny<bool>());
-        mockTransaction
-            .Protected()
-            .Setup("OnCancel")
-            .Verifiable();
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns(mockTransaction.Object);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        mockEditorService.Verify(s => s.ShowDialog(It.IsAny<Form>()), Times.Once());
-        mockTransaction.Protected().Verify("OnCancel", Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_EditValue_ValidProviderValidHostWithIComponentChangeService_ReturnsValue()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IComponentChangeService> mockChangeService = new(MockBehavior.Strict);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(mockChangeService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(mockChangeService.Object);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        mockEditorService.Verify(s => s.ShowDialog(It.IsAny<Form>()), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionEditor_EditValue_NullType_ThrowsArgumentNullException()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(null);
-        object value = new();
-        Assert.Throws<ArgumentNullException>("type", () => editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void CollectionEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Same(value, editor.EditValue(null, provider, value));
-        Assert.Null(editor.Context);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void CollectionEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        CollectionEditor editor = new(null);
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void CollectionEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        CollectionEditor editor = new(null);
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    public static IEnumerable<Object[]> GetDisplayText_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { null, string.Empty, "String" };
-        yield return new object[] { null, "string", "string" };
-
-        yield return new object[] { null, new ClassWithStringName { Name = "CustomName" }, "CustomName" };
-        yield return new object[] { null, new ClassWithStringName { Name = string.Empty }, "ClassWithStringName" };
-        yield return new object[] { null, new ClassWithStringName { Name = null }, "ClassWithStringName" };
-        yield return new object[] { null, new ClassWithNonStringName { Name = 1 }, "ClassWithNonStringName" };
-        yield return new object[] { null, new ClassWithNullToString(), "ClassWithNullToString" };
-
-        yield return new object[] { typeof(int), null, string.Empty };
-        yield return new object[] { typeof(int), "", "String" };
-        yield return new object[] { typeof(int), "value", "value" };
-        yield return new object[] { typeof(int), 1, "1" };
-        yield return new object[] { typeof(int), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithStringDefaultProperty" };
-
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), null, string.Empty };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "CustomName" };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = string.Empty }, "ClassWithStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithStringDefaultProperty), new ClassWithStringDefaultProperty { DefaultProperty = null }, "ClassWithStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithNonStringDefaultProperty), new ClassWithNonStringDefaultProperty { DefaultProperty = 1 }, "ClassWithNonStringDefaultProperty" };
-        yield return new object[] { typeof(ClassWithNoSuchDefaultProperty), new ClassWithNoSuchDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithNoSuchDefaultProperty" };
-        yield return new object[] { typeof(List<ClassWithStringDefaultProperty>), new ClassWithStringDefaultProperty { DefaultProperty = "CustomName" }, "ClassWithStringDefaultProperty" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDisplayText_TestData))]
-    public void CollectionEditor_GetDisplayText_Invoke_ReturnsExpected(Type type, object value, string expected)
-    {
-        SubCollectionEditor editor = new(type);
-        Assert.Equal(expected, editor.GetDisplayText(value));
-    }
-
-    [Fact]
-    public void CollectionEditor_GetDisplayText_ValueDoesntMatchCollectionType_ThrowsTargetException()
-    {
-        SubCollectionEditor editor = new(typeof(ClassWithStringDefaultProperty));
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => editor.GetDisplayText(new ClassWithNonStringDefaultProperty()));
-        Assert.IsType<TargetException>(ex.InnerException);
-    }
-
-    public static IEnumerable<object[]> GetItems_TestData()
-    {
-        yield return new object[] { null, Array.Empty<object>() };
-        yield return new object[] { new object(), Array.Empty<object>() };
-        yield return new object[] { new int[] { 1, 2, 3 }, new object[] { 1, 2, 3, } };
-        yield return new object[] { new ArrayList { 1, 2, 3 }, new object[] { 1, 2, 3, } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetItems_TestData))]
-    public void CollectionEditor_GetItems_Invoke_ReturnsExpected(object editValue, object[] expected)
-    {
-        SubCollectionEditor editor = new(null);
-        object[] items = editor.GetItems(editValue);
-        Assert.Equal(expected, items);
-        Assert.IsType(expected.GetType(), items);
-        Assert.NotSame(editValue, items);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void CollectionEditor_GetService_WithContext_CallsContextGetService(Type serviceType)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        object result = new();
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(serviceType))
-            .Returns(result);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        Assert.Same(result, editor.GetService(serviceType));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void CollectionEditor_GetService_InvokeWithoutContext_ReturnsNull(Type serviceType)
-    {
-        SubCollectionEditor editor = new(serviceType);
-        Assert.Null(editor.GetService(serviceType));
-    }
-
-    public static IEnumerable<object[]> GetObjectsFromInstance_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetObjectsFromInstance_TestData))]
-    public void CollectionEditor_GetObjectsFromInstance_Invoke_ReturnsExpected(object instance)
-    {
-        SubCollectionEditor editor = new(null);
-        IList objects = editor.GetObjectsFromInstance(instance);
-        Assert.Equal(new object[] { instance }, objects);
-        Assert.IsType<ArrayList>(objects);
-        Assert.NotSame(objects, editor.GetObjectsFromInstance(instance));
-    }
-
-    public static IEnumerable<object[]> SetItems_TestData()
-    {
-        yield return new object[] { null, new object[] { 1, 2, 3 }, null };
-        yield return new object[] { null, Array.Empty<object>(), null };
-        yield return new object[] { null, null, null };
-
-        object o = new();
-        yield return new object[] { o, new object[] { 1, 2, 3 }, o };
-        yield return new object[] { o, Array.Empty<object>(), o };
-        yield return new object[] { o, null, o };
-
-        yield return new object[] { new int[] { 1, 2, 3 }, Array.Empty<object>(), new object[] { 0, 0, 0 } };
-        yield return new object[] { new int[] { 1, 2, 3 }, null, new object[] { 0, 0, 0 } };
-
-        yield return new object[] { new ArrayList { 1, 2, 3 }, new object[] { 1 }, new object[] { 1 } };
-        yield return new object[] { new ArrayList { 1, 2, 3 }, Array.Empty<object>(), Array.Empty<object>() };
-        yield return new object[] { new ArrayList { 1, 2, 3 }, null, Array.Empty<object>() };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetItems_TestData))]
-    public void CollectionEditor_SetItems_Invoke_ReturnsExpected(object editValue, object[] value, object expected)
-    {
-        SubCollectionEditor editor = new(null);
-        object items = editor.SetItems(editValue, value);
-        Assert.Equal(expected, items);
-        Assert.Same(editValue, items);
-    }
-
-    [Fact]
-    public void CollectionEditor_SetItems_InvokeArray_ThrowsNotSupportedException()
-    {
-        SubCollectionEditor editor = new(null);
-        Assert.Throws<NotSupportedException>(() => editor.SetItems(new object[1], new object[1]));
-    }
-
-    [Fact]
-    public void CollectionEditor_ShowHelp_NoContext_Nop()
-    {
-        SubCollectionEditor editor = new(typeof(List<int>));
-        editor.ShowHelp();
-    }
-
-    [Fact]
-    public void CollectionEditor_ShowHelp_ValidDesignerHost_CallsShowHelpFromKeyword()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IHelpService> mockHelpService = new(MockBehavior.Strict);
-        mockHelpService
-            .Setup(s => s.ShowHelpFromKeyword("net.ComponentModel.CollectionEditor"))
-            .Verifiable();
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IHelpService)))
-            .Returns(mockHelpService.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        editor.ShowHelp();
-
-        mockHelpService.Verify(s => s.ShowHelpFromKeyword("net.ComponentModel.CollectionEditor"), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionEditor_ShowHelp_InvalidHelpService_Nop(object helpService)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IHelpService)))
-            .Returns(helpService);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        editor.ShowHelp();
-    }
-
-    private class SubCollectionEditor : CollectionEditor
-    {
-        public SubCollectionEditor(Type type) : base(type)
-        {
-        }
-
-        public new Type CollectionItemType => base.CollectionItemType;
-
-        public new Type CollectionType => base.CollectionType;
-
-        public new ITypeDescriptorContext Context => base.Context;
-
-        public new string HelpTopic => base.HelpTopic;
-
-        public new Type[] NewItemTypes => base.NewItemTypes;
-
-        public new void CancelChanges() => base.CancelChanges();
-
-        public new bool CanRemoveInstance(object value) => base.CanRemoveInstance(value);
-
-        public new bool CanSelectMultipleInstances() => base.CanSelectMultipleInstances();
-
-        public new Form CreateCollectionForm() => base.CreateCollectionForm();
-
-        public new Type CreateCollectionItemType() => base.CreateCollectionItemType();
-
-        public new object CreateInstance(Type itemType) => base.CreateInstance(itemType);
-
-        public new Type[] CreateNewItemTypes() => base.CreateNewItemTypes();
-
-        public new void DestroyInstance(object instance) => base.DestroyInstance(instance);
-
-        public new string GetDisplayText(object value) => base.GetDisplayText(value);
-
-        public new object[] GetItems(object editValue) => base.GetItems(editValue);
-
-        public new object GetService(Type serviceType) => base.GetService(serviceType);
-
-        public new IList GetObjectsFromInstance(object instance) => base.GetObjectsFromInstance(instance);
-
-        public new object SetItems(object editValue, object[] value) => base.SetItems(editValue, value);
-
-        public new void ShowHelp() => base.ShowHelp();
-    }
-
-    private class ClassWithItem
-    {
-        public int Item { get; set; }
-    }
-
-    private class ClassWithPrivateItem
-    {
-        private int Item { get; set; }
-    }
-
-    private class ClassWithStaticItem
-    {
-        public static int Item { get; set; }
-    }
-
-    private class ClassWithItems
-    {
-        public int Items { get; set; }
-    }
-
-    private class ClassWithPrivateItems
-    {
-        private int Items { get; set; }
-    }
-
-    private class ClassWithStaticItems
-    {
-        public static int Items { get; set; }
-    }
-
-    private class ClassWithStringName
-    {
-        public string Name { get; set; }
-
-        public override string ToString() => nameof(ClassWithStringName);
-    }
-
-    private class ClassWithNonStringName
-    {
-        public int Name { get; set; }
-
-        public override string ToString() => nameof(ClassWithNonStringName);
-    }
-
-    private class ClassWithNullToString
-    {
-        public int Name { get; set; }
-
-        public override string ToString() => null;
-    }
-
-    [DefaultProperty(nameof(ClassWithStringDefaultProperty.DefaultProperty))]
-    private class ClassWithStringDefaultProperty
-    {
-        public string DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithStringDefaultProperty);
-    }
-
-    [DefaultProperty(nameof(ClassWithNonStringDefaultProperty.DefaultProperty))]
-    private class ClassWithNonStringDefaultProperty
-    {
-        public int DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithNonStringDefaultProperty);
-    }
-
-    [DefaultProperty("NoSuchProperty")]
-    private class ClassWithNoSuchDefaultProperty
-    {
-        public string DefaultProperty { get; set; }
-
-        public override string ToString() => nameof(ClassWithNoSuchDefaultProperty);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionFormTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionFormTests.cs
deleted file mode 100644
index bc8b6ca320a..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/CollectionFormTests.cs
+++ /dev/null
@@ -1,881 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class CollectionFormTests : CollectionEditor
-{
-    public CollectionFormTests() : base(typeof(List<int>))
-    {
-    }
-
-    [Fact]
-    public void CollectionForm_Ctor_CollectionEditor()
-    {
-        CollectionEditor editor = new(typeof(List<int>));
-        SubCollectionForm form = new(editor);
-        Assert.Equal(typeof(int), form.CollectionItemType);
-        Assert.Same(form.CollectionItemType, form.CollectionItemType);
-        Assert.Equal(typeof(List<int>), form.CollectionType);
-        Assert.Null(form.Context);
-        Assert.Null(form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(new Type[] { typeof(int) }, form.NewItemTypes);
-    }
-
-    [Fact]
-    public void CollectionForm_Ctor_NullEditor_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("editor", () => new SubCollectionForm(null));
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void CollectionForm_EditValue_Set_GetReturnsExpected(object value)
-    {
-        CollectionEditor editor = new(typeof(int[]));
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = value
-        };
-        Assert.Same(value, form.EditValue);
-        Assert.Equal(1, form.OnEditValueChangedCallCount);
-
-        // Set same.
-        form.EditValue = value;
-        Assert.Same(value, form.EditValue);
-        Assert.Equal(2, form.OnEditValueChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Items_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<object>() };
-        yield return new object[] { new object[] { 1, 2, 3 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithoutContext_GetReturnsExpected(object[] value)
-    {
-        CollectionEditor editor = new(typeof(int[]));
-        SubCollectionForm form = new(editor)
-        {
-            Items = value
-        };
-        Assert.Null(form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-
-        // Set same.
-        form.Items = value;
-        Assert.Null(form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithEditValue_GetReturnsExpected(object[] value)
-    {
-        SubCollectionEditor editor = new(typeof(List<int>));
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        form.Items = value;
-        Assert.Equal(new object[] { 1, 2 }, form.EditValue);
-        Assert.Equal(new object[] { 1, 2 }, form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-
-        // Set same.
-        form.Items = value;
-        Assert.Equal(new object[] { 1, 2 }, form.EditValue);
-        Assert.Equal(new object[] { 1, 2 }, form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContext_GetReturnsExpected(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(true)
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            Items = value
-        };
-        Assert.Null(form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Once());
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Once());
-
-        // Set same.
-        form.Items = value;
-        Assert.Null(form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Exactly(2));
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContextWithEditValue_GetReturnsExpected(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(true)
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        form.Items = value;
-        Assert.Equal(value ?? Array.Empty<object>(), form.EditValue);
-        Assert.Equal(value ?? Array.Empty<object>(), form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Once());
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Once());
-
-        // Set same.
-        form.Items = value;
-        Assert.Equal(value ?? Array.Empty<object>(), form.EditValue);
-        Assert.Equal(value ?? Array.Empty<object>(), form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Exactly(2));
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContextWithEditValueCustomSetItems_GetReturnsExpected(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(true)
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-
-        CustomSetItemsCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        form.Items = value;
-        Assert.Equal("CustomSetItems", form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(1, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Once());
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Once());
-
-        // Set same.
-        form.Items = value;
-        Assert.Equal("CustomSetItems", form.EditValue);
-        Assert.Empty(form.Items);
-        Assert.Equal(1, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Exactly(2));
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContextWithEditValueFalseOnChanging_GetReturnsExpected(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(false)
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        form.Items = value;
-        Assert.Equal(new object[] { 1, 2 }, form.EditValue);
-        Assert.Equal(new object[] { 1, 2 }, form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Once());
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Never());
-
-        // Set same.
-        form.Items = value;
-        Assert.Equal(new object[] { 1, 2 }, form.EditValue);
-        Assert.Equal(new object[] { 1, 2 }, form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Exactly(2));
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Never());
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContextWithEditValueThrowsCriticalExceptionOnChanging_Rethrows(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(() => throw new StackOverflowException())
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        Assert.Throws<StackOverflowException>(() => form.Items = value);
-    }
-
-    [Theory]
-    [MemberData(nameof(Items_Set_TestData))]
-    public void CollectionForm_Items_SetWithContextWithEditValueThrowsCriticalExceptionOnChanging_CallsDisplayError(object[] value)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        DivideByZeroException exception = new();
-        Mock<IUIService> mockService = new(MockBehavior.Strict);
-        mockService
-            .Setup(s => s.ShowError(exception))
-            .Verifiable();
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.OnComponentChanging())
-            .Returns(() => throw exception)
-            .Verifiable();
-        mockContext
-            .Setup(c => c.OnComponentChanged())
-            .Verifiable();
-        mockContext
-            .Setup(c => c.GetService(typeof(IUIService)))
-            .Returns(mockService.Object);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor)
-        {
-            EditValue = new List<int> { 1, 2 }
-        };
-        form.OnEditValueChangedCallCount = 0;
-
-        form.Items = value;
-        Assert.Equal(new object[] { 1, 2 }, form.EditValue);
-        Assert.Equal(new object[] { 1, 2 }, form.Items);
-        Assert.Equal(0, form.OnEditValueChangedCallCount);
-        mockContext.Verify(c => c.OnComponentChanging(), Times.Once());
-        mockContext.Verify(c => c.OnComponentChanged(), Times.Never());
-        mockService.Verify(s => s.ShowError(exception), Times.Once());
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_TestData()
-    {
-        yield return new object[] { "some string" };
-        yield return new object[] { 123 };
-        yield return new object[] { null };
-        yield return new object[] { new Component() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_TestData))]
-    public void CollectionForm_CanRemoveInstance_Invoke_ReturnsExpected(object value)
-    {
-        SubCollectionEditor editor = new(null);
-        SubCollectionForm form = new(editor);
-        Assert.True(form.CanRemoveInstance(value));
-    }
-
-    public static IEnumerable<object[]> CanRemoveInstance_InheritanceAttribute_TestData()
-    {
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited - 1), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.Inherited), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.InheritedReadOnly), false };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited), true };
-        yield return new object[] { new InheritanceAttribute(InheritanceLevel.NotInherited + 1), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanRemoveInstance_InheritanceAttribute_TestData))]
-    public void CollectionForm_CanRemoveInstance_InheritanceAttribute_ReturnsExpected(InheritanceAttribute attribute, bool expected)
-    {
-        using Component component = new();
-        TypeDescriptor.AddAttributes(component, attribute);
-        SubCollectionEditor editor = new(null);
-        SubCollectionForm form = new(editor);
-        Assert.Equal(expected, form.CanRemoveInstance(component));
-    }
-
-    [Fact]
-    public void CollectionForm_CanSelectMultipleInstances_Invoke_ReturnsFalse()
-    {
-        SubCollectionEditor editor = new(null);
-        SubCollectionForm form = new(editor);
-        Assert.True(form.CanSelectMultipleInstances());
-    }
-
-    public static IEnumerable<object[]> InvalidDesignerHost_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(InvalidDesignerHost_TestData))]
-    public void CollectionForm_CreateInstance_WithContextWithInvalidDesignerHost_ReturnsExpected(object host)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(host);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        Assert.IsType<Component>(form.CreateInstance(typeof(Component)));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_HostDesigner_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Setup(d => d.Dispose());
-        yield return new object[] { mockDesigner.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_HostDesigner_TestData))]
-    public void CollectionForm_CreateInstance_WithContextWithHostReturningComponent_CallsCreateComponent(IDesigner designer)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        using Component result = new();
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns(result);
-        mockHost
-            .Setup(h => h.GetDesigner(result))
-            .Returns(designer);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        Assert.Same(result, form.CreateInstance(typeof(Component)));
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_HostDesigner_TestData))]
-    public void CollectionForm_CreateInstance_WithContextWithHostReturningNullComponent_CallsCreateComponent(IDesigner designer)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns((IComponent)null);
-        mockHost
-            .Setup(h => h.GetDesigner(null))
-            .Returns(designer);
-        mockHost
-            .Setup(c => c.GetService(typeof(TypeDescriptionProvider)))
-            .Returns(null);
-
-        object result = new();
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        Assert.IsType<Component>(form.CreateInstance(typeof(Component)));
-    }
-
-    [Fact]
-    public void CollectionForm_CreateInstance_WithContextWithHostReturningComponentWithIComponentInitializerDesigner_CallsInitializeNewComponent()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        using Component result = new();
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(d => d.InitializeNewComponent(null))
-            .Verifiable();
-
-        Mock<IDesignerHost> mockHost = new(MockBehavior.Strict);
-        mockHost
-            .Setup(h => h.CreateTransaction("Add or remove Int32 objects"))
-            .Returns((DesignerTransaction)null);
-        mockHost
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockHost
-            .Setup(h => h.CreateComponent(typeof(Component), null))
-            .Returns(result);
-        mockHost
-            .Setup(h => h.GetDesigner(result))
-            .Returns(mockDesigner.Object);
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(mockHost.Object);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        Assert.Same(result, form.CreateInstance(typeof(Component)));
-        mockComponentInitializer.Verify(d => d.InitializeNewComponent(null), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionForm_CreateInstance_InvokeWithoutContext_ReturnsExpected()
-    {
-        SubCollectionEditor editor = new(null);
-        SubCollectionForm form = new(editor);
-        Assert.Equal(0, form.CreateInstance(typeof(int)));
-    }
-
-    [Fact]
-    public void CollectionForm_CreateInstance_NullItemType_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(null);
-        SubCollectionForm form = new(editor);
-        Assert.Throws<ArgumentNullException>("objectType", () => form.CreateInstance(null));
-    }
-
-    [Fact]
-    public void CollectionForm_DisplayError_InvokeWithContextWithIUIService_CallsShowError()
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        Exception exception = new();
-        Mock<IUIService> mockService = new(MockBehavior.Strict);
-        mockService
-            .Setup(s => s.ShowError(exception))
-            .Verifiable();
-
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IUIService)))
-            .Returns(mockService.Object);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object editValue = new();
-        Assert.Same(editValue, editor.EditValue(mockContext.Object, mockServiceProvider.Object, editValue));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        form.DisplayError(exception);
-        mockService.Verify(s => s.ShowError(exception), Times.Once());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void CollectionForm_GetService_WithContext_CallsContextGetService(Type serviceType)
-    {
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(It.IsAny<Form>()))
-            .Returns(DialogResult.OK);
-
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object);
-
-        object result = new();
-        Mock<ITypeDescriptorContext> mockContext = new(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockContext
-            .Setup(c => c.GetService(serviceType))
-            .Returns(result);
-
-        SubCollectionEditor editor = new(typeof(List<int>));
-        object value = new();
-        Assert.Same(value, editor.EditValue(mockContext.Object, mockServiceProvider.Object, value));
-        Assert.Same(mockContext.Object, editor.Context);
-
-        SubCollectionForm form = new(editor);
-        Assert.Same(result, form.GetService(serviceType));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void CollectionForm_GetService_InvokeWithoutContext_ReturnsNull(Type serviceType)
-    {
-        SubCollectionEditor editor = new(serviceType);
-        SubCollectionForm form = new(editor);
-        Assert.Null(form.GetService(serviceType));
-    }
-
-    [Fact]
-    public void CollectionForm_ShowEditorDialog_Invoke_Success()
-    {
-        SubCollectionEditor editor = new(typeof(List<int>));
-        SubCollectionForm form = new(editor);
-
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        mockEditorService
-            .Setup(s => s.ShowDialog(form))
-            .Returns(DialogResult.OK);
-        Assert.Equal(DialogResult.OK, form.ShowEditorDialog(mockEditorService.Object));
-        mockEditorService.Verify(s => s.ShowDialog(form), Times.Once());
-    }
-
-    [Fact]
-    public void CollectionForm_ShowEditorDialog_NullEdSvc_ThrowsArgumentNullException()
-    {
-        SubCollectionEditor editor = new(typeof(List<int>));
-        SubCollectionForm form = new(editor);
-        Assert.Throws<ArgumentNullException>("edSvc", () => form.ShowEditorDialog(null));
-    }
-
-    private class SubCollectionEditor : CollectionEditor
-    {
-        public SubCollectionEditor(Type type) : base(type)
-        {
-        }
-
-        public new ITypeDescriptorContext Context => base.Context;
-    }
-
-    private class CustomSetItemsCollectionEditor : CollectionEditor
-    {
-        public CustomSetItemsCollectionEditor(Type type) : base(type)
-        {
-        }
-
-        public new ITypeDescriptorContext Context => base.Context;
-
-        protected override object SetItems(object editValue, object[] value) => "CustomSetItems";
-    }
-
-    private class SubCollectionForm : CollectionForm
-    {
-        public SubCollectionForm(CollectionEditor editor) : base(editor)
-        {
-        }
-
-        public new Type CollectionItemType => base.CollectionItemType;
-
-        public new Type CollectionType => base.CollectionType;
-
-        public new ITypeDescriptorContext Context => base.Context;
-
-        public new object[] Items
-        {
-            get => base.Items;
-            set => base.Items = value;
-        }
-
-        public new Type[] NewItemTypes => base.NewItemTypes;
-
-        public new bool CanRemoveInstance(object value) => base.CanRemoveInstance(value);
-
-        public new bool CanSelectMultipleInstances() => base.CanSelectMultipleInstances();
-
-        public new object CreateInstance(Type itemType) => base.CreateInstance(itemType);
-
-        public new void DestroyInstance(object instance) => base.DestroyInstance(instance);
-
-        public new void DisplayError(Exception e) => base.DisplayError(e);
-
-        public new object GetService(Type serviceType) => base.GetService(serviceType);
-
-        public new DialogResult ShowEditorDialog(IWindowsFormsEditorService edSvc) => base.ShowEditorDialog(edSvc);
-
-        public int OnEditValueChangedCallCount { get; set; }
-
-        protected override void OnEditValueChanged() => OnEditValueChangedCallCount++;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ComponentDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ComponentDesignerTests.cs
deleted file mode 100644
index dbf1d4bafdc..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ComponentDesignerTests.cs
+++ /dev/null
@@ -1,3032 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Configuration;
-using Moq;
-using Moq.Protected;
-using System.Windows.Forms.TestUtilities;
-using System.Windows.Forms.Design.Tests.Mocks;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ComponentDesignerTests
-{
-    [Fact]
-    public void ComponentDesigner_Ctor_Default()
-    {
-        using SubComponentDesigner designer = new();
-        Assert.Empty(designer.ActionLists);
-        Assert.Same(designer.ActionLists, designer.ActionLists);
-        Assert.Empty(designer.AssociatedComponents);
-        Assert.Null(designer.Component);
-        Assert.Same(InheritanceAttribute.Default, designer.InheritanceAttribute);
-        Assert.Same(designer.InheritanceAttribute, designer.InheritanceAttribute);
-        Assert.False(designer.Inherited);
-        Assert.Null(designer.ParentComponent);
-        Assert.NotNull(designer.ShadowProperties);
-        Assert.Same(designer.ShadowProperties, designer.ShadowProperties);
-        Assert.Empty(designer.Verbs);
-        Assert.Same(designer.Verbs, designer.Verbs);
-    }
-
-    [Fact]
-    public void ComponentDesigner_Children_GetDefault_ReturnsExpected()
-    {
-        using ComponentDesigner designer = new();
-        ITreeDesigner treeDesigner = designer;
-        Assert.Empty(treeDesigner.Children);
-    }
-
-    [Fact]
-    public void ComponentDesigner_GetService_ReturnsExpected()
-    {
-        using ComponentDesigner designer = new();
-
-        var service = designer.GetService<IDesignerHost>();
-        Assert.Null(service);
-
-        using Component component = new();
-        designer.Initialize(component);
-
-        service = designer.GetService<IDesignerHost>();
-        Assert.Null(service);
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(component);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-
-        service = designer.GetService<IDesignerHost>();
-        Assert.NotNull(service);
-    }
-
-    [Fact]
-    public void ComponentDesigner_PostFilterProperties_Success()
-    {
-        using SubComponentDesigner designer = new();
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        designer.PostFilterProperties(properties);
-        PropertyDescriptor result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.Same(descriptor, result);
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(component);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-
-        designer.PostFilterProperties(properties);
-        result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.NotSame(descriptor, result);
-    }
-
-    [Fact]
-    public void ComponentDesigner_Children_GetWithValidHostValidResult_ReturnsExpected()
-    {
-        Mock<IComponent> mockComponent1 = new(MockBehavior.Strict);
-        Mock<IComponent> mockComponent2 = new(MockBehavior.Strict);
-        Mock<IDesigner> mockDesigner1 = new(MockBehavior.Strict);
-        Mock<IDesigner> mockDesigner2 = new(MockBehavior.Strict);
-        using CustomAssociatedComponentsComponentDesigner designer = new(
-            new object[] { mockComponent1.Object, mockComponent2.Object });
-        ITreeDesigner treeDesigner = designer;
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(mockComponent1.Object))
-            .Returns(mockDesigner1.Object)
-            .Verifiable();
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(mockComponent2.Object))
-            .Returns(mockDesigner2.Object)
-            .Verifiable();
-
-        using Component component = new()
-        {
-            Site = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object).Object
-        };
-
-        designer.Initialize(component);
-        Assert.Equal(new object[] { mockDesigner1.Object, mockDesigner2.Object }, treeDesigner.Children);
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent1.Object), Times.Once());
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent2.Object), Times.Once());
-
-        // Call again to test caching behavior.
-        Assert.Equal(new object[] { mockDesigner1.Object, mockDesigner2.Object }, treeDesigner.Children);
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent1.Object), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent2.Object), Times.Exactly(2));
-    }
-
-    [Fact]
-    public void ComponentDesigner_Children_GetWithValidHostInvalidResult_ReturnsExpected()
-    {
-        Mock<IComponent> mockComponent1 = new(MockBehavior.Strict);
-        Mock<IComponent> mockComponent2 = new(MockBehavior.Strict);
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        using CustomAssociatedComponentsComponentDesigner designer = new(
-            new object[] { new object(), null, mockComponent1.Object, mockComponent2.Object });
-        ITreeDesigner treeDesigner = designer;
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(mockComponent1.Object))
-            .Returns(mockDesigner.Object)
-            .Verifiable();
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(mockComponent2.Object))
-            .Returns<IDesigner>(null)
-            .Verifiable();
-
-        using Component component = new()
-        {
-            Site = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object).Object
-        };
-
-        designer.Initialize(component);
-        Assert.Equal(new object[] { mockDesigner.Object }, treeDesigner.Children);
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent1.Object), Times.Once());
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent2.Object), Times.Once());
-
-        // Call again to test caching behavior.
-        Assert.Equal(new object[] { mockDesigner.Object }, treeDesigner.Children);
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent1.Object), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.GetDesigner(mockComponent2.Object), Times.Exactly(2));
-    }
-
-    public static IEnumerable<object[]> Children_GetInvalidService_TestData()
-    {
-        foreach (ICollection associatedComponents in new object[] { null, Array.Empty<object>(), new object[] { new Component() } })
-        {
-            yield return new object[] { associatedComponents, null };
-            yield return new object[] { associatedComponents, new object() };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Children_GetInvalidService_TestData))]
-    public void ComponentDesigner_Children_GetWithInvalidDesignerHost_ReturnsEmpty(ICollection associatedComponents, object host)
-    {
-        using CustomAssociatedComponentsComponentDesigner designer = new(associatedComponents);
-        ITreeDesigner treeDesigner = designer;
-
-        using Component component = new()
-        {
-            Site = MockSite.CreateMockSiteWithDesignerHost(host).Object
-        };
-
-        designer.Initialize(component);
-        Assert.Empty(treeDesigner.Children);
-    }
-
-    public static IEnumerable<object[]> InheritanceAttribute_GetValidService_TestData()
-    {
-        yield return new object[] { null, 3, 5 };
-        yield return new object[] { new InheritanceAttribute(), 1, 1 };
-    }
-
-    private static Mock<ISite> CreateMockSiteWithInheritanceService(object inheritanceService)
-    {
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(inheritanceService);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        return mockSite;
-    }
-
-    [Theory]
-    [MemberData(nameof(InheritanceAttribute_GetValidService_TestData))]
-    public void ComponentDesigner_InheritanceAttribute_GetWithValidService_ReturnsDefault(InheritanceAttribute attributeResult, int expectedCallCount1, int expectedCallCount2)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        Mock<IInheritanceService> mockInheritanceService = new(MockBehavior.Strict);
-        mockInheritanceService
-            .Setup(s => s.GetInheritanceAttribute(component))
-            .Returns(attributeResult)
-            .Verifiable();
-        var mockSite = CreateMockSiteWithInheritanceService(mockInheritanceService.Object);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IInheritanceService)), Times.Exactly(expectedCallCount1));
-
-        InheritanceAttribute attribute = designer.InheritanceAttribute;
-        Assert.Same(attributeResult, attribute);
-        Assert.Same(attribute, designer.InheritanceAttribute);
-        mockSite.Verify(s => s.GetService(typeof(IInheritanceService)), Times.Exactly(expectedCallCount2));
-    }
-
-    public static IEnumerable<object[]> InheritanceAttribute_GetInvalidService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(InheritanceAttribute_GetInvalidService_TestData))]
-    public void ComponentDesigner_InheritanceAttribute_GetWithInvalidService_ReturnsDefault(object inheritanceService)
-    {
-        using SubComponentDesigner designer = new();
-        var mockSite = CreateMockSiteWithInheritanceService(inheritanceService);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IInheritanceService)), Times.Once());
-
-        InheritanceAttribute attribute = designer.InheritanceAttribute;
-        Assert.Same(InheritanceAttribute.Default, attribute);
-        Assert.Same(attribute, designer.InheritanceAttribute);
-        mockSite.Verify(s => s.GetService(typeof(IInheritanceService)), Times.Once());
-    }
-
-    public static IEnumerable<object[]> Inherited_Get_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { InheritanceAttribute.Default, false };
-        yield return new object[] { InheritanceAttribute.Inherited, true };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, true };
-        yield return new object[] { InheritanceAttribute.NotInherited, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Inherited_Get_TestData))]
-    public void ComponentDesigner_Inherited_Get_ReturnsExpected(InheritanceAttribute inheritanceAttribute, bool expected)
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(inheritanceAttribute);
-        Assert.Equal(expected, designer.Inherited);
-    }
-
-    public static IEnumerable<object[]> ParentComponent_ValidService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Component() };
-    }
-
-    [Theory]
-    [MemberData(nameof(ParentComponent_ValidService_TestData))]
-    public void ComponentDesigner_ParentComponent_GetWithValidService_ReturnsExpected(Component rootComponent)
-    {
-        using SubComponentDesigner designer = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(rootComponent);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-
-        Assert.Same(rootComponent, designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(2));
-
-        // Get again.
-        Assert.Same(rootComponent, designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(3));
-    }
-
-    [Fact]
-    public void ComponentDesigner_ParentComponent_GetWithValidServiceRootComponentEqual_ReturnsNull()
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(component);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-
-        Assert.Null(designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(2));
-
-        // Get again.
-        Assert.Null(designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(3));
-    }
-
-    public static IEnumerable<object[]> ParentComponent_InvalidService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(ParentComponent_InvalidService_TestData))]
-    public void ComponentDesigner_ParentComponent_GetWithInvalidService_ReturnsNull(object host)
-    {
-        using SubComponentDesigner designer = new();
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(host);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-
-        Assert.Null(designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-
-        // Get again.
-        Assert.Null(designer.ParentComponent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-    }
-
-    [Theory]
-    [MemberData(nameof(ParentComponent_ValidService_TestData))]
-    public void ComponentDesigner_ITreeDesignerParent_GetWithValidService_ReturnsExpected(Component rootComponent)
-    {
-        using SubComponentDesigner designer = new();
-        ITreeDesigner treeDesigner = designer;
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(rootComponent);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(rootComponent))
-            .Returns(designer)
-            .Verifiable();
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-        mockDesignerHost.Verify(h => h.GetDesigner(rootComponent), Times.Never());
-
-        Assert.Same(rootComponent is null ? null : designer, treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(rootComponent is null ? 2 : 3));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.GetDesigner(rootComponent), Times.Exactly(rootComponent is null ? 0 : 1));
-
-        // Get again.
-        Assert.Same(rootComponent is null ? null : designer, treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(rootComponent is null ? 3 : 5));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.GetDesigner(rootComponent), Times.Exactly(rootComponent is null ? 0 : 2));
-    }
-
-    [Fact]
-    public void ComponentDesigner_ITreeDesignerParent_GetWithValidServiceRootComponentEqual_ReturnsNull()
-    {
-        using ComponentDesigner designer = new();
-        ITreeDesigner treeDesigner = designer;
-        using Component component = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(component);
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(2));
-
-        // Get again.
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(3));
-    }
-
-    [Theory]
-    [MemberData(nameof(ParentComponent_InvalidService_TestData))]
-    public void ComponentDesigner_ITreeDesignerParent_GetWithInvalidServiceFirstCall_ReturnsNull(object host)
-    {
-        using SubComponentDesigner designer = new();
-        ITreeDesigner treeDesigner = designer;
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(host);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-
-        // Get again.
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-    }
-
-    [Theory]
-    [MemberData(nameof(ParentComponent_InvalidService_TestData))]
-    public void ComponentDesigner_ITreeDesignerParent_GetWithInvalidServiceSecondCall_ReturnsNull(object host)
-    {
-        using SubComponentDesigner designer = new();
-        ITreeDesigner treeDesigner = designer;
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(new Component());
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        int callCount = 0;
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(() =>
-            {
-                callCount++;
-                if (callCount < 3)
-                {
-                    return mockDesignerHost.Object;
-                }
-                else
-                {
-                    return host;
-                }
-            });
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-
-        // Get again.
-        Assert.Null(treeDesigner.Parent);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(4));
-    }
-
-    [Fact]
-    public void ComponentDesigner_Dispose_InvokeWithComponent_Success()
-    {
-        using ComponentDesigner designer = new();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns((ISite)null);
-        mockComponent
-            .Setup(c => c.Dispose())
-            .Verifiable();
-        designer.Initialize(mockComponent.Object);
-        Assert.Same(mockComponent.Object, designer.Component);
-
-        designer.Dispose();
-        Assert.Null(designer.Component);
-        mockComponent.Verify(c => c.Dispose(), Times.Never());
-
-        // Dispose again.
-        designer.Dispose();
-        Assert.Null(designer.Component);
-        mockComponent.Verify(c => c.Dispose(), Times.Never());
-    }
-
-    public static IEnumerable<object[]> Dispose_InvokeWithComponentChangeService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Mock<IComponentChangeService>(MockBehavior.Strict).Object };
-    }
-
-    private static Mock<ISite> CreateMockSiteWithComponentChangeService(object componentChangeService)
-    {
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(componentChangeService);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        return mockSite;
-    }
-
-    [Theory]
-    [MemberData(nameof(Dispose_InvokeWithComponentChangeService_TestData))]
-    public void ComponentDesigner_Dispose_InvokeWithComponentChangeService_Success(object componentChangeService)
-    {
-        using ComponentDesigner designer = new();
-        using Component component = new()
-        {
-            Site = CreateMockSiteWithComponentChangeService(componentChangeService).Object
-        };
-        designer.Initialize(component);
-        Assert.Same(component, designer.Component);
-
-        designer.Dispose();
-        Assert.Null(designer.Component);
-
-        // Dispose again.
-        designer.Dispose();
-        Assert.Null(designer.Component);
-    }
-
-    [Fact]
-    public void ComponentDesigner_Dispose_InvokeWithoutComponent_Success()
-    {
-        using ComponentDesigner designer = new();
-        designer.Dispose();
-        Assert.Null(designer.Component);
-
-        // Dispose again.
-        designer.Dispose();
-        Assert.Null(designer.Component);
-    }
-
-    [Theory]
-    [BoolData]
-    public void ComponentDesigner_Dispose_InvokeBoolWithComponent_Success(bool disposing)
-    {
-        using SubComponentDesigner designer = new();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns((ISite)null);
-        mockComponent
-            .Setup(c => c.Dispose())
-            .Verifiable();
-        designer.Initialize(mockComponent.Object);
-        Assert.Same(mockComponent.Object, designer.Component);
-
-        designer.Dispose(disposing);
-        Assert.Same(disposing ? null : mockComponent.Object, designer.Component);
-        mockComponent.Verify(c => c.Dispose(), Times.Never());
-
-        // Dispose again.
-        designer.Dispose(disposing);
-        Assert.Same(disposing ? null : mockComponent.Object, designer.Component);
-        mockComponent.Verify(c => c.Dispose(), Times.Never());
-    }
-
-    public static IEnumerable<object[]> Dispose_InvokeBoolWithComponentChangeService_TestData()
-    {
-        foreach (bool disposing in new bool[] { true, false })
-        {
-            yield return new object[] { null, disposing };
-            yield return new object[] { new object(), disposing };
-            yield return new object[] { new Mock<IComponentChangeService>(MockBehavior.Strict), disposing };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Dispose_InvokeBoolWithComponentChangeService_TestData))]
-    public void ComponentDesigner_Dispose_InvokeBoolWithComponentChangeService_Success(object componentChangeService, bool disposing)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new()
-        {
-            Site = CreateMockSiteWithComponentChangeService(componentChangeService).Object
-        };
-        designer.Initialize(component);
-        Assert.Same(component, designer.Component);
-
-        designer.Dispose(disposing);
-        Assert.Same(disposing ? null : component, designer.Component);
-
-        // Dispose again.
-        designer.Dispose(disposing);
-        Assert.Same(disposing ? null : component, designer.Component);
-    }
-
-    [Theory]
-    [BoolData]
-    public void ComponentDesigner_Dispose_InvokeBoolWithoutComponent_Success(bool disposing)
-    {
-        using SubComponentDesigner designer = new();
-        designer.Dispose(disposing);
-        Assert.Null(designer.Component);
-
-        // Dispose again.
-        designer.Dispose(disposing);
-        Assert.Null(designer.Component);
-    }
-
-    [Fact]
-    public void ComponentDesigner_DoDefaultAction_InvokeDefault_Nop()
-    {
-        using ComponentDesigner designer = new();
-        designer.DoDefaultAction();
-
-        // Call again.
-        designer.DoDefaultAction();
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_ValidProperty_TestData()
-    {
-        foreach (string property in new string[] { nameof(DefaultEventComponent.StringProperty) })
-        {
-            yield return new object[] { property, null, 1, null };
-            yield return new object[] { property, null, 1, string.Empty };
-            yield return new object[] { property, null, 1, "UniqueMethod" };
-
-            yield return new object[] { property, Array.Empty<object>(), 1, null };
-            yield return new object[] { property, Array.Empty<object>(), 1, string.Empty };
-            yield return new object[] { property, Array.Empty<object>(), 1, "UniqueMethod" };
-
-            yield return new object[] { property, new object[] { null, new object(), "NoSuchStringValue" }, 1, null };
-            yield return new object[] { property, new object[] { null, new object(), "NoSuchStringValue" }, 1, string.Empty };
-            yield return new object[] { property, new object[] { null, new object(), "NoSuchStringValue" }, 1, "UniqueMethod" };
-
-            // Should not call if in the compatible methods list.
-            yield return new object[] { property, new object[] { "StringValue" }, 0, null };
-            yield return new object[] { property, new object[] { "StringValue" }, 0, string.Empty };
-            yield return new object[] { property, new object[] { "StringValue" }, 0, "UniqueMethod" };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_ValidProperty_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithComponentWithHostValidProperty_Success(string property, ICollection compatibleMethods, int expectedSetCallCount, string uniqueMethodName)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component1 = new()
-        {
-            StringProperty = "StringValue"
-        };
-        using DefaultEventComponent component2 = new()
-        {
-            StringProperty = string.Empty
-        };
-        using DefaultEventComponent component3 = new()
-        {
-            StringProperty = null
-        };
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[property])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()))
-            .Returns(uniqueMethodName)
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Returns(compatibleMethods)
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component1, component2, component3 });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns<DesignerTransaction>(null)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(rootComponent);
-        component1.StringPropertySetCount = 0;
-        component2.StringPropertySetCount = 0;
-        component3.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(3));
-        mockEventBindingService.Verify(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()), Times.Once());
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component1.StringProperty);
-        Assert.Equal(expectedSetCallCount, component1.StringPropertySetCount);
-        Assert.Empty(component2.StringProperty);
-        Assert.Equal(1, component2.StringPropertySetCount);
-        Assert.Equal(uniqueMethodName, component3.StringProperty);
-        Assert.Equal(1, component3.StringPropertySetCount);
-
-        // Call again.
-        component1.StringProperty = "StringValue";
-        component2.StringProperty = string.Empty;
-        component3.StringProperty = null;
-        component1.StringPropertySetCount = 0;
-        component2.StringPropertySetCount = 0;
-        component3.StringPropertySetCount = 0;
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(6));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(6));
-        mockEventBindingService.Verify(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(4));
-        Assert.Equal("StringValue", component1.StringProperty);
-        Assert.Equal(expectedSetCallCount, component1.StringPropertySetCount);
-        Assert.Empty(component2.StringProperty);
-        Assert.Equal(1, component2.StringPropertySetCount);
-        Assert.Equal(uniqueMethodName, component3.StringProperty);
-        Assert.Equal(1, component3.StringPropertySetCount);
-    }
-
-    [Theory]
-    [InlineData(null, null, 0)]
-    [InlineData(null, "", 1)]
-    [InlineData(null, "name", 1)]
-    [InlineData("", "", 1)]
-    [InlineData("name", "name", 1)]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithRootComponent_CallsShowCode(string value, string uniqueName, int expectedCallCount)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = value
-        };
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Returns(Array.Empty<object>());
-        mockEventBindingService
-            .Setup(s => s.CreateUniqueMethodName(component, It.IsAny<EventDescriptor>()))
-            .Returns(uniqueName);
-        mockEventBindingService
-            .Setup(s => s.ShowCode(component, It.IsAny<EventDescriptor>()))
-            .Returns(false)
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns<DesignerTransaction>(null)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        component.Site = mockSite.Object;
-        designer.Initialize(component);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        mockEventBindingService.Verify(s => s.ShowCode(component, It.IsAny<EventDescriptor>()), Times.Exactly(expectedCallCount));
-        Assert.Equal(uniqueName, component.StringProperty);
-        Assert.Equal(1, component.StringPropertySetCount);
-
-        // Call again.
-        component.StringPropertySetCount = 0;
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.ShowCode(component, It.IsAny<EventDescriptor>()), Times.Exactly(expectedCallCount * 2));
-        Assert.Equal(uniqueName, component.StringProperty);
-        Assert.Equal(1, component.StringPropertySetCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_ValidProperty_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithComponentWithHostValidPropertyWithTransaction_Success(string property, ICollection compatibleMethods, int expectedSetCallCount, string uniqueMethodName)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component1 = new()
-        {
-            StringProperty = "StringValue"
-        };
-        using DefaultEventComponent component2 = new()
-        {
-            StringProperty = string.Empty
-        };
-        using DefaultEventComponent component3 = new()
-        {
-            StringProperty = null
-        };
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("OnCommit")
-            .Verifiable();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[property])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()))
-            .Returns(uniqueMethodName)
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Returns(compatibleMethods)
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { null, new object(), component1, component2, component3 });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns(mockTransaction.Object)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(rootComponent);
-        component1.StringPropertySetCount = 0;
-        component2.StringPropertySetCount = 0;
-        component3.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(3));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        mockEventBindingService.Verify(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()), Times.Once());
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockTransaction.Protected().Verify("OnCommit", Times.Once());
-        Assert.Equal("StringValue", component1.StringProperty);
-        Assert.Equal(expectedSetCallCount, component1.StringPropertySetCount);
-        Assert.Empty(component2.StringProperty);
-        Assert.Equal(1, component2.StringPropertySetCount);
-        Assert.Equal(uniqueMethodName, component3.StringProperty);
-        Assert.Equal(1, component3.StringPropertySetCount);
-
-        // Call again.
-        component1.StringProperty = "StringValue";
-        component2.StringProperty = string.Empty;
-        component3.StringProperty = null;
-        component1.StringPropertySetCount = 0;
-        component2.StringPropertySetCount = 0;
-        component3.StringPropertySetCount = 0;
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(6));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.CreateUniqueMethodName(component3, It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(4));
-        mockTransaction.Protected().Verify("OnCommit", Times.Once());
-        Assert.Equal("StringValue", component1.StringProperty);
-        Assert.Equal(expectedSetCallCount, component1.StringPropertySetCount);
-        Assert.Empty(component2.StringProperty);
-        Assert.Equal(1, component2.StringPropertySetCount);
-        Assert.Equal(uniqueMethodName, component3.StringProperty);
-        Assert.Equal(1, component3.StringPropertySetCount);
-    }
-
-    [Fact]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithCanceledThrowingCreateTransaction_Success()
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component, new DefaultEventComponent() });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Throws(CheckoutException.Canceled)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_NotCanceledException_TestData()
-    {
-        yield return new object[] { new CheckoutException() };
-        yield return new object[] { new DivideByZeroException() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_NotCanceledException_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithNotCanceledThrowingCreateTransaction_Rethrows(Exception exception)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component, new DefaultEventComponent() });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Throws(exception)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        Assert.Throws(exception.GetType(), () => designer.DoDefaultAction());
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        Assert.Throws(exception.GetType(), () => designer.DoDefaultAction());
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    [Fact]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithInvalidOperationExceptionThrowingCreateTransaction_Catches()
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("OnCancel")
-            .Verifiable();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component, new DefaultEventComponent() });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Throws(new InvalidOperationException())
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    [Fact]
-    public void ComponentDesigner_DoDefaultAction_InvokeThrowsInvalidOperationException_CallsCancel()
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("OnCancel")
-            .Verifiable();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Throws(new InvalidOperationException())
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component, new DefaultEventComponent() });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns(mockTransaction.Object)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        mockTransaction.Protected().Verify("OnCancel", Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        mockTransaction.Protected().Verify("OnCancel", Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_NonInvalidOperationException_TestData()
-    {
-        yield return new object[] { new CheckoutException() };
-        yield return new object[] { CheckoutException.Canceled };
-        yield return new object[] { new DivideByZeroException() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_NonInvalidOperationException_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeThrowsNonInvalidOperationException_CallsCommit(Exception exception)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<DesignerTransaction> mockTransaction = new(MockBehavior.Strict);
-        mockTransaction
-            .Protected()
-            .Setup("OnCommit")
-            .Verifiable();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Throws(exception)
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component, new DefaultEventComponent() });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns(mockTransaction.Object)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        Assert.Throws(exception.GetType(), () => designer.DoDefaultAction());
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Once());
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Once());
-        mockTransaction.Protected().Verify("OnCommit", Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        Assert.Throws(exception.GetType(), () => designer.DoDefaultAction());
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.CreateTransaction(It.IsAny<string>()), Times.Exactly(2));
-        mockTransaction.Protected().Verify("OnCommit", Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_InvalidProperty_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.ReadOnlyProperty)] };
-        yield return new object[] { TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.IntProperty)] };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_InvalidProperty_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithComponentWithHostInvalidProperty_Success(PropertyDescriptor property)
-    {
-        using ComponentDesigner designer = new();
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(property)
-            .Verifiable();
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component });
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        mockDesignerHost
-            .Setup(h => h.CreateTransaction(It.IsAny<string>()))
-            .Returns<DesignerTransaction>(null)
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(0, component.StringPropertySetCount);
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_InvalidSelectedComponents_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<object>() };
-        yield return new object[] { new object[] { null, new object() } };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_InvalidSelectedComponents_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeWithComponentWithHostInvalidSelectedComponents_Success(ICollection selectedComponents)
-    {
-        using ComponentDesigner designer = new();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(selectedComponents);
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns<IComponent>(null);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(rootComponent);
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_InvalidEventBindingService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_InvalidEventBindingService_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeInvalidEventBindingService_Nop(object eventBindingService)
-    {
-        using ComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(eventBindingService)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_InvalidSelectionService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_InvalidSelectionService_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeInvalidSelectionService_Nop(object selectionService)
-    {
-        using ComponentDesigner designer = new();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(selectionService)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(component);
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-
-        // Call again.
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-    }
-
-    public static IEnumerable<object[]> DoDefaultAction_InvalidDesignerHost_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(DoDefaultAction_InvalidDesignerHost_TestData))]
-    public void ComponentDesigner_DoDefaultAction_InvokeInvalidDesignerHost_Success(object designerHost)
-    {
-        using DefaultEventComponent component = new()
-        {
-            StringProperty = "StringValue"
-        };
-        using ComponentDesigner designer = new();
-        Mock<IEventBindingService> mockEventBindingService = new(MockBehavior.Strict);
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetSelectedComponents())
-            .Returns(new object[] { component });
-        mockEventBindingService
-            .Setup(s => s.GetEventProperty(It.IsAny<EventDescriptor>()))
-            .Returns(TypeDescriptor.GetProperties(typeof(DefaultEventComponent))[nameof(DefaultEventComponent.StringProperty)])
-            .Verifiable();
-        mockEventBindingService
-            .Setup(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()))
-            .Returns(Array.Empty<object>())
-            .Verifiable();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(designerHost);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component rootComponent = new()
-        {
-            Site = mockSite.Object
-        };
-        designer.Initialize(rootComponent);
-        component.StringPropertySetCount = 0;
-
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Once());
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Once());
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Once());
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(1, component.StringPropertySetCount);
-
-        // Call again.
-        component.StringPropertySetCount = 0;
-        designer.DoDefaultAction();
-        mockSite.Verify(s => s.GetService(typeof(IEventBindingService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetSelectedComponents(), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetEventProperty(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        mockEventBindingService.Verify(s => s.GetCompatibleMethods(It.IsAny<EventDescriptor>()), Times.Exactly(2));
-        Assert.Equal("StringValue", component.StringProperty);
-        Assert.Equal(1, component.StringPropertySetCount);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void ComponentDesigner_GetService_InvokeWithComponentWithSite_ReturnsNull(Type serviceType)
-    {
-        object service = new();
-        using SubComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(serviceType))
-            .Returns(service)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        Assert.Same(service, designer.GetService(serviceType));
-        mockSite.Verify(s => s.GetService(serviceType), Times.Once());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void ComponentDesigner_GetService_InvokeWithComponentWithoutSite_ReturnsNull(Type serviceType)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        designer.Initialize(component);
-        Assert.Null(designer.GetService(serviceType));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void ComponentDesigner_GetService_InvokeWithoutComponent_ReturnsNull(Type serviceType)
-    {
-        using SubComponentDesigner designer = new();
-        Assert.Null(designer.GetService(serviceType));
-    }
-
-    [Fact]
-    public void ComponentDesigner_Initialize_Invoke_Success()
-    {
-        using ComponentDesigner designer = new();
-        using Component component = new();
-        designer.Initialize(component);
-        Assert.Same(component, designer.Component);
-        Assert.Empty(designer.AssociatedComponents);
-
-        // Override with null.
-        designer.Initialize(null);
-        Assert.Null(designer.Component);
-        Assert.Empty(designer.AssociatedComponents);
-    }
-
-    [Fact]
-    public void ComponentDesigner_Initialize_RootComponent_Success()
-    {
-        using Component component = new();
-        using ComponentDesigner designer = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(component);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        component.Site = mockSite.Object;
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IInheritanceService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IDictionaryService)), Times.Exactly(4));
-        mockSite.Verify(s => s.GetService(typeof(IExtenderListService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(ITypeDescriptorFilterService)), Times.Once());
-    }
-
-    public static IEnumerable<object[]> Initialize_NonRootComponent_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), new object() };
-
-        Mock<IDesignerHost> mockNullDesignerHost = new(MockBehavior.Strict);
-        mockNullDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns((IComponent)null);
-        yield return new object[] { mockNullDesignerHost.Object, null };
-
-        Mock<IDesignerHost> mockNonNullDesignerHost = new(MockBehavior.Strict);
-        mockNonNullDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(new Component());
-        yield return new object[] { mockNonNullDesignerHost.Object, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Initialize_NonRootComponent_TestData))]
-    public void ComponentDesigner_Initialize_NonRootComponent_Success(object host, object componentChangeService)
-    {
-        using ComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(host);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(componentChangeService);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(DesignerCommandSet)), Times.Never());
-    }
-
-    [Fact]
-    public void ComponentDesigner_Initialize_NullInheritanceAttribute_Success()
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(null);
-        using Component component = new();
-        designer.Initialize(component);
-        Assert.Same(component, designer.Component);
-        Assert.Empty(designer.AssociatedComponents);
-    }
-
-    [Fact]
-    public void ComponentDesigner_Initialize_InvokeIServiceContainerSiteWithNullDesignerCommandSet_CallsAddService()
-    {
-        using ComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(null)
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        DesignerCommandSet set = null;
-        mockSite
-            .As<IServiceContainer>()
-            .Setup(c => c.AddService(typeof(DesignerCommandSet), It.IsAny<DesignerCommandSet>()))
-            .Callback<Type, object>((t, s) => set = Assert.IsAssignableFrom<DesignerCommandSet>(s))
-            .Verifiable();
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(DesignerCommandSet)), Times.Once());
-        mockSite.As<IServiceContainer>().Verify(s => s.AddService(typeof(DesignerCommandSet), set), Times.Once());
-        Assert.Same(designer.ActionLists, set.GetCommands("ActionLists"));
-        Assert.Same(designer.Verbs, set.GetCommands("Verbs"));
-        Assert.Null(set.GetCommands("Other"));
-        Assert.Null(set.GetCommands(string.Empty));
-        Assert.Null(set.GetCommands(null));
-    }
-
-    public static IEnumerable<object[]> Initialize_NonNullDesignerCommandSet_TestData()
-    {
-        yield return new object[] { new object() };
-        yield return new object[] { new DesignerCommandSet() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Initialize_NonNullDesignerCommandSet_TestData))]
-    public void ComponentDesigner_Initialize_InvokeIServiceContainerSiteWithNonNullDesignerCommandSet_DoesNotCallAddService(object designerCommandSet)
-    {
-        using ComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(designerCommandSet)
-            .Verifiable();
-        mockSite
-            .As<IServiceContainer>()
-            .Setup(c => c.AddService(typeof(DesignerCommandSet), It.IsAny<DesignerCommandSet>()))
-            .Verifiable();
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockSite.Verify(s => s.GetService(typeof(DesignerCommandSet)), Times.Once());
-        mockSite.As<IServiceContainer>().Verify(s => s.AddService(typeof(DesignerCommandSet), It.IsAny<DesignerCommandSet>()), Times.Never());
-    }
-
-    [Fact]
-    public void ComponentDesigner_ParentComponent_GetWithHost_ReturnsExpected()
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        designer.Initialize(component);
-    }
-
-    public static IEnumerable<object[]> IDictionary_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Dictionary<int, int>() };
-    }
-
-    [Theory]
-    [MemberData(nameof(IDictionary_TestData))]
-    public void ComponentDesigner_InitializeExistingComponent_Invoke_ThrowsNotImplementedException(IDictionary defaultValues)
-    {
-        using ComponentDesigner designer = new();
-        Assert.Throws<NotImplementedException>(() => designer.InitializeExistingComponent(defaultValues));
-    }
-
-    [Theory]
-    [MemberData(nameof(IDictionary_TestData))]
-    public void ComponentDesigner_InitializeNewComponent_Invoke_Nop(IDictionary defaultValues)
-    {
-        using ComponentDesigner designer = new();
-        designer.InitializeNewComponent(defaultValues);
-    }
-
-#pragma warning disable 0618
-    [Fact]
-    public void ComponentDesigner_InitializeNonDefault_Invoke_Nop()
-    {
-        using ComponentDesigner designer = new();
-        designer.InitializeNonDefault();
-    }
-#pragma warning restore 0618
-
-    [Fact]
-    public void ComponentDesigner_InvokeGetInheritanceAttribute_InvokeNonNullToInvoke_ReturnsExpected()
-    {
-        using SubComponentDesigner designer = new();
-        Assert.Same(designer.InheritanceAttribute, designer.InvokeGetInheritanceAttribute(designer));
-    }
-
-    [Fact]
-    public void ComponentDesigner_InvokeGetInheritanceAttribute_InvokeNullToInvoke_ReturnsNull()
-    {
-        using SubComponentDesigner designer = new();
-        Assert.Null(designer.InvokeGetInheritanceAttribute(null));
-    }
-
-    public static IEnumerable<object[]> PreFilterProperties_ComponentWithoutKey_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Dictionary<string, object>() };
-        yield return new object[] { new Dictionary<string, object> { { "SettingsKey", new object() } } };
-        yield return new object[] { new Dictionary<string, object> { { "SettingsKey", null } } };
-    }
-
-    [Fact]
-    public void ComponentDesigner_PreFilterProperties_WithComponentWithKey_Success()
-    {
-        using SubComponentDesigner designer = new();
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        designer.PreFilterProperties(properties);
-        PropertyDescriptor result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.NotSame(descriptor, result);
-        Assert.Equal(typeof(ComponentDesigner), result.ComponentType);
-        Assert.Equal(descriptor.Name, result.Name);
-        Assert.True(descriptor.Attributes.Count >= 7);
-        Assert.True(result.Attributes.Count >= 8);
-    }
-
-    [Fact]
-    public void ComponentDesigner_PreFilterProperties_WithIPersistComponentSettingsComponentWithKey_Success()
-    {
-        using SubComponentDesigner designer = new();
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        designer.PreFilterProperties(properties);
-        PropertyDescriptor result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.NotSame(descriptor, result);
-        Assert.Equal(typeof(ComponentDesigner), result.ComponentType);
-        Assert.Equal(descriptor.Name, result.Name);
-        Assert.True(descriptor.Attributes.Count >= 7);
-        Assert.True(result.Attributes.Count >= 8);
-    }
-
-    [Theory]
-    [MemberData(nameof(PreFilterProperties_ComponentWithoutKey_TestData))]
-    public void ComponentDesigner_PreFilterProperties_WithIPersistComponentSettingsComponentWithoutKey_Success(IDictionary properties)
-    {
-        using SubComponentDesigner designer = new();
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        object oldValue = properties?["SettingsKey"];
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        designer.PreFilterProperties(properties);
-        Assert.Same(oldValue, properties?["SettingsKey"]);
-    }
-
-    [Fact]
-    public void ComponentDesigner_PreFilterProperties_WithNonIPersistComponentSettingsComponent_Nop()
-    {
-        using SubComponentDesigner designer = new();
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using Component component = new();
-        designer.Initialize(component);
-        designer.PreFilterProperties(properties);
-        Assert.Same(descriptor, properties["SettingsKey"]);
-    }
-
-    [Theory]
-    [MemberData(nameof(IDictionary_TestData))]
-    public void ComponentDesigner_PreFilterProperties_WithoutComponent_Nop(IDictionary properties)
-    {
-        using SubComponentDesigner designer = new();
-        designer.PreFilterProperties(properties);
-    }
-
-    public static IEnumerable<object[]> PostFilterAttributes_NoInheritanceAttribute_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { null, new Dictionary<Type, object>(), null };
-        yield return new object[] { InheritanceAttribute.Default, null, null };
-        yield return new object[] { InheritanceAttribute.Default, new Dictionary<Type, object>(), null };
-        yield return new object[] { InheritanceAttribute.Inherited, null, null };
-        yield return new object[] { InheritanceAttribute.Inherited, new Dictionary<Type, object>(), InheritanceAttribute.Inherited };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, null, null };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, new Dictionary<Type, object>(), InheritanceAttribute.InheritedReadOnly };
-        yield return new object[] { InheritanceAttribute.NotInherited, null, null };
-        yield return new object[] { InheritanceAttribute.NotInherited, new Dictionary<Type, object>(), null };
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterAttributes_NoInheritanceAttribute_TestData))]
-    public void ComponentDesigner_PostFilterAttributes_NoInheritanceAttribute_AddsToAttributes(InheritanceAttribute attribute, IDictionary attributes, object expected)
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(attribute);
-        designer.PostFilterAttributes(attributes);
-        Assert.Same(expected, attributes?[typeof(InheritanceAttribute)]);
-    }
-
-    public static IEnumerable<object[]> PostFilterAttributes_TestData()
-    {
-        yield return new object[] { null, InheritanceAttribute.Default };
-        yield return new object[] { new Dictionary<Type, object>(), InheritanceAttribute.Default };
-        yield return new object[] { new Dictionary<Type, object> { { typeof(InheritanceAttribute), null } }, InheritanceAttribute.Default };
-        yield return new object[] { new Dictionary<Type, object> { { typeof(InheritanceAttribute), new object() } }, InheritanceAttribute.Default };
-        InheritanceAttribute attribute = new();
-        yield return new object[] { new Dictionary<Type, object> { { typeof(InheritanceAttribute), attribute } }, attribute };
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterAttributes_TestData))]
-    public void ComponentDesigner_PostFilterAttributes_HasInheritanceAttributeKey_Sets(IDictionary attributes, object expected)
-    {
-        using SubComponentDesigner designer = new();
-        designer.PostFilterAttributes(attributes);
-        Assert.Same(expected, designer.InheritanceAttribute);
-    }
-
-    public static IEnumerable<object[]> PostFilterEvents_HasEvents_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { InheritanceAttribute.Default, false };
-        yield return new object[] { InheritanceAttribute.Inherited, false };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, true };
-        yield return new object[] { InheritanceAttribute.NotInherited, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterEvents_HasEvents_TestData))]
-    public void ComponentDesigner_PostFilterEvents_InvokeWithEvents_Success(InheritanceAttribute inheritanceAttribute, bool valid)
-    {
-        EventDescriptor descriptor = TypeDescriptor.GetEvents(typeof(CustomComponent))[0];
-        Dictionary<object, object> events = new() { { "key1", descriptor }, { "Key2", null } };
-        using CustomInheritanceAttributeComponentDesigner designer = new(inheritanceAttribute);
-        designer.PostFilterEvents(events);
-        if (valid)
-        {
-            EventDescriptor result = Assert.IsAssignableFrom<EventDescriptor>(events["Event"]);
-            Assert.Equal(typeof(CustomComponent), result.ComponentType);
-            Assert.Equal("Event", result.Name);
-            Assert.True(Assert.IsType<ReadOnlyAttribute>(result.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-            Assert.Equal(new Dictionary<object, object> { { "key1", descriptor }, { "Key2", null }, { "Event", result } }, events);
-        }
-        else
-        {
-            Assert.Equal(new Dictionary<object, object> { { "key1", descriptor }, { "Key2", null } }, events);
-        }
-    }
-
-    public static IEnumerable<object[]> PostFilterEvents_NoEvents_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { null, new Dictionary<string, object>(), new Dictionary<string, object>() };
-        yield return new object[] { InheritanceAttribute.Default, new Dictionary<string, object>(), new Dictionary<string, object>() };
-        yield return new object[] { InheritanceAttribute.Default, new Dictionary<string, object>(), new Dictionary<string, object>() };
-        yield return new object[] { InheritanceAttribute.Inherited, null, null };
-        yield return new object[] { InheritanceAttribute.Inherited, new Dictionary<string, object>(), new Dictionary<string, object>() };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, null, null };
-        yield return new object[] { InheritanceAttribute.InheritedReadOnly, new Dictionary<string, object>(), new Dictionary<string, object>() };
-        yield return new object[] { InheritanceAttribute.NotInherited, null, null };
-        yield return new object[] { InheritanceAttribute.NotInherited, new Dictionary<string, object>(), new Dictionary<string, object>() };
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterEvents_NoEvents_TestData))]
-    public void ComponentDesigner_PostFilterEvents_InvokeWithoutEvents_Success(InheritanceAttribute inheritanceAttribute, IDictionary events, IDictionary expected)
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(inheritanceAttribute);
-        designer.PostFilterEvents(events);
-        Assert.Equal(expected, events);
-    }
-
-    [Fact]
-    public void ComponentDesigner_PostFilterEvents_InvokeWithInvalidEvents_ThrowsArrayTypeMismatchException()
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(InheritanceAttribute.InheritedReadOnly);
-        Assert.Throws<ArrayTypeMismatchException>(() => designer.PostFilterEvents(new Dictionary<object, object> { { "key", new object() } }));
-    }
-
-    public static IEnumerable<object[]> RaiseComponentChanged_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { TypeDescriptor.GetProperties(typeof(CustomComponent))[0], new object(), new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanged_TestData))]
-    public void ComponentDesigner_RaiseComponentChanged_InvokeWithValidService_CallsOnOnComponentChanged(MemberDescriptor member, object oldValue, object newValue)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        mockComponentChangeService
-            .Setup(s => s.OnComponentChanged(component, member, oldValue, newValue))
-            .Verifiable();
-        var mockSite = CreateMockSiteWithComponentChangeService(mockComponentChangeService.Object);
-        component.Site = mockSite.Object;
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        designer.RaiseComponentChanged(member, oldValue, newValue);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Exactly(2));
-        mockComponentChangeService.Verify(s => s.OnComponentChanged(component, member, oldValue, newValue), Times.Once());
-    }
-
-    public static IEnumerable<object[]> RaiseComponentChanged_InvalidService_TestData()
-    {
-        foreach (object componentChangeService in new object[] { null, new object() })
-        {
-            yield return new object[] { componentChangeService, null, null, null };
-            yield return new object[] { componentChangeService, TypeDescriptor.GetProperties(typeof(CustomComponent))[0], new object(), new object() };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanged_InvalidService_TestData))]
-    public void ComponentDesigner_RaiseComponentChanged_InvokeWithInvalidService_CallsOnOnComponentChanged(object componentChangeService, MemberDescriptor member, object oldValue, object newValue)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        var mockSite = CreateMockSiteWithComponentChangeService(componentChangeService);
-        component.Site = mockSite.Object;
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        designer.RaiseComponentChanged(member, oldValue, newValue);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanged_TestData))]
-    public void ComponentDesigner_RaiseComponentChanged_InvokeWithoutComponent_Nop(MemberDescriptor member, object oldValue, object newValue)
-    {
-        using SubComponentDesigner designer = new();
-        designer.RaiseComponentChanged(member, oldValue, newValue);
-    }
-
-    public static IEnumerable<object[]> RaiseComponentChanging_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { TypeDescriptor.GetProperties(typeof(CustomComponent))[0] };
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanging_TestData))]
-    public void ComponentDesigner_RaiseComponentChanging_InvokeWithValidService_CallsOnOnComponentChanged(MemberDescriptor member)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        mockComponentChangeService
-            .Setup(s => s.OnComponentChanging(component, member))
-            .Verifiable();
-        var mockSite = CreateMockSiteWithComponentChangeService(mockComponentChangeService.Object);
-        component.Site = mockSite.Object;
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        designer.RaiseComponentChanging(member);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Exactly(2));
-        mockComponentChangeService.Verify(s => s.OnComponentChanging(component, member), Times.Once());
-    }
-
-    public static IEnumerable<object[]> RaiseComponentChanging_InvalidService_TestData()
-    {
-        foreach (object componentChangeService in new object[] { null, new object() })
-        {
-            yield return new object[] { componentChangeService, null };
-            yield return new object[] { componentChangeService, TypeDescriptor.GetProperties(typeof(CustomComponent))[0] };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanging_InvalidService_TestData))]
-    public void ComponentDesigner_RaiseComponentChanging_InvokeWithInvalidService_CallsOnOnComponentChanged(object componentChangeService, MemberDescriptor member)
-    {
-        using SubComponentDesigner designer = new();
-        using Component component = new();
-        var mockSite = CreateMockSiteWithComponentChangeService(componentChangeService);
-        component.Site = mockSite.Object;
-
-        designer.Initialize(component);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Once());
-        designer.RaiseComponentChanging(member);
-        mockSite.Verify(s => s.GetService(typeof(IComponentChangeService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(RaiseComponentChanging_TestData))]
-    public void ComponentDesigner_RaiseComponentChanging_InvokeWithoutComponent_Nop(MemberDescriptor member)
-    {
-        using SubComponentDesigner designer = new();
-        designer.RaiseComponentChanging(member);
-    }
-
-#pragma warning disable 0618
-    [Theory]
-    [InlineData(null, null, null)]
-    [InlineData(null, "", "")]
-    [InlineData(null, "NewValue", "NewValue")]
-    [InlineData("", null, null)]
-    [InlineData("", "", "")]
-    [InlineData("", "NewValue", "NewValue")]
-    [InlineData("OldValue", null, "OldValue")]
-    [InlineData("OldValue", "", "OldValue")]
-    [InlineData("OldValue", "NewValue", "OldValue")]
-    public void ComponentDesigner_OnSetComponentDefaults_InvokeWithComponentWithDefaultProperty_Nop(string oldValue, string siteName, string expectedValue)
-    {
-        using ComponentDesigner designer = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(siteName);
-        mockSite
-            .SetupGet(s => s.Container)
-            .Returns((IContainer)null);
-        using StringDefaultPropertyComponent component = new()
-        {
-            Site = mockSite.Object,
-            Value = oldValue
-        };
-        designer.Initialize(component);
-        designer.OnSetComponentDefaults();
-        Assert.Equal(expectedValue, component.Value);
-    }
-
-    public static IEnumerable<object[]> OnSetComponentDefaults_InvalidComponent_TestData()
-    {
-        yield return new object[] { new Component() };
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        yield return new object[] { new Component { Site = mockSite.Object } };
-        yield return new object[] { new IntDefaultPropertyComponent { Site = mockSite.Object } };
-    }
-
-    [Theory]
-    [MemberData(nameof(OnSetComponentDefaults_InvalidComponent_TestData))]
-    public void ComponentDesigner_OnSetComponentDefaults_InvokeWithInvalidComponent_Nop(Component component)
-    {
-        using ComponentDesigner designer = new();
-        designer.Initialize(component);
-        designer.OnSetComponentDefaults();
-    }
-
-    [Fact]
-    public void ComponentDesigner_OnSetComponentDefaults_InvokeWithComponentWithoutSite_Nop()
-    {
-        using ComponentDesigner designer = new();
-        using Component component = new();
-        designer.Initialize(component);
-        designer.OnSetComponentDefaults();
-    }
-
-    [Fact]
-    public void ComponentDesigner_OnSetComponentDefaults_InvokeWithoutComponent_Nop()
-    {
-        using ComponentDesigner designer = new();
-        designer.OnSetComponentDefaults();
-    }
-#pragma warning restore 0618
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPreFilterAttributes_Invoke_CallsProtectedVirtualMethod()
-    {
-        Mock<ComponentDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Protected()
-            .Setup("PreFilterAttributes", ItExpr.IsAny<IDictionary>())
-            .Verifiable();
-        IDesignerFilter filter = mockDesigner.Object;
-
-        filter.PreFilterAttributes(new Dictionary<string, object>());
-
-        mockDesigner.Protected().Verify("PreFilterAttributes", Times.Once(), ItExpr.IsAny<IDictionary>());
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPreFilterEvents_Invoke_CallsProtectedVirtualMethod()
-    {
-        Mock<ComponentDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Protected()
-            .Setup("PreFilterEvents", ItExpr.IsAny<IDictionary>())
-            .Verifiable();
-        IDesignerFilter filter = mockDesigner.Object;
-
-        filter.PreFilterEvents(new Dictionary<string, object>());
-
-        mockDesigner.Protected().Verify("PreFilterEvents", Times.Once(), ItExpr.IsAny<IDictionary>());
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPreFilterProperties_WithComponentWithKey_Success()
-    {
-        using SubComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        filter.PreFilterProperties(properties);
-        PropertyDescriptor result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.NotSame(descriptor, result);
-        Assert.Equal(typeof(ComponentDesigner), result.ComponentType);
-        Assert.Equal(descriptor.Name, result.Name);
-        Assert.True(descriptor.Attributes.Count >= 7);
-        Assert.True(result.Attributes.Count >= 8);
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPreFilterProperties_WithIPersistComponentSettingsComponentWithKey_Success()
-    {
-        using SubComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        filter.PreFilterProperties(properties);
-        PropertyDescriptor result = (PropertyDescriptor)properties["SettingsKey"];
-        Assert.NotSame(descriptor, result);
-        Assert.Equal(typeof(ComponentDesigner), result.ComponentType);
-        Assert.Equal(descriptor.Name, result.Name);
-        Assert.True(descriptor.Attributes.Count >= 7);
-        Assert.True(result.Attributes.Count >= 8);
-    }
-
-    [Theory]
-    [MemberData(nameof(PreFilterProperties_ComponentWithoutKey_TestData))]
-    public void ComponentDesigner_IDesignerFilterPreFilterProperties_WithIPersistComponentSettingsComponentWithoutKey_Success(IDictionary properties)
-    {
-        using SubComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        object oldValue = properties?["SettingsKey"];
-        using IPersistComponentSettingsComponent component = new();
-        designer.Initialize(component);
-        filter.PreFilterProperties(properties);
-        Assert.Same(oldValue, properties?["SettingsKey"]);
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPreFilterProperties_WithNonIPersistComponentSettingsComponent_Nop()
-    {
-        using ComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(CustomComponent))[0];
-        Dictionary<string, PropertyDescriptor> properties = new()
-        {
-            { "SettingsKey", descriptor }
-        };
-        using Component component = new();
-        designer.Initialize(component);
-        filter.PreFilterProperties(properties);
-        Assert.Same(descriptor, properties["SettingsKey"]);
-    }
-
-    [Theory]
-    [MemberData(nameof(IDictionary_TestData))]
-    public void ComponentDesigner_IDesignerFilterPreFilterProperties_WithoutComponent_Nop(IDictionary properties)
-    {
-        using ComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        filter.PreFilterProperties(properties);
-    }
-
-    [Fact]
-    public void IDesignerFilterPreFilterProperties_Invoke_CallsProtectedVirtualMethod()
-    {
-        Mock<ComponentDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Protected()
-            .Setup("PreFilterProperties", ItExpr.IsAny<IDictionary>())
-            .Verifiable();
-        IDesignerFilter filter = mockDesigner.Object;
-
-        filter.PreFilterProperties(new Dictionary<string, object>());
-
-        mockDesigner.Protected().Verify("PreFilterProperties", Times.Once(), ItExpr.IsAny<IDictionary>());
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterAttributes_NoInheritanceAttribute_TestData))]
-    public void ComponentDesigner_IDesignerFilterPostFilterAttributes_NoInheritanceAttribute_AddsToAttributes(InheritanceAttribute attribute, IDictionary attributes, object expected)
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(attribute);
-        IDesignerFilter filter = designer;
-        filter.PostFilterAttributes(attributes);
-        Assert.Same(expected, attributes?[typeof(InheritanceAttribute)]);
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterAttributes_TestData))]
-    public void ComponentDesigner_IDesignerFilterPostFilterAttributes_HasInheritanceAttributeKey_Sets(IDictionary attributes, object expected)
-    {
-        using SubComponentDesigner designer = new();
-        IDesignerFilter filter = designer;
-        filter.PostFilterAttributes(attributes);
-        Assert.Same(expected, designer.InheritanceAttribute);
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPostFilterAttributes_Invoke_CallsProtectedVirtualMethod()
-    {
-        Mock<ComponentDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Protected()
-            .SetupGet<InheritanceAttribute>("InheritanceAttribute")
-            .Returns(InheritanceAttribute.Default);
-        mockDesigner
-            .Protected()
-            .Setup("PostFilterAttributes", ItExpr.IsAny<IDictionary>())
-            .Verifiable();
-        IDesignerFilter filter = mockDesigner.Object;
-
-        filter.PostFilterAttributes(new Dictionary<string, object>());
-
-        mockDesigner.Protected().Verify("PostFilterAttributes", Times.Once(), ItExpr.IsAny<IDictionary>());
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterEvents_HasEvents_TestData))]
-    public void ComponentDesigner_IDesignerFilterPostFilterEvents_InvokeWithEvents_Success(InheritanceAttribute inheritanceAttribute, bool valid)
-    {
-        EventDescriptor descriptor = TypeDescriptor.GetEvents(typeof(CustomComponent))[0];
-        Dictionary<object, object> events = new() { { "key1", descriptor }, { "Key2", null } };
-        using CustomInheritanceAttributeComponentDesigner designer = new(inheritanceAttribute);
-        IDesignerFilter filter = designer;
-        filter.PostFilterEvents(events);
-        if (valid)
-        {
-            EventDescriptor result = Assert.IsAssignableFrom<EventDescriptor>(events["Event"]);
-            Assert.Equal(typeof(CustomComponent), result.ComponentType);
-            Assert.Equal("Event", result.Name);
-            Assert.True(Assert.IsType<ReadOnlyAttribute>(result.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-            Assert.Equal(new Dictionary<object, object> { { "key1", descriptor }, { "Key2", null }, { "Event", result } }, events);
-        }
-        else
-        {
-            Assert.Equal(new Dictionary<object, object> { { "key1", descriptor }, { "Key2", null } }, events);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(PostFilterEvents_NoEvents_TestData))]
-    public void ComponentDesigner_IDesignerFilterPostFilterEvents_InvokeWithoutEvents_Success(InheritanceAttribute inheritanceAttribute, IDictionary events, IDictionary expected)
-    {
-        using CustomInheritanceAttributeComponentDesigner designer = new(inheritanceAttribute);
-        IDesignerFilter filter = designer;
-        filter.PostFilterEvents(events);
-        Assert.Equal(expected, events);
-    }
-
-    [Fact]
-    public void ComponentDesigner_IDesignerFilterPostFilterEvents_InvokeWithInvalidEvents_ThrowsArrayTypeMismatchException()
-    {
-        CustomInheritanceAttributeComponentDesigner designer = new(InheritanceAttribute.InheritedReadOnly);
-        IDesignerFilter filter = designer;
-        Assert.Throws<ArrayTypeMismatchException>(() => filter.PostFilterEvents(new Dictionary<object, object> { { "key", new object() } }));
-    }
-
-    [Fact]
-    public void PostFilterEvents_Invoke_CallsProtectedVirtualMethod()
-    {
-        Mock<ComponentDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner
-            .Protected()
-            .SetupGet<InheritanceAttribute>("InheritanceAttribute")
-            .Returns(InheritanceAttribute.Default);
-        mockDesigner
-            .Protected()
-            .Setup("PostFilterEvents", ItExpr.IsAny<IDictionary>())
-            .Verifiable();
-        IDesignerFilter filter = mockDesigner.Object;
-
-        filter.PostFilterEvents(new Dictionary<string, object>());
-
-        mockDesigner.Protected().Verify("PostFilterEvents", Times.Once(), ItExpr.IsAny<IDictionary>());
-    }
-
-    private class SubComponentDesigner : ComponentDesigner
-    {
-        public new InheritanceAttribute InheritanceAttribute => base.InheritanceAttribute;
-
-        public new bool Inherited => base.Inherited;
-
-        public new IComponent ParentComponent => base.ParentComponent;
-
-        public new object ShadowProperties => base.ShadowProperties;
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new object GetService(Type serviceType) => base.GetService(serviceType);
-
-        public new InheritanceAttribute InvokeGetInheritanceAttribute(ComponentDesigner toInvoke) => base.InvokeGetInheritanceAttribute(toInvoke);
-
-        public new void PreFilterAttributes(IDictionary attributes) => base.PreFilterAttributes(attributes);
-
-        public new void PreFilterEvents(IDictionary events) => base.PreFilterEvents(events);
-
-        public new void PreFilterProperties(IDictionary properties) => base.PreFilterProperties(properties);
-
-        public new void PostFilterAttributes(IDictionary attributes) => base.PostFilterAttributes(attributes);
-
-        public new void PostFilterEvents(IDictionary events) => base.PostFilterEvents(events);
-
-        public new void PostFilterProperties(IDictionary properties) => base.PostFilterProperties(properties);
-
-        public new void RaiseComponentChanged(MemberDescriptor member, object oldValue, object newValue)
-        {
-            base.RaiseComponentChanged(member, oldValue, newValue);
-        }
-
-        public new void RaiseComponentChanging(MemberDescriptor member) => base.RaiseComponentChanging(member);
-    }
-
-    private class CustomAssociatedComponentsComponentDesigner : ComponentDesigner
-    {
-        private readonly ICollection _associatedComponents;
-
-        public CustomAssociatedComponentsComponentDesigner(ICollection associatedComponents)
-        {
-            _associatedComponents = associatedComponents;
-        }
-
-        public override ICollection AssociatedComponents => _associatedComponents;
-    }
-
-    private class CustomInheritanceAttributeComponentDesigner : ComponentDesigner
-    {
-        private InheritanceAttribute _inheritanceAttribute;
-
-        public CustomInheritanceAttributeComponentDesigner(InheritanceAttribute inheritanceAttribute) : base()
-        {
-            _inheritanceAttribute = inheritanceAttribute;
-        }
-
-        protected override InheritanceAttribute InheritanceAttribute => _inheritanceAttribute;
-
-        public new bool Inherited => base.Inherited;
-
-        public new void PostFilterAttributes(IDictionary attributes) => base.PostFilterAttributes(attributes);
-
-        public new void PostFilterEvents(IDictionary events) => base.PostFilterEvents(events);
-
-        public new void PostFilterProperties(IDictionary events) => base.PostFilterProperties(events);
-    }
-
-    private class IPersistComponentSettingsComponent : Component, IPersistComponentSettings
-    {
-        public bool SaveSettings { get; set; }
-
-        public string SettingsKey { get; set; }
-
-        public void LoadComponentSettings() => throw new NotImplementedException();
-
-        public void ResetComponentSettings() => throw new NotImplementedException();
-
-        public void SaveComponentSettings() => throw new NotImplementedException();
-    }
-
-    private class CustomComponent : Component
-    {
-        [EditorBrowsable(EditorBrowsableState.Advanced)]
-        public int Property { get; set; }
-
-        public event EventHandler Event
-        {
-            add { }
-            remove { }
-        }
-    }
-
-    [DefaultProperty(nameof(StringDefaultPropertyComponent.Value))]
-    private class StringDefaultPropertyComponent : Component
-    {
-        public string Value { get; set; }
-    }
-
-    [DefaultProperty(nameof(IntDefaultPropertyComponent.Value))]
-    private class IntDefaultPropertyComponent : Component
-    {
-        public int Value { get; set; }
-    }
-
-    [DefaultEvent(nameof(DefaultEventComponent.Event))]
-    private class DefaultEventComponent : Component
-    {
-        private string _stringProperty;
-
-        public event EventHandler Event
-        {
-            add { }
-            remove { }
-        }
-
-        public object ObjectProperty
-        {
-            get => StringProperty;
-            set => StringProperty = (string)value;
-        }
-
-        public string StringProperty
-        {
-            get => _stringProperty;
-            set
-            {
-                StringPropertySetCount++;
-                _stringProperty = value;
-            }
-        }
-
-        public int StringPropertySetCount { get; set; }
-
-        public int IntProperty { get; set; }
-
-        public object ReadOnlyProperty { get; }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignSurfaceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignSurfaceTests.cs
deleted file mode 100644
index 5109bcfb2a9..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignSurfaceTests.cs
+++ /dev/null
@@ -1,1895 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Reflection;
-using System.Windows.Forms.Design;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignSurfaceTests
-{
-    [WinFormsFact]
-    public void DesignSurface_Ctor_Default()
-    {
-        using SubDesignSurface surface = new();
-        Assert.NotNull(surface.ComponentContainer);
-        Assert.Empty(surface.ComponentContainer.Components);
-        Assert.False(surface.DtelLoading);
-        Assert.False(surface.Host.CanReloadWithErrors);
-        Assert.Same(surface.Host, surface.Host.Container);
-        Assert.False(surface.Host.Loading);
-        Assert.False(surface.Host.IgnoreErrorsDuringReload);
-        Assert.False(surface.Host.InTransaction);
-        Assert.False(((IDesignerHostTransactionState)surface.Host).IsClosingTransaction);
-        Assert.Null(surface.Host.RootComponent);
-        Assert.Null(surface.Host.RootComponentClassName);
-        Assert.Null(surface.Host.TransactionDescription);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.NotNull(surface.ServiceContainer);
-        Assert.Throws<InvalidOperationException>(() => surface.View);
-    }
-
-    public static IEnumerable<object[]> Ctor_IServiceProvider_TestData()
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IHelpService)))
-            .Returns(null);
-        yield return new object[] { null };
-        yield return new object[] { mockServiceProvider.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_IServiceProvider_TestData))]
-    public void DesignSurface_Ctor_IServiceProvider(IServiceProvider parentProvider)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        Assert.NotNull(surface.ComponentContainer);
-        Assert.Empty(surface.ComponentContainer.Components);
-        Assert.False(surface.DtelLoading);
-        Assert.False(surface.Host.CanReloadWithErrors);
-        Assert.Same(surface.Host, surface.Host.Container);
-        Assert.False(surface.Host.Loading);
-        Assert.False(surface.Host.IgnoreErrorsDuringReload);
-        Assert.False(surface.Host.InTransaction);
-        Assert.False(((IDesignerHostTransactionState)surface.Host).IsClosingTransaction);
-        Assert.Null(surface.Host.RootComponent);
-        Assert.Null(surface.Host.RootComponentClassName);
-        Assert.Null(surface.Host.TransactionDescription);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.NotNull(surface.ServiceContainer);
-        Assert.Throws<InvalidOperationException>(() => surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Ctor_Type()
-    {
-        using SubDesignSurface surface = new(typeof(RootDesignerComponent));
-        Assert.NotNull(surface.ComponentContainer);
-        Assert.Single(surface.ComponentContainer.Components);
-        Assert.False(surface.DtelLoading);
-        Assert.False(surface.Host.CanReloadWithErrors);
-        Assert.Same(surface.Host, surface.Host.Container);
-        Assert.False(surface.Host.Loading);
-        Assert.False(surface.Host.IgnoreErrorsDuringReload);
-        Assert.False(surface.Host.InTransaction);
-        Assert.False(((IDesignerHostTransactionState)surface.Host).IsClosingTransaction);
-        Assert.IsType<RootDesignerComponent>(surface.Host.RootComponent);
-        Assert.Equal(typeof(RootDesignerComponent).FullName, surface.Host.RootComponentClassName);
-        Assert.Null(surface.Host.TransactionDescription);
-        Assert.True(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.NotNull(surface.ServiceContainer);
-        Assert.Same(RootComponentDesigner.View, surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Ctor_IServiceProvider_Type_NullParentProvider()
-    {
-        using SubDesignSurface surface = new(null, typeof(RootDesignerComponent));
-        Assert.NotNull(surface.ComponentContainer);
-        Assert.Single(surface.ComponentContainer.Components);
-        Assert.False(surface.DtelLoading);
-        Assert.False(surface.Host.CanReloadWithErrors);
-        Assert.Same(surface.Host, surface.Host.Container);
-        Assert.False(surface.Host.Loading);
-        Assert.False(surface.Host.IgnoreErrorsDuringReload);
-        Assert.False(surface.Host.InTransaction);
-        Assert.False(((IDesignerHostTransactionState)surface.Host).IsClosingTransaction);
-        Assert.IsType<RootDesignerComponent>(surface.Host.RootComponent);
-        Assert.Equal(typeof(RootDesignerComponent).FullName, surface.Host.RootComponentClassName);
-        Assert.Null(surface.Host.TransactionDescription);
-        Assert.True(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.NotNull(surface.ServiceContainer);
-        Assert.Same(RootComponentDesigner.View, surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Ctor_IServiceProvider_Type_CustomParentProvider()
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProvider)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IHelpService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        using SubDesignSurface surface = new(mockServiceProvider.Object, typeof(RootDesignerComponent));
-        Assert.NotNull(surface.ComponentContainer);
-        Assert.Single(surface.ComponentContainer.Components);
-        Assert.False(surface.DtelLoading);
-        Assert.False(surface.Host.CanReloadWithErrors);
-        Assert.Same(surface.Host, surface.Host.Container);
-        Assert.False(surface.Host.Loading);
-        Assert.False(surface.Host.IgnoreErrorsDuringReload);
-        Assert.False(surface.Host.InTransaction);
-        Assert.False(((IDesignerHostTransactionState)surface.Host).IsClosingTransaction);
-        Assert.IsType<RootDesignerComponent>(surface.Host.RootComponent);
-        Assert.Equal(typeof(RootDesignerComponent).FullName, surface.Host.RootComponentClassName);
-        Assert.Null(surface.Host.TransactionDescription);
-        Assert.True(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.NotNull(surface.ServiceContainer);
-        Assert.Same(RootComponentDesigner.View, surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Ctor_NullRootComponentType_ThrowsArgumentNullException()
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        Assert.Throws<ArgumentNullException>("rootComponentType", () => new DesignSurface((Type)null));
-        Assert.Throws<ArgumentNullException>("rootComponentType", () => new DesignSurface(mockServiceProvider.Object, (Type)null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ComponentContainer_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => surface.ComponentContainer);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignSurface_DtelLoading_Set_GetReturnsExpected(bool value)
-    {
-        using DesignSurface surface = new()
-        {
-            DtelLoading = value
-        };
-        Assert.Equal(value, surface.DtelLoading);
-
-        // Set same
-        surface.DtelLoading = value;
-        Assert.Equal(value, surface.DtelLoading);
-
-        // Set different
-        surface.DtelLoading = !value;
-        Assert.Equal(!value, surface.DtelLoading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_Get_ReturnsSame()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.NotNull(container);
-        Assert.Same(container, surface.ServiceContainer);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetISelectionService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        ISelectionService service = Assert.IsAssignableFrom<ISelectionService>(container.GetService(typeof(ISelectionService)));
-        Assert.Null(service.PrimarySelection);
-        Assert.Equal(0, service.SelectionCount);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetIExtenderProviderService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.IsAssignableFrom<IExtenderProviderService>(container.GetService(typeof(IExtenderProviderService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetIExtenderListService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.IsAssignableFrom<IExtenderListService>(container.GetService(typeof(IExtenderListService)));
-        Assert.IsAssignableFrom<IExtenderProviderService>(container.GetService(typeof(IExtenderListService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetITypeDescriptorFilterService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.IsAssignableFrom<ITypeDescriptorFilterService>(container.GetService(typeof(ITypeDescriptorFilterService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetIReferenceService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.IsAssignableFrom<IReferenceService>(container.GetService(typeof(IReferenceService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetDesignSurfaceService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(surface, container.GetService(typeof(DesignSurface)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetInstanceTypeService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(container, container.GetService(container.GetType()));
-    }
-
-    public static IEnumerable<object[]> ServiceContainer_FixedService_TestData()
-    {
-        yield return new object[] { typeof(IDesignerHost) };
-        yield return new object[] { typeof(IContainer) };
-        yield return new object[] { typeof(IComponentChangeService) };
-        yield return new object[] { typeof(IDesignerLoaderHost2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ServiceContainer_FixedService_TestData))]
-    public void DesignSurface_ServiceContainer_GetFixedService_ReturnsExpected(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(surface.Host, container.GetService(serviceType));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ServiceContainer_FixedService_TestData))]
-    public void DesignSurface_ServiceContainer_RemoveFixedService_ThrowsInvalidOperationException(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Throws<InvalidOperationException>(() => container.RemoveService(serviceType));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(ISelectionService))]
-    [InlineData(typeof(IExtenderProviderService))]
-    [InlineData(typeof(IExtenderListService))]
-    [InlineData(typeof(ITypeDescriptorFilterService))]
-    [InlineData(typeof(IReferenceService))]
-    [InlineData(typeof(DesignSurface))]
-    public void DesignSurface_ServiceContainer_RemoveNonFixedServiceType_ThrowsArgumentNullException(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.NotNull(container.GetService(serviceType));
-        container.RemoveService(serviceType);
-        Assert.Null(container.GetService(serviceType));
-
-        // Remove again.
-        container.RemoveService(serviceType);
-        Assert.Null(container.GetService(serviceType));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_RemoveNullServiceType_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Throws<ArgumentNullException>("serviceType", () => container.RemoveService(null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_ServiceContainer_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using SubDesignSurface surface = new();
-        surface.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => surface.ServiceContainer);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(NullSupportedTechnologiesRootDesignerComponent))]
-    [InlineData(typeof(EmptySupportedTechnologiesRootDesignerComponent))]
-    public void DesignSurface_View_GetWithInvalidSupportedTechnologies_ThrowsNotSupportedException(Type rootComponentType)
-    {
-        using SubDesignSurface surface = new();
-        surface.BeginLoad(rootComponentType);
-        Assert.Throws<NotSupportedException>(() => surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_View_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_View_GetWithExceptionLoadErrors_ThrowsInvalidOperationException()
-    {
-        Exception exception = new();
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Throws(exception);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Same(exception, Assert.Throws<InvalidOperationException>(() => surface.View).InnerException);
-    }
-
-    public static IEnumerable<object[]> View_GetLoadError_TestData()
-    {
-        yield return new object[] { Array.Empty<object>() };
-        yield return new object[] { new object[] { new Exception() } };
-        yield return new object[] { new object[] { "Error" } };
-        yield return new object[] { new object[] { null } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(View_GetLoadError_TestData))]
-    public void DesignSurface_View_GetWithLoadErrors_ThrowsInvalidOperationException(object[] errorCollection)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        host.EndLoad("BaseClassName", false, errorCollection);
-        Assert.Throws<InvalidOperationException>(() => surface.View);
-    }
-
-    public static IEnumerable<object[]> BeginLoad_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null);
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object };
-
-        Mock<IDesignerEventService> mockDesignerEventService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(mockDesignerEventService.Object);
-        yield return new object[] { mockServiceProvider.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BeginLoad_TestData))]
-    public void DesignSurface_BeginLoad_Invoke_Success(IServiceProvider parentProvider)
-    {
-        SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.True(surface.Host.Loading);
-        Assert.True(host.Loading);
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Throws<InvalidOperationException>(() => surface.View);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_ThrowsException_SetsLoadErrors()
-    {
-        Exception exception = new();
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Throws(exception);
-        mockLoader
-            .Setup(l => l.Loading)
-            .Returns(false);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.False(surface.Host.Loading);
-        Assert.Same(exception, Assert.Single(surface.LoadErrors));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DesignSurface_BeginLoad_ThrowsExceptionWithoutMessage_SetsLoadErrors(string message)
-    {
-        Mock<Exception> mockException = new(MockBehavior.Strict);
-        mockException
-            .Setup(e => e.Message)
-            .Returns(message);
-        mockException
-            .Setup(e => e.ToString())
-            .Returns("ExceptionText");
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Throws(mockException.Object);
-        mockLoader
-            .Setup(l => l.Loading)
-            .Returns(false);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Exception error = Assert.IsType<Exception>(Assert.Single(surface.LoadErrors));
-        Assert.Contains("ExceptionText", error.Message);
-        Assert.False(surface.Host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_ThrowsTargetInvocationException_SetsLoadErrors()
-    {
-        Exception exception = new();
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Throws(new TargetInvocationException(exception));
-        mockLoader
-            .Setup(l => l.Loading)
-            .Returns(false);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.Same(exception, Assert.Single(surface.LoadErrors));
-        Assert.False(surface.Host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeWithLoading_CallsHandler()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        int loadingCallCount = 0;
-        surface.Loading += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadingCallCount++;
-        };
-        int loadedCallCount = 0;
-        surface.Loaded += (sender, e) => loadedCallCount++;
-        int unloadingCallCount = 0;
-        surface.Unloading += (sender, e) => unloadingCallCount++;
-        int unloadedCallCount = 0;
-        surface.Unloaded += (sender, e) => unloadedCallCount++;
-        int flushedCallCount = 0;
-        surface.Flushed += (sender, e) => flushedCallCount++;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.True(surface.Host.Loading);
-        Assert.Equal(1, loadingCallCount);
-        Assert.Equal(0, loadedCallCount);
-        Assert.Equal(0, unloadingCallCount);
-        Assert.Equal(0, unloadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.True(surface.Host.Loading);
-        Assert.Equal(2, loadingCallCount);
-        Assert.Equal(0, loadedCallCount);
-        Assert.Equal(0, unloadingCallCount);
-        Assert.Equal(0, unloadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeErrorWithUnloading_CallsHandler()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        int unloadingCallCount = 0;
-        surface.Unloading += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            unloadingCallCount++;
-        };
-        int unloadedCallCount = 0;
-        surface.Unloaded += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(unloadedCallCount < unloadingCallCount);
-            unloadedCallCount++;
-        };
-        int loadedCallCount = 0;
-        surface.Loaded += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.False(e.HasSucceeded);
-            Assert.Same(surface.LoadErrors, e.Errors);
-            Assert.True(loadedCallCount < unloadingCallCount);
-            loadedCallCount++;
-        };
-        int flushedCallCount = 0;
-        surface.Flushed += (sender, e) => flushedCallCount++;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Throws(new Exception())
-            .Verifiable();
-        mockLoader
-            .Setup(l => l.Loading)
-            .Returns(false);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.Single(surface.LoadErrors);
-        Assert.False(surface.Host.Loading);
-        Assert.Equal(1, unloadingCallCount);
-        Assert.Equal(1, unloadedCallCount);
-        Assert.Equal(1, loadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        Assert.False(surface.IsLoaded);
-        Assert.False(surface.Host.Loading);
-        Assert.Single(surface.LoadErrors);
-        Assert.Equal(2, unloadingCallCount);
-        Assert.Equal(2, unloadedCallCount);
-        Assert.Equal(2, loadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeDefaultIExtenderProvider_Success()
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null)
-            .Verifiable();
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IExtenderListService defaultProviderService = (IExtenderListService)surface.GetService(typeof(IExtenderListService));
-        IDesignerLoaderHost2 host = surface.Host;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        var mockExtenderProvider = mockLoader.As<IExtenderProvider>();
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        Assert.Same(mockExtenderProvider.Object, Assert.Single(defaultProviderService.GetExtenderProviders()));
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        Assert.Same(mockExtenderProvider.Object, Assert.Single(defaultProviderService.GetExtenderProviders()));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeValidIExtenderProvider_CallsAddExtenderProvider()
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(It.IsAny<IExtenderProvider>()))
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null)
-            .Verifiable();
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IExtenderListService defaultProviderService = (IExtenderListService)surface.GetService(typeof(IExtenderListService));
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        var mockExtenderProvider = mockLoader.As<IExtenderProvider>();
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(mockExtenderProvider.Object), Times.Once());
-        Assert.Empty(defaultProviderService.GetExtenderProviders());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(mockExtenderProvider.Object), Times.Once());
-        Assert.Empty(defaultProviderService.GetExtenderProviders());
-    }
-
-    public static IEnumerable<object[]> BeginLoad_InvalidIExtenderProvider_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BeginLoad_InvalidIExtenderProvider_TestData))]
-    public void DesignSurface_BeginLoad_InvokeInvalidIExtenderProvider_Success(object service)
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(service)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null)
-            .Verifiable();
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IExtenderListService defaultProviderService = (IExtenderListService)surface.GetService(typeof(IExtenderListService));
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        var mockExtenderProvider = mockLoader.As<IExtenderProvider>();
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        Assert.Empty(defaultProviderService.GetExtenderProviders());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-        Assert.Empty(defaultProviderService.GetExtenderProviders());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeWithoutIDesignerEventServiceWithActivated_CallsHandler()
-    {
-        SubDesignSurface surface = new();
-        int callCount = 0;
-        IDesignerLoaderHost2 host = surface.Host;
-        host.Activated += (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(1, callCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(2, callCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeWithIDesignerEventServiceWithActivated_DoesNotCallHandler()
-    {
-        Mock<IDesignerEventService> mockDesignerEventService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(mockDesignerEventService.Object)
-            .Verifiable();
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        int callCount = 0;
-        host.Activated += (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Verifiable();
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(0, callCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-
-        // Reload.
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(0, callCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerEventService)), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_DisposeInLoading_DoesCallFlush()
-    {
-        using SubDesignSurface surface = new();
-        int loadingCallCount = 0;
-        surface.Loading += (sender, e) =>
-        {
-            // Catch the InvalidOperationException thrown.
-            try
-            {
-                surface.Dispose();
-            }
-            catch
-            {
-            }
-
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadingCallCount++;
-        };
-        int loadedCallCount = 0;
-        surface.Loaded += (sender, e) => loadedCallCount++;
-        int unloadingCallCount = 0;
-        surface.Unloading += (sender, e) => unloadingCallCount++;
-        int unloadedCallCount = 0;
-        surface.Unloaded += (sender, e) => unloadedCallCount++;
-        int flushedCallCount = 0;
-        surface.Flushed += (sender, e) => flushedCallCount++;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(1, loadingCallCount);
-        Assert.Equal(0, loadedCallCount);
-        Assert.Equal(0, unloadingCallCount);
-        Assert.Equal(0, unloadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_DisposeInBeginLoad_DoesCallFlush()
-    {
-        using SubDesignSurface surface = new();
-        int loadingCallCount = 0;
-        surface.Loading += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadingCallCount++;
-        };
-        int loadedCallCount = 0;
-        surface.Loaded += (sender, e) => loadedCallCount++;
-        int unloadingCallCount = 0;
-        surface.Unloading += (sender, e) => unloadingCallCount++;
-        int unloadedCallCount = 0;
-        surface.Unloaded += (sender, e) => unloadedCallCount++;
-        int flushedCallCount = 0;
-        surface.Flushed += (sender, e) => flushedCallCount++;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        IDesignerLoaderHost2 host = surface.Host;
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Callback(() =>
-            {
-                // Catch the InvalidOperationException thrown.
-                try
-                {
-                    surface.Dispose();
-                }
-                catch
-                {
-                }
-            });
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(1, loadingCallCount);
-        Assert.Equal(0, loadedCallCount);
-        Assert.Equal(0, unloadingCallCount);
-        Assert.Equal(0, unloadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_DisposeInBeginLoadThrowsException_DoesCallFlush()
-    {
-        using SubDesignSurface surface = new();
-        int loadingCallCount = 0;
-        surface.Loading += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadingCallCount++;
-        };
-        int loadedCallCount = 0;
-        surface.Loaded += (sender, e) => loadedCallCount++;
-        int unloadingCallCount = 0;
-        surface.Unloading += (sender, e) => unloadingCallCount++;
-        int unloadedCallCount = 0;
-        surface.Unloaded += (sender, e) => unloadedCallCount++;
-        int flushedCallCount = 0;
-        surface.Flushed += (sender, e) => flushedCallCount++;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        IDesignerLoaderHost2 host = surface.Host;
-        mockLoader
-            .Setup(l => l.BeginLoad(host))
-            .Callback(() =>
-            {
-                // Catch the InvalidOperationException thrown.
-                try
-                {
-                    surface.Dispose();
-                }
-                catch
-                {
-                }
-
-                throw new Exception();
-            });
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(1, loadingCallCount);
-        Assert.Equal(0, loadedCallCount);
-        Assert.Equal(0, unloadingCallCount);
-        Assert.Equal(0, unloadedCallCount);
-        Assert.Equal(0, flushedCallCount);
-        mockLoader.Verify(l => l.BeginLoad(host), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_NullLoader_ThrowsArgumentNullException()
-    {
-        using DesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("loader", () => surface.BeginLoad((DesignerLoader)null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_InvokeType_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(RootDesignerComponent));
-        Assert.True(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(surface.Host.Loading);
-        Assert.False(host.Loading);
-        Assert.IsType<RootDesignerComponent>(host.RootComponent);
-        Assert.Equal(typeof(RootDesignerComponent).FullName, host.RootComponentClassName);
-        Assert.Same(RootComponentDesigner.View, surface.View);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_NullRootComponentType_ThrowsArgumentNullException()
-    {
-        using DesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("rootComponentType", () => surface.BeginLoad((Type)null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_AlreadyCalled_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Mock<DesignerLoader> otherMockLoader = new(MockBehavior.Strict);
-        otherMockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Throws<InvalidOperationException>(() => surface.BeginLoad(typeof(RootDesignerComponent)));
-        Assert.Throws<InvalidOperationException>(() => surface.BeginLoad(otherMockLoader.Object));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_BeginLoad_Disposed_ThrowsObjectDisposedException()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        Assert.Throws<ObjectDisposedException>(() => surface.BeginLoad(typeof(RootDesignerComponent)));
-        Assert.Throws<ObjectDisposedException>(() => surface.BeginLoad(mockLoader.Object));
-    }
-
-    [WinFormsTheory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public void DesignSurface_CreateDesigner_InvokeNoDesigner_ReturnsExpected(bool rootDesigner)
-    {
-        using SubDesignSurface surface = new();
-        using Component component = new();
-
-        Assert.NotNull(surface.CreateDesigner(component, rootDesigner));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateDesigner_InvokeIDesigner_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        using DesignerComponent component = new();
-
-        Assert.IsType<ComponentDocumentDesigner>(surface.CreateDesigner(component, rootDesigner: true));
-        Assert.IsType<ComponentDesigner>(surface.CreateDesigner(component, rootDesigner: false));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateDesigner_InvokeIRootDesigner_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        using RootDesignerComponent component = new();
-        Assert.IsType<RootComponentDesigner>(surface.CreateDesigner(component, rootDesigner: true));
-        Assert.IsType<ComponentDesigner>(surface.CreateDesigner(component, rootDesigner: false));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateDesigner_NullComponent_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("component", () => surface.CreateDesigner(null, true));
-        Assert.Throws<ArgumentNullException>("component", () => surface.CreateDesigner(null, false));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateDesigner_Disposed_ThrowsObjectDisposedException()
-    {
-        using SubDesignSurface surface = new();
-        surface.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => surface.CreateDesigner(new Component(), true));
-        Assert.Throws<ObjectDisposedException>(() => surface.CreateDesigner(new Component(), false));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateComponent_IComponentWithPublicDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithPublicConstructor instance = Assert.IsType<ComponentWithPublicConstructor>(surface.CreateComponent(typeof(ComponentWithPublicConstructor)));
-        Assert.Null(instance.Container);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateComponent_IComponentWithPrivateDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithPrivateDefaultConstructor instance = Assert.IsType<ComponentWithPrivateDefaultConstructor>(surface.CreateComponent(typeof(ComponentWithPrivateDefaultConstructor)));
-        Assert.Null(instance.Container);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateComponent_IComponentWithIContainerConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithIContainerConstructor instance = Assert.IsType<ComponentWithIContainerConstructor>(surface.CreateComponent(typeof(ComponentWithIContainerConstructor)));
-        Assert.Same(surface.ComponentContainer, instance.Container);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(ClassWithPublicConstructor))]
-    [InlineData(typeof(ClassWithPrivateDefaultConstructor))]
-    public void DesignSurface_CreateComponent_NonIComponent_ReturnsNull(Type type)
-    {
-        using SubDesignSurface surface = new();
-        Assert.Null(surface.CreateComponent(type));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(ClassWithIContainerConstructor))]
-    [InlineData(typeof(ClassWithNoMatchingConstructor))]
-    [InlineData(typeof(ComponentWithPrivateIContainerConstructor))]
-    [InlineData(typeof(ComponentWithNoMatchingConstructor))]
-    public void DesignSurface_CreateComponent_TypeWithNoMatchingConstructor_ThrowsMissingMethodException(Type type)
-    {
-        using SubDesignSurface surface = new();
-        Assert.Throws<MissingMethodException>(() => surface.CreateComponent(type));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateComponent_NullType_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("type", () => surface.CreateComponent(null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_NonIComponentWithPublicDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        Assert.IsType<ClassWithPublicConstructor>(surface.CreateInstance(typeof(ClassWithPublicConstructor)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_NonIComponentWithPrivateDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        Assert.IsType<ClassWithPrivateDefaultConstructor>(surface.CreateInstance(typeof(ClassWithPrivateDefaultConstructor)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_IComponentWithPublicDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithPublicConstructor instance = Assert.IsType<ComponentWithPublicConstructor>(surface.CreateInstance(typeof(ComponentWithPublicConstructor)));
-        Assert.Null(instance.Container);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_IComponentWithPrivateDefaultConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithPrivateDefaultConstructor instance = Assert.IsType<ComponentWithPrivateDefaultConstructor>(surface.CreateInstance(typeof(ComponentWithPrivateDefaultConstructor)));
-        Assert.Null(instance.Container);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_IComponentWithIContainerConstructor_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ComponentWithIContainerConstructor instance = Assert.IsType<ComponentWithIContainerConstructor>(surface.CreateInstance(typeof(ComponentWithIContainerConstructor)));
-        Assert.Same(surface.ComponentContainer, instance.Container);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(ClassWithIContainerConstructor))]
-    [InlineData(typeof(ClassWithNoMatchingConstructor))]
-    [InlineData(typeof(ComponentWithPrivateIContainerConstructor))]
-    [InlineData(typeof(ComponentWithNoMatchingConstructor))]
-    public void DesignSurface_CreateInstance_TypeWithNoMatchingConstructor_ThrowsMissingMethodException(Type type)
-    {
-        using SubDesignSurface surface = new();
-        Assert.Throws<MissingMethodException>(() => surface.CreateInstance(type));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateInstance_NullType_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("type", () => surface.CreateInstance(null));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateNestedContainer_InvokeObject_ReturnsExpected()
-    {
-        using DesignSurface surface = new();
-        using Component ownerComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(ownerComponent);
-        Assert.Empty(container.Components);
-        Assert.Same(ownerComponent, container.Owner);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void DesignSurface_CreateNestedContainer_InvokeObjectString_ReturnsExpected(string containerName)
-    {
-        using DesignSurface surface = new();
-        using Component ownerComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(ownerComponent, containerName);
-        Assert.Empty(container.Components);
-        Assert.Same(ownerComponent, container.Owner);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateNestedContainer_NullOwningComponent_ThrowsArgumentNullException()
-    {
-        using DesignSurface surface = new();
-        Assert.Throws<ArgumentNullException>("owningComponent", () => surface.CreateNestedContainer(null));
-        Assert.Throws<ArgumentNullException>("owningComponent", () => surface.CreateNestedContainer(null, "name"));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_CreateNestedContainer_Disposed_ThrowsObjectDisposedException()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => surface.CreateNestedContainer(null, "name"));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeMultipleTimes_Success()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        surface.Dispose();
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_Invoke_RemovesDesignSurfaceService()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(surface, container.GetService(typeof(DesignSurface)));
-
-        surface.Dispose();
-        Assert.Null(container.GetService(typeof(DesignSurface)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeHasLoader_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.True(host.Loading);
-
-        // Should not throw again.
-        surface.Dispose();
-        Assert.True(host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeHasHostWithTransactions_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction = host.CreateTransaction("Transaction1");
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-
-        // Should not throw again.
-        surface.Dispose();
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeWithDisposed_CallsHandler()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        surface.Disposed += handler;
-
-        // Call with handler.
-        surface.Dispose();
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        surface.Dispose();
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        surface.Disposed -= handler;
-        surface.Dispose();
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignSurface_Dispose_InvokeDisposingMultipleTimes_Success(bool disposing)
-    {
-        using SubDesignSurface surface = new();
-        surface.Dispose(disposing);
-        surface.Dispose(disposing);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeDisposing_RemovesDesignSurfaceService()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(surface, container.GetService(typeof(DesignSurface)));
-
-        surface.Dispose(true);
-        Assert.Null(container.GetService(typeof(DesignSurface)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeNotDisposing_DoesNotRemoveDesignSurfaceService()
-    {
-        using SubDesignSurface surface = new();
-        ServiceContainer container = surface.ServiceContainer;
-        Assert.Same(surface, container.GetService(typeof(DesignSurface)));
-
-        surface.Dispose(false);
-        Assert.Same(surface, container.GetService(typeof(DesignSurface)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeDisposingHasLoader_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose(true));
-        Assert.True(host.Loading);
-
-        // Should not throw again.
-        surface.Dispose(true);
-        Assert.True(host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeNotDisposingHasLoader_Nop()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        surface.Dispose(false);
-        Assert.True(host.Loading);
-
-        // Should not throw again.
-        surface.Dispose(false);
-        Assert.True(host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeDisposingHasHostWithTransactions_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction = host.CreateTransaction("Transaction1");
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose(true));
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-
-        // Should not throw again.
-        surface.Dispose(true);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Dispose_InvokeNotDisposingHasHostWithTransactions_Nop()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction = host.CreateTransaction("Transaction1");
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-        surface.Dispose(false);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-
-        // Should not throw again.
-        surface.Dispose(false);
-        Assert.True(host.Loading);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Transaction1", host.TransactionDescription);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Dispose_InvokeDisposingWithDisposed_CallsHandler(bool disposing, int expectedCallCount)
-    {
-        using SubDesignSurface surface = new();
-        surface.Dispose();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        surface.Disposed += handler;
-
-        // Call with handler.
-        surface.Dispose(disposing);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Call again.
-        surface.Dispose(disposing);
-        Assert.Equal(expectedCallCount * 2, callCount);
-
-        // Remove handler.
-        surface.Disposed -= handler;
-        surface.Dispose(disposing);
-        Assert.Equal(expectedCallCount * 2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Flush_InvokeWithHostWithLoader_CallsLoaderFlush()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        mockLoader
-            .Setup(l => l.Flush())
-            .Verifiable();
-        surface.BeginLoad(mockLoader.Object);
-
-        surface.Flush();
-        mockLoader.Verify(l => l.Flush(), Times.Once());
-
-        // Flush again.
-        surface.Flush();
-        mockLoader.Verify(l => l.Flush(), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Flush_InvokeWithHostWithoutLoader_Nop()
-    {
-        using DesignSurface surface = new();
-        surface.Flush();
-
-        // Flush again.
-        surface.Flush();
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Flush_InvokeDisposed_Nop()
-    {
-        using DesignSurface surface = new();
-        surface.Dispose();
-        surface.Flush();
-
-        // Flush again.
-        surface.Flush();
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_Flush_InvokeWithFlushed_CallsHandler()
-    {
-        using DesignSurface surface = new();
-        int callCount = 0;
-        surface.Flushed += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        surface.Flush();
-        Assert.Equal(1, callCount);
-
-        // Flush again.
-        surface.Flush();
-        Assert.Equal(2, callCount);
-
-        // Flush when disposed.
-        surface.Dispose();
-        surface.Flush();
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_InvokeWithServiceProvider_ReturnsExpected()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(int)))
-            .Returns(service)
-            .Verifiable();
-        using DesignSurface surface = new(mockServiceProvider.Object);
-        Assert.Same(service, surface.GetService(typeof(int)));
-        mockServiceProvider.Verify(p => p.GetService(typeof(int)), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetISelectionService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        ISelectionService service = Assert.IsAssignableFrom<ISelectionService>(surface.GetService(typeof(ISelectionService)));
-        Assert.Null(service.PrimarySelection);
-        Assert.Equal(0, service.SelectionCount);
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetIExtenderProviderService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        Assert.IsAssignableFrom<IExtenderProviderService>(surface.GetService(typeof(IExtenderProviderService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetIExtenderListService_ReturnsExpected()
-    {
-        using DesignSurface surface = new();
-        Assert.IsAssignableFrom<IExtenderListService>(surface.GetService(typeof(IExtenderListService)));
-        Assert.IsAssignableFrom<IExtenderProviderService>(surface.GetService(typeof(IExtenderListService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetITypeDescriptorFilterService_ReturnsExpected()
-    {
-        using DesignSurface surface = new();
-        Assert.IsAssignableFrom<ITypeDescriptorFilterService>(surface.GetService(typeof(ITypeDescriptorFilterService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetIReferenceService_ReturnsExpected()
-    {
-        using DesignSurface surface = new();
-        Assert.IsAssignableFrom<IReferenceService>(surface.GetService(typeof(IReferenceService)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetDesignSurfaceService_ReturnsExpected()
-    {
-        using DesignSurface surface = new();
-        Assert.Same(surface, surface.GetService(typeof(DesignSurface)));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_GetInstanceTypeService_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        Assert.Same(surface.ServiceContainer, surface.GetService(surface.ServiceContainer.GetType()));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(IServiceContainer))]
-    [InlineData(typeof(ServiceContainer))]
-    public void DesignSurface_GetService_IServiceContainer_ReturnsExpected(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        Assert.Same(surface.ServiceContainer, surface.GetService(serviceType));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ServiceContainer_FixedService_TestData))]
-    public void DesignSurface_GetService_GetFixedService_ReturnsExpected(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        Assert.Same(surface.Host, surface.GetService(serviceType));
-    }
-
-    [WinFormsFact]
-    public void DesignSurface_GetService_InvokeWithoutServiceProvider_ReturnsNull()
-    {
-        using DesignSurface surface = new();
-        Assert.Null(surface.GetService(typeof(int)));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ServiceContainer_FixedService_TestData))]
-    public void DesignSurface_GetService_Disposed_ReturnsNull(Type serviceType)
-    {
-        using SubDesignSurface surface = new();
-        surface.Dispose();
-        Assert.Null(surface.GetService(serviceType));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignSurface_OnLoading_Invoke_Success(EventArgs eventArgs)
-    {
-        using SubDesignSurface surface = new();
-
-        // No handler.
-        surface.OnLoading(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(surface, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        surface.Loading += handler;
-        surface.OnLoading(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        surface.Loading -= handler;
-        surface.OnLoading(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> LoadedEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new LoadedEventArgs(false, null) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LoadedEventArgs_TestData))]
-    public void DesignSurface_OnLoaded_Invoke_Success(LoadedEventArgs eventArgs)
-    {
-        using SubDesignSurface surface = new();
-
-        // No handler.
-        surface.OnLoaded(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        LoadedEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(surface, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        surface.Loaded += handler;
-        surface.OnLoaded(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        surface.Loaded -= handler;
-        surface.OnLoaded(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignSurface_OnUnloaded_Invoke_Success(EventArgs eventArgs)
-    {
-        using SubDesignSurface surface = new();
-
-        // No handler.
-        surface.OnUnloaded(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(surface, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        surface.Unloaded += handler;
-        surface.OnUnloaded(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        surface.Unloaded -= handler;
-        surface.OnUnloaded(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignSurface_OnUnloading_Invoke_Success(EventArgs eventArgs)
-    {
-        using SubDesignSurface surface = new();
-
-        // No handler.
-        surface.OnUnloading(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(surface, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        surface.Unloading += handler;
-        surface.OnUnloading(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        surface.Unloading -= handler;
-        surface.OnUnloading(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignSurface_OnViewActivate_Invoke_Success(EventArgs eventArgs)
-    {
-        using SubDesignSurface surface = new();
-
-        // No handler.
-        surface.OnViewActivate(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(surface, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        surface.ViewActivated += handler;
-        surface.OnViewActivate(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        surface.ViewActivated -= handler;
-        surface.OnViewActivate(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    private class SubDesignSurface : DesignSurface
-    {
-        public SubDesignSurface() : base()
-        {
-        }
-
-        public SubDesignSurface(IServiceProvider parentProvider) : base(parentProvider)
-        {
-        }
-
-        public SubDesignSurface(Type rootComponentType) : base(rootComponentType)
-        {
-        }
-
-        public SubDesignSurface(IServiceProvider parentProvider, Type rootComponentType) : base(parentProvider, rootComponentType)
-        {
-        }
-
-        public new ServiceContainer ServiceContainer => base.ServiceContainer;
-
-        public IDesignerLoaderHost2 Host => Assert.IsAssignableFrom<IDesignerLoaderHost2>(ComponentContainer);
-
-#pragma warning disable 0618
-        public new IComponent CreateComponent(Type componentType) => base.CreateComponent(componentType);
-#pragma warning restore 0618
-
-        public new IDesigner CreateDesigner(IComponent component, bool rootDesigner) => base.CreateDesigner(component, rootDesigner);
-
-        public new object CreateInstance(Type type) => base.CreateInstance(type);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new void OnLoading(EventArgs e) => base.OnLoading(e);
-
-        public new void OnLoaded(LoadedEventArgs e) => base.OnLoaded(e);
-
-        public new void OnUnloading(EventArgs e) => base.OnUnloading(e);
-
-        public new void OnUnloaded(EventArgs e) => base.OnUnloaded(e);
-
-        public new void OnViewActivate(EventArgs e) => base.OnViewActivate(e);
-    }
-
-    [Designer(typeof(ComponentDesigner))]
-    private class DesignerComponent : Component
-    {
-    }
-
-    private class RootComponentDesigner : ComponentDesigner, IRootDesigner
-    {
-        public static object View { get; } = new object();
-
-        public ViewTechnology[] SupportedTechnologies => new ViewTechnology[] { ViewTechnology.Default + 1 };
-        public object GetView(ViewTechnology technology)
-        {
-            Assert.Equal(ViewTechnology.Default + 1, technology);
-            return View;
-        }
-    }
-
-    [Designer(typeof(RootComponentDesigner), typeof(IRootDesigner))]
-    private class RootDesignerComponent : Component
-    {
-    }
-
-    private class NullSupportedTechnologiesRootComponentDesigner : ComponentDesigner, IRootDesigner
-    {
-        public ViewTechnology[] SupportedTechnologies => null;
-        public object GetView(ViewTechnology technology) => throw new NotImplementedException();
-    }
-
-    [Designer(typeof(NullSupportedTechnologiesRootComponentDesigner), typeof(IRootDesigner))]
-    private class NullSupportedTechnologiesRootDesignerComponent : Component
-    {
-    }
-
-    private class EmptySupportedTechnologiesRootComponentDesigner : ComponentDesigner, IRootDesigner
-    {
-        public ViewTechnology[] SupportedTechnologies => Array.Empty<ViewTechnology>();
-        public object GetView(ViewTechnology technology) => throw new NotImplementedException();
-    }
-
-    [Designer(typeof(EmptySupportedTechnologiesRootComponentDesigner), typeof(IRootDesigner))]
-    private class EmptySupportedTechnologiesRootDesignerComponent : Component
-    {
-    }
-
-    private class ClassWithPublicConstructor
-    {
-        public ClassWithPublicConstructor()
-        {
-        }
-
-        public ClassWithPublicConstructor(IContainer container)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class ComponentWithPublicConstructor : Component
-    {
-        public ComponentWithPublicConstructor()
-        {
-        }
-
-        public ComponentWithPublicConstructor(IContainer container)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class ClassWithPrivateDefaultConstructor
-    {
-        private ClassWithPrivateDefaultConstructor()
-        {
-        }
-
-        private ClassWithPrivateDefaultConstructor(IContainer container)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class ComponentWithPrivateDefaultConstructor : Component
-    {
-        private ComponentWithPrivateDefaultConstructor()
-        {
-        }
-
-        private ComponentWithPrivateDefaultConstructor(IContainer container)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class ComponentWithIContainerConstructor : Component
-    {
-        public new IContainer Container { get; set; }
-
-        public ComponentWithIContainerConstructor(IContainer container)
-        {
-            Container = container;
-        }
-    }
-
-    private class ClassWithIContainerConstructor
-    {
-        public IContainer Container { get; set; }
-
-        public ClassWithIContainerConstructor(IContainer container)
-        {
-            Container = container;
-        }
-    }
-
-    private class ClassWithNoMatchingConstructor
-    {
-        private ClassWithNoMatchingConstructor(bool value)
-        {
-        }
-    }
-
-    private class ComponentWithNoMatchingConstructor : Component
-    {
-        private ComponentWithNoMatchingConstructor(bool value)
-        {
-        }
-    }
-
-    private class ClassWithPrivateIContainerConstructor
-    {
-        private ClassWithPrivateIContainerConstructor(IContainer container)
-        {
-        }
-    }
-
-    private class ComponentWithPrivateIContainerConstructor : Component
-    {
-        private ComponentWithPrivateIContainerConstructor(IContainer container)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionHeaderItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionHeaderItemTests.cs
deleted file mode 100644
index 235ab214a8b..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionHeaderItemTests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionHeaderItemTests
-{
-    [Theory]
-    [InlineData("displayName", "category", "displayName")]
-    [InlineData("displa(&a)yName", "cate(&a)gory", "displayName")]
-    [InlineData("", "", "")]
-    [InlineData(null, null, null)]
-    public void DesignerActionItem_Ctor_String_String(string displayName, string category, string expectedDisplayName)
-    {
-        DesignerActionHeaderItem item = new(displayName, category);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-    }
-
-    [Theory]
-    [InlineData("displayName", "displayName")]
-    [InlineData("displa(&a)yName", "displayName")]
-    [InlineData("", "")]
-    [InlineData(null, null)]
-    public void DesignerActionItem_Ctor_String(string displayName, string expectedDisplayName)
-    {
-        DesignerActionHeaderItem item = new(displayName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(displayName, item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemCollectionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemCollectionTests.cs
deleted file mode 100644
index d7b0207cabb..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemCollectionTests.cs
+++ /dev/null
@@ -1,170 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionItemCollectionTests
-{
-    [Fact]
-    public void DesignerActionItemCollection_Ctor_Default()
-    {
-        DesignerActionItemCollection collection = new();
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Add_DesignerActionItem_Success()
-    {
-        DesignerActionItemCollection collection = new();
-
-        SubDesignerActionItem value1 = new("displayName", "category", "description");
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        SubDesignerActionItem value2 = new("displayName", "category", "description");
-        collection.Add(value2);
-        Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(1, collection.IndexOf(value2));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Add_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerActionItemCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => collection.Add(null));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Insert_DesignerActionItem_Success()
-    {
-        DesignerActionItemCollection collection = new();
-
-        SubDesignerActionItem value1 = new("displayName", "category", "description");
-        collection.Insert(0, value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        SubDesignerActionItem value2 = new("displayName", "category", "description");
-        collection.Insert(0, value2);
-        Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Insert_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerActionItemCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => collection.Insert(0, null));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Remove_Invoke_Success()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-        Assert.Same(value, Assert.Single(collection));
-
-        collection.Remove(value);
-        Assert.Empty(collection);
-        Assert.False(collection.Contains(value));
-        Assert.Equal(-1, collection.IndexOf(value));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Remove_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerActionItemCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => collection.Remove(null));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Item_Set_GetReturnsExpected()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value1 = new("displayName", "category", "description");
-        SubDesignerActionItem value2 = new("displayName", "category", "description");
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-
-        collection[0] = value2;
-        Assert.Same(value2, Assert.Single(collection));
-        Assert.Same(value2, collection[0]);
-        Assert.False(collection.Contains(value1));
-        Assert.Equal(-1, collection.IndexOf(value1));
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Item_SetNull_ThrowsArgumentNullException()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_CopyTo_Invoke_Success()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-
-        var array = new DesignerActionItem[3];
-        collection.CopyTo(array, 1);
-        Assert.Equal(new DesignerActionItem[] { null, value, null }, array);
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Contains_NoSuchValue_ReturnsFalse()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-
-        Assert.False(collection.Contains(new SubDesignerActionItem("displayName", "category", "description")));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_IndexOf_NoSuchValue_ReturnsNegativeOne()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-
-        Assert.Equal(-1, collection.IndexOf(new SubDesignerActionItem("displayName", "category", "description")));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerActionItemCollection_Clear_Success()
-    {
-        DesignerActionItemCollection collection = new();
-        SubDesignerActionItem value = new("displayName", "category", "description");
-        collection.Add(value);
-
-        collection.Clear();
-        Assert.Empty(collection);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    private class SubDesignerActionItem : DesignerActionItem
-    {
-        public SubDesignerActionItem(string displayName, string category, string description) : base(displayName, category, description)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemTests.cs
deleted file mode 100644
index 59ddc25aa8d..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionItemTests.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionItemTests
-{
-    [Theory]
-    [InlineData("displayName", "category", "description", "displayName")]
-    [InlineData("displa(&a)yName", "cate(&a)gory", "descr(&a)iption", "displayName")]
-    [InlineData("", "", "", "")]
-    [InlineData(null, null, null, null)]
-    public void DesignerActionItem_Ctor_String_String_String(string displayName, string category, string description, string expectedDisplayName)
-    {
-        SubDesignerActionItem item = new(displayName, category, description);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Equal(description, item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerActionItem_AllowAssociate_Set_GetReturnsExpected(bool value)
-    {
-        SubDesignerActionItem item = new("displayName", "category", "description")
-        {
-            AllowAssociate = value
-        };
-        Assert.Equal(value, item.AllowAssociate);
-
-        // Set same.
-        item.AllowAssociate = value;
-        Assert.Equal(value, item.AllowAssociate);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerActionItem_ShowInSourceView_Set_GetReturnsExpected(bool value)
-    {
-        SubDesignerActionItem item = new("displayName", "category", "description")
-        {
-            ShowInSourceView = value
-        };
-        Assert.Equal(value, item.ShowInSourceView);
-
-        // Set same.
-        item.ShowInSourceView = value;
-        Assert.Equal(value, item.ShowInSourceView);
-    }
-
-    private class SubDesignerActionItem : DesignerActionItem
-    {
-        public SubDesignerActionItem(string displayName, string category, string description) : base(displayName, category, description)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListCollectionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListCollectionTests.cs
deleted file mode 100644
index 86051c4b169..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListCollectionTests.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionListCollectionTests
-{
-    [Fact]
-    public void DesignerActionListCollection_Ctor_Default()
-    {
-        DesignerActionListCollection collection = new();
-        Assert.Empty(collection);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionListArray_TestData()
-    {
-        yield return new object[] { Array.Empty<DesignerActionList>() };
-        yield return new object[] { new DesignerActionList[] { new DesignerActionList(null), null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionListArray_TestData))]
-    public void DesignerActionListCollection_Ctor_DesignerActionListArray(DesignerActionList[] value)
-    {
-        DesignerActionListCollection collection = new(value);
-        Assert.Equal(value, collection.Cast<object>());
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Ctor_NullValue_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("value", () => new DesignerActionListCollection(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Add_DesignerActionList_Success()
-    {
-        DesignerActionListCollection collection = new();
-
-        DesignerActionList value1 = new(null);
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        DesignerActionList value2 = new(null);
-        collection.Add(value2);
-        Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(1, collection.IndexOf(value2));
-
-        collection.Add(null);
-        Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>());
-        Assert.True(collection.Contains(null));
-        Assert.Equal(2, collection.IndexOf(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionListArray_TestData))]
-    public void DesignerActionListCollection_AddRange_DesignerActionListArray_Success(DesignerActionList[] value)
-    {
-        DesignerActionListCollection collection = new();
-        collection.AddRange(value);
-        Assert.Equal(value, collection.Cast<object>());
-
-        // Add again.
-        collection.AddRange(value);
-        Assert.Equal(value.Concat(value), collection.Cast<object>());
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionListArray_TestData))]
-    public void DesignerActionListCollection_AddRange_DesignerActionListCollection_Success(DesignerActionList[] value)
-    {
-        DesignerActionListCollection collection = new();
-        collection.AddRange(new DesignerActionListCollection(value));
-        Assert.Equal(value, collection.Cast<object>());
-
-        // Add again.
-        collection.AddRange(new DesignerActionListCollection(value));
-        Assert.Equal(value.Concat(value), collection.Cast<object>());
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_AddRange_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerActionListCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange((DesignerActionList[])null));
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange((DesignerActionListCollection)null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Insert_DesignerActionList_Success()
-    {
-        DesignerActionListCollection collection = new();
-
-        DesignerActionList value1 = new(null);
-        collection.Insert(0, value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        DesignerActionList value2 = new(null);
-        collection.Insert(0, value2);
-        Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-
-        collection.Insert(1, null);
-        Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());
-        Assert.True(collection.Contains(null));
-        Assert.Equal(1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Remove_Invoke_Success()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value = new(null);
-        collection.Add(value);
-        Assert.Same(value, Assert.Single(collection));
-
-        collection.Remove(value);
-        Assert.Empty(collection);
-        Assert.False(collection.Contains(value));
-        Assert.Equal(-1, collection.IndexOf(value));
-
-        collection.Add(null);
-        collection.Remove(null);
-        Assert.Empty(collection);
-        Assert.False(collection.Contains(null));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Item_Set_GetReturnsExpected()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value1 = new(null);
-        DesignerActionList value2 = new(null);
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-
-        collection[0] = value2;
-        Assert.Same(value2, Assert.Single(collection));
-        Assert.Same(value2, collection[0]);
-        Assert.False(collection.Contains(value1));
-        Assert.Equal(-1, collection.IndexOf(value1));
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-
-        collection[0] = null;
-        Assert.Null(Assert.Single(collection));
-        Assert.Null(collection[0]);
-        Assert.False(collection.Contains(value2));
-        Assert.Equal(-1, collection.IndexOf(value2));
-        Assert.True(collection.Contains(null));
-        Assert.Equal(0, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_CopyTo_Invoke_Success()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value = new(null);
-        collection.Add(value);
-
-        var array = new DesignerActionList[3];
-        collection.CopyTo(array, 1);
-        Assert.Equal(new DesignerActionList[] { null, value, null }, array);
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Contains_NoSuchValue_ReturnsFalse()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value = new(null);
-        collection.Add(value);
-
-        Assert.False(collection.Contains(new DesignerActionList(null)));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_IndexOf_NoSuchValue_ReturnsNegativeOne()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value = new(null);
-        collection.Add(value);
-
-        Assert.Equal(-1, collection.IndexOf(new DesignerActionList(null)));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerActionListCollection_Clear_Success()
-    {
-        DesignerActionListCollection collection = new();
-        DesignerActionList value = new(null);
-        collection.Add(value);
-
-        collection.Clear();
-        Assert.Empty(collection);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListTests.cs
deleted file mode 100644
index 3bc45ebbb20..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListTests.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionListTests
-{
-    public static IEnumerable<object[]> Ctor_IComponent_TestDat()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Component() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IComponent_TestDat))]
-    public void DesignerActionList_Ctor_IComponent(IComponent component)
-    {
-        DesignerActionList list = new(component);
-        Assert.Equal(component, list.Component);
-        Assert.False(list.AutoShow);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerActionList_AutoShow_Set_GetReturnsExpected(bool value)
-    {
-        DesignerActionList list = new(new Component())
-        {
-            AutoShow = value
-        };
-        Assert.Equal(value, list.AutoShow);
-
-        // Set same.
-        list.AutoShow = value;
-        Assert.Equal(value, list.AutoShow);
-    }
-
-    public static IEnumerable<object[]> GetService_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new Component(), null };
-
-        object o = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(int)))
-            .Returns(o);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        yield return new object[] { new Component { Site = mockSite.Object }, o };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetService_TestData))]
-    public void DesignerActionList_GetService_Invoke_ReturnsExpected(Component component, object expected)
-    {
-        DesignerActionList list = new(component);
-        Assert.Equal(expected, list.GetService(typeof(int)));
-    }
-
-    [Fact]
-    public void DesignerActionList_GetSortedActionItems_CustomClass_ReturnsExpected()
-    {
-        SubDesignerActionList list = new();
-        DesignerActionItemCollection items = list.GetSortedActionItems();
-        Assert.Equal(8, items.Count);
-
-        DesignerActionMethodItem item1 = Assert.IsType<DesignerActionMethodItem>(items[0]);
-        Assert.Equal("AnnotatedMethod", item1.MemberName);
-        Assert.Equal("DisplayName", item1.DisplayName);
-        Assert.Equal("Description", item1.Description);
-        Assert.Equal("Category", item1.Category);
-
-        DesignerActionPropertyItem item2 = Assert.IsType<DesignerActionPropertyItem>(items[1]);
-        Assert.Equal("AnnotatedProperty", item2.MemberName);
-        Assert.Equal("DisplayName", item2.DisplayName);
-        Assert.Equal("Description", item2.Description);
-        Assert.Equal("Category", item2.Category);
-
-        DesignerActionMethodItem item3 = Assert.IsType<DesignerActionMethodItem>(items[2]);
-        Assert.Equal("EmptyAnnotatedMethod", item3.MemberName);
-        Assert.Equal("EmptyAnnotatedMethod", item3.DisplayName);
-        Assert.Empty(item3.Description);
-        Assert.Empty(item3.Category);
-
-        DesignerActionPropertyItem item4 = Assert.IsType<DesignerActionPropertyItem>(items[3]);
-        Assert.Equal("EmptyAnnotatedProperty", item4.MemberName);
-        Assert.Equal("EmptyAnnotatedProperty", item4.DisplayName);
-        Assert.Empty(item4.Description);
-        Assert.Empty(item4.Category);
-
-        DesignerActionMethodItem item5 = Assert.IsType<DesignerActionMethodItem>(items[4]);
-        Assert.Equal("NullAnnotatedMethod", item5.MemberName);
-        Assert.Equal("NullAnnotatedMethod", item5.DisplayName);
-        Assert.Null(item5.Description);
-        Assert.Null(item5.Category);
-
-        DesignerActionPropertyItem item6 = Assert.IsType<DesignerActionPropertyItem>(items[5]);
-        Assert.Equal("NullAnnotatedProperty", item6.MemberName);
-        Assert.Equal("NullAnnotatedProperty", item6.DisplayName);
-        Assert.Null(item6.Description);
-        Assert.Null(item6.Category);
-
-        DesignerActionMethodItem item7 = Assert.IsType<DesignerActionMethodItem>(items[6]);
-        Assert.Equal("PublicMethod", item7.MemberName);
-        Assert.Equal("PublicMethod", item7.DisplayName);
-        Assert.Empty(item7.Description);
-        Assert.Empty(item7.Category);
-
-        DesignerActionPropertyItem item8 = Assert.IsType<DesignerActionPropertyItem>(items[7]);
-        Assert.Equal("PublicProperty", item8.MemberName);
-        Assert.Equal("PublicProperty", item8.DisplayName);
-        Assert.Empty(item8.Description);
-        Assert.Empty(item8.Category);
-    }
-
-    [Fact]
-    public void DesignerActionList_GetSortedActionItems_BaseClass_ReturnsEmpty()
-    {
-        DesignerActionList list = new(null);
-        DesignerActionItemCollection items = list.GetSortedActionItems();
-        Assert.Empty(items);
-    }
-
-    private class SubDesignerActionList : DesignerActionList
-    {
-        public SubDesignerActionList() : base(null)
-        {
-        }
-
-        public void PublicMethod()
-        {
-        }
-
-        [Description("Description")]
-        [DisplayName("DisplayName")]
-        [Category("Category")]
-        public void AnnotatedMethod()
-        {
-        }
-
-        [Description("")]
-        [DisplayName("")]
-        [Category("")]
-        public void EmptyAnnotatedMethod()
-        {
-        }
-
-        [Description(null)]
-        [DisplayName(null)]
-        [Category(null)]
-        public void NullAnnotatedMethod()
-        {
-        }
-
-        private void PrivateMethod()
-        {
-        }
-
-        public void MethodWithParameters(object o)
-        {
-        }
-
-        [SpecialName]
-        public void MethodWithSpecialName()
-        {
-        }
-
-        public static void StaticMethod()
-        {
-        }
-
-        public int PublicProperty { get; set; }
-
-        [Description("Description")]
-        [DisplayName("DisplayName")]
-        [Category("Category")]
-        public int AnnotatedProperty { get; set; }
-
-        [Description("")]
-        [DisplayName("")]
-        [Category("")]
-        public int EmptyAnnotatedProperty { get; set; }
-
-        [Description(null)]
-        [DisplayName(null)]
-        [Category(null)]
-        public int NullAnnotatedProperty { get; set; }
-
-        private int PrivateProperty { get; set; }
-
-        public static int StaticProperty { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListsChangedEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListsChangedEventArgsTests.cs
deleted file mode 100644
index 8552fd326e4..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionListsChangedEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionListsChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Object_DesignerActionListsChangedType_DesignerActionListCollection_TestData()
-    {
-        yield return new object[] { null, DesignerActionListsChangedType.ActionListsAdded - 1, null };
-        yield return new object[] { new object(), DesignerActionListsChangedType.ActionListsAdded, new DesignerActionListCollection() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Object_DesignerActionListsChangedType_DesignerActionListCollection_TestData))]
-    public void Ctor_Object_DesignerActionListsChangedType_DesignerActionListCollection(object relatedObject, DesignerActionListsChangedType changeType, DesignerActionListCollection actionLists)
-    {
-        DesignerActionListsChangedEventArgs e = new(relatedObject, changeType, actionLists);
-        Assert.Same(relatedObject, e.RelatedObject);
-        Assert.Equal(changeType, e.ChangeType);
-        Assert.Same(actionLists, e.ActionLists);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionMethodItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionMethodItemTests.cs
deleted file mode 100644
index c8f934527bf..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionMethodItemTests.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-using System.Reflection;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionMethodItemTests
-{
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_String_String_Bool_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", "category", "description", false, "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", "cate(&a)gory", "description", true, "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, string.Empty, string.Empty, false, string.Empty };
-        yield return new object[] { null, null, null, null, null, false, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_String_String_Bool_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String_String_String_Bool(DesignerActionList actionList, string memberName, string displayName, string category, string description, bool includeAsDesignerVerb, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName, category, description, includeAsDesignerVerb);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Equal(description, item.Description);
-        Assert.Equal(includeAsDesignerVerb, item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_String_String_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", "category", "description", "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", "cate(&a)gory", "description", "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { null, null, null, null, null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_String_String_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String_String_String(DesignerActionList actionList, string memberName, string displayName, string category, string description, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName, category, description);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Equal(description, item.Description);
-        Assert.False(item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_String_Bool_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", "category", false, "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", "cate(&a)gory", true, "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, string.Empty, false, string.Empty };
-        yield return new object[] { null, null, null, null, false, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_String_Bool_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String_String_Bool(DesignerActionList actionList, string memberName, string displayName, string category, bool includeAsDesignerVerb, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName, category, includeAsDesignerVerb);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Null(item.Description);
-        Assert.Equal(includeAsDesignerVerb, item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_String_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", "category", "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", "cate(&a)gory", "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { null, null, null, null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_String_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String_String(DesignerActionList actionList, string memberName, string displayName, string category, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName, category);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_Bool_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", false, "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", true, "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, false, string.Empty };
-        yield return new object[] { null, null, null, false, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_Bool_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String_Bool(DesignerActionList actionList, string memberName, string displayName, bool includeAsDesignerVerb, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName, includeAsDesignerVerb);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Null(item.Category);
-        Assert.Null(item.Description);
-        Assert.Equal(includeAsDesignerVerb, item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerActionList_String_String_TestData()
-    {
-        yield return new object[] { new DesignerActionList(null), "memberName", "displayName", "displayName" };
-        yield return new object[] { new DesignerActionList(null), "member(&a)Name", "displa(&a)yName", "displayName" };
-        yield return new object[] { null, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { null, null, null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerActionList_String_String_TestData))]
-    public void DesignerActionMethodItem_Ctor_DesignerActionList_String_String(DesignerActionList actionList, string memberName, string displayName, string expectedDisplayName)
-    {
-        DesignerActionMethodItem item = new(actionList, memberName, displayName);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Null(item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.IncludeAsDesignerVerb);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> RelatedComponent_Set_TestData()
-    {
-        yield return new object[] { new Component() };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(RelatedComponent_Set_TestData))]
-    public void DesignerActionMethodItem_RelatedComponent_Set_GetReturnsExpected(IComponent value)
-    {
-        DesignerActionMethodItem item = new(null, "memberName", "displayName", "category", "description")
-        {
-            RelatedComponent = value
-        };
-        Assert.Same(value, item.RelatedComponent);
-
-        // Set same.
-        item.RelatedComponent = value;
-        Assert.Same(value, item.RelatedComponent);
-    }
-
-    [Theory]
-    [InlineData(nameof(SubDesignerActionList.PublicMethod))]
-    [InlineData("PrivateMethod")]
-    public void Invoke_ValidMemberName_ReturnsExpected(string memberName)
-    {
-        SubDesignerActionList list = new();
-        DesignerActionMethodItem item = new(list, memberName, "displayName", "category", "description");
-        item.Invoke();
-        Assert.Equal(memberName, list.CalledMethod);
-
-        // Call again to test caching behaviour.
-        list.CalledMethod = null;
-        item.Invoke();
-        Assert.Equal(memberName, list.CalledMethod);
-    }
-
-    [Fact]
-    public void Invoke_NullActionList_ThrowsInvalidOperationException()
-    {
-        DesignerActionMethodItem item = new(null, "memberName", "displayName", "category", "description");
-        Assert.Throws<InvalidOperationException>(() => item.Invoke());
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("NoSuchMember")]
-    [InlineData(nameof(SubDesignerActionList.StaticMethod))]
-    public void Invoke_NoSuchMemberName_ThrowsInvalidOperationException(string memberName)
-    {
-        SubDesignerActionList list = new();
-        DesignerActionMethodItem item = new(list, memberName, "displayName", "category", "description");
-        Assert.Throws<InvalidOperationException>(() => item.Invoke());
-    }
-
-    [Fact]
-    public void Invoke_NullMemberName_ThrowsArgumentNullException()
-    {
-        SubDesignerActionList list = new();
-        DesignerActionMethodItem item = new(list, null, "displayName", "category", "description");
-        Assert.Throws<ArgumentNullException>("name", () => item.Invoke());
-    }
-
-    [Fact]
-    public void Invoke_MemberWithParameters_ThrowsTargetParameterCountException()
-    {
-        SubDesignerActionList list = new();
-        DesignerActionMethodItem item = new(list, nameof(SubDesignerActionList.MethodWithParameters), "displayName", "category", "description");
-        Assert.Throws<TargetParameterCountException>(() => item.Invoke());
-    }
-
-    private class SubDesignerActionList : DesignerActionList
-    {
-        public SubDesignerActionList() : base(null)
-        {
-        }
-
-        public string CalledMethod { get; set; }
-
-        public void PublicMethod()
-        {
-            Assert.Null(CalledMethod);
-            CalledMethod = nameof(PublicMethod);
-        }
-
-        private void PrivateMethod()
-        {
-            Assert.Null(CalledMethod);
-            CalledMethod = nameof(PrivateMethod);
-        }
-
-        public static void StaticMethod()
-        {
-            throw new InvalidOperationException();
-        }
-
-        public void MethodWithParameters(object o)
-        {
-            throw new InvalidOperationException();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionPropertyItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionPropertyItemTests.cs
deleted file mode 100644
index e2ae8200248..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionPropertyItemTests.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionPropertyItemTests
-{
-    [Theory]
-    [InlineData("memberName", "displayName", "category", "description", "displayName")]
-    [InlineData("member(&a)Name", "displa(&a)yName", "cate(&a)gory", "descr(&a)iption", "displayName")]
-    [InlineData("", "", "", "", "")]
-    [InlineData(null, null, null, null, null)]
-    public void DesignerActionPropertyItem_Ctor_String_String_String_String(string memberName, string displayName, string category, string description, string expectedDisplayName)
-    {
-        DesignerActionPropertyItem item = new(memberName, displayName, category, description);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Equal(description, item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    [Theory]
-    [InlineData("memberName", "displayName", "category", "displayName")]
-    [InlineData("member(&a)Name", "displa(&a)yName", "cate(&a)gory", "displayName")]
-    [InlineData("", "", "", "")]
-    [InlineData(null, null, null, null)]
-    public void DesignerActionPropertyItem_Ctor_String_String_String(string memberName, string displayName, string category, string expectedDisplayName)
-    {
-        DesignerActionPropertyItem item = new(memberName, displayName, category);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    [Theory]
-    [InlineData("memberName", "displayName", "displayName")]
-    [InlineData("member(&a)Name", "displa(&a)yName", "displayName")]
-    [InlineData("", "", "")]
-    [InlineData(null, null, null)]
-    public void DesignerActionPropertyItem_Ctor_String_String(string memberName, string displayName, string expectedDisplayName)
-    {
-        DesignerActionPropertyItem item = new(memberName, displayName);
-        Assert.Equal(memberName, item.MemberName);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Null(item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-        Assert.Null(item.RelatedComponent);
-    }
-
-    public static IEnumerable<object[]> RelatedComponent_Set_TestData()
-    {
-        yield return new object[] { new Component() };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(RelatedComponent_Set_TestData))]
-    public void DesignerActionPropertyItem_RelatedComponent_Set_GetReturnsExpected(IComponent value)
-    {
-        DesignerActionPropertyItem item = new("memberName", "displayName", "category", "description")
-        {
-            RelatedComponent = value
-        };
-        Assert.Same(value, item.RelatedComponent);
-
-        // Set same.
-        item.RelatedComponent = value;
-        Assert.Same(value, item.RelatedComponent);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionServiceTests.cs
deleted file mode 100644
index b925d15d202..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionServiceTests.cs
+++ /dev/null
@@ -1,1079 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Collections.Specialized;
-using System.Windows.Forms.Design;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionServiceTests
-{
-    [Fact]
-    public void Ctor_IServiceProvider()
-    {
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.AddService(typeof(DesignerActionService), It.IsAny<DesignerActionService>()))
-            .Verifiable();
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        DesignerActionService service = new(mockServiceProvider.Object);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerHost)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(ISelectionService)), Times.Once());
-        mockDesignerHost.Verify(h => h.AddService(typeof(DesignerActionService), service), Times.Once());
-    }
-
-    public static IEnumerable<object[]> Add_ComponentDesignerActionList_TestData()
-    {
-        CustomDesignerActionList actionList = new(null);
-        yield return new object[] { null, new DesignerActionListCollection() };
-        yield return new object[] { new DesignerActionList(null), new DesignerActionListCollection() };
-        yield return new object[] { new NullCustomDesignerActionList(null), new DesignerActionListCollection() };
-        yield return new object[] { actionList, new DesignerActionListCollection { actionList } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Add_ComponentDesignerActionList_TestData))]
-    public void Add_ComponentDesignerActionList_Success(DesignerActionList actionList, DesignerActionListCollection expected)
-    {
-        SubDesignerActionService service = new(null);
-        using Component component = new();
-        service.Add(component, actionList);
-        Assert.True(service.Contains(component));
-        Assert.Equal(expected, service.GetComponentActions(component));
-        Assert.Equal(expected, service.GetComponentActions(component, ComponentActionsType.All));
-        Assert.Equal(expected, service.GetComponentActions(component, ComponentActionsType.Service));
-        Assert.Empty(service.GetComponentActions(component, ComponentActionsType.Component));
-
-        DesignerActionListCollection actionListBuffer1 = new();
-        service.GetComponentDesignerActions(component, actionListBuffer1);
-        Assert.Empty(actionListBuffer1);
-
-        DesignerActionListCollection actionListBuffer2 = new();
-        service.GetComponentServiceActions(component, actionListBuffer2);
-        Assert.Equal(expected, actionListBuffer2);
-    }
-
-    [Fact]
-    public void Add_ComponentDesignerActionListExisting_Success()
-    {
-        SubDesignerActionService service = new(null);
-        Component component = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        service.Add(component, actionList1);
-        service.Add(component, actionList2);
-        service.Add(component, (DesignerActionList)null);
-
-        Assert.True(service.Contains(component));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component, ComponentActionsType.All));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component, ComponentActionsType.Service));
-        Assert.Empty(service.GetComponentActions(component, ComponentActionsType.Component));
-
-        DesignerActionListCollection actionListBuffer1 = new();
-        service.GetComponentDesignerActions(component, actionListBuffer1);
-        Assert.Empty(actionListBuffer1);
-
-        DesignerActionListCollection actionListBuffer2 = new();
-        service.GetComponentServiceActions(component, actionListBuffer2);
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, actionListBuffer2);
-    }
-
-    [Fact]
-    public void Add_NullComponent_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("comp", () => service.Add((IComponent)null, (DesignerActionListCollection)null));
-        Assert.Throws<ArgumentNullException>("comp", () => service.Add((IComponent)null, (DesignerActionList)null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Add_ComponentDesignerActionList_TestData))]
-    public void Add_ComponentDesignerActionListCollection_Success(DesignerActionList actionList, DesignerActionListCollection expected)
-    {
-        SubDesignerActionService service = new(null);
-        using Component component = new();
-        service.Add(component, new DesignerActionListCollection { actionList });
-        Assert.True(service.Contains(component));
-        Assert.Equal(expected, service.GetComponentActions(component));
-        Assert.Equal(expected, service.GetComponentActions(component, ComponentActionsType.All));
-        Assert.Equal(expected, service.GetComponentActions(component, ComponentActionsType.Service));
-        Assert.Empty(service.GetComponentActions(component, ComponentActionsType.Component));
-
-        DesignerActionListCollection actionListBuffer1 = new();
-        service.GetComponentDesignerActions(component, actionListBuffer1);
-        Assert.Empty(actionListBuffer1);
-
-        DesignerActionListCollection actionListBuffer2 = new();
-        service.GetComponentServiceActions(component, actionListBuffer2);
-        Assert.Equal(expected, actionListBuffer2);
-    }
-
-    [Fact]
-    public void Add_ComponentDesignerActionListCollectionExisting_Success()
-    {
-        SubDesignerActionService service = new(null);
-        using Component component = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        service.Add(component, new DesignerActionListCollection { actionList1 });
-        service.Add(component, new DesignerActionListCollection { actionList2 });
-        service.Add(component, new DesignerActionListCollection { (DesignerActionList)null });
-
-        Assert.True(service.Contains(component));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component, ComponentActionsType.All));
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, service.GetComponentActions(component, ComponentActionsType.Service));
-        Assert.Empty(service.GetComponentActions(component, ComponentActionsType.Component));
-
-        DesignerActionListCollection actionListBuffer1 = new();
-        service.GetComponentDesignerActions(component, actionListBuffer1);
-        Assert.Empty(actionListBuffer1);
-
-        DesignerActionListCollection actionListBuffer2 = new();
-        service.GetComponentServiceActions(component, actionListBuffer2);
-        Assert.Equal(new DesignerActionListCollection { actionList1, actionList2 }, actionListBuffer2);
-    }
-
-    [Fact]
-    public void Add_NullDesignerActionListCollection_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("designerActionListCollection", () => service.Add(new Component(), (DesignerActionListCollection)null));
-    }
-
-    [Fact]
-    public void Clear_NotEmpty_Success()
-    {
-        SubDesignerActionService service = new(null);
-        Component component = new();
-        service.Add(component, new CustomDesignerActionList(null));
-        Assert.NotEmpty(service.GetComponentActions(component));
-        Assert.True(service.Contains(component));
-
-        service.Clear();
-        Assert.Empty(service.GetComponentActions(component));
-        Assert.False(service.Contains(component));
-
-        // Clear again.
-        service.Clear();
-        Assert.Empty(service.GetComponentActions(component));
-        Assert.False(service.Contains(component));
-    }
-
-    [Fact]
-    public void Clear_Empty_Success()
-    {
-        SubDesignerActionService service = new(null);
-        service.Clear();
-
-        // Clear again.
-        service.Clear();
-    }
-
-    [Fact]
-    public void Clear_InvokeWithDesignerActionListsChanged_CallsHandler()
-    {
-        SubDesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        CustomDesignerActionList actionList = new(null);
-        service.Add(component1, actionList);
-        service.Add(component2, new DesignerActionListCollection());
-
-        int callCount = 0;
-        DesignerActionListsChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(service, sender);
-            Assert.True(e.RelatedObject == component1 || e.RelatedObject == component2);
-            Assert.Equal(DesignerActionListsChangedType.ActionListsRemoved, e.ChangeType);
-            //Assert.Same(actionList, Assert.Single(e.ActionLists));
-            callCount++;
-        };
-        service.DesignerActionListsChanged += handler;
-
-        service.Clear();
-        Assert.Equal(2, callCount);
-
-        // Remove again.
-        service.Clear();
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        service.DesignerActionListsChanged -= handler;
-        service.Add(component1, actionList);
-        service.Add(component2, new DesignerActionListCollection());
-        service.Remove(component2);
-        Assert.Equal(2, callCount);
-    }
-
-    [Fact]
-    public void Contains_NoSuchComponentEmpty_ReturnsFalse()
-    {
-        DesignerActionService service = new(null);
-        Assert.False(service.Contains(new Component()));
-    }
-
-    [Fact]
-    public void Contains_NoSuchComponentNotEmpty_ReturnsFalse()
-    {
-        DesignerActionService service = new(null);
-        service.Add(new Component(), new DesignerActionListCollection());
-        Assert.False(service.Contains(new Component()));
-    }
-
-    [Fact]
-    public void Contains_NullComponent_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("comp", () => service.Contains(null));
-    }
-
-    [Fact]
-    public void Dispose_Invoke_Success()
-    {
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.AddService(typeof(DesignerActionService), It.IsAny<DesignerActionService>()));
-        mockDesignerHost
-            .Setup(h => h.RemoveService(typeof(DesignerActionService)));
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object);
-        DesignerActionService service = new(mockServiceProvider.Object);
-        service.Dispose();
-        mockDesignerHost.Verify(h => h.RemoveService(typeof(DesignerActionService)), Times.Once());
-
-        // Dispose again.
-        service.Dispose();
-        mockDesignerHost.Verify(h => h.RemoveService(typeof(DesignerActionService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Dispose_InvokeDisposing_Success(bool disposing, int expectedRemoveCallCount)
-    {
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.AddService(typeof(DesignerActionService), It.IsAny<DesignerActionService>()));
-        mockDesignerHost
-            .Setup(h => h.RemoveService(typeof(DesignerActionService)));
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        Mock<ISelectionService> mockSelectionService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object);
-        SubDesignerActionService service = new(mockServiceProvider.Object);
-        service.Dispose(disposing);
-        mockDesignerHost.Verify(h => h.RemoveService(typeof(DesignerActionService)), Times.Exactly(expectedRemoveCallCount));
-
-        // Dispose again.
-        service.Dispose(disposing);
-        mockDesignerHost.Verify(h => h.RemoveService(typeof(DesignerActionService)), Times.Exactly(expectedRemoveCallCount * 2));
-    }
-
-    public static IEnumerable<object[]> Dispose_InvalidServiceProvider_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns((IComponentChangeService)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ISelectionService)))
-            .Returns((IComponentChangeService)null);
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ISelectionService)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(Dispose_InvalidServiceProvider_TestData))]
-    public void Dispose_InvalidServiceProvider_Success(IServiceProvider serviceProvider)
-    {
-        DesignerActionService service = new(serviceProvider);
-        service.Dispose();
-
-        // Dispose again.
-        service.Dispose();
-    }
-
-    [Theory]
-    [EnumData<ComponentActionsType>]
-    [InvalidEnumData<ComponentActionsType>]
-    public void GetComponentActions_NoSuchComponentNotEmpty_ReturnsEmpty(ComponentActionsType type)
-    {
-        SubDesignerActionService service = new(null);
-        using Component component = new();
-        CustomDesignerActionList actionList = new(null);
-        service.Add(component, actionList);
-        Assert.Empty(service.GetComponentActions(new Component(), type));
-        Assert.Empty(service.GetComponentActions(new Component(), type));
-    }
-
-    [Theory]
-    [EnumData<ComponentActionsType>]
-    [InvalidEnumData<ComponentActionsType>]
-    public void GetComponentActions_NoSuchComponentEmpty_ReturnsEmpty(ComponentActionsType type)
-    {
-        SubDesignerActionService service = new(null);
-        Assert.Empty(service.GetComponentActions(new Component(), type));
-    }
-
-    [Theory]
-    [InvalidEnumData<ComponentActionsType>]
-    public void GetComponentActions_NoSuchAction_ReturnsEmpty(ComponentActionsType type)
-    {
-        SubDesignerActionService service = new(null);
-        using Component component = new();
-        CustomDesignerActionList actionList = new(null);
-        service.Add(component, actionList);
-        Assert.Empty(service.GetComponentActions(component, type));
-    }
-
-    [Fact]
-    public void GetComponentActions_NullComponent_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("component", () => service.GetComponentActions(null));
-        Assert.Throws<ArgumentNullException>("component", () => service.GetComponentActions(null, ComponentActionsType.All));
-    }
-
-    public static IEnumerable<object[]> GetComponentDesignerActions_TestData()
-    {
-        yield return new object[] { null, new DesignerActionListCollection() };
-
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        yield return new object[] { mockSite.Object, new DesignerActionListCollection() };
-
-        Mock<ISite> nullMockSite = new(MockBehavior.Strict);
-        nullMockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        yield return new object[] { nullMockSite.Object, new DesignerActionListCollection() };
-
-        Mock<ISite> invalidMockSite = new(MockBehavior.Strict);
-        invalidMockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(new object());
-        yield return new object[] { invalidMockSite.Object, new DesignerActionListCollection() };
-
-        Mock<DesignerCommandSet> nullMockDesignerCommandSet = new(MockBehavior.Strict);
-        nullMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns((ICollection)null);
-        nullMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns((ICollection)null);
-        Mock<ISite> nullCommandSetMockSite = new(MockBehavior.Strict);
-        nullCommandSetMockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(nullMockDesignerCommandSet.Object);
-        yield return new object[] { nullCommandSetMockSite.Object, new DesignerActionListCollection() };
-
-        Mock<DesignerCommandSet> emptyMockDesignerCommandSet = new(MockBehavior.Strict);
-        emptyMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns(new DesignerActionListCollection());
-        emptyMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns(new DesignerVerbCollection());
-        Mock<ISite> emptyCommandSetMockSite = new(MockBehavior.Strict);
-        emptyCommandSetMockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(emptyMockDesignerCommandSet.Object);
-        yield return new object[] { emptyCommandSetMockSite.Object, new DesignerActionListCollection() };
-
-        DesignerVerb verb = new(null, null);
-        DesignerVerbCollection verbs = new() { null, verb };
-        CustomDesignerActionList actionList = new(null);
-        DesignerActionListCollection actionLists = new() { null, new DesignerActionList(null), new NullCustomDesignerActionList(null), actionList };
-
-        Mock<DesignerCommandSet> actionListsMockDesignerCommandSet = new(MockBehavior.Strict);
-        actionListsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns(actionLists);
-        actionListsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns(verbs);
-        Mock<ISite> actionListsCommandSetMockSite = new(MockBehavior.Strict);
-        actionListsCommandSetMockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(actionListsMockDesignerCommandSet.Object);
-        yield return new object[] { actionListsCommandSetMockSite.Object, new DesignerActionListCollection { actionList } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetComponentDesignerActions_TestData))]
-    public void GetComponentDesignerActions_Invoke_ReturnsExpected(ISite site, DesignerActionListCollection expected)
-    {
-        SubDesignerActionService service = new(null);
-        Component component = new()
-        {
-            Site = site
-        };
-
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentDesignerActions(component, actionListBuffer);
-        Assert.Equal(expected, actionListBuffer);
-    }
-
-    [Fact]
-    public void GetComponentDesignerActions_InvokeVerbs_ReturnsExpected()
-    {
-        DesignerVerb verb = new(null, null);
-        DesignerVerbCollection verbs = new() { null, new DesignerVerb(null, null) { Enabled = false }, new DesignerVerb(null, null) { Visible = false }, verb };
-        Mock<DesignerCommandSet> verbsMockDesignerCommandSet = new(MockBehavior.Strict);
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns(new DesignerActionListCollection());
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns(verbs);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(verbsMockDesignerCommandSet.Object);
-        SubDesignerActionService service = new(null);
-        Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentDesignerActions(component, actionListBuffer);
-        DesignerActionList actionList = Assert.IsAssignableFrom<DesignerActionList>(Assert.Single(actionListBuffer));
-        Assert.False(actionList.AutoShow);
-        Assert.Null(actionList.Component);
-
-        DesignerActionItemCollection verbActionActionItems = actionList.GetSortedActionItems();
-        DesignerActionMethodItem actionItem = Assert.IsAssignableFrom<DesignerActionMethodItem>(Assert.Single(verbActionActionItems));
-        Assert.Equal("Verbs", actionItem.Category);
-        Assert.False(actionItem.AllowAssociate);
-        Assert.Null(actionItem.Description);
-        Assert.False(actionItem.IncludeAsDesignerVerb);
-        Assert.Null(actionItem.MemberName);
-        Assert.Empty(actionItem.DisplayName);
-        Assert.Empty(actionItem.Properties);
-        Assert.Same(actionItem.Properties, actionItem.Properties);
-        Assert.IsType<HybridDictionary>(actionItem.Properties);
-        Assert.Null(actionItem.RelatedComponent);
-        Assert.True(actionItem.ShowInSourceView);
-    }
-
-    [Fact]
-    public void GetComponentDesignerActionsVerbs_GetSortedActionItems_ReturnsExpected()
-    {
-        DesignerVerb verb = new(null, null);
-        DesignerVerbCollection verbs = new() { null, new DesignerVerb(null, null) { Enabled = false }, new DesignerVerb(null, null) { Visible = false }, verb };
-        Mock<DesignerCommandSet> verbsMockDesignerCommandSet = new(MockBehavior.Strict);
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns(new DesignerActionListCollection());
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns(verbs);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(verbsMockDesignerCommandSet.Object);
-        SubDesignerActionService service = new(null);
-        Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentDesignerActions(component, actionListBuffer);
-        DesignerActionList actionList = Assert.IsAssignableFrom<DesignerActionList>(Assert.Single(actionListBuffer));
-        Assert.Single(actionList.GetSortedActionItems());
-
-        // Not Disabled.
-        verb.Enabled = false;
-        Assert.Empty(actionList.GetSortedActionItems());
-        verb.Enabled = true;
-
-        // Not Visible.
-        verb.Visible = false;
-        Assert.Empty(actionList.GetSortedActionItems());
-        verb.Visible = true;
-
-        // Not Supported.
-        verb.Supported = false;
-        Assert.Empty(actionList.GetSortedActionItems());
-        verb.Supported = true;
-
-        // Back to normal.
-        Assert.Single(actionList.GetSortedActionItems());
-    }
-
-    [Fact]
-    public void GetComponentDesignerActionsVerbs_InvokeActionItem_CallsVerbInvoke()
-    {
-        DesignerVerb verb = null;
-        int invokeCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(verb, sender);
-            Assert.Same(EventArgs.Empty, e);
-            invokeCallCount++;
-        };
-        verb = new DesignerVerb("text", handler);
-
-        DesignerVerbCollection verbs = new() { null, new DesignerVerb(null, null) { Enabled = false }, new DesignerVerb(null, null) { Visible = false }, verb };
-        Mock<DesignerCommandSet> verbsMockDesignerCommandSet = new(MockBehavior.Strict);
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("ActionLists"))
-            .Returns(new DesignerActionListCollection());
-        verbsMockDesignerCommandSet
-            .Setup(c => c.GetCommands("Verbs"))
-            .Returns(verbs);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .As<IServiceContainer>()
-            .Setup(s => s.GetService(typeof(DesignerCommandSet)))
-            .Returns(verbsMockDesignerCommandSet.Object);
-        SubDesignerActionService service = new(null);
-        Component component = new()
-        {
-            Site = mockSite.Object
-        };
-
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentDesignerActions(component, actionListBuffer);
-        DesignerActionList actionList = Assert.IsAssignableFrom<DesignerActionList>(Assert.Single(actionListBuffer));
-        DesignerActionItemCollection verbActionActionItems = actionList.GetSortedActionItems();
-        DesignerActionMethodItem actionItem = Assert.IsAssignableFrom<DesignerActionMethodItem>(Assert.Single(actionList.GetSortedActionItems()));
-
-        Assert.Equal(0, invokeCallCount);
-        actionItem.Invoke();
-        Assert.Equal(1, invokeCallCount);
-    }
-
-    [Fact]
-    public void GetComponentDesignerActions_NullComponent_ThrowsArgumentNullException()
-    {
-        SubDesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("component", () => service.GetComponentDesignerActions(null, null));
-    }
-
-    [Fact]
-    public void GetComponentDesignerActions_NullActionLists_ThrowsArgumentNullException()
-    {
-        SubDesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("actionLists", () => service.GetComponentDesignerActions(new Component(), null));
-    }
-
-    [Fact]
-    public void GetComponentServiceActions_NoSuchComponentNotEmpty_ReturnsEmpty()
-    {
-        SubDesignerActionService service = new(null);
-        Component component = new();
-        CustomDesignerActionList actionList = new(null);
-        service.Add(component, actionList);
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentServiceActions(new Component(), actionListBuffer);
-        Assert.Empty(actionListBuffer);
-    }
-
-    [Fact]
-    public void GetComponentServiceActions_NoSuchComponentEmpty_ReturnsEmpty()
-    {
-        SubDesignerActionService service = new(null);
-        DesignerActionListCollection actionListBuffer = new();
-        service.GetComponentServiceActions(new Component(), actionListBuffer);
-        Assert.Empty(actionListBuffer);
-    }
-
-    [Fact]
-    public void GetComponentServiceActions_NullComponent_ThrowsArgumentNullException()
-    {
-        SubDesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("component", () => service.GetComponentServiceActions(null, null));
-    }
-
-    [Fact]
-    public void GetComponentServiceActions_NullActionLists_ThrowsArgumentNullException()
-    {
-        SubDesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("actionLists", () => service.GetComponentServiceActions(new Component(), null));
-    }
-
-    [Fact]
-    public void Remove_InvokeComponent_Success()
-    {
-        DesignerActionService service = new(null);
-        using Component component = new();
-        service.Add(component, new CustomDesignerActionList(null));
-        Assert.NotEmpty(service.GetComponentActions(component));
-        Assert.True(service.Contains(component));
-
-        service.Remove(component);
-        Assert.Empty(service.GetComponentActions(component));
-        Assert.False(service.Contains(component));
-
-        // Remove again.
-        service.Remove(component);
-        Assert.Empty(service.GetComponentActions(component));
-        Assert.False(service.Contains(component));
-    }
-
-    [Fact]
-    public void Remove_InvokeComponentWithDesignerActionListsChanged_CallsHandler()
-    {
-        DesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        CustomDesignerActionList actionList = new(null);
-        service.Add(component1, actionList);
-        service.Add(component2, new DesignerActionListCollection());
-
-        int callCount = 0;
-        DesignerActionListsChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(service, sender);
-            Assert.Same(component1, e.RelatedObject);
-            Assert.Equal(DesignerActionListsChangedType.ActionListsRemoved, e.ChangeType);
-            Assert.Empty(e.ActionLists);
-            callCount++;
-        };
-        service.DesignerActionListsChanged += handler;
-
-        service.Remove(component1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove again.
-        service.Remove(component1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        service.DesignerActionListsChanged -= handler;
-        service.Remove(component2);
-        Assert.False(service.Contains(component2));
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void Remove_NoSuchComponentNotEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        service.Add(new Component(), new DesignerActionListCollection());
-        service.Remove(new Component());
-    }
-
-    [Fact]
-    public void Remove_NoSuchComponentEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        service.Remove(new Component());
-    }
-
-    [Fact]
-    public void Remove_InvokeDesignerActionList_Success()
-    {
-        DesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        using Component component3 = new();
-        using Component component4 = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        CustomDesignerActionList actionList3 = new(null);
-        CustomDesignerActionList actionList4 = new(null);
-        service.Add(component1, actionList1);
-        service.Add(component2, actionList2);
-        service.Add(component2, actionList3);
-        service.Add(component3, actionList3);
-        service.Add(component4, actionList4);
-        service.Add(component4, actionList4);
-
-        service.Remove(actionList1);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList2, actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove again.
-        service.Remove(actionList1);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList2, actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove partial.
-        service.Remove(actionList2);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove across multiple components.
-        service.Remove(actionList3);
-        Assert.Empty(service.GetComponentActions(component1));
-        // Random based off ordering of Dictionary keys.
-        if (service.GetComponentActions(component2).Count == 1)
-        {
-            Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component2));
-            Assert.Empty(service.GetComponentActions(component3));
-        }
-        else
-        {
-            Assert.Empty(service.GetComponentActions(component2));
-            Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        }
-
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        if (service.GetComponentActions(component2).Count == 1)
-        {
-            Assert.True(service.Contains(component2));
-            Assert.False(service.Contains(component3));
-        }
-        else
-        {
-            Assert.False(service.Contains(component2));
-            Assert.True(service.Contains(component3));
-        }
-
-        Assert.True(service.Contains(component4));
-
-        // Remove duplicates.
-        service.Remove(actionList4);
-        Assert.Empty(service.GetComponentActions(component1));
-        // Random based off ordering of Dictionary keys.
-        if (service.GetComponentActions(component2).Count == 1)
-        {
-            Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component2));
-            Assert.Empty(service.GetComponentActions(component3));
-        }
-        else
-        {
-            Assert.Empty(service.GetComponentActions(component2));
-            Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        }
-
-        Assert.Empty(service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        if (service.GetComponentActions(component2).Count == 1)
-        {
-            Assert.True(service.Contains(component2));
-            Assert.False(service.Contains(component3));
-        }
-        else
-        {
-            Assert.False(service.Contains(component2));
-            Assert.True(service.Contains(component3));
-        }
-
-        Assert.True(service.Contains(component4));
-    }
-
-    [Fact]
-    public void Remove_NoSuchActionListNotEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        Component component = new();
-        service.Add(component, new CustomDesignerActionList(null));
-        service.Remove(new CustomDesignerActionList(null));
-        Assert.Single(service.GetComponentActions(component));
-    }
-
-    [Fact]
-    public void Remove_NoSuchActionListEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        service.Remove(new CustomDesignerActionList(null));
-    }
-
-    [Fact]
-    public void Remove_InvokeDesignerActionListWithDesignerActionListsChanged_CallsHandler()
-    {
-        DesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        service.Add(component1, actionList1);
-        service.Add(component2, actionList2);
-
-        int callCount = 0;
-        DesignerActionListsChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(service, sender);
-            Assert.Same(component1, e.RelatedObject);
-            Assert.Equal(DesignerActionListsChangedType.ActionListsRemoved, e.ChangeType);
-            Assert.Empty(e.ActionLists);
-            callCount++;
-        };
-        service.DesignerActionListsChanged += handler;
-
-        service.Remove(actionList1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove again.
-        service.Remove(actionList1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        service.DesignerActionListsChanged -= handler;
-        service.Remove(actionList2);
-        Assert.False(service.Contains(component2));
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void Remove_InvokeComponentDesignerActionList_Success()
-    {
-        DesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        using Component component3 = new();
-        using Component component4 = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        CustomDesignerActionList actionList3 = new(null);
-        CustomDesignerActionList actionList4 = new(null);
-        service.Add(component1, actionList1);
-        service.Add(component2, actionList2);
-        service.Add(component2, actionList3);
-        service.Add(component3, actionList3);
-        service.Add(component4, actionList4);
-        service.Add(component4, actionList4);
-
-        service.Remove(component1, actionList1);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList2, actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove again.
-        service.Remove(component1, actionList1);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList2, actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove partial.
-        service.Remove(component2, actionList2);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.True(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove across multiple components.
-        service.Remove(component2, actionList3);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Empty(service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Equal(new DesignerActionListCollection { actionList4, actionList4 }, service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.False(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-
-        // Remove duplicates.
-        service.Remove(actionList4);
-        Assert.Empty(service.GetComponentActions(component1));
-        Assert.Empty(service.GetComponentActions(component2));
-        Assert.Equal(new DesignerActionListCollection { actionList3 }, service.GetComponentActions(component3));
-        Assert.Empty(service.GetComponentActions(component4));
-        Assert.False(service.Contains(component1));
-        Assert.False(service.Contains(component2));
-        Assert.True(service.Contains(component3));
-        Assert.True(service.Contains(component4));
-    }
-
-    [Fact]
-    public void Remove_NoSuchComponentActionListNotEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        using Component component = new();
-        service.Add(component, new CustomDesignerActionList(null));
-        service.Remove(new Component(), new CustomDesignerActionList(null));
-        service.Remove(component, new CustomDesignerActionList(null));
-        Assert.Single(service.GetComponentActions(component));
-    }
-
-    [Fact]
-    public void Remove_NoSuchComponentActionListEmpty_Nop()
-    {
-        DesignerActionService service = new(null);
-        service.Remove(new Component(), new CustomDesignerActionList(null));
-    }
-
-    [Fact]
-    public void Remove_InvokeComponentDesignerActionListWithDesignerActionListsChanged_CallsHandler()
-    {
-        DesignerActionService service = new(null);
-        using Component component1 = new();
-        using Component component2 = new();
-        CustomDesignerActionList actionList1 = new(null);
-        CustomDesignerActionList actionList2 = new(null);
-        service.Add(component1, actionList1);
-        service.Add(component2, actionList2);
-
-        int callCount = 0;
-        DesignerActionListsChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(service, sender);
-            Assert.Same(component1, e.RelatedObject);
-            Assert.Equal(DesignerActionListsChangedType.ActionListsRemoved, e.ChangeType);
-            Assert.Empty(e.ActionLists);
-            callCount++;
-        };
-        service.DesignerActionListsChanged += handler;
-
-        service.Remove(component1, actionList1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove again.
-        service.Remove(component1, actionList1);
-        Assert.False(service.Contains(component1));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        service.DesignerActionListsChanged -= handler;
-        service.Remove(component2, actionList2);
-        Assert.False(service.Contains(component2));
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void Remove_NullComponent_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("comp", () => service.Remove((IComponent)null));
-        Assert.Throws<ArgumentNullException>("comp", () => service.Remove((IComponent)null, null));
-    }
-
-    [Fact]
-    public void Remove_NullActionList_ThrowsArgumentNullException()
-    {
-        DesignerActionService service = new(null);
-        Assert.Throws<ArgumentNullException>("actionList", () => service.Remove((DesignerActionList)null));
-        Assert.Throws<ArgumentNullException>("actionList", () => service.Remove(new Component(), (DesignerActionList)null));
-    }
-
-    private class SubDesignerActionService : DesignerActionService
-    {
-        public SubDesignerActionService(IServiceProvider serviceProvider) : base(serviceProvider)
-        {
-        }
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new void GetComponentDesignerActions(IComponent component, DesignerActionListCollection actionLists)
-        {
-            base.GetComponentDesignerActions(component, actionLists);
-        }
-
-        public new void GetComponentServiceActions(IComponent component, DesignerActionListCollection actionLists)
-        {
-            base.GetComponentServiceActions(component, actionLists);
-        }
-    }
-
-    private class CustomDesignerActionList : DesignerActionList
-    {
-        public CustomDesignerActionList(IComponent component) : base(component)
-        {
-        }
-
-        public void PublicMethod()
-        {
-        }
-    }
-
-    private class NullCustomDesignerActionList : DesignerActionList
-    {
-        public NullCustomDesignerActionList(IComponent component) : base(component)
-        {
-        }
-
-        public override DesignerActionItemCollection GetSortedActionItems() => null;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionTextItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionTextItemTests.cs
deleted file mode 100644
index 3067851f318..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionTextItemTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionTextItemTests
-{
-    [Theory]
-    [InlineData("displayName", "category", "displayName")]
-    [InlineData("displa(&a)yName", "cate(&a)gory", "displayName")]
-    [InlineData("", "", "")]
-    [InlineData(null, null, null)]
-    public void DesignerActionItem_Ctor_String_String(string displayName, string category, string expectedDisplayName)
-    {
-        DesignerActionTextItem item = new(displayName, category);
-        Assert.Equal(expectedDisplayName, item.DisplayName);
-        Assert.Equal(category, item.Category);
-        Assert.Null(item.Description);
-        Assert.False(item.AllowAssociate);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.IsType<HybridDictionary>(item.Properties);
-        Assert.True(item.ShowInSourceView);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionUIStateChangeEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionUIStateChangeEventArgsTests.cs
deleted file mode 100644
index b86c5e824c1..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerActionUIStateChangeEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerActionUIStateChangeEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Object_DesignerActionUIStateChangeType_TestData()
-    {
-        yield return new object[] { null, DesignerActionUIStateChangeType.Show - 1 };
-        yield return new object[] { new object(), DesignerActionUIStateChangeType.Show };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Object_DesignerActionUIStateChangeType_TestData))]
-    public void Ctor_Object_DesignerActionUIStateChangeType(object relatedObject, DesignerActionUIStateChangeType changeType)
-    {
-        DesignerActionUIStateChangeEventArgs e = new(relatedObject, changeType);
-        Assert.Same(relatedObject, e.RelatedObject);
-        Assert.Equal(changeType, e.ChangeType);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerCommandSetTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerCommandSetTests.cs
deleted file mode 100644
index e5c158c268b..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerCommandSetTests.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerCommandSetTests
-{
-    [Fact]
-    public void DesignerCommandSet_Ctor_Default()
-    {
-        DesignerCommandSet set = new();
-        Assert.Null(set.ActionLists);
-        Assert.Null(set.Verbs);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DesignerCommandSet_GetCommands_Invoke_ReturnsNull(string name)
-    {
-        DesignerCommandSet set = new();
-        Assert.Null(set.GetCommands(name));
-    }
-
-    [Fact]
-    public void DesignerCommandSet_Verbs_OverridenGetCommands_ReturnsExpected()
-    {
-        DesignerVerbCollection collection = new();
-        Mock<DesignerCommandSet> mockSet = new(MockBehavior.Strict);
-        mockSet
-            .Setup(s => s.GetCommands("Verbs"))
-            .Returns(collection);
-        Assert.Same(collection, mockSet.Object.Verbs);
-    }
-
-    [Fact]
-    public void DesignerCommandSet_Verbs_InvalidOverridenGetCommands_ThrowsInvalidCastException()
-    {
-        Mock<DesignerCommandSet> mockSet = new(MockBehavior.Strict);
-        mockSet
-            .Setup(s => s.GetCommands("Verbs"))
-            .Returns(Array.Empty<object>());
-        Assert.Throws<InvalidCastException>(() => mockSet.Object.Verbs);
-    }
-
-    [Fact]
-    public void DesignerCommandSet_ActionLists_OverridenGetCommands_ReturnsExpected()
-    {
-        DesignerActionListCollection collection = new();
-        Mock<DesignerCommandSet> mockSet = new(MockBehavior.Strict);
-        mockSet
-            .Setup(s => s.GetCommands("ActionLists"))
-            .Returns(collection);
-        Assert.Same(collection, mockSet.Object.ActionLists);
-    }
-
-    [Fact]
-    public void DesignerCommandSet_ActionLists_InvalidOverridenGetCommands_ThrowsInvalidCastException()
-    {
-        Mock<DesignerCommandSet> mockSet = new(MockBehavior.Strict);
-        mockSet
-            .Setup(s => s.GetCommands("ActionLists"))
-            .Returns(Array.Empty<object>());
-        Assert.Throws<InvalidCastException>(() => mockSet.Object.ActionLists);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerHostTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerHostTests.cs
deleted file mode 100644
index 3f3796e49ee..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerHostTests.cs
+++ /dev/null
@@ -1,3307 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel.Design.Serialization;
-using System.Reflection;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerHostTests
-{
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_CanReloadWithErrors_Set_GetReturnsExpected(bool value)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        host.CanReloadWithErrors = value;
-        Assert.Equal(value, host.CanReloadWithErrors);
-
-        // Set same.
-        host.CanReloadWithErrors = value;
-        Assert.Equal(value, host.CanReloadWithErrors);
-
-        // Set different.
-        host.CanReloadWithErrors = !value;
-        Assert.Equal(!value, host.CanReloadWithErrors);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Container_Get_ReturnsHost()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Same(host, host.Container);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_IgnoreErrorsDuringReload_Set_GetReturnsExpected(bool value)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        host.IgnoreErrorsDuringReload = value;
-        Assert.False(host.IgnoreErrorsDuringReload);
-
-        // Set same.
-        host.IgnoreErrorsDuringReload = value;
-        Assert.False(host.IgnoreErrorsDuringReload);
-
-        // Set different.
-        host.IgnoreErrorsDuringReload = !value;
-        Assert.False(host.IgnoreErrorsDuringReload);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_IgnoreErrorsDuringReload_SetWithCanReloadWithErrors_GetReturnsExpected(bool value)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        host.CanReloadWithErrors = true;
-
-        host.IgnoreErrorsDuringReload = value;
-        Assert.Equal(value, host.IgnoreErrorsDuringReload);
-
-        // Set same.
-        host.IgnoreErrorsDuringReload = value;
-        Assert.Equal(value, host.IgnoreErrorsDuringReload);
-
-        // Set different.
-        host.IgnoreErrorsDuringReload = !value;
-        Assert.Equal(!value, host.IgnoreErrorsDuringReload);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_InTransaction_GetWithoutTransactions_ReturnsFalse()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.False(host.InTransaction);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IsClosingTransaction_GetWithoutTransaction_ReturnsFalse()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerHostTransactionState hostTransactionState = Assert.IsAssignableFrom<IDesignerHostTransactionState>(surface.Host);
-        Assert.False(hostTransactionState.IsClosingTransaction);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Loading_GetWithoutComponent_ReturnsFalse()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_Loading_GetWithLoader_ReturnsExpected(bool loading)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        mockLoader
-            .Setup(l => l.Loading)
-            .Returns(loading);
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-        mockLoader.Verify(l => l.Loading, Times.Never());
-
-        host.EndLoad(null, true, null);
-        Assert.Equal(loading, host.Loading);
-        mockLoader.Verify(l => l.Loading, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_RootComponent_GetWithoutComponent_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Null(host.RootComponent);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_RootComponentClassName_GetWithoutComponent_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Null(host.RootComponentClassName);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_TransactionDescription_GetWithoutTransactions_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Null(host.TransactionDescription);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Activate_Invoke_CallsViewActivated()
-    {
-        using SubDesignSurface surface = new();
-        int viewActivatedCallCount = 0;
-        int activatedCallCount = 0;
-        surface.ViewActivated += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            viewActivatedCallCount++;
-        };
-        IDesignerLoaderHost2 host = surface.Host;
-        host.Activated += (sender, e) => activatedCallCount++;
-        host.Activate();
-        Assert.Equal(1, viewActivatedCallCount);
-        Assert.Equal(0, activatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Activate_InvokeDisposed_Nop()
-    {
-        using SubDesignSurface surface = new();
-        int viewActivatedCallCount = 0;
-        int activatedCallCount = 0;
-        surface.ViewActivated += (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            viewActivatedCallCount++;
-        };
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.Dispose();
-        host.Activated += (sender, e) => activatedCallCount++;
-        host.Activate();
-        Assert.Equal(0, viewActivatedCallCount);
-        Assert.Equal(0, activatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Add_InvalidNameCreationServiceParentProvider_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(new object());
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(new object());
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object };
-    }
-
-    public static IEnumerable<object[]> Add_ComponentParentProvider_TestData()
-    {
-        foreach (object[] testData in Add_InvalidNameCreationServiceParentProvider_TestData())
-        {
-            yield return new object[] { testData[0], string.Empty };
-        }
-
-        foreach (string name in new string[] { null, string.Empty, "name" })
-        {
-            Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-            mockNameCreationService
-                .Setup(s => s.CreateName(It.IsAny<IContainer>(), It.IsAny<Type>()))
-                .Returns(name);
-            Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(ContainerFilterService)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(IInheritanceService)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(INameCreationService)))
-                .Returns(mockNameCreationService.Object);
-            yield return new object[] { mockServiceProvider.Object, name };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_ComponentParentProvider_TestData))]
-    public void DesignerHost_Add_ComponentWithRootDesigner_Success(IServiceProvider parentProvider, string expectedName)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        using DesignerComponent component3 = new();
-        using Component component4 = new();
-
-        host.Container.Add(component1);
-        Assert.Same(component1, Assert.Single(host.Container.Components));
-        Assert.Same(expectedName, host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(host, component1.Container);
-        Assert.Same(component1, component1.Site.Component);
-        Assert.Same(host, component1.Site.Container);
-        Assert.True(component1.Site.DesignMode);
-        Assert.Equal(expectedName, component1.Site.Name);
-
-        // Add different - root designer.
-        host.Container.Add(component2);
-        Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(expectedName, host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(host, component2.Container);
-        Assert.Same(component2, component2.Site.Component);
-        Assert.Same(host, component2.Site.Container);
-        Assert.True(component2.Site.DesignMode);
-        Assert.Equal(expectedName, component2.Site.Name);
-
-        // Add different - non root designer.
-        host.Container.Add(component3);
-        Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(expectedName, host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(host, component3.Container);
-        Assert.Same(component3, component3.Site.Component);
-        Assert.Same(host, component3.Site.Container);
-        Assert.True(component3.Site.DesignMode);
-        Assert.Equal(expectedName, component3.Site.Name);
-
-        // Add different - non designer.
-        host.Container.Add(component4);
-        Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(expectedName, host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(host, component4.Container);
-        Assert.Same(component4, component4.Site.Component);
-        Assert.Same(host, component4.Site.Container);
-        Assert.True(component4.Site.DesignMode);
-        Assert.Equal(expectedName, component4.Site.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_InvalidNameCreationServiceParentProvider_TestData))]
-    public void DesignerHost_Add_ComponentStringWithRootDesigner_Success(IServiceProvider parentProvider)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        using DesignerComponent component3 = new();
-        using Component component4 = new();
-
-        host.Container.Add(component1, "name1");
-        Assert.Same(component1, Assert.Single(host.Container.Components));
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(host, component1.Container);
-        Assert.Same(component1, component1.Site.Component);
-        Assert.Same(host, component1.Site.Container);
-        Assert.True(component1.Site.DesignMode);
-        Assert.Equal("name1", component1.Site.Name);
-
-        // Add different - root designer.
-        host.Container.Add(component2, "name2");
-        Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(host, component2.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component2, component2.Site.Component);
-        Assert.Same(host, component2.Site.Container);
-        Assert.True(component2.Site.DesignMode);
-        Assert.Equal("name2", component2.Site.Name);
-
-        // Add different - non root designer.
-        host.Container.Add(component3, string.Empty);
-        Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(host, component3.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component3, component3.Site.Component);
-        Assert.Same(host, component3.Site.Container);
-        Assert.True(component3.Site.DesignMode);
-        Assert.Empty(component3.Site.Name);
-
-        // Add different - non designer.
-        host.Container.Add(component4, null);
-        Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>());
-        Assert.Same(host, component4.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component4, component4.Site.Component);
-        Assert.Same(host, component4.Site.Container);
-        Assert.True(component4.Site.DesignMode);
-        Assert.Empty(component4.Site.Name);
-    }
-
-    public static IEnumerable<object[]> Add_IExtenderProviderServiceWithoutDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent(), 0 };
-        yield return new object[] { new RootExtenderProviderDesignerComponent(), 1 };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent, 0 };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent, 1 };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_IExtenderProviderServiceWithoutDefault_TestData))]
-    public void DesignerHost_Add_IExtenderProviderServiceWithoutDefault_Success(Component component, int expectedCallCount)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount));
-
-        // Add again.
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount));
-
-        // Add again with name.
-        host.Container.Add(component, "name");
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Equal("name", component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount));
-    }
-
-    public static IEnumerable<object[]> Add_IExtenderProviderServiceWithDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent() };
-        yield return new object[] { new RootExtenderProviderDesignerComponent() };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_IExtenderProviderServiceWithDefault_TestData))]
-    public void DesignerHost_Add_IExtenderProviderServiceWithDefault_DoesNotCallGetService(Component component)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Add again.
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Add again with name.
-        host.Container.Add(component, "name");
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Equal("name", component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-    }
-
-    public static IEnumerable<object[]> InvalidIExtenderProviderService_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(null)
-            .Verifiable();
-        yield return new object[] { nullMockServiceProvider };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(new object())
-            .Verifiable();
-        yield return new object[] { invalidMockServiceProvider };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void DesignerHost_Add_InvalidIExtenderProviderServiceWithoutDefault_CallsParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootExtenderProviderDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void DesignerHost_Add_InvalidIExtenderProviderServiceWithDefault_DoesNotCallParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootExtenderProviderDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_SameComponent_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-
-        // Add again.
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-
-        // Add again with name.
-        host.Container.Add(component, "name");
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Equal("name", component.Site.Name);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ComponentWithNameCreationServiceWithoutName_CallsCreateName()
-    {
-        Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-        mockNameCreationService
-            .Setup(s => s.CreateName(It.IsAny<IContainer>(), It.IsAny<Type>()))
-            .Returns("name")
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(mockNameCreationService.Object);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Equal("name", component.Site.Name);
-        mockNameCreationService.Verify(s => s.CreateName(host.Container, typeof(RootDesignerComponent)), Times.Once());
-
-        host.Container.Add(component, null);
-        Assert.Equal("name", component.Site.Name);
-        mockNameCreationService.Verify(s => s.CreateName(host.Container, typeof(RootDesignerComponent)), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ComponentWithNameCreationServiceWithCustomReflectionType_CallsCreateName()
-    {
-        using CustomTypeDescriptionProviderComponent component = new();
-        Mock<ICustomTypeDescriptor> mockCustomTypeDescriptor = new(MockBehavior.Strict);
-        mockCustomTypeDescriptor
-            .Setup(d => d.GetAttributes())
-            .Returns(TypeDescriptor.GetAttributes(typeof(CustomTypeDescriptionProviderComponent)));
-        Mock<TypeDescriptionProvider> mockProvider = new(MockBehavior.Strict);
-        mockProvider
-            .Setup(p => p.GetReflectionType(typeof(CustomTypeDescriptionProviderComponent), component))
-            .Returns(typeof(RootDesignerComponent))
-            .Verifiable();
-        mockProvider
-            .Setup(p => p.GetTypeDescriptor(typeof(CustomTypeDescriptionProviderComponent), component))
-            .Returns(mockCustomTypeDescriptor.Object);
-        mockProvider
-            .Setup(p => p.GetCache(component))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(component))
-            .CallBase();
-        TypeDescriptor.AddProvider(mockProvider.Object, component);
-
-        Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-        mockNameCreationService
-            .Setup(s => s.CreateName(It.IsAny<IContainer>(), It.IsAny<Type>()))
-            .Returns("name")
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(mockNameCreationService.Object);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.Container.Add(component);
-        Assert.Equal("name", component.Site.Name);
-        mockNameCreationService.Verify(s => s.CreateName(host.Container, typeof(RootDesignerComponent)), Times.Once());
-
-        host.Container.Add(component, null);
-        Assert.Equal("name", component.Site.Name);
-        mockNameCreationService.Verify(s => s.CreateName(host.Container, typeof(RootDesignerComponent)), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void DesignerHost_Add_ComponentWithNameCreationServiceWithName_CallsValidateName(string name)
-    {
-        Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-        mockNameCreationService
-            .Setup(s => s.ValidateName(It.IsAny<string>()))
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(mockNameCreationService.Object)
-            .Verifiable();
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        host.Container.Add(component1, name);
-        Assert.Same(name, component1.Site.Name);
-        mockNameCreationService.Verify(s => s.ValidateName(name), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(INameCreationService)), Times.Once());
-
-        // Add another.
-        using DesignerComponent component2 = new();
-        host.Container.Add(component2, "name2");
-        Assert.Equal("name2", component2.Site.Name);
-        mockNameCreationService.Verify(s => s.ValidateName("name2"), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(INameCreationService)), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ComponentWithTypeDescriptionProviderServiceWithoutProjectTargetFrameworkAttribute_AddsProvider()
-    {
-        ICustomTypeDescriptor descriptor = TypeDescriptor.GetProvider(typeof(RootDesignerComponent)).GetTypeDescriptor(typeof(RootDesignerComponent));
-        Mock<TypeDescriptionProvider> mockTypeDescriptionProvider = new(MockBehavior.Strict);
-        mockTypeDescriptionProvider
-            .Setup(p => p.IsSupportedType(typeof(int)))
-            .Returns(false)
-            .Verifiable();
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetTypeDescriptor(It.IsAny<Type>(), It.IsAny<object>()))
-            .Returns(descriptor);
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetCache(It.IsAny<object>()))
-            .CallBase();
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(It.IsAny<object>()))
-            .CallBase();
-        Mock<TypeDescriptionProviderService> mockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        mockTypeDescriptionProviderService
-            .Setup(s => s.GetProvider(It.IsAny<object>()))
-            .Returns(mockTypeDescriptionProvider.Object)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(mockTypeDescriptionProviderService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        host.Container.Add(component1, "name1");
-        Assert.Equal("name1", component1.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Once());
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(component1), Times.Once());
-
-        // Make sure we added the TypeDescriptionProvider.
-        Assert.False(TypeDescriptor.GetProvider(component1).IsSupportedType(typeof(int)));
-        mockTypeDescriptionProvider.Verify(p => p.IsSupportedType(typeof(int)), Times.Once());
-
-        // Add again.
-        using DesignerComponent component2 = new();
-        host.Container.Add(component2, "name2");
-        Assert.Equal("name2", component2.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Once());
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(component2), Times.Once());
-
-        // Make sure we added the TypeDescriptionProvider.
-        Assert.False(TypeDescriptor.GetProvider(component2).IsSupportedType(typeof(int)));
-        mockTypeDescriptionProvider.Verify(p => p.IsSupportedType(typeof(int)), Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ComponentWithNullTypeDescriptionProviderService_Success()
-    {
-        Mock<TypeDescriptionProviderService> mockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        mockTypeDescriptionProviderService
-            .Setup(s => s.GetProvider(It.IsAny<object>()))
-            .Returns<TypeDescriptionProvider>(null)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(mockTypeDescriptionProviderService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component, "name1");
-        Assert.Equal("name1", component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Once());
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(component), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ComponentWithTypeDescriptionProviderServiceWithProjectTargetFrameworkAttribute_DoesNotAddProvider()
-    {
-        using RootDesignerComponent component = new();
-        ICustomTypeDescriptor descriptor = TypeDescriptor.GetProvider(typeof(RootDesignerComponent)).GetTypeDescriptor(typeof(RootDesignerComponent));
-        Mock<TypeDescriptionProvider> mockTypeDescriptionProvider = new(MockBehavior.Strict);
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetTypeDescriptor(It.IsAny<Type>(), It.IsAny<object>()))
-            .Returns(descriptor);
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetCache(component))
-            .CallBase();
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(It.IsAny<object>()))
-            .CallBase();
-        mockTypeDescriptionProvider
-            .Setup(p => p.GetReflectionType(typeof(object), null))
-            .Returns(typeof(ClassWithProjectTargetFrameworkAttribute));
-        TypeDescriptor.AddProvider(mockTypeDescriptionProvider.Object, component);
-
-        Mock<TypeDescriptionProviderService> mockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(mockTypeDescriptionProviderService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        host.Container.Add(component, "name1");
-        Assert.Equal("name1", component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Once());
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(component), Times.Never());
-    }
-
-    [WinFormsFact(Skip = "Unstable test, see: https://github.com/dotnet/winforms/issues/1460")]
-    public void DesignerHost_Add_DuringUnload_ThrowsException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(RootDesignerComponent));
-
-        using DesignerComponent component = new();
-        host.Container.Add(component);
-        int callCount = 0;
-        component.Disposed += (sender, e) =>
-        {
-            using DesignerComponent newComponent = new();
-            Assert.Throws<Exception>(() => host.Container.Add(newComponent));
-            callCount++;
-        };
-        surface.Dispose();
-        Assert.Equal(1, callCount);
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetKey_NoDictionary_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        Assert.Null(service.GetKey(null));
-        Assert.Null(service.GetKey(new object()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetKey_NoSuchKeyWithDictionary_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        object key1 = new();
-        object value1 = new();
-        service.SetValue(key1, value1);
-        Assert.Same(key1, service.GetKey(value1));
-        Assert.Same(value1, service.GetValue(key1));
-
-        Assert.Null(service.GetKey(null));
-        Assert.Null(service.GetKey(new object()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetValue_NoDictionary_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        Assert.Null(service.GetValue(new object()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetValue_NoSuchValueWithDictionary_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        object key1 = new();
-        object value1 = new();
-        service.SetValue(key1, value1);
-        Assert.Same(key1, service.GetKey(value1));
-        Assert.Same(value1, service.GetValue(key1));
-
-        Assert.Null(service.GetValue(new object()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetValue_NullValueNoDictionary_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        Assert.Throws<ArgumentNullException>("key", () => service.GetValue(null));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceGetValue_NullValueWithDictionary_ThrowsArgumentNullException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        object key1 = new();
-        object value1 = new();
-        service.SetValue(key1, value1);
-        Assert.Same(key1, service.GetKey(value1));
-        Assert.Same(value1, service.GetValue(key1));
-
-        Assert.Throws<ArgumentNullException>("key", () => service.GetValue(null));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceSetValue_Invoke_GetKeyValueReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-
-        object key1 = new();
-        object value1 = new();
-        service.SetValue(key1, value1);
-        Assert.Same(key1, service.GetKey(value1));
-        Assert.Same(value1, service.GetValue(key1));
-
-        // Add another.
-        object key2 = new();
-        object value2 = new();
-        service.SetValue(key2, value2);
-        Assert.Same(key2, service.GetKey(value2));
-        Assert.Same(value2, service.GetValue(key2));
-
-        // Add same.
-        object value3 = new();
-        service.SetValue(key1, value3);
-        Assert.Same(key1, service.GetKey(value3));
-        Assert.Null(service.GetKey(value1));
-        Assert.Same(value3, service.GetValue(key1));
-
-        // Add null value.
-        service.SetValue(key1, null);
-        Assert.Null(service.GetKey(null));
-        Assert.Null(service.GetKey(value3));
-        Assert.Null(service.GetValue(key1));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIDictionaryServiceSetValue_NullKey_ThrowsArgumentNullException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        Assert.Throws<ArgumentNullException>("key", () => service.SetValue(null, new object()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeObject_ReturnsExpected()
-    {
-        object service = new();
-        object otherService = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), service);
-        Assert.Same(service, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeObjectPromote_ReturnsExpected()
-    {
-        object service = new();
-        object otherService = new();
-        ServiceContainer otherContainer = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IServiceContainer)))
-            .Returns(otherContainer);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), service, true);
-        Assert.Same(otherService, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-        Assert.Same(service, otherContainer.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeObjectNoPromote_ReturnsExpected()
-    {
-        object service = new();
-        object otherService = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), service, false);
-        Assert.Same(service, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeServiceCreatorCallback_ReturnsExpected()
-    {
-        object service = new();
-        ServiceCreatorCallback callback = (c, serviceType) =>
-        {
-            Assert.Same(typeof(object), serviceType);
-            return service;
-        };
-        object otherService = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), callback);
-        Assert.Same(service, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeServiceCreatorCallbackPromote_ReturnsExpected()
-    {
-        object service = new();
-        ServiceCreatorCallback callback = (c, serviceType) =>
-        {
-            Assert.Same(typeof(object), serviceType);
-            return service;
-        };
-        object otherService = new();
-        ServiceContainer otherContainer = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IServiceContainer)))
-            .Returns(otherContainer);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), callback, true);
-        Assert.Same(otherService, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-        Assert.Same(service, otherContainer.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentIServiceContainerAddService_InvokeServiceCreatorCallbackNoPromote_ReturnsExpected()
-    {
-        object service = new();
-        ServiceCreatorCallback callback = (c, serviceType) =>
-        {
-            Assert.Same(typeof(object), serviceType);
-            return service;
-        };
-        object otherService = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(object)))
-            .Returns(otherService);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IServiceContainer container = Assert.IsAssignableFrom<IServiceContainer>(component.Site);
-        container.AddService(typeof(object), callback, false);
-        Assert.Same(service, container.GetService(typeof(object)));
-        Assert.Same(otherService, surface.GetService(typeof(object)));
-    }
-
-    public static IEnumerable<object[]> AddComponentISiteName_Set_TestData()
-    {
-        foreach (object[] testData in Add_InvalidNameCreationServiceParentProvider_TestData())
-        {
-            foreach (string oldName in new string[] { null, string.Empty, "oldName" })
-            {
-                yield return new object[] { testData[0], oldName, null, string.Empty };
-                yield return new object[] { testData[0], oldName, string.Empty, string.Empty };
-                yield return new object[] { testData[0], oldName, "name", "name" };
-                yield return new object[] { testData[0], oldName, "ldName", "ldName" };
-                yield return new object[] { testData[0], oldName, "ldName", "ldName" };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AddComponentISiteName_Set_TestData))]
-    public void DesignerHost_AddComponentISiteName_SetRootComponent_GetReturnsExpected(IServiceProvider parentProvider, string oldName, string value, string expectedName)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component, oldName);
-        component.Site.Name = value;
-        Assert.Same(expectedName, component.Site.Name);
-        Assert.Same(expectedName, host.RootComponentClassName);
-
-        // Set same.
-        component.Site.Name = value;
-        Assert.Same(expectedName, component.Site.Name);
-        Assert.Same(expectedName, host.RootComponentClassName);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteName_SetDifferentCase_GetReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component, "name");
-        component.Site.Name = "NAME";
-        Assert.Equal("NAME", component.Site.Name);
-
-        // Set same.
-        component.Site.Name = "NAME";
-        Assert.Equal("NAME", component.Site.Name);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DesignerHost_AddComponentISiteName_SetWithMultipleComponents_GetReturnsExpected(string value)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        using RootDesignerComponent component3 = new();
-        host.Container.Add(component1);
-        host.Container.Add(component2, null);
-        host.Container.Add(component3, "name3");
-
-        component1.Site.Name = value;
-        Assert.Same(value ?? string.Empty, component1.Site.Name);
-
-        // Set same.
-        component1.Site.Name = value;
-        Assert.Same(value ?? string.Empty, component1.Site.Name);
-    }
-
-    public static IEnumerable<object[]> AddComponentISiteName_SetWithNamespaceInRootComponentClassName_TestData()
-    {
-        yield return new object[] { string.Empty, "oldName", null, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, "oldName", string.Empty, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, "oldName", "newName", "newName", "newName" };
-
-        yield return new object[] { "oldName", "oldName", null, string.Empty, string.Empty };
-        yield return new object[] { "oldName", "oldName", string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "oldName", "oldName", "newName", "newName", "newName" };
-        yield return new object[] { "oldName", "oldName", "oldName", "oldName", "oldName" };
-
-        yield return new object[] { "namespace.oldName", "oldName", null, string.Empty, "namespace." };
-        yield return new object[] { "namespace.oldName", "oldName", string.Empty, string.Empty, "namespace." };
-        yield return new object[] { "namespace.oldName", "oldName", "newName", "newName", "namespace.newName" };
-        yield return new object[] { "namespace.oldName", "oldName", "oldName", "oldName", "namespace.oldName" };
-        yield return new object[] { "namespace.oldName", "ldName", "ldName", "ldName", "namespace.oldName" };
-
-        yield return new object[] { "namespace.oldName", "namespace.oldName", null, string.Empty, string.Empty };
-        yield return new object[] { "namespace.oldName", "namespace.oldName", string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "namespace.oldName", "namespace.oldName", "newName", "newName", "newName" };
-        yield return new object[] { "namespace.oldName", "namespace.oldName", "oldName", "oldName", "oldName" };
-        yield return new object[] { "namespace.oldName", "namespace.oldName", "ldName", "ldName", "ldName" };
-
-        yield return new object[] { "namespace.oldName", "name", null, string.Empty, string.Empty };
-        yield return new object[] { "namespace.oldName", "name", string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "namespace.oldName", "name", "newName", "newName", "newName" };
-        yield return new object[] { "namespace.oldName", "name", "oldName", "oldName", "oldName" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AddComponentISiteName_SetWithNamespaceInRootComponentClassName_TestData))]
-    public void DesignerHost_AddComponentISiteName_SetWithNamespaceInRootComponentClassName_GetReturnsExpected(string oldRootComponentClassName, string oldName, string value, string expectedName, string expectedRootComponentClassName)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-
-        host.EndLoad(oldRootComponentClassName, true, null);
-        Assert.Equal(oldRootComponentClassName, host.RootComponentClassName);
-        Assert.Null(host.RootComponent);
-
-        host.Container.Add(component, oldName);
-        Assert.Equal(oldName, component.Site.Name);
-        Assert.Equal(oldRootComponentClassName, host.RootComponentClassName);
-        Assert.Same(component, host.RootComponent);
-
-        component.Site.Name = value;
-        Assert.Equal(expectedName, component.Site.Name);
-        Assert.Equal(expectedRootComponentClassName, host.RootComponentClassName);
-        Assert.Same(component, host.RootComponent);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DesignerHost_AddComponentISiteName_SetNameWithComponentRename_CallsHandler(string value)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-        using RootDesignerComponent component = new();
-
-        int callCount = 0;
-        ComponentRenameEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component, e.Component);
-            Assert.Equal("oldName", e.OldName);
-            Assert.Same(value ?? string.Empty, e.NewName);
-            callCount++;
-        };
-        changeService.ComponentRename += handler;
-        host.Container.Add(component, "oldName");
-
-        component.Site.Name = value;
-        Assert.Same(value ?? string.Empty, component.Site.Name);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        component.Site.Name = value;
-        Assert.Same(value ?? string.Empty, component.Site.Name);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        changeService.ComponentRename -= handler;
-        component.Site.Name = "name";
-        Assert.Equal("name", component.Site.Name);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 1)]
-    [InlineData("", "", 1)]
-    [InlineData("newName", "newName", 1)]
-    [InlineData("OLDNAME", "OLDNAME", 0)]
-    public void DesignerHost_AddComponentISite_SetNameWithINameCreateService_CallsValidateName(string value, string expectedName, int expectedCallCount)
-    {
-        Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-        mockNameCreationService
-            .Setup(s => s.ValidateName("oldName"))
-            .Verifiable();
-        mockNameCreationService
-            .Setup(s => s.ValidateName(expectedName))
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(mockNameCreationService.Object);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component, "oldName");
-        Assert.Equal("oldName", component.Site.Name);
-        mockNameCreationService.Verify(s => s.ValidateName("oldName"), Times.Once());
-
-        component.Site.Name = value;
-        Assert.Equal(expectedName, component.Site.Name);
-        mockNameCreationService.Verify(s => s.ValidateName(expectedName), Times.Exactly(expectedCallCount));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteName_SetSameAsOtherComponent_GetReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        host.Container.Add(component1, "name1");
-        host.Container.Add(component2, "name2");
-        Assert.Throws<Exception>(() => component1.Site.Name = "name2");
-        Assert.Throws<Exception>(() => component1.Site.Name = "NAME2");
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_Invoke_ReturnsExpected()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(int)))
-            .Returns(service);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Same(service, component.Site.GetService(typeof(int)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_InvokeWithNestedContainer_ReturnsService()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(int)))
-            .Returns(service);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        INestedContainer nestedContainer = Assert.IsAssignableFrom<INestedContainer>(component.Site.GetService(typeof(INestedContainer)));
-        Assert.Same(service, component.Site.GetService(typeof(int)));
-        Assert.Same(component.Site, component.Site.GetService(typeof(IDictionaryService)));
-        Assert.Same(nestedContainer, component.Site.GetService(typeof(INestedContainer)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_INestedContainer_ReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        INestedContainer container = Assert.IsAssignableFrom<INestedContainer>(component.Site.GetService(typeof(INestedContainer)));
-        Assert.Same(container, component.Site.GetService(typeof(INestedContainer)));
-        Assert.Empty(container.Components);
-        Assert.Same(component, container.Owner);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetServiceINestedContainerGetService_Invoke_ReturnsExpected()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(int)))
-            .Returns(service);
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        NestedContainer container = Assert.IsAssignableFrom<NestedContainer>(component.Site.GetService(typeof(INestedContainer)));
-        using Component nestedComponent = new();
-        container.Add(nestedComponent);
-        Assert.Same(service, nestedComponent.Site.GetService(typeof(int)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_IDictionaryService_ReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Same(component.Site, component.Site.GetService(typeof(IDictionaryService)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_IServiceContainerReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Same(surface.ServiceContainer, component.Site.GetService(typeof(IServiceContainer)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_IContainerReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Same(host, component.Site.GetService(typeof(IContainer)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddComponentISiteGetService_NullServiceType_ThrowsArgumentNullException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Throws<ArgumentNullException>("service", () => component.Site.GetService(null));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_IComponentWithComponentAddingAndAdded_CallsHandler()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component = new();
-        int componentAddingCallCount = 0;
-        ComponentEventHandler componentAddingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component, e.Component);
-            componentAddingCallCount++;
-        };
-        changeService.ComponentAdding += componentAddingHandler;
-        int componentAddedCallCount = 0;
-        ComponentEventHandler componentAddedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component, e.Component);
-            Assert.True(componentAddedCallCount < componentAddingCallCount);
-            componentAddedCallCount++;
-        };
-        changeService.ComponentAdded += componentAddedHandler;
-
-        // With handler.
-        host.Container.Add(component);
-        Assert.Same(host.Container, component.Container);
-        Assert.Equal(1, componentAddingCallCount);
-        Assert.Equal(1, componentAddedCallCount);
-
-        // Add again.
-        host.Container.Add(component);
-        Assert.Same(host.Container, component.Container);
-        Assert.Equal(1, componentAddingCallCount);
-        Assert.Equal(1, componentAddedCallCount);
-
-        // Remove handler.
-        changeService.ComponentAdding -= componentAddingHandler;
-        changeService.ComponentAdded -= componentAddedHandler;
-        host.Container.Add(component);
-        Assert.Same(host.Container, component.Container);
-        Assert.Equal(1, componentAddingCallCount);
-        Assert.Equal(1, componentAddedCallCount);
-    }
-
-    public static IEnumerable<object[]> Add_NoRootDesigner_TestData()
-    {
-        yield return new object[] { new Component() };
-        yield return new object[] { new DesignerComponent() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_NoRootDesigner_TestData))]
-    public void DesignerHost_Add_NoRootDesigner_ThrowsException(IComponent component)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Throws<NotImplementedException>(() => host.Container.Add(component));
-        Assert.Throws<NotImplementedException>(() => host.Container.Add(component, "name"));
-        Assert.Empty(host.Container.Components);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_CyclicRootDesigner_ThrowsException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component, component.GetType().FullName);
-        Assert.Equal(component.GetType().FullName, host.RootComponentClassName);
-        Assert.Throws<Exception>(() => host.Container.Add(component));
-        Assert.Throws<Exception>(() => host.Container.Add(new RootDesignerComponent(), host.RootComponentClassName));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_NonInitializingRootDesigner_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using NonInitializingDesignerComponent component = new();
-        Assert.Throws<InvalidOperationException>(() => host.Container.Add(component));
-        Assert.Throws<InvalidOperationException>(() => host.Container.Add(component, "name"));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_ThrowingInitializingRootDesigner_RethrowsException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using ThrowingInitializingDesignerComponent component = new();
-        Assert.Throws<DivideByZeroException>(() => host.Container.Add(component));
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-
-        Assert.Throws<DivideByZeroException>(() => host.Container.Add(component, "name"));
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Add_CheckoutExceptionThrowingInitializingRootDesigner_RethrowsException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using CheckoutExceptionThrowingInitializingDesignerComponent component = new();
-        // CheckoutException does not bubble up in xunit.
-        bool threwCheckoutException = false;
-        try
-        {
-            host.Container.Add(component);
-        }
-        catch (CheckoutException)
-        {
-            threwCheckoutException = true;
-        }
-
-        Assert.True(threwCheckoutException);
-        Assert.Same(host.Container, component.Container);
-        Assert.Empty(component.Site.Name);
-
-        host.Container.Add(component, "name");
-        Assert.Same(host.Container, component.Container);
-        Assert.Equal("name", component.Site.Name);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddService_InvokeObject_GetServiceReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        object service = new();
-        host.AddService(typeof(object), service);
-        Assert.Same(service, surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Same(service, surface.GetService(typeof(object)));
-        Assert.Same(service, host.GetService(typeof(object)));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_AddService_InvokeObjectBool_GetServiceReturnsExpected(bool promote)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        object service = new();
-        host.AddService(typeof(object), service, promote);
-        Assert.Same(service, surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Same(service, surface.GetService(typeof(object)));
-        Assert.Same(service, host.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddService_InvokeCallback_GetServiceReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        object service = new();
-        ServiceCreatorCallback callback = (container, serviceType) => service;
-        host.AddService(typeof(object), callback);
-        Assert.Same(service, surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Same(service, surface.GetService(typeof(object)));
-        Assert.Same(service, host.GetService(typeof(object)));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_AddService_InvokeObjectCallback_GetServiceReturnsExpected(bool promote)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        object service = new();
-        ServiceCreatorCallback callback = (container, serviceType) => service;
-        host.AddService(typeof(object), callback, promote);
-        Assert.Same(service, surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Same(service, surface.GetService(typeof(object)));
-        Assert.Same(service, host.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_AddService_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.Dispose();
-        ServiceCreatorCallback callback = (container, service) => new object();
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), new object()));
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), new object(), true));
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), new object(), false));
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), callback));
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), callback, true));
-        Assert.Throws<ObjectDisposedException>(() => host.AddService(typeof(object), callback, false));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Dispose_Invoke_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IDisposable disposable = Assert.IsAssignableFrom<IDisposable>(host);
-        Assert.Throws<InvalidOperationException>(() => disposable.Dispose());
-    }
-
-    [WinFormsFact(Skip = "Unstable test, see: https://github.com/dotnet/winforms/issues/1460")]
-    public void DesignerHost_Add_DesignerDisposeThrowsDuringUnloadingDispose_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(RootDesignerComponent));
-
-        using ThrowingDesignerDisposeComponent component = new();
-        host.Container.Add(component);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsFact(Skip = "Unstable test, see: https://github.com/dotnet/winforms/issues/1151")]
-    public void DesignerHost_Add_ComponentDisposeThrowsDuringUnloadingDispose_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(RootDesignerComponent));
-
-        using ThrowingDisposeDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsFact(Skip = "Unstable test, see: https://github.com/dotnet/winforms/issues/1460")]
-    public void DesignerHost_Add_RootDesignerDisposeThrowsDuringUnloadingDispose_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(ThrowingRootDesignerDisposeComponent));
-
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsFact(Skip = "Unstable test, see: https://github.com/dotnet/winforms/issues/1460")]
-    public void DesignerHost_Add_RootComponentDisposeThrowsDuringUnloadingDispose_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(ThrowingDisposeRootDesignerComponent));
-        Assert.Throws<InvalidOperationException>(() => surface.Dispose());
-        Assert.False(surface.IsLoaded);
-        Assert.Empty(surface.LoadErrors);
-        Assert.False(host.Loading);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateComponent_NullComponentType_ThrowsArgumentNullException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Throws<ArgumentNullException>("componentType", () => host.CreateComponent(null));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_Invoke_ReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction();
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("No Description Available", transaction1.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("No Description Available", host.TransactionDescription);
-
-        DesignerTransaction transaction2 = host.CreateTransaction();
-        Assert.False(transaction2.Canceled);
-        Assert.False(transaction2.Committed);
-        Assert.Equal("No Description Available", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("No Description Available", host.TransactionDescription);
-
-        transaction2.Cancel();
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "No Description Available")]
-    [InlineData("", "")]
-    [InlineData("Description", "Description")]
-    public void DesignerHost_CreateTransaction_InvokeWithDescription_ReturnsExpected(string description, string expectedDescription)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction(description);
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal(expectedDescription, transaction1.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal(expectedDescription, host.TransactionDescription);
-
-        DesignerTransaction transaction2 = host.CreateTransaction("CustomDescription");
-        Assert.False(transaction2.Canceled);
-        Assert.False(transaction2.Committed);
-        Assert.Equal("CustomDescription", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("CustomDescription", host.TransactionDescription);
-
-        transaction2.Cancel();
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_InvokeWithTransactionOpeningAndTransactionOpened_CallsHandlers()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        int openingCallCount = 0;
-        EventHandler openingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            openingCallCount++;
-        };
-        int openedCallCount = 0;
-        EventHandler openedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(openedCallCount < openingCallCount);
-            openedCallCount++;
-        };
-        host.TransactionOpening += openingHandler;
-        host.TransactionOpened += openedHandler;
-
-        // With handler.
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        Assert.Equal(1, openingCallCount);
-        Assert.Equal(1, openedCallCount);
-
-        // Create again.
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-        Assert.Equal(2, openingCallCount);
-        Assert.Equal(2, openedCallCount);
-
-        // Remove handler.
-        host.TransactionOpening -= openingHandler;
-        host.TransactionOpened -= openedHandler;
-        DesignerTransaction transaction3 = host.CreateTransaction("Description2");
-        Assert.Equal(2, openingCallCount);
-        Assert.Equal(2, openedCallCount);
-
-        transaction3.Cancel();
-        transaction2.Cancel();
-        transaction1.Cancel();
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_Cancel_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-
-        // Cancel first.
-        transaction2.Cancel();
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.True(transaction2.Canceled);
-        Assert.False(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Description1", host.TransactionDescription);
-
-        // Cancel again.
-        transaction2.Cancel();
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.True(transaction2.Canceled);
-        Assert.False(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Description1", host.TransactionDescription);
-
-        // Cancel second.
-        transaction1.Cancel();
-        Assert.True(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.True(transaction2.Canceled);
-        Assert.False(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.False(host.InTransaction);
-        Assert.Null(host.TransactionDescription);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_CancelWithTransactionClosingAndTransactionClosed_CallsHandlers()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-
-        bool expectedLastTransaction = false;
-        int closingCallCount = 0;
-        DesignerTransactionCloseEventHandler closingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.False(e.TransactionCommitted);
-            Assert.Equal(expectedLastTransaction, e.LastTransaction);
-            closingCallCount++;
-        };
-        int closedCallCount = 0;
-        DesignerTransactionCloseEventHandler closedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.False(e.TransactionCommitted);
-            Assert.Equal(expectedLastTransaction, e.LastTransaction);
-            Assert.True(closedCallCount < closingCallCount);
-            closedCallCount++;
-        };
-        host.TransactionClosing += closingHandler;
-        host.TransactionClosed += closedHandler;
-
-        // With handler.
-        transaction2.Cancel();
-        Assert.False(transaction1.Canceled);
-        Assert.True(transaction2.Canceled);
-        Assert.Equal(1, closingCallCount);
-        Assert.Equal(1, closedCallCount);
-
-        // Cancel again.
-        transaction2.Cancel();
-        Assert.False(transaction1.Canceled);
-        Assert.True(transaction2.Canceled);
-        Assert.Equal(1, closingCallCount);
-        Assert.Equal(1, closedCallCount);
-
-        // Cancel second.
-        expectedLastTransaction = true;
-        transaction1.Cancel();
-        Assert.True(transaction1.Canceled);
-        Assert.True(transaction2.Canceled);
-        Assert.Equal(2, closingCallCount);
-        Assert.Equal(2, closedCallCount);
-
-        // Remove handler.
-        host.TransactionClosing -= closingHandler;
-        host.TransactionClosed -= closedHandler;
-        DesignerTransaction transaction3 = host.CreateTransaction("Description1");
-        transaction3.Cancel();
-        Assert.True(transaction3.Canceled);
-        Assert.Equal(2, closingCallCount);
-        Assert.Equal(2, closedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_CancelNested_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-        Assert.Throws<InvalidOperationException>(() => transaction1.Cancel());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_Commit_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-
-        // Commit first.
-        transaction2.Commit();
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.False(transaction2.Canceled);
-        Assert.True(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Description1", host.TransactionDescription);
-
-        // Commit again.
-        transaction2.Commit();
-        Assert.False(transaction1.Canceled);
-        Assert.False(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.False(transaction2.Canceled);
-        Assert.True(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.True(host.InTransaction);
-        Assert.Equal("Description1", host.TransactionDescription);
-
-        // Commit second.
-        transaction1.Commit();
-        Assert.False(transaction1.Canceled);
-        Assert.True(transaction1.Committed);
-        Assert.Equal("Description1", transaction1.Description);
-        Assert.False(transaction2.Canceled);
-        Assert.True(transaction2.Committed);
-        Assert.Equal("Description2", transaction2.Description);
-        Assert.False(host.InTransaction);
-        Assert.Null(host.TransactionDescription);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_CommitWithTransactionClosingAndTransactionClosed_CallsHandlers()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-
-        bool expectedLastTransaction = false;
-        int closingCallCount = 0;
-        DesignerTransactionCloseEventHandler closingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.True(e.TransactionCommitted);
-            Assert.Equal(expectedLastTransaction, e.LastTransaction);
-            closingCallCount++;
-        };
-        int closedCallCount = 0;
-        DesignerTransactionCloseEventHandler closedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.True(e.TransactionCommitted);
-            Assert.Equal(expectedLastTransaction, e.LastTransaction);
-            Assert.True(closedCallCount < closingCallCount);
-            closedCallCount++;
-        };
-        host.TransactionClosing += closingHandler;
-        host.TransactionClosed += closedHandler;
-
-        // With handler.
-        transaction2.Commit();
-        Assert.False(transaction1.Committed);
-        Assert.True(transaction2.Committed);
-        Assert.Equal(1, closingCallCount);
-        Assert.Equal(1, closedCallCount);
-
-        // Commit again.
-        transaction2.Commit();
-        Assert.False(transaction1.Committed);
-        Assert.True(transaction2.Committed);
-        Assert.Equal(1, closingCallCount);
-        Assert.Equal(1, closedCallCount);
-
-        // Commit second.
-        expectedLastTransaction = true;
-        transaction1.Commit();
-        Assert.True(transaction1.Committed);
-        Assert.True(transaction2.Committed);
-        Assert.Equal(2, closingCallCount);
-        Assert.Equal(2, closedCallCount);
-
-        // Remove handler.
-        host.TransactionClosing -= closingHandler;
-        host.TransactionClosed -= closedHandler;
-        DesignerTransaction transaction3 = host.CreateTransaction("Description1");
-        transaction3.Commit();
-        Assert.True(transaction3.Committed);
-        Assert.Equal(2, closingCallCount);
-        Assert.Equal(2, closedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_CreateTransaction_CommitNested_ThrowsInvalidOperationException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        DesignerTransaction transaction1 = host.CreateTransaction("Description1");
-        DesignerTransaction transaction2 = host.CreateTransaction("Description2");
-        Assert.Throws<InvalidOperationException>(() => transaction1.Commit());
-    }
-
-    public static IEnumerable<object[]> DesignerHost_EndLoad_TestData()
-    {
-        yield return new object[] { null, true, null };
-        yield return new object[] { null, true, Array.Empty<object>() };
-        yield return new object[] { null, true, new object[] { new Exception() } };
-        yield return new object[] { null, true, new object[] { "abc" } };
-        yield return new object[] { null, true, new object[] { null } };
-        yield return new object[] { null, false, null };
-        yield return new object[] { null, false, Array.Empty<object>() };
-        yield return new object[] { null, false, new object[] { new Exception() } };
-        yield return new object[] { null, false, new object[] { "abc" } };
-        yield return new object[] { null, false, new object[] { null } };
-        yield return new object[] { string.Empty, true, null };
-        yield return new object[] { string.Empty, true, Array.Empty<object>() };
-        yield return new object[] { string.Empty, true, new object[] { new Exception() } };
-        yield return new object[] { string.Empty, true, new object[] { "abc" } };
-        yield return new object[] { string.Empty, true, new object[] { null } };
-        yield return new object[] { string.Empty, false, null };
-        yield return new object[] { string.Empty, false, Array.Empty<object>() };
-        yield return new object[] { string.Empty, false, new object[] { new Exception() } };
-        yield return new object[] { string.Empty, false, new object[] { "abc" } };
-        yield return new object[] { string.Empty, false, new object[] { null } };
-        yield return new object[] { "baseClassName", true, null };
-        yield return new object[] { "baseClassName", true, new object[] { new Exception() } };
-        yield return new object[] { "baseClassName", true, new object[] { "abc" } };
-        yield return new object[] { "baseClassName", true, new object[] { null } };
-        yield return new object[] { "baseClassName", false, null };
-        yield return new object[] { "baseClassName", false, new object[] { new Exception() } };
-        yield return new object[] { "baseClassName", false, new object[] { "abc" } };
-        yield return new object[] { "baseClassName", false, new object[] { null } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DesignerHost_EndLoad_TestData))]
-    public void DesignerHost_EndLoad_NotCalledBeginLoad_Success(string baseClassName, bool successful, ICollection errorCollection)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        host.EndLoad(baseClassName, successful, errorCollection);
-        Assert.False(surface.IsLoaded);
-        Assert.False(host.Loading);
-        Assert.Empty(surface.LoadErrors);
-        Assert.Null(host.RootComponent);
-        Assert.Same(baseClassName, host.RootComponentClassName);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetComponents_Invoke_ReturnsFiltered()
-    {
-        ComponentCollection collection = new(new Component[] { new Component() });
-        Mock<ContainerFilterService> mockFilterService = new(MockBehavior.Strict);
-        mockFilterService
-            .Setup(f => f.FilterComponents(new ComponentCollection(Array.Empty<IComponent>())))
-            .Returns(collection);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(mockFilterService.Object);
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        Assert.Same(collection, surface.ComponentContainer.Components);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetDesigner_InvokeNonEmpty_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerHost host = surface.Host;
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        Assert.IsType<RootDesigner>(host.GetDesigner(component));
-        Assert.Null(host.GetDesigner(new Component()));
-        Assert.Null(host.GetDesigner(new RootDesignerComponent()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetDesigner_InvokeEmpty_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerHost host = surface.Host;
-        Assert.Null(host.GetDesigner(new Component()));
-        Assert.Null(host.GetDesigner(new RootDesignerComponent()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetDesigner_NullComponent_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerHost host = surface.Host;
-        Assert.Throws<ArgumentNullException>("component", () => host.GetDesigner(null));
-    }
-
-    public static IEnumerable<object[]> GetService_InvalidLoader_TestData()
-    {
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(It.IsAny<IDesignerLoaderHost>()));
-        yield return new object[] { mockLoader.Object, null };
-
-        Mock<DesignerLoader> mockNullServiceProviderLoader = new(MockBehavior.Strict);
-        mockNullServiceProviderLoader
-            .Setup(l => l.BeginLoad(It.IsAny<IDesignerLoaderHost>()));
-        mockNullServiceProviderLoader
-            .As<IServiceProvider>()
-            .Setup(p => p.GetService(typeof(IMultitargetHelperService)))
-            .Returns(null);
-        yield return new object[] { mockNullServiceProviderLoader.Object, null };
-
-        object o = new();
-        Mock<DesignerLoader> mockInvalidServiceProviderLoader = new(MockBehavior.Strict);
-        mockInvalidServiceProviderLoader
-            .Setup(l => l.BeginLoad(It.IsAny<IDesignerLoaderHost>()));
-        mockInvalidServiceProviderLoader
-            .As<IServiceProvider>()
-            .Setup(p => p.GetService(typeof(IMultitargetHelperService)))
-            .Returns(o);
-        yield return new object[] { mockInvalidServiceProviderLoader.Object, o };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetService_InvalidLoader_TestData))]
-    public void DesignerHost_GetService_IMultitargetHelperServiceWithLoader_ReturnsExpected(DesignerLoader loader, object expected)
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null);
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        surface.BeginLoad(loader);
-
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Same(expected, host.GetService(typeof(IMultitargetHelperService)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetServiceIMultitargetHelperServiceWithoutLoader_ReturnsNull()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Null(host.GetService(typeof(IMultitargetHelperService)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetService_InvokeWithServiceProvider_ReturnsExpected()
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(int)))
-            .Returns(service)
-            .Verifiable();
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Same(service, host.GetService(typeof(int)));
-        mockServiceProvider.Verify(p => p.GetService(typeof(int)), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetService_InvokeWithoutServiceProvider_ReturnsNull()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Null(host.GetService(typeof(int)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetService_IContainer_ReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Same(host, host.GetService(typeof(IContainer)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(IServiceContainer))]
-    [InlineData(typeof(ServiceContainer))]
-    public void DesignerHost_GetService_IServiceContainer_ReturnsExpected(Type serviceType)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Same(surface.ServiceContainer, host.GetService(serviceType));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetService_NullType_ThrowsArgumentNullException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        Assert.Throws<ArgumentNullException>("service", () => host.GetService(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("", null)]
-    [InlineData("", typeof(int))]
-    [InlineData("typeName", null)]
-    [InlineData("typeName", typeof(int))]
-    [InlineData("System.Object", null)]
-    [InlineData("System.Object", typeof(int))]
-    public void DesignerHost_GetType_InvokeWithTypeResolutionService_ReturnsExpected(string typeName, Type expected)
-    {
-        Mock<ITypeResolutionService> mockTypeResolutionService = new(MockBehavior.Strict);
-        mockTypeResolutionService
-            .Setup(s => s.GetType(typeName))
-            .Returns(expected)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(mockTypeResolutionService.Object)
-            .Verifiable();
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerHost host = surface.Host;
-        Assert.Equal(expected, host.GetType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetType_InvalidTypeResolutionService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetType_InvalidTypeResolutionService_TestData))]
-    public void DesignerHost_GetType_InvokeWithInvalidTypeResolutionService_ReturnsExpected(object service)
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(service)
-            .Verifiable();
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerHost host = surface.Host;
-        Assert.Equal(typeof(int), host.GetType(typeof(int).FullName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_GetType_NullTypeName_ThrowsArgumentNullException()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerHost host = surface.Host;
-        Assert.Throws<ArgumentNullException>("typeName", () => host.GetType(null));
-    }
-
-    private static readonly IDesignerHost s_placeholderHost = new Mock<IDesignerHost>(MockBehavior.Strict).Object;
-
-    public static IEnumerable<object[]> ChangeActiveDesigner_TestData()
-    {
-        IDesignerLoaderHost2 otherHost = new SubDesignSurface().Host;
-
-        yield return new object[] { null, 0, 0, 0 };
-
-        yield return new object[] { new ActiveDesignerEventArgs(s_placeholderHost, s_placeholderHost), 0, 1, 1 };
-        yield return new object[] { new ActiveDesignerEventArgs(s_placeholderHost, otherHost), 0, 1, 1 };
-        yield return new object[] { new ActiveDesignerEventArgs(s_placeholderHost, null), 0, 1, 1 };
-
-        yield return new object[] { new ActiveDesignerEventArgs(otherHost, s_placeholderHost), 1, 0, 0 };
-        yield return new object[] { new ActiveDesignerEventArgs(otherHost, otherHost), 0, 0, 0 };
-        yield return new object[] { new ActiveDesignerEventArgs(otherHost, null), 0, 0, 0 };
-
-        yield return new object[] { new ActiveDesignerEventArgs(null, s_placeholderHost), 1, 0, 0 };
-        yield return new object[] { new ActiveDesignerEventArgs(null, otherHost), 0, 0, 0 };
-        yield return new object[] { new ActiveDesignerEventArgs(null, null), 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ChangeActiveDesigner_TestData))]
-    public void DesignerHost_ChangeActiveDesigner_Invoke_Success(ActiveDesignerEventArgs eventArgs, int expectedActivatedCallCount, int expectedDeactivatedCallCount, int expectedFlushCount)
-    {
-        Mock<IDesignerEventService> mockDesignerEventService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(mockDesignerEventService.Object);
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-
-        int activatedCallCount = 0;
-        EventHandler activatedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            activatedCallCount++;
-        };
-        host.Activated += activatedHandler;
-        int deactivatedCallCount = 0;
-        EventHandler deactivatedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(EventArgs.Empty, e);
-            deactivatedCallCount++;
-        };
-        host.Deactivated += deactivatedHandler;
-        int flushCallCount = 0;
-        EventHandler flushedHandler = (sender, e) =>
-        {
-            Assert.Same(surface, sender);
-            Assert.Same(EventArgs.Empty, e);
-            flushCallCount++;
-        };
-        surface.Flushed += flushedHandler;
-
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad((IDesignerLoaderHost)surface.ComponentContainer));
-        mockLoader
-            .Setup(l => l.Flush());
-        surface.BeginLoad(mockLoader.Object);
-        Assert.Equal(0, activatedCallCount);
-        Assert.Equal(0, deactivatedCallCount);
-        Assert.Equal(0, flushCallCount);
-
-        // Replace placeholders for "this"
-        ActiveDesignerEventArgs actualEventArgs = null;
-        if (eventArgs is not null)
-        {
-            IDesignerHost newDesigner = eventArgs.NewDesigner == s_placeholderHost ? host : eventArgs.NewDesigner;
-            IDesignerHost oldDesigner = eventArgs.OldDesigner == s_placeholderHost ? host : eventArgs.OldDesigner;
-            actualEventArgs = new ActiveDesignerEventArgs(oldDesigner, newDesigner);
-        }
-
-        mockDesignerEventService.Raise(s => s.ActiveDesignerChanged += null, actualEventArgs);
-        Assert.Equal(expectedActivatedCallCount, activatedCallCount);
-        Assert.Equal(expectedDeactivatedCallCount, deactivatedCallCount);
-        Assert.Equal(expectedFlushCount, flushCallCount);
-
-        // Should not invoke if removed.
-        host.Activated -= activatedHandler;
-        host.Deactivated -= deactivatedHandler;
-        surface.Flushed -= flushedHandler;
-        mockDesignerEventService.Raise(s => s.ActiveDesignerChanged += null, actualEventArgs);
-        Assert.Equal(expectedActivatedCallCount, activatedCallCount);
-        Assert.Equal(expectedDeactivatedCallCount, deactivatedCallCount);
-        Assert.Equal(expectedFlushCount, flushCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Remove_Invoke_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        using RootDesignerComponent rootComponent = new();
-        using DesignerComponent component = new();
-        host.Container.Add(rootComponent);
-        host.Container.Add(component);
-        host.Container.Remove(rootComponent);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(host.GetDesigner(rootComponent));
-        Assert.NotNull(host.GetDesigner(component));
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Same(host.Container, component.Container);
-        Assert.NotNull(component.Site);
-
-        // Remove again.
-        host.Container.Remove(rootComponent);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(host.GetDesigner(rootComponent));
-        Assert.NotNull(host.GetDesigner(component));
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Same(host.Container, component.Container);
-        Assert.NotNull(component.Site);
-
-        // Remove other.
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(host.GetDesigner(rootComponent));
-        Assert.Null(host.GetDesigner(component));
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    public static IEnumerable<object[]> Remove_IExtenderProviderServiceWithoutDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent(), 0, 0 };
-        yield return new object[] { new RootExtenderProviderDesignerComponent(), 1, 1 };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent, 0, 1 };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent, 1, 1 };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_IExtenderProviderServiceWithoutDefault_TestData))]
-    public void DesignerHost_Remove_IExtenderProviderServiceWithoutDefault_Success(Component component, int expectedAddCallCount, int expectedRemoveCallCount)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider));
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Same(host, component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount));
-
-        // Remove.
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount + expectedRemoveCallCount));
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedRemoveCallCount));
-
-        // Remove again.
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount + expectedRemoveCallCount));
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedRemoveCallCount));
-    }
-
-    public static IEnumerable<object[]> Remove_IExtenderProviderServiceWithDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent() };
-        yield return new object[] { new RootExtenderProviderDesignerComponent() };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_IExtenderProviderServiceWithDefault_TestData))]
-    public void DesignerHost_Remove_IExtenderProviderServiceWithDefault_Success(Component component)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ContainerFilterService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        SubDesignSurface surface = new(mockServiceProvider.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        Assert.Empty(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Remove.
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Remove again.
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Never());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void DesignerHost_Remove_InvalidIExtenderProviderServiceWithoutDefault_CallsParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootExtenderProviderDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(2));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void DesignerHost_Remove_InvalidIExtenderProviderServiceWithDefault_DoesNotCallParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        IDesignerLoaderHost2 host = surface.Host;
-        using RootExtenderProviderDesignerComponent component = new();
-
-        host.Container.Add(component);
-        Assert.Same(component, Assert.Single(host.Container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-
-        host.Container.Remove(component);
-        Assert.Empty(host.Container.Components);
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-    }
-
-    [WinFormsFact]
-    public void Remove_ComponentNotInContainerNonEmpty_Nop()
-    {
-        using SubDesignSurface surface1 = new();
-        using SubDesignSurface surface2 = new();
-        IDesignerLoaderHost2 host1 = surface1.Host;
-        IDesignerLoaderHost2 host2 = surface2.Host;
-
-        RootDesignerComponent otherComponent = new();
-        using RootDesignerComponent component = new();
-        host1.Container.Add(otherComponent);
-        host2.Container.Add(component);
-        host2.Container.Remove(otherComponent);
-        host2.Container.Remove(new Component());
-        Assert.Same(otherComponent, Assert.Single(host1.Container.Components));
-        Assert.Same(component, Assert.Single(host2.Container.Components));
-    }
-
-    [WinFormsFact]
-    public void Remove_ComponentNotInContainerEmpty_Nop()
-    {
-        using SubDesignSurface surface1 = new();
-        using SubDesignSurface surface2 = new();
-        IDesignerLoaderHost2 host1 = surface1.Host;
-        IDesignerLoaderHost2 host2 = surface2.Host;
-
-        using RootDesignerComponent otherComponent = new();
-        host1.Container.Add(otherComponent);
-        host2.Container.Remove(otherComponent);
-        host2.Container.Remove(new Component());
-        Assert.Same(otherComponent, Assert.Single(host1.Container.Components));
-        Assert.Empty(host2.Container.Components);
-    }
-
-    [WinFormsFact]
-    public void Remove_InvokeWithComponentRemoved_CallsHandler()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component1 = new();
-        using DesignerComponent component2 = new();
-        int componentRemovingCallCount = 0;
-        ComponentEventHandler componentRemovingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component1, e.Component);
-            Assert.NotNull(e.Component.Site);
-            componentRemovingCallCount++;
-        };
-        changeService.ComponentRemoving += componentRemovingHandler;
-
-        int componentRemovedCallCount = 0;
-        ComponentEventHandler componentRemovedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component1, e.Component);
-            Assert.NotNull(e.Component.Site);
-            Assert.True(componentRemovedCallCount < componentRemovingCallCount);
-            componentRemovedCallCount++;
-        };
-        changeService.ComponentRemoved += componentRemovedHandler;
-
-        host.Container.Add(component1);
-        host.Container.Add(component2);
-
-        // With handler.
-        host.Container.Remove(component1);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Same(host.Container, component2.Container);
-        Assert.NotNull(component2.Site);
-        Assert.Same(component2, Assert.Single(host.Container.Components));
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-
-        // Remove again.
-        host.Container.Remove(component1);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Same(host.Container, component2.Container);
-        Assert.NotNull(component2.Site);
-        Assert.Same(component2, Assert.Single(host.Container.Components));
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-
-        // Remove handler.
-        changeService.ComponentRemoving -= componentRemovingHandler;
-        changeService.ComponentRemoved -= componentRemovedHandler;
-        host.Container.Remove(component2);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Null(component2.Container);
-        Assert.Null(component2.Site);
-        Assert.Empty(host.Container.Components);
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Remove_SetSiteToNullInComponentRemoving_Success()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component = new();
-        int componentRemovingCallCount = 0;
-        ComponentEventHandler componentRemovingHandler = (sender, e) =>
-        {
-            component.Site = null;
-            componentRemovingCallCount++;
-        };
-        changeService.ComponentRemoving += componentRemovingHandler;
-
-        host.Container.Add(component);
-        host.Container.Remove(component);
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_Remove_SiteHasDictionary_ClearsDictionary()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        using RootDesignerComponent component = new();
-        host.Container.Add(component);
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        service.SetValue("key", "value");
-        Assert.Equal("value", service.GetValue("key"));
-
-        host.Container.Remove(component);
-        Assert.Null(service.GetValue("key"));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_RemoveService_Invoke_GetServiceReturnsExpected()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.AddService(typeof(object), new object());
-        host.RemoveService(typeof(object));
-        Assert.Null(surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Null(surface.GetService(typeof(object)));
-        Assert.Null(host.GetService(typeof(object)));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DesignerHost_RemoveService_InvokeBool_GetServiceReturnsExpected(bool promote)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-
-        host.AddService(typeof(object), new object());
-        host.RemoveService(typeof(object), promote);
-        Assert.Null(surface.ServiceContainer.GetService(typeof(object)));
-        Assert.Null(surface.GetService(typeof(object)));
-        Assert.Null(host.GetService(typeof(object)));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_RemoveService_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.Dispose();
-        ServiceCreatorCallback callback = (container, service) => new object();
-        Assert.Throws<ObjectDisposedException>(() => host.RemoveService(typeof(object)));
-        Assert.Throws<ObjectDisposedException>(() => host.RemoveService(typeof(object), true));
-        Assert.Throws<ObjectDisposedException>(() => host.RemoveService(typeof(object), false));
-    }
-
-    public static IEnumerable<object[]> OnComponentChanging_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), TypeDescriptor.GetProperties(typeof(string))[0] };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnComponentChanging_TestData))]
-    public void DesignerHost_IComponentChangeServiceOnComponentChanging_Invoke_CallsComponentChanging(object component, MemberDescriptor member)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        int callCount = 0;
-        ComponentChangingEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component, e.Component);
-            Assert.Same(member, e.Member);
-            callCount++;
-        };
-        changeService.ComponentChanging += handler;
-        Assert.False(host.Loading);
-
-        // With handler.
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        changeService.ComponentChanging -= handler;
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnComponentChanging_TestData))]
-    public void DesignerHost_IComponentChangeServiceOnComponentChanging_InvokeLoading_DoesNotCallHandler(object component, MemberDescriptor member)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        int callCount = 0;
-        ComponentChangingEventHandler handler = (sender, e) => callCount++;
-        changeService.ComponentChanging += handler;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-
-        // With handler.
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        changeService.ComponentChanging -= handler;
-        changeService.OnComponentChanging(component, member);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnComponentChanged_TestData()
-    {
-        yield return new object[] { null, null, null, null };
-        yield return new object[] { new object(), TypeDescriptor.GetProperties(typeof(string))[0], new object(), new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnComponentChanged_TestData))]
-    public void DesignerHost_IComponentChangeServiceOnComponentChanged_Invoke_CallsComponentChanged(object component, MemberDescriptor member, object oldValue, object newValue)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        int callCount = 0;
-        ComponentChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component, e.Component);
-            Assert.Same(member, e.Member);
-            Assert.Same(oldValue, e.OldValue);
-            Assert.Same(newValue, e.NewValue);
-            callCount++;
-        };
-        changeService.ComponentChanged += handler;
-        Assert.False(host.Loading);
-
-        // With handler.
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        changeService.ComponentChanged -= handler;
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnComponentChanged_TestData))]
-    public void DesignerHost_IComponentChangeServiceOnComponentChanged_InvokeLoading_DoesNotCallHandler(object component, MemberDescriptor member, object oldValue, object newValue)
-    {
-        SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        int callCount = 0;
-        ComponentChangedEventHandler handler = (sender, e) => callCount++;
-        changeService.ComponentChanged += handler;
-        Mock<DesignerLoader> mockLoader = new(MockBehavior.Strict);
-        mockLoader
-            .Setup(l => l.BeginLoad(host));
-        surface.BeginLoad(mockLoader.Object);
-        Assert.True(host.Loading);
-
-        // With handler.
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        changeService.ComponentChanged -= handler;
-        changeService.OnComponentChanged(component, member, oldValue, newValue);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_UnderlyingSystemType_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost), reflect.UnderlyingSystemType);
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetField_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetField(nameof(IDesignerHost.Activate)), reflect.GetField(nameof(IDesignerHost.Activate), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetFields_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetFields(), reflect.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetMember_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetMember(nameof(IDesignerHost.Container)), reflect.GetMember(nameof(IDesignerHost.Container), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetMembers_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetMembers(), reflect.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetMethod_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetMethod(nameof(IDesignerHost.Activate)), reflect.GetMethod(nameof(IDesignerHost.Activate), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-        Assert.Equal(typeof(IDesignerHost).GetMethod(nameof(IDesignerHost.Activate)), reflect.GetMethod(nameof(IDesignerHost.Activate), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, Array.Empty<Type>(), Array.Empty<ParameterModifier>()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetMethods_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetMethods(), reflect.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetProperty_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetProperty(nameof(IDesignerHost.Container)), reflect.GetProperty(nameof(IDesignerHost.Container), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-        Assert.Equal(typeof(IDesignerHost).GetProperty(nameof(IDesignerHost.Container)), reflect.GetProperty(nameof(IDesignerHost.Container), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, typeof(IContainer), Array.Empty<Type>(), Array.Empty<ParameterModifier>()));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_GetProperties_Success()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(typeof(IDesignerHost).GetProperties(), reflect.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public));
-    }
-
-    [WinFormsFact]
-    public void DesignerHost_IReflect_InvokeMember_ReturnsExpected()
-    {
-        using SubDesignSurface surface = new();
-        IReflect reflect = Assert.IsAssignableFrom<IReflect>(surface.Host);
-        Assert.Equal(surface.Host.Container, reflect.InvokeMember(nameof(IDesignerHost.Container), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.GetProperty, null, surface.Host, Array.Empty<object>(), Array.Empty<ParameterModifier>(), null, Array.Empty<string>()));
-    }
-
-    private class SubDesignSurface : DesignSurface
-    {
-        public SubDesignSurface() : base()
-        {
-        }
-
-        public SubDesignSurface(IServiceProvider parentProvider) : base(parentProvider)
-        {
-        }
-
-        public IDesignerLoaderHost2 Host => Assert.IsAssignableFrom<IDesignerLoaderHost2>(ComponentContainer);
-
-        public new ServiceContainer ServiceContainer => base.ServiceContainer;
-    }
-
-    private abstract class CustomDesigner : IDesigner
-    {
-        protected IComponent _initializedComponent;
-
-        public IComponent Component => _initializedComponent;
-
-        public DesignerVerbCollection Verbs { get; }
-
-        public void DoDefaultAction()
-        {
-        }
-
-        public void Dispose() => Dispose(true);
-
-        protected virtual void Dispose(bool disposing)
-        {
-        }
-
-        public abstract void Initialize(IComponent component);
-    }
-
-    private class Designer : CustomDesigner
-    {
-        public override void Initialize(IComponent component) => _initializedComponent = component;
-    }
-
-    [Designer(typeof(Designer))]
-    private class DesignerComponent : Component
-    {
-    }
-
-    private class RootDesigner : Designer, IRootDesigner
-    {
-        public ViewTechnology[] SupportedTechnologies { get; }
-
-        public object GetView(ViewTechnology technology) => throw new NotImplementedException();
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class RootDesignerComponent : Component
-    {
-    }
-
-    [ProjectTargetFramework("ProjectTargetFramework")]
-    private class ClassWithProjectTargetFrameworkAttribute
-    {
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class RootExtenderProviderDesignerComponent : Component, IExtenderProvider
-    {
-        public bool CanExtend(object extendee) => throw new NotImplementedException();
-    }
-
-    private class NonInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-        }
-    }
-
-    [Designer(typeof(NonInitializingDesigner), typeof(IRootDesigner))]
-    private class NonInitializingDesignerComponent : Component
-    {
-    }
-
-    private class ThrowingInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [Designer(typeof(ThrowingInitializingDesigner), typeof(IRootDesigner))]
-    private class ThrowingInitializingDesignerComponent : Component
-    {
-    }
-
-    private class CheckoutExceptionThrowingInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-            throw CheckoutException.Canceled;
-        }
-    }
-
-    [Designer(typeof(CheckoutExceptionThrowingInitializingDesigner), typeof(IRootDesigner))]
-    private class CheckoutExceptionThrowingInitializingDesignerComponent : Component
-    {
-    }
-
-    private class ThrowingDisposeComponentDesigner : Designer
-    {
-        protected override void Dispose(bool disposing)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    [Designer(typeof(ThrowingDisposeComponentDesigner))]
-    private class ThrowingDesignerDisposeComponent : Component
-    {
-    }
-
-    [Designer(typeof(Designer))]
-    private class ThrowingDisposeDesignerComponent : Component
-    {
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                throw new NotImplementedException();
-            }
-        }
-    }
-
-    private class ThrowingDisposeRootComponentDesigner : RootDesigner
-    {
-        protected override void Dispose(bool disposing)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    [Designer(typeof(ThrowingDisposeRootComponentDesigner), typeof(IRootDesigner))]
-    private class ThrowingRootDesignerDisposeComponent : Component
-    {
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class ThrowingDisposeRootDesignerComponent : Component
-    {
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                throw new NotImplementedException();
-            }
-        }
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class CustomTypeDescriptionProviderComponent : Component
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerVerbCollectionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerVerbCollectionTests.cs
deleted file mode 100644
index 763fee93188..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/DesignerVerbCollectionTests.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class DesignerVerbCollectionTests
-{
-    [Fact]
-    public void DesignerVerbCollection_Ctor_Default()
-    {
-        DesignerVerbCollection collection = new();
-        Assert.Empty(collection);
-    }
-
-    public static IEnumerable<object[]> Ctor_DesignerVerbArray_TestData()
-    {
-        yield return new object[] { Array.Empty<DesignerVerb>() };
-        yield return new object[] { new DesignerVerb[] { new DesignerVerb(null, null), null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerVerbArray_TestData))]
-    public void DesignerVerbCollection_Ctor_DesignerVerbArray(DesignerVerb[] value)
-    {
-        DesignerVerbCollection collection = new(value);
-        Assert.Equal(value, collection.Cast<object>());
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Ctor_NullValue_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("value", () => new DesignerVerbCollection(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Add_DesignerVerb_Success()
-    {
-        DesignerVerbCollection collection = new();
-
-        DesignerVerb value1 = new(null, null);
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        DesignerVerb value2 = new(null, null);
-        collection.Add(value2);
-        Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(1, collection.IndexOf(value2));
-
-        collection.Add(null);
-        Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>());
-        Assert.True(collection.Contains(null));
-        Assert.Equal(2, collection.IndexOf(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerVerbArray_TestData))]
-    public void DesignerVerbCollection_AddRange_DesignerVerbArray_Success(DesignerVerb[] value)
-    {
-        DesignerVerbCollection collection = new();
-        collection.AddRange(value);
-        Assert.Equal(value, collection.Cast<object>());
-
-        // Add again.
-        collection.AddRange(value);
-        Assert.Equal(value.Concat(value), collection.Cast<object>());
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DesignerVerbArray_TestData))]
-    public void DesignerVerbCollection_AddRange_DesignerVerbCollection_Success(DesignerVerb[] value)
-    {
-        DesignerVerbCollection collection = new();
-        collection.AddRange(new DesignerVerbCollection(value));
-        Assert.Equal(value, collection.Cast<object>());
-
-        // Add again.
-        collection.AddRange(new DesignerVerbCollection(value));
-        Assert.Equal(value.Concat(value), collection.Cast<object>());
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_AddRange_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerVerbCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange((DesignerVerb[])null));
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange((DesignerVerbCollection)null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Insert_DesignerVerb_Success()
-    {
-        DesignerVerbCollection collection = new();
-
-        DesignerVerb value1 = new(null, null);
-        collection.Insert(0, value1);
-        Assert.Same(value1, Assert.Single(collection));
-        Assert.Same(value1, collection[0]);
-        Assert.True(collection.Contains(value1));
-        Assert.Equal(0, collection.IndexOf(value1));
-
-        DesignerVerb value2 = new(null, null);
-        collection.Insert(0, value2);
-        Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>());
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-
-        collection.Insert(1, null);
-        Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());
-        Assert.True(collection.Contains(null));
-        Assert.Equal(1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Remove_Invoke_Success()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value = new(null, null);
-        collection.Add(value);
-        Assert.Same(value, Assert.Single(collection));
-
-        collection.Remove(value);
-        Assert.Empty(collection);
-        Assert.False(collection.Contains(value));
-        Assert.Equal(-1, collection.IndexOf(value));
-
-        collection.Add(null);
-        collection.Remove(null);
-        Assert.Empty(collection);
-        Assert.False(collection.Contains(null));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Item_Set_GetReturnsExpected()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value1 = new(null, null);
-        DesignerVerb value2 = new(null, null);
-        collection.Add(value1);
-        Assert.Same(value1, Assert.Single(collection));
-
-        collection[0] = value2;
-        Assert.Same(value2, Assert.Single(collection));
-        Assert.Same(value2, collection[0]);
-        Assert.False(collection.Contains(value1));
-        Assert.Equal(-1, collection.IndexOf(value1));
-        Assert.True(collection.Contains(value2));
-        Assert.Equal(0, collection.IndexOf(value2));
-
-        collection[0] = null;
-        Assert.Null(Assert.Single(collection));
-        Assert.Null(collection[0]);
-        Assert.False(collection.Contains(value2));
-        Assert.Equal(-1, collection.IndexOf(value2));
-        Assert.True(collection.Contains(null));
-        Assert.Equal(0, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_CopyTo_Invoke_Success()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value = new(null, null);
-        collection.Add(value);
-
-        var array = new DesignerVerb[3];
-        collection.CopyTo(array, 1);
-        Assert.Equal(new DesignerVerb[] { null, value, null }, array);
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Contains_NoSuchValue_ReturnsFalse()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value = new(null, null);
-        collection.Add(value);
-
-        Assert.False(collection.Contains(new DesignerVerb(null, null)));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_IndexOf_NoSuchValue_ReturnsNegativeOne()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value = new(null, null);
-        collection.Add(value);
-
-        Assert.Equal(-1, collection.IndexOf(new DesignerVerb(null, null)));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void DesignerVerbCollection_Clear_Success()
-    {
-        DesignerVerbCollection collection = new();
-        DesignerVerb value = new(null, null);
-        collection.Add(value);
-
-        collection.Clear();
-        Assert.Empty(collection);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExceptionCollectionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExceptionCollectionTests.cs
deleted file mode 100644
index 8087bf4a2c0..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExceptionCollectionTests.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ExceptionCollectionTests
-{
-    public static IEnumerable<object[]> Ctor_ArrayList_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ArrayList() };
-        yield return new object[] { new ArrayList { new Exception(), new Exception(), new Exception()} };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ArrayList_TestData))]
-    public void ExceptionCollection_Ctor_ArrayList(ArrayList exceptions)
-    {
-        ExceptionCollection collection = new(exceptions);
-        if (exceptions is null)
-        {
-            Assert.Null(collection.Exceptions);
-        }
-        else
-        {
-            Assert.Equal(exceptions, collection.Exceptions);
-            Assert.NotSame(exceptions, collection.Exceptions);
-            Assert.Equal(collection.Exceptions, collection.Exceptions);
-            Assert.NotSame(collection.Exceptions, collection.Exceptions);
-        }
-    }
-
-    [Fact]
-    public void ExceptionCollection_Ctor_ArguementException()
-    {
-        ArrayList exceptions = new() { 1, 2, 3 };
-        Assert.Throws<ArgumentException>(() => new ExceptionCollection(exceptions));
-    }
-
-    [Theory]
-    [BoolData]
-    public void ExceptionCollection_Serialize_ThrowsSerializationException(bool formatterEnabled)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: formatterEnabled);
-        using MemoryStream stream = new();
-        BinaryFormatter formatter = new();
-        ExceptionCollection collection = new(new ArrayList());
-        if (formatterEnabled)
-        {
-            Assert.Throws<SerializationException>(() => formatter.Serialize(stream, collection));
-        }
-        else
-        {
-            Assert.Throws<NotSupportedException>(() => formatter.Serialize(stream, collection));
-        }
-    }
-
-    [Fact]
-    public void ExceptionCollection_GetObjectData_ThrowsPlatformNotSupportedException()
-    {
-        ExceptionCollection collection = new(new ArrayList());
-        Assert.Throws<PlatformNotSupportedException>(() => collection.GetObjectData(null, new StreamingContext()));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExtenderProviderServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExtenderProviderServiceTests.cs
deleted file mode 100644
index 70a84a3e53c..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ExtenderProviderServiceTests.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ExtenderProviderServiceTests
-{
-    [Fact]
-    public void ExtenderProviderService_GetExtenderProviders_Invoke_ReturnsEmpty()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderListService listService = Assert.IsAssignableFrom<IExtenderListService>(service);
-        Assert.Empty(listService.GetExtenderProviders());
-    }
-
-    [Fact]
-    public void ExtenderProviderService_AddExtenderProvider_Invoke_Success()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderListService listService = Assert.IsAssignableFrom<IExtenderListService>(service);
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Mock<IExtenderProvider> mockExtenderProvider1 = new(MockBehavior.Strict);
-        Mock<IExtenderProvider> mockExtenderProvider2 = new(MockBehavior.Strict);
-
-        providerService.AddExtenderProvider(mockExtenderProvider1.Object);
-        Assert.Equal(new IExtenderProvider[] { mockExtenderProvider1.Object }, listService.GetExtenderProviders());
-
-        // Add another.
-        providerService.AddExtenderProvider(mockExtenderProvider2.Object);
-        Assert.Equal(new IExtenderProvider[] { mockExtenderProvider1.Object, mockExtenderProvider2.Object }, listService.GetExtenderProviders());
-    }
-
-    [Fact]
-    public void ExtenderProviderService_AddExtenderProvider_NullProvider_ThrowsArgumentNullException()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Assert.Throws<ArgumentNullException>("provider", () => providerService.AddExtenderProvider(null));
-    }
-
-    [Fact]
-    public void ExtenderProviderService_AddExtenderProvider_DuplicateProvider_ThrowsArgumentException()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderListService listService = Assert.IsAssignableFrom<IExtenderListService>(service);
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Mock<IExtenderProvider> mockExtenderProvider = new(MockBehavior.Strict);
-
-        providerService.AddExtenderProvider(mockExtenderProvider.Object);
-        Assert.Throws<ArgumentException>("provider", () => providerService.AddExtenderProvider(mockExtenderProvider.Object));
-    }
-
-    [Fact]
-    public void ExtenderProviderService_RemoveExtenderProvider_InvokeWithProviders_Success()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderListService listService = Assert.IsAssignableFrom<IExtenderListService>(service);
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Mock<IExtenderProvider> mockExtenderProvider1 = new(MockBehavior.Strict);
-        Mock<IExtenderProvider> mockExtenderProvider2 = new(MockBehavior.Strict);
-
-        providerService.AddExtenderProvider(mockExtenderProvider1.Object);
-        providerService.AddExtenderProvider(mockExtenderProvider2.Object);
-
-        providerService.RemoveExtenderProvider(mockExtenderProvider1.Object);
-        Assert.Equal(new IExtenderProvider[] { mockExtenderProvider2.Object }, listService.GetExtenderProviders());
-
-        // Remove again.
-        providerService.RemoveExtenderProvider(mockExtenderProvider1.Object);
-        Assert.Equal(new IExtenderProvider[] { mockExtenderProvider2.Object }, listService.GetExtenderProviders());
-
-        // Remove other.
-        providerService.RemoveExtenderProvider(mockExtenderProvider2.Object);
-        Assert.Empty(listService.GetExtenderProviders());
-    }
-
-    [Fact]
-    public void ExtenderProviderService_RemoveExtenderProvider_InvokeWithoutProviders_Nop()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderListService listService = Assert.IsAssignableFrom<IExtenderListService>(service);
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Mock<IExtenderProvider> mockExtenderProvider = new(MockBehavior.Strict);
-        providerService.RemoveExtenderProvider(mockExtenderProvider.Object);
-        Assert.Empty(listService.GetExtenderProviders());
-    }
-
-    [Fact]
-    public void ExtenderProviderService_RemoveExtenderProvider_NullProvider_ThrowsArgumentNullException()
-    {
-        DesignSurface surface = new();
-        object service = surface.GetService(typeof(IExtenderListService));
-        IExtenderProviderService providerService = Assert.IsAssignableFrom<IExtenderProviderService>(service);
-        Assert.Throws<ArgumentNullException>("provider", () => providerService.RemoveExtenderProvider(null));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/InheritanceServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/InheritanceServiceTests.cs
deleted file mode 100644
index eb424834bb4..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/InheritanceServiceTests.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class InheritanceServicerTests
-{
-    [Fact]
-    public void InheritanceService_Constructor()
-    {
-        InheritanceService underTest = new();
-        Assert.NotNull(underTest);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/LoadedEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/LoadedEventArgsTests.cs
deleted file mode 100644
index d3799e4a0f2..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/LoadedEventArgsTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class LoadedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Bool_ICollection_TestData()
-    {
-        yield return new object[] { true, null };
-        yield return new object[] { false, Array.Empty<object>() };
-        yield return new object[] { true, new object[] { null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Bool_ICollection_TestData))]
-    public void Ctor_Bool_ICollection(bool succeeded, ICollection errors)
-    {
-        LoadedEventArgs e = new(succeeded, errors);
-        Assert.Equal(succeeded, e.HasSucceeded);
-        if (errors is null)
-        {
-            Assert.Empty(e.Errors);
-        }
-        else
-        {
-            Assert.Same(errors, e.Errors);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/MultilineStringEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/MultilineStringEditorTests.cs
deleted file mode 100644
index debdb00f925..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/MultilineStringEditorTests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Design;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class MultilineStringEditorTests
-{
-    [Fact]
-    public void MultilineStringEditor_Ctor_Default()
-    {
-        MultilineStringEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void MultilineStringEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        MultilineStringEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Same(string.Empty, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Same(string.Empty, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void MultilineStringEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        MultilineStringEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void MultilineStringEditor_GetEditStyle_Invoke_ReturnsDropDown(ITypeDescriptorContext context)
-    {
-        MultilineStringEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void MultilineStringEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        MultilineStringEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ObjectSelectorEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ObjectSelectorEditorTests.cs
deleted file mode 100644
index bd26eb592bf..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ObjectSelectorEditorTests.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Design;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ObjectSelectorEditorTests
-{
-    [Fact]
-    public void ObjectSelectorEditor_Ctor_Default()
-    {
-        SubObjectSelectorEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-        Assert.False(editor.SubObjectSelector);
-    }
-
-    [Theory]
-    [BoolData]
-    public void ObjectSelectorEditor_Ctor_Bool(bool subObjectSelector)
-    {
-        SubObjectSelectorEditor editor = new(subObjectSelector);
-        Assert.False(editor.IsDropDownResizable);
-        Assert.Equal(subObjectSelector, editor.SubObjectSelector);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void ObjectSelectorEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        SubObjectSelectorEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Same(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Same(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void ObjectSelectorEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        SubObjectSelectorEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ObjectSelectorEditor_GetEditStyle_Invoke_ReturnsDropDown(ITypeDescriptorContext context)
-    {
-        SubObjectSelectorEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ObjectSelectorEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        SubObjectSelectorEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    [Theory]
-    [InlineData(null, true)]
-    [InlineData("value", false)]
-    public void ObjectSelectorEditor_EqualsToValue_InvokeWithoutValue_ReturnsExpected(object value, bool expected)
-    {
-        SubObjectSelectorEditor editor = new();
-        Assert.Equal(expected, editor.EqualsToValue(value));
-    }
-
-    [Fact]
-    public void ObjectSelectorEditor_EqualsToValue_InvokeWithValue_ReturnsExpected()
-    {
-        SubObjectSelectorEditor editor = new();
-        editor.SetValue("value");
-        Assert.True(editor.EqualsToValue("value"));
-        Assert.False(editor.EqualsToValue("other value"));
-        Assert.False(editor.EqualsToValue(null));
-    }
-
-    [Fact]
-    public void ObjectSelectorEditor_Selector()
-    {
-        ObjectSelectorEditor.Selector underTest = new ObjectSelectorEditor.Selector(new SubObjectSelectorEditor());
-
-        Assert.NotNull(underTest);
-        underTest.AddNode("node", "value", null);
-        Assert.Single(underTest.Nodes);
-        Assert.True(underTest.SetSelection("value", null));
-        Assert.False(underTest.SetSelection("other value", null));
-        underTest.Clear();
-        Assert.Empty(underTest.Nodes);
-    }
-
-    private class SubObjectSelectorEditor : ObjectSelectorEditor
-    {
-        public SubObjectSelectorEditor()
-        {
-        }
-
-        public SubObjectSelectorEditor(bool subObjectSelector) : base(subObjectSelector)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ProjectTargetFrameworkAttributeTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ProjectTargetFrameworkAttributeTests.cs
deleted file mode 100644
index 1a46eefee9c..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/ProjectTargetFrameworkAttributeTests.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Tests;
-
-public class ProjectTargetFrameworkAttributeTests
-{
-    [Theory]
-    [StringWithNullData]
-    public void ProjectTargetFrameworkAttribute_Ctor_String(string targetFrameworkMoniker)
-    {
-        ProjectTargetFrameworkAttribute attribute = new(targetFrameworkMoniker);
-        Assert.Equal(targetFrameworkMoniker, attribute.TargetFrameworkMoniker);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomComponentSerializationServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomComponentSerializationServiceTests.cs
deleted file mode 100644
index da0bcaac799..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomComponentSerializationServiceTests.cs
+++ /dev/null
@@ -1,1794 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-using System.Collections;
-using System.Reflection;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class CodeDomComponentSerializationServiceTests
-{
-    private Mock<ISite> GetDefaultMockSite(string name)
-    {
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(default(Container));
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-
-        return mockSite;
-    }
-
-    public static IEnumerable<object[]> Ctor_IServiceProvider_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Mock<IServiceProvider>(MockBehavior.Strict).Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IServiceProvider_TestData))]
-    public void Ctor_IServiceProvider(IServiceProvider provider)
-    {
-        new CodeDomComponentSerializationService(provider);
-    }
-
-    [Fact]
-    public void CreateStore_Invoke_ReturnsExpected()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        Assert.Empty(store.Errors);
-        Assert.NotSame(store.Errors, store.Errors);
-    }
-
-    public static IEnumerable<object[]> CreateStore_ServiceProvider_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Mock<IDesignerSerializationManager>(MockBehavior.Strict) };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateStore_ServiceProvider_TestData))]
-    public void CreateStore_CloseWithProviderMultipleTimes_Success(object result)
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerSerializationManager)))
-            .Returns(result);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        CodeDomComponentSerializationService service = new(mockServiceProvider.Object);
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        Assert.Empty(store.Errors);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerSerializationManager)), Times.Once());
-
-        store.Close();
-        Assert.Empty(store.Errors);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerSerializationManager)), Times.Once());
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerialize_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite1 = GetDefaultMockSite("name1");
-        DataClass value1 = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite1.Object
-        };
-        var mockSite2 = GetDefaultMockSite("name2");
-        DataClass value2 = new()
-        {
-            IntValue = 2,
-            StringValue = "OtherValue",
-            Site = mockSite2.Object
-        };
-        service.Serialize(store, value1);
-        service.Serialize(store, value2);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        Assert.Equal(2, state.Count);
-        object[] valueState1 = Assert.IsType<object[]>(state["name1"]);
-        Assert.Equal(6, valueState1.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name1"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name1"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name1"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name1"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name1"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name1"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState1[0]));
-        Assert.Null(valueState1[1]);
-        Assert.Null(valueState1[2]);
-        Assert.Null(valueState1[3]);
-        Assert.Null(valueState1[4]);
-        Assert.Null(valueState1[5]);
-
-        object[] valueState2 = Assert.IsType<object[]>(state["name2"]);
-        Assert.Equal(6, valueState2.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name2"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name2"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name2"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name2"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name2"), "IntValue"), new CodePrimitiveExpression(2)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name2"), "StringValue"), new CodePrimitiveExpression("OtherValue"))
-        }), Assert.IsType<CodeStatementCollection>(valueState2[0]));
-        Assert.Null(valueState2[1]);
-        Assert.Null(valueState2[2]);
-        Assert.Null(valueState2[3]);
-        Assert.Null(valueState2[4]);
-        Assert.Null(valueState2[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal(new List<string> { "name1", "name2" }, names);
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    public static IEnumerable<object[]> CreateStore_CloseSerializeWithInvalidProvider_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateStore_CloseSerializeWithInvalidProvider_TestData))]
-    public void CreateStore_CloseSerializeWithInvalidProvider_Success(object result)
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerSerializationManager)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(result);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IEventBindingService)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ComponentCache)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IServiceContainer)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(MemberRelationshipService)))
-            .Returns(result)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(result);
-        CodeDomComponentSerializationService service = new(mockServiceProvider.Object);
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.Serialize(store, value);
-        store.Close();
-        Assert.Empty(store.Errors);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerSerializationManager)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ComponentCache)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IServiceContainer)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(MemberRelationshipService)), Times.Exactly(3));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    public static IEnumerable<object[]> CreateStore_CloseSerializeWithValidProvider_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), new object() };
-
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        yield return new object[] { mockComponentChangeService.Object, new WindowsFormsDesignerOptionService() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateStore_CloseSerializeWithValidProvider_TestData))]
-    public void CreateStore_CloseSerializeWithValidProvider_Success(object componentChangeService, object designerOptionService)
-    {
-        DesignerSerializationManager manager = new();
-        ServiceContainer container = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerSerializationManager)))
-            .Returns(manager)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(null)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IEventBindingService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ComponentCache)))
-            .Returns(null)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IServiceContainer)))
-            .Returns(container)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(MemberRelationshipService)))
-            .Returns(null)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(componentChangeService)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerOptionService)))
-            .Returns(designerOptionService)
-            .Verifiable();
-        CodeDomComponentSerializationService service = new(mockServiceProvider.Object);
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.Serialize(store, value);
-        store.Close();
-        Assert.Empty(store.Errors);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerSerializationManager)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ComponentCache)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(IServiceContainer)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(MemberRelationshipService)), Times.Exactly(3));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IComponentChangeService)), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(DesignerOptionService)), Times.Once());
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeAbsolute_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.SerializeAbsolute(store, value);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeMember_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.DefaultStringValue)];
-        MemberDescriptor member3 = TypeDescriptor.GetEvents(typeof(DataClass))[nameof(DataClass.Event)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.SerializeMember(store, value, member1);
-        service.SerializeMember(store, value, member2);
-        service.SerializeMember(store, value, member1);
-        service.SerializeMember(store, value, member3);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeMemberAbsolute_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.DefaultStringValue)];
-        MemberDescriptor member3 = TypeDescriptor.GetEvents(typeof(DataClass))[nameof(DataClass.Event)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.SerializeMemberAbsolute(store, value, member1);
-        service.SerializeMemberAbsolute(store, value, member2);
-        service.SerializeMemberAbsolute(store, value, member1);
-        service.SerializeMemberAbsolute(store, value, member3);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeThenSerializeMember_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.DefaultStringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.Serialize(store, value);
-        service.SerializeMember(store, value, member1);
-        service.SerializeMember(store, value, member2);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeMemberThenSerialize_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.DefaultStringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        var mockSite = GetDefaultMockSite("name");
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.SerializeMember(store, value, member1);
-        service.SerializeMember(store, value, member2);
-        service.Serialize(store, value);
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Hashtable state = Assert.IsType<Hashtable>(info.GetValue("State", typeof(Hashtable)));
-        object[] valueState = Assert.IsType<object[]>(state["name"]);
-        Assert.Equal(6, valueState.Length);
-        CodeDomHelpers.AssertEqualCodeStatementCollection(new CodeStatementCollection(new CodeStatement[]
-        {
-            new CodeVariableDeclarationStatement(typeof(DataClass), "name"),
-            new CodeAssignStatement(new CodeVariableReferenceExpression("name"), new CodeObjectCreateExpression(typeof(DataClass))),
-            new CodeCommentStatement(string.Empty),
-            new CodeCommentStatement("name"),
-            new CodeCommentStatement(string.Empty),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "DefaultStringValue"), new CodePrimitiveExpression(null)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "IntValue"), new CodePrimitiveExpression(1)),
-            new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("name"), "StringValue"), new CodePrimitiveExpression("Value"))
-        }), Assert.IsType<CodeStatementCollection>(valueState[0]));
-        Assert.Null(valueState[1]);
-        Assert.Null(valueState[2]);
-        Assert.Null(valueState[3]);
-        Assert.Null(valueState[4]);
-        Assert.Null(valueState[5]);
-
-        List<string> names = Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)));
-        Assert.Equal("name", Assert.Single(names));
-
-        AssemblyName[] assemblies = Assert.IsType<AssemblyName[]>(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Equal(typeof(DataClass).Assembly.GetName(true).FullName, Assert.Single(assemblies).FullName);
-
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_CloseSerializeThrows_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("name");
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Throws(new DivideByZeroException());
-        DataClass value = new()
-        {
-            IntValue = 1,
-            StringValue = "Value",
-            Site = mockSite.Object
-        };
-        service.Serialize(store, value);
-        Assert.Throws<DivideByZeroException>(() => store.Close());
-        Assert.Empty(store.Errors);
-    }
-
-    [Fact]
-    public void CreateStore_CloseWithoutProviderMultipleTimes_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        Assert.Empty(store.Errors);
-
-        store.Close();
-        Assert.Empty(store.Errors);
-    }
-
-    [Fact]
-    public void CreateStore_ISerializableGetObjectDataDefault_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>))));
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_ISerializableGetObjectDataSerialized_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        object value = new();
-        service.Serialize(store, value);
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        Assert.NotEmpty(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>))));
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void CreateStore_ISerializableGetObjectDataDefaultNullInfo_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-        Assert.Throws<ArgumentNullException>("info", () => serializable.GetObjectData(null, new StreamingContext()));
-    }
-
-    [Theory]
-    [BoolData]
-    public void LoadStore_SerializedStore_ThrowsSerializationException(bool formatterEnabled)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: formatterEnabled);
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        using MemoryStream stream = new();
-        BinaryFormatter formatter = new();
-        if (formatterEnabled)
-        {
-            Assert.Throws<SerializationException>(() => formatter.Serialize(stream, store));
-        }
-        else
-        {
-            Assert.Throws<NotSupportedException>(() => formatter.Serialize(stream, store));
-        }
-    }
-
-    [Fact]
-    public void LoadStore_NullStream_ThrowsPlatformNotSupportedException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Assert.Throws<PlatformNotSupportedException>(() => service.LoadStore(null));
-    }
-
-    [Fact]
-    public void Serialize_InvokeObject_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        object value = new();
-        service.Serialize(store, value);
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.Serialize(store, value);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void Serialize_InvokeIComponentWithoutSite_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns<ISite>(null)
-            .Verifiable();
-
-        service.Serialize(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.Serialize(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "^object_........_...._...._...._............$")]
-    [InlineData("name", 2, "^name$")]
-    public void Serialize_InvokeIComponentWithISite_Success(string name, int expectedCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockSite.Object)
-            .Verifiable();
-
-        service.Serialize(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.Serialize(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "name", 2, "^name$")]
-    [InlineData("", 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "name", 2, "^name$")]
-    [InlineData("fullName", 2, null, 0, "^fullName$")]
-    [InlineData("fullName", 2, "", 0, "^fullName$")]
-    [InlineData("fullName", 2, "name", 0, "^fullName$")]
-    public void Serialize_InvokeIComponentWithINestedSite_Success(string fullName, int expectedFullNameCallCount, string name, int expectedNameCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<INestedSite> mockNestedSite = new(MockBehavior.Strict);
-        mockNestedSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        mockNestedSite
-            .Setup(s => s.FullName)
-            .Returns(fullName)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockNestedSite.Object)
-            .Verifiable();
-
-        service.Serialize(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.Serialize(store, mockComponent.Object);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void Serialize_NullStore_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Assert.Throws<ArgumentNullException>("store", () => service.Serialize(null, new object()));
-    }
-
-    [Fact]
-    public void Serialize_NullValue_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        Assert.Throws<ArgumentNullException>("value", () => service.Serialize(mockStore.Object, null));
-    }
-
-    [Fact]
-    public void Serialize_InvalidStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        Assert.Throws<InvalidOperationException>(() => service.Serialize(mockStore.Object, new object()));
-    }
-
-    [Fact]
-    public void Serialize_ClosedStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        Assert.Throws<InvalidOperationException>(() => service.Serialize(store, new object()));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_InvokeObject_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        object value = new();
-        service.SerializeAbsolute(store, value);
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeAbsolute(store, value);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_InvokeIComponentWithoutSite_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns<ISite>(null)
-            .Verifiable();
-
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "^object_........_...._...._...._............$")]
-    [InlineData("name", 2, "^name$")]
-    public void SerializeAbsolute_InvokeIComponentWithISite_Success(string name, int expectedCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockSite.Object)
-            .Verifiable();
-
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "name", 2, "^name$")]
-    [InlineData("", 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "name", 2, "^name$")]
-    [InlineData("fullName", 2, null, 0, "^fullName$")]
-    [InlineData("fullName", 2, "", 0, "^fullName$")]
-    [InlineData("fullName", 2, "name", 0, "^fullName$")]
-    public void SerializeAbsolute_InvokeIComponentWithINestedSite_Success(string fullName, int expectedFullNameCallCount, string name, int expectedNameCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<INestedSite> mockNestedSite = new(MockBehavior.Strict);
-        mockNestedSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        mockNestedSite
-            .Setup(s => s.FullName)
-            .Returns(fullName)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockNestedSite.Object)
-            .Verifiable();
-
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeAbsolute(store, mockComponent.Object);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_NullStore_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Assert.Throws<ArgumentNullException>("store", () => service.SerializeAbsolute(null, new object()));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_NullValue_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        Assert.Throws<ArgumentNullException>("value", () => service.SerializeAbsolute(mockStore.Object, null));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_InvalidStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        Assert.Throws<InvalidOperationException>(() => service.SerializeAbsolute(mockStore.Object, new object()));
-    }
-
-    [Fact]
-    public void SerializeAbsolute_ClosedStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        Assert.Throws<InvalidOperationException>(() => service.SerializeAbsolute(store, new object()));
-    }
-
-    [Fact]
-    public void SerializeMember_InvokeObject_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        object value = new();
-        service.SerializeMember(store, value, member1);
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMember(store, value, member1);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMember(store, value, member2);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeMember_InvokeIComponentWithoutSite_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns<ISite>(null)
-            .Verifiable();
-
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMember(store, mockComponent.Object, member2);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "^object_........_...._...._...._............$")]
-    [InlineData("name", 2, "^name$")]
-    public void SerializeMember_InvokeIComponentWithISite_Success(string name, int expectedCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockSite.Object)
-            .Verifiable();
-
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMember(store, mockComponent.Object, member2);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "name", 2, "^name$")]
-    [InlineData("", 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "name", 2, "^name$")]
-    [InlineData("fullName", 2, null, 0, "^fullName$")]
-    [InlineData("fullName", 2, "", 0, "^fullName$")]
-    [InlineData("fullName", 2, "name", 0, "^fullName$")]
-    public void SerializeMember_InvokeIComponentWithINestedSite_Success(string fullName, int expectedFullNameCallCount, string name, int expectedNameCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<INestedSite> mockNestedSite = new(MockBehavior.Strict);
-        mockNestedSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        mockNestedSite
-            .Setup(s => s.FullName)
-            .Returns(fullName)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockNestedSite.Object)
-            .Verifiable();
-
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMember(store, mockComponent.Object, member1);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMember(store, mockComponent.Object, member2);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeMember_NullStore_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<ArgumentNullException>("store", () => service.SerializeMember(null, new DataClass(), member));
-    }
-
-    [Fact]
-    public void SerializeMember_NullOwningObject_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<ArgumentNullException>("owningObject", () => service.SerializeMember(store, null, member));
-    }
-
-    [Fact]
-    public void SerializeMember_NullMember_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        Assert.Throws<ArgumentNullException>("member", () => service.SerializeMember(store, new DataClass(), null));
-    }
-
-    [Fact]
-    public void SerializeMember_InvalidStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<InvalidOperationException>(() => service.SerializeMember(mockStore.Object, new DataClass(), member));
-    }
-
-    [Fact]
-    public void SerializeMember_ClosedStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<InvalidOperationException>(() => service.SerializeMember(store, new DataClass(), member));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_InvokeObject_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        object value = new();
-        service.SerializeMemberAbsolute(store, value, member1);
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMemberAbsolute(store, value, member1);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMemberAbsolute(store, value, member2);
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_InvokeIComponentWithoutSite_Success()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns<ISite>(null)
-            .Verifiable();
-
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member2);
-        mockComponent.Verify(c => c.Site, Times.Once());
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches("^object_........_...._...._...._............$", nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "^object_........_...._...._...._............$")]
-    [InlineData("name", 2, "^name$")]
-    public void SerializeMemberAbsolute_InvokeIComponentWithISite_Success(string name, int expectedCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockSite.Object)
-            .Verifiable();
-
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member2);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        Assert.Null(info.GetValue("State", typeof(Hashtable)));
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Theory]
-    [InlineData(null, 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData(null, 1, "name", 2, "^name$")]
-    [InlineData("", 1, null, 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "", 1, "^object_........_...._...._...._............$")]
-    [InlineData("", 1, "name", 2, "^name$")]
-    [InlineData("fullName", 2, null, 0, "^fullName$")]
-    [InlineData("fullName", 2, "", 0, "^fullName$")]
-    [InlineData("fullName", 2, "name", 0, "^fullName$")]
-    public void SerializeMemberAbsolute_InvokeIComponentWithINestedSite_Success(string fullName, int expectedFullNameCallCount, string name, int expectedNameCallCount, string expectedPattern)
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.StringValue)];
-        ISerializable serializable = Assert.IsAssignableFrom<ISerializable>(store);
-
-        Mock<INestedSite> mockNestedSite = new(MockBehavior.Strict);
-        mockNestedSite
-            .Setup(s => s.Name)
-            .Returns(name)
-            .Verifiable();
-        mockNestedSite
-            .Setup(s => s.FullName)
-            .Returns(fullName)
-            .Verifiable();
-        Mock<IComponent> mockComponent = new(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Site)
-            .Returns(mockNestedSite.Object)
-            .Verifiable();
-
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockComponent.Verify(c => c.Site, Times.Once());
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        SerializationInfo info = new(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        string nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize again.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member1);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-
-        // Serialize another.
-        service.SerializeMemberAbsolute(store, mockComponent.Object, member2);
-        mockNestedSite.Verify(s => s.Name, Times.Exactly(expectedNameCallCount));
-        mockNestedSite.Verify(s => s.FullName, Times.Exactly(expectedFullNameCallCount));
-
-        info = new SerializationInfo(store.GetType(), new FormatterConverter());
-        serializable.GetObjectData(info, new StreamingContext());
-        nameResult = Assert.IsType<string>(Assert.Single(Assert.IsType<List<string>>(info.GetValue("Names", typeof(List<string>)))));
-        Assert.Matches(expectedPattern, nameResult);
-        Assert.Null(info.GetValue("Assemblies", typeof(AssemblyName[])));
-        Assert.Null(info.GetValue("Resources", typeof(Hashtable)));
-        Assert.Empty(Assert.IsType<List<string>>(info.GetValue("Shim", typeof(List<string>))));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_NullStore_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<ArgumentNullException>("store", () => service.SerializeMemberAbsolute(null, new DataClass(), member));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_NullOwningObject_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<ArgumentNullException>("owningObject", () => service.SerializeMemberAbsolute(store, null, member));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_NullMember_ThrowsArgumentNullException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        Assert.Throws<ArgumentNullException>("member", () => service.SerializeMemberAbsolute(store, new DataClass(), null));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_InvalidStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        Mock<SerializationStore> mockStore = new(MockBehavior.Strict);
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<InvalidOperationException>(() => service.SerializeMemberAbsolute(mockStore.Object, new DataClass(), member));
-    }
-
-    [Fact]
-    public void SerializeMemberAbsolute_ClosedStore_ThrowsInvalidOperationException()
-    {
-        CodeDomComponentSerializationService service = new();
-        SerializationStore store = service.CreateStore();
-        store.Close();
-        MemberDescriptor member = TypeDescriptor.GetProperties(typeof(DataClass))[nameof(DataClass.IntValue)];
-        Assert.Throws<InvalidOperationException>(() => service.SerializeMemberAbsolute(store, new DataClass(), member));
-    }
-
-    private class DataClass : Component
-    {
-        public int IntValue { get; set; }
-
-        public string StringValue { get; set; }
-
-        public string DefaultStringValue { get; set; }
-
-        public event EventHandler Event
-        {
-            add { }
-            remove { }
-        }
-    }
-
-    private static void DumpState(Hashtable state)
-    {
-        Console.WriteLine("---- DUMPING ----");
-        foreach (string key in state.Keys)
-        {
-            Console.WriteLine(key);
-            object[] valueState = (object[])state[key];
-            CodeStatementCollection state0 = (CodeStatementCollection)valueState[0];
-            if (state0 is null)
-            {
-                Console.WriteLine("- [0]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [0]: {state0}, {state0.Count} elements");
-                foreach (CodeStatement e in state0)
-                {
-                    Console.WriteLine($"  - {CodeDomHelpers.GetConstructionString(e)}");
-                }
-            }
-
-            object state1 = valueState[1];
-            if (state1 is null)
-            {
-                Console.WriteLine("- [1]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [1]: {state1}");
-            }
-
-            object state2 = valueState[2];
-            if (state2 is null)
-            {
-                Console.WriteLine("- [2]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [2]: {state2}");
-            }
-
-            object state3 = valueState[3];
-            if (state3 is null)
-            {
-                Console.WriteLine("- [3]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [3]: {state3}");
-            }
-
-            object state4 = valueState[4];
-            if (state4 is null)
-            {
-                Console.WriteLine("- [4]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [4]: {state4}");
-            }
-
-            object state5 = valueState[5];
-            if (state5 is null)
-            {
-                Console.WriteLine("- [5]: null");
-            }
-            else
-            {
-                Console.WriteLine($"- [5]: {state5}");
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomSerializerExceptionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomSerializerExceptionTests.cs
deleted file mode 100644
index e4e6626aee5..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/CodeDomSerializerExceptionTests.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-using System.ComponentModel.Design.Serialization;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using Moq;
-
-namespace System.Windows.Forms.Design.Serialization.Tests;
-
-public class CodeDomSerializerExceptionTests
-{
-    public static IEnumerable<object[]> Ctor_String_CodeLinePragma_TestData()
-    {
-        yield return new object[] { "message", new CodeLinePragma() };
-        yield return new object[] { null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_CodeLinePragma_TestData))]
-    public void CodeDomSerializerException_Ctor_String_CodeLinePragma(string message, CodeLinePragma linePragma)
-    {
-        CodeDomSerializerException exception = new(message, linePragma);
-        Assert.NotEmpty(exception.Message);
-        Assert.Null(exception.InnerException);
-        Assert.Same(linePragma, exception.LinePragma);
-    }
-
-    public static IEnumerable<object[]> Ctor_Exception_CodeLinePragma_TestData()
-    {
-        yield return new object[] { new Exception(), new CodeLinePragma() };
-        yield return new object[] { null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Exception_CodeLinePragma_TestData))]
-    public void CodeDomSerializerException_Ctor_Exception_CodeLinePragma(Exception innerException, CodeLinePragma linePragma)
-    {
-        CodeDomSerializerException exception = new(innerException, linePragma);
-        Assert.NotEmpty(exception.Message);
-        Assert.Same(innerException, exception.InnerException);
-        Assert.Same(linePragma, exception.LinePragma);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_IDesignerSerializationManager_TestData()
-    {
-        Mock<IDesignerSerializationManager> mockDesignerSerializationManager = new(MockBehavior.Strict);
-        yield return new object[] { "message", mockDesignerSerializationManager.Object };
-        yield return new object[] { null, mockDesignerSerializationManager.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_IDesignerSerializationManager_TestData))]
-    public void CodeDomSerializerException_Ctor_String_IDesignerSerializationManager(string message, IDesignerSerializationManager manager)
-    {
-        CodeDomSerializerException exception = new(message, manager);
-        Assert.NotEmpty(exception.Message);
-        Assert.Null(exception.InnerException);
-        Assert.Null(exception.LinePragma);
-    }
-
-    public static IEnumerable<object[]> Ctor_Exception_IDesignerSerializationManager_TestData()
-    {
-        Mock<IDesignerSerializationManager> mockDesignerSerializationManager = new(MockBehavior.Strict);
-        yield return new object[] { new Exception(), mockDesignerSerializationManager.Object };
-        yield return new object[] { null, mockDesignerSerializationManager.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Exception_IDesignerSerializationManager_TestData))]
-    public void CodeDomSerializerException_Ctor_Exception_IDesignerSerializationManager(Exception innerException, IDesignerSerializationManager manager)
-    {
-        CodeDomSerializerException exception = new(innerException, manager);
-        Assert.NotEmpty(exception.Message);
-        Assert.Same(innerException, exception.InnerException);
-        Assert.Null(exception.LinePragma);
-    }
-
-    [Fact]
-    public void CodeDomSerializerException_NullManager_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("manager", () => new CodeDomSerializerException("message", (IDesignerSerializationManager)null));
-        Assert.Throws<ArgumentNullException>("manager", () => new CodeDomSerializerException(new Exception(), (IDesignerSerializationManager)null));
-    }
-
-    [Theory]
-    [BoolData]
-    public void CodeDomSerializerException_Serialize_ThrowsSerializationException(bool formatterEnabled)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: formatterEnabled);
-        using MemoryStream stream = new();
-        BinaryFormatter formatter = new();
-        CodeDomSerializerException exception = new("message", new CodeLinePragma("fileName.cs", 11));
-        if (formatterEnabled)
-        {
-            Assert.Throws<SerializationException>(() => formatter.Serialize(stream, exception));
-        }
-        else
-        {
-            Assert.Throws<NotSupportedException>(() => formatter.Serialize(stream, exception));
-        }
-#pragma warning restore SYSLIB0011
-    }
-
-    [Fact]
-    public void CodeDomSerializerException_GetObjectData_ThrowsPlatformNotSupportedException()
-    {
-        CodeDomSerializerException exception = new("message", new CodeLinePragma("fileName.cs", 11));
-        Assert.Throws<PlatformNotSupportedException>(() => exception.GetObjectData(null, new StreamingContext()));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/DesignerSerializationManagerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/DesignerSerializationManagerTests.cs
deleted file mode 100644
index c09b7daa39b..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/DesignerSerializationManagerTests.cs
+++ /dev/null
@@ -1,2150 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using Moq;
-using Moq.Protected;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class DesignerSerializationManagerTests
-{
-    [Fact]
-    public void DesignerSerializationManager_Ctor_Default()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Null(manager.Container);
-        Assert.True(manager.PreserveNames);
-        Assert.Empty(iManager.Properties);
-        Assert.Same(iManager.Properties, iManager.Properties);
-        Assert.Null(manager.PropertyProvider);
-        Assert.False(manager.RecycleInstances);
-        Assert.True(manager.ValidateRecycledTypes);
-        ;
-    }
-
-    public static IEnumerable<object[]> Ctor_IServiceProvider_TestData()
-    {
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        yield return new object[] { nullMockServiceProvider.Object, null };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object, null };
-
-        Container container = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns(container);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        yield return new object[] { mockServiceProvider.Object, container };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IServiceProvider_TestData))]
-    public void DesignerSerializationManager_Ctor_IServiceProvider(IServiceProvider provider, IContainer expectedContainer)
-    {
-        DesignerSerializationManager manager = new(provider);
-        IDesignerSerializationManager iManager = manager;
-        Assert.Same(expectedContainer, manager.Container);
-        Assert.Same(manager.Container, manager.Container);
-        Assert.True(manager.PreserveNames);
-        Assert.Empty(iManager.Properties);
-        Assert.Same(iManager.Properties, iManager.Properties);
-        Assert.Null(manager.PropertyProvider);
-        Assert.False(manager.RecycleInstances);
-        Assert.True(manager.ValidateRecycledTypes);
-        ;
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Ctor_NullProvider_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("provider", () => new DesignerSerializationManager(null));
-    }
-
-    public static IEnumerable<object[]> Container_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Container() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Container_Set_TestData))]
-    public void DesignerSerializationManager_Container_Set_GetReturnsExpected(IContainer value)
-    {
-        SubDesignerSerializationManager manager = new()
-        {
-            Container = value
-        };
-        Assert.Same(value, manager.Container);
-        Assert.Same(value, manager.GetService(typeof(IContainer)));
-
-        // Set same.
-        manager.Container = value;
-        Assert.Same(value, manager.Container);
-        Assert.Same(value, manager.GetService(typeof(IContainer)));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Container_SetWithSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        Assert.Throws<InvalidOperationException>(() => manager.Container = null);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Context_GetWithSession_ReturnsExpected()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        IDisposable session = manager.CreateSession();
-        ContextStack context = iManager.Context;
-        Assert.Null(context.Current);
-        Assert.Same(context, iManager.Context);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Context_GetNoSessionAfterGetting_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        IDisposable session = manager.CreateSession();
-        ContextStack context = iManager.Context;
-        Assert.NotNull(context);
-        Assert.Same(context, iManager.Context);
-        session.Dispose();
-        Assert.Throws<InvalidOperationException>(() => iManager.Context);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Context_GetNoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<InvalidOperationException>(() => iManager.Context);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Errors_GetWithSession_ReturnsExpected()
-    {
-        DesignerSerializationManager manager = new();
-        IDisposable session = manager.CreateSession();
-        IList errors = manager.Errors;
-        Assert.Empty(errors);
-        Assert.Same(errors, manager.Errors);
-        Assert.IsAssignableFrom<IList>(errors);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Errors_NoSessionWithPreviousSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDisposable session = manager.CreateSession();
-        Assert.Empty(manager.Errors);
-        session.Dispose();
-        Assert.Throws<InvalidOperationException>(() => manager.Errors);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Errors_NoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Throws<InvalidOperationException>(() => manager.Errors);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_PreserveNames_Set_GetReturnsExpected(bool value)
-    {
-        DesignerSerializationManager manager = new()
-        {
-            PreserveNames = value
-        };
-        Assert.Equal(value, manager.PreserveNames);
-
-        // Set same
-        manager.PreserveNames = value;
-        Assert.Equal(value, manager.PreserveNames);
-
-        // Set different
-        manager.PreserveNames = !value;
-        Assert.Equal(!value, manager.PreserveNames);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_PreserveNames_SetWithSession_ThrowsInvalidOperationException(bool value)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        Assert.Throws<InvalidOperationException>(() => manager.PreserveNames = value);
-        Assert.True(manager.PreserveNames);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Properties_GetWithPropertyProvider_ReturnExpected()
-    {
-        PropertyProvider provider = new();
-        DesignerSerializationManager manager = new()
-        {
-            PropertyProvider = provider
-        };
-        IDesignerSerializationManager iManager = manager;
-        PropertyDescriptorCollection properties = iManager.Properties;
-        Assert.Same(properties, iManager.Properties);
-        PropertyDescriptor property = Assert.IsAssignableFrom<PropertyDescriptor>(Assert.Single(properties));
-        Assert.NotEmpty(property.Attributes);
-        Assert.Equal("Category", property.Category);
-        Assert.IsType<Int64Converter>(property.Converter);
-        Assert.Equal(typeof(PropertyProvider), property.ComponentType);
-        Assert.Equal("Description", property.Description);
-        Assert.True(property.DesignTimeOnly);
-        Assert.Equal("DisplayName", property.DisplayName);
-        Assert.True(property.IsBrowsable);
-        Assert.True(property.IsLocalizable);
-        Assert.False(property.IsReadOnly);
-        Assert.Equal("Value", property.Name);
-        Assert.Equal(typeof(int), property.PropertyType);
-        Assert.Equal(DesignerSerializationVisibility.Content, property.SerializationVisibility);
-        Assert.False(property.SupportsChangeEvents);
-
-        // Should be wrapped.
-        Assert.False(property.CanResetValue(new Component()));
-        Assert.Equal(0, property.GetValue(new Component()));
-        property.SetValue(new Component(), 1);
-        Assert.Equal(1, property.GetValue(new Component()));
-        property.ResetValue(new Component());
-        Assert.Equal(1, property.GetValue(new Component()));
-        Assert.True(property.ShouldSerializeValue(new Component()));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Properties_GetWithNullPropertyInPropertyProvider_ThrowsArgumentNullException()
-    {
-        object provider = new();
-        DesignerSerializationManager manager = new()
-        {
-            PropertyProvider = provider
-        };
-        IDesignerSerializationManager iManager = manager;
-        Mock<CustomTypeDescriptor> mockCustomTypeDescriptor = new(MockBehavior.Strict);
-        mockCustomTypeDescriptor
-            .Setup(d => d.GetProperties())
-            .Returns(new PropertyDescriptorCollection(new PropertyDescriptor[] { null }));
-        Mock<TypeDescriptionProvider> mockProvider = new(MockBehavior.Strict);
-        mockProvider
-            .Setup(p => p.GetCache(provider))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(provider))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetTypeDescriptor(typeof(object), provider))
-            .Returns(mockCustomTypeDescriptor.Object);
-        TypeDescriptor.AddProvider(mockProvider.Object, provider);
-
-        Assert.Same(provider, manager.PropertyProvider);
-        Assert.Throws<ArgumentNullException>("property", () => iManager.Properties);
-
-        // Call again.
-        Assert.Throws<ArgumentNullException>("property", () => iManager.Properties);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DesignerSerializationManager_PropertyProvider_Set_GetReturnsExpected(string value)
-    {
-        DesignerSerializationManager manager = new()
-        {
-            PropertyProvider = value
-        };
-        Assert.Same(value, manager.PropertyProvider);
-
-        // Set same
-        manager.PropertyProvider = value;
-        Assert.Same(value, manager.PropertyProvider);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DesignerSerializationManager_PropertyProvider_SetWithSession_GetReturnsExpected(string value)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-
-        manager.PropertyProvider = value;
-        Assert.Same(value, manager.PropertyProvider);
-
-        // Set same
-        manager.PropertyProvider = value;
-        Assert.Same(value, manager.PropertyProvider);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_Properties_SetWithExistingProperties_Resets()
-    {
-        DesignerSerializationManager manager = new()
-        {
-            PropertyProvider = new PropertyProvider()
-        };
-        IDesignerSerializationManager iManager = manager;
-        PropertyDescriptorCollection properties = iManager.Properties;
-        PropertyDescriptor property = Assert.IsAssignableFrom<PropertyDescriptor>(Assert.Single(properties));
-        Assert.Equal(nameof(PropertyProvider.Value), property.Name);
-        Assert.Same(properties, iManager.Properties);
-
-        OtherPropertyProvider provider = new();
-        manager.PropertyProvider = provider;
-        Assert.Same(provider, manager.PropertyProvider);
-        PropertyDescriptorCollection otherProperties = iManager.Properties;
-        PropertyDescriptor otherProperty = Assert.IsAssignableFrom<PropertyDescriptor>(Assert.Single(otherProperties));
-        Assert.Equal(nameof(OtherPropertyProvider.OtherValue), otherProperty.Name);
-        Assert.Same(otherProperties, iManager.Properties);
-
-        // Set same.
-        manager.PropertyProvider = provider;
-        Assert.Same(provider, manager.PropertyProvider);
-        Assert.Same(otherProperties, iManager.Properties);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_RecycleInstances_Set_GetReturnsExpected(bool value)
-    {
-        DesignerSerializationManager manager = new()
-        {
-            RecycleInstances = value
-        };
-        Assert.Equal(value, manager.RecycleInstances);
-
-        // Set same
-        manager.RecycleInstances = value;
-        Assert.Equal(value, manager.RecycleInstances);
-
-        // Set different
-        manager.RecycleInstances = !value;
-        Assert.Equal(!value, manager.RecycleInstances);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_RecycleInstances_SetWithSession_ThrowsInvalidOperationException(bool value)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        Assert.Throws<InvalidOperationException>(() => manager.RecycleInstances = value);
-        Assert.False(manager.RecycleInstances);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_ValidateRecycledTypes_Set_GetReturnsExpected(bool value)
-    {
-        DesignerSerializationManager manager = new()
-        {
-            ValidateRecycledTypes = value
-        };
-        Assert.Equal(value, manager.ValidateRecycledTypes);
-
-        // Set same
-        manager.ValidateRecycledTypes = value;
-        Assert.Equal(value, manager.ValidateRecycledTypes);
-
-        // Set different
-        manager.ValidateRecycledTypes = !value;
-        Assert.Equal(!value, manager.ValidateRecycledTypes);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerSerializationManager_ValidateRecycledTypes_SetWithSession_ThrowsInvalidOperationException(bool value)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        Assert.Throws<InvalidOperationException>(() => manager.ValidateRecycledTypes = value);
-        Assert.True(manager.ValidateRecycledTypes);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_ResolveName_AddNoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        ResolveNameEventHandler handler = (sender, e) => callCount++;
-        Assert.Throws<InvalidOperationException>(() => iManager.ResolveName += handler);
-        iManager.ResolveName -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_SerializationComplete_AddNoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        Assert.Throws<InvalidOperationException>(() => iManager.SerializationComplete += handler);
-        iManager.SerializationComplete -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> AddSerializationProvider_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { null, new object() };
-        yield return new object[] { typeof(int), null };
-        yield return new object[] { typeof(int), new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddSerializationProvider_TestData))]
-    public void DesignerSerializationManager_AddSerializationProvider_NonNullProvider_GetSerializerReturnsExpected(Type objectType, object expected)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Mock<IDesignerSerializationProvider> mockDesignerSerializationProvider = new(MockBehavior.Strict);
-        mockDesignerSerializationProvider
-            .Setup(p => p.GetSerializer(manager, null, objectType, mockDesignerSerializationProvider.Object.GetType()))
-            .Returns(expected)
-            .Verifiable();
-        iManager.AddSerializationProvider(mockDesignerSerializationProvider.Object);
-        Assert.Same(expected, iManager.GetSerializer(objectType, mockDesignerSerializationProvider.Object.GetType()));
-        mockDesignerSerializationProvider.Verify(p => p.GetSerializer(manager, null, objectType, mockDesignerSerializationProvider.Object.GetType()), Times.Once());
-
-        // Call again.
-        Assert.Same(expected, iManager.GetSerializer(objectType, mockDesignerSerializationProvider.Object.GetType()));
-        mockDesignerSerializationProvider.Verify(p => p.GetSerializer(manager, null, objectType, mockDesignerSerializationProvider.Object.GetType()), Times.Exactly(2));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_AddSerializationProvider_NullProvider_Nop()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        iManager.AddSerializationProvider(null);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Invoke_Success()
-    {
-        DesignerSerializationManager manager = new();
-        IDisposable session = manager.CreateSession();
-        Assert.NotNull(session);
-        session.Dispose();
-
-        // Get another.
-        IDisposable session2 = manager.CreateSession();
-        Assert.NotNull(session2);
-        Assert.NotSame(session, session2);
-        session2.Dispose();
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_DisposeMultipleTimes_Success()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        IDisposable session1 = manager.CreateSession();
-        session1.Dispose();
-        Assert.Throws<InvalidOperationException>(() => iManager.Context);
-
-        // Dispose again without session.
-        session1.Dispose();
-        Assert.Throws<InvalidOperationException>(() => iManager.Context);
-
-        // Dispose with session.
-        IDisposable session2 = manager.CreateSession();
-        session1.Dispose();
-        Assert.Throws<InvalidOperationException>(() => iManager.Context);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Invoke_CallsOnSessionCreated()
-    {
-        Mock<DesignerSerializationManager> mockManager = new(MockBehavior.Strict);
-        mockManager
-            .Protected()
-            .Setup("OnSessionCreated", EventArgs.Empty)
-            .Verifiable();
-        IDisposable session = mockManager.Object.CreateSession();
-        mockManager.Protected().Verify("OnSessionCreated", Times.Once(), EventArgs.Empty);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_InvokeWithSessionCreated_CallsHandler()
-    {
-        DesignerSerializationManager manager = new();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        manager.SessionCreated += handler;
-
-        IDisposable session = manager.CreateSession();
-        Assert.NotNull(session);
-        Assert.Equal(1, callCount);
-        session.Dispose();
-
-        // Remove handler.
-        manager.SessionCreated -= handler;
-        session = manager.CreateSession();
-        Assert.NotNull(session);
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Dispose_CallsOnSessionDisposed()
-    {
-        Mock<DesignerSerializationManager> mockManager = new(MockBehavior.Strict);
-        mockManager
-            .Protected()
-            .Setup("OnSessionCreated", EventArgs.Empty);
-        mockManager
-            .Protected()
-            .Setup("OnSessionDisposed", EventArgs.Empty)
-            .Verifiable();
-        IDisposable session = mockManager.Object.CreateSession();
-        session.Dispose();
-        mockManager.Protected().Verify("OnSessionDisposed", Times.Once(), EventArgs.Empty);
-
-        // Dispose again.
-        session.Dispose();
-        mockManager.Protected().Verify("OnSessionDisposed", Times.Exactly(2), EventArgs.Empty);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Dispose_ClearsErrors()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-
-        IDisposable session1 = manager.CreateSession();
-        IList errors1 = manager.Errors;
-        Assert.Empty(errors1);
-        Assert.Same(errors1, manager.Errors);
-        object errorInformation = new();
-        iManager.ReportError(errorInformation);
-        Assert.Same(errorInformation, Assert.Single(errors1));
-
-        // Dispose, get another and ensure cleared.
-        session1.Dispose();
-        IDisposable session2 = manager.CreateSession();
-        IList errors2 = manager.Errors;
-        Assert.Empty(errors2);
-        Assert.Same(errors2, manager.Errors);
-        Assert.NotSame(errors1, errors2);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Dispose_ClearsContext()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-
-        IDisposable session1 = manager.CreateSession();
-        ContextStack stack1 = iManager.Context;
-        Assert.NotNull(stack1);
-        Assert.Same(stack1, iManager.Context);
-
-        // Dispose, get another and ensure cleared.
-        session1.Dispose();
-        IDisposable session2 = manager.CreateSession();
-        ContextStack stack2 = iManager.Context;
-        Assert.NotNull(stack2);
-        Assert.Same(stack2, iManager.Context);
-        Assert.NotSame(stack1, stack2);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_Dispose_ClearsSerializers()
-    {
-        DesignerSerializationManager manager = new();
-
-        IDisposable session1 = manager.CreateSession();
-        object serializer1 = manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass));
-        Assert.IsType<PublicDesignerSerializationProvider>(serializer1);
-        Assert.Same(serializer1, manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(PublicDesignerSerializationProvider)));
-
-        // Dispose and ensure cleared.
-        session1.Dispose();
-        object serializer2 = manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass));
-        Assert.IsType<PublicDesignerSerializationProvider>(serializer2);
-        Assert.NotSame(serializer1, serializer2);
-        Assert.NotSame(serializer2, manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass)));
-    }
-
-    [Theory]
-    [MemberData(nameof(ResolveNameEventArgs_TestData))]
-    public void DesignerSerializationManager_CreateSession_Dispose_ClearsResolveNameEventHandler(ResolveNameEventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        ResolveNameEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        IDisposable session = manager.CreateSession();
-        iManager.ResolveName += handler;
-
-        manager.OnResolveName(eventArgs);
-        Assert.Equal(1, callCount);
-        session.Dispose();
-
-        // Call again.
-        session = manager.CreateSession();
-        manager.OnResolveName(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [Theory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignerSerializationManager_CreateSession_Dispose_ClearsSerializationCompleteEventHandler(EventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        IDisposable session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(1, callCount);
-        session.Dispose();
-
-        // Call again.
-        session = manager.CreateSession();
-        session.Dispose();
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSessionDispose_InvokeWithSessionDisposed_CallsHandler()
-    {
-        DesignerSerializationManager manager = new();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        manager.SessionDisposed += handler;
-
-        IDisposable session = manager.CreateSession();
-        session.Dispose();
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        session = manager.CreateSession();
-        session.Dispose();
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        manager.SessionDisposed -= handler;
-        session = manager.CreateSession();
-        session.Dispose();
-        Assert.Equal(2, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSessionDispose_InvokeWithSerializationComplete_CallsHandler()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        IDisposable session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        session.Dispose();
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        session = manager.CreateSession();
-        session.Dispose();
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        iManager.SerializationComplete -= handler;
-        session.Dispose();
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_CreateSession_InvokeWithSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        Assert.Throws<InvalidOperationException>(() => manager.CreateSession());
-    }
-
-    public static IEnumerable<object[]> GetInstance_NoSuchInstance_TestData()
-    {
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-
-        Component component = new();
-        Container container = new();
-        container.Add(component, "name");
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns(container);
-        Mock<IServiceProvider> mockContainerServiceProvider = new(MockBehavior.Strict);
-        mockContainerServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-
-        yield return new object[] { mockServiceProvider.Object, true, string.Empty, null };
-        yield return new object[] { mockServiceProvider.Object, false, string.Empty, null };
-        yield return new object[] { mockServiceProvider.Object, true, "NoSuchName", null };
-        yield return new object[] { mockServiceProvider.Object, false, "NoSuchName", null };
-
-        yield return new object[] { mockContainerServiceProvider.Object, true, string.Empty, null };
-        yield return new object[] { mockContainerServiceProvider.Object, false, string.Empty, null };
-        yield return new object[] { mockContainerServiceProvider.Object, true, "NoSuchName", null };
-        yield return new object[] { mockContainerServiceProvider.Object, false, "NoSuchName", null };
-        yield return new object[] { mockContainerServiceProvider.Object, true, "name", component };
-        yield return new object[] { mockContainerServiceProvider.Object, false, "name", null };
-        yield return new object[] { mockContainerServiceProvider.Object, true, "Name", component };
-        yield return new object[] { mockContainerServiceProvider.Object, false, "Name", null };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetInstance_NoSuchInstance_TestData))]
-    public void DesignerSerializationManager_GetInstance_NoNamedInstances_ReturnsNull(IServiceProvider provider, bool preserveNames, string name, object expected)
-    {
-        DesignerSerializationManager manager = new(provider)
-        {
-            PreserveNames = preserveNames
-        };
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        Assert.Same(expected, iManager.GetInstance(name));
-
-        // Call again.
-        Assert.Same(expected, iManager.GetInstance(name));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_GetInstance_HasNameInstancesNameExists_ReturnsExpected(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        object instance = new();
-        iManager.SetName(instance, name);
-        Assert.Same(instance, iManager.GetInstance(name));
-
-        // Call again.
-        Assert.Same(instance, iManager.GetInstance(name));
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("Name")]
-    [InlineData("NoSuchName")]
-    public void DesignerSerializationManager_GetInstance_HasNameInstancesNoSuchName_ReturnsExpected(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        object instance = new();
-        iManager.SetName(instance, "name");
-        Assert.Null(iManager.GetInstance(name));
-
-        // Call again.
-        Assert.Null(iManager.GetInstance(name));
-    }
-
-    public static IEnumerable<object[]> GetInstance_InvokeWithResolveName_TestData()
-    {
-        yield return new object[] { string.Empty, null };
-        yield return new object[] { string.Empty, new object() };
-        yield return new object[] { "NoSuchName", null };
-        yield return new object[] { "NoSuchName", new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetInstance_InvokeWithResolveName_TestData))]
-    public void DesignerSerializationManager_GetInstance_InvokeWithResolveName_CallsHandler(string name, object value)
-    {
-        Component component = new();
-        Container container = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns(container);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        DesignerSerializationManager manager = new(mockServiceProvider.Object);
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        ResolveNameEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(name, e.Name);
-            e.Value = value;
-            callCount++;
-        };
-        manager.CreateSession();
-        iManager.ResolveName += handler;
-
-        // With handler.
-        Assert.Same(value, iManager.GetInstance(name));
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        Assert.Same(value, iManager.GetInstance(name));
-        Assert.Equal(2, callCount);
-
-        // Does not call if there is a container instance.
-        container.Add(component, "name");
-        Assert.Same(component, iManager.GetInstance("name"));
-        Assert.Equal(2, callCount);
-
-        // Does not call if there is a named instance.
-        container.Remove(component);
-        iManager.SetName(component, "name");
-        Assert.Same(component, iManager.GetInstance("name"));
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        iManager.ResolveName -= handler;
-        Assert.Null(iManager.GetInstance(name));
-        Assert.Equal(2, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetInstance_NullName_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<ArgumentNullException>("name", () => iManager.GetInstance(null));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_GetInstance_NoSession_ThrowsInvalidOperationException(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<InvalidOperationException>(() => iManager.GetInstance(name));
-    }
-
-    public static IEnumerable<object[]> GetName_NoNamedInstance_TestData()
-    {
-        yield return new object[] { new object(), null };
-        yield return new object[] { new Component(), null };
-
-        Mock<IComponent> mockNoSiteComponent = new(MockBehavior.Strict);
-        mockNoSiteComponent
-            .Setup(c => c.Site)
-            .Returns((ISite)null);
-        mockNoSiteComponent
-            .Setup(c => c.Dispose());
-        yield return new object[] { mockNoSiteComponent.Object, null };
-
-        foreach (string name in new string[] { null, string.Empty, "name" })
-        {
-            Mock<ISite> mockSite = new(MockBehavior.Strict);
-            mockSite
-                .Setup(s => s.Name)
-                .Returns(name);
-            Mock<IComponent> mockSiteComponent = new(MockBehavior.Strict);
-            mockSiteComponent
-                .Setup(c => c.Site)
-                .Returns(mockSite.Object);
-            mockSiteComponent
-                .Setup(c => c.Dispose());
-            yield return new object[] { mockSiteComponent.Object, name };
-
-            Mock<INestedSite> mockNestedSite = new(MockBehavior.Strict);
-            mockNestedSite
-                .Setup(s => s.FullName)
-                .Returns(name);
-            Mock<IComponent> mockNestedSiteComponent = new(MockBehavior.Strict);
-            mockNestedSiteComponent
-                .Setup(c => c.Site)
-                .Returns(mockNestedSite.Object);
-            mockNestedSiteComponent
-                .Setup(c => c.Dispose());
-            yield return new object[] { mockNestedSiteComponent.Object, name };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetName_NoNamedInstance_TestData))]
-    public void DesignerSerializationManager_GetName_NoNamedInstance_ReturnsExpected(object instance, string expected)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        Assert.Same(expected, iManager.GetName(instance));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_GetName_HasNamedInstance_ReturnsExpected(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        object instance = new();
-        iManager.SetName(instance, name);
-        Assert.Same(name, iManager.GetName(instance));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_GetName_HasNamedComponent_ReturnsExpected(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        Mock<IComponent> mockInstance = new(MockBehavior.Strict);
-        mockInstance
-            .Setup(i => i.Site)
-            .Verifiable();
-        iManager.SetName(mockInstance.Object, name);
-        Assert.Same(name, iManager.GetName(mockInstance.Object));
-        mockInstance.Verify(i => i.Site, Times.Never());
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetName_NullValue_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<ArgumentNullException>("value", () => iManager.GetName(null));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetName_InvokeNoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<InvalidOperationException>(() => iManager.GetName("value"));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DesignerSerializationManager_GetService_WithProvider_ReturnsExpected(Type serviceType)
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(serviceType))
-            .Returns(service)
-            .Verifiable();
-        SubDesignerSerializationManager manager = new(mockServiceProvider.Object);
-        Assert.Same(service, manager.GetService(serviceType));
-        mockServiceProvider.Verify(p => p.GetService(serviceType), Times.Once());
-
-        Assert.Same(service, ((IServiceProvider)manager).GetService(serviceType));
-        mockServiceProvider.Verify(p => p.GetService(serviceType), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IServiceProvider_TestData))]
-    public void DesignerSerializationManager_GetService_IContainer_ReturnsExpected(IServiceProvider provider, object expected)
-    {
-        SubDesignerSerializationManager manager = new(provider);
-        Assert.Same(expected, manager.GetService(typeof(IContainer)));
-        Assert.Same(expected, ((IServiceProvider)manager).GetService(typeof(IContainer)));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    [InlineData(typeof(IContainer))]
-    public void DesignerSerializationManager_GetService_NoProvider_ReturnsNull(Type serviceType)
-    {
-        SubDesignerSerializationManager manager = new();
-        Assert.Null(manager.GetService(serviceType));
-        Assert.Null(((IServiceProvider)manager).GetService(serviceType));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetService_Invoke_CallsProtectedGetService()
-    {
-        object service = new();
-        Mock<DesignerSerializationManager> mockManager = new(MockBehavior.Strict);
-        mockManager
-            .Protected()
-            .Setup<object>("GetService", typeof(int))
-            .Returns(service)
-            .Verifiable();
-        IDesignerSerializationManager iManager = mockManager.Object;
-        Assert.Same(service, iManager.GetService(typeof(int)));
-        mockManager.Protected().Verify("GetService", Times.Once(), typeof(int));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetService_WithProvider_ReturnsExpected(Type serviceType)
-    {
-        object service = new();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(serviceType))
-            .Returns(service)
-            .Verifiable();
-        IDesignerSerializationManager iManager = new DesignerSerializationManager(mockServiceProvider.Object);
-        Assert.Same(service, iManager.GetService(serviceType));
-        mockServiceProvider.Verify(p => p.GetService(serviceType), Times.Once());
-
-        Assert.Same(service, ((IServiceProvider)iManager).GetService(serviceType));
-        mockServiceProvider.Verify(p => p.GetService(serviceType), Times.Exactly(2));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IServiceProvider_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetService_IContainer_ReturnsExpected(IServiceProvider provider, object expected)
-    {
-        IDesignerSerializationManager iManager = new DesignerSerializationManager(provider);
-        Assert.Same(expected, iManager.GetService(typeof(IContainer)));
-        Assert.Same(expected, ((IServiceProvider)iManager).GetService(typeof(IContainer)));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    [InlineData(typeof(IContainer))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetService_NoProvider_ReturnsNull(Type serviceType)
-    {
-        IDesignerSerializationManager iManager = new DesignerSerializationManager();
-        Assert.Null(iManager.GetService(serviceType));
-        Assert.Null(((IServiceProvider)iManager).GetService(serviceType));
-    }
-
-    public static IEnumerable<object[]> GetRuntimeType_ValidProvider_TestData()
-    {
-        foreach (string typeName in new string[] { null, string.Empty, "typeName" })
-        {
-            yield return new object[] { typeName, null };
-            yield return new object[] { typeName, typeof(string) };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetRuntimeType_ValidProvider_TestData))]
-    public void DesignerSerializationManager_GetRuntimeType_ValidProvider_ReturnsExpected(string typeName, Type resolvedType)
-    {
-        Mock<ITypeResolutionService> mockTypeResolutionService = new(MockBehavior.Strict);
-        mockTypeResolutionService
-            .Setup(s => s.GetType(typeName))
-            .Returns(resolvedType)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(mockTypeResolutionService.Object)
-            .Verifiable();
-        DesignerSerializationManager manager = new(mockServiceProvider.Object);
-        Assert.Same(resolvedType, manager.GetRuntimeType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Once());
-
-        // Call again.
-        Assert.Same(resolvedType, manager.GetRuntimeType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Exactly(2));
-    }
-
-    public static IEnumerable<object[]> GetRuntimeType_InvalidProvider_TestData()
-    {
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns((ITypeResolutionService)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns((TypeDescriptionProviderService)null);
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetRuntimeType_InvalidProvider_TestData))]
-    public void DesignerSerializationManager_GetRuntimeType_InvalidProvider_ReturnsExpected(IServiceProvider provider)
-    {
-        DesignerSerializationManager manager = new(provider);
-        Assert.Equal(typeof(int), manager.GetRuntimeType(typeof(int).FullName));
-    }
-
-    [Theory]
-    [InlineData("System.Int32", typeof(int))]
-    [InlineData("system.int32", null)]
-    [InlineData("NoSuchType", null)]
-    [InlineData("", null)]
-    public void DesignerSerializationManager_GetRuntimeType_NoProvider_ReturnsExpected(string typeName, Type expected)
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Same(expected, manager.GetRuntimeType(typeName));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetRuntimeType_NullTypeName_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Throws<ArgumentNullException>("typeName", () => manager.GetRuntimeType(null));
-    }
-
-    public static IEnumerable<object[]> GetSerializer_TestData()
-    {
-        foreach (Type objectType in new Type[] { null, typeof(int) })
-        {
-            yield return new object[] { objectType, typeof(int), null };
-            yield return new object[] { objectType, typeof(IDesignerSerializationProvider), null };
-            yield return new object[] { objectType, typeof(PublicDesignerSerializationProvider), null };
-            yield return new object[] { objectType, typeof(PrivateDesignerSerializationProvider), null };
-            yield return new object[] { objectType, typeof(ClassWithEmptyDefaultSerializationProvider), null };
-            yield return new object[] { objectType, typeof(ClassWithNoSuchDefaultSerializationProvider), null };
-            yield return new object[] { objectType, typeof(ClassWithInvalidDefaultSerializationProvider), null };
-            yield return new object[] { objectType, typeof(ClassWithPublicDesignerSerializationProvider), PublicDesignerSerializationProvider.Serializer };
-            yield return new object[] { objectType, typeof(ClassWithPrivateDesignerSerializationProvider), PrivateDesignerSerializationProvider.Serializer };
-            yield return new object[] { objectType, typeof(ClassWithNullDesignerSerializationProvider), null };
-        }
-
-        yield return new object[] { typeof(ClassWithNullBaseDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithEmptyBaseDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithNoSuchBaseDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithNullSubDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithEmptySubDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithNoSuchSubDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithPublicDesignerSerializer), typeof(int), null };
-        yield return new object[] { typeof(ClassWithPublicDesignerSerializer), typeof(object), null };
-        yield return new object[] { typeof(ClassWithPublicDesignerSerializer), typeof(SubClass), null };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_TestData))]
-    public void DesignerSerializationManager_GetSerializer_CustomIDesignerSerializationProvider_ReturnsExpected(Type objectType, Type serializerType, object expected)
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Same(expected, manager.GetSerializer(objectType, serializerType));
-
-        // Call again.
-        Assert.Same(expected, manager.GetSerializer(objectType, serializerType));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_TestData))]
-    public void DesignerSerializationManager_GetSerializerWithSession_CustomIDesignerSerializationProvider_ReturnsExpected(Type objectType, Type serializerType, object expected)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-
-        Assert.Same(expected, manager.GetSerializer(objectType, serializerType));
-
-        // Call again.
-        Assert.Same(expected, manager.GetSerializer(objectType, serializerType));
-    }
-
-    public static IEnumerable<object[]> GetSerializer_CustomDesignerSerializer_TestData()
-    {
-        yield return new object[] { typeof(ClassWithPublicDesignerSerializer), typeof(PublicDesignerSerializationProvider) };
-        yield return new object[] { typeof(ClassWithPrivateDesignerSerializer), typeof(PrivateDesignerSerializationProvider) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_CustomDesignerSerializer_TestData))]
-    public void DesignerSerializationManager_GetSerializer_CustomDesignerSerializerNoSession_ReturnsExpected(Type objectType, Type expectedSerializerType)
-    {
-        DesignerSerializationManager manager = new();
-        object serializer1 = manager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer1);
-
-        // Call again.
-        object serializer2 = manager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer2);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call different serializer type.
-        Assert.Null(manager.GetSerializer(objectType, expectedSerializerType));
-
-        // Call again.
-        Assert.Null(manager.GetSerializer(objectType, expectedSerializerType));
-
-        // Call invalid serializer type.
-        Assert.Null(manager.GetSerializer(objectType, typeof(object)));
-
-        // Call again.
-        Assert.Null(manager.GetSerializer(objectType, typeof(object)));
-
-        // Call unrelated serializer type.
-        Assert.Null(manager.GetSerializer(objectType, typeof(int)));
-
-        // Call again.
-        Assert.Null(manager.GetSerializer(objectType, typeof(int)));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_CustomDesignerSerializer_TestData))]
-    public void DesignerSerializationManager_GetSerializer_CustomDesignerSerializerWithSession_ReturnsExpected(Type objectType, Type expectedSerializerType)
-    {
-        DesignerSerializationManager manager = new();
-        manager.CreateSession();
-        object serializer1 = manager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer1);
-
-        // Call again.
-        object serializer2 = manager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer2);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call different serializer type.
-        object serializer3 = manager.GetSerializer(objectType, expectedSerializerType);
-        Assert.IsType(expectedSerializerType, serializer3);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call again.
-        object serializer4 = manager.GetSerializer(objectType, expectedSerializerType);
-        Assert.IsType(expectedSerializerType, serializer4);
-        Assert.Same(serializer3, serializer4);
-
-        // Call invalid serializer type.
-        object serializer5 = manager.GetSerializer(objectType, typeof(object));
-        Assert.IsType(expectedSerializerType, serializer5);
-        Assert.Same(serializer4, serializer5);
-
-        // Call again.
-        object serializer6 = manager.GetSerializer(objectType, typeof(object));
-        Assert.IsType(expectedSerializerType, serializer6);
-        Assert.Same(serializer5, serializer6);
-
-        // Call unrelated serializer type.
-        Assert.Null(manager.GetSerializer(objectType, typeof(int)));
-
-        // Call again.
-        Assert.Null(manager.GetSerializer(objectType, typeof(int)));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetSerializer_IDesignerSerializationProvider_ThrowsMissingMethodException()
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Throws<MissingMethodException>(() => manager.GetSerializer(null, typeof(ClassWithInterfaceDefaultSerializationProvider)));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DesignerSerializationManager_GetSerializer_NullSerializerType_ThrowsArgumentNullException(Type objectType)
-    {
-        DesignerSerializationManager manager = new();
-        Assert.Throws<ArgumentNullException>("serializerType", () => manager.GetSerializer(objectType, null));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializer_CustomIDesignerSerializationProvider_ReturnsExpected(Type objectType, Type serializerType, object expected)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Same(expected, iManager.GetSerializer(objectType, serializerType));
-
-        // Call again.
-        Assert.Same(expected, iManager.GetSerializer(objectType, serializerType));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializerWithSession_CustomIDesignerSerializationProvider_ReturnsExpected(Type objectType, Type serializerType, object expected)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        Assert.Same(expected, iManager.GetSerializer(objectType, serializerType));
-
-        // Call again.
-        Assert.Same(expected, iManager.GetSerializer(objectType, serializerType));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_CustomDesignerSerializer_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializer_CustomDesignerSerializerNoSession_ReturnsExpected(Type objectType, Type expectedSerializerType)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        object serializer1 = iManager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer1);
-
-        // Call again.
-        object serializer2 = iManager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer2);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call different serializer type.
-        Assert.Null(iManager.GetSerializer(objectType, expectedSerializerType));
-
-        // Call again.
-        Assert.Null(iManager.GetSerializer(objectType, expectedSerializerType));
-
-        // Call invalid serializer type.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(object)));
-
-        // Call again.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(object)));
-
-        // Call unrelated serializer type.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(int)));
-
-        // Call again.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(int)));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetSerializer_CustomDesignerSerializer_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializer_CustomDesignerSerializerWithSession_ReturnsExpected(Type objectType, Type expectedSerializerType)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        object serializer1 = iManager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer1);
-
-        // Call again.
-        object serializer2 = iManager.GetSerializer(objectType, typeof(BaseClass));
-        Assert.IsType(expectedSerializerType, serializer2);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call different serializer type.
-        object serializer3 = iManager.GetSerializer(objectType, expectedSerializerType);
-        Assert.IsType(expectedSerializerType, serializer3);
-        Assert.NotSame(serializer1, serializer2);
-
-        // Call again.
-        object serializer4 = iManager.GetSerializer(objectType, expectedSerializerType);
-        Assert.IsType(expectedSerializerType, serializer4);
-        Assert.Same(serializer3, serializer4);
-
-        // Call invalid serializer type.
-        object serializer5 = iManager.GetSerializer(objectType, typeof(object));
-        Assert.IsType(expectedSerializerType, serializer5);
-        Assert.Same(serializer4, serializer5);
-
-        // Call again.
-        object serializer6 = iManager.GetSerializer(objectType, typeof(object));
-        Assert.IsType(expectedSerializerType, serializer6);
-        Assert.Same(serializer5, serializer6);
-
-        // Call unrelated serializer type.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(int)));
-
-        // Call again.
-        Assert.Null(iManager.GetSerializer(objectType, typeof(int)));
-
-        // Call unrelated object type
-        Assert.Null(iManager.GetSerializer(typeof(object), typeof(int)));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializer_IDesignerSerializationProvider_ThrowsMissingMethodException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<MissingMethodException>(() => iManager.GetSerializer(null, typeof(ClassWithInterfaceDefaultSerializationProvider)));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetSerializer_NullSerializerType_ThrowsArgumentNullException(Type objectType)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<ArgumentNullException>("serializerType", () => iManager.GetSerializer(objectType, null));
-    }
-
-    public static IEnumerable<object[]> GetType_ValidProvider_TestData()
-    {
-        foreach (string typeName in new string[] { null, string.Empty, "typeName" })
-        {
-            yield return new object[] { typeName, null, 0, true, null };
-            yield return new object[] { typeName, null, 0, false, null };
-            yield return new object[] { typeName, typeof(int), 1, true, typeof(int) };
-            yield return new object[] { typeName, typeof(int), 1, false, null };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_ValidProvider_TestData))]
-    public void DesignerSerializationManager_GetType_ValidProvider_ReturnsExpected(string typeName, Type resolvedType, int typeDescriptionProviderServiceCount, bool supportedType, Type expected)
-    {
-        Mock<ITypeResolutionService> mockTypeResolutionService = new(MockBehavior.Strict);
-        mockTypeResolutionService
-            .Setup(s => s.GetType(typeName))
-            .Returns(resolvedType)
-            .Verifiable();
-        Mock<TypeDescriptionProvider> mockTypeDescriptionProvider = new(MockBehavior.Strict);
-        mockTypeDescriptionProvider
-            .Setup(p => p.IsSupportedType(resolvedType))
-            .Returns(supportedType)
-            .Verifiable();
-        Mock<TypeDescriptionProviderService> mockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        mockTypeDescriptionProviderService
-            .Setup(s => s.GetProvider(resolvedType))
-            .Returns(mockTypeDescriptionProvider.Object)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(mockTypeResolutionService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(mockTypeDescriptionProviderService.Object)
-            .Verifiable();
-        SubDesignerSerializationManager manager = new(mockServiceProvider.Object);
-        Assert.Same(expected, manager.GetType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Exactly(typeDescriptionProviderServiceCount));
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount));
-        mockTypeDescriptionProvider.Verify(s => s.IsSupportedType(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount));
-
-        // Call again.
-        Assert.Same(expected, manager.GetType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-        mockTypeDescriptionProvider.Verify(s => s.IsSupportedType(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-    }
-
-    public static IEnumerable<object[]> GetType_InvalidProvider_TestData()
-    {
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns((ITypeResolutionService)null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns((TypeDescriptionProviderService)null);
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(new object());
-        yield return new object[] { invalidMockServiceProvider.Object };
-
-        Mock<TypeDescriptionProviderService> invalidMockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        invalidMockTypeDescriptionProviderService
-            .Setup(p => p.GetProvider(typeof(int)))
-            .Returns((TypeDescriptionProvider)null);
-        Mock<IServiceProvider> invalidTypeDescriptionProviderServiceMockServiceProvider = new(MockBehavior.Strict);
-        invalidTypeDescriptionProviderServiceMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidTypeDescriptionProviderServiceMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidTypeDescriptionProviderServiceMockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(invalidMockTypeDescriptionProviderService.Object);
-        yield return new object[] { invalidTypeDescriptionProviderServiceMockServiceProvider.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_InvalidProvider_TestData))]
-    public void DesignerSerializationManager_GetType_InvalidProvider_ReturnsExpected(IServiceProvider provider)
-    {
-        SubDesignerSerializationManager manager = new(provider);
-        Assert.Equal(typeof(int), manager.GetType(typeof(int).FullName));
-    }
-
-    public static IEnumerable<object[]> GetType_NoProvider_TestData()
-    {
-        yield return new object[] { "System.Int32", typeof(int) };
-        yield return new object[] { "system.int32", null };
-        yield return new object[] { "NoSuchType", null };
-        yield return new object[] { string.Empty, null };
-        yield return new object[] { ".System.Int32", null };
-        yield return new object[] { "System.Int32.", null };
-        yield return new object[] { "Name.System.Int32", null };
-        yield return new object[] { "System.Int32.Name", null };
-        yield return new object[] { ".", null };
-        yield return new object[] { typeof(NestedClass).AssemblyQualifiedName, typeof(NestedClass) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_NoProvider_TestData))]
-    public void DesignerSerializationManager_GetType_NoProvider_ReturnsExpected(string typeName, Type expected)
-    {
-        SubDesignerSerializationManager manager = new();
-        Assert.Same(expected, manager.GetType(typeName));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_GetType_NullTypeName_ThrowsArgumentNullException()
-    {
-        SubDesignerSerializationManager manager = new();
-        Assert.Throws<ArgumentNullException>("typeName", () => manager.GetType(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_ValidProvider_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetType_ValidProvider_ReturnsExpected(string typeName, Type resolvedType, int typeDescriptionProviderServiceCount, bool supportedType, Type expected)
-    {
-        Mock<ITypeResolutionService> mockTypeResolutionService = new(MockBehavior.Strict);
-        mockTypeResolutionService
-            .Setup(s => s.GetType(typeName))
-            .Returns(resolvedType)
-            .Verifiable();
-        Mock<TypeDescriptionProvider> mockTypeDescriptionProvider = new(MockBehavior.Strict);
-        mockTypeDescriptionProvider
-            .Setup(p => p.IsSupportedType(resolvedType))
-            .Returns(supportedType)
-            .Verifiable();
-        Mock<TypeDescriptionProviderService> mockTypeDescriptionProviderService = new(MockBehavior.Strict);
-        mockTypeDescriptionProviderService
-            .Setup(s => s.GetProvider(resolvedType))
-            .Returns(mockTypeDescriptionProvider.Object)
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(mockTypeResolutionService.Object)
-            .Verifiable();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(TypeDescriptionProviderService)))
-            .Returns(mockTypeDescriptionProviderService.Object)
-            .Verifiable();
-        DesignerSerializationManager manager = new(mockServiceProvider.Object);
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        Assert.Same(expected, iManager.GetType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Once());
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Exactly(typeDescriptionProviderServiceCount));
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount));
-        mockTypeDescriptionProvider.Verify(s => s.IsSupportedType(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount));
-
-        // Call again.
-        Assert.Same(expected, iManager.GetType(typeName));
-        mockServiceProvider.Verify(p => p.GetService(typeof(ITypeResolutionService)), Times.Once());
-        mockTypeResolutionService.Verify(s => s.GetType(typeName), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(TypeDescriptionProviderService)), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-        mockTypeDescriptionProviderService.Verify(s => s.GetProvider(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-        mockTypeDescriptionProvider.Verify(s => s.IsSupportedType(resolvedType), Times.Exactly(typeDescriptionProviderServiceCount * 2));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_InvalidProvider_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetType_InvalidProvider_ReturnsExpected(IServiceProvider provider)
-    {
-        DesignerSerializationManager manager = new(provider);
-        IDesignerSerializationManager iManager = manager;
-        using IDisposable session = manager.CreateSession();
-        Assert.Equal(typeof(int), iManager.GetType(typeof(int).FullName));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_NoProvider_TestData))]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetType_NoProvider_ReturnsExpected(string typeName, Type expected)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        using IDisposable session = manager.CreateSession();
-        Assert.Same(expected, iManager.GetType(typeName));
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetType_NoSession_ThrowsInvalidOperationException(string typeName)
-    {
-        IDesignerSerializationManager iManager = new DesignerSerializationManager();
-        Assert.Throws<InvalidOperationException>(() => iManager.GetType(typeName));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_IDesignerSerializationManagerGetType_NullTypeName_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        using IDisposable session = manager.CreateSession();
-        Assert.Throws<ArgumentNullException>("typeName", () => iManager.GetType(null));
-    }
-
-    public static IEnumerable<object[]> ResolveNameEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ResolveNameEventArgs("name") };
-    }
-
-    [Theory]
-    [MemberData(nameof(ResolveNameEventArgs_TestData))]
-    public void DesignerSerializationManager_OnResolveName_InvokeWithResolveName_CallsHandler(ResolveNameEventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        ResolveNameEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        IDisposable session = manager.CreateSession();
-        iManager.ResolveName += handler;
-
-        // With handler.
-        manager.OnResolveName(eventArgs);
-        Assert.Equal(1, callCount);
-        session.Dispose();
-
-        // Call again.
-        session = manager.CreateSession();
-        iManager.ResolveName += handler;
-        manager.OnResolveName(eventArgs);
-        Assert.Equal(2, callCount);
-        session.Dispose();
-
-        // Remove handler.
-        session = manager.CreateSession();
-        iManager.ResolveName += handler;
-        iManager.ResolveName -= handler;
-        Assert.Equal(2, callCount);
-        session.Dispose();
-    }
-
-    [Theory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignerSerializationManager_OnSessionCreated_InvokeWithSessionCreated_CallsHandler(EventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        manager.SessionCreated += handler;
-
-        // With handler.
-        manager.OnSessionCreated(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        manager.OnSessionCreated(eventArgs);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        manager.SessionCreated -= handler;
-        Assert.Equal(2, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_OnSessionDisposed_Invoke_ClearsErrors()
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-
-        IDisposable session1 = manager.CreateSession();
-        IList errors1 = manager.Errors;
-        Assert.Empty(errors1);
-        Assert.Same(errors1, manager.Errors);
-        object errorInformation = new();
-        iManager.ReportError(errorInformation);
-        Assert.Same(errorInformation, Assert.Single(errors1));
-
-        // Dispose, get another and ensure cleared.
-        manager.OnSessionDisposed(EventArgs.Empty);
-        IDisposable session2 = manager.CreateSession();
-        IList errors2 = manager.Errors;
-        Assert.Empty(errors2);
-        Assert.Same(errors2, manager.Errors);
-        Assert.NotSame(errors1, errors2);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_OnSessionDisposed_Invoke_ClearsContext()
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-
-        IDisposable session1 = manager.CreateSession();
-        ContextStack stack1 = iManager.Context;
-        Assert.NotNull(stack1);
-        Assert.Same(stack1, iManager.Context);
-
-        // Dispose, get another and ensure cleared.
-        manager.OnSessionDisposed(EventArgs.Empty);
-        IDisposable session2 = manager.CreateSession();
-        ContextStack stack2 = iManager.Context;
-        Assert.NotNull(stack2);
-        Assert.Same(stack2, iManager.Context);
-        Assert.NotSame(stack1, stack2);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_OnSessionDisposed_Invoke_ClearsSerializers()
-    {
-        SubDesignerSerializationManager manager = new();
-
-        IDisposable session1 = manager.CreateSession();
-        object serializer1 = manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass));
-        Assert.IsType<PublicDesignerSerializationProvider>(serializer1);
-        Assert.Same(serializer1, manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(PublicDesignerSerializationProvider)));
-
-        // Dispose and ensure cleared.
-        manager.OnSessionDisposed(EventArgs.Empty);
-        object serializer2 = manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass));
-        Assert.IsType<PublicDesignerSerializationProvider>(serializer2);
-        Assert.NotSame(serializer1, serializer2);
-        Assert.NotSame(serializer2, manager.GetSerializer(typeof(ClassWithPublicDesignerSerializer), typeof(BaseClass)));
-    }
-
-    [Theory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignerSerializationManager_OnSessionDisposed_InvokeWithSessionDisposed_CallsHandler(EventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        manager.SessionDisposed += handler;
-
-        // With handler.
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        manager.SessionDisposed -= handler;
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [Theory]
-    [NewAndDefaultData<EventArgs>]
-    public void DesignerSerializationManager_OnSessionDisposed_InvokeWithSerializationComplete_CallsHandler(EventArgs eventArgs)
-    {
-        SubDesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(manager, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        IDisposable session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(1, callCount);
-        session.Dispose();
-
-        // Call again.
-        session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        session = manager.CreateSession();
-        iManager.SerializationComplete += handler;
-        iManager.SerializationComplete -= handler;
-        manager.OnSessionDisposed(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_RemoveSerializationProvider_Invoke_GetSerializerReturnsNull()
-    {
-        object serializer = new();
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Mock<IDesignerSerializationProvider> mockDesignerSerializationProvider = new(MockBehavior.Strict);
-        mockDesignerSerializationProvider
-            .Setup(p => p.GetSerializer(manager, null, typeof(int), mockDesignerSerializationProvider.Object.GetType()))
-            .Returns(serializer)
-            .Verifiable();
-        iManager.AddSerializationProvider(mockDesignerSerializationProvider.Object);
-        Assert.Same(serializer, iManager.GetSerializer(typeof(int), mockDesignerSerializationProvider.Object.GetType()));
-        mockDesignerSerializationProvider.Verify(p => p.GetSerializer(manager, null, typeof(int), mockDesignerSerializationProvider.Object.GetType()), Times.Once());
-
-        iManager.RemoveSerializationProvider(mockDesignerSerializationProvider.Object);
-        Assert.Null(iManager.GetSerializer(typeof(int), mockDesignerSerializationProvider.Object.GetType()));
-        mockDesignerSerializationProvider.Verify(p => p.GetSerializer(manager, null, typeof(int), mockDesignerSerializationProvider.Object.GetType()), Times.Once());
-
-        // Remove again.
-        iManager.RemoveSerializationProvider(mockDesignerSerializationProvider.Object);
-        Assert.Null(iManager.GetSerializer(typeof(int), mockDesignerSerializationProvider.Object.GetType()));
-        mockDesignerSerializationProvider.Verify(p => p.GetSerializer(manager, null, typeof(int), mockDesignerSerializationProvider.Object.GetType()), Times.Once());
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_RemoveSerializationProvider_NoSuchProviderNotEmpty_Nop()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Mock<IDesignerSerializationProvider> mockDesignerSerializationProvider1 = new(MockBehavior.Strict);
-        Mock<IDesignerSerializationProvider> mockDesignerSerializationProvider2 = new(MockBehavior.Strict);
-        iManager.AddSerializationProvider(mockDesignerSerializationProvider1.Object);
-        iManager.RemoveSerializationProvider(null);
-        iManager.RemoveSerializationProvider(mockDesignerSerializationProvider2.Object);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_RemoveSerializationProvider_NoSuchProviderEmpty_Nop()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Mock<IDesignerSerializationProvider> mockDesignerSerializationProvider = new(MockBehavior.Strict);
-        iManager.RemoveSerializationProvider(null);
-        iManager.RemoveSerializationProvider(mockDesignerSerializationProvider.Object);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_ReportError_NonNullErrorInformation_AddsToErrors()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        using (IDisposable session = manager.CreateSession())
-        {
-            object errorInformation = new();
-            iManager.ReportError(errorInformation);
-            Assert.Same(errorInformation, Assert.Single(manager.Errors));
-        }
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_ReportError_NullErrorInformation_Nop()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        using IDisposable session = manager.CreateSession();
-        iManager.ReportError(null);
-        Assert.Empty(manager.Errors);
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_ReportError_NoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<InvalidOperationException>(() => iManager.ReportError(null));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_SetName_Invoke_GetNameReturnsExpected(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-
-        object instance1 = new();
-        iManager.SetName(instance1, name);
-        Assert.Same(instance1, iManager.GetInstance(name));
-        Assert.Same(name, iManager.GetName(instance1));
-
-        object instance2 = new();
-        iManager.SetName(instance2, "OtherName");
-        Assert.Same(instance2, iManager.GetInstance("OtherName"));
-        Assert.Equal("OtherName", iManager.GetName(instance2));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_SetName_NullInstance_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        Assert.Throws<ArgumentNullException>("instance", () => iManager.SetName(null, "name"));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_SetName_NullName_ThrowsArgumentNullException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        Assert.Throws<ArgumentNullException>("name", () => iManager.SetName(new object(), null));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_SetName_OtherInstanceHasName_ThrowsArgumentException(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        object instance = new();
-        iManager.SetName(instance, name);
-        Assert.Throws<ArgumentException>("name", () => iManager.SetName(new object(), name));
-        Assert.Equal(name, iManager.GetName(instance));
-    }
-
-    [Theory]
-    [StringData]
-    public void DesignerSerializationManager_SetName_SameInstanceHasName_ThrowsArgumentException(string name)
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        manager.CreateSession();
-        object instance = new();
-        iManager.SetName(instance, name);
-        Assert.Throws<ArgumentException>("name", () => iManager.SetName(instance, name));
-        Assert.Throws<ArgumentException>("instance", () => iManager.SetName(instance, "OtherName"));
-        Assert.Equal(name, iManager.GetName(instance));
-    }
-
-    [Fact]
-    public void DesignerSerializationManager_SetName_InvokeNoSession_ThrowsInvalidOperationException()
-    {
-        DesignerSerializationManager manager = new();
-        IDesignerSerializationManager iManager = manager;
-        Assert.Throws<InvalidOperationException>(() => iManager.SetName(null, null));
-    }
-
-    private class SubDesignerSerializationManager : DesignerSerializationManager
-    {
-        public SubDesignerSerializationManager() : base()
-        {
-        }
-
-        public SubDesignerSerializationManager(IServiceProvider provider) : base(provider)
-        {
-        }
-
-        public new object CreateInstance(Type type, ICollection arguments, string name, bool addToContainer)
-        {
-            return base.CreateInstance(type, arguments, name, addToContainer);
-        }
-
-        public new object GetService(Type serviceType) => base.GetService(serviceType);
-
-        public new Type GetType(string typeName) => base.GetType(typeName);
-
-        public new void OnResolveName(ResolveNameEventArgs e) => base.OnResolveName(e);
-
-        public new void OnSessionCreated(EventArgs e) => base.OnSessionCreated(e);
-
-        public new void OnSessionDisposed(EventArgs e) => base.OnSessionDisposed(e);
-    }
-
-    private class PropertyProvider
-    {
-        [Category("Category")]
-        [Description("Description")]
-        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
-        [DesignOnly(true)]
-        [DisplayName("DisplayName")]
-        [Localizable(true)]
-        [TypeConverter(typeof(Int64Converter))]
-        public int Value { get; set; }
-    }
-
-    private class OtherPropertyProvider
-    {
-        public int OtherValue { get; set; }
-    }
-
-    private class NestedClass
-    {
-    }
-
-    [DesignerSerializerAttribute("System.Int32", (string)null)]
-    private class ClassWithNullBaseDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute("System.Int32", "")]
-    private class ClassWithEmptyBaseDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute("System.Int32", "NoSuchType")]
-    private class ClassWithNoSuchBaseDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute((string)null, typeof(int))]
-    private class ClassWithNullSubDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute("", typeof(int))]
-    private class ClassWithEmptySubDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute("NoSuchType", typeof(int))]
-    private class ClassWithNoSuchSubDesignerSerializer
-    {
-    }
-
-    private class BaseClass
-    {
-    }
-
-    private class SubClass : BaseClass
-    {
-    }
-
-    [DesignerSerializerAttribute(typeof(PublicDesignerSerializationProvider), typeof(BaseClass))]
-    private class ClassWithPublicDesignerSerializer
-    {
-    }
-
-    [DesignerSerializerAttribute(typeof(PrivateDesignerSerializationProvider), typeof(BaseClass))]
-    private class ClassWithPrivateDesignerSerializer
-    {
-    }
-
-    [DefaultSerializationProvider("")]
-    private class ClassWithEmptyDefaultSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider("NoSuchType")]
-    private class ClassWithNoSuchDefaultSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider(typeof(int))]
-    private class ClassWithInvalidDefaultSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider(typeof(IDesignerSerializationProvider))]
-    private class ClassWithInterfaceDefaultSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider(typeof(PublicDesignerSerializationProvider))]
-    private class ClassWithPublicDesignerSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider(typeof(PrivateDesignerSerializationProvider))]
-    private class ClassWithPrivateDesignerSerializationProvider
-    {
-    }
-
-    [DefaultSerializationProvider(typeof(NullDesignerSerializationProvider))]
-    private class ClassWithNullDesignerSerializationProvider
-    {
-    }
-
-    private class PublicDesignerSerializationProvider : IDesignerSerializationProvider
-    {
-        public static object Serializer { get; } = new object();
-
-        private PublicDesignerSerializationProvider()
-        {
-        }
-
-        public object GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
-        {
-            return Serializer;
-        }
-    }
-
-    private class PrivateDesignerSerializationProvider : IDesignerSerializationProvider
-    {
-        public static object Serializer { get; } = new object();
-
-        private PrivateDesignerSerializationProvider()
-        {
-        }
-
-        public object GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
-        {
-            return Serializer;
-        }
-    }
-
-    private class NullDesignerSerializationProvider : IDesignerSerializationProvider
-    {
-        public object GetSerializer(IDesignerSerializationManager manager, object currentSerializer, Type objectType, Type serializerType)
-        {
-            return null;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/ExpressionContextTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/ExpressionContextTests.cs
deleted file mode 100644
index 483b73a0fd1..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/ExpressionContextTests.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class ExpressionContextTests
-{
-    public static IEnumerable<object[]> Ctor_CodeExpression_Type_Object_Object_TestData()
-    {
-        yield return new object[] { new CodeExpression(), typeof(int), new object(), new object() };
-        yield return new object[] { new CodeExpression(), typeof(int), new object(), null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_CodeExpression_Type_Object_Object_TestData))]
-    public void ExpressionContext_Ctor_CodeExpression_Type_Object_Object_TestData(CodeExpression expression, Type expressionType, object owner, object presetValue)
-    {
-        ExpressionContext context = new(expression, expressionType, owner, presetValue);
-        Assert.Same(expression, context.Expression);
-        Assert.Same(expressionType, context.ExpressionType);
-        Assert.Same(owner, context.Owner);
-        Assert.Same(presetValue, context.PresetValue);
-    }
-
-    public static IEnumerable<object[]> Ctor_CodeExpression_Type_Object_TestData()
-    {
-        yield return new object[] { new CodeExpression(), typeof(int), new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_CodeExpression_Type_Object_TestData))]
-    public void ExpressionContext_Ctor_CodeExpression_Type_Object_TestData(CodeExpression expression, Type expressionType, object owner)
-    {
-        ExpressionContext context = new(expression, expressionType, owner);
-        Assert.Same(expression, context.Expression);
-        Assert.Same(expressionType, context.ExpressionType);
-        Assert.Same(owner, context.Owner);
-        Assert.Null(context.PresetValue);
-    }
-
-    [Fact]
-    public void ExpressionContext_Ctor_NullExpression_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("expression", () => new ExpressionContext(null, typeof(int), new object(), new object()));
-    }
-
-    [Fact]
-    public void RootContext_Ctor_NullExpressionType_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("expressionType", () => new ExpressionContext(new CodeExpression(), null, new object(), new object()));
-    }
-
-    [Fact]
-    public void RootContext_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new ExpressionContext(new CodeExpression(), typeof(int), null, new object()));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/RootContextTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/RootContextTests.cs
deleted file mode 100644
index d5f8c6d6ba0..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/RootContextTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class RootContextTests
-{
-    [Fact]
-    public void RootContext_Ctor_CodeExpression_Object()
-    {
-        CodeExpression expression = new();
-        object value = new();
-        RootContext context = new(expression, value);
-        Assert.Same(expression, context.Expression);
-        Assert.Same(value, context.Value);
-    }
-
-    [Fact]
-    public void RootContext_Ctor_NullExpression_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("expression", () => new RootContext(null, new object()));
-    }
-
-    [Fact]
-    public void RootContext_Ctor_NullValue_ThrowsArgumentNullException()
-    {
-        CodeExpression expression = new();
-        Assert.Throws<ArgumentNullException>("value", () => new RootContext(expression, null));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/SerializeAbsoluteContextTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/SerializeAbsoluteContextTests.cs
deleted file mode 100644
index ac3906a8810..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/SerializeAbsoluteContextTests.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class SerializeAbsoluteContextTests
-{
-    [Fact]
-    public void SerializeAbsoluteContext_Ctor_Default()
-    {
-        SerializeAbsoluteContext context = new();
-        Assert.Null(context.Member);
-    }
-
-    public static IEnumerable<object[]> Ctor_MemberDescriptor_TestData()
-    {
-        yield return new object[] { null };
-
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(RootContext));
-        yield return new object[] { properties[nameof(RootContext.Expression)] };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_MemberDescriptor_TestData))]
-    public void SerializeAbsoluteContext_Ctor_MemberDescriptor(MemberDescriptor member)
-    {
-        SerializeAbsoluteContext context = new(member);
-        Assert.Same(member, context.Member);
-    }
-
-    public static IEnumerable<object[]> ShouldSerialize_TestData()
-    {
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(RootContext));
-        MemberDescriptor member1 = properties[nameof(RootContext.Expression)];
-        MemberDescriptor member2 = properties[nameof(RootContext.Value)];
-
-        yield return new object[] { new SerializeAbsoluteContext(null), null, true };
-        yield return new object[] { new SerializeAbsoluteContext(null), member1, true };
-
-        yield return new object[] { new SerializeAbsoluteContext(member1), null, false };
-        yield return new object[] { new SerializeAbsoluteContext(member1), member1, true };
-        yield return new object[] { new SerializeAbsoluteContext(member2), member2, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(ShouldSerialize_TestData))]
-    public void SerializeAbsoluteContext_ShouldSerialize_Invoke_ReturnsExpected(SerializeAbsoluteContext context, MemberDescriptor member, bool expected)
-    {
-        Assert.Equal(expected, context.ShouldSerialize(member));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/StatementContextTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/StatementContextTests.cs
deleted file mode 100644
index 1532efa41bd..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/Serialization/StatementContextTests.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.ComponentModel.Design.Serialization.Tests;
-
-public class StatementContextTests
-{
-    [Fact]
-    public void StatementContext_Ctor_Default()
-    {
-        StatementContext context = new();
-        Assert.Empty(context.StatementCollection);
-        Assert.Same(context.StatementCollection, context.StatementCollection);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/SiteNestedContainerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/SiteNestedContainerTests.cs
deleted file mode 100644
index 2933ad5579f..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/SiteNestedContainerTests.cs
+++ /dev/null
@@ -1,1138 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class SiteNestedContainerTests
-{
-    public static IEnumerable<object[]> CreateNestedContainer_TestData()
-    {
-        static ISite CreateSite(string name)
-        {
-            Mock<ISite> mockSite = new(MockBehavior.Strict);
-            mockSite
-                .Setup(s => s.Name)
-                .Returns(name);
-            mockSite
-                .Setup(s => s.Container)
-                .Returns((IContainer)null);
-            mockSite
-                .Setup(s => s.GetService(typeof(ContainerFilterService)))
-                .Returns(null);
-            return mockSite.Object;
-        }
-
-        foreach (ISite site in new ISite[] { null, CreateSite(null) })
-        {
-            yield return new object[] { site, null, null, null };
-            yield return new object[] { site, null, string.Empty, string.Empty };
-            yield return new object[] { site, null, "componentName", "componentName" };
-            yield return new object[] { site, string.Empty, null, null };
-            yield return new object[] { site, string.Empty, string.Empty, string.Empty };
-            yield return new object[] { site, string.Empty, "componentName", "componentName" };
-            yield return new object[] { site, "containerName", null, null };
-            yield return new object[] { site, "containerName", string.Empty, ".containerName." };
-            yield return new object[] { site, "containerName", "componentName", ".containerName.componentName" };
-        }
-
-        yield return new object[] { CreateSite(string.Empty), null, null, null };
-        yield return new object[] { CreateSite(string.Empty), null, string.Empty, "." };
-        yield return new object[] { CreateSite(string.Empty), null, "componentName", ".componentName" };
-        yield return new object[] { CreateSite(string.Empty), string.Empty, null, null };
-        yield return new object[] { CreateSite(string.Empty), string.Empty, string.Empty, "." };
-        yield return new object[] { CreateSite(string.Empty), string.Empty, "componentName", ".componentName" };
-        yield return new object[] { CreateSite(string.Empty), "containerName", null, null };
-        yield return new object[] { CreateSite(string.Empty), "containerName", string.Empty, ".containerName." };
-        yield return new object[] { CreateSite(string.Empty), "containerName", "componentName", ".containerName.componentName" };
-
-        yield return new object[] { CreateSite("ownerName"), null, null, null };
-        yield return new object[] { CreateSite("ownerName"), null, string.Empty, "ownerName." };
-        yield return new object[] { CreateSite("ownerName"), null, "componentName", "ownerName.componentName" };
-        yield return new object[] { CreateSite("ownerName"), string.Empty, null, null };
-        yield return new object[] { CreateSite("ownerName"), string.Empty, string.Empty, "ownerName." };
-        yield return new object[] { CreateSite("ownerName"), string.Empty, "componentName", "ownerName.componentName" };
-        yield return new object[] { CreateSite("ownerName"), "containerName", null, null };
-        yield return new object[] { CreateSite("ownerName"), "containerName", string.Empty, "ownerName.containerName." };
-        yield return new object[] { CreateSite("ownerName"), "containerName", "componentName", "ownerName.containerName.componentName" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateNestedContainer_TestData))]
-    public void SiteNestedContainer_Add_Component_Success(ISite ownerSite, string containerName, string componentName, string expectedFullName)
-    {
-        using SubDesignSurface surface = new();
-        using Component ownerComponent = new()
-        {
-            Site = ownerSite
-        };
-        IDesignerLoaderHost2 host = surface.Host;
-        using INestedContainer container = surface.CreateNestedContainer(ownerComponent, containerName);
-        using RootDesignerComponent component1 = new();
-        container.Add(component1, componentName);
-        Assert.Same(container, component1.Container);
-        INestedSite nestedSite = Assert.IsAssignableFrom<INestedSite>(component1.Site);
-        Assert.Same(component1, nestedSite.Component);
-        Assert.Same(container, nestedSite.Container);
-        Assert.True(nestedSite.DesignMode);
-        Assert.Equal(expectedFullName, nestedSite.FullName);
-        Assert.Same(componentName, component1.Site.Name);
-        Assert.Same(component1, Assert.Single(container.Components));
-        Assert.Empty(host.Container.Components);
-        Assert.Equal(componentName, host.RootComponentClassName);
-
-        // Add another.
-        using RootDesignerComponent component2 = new();
-        container.Add(component2, "otherComponent");
-        Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>());
-        Assert.Empty(host.Container.Components);
-
-        // Add again.
-        container.Add(component1, "newName");
-        if (component1.Site is not null)
-        {
-            Assert.Equal(componentName, component1.Site.Name);
-        }
-
-        Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>());
-        Assert.Empty(host.Container.Components);
-    }
-
-    public static IEnumerable<object[]> Add_InvalidNameCreationServiceParentProvider_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        yield return new object[] { nullMockServiceProvider.Object };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(new object());
-        invalidMockServiceProvider
-           .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-           .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        yield return new object[] { invalidMockServiceProvider.Object };
-    }
-
-    public static IEnumerable<object[]> Add_ComponentParentProvider_TestData()
-    {
-        foreach (object[] testData in Add_InvalidNameCreationServiceParentProvider_TestData())
-        {
-            yield return new object[] { testData[0] };
-        }
-
-        foreach (string name in new string[] { null, string.Empty, "name" })
-        {
-            Mock<INameCreationService> mockNameCreationService = new(MockBehavior.Strict);
-            mockNameCreationService
-                .Setup(s => s.CreateName(It.IsAny<IContainer>(), It.IsAny<Type>()))
-                .Returns(name);
-            Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-                .Returns(null);
-            mockServiceProvider
-               .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-               .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(IInheritanceService)))
-                .Returns(null);
-            mockServiceProvider
-                .Setup(p => p.GetService(typeof(INameCreationService)))
-                .Returns(mockNameCreationService.Object);
-            yield return new object[] { mockServiceProvider.Object };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_ComponentParentProvider_TestData))]
-    public void SiteNestedContainer_Add_ComponentWithRootDesigner_Success(IServiceProvider parentProvider)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        using DesignerComponent component3 = new();
-        using Component component4 = new();
-
-        container.Add(component1);
-        Assert.Same(component1, Assert.Single(container.Components));
-        Assert.Null(host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(container, component1.Container);
-        Assert.Same(component1, component1.Site.Component);
-        Assert.Same(container, component1.Site.Container);
-        Assert.True(component1.Site.DesignMode);
-        Assert.Null(component1.Site.Name);
-
-        // Add different - root designer.
-        container.Add(component2);
-        Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>());
-        Assert.Null(host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(container, component2.Container);
-        Assert.Same(component2, component2.Site.Component);
-        Assert.Same(container, component2.Site.Container);
-        Assert.True(component2.Site.DesignMode);
-        Assert.Null(component2.Site.Name);
-
-        // Add different - non root designer.
-        container.Add(component3);
-        Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>());
-        Assert.Null(host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(container, component3.Container);
-        Assert.Same(component3, component3.Site.Component);
-        Assert.Same(container, component3.Site.Container);
-        Assert.True(component3.Site.DesignMode);
-        Assert.Null(component3.Site.Name);
-
-        // Add different - non designer.
-        container.Add(component4);
-        Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>());
-        Assert.Null(host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(container, component4.Container);
-        Assert.Same(component4, component4.Site.Component);
-        Assert.Same(container, component4.Site.Container);
-        Assert.True(component4.Site.DesignMode);
-        Assert.Null(component4.Site.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_InvalidNameCreationServiceParentProvider_TestData))]
-    public void SiteNestedContainer_Add_ComponentStringWithRootDesigner_Success(IServiceProvider parentProvider)
-    {
-        using SubDesignSurface surface = new(parentProvider);
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootDesignerComponent component1 = new();
-        using RootDesignerComponent component2 = new();
-        using DesignerComponent component3 = new();
-        using Component component4 = new();
-
-        container.Add(component1, "name1");
-        Assert.Same(component1, Assert.Single(container.Components));
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(container, component1.Container);
-        Assert.Same(component1, component1.Site.Component);
-        Assert.Same(container, component1.Site.Container);
-        Assert.True(component1.Site.DesignMode);
-        Assert.Equal("name1", component1.Site.Name);
-
-        // Add different - root designer.
-        container.Add(component2, "name2");
-        Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>());
-        Assert.Same(container, component2.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component2, component2.Site.Component);
-        Assert.Same(container, component2.Site.Container);
-        Assert.True(component2.Site.DesignMode);
-        Assert.Equal("name2", component2.Site.Name);
-
-        // Add different - non root designer.
-        container.Add(component3, string.Empty);
-        Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>());
-        Assert.Same(container, component3.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component3, component3.Site.Component);
-        Assert.Same(container, component3.Site.Container);
-        Assert.True(component3.Site.DesignMode);
-        Assert.Empty(component3.Site.Name);
-
-        // Add different - non designer.
-        container.Add(component4, null);
-        Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>());
-        Assert.Same(container, component4.Container);
-        Assert.Equal("name1", host.RootComponentClassName);
-        Assert.Same(component1, host.RootComponent);
-        Assert.Same(component4, component4.Site.Component);
-        Assert.Same(container, component4.Site.Container);
-        Assert.True(component4.Site.DesignMode);
-        Assert.Null(component4.Site.Name);
-    }
-
-    public static IEnumerable<object[]> Add_IExtenderProviderServiceWithoutDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent(), 0 };
-        yield return new object[] { new RootExtenderProviderDesignerComponent(), 1 };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent, 0 };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent, 1 };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_IExtenderProviderServiceWithoutDefault_TestData))]
-    public void SiteNestedContainer_Add_IExtenderProviderServiceWithoutDefault_Success(Component component, int expectedCallCount)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount));
-
-        // Add again.
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount * 2 + 1));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount * 2));
-
-        // Add again with name.
-        container.Add(component, "name");
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedCallCount * 3 + 1));
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedCallCount * 3));
-    }
-
-    public static IEnumerable<object[]> Add_IExtenderProviderServiceWithDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent(), false };
-        yield return new object[] { new RootExtenderProviderDesignerComponent(), true };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent, false };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent, true };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_IExtenderProviderServiceWithDefault_TestData))]
-    public void SiteNestedContainer_Add_IExtenderProviderServiceWithDefault_DoesNotCallGetService(Component component, bool throws)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(DesignerCommandSet)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IInheritanceService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using DesignSurface surface = new(mockServiceProvider.Object);
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Add again.
-        if (throws)
-        {
-            Assert.Throws<ArgumentException>("provider", () => container.Add(component));
-            Assert.Empty(container.Components);
-            Assert.Null(component.Site);
-        }
-        else
-        {
-            container.Add(component);
-            Assert.Same(component, Assert.Single(container.Components));
-            Assert.Null(component.Site.Name);
-        }
-
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Add again with name.
-        container.Add(component, "name");
-        Assert.Same(component, Assert.Single(container.Components));
-        if (throws)
-        {
-            Assert.Equal("name", component.Site.Name);
-        }
-        else
-        {
-            Assert.Null(component.Site.Name);
-        }
-
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-    }
-
-    public static IEnumerable<object[]> InvalidIExtenderProviderService_TestData()
-    {
-        yield return new object[] { null };
-
-        Mock<IServiceProvider> nullMockServiceProvider = new(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(null)
-            .Verifiable();
-        yield return new object[] { nullMockServiceProvider };
-
-        Mock<IServiceProvider> invalidMockServiceProvider = new(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(new object())
-            .Verifiable();
-        yield return new object[] { invalidMockServiceProvider };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void SiteNestedContainer_Add_InvalidIExtenderProviderServiceWithoutDefault_CallsParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootExtenderProviderDesignerComponent component = new();
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void SiteNestedContainer_Add_InvalidIExtenderProviderServiceWithDefault_DoesNotCallParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootExtenderProviderDesignerComponent component = new();
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Add_IComponentWithComponentAddingAndAdded_CallsHandler()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component = new();
-        int componentAddingCallCount = 0;
-        ComponentEventHandler componentAddingHandler = (sender, e) =>
-        {
-            Assert.Same(container, sender);
-            Assert.Same(component, e.Component);
-            componentAddingCallCount++;
-        };
-        changeService.ComponentAdding += componentAddingHandler;
-        int componentAddedCallCount = 0;
-        ComponentEventHandler componentAddedHandler = (sender, e) =>
-        {
-            Assert.Same(container, sender);
-            Assert.Same(component, e.Component);
-            Assert.True(componentAddedCallCount < componentAddingCallCount);
-            componentAddedCallCount++;
-        };
-        changeService.ComponentAdded += componentAddedHandler;
-
-        // With handler.
-        container.Add(component);
-        Assert.Same(container, component.Container);
-        Assert.Equal(1, componentAddingCallCount);
-        Assert.Equal(1, componentAddedCallCount);
-
-        // Add again.
-        container.Add(component);
-        Assert.Same(container, component.Container);
-        Assert.Equal(2, componentAddingCallCount);
-        Assert.Equal(2, componentAddedCallCount);
-
-        // Remove handler.
-        changeService.ComponentAdding -= componentAddingHandler;
-        changeService.ComponentAdded -= componentAddedHandler;
-        container.Add(component);
-        Assert.Same(container, component.Container);
-        Assert.Equal(2, componentAddingCallCount);
-        Assert.Equal(2, componentAddedCallCount);
-    }
-
-    public static IEnumerable<object[]> Add_NoRootDesigner_TestData()
-    {
-        yield return new object[] { new Component() };
-        yield return new object[] { new DesignerComponent() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_NoRootDesigner_TestData))]
-    public void SiteNestedContainer_Add_NoRootDesigner_ThrowsException(IComponent component)
-    {
-        using DesignSurface surface = new();
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        Assert.Throws<NotImplementedException>(() => container.Add(component));
-        Assert.Throws<NotImplementedException>(() => container.Add(component, "name"));
-        Assert.Empty(container.Components);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Add_CyclicRootDesigner_ThrowsException()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootDesignerComponent component = new();
-        container.Add(component, component.GetType().FullName);
-        Assert.Equal(component.GetType().FullName, host.RootComponentClassName);
-        Assert.Throws<Exception>(() => container.Add(component));
-        Assert.Throws<Exception>(() => container.Add(new RootDesignerComponent(), host.RootComponentClassName));
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Add_NonInitializingRootDesigner_ThrowsInvalidOperationException()
-    {
-        using DesignSurface surface = new();
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using NonInitializingDesignerComponent component = new();
-        Assert.Throws<InvalidOperationException>(() => container.Add(component));
-        Assert.Throws<InvalidOperationException>(() => container.Add(component, "name"));
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Add_ThrowingInitializingRootDesigner_RethrowsException()
-    {
-        using DesignSurface surface = new();
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using ThrowingInitializingDesignerComponent component = new();
-        Assert.Throws<DivideByZeroException>(() => container.Add(component));
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-
-        Assert.Throws<DivideByZeroException>(() => container.Add(component, "name"));
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Add_CheckoutExceptionThrowingInitializingRootDesigner_RethrowsException()
-    {
-        using DesignSurface surface = new();
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using CheckoutExceptionThrowingInitializingDesignerComponent component = new();
-        // CheckoutException does not bubble up in xunit.
-        bool threwCheckoutException = false;
-        try
-        {
-            container.Add(component);
-        }
-        catch (CheckoutException)
-        {
-            threwCheckoutException = true;
-        }
-
-        Assert.True(threwCheckoutException);
-        Assert.Same(container, component.Container);
-        Assert.Null(component.Site.Name);
-
-        container.Add(component, "name");
-        Assert.Same(container, component.Container);
-        Assert.Null(component.Site.Name);
-    }
-
-    [Fact(Skip = "Unstable test. See https://github.com/dotnet/winforms/issues/1151")]
-    public void SiteNestedContainer_Add_Unloading_Nop()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        surface.BeginLoad(typeof(RootDesignerComponent));
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        DisposingDesignerComponent component = new();
-        container.Add(component);
-        int callCount = 0;
-        DisposingDesigner.Disposed += (sender, e) =>
-        {
-            callCount++;
-        };
-        surface.Dispose();
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_Invoke_Success()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        using RootDesignerComponent rootComponent = new();
-        using DesignerComponent component = new();
-        container.Add(rootComponent);
-        container.Add(component);
-        container.Remove(rootComponent);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Same(container, component.Container);
-        Assert.NotNull(component.Site);
-
-        // Remove again.
-        container.Remove(rootComponent);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Same(container, component.Container);
-        Assert.NotNull(component.Site);
-
-        // Remove other.
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        Assert.Null(host.RootComponent);
-        Assert.Null(host.RootComponentClassName);
-        Assert.Null(rootComponent.Container);
-        Assert.Null(rootComponent.Site);
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    public static IEnumerable<object[]> Remove_IExtenderProviderServiceWithoutDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent(), 0, 0 };
-        yield return new object[] { new RootExtenderProviderDesignerComponent(), 1, 1 };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent, 0, 1 };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent, 1, 1 };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_IExtenderProviderServiceWithoutDefault_TestData))]
-    public void SiteNestedContainer_Remove_IExtenderProviderServiceWithoutDefault_Success(Component component, int expectedAddCallCount, int expectedRemoveCallCount)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider));
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using SubDesignSurface surface = new(mockServiceProvider.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Same(container, component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount));
-
-        // Remove.
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount + expectedRemoveCallCount));
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedRemoveCallCount));
-
-        // Remove again.
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(expectedAddCallCount + expectedRemoveCallCount));
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Exactly(expectedRemoveCallCount));
-    }
-
-    public static IEnumerable<object[]> Remove_IExtenderProviderServiceWithDefault_TestData()
-    {
-        yield return new object[] { new RootDesignerComponent() };
-        yield return new object[] { new RootExtenderProviderDesignerComponent() };
-
-        RootExtenderProviderDesignerComponent readOnlyComponent = new();
-        TypeDescriptor.AddAttributes(readOnlyComponent, new InheritanceAttribute(InheritanceLevel.InheritedReadOnly));
-        yield return new object[] { readOnlyComponent };
-
-        RootExtenderProviderDesignerComponent inheritedComponent = new();
-        TypeDescriptor.AddAttributes(inheritedComponent, new InheritanceAttribute(InheritanceLevel.Inherited));
-        yield return new object[] { inheritedComponent };
-
-        RootExtenderProviderDesignerComponent notInheritedComponent = new();
-        TypeDescriptor.AddAttributes(notInheritedComponent, new InheritanceAttribute(InheritanceLevel.NotInherited));
-        yield return new object[] { notInheritedComponent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_IExtenderProviderServiceWithDefault_TestData))]
-    public void SiteNestedContainer_Remove_IExtenderProviderServiceWithDefault_Success(Component component)
-    {
-        Mock<IExtenderProviderService> mockExtenderProviderService = new(MockBehavior.Strict);
-        mockExtenderProviderService
-            .Setup(s => s.AddExtenderProvider(component as IExtenderProvider))
-            .Verifiable();
-        mockExtenderProviderService
-            .Setup(s => s.RemoveExtenderProvider(component as IExtenderProvider));
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(INameCreationService)))
-            .Returns(null);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IExtenderProviderService)))
-            .Returns(mockExtenderProviderService.Object)
-            .Verifiable();
-
-        using DesignSurface surface = new(mockServiceProvider.Object);
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        Assert.Null(component.Site.Name);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.AddExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Remove.
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Never());
-
-        // Remove again.
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        Assert.Null(component.Container);
-        mockServiceProvider.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-        mockExtenderProviderService.Verify(s => s.RemoveExtenderProvider(component as IExtenderProvider), Times.Never());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void SiteNestedContainer_Remove_InvalidIExtenderProviderServiceWithoutDefault_CallsParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using SubDesignSurface surface = new(mockParentProvider?.Object);
-        surface.ServiceContainer.RemoveService(typeof(IExtenderProviderService));
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootExtenderProviderDesignerComponent component = new();
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Once());
-
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Exactly(2));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidIExtenderProviderService_TestData))]
-    public void SiteNestedContainer_Remove_InvalidIExtenderProviderServiceWithDefault_DoesNotCallParentGetService(Mock<IServiceProvider> mockParentProvider)
-    {
-        using DesignSurface surface = new(mockParentProvider?.Object);
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        using RootExtenderProviderDesignerComponent component = new();
-
-        container.Add(component);
-        Assert.Same(component, Assert.Single(container.Components));
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-
-        container.Remove(component);
-        Assert.Empty(container.Components);
-        mockParentProvider?.Verify(p => p.GetService(typeof(IExtenderProviderService)), Times.Never());
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_ComponentNotInContainerNonEmpty_Nop()
-    {
-        using DesignSurface surface = new();
-        using Component component1 = new();
-        using INestedContainer container1 = surface.CreateNestedContainer(component1, "containerName");
-        using Component component2 = new();
-        using INestedContainer container2 = surface.CreateNestedContainer(component2, "containerName");
-
-        using RootDesignerComponent otherComponent = new();
-        using RootDesignerComponent component = new();
-        container1.Add(otherComponent);
-        container2.Add(component);
-        container2.Remove(otherComponent);
-        container2.Remove(new Component());
-        Assert.Same(otherComponent, Assert.Single(container1.Components));
-        Assert.Same(component, Assert.Single(container2.Components));
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_ComponentNotInContainerEmpty_Nop()
-    {
-        using DesignSurface surface = new();
-        using Component component1 = new();
-        using INestedContainer container1 = surface.CreateNestedContainer(component1, "containerName");
-        using Component component2 = new();
-        using INestedContainer container2 = surface.CreateNestedContainer(component2, "containerName");
-
-        using RootDesignerComponent otherComponent = new();
-        container1.Add(otherComponent);
-        container2.Remove(otherComponent);
-        container2.Remove(new Component());
-        Assert.Same(otherComponent, Assert.Single(container1.Components));
-        Assert.Empty(container2.Components);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_InvokeWithComponentRemoved_CallsHandler()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component1 = new();
-        using DesignerComponent component2 = new();
-        int componentRemovingCallCount = 0;
-        ComponentEventHandler componentRemovingHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component1, e.Component);
-            Assert.NotNull(e.Component.Site);
-            componentRemovingCallCount++;
-        };
-        changeService.ComponentRemoving += componentRemovingHandler;
-
-        int componentRemovedCallCount = 0;
-        ComponentEventHandler componentRemovedHandler = (sender, e) =>
-        {
-            Assert.Same(host, sender);
-            Assert.Same(component1, e.Component);
-            Assert.NotNull(e.Component.Site);
-            Assert.True(componentRemovedCallCount < componentRemovingCallCount);
-            componentRemovedCallCount++;
-        };
-        changeService.ComponentRemoved += componentRemovedHandler;
-
-        container.Add(component1);
-        container.Add(component2);
-
-        // With handler.
-        container.Remove(component1);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Same(container, component2.Container);
-        Assert.NotNull(component2.Site);
-        Assert.Same(component2, Assert.Single(container.Components));
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-
-        // Remove again.
-        container.Remove(component1);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Same(container, component2.Container);
-        Assert.NotNull(component2.Site);
-        Assert.Same(component2, Assert.Single(container.Components));
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-
-        // Remove handler.
-        changeService.ComponentRemoving -= componentRemovingHandler;
-        changeService.ComponentRemoved -= componentRemovedHandler;
-        container.Remove(component2);
-        Assert.Null(component1.Container);
-        Assert.Null(component1.Site);
-        Assert.Null(component2.Container);
-        Assert.Null(component2.Site);
-        Assert.Empty(host.Container.Components);
-        Assert.Equal(1, componentRemovingCallCount);
-        Assert.Equal(1, componentRemovedCallCount);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_SetSiteToNullInComponentRemoving_Success()
-    {
-        using SubDesignSurface surface = new();
-        IDesignerLoaderHost2 host = surface.Host;
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-        IComponentChangeService changeService = Assert.IsAssignableFrom<IComponentChangeService>(host);
-
-        using RootDesignerComponent component = new();
-        int componentRemovingCallCount = 0;
-        ComponentEventHandler componentRemovingHandler = (sender, e) =>
-        {
-            component.Site = null;
-            componentRemovingCallCount++;
-        };
-        changeService.ComponentRemoving += componentRemovingHandler;
-
-        container.Add(component);
-        container.Remove(component);
-        Assert.Null(component.Container);
-        Assert.Null(component.Site);
-    }
-
-    [WinFormsFact]
-    public void SiteNestedContainer_Remove_SiteHasDictionary_DoesNotClearDictionary()
-    {
-        using SubDesignSurface surface = new();
-        using Component owningComponent = new();
-        using INestedContainer container = surface.CreateNestedContainer(owningComponent, "containerName");
-
-        using RootDesignerComponent component = new();
-        container.Add(component);
-        IDictionaryService service = Assert.IsAssignableFrom<IDictionaryService>(component.Site);
-        service.SetValue("key", "value");
-        Assert.Equal("value", service.GetValue("key"));
-
-        container.Remove(component);
-        Assert.Equal("value", service.GetValue("key"));
-    }
-
-    private class SubDesignSurface : DesignSurface
-    {
-        public SubDesignSurface() : base()
-        {
-        }
-
-        public SubDesignSurface(IServiceProvider parentProvider) : base(parentProvider)
-        {
-        }
-
-        public new ServiceContainer ServiceContainer => base.ServiceContainer;
-
-        public IDesignerLoaderHost2 Host => Assert.IsAssignableFrom<IDesignerLoaderHost2>(ComponentContainer);
-    }
-
-    private abstract class CustomDesigner : IDesigner
-    {
-        protected IComponent _initializedComponent;
-
-        public IComponent Component => _initializedComponent;
-
-        public DesignerVerbCollection Verbs { get; }
-
-        public void DoDefaultAction()
-        {
-        }
-
-        public void Dispose() => Dispose(true);
-
-        protected virtual void Dispose(bool disposing)
-        {
-        }
-
-        public abstract void Initialize(IComponent component);
-    }
-
-    private class Designer : CustomDesigner
-    {
-        public override void Initialize(IComponent component) => _initializedComponent = component;
-    }
-
-    [Designer(typeof(Designer))]
-    private class DesignerComponent : Component
-    {
-    }
-
-    private class RootDesigner : Designer, IRootDesigner
-    {
-        public ViewTechnology[] SupportedTechnologies { get; }
-
-        public object GetView(ViewTechnology technology) => throw new NotImplementedException();
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class RootDesignerComponent : Component
-    {
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class RootExtenderProviderDesignerComponent : Component, IExtenderProvider
-    {
-        public bool CanExtend(object extendee) => false;
-    }
-
-    private class NonInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-        }
-    }
-
-    [Designer(typeof(NonInitializingDesigner), typeof(IRootDesigner))]
-    private class NonInitializingDesignerComponent : Component
-    {
-    }
-
-    private class ThrowingInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [Designer(typeof(ThrowingInitializingDesigner), typeof(IRootDesigner))]
-    private class ThrowingInitializingDesignerComponent : Component
-    {
-    }
-
-    private class CheckoutExceptionThrowingInitializingDesigner : RootDesigner
-    {
-        public override void Initialize(IComponent component)
-        {
-            throw CheckoutException.Canceled;
-        }
-    }
-
-    [Designer(typeof(CheckoutExceptionThrowingInitializingDesigner), typeof(IRootDesigner))]
-    private class CheckoutExceptionThrowingInitializingDesignerComponent : Component
-    {
-    }
-
-    private class DisposingDesigner : Designer
-    {
-        public static EventHandler Disposed;
-
-        protected override void Dispose(bool disposing)
-        {
-            Disposed?.Invoke(this, EventArgs.Empty);
-        }
-    }
-
-    [Designer(typeof(DisposingDesigner))]
-    private class DisposingDesignerComponent : Component
-    {
-    }
-
-    [Designer(typeof(RootDesigner), typeof(IRootDesigner))]
-    private class CustomTypeDescriptionProviderComponent : Component
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/UndoUnitTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/UndoUnitTests.cs
deleted file mode 100644
index 265167f5e66..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/ComponentModel/Design/UndoUnitTests.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using Moq;
-
-namespace System.ComponentModel.Design.Tests;
-
-public class UndoUnitTests : UndoEngine
-{
-    public UndoUnitTests() : base(GetServiceProvider())
-    {
-    }
-
-    private static IServiceProvider GetServiceProvider()
-    {
-        Mock<IServiceProvider> mockServiceProvider = new();
-        Mock<IDesignerHost> mockDesignerHost = new();
-        Mock<IComponentChangeService> mockComponentChangeService = new();
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(ComponentSerializationService)))
-            .Returns(new CodeDomComponentSerializationService());
-        return mockServiceProvider.Object;
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void UndoUnit_Ctor_UndoEngine_String(string name, string expectedName)
-    {
-        SubUndoUnit unit = new(this, name);
-        Assert.Same(this, unit.UndoEngine);
-        Assert.Equal(expectedName, unit.Name);
-        Assert.True(unit.IsEmpty);
-    }
-
-    [Fact]
-    public void UndoUnit_NullEngine_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("engine", () => new UndoUnit(null, "name"));
-    }
-
-    protected override void AddUndoUnit(UndoUnit unit)
-    {
-    }
-
-    protected class SubUndoUnit : UndoUnit
-    {
-        public SubUndoUnit(UndoEngine engine, string name) : base(engine, name)
-        {
-        }
-
-        public new UndoEngine UndoEngine => base.UndoEngine;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/BitmapEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/BitmapEditorTests.cs
deleted file mode 100644
index dd819a953fe..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/BitmapEditorTests.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Imaging;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class BitmapEditorTests
-{
-    [Fact]
-    public void BitmapEditor_Ctor_Default()
-    {
-        BitmapEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Fact]
-    public void BitmapEditor_BitmapExtensions_Get_ReturnsExpected()
-    {
-        SubBitmapEditor editor = new();
-        List<string> extensions = SubBitmapEditor.BitmapExtensions;
-        Assert.Equal(new string[] { "bmp", "gif", "jpg", "jpeg", "png", "ico" }, extensions);
-        Assert.Same(extensions, SubBitmapEditor.BitmapExtensions);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void BitmapEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        BitmapEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Fact]
-    public void BitmapEditor_GetExtensions_InvokeDefault_ReturnsExpected()
-    {
-        SubBitmapEditor editor = new();
-        string[] extensions = editor.GetExtensions();
-        Assert.Equal(new string[] { "bmp", "gif", "jpg", "jpeg", "png", "ico" }, extensions);
-        Assert.NotSame(extensions, editor.GetExtensions());
-    }
-
-    [Fact]
-    public void BitmapEditor_GetExtensions_InvokeCustomExtenders_ReturnsExpected()
-    {
-        CustomGetImageExtendersEditor editor = new();
-        string[] extensions = editor.GetExtensions();
-        Assert.Equal(new string[] { "bmp", "gif", "jpg", "jpeg", "png", "ico" }, extensions);
-        Assert.NotSame(extensions, editor.GetExtensions());
-    }
-
-    [Fact]
-    public void BitmapEditor_GetFileDialogDescription_Invoke_ReturnsExpected()
-    {
-        SubBitmapEditor editor = new();
-        Assert.Equal("Bitmap files", editor.GetFileDialogDescription());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void BitmapEditor_GetPaintValueSupported_Invoke_ReturnsTrue(ITypeDescriptorContext context)
-    {
-        BitmapEditor editor = new();
-        Assert.True(editor.GetPaintValueSupported(context));
-    }
-
-    [Fact]
-    public void BitmapEditor_LoadFromStream_BitmapStream_ReturnsExpected()
-    {
-        SubBitmapEditor editor = new();
-        using (MemoryStream stream = new MemoryStream())
-        using (Bitmap image = new(10, 10))
-        {
-            image.Save(stream, ImageFormat.Bmp);
-            stream.Position = 0;
-            Bitmap result = Assert.IsType<Bitmap>(editor.LoadFromStream(stream));
-            Assert.Equal(new Size(10, 10), result.Size);
-
-            using MemoryStream resultStream = new();
-            result.Save(resultStream, ImageFormat.Bmp);
-            Assert.Equal(stream.Length, resultStream.Length);
-        }
-    }
-
-    [Fact]
-    public void BitmapEditor_LoadFromStream_MetafileStream_ReturnsExpected()
-    {
-        SubBitmapEditor editor = new();
-        using (Stream stream = File.OpenRead("Resources/telescope_01.wmf"))
-        {
-            Bitmap result = Assert.IsType<Bitmap>(editor.LoadFromStream(stream));
-            Assert.Equal(new Size(490, 654), result.Size);
-        }
-    }
-
-    [Fact]
-    public void BitmapEditor_LoadFromStream_NullStream_ThrowsArgumentNullException()
-    {
-        SubBitmapEditor editor = new();
-        Assert.Throws<ArgumentNullException>("stream", () => editor.LoadFromStream(null));
-    }
-
-    private class SubBitmapEditor : BitmapEditor
-    {
-        public static new List<string> BitmapExtensions = BitmapEditor.BitmapExtensions;
-
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        public new string GetFileDialogDescription() => base.GetFileDialogDescription();
-
-        public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);
-    }
-
-    private class CustomGetImageExtendersEditor : BitmapEditor
-    {
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        protected override Type[] GetImageExtenders() => new Type[] { typeof(CustomGetExtensionsEditor) };
-    }
-
-    private class CustomGetExtensionsEditor : ImageEditor
-    {
-        protected override string[] GetExtensions() => new string[] { "CustomGetExtensionsEditor" };
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.CustomColorDialogTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.CustomColorDialogTests.cs
deleted file mode 100644
index e69749a9026..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.CustomColorDialogTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Drawing.Design.Tests;
-
-public partial class ColorEditor_CustomColorDialogTests
-{
-    [WinFormsFact]
-    public void CustomColorDialog_Ctor_Default()
-    {
-        Type? typeCustomColorDialog = typeof(ColorEditor).Assembly.GetTypes().SingleOrDefault(t => t.Name == "CustomColorDialog");
-        Assert.NotNull(typeCustomColorDialog);
-
-        using ColorDialog dialog = (ColorDialog)Activator.CreateInstance(typeCustomColorDialog!)!;
-        Assert.NotNull(dialog);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.cs
deleted file mode 100644
index 71463510fb4..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ColorEditorTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public partial class ColorEditorTests
-{
-    [Fact]
-    public void ColorEditor_Ctor_Default()
-    {
-        ColorEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void ColorEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        ColorEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void ColorEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        ColorEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ColorEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        ColorEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ColorEditor_GetPaintValueSupported_Invoke_ReturnsTrue(ITypeDescriptorContext context)
-    {
-        ColorEditor editor = new();
-        Assert.True(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/CursorEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/CursorEditorTests.cs
deleted file mode 100644
index 58a0dc5889e..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/CursorEditorTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class CursorEditorTests
-{
-    [Fact]
-    public void CursorEditor_Ctor_Default()
-    {
-        CursorEditor editor = new();
-        Assert.True(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { Cursors.Default };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void CursorEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        CursorEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void CursorEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        CursorEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void CursorEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        CursorEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void CursorEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        CursorEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontEditorTests.cs
deleted file mode 100644
index 91ff0614af6..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontEditorTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class FontEditorTests
-{
-    [Fact]
-    public void FontEditor_Ctor_Default()
-    {
-        FontEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void FontEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        FontEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FontEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        FontEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FontEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        FontEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontNameEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontNameEditorTests.cs
deleted file mode 100644
index e1b0c39bc89..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/FontNameEditorTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Windows.Forms.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class FontNameEditorTests
-{
-    private readonly ITypeDescriptorContext _typeDescriptorContext;
-
-    public FontNameEditorTests()
-    {
-        _typeDescriptorContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict).Object;
-    }
-
-    [Fact]
-    public void FontNameEditor_Ctor_Default()
-    {
-        FontNameEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void FontNameEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        FontNameEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        Assert.Same(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Never());
-
-        // Edit again.
-        Assert.Same(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Never());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void FontNameEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        FontNameEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FontNameEditor_GetEditStyle_Invoke_ReturnsNone(ITypeDescriptorContext context)
-    {
-        FontNameEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.None, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FontNameEditor_GetPaintValueSupported_Invoke_ReturnsTrue(ITypeDescriptorContext context)
-    {
-        FontNameEditor editor = new();
-        Assert.True(editor.GetPaintValueSupported(context));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("\t")]
-    public void FontNameEditor_PaintValue_ReturnsEarly_InvalidPaintValueEventArgsValue(string fontName)
-    {
-        PaintValueEventArgs e;
-        using (Bitmap bitmap = new(1, 1))
-        {
-            using var g = Graphics.FromImage(bitmap);
-            e = new PaintValueEventArgs(_typeDescriptorContext, fontName, g, Rectangle.Empty);
-        }
-
-        // assert by the virtue of calling the method
-        // if the implementation is incorrect, having disposed of the Graphics object
-        // we would received an AE attempting to call e.Graphics.FillRectangle()
-        FontNameEditor editor = new();
-        editor.PaintValue(e);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ImageEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ImageEditorTests.cs
deleted file mode 100644
index 8e751661d38..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ImageEditorTests.cs
+++ /dev/null
@@ -1,270 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Imaging;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class ImageEditorTests
-{
-    [Fact]
-    public void ImageEditor_Ctor_Default()
-    {
-        ImageEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> CreateExtensionsString_TestData()
-    {
-        yield return new object[] { null, ",", null };
-        yield return new object[] { Array.Empty<string>(), ",", null };
-        yield return new object[] { new string[] { "a", "b", "c" }, ",", "*.a,*.b,*.c" };
-        yield return new object[] { new string[] { "a", "b", "c" }, "", "*.a*.b*.c" };
-        yield return new object[] { new string[] { "a", "b", "c" }, null, "*.a*.b*.c" };
-        yield return new object[] { new string[] { null, null, null }, ",", "" };
-        yield return new object[] { new string[] { string.Empty, string.Empty, string.Empty }, ",", "" };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateExtensionsString_TestData))]
-    public void ImageEditor_CreateExtensionsString_Invoke_ReturnsExpected(string[] extensions, string sep, string expected)
-    {
-        Assert.Equal(expected, SubImageEditor.CreateExtensionsString(extensions, sep));
-    }
-
-    [Fact]
-    public void ImageEditor_CreateFilterEntry_Invoke_CallsGetExtensionsOnce()
-    {
-        CustomGetImageExtendersEditor editor = new()
-        {
-            GetImageExtendersResult = new Type[] { typeof(PublicImageEditor), typeof(PrivateImageEditor) }
-        };
-        Assert.Equal("CustomGetImageExtendersEditor(*.PublicImageEditor,*.PrivateImageEditor)|*.PublicImageEditor;*.PrivateImageEditor", SubImageEditor.CreateFilterEntry(editor));
-        Assert.Equal(1, editor.GetImageExtendersCallCount);
-    }
-
-    [Fact]
-    public void ImageEditor_CreateFilterEntry_NullE_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("e", () => SubImageEditor.CreateFilterEntry(null));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void ImageEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        ImageEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ImageEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        ImageEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Fact]
-    public void ImageEditor_GetExtensions_InvokeDefault_ReturnsExpected()
-    {
-        SubImageEditor editor = new();
-        string[] extensions = editor.GetExtensions();
-        Assert.Equal(new string[] { "bmp", "gif", "jpg", "jpeg", "png", "ico", "emf", "wmf" }, extensions);
-        Assert.NotSame(extensions, editor.GetExtensions());
-    }
-
-    [Fact]
-    public void ImageEditor_GetExtensions_InvokeCustom_CallsGetImageExtendersOnce()
-    {
-        CustomGetImageExtendersEditor editor = new()
-        {
-            GetImageExtendersResult = new Type[] { typeof(PublicImageEditor), typeof(PrivateImageEditor), typeof(ImageEditor), typeof(NullExtensionsImageEditor) }
-        };
-        Assert.Equal(new string[] { "PublicImageEditor", "PrivateImageEditor" }, editor.GetExtensions());
-        Assert.Equal(1, editor.GetImageExtendersCallCount);
-    }
-
-    [Fact]
-    public void ImageEditor_GetExtensions_InvokeInvalid_ReturnsExpected()
-    {
-        CustomGetImageExtendersEditor editor = new()
-        {
-            GetImageExtendersResult = new Type[] { typeof(object), null }
-        };
-        Assert.Empty(editor.GetExtensions());
-        Assert.Equal(1, editor.GetImageExtendersCallCount);
-    }
-
-    [Fact]
-    public void ImageEditor_GetFileDialogDescription_Invoke_ReturnsExpected()
-    {
-        SubImageEditor editor = new();
-        Assert.Equal("All image files", editor.GetFileDialogDescription());
-    }
-
-    [Fact]
-    public void ImageEditor_GetImageExtenders_Invoke_ReturnsExpected()
-    {
-        SubImageEditor editor = new();
-        Type[] extenders = editor.GetImageExtenders();
-        Assert.Equal(new Type[] { typeof(BitmapEditor), typeof(MetafileEditor) }, extenders);
-        Assert.Same(extenders, editor.GetImageExtenders());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ImageEditor_GetPaintValueSupported_Invoke_ReturnsTrue(ITypeDescriptorContext context)
-    {
-        ImageEditor editor = new();
-        Assert.True(editor.GetPaintValueSupported(context));
-    }
-
-    [Fact]
-    public void ImageEditor_LoadFromStream_BitmapStream_ReturnsExpected()
-    {
-        SubImageEditor editor = new();
-        using (MemoryStream stream = new MemoryStream())
-        using (Bitmap image = new(10, 10))
-        {
-            image.Save(stream, ImageFormat.Bmp);
-            stream.Position = 0;
-            Bitmap result = Assert.IsType<Bitmap>(editor.LoadFromStream(stream));
-            Assert.Equal(new Size(10, 10), result.Size);
-
-            using MemoryStream resultStream = new();
-            result.Save(resultStream, ImageFormat.Bmp);
-            Assert.Equal(stream.Length, resultStream.Length);
-        }
-    }
-
-    [Fact]
-    public void ImageEditor_LoadFromStream_MetafileStream_ThrowsArgumentException()
-    {
-        SubImageEditor editor = new();
-        using (Stream stream = File.OpenRead("Resources/telescope_01.wmf"))
-        {
-            Assert.Throws<ArgumentException>(() => editor.LoadFromStream(stream));
-        }
-    }
-
-    [Fact]
-    public void ImageEditor_LoadFromStream_NullStream_ThrowsArgumentNullException()
-    {
-        SubImageEditor editor = new();
-        Assert.Throws<ArgumentNullException>("stream", () => editor.LoadFromStream(null));
-    }
-
-    [Fact]
-    public void ImageEditor_PaintValue_Invoke_Success()
-    {
-        ImageEditor editor = new();
-        using (Bitmap image = new(10, 10))
-        using (Bitmap otherImage = new(3, 2))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            otherImage.SetPixel(0, 0, Color.Red);
-            otherImage.SetPixel(1, 0, Color.Red);
-            otherImage.SetPixel(2, 0, Color.Red);
-            otherImage.SetPixel(0, 1, Color.Red);
-            otherImage.SetPixel(1, 1, Color.Red);
-            otherImage.SetPixel(2, 1, Color.Red);
-
-            PaintValueEventArgs e = new(null, otherImage, graphics, new Rectangle(1, 2, 3, 4));
-            editor.PaintValue(e);
-        }
-    }
-
-    public static IEnumerable<object[]> PaintValue_InvalidArgsValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(PaintValue_InvalidArgsValue_TestData))]
-    public void ImageEditor_PaintValue_InvalidArgsValue_Nop(object value)
-    {
-        ImageEditor editor = new();
-        using (Bitmap image = new(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            PaintValueEventArgs e = new(null, value, graphics, new Rectangle(1, 2, 3, 4));
-            editor.PaintValue(e);
-        }
-    }
-
-    [Fact]
-    public void ImageEditor_PaintValue_NullE_Nop()
-    {
-        ImageEditor editor = new();
-        editor.PaintValue(null);
-    }
-
-    private class SubImageEditor : ImageEditor
-    {
-        public static new string CreateExtensionsString(string[] extensions, string sep)
-        {
-            return ImageEditor.CreateExtensionsString(extensions, sep);
-        }
-
-        public static new string CreateFilterEntry(ImageEditor e)
-        {
-            return ImageEditor.CreateFilterEntry(e);
-        }
-
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        public new string GetFileDialogDescription() => base.GetFileDialogDescription();
-
-        public new Type[] GetImageExtenders() => base.GetImageExtenders();
-
-        public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);
-    }
-
-    private class CustomGetImageExtendersEditor : ImageEditor
-    {
-        public int GetImageExtendersCallCount { get; set; }
-
-        public Type[] GetImageExtendersResult { get; set; }
-
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        protected override string GetFileDialogDescription() => "CustomGetImageExtendersEditor";
-
-        protected override Type[] GetImageExtenders()
-        {
-            GetImageExtendersCallCount++;
-            return GetImageExtendersResult;
-        }
-    }
-
-    private class PublicImageEditor : ImageEditor
-    {
-        public PublicImageEditor()
-        {
-        }
-
-        protected override string[] GetExtensions() => new string[] { "PublicImageEditor" };
-    }
-
-    private class PrivateImageEditor : ImageEditor
-    {
-        private PrivateImageEditor()
-        {
-        }
-
-        protected override string[] GetExtensions() => new string[] { "PrivateImageEditor" };
-    }
-
-    private class NullExtensionsImageEditor : ImageEditor
-    {
-        public NullExtensionsImageEditor()
-        {
-        }
-
-        protected override string[] GetExtensions() => null;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/MetafileEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/MetafileEditorTests.cs
deleted file mode 100644
index 3b27a0d62f2..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/MetafileEditorTests.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Imaging;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-public class MetafileEditorTests
-{
-    [Fact]
-    public void MetafileEditor_Ctor_Default()
-    {
-        MetafileEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void MetafileEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        MetafileEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Fact]
-    public void MetafileEditor_GetExtensions_InvokeDefault_ReturnsExpected()
-    {
-        SubMetafileEditor editor = new();
-        string[] extensions = editor.GetExtensions();
-        Assert.Equal(new string[] { "emf", "wmf" }, extensions);
-        Assert.NotSame(extensions, editor.GetExtensions());
-    }
-
-    [Fact]
-    public void MetafileEditor_GetFileDialogDescription_Invoke_ReturnsExpected()
-    {
-        SubMetafileEditor editor = new();
-        Assert.Equal("Metafiles", editor.GetFileDialogDescription());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void MetafileEditor_GetPaintValueSupported_Invoke_ReturnsTrue(ITypeDescriptorContext context)
-    {
-        MetafileEditor editor = new();
-        Assert.True(editor.GetPaintValueSupported(context));
-    }
-
-    [Fact]
-    public void MetafileEditor_LoadFromStream_BitmapStream_ThrowsExternalException()
-    {
-        SubMetafileEditor editor = new();
-        using (MemoryStream stream = new MemoryStream())
-        using (Bitmap image = new(10, 10))
-        {
-            image.Save(stream, ImageFormat.Bmp);
-            stream.Position = 0;
-            Assert.Throws<ExternalException>(() => editor.LoadFromStream(stream));
-        }
-    }
-
-    [Fact]
-    public void MetafileEditor_LoadFromStream_MetafileStream_ReturnsExpected()
-    {
-        SubMetafileEditor editor = new();
-        using (Stream stream = File.OpenRead("Resources/telescope_01.wmf"))
-        {
-            Metafile result = Assert.IsType<Metafile>(editor.LoadFromStream(stream));
-            Assert.Equal(new Size(3096, 4127), result.Size);
-        }
-    }
-
-    [Fact]
-    public void MetafileEditor_LoadFromStream_NullStream_ThrowsArgumentNullException()
-    {
-        SubMetafileEditor editor = new();
-        Assert.Throws<ArgumentNullException>("stream", () => editor.LoadFromStream(null));
-    }
-
-    private class SubMetafileEditor : MetafileEditor
-    {
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        public new string GetFileDialogDescription() => base.GetFileDialogDescription();
-
-        public new Image LoadFromStream(Stream stream) => base.LoadFromStream(stream);
-    }
-
-    private class CustomGetImageExtendersEditor : MetafileEditor
-    {
-        public new string[] GetExtensions() => base.GetExtensions();
-
-        protected override Type[] GetImageExtenders() => new Type[] { typeof(CustomGetExtensionsEditor) };
-    }
-
-    private class CustomGetExtensionsEditor : ImageEditor
-    {
-        protected override string[] GetExtensions() => new string[] { "CustomGetExtensionsEditor" };
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatedEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatedEventArgsTests.cs
deleted file mode 100644
index 4d88a90973a..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatedEventArgsTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Drawing.Design.Tests;
-
-public class ToolboxComponentsCreatedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_IComponentArray_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<IComponent>() };
-        yield return new object[] { new IComponent[] { null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IComponentArray_TestData))]
-    public void Ctor_IComponentArray(IComponent[] components)
-    {
-        ToolboxComponentsCreatedEventArgs e = new(components);
-        if (components is null)
-        {
-            Assert.Null(e.Components);
-        }
-        else
-        {
-            Assert.Equal(components, e.Components);
-            Assert.NotSame(components, e.Components);
-            Assert.Equal(e.Components, e.Components);
-            Assert.NotSame(e.Components, e.Components);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatingEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatingEventArgsTests.cs
deleted file mode 100644
index c58789f3fb6..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxComponentsCreatingEventArgsTests.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using Moq;
-
-namespace System.Drawing.Design.Tests;
-
-public class ToolboxComponentsCreatingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_IDesignerHost_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Mock<IDesignerHost>(MockBehavior.Strict).Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IDesignerHost_TestData))]
-    public void Ctor_IDesignerHost(IDesignerHost host)
-    {
-        ToolboxComponentsCreatingEventArgs e = new(host);
-        Assert.Equal(host, e.DesignerHost);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemCollectionTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemCollectionTests.cs
deleted file mode 100644
index c55d2da638d..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemCollectionTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Drawing.Design.Tests;
-
-public class ToolboxItemCollectionTests
-{
-    [Fact]
-    public void ToolboxItemCollection_Ctor_ToolboxItemArray()
-    {
-        ToolboxItem item = new();
-        ToolboxItemCollection collection = new(new ToolboxItem[] { item });
-        Assert.Same(item, Assert.Single(collection));
-        Assert.Same(item, collection[0]);
-        Assert.True(collection.Contains(item));
-        Assert.Equal(0, collection.IndexOf(item));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_Ctor_NullToolboxItemArray_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("c", () => new ToolboxItemCollection((ToolboxItem[])null));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_Ctor_ToolboxItemCollection()
-    {
-        ToolboxItem item = new();
-        ToolboxItemCollection value = new(new ToolboxItem[] { item });
-        ToolboxItemCollection collection = new(value);
-        Assert.Same(item, Assert.Single(collection));
-        Assert.Same(item, collection[0]);
-        Assert.True(collection.Contains(item));
-        Assert.Equal(0, collection.IndexOf(item));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_Ctor_NullToolboxItemCollection_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("c", () => new ToolboxItemCollection((ToolboxItemCollection)null));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_Contains_NoSuchValue_ReturnsFalse()
-    {
-        ToolboxItem item = new();
-        ToolboxItemCollection collection = new(new ToolboxItem[] { item });
-        Assert.False(collection.Contains(new ToolboxItem { DisplayName = "Other" }));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_IndexOf_NoSuchValue_ReturnsNegativeOne()
-    {
-        ToolboxItem item = new();
-        ToolboxItemCollection collection = new(new ToolboxItem[] { item });
-        Assert.Equal(-1, collection.IndexOf(new ToolboxItem { DisplayName = "Other" }));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void ToolboxItemCollection_CopyTo_Invoke_Success()
-    {
-        ToolboxItem item = new();
-        ToolboxItemCollection collection = new(new ToolboxItem[] { item });
-
-        var array = new ToolboxItem[3];
-        collection.CopyTo(array, 1);
-        Assert.Equal(new ToolboxItem[] { null, item, null }, array);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemTests.cs
deleted file mode 100644
index 6a1464424c9..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Drawing/Design/ToolboxItemTests.cs
+++ /dev/null
@@ -1,1788 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Reflection;
-using System.Runtime.Loader;
-using Moq;
-
-namespace System.Drawing.Design.Tests;
-
-public class ToolboxItemTests
-{
-    [Fact]
-    public void ToolboxItem_Ctor_Default()
-    {
-        ToolboxItem item = new();
-        Assert.Null(item.AssemblyName);
-        Assert.Null(item.Bitmap);
-        Assert.Null(item.Company);
-        Assert.Equal(".NET Component", item.ComponentType);
-        Assert.Null(item.DependentAssemblies);
-        Assert.Null(item.Description);
-        Assert.Empty(item.DisplayName);
-        Assert.Empty(item.Filter);
-        Assert.Same(item.Filter, item.Filter);
-        Assert.False(item.IsTransient);
-        Assert.False(item.Locked);
-        Assert.Null(item.OriginalBitmap);
-        Assert.Empty(item.Properties);
-        Assert.Same(item.Properties, item.Properties);
-        Assert.False(item.Properties.IsFixedSize);
-        Assert.False(item.Properties.IsReadOnly);
-        Assert.Empty(item.TypeName);
-        Assert.Empty(item.Version);
-    }
-
-    public static IEnumerable<object[]> AssemblyName_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AssemblyName() };
-        yield return new object[] { new AssemblyName(typeof(int).Assembly.FullName) };
-    }
-
-    [Theory]
-    [MemberData(nameof(AssemblyName_Set_TestData))]
-    public void ToolboxItem_AssemblyName_Set_GetReturnsExpected(AssemblyName value)
-    {
-        ToolboxItem item = new()
-        {
-            AssemblyName = value
-        };
-        if (value is null)
-        {
-            Assert.Null(item.AssemblyName);
-            Assert.Null(item.Properties["AssemblyName"]);
-            Assert.Empty(item.Version);
-        }
-        else
-        {
-            Assert.Equal(value.FullName, item.AssemblyName.FullName);
-            Assert.NotSame(value, item.AssemblyName);
-            Assert.NotSame(item.AssemblyName, item.AssemblyName);
-            Assert.Equal(value.FullName, ((AssemblyName)item.Properties["AssemblyName"]).FullName);
-            Assert.NotSame(value, item.Properties["AssemblyName"]);
-            Assert.NotSame(item.Properties["AssemblyName"], item.Properties["AssemblyName"]);
-            Assert.Equal(value.Version?.ToString() ?? string.Empty, item.Version);
-        }
-
-        // Set same.
-        item.AssemblyName = value;
-        if (value is null)
-        {
-            Assert.Null(item.AssemblyName);
-            Assert.Null(item.Properties["AssemblyName"]);
-            Assert.Empty(item.Version);
-        }
-        else
-        {
-            Assert.Equal(value.FullName, item.AssemblyName.FullName);
-            Assert.NotSame(value, item.AssemblyName);
-            Assert.NotSame(item.AssemblyName, item.AssemblyName);
-            Assert.Equal(value.FullName, ((AssemblyName)item.Properties["AssemblyName"]).FullName);
-            Assert.NotSame(value, item.Properties["AssemblyName"]);
-            Assert.NotSame(item.Properties["AssemblyName"], item.Properties["AssemblyName"]);
-            Assert.Equal(value.Version?.ToString() ?? string.Empty, item.Version);
-        }
-    }
-
-    [Fact]
-    public void ToolboxItem_AssemblyName_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("AssemblyName", new object()));
-    }
-
-    public static IEnumerable<object[]> Bitmap_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Bitmap_Set_TestData))]
-    public void ToolboxItem_Bitmap_Set_GetReturnsExpected(Bitmap value)
-    {
-        ToolboxItem item = new()
-        {
-            Bitmap = value
-        };
-        Assert.Same(value, item.Bitmap);
-        Assert.Same(value, item.Properties["Bitmap"]);
-
-        // Set same.
-        item.Bitmap = value;
-        Assert.Same(value, item.Bitmap);
-        Assert.Same(value, item.Properties["Bitmap"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_Bitmap_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Bitmap", new object()));
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ToolboxItem_Company_Set_GetReturnsExpected(string value, string expected)
-    {
-        ToolboxItem item = new()
-        {
-            Company = value
-        };
-        Assert.Equal(expected, item.Company);
-        Assert.Equal(expected, item.Properties["Company"]);
-
-        // Set same.
-        item.Company = value;
-        Assert.Equal(expected, item.Company);
-        Assert.Equal(expected, item.Properties["Company"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_Company_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Company", new object()));
-    }
-
-    public static IEnumerable<object[]> DependentAssemblies_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<AssemblyName>() };
-        yield return new object[] { new AssemblyName[] { null } };
-        yield return new object[] { new AssemblyName[] { new AssemblyName() } };
-    }
-
-    [Theory]
-    [MemberData(nameof(DependentAssemblies_Set_TestData))]
-    public void ToolboxItem_DependentAssemblies_Set_GetReturnsExpected(AssemblyName[] value)
-    {
-        ToolboxItem item = new()
-        {
-            DependentAssemblies = value
-        };
-        if (value is null)
-        {
-            Assert.Null(item.DependentAssemblies);
-            Assert.Null(item.Properties["DependentAssemblies"]);
-        }
-        else
-        {
-            Assert.Equal(value, item.DependentAssemblies);
-            Assert.NotSame(value, item.DependentAssemblies);
-            Assert.Equal(value, item.Properties["DependentAssemblies"]);
-            Assert.NotSame(value, item.Properties["DependentAssemblies"]);
-        }
-
-        // Set same.
-        item.DependentAssemblies = value;
-        if (value is null)
-        {
-            Assert.Null(item.DependentAssemblies);
-            Assert.Null(item.Properties["DependentAssemblies"]);
-        }
-        else
-        {
-            Assert.Equal(value, item.DependentAssemblies);
-            Assert.NotSame(value, item.DependentAssemblies);
-            Assert.Equal(value, item.Properties["DependentAssemblies"]);
-            Assert.NotSame(value, item.Properties["DependentAssemblies"]);
-        }
-    }
-
-    [Fact]
-    public void ToolboxItem_DependentAssemblies_SetWithInvalidPropertyType_GetThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("DependentAssemblies", new object()));
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ToolboxItem_Description_Set_GetReturnsExpected(string value, string expected)
-    {
-        ToolboxItem item = new()
-        {
-            Description = value
-        };
-        Assert.Equal(expected, item.Description);
-        Assert.Equal(expected, item.Properties["Description"]);
-
-        // Set same.
-        item.Description = value;
-        Assert.Equal(expected, item.Description);
-        Assert.Equal(expected, item.Properties["Description"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_Description_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Description", new object()));
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ToolboxItem_DisplayName_Set_GetReturnsExpected(string value, string expected)
-    {
-        ToolboxItem item = new()
-        {
-            DisplayName = value
-        };
-        Assert.Equal(expected, item.DisplayName);
-        Assert.Equal(expected, item.Properties["DisplayName"]);
-
-        // Set same.
-        item.DisplayName = value;
-        Assert.Equal(expected, item.DisplayName);
-        Assert.Equal(expected, item.Properties["DisplayName"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_DisplayName_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("DisplayName", new object()));
-    }
-
-    public static IEnumerable<object[]> Filter_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<object>() };
-        yield return new object[] { Array.Empty<object>(), Array.Empty<object>() };
-        yield return new object[] { new object[] { null }, Array.Empty<object>() };
-        yield return new object[] { new object[] { new object(), new ToolboxItemFilterAttribute("filterString") }, new object[] { new ToolboxItemFilterAttribute("filterString") } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Filter_Set_TestData))]
-    public void ToolboxItem_Filter_Set_GetReturnsExpected(ICollection value, ICollection expected)
-    {
-        ToolboxItem item = new()
-        {
-            Filter = value
-        };
-        Assert.Equal(expected, item.Filter);
-        Assert.Equal(expected, item.Properties["Filter"]);
-
-        // Set same.
-        item.Filter = value;
-        Assert.Equal(expected, item.Filter);
-        Assert.Equal(expected, item.Properties["Filter"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_Filter_SetWithInvalidPropertyType_GetThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Filter", new object()));
-    }
-
-    [Theory]
-    [BoolData]
-    public void ToolboxItem_IsTransient_Set_GetReturnsExpected(bool value)
-    {
-        ToolboxItem item = new()
-        {
-            IsTransient = value
-        };
-        Assert.Equal(value, item.IsTransient);
-        Assert.Equal(value, item.Properties["IsTransient"]);
-
-        // Set same.
-        item.IsTransient = value;
-        Assert.Equal(value, item.IsTransient);
-        Assert.Equal(value, item.Properties["IsTransient"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_IsTransient_SetWithNullPropertyType_GetThrowsArgumentNullException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentNullException>("value", () => item.Properties.Add("IsTransient", null));
-    }
-
-    [Fact]
-    public void ToolboxItem_IsTransient_SetWithInvalidPropertyType_GetThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("IsTransient", new object()));
-    }
-
-    [Theory]
-    [MemberData(nameof(Bitmap_Set_TestData))]
-    public void ToolboxItem_OriginalBitmap_Set_GetReturnsExpected(Bitmap value)
-    {
-        ToolboxItem item = new()
-        {
-            OriginalBitmap = value
-        };
-        Assert.Same(value, item.OriginalBitmap);
-        Assert.Same(value, item.Properties["OriginalBitmap"]);
-
-        // Set same.
-        item.OriginalBitmap = value;
-        Assert.Same(value, item.OriginalBitmap);
-        Assert.Same(value, item.Properties["OriginalBitmap"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_OriginalBitmap_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("OriginalBitmap", new object()));
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ToolboxItem_TypeName_Set_GetReturnsExpected(string value, string expected)
-    {
-        ToolboxItem item = new()
-        {
-            TypeName = value
-        };
-        Assert.Equal(expected, item.TypeName);
-        Assert.Equal(expected, item.Properties["TypeName"]);
-
-        // Set same.
-        item.TypeName = value;
-        Assert.Equal(expected, item.TypeName);
-        Assert.Equal(expected, item.Properties["TypeName"]);
-    }
-
-    [Fact]
-    public void ToolboxItem_TypeName_SetWithInvalidPropertyType_ThrowsArgumentException()
-    {
-        ToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("TypeName", new object()));
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponents_InvokeWithoutHost_ReturnsExpected()
-    {
-        ToolboxItem item = new()
-        {
-            AssemblyName = typeof(Component).Assembly.GetName(true),
-            TypeName = "System.ComponentModel.Component"
-        };
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.IsType<Component>(Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.IsType<Component>(Assert.Single(item.CreateComponents()));
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        Assert.IsType<Component>(Assert.Single(item.CreateComponents(null)));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(2, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.IsType<Component>(Assert.Single(item.CreateComponents(null)));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData()
-    {
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner.Setup(d => d.Dispose());
-
-        yield return new object[] { new Component(), null };
-        yield return new object[] { new Component(), mockDesigner.Object };
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, mockDesigner.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData))]
-    public void ToolboxItem_CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_ReturnsExpected(Component component, IDesigner designer)
-    {
-        ToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(designer);
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, null)));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(2, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, new Hashtable())));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(3, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(3, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponents_InvokeWithHostWithIComponentInitializerDesigner_ReturnsExpected()
-    {
-        using Component component = new();
-        ToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner.Setup(d => d.Dispose());
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(null));
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(new Hashtable()));
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(mockDesigner.Object);
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, null)));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(2, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, new Hashtable())));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(3, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(3, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponents_InvokeWithHostWithThrowingIComponentInitializerDesigner_ReturnsExpected()
-    {
-        using Component component = new();
-        ToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner.Setup(d => d.Dispose());
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(null))
-            .Throws(new Exception());
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(new Hashtable()))
-            .Throws(new Exception());
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(mockDesigner.Object);
-        mockDesignerHost
-            .Setup(h => h.DestroyComponent(component));
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Throws<Exception>(() => item.CreateComponents(mockDesignerHost.Object));
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Throws<Exception>(() => item.CreateComponents(mockDesignerHost.Object, null));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Throws<Exception>(() => item.CreateComponents(mockDesignerHost.Object, new Hashtable()));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Throws<Exception>(() => item.CreateComponents(mockDesignerHost.Object));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponents_InvokeWithNullComponentsCoreWithHost_ReturnsExpected()
-    {
-        NullComponentsToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(new Component());
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.Components);
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Null(item.CreateComponents(mockDesignerHost.Object));
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Null(item.CreateComponents(mockDesignerHost.Object, null));
-        Assert.Equal(2, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Null(item.CreateComponents(mockDesignerHost.Object, new Hashtable()));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Null(item.CreateComponents(mockDesignerHost.Object));
-        Assert.Equal(3, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("NoSuchType")]
-    [InlineData("System.Int32")]
-    public void ToolboxItem_CreateComponents_InvokeInvalidType_ReturnsEmpty(string typeName)
-    {
-        ToolboxItem item = new()
-        {
-            TypeName = typeName
-        };
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.Components);
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        Assert.Empty(item.CreateComponents());
-        Assert.Equal(1, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponentsCore_InvokeWithoutHost_ReturnsExpected()
-    {
-        SubToolboxItem item = new()
-        {
-            AssemblyName = typeof(Component).Assembly.GetName(true),
-            TypeName = "System.ComponentModel.Component"
-        };
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.IsType<Component>(Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.IsType<Component>(Assert.Single(item.CreateComponentsCore(null)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.IsType<Component>(Assert.Single(item.CreateComponentsCore(null)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData))]
-    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithNonIComponentInitializerDesigner_ReturnsExpected(Component component, IDesigner designer)
-    {
-        SubToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(designer);
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, null)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable())));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithIComponentInitializerDesigner_ReturnsExpected()
-    {
-        using Component component = new();
-        SubToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner.Setup(d => d.Dispose());
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(null));
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(new Hashtable()));
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(mockDesigner.Object);
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, null)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable())));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithThrowingIComponentInitializerDesigner_ReturnsExpected()
-    {
-        using Component component = new();
-        SubToolboxItem item = new()
-        {
-            TypeName = "typeName"
-        };
-        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
-        mockDesigner.Setup(d => d.Dispose());
-        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(null))
-            .Throws(new Exception());
-        mockComponentInitializer
-            .Setup(i => i.InitializeNewComponent(new Hashtable()))
-            .Throws(new Exception());
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new CustomTypeResolutionService());
-        mockDesignerHost
-            .Setup(h => h.CreateComponent(typeof(bool)))
-            .Returns(component);
-        mockDesignerHost
-            .Setup(h => h.GetDesigner(component))
-            .Returns(mockDesigner.Object);
-        mockDesignerHost
-            .Setup(h => h.DestroyComponent(component));
-
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(component, Assert.Single(e.Components));
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        // With handler.
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Throws<Exception>(() => item.CreateComponentsCore(mockDesignerHost.Object, null));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.Throws<Exception>(() => item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable()));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ComponentsCreating -= creatingHandler;
-        item.ComponentsCreated -= createdHandler;
-
-        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("NoSuchType")]
-    [InlineData("System.Int32")]
-    public void ToolboxItem_CreateComponentsCore_InvokeInvalidType_ReturnsEmpty(string typeName)
-    {
-        SubToolboxItem item = new()
-        {
-            TypeName = typeName
-        };
-        int creatingCallCount = 0;
-        int createdCallCount = 0;
-        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.DesignerHost);
-            creatingCallCount++;
-        };
-        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Null(e.Components);
-            createdCallCount++;
-        };
-        item.ComponentsCreating += creatingHandler;
-        item.ComponentsCreated += createdHandler;
-
-        Assert.Empty(item.CreateComponentsCore(null));
-        Assert.Equal(0, creatingCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_CheckUnlocked_NotLocked_Nop()
-    {
-        SubToolboxItem item = new();
-        item.CheckUnlocked();
-        item.CheckUnlocked();
-    }
-
-    [Fact]
-    public void ToolboxItem_CheckUnlocked_Locked_ThrowsInvalidOperationException()
-    {
-        SubToolboxItem item = new();
-        item.Lock();
-        Assert.Throws<InvalidOperationException>(() => item.CheckUnlocked());
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        ToolboxItem item = new();
-        yield return new object[] { item, item, true };
-        yield return new object[] { item, new ToolboxItem(), true };
-        yield return new object[] { item, new SubToolboxItem(), false };
-
-        yield return new object[]
-        {
-            item,
-            new ToolboxItem
-            {
-                Company = "Company",
-                DependentAssemblies = new AssemblyName[] { null },
-                Description = "Description",
-                Filter = new ToolboxItemFilterAttribute[] { new ToolboxItemFilterAttribute("Filter") },
-                IsTransient = true
-            },
-            true
-        };
-
-        yield return new object[]
-        {
-            new ToolboxItem { TypeName = "TypeName" },
-            new ToolboxItem { TypeName = "TypeName" },
-            true
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { TypeName = "TypeName" },
-            new ToolboxItem { TypeName = "typename" },
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { TypeName = "TypeName" },
-            new ToolboxItem(),
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem(),
-            new ToolboxItem { TypeName = "TypeName" },
-            false
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { TypeName = null },
-            new NoValidationToolboxItem { TypeName = null },
-            true
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { TypeName = null },
-            new NoValidationToolboxItem { TypeName = "TypeName" },
-            false
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { TypeName = "TypeName" },
-            new NoValidationToolboxItem { TypeName = null },
-            false
-        };
-
-        yield return new object[]
-        {
-            new ToolboxItem { DisplayName = "DisplayName" },
-            new ToolboxItem { DisplayName = "DisplayName" },
-            true
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { DisplayName = "DisplayName" },
-            new ToolboxItem { DisplayName = "displayname" },
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { DisplayName = "DisplayName" },
-            new ToolboxItem(),
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem(),
-            new ToolboxItem { DisplayName = "DisplayName" },
-            false
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { DisplayName = null },
-            new NoValidationToolboxItem { DisplayName = null },
-            true
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { DisplayName = null },
-            new NoValidationToolboxItem { DisplayName = "TypeName" },
-            false
-        };
-        yield return new object[]
-        {
-            new NoValidationToolboxItem { DisplayName = "TypeName" },
-            new NoValidationToolboxItem { DisplayName = null },
-            false
-        };
-
-        yield return new object[]
-        {
-            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
-            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
-            true
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
-            new ToolboxItem { AssemblyName = new AssemblyName("name") },
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem(),
-            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
-            false
-        };
-        yield return new object[]
-        {
-            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
-            new ToolboxItem(),
-            false
-        };
-
-        yield return new object[] { new ToolboxItem(), new object(), false };
-        yield return new object[] { new ToolboxItem(), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void ToolboxItem_Equals_Invoke_ReturnsExpected(ToolboxItem item, object other, bool expected)
-    {
-        Assert.Equal(expected, item.Equals(other));
-    }
-
-    public static IEnumerable<object[]> FilterPropertyValue_TestData()
-    {
-        object o = new();
-        yield return new object[] { "AssemblyName", null, null, true };
-        yield return new object[] { "AssemblyName", new AssemblyName("Name"), new AssemblyName("Name"), false };
-        yield return new object[] { "AssemblyName", o, o, true };
-        yield return new object[] { "assemblyName", new AssemblyName("Name"), new AssemblyName("Name"), true };
-
-        yield return new object[] { "DisplayName", null, string.Empty, false };
-        yield return new object[] { "DisplayName", "value", "value", true };
-        yield return new object[] { "DisplayName", o, o, true };
-        yield return new object[] { "displayname", null, null, true };
-
-        yield return new object[] { "TypeName", null, string.Empty, false };
-        yield return new object[] { "TypeName", "value", "value", true };
-        yield return new object[] { "TypeName", o, o, true };
-        yield return new object[] { "typename", null, null, true };
-
-        yield return new object[] { "Filter", null, Array.Empty<ToolboxItemFilterAttribute>(), false };
-        yield return new object[] { "Filter", Array.Empty<ToolboxItemFilterAttribute>(), Array.Empty<ToolboxItemFilterAttribute>(), true };
-        yield return new object[] { "Filter", o, o, true };
-        yield return new object[] { "filter", null, null, true };
-
-        yield return new object[] { "IsTransient", null, false, false };
-        yield return new object[] { "IsTransient", true, true, true };
-        yield return new object[] { "IsTransient", o, o, true };
-        yield return new object[] { "istransient", null, null, true };
-
-        yield return new object[] { "NoSuchProperty", null, null, true };
-        yield return new object[] { "NoSuchProperty", "value", "value", true };
-        yield return new object[] { "NoSuchProperty", o, o, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(FilterPropertyValue_TestData))]
-    public void ToolboxItem_FilterPropertyValue_Invoke_ReturnsExpected(string propertyName, object value, object expected, bool same)
-    {
-        SubToolboxItem item = new();
-        object actual = item.FilterPropertyValue(propertyName, value);
-        if (expected is AssemblyName expectedName)
-        {
-            Assert.Equal(expectedName.FullName, Assert.IsType<AssemblyName>(actual).FullName);
-        }
-        else
-        {
-            Assert.Equal(expected, actual);
-        }
-
-        Assert.Equal(same, object.ReferenceEquals(value, actual));
-    }
-
-    public static IEnumerable<object[]> GetHashCode_TestData()
-    {
-        yield return new object[] { new ToolboxItem() };
-        yield return new object[] { new ToolboxItem { TypeName = "TypeName", DisplayName = "DisplayName" } };
-        yield return new object[] { new NoValidationToolboxItem { TypeName = null, DisplayName = null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetHashCode_TestData))]
-    public void ToolboxItem_GetHashCode_Invoke_ReturnsExpected(ToolboxItem item)
-    {
-        Assert.Equal(item.GetHashCode(), item.GetHashCode());
-    }
-
-    public static IEnumerable<object[]> GetType_TestData()
-    {
-        Mock<IDesignerHost> nullServiceDesignerHost = new(MockBehavior.Strict);
-        nullServiceDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        foreach (object host in new object[] { null, nullServiceDesignerHost.Object })
-        {
-            yield return new object[] { null, null, "System.Int32", false, typeof(int) };
-            yield return new object[] { null, new AssemblyName("NoSuchAssembly"), "System.Int32", false, typeof(int) };
-            yield return new object[] { null, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", false, typeof(int) };
-            yield return new object[] { null, new AssemblyName(typeof(ToolboxItem).Assembly.FullName), "System.Int32", false, typeof(int) };
-            yield return new object[] { null, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", false, null };
-            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", false, typeof(ToolboxItemTests) };
-            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "System.Drawing.Design.Tests.toolboxitemtests", false, null };
-            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "NoSuchType", false, null };
-            yield return new object[] { null, null, string.Empty, false, null };
-
-#pragma warning disable SYSLIB0044 // Type or member is obsolete
-            AssemblyName validNameWithCodeBase = new(typeof(int).Assembly.FullName)
-            {
-                CodeBase = "System.Windows.Forms.Design.Tests.dll"
-            };
-            yield return new object[] { null, validNameWithCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, null };
-
-            AssemblyName invalidNameWithCodeBase = new("NoSuchAssembly")
-            {
-                CodeBase = "System.Windows.Forms.Design.Tests.dll"
-            };
-            yield return new object[] { null, invalidNameWithCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, typeof(ToolboxItemTests) };
-
-            AssemblyName invalidNameWithInvalidCodeBase = new("NoSuchAssembly")
-            {
-                CodeBase = "AlsoNoSuchAssembly"
-            };
-            yield return new object[] { null, invalidNameWithInvalidCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, null };
-
-            AssemblyLoadContext.Default.Resolving += (context, name) =>
-            {
-                if (name.Name == "ThrowBadImageFormatException")
-                {
-                    throw new BadImageFormatException();
-                }
-                else if (name.Name == "ThrowIOException")
-                {
-                    throw new IOException();
-                }
-
-                return null;
-            };
-            yield return new object[] { null, new AssemblyName("ThrowBadImageFormatException"), "System.Int32", false, typeof(int) };
-            yield return new object[] { null, new AssemblyName("ThrowIOException"), "System.Int32", false, typeof(int) };
-
-            AssemblyName badImageFormatExceptionCodeBase = new("NoSuchAssembly")
-            {
-                CodeBase = "ThrowBadImageFormatException"
-            };
-            yield return new object[] { null, badImageFormatExceptionCodeBase, "System.Int32", false, typeof(int) };
-
-            AssemblyName ioFormatExceptionCodeBase = new("NoSuchAssembly")
-            {
-                CodeBase = "ThrowIOException"
-            };
-#pragma warning restore SYSLIB0044 // Type or member is obsolete
-            yield return new object[] { null, ioFormatExceptionCodeBase, "System.Int32", false, typeof(int) };
-        }
-
-        Mock<IDesignerHost> invalidServiceDesignerHost = new(MockBehavior.Strict);
-        invalidServiceDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(new object());
-        yield return new object[] { invalidServiceDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", false, typeof(int) };
-
-        foreach (bool reference in new bool[] { true, false })
-        {
-            Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-            mockDesignerHost
-                .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-                .Returns(new CustomTypeResolutionService());
-            yield return new object[] { mockDesignerHost.Object, null, "typeName", reference, typeof(bool) };
-            yield return new object[] { mockDesignerHost.Object, null, string.Empty, false, null };
-            yield return new object[] { mockDesignerHost.Object, new AssemblyName(), "typeName", reference, typeof(bool) };
-            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", reference, typeof(int) };
-            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", reference, typeof(ToolboxItemTests) };
-            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.toolboxitemtests", reference, null };
-            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "NoSuchType", reference, null };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_TestData))]
-    public void ToolboxItem_GetType_InvokeWithoutTypeNameAssemblyName_ReturnsExpected(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference, Type expected)
-    {
-        if (reference)
-        {
-            return;
-        }
-
-        ToolboxItem item = new()
-        {
-            AssemblyName = assemblyName,
-            TypeName = typeName
-        };
-        Assert.Equal(expected, item.GetType(host));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetType_TestData))]
-    public void ToolboxItem_GetType_InvokeWithTypeNameAssemblyName_ReturnsExpected(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference, Type expected)
-    {
-        SubToolboxItem item = new();
-        Assert.Equal(expected, item.GetType(host, assemblyName, typeName, reference));
-    }
-
-    [Fact]
-    public void ToolboxItem_GetType_NullTypeName_ThrowsArgumentNullException()
-    {
-        SubToolboxItem item = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        Assert.Throws<ArgumentNullException>("typeName", () => item.GetType(mockDesignerHost.Object, null, null, false));
-        Assert.Throws<ArgumentNullException>("typeName", () => item.GetType(null, null, null, false));
-    }
-
-    [Fact]
-    public void ToolboxItem_GetType_EmptyAssemblyName_ThrowsArgumentException()
-    {
-        SubToolboxItem item = new();
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
-            .Returns(null);
-        Assert.Throws<ArgumentException>(() => item.GetType(mockDesignerHost.Object, new AssemblyName(), "typeName", false));
-        Assert.Throws<ArgumentException>(() => item.GetType(null, new AssemblyName(), "typeName", false));
-    }
-
-    public static IEnumerable<object[]> Initialize_TypeWithAttributes_TestData()
-    {
-        yield return new object[] { typeof(ClassWithValidAttributes), new Size(16, 16) };
-        yield return new object[] { typeof(ClassWithStretchedWidthImage), new Size(24, 16) };
-        yield return new object[] { typeof(ClassWithStretchedHeightImage), new Size(16, 24) };
-        yield return new object[] { typeof(ClassWithInvalidImage), new Size(16, 16) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Initialize_TypeWithAttributes_TestData))]
-    public void ToolboxItem_Initialize_TypeWithAttributes_Success(Type type, Size expectedOriginalBitmapSize)
-    {
-        using Bitmap bitmap = new(10, 10);
-        using Bitmap originalBitmap = new(10, 10);
-
-        var filter = new ToolboxItemFilterAttribute[] { new ToolboxItemFilterAttribute("Filter") };
-        ToolboxItem item = new()
-        {
-            AssemblyName = new AssemblyName("AssemblyName"),
-            Bitmap = bitmap,
-            Company = "Company",
-            Description = "Description",
-            DependentAssemblies = new AssemblyName[2],
-            DisplayName = "DisplayName",
-            Filter = filter,
-            OriginalBitmap = originalBitmap
-        };
-        item.Initialize(type);
-        if (expectedOriginalBitmapSize == new Size(10, 10))
-        {
-            Assert.NotEqual(bitmap, item.Bitmap);
-            Assert.Same(item.Bitmap, item.Bitmap);
-        }
-        else
-        {
-            Assert.Equal(new Size(16, 16), item.Bitmap.Size);
-        }
-
-        Assert.Equal("Microsoft Corporation", item.Company);
-        Assert.Equal("Description", item.Description);
-        Assert.Equal(type.Assembly.FullName, item.AssemblyName.FullName);
-        Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
-        Assert.Equal(type.Name, item.DisplayName);
-        Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f));
-        Assert.Equal(expectedOriginalBitmapSize, item.OriginalBitmap.Size);
-
-        Assert.Equal("Microsoft Corporation", item.Company);
-        Assert.Equal("Description", item.Description);
-        Assert.Equal(type.Assembly.FullName, item.AssemblyName.FullName);
-        Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
-        Assert.Equal(type.Name, item.DisplayName);
-        Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f));
-        Assert.Equal(expectedOriginalBitmapSize, item.OriginalBitmap.Size);
-    }
-
-    [Fact]
-    public void ToolboxItem_Initialize_ObjectType_Success()
-    {
-        using (Bitmap bitmap = new(10, 10))
-        using (Bitmap originalBitmap = new(10, 10))
-        {
-            var filter = new ToolboxItemFilterAttribute[] { new ToolboxItemFilterAttribute("Filter") };
-            ToolboxItem item = new()
-            {
-                AssemblyName = new AssemblyName("AssemblyName"),
-                Bitmap = bitmap,
-                Company = "Company",
-                Description = "Description",
-                DependentAssemblies = new AssemblyName[2],
-                DisplayName = "DisplayName",
-                Filter = filter,
-                OriginalBitmap = originalBitmap
-            };
-            item.Initialize(typeof(object));
-            Assert.NotEqual(bitmap, item.Bitmap);
-            Assert.Same(item.Bitmap, item.Bitmap);
-            Assert.Equal("Microsoft Corporation", item.Company);
-            Assert.Empty(item.Description);
-            Assert.Equal(typeof(object).Assembly.FullName, item.AssemblyName.FullName);
-            Assert.Equal(new string[] { typeof(object).Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
-            Assert.Equal("Object", item.DisplayName);
-            Assert.Equal(new string[] { "System.Object" }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString));
-            Assert.Same(item.OriginalBitmap, item.OriginalBitmap);
-        }
-    }
-
-    [Fact]
-    public void ToolboxItem_Initialize_NullType_Nop()
-    {
-        using (Bitmap bitmap = new(10, 10))
-        using (Bitmap originalBitmap = new(10, 10))
-        {
-            var filter = new ToolboxItemFilterAttribute[] { new ToolboxItemFilterAttribute("Filter") };
-            ToolboxItem item = new()
-            {
-                AssemblyName = new AssemblyName("AssemblyName"),
-                Bitmap = bitmap,
-                Company = "Company",
-                Description = "Description",
-                DependentAssemblies = new AssemblyName[2],
-                DisplayName = "DisplayName",
-                Filter = filter,
-                OriginalBitmap = originalBitmap
-            };
-            item.Initialize(null);
-            Assert.Equal("AssemblyName", item.AssemblyName.FullName);
-            Assert.Same(bitmap, item.Bitmap);
-            Assert.Equal("Company", item.Company);
-            Assert.Equal("Description", item.Description);
-            Assert.Equal(new AssemblyName[2], item.DependentAssemblies);
-            Assert.Equal("DisplayName", item.DisplayName);
-            Assert.Equal(filter, item.Filter);
-            Assert.Same(originalBitmap, item.OriginalBitmap);
-        }
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    public void ToolboxItem_Initialize_Locked_ThrowsInvalidOperationException(Type type)
-    {
-        ToolboxItem item = new();
-        item.Lock();
-        Assert.Throws<InvalidOperationException>(() => item.Initialize(type));
-    }
-
-    [Fact]
-    public void ToolboxItem_Lock_Invoke_Success()
-    {
-        ToolboxItem item = new();
-        item.Lock();
-        Assert.True(item.Locked);
-        Assert.True(item.Properties.IsFixedSize);
-        Assert.True(item.Properties.IsReadOnly);
-
-        // Lock again.
-        item.Lock();
-        Assert.True(item.Locked);
-        Assert.True(item.Properties.IsFixedSize);
-        Assert.True(item.Properties.IsReadOnly);
-    }
-
-    [Fact]
-    public void ToolboxItem_OnComponentsCreated_Invoke_Success()
-    {
-        SubToolboxItem item = new();
-
-        // No handler.
-        item.OnComponentsCreated(null);
-
-        // Handler.
-        int callCount = 0;
-        ToolboxComponentsCreatedEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(item, sender);
-            Assert.Null(e);
-            callCount++;
-        };
-
-        item.ComponentsCreated += handler;
-        item.OnComponentsCreated(null);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        item.ComponentsCreated -= handler;
-        item.OnComponentsCreated(null);
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void ToolboxItem_OnComponentsCreating_Invoke_Success()
-    {
-        SubToolboxItem item = new();
-
-        // No handler.
-        item.OnComponentsCreating(null);
-
-        // Handler.
-        int callCount = 0;
-        ToolboxComponentsCreatingEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(item, sender);
-            Assert.Null(e);
-            callCount++;
-        };
-
-        item.ComponentsCreating += handler;
-        item.OnComponentsCreating(null);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        item.ComponentsCreating -= handler;
-        item.OnComponentsCreating(null);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new ToolboxItem(), string.Empty };
-        yield return new object[] { new ToolboxItem { DisplayName = "DisplayName" }, "DisplayName" };
-        yield return new object[] { new NoValidationToolboxItem { DisplayName = null }, string.Empty };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void ToolboxItem_ToString_Invoke_ReturnsExpected(ToolboxItem item, string expected)
-    {
-        Assert.Equal(expected, item.ToString());
-    }
-
-    public static IEnumerable<object[]> ValidatePropertyValue_TestData()
-    {
-        AssemblyName name = new();
-        yield return new object[] { "AssemblyName", null, null };
-        yield return new object[] { "AssemblyName", name, name };
-
-        Bitmap bitmap = new(10, 10);
-        yield return new object[] { "Bitmap", null, null };
-        yield return new object[] { "Bitmap", bitmap, bitmap };
-
-        Bitmap originalBitmap = new(10, 10);
-        yield return new object[] { "OriginalBitmap", null, null };
-        yield return new object[] { "OriginalBitmap", originalBitmap, originalBitmap };
-
-        yield return new object[] { "Company", null, string.Empty };
-        yield return new object[] { "Company", "value", "value" };
-
-        yield return new object[] { "Description", null, string.Empty };
-        yield return new object[] { "Description", "value", "value" };
-
-        yield return new object[] { "DisplayName", null, string.Empty };
-        yield return new object[] { "DisplayName", "value", "value" };
-
-        yield return new object[] { "TypeName", null, string.Empty };
-        yield return new object[] { "TypeName", "value", "value" };
-
-        ToolboxItemFilterAttribute filter = new("filter");
-        yield return new object[] { "Filter", null, Array.Empty<ToolboxItemFilterAttribute>() };
-        yield return new object[] { "Filter", Array.Empty<ToolboxItemFilterAttribute>(), Array.Empty<ToolboxItemFilterAttribute>() };
-        yield return new object[] { "Filter", new object[] { null, "value", filter, filter }, new ToolboxItemFilterAttribute[] { filter, filter } };
-
-        yield return new object[] { "NoSuchProperty", null, null };
-        yield return new object[] { "NoSuchProperty", 1, 1 };
-
-        yield return new object[] { "istransient", null, null };
-        yield return new object[] { "istransient", 1, 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(ValidatePropertyValue_TestData))]
-    public void ToolboxItem_ValidatePropertyValue_ValueAllowed_ReturnsExpected(string propertyName, object value, object expected)
-    {
-        SubToolboxItem item = new();
-        Assert.Equal(expected, item.ValidatePropertyValue(propertyName, value));
-    }
-
-    [Theory]
-    [InlineData("IsTransient")]
-    public void ToolboxItem_ValidatePropertyValue_NullValueDisallowed_ThrowsArgumentNullException(string propertyName)
-    {
-        SubToolboxItem item = new();
-        Assert.Throws<ArgumentNullException>("value", () => item.ValidatePropertyValue(propertyName, null));
-    }
-
-    [Theory]
-    [InlineData("AssemblyName")]
-    [InlineData("Bitmap")]
-    [InlineData("OriginalBitmap")]
-    [InlineData("Company")]
-    [InlineData("Description")]
-    [InlineData("DisplayName")]
-    [InlineData("TypeName")]
-    [InlineData("Filter")]
-    [InlineData("DependentAssemblies")]
-    public void ToolboxItem_ValidatePropertyValue_InvalidValue_ThrowsArgumentException(string propertyName)
-    {
-        SubToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.ValidatePropertyValue(propertyName, new object()));
-    }
-
-    [Theory]
-    [InlineData(null, null)]
-    [InlineData("propertyName", typeof(int))]
-    public void ToolboxItem_ValidatePropertyType_NullDisallowed_ThrowsArgumentNullException(string propertyName, Type expectedType)
-    {
-        SubToolboxItem item = new();
-        Assert.Throws<ArgumentNullException>("value", () => item.ValidatePropertyType(propertyName, null, expectedType, allowNull: false));
-    }
-
-    [Theory]
-    [InlineData(null, null)]
-    [InlineData("propertyName", typeof(int))]
-    public void ToolboxItem_ValidatePropertyType_NullAllowed_Nop(string propertyName, Type expectedType)
-    {
-        SubToolboxItem item = new();
-        item.ValidatePropertyType(propertyName, null, expectedType, allowNull: true);
-    }
-
-    [Theory]
-    [InlineData(null, false)]
-    [InlineData("propertyName", true)]
-    public void ToolboxItem_ValidatePropertyType_ValidType_Nop(string propertyName, bool allowNull)
-    {
-        SubToolboxItem item = new();
-        item.ValidatePropertyType(propertyName, 1, typeof(int), allowNull);
-    }
-
-    [Theory]
-    [InlineData(null, false)]
-    [InlineData("propertyName", true)]
-    public void ToolboxItem_ValidatePropertyType_InvalidType_ThrowsArgumentException(string propertyName, bool allowNull)
-    {
-        SubToolboxItem item = new();
-        Assert.Throws<ArgumentException>("value", () => item.ValidatePropertyType(propertyName, new object(), typeof(int), allowNull));
-    }
-
-    private class SubToolboxItem : ToolboxItem
-    {
-        public new void CheckUnlocked() => base.CheckUnlocked();
-
-        public new IComponent[] CreateComponentsCore(IDesignerHost host)
-        {
-            return base.CreateComponentsCore(host);
-        }
-
-        public new IComponent[] CreateComponentsCore(IDesignerHost host, IDictionary defaultValues)
-        {
-            return base.CreateComponentsCore(host, defaultValues);
-        }
-
-        public new object FilterPropertyValue(string propertyName, object value)
-        {
-            return base.FilterPropertyValue(propertyName, value);
-        }
-
-        public new Type GetType(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference)
-        {
-            return base.GetType(host, assemblyName, typeName, reference);
-        }
-
-        public new void OnComponentsCreated(ToolboxComponentsCreatedEventArgs args)
-        {
-            base.OnComponentsCreated(args);
-        }
-
-        public new void OnComponentsCreating(ToolboxComponentsCreatingEventArgs args)
-        {
-            base.OnComponentsCreating(args);
-        }
-
-        public new object ValidatePropertyValue(string propertyName, object value)
-        {
-            return base.ValidatePropertyValue(propertyName, value);
-        }
-
-        public new void ValidatePropertyType(string propertyName, object value, Type expectedType, bool allowNull)
-        {
-            base.ValidatePropertyType(propertyName, value, expectedType, allowNull);
-        }
-    }
-
-    private class CustomTypeResolutionService : ITypeResolutionService
-    {
-        public Assembly GetAssemblyResult { get; set; }
-
-        public Assembly GetAssembly(AssemblyName name) => GetAssemblyResult;
-
-        public Assembly GetAssembly(AssemblyName name, bool throwOnError)
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetPathOfAssembly(AssemblyName name)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Type GetType(string name)
-        {
-            if (name == "typeName")
-            {
-                return typeof(bool);
-            }
-
-            return Type.GetType(name);
-        }
-
-        public Type GetType(string name, bool throwOnError)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Type GetType(string name, bool throwOnError, bool ignoreCase)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<AssemblyName> ReferenceAssemblies { get; } = new List<AssemblyName>();
-
-        public void ReferenceAssembly(AssemblyName name)
-        {
-            ReferenceAssemblies.Add(name);
-        }
-    }
-
-    private class NoValidationToolboxItem : ToolboxItem
-    {
-        protected override object FilterPropertyValue(string propertyName, object value)
-        {
-            // Don't normalize.
-            return value;
-        }
-
-        protected override object ValidatePropertyValue(string propertyName, object value)
-        {
-            // Don't normalize.
-            return value;
-        }
-    }
-
-    private class NullComponentsToolboxItem : ToolboxItem
-    {
-        protected override IComponent[] CreateComponentsCore(IDesignerHost host)
-        {
-            return null;
-        }
-    }
-
-    [Description("Description")]
-    [ToolboxBitmap(typeof(ToolboxItemTests), "16x16.bmp")]
-    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithValidAttributes")]
-    [ToolboxItemFilter("ClassWithValidAttributes")]
-    [ToolboxItemFilter("Filter")]
-    private class ClassWithValidAttributes
-    {
-    }
-
-    [Description("Description")]
-    [ToolboxBitmap(typeof(ToolboxItemTests), "24x16.bmp")]
-    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithStretchedWidthImage")]
-    [ToolboxItemFilter("ClassWithStretchedWidthImage")]
-    [ToolboxItemFilter("Filter")]
-    private class ClassWithStretchedWidthImage
-    {
-    }
-
-    [Description("Description")]
-    [ToolboxBitmap(typeof(ToolboxItemTests), "16x24.bmp")]
-    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithStretchedHeightImage")]
-    [ToolboxItemFilter("ClassWithStretchedHeightImage")]
-    [ToolboxItemFilter("Filter")]
-    private class ClassWithStretchedHeightImage
-    {
-    }
-
-    [Description("Description")]
-    [ToolboxBitmap("NoSuchImage")]
-    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithInvalidImage")]
-    [ToolboxItemFilter("ClassWithInvalidImage")]
-    [ToolboxItemFilter("Filter")]
-    private class ClassWithInvalidImage
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/CodeDomCompileHelper.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/CodeDomCompileHelper.cs
deleted file mode 100644
index 9e2cbc50096..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/CodeDomCompileHelper.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom.Compiler;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CSharp;
-using System.CodeDom;
-using System.Runtime.Loader;
-using System.Reflection;
-using System.Drawing;
-
-namespace System.Resources.Tools.Tests;
-
-internal static class CodeDomCompileHelper
-{
-    private static readonly CodeDomProvider s_cSharpProvider = new CSharpCodeProvider();
-
-    private static MetadataReference[] References { get; } = CreateReferences();
-
-    private static MetadataReference[] CreateReferences()
-    {
-        string corelibPath = typeof(object).Assembly.Location;
-        return new[]
-        {
-            MetadataReference.CreateFromFile(corelibPath),
-            MetadataReference.CreateFromFile(Path.Join(Path.GetDirectoryName(corelibPath), "System.Runtime.dll")),
-            MetadataReference.CreateFromFile(typeof(Bitmap).Assembly.Location),
-        };
-    }
-
-    private static Stream CreateAssemblyImage(string source, string assemblyName, string resourceName, Stream resource)
-    {
-        CSharpCompilation compilation = CSharpCompilation.Create(
-            assemblyName,
-            new[] { CSharpSyntaxTree.ParseText(source) },
-            References,
-            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-
-        ResourceDescription[] description = resource is null
-            ? null
-            : new ResourceDescription[] { new(resourceName, () => resource, isPublic: true) };
-
-        MemoryStream stream = new();
-        var result = compilation.Emit(stream, manifestResources: description);
-        if (result.Success)
-        {
-            stream.Position = 0;
-            return stream;
-        }
-        else
-        {
-            throw new InvalidOperationException(string.Join('\n', result.Diagnostics.Select(d => d.GetMessage())));
-        }
-    }
-
-    internal static Type CompileClass(
-        CodeCompileUnit compileUnit,
-        string baseName,
-        string nameSpace = null,
-        Stream resource = null)
-    {
-        AssemblyLoadContext context = new(name: null, isCollectible: true);
-        string fullName = nameSpace is null ? baseName : $"{nameSpace}.{baseName}";
-
-        using StringWriter writer = new();
-        s_cSharpProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new());
-        Assembly assembly = context.LoadFromStream(CreateAssemblyImage(
-            writer.ToString(),
-            fullName,
-            $"{fullName}.resources",
-            resource));
-        Type type = assembly.GetType(fullName, throwOnError: true);
-
-        // Once all references are collected, the assembly will unload.
-        context.Unload();
-        return type;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/StronglyTypedResourceBuilderTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/StronglyTypedResourceBuilderTests.cs
deleted file mode 100644
index 431e4f4a964..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Resources/Tools/StronglyTypedResourceBuilderTests.cs
+++ /dev/null
@@ -1,715 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CodeDom;
-using System.CodeDom.Compiler;
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Reflection;
-using System.Text;
-using System.Windows.Forms.TestUtilities;
-using AxWMPLib;
-using Microsoft.CSharp;
-
-namespace System.Resources.Tools.Tests;
-
-public partial class StronglyTypedResourceBuilderTests
-{
-    // https://docs.microsoft.com/dotnet/core/extensions/work-with-resx-files-programmatically
-
-    private static readonly CodeDomProvider s_cSharpProvider = new CSharpCodeProvider();
-    private const string TypeAssembly = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
-    private const string TxtFileEncoding = "Windows-1252";
-
-    [Fact]
-    public void StronglyTypedResourceBuilder_Create_NullBaseName_ThrowsArgumentNull()
-    {
-        Hashtable resources = new();
-        Assert.Throws<ArgumentNullException>(
-            "baseName",
-            () => StronglyTypedResourceBuilder.Create(
-                resources,
-                baseName: null,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "baseName",
-            () => StronglyTypedResourceBuilder.Create(
-                resources,
-                baseName: null,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx());
-        Assert.Throws<ArgumentNullException>(
-            "baseName",
-            () => StronglyTypedResourceBuilder.Create(
-                temp.Path,
-                baseName: null,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "baseName",
-            () => StronglyTypedResourceBuilder.Create(
-                temp.Path,
-                baseName: null,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-    }
-
-    [Fact]
-    public void StronglyTypedResourceBuilder_Create_NullCodeProvider_ThrowsArgumentNull()
-    {
-        Hashtable resources = new();
-        Assert.Throws<ArgumentNullException>(
-            "codeProvider",
-            () => StronglyTypedResourceBuilder.Create(
-                resources,
-                string.Empty,
-                string.Empty,
-                codeProvider: null,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "codeProvider",
-            () => StronglyTypedResourceBuilder.Create(
-                resources,
-                string.Empty,
-                string.Empty,
-                string.Empty,
-                codeProvider: null,
-                internalClass: false,
-                out _));
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx());
-        Assert.Throws<ArgumentNullException>(
-            "codeProvider",
-            () => StronglyTypedResourceBuilder.Create(
-                temp.Path,
-                string.Empty,
-                string.Empty,
-                codeProvider: null,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "codeProvider",
-            () => StronglyTypedResourceBuilder.Create(
-                temp.Path,
-                string.Empty,
-                string.Empty,
-                string.Empty,
-                codeProvider: null,
-                internalClass: false,
-                out _));
-    }
-
-    [Fact]
-    public void StronglyTypedResourceBuilder_Create_NullResourceList_ThrowsArgumentNull()
-    {
-        Hashtable resources = new();
-        Assert.Throws<ArgumentNullException>(
-            "resourceList",
-            () => StronglyTypedResourceBuilder.Create(
-                resourceList: null,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "resourceList",
-            () => StronglyTypedResourceBuilder.Create(
-                resourceList: null,
-                string.Empty,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-    }
-
-    [Fact]
-    public void StronglyTypedResourceBuilder_Create_NullResxFile_ThrowsArgumentNull()
-    {
-        Assert.Throws<ArgumentNullException>(
-            "resxFile",
-            () => StronglyTypedResourceBuilder.Create(
-                resxFile: null,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-
-        Assert.Throws<ArgumentNullException>(
-            "resxFile",
-            () => StronglyTypedResourceBuilder.Create(
-                resxFile: null,
-                string.Empty,
-                string.Empty,
-                string.Empty,
-                s_cSharpProvider,
-                internalClass: false,
-                out _));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_MismatchedResxDataNode_Throws()
-    {
-        Hashtable values = new()
-        {
-            { "TestName", new ResXDataNode("WrongName", "TestValue") }
-        };
-
-        Assert.Throws<ArgumentException>(() => StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_EmptyResx()
-    {
-        using var temp = TempFile.Create(ResxHelper.CreateResx());
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: null,
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        Type type = CodeDomCompileHelper.CompileClass(compileUnit, "Resources");
-        Assert.NotNull(type);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_StringResource_FromFile()
-    {
-        const string data = """
-            <data name="TestName" xml:space="preserve">
-              <value>TestValue</value>
-            </data>
-            """;
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx(data));
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resourceStream = new();
-        using ResourceWriter resourceWriter = new(resourceStream);
-        resourceWriter.AddResource("TestName", "TestValue");
-        resourceWriter.Generate();
-        resourceStream.Position = 0;
-
-        Type type = CodeDomCompileHelper.CompileClass(compileUnit, "Resources", "Namespace", resourceStream);
-        Assert.NotNull(type);
-        var nameProperty = type.GetProperty("TestName");
-        Assert.NotNull(nameProperty);
-        Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_StringResource_FromResxWriterFile()
-    {
-        using var temp = TempFile.Create();
-        using (ResXResourceWriter writer = new(temp.Path))
-        {
-            writer.AddResource("TestName", "TestValue");
-            writer.Generate();
-        }
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resourceStream = new();
-        using ResourceWriter resourceWriter = new(resourceStream);
-        resourceWriter.AddResource("TestName", "TestValue");
-        resourceWriter.Generate();
-        resourceStream.Position = 0;
-
-        Type type = CodeDomCompileHelper.CompileClass(compileUnit, "Resources", "Namespace", resourceStream);
-        Assert.NotNull(type);
-        var nameProperty = type.GetProperty("TestName");
-        Assert.NotNull(nameProperty);
-        Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_StringResource_FromResxDataNode()
-    {
-        Hashtable values = new()
-        {
-            { "TestName", new ResXDataNode("TestName", "TestValue") }
-        };
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resourceStream = new();
-        using ResourceWriter resourceWriter = new(resourceStream);
-        resourceWriter.AddResource("TestName", "TestValue");
-        resourceWriter.Generate();
-        resourceStream.Position = 0;
-
-        Type type = CodeDomCompileHelper.CompileClass(compileUnit, "Resources", "Namespace", resourceStream);
-        Assert.NotNull(type);
-        var nameProperty = type.GetProperty("TestName");
-        Assert.NotNull(nameProperty);
-        Assert.Equal("TestValue", (string)nameProperty.GetValue(obj: null));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_BitmapResource_FromFile()
-    {
-        const string data = $"""
-            <data name="Image1" type="System.Resources.ResXFileRef, System.Windows.Forms">
-                <value>Resources\Image1.png;System.Byte[], {TypeAssembly}</value>
-            </data>
-            """;
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx(data));
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        var imagePropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Image1");
-        using Bitmap expected = (Bitmap)Image.FromFile(@"Resources\Image1.png");
-        ValidateResultBitmap(imagePropertyInfo, expected, TypeDescriptor.GetConverter(typeof(Bitmap)));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_BitmapResource_FromMemory()
-    {
-        using Bitmap bitmap = new(10, 10);
-        bitmap.SetPixel(0, 0, Color.Red);
-        var converter = TypeDescriptor.GetConverter(bitmap);
-
-        ResXDataNode node = new("Image1", converter.ConvertTo(bitmap, typeof(byte[])));
-        using var temp = TempFile.Create();
-        using (ResXResourceWriter resxWriter = new(temp.Path))
-        {
-            resxWriter.AddResource(node);
-            resxWriter.Generate();
-        }
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        var imagePropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Image1");
-        ValidateResultBitmap(imagePropertyInfo, bitmap, converter);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_BitmapResource_FromFileRef()
-    {
-        ResXFileRef fileRef = new(@"Resources\Image1.png", $"System.Byte[], {TypeAssembly}");
-        Hashtable values = new()
-        {
-            { "Image1", new ResXDataNode("Image1", fileRef) }
-        };
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resxStream = new();
-        using ResXResourceWriter resxWriter = new(resxStream);
-        resxWriter.AddResource(new ResXDataNode("Image1", fileRef));
-        resxWriter.Generate();
-        resxStream.Position = 0;
-        using ResXResourceReader reader = new(resxStream);
-        var imagePropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Image1");
-        using Bitmap expected = (Bitmap)Image.FromFile(@"Resources\Image1.png");
-        ValidateResultBitmap(imagePropertyInfo, expected, TypeDescriptor.GetConverter(typeof(Bitmap)));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_IconResource_FromFile()
-    {
-        const string data = $"""
-            <data name="Icon1" type="System.Resources.ResXFileRef, System.Windows.Forms">
-              <value>Resources\Icon1.ico;System.Byte[], {TypeAssembly}</value>
-            </data>
-            """;
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx(data));
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        var iconPropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Icon1");
-        using Icon expected = new(@"Resources\Icon1.ico");
-        ValidateResultIcon(iconPropertyInfo, expected, TypeDescriptor.GetConverter(typeof(Icon)));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_IconResource_FromMemory()
-    {
-        using Icon icon = new(SystemIcons.Exclamation, 16, 16);
-        var converter = TypeDescriptor.GetConverter(icon);
-
-        ResXDataNode node = new("Icon1", converter.ConvertTo(icon, typeof(byte[])));
-        using var temp = TempFile.Create();
-        using (ResXResourceWriter resxWriter = new(temp.Path))
-        {
-            resxWriter.AddResource(node);
-            resxWriter.Generate();
-        }
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        var iconPropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Icon1");
-        ValidateResultIcon(iconPropertyInfo, icon, converter);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_IconResource_FromFileRef()
-    {
-        ResXFileRef fileRef = new(@"Resources\Icon1.ico", $"System.Byte[], {TypeAssembly}");
-        Hashtable values = new()
-        {
-            { "Icon1", new ResXDataNode("Icon1", fileRef) }
-        };
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resxStream = new();
-        using ResXResourceWriter resxWriter = new(resxStream);
-        resxWriter.AddResource(new ResXDataNode("Icon1", fileRef));
-        resxWriter.Generate();
-        resxStream.Position = 0;
-        using ResXResourceReader reader = new(resxStream);
-        var iconPropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Icon1");
-        using Icon expected = new(@"Resources\Icon1.ico");
-        ValidateResultIcon(iconPropertyInfo, expected, TypeDescriptor.GetConverter(typeof(Icon)));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_TxtFileResource_FromFile()
-    {
-        const string data = $"""
-            <data name="TextFile1" type="System.Resources.ResXFileRef, System.Windows.Forms">
-              <value>Resources\TextFile1.txt;System.String, {TypeAssembly};{TxtFileEncoding}</value>
-            </data>
-            """;
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx(data));
-        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        ValidateResultTxtFileContent(CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "TextFile1"));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_TxtFileResource_FromFileRef()
-    {
-        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-        ResXFileRef fileRef = new(
-            @"Resources\TextFile1.txt",
-            $"System.String, {TypeAssembly}",
-            Encoding.GetEncoding(TxtFileEncoding));
-        Hashtable values = new()
-        {
-            { "TextFile1", new ResXDataNode("TextFile1", fileRef) }
-        };
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resxStream = new();
-        using ResXResourceWriter resxWriter = new(resxStream);
-        resxWriter.AddResource(new ResXDataNode("TextFile1", fileRef));
-        resxWriter.Generate();
-        resxStream.Position = 0;
-        using ResXResourceReader reader = new(resxStream);
-        ValidateResultTxtFileContent(CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "TextFile1"));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_AudioResource_FromFile()
-    {
-        const string data = $"""
-            <data name="Audio1" type="System.Resources.ResXFileRef, System.Windows.Forms">
-              <value>Resources\Audio1.wav;System.IO.MemoryStream, {TypeAssembly}</value>
-            </data>
-            """;
-
-        using var temp = TempFile.Create(ResxHelper.CreateResx(data));
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        ValidateResultAudio(CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Audio1"));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_Create_AudioResource_FromFileRef()
-    {
-        ResXFileRef fileRef = new(@"Resources\Audio1.wav", $"System.IO.MemoryStream, {TypeAssembly}");
-        Hashtable values = new()
-        {
-            { "Audio1", new ResXDataNode("Audio1", fileRef) }
-        };
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resourceList: values,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using MemoryStream resxStream = new();
-        using ResXResourceWriter resxWriter = new(resxStream);
-        resxWriter.AddResource(new ResXDataNode("Audio1", fileRef));
-        resxWriter.Generate();
-        resxStream.Position = 0;
-        using ResXResourceReader reader = new(resxStream);
-        ValidateResultAudio(CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "Audio1"));
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_VerifyResourceName_ValidName()
-    {
-        string key = "MyResource";
-        string result = StronglyTypedResourceBuilder.VerifyResourceName(key, s_cSharpProvider);
-        Assert.Equal(key, result);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_VerifyResourceName_InvalidName()
-    {
-        string key = "Invalid Resource?";
-        string result = StronglyTypedResourceBuilder.VerifyResourceName(key, s_cSharpProvider);
-        Assert.Equal("Invalid_Resource_", result);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_VerifyResourceName_NameWithSpaces()
-    {
-        string key = "Resource Name";
-        string result = StronglyTypedResourceBuilder.VerifyResourceName(key, s_cSharpProvider);
-        Assert.Equal("Resource_Name", result);
-    }
-
-    [Fact]
-    public static void StronglyTypedResourceBuilder_VerifyResourceName_NameStartWithNumber()
-    {
-        string key = "1.name";
-        string result = StronglyTypedResourceBuilder.VerifyResourceName(key, s_cSharpProvider);
-        Assert.Equal("_1_name", result);
-    }
-
-    [Theory]
-    [MemberData(nameof(ResourceName_TestData))]
-    public static void StronglyTypedResourceBuilder_VerifyResourceName_NameWithSpecialCharacters(string resourceName, string expectedResult)
-    {
-        string result = StronglyTypedResourceBuilder.VerifyResourceName(resourceName, s_cSharpProvider);
-        Assert.Equal(expectedResult, result);
-    }
-
-    [WinFormsFact]
-    public static void StronglyTypedResourceBuilder_Create_AxHost_FromMemory_SerializeWith_StateConverter()
-    {
-        // AxHost.StateConverter is not properly registered as a converter for AxHost.State.
-        // Temporarily register StateConverter as State's converter and test serialization.
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(AxHost.State));
-        Assert.Equal(typeof(TypeConverter), converter.GetType());
-        using var scope = CustomConverter.RegisterConverter(typeof(AxHost.State), new AxHost.StateConverter());
-        converter = TypeDescriptor.GetConverter(typeof(AxHost.State));
-        Assert.Equal(typeof(AxHost.StateConverter), converter.GetType());
-
-        using Form form = new();
-        using AxWindowsMediaPlayer mediaPlayer = new();
-        ((ISupportInitialize)mediaPlayer).BeginInit();
-        form.Controls.Add(mediaPlayer);
-        ((ISupportInitialize)mediaPlayer).EndInit();
-
-        string expectedUrl = $"{Path.GetTempPath()}testurl1";
-        mediaPlayer.URL = expectedUrl;
-
-        ResXDataNode node = new("MediaPlayer1", converter.ConvertTo(mediaPlayer.OcxState, typeof(byte[])));
-        using var temp = TempFile.Create();
-        using (ResXResourceWriter resxWriter = new(temp.Path))
-        {
-            resxWriter.AddResource(node);
-            resxWriter.Generate();
-        }
-
-        var compileUnit = StronglyTypedResourceBuilder.Create(
-            resxFile: temp.Path,
-            baseName: "Resources",
-            generatedCodeNamespace: "Namespace",
-            s_cSharpProvider,
-            internalClass: false,
-            out _);
-
-        using ResXResourceReader reader = new(temp.Path);
-        var mediaPlayerPropertyInfo = CompileAndGetPropertyInfo(reader.GetEnumerator(), compileUnit, "MediaPlayer1");
-        byte[] resourceByte = Assert.IsType<byte[]>(mediaPlayerPropertyInfo.GetValue(obj: null));
-        AxHost.State state = Assert.IsType<AxHost.State>(converter.ConvertFrom(resourceByte));
-
-        string changedUrl = $"{Path.GetTempPath()}testurl2";
-        mediaPlayer.URL = changedUrl;
-        Assert.Equal(changedUrl, mediaPlayer.URL);
-
-        mediaPlayer.OcxState = state;
-        Assert.Equal(expectedUrl, mediaPlayer.URL);
-    }
-
-    // Utilizes ResourceWriter to save the resources and gets the specified
-    // PropertyInfo.
-    private static PropertyInfo CompileAndGetPropertyInfo(
-        IDictionaryEnumerator resources,
-        CodeCompileUnit compileUnit,
-        string propertyName)
-    {
-        using MemoryStream resourceStream = new();
-        using ResourceWriter resourceWriter = new(resourceStream);
-        while (resources.MoveNext())
-        {
-            resourceWriter.AddResource((string)resources.Key, resources.Value);
-        }
-
-        resourceWriter.Generate();
-        resourceStream.Position = 0;
-
-        Type type = CodeDomCompileHelper.CompileClass(compileUnit, "Resources", "Namespace", resourceStream);
-        Assert.NotNull(type);
-        var propertyInfo = type.GetProperty(propertyName);
-        Assert.NotNull(propertyInfo);
-        return propertyInfo;
-    }
-
-    private static void ValidateResultBitmap(PropertyInfo imagePropertyInfo, Bitmap expected, TypeConverter converter)
-    {
-        byte[] resourceBytes = Assert.IsType<byte[]>(imagePropertyInfo.GetValue(obj: null));
-        using Bitmap resourceBitmap = Assert.IsType<Bitmap>(converter.ConvertFrom(resourceBytes));
-        Assert.Equal(expected.Size, resourceBitmap.Size);
-        Assert.Equal(expected.GetPixel(0, 0), resourceBitmap.GetPixel(0, 0));
-    }
-
-    private static void ValidateResultIcon(PropertyInfo iconPropertyInfo, Icon expected, TypeConverter converter)
-    {
-        byte[] resourceByte = Assert.IsType<byte[]>(iconPropertyInfo.GetValue(obj: null));
-        using Icon resourceIcon = Assert.IsType<Icon>(converter.ConvertFrom(resourceByte));
-        Assert.Equal(expected.Size, resourceIcon.Size);
-    }
-
-    private static void ValidateResultTxtFileContent(PropertyInfo txtFilePropertyInfo)
-    {
-        string resourceTxtFileContents = Assert.IsType<string>(txtFilePropertyInfo.GetValue(obj: null));
-        Assert.Equal("hello test\r\n!", resourceTxtFileContents);
-    }
-
-    private static void ValidateResultAudio(PropertyInfo audioPropertyInfo)
-    {
-        using UnmanagedMemoryStream resourceAudio =
-            Assert.IsType<UnmanagedMemoryStream>(audioPropertyInfo.GetValue(obj: null));
-        var contents = new byte[resourceAudio.Length];
-        int pos = (int)(resourceAudio.Position = 0);
-        while (pos < resourceAudio.Length)
-        {
-            pos += resourceAudio.Read(contents, pos, (int)(resourceAudio.Length - pos));
-        }
-
-        Assert.Equal("HELLO", Encoding.UTF8.GetString(contents));
-    }
-
-    public static IEnumerable<object[]> ResourceName_TestData()
-    {
-        yield return new object[] { "Image#Jpeg", "Image_Jpeg" };
-        yield return new object[] { "Generate &method", "Generate__method" };
-        yield return new object[] { "'%s' in this scope", "__s__in_this_scope" };
-        yield return new object[] { "{ ... }", "_______" };
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/AnchorEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/AnchorEditorTests.cs
deleted file mode 100644
index 9939f1057c6..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/AnchorEditorTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using System.Reflection;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class AnchorEditorTests
-{
-    [Fact]
-    public void AnchorEditor_Ctor_Default()
-    {
-        AnchorEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { AnchorStyles.Top };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void AnchorEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        AnchorEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void AnchorEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        AnchorEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void AnchorEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        AnchorEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void AnchorEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        AnchorEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    [Theory]
-    [InlineData("left")]
-    [InlineData("right")]
-    [InlineData("top")]
-    [InlineData("bottom")]
-    public void AnchorEditor_AnchorUI_ControlType_IsCheckButton(string fieldName)
-    {
-        AnchorEditor editor = new();
-        Type type = editor.GetType()
-            .GetNestedType("AnchorUI", BindingFlags.NonPublic | BindingFlags.Instance);
-        var anchorUI = (Control)Activator.CreateInstance(type, new object[] { editor });
-        var item = (Control)anchorUI.GetType()
-            .GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance).GetValue(anchorUI);
-
-        object actual = item.AccessibilityObject.TestAccessor().Dynamic
-            .GetPropertyValue(Interop.UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(Interop.UiaCore.UIA.CheckBoxControlTypeId, actual);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/BehaviorDragDropEventArgsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/BehaviorDragDropEventArgsTests.cs
deleted file mode 100644
index 7f0732ab4ac..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/BehaviorDragDropEventArgsTests.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Design.Behavior.Tests;
-
-public class BehaviorDragDropEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ICollection_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<object>() };
-        yield return new object[] { new object[] { null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ICollection_TestData))]
-    public void Ctor_ICollection(ICollection components)
-    {
-        BehaviorDragDropEventArgs e = new(components);
-        Assert.Same(components, e.DragComponents);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/SnapLineTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/SnapLineTests.cs
deleted file mode 100644
index ba8e02577fa..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/Behavior/SnapLineTests.cs
+++ /dev/null
@@ -1,239 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Behavior.Tests;
-
-public class SnapLineTests
-{
-    private static string[] s_Margins = new[] { SnapLine.MarginLeft, SnapLine.MarginTop, SnapLine.MarginRight, SnapLine.MarginBottom };
-    private static string[] s_Paddings = new[] { SnapLine.PaddingLeft, SnapLine.PaddingTop, SnapLine.PaddingRight, SnapLine.PaddingBottom };
-
-    private const int DefaultOffset = 123;
-    private const string DefaultFilter = "filter";
-    private const SnapLinePriority DefaultPriority = SnapLinePriority.Medium;
-
-    [Fact]
-    public void SnapLine_Ctor_type_offset()
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, DefaultOffset);
-
-        Assert.Equal(SnapLineType.Baseline, snapLine.SnapLineType);
-        Assert.Equal(DefaultOffset, snapLine.Offset);
-        Assert.Null(snapLine.Filter);
-        Assert.Equal(SnapLinePriority.Low, snapLine.Priority);
-    }
-
-    [Fact]
-    public void SnapLine_Ctor_type_offset_filter()
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, DefaultOffset, DefaultFilter);
-
-        Assert.Equal(SnapLineType.Baseline, snapLine.SnapLineType);
-        Assert.Equal(DefaultOffset, snapLine.Offset);
-        Assert.Equal(DefaultFilter, snapLine.Filter);
-        Assert.Equal(SnapLinePriority.Low, snapLine.Priority);
-    }
-
-    [Fact]
-    public void SnapLine_Ctor_type_offset_priority()
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, DefaultOffset, DefaultPriority);
-
-        Assert.Equal(SnapLineType.Baseline, snapLine.SnapLineType);
-        Assert.Equal(DefaultOffset, snapLine.Offset);
-        Assert.Null(snapLine.Filter);
-        Assert.Equal(DefaultPriority, snapLine.Priority);
-    }
-
-    [Fact]
-    public void SnapLine_Ctor_type_offset_filter_priority()
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, DefaultOffset, DefaultFilter, DefaultPriority);
-
-        Assert.Equal(SnapLineType.Baseline, snapLine.SnapLineType);
-        Assert.Equal(DefaultOffset, snapLine.Offset);
-        Assert.Equal(DefaultFilter, snapLine.Filter);
-        Assert.Equal(DefaultPriority, snapLine.Priority);
-    }
-
-    [Theory]
-    [InlineData(SnapLineType.Top, true)]
-    [InlineData(SnapLineType.Bottom, true)]
-    [InlineData(SnapLineType.Horizontal, true)]
-    [InlineData(SnapLineType.Baseline, true)]
-    [InlineData(SnapLineType.Left, false)]
-    [InlineData(SnapLineType.Right, false)]
-    [InlineData(SnapLineType.Vertical, false)]
-    public void SnapLine_IsHorizontal(SnapLineType type, bool expected)
-    {
-        SnapLine snapLine = new(type, DefaultOffset, DefaultFilter, DefaultPriority);
-
-        Assert.Equal(expected, snapLine.IsHorizontal);
-    }
-
-    [Theory]
-    [InlineData(SnapLineType.Top, false)]
-    [InlineData(SnapLineType.Bottom, false)]
-    [InlineData(SnapLineType.Horizontal, false)]
-    [InlineData(SnapLineType.Baseline, false)]
-    [InlineData(SnapLineType.Left, true)]
-    [InlineData(SnapLineType.Right, true)]
-    [InlineData(SnapLineType.Vertical, true)]
-    public void SnapLine_IsVertical(SnapLineType type, bool expected)
-    {
-        SnapLine snapLine = new(type, DefaultOffset, DefaultFilter, DefaultPriority);
-
-        Assert.Equal(expected, snapLine.IsVertical);
-    }
-
-    public static IEnumerable<object[]> SnapLineType_Set_TestData()
-    {
-        foreach (var type in Enum.GetValues(typeof(SnapLineType)))
-        {
-            yield return new[] { type };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SnapLineType_Set_TestData))]
-    public void SnapLine_ensure_IsHorizontal_IsVertical_do_not_overlap(SnapLineType type)
-    {
-        SnapLine snapLine = new(type, DefaultOffset, DefaultFilter, DefaultPriority);
-
-        Assert.NotEqual(snapLine.IsHorizontal, snapLine.IsVertical);
-    }
-
-    [Theory]
-    [InlineData(DefaultOffset, 10, DefaultOffset + 10)]
-    [InlineData(DefaultOffset, -10, DefaultOffset - 10)]
-    [InlineData(DefaultOffset, int.MaxValue, /* overflown */-2147483526)]
-    [InlineData(-DefaultOffset, int.MinValue, /* overflown */2147483525)]
-    public void SnapLine_AdjustOffset(int offset, int adjustment, int expected)
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, offset, DefaultFilter, DefaultPriority);
-
-        snapLine.AdjustOffset(adjustment);
-        Assert.Equal(expected, snapLine.Offset);
-    }
-
-    [Fact]
-    public void SnapLine_ShouldSnap_should_return_false_if_types_differ()
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, DefaultFilter, DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Baseline, DefaultOffset, DefaultFilter, DefaultPriority);
-
-        Assert.False(SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    [Fact]
-    public void SnapLine_ShouldSnap_should_return_true_if_types_equal_and_both_filters_null()
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, null, DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, null, SnapLinePriority.Low);
-
-        Assert.True(SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    [Fact]
-    public void SnapLine_ShouldSnap_should_return_false_if_types_equal_and_one_of_filters_not_null()
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, null, DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, DefaultFilter, SnapLinePriority.Low);
-
-        Assert.False(SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    public static IEnumerable<object[]> SnapLineFilter_Margin_TestData()
-    {
-        return EnumerateFilterMarginPaths(SnapLine.MarginRight, SnapLine.MarginLeft, SnapLine.PaddingRight)
-            .Union(EnumerateFilterMarginPaths(SnapLine.MarginLeft, SnapLine.MarginRight, SnapLine.PaddingLeft))
-            .Union(EnumerateFilterMarginPaths(SnapLine.MarginTop, SnapLine.MarginBottom, SnapLine.PaddingTop))
-            .Union(EnumerateFilterMarginPaths(SnapLine.MarginBottom, SnapLine.MarginTop, SnapLine.PaddingBottom));
-
-        static IEnumerable<object[]> EnumerateFilterMarginPaths(string snapLine1Filter, string snapLine2MarginFilter, string snapLine2PaddingFilter)
-        {
-            // happy paths
-            yield return new object[] { snapLine1Filter, snapLine2MarginFilter, true };
-            yield return new object[] { snapLine1Filter, snapLine2PaddingFilter, true };
-
-            // unhappy paths
-            foreach (var margin in s_Margins.Except(new[] { snapLine2MarginFilter }))
-            {
-                yield return new object[] { snapLine1Filter, margin, false };
-            }
-
-            foreach (var margin in s_Paddings.Except(new[] { snapLine2PaddingFilter }))
-            {
-                yield return new object[] { snapLine1Filter, margin, false };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SnapLineFilter_Margin_TestData))]
-    public void SnapLine_ShouldSnap_should_return_expected_if_types_equal_and_filter_contains_margin(string snapLine1Filter, string snapLine2Filter, bool expected)
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, snapLine1Filter, DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, snapLine2Filter, SnapLinePriority.Low);
-
-        Assert.Equal(expected, SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    public static IEnumerable<object[]> SnapLineFilter_Padding_TestData()
-    {
-        return EnumerateFilterPaddingPaths(SnapLine.PaddingLeft, SnapLine.MarginLeft)
-            .Union(EnumerateFilterPaddingPaths(SnapLine.PaddingRight, SnapLine.MarginRight))
-            .Union(EnumerateFilterPaddingPaths(SnapLine.PaddingTop, SnapLine.MarginTop))
-            .Union(EnumerateFilterPaddingPaths(SnapLine.PaddingBottom, SnapLine.MarginBottom));
-
-        static IEnumerable<object[]> EnumerateFilterPaddingPaths(string snapLine1Filter, string snapLine2Filter)
-        {
-            // happy paths
-            yield return new object[] { snapLine1Filter, snapLine2Filter, true };
-
-            // unhappy paths
-            foreach (var margin in s_Margins.Except(new[] { snapLine2Filter }))
-            {
-                yield return new object[] { snapLine1Filter, margin, false };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SnapLineFilter_Padding_TestData))]
-    public void SnapLine_ShouldSnap_should_return_expected_if_types_equal_and_filter_contains_padding(string snapLine1Filter, string snapLine2Filter, bool expected)
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, snapLine1Filter, DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, snapLine2Filter, SnapLinePriority.Low);
-
-        Assert.Equal(expected, SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    [Fact]
-    public void SnapLine_ShouldSnap_should_return_true_if_types_equal_and_filters_match()
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, "custom filter", DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, "custom filter", SnapLinePriority.Low);
-
-        Assert.True(SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    [Fact]
-    public void SnapLine_ShouldSnap_should_return_false_if_types_equal_and_filters_not_match()
-    {
-        SnapLine snapLine1 = new(SnapLineType.Top, DefaultOffset, "custom filter", DefaultPriority);
-        SnapLine snapLine2 = new(SnapLineType.Top, DefaultOffset, "another filter", SnapLinePriority.Low);
-
-        Assert.False(SnapLine.ShouldSnap(snapLine1, snapLine2));
-    }
-
-    [Theory]
-    [InlineData(null, "SnapLine: {type = Baseline, offset = 123, priority = Medium, filter = <null>}")]
-    [InlineData(DefaultFilter, "SnapLine: {type = Baseline, offset = 123, priority = Medium, filter = filter}")]
-    public void SnapLine_ToString(string filter, string expected)
-    {
-        SnapLine snapLine = new(SnapLineType.Baseline, DefaultOffset, filter, DefaultPriority);
-
-        Assert.Equal(expected, snapLine.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/BorderSidesEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/BorderSidesEditorTests.cs
deleted file mode 100644
index 42579768c40..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/BorderSidesEditorTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class BorderSidesEditorTests
-{
-    [Fact]
-    public void BorderSidesEditor_Ctor_Default()
-    {
-        BorderSidesEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { ToolStripStatusLabelBorderSides.Top };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void BorderSidesEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        BorderSidesEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void BorderSidesEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        BorderSidesEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void BorderSidesEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        BorderSidesEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void BorderSidesEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        BorderSidesEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ColumnHeaderCollectionEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ColumnHeaderCollectionEditorTests.cs
deleted file mode 100644
index a84da13d0ab..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ColumnHeaderCollectionEditorTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ColumnHeaderCollectionEditorTests
-{
-    [Fact]
-    public void ColumnHeaderCollectionEditor_Ctor_Default()
-    {
-        ColumnHeaderCollectionEditor editor = new(typeof(string));
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Fact]
-    public void ColumnHeaderCollectionEditor_EditValue_ReturnsValue()
-    {
-        ColumnHeaderCollectionEditor editor = new(typeof(string));
-        string[] value = new string[] { "asdf", "qwer", "zxcv" };
-
-        Assert.Same(value, editor.EditValue(null, value));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ContentAlignmentEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ContentAlignmentEditorTests.cs
deleted file mode 100644
index 0010ebdc11f..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ContentAlignmentEditorTests.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Design;
-using System.Reflection;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ContentAlignmentEditorTests
-{
-    [Theory]
-    [InlineData("_topLeft")]
-    [InlineData("_topCenter")]
-    [InlineData("_topRight")]
-    [InlineData("_middleLeft")]
-    [InlineData("_middleCenter")]
-    [InlineData("_middleRight")]
-    [InlineData("_bottomLeft")]
-    [InlineData("_bottomCenter")]
-    [InlineData("_bottomRight")]
-    public void ContentAlignmentEditor_ContentAlignmentEditor_ContentUI_IsRadioButton(string fieldName)
-    {
-        ContentAlignmentEditor editor = new();
-        Type type = editor.GetType()
-            .GetNestedType("ContentUI", BindingFlags.NonPublic | BindingFlags.Instance);
-        var contentUI = (Control)Activator.CreateInstance(type);
-        var item = (Control)contentUI.GetType()
-            .GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance).GetValue(contentUI);
-
-        object actual = item.AccessibilityObject.TestAccessor().Dynamic
-            .GetPropertyValue(Interop.UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(Interop.UiaCore.UIA.RadioButtonControlTypeId, actual);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataGridViewCellStyleEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataGridViewCellStyleEditorTests.cs
deleted file mode 100644
index bab5774d6ad..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataGridViewCellStyleEditorTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing.Design;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class DataGridViewCellStyleEditorTests
-{
-    [Fact]
-    public void DataGridViewCellStyleEditor_Ctor_Default()
-    {
-        DataGridViewCellStyleEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyleEditor_GetEditStyle_ReturnsModal()
-    {
-        DataGridViewCellStyleEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(null));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataMemberFieldConverterTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataMemberFieldConverterTests.cs
deleted file mode 100644
index 67797a29721..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DataMemberFieldConverterTests.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Globalization;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class DataMemberFieldConverterTests
-{
-    private static DataMemberFieldConverter s_converter = new();
-    private static ITypeDescriptorContext s_context = new MyTypeDescriptorContext();
-
-    [Fact]
-    public static void CanConvertFrom()
-    {
-        Assert.True(s_converter.CanConvertFrom(s_context, typeof(string)));
-        Assert.True(s_converter.CanConvertFrom(s_context, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData("", "")]
-    [InlineData(null, null)]
-    [InlineData("(None)", "")]
-    public static void ConvertFrom(object actual, object expected)
-    {
-        Assert.Equal(expected, s_converter.ConvertFrom(s_context, CultureInfo.CurrentCulture, actual));
-    }
-
-    [Theory]
-    [InlineData("", typeof(string), "(none)")]
-    [InlineData(null, typeof(string), "(none)")]
-    [InlineData("FirstName", typeof(string), "FirstName")]
-    public static void ConvertTo(object actual, Type expectedType, object expected)
-    {
-        Assert.Equal(expected, s_converter.ConvertTo(s_context, CultureInfo.CurrentCulture, actual, expectedType));
-    }
-
-    [Theory]
-    [InlineData("", typeof(int))]
-    [InlineData("FirstName", typeof(int))]
-    public static void ConvertTo_ThrowsNotSupportedException(object actual, Type expectedType)
-    {
-        Assert.Throws<NotSupportedException>(
-            () => s_converter.ConvertTo(s_context, CultureInfo.CurrentCulture, actual, expectedType));
-    }
-}
-
-[Serializable]
-public class MyTypeDescriptorContext : ITypeDescriptorContext
-{
-    public IContainer Container => null;
-    public object Instance { get { return null; } }
-    public PropertyDescriptor PropertyDescriptor { get { return null; } }
-    public bool OnComponentChanging() { return true; }
-    public void OnComponentChanged() { }
-    public object GetService(Type serviceType) { return null; }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DesignerOptionsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DesignerOptionsTests.cs
deleted file mode 100644
index 78abd8cce0f..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DesignerOptionsTests.cs
+++ /dev/null
@@ -1,182 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class DesignerOptionsTests
-{
-    [Fact]
-    public void DesignerOptions_Ctor_Default()
-    {
-        DesignerOptions options = new();
-        Assert.True(options.EnableInSituEditing);
-        Assert.Equal(new Size(8, 8), options.GridSize);
-        Assert.True(options.ObjectBoundSmartTagAutoShow);
-        Assert.True(options.ShowGrid);
-        Assert.True(options.SnapToGrid);
-        Assert.False(options.UseOptimizedCodeGeneration);
-        Assert.False(options.UseSmartTags);
-        Assert.False(options.UseSnapLines);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_EnableInSituEditing_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            EnableInSituEditing = value
-        };
-        Assert.Equal(value, options.EnableInSituEditing);
-
-        // Set same.
-        options.EnableInSituEditing = value;
-        Assert.Equal(value, options.EnableInSituEditing);
-
-        // Set different.
-        options.EnableInSituEditing = !value;
-        Assert.Equal(!value, options.EnableInSituEditing);
-    }
-
-    public static IEnumerable<object[]> GridSize_Set_TestData()
-    {
-        yield return new object[] { new Size(0, 0), new Size(2, 2) };
-        yield return new object[] { new Size(0, 2), new Size(2, 2) };
-        yield return new object[] { new Size(2, 0), new Size(2, 2) };
-        yield return new object[] { new Size(2, 2), new Size(2, 2) };
-        yield return new object[] { new Size(200, 200), new Size(200, 200) };
-        yield return new object[] { new Size(201, 200), new Size(200, 200) };
-        yield return new object[] { new Size(200, 201), new Size(200, 200) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GridSize_Set_TestData))]
-    public void DesignerOptions_GridSize_Set_GetReturnsExpected(Size value, Size expected)
-    {
-        DesignerOptions options = new()
-        {
-            GridSize = value
-        };
-        Assert.Equal(expected, options.GridSize);
-
-        // Set same.
-        options.GridSize = value;
-        Assert.Equal(expected, options.GridSize);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_ObjectBoundSmartTagAutoShow_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            ObjectBoundSmartTagAutoShow = value
-        };
-        Assert.Equal(value, options.ObjectBoundSmartTagAutoShow);
-
-        // Set same.
-        options.ObjectBoundSmartTagAutoShow = value;
-        Assert.Equal(value, options.ObjectBoundSmartTagAutoShow);
-
-        // Set different.
-        options.ObjectBoundSmartTagAutoShow = !value;
-        Assert.Equal(!value, options.ObjectBoundSmartTagAutoShow);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_ShowGrid_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            ShowGrid = value
-        };
-        Assert.Equal(value, options.ShowGrid);
-
-        // Set same.
-        options.ShowGrid = value;
-        Assert.Equal(value, options.ShowGrid);
-
-        // Set different.
-        options.ShowGrid = !value;
-        Assert.Equal(!value, options.ShowGrid);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_SnapToGrid_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            SnapToGrid = value
-        };
-        Assert.Equal(value, options.SnapToGrid);
-
-        // Set same.
-        options.SnapToGrid = value;
-        Assert.Equal(value, options.SnapToGrid);
-
-        // Set different.
-        options.SnapToGrid = !value;
-        Assert.Equal(!value, options.SnapToGrid);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_UseOptimizedCodeGeneration_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            UseOptimizedCodeGeneration = value
-        };
-        Assert.Equal(value, options.UseOptimizedCodeGeneration);
-
-        // Set same.
-        options.UseOptimizedCodeGeneration = value;
-        Assert.Equal(value, options.UseOptimizedCodeGeneration);
-
-        // Set different.
-        options.UseOptimizedCodeGeneration = !value;
-        Assert.Equal(!value, options.UseOptimizedCodeGeneration);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_UseSmartTags_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            UseSmartTags = value
-        };
-        Assert.Equal(value, options.UseSmartTags);
-
-        // Set same.
-        options.UseSmartTags = value;
-        Assert.Equal(value, options.UseSmartTags);
-
-        // Set different.
-        options.UseSmartTags = !value;
-        Assert.Equal(!value, options.UseSmartTags);
-    }
-
-    [Theory]
-    [BoolData]
-    public void DesignerOptions_UseSnapLines_Set_GetReturnsExpected(bool value)
-    {
-        DesignerOptions options = new()
-        {
-            UseSnapLines = value
-        };
-        Assert.Equal(value, options.UseSnapLines);
-
-        // Set same.
-        options.UseSnapLines = value;
-        Assert.Equal(value, options.UseSnapLines);
-
-        // Set different.
-        options.UseSnapLines = !value;
-        Assert.Equal(!value, options.UseSnapLines);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DockEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DockEditorTests.cs
deleted file mode 100644
index 36a2c08d584..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/DockEditorTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class DockEditorTests
-{
-    [Fact]
-    public void DockEditor_Ctor_Default()
-    {
-        DockEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { DockStyle.Top };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void DockEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        DockEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void DockEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        DockEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void DockEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        DockEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void DockEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        DockEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EmbeddedResourceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EmbeddedResourceTests.cs
deleted file mode 100644
index a918d6a4339..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EmbeddedResourceTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class EmbeddedResourceTests
-{
-    // Get System.Windows.Forms.Design assembly to verify that it contains all the icons that the code uses.
-    private readonly Assembly assembly = Assembly.GetAssembly(typeof(AnchorEditor));
-
-    private static string s_expectedIconNames = """
-            System.ComponentModel.Design.Arrow
-            System.ComponentModel.Design.ComponentEditorPage
-            System.ComponentModel.Design.DateTimeFormat
-            System.ComponentModel.Design.DefaultComponent
-            System.ComponentModel.Design.NumericFormat
-            System.ComponentModel.Design.OrderImages
-            System.ComponentModel.Design.SortDown
-            System.ComponentModel.Design.SortUp
-            System.ComponentModel.Design.UncheckedBox
-            System.Windows.Forms.Design.256_1
-            System.Windows.Forms.Design.256_2
-            System.Windows.Forms.Design.AddNewDataSource
-            System.Windows.Forms.Design.Behavior.bottomclose
-            System.Windows.Forms.Design.Behavior.bottomopen
-            System.Windows.Forms.Design.Behavior.Close_left
-            System.Windows.Forms.Design.Behavior.DesignerShortcutBox
-            System.Windows.Forms.Design.Behavior.leftClose
-            System.Windows.Forms.Design.Behavior.leftOpen
-            System.Windows.Forms.Design.Behavior.MoverGlyph
-            System.Windows.Forms.Design.Behavior.Open_left
-            System.Windows.Forms.Design.Behavior.rightclose
-            System.Windows.Forms.Design.Behavior.rightopen
-            System.Windows.Forms.Design.Behavior.topclose
-            System.Windows.Forms.Design.Behavior.topopen
-            System.Windows.Forms.Design.BindingFormattingDialog.Arrow
-            System.Windows.Forms.Design.BindingFormattingDialog.Bound
-            System.Windows.Forms.Design.BindingFormattingDialog.Unbound
-            System.Windows.Forms.Design.BoundProperty
-            System.Windows.Forms.Design.ChildFolder
-            System.Windows.Forms.Design.classic
-            System.Windows.Forms.Design.colorful1
-            System.Windows.Forms.Design.DataGridViewColumnsDialog.delete
-            System.Windows.Forms.Design.DataGridViewColumnsDialog.moveDown
-            System.Windows.Forms.Design.DataGridViewColumnsDialog.moveUp
-            System.Windows.Forms.Design.DataGridViewColumnsDialog.selectedColumns
-            System.Windows.Forms.Design.DataPickerImages
-            System.Windows.Forms.Design.default
-            System.Windows.Forms.Design.Delete
-            System.Windows.Forms.Design.DummyNodeImage
-            System.Windows.Forms.Design.Folder
-            System.Windows.Forms.Design.ImageEditor
-            System.Windows.Forms.Design.InheritedGlyph
-            System.Windows.Forms.Design.InsertableObject
-            System.Windows.Forms.Design.Professional1
-            System.Windows.Forms.Design.Professional2
-            System.Windows.Forms.Design.ToolStripTemplateNode
-            System.Windows.Forms.Design.UserControlToolboxItem
-            """;
-
-    public static TheoryData ExpectedIconNames()
-        => s_expectedIconNames.Split(Environment.NewLine).ToTheoryData();
-
-    [Theory]
-    [MemberData(nameof(ExpectedIconNames))]
-    public void EmbeddedResource_ResourcesExist_Icon(string resourceName)
-    {
-        using Stream stream = assembly.GetManifestResourceStream(resourceName);
-        Assert.NotNull(stream);
-
-        using Icon icon = new(stream);
-        Assert.NotNull(icon);
-    }
-
-    private const string expectedResourceNames = """
-            System.ComponentModel.Design.BinaryEditor.resources
-            System.ComponentModel.Design.CollectionEditor.resources
-            System.SR.resources
-            System.Windows.Forms.Design.BorderSidesEditor.resources
-            System.Windows.Forms.Design.colordlg.data
-            System.Windows.Forms.Design.FormatControl.resources
-            System.Windows.Forms.Design.LinkAreaEditor.resources
-            System.Windows.Forms.Design.MaskDesignerDialog.resources
-            System.Windows.Forms.Design.ShortcutKeysEditor.resources
-            System.Windows.Forms.Design.StringCollectionEditor.resources
-            """;
-
-    [Fact]
-    public void EmbeddedResource_VerifyList()
-    {
-        string[] actual = assembly.GetManifestResourceNames();
-        Array.Sort(actual, StringComparer.Ordinal);
-
-        string[] expected = $"{s_expectedIconNames}{Environment.NewLine}{expectedResourceNames}".Split(Environment.NewLine);
-        Array.Sort(expected, StringComparer.Ordinal);
-
-        AssertExtensions.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EventHandlerServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EventHandlerServiceTests.cs
deleted file mode 100644
index 6531eb20d8b..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/EventHandlerServiceTests.cs
+++ /dev/null
@@ -1,181 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class EventHandlerServiceTests
-{
-    [Fact]
-    public void ctor_should_set_FocusWindow()
-    {
-        EventHandlerService service = new(null);
-        Assert.Null(service.FocusWindow);
-
-        using Control focusWnd = new();
-        service = new EventHandlerService(focusWnd);
-        Assert.Same(focusWnd, service.FocusWindow);
-    }
-
-    [Fact]
-    public void GetHandler_should_throw_if_handlerType_null()
-    {
-        EventHandlerService service = new(null);
-
-        Assert.Throws<ArgumentNullException>(() => service.GetHandler(null));
-    }
-
-    [Fact]
-    public void GetHandler_should_return_null_if_no_handlers()
-    {
-        EventHandlerService service = new(null);
-
-        Assert.Null(service.GetHandler(typeof(object)));
-    }
-
-    [Fact]
-    public void GetHandler_should_return_last_inserted_handler_of_type()
-    {
-        EventHandlerService service = new(null);
-        service.PushHandler(new A());
-
-        object second = new A();
-        service.PushHandler(second);
-
-        Assert.Same(second, service.GetHandler(typeof(A)));
-    }
-
-    [Fact]
-    public void GetHandler_should_not_remove_from_handlers()
-    {
-        EventHandlerService service = new(null);
-        A a = new A();
-        service.PushHandler(a);
-
-        var foundHandler = service.GetHandler(typeof(A));
-        Assert.Same(a, foundHandler);
-        foundHandler = service.GetHandler(typeof(A));
-        Assert.Same(a, foundHandler);
-    }
-
-    [Fact]
-    public void GetHandler_should_return_derived_handler_if_found()
-    {
-        EventHandlerService service = new(null);
-        A a = new A();
-        service.PushHandler(a);
-        B b = new B();
-        service.PushHandler(b);
-
-        var foundHandler = service.GetHandler(typeof(A));
-
-        Assert.Same(b, foundHandler);
-    }
-
-    [Fact]
-    public void GetHandler_should_return_null_if_handler_type_not_found()
-    {
-        EventHandlerService service = new(null);
-        service.PushHandler("Handler");
-
-        // PopHandler asserts when an item isn't found
-        using (new NoAssertContext())
-        {
-            Assert.Null(service.GetHandler(typeof(int)));
-        }
-    }
-
-    [Fact]
-    public void PopHandler_should_throw_if_handler_null()
-    {
-        EventHandlerService service = new(null);
-
-        Assert.Throws<ArgumentNullException>(() => service.PopHandler(null));
-    }
-
-    [Fact]
-    public void PopHandler_should_not_throw_if_stack_empty()
-    {
-        EventHandlerService service = new(null);
-
-        service.PopHandler(typeof(ComboBox));
-    }
-
-    [Fact]
-    public void PopHandler_should_not_pop_if_handler_not_found_on_stack()
-    {
-        EventHandlerService service = new(null);
-        A a = new A();
-        service.PushHandler(a);
-
-        // PopHandler asserts when an item isn't found
-        using (new NoAssertContext())
-        {
-            service.PopHandler(new B());
-        }
-
-        Assert.Same(a, service.GetHandler(typeof(A)));
-    }
-
-    [Fact]
-    public void PopHandler_should_pop_if_handler_found_on_stack()
-    {
-        EventHandlerService service = new(null);
-        A a = new A();
-        service.PushHandler(a);
-        service.PopHandler(a);
-        Assert.Null(service.GetHandler(typeof(A)));
-    }
-
-    [Fact]
-    public void PopHandler_should_raise_changedEvent_if_handler_found_on_stack()
-    {
-        EventHandlerService service = new(null);
-
-        A a = new A();
-        service.PushHandler(a);
-
-        int callCount = 0;
-        service.EventHandlerChanged += (s, e) => { callCount++; };
-
-        service.PopHandler(a);
-
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void PushHandler_should_throw_if_handler_null()
-    {
-        EventHandlerService service = new(null);
-
-        Assert.Throws<ArgumentNullException>(() => service.PushHandler(null));
-    }
-
-    [Fact]
-    public void PushHandler_should_set_handlerHead_to_new_handler()
-    {
-        EventHandlerService service = new(null);
-
-        A a1 = new A();
-        service.PushHandler(a1);
-        A a2 = new A();
-        service.PushHandler(a2);
-
-        Assert.Same(a2, service.GetHandler(typeof(A)));
-    }
-
-    [Fact]
-    public void PushHandler_should_raise_changedEvent_for_new_handler()
-    {
-        EventHandlerService service = new(null);
-        A a = new();
-        int callCount = 0;
-        service.EventHandlerChanged += (s, e) => { callCount++; };
-
-        service.PushHandler(a);
-
-        Assert.Equal(1, callCount);
-    }
-
-    private class A { }
-    private class B : A { }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FileNameEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FileNameEditorTests.cs
deleted file mode 100644
index d57065cc32e..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FileNameEditorTests.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class FileNameEditorTests
-{
-    [Fact]
-    public void FileNameEditor_Ctor_Default()
-    {
-        FileNameEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void FileNameEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        FileNameEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FileNameEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        FileNameEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FileNameEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        FileNameEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    [Fact]
-    public void FileNameEditor_InitializeDialog_Invoke_Success()
-    {
-        SubFileNameEditor editor = new();
-        using (OpenFileDialog openFileDialog = new())
-        {
-            editor.InitializeDialog(openFileDialog);
-            Assert.Equal("All Files(*.*)|*.*", openFileDialog.Filter);
-            Assert.Equal("Open File", openFileDialog.Title);
-        }
-    }
-
-    [Fact]
-    public void FileNameEditor_InitializeDialog_NullOpenFileDialog_ThrowsArgumentNullException()
-    {
-        SubFileNameEditor editor = new();
-        Assert.Throws<ArgumentNullException>("openFileDialog", () => editor.InitializeDialog(null));
-    }
-
-    private class SubFileNameEditor : FileNameEditor
-    {
-        public new void InitializeDialog(OpenFileDialog openFileDialog) => base.InitializeDialog(openFileDialog);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FolderNameEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FolderNameEditorTests.cs
deleted file mode 100644
index d53cef3a678..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/FolderNameEditorTests.cs
+++ /dev/null
@@ -1,106 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class FolderNameEditorTests
-{
-    [Fact]
-    public void FolderNameEditor_Ctor_Default()
-    {
-        FileNameEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FolderNameEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        FolderNameEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.Modal, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void FolderNameEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        FolderNameEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    [Fact]
-    public void FolderNameEditor_InitializeDialog_Invoke_Nop()
-    {
-        SubFolderNameEditor editor = new();
-        editor.InitializeDialog();
-    }
-
-    public class FolderBrowserTests : FolderNameEditor
-    {
-        [Fact]
-        public void FolderBrowser_Ctor_Default()
-        {
-            FolderBrowser browser = new();
-            Assert.Empty(browser.DirectoryPath);
-            Assert.Empty(browser.Description);
-            Assert.Equal(FolderBrowserStyles.RestrictToFilesystem, browser.Style);
-            Assert.Equal(FolderBrowserFolder.Desktop, browser.StartLocation);
-        }
-
-        [Theory]
-        [NormalizedStringData]
-        public void FolderBrowser_Description_Set_GetReturnsExpected(string value, string expected)
-        {
-            FolderBrowser browser = new()
-            {
-                Description = value
-            };
-            Assert.Equal(expected, browser.Description);
-
-            // Set same.
-            browser.Description = value;
-            Assert.Equal(expected, browser.Description);
-        }
-
-        [Theory]
-        [EnumData<FolderBrowserFolder>]
-        [InvalidEnumData<FolderBrowserFolder>]
-        protected void FolderBrowser_StartLocation_Set_GetReturnsExpected(FolderBrowserFolder value)
-        {
-            FolderBrowser browser = new()
-            {
-                StartLocation = value
-            };
-            Assert.Equal(value, browser.StartLocation);
-
-            // Set same.
-            browser.StartLocation = value;
-            Assert.Equal(value, browser.StartLocation);
-        }
-
-        [Theory]
-        [EnumData<FolderBrowserStyles>]
-        [InvalidEnumData<FolderBrowserStyles>]
-        protected void FolderBrowser_Style_Set_GetReturnsExpected(FolderBrowserStyles value)
-        {
-            FolderBrowser browser = new()
-            {
-                Style = value
-            };
-            Assert.Equal(value, browser.Style);
-
-            // Set same.
-            browser.Style = value;
-            Assert.Equal(value, browser.Style);
-        }
-    }
-
-    private class SubFolderNameEditor : FolderNameEditor
-    {
-        public void InitializeDialog() => base.InitializeDialog(null);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ImageListImageEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ImageListImageEditorTests.cs
deleted file mode 100644
index 991eb3c6a6d..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ImageListImageEditorTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Imaging;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ImageListImageEditorTests
-{
-    [Fact]
-    public void ImageListImageEditor_LoadImageFromStream_BitmapStream_ReturnsExpected()
-    {
-        ImageListImageEditor editor = new();
-        var editor_LoadImageFromStream = editor.TestAccessor().CreateDelegate<Func<Stream, bool, ImageListImage>>("LoadImageFromStream");
-
-        using MemoryStream stream = new();
-        using Bitmap image = new(10, 10);
-        image.Save(stream, ImageFormat.Bmp);
-        stream.Position = 0;
-
-        var result = Assert.IsType<ImageListImage>(editor_LoadImageFromStream(stream, false));
-        var resultImage = Assert.IsType<Bitmap>(result.Image);
-        Assert.Equal(new Size(10, 10), result.Size);
-        Assert.Equal(new Size(10, 10), resultImage.Size);
-
-        using MemoryStream resultStream = new();
-        result.Image.Save(resultStream, ImageFormat.Bmp);
-        Assert.Equal(stream.Length, resultStream.Length);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/MenuCommandsTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/MenuCommandsTests.cs
deleted file mode 100644
index 2866b979514..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/MenuCommandsTests.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class MenuCommandsTests
-{
-    [Fact]
-    public void MenuCommands_Ctor_Default()
-    {
-        // Make sure it doesn't throw.
-        new MenuCommands();
-    }
-
-    public static IEnumerable<object[]> Commands_TestData()
-    {
-        yield return new object[] { MenuCommands.ComponentTrayMenu, new CommandID(new Guid("74d21312-2aee-11d1-8bfb-00a0c90f26f7"), 1286) };
-        yield return new object[] { MenuCommands.ContainerMenu, new CommandID(new Guid("74d21312-2aee-11d1-8bfb-00a0c90f26f7"), 1281) };
-        yield return new object[] { MenuCommands.DesignerProperties, new CommandID(new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"), 4097) };
-        yield return new object[] { MenuCommands.EditLabel, new CommandID(new Guid("5efc7975-14bc-11cf-9b2b-00aa00573819"), 338) };
-        yield return new object[] { MenuCommands.KeyCancel, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 103) };
-        yield return new object[] { MenuCommands.KeyDefaultAction, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 3) };
-        yield return new object[] { MenuCommands.KeyEnd, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 17) };
-        yield return new object[] { MenuCommands.KeyHome, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 15) };
-        yield return new object[] { MenuCommands.KeyInvokeSmartTag, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 147) };
-        yield return new object[] { MenuCommands.KeyMoveDown, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 13) };
-        yield return new object[] { MenuCommands.KeyMoveLeft, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 7) };
-        yield return new object[] { MenuCommands.KeyMoveRight, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 9) };
-        yield return new object[] { MenuCommands.KeyMoveUp, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 11) };
-        yield return new object[] { MenuCommands.KeyNudgeDown, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1225) };
-        yield return new object[] { MenuCommands.KeyNudgeHeightDecrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1229) };
-        yield return new object[] { MenuCommands.KeyNudgeHeightIncrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1228) };
-        yield return new object[] { MenuCommands.KeyNudgeLeft, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1224) };
-        yield return new object[] { MenuCommands.KeyNudgeRight, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1226) };
-        yield return new object[] { MenuCommands.KeyNudgeUp, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1227) };
-        yield return new object[] { MenuCommands.KeyNudgeWidthDecrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1230) };
-        yield return new object[] { MenuCommands.KeyNudgeWidthDecrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1230) };
-        yield return new object[] { MenuCommands.KeyNudgeHeightIncrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 1228) };
-        yield return new object[] { MenuCommands.KeyReverseCancel, new CommandID(new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"), 16385) };
-        yield return new object[] { MenuCommands.KeySelectNext, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 4) };
-        yield return new object[] { MenuCommands.KeySelectPrevious, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 5) };
-        yield return new object[] { MenuCommands.KeyShiftEnd, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 18) };
-        yield return new object[] { MenuCommands.KeyShiftHome, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 16) };
-        yield return new object[] { MenuCommands.KeySizeHeightDecrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 14) };
-        yield return new object[] { MenuCommands.KeySizeHeightIncrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 12) };
-        yield return new object[] { MenuCommands.KeySizeWidthDecrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 8) };
-        yield return new object[] { MenuCommands.KeySizeWidthIncrease, new CommandID(new Guid("1496a755-94de-11d0-8c3f-00c04fc2aae2"), 10) };
-        yield return new object[] { MenuCommands.KeyTabOrderSelect, new CommandID(new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"), 16405) };
-        yield return new object[] { MenuCommands.SelectionMenu, new CommandID(new Guid("74d21312-2aee-11d1-8bfb-00a0c90f26f7"), 1280) };
-        yield return new object[] { MenuCommands.SetStatusRectangle, new CommandID(new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"), 16388) };
-        yield return new object[] { MenuCommands.SetStatusText, new CommandID(new Guid("74d21313-2aee-11d1-8bfb-00a0c90f26f7"), 16387) };
-        yield return new object[] { MenuCommands.TraySelectionMenu, new CommandID(new Guid("74d21312-2aee-11d1-8bfb-00a0c90f26f7"), 1283) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Commands_TestData))]
-    public void MenuCommands_Commands_Get_ReturnsExpected(CommandID command, CommandID expected)
-    {
-        Assert.Equal(expected, command);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ShortcutKeysEditorTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ShortcutKeysEditorTests.cs
deleted file mode 100644
index c88e7c454e2..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/ShortcutKeysEditorTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ShortcutKeysEditorTests
-{
-    [Fact]
-    public void ShortcutKeysEditor_Ctor_Default()
-    {
-        ShortcutKeysEditor editor = new();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "value" };
-        yield return new object[] { Shortcut.CtrlA };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_TestData))]
-    public void ShortcutKeysEditor_EditValue_ValidProvider_ReturnsValue(object value)
-    {
-        ShortcutKeysEditor editor = new();
-        Mock<IWindowsFormsEditorService> mockEditorService = new(MockBehavior.Strict);
-        Mock<IServiceProvider> mockServiceProvider = new(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(mockEditorService.Object)
-            .Verifiable();
-        mockEditorService
-            .Setup(e => e.DropDownControl(It.IsAny<Control>()))
-            .Verifiable();
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Once());
-        mockEditorService.Verify(e => e.DropDownControl(It.IsAny<Control>()), Times.Once());
-
-        // Edit again.
-        Assert.Equal(value, editor.EditValue(null, mockServiceProvider.Object, value));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-        mockServiceProvider.Verify(p => p.GetService(typeof(IWindowsFormsEditorService)), Times.Exactly(2));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetEditValueInvalidProviderTestData))]
-    public void ShortcutKeysEditor_EditValue_InvalidProvider_ReturnsValue(IServiceProvider provider, object value)
-    {
-        ShortcutKeysEditor editor = new();
-        Assert.Same(value, editor.EditValue(null, provider, value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ShortcutKeysEditor_GetEditStyle_Invoke_ReturnsModal(ITypeDescriptorContext context)
-    {
-        ShortcutKeysEditor editor = new();
-        Assert.Equal(UITypeEditorEditStyle.DropDown, editor.GetEditStyle(context));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void ShortcutKeysEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        ShortcutKeysEditor editor = new();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsDesignerOptionServiceTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsDesignerOptionServiceTests.cs
deleted file mode 100644
index 036585aa9cf..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsDesignerOptionServiceTests.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class WindowsFormsDesignerOptionServiceTests
-{
-    [Fact]
-    public void WindowsFormsDesignerOptionService_Ctor_Default()
-    {
-        WindowsFormsDesignerOptionService service = new();
-        DesignerOptions options = service.CompatibilityOptions;
-        Assert.True(options.EnableInSituEditing);
-        Assert.Equal(new Size(8, 8), options.GridSize);
-        Assert.True(options.ObjectBoundSmartTagAutoShow);
-        Assert.True(options.ShowGrid);
-        Assert.True(options.SnapToGrid);
-        Assert.False(options.UseSmartTags);
-        Assert.False(options.UseSnapLines);
-        Assert.False(options.UseOptimizedCodeGeneration);
-        Assert.Same(options, service.CompatibilityOptions);
-    }
-
-    [Fact]
-    public void WindowsFormsDesignerOptionService_Options_Get_ReturnsExpected()
-    {
-        WindowsFormsDesignerOptionService service = new();
-        Assert.Empty(service.Options.Name);
-        DesignerOptionService.DesignerOptionCollection childCollection = Assert.IsType<DesignerOptionService.DesignerOptionCollection>(Assert.Single(service.Options));
-        Assert.Equal("DesignerOptions", childCollection.Name);
-        Assert.Same(service.Options, childCollection.Parent);
-        Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));
-        Assert.Empty(childCollection);
-    }
-
-    [Fact]
-    public void WindowsFormsDesignerOptionService_Options_GetNullDesignerOptions_ReturnsExpected()
-    {
-        NullCompatibilityOptions service = new();
-        Assert.Empty(service.Options.Name);
-        Assert.Empty(service.Options);
-    }
-
-    [Fact]
-    public void WindowsFormsDesignerOptionService_PopulateOptionCollection_ValidOptionsFromSameClass_Success()
-    {
-        SubWindowsFormsDesignerOptionService service = new();
-        service.PopulateOptionCollectionEntry(service.Options);
-        Assert.Equal(1, service.PopulateOptionCollectionCallCount);
-
-        // Should not retrieve again when accessing Options.
-        DesignerOptionService.DesignerOptionCollection childCollection = Assert.IsType<DesignerOptionService.DesignerOptionCollection>(Assert.Single(service.Options));
-        Assert.Equal(1, service.PopulateOptionCollectionCallCount);
-        Assert.Equal("DesignerOptions", childCollection.Name);
-        Assert.Same(service.Options, childCollection.Parent);
-        Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));
-        Assert.Empty(childCollection);
-    }
-
-    [Fact]
-    public void WindowsFormsDesignerOptionService_PopulateOptionCollection_ValidOptionsFromOtherClass_Success()
-    {
-        SubWindowsFormsDesignerOptionService service = new();
-        SubWindowsFormsDesignerOptionService otherService = new();
-        service.PopulateOptionCollectionEntry(otherService.Options);
-        Assert.Equal(1, service.PopulateOptionCollectionCallCount);
-
-        // Should retrieve again when accessing Options.
-        DesignerOptionService.DesignerOptionCollection childCollection = Assert.IsType<DesignerOptionService.DesignerOptionCollection>(Assert.Single(service.Options));
-        Assert.Equal(2, service.PopulateOptionCollectionCallCount);
-        Assert.Equal("DesignerOptions", childCollection.Name);
-        Assert.Same(service.Options, childCollection.Parent);
-        Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));
-        Assert.Empty(childCollection);
-
-        DesignerOptionService.DesignerOptionCollection otherChildCollection = Assert.IsType<DesignerOptionService.DesignerOptionCollection>(Assert.Single(service.Options));
-        Assert.Equal(0, otherService.PopulateOptionCollectionCallCount);
-        Assert.Equal("DesignerOptions", otherChildCollection.Name);
-        Assert.Same(service.Options, otherChildCollection.Parent);
-        Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));
-        Assert.Empty(otherChildCollection);
-    }
-
-    [Fact]
-    public void WindowsFormsDesignerOptionService_PopulateOptionCollection_NullOptions_Success()
-    {
-        SubWindowsFormsDesignerOptionService service = new();
-        service.PopulateOptionCollectionEntry(null);
-        Assert.Equal(1, service.PopulateOptionCollectionCallCount);
-
-        // Should retrieve again when accessing Options.
-        DesignerOptionService.DesignerOptionCollection childCollection = Assert.IsType<DesignerOptionService.DesignerOptionCollection>(Assert.Single(service.Options));
-        Assert.Equal(2, service.PopulateOptionCollectionCallCount);
-        Assert.Equal("DesignerOptions", childCollection.Name);
-        Assert.Same(service.Options, childCollection.Parent);
-        Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));
-        Assert.Empty(childCollection);
-        Assert.Equal(3, service.PopulateOptionCollectionCallCount);
-    }
-
-    private class SubWindowsFormsDesignerOptionService : WindowsFormsDesignerOptionService
-    {
-        public int PopulateOptionCollectionCallCount { get; set; }
-
-        public void PopulateOptionCollectionEntry(DesignerOptionCollection options)
-        {
-            PopulateOptionCollection(options);
-        }
-
-        protected override void PopulateOptionCollection(DesignerOptionCollection options)
-        {
-            PopulateOptionCollectionCallCount++;
-            base.PopulateOptionCollection(options);
-        }
-    }
-
-    private class NullCompatibilityOptions : WindowsFormsDesignerOptionService
-    {
-        public override DesignerOptions CompatibilityOptions => null;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/SystemDesignMetadataReader.cs b/src/System.Windows.Forms.Design/tests/UnitTests/SystemDesignMetadataReader.cs
deleted file mode 100644
index 3af622fcc0e..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/SystemDesignMetadataReader.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using System.Reflection;
-using System.Reflection.Metadata;
-using System.Reflection.PortableExecutable;
-
-namespace System.Windows.Forms.Design.Editors.Tests;
-
-internal sealed class SystemDesignMetadataReader
-{
-    public IReadOnlyList<string> GetExportedTypeNames()
-    {
-        // Force load System.Design into the appdomain
-        DesignSurface designSurface = new();
-        IDesigner designer = designSurface.CreateDesigner(new Control(), true);
-        Assert.NotNull(designer);
-
-        Assembly systemDesign = AppDomain.CurrentDomain.GetAssemblies().First(a => a.GetName().Name == "System.Design");
-
-        using FileStream fs = new(systemDesign.Location, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-        using PEReader peReader = new(fs);
-
-        MetadataReader metadataReader = peReader.GetMetadataReader();
-        List<string> typeNames = new();
-
-        foreach (ExportedTypeHandle typeHandle in metadataReader.ExportedTypes)
-        {
-            ExportedType type = metadataReader.GetExportedType(typeHandle);
-
-            string ns = metadataReader.GetString(type.Namespace);
-            string name = metadataReader.GetString(type.Name);
-
-            typeNames.Add($"{ns}.{name}");
-        }
-
-        return typeNames;
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/TestControlDesigner.cs b/src/System.Windows.Forms.Design/tests/UnitTests/TestControlDesigner.cs
deleted file mode 100644
index 1f8e465d66d..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/TestControlDesigner.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Design.Behavior;
-
-namespace System.Windows.Forms.Design.Tests;
-
-internal class TestControlDesigner : ControlDesigner
-{
-    internal AccessibleObject GetAccessibleObjectField()
-    {
-        return accessibilityObj;
-    }
-
-    internal BehaviorService GetBehaviorServiceProperty()
-    {
-        return BehaviorService;
-    }
-
-    internal bool GetEnableDragRectProperty()
-    {
-        return EnableDragRect;
-    }
-
-    internal IComponent GetParentComponentProperty()
-    {
-        return ParentComponent;
-    }
-
-    internal InheritanceAttribute GetInheritanceAttributeProperty()
-    {
-        return InheritanceAttribute;
-    }
-
-    internal void BaseWndProcMethod(ref Message m)
-    {
-        BaseWndProc(ref m);
-    }
-
-    internal void DefWndProcMethod(ref Message m)
-    {
-        DefWndProc(ref m);
-    }
-
-    internal void DisplayErrorMethod(Exception e)
-    {
-        DisplayError(e);
-    }
-
-    internal void DisposeMethod(bool disposing)
-    {
-        Dispose(disposing);
-    }
-
-    internal bool EnableDesignModeMethod(Control child, string name)
-    {
-        return EnableDesignMode(child, name);
-    }
-
-    internal void EnableDragDropMethod(bool value)
-    {
-        EnableDragDrop(value);
-    }
-
-    internal ControlBodyGlyph GetControlGlyphMethod(GlyphSelectionType selectionType)
-    {
-        return GetControlGlyph(selectionType);
-    }
-
-    internal bool GetHitTestMethod(Point point)
-    {
-        return GetHitTest(point);
-    }
-
-    internal void HookChildControlsMethod(Control firstChild)
-    {
-        HookChildControls(firstChild);
-    }
-
-    internal void OnContextMenuMethod(int x, int y)
-    {
-        OnContextMenu(x, y);
-    }
-
-    internal void OnCreateHandleMethod()
-    {
-        OnCreateHandle();
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDesignerTests.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDesignerTests.cs
deleted file mode 100644
index fcd98f0bd20..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDesignerTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using System.Windows.Forms.Design.Behavior;
-using System.Windows.Forms.Design.Tests.Mocks;
-using Moq;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ToolStripDesignerTests
-{
-    [WinFormsFact]
-    public void ToolStripDesigner_AssociatedComponentsTest()
-    {
-        using ToolStripDesigner toolStripDesigner = new();
-        using ToolStrip toolStrip = new();
-
-        Mock<IComponentChangeService> mockIComponentChangeService = new(MockBehavior.Strict);
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(toolStrip);
-        mockDesignerHost
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(mockIComponentChangeService.Object);
-        mockDesignerHost.Setup(s => s.AddService(typeof(ToolStripKeyboardHandlingService), It.IsAny<object>()));
-        mockDesignerHost.Setup(s => s.AddService(typeof(ISupportInSituService), It.IsAny<object>()));
-
-        var mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        mockSite.Setup(s => s.GetService(typeof(BehaviorService))).Returns(null);
-        mockSite.Setup(s => s.GetService(typeof(ToolStripAdornerWindowService))).Returns(null);
-        toolStrip.Site = mockSite.Object;
-
-        toolStripDesigner.Initialize(toolStrip);
-
-        Assert.Empty(toolStripDesigner.AssociatedComponents);
-
-        toolStrip.Items.Add("123");
-        toolStrip.Items.Add("abc");
-
-        Assert.Equal(2, toolStripDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownDesignerTest.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownDesignerTest.cs
deleted file mode 100644
index 3c838cde0f1..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownDesignerTest.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design;
-using System.ComponentModel;
-using Moq;
-using System.Windows.Forms.Design.Tests.Mocks;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ToolStripDropDownDesignerTest
-{
-    [WinFormsFact]
-    public void ToolStripDropDownDesignerTest_AssociatedComponentsTest()
-    {
-        ToolStripDropDownDesigner toolStripDropDownDesigner = new();
-        ToolStripDropDown toolStripDropDown = new();
-
-        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(toolStripDropDown);
-        mockDesignerHost
-            .Setup(h => h.Loading)
-            .Returns(true);
-        Mock<IComponentChangeService> mockComponentChangeService = new(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockDesignerHost.Setup(s => s.AddService(It.IsAny<Type>(), It.IsAny<object>()));
-
-        Mock<ISite> mockSite = MockSite.CreateMockSiteWithDesignerHost(mockDesignerHost.Object);
-        toolStripDropDown.Site = mockSite.Object;
-
-        toolStripDropDownDesigner.Initialize(toolStripDropDown);
-
-        Assert.Empty(toolStripDropDownDesigner.AssociatedComponents);
-
-        toolStripDropDown.Items.Add("123");
-        toolStripDropDown.Items.Add("456");
-
-        Assert.Equal(2, toolStripDropDownDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownItemDesignerTest.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownItemDesignerTest.cs
deleted file mode 100644
index be8816ac49a..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripDropDownItemDesignerTest.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ToolStripDropDownItemDesignerTest
-{
-    [WinFormsFact]
-    public void ToolStripDropDownItemDesignerTest_AssociatedComponentsTest()
-    {
-        ToolStripDropDownItemDesigner toolStripDropDownItemDesigner = new();
-        ToolStripMenuItem toolStripDropDown = new();
-
-        toolStripDropDownItemDesigner.Initialize(toolStripDropDown);
-
-        Assert.Empty(toolStripDropDownItemDesigner.AssociatedComponents);
-
-        toolStripDropDown.DropDownItems.Add("123");
-
-        Assert.Equal(1, toolStripDropDownItemDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripMenuItemDesignerTest.cs b/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripMenuItemDesignerTest.cs
deleted file mode 100644
index f561584c81c..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/ToolStripMenuItemDesignerTest.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ToolStripMenuItemDesignerTest
-{
-    [WinFormsFact]
-    public void ToolStripMenuItemDesignerTest_AssociatedComponentsTest()
-    {
-        ToolStripMenuItemDesigner toolStripMenuItemDesigner = new();
-        ToolStripMenuItem toolStripDropDown = new();
-        toolStripMenuItemDesigner.Initialize(toolStripDropDown);
-
-        Assert.Empty(toolStripMenuItemDesigner.AssociatedComponents);
-
-        toolStripDropDown.DropDownItems.Add("123");
-
-        Assert.Equal(1, toolStripMenuItemDesigner.AssociatedComponents.Count);
-    }
-}
diff --git a/src/System.Windows.Forms.Design/tests/UnitTests/runtimeconfig.template.json b/src/System.Windows.Forms.Design/tests/UnitTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/System.Windows.Forms.Design/tests/UnitTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.CCM.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.CCM.cs
new file mode 100644
index 00000000000..bdfa45508ab
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.CCM.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        public enum CCM : uint
+        {
+            FIRST = 0x2000,
+            SETBKCOLOR = FIRST + 1,
+            SETCOLORSCHEME = FIRST + 2,
+            GETCOLORSCHEME = FIRST + 3,
+            GETDROPTARGET = FIRST + 4,
+            SETUNICODEFORMAT = FIRST + 5,
+            GETUNICODEFORMAT = FIRST + 6,
+            SETVERSION = FIRST + 0x7,
+            GETVERSION = FIRST + 0x8,
+            SETNOTIFYWINDOW = FIRST + 0x9,
+            SETWINDOWTHEME = FIRST + 0xB,
+            DPISCALE = FIRST + 0xC,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.ICC.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.ICC.cs
new file mode 100644
index 00000000000..64517dcfb08
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.ICC.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        public enum ICC : uint
+        {
+            LISTVIEW_CLASSES = 0x00000001,
+            TREEVIEW_CLASSES = 0x00000002,
+            BAR_CLASSES = 0x00000004,
+            TAB_CLASSES = 0x00000008,
+            UPDOWN_CLASS = 0x00000010,
+            PROGRESS_CLASS = 0x00000020,
+            HOTKEY_CLASS = 0x00000040,
+            ANIMATE_CLASS = 0x00000080,
+            WIN95_CLASSES = 0x000000FF,
+            DATE_CLASSES = 0x00000100,
+            USEREX_CLASSES = 0x00000200,
+            COOL_CLASSES = 0x00000400,
+            INTERNET_CLASSES = 0x00000800,
+            PAGESCROLLER_CLASS = 0x00001000,
+            NATIVEFNTCTL_CLASS = 0x00002000,
+            STANDARD_CLASSES = 0x00004000,
+            LINK_CLASS = 0x00008000,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.InitCommonControlsEx.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.InitCommonControlsEx.cs
new file mode 100644
index 00000000000..298badf4c2e
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.InitCommonControlsEx.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal partial class Interop
+{
+    internal partial class ComCtl32
+    {
+        [DllImport(Libraries.Comctl32, ExactSpelling = true, EntryPoint = "InitCommonControlsEx")]
+        private static extern BOOL InitCommonControlsExInternal(ref INITCOMMONCONTROLSEX picce);
+
+        public static BOOL InitCommonControlsEx(ref INITCOMMONCONTROLSEX picce)
+        {
+            picce.dwSize = (uint)Marshal.SizeOf<INITCOMMONCONTROLSEX>();
+            return InitCommonControlsExInternal(ref picce);
+        }
+
+        public struct INITCOMMONCONTROLSEX
+        {
+            public uint dwSize;
+            public ICC dwICC;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTDT.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTDT.cs
new file mode 100644
index 00000000000..5f52debc926
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTDT.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        public enum TTDT : uint
+        {
+            AUTOMATIC = 0,
+            RESHOW = 1,
+            AUTOPOP = 2,
+            INITIAL = 3,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTF.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTF.cs
new file mode 100644
index 00000000000..5127c7d63ef
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTF.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        [Flags]
+        public enum TTF
+        {
+            IDISHWND = 0x0001,
+            CENTERTIP = 0x0002,
+            RTLREADING = 0x0004,
+            SUBCLASS = 0x0010,
+            TRACK = 0x0020,
+            ABSOLUTE = 0x0080,
+            TRANSPARENT = 0x0100,
+            PARSELINKS = 0x1000,
+            DI_SETITEM = 0x8000
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTM.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTM.cs
new file mode 100644
index 00000000000..ea0c1250f2a
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTM.cs
@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using static Interop.User32;
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        public enum TTM : uint
+        {
+            ACTIVATE = WM.USER + 1,
+            SETDELAYTIME = WM.USER + 3,
+            RELAYEVENT = WM.USER + 7,
+            GETTOOLCOUNT = WM.USER + 13,
+            WINDOWFROMPOINT = WM.USER + 16,
+            TRACKACTIVATE = WM.USER + 17,
+            TRACKPOSITION = WM.USER + 18,
+            SETTIPBKCOLOR = WM.USER + 19,
+            SETTIPTEXTCOLOR = WM.USER + 20,
+            GETDELAYTIME = WM.USER + 21,
+            GETTIPBKCOLOR = WM.USER + 22,
+            GETTIPTEXTCOLOR = WM.USER + 23,
+            SETMAXTIPWIDTH = WM.USER + 24,
+            GETMAXTIPWIDTH = WM.USER + 25,
+            SETMARGIN = WM.USER + 26,
+            GETMARGIN = WM.USER + 27,
+            POP = WM.USER + 28,
+            UPDATE = WM.USER + 29,
+            GETBUBBLESIZE = WM.USER + 30,
+            ADJUSTRECT = WM.USER + 31,
+            SETTITLEW = WM.USER + 33,
+            POPUP = WM.USER + 34,
+            GETTITLE = WM.USER + 35,
+            ADDTOOLW = WM.USER + 50,
+            DELTOOLW = WM.USER + 51,
+            NEWTOOLRECTW = WM.USER + 52,
+            GETTOOLINFOW = WM.USER + 53,
+            SETTOOLINFOW = WM.USER + 54,
+            HITTESTW = WM.USER + 55,
+            GETTEXTW = WM.USER + 56,
+            UPDATETIPTEXTW = WM.USER + 57,
+            ENUMTOOLSW = WM.USER + 58,
+            GETCURRENTTOOLW = WM.USER + 59,
+            GETWINDOWTHEME = CCM.SETWINDOWTHEME,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTS.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTS.cs
new file mode 100644
index 00000000000..e313a5a49ac
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.TTS.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        [Flags]
+        public enum TTS : int
+        {
+            ALWAYSTIP = 0x01,
+            NOPREFIX = 0x02,
+            NOANIMATE = 0x10,
+            NOFADE = 0x20,
+            BALLOON = 0x40,
+            CLOSE = 0x80,
+            USEVISUALSTYLE = 0x100
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.WindowClasses.cs b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.WindowClasses.cs
new file mode 100644
index 00000000000..ee4306885b5
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/ComCtl32/Interop.WindowClasses.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class ComCtl32
+    {
+        public static class WindowClasses
+        {
+            public const string MSFTEDIT_CLASS = "RICHEDIT50W";
+            public const string TOOLTIPS_CLASS = "tooltips_class32";
+            public const string WC_BUTTON = "Button";
+            public const string WC_COMBOBOX = "ComboBox";
+            public const string WC_DATETIMEPICK = "SysDateTimePick32";
+            public const string WC_EDIT = "Edit";
+            public const string WC_LISTBOX = "ListBox";
+            public const string WC_LISTVIEW = "SysListView32";
+            public const string WC_MONTHCAL = "SysMonthCal32";
+            public const string WC_PROGRESS = "msctls_progress32";
+            public const string WC_SCROLLBAR = "ScrollBar";
+            public const string WC_STATIC = "Static";
+            public const string WC_STATUSBAR = "msctls_statusbar32";
+            public const string WC_TABCONTROL = "SysTabControl32";
+            public const string WC_TOOLBAR = "ToolbarWindow32";
+            public const string WC_TREEVIEW = "SysTreeView32";
+            public const string WC_TRACKBAR = "msctls_trackbar32";
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.CreateBrushIndirect.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.CreateBrushIndirect.cs
new file mode 100644
index 00000000000..fa2f11e82aa
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.CreateBrushIndirect.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true, SetLastError = true)]
+        public static extern HBRUSH CreateBrushIndirect(ref LOGBRUSH lb);
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.DeleteObject.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.DeleteObject.cs
new file mode 100644
index 00000000000..ff09b1a20e9
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.DeleteObject.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true)]
+        public static extern BOOL DeleteObject(IntPtr hObject);
+
+        public static BOOL DeleteObject(HGDIOBJ hObject) => DeleteObject(hObject.Handle);
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetObjectType.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetObjectType.cs
new file mode 100644
index 00000000000..5f4c3f47d5c
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetObjectType.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        // This does set last error but *only* in one error case that doesn't add any real value.
+        [DllImport(Libraries.Gdi32, ExactSpelling = true)]
+        public static extern OBJ GetObjectType(HGDIOBJ h);
+
+        public static OBJ GetObjectType(HandleRef h)
+        {
+            OBJ result = GetObjectType((HGDIOBJ)h.Handle);
+            GC.KeepAlive(h.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetRegionData.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetRegionData.cs
new file mode 100644
index 00000000000..01333c75c5c
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.GetRegionData.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true)]
+        public static extern uint GetRegionData(IntPtr hRgn, uint nCount, IntPtr lpRgnData);
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HBRUSH.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HBRUSH.cs
new file mode 100644
index 00000000000..4b0624c5237
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HBRUSH.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        public readonly struct HBRUSH
+        {
+            public IntPtr Handle { get; }
+
+            public HBRUSH(IntPtr handle) => Handle = handle;
+
+            public bool IsNull => Handle == IntPtr.Zero;
+
+            public static explicit operator IntPtr(HBRUSH hbrush) => hbrush.Handle;
+            public static explicit operator HBRUSH(IntPtr hbrush) => new HBRUSH(hbrush);
+            public static implicit operator HGDIOBJ(HBRUSH hbrush) => new HGDIOBJ(hbrush.Handle);
+            public static explicit operator HBRUSH(HGDIOBJ hbrush) => new HBRUSH(hbrush.Handle);
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HDC.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HDC.cs
new file mode 100644
index 00000000000..22e63ead72b
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HDC.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    [SuppressMessage("Usage", "CA1066:Type {0} should implement IEquatable<T> because it overrides Equals", Justification = "Reason for suppressing")]
+    internal static partial class Gdi32
+    {
+        public readonly struct HDC
+        {
+            public IntPtr Handle { get; }
+
+            public HDC(IntPtr handle) => Handle = handle;
+
+            public bool IsNull => Handle == IntPtr.Zero;
+
+            public static explicit operator IntPtr(HDC hdc) => hdc.Handle;
+            public static explicit operator HDC(IntPtr hdc) => new HDC(hdc);
+            public static implicit operator HGDIOBJ(HDC hdc) => new HGDIOBJ(hdc.Handle);
+
+            public static bool operator ==(HDC value1, HDC value2) => value1.Handle == value2.Handle;
+            public static bool operator !=(HDC value1, HDC value2) => value1.Handle != value2.Handle;
+            public override bool Equals(object? obj) => obj is HDC hdc && hdc.Handle == Handle;
+            public override int GetHashCode() => Handle.GetHashCode();
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HGDIOBJ.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HGDIOBJ.cs
new file mode 100644
index 00000000000..645a6a3acc5
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HGDIOBJ.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    [SuppressMessage("Usage", "CA1066:Type {0} should implement IEquatable<T> because it overrides Equals", Justification = "Reason for suppressing")]
+    internal static partial class Gdi32
+    {
+        public struct HGDIOBJ
+        {
+            public IntPtr Handle { get; }
+
+            public HGDIOBJ(IntPtr handle) => Handle = handle;
+
+            public bool IsNull => Handle == IntPtr.Zero;
+
+            public static explicit operator IntPtr(HGDIOBJ hgdiobj) => hgdiobj.Handle;
+            public static explicit operator HGDIOBJ(IntPtr hgdiobj) => new HGDIOBJ(hgdiobj);
+
+            public static bool operator ==(HGDIOBJ value1, HGDIOBJ value2) => value1.Handle == value2.Handle;
+            public static bool operator !=(HGDIOBJ value1, HGDIOBJ value2) => value1.Handle != value2.Handle;
+            public override bool Equals(object? obj) => obj is HGDIOBJ hgdiobj && hgdiobj.Handle == Handle;
+            public override int GetHashCode() => Handle.GetHashCode();
+
+            public OBJ ObjectType => GetObjectType(this);
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HRGN.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HRGN.cs
new file mode 100644
index 00000000000..b72fac07fed
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.HRGN.cs
@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        public readonly struct HRGN
+        {
+            public IntPtr Handle { get; }
+
+            public HRGN(IntPtr handle) => Handle = handle;
+
+            public bool IsNull => Handle == IntPtr.Zero;
+
+            public static implicit operator HGDIOBJ(HRGN hrgn) => new HGDIOBJ(hrgn.Handle);
+            public static explicit operator IntPtr(HRGN hrgn) => hrgn.Handle;
+            public static explicit operator HRGN(IntPtr hrgn) => new HRGN(hrgn);
+
+            public unsafe RECT[] GetRegionRects()
+            {
+                uint regionDataSize = GetRegionData(Handle, 0, IntPtr.Zero);
+                if (regionDataSize == 0)
+                {
+                    return Array.Empty<RECT>();
+                }
+
+                byte[] buffer = ArrayPool<byte>.Shared.Rent((int)regionDataSize);
+
+                fixed (byte* b = buffer)
+                {
+                    if (GetRegionData(Handle, regionDataSize, (IntPtr)b) != regionDataSize)
+                    {
+                        return Array.Empty<RECT>();
+                    }
+
+                    RECT[] result = RGNDATAHEADER.GetRegionRects((RGNDATAHEADER*)b);
+                    ArrayPool<byte>.Shared.Return(buffer);
+                    return result;
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.OBJ.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.OBJ.cs
new file mode 100644
index 00000000000..9f74d55061f
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.OBJ.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        public enum OBJ : int
+        {
+            PEN = 1,
+            BRUSH = 2,
+            DC = 3,
+            METADC = 4,
+            PAL = 5,
+            FONT = 6,
+            BITMAP = 7,
+            REGION = 8,
+            METAFILE = 9,
+            MEMDC = 10,
+            EXTPEN = 11,
+            ENHMETADC = 12,
+            ENHMETAFILE = 13,
+            COLORSPACE = 14
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.PatBlt.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.PatBlt.cs
new file mode 100644
index 00000000000..51114a6d6c6
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.PatBlt.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true)]
+        public static extern BOOL PatBlt(HDC hdc, int x, int y, int w, int h, ROP rop);
+
+        public static BOOL PatBlt(HandleRef hdc, int x, int y, int w, int h, ROP rop)
+        {
+            BOOL result = PatBlt((HDC)hdc.Handle, x, y, w, h, rop);
+            GC.KeepAlive(hdc.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.ROP.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.ROP.cs
new file mode 100644
index 00000000000..43f0ff48eae
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.ROP.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        public enum ROP : uint
+        {
+            SRCCOPY      = 0x00CC0020, // dest = source
+            SRCPAINT     = 0x00EE0086, // dest = source OR dest
+            SRCAND       = 0x008800C6, // dest = source AND dest
+            SRCINVERT    = 0x00660046, // dest = source XOR dest
+            SRCERASE     = 0x00440328, // dest = source AND (NOT dest)
+            NOTSRCCOPY   = 0x00330008, // dest = (NOT source)
+            NOTSRCERASE  = 0x001100A6, // dest = (NOT src) AND (NOT dest)
+            MERGECOPY    = 0x00C000CA, // dest = (source AND pattern)
+            MERGEPAINT   = 0x00BB0226, // dest = (NOT source) OR dest
+            PATCOPY      = 0x00F00021, // dest = pattern
+            PATPAINT     = 0x00FB0A09, // dest = DPSnoo
+            PATINVERT    = 0x005A0049, // dest = pattern XOR dest
+            DSTINVERT    = 0x00550009, // dest = (NOT dest)
+            BLACKNESS    = 0x00000042, // dest = BLACK
+            WHITENESS    = 0x00FF0062  // dest = WHITE
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.RealizePalette.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.RealizePalette.cs
new file mode 100644
index 00000000000..85303aa96b1
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.RealizePalette.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true)]
+        public static extern uint RealizePalette(IntPtr hdc);
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectObject.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectObject.cs
new file mode 100644
index 00000000000..efe2d753dde
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectObject.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, SetLastError = true, ExactSpelling = true)]
+        public static extern HGDIOBJ SelectObject(HDC hdc, HGDIOBJ h);
+
+        public static HGDIOBJ SelectObject(IHandle<HDC> hdc, HGDIOBJ h)
+        {
+            HGDIOBJ lastObject = SelectObject((HDC)hdc.Handle, h);
+            GC.KeepAlive(hdc);
+            return lastObject;
+        }
+
+        public static HGDIOBJ SelectObject(HandleRef hdc, HGDIOBJ h)
+        {
+            HGDIOBJ lastObject = SelectObject((HDC)hdc.Handle, h);
+            GC.KeepAlive(hdc.Wrapper);
+            return lastObject;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectPalette.cs b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectPalette.cs
new file mode 100644
index 00000000000..baab8127c44
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Gdi32/Interop.SelectPalette.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Gdi32
+    {
+        [DllImport(Libraries.Gdi32, ExactSpelling = true, SetLastError = true)]
+        public static extern IntPtr SelectPalette(IntPtr hdc, IntPtr hPal, BOOL bForceBkgd);
+
+        public static IntPtr SelectPalette(HandleRef hdc, HandleRef hPal, BOOL bForceBkgd)
+        {
+            IntPtr result = SelectPalette(hdc.Handle, hPal.Handle, bForceBkgd);
+            GC.KeepAlive(hdc.Wrapper);
+            GC.KeepAlive(hPal.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/IHandle.cs b/src/System.Windows.Forms.Primitives/src/Interop/IHandle.cs
index aea69585820..af96942d1aa 100644
--- a/src/System.Windows.Forms.Primitives/src/Interop/IHandle.cs
+++ b/src/System.Windows.Forms.Primitives/src/Interop/IHandle.cs
@@ -44,3 +44,8 @@ internal interface IHandle<THandle> where THandle : unmanaged
     /// </remarks>
     object? Wrapper => this;
 }
+
+//internal interface IHandle
+//{
+//    public IntPtr Handle { get; }
+//}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Interop.WindowMessages.cs b/src/System.Windows.Forms.Primitives/src/Interop/Interop.WindowMessages.cs
new file mode 100644
index 00000000000..f9334539dbb
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Interop.WindowMessages.cs
@@ -0,0 +1,252 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    public static class WindowMessages
+    {
+        public const int WM_NULL = 0x0000;
+        public const int WM_CREATE = 0x0001;
+        public const int WM_DELETEITEM = 0x002D;
+        public const int WM_DESTROY = 0x0002;
+        public const int WM_MOVE = 0x0003;
+        public const int WM_SIZE = 0x0005;
+        public const int WM_ACTIVATE = 0x0006;
+        public const int WM_SETFOCUS = 0x0007;
+        public const int WM_KILLFOCUS = 0x0008;
+        public const int WM_ENABLE = 0x000A;
+        public const int WM_SETREDRAW = 0x000B;
+        public const int WM_SETTEXT = 0x000C;
+        public const int WM_GETTEXT = 0x000D;
+        public const int WM_GETTEXTLENGTH = 0x000E;
+        public const int WM_PAINT = 0x000F;
+        public const int WM_CLOSE = 0x0010;
+        public const int WM_QUERYENDSESSION = 0x0011;
+        public const int WM_QUIT = 0x0012;
+        public const int WM_QUERYOPEN = 0x0013;
+        public const int WM_ERASEBKGND = 0x0014;
+        public const int WM_SYSCOLORCHANGE = 0x0015;
+        public const int WM_ENDSESSION = 0x0016;
+        public const int WM_SHOWWINDOW = 0x0018;
+        public const int WM_WININICHANGE = 0x001A;
+        public const int WM_SETTINGCHANGE = 0x001A;
+        public const int WM_DEVMODECHANGE = 0x001B;
+        public const int WM_ACTIVATEAPP = 0x001C;
+        public const int WM_FONTCHANGE = 0x001D;
+        public const int WM_TIMECHANGE = 0x001E;
+        public const int WM_CANCELMODE = 0x001F;
+        public const int WM_SETCURSOR = 0x0020;
+        public const int WM_MOUSEACTIVATE = 0x0021;
+        public const int WM_CHILDACTIVATE = 0x0022;
+        public const int WM_QUEUESYNC = 0x0023;
+        public const int WM_GETMINMAXINFO = 0x0024;
+        public const int WM_PAINTICON = 0x0026;
+        public const int WM_ICONERASEBKGND = 0x0027;
+        public const int WM_NEXTDLGCTL = 0x0028;
+        public const int WM_SPOOLERSTATUS = 0x002A;
+        public const int WM_DRAWITEM = 0x002B;
+        public const int WM_MEASUREITEM = 0x002C;
+        public const int WM_VKEYTOITEM = 0x002E;
+        public const int WM_CHARTOITEM = 0x002F;
+        public const int WM_SETFONT = 0x0030;
+        public const int WM_GETFONT = 0x0031;
+        public const int WM_SETHOTKEY = 0x0032;
+        public const int WM_GETHOTKEY = 0x0033;
+        public const int WM_QUERYDRAGICON = 0x0037;
+        public const int WM_COMPAREITEM = 0x0039;
+        public const int WM_GETOBJECT = 0x003D;
+        public const int WM_COMPACTING = 0x0041;
+        public const int WM_COMMNOTIFY = 0x0044;
+        public const int WM_WINDOWPOSCHANGING = 0x0046;
+        public const int WM_WINDOWPOSCHANGED = 0x0047;
+        public const int WM_POWER = 0x0048;
+        public const int WM_COPYDATA = 0x004A;
+        public const int WM_CANCELJOURNAL = 0x004B;
+        public const int WM_NOTIFY = 0x004E;
+        public const int WM_INPUTLANGCHANGEREQUEST = 0x0050;
+        public const int WM_INPUTLANGCHANGE = 0x0051;
+        public const int WM_TCARD = 0x0052;
+        public const int WM_HELP = 0x0053;
+        public const int WM_USERCHANGED = 0x0054;
+        public const int WM_NOTIFYFORMAT = 0x0055;
+        public const int WM_CONTEXTMENU = 0x007B;
+        public const int WM_STYLECHANGING = 0x007C;
+        public const int WM_STYLECHANGED = 0x007D;
+        public const int WM_DISPLAYCHANGE = 0x007E;
+        public const int WM_GETICON = 0x007F;
+        public const int WM_SETICON = 0x0080;
+        public const int WM_NCCREATE = 0x0081;
+        public const int WM_NCDESTROY = 0x0082;
+        public const int WM_NCCALCSIZE = 0x0083;
+        public const int WM_NCHITTEST = 0x0084;
+        public const int WM_NCPAINT = 0x0085;
+        public const int WM_NCACTIVATE = 0x0086;
+        public const int WM_GETDLGCODE = 0x0087;
+        public const int WM_NCMOUSEMOVE = 0x00A0;
+        public const int WM_NCMOUSELEAVE = 0x02A2;
+        public const int WM_NCLBUTTONDOWN = 0x00A1;
+        public const int WM_NCLBUTTONUP = 0x00A2;
+        public const int WM_NCLBUTTONDBLCLK = 0x00A3;
+        public const int WM_NCRBUTTONDOWN = 0x00A4;
+        public const int WM_NCRBUTTONUP = 0x00A5;
+        public const int WM_NCRBUTTONDBLCLK = 0x00A6;
+        public const int WM_NCMBUTTONDOWN = 0x00A7;
+        public const int WM_NCMBUTTONUP = 0x00A8;
+        public const int WM_NCMBUTTONDBLCLK = 0x00A9;
+        public const int WM_NCXBUTTONDOWN = 0x00AB;
+        public const int WM_NCXBUTTONUP = 0x00AC;
+        public const int WM_NCXBUTTONDBLCLK = 0x00AD;
+        public const int WM_KEYFIRST = 0x0100;
+        public const int WM_KEYDOWN = 0x0100;
+        public const int WM_KEYUP = 0x0101;
+        public const int WM_CHAR = 0x0102;
+        public const int WM_DEADCHAR = 0x0103;
+        public const int WM_CTLCOLOR = 0x0019;
+        public const int WM_SYSKEYDOWN = 0x0104;
+        public const int WM_SYSKEYUP = 0x0105;
+        public const int WM_SYSCHAR = 0x0106;
+        public const int WM_SYSDEADCHAR = 0x0107;
+        public const int WM_KEYLAST = 0x0108;
+        public const int WM_IME_STARTCOMPOSITION = 0x010D;
+        public const int WM_IME_ENDCOMPOSITION = 0x010E;
+        public const int WM_IME_COMPOSITION = 0x010F;
+        public const int WM_IME_KEYLAST = 0x010F;
+        public const int WM_INITDIALOG = 0x0110;
+        public const int WM_COMMAND = 0x0111;
+        public const int WM_SYSCOMMAND = 0x0112;
+        public const int WM_TIMER = 0x0113;
+        public const int WM_HSCROLL = 0x0114;
+        public const int WM_VSCROLL = 0x0115;
+        public const int WM_INITMENU = 0x0116;
+        public const int WM_INITMENUPOPUP = 0x0117;
+        public const int WM_MENUSELECT = 0x011F;
+        public const int WM_MENUCHAR = 0x0120;
+        public const int WM_ENTERIDLE = 0x0121;
+        public const int WM_UNINITMENUPOPUP = 0x0125;
+        public const int WM_CHANGEUISTATE = 0x0127;
+        public const int WM_UPDATEUISTATE = 0x0128;
+        public const int WM_QUERYUISTATE = 0x0129;
+        public const int WM_CTLCOLORMSGBOX = 0x0132;
+        public const int WM_CTLCOLOREDIT = 0x0133;
+        public const int WM_CTLCOLORLISTBOX = 0x0134;
+        public const int WM_CTLCOLORBTN = 0x0135;
+        public const int WM_CTLCOLORDLG = 0x0136;
+        public const int WM_CTLCOLORSCROLLBAR = 0x0137;
+        public const int WM_CTLCOLORSTATIC = 0x0138;
+        public const int WM_MOUSEFIRST = 0x0200;
+        public const int WM_MOUSEMOVE = 0x0200;
+        public const int WM_LBUTTONDOWN = 0x0201;
+        public const int WM_LBUTTONUP = 0x0202;
+        public const int WM_LBUTTONDBLCLK = 0x0203;
+        public const int WM_RBUTTONDOWN = 0x0204;
+        public const int WM_RBUTTONUP = 0x0205;
+        public const int WM_RBUTTONDBLCLK = 0x0206;
+        public const int WM_MBUTTONDOWN = 0x0207;
+        public const int WM_MBUTTONUP = 0x0208;
+        public const int WM_MBUTTONDBLCLK = 0x0209;
+        public const int WM_NCMOUSEHOVER = 0x02A0;
+        public const int WM_XBUTTONDOWN = 0x020B;
+        public const int WM_XBUTTONUP = 0x020C;
+        public const int WM_XBUTTONDBLCLK = 0x020D;
+        public const int WM_MOUSEWHEEL = 0x020A;
+        public const int WM_MOUSELAST = 0x020A;
+        public const int WM_PARENTNOTIFY = 0x0210;
+        public const int WM_ENTERMENULOOP = 0x0211;
+        public const int WM_EXITMENULOOP = 0x0212;
+        public const int WM_NEXTMENU = 0x0213;
+        public const int WM_SIZING = 0x0214;
+        public const int WM_CAPTURECHANGED = 0x0215;
+        public const int WM_MOVING = 0x0216;
+        public const int WM_POWERBROADCAST = 0x0218;
+        public const int WM_DEVICECHANGE = 0x0219;
+        public const int WM_IME_SETCONTEXT = 0x0281;
+        public const int WM_IME_NOTIFY = 0x0282;
+        public const int WM_IME_CONTROL = 0x0283;
+        public const int WM_IME_COMPOSITIONFULL = 0x0284;
+        public const int WM_IME_SELECT = 0x0285;
+        public const int WM_IME_CHAR = 0x0286;
+        public const int WM_IME_KEYDOWN = 0x0290;
+        public const int WM_IME_KEYUP = 0x0291;
+        public const int WM_MDICREATE = 0x0220;
+        public const int WM_MDIDESTROY = 0x0221;
+        public const int WM_MDIACTIVATE = 0x0222;
+        public const int WM_MDIRESTORE = 0x0223;
+        public const int WM_MDINEXT = 0x0224;
+        public const int WM_MDIMAXIMIZE = 0x0225;
+        public const int WM_MDITILE = 0x0226;
+        public const int WM_MDICASCADE = 0x0227;
+        public const int WM_MDIICONARRANGE = 0x0228;
+        public const int WM_MDIGETACTIVE = 0x0229;
+        public const int WM_MDISETMENU = 0x0230;
+        public const int WM_ENTERSIZEMOVE = 0x0231;
+        public const int WM_EXITSIZEMOVE = 0x0232;
+        public const int WM_DROPFILES = 0x0233;
+        public const int WM_MDIREFRESHMENU = 0x0234;
+        public const int WM_MOUSEHOVER = 0x02A1;
+        public const int WM_MOUSELEAVE = 0x02A3;
+        public const int WM_DPICHANGED = 0x02E0;
+        public const int WM_GETDPISCALEDSIZE = 0x02E1;
+        public const int WM_DPICHANGED_BEFOREPARENT = 0x02E2;
+        public const int WM_DPICHANGED_AFTERPARENT = 0x02E3;
+        public const int WM_CUT = 0x0300;
+        public const int WM_COPY = 0x0301;
+        public const int WM_PASTE = 0x0302;
+        public const int WM_CLEAR = 0x0303;
+        public const int WM_UNDO = 0x0304;
+        public const int WM_RENDERFORMAT = 0x0305;
+        public const int WM_RENDERALLFORMATS = 0x0306;
+        public const int WM_DESTROYCLIPBOARD = 0x0307;
+        public const int WM_DRAWCLIPBOARD = 0x0308;
+        public const int WM_PAINTCLIPBOARD = 0x0309;
+        public const int WM_VSCROLLCLIPBOARD = 0x030A;
+        public const int WM_SIZECLIPBOARD = 0x030B;
+        public const int WM_ASKCBFORMATNAME = 0x030C;
+        public const int WM_CHANGECBCHAIN = 0x030D;
+        public const int WM_HSCROLLCLIPBOARD = 0x030E;
+        public const int WM_QUERYNEWPALETTE = 0x030F;
+        public const int WM_PALETTEISCHANGING = 0x0310;
+        public const int WM_PALETTECHANGED = 0x0311;
+        public const int WM_HOTKEY = 0x0312;
+        public const int WM_PRINT = 0x0317;
+        public const int WM_PRINTCLIENT = 0x0318;
+        public const int WM_THEMECHANGED = 0x031A;
+        public const int WM_HANDHELDFIRST = 0x0358;
+        public const int WM_HANDHELDLAST = 0x035F;
+        public const int WM_AFXFIRST = 0x0360;
+        public const int WM_AFXLAST = 0x037F;
+        public const int WM_PENWINFIRST = 0x0380;
+        public const int WM_PENWINLAST = 0x038F;
+        public const int WM_APP = unchecked((int)0x8000);
+        public const int WM_USER = 0x0400;
+        public const int WM_REFLECT = WM_USER + 0x1C00;
+
+        public const uint TTM_ACTIVATE = WM_USER + 1;
+        public const uint TTM_SETDELAYTIME = WM_USER + 3;
+        public const uint TTM_RELAYEVENT = WM_USER + 7;
+        public const uint TTM_WINDOWFROMPOINT = WM_USER + 16;
+        public const uint TTM_TRACKACTIVATE = WM_USER + 17;
+        public const uint TTM_TRACKPOSITION = WM_USER + 18;
+        public const uint TTM_SETTIPBKCOLOR = WM_USER + 19;
+        public const uint TTM_SETTIPTEXTCOLOR = WM_USER + 20;
+        public const uint TTM_GETDELAYTIME = WM_USER + 21;
+        public const uint TTM_GETTIPBKCOLOR = WM_USER + 22;
+        public const uint TTM_GETTIPTEXTCOLOR = WM_USER + 23;
+        public const uint TTM_SETMAXTIPWIDTH = WM_USER + 24;
+        public const uint TTM_POP = WM_USER + 28;
+        public const uint TTM_UPDATE = WM_USER + 29;
+        public const uint TTM_GETBUBBLESIZE = WM_USER + 30;
+        public const uint TTM_ADJUSTRECT = WM_USER + 31;
+        public const uint TTM_SETTITLEW = WM_USER + 33;
+        public const uint TTM_ADDTOOLW = WM_USER + 50;
+        public const uint TTM_DELTOOLW = WM_USER + 51;
+        public const uint TTM_NEWTOOLRECTW = WM_USER + 52;
+        public const uint TTM_GETTOOLINFOW = WM_USER + 53;
+        public const uint TTM_SETTOOLINFOW = WM_USER + 54;
+        public const uint TTM_HITTESTW = WM_USER + 55;
+        public const uint TTM_GETTEXTW = WM_USER + 56;
+        public const uint TTM_UPDATETIPTEXTW = WM_USER + 57;
+        public const uint TTM_ENUMTOOLSW = WM_USER + 58;
+        public const uint TTM_GETCURRENTTOOLW = WM_USER + 59;
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.DispatchID.cs b/src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.DispatchID.cs
new file mode 100644
index 00000000000..17c0c500e94
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/Ole32/Interop.DispatchID.cs
@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class Ole32
+    {
+        public enum DispatchID : int
+        {
+            VALUE = unchecked((int)0x0),
+            UNKNOWN = unchecked((int)0xFFFFFFFF),
+            MEMBERID_NIL = UNKNOWN,
+            PROPERTYPUT = unchecked((int)0xFFFFFFFD),
+            AUTOSIZE = unchecked((int)0xFFFFFE0C),
+            BACKCOLOR = unchecked((int)0xFFFFFE0B),
+            BACKSTYLE = unchecked((int)0xFFFFFE0A),
+            BORDERCOLOR = unchecked((int)0xFFFFFE09),
+            BORDERSTYLE = unchecked((int)0xFFFFFE08),
+            BORDERWIDTH = unchecked((int)0xFFFFFE07),
+            DRAWMODE = unchecked((int)0xFFFFFE05),
+            DRAWSTYLE = unchecked((int)0xFFFFFE04),
+            DRAWWIDTH = unchecked((int)0xFFFFFE03),
+            FILLCOLOR = unchecked((int)0xFFFFFE02),
+            FILLSTYLE = unchecked((int)0xFFFFFE01),
+            FONT = unchecked((int)0xFFFFFE00),
+            FORECOLOR = unchecked((int)0xFFFFFDFF),
+            ENABLED = unchecked((int)0xFFFFFDFE),
+            HWND = unchecked((int)0xFFFFFDFD),
+            TABSTOP = unchecked((int)0xFFFFFDFC),
+            TEXT = unchecked((int)0xFFFFFDFB),
+            CAPTION = unchecked((int)0xFFFFFDFA),
+            BORDERVISIBLE = unchecked((int)0xFFFFFDF9),
+            APPEARANCE = unchecked((int)0xFFFFFDF8),
+            MOUSEPOINTER = unchecked((int)0xFFFFFDF7),
+            MOUSEICON = unchecked((int)0xFFFFFDF6),
+            PICTURE = unchecked((int)0xFFFFFDF5),
+            VALID = unchecked((int)0xFFFFFDF4),
+            READYSTATE = unchecked((int)0xFFFFFDF3),
+            REFRESH = unchecked((int)0xFFFFFDDA),
+            DOCLICK = unchecked((int)0xFFFFFDD9),
+            ABOUTBOX = unchecked((int)0xFFFFFDD8),
+            CLICK = unchecked((int)0xFFFFFDA8),
+            DBLCLICK = unchecked((int)0xFFFFFDA7),
+            KEYDOWN = unchecked((int)0xFFFFFDA6),
+            KEYPRESS = unchecked((int)0xFFFFFDA5),
+            KEYUP = unchecked((int)0xFFFFFDA4),
+            MOUSEDOWN = unchecked((int)0xFFFFFDA3),
+            MOUSEMOVE = unchecked((int)0xFFFFFDA2),
+            MOUSEUP = unchecked((int)0xFFFFFDA1),
+            ERROREVENT = unchecked((int)0xFFFFFDA0),
+            RIGHTTOLEFT = unchecked((int)0xFFFFFD9D),
+            READYSTATECHANGE = unchecked((int)0xFFFFFD9F),
+            AMBIENT_BACKCOLOR = unchecked((int)0xFFFFFD43),
+            AMBIENT_DISPLAYNAME = unchecked((int)0xFFFFFD42),
+            AMBIENT_FONT = unchecked((int)0xFFFFFD41),
+            AMBIENT_FORECOLOR = unchecked((int)0xFFFFFD40),
+            AMBIENT_LOCALEID = unchecked((int)0xFFFFFD3F),
+            AMBIENT_MESSAGEREFLECT = unchecked((int)0xFFFFFD3E),
+            AMBIENT_SCALEUNITS = unchecked((int)0xFFFFFD3D),
+            AMBIENT_TEXTALIGN = unchecked((int)0xFFFFFD3C),
+            AMBIENT_USERMODE = unchecked((int)0xFFFFFD3B),
+            AMBIENT_UIDEAD = unchecked((int)0xFFFFFD3A),
+            AMBIENT_SHOWGRABHANDLES = unchecked((int)0xFFFFFD39),
+            AMBIENT_SHOWHATCHING = unchecked((int)0xFFFFFD38),
+            AMBIENT_DISPLAYASDEFAULT = unchecked((int)0xFFFFFD37),
+            AMBIENT_SUPPORTSMNEMONICS = unchecked((int)0xFFFFFD36),
+            AMBIENT_AUTOCLIP = unchecked((int)0xFFFFFD35),
+            AMBIENT_APPEARANCE = unchecked((int)0xFFFFFD34),
+            AMBIENT_PALETTE = unchecked((int)0xFFFFFD2A),
+            AMBIENT_TRANSFERPRIORITY = unchecked((int)0xFFFFFD28),
+            AMBIENT_RIGHTTOLEFT = unchecked((int)0xFFFFFD24),
+            Name = unchecked((int)0xFFFFFCE0),
+            Delete = unchecked((int)0xFFFFFCDF),
+            Object = unchecked((int)0xFFFFFCDE),
+            Parent = unchecked((int)0xFFFFFCDD),
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreateMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreateMenu.cs
new file mode 100644
index 00000000000..a852bee1e20
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreateMenu.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern IntPtr CreateMenu();
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreatePopupMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreatePopupMenu.cs
new file mode 100644
index 00000000000..0073e0ccc36
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.CreatePopupMenu.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern IntPtr CreatePopupMenu();
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DCX.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DCX.cs
new file mode 100644
index 00000000000..a2da4cae69f
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DCX.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum DCX : uint
+        {
+            WINDOW              = 0x00000001,
+            CACHE               = 0x00000002,
+            NORESETATTRS        = 0x00000004,
+            CLIPCHILDREN        = 0x00000008,
+            CLIPSIBLINGS        = 0x00000010,
+            PARENTCLIP          = 0x00000020,
+            EXCLUDERGN          = 0x00000040,
+            INTERSECTRGN        = 0x00000080,
+            EXCLUDEUPDATE       = 0x00000100,
+            INTERSECTUPDATE     = 0x00000200,
+            LOCKWINDOWUPDATE    = 0x00000400,
+            USESTYLE            = 0x00010000,
+            VALIDATE            = 0x00200000,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DRAWITEMSTRUCT.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DRAWITEMSTRUCT.cs
new file mode 100644
index 00000000000..d0e59d5c1bd
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DRAWITEMSTRUCT.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        public struct DRAWITEMSTRUCT
+        {
+            public ODT CtlType;
+            public uint CtlID;
+            public uint itemID;
+            public ODA itemAction;
+            public ODS itemState;
+            public IntPtr hwndItem;
+            public IntPtr hDC;
+            public RECT rcItem;
+            public IntPtr itemData;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DestroyMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DestroyMenu.cs
new file mode 100644
index 00000000000..8641e30cea9
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.DestroyMenu.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern BOOL DestroyMenu(IntPtr hMenu);
+
+        public static BOOL DestroyMenu(HandleRef hMenu)
+        {
+            BOOL result = DestroyMenu(hMenu.Handle);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetDCEx.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetDCEx.cs
new file mode 100644
index 00000000000..13139da3317
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetDCEx.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern Gdi32.HDC GetDCEx(HWND hWnd, IntPtr hrgnClip, DCX flags);
+
+        public static Gdi32.HDC GetDCEx(IHandle<HWND> hWnd, IntPtr hrgnClip, DCX flags)
+        {
+            Gdi32.HDC result = GetDCEx(hWnd.Handle, hrgnClip, flags);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenu.cs
new file mode 100644
index 00000000000..8135d735542
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenu.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern IntPtr GetMenu(IntPtr hWnd);
+
+        public static IntPtr GetMenu(IHandle<HWND> hWnd)
+        {
+            IntPtr result = GetMenu((IntPtr)hWnd.Handle);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemCount.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemCount.cs
new file mode 100644
index 00000000000..f9a8ef01e54
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemCount.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern int GetMenuItemCount(IntPtr hMenu);
+
+        public static int GetMenuItemCount(HandleRef hMenu)
+        {
+            int result = GetMenuItemCount(hMenu.Handle);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemID.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemID.cs
new file mode 100644
index 00000000000..46a65d700b4
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetMenuItemID.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern int GetMenuItemID(IntPtr hMenu, int nPos);
+
+        public static int GetMenuItemID(HandleRef hMenu, int nPos)
+        {
+            int result = GetMenuItemID(hMenu.Handle, nPos);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetSubMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetSubMenu.cs
new file mode 100644
index 00000000000..43be071c4d0
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.GetSubMenu.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern IntPtr GetSubMenu(IntPtr hMenu, int nPos);
+
+        public static IntPtr GetSubMenu(HandleRef hMenu, int nPos)
+        {
+            IntPtr result = GetSubMenu(hMenu.Handle, nPos);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MEASUREITEMSTRUCT.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MEASUREITEMSTRUCT.cs
new file mode 100644
index 00000000000..bd91a20092e
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MEASUREITEMSTRUCT.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        public struct MEASUREITEMSTRUCT
+        {
+            public ODT CtlType;
+            public uint CtlID;
+            public uint itemID;
+            public uint itemWidth;
+            public uint itemHeight;
+            public IntPtr itemData;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MF.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MF.cs
new file mode 100644
index 00000000000..d35bd253fb0
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.MF.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum MF : uint
+        {
+            INSERT = 0x00000000,
+            CHANGE = 0x00000080,
+            APPEND = 0x00000100,
+            DELETE = 0x00000200,
+            REMOVE = 0x00001000,
+            BYCOMMAND = 0x00000000,
+            BYPOSITION = 0x00000400,
+            SEPARATOR = 0x00000800,
+            ENABLED = 0x00000000,
+            GRAYED = 0x00000001,
+            DISABLED = 0x00000002,
+            UNCHECKED = 0x00000000,
+            CHECKED = 0x00000008,
+            USECHECKBITMAPS = 0x00000200,
+            STRING = 0x00000000,
+            BITMAP = 0x00000004,
+            OWNERDRAW = 0x00000100,
+            POPUP = 0x00000010,
+            MENUBARBREAK = 0x00000020,
+            MENUBREAK = 0x00000040,
+            UNHILITE = 0x00000000,
+            HILITE = 0x00000080,
+            DEFAULT = 0x00001000,
+            SYSMENU = 0x00002000,
+            HELP = 0x00004000,
+            RIGHTJUSTIFY = 0x00004000,
+            MOUSESELECT = 0x00008000,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODA.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODA.cs
new file mode 100644
index 00000000000..6b6583f93fb
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODA.cs
@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum ODA : uint
+        {
+            DRAWENTIRE = 0x1,
+            SELECT = 0x2,
+            FOCUS = 0x4,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODT.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODT.cs
new file mode 100644
index 00000000000..dbf5d8036cb
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ODT.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        public enum ODT : uint
+        {
+            MENU = 1,
+            LISTBOX = 2,
+            COMBOBOX = 3,
+            BUTTON = 4,
+            STATIC = 5,
+            HEADER = 100,
+            TAB = 101,
+            LISTVIEW = 102
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ReleaseDC.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ReleaseDC.cs
new file mode 100644
index 00000000000..79b7bfb09c9
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ReleaseDC.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern int ReleaseDC(IntPtr hWnd, Gdi32.HDC hDC);
+
+        public static int ReleaseDC(HandleRef hWnd, Gdi32.HDC hDC)
+        {
+            int result = ReleaseDC(hWnd.Handle, hDC);
+            GC.KeepAlive(hWnd.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.RemoveMenuItem.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.RemoveMenuItem.cs
new file mode 100644
index 00000000000..9b1e4d73fc1
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.RemoveMenuItem.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern BOOL RemoveMenu(IntPtr hMenu, uint uPosition, MF uFlags);
+
+        public static BOOL RemoveMenu(HandleRef hMenu, uint uPosition, MF uFlags)
+        {
+            BOOL result = RemoveMenu(hMenu.Handle, uPosition, uFlags);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SWP.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SWP.cs
new file mode 100644
index 00000000000..63c4fc1208e
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SWP.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum SWP : uint
+        {
+            NOSIZE = 0x0001,
+            NOMOVE = 0x0002,
+            NOZORDER = 0x0004,
+            NOREDRAW = 0x0008,
+            NOACTIVATE = 0x0010,
+            FRAMECHANGED = 0x0020,
+            SHOWWINDOW = 0x0040,
+            HIDEWINDOW = 0x0080,
+            NOCOPYBITS = 0x0100,
+            NOOWNERZORDER = 0x0200,
+            NOSENDCHANGING = 0x0400,
+            DEFERERASE = 0x2000,
+            ASYNCWINDOWPOS = 0x4000,
+            DRAWFRAME = FRAMECHANGED,
+            NOREPOSITION = NOOWNERZORDER
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollSW.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollSW.cs
new file mode 100644
index 00000000000..ec7facffc87
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollSW.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum ScrollSW : uint
+        {
+            SCROLLCHILDREN = 0x0001,
+            INVALIDATE = 0x0002,
+            ERASE = 0x0004,
+            SMOOTHSCROLL = 0x0010,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindow.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindow.cs
new file mode 100644
index 00000000000..5b6fa0b420a
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindow.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        private static extern BOOL ScrollWindow(HWND hWnd, int nXAmount, int nYAmount, ref RECT rectScrollRegion, ref RECT rectClip);
+
+        public static BOOL ScrollWindow(IHandle<HWND> hWnd, int nXAmount, int nYAmount, ref RECT rectScrollRegion, ref RECT rectClip)
+        {
+            BOOL result = ScrollWindow(hWnd.Handle, nXAmount, nYAmount, ref rectScrollRegion, ref rectClip);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindowEx.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindowEx.cs
new file mode 100644
index 00000000000..c01cca0546a
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.ScrollWindowEx.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public unsafe static extern int ScrollWindowEx(
+            IntPtr hWnd,
+            int dx,
+            int dy,
+            RECT* prcScroll,
+            RECT* prcClip,
+            IntPtr hrgnUpdate,
+            RECT* prcUpdate,
+            ScrollSW flags);
+
+        public unsafe static int ScrollWindowEx(
+            IHandle<IntPtr> hWnd,
+            int dx,
+            int dy,
+            RECT* prcScroll,
+            RECT* prcClip,
+            IntPtr hrgnUpdate,
+            RECT* prcUpdate,
+            ScrollSW flags)
+        {
+            int result = ScrollWindowEx(hWnd.Handle, dx, dy, prcScroll, prcClip, hrgnUpdate, prcUpdate, flags);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SendMessageW.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SendMessageW.cs
new file mode 100644
index 00000000000..0b4e69ea028
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SendMessageW.cs
@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern IntPtr SendMessageW(
+            IntPtr hWnd,
+            WM Msg,
+            IntPtr wParam = default,
+            IntPtr lParam = default);
+
+        public static IntPtr SendMessageW(
+            HandleRef hWnd,
+            WM Msg,
+            IntPtr wParam = default,
+            IntPtr lParam = default)
+        {
+            IntPtr result = SendMessageW(hWnd.Handle, Msg, wParam, lParam);
+            GC.KeepAlive(hWnd.Wrapper);
+            return result;
+        }
+
+        public static IntPtr SendMessageW(
+            IHandle<HWND> hWnd,
+            WM Msg,
+            IntPtr wParam = default,
+            IntPtr lParam = default)
+        {
+            IntPtr result = SendMessageW((IntPtr)hWnd.Handle, Msg, wParam, lParam);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+
+        public unsafe static IntPtr SendMessageW(
+            IntPtr hWnd,
+            WM Msg,
+            IntPtr wParam,
+            string lParam)
+        {
+            fixed (char* c = lParam)
+            {
+                return SendMessageW(hWnd, Msg, wParam, (IntPtr)(void*)c);
+            }
+        }
+
+        public unsafe static IntPtr SendMessageW(
+            HandleRef hWnd,
+            WM Msg,
+            IntPtr wParam,
+            string lParam)
+        {
+            fixed (char* c = lParam)
+            {
+                return SendMessageW(hWnd, Msg, wParam, (IntPtr)(void*)c);
+            }
+        }
+
+        public unsafe static IntPtr SendMessageW(
+            IHandle<HWND> hWnd,
+            WM Msg,
+            IntPtr wParam,
+            string lParam)
+        {
+            fixed (char* c = lParam)
+            {
+                return SendMessageW(hWnd, Msg, wParam, (IntPtr)(void*)c);
+            }
+        }
+
+        public unsafe static IntPtr SendMessageW<T>(
+            IntPtr hWnd,
+            WM Msg,
+            IntPtr wParam,
+            ref T lParam) where T : unmanaged
+        {
+            fixed (void* l = &lParam)
+            {
+                return SendMessageW(hWnd, Msg, wParam, (IntPtr)l);
+            }
+        }
+
+        public unsafe static IntPtr SendMessageW<T>(
+            IHandle<HWND> hWnd,
+            WM Msg,
+            IntPtr wParam,
+            ref T lParam) where T : unmanaged
+        {
+            fixed (void* l = &lParam)
+            {
+                return SendMessageW(hWnd, Msg, wParam, (IntPtr)l);
+            }
+        }
+
+        public unsafe static IntPtr SendMessageW<TWParam, TLParam>(
+            IHandle<HWND> hWnd,
+            WM Msg,
+            ref TWParam wParam,
+            ref TLParam lParam)
+            where TWParam : unmanaged
+            where TLParam : unmanaged
+        {
+            fixed (void* w = &wParam, l = &lParam)
+            {
+                return SendMessageW(hWnd, Msg, (IntPtr)w, (IntPtr)l);
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenu.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenu.cs
new file mode 100644
index 00000000000..8db6f6421e8
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenu.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public extern static BOOL SetMenu(IntPtr hWnd, IntPtr hMenu);
+
+        public static BOOL SetMenu(IHandle<HWND> hWnd, IntPtr hMenu)
+        {
+            BOOL result = SetMenu((IntPtr)hWnd.Handle, hMenu);
+            GC.KeepAlive(hWnd);
+            return result;
+        }
+
+        public static BOOL SetMenu(IHandle<HWND> hWnd, HandleRef hMenu)
+        {
+            BOOL result = SetMenu((IntPtr)hWnd.Handle, hMenu.Handle);
+            GC.KeepAlive(hWnd);
+            GC.KeepAlive(hMenu.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenuDefaultItem.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenuDefaultItem.cs
new file mode 100644
index 00000000000..9825fed11e2
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetMenuDefaultItem.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern BOOL SetMenuDefaultItem(IntPtr hwnd, int uItem, BOOL fByPos);
+
+        public static BOOL SetMenuDefaultItem(HandleRef hwnd, int uItem, BOOL fByPos)
+        {
+            BOOL result = SetMenuDefaultItem(hwnd.Handle, uItem, fByPos);
+            GC.KeepAlive(hwnd.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetWindowPos.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetWindowPos.cs
new file mode 100644
index 00000000000..3105988f420
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.SetWindowPos.cs
@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        public static IntPtr HWND_TOP = (IntPtr)0;
+        public static IntPtr HWND_BOTTOM = (IntPtr)1;
+        public static IntPtr HWND_TOPMOST = (IntPtr)(-1);
+        public static IntPtr HWND_NOTOPMOST = (IntPtr)(-2);
+        public static IntPtr HWND_MESSAGE = (IntPtr)(-3);
+
+        [DllImport(Libraries.User32, ExactSpelling = true)]
+        public static extern BOOL SetWindowPos(
+            IntPtr hWnd,
+            IntPtr hWndInsertAfter,
+            int x = 0,
+            int y = 0,
+            int cx = 0,
+            int cy = 0,
+            SWP flags = (SWP)0);
+
+        public static BOOL SetWindowPos(
+            HandleRef hWnd,
+            IntPtr hWndInsertAfter,
+            int x = 0,
+            int y = 0,
+            int cx = 0,
+            int cy = 0,
+            SWP flags = (SWP)0)
+        {
+            BOOL result = SetWindowPos(hWnd.Handle, hWndInsertAfter, x, y, cx, cy, flags);
+            GC.KeepAlive(hWnd.Wrapper);
+            return result;
+        }
+
+        public static BOOL SetWindowPos(
+            HandleRef hWnd,
+            HandleRef hWndInsertAfter,
+            int x = 0,
+            int y = 0,
+            int cx = 0,
+            int cy = 0,
+            SWP flags = (SWP)0)
+        {
+            BOOL result = SetWindowPos(hWnd.Handle, hWndInsertAfter.Handle, x, y, cx, cy, flags);
+            GC.KeepAlive(hWnd.Wrapper);
+            GC.KeepAlive(hWndInsertAfter.Wrapper);
+            return result;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.WM.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.WM.cs
new file mode 100644
index 00000000000..ef5220101fe
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/Interop.WM.cs
@@ -0,0 +1,289 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        public enum WM : uint
+        {
+            NULL = 0x0000,
+            CREATE = 0x0001,
+            DESTROY = 0x0002,
+            MOVE = 0x0003,
+            SIZE = 0x0005,
+            ACTIVATE = 0x0006,
+            SETFOCUS = 0x0007,
+            KILLFOCUS = 0x0008,
+            ENABLE = 0x000A,
+            SETREDRAW = 0x000B,
+            SETTEXT = 0x000C,
+            GETTEXT = 0x000D,
+            GETTEXTLENGTH = 0x000E,
+            PAINT = 0x000F,
+            CLOSE = 0x0010,
+            QUERYENDSESSION = 0x0011,
+            QUERYOPEN = 0x0013,
+            ENDSESSION = 0x0016,
+            QUIT = 0x0012,
+            ERASEBKGND = 0x0014,
+            SYSCOLORCHANGE = 0x0015,
+            SHOWWINDOW = 0x0018,
+            CTLCOLOR = 0x0019,
+            SETTINGCHANGE = 0x001A,
+            WININICHANGE = 0x001A,
+            DEVMODECHANGE = 0x001B,
+            ACTIVATEAPP = 0x001C,
+            FONTCHANGE = 0x001D,
+            TIMECHANGE = 0x001E,
+            CANCELMODE = 0x001F,
+            SETCURSOR = 0x0020,
+            MOUSEACTIVATE = 0x0021,
+            CHILDACTIVATE = 0x0022,
+            QUEUESYNC = 0x0023,
+            GETMINMAXINFO = 0x0024,
+            PAINTICON = 0x0026,
+            ICONERASEBKGND = 0x0027,
+            NEXTDLGCTL = 0x0028,
+            SPOOLERSTATUS = 0x002A,
+            DRAWITEM = 0x002B,
+            MEASUREITEM = 0x002C,
+            DELETEITEM = 0x002D,
+            VKEYTOITEM = 0x002E,
+            CHARTOITEM = 0x002F,
+            SETFONT = 0x0030,
+            GETFONT = 0x0031,
+            SETHOTKEY = 0x0032,
+            GETHOTKEY = 0x0033,
+            QUERYDRAGICON = 0x0037,
+            COMPAREITEM = 0x0039,
+            GETOBJECT = 0x003D,
+            COMPACTING = 0x0041,
+            COMMNOTIFY = 0x0044,
+            WINDOWPOSCHANGING = 0x0046,
+            WINDOWPOSCHANGED = 0x0047,
+            POWER = 0x0048,
+            COPYDATA = 0x004A,
+            CANCELJOURNAL = 0x004B,
+            NOTIFY = 0x004E,
+            INPUTLANGCHANGEREQUEST = 0x0050,
+            INPUTLANGCHANGE = 0x0051,
+            TCARD = 0x0052,
+            HELP = 0x0053,
+            USERCHANGED = 0x0054,
+            NOTIFYFORMAT = 0x0055,
+            CONTEXTMENU = 0x007B,
+            STYLECHANGING = 0x007C,
+            STYLECHANGED = 0x007D,
+            DISPLAYCHANGE = 0x007E,
+            GETICON = 0x007F,
+            SETICON = 0x0080,
+            NCCREATE = 0x0081,
+            NCDESTROY = 0x0082,
+            NCCALCSIZE = 0x0083,
+            NCHITTEST = 0x0084,
+            NCPAINT = 0x0085,
+            NCACTIVATE = 0x0086,
+            GETDLGCODE = 0x0087,
+            SYNCPAINT = 0x0088,
+            NCMOUSEMOVE = 0x00A0,
+            NCLBUTTONDOWN = 0x00A1,
+            NCLBUTTONUP = 0x00A2,
+            NCLBUTTONDBLCLK = 0x00A3,
+            NCRBUTTONDOWN = 0x00A4,
+            NCRBUTTONUP = 0x00A5,
+            NCRBUTTONDBLCLK = 0x00A6,
+            NCMBUTTONDOWN = 0x00A7,
+            NCMBUTTONUP = 0x00A8,
+            NCMBUTTONDBLCLK = 0x00A9,
+            NCXBUTTONDOWN = 0x00AB,
+            NCXBUTTONUP = 0x00AC,
+            NCXBUTTONDBLCLK = 0x00AD,
+            INPUT_DEVICE_CHANGE = 0x00FE,
+            INPUT = 0x00FF,
+            KEYFIRST = 0x0100,
+            KEYDOWN = 0x0100,
+            KEYUP = 0x0101,
+            CHAR = 0x0102,
+            DEADCHAR = 0x0103,
+            SYSKEYDOWN = 0x0104,
+            SYSKEYUP = 0x0105,
+            SYSCHAR = 0x0106,
+            SYSDEADCHAR = 0x0107,
+            UNICHAR = 0x0109,
+            KEYLAST = 0x0109,
+            IME_STARTCOMPOSITION = 0x010D,
+            IME_ENDCOMPOSITION = 0x010E,
+            IME_COMPOSITION = 0x010F,
+            IME_KEYLAST = 0x010F,
+            INITDIALOG = 0x0110,
+            COMMAND = 0x0111,
+            SYSCOMMAND = 0x0112,
+            TIMER = 0x0113,
+            HSCROLL = 0x0114,
+            VSCROLL = 0x0115,
+            INITMENU = 0x0116,
+            INITMENUPOPUP = 0x0117,
+            GESTURE = 0x0119,
+            GESTURENOTIFY = 0x011A,
+            MENUSELECT = 0x011F,
+            MENUCHAR = 0x0120,
+            ENTERIDLE = 0x0121,
+            MENURBUTTONUP = 0x0122,
+            MENUDRAG = 0x0123,
+            MENUGETOBJECT = 0x0124,
+            UNINITMENUPOPUP = 0x0125,
+            MENUCOMMAND = 0x0126,
+            CHANGEUISTATE = 0x0127,
+            UPDATEUISTATE = 0x0128,
+            QUERYUISTATE = 0x0129,
+            CTLCOLORMSGBOX = 0x0132,
+            CTLCOLOREDIT = 0x0133,
+            CTLCOLORLISTBOX = 0x0134,
+            CTLCOLORBTN = 0x0135,
+            CTLCOLORDLG = 0x0136,
+            CTLCOLORSCROLLBAR = 0x0137,
+            CTLCOLORSTATIC = 0x0138,
+            MOUSEFIRST = 0x0200,
+            MOUSEMOVE = 0x0200,
+            LBUTTONDOWN = 0x0201,
+            LBUTTONUP = 0x0202,
+            LBUTTONDBLCLK = 0x0203,
+            RBUTTONDOWN = 0x0204,
+            RBUTTONUP = 0x0205,
+            RBUTTONDBLCLK = 0x0206,
+            MBUTTONDOWN = 0x0207,
+            MBUTTONUP = 0x0208,
+            MBUTTONDBLCLK = 0x0209,
+            MOUSEWHEEL = 0x020A,
+            XBUTTONDOWN = 0x020B,
+            XBUTTONUP = 0x020C,
+            XBUTTONDBLCLK = 0x020D,
+            MOUSEHWHEEL = 0x020E,
+            MOUSELAST = 0x020E,
+            PARENTNOTIFY = 0x0210,
+            ENTERMENULOOP = 0x0211,
+            EXITMENULOOP = 0x0212,
+            NEXTMENU = 0x0213,
+            SIZING = 0x0214,
+            CAPTURECHANGED = 0x0215,
+            MOVING = 0x0216,
+            POWERBROADCAST = 0x0218,
+            DEVICECHANGE = 0x0219,
+            MDICREATE = 0x0220,
+            MDIDESTROY = 0x0221,
+            MDIACTIVATE = 0x0222,
+            MDIRESTORE = 0x0223,
+            MDINEXT = 0x0224,
+            MDIMAXIMIZE = 0x0225,
+            MDITILE = 0x0226,
+            MDICASCADE = 0x0227,
+            MDIICONARRANGE = 0x0228,
+            MDIGETACTIVE = 0x0229,
+            MDISETMENU = 0x0230,
+            ENTERSIZEMOVE = 0x0231,
+            EXITSIZEMOVE = 0x0232,
+            DROPFILES = 0x0233,
+            MDIREFRESHMENU = 0x0234,
+            POINTERDEVICECHANGE = 0x0238,
+            POINTERDEVICEINRANGE = 0x0239,
+            POINTERDEVICEOUTOFRANGE = 0x023A,
+            TOUCH = 0x0240,
+            NCPOINTERUPDATE = 0x0241,
+            NCPOINTERDOWN = 0x0242,
+            NCPOINTERUP = 0x0243,
+            POINTERUPDATE = 0x0245,
+            POINTERDOWN = 0x0246,
+            POINTERUP = 0x0247,
+            POINTERENTER = 0x0249,
+            POINTERLEAVE = 0x024A,
+            POINTERACTIVATE = 0x024B,
+            POINTERCAPTURECHANGED = 0x024C,
+            TOUCHHITTESTING = 0x024D,
+            POINTERWHEEL = 0x024E,
+            POINTERHWHEEL = 0x024F,
+            POINTERROUTEDTO = 0x0251,
+            POINTERROUTEDAWAY = 0x0252,
+            POINTERROUTEDRELEASED = 0x0253,
+            IME_SETCONTEXT = 0x0281,
+            IME_NOTIFY = 0x0282,
+            IME_CONTROL = 0x0283,
+            IME_COMPOSITIONFULL = 0x0284,
+            IME_SELECT = 0x0285,
+            IME_CHAR = 0x0286,
+            IME_REQUEST = 0x0288,
+            IME_KEYDOWN = 0x0290,
+            IME_KEYUP = 0x0291,
+            MOUSEHOVER = 0x02A1,
+            MOUSELEAVE = 0x02A3,
+            NCMOUSEHOVER = 0x02A0,
+            NCMOUSELEAVE = 0x02A2,
+            WTSSESSION_CHANGE = 0x02B1,
+            DPICHANGED = 0x02E0,
+            DPICHANGED_BEFOREPARENT = 0x02E2,
+            DPICHANGED_AFTERPARENT = 0x02E3,
+            GETDPISCALEDSIZE = 0x02E4,
+            CUT = 0x0300,
+            COPY = 0x0301,
+            PASTE = 0x0302,
+            CLEAR = 0x0303,
+            UNDO = 0x0304,
+            RENDERFORMAT = 0x0305,
+            RENDERALLFORMATS = 0x0306,
+            DESTROYCLIPBOARD = 0x0307,
+            DRAWCLIPBOARD = 0x0308,
+            PAINTCLIPBOARD = 0x0309,
+            VSCROLLCLIPBOARD = 0x030A,
+            SIZECLIPBOARD = 0x030B,
+            ASKCBFORMATNAME = 0x030C,
+            CHANGECBCHAIN = 0x030D,
+            HSCROLLCLIPBOARD = 0x030E,
+            QUERYNEWPALETTE = 0x030F,
+            PALETTEISCHANGING = 0x0310,
+            PALETTECHANGED = 0x0311,
+            HOTKEY = 0x0312,
+            PRINT = 0x0317,
+            PRINTCLIENT = 0x0318,
+            APPCOMMAND = 0x0319,
+            THEMECHANGED = 0x031A,
+            CLIPBOARDUPDATE = 0x031D,
+            DWMCOMPOSITIONCHANGED = 0x031E,
+            DWMNCRENDERINGCHANGED = 0x031F,
+            DWMCOLORIZATIONCOLORCHANGED = 0x0320,
+            DWMWINDOWMAXIMIZEDCHANGE = 0x0321,
+            DWMSENDICONICTHUMBNAIL = 0x0323,
+            DWMSENDICONICLIVEPREVIEWBITMAP = 0x0326,
+            GETTITLEBARINFOEX = 0x033F,
+            HANDHELDFIRST = 0x0358,
+            HANDHELDLAST = 0x035F,
+            AFXFIRST = 0x0360,
+            AFXLAST = 0x037F,
+            PENWINFIRST = 0x0380,
+            PENWINLAST = 0x038F,
+            USER = 0x0400,
+            CHOOSEFONT_GETLOGFONT = USER + 1,
+            APP = 0x8000,
+            REFLECT = USER + 0x1C00,
+
+            // Messages that are a combination of REFLECT with other messages.
+            REFLECT_NOTIFY = REFLECT + NOTIFY,
+            REFLECT_NOTIFYFORMAT = REFLECT + NOTIFYFORMAT,
+            REFLECT_COMMAND = REFLECT + COMMAND,
+            REFLECT_CHARTOITEM = REFLECT + CHARTOITEM,
+            REFLECT_VKEYTOITEM = REFLECT + VKEYTOITEM,
+            REFLECT_DRAWITEM = REFLECT + DRAWITEM,
+            REFLECT_MEASUREITEM = REFLECT + MEASUREITEM,
+            REFLECT_HSCROLL = REFLECT + HSCROLL,
+            REFLECT_VSCROLL = REFLECT + VSCROLL,
+            REFLECT_CTLCOLOR = REFLECT + CTLCOLOR,
+            REFLECT_CTLCOLORBTN = REFLECT + CTLCOLORBTN,
+            REFLECT_CTLCOLORDLG = REFLECT + CTLCOLORDLG,
+            REFLECT_CTLCOLORMSGBOX = REFLECT + CTLCOLORMSGBOX,
+            REFLECT_CTLCOLORSCROLLBAR = REFLECT + CTLCOLORSCROLLBAR,
+            REFLECT_CTLCOLOREDIT = REFLECT + CTLCOLOREDIT,
+            REFLECT_CTLCOLORLISTBOX = REFLECT + CTLCOLORLISTBOX,
+            REFLECT_CTLCOLORSTATIC = REFLECT + CTLCOLORSTATIC
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/Interop/User32/ODS.cs b/src/System.Windows.Forms.Primitives/src/Interop/User32/ODS.cs
new file mode 100644
index 00000000000..c6211f1d6f8
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/Interop/User32/ODS.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+internal static partial class Interop
+{
+    internal static partial class User32
+    {
+        [Flags]
+        public enum ODS : uint
+        {
+            SELECTED = 0x0001,
+            GRAYED = 0x0002,
+            DISABLED = 0x0004,
+            CHECKED = 0x0008,
+            FOCUS = 0x0010,
+            DEFAULT = 0x0020,
+            HOTLIGHT = 0x0040,
+            INACTIVE = 0x0080,
+            NOACCEL = 0x0100,
+            NOFOCUSRECT = 0x0200,
+            COMBOBOXEDIT = 0x1000,
+        }
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/NativeMethods.txt b/src/System.Windows.Forms.Primitives/src/NativeMethods.txt
index 78140b43356..e60c0cb3167 100644
--- a/src/System.Windows.Forms.Primitives/src/NativeMethods.txt
+++ b/src/System.Windows.Forms.Primitives/src/NativeMethods.txt
@@ -25,6 +25,7 @@ CBN_*
 CBS_*
 CCM_*
 CDM_GETSPEC
+CCS_*
 CDRF_*
 CHILDID_SELF
 ChildWindowFromPointEx
@@ -517,6 +518,7 @@ NMLVCUSTOMDRAW_ITEM_TYPE
 NMDATETIMECHANGE_FLAGS
 NMLVGETINFOTIP_FLAGS
 NMHDR
+NMTBHOTITEM
 NMTVCUSTOMDRAW
 NONCLIENTMETRICSW
 NotifyWinEvent
@@ -683,8 +685,11 @@ TASKDIALOG_ICON_ELEMENTS
 TASKDIALOG_MESSAGES
 TASKDIALOG_NOTIFICATIONS
 TB_*
+TBN_*
 TBS_*
 TBM_*
+TBSTATE_*
+TBSTYLE_*
 TCITEMHEADERA_MASK
 TCM_*
 TCS_*
@@ -698,6 +703,7 @@ TranslateMDISysAccel
 TranslateMessage
 TTDT_*
 TTM_*
+TTN_*
 TTS_*
 TVGN_*
 TVITEM_MASK
diff --git a/src/System.Windows.Forms.Primitives/src/System.Windows.Forms.Primitives.csproj b/src/System.Windows.Forms.Primitives/src/System.Windows.Forms.Primitives.csproj
index f7c99ef9c2c..c9809ed6bfc 100644
--- a/src/System.Windows.Forms.Primitives/src/System.Windows.Forms.Primitives.csproj
+++ b/src/System.Windows.Forms.Primitives/src/System.Windows.Forms.Primitives.csproj
@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   
   <PropertyGroup>
     <AssemblyName>System.Windows.Forms.Primitives</AssemblyName>
+    <AssemblyVersion>8.0.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <CLSCompliant>true</CLSCompliant>
     <Nullable>enable</Nullable>
@@ -11,7 +12,8 @@
       users won't be impacted. If some name becomes difficult to adapt to with the @ symbol we can
       cross that bridge when we hit it (if ever).
     -->
-    <NoWarn>$(NoWarn);CS8981;CS3016</NoWarn>
+    <!--Most of the suppresions have got to do with default values from code-analysis.--> 
+    <NoWarn>$(NoWarn);CS8981;CS3016;CA1052;SA1507;CA1805</NoWarn>
     <!--
       We don't care about CLS compliance since everything here is internal and we want to match native types.
     -->
@@ -34,14 +36,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\Accessibility\src\Accessibility.ilproj" />
-    <ProjectReference Include="..\..\System.Drawing.Common\src\System.Drawing.Common.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
+    <PackageReference Include="Accessibility" Version="4.6.0-preview3-27504-2" />
     <PackageReference Include="Microsoft.Win32.SystemEvents" Version="$(MicrosoftWin32SystemEventsPackageVersion)" />
     <PackageReference Include="Microsoft.Windows.CsWin32" Version="$(MicrosoftWindowsCsWin32PackageVersion)" PrivateAssets="all" />
     <PackageReference Include="System.Configuration.ConfigurationManager" Version="$(SystemConfigurationConfigurationManagerPackageVersion)" />
+    <PackageReference Include="System.Drawing.Common" Version="$(SystemDrawingCommonPackageVersion)" />
     <PackageReference Include="System.Resources.Extensions" Version="$(SystemResourcesExtensionsPackageVersion)" />
     <PackageReference Include="System.Windows.Extensions" Version="$(SystemWindowsExtensionsPackageVersion)" />
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafePackageVersion)" />
diff --git a/src/System.Windows.Forms.Primitives/src/System/ExternDll.cs b/src/System.Windows.Forms.Primitives/src/System/ExternDll.cs
new file mode 100644
index 00000000000..cdeb8547274
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/System/ExternDll.cs
@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System
+{
+    internal static class ExternDll
+    {
+        public const string Activeds = "activeds.dll";
+        public const string Comctl32 = "comctl32.dll";
+        public const string Comdlg32 = "comdlg32.dll";
+        public const string Gdi32 = "gdi32.dll";
+        public const string Gdiplus = "gdiplus.dll";
+        public const string Hhctrl = "hhctrl.ocx";
+        public const string Imm32 = "imm32.dll";
+        public const string Kernel32 = "kernel32.dll";
+        public const string Loadperf = "Loadperf.dll";
+        public const string Mscoree = "mscoree.dll";
+        public const string Clr = "clr.dll";
+        public const string Msi = "msi.dll";
+        public const string Mqrt = "mqrt.dll";
+        public const string Ntdll = "ntdll.dll";
+        public const string Ole32 = "ole32.dll";
+        public const string Oleacc = "oleacc.dll";
+        public const string Oleaut32 = "oleaut32.dll";
+        public const string Olepro32 = "olepro32.dll";
+        public const string PerfCounter = "perfcounter.dll";
+        public const string Psapi = "psapi.dll";
+        public const string Shell32 = "shell32.dll";
+        public const string User32 = "user32.dll";
+        public const string Uxtheme = "uxtheme.dll";
+        public const string WinMM = "winmm.dll";
+        public const string Winspool = "winspool.drv";
+        public const string Wtsapi32 = "wtsapi32.dll";
+        public const string Version = "version.dll";
+        public const string Vsassert = "vsassert.dll";
+        public const string Fxassert = "Fxassert.dll";
+        public const string Crypt32 = "crypt32.dll";
+        public const string ShCore = "SHCore.dll";
+        public const string Wldp = "wldp.dll";
+
+        // system.data specific
+        internal const string Odbc32 = "odbc32.dll";
+        internal const string SNI = "System.Data.dll";
+
+        // system.data.oracleclient specific
+        internal const string OciDll = "oci.dll";
+        internal const string OraMtsDll = "oramts.dll";
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/ClientUtils.cs b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/ClientUtils.cs
index 2a342b6d8e6..43187b3e3a1 100644
--- a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/ClientUtils.cs
+++ b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/ClientUtils.cs
@@ -7,6 +7,15 @@ namespace System.Windows.Forms;
 
 internal static class ClientUtils
 {
+    // Sequential version
+    // assumes sequential enum members 0,1,2,3,4 -etc.
+    //
+    public static bool IsEnumValid(Enum enumValue, int value, int minValue, int maxValue)
+    {
+        bool valid = (value >= minValue) && (value <= maxValue);
+        return valid;
+    }
+
     private enum CharType
     {
         None,
diff --git a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/NativeMethods.cs b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/NativeMethods.cs
index 22f134cb63e..29a0ae79401 100644
--- a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/NativeMethods.cs
+++ b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/NativeMethods.cs
@@ -10,8 +10,654 @@ internal static class NativeMethods
 {
     public delegate IntPtr WndProc(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);
 
+    public static HandleRef NullHandleRef = new HandleRef(null, IntPtr.Zero);
+
+    public const int WHEEL_DELTA = 120;
+
+    public const string WC_DATETIMEPICK = "SysDateTimePick32",
+        WC_LISTVIEW = "SysListView32",
+        WC_MONTHCAL = "SysMonthCal32",
+        WC_PROGRESS = "msctls_progress32",
+        WC_STATUSBAR = "msctls_statusbar32",
+        WC_TOOLBAR = "ToolbarWindow32",
+        WC_TRACKBAR = "msctls_trackbar32",
+        WC_TREEVIEW = "SysTreeView32",
+        WC_TABCONTROL = "SysTabControl32",
+        MSH_MOUSEWHEEL = "MSWHEEL_ROLLMSG",
+        MSH_SCROLL_LINES = "MSH_SCROLL_LINES_MSG";
+
+    public const int CF_TEXT = 1,
+        CF_BITMAP = 2,
+        CF_METAFILEPICT = 3,
+        CF_SYLK = 4,
+        CF_DIF = 5,
+        CF_TIFF = 6,
+        CF_OEMTEXT = 7,
+        CF_DIB = 8,
+        CF_PALETTE = 9,
+        CF_PENDATA = 10,
+        CF_RIFF = 11,
+        CF_WAVE = 12,
+        CF_UNICODETEXT = 13,
+        CF_ENHMETAFILE = 14,
+        CF_HDROP = 15,
+        CF_LOCALE = 16,
+        CLSCTX_INPROC_SERVER = 0x1,
+        CLSCTX_LOCAL_SERVER = 0x4,
+        CW_USEDEFAULT = (unchecked((int)0x80000000)),
+        CWP_SKIPINVISIBLE = 0x0001,
+        COLOR_WINDOW = 5,
+        CB_ERR = (-1),
+        CBN_SELCHANGE = 1,
+        CBN_DBLCLK = 2,
+        CBN_EDITCHANGE = 5,
+        CBN_EDITUPDATE = 6,
+        CBN_DROPDOWN = 7,
+        CBN_CLOSEUP = 8,
+        CBN_SELENDOK = 9,
+        CBS_SIMPLE = 0x0001,
+        CBS_DROPDOWN = 0x0002,
+        CBS_DROPDOWNLIST = 0x0003,
+        CBS_OWNERDRAWFIXED = 0x0010,
+        CBS_OWNERDRAWVARIABLE = 0x0020,
+        CBS_AUTOHSCROLL = 0x0040,
+        CBS_HASSTRINGS = 0x0200,
+        CBS_NOINTEGRALHEIGHT = 0x0400,
+        CB_GETEDITSEL = 0x0140,
+        CB_LIMITTEXT = 0x0141,
+        CB_SETEDITSEL = 0x0142,
+        CB_ADDSTRING = 0x0143,
+        CB_DELETESTRING = 0x0144,
+        CB_GETCURSEL = 0x0147,
+        CB_GETLBTEXT = 0x0148,
+        CB_GETLBTEXTLEN = 0x0149,
+        CB_INSERTSTRING = 0x014A,
+        CB_RESETCONTENT = 0x014B,
+        CB_FINDSTRING = 0x014C,
+        CB_SETCURSEL = 0x014E,
+        CB_SHOWDROPDOWN = 0x014F,
+        CB_GETITEMDATA = 0x0150,
+        CB_SETITEMHEIGHT = 0x0153,
+        CB_GETITEMHEIGHT = 0x0154,
+        CB_GETDROPPEDSTATE = 0x0157,
+        CB_GETTOPINDEX = 0x015b,
+        CB_SETTOPINDEX = 0x015c,
+        CB_FINDSTRINGEXACT = 0x0158,
+        CB_GETDROPPEDWIDTH = 0x015F,
+        CB_SETDROPPEDWIDTH = 0x0160,
+        CDRF_DODEFAULT = 0x00000000,
+        CDRF_NEWFONT = 0x00000002,
+        CDRF_SKIPDEFAULT = 0x00000004,
+        CDRF_NOTIFYPOSTPAINT = 0x00000010,
+        CDRF_NOTIFYITEMDRAW = 0x00000020,
+        CDRF_NOTIFYSUBITEMDRAW = CDRF_NOTIFYITEMDRAW,
+        CDDS_PREPAINT = 0x00000001,
+        CDDS_POSTPAINT = 0x00000002,
+        CDDS_ITEM = 0x00010000,
+        CDDS_SUBITEM = 0x00020000,
+        CDDS_ITEMPREPAINT = (0x00010000 | 0x00000001),
+        CDDS_ITEMPOSTPAINT = (0x00010000 | 0x00000002),
+        CDIS_SELECTED = 0x0001,
+        CDIS_GRAYED = 0x0002,
+        CDIS_DISABLED = 0x0004,
+        CDIS_CHECKED = 0x0008,
+        CDIS_FOCUS = 0x0010,
+        CDIS_DEFAULT = 0x0020,
+        CDIS_HOT = 0x0040,
+        CDIS_MARKED = 0x0080,
+        CDIS_INDETERMINATE = 0x0100,
+        CDIS_SHOWKEYBOARDCUES = 0x0200,
+        CLR_NONE = unchecked((int)0xFFFFFFFF),
+        CLR_DEFAULT = unchecked((int)0xFF000000),
+        CCM_SETVERSION = (0x2000 + 0x7),
+        CCM_GETVERSION = (0x2000 + 0x8),
+        CCS_NORESIZE = 0x00000004,
+        CCS_NOPARENTALIGN = 0x00000008,
+        CCS_NODIVIDER = 0x00000040,
+        CBEM_INSERTITEM = (0x0400 + 11),
+        CBEM_SETITEM = (0x0400 + 12),
+        CBEM_GETITEM = (0x0400 + 13),
+        CBEN_ENDEDIT = ((0 - 800) - 6),
+        CONNECT_E_NOCONNECTION = unchecked((int)0x80040200),
+        CONNECT_E_CANNOTCONNECT = unchecked((int)0x80040202),
+        CTRLINFO_EATS_RETURN = 1,
+        CTRLINFO_EATS_ESCAPE = 2;
+
+    public const int SW_SCROLLCHILDREN = 0x0001,
+        SW_INVALIDATE = 0x0002,
+        SW_ERASE = 0x0004,
+        SW_SMOOTHSCROLL = 0x0010,
+        SC_SIZE = 0xF000,
+        SC_MINIMIZE = 0xF020,
+        SC_MAXIMIZE = 0xF030,
+        SC_CLOSE = 0xF060,
+        SC_KEYMENU = 0xF100,
+        SC_RESTORE = 0xF120,
+        SC_MOVE = 0xF010,
+        SC_CONTEXTHELP = 0xF180,
+        SS_LEFT = 0x00000000,
+        SS_CENTER = 0x00000001,
+        SS_RIGHT = 0x00000002,
+        SS_OWNERDRAW = 0x0000000D,
+        SS_NOPREFIX = 0x00000080,
+        SS_SUNKEN = 0x00001000,
+        SBS_HORZ = 0x0000,
+        SBS_VERT = 0x0001,
+        SIF_RANGE = 0x0001,
+        SIF_PAGE = 0x0002,
+        SIF_POS = 0x0004,
+        SIF_TRACKPOS = 0x0010,
+        SIF_ALL = (0x0001 | 0x0002 | 0x0004 | 0x0010),
+        SPI_GETFONTSMOOTHING = 0x004A,
+        SPI_GETDROPSHADOW = 0x1024,
+        SPI_GETFLATMENU = 0x1022,
+        SPI_GETFONTSMOOTHINGTYPE = 0x200A,
+        SPI_GETFONTSMOOTHINGCONTRAST = 0x200C,
+        SPI_ICONHORIZONTALSPACING = 0x000D,
+        SPI_ICONVERTICALSPACING = 0x0018,
+        // SPI_GETICONMETRICS =        0x002D,
+        SPI_GETICONTITLEWRAP = 0x0019,
+        SPI_GETKEYBOARDCUES = 0x100A,
+        SPI_GETKEYBOARDDELAY = 0x0016,
+        SPI_GETKEYBOARDPREF = 0x0044,
+        SPI_GETKEYBOARDSPEED = 0x000A,
+        SPI_GETMOUSEHOVERWIDTH = 0x0062,
+        SPI_GETMOUSEHOVERHEIGHT = 0x0064,
+        SPI_GETMOUSEHOVERTIME = 0x0066,
+        SPI_GETMOUSESPEED = 0x0070,
+        SPI_GETMENUDROPALIGNMENT = 0x001B,
+        SPI_GETMENUFADE = 0x1012,
+        SPI_GETMENUSHOWDELAY = 0x006A,
+        SPI_GETCOMBOBOXANIMATION = 0x1004,
+        SPI_GETGRADIENTCAPTIONS = 0x1008,
+        SPI_GETHOTTRACKING = 0x100E,
+        SPI_GETLISTBOXSMOOTHSCROLLING = 0x1006,
+        SPI_GETMENUANIMATION = 0x1002,
+        SPI_GETSELECTIONFADE = 0x1014,
+        SPI_GETTOOLTIPANIMATION = 0x1016,
+        SPI_GETUIEFFECTS = 0x103E,
+        SPI_GETACTIVEWINDOWTRACKING = 0x1000,
+        SPI_GETACTIVEWNDTRKTIMEOUT = 0x2002,
+        SPI_GETANIMATION = 0x0048,
+        SPI_GETBORDER = 0x0005,
+        SPI_GETCARETWIDTH = 0x2006,
+        SPI_GETDRAGFULLWINDOWS = 38,
+        SPI_GETNONCLIENTMETRICS = 41,
+        SPI_GETWORKAREA = 48,
+        SPI_GETHIGHCONTRAST = 66,
+        SPI_GETDEFAULTINPUTLANG = 89,
+        SPI_GETSNAPTODEFBUTTON = 95,
+        SPI_GETWHEELSCROLLLINES = 104,
+        SBARS_SIZEGRIP = 0x0100,
+        SB_SETTEXT = (0x0400 + 11),
+        SB_GETTEXT = (0x0400 + 13),
+        SB_GETTEXTLENGTH = (0x0400 + 12),
+        SB_SETPARTS = (0x0400 + 4),
+        SB_SIMPLE = (0x0400 + 9),
+        SB_GETRECT = (0x0400 + 10),
+        SB_SETICON = (0x0400 + 15),
+        SB_SETTIPTEXT = (0x0400 + 17),
+        SB_GETTIPTEXT = (0x0400 + 19),
+        SBT_OWNERDRAW = 0x1000,
+        SBT_NOBORDERS = 0x0100,
+        SBT_POPOUT = 0x0200,
+        SBT_RTLREADING = 0x0400,
+        SRCCOPY = 0x00CC0020;
+
+    public static HandleRef HWND_TOPMOST = new HandleRef(null, new IntPtr(-1));
+
+    public const int MEMBERID_NIL = (-1),
+        ERROR_INSUFFICIENT_BUFFER = 122, //https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx
+        MA_ACTIVATE = 0x0001,
+        MA_ACTIVATEANDEAT = 0x0002,
+        MA_NOACTIVATE = 0x0003,
+        MA_NOACTIVATEANDEAT = 0x0004,
+        MM_TEXT = 1,
+        MM_ANISOTROPIC = 8,
+        MNC_EXECUTE = 2,
+        MNC_SELECT = 3,
+        MIIM_STATE = 0x00000001,
+        MIIM_ID = 0x00000002,
+        MIIM_SUBMENU = 0x00000004,
+        MIIM_TYPE = 0x00000010,
+        MIIM_DATA = 0x00000020,
+        MIIM_STRING = 0x00000040,
+        MIIM_BITMAP = 0x00000080,
+        MIIM_FTYPE = 0x00000100,
+        MB_OK = 0x00000000,
+        MFS_DISABLED = 0x00000003,
+        MFT_MENUBREAK = 0x00000040,
+        MFT_SEPARATOR = 0x00000800,
+        MFT_RIGHTORDER = 0x00002000,
+        MFT_RIGHTJUSTIFY = 0x00004000,
+        MDIS_ALLCHILDSTYLES = 0x0001,
+        MDITILE_VERTICAL = 0x0000,
+        MDITILE_HORIZONTAL = 0x0001,
+        MDITILE_SKIPDISABLED = 0x0002,
+        MCM_SETMAXSELCOUNT = (0x1000 + 4),
+        MCM_SETSELRANGE = (0x1000 + 6),
+        MCM_GETMONTHRANGE = (0x1000 + 7),
+        MCM_GETMINREQRECT = (0x1000 + 9),
+        MCM_SETCOLOR = (0x1000 + 10),
+        MCM_SETTODAY = (0x1000 + 12),
+        MCM_GETTODAY = (0x1000 + 13),
+        MCM_HITTEST = (0x1000 + 14),
+        MCM_SETFIRSTDAYOFWEEK = (0x1000 + 15),
+        MCM_SETRANGE = (0x1000 + 18),
+        MCM_SETMONTHDELTA = (0x1000 + 20),
+        MCM_GETMAXTODAYWIDTH = (0x1000 + 21),
+        MCHT_TITLE = 0x00010000,
+        MCHT_CALENDAR = 0x00020000,
+        MCHT_TODAYLINK = 0x00030000,
+        MCHT_TITLEBK = (0x00010000),
+        MCHT_TITLEMONTH = (0x00010000 | 0x0001),
+        MCHT_TITLEYEAR = (0x00010000 | 0x0002),
+        MCHT_TITLEBTNNEXT = (0x00010000 | 0x01000000 | 0x0003),
+        MCHT_TITLEBTNPREV = (0x00010000 | 0x02000000 | 0x0003),
+        MCHT_CALENDARBK = (0x00020000),
+        MCHT_CALENDARDATE = (0x00020000 | 0x0001),
+        MCHT_CALENDARDATENEXT = ((0x00020000 | 0x0001) | 0x01000000),
+        MCHT_CALENDARDATEPREV = ((0x00020000 | 0x0001) | 0x02000000),
+        MCHT_CALENDARDAY = (0x00020000 | 0x0002),
+        MCHT_CALENDARWEEKNUM = (0x00020000 | 0x0003),
+        MCSC_TEXT = 1,
+        MCSC_TITLEBK = 2,
+        MCSC_TITLETEXT = 3,
+        MCSC_MONTHBK = 4,
+        MCSC_TRAILINGTEXT = 5,
+        MCN_VIEWCHANGE = (0 - 750), // MCN_SELECT -4  - give state of calendar view
+        MCN_SELCHANGE = ((0 - 750) + 1),
+        MCN_GETDAYSTATE = ((0 - 750) + 3),
+        MCN_SELECT = ((0 - 750) + 4),
+        MCS_DAYSTATE = 0x0001,
+        MCS_MULTISELECT = 0x0002,
+        MCS_WEEKNUMBERS = 0x0004,
+        MCS_NOTODAYCIRCLE = 0x0008,
+        MCS_NOTODAY = 0x0010,
+        MSAA_MENU_SIG = (unchecked((int)0xAA0DF00D));
+
     public delegate int ListViewCompareCallback(IntPtr lParam1, IntPtr lParam2, IntPtr lParamSort);
 
+    public const int IME_CMODE_NATIVE = 0x0001,
+        IME_CMODE_KATAKANA = 0x0002,
+        IME_CMODE_FULLSHAPE = 0x0008,
+        INPLACE_E_NOTOOLSPACE = unchecked((int)0x800401A1),
+        ICON_SMALL = 0,
+        ICON_BIG = 1,
+        IMAGE_ICON = 1,
+        IMAGE_CURSOR = 2,
+        ICC_LISTVIEW_CLASSES = 0x00000001,
+        ICC_TREEVIEW_CLASSES = 0x00000002,
+        ICC_BAR_CLASSES = 0x00000004,
+        ICC_TAB_CLASSES = 0x00000008,
+        ICC_PROGRESS_CLASS = 0x00000020,
+        ICC_DATE_CLASSES = 0x00000100,
+        ILC_MASK = 0x0001,
+        ILC_COLOR = 0x0000,
+        ILC_COLOR4 = 0x0004,
+        ILC_COLOR8 = 0x0008,
+        ILC_COLOR16 = 0x0010,
+        ILC_COLOR24 = 0x0018,
+        ILC_COLOR32 = 0x0020,
+        ILC_MIRROR = 0x00002000,
+        ILD_NORMAL = 0x0000,
+        ILD_TRANSPARENT = 0x0001,
+        ILD_MASK = 0x0010,
+        ILD_ROP = 0x0040,
+
+// ImageList
+//
+        ILP_NORMAL = 0,
+        ILP_DOWNLEVEL = 1,
+        ILS_NORMAL = 0x0,
+        ILS_GLOW = 0x1,
+        ILS_SHADOW = 0x2,
+        ILS_SATURATE = 0x4,
+        ILS_ALPHA = 0x8;
+
+    [StructLayout(LayoutKind.Sequential)]
+    public class DRAWITEMSTRUCT
+    {
+        public int CtlType = 0;
+        public int CtlID = 0;
+        public int itemID = 0;
+        public int itemAction = 0;
+        public int itemState = 0;
+        public IntPtr hwndItem = IntPtr.Zero;
+        public IntPtr hDC = IntPtr.Zero;
+        public RECT rcItem;
+        public IntPtr itemData = IntPtr.Zero;
+    }
+
+    public const int NIM_ADD = 0x00000000,
+        NIM_MODIFY = 0x00000001,
+        NIM_DELETE = 0x00000002,
+        NIF_MESSAGE = 0x00000001,
+        NIM_SETVERSION = 0x00000004,
+        NIF_ICON = 0x00000002,
+        NIF_INFO = 0x00000010,
+        NIF_TIP = 0x00000004,
+        NIIF_NONE = 0x00000000,
+        NIIF_INFO = 0x00000001,
+        NIIF_WARNING = 0x00000002,
+        NIIF_ERROR = 0x00000003,
+        NIN_BALLOONSHOW = (Interop.WindowMessages.WM_USER + 2),
+        NIN_BALLOONHIDE = (Interop.WindowMessages.WM_USER + 3),
+        NIN_BALLOONTIMEOUT = (Interop.WindowMessages.WM_USER + 4),
+        NIN_BALLOONUSERCLICK = (Interop.WindowMessages.WM_USER + 5),
+        NFR_ANSI = 1,
+        NFR_UNICODE = 2,
+        NM_CLICK = ((0 - 0) - 2),
+        NM_DBLCLK = ((0 - 0) - 3),
+        NM_RCLICK = ((0 - 0) - 5),
+        NM_RDBLCLK = ((0 - 0) - 6),
+        NM_CUSTOMDRAW = ((0 - 0) - 12),
+        NM_RELEASEDCAPTURE = ((0 - 0) - 16);
+
+    public const int
+        HC_ACTION = 0,
+        HC_GETNEXT = 1,
+        HC_SKIP = 2,
+        HTTRANSPARENT = (-1),
+        HTNOWHERE = 0,
+        HTCLIENT = 1,
+        HTLEFT = 10,
+        HTBOTTOM = 15,
+        HTBOTTOMLEFT = 16,
+        HTBOTTOMRIGHT = 17,
+        HTBORDER = 18,
+        HELPINFO_WINDOW = 0x0001,
+        HCF_HIGHCONTRASTON = 0x00000001,
+        HDI_ORDER = 0x0080,
+        HDI_WIDTH = 0x0001,
+        HDM_GETITEMCOUNT = (0x1200 + 0),
+        HDM_INSERTITEMW = (0x1200 + 10),
+        HDM_GETITEMW = (0x1200 + 11),
+        HDM_LAYOUT = (0x1200 + 5),
+        HDM_SETITEMW = (0x1200 + 12),
+        HDN_ITEMCHANGING = ((0 - 300) - 20),
+        HDN_ITEMCHANGED = ((0 - 300) - 21),
+        HDN_ITEMCLICK = ((0 - 300) - 22),
+        HDN_ITEMDBLCLICK = ((0 - 300) - 23),
+        HDN_DIVIDERDBLCLICK = ((0 - 300) - 25),
+        HDN_BEGINTDRAG = ((0 - 300) - 10),
+        HDN_BEGINTRACK = ((0 - 300) - 26),
+        HDN_ENDDRAG = ((0 - 300) - 11),
+        HDN_ENDTRACK = ((0 - 300) - 27),
+        HDN_TRACK = ((0 - 300) - 28),
+        HDN_GETDISPINFO = ((0 - 300) - 29);
+    // HOVER_DEFAULT = Do not use this value ever! It crashes entire servers.
+
+    public const string TOOLTIPS_CLASS = "tooltips_class32";
+
+    public const int stc4 = 0x0443,
+        STARTF_USESHOWWINDOW = 0x00000001,
+        SB_HORZ = 0,
+        SB_VERT = 1,
+        SB_CTL = 2,
+        SB_LINEUP = 0,
+        SB_LINELEFT = 0,
+        SB_LINEDOWN = 1,
+        SB_LINERIGHT = 1,
+        SB_PAGEUP = 2,
+        SB_PAGELEFT = 2,
+        SB_PAGEDOWN = 3,
+        SB_PAGERIGHT = 3,
+        SB_THUMBPOSITION = 4,
+        SB_THUMBTRACK = 5,
+        SB_LEFT = 6,
+        SB_RIGHT = 7,
+        SB_ENDSCROLL = 8,
+        SB_TOP = 6,
+        SB_BOTTOM = 7,
+        SIZE_RESTORED = 0,
+        SIZE_MAXIMIZED = 2,
+        ESB_ENABLE_BOTH = 0x0000,
+        ESB_DISABLE_BOTH = 0x0003,
+        SORT_DEFAULT = 0x0,
+        SUBLANG_DEFAULT = 0x01,
+        SW_HIDE = 0,
+        SW_NORMAL = 1,
+        SW_SHOWMINIMIZED = 2,
+        SW_SHOWMAXIMIZED = 3,
+        SW_MAXIMIZE = 3,
+        SW_SHOWNOACTIVATE = 4,
+        SW_SHOW = 5,
+        SW_MINIMIZE = 6,
+        SW_SHOWMINNOACTIVE = 7,
+        SW_SHOWNA = 8,
+        SW_RESTORE = 9,
+        SW_MAX = 10,
+        SWP_NOSIZE = 0x0001,
+        SWP_NOMOVE = 0x0002,
+        SWP_NOZORDER = 0x0004,
+        SWP_NOACTIVATE = 0x0010,
+        SWP_SHOWWINDOW = 0x0040,
+        SWP_HIDEWINDOW = 0x0080,
+        SWP_DRAWFRAME = 0x0020,
+        SWP_NOOWNERZORDER = 0x0200;
+
+
+    public const int TRANSPARENT = 1,
+        OPAQUE = 2,
+        TME_HOVER = 0x00000001,
+        TME_LEAVE = 0x00000002,
+        TPM_LEFTBUTTON = 0x0000,
+        TPM_RIGHTBUTTON = 0x0002,
+        TPM_LEFTALIGN = 0x0000,
+        TPM_RIGHTALIGN = 0x0008,
+        TPM_VERTICAL = 0x0040,
+        TV_FIRST = 0x1100,
+        TBSTATE_CHECKED = 0x01,
+        TBSTATE_ENABLED = 0x04,
+        TBSTATE_HIDDEN = 0x08,
+        TBSTATE_INDETERMINATE = 0x10,
+        TBSTYLE_BUTTON = 0x00,
+        TBSTYLE_SEP = 0x01,
+        TBSTYLE_CHECK = 0x02,
+        TBSTYLE_DROPDOWN = 0x08,
+        TBSTYLE_TOOLTIPS = 0x0100,
+        TBSTYLE_FLAT = 0x0800,
+        TBSTYLE_LIST = 0x1000,
+        TBSTYLE_EX_DRAWDDARROWS = 0x00000001,
+        TB_ENABLEBUTTON = (0x0400 + 1),
+        TB_ISBUTTONCHECKED = (0x0400 + 10),
+        TB_ISBUTTONINDETERMINATE = (0x0400 + 13),
+        TB_ADDBUTTONS = (0x0400 + 68),
+        TB_INSERTBUTTON = (0x0400 + 67),
+        TB_DELETEBUTTON = (0x0400 + 22),
+        TB_GETBUTTON = (0x0400 + 23),
+        TB_SAVERESTORE = (0x0400 + 76),
+        TB_ADDSTRING = (0x0400 + 77),
+        TB_BUTTONSTRUCTSIZE = (0x0400 + 30),
+        TB_SETBUTTONSIZE = (0x0400 + 31),
+        TB_AUTOSIZE = (0x0400 + 33),
+        TB_GETROWS = (0x0400 + 40),
+        TB_GETBUTTONTEXT = (0x0400 + 75),
+        TB_SETIMAGELIST = (0x0400 + 48),
+        TB_GETRECT = (0x0400 + 51),
+        TB_GETBUTTONSIZE = (0x0400 + 58),
+        TB_GETBUTTONINFO = (0x0400 + 63),
+        TB_SETBUTTONINFO = (0x0400 + 64),
+        TB_SETEXTENDEDSTYLE = (0x0400 + 84),
+        TB_MAPACCELERATOR = (0x0400 + 90),
+        TB_GETTOOLTIPS = (0x0400 + 35),
+        TB_SETTOOLTIPS = (0x0400 + 36),
+        TBIF_IMAGE = 0x00000001,
+        TBIF_TEXT = 0x00000002,
+        TBIF_STATE = 0x00000004,
+        TBIF_STYLE = 0x00000008,
+        TBIF_COMMAND = 0x00000020,
+        TBIF_SIZE = 0x00000040,
+        TBN_GETBUTTONINFO = ((0 - 700) - 20),
+        TBN_QUERYINSERT = ((0 - 700) - 6),
+        TBN_DROPDOWN = ((0 - 700) - 10),
+        TBN_HOTITEMCHANGE = ((0 - 700) - 13),
+        TBN_GETDISPINFO = ((0 - 700) - 17),
+        TBN_GETINFOTIP = ((0 - 700) - 19),
+        TTS_ALWAYSTIP = 0x01,
+        TTS_NOPREFIX = 0x02,
+        TTS_NOANIMATE = 0x10,
+        TTS_NOFADE = 0x20,
+        TTS_BALLOON = 0x40,
+        //TTI_NONE                =0,
+        //TTI_INFO                =1,
+        TTI_WARNING = 2,
+        //TTI_ERROR               =3,
+        TTN_GETDISPINFO = ((0 - 520) - 10),
+        TTN_SHOW = ((0 - 520) - 1),
+        TTN_POP = ((0 - 520) - 2),
+        TTN_NEEDTEXT = ((0 - 520) - 10),
+        TBS_AUTOTICKS = 0x0001,
+        TBS_VERT = 0x0002,
+        TBS_TOP = 0x0004,
+        TBS_BOTTOM = 0x0000,
+        TBS_BOTH = 0x0008,
+        TBS_NOTICKS = 0x0010,
+        TBM_GETPOS = (0x0400),
+        TBM_SETTIC = (0x0400 + 4),
+        TBM_SETPOS = (0x0400 + 5),
+        TBM_SETRANGE = (0x0400 + 6),
+        TBM_SETRANGEMIN = (0x0400 + 7),
+        TBM_SETRANGEMAX = (0x0400 + 8),
+        TBM_SETTICFREQ = (0x0400 + 20),
+        TBM_SETPAGESIZE = (0x0400 + 21),
+        TBM_SETLINESIZE = (0x0400 + 23),
+        TB_LINEUP = 0,
+        TB_LINEDOWN = 1,
+        TB_PAGEUP = 2,
+        TB_PAGEDOWN = 3,
+        TB_THUMBPOSITION = 4,
+        TB_THUMBTRACK = 5,
+        TB_TOP = 6,
+        TB_BOTTOM = 7,
+        TB_ENDTRACK = 8,
+        TVS_HASBUTTONS = 0x0001,
+        TVS_HASLINES = 0x0002,
+        TVS_LINESATROOT = 0x0004,
+        TVS_EDITLABELS = 0x0008,
+        TVS_SHOWSELALWAYS = 0x0020,
+        TVS_RTLREADING = 0x0040,
+        TVS_CHECKBOXES = 0x0100,
+        TVS_TRACKSELECT = 0x0200,
+        TVS_FULLROWSELECT = 0x1000,
+        TVS_NONEVENHEIGHT = 0x4000,
+        TVS_INFOTIP = 0x0800,
+        TVS_NOTOOLTIPS = 0x0080,
+        TVIF_TEXT = 0x0001,
+        TVIF_IMAGE = 0x0002,
+        TVIF_PARAM = 0x0004,
+        TVIF_STATE = 0x0008,
+        TVIF_HANDLE = 0x0010,
+        TVIF_SELECTEDIMAGE = 0x0020,
+        TVIS_SELECTED = 0x0002,
+        TVIS_EXPANDED = 0x0020,
+        TVIS_EXPANDEDONCE = 0x0040,
+        TVIS_STATEIMAGEMASK = 0xF000,
+        TVI_ROOT = (unchecked((int)0xFFFF0000)),
+        TVI_FIRST = (unchecked((int)0xFFFF0001)),
+        TVM_INSERTITEM = (0x1100 + 50),
+        TVM_DELETEITEM = (0x1100 + 1),
+        TVM_EXPAND = (0x1100 + 2),
+        TVE_COLLAPSE = 0x0001,
+        TVE_EXPAND = 0x0002,
+        TVM_GETITEMRECT = (0x1100 + 4),
+        TVM_GETINDENT = (0x1100 + 6),
+        TVM_SETINDENT = (0x1100 + 7),
+        TVM_GETIMAGELIST = (0x1100 + 8),
+        TVM_SETIMAGELIST = (0x1100 + 9),
+        TVM_GETNEXTITEM = (0x1100 + 10),
+        TVGN_NEXT = 0x0001,
+        TVGN_PREVIOUS = 0x0002,
+        TVGN_FIRSTVISIBLE = 0x0005,
+        TVGN_NEXTVISIBLE = 0x0006,
+        TVGN_PREVIOUSVISIBLE = 0x0007,
+        TVGN_DROPHILITE = 0x0008,
+        TVGN_CARET = 0x0009,
+        TVM_SELECTITEM = (0x1100 + 11),
+        TVM_GETITEM = (0x1100 + 62),
+        TVM_SETITEM = (0x1100 + 63),
+        TVM_EDITLABEL = (0x1100 + 65),
+        TVM_GETEDITCONTROL = (0x1100 + 15),
+        TVM_GETVISIBLECOUNT = (0x1100 + 16),
+        TVM_HITTEST = (0x1100 + 17),
+        TVM_ENSUREVISIBLE = (0x1100 + 20),
+        TVM_ENDEDITLABELNOW = (0x1100 + 22),
+        TVM_GETISEARCHSTRING = (0x1100 + 64),
+        TVM_SETITEMHEIGHT = (0x1100 + 27),
+        TVM_GETITEMHEIGHT = (0x1100 + 28),
+        TVN_SELCHANGING = ((0 - 400) - 50),
+        TVN_GETINFOTIP = ((0 - 400) - 14),
+        TVN_SELCHANGED = ((0 - 400) - 51),
+        TVC_UNKNOWN = 0x0000,
+        TVC_BYMOUSE = 0x0001,
+        TVC_BYKEYBOARD = 0x0002,
+        TVN_GETDISPINFO = ((0 - 400) - 52),
+        TVN_SETDISPINFO = ((0 - 400) - 53),
+        TVN_ITEMEXPANDING = ((0 - 400) - 54),
+        TVN_ITEMEXPANDED = ((0 - 400) - 55),
+        TVN_BEGINDRAG = ((0 - 400) - 56),
+        TVN_BEGINRDRAG = ((0 - 400) - 57),
+        TVN_BEGINLABELEDIT = ((0 - 400) - 59),
+        TVN_ENDLABELEDIT = ((0 - 400) - 60),
+        TCS_BOTTOM = 0x0002,
+        TCS_RIGHT = 0x0002,
+        TCS_FLATBUTTONS = 0x0008,
+        TCS_HOTTRACK = 0x0040,
+        TCS_VERTICAL = 0x0080,
+        TCS_TABS = 0x0000,
+        TCS_BUTTONS = 0x0100,
+        TCS_MULTILINE = 0x0200,
+        TCS_RIGHTJUSTIFY = 0x0000,
+        TCS_FIXEDWIDTH = 0x0400,
+        TCS_RAGGEDRIGHT = 0x0800,
+        TCS_OWNERDRAWFIXED = 0x2000,
+        TCS_TOOLTIPS = 0x4000,
+        TCM_SETIMAGELIST = (0x1300 + 3),
+        TCIF_TEXT = 0x0001,
+        TCIF_IMAGE = 0x0002,
+        TCM_GETITEM = (0x1300 + 60),
+        TCM_SETITEM = (0x1300 + 61),
+        TCM_INSERTITEM = (0x1300 + 62),
+        TCM_DELETEITEM = (0x1300 + 8),
+        TCM_DELETEALLITEMS = (0x1300 + 9),
+        TCM_GETITEMRECT = (0x1300 + 10),
+        TCM_GETCURSEL = (0x1300 + 11),
+        TCM_SETCURSEL = (0x1300 + 12),
+        TCM_ADJUSTRECT = (0x1300 + 40),
+        TCM_SETITEMSIZE = (0x1300 + 41),
+        TCM_SETPADDING = (0x1300 + 43),
+        TCM_GETROWCOUNT = (0x1300 + 44),
+        TCM_GETTOOLTIPS = (0x1300 + 45),
+        TCM_SETTOOLTIPS = (0x1300 + 46),
+        TCN_SELCHANGE = ((0 - 550) - 1),
+        TCN_SELCHANGING = ((0 - 550) - 2),
+        TBSTYLE_WRAPPABLE = 0x0200,
+        TVM_SETBKCOLOR = (TV_FIRST + 29),
+        TVM_SETTEXTCOLOR = (TV_FIRST + 30),
+        TYMED_NULL = 0,
+        TVM_GETLINECOLOR = (TV_FIRST + 41),
+        TVM_SETLINECOLOR = (TV_FIRST + 40),
+        TVM_SETTOOLTIPS = (TV_FIRST + 24),
+        TVSIL_STATE = 2,
+        TVM_SORTCHILDRENCB = (TV_FIRST + 21),
+        TMPF_FIXED_PITCH = 0x01;
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct NMHDR
+    {
+        public IntPtr hwndFrom;
+        public IntPtr idFrom; //This is declared as UINT_PTR in winuser.h
+        public int code;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public class INITCOMMONCONTROLSEX
+    {
+        public int dwSize = 8; //ndirect.DllLib.sizeOf(this);
+        public int dwICC;
+    }
+
     [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
     public class PRINTDLGEX
     {
@@ -50,6 +696,17 @@ public class PRINTDLGEX
         public Comdlg32.PD_RESULT dwResultAction;
     }
 
+    [StructLayout(LayoutKind.Sequential)]
+    public class TPMPARAMS
+    {
+        public int cbSize = Marshal.SizeOf<TPMPARAMS>();
+        // rcExclude was a by-value RECT structure
+        public int rcExclude_left;
+        public int rcExclude_top;
+        public int rcExclude_right;
+        public int rcExclude_bottom;
+    }
+
     public static class ActiveX
     {
         public const int ALIGN_MIN = 0x0;
@@ -59,5 +716,292 @@ public static class ActiveX
         public const int ALIGN_LEFT = 0x3;
         public const int ALIGN_RIGHT = 0x4;
         public const int ALIGN_MAX = 0x4;
+
+        public const int OCM__BASE = 0x2000;
+        public const int DISPID_VALUE = unchecked((int)0x0);
+        public const int DISPID_UNKNOWN = unchecked((int)0xFFFFFFFF);
+        public const int DISPID_AUTOSIZE = unchecked((int)0xFFFFFE0C);
+        public const int DISPID_BACKCOLOR = unchecked((int)0xFFFFFE0B);
+        public const int DISPID_BACKSTYLE = unchecked((int)0xFFFFFE0A);
+        public const int DISPID_BORDERCOLOR = unchecked((int)0xFFFFFE09);
+        public const int DISPID_BORDERSTYLE = unchecked((int)0xFFFFFE08);
+        public const int DISPID_BORDERWIDTH = unchecked((int)0xFFFFFE07);
+        public const int DISPID_DRAWMODE = unchecked((int)0xFFFFFE05);
+        public const int DISPID_DRAWSTYLE = unchecked((int)0xFFFFFE04);
+        public const int DISPID_DRAWWIDTH = unchecked((int)0xFFFFFE03);
+        public const int DISPID_FILLCOLOR = unchecked((int)0xFFFFFE02);
+        public const int DISPID_FILLSTYLE = unchecked((int)0xFFFFFE01);
+        public const int DISPID_FONT = unchecked((int)0xFFFFFE00);
+        public const int DISPID_FORECOLOR = unchecked((int)0xFFFFFDFF);
+        public const int DISPID_ENABLED = unchecked((int)0xFFFFFDFE);
+        public const int DISPID_HWND = unchecked((int)0xFFFFFDFD);
+        public const int DISPID_TABSTOP = unchecked((int)0xFFFFFDFC);
+        public const int DISPID_TEXT = unchecked((int)0xFFFFFDFB);
+        public const int DISPID_CAPTION = unchecked((int)0xFFFFFDFA);
+        public const int DISPID_BORDERVISIBLE = unchecked((int)0xFFFFFDF9);
+        public const int DISPID_APPEARANCE = unchecked((int)0xFFFFFDF8);
+        public const int DISPID_MOUSEPOINTER = unchecked((int)0xFFFFFDF7);
+        public const int DISPID_MOUSEICON = unchecked((int)0xFFFFFDF6);
+        public const int DISPID_PICTURE = unchecked((int)0xFFFFFDF5);
+        public const int DISPID_VALID = unchecked((int)0xFFFFFDF4);
+        public const int DISPID_READYSTATE = unchecked((int)0xFFFFFDF3);
+        public const int DISPID_REFRESH = unchecked((int)0xFFFFFDDA);
+        public const int DISPID_DOCLICK = unchecked((int)0xFFFFFDD9);
+        public const int DISPID_ABOUTBOX = unchecked((int)0xFFFFFDD8);
+        public const int DISPID_CLICK = unchecked((int)0xFFFFFDA8);
+        public const int DISPID_DBLCLICK = unchecked((int)0xFFFFFDA7);
+        public const int DISPID_KEYDOWN = unchecked((int)0xFFFFFDA6);
+        public const int DISPID_KEYPRESS = unchecked((int)0xFFFFFDA5);
+        public const int DISPID_KEYUP = unchecked((int)0xFFFFFDA4);
+        public const int DISPID_MOUSEDOWN = unchecked((int)0xFFFFFDA3);
+        public const int DISPID_MOUSEMOVE = unchecked((int)0xFFFFFDA2);
+        public const int DISPID_MOUSEUP = unchecked((int)0xFFFFFDA1);
+        public const int DISPID_ERROREVENT = unchecked((int)0xFFFFFDA0);
+        public const int DISPID_RIGHTTOLEFT = unchecked((int)0xFFFFFD9D);
+        public const int DISPID_READYSTATECHANGE = unchecked((int)0xFFFFFD9F);
+        public const int DISPID_AMBIENT_BACKCOLOR = unchecked((int)0xFFFFFD43);
+        public const int DISPID_AMBIENT_DISPLAYNAME = unchecked((int)0xFFFFFD42);
+        public const int DISPID_AMBIENT_FONT = unchecked((int)0xFFFFFD41);
+        public const int DISPID_AMBIENT_FORECOLOR = unchecked((int)0xFFFFFD40);
+        public const int DISPID_AMBIENT_LOCALEID = unchecked((int)0xFFFFFD3F);
+        public const int DISPID_AMBIENT_MESSAGEREFLECT = unchecked((int)0xFFFFFD3E);
+        public const int DISPID_AMBIENT_SCALEUNITS = unchecked((int)0xFFFFFD3D);
+        public const int DISPID_AMBIENT_TEXTALIGN = unchecked((int)0xFFFFFD3C);
+        public const int DISPID_AMBIENT_USERMODE = unchecked((int)0xFFFFFD3B);
+        public const int DISPID_AMBIENT_UIDEAD = unchecked((int)0xFFFFFD3A);
+        public const int DISPID_AMBIENT_SHOWGRABHANDLES = unchecked((int)0xFFFFFD39);
+        public const int DISPID_AMBIENT_SHOWHATCHING = unchecked((int)0xFFFFFD38);
+        public const int DISPID_AMBIENT_DISPLAYASDEFAULT = unchecked((int)0xFFFFFD37);
+        public const int DISPID_AMBIENT_SUPPORTSMNEMONICS = unchecked((int)0xFFFFFD36);
+        public const int DISPID_AMBIENT_AUTOCLIP = unchecked((int)0xFFFFFD35);
+        public const int DISPID_AMBIENT_APPEARANCE = unchecked((int)0xFFFFFD34);
+        public const int DISPID_AMBIENT_PALETTE = unchecked((int)0xFFFFFD2A);
+        public const int DISPID_AMBIENT_TRANSFERPRIORITY = unchecked((int)0xFFFFFD28);
+        public const int DISPID_AMBIENT_RIGHTTOLEFT = unchecked((int)0xFFFFFD24);
+        public const int DISPID_Name = unchecked((int)0xFFFFFCE0);
+        public const int DISPID_Delete = unchecked((int)0xFFFFFCDF);
+        public const int DISPID_Object = unchecked((int)0xFFFFFCDE);
+        public const int DISPID_Parent = unchecked((int)0xFFFFFCDD);
+        public const int DVASPECT_CONTENT = 0x1;
+        public const int DVASPECT_THUMBNAIL = 0x2;
+        public const int DVASPECT_ICON = 0x4;
+        public const int DVASPECT_DOCPRINT = 0x8;
+        public const int OLEMISC_RECOMPOSEONRESIZE = 0x1;
+        public const int OLEMISC_ONLYICONIC = 0x2;
+        public const int OLEMISC_INSERTNOTREPLACE = 0x4;
+        public const int OLEMISC_STATIC = 0x8;
+        public const int OLEMISC_CANTLINKINSIDE = 0x10;
+        public const int OLEMISC_CANLINKBYOLE1 = 0x20;
+        public const int OLEMISC_ISLINKOBJECT = 0x40;
+        public const int OLEMISC_INSIDEOUT = 0x80;
+        public const int OLEMISC_ACTIVATEWHENVISIBLE = 0x100;
+        public const int OLEMISC_RENDERINGISDEVICEINDEPENDENT = 0x200;
+        public const int OLEMISC_INVISIBLEATRUNTIME = 0x400;
+        public const int OLEMISC_ALWAYSRUN = 0x800;
+        public const int OLEMISC_ACTSLIKEBUTTON = 0x1000;
+        public const int OLEMISC_ACTSLIKELABEL = 0x2000;
+        public const int OLEMISC_NOUIACTIVATE = 0x4000;
+        public const int OLEMISC_ALIGNABLE = 0x8000;
+        public const int OLEMISC_SIMPLEFRAME = 0x10000;
+        public const int OLEMISC_SETCLIENTSITEFIRST = 0x20000;
+        public const int OLEMISC_IMEMODE = 0x40000;
+        public const int OLEMISC_IGNOREACTIVATEWHENVISIBLE = 0x80000;
+        public const int OLEMISC_WANTSTOMENUMERGE = 0x100000;
+        public const int OLEMISC_SUPPORTSMULTILEVELUNDO = 0x200000;
+        public const int QACONTAINER_SHOWHATCHING = 0x1;
+        public const int QACONTAINER_SHOWGRABHANDLES = 0x2;
+        public const int QACONTAINER_USERMODE = 0x4;
+        public const int QACONTAINER_DISPLAYASDEFAULT = 0x8;
+        public const int QACONTAINER_UIDEAD = 0x10;
+        public const int QACONTAINER_AUTOCLIP = 0x20;
+        public const int QACONTAINER_MESSAGEREFLECT = 0x40;
+        public const int QACONTAINER_SUPPORTSMNEMONICS = 0x80;
+        public const int XFORMCOORDS_POSITION = 0x1;
+        public const int XFORMCOORDS_SIZE = 0x2;
+        public const int XFORMCOORDS_HIMETRICTOCONTAINER = 0x4;
+        public const int XFORMCOORDS_CONTAINERTOHIMETRIC = 0x8;
+        public const int PROPCAT_Nil = unchecked((int)0xFFFFFFFF);
+        public const int PROPCAT_Misc = unchecked((int)0xFFFFFFFE);
+        public const int PROPCAT_Font = unchecked((int)0xFFFFFFFD);
+        public const int PROPCAT_Position = unchecked((int)0xFFFFFFFC);
+        public const int PROPCAT_Appearance = unchecked((int)0xFFFFFFFB);
+        public const int PROPCAT_Behavior = unchecked((int)0xFFFFFFFA);
+        public const int PROPCAT_Data = unchecked((int)0xFFFFFFF9);
+        public const int PROPCAT_List = unchecked((int)0xFFFFFFF8);
+        public const int PROPCAT_Text = unchecked((int)0xFFFFFFF7);
+        public const int PROPCAT_Scale = unchecked((int)0xFFFFFFF6);
+        public const int PROPCAT_DDE = unchecked((int)0xFFFFFFF5);
+        public const int GC_WCH_SIBLING = 0x1;
+        public const int GC_WCH_CONTAINER = 0x2;
+        public const int GC_WCH_CONTAINED = 0x3;
+        public const int GC_WCH_ALL = 0x4;
+        public const int GC_WCH_FREVERSEDIR = 0x8000000;
+        public const int GC_WCH_FONLYNEXT = 0x10000000;
+        public const int GC_WCH_FONLYPREV = 0x20000000;
+        public const int GC_WCH_FSELECTED = 0x40000000;
+        public const int OLECONTF_EMBEDDINGS = 0x1;
+        public const int OLECONTF_LINKS = 0x2;
+        public const int OLECONTF_OTHERS = 0x4;
+        public const int OLECONTF_ONLYUSER = 0x8;
+        public const int OLECONTF_ONLYIFRUNNING = 0x10;
+
+        public const int OLEVERBATTRIB_NEVERDIRTIES = 0x1;
+        public const int OLEVERBATTRIB_ONCONTAINERMENU = 0x2;
+
+        public static Guid IID_IUnknown = new Guid("{00000000-0000-0000-C000-000000000046}");
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct MSAAMENUINFO
+    {
+        public int dwMSAASignature;
+        public int cchWText;
+        public string pszWText;
+
+        public MSAAMENUINFO(string text)
+        {
+            dwMSAASignature = unchecked((int)MSAA_MENU_SIG);
+            cchWText = text.Length;
+            pszWText = text;
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    public class MENUITEMINFO_T
+    {
+        public int cbSize = Marshal.SizeOf<MENUITEMINFO_T>();
+        public int fMask;
+        public int fType;
+        public int fState;
+        public int wID;
+        public IntPtr hSubMenu;
+        public IntPtr hbmpChecked;
+        public IntPtr hbmpUnchecked;
+        public IntPtr dwItemData;
+        public string? dwTypeData;
+        public int cch;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct NMTOOLBAR
+    {
+        public NMHDR hdr;
+        public int iItem;
+        public TBBUTTON tbButton;
+        public int cchText;
+        public IntPtr pszText;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct TBBUTTON
+    {
+        public int iBitmap;
+        public int idCommand;
+        public byte fsState;
+        public byte fsStyle;
+        public byte bReserved0;
+        public byte bReserved1;
+        public IntPtr dwData;
+        public IntPtr iString;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    public class TOOLTIPTEXT
+    {
+        public NMHDR hdr;
+        public string? lpszText;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
+        public string? szText = null;
+
+        public IntPtr hinst;
+        public int uFlags;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    public struct TBBUTTONINFO
+    {
+        public int cbSize;
+        public int dwMask;
+        public int idCommand;
+        public int iImage;
+        public byte fsState;
+        public byte fsStyle;
+        public short cx;
+        public IntPtr lParam;
+        public IntPtr pszText;
+        public int cchTest;
+    }
+
+    public static class Util
+    {
+        public static int MAKELONG(int low, int high)
+        {
+            return (high << 16) | (low & 0xffff);
+        }
+
+        public static IntPtr MAKELPARAM(int low, int high)
+        {
+            return (IntPtr)((high << 16) | (low & 0xffff));
+        }
+
+        public static int HIWORD(int n)
+        {
+            return (n >> 16) & 0xffff;
+        }
+
+        public static int HIWORD(IntPtr n)
+        {
+            return HIWORD(unchecked((int)(long)n));
+        }
+
+        public static int LOWORD(int n)
+        {
+            return n & 0xffff;
+        }
+
+        public static int LOWORD(IntPtr n)
+        {
+            return LOWORD(unchecked((int)(long)n));
+        }
+
+        public static int SignedHIWORD(IntPtr n)
+        {
+            return SignedHIWORD(unchecked((int)(long)n));
+        }
+
+        public static int SignedLOWORD(IntPtr n)
+        {
+            return SignedLOWORD(unchecked((int)(long)n));
+        }
+
+        public static int SignedHIWORD(int n)
+        {
+            int i = (int)(short)((n >> 16) & 0xffff);
+
+            return i;
+        }
+
+        public static int SignedLOWORD(int n)
+        {
+            int i = (int)(short)(n & 0xFFFF);
+
+            return i;
+        }
+
+        private static int GetEmbeddedNullStringLengthAnsi(string s)
+        {
+            int n = s.IndexOf('\0');
+            if (n > -1)
+            {
+                string left = s.Substring(0, n);
+                string right = s.Substring(n + 1);
+                return left.Length + GetEmbeddedNullStringLengthAnsi(right) + 1;
+            }
+            else
+            {
+                return s.Length;
+            }
+        }
     }
 }
diff --git a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/SafeNativeMethods.cs b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/SafeNativeMethods.cs
new file mode 100644
index 00000000000..ff9510b73c9
--- /dev/null
+++ b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/SafeNativeMethods.cs
@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    internal class SafeNativeMethods
+    {
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool TrackPopupMenuEx(HandleRef hmenu, int fuFlags, int x, int y, HandleRef hwnd, NativeMethods.TPMPARAMS tpm);
+
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool DrawMenuBar(HandleRef hWnd);
+
+        [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+        public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, int[] lParam);
+
+        [DllImport(ExternDll.Comctl32)]
+        public static extern bool InitCommonControlsEx(NativeMethods.INITCOMMONCONTROLSEX icc);
+
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool SetWindowPos(
+            HandleRef hWnd,
+            HandleRef hWndInsertAfter,
+            int x = 0,
+            int y = 0,
+            int cx = 0,
+            int cy = 0,
+            int flags = 0);
+
+        [DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter,
+            int x, int y, int cx, int cy, int flags);
+    }
+}
diff --git a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/UnsafeNativeMethods.cs b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/UnsafeNativeMethods.cs
index 817d87aa966..67c6da2b6f7 100644
--- a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/UnsafeNativeMethods.cs
+++ b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Internals/UnsafeNativeMethods.cs
@@ -10,4 +10,36 @@ internal static class UnsafeNativeMethods
 {
     [DllImport(Libraries.Comdlg32, SetLastError = true, CharSet = CharSet.Auto)]
     public static extern HRESULT PrintDlgEx([In, Out] NativeMethods.PRINTDLGEX lppdex);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public static extern IntPtr SendMessage(HandleRef hWnd, int msg, IntPtr wParam, string lParam);
+
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Unicode)]
+    public extern static IntPtr SendMessage(HandleRef hWnd, int Msg, IntPtr wParam, ref RECT lParam);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public static extern IntPtr SendMessage(HandleRef hWnd, int msg, HandleRef wParam, int lParam);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public static extern IntPtr SendMessage(HandleRef hWnd, int msg, IntPtr wParam, IntPtr lParam);
+
+    [DllImport(Libraries.User32, CharSet = CharSet.Auto)]
+    public static extern BOOL GetMenuItemInfo(IntPtr hMenu, int uItem, bool fByPosition, [In, Out] NativeMethods.MENUITEMINFO_T lpmii);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public extern static bool InsertMenuItem(HandleRef hMenu, int uItem, bool fByPosition, NativeMethods.MENUITEMINFO_T lpmii);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public extern static bool SetMenuItemInfo(HandleRef hMenu, int uItem, bool fByPosition, NativeMethods.MENUITEMINFO_T lpmii);
+
+    [DllImport(ExternDll.User32, CharSet = CharSet.Auto)]
+    public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, int[] lParam);
+
+    public static BOOL GetMenuItemInfo(HandleRef hMenu, int uItem, bool fByPosition, NativeMethods.MENUITEMINFO_T lpmii)
+    {
+        BOOL result = GetMenuItemInfo(hMenu.Handle, uItem, fByPosition, lpmii);
+        GC.KeepAlive(hMenu.Wrapper);
+        return result;
+    }
 }
diff --git a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Message.cs b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Message.cs
index f0ded75b306..d5322ffdce6 100644
--- a/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Message.cs
+++ b/src/System.Windows.Forms.Primitives/src/System/Windows/Forms/Message.cs
@@ -61,22 +61,26 @@ public IntPtr WParam
         set => WParamInternal = (nuint)value;
     }
 
+/*
 #if DEBUG
     [Obsolete(
         $"Casting to/from IntPtr is unsafe, use {nameof(LParamInternal)}.",
         DiagnosticId = "WFDEV001")]
 #endif
+*/
     public IntPtr LParam
     {
         readonly get => LParamInternal;
         set => LParamInternal = value;
     }
 
+/*
 #if DEBUG
     [Obsolete(
         $"Casting to/from IntPtr is unsafe, use {nameof(ResultInternal)}.",
         DiagnosticId = "WFDEV001")]
 #endif
+*/
     public IntPtr Result
     {
         readonly get => ResultInternal;
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/ComparisonHelpersTests.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/ComparisonHelpersTests.cs
deleted file mode 100644
index 1e57bf6f9c1..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/ComparisonHelpersTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Tests;
-
-public class ComparisonHelpersTests
-{
-    [Theory]
-    [InlineData(0, 0, 0, true)]
-    [InlineData(1, -1, 2, true)]
-    [InlineData(1, -1, 1, false)]
-    [InlineData(-1, 1, 2, true)]
-    [InlineData(-1, 1, 1, false)]
-    [InlineData(-1, -1, 0, true)]
-    [InlineData(-1, -2, 1, true)]
-    [InlineData(-2, -1, 1, true)]
-    [InlineData(int.MinValue, int.MinValue, int.MaxValue, true)]
-    public void EqualsInteger(int x, int y, int tolerance, bool expected)
-    {
-        Assert.Equal(expected, ComparisonHelpers.EqualsInteger(x, y, tolerance));
-    }
-
-    [Theory]
-    [InlineData(0, 0, 0, true)]
-    [InlineData(1, -1, 2, true)]
-    [InlineData(-1, 1, 2, true)]
-    [InlineData(-1, -1, 0, true)]
-    [InlineData(-1, -2, 1, true)]
-    [InlineData(-2, -1, 1, true)]
-    [InlineData(1.00000f, 1.00001f, 0.00002f, true)]
-    [InlineData(1.00000f, 1.00001f, 0.000001f, false)]
-    [InlineData(int.MinValue, int.MinValue, int.MaxValue, true)]
-    public void EqualsFloat(float x, float y, float tolerance, bool expected)
-    {
-        Assert.Equal(expected, ComparisonHelpers.EqualsFloating(x, y, tolerance));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/GlobalUsings.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/GlobalUsings.cs
deleted file mode 100644
index 4fb1a00800f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/GlobalUsings.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using Xunit;
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/Metafiles/Validators/RepeatValidatorTests.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/Metafiles/Validators/RepeatValidatorTests.cs
deleted file mode 100644
index a673d16c54d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/Metafiles/Validators/RepeatValidatorTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.Windows.Forms.Metafiles.Tests;
-
-public class RepeatValidatorTests
-{
-    [Fact]
-    public unsafe void RepeatValidator_Validate_complete_should_be_expected()
-    {
-        Mock<IEmfValidator> emfValidator = new();
-        RepeatValidator repeatValidator = new(emfValidator.Object, 2);
-
-        EmfRecord emfRecord = new();
-
-        repeatValidator.Validate(ref emfRecord, state: null!, out bool complete);
-        Assert.False(complete);
-
-        // call again - we'll be at zero now
-        repeatValidator.Validate(ref emfRecord, state: null!, out complete);
-        Assert.True(complete);
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public unsafe void RepeatValidator_Validate_should_throw_IOE_if_count_not_positive(int count)
-    {
-        Mock<IEmfValidator> emfValidator = new();
-        RepeatValidator repeatValidator = new(emfValidator.Object, count);
-
-        EmfRecord emfRecord = new();
-
-        Assert.Throws<InvalidOperationException>(() => repeatValidator.Validate(ref emfRecord, state: null!, out bool complete));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/System.Windows.Forms.Primitives.TestUtilities.Tests.csproj b/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/System.Windows.Forms.Primitives.TestUtilities.Tests.csproj
deleted file mode 100644
index a29b3da0eab..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities.Tests/System.Windows.Forms.Primitives.TestUtilities.Tests.csproj
+++ /dev/null
@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>System.Windows.Forms.Primitives.TestUtilities.Tests</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <NoWarn>$(NoWarn);618</NoWarn>
-    <Nullable>enable</Nullable>
-    <RootNamespace>System.Windows.Forms.Primitives.TestUtilities.Tests</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/ArchitectureDetection.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/ArchitectureDetection.cs
deleted file mode 100644
index 1f4610884bf..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/ArchitectureDetection.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public static class ArchitectureDetection
-{
-    public static bool Is32bit => IntPtr.Size == 4;
-    public static bool Is64bit => IntPtr.Size == 8;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/DeviceContextState.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/DeviceContextState.cs
deleted file mode 100644
index dbc98ac401b..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/DeviceContextState.cs
+++ /dev/null
@@ -1,203 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Numerics;
-using System.Windows.Forms.Metafiles;
-
-namespace System;
-
-/// <summary>
-///  Holder for tracking HDC state.
-/// </summary>
-internal unsafe class DeviceContextState
-{
-    // Not all state is handled yet. Backfilling in as we write specific tests. Of special note is that we don't
-    // have tracking for Save/RestoreDC yet.
-
-    private readonly List<State> _savedStates = new();
-    private State _currentState;
-
-    /// <summary>
-    ///  Initialize the current state of <paramref name="hdc"/>.
-    /// </summary>
-    public DeviceContextState(HDC hdc)
-    {
-        MapMode = (HDC_MAP_MODE)PInvoke.GetMapMode(hdc);
-        BackColor = PInvoke.GetBkColor(hdc);
-        TextColor = PInvoke.GetTextColor(hdc);
-        Rop2Mode = (R2_MODE)PInvoke.GetROP2(hdc);
-        TextAlign = (TEXT_ALIGN_OPTIONS)PInvoke.GetTextAlign(hdc);
-        BackgroundMode = (BACKGROUND_MODE)PInvoke.GetBkMode(hdc);
-
-        Matrix3x2 transform = default;
-        PInvoke.GetWorldTransform(hdc, (XFORM*)(void*)&transform);
-        Transform = transform;
-
-        Point point = default;
-        PInvoke.GetBrushOrgEx(hdc, &point);
-        BrushOrigin = point;
-
-        var hfont = PInvoke.GetCurrentObject(hdc, OBJ_TYPE.OBJ_FONT);
-        PInvoke.GetObject(hfont, out LOGFONTW logfont);
-        SelectedFont = logfont;
-
-        var hpen = PInvoke.GetCurrentObject(hdc, OBJ_TYPE.OBJ_PEN);
-        PInvoke.GetObject(hpen, out LOGPEN logpen);
-        SelectedPen = logpen;
-
-        var hbrush = PInvoke.GetCurrentObject(hdc, OBJ_TYPE.OBJ_BRUSH);
-        PInvoke.GetObject(hbrush, out LOGBRUSH logbrush);
-        SelectedBrush = logbrush;
-    }
-
-    public HDC_MAP_MODE MapMode { get => _currentState.MapMode; set => _currentState.MapMode = value; }
-    public R2_MODE Rop2Mode { get => _currentState.Rop2Mode; set => _currentState.Rop2Mode = value; }
-    public COLORREF BackColor { get => _currentState.BackColor; set => _currentState.BackColor = value; }
-    public COLORREF TextColor { get => _currentState.TextColor; set => _currentState.TextColor = value; }
-    public Point BrushOrigin { get => _currentState.BrushOrigin; set => _currentState.BrushOrigin = value; }
-    public TEXT_ALIGN_OPTIONS TextAlign { get => _currentState.TextAlign; set => _currentState.TextAlign = value; }
-    public BACKGROUND_MODE BackgroundMode { get => _currentState.BackgroundMode; set => _currentState.BackgroundMode = value; }
-    public LOGFONTW SelectedFont { get => _currentState.SelectedFont; set => _currentState.SelectedFont = value; }
-    public LOGBRUSH SelectedBrush { get => _currentState.SelectedBrush; set => _currentState.SelectedBrush = value; }
-    public EXTLOGPEN32 SelectedPen { get => _currentState.SelectedPen; set => _currentState.SelectedPen = value; }
-    public Point LastBeginPathBrushOrigin { get => _currentState.LastBeginPathBrushOrigin; set => _currentState.LastBeginPathBrushOrigin = value; }
-    public bool InPath { get => _currentState.InPath; set => _currentState.InPath = value; }
-    public Matrix3x2 Transform { get => _currentState.Transform; set => _currentState.Transform = value; }
-    public RECT[] ClipRegion { get => _currentState.ClipRegion; set => _currentState.ClipRegion = value; }
-
-    private struct State
-    {
-        public HDC_MAP_MODE MapMode { get; set; }
-        public R2_MODE Rop2Mode { get; set; }
-        public COLORREF BackColor { get; set; }
-        public COLORREF TextColor { get; set; }
-        public Point BrushOrigin { get; set; }
-        public TEXT_ALIGN_OPTIONS TextAlign { get; set; }
-        public BACKGROUND_MODE BackgroundMode { get; set; }
-        public LOGFONTW SelectedFont { get; set; }
-        public LOGBRUSH SelectedBrush { get; set; }
-        public EXTLOGPEN32 SelectedPen { get; set; }
-        public Point LastBeginPathBrushOrigin { get; set; }
-        public bool InPath { get; set; }
-        public Matrix3x2 Transform { get; set; }
-        public RECT[] ClipRegion { get; set; }
-    }
-
-    /// <summary>
-    ///  When using to parse a metafile, this is the list of known created objects.
-    /// </summary>
-    public List<EmfRecord> GdiObjects { get; } = new List<EmfRecord>();
-
-    /// <summary>
-    ///  Adds the given object to <see cref="GdiObjects"/>.
-    /// </summary>
-    public void AddGdiObject(ref EmfRecord record, int index)
-    {
-        // Ensure we have capacity
-        if (GdiObjects.Capacity <= index)
-        {
-            GdiObjects.Capacity = index + 1;
-        }
-
-        // Fill in any gaps if we have them
-        while (GdiObjects.Count <= index)
-        {
-            GdiObjects.Add(default);
-        }
-
-        GdiObjects[index] = record;
-    }
-
-    public void SaveDC() => _savedStates.Add(_currentState);
-
-    public void RestoreDC(int state)
-    {
-        int index;
-        if (state > 0)
-        {
-            // Positive removes a specific state
-            index = state - 1;
-        }
-        else
-        {
-            // Negative is relative (-1 is last saved state)
-            index = _savedStates.Count + state;
-        }
-
-        _currentState = _savedStates[index];
-        _savedStates.RemoveRange(index, _savedStates.Count - index);
-    }
-
-    /// <summary>
-    ///  Applies the given selection record to the state.
-    /// </summary>
-    public void SelectGdiObject(EMRINDEXRECORD* selectionRecord)
-    {
-        // Not all records are handled yet. Backfilling in as we write specific tests.
-
-        if (selectionRecord->IsStockObject)
-        {
-            HGDIOBJ hgdiobj = PInvoke.GetStockObject(selectionRecord->StockObject);
-
-            switch (selectionRecord->StockObject)
-            {
-                case GET_STOCK_OBJECT_FLAGS.ANSI_FIXED_FONT:
-                case GET_STOCK_OBJECT_FLAGS.OEM_FIXED_FONT:
-                case GET_STOCK_OBJECT_FLAGS.ANSI_VAR_FONT:
-                case GET_STOCK_OBJECT_FLAGS.SYSTEM_FONT:
-                case GET_STOCK_OBJECT_FLAGS.DEVICE_DEFAULT_FONT:
-                case GET_STOCK_OBJECT_FLAGS.SYSTEM_FIXED_FONT:
-                case GET_STOCK_OBJECT_FLAGS.DEFAULT_GUI_FONT:
-                    PInvoke.GetObject(hgdiobj, out LOGFONTW logfont);
-                    SelectedFont = logfont;
-                    break;
-                case GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.LTGRAY_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.GRAY_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.DKGRAY_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.BLACK_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.NULL_BRUSH:
-                case GET_STOCK_OBJECT_FLAGS.DC_BRUSH:
-                    PInvoke.GetObject(hgdiobj, out LOGBRUSH logBrush);
-                    SelectedBrush = logBrush;
-                    break;
-                case GET_STOCK_OBJECT_FLAGS.WHITE_PEN:
-                case GET_STOCK_OBJECT_FLAGS.BLACK_PEN:
-                case GET_STOCK_OBJECT_FLAGS.NULL_PEN:
-                case GET_STOCK_OBJECT_FLAGS.DC_PEN:
-                    PInvoke.GetObject(hgdiobj, out LOGPEN logPen);
-                    SelectedPen = logPen;
-                    break;
-                case GET_STOCK_OBJECT_FLAGS.DEFAULT_PALETTE:
-                    break;
-            }
-
-            return;
-        }
-
-        // WARNING: You can not use fields that index out of the saved EmfRecord's contents here as the struct
-        // is just a copy of the original. Any pointers or offsets outside of the struct aren't valid.
-
-        EmfRecord savedRecord = GdiObjects[(int)selectionRecord->index];
-        switch (savedRecord.Type)
-        {
-            case ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEFONTINDIRECTW:
-                SelectedFont = savedRecord.ExtCreateFontIndirectWRecord->elfw.elfLogFont;
-                break;
-            case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEPEN:
-                SelectedPen = savedRecord.CreatePenRecord->lopn;
-                break;
-            case ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEPEN:
-                SelectedPen = savedRecord.ExtCreatePenRecord->elp;
-                break;
-            case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEBRUSHINDIRECT:
-                SelectedBrush = savedRecord.CreateBrushIndirectRecord->lb;
-                break;
-        }
-    }
-
-    public Point TransformPoint(Point point) => Transform.TransformPoint(point);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/AssertExtensions.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/AssertExtensions.cs
deleted file mode 100644
index 8b1526ba282..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/AssertExtensions.cs
+++ /dev/null
@@ -1,709 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using System.Windows.Forms;
-using Xunit.Sdk;
-using static Interop;
-
-namespace System;
-
-public static class AssertExtensions
-{
-    private static bool IsNetFramework => RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework");
-
-    internal static void True(AccessibleObject accessibleObject, UiaCore.UIA propertyId)
-    {
-        Assert.True((bool)accessibleObject.GetPropertyValue(propertyId));
-    }
-
-    internal static void False(AccessibleObject accessibleObject, UiaCore.UIA propertyId)
-    {
-        Assert.False((bool)accessibleObject.GetPropertyValue(propertyId));
-    }
-
-    public static void Throws<T>(Action action, string expectedMessage)
-        where T : Exception
-    {
-        Assert.Equal(expectedMessage, Assert.Throws<T>(action).Message);
-    }
-
-    public static void ThrowsContains<T>(Action action, string expectedMessageContent)
-        where T : Exception
-    {
-        Assert.Contains(expectedMessageContent, Assert.Throws<T>(action).Message);
-    }
-
-    public static T Throws<T>(string netCoreParamName, string netFxParamName, Action action)
-        where T : ArgumentException
-    {
-        T exception = Assert.Throws<T>(action);
-
-        if (netFxParamName is null && IsNetFramework)
-        {
-            // Param name varies between .NET Framework versions -- skip checking it
-            return exception;
-        }
-
-        string expectedParamName =
-            IsNetFramework ?
-            netFxParamName : netCoreParamName;
-
-        Assert.Equal(expectedParamName, exception.ParamName);
-        return exception;
-    }
-
-    public static void Throws<T>(string netCoreParamName, string netFxParamName, Func<object> testCode)
-        where T : ArgumentException
-    {
-        T exception = Assert.Throws<T>(testCode);
-
-        if (netFxParamName is null && IsNetFramework)
-        {
-            // Param name varies between .NET Framework versions -- skip checking it
-            return;
-        }
-
-        string expectedParamName =
-            IsNetFramework ?
-            netFxParamName : netCoreParamName;
-
-        Assert.Equal(expectedParamName, exception.ParamName);
-    }
-
-    public static T Throws<T>(string expectedParamName, Action action)
-        where T : ArgumentException
-    {
-        T exception = Assert.Throws<T>(action);
-
-        Assert.Equal(expectedParamName, exception.ParamName);
-
-        return exception;
-    }
-
-    public static T Throws<T>(Action action)
-        where T : Exception
-    {
-        T exception = Assert.Throws<T>(action);
-
-        return exception;
-    }
-
-    public static TException Throws<TException, TResult>(Func<TResult> func)
-        where TException : Exception
-    {
-        object result = null;
-        bool returned = false;
-        try
-        {
-            return
-                Assert.Throws<TException>(() =>
-                {
-                    result = func();
-                    returned = true;
-                });
-        }
-        catch (Exception ex) when (returned)
-        {
-            string resultStr;
-            if (result is null)
-            {
-                resultStr = "(null)";
-            }
-            else
-            {
-                resultStr = result.ToString();
-                if (typeof(TResult) == typeof(string))
-                {
-                    resultStr = $"\"{resultStr}\"";
-                }
-            }
-
-            throw new AggregateException($"Result: {resultStr}", ex);
-        }
-    }
-
-    public static T Throws<T>(string expectedParamName, Func<object> testCode)
-        where T : ArgumentException
-    {
-        T exception = Assert.Throws<T>(testCode);
-
-        Assert.Equal(expectedParamName, exception.ParamName);
-
-        return exception;
-    }
-
-    public static async Task<T> ThrowsAsync<T>(string expectedParamName, Func<Task> testCode)
-        where T : ArgumentException
-    {
-        T exception = await Assert.ThrowsAsync<T>(testCode);
-
-        Assert.Equal(expectedParamName, exception.ParamName);
-
-        return exception;
-    }
-
-    public static void Throws<TNetCoreExceptionType, TNetFxExceptionType>(string expectedParamName, Action action)
-        where TNetCoreExceptionType : ArgumentException
-        where TNetFxExceptionType : Exception
-    {
-        if (IsNetFramework)
-        {
-            // Support cases where the .NET Core exception derives from ArgumentException
-            // but the .NET Framework exception is not.
-            if (typeof(ArgumentException).IsAssignableFrom(typeof(TNetFxExceptionType)))
-            {
-                Exception exception = Assert.Throws(typeof(TNetFxExceptionType), action);
-                Assert.Equal(expectedParamName, ((ArgumentException)exception).ParamName);
-            }
-            else
-            {
-                AssertExtensions.Throws<TNetFxExceptionType>(action);
-            }
-        }
-        else
-        {
-            AssertExtensions.Throws<TNetCoreExceptionType>(expectedParamName, action);
-        }
-    }
-
-    public static Exception Throws<TNetCoreExceptionType, TNetFxExceptionType>(Action action)
-        where TNetCoreExceptionType : Exception
-        where TNetFxExceptionType : Exception
-    {
-        return Throws(typeof(TNetCoreExceptionType), typeof(TNetFxExceptionType), action);
-    }
-
-    public static Exception Throws(Type netCoreExceptionType, Type netFxExceptionType, Action action)
-    {
-        if (IsNetFramework)
-        {
-            return Assert.Throws(netFxExceptionType, action);
-        }
-        else
-        {
-            return Assert.Throws(netCoreExceptionType, action);
-        }
-    }
-
-    public static void Throws<TNetCoreExceptionType, TNetFxExceptionType>(string netCoreParamName, string netFxParamName, Action action)
-        where TNetCoreExceptionType : ArgumentException
-        where TNetFxExceptionType : ArgumentException
-    {
-        if (IsNetFramework)
-        {
-            Throws<TNetFxExceptionType>(netFxParamName, action);
-        }
-        else
-        {
-            Throws<TNetCoreExceptionType>(netCoreParamName, action);
-        }
-    }
-
-    public static void ThrowsAny(Type firstExceptionType, Type secondExceptionType, Action action)
-    {
-        ThrowsAnyInternal(action, firstExceptionType, secondExceptionType);
-    }
-
-    private static void ThrowsAnyInternal(Action action, params Type[] exceptionTypes)
-    {
-        try
-        {
-            action();
-        }
-        catch (Exception e)
-        {
-            Type exceptionType = e.GetType();
-            if (exceptionTypes.Any(t => t.Equals(exceptionType)))
-                return;
-
-            throw new XunitException($"Expected one of: ({string.Join<Type>(", ", exceptionTypes)}) -> Actual: ({exceptionType}): {e}"); // Log message and callstack to help diagnosis
-        }
-
-        throw new XunitException($"Expected one of: ({string.Join<Type>(", ", exceptionTypes)}) -> Actual: No exception thrown");
-    }
-
-    public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType>(Action action)
-        where TFirstExceptionType : Exception
-        where TSecondExceptionType : Exception
-    {
-        ThrowsAnyInternal(action, typeof(TFirstExceptionType), typeof(TSecondExceptionType));
-    }
-
-    public static void ThrowsAny<TFirstExceptionType, TSecondExceptionType, TThirdExceptionType>(Action action)
-        where TFirstExceptionType : Exception
-        where TSecondExceptionType : Exception
-        where TThirdExceptionType : Exception
-    {
-        ThrowsAnyInternal(action, typeof(TFirstExceptionType), typeof(TSecondExceptionType), typeof(TThirdExceptionType));
-    }
-
-    public static void ThrowsIf<T>(bool condition, Action action)
-        where T : Exception
-    {
-        if (condition)
-        {
-            Assert.Throws<T>(action);
-        }
-        else
-        {
-            action();
-        }
-    }
-
-    public static void Canceled(CancellationToken cancellationToken, Action testCode)
-    {
-        OperationCanceledException oce = Assert.ThrowsAny<OperationCanceledException>(testCode);
-        if (cancellationToken.CanBeCanceled)
-        {
-            Assert.Equal(cancellationToken, oce.CancellationToken);
-        }
-    }
-
-    public static Task CanceledAsync(CancellationToken cancellationToken, Task task)
-    {
-        Assert.NotNull(task);
-        return CanceledAsync(cancellationToken, () => task);
-    }
-
-    public static async Task CanceledAsync(CancellationToken cancellationToken, Func<Task> testCode)
-    {
-        OperationCanceledException oce = await Assert.ThrowsAnyAsync<OperationCanceledException>(testCode);
-        if (cancellationToken.CanBeCanceled)
-        {
-            Assert.Equal(cancellationToken, oce.CancellationToken);
-        }
-    }
-
-    private static string AddOptionalUserMessage(string message, string userMessage)
-    {
-        if (userMessage is null)
-            return message;
-        else
-            return $"{message} {userMessage}";
-    }
-
-    /// <summary>
-    /// Tests whether the specified string contains the specified substring
-    /// and throws an exception if the substring does not occur within the
-    /// test string or if either string or substring is null.
-    /// </summary>
-    /// <param name="value">
-    /// The string that is expected to contain <paramref name="substring"/>.
-    /// </param>
-    /// <param name="substring">
-    /// The string expected to occur within <paramref name="value"/>.
-    /// </param>
-    public static void Contains(string value, string substring)
-    {
-        Assert.NotNull(value);
-        Assert.NotNull(substring);
-        Assert.Contains(substring, value, StringComparison.Ordinal);
-    }
-
-    /// <summary>
-    /// Validate that a given value is greater than another value.
-    /// </summary>
-    /// <param name="actual">The value that should be greater than <paramref name="greaterThan"/>.</param>
-    /// <param name="greaterThan">The value that <paramref name="actual"/> should be greater than.</param>
-    public static void GreaterThan<T>(T actual, T greaterThan, string userMessage = null) where T : IComparable
-    {
-        if (actual is null)
-            throw new XunitException(
-                greaterThan is null
-                    ? AddOptionalUserMessage($"Expected: <null> to be greater than <null>.", userMessage)
-                    : AddOptionalUserMessage($"Expected: <null> to be greater than {greaterThan}.", userMessage));
-
-        if (actual.CompareTo(greaterThan) <= 0)
-            throw new XunitException(AddOptionalUserMessage($"Expected: {actual} to be greater than {greaterThan}", userMessage));
-    }
-
-    /// <summary>
-    /// Validate that a given value is less than another value.
-    /// </summary>
-    /// <param name="actual">The value that should be less than <paramref name="lessThan"/>.</param>
-    /// <param name="lessThan">The value that <paramref name="actual"/> should be less than.</param>
-    public static void LessThan<T>(T actual, T lessThan, string userMessage = null) where T : IComparable
-    {
-        if (actual is null)
-        {
-            if (lessThan is null)
-            {
-                throw new XunitException(AddOptionalUserMessage($"Expected: <null> to be less than <null>.", userMessage));
-            }
-            else
-            {
-                // Null is always less than non-null
-                return;
-            }
-        }
-
-        if (actual.CompareTo(lessThan) >= 0)
-            throw new XunitException(AddOptionalUserMessage($"Expected: {actual} to be less than {lessThan}", userMessage));
-    }
-
-    /// <summary>
-    /// Validate that a given value is less than or equal to another value.
-    /// </summary>
-    /// <param name="actual">The value that should be less than or equal to <paramref name="lessThanOrEqualTo"/></param>
-    /// <param name="lessThanOrEqualTo">The value that <paramref name="actual"/> should be less than or equal to.</param>
-    public static void LessThanOrEqualTo<T>(T actual, T lessThanOrEqualTo, string userMessage = null) where T : IComparable
-    {
-        // null, by definition is always less than or equal to
-        if (actual is null)
-            return;
-
-        if (actual.CompareTo(lessThanOrEqualTo) > 0)
-            throw new XunitException(AddOptionalUserMessage($"Expected: {actual} to be less than or equal to {lessThanOrEqualTo}", userMessage));
-    }
-
-    /// <summary>
-    /// Validate that a given value is greater than or equal to another value.
-    /// </summary>
-    /// <param name="actual">The value that should be greater than or equal to <paramref name="greaterThanOrEqualTo"/></param>
-    /// <param name="greaterThanOrEqualTo">The value that <paramref name="actual"/> should be greater than or equal to.</param>
-    public static void GreaterThanOrEqualTo<T>(T actual, T greaterThanOrEqualTo, string userMessage = null) where T : IComparable
-    {
-        // null, by definition is always less than or equal to
-        if (actual is null)
-        {
-            if (greaterThanOrEqualTo is null)
-            {
-                // We're equal
-                return;
-            }
-            else
-            {
-                // Null is always less than non-null
-                throw new XunitException(AddOptionalUserMessage($"Expected: <null> to be greater than or equal to <null>.", userMessage));
-            }
-        }
-
-        if (actual.CompareTo(greaterThanOrEqualTo) < 0)
-            throw new XunitException(AddOptionalUserMessage($"Expected: {actual} to be greater than or equal to {greaterThanOrEqualTo}", userMessage));
-    }
-
-    // NOTE: Consider using SequenceEqual below instead, as it will give more useful information about what
-    // the actual differences are, especially for large arrays/spans.
-    /// <summary>
-    /// Validates that the actual array is equal to the expected array. XUnit only displays the first 5 values
-    /// of each collection if the test fails. This doesn't display at what point or how the equality assertion failed.
-    /// </summary>
-    /// <param name="expected">The array that <paramref name="actual"/> should be equal to.</param>
-    /// <param name="actual"></param>
-    public static void Equal<T>(T[] expected, T[] actual) where T : IEquatable<T>
-    {
-        // Use the SequenceEqual to compare the arrays for better performance. The default Assert.Equal method compares
-        // the arrays by boxing each element that is very slow for large arrays.
-        if (!expected.AsSpan().SequenceEqual(actual.AsSpan()))
-        {
-            string expectedString = string.Join(", ", expected);
-            string actualString = string.Join(", ", actual);
-            throw new AssertActualExpectedException(expectedString, actualString, null);
-        }
-    }
-
-    /// <summary>Validates that the two sets contains the same elements. XUnit doesn't display the full collections.</summary>
-    public static void Equal<T>(HashSet<T> expected, HashSet<T> actual)
-    {
-        if (!actual.SetEquals(expected))
-        {
-            throw new XunitException($"Expected: {string.Join(", ", expected)}{Environment.NewLine}Actual: {string.Join(", ", actual)}");
-        }
-    }
-
-    /// <summary>
-    /// Validates that the actual collection contains same items as expected collection. If the test fails, this will display:
-    /// 1. Count if two collection count are different;
-    /// 2. Missed expected collection item when found
-    /// </summary>
-    /// <param name="expected">The collection that <paramref name="actual"/> should contain same items as</param>
-    /// <param name="actual"></param>
-    /// <param name="comparer">The comparer used to compare the items in two collections</param>
-    public static void CollectionEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer)
-    {
-        var actualItemCountMapping = new Dictionary<T, ItemCount>(comparer);
-        int actualCount = 0;
-        foreach (T actualItem in actual)
-        {
-            if (actualItemCountMapping.TryGetValue(actualItem, out ItemCount countInfo))
-            {
-                countInfo.Original++;
-                countInfo.Remain++;
-            }
-            else
-            {
-                actualItemCountMapping[actualItem] = new ItemCount(1, 1);
-            }
-
-            actualCount++;
-        }
-
-        T[] expectedArray = expected.ToArray();
-        int expectedCount = expectedArray.Length;
-
-        if (expectedCount != actualCount)
-        {
-            throw new XunitException($"Expected count: {expectedCount}{Environment.NewLine}Actual count: {actualCount}");
-        }
-
-        for (int i = 0; i < expectedCount; i++)
-        {
-            T currentExpectedItem = expectedArray[i];
-            if (!actualItemCountMapping.TryGetValue(currentExpectedItem, out ItemCount countInfo))
-            {
-                throw new XunitException($"Expected: {currentExpectedItem} but not found");
-            }
-
-            if (countInfo.Remain == 0)
-            {
-                throw new XunitException($"Collections are not equal.{Environment.NewLine}Totally {countInfo.Original} {currentExpectedItem} in actual collection but expect more {currentExpectedItem}");
-            }
-
-            countInfo.Remain--;
-        }
-    }
-
-    /// <summary>
-    /// Validates that the actual span is equal to the expected span.
-    /// If this fails, determine where the differences are and create an exception with that information.
-    /// </summary>
-    /// <param name="expected">The array that <paramref name="actual"/> should be equal to.</param>
-    /// <param name="actual"></param>
-    public static void SequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual) where T : IEquatable<T>
-    {
-        // Use the SequenceEqual to compare the arrays for better performance. The default Assert.Equal method compares
-        // the arrays by boxing each element that is very slow for large arrays.
-        if (!expected.SequenceEqual(actual))
-        {
-            if (expected.Length != actual.Length)
-            {
-                throw new XunitException($"Expected: Span of length {expected.Length}{Environment.NewLine}Actual: Span of length {actual.Length}");
-            }
-            else
-            {
-                const int MaxDiffsToShow = 10;      // arbitrary; enough to be useful, hopefully, but still manageable
-
-                int diffCount = 0;
-                string message = $"Showing first {MaxDiffsToShow} differences{Environment.NewLine}";
-                for (int i = 0; i < expected.Length; i++)
-                {
-                    if (!expected[i].Equals(actual[i]))
-                    {
-                        diffCount++;
-
-                        // Add up to 10 differences to the exception message
-                        if (diffCount <= MaxDiffsToShow)
-                        {
-                            message += $"  Position {i}: Expected: {expected[i]}, Actual: {actual[i]}{Environment.NewLine}";
-                        }
-                    }
-                }
-
-                message += $"Total number of differences: {diffCount} out of {expected.Length}";
-
-                throw new XunitException(message);
-            }
-        }
-    }
-
-    public static void FilledWith<T>(T expected, ReadOnlySpan<T> actual)
-    {
-        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
-
-        for (int i = 0; i < actual.Length; i++)
-        {
-            if (!comparer.Equals(expected, actual[i]))
-            {
-                throw new XunitException($"Expected {expected?.ToString() ?? "null"} at position {i}; actual {actual[i]?.ToString() ?? "null"}");
-            }
-        }
-    }
-
-    public static void SequenceEqual<T>(Span<T> expected, Span<T> actual) where T : IEquatable<T> => SequenceEqual((ReadOnlySpan<T>)expected, (ReadOnlySpan<T>)actual);
-
-    public static void SequenceEqual<T>(T[] expected, T[] actual) where T : IEquatable<T> => SequenceEqual(expected.AsSpan(), actual.AsSpan());
-
-    public static void AtLeastOneEquals<T>(T expected1, T expected2, T value)
-    {
-        EqualityComparer<T> comparer = EqualityComparer<T>.Default;
-        if (!(comparer.Equals(value, expected1) || comparer.Equals(value, expected2)))
-            throw new XunitException($"Expected: {expected1} || {expected2}{Environment.NewLine}Actual: {value}");
-    }
-
-    /// <summary>
-    /// Compares two strings, logs entire content if they are not equal.
-    /// </summary>
-    public static void Equal(string expected, string actual)
-    {
-        try
-        {
-            Assert.Equal(expected, actual);
-        }
-        catch (Exception e)
-        {
-            throw new XunitException(
-                e.Message + Environment.NewLine +
-                Environment.NewLine +
-                "Expected:" + Environment.NewLine +
-                expected + Environment.NewLine +
-                Environment.NewLine +
-                "Actual:" + Environment.NewLine +
-                actual + Environment.NewLine +
-                Environment.NewLine);
-        }
-    }
-
-    public delegate void AssertThrowsActionReadOnly<T>(ReadOnlySpan<T> span);
-
-    public delegate void AssertThrowsAction<T>(Span<T> span);
-
-    // Cannot use standard Assert.Throws() when testing Span - Span and closures don't get along.
-    public static E AssertThrows<E, T>(ReadOnlySpan<T> span, AssertThrowsActionReadOnly<T> action) where E : Exception
-    {
-        Exception exception;
-
-        try
-        {
-            action(span);
-            exception = null;
-        }
-        catch (Exception ex)
-        {
-            exception = ex;
-        }
-
-        switch(exception)
-        {
-            case null:
-                throw new ThrowsException(typeof(E));
-            case E ex when (ex.GetType() == typeof(E)):
-                return ex;
-            default:
-                throw new ThrowsException(typeof(E), exception);
-        }
-    }
-
-    public static E AssertThrows<E, T>(Span<T> span, AssertThrowsAction<T> action) where E : Exception
-    {
-        Exception exception;
-
-        try
-        {
-            action(span);
-            exception = null;
-        }
-        catch (Exception ex)
-        {
-            exception = ex;
-        }
-
-        switch(exception)
-        {
-            case null:
-                throw new ThrowsException(typeof(E));
-            case E ex when (ex.GetType() == typeof(E)):
-                return ex;
-            default:
-                throw new ThrowsException(typeof(E), exception);
-        }
-    }
-
-    public static E Throws<E, T>(string expectedParamName, ReadOnlySpan<T> span, AssertThrowsActionReadOnly<T> action)
-        where E : ArgumentException
-    {
-        E exception = AssertThrows<E, T>(span, action);
-        Assert.Equal(expectedParamName, exception.ParamName);
-        return exception;
-    }
-
-    public static E Throws<E, T>(string expectedParamName, Span<T> span, AssertThrowsAction<T> action)
-        where E : ArgumentException
-    {
-        E exception = AssertThrows<E, T>(span, action);
-        Assert.Equal(expectedParamName, exception.ParamName);
-        return exception;
-    }
-
-    private class ItemCount
-    {
-        public int Original { get; set; }
-        public int Remain { get; set; }
-
-        public ItemCount(int original, int remain)
-        {
-            Original = original;
-            Remain = remain;
-        }
-    }
-
-    /// <summary>Verifies that two <see cref="RectangleF"/> values are equal, within the <paramref name="variance"/>.</summary>
-    /// <param name="expected">The expected value</param>
-    /// <param name="actual">The value to be compared against</param>
-    /// <param name="variance">The total variance allowed between the expected and actual results.</param>
-    /// <exception cref="EqualException">Thrown when the values are not equal</exception>
-    public static void Equal(RectangleF expected, RectangleF actual, float variance)
-    {
-        if (!ComparisonHelpers.EqualsFloating(expected.X, actual.X, variance)
-            || !ComparisonHelpers.EqualsFloating(expected.Y, actual.Y, variance)
-            || !ComparisonHelpers.EqualsFloating(expected.Width, actual.Width, variance)
-            || !ComparisonHelpers.EqualsFloating(expected.Height, actual.Height, variance))
-        {
-            throw new EqualException(expected, actual);
-        }
-    }
-
-    /// <summary>Verifies that two <typeparamref name="T"/> values are equal, within the <paramref name="variance"/>.</summary>
-    /// <param name="expected">The expected value</param>
-    /// <param name="actual">The value to be compared against</param>
-    /// <param name="variance">The total variance allowed between the expected and actual results.</param>
-    /// <exception cref="EqualException">Thrown when the values are not equal</exception>
-    public static void Equal<T>(T expected, T actual, T variance)
-        where T : struct, IFloatingPoint<T>
-    {
-        if (!ComparisonHelpers.EqualsFloating(expected, actual, variance))
-        {
-            throw new EqualException(ToStringPadded(expected), ToStringPadded(actual));
-        }
-
-        // We have a custom ToString here to ensure that edge cases (specifically +-0.0,
-        // but also NaN and +-infinity) are correctly and consistently represented.
-        static string ToStringPadded(T value)
-        {
-            if (T.IsNaN(value))
-            {
-                return "NaN".PadLeft(10);
-            }
-            else if (T.IsPositiveInfinity(value))
-            {
-                return "+\u221E".PadLeft(10);
-            }
-            else if (T.IsNegativeInfinity(value))
-            {
-                return "-\u221E".PadLeft(10);
-            }
-            else if (IsNegativeZero(value))
-            {
-                return "-0.0".PadLeft(10);
-            }
-            else if (IsPositiveZero(value))
-            {
-                return "+0.0".PadLeft(10);
-            }
-            else
-            {
-                return $"{value,10:G9}";
-            }
-        }
-    }
-
-    private static unsafe bool IsNegativeZero<T>(T value)
-        where T : IFloatingPoint<T>
-        => T.IsZero(value) && T.IsNegative(value);
-
-    private static unsafe bool IsPositiveZero<T>(T value)
-        where T : IFloatingPoint<T>
-        => T.IsZero(value) && T.IsPositive(value);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/GdiExtensions.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/GdiExtensions.cs
deleted file mode 100644
index 790585670e0..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/GdiExtensions.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Numerics;
-
-namespace System;
-
-internal static class GdiExtensions
-{
-    public static string ToSystemColorString(this COLORREF colorRef)
-        => SystemCOLORs.ToSystemColorString(colorRef);
-
-    public static Point TransformPoint(in this Matrix3x2 transform, Point point)
-    {
-        if (transform.IsIdentity)
-        {
-            return point;
-        }
-
-        float y = point.Y;
-        float x = point.X;
-
-        float xadd = y * transform.M21 + transform.M31;
-        float yadd = x * transform.M12 + transform.M32;
-        x *= transform.M11;
-        x += xadd;
-        y *= transform.M22;
-        y += yadd;
-
-        return new Point((int)x, (int)y);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/SpanExtensions.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/SpanExtensions.cs
deleted file mode 100644
index a43299aa580..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/SpanExtensions.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public static class SpanExtensions
-{
-    public static T2[] Transform<T1, T2>(this ReadOnlySpan<T1> span, Func<T1, T2> transform)
-    {
-        T2[] output = new T2[span.Length];
-        for (int i = 0; i < span.Length; i++)
-        {
-            output[i] = transform(span[i]);
-        }
-
-        return output;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/TheoryExtensions.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/TheoryExtensions.cs
deleted file mode 100644
index aac1b9bfedd..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Extensions/TheoryExtensions.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System;
-
-public static class TheoryExtensions
-{
-    /// <summary>
-    ///  Converts an IEnumerable<typeparamref name="T"/> into an Xunit theory compatible enumerable.
-    /// </summary>
-    public static TheoryData ToTheoryData<T>(this IEnumerable<T> data)
-    {
-        // Returning TheoryData rather than IEnumerable<object> directly should
-        // encourage discover and usage of TheoryData<T1, ..> classes for more
-        // complicated theories. Slightly easier to type as well.
-        return new TheoryDataAdapter(data.Select(d => new object[] { d }));
-    }
-
-    private class TheoryDataAdapter : TheoryData, IEnumerable<object[]>
-    {
-        private readonly IEnumerable<object[]> _data;
-
-        public TheoryDataAdapter(IEnumerable<object[]> data)
-        {
-            _data = data;
-        }
-
-        public new IEnumerator<object[]> GetEnumerator() => _data.GetEnumerator();
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/GdiHelper.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/GdiHelper.cs
deleted file mode 100644
index 6d99d4c510d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/GdiHelper.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-/// <summary>
-///  Utility class for Gdi related things.
-/// </summary>
-public static class GdiHelper
-{
-    static GdiHelper()
-    {
-        using var dc = GetDcScope.ScreenDC;
-        LogicalPixelsX = PInvoke.GetDeviceCaps(dc, GET_DEVICE_CAPS_INDEX.LOGPIXELSX);
-        LogicalPixelsY = PInvoke.GetDeviceCaps(dc, GET_DEVICE_CAPS_INDEX.LOGPIXELSY);
-    }
-
-    /// <summary>
-    ///  Logical pixels per inch horizontally.
-    /// </summary>
-    public static int LogicalPixelsX { get; private set; }
-
-    /// <summary>
-    ///  Logical pixels per inch vertically.
-    /// </summary>
-    public static int LogicalPixelsY { get; private set; }
-
-    // private const int TwipsPerInch = 1440;
-
-    /// <summary>
-    ///  Himetric units per inch.
-    /// </summary>
-    public const int HiMetricPerInch = 2540;
-
-    /// <summary>
-    ///  Convert HiMetric units to pixels (width).
-    /// </summary>
-    public static int HimetricToPixelX(int himetric)
-        => (int)Math.Round((double)((long)LogicalPixelsX * himetric) / HiMetricPerInch, 0);
-
-    /// <summary>
-    ///  Convert Himetric units to pixels (height).
-    /// </summary>
-    public static int HimetricToPixelY(int himetric)
-        => (int)Math.Round((double)((long)LogicalPixelsY * himetric) / HiMetricPerInch, 0);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/GlobalUsings.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/GlobalUsings.cs
deleted file mode 100644
index f5e1f631fa7..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/GlobalUsings.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using System.Diagnostics.CodeAnalysis;
-global using Windows.Win32;
-global using Windows.Win32.Foundation;
-global using Windows.Win32.Graphics.Gdi;
-global using Windows.Win32.UI.WindowsAndMessaging;
-global using Xunit;
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/HdcDeviceContextAdapter.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/HdcDeviceContextAdapter.cs
deleted file mode 100644
index c63a5379759..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/HdcDeviceContextAdapter.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System;
-
-/// <summary>
-///  Simple adapter for passing <see cref="HDC"/> as <see cref="IDeviceContext"/>. Does not manage HDC
-///  lifetime.
-/// </summary>
-internal class HdcDeviceContextAdapter : IDeviceContext
-{
-    private readonly HDC _hdc;
-
-    public HdcDeviceContextAdapter(HDC hdc) => _hdc = hdc;
-
-    public IntPtr GetHdc() => (IntPtr)_hdc;
-    public void ReleaseHdc() { }
-    public void Dispose() { }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/DataHelpers.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/DataHelpers.cs
deleted file mode 100644
index a7ce7ef14b2..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/DataHelpers.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-public static class DataHelpers
-{
-    public static unsafe Point[] PointArray(params int[] values)
-    {
-        if (values is null)
-            throw new ArgumentNullException(nameof(values));
-
-        if (values.Length % 2 != 0)
-            throw new ArgumentOutOfRangeException(nameof(values));
-
-        Point[] points = new Point[values.Length / 2];
-        fixed (int* i = values)
-        fixed (Point* p = points)
-        {
-            Unsafe.CopyBlock(p, i, (uint)(sizeof(int) * values.Length));
-        }
-
-        return points;
-    }
-
-    public static unsafe Point[] PointArray(Matrix3x2 transform, params int[] values)
-    {
-        Point[] points = PointArray(values);
-        for (int i = 0; i < points.Length; i++)
-        {
-            points[i] = transform.TransformPoint(points[i]);
-        }
-
-        return points;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfRecord.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfRecord.cs
deleted file mode 100644
index ffd635f77fe..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfRecord.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-using Windows.Win32.UI.ColorSystem;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal readonly unsafe struct EmfRecord
-{
-    public HDC HDC { get; }
-    private readonly HANDLETABLE* _lpht;
-    private readonly ENHMETARECORD* _lpmr;
-    private readonly int _nHandles;
-    public LPARAM Data { get; }
-
-    public EmfRecord(
-        HDC hdc,
-        HANDLETABLE* lpht,
-        ENHMETARECORD* lpmr,
-        int nHandles,
-        LPARAM data)
-    {
-        HDC = hdc;
-        _lpht = lpht;
-        _lpmr = lpmr;
-        _nHandles = nHandles;
-        Data = data;
-    }
-
-    public ENHANCED_METAFILE_RECORD_TYPE Type => _lpmr->iType;
-    public ReadOnlySpan<uint> Params => _lpmr->dParm.AsReadOnlySpan();
-    public ReadOnlySpan<HGDIOBJ> Handles => new(_lpht, _nHandles);
-
-    public ENHMETAHEADER* HeaderRecord => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_HEADER ? (ENHMETAHEADER*)_lpmr : null;
-    public EMREXTSELECTCLIPRGN* ExtSelectClipRgnRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTSELECTCLIPRGN ? (EMREXTSELECTCLIPRGN*)_lpmr : null;
-    public EMRPOINTRECORD* SetViewportOrgExRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETVIEWPORTORGEX ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRPOINTRECORD* SetBrushOrgExRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBRUSHORGEX ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRPOINTRECORD* SetWindowOrgExRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETWINDOWORGEX ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRPOINTRECORD* OffsetClipRgnRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_OFFSETCLIPRGN ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRPOINTRECORD* MoveToExRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_MOVETOEX ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRPOINTRECORD* LineToRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_LINETO ? (EMRPOINTRECORD*)_lpmr : null;
-    public EMRCREATEBRUSHINDIRECT* CreateBrushIndirectRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEBRUSHINDIRECT ? (EMRCREATEBRUSHINDIRECT*)_lpmr : null;
-    public EMRENUMRECORD<R2_MODE>* SetROP2Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETROP2 ? (EMRENUMRECORD<R2_MODE>*)_lpmr : null;
-    public EMRENUMRECORD<BACKGROUND_MODE>* SetBkModeRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKMODE ? (EMRENUMRECORD<BACKGROUND_MODE>*)_lpmr : null;
-    public EMRCREATEPEN* CreatePenRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEPEN ? (EMRCREATEPEN*)_lpmr : null;
-    public EMREXTCREATEPEN* ExtCreatePenRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEPEN ? (EMREXTCREATEPEN*)_lpmr : null;
-    public EMRINDEXRECORD* SelectObjectRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SELECTOBJECT ? (EMRINDEXRECORD*)_lpmr : null;
-    public EMRINDEXRECORD* DeleteObjectRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_DELETEOBJECT ? (EMRINDEXRECORD*)_lpmr : null;
-    public EMRBITBLT* BitBltRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT ? (EMRBITBLT*)_lpmr : null;
-    public EMRENUMRECORD<ICM_MODE>* SetIcmModeRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETICMMODE ? (EMRENUMRECORD<ICM_MODE>*)_lpmr : null;
-    public EMRPOLY16* Polygon16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16 ? (EMRPOLY16*)_lpmr : null;
-    public EMRPOLY16* Polyline16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE16 ? (EMRPOLY16*)_lpmr : null;
-    public EMRPOLY16* PolyBezier16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIER16 ? (EMRPOLY16*)_lpmr : null;
-    public EMRPOLY16* PolylineTo16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINETO16 ? (EMRPOLY16*)_lpmr : null;
-    public EMRPOLY16* PolyBezierTo16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIERTO16 ? (EMRPOLY16*)_lpmr : null;
-    public EMRPOLYPOLY16* PolyPolyline16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE16 ? (EMRPOLYPOLY16*)_lpmr : null;
-    public EMRPOLYPOLY16* PolyPolygon16Record
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16 ? (EMRPOLYPOLY16*)_lpmr : null;
-    public EMRSETWORLDTRANSFORM* SetWorldTransformRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETWORLDTRANSFORM ? (EMRSETWORLDTRANSFORM*)_lpmr : null;
-    public EMRMODIFYWORLDTRANSFORM* ModifyWorldTransformRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_MODIFYWORLDTRANSFORM ? (EMRMODIFYWORLDTRANSFORM*)_lpmr : null;
-    public EMRSETCOLOR* SetBkColorRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKCOLOR ? (EMRSETCOLOR*)_lpmr : null;
-    public EMRSETCOLOR* SetTextColorRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTCOLOR ? (EMRSETCOLOR*)_lpmr : null;
-    public EMRCREATEDIBPATTERNBRUSHPT* CreateDibPatternBrushPtRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEDIBPATTERNBRUSHPT ? (EMRCREATEDIBPATTERNBRUSHPT*)_lpmr : null;
-    public EMRENUMRECORD<TEXT_ALIGN_OPTIONS>* SetTextAlignRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTALIGN ? (EMRENUMRECORD<TEXT_ALIGN_OPTIONS>*)_lpmr : null;
-    public EMREXTCREATEFONTINDIRECTW* ExtCreateFontIndirectWRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEFONTINDIRECTW ? (EMREXTCREATEFONTINDIRECTW*)_lpmr : null;
-    public EMREXTTEXTOUTW* ExtTextOutWRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTTEXTOUTW ? (EMREXTTEXTOUTW*)_lpmr : null;
-    public EMRENUMRECORD<HDC_MAP_MODE>* SetMapModeRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_SETMAPMODE ? (EMRENUMRECORD<HDC_MAP_MODE>*)_lpmr : null;
-    public EMRRECTRECORD* FillPathRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_FILLPATH ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* StrokeAndFillPathRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEANDFILLPATH ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* StrokePathRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEPATH ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* ExcludeClipRectRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXCLUDECLIPRECT ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* IntersetClipRectRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_INTERSECTCLIPRECT ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* EllipseRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_ELLIPSE ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRECTRECORD* RectangleRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_RECTANGLE ? (EMRRECTRECORD*)_lpmr : null;
-    public EMRRESTOREDC* RestoreDCRecord
-        => Type == ENHANCED_METAFILE_RECORD_TYPE.EMR_RESTOREDC ? (EMRRESTOREDC*)_lpmr : null;
-
-    public override string ToString() => Type switch
-    {
-        // Note that not all records have special handling yet- we're filling these in as we go.
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_HEADER => HeaderRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTSELECTCLIPRGN => ExtSelectClipRgnRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETVIEWPORTORGEX => SetViewportOrgExRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETWINDOWORGEX => SetWindowOrgExRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_OFFSETCLIPRGN => OffsetClipRgnRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_MOVETOEX => MoveToExRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_LINETO => LineToRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEBRUSHINDIRECT => CreateBrushIndirectRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKMODE => SetBkModeRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETROP2 => SetROP2Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEPEN => CreatePenRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEPEN => ExtCreatePenRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SELECTOBJECT => SelectObjectRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_DELETEOBJECT => DeleteObjectRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT => BitBltRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETICMMODE => SetIcmModeRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE16 => Polyline16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIER16 => PolyBezier16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16 => Polygon16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIERTO16 => PolyBezierTo16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINETO16 => PolylineTo16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16 => PolyPolygon16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE16 => PolyPolyline16Record->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETWORLDTRANSFORM => SetWorldTransformRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_MODIFYWORLDTRANSFORM => ModifyWorldTransformRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTCOLOR => SetTextColorRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKCOLOR => SetBkColorRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEDIBPATTERNBRUSHPT => CreateDibPatternBrushPtRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTALIGN => SetTextAlignRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEFONTINDIRECTW => ExtCreateFontIndirectWRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTTEXTOUTW => ExtTextOutWRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_SETMAPMODE => SetMapModeRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_FILLPATH => FillPathRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEANDFILLPATH => StrokeAndFillPathRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEPATH => StrokePathRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_EXCLUDECLIPRECT => ExcludeClipRectRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_INTERSECTCLIPRECT => IntersetClipRectRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_ELLIPSE => EllipseRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_RECTANGLE => RectangleRecord->ToString(),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_RESTOREDC => RestoreDCRecord->ToString(),
-        _ => $"[EMR{Type}]"
-    };
-
-    public string ToString(DeviceContextState state) => Type switch
-    {
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE16 => Polyline16Record->ToString(state),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16 => Polygon16Record->ToString(state),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16 => PolyPolygon16Record->ToString(state),
-        ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE16 => PolyPolyline16Record->ToString(state),
-        _ => ToString()
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfScope.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfScope.cs
deleted file mode 100644
index c4434fd1555..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/EmfScope.cs
+++ /dev/null
@@ -1,258 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.Numerics;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class EmfScope :
-#if DEBUG
-    DisposalTracking.Tracker,
-#endif
-    IDisposable
-{
-    public HDC HDC { get; }
-    private HENHMETAFILE _hemf;
-
-    public unsafe EmfScope()
-        : this(CreateEnhMetaFile())
-    {
-    }
-
-    public EmfScope(HDC hdc)
-    {
-        HDC = hdc;
-        _hemf = default;
-    }
-
-    public EmfScope(HENHMETAFILE hemf)
-    {
-        _hemf = hemf;
-    }
-
-    private static unsafe HDC CreateEnhMetaFile(
-        HDC hdc = default,
-        string? lpFilename = null,
-        RECT* lprc = null,
-        string? lpDesc = null)
-    {
-        fixed (char* pFileName = lpFilename)
-        fixed (char* pDesc = lpDesc)
-        {
-            HDC metafileHdc = PInvoke.CreateEnhMetaFile(hdc, pFileName, lprc, pDesc);
-            if (metafileHdc.IsNull)
-            {
-                throw new Win32Exception("Could not create metafile");
-            }
-
-            return metafileHdc;
-        }
-    }
-
-    public static unsafe EmfScope Create() => new();
-
-    public HENHMETAFILE HENHMETAFILE
-    {
-        get
-        {
-            if (_hemf.IsNull)
-            {
-                if (HDC.IsNull)
-                {
-                    return default;
-                }
-
-                _hemf = PInvoke.CloseEnhMetaFile(HDC);
-            }
-
-            return _hemf;
-        }
-    }
-
-    public unsafe void Enumerate(ProcessRecordDelegate enumerator)
-    {
-        GCHandle enumeratorHandle = GCHandle.Alloc(enumerator);
-        try
-        {
-            var callback = Marshal.GetFunctionPointerForDelegate(CallBack);
-            PInvoke.EnumEnhMetaFile(
-                default,
-                HENHMETAFILE,
-                (delegate* unmanaged[Stdcall]<HDC, HANDLETABLE*, ENHMETARECORD*, int, LPARAM, int>)callback,
-                (void*)(nint)enumeratorHandle,
-                (RECT*)null);
-        }
-        finally
-        {
-            if (enumeratorHandle.IsAllocated)
-            {
-                enumeratorHandle.Free();
-            }
-        }
-    }
-
-    /// <summary>
-    ///  Allows enumerating the metafile records while tracking state. <paramref name="state"/> should be
-    ///  initialized to the metafile DC state before any drawing has begun.
-    /// </summary>
-    /// <remarks>
-    ///  <para>
-    ///   State is whatever is current *before* the current record is "applied" as it is necessary to understand
-    ///   what delta the actual record makes.
-    ///  </para>
-    /// </remarks>
-    public unsafe void EnumerateWithState(ProcessRecordWithStateDelegate enumerator, DeviceContextState state)
-    {
-        Enumerate(stateTracker);
-
-        bool stateTracker(ref EmfRecord record)
-        {
-            bool result = enumerator(ref record, state);
-
-            // This must come *after* calling the nested enumerator so that the record reflects what is *about*
-            // to be applied. If we invert the model you wouldn't be able to tell what things like LineTo actually
-            // do as they only contain the destination point.
-            switch (record.Type)
-            {
-                // Not all records are handled yet. Backfilling in as we write specific tests.
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTALIGN:
-                    state.TextAlign = record.SetTextAlignRecord->iMode;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETMAPMODE:
-                    state.MapMode = record.SetMapModeRecord->iMode;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKMODE:
-                    state.BackgroundMode = record.SetBkModeRecord->iMode;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETROP2:
-                    state.Rop2Mode = record.SetROP2Record->iMode;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETTEXTCOLOR:
-                    state.TextColor = record.SetTextColorRecord->crColor;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETBKCOLOR:
-                    state.BackColor = record.SetBkColorRecord->crColor;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_MOVETOEX:
-                    state.BrushOrigin = record.MoveToExRecord->point;
-                    // The documentation indicates that the last MoveTo will be where CloseFigure draws a line to.
-                    state.LastBeginPathBrushOrigin = state.BrushOrigin;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_LINETO:
-                    state.BrushOrigin = record.LineToRecord->point;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_BEGINPATH:
-                    state.LastBeginPathBrushOrigin = state.BrushOrigin;
-                    state.InPath = true;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_ABORTPATH:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_ENDPATH:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CLOSEFIGURE:
-                    state.InPath = false;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEFONTINDIRECTW:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEPALETTE:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEPEN:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTCREATEPEN:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEMONOBRUSH:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEBRUSHINDIRECT:
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_CREATEDIBPATTERNBRUSHPT:
-                    // All of these records have their index as the first "parameter".
-                    state.AddGdiObject(ref record, (int)record.Params[0]);
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SELECTOBJECT:
-                    state.SelectGdiObject(record.SelectObjectRecord);
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_DELETEOBJECT:
-                    state.GdiObjects[(int)record.DeleteObjectRecord->index] = default;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTSELECTCLIPRGN:
-                    state.ClipRegion = record.ExtSelectClipRgnRecord->ClippingRectangles;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SETWORLDTRANSFORM:
-                    state.Transform = record.SetWorldTransformRecord->xform;
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_MODIFYWORLDTRANSFORM:
-                    var transform = record.ModifyWorldTransformRecord;
-                    switch (transform->iMode)
-                    {
-                        case MODIFY_WORLD_TRANSFORM_MODE.MWT_IDENTITY:
-                            state.Transform = Matrix3x2.Identity;
-                            break;
-                        case MODIFY_WORLD_TRANSFORM_MODE.MWT_LEFTMULTIPLY:
-                            state.Transform = transform->xform * state.Transform;
-                            break;
-                        case MODIFY_WORLD_TRANSFORM_MODE.MWT_RIGHTMULTIPLY:
-                            state.Transform = state.Transform * transform->xform;
-                            break;
-                    }
-
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_SAVEDC:
-                    state.SaveDC();
-                    break;
-                case ENHANCED_METAFILE_RECORD_TYPE.EMR_RESTOREDC:
-                    state.RestoreDC(record.RestoreDCRecord->iRelative);
-                    break;
-            }
-
-            return result;
-        }
-    }
-
-    public string RecordsToString()
-    {
-        StringBuilder sb = new StringBuilder(1024);
-        Enumerate((ref EmfRecord record) =>
-        {
-            sb.AppendLine(record.ToString());
-            return true;
-        });
-
-        return sb.ToString();
-    }
-
-    public string RecordsToStringWithState(DeviceContextState state)
-    {
-        StringBuilder sb = new StringBuilder(1024);
-        EnumerateWithState((ref EmfRecord record, DeviceContextState state) =>
-        {
-            sb.AppendLine(record.ToString(state));
-            return true;
-        },
-        state);
-
-        return sb.ToString();
-    }
-
-    private static unsafe BOOL CallBack(
-        HDC hdc,
-        HANDLETABLE* lpht,
-        ENHMETARECORD* lpmr,
-        int nHandles,
-        LPARAM data)
-    {
-        // Note that the record pointer is *only* valid during the callback.
-        GCHandle enumeratorHandle = GCHandle.FromIntPtr(data);
-        ProcessRecordDelegate enumerator = (ProcessRecordDelegate)enumeratorHandle.Target!;
-        var record = new EmfRecord(hdc, lpht, lpmr, nHandles, data);
-        return enumerator(ref record);
-    }
-
-    public static implicit operator HDC(in EmfScope scope) => scope.HDC;
-
-    public void Dispose()
-    {
-        if (!HDC.IsNull)
-        {
-            PInvoke.DeleteEnhMetaFile(HENHMETAFILE);
-        }
-
-        GC.SuppressFinalize(this);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordDelegate.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordDelegate.cs
deleted file mode 100644
index e741bfa43ea..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordDelegate.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal delegate bool ProcessRecordDelegate(ref EmfRecord record);
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordWithStateDelegate.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordWithStateDelegate.cs
deleted file mode 100644
index d9146533152..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/ProcessRecordWithStateDelegate.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal delegate bool ProcessRecordWithStateDelegate(ref EmfRecord record, DeviceContextState state);
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMR.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMR.cs
deleted file mode 100644
index 4651cc01f0e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMR.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMR
-{
-    public ENHANCED_METAFILE_RECORD_TYPE iType;
-    public uint nSize;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRBITBLT.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRBITBLT.cs
deleted file mode 100644
index 018e457dbab..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRBITBLT.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Numerics;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRBITBLT
-{
-    public EMR emr;
-    public RECT rclBounds;          // Inclusive-inclusive bounds in device units
-    public int xDest;
-    public int yDest;
-    public int cxDest;
-    public int cyDest;
-    public ROP_CODE dwRop;
-    public int xSrc;
-    public int ySrc;
-    public Matrix3x2 xformSrc;     // Source DC transform
-    public COLORREF crBkColorSrc;  // Source DC BkColor in RGB
-    public DIB_USAGE iUsageSrc;    // Source bitmap info color table usage
-                                   // (DIB_RGB_COLORS)
-    public uint offBmiSrc;         // Offset to the source BITMAPINFO structure
-    public uint cbBmiSrc;          // Size of the source BITMAPINFO structure
-    public uint offBitsSrc;        // Offset to the source bitmap bits
-    public uint cbBitsSrc;         // Size of the source bitmap bits
-
-    public override string ToString()
-    {
-        RECT dest = new Rectangle(xDest, yDest, cxDest, cyDest);
-        return $@"[{nameof(EMRBITBLT)}] Bounds: {rclBounds} Destination: {dest} Rop: {dwRop}Source DC Color: {crBkColorSrc.ToSystemColorString()}";
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEBRUSHINDIRECT.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEBRUSHINDIRECT.cs
deleted file mode 100644
index 3fc6eab6b8d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEBRUSHINDIRECT.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRCREATEBRUSHINDIRECT
-{
-    public EMR emr;
-    public uint ihBrush;
-    public LOGBRUSH32 lb;
-
-    public override string ToString()
-        => $@"[{nameof(EMRCREATEBRUSHINDIRECT)}] Index: {ihBrush} Style: {lb.lbStyle} Color: {lb.lbColor.ToSystemColorString()}";
-
-    // This structure is used exclusively in EMRCREATEBRUSHINDIRECT
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct LOGBRUSH32
-    {
-        public BRUSH_STYLE lbStyle;
-        public COLORREF lbColor;
-        public uint lbHatch;
-
-        public static implicit operator LOGBRUSH(LOGBRUSH32 logbrush) => new()
-        {
-            lbStyle = logbrush.lbStyle,
-            lbColor = logbrush.lbColor,
-            lbHatch = logbrush.lbHatch
-        };
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEDIBPATTERNBRUSHPT.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEDIBPATTERNBRUSHPT.cs
deleted file mode 100644
index 0e6fa3b06de..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEDIBPATTERNBRUSHPT.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRCREATEDIBPATTERNBRUSHPT
-{
-    public EMR emr;
-    public uint ihBrush;            // Brush handle index
-    public uint iUsage;             // Bitmap info color table usage
-    public uint offBmi;             // Offset to the BITMAPINFO structure
-    public uint cbBmi;              // Size of the BITMAPINFO structure
-                                    // The bitmap info is followed by the bitmap
-                                    // bits to form a packed DIB.
-    public uint offBits;            // Offset to the bitmap bits
-    public uint cbBits;             // Size of the bitmap bits
-
-    public override string ToString()
-        => $"[{nameof(EMRCREATEDIBPATTERNBRUSHPT)}] Index: {ihBrush}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEPEN.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEPEN.cs
deleted file mode 100644
index 4251c9dd463..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRCREATEPEN.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRCREATEPEN
-{
-    public EMR emr;
-    public uint ihPen;
-    public LOGPEN lopn;
-
-    public override string ToString()
-        => $@"[{nameof(EMRCREATEPEN)}] Index: {ihPen} Style: {lopn.lopnStyle} Width: {lopn.lopnWidth} Color: {lopn.lopnColor.ToSystemColorString()}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRENUMRECORD.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRENUMRECORD.cs
deleted file mode 100644
index 0da5b8ac4de..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRENUMRECORD.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that has just a single enum value.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///   - EMRSELECTCLIPPATH
-///   - EMRSETBKMODE
-///   - EMRSETMAPMODE
-///   - EMRSETLAYOUT
-///   - EMRSETPOLYFILLMODE
-///   - EMRSETROP2
-///   - EMRSETSTRETCHBLTMODE
-///   - EMRSETTEXTALIGN
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRENUMRECORD<T> where T : Enum
-{
-    public EMR emr;
-    public T iMode;
-
-    public override string ToString() => $"[EMR{emr.iType}] Mode: {typeof(T).Name}_{iMode}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEFONTINDIRECTW.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEFONTINDIRECTW.cs
deleted file mode 100644
index 14306f07a8a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEFONTINDIRECTW.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMREXTCREATEFONTINDIRECTW
-{
-    public EMR emr;
-    public uint ihFont;
-    public EXTLOGFONTW elfw;
-
-    public override string ToString()
-        => $@"[{nameof(EMREXTCREATEFONTINDIRECTW)}] Index: {ihFont} FaceName: '{elfw.elfLogFont.FaceName.ToString()}' Height: {elfw.elfLogFont.lfHeight} Weight: FW_{elfw.elfLogFont.lfWeight}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEPEN.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEPEN.cs
deleted file mode 100644
index 1b1042c59f7..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTCREATEPEN.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMREXTCREATEPEN
-{
-    public EMR emr;
-    public uint ihPen;              // Pen handle index
-    public uint offBmi;             // Offset to the BITMAPINFO structure if any
-    public uint cbBmi;              // Size of the BITMAPINFO structure if any
-                                    // The bitmap info is followed by the bitmap
-                                    // bits to form a packed DIB.
-    public uint offBits;            // Offset to the brush bitmap bits if any
-    public uint cbBits;             // Size of the brush bitmap bits if any
-    public EXTLOGPEN32 elp;         // The extended pen with the style array.
-
-    public override string ToString()
-        => $@"[{nameof(EMREXTCREATEPEN)}] Index: {ihPen} Style: {elp.elpPenStyle} Width: {elp.elpWidth}BrushStyle: {elp.elpBrushStyle} Color: {elp.elpColor.ToSystemColorString()}";
-}
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EXTLOGPEN32
-{
-    public PEN_STYLE elpPenStyle;
-    public uint elpWidth;
-    public BRUSH_STYLE elpBrushStyle;
-    public COLORREF elpColor;
-    public uint elpHatch;
-    public uint elpNumEntries;
-    public uint elpStyleEntry;
-
-    public static implicit operator EXTLOGPEN32(LOGPEN logPen) => new()
-    {
-        elpPenStyle = logPen.lopnStyle,
-        elpWidth = (uint)logPen.lopnWidth.X,
-        elpColor = logPen.lopnColor
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTSELECTCLIPRGN.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTSELECTCLIPRGN.cs
deleted file mode 100644
index 343ca889894..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTSELECTCLIPRGN.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal unsafe struct EMREXTSELECTCLIPRGN
-{
-    public EMR emr;
-    public uint cbRgnData;          // Size of region data in bytes
-    public RGN_COMBINE_MODE iMode;
-    public byte RgnData;
-
-    public RGNDATAHEADER* RegionDataHeader
-    {
-        get
-        {
-            fixed (void* data = &RgnData)
-            {
-                return cbRgnData >= sizeof(RGNDATAHEADER) ? (RGNDATAHEADER*)data : null;
-            }
-        }
-    }
-
-    public RECT[] ClippingRectangles => RGNDATAHEADER.GetRegionRects(RegionDataHeader);
-
-    public override string ToString()
-    {
-        if (RegionDataHeader is null)
-        {
-            return $"[{nameof(EMREXTSELECTCLIPRGN)}] Mode: Set Default";
-        }
-
-        StringBuilder sb = new StringBuilder(512);
-        sb.Append($@"[{nameof(EMREXTSELECTCLIPRGN)}] Mode: {iMode} Bounds: {RegionDataHeader->rcBound} Rects: {RegionDataHeader->nCount}");
-
-        RECT[] clippingRects = ClippingRectangles;
-        for (int i = 0; i < clippingRects.Length; i++)
-        {
-            sb.Append($"\n\tRect index {i}: {clippingRects[i]}");
-        }
-
-        return sb.ToString();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTTEXTOUTW.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTTEXTOUTW.cs
deleted file mode 100644
index 1fdea4428a7..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMREXTTEXTOUTW.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMREXTTEXTOUTW
-{
-    public EMR emr;
-    public RECT rclBounds;           // Inclusive-inclusive bounds in device units
-    public GM iGraphicsMode;         // Current graphics mode
-    public float exScale;            // X and Y scales from Page units to .01mm units
-    public float eyScale;            //   if graphics mode is GM_COMPATIBLE.
-    public EMRTEXT emrtext;          // This is followed by the string and spacing
-
-    public override string ToString()
-        => $@"[{nameof(EMREXTTEXTOUTW)}] Bounds: {rclBounds} Text: '{emrtext.GetText().ToString()}'";
-
-    internal enum GM : uint
-    {
-        COMPATIBLE = 0x00000001,
-        ADVANCED = 0x00000002
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRINDEXRECORD.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRINDEXRECORD.cs
deleted file mode 100644
index 26cb44240b8..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRINDEXRECORD.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that represents an index.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///   - EMRSELECTOBJECT
-///   - EMRDELETEOBJECT
-///   - EMRSELECTPALETTE
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRINDEXRECORD
-{
-    public EMR emr;
-    public uint index;
-
-    public bool IsStockObject => (index & 0x80000000) != 0;
-    public GET_STOCK_OBJECT_FLAGS StockObject => (GET_STOCK_OBJECT_FLAGS)(index & ~0x80000000);
-
-    public override string ToString()
-        => IsStockObject
-            ? $"[EMR{emr.iType}] StockObject: {StockObject}"
-            : $"[EMR{emr.iType}] Index: {index}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRMODIFYWORLDTRANSFORM.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRMODIFYWORLDTRANSFORM.cs
deleted file mode 100644
index 3433ffc8d4d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRMODIFYWORLDTRANSFORM.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Numerics;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRMODIFYWORLDTRANSFORM
-{
-    public EMR emr;
-    public Matrix3x2 xform;
-    public MODIFY_WORLD_TRANSFORM_MODE iMode;
-
-    public override string ToString() => $"[{nameof(EMRMODIFYWORLDTRANSFORM)}] Mode: {iMode} Transform: {xform}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOINTRECORD.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOINTRECORD.cs
deleted file mode 100644
index bd8531c593e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOINTRECORD.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that just has a single point value.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///    - EMRLINETO
-///    - EMRMOVETOEX
-///    - EMROFFSETCLIPRGN
-///    - EMRSETVIEWPORTORGEX
-///    - EMRSETWINDOWORGEX
-///    - EMRSETBRUSHORGEX
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRPOINTRECORD
-{
-    public EMR emr;
-    public Point point;
-
-    public override string ToString() => $"[EMR{emr.iType}] Point: {point}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLY16.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLY16.cs
deleted file mode 100644
index 8682738c802..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLY16.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using static Interop;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that represents a 16 bit Poly record.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///  - EMRPOLYLINE16
-///  - EMRPOLYBEZIER16
-///  - EMRPOLYGON16
-///  - EMRPOLYBEZIERTO16
-///  - EMRPOLYLINETO16
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRPOLY16
-{
-    public EMR emr;
-    public RECT rclBounds;          // Inclusive-inclusive bounds in device units
-    public uint cpts;
-    private POINTS _apts;
-
-    public unsafe ReadOnlySpan<POINTS> points
-    {
-        get
-        {
-            fixed (POINTS* p = &_apts)
-            {
-                return new(p, checked((int)cpts));
-            }
-        }
-    }
-
-    public override string ToString() => $"[EMR{emr.iType}] Bounds: {rclBounds} Points: {string.Join(' ', points.ToArray())}";
-
-    public string ToString(DeviceContextState state)
-    {
-        Point[] transformedPoints = points.Transform(point => state.TransformPoint(point));
-        return $"[EMR{emr.iType}] Bounds: {rclBounds} Points: {string.Join(' ', transformedPoints)}";
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLYPOLY16.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLYPOLY16.cs
deleted file mode 100644
index cd7d742ac0f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRPOLYPOLY16.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-using System.Text;
-using static Interop;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that represents a 16 bit Poly record.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///  - EMRPOLYPOLYLINE16
-///  - EMRPOLYPOLYBEZIER16
-///  - EMRPOLYPOLYGON16
-///  - EMRPOLYPOLYLINETO16
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRPOLYPOLY16
-{
-    public EMR emr;
-    public RECT rclBounds;          // Inclusive-inclusive bounds in device units
-    public uint nPolys;             // Number of polys
-    public uint cpts;               // Total number of points in all polys
-    public uint _aPolyCounts;       // Array of point counts for each poly
-
-    // Can't represent this as a field as it comes nPolys uints after cpts
-    // public POINTS apts[1];        // Array of points
-
-    public override string ToString() => ToString(null);
-
-    public string ToString(DeviceContextState? state)
-    {
-        StringBuilder sb = new StringBuilder(512);
-        sb.Append($"[EMR{emr.iType}] Bounds: {rclBounds} Poly count: {nPolys} Total points: {cpts}");
-
-        for (int i = 0; i < nPolys; i++)
-        {
-            if (state is null)
-            {
-                sb.Append($"\n\tPoly index {i}: {string.Join(' ', GetPointsForPoly(i).ToArray())}");
-            }
-            else
-            {
-                sb.Append($"\n\tPoly index {i}: {string.Join(' ', GetPointsForPoly(i).Transform(p => state.TransformPoint(p)))}");
-            }
-        }
-
-        return sb.ToString();
-    }
-
-    public unsafe ReadOnlySpan<uint> aPolyCounts
-    {
-        get
-        {
-            fixed(uint* c = &_aPolyCounts)
-            {
-                return new(c, checked((int)nPolys));
-            }
-        }
-    }
-
-    public unsafe ReadOnlySpan<POINTS> GetPointsForPoly(int index)
-    {
-        if (index < 0 || index >= nPolys)
-            throw new ArgumentOutOfRangeException(nameof(index));
-
-        int current = 0;
-        fixed (void* s = &emr)
-        {
-            POINTS* currentPoint = (POINTS*)((byte*)s + sizeof(EMRPOLYPOLY16) + (sizeof(uint) * (nPolys - 1)));
-            var counts = aPolyCounts;
-            while (current != index)
-            {
-                currentPoint += counts[current];
-                current++;
-            }
-
-            return new ReadOnlySpan<POINTS>(currentPoint, (int)counts[current]);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRECTRECORD.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRECTRECORD.cs
deleted file mode 100644
index cf55246e669..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRECTRECORD.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that just has a single <see cref="RECT"/> value.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///    - EMRFILLPATH
-///    - EMRSTROKEANDFILLPATH
-///    - EMRSTROKEPATH
-///    - EMREXCLUDECLIPRECT
-///    - EMRINTERSECTCLIPRECT
-///    - EMRELLIPSE
-///    - EMRRECTANGLE
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRRECTRECORD
-{
-    public EMR emr;
-    public RECT rect;
-
-    public override string ToString() => $"[EMR{emr.iType}] RECT: {rect}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRESTOREDC.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRESTOREDC.cs
deleted file mode 100644
index 393bcd6b9d0..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRRESTOREDC.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRRESTOREDC
-{
-    public EMR emr;
-    public int iRelative;
-
-    public override string ToString() => $"[{nameof(EMRRESTOREDC)}] Index: {iRelative}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETCOLOR.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETCOLOR.cs
deleted file mode 100644
index b959003ea2b..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETCOLOR.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Record that represents a 16 bit Poly record.
-/// </summary>
-/// <remarks>
-///   Not an actual Win32 define, encapsulates:
-///
-///   - EMRSETTEXTCOLOR
-///   - EMRSETBKCOLOR
-/// </remarks>
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRSETCOLOR
-{
-    public EMR emr;
-    public COLORREF crColor;
-
-    public override string ToString()
-    {
-        return $"[EMR{emr.iType}] Color: {crColor.ToSystemColorString()}";
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETWORLDTRANSFORM.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETWORLDTRANSFORM.cs
deleted file mode 100644
index 365b4cf58e6..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRSETWORLDTRANSFORM.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Numerics;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRSETWORLDTRANSFORM
-{
-    public EMR emr;
-    public Matrix3x2 xform;
-
-    public override string ToString() => $"[{nameof(EMRSETWORLDTRANSFORM)}] Transform: {xform}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRTEXT.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRTEXT.cs
deleted file mode 100644
index bb15e729835..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/EMRTEXT.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct EMRTEXT
-{
-    public Point ptlReference;
-    public uint nChars;
-    public uint offString;          // Offset to the string
-    public uint fOptions;
-    public RECT rcl;
-    public uint offDx;              // Offset to the inter-character spacing array.
-
-    public unsafe ReadOnlySpan<char> GetText()
-    {
-        int offset = (int)offString - sizeof(EMREXTTEXTOUTW) + sizeof(EMRTEXT);
-        fixed (Point* p = &ptlReference)
-        {
-            byte* b = (byte*)(void*)p;
-            b += offset;
-            return new ReadOnlySpan<char>((void*)b, (int)nChars);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/ENHMETAHEADER.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/ENHMETAHEADER.cs
deleted file mode 100644
index 4c7f53cdc59..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/RecordTypes/ENHMETAHEADER.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Metafiles;
-
-[StructLayout(LayoutKind.Sequential)]
-internal struct ENHMETAHEADER
-{
-    public uint iType;              // Record typeEMR_HEADER
-    public uint nSize;              // Record size in bytes.  This may be greater
-                                    // than the sizeof(ENHMETAHEADER).
-    public RECT rclBounds;          // Inclusive-inclusive bounds in device units
-    public RECT rclFrame;           // Inclusive-inclusive Picture Frame of metafile in .01 mm units
-    public uint dSignature;         // Signature.  Must be ENHMETA_SIGNATURE.
-    public uint nVersion;           // Version number
-    public uint nBytes;             // Size of the metafile in bytes
-    public uint nRecords;           // Number of records in the metafile
-    public ushort nHandles;         // Number of handles in the handle table
-                                    // Handle index zero is reserved.
-    public ushort sReserved;        // Reserved.  Must be zero.
-    public uint nDescription;       // Number of chars in the unicode description string
-                                    // This is 0 if there is no description string
-    public uint offDescription;     // Offset to the metafile description record.
-                                    // This is 0 if there is no description string
-    public uint nPalEntries;        // Number of entries in the metafile palette.
-    public Size szlDevice;          // Size of the reference device in pixels
-    public Size szlMillimeters;     // Size of the reference device in millimeters
-
-    // The next three bring the size up to 100 bytes
-    public uint cbPixelFormat;      // Size of PIXELFORMATDESCRIPTOR information
-                                    // This is 0 if no pixel format is set
-    public uint offPixelFormat;     // Offset to PIXELFORMATDESCRIPTOR
-                                    // This is 0 if no pixel format is set
-    public BOOL bOpenGL;            // TRUE if OpenGL commands are present in
-                                    // the metafile, otherwise FALSE
-
-    // The next field brings the size to 108 bytes
-    public Size szlMicrometers;     // Size of the reference device in micrometers
-
-    public override string ToString() => $@"[{nameof(ENHMETAHEADER)}] Bounds: {rclBounds} Device Size: {szlDevice}Header Size: {nSize}";
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ActionValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ActionValidator.cs
deleted file mode 100644
index a592f55003e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ActionValidator.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Simple delegate wrapping validator.
-/// </summary>
-internal class ActionValidator : IEmfValidator
-{
-    private readonly ENHANCED_METAFILE_RECORD_TYPE _recordType;
-    private readonly ProcessRecordDelegate? _processor;
-    private readonly ProcessRecordWithStateDelegate? _processorWithState;
-
-    public ActionValidator(ENHANCED_METAFILE_RECORD_TYPE recordType, ProcessRecordDelegate processor)
-    {
-        _recordType = recordType;
-        _processor = processor;
-    }
-
-    public ActionValidator(ENHANCED_METAFILE_RECORD_TYPE recordType, ProcessRecordWithStateDelegate processor)
-    {
-        _recordType = recordType;
-        _processorWithState = processor;
-    }
-
-    public bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == _recordType;
-
-    public void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        complete = true;
-
-        _processor?.Invoke(ref record);
-        _processorWithState?.Invoke(ref record, state);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BackgroundModeValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BackgroundModeValidator.cs
deleted file mode 100644
index b896f612c05..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BackgroundModeValidator.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class BackgroundModeValidator : IStateValidator
-{
-    private readonly BACKGROUND_MODE _backgroundMode;
-    public BackgroundModeValidator(BACKGROUND_MODE backgroundMode) => _backgroundMode = backgroundMode;
-    public void Validate(DeviceContextState state) => Assert.Equal(_backgroundMode, state.BackgroundMode);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BitBltValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BitBltValidator.cs
deleted file mode 100644
index 2641c52067f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BitBltValidator.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class BitBltValidator : StateValidator
-{
-    private readonly Rectangle? _bounds;
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public BitBltValidator(
-        RECT? bounds,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        _bounds = bounds;
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one BitBlt record, so this call completes our work.
-        complete = true;
-
-        if (_bounds.HasValue)
-        {
-            EMRBITBLT* bitBlt = record.BitBltRecord;
-            Assert.Equal(_bounds.Value, (Rectangle)bitBlt->rclBounds);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushColorValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushColorValidator.cs
deleted file mode 100644
index e5ae6688ef9..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushColorValidator.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class BrushColorValidator : IStateValidator
-{
-    private readonly Color _brushColor;
-    public BrushColorValidator(Color brushColor) => _brushColor = brushColor;
-    public void Validate(DeviceContextState state) => Assert.Equal((COLORREF)_brushColor, state.SelectedBrush.lbColor);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushStyleValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushStyleValidator.cs
deleted file mode 100644
index 26b508bc795..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushStyleValidator.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class BrushStyleValidator : IStateValidator
-{
-    private readonly BRUSH_STYLE _brushStyle;
-    public BrushStyleValidator(BRUSH_STYLE brushStyle) => _brushStyle = brushStyle;
-    public void Validate(DeviceContextState state) => Assert.Equal(_brushStyle, state.SelectedBrush.lbStyle);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushValidator.cs
deleted file mode 100644
index 96551a6c523..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/BrushValidator.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class BrushValidator : IStateValidator
-{
-    private readonly Color _brushColor;
-    private readonly BRUSH_STYLE _brushStyle;
-
-    public BrushValidator(Color brushColor, BRUSH_STYLE brushStyle)
-    {
-        _brushColor = brushColor;
-        _brushStyle = brushStyle;
-    }
-
-    public void Validate(DeviceContextState state)
-    {
-        Assert.Equal((COLORREF)_brushColor, state.SelectedBrush.lbColor);
-        Assert.Equal(_brushStyle, state.SelectedBrush.lbStyle);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ClippingValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ClippingValidator.cs
deleted file mode 100644
index 41671f8f322..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/ClippingValidator.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class ClippingValidator : IStateValidator
-{
-    private readonly RECT[] _clippingRectangles;
-    public ClippingValidator(RECT[] clippingRectangles) => _clippingRectangles = clippingRectangles;
-
-    public void Validate(DeviceContextState state)
-        => Assert.Equal(_clippingRectangles, state.ClipRegion);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.WrappedXunitException.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.WrappedXunitException.cs
deleted file mode 100644
index 979af99637f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.WrappedXunitException.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using Xunit.Sdk;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal static partial class EmfValidator
-{
-    private class WrappedXunitException : XunitException
-    {
-        public WrappedXunitException(string userMessage, XunitException innerException)
-            : base(userMessage, innerException)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.cs
deleted file mode 100644
index 070c1fb84a5..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/EmfValidator.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using Xunit.Sdk;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal static partial class EmfValidator
-{
-    internal static void Validate(
-        this EmfScope emf,
-        DeviceContextState state,
-        params IEmfValidator[] validationSteps)
-    {
-        if (state is null)
-            throw new ArgumentNullException(nameof(state));
-        if (validationSteps is null)
-            throw new ArgumentNullException(nameof(validationSteps));
-
-        int currentIndex = 0;
-        IEmfValidator? currentValidator = validationSteps[currentIndex];
-
-        emf.EnumerateWithState((ref EmfRecord record, DeviceContextState state) =>
-            {
-                if (currentValidator?.ShouldValidate(record.Type) ?? false)
-                {
-                    try
-                    {
-                        currentValidator.Validate(ref record, state, out bool complete);
-
-                        if (complete)
-                        {
-                            // Current validator doesn't want to look at any more records.
-                            currentIndex++;
-                            currentValidator = currentIndex < validationSteps.Length
-                                ? validationSteps[currentIndex]
-                                : null;
-                        }
-                    }
-                    catch (XunitException ex)
-                    {
-                        throw new WrappedXunitException(
-                            $"\nValidator index {currentIndex}: {currentValidator!.GetType().Name} failed\n\n{emf.RecordsToString()}",
-                            ex);
-                    }
-                }
-                else
-                {
-                    Assert.False(IsRenderingRecord(record.Type), $"Got unexpected {record.Type}\n\n{emf.RecordsToString()}");
-                }
-
-                return true;
-            },
-            state);
-
-        if (currentValidator is not null)
-        {
-            Assert.False(
-                currentValidator.FailIfIncomplete,
-                $"{currentValidator.GetType().Name} did not receive expected records\n\n{emf.RecordsToString()}");
-        }
-    }
-
-    private static bool IsRenderingRecord(ENHANCED_METAFILE_RECORD_TYPE recordType)
-        => recordType switch
-        {
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIER               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON                  => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIERTO             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINETO               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON              => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_SETPIXELV                => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ANGLEARC                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ELLIPSE                  => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_RECTANGLE                => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ROUNDRECT                => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ARC                      => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_CHORD                    => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_PIE                      => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTFLOODFILL             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_LINETO                   => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ARCTO                    => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYDRAW                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_CLOSEFIGURE              => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_FILLPATH                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEANDFILLPATH        => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_STROKEPATH               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_FILLRGN                  => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_FRAMERGN                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_INVERTRGN                => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_PAINTRGN                 => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT                   => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHBLT               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_MASKBLT                  => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_PLGBLT                   => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_SETDIBITSTODEVICE        => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHDIBITS            => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTTEXTOUTA              => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTTEXTOUTW              => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIER16             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16                => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE16               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYBEZIERTO16           => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINETO16             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE16           => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16            => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYDRAW16               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYTEXTOUTA             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYTEXTOUTW             => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_ALPHABLEND               => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_TRANSPARENTBLT           => true,
-            ENHANCED_METAFILE_RECORD_TYPE.EMR_GRADIENTFILL             => true,
-            _ => false
-        };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/FontFaceNameValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/FontFaceNameValidator.cs
deleted file mode 100644
index d15759c815e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/FontFaceNameValidator.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class FontFaceNameValidator : IStateValidator
-{
-    private readonly string _fontFaceName;
-
-    /// <param name="fontFaceName">The font face name to validate.</param>
-    public FontFaceNameValidator(string fontFaceName) => _fontFaceName = fontFaceName;
-
-    public void Validate(DeviceContextState state) => Assert.Equal(_fontFaceName, state.SelectedFont.FaceName.ToString());
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IEmfValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IEmfValidator.cs
deleted file mode 100644
index 62f1b0f4acc..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IEmfValidator.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Windows.Forms.Metafiles;
-
-namespace System;
-
-internal interface IEmfValidator
-{
-    /// <summary>
-    ///  Returns true if the given <paramref name="recordType"/> should be validated by this validator.
-    /// </summary>
-    bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType);
-
-    /// <summary>
-    ///  Validates the given <paramref name="record"/>.
-    /// </summary>
-    /// <param name="complete">
-    ///  True if the validator is finished validating. If false the validator will remain in scope for handling
-    ///  the next record.
-    /// </param>
-    void Validate(ref EmfRecord record, DeviceContextState state, out bool complete);
-
-    /// <summary>
-    ///  Return true if this validator is still in scope when all records have been processed.
-    /// </summary>
-    bool FailIfIncomplete => true;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IStateValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IStateValidator.cs
deleted file mode 100644
index 0aac2e00646..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/IStateValidator.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal interface IStateValidator
-{
-    void Validate(DeviceContextState state);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/LineToValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/LineToValidator.cs
deleted file mode 100644
index 802955ab8be..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/LineToValidator.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class LineToValidator : StateValidator
-{
-    private readonly Point? _from;
-    private readonly Point? _to;
-
-    /// <param name="from">Optional source point to validate.</param>
-    /// <param name="to">Optional destination point to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public LineToValidator(
-        Point? from,
-        Point? to,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        _from = from;
-        _to = to;
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_LINETO;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one LineTo record, so this call completes our work.
-        complete = true;
-
-        EMRPOINTRECORD* lineTo = record.LineToRecord;
-
-        if (_from.HasValue)
-        {
-            Assert.Equal(_from.Value, state.BrushOrigin);
-        }
-
-        if (_to.HasValue)
-        {
-            Assert.Equal(_to.Value, lineTo->point);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenColorValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenColorValidator.cs
deleted file mode 100644
index 74063ecf60d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenColorValidator.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PenColorValidator : IStateValidator
-{
-    private readonly Color _penColor;
-    public PenColorValidator(Color penColor) => _penColor = penColor;
-    public void Validate(DeviceContextState state) => Assert.Equal((COLORREF)_penColor, state.SelectedPen.elpColor);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenStyleValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenStyleValidator.cs
deleted file mode 100644
index ba8a2f8823c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenStyleValidator.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PenStyleValidator : IStateValidator
-{
-    private readonly PEN_STYLE _penStyle;
-    public PenStyleValidator(PEN_STYLE penStyle) => _penStyle = penStyle;
-    public void Validate(DeviceContextState state) => Assert.Equal(_penStyle, state.SelectedPen.elpPenStyle);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenValidator.cs
deleted file mode 100644
index b9447e88bd5..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenValidator.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PenValidator : IStateValidator
-{
-    private readonly int _penWidth;
-    private readonly PEN_STYLE _penStyle;
-    private readonly Color _penColor;
-
-    public PenValidator(int penWidth, Color penColor, PEN_STYLE penStyle)
-    {
-        _penWidth = penWidth;
-        _penColor = penColor;
-        _penStyle = penStyle;
-    }
-
-    public void Validate(DeviceContextState state)
-    {
-        Assert.Equal(_penWidth, (int)state.SelectedPen.elpWidth);
-        Assert.Equal((COLORREF)_penColor, state.SelectedPen.elpColor);
-        Assert.Equal(_penStyle, state.SelectedPen.elpPenStyle);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenWidthValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenWidthValidator.cs
deleted file mode 100644
index c0961e80f7a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PenWidthValidator.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PenWidthValidator : IStateValidator
-{
-    private readonly int _penWidth;
-    public PenWidthValidator(int penWidth) => _penWidth = penWidth;
-    public void Validate(DeviceContextState state) => Assert.Equal(_penWidth, (int)state.SelectedPen.elpWidth);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Poly16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Poly16Validator.cs
deleted file mode 100644
index 8fb3ab299c4..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Poly16Validator.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal abstract class Poly16Validator : StateValidator
-{
-    private readonly Rectangle? _bounds;
-    private readonly Point[]? _points;
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="points">Optional points to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public Poly16Validator(
-        RECT? bounds,
-        Point[]? points,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        _bounds = bounds;
-        _points = points;
-    }
-
-    protected unsafe void Validate(EMRPOLY16* poly)
-    {
-        if (_bounds.HasValue)
-        {
-            Assert.Equal(_bounds.Value, (Rectangle)poly->rclBounds);
-        }
-
-        if (_points is not null)
-        {
-            Assert.Equal(_points.Length, (int)poly->cpts);
-            Assert.Equal(_points, poly->points.Transform<POINTS, Point>(p => p));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPoly16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPoly16Validator.cs
deleted file mode 100644
index c0a56225b6b..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPoly16Validator.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal abstract class PolyPoly16Validator : StateValidator
-{
-    private readonly Rectangle? _bounds;
-    private readonly int? _polyCount;
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="polyCount">Number of expected polys.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public PolyPoly16Validator(
-        RECT? bounds,
-        int? polyCount,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        // Full point validation still needs implemented
-        _polyCount = polyCount;
-        _bounds = bounds;
-    }
-
-    protected unsafe void Validate(EMRPOLYPOLY16* poly)
-    {
-        if (_bounds.HasValue)
-        {
-            Assert.Equal(_bounds.Value, (Rectangle)poly->rclBounds);
-        }
-
-        if (_polyCount.HasValue)
-        {
-            Assert.Equal(_polyCount.Value, (int)poly->nPolys);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolygon16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolygon16Validator.cs
deleted file mode 100644
index 95419758cc4..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolygon16Validator.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PolyPolygon16Validator : PolyPoly16Validator
-{
-    /// <inheritdoc/>
-    public PolyPolygon16Validator(
-        RECT? bounds,
-        int? polyCount,
-        params IStateValidator[] stateValidators) : base(
-            bounds,
-            polyCount,
-            stateValidators)
-    {
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one PolyPolygon16 record, so this call completes our work.
-        complete = true;
-
-        Validate(record.PolyPolygon16Record);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolyline16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolyline16Validator.cs
deleted file mode 100644
index a736e36d9dd..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/PolyPolyline16Validator.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class PolyPolyline16Validator : PolyPoly16Validator
-{
-    /// <inheritdoc/>
-    public PolyPolyline16Validator(
-        RECT? bounds,
-        int? polyCount,
-        params IStateValidator[] stateValidators) : base(
-            bounds,
-            polyCount,
-            stateValidators)
-    {
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYLINE16;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one PolyPolyline16 record, so this call completes our work.
-        complete = true;
-
-        Validate(record.PolyPolyline16Record);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polygon16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polygon16Validator.cs
deleted file mode 100644
index df4065932a3..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polygon16Validator.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class Polygon16Validator : Poly16Validator
-{
-    /// <inheritdoc/>
-    public Polygon16Validator(
-        RECT? bounds,
-        Point[]? points,
-        params IStateValidator[] stateValidators) : base(
-            bounds,
-            points,
-            stateValidators)
-    {
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one Polygon16 record, so this call completes our work.
-        complete = true;
-
-        Validate(record.Polygon16Record);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polyline16Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polyline16Validator.cs
deleted file mode 100644
index 827988790a7..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Polyline16Validator.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class Polyline16Validator : Poly16Validator
-{
-    /// <inheritdoc/>
-    public Polyline16Validator(
-        RECT? bounds,
-        Point[]? points,
-        params IStateValidator[] stateValidators) : base(
-            bounds,
-            points,
-            stateValidators)
-    {
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYLINE16;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one Polyline16 record, so this call completes our work.
-        complete = true;
-
-        Validate(record.Polyline16Record);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RectangleValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RectangleValidator.cs
deleted file mode 100644
index 77fe47552e3..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RectangleValidator.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class RectangleValidator : StateValidator
-{
-    private readonly Rectangle? _bounds;
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public RectangleValidator(
-        RECT? bounds,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        _bounds = bounds;
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_RECTANGLE;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one Rectangle record, so this call completes our work.
-        complete = true;
-
-        if (_bounds.HasValue)
-        {
-            EMRRECTRECORD* rectangle = record.RectangleRecord;
-            Assert.Equal(_bounds.Value, (Rectangle)rectangle->rect);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RepeatValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RepeatValidator.cs
deleted file mode 100644
index 091bb77385d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/RepeatValidator.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class RepeatValidator : IEmfValidator
-{
-    private readonly IEmfValidator _validator;
-    private int _count;
-
-    public RepeatValidator(IEmfValidator validator, int count)
-    {
-        _validator = validator;
-        _count = count;
-    }
-
-    public bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => _validator.ShouldValidate(recordType);
-
-    public void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        if (_count <= 0)
-            throw new InvalidOperationException();
-
-        _validator.Validate(ref record, state, out _);
-        _count--;
-        complete = _count == 0;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Rop2Validator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Rop2Validator.cs
deleted file mode 100644
index 282243ad255..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Rop2Validator.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class Rop2Validator : IStateValidator
-{
-    private readonly R2_MODE _rop2Mode;
-    public Rop2Validator(R2_MODE rop2Mode) => _rop2Mode = rop2Mode;
-    public void Validate(DeviceContextState state) => Assert.Equal(_rop2Mode, state.Rop2Mode);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipAllValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipAllValidator.cs
deleted file mode 100644
index 12611e4d689..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipAllValidator.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class SkipAllValidator : IEmfValidator
-{
-    public static IEmfValidator Instance = new SkipAllValidator();
-
-    public bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => true;
-
-    public void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        // Always want to remain in scope.
-        complete = false;
-    }
-
-    // We don't require any more records to "pass"
-    public bool FailIfIncomplete => false;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipToValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipToValidator.cs
deleted file mode 100644
index 1ee65af2273..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipToValidator.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class SkipToValidator : IEmfValidator
-{
-    private readonly IEmfValidator _validator;
-
-    public SkipToValidator(IEmfValidator validator) => _validator = validator;
-
-    public bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => true;
-
-    public void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        if (_validator.ShouldValidate(record.Type))
-        {
-            // Hit our validator, pass through.
-            _validator.Validate(ref record, state, out complete);
-            return;
-        }
-
-        // Still skipping.
-        complete = false;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipTypesValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipTypesValidator.cs
deleted file mode 100644
index b0bde5bc89d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/SkipTypesValidator.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class SkipTypesValidator : IEmfValidator
-{
-    private readonly ENHANCED_METAFILE_RECORD_TYPE[] _skipTypes;
-
-    public SkipTypesValidator(params ENHANCED_METAFILE_RECORD_TYPE[] skipTypes) => _skipTypes = skipTypes;
-
-    public bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => _skipTypes.Contains(recordType);
-
-    public void Validate(ref EmfRecord record, DeviceContextState state, out bool complete) => complete = true;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/State.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/State.cs
deleted file mode 100644
index c8ccf694ad3..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/State.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Numerics;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal static class State
-{
-    internal static IStateValidator BackgroundMode(BACKGROUND_MODE backgroundMode) => new BackgroundModeValidator(backgroundMode);
-    internal static IStateValidator Brush(Color brushColor, BRUSH_STYLE brushStyle)
-        => new BrushValidator(brushColor, brushStyle);
-    internal static IStateValidator BrushColor(Color brushColor) => new BrushColorValidator(brushColor);
-    internal static IStateValidator BrushStyle(BRUSH_STYLE brushStyle) => new BrushStyleValidator(brushStyle);
-    internal static IStateValidator Clipping(RECT[] clippingRectangles) => new ClippingValidator(clippingRectangles);
-    internal static IStateValidator FontFace(string fontFaceName) => new FontFaceNameValidator(fontFaceName);
-    internal static IStateValidator Pen(int penWidth, Color penColor, PEN_STYLE penStyle)
-        => new PenValidator(penWidth, penColor, penStyle);
-    internal static IStateValidator PenColor(Color penColor) => new PenColorValidator(penColor);
-    internal static IStateValidator PenStyle(PEN_STYLE penStyle) => new PenStyleValidator(penStyle);
-    internal static IStateValidator PenWidth(int penWidth) => new PenWidthValidator(penWidth);
-    internal static IStateValidator Rop2(R2_MODE rop2Mode) => new Rop2Validator(rop2Mode);
-    internal static IStateValidator TextColor(Color textColor) => new TextColorValidator(textColor);
-    internal static IStateValidator Transform(Matrix3x2 transform) => new TransformValidator(transform);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/StateValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/StateValidator.cs
deleted file mode 100644
index 9ce077cda80..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/StateValidator.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace System.Windows.Forms.Metafiles;
-
-/// <summary>
-///  Base <see cref="IEmfValidator"/> that handles optional validation of device context state.
-/// </summary>
-internal abstract class StateValidator : IEmfValidator
-{
-    private readonly IStateValidator[] _stateValidators;
-    public StateValidator(IStateValidator[] stateValidators) => _stateValidators = stateValidators;
-    public abstract bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType);
-
-    public virtual void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        complete = false;
-
-        if (_stateValidators is null)
-        {
-            return;
-        }
-
-        foreach (IStateValidator validator in _stateValidators)
-        {
-            validator.Validate(state);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextColorValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextColorValidator.cs
deleted file mode 100644
index 1102fdc5282..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextColorValidator.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class TextColorValidator : IStateValidator
-{
-    private readonly Color _textColor;
-    public TextColorValidator(Color textColor) => _textColor = textColor;
-    public void Validate(DeviceContextState state) => Assert.Equal((COLORREF)_textColor, state.TextColor);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextOutValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextOutValidator.cs
deleted file mode 100644
index 7ca90c29360..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TextOutValidator.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal sealed class TextOutValidator : StateValidator
-{
-    private readonly string? _text;
-    private readonly Rectangle? _bounds;
-
-    /// <param name="text">Optional text to validate.</param>
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public TextOutValidator(
-        string? text,
-        Rectangle? bounds = default,
-        params IStateValidator[] stateValidators) : base(stateValidators)
-    {
-        _text = text;
-        _bounds = bounds;
-    }
-
-    public override bool ShouldValidate(ENHANCED_METAFILE_RECORD_TYPE recordType) => recordType == ENHANCED_METAFILE_RECORD_TYPE.EMR_EXTTEXTOUTW;
-
-    public override unsafe void Validate(ref EmfRecord record, DeviceContextState state, out bool complete)
-    {
-        base.Validate(ref record, state, out _);
-
-        // We're only checking one TextOut record, so this call completes our work.
-        complete = true;
-
-        EMREXTTEXTOUTW* textOut = record.ExtTextOutWRecord;
-
-        if (_text is not null)
-        {
-            Assert.Equal(_text, textOut->emrtext.GetText().ToString());
-        }
-
-        if (_bounds.HasValue)
-        {
-            Assert.Equal(_bounds.Value, (Rectangle)textOut->rclBounds);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TransformValidator.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TransformValidator.cs
deleted file mode 100644
index d154d74385f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/TransformValidator.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Numerics;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal class TransformValidator : IStateValidator
-{
-    private readonly Matrix3x2 _transform;
-    public TransformValidator(Matrix3x2 transform) => _transform = transform;
-    public void Validate(DeviceContextState state) => Assert.Equal(_transform, state.Transform);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Validate.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Validate.cs
deleted file mode 100644
index b655e81d323..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Metafiles/Validators/Validate.cs
+++ /dev/null
@@ -1,130 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Metafiles;
-
-internal static class Validate
-{
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="points">Optional points to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator Polygon16(
-        Rectangle? bounds = default,
-        Point[]? points = default,
-        params IStateValidator[] stateValidators) => new Polygon16Validator(
-            bounds,
-            points,
-            stateValidators);
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="points">Optional points to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator Polyline16(
-        Rectangle? bounds = default,
-        Point[]? points = default,
-        params IStateValidator[] stateValidators) => new Polyline16Validator(
-            bounds,
-            points,
-            stateValidators);
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="polyCount">Optional count of polygons to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator PolyPolygon16(
-        Rectangle? bounds = default,
-        int? polyCount = default,
-        params IStateValidator[] stateValidators) => new PolyPolygon16Validator(
-            bounds,
-            polyCount,
-            stateValidators);
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="polyCount">Optional count of polygons to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator PolyPolyline16(
-        Rectangle? bounds = default,
-        int? polyCount = default,
-        params IStateValidator[] stateValidators) => new PolyPolyline16Validator(
-            bounds,
-            polyCount,
-            stateValidators);
-
-    /// <param name="text">Optional text to validate.</param>
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator TextOut(
-        string? text = default,
-        Rectangle? bounds = default,
-        params IStateValidator[] stateValidators) => new TextOutValidator(
-            text,
-            bounds,
-            stateValidators);
-
-    /// <param name="from">Optional source point to validate.</param>
-    /// <param name="to">Optional destination point to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator LineTo(
-        EasyPoint? from,
-        EasyPoint? to,
-        params IStateValidator[] stateValidators) => new LineToValidator(
-            from,
-            to,
-            stateValidators);
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    internal static IEmfValidator Rectangle(
-        RECT? bounds,
-        params IStateValidator[] stateValidators) => new RectangleValidator(
-            bounds,
-            stateValidators);
-
-    /// <param name="bounds">Optional bounds to validate.</param>
-    /// <param name="stateValidators">Optional device context state validation to perform.</param>
-    public static IEmfValidator BitBltValidator(
-        RECT? bounds,
-        params IStateValidator[] stateValidators) => new BitBltValidator(
-            bounds,
-            stateValidators);
-
-    /// <summary>
-    ///  Simple wrapper to allow doing an arbitrary action for a given <paramref name="recordType"/>.
-    /// </summary>
-    internal static IEmfValidator Action(ENHANCED_METAFILE_RECORD_TYPE recordType, ProcessRecordDelegate action)
-        => new ActionValidator(recordType, action);
-
-    /// <summary>
-    ///  Simple wrapper to allow doing an arbitrary action for a given <paramref name="recordType"/>.
-    /// </summary>
-    internal static IEmfValidator Action(ENHANCED_METAFILE_RECORD_TYPE recordType, ProcessRecordWithStateDelegate action)
-        => new ActionValidator(recordType, action);
-
-    /// <summary>
-    ///  Skip all records from this point. Use when you don't care about any further records.
-    /// </summary>
-    internal static IEmfValidator SkipAll() => SkipAllValidator.Instance;
-
-    /// <summary>
-    ///  Skip all output records that the given <paramref name="validator"/> does not validate.
-    /// </summary>
-    internal static IEmfValidator SkipTo(IEmfValidator validator) => new SkipToValidator(validator);
-
-    /// <summary>
-    ///  Skips the next record of the given type.
-    /// </summary>
-    internal static IEmfValidator SkipType(ENHANCED_METAFILE_RECORD_TYPE type) => new SkipTypesValidator(type);
-
-    /// <summary>
-    ///  Skip the next record if it matches any of the given types.
-    /// </summary>
-    internal static IEmfValidator SkipTypes(params ENHANCED_METAFILE_RECORD_TYPE[] types) => new SkipTypesValidator(types);
-
-    /// <summary>
-    ///  Repeat the given validation <paramref name="count"/> number of times.
-    /// </summary>
-    internal static IEmfValidator Repeat(IEmfValidator validator, int count) => new RepeatValidator(validator, count);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/ModuleInitializer.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/ModuleInitializer.cs
deleted file mode 100644
index bd13bfb703c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/ModuleInitializer.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-namespace System;
-
-internal class ModuleInitializer
-{
-    [ModuleInitializer]
-    [SuppressMessage("Usage", "CA2255:The 'ModuleInitializer' attribute should not be used in libraries", Justification = "Intentional use of module initializer to register trace listener.")]
-    internal static void Initialize()
-    {
-        // Ensure the module initializer runs for the main test helper assembly
-        RuntimeHelpers.RunModuleConstructor(typeof(BoolDataAttribute).Module.ModuleHandle);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/NoAssertContext.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/NoAssertContext.cs
deleted file mode 100644
index a479116fbfd..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/NoAssertContext.cs
+++ /dev/null
@@ -1,161 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Collections.Concurrent;
-
-namespace System;
-
-/// <summary>
-///  Use (within a using) to eat asserts.
-/// </summary>
-public sealed class NoAssertContext : IDisposable
-{
-    // For any given thread we don't need to lock to decide how to route messages, as any messages for that
-    // given thread will not happen while we're in the constructor or dispose method on that thread. That
-    // means we can safely check to see if we've hooked our thread without locking (outside of using a
-    // concurrent collection to make sure the collection is in a known state).
-    //
-    // We do, however need to lock around hooking/unhooking our custom listener to make sure that we
-    // are rerouting correctly if multiple threads are creating/disposing this class concurrently.
-
-    private static readonly object s_lock = new();
-    private static bool s_hooked;
-    private static bool s_hasDefaultListener;
-    private static bool s_hasThrowingListener;
-
-    private static readonly ConcurrentDictionary<int, int> s_suppressedThreads = new();
-
-    // "Default" is the listener that terminates the process when debug assertions fail.
-    private static readonly TraceListener? s_defaultListener = Trace.Listeners["Default"];
-    private static readonly NoAssertListener s_noAssertListener = new();
-
-    public NoAssertContext()
-    {
-        s_suppressedThreads.AddOrUpdate(Environment.CurrentManagedThreadId, 1, (key, oldValue) => oldValue + 1);
-
-        // Lock to make sure we are hooked properly if two threads come into the constructor/dispose at the same time.
-        lock (s_lock)
-        {
-            if (!s_hooked)
-            {
-                // Hook our custom listener first so we don't lose assertions from other threads when
-                // we disconnect the default listener.
-                Trace.Listeners.Add(s_noAssertListener);
-                if (s_defaultListener is not null && Trace.Listeners.Contains(s_defaultListener))
-                {
-                    s_hasDefaultListener = true;
-                    Trace.Listeners.Remove(s_defaultListener);
-                }
-
-                if (Trace.Listeners.OfType<ThrowingTraceListener>().FirstOrDefault() is { } throwingTraceListener)
-                {
-                    s_hasThrowingListener = true;
-                    Trace.Listeners.Remove(throwingTraceListener);
-                }
-
-                s_hooked = true;
-            }
-        }
-    }
-
-    public void Dispose()
-    {
-        GC.SuppressFinalize(this);
-
-        int currentThread = Environment.CurrentManagedThreadId;
-        if (s_suppressedThreads.TryRemove(currentThread, out int count))
-        {
-            if (count > 1)
-            {
-                // We're in a nested assert context on a given thread, re-add with a decremented count.
-                // This doesn't need to be atomic as we're currently on the thread that would care about
-                // being rerouted.
-                s_suppressedThreads.TryAdd(currentThread, --count);
-            }
-        }
-
-        lock (s_lock)
-        {
-            if (s_hooked && s_suppressedThreads.IsEmpty)
-            {
-                // We're the first to hit the need to unhook. Add the default listener back first to
-                // ensure we don't lose any asserts from other threads.
-                if (s_hasDefaultListener)
-                {
-                    Trace.Listeners.Add(s_defaultListener!);
-                }
-
-                if (s_hasThrowingListener)
-                {
-                    Trace.Listeners.Add(ThrowingTraceListener.Instance);
-                }
-
-                Trace.Listeners.Remove(s_noAssertListener);
-                s_hooked = false;
-            }
-        }
-    }
-
-    ~NoAssertContext()
-    {
-        // We need this class to be used in a using to effectively rationalize about a test.
-        throw new InvalidOperationException($"Did not dispose {nameof(NoAssertContext)}");
-    }
-
-    private class NoAssertListener : TraceListener
-    {
-        public NoAssertListener()
-            : base(typeof(NoAssertListener).FullName)
-        {
-        }
-
-        private TraceListener? DefaultListener
-        {
-            get
-            {
-                if (s_hasThrowingListener)
-                    return ThrowingTraceListener.Instance;
-                else if (s_hasDefaultListener)
-                    return s_defaultListener;
-                else
-                    return null;
-            }
-        }
-
-        public override void Fail(string? message)
-        {
-            if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _))
-            {
-                DefaultListener?.Fail(message);
-            }
-        }
-
-        public override void Fail(string? message, string? detailMessage)
-        {
-            if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _))
-            {
-                DefaultListener?.Fail(message, detailMessage);
-            }
-        }
-
-        // Write and WriteLine are virtual
-
-        public override void Write(string? message)
-        {
-            if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _))
-            {
-                DefaultListener?.Write(message);
-            }
-        }
-
-        public override void WriteLine(string? message)
-        {
-            if (!s_suppressedThreads.TryGetValue(Environment.CurrentManagedThreadId, out _))
-            {
-                DefaultListener?.WriteLine(message);
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.Windows.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.Windows.cs
deleted file mode 100644
index 4ee3ef4b15b..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.Windows.cs
+++ /dev/null
@@ -1,304 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using System.Security;
-using Microsoft.Win32;
-
-namespace System;
-
-public static partial class PlatformDetection
-{
-    public static bool IsNetFramework => RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);
-    public static Version OSXVersion => throw new PlatformNotSupportedException();
-    public static Version OpenSslVersion => throw new PlatformNotSupportedException();
-    public static bool IsSuperUser => throw new PlatformNotSupportedException();
-    public static bool IsCentos6 => false;
-    public static bool IsOpenSUSE => false;
-    public static bool IsUbuntu => false;
-    public static bool IsDebian => false;
-    public static bool IsAlpine => false;
-    public static bool IsDebian8 => false;
-    public static bool IsUbuntu1404 => false;
-    public static bool IsUbuntu1604 => false;
-    public static bool IsUbuntu1704 => false;
-    public static bool IsUbuntu1710 => false;
-    public static bool IsUbuntu1710OrHigher => false;
-    public static bool IsUbuntu1804 => false;
-    public static bool IsTizen => false;
-    public static bool IsNotFedoraOrRedHatFamily => true;
-    public static bool IsFedora => false;
-    public static bool IsWindowsNanoServer => (IsNotWindowsIoTCore && GetInstallationType().Equals("Nano Server", StringComparison.OrdinalIgnoreCase));
-    public static bool IsWindowsServerCore => GetInstallationType().Equals("Server Core", StringComparison.OrdinalIgnoreCase);
-    public static int WindowsVersion => GetWindowsVersion();
-    public static bool IsMacOsHighSierraOrHigher { get; }
-    public static Version ICUVersion => new(0, 0, 0, 0);
-    public static bool IsRedHatFamily => false;
-    public static bool IsNotRedHatFamily => true;
-    public static bool IsRedHatFamily6 => false;
-    public static bool IsRedHatFamily7 => false;
-    public static bool IsNotRedHatFamily6 => true;
-
-    public static bool IsWindows10Version1607OrGreater =>
-        GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 14393;
-    public static bool IsWindows10Version1703OrGreater =>
-        GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 15063;
-    public static bool IsWindows10Version1709OrGreater =>
-        GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 16299;
-    public static bool IsWindows10Version1803OrGreater =>
-        GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 17134;
-    public static bool IsWindows11OrHigher =>
-        GetWindowsVersion() == 10 && GetWindowsMinorVersion() == 0 && GetWindowsBuildNumber() >= 22000;
-
-    // Windows OneCoreUAP SKU doesn't have httpapi.dll
-    public static bool IsNotOneCoreUAP =>
-        File.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "System32", "httpapi.dll"));
-
-    public static bool IsWindowsIoTCore
-    {
-        get
-        {
-            int productType = GetWindowsProductType();
-            if ((productType == PRODUCT_IOTUAPCOMMERCIAL) ||
-                (productType == PRODUCT_IOTUAP))
-            {
-                return true;
-            }
-
-            return false;
-        }
-    }
-
-    public static bool IsWindowsHomeEdition
-    {
-        get
-        {
-            int productType = GetWindowsProductType();
-            switch (productType)
-            {
-                case PRODUCT_CORE:
-                case PRODUCT_CORE_COUNTRYSPECIFIC:
-                case PRODUCT_CORE_N:
-                case PRODUCT_CORE_SINGLELANGUAGE:
-                case PRODUCT_HOME_BASIC:
-                case PRODUCT_HOME_BASIC_N:
-                case PRODUCT_HOME_PREMIUM:
-                case PRODUCT_HOME_PREMIUM_N:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-    }
-
-    public static bool IsWindows => true;
-    public static bool IsWindows7 => GetWindowsVersion() == 6 && GetWindowsMinorVersion() == 1;
-    public static bool IsNotWindows7 => !IsWindows7;
-    public static bool IsWindows8x => GetWindowsVersion() == 6 && (GetWindowsMinorVersion() == 2 || GetWindowsMinorVersion() == 3);
-
-    public static string LibcRelease => "glibc_not_found";
-    public static string LibcVersion => "glibc_not_found";
-
-    public static string GetDistroVersionString() => $"WindowsProductType={GetWindowsProductType()} WindowsInstallationType={GetInstallationType()}";
-
-    private static int s_isInAppContainer = -1;
-
-    public static bool IsInAppContainer
-    {
-        // This actually checks whether code is running in a modern app.
-        // Currently this is the only situation where we run in app container.
-        // If we want to distinguish the two cases in future,
-        // EnvironmentHelpers.IsAppContainerProcess in desktop code shows how to check for the AC token.
-        get
-        {
-            if (s_isInAppContainer != -1)
-            {
-                return s_isInAppContainer == 1;
-            }
-
-            if (!IsWindows || IsWindows7)
-            {
-                s_isInAppContainer = 0;
-                return false;
-            }
-
-            byte[] buffer = Array.Empty<byte>();
-            uint bufferSize = 0;
-            try
-            {
-                int result = GetCurrentApplicationUserModelId(ref bufferSize, buffer);
-                switch (result)
-                {
-                    case 15703: // APPMODEL_ERROR_NO_APPLICATION
-                        s_isInAppContainer = 0;
-                        break;
-                    case 0:     // ERROR_SUCCESS
-                    case 122:   // ERROR_INSUFFICIENT_BUFFER
-                                // Success is actually insufficent buffer as we're really only looking for
-                                // not NO_APPLICATION and we're not actually giving a buffer here. The
-                                // API will always return NO_APPLICATION if we're not running under a
-                                // WinRT process, no matter what size the buffer is.
-                        s_isInAppContainer = 1;
-                        break;
-                    default:
-                        throw new InvalidOperationException($"Failed to get AppId, result was {result}.");
-                }
-            }
-            catch (Exception e)
-            {
-                // We could catch this here, being friendly with older portable surface area should we
-                // desire to use this method elsewhere.
-                if (e.GetType().FullName.Equals("System.EntryPointNotFoundException", StringComparison.Ordinal))
-                {
-                    // API doesn't exist, likely pre Win8
-                    s_isInAppContainer = 0;
-                }
-                else
-                {
-                    throw;
-                }
-            }
-
-            return s_isInAppContainer == 1;
-        }
-    }
-
-    private static int s_isWindowsElevated = -1;
-
-    public static bool IsWindowsAndElevated
-    {
-        get
-        {
-            if (s_isWindowsElevated != -1)
-            {
-                return s_isWindowsElevated == 1;
-            }
-
-            if (!IsWindows || IsInAppContainer)
-            {
-                s_isWindowsElevated = 0;
-                return false;
-            }
-
-            Assert.True(OpenProcessToken(PInvoke.GetCurrentProcess(), TOKEN_READ, out IntPtr processToken));
-
-            try
-            {
-                Assert.True(GetTokenInformation(
-                    processToken, TokenElevation, out uint tokenInfo, sizeof(uint), out uint returnLength));
-
-                s_isWindowsElevated = tokenInfo == 0 ? 0 : 1;
-            }
-            finally
-            {
-                PInvoke.CloseHandle((HANDLE)processToken);
-            }
-
-            return s_isWindowsElevated == 1;
-        }
-    }
-
-    private static string GetInstallationType()
-    {
-        string key = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion";
-        string value = string.Empty;
-
-        try
-        {
-            value = (string)Registry.GetValue(key, "InstallationType", defaultValue: "");
-        }
-        catch (Exception e) when (e is SecurityException || e is InvalidCastException || e is PlatformNotSupportedException /* UAP */)
-        {
-        }
-
-        return value;
-    }
-
-    private static int GetWindowsProductType()
-    {
-        Assert.True(GetProductInfo(Environment.OSVersion.Version.Major, Environment.OSVersion.Version.Minor, 0, 0, out int productType));
-        return productType;
-    }
-
-    private static unsafe int GetWindowsMinorVersion()
-    {
-        var osvi = new RTL_OSVERSIONINFOEX
-        {
-            dwOSVersionInfoSize = (uint)sizeof(RTL_OSVERSIONINFOEX)
-        };
-        Assert.Equal(0, RtlGetVersion(ref osvi));
-        return (int)osvi.dwMinorVersion;
-    }
-
-    private static unsafe int GetWindowsBuildNumber()
-    {
-        var osvi = new RTL_OSVERSIONINFOEX
-        {
-            dwOSVersionInfoSize = (uint)sizeof(RTL_OSVERSIONINFOEX)
-        };
-        Assert.Equal(0, RtlGetVersion(ref osvi));
-        return (int)osvi.dwBuildNumber;
-    }
-
-    private const uint TokenElevation = 20;
-    private const uint STANDARD_RIGHTS_READ = 0x00020000;
-    private const uint TOKEN_QUERY = 0x0008;
-    private const uint TOKEN_READ = STANDARD_RIGHTS_READ | TOKEN_QUERY;
-
-    [DllImport("advapi32.dll", SetLastError = true, ExactSpelling = true)]
-    private static extern bool GetTokenInformation(
-        IntPtr TokenHandle,
-        uint TokenInformationClass,
-        out uint TokenInformation,
-        uint TokenInformationLength,
-        out uint ReturnLength);
-
-    private const int PRODUCT_IOTUAP = 0x0000007B;
-    private const int PRODUCT_IOTUAPCOMMERCIAL = 0x00000083;
-    private const int PRODUCT_CORE = 0x00000065;
-    private const int PRODUCT_CORE_COUNTRYSPECIFIC = 0x00000063;
-    private const int PRODUCT_CORE_N = 0x00000062;
-    private const int PRODUCT_CORE_SINGLELANGUAGE = 0x00000064;
-    private const int PRODUCT_HOME_BASIC = 0x00000002;
-    private const int PRODUCT_HOME_BASIC_N = 0x00000005;
-    private const int PRODUCT_HOME_PREMIUM = 0x00000003;
-    private const int PRODUCT_HOME_PREMIUM_N = 0x0000001A;
-
-    [DllImport("kernel32.dll", SetLastError = false)]
-    private static extern bool GetProductInfo(
-        int dwOSMajorVersion,
-        int dwOSMinorVersion,
-        int dwSpMajorVersion,
-        int dwSpMinorVersion,
-        out int pdwReturnedProductType);
-
-    [DllImport("ntdll.dll", ExactSpelling = true)]
-    private static extern int RtlGetVersion(ref RTL_OSVERSIONINFOEX lpVersionInformation);
-
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-    private unsafe struct RTL_OSVERSIONINFOEX
-    {
-        internal uint dwOSVersionInfoSize;
-        internal uint dwMajorVersion;
-        internal uint dwMinorVersion;
-        internal uint dwBuildNumber;
-        internal uint dwPlatformId;
-        internal fixed char szCSDVersion[128];
-    }
-
-    private static unsafe int GetWindowsVersion()
-    {
-        var osvi = new RTL_OSVERSIONINFOEX
-        {
-            dwOSVersionInfoSize = (uint)sizeof(RTL_OSVERSIONINFOEX)
-        };
-        Assert.Equal(0, RtlGetVersion(ref osvi));
-        return (int)osvi.dwMajorVersion;
-    }
-
-    [DllImport("kernel32.dll", ExactSpelling = true)]
-    private static extern int GetCurrentApplicationUserModelId(ref uint applicationUserModelIdLength, byte[] applicationUserModelId);
-
-    [DllImport("advapi32.dll", SetLastError = true, ExactSpelling = true)]
-    private static extern bool OpenProcessToken(IntPtr ProcessHandle, uint DesiredAccess, out IntPtr TokenHandle);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.cs
deleted file mode 100644
index 25fc44a1cf8..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/PlatformDetection.cs
+++ /dev/null
@@ -1,158 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace System;
-
-public static partial class PlatformDetection
-{
-    //
-    // Do not use the " { get; } = <expression> " pattern here. Having all the initialization happen in the type initializer
-    // means that one exception anywhere means all tests using PlatformDetection fail. If you feel a value is worth latching,
-    // do it in a way that failures don't cascade.
-    //
-
-    public static bool HasWindowsShell => IsWindows && IsNotWindowsServerCore && IsNotWindowsNanoServer && IsNotWindowsIoTCore;
-    public static bool IsUap => IsInAppContainer || IsNetNative;
-    public static bool IsNetNative => RuntimeInformation.FrameworkDescription.StartsWith(".NET Native", StringComparison.OrdinalIgnoreCase);
-    public static bool IsNetCore => RuntimeInformation.FrameworkDescription.StartsWith(".NET Core", StringComparison.OrdinalIgnoreCase);
-    public static bool IsNotWindows8x => !IsWindows8x;
-    public static bool IsNotWindowsNanoServer => !IsWindowsNanoServer;
-    public static bool IsNotWindowsServerCore => !IsWindowsServerCore;
-    public static bool IsNotWindowsIoTCore => !IsWindowsIoTCore;
-    public static bool IsNotWindowsHomeEdition => !IsWindowsHomeEdition;
-    public static bool IsDrawingSupported => (IsNotWindowsNanoServer && IsNotWindowsIoTCore);
-    public static bool IsArmProcess => RuntimeInformation.ProcessArchitecture == Architecture.Arm;
-    public static bool IsNotArmProcess => !IsArmProcess;
-    public static bool IsArm64Process => RuntimeInformation.ProcessArchitecture == Architecture.Arm64;
-    public static bool IsNotArm64Process => !IsArm64Process;
-    public static bool IsArmOrArm64Process => IsArmProcess || IsArm64Process;
-    public static bool Is32BitProcess => IntPtr.Size == 4;
-
-    public static bool IsMonoRuntime => Type.GetType("Mono.RuntimeStructs") is object;
-    public static bool IsNotMonoRuntime => !IsMonoRuntime;
-    public static bool IsMonoInterpreter => GetIsRunningOnMonoInterpreter();
-    public static bool IsNativeAot => IsNotMonoRuntime && !IsReflectionEmitSupported;
-
-    // Changed to `true` when trimming
-    public static bool IsBuiltWithAggressiveTrimming => IsNativeAot;
-    public static bool IsNotBuiltWithAggressiveTrimming => !IsBuiltWithAggressiveTrimming;
-
-    public static bool IsNotInAppContainer => !IsInAppContainer;
-    public static bool IsWinRTSupported => IsWindows && !IsWindows7;
-    public static bool IsNotWinRTSupported => !IsWinRTSupported;
-    public static bool IsNotMacOsHighSierraOrHigher => !IsMacOsHighSierraOrHigher;
-
-    public static bool IsDomainJoinedMachine => !Environment.MachineName.Equals(Environment.UserDomainName, StringComparison.OrdinalIgnoreCase);
-
-    public static bool IsNotNetNative => !IsNetNative;
-
-    // Windows - Schannel supports alpn from win8.1/2012 R2 and higher.
-    // Linux - OpenSsl supports alpn from openssl 1.0.2 and higher.
-    // OSX - SecureTransport doesn't expose alpn APIs. #30492
-    public static bool SupportsAlpn => (IsWindows && !IsWindows7) ||
-        (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) &&
-        (OpenSslVersion.Major >= 1 && (OpenSslVersion.Minor >= 1 || OpenSslVersion.Build >= 2)));
-    public static bool SupportsClientAlpn => SupportsAlpn ||
-        (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && PlatformDetection.OSXVersion > new Version(10, 12));
-
-    // Officially, .Net Native only supports processes running in an AppContainer. However, the majority of tests still work fine
-    // in a normal Win32 process and we often do so as running in an AppContainer imposes a substantial tax in debuggability
-    // and investigatability. This predicate is used in ConditionalFacts to disable the specific tests that really need to be
-    // running in AppContainer when running on .NetNative.
-    public static bool IsNotNetNativeRunningAsConsoleApp => !(IsNetNative && !IsInAppContainer);
-
-    private static readonly Lazy<bool> m_isWindowsSubsystemForLinux = new(GetIsWindowsSubsystemForLinux);
-
-    public static bool IsWindowsSubsystemForLinux => m_isWindowsSubsystemForLinux.Value;
-    public static bool IsNotWindowsSubsystemForLinux => !IsWindowsSubsystemForLinux;
-
-    private static bool GetIsWindowsSubsystemForLinux()
-    {
-        // https://github.com/Microsoft/BashOnWindows/issues/423#issuecomment-221627364
-
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-        {
-            const string versionFile = "/proc/version";
-            if (File.Exists(versionFile))
-            {
-                string s = File.ReadAllText(versionFile);
-
-                if (s.Contains("Microsoft") || s.Contains("WSL"))
-                {
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    private static readonly Lazy<bool> s_largeArrayIsNotSupported = new(IsLargeArrayNotSupported);
-
-    [MethodImpl(MethodImplOptions.NoOptimization)]
-    private static bool IsLargeArrayNotSupported()
-    {
-        try
-        {
-            var tmp = new byte[int.MaxValue];
-            return tmp is null;
-        }
-        catch (OutOfMemoryException)
-        {
-            return true;
-        }
-    }
-
-    public static bool IsNotIntMaxValueArrayIndexSupported => s_largeArrayIsNotSupported.Value;
-
-    public static bool IsNonZeroLowerBoundArraySupported
-    {
-        get
-        {
-            if (s_lazyNonZeroLowerBoundArraySupported is null)
-            {
-                bool nonZeroLowerBoundArraysSupported = false;
-                try
-                {
-                    Array.CreateInstance(typeof(int), new int[] { 5 }, new int[] { 5 });
-                    nonZeroLowerBoundArraysSupported = true;
-                }
-                catch (PlatformNotSupportedException)
-                {
-                }
-
-                s_lazyNonZeroLowerBoundArraySupported = Tuple.Create<bool>(nonZeroLowerBoundArraysSupported);
-            }
-
-            return s_lazyNonZeroLowerBoundArraySupported.Item1;
-        }
-    }
-
-    private static volatile Tuple<bool> s_lazyNonZeroLowerBoundArraySupported;
-
-    // Tracked in: https://github.com/dotnet/corert/issues/3643 in case we change our mind about this.
-    public static bool IsInvokingStaticConstructorsSupported => !PlatformDetection.IsNetNative;
-
-    // System.Security.Cryptography.Xml.XmlDsigXsltTransform.GetOutput() relies on XslCompiledTransform which relies
-    // heavily on Reflection.Emit
-    public static bool IsXmlDsigXsltTransformSupported => !PlatformDetection.IsUap;
-
-    private static bool GetIsRunningOnMonoInterpreter()
-    {
-#if NETCOREAPP
-        return IsMonoRuntime && RuntimeFeature.IsDynamicCodeSupported && !RuntimeFeature.IsDynamicCodeCompiled;
-#else
-        return false;
-#endif
-    }
-
-#if NETCOREAPP
-    public static bool IsReflectionEmitSupported => RuntimeFeature.IsDynamicCodeSupported;
-    public static bool IsNotReflectionEmitSupported => !IsReflectionEmitSupported;
-#else
-    public static bool IsReflectionEmitSupported => true;
-#endif
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Properties/InternalsVisibleTo.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Properties/InternalsVisibleTo.cs
deleted file mode 100644
index b8a60fe3ae0..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Properties/InternalsVisibleTo.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-// Awkward, but necessary to expose Interop based internals to other test libraries
-[assembly: InternalsVisibleTo("System.Windows.Forms.Primitives.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.TestUtilities, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.Primitives.TestUtilities.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.Design.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("WinformsControlsTest, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("MauiListViewTests, PublicKey=00000000000000000400000000000000")]
-
-// This is needed in order to Moq internal interfaces for testing
-[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/System.Windows.Forms.Primitives.TestUtilities.csproj b/src/System.Windows.Forms.Primitives/tests/TestUtilities/System.Windows.Forms.Primitives.TestUtilities.csproj
deleted file mode 100644
index d5bcc445d3e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/System.Windows.Forms.Primitives.TestUtilities.csproj
+++ /dev/null
@@ -1,21 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <AssemblyName>System.Windows.Forms.Primitives.TestUtilities</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <RootNamespace>System</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\Common\tests\TestUtilities\System.Windows.Forms.Common.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\..\System.Windows.Forms\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.Primitives.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/System/Windows/Forms/BinaryFormat/BinaryFormatTestExtensions.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/System/Windows/Forms/BinaryFormat/BinaryFormatTestExtensions.cs
deleted file mode 100644
index b5e8a2cdbb2..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/System/Windows/Forms/BinaryFormat/BinaryFormatTestExtensions.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.BinaryFormat;
-
-internal static class BinaryFormatTestExtensions
-{
-    /// <summary>
-    ///  Serializes the object using the <see cref="BinaryFormatter"/> and reads it into a <see cref="BinaryFormattedObject"/>.
-    /// </summary>
-    public static BinaryFormattedObject SerializeAndParse(this object source) => new(source.Serialize());
-
-    /// <summary>
-    ///  Serializes the object using the <see cref="BinaryFormatter"/>.
-    /// </summary>
-    public static Stream Serialize(this object source)
-    {
-        MemoryStream stream = new();
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011
-        formatter.Serialize(stream, source);
-        stream.Position = 0;
-        return stream;
-    }
-
-    /// <summary>
-    ///  Returns `true` if the <see cref="Type"/> would use the <see cref="BinaryFormatter"/> for the purposes
-    ///  of designer serialization (either through Resx or IPropertyBag for ActiveXImpl).
-    /// </summary>
-    public static bool IsBinaryFormatted(this Type type)
-    {
-        bool iSerializable = type.IsAssignableTo(typeof(ISerializable));
-#pragma warning disable SYSLIB0050 // Type or member is obsolete
-        bool serializable = type.IsSerializable;
-#pragma warning restore SYSLIB0050
-
-        if (!iSerializable && !serializable)
-        {
-            return false;
-        }
-
-        TypeConverter converter;
-        try
-        {
-            converter = TypeDescriptor.GetConverter(type);
-        }
-        catch (Exception)
-        {
-            // No valid type converter.
-            return true;
-        }
-
-        return !((converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(typeof(string)))
-            || (converter.CanConvertFrom(typeof(byte[])) && converter.CanConvertTo(typeof(byte[]))));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/SystemCOLORs.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/SystemCOLORs.cs
deleted file mode 100644
index 8f00854e431..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/SystemCOLORs.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-internal static class SystemCOLORs
-{
-    private static readonly Dictionary<COLORREF, List<SYS_COLOR_INDEX>> s_systemColors = CreateColorDictionary();
-
-    private static readonly Dictionary<SYS_COLOR_INDEX, string> s_names = new()
-    {
-        { SYS_COLOR_INDEX.COLOR_SCROLLBAR, "COLOR_SCROLLBAR" },
-        { SYS_COLOR_INDEX.COLOR_BACKGROUND, "COLOR_BACKGROUND" },
-        { SYS_COLOR_INDEX.COLOR_ACTIVECAPTION, "COLOR_ACTIVECAPTION" },
-        { SYS_COLOR_INDEX.COLOR_INACTIVECAPTION, "COLOR_INACTIVECAPTION" },
-        { SYS_COLOR_INDEX.COLOR_MENU, "COLOR_MENU" },
-        { SYS_COLOR_INDEX.COLOR_WINDOW, "COLOR_WINDOW" },
-        { SYS_COLOR_INDEX.COLOR_WINDOWFRAME, "COLOR_WINDOWFRAME" },
-        { SYS_COLOR_INDEX.COLOR_MENUTEXT, "COLOR_MENUTEXT" },
-        { SYS_COLOR_INDEX.COLOR_WINDOWTEXT, "COLOR_WINDOWTEXT" },
-        { SYS_COLOR_INDEX.COLOR_CAPTIONTEXT, "COLOR_CAPTIONTEXT" },
-        { SYS_COLOR_INDEX.COLOR_ACTIVEBORDER, "COLOR_ACTIVEBORDER" },
-        { SYS_COLOR_INDEX.COLOR_INACTIVEBORDER, "COLOR_INACTIVEBORDER" },
-        { SYS_COLOR_INDEX.COLOR_APPWORKSPACE, "COLOR_APPWORKSPACE" },
-        { SYS_COLOR_INDEX.COLOR_HIGHLIGHT, "COLOR_HIGHLIGHT" },
-        { SYS_COLOR_INDEX.COLOR_HIGHLIGHTTEXT, "COLOR_HIGHLIGHTTEXT" },
-        { SYS_COLOR_INDEX.COLOR_BTNFACE, "COLOR_BTNFACE" },
-        { SYS_COLOR_INDEX.COLOR_BTNSHADOW, "COLOR_BTNSHADOW" },
-        { SYS_COLOR_INDEX.COLOR_GRAYTEXT, "COLOR_GRAYTEXT" },
-        { SYS_COLOR_INDEX.COLOR_BTNTEXT, "COLOR_BTNTEXT" },
-        { SYS_COLOR_INDEX.COLOR_INACTIVECAPTIONTEXT, "COLOR_INACTIVECAPTIONTEXT" },
-        { SYS_COLOR_INDEX.COLOR_BTNHIGHLIGHT, "COLOR_BTNHIGHLIGHT" },
-        { SYS_COLOR_INDEX.COLOR_3DDKSHADOW, "COLOR_3DDKSHADOW" },
-        { SYS_COLOR_INDEX.COLOR_3DLIGHT, "COLOR_3DLIGHT" },
-        { SYS_COLOR_INDEX.COLOR_INFOTEXT, "COLOR_INFOTEXT" },
-        { SYS_COLOR_INDEX.COLOR_INFOBK, "COLOR_INFOBK" },
-        { SYS_COLOR_INDEX.COLOR_HOTLIGHT, "COLOR_HOTLIGHT" },
-        { SYS_COLOR_INDEX.COLOR_GRADIENTACTIVECAPTION, "COLOR_GRADIENTACTIVECAPTION" },
-        { SYS_COLOR_INDEX.COLOR_GRADIENTINACTIVECAPTION, "COLOR_GRADIENTINACTIVECAPTION" },
-        { SYS_COLOR_INDEX.COLOR_MENUHILIGHT, "COLOR_MENUHILIGHT" },
-        { SYS_COLOR_INDEX.COLOR_MENUBAR, "COLOR_MENUBAR" },
-    };
-
-    public static bool TryGetSystemColor(COLORREF colorRef, out List<SYS_COLOR_INDEX> colors)
-        => s_systemColors.TryGetValue(colorRef, out colors);
-
-    public static string ToSystemColorString(COLORREF colorRef)
-    {
-        if (TryGetSystemColor(colorRef, out List<SYS_COLOR_INDEX> colors))
-        {
-            string colorString = string.Join(", ", colors.Select(c => s_names[c]));
-            return $"{colorRef} ({colorString})";
-        }
-        else
-        {
-            return colorRef.ToString();
-        }
-    }
-
-    private static Dictionary<COLORREF, List<SYS_COLOR_INDEX>> CreateColorDictionary()
-    {
-        Dictionary<COLORREF, List<SYS_COLOR_INDEX>> dictionary = new();
-
-        for (int i = 0; i <= (int)SYS_COLOR_INDEX.COLOR_MENUBAR; i++)
-        {
-            if (i == 25)
-            {
-                // Only undefined value
-                continue;
-            }
-
-            COLORREF colorRef = (COLORREF)PInvoke.GetSysColor((SYS_COLOR_INDEX)i);
-
-            if (dictionary.TryGetValue(colorRef, out List<SYS_COLOR_INDEX> colors))
-            {
-                colors.Add((SYS_COLOR_INDEX)i);
-            }
-            else
-            {
-                List<SYS_COLOR_INDEX> colorList = new()
-                {
-                    (SYS_COLOR_INDEX)i
-                };
-
-                dictionary.Add(colorRef, colorList);
-            }
-        }
-
-        return dictionary;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditClass.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditClass.cs
deleted file mode 100644
index 2e53e1f9225..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditClass.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-internal class EditClass : WindowClass
-{
-    public EditClass() : base(PInvoke.WC_EDIT)
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditControl.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditControl.cs
deleted file mode 100644
index 0ea04ead502..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/EditControl.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System;
-
-internal class EditControl : Window
-{
-    private static readonly EditClass s_editClass = new();
-
-    public EditControl(string windowName = default,
-        WINDOW_STYLE style = WINDOW_STYLE.WS_OVERLAPPED,
-        WINDOW_EX_STYLE extendedStyle = WINDOW_EX_STYLE.WS_EX_CLIENTEDGE | WINDOW_EX_STYLE.WS_EX_LEFT | WINDOW_EX_STYLE.WS_EX_LTRREADING,
-        bool isMainWindow = false,
-        Window parentWindow = default,
-        nint parameters = default,
-        HMENU menuHandle = default)
-        : base(s_editClass, new Rectangle(0, 0, 100, 50), windowName, style, extendedStyle, isMainWindow, parentWindow, parameters, menuHandle)
-    {
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/Window.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/Window.cs
deleted file mode 100644
index 9bf9c7c8349..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/Window.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System;
-
-internal class Window : IDisposable, IHandle<HWND>
-{
-    private readonly WindowClass _windowClass;
-
-    public HWND Handle { get; }
-
-    public Window(
-        WindowClass windowClass,
-        Rectangle bounds,
-        string windowName = default,
-        WINDOW_STYLE style = WINDOW_STYLE.WS_OVERLAPPED,
-        WINDOW_EX_STYLE extendedStyle = default,
-        bool isMainWindow = false,
-        Window parentWindow = default,
-        nint parameters = default,
-        HMENU menuHandle = default)
-    {
-        _windowClass = windowClass;
-        if (!_windowClass.IsRegistered)
-        {
-            _windowClass.Register();
-        }
-
-        Handle = _windowClass.CreateWindow(
-            bounds,
-            windowName,
-            style,
-            extendedStyle,
-            isMainWindow,
-            parentWindow?.Handle ?? default,
-            parameters,
-            menuHandle);
-    }
-
-    public void Dispose()
-    {
-        if (!Handle.IsNull)
-        {
-            PInvoke.DestroyWindow(Handle);
-        }
-
-        GC.SuppressFinalize(this);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/WindowClass.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/WindowClass.cs
deleted file mode 100644
index 36885ee3215..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Win32/WindowClass.cs
+++ /dev/null
@@ -1,232 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-namespace System;
-
-internal class WindowClass
-{
-    private static RECT DefaultBounds
-        => new(PInvoke.CW_USEDEFAULT, PInvoke.CW_USEDEFAULT, PInvoke.CW_USEDEFAULT, PInvoke.CW_USEDEFAULT);
-
-    // Stash the delegate to keep it from being collected
-    private readonly WNDPROC _windowProcedure;
-    private WNDCLASSW _wndClass;
-    private readonly string _className;
-    private readonly string _menuName;
-
-    public ATOM Atom { get; private set; }
-    public HWND MainWindow { get; private set; }
-    public HINSTANCE ModuleInstance { get; }
-
-    /// <summary>
-    ///  Constructor.
-    /// </summary>
-    /// <param name="className">Name, or default will be generated.</param>
-    /// <param name="moduleInstance">Module to associate with the window. The entry assembly is the default.</param>
-    /// <param name="backgroundBrush">Use (HINSTANCE)(-1) for no background brush.</param>
-    /// <param name="icon">Use (HICON)(-1) for no icon.</param>
-    /// <param name="cursor">Use (HCURSOR)(-1) for no cursor.</param>
-    /// <param name="menuName">Menu name, can not set with <paramref name="menuId"/>.</param>
-    /// <param name="menuId">Menu id, can not set with <paramref name="menuName"/>.</param>
-    [UnconditionalSuppressMessage("SingleFile", "IL3002:Avoid calling members marked with 'RequiresAssemblyFilesAttribute' when publishing as a single-file", Justification = "Test only binary and not shippable.")]
-    public unsafe WindowClass(
-        string className = default,
-        HINSTANCE moduleInstance = default,
-        WNDCLASS_STYLES classStyle = WNDCLASS_STYLES.CS_HREDRAW | WNDCLASS_STYLES.CS_VREDRAW,
-        HBRUSH backgroundBrush = default,
-        HICON icon = default,
-        HCURSOR cursor = default,
-        string menuName = null,
-        int menuId = 0,
-        int classExtraBytes = 0,
-        int windowExtraBytes = 0)
-    {
-        // Handle default values
-        className ??= Guid.NewGuid().ToString();
-
-        if (backgroundBrush.IsNull)
-        {
-            backgroundBrush = PInvoke.GetSysColorBrush(SYS_COLOR_INDEX.COLOR_WINDOW);
-        }
-        else if (backgroundBrush == (HBRUSH)(-1))
-        {
-            backgroundBrush = default;
-        }
-
-        if (icon.IsNull)
-        {
-            icon = PInvoke.LoadIcon((HINSTANCE)0, (PCWSTR)(char*)PInvoke.IDI_APPLICATION);
-        }
-        else if (icon == (-1))
-        {
-            icon = default;
-        }
-
-        if (cursor == default)
-        {
-            cursor = PInvoke.LoadCursor((HINSTANCE)0, (PCWSTR)(char*)PInvoke.IDC_ARROW);
-        }
-        else if (cursor == (-1))
-        {
-            cursor = default;
-        }
-
-        if (moduleInstance.IsNull)
-            Marshal.GetHINSTANCE(Assembly.GetCallingAssembly().Modules.First());
-
-        if (menuId != 0 && menuName is not null)
-            throw new ArgumentException($"Can't set both {nameof(menuName)} and {nameof(menuId)}.");
-
-        _windowProcedure = WNDPROC;
-        ModuleInstance = moduleInstance;
-
-        _className = className;
-        _menuName = menuName ?? string.Empty;
-
-        _wndClass = new WNDCLASSW
-        {
-            style = classStyle,
-            lpfnWndProc = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, LRESULT>)Marshal.GetFunctionPointerForDelegate(_windowProcedure),
-            cbClsExtra = classExtraBytes,
-            cbWndExtra = windowExtraBytes,
-            hInstance = moduleInstance,
-            hIcon = icon,
-            hCursor = cursor,
-            hbrBackground = backgroundBrush,
-            lpszMenuName = (char*)menuId
-        };
-    }
-
-    public bool IsRegistered => Atom.IsValid || ModuleInstance.IsNull;
-
-    public unsafe WindowClass Register()
-    {
-        fixed (char* name = _className)
-        fixed (char* menuName = _menuName)
-        {
-            _wndClass.lpszClassName = name;
-            if (!string.IsNullOrEmpty(_menuName))
-                _wndClass.lpszMenuName = menuName;
-
-            ATOM atom = PInvoke.RegisterClass(in _wndClass);
-            if (!atom.IsValid)
-            {
-                throw new Win32Exception();
-            }
-
-            Atom = atom;
-            return this;
-        }
-    }
-
-    public IntPtr CreateWindow(
-        string windowName = null,
-        WINDOW_STYLE style = WINDOW_STYLE.WS_OVERLAPPED,
-        WINDOW_EX_STYLE extendedStyle = default,
-        bool isMainWindow = false,
-        HWND parentWindow = default,
-        nint parameters = default,
-        HMENU menuHandle = default)
-    {
-        return CreateWindow(
-            DefaultBounds,
-            windowName,
-            style,
-            extendedStyle,
-            isMainWindow,
-            parentWindow,
-            parameters,
-            menuHandle);
-    }
-
-    public unsafe HWND CreateWindow(
-        RECT bounds,
-        string windowName = null,
-        WINDOW_STYLE style = WINDOW_STYLE.WS_OVERLAPPED,
-        WINDOW_EX_STYLE extendedStyle = default,
-        bool isMainWindow = false,
-        HWND parentWindow = default,
-        nint parameters = default,
-        HMENU menuHandle = default)
-    {
-        if (!IsRegistered)
-            throw new ArgumentException("Window class must be registered before using.");
-
-        fixed (char* wn = windowName)
-        {
-            HWND window;
-            if (Atom.IsValid)
-            {
-                window = PInvoke.CreateWindowEx(
-                    dwExStyle: extendedStyle,
-                    lpClassName: (PCWSTR)(char*)Atom.Value,
-                    lpWindowName: (PCWSTR)wn,
-                    dwStyle: style,
-                    X: bounds.X,
-                    Y: bounds.Y,
-                    nWidth: bounds.Width,
-                    nHeight: bounds.Height,
-                    hWndParent: parentWindow,
-                    hMenu: menuHandle,
-                    hInstance: (HINSTANCE)0,
-                    lpParam: (void*)parameters);
-            }
-            else
-            {
-                fixed (char* cn = _className)
-                {
-                    window = PInvoke.CreateWindowEx(
-                        dwExStyle: extendedStyle,
-                        lpClassName: (PCWSTR)cn,
-                        lpWindowName: (PCWSTR)wn,
-                        dwStyle: style,
-                        X: bounds.X,
-                        Y: bounds.Y,
-                        nWidth: bounds.Width,
-                        nHeight: bounds.Height,
-                        hWndParent: parentWindow,
-                        hMenu: menuHandle,
-                        hInstance: (HINSTANCE)0,
-                        lpParam: (void*)parameters);
-                }
-            }
-
-            if (window.IsNull)
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-
-            if (!Atom.IsValid)
-            {
-                Atom = PInvoke.GetClassLong(window, GET_CLASS_LONG_INDEX.GCW_ATOM);
-            }
-
-            if (isMainWindow)
-            {
-                MainWindow = window;
-            }
-
-            return window;
-        }
-    }
-
-    protected virtual LRESULT WNDPROC(HWND hWnd, MessageId msg, WPARAM wParam, LPARAM lParam)
-    {
-        switch (msg)
-        {
-            case PInvoke.WM_DESTROY:
-                if (hWnd == MainWindow)
-                {
-                    PInvoke.PostQuitMessage(0);
-                }
-
-                return (LRESULT)0;
-        }
-
-        return PInvoke.DefWindowProc(hWnd, (uint)msg, wParam, lParam);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Com/ComClassFactory.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Com/ComClassFactory.cs
deleted file mode 100644
index b25bc1ce816..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Com/ComClassFactory.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-
-namespace Windows.Win32.System.Com;
-
-/// <summary>
-///  Wraps an <see cref="IClassFactory"/> from a dynamically loaded assembly.
-/// </summary>
-internal unsafe class ComClassFactory : IDisposable
-{
-    private readonly string _filePath;
-    public Guid ClassId { get; }
-    private readonly HINSTANCE _instance;
-    private readonly IClassFactory* _classFactory;
-
-    private const string ExportMethodName = "DllGetClassObject";
-
-    public ComClassFactory(
-        string filePath,
-        Guid classId)
-    {
-        _filePath = filePath;
-        ClassId = classId;
-        _instance = PInvoke.LoadLibraryEx(filePath, default);
-        if (_instance.IsNull)
-        {
-            throw new Win32Exception();
-        }
-
-        // Dynamically get the class factory method.
-
-        // HRESULT DllGetClassObject(
-        //   [in] REFCLSID rclsid,
-        //   [in] REFIID riid,
-        //   [out] LPVOID* ppv
-        // );
-
-        FARPROC proc = PInvoke.GetProcAddress(_instance, ExportMethodName);
-        IClassFactory* classFactory;
-        ((delegate* unmanaged<Guid*, Guid*, void**, HRESULT>)proc.Value)(
-            &classId, IID.Get<IClassFactory>(),
-            (void**)&classFactory).ThrowOnFailure();
-        _classFactory = classFactory;
-    }
-
-    internal HRESULT CreateInstance(out IUnknown* unknown)
-    {
-        unknown = default;
-        fixed (IUnknown** u = &unknown)
-        {
-            return _classFactory->CreateInstance(null, IID.Get<IUnknown>(), (void**)u);
-        }
-    }
-
-    internal HRESULT CreateInstance(out object unknown)
-    {
-        HRESULT result = CreateInstance(out IUnknown* punk);
-        unknown = punk is null ? null : Marshal.GetObjectForIUnknown((nint)punk);
-        return result;
-    }
-
-    public void Dispose()
-    {
-        _classFactory->Release();
-        PInvoke.FreeLibrary(_instance);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Ole/DropTargetMock.cs b/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Ole/DropTargetMock.cs
deleted file mode 100644
index acf7a3d531c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/TestUtilities/Windows/Win32/System/Ole/DropTargetMock.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32.System.Com;
-using Windows.Win32.System.SystemServices;
-
-namespace Windows.Win32.System.Ole;
-
-internal unsafe class DropTargetMock : IDropTarget.Interface, IManagedWrapper<IDropTarget>
-{
-    public virtual HRESULT DragEnter(IDataObject* pDataObj, MODIFIERKEYS_FLAGS grfKeyState, POINTL pt, DROPEFFECT* pdwEffect)
-    {
-        throw new NotImplementedException();
-    }
-
-    public virtual HRESULT DragOver(MODIFIERKEYS_FLAGS grfKeyState, POINTL pt, DROPEFFECT* pdwEffect)
-    {
-        throw new NotImplementedException();
-    }
-
-    public virtual HRESULT DragLeave()
-    {
-        throw new NotImplementedException();
-    }
-
-    public virtual HRESULT Drop(IDataObject* pDataObj, MODIFIERKEYS_FLAGS grfKeyState, POINTL pt, DROPEFFECT* pdwEffect)
-    {
-        throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/GlobalUsings.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/GlobalUsings.cs
deleted file mode 100644
index 46aa0cc2626..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/GlobalUsings.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using Windows.Win32;
-global using Windows.Win32.Foundation;
-global using Windows.Win32.Graphics.Gdi;
-global using Windows.Win32.UI.WindowsAndMessaging;
-global using Xunit;
-global using FluentAssertions;
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/LVITEMWTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/LVITEMWTests.cs
deleted file mode 100644
index ae6d6810398..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/LVITEMWTests.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Tests.InteropTests;
-
-public class LVITEMWTests
-{
-    [Fact]
-    public unsafe void UpdateText_should_throw_AOOR_if_cchTextMax_less_than_1()
-    {
-        var lvi = new LVITEMW
-        {
-            cchTextMax = 0,
-        };
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => lvi.UpdateText("012345"));
-    }
-
-#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
-    [Theory]
-    [MemberData(nameof(UpdateText_TestData))]
-    public unsafe void UpdateText_should_limit_input_text_to_cchTextMax_less_1_text_longer(string originalText, int maxLength, string newText, string expected)
-    {
-        fixed (char* pOriginalText = originalText)
-        {
-            var lvi = new LVITEMW
-            {
-                cchTextMax = maxLength,
-                pszText = pOriginalText
-            };
-
-            lvi.UpdateText(newText);
-
-            var text = new string(lvi.pszText);
-            Assert.Equal(expected, text);
-            Assert.Equal(maxLength - 1, text.Length);
-            Assert.Equal(text.Length + 1, lvi.cchTextMax);
-            Assert.Equal(maxLength, lvi.cchTextMax);
-        }
-    }
-#pragma warning restore xUnit1026 // Theory methods should use all of their parameters
-
-    public static IEnumerable<object[]> UpdateText_TestData()
-    {
-        yield return new object[] { "abcdefg", "abcdefg".Length, "0123456", "012345" };
-        yield return new object[] { "abcdefg", "abcdefg".Length, "0123456789", "012345" };
-    }
-
-    [Fact]
-    public unsafe void UpdateText_should_set_cchTextMax_to_input_text_length_plus_1_if_text_shorter()
-    {
-        string originalText = "abcdefghi";
-        fixed (char* pOriginalText = originalText)
-        {
-            var lvi = new LVITEMW
-            {
-                cchTextMax = originalText.Length,
-                pszText = pOriginalText
-            };
-
-            lvi.UpdateText("012345");
-
-            var sText = new ReadOnlySpan<char>(lvi.pszText, lvi.cchTextMax);
-
-            var text = new string(lvi.pszText);
-            Assert.Equal("012345", text);
-            Assert.Equal(lvi.cchTextMax, text.Length + 1);
-        }
-    }
-
-    [Fact]
-    public unsafe void UpdateText_should_set_null_terminated_text()
-    {
-        string originalText = "abcdefghi";
-        fixed (char* pOriginalText = originalText)
-        {
-            var lvi = new LVITEMW
-            {
-                cchTextMax = originalText.Length,
-                pszText = pOriginalText
-            };
-
-            lvi.UpdateText("012345");
-
-            var sText = new ReadOnlySpan<char>(lvi.pszText, lvi.cchTextMax);
-            Assert.Equal(sText.ToArray(), new char[] { '0', '1', '2', '3', '4', '5', '\0' });
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/MCGRIDINFOTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/MCGRIDINFOTests.cs
deleted file mode 100644
index 130451f2f8c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/MCGRIDINFOTests.cs
+++ /dev/null
@@ -1,150 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.ComCtl32;
-
-public class MCGRIDINFOTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void MCGRIDINFO_x32_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(84, sizeof(MCGRIDINFO));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void MCGRIDINFO_x32_Marshal_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(84, Marshal.SizeOf<MCGRIDINFO>());
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void MCGRIDINFO_x32_ensure_layout()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        MCGRIDINFO sut = new MCGRIDINFO();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.cbSize - addr);          // 4, UINT
-        Assert.Equal(4, (byte*)&sut.dwPart - addr);          // 4, DWORD
-        Assert.Equal(8, (byte*)&sut.dwFlags - addr);         // 4, DWORD
-        Assert.Equal(12, (byte*)&sut.iCalendar - addr);      // 4, int
-        Assert.Equal(16, (byte*)&sut.iRow - addr);           // 4, int
-        Assert.Equal(20, (byte*)&sut.iCol - addr);           // 4, int
-        Assert.Equal(24, (byte*)&sut.bSelected - addr);      // 4, BOOL
-        Assert.Equal(28, (byte*)&sut.stStart - addr);        // 16, SYSTEMTIME
-        Assert.Equal(44, (byte*)&sut.stEnd - addr);          // 16, SYSTEMTIME
-        Assert.Equal(60, (byte*)&sut.rc - addr);             // 16, RECT
-        Assert.Equal(76, (byte*)&sut.pszName - addr);        // 4, PWSTR
-        Assert.Equal(80, (byte*)&sut.cchName - addr);        // 4, size_t
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public void MCGRIDINFO_x32_Marshal_OffsetOf_IsCorrect()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(0, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.cbSize)));            // 4, UINT
-        Assert.Equal(4, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.dwPart)));            // 4, DWORD
-        Assert.Equal(8, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.dwFlags)));           // 4, DWORD
-        Assert.Equal(12, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iCalendar)));        // 4, int
-        Assert.Equal(16, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iRow)));             // 4, int
-        Assert.Equal(20, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iCol)));             // 4, int
-        Assert.Equal(24, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.bSelected)));        // 4, BOOL
-        Assert.Equal(28, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.stStart)));          // 16, SYSTEMTIME
-        Assert.Equal(44, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.stEnd)));            // 16, SYSTEMTIME
-        Assert.Equal(60, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.rc)));               // 16, RECT
-        Assert.Equal(76, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.pszName)));          // 8, PWSTR
-        Assert.Equal(80, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.cchName)));          // 8, size_t
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void MCGRIDINFO_x64_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(96, sizeof(MCGRIDINFO));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public void MCGRIDINFO_x64_Marshal_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(96, Marshal.SizeOf<MCGRIDINFO>());
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void MCGRIDINFO_x64_ensure_layout()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        MCGRIDINFO sut = new MCGRIDINFO();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.cbSize - addr);          // 4, UINT
-        Assert.Equal(4, (byte*)&sut.dwPart - addr);          // 4, DWORD
-        Assert.Equal(8, (byte*)&sut.dwFlags - addr);         // 4, DWORD
-        Assert.Equal(12, (byte*)&sut.iCalendar - addr);      // 4, int
-        Assert.Equal(16, (byte*)&sut.iRow - addr);           // 4, int
-        Assert.Equal(20, (byte*)&sut.iCol - addr);           // 4, int
-        Assert.Equal(24, (byte*)&sut.bSelected - addr);      // 4, BOOL
-        Assert.Equal(28, (byte*)&sut.stStart - addr);        // 16, SYSTEMTIME
-        Assert.Equal(44, (byte*)&sut.stEnd - addr);          // 16, SYSTEMTIME
-        Assert.Equal(60, (byte*)&sut.rc - addr);             // 16, RECT
-        // 4 bytes alignment 76 -> 80
-        Assert.Equal(80, (byte*)&sut.pszName - addr);        // 8, PWSTR
-        Assert.Equal(88, (byte*)&sut.cchName - addr);        // 8, size_t
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public void MCGRIDINFO_x64_Marshal_OffsetOf_IsCorrect()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(0, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.cbSize)));            // 4, UINT
-        Assert.Equal(4, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.dwPart)));            // 4, DWORD
-        Assert.Equal(8, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.dwFlags)));           // 4, DWORD
-        Assert.Equal(12, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iCalendar)));        // 4, int
-        Assert.Equal(16, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iRow)));             // 4, int
-        Assert.Equal(20, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.iCol)));             // 4, int
-        Assert.Equal(24, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.bSelected)));        // 4, BOOL
-        Assert.Equal(28, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.stStart)));          // 16, SYSTEMTIME
-        Assert.Equal(44, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.stEnd)));            // 16, SYSTEMTIME
-        Assert.Equal(60, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.rc)));               // 16, RECT
-        // 4 bytes alignment 76 -> 80
-        Assert.Equal(80, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.pszName)));          // 8, PWSTR
-        Assert.Equal(88, (int)Marshal.OffsetOf<MCGRIDINFO>(nameof(MCGRIDINFO.cchName)));          // 8, size_t
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGIconUnionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGIconUnionTests.cs
deleted file mode 100644
index cfa44e0b62d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGIconUnionTests.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.ComCtl32;
-
-public class TASKDIALOGCONFIGIconUnionTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOGCONFIGIconUnion_x32_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(4, sizeof(TASKDIALOGCONFIG.IconUnion));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOGCONFIGIconUnion_x32_ensure_layout()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOGCONFIG.IconUnion sut = new TASKDIALOGCONFIG.IconUnion();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.hIcon - addr);  // 4, HICON
-        Assert.Equal(0, (byte*)&sut.pszIcon - addr);  // 4, PCWSTR
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOGCONFIGIconUnion_x64_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(8, sizeof(TASKDIALOGCONFIG.IconUnion));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOGCONFIGIconUnion_x64_ensure_layout()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOGCONFIG.IconUnion sut = new TASKDIALOGCONFIG.IconUnion();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.hIcon - addr);  // 8, HICON
-        Assert.Equal(0, (byte*)&sut.pszIcon - addr);  // 8, PCWSTR
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGTests.cs
deleted file mode 100644
index 788e97eba9a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOGCONFIGTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.ComCtl32;
-
-public class TASKDIALOGCONFIGTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOGCONFIG_x32_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(96, sizeof(TASKDIALOGCONFIG));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOGCONFIG_x32_ensure_layout()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOGCONFIG sut = new TASKDIALOGCONFIG();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.cbSize - addr);                   // 4, UINT
-        Assert.Equal(4, (byte*)&sut.hwndParent - addr);               // 4, HWND
-        Assert.Equal(8, (byte*)&sut.hInstance - addr);                // 4, HINSTANCE
-        Assert.Equal(12, (byte*)&sut.dwFlags - addr);                 // 4, TASKDIALOG_FLAGS
-        Assert.Equal(16, (byte*)&sut.dwCommonButtons - addr);         // 4, TASKDIALOG_COMMON_BUTTON_FLAGS
-        Assert.Equal(20, (byte*)&sut.pszWindowTitle - addr);          // 4, PCWSTR
-        Assert.Equal(24, (byte*)&sut.mainIcon - addr);                // 4, union { HICON; PCWSTR; }
-        Assert.Equal(28, (byte*)&sut.pszMainInstruction - addr);      // 4, PCWSTR
-        Assert.Equal(32, (byte*)&sut.pszContent - addr);              // 4, PCWSTR
-        Assert.Equal(36, (byte*)&sut.cButtons - addr);                // 4, UINT
-        Assert.Equal(40, (byte*)&sut.pButtons - addr);                // 4, const TASKDIALOG_BUTTON *
-        Assert.Equal(44, (byte*)&sut.nDefaultButton - addr);          // 4, int
-        Assert.Equal(48, (byte*)&sut.cRadioButtons - addr);           // 4, UINT
-        Assert.Equal(52, (byte*)&sut.pRadioButtons - addr);           // 4, const TASKDIALOG_BUTTON *
-        Assert.Equal(56, (byte*)&sut.nDefaultRadioButton - addr);     // 4, int
-        Assert.Equal(60, (byte*)&sut.pszVerificationText - addr);     // 4, PCWSTR
-        Assert.Equal(64, (byte*)&sut.pszExpandedInformation - addr);  // 4, PCWSTR
-        Assert.Equal(68, (byte*)&sut.pszExpandedControlText - addr);  // 4, PCWSTR
-        Assert.Equal(72, (byte*)&sut.pszCollapsedControlText - addr); // 4, PCWSTR
-        Assert.Equal(76, (byte*)&sut.footerIcon - addr);              // 4, union { HICON; PCWSTR; }
-        Assert.Equal(80, (byte*)&sut.pszFooter - addr);               // 4, PCWSTR
-        Assert.Equal(84, (byte*)&sut.pfCallback - addr);              // 4, PFTASKDIALOGCALLBACK
-        Assert.Equal(88, (byte*)&sut.lpCallbackData - addr);          // 4, LONG_PTR
-        Assert.Equal(92, (byte*)&sut.cxWidth - addr);                 // 4, UINT
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOGCONFIG_x64_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(160, sizeof(TASKDIALOGCONFIG));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOGCONFIG_x64_ensure_layout()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOGCONFIG sut = new TASKDIALOGCONFIG();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.cbSize - addr);                    // 4, UINT
-        Assert.Equal(4, (byte*)&sut.hwndParent - addr);                // 8, HWND
-        Assert.Equal(12, (byte*)&sut.hInstance - addr);                // 8, HINSTANCE
-        Assert.Equal(20, (byte*)&sut.dwFlags - addr);                  // 4, TASKDIALOG_FLAGS
-        Assert.Equal(24, (byte*)&sut.dwCommonButtons - addr);          // 4, TASKDIALOG_COMMON_BUTTON_FLAGS
-        Assert.Equal(28, (byte*)&sut.pszWindowTitle - addr);           // 8, PCWSTR
-        Assert.Equal(36, (byte*)&sut.mainIcon - addr);                 // 8, union { HICON; PCWSTR; }
-        Assert.Equal(44, (byte*)&sut.pszMainInstruction - addr);       // 8, PCWSTR
-        Assert.Equal(52, (byte*)&sut.pszContent - addr);               // 8, PCWSTR
-        Assert.Equal(60, (byte*)&sut.cButtons - addr);                 // 4, UINT
-        Assert.Equal(64, (byte*)&sut.pButtons - addr);                 // 8, const TASKDIALOG_BUTTON *
-        Assert.Equal(72, (byte*)&sut.nDefaultButton - addr);           // 4, int
-        Assert.Equal(76, (byte*)&sut.cRadioButtons - addr);            // 4, UINT
-        Assert.Equal(80, (byte*)&sut.pRadioButtons - addr);            // 8, const TASKDIALOG_BUTTON *
-        Assert.Equal(88, (byte*)&sut.nDefaultRadioButton - addr);      // 4, int
-        Assert.Equal(92, (byte*)&sut.pszVerificationText - addr);      // 8, PCWSTR
-        Assert.Equal(100, (byte*)&sut.pszExpandedInformation - addr);  // 8, PCWSTR
-        Assert.Equal(108, (byte*)&sut.pszExpandedControlText - addr);  // 8, PCWSTR
-        Assert.Equal(116, (byte*)&sut.pszCollapsedControlText - addr); // 8, PCWSTR
-        Assert.Equal(124, (byte*)&sut.footerIcon - addr);              // 8, union { HICON; PCWSTR; }
-        Assert.Equal(132, (byte*)&sut.pszFooter - addr);               // 8, PCWSTR
-        Assert.Equal(140, (byte*)&sut.pfCallback - addr);              // 8, PFTASKDIALOGCALLBACK
-        Assert.Equal(148, (byte*)&sut.lpCallbackData - addr);          // 8, LONG_PTR
-        Assert.Equal(156, (byte*)&sut.cxWidth - addr);                 // 4, UINT
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOG_BUTTONTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOG_BUTTONTests.cs
deleted file mode 100644
index 92178253ef6..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/ComCtl32/TASKDIALOG_BUTTONTests.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.ComCtl32;
-
-public class TASKDIALOG_BUTTONTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOG_BUTTON_x32_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(8, sizeof(TASKDIALOG_BUTTON));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void TASKDIALOG_BUTTON_x32_ensure_layout()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOG_BUTTON sut = new TASKDIALOG_BUTTON();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.nButtonID - addr);                // 4, int
-        Assert.Equal(4, (byte*)&sut.pszButtonText - addr);            // 4, PCWSTR
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOG_BUTTON_x64_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(12, sizeof(TASKDIALOG_BUTTON));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void TASKDIALOG_BUTTON_x64_ensure_layout()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        TASKDIALOG_BUTTON sut = new TASKDIALOG_BUTTON();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut.nButtonID - addr);                // 4, int
-        Assert.Equal(4, (byte*)&sut.pszButtonText - addr);            // 8, PCWSTR
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Comdlg32/PRINTDLGWTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Comdlg32/PRINTDLGWTests.cs
deleted file mode 100644
index 3f18186e61a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Comdlg32/PRINTDLGWTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.Comdlg32;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.Comdlg32;
-
-public class PRINTDLGWTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void PRINTDLGW_32_Size()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(66, sizeof(PRINTDLGW_32));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void PRINTDLGW_32_ensure_layout()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        PRINTDLGW_32 sut = new PRINTDLGW_32();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut._lStructSize - addr);           // 4, DWORD
-        Assert.Equal(4, (byte*)&sut._hwndOwner - addr);             // 4, HWND
-        Assert.Equal(8, (byte*)&sut._hDevMode - addr);              // 4, HGLOBAL
-        Assert.Equal(12, (byte*)&sut._hDevNames - addr);            // 4, HGLOBAL
-        Assert.Equal(16, (byte*)&sut._hDC - addr);                  // 4, HDC
-        Assert.Equal(20, (byte*)&sut._flags - addr);                // 4, DWORD
-        Assert.Equal(24, (byte*)&sut._nFromPage - addr);            // 2, WORD
-        Assert.Equal(26, (byte*)&sut._nToPage - addr);              // 2, WORD
-        Assert.Equal(28, (byte*)&sut._nMinPage - addr);             // 2, WORD
-        Assert.Equal(30, (byte*)&sut._nMaxPage - addr);             // 2, WORD
-        Assert.Equal(32, (byte*)&sut._nCopies - addr);              // 2, WORD
-        Assert.Equal(34, (byte*)&sut._hInstance - addr);            // 4, HINSTANCE
-        Assert.Equal(38, (byte*)&sut._lCustData - addr);            // 4, LPARAM
-        Assert.Equal(42, (byte*)&sut._lpfnPrintHook - addr);        // 4, LPPRINTHOOKPROC
-        Assert.Equal(46, (byte*)&sut._lpfnSetupHook - addr);        // 4, LPSETUPHOOKPROC
-        Assert.Equal(50, (byte*)&sut._lpPrintTemplateName - addr);  // 4, LPCWSTR
-        Assert.Equal(54, (byte*)&sut._lpSetupTemplateName - addr);  // 4, LPCWSTR
-        Assert.Equal(58, (byte*)&sut._hPrintTemplate - addr);       // 4, HGLOBAL
-        Assert.Equal(62, (byte*)&sut._hSetupTemplate - addr);       // 4, HGLOBAL
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void PRINTDLGW_64_Size()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(120, sizeof(PRINTDLGW_64));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void PRINTDLGW_64_ensure_layout()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        PRINTDLGW_64 sut = new PRINTDLGW_64();
-        byte* addr = (byte*)&sut;
-
-        Assert.Equal(0, (byte*)&sut._lStructSize - addr);           // 8, DWORD
-        Assert.Equal(8, (byte*)&sut._hwndOwner - addr);             // 8, HWND
-        Assert.Equal(16, (byte*)&sut._hDevMode - addr);             // 8, HGLOBAL
-        Assert.Equal(24, (byte*)&sut._hDevNames - addr);            // 8, HGLOBAL
-        Assert.Equal(32, (byte*)&sut._hDC - addr);                  // 8, HDC
-        Assert.Equal(40, (byte*)&sut._flags - addr);                // 8, DWORD
-        Assert.Equal(44, (byte*)&sut._nFromPage - addr);            // 2, WORD
-        Assert.Equal(46, (byte*)&sut._nToPage - addr);              // 2, WORD
-        Assert.Equal(48, (byte*)&sut._nMinPage - addr);             // 2, WORD
-        Assert.Equal(50, (byte*)&sut._nMaxPage - addr);             // 2, WORD
-        Assert.Equal(52, (byte*)&sut._nCopies - addr);              // 2, WORD
-        // 2 bytes alignment 54 -> 56
-        Assert.Equal(56, (byte*)&sut._hInstance - addr);            // 8, HINSTANCE
-        Assert.Equal(64, (byte*)&sut._lCustData - addr);            // 8, LPARAM
-        Assert.Equal(72, (byte*)&sut._lpfnPrintHook - addr);        // 8, LPPRINTHOOKPROC
-        Assert.Equal(80, (byte*)&sut._lpfnSetupHook - addr);        // 8, LPSETUPHOOKPROC
-        Assert.Equal(88, (byte*)&sut._lpPrintTemplateName - addr);  // 8, LPCWSTR
-        Assert.Equal(96, (byte*)&sut._lpSetupTemplateName - addr);  // 8, LPCWSTR
-        Assert.Equal(104, (byte*)&sut._hPrintTemplate - addr);      // 8, HGLOBAL
-        Assert.Equal(112, (byte*)&sut._hSetupTemplate - addr);      // 8, HGLOBAL
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Gdi32/GetStockObjectTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Gdi32/GetStockObjectTests.cs
deleted file mode 100644
index 700ddea1b86..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Gdi32/GetStockObjectTests.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Gdi32Tests;
-
-public class GetStockObjectTests
-{
-    [Theory]
-    [InlineData((int)GET_STOCK_OBJECT_FLAGS.BLACK_BRUSH, 0x00000000, (uint)BRUSH_STYLE.BS_SOLID)]
-    [InlineData((int)GET_STOCK_OBJECT_FLAGS.NULL_BRUSH, 0x00000000, (uint)BRUSH_STYLE.BS_HOLLOW)]
-    [InlineData((int)GET_STOCK_OBJECT_FLAGS.WHITE_BRUSH, 0x00FFFFFF, (uint)BRUSH_STYLE.BS_SOLID)]
-    public void GetStockBrushes(int id, uint color, uint brushStyle)
-    {
-        HGDIOBJ hgdiobj = PInvoke.GetStockObject((GET_STOCK_OBJECT_FLAGS)id);
-        Assert.False(hgdiobj.IsNull);
-
-        PInvoke.GetObject(hgdiobj, out LOGBRUSH logBrush);
-        Assert.Equal(color, logBrush.lbColor);
-        Assert.Equal((BRUSH_STYLE)brushStyle, logBrush.lbStyle);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/GdiPlus/ARGBTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/GdiPlus/ARGBTests.cs
deleted file mode 100644
index c998e1caed7..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/GdiPlus/ARGBTests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests.Interop.GdiPlus;
-
-public class ARGBTests
-{
-    [Theory]
-    [InlineData(0x0000_0000, 0x00, 0x00, 0x00, 0x00)]
-    [InlineData(0xFFFF_FFFF, 0xFF, 0xFF, 0xFF, 0xFF)]
-    [InlineData(0xFF00_0000, 0x00, 0x00, 0x00, 0xFF)]
-    [InlineData(0x00AA_0000, 0xAA, 0x00, 0x00, 0x00)]
-    [InlineData(0x0000_BB00, 0x00, 0xBB, 0x00, 0x00)]
-    [InlineData(0x0000_00CC, 0x00, 0x00, 0xCC, 0x00)]
-    public void Construction_Raw(uint value, byte r, byte g, byte b, byte a)
-    {
-        ARGB fromValue = new ARGB((int)value);
-        Assert.Equal(a, fromValue.A);
-        Assert.Equal(r, fromValue.R);
-        Assert.Equal(g, fromValue.G);
-        Assert.Equal(b, fromValue.B);
-        ARGB fromBytes = new ARGB(a, r, g, b);
-        Assert.Equal((int)value, fromBytes.Value);
-    }
-
-    [Theory]
-    [MemberData(nameof(Colors))]
-    public void ToFromColor(Color color)
-    {
-        ARGB argb = color;
-        Assert.Equal(color.ToArgb(), argb.Value);
-        Color backAgain = argb;
-        Assert.Equal(color.ToArgb(), backAgain.ToArgb());
-    }
-
-    public static TheoryData<Color> Colors =>
-        new()
-        {
-            Color.CornflowerBlue,
-            Color.Transparent,
-            Color.BurlyWood
-        };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/FILETIMETests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/FILETIMETests.cs
deleted file mode 100644
index daba6eeae7a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/FILETIMETests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Tests.Interop.Kernel32;
-
-// NB: doesn't require thread affinity
-public class FILETIMETests
-{
-    [Fact]
-    public unsafe void FILETIME_Sizeof_Invoke_ReturnsExpected()
-    {
-        Assert.Equal(8, Marshal.SizeOf<PInvoke.FILETIME>());
-        Assert.Equal(8, sizeof(PInvoke.FILETIME));
-    }
-
-    [Fact]
-    public void FILETIME_Ctor_Default()
-    {
-        var ft = new PInvoke.FILETIME();
-        Assert.Equal(0u, ft.dwLowDateTime);
-        Assert.Equal(0u, ft.dwHighDateTime);
-    }
-
-    [Fact]
-    public void FILETIME_Ctor_DateTime()
-    {
-        var dt = new DateTime(2020, 05, 13, 13, 3, 12, DateTimeKind.Utc).ToLocalTime();
-        var ft = new PInvoke.FILETIME(dt);
-        Assert.Equal(3680495616u, ft.dwLowDateTime);
-        Assert.Equal(30812454u, ft.dwHighDateTime);
-    }
-
-    [Fact]
-    public void FILETIME_ToDateTime_Invoke_ReturnsExpected()
-    {
-        var ft = new PInvoke.FILETIME()
-        {
-            dwLowDateTime = 3680495616u,
-            dwHighDateTime = 30812454u
-        };
-        Assert.Equal(new DateTime(2020, 05, 13, 13, 3, 12, DateTimeKind.Utc).ToLocalTime(), ft.ToDateTime());
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/SYSTEMTIMETests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/SYSTEMTIMETests.cs
deleted file mode 100644
index 94f3377005d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Kernel32/SYSTEMTIMETests.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Tests.Interop.Kernel32;
-
-public class SYSTEMTIMETests
-{
-    [Fact]
-    public unsafe void SYSTEMTIME_Sizeof_ReturnsExpected()
-    {
-        Assert.Equal(16, Marshal.SizeOf<SYSTEMTIME>());
-        Assert.Equal(16, sizeof(SYSTEMTIME));
-    }
-
-    [Fact]
-    public void SYSTEMTIME_Ctor_Default()
-    {
-        var st = new SYSTEMTIME();
-
-        Assert.Equal(0, st.wYear);
-        Assert.Equal(0, st.wMonth);
-        Assert.Equal(0, st.wDayOfWeek);
-        Assert.Equal(0, st.wDay);
-        Assert.Equal(0, st.wHour);
-        Assert.Equal(0, st.wMinute);
-        Assert.Equal(0, st.wSecond);
-        Assert.Equal(0, st.wMilliseconds);
-    }
-
-    [Fact]
-    public void SYSTEMTIME_CastToDateTime_ReturnsExpected()
-    {
-        var st = new SYSTEMTIME()
-        {
-            wYear = 2021,
-            wMonth = 5,
-            wDay = 3,
-            wHour = 6,
-            wMinute = 15,
-            wSecond = 30,
-            wMilliseconds = 50
-        };
-
-        DateTime dt = (DateTime)st; // cast to DateTime implicitly
-
-        Assert.Equal(st.wYear, dt.Year);
-        Assert.Equal(st.wMonth, dt.Month);
-        Assert.Equal(DayOfWeek.Monday, dt.DayOfWeek);
-        Assert.Equal(st.wDay, dt.Day);
-        Assert.Equal(st.wHour, dt.Hour);
-        Assert.Equal(st.wMinute, dt.Minute);
-        Assert.Equal(st.wSecond, dt.Second);
-        Assert.Equal(st.wMilliseconds, dt.Millisecond);
-    }
-
-    [Fact]
-    public void SYSTEMTIME_CastToDateTime_ThrowsException_IfArgumentsAreIncorrect()
-    {
-        var st = new SYSTEMTIME()
-        {
-            wYear = 9999,
-            wMonth = 99,
-            wDay = 99,
-            wHour = 99,
-            wMinute = 99,
-            wSecond = 99,
-            wMilliseconds = 9999
-        };
-        DateTime dt;
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => dt = (DateTime)st); // cast to DateTime implicitly with incorrect arguments
-    }
-
-    [Fact]
-    public void SYSTEMTIME_CastToDateTime_ReturnsMinValue_IfValueIsDefault()
-    {
-        var st = new SYSTEMTIME();
-        DateTime dt;
-
-        using (new NoAssertContext())
-        {
-            dt = (DateTime)st; // cast to DateTime implicitly
-        }
-
-        Assert.Equal(DateTime.MinValue, dt);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Mocks/MockCursor.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Mocks/MockCursor.cs
deleted file mode 100644
index dfb4a71d68e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Mocks/MockCursor.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.Mocks;
-
-public class MockCursor : IDisposable
-{
-    private HCURSOR _handle;
-    private readonly bool _ownHandle = true;
-    private readonly PCWSTR _resourceId;
-
-    internal MockCursor(PCWSTR nResourceId)
-    {
-        // We don't delete stock cursors.
-        _ownHandle = false;
-        _resourceId = nResourceId;
-        _handle = PInvoke.LoadCursor(HINSTANCE.Null, nResourceId);
-        if (_handle.IsNull)
-        {
-            throw new Win32Exception(Marshal.GetLastWin32Error());
-        }
-    }
-
-    public void Dispose()
-    {
-        if (!_handle.IsNull && _ownHandle)
-        {
-            PInvoke.DestroyCursor(_handle);
-            _handle = HCURSOR.Null;
-        }
-    }
-
-    internal HCURSOR Handle => _handle.IsNull ? throw new ObjectDisposedException(nameof(MockCursor)) : _handle;
-
-    public Size Size => SystemInformation.CursorSize;
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CADWORDTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CADWORDTests.cs
deleted file mode 100644
index 6aa04748197..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CADWORDTests.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Primitives.Ole32Tests;
-
-public class CADWORDTests
-{
-    [Fact]
-    public void CADWORD_ConvertAndFree_SingleItem()
-    {
-        CADWORD ca = CreateIntVector(2020);
-
-        uint[] values = ca.ConvertAndFree();
-        Assert.Equal(1, values.Length);
-        Assert.Equal(2020u, values[0]);
-    }
-
-    [Fact]
-    public void CADWORD_ConvertAndFree_EmptyStruct()
-    {
-        CADWORD ca = default;
-
-        uint[] values = ca.ConvertAndFree();
-        Assert.Empty(values);
-    }
-
-    private static CADWORD CreateIntVector(params uint[] values)
-        => CreateIntVector(allocations: null, values);
-
-    private static unsafe CADWORD CreateIntVector(IList<IntPtr>? allocations, params uint[] values)
-    {
-        CADWORD ca = new()
-        {
-            cElems = (uint)values.Length,
-            pElems = (uint*)Marshal.AllocCoTaskMem(sizeof(uint) * values.Length)
-        };
-
-        allocations?.Add((IntPtr)ca.pElems);
-
-        Span<uint> elements = new(ca.pElems, values.Length);
-        for (int i = 0; i < values.Length; i++)
-        {
-            elements[i] = values[i];
-        }
-
-        return ca;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CALPOLESTRTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CALPOLESTRTests.cs
deleted file mode 100644
index 5d5abf2a5ec..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/CALPOLESTRTests.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Primitives.Ole32Tests;
-
-public class CALPOLESTRTests
-{
-    [Fact]
-    public void CALPOLESTR_ConvertAndFree_SingleItem()
-    {
-        CALPOLESTR ca = CreateStringVector("Swizzle");
-
-        string?[] values = ca.ConvertAndFree();
-        Assert.Equal(1, values.Length);
-        Assert.Equal("Swizzle", values[0]);
-    }
-
-    [Fact]
-    public void CALPOLESTR_ConvertAndFree_EmptyStruct()
-    {
-        CALPOLESTR ca = default;
-
-        string?[] values = ca.ConvertAndFree();
-        Assert.Empty(values);
-    }
-
-    private static CALPOLESTR CreateStringVector(params string[] values)
-        => CreateStringVector(allocations: null, values);
-
-    private static unsafe CALPOLESTR CreateStringVector(IList<IntPtr>? allocations, params string[] values)
-    {
-        CALPOLESTR ca = new()
-        {
-            cElems = (uint)values.Length,
-            pElems = (PWSTR*)Marshal.AllocCoTaskMem(IntPtr.Size * values.Length)
-        };
-
-        allocations?.Add((IntPtr)ca.pElems);
-
-        Span<IntPtr> elements = new(ca.pElems, values.Length);
-        for (int i = 0; i < values.Length; i++)
-        {
-            IntPtr nativeCopy = Marshal.StringToCoTaskMemUni(values[i]);
-            allocations?.Add(nativeCopy);
-            elements[i] = nativeCopy;
-        }
-
-        return ca;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/IPictureTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/IPictureTests.cs
deleted file mode 100644
index 92ee2e4ce05..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Ole32/IPictureTests.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Primitives.Tests.Interop.Mocks;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.Ole32;
-
-[Collection("Sequential")]
-public unsafe class IPictureTests
-{
-    [StaFact]
-    public void GetIPictureFromCursor()
-    {
-        using MockCursor arrow = new MockCursor(PInvoke.IDC_ARROW);
-
-        using var picture = IPicture.CreateFromIcon(Icon.FromHandle(arrow.Handle), copy: true);
-        Assert.False(picture.IsNull);
-        Assert.Equal(PICTYPE.PICTYPE_ICON, picture.Value->Type);
-
-        int height = picture.Value->Height;
-        Assert.Equal(arrow.Size.Height, GdiHelper.HimetricToPixelY(height));
-        int width = picture.Value->Width;
-        Assert.Equal(arrow.Size.Width, GdiHelper.HimetricToPixelX(width));
-    }
-
-    [StaFact]
-    public void GetIPictureFromImage()
-    {
-        using MockCursor arrow = new MockCursor(PInvoke.IDC_ARROW);
-        using Icon icon = Icon.FromHandle(arrow.Handle);
-        using Bitmap bitmap = icon.ToBitmap();
-        using var picture = IPicture.CreateFromImage(bitmap);
-        Assert.False(picture.IsNull);
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, picture.Value->Type);
-
-        int height = picture.Value->Height;
-        Assert.Equal(bitmap.Size.Height, GdiHelper.HimetricToPixelY(height));
-        int width = picture.Value->Width;
-        Assert.Equal(bitmap.Size.Width, GdiHelper.HimetricToPixelX(width));
-    }
-
-    [StaFact]
-    public void GetIPictureDispFromImage()
-    {
-        using Icon icon = SystemIcons.Question;
-        using Bitmap bitmap = icon.ToBitmap();
-        using var picture = IPictureDisp.CreateFromImage(bitmap);
-        Assert.False(picture.IsNull);
-        using VARIANT variant = new();
-
-        IDispatch* dispatch = (IDispatch*)picture.Value;
-        dispatch->TryGetProperty(PInvoke.DISPID_PICT_TYPE, &variant).ThrowOnFailure();
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, (PICTYPE)variant.data.iVal);
-
-        dispatch->TryGetProperty(PInvoke.DISPID_PICT_HEIGHT, &variant).ThrowOnFailure();
-        Assert.Equal(bitmap.Size.Height, GdiHelper.HimetricToPixelY((int)variant.data.uintVal));
-
-        dispatch->TryGetProperty(PInvoke.DISPID_PICT_WIDTH, &variant).ThrowOnFailure();
-        Assert.Equal(bitmap.Size.Width, GdiHelper.HimetricToPixelX((int)variant.data.uintVal));
-    }
-
-    [StaFact]
-    public void GetPictureFromIPicture()
-    {
-        using Icon icon = SystemIcons.Exclamation;
-        using Bitmap bitmap = icon.ToBitmap();
-        using var picture = IPicture.CreateFromImage(bitmap);
-        Assert.False(picture.IsNull);
-        using Image? image = picture.Value->ToImage();
-        Assert.NotNull(image);
-        Assert.Equal(bitmap.Size, image.Size);
-    }
-
-    [StaFact]
-    public void GetPictureFromIPictureDisp()
-    {
-        using Bitmap bitmap = new Bitmap(100, 200);
-        using var picture = IPictureDisp.CreateFromImage(bitmap);
-        Assert.False(picture.IsNull);
-        using Image? image = picture.Value->ToImage();
-        Assert.NotNull(image);
-        Assert.Equal(bitmap.Size, image.Size);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/DECIMALTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/DECIMALTests.cs
deleted file mode 100644
index 0262a1f73e4..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/DECIMALTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using static Interop;
-
-namespace System.Windows.Forms.Tests.Interop.Oleaut32;
-
-// NB: doesn't require thread affinity
-public class DECIMALTests
-{
-    [Fact]
-    public unsafe void DECIMAL_Sizeof_Invoke_ReturnsExpected()
-    {
-        Assert.Equal(16, Marshal.SizeOf<DECIMAL>());
-        Assert.Equal(16, sizeof(DECIMAL));
-    }
-
-    [Fact]
-    public void DECIMAL_ToDecimal_InvokeEmpty_ReturnsExpected()
-    {
-        var dec = new DECIMAL();
-        Assert.Equal(0m, dec.ToDecimal());
-    }
-
-    [Theory]
-    [InlineData((double)int.MinValue)]
-    [InlineData(-1.2)]
-    [InlineData(0)]
-    [InlineData(1.2)]
-    [InlineData((double)int.MaxValue)]
-    public void DECIMAL_ToDecimal_InvokeCustom_ReturnsExpected(double value)
-    {
-        HRESULT hr = VarDecFromR8(value, out DECIMAL dec);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal((decimal)value, dec.ToDecimal());
-    }
-
-    [DllImport(Libraries.Oleaut32, ExactSpelling = true)]
-    private static extern HRESULT VarDecFromR8(double dblIn, out DECIMAL pdecOut);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/ITypeInfoTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/ITypeInfoTests.cs
deleted file mode 100644
index 28caada8a3f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/ITypeInfoTests.cs
+++ /dev/null
@@ -1,381 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.Oleaut32;
-
-[Collection("Sequential")]
-public class ITypeInfoTests
-{
-    [StaFact]
-    public unsafe void ITypeInfo_AddressOfMember_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        try
-        {
-            void* pvObj;
-            typeInfo.Value->AddressOfMember(6, INVOKEKIND.INVOKE_FUNC, &pvObj);
-        }
-        catch (COMException ex)
-        {
-            Assert.Equal((int)HRESULT.TYPE_E_BADMODULEKIND, ex.HResult);
-            return;
-        }
-
-        Assert.Fail("Exception was not thrown");
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_CreateInstance_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        try
-        {
-            void* pvObj;
-            typeInfo.Value->CreateInstance(null, IID.Get<IPictureDisp>(), &pvObj);
-        }
-        catch (COMException ex)
-        {
-            Assert.Equal((int)HRESULT.TYPE_E_BADMODULEKIND, ex.HResult);
-            return;
-        }
-
-        Assert.Fail("Exception was not thrown");
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetContainingTypeLib_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        using ComScope<ITypeLib> typeLib = new(null);
-        uint index = uint.MaxValue;
-        typeInfo.Value->GetContainingTypeLib(typeLib, &index);
-
-        Assert.NotEqual(0u, index);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetDllEntry_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        using BSTR dllName = new("DllName");
-        using BSTR name = new("Name");
-        ushort wOrdinal = ushort.MaxValue;
-
-        try
-        {
-            typeInfo.Value->GetDllEntry(6, INVOKEKIND.INVOKE_FUNC, &dllName, &name, &wOrdinal);
-        }
-        catch (COMException ex)
-        {
-            Assert.Equal((int)HRESULT.TYPE_E_BADMODULEKIND, ex.HResult);
-            Assert.True(dllName.Length == 0);
-            Assert.True(name.Length == 0);
-            Assert.Equal(0u, wOrdinal);
-            return;
-        }
-
-        Assert.Fail("Exception was not thrown");
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetDocumentation_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        using BSTR name = new("Name");
-        using BSTR docString = new("DocString");
-        uint dwHelpContext = uint.MaxValue;
-        using BSTR helpFile = new("HelpFile");
-        typeInfo.Value->GetDocumentation(4, &name, &docString, &dwHelpContext, &helpFile);
-        Assert.Equal("Width", name.ToString());
-        Assert.True(docString.Length == 0);
-        Assert.Equal(0u, dwHelpContext);
-        Assert.True(helpFile.Length == 0);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetFuncDesc_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        FUNCDESC* pFuncDesc = null;
-        try
-        {
-            typeInfo.Value->GetFuncDesc(0, &pFuncDesc);
-            Assert.Equal(6, pFuncDesc->memid);
-            Assert.True(pFuncDesc->lprgscode is null);
-            Assert.NotEqual(IntPtr.Zero, (IntPtr)pFuncDesc->lprgelemdescParam);
-            Assert.Equal(FUNCKIND.FUNC_DISPATCH, pFuncDesc->funckind);
-            Assert.Equal(INVOKEKIND.INVOKE_FUNC, pFuncDesc->invkind);
-            Assert.Equal(CALLCONV.CC_STDCALL, pFuncDesc->callconv);
-            Assert.Equal(10, pFuncDesc->cParams);
-            Assert.Equal(0, pFuncDesc->cParamsOpt);
-            Assert.Equal(0, pFuncDesc->oVft);
-            Assert.Equal(0, pFuncDesc->cScodes);
-            Assert.Equal(VARENUM.VT_VOID, pFuncDesc->elemdescFunc.tdesc.vt);
-            Assert.True(pFuncDesc->elemdescFunc.tdesc.Anonymous.lpadesc is null);
-            Assert.True(pFuncDesc->elemdescFunc.Anonymous.paramdesc.pparamdescex is null);
-            Assert.True(pFuncDesc->elemdescFunc.Anonymous.paramdesc.pparamdescex is null);
-        }
-        finally
-        {
-            typeInfo.Value->ReleaseFuncDesc(pFuncDesc);
-        }
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetIDsOfNames_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        fixed (char* width = "Width")
-        fixed (char* other = "Other")
-        {
-            var rgszNames = new PWSTR[] { width, other };
-            var rgDispId = new int[rgszNames.Length];
-            fixed (PWSTR* pRgszNames = rgszNames)
-            fixed (int* pRgDispId = rgDispId)
-            {
-                typeInfo.Value->GetIDsOfNames(pRgszNames, (uint)rgszNames.Length, pRgDispId);
-                Assert.Equal(new PWSTR[] { width, other }, rgszNames);
-                Assert.Equal(new int[] { (int)PInvoke.DISPID_PICT_WIDTH, PInvoke.DISPID_UNKNOWN }, rgDispId);
-            }
-        }
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetImplTypeFlags_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        IMPLTYPEFLAGS implTypeFlags = (IMPLTYPEFLAGS)(-1);
-        typeInfo.Value->GetImplTypeFlags(0, &implTypeFlags);
-        Assert.NotEqual(IMPLTYPEFLAGS.IMPLTYPEFLAG_FDEFAULT, implTypeFlags);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetMops_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        using BSTR mops = new("Mops");
-        typeInfo.Value->GetMops(4, &mops);
-        Assert.True(mops.Length == 0);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetNames_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        BSTR* rgszNames = stackalloc BSTR[2];
-        rgszNames[0] = new BSTR("Name1");
-        rgszNames[1] = new BSTR("Name2");
-        uint cNames = 0;
-        typeInfo.Value->GetNames(4, rgszNames, 2u, &cNames);
-        Assert.Equal("Width", rgszNames[0].ToString());
-        Assert.Equal("Name2", rgszNames[1].ToString());
-        Assert.Equal(1u, cNames);
-
-        rgszNames[0].Dispose();
-        rgszNames[1].Dispose();
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetRefTypeInfo_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        uint refType = uint.MaxValue;
-        typeInfo.Value->GetRefTypeOfImplType(0, &refType);
-        Assert.NotEqual(0u, refType);
-
-        using ComScope<ITypeInfo> refTypeInfo = new(null);
-        typeInfo.Value->GetRefTypeInfo(refType, refTypeInfo);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetRefTypeOfImplType_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        uint refType = uint.MaxValue;
-        typeInfo.Value->GetRefTypeOfImplType(0, &refType);
-        Assert.NotEqual(0u, refType);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetTypeAttr_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        TYPEATTR* pTypeAttr = null;
-        try
-        {
-            typeInfo.Value->GetTypeAttr(&pTypeAttr);
-            Assert.Equal(typeof(IPictureDisp).GUID, pTypeAttr->guid);
-            Assert.Equal(0u, pTypeAttr->lcid);
-            Assert.Equal(0u, pTypeAttr->dwReserved);
-            Assert.Equal(PInvoke.DISPID_UNKNOWN, pTypeAttr->memidConstructor);
-            Assert.Equal(PInvoke.DISPID_UNKNOWN, pTypeAttr->memidDestructor);
-            Assert.True(pTypeAttr->lpstrSchema.IsNull);
-            Assert.Equal((uint)IntPtr.Size, pTypeAttr->cbSizeInstance);
-            Assert.Equal(TYPEKIND.TKIND_DISPATCH, pTypeAttr->typekind);
-            Assert.Equal(1, pTypeAttr->cFuncs);
-            Assert.Equal(5, pTypeAttr->cVars);
-            Assert.Equal(1, pTypeAttr->cImplTypes);
-            Assert.Equal(7 * IntPtr.Size, pTypeAttr->cbSizeVft);
-            Assert.Equal((ushort)IntPtr.Size, pTypeAttr->cbAlignment);
-            Assert.Equal(0x1000, pTypeAttr->wTypeFlags);
-            Assert.Equal(0, pTypeAttr->wMajorVerNum);
-            Assert.Equal(0, pTypeAttr->wMinorVerNum);
-            Assert.Equal(VARENUM.VT_EMPTY, pTypeAttr->tdescAlias.vt);
-            Assert.Equal((nuint)0, pTypeAttr->idldescType.dwReserved);
-            Assert.Equal(IDLFLAGS.IDLFLAG_NONE, pTypeAttr->idldescType.wIDLFlags);
-        }
-        finally
-        {
-            typeInfo.Value->ReleaseTypeAttr(pTypeAttr);
-        }
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetTypeComp_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        using ComScope<ITypeComp> typeComp = new(null);
-        typeInfo.Value->GetTypeComp(typeComp);
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_GetVarDesc_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        VARDESC* pVarDesc = null;
-        try
-        {
-            typeInfo.Value->GetVarDesc(3, &pVarDesc);
-            Assert.Equal(4, pVarDesc->memid);
-            Assert.True(pVarDesc->lpstrSchema.IsNull);
-            Assert.True(pVarDesc->Anonymous.lpvarValue  is null);
-            Assert.Equal(VARENUM.VT_USERDEFINED, pVarDesc->elemdescVar.tdesc.vt);
-            Assert.False(pVarDesc->elemdescVar.tdesc.Anonymous.lpadesc is null);
-            Assert.True(pVarDesc->elemdescVar.Anonymous.paramdesc.pparamdescex is null);
-            Assert.Equal(PARAMFLAGS.PARAMFLAG_NONE, pVarDesc->elemdescVar.Anonymous.paramdesc.wParamFlags);
-            Assert.Equal(VARFLAGS.VARFLAG_FREADONLY, pVarDesc->wVarFlags);
-            Assert.Equal(VARKIND.VAR_DISPATCH, pVarDesc->varkind);
-        }
-        finally
-        {
-            typeInfo.Value->ReleaseVarDesc(pVarDesc);
-        }
-    }
-
-    [StaFact]
-    public unsafe void ITypeInfo_Invoke_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(image);
-        Assert.False(iPictureDisp.IsNull);
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        ((IDispatch*)iPictureDisp.Value)->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-
-        DISPPARAMS dispParams = default;
-        VARIANT varResult = default;
-        EXCEPINFO excepInfo = default;
-        uint argErr = 0;
-
-        try
-        {
-            typeInfo.Value->Invoke(
-                iPictureDisp,
-                (int)PInvoke.DISPID_PICT_WIDTH,
-                DISPATCH_FLAGS.DISPATCH_PROPERTYGET,
-                &dispParams,
-                &varResult,
-                &excepInfo,
-                &argErr);
-        }
-        catch (COMException ex)
-        {
-            Assert.Equal((int)HRESULT.DISP_E_MEMBERNOTFOUND, ex.HResult);
-            Assert.Equal(default, varResult);
-            Assert.Equal(0u, argErr);
-            return;
-        }
-
-        Assert.Fail("Exception was not thrown");
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/SAFEARRAYTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/SAFEARRAYTests.cs
deleted file mode 100644
index 0c5d15d9f80..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/SAFEARRAYTests.cs
+++ /dev/null
@@ -1,405 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-using static Windows.Win32.System.Com.ADVANCED_FEATURE_FLAGS;
-using static Windows.Win32.System.Variant.VARENUM;
-
-namespace System.Windows.Forms.Tests.Interop.SafeArrayTests;
-
-public unsafe class SAFEARRAYTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public void SAFEARRAY_Sizeof_InvokeX86_ReturnsExpected()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(24, Marshal.SizeOf<SAFEARRAY>());
-        Assert.Equal(24, sizeof(SAFEARRAY));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public void SAFEARRAY_Sizeof_InvokeX64_ReturnsExpected()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(32, Marshal.SizeOf<SAFEARRAY>());
-        Assert.Equal(32, sizeof(SAFEARRAY));
-    }
-
-    public static IEnumerable<object[]> Create_TestData()
-    {
-        yield return new object[] { VT_I4, FADF_HAVEVARTYPE, 4 };
-        yield return new object[] { VT_I8, FADF_HAVEVARTYPE, 8 };
-        yield return new object[] { VT_BSTR, FADF_HAVEVARTYPE | FADF_BSTR, IntPtr.Size };
-        yield return new object[] { VT_UNKNOWN, FADF_HAVEIID | FADF_UNKNOWN, IntPtr.Size };
-        yield return new object[] { VT_DISPATCH, FADF_HAVEIID | FADF_DISPATCH, IntPtr.Size };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Create_TestData))]
-    public void SAFEARRAY_CreateSingleDimension_GetProperties_Success(ushort vt, ushort expectedFeatures, uint expectedCbElements)
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = 1
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate((VARENUM)vt, 1, &saBound);
-        Assert.True(psa != null);
-
-        try
-        {
-            Assert.Equal(1u, psa->cDims);
-            Assert.Equal((ADVANCED_FEATURE_FLAGS)expectedFeatures, psa->fFeatures);
-            Assert.Equal(expectedCbElements, psa->cbElements);
-            Assert.Equal(0u, psa->cLocks);
-            Assert.True(psa->pvData != null);
-            Assert.Equal(10u, psa->rgsabound._0.cElements);
-            Assert.Equal(1, psa->rgsabound._0.lLbound);
-
-            VARENUM arrayVt = VT_EMPTY;
-            HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal((VARENUM)vt, arrayVt);
-        }
-        finally
-        {
-            HRESULT hr = PInvoke.SafeArrayDestroy(psa);
-            Assert.Equal(HRESULT.S_OK, hr);
-        }
-    }
-
-    [StaFact]
-    public void SAFEARRAY_CreateSingleDimensionRECORD_GetProperties_Success()
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = 1
-        };
-
-        using ComScope<IRecordInfo> recordInfo = new(new CustomRecordInfo().GetComInterface());
-
-        SAFEARRAY* psa = PInvoke.SafeArrayCreateEx(VT_RECORD, 1, &saBound, recordInfo);
-        Assert.True(psa != null);
-
-        try
-        {
-            Assert.Equal(1u, psa->cDims);
-            Assert.Equal(FADF_RECORD, psa->fFeatures);
-            Assert.Equal((uint)sizeof(int), psa->cbElements);
-            Assert.Equal(0u, psa->cLocks);
-            Assert.True(psa->pvData != null);
-            Assert.Equal(10u, psa->rgsabound._0.cElements);
-            Assert.Equal(1, psa->rgsabound._0.lLbound);
-
-            VARENUM arrayVt = VT_EMPTY;
-            HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_RECORD, arrayVt);
-        }
-        finally
-        {
-            HRESULT hr = PInvoke.SafeArrayDestroy(psa);
-            Assert.Equal(HRESULT.S_OK, hr);
-        }
-    }
-
-    private class CustomRecordInfo : IRecordInfo.Interface
-    {
-        public IRecordInfo* GetComInterface() => (IRecordInfo*)Marshal.GetComInterfaceForObject<CustomRecordInfo, IRecordInfo.Interface>(this);
-
-        public HRESULT RecordInit(void* pvNew) => throw new NotImplementedException();
-
-        public HRESULT RecordClear(void* pvExisting) => throw new NotImplementedException();
-
-        public HRESULT RecordCopy(void* pvExisting, void* pvNew) => throw new NotImplementedException();
-
-        public Func<(Guid, HRESULT)> GetGuidAction { get; set; }
-
-        public HRESULT GetGuid(Guid* pguid)
-        {
-            (Guid guid, HRESULT hr) = GetGuidAction();
-            *pguid = guid;
-            return hr;
-        }
-
-        public HRESULT GetName(BSTR* pbstrName) => throw new NotImplementedException();
-
-        public HRESULT GetSize(uint* pcbSize)
-        {
-            *pcbSize = (uint)sizeof(int);
-            return HRESULT.S_OK;
-        }
-
-        public HRESULT GetTypeInfo(ITypeInfo** ppTypeInfo) => throw new NotImplementedException();
-
-        public HRESULT GetField(void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT GetFieldNoCopy(void* pvData, PCWSTR szFieldName, VARIANT* pvarField, void** ppvDataCArray) => throw new NotImplementedException();
-
-        public HRESULT PutField(uint wFlags, void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT PutFieldNoCopy(uint wFlags, void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT GetFieldNames(uint* pcNames, BSTR* rgBstrNames) => throw new NotImplementedException();
-
-        public BOOL IsMatchingType(IRecordInfo* pRecordInfoInfo) => throw new NotImplementedException();
-
-        public void* RecordCreate() => throw new NotImplementedException();
-
-        public HRESULT RecordCreateCopy(void* pvSource, void** ppvDest) => throw new NotImplementedException();
-
-        public HRESULT RecordDestroy(void* pvRecord) => throw new NotImplementedException();
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Create_TestData))]
-    public void SAFEARRAY_CreateMultipleDimensions_GetProperties_Success(ushort vt, ushort expectedFeatures, uint expectedCbElements)
-    {
-        SAFEARRAYBOUND* saBounds = stackalloc SAFEARRAYBOUND[2];
-        saBounds[0] = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = 1
-        };
-        saBounds[1] = new SAFEARRAYBOUND
-        {
-            cElements = 20,
-            lLbound = 0
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate((VARENUM)vt, 2, saBounds);
-        Assert.True(psa != null);
-
-        try
-        {
-            Assert.Equal(2u, psa->cDims);
-            Assert.Equal((ADVANCED_FEATURE_FLAGS)expectedFeatures, psa->fFeatures);
-            Assert.Equal(expectedCbElements, psa->cbElements);
-            Assert.Equal(0u, psa->cLocks);
-            Assert.True(psa->pvData != null);
-            Assert.Equal(20u, psa->rgsabound._0.cElements);
-            Assert.Equal(0, psa->rgsabound._0.lLbound);
-            Assert.Equal(10u, ((SAFEARRAYBOUND*)&psa->rgsabound)[1].cElements);
-            Assert.Equal(1, ((SAFEARRAYBOUND*)&psa->rgsabound)[1].lLbound);
-
-            VARENUM arrayVt = VT_EMPTY;
-            HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal((VARENUM)vt, arrayVt);
-        }
-        finally
-        {
-            HRESULT hr = PInvoke.SafeArrayDestroy(psa);
-            Assert.Equal(HRESULT.S_OK, hr);
-        }
-    }
-
-    [StaFact]
-    public void SAFEARRAY_GetValue_InvokeSingleDimensional_ReturnsExpected()
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = 0
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(VT_I4, 1, &saBound);
-        Assert.True(psa != null);
-
-        try
-        {
-            Span<int> indices1 = stackalloc int[] { 0 };
-            Span<int> indices2 = stackalloc int[] { 1 };
-
-            fixed (int* pIndices1 = indices1)
-            fixed (int* pIndices2 = indices2)
-            {
-                int value1 = 1;
-                HRESULT hr = PInvoke.SafeArrayPutElement(psa, pIndices1, &value1);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int value2 = 2;
-                hr = PInvoke.SafeArrayPutElement(psa, pIndices2, &value2);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int result = -1;
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices1, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(1, result);
-
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices2, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(2, result);
-            }
-
-            Assert.Equal(1, psa->GetValue<int>(indices1));
-            Assert.Equal(2, psa->GetValue<int>(indices2));
-        }
-        finally
-        {
-            PInvoke.SafeArrayDestroy(psa);
-        }
-    }
-
-    [StaFact]
-    public void SAFEARRAY_GetValue_InvokeSingleDimensionalNonZeroLowerBound_ReturnsExpected()
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = -5
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(VT_I4, 1, &saBound);
-        Assert.True(psa != null);
-
-        try
-        {
-            Span<int> indices1 = stackalloc int[] { -5 };
-            Span<int> indices2 = stackalloc int[] { -4 };
-
-            fixed (int* pIndices1 = indices1)
-            fixed (int* pIndices2 = indices2)
-            {
-                int value1 = 1;
-                HRESULT hr = PInvoke.SafeArrayPutElement(psa, pIndices1, &value1);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int value2 = 2;
-                hr = PInvoke.SafeArrayPutElement(psa, pIndices2, &value2);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int result = -1;
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices1, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(1, result);
-
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices2, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(2, result);
-            }
-
-            Assert.Equal(1, psa->GetValue<int>(indices1));
-            Assert.Equal(2, psa->GetValue<int>(indices2));
-        }
-        finally
-        {
-            PInvoke.SafeArrayDestroy(psa);
-        }
-    }
-
-    [StaFact]
-    public void SAFEARRAY_GetValue_InvokeMultiDimensional_ReturnsExpected()
-    {
-        SAFEARRAYBOUND* saBounds = stackalloc SAFEARRAYBOUND[2];
-        saBounds[0] = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = 0
-        };
-        saBounds[1] = new SAFEARRAYBOUND
-        {
-            cElements = 20,
-            lLbound = 0
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(VT_I4, 2, saBounds);
-        Assert.True(psa != null);
-
-        try
-        {
-            Span<int> indices1 = stackalloc int[] { 0, 0 };
-            Span<int> indices2 = stackalloc int[] { 1, 2 };
-
-            fixed (int* pIndices1 = indices1)
-            fixed (int* pIndices2 = indices2)
-            {
-                int value1 = 1;
-                HRESULT hr = PInvoke.SafeArrayPutElement(psa, pIndices1, &value1);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int value2 = 2;
-                hr = PInvoke.SafeArrayPutElement(psa, pIndices2, &value2);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int result = -1;
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices1, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(1, result);
-
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices2, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(2, result);
-            }
-
-            Assert.Equal(1, psa->GetValue<int>(indices1));
-            Assert.Equal(2, psa->GetValue<int>(indices2));
-        }
-        finally
-        {
-            PInvoke.SafeArrayDestroy(psa);
-        }
-    }
-
-    [StaFact]
-    public void SAFEARRAY_GetValue_InvokeMultiDimensionalNonZeroLowerBound_ReturnsExpected()
-    {
-        SAFEARRAYBOUND* saBounds = stackalloc SAFEARRAYBOUND[2];
-        saBounds[0] = new SAFEARRAYBOUND
-        {
-            cElements = 10,
-            lLbound = -5
-        };
-        saBounds[1] = new SAFEARRAYBOUND
-        {
-            cElements = 20,
-            lLbound = -4
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(VT_I4, 2, saBounds);
-        Assert.True(psa != null);
-
-        try
-        {
-            Span<int> indices1 = stackalloc int[] { -5, -4 };
-            Span<int> indices2 = stackalloc int[] { -4, -3 };
-
-            fixed (int* pIndices1 = indices1)
-            fixed (int* pIndices2 = indices2)
-            {
-                int value1 = 1;
-                HRESULT hr = PInvoke.SafeArrayPutElement(psa, pIndices1, &value1);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int value2 = 2;
-                hr = PInvoke.SafeArrayPutElement(psa, pIndices2, &value2);
-                Assert.Equal(HRESULT.S_OK, hr);
-
-                int result = -1;
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices1, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(1, result);
-
-                hr = PInvoke.SafeArrayGetElement(psa, pIndices2, &result);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(2, result);
-            }
-
-            Assert.Equal(1, psa->GetValue<int>(indices1));
-            Assert.Equal(2, psa->GetValue<int>(indices2));
-        }
-        finally
-        {
-            PInvoke.SafeArrayDestroy(psa);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/VARIANTTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/VARIANTTests.cs
deleted file mode 100644
index bd19d46ec3d..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Oleaut32/VARIANTTests.cs
+++ /dev/null
@@ -1,5845 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-using static Windows.Win32.System.Com.ADVANCED_FEATURE_FLAGS;
-using static Windows.Win32.System.Variant.VARENUM;
-using static Interop;
-
-namespace System.Windows.Forms.Tests.Interop.Oleaut32;
-
-public unsafe class VARIANTTests
-{
-    private static VARIANT Create(VARENUM type)
-        => new () { vt = type };
-
-    private static VARIANT Create(VARENUM type, void* value)
-        => new()
-        {
-            vt = type,
-            data = new() { byref = value }
-        };
-
-    private static VARIANT Create(bool value)
-        => new()
-        {
-            vt = VT_BOOL,
-            data = new() { boolVal = value ? VARIANT_BOOL.VARIANT_TRUE : VARIANT_BOOL.VARIANT_FALSE }
-        };
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public void VARIANT_Sizeof_InvokeX86_ReturnsExpected()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(16, Marshal.SizeOf<VARIANT>());
-        Assert.Equal(16, sizeof(VARIANT));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public void VARIANT_Sizeof_InvokeX64_ReturnsExpected()
-    {
-        if (!Environment.Is64BitProcess)
-        {
-            return;
-        }
-
-        Assert.Equal(24, Marshal.SizeOf<VARIANT>());
-        Assert.Equal(24, sizeof(VARIANT));
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_EMPTY, false)]
-    [InlineData((ushort)VT_BOOL, false)]
-    [InlineData((ushort)(VT_BYREF), true)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF), true)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF | VT_ARRAY), true)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF | VT_VECTOR), true)]
-    [InlineData((ushort)(VT_BOOL | VT_ARRAY), false)]
-    [InlineData((ushort)(VT_BOOL | VT_VECTOR), false)]
-    public void VARIANT_Byref_Get_ReturnsExpected(ushort vt, bool expected)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        Assert.Equal(expected, variant.Byref);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_EMPTY, (ushort)VT_EMPTY)]
-    [InlineData((ushort)VT_BOOL, (ushort)VT_BOOL)]
-    [InlineData((ushort)(VT_BYREF), (ushort)VT_EMPTY)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF), (ushort)VT_BOOL)]
-    public void VARIANT_Type_Get_ReturnsExpected(ushort vt, ushort expected)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        Assert.Equal((VARENUM)expected, variant.Type);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_EMPTY)]
-    [InlineData((ushort)(VT_EMPTY | VT_BYREF))]
-    [InlineData((ushort)VT_UNKNOWN)]
-    [InlineData((ushort)(VT_UNKNOWN | VT_BYREF))]
-    [InlineData((ushort)VT_DISPATCH)]
-    [InlineData((ushort)(VT_DISPATCH | VT_BYREF))]
-    [InlineData((ushort)VT_BSTR)]
-    [InlineData((ushort)(VT_BSTR | VT_BYREF))]
-    [InlineData((ushort)VT_BOOL)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF))]
-    public void VARIANT_Clear_InvokeDefault_Success(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        variant.Clear();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.punkVal is null);
-    }
-
-    [StaFact]
-    public void VARIANT_Clear_InvokeCustom_Success()
-    {
-        using VARIANT variant = Create(true);
-        variant.Clear();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.punkVal is null);
-    }
-
-    [StaFact]
-    public void VARIANT_Clear_InvokeBSTR_Success()
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_BSTR,
-            data = new() { bstrVal = new BSTR("abc") }
-        };
-
-        variant.Clear();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.pbstrVal is null);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_EMPTY)]
-    [InlineData((ushort)(VT_EMPTY | VT_BYREF))]
-    [InlineData((ushort)VT_UNKNOWN)]
-    [InlineData((ushort)(VT_UNKNOWN | VT_BYREF))]
-    [InlineData((ushort)VT_DISPATCH)]
-    [InlineData((ushort)(VT_DISPATCH | VT_BYREF))]
-    [InlineData((ushort)VT_BSTR)]
-    [InlineData((ushort)(VT_BSTR | VT_BYREF))]
-    [InlineData((ushort)VT_BOOL)]
-    [InlineData((ushort)(VT_BOOL | VT_BYREF))]
-    public void VARIANT_Dispose_InvokeDefault_Success(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        variant.Dispose();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.punkVal is null);
-    }
-
-    [StaFact]
-    public void VARIANT_Dispose_InvokeCustom_Success()
-    {
-        using VARIANT variant = Create(true);
-        variant.Dispose();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.punkVal is null);
-    }
-
-    [StaFact]
-    public void VARIANT_Dispose_InvokeBSTR_Success()
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_BSTR,
-            data = new() { bstrVal = new BSTR("abc") }
-        };
-        variant.Dispose();
-        Assert.Equal(VT_EMPTY, variant.vt);
-        Assert.True(variant.Anonymous.Anonymous.Anonymous.pbstrVal is null);
-    }
-
-    public static IEnumerable<object[]> ToObject_TestData()
-    {
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I1, unchecked((nint)long.MinValue), (sbyte)0 };
-        }
-
-        yield return new object[] { VT_I1, (nint)int.MinValue, (sbyte)0 };
-        yield return new object[] { VT_I1, (nint)short.MinValue, (sbyte)0 };
-        yield return new object[] { VT_I1, (nint)sbyte.MinValue, sbyte.MinValue };
-        yield return new object[] { VT_I1, (nint)(-10), (sbyte)(-10) };
-        yield return new object[] { VT_I1, (nint)0, (sbyte)0 };
-        yield return new object[] { VT_I1, (nint)10, (sbyte)10 };
-        yield return new object[] { VT_I1, (nint)sbyte.MaxValue, sbyte.MaxValue };
-        yield return new object[] { VT_I1, (nint)short.MaxValue, (sbyte)(-1) };
-        yield return new object[] { VT_I1, (nint)int.MaxValue, (sbyte)(-1) };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I1, unchecked((nint)long.MaxValue), (sbyte)(-1) };
-        }
-
-        yield return new object[] { VT_UI1, (nint)(-10), (byte)246 };
-        yield return new object[] { VT_UI1, (nint)0, (byte)0 };
-        yield return new object[] { VT_UI1, (nint)10, (byte)10 };
-        yield return new object[] { VT_UI1, (nint)byte.MaxValue, byte.MaxValue };
-        yield return new object[] { VT_UI1, (nint)ushort.MaxValue, byte.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_UI1, unchecked((nint)uint.MaxValue), byte.MaxValue };
-        }
-
-        yield return new object[] { VT_UI1, (nint)(-1), byte.MaxValue };
-
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I2, unchecked((nint)long.MinValue), (short)0 };
-        }
-
-        yield return new object[] { VT_I2, (nint)int.MinValue, (short)0 };
-        yield return new object[] { VT_I2, (nint)short.MinValue, short.MinValue };
-        yield return new object[] { VT_I2, (nint)sbyte.MinValue, (short)sbyte.MinValue };
-        yield return new object[] { VT_I2, (nint)(-10), (short)(-10) };
-        yield return new object[] { VT_I2, (nint)0, (short)0 };
-        yield return new object[] { VT_I2, (nint)10, (short)10 };
-        yield return new object[] { VT_I2, (nint)sbyte.MaxValue, (short)sbyte.MaxValue };
-        yield return new object[] { VT_I2, (nint)short.MaxValue, short.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I2, unchecked((nint)long.MaxValue), (short)(-1) };
-        }
-
-        yield return new object[] { VT_UI2, (nint)(-10), (ushort)65526 };
-        yield return new object[] { VT_UI2, (nint)0, (ushort)0 };
-        yield return new object[] { VT_UI2, (nint)10, (ushort)10 };
-        yield return new object[] { VT_UI2, (nint)byte.MaxValue, (ushort)byte.MaxValue };
-        yield return new object[] { VT_UI2, (nint)ushort.MaxValue, ushort.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_UI2, unchecked((nint)uint.MaxValue), ushort.MaxValue };
-        }
-
-        yield return new object[] { VT_UI2, (nint)(-1), ushort.MaxValue };
-
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I4, unchecked((nint)long.MinValue), 0 };
-        }
-
-        yield return new object[] { VT_I4, (nint)int.MinValue, int.MinValue };
-        yield return new object[] { VT_I4, (nint)short.MinValue, (int)short.MinValue };
-        yield return new object[] { VT_I4, (nint)sbyte.MinValue, (int)sbyte.MinValue };
-        yield return new object[] { VT_I4, (nint)(-10), -10 };
-        yield return new object[] { VT_I4, (nint)0, 0 };
-        yield return new object[] { VT_I4, (nint)10, 10 };
-        yield return new object[] { VT_I4, (nint)sbyte.MaxValue, (int)sbyte.MaxValue };
-        yield return new object[] { VT_I4, (nint)short.MaxValue, (int)short.MaxValue };
-        yield return new object[] { VT_I4, (nint)int.MaxValue, int.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_I4, unchecked((nint)long.MaxValue), -1 };
-        }
-
-        yield return new object[] { VT_UI4, (nint)(-10), (uint)4294967286 };
-        yield return new object[] { VT_UI4, (nint)0, (uint)0 };
-        yield return new object[] { VT_UI4, (nint)10, (uint)10 };
-        yield return new object[] { VT_UI4, (nint)byte.MaxValue, (uint)byte.MaxValue };
-        yield return new object[] { VT_UI4, (nint)ushort.MaxValue, (uint)ushort.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_UI4, unchecked((nint)uint.MaxValue), uint.MaxValue };
-        }
-
-        yield return new object[] { VT_UI4, (nint)(-1), uint.MaxValue };
-
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_INT, unchecked((nint)long.MinValue), 0 };
-        }
-
-        yield return new object[] { VT_INT, (nint)int.MinValue, int.MinValue };
-        yield return new object[] { VT_INT, (nint)short.MinValue, (int)short.MinValue };
-        yield return new object[] { VT_INT, (nint)sbyte.MinValue, (int)sbyte.MinValue };
-        yield return new object[] { VT_INT, (nint)(-10), -10 };
-        yield return new object[] { VT_INT, (nint)0, 0 };
-        yield return new object[] { VT_INT, (nint)10, 10 };
-        yield return new object[] { VT_INT, (nint)sbyte.MaxValue, (int)sbyte.MaxValue };
-        yield return new object[] { VT_INT, (nint)short.MaxValue, (int)short.MaxValue };
-        yield return new object[] { VT_INT, (nint)int.MaxValue, int.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_INT, unchecked((nint)long.MaxValue), -1 };
-        }
-
-        yield return new object[] { VT_UINT, (nint)(-10), (uint)4294967286 };
-        yield return new object[] { VT_UINT, (nint)0, (uint)0 };
-        yield return new object[] { VT_UINT, (nint)10, (uint)10 };
-        yield return new object[] { VT_UINT, (nint)byte.MaxValue, (uint)byte.MaxValue };
-        yield return new object[] { VT_UINT, (nint)ushort.MaxValue, (uint)ushort.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_UINT, unchecked((nint)uint.MaxValue), uint.MaxValue };
-        }
-
-        yield return new object[] { VT_UINT, (nint)(-1), uint.MaxValue };
-
-        yield return new object[] { VT_BOOL, (nint)(-1), true };
-        yield return new object[] { VT_BOOL, (nint)0, false };
-        yield return new object[] { VT_BOOL, (nint)1, true };
-
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_ERROR, unchecked((nint)long.MinValue), 0 };
-        }
-
-        yield return new object[] { VT_ERROR, (nint)int.MinValue, int.MinValue };
-        yield return new object[] { VT_ERROR, (nint)short.MinValue, (int)short.MinValue };
-        yield return new object[] { VT_ERROR, (nint)sbyte.MinValue, (int)sbyte.MinValue };
-        yield return new object[] { VT_ERROR, (nint)(-10), -10 };
-        yield return new object[] { VT_ERROR, (nint)0, 0 };
-        yield return new object[] { VT_ERROR, (nint)10, 10 };
-        yield return new object[] { VT_ERROR, (nint)sbyte.MaxValue, (int)sbyte.MaxValue };
-        yield return new object[] { VT_ERROR, (nint)short.MaxValue, (int)short.MaxValue };
-        yield return new object[] { VT_ERROR, (nint)int.MaxValue, int.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { VT_ERROR, unchecked((nint)long.MaxValue), -1 };
-        }
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ToObject_TestData))]
-    public void VARIANT_ToObject_Invoke_ReturnsExpected(ushort vt, nint data, object expected)
-    {
-        using VARIANT variant = Create((VARENUM)vt, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ToObject_TestData))]
-    public void VARIANT_ToObject_InvokeBYREF_ReturnsExpected(ushort vt, nint data, object expected)
-    {
-        using VARIANT variant = Create((VARENUM)vt | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> BYREFNoData_TestData()
-    {
-        yield return new object[] { VT_I2 };
-        yield return new object[] { VT_I4 };
-        yield return new object[] { VT_R4 };
-        yield return new object[] { VT_R8 };
-        yield return new object[] { VT_CY };
-        yield return new object[] { VT_DATE };
-        yield return new object[] { VT_BSTR };
-        yield return new object[] { VT_DISPATCH };
-        yield return new object[] { VT_ERROR };
-        yield return new object[] { VT_BOOL };
-        yield return new object[] { VT_VARIANT };
-        yield return new object[] { VT_UNKNOWN };
-        yield return new object[] { VT_DECIMAL };
-        yield return new object[] { VT_I1 };
-        yield return new object[] { VT_UI1 };
-        yield return new object[] { VT_UI2 };
-        yield return new object[] { VT_UI4 };
-        yield return new object[] { VT_I8 };
-        yield return new object[] { VT_UI8 };
-        yield return new object[] { VT_INT };
-        yield return new object[] { VT_UINT };
-        yield return new object[] { VT_VOID };
-        yield return new object[] { VT_HRESULT };
-        yield return new object[] { VT_PTR };
-        yield return new object[] { VT_SAFEARRAY };
-        yield return new object[] { VT_CARRAY };
-        yield return new object[] { VT_USERDEFINED };
-        yield return new object[] { VT_LPSTR };
-        yield return new object[] { VT_LPWSTR };
-        yield return new object[] { VT_RECORD };
-        yield return new object[] { VT_INT_PTR };
-        yield return new object[] { VT_UINT_PTR };
-        yield return new object[] { VT_FILETIME };
-        yield return new object[] { VT_BLOB };
-        yield return new object[] { VT_STREAM };
-        yield return new object[] { VT_STORAGE };
-        yield return new object[] { VT_STREAMED_OBJECT };
-        yield return new object[] { VT_STORED_OBJECT };
-        yield return new object[] { VT_BLOB_OBJECT };
-        yield return new object[] { VT_CF };
-        yield return new object[] { VT_CLSID };
-        yield return new object[] { VT_VERSIONED_STREAM };
-        yield return new object[] { VT_BSTR_BLOB };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(BYREFNoData_TestData))]
-    public void VARIANT_ToObject_BYREFNoData_Throws(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt | VT_BYREF);
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_I8_TestData()
-    {
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)long.MinValue), long.MinValue };
-            yield return new object[] { (nint)int.MinValue, (long)int.MinValue };
-            yield return new object[] { (nint)short.MinValue, (long)short.MinValue };
-            yield return new object[] { (nint)sbyte.MinValue, (long)sbyte.MinValue };
-            yield return new object[] { (nint)(-10), (long)(-10) };
-        }
-
-        yield return new object[] { (nint)0, (long)0 };
-        yield return new object[] { (nint)10, (long)10 };
-        yield return new object[] { (nint)sbyte.MaxValue, (long)sbyte.MaxValue };
-        yield return new object[] { (nint)short.MaxValue, (long)short.MaxValue };
-        yield return new object[] { (nint)int.MaxValue, (long)int.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)long.MaxValue), long.MaxValue };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_I8_TestData))]
-    public void VARIANT_ToObject_I8_ReturnsExpected(nint data, long expected)
-    {
-        using VARIANT variant = Create(VT_I8, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_I8BYREF_TestData()
-    {
-        yield return new object[] { long.MinValue };
-        yield return new object[] { int.MinValue };
-        yield return new object[] { short.MinValue };
-        yield return new object[] { sbyte.MinValue };
-        yield return new object[] { -10, };
-        yield return new object[] { 0, };
-        yield return new object[] { 10, };
-        yield return new object[] { sbyte.MaxValue };
-        yield return new object[] { short.MaxValue };
-        yield return new object[] { int.MaxValue };
-        yield return new object[] { long.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_I8BYREF_TestData))]
-    public void VARIANT_ToObject_I8BYREF_ReturnsExpected(long data)
-    {
-        using VARIANT variant = Create(VT_I8 | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqual(data, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_UI8_TestData()
-    {
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { (nint)(-10), (ulong)18446744073709551606 };
-        }
-
-        yield return new object[] { (nint)0, (ulong)0 };
-        yield return new object[] { (nint)10, (ulong)10 };
-        yield return new object[] { (nint)byte.MaxValue, (ulong)byte.MaxValue };
-        yield return new object[] { (nint)ushort.MaxValue, (ulong)ushort.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)uint.MaxValue), (ulong)uint.MaxValue };
-            yield return new object[] { (nint)(-1L), ulong.MaxValue };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_UI8_TestData))]
-    public void VARIANT_ToObject_UI8_ReturnsExpected(nint data, ulong expected)
-    {
-        using VARIANT variant = Create(VT_UI8, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_UI8BYREF_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 10 };
-        yield return new object[] { byte.MaxValue };
-        yield return new object[] { ushort.MaxValue };
-        yield return new object[] { uint.MaxValue };
-        yield return new object[] { ulong.MaxValue };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_UI8BYREF_TestData))]
-    public void VARIANT_ToObject_UI8BYREF_ReturnsExpected(ulong data)
-    {
-        using VARIANT variant = Create(VT_UI8 | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqual(data, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_CY_TestData()
-    {
-        yield return new object[] { (nint)0, 0.0m };
-        yield return new object[] { (nint)10, 0.001m };
-        yield return new object[] { (nint)10000, 1m };
-        yield return new object[] { (nint)123456, 12.3456m };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { (nint)(-10), -0.001m };
-            yield return new object[] { (nint)(-10000), -1m };
-            yield return new object[] { (nint)(-123456), -12.3456m };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_CY_TestData))]
-    public void VARIANT_ToObject_CY_ReturnsExpected(nint data, decimal expected)
-    {
-        using VARIANT variant = Create(VT_CY, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_CYBYREF_TestData()
-    {
-        yield return new object[] { 0, 0.0m };
-        yield return new object[] { 10, 0.001m };
-        yield return new object[] { 10000, 1m };
-        yield return new object[] { 123456, 12.3456m };
-        yield return new object[] { -10, -0.001m };
-        yield return new object[] { -10000, -1m };
-        yield return new object[] { -123456, -12.3456m };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_CYBYREF_TestData))]
-    public void VARIANT_ToObject_CYBYREF_ReturnsExpected(long data, decimal expected)
-    {
-        using VARIANT variant = Create(VT_CY | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_R4_TestData()
-    {
-        yield return new object[] { (nint)0, 0.0f };
-        yield return new object[] { (nint)1067030938, 1.2f };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)3214514586), -1.2f };
-            yield return new object[] { unchecked((nint)4290772992), float.NaN };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_R4_TestData))]
-    public void VARIANT_ToObject_R4_ReturnsExpected(nint data, float expected)
-    {
-        using VARIANT variant = Create(VT_R4, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_R4BYREF_TestData()
-    {
-        yield return new object[] { 0.0f };
-        yield return new object[] { 1.2f };
-        yield return new object[] { -1.2f };
-        yield return new object[] { float.NaN };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_R4BYREF_TestData))]
-    public void VARIANT_ToObject_R4BYREF_ReturnsExpected(float data)
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_R4 | VT_BYREF,
-            data = new()
-            {
-                pfltVal = &data
-            }
-        };
-
-        AssertToObjectEqual(data, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_R8_TestData()
-    {
-        yield return new object[] { (nint)0, 0.0 };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)4608083138725491507), 1.2 };
-            yield return new object[] { unchecked((nint)(-4615288898129284301)), -1.2 };
-            yield return new object[] { unchecked((nint)(-2251799813685248)), double.NaN };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_R8_TestData))]
-    public void VARIANT_ToObject_R8_ReturnsExpected(nint data, double expected)
-    {
-        using VARIANT variant = Create(VT_R8, (IUnknown*)data);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    public static IEnumerable<object[]> ToObject_R8BYREF_TestData()
-    {
-        yield return new object[] { 0.0 };
-        yield return new object[] { 1.2 };
-        yield return new object[] { -1.2 };
-        yield return new object[] { double.NaN };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToObject_R8BYREF_TestData))]
-    public void VARIANT_ToObject_R8BYREF_ReturnsExpected(double data)
-    {
-        using VARIANT variant = Create(VT_R8 | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqual(data, variant);
-    }
-
-    public static IEnumerable<object[]> NULL_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (nint)1 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(NULL_TestData))]
-    public void VARIANT_ToObject_NULL_Success(nint data)
-    {
-        using VARIANT variant = Create(VT_BYREF | VT_NULL, (IUnknown*)data);
-        AssertToObjectEqual(Convert.DBNull, variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(NULL_TestData))]
-    public void VARIANT_ToObject_NULLBYREFData_Success(nint data)
-    {
-        using VARIANT variant = Create(VT_BYREF | VT_NULL, (IUnknown*)&data);
-        AssertToObjectEqual(Convert.DBNull, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_NULLBYREFNoData_Success()
-    {
-        using VARIANT variant = Create(VT_BYREF | VT_NULL);
-        AssertToObjectEqual(Convert.DBNull, variant);
-    }
-
-    public static IEnumerable<object[]> EMPTY_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (nint)1 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(EMPTY_TestData))]
-    public void VARIANT_ToObject_EMPTY_Success(nint data)
-    {
-        using VARIANT variant = Create(VT_EMPTY, (IUnknown*)data);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(EMPTY_TestData))]
-    public void VARIANT_ToObject_EMPTYBYREFData_Success(nint data)
-    {
-        using VARIANT variant = Create(VT_BYREF | VT_EMPTY, (IUnknown*)&data);
-        AssertToObject(variant, value =>
-        {
-            if (IntPtr.Size == 8)
-            {
-                Assert.Equal((ulong)(IntPtr)variant.Anonymous.Anonymous.Anonymous.ppunkVal, value);
-            }
-            else
-            {
-                Assert.Equal((uint)(IntPtr)variant.Anonymous.Anonymous.Anonymous.ppunkVal, value);
-            }
-        });
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_EMPTYBYREFNoData_Success()
-    {
-        using VARIANT variant = Create(VT_BYREF | VT_EMPTY);
-        AssertToObject(variant, value =>
-        {
-            if (IntPtr.Size == 8)
-            {
-                Assert.Equal((ulong)0, value);
-            }
-            else
-            {
-                Assert.Equal((uint)0, value);
-            }
-        });
-    }
-
-    public static IEnumerable<object[]> HRESULT_TestData()
-    {
-        yield return new object[] { (nint)int.MinValue, int.MinValue };
-        yield return new object[] { (nint)short.MinValue, (int)short.MinValue };
-        yield return new object[] { (nint)sbyte.MinValue, (int)sbyte.MinValue };
-        yield return new object[] { (nint)(-10), -10 };
-        yield return new object[] { (nint)0, 0 };
-        yield return new object[] { (nint)10, 10 };
-        yield return new object[] { (nint)sbyte.MaxValue, (int)sbyte.MaxValue };
-        yield return new object[] { (nint)short.MaxValue, (int)short.MaxValue };
-        yield return new object[] { (nint)int.MaxValue, int.MaxValue };
-        if (IntPtr.Size == 8)
-        {
-            yield return new object[] { unchecked((nint)long.MinValue), 0 };
-            yield return new object[] { unchecked((nint)long.MaxValue), -1 };
-        }
-    }
-
-    [StaTheory]
-    [MemberData(nameof(HRESULT_TestData))]
-    public void VARIANT_ToObject_HRESULT_Success(nint data, int expected)
-    {
-        using VARIANT variant = Create(VT_HRESULT, (IUnknown*)data);
-        AssertToObjectEqualExtension<ArgumentException>(expected, variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(HRESULT_TestData))]
-    public void VARIANT_ToObject_HRESULTBYREF_Success(nint data, int expected)
-    {
-        using VARIANT variant = Create(VT_HRESULT | VT_BYREF, (IUnknown*)&data);
-        AssertToObjectEqualExtension<ArgumentException>(expected, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_FILETIME_Success()
-    {
-        using VARIANT variant = new();
-        var dt = new DateTime(2020, 05, 13, 13, 3, 12);
-        var ft = new PInvoke.FILETIME(dt);
-        HRESULT hr = InitPropVariantFromFileTime(&ft, &variant);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(VT_FILETIME, variant.vt);
-
-        AssertToObjectEqualExtension<ArgumentException>(new DateTime(2020, 05, 13, 13, 3, 12), variant);
-    }
-
-    [StaTheory]
-    [InlineData(-10)]
-    public void VARIANT_ToObject_InvalidFILETIME_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using VARIANT variant = new()
-        {
-            Anonymous = new()
-            {
-                Anonymous = new()
-                {
-                    vt = VT_FILETIME,
-                    Anonymous = new() { cyVal = new() { int64 = value } }
-                }
-            }
-        };
-
-        Assert.Throws<ArgumentOutOfRangeException>("fileTime", () => variant.ToObject());
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DateFromFILETIME_Success()
-    {
-        using VARIANT variant = new();
-        var dt = new DateTime(2020, 05, 13, 13, 3, 12, DateTimeKind.Utc).ToLocalTime();
-        var ft = new PInvoke.FILETIME(dt);
-        HRESULT hr = InitVariantFromFileTime(&ft, &variant);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(VT_DATE, variant.vt);
-
-        AssertToObjectEqual(new DateTime(2020, 05, 13, 13, 3, 12, DateTimeKind.Utc).ToUniversalTime(), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_Date_Success()
-    {
-        var dt = new DateTime(2020, 05, 13, 13, 3, 12);
-        double date = dt.ToOADate();
-        using VARIANT variant = new()
-        {
-            Anonymous = new()
-            {
-                Anonymous = new()
-                {
-                    vt = VT_DATE,
-                    Anonymous = new() { date = date }
-                }
-            }
-        };
-
-        AssertToObjectEqual(new DateTime(2020, 05, 13, 13, 3, 12), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DateEmpty_Success()
-    {
-        using VARIANT variant = Create(VT_DATE);
-        AssertToObjectEqual(new DateTime(1899, 12, 30), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DateBYREF_Success()
-    {
-        var dt = new DateTime(2020, 05, 13, 13, 3, 12);
-        double date = dt.ToOADate();
-        using VARIANT variant = new()
-        {
-            Anonymous = new()
-            {
-                Anonymous = new()
-                {
-                    vt = VT_DATE | VT_BYREF,
-                    Anonymous = new() { pdate = &date }
-                }
-            }
-        };
-
-        AssertToObjectEqual(new DateTime(2020, 05, 13, 13, 3, 12), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DateBYREFEmpty_Success()
-    {
-        double date = 0;
-        using VARIANT variant = Create(VT_DATE | VT_BYREF);
-        variant.data.pdate = &date;
-
-        AssertToObjectEqual(new DateTime(1899, 12, 30), variant);
-    }
-
-    [StaTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_BSTR_ReturnsExpected(string text)
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_BSTR,
-            data = new() { bstrVal = new BSTR(text) }
-        };
-        AssertToObjectEqual(text, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_BSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_BSTR);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaTheory]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_BSTRBYREF_ReturnsExpected(string text)
-    {
-        // ByRef VARIANTs are not freed
-        using BSTR bstr = new(text);
-        using VARIANT variant = new()
-        {
-            vt = VT_BSTR | VT_BYREF,
-            data = new() { pbstrVal = &bstr }
-        };
-        AssertToObjectEqual(text, variant);
-    }
-
-    [StaTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_LPWSTR_ReturnsExpected(string text)
-    {
-        using VARIANT variant = Create(VT_LPWSTR, (IUnknown*)(void*)Marshal.StringToCoTaskMemUni(text));
-        AssertToObjectEqualExtension<ArgumentException>(text, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_LPWSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_LPWSTR);
-        AssertToObjectEqualExtension<ArgumentException>(null, variant);
-    }
-
-    [StaTheory]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_LPWSTRBYREF_ReturnsExpected(string text)
-    {
-        fixed (char* t = text)
-        {
-            // Not freed when by ref, can just pin.
-            using VARIANT variant = Create(VT_LPWSTR | VT_BYREF, &t);
-            AssertToObjectEqualExtension<ArgumentException>(text, variant);
-        }
-    }
-
-    [StaTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_LPSTR_ReturnsExpected(string text)
-    {
-        using VARIANT variant = Create(VT_LPSTR, (void*)Marshal.StringToCoTaskMemAnsi(text));
-        AssertToObjectEqualExtension<ArgumentException>(text, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_LPSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_LPSTR);
-        AssertToObjectEqualExtension<ArgumentException>(null, variant);
-    }
-
-    [StaTheory]
-    [InlineData("")]
-    [InlineData("text")]
-    public void VARIANT_ToObject_LPSTRBYREF_ReturnsExpected(string text)
-    {
-        IntPtr ptr = Marshal.StringToCoTaskMemAnsi(text);
-        try
-        {
-            using VARIANT variant = Create(VT_LPSTR | VT_BYREF, &ptr);
-            AssertToObjectEqualExtension<ArgumentException>(text, variant);
-        }
-        finally
-        {
-            Marshal.FreeCoTaskMem(ptr);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_Dispatch_ReturnsExpected()
-    {
-        var o = new object();
-        IntPtr pUnk = Marshal.GetIUnknownForObject(o);
-        using VARIANT variant = Create(VT_DISPATCH, (void*)pUnk);
-        AssertToObjectEqual(o, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DispatchNoData_ReturnsNull()
-    {
-        using VARIANT variant = Create(VT_DISPATCH);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DispatchBYREF_ReturnsExpected()
-    {
-        var o = new object();
-        using ComScope<IUnknown> unknown = new((IUnknown*)(void*)Marshal.GetIUnknownForObject(o));
-        using VARIANT variant = Create(VT_DISPATCH | VT_BYREF, &unknown);
-        AssertToObjectEqual(o, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DispatchBYREFNullData_ReturnsNull()
-    {
-        IUnknown* unknown = null;
-        using VARIANT variant = Create(VT_DISPATCH | VT_BYREF, &unknown);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_UNKNOWN_ReturnsExpected()
-    {
-        var o = new object();
-        IntPtr pUnk = Marshal.GetIUnknownForObject(o);
-        using VARIANT variant = Create(VT_UNKNOWN, (void*)Marshal.GetIUnknownForObject(o));
-        AssertToObjectEqual(o, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_UNKNOWNNoData_ReturnsNull()
-    {
-        using VARIANT variant = Create(VT_UNKNOWN);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_UNKNOWNBYREF_ReturnsExpected()
-    {
-        var o = new object();
-        using ComScope<IUnknown> unknown = new((IUnknown*)(void*)Marshal.GetIUnknownForObject(o));
-        using VARIANT variant = Create(VT_UNKNOWN | VT_BYREF, &unknown);
-        AssertToObjectEqual(o, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_UNKNOWNBYREFNullData_ReturnsNull()
-    {
-        IUnknown* unknown = null;
-        using VARIANT variant = Create(VT_UNKNOWN | VT_BYREF, &unknown);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_I4VARIANTBYREF_ReturnsExpected()
-    {
-        using VARIANT target = new()
-        {
-            Anonymous = new()
-            {
-                Anonymous = new()
-                {
-                    vt = VT_I4,
-                    Anonymous = new() { llVal = 10 }
-                }
-            }
-        };
-
-        using VARIANT variant = Create(VT_VARIANT | VT_BYREF, &target);
-        AssertToObjectEqual(10, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_BSTRVARIANTBYREF_ReturnsExpected()
-    {
-        using VARIANT target = new()
-        {
-            vt = VT_BSTR,
-            data = new() { bstrVal = new BSTR("test") }
-        };
-        using VARIANT variant = Create(VT_VARIANT | VT_BYREF, &target);
-        AssertToObjectEqual("test", variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_EMPTYVARIANTBYREF_ThrowsInvalidOleVariantTypeException()
-    {
-        using VARIANT target = Create(VT_EMPTY);
-        using VARIANT variant = Create(VT_VARIANT | VT_BYREF, &target);
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_BYREFVARIANTBYREF_ThrowsInvalidOleVariantTypeException()
-    {
-        int lval = 10;
-        using VARIANT target = new()
-        {
-            Anonymous = new()
-            {
-                Anonymous = new()
-                {
-                    vt = VT_BYREF | VT_I4,
-                    Anonymous = new() { plVal = &lval }
-                }
-            }
-        };
-
-        using VARIANT variant = Create(VT_VARIANT | VT_BYREF, &target);
-        AssertToObjectThrows<InvalidOleVariantTypeException>(variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VARIANT_ThrowsArgumentException()
-    {
-        using VARIANT variant = Create(VT_VARIANT);
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    public static IEnumerable<object[]> Decimal_I8_TestData()
-    {
-        yield return new object[] { long.MinValue, (decimal)long.MinValue };
-        yield return new object[] { -123, -123m };
-        yield return new object[] { 0, 0m };
-        yield return new object[] { 123, 123m };
-        yield return new object[] { long.MaxValue, (decimal)long.MaxValue };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Decimal_I8_TestData))]
-    public void VARIANT_ToObject_DecimalI8_ReturnsExpected(long i8, decimal expected)
-    {
-        VarDecFromI8(i8, out DECIMAL d);
-        VARIANT_ToObject_Decimal_ReturnsExpected(d, expected);
-        VARIANT_ToObject_DecimalBYREF_ReturnsExpected(d, expected);
-    }
-
-    public static IEnumerable<object[]> Decimal_R8_TestData()
-    {
-        yield return new object[] { -10e12, -10e12m };
-        yield return new object[] { -123.456, -123.456m };
-        yield return new object[] { 0.0, 0m };
-        yield return new object[] { 123.456, 123.456m };
-        yield return new object[] { 10e12, 10e12m };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Decimal_R8_TestData))]
-    public void VARIANT_ToObject_DecimalR8_ReturnsExpected(double r8, decimal expected)
-    {
-        VarDecFromR8(r8, out DECIMAL d);
-        VARIANT_ToObject_Decimal_ReturnsExpected(d, expected);
-        VARIANT_ToObject_DecimalBYREF_ReturnsExpected(d, expected);
-    }
-
-    public static IEnumerable<object[]> Decimal_TestData()
-    {
-        yield return new object[] { new DECIMAL(), 0.0m };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Decimal_TestData))]
-    public void VARIANT_ToObject_Decimal_ReturnsExpected(object d, decimal expected)
-    {
-        VARIANT variant = new();
-        *(DECIMAL*)(&variant) = (DECIMAL)d;
-        variant.Anonymous.Anonymous.vt = VT_DECIMAL;
-        AssertToObjectEqual(expected, variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(Decimal_TestData))]
-    public void VARIANT_ToObject_DecimalBYREF_ReturnsExpected(object d, decimal expected)
-    {
-        DECIMAL asD = (DECIMAL)d;
-        using VARIANT variant = Create(VT_DECIMAL | VT_BYREF, &asD);
-        AssertToObjectEqual(expected, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_CLSID_ReturnsExpected()
-    {
-        var guid = Guid.NewGuid();
-        using VARIANT variant = new();
-        HRESULT hr = InitPropVariantFromCLSID(&guid, &variant);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(VT_CLSID, variant.vt);
-
-        AssertToObjectEqualExtension<ArgumentException>(guid, variant);
-    }
-
-    public static IEnumerable<object[]> VOID_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)1 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VOID_TestData))]
-    public void VARIANT_ToObject_VOID_ReturnsExpected(IntPtr data)
-    {
-        using VARIANT variant = Create(VT_VOID, (void*)data);
-        IntPtr pv = (IntPtr)(&variant);
-        Assert.Null(Marshal.GetObjectForNativeVariant(pv));
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_USERDEFINED)]
-    [InlineData((ushort)(VT_USERDEFINED | VT_BYREF))]
-    public void VARIANT_ToObject_USERDATA_ThrowsArgumentException(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)(VT_VOID | VT_BYREF))]
-    [InlineData((ushort)VT_PTR)]
-    [InlineData((ushort)(VT_PTR | VT_BYREF))]
-    [InlineData((ushort)VT_SAFEARRAY)]
-    [InlineData((ushort)(VT_SAFEARRAY | VT_BYREF))]
-    [InlineData((ushort)VT_CARRAY)]
-    [InlineData((ushort)(VT_CARRAY | VT_BYREF))]
-    [InlineData((ushort)VT_RECORD)]
-    [InlineData((ushort)(VT_RECORD | VT_BYREF))]
-    [InlineData((ushort)VT_BLOB)]
-    [InlineData((ushort)(VT_BLOB | VT_BYREF))]
-    [InlineData((ushort)VT_STREAM)]
-    [InlineData((ushort)(VT_STREAM | VT_BYREF))]
-    [InlineData((ushort)VT_STORAGE)]
-    [InlineData((ushort)(VT_STORAGE | VT_BYREF))]
-    [InlineData((ushort)VT_STREAMED_OBJECT)]
-    [InlineData((ushort)(VT_STREAMED_OBJECT | VT_BYREF))]
-    [InlineData((ushort)VT_STORED_OBJECT)]
-    [InlineData((ushort)(VT_STORED_OBJECT | VT_BYREF))]
-    [InlineData((ushort)VT_BLOB_OBJECT)]
-    [InlineData((ushort)(VT_BLOB_OBJECT | VT_BYREF))]
-    [InlineData((ushort)VT_CF)]
-    [InlineData((ushort)(VT_CF | VT_BYREF))]
-    [InlineData((ushort)(VT_BSTR_BLOB | VT_BYREF))]
-    [InlineData((ushort)VT_ILLEGAL)]
-    [InlineData((ushort)VT_INT_PTR)]
-    [InlineData((ushort)VT_UINT_PTR)]
-    [InlineData(127)]
-    [InlineData(0x000F)]
-    [InlineData(0x0020)]
-    [InlineData(0x0021)]
-    [InlineData(0x0022)]
-    [InlineData(0x0023)]
-    [InlineData(0x0024)]
-    public void VARIANT_ToObject_CantConvert_ThrowsArgumentException(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    [StaTheory]
-    [InlineData(128)]
-    [InlineData(129)]
-    [InlineData((ushort)VT_BSTR_BLOB)]
-    public void VARIANT_ToObject_Illegal_ThrowsInvalidOleVariantTypeException(ushort vt)
-    {
-        using VARIANT variant = Create((VARENUM)vt);
-        AssertToObjectThrows<InvalidOleVariantTypeException>(variant);
-    }
-
-    public static IEnumerable<object[]> VectorI1_TestData()
-    {
-        yield return new object[] { Array.Empty<sbyte>() };
-        yield return new object[] { new sbyte[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI1_TestData))]
-    public void VARIANT_ToObject_VECTORI1_ReturnsExpected(sbyte[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (sbyte* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromBuffer(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_UI1, variant.vt);
-            }
-
-            // I1 and UI1 have the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_I1;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORI1NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_I1);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<sbyte>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorUI1_TestData()
-    {
-        yield return new object[] { Array.Empty<byte>() };
-        yield return new object[] { new byte[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI1_TestData))]
-    public void VARIANT_ToObject_VECTORUI1_ReturnsExpected(byte[] result)
-    {
-        using VARIANT variant = new();
-        fixed (byte* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromBuffer(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_UI1, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORUI1NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_UI1);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<byte>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorI2_TestData()
-    {
-        yield return new object[] { Array.Empty<short>() };
-        yield return new object[] { new short[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI2_TestData))]
-    public void VARIANT_ToObject_VECTORI2_ReturnsExpected(short[] result)
-    {
-        using VARIANT variant = new();
-        fixed (short* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromInt16Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_I2, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORI2NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_I2);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<short>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorUI2_TestData()
-    {
-        yield return new object[] { Array.Empty<ushort>() };
-        yield return new object[] { new ushort[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI2_TestData))]
-    public void VARIANT_ToObject_VECTORUI2_ReturnsExpected(ushort[] result)
-    {
-        using VARIANT variant = new();
-        fixed (ushort* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromUInt16Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_UI2, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORUI2NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_UI2);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<ushort>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorBOOL_TestData()
-    {
-        yield return new object[] { Array.Empty<BOOL>(), Array.Empty<bool>() };
-        yield return new object[] { new BOOL[] { BOOL.TRUE, BOOL.FALSE, BOOL.TRUE }, new bool[] { true, false, true } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorBOOL_TestData))]
-    public void VARIANT_ToObject_VECTORBOOL_ReturnsExpected(object result, bool[] expected)
-    {
-        using VARIANT variant = new();
-        BOOL[] boolResult = (BOOL[])result;
-        fixed (BOOL* pResult = boolResult)
-        {
-            HRESULT hr = InitPropVariantFromBooleanVector(pResult, (uint)boolResult.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_BOOL, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(expected, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORBOOLNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_BOOL);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<bool>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorI4_TestData()
-    {
-        yield return new object[] { Array.Empty<int>() };
-        yield return new object[] { new int[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI4_TestData))]
-    public void VARIANT_ToObject_VECTORI4_ReturnsExpected(int[] result)
-    {
-        using VARIANT variant = new();
-        fixed (int* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORI4NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_I4);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorUI4_TestData()
-    {
-        yield return new object[] { Array.Empty<uint>() };
-        yield return new object[] { new uint[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI4_TestData))]
-    public void VARIANT_ToObject_VECTORUI4_ReturnsExpected(uint[] result)
-    {
-        using VARIANT variant = new();
-        fixed (uint* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromUInt32Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_UI4, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORUI4NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_UI4);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<uint>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorINT_TestData()
-    {
-        yield return new object[] { Array.Empty<int>() };
-        yield return new object[] { new int[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorINT_TestData))]
-    public void VARIANT_ToObject_VECTORINT_ReturnsExpected(int[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (int* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-            }
-
-            // I4 and INT have the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_INT;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORINTNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_INT);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorUINT_TestData()
-    {
-        yield return new object[] { Array.Empty<uint>() };
-        yield return new object[] { new uint[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUINT_TestData))]
-    public void VARIANT_ToObject_VECTORUINT_ReturnsExpected(uint[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (uint* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromUInt32Vector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_UI4, variant.vt);
-            }
-
-            // UI4 and UINT have the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_UINT;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORUINTNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_UINT);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<uint>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorI8_TestData()
-    {
-        yield return new object[] { Array.Empty<long>() };
-        yield return new object[] { new long[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI8_TestData))]
-    public void VARIANT_ToObject_VECTORI8_ReturnsExpected(long[] result)
-    {
-        using VARIANT variant = new();
-        fixed (long* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromInt64Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_I8, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORI8NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_I8);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<long>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorUI8_TestData()
-    {
-        yield return new object[] { Array.Empty<ulong>() };
-        yield return new object[] { new ulong[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI8_TestData))]
-    public void VARIANT_ToObject_VECTORUI8_ReturnsExpected(ulong[] result)
-    {
-        using VARIANT variant = new();
-        fixed (ulong* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromUInt64Vector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_UI8, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORUI8NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_UI8);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<ulong>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorR4_TestData()
-    {
-        yield return new object[] { Array.Empty<float>() };
-        yield return new object[] { new float[] { 1.1f, 2.2f, 3.3f } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR4_TestData))]
-    public void VARIANT_ToObject_VECTORR4_ReturnsExpected(float[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (float* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-            }
-
-            // I4 and R4 are the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_R4;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORR4NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_R4);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorR8_TestData()
-    {
-        yield return new object[] { Array.Empty<double>() };
-        yield return new object[] { new double[] { 1.1, 2.2, 3.3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR8_TestData))]
-    public void VARIANT_ToObject_VECTORR8_ReturnsExpected(double[] result)
-    {
-        using VARIANT variant = new();
-        fixed (double* pResult = result)
-        {
-            HRESULT hr = InitPropVariantFromDoubleVector(pResult, (uint)result.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_R8, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORR8NoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_R8);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<double>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorERROR_TestData()
-    {
-        yield return new object[] { Array.Empty<uint>() };
-        yield return new object[] { new uint[] { 1, 2, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorERROR_TestData))]
-    public void VARIANT_ToObject_VECTORERROR_ReturnsExpected(uint[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (uint* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromUInt32Vector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_UI4, variant.vt);
-            }
-
-            // UI4 and ERROR are the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_ERROR;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORERRORNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_ERROR);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorCY_TestData()
-    {
-        yield return new object[] { Array.Empty<long>(), Array.Empty<decimal>() };
-        yield return new object[] { new long[] { 11000, 22000, 30000 }, new decimal[] { 1.1m, 2.2m, 3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorCY_TestData))]
-    public void VARIANT_ToObject_VECTORCY_ReturnsExpected(long[] result, decimal[] expected)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (long* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromInt64Vector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_I8, variant.vt);
-            }
-
-            // I8 and CY have the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_CY;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(expected, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORCYNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_CY);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<decimal>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorDATE_TestData()
-    {
-        yield return new object[] { Array.Empty<double>(), Array.Empty<DateTime>() };
-
-        var d1 = new DateTime(2020, 05, 13, 13, 3, 12);
-        var d2 = new DateTime(2020, 05, 13, 13, 3, 11);
-        var d3 = new DateTime(2020, 3, 13, 13, 3, 12);
-        yield return new object[] { new double[] { d1.ToOADate(), d2.ToOADate(), d3.ToOADate() }, new DateTime[] { d1, d2, d3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorDATE_TestData))]
-    public void VARIANT_ToObject_VECTORDATE_ReturnsExpected(double[] result, DateTime[] expected)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (double* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromDoubleVector(pResult, (uint)result.Length, &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_R8, variant.vt);
-            }
-
-            // R8 and DATE have the same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_DATE;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(expected, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORDATENoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_DATE);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<DateTime>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorFILETIME_TestData()
-    {
-        yield return new object[] { Array.Empty<PInvoke.FILETIME>(), Array.Empty<DateTime>() };
-
-        var d1 = new DateTime(2020, 05, 13, 13, 3, 12);
-        var d2 = new DateTime(2020, 05, 13, 13, 3, 11);
-        var d3 = new DateTime(2020, 3, 13, 13, 3, 12);
-        yield return new object[] { new PInvoke.FILETIME[] { new PInvoke.FILETIME(d1), new PInvoke.FILETIME(d2), new PInvoke.FILETIME(d3) }, new DateTime[] { d1, d2, d3 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorFILETIME_TestData))]
-    public void VARIANT_ToObject_VECTORFILETIME_ReturnsExpected(object result, DateTime[] expected)
-    {
-        using VARIANT variant = new();
-        PInvoke.FILETIME[] fileTimeResult = (PInvoke.FILETIME[])result;
-        fixed (PInvoke.FILETIME* pResult = fileTimeResult)
-        {
-            HRESULT hr = InitPropVariantFromFileTimeVector(pResult, (uint)fileTimeResult.Length, &variant);
-            Assert.Equal(HRESULT.S_OK, hr);
-            Assert.Equal(VT_VECTOR | VT_FILETIME, variant.vt);
-        }
-
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(expected, variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORFILETIMENoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_FILETIME);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<DateTime>(), variant);
-    }
-
-    public static IEnumerable<object[]> VectorCLSID_TestData()
-    {
-        yield return new object[] { Array.Empty<Guid>() };
-        yield return new object[] { new Guid[] { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorCLSID_TestData))]
-    public void VARIANT_ToObject_VECTORCLSID_ReturnsExpected(Guid[] result)
-    {
-        VARIANT variant = new();
-        try
-        {
-            fixed (Guid* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromBuffer(pResult, (uint)(result.Length * sizeof(Guid)), &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_UI1, variant.vt);
-            }
-
-            variant.Anonymous.Anonymous.Anonymous.ca.cElems = (uint)(variant.Anonymous.Anonymous.Anonymous.ca.cElems / sizeof(Guid));
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_CLSID;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(result, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORCLSIDNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_CLSID);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORBSTR_ReturnsExpected()
-    {
-        VARIANT variant = new();
-        IntPtr ptr1 = Marshal.StringToBSTR("text");
-        IntPtr ptr2 = Marshal.StringToBSTR("");
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            fixed (IntPtr* pResult = result)
-            {
-                if (IntPtr.Size == 4)
-                {
-                    HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-                }
-                else
-                {
-                    HRESULT hr = InitPropVariantFromInt64Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I8, variant.vt);
-                }
-            }
-
-            // I4/I8 and BSTR have same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_BSTR;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(new string[] { null, "text", "" }, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORBSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_BSTR);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORLPWSTR_ReturnsExpected()
-    {
-        VARIANT variant = new();
-        IntPtr ptr1 = Marshal.StringToCoTaskMemUni("text");
-        IntPtr ptr2 = Marshal.StringToCoTaskMemUni("");
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            fixed (IntPtr* pResult = result)
-            {
-                if (IntPtr.Size == 4)
-                {
-                    HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-                }
-                else
-                {
-                    HRESULT hr = InitPropVariantFromInt64Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I8, variant.vt);
-                }
-            }
-
-            // I4/I8 and LPWSTR have same size.
-            variant.vt = VT_VECTOR | VT_LPWSTR;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(new string[] { null, "text", "" }, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORLPWSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_LPWSTR);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORLPSTR_ReturnsExpected()
-    {
-        VARIANT variant = new();
-        IntPtr ptr1 = Marshal.StringToCoTaskMemAnsi("text");
-        IntPtr ptr2 = Marshal.StringToCoTaskMemAnsi("");
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            fixed (IntPtr* pResult = result)
-            {
-                if (IntPtr.Size == 4)
-                {
-                    HRESULT hr = InitPropVariantFromInt32Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I4, variant.vt);
-                }
-                else
-                {
-                    HRESULT hr = InitPropVariantFromInt64Vector(pResult, (uint)result.Length, &variant);
-                    Assert.Equal(HRESULT.S_OK, hr);
-                    Assert.Equal(VT_VECTOR | VT_I8, variant.vt);
-                }
-            }
-
-            // I4/I8 and LPSTR have same size.
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_LPSTR;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(new string[] { null, "text", "" }, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORLPSTRNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_LPSTR);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORVARIANT_ReturnsExpected()
-    {
-        VARIANT variant = new();
-        try
-        {
-            VARIANT variant1 = Create(VT_I4);
-            variant1.data.llVal = 1;
-            VARIANT variant2 = Create(VT_UI4);
-            variant2.data.ullVal = 2;
-            var result = new VARIANT[] { variant1, variant2 };
-            fixed (VARIANT* pResult = result)
-            {
-                HRESULT hr = InitPropVariantFromBuffer(pResult, (uint)(result.Length * sizeof(VARIANT)), &variant);
-                Assert.Equal(HRESULT.S_OK, hr);
-                Assert.Equal(VT_VECTOR | VT_UI1, variant.vt);
-            }
-
-            variant.data.ca.cElems = (uint)(variant.data.ca.cElems / sizeof(VARIANT));
-            variant.Anonymous.Anonymous.vt = VT_VECTOR | VT_VARIANT;
-            AssertToObjectEqualExtension<InvalidOleVariantTypeException>(new object[] { 1, 2u }, variant);
-        }
-        finally
-        {
-            variant.Dispose();
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_VECTORVARIANTNoData_ReturnsExpected()
-    {
-        using VARIANT variant = Create(VT_VECTOR | VT_VARIANT);
-        AssertToObjectEqualExtension<InvalidOleVariantTypeException>(Array.Empty<int>(), variant);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_EMPTY)]
-    [InlineData((ushort)VT_DECIMAL)]
-    [InlineData((ushort)VT_UNKNOWN)]
-    [InlineData((ushort)VT_DISPATCH)]
-    [InlineData((ushort)VT_NULL)]
-    [InlineData((ushort)VT_CF)]
-    [InlineData((ushort)VT_VOID)]
-    [InlineData((ushort)VT_PTR)]
-    [InlineData((ushort)VT_SAFEARRAY)]
-    [InlineData((ushort)VT_CARRAY)]
-    [InlineData((ushort)VT_RECORD)]
-    [InlineData((ushort)VT_BLOB)]
-    [InlineData((ushort)VT_STREAM)]
-    [InlineData((ushort)VT_STORAGE)]
-    [InlineData((ushort)VT_STREAMED_OBJECT)]
-    [InlineData((ushort)VT_STORED_OBJECT)]
-    [InlineData((ushort)VT_BLOB_OBJECT)]
-    [InlineData(127)]
-    [InlineData(0x000F)]
-    [InlineData(0x0020)]
-    [InlineData(0x0021)]
-    [InlineData(0x0022)]
-    [InlineData(0x0023)]
-    [InlineData(0x0024)]
-    public void VARIANT_ToObject_VECTORInvalidType_ThrowsArgumentException(ushort vt)
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_VECTOR | (VARENUM)vt
-        };
-        Assert.Throws<ArgumentException>(() => variant.ToObject());
-    }
-
-    [StaTheory]
-    [InlineData(128)]
-    [InlineData(129)]
-    [InlineData((ushort)VT_BSTR_BLOB)]
-    public void VARIANT_ToObject_VECTORInvalidTypeNoData_ThrowsInvalidOleVariantTypeException(ushort vt)
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_VECTOR | (VARENUM)vt
-        };
-        AssertToObjectThrows<InvalidOleVariantTypeException>(variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI1_TestData))]
-    public void VARIANT_ToObject_ARRAYUI1SingleDimension_ReturnsExpected(byte[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI1, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI1
-        };
-        variant.data.parray = psa;
-
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<byte[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI1_TestData))]
-    public void VARIANT_ToObject_ARRAYUI1SingleDimensionNonZeroLowerBounds_ReturnsExpected(byte[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI1, result, 1);
-        using VARIANT variant = Create(VT_ARRAY | VT_UI1);
-        variant.data.parray = psa;
-
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(byte).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionUI1_TestData()
-    {
-        yield return new object[] { new byte[0, 0] };
-        yield return new object[]
-        {
-            new byte[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI1_TestData))]
-    public void VARIANT_ToObject_ARRAYUI1MultiDimension_ReturnsExpected(byte[,] result)
-    {
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI1
-        };
-        variant.data.parray = CreateSafeArray(VT_UI1, result);
-
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(byte).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI1_TestData))]
-    public void VARIANT_ToObject_ARRAYUI1MultiDimensionNonZeroLowerBound_ReturnsExpected(byte[,] result)
-    {
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_UI1 };
-        variant.data.parray = CreateSafeArray(VT_UI1, result, 1, 2);
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(byte).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI1_TestData))]
-    public void VARIANT_ToObject_ARRAYI1SingleDimension_ReturnsExpected(sbyte[] result)
-    {
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_I1 };
-        variant.data.parray = CreateSafeArray(VT_I1, result);
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<sbyte[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI1_TestData))]
-    public void VARIANT_ToObject_ARRAYI1SingleDimensionNonZeroLowerBounds_ReturnsExpected(sbyte[] result)
-    {
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_I1 };
-        variant.data.parray = CreateSafeArray(VT_I1, result, 1);
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(sbyte).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionI1_TestData()
-    {
-        yield return new object[] { new sbyte[0, 0] };
-        yield return new object[]
-        {
-            new sbyte[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI1_TestData))]
-    public void VARIANT_ToObject_ARRAYI1MultiDimension_ReturnsExpected(sbyte[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I1,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(sbyte).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI1_TestData))]
-    public void VARIANT_ToObject_ARRAYI1MultiDimensionNonZeroLowerBound_ReturnsExpected(sbyte[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I1,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(sbyte).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI2_TestData))]
-    public void VARIANT_ToObject_ARRAYI2SingleDimension_ReturnsExpected(short[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I2, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<short[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI2_TestData))]
-    public void VARIANT_ToObject_ARRAYI2SingleDimensionNonZeroLowerBounds_ReturnsExpected(short[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I2, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(short).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionI2_TestData()
-    {
-        yield return new object[] { new short[0, 0] };
-        yield return new object[]
-        {
-            new short[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI2_TestData))]
-    public void VARIANT_ToObject_ARRAYI2MultiDimension_ReturnsExpected(short[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I2, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(short).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI2_TestData))]
-    public void VARIANT_ToObject_ARRAYI2MultiDimensionNonZeroLowerBound_ReturnsExpected(short[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I2, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(short).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI2_TestData))]
-    public void VARIANT_ToObject_ARRAYUI2SingleDimension_ReturnsExpected(ushort[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI2, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<ushort[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI2_TestData))]
-    public void VARIANT_ToObject_ARRAYUI2SingleDimensionNonZeroLowerBounds_ReturnsExpected(ushort[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI2, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ushort).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionUI2_TestData()
-    {
-        yield return new object[] { new ushort[0, 0] };
-        yield return new object[]
-        {
-            new ushort[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI2_TestData))]
-    public void VARIANT_ToObject_ARRAYUI2MultiDimension_ReturnsExpected(ushort[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI2, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ushort).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI2_TestData))]
-    public void VARIANT_ToObject_ARRAYUI2MultiDimensionNonZeroLowerBound_ReturnsExpected(ushort[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI2, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI2,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ushort).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI4_TestData))]
-    public void VARIANT_ToObject_ARRAYI4SingleDimension_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<int[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI4_TestData))]
-    public void VARIANT_ToObject_ARRAYI4SingleDimensionNonZeroLowerBounds_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionI4_TestData()
-    {
-        yield return new object[] { new int[0, 0] };
-        yield return new object[]
-        {
-            new int[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI4_TestData))]
-    public void VARIANT_ToObject_ARRAYI4MultiDimension_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI4_TestData))]
-    public void VARIANT_ToObject_ARRAYI4MultiDimensionNonZeroLowerBound_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI4_TestData))]
-    public void VARIANT_ToObject_INTArrayI4SingleDimension_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<int[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI4_TestData))]
-    public void VARIANT_ToObject_INTArrayI4SingleDimensionNonZeroLowerBounds_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI4_TestData))]
-    public void VARIANT_ToObject_INTArrayI4MultiDimension_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI4_TestData))]
-    public void VARIANT_ToObject_INTArrayI4MultiDimensionNonZeroLowerBound_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI4_TestData))]
-    public void VARIANT_ToObject_ARRAYUI4SingleDimension_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<uint[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI4_TestData))]
-    public void VARIANT_ToObject_ARRAYUI4SingleDimensionNonZeroLowerBounds_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionUI4_TestData()
-    {
-        yield return new object[] { new uint[0, 0] };
-        yield return new object[]
-        {
-            new uint[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI4_TestData))]
-    public void VARIANT_ToObject_ARRAYUI4MultiDimension_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI4_TestData))]
-    public void VARIANT_ToObject_ARRAYUI4MultiDimensionNonZeroLowerBound_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI4_TestData))]
-    public void VARIANT_ToObject_UINTArrayUI4SingleDimension_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<uint[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI4_TestData))]
-    public void VARIANT_ToObject_UINTArrayUI4SingleDimensionNonZeroLowerBounds_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI4_TestData))]
-    public void VARIANT_ToObject_UINTArrayUI4MultiDimension_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI4_TestData))]
-    public void VARIANT_ToObject_UINTArrayUI4MultiDimensionNonZeroLowerBound_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorINT_TestData))]
-    public void VARIANT_ToObject_ARRAYINTSingleDimension_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<int[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorINT_TestData))]
-    public void VARIANT_ToObject_ARRAYINTSingleDimensionNonZeroLowerBounds_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionINT_TestData()
-    {
-        yield return new object[] { new int[0, 0] };
-        yield return new object[]
-        {
-            new int[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionINT_TestData))]
-    public void VARIANT_ToObject_ARRAYINTMultiDimension_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionINT_TestData))]
-    public void VARIANT_ToObject_ARRAYINTMultiDimensionNonZeroLowerBound_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_INT, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorINT_TestData))]
-    public void VARIANT_ToObject_I4ArrayINTSingleDimension_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<int[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorINT_TestData))]
-    public void VARIANT_ToObject_I4ArrayINTSingleDimensionNonZeroLowerBounds_ReturnsExpected(int[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionINT_TestData))]
-    public void VARIANT_ToObject_I4ArrayINTMultiDimension_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionINT_TestData))]
-    public void VARIANT_ToObject_I4ArrayINTMultiDimensionNonZeroLowerBound_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I4, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_INT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(int).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUINT_TestData))]
-    public void VARIANT_ToObject_ARRAYUINTSingleDimension_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<uint[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUINT_TestData))]
-    public void VARIANT_ToObject_ARRAYUINTSingleDimensionNonZeroLowerBounds_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionUINT_TestData()
-    {
-        yield return new object[] { new uint[0, 0] };
-        yield return new object[]
-        {
-            new uint[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUINT_TestData))]
-    public void VARIANT_ToObject_ARRAYUINTMultiDimension_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUINT_TestData))]
-    public void VARIANT_ToObject_ARRAYUINTMultiDimensionNonZeroLowerBound_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UINT, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUINT_TestData))]
-    public void VARIANT_ToObject_UI4ArrayUINTSingleDimension_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<uint[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUINT_TestData))]
-    public void VARIANT_ToObject_UI4ArrayUINTSingleDimensionNonZeroLowerBounds_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUINT_TestData))]
-    public void VARIANT_ToObject_UI4ArrayUINTMultiDimension_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUINT_TestData))]
-    public void VARIANT_ToObject_UI4ArrayUINTMultiDimensionNonZeroLowerBound_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI4, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UINT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI8_TestData))]
-    public void VARIANT_ToObject_ARRAYI8SingleDimension_ReturnsExpected(long[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<long[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorI8_TestData))]
-    public void VARIANT_ToObject_ARRAYI8SingleDimensionNonZeroLowerBounds_ReturnsExpected(long[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I8, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(long).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionI8_TestData()
-    {
-        yield return new object[] { new long[0, 0] };
-        yield return new object[]
-        {
-            new long[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI8_TestData))]
-    public void VARIANT_ToObject_ARRAYI8MultiDimension_ReturnsExpected(long[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(long).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionI8_TestData))]
-    public void VARIANT_ToObject_ARRAYI8MultiDimensionNonZeroLowerBound_ReturnsExpected(long[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I8, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(long).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI8_TestData))]
-    public void VARIANT_ToObject_ARRAYUI8SingleDimension_ReturnsExpected(ulong[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<ulong[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorUI8_TestData))]
-    public void VARIANT_ToObject_ARRAYUI8SingleDimensionNonZeroLowerBounds_ReturnsExpected(ulong[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI8, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ulong).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionUI8_TestData()
-    {
-        yield return new object[] { new ulong[0, 0] };
-        yield return new object[]
-        {
-            new ulong[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI8_TestData))]
-    public void VARIANT_ToObject_ARRAYUI8MultiDimension_ReturnsExpected(ulong[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ulong).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionUI8_TestData))]
-    public void VARIANT_ToObject_ARRAYUI8MultiDimensionNonZeroLowerBound_ReturnsExpected(ulong[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_UI8, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_UI8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(ulong).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR4_TestData))]
-    public void VARIANT_ToObject_ARRAYR4SingleDimension_ReturnsExpected(float[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<float[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR4_TestData))]
-    public void VARIANT_ToObject_ARRAYR4SingleDimensionNonZeroLowerBounds_ReturnsExpected(float[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R4, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(float).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionR4_TestData()
-    {
-        yield return new object[] { new float[0, 0] };
-        yield return new object[]
-        {
-            new float[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionR4_TestData))]
-    public void VARIANT_ToObject_ARRAYR4MultiDimension_ReturnsExpected(float[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R4, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(float).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionR4_TestData))]
-    public void VARIANT_ToObject_ARRAYR4MultiDimensionNonZeroLowerBound_ReturnsExpected(float[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R4, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(float).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR8_TestData))]
-    public void VARIANT_ToObject_ARRAYR8SingleDimension_ReturnsExpected(double[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<double[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorR8_TestData))]
-    public void VARIANT_ToObject_ARRAYR8SingleDimensionNonZeroLowerBounds_ReturnsExpected(double[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R8, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(double).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionR8_TestData()
-    {
-        yield return new object[] { new double[0, 0] };
-        yield return new object[]
-        {
-            new double[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionR8_TestData))]
-    public void VARIANT_ToObject_ARRAYR8MultiDimension_ReturnsExpected(double[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R8, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(double).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionR8_TestData))]
-    public void VARIANT_ToObject_ARRAYR8MultiDimensionNonZeroLowerBound_ReturnsExpected(double[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_R8, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_R8,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(double).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorERROR_TestData))]
-    public void VARIANT_ToObject_ARRAYERRORSingleDimension_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_ERROR, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_ERROR,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<uint[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorERROR_TestData))]
-    public void VARIANT_ToObject_ARRAYERRORSingleDimensionNonZeroLowerBounds_ReturnsExpected(uint[] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_ERROR, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_ERROR,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionERROR_TestData()
-    {
-        yield return new object[] { new uint[0, 0] };
-        yield return new object[]
-        {
-            new uint[2, 3]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionERROR_TestData))]
-    public void VARIANT_ToObject_ARRAYERRORMultiDimension_ReturnsExpected(uint[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_ERROR, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_ERROR,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionERROR_TestData))]
-    public void VARIANT_ToObject_ARRAYERRORMultiDimensionNonZeroLowerBound_ReturnsExpected(int[,] result)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_ERROR, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_ERROR,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(uint).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(result, array);
-        });
-    }
-
-    public static IEnumerable<object[]> ArrayBOOL_TestData()
-    {
-        yield return new object[] { Array.Empty<VARIANT_BOOL>(), Array.Empty<bool>() };
-        yield return new object[] { new VARIANT_BOOL[] { VARIANT_BOOL.VARIANT_TRUE, VARIANT_BOOL.VARIANT_FALSE, VARIANT_BOOL.VARIANT_TRUE }, new bool[] { true, false, true } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ArrayBOOL_TestData))]
-    public void VARIANT_ToObject_ARRAYBOOLSingleDimension_ReturnsExpected(object result, bool[] expected)
-    {
-        VARIANT_BOOL[] boolResult = (VARIANT_BOOL[])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_BOOL, boolResult);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_BOOL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<bool[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ArrayBOOL_TestData))]
-    public void VARIANT_ToObject_ARRAYBOOLSingleDimensionNonZeroLowerBounds_ReturnsExpected(object result, bool[] expected)
-    {
-        VARIANT_BOOL[] boolResult = (VARIANT_BOOL[])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_BOOL, boolResult, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_BOOL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(bool).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionBOOL_TestData()
-    {
-        yield return new object[] { new VARIANT_BOOL[0, 0], new bool[0, 0] };
-        yield return new object[]
-        {
-            new VARIANT_BOOL[2, 3]
-            {
-                { VARIANT_BOOL.VARIANT_TRUE, VARIANT_BOOL.VARIANT_FALSE, VARIANT_BOOL.VARIANT_TRUE },
-                { VARIANT_BOOL.VARIANT_FALSE, VARIANT_BOOL.VARIANT_TRUE, VARIANT_BOOL.VARIANT_FALSE }
-            },
-            new bool[2, 3]
-            {
-                { true, false, true },
-                { false, true, false }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionBOOL_TestData))]
-    public void VARIANT_ToObject_ARRAYBOOLMultiDimension_ReturnsExpected(object result, bool[,] expected)
-    {
-        VARIANT_BOOL[,] boolResult = (VARIANT_BOOL[,])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_BOOL, boolResult);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_BOOL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(bool).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionBOOL_TestData))]
-    public void VARIANT_ToObject_ARRAYBOOLMultiDimensionNonZeroLowerBound_ReturnsExpected(object result, bool[,] expected)
-    {
-        VARIANT_BOOL[,] boolResult = (VARIANT_BOOL[,])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_BOOL, boolResult, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_BOOL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(bool).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    public static IEnumerable<object[]> ArrayDECIMAL_TestData()
-    {
-        yield return new object[] { Array.Empty<DECIMAL>(), Array.Empty<decimal>() };
-
-        VarDecFromR8(1.1, out DECIMAL d1);
-        VarDecFromR8(2.2, out DECIMAL d2);
-        VarDecFromR8(3.3, out DECIMAL d3);
-        yield return new object[] { new DECIMAL[] { d1, d2, d3 }, new decimal[] { 1.1m, 2.2m, 3.3m } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ArrayDECIMAL_TestData))]
-    public void VARIANT_ToObject_ARRAYDECIMALSingleDimension_ReturnsExpected(object result, decimal[] expected)
-    {
-        DECIMAL[] decimalResult = (DECIMAL[])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_DECIMAL, decimalResult);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DECIMAL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<decimal[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(ArrayDECIMAL_TestData))]
-    public void VARIANT_ToObject_ARRAYDECIMALSingleDimensionNonZeroLowerBounds_ReturnsExpected(object result, decimal[] expected)
-    {
-        DECIMAL[] decimalResult = (DECIMAL[])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_DECIMAL, decimalResult, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DECIMAL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionDECIMAL_TestData()
-    {
-        yield return new object[] { new DECIMAL[0, 0], new decimal[0, 0] };
-        VarDecFromR8(1.1, out DECIMAL d1);
-        VarDecFromR8(2.2, out DECIMAL d2);
-        VarDecFromR8(3.3, out DECIMAL d3);
-        VarDecFromR8(3.1, out DECIMAL d4);
-        VarDecFromR8(2.2, out DECIMAL d5);
-        VarDecFromR8(1.3, out DECIMAL d6);
-        yield return new object[]
-        {
-            new DECIMAL[2, 3]
-            {
-                { d1, d2, d3 },
-                { d4, d5, d6 }
-            },
-            new decimal[2, 3]
-            {
-                { 1.1m, 2.2m, 3.3m },
-                { 3.1m, 2.2m, 1.3m }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionDECIMAL_TestData))]
-    public void VARIANT_ToObject_ARRAYDECIMALMultiDimension_ReturnsExpected(object result, decimal[,] expected)
-    {
-        DECIMAL[,] decimalResult = (DECIMAL[,])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_DECIMAL, decimalResult);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DECIMAL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionDECIMAL_TestData))]
-    public void VARIANT_ToObject_ARRAYDECIMALMultiDimensionNonZeroLowerBound_ReturnsExpected(object result, decimal[,] expected)
-    {
-        DECIMAL[,] decimalResult = (DECIMAL[,])result;
-        SAFEARRAY* psa = CreateSafeArray(VT_DECIMAL, decimalResult, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DECIMAL,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorCY_TestData))]
-    public void VARIANT_ToObject_ARRAYCYSingleDimension_ReturnsExpected(long[] result, decimal[] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_CY, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_CY,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<decimal[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorCY_TestData))]
-    public void VARIANT_ToObject_ARRAYCYSingleDimensionNonZeroLowerBounds_ReturnsExpected(long[] result, decimal[] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_CY, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_CY,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionCY_TestData()
-    {
-        yield return new object[] { new long[0, 0], new decimal[0, 0] };
-        yield return new object[]
-        {
-            new long[2, 3]
-            {
-                { 11000, 22000, 33000 },
-                { 31000, 22000, 13000 }
-            },
-            new decimal[2, 3]
-            {
-                { 1.1m, 2.2m, 3.3m },
-                { 3.1m, 2.2m, 1.3m }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionCY_TestData))]
-    public void VARIANT_ToObject_ARRAYCYMultiDimension_ReturnsExpected(long[,] result, decimal[,] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_CY, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_CY,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionCY_TestData))]
-    public void VARIANT_ToObject_ARRAYCYMultiDimensionNonZeroLowerBound_ReturnsExpected(long[,] result, decimal[,] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_CY, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_CY,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(decimal).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorDATE_TestData))]
-    public void VARIANT_ToObject_ARRAYDATESingleDimension_ReturnsExpected(double[] result, DateTime[] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_DATE, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DATE,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<DateTime[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(VectorDATE_TestData))]
-    public void VARIANT_ToObject_ARRAYDATESingleDimensionNonZeroLowerBounds_ReturnsExpected(double[] result, DateTime[] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_DATE, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DATE,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(DateTime).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(expected.Length, array.GetLength(0));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    public static IEnumerable<object[]> MultiDimensionDATE_TestData()
-    {
-        yield return new object[] { new double[0, 0], new DateTime[0, 0] };
-
-        var d1 = new DateTime(2020, 05, 13, 13, 3, 12);
-        var d2 = new DateTime(2020, 05, 13, 13, 3, 11);
-        var d3 = new DateTime(2020, 3, 13, 13, 3, 12);
-        var d4 = new DateTime(1892, 1, 2, 3, 4, 5, 6);
-        var d5 = new DateTime(2010, 2, 3, 4, 5, 6);
-        var d6 = new DateTime(8000, 10, 11, 12, 13, 14);
-        yield return new object[]
-        {
-            new double[2, 3]
-            {
-                { d1.ToOADate(), d2.ToOADate(), d3.ToOADate() },
-                { d4.ToOADate(), d5.ToOADate(), d6.ToOADate() }
-            },
-            new DateTime[2, 3]
-            {
-                { d1, d2, d3 },
-                { d4, d5, d6 }
-            }
-        };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionDATE_TestData))]
-    public void VARIANT_ToObject_ARRAYDATEMultiDimension_ReturnsExpected(double[,] result, DateTime[,] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_DATE, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DATE,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(DateTime).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaTheory]
-    [MemberData(nameof(MultiDimensionDATE_TestData))]
-    public void VARIANT_ToObject_ARRAYDATEMultiDimensionNonZeroLowerBound_ReturnsExpected(double[,] result, DateTime[,] expected)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_DATE, result, 1, 2);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_DATE,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(DateTime).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(2, array.GetLowerBound(1));
-            Assert.Equal(expected.GetLength(0), array.GetLength(0));
-            Assert.Equal(expected.GetLength(1), array.GetLength(1));
-            Assert.Equal(expected, array);
-        });
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYBSTRSingleDimension_ReturnsExpected()
-    {
-        IntPtr ptr1 = Marshal.StringToBSTR("text");
-        IntPtr ptr2 = Marshal.StringToBSTR("");
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_BSTR, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_BSTR,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType<string[]>(array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new string[] { null, "text", "" }, array);
-            });
-        }
-        finally
-        {
-            Marshal.FreeBSTR(ptr1);
-            Marshal.FreeBSTR(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYBSTRSingleDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        IntPtr ptr1 = Marshal.StringToBSTR("text");
-        IntPtr ptr2 = Marshal.StringToBSTR("");
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_BSTR, result, 1);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_BSTR,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(string).MakeArrayType(1), array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new string[] { null, "text", "" }, array);
-            });
-        }
-        finally
-        {
-            Marshal.FreeBSTR(ptr1);
-            Marshal.FreeBSTR(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYBSTRMultiDimension_ReturnsExpected()
-    {
-        IntPtr ptr1 = Marshal.StringToBSTR("text");
-        IntPtr ptr2 = Marshal.StringToBSTR("");
-        IntPtr ptr3 = Marshal.StringToBSTR("text3");
-        IntPtr ptr4 = Marshal.StringToBSTR("text4");
-        IntPtr ptr5 = Marshal.StringToBSTR("text5");
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_BSTR, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_BSTR,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(string).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(0, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new string[,]
-                {
-                    { null, "text", "" },
-                    { "text3", "text4", "text5" }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.FreeBSTR(ptr1);
-            Marshal.FreeBSTR(ptr2);
-            Marshal.FreeBSTR(ptr3);
-            Marshal.FreeBSTR(ptr4);
-            Marshal.FreeBSTR(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYBSTRMultiDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        IntPtr ptr1 = Marshal.StringToBSTR("text");
-        IntPtr ptr2 = Marshal.StringToBSTR("");
-        IntPtr ptr3 = Marshal.StringToBSTR("text3");
-        IntPtr ptr4 = Marshal.StringToBSTR("text4");
-        IntPtr ptr5 = Marshal.StringToBSTR("text5");
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_BSTR, result, 1, 2);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_BSTR,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(string).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(2, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new string[,]
-                {
-                    { null, "text", "" },
-                    { "text3", "text4", "text5" }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.FreeBSTR(ptr1);
-            Marshal.FreeBSTR(ptr2);
-            Marshal.FreeBSTR(ptr3);
-            Marshal.FreeBSTR(ptr4);
-            Marshal.FreeBSTR(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYUNKNOWNSingleDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_UNKNOWN, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType<object[]>(array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYUNKNOWNSingleDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_UNKNOWN, result, 1);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(1), array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYUNKNOWNMultiDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_UNKNOWN, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(0, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYUNKNOWNMultiDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_UNKNOWN, result, 1, 2);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(2, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DISPATCHArrayUNKNOWNSingleDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType<object[]>(array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DISPATCHArrayUNKNOWNSingleDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result, 1);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(1), array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DISPATCHArrayUNKNOWNMultiDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(0, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_DISPATCHArrayUNKNOWNMultiDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result, 1, 2);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_UNKNOWN,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(2, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYDISPATCHSingleDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_DISPATCH,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType<object[]>(array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYDISPATCHSingleDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        try
-        {
-            var result = new IntPtr[] { IntPtr.Zero, ptr1, ptr2 };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result, 1);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_DISPATCH,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(1), array);
-                Assert.Equal(1, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(result.Length, array.GetLength(0));
-                Assert.Equal(new object[] { null, o1, o2 }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYDISPATCHMultiDimension_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_DISPATCH,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(0, array.GetLowerBound(0));
-                Assert.Equal(0, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYDISPATCHMultiDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        var o1 = new object();
-        var o2 = new object();
-        var o3 = new object();
-        var o4 = new object();
-        var o5 = new object();
-        IntPtr ptr1 = Marshal.GetIUnknownForObject(o1);
-        IntPtr ptr2 = Marshal.GetIUnknownForObject(o2);
-        IntPtr ptr3 = Marshal.GetIUnknownForObject(o3);
-        IntPtr ptr4 = Marshal.GetIUnknownForObject(o4);
-        IntPtr ptr5 = Marshal.GetIUnknownForObject(o5);
-        try
-        {
-            var result = new IntPtr[2, 3]
-            {
-                { IntPtr.Zero, ptr1, ptr2 },
-                { ptr3, ptr4, ptr5 }
-            };
-            SAFEARRAY* psa = CreateSafeArray(VT_DISPATCH, result, 1, 2);
-            using VARIANT variant = new()
-            {
-                vt = VT_ARRAY | VT_DISPATCH,
-                data = new()
-                {
-                    parray = psa
-                }
-            };
-            AssertToObject(variant, value =>
-            {
-                Array array = (Array)value;
-                Assert.IsType(typeof(object).MakeArrayType(2), array);
-                Assert.Equal(2, array.Rank);
-                Assert.Equal(1, array.GetLowerBound(0));
-                Assert.Equal(2, array.GetLowerBound(1));
-                Assert.Equal(result.GetLength(0), array.GetLength(0));
-                Assert.Equal(result.GetLength(1), array.GetLength(1));
-                Assert.Equal(new object[,]
-                {
-                    { null, o1, o2 },
-                    { o3, o4, o5 }
-                }, array);
-            });
-        }
-        finally
-        {
-            Marshal.Release(ptr1);
-            Marshal.Release(ptr2);
-            Marshal.Release(ptr3);
-            Marshal.Release(ptr4);
-            Marshal.Release(ptr5);
-        }
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYVARIANTSingleDimension_ReturnsExpected()
-    {
-        using VARIANT v1 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 1
-            }
-        };
-        using VARIANT v2 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 2
-            }
-        };
-        using VARIANT v3 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 3
-            }
-        };
-        var result = new VARIANT[] { v1, v2, v3 };
-        SAFEARRAY* psa = CreateSafeArray(VT_VARIANT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_VARIANT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType<object[]>(array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(new object[] { 1, 2, 3 }, array);
-        });
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYVARIANTSingleDimensionNonZeroLowerBound_ReturnsExpected()
-    {
-        using VARIANT v1 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 1
-            }
-        };
-        using VARIANT v2 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 2
-            }
-        };
-        using VARIANT v3 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 3
-            }
-        };
-        var result = new VARIANT[] { v1, v2, v3 };
-        SAFEARRAY* psa = CreateSafeArray(VT_VARIANT, result, 1);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_VARIANT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(object).MakeArrayType(1), array);
-            Assert.Equal(1, array.Rank);
-            Assert.Equal(1, array.GetLowerBound(0));
-            Assert.Equal(result.Length, array.GetLength(0));
-            Assert.Equal(new object[] { 1, 2, 3 }, array);
-        });
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYVARIANTMultiDimension_ReturnsExpected()
-    {
-        using VARIANT v1 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 1
-            }
-        };
-        using VARIANT v2 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 2
-            }
-        };
-        using VARIANT v3 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 3
-            }
-        };
-        using VARIANT v4 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 4
-            }
-        };
-        using VARIANT v5 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 5
-            }
-        };
-        using VARIANT v6 = new()
-        {
-            vt = VT_I4,
-            data = new()
-            {
-                llVal = 6
-            }
-        };
-
-        var result = new VARIANT[2, 3]
-        {
-            { v1, v2, v3 },
-            { v4, v5, v6 }
-        };
-        SAFEARRAY* psa = CreateSafeArray(VT_VARIANT, result);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_VARIANT,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObject(variant, value =>
-        {
-            Array array = (Array)value;
-            Assert.IsType(typeof(object).MakeArrayType(2), array);
-            Assert.Equal(2, array.Rank);
-            Assert.Equal(0, array.GetLowerBound(0));
-            Assert.Equal(0, array.GetLowerBound(1));
-            Assert.Equal(result.GetLength(0), array.GetLength(0));
-            Assert.Equal(result.GetLength(1), array.GetLength(1));
-            Assert.Equal(new object[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            }, array);
-        });
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_I1)]
-    [InlineData((ushort)VT_UI1)]
-    [InlineData((ushort)VT_I2)]
-    [InlineData((ushort)VT_UI2)]
-    [InlineData((ushort)VT_I4)]
-    [InlineData((ushort)VT_UI4)]
-    [InlineData((ushort)VT_I8)]
-    [InlineData((ushort)VT_UI8)]
-    [InlineData((ushort)VT_BSTR)]
-    [InlineData((ushort)VT_LPWSTR)]
-    [InlineData((ushort)VT_LPSTR)]
-    [InlineData((ushort)VT_UNKNOWN)]
-    [InlineData((ushort)VT_DISPATCH)]
-    [InlineData((ushort)VT_EMPTY)]
-    [InlineData((ushort)VT_NULL)]
-    [InlineData((ushort)VT_CF)]
-    [InlineData((ushort)VT_VOID)]
-    [InlineData((ushort)VT_PTR)]
-    [InlineData((ushort)VT_SAFEARRAY)]
-    [InlineData((ushort)VT_CARRAY)]
-    [InlineData((ushort)VT_RECORD)]
-    [InlineData((ushort)VT_BLOB)]
-    [InlineData((ushort)VT_STREAM)]
-    [InlineData((ushort)VT_STORAGE)]
-    [InlineData((ushort)VT_STREAMED_OBJECT)]
-    [InlineData((ushort)VT_STORED_OBJECT)]
-    [InlineData((ushort)VT_BLOB_OBJECT)]
-    public void VARIANT_ToObject_ARRAYNoData_ReturnsExpected(ushort vt)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | (VARENUM)vt
-        };
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaTheory]
-    [InlineData(128)]
-    [InlineData(129)]
-    [InlineData((ushort)VT_BSTR_BLOB)]
-    public void VARIANT_ToObject_ARRAYInvalidTypeNoData_ThrowsInvalidOleVariantTypeException(ushort vt)
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | (VARENUM)vt
-        };
-        AssertToObjectThrows<InvalidOleVariantTypeException>(variant);
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYVECTOR_ThrowsInvalidOleVariantTypeException()
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_VECTOR | VT_I4
-        };
-        Assert.Throws<ArgumentException>(() => variant.ToObject());
-    }
-
-    [StaFact]
-    public void VARIANT_ToObject_ARRAYTypeEMPTY_ThrowsInvalidOleVariantTypeException()
-    {
-        SAFEARRAY* psa = CreateSafeArray(VT_I1, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_EMPTY,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObjectThrows<InvalidOleVariantTypeException>(variant);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_I1, (ushort)VT_UI1)]
-    [InlineData((ushort)VT_UI1, (ushort)VT_I1)]
-    [InlineData((ushort)VT_I2, (ushort)VT_UI2)]
-    [InlineData((ushort)VT_UI2, (ushort)VT_I2)]
-    [InlineData((ushort)VT_I4, (ushort)VT_UI4)]
-    [InlineData((ushort)VT_UI4, (ushort)VT_I4)]
-    [InlineData((ushort)VT_INT, (ushort)VT_UINT)]
-    [InlineData((ushort)VT_INT, (ushort)VT_I2)]
-    [InlineData((ushort)VT_INT, (ushort)VT_I8)]
-    [InlineData((ushort)VT_UINT, (ushort)VT_INT)]
-    [InlineData((ushort)VT_UINT, (ushort)VT_UI2)]
-    [InlineData((ushort)VT_UINT, (ushort)VT_UI8)]
-    [InlineData((ushort)VT_I8, (ushort)VT_UI8)]
-    [InlineData((ushort)VT_UI8, (ushort)VT_I8)]
-    [InlineData((ushort)VT_UNKNOWN, (ushort)VT_DISPATCH)]
-    [InlineData((ushort)VT_UNKNOWN, (ushort)VT_I4)]
-    [InlineData((ushort)VT_UNKNOWN, (ushort)VT_UI4)]
-    [InlineData((ushort)VT_UNKNOWN, (ushort)VT_I8)]
-    [InlineData((ushort)VT_UNKNOWN, (ushort)VT_UI8)]
-    [InlineData((ushort)VT_DISPATCH, (ushort)VT_I4)]
-    [InlineData((ushort)VT_DISPATCH, (ushort)VT_UI4)]
-    [InlineData((ushort)VT_DISPATCH, (ushort)VT_I8)]
-    [InlineData((ushort)VT_DISPATCH, (ushort)VT_UI8)]
-    public void VARIANT_ToObject_ARRAYTypeDifferent_ThrowsSafeArrayTypeMismatchException(ushort arrayVt, ushort vt)
-    {
-        SAFEARRAY* psa = CreateSafeArray((VARENUM)arrayVt, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | (VARENUM)vt,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObjectThrows<SafeArrayTypeMismatchException>(variant);
-    }
-
-    [StaTheory]
-    [InlineData((ushort)VT_INT_PTR)]
-    [InlineData((ushort)VT_UINT_PTR)]
-    public void VARIANT_ToObject_ARRAYTypeInvalid_ThrowsArgumentException(ushort vt)
-    {
-        SAFEARRAY* psa = CreateSafeArray((VARENUM)vt, Array.Empty<byte>());
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | (VARENUM)vt,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    [StaTheory]
-    [InlineData(33)]
-    [InlineData(255)]
-    [InlineData(256)]
-    [InlineData(512)]
-    public void VARIANT_ARRAYBigRank_ThrowsTypeLoadException(int rank)
-    {
-        SAFEARRAYBOUND* saBounds = stackalloc SAFEARRAYBOUND[rank];
-        for (uint i = 0; i < rank; i++)
-        {
-            saBounds[i] = new SAFEARRAYBOUND
-            {
-                cElements = 0,
-                lLbound = 0
-            };
-        }
-
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(VT_I4, (uint)rank, saBounds);
-        using VARIANT variant = new()
-        {
-            vt = VT_ARRAY | VT_I4,
-            data = new()
-            {
-                parray = psa
-            }
-        };
-        AssertToObjectThrows<TypeLoadException>(variant);
-    }
-
-    private static unsafe SAFEARRAY* CreateSafeArray<T>(VARENUM vt, T[] result, int lbound = 0) where T : unmanaged
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = (uint)result.Length,
-            lLbound = lbound
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(vt, 1, &saBound);
-        Assert.True(psa != null);
-
-        VARENUM arrayVt = VT_EMPTY;
-        HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(vt, arrayVt);
-
-        for (int i = 0; i < result.Length; i++)
-        {
-            T value = result[i];
-            int index = i + lbound;
-            // Insert pointers directly.
-            if (value is IntPtr valuePtr)
-            {
-                hr = PInvoke.SafeArrayPutElement(psa, &index, (void*)valuePtr);
-            }
-            else
-            {
-                hr = PInvoke.SafeArrayPutElement(psa, &index, &value);
-            }
-
-            Assert.Equal(HRESULT.S_OK, hr);
-        }
-
-        return psa;
-    }
-
-    private unsafe SAFEARRAY* CreateSafeArray<T>(VARENUM vt, T[,] multiDimArray, int lbound1 = 0, int lbound2 = 0) where T : unmanaged
-    {
-        SAFEARRAYBOUND* saBounds = stackalloc SAFEARRAYBOUND[2];
-        saBounds[0] = new SAFEARRAYBOUND
-        {
-            cElements = (uint)multiDimArray.GetLength(0),
-            lLbound = lbound1
-        };
-        saBounds[1] = new SAFEARRAYBOUND
-        {
-            cElements = (uint)multiDimArray.GetLength(1),
-            lLbound = lbound2
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreate(vt, 2, saBounds);
-        Assert.True(psa != null);
-
-        VARENUM arrayVt = VT_EMPTY;
-        HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(vt, arrayVt);
-
-        for (int i = 0; i < multiDimArray.GetLength(0); i++)
-        {
-            for (int j = 0; j < multiDimArray.GetLength(1); j++)
-            {
-                int* indices = stackalloc int[] { i + lbound1, j + lbound2 };
-                T value = multiDimArray[i, j];
-                // Insert pointers directly.
-                if (value is IntPtr valuePtr)
-                {
-                    hr = PInvoke.SafeArrayPutElement(psa, indices, (void*)valuePtr);
-                }
-                else
-                {
-                    hr = PInvoke.SafeArrayPutElement(psa, indices, &value);
-                }
-
-                Assert.Equal(HRESULT.S_OK, hr);
-            }
-        }
-
-        return psa;
-    }
-
-    [StaFact]
-    public void ToObject_RECORDRecordData_ReturnsExpected()
-    {
-        int record = 1;
-        IntPtr mem = Marshal.AllocCoTaskMem(sizeof(int));
-        (*(int*)mem) = record;
-        CustomRecordInfo recordInfo = new()
-        {
-            GetGuidAction = () => (typeof(int).GUID, HRESULT.S_OK)
-        };
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        variant.data.Anonymous.pvRecord = mem.ToPointer();
-
-        // Records actually don't work in .NET Core...
-#if false
-        AssertToObjectEqual(1, variant);
-#else
-        AssertToObjectThrows<ArgumentException>(variant);
-#endif
-    }
-
-    [StaFact]
-    public void ToObject_RECORDNullRecordData_ReturnsNull()
-    {
-        CustomRecordInfo recordInfo = new();
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void ToObject_RECORDNullRecordInfo_ThrowsArgumentException()
-    {
-        int record = 1;
-        IntPtr mem = Marshal.AllocCoTaskMem(sizeof(int));
-        (*(int*)mem) = record;
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pvRecord = mem.ToPointer();
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    [StaFact]
-    public void ToObject_RECORDInvalidGetGuidHRData_ThrowsArgumentException()
-    {
-        int record = 1;
-        IntPtr mem = Marshal.AllocCoTaskMem(sizeof(int));
-        (*(int*)mem) = record;
-
-        CustomRecordInfo recordInfo = new()
-        {
-            GetGuidAction = () => (Guid.Empty, HRESULT.DISP_E_DIVBYZERO)
-        };
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        variant.data.Anonymous.pvRecord = mem.ToPointer();
-
-        // Records actually don't work in .NET Core...
-#if false
-        AssertToObjectThrows<DivideByZeroException>(variant);
-#endif
-    }
-
-    [StaFact]
-    public void ToObject_RECORDInvalidGetGuidHRNoData_ReturnsNull()
-    {
-        CustomRecordInfo recordInfo = new()
-        {
-            GetGuidAction = () => (Guid.Empty, HRESULT.DISP_E_DIVBYZERO)
-        };
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        AssertToObjectEqual(null, variant);
-    }
-
-    public static IEnumerable<object[]> RECORD_TestData()
-    {
-        yield return new object[] { Guid.Empty };
-        yield return new object[] { new Guid("8856f961-340a-11d0-a96b-00c04fd705a2") };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(RECORD_TestData))]
-    public void ToObject_RECORDInvalidGuidData_ThrowsArgumentException(Guid guid)
-    {
-        int record = 1;
-        IntPtr mem = Marshal.AllocCoTaskMem(sizeof(int));
-        (*(int*)mem) = record;
-
-        CustomRecordInfo recordInfo = new CustomRecordInfo
-        {
-            GetGuidAction = () => (guid, HRESULT.S_OK)
-        };
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        variant.data.Anonymous.pvRecord = mem.ToPointer();
-
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    [StaTheory]
-    [MemberData(nameof(RECORD_TestData))]
-    public void ToObject_RECORDInvalidGuidNoData_ReturnsNull(Guid guid)
-    {
-        CustomRecordInfo recordInfo = new()
-        {
-            GetGuidAction = () => (guid, HRESULT.S_OK)
-        };
-
-        using VARIANT variant = new() { vt = VT_RECORD };
-        variant.data.Anonymous.pRecInfo = recordInfo.GetComInterface();
-        AssertToObjectEqual(null, variant);
-    }
-
-    [StaFact]
-    public void ToObject_RECORDARRAYValid_ReturnsExpected()
-    {
-        var result = new int[] { 1, 2 };
-        CustomRecordInfo recordInfo = new()
-        {
-            GetGuidAction = () => (typeof(int).GUID, HRESULT.S_OK)
-        };
-
-        using ComScope<IRecordInfo> pRecordInfo = new(recordInfo.GetComInterface());
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_RECORD };
-        variant.data.parray = CreateRecordSafeArray(result, pRecordInfo);
-
-        // Records actually don't work in .NET Core...
-#if false
-        AssertToObjectEqual(new int[] { 0, 0 }, variant);
-#endif
-    }
-
-    [StaFact]
-    public void ToObject_RECORDARRAYInvalidFFeatures_ThrowsArgumentException()
-    {
-        var result = new int[] { 1, 2 };
-        CustomRecordInfo recordInfo = new();
-        using ComScope<IRecordInfo> pRecordInfo = new(recordInfo.GetComInterface());
-        SAFEARRAY* psa = CreateRecordSafeArray(result, pRecordInfo);
-        psa->fFeatures &= ~FADF_RECORD;
-        try
-        {
-            using VARIANT variant = new() { vt = VT_ARRAY | VT_RECORD };
-            variant.data.parray = psa;
-            AssertToObjectThrows<ArgumentException>(variant);
-        }
-        finally
-        {
-            // Make sure disposal works.
-            psa->fFeatures |= FADF_RECORD;
-        }
-    }
-
-    [StaFact]
-    public void ToObject_RECORDARRAYInvalidGetGuidHR_ThrowsArgumentException()
-    {
-        var result = new int[] { 1, 2 };
-        CustomRecordInfo record = new()
-        {
-            GetGuidAction = () => (Guid.Empty, HRESULT.DISP_E_DIVBYZERO)
-        };
-
-        using ComScope<IRecordInfo> pRecordInfo = new(record.GetComInterface());
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_RECORD };
-        variant.data.parray = CreateRecordSafeArray(result, pRecordInfo);
-
-        VARIANT copy = variant;
-        IntPtr pv = (IntPtr)(&copy);
-        Assert.Throws<ArgumentException>(() => Marshal.GetObjectForNativeVariant(pv));
-        Assert.Throws<ArgumentException>(() => variant.ToObject());
-    }
-
-    public static IEnumerable<object[]> RECORDARRAY_InvalidGuid_TestData()
-    {
-        yield return new object[] { Guid.Empty };
-        yield return new object[] { new Guid("8856f961-340a-11d0-a96b-00c04fd705a2") };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(RECORDARRAY_InvalidGuid_TestData))]
-    public void ToObject_RECORDARRAY_InvokeInvalidGuid_ThrowsArgumentException(Guid guid)
-    {
-        var result = new int[] { 1, 2 };
-        CustomRecordInfo record = new()
-        {
-            GetGuidAction = () => (guid, HRESULT.S_OK)
-        };
-
-        using ComScope<IRecordInfo> pRecordInfo = new(record.GetComInterface());
-        using VARIANT variant = new() { vt = VT_ARRAY | VT_RECORD };
-        variant.data.parray = CreateRecordSafeArray(result, pRecordInfo);
-        AssertToObjectThrows<ArgumentException>(variant);
-    }
-
-    private class CustomRecordInfo : IRecordInfo.Interface
-    {
-        public IRecordInfo* GetComInterface() => (IRecordInfo*)Marshal.GetComInterfaceForObject<CustomRecordInfo, IRecordInfo.Interface>(this);
-
-        public HRESULT RecordInit(void* pvNew) => throw new NotImplementedException();
-
-        public HRESULT RecordClear(void* pvExisting) => throw new NotImplementedException();
-
-        public HRESULT RecordCopy(void* pvExisting, void* pvNew) => throw new NotImplementedException();
-
-        public Func<(Guid, HRESULT)> GetGuidAction { get; set; }
-
-        public HRESULT GetGuid(Guid* pguid)
-        {
-            (Guid guid, HRESULT hr) = GetGuidAction();
-            *pguid = guid;
-            return hr;
-        }
-
-        public HRESULT GetName(BSTR* pbstrName) => throw new NotImplementedException();
-
-        public HRESULT GetSize(uint* pcbSize)
-        {
-            *pcbSize = (uint)sizeof(int);
-            return HRESULT.S_OK;
-        }
-
-        public HRESULT GetTypeInfo(ITypeInfo** ppTypeInfo) => throw new NotImplementedException();
-
-        public HRESULT GetField(void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT GetFieldNoCopy(void* pvData, PCWSTR szFieldName, VARIANT* pvarField, void** ppvDataCArray) => throw new NotImplementedException();
-
-        public HRESULT PutField(uint wFlags, void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT PutFieldNoCopy(uint wFlags, void* pvData, PCWSTR szFieldName, VARIANT* pvarField) => throw new NotImplementedException();
-
-        public HRESULT GetFieldNames(uint* pcNames, BSTR* rgBstrNames) => throw new NotImplementedException();
-
-        public BOOL IsMatchingType(IRecordInfo* pRecordInfoInfo) => throw new NotImplementedException();
-
-        public void* RecordCreate() => throw new NotImplementedException();
-
-        public HRESULT RecordCreateCopy(void* pvSource, void** ppvDest) => throw new NotImplementedException();
-
-        public HRESULT RecordDestroy(void* pvRecord) => throw new NotImplementedException();
-    }
-
-    private static SAFEARRAY* CreateRecordSafeArray<T>(T[] result, IRecordInfo* recordInfo, int lbound = 0)
-    {
-        var saBound = new SAFEARRAYBOUND
-        {
-            cElements = (uint)result.Length,
-            lLbound = lbound
-        };
-        SAFEARRAY* psa = PInvoke.SafeArrayCreateEx(VT_RECORD, 1, &saBound, recordInfo);
-        Assert.True(psa != null);
-
-        VARENUM arrayVt = VT_EMPTY;
-        HRESULT hr = PInvoke.SafeArrayGetVartype(psa, &arrayVt);
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(VT_RECORD, arrayVt);
-
-        return psa;
-    }
-
-    private static void AssertToObjectThrows<T>(VARIANT variant) where T : Exception
-    {
-        VARIANT copy = variant;
-        IntPtr pv = (IntPtr)(&copy);
-        Assert.Throws<T>(() => Marshal.GetObjectForNativeVariant(pv));
-
-        Assert.Throws<T>(() => variant.ToObject());
-    }
-
-    private static void AssertToObjectEqual(object expected, VARIANT variant)
-        => AssertToObject(variant, actual => Assert.Equal(expected, actual));
-
-    private static void AssertToObjectEqualExtension<T>(object expected, VARIANT variant) where T : Exception
-    {
-        // Not supported type.
-        VARIANT copy = variant;
-        IntPtr pv = (IntPtr)(&copy);
-        Assert.Throws<T>(() => Marshal.GetObjectForNativeVariant(pv));
-
-        Assert.Equal(expected, variant.ToObject());
-    }
-
-    private static void AssertToObject(VARIANT variant, Action<object> action)
-    {
-        IntPtr pv = (IntPtr)(&variant);
-        action(Marshal.GetObjectForNativeVariant(pv));
-
-        action(variant.ToObject());
-    }
-
-    [Fact]
-    public void MarshallingFromExchangeTypes()
-    {
-        // These are the common TypeConverter types we're using.
-
-        using (VARIANT variant = new())
-        {
-            byte[] bytes = { 1, 2, 3 };
-            Marshal.GetNativeVariantForObject(bytes, (nint)(void*)&variant);
-            Assert.Equal(VT_UI1 | VT_ARRAY, variant.vt);
-        }
-
-        using (VARIANT variant = new())
-        {
-            string value = "Testing";
-            Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);
-            Assert.Equal(VT_BSTR, variant.vt);
-        }
-    }
-
-    [Fact]
-    public void MarshallingFromIntAndUint()
-    {
-        // Interop marshals as VT_I4/VT_UI4 and not VT_INT/VT_UINT
-        VARIANT variant = new();
-        int intValue = 42;
-        Marshal.GetNativeVariantForObject(intValue, (nint)(void*)&variant);
-        variant.vt.Should().Be(VT_I4);
-        uint uintValue = 42;
-        Marshal.GetNativeVariantForObject(uintValue, (nint)(void*)&variant);
-        variant.vt.Should().Be(VT_UI4);
-    }
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromCLSID(Guid* clsid, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromFileTime(PInvoke.FILETIME* pftIn, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitVariantFromFileTime(PInvoke.FILETIME* pftIn, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromBuffer(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromInt16Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromUInt16Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromBooleanVector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromInt32Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromUInt32Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromInt64Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromUInt64Vector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromDoubleVector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Propsys, ExactSpelling = true)]
-    private static extern unsafe HRESULT InitPropVariantFromFileTimeVector(void* pv, uint cb, VARIANT* ppropvar);
-
-    [DllImport(Libraries.Oleaut32, ExactSpelling = true)]
-    private static extern HRESULT VarDecFromI8(long i64In, out DECIMAL pdecOut);
-
-    [DllImport(Libraries.Oleaut32, ExactSpelling = true)]
-    private static extern HRESULT VarDecFromR8(double dblIn, out DECIMAL pdecOut);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/PARAMTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/PARAMTests.cs
deleted file mode 100644
index a9a2924539c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/PARAMTests.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop;
-
-public class PARAMTests
-{
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void FromLowHigh_x32_Result()
-    {
-        Assert.Equal((int)0x03040102, (int)PARAM.FromLowHigh(0x0102, 0x0304));
-        Assert.Equal(unchecked((int)0xF3F4F1F2), (int)PARAM.FromLowHigh(0xF1F2, 0xF3F4));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void FromLowHigh_x64_Result()
-    {
-        Assert.Equal((long)0x0000000003040102, (long)PARAM.FromLowHigh(0x0102, 0x0304));
-        Assert.Equal(unchecked((long)0xFFFFFFFFF3F4F1F2), (long)PARAM.FromLowHigh(0xF1F2, 0xF3F4));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void FromLowHighUnsigned_x32_Result()
-    {
-        Assert.Equal((int)0x03040102, (int)PARAM.FromLowHighUnsigned(0x0102, 0x0304));
-        Assert.Equal(unchecked((int)0xF3F4F1F2), (int)PARAM.FromLowHighUnsigned(0xF1F2, 0xF3F4));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void FromLowHighUnsigned_x64_Result()
-    {
-        if (Environment.Is64BitProcess)
-        {
-            Assert.Equal((long)0x0000000003040102, (long)PARAM.FromLowHighUnsigned(0x0102, 0x0304));
-            Assert.Equal((long)0x00000000F3F4F1F2, (long)PARAM.FromLowHighUnsigned(0xF1F2, 0xF3F4));
-        }
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void LOWORD_x32_Result()
-    {
-        Assert.Equal(0x0304, PARAM.LOWORD((nint)0x01020304));
-        Assert.Equal(0xF3F4, PARAM.LOWORD(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void LOWORD_x64_Result()
-    {
-        Assert.Equal(0x0304, PARAM.LOWORD(unchecked((nint)0x0506070801020304)));
-        Assert.Equal(0xF3F4, PARAM.LOWORD(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void HIWORD_x32_Result()
-    {
-        Assert.Equal(0x0102, PARAM.HIWORD((nint)0x01020304));
-        Assert.Equal(0xF1F2, PARAM.HIWORD(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void HIWORD_x64_Result()
-    {
-        Assert.Equal(0x0102, PARAM.HIWORD(unchecked((nint)0x0506070801020304)));
-        Assert.Equal(0xF1F2, PARAM.HIWORD(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void SignedLOWORD_x32_Result()
-    {
-        Assert.Equal((short)0x0304, PARAM.SignedLOWORD((nint)0x01020304));
-        Assert.Equal(unchecked((short)0xF3F4), PARAM.SignedLOWORD(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void SignedLOWORD_x64_Result()
-    {
-        Assert.Equal((short)0x0304, PARAM.SignedLOWORD(unchecked((nint)0x0506070801020304)));
-        Assert.Equal(unchecked((short)0xF3F4), PARAM.SignedLOWORD(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void SignedHIWORD_x32_Result()
-    {
-        Assert.Equal((short)0x0102, PARAM.SignedHIWORD((nint)0x01020304));
-        Assert.Equal(unchecked((short)0xF1F2), PARAM.SignedHIWORD(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void SignedHIWORD_x64_Result()
-    {
-        Assert.Equal((short)0x0102, PARAM.SignedHIWORD(unchecked((nint)0x0506070801020304)));
-        Assert.Equal(unchecked((short)0xF1F2), PARAM.SignedHIWORD(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void ToInt_x32_Result()
-    {
-        Assert.Equal((int)0x01020304, PARAM.ToInt((nint)0x01020304));
-        Assert.Equal(unchecked((int)0xF1F2F3F4), PARAM.ToInt(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void ToInt_x64_Result()
-    {
-        Assert.Equal((int)0x01020304, PARAM.ToInt(unchecked((nint)0x0506070801020304)));
-        Assert.Equal(unchecked((int)0xF1F2F3F4), PARAM.ToInt(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is32bit))]
-    public unsafe void ToUInt_x32_Result()
-    {
-        Assert.Equal((uint)0x01020304, PARAM.ToUInt((nint)0x01020304));
-        Assert.Equal((uint)0xF1F2F3F4, PARAM.ToUInt(unchecked((nint)0xF1F2F3F4)));
-    }
-
-    [ConditionalFact(typeof(ArchitectureDetection), nameof(ArchitectureDetection.Is64bit))]
-    public unsafe void ToUInt_x64_Result()
-    {
-        Assert.Equal((uint)0x01020304, PARAM.ToUInt(unchecked((nint)0x0506070801020304)));
-        Assert.Equal((uint)0xF1F2F3F4, PARAM.ToUInt(unchecked((nint)0xF5F6F7F8F1F2F3F4)));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/CHARFORMAT2WTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/CHARFORMAT2WTests.cs
deleted file mode 100644
index 96b70a5fb31..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/CHARFORMAT2WTests.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.Richedit;
-
-namespace System.Windows.Forms.Tests.Interop.Richedit;
-
-// NB: doesn't require thread affinity
-public class CHARFORMAT2WTests
-{
-    [Fact]
-    public unsafe void CharFormat_Size()
-    {
-        Assert.Equal(116, sizeof(CHARFORMAT2W));
-    }
-
-    [Fact]
-    public unsafe void CharFormat_FaceName()
-    {
-        CHARFORMAT2W charFormat = default;
-        charFormat.FaceName = "TwoFace";
-        Assert.Equal("TwoFace", charFormat.FaceName.ToString());
-
-        // Set a smaller name to make sure it gets terminated properly.
-        charFormat.FaceName = "Face";
-        Assert.Equal("Face", charFormat.FaceName.ToString());
-
-        // CHARFORMAT has space for 32 characters, we want to see it gets
-        // cut to 31 to make room for the null.
-        string bigString = new('*', 32);
-
-        charFormat.FaceName = bigString;
-        Assert.True(charFormat.FaceName.SequenceEqual(bigString.AsSpan().Slice(1)));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/EDITSTREAMTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/EDITSTREAMTests.cs
deleted file mode 100644
index cbf0783375e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Richedit/EDITSTREAMTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.Richedit;
-
-namespace System.Windows.Forms.Tests.Interop.Richedit;
-
-public class EDITSTREAMTests
-{
-    [Fact]
-    public unsafe void EditStream_Size_Get_ReturnsExpected()
-    {
-        if (IntPtr.Size == 4)
-        {
-            Assert.Equal(12, sizeof(EDITSTREAM));
-        }
-        else
-        {
-            Assert.Equal(20, sizeof(EDITSTREAM));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Shell32/ShellItemTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Shell32/ShellItemTests.cs
deleted file mode 100644
index b928c0d1c86..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/Shell32/ShellItemTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.UI.Shell.Common;
-
-namespace System.Windows.Forms.Tests.Interop.Shell32Tests;
-
-public class ShellItemTests
-{
-    [Fact]
-    public unsafe void SHParseDisplayName_ValidPath()
-    {
-        string path = Path.GetTempPath();
-        uint rgflnOut = default;
-        HRESULT result = PInvoke.SHParseDisplayName(path, pbc: null, out ITEMIDLIST* ppidl, 0, &rgflnOut);
-        try
-        {
-            Assert.Equal(HRESULT.S_OK, result);
-            Assert.NotEqual(0, (nint)ppidl);
-        }
-        finally
-        {
-            if (ppidl is not null)
-            {
-                Marshal.FreeCoTaskMem((nint)ppidl);
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/GetWindowTextTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/GetWindowTextTests.cs
deleted file mode 100644
index 52452706fef..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/GetWindowTextTests.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.User32;
-
-public class GetWindowTextTests
-{
-    [StaFact]
-    public void GetWindowText_DoesNotTruncateText()
-    {
-        CallGetWindowText(useBeforeGetTextLengthCallback: false);
-    }
-
-    [StaFact]
-    public void GetWindowText_DoesNotLoopInfinitely()
-    {
-        CallGetWindowText(useBeforeGetTextLengthCallback: true);
-    }
-
-    private void CallGetWindowText(bool useBeforeGetTextLengthCallback)
-    {
-        const string shortText = "A";
-
-        // Use a long string that exceeds the initial buffer size (16).
-        string longText = new('X', 50);
-
-        var windowClass = new ChangeWindowTextClass();
-        windowClass.Register();
-        HWND windowHandle = (HWND)windowClass.CreateWindow(shortText);
-
-        windowClass.BeforeGetTextCallback = () => longText;
-        if (useBeforeGetTextLengthCallback)
-        {
-            windowClass.BeforeGetTextLengthCallback = () => shortText;
-        }
-
-        string result = PInvoke.GetWindowText(windowHandle);
-        PInvoke.DestroyWindow(windowHandle);
-
-        Assert.Equal(longText, result);
-    }
-
-    private class ChangeWindowTextClass : WindowClass
-    {
-        public Func<string>? BeforeGetTextLengthCallback
-        {
-            get;
-            set;
-        }
-
-        public Func<string>? BeforeGetTextCallback
-        {
-            get;
-            set;
-        }
-
-        protected override LRESULT WNDPROC(HWND hWnd, MessageId msg, WPARAM wParam, LPARAM lParam)
-        {
-            switch (msg)
-            {
-                case PInvoke.WM_GETTEXTLENGTH:
-                    string? text = BeforeGetTextLengthCallback?.Invoke();
-                    if (text is not null)
-                    {
-                        PInvoke.SetWindowText(hWnd, text);
-                    }
-
-                    break;
-                case PInvoke.WM_GETTEXT:
-                    text = BeforeGetTextCallback?.Invoke();
-                    if (text is not null)
-                    {
-                        PInvoke.SetWindowText(hWnd, text);
-                    }
-
-                    break;
-            }
-
-            return base.WNDPROC(hWnd, msg, wParam, lParam);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/LOGFONTWTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/LOGFONTWTests.cs
deleted file mode 100644
index cb3dc932d32..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/LOGFONTWTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.User32;
-
-public class LOGFONTWTests
-{
-    [Fact]
-    public unsafe void LogFont_Size()
-    {
-        Assert.Equal(92, sizeof(LOGFONTW));
-    }
-
-    [Fact]
-    public unsafe void LogFont_FaceName()
-    {
-        LOGFONTW logFont = default;
-        logFont.FaceName = "TwoFace";
-        Assert.Equal("TwoFace", logFont.FaceName.ToString());
-
-        // Set a smaller name to make sure it gets terminated properly.
-        logFont.FaceName = "Face";
-        Assert.Equal("Face", logFont.FaceName.ToString());
-
-        // LOGFONT has space for 32 characters, we want to see it gets
-        // cut to 31 to make room for the null.
-        string bigString = new('*', 32);
-
-        logFont.FaceName = bigString;
-        Assert.True(logFont.FaceName.SequenceEqual(bigString.AsSpan().Slice(1)));
-    }
-
-    [Fact]
-    public unsafe void CreateFontIndirect()
-    {
-        LOGFONTW logFont = default;
-        HFONT handle = PInvoke.CreateFontIndirect(&logFont);
-        Assert.False(handle.IsNull);
-        Assert.True(PInvoke.DeleteObject(handle));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/SystemParametersInfoWTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/SystemParametersInfoWTests.cs
deleted file mode 100644
index 2e06516a80c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Interop/User32/SystemParametersInfoWTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Primitives.Tests.Interop.User32;
-
-public class SystemParametersInfoWTests
-{
-    [Fact]
-    public void SystemParametersInfoW_check_fonts()
-    {
-        NONCLIENTMETRICSW data = default;
-
-        bool result = PInvoke.SystemParametersInfo(ref data);
-        Assert.True(result);
-
-        Font captionFont = Font.FromLogFont(data.lfCaptionFont);
-        AreEqual(SystemFonts.CaptionFont!, captionFont);
-
-        Font menuFont = Font.FromLogFont(data.lfMenuFont);
-        AreEqual(SystemFonts.CaptionFont!, menuFont);
-
-        Font messageFont = Font.FromLogFont(data.lfMessageFont);
-        AreEqual(SystemFonts.MessageBoxFont!, messageFont);
-
-        Font smCaptionFont = Font.FromLogFont(data.lfSmCaptionFont);
-        AreEqual(SystemFonts.SmallCaptionFont!, smCaptionFont);
-
-        Font statusFont = Font.FromLogFont(data.lfStatusFont);
-        AreEqual(SystemFonts.StatusFont!, statusFont);
-
-        static void AreEqual(Font expected, Font actual)
-        {
-            Assert.Equal(expected.Name, actual.Name);
-            Assert.Equal(expected.SizeInPoints, actual.SizeInPoints);
-            Assert.Equal(expected.GdiCharSet, actual.GdiCharSet);
-            Assert.Equal(expected.Style, actual.Style);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Properties/launchSettings.json b/src/System.Windows.Forms.Primitives/tests/UnitTests/Properties/launchSettings.json
deleted file mode 100644
index 0fc24c85f30..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Properties/launchSettings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "System.Windows.Forms.Primitives.Tests": {
-      "commandName": "Project",
-      "nativeDebugging": true
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System.Windows.Forms.Primitives.Tests.csproj b/src/System.Windows.Forms.Primitives/tests/UnitTests/System.Windows.Forms.Primitives.Tests.csproj
deleted file mode 100644
index 404fa8ed4f8..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System.Windows.Forms.Primitives.Tests.csproj
+++ /dev/null
@@ -1,25 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <AssemblyName>System.Windows.Forms.Primitives.Tests</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <NoWarn>$(NoWarn);618</NoWarn>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-    <Nullable>enable</Nullable>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="$(FluentAssertionsVersion)" />
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/BufferScopeTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/BufferScopeTests.cs
deleted file mode 100644
index 8b7311c019a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/BufferScopeTests.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Tests;
-
-public unsafe class BufferScopeTests
-{
-    [Fact]
-    public void Construct_WithStackAlloc()
-    {
-        using BufferScope<char> buffer = new(stackalloc char[10]);
-        Assert.Equal(10, buffer.Length);
-        buffer[0] = 'Y';
-        Assert.Equal("Y", buffer[..1].ToString());
-    }
-
-    [Fact]
-    public void Construct_WithStackAlloc_GrowAndCopy()
-    {
-        using BufferScope<char> buffer = new(stackalloc char[10]);
-        Assert.Equal(10, buffer.Length);
-        buffer[0] = 'Y';
-        buffer.EnsureCapacity(64, copy: true);
-        Assert.True(buffer.Length >= 64);
-        Assert.Equal("Y", buffer[..1].ToString());
-    }
-
-    [Fact]
-    public void Construct_WithStackAlloc_Pin()
-    {
-        using BufferScope<char> buffer = new(stackalloc char[10]);
-        Assert.Equal(10, buffer.Length);
-        buffer[0] = 'Y';
-        fixed (char* c = buffer)
-        {
-            Assert.Equal('Y', *c);
-            *c = 'Z';
-        }
-
-        Assert.Equal("Z", buffer[..1].ToString());
-    }
-
-    [Fact]
-    public void Construct_GrowAndCopy()
-    {
-        using BufferScope<char> buffer = new(32);
-        Assert.True(buffer.Length >= 32);
-        buffer[0] = 'Y';
-        buffer.EnsureCapacity(64, copy: true);
-        Assert.True(buffer.Length >= 64);
-        Assert.Equal("Y", buffer[..1].ToString());
-    }
-
-    [Fact]
-    public void Construct_Pin()
-    {
-        using BufferScope<char> buffer = new(64);
-        Assert.True(buffer.Length >= 64);
-        buffer[0] = 'Y';
-        fixed (char* c = buffer)
-        {
-            Assert.Equal('Y', *c);
-            *c = 'Z';
-        }
-
-        Assert.Equal("Z", buffer[..1].ToString());
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/TestAccessors.UiaTextRangeTestAccessor.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/TestAccessors.UiaTextRangeTestAccessor.cs
deleted file mode 100644
index 770a1742f73..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/TestAccessors.UiaTextRangeTestAccessor.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Automation;
-
-namespace System;
-
-public static partial class TestAccessors
-{
-    internal class UiaTextRangeTestAccessor : TestAccessor<UiaTextRange>
-    {
-        // Accessor for static members
-        private static readonly dynamic Static = typeof(UiaTextRange).TestAccessor().Dynamic;
-
-        public UiaTextRangeTestAccessor(UiaTextRange instance)
-            : base(instance) { }
-
-        public int _start
-        {
-            get => Dynamic._start;
-            set => Dynamic._start = value;
-        }
-
-        public int _end
-        {
-            get => Dynamic._end;
-            set => Dynamic._end = value;
-        }
-
-        public UiaTextProvider _provider => Dynamic._provider;
-
-        public CapStyle GetCapStyle(WINDOW_STYLE windowStyle) => Dynamic.GetCapStyle(windowStyle);
-
-        public double GetFontSize(LOGFONTW logfont) => Dynamic.GetFontSize(logfont);
-
-        public HorizontalTextAlignment GetHorizontalTextAlignment(WINDOW_STYLE windowStyle)
-            => Dynamic.GetHorizontalTextAlignment(windowStyle);
-
-        public bool GetReadOnly() => Dynamic.GetReadOnly();
-
-        public void MoveTo(int start, int end) => Dynamic.MoveTo(start, end);
-
-        public void ValidateEndpoints() => Dynamic.ValidateEndpoints();
-
-        public bool AtParagraphBoundary(string text, int index) => Static.AtParagraphBoundary(text, index);
-
-        public bool AtWordBoundary(string text, int index) => Static.AtWordBoundary(text, index);
-
-        public COLORREF GetBackgroundColor() => Static.GetBackgroundColor();
-
-        public string GetFontName(LOGFONTW logfont) => Static.GetFontName(logfont);
-
-        public bool IsApostrophe(char ch) => Static.IsApostrophe(ch);
-
-        public FW GetFontWeight(LOGFONTW logfont) => Static.GetFontWeight(logfont);
-
-        public COLORREF GetForegroundColor() => Static.GetForegroundColor();
-
-        public bool GetItalic(LOGFONTW logfont) => Static.GetItalic(logfont);
-
-        public TextDecorationLineStyle GetStrikethroughStyle(LOGFONTW logfont) => Static.GetStrikethroughStyle(logfont);
-
-        public TextDecorationLineStyle GetUnderlineStyle(LOGFONTW logfont) => Static.GetUnderlineStyle(logfont);
-    }
-
-    internal static UiaTextRangeTestAccessor TestAccessor(this UiaTextRange textRange)
-        => new(textRange);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextProviderTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextProviderTests.cs
deleted file mode 100644
index b0a9e7296a1..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextProviderTests.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using Moq;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-
-namespace System.Windows.Forms.Primitives.Tests.Automation;
-
-public class UiaTextProviderTests
-{
-    [StaFact]
-    public void UiaTextProvider_GetEditStyle_ContainsMultilineStyle_ForMultilineTextBox()
-    {
-        // EditControl Multiline is true when EditControl has ES_MULTILINE style
-        using EditControl textBox = new EditControl(
-            style: WINDOW_STYLE.WS_OVERLAPPED
-                | WINDOW_STYLE.WS_VISIBLE
-                | (WINDOW_STYLE)(PInvoke.ES_MULTILINE | PInvoke.ES_LEFT | PInvoke.ES_AUTOHSCROLL | PInvoke.ES_AUTOVSCROLL));
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        WINDOW_STYLE actual = UiaTextProvider.GetWindowStyle(textBox);
-        Assert.True(((int)actual & PInvoke.ES_MULTILINE) != 0);
-    }
-
-    [StaFact]
-    public void UiaTextProvider_GetEditStyle_DoesntContainMultilineStyle_ForSinglelineTextBox()
-    {
-        // EditControl Multiline is false when EditControl doesn't have ES_MULTILINE style
-        using EditControl textBox = new EditControl(
-            style: WINDOW_STYLE.WS_OVERLAPPED
-                | WINDOW_STYLE.WS_VISIBLE
-                | (WINDOW_STYLE)(PInvoke.ES_LEFT | PInvoke.ES_AUTOHSCROLL | PInvoke.ES_AUTOVSCROLL));
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        WINDOW_STYLE actual = UiaTextProvider.GetWindowStyle(textBox);
-        Assert.False(((int)actual & PInvoke.ES_MULTILINE) != 0);
-    }
-
-    [StaFact]
-    public void UiaTextProvider_GetWindowStyle_ContainsVisible()
-    {
-        using EditControl textBox = new EditControl(
-            style: WINDOW_STYLE.WS_OVERLAPPED
-                | WINDOW_STYLE.WS_VISIBLE
-                | (WINDOW_STYLE)(PInvoke.ES_MULTILINE | PInvoke.ES_LEFT | PInvoke.ES_AUTOHSCROLL | PInvoke.ES_AUTOVSCROLL));
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        WINDOW_STYLE actual = UiaTextProvider.GetWindowStyle(textBox);
-        Assert.True(actual.HasFlag(WINDOW_STYLE.WS_VISIBLE));
-    }
-
-    [StaFact]
-    public void UiaTextProvider_GetWindowExStyle_ContainsClientedge()
-    {
-        using EditControl textBox = new EditControl(
-            style: WINDOW_STYLE.WS_OVERLAPPED | WINDOW_STYLE.WS_VISIBLE);
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        WINDOW_EX_STYLE actual = UiaTextProvider.GetWindowExStyle(textBox);
-        Assert.True(actual.HasFlag(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE));
-    }
-
-    [StaFact]
-    public void UiaTextProvider_RectArrayToDoubleArray_ReturnsCorrectValue()
-    {
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        double[] expected = { 0, 0, 10, 5, 10, 10, 20, 30 };
-        double[] actual = UiaTextProvider.RectListToDoubleArray(new List<Rectangle>
-        {
-            new Rectangle(0, 0, 10, 5),
-            new Rectangle(10, 10, 20, 30)
-        });
-
-        Assert.Equal(8, actual.Length);
-
-        for (int i = 0; i < expected.Length; i++)
-        {
-            Assert.Equal(expected[i], actual[i]);
-        }
-    }
-
-#pragma warning disable CS8625 // RectArrayToDoubleArray doesn't accept a null parameter
-    [StaFact]
-    public void UiaTextProvider_RectArrayToDoubleArray_NullParameter_ReturnsNull()
-    {
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        double[] actual = UiaTextProvider.RectListToDoubleArray(null);
-        Assert.Empty(actual);
-    }
-#pragma warning restore CS8625
-
-    [StaFact]
-    public void UiaTextProvider_RectArrayToDoubleArray_EmptyArrayParameter_ReturnsEmptyArrayResult()
-    {
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        double[] actual = UiaTextProvider.RectListToDoubleArray(new List<Rectangle>());
-        Assert.Empty(actual);
-    }
-
-    [StaFact]
-    public unsafe void UiaTextProvider_SendInput_SendsOneInput()
-    {
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        INPUT keyboardInput = new INPUT();
-
-        int actual = providerMock.Object.SendInput(1, ref keyboardInput, sizeof(INPUT));
-        Assert.Equal(1, actual);
-    }
-
-    [StaFact]
-    public void UiaTextProvider_SendKeyboardInputVK_SendsOneInput()
-    {
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-
-        int actual = providerMock.Object.SendKeyboardInputVK(VIRTUAL_KEY.VK_LEFT, true);
-        Assert.Equal(1, actual);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextRangeTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextRangeTests.cs
deleted file mode 100644
index b2373a2b2c4..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Automation/UiaTextRangeTests.cs
+++ /dev/null
@@ -1,1215 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.Automation;
-using Moq;
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Primitives.Tests.Automation;
-
-public class UiaTextRangeTests
-{
-    // Used to get access to the test accessor for static members
-    private const UiaTextRange StaticNullTextRange = null!;
-
-    [StaTheory]
-    [InlineData(0, 0)]
-    [InlineData(0, 5)]
-    [InlineData(5, 10)]
-    [InlineData(1, 1)]
-    public void UiaTextRange_Constructor_InitializesProvider_And_CorrectEndpoints(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        Assert.Equal(start, textRange.Start);
-        Assert.Equal(end, textRange.End);
-        Assert.Equal(enclosingElement, ((ITextRangeProvider)textRange).GetEnclosingElement());
-
-        object actual = textRange.TestAccessor()._provider;
-
-        Assert.Equal(provider, actual);
-    }
-
-    [StaTheory]
-    [InlineData(-10, 0, 0, 0)]
-    [InlineData(0, -10, 0, 0)]
-    [InlineData(5, 0, 5, 5)]
-    [InlineData(-1, -1, 0, 0)]
-    [InlineData(10, 5, 10, 10)]
-    [InlineData(-5, 5, 0, 5)]
-    [InlineData(5, -5, 5, 5)]
-    public void UiaTextRange_Constructor_InitializesProvider_And_CorrectEndpoints_IfEndpointsincorrect(int start, int end, int expectedStart, int expectedEnd)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        Assert.Equal(expectedStart, textRange.Start);
-        Assert.Equal(expectedEnd, textRange.End);
-    }
-
-#pragma warning disable CS8625 // UiaTextRange constructor doesn't accept a provider null parameter
-    [StaFact]
-    public void UiaTextRange_Constructor_Provider_Null_ThrowsException()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Assert.Throws<ArgumentNullException>(() => new UiaTextRange(enclosingElement, null, 0, 5));
-    }
-#pragma warning restore CS8625
-
-#pragma warning disable CS8625 // UiaTextRange constructor doesn't accept an enclosingElement null parameter
-    [StaFact]
-    public void UiaTextRange_Constructor_Control_Null_ThrowsException()
-    {
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        Assert.Throws<ArgumentNullException>(() => new UiaTextRange(null, provider, 0, 5));
-    }
-#pragma warning restore CS8625
-
-    [StaTheory]
-    [InlineData(3, -5)]
-    [InlineData(-5, 3)]
-    [InlineData(-3, -5)]
-    public void UiaTextRange_Constructor_SetCorrectValues_IfNegativeStartEnd(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        Assert.True(textRange.Start >= 0);
-        Assert.True(textRange.End >= 0);
-    }
-
-    [StaTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(int.MaxValue)]
-    public void UiaTextRange_End_Get_ReturnsCorrectValue(int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end);
-        Assert.Equal(end, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(int.MaxValue)]
-    public void UiaTextRange_End_SetCorrectly(int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        textRange.End = end;
-        int actual = textRange.End < textRange.Start ? textRange.Start : textRange.End;
-        Assert.Equal(end, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_End_SetCorrect_IfValueIncorrect()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 5, end: 10);
-        textRange.End = 3;  /*Incorrect value*/
-        Assert.Equal(textRange.Start, textRange.End);
-
-        textRange.End = 6;
-        Assert.Equal(6, textRange.End);
-
-        textRange.End = -10; /*Incorrect value*/
-        Assert.Equal(textRange.Start, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(0, 0, 0)]
-    [InlineData(5, 5, 0)]
-    [InlineData(3, 15, 12)]
-    [InlineData(0, 10, 10)]
-    [InlineData(6, 10, 4)]
-    public void UiaTextRange_Length_ReturnsCorrectValue(int start, int end, int expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        Assert.Equal(expected, textRange.Length);
-    }
-
-    [StaTheory]
-    [InlineData(-5, 0)]
-    [InlineData(0, -5)]
-    [InlineData(-5, -5)]
-    [InlineData(10, 5)]
-    public void UiaTextRange_Length_ReturnsCorrectValue_IfIncorrectStartEnd(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 3, 10);
-
-        var testAccessor = textRange.TestAccessor();
-        testAccessor._start = start;
-        testAccessor._end = end;
-
-        Assert.Equal(0, textRange.Length);
-    }
-
-    [StaTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(int.MaxValue)]
-    public void UiaTextRange_Start_Get_ReturnsCorrectValue(int start)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-
-        textRange.TestAccessor()._start = start;
-
-        Assert.Equal(start, textRange.Start);
-    }
-
-    [StaTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(int.MaxValue)]
-    public void UiaTextRange_Start_SetCorrectly(int start)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        textRange.Start = start;
-        int actual = textRange.Start < textRange.End ? textRange.End : textRange.Start;
-        Assert.Equal(start, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_Start_Set_Correct_IfValueIncorrect()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 4, end: 8);
-        textRange.Start = -10;
-        Assert.Equal(0, textRange.Start);
-        Assert.Equal(8, textRange.End);
-    }
-
-    [StaFact]
-    public void UiaTextRange_Start_Set_Correct_IfValueMoreThanEnd()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 4, end: 10);
-        textRange.Start = 15; // More than End = 10
-        Assert.True(textRange.Start <= textRange.End);
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_Clone_ReturnsCorrectValue()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 3, end: 9);
-        UiaTextRange actual = (UiaTextRange)((ITextRangeProvider)textRange).Clone();
-        Assert.Equal(textRange.Start, actual.Start);
-        Assert.Equal(textRange.End, actual.End);
-    }
-
-    [StaTheory]
-    [InlineData(3, 9, true)]
-    [InlineData(0, 2, false)]
-    public void UiaTextRange_ITextRangeProvider_Compare_ReturnsCorrectValue(int start, int end, bool expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange1 = new UiaTextRange(enclosingElement, provider, start: 3, end: 9);
-        UiaTextRange textRange2 = new UiaTextRange(enclosingElement, provider, start, end);
-        bool actual = ((ITextRangeProvider)textRange1).Compare(textRange2);
-        Assert.Equal(expected, actual);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_CompareEndpoints_ReturnsCorrectValue_TestData()
-    {
-        yield return new object[] { TextPatternRangeEndpoint.Start, 3, 9, TextPatternRangeEndpoint.Start, 0 };
-        yield return new object[] { TextPatternRangeEndpoint.End, 3, 9, TextPatternRangeEndpoint.Start, 6 };
-        yield return new object[] { TextPatternRangeEndpoint.Start, 3, 9, TextPatternRangeEndpoint.End, -6 };
-        yield return new object[] { TextPatternRangeEndpoint.End, 3, 9, TextPatternRangeEndpoint.End, 0 };
-        yield return new object[] { TextPatternRangeEndpoint.Start, 0, 0, TextPatternRangeEndpoint.Start, 3 };
-        yield return new object[] { TextPatternRangeEndpoint.End, 0, 0, TextPatternRangeEndpoint.Start, 9 };
-        yield return new object[] { TextPatternRangeEndpoint.End, 1, 15, TextPatternRangeEndpoint.End, -6 };
-        yield return new object[] { TextPatternRangeEndpoint.Start, 1, 15, TextPatternRangeEndpoint.End, -12 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_CompareEndpoints_ReturnsCorrectValue_TestData))]
-    public void UiaTextRange_ITextRangeProvider_CompareEndpoints_ReturnsCorrectValue(
-        int endpoint,
-        int targetStart,
-        int targetEnd,
-        int targetEndpoint,
-        int expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 3, end: 9);
-        UiaTextRange targetRange = new UiaTextRange(enclosingElement, provider, start: targetStart, end: targetEnd);
-        int actual = ((ITextRangeProvider)textRange).CompareEndpoints((TextPatternRangeEndpoint)endpoint, targetRange, (TextPatternRangeEndpoint)targetEndpoint);
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(2, 2, 2, 3)]
-    [InlineData(8, 9, 8, 9)]
-    [InlineData(0, 3, 0, 3)]
-    public void UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToCharacter(int start, int end, int expandedStart, int expandedEnd)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.TextLength).Returns("words, words, words".Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ExpandToEnclosingUnit(TextUnit.Character);
-        Assert.Equal(expandedStart, textRange.Start);
-        Assert.Equal(expandedEnd, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(2, 3, 0, 5)]
-    [InlineData(8, 8, 7, 12)]
-    [InlineData(16, 17, 14, 19)]
-    public void UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToWord(int start, int end, int expandedStart, int expandedEnd)
-    {
-        string testText = "words, words, words";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ExpandToEnclosingUnit(TextUnit.Word);
-        Assert.Equal(expandedStart, textRange.Start);
-        Assert.Equal(expandedEnd, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(2, 4, 0, 12)]
-    [InlineData(15, 16, 12, 25)]
-    [InlineData(27, 28, 25, 36)]
-    public void UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToLine(int start, int end, int expandedStart, int expandedEnd)
-    {
-        string testText =
-@"First line
-second line
-third line.";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        providerMock.Setup(m => m.LinesCount).Returns(3);
-        providerMock.Setup(m => m.GetLineIndex(0)).Returns(0);
-        providerMock.Setup(m => m.GetLineIndex(1)).Returns(12);
-        providerMock.Setup(m => m.GetLineIndex(2)).Returns(25);
-        providerMock.Setup(m => m.GetLineFromCharIndex(2)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(4)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(15)).Returns(1);
-        providerMock.Setup(m => m.GetLineFromCharIndex(16)).Returns(1);
-        providerMock.Setup(m => m.GetLineFromCharIndex(27)).Returns(2);
-        providerMock.Setup(m => m.GetLineFromCharIndex(28)).Returns(2);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ExpandToEnclosingUnit(TextUnit.Line);
-        Assert.Equal(expandedStart, textRange.Start);
-        Assert.Equal(expandedEnd, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(2, 4, 0, 24)]
-    [InlineData(30, 30, 24, 49)]
-    [InlineData(49, 60, 49, 72)]
-    public void UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToParagraph(int start, int end, int expandedStart, int expandedEnd)
-    {
-        string testText =
-@"This is the first line
-this is the second line
-this is the third line.";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ExpandToEnclosingUnit(TextUnit.Paragraph);
-        Assert.Equal(expandedStart, textRange.Start);
-        Assert.Equal(expandedEnd, textRange.End);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToAllText_TestData()
-    {
-        yield return new object[] { 5, 8, TextUnit.Page, 0, 72 };
-        yield return new object[] { 10, 10, TextUnit.Format, 0, 72 };
-        yield return new object[] { 10, 10, TextUnit.Document, 0, 72 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToAllText_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_ExpandToEnclosingUnit_ExpandsToAllText(int start, int end, TextUnit textUnit, int expandedStart, int expandedEnd)
-    {
-        string testText =
-@"This is the first line
-this is the second line
-this is the third line.";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ExpandToEnclosingUnit(textUnit);
-        Assert.Equal(expandedStart, textRange.Start);
-        Assert.Equal(expandedEnd, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    internal void UiaTextRange_ITextRangeProvider_FindAttribute_Returns_null(bool backward)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        Array textAttributeIdentifiers = Enum.GetValues(typeof(TextAttributeIdentifier));
-
-        foreach (int textAttributeIdentifier in textAttributeIdentifiers)
-        {
-            ITextRangeProvider? actual = ((ITextRangeProvider)textRange).FindAttribute(textAttributeIdentifier, new object(), backward);
-            Assert.Null(actual);
-        }
-    }
-
-    public static IEnumerable<object?[]> UiaTextRange_ITextRangeProvider_FindText_Returns_Correct_TestData()
-    {
-        yield return new object?[] { "text", "text", BOOL.FALSE, BOOL.FALSE };
-        yield return new object?[] { "other", null, BOOL.FALSE, BOOL.FALSE };
-        yield return new object?[] { "TEXT", "text", BOOL.FALSE, BOOL.TRUE };
-        yield return new object?[] { "TEXT", null, BOOL.FALSE, BOOL.FALSE };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_FindText_Returns_Correct_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_FindText_Returns_Correct(string textToSearch, string? foundText, BOOL backward, BOOL ignoreCase)
-    {
-        string testText = "Test text to find something.";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 28);
-
-        ITextRangeProvider? actual = ((ITextRangeProvider)textRange).FindText(textToSearch, backward, ignoreCase);
-
-        if (foundText is not null)
-        {
-            Assert.Equal(foundText, actual?.GetText(5000));
-        }
-        else
-        {
-            Assert.Null(actual);
-        }
-    }
-
-#pragma warning disable CS8625 // FindText doesn't accept a text null parameter
-    [StaFact]
-    internal void UiaTextRange_ITextRangeProvider_FindText_ReturnsNull_IfTextNull()
-    {
-        using (new NoAssertContext())
-        {
-            IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-            UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-            UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 28);
-            ITextRangeProvider? actual = ((ITextRangeProvider)textRange).FindText(null, BOOL.TRUE, BOOL.TRUE);
-            Assert.Null(actual);
-        }
-    }
-#pragma warning restore CS8625
-
-    private static object? notSupportedValue;
-
-    [DllImport(Libraries.UiaCore, ExactSpelling = true)]
-    private static extern int UiaGetReservedNotSupportedValue([MarshalAs(UnmanagedType.IUnknown)] out object notSupportedValue);
-
-    public static object UiaGetReservedNotSupportedValue()
-    {
-        if (notSupportedValue is null)
-        {
-            UiaGetReservedNotSupportedValue(out notSupportedValue);
-        }
-
-        return notSupportedValue;
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_GetAttributeValue_Returns_Correct_TestData()
-    {
-        yield return new object[] { TextAttributeIdentifier.BackgroundColorAttributeId, (int)(uint)(COLORREF)PInvoke.GetSysColor(SYS_COLOR_INDEX.COLOR_WINDOW) };
-        yield return new object[] { TextAttributeIdentifier.CapStyleAttributeId, CapStyle.None };
-        yield return new object[] { TextAttributeIdentifier.FontNameAttributeId, "Segoe UI" };
-        yield return new object[] { TextAttributeIdentifier.FontSizeAttributeId, 9.0 };
-        yield return new object[] { TextAttributeIdentifier.FontWeightAttributeId, FW.NORMAL };
-        yield return new object[] { TextAttributeIdentifier.ForegroundColorAttributeId, (int)(uint)new COLORREF() };
-        yield return new object[] { TextAttributeIdentifier.HorizontalTextAlignmentAttributeId, HorizontalTextAlignment.Left };
-        yield return new object[] { TextAttributeIdentifier.IsItalicAttributeId, false };
-        yield return new object[] { TextAttributeIdentifier.IsReadOnlyAttributeId, false };
-        yield return new object[] { TextAttributeIdentifier.StrikethroughStyleAttributeId, TextDecorationLineStyle.None };
-        yield return new object[] { TextAttributeIdentifier.UnderlineStyleAttributeId, TextDecorationLineStyle.None };
-
-        yield return new object[] { TextAttributeIdentifier.AnimationStyleAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.BulletStyleAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.CultureAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IndentationFirstLineAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IndentationLeadingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IndentationTrailingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IsHiddenAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IsSubscriptAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IsSuperscriptAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.MarginBottomAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.MarginLeadingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.MarginTopAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.MarginTrailingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.OutlineStylesAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.OverlineColorAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.OverlineStyleAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.StrikethroughColorAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.TabsAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.TextFlowDirectionsAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.UnderlineColorAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.AnnotationTypesAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.AnnotationObjectsAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.StyleNameAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.StyleIdAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.LinkAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.IsActiveAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.SelectionActiveEndAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.CaretPositionAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.CaretBidiModeAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.LineSpacingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.BeforeParagraphSpacingAttributeId, UiaGetReservedNotSupportedValue() };
-        yield return new object[] { TextAttributeIdentifier.AfterParagraphSpacingAttributeId, UiaGetReservedNotSupportedValue() };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_GetAttributeValue_Returns_Correct_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_GetAttributeValue_Returns_Correct(int attributeId, object attributeValue)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        using Font font = new Font("Segoe UI", 9, FontStyle.Regular);
-        providerMock.Setup(m => m.Logfont).Returns(LOGFONTW.FromFont(font));
-        providerMock.Setup(m => m.WindowStyle).Returns(PInvoke.ES_LEFT);
-        providerMock.Setup(m => m.IsReadOnly).Returns(false);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 28);
-        object? actual = ((ITextRangeProvider)textRange).GetAttributeValue(attributeId);
-        Assert.Equal(attributeValue, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsEmpty_for_EmptyText()
-    {
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        Rectangle expected = new Rectangle(10, 33, 96, 19);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new double[] { 10, 33, 96, 19 });
-        IRawElementProviderSimple enclosingElement = enclosingElementMock.Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(p => p.Text).Returns("");
-        providerMock.Setup(p => p.TextLength).Returns(0);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        var actual = ((ITextRangeProvider)textRange).GetBoundingRectangles();
-        Assert.Equal(UiaTextProvider.BoundingRectangleAsArray(expected), actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsEmpty_for_DegenerateRange()
-    {
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new Rectangle(10, 33, 96, 19));
-        IRawElementProviderSimple enclosingElement = enclosingElementMock.Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(p => p.Text).Returns("abcde");
-        providerMock.Setup(p => p.TextLength).Returns(5);
-        providerMock.Setup(p => p.IsMultiline).Returns(false);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        var actual = ((ITextRangeProvider)textRange).GetBoundingRectangles();
-        Assert.Empty(actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsExpected_for_Endline()
-    {
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new double[] {10, 33, 96, 19 });
-        IRawElementProviderSimple enclosingElement = enclosingElementMock.Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(p => p.Text).Returns("abc");
-        providerMock.Setup(p => p.TextLength).Returns(3);
-        providerMock.Setup(p => p.PointToScreen(It.IsAny<Point>())).Returns(Point.Empty);
-        using Font font = new Font("Arial", 9f, FontStyle.Regular);
-        providerMock.Setup(m => m.Logfont).Returns(LOGFONTW.FromFont(font));
-        UiaTextProvider provider = providerMock.Object;
-
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 3, end: 3);
-        double actualWidth = ((ITextRangeProvider)textRange).GetBoundingRectangles()[2]; // {X,Y,Width,Height}
-
-        Assert.Equal(UiaTextProvider.EndOfLineWidth, actualWidth);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_SingleLine_TestData()
-    {
-        yield return new object[] { 3, 6, new double[] { 27, 34, 11, 14 } };
-        yield return new object[] { 0, 2, new double[] { 11, 34, 16, 15 } };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_SingleLine_TestData))]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_SingleLine(int start, int end, double[] expected)
-    {
-        string testText = "Test text.";
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new Rectangle(10, 33, 96, 19));
-        IRawElementProviderSimple enclosingElement = enclosingElementMock.Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        providerMock.Setup(m => m.IsMultiline).Returns(false);
-        providerMock.Setup(m => m.BoundingRectangle).Returns(new Rectangle(1, 1, 94, 15));
-        providerMock.Setup(m => m.GetPositionFromChar(3)).Returns(new Point(17, 0));
-        providerMock.Setup(m => m.GetPositionFromChar(0)).Returns(new Point(1, 0));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(5, testText)).Returns(new Point(28, 0));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(1, testText)).Returns(new Point(17, 0));
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        double[] actual = ((ITextRangeProvider)textRange).GetBoundingRectangles();
-
-        // Acceptable deviation of 1 px.
-        for (int i = 0; i < actual.Length; i++)
-        {
-            Assert.True(actual[i] >= 0 && actual[i] >= expected[i] - 1 && actual[i] <= expected[i] + 1);
-        }
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine_TestData()
-    {
-        yield return new object[] { 0, 63, new double[] { 32, 131, 103, 12, 32, 148, 85, 12, 32, 165, 83, 12, 32, 182, 90, 12, 32, 199, 40, 12 } }; // Whole text
-        yield return new object[] { 23, 53, new double[] { 72, 148, 45, 12, 32, 165, 83, 12, 32, 182, 56, 12 } }; // "xt with several lines and num" text is selected
-    }
-
-    /// <remark>All returned values of mock methods and properties were taken from a real TextBox.</remark>
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine_TestData))]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine(int start, int end, double[] expected)
-    {
-        string testText =
-@"Some long long
-test text with several lines
-and numbers 12345";
-
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new double[] {27, 128, 128, 155 });
-
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.IsReadingRTL).Returns(false);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.BoundingRectangle).Returns(new Rectangle(5, 1, 118, 153));
-        providerMock.Setup(m => m.IsMultiline).Returns(true);
-        providerMock.Setup(m => m.FirstVisibleLine).Returns(0);
-        providerMock.Setup(m => m.LinesPerPage).Returns(9);
-        using Font font = new Font("Arial", 9f, FontStyle.Regular);
-        providerMock.Setup(m => m.Logfont).Returns(LOGFONTW.FromFont(font));
-
-        // Offset by enclosing element's coordinates
-        providerMock.Setup(m => m.RectangleToScreen(It.IsAny<Rectangle>()))
-            .Returns((Rectangle rect) => new Rectangle(rect.X + 27, rect.Y + 128, rect.Width, rect.Height));
-
-        providerMock.Setup(m => m.GetLineFromCharIndex(0)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(14)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(23)).Returns(1);
-        providerMock.Setup(m => m.GetLineFromCharIndex(31)).Returns(2);
-        providerMock.Setup(m => m.GetLineFromCharIndex(44)).Returns(2);
-        providerMock.Setup(m => m.GetLineFromCharIndex(52)).Returns(3);
-        providerMock.Setup(m => m.GetLineFromCharIndex(58)).Returns(4);
-        providerMock.Setup(m => m.GetLineFromCharIndex(62)).Returns(4);
-
-        providerMock.Setup(m => m.GetPositionFromChar(0)).Returns(new Point(5, 1));
-        providerMock.Setup(m => m.GetPositionFromChar(16)).Returns(new Point(5, 18));
-        providerMock.Setup(m => m.GetPositionFromChar(23)).Returns(new Point(45, 18));
-        providerMock.Setup(m => m.GetPositionFromChar(31)).Returns(new Point(5, 35));
-        providerMock.Setup(m => m.GetPositionFromChar(46)).Returns(new Point(5, 52));
-        providerMock.Setup(m => m.GetPositionFromChar(58)).Returns(new Point(5, 69));
-
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(15, testText)).Returns(new Point(108, 1));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(30, testText)).Returns(new Point(90, 18));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(45, testText)).Returns(new Point(88, 35));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(52, testText)).Returns(new Point(61, 52));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(57, testText)).Returns(new Point(95, 52));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(62, testText)).Returns(new Point(45, 69));
-
-        providerMock.Setup(m => m.GetLineIndex(1)).Returns(16);
-        providerMock.Setup(m => m.GetLineIndex(2)).Returns(31);
-        providerMock.Setup(m => m.GetLineIndex(3)).Returns(46);
-        providerMock.Setup(m => m.GetLineIndex(4)).Returns(58);
-
-        UiaTextRange textRange = new UiaTextRange(enclosingElementMock.Object, providerMock.Object, start, end);
-        var actual = ((ITextRangeProvider)textRange).GetBoundingRectangles();
-        Assert.Equal(expected, actual);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine_And_RTL_TestData()
-    {
-        yield return new object[] { 0, 63, new double[] { 47, 131, 103, 12, 67, 148, 83, 12, 67, 165, 83, 12, 62, 182, 88, 12, 110, 199, 40, 12 } }; // Whole text
-        yield return new object[] { 23, 53, new double[] { 107, 148, 43, 12, 67, 165, 83, 12, 64, 182, 56, 12 } }; // "xt with several lines and num" text is selected
-    }
-
-    /// <remark>All returned values of mock methods and properties were taken from a real TextBox.</remark>
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine_And_RTL_TestData))]
-    public void UiaTextRange_ITextRangeProvider_GetBoundingRectangles_ReturnsCorrectValue_for_MultiLine_And_RTL(int start, int end, double[] expected)
-    {
-        string testText =
-@"Some long long
-test text with several lines
-and numbers 12345";
-
-        Mock<IRawElementProviderSimple> enclosingElementMock = new Mock<IRawElementProviderSimple>(MockBehavior.Strict);
-        enclosingElementMock.Setup(m => m.GetPropertyValue(UIA.BoundingRectanglePropertyId)).Returns(new double[] { 27, 128, 128, 155 });
-
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.IsReadingRTL).Returns(true);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.BoundingRectangle).Returns(new Rectangle(5, 1, 118, 153));
-        providerMock.Setup(m => m.IsMultiline).Returns(true);
-        providerMock.Setup(m => m.FirstVisibleLine).Returns(0);
-        providerMock.Setup(m => m.LinesPerPage).Returns(9);
-        using Font font = new Font("Arial", 9f, FontStyle.Regular);
-        providerMock.Setup(m => m.Logfont).Returns(LOGFONTW.FromFont(font));
-
-        // Offset by enclosing element's coordinates
-        providerMock.Setup(m => m.RectangleToScreen(It.IsAny<Rectangle>()))
-            .Returns((Rectangle rect) => new Rectangle(rect.X + 27, rect.Y + 128, rect.Width, rect.Height));
-
-        providerMock.Setup(m => m.GetLineFromCharIndex(0)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(14)).Returns(0);
-        providerMock.Setup(m => m.GetLineFromCharIndex(23)).Returns(1);
-        providerMock.Setup(m => m.GetLineFromCharIndex(31)).Returns(2);
-        providerMock.Setup(m => m.GetLineFromCharIndex(44)).Returns(2);
-        providerMock.Setup(m => m.GetLineFromCharIndex(52)).Returns(3);
-        providerMock.Setup(m => m.GetLineFromCharIndex(58)).Returns(4);
-        providerMock.Setup(m => m.GetLineFromCharIndex(62)).Returns(4);
-
-        providerMock.Setup(m => m.GetPositionFromChar(0)).Returns(new Point(22, 1));
-        providerMock.Setup(m => m.GetPositionFromChar(16)).Returns(new Point(42, 18));
-        providerMock.Setup(m => m.GetPositionFromChar(23)).Returns(new Point(82, 18));
-        providerMock.Setup(m => m.GetPositionFromChar(31)).Returns(new Point(42, 35));
-        providerMock.Setup(m => m.GetPositionFromChar(46)).Returns(new Point(37, 52));
-        providerMock.Setup(m => m.GetPositionFromChar(58)).Returns(new Point(83, 69));
-
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(15, testText)).Returns(new Point(125, 1));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(30, testText)).Returns(new Point(127, 18));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(45, testText)).Returns(new Point(125, 35));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(52, testText)).Returns(new Point(93, 52));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(57, testText)).Returns(new Point(127, 52));
-        providerMock.Setup(m => m.GetPositionFromCharForUpperRightCorner(62, testText)).Returns(new Point(123, 69));
-
-        providerMock.Setup(m => m.GetLineIndex(1)).Returns(16);
-        providerMock.Setup(m => m.GetLineIndex(2)).Returns(31);
-        providerMock.Setup(m => m.GetLineIndex(3)).Returns(46);
-        providerMock.Setup(m => m.GetLineIndex(4)).Returns(58);
-
-        UiaTextRange textRange = new UiaTextRange(enclosingElementMock.Object, providerMock.Object, start, end);
-        var actual = ((ITextRangeProvider)textRange).GetBoundingRectangles();
-        Assert.Equal(expected, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_GetEnclosingElement_ReturnsCorrectValue()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        IRawElementProviderSimple actual = ((ITextRangeProvider)textRange).GetEnclosingElement();
-        Assert.Equal(enclosingElement, actual);
-    }
-
-    [StaTheory]
-    [InlineData(0, 0, 0, "")]
-    [InlineData(0, 0, 5, "")]
-    [InlineData(0, 10, -5, "Some long ")]
-    [InlineData(0, 10, 0, "")]
-    [InlineData(0, 10, 10, "Some long ")]
-    [InlineData(0, 10, 20, "Some long ")]
-    [InlineData(0, 25, 7, "Some lo")]
-    [InlineData(0, 300, 400, "Some long long test text")]
-    [InlineData(5, 15, 7, "long lo")]
-    [InlineData(5, 15, 25, "long long ")]
-    [InlineData(5, 15, 300, "long long ")]
-    [InlineData(5, 24, 400, "long long test text")]
-    [InlineData(5, 25, 0, "")]
-    [InlineData(5, 25, 7, "long lo")]
-    [InlineData(5, 300, -5, "long long test text")]
-    [InlineData(5, 300, 7, "long lo")]
-    [InlineData(5, 300, 300, "long long test text")]
-    public void UiaTextRange_ITextRangeProvider_GetText_ReturnsCorrectValue(int start, int end, int maxLength, string expected)
-    {
-        string testText = "Some long long test text";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        string actual = ((ITextRangeProvider)textRange).GetText(maxLength);
-        Assert.Equal(expected, actual);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_Move_MovesCorrectly_TestData()
-    {
-        yield return new object[] { 0, 5, TextUnit.Character, 1, 6, 6 };
-        yield return new object[] { 1, 6, TextUnit.Character, 5, 11, 11 };
-        yield return new object[] { 0, 5, TextUnit.Character, -2, 0, 0 };
-        yield return new object[] { 3, 6, TextUnit.Character, -2, 1, 1 };
-        yield return new object[] { 1, 2, TextUnit.Word, 1, 4, 4 };
-        yield return new object[] { 1, 2, TextUnit.Word, 5, 11, 11 };
-        yield return new object[] { 12, 14, TextUnit.Word, -2, 8, 8 };
-        yield return new object[] { 12, 14, TextUnit.Word, -10, 0, 0 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_Move_MovesCorrectly_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_Move_MovesCorrectly(int start, int end, TextUnit unit, int count, int expectedStart, int expectedEnd)
-    {
-        string testText =
-@"This is the text to move on - line 1
-This is the line 2
-This is the line 3";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        int result = ((ITextRangeProvider)textRange).Move(unit, count);
-        Assert.Equal(expectedStart, textRange.Start);
-        Assert.Equal(expectedEnd, textRange.End);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_MoveEndpointByUnit_MovesCorrectly_TestData()
-    {
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.Start, TextUnit.Character, 1, 1, 5 };
-        yield return new object[] { 1, 6, TextPatternRangeEndpoint.Start, TextUnit.Character, 5, 6, 6 };
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.Start, TextUnit.Character, -2, 0, 5 };
-        yield return new object[] { 3, 6, TextPatternRangeEndpoint.Start, TextUnit.Character, -2, 1, 6 };
-        yield return new object[] { 3, 6, TextPatternRangeEndpoint.End, TextUnit.Character, 1, 3, 7 };
-        yield return new object[] { 3, 6, TextPatternRangeEndpoint.End, TextUnit.Character, -1, 3, 5 };
-        yield return new object[] { 1, 2, TextPatternRangeEndpoint.Start, TextUnit.Word, 1, 4, 4 };
-        yield return new object[] { 1, 2, TextPatternRangeEndpoint.Start, TextUnit.Word, 5, 11, 11 };
-        yield return new object[] { 12, 14, TextPatternRangeEndpoint.Start, TextUnit.Word, -1, 11, 14 };
-        yield return new object[] { 12, 14, TextPatternRangeEndpoint.Start, TextUnit.Word, -2, 8, 14 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_MoveEndpointByUnit_MovesCorrectly_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_MoveEndpointByUnit_MovesCorrectly(int start, int end, TextPatternRangeEndpoint endpoint, TextUnit unit, int count, int expectedStart, int expectedEnd)
-    {
-        string testText =
-@"This is the text to move on - line 1
-This is the line 2
-This is the line 3";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.Text).Returns(testText);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).MoveEndpointByUnit(endpoint, unit, count);
-        Assert.Equal(expectedStart, textRange.Start);
-        Assert.Equal(expectedEnd, textRange.End);
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_MoveEndpointByRange_MovesCorrectly_TestData()
-    {
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.Start, 7, 10, TextPatternRangeEndpoint.Start, 7, 7 };
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.Start, 7, 10, TextPatternRangeEndpoint.End, 10, 10 };
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.End, 7, 10, TextPatternRangeEndpoint.Start, 0, 7 };
-        yield return new object[] { 0, 5, TextPatternRangeEndpoint.End, 7, 10, TextPatternRangeEndpoint.End, 0, 10 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_MoveEndpointByRange_MovesCorrectly_TestData))]
-    internal void UiaTextRange_ITextRangeProvider_MoveEndpointByRange_MovesCorrectly(int start, int end, TextPatternRangeEndpoint endpoint, int targetRangeStart, int targetRangeEnd, TextPatternRangeEndpoint targetEndpoint, int expectedStart, int expectedEnd)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        UiaTextRange targetRange = new UiaTextRange(enclosingElement, provider, targetRangeStart, targetRangeEnd);
-        ((ITextRangeProvider)textRange).MoveEndpointByRange(endpoint, targetRange, targetEndpoint);
-        Assert.Equal(expectedStart, textRange.Start);
-        Assert.Equal(expectedEnd, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(0, 0)]
-    [InlineData(0, 10)]
-    [InlineData(5, 10)]
-    public void UiaTextRange_ITextRangeProvider_Select_ReturnsCorrectValue(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.SetSelection(start, end));
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).Select();
-        providerMock.Verify(m => m.SetSelection(start, end), Times.Once());
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_AddToSelection_DoesntThrowException()
-    {
-        // Check an app doesn't crash when calling AddToSelection method.
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 3, 7);
-        ((ITextRangeProvider)textRange).AddToSelection();
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_RemoveFromSelection_DoesntThrowException()
-    {
-        // Check an app doesn't crash when calling RemoveFromSelection method.
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 3, 7);
-        ((ITextRangeProvider)textRange).RemoveFromSelection();
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_ScrollIntoView_Multiline_CallsLineScrollCorrectly_TestData()
-    {
-        yield return new object[] { 30, 35, 30, 1, 30, 0, 1 };
-        yield return new object[] { 60, 65, 60, 2, 60, 2, 0 };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_ScrollIntoView_Multiline_CallsLineScrollCorrectly_TestData))]
-    public void UiaTextRange_ITextRangeProvider_ScrollIntoView_Multiline_CallsLineScrollCorrectly(int start, int end, int charIndex, int lineForCharIndex, int charactersHorizontal, int linesVertical, int firstVisibleLine)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-
-        var providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(p => p.IsMultiline).Returns(true);
-        providerMock.Setup(p => p.GetLineFromCharIndex(charIndex)).Returns(lineForCharIndex);
-        providerMock.Setup(p => p.LineScroll(charactersHorizontal, linesVertical)).Returns(true);
-        providerMock.Setup(p => p.FirstVisibleLine).Returns(firstVisibleLine);
-
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ScrollIntoView(BOOL.TRUE);
-        providerMock.Verify(e => e.LineScroll(charactersHorizontal, linesVertical), Times.Once());
-    }
-
-    public static IEnumerable<object[]> UiaTextRange_ITextRangeProvider_ScrollIntoView_SingleLine_ExecutesCorrectly_TestData()
-    {
-        yield return new object[] { 0, 30, true, false };
-        yield return new object[] { 70, 85, true, false };
-    }
-
-    [StaTheory]
-    [MemberData(nameof(UiaTextRange_ITextRangeProvider_ScrollIntoView_SingleLine_ExecutesCorrectly_TestData))]
-    public void UiaTextRange_ITextRangeProvider_ScrollIntoView_SingleLine_ExecutesCorrectly(int start, int end, bool scrollable, bool readingRTL)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        int visibleStart = 40;
-        int visibleEnd = 60;
-
-        var providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(p => p.IsMultiline).Returns(false);
-        providerMock.Setup(p => p.IsScrollable).Returns(scrollable);
-        providerMock.Setup(p => p.IsReadingRTL).Returns(readingRTL);
-        providerMock.Setup(p => p.GetVisibleRangePoints(out visibleStart, out visibleEnd));
-
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-        ((ITextRangeProvider)textRange).ScrollIntoView(BOOL.TRUE);
-        providerMock.Verify(p => p.GetVisibleRangePoints(out visibleStart, out visibleEnd), Times.Exactly(2));
-    }
-
-    [StaFact]
-    public void UiaTextRange_ITextRangeProvider_GetChildren_ReturnsCorrectValue()
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start: 0, end: 0);
-        IRawElementProviderSimple[] actual = ((ITextRangeProvider)textRange).GetChildren();
-        Assert.Empty(actual);
-    }
-
-    [StaTheory]
-    [InlineData("", 0, true)]
-    [InlineData("", 5, true)]
-    [InlineData("", -5, true)]
-    [InlineData("Some text", 0, true)]
-    [InlineData("Some text", 5, false)]
-    [InlineData("Some text", 6, false)]
-    [InlineData("Some text", 99, true)]
-    [InlineData("Some text", -5, true)]
-    [InlineData("Some, text", 4, false)]
-    [InlineData("Some text", 4, false)]
-    [InlineData("1dsf'21gj", 3, false)]
-    [InlineData("1dsf'21gj", 4, false)]
-    [InlineData("1dsf'21gj", 6, false)]
-    [InlineData("1d??sf'21gj", 6, false)]
-    public void UiaTextRange_private_AtParagraphBoundary_ReturnsCorrectValue(string text, int index, bool expected)
-    {
-        bool actual = StaticNullTextRange.TestAccessor().AtParagraphBoundary(text, index);
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData("", 0, true)]
-    [InlineData("", 5, true)]
-    [InlineData("", -5, true)]
-    [InlineData("Some text", 0, true)]
-    [InlineData("Some text", 5, true)]
-    [InlineData("Some text", 6, false)]
-    [InlineData("Some text", 99, true)]
-    [InlineData("Some text", -5, true)]
-    [InlineData("Some, text", 4, true)]
-    [InlineData("Some text", 4, true)]
-    [InlineData("1dsf'21gj", 3, false)]
-    [InlineData("1dsf'21gj", 4, false)]
-    [InlineData("1dsf'21gj", 6, false)]
-    [InlineData("1d??sf'21gj", 6, false)]
-    public void UiaTextRange_private_AtWordBoundary_ReturnsCorrectValue(string text, int index, bool expected)
-    {
-        bool actual = StaticNullTextRange.TestAccessor().AtWordBoundary(text, index);
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData('\'', true)]
-    [InlineData((char)0x2019, true)]
-    [InlineData('\t', false)]
-    [InlineData('t', false)]
-    public void UiaTextRange_private_IsApostrophe_ReturnsCorrectValue(char ch, bool expected)
-    {
-        bool actual = StaticNullTextRange.TestAccessor().IsApostrophe(ch);
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(PInvoke.ES_CENTER, (int)HorizontalTextAlignment.Centered)]
-    [InlineData(PInvoke.ES_LEFT, (int)HorizontalTextAlignment.Left)]
-    [InlineData(PInvoke.ES_RIGHT, (int)HorizontalTextAlignment.Right)]
-    public void UiaTextRange_private_GetHorizontalTextAlignment_ReturnsCorrectValue(int style, int expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 0, 0);
-
-        HorizontalTextAlignment actual = textRange.TestAccessor().GetHorizontalTextAlignment((WINDOW_STYLE)style);
-
-        Assert.Equal((HorizontalTextAlignment)expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData((PInvoke.ES_UPPERCASE | PInvoke.ES_LEFT | PInvoke.ES_MULTILINE | PInvoke.ES_READONLY | PInvoke.ES_AUTOHSCROLL), (int)CapStyle.AllCap)]
-    [InlineData((PInvoke.ES_LOWERCASE | PInvoke.ES_LEFT | PInvoke.ES_MULTILINE | PInvoke.ES_READONLY | PInvoke.ES_AUTOHSCROLL), (int)CapStyle.None)]
-    public void UiaTextRange_private_GetCapStyle_ReturnsExpectedValue(int editStyle, int expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 0, 0);
-
-        CapStyle actual = textRange.TestAccessor().GetCapStyle((WINDOW_STYLE)editStyle);
-
-        Assert.Equal((CapStyle)expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void UiaTextRange_private_GetReadOnly_ReturnsCorrectValue(bool readOnly)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.IsReadOnly).Returns(readOnly);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 0, 0);
-
-        bool actual = textRange.TestAccessor().GetReadOnly();
-
-        Assert.Equal(readOnly, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_private_GetBackgroundColor_ReturnsExpectedValue()
-    {
-        COLORREF actual = StaticNullTextRange.TestAccessor().GetBackgroundColor();
-        uint expected = 0x00ffffff; // WINDOW system color
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData(" ")]
-    [InlineData("Some test text")]
-    public void UiaTextRange_private_GetFontName_ReturnsExpectedValue(string faceName)
-    {
-        LOGFONTW logfont = new()
-        {
-            FaceName = faceName
-        };
-
-        string actual = StaticNullTextRange.TestAccessor().GetFontName(logfont);
-
-        Assert.Equal(faceName ?? "", actual);
-    }
-
-    [StaTheory]
-    [InlineData(1, 1)]
-    [InlineData(5, 5)]
-    [InlineData(5.3, 5)]
-    [InlineData(9.5, 10)]
-    [InlineData(18, 18)]
-    [InlineData(18.8, 19)]
-    [InlineData(100, 100)]
-    public void UiaTextRange_private_GetFontSize_ReturnsCorrectValue(float fontSize, double expected)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        using Font font = new Font("Arial", fontSize, FontStyle.Regular);
-        providerMock.Setup(m => m.Logfont).Returns(LOGFONTW.FromFont(font));
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 5, 20);
-
-        double actual = textRange.TestAccessor().GetFontSize(provider.Logfont);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(FW.BLACK)]
-    [InlineData(FW.BOLD)]
-    [InlineData(FW.DEMIBOLD)]
-    [InlineData(FW.DONTCARE)]
-    [InlineData(FW.EXTRABOLD)]
-    [InlineData(FW.EXTRALIGHT)]
-    [InlineData(FW.LIGHT)]
-    [InlineData(FW.MEDIUM)]
-    [InlineData(FW.NORMAL)]
-    [InlineData(FW.THIN)]
-    public void UiaTextRange_private_GetFontWeight_ReturnsCorrectValue(object fontWeight)
-    {
-        LOGFONTW logfont = new() { lfWeight = (int)fontWeight };
-        FW actual = StaticNullTextRange.TestAccessor().GetFontWeight(logfont);
-        Assert.Equal(fontWeight, actual);
-    }
-
-    [StaFact]
-    public void UiaTextRange_private_GetForegroundColor_ReturnsCorrectValue()
-    {
-        COLORREF actual = StaticNullTextRange.TestAccessor().GetForegroundColor();
-        Assert.Equal(new COLORREF(), actual);
-    }
-
-    [StaTheory]
-    [InlineData(0, false)]
-    [InlineData(5, true)]
-    public void UiaTextRange_private_GetItalic_ReturnsCorrectValue(byte ifItalic, bool expected)
-    {
-        LOGFONTW logfont = new LOGFONTW() { lfItalic = ifItalic };
-
-        bool actual = StaticNullTextRange.TestAccessor().GetItalic(logfont);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(0, (int)TextDecorationLineStyle.None)]
-    [InlineData(5, (int)TextDecorationLineStyle.Single)]
-    public void UiaTextRange_private_GetStrikethroughStyle_ReturnsCorrectValue(byte ifStrikeOut, int expected)
-    {
-        LOGFONTW logfont = new LOGFONTW() { lfStrikeOut = ifStrikeOut };
-        TextDecorationLineStyle actual = StaticNullTextRange.TestAccessor().GetStrikethroughStyle(logfont);
-
-        Assert.Equal((TextDecorationLineStyle)expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(0, (int)TextDecorationLineStyle.None)]
-    [InlineData(5, (int)TextDecorationLineStyle.Single)]
-    public void UiaTextRange_private_GetUnderlineStyle_ReturnsCorrectValue(byte ifUnderline, int expected)
-    {
-        LOGFONTW logfont = new LOGFONTW() { lfUnderline = ifUnderline };
-        TextDecorationLineStyle actual = StaticNullTextRange.TestAccessor().GetUnderlineStyle(logfont);
-
-        Assert.Equal((TextDecorationLineStyle)expected, actual);
-    }
-
-    [StaTheory]
-    [InlineData(0, 0)]
-    [InlineData(0, 10)]
-    [InlineData(5, 10)]
-    [InlineData(5, 100)]
-    [InlineData(100, 100)]
-    [InlineData(100, 200)]
-    public void UiaTextRange_private_MoveTo_SetValuesCorrectly(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 0, 0);
-
-        textRange.TestAccessor().MoveTo(start, end);
-
-        Assert.Equal(start, textRange.Start);
-        Assert.Equal(end, textRange.End);
-    }
-
-    [StaTheory]
-    [InlineData(-5, 0)]
-    [InlineData(0, -5)]
-    [InlineData(-10, -10)]
-    [InlineData(10, 5)]
-    public void UiaTextRange_private_MoveTo_ThrowsException_IfIncorrectParameters(int start, int end)
-    {
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        UiaTextProvider provider = new Mock<UiaTextProvider>(MockBehavior.Strict).Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, 0, 0);
-
-        Assert.ThrowsAny<Exception>(() => textRange.TestAccessor().MoveTo(start, end));
-    }
-
-    [StaTheory]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(0, 10, 0, 10)]
-    [InlineData(5, 10, 5, 10)]
-    [InlineData(5, 100, 5, 24)]
-    [InlineData(100, 100, 24, 24)]
-    [InlineData(100, 200, 24, 24)]
-    public void UiaTextRange_private_ValidateEndpoints_SetValuesCorrectly(int start, int end, int expectedStart, int expectedEnd)
-    {
-        string testText = "Some long long test text";
-        IRawElementProviderSimple enclosingElement = new Mock<IRawElementProviderSimple>(MockBehavior.Strict).Object;
-        Mock<UiaTextProvider> providerMock = new Mock<UiaTextProvider>(MockBehavior.Strict);
-        providerMock.Setup(m => m.TextLength).Returns(testText.Length);
-        UiaTextProvider provider = providerMock.Object;
-        UiaTextRange textRange = new UiaTextRange(enclosingElement, provider, start, end);
-
-        textRange.TestAccessor().ValidateEndpoints();
-
-        Assert.Equal(expectedStart, textRange.Start);
-        Assert.Equal(expectedEnd, textRange.End);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ArrayTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ArrayTests.cs
deleted file mode 100644
index 3fc0bd560e2..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ArrayTests.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class ArrayTests
-{
-    [Theory]
-    [MemberData(nameof(ArrayInfo_ParseSuccessData))]
-    public void ArrayInfo_Parse_Success(MemoryStream stream, int expectedId, int expectedLength)
-    {
-        using BinaryReader reader = new(stream);
-        ArrayInfo info = ArrayInfo.Parse(reader, out Count length);
-        info.ObjectId.Should().Be(expectedId);
-        info.Length.Should().Be(expectedLength);
-        length.Should().Be(expectedLength);
-    }
-
-    public static TheoryData<Stream, int, int> ArrayInfo_ParseSuccessData => new()
-    {
-        { new MemoryStream(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }), 0, 0 },
-        { new MemoryStream(new byte[] { 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 }), 1, 1 },
-        { new MemoryStream(new byte[] { 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 }), 2, 1 },
-        { new MemoryStream(new byte[] { 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F }), int.MaxValue, int.MaxValue }
-    };
-
-    [Theory]
-    [MemberData(nameof(ArrayInfo_ParseNegativeData))]
-    public void ArrayInfo_Parse_Negative(MemoryStream stream, Type expectedException)
-    {
-        using BinaryReader reader = new(stream);
-        Assert.Throws(expectedException, () => ArrayInfo.Parse(reader, out Count length));
-    }
-
-    public static TheoryData<Stream, Type> ArrayInfo_ParseNegativeData => new()
-    {
-        // Not enough data
-        { new MemoryStream(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }), typeof(EndOfStreamException) },
-        { new MemoryStream(new byte[] { 0x00, 0x00, 0x00 }), typeof(EndOfStreamException) },
-        // Negative numbers
-        { new MemoryStream(new byte[] { 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF }), typeof(ArgumentOutOfRangeException) }
-    };
-
-    [Theory]
-    [MemberData(nameof(StringArray_Parse_Data))]
-    public void StringArray_Parse(string?[] strings)
-    {
-        BinaryFormattedObject format = strings.SerializeAndParse();
-        format.RecordCount.Should().BeGreaterThanOrEqualTo(3);
-        ArraySingleString array = (ArraySingleString)format[1];
-        format.GetStringValues(array, strings.Length).Should().BeEquivalentTo(strings);
-    }
-
-    public static TheoryData<string?[]> StringArray_Parse_Data => new()
-    {
-        new string?[] { "one", "two" },
-        new string?[] { "yes", "no", null },
-        new string?[] { "same", "same", "same" }
-    };
-
-    [Theory]
-    [MemberData(nameof(PrimitiveArray_Parse_Data))]
-    public void PrimitiveArray_Parse(Array array)
-    {
-        BinaryFormattedObject format = array.SerializeAndParse();
-        format.RecordCount.Should().BeGreaterThanOrEqualTo(3);
-        ArraySinglePrimitive arrayRecord = (ArraySinglePrimitive)format[1];
-        ((IEnumerable)arrayRecord.ArrayObjects).Should().BeEquivalentTo((IEnumerable)array);
-    }
-
-    public static TheoryData<Array> PrimitiveArray_Parse_Data => new()
-    {
-        new int[] { 1, 2, 3 },
-        new int[] { 1, 2, 1 },
-        new float[] { 1.0f, float.NaN, float.PositiveInfinity },
-        new DateTime[] { DateTime.MaxValue }
-    };
-
-    public static IEnumerable<object[]> Array_TestData => StringArray_Parse_Data.Concat(PrimitiveArray_Parse_Data);
-
-    public static TheoryData<Array> Array_UnsupportedTestData => new()
-    {
-        new Point[] { new Point() },
-        new object[] { new object() },
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormatWriterTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormatWriterTests.cs
deleted file mode 100644
index 86207ab7391..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormatWriterTests.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class BinaryFormatWriterTests
-{
-    [Theory]
-    [InlineData("Hello World.")]
-    [InlineData("")]
-    [InlineData("\0")]
-    [InlineData("Embedded\0 Null.")]
-    public void BinaryFormatWriter_WriteString(string testString)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.WriteString(stream, testString);
-        stream.Position = 0;
-
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore
-        object deserialized = formatter.Deserialize(stream);
-        deserialized.Should().Be(testString);
-    }
-
-    [Theory]
-    [MemberData(nameof(TryWriteObject_SupportedObjects_TestData))]
-    public void BinaryFormatWriter_TryWriteObject_SupportedObjects_BinaryFormatterRead(object value)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.TryWriteFrameworkObject(stream, value).Should().BeTrue();
-        stream.Position = 0;
-
-        using BinaryFormatterScope formaterScope = new(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        object deserialized = formatter.Deserialize(stream);
-
-        if (value is Hashtable hashtable)
-        {
-            Hashtable deserializedHashtable = (Hashtable)deserialized;
-            deserializedHashtable.Count.Should().Be(hashtable.Count);
-            foreach (var key in hashtable.Keys)
-            {
-                deserializedHashtable[key].Should().Be(hashtable[key]);
-            }
-        }
-        else if (value is IEnumerable enumerable)
-        {
-            ((IEnumerable)deserialized).Should().BeEquivalentTo(enumerable);
-        }
-        else
-        {
-            deserialized.Should().Be(value);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(TryWriteObject_SupportedObjects_TestData))]
-    public void BinaryFormatWriter_TryWriteObject_SupportedObjects_RoundTrip(object value)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.TryWriteFrameworkObject(stream, value).Should().BeTrue();
-        stream.Position = 0;
-
-        BinaryFormattedObject format = new(stream);
-        format.TryGetFrameworkObject(out object? deserialized).Should().BeTrue();
-
-        if (value is Hashtable hashtable)
-        {
-            Hashtable deserializedHashtable = (Hashtable)deserialized!;
-            deserializedHashtable.Count.Should().Be(hashtable.Count);
-            foreach (var key in hashtable.Keys)
-            {
-                deserializedHashtable[key].Should().Be(hashtable[key]);
-            }
-        }
-        else if (value is IEnumerable enumerable)
-        {
-            ((IEnumerable)deserialized!).Should().BeEquivalentTo(enumerable);
-        }
-        else
-        {
-            deserialized.Should().Be(value);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(TryWriteObject_UnsupportedObjects_TestData))]
-    public void BinaryFormatWriter_TryWriteObject_UnsupportedObjects_RoundTrip(object value)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.TryWriteFrameworkObject(stream, value).Should().BeFalse();
-        stream.Position.Should().Be(0);
-    }
-
-    public static IEnumerable<object[]?> TryWriteObject_SupportedObjects_TestData =>
-        HashtableTests.Hashtables_TestData.Concat(
-            ListTests.PrimitiveLists_TestData).Concat(
-            ListTests.ArrayLists_TestData).Concat(
-            PrimitiveTypeTests.Primitive_Data).Concat(
-            SystemDrawingTests.SystemDrawing_TestData).Concat(
-            ArrayTests.Array_TestData);
-
-    public static IEnumerable<object[]?> TryWriteObject_UnsupportedObjects_TestData =>
-        HashtableTests.Hashtables_UnsupportedTestData.Concat(
-            ListTests.Lists_UnsupportedTestData).Concat(
-            ListTests.ArrayLists_UnsupportedTestData).Concat(
-            ArrayTests.Array_UnsupportedTestData);
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedObjectTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedObjectTests.cs
deleted file mode 100644
index 00d8b8655ad..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedObjectTests.cs
+++ /dev/null
@@ -1,413 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class BinaryFormattedObjectTests
-{
-    [Fact]
-    public void ReadHeader()
-    {
-        BinaryFormattedObject format = "Hello World.".SerializeAndParse();
-        SerializationHeader header = (SerializationHeader)format[0];
-        header.MajorVersion.Should().Be(1);
-        header.MinorVersion.Should().Be(0);
-        header.RootId.Should().Be(1);
-        header.HeaderId.Should().Be(-1);
-    }
-
-    [Theory]
-    [InlineData("Hello there.")]
-    [InlineData("")]
-    [InlineData("Embedded\0 Null.")]
-    public void ReadBinaryObjectString(string testString)
-    {
-        BinaryFormattedObject format = testString.SerializeAndParse();
-        BinaryObjectString stringRecord = (BinaryObjectString)format[1];
-        stringRecord.ObjectId.Should().Be(1);
-        stringRecord.Value.Should().Be(testString);
-    }
-
-    [Fact]
-    public void ReadEmptyHashTable()
-    {
-        BinaryFormattedObject format = new Hashtable().SerializeAndParse();
-
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-        systemClass.ObjectId.Should().Be(1);
-        systemClass.Name.Should().Be("System.Collections.Hashtable");
-        systemClass.MemberNames.Should().BeEquivalentTo(new[]
-        {
-            "LoadFactor",
-            "Version",
-            "Comparer",
-            "HashCodeProvider",
-            "HashSize",
-            "Keys",
-            "Values"
-        });
-
-        systemClass.MemberTypeInfo.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.SystemClass, "System.Collections.IComparer"),
-            (BinaryType.SystemClass, "System.Collections.IHashCodeProvider"),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.ObjectArray, null),
-            (BinaryType.ObjectArray, null)
-        });
-
-        systemClass.MemberValues.Should().BeEquivalentTo(new object?[]
-        {
-            0.72f,
-            0,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            3,
-            new MemberReference(2),
-            new MemberReference(3)
-        });
-
-        ArraySingleObject array = (ArraySingleObject)format[2];
-        array.ArrayInfo.ObjectId.Should().Be(2);
-        array.ArrayInfo.Length.Should().Be(0);
-
-        array = (ArraySingleObject)format[3];
-        array.ArrayInfo.ObjectId.Should().Be(3);
-        array.ArrayInfo.Length.Should().Be(0);
-    }
-
-    [Fact]
-    public void ReadHashTableWithStringPair()
-    {
-        BinaryFormattedObject format = new Hashtable()
-        {
-            { "This", "That" }
-        }.SerializeAndParse();
-
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-
-        systemClass.MemberTypeInfo.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.SystemClass, "System.Collections.IComparer"),
-            (BinaryType.SystemClass, "System.Collections.IHashCodeProvider"),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.ObjectArray, null),
-            (BinaryType.ObjectArray, null)
-        });
-
-        systemClass.MemberValues.Should().BeEquivalentTo(new object?[]
-        {
-            0.72f,
-            1,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            3,
-            new MemberReference(2),
-            new MemberReference(3)
-        });
-
-        ArraySingleObject array = (ArraySingleObject)format[2];
-        array.ArrayInfo.ObjectId.Should().Be(2);
-        array.ArrayInfo.Length.Should().Be(1);
-        BinaryObjectString value = (BinaryObjectString)array.ArrayObjects[0];
-        value.ObjectId.Should().Be(4);
-        value.Value.Should().Be("This");
-
-        array = (ArraySingleObject)format[3];
-        array.ArrayInfo.ObjectId.Should().Be(3);
-        array.ArrayInfo.Length.Should().Be(1);
-        value = (BinaryObjectString)array.ArrayObjects[0];
-        value.ObjectId.Should().Be(5);
-        value.Value.Should().Be("That");
-    }
-
-    [Fact]
-    public void ReadHashTableWithRepeatedStrings()
-    {
-        BinaryFormattedObject format = new Hashtable()
-        {
-            { "This", "That" },
-            { "TheOther", "This" },
-            { "That", "This" }
-        }.SerializeAndParse();
-
-        // The collections themselves get ids first before the strings do.
-        // Everything in the second array is a string reference.
-        ArraySingleObject array = (ArraySingleObject)format[3];
-        array.ObjectId.Should().Be(3);
-        array[0].Should().BeOfType<MemberReference>();
-        array[1].Should().BeOfType<MemberReference>();
-        array[2].Should().BeOfType<MemberReference>();
-    }
-
-    [Fact]
-    public void ReadHashTableWithNullValues()
-    {
-        BinaryFormattedObject format = new Hashtable()
-        {
-            { "Yowza", null },
-            { "Youza", null },
-            { "Meeza", null }
-        }.SerializeAndParse();
-
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-
-        systemClass.MemberValues.Should().BeEquivalentTo(new object?[]
-        {
-            0.72f,
-            4,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            7,
-            new MemberReference(2),
-            new MemberReference(3)
-        });
-
-        ArrayRecord array = (ArrayRecord)format[(MemberReference)systemClass.MemberValues[5]];
-
-        array.ArrayInfo.ObjectId.Should().Be(2);
-        array.ArrayInfo.Length.Should().Be(3);
-        BinaryObjectString value = (BinaryObjectString)array.ArrayObjects[0];
-        value.ObjectId.Should().Be(4);
-        value.Value.Should().BeOneOf("Yowza", "Youza", "Meeza");
-
-        array = (ArrayRecord)format[(MemberReference)systemClass["Values"]];
-        array.ArrayInfo.ObjectId.Should().Be(3);
-        array.ArrayInfo.Length.Should().Be(3);
-        array.ArrayObjects[0].Should().BeOfType<ObjectNull>();
-    }
-
-    [Fact]
-    public void ReadObject()
-    {
-        BinaryFormattedObject format = new object().SerializeAndParse();
-        format[1].Should().BeOfType<SystemClassWithMembersAndTypes>();
-    }
-
-    [Fact]
-    public void ReadStruct()
-    {
-        ValueTuple<int> tuple = new(355);
-        BinaryFormattedObject format = tuple.SerializeAndParse();
-        format[1].Should().BeOfType<SystemClassWithMembersAndTypes>();
-    }
-
-    [Fact]
-    public void ReadSimpleSerializableObject()
-    {
-        BinaryFormattedObject format = new SimpleSerializableObject().SerializeAndParse();
-
-        BinaryLibrary library = (BinaryLibrary)format[1];
-        library.LibraryName.Should().Be(typeof(BinaryFormattedObjectTests).Assembly.FullName);
-        library.LibraryId.Should().Be(2);
-
-        ClassWithMembersAndTypes @class = (ClassWithMembersAndTypes)format[2];
-        @class.ObjectId.Should().Be(1);
-        @class.Name.Should().Be(typeof(SimpleSerializableObject).FullName);
-        @class.MemberNames.Should().BeEmpty();
-        @class.LibraryId.Should().Be(2);
-        @class.MemberTypeInfo.Should().BeEmpty();
-
-        format[3].Should().BeOfType<MessageEnd>();
-    }
-
-    [Fact]
-    public void ReadNestedSerializableObject()
-    {
-        BinaryFormattedObject format = new NestedSerializableObject().SerializeAndParse();
-
-        BinaryLibrary library = (BinaryLibrary)format[1];
-        library.LibraryName.Should().Be(typeof(BinaryFormattedObjectTests).Assembly.FullName);
-        library.LibraryId.Should().Be(2);
-
-        ClassWithMembersAndTypes @class = (ClassWithMembersAndTypes)format[2];
-        @class.ObjectId.Should().Be(1);
-        @class.Name.Should().Be(typeof(NestedSerializableObject).FullName);
-        @class.MemberNames.Should().BeEquivalentTo(new[] { "_object", "_meaning" });
-        @class.LibraryId.Should().Be(2);
-        @class.MemberTypeInfo.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Class, new ClassTypeInfo(typeof(SimpleSerializableObject).FullName!, 2)),
-            (BinaryType.Primitive, PrimitiveType.Int32)
-        });
-        @class.MemberValues.Should().BeEquivalentTo(new object?[]
-        {
-            new MemberReference(3),
-            42
-        });
-
-        @class = (ClassWithMembersAndTypes)format[3];
-        @class.ObjectId.Should().Be(3);
-        @class.Name.Should().Be(typeof(SimpleSerializableObject).FullName);
-        @class.MemberNames.Should().BeEmpty();
-        @class.LibraryId.Should().Be(2);
-        @class.MemberTypeInfo.Should().BeEmpty();
-
-        format[4].Should().BeOfType<MessageEnd>();
-    }
-
-    [Fact]
-    public void ReadTwoIntObject()
-    {
-        BinaryFormattedObject format = new TwoIntSerializableObject().SerializeAndParse();
-
-        BinaryLibrary library = (BinaryLibrary)format[1];
-        library.LibraryName.Should().Be(typeof(BinaryFormattedObjectTests).Assembly.FullName);
-        library.LibraryId.Should().Be(2);
-
-        ClassWithMembersAndTypes @class = (ClassWithMembersAndTypes)format[2];
-        @class.ObjectId.Should().Be(1);
-        @class.Name.Should().Be(typeof(TwoIntSerializableObject).FullName);
-        @class.MemberNames.Should().BeEquivalentTo(new[] { "_value", "_meaning" });
-        @class.LibraryId.Should().Be(2);
-        @class.MemberTypeInfo.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.Primitive, PrimitiveType.Int32)
-        });
-
-        @class.MemberValues.Should().BeEquivalentTo(new object?[]
-        {
-            1970,
-            42
-        });
-
-        format[3].Should().BeOfType<MessageEnd>();
-    }
-
-    [Fact]
-    public void ReadRepeatedNestedObject()
-    {
-        BinaryFormattedObject format = new RepeatedNestedSerializableObject().SerializeAndParse();
-        ClassWithMembersAndTypes firstClass = (ClassWithMembersAndTypes)format[3];
-        ClassWithId classWithId = (ClassWithId)format[4];
-        classWithId.MetadataId.Should().Be(firstClass.ObjectId);
-        classWithId.MemberValues.Should().BeEquivalentTo(new object[] { 1970, 42 });
-    }
-
-    [Fact]
-    public void ReadPrimitiveArray()
-    {
-        BinaryFormattedObject format = new int[] { 10, 9, 8, 7 }.SerializeAndParse();
-
-        ArraySinglePrimitive array = (ArraySinglePrimitive)format[1];
-        array.ArrayInfo.Length.Should().Be(4);
-        array.PrimitiveType.Should().Be(PrimitiveType.Int32);
-        array.ArrayObjects.Should().BeEquivalentTo(new object[] { 10, 9, 8, 7 });
-    }
-
-    [Fact]
-    public void ReadStringArray()
-    {
-        BinaryFormattedObject format = new string[] { "Monday", "Tuesday", "Wednesday" }.SerializeAndParse();
-        ArraySingleString array = (ArraySingleString)format[1];
-        array.ArrayInfo.ObjectId.Should().Be(1);
-        array.ArrayInfo.Length.Should().Be(3);
-        BinaryObjectString value = (BinaryObjectString)array.ArrayObjects[0];
-    }
-
-    [Fact]
-    public void ReadStringArrayWithNulls()
-    {
-        BinaryFormattedObject format = new string?[] { "Monday", null, "Wednesday", null, null, null }.SerializeAndParse();
-        ArraySingleString array = (ArraySingleString)format[1];
-        array.ArrayInfo.ObjectId.Should().Be(1);
-        array.ArrayInfo.Length.Should().Be(6);
-        array.ArrayObjects.Should().BeEquivalentTo(new object?[]
-        {
-            new BinaryObjectString(2, "Monday"),
-            ObjectNull.Instance,
-            new BinaryObjectString(3, "Wednesday"),
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            ObjectNull.Instance
-        });
-        BinaryObjectString value = (BinaryObjectString)array.ArrayObjects[0];
-    }
-
-    [Fact]
-    public void ReadDuplicatedStringArray()
-    {
-        BinaryFormattedObject format = new string[] { "Monday", "Tuesday", "Monday" }.SerializeAndParse();
-        ArraySingleString array = (ArraySingleString)format[1];
-        array.ArrayInfo.ObjectId.Should().Be(1);
-        array.ArrayInfo.Length.Should().Be(3);
-        BinaryObjectString value = (BinaryObjectString)array.ArrayObjects[0];
-        MemberReference reference = (MemberReference)array.ArrayObjects[2];
-        reference.IdRef.Should().Be(value.ObjectId);
-    }
-
-    [Fact]
-    public void ReadObjectWithNullableObjects()
-    {
-        BinaryFormattedObject format = new ObjectWithNullableObjects().SerializeAndParse();
-        ClassWithMembersAndTypes classRecord = (ClassWithMembersAndTypes)format[2];
-        BinaryLibrary library = (BinaryLibrary)format[classRecord.LibraryId];
-    }
-
-    [Fact]
-    public void ReadNestedObjectWithNullableObjects()
-    {
-        BinaryFormattedObject format = new NestedObjectWithNullableObjects().SerializeAndParse();
-        ClassWithMembersAndTypes classRecord = (ClassWithMembersAndTypes)format[2];
-        BinaryLibrary library = (BinaryLibrary)format[classRecord.LibraryId];
-    }
-
-    [Serializable]
-    private class SimpleSerializableObject
-    {
-    }
-
-#pragma warning disable IDE0052 // Remove unread private members
-#pragma warning disable IDE0051 // Remove unused private members
-#pragma warning disable CS0414  // Field is assigned but its value is never used
-#pragma warning disable CS0649  // Field is never assigned to, and will always have its default value null
-#pragma warning disable CA1823 // Avoid unused private fields
-    [Serializable]
-    private class ObjectWithNullableObjects
-    {
-        public object? First;
-        public object? Second;
-        public object? Third;
-    }
-
-    [Serializable]
-    private class NestedObjectWithNullableObjects
-    {
-        public ObjectWithNullableObjects? First;
-        public ObjectWithNullableObjects? Second;
-        public ObjectWithNullableObjects? Third = new();
-    }
-
-    [Serializable]
-    private class NestedSerializableObject
-    {
-        private readonly SimpleSerializableObject _object = new();
-        private readonly int _meaning = 42;
-    }
-
-    [Serializable]
-    private class TwoIntSerializableObject
-    {
-        private readonly int _value = 1970;
-        private readonly int _meaning = 42;
-    }
-
-    [Serializable]
-    private class RepeatedNestedSerializableObject
-    {
-        private readonly TwoIntSerializableObject _first = new();
-        private readonly TwoIntSerializableObject _second = new();
-    }
-#pragma warning restore IDE0052 // Remove unread private members
-#pragma warning restore IDE0051 // Remove unused private members
-#pragma warning restore CS0414  // Field is assigned but its value is never used
-#pragma warning restore CS0649  // Field is never assigned to, and will always have its default value null
-#pragma warning restore CA1823 // Avoid unused private fields
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedTypes.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedTypes.cs
deleted file mode 100644
index 746d6ce5f89..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/BinaryFormattedTypes.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.Serialization;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class BinaryFormattedTypes
-{
-    [Theory]
-    [MemberData(nameof(BinaryFormattedTypes_TestData))]
-    public void Types_UseBinaryFormatter(Type type)
-    {
-        bool iSerializable = type.IsAssignableTo(typeof(ISerializable));
-#pragma warning disable SYSLIB0050 // Type or member is obsolete
-        bool serializable = type.IsSerializable;
-#pragma warning restore SYSLIB0050
-
-        Assert.True(iSerializable || serializable, "Type should either implement ISerializable or be marked as [Serializable]");
-
-        var converter = TypeDescriptor.GetConverter(type);
-        Assert.False(
-            converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(typeof(string)),
-            "Type should not be convertable back and forth to string.");
-        Assert.False(
-            converter.CanConvertFrom(typeof(byte[])) && converter.CanConvertTo(typeof(byte[])),
-            "Type should not be convertable back and forth to byte[].");
-    }
-
-    public static TheoryData<Type> BinaryFormattedTypes_TestData => new()
-    {
-        typeof(Hashtable),
-        typeof(ArrayList),
-        typeof(PointF),
-        typeof(RectangleF),
-        typeof(List<string>),
-    };
-
-    [Theory]
-    [MemberData(nameof(NotBinaryFormattedTypes_TestData))]
-    public void Types_DoNotUseBinaryFormatter(Type type)
-    {
-        var converter = TypeDescriptor.GetConverter(type);
-        Assert.True(
-            (converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(typeof(string)))
-            || (converter.CanConvertFrom(typeof(byte[])) && converter.CanConvertTo(typeof(byte[]))),
-            "Type should be convertable back and forth to string or byte[].");
-    }
-
-    public static TheoryData<Type> NotBinaryFormattedTypes_TestData => new()
-    {
-        typeof(Point),
-        typeof(Size),
-        typeof(SizeF),
-        typeof(Rectangle),
-        typeof(Color)
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ClassInfoTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ClassInfoTests.cs
deleted file mode 100644
index 5f5250fdb8f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ClassInfoTests.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class ClassInfoTests
-{
-    private static readonly byte[] s_hashtableClassInfo = new byte[]
-    {
-        0x01, 0x00, 0x00, 0x00, 0x1c, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x43, 0x6f, 0x6c, 0x6c,
-        0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x48, 0x61, 0x73, 0x68, 0x74, 0x61, 0x62, 0x6c,
-        0x65, 0x07, 0x00, 0x00, 0x00, 0x0a, 0x4c, 0x6f, 0x61, 0x64, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72,
-        0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x08, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65,
-        0x72, 0x10, 0x48, 0x61, 0x73, 0x68, 0x43, 0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64,
-        0x65, 0x72, 0x08, 0x48, 0x61, 0x73, 0x68, 0x53, 0x69, 0x7a, 0x65, 0x04, 0x4b, 0x65, 0x79, 0x73,
-        0x06, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73
-    };
-
-    [Fact]
-    public void ClassInfo_ReadHashtable()
-    {
-        using BinaryReader reader = new(new MemoryStream(s_hashtableClassInfo));
-        ClassInfo info = ClassInfo.Parse(reader, out Count memberCount);
-
-        memberCount.Should().Be(7);
-        info.ObjectId.Should().Be(1);
-        info.Name.Should().Be("System.Collections.Hashtable");
-        info.MemberNames.Should().BeEquivalentTo(new[]
-        {
-            "LoadFactor",
-            "Version",
-            "Comparer",
-            "HashCodeProvider",
-            "HashSize",
-            "Keys",
-            "Values"
-        });
-    }
-
-    [Fact]
-    public void ClassInfo_Hashtable_RoundTrip()
-    {
-        using BinaryReader reader = new(new MemoryStream(s_hashtableClassInfo));
-        ClassInfo info = ClassInfo.Parse(reader, out Count memberCount);
-
-        MemoryStream stream = new();
-        BinaryWriter writer = new(stream);
-        info.Write(writer);
-        stream.Position = 0;
-
-        using BinaryReader reader2 = new(stream);
-        info = ClassInfo.Parse(reader2, out memberCount);
-
-        memberCount.Should().Be(7);
-        info.ObjectId.Should().Be(1);
-        info.Name.Should().Be("System.Collections.Hashtable");
-        info.MemberNames.Should().BeEquivalentTo(new[]
-        {
-            "LoadFactor",
-            "Version",
-            "Comparer",
-            "HashCodeProvider",
-            "HashSize",
-            "Keys",
-            "Values"
-        });
-    }
-
-    [Fact]
-    public void MemberTypeInfo_ReadHashtable_TooShort()
-    {
-        MemoryStream stream = new(s_hashtableClassInfo);
-        stream.SetLength(stream.Length - 1);
-        using BinaryReader reader = new(stream);
-        Action action = () => ClassInfo.Parse(reader, out _);
-        action.Should().Throw<EndOfStreamException>();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/CountTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/CountTests.cs
deleted file mode 100644
index 80bbd0c4eb0..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/CountTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class CountTests
-{
-    [Fact]
-    public void CountDoesNotAcceptNegativeValues()
-    {
-        Func<Count> func = () => (Count)(-1);
-        func.Should().Throw<ArgumentOutOfRangeException>();
-    }
-
-    [Fact]
-    public void CountEqualsInt()
-    {
-        ((Count)4).Should().Be(4);
-    }
-
-    [Fact]
-    public void CountEqualsCount()
-    {
-        ((Count)4).Should().Be((Count)4);
-    }
-
-    [Fact]
-    public void CountToStringIsInt()
-    {
-        ((Count)5).ToString().Should().Be("5");
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ExceptionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ExceptionTests.cs
deleted file mode 100644
index 6c88318a557..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ExceptionTests.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class ExceptionTests
-{
-    [Fact]
-    public void NotSupportedException_Parse()
-    {
-        BinaryFormattedObject format = new NotSupportedException().SerializeAndParse();
-        format.RecordCount.Should().Be(3);
-        var systemClass = (SystemClassWithMembersAndTypes)format[1];
-        systemClass.Name.Should().Be(typeof(NotSupportedException).FullName);
-        systemClass.MemberNames.Should().BeEquivalentTo(new string[]
-        {
-            "ClassName",
-            "Message",
-            "Data",
-            "InnerException",
-            "HelpURL",
-            "StackTraceString",
-            "RemoteStackTraceString",
-            "RemoteStackIndex",
-            "ExceptionMethod",
-            "HResult",
-            "Source",
-            "WatsonBuckets"
-        });
-
-        systemClass.MemberTypeInfo.Should().BeEquivalentTo(new (BinaryType, object?)[]
-        {
-            (BinaryType.String, null),
-            (BinaryType.String, null),
-            (BinaryType.SystemClass, typeof(IDictionary).FullName),
-            (BinaryType.SystemClass, typeof(Exception).FullName),
-            (BinaryType.String, null),
-            (BinaryType.String, null),
-            (BinaryType.String, null),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.String, null),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.String, null),
-            (BinaryType.PrimitiveArray, PrimitiveType.Byte)
-        });
-
-        systemClass.MemberValues.Should().BeEquivalentTo(new object[]
-        {
-            new BinaryObjectString(2, "System.NotSupportedException"),
-            new BinaryObjectString(3, "Specified method is not supported."),
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            ObjectNull.Instance,
-            0,
-            ObjectNull.Instance,
-            unchecked((int)0x80131515),
-            ObjectNull.Instance,
-            ObjectNull.Instance
-        });
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/HashTableTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/HashTableTests.cs
deleted file mode 100644
index 6a5189966c6..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/HashTableTests.cs
+++ /dev/null
@@ -1,249 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class HashtableTests
-{
-    [Fact]
-    public void HashTable_GetObjectData()
-    {
-        Hashtable hashtable = new()
-        {
-            { "This", "That" }
-        };
-
-        // The converter isn't used for this scenario and can be a no-op.
-#pragma warning disable SYSLIB0050 // Type or member is obsolete
-        SerializationInfo info = new(typeof(Hashtable), FormatterConverterStub.Instance);
-#pragma warning restore SYSLIB0050
-#pragma warning disable SYSLIB0051 // Type or member is obsolete
-        hashtable.GetObjectData(info, default);
-#pragma warning restore SYSLIB0051
-        info.MemberCount.Should().Be(7);
-
-        var enumerator = info.GetEnumerator();
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("LoadFactor");
-        enumerator.Current.Value.Should().Be(0.72f);
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("Version");
-        enumerator.Current.Value.Should().Be(1);
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("Comparer");
-        enumerator.Current.Value.Should().BeNull();
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("HashCodeProvider");
-        enumerator.Current.Value.Should().BeNull();
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("HashSize");
-        enumerator.Current.Value.Should().Be(3);
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("Keys");
-        enumerator.Current.Value.Should().BeEquivalentTo(new object[] { "This" });
-
-        enumerator.MoveNext().Should().BeTrue();
-        enumerator.Current.Name.Should().Be("Values");
-        enumerator.Current.Value.Should().BeEquivalentTo(new object[] { "That" });
-    }
-
-    [Theory]
-    [MemberData(nameof(Hashtables_TestData))]
-    public void BinaryFormatWriter_WriteHashtables(Hashtable hashtable)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.WritePrimitiveHashtable(stream, hashtable);
-        stream.Position = 0;
-
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-        Hashtable deserialized = (Hashtable)formatter.Deserialize(stream);
-#pragma warning restore SYSLIB0011
-
-        deserialized.Count.Should().Be(hashtable.Count);
-        foreach (var key in hashtable.Keys)
-        {
-            deserialized[key].Should().Be(hashtable[key]);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Hashtables_UnsupportedTestData))]
-    public void BinaryFormatWriter_WriteUnsupportedHashtables(Hashtable hashtable)
-    {
-        using MemoryStream stream = new();
-        Action action = () => BinaryFormatWriter.WritePrimitiveHashtable(stream, hashtable);
-        action.Should().Throw<ArgumentException>();
-    }
-
-    [Theory]
-    [MemberData(nameof(Hashtables_TestData))]
-    public void BinaryFormattedObjectExtensions_TryGetPrimitiveHashtable(Hashtable hashtable)
-    {
-        BinaryFormattedObject format = hashtable.SerializeAndParse();
-        format.TryGetPrimitiveHashtable(out Hashtable? deserialized).Should().BeTrue();
-
-        deserialized!.Count.Should().Be(hashtable.Count);
-        foreach (var key in hashtable.Keys)
-        {
-            deserialized[key].Should().Be(hashtable[key]);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Hashtables_TestData))]
-    public void RoundTripHashtables(Hashtable hashtable)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.WritePrimitiveHashtable(stream, hashtable);
-        stream.Position = 0;
-
-        BinaryFormattedObject format = new(stream);
-        format.TryGetPrimitiveHashtable(out Hashtable? deserialized).Should().BeTrue();
-        deserialized!.Count.Should().Be(hashtable.Count);
-        foreach (var key in hashtable.Keys)
-        {
-            deserialized[key].Should().Be(hashtable[key]);
-        }
-    }
-
-    public static TheoryData<Hashtable> Hashtables_TestData => new()
-    {
-        new Hashtable(),
-        new Hashtable()
-        {
-            { "This", "That" }
-        },
-        new Hashtable()
-        {
-            { "Meaning", 42 }
-        },
-        new Hashtable()
-        {
-            { 42, 42 }
-        },
-        new Hashtable()
-        {
-            { 42, 42 },
-            { 43, 42 }
-        },
-        new Hashtable()
-        {
-            { "Hastings", new DateTime(1066, 10, 14) }
-        },
-        new Hashtable()
-        {
-            { "Decimal", decimal.MaxValue }
-        },
-        new Hashtable()
-        {
-            { "This", "That" },
-            { "TheOther", "This" },
-            { "That", "This" }
-        },
-        new Hashtable()
-        {
-            { "Yowza", null },
-            { "Youza", null },
-            { "Meeza", null }
-        },
-        new Hashtable()
-        {
-            { "Yowza", null },
-            { "Youza", "Binks" },
-            { "Meeza", null }
-        },
-        new Hashtable()
-        {
-            { "Yowza", "Binks" },
-            { "Youza", "Binks" },
-            { "Meeza", null }
-        },
-        new Hashtable()
-        {
-            { decimal.MinValue, decimal.MaxValue },
-            { float.MinValue, float.MaxValue },
-            { DateTime.MinValue, DateTime.MaxValue },
-            { TimeSpan.MinValue, TimeSpan.MaxValue }
-        },
-        // Stress the string interning
-        MakeRepeatedHashtable(50, "Ditto"),
-        MakeRepeatedHashtable(100, "..."),
-        // Cross over into ObjectNullMultiple
-        MakeRepeatedHashtable(255, null),
-        MakeRepeatedHashtable(256, null),
-        MakeRepeatedHashtable(257, null)
-    };
-
-    public static TheoryData<Hashtable> Hashtables_UnsupportedTestData => new()
-    {
-        new Hashtable()
-        {
-            { new object(), new object() }
-        },
-        new Hashtable()
-        {
-            { "Foo", new object() }
-        },
-        new Hashtable()
-        {
-            { "Foo", new Point() }
-        },
-        new Hashtable()
-        {
-            { "Foo", new PointF() }
-        },
-        new Hashtable()
-        {
-            { "Foo", (nint)42 }
-        },
-    };
-
-    private static Hashtable MakeRepeatedHashtable(int countOfEntries, object? value)
-    {
-        Hashtable result = new(countOfEntries);
-        for (int i = 1; i <= countOfEntries; i++)
-        {
-            result.Add($"Entry{i}", value);
-        }
-
-        return result;
-    }
-
-#pragma warning disable SYSLIB0050 // Type or member is obsolete
-    private sealed class FormatterConverterStub : IFormatterConverter
-    {
-        public static IFormatterConverter Instance { get; } = new FormatterConverterStub();
-#pragma warning restore SYSLIB0050
-
-        public object Convert(object value, Type type) => throw new NotImplementedException();
-        public object Convert(object value, TypeCode typeCode) => throw new NotImplementedException();
-        public bool ToBoolean(object value) => throw new NotImplementedException();
-        public byte ToByte(object value) => throw new NotImplementedException();
-        public char ToChar(object value) => throw new NotImplementedException();
-        public DateTime ToDateTime(object value) => throw new NotImplementedException();
-        public decimal ToDecimal(object value) => throw new NotImplementedException();
-        public double ToDouble(object value) => throw new NotImplementedException();
-        public short ToInt16(object value) => throw new NotImplementedException();
-        public int ToInt32(object value) => throw new NotImplementedException();
-        public long ToInt64(object value) => throw new NotImplementedException();
-        public sbyte ToSByte(object value) => throw new NotImplementedException();
-        public float ToSingle(object value) => throw new NotImplementedException();
-        public string? ToString(object value) => throw new NotImplementedException();
-        public ushort ToUInt16(object value) => throw new NotImplementedException();
-        public uint ToUInt32(object value) => throw new NotImplementedException();
-        public ulong ToUInt64(object value) => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ListTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ListTests.cs
deleted file mode 100644
index 230064ba22a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/ListTests.cs
+++ /dev/null
@@ -1,221 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class ListTests
-{
-    [Fact]
-    public void BinaryFormattedObject_ParseEmptyArrayList()
-    {
-        BinaryFormattedObject format = new ArrayList().SerializeAndParse();
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-
-        systemClass.Name.Should().Be(typeof(ArrayList).FullName);
-        systemClass.MemberNames.Should().BeEquivalentTo(new string[] { "_items", "_size", "_version" });
-        systemClass.MemberTypeInfo[0].Should().Be((BinaryType.ObjectArray, null));
-
-        format[2].Should().BeOfType<ArraySingleObject>();
-    }
-
-    [Theory]
-    [MemberData(nameof(ArrayList_Primitive_Data))]
-    public void BinaryFormattedObject_ParsePrimitivesArrayList(object value)
-    {
-        BinaryFormattedObject format = new ArrayList()
-        {
-            value
-        }.SerializeAndParse();
-
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-
-        systemClass.Name.Should().Be(typeof(ArrayList).FullName);
-        systemClass.MemberNames.Should().BeEquivalentTo(new string[] { "_items", "_size", "_version" });
-        systemClass.MemberTypeInfo[0].Should().Be((BinaryType.ObjectArray, null));
-
-        ArraySingleObject array = (ArraySingleObject)format[2];
-        MemberPrimitiveTyped primitve = (MemberPrimitiveTyped)array[0];
-        primitve.Value.Should().Be(value);
-    }
-
-    [Fact]
-    public void BinaryFormattedObject_ParseStringArrayList()
-    {
-        BinaryFormattedObject format = new ArrayList()
-        {
-            "JarJar"
-        }.SerializeAndParse();
-
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-
-        systemClass.Name.Should().Be(typeof(ArrayList).FullName);
-        systemClass.MemberNames.Should().BeEquivalentTo(new string[] { "_items", "_size", "_version" });
-        systemClass.MemberTypeInfo[0].Should().Be((BinaryType.ObjectArray, null));
-
-        ArraySingleObject array = (ArraySingleObject)format[2];
-        BinaryObjectString binaryString = (BinaryObjectString)array[0];
-        binaryString.Value.Should().Be("JarJar");
-    }
-
-    public static TheoryData<object> ArrayList_Primitive_Data => new()
-    {
-        int.MaxValue,
-        uint.MaxValue,
-        long.MaxValue,
-        ulong.MaxValue,
-        short.MaxValue,
-        ushort.MaxValue,
-        byte.MaxValue,
-        sbyte.MaxValue,
-        true,
-        float.MaxValue,
-        double.MaxValue,
-        char.MaxValue,
-        TimeSpan.MaxValue,
-        DateTime.MaxValue,
-        decimal.MaxValue,
-    };
-
-    public static TheoryData<ArrayList> ArrayLists_TestData => new()
-    {
-        new ArrayList(),
-        new ArrayList()
-        {
-            int.MaxValue,
-            uint.MaxValue,
-            long.MaxValue,
-            ulong.MaxValue,
-            short.MaxValue,
-            ushort.MaxValue,
-            byte.MaxValue,
-            sbyte.MaxValue,
-            true,
-            float.MaxValue,
-            double.MaxValue,
-            char.MaxValue,
-            TimeSpan.MaxValue,
-            DateTime.MaxValue,
-            decimal.MaxValue,
-            "You betcha"
-        },
-        new ArrayList() { "Same", "old", "same", "old" }
-    };
-
-    public static TheoryData<ArrayList> ArrayLists_UnsupportedTestData => new()
-    {
-        new ArrayList()
-        {
-            new object(),
-        },
-        new ArrayList()
-        {
-            int.MaxValue,
-            new Point()
-        }
-    };
-
-    [Fact]
-    public void BinaryFormattedObject_ParseEmptyIntList()
-    {
-        BinaryFormattedObject format = new List<int>().SerializeAndParse();
-        SystemClassWithMembersAndTypes classInfo = (SystemClassWithMembersAndTypes)format[1];
-
-        // Note that T types are serialized as the mscorlib type.
-        classInfo.Name.Should().Be(
-            "System.Collections.Generic.List`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]");
-
-        classInfo.ClassInfo.MemberNames.Should().BeEquivalentTo(new string[]
-        {
-            "_items",
-            // This is something that wouldn't be needed if List<T> implemented ISerializable. If we format
-            // we can save any extra unused array spots.
-            "_size",
-            // It is a bit silly that _version gets serialized, it's only use is as a check to see if
-            // the collection is modified while it is being enumerated.
-            "_version"
-        });
-        classInfo.MemberTypeInfo[0].Should().Be((BinaryType.PrimitiveArray, PrimitiveType.Int32));
-        classInfo.MemberTypeInfo[1].Should().Be((BinaryType.Primitive, PrimitiveType.Int32));
-        classInfo.MemberTypeInfo[2].Should().Be((BinaryType.Primitive, PrimitiveType.Int32));
-        classInfo["_items"].Should().BeOfType<MemberReference>();
-        classInfo["_size"].Should().Be(0);
-        classInfo["_version"].Should().Be(0);
-
-        ArraySinglePrimitive array = (ArraySinglePrimitive)format[2];
-        array.Length.Should().Be(0);
-    }
-
-    [Fact]
-    public void BinaryFormattedObject_ParseEmptyStringList()
-    {
-        BinaryFormattedObject format = new List<string>().SerializeAndParse();
-        SystemClassWithMembersAndTypes classInfo = (SystemClassWithMembersAndTypes)format[1];
-        classInfo.ClassInfo.Name.Should().StartWith("System.Collections.Generic.List`1[[System.String,");
-        classInfo.MemberTypeInfo[0].Should().Be((BinaryType.StringArray, null));
-        classInfo["_items"].Should().BeOfType<MemberReference>();
-
-        ArraySingleString array = (ArraySingleString)format[2];
-        array.Length.Should().Be(0);
-    }
-
-    [Theory]
-    [MemberData(nameof(PrimitiveLists_TestData))]
-    public void BinaryFormatWriter_TryWritePrimitiveList(IList list)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.TryWritePrimitiveList(stream, list).Should().BeTrue();
-        stream.Position = 0;
-
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-        IList deserialized = (IList)formatter.Deserialize(stream);
-#pragma warning restore SYSLIB0011
-
-        deserialized.Should().BeEquivalentTo(list);
-    }
-
-    [Theory]
-    [MemberData(nameof(Lists_UnsupportedTestData))]
-    public void BinaryFormatWriter_TryWritePrimitiveList_Unsupported(IList list)
-    {
-        using MemoryStream stream = new();
-        BinaryFormatWriter.TryWritePrimitiveList(stream, list).Should().BeFalse();
-        stream.Position.Should().Be(0);
-    }
-
-    [Theory]
-    [MemberData(nameof(PrimitiveLists_TestData))]
-    public void BinaryFormattedObjectExtensions_TryGetPrimitiveList(IList list)
-    {
-        BinaryFormattedObject format = list.SerializeAndParse();
-        format.TryGetPrimitiveList(out object? deserialized).Should().BeTrue();
-        deserialized.Should().BeEquivalentTo(list);
-    }
-
-    public static TheoryData<IList> PrimitiveLists_TestData => new()
-    {
-        new List<int>(),
-        new List<float>() { 3.14f },
-        new List<float>() { float.NaN, float.PositiveInfinity, float.NegativeInfinity, float.NegativeZero },
-        new List<int>() { 1, 3, 4, 5, 6, 7 },
-        new List<byte>() { 0xDE, 0xAD, 0xBE, 0xEF },
-        new List<char>() { 'a', 'b',  'c', 'd', 'e', 'f', 'g', 'h' },
-        new List<char>() { 'a', '\0',  'c' },
-        new List<string>() { "Believe", "it", "or", "not" },
-        new List<decimal>() { 42m },
-        new List<DateTime>() { new(2000, 1, 1) },
-        new List<TimeSpan>() { new(0, 0, 50) }
-    };
-
-    public static TheoryData<IList> Lists_UnsupportedTestData => new()
-    {
-        new List<object>(),
-        new List<nint>(),
-        new List<(int, int)>()
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/MemberTypeInfoTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/MemberTypeInfoTests.cs
deleted file mode 100644
index fe4099e4745..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/MemberTypeInfoTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class MemberTypeInfoTests
-{
-    private static readonly byte[] s_hashtableMemberInfo = new byte[]
-    {
-        0x00, 0x00, 0x03, 0x03, 0x00, 0x05, 0x05, 0x0b, 0x08, 0x1c, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d,
-        0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x43, 0x6f,
-        0x6d, 0x70, 0x61, 0x72, 0x65, 0x72, 0x24, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x43, 0x6f,
-        0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x48, 0x61, 0x73, 0x68, 0x43,
-        0x6f, 0x64, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x08
-    };
-
-    [Fact]
-    public void MemberTypeInfo_ReadHashtable()
-    {
-        using BinaryReader reader = new(new MemoryStream(s_hashtableMemberInfo));
-        MemberTypeInfo info = MemberTypeInfo.Parse(reader, 7);
-
-        info.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.SystemClass, "System.Collections.IComparer"),
-            (BinaryType.SystemClass, "System.Collections.IHashCodeProvider"),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.ObjectArray, null),
-            (BinaryType.ObjectArray, null)
-        });
-    }
-
-    [Fact]
-    public void MemberTypeInfo_HashtableRoundTrip()
-    {
-        using BinaryReader reader = new(new MemoryStream(s_hashtableMemberInfo));
-        MemberTypeInfo info = MemberTypeInfo.Parse(reader, 7);
-
-        MemoryStream stream = new();
-        BinaryWriter writer = new(stream);
-        info.Write(writer);
-        stream.Position = 0;
-
-        using BinaryReader reader2 = new(stream);
-        info = MemberTypeInfo.Parse(reader2, 7);
-        info.Should().BeEquivalentTo(new (BinaryType Type, object? Info)[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.SystemClass, "System.Collections.IComparer"),
-            (BinaryType.SystemClass, "System.Collections.IHashCodeProvider"),
-            (BinaryType.Primitive, PrimitiveType.Int32),
-            (BinaryType.ObjectArray, null),
-            (BinaryType.ObjectArray, null)
-        });
-    }
-
-    [Fact]
-    public void MemberTypeInfo_ReadHashtable_TooShort()
-    {
-        MemoryStream stream = new(s_hashtableMemberInfo);
-        stream.SetLength(stream.Length - 1);
-        using BinaryReader reader = new(stream);
-        Action action = () => MemberTypeInfo.Parse(reader, 7);
-        action.Should().Throw<EndOfStreamException>();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/NullTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/NullTests.cs
deleted file mode 100644
index b57769c0bb1..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/NullTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class NullTests
-{
-    [Fact]
-    public void ObjectNullMultiple256_ThrowsOverflowOnWrite()
-    {
-        // We read a byte on the way in so there is nothing to check.
-
-        NullRecord.ObjectNullMultiple256 objectNull = new(1000);
-
-        using BinaryWriter writer = new(new MemoryStream());
-        Action action = () => objectNull.Write(writer);
-        action.Should().Throw<OverflowException>();
-    }
-
-    [Fact]
-    public void ObjectNullMultiple256_WritesCorrectly()
-    {
-        NullRecord.ObjectNullMultiple256 objectNull = new(0xCA);
-
-        byte[] buffer = new byte[2];
-        using BinaryWriter writer = new(new MemoryStream(buffer));
-        objectNull.Write(writer);
-        buffer.Should().BeEquivalentTo(new byte[] { (byte)NullRecord.ObjectNullMultiple256.RecordType, 0xCA });
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PointFTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PointFTests.cs
deleted file mode 100644
index ad1a7a42f7e..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PointFTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class PointFTests
-{
-    [Fact]
-    public void PointF_Parse()
-    {
-        BinaryFormattedObject format = new PointF().SerializeAndParse();
-
-        BinaryLibrary binaryLibrary = (BinaryLibrary)format[1];
-        binaryLibrary.LibraryId.Should().Be(2);
-        binaryLibrary.LibraryName.Should().Be("System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
-
-        ClassWithMembersAndTypes classInfo = (ClassWithMembersAndTypes)format[2];
-        classInfo.ObjectId.Should().Be(1);
-        classInfo.Name.Should().Be("System.Drawing.PointF");
-        classInfo.MemberNames.Should().BeEquivalentTo(new string[] { "x", "y" });
-        classInfo.MemberValues.Should().BeEquivalentTo(new object[] { 0.0f, 0.0f });
-        classInfo.MemberTypeInfo.Should().BeEquivalentTo(new[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Single)
-        });
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PrimitiveTypeTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PrimitiveTypeTests.cs
deleted file mode 100644
index 2548a9c368f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/PrimitiveTypeTests.cs
+++ /dev/null
@@ -1,158 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Text;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class PrimitiveTypeTests
-{
-    [Theory]
-    [MemberData(nameof(RoundTrip_Data))]
-    public void WriteReadPrimitiveValue_RoundTrip(byte type, object value)
-    {
-        MemoryStream stream = new();
-        using (BinaryWriter writer = new(stream, Encoding.UTF8, leaveOpen: true))
-        {
-            TestRecord.WritePrimitiveValue(writer, (PrimitiveType)type, value);
-        }
-
-        stream.Position = 0;
-
-        using BinaryReader reader = new(stream);
-        object result = TestRecord.ReadPrimitiveValue(reader, (PrimitiveType)type);
-        result.Should().Be(value);
-    }
-
-    public static TheoryData<byte, object> RoundTrip_Data => new()
-    {
-        { (byte)PrimitiveType.Int64, 0L },
-        { (byte)PrimitiveType.Int64, -1L },
-        { (byte)PrimitiveType.Int64, 1L },
-        { (byte)PrimitiveType.Int64, long.MaxValue },
-        { (byte)PrimitiveType.Int64, long.MinValue },
-        { (byte)PrimitiveType.UInt64, ulong.MaxValue },
-        { (byte)PrimitiveType.UInt64, ulong.MinValue },
-        { (byte)PrimitiveType.Int32, 0 },
-        { (byte)PrimitiveType.Int32, -1 },
-        { (byte)PrimitiveType.Int32, 1 },
-        { (byte)PrimitiveType.Int32, int.MaxValue },
-        { (byte)PrimitiveType.Int32, int.MinValue },
-        { (byte)PrimitiveType.UInt32, uint.MaxValue },
-        { (byte)PrimitiveType.UInt32, uint.MinValue },
-        { (byte)PrimitiveType.Int16, (short)0 },
-        { (byte)PrimitiveType.Int16, (short)-1 },
-        { (byte)PrimitiveType.Int16, (short)1 },
-        { (byte)PrimitiveType.Int16, short.MaxValue },
-        { (byte)PrimitiveType.Int16, short.MinValue },
-        { (byte)PrimitiveType.UInt16, ushort.MaxValue },
-        { (byte)PrimitiveType.UInt16, ushort.MinValue },
-        { (byte)PrimitiveType.SByte, (sbyte)0 },
-        { (byte)PrimitiveType.SByte, (sbyte)-1 },
-        { (byte)PrimitiveType.SByte, (sbyte)1 },
-        { (byte)PrimitiveType.SByte, sbyte.MaxValue },
-        { (byte)PrimitiveType.SByte, sbyte.MinValue },
-        { (byte)PrimitiveType.Byte, byte.MinValue },
-        { (byte)PrimitiveType.Byte, byte.MaxValue },
-        { (byte)PrimitiveType.Boolean, true },
-        { (byte)PrimitiveType.Boolean, false },
-        { (byte)PrimitiveType.Single, 0.0f },
-        { (byte)PrimitiveType.Single, -1.0f },
-        { (byte)PrimitiveType.Single, 1.0f },
-        { (byte)PrimitiveType.Single, float.MaxValue },
-        { (byte)PrimitiveType.Single, float.MinValue },
-        { (byte)PrimitiveType.Single, float.NegativeZero },
-        { (byte)PrimitiveType.Single, float.NaN },
-        { (byte)PrimitiveType.Single, float.NegativeInfinity },
-        { (byte)PrimitiveType.Double, 0.0d },
-        { (byte)PrimitiveType.Double, -1.0d },
-        { (byte)PrimitiveType.Double, 1.0d },
-        { (byte)PrimitiveType.Double, double.MaxValue },
-        { (byte)PrimitiveType.Double, double.MinValue },
-        { (byte)PrimitiveType.Double, double.NegativeZero },
-        { (byte)PrimitiveType.Double, double.NaN },
-        { (byte)PrimitiveType.Double, double.NegativeInfinity },
-        { (byte)PrimitiveType.TimeSpan, TimeSpan.MinValue },
-        { (byte)PrimitiveType.TimeSpan, TimeSpan.MaxValue },
-        { (byte)PrimitiveType.DateTime, DateTime.MinValue },
-        { (byte)PrimitiveType.DateTime, DateTime.MaxValue },
-    };
-
-    [Theory]
-    [MemberData(nameof(Primitive_Data))]
-    public void PrimitiveTypeMemberName(object value)
-    {
-        BinaryFormattedObject format = value.SerializeAndParse();
-        SystemClassWithMembersAndTypes systemClass = (SystemClassWithMembersAndTypes)format[1];
-        systemClass.MemberNames[0].Should().Be("m_value");
-        systemClass.MemberValues.Count.Should().Be(1);
-    }
-
-    [Theory]
-    [MemberData(nameof(Primitive_Data))]
-    [MemberData(nameof(Primitive_ExtendedData))]
-    public void BinaryFormatWriter_WritePrimitive(object value)
-    {
-        MemoryStream stream = new();
-        BinaryFormatWriter.WritePrimitive(stream, value);
-        stream.Position = 0;
-
-        using BinaryFormatterScope formatterScope = new(enable: true);
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        object deserialized = formatter.Deserialize(stream);
-        deserialized.Should().Be(value);
-    }
-
-    [Theory]
-    [MemberData(nameof(Primitive_Data))]
-    [MemberData(nameof(Primitive_ExtendedData))]
-    public void BinaryFormattedObject_ReadPrimitive(object value)
-    {
-        BinaryFormattedObject formattedObject = value.SerializeAndParse();
-        formattedObject.TryGetPrimitiveType(out object? deserialized).Should().BeTrue();
-        deserialized.Should().Be(value);
-    }
-
-    public static TheoryData<object> Primitive_Data => new()
-    {
-        int.MaxValue,
-        uint.MaxValue,
-        long.MaxValue,
-        ulong.MaxValue,
-        short.MaxValue,
-        ushort.MaxValue,
-        byte.MaxValue,
-        sbyte.MaxValue,
-        true,
-        float.MaxValue,
-        double.MaxValue,
-        char.MaxValue
-    };
-
-    public static TheoryData<object> Primitive_ExtendedData => new()
-    {
-        TimeSpan.MaxValue,
-        DateTime.MaxValue,
-        decimal.MaxValue,
-        (nint)1918,
-        (nuint)2020,
-        "Roundabout"
-    };
-
-    internal class TestRecord : Record
-    {
-        public static void WritePrimitiveValue(BinaryWriter writer, PrimitiveType type, object value)
-            => WritePrimitiveType(writer, type, value);
-
-        public static object ReadPrimitiveValue(BinaryReader reader, PrimitiveType type)
-            => ReadPrimitiveType(reader, type);
-
-        public override void Write(BinaryWriter writer)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/RecordMapTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/RecordMapTests.cs
deleted file mode 100644
index 5a7e529b149..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/RecordMapTests.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class RecordMapTests
-{
-    private class Record : IRecord
-    {
-        void IBinaryWriteable.Write(BinaryWriter writer) { }
-    }
-
-    [Fact]
-    public void RecordMap_CannotAddSameIndexTwice()
-    {
-        RecordMap map = new();
-        Action action = () => map[1] = new Record();
-        action();
-        action.Should().Throw<ArgumentException>();
-    }
-
-    [Fact]
-    public void RecordMap_GetMissingThrowsKeyNotFound()
-    {
-        RecordMap map = new();
-        Func<object> func = () => map[0];
-        func.Should().Throw<KeyNotFoundException>();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/StringRecordsCollectionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/StringRecordsCollectionTests.cs
deleted file mode 100644
index 36c83e59f39..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/StringRecordsCollectionTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class StringRecordsCollectionTests
-{
-    [Fact]
-    public void BasicFunctionality()
-    {
-        StringRecordsCollection collection = new(currentId: 1);
-        IRecord record = collection.GetStringRecord("Foo");
-        collection.CurrentId.Should().Be(2);
-        record.Should().BeOfType<BinaryObjectString>();
-        ((BinaryObjectString)record).ObjectId.Should().Be(1);
-
-        record = collection.GetStringRecord("Foo");
-        collection.CurrentId.Should().Be(2);
-        record.Should().BeOfType<MemberReference>();
-        ((MemberReference)record).IdRef.Should().Be(1);
-
-        record = collection.GetStringRecord("Bar");
-        collection.CurrentId.Should().Be(3);
-        record.Should().BeOfType<BinaryObjectString>();
-        ((BinaryObjectString)record).ObjectId.Should().Be(2);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/SystemDrawingTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/SystemDrawingTests.cs
deleted file mode 100644
index 3798293bfa0..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/BinaryFormat/SystemDrawingTests.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class SystemDrawingTests
-{
-    [Fact]
-    public void PointF_Parse()
-    {
-        BinaryFormattedObject format = new PointF().SerializeAndParse();
-
-        BinaryLibrary binaryLibrary = (BinaryLibrary)format[1];
-        binaryLibrary.LibraryId.Should().Be(2);
-        binaryLibrary.LibraryName.ToString().Should().Be("System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
-
-        ClassWithMembersAndTypes classInfo = (ClassWithMembersAndTypes)format[2];
-        classInfo.ObjectId.Should().Be(1);
-        classInfo.Name.Should().Be("System.Drawing.PointF");
-        classInfo.MemberNames.Should().BeEquivalentTo(new string[] { "x", "y" });
-        classInfo.MemberValues.Should().BeEquivalentTo(new object[] { 0.0f, 0.0f });
-        classInfo.MemberTypeInfo.Should().BeEquivalentTo(new[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Single)
-        });
-    }
-
-    [Fact]
-    public void RectangleF_Parse()
-    {
-        BinaryFormattedObject format = new RectangleF().SerializeAndParse();
-
-        BinaryLibrary binaryLibrary = (BinaryLibrary)format[1];
-        binaryLibrary.LibraryId.Should().Be(2);
-        binaryLibrary.LibraryName.ToString().Should().Be("System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
-
-        ClassWithMembersAndTypes classInfo = (ClassWithMembersAndTypes)format[2];
-        classInfo.ObjectId.Should().Be(1);
-        classInfo.Name.Should().Be("System.Drawing.RectangleF");
-        classInfo.MemberNames.Should().BeEquivalentTo(new string[] { "x", "y", "width", "height" });
-        classInfo.MemberValues.Should().BeEquivalentTo(new object[] { 0.0f, 0.0f, 0.0f, 0.0f });
-        classInfo.MemberTypeInfo.Should().BeEquivalentTo(new[]
-        {
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Single),
-            (BinaryType.Primitive, PrimitiveType.Single)
-        });
-    }
-
-    public static TheoryData<object> SystemDrawing_TestData => new()
-    {
-        new PointF(),
-        new RectangleF()
-    };
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextHdcScopeTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextHdcScopeTests.cs
deleted file mode 100644
index 9783097eec3..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextHdcScopeTests.cs
+++ /dev/null
@@ -1,341 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using Moq;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DeviceContextHdcScopeTests
-{
-    [Fact]
-    public unsafe void CreateWithGraphicsBasedOnImageAppliesRequestedParameters()
-    {
-        using Bitmap b = new Bitmap(10, 10);
-        using Graphics g = Graphics.FromImage(b);
-
-        Rectangle clipRectangle = new Rectangle(1, 1, 5, 5);
-        using Region r = new Region(clipRectangle);
-        g.Clip = r;
-
-        Matrix transform = new Matrix();
-        transform.Translate(1.0f, 2.0f);
-        g.Transform = transform;
-
-        // Just the translation transform
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.TranslateTransform))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(1, 2), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(new Rectangle(-1, -2, 10, 10), (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-        }
-
-        // Just the clipping
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.Clipping))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(0, 0), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(clipRectangle, (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-        }
-
-        // Both
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.All))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(1, 2), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(new Rectangle(0, -1, 5, 5), (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-        }
-
-        // Nothing
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.None))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(0, 0), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(new Rectangle(0, 0, 10, 10), (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-        }
-
-        // Validating we've unlocked the graphics object
-        g.DrawLine(Pens.DarkBlue, default, default);
-    }
-
-    [Fact]
-    public unsafe void CreateWithGraphicsBasedOnHdcAppliesRequestedParameters()
-    {
-        using var hdc = GetDcScope.ScreenDC;
-        RECT originalClipRect = default;
-        RegionType originalRegionType = (RegionType)PInvoke.GetClipBox(hdc, &originalClipRect);
-        Point originalOrigin = default;
-        PInvoke.GetViewportOrgEx(hdc, &originalOrigin);
-
-        using Graphics g = Graphics.FromHdcInternal(hdc);
-
-        Rectangle clipRectangle = new Rectangle(1, 1, 5, 5);
-        using Region r = new Region(clipRectangle);
-        g.Clip = r;
-
-        Matrix transform = new Matrix();
-        transform.Translate(1.0f, 2.0f);
-        g.Transform = transform;
-
-        // Just the translation transform
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.TranslateTransform))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(1, 2), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(originalRegionType, regionType);
-            Rectangle expectedClipRect = originalClipRect;
-            expectedClipRect.X -= 1;
-            expectedClipRect.Y -= 2;
-            Assert.Equal(expectedClipRect, (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-            Assert.Equal(hdc, scope.HDC);
-        }
-
-        // Should be in original state
-        RECT currentClipRect = default;
-        PInvoke.GetClipBox(hdc, &currentClipRect);
-        Point currentOrigin = default;
-        PInvoke.GetViewportOrgEx(hdc, &currentOrigin);
-        Assert.Equal(originalClipRect, currentClipRect);
-        Assert.Equal(originalOrigin, currentOrigin);
-
-        // Just the clipping
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.Clipping))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(0, 0), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(clipRectangle, (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-            Assert.Equal(hdc, scope.HDC);
-        }
-
-        // Should be in original state
-        currentClipRect = default;
-        PInvoke.GetClipBox(hdc, &currentClipRect);
-        PInvoke.GetViewportOrgEx(hdc, &currentOrigin);
-        Assert.Equal(originalClipRect, currentClipRect);
-        Assert.Equal(originalOrigin, currentOrigin);
-
-        // Both
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.All))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(1, 2), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(RegionType.SIMPLEREGION, regionType);
-            Assert.Equal(new Rectangle(0, -1, 5, 5), (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-            Assert.Equal(hdc, scope.HDC);
-        }
-
-        // Should be in original state
-        currentClipRect = default;
-        PInvoke.GetClipBox(hdc, &currentClipRect);
-        PInvoke.GetViewportOrgEx(hdc, &currentOrigin);
-        Assert.Equal(originalClipRect, currentClipRect);
-        Assert.Equal(originalOrigin, currentOrigin);
-
-        // Nothing
-        using (var scope = new DeviceContextHdcScope(g, ApplyGraphicsProperties.None))
-        {
-            Point origin = default;
-            PInvoke.GetViewportOrgEx(scope, &origin);
-            Assert.Equal(new Point(0, 0), origin);
-
-            RECT clipRect = default;
-            RegionType regionType = (RegionType)PInvoke.GetClipBox(scope, &clipRect);
-            Assert.Equal(originalRegionType, regionType);
-            Assert.Equal((Rectangle)originalClipRect, (Rectangle)clipRect);
-
-            Assert.Equal(g, scope.DeviceContext);
-            Assert.Equal(hdc, scope.HDC);
-        }
-
-        // Should be in original state
-        currentClipRect = default;
-        PInvoke.GetClipBox(hdc, &currentClipRect);
-        PInvoke.GetViewportOrgEx(hdc, &currentOrigin);
-        Assert.Equal(originalClipRect, currentClipRect);
-        Assert.Equal(originalOrigin, currentOrigin);
-
-        // Validating we've unlocked the graphics object
-        g.DrawLine(Pens.DarkBlue, default, default);
-    }
-
-    [Theory]
-    [InlineData((int)ApplyGraphicsProperties.TranslateTransform)]
-    [InlineData((int)ApplyGraphicsProperties.Clipping)]
-    [InlineData((int)ApplyGraphicsProperties.All)]
-    [InlineData((int)ApplyGraphicsProperties.None)]
-    public void CreateFromCleanIGraphicsHdcProviderDoesNotCreateGraphics(int apply)
-    {
-        using var hdc = GetDcScope.ScreenDC;
-        var mockHdcProvider = new Mock<IGraphicsHdcProvider>();
-        var mockIDeviceContext = mockHdcProvider.As<IDeviceContext>();
-        mockHdcProvider
-            .Setup(p => p.IsGraphicsStateClean)
-            .Returns(true);
-        mockHdcProvider
-            .Setup(p => p.GetHDC())
-            .Returns(hdc);
-
-        using (var scope = new DeviceContextHdcScope(mockIDeviceContext.Object, (ApplyGraphicsProperties)apply))
-        {
-            Assert.Equal(hdc, scope.HDC);
-            Assert.Equal(mockIDeviceContext.Object, scope.DeviceContext);
-
-            mockHdcProvider.VerifyGet(p => p.IsGraphicsStateClean, Times.AtLeastOnce());
-            mockHdcProvider.Verify(p => p.GetHDC(), Times.Once());
-            mockHdcProvider.VerifyNoOtherCalls();
-            mockIDeviceContext.VerifyNoOtherCalls();
-        }
-
-        // If we didn't create a graphics there is no need to release the HDC
-        mockHdcProvider.VerifyNoOtherCalls();
-        mockIDeviceContext.VerifyNoOtherCalls();
-    }
-
-    [Theory]
-    [InlineData((int)ApplyGraphicsProperties.TranslateTransform)]
-    [InlineData((int)ApplyGraphicsProperties.Clipping)]
-    [InlineData((int)ApplyGraphicsProperties.All)]
-    public void CreateFromDirtyIGraphicsHdcProviderCreatesGraphics(int apply)
-    {
-        using Bitmap b = new Bitmap(10, 10);
-        using Graphics g = Graphics.FromImage(b);
-
-        HDC mockHdc = new HDC((IntPtr)1234);
-        var mockHdcProvider = new Mock<IGraphicsHdcProvider>();
-        var mockIDeviceContext = mockHdcProvider.As<IDeviceContext>();
-        mockHdcProvider
-            .Setup(p => p.IsGraphicsStateClean)
-            .Returns(false);
-        mockHdcProvider
-            .Setup(p => p.GetHDC())
-            .Returns(mockHdc);
-        mockHdcProvider
-            .Setup(p => p.GetGraphics(true))
-            .Returns(g);
-
-        using (var scope = new DeviceContextHdcScope(mockIDeviceContext.Object, (ApplyGraphicsProperties)apply))
-        {
-            Assert.NotEqual(mockHdc, scope.HDC);
-            Assert.Equal(g, scope.DeviceContext);
-
-            mockHdcProvider.VerifyGet(p => p.IsGraphicsStateClean, Times.AtLeastOnce());
-            mockHdcProvider.Verify(p => p.GetGraphics(true), Times.Once());
-            mockHdcProvider.VerifyNoOtherCalls();
-            mockIDeviceContext.VerifyNoOtherCalls();
-        }
-
-        // The graphics object itself will be called to release
-        mockHdcProvider.VerifyNoOtherCalls();
-        mockIDeviceContext.VerifyNoOtherCalls();
-
-        // Validating we've unlocked the graphics object
-        g.DrawLine(Pens.DarkBlue, default, default);
-    }
-
-    [Fact]
-    public void CreateFromDirtyIGraphicsHdcProviderDoesNotCreateGraphics()
-    {
-        // If we don't request to apply properties, there is no need to get the graphics.
-
-        using var hdc = GetDcScope.ScreenDC;
-        var mockHdcProvider = new Mock<IGraphicsHdcProvider>();
-        var mockIDeviceContext = mockHdcProvider.As<IDeviceContext>();
-        mockHdcProvider
-            .Setup(p => p.IsGraphicsStateClean)
-            .Returns(false);
-        mockHdcProvider
-            .Setup(p => p.GetHDC())
-            .Returns(hdc);
-
-        using (var scope = new DeviceContextHdcScope(mockIDeviceContext.Object, ApplyGraphicsProperties.None))
-        {
-            Assert.Equal(hdc, scope.HDC);
-            Assert.Equal(mockIDeviceContext.Object, scope.DeviceContext);
-
-            mockHdcProvider.VerifyGet(p => p.IsGraphicsStateClean, Times.AtLeastOnce());
-            mockHdcProvider.Verify(p => p.GetHDC(), Times.Once());
-            mockHdcProvider.VerifyNoOtherCalls();
-            mockIDeviceContext.VerifyNoOtherCalls();
-        }
-
-        // We don't release anything as we haven't locked a Graphics object
-        mockHdcProvider.VerifyNoOtherCalls();
-        mockIDeviceContext.VerifyNoOtherCalls();
-    }
-
-    [Theory]
-    [InlineData((int)ApplyGraphicsProperties.TranslateTransform)]
-    [InlineData((int)ApplyGraphicsProperties.Clipping)]
-    [InlineData((int)ApplyGraphicsProperties.All)]
-    [InlineData((int)ApplyGraphicsProperties.None)]
-    public void CreateFromIDeviceContext(int apply)
-    {
-        using var hdc = GetDcScope.ScreenDC;
-        var mockIDeviceContext = new Mock<IDeviceContext>();
-        mockIDeviceContext
-            .Setup(p => p.GetHdc())
-            .Returns(hdc);
-        mockIDeviceContext
-            .Setup(p => p.ReleaseHdc());
-
-        using (var scope = new DeviceContextHdcScope(mockIDeviceContext.Object, (ApplyGraphicsProperties)apply))
-        {
-            Assert.Equal(hdc, scope.HDC);
-            Assert.Equal(mockIDeviceContext.Object, scope.DeviceContext);
-
-            mockIDeviceContext.Verify(p => p.GetHdc(), Times.Once);
-            mockIDeviceContext.VerifyNoOtherCalls();
-        }
-
-        mockIDeviceContext.Verify(p => p.ReleaseHdc(), Times.Once);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextScopeTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextScopeTests.cs
deleted file mode 100644
index 2db959c4ef3..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/DeviceContextScopeTests.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Runtime.InteropServices;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DeviceContextScopeTests
-{
-    [DllImport(Libraries.Gdi32, SetLastError = true, ExactSpelling = true)]
-    private static extern int GetRandomRgn(HDC hdc, HRGN hrgn, int i);
-
-    [Fact]
-    public unsafe void Scope_ApplyGraphicsProperties()
-    {
-        // Create a bitmap using the screen's stats
-        using PInvoke.CreateDcScope dcScope = new(default);
-        using PInvoke.CreateBitmapScope bitmapScope = new(dcScope, 20, 20);
-        PInvoke.SelectObject(dcScope, bitmapScope);
-
-        // Select a clipping region into the DC
-        using var dcRegion = new PInvoke.RegionScope(2, 1, 4, 7);
-        RegionType type = (RegionType)PInvoke.SelectClipRgn(dcScope, dcRegion);
-        Assert.Equal(RegionType.SIMPLEREGION, type);
-
-        using var test = new PInvoke.RegionScope(0, 0, 0, 0);
-        int result = GetRandomRgn(dcScope, test, 1);
-        RECT rect2 = default;
-        type = (RegionType)PInvoke.GetRgnBox(test, &rect2);
-
-        // Create a Graphics object and set it's clipping region
-        using Graphics graphics = dcScope.CreateGraphics();
-        using Region oldRegion = graphics.Clip;
-
-        // The existing region should be infinite (no clipping)
-        Assert.True(oldRegion.IsInfinite(graphics));
-
-        // Add a new region and transform
-        using Region region = new Region(new Rectangle(1, 1, 2, 3));
-        graphics.Clip = region;
-        graphics.Transform = new Matrix(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f);
-
-        using var hdcScope = new DeviceContextHdcScope(graphics);
-        using var regionScope = new PInvoke.RegionScope(hdcScope);
-        Assert.False(regionScope.IsNull);
-        RECT rect = default;
-        type = (RegionType)PInvoke.GetRgnBox(regionScope, &rect);
-
-        // Our clipping region should be the intersection
-        Assert.Equal(new Rectangle(2, 1, 1, 3), (Rectangle)rect);
-    }
-
-    [Fact]
-    public void Graphics_HdcStatePersistence()
-    {
-        // Create a bitmap using the screen's stats
-        using PInvoke.CreateDcScope dcScope = new(default);
-        using PInvoke.CreateBitmapScope bitmapScope = new(dcScope, 20, 20);
-        HDC_MAP_MODE originalMapMode = (HDC_MAP_MODE)PInvoke.SetMapMode(dcScope, HDC_MAP_MODE.MM_HIMETRIC);
-        PInvoke.SelectObject(dcScope, bitmapScope);
-
-        using PInvoke.CreateBrushScope blueBrush = new(Color.Blue);
-        using PInvoke.CreateBrushScope redBrush = new(Color.Red);
-        PInvoke.SelectObject(dcScope, blueBrush);
-
-        using Graphics graphics = dcScope.CreateGraphics();
-        HGDIOBJ current = PInvoke.GetCurrentObject(dcScope, OBJ_TYPE.OBJ_BRUSH);
-
-        HDC_MAP_MODE currentMode = (HDC_MAP_MODE)PInvoke.GetMapMode(dcScope);
-        Assert.Equal(HDC_MAP_MODE.MM_HIMETRIC, currentMode);
-
-        IntPtr hdc = graphics.GetHdc();
-        currentMode = (HDC_MAP_MODE)PInvoke.SetMapMode(dcScope, HDC_MAP_MODE.MM_TEXT);
-        Assert.Equal(HDC_MAP_MODE.MM_HIMETRIC, currentMode);
-        try
-        {
-            // We get the same HDC out
-            Assert.Equal(dcScope.HDC, (HDC)hdc);
-            current = PInvoke.GetCurrentObject(dcScope, OBJ_TYPE.OBJ_BRUSH);
-            Assert.Equal(blueBrush.HBRUSH, (HBRUSH)current);
-            PInvoke.SelectObject(dcScope, redBrush);
-        }
-        finally
-        {
-            graphics.ReleaseHdc(hdc);
-            currentMode = (HDC_MAP_MODE)PInvoke.GetMapMode(dcScope);
-            Assert.Equal(HDC_MAP_MODE.MM_TEXT, currentMode);
-            current = PInvoke.GetCurrentObject(dcScope, OBJ_TYPE.OBJ_BRUSH);
-
-            graphics.GetHdc();
-            try
-            {
-                currentMode = (HDC_MAP_MODE)PInvoke.GetMapMode(dcScope);
-                Assert.Equal(HDC_MAP_MODE.MM_TEXT, currentMode);
-            }
-            finally
-            {
-                graphics.ReleaseHdc(hdc);
-            }
-        }
-
-        current = PInvoke.GetCurrentObject(dcScope, OBJ_TYPE.OBJ_BRUSH);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlaceTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlaceTests.cs
deleted file mode 100644
index 515dab0b718..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlaceTests.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class FileDialogCustomPlaceTests
-{
-    public static TheoryData<string?> GetStringWithNullTheoryData()
-    {
-        var data = new TheoryData<string?>
-        {
-            null,
-            string.Empty,
-            "reasonable"
-        };
-        return data;
-    }
-
-    [Theory]
-    [MemberData(nameof(GetStringWithNullTheoryData))]
-    public void FileDialogCustomPlace_Ctor_String(string? path)
-    {
-        var place = new FileDialogCustomPlace(path);
-        Assert.Equal(Guid.Empty, place.KnownFolderGuid);
-        Assert.Same(path ?? string.Empty, place.Path);
-    }
-
-    public static TheoryData<Guid> GetGuidTheoryData()
-    {
-        var data = new TheoryData<Guid>
-        {
-            Guid.Empty,
-            Guid.NewGuid()
-        };
-        return data;
-    }
-
-    [Theory]
-    [MemberData(nameof(GetGuidTheoryData))]
-    public void FileDialogCustomPlace_Ctor_Guid(Guid knownFolderGuid)
-    {
-        var place = new FileDialogCustomPlace(knownFolderGuid);
-        Assert.Equal(knownFolderGuid, place.KnownFolderGuid);
-        Assert.Empty(place.Path);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetGuidTheoryData))]
-    public void FileDialogCustomPlace_KnownFolderGuid_Set_GetReturnsExpected(Guid value)
-    {
-        var place = new FileDialogCustomPlace("path")
-        {
-            KnownFolderGuid = value
-        };
-        Assert.Equal(value, place.KnownFolderGuid);
-        Assert.Empty(place.Path);
-
-        // Set same.
-        place.KnownFolderGuid = value;
-        Assert.Equal(value, place.KnownFolderGuid);
-        Assert.Empty(place.Path);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetStringWithNullTheoryData))]
-    public void FileDialogCustomPlace_Path_Set_GetReturnsExpected(string? value)
-    {
-        var place = new FileDialogCustomPlace(Guid.NewGuid())
-        {
-            Path = value
-        };
-        Assert.Same(value ?? string.Empty, place.Path);
-        Assert.Equal(Guid.Empty, place.KnownFolderGuid);
-
-        // Set same.
-        place.Path = value;
-        Assert.Same(value ?? string.Empty, place.Path);
-        Assert.Equal(Guid.Empty, place.KnownFolderGuid);
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new FileDialogCustomPlace("path"), "System.Windows.Forms.FileDialogCustomPlace Path: path KnownFolderGuid: 00000000-0000-0000-0000-000000000000" };
-        yield return new object[] { new FileDialogCustomPlace(new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), "System.Windows.Forms.FileDialogCustomPlace Path:  KnownFolderGuid: 00000001-0002-0003-0405-060708090a0b" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void FileDialogCustomPlace_ToString_Invoke_ReturnsExpected(FileDialogCustomPlace place, string expected)
-    {
-        Assert.Equal(expected, place.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlacesCollectionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlacesCollectionTests.cs
deleted file mode 100644
index a02c26c501b..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/FileDialogCustomPlacesCollectionTests.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class FileDialogCustomPlacesCollectionTests
-{
-    public static TheoryData<string?> GetStringWithNullTheoryData()
-    {
-        var data = new TheoryData<string?>
-        {
-            null,
-            string.Empty,
-            "reasonable"
-        };
-        return data;
-    }
-
-    [Theory]
-    [MemberData(nameof(GetStringWithNullTheoryData))]
-    public void FileDialogCustomPlacesCollection_Add_String_Success(string? path)
-    {
-        var collection = new FileDialogCustomPlacesCollection
-        {
-            path
-        };
-        FileDialogCustomPlace place = Assert.Single(collection);
-        Assert.Equal(Guid.Empty, place.KnownFolderGuid);
-        Assert.Same(path ?? string.Empty, place.Path);
-    }
-
-    public static TheoryData<Guid> GetGuidTheoryData()
-    {
-        var data = new TheoryData<Guid>
-        {
-            Guid.Empty,
-            Guid.NewGuid()
-        };
-        return data;
-    }
-
-    [Theory]
-    [MemberData(nameof(GetGuidTheoryData))]
-    public void FileDialogCustomPlacesCollection_Add_Guid_Success(Guid knownFolderGuid)
-    {
-        var collection = new FileDialogCustomPlacesCollection
-        {
-            knownFolderGuid
-        };
-        FileDialogCustomPlace place = Assert.Single(collection);
-        Assert.Equal(knownFolderGuid, place.KnownFolderGuid);
-        Assert.Empty(place.Path);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/IdTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/IdTests.cs
deleted file mode 100644
index 3dac040b44f..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/IdTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class IdTests
-{
-    [Fact]
-    public void IdSignedAreEquivalent()
-    {
-        ((Id)1).Should().Be((Id)(-1));
-    }
-
-    [Fact]
-    public void IdEqualsInt()
-    {
-        ((Id)4).Should().Be(4);
-    }
-
-    [Fact]
-    public void IdEqualsId()
-    {
-        ((Id)4).Should().Be((Id)4);
-    }
-
-    [Fact]
-    public void IdToStringIsInt()
-    {
-        ((Id)5).ToString().Should().Be("5");
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Internals/ArgumentValidationTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Internals/ArgumentValidationTests.cs
deleted file mode 100644
index 3550d3611e9..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/Internals/ArgumentValidationTests.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ArgumentValidationTests
-{
-    [Fact]
-    public void OrThrowIfNull_ParamIsNull()
-    {
-        object? param = null;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNull());
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNull_ParamIsNull_DifferentParamName()
-    {
-        string paramName = "param2";
-        object? param = null;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNull(paramName));
-        Assert.Equal(paramName, exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNull_ParamIsNotNull()
-    {
-        var param = new object();
-        var variable = param.OrThrowIfNull();
-        Assert.Equal(param, variable);
-    }
-
-    [Fact]
-    public void OrThrowIfNullWithMessage_ParamIsNull()
-    {
-        object? param = null;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullWithMessage(message));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullWithMessage_ParamIsNull_DifferentParamName()
-    {
-        var paramName = "param2";
-        object? param = null;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullWithMessage(message, paramName));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal(paramName, exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullWithMessage_ParamIsNotNull()
-    {
-        var param = new object();
-        var message = "message";
-        var variable = param.OrThrowIfNullWithMessage(message);
-        Assert.Equal(param, variable);
-    }
-
-    [Fact]
-    public void OrThrowIfZero_ParamIsZero()
-    {
-        var param = IntPtr.Zero;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfZero());
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfZero_ParamIsNull_DifferentParamName()
-    {
-        var paramName = "param2";
-        var param = IntPtr.Zero;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfZero(paramName));
-        Assert.Equal(paramName, exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfZero_ParamIsNotZero()
-    {
-        var param = new IntPtr(24);
-        var variable = param.OrThrowIfZero();
-        Assert.Equal(param, variable);
-    }
-
-    [Fact]
-    public void ThrowIfNull_HDC_ParamIsNull()
-    {
-        var param = new HDC(IntPtr.Zero);
-        var exception = Assert.Throws<ArgumentNullException>(() => ArgumentValidation.ThrowIfNull(param));
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNull_HDC_ParamIsNotNull()
-    {
-        var param = new HDC(new IntPtr(24));
-        ArgumentValidation.ThrowIfNull(param);
-    }
-
-    [Fact]
-    public void ThrowIfNull_HDC_DifferentParamName()
-    {
-        var param = new HDC(IntPtr.Zero);
-        var exception = Assert.Throws<ArgumentNullException>(() => ArgumentValidation.ThrowIfNull(param, "paramName"));
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsValid()
-    {
-        var param = "valid";
-        ArgumentValidation.ThrowIfNullOrEmpty(param);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsNull()
-    {
-        string? param = null;
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmpty());
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsEmpty()
-    {
-        string param = string.Empty;
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmpty());
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsValid_DifferentParamName()
-    {
-        string param = "valid";
-        ArgumentValidation.ThrowIfNullOrEmpty(param, "paramName");
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsNull_DifferentParamName()
-    {
-        string? param = null;
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmpty("paramName"));
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmpty_ParamIsEmpty_DifferentParamName()
-    {
-        var param = string.Empty;
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmpty("paramName"));
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsValid()
-    {
-        string param = "valid";
-        param.ThrowIfNullOrEmptyWithMessage("message");
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsNull()
-    {
-        string? param = null;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmptyWithMessage(message));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsEmpty()
-    {
-        var param = string.Empty;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmptyWithMessage(message));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsValid_DifferentParamName()
-    {
-        string param = "valid";
-        param.ThrowIfNullOrEmptyWithMessage("message", "paramName");
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsNull_DifferentParamName()
-    {
-        string? param = null;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmptyWithMessage(message, "paramName"));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void ThrowIfNullOrEmptyWithMessage_ParamIsEmpty_DifferentParamName()
-    {
-        var param = string.Empty;
-        var message = "message";
-        var exception = Assert.Throws<ArgumentNullException>(() => param.ThrowIfNullOrEmptyWithMessage(message, "paramName"));
-        Assert.StartsWith(message, exception.Message);
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsValid()
-    {
-        var param = "valid";
-        var value = param.OrThrowIfNullOrEmpty();
-        Assert.Equal(param, value);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsNull()
-    {
-        string? param = null;
-#pragma warning disable CS8604 // Possible null reference argument.
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullOrEmpty());
-#pragma warning restore CS8604 // Possible null reference argument.
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsEmpty()
-    {
-        var param = string.Empty;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullOrEmpty());
-        Assert.Equal(nameof(param), exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsValid_DifferentParamName()
-    {
-        var param = "valid";
-        var value = param.OrThrowIfNullOrEmpty("paramName");
-        Assert.Equal(param, value);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsNull_DifferentParamName()
-    {
-        string? param = null;
-#pragma warning disable CS8604 // Possible null reference argument.
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullOrEmpty("paramName"));
-#pragma warning restore CS8604 // Possible null reference argument.
-        Assert.Equal("paramName", exception.ParamName);
-    }
-
-    [Fact]
-    public void OrThrowIfNullOrEmpty_ParamIsEmpty_DifferentParamName()
-    {
-        var param = string.Empty;
-        var exception = Assert.Throws<ArgumentNullException>(() => _ = param.OrThrowIfNullOrEmpty("paramName"));
-        Assert.Equal("paramName", exception.ParamName);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/LocalAppContextSwitchesTest.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/LocalAppContextSwitchesTest.cs
deleted file mode 100644
index 1fbae5a7a54..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/LocalAppContextSwitchesTest.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the.NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.Versioning;
-using System.Windows.Forms.Primitives;
-
-namespace System.Windows.Forms.Tests;
-
-public class LocalAppContextSwitchesTest
-{
-    private void ResetLocalSwitches(dynamic testAccessor)
-    {
-        testAccessor.s_anchorLayoutV2 = 0;
-        testAccessor.s_scaleTopLevelFormMinMaxSizeForDpi = 0;
-        testAccessor.s_trackBarModernRendering = 0;
-        testAccessor.s_servicePointManagerCheckCrl = 0;
-    }
-
-    [WinFormsTheory]
-    [InlineData(".NETCoreApp,Version=v8.0", true)]
-    [InlineData(".NETCoreApp,Version=v7.0", false)]
-    [InlineData(".NET Framework,Version=v4.8", false)]
-    public void Validate_Default_Switch_Values(string targetFrameworkName, bool expected)
-    {
-        FrameworkName? previousTestTargetFramework = LocalAppContextSwitches.TargetFrameworkName;
-        dynamic testAccessor = typeof(LocalAppContextSwitches).TestAccessor().Dynamic;
-        ResetLocalSwitches(testAccessor);
-
-        try
-        {
-            testAccessor.s_targetFrameworkName = new FrameworkName(targetFrameworkName);
-
-            Assert.Equal(expected, LocalAppContextSwitches.TrackBarModernRendering);
-            Assert.Equal(expected, LocalAppContextSwitches.ScaleTopLevelFormMinMaxSizeForDpi);
-            Assert.Equal(expected, LocalAppContextSwitches.ServicePointManagerCheckCrl);
-        }
-        finally
-        {
-            // Reset target framework name.
-            testAccessor.s_targetFrameworkName = previousTestTargetFramework;
-            ResetLocalSwitches(testAccessor);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/NonNullCollectionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/NonNullCollectionTests.cs
deleted file mode 100644
index 3bb39bb3586..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/NonNullCollectionTests.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class NonNullCollectionTests
-{
-    [Fact]
-    public void NonNullCollection_Constructor_ThrowsWithNull()
-    {
-        Assert.Throws<ArgumentNullException>("items", () => new TestCollection(null!));
-    }
-
-    [Fact]
-    public void NonNullCollection_Constructor_ThrowsWithNullInCollection()
-    {
-        Assert.Throws<ArgumentNullException>("items", () => new TestCollection(new object[] { null! }));
-    }
-
-    [Fact]
-    public void NonNullCollection_Add_ThrowsWithNull()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("item", () => collection.Add(null!));
-    }
-
-    [Fact]
-    public void NonNullCollection_Add_CallsItemAdded()
-    {
-        TestCollection collection = new();
-        object item = new();
-        collection.Add(item);
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(1, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_IListAdd_ThrowsWithNull()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => ((IList)collection).Add(null));
-    }
-
-    [Fact]
-    public void NonNullCollection_IListAdd_CallsItemAdded()
-    {
-        TestCollection collection = new();
-        object item = new();
-        ((IList)collection).Add(item);
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(1, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_Indexer_ThrowsWithNull()
-    {
-        TestCollection collection = new() { new() };
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null!);
-    }
-
-    [Fact]
-    public void NonNullCollection_Indexer_CallsItemAdded()
-    {
-        TestCollection collection = new(new object[] { new() });
-        object item = new();
-        collection[0] = item;
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(2, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_IListIndexer_ThrowsWithNull()
-    {
-        TestCollection collection = new() { new() };
-        Assert.Throws<ArgumentNullException>("value", () => ((IList)collection)[0] = null);
-    }
-
-    [Fact]
-    public void NonNullCollection_IListIndexer_CallsItemAdded()
-    {
-        TestCollection collection = new(new object[] { new() });
-        object item = new();
-        ((IList)collection)[0] = item;
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(2, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_Insert_ThrowsWithNull()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("item", () => collection.Insert(0, null!));
-    }
-
-    [Fact]
-    public void NonNullCollection_Insert_CallsItemAdded()
-    {
-        TestCollection collection = new();
-        object item = new();
-        collection.Insert(0, item);
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(1, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_IListInsert_ThrowsWithNull()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("value", () => ((IList)collection).Insert(0, null));
-    }
-
-    [Fact]
-    public void NonNullCollection_IListInsert_CallsItemAdded()
-    {
-        TestCollection collection = new();
-        object item = new();
-        ((IList)collection).Insert(0, item);
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(1, collection.AddCount);
-    }
-
-    [Fact]
-    public void NonNullCollection_AddRange_ThrowsWithNull()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange(null!));
-    }
-
-    [Fact]
-    public void NonNullCollection_AddRange_ThrowsWithNullInCollection()
-    {
-        TestCollection collection = new();
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange(new object[] { null! }));
-    }
-
-    [Fact]
-    public void NonNullCollection_AddRange_CallsItemAdded()
-    {
-        TestCollection collection = new();
-        object item = new();
-        collection.AddRange(new object[] { item });
-        Assert.Same(item, collection.LastAdded);
-        Assert.Equal(1, collection.AddCount);
-
-        collection.AddRange(new object[] { new(), new(), new() });
-        Assert.Equal(4, collection.AddCount);
-    }
-
-    private class TestCollection : NonNullCollection<object>
-    {
-        public object? LastAdded { get; set; }
-
-        public int AddCount { get; set; }
-
-        public TestCollection()
-        {
-        }
-
-        public TestCollection(IEnumerable<object> items) : base(items)
-        {
-        }
-
-        protected override void ItemAdded(object item)
-        {
-            LastAdded = item;
-            AddCount++;
-            base.ItemAdded(item);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/RefCacheTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/RefCacheTests.cs
deleted file mode 100644
index 23be0e958c4..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/RefCacheTests.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class RefCacheTests
-{
-    [Fact]
-    public void RefCountTests()
-    {
-        var cache = new ObjectCache<object>(5, 10);
-        var firstScope = cache.GetEntry(1);
-        Assert.Equal(1, firstScope.RefCount);
-        object first = firstScope.Object;
-        var secondScope = cache.GetEntry(1);
-        object second = secondScope.Object;
-        Assert.Equal(2, firstScope.RefCount);
-        Assert.Equal(2, secondScope.RefCount);
-        Assert.Same(first, second);
-        firstScope.Dispose();
-        Assert.Equal(1, secondScope.RefCount);
-        secondScope.Dispose();
-        Assert.Equal(0, secondScope.RefCount);
-        using var thirdScope = cache.GetEntry(1);
-        Assert.Equal(1, thirdScope.RefCount);
-        Assert.Same(first, thirdScope.Object);
-    }
-
-    [Fact]
-    public void LimitTests()
-    {
-        var cache = new ObjectCache<DisposalCounter>(2, 4);
-
-        // Fill to the hard limit
-        var firstScope = cache.GetEntry(1);
-        var secondScope = cache.GetEntry(2);
-        var thirdScope = cache.GetEntry(3);
-        var fourthScope = cache.GetEntry(4);
-        Assert.Equal(0, firstScope.Object.DisposeCount);
-        Assert.Equal(0, secondScope.Object.DisposeCount);
-        Assert.Equal(0, thirdScope.Object.DisposeCount);
-        Assert.Equal(0, fourthScope.Object.DisposeCount);
-
-        // New objects shouldn't be cached
-        var fifthScope = cache.GetEntry(5);
-        var sixthScope = cache.GetEntry(5);
-
-        Assert.NotSame(fifthScope.Object, sixthScope.Object);
-
-        // Dispose all scopes
-        firstScope.Dispose();
-        secondScope.Dispose();
-        thirdScope.Dispose();
-        fourthScope.Dispose();
-        fifthScope.Dispose();
-        sixthScope.Dispose();
-
-        Assert.Equal(0, firstScope.Object.DisposeCount);
-        Assert.Equal(0, secondScope.Object.DisposeCount);
-        Assert.Equal(0, thirdScope.Object.DisposeCount);
-        Assert.Equal(0, fourthScope.Object.DisposeCount);
-
-        // As these were never cached they should be disposed
-        Assert.Equal(1, fifthScope.Object.DisposeCount);
-        Assert.Equal(1, sixthScope.Object.DisposeCount);
-
-        using var seventhScope = cache.GetEntry(7);
-
-        // Now that the other scopes are closed, the earliest entries should have been cleaned
-        Assert.Equal(1, firstScope.Object.DisposeCount);
-        Assert.Equal(1, secondScope.Object.DisposeCount);
-        Assert.Equal(0, thirdScope.Object.DisposeCount);
-        Assert.Equal(0, fourthScope.Object.DisposeCount);
-    }
-
-    // Example to show that the entry data can match the object type when it has enough context to match the key
-    internal sealed class IntColorCache : RefCountedCache<Color, Color, int>
-    {
-        public IntColorCache(int softLimit, int hardLimit) : base(softLimit, hardLimit) { }
-
-        protected override CacheEntry CreateEntry(int key, bool cached)
-            => new ColorCacheEntry(Color.FromArgb(key), cached);
-
-        protected override bool IsMatch(int key, CacheEntry data) => key == data.Data.ToArgb();
-
-        private class ColorCacheEntry : CacheEntry
-        {
-            public ColorCacheEntry(Color color, bool cached) : base(color, cached) { }
-            public override Color Object => Data;
-        }
-    }
-
-    public class DisposalCounter : IDisposable
-    {
-        public int DisposeCount;
-        public void Dispose() => DisposeCount++;
-    }
-
-    internal class ObjectCache<T> : RefCountedCache<T, int, int> where T : class, new()
-    {
-        public ObjectCache(int softLimit = 40, int hardLimit = 60) : base(softLimit, hardLimit) { }
-
-        protected override CacheEntry CreateEntry(int key, bool cached) => new ObjectCacheEntry(key, cached);
-        protected override bool IsMatch(int key, CacheEntry data) => key == data.Data;
-
-        protected class ObjectCacheEntry : CacheEntry
-        {
-            private readonly T _object;
-            public ObjectCacheEntry(int value, bool cached) : base(value, cached) => _object = new T();
-            public override T Object => _object;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/SinglyLinkedListTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/SinglyLinkedListTests.cs
deleted file mode 100644
index 8ea9d4d7185..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/System/Windows/Forms/SinglyLinkedListTests.cs
+++ /dev/null
@@ -1,199 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class SinglyLinkedListTests
-{
-    [Fact]
-    public void AddFirst()
-    {
-        var list = new SinglyLinkedList<int>();
-
-        Assert.Equal(0, list.Count);
-        Assert.Null(list.First);
-        Assert.Null(list.Last);
-
-        list.AddFirst(1);
-        Assert.Equal(1, list.Count);
-        Assert.NotNull(list.First);
-        Assert.NotNull(list.Last);
-        Assert.Same(list.First, list.Last);
-        Assert.Null(list.First!.Next);
-        Assert.Equal(1, list.First);
-
-        list.AddFirst(2);
-        Assert.Equal(2, list.Count);
-        Assert.NotNull(list.First);
-        Assert.NotNull(list.Last);
-        Assert.NotSame(list.First, list.Last);
-        Assert.Same(list.First.Next, list.Last);
-        Assert.Null(list.Last!.Next);
-        Assert.Equal(2, list.First);
-        Assert.Equal(1, list.Last);
-    }
-
-    [Fact]
-    public void AddLast()
-    {
-        var list = new SinglyLinkedList<int>();
-
-        Assert.Equal(0, list.Count);
-        Assert.Null(list.First);
-        Assert.Null(list.Last);
-
-        list.AddLast(1);
-        Assert.Equal(1, list.Count);
-        Assert.NotNull(list.First);
-        Assert.NotNull(list.Last);
-        Assert.Same(list.First, list.Last);
-        Assert.Null(list.First!.Next);
-        Assert.Equal(1, list.First);
-
-        list.AddLast(2);
-        Assert.Equal(2, list.Count);
-        Assert.NotNull(list.First);
-        Assert.NotNull(list.Last);
-        Assert.NotSame(list.First, list.Last);
-        Assert.Same(list.First.Next, list.Last);
-        Assert.Null(list.Last!.Next);
-        Assert.Equal(1, list.First);
-        Assert.Equal(2, list.Last);
-    }
-
-    [Fact]
-    public void MoveToFront()
-    {
-        var list = new SinglyLinkedList<int>();
-        list.AddAll(1, 2, 3, 4, 5);
-
-        var enumerator = list.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-        enumerator.MoveCurrentToFront();
-
-        // Should be moved back in front
-        Assert.Null(enumerator.Current);
-        Assert.Equal(5, list.Count);
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(1, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(2, enumerator.Current);
-        enumerator.MoveCurrentToFront();
-        Assert.Equal(1, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(3, enumerator.Current);
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(4, enumerator.Current);
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(5, enumerator.Current);
-
-        enumerator.MoveCurrentToFront();
-        Assert.Equal(4, enumerator.Current);
-
-        Assert.False(enumerator.MoveNext());
-        Assert.Null(enumerator.Current);
-        Assert.Equal(5, list!.First);
-
-        Assert.Equal(new int[] { 5, 2, 1, 3, 4 }, list.WalkToList());
-        Assert.Equal(new int[] { 5, 2, 1, 3, 4 }, list.EnumerateToList());
-    }
-
-    [Fact]
-    public void MoveToFront_InvalidOperations()
-    {
-        var list = new SinglyLinkedList<int>();
-        list.AddFirst(1);
-
-        var enumerator = list.GetEnumerator();
-        Assert.Throws<InvalidOperationException>(() => enumerator.MoveCurrentToFront());
-        Assert.True(enumerator.MoveNext());
-        enumerator.MoveCurrentToFront();
-        Assert.Throws<InvalidOperationException>(() => enumerator.MoveCurrentToFront());
-    }
-
-    [Fact]
-    public void RemoveCurrent()
-    {
-        var list = new SinglyLinkedList<int>();
-        list.AddAll(1, 2, 3, 4, 5);
-
-        var enumerator = list.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-
-        enumerator.RemoveCurrent();
-        Assert.Equal(4, list.Count);
-        Assert.Null(enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(2, enumerator.Current);
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(3, enumerator.Current);
-        enumerator.RemoveCurrent();
-        Assert.Equal(3, list.Count);
-        Assert.Equal(2, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(5, enumerator.Current);
-        enumerator.RemoveCurrent();
-        Assert.Equal(2, list.Count);
-        Assert.Equal(4, enumerator.Current);
-        Assert.False(enumerator.MoveNext());
-        Assert.Null(enumerator.Current);
-
-        Assert.Equal(new int[] { 2, 4 }, list.WalkToList());
-        Assert.Equal(new int[] { 2, 4 }, list.EnumerateToList());
-    }
-
-    [Fact]
-    public void RemoveCurrent_InvalidOperations()
-    {
-        var list = new SinglyLinkedList<int>();
-        list.AddFirst(1);
-        list.AddLast(2);
-
-        var enumerator = list.GetEnumerator();
-        Assert.Throws<InvalidOperationException>(() => enumerator.RemoveCurrent());
-        Assert.True(enumerator.MoveNext());
-        enumerator.RemoveCurrent();
-        Assert.Throws<InvalidOperationException>(() => enumerator.RemoveCurrent());
-    }
-}
-
-internal static class ListExtensions
-{
-    public static void AddAll<T>(this SinglyLinkedList<T> linkedList, params T[] values)
-    {
-        foreach (T value in values)
-        {
-            linkedList.AddLast(value);
-        }
-    }
-
-    public static List<T> WalkToList<T>(this SinglyLinkedList<T> linkedList)
-    {
-        List<T> list = new List<T>(linkedList.Count);
-        var node = linkedList.First;
-        while (node is not null)
-        {
-            list.Add(node);
-            node = node.Next;
-        }
-
-        return list;
-    }
-
-    public static List<T> EnumerateToList<T>(this SinglyLinkedList<T> linkedList)
-    {
-        List<T> list = new List<T>(linkedList.Count);
-        var enumerator = linkedList.GetEnumerator();
-        while (enumerator.MoveNext())
-        {
-            list.Add(enumerator.Current);
-        }
-
-        return list;
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/AgileComPointerTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/AgileComPointerTests.cs
deleted file mode 100644
index a2d8604c64c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/AgileComPointerTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32.System.Com;
-
-namespace System.Windows.Forms.Primitives.Tests.Windows.Win32;
-
-public unsafe class AgileComPointerTests
-{
-    [Fact]
-    public void AgileComPointer_CheckRefCounts()
-    {
-        IStream* stream = ComHelpers.GetComPointer<IStream>(new GlobalInterfaceTableTests.MyStream());
-
-        uint count;
-
-        using (var agileStream = new AgileComPointer<IStream>(stream, takeOwnership: true))
-        {
-            count = stream->AddRef();
-            Assert.Equal(2u, count);
-            using var astream = agileStream.GetInterface();
-        }
-
-        count = stream->Release();
-        Assert.Equal(0u, count);
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/GlobalInterfaceTableTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/GlobalInterfaceTableTests.cs
deleted file mode 100644
index ff3fd1b83aa..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/GlobalInterfaceTableTests.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-
-namespace System.Windows.Forms.Primitives.Tests.Windows.Win32;
-
-public unsafe class GlobalInterfaceTableTests
-{
-    [Fact]
-    public void GlobalInterfaceTable_CheckRefCounts()
-    {
-        using var stream = ComHelpers.TryGetComScope<IStream>(new MyStream(), out HRESULT hr);
-        Assert.True(hr.Succeeded);
-
-        uint count = stream.Value->AddRef();
-        Assert.Equal(2u, count);
-
-        count = stream.Value->Release();
-        Assert.Equal(1u, count);
-
-        uint cookie = GlobalInterfaceTable.RegisterInterface(stream.Value);
-        count = stream.Value->AddRef();
-        // +1 for the AddRef, and +1 for the git registration
-        Assert.Equal(3u, count);
-
-        count = stream.Value->Release();
-        Assert.Equal(2u, count);
-
-        GlobalInterfaceTable.RevokeInterface(cookie);
-        count = stream.Value->AddRef();
-        Assert.Equal(2u, count);
-        stream.Value->Release();
-    }
-
-    internal class MyStream : IStream.Interface, IManagedWrapper<IStream, ISequentialStream>
-    {
-        public unsafe HRESULT Read(void* pv, uint cb, [Optional] uint* pcbRead) => throw new NotImplementedException();
-        public unsafe HRESULT Write(void* pv, uint cb, [Optional] uint* pcbWritten) => throw new NotImplementedException();
-        public unsafe HRESULT Seek(long dlibMove, SeekOrigin dwOrigin, [Optional] ulong* plibNewPosition) => throw new NotImplementedException();
-        public HRESULT SetSize(ulong libNewSize) => throw new NotImplementedException();
-        public unsafe HRESULT CopyTo(IStream* pstm, ulong cb, [Optional] ulong* pcbRead, [Optional] ulong* pcbWritten) => throw new NotImplementedException();
-        public HRESULT Commit(uint grfCommitFlags) => throw new NotImplementedException();
-        public HRESULT Revert() => throw new NotImplementedException();
-        public HRESULT LockRegion(ulong libOffset, ulong cb, uint dwLockType) => throw new NotImplementedException();
-        public HRESULT UnlockRegion(ulong libOffset, ulong cb, uint dwLockType) => throw new NotImplementedException();
-        public unsafe HRESULT Stat(STATSTG* pstatstg, uint grfStatFlag) => throw new NotImplementedException();
-        public unsafe HRESULT Clone(IStream** ppstm) => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/RegionTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/RegionTests.cs
deleted file mode 100644
index c3f3763e10a..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/RegionTests.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Primitives.Tests.Windows.Win32;
-
-public class RegionTests
-{
-    [Fact]
-    public void GetClipRgn_NoRegion()
-    {
-        // Create a bitmap using the screen's stats
-        HDC hdc = PInvoke.CreateCompatibleDC((HDC)default);
-        Assert.False(hdc.IsNull);
-
-        try
-        {
-            HBITMAP hbitmap = PInvoke.CreateCompatibleBitmap(hdc, 20, 20);
-            Assert.False(hdc.IsNull);
-
-            try
-            {
-                PInvoke.SelectObject(hdc, hbitmap);
-                HRGN hregion = PInvoke.CreateRectRgn(0, 0, 0, 0);
-
-                Assert.False(hregion.IsNull);
-                try
-                {
-                    int result = PInvoke.GetClipRgn(hdc, hregion);
-
-                    // We should have no clipping region
-                    Assert.Equal(0, result);
-                }
-                finally
-                {
-                    PInvoke.DeleteObject(hregion);
-                }
-            }
-            finally
-            {
-                PInvoke.DeleteObject(hbitmap);
-            }
-        }
-        finally
-        {
-            PInvoke.DeleteDC(hdc);
-        }
-    }
-
-    [Fact]
-    public void RegionScope_NullWithNoClippingRegion()
-    {
-        // Create a bitmap using the screen's stats
-        HDC hdc = PInvoke.CreateCompatibleDC((HDC)default);
-        Assert.False(hdc.IsNull);
-
-        try
-        {
-            HBITMAP hbitmap = PInvoke.CreateCompatibleBitmap(hdc, 20, 20);
-            Assert.False(hdc.IsNull);
-
-            try
-            {
-                using var hregion = new PInvoke.RegionScope(hdc);
-                Assert.True(hregion.IsNull);
-            }
-            finally
-            {
-                PInvoke.DeleteObject(hbitmap);
-            }
-        }
-        finally
-        {
-            PInvoke.DeleteDC(hdc);
-        }
-    }
-
-    [Fact]
-    public unsafe void RegionScope_GetRegion()
-    {
-        // Create a bitmap using the screen's stats
-        HDC hdc = PInvoke.CreateCompatibleDC((HDC)default);
-        Assert.False(hdc.IsNull);
-
-        try
-        {
-            HBITMAP hbitmap = PInvoke.CreateCompatibleBitmap(hdc, 20, 20);
-            Assert.False(hdc.IsNull);
-
-            try
-            {
-                Rectangle rectangle = new(1, 2, 3, 4);
-                using PInvoke.RegionScope originalRegion = new(rectangle);
-                PInvoke.SelectClipRgn(hdc, originalRegion);
-                using PInvoke.RegionScope retrievedRegion = new(hdc);
-                RECT rect = default;
-                RegionType type = (RegionType)PInvoke.GetRgnBox(retrievedRegion, &rect);
-                Assert.Equal(RegionType.SIMPLEREGION, type);
-                Assert.Equal(rectangle, (Rectangle)rect);
-            }
-            finally
-            {
-                PInvoke.DeleteObject(hbitmap);
-            }
-        }
-        finally
-        {
-            PInvoke.DeleteDC(hdc);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Com/IDispatchTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Com/IDispatchTests.cs
deleted file mode 100644
index 101f6ea00c1..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Com/IDispatchTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-
-namespace Windows.Win32.System.Com.Tests;
-
-[Collection("Sequential")]
-public partial class IDispatchTests
-{
-    [StaFact]
-    public unsafe void IDispatch_GetIDsOfNames_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var picture = IPictureDisp.CreateFromImage(image);
-        Assert.False(picture.IsNull);
-
-        Guid riid = Guid.Empty;
-        fixed (char* width = "Width")
-        fixed (char* other = "Other")
-        {
-            var rgszNames = new PWSTR[] { width, other };
-            var rgDispId = new int[rgszNames.Length];
-            fixed (int* pRgDispId = rgDispId)
-            fixed (PWSTR* pRgszNames = rgszNames)
-            {
-                picture.Value->GetIDsOfNames(&riid, pRgszNames, (uint)rgszNames.Length, PInvoke.GetThreadLocale(), pRgDispId);
-                Assert.Equal(new PWSTR[] { width, other }, rgszNames);
-
-                Assert.Equal(new int[] { (int)PInvoke.DISPID_PICT_WIDTH, PInvoke.DISPID_UNKNOWN }, rgDispId);
-            }
-        }
-    }
-
-    [StaFact]
-    public unsafe void IDispatch_GetTypeInfo_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 16);
-        using var picture = IPictureDisp.CreateFromImage(image);
-        Assert.False(picture.IsNull);
-
-        using ComScope<ITypeInfo> typeInfo = new(null);
-        picture.Value->GetTypeInfo(0, PInvoke.GetThreadLocale(), typeInfo);
-    }
-
-    [StaFact]
-    public unsafe void IDispatch_GetTypeInfoCount_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 16);
-        using var picture = IPictureDisp.CreateFromImage(image);
-        Assert.False(picture.IsNull);
-
-        uint ctInfo = uint.MaxValue;
-        picture.Value->GetTypeInfoCount(&ctInfo);
-        Assert.Equal(1u, ctInfo);
-    }
-
-    [StaFact]
-    public unsafe void IDispatch_Invoke_Invoke_Success()
-    {
-        using var image = new Bitmap(16, 32);
-        using var picture = IPictureDisp.CreateFromImage(image);
-        Assert.False(picture.IsNull);
-
-        using VARIANT varResult = default;
-        HRESULT hr = ((IDispatch*)picture.Value)->TryGetProperty(
-            PInvoke.DISPID_PICT_WIDTH,
-            &varResult,
-            PInvoke.GetThreadLocale());
-        Assert.Equal(HRESULT.S_OK, hr);
-        Assert.Equal(VARENUM.VT_I4, varResult.vt);
-        Assert.Equal(16, GdiHelper.HimetricToPixelY(varResult.data.intVal));
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Ole/ClassPropertyDispatchAdapterTests.cs b/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Ole/ClassPropertyDispatchAdapterTests.cs
deleted file mode 100644
index c1a4a3494cc..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/Windows/Win32/System/Ole/ClassPropertyDispatchAdapterTests.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Variant;
-using static Windows.Win32.System.Ole.FDEX_PROP_FLAGS;
-
-namespace Windows.Win32.System.Ole.Tests;
-
-public unsafe class ClassPropertyDispatchAdapterTests
-{
-    [Fact]
-    public void ClassPropertyDispatchAdapter_SingleClass()
-    {
-        TestClass testClass = new();
-        ClassPropertyDispatchAdapter adapter = new(testClass);
-
-        adapter.TryGetNextDispId(PInvoke.DISPID_STARTENUM, out int result).Should().BeTrue();
-        result.Should().Be(0x10000);
-        adapter.TryGetMemberName(result, out string? name).Should().BeTrue();
-        name.Should().Be("Value");
-        adapter.TryGetMemberProperties(result, out var flags).Should().BeTrue();
-        flags.Should().Be(fdexPropCanGet | fdexPropCanPut | fdexPropCannotPutRef | fdexPropCannotCall | fdexPropCannotConstruct | fdexPropCannotSourceEvents);
-
-        VARIANT parameter = (VARIANT)42;
-        Com.DISPPARAMS dispParams = new()
-        {
-            cArgs = 1,
-            rgvarg = &parameter
-        };
-
-        HRESULT hr = adapter.Invoke(result, 0, Com.DISPATCH_FLAGS.DISPATCH_PROPERTYPUT, &dispParams, null);
-        hr.Succeeded.Should().BeTrue();
-        testClass.Value.Should().Be(42);
-        VARIANT returnValue = default;
-        hr = adapter.Invoke(result, 0, Com.DISPATCH_FLAGS.DISPATCH_PROPERTYGET, &dispParams, &returnValue);
-        hr.Succeeded.Should().BeTrue();
-        ((int)returnValue).Should().Be(42);
-
-        adapter.TryGetNextDispId(result, out result).Should().BeTrue();
-        result.Should().Be(0x10001);
-        adapter.TryGetMemberName(result, out name).Should().BeTrue();
-        name.Should().Be("Name");
-        adapter.TryGetMemberProperties(result, out flags).Should().BeTrue();
-        flags.Should().Be(fdexPropCanGet | fdexPropCannotPut | fdexPropCannotPutRef | fdexPropCannotCall | fdexPropCannotConstruct | fdexPropCannotSourceEvents);
-        hr = adapter.Invoke(result, 0, Com.DISPATCH_FLAGS.DISPATCH_PROPERTYGET, &dispParams, &returnValue);
-        hr.Succeeded.Should().BeTrue();
-        ((BSTR)returnValue).ToStringAndFree().Should().Be("Q");
-
-        adapter.TryGetNextDispId(result, out result).Should().BeTrue();
-        result.Should().Be(0x1);
-        adapter.TryGetMemberName(result, out name).Should().BeTrue();
-        name.Should().Be("Percent");
-    }
-
-    [Fact]
-    public void ClassPropertyDispatchAdapter_ConflictingDispID()
-    {
-        TestClass testClass = new();
-        TestClass2 testClass2 = new();
-
-        ClassPropertyDispatchAdapter adapter = new(testClass, new(testClass2));
-        adapter.TryGetDispID("Percent", out int dispId).Should().BeTrue();
-        dispId.Should().Be(0x10002);
-        adapter.TryGetDispID("CollidingDispId", out dispId).Should().BeTrue();
-        dispId.Should().Be(0x1);
-
-        adapter = new(testClass2, new(testClass));
-        adapter.TryGetDispID("Percent", out dispId).Should().BeTrue();
-        dispId.Should().Be(0x1);
-        adapter.TryGetDispID("CollidingDispId", out dispId).Should().BeTrue();
-        dispId.Should().Be(0x10002);
-    }
-
-    public class TestClass
-    {
-        public int Value { get; set; }
-        public string Name { get; } = "Q";
-
-        [DispId(1)]
-        public float Percent { get; set; }
-    }
-
-    public class TestClass2
-    {
-        [DispId(1)]
-        public int CollidingDispId { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms.Primitives/tests/UnitTests/runtimeconfig.template.json b/src/System.Windows.Forms.Primitives/tests/UnitTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/System.Windows.Forms.Primitives/tests/UnitTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/EnumValidationTests.cs b/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/EnumValidationTests.cs
deleted file mode 100644
index d164c03e558..00000000000
--- a/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/EnumValidationTests.cs
+++ /dev/null
@@ -1,344 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.Reflection;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Xunit;
-
-namespace System.Windows.Forms.PrivateSourceGenerators.Tests;
-
-public class EnumValidationTests
-{
-    [Fact]
-    public void SequentialEnum()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David,
-        Igor,
-        Jeremy,
-        Hugh,
-        Tobias,
-        Olia,
-        Merrie
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 0 && intValue <= 6) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void MultipleCalls_OneValidateMethod()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David,
-        Igor,
-        Jeremy,
-        Hugh,
-        Tobias,
-        Olia,
-        Merrie
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-
-        void N(Names input)
-        {
-            SourceGenerated.EnumValidator.Validate(input, nameof(input));
-        }
-
-        C(Names name)
-        {
-            SourceGenerated.EnumValidator.Validate(name, nameof(name));
-            SourceGenerated.EnumValidator.Validate(name);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 0 && intValue <= 6) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void DuplicateValues()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David = 1,
-        Igor = 2,
-        Jeremy = 2,
-        Hugh = 4,
-        Tobias = 4
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 1 && intValue <= 2) return;
-if (intValue == 4) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void ValuesFromConstants()
-    {
-        string source = @"
-namespace People
-{
-    static class Win32
-    {
-        public const int HResult = 2;
-        public const int E_FAIL = 4;
-    }
-
-    enum Names
-    {
-        David = Win32.HResult,
-        Igor = Win32.E_FAIL,
-        Jeremy = Win32.HResult - 1,
-        Hugh = Win32.E_FAIL + Win32.HResult,
-        Tobias = Hugh
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 1 && intValue <= 2) return;
-if (intValue == 4) return;
-if (intValue == 6) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void NonSequentialEnum()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David = 1,
-        Igor = 7,
-        Jeremy = 6,
-        Hugh = 9,
-        Tobias = 2,
-        Olia = 15,
-        Merrie = 3
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 1 && intValue <= 3) return;
-if (intValue >= 6 && intValue <= 7) return;
-if (intValue == 9) return;
-if (intValue == 15) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void SequentialEnumWithPowersOf2()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David = 1,
-        Igor = 2,
-        Jeremy = 4,
-        Hugh = 8,
-        Tobias = 16,
-        Olia = 32,
-        Merrie = 64
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 1 && intValue <= 2) return;
-if (intValue == 4) return;
-if (intValue == 8) return;
-if (intValue == 16) return;
-if (intValue == 32) return;
-if (intValue == 64) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void SequentialEnumWithPowersOf2_BinaryNotation()
-    {
-        string source = @"
-namespace People
-{
-    enum Names
-    {
-        David =  0b0000001,
-        Igor =   0b0000010,
-        Jeremy = 0b0000100,
-        Hugh =   0b0001000,
-        Tobias = 0b0010000,
-        Olia =   0b0100000,
-        Merrie = 0b1000000
-    }
-
-    class C
-    {
-        void M(Names value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if (intValue >= 1 && intValue <= 2) return;
-if (intValue == 4) return;
-if (intValue == 8) return;
-if (intValue == 16) return;
-if (intValue == 32) return;
-if (intValue == 64) return;";
-
-        VerifyGeneratedMethodLines(source, "People.Names", expected);
-    }
-
-    [Fact]
-    public void FlagsEnum()
-    {
-        string source = @"
-namespace Paint
-{
-    [System.Flags]
-    enum Colours
-    {
-        Red = 1,
-        Green = 2,
-        Blue = 4,
-        Purple = 8
-    }
-
-    class C
-    {
-        void M(Colours value)
-        {
-            SourceGenerated.EnumValidator.Validate(value);
-        }
-    }
-}";
-        string expected =
-@"if ((intValue & 15) == intValue) return;";
-
-        VerifyGeneratedMethodLines(source, "Paint.Colours", expected);
-    }
-
-    private void VerifyGeneratedMethodLines(string source, string expectedEnumName, string expectedBody)
-    {
-        SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source);
-
-        List<MetadataReference> references = new List<MetadataReference>();
-        Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
-        foreach (Assembly assembly in assemblies)
-        {
-            if (!assembly.IsDynamic)
-            {
-                references.Add(MetadataReference.CreateFromFile(assembly.Location));
-            }
-        }
-
-        CSharpCompilation compilation = CSharpCompilation.Create("original", new SyntaxTree[] { syntaxTree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-
-        ISourceGenerator generator = new EnumValidationGenerator().AsSourceGenerator();
-
-        CSharpGeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
-        driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation outputCompilation, out ImmutableArray<Diagnostic> diagnostics);
-        Assert.False(diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error), $"Failed: {diagnostics.FirstOrDefault()?.GetMessage()}");
-
-        string output = outputCompilation.SyntaxTrees.Skip(2).First().ToString();
-
-        List<string> lines = output.Split("\r\n").ToList();
-
-        AssertFirstLineAndRemove(lines, "// <auto-generated />");
-        AssertFirstLineAndRemove(lines, "namespace SourceGenerated");
-        AssertFirstLineAndRemove(lines, "{");
-        AssertFirstLineAndRemove(lines, "internal static partial class EnumValidator");
-        AssertFirstLineAndRemove(lines, "{");
-
-        AssertFirstLineAndRemove(lines, "/// <summary>Validates that the enum value passed in is valid for the enum type.</summary>");
-        AssertFirstLineAndRemove(lines, $"public static void Validate({expectedEnumName} enumToValidate, string parameterName = \"value\")");
-        AssertFirstLineAndRemove(lines, "{");
-        AssertFirstLineAndRemove(lines, "int intValue = (int)enumToValidate;");
-
-        foreach (string line in expectedBody.Split("\r\n"))
-        {
-            AssertFirstLineAndRemove(lines, line.Trim());
-        }
-
-        AssertFirstLineAndRemove(lines, $"ReportEnumValidationError(parameterName, intValue, typeof({expectedEnumName}));");
-
-        AssertFirstLineAndRemove(lines, "}");
-
-        static void AssertFirstLineAndRemove(List<string> lines, string expected)
-        {
-            Assert.True(lines.Count > 0);
-
-            var line = lines[0].Trim();
-            lines.RemoveAt(0);
-            Assert.Equal(expected, line);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/System.Windows.Forms.PrivateSourceGenerators.Tests.csproj b/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/System.Windows.Forms.PrivateSourceGenerators.Tests.csproj
deleted file mode 100644
index 208a5519844..00000000000
--- a/src/System.Windows.Forms.PrivateSourceGenerators/tests/UnitTests/System.Windows.Forms.PrivateSourceGenerators.Tests.csproj
+++ /dev/null
@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="$(MicrosoftCodeAnalysisAnalyzersVersion)">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisCSharpWorkspacesVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\System.Windows.Forms.PrivateSourceGenerators.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/src/AssemblyRef.cs b/src/System.Windows.Forms/src/AssemblyRef.cs
index ab3e532e150..20bcd5297e0 100644
--- a/src/System.Windows.Forms/src/AssemblyRef.cs
+++ b/src/System.Windows.Forms/src/AssemblyRef.cs
@@ -5,7 +5,7 @@ internal static class FXAssembly
 {
     // NB: this must never-ever change to facilitate type-forwarding from
     // .NET Framework, if those are referenced in .NET project.
-    internal const string Version = "4.0.0.0";
+    internal const string Version = "8.0.0.0";
 }
 
 internal static class AssemblyRef
diff --git a/src/System.Windows.Forms/src/Properties/AssemblyInfo.cs b/src/System.Windows.Forms/src/Properties/AssemblyInfo.cs
index 45c3e6510a3..672a3721bdf 100644
--- a/src/System.Windows.Forms/src/Properties/AssemblyInfo.cs
+++ b/src/System.Windows.Forms/src/Properties/AssemblyInfo.cs
@@ -5,6 +5,7 @@
 
 [assembly: System.Runtime.InteropServices.ComVisible(false)]
 
+[assembly: InternalsVisibleTo("WTG.System.Windows.Forms.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
 [assembly: InternalsVisibleTo("System.Windows.Forms.Tests, PublicKey=00000000000000000400000000000000")]
 [assembly: InternalsVisibleTo("System.Windows.Forms.TestUtilities, PublicKey=00000000000000000400000000000000")]
 [assembly: InternalsVisibleTo("System.Windows.Forms.Primitives.TestUtilities, PublicKey=00000000000000000400000000000000")]
diff --git a/src/System.Windows.Forms/src/Resources/SR.resx b/src/System.Windows.Forms/src/Resources/SR.resx
index 87500f3321f..b09c8690821 100644
--- a/src/System.Windows.Forms/src/Resources/SR.resx
+++ b/src/System.Windows.Forms/src/Resources/SR.resx
@@ -5583,6 +5583,84 @@ Stack trace where the illegal operation occurred was:
   <data name="TimerTimerDescr" xml:space="preserve">
     <value>Occurs whenever the specified interval time elapses.</value>
   </data>
+  <data name="ToolBarAppearanceDescr" xml:space="preserve">
+    <value>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</value>
+  </data>
+  <data name="ToolBarAutoSizeDescr" xml:space="preserve">
+    <value>Controls whether the ToolBar will automatically size itself based on Button size.</value>
+  </data>
+  <data name="ToolBarBadToolBarButton" xml:space="preserve">
+    <value>Parameter must be of type ToolBarButton.</value>
+  </data>
+  <data name="ToolBarBorderStyleDescr" xml:space="preserve">
+    <value>Controls what type of border the ToolBar control will have.</value>
+  </data>
+  <data name="ToolBarButtonClickDescr" xml:space="preserve">
+    <value>Occurs whenever a button in the ToolBar is clicked by the user.</value>
+  </data>
+  <data name="ToolBarButtonDropDownDescr" xml:space="preserve">
+    <value>Occurs whenever a button with the DropDownButton style is pressed.</value>
+  </data>
+  <data name="ToolBarButtonEnabledDescr" xml:space="preserve">
+    <value>Controls whether this button responds to user input.</value>
+  </data>
+  <data name="ToolBarButtonImageIndexDescr" xml:space="preserve">
+    <value>Identifies the image displayed on the button.</value>
+  </data>
+  <data name="ToolBarButtonInvalidDropDownMenuType" xml:space="preserve">
+    <value>The drop-down menu for a ToolBarButton must be of type ContextMenu.</value>
+  </data>
+  <data name="ToolBarButtonMenuDescr" xml:space="preserve">
+    <value>The shortcut menu that will appear if this button's style is set to DropDownButton.</value>
+  </data>
+  <data name="ToolBarButtonNotFound" xml:space="preserve">
+    <value>References that a non-existent ToolBarButton has been received.</value>
+  </data>
+  <data name="ToolBarButtonPartialPushDescr" xml:space="preserve">
+    <value>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</value>
+  </data>
+  <data name="ToolBarButtonPushedDescr" xml:space="preserve">
+    <value>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</value>
+  </data>
+  <data name="ToolBarButtonsDescr" xml:space="preserve">
+    <value>The collection of ToolBarButtons that make up this ToolBar.</value>
+  </data>
+  <data name="ToolBarButtonSizeDescr" xml:space="preserve">
+    <value>The size of the buttons on the control if the button contents do not require a larger size.</value>
+  </data>
+  <data name="ToolBarButtonStyleDescr" xml:space="preserve">
+    <value>Indicates what style of ToolBarButton this will be.</value>
+  </data>
+  <data name="ToolBarButtonTextDescr" xml:space="preserve">
+    <value>The caption to be displayed for this button.</value>
+  </data>
+  <data name="ToolBarButtonToolTipTextDescr" xml:space="preserve">
+    <value>The ToolTip text to be displayed for this button.</value>
+  </data>
+  <data name="ToolBarButtonVisibleDescr" xml:space="preserve">
+    <value>Indicates whether this button should be visible.</value>
+  </data>
+  <data name="ToolBarDividerDescr" xml:space="preserve">
+    <value>Controls whether the ToolBar will display a 3-D line at the top of its client area.</value>
+  </data>
+  <data name="ToolBarDropDownArrowsDescr" xml:space="preserve">
+    <value>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</value>
+  </data>
+  <data name="ToolBarImageListDescr" xml:space="preserve">
+    <value>The ImageList from which this ToolBar will get all of the button images.</value>
+  </data>
+  <data name="ToolBarImageSizeDescr" xml:space="preserve">
+    <value>The size of the images within the ToolBar's ImageList.</value>
+  </data>
+  <data name="ToolBarShowToolTipsDescr" xml:space="preserve">
+    <value>Indicates whether ToolTips will be shown for each of the buttons, if available.</value>
+  </data>
+  <data name="ToolBarTextAlignDescr" xml:space="preserve">
+    <value>Controls how the text is positioned relative to the Image in each button.</value>
+  </data>
+  <data name="ToolBarWrappableDescr" xml:space="preserve">
+    <value>Indicates if more than one row of buttons is allowed.</value>
+  </data>
   <data name="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue" xml:space="preserve">
     <value>AllowItemReorder and AllowDrop cannot both be true.</value>
   </data>
@@ -6128,52 +6206,52 @@ Stack trace where the illegal operation occurred was:
   </data>
   <data name="toStringAlt" xml:space="preserve">
     <value>Alt</value>
-	<comment>{Locked="Alt"}</comment>
+    <comment>{Locked="Alt"}</comment>
   </data>
   <data name="toStringBack" xml:space="preserve">
     <value>Back</value>
   </data>
   <data name="toStringControl" xml:space="preserve">
     <value>Ctrl</value>
-	<comment>{Locked=!de; "Ctrl"}</comment>
+    <comment>{Locked=!de; "Ctrl"}</comment>
   </data>
   <data name="toStringDefault" xml:space="preserve">
     <value>(default)</value>
   </data>
   <data name="toStringDelete" xml:space="preserve">
     <value>Del</value>
-	<comment>{Locked=!fr,de,it,es; "Del"}</comment>
+    <comment>{Locked=!fr,de,it,es; "Del"}</comment>
   </data>
   <data name="toStringEnd" xml:space="preserve">
     <value>End</value>
-	<comment>{Locked=!fr,de,it,es; "End"}</comment>
+    <comment>{Locked=!fr,de,it,es; "End"}</comment>
   </data>
   <data name="toStringEnter" xml:space="preserve">
     <value>Enter</value>
-	<comment>{Locked=!fr,de,it,es; "Enter"}</comment>
+    <comment>{Locked=!fr,de,it,es; "Enter"}</comment>
   </data>
   <data name="toStringHome" xml:space="preserve">
     <value>Home</value>
-	<comment>{Locked=!fr,de,es; "Home"}</comment>
+    <comment>{Locked=!fr,de,es; "Home"}</comment>
   </data>
   <data name="toStringInsert" xml:space="preserve">
     <value>Insert</value>
-	<comment>{Locked=!fr,de,it,es,zh-Hant; "Insert"}</comment>
+    <comment>{Locked=!fr,de,it,es,zh-Hant; "Insert"}</comment>
   </data>
   <data name="toStringNone" xml:space="preserve">
     <value>(none)</value>
   </data>
   <data name="toStringPageDown" xml:space="preserve">
     <value>PgDn</value>
-	<comment>{Locked=!fr,de,it,es; "PgDn"}</comment>
+    <comment>{Locked=!fr,de,it,es; "PgDn"}</comment>
   </data>
   <data name="toStringPageUp" xml:space="preserve">
     <value>PgUp</value>
-	<comment>{Locked=!fr,de,it,es; "PgUp"}</comment>
+    <comment>{Locked=!fr,de,it,es; "PgUp"}</comment>
   </data>
   <data name="toStringShift" xml:space="preserve">
     <value>Shift</value>
-	<comment>{Locked=!fr,de,it,es; "Shift"}</comment>
+    <comment>{Locked=!fr,de,it,es; "Shift"}</comment>
   </data>
   <data name="TrackBarAutoSizeDescr" xml:space="preserve">
     <value>Indicates whether the control will resize itself automatically based on a computation of the default scroll bar dimensions.</value>
@@ -6979,4 +7057,418 @@ Stack trace where the illegal operation occurred was:
   <data name="ResourceValueNotFound" xml:space="preserve">
     <value>The resource value '{0}' was not found.</value>
   </data>
+  <data name="DataGridAllowSortingDescr" xml:space="preserve">
+    <value>Indicates whether the grid can be re-sorted by clicking a column header.</value>
+  </data>
+  <data name="DataGridAlternatingBackColorDescr" xml:space="preserve">
+    <value>Indicates the background color of alternating rows for a ledger appearance.</value>
+  </data>
+  <data name="DataGridBackButtonClickDescr" xml:space="preserve">
+    <value>Occurs when the user clicks the Back button on a child table to return to the parent table.</value>
+  </data>
+  <data name="DataGridBackgroundColorDescr" xml:space="preserve">
+    <value>Indicates the color of the DataGrid background.</value>
+  </data>
+  <data name="DataGridBeginInit" xml:space="preserve">
+    <value>BeginInit() has already been called without an EndInit().</value>
+  </data>
+  <data name="DataGridBoolColumnAllowNullValue" xml:space="preserve">
+    <value>Specifies whether the DataGridBoolColumn allows null values.</value>
+  </data>
+  <data name="DataGridBorderStyleDescr" xml:space="preserve">
+    <value>Indicates the border style for the DataGrid.</value>
+  </data>
+  <data name="DataGridCaptionBackButtonToolTip" xml:space="preserve">
+    <value>Navigates back to the parent rows.</value>
+  </data>
+  <data name="DataGridCaptionBackColorDescr" xml:space="preserve">
+    <value>Indicates the background color of the top caption.</value>
+  </data>
+  <data name="DataGridCaptionDetailsButtonToolTip" xml:space="preserve">
+    <value>Shows/Hides the parent rows for the current set of child rows.</value>
+  </data>
+  <data name="DataGridCaptionFontDescr" xml:space="preserve">
+    <value>Indicates the font of the top caption.</value>
+  </data>
+  <data name="DataGridCaptionForeColorDescr" xml:space="preserve">
+    <value>Indicates the color of text that appears in the top caption.</value>
+  </data>
+  <data name="DataGridCaptionTextDescr" xml:space="preserve">
+    <value>Indicates the text displayed in the top caption.</value>
+  </data>
+  <data name="DataGridCaptionVisibleDescr" xml:space="preserve">
+    <value>Indicates whether the top caption is visible.</value>
+  </data>
+  <data name="DataGridColumnCollectionMissing" xml:space="preserve">
+    <value>DataGridColumn instance does not exist in the collection.</value>
+  </data>
+  <data name="DataGridColumnHeadersVisibleDescr" xml:space="preserve">
+    <value>Indicates whether the column headers are visible.</value>
+  </data>
+  <data name="DataGridColumnListManagerPosition" xml:space="preserve">
+    <value>Position of ListManager must be equal to 'rowNum'.</value>
+  </data>
+  <data name="DataGridColumnNoPropertyDescriptor" xml:space="preserve">
+    <value>PropertyDescriptor has not been set on this DataGridColumn.</value>
+  </data>
+  <data name="DataGridColumnStyleDuplicateMappingName" xml:space="preserve">
+    <value>Data grid column styles collection already contains a column style with the same mapping name.</value>
+  </data>
+  <data name="DataGridColumnUnbound" xml:space="preserve">
+    <value>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</value>
+  </data>
+  <data name="DataGridColumnWidth" xml:space="preserve">
+    <value>ColumnWidth must be greater than or equal to 0.</value>
+  </data>
+  <data name="DataGridCurrentCellDescr" xml:space="preserve">
+    <value>The currently selected cell in the DataGrid.</value>
+  </data>
+  <data name="DataGridDataMemberDescr" xml:space="preserve">
+    <value>Indicates a sub-list of the DataSource to show in the DataGrid.</value>
+  </data>
+  <data name="DataGridDataSourceDescr" xml:space="preserve">
+    <value>Indicates the source of data for the DataGrid.</value>
+  </data>
+  <data name="DataGridDefaultColumnCollectionChanged" xml:space="preserve">
+    <value>User cannot change the contents of the default GridColumnStylesCollection.</value>
+  </data>
+  <data name="DataGridDefaultTableSet" xml:space="preserve">
+    <value>Value of this property cannot be changed on the default DataGridTableStyle.</value>
+  </data>
+  <data name="DataGridDownButtonClickDescr" xml:space="preserve">
+    <value>Occurs when the user clicks the "show/hide parent rows" icon.</value>
+  </data>
+  <data name="DataGridEmptyColor" xml:space="preserve">
+    <value>Value '{0}' cannot be set to an empty value.</value>
+  </data>
+  <data name="DataGridErrorMessageBoxCaption" xml:space="preserve">
+    <value>Committing the row to the original data store has caused an error.</value>
+  </data>
+  <data name="DataGridExceptionInPaint" xml:space="preserve">
+    <value>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</value>
+  </data>
+  <data name="DataGridFailedToGetRegionInfo" xml:space="preserve">
+    <value>Program cannot get information about the painting and scrolling region.</value>
+  </data>
+  <data name="DataGridFirstVisibleColumnDescr" xml:space="preserve">
+    <value>Indicates the index of the column that is first shown.</value>
+  </data>
+  <data name="DataGridFlatModeDescr" xml:space="preserve">
+    <value>Indicates whether the grid has a flat appearance.</value>
+  </data>
+  <data name="DataGridGridLineColorDescr" xml:space="preserve">
+    <value>Indicates the color of the grid lines.</value>
+  </data>
+  <data name="DataGridGridLineStyleDescr" xml:space="preserve">
+    <value>Indicates the style of the grid lines.</value>
+  </data>
+  <data name="DataGridGridTablesDescr" xml:space="preserve">
+    <value>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</value>
+  </data>
+  <data name="DataGridHeaderBackColorDescr" xml:space="preserve">
+    <value>Indicates the background color of the column and row headers.</value>
+  </data>
+  <data name="DataGridHeaderFontDescr" xml:space="preserve">
+    <value>Indicates the font of the text in the column and row headers.</value>
+  </data>
+  <data name="DataGridHeaderForeColorDescr" xml:space="preserve">
+    <value>Indicates the color of the text in the column and row headers.</value>
+  </data>
+  <data name="DataGridHorizScrollBarDescr" xml:space="preserve">
+    <value>Returns the horizontal scroll bar used by the grid.</value>
+  </data>
+  <data name="DataGridLinkColorDescr" xml:space="preserve">
+    <value>Indicates the color of the text that appears inside the child links.</value>
+  </data>
+  <data name="DataGridLinkHoverColorDescr" xml:space="preserve">
+    <value>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</value>
+  </data>
+  <data name="DataGridListManagerDescr" xml:space="preserve">
+    <value>The CurrencyManager that the DataGrid uses to get data from the data source.</value>
+  </data>
+  <data name="DataGridNavigateEventDescr" xml:space="preserve">
+    <value>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</value>
+  </data>
+  <data name="DataGridNavigationModeDescr" xml:space="preserve">
+    <value>Indicates whether links to child tables are shown.</value>
+  </data>
+  <data name="DataGridNodeClickEventDescr" xml:space="preserve">
+    <value>Occurs when the user clicks on the expansion glyph on the row header.</value>
+  </data>
+  <data name="DataGridNullText" xml:space="preserve">
+    <value>Event raised when the value of the BackgroundColor property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnBackgroundColorChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the BorderStyle property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnCaptionVisibleChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the CaptionVisible property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnCurrentCellChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the CurrentCell property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnDataSourceChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the DataSource property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnFlatModeChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the FlatMode property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnNavigationModeChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the NavigationMode property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnParentRowsLabelStyleChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnParentRowsVisibleChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridOnReadOnlyChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the ReadOnly property is changed on DataGrid.</value>
+  </data>
+  <data name="DataGridParentRowsBackColorDescr" xml:space="preserve">
+    <value>Indicates the background color of the parent rows.</value>
+  </data>
+  <data name="DataGridParentRowsForeColorDescr" xml:space="preserve">
+    <value>Indicates the color of the text in the parent rows.</value>
+  </data>
+  <data name="DataGridParentRowsLabelStyleDescr" xml:space="preserve">
+    <value>Indicates whether the parent rows show labels for the table and for the columns.</value>
+  </data>
+  <data name="DataGridParentRowsVisibleDescr" xml:space="preserve">
+    <value>Indicates whether the parent rows area is visible.</value>
+  </data>
+  <data name="DataGridPreferredColumnWidthDescr" xml:space="preserve">
+    <value>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</value>
+  </data>
+  <data name="DataGridPreferredRowHeightDescr" xml:space="preserve">
+    <value>Indicates the preferred height of the rows.</value>
+  </data>
+  <data name="DataGridPushedIncorrectValueIntoColumn" xml:space="preserve">
+    <value>Value {0} Do you want to correct this value?</value>
+  </data>
+  <data name="DataGridReadOnlyDescr" xml:space="preserve">
+    <value>Indicates whether rows in the grid can be edited, added, or deleted.</value>
+  </data>
+  <data name="DataGridRowHeadersVisibleDescr" xml:space="preserve">
+    <value>Indicates whether the row headers are visible.</value>
+  </data>
+  <data name="DataGridRowHeaderWidthDescr" xml:space="preserve">
+    <value>Indicates the width of the row headers.</value>
+  </data>
+  <data name="DataGridRowRowHeight" xml:space="preserve">
+    <value>DataGridRow.Height cannot be negative.</value>
+  </data>
+  <data name="DataGridRowRowNumber" xml:space="preserve">
+    <value>DataGridRow cannot have a negative row number.</value>
+  </data>
+  <data name="DataGridScrollEventDescr" xml:space="preserve">
+    <value>Occurs when the user scrolls either the horizontal or vertical scroll bar.</value>
+  </data>
+  <data name="DataGridSelectedIndexDescr" xml:space="preserve">
+    <value>Indicates the index of the current row.</value>
+  </data>
+  <data name="DataGridSelectionBackColorDescr" xml:space="preserve">
+    <value>Indicates the background color of any selected cells or rows.</value>
+  </data>
+  <data name="DataGridSelectionForeColorDescr" xml:space="preserve">
+    <value>Indicates the color of the text in any selected cells or rows.</value>
+  </data>
+  <data name="DataGridSetListManager" xml:space="preserve">
+    <value>ListManager can be set using the DataSource and DataMember properties.</value>
+  </data>
+  <data name="DataGridSetSelectIndex" xml:space="preserve">
+    <value>Position on a null ListManager cannot be set.</value>
+  </data>
+  <data name="DataGridSettingCurrentCellNotGood" xml:space="preserve">
+    <value>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</value>
+  </data>
+  <data name="DataGridTableCollectionMissingTable" xml:space="preserve">
+    <value>DataGridTable instance does not exist in the collection.</value>
+  </data>
+  <data name="DataGridTableStyleCollectionAddedParentedTableStyle" xml:space="preserve">
+    <value>DataGridTableStyle that is already parented to another DataGrid cannot be added.</value>
+  </data>
+  <data name="DataGridTableStyleDuplicateMappingName" xml:space="preserve">
+    <value>Data grid table styles collection already contains a table style with the same mapping name.</value>
+  </data>
+  <data name="DataGridTableStyleTransparentAlternatingBackColorNotAllowed" xml:space="preserve">
+    <value>DataGridTableStyle does not support transparent AlternatingBackColor.</value>
+  </data>
+  <data name="DataGridTableStyleTransparentBackColorNotAllowed" xml:space="preserve">
+    <value>DataGridTableStyle does not support transparent BackColor.</value>
+  </data>
+  <data name="DataGridTableStyleTransparentHeaderBackColorNotAllowed" xml:space="preserve">
+    <value>DataGridTableStyle does not support transparent HeaderBackColor.</value>
+  </data>
+  <data name="DataGridTableStyleTransparentSelectionBackColorNotAllowed" xml:space="preserve">
+    <value>DataGridTableStyle does not support transparent SelectionBackColor.</value>
+  </data>
+  <data name="DataGridToolTipEmptyIcon" xml:space="preserve">
+    <value>null rectangle for icon bounds when adding tool tip.</value>
+  </data>
+  <data name="DataGridTransparentAlternatingBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent AlternatingBackColor.</value>
+  </data>
+  <data name="DataGridTransparentBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent BackColor.</value>
+  </data>
+  <data name="DataGridTransparentCaptionBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent CaptionBackColor.</value>
+  </data>
+  <data name="DataGridTransparentHeaderBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent HeaderBackColor.</value>
+  </data>
+  <data name="DataGridTransparentParentRowsBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent ParentRowsBackColor.</value>
+  </data>
+  <data name="DataGridTransparentSelectionBackColorNotAllowed" xml:space="preserve">
+    <value>DataGrid control does not support transparent SelectionBackColor.</value>
+  </data>
+  <data name="DataGridUnbound" xml:space="preserve">
+    <value>Data cannot be read from a DataGrid which is not bound to a DataTable.</value>
+  </data>
+  <data name="DataGridVertScrollBarDescr" xml:space="preserve">
+    <value>Returns the vertical scroll bar used by the grid.</value>
+  </data>
+  <data name="DataGridOnBorderStyleChangedDescr" xml:space="preserve">
+    <value>Event raised when the value of the BorderStyle property is changed on DataGrid.</value>
+  </data>
+  <data name="ContextMenuCollapseDescr" xml:space="preserve">
+    <value>Raised when the context menu collapses.</value>
+  </data>
+  <data name="ContextMenuImageListDescr" xml:space="preserve">
+    <value>Gets or sets the ImageList associated with this context menu.</value>
+  </data>
+  <data name="ContextMenuInvalidParent" xml:space="preserve">
+    <value>ContextMenu cannot be shown on an invisible control.</value>
+  </data>
+  <data name="ContextMenuIsImageMarginPresentDescr" xml:space="preserve">
+    <value>Gets or sets a value indicating whether the menu has an image margin.</value>
+  </data>
+  <data name="ContextMenuSourceControlDescr" xml:space="preserve">
+    <value>The last control that caused this context menu to be displayed.</value>
+  </data>
+  <data name="FormMenuDescr" xml:space="preserve">
+    <value>The main menu of the form. This must be set to a component of type MainMenu.</value>
+  </data>
+  <data name="MainMenuCollapseDescr" xml:space="preserve">
+    <value>Occurs when the main menu collapses.</value>
+  </data>
+  <data name="MenuBadMenuItem" xml:space="preserve">
+    <value>Parameter must be of type MenuItem.</value>
+  </data>
+  <data name="MenuIsParentDescr" xml:space="preserve">
+    <value>Indicates if this menu contains any child items.</value>
+  </data>
+  <data name="MenuItemAlreadyExists" xml:space="preserve">
+    <value>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</value>
+  </data>
+  <data name="MenuItemCheckedDescr" xml:space="preserve">
+    <value>Indicates whether the item is checked.</value>
+  </data>
+  <data name="MenuItemDefaultDescr" xml:space="preserve">
+    <value>Indicates whether the item is the default item.</value>
+  </data>
+  <data name="MenuItemEnabledDescr" xml:space="preserve">
+    <value>Indicates whether the item is enabled.</value>
+  </data>
+  <data name="MenuItemInvalidCheckProperty" xml:space="preserve">
+    <value>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</value>
+  </data>
+  <data name="MenuItemMDIListDescr" xml:space="preserve">
+    <value>Determines whether the MDI child window list is appended to this item.</value>
+  </data>
+  <data name="MenuItemMergeOrderDescr" xml:space="preserve">
+    <value>Determines the merge order of the item.</value>
+  </data>
+  <data name="MenuItemMergeTypeDescr" xml:space="preserve">
+    <value>Determines how the item is handled when menus are merged.</value>
+  </data>
+  <data name="MenuItemOnClickDescr" xml:space="preserve">
+    <value>Occurs when the menu item is selected.</value>
+  </data>
+  <data name="MenuItemOnInitDescr" xml:space="preserve">
+    <value>Occurs before the containing menu is displayed.</value>
+  </data>
+  <data name="MenuItemOnSelectDescr" xml:space="preserve">
+    <value>Occurs when the menu item is selected.</value>
+  </data>
+  <data name="MenuItemOwnerDrawDescr" xml:space="preserve">
+    <value>Indicates if Windows will draw the menu item or if the user will handle the painting.</value>
+  </data>
+  <data name="MenuItemRadioCheckDescr" xml:space="preserve">
+    <value>If the item is checked, this value will determine whether the check style is a radio button.</value>
+  </data>
+  <data name="MenuItemTextDescr" xml:space="preserve">
+    <value>The caption displayed by the item.</value>
+  </data>
+  <data name="MenuItemVisibleDescr" xml:space="preserve">
+    <value>Indicates whether the item is visible.</value>
+  </data>
+  <data name="MenuMDIListItemDescr" xml:space="preserve">
+    <value>Retrieves the menu item that contains a list of MDI child windows.</value>
+  </data>
+  <data name="MenuMenuItemsDescr" xml:space="preserve">
+    <value>The menu items for the menu.</value>
+  </data>
+  <data name="MenuMergeWithSelf" xml:space="preserve">
+    <value>Cannot merge a menu with itself.</value>
+  </data>
+  <data name="MenuRightToLeftDescr" xml:space="preserve">
+    <value>Indicates if this menu should display right to left</value>
+  </data>
+  <data name="FormMergedMenuDescr" xml:space="preserve">
+    <value>The merged menu of this form, which is used when displaying a single merged MDI menu.</value>
+  </data>
+  <data name="StatusBarAddFailed" xml:space="preserve">
+    <value>Adding the panel to the native status bar control has not succeeded.</value>
+  </data>
+  <data name="StatusBarBadStatusBarPanel" xml:space="preserve">
+    <value>Parameter must be of type StatusBarPanel.</value>
+  </data>
+  <data name="StatusBarDrawItem" xml:space="preserve">
+    <value>Occurs whenever a panel in the StatusBar needs to be painted.</value>
+  </data>
+  <data name="StatusBarOnPanelClickDescr" xml:space="preserve">
+    <value>Occurs when a panel within the status bar is clicked.</value>
+  </data>
+  <data name="StatusBarPanelAlignmentDescr" xml:space="preserve">
+    <value>The alignment of the panel's text.</value>
+  </data>
+  <data name="StatusBarPanelAutoSizeDescr" xml:space="preserve">
+    <value>Determines how a panel will resize when the parent changes size.</value>
+  </data>
+  <data name="StatusBarPanelBorderStyleDescr" xml:space="preserve">
+    <value>Determines what type of border a panel has.</value>
+  </data>
+  <data name="StatusBarPanelIconDescr" xml:space="preserve">
+    <value>Determines what icon is displayed in the panel.</value>
+  </data>
+  <data name="StatusBarPanelMinWidthDescr" xml:space="preserve">
+    <value>The minimum width of the panel.</value>
+  </data>
+  <data name="StatusBarPanelNameDescr" xml:space="preserve">
+    <value>The name of the panel.</value>
+  </data>
+  <data name="StatusBarPanelsDescr" xml:space="preserve">
+    <value>The panels in the status bar.</value>
+  </data>
+  <data name="StatusBarPanelStyleDescr" xml:space="preserve">
+    <value>The style of the panel.</value>
+  </data>
+  <data name="StatusBarPanelTextDescr" xml:space="preserve">
+    <value>The text displayed in the panel.</value>
+  </data>
+  <data name="StatusBarPanelToolTipTextDescr" xml:space="preserve">
+    <value>The panel's ToolTip text.</value>
+  </data>
+  <data name="StatusBarPanelWidthDescr" xml:space="preserve">
+    <value>The width of the panel.</value>
+  </data>
+  <data name="StatusBarShowPanelsDescr" xml:space="preserve">
+    <value>Determines if a status bar displays panels, or if it displays a single line of text.</value>
+  </data>
+  <data name="StatusBarSizingGripDescr" xml:space="preserve">
+    <value>Determines whether a status bar has a sizing grip.</value>
+  </data>
 </root>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.cs.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.cs.xlf
index 213a79130f2..3ec782e754d 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.cs.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.cs.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Nadřazený formulář tohoto ovládacího prvku kontejneru.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Vyvolá se při sbalení místní nabídky.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Získá nebo nastaví ovládací prvek ImageList spojený s touto místní nabídkou.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">Nabídku ContextMenu nelze zobrazit v neviditelném ovládacím prvku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Získá nebo nastaví hodnotu označující, zda má nabídka okraj pro obrázek.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Poslední ovládací prvek, který způsobil zobrazení této kontextové nabídky.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Poslední ovládací prvek, který způsobil zobrazení této místní nabídky</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">Funkce RemoveAt není pro vazby mezi vlastnostmi podporována.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Vyvolá se při změně hodnoty vlastnosti AlternatingRowsDefaultCellStyle.</target>
@@ -5375,11 +5860,21 @@ Chcete jej nahradit?</target>
         <target state="translated">Získá nebo nastaví ukotvení pro minimalizované podřízené položky MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Určuje primární hodnotu MenuStrip pro formulář. Tato vlastnost se používá k aktivování klávesnice a automatickému sloučení v MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Určuje, zda formulář má v pravém horním rohu záhlaví minimalizační pole.</target>
@@ -6929,6 +7424,11 @@ Trasování zásobníku, kde došlo k neplatné operaci:
         <target state="translated">Formulář, který byl určen jako nadřazený objekt MdiParent pro tento formulář, není typu MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Označuje, zda je znak příkazového řádku platný jako vstup.</target>
@@ -7064,6 +7564,81 @@ Trasování zásobníku, kde došlo k neplatné operaci:
         <target state="translated">Určuje typ objektu, který se má použít k analýze vstupního textu v případě, že ovládací prvek ztratí fokus.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Klávesová zkratka přiřazená položce nabídky</target>
@@ -7074,6 +7649,36 @@ Trasování zásobníku, kde došlo k neplatné operaci:
         <target state="translated">Určuje, zda bude v položce nabídky zobrazena klávesová zkratka pro tuto položku. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Určuje položku, jejíž seznam DropDown se zobrazí v seznamu oken MDI.</target>
@@ -9129,6 +9734,91 @@ Trasování zásobníku, kde došlo k neplatné operaci:
         <target state="translated">Získání zařazovacího modulu pro IID {0} se nezdařilo.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Určuje strany panelu, na kterých by se měla zobrazovat ohraničení.</target>
@@ -9714,6 +10404,136 @@ Trasování zásobníku, kde došlo k neplatné operaci:
         <target state="translated">Příliš mnoho volání ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Určuje vzhled ovládacího prvku ToolBar a využívá hodnoty výčtu ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Určuje, zda ovládací prvek ToolBar automaticky změní velikost na základě velikosti prvku Button.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Parametr musí být typu ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Určuje typ ohraničení ovládacího prvku ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Vyvolá se vždy, když uživatel klikne na tlačítko na panelu nástrojů (ToolBar).</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Vyvolá se při každém stisknutí tlačítka se stylem DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Určuje, zda toto tlačítko bude reagovat na vstup uživatele.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Určuje obrázek zobrazovaný na tlačítku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Rozevírací nabídka pro ovládací prvek ToolBarButton musí být typu ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Místní nabídka, která bude zobrazena, pokud bude styl tohoto tlačítka nastaven na hodnotu DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Označuje, že byl přijat neexistující objekt ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Určuje, zda by tlačítko mělo být zobrazeno jako částečně stisknuté, ale pouze v případě, že je styl tlačítka nastaven na hodnotu ToggleButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Určuje, zda tlačítko je nebo není stisknuto. Nejčastěji se používá pro tlačítka se stylem TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Velikost tlačítek v ovládacím prvku, pokud obsah tlačítek nevyžaduje větší velikost</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Určuje styl ovládacího prvku ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Titulek, který bude zobrazen pro toto tlačítko.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Text popisu tlačítka, který bude zobrazen pro toto tlačítko.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Určuje, zda toto tlačítko bude viditelné.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Kolekce objektů ToolBarButtons, které vytvářejí tento ovládací prvek ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Určuje, zda ovládací prvek ToolBar zobrazí v horní části klientské oblasti prostorovou čáru.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Určuje, zda ovládací prvek ToolBar zobrazí vedle rozevíracích tlačítek šipku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">Seznam ImageList, z něhož tento ovládací prvek ToolBar získá všechny obrázky tlačítek.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">Velikost obrázků v rámci seznamu ImageList tohoto ovládacího prvku ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Určuje, zda budou pro jednotlivá tlačítka zobrazeny popisy tlačítek, jsou-li k dispozici.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Určuje pozici textu vzhledem k obrázku v jednotlivých tlačítkách.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Určuje, zda je povolen více než jeden řádek tlačítek.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">Vlastnosti AllowItemReorder a AllowDrop nemohou být současně nastaveny na hodnotu True.</target>
@@ -11431,4 +12251,4 @@ Trasování zásobníku, kde došlo k neplatné operaci:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.de.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.de.xlf
index 34359e0070b..734f0513d07 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.de.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.de.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Das übergeordnete Formular des Containersteuerelements.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Wird ausgelöst, wenn das Kontextmenü ausgeblendet wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Ruft die mit diesem Kontextmenü verknüpfte ImageList ab oder legt sie fest.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">ContextMenu kann nicht auf einem unsichtbarem Steuerelement angezeigt werden.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Ruft einen Wert ab oder legt einen Wert fest, der anzeigt, ob das Menü einen Bildrand hat.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Das letzte Steuerelement, dass die Anzeige des Kontextmenüs verursacht hat.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Das letzte Steuerelement, das die Anzeige dieser Kontextmenüleiste verursacht hat.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt wird für die Eigenschaftenbindung nicht unterstützt.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Tritt auf, wenn sich der Wert der AlternatingRowsDefaultCellStyle-Eigenschaft ändert.</target>
@@ -5375,11 +5860,21 @@ Möchten Sie sie ersetzen?</target>
         <target state="translated">Ruft die Verankerung für minimierte untergeordnete MDI-Elemente ab oder legt sie fest.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Gibt den primären MenuStrip für das Formular an. Diese Eigenschaft wird für die Tastaturaktivierung und das automatische Zusammenführen in MDI verwendet.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Bestimmt, ob ein Formular ein Minimieren-Feld in der oberen rechten Ecke seiner Titelleiste hat.</target>
@@ -6929,6 +7424,11 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
         <target state="translated">Das Formular, das als MdiParent für dieses Formular angegeben wurde, ist kein MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Zeigt an, ob das Eingabeaufforderungszeichen eine gültige Eingabe ist.</target>
@@ -7064,6 +7564,81 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
         <target state="translated">Gibt den Typ des für die Analyse des Eingabetexts zu verwendenden Objekts an, wenn das Steuerelement den Fokus verliert.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Die dem Menüelement zugeordnete Tastenkombination. </target>
@@ -7074,6 +7649,36 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
         <target state="translated">Gibt an, ob die Tastenkombination für das Menüelement in dem Element angezeigt wird. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Gibt das Element an, dessen DropDown die Liste der MDI-Fenster anzeigt.</target>
@@ -9129,6 +9734,91 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
         <target state="translated">Fehler beim Abrufen des Marshallers für IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Gibt die Seiten des Bereichs an, die Rahmen anzeigen sollen.</target>
@@ -9714,6 +10404,136 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
         <target state="translated">Zu viele Aufrufe an ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Steuert die Darstellung des ToolBar-Steuerelements mit Werten aus der ToolBarAppearance-Enumeration.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Steuert, ob die Größe der ToolBar automatisch basierend auf der Schaltflächengröße geändert wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Der Parameter muss den Typ ToolBarButton haben.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Steuert den Rahmentyp des ToolBar-Steuerelements.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Tritt ein, wenn der Benutzer auf eine ToolBar-Schaltfläche klickt.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Tritt ein, wenn auf eine Schaltfläche mit dem Stil DropDownButton geklickt wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Steuert, ob die Schaltfläche auf Benutzereingaben reagiert.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Gibt das auf der Schaltfläche angezeigte Bild an.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Das DropdownmMenü für einen ToolBarButton muss den Typ ContextMenu haben.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Das Kontextmenü, das angezeigt wird, wenn der Stil der Schaltfläche auf DropDownButton festgelegt ist.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Gibt an, dass ein nicht vorhandener ToolBarButton empfangen wurde.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Steuert, ob die Schaltfläche als partiell gedrückt angezeigt wird (nur wenn der Stil der Schaltfläche auf ToggleButton festgelegt ist).</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Gibt an, ob auf die Schaltfläche geklickt wurde (wird häufig für Schaltflächen mit dem TOGGLEBUTTON-Stil verwendet).</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Die Größe der Schaltflächen in dem Steuerelement, wenn für den Inhalt der Schaltfläche keine größere Größe erforderlich ist.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Gibt den Stil für ToolBarButton an.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Die Beschriftung, die für diese Schaltfläche angezeigt wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Die QuickInfo, die für diese Schaltfläche angezeigt wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Zeigt an, ob diese Schaltfläche sichtbar sein soll.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Die ToolBarButtons-Sammlung, die diese ToolBar bildet.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Steuert, ob in der ToolBar eine 3D-Zeile am oberen Rand des Clientbereichs angezeigt wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Steuert, ob in der ToolBar ein Pfeil neben den Dropdown-Schaltflächen angezeigt wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">Die ImageList, aus der die ToolBar alle Schaltflächenbilder abruft.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">Die Größe der Bilder in der ImageList der Toolbar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Gibt an, ob QuickInfos für jede Schaltfläche angezeigt werden, sofern verfügbar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Steuert, wie der Text relativ zum Bild in jeder Schaltfläche positioniert wird.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Zeigt an, ob mehr als eine Schaltflächenzeile zulässig ist.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder und AllowDrop können nicht beide "true" sein.</target>
@@ -11431,4 +12251,4 @@ Stapelüberwachung, in der der unzulässige Vorgang auftrat:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.es.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.es.xlf
index 9a903f8da2e..f4073f4ba60 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.es.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.es.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Formulario primario de este control contenedor.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Se desencadena cuando se contrae el menú contextual.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Obtiene o establece ImageList asociado con este menú contextual.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">No se puede mostrar ContextMenu en un control invisible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Obtiene o establece un valor que indica si el menú tiene un margen de imagen.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Último control que hizo que se mostrara el menú contextual.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Último control que hizo que se mostrara la franja de menús contextuales.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">El enlace propiedad a propiedad no admite RemoveAt.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Tiene lugar cuando el valor de la propiedad AlternatingRowsDefaultCellStyle cambia.</target>
@@ -5375,11 +5860,21 @@ Do you want to replace it?</source>
         <target state="translated">Obtiene o establece la delimitación para elementos secundarios MDI minimizados.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Especifica el MenuStrip principal para el formulario. Esta propiedad se utiliza para la activación del teclado y la combinación automática en MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Determina si el formulario tiene un cuadro para minimizar en la esquina superior derecha de la barra de título.</target>
@@ -6929,6 +7424,11 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
         <target state="translated">El formulario especificado como MdiParent para este formulario no es un contenedor MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Indica si el carácter de petición de datos es válido como entrada.</target>
@@ -7064,6 +7564,81 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
         <target state="translated">Especifica el tipo del objeto que se va a utilizar para analizar el texto de entrada cuando el control pierde el foco.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Tecla de método abreviado asociada al elemento de menú. </target>
@@ -7074,6 +7649,36 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
         <target state="translated">Indica si la tecla de método abreviado del elemento de menú se muestra en el elemento. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Especifica el elemento cuyo DropDown mostrará la lista de ventanas MDI.</target>
@@ -9129,6 +9734,91 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
         <target state="translated">No se pudo obtener el cálculo de referencias para IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Especifica los lados del panel que deberían mostrar bordes.</target>
@@ -9714,6 +10404,136 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
         <target state="translated">Demasiadas llamadas a ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Controla la apariencia del control ToolBar, usando los valores de la enumeración ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Controla si la barra de herramientas debe cambiar automáticamente de tamaño basándose en el tamaño de los botones.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">El parámetro debe ser de tipo ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Controla qué tipo de borde tiene el control de la barra de herramientas.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Tiene lugar cuando el usuario hace clic en un botón de la barra de herramientas.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Tiene lugar cuando se presiona un botón con estilo DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Controla si este botón responde a la entrada del usuario.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Identifica la imagen que aparece en el botón.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">El menú desplegable de la colección ToolBarButton debe ser de tipo ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Menú contextual que aparecerá si el estilo de este botón se establece en DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Se han recibido referencias a un ToolBarButton que no existe.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Controla si el botón se debe mostrar como parcialmente presionado, pero sólo si el estilo del botón es ToggleButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Indica si el botón está presionado o no. Lo más normal es encontrarlo en los botones que tienen el estilo TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Tamaño de los botones del control si el contenido de los botones no requiere un tamaño mayor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Indica qué estilo tendrá ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Título que se muestra para este botón.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">El texto de información sobre herramientas que se va a mostrar para este botón.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Indica si este botón debe ser visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Colección de botones ToolBarButtons que forman esta barra de herramientas.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Controla si la barra de herramientas mostrará una línea en 3D en la parte superior de su área cliente.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Controla si la barra de herramientas mostrará una flecha junto a los botones de lista desplegable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">ImageList de la que esta barra de herramientas obtendrá todas las imágenes de los botones.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">Tamaño de las imágenes de ImageList de la barra de herramientas.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Indica si se debe mostrar la información sobre herramientas para cada uno de los botones, si está disponible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Controla cómo se sitúa el texto en relación con la imagen en cada botón.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Indica si se permite más de una fila de botones.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder y AllowDrop no pueden ser ambos true.</target>
@@ -11431,4 +12251,4 @@ El seguimiento de la pila donde tuvo lugar la operación no válida fue:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.fr.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.fr.xlf
index c32040002c0..6a32fd7fa83 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.fr.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.fr.xlf
@@ -1312,9 +1312,34 @@
         <target state="translated">Le formulaire parent de ce contrôle conteneur.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Déclenché lorsque le menu contextuel est réduit.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Obtient ou définit le ImageList associé à ce menu contextuel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">ContextMenu ne peut pas être affiché sur un contrôle invisible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Obtient ou définit une valeur indiquant si le menu dispose d'une marge d'image.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Dernier contrôle ayant provoqué l'affichage de ce menu contextuel.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
-        <target state="translated">Dernier contrôle ayant provoqué l'affichage de cette bande de menus contextuels.</target>
+        <target state="new">The last control that caused this context menu strip to be displayed.</target>
         <note />
       </trans-unit>
       <trans-unit id="ControlAccessibleObjectInvalid">
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt n'est pas pris en charge pour la liaison de propriété à propriété.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Se produit lorsque la valeur de la propriété AlternatingRowsDefaultCellStyle change.</target>
@@ -5375,11 +5860,21 @@ Voulez-vous le remplacer ?</target>
         <target state="translated">Obtient ou définit l’ancrage pour les enfants MDI réduits.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Spécifie le MenuStrip principal du formulaire. Cette propriété est utilisée pour l'activation clavier et la fusion automatique en MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Détermine si un formulaire dispose d'un bouton de réduction dans le coin supérieur droit de sa barre de légende.</target>
@@ -6929,6 +7424,11 @@ Cette opération non conforme s'est produite sur la trace de la pile :
         <target state="translated">Le formulaire qui a été spécifié comme étant le MdiParent pour ce formulaire n'est pas un MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Indique si le caractère d'invite est valide en tant qu'entrée.</target>
@@ -7064,6 +7564,81 @@ Cette opération non conforme s'est produite sur la trace de la pile :
         <target state="translated">Spécifie le Type de l'objet à utiliser pour l'analyse du texte d'entrée lorsque le contrôle perd le focus.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">La touche de raccourci associée à l'élément de menu. </target>
@@ -7074,6 +7649,36 @@ Cette opération non conforme s'est produite sur la trace de la pile :
         <target state="translated">Indique si la touche de raccourci pour l'élément de menu est affichée sur l'élément. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Spécifie l'élément dont le DropDown affichera la liste des fenêtres MDI.</target>
@@ -9129,6 +9734,91 @@ Cette opération non conforme s'est produite sur la trace de la pile :
         <target state="translated">Impossible d'obtenir le marshaleur pour IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Spécifie les côtés du panneau qui doivent afficher des bordures.</target>
@@ -9714,6 +10404,136 @@ Cette opération non conforme s'est produite sur la trace de la pile :
         <target state="translated">Trop d'appels vers ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Contrôle l'apparence du contrôle ToolBar, en utilisant les valeurs de l'énumération ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Contrôle si la barre d'outils est automatiquement redimensionnée en fonction de la taille des boutons.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Le paramètre doit être de type ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Contrôle le type de bordure du contrôle ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Se produit lorsqu'un utilisateur clique sur un bouton du ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Se produit lorsqu'un bouton de style DropDownButton est enfoncé.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Contrôle si ce bouton répond aux entrées d'utilisateur.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Identifie l'image affichée sur ce bouton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Le type d'un menu déroulant d'un ToolBarButton doit être ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Le menu contextuel qui s'affiche si le style du bouton a la valeur DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Indique qu'un ToolBarButton inexistant a été reçu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Contrôle si le bouton doit être affiché comme étant partiellement enfoncé, mais uniquement si le style du bouton est ToggleButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Indique si le bouton est ou non enfoncé. Utilisé pour les boutons avec le style TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">La taille des boutons du contrôle, si le contenu du bouton ne nécessite pas une taille plus grande.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Indique le style du ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">La légende à afficher pour ce bouton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Le texte ToolTip à afficher pour ce bouton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Indique si ce bouton doit être visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">La collection de ToolBarButtons qui composent ce ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Contrôle si le ToolBar affiche une ligne 3D en haut de la zone cliente.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Contrôle si le ToolBar affiche une flèche sur le côté des boutons déroulants.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">Le ImageList à partir duquel ce ToolBar obtient toutes les images de boutons.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">La taille des images dans le ImageList du ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Indique si des info-bulles sont affichées pour chaque bouton, si elles sont disponibles.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Contrôle la façon dont le texte est positionné par rapport à l'image dans chaque bouton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Indique si plusieurs lignes de boutons sont autorisées.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder et AllowDrop ne peuvent pas être true en même temps.</target>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.it.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.it.xlf
index 2252ee790ef..aa60c568cbd 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.it.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.it.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Form padre di questo controllo contenitore.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Generato quando si comprime il menu di scelta rapida.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Ottiene o imposta il componente ImageList associato a questo menu di scelta rapida.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">Impossibile visualizzare il menu di scelta rapida su un controllo invisibile.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Ottiene o imposta un valore che indica se è presente un margine nell'immagine del menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Ultimo controllo che ha comportato la visualizzazione di questo menu di scelta rapida.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Ultimo controllo che ha causato la visualizzazione di questo elenco di menu di scelta rapida.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt non è supportato per l'associazione da proprietà a proprietà.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Generato quando il valore della proprietà AlternatingRowsDefaultCellStyle cambia.</target>
@@ -5375,11 +5860,21 @@ Sostituirlo?</target>
         <target state="translated">Ottiene o imposta l'ancoraggio per gli elementi figlio MDI ridotti a icona.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Specifica il MenuStrip principale per il form. Questa proprietà consente l'attivazione della tastiera e il merge automatico in MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Determina se un form dispone di un pulsante di riduzione a icona nella parte superiore destra della barra del titolo.</target>
@@ -6929,6 +7424,11 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
         <target state="translated">Il form specificato come MdiParent per questo form non è un MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Indica se il carattere di prompt è valido come input.</target>
@@ -7064,6 +7564,81 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
         <target state="translated">Specifica il tipo di oggetto da utilizzare per l'analisi del testo di input quando il controllo perde lo stato attivo.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Il tasto di scelta rapida associato alla voce di menu. </target>
@@ -7074,6 +7649,36 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
         <target state="translated">Indica se il tasto di scelta rapida della voce di menu viene visualizzato sulla voce. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Specifica per quale elemento l'oggetto DropDown visualizzerà l'elenco delle finestre MDI.</target>
@@ -9129,6 +9734,91 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
         <target state="translated">Impossibile ottenere il gestore di marshalling per IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Specifica i lati del riquadro per i quali devono essere visualizzati i bordi.</target>
@@ -9714,6 +10404,136 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
         <target state="translated">Troppe chiamate a ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Determina l'aspetto del controllo ToolBar  utilizzando i valori dell'enumerazione ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Determina se viene effettuato il ridimensionamento automatico del controllo ToolBar in base alla dimensione del controllo Button.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Il parametro deve essere di tipo ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Determina il tipo di bordo del controllo ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Generato quando l'utente fa clic su un pulsante del controllo ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Generato quando si fa clic su un pulsante con lo stile DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Determina se questo pulsante risponde all'input dell'utente.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Identifica l'immagine visualizzata sul pulsante.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Il menu a discesa di ToolBarButton deve essere di tipo ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Il menu di scelta rapida che verrà visualizzato se lo stile di questo pulsante è DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Ricevuto ToolBarButton inesistente.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Se lo stile del pulsante è ToggleButton, determina se il pulsante deve essere visualizzato come parzialmente premuto.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Indica se il pulsante è premuto. Normalmente si utilizza con pulsanti con lo stile TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">La dimensione dei pulsanti del controllo se il contenuto dei pulsanti non richiede una dimensione maggiore.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Indica lo stile del controllo ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">La didascalia da visualizzare per questo pulsante.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Il testo di ToolTip da visualizzare per questo pulsante.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Indica se questo pulsante deve essere visibile.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">La raccolta di controlli ToolBarButton che appartengono a questo controllo ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Determina se la barra degli strumenti visualizzerà una riga 3D nella parte superiore della propria area client.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Determina se nel controllo ToolBar verrà visualizzata una freccia accanto ai pulsanti a discesa.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">ImageList da cui questo controllo ToolBar recupera tutte le immagini dei pulsanti.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">La dimensione delle immagini in ImageList di ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Indica se visualizzare componenti ToolTip per ciascun pulsante, se disponibili.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Determina in che modo verrà posizionato il testo dei pulsanti rispetto all'immagine.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Indica se è consentita più di una riga di pulsanti.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">Le proprietà AllowItemReorder e AllowDrop non possono avere entrambe valore true.</target>
@@ -11431,4 +12251,4 @@ Traccia dello stack da cui si è verificata l'operazione non valida:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.ja.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.ja.xlf
index 525f32e234d..f8195b90ee1 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.ja.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.ja.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">このコンテナー コントロールの親フォームです。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">コンテキスト メニューが縮小するときに発生します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">このコンテキスト メニューに関連付けられた ImageList を取得および設定します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">非表示のコントロールでは、ContextMenu を表示できません。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">メニューがイメージの余白を持つかどうかを示す値を取得または設定します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">このコンテキスト メニューを最後に表示させたコントロールです。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">このコンテキスト メニュー ストリップを最後に表示させたコントロールです。</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt は、プロパティからプロパティへの バインドに対してサポートされていません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">AlternatingRowsDefaultCellStyle プロパティの値が変更したときに発生します。</target>
@@ -5375,11 +5860,21 @@ Do you want to replace it?</source>
         <target state="translated">最小化された MDI 子要素の固定を取得または設定します。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">フォームの主要な MenuStrip を指定します。このプロパティは、キーボードのアクティブ化および MDI での自動マージのために使用されます。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">フォームがキャプション バーの右上に最小化ボタンを指定するかどうかを決定します。</target>
@@ -6929,6 +7424,11 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">このフォームの MdiParent として指定されたフォームは MdiContainer ではありません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">プロンプト文字が入力として有効であるかどうかを示します。</target>
@@ -7064,6 +7564,81 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">コントロールがフォーカスを失ったときに、入力テキストを解析するために使用されるオブジェクトの型を指定します。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">メニュー項目に関連付けられたショートカット キーです。</target>
@@ -7074,6 +7649,36 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">メニュー項目のショートカット キーをアイテムに表示するかどうかを示します。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">DropDown が MDI ウィンドウの一覧を表示するアイテムを指定します。</target>
@@ -9129,6 +9734,91 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">IID {0} のマーシャラーを取得できませんでした。</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">境界線を表示するパネルの側面を指定します。</target>
@@ -9714,6 +10404,136 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">ResumeUpdateMenuHandles への呼び出しが多すぎます。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">ToolBarAppearance 列挙 からの値を用いて、ToolBar コントロールの外観を制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">ボタンのサイズに基づいて、ツール バーのサイズを自動的に変更するかどうかを制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">パラメーターは型 ToolBarButton でなければなりません。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">ツール バー コントロールの境界線の種類を設定します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">ユーザーがツール バーのボタンをクリックしたときに発生します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">DropDownButton スタイルのボタンがクリックされたときに発生します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">このボタンがユーザーの入力に応答するかどうかを制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">ボタンに表示されたイメージを識別します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">ToolBarButton のドロップダウン メニューは ContextMenu 型でなければなりません。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">このボタンのスタイルが DropDownButton に設定されている場合に表示されるショートカット メニューです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">存在しない ToolBarButton を受け取ったことを示します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">ボタンの種類が ToggleButton の場合のみ、ボタンが部分的にクリックされたとして表示するかどうかを制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">ボタンをクリックしたかどうかを示します。TOGGLEBUTTON スタイルのボタンによく使われます。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">ボタンの内容により大きなサイズが必要でない場合の、コントロール上のボタンのサイズです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">ToolBarButton のスタイルを示します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">このボタンに表示されるキャプションです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">このボタンに表示されるツールヒント テキストです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">このボタンを表示するかどうかを示します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">このツール バーを構成する ToolBarButtons のコレクションです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">ツール バーがこのクライアント領域の上に 3D の線を表示するかどうかを設定します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">ツール バーがドロップダウン ボタンの横に矢印を表示するかどうかを制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">ツール バーがすべてボタンのイメージを取得する ImageList です。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">ツール バーの ImageList 内にある、イメージのサイズです。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">ツールヒントがある場合に、それぞれのボタンでそれを表示するかどうかを示します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">各ボタンのイメージに対して、テキストがどのように表示されるか制御します。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">複数行のボタンを許可するかどうかを示します。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder と AllowDrop の両方を true にすることはできません。</target>
@@ -11431,4 +12251,4 @@ Stack trace where the illegal operation occurred was:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.ko.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.ko.xlf
index d712fad67d0..f12f017d237 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.ko.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.ko.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">이 컨테이너 컨트롤의 부모 폼입니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">상황에 맞는 메뉴가 축소될 때 발생합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">이 상황에 맞는 메뉴에 연결된 ImageList를 가져오거나 설정합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">보이지 않는 컨트롤에 ContextMenu를 표시할 수 없습니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">메뉴에 이미지 여백이 있는지 여부를 나타내는 값을 가져오거나 설정합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">상황에 맞는 메뉴를 표시한 마지막 컨트롤입니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">상황에 맞는 메뉴 스트립을 표시한 마지막 컨트롤입니다.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt은 속성에 대하여 속성 바인딩을 지원하지 않습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">AlternatingRowsDefaultCellStyle 속성 값이 변경될 때 발생합니다.</target>
@@ -5375,11 +5860,21 @@ Do you want to replace it?</source>
         <target state="translated">최소화된 MDI 자식에 대한 앵커링을 가져오거나 설정합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">폼의 주 MenuStrip을 지정합니다. 이 속성은 MDI에서 자동 병합 및 키보드 활성화에 사용됩니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">폼의 캡션 표시줄 오른쪽 위 모퉁이에 최소화 상자를 포함할지 여부를 결정합니다.</target>
@@ -6929,6 +7424,11 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">이 폼의 MdiParent로 지정한 폼이 MdiContainer가 아닙니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">프롬프트 문자가 입력으로 올바른지 여부를 나타냅니다.</target>
@@ -7064,6 +7564,81 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">컨트롤이 포커스를 잃을 때 입력 텍스트를 구문 분석하는 데 사용할 개체의 형식을 지정합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">메뉴 항목에 연결된 바로 가기 키입니다.</target>
@@ -7074,6 +7649,36 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">메뉴 항목의 바로 가기 키가 항목에 표시되는지 여부를 나타냅니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">DropDown에 MDI 창의 목록이 표시되는 항목을 지정합니다.</target>
@@ -9129,6 +9734,91 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">IID {0}의 마샬러를 가져오지 못했습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">테두리를 표시할 패널 면을 지정합니다.</target>
@@ -9714,6 +10404,136 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">ResumeUpdateMenuHandles에 대한 호출이 너무 많습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">ToolBarAppearance 열거형의 값을 사용하여 ToolBar 컨트롤의 모양을 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">단추 크기에 따라 도구 모음의 크기를 자동으로 조정할지 여부를 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">매개 변수는 ToolBarButton 형식이어야 합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">ToolBar 컨트롤의 테두리 형식을 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">사용자가 ToolBar의 단추를 클릭할 때마다 발생합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">DropDownButton 스타일의 단추를 누를 때마다 발생합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">이 단추가 사용자 입력에 응답하는지 여부를 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">단추에 표시되는 이미지를 식별합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">ToolBarButton의 드롭다운 메뉴는 ContextMenu 형식이어야 합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">이 단추의 스타일을 DropDownButton으로 설정하면 표시되는 바로 가기 메뉴입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">존재하지 않는 ToolBarButton에 대한 참조를 받았습니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">단추 스타일이 ToggleButton인 경우에 한하여 단추를 부분적으로 눌린 상태로 표시할지 여부를 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">단추의 누름 상태를 나타내며, 대개 TOGGLEBUTTON 스타일의 단추에서 볼 수 있습니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">단추 크기가 단추 내용에 적합한 경우 컨트롤에 표시될 단추의 크기입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">구현될 ToolBarButton 스타일을 나타냅니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">이 단추에 표시할 캡션입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">이 단추에 표시할 ToolTip 텍스트입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">이 단추를 표시할지 여부를 나타냅니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">이 ToolBar를 구성하는 ToolBarButtons 컬렉션입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">도구 모음에서 클라이언트 영역의 맨 위에 3D 선을 표시할지 여부를 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">도구 모음에서 드롭다운 단추 옆에 화살표를 표시할지 여부를 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">이 ToolBar에서 모든 단추 이미지를 가져올 ImageList입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">도구 모음의 ImageList에 있는 이미지의 크기입니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">도구 설명을 사용할 수 있는 경우 각 단추의 도구 설명을 표시할지 여부를 나타냅니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">각 단추에서 이미지를 기준으로 하여 텍스트를 배치하는 방법을 제어합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">두 행 이상의 단추를 사용할 수 있는지 여부를 나타냅니다.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder 및 AllowDrop이 모두 true일 수 없습니다.</target>
@@ -11431,4 +12251,4 @@ Stack trace where the illegal operation occurred was:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.pl.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.pl.xlf
index 2bc82e65006..d47bbd4f725 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.pl.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.pl.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Formularz nadrzędny tego formantu kontenera.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Występuje po zwinięciu menu kontekstowego.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Pobiera lub ustawia listę ImageList skojarzoną z tym menu kontekstowym.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">Nie można pokazać elementu ContextMenu w niewidocznym formancie.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Pobiera lub ustawia wartość wskazującą, czy menu ma margines obrazu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Ostatni formant, który spowodował wyświetlenie tego menu kontekstowego.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Ostatni formant, który spowodował wyświetlenie tego paska menu kontekstowego.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">Element RemoveAt nie jest obsługiwany dla powiązań właściwości z właściwością</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Występuje, gdy wartość właściwości AlternatingRowsDefaultCellStyle zostanie zmieniona.</target>
@@ -5375,11 +5860,21 @@ Czy chcesz go zamienić?</target>
         <target state="translated">Pobiera lub ustawia kotwiczenie dla zminimalizowanych elementów podrzędnych MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Określa podstawowy element MenuStrip dla elementu Form. Ta właściwość jest używana do aktywacji klawiatury i automatycznego scalania w interfejsie MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Określa, czy w prawym górnym rogu paska podpisu formularza znajduje się pole minimalizacji.</target>
@@ -6929,6 +7424,11 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
         <target state="translated">Formularz, który został określony jako MdiParent dla tego formularza, nie jest elementem MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Wskazuje, czy znak monitu jest prawidłowym wprowadzanym znakiem.</target>
@@ -7064,6 +7564,81 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
         <target state="translated">Określa typ obiektu używanego do analizowania tekstu wejściowego, gdy formant utraci fokus.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Klawisz skrótu skojarzony z elementem menu. </target>
@@ -7074,6 +7649,36 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
         <target state="translated">Wskazuje, czy skrót do elementu menu będzie wyświetlany. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Określa element, którego element DropDown pokazuje listę okien interfejsu MDI.</target>
@@ -9129,6 +9734,91 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
         <target state="translated">Nie można uzyskać modułu serializacji dla identyfikatora IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Określa strony panelu, które mają wyświetlać obramowanie.</target>
@@ -9714,6 +10404,136 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
         <target state="translated">Zbyt wiele odwołań do elementu ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Steruje wyglądem formantu ToolBar przy użyciu wartości z wyliczenia ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Określa, czy rozmiar formantu ToolBar będzie zmieniał się automatycznie na podstawie rozmiaru elementu Button.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Parametr musi być typu ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Określa typ obramowania formantu ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Występuje za każdym razem, gdy użytkownik kliknie przycisk w formancie ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Występuje zawsze, gdy zostanie naciśnięty przycisk o stylu DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Określa, czy przycisk odpowiada na działania użytkownika.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Identyfikuje obraz wyświetlany na przycisku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Menu rozwijane elementu ToolBarButton musi być typu ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Menu kontekstowe pojawiające się, jeśli styl przycisku jest ustawiony na DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Odebrano odwołania do nieistniejącego elementu ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Określa, czy przycisk powinien być wyświetlany jako częściowo naciśnięty, czy nie, ale tylko wtedy, gdy stylem przycisku jest ToggleButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Wskazuje, czy przycisk jest naciśnięty, czy nie. Najczęściej występuje w przyciskach ze stylem TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Rozmiar przycisków w formancie, gdy zawartość formantu nie wymaga większego rozmiaru.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Wskazuje styl elementu ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Podpis wyświetlany dla przycisku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Tekst elementu ToolTip wyświetlany na tym przycisku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Wskazuje, czy przycisk powinien być widoczny.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Kolekcja elementów ToolBarButton, które tworzą ten element ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Określa, czy u góry obszaru klienckiego elementu ToolBar ma być wyświetlana linia 3W.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Określa, czy obok przycisków rozwijanych w elemencie ToolBar będą wyświetlane strzałki.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">Element ImageList, z którego element ToolBar pobierze wszystkie obrazy dla przycisków.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">Rozmiary obrazów w elemencie ImageList elementu ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Wskazuje, czy elementy ToolTip mają być pokazywane na każdym przycisku, jeśli są dostępne.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Określa, jak rozmieszczany jest tekst względem obrazu na każdym przycisku.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Wskazuje, czy dopuszczalny jest więcej niż jeden wiersz przycisków.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">Wartości AllowItemReorder i AllowDrop nie mogą być jednocześnie prawdziwe.</target>
@@ -11431,4 +12251,4 @@ Stos śledzenia, w którym wystąpiła zabroniona operacja:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.pt-BR.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.pt-BR.xlf
index eb4505e49be..65317b308e5 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.pt-BR.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.pt-BR.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">O formulário pai deste controle de recipiente.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Gerado quando o menu contextual é recolhido.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Obtém ou define a ImageList associada ao menu contextual.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">ContextMenu não pode ser mostrado em um controle invisível.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Obtém ou define um valor indicando se o menu tem uma margem de imagem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">O último controle que exibiu este menu contextual.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">O último controle que fez esta faixa de menus contextuais ser exibida.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt não oferece suporte para associação de propriedade a propriedade.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Ocorre quando o valor da propriedade AlternatingRowsDefaultCellStyle é alterado.</target>
@@ -5375,11 +5860,21 @@ Deseja substituí-lo?</target>
         <target state="translated">Obtém ou define a ancoragem para filhos MDI minimizados.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Especifica a MenuStrip primário do formulário. Essa propriedade é usada para ativação do teclado e mesclagem automática em MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Determina se um formulário tem uma caixa de minimização no canto superior direito de sua barra de legenda.</target>
@@ -6929,6 +7424,11 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
         <target state="translated">O formulário especificado para ser o MdiParent deste formulário não é um MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Indica se o caractere de prompt é válido como entrada.</target>
@@ -7064,6 +7564,81 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
         <target state="translated">Especifica o Tipo de objeto a ser usado para análise do texto de entrada quando o controle perde o foco.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">A tecla de atalho associada ao item de menu. </target>
@@ -7074,6 +7649,36 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
         <target state="translated">Indica se a tecla de atalho para o item de menu é exibida no item. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Especifica o item cujo DropDown mostrará a lista de janelas MDI.</target>
@@ -9129,6 +9734,91 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
         <target state="translated">Falha ao obter marshaler para IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Especifica os lados do painel que deverão exibir bordas.</target>
@@ -9714,6 +10404,136 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
         <target state="translated">Número excessivo de chamadas para ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Controla a aparência do controle ToolBar, usando os valores de enumeração ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Controla se ToolBar será dimensionado automaticamente com base no tamanho do botão.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">O parâmetro deve ser do tipo ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Controla o tipo de borda que o controle ToolBar terá.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Ocorre sempre que um botão em ToolBar é clicado pelo usuário.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Ocorre sempre que um botão com o estilo DropDownButton é pressionado.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Controla se este botão responde à entrada do usuário.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Identifica a imagem exibida no botão.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">O menu suspenso para um ToolBarButton deve ser do tipo ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">O menu de atalho a ser exibido se o estilo deste botão for definido como DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Referências de que um ToolBarButton inexistente foi recebido.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Controla se o botão deve ser exibido como parcialmente pressionado ou não, mas somente se o estilo do botão for ToggleButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Indica se o botão está pressionado ou não. Isso é mais comum para botões com estilo TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">O tamanho dos botões no controle se o conteúdo do botão não exigir um tamanho maior.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Indica o estilo de ToolBarButton a ser usado.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">A legenda a ser exibida para este botão.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">O texto de dica de ferramenta a ser exibido para este botão.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Indica se este botão deve estar visível.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">A coleção de ToolBarButtons que compõe este ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Controla se ToolBar exibirá uma linha em 3D na parte superior de sua área cliente.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Controla se ToolBar exibirá uma seta na lateral dos botões suspensos.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">ImageList do qual este ToolBar obterá todas as imagens de botões.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">O tamanho das imagens dentro de ImageList de ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Indica se dicas de ferramenta serão mostradas para cada um dos botões, se disponíveis.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Controla como o texto é posicionado em relação à imagem em cada botão.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Indica se é permitida mais de uma linha de botões.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder e AllowDrop não podem ser verdadeiros.</target>
@@ -11431,4 +12251,4 @@ Rastreamento de pilha em que a operação ilegal ocorreu:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.ru.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.ru.xlf
index bcfb7b33f8e..3bfd91f3b5e 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.ru.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.ru.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Родительская форма данного вмещающего элемента управления.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">Вызывается при сворачивании контекстного меню.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Получает или устанавливает ImageList для данного контекстного меню.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">Невозможно отобразить ContextMenu в невидимом элементе управления.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Получает или задает значение, определяющее наличие в меню полей изображения.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Последний элемент управления, вызывавший отображение этого контекстного меню.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Последний элемент управления, вызвавший отображение полосы данного контекстного меню.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">Метод RemoveAt не поддерживается для привязки свойства к другому свойству.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">Возникает при изменении значения свойства AlternatingRowsDefaultCellStyle.</target>
@@ -5376,11 +5861,21 @@ Do you want to replace it?</source>
         <target state="translated">Получает или задает привязку для свернутых дочерних форм MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Определяет для Form первичный MenuStrip. Данное свойство используется для активации клавиатуры и автоматического слияния в MDI.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Определяет, содержит ли форма в правом верхнем углу строки заголовка значок свертывания.</target>
@@ -6930,6 +7425,11 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">Форма, указанная как MdiParent для данной формы, не является MdiContainer.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">Указывает, является ли символ, введенный в окне приглашения, допустимым.</target>
@@ -7065,6 +7565,81 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">Указывает Type для объекта, который будет использоваться для разбора вводимого текста при потере фокуса элементом управления.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Указывает клавиши быстрого доступа к данному меню.</target>
@@ -7075,6 +7650,36 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">Определяет, будут ли отображаться клавиши быстрого доступа для данного элемента меню.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">Указывает пункт, чья функция DropDown будет отображать список окон MDI.</target>
@@ -9130,6 +9735,91 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">Не удалось получить упаковщик ("маршалер") для IID {0}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Задает стороны панели, на которых должны отображаться границы.</target>
@@ -9715,6 +10405,136 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">Недопустимо большое число вызовов ResumeUpdateMenuHandles.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">Задает внешний вид элемента управления ToolBar с помощью значений из перечисления ToolBarAppearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Указывает, будет ли ToolBar автоматически изменять размер в соответствии с размером кнопок.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Параметр должен быть типа ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">Определяет тип границы для элемента управления ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Происходит при каждом нажатии кнопки на ToolBar с помощью мыши.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">Происходит при каждом нажатии кнопки, имеющей стиль DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Указывает, воспринимает ли эта кнопка действия пользователя.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Указывает индекс изображения в ImageList для родительского ToolBar, который используется при получении изображения для этой кнопки.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">Раскрывающееся меню для ToolBarButton должно иметь тип ContextMenu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Контекстное меню, отображаемое в том случае, если кнопке назначен стиль DropDownButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Сообщает о том, что получен несуществующий ToolBarButton.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Задает, должна ли кнопка отображаться нажатой (только для кнопок, имеющих стиль ToggleButton).</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Указывает, находится ли кнопка в нажатом положении. Обычно этот признак используется для кнопок, имеющих стиль TOGGLEBUTTON.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Предлагает размер кнопок на ToolBar. Размеры отдельных кнопок могут отличаться от данного размера в зависимости от длины текста, наличия стрелок раскрывающегося списка и др.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Указывает, какой стиль ToolBarButton будет использоваться.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Надпись, отображаемая на этой кнопке.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Текст подсказки, отображаемый для этой кнопки.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Указывает, должна ли эта кнопка быть видимой.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Коллекция ToolBarButton, из которых состоит эта панель ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">Задает, должна ли в верхней части клиентской области панели ToolBar отображаться объемная линия.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">Задает, отображаются ли на ToolBar стрелки рядом с кнопками, имеющими раскрывающиеся списки.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">ImageList, из которого эта панель ToolBar будет извлекать изображения всех кнопок.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">Размер изображений в списке изображений для ToolBar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Указывает, должна ли отображаться подсказка (если доступна) для каждой кнопки.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Задает расположение текста относительно изображения на каждой кнопке.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Указывает, разрешено ли несколько рядов кнопок.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder и AllowDrop не могут одновременно иметь значение true.</target>
@@ -11432,4 +12252,4 @@ Stack trace where the illegal operation occurred was:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.tr.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.tr.xlf
index e41d54bf92f..8fca0bb8407 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.tr.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.tr.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">Bu kapsayıcı denetiminin üst formu.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">İçerik menüsü daraltıldığında harekete geçirilir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">Bu içerik menüsüyle ilişkili ImageList'i alır veya ayarlar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">ContextMenu, görünmeyen bir denetimde gösterilemiyor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">Menüde resim kenar boşluğu olup olmadığını gösteren değeri alır veya ayarlar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">Bu bağlam menüsünün görüntülenmesine neden olan en son denetim.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">Bu içerik menüsü şeridinin görüntülenmesine neden olan en son denetim.</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">RemoveAt, özellikler arası bağlama için desteklenmiyor.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">AlternatingRowsDefaultCellStyle özelliğinin değeri değiştiğinde gerçekleşir.</target>
@@ -5375,11 +5860,21 @@ Bunu değiştirmek istiyor musunuz?</target>
         <target state="translated">Simge durumuna küçültülmüş MDI alt öğeleri için bağlamayı alır veya ayarlar.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">Form için birincil MenuStrip'i belirtir. Bu özellik MDI'da klavye etkinleştirme ve otomatik birleştirme için kullanılır.</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">Formda başlık çubuğunun sağ üst köşesinde simge durumuna küçültme kutusunun bulunup bulunmadığını belirler.</target>
@@ -6929,6 +7424,11 @@ Geçersiz işlemin gerçekleştiği yığın izi:
         <target state="translated">Bu form için MdiParent olarak belirtilen form, bir MdiContainer değil.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">İstem karakterinin giriş olarak geçerli olup olmadığını gösterir.</target>
@@ -7064,6 +7564,81 @@ Geçersiz işlemin gerçekleştiği yığın izi:
         <target state="translated">Denetim odağı kaybettiğinde giriş metnini ayrıştırmak için kullanılacak nesnenin türünü belirtir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">Menü öğesiyle ilişkili kısayol tuşu. </target>
@@ -7074,6 +7649,36 @@ Geçersiz işlemin gerçekleştiği yığın izi:
         <target state="translated">Menü öğesinin kısayolunun öğede görüntülenip görüntülenmeyeceğini gösterir. </target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">DropDown'ı MDI pencereleri listesini gösterecek öğeyi belirtir.</target>
@@ -9129,6 +9734,91 @@ Geçersiz işlemin gerçekleştiği yığın izi:
         <target state="translated">{0} IID için sıralayıcı alınamadı.</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">Bölmenin kenarlıkları görüntüleyecek taraflarını belirtir.</target>
@@ -9714,6 +10404,136 @@ Geçersiz işlemin gerçekleştiği yığın izi:
         <target state="translated">Çok fazla sayıda ResumeUpdateMenuHandles çağrısı.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">ToolBarAppearance numaralandırmasındaki değerleri kullanarak ToolBar denetiminin görünümünü denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">Araç Çubuğu'nun Düğme boyutuna bağlı olarak kendi kendini otomatik olarak boyutlandırıp boyutlandıramayacağını denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">Parametrenin ToolBarButton türünde olması gerekir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">ToolBar denetiminin ne tür kenarlığı olacağını denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">Araç Çubuğu'ndaki bir düğme kullanıcı tarafından her tıklatıldığında gerçekleşir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">DropDownButton stilindeki bir düğmeye her basıldığında gerçekleşir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">Bu düğmenin kullanıcı girişini yanıtlayıp yanıtlayamayacağını denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">Düğmede görüntülenen resmi tanımlar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">ToolBarButton'ın açılan menüsü ContextMenu türünde olmalı.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">Bu düğmenin stili DropDownButton olarak ayarlandığında görünecek olan kısayol menüsü.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">Varolmayan bir ToolBarButton alındığını gösterir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">Düğmenin kısmen basılı olarak görüntülenip görüntülenmeyeceğini denetler, ancak yalnızca düğme stili ToggleButton ise uygulanabilir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">Düğmenin basılı olup olmadığını gösterir. Bu, genellikle stili TOGGLEBUTTON olan düğmelerde görülür.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">Düğme içerikleri daha büyük bir boyut gerektirmezse düğmelerin boyutu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">Bu ToolBarButton'ın hangi stilde olacağını gösterir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">Bu düğme için görüntülenecek başlık.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">Bu düğme için görüntülenecek ToolTip metni.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">Bu düğmenin görünür olup olmayacağını gösterir.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">Bu ToolBar'ı oluşturan ToolBarButton koleksiyonu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">ToolBar'ın istemci alanının üstünde 3 boyutlu çizgi görüntülenip görüntülenmeyeceğini denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">ToolBar'ın açılır düğmelerinin yanında ok görüntülenip görüntülenmeyeceğini denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">Bu ToolBar'ın tüm düğme resimlerini alacağı ImageList.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">ToolBar'ın ImageList'indeki resimlerin boyutu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">Her bir düğme için ToolTip'lerin (varsa) gösterilip gösterilmeyeceğini belirler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">Metnin her düğmedeki Resme göre nasıl yerleştirileceğini denetler.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">Birden fazla düğme satırına izin verilip verilmeyeceğini gösterir.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">Hem AllowItemReorder hem de AllowDrop True olamaz.</target>
@@ -11431,4 +12251,4 @@ Geçersiz işlemin gerçekleştiği yığın izi:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hans.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hans.xlf
index 4956e80123c..31990b71af4 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hans.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hans.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">此容器控件的父窗体。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">在上下文菜单折叠时引发。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">获取或设置与此上下文菜单关联的 ImageList。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">ContextMenu 无法在不可见的控件上显示。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">获取或设置指示菜单是否有图像边距的值。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">使此上下文菜单显示的最后一个控件。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">使该上下文菜单条显示的最后一个控件。</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">属性到属性的绑定不支持 RemoveAt。</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">AlternatingRowsDefaultCellStyle 属性值更改时发生。</target>
@@ -5375,11 +5860,21 @@ Do you want to replace it?</source>
         <target state="translated">获取或设置最小化 MDI 子级的定位点。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">为窗体指定主 MenuStrip。此属性用于键盘激活和 MDI 中的自动合并。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">确定窗体标题栏的右上角是否有最小化框。</target>
@@ -6929,6 +7424,11 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">被指定为此窗体的 MdiParent 的窗体不是 MdiContainer。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">指示提示字符是否为有效输入。</target>
@@ -7064,6 +7564,81 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">指定当控件失去焦点时用于分析输入文本的对象的类型。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">与菜单项关联的快捷键。</target>
@@ -7074,6 +7649,36 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">指示是否在该项上显示菜单项的快捷键。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">指定其 DropDown 将显示 MDI 窗口列表的项。</target>
@@ -9129,6 +9734,91 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">未能获取 IID {0} 的封送处理程序。</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">指定应显示边框的面板的边。</target>
@@ -9714,6 +10404,136 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">对 ResumeUpdateMenuHandles 的调用过多。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">使用 ToolBarAppearance 枚举中的值来控制 ToolBar 控件的外观。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">控制工具栏是否根据按钮大小自动调整自身的大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">参数必须是 ToolBarButton 类型。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">控制工具栏控件将具有的边框类型。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">每当用户单击 ToolBar 中的按钮时发生。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">每当按下具有 DropDownButton 样式的按钮时发生。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">控制此按钮是否响应用户输入。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">标识按钮上显示的图像。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">ToolBarButton 的下拉菜单的类型必须为 ContextMenu。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">当此按钮的样式设置为 DropDownButton 时将显示的快捷菜单。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">接收到对不存在的 ToolBarButton 的引用。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">控制该按钮是否应显示为部分下压，但这仅适用于样式为 ToggleButton 的按钮。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">指示按钮是否是下压的。这常见于样式为 TOGGLEBUTTON 的按钮。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">按钮内容不需要更大大小时控件上的按钮的大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">指示它将成为何种样式的 ToolBarButton。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">此按钮将要显示的标题。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">要为此按钮显示的 ToolTip 文本。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">指示此按钮是否应为可见。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">组成此 ToolBar 的 ToolBarButtons 集合。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">控制工具栏是否在其工作区的顶部显示三维线。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">控制工具栏是否在下拉按钮旁边显示一个箭头。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">此 ToolBar 将从中获取所有按钮图像的 ImageList。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">工具栏的 ImageList 内的图像的大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">指示是否为每个按钮显示工具提示(如果有的话)。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">控制如何相对于每一按钮中的图像来定位文本。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">指示是否允许多行按钮。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder 和 AllowDrop 不能同时为 True。</target>
@@ -11431,4 +12251,4 @@ Stack trace where the illegal operation occurred was:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hant.xlf b/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hant.xlf
index c2d9b1065e9..8358ed3de3b 100644
--- a/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hant.xlf
+++ b/src/System.Windows.Forms/src/Resources/xlf/SR.zh-Hant.xlf
@@ -1312,6 +1312,31 @@
         <target state="translated">此容器控制項的父表單。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ContextMenuCollapseDescr">
+        <source>Raised when the context menu collapses.</source>
+        <target state="translated">在內容功能表摺疊時引發。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuImageListDescr">
+        <source>Gets or sets the ImageList associated with this context menu.</source>
+        <target state="translated">取得或設定與此內容功能表相關的 ImageList。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuInvalidParent">
+        <source>ContextMenu cannot be shown on an invisible control.</source>
+        <target state="translated">無法在不可見的控制項上顯示 ContextMenu。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuIsImageMarginPresentDescr">
+        <source>Gets or sets a value indicating whether the menu has an image margin.</source>
+        <target state="translated">取得或設定用來指示功能表是否有影像邊界的值。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ContextMenuSourceControlDescr">
+        <source>The last control that caused this context menu to be displayed.</source>
+        <target state="translated">造成顯示此內容功能表的最後控制項。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ContextMenuStripSourceControlDescr">
         <source>The last control that caused this context menu strip to be displayed.</source>
         <target state="translated">造成顯示此內容功能表區域的最後控制項。</target>
@@ -2192,6 +2217,466 @@
         <target state="translated">屬性間的繫結不支援 RemoveAt。</target>
         <note />
       </trans-unit>
+      <trans-unit id="DataGridAllowSortingDescr">
+        <source>Indicates whether the grid can be re-sorted by clicking a column header.</source>
+        <target state="new">Indicates whether the grid can be re-sorted by clicking a column header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridAlternatingBackColorDescr">
+        <source>Indicates the background color of alternating rows for a ledger appearance.</source>
+        <target state="new">Indicates the background color of alternating rows for a ledger appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackButtonClickDescr">
+        <source>Occurs when the user clicks the Back button on a child table to return to the parent table.</source>
+        <target state="new">Occurs when the user clicks the Back button on a child table to return to the parent table.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBackgroundColorDescr">
+        <source>Indicates the color of the DataGrid background.</source>
+        <target state="new">Indicates the color of the DataGrid background.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBeginInit">
+        <source>BeginInit() has already been called without an EndInit().</source>
+        <target state="new">BeginInit() has already been called without an EndInit().</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBoolColumnAllowNullValue">
+        <source>Specifies whether the DataGridBoolColumn allows null values.</source>
+        <target state="new">Specifies whether the DataGridBoolColumn allows null values.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridBorderStyleDescr">
+        <source>Indicates the border style for the DataGrid.</source>
+        <target state="new">Indicates the border style for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackButtonToolTip">
+        <source>Navigates back to the parent rows.</source>
+        <target state="new">Navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionBackColorDescr">
+        <source>Indicates the background color of the top caption.</source>
+        <target state="new">Indicates the background color of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionDetailsButtonToolTip">
+        <source>Shows/Hides the parent rows for the current set of child rows.</source>
+        <target state="new">Shows/Hides the parent rows for the current set of child rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionFontDescr">
+        <source>Indicates the font of the top caption.</source>
+        <target state="new">Indicates the font of the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionForeColorDescr">
+        <source>Indicates the color of text that appears in the top caption.</source>
+        <target state="new">Indicates the color of text that appears in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionTextDescr">
+        <source>Indicates the text displayed in the top caption.</source>
+        <target state="new">Indicates the text displayed in the top caption.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCaptionVisibleDescr">
+        <source>Indicates whether the top caption is visible.</source>
+        <target state="new">Indicates whether the top caption is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnCollectionMissing">
+        <source>DataGridColumn instance does not exist in the collection.</source>
+        <target state="new">DataGridColumn instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnHeadersVisibleDescr">
+        <source>Indicates whether the column headers are visible.</source>
+        <target state="new">Indicates whether the column headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnListManagerPosition">
+        <source>Position of ListManager must be equal to 'rowNum'.</source>
+        <target state="new">Position of ListManager must be equal to 'rowNum'.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnNoPropertyDescriptor">
+        <source>PropertyDescriptor has not been set on this DataGridColumn.</source>
+        <target state="new">PropertyDescriptor has not been set on this DataGridColumn.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnStyleDuplicateMappingName">
+        <source>Data grid column styles collection already contains a column style with the same mapping name.</source>
+        <target state="new">Data grid column styles collection already contains a column style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnUnbound">
+        <source>DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</source>
+        <target state="new">DataGridColumnStyle of '{0}' cannot be used because it is not associated with a Property or Column in the DataSource.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridColumnWidth">
+        <source>ColumnWidth must be greater than or equal to 0.</source>
+        <target state="new">ColumnWidth must be greater than or equal to 0.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridCurrentCellDescr">
+        <source>The currently selected cell in the DataGrid.</source>
+        <target state="new">The currently selected cell in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataMemberDescr">
+        <source>Indicates a sub-list of the DataSource to show in the DataGrid.</source>
+        <target state="new">Indicates a sub-list of the DataSource to show in the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDataSourceDescr">
+        <source>Indicates the source of data for the DataGrid.</source>
+        <target state="new">Indicates the source of data for the DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultColumnCollectionChanged">
+        <source>User cannot change the contents of the default GridColumnStylesCollection.</source>
+        <target state="new">User cannot change the contents of the default GridColumnStylesCollection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDefaultTableSet">
+        <source>Value of this property cannot be changed on the default DataGridTableStyle.</source>
+        <target state="new">Value of this property cannot be changed on the default DataGridTableStyle.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridDownButtonClickDescr">
+        <source>Occurs when the user clicks the "show/hide parent rows" icon.</source>
+        <target state="new">Occurs when the user clicks the "show/hide parent rows" icon.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridEmptyColor">
+        <source>Value '{0}' cannot be set to an empty value.</source>
+        <target state="new">Value '{0}' cannot be set to an empty value.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridErrorMessageBoxCaption">
+        <source>Committing the row to the original data store has caused an error.</source>
+        <target state="new">Committing the row to the original data store has caused an error.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridExceptionInPaint">
+        <source>DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</source>
+        <target state="new">DataGrid received an exception at design time. Reset the DataSource and DataMember property on the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFailedToGetRegionInfo">
+        <source>Program cannot get information about the painting and scrolling region.</source>
+        <target state="new">Program cannot get information about the painting and scrolling region.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFirstVisibleColumnDescr">
+        <source>Indicates the index of the column that is first shown.</source>
+        <target state="new">Indicates the index of the column that is first shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridFlatModeDescr">
+        <source>Indicates whether the grid has a flat appearance.</source>
+        <target state="new">Indicates whether the grid has a flat appearance.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineColorDescr">
+        <source>Indicates the color of the grid lines.</source>
+        <target state="new">Indicates the color of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridLineStyleDescr">
+        <source>Indicates the style of the grid lines.</source>
+        <target state="new">Indicates the style of the grid lines.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridGridTablesDescr">
+        <source>The collection of DataGridTableStyle objects that the DataGrid can render its data with.</source>
+        <target state="new">The collection of DataGridTableStyle objects that the DataGrid can render its data with.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderBackColorDescr">
+        <source>Indicates the background color of the column and row headers.</source>
+        <target state="new">Indicates the background color of the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderFontDescr">
+        <source>Indicates the font of the text in the column and row headers.</source>
+        <target state="new">Indicates the font of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHeaderForeColorDescr">
+        <source>Indicates the color of the text in the column and row headers.</source>
+        <target state="new">Indicates the color of the text in the column and row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridHorizScrollBarDescr">
+        <source>Returns the horizontal scroll bar used by the grid.</source>
+        <target state="new">Returns the horizontal scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkColorDescr">
+        <source>Indicates the color of the text that appears inside the child links.</source>
+        <target state="new">Indicates the color of the text that appears inside the child links.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridLinkHoverColorDescr">
+        <source>Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</source>
+        <target state="new">Indicates the color of the text that appears inside a child link when the mouse pointer moves over it.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridListManagerDescr">
+        <source>The CurrencyManager that the DataGrid uses to get data from the data source.</source>
+        <target state="new">The CurrencyManager that the DataGrid uses to get data from the data source.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigateEventDescr">
+        <source>Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</source>
+        <target state="new">Occurs when the user navigates to the child rows or when the user navigates back to the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNavigationModeDescr">
+        <source>Indicates whether links to child tables are shown.</source>
+        <target state="new">Indicates whether links to child tables are shown.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNodeClickEventDescr">
+        <source>Occurs when the user clicks on the expansion glyph on the row header.</source>
+        <target state="new">Occurs when the user clicks on the expansion glyph on the row header.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridNullText">
+        <source>Event raised when the value of the BackgroundColor property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BackgroundColor property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBackgroundColorChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnBorderStyleChangedDescr">
+        <source>Event raised when the value of the BorderStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the BorderStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCaptionVisibleChangedDescr">
+        <source>Event raised when the value of the CaptionVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CaptionVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnCurrentCellChangedDescr">
+        <source>Event raised when the value of the CurrentCell property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the CurrentCell property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnDataSourceChangedDescr">
+        <source>Event raised when the value of the DataSource property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the DataSource property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnFlatModeChangedDescr">
+        <source>Event raised when the value of the FlatMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the FlatMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnNavigationModeChangedDescr">
+        <source>Event raised when the value of the NavigationMode property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the NavigationMode property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsLabelStyleChangedDescr">
+        <source>Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsLabelStyle property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnParentRowsVisibleChangedDescr">
+        <source>Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ParentRowsVisible property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridOnReadOnlyChangedDescr">
+        <source>Event raised when the value of the ReadOnly property is changed on DataGrid.</source>
+        <target state="new">Event raised when the value of the ReadOnly property is changed on DataGrid.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsBackColorDescr">
+        <source>Indicates the background color of the parent rows.</source>
+        <target state="new">Indicates the background color of the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsForeColorDescr">
+        <source>Indicates the color of the text in the parent rows.</source>
+        <target state="new">Indicates the color of the text in the parent rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsLabelStyleDescr">
+        <source>Indicates whether the parent rows show labels for the table and for the columns.</source>
+        <target state="new">Indicates whether the parent rows show labels for the table and for the columns.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridParentRowsVisibleDescr">
+        <source>Indicates whether the parent rows area is visible.</source>
+        <target state="new">Indicates whether the parent rows area is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredColumnWidthDescr">
+        <source>Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</source>
+        <target state="new">Specifies what the default pixel widths of the grid columns are. The default value for PreferredColumnWidth is 75.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPreferredRowHeightDescr">
+        <source>Indicates the preferred height of the rows.</source>
+        <target state="new">Indicates the preferred height of the rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridPushedIncorrectValueIntoColumn">
+        <source>Value {0} Do you want to correct this value?</source>
+        <target state="new">Value {0} Do you want to correct this value?</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridReadOnlyDescr">
+        <source>Indicates whether rows in the grid can be edited, added, or deleted.</source>
+        <target state="new">Indicates whether rows in the grid can be edited, added, or deleted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeaderWidthDescr">
+        <source>Indicates the width of the row headers.</source>
+        <target state="new">Indicates the width of the row headers.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowHeadersVisibleDescr">
+        <source>Indicates whether the row headers are visible.</source>
+        <target state="new">Indicates whether the row headers are visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowHeight">
+        <source>DataGridRow.Height cannot be negative.</source>
+        <target state="new">DataGridRow.Height cannot be negative.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridRowRowNumber">
+        <source>DataGridRow cannot have a negative row number.</source>
+        <target state="new">DataGridRow cannot have a negative row number.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridScrollEventDescr">
+        <source>Occurs when the user scrolls either the horizontal or vertical scroll bar.</source>
+        <target state="new">Occurs when the user scrolls either the horizontal or vertical scroll bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectedIndexDescr">
+        <source>Indicates the index of the current row.</source>
+        <target state="new">Indicates the index of the current row.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionBackColorDescr">
+        <source>Indicates the background color of any selected cells or rows.</source>
+        <target state="new">Indicates the background color of any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSelectionForeColorDescr">
+        <source>Indicates the color of the text in any selected cells or rows.</source>
+        <target state="new">Indicates the color of the text in any selected cells or rows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetListManager">
+        <source>ListManager can be set using the DataSource and DataMember properties.</source>
+        <target state="new">ListManager can be set using the DataSource and DataMember properties.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSetSelectIndex">
+        <source>Position on a null ListManager cannot be set.</source>
+        <target state="new">Position on a null ListManager cannot be set.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridSettingCurrentCellNotGood">
+        <source>CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</source>
+        <target state="new">CurrentCell cannot be set at this time. Moving your code to the Form.Load event should solve this problem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableCollectionMissingTable">
+        <source>DataGridTable instance does not exist in the collection.</source>
+        <target state="new">DataGridTable instance does not exist in the collection.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleCollectionAddedParentedTableStyle">
+        <source>DataGridTableStyle that is already parented to another DataGrid cannot be added.</source>
+        <target state="new">DataGridTableStyle that is already parented to another DataGrid cannot be added.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleDuplicateMappingName">
+        <source>Data grid table styles collection already contains a table style with the same mapping name.</source>
+        <target state="new">Data grid table styles collection already contains a table style with the same mapping name.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentAlternatingBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent BackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentHeaderBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTableStyleTransparentSelectionBackColorNotAllowed">
+        <source>DataGridTableStyle does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGridTableStyle does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridToolTipEmptyIcon">
+        <source>null rectangle for icon bounds when adding tool tip.</source>
+        <target state="new">null rectangle for icon bounds when adding tool tip.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentAlternatingBackColorNotAllowed">
+        <source>DataGrid control does not support transparent AlternatingBackColor.</source>
+        <target state="new">DataGrid control does not support transparent AlternatingBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentBackColorNotAllowed">
+        <source>DataGrid control does not support transparent BackColor.</source>
+        <target state="new">DataGrid control does not support transparent BackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentCaptionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent CaptionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent CaptionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentHeaderBackColorNotAllowed">
+        <source>DataGrid control does not support transparent HeaderBackColor.</source>
+        <target state="new">DataGrid control does not support transparent HeaderBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentParentRowsBackColorNotAllowed">
+        <source>DataGrid control does not support transparent ParentRowsBackColor.</source>
+        <target state="new">DataGrid control does not support transparent ParentRowsBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridTransparentSelectionBackColorNotAllowed">
+        <source>DataGrid control does not support transparent SelectionBackColor.</source>
+        <target state="new">DataGrid control does not support transparent SelectionBackColor.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridUnbound">
+        <source>Data cannot be read from a DataGrid which is not bound to a DataTable.</source>
+        <target state="new">Data cannot be read from a DataGrid which is not bound to a DataTable.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DataGridVertScrollBarDescr">
+        <source>Returns the vertical scroll bar used by the grid.</source>
+        <target state="new">Returns the vertical scroll bar used by the grid.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DataGridViewAlternatingRowsDefaultCellStyleChangedDescr">
         <source>Occurs when the value of the AlternatingRowsDefaultCellStyle property changes.</source>
         <target state="translated">AlternatingRowsDefaultCellStyle 屬性的值變更時發生。</target>
@@ -5375,11 +5860,21 @@ Do you want to replace it?</source>
         <target state="translated">為最小化的 MDI 子項目獲得或設定錨定。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMenuDescr">
+        <source>The main menu of the form. This must be set to a component of type MainMenu.</source>
+        <target state="new">The main menu of the form. This must be set to a component of type MainMenu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMenuStripDescr">
         <source>Specifies the primary MenuStrip for the Form. This property is used for keyboard activation and automatic merging in MDI.</source>
         <target state="translated">指定表單的主要 MenuStrip。此屬性可用於鍵盤啟用，以及 MDI 中的自動合併。</target>
         <note />
       </trans-unit>
+      <trans-unit id="FormMergedMenuDescr">
+        <source>The merged menu of this form, which is used when displaying a single merged MDI menu.</source>
+        <target state="new">The merged menu of this form, which is used when displaying a single merged MDI menu.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="FormMinimizeBoxDescr">
         <source>Determines whether a form has a minimize box in the upper-right corner of its caption bar.</source>
         <target state="translated">決定表單在其標題列的右上角是否有最小化的方塊。</target>
@@ -6929,6 +7424,11 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">指定了不是 MdiContainer 的表單當做是該表單的 MdiParent 的表單。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MainMenuCollapseDescr">
+        <source>Occurs when the main menu collapses.</source>
+        <target state="new">Occurs when the main menu collapses.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MaskedTextBoxAllowPromptAsInputDescr">
         <source>Indicates whether the prompt character is valid as input.</source>
         <target state="translated">表示提示字元是否可以當做有效輸入。</target>
@@ -7064,6 +7564,81 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">指定當控制項遺失焦點時，用來剖析輸入文字的物件類型。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuBadMenuItem">
+        <source>Parameter must be of type MenuItem.</source>
+        <target state="new">Parameter must be of type MenuItem.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuIsParentDescr">
+        <source>Indicates if this menu contains any child items.</source>
+        <target state="new">Indicates if this menu contains any child items.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemAlreadyExists">
+        <source>Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</source>
+        <target state="new">Cannot add MenuItem '{0}'. It already exists as a parent of the current menu item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemCheckedDescr">
+        <source>Indicates whether the item is checked.</source>
+        <target state="new">Indicates whether the item is checked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemDefaultDescr">
+        <source>Indicates whether the item is the default item.</source>
+        <target state="new">Indicates whether the item is the default item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemEnabledDescr">
+        <source>Indicates whether the item is enabled.</source>
+        <target state="new">Indicates whether the item is enabled.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemInvalidCheckProperty">
+        <source>True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</source>
+        <target state="new">True is not a valid value for the Checked property.  This is only valid for MenuItems that have no children and are not top-level.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMDIListDescr">
+        <source>Determines whether the MDI child window list is appended to this item.</source>
+        <target state="new">Determines whether the MDI child window list is appended to this item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeOrderDescr">
+        <source>Determines the merge order of the item.</source>
+        <target state="new">Determines the merge order of the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemMergeTypeDescr">
+        <source>Determines how the item is handled when menus are merged.</source>
+        <target state="new">Determines how the item is handled when menus are merged.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnClickDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnInitDescr">
+        <source>Occurs before the containing menu is displayed.</source>
+        <target state="new">Occurs before the containing menu is displayed.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOnSelectDescr">
+        <source>Occurs when the menu item is selected.</source>
+        <target state="new">Occurs when the menu item is selected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemOwnerDrawDescr">
+        <source>Indicates if Windows will draw the menu item or if the user will handle the painting.</source>
+        <target state="new">Indicates if Windows will draw the menu item or if the user will handle the painting.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemRadioCheckDescr">
+        <source>If the item is checked, this value will determine whether the check style is a radio button.</source>
+        <target state="new">If the item is checked, this value will determine whether the check style is a radio button.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuItemShortCutDescr">
         <source>The shortcut key associated with the menu item. </source>
         <target state="translated">與功能表項目相關的快速鍵。</target>
@@ -7074,6 +7649,36 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">表示是否將功能表項目的快速鍵顯示在該項目上。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MenuItemTextDescr">
+        <source>The caption displayed by the item.</source>
+        <target state="new">The caption displayed by the item.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuItemVisibleDescr">
+        <source>Indicates whether the item is visible.</source>
+        <target state="new">Indicates whether the item is visible.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMDIListItemDescr">
+        <source>Retrieves the menu item that contains a list of MDI child windows.</source>
+        <target state="new">Retrieves the menu item that contains a list of MDI child windows.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMenuItemsDescr">
+        <source>The menu items for the menu.</source>
+        <target state="new">The menu items for the menu.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuMergeWithSelf">
+        <source>Cannot merge a menu with itself.</source>
+        <target state="new">Cannot merge a menu with itself.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="MenuRightToLeftDescr">
+        <source>Indicates if this menu should display right to left</source>
+        <target state="new">Indicates if this menu should display right to left</target>
+        <note />
+      </trans-unit>
       <trans-unit id="MenuStripMdiWindowListItem">
         <source>Specifies the item whose DropDown will show the list of MDI windows.</source>
         <target state="translated">指定其 DropDown 將顯示 MDI 視窗清單的項目。</target>
@@ -9129,6 +9734,91 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">無法取得 IID {0} 的封送處理器。</target>
         <note />
       </trans-unit>
+      <trans-unit id="StatusBarAddFailed">
+        <source>Adding the panel to the native status bar control has not succeeded.</source>
+        <target state="new">Adding the panel to the native status bar control has not succeeded.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarBadStatusBarPanel">
+        <source>Parameter must be of type StatusBarPanel.</source>
+        <target state="new">Parameter must be of type StatusBarPanel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarDrawItem">
+        <source>Occurs whenever a panel in the StatusBar needs to be painted.</source>
+        <target state="new">Occurs whenever a panel in the StatusBar needs to be painted.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarOnPanelClickDescr">
+        <source>Occurs when a panel within the status bar is clicked.</source>
+        <target state="new">Occurs when a panel within the status bar is clicked.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAlignmentDescr">
+        <source>The alignment of the panel's text.</source>
+        <target state="new">The alignment of the panel's text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelAutoSizeDescr">
+        <source>Determines how a panel will resize when the parent changes size.</source>
+        <target state="new">Determines how a panel will resize when the parent changes size.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelBorderStyleDescr">
+        <source>Determines what type of border a panel has.</source>
+        <target state="new">Determines what type of border a panel has.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelIconDescr">
+        <source>Determines what icon is displayed in the panel.</source>
+        <target state="new">Determines what icon is displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelMinWidthDescr">
+        <source>The minimum width of the panel.</source>
+        <target state="new">The minimum width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelNameDescr">
+        <source>The name of the panel.</source>
+        <target state="new">The name of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelStyleDescr">
+        <source>The style of the panel.</source>
+        <target state="new">The style of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelTextDescr">
+        <source>The text displayed in the panel.</source>
+        <target state="new">The text displayed in the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelToolTipTextDescr">
+        <source>The panel's ToolTip text.</source>
+        <target state="new">The panel's ToolTip text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelWidthDescr">
+        <source>The width of the panel.</source>
+        <target state="new">The width of the panel.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarPanelsDescr">
+        <source>The panels in the status bar.</source>
+        <target state="new">The panels in the status bar.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarShowPanelsDescr">
+        <source>Determines if a status bar displays panels, or if it displays a single line of text.</source>
+        <target state="new">Determines if a status bar displays panels, or if it displays a single line of text.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="StatusBarSizingGripDescr">
+        <source>Determines whether a status bar has a sizing grip.</source>
+        <target state="new">Determines whether a status bar has a sizing grip.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="StatusStripPanelBorderSidesDescr">
         <source>Specifies the sides of the panel that should display borders.</source>
         <target state="translated">指定面板中應該顯示框線的邊。</target>
@@ -9714,6 +10404,136 @@ Stack trace where the illegal operation occurred was:
         <target state="translated">太多的 ResumeUpdateMenuHandles 呼叫。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ToolBarAppearanceDescr">
+        <source>Controls the appearance of the ToolBar control, using values from the ToolBarAppearance enumeration.</source>
+        <target state="translated">控制 ToolBar 控制項的外觀，使用來自 ToolBarAppearance 列舉型別的值。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarAutoSizeDescr">
+        <source>Controls whether the ToolBar will automatically size itself based on Button size.</source>
+        <target state="translated">控制工具列 (ToolBar) 是否會依照按鈕大小自動調整其大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBadToolBarButton">
+        <source>Parameter must be of type ToolBarButton.</source>
+        <target state="translated">參數必須屬於 ToolBarButton 類型。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarBorderStyleDescr">
+        <source>Controls what type of border the ToolBar control will have.</source>
+        <target state="translated">控制 ToolBar 控制項擁有的框線類型。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonClickDescr">
+        <source>Occurs whenever a button in the ToolBar is clicked by the user.</source>
+        <target state="translated">當使用者按下 ToolBar 中的按鈕時發生。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonDropDownDescr">
+        <source>Occurs whenever a button with the DropDownButton style is pressed.</source>
+        <target state="translated">當按住有 DropDownButton 樣式的按鈕時發生。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonEnabledDescr">
+        <source>Controls whether this button responds to user input.</source>
+        <target state="translated">控制此按鈕是否回應使用者的輸入。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonImageIndexDescr">
+        <source>Identifies the image displayed on the button.</source>
+        <target state="translated">識別按鈕上顯示的影像。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonInvalidDropDownMenuType">
+        <source>The drop-down menu for a ToolBarButton must be of type ContextMenu.</source>
+        <target state="translated">ToolBarButton 的下拉式功能表必須屬於 ContextMenu 類型。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonMenuDescr">
+        <source>The shortcut menu that will appear if this button's style is set to DropDownButton.</source>
+        <target state="translated">將此按鈕的樣式設為 DropDownButton 時會顯示的捷徑功能表。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonNotFound">
+        <source>References that a non-existent ToolBarButton has been received.</source>
+        <target state="translated">參考已收到的非現存 ToolBarButton。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPartialPushDescr">
+        <source>Controls whether the button should be displayed as partially pushed or not, but only if the style of the button is ToggleButton.</source>
+        <target state="translated">控制按鈕是否應顯示為部分壓下，但僅適用於按鈕的樣式為 ToggleButton。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonPushedDescr">
+        <source>Indicates whether the button is pushed or not. This is most commonly seen for buttons with the TOGGLEBUTTON style.</source>
+        <target state="translated">表示是否按下按鈕。這些按鈕最常見的樣式為 TOGGLEBUTTON。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonSizeDescr">
+        <source>The size of the buttons on the control if the button contents do not require a larger size.</source>
+        <target state="translated">按鈕內容不需要更大的大小時，控制項上按鈕的大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonStyleDescr">
+        <source>Indicates what style of ToolBarButton this will be.</source>
+        <target state="translated">表示將會是何種 ToolBarButton 樣式。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonTextDescr">
+        <source>The caption to be displayed for this button.</source>
+        <target state="translated">此按鈕所顯示的標題。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonToolTipTextDescr">
+        <source>The ToolTip text to be displayed for this button.</source>
+        <target state="translated">此按鈕所顯示的 ToolTip 文字。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonVisibleDescr">
+        <source>Indicates whether this button should be visible.</source>
+        <target state="translated">表示此按鈕是否可見。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarButtonsDescr">
+        <source>The collection of ToolBarButtons that make up this ToolBar.</source>
+        <target state="translated">組成這個 ToolBar 的 ToolBarButtons 集合物件。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDividerDescr">
+        <source>Controls whether the ToolBar will display a 3-D line at the top of its client area.</source>
+        <target state="translated">控制工具列是否要在其工作區的頂端顯示立體線段。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarDropDownArrowsDescr">
+        <source>Controls whether the ToolBar will display an arrow on the side of drop-down buttons.</source>
+        <target state="translated">控制工具列是否要在下拉按鈕旁顯示箭頭。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageListDescr">
+        <source>The ImageList from which this ToolBar will get all of the button images.</source>
+        <target state="translated">這個 ToolBar 用來取得所有按鈕影像的 ImageList。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarImageSizeDescr">
+        <source>The size of the images within the ToolBar's ImageList.</source>
+        <target state="translated">工具列的 ImageList 中的影像大小。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarShowToolTipsDescr">
+        <source>Indicates whether ToolTips will be shown for each of the buttons, if available.</source>
+        <target state="translated">表示是否顯示每個按鈕的工具提示 (如果有)。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarTextAlignDescr">
+        <source>Controls how the text is positioned relative to the Image in each button.</source>
+        <target state="translated">控制每個按鈕中與影像相關的文字位置。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ToolBarWrappableDescr">
+        <source>Indicates if more than one row of buttons is allowed.</source>
+        <target state="translated">表示是否允許一列以上的按鈕。</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ToolStripAllowItemReorderAndAllowDropCannotBeSetToTrue">
         <source>AllowItemReorder and AllowDrop cannot both be true.</source>
         <target state="translated">AllowItemReorder 和 AllowDrop 不能同時為 true。</target>
@@ -11431,4 +12251,4 @@ Stack trace where the illegal operation occurred was:
       </trans-unit>
     </body>
   </file>
-</xliff>
\ No newline at end of file
+</xliff>
diff --git a/src/System.Windows.Forms/src/System.Windows.Forms.csproj b/src/System.Windows.Forms/src/System.Windows.Forms.csproj
index ed4abdf9d1e..32d4ce94633 100644
--- a/src/System.Windows.Forms/src/System.Windows.Forms.csproj
+++ b/src/System.Windows.Forms/src/System.Windows.Forms.csproj
@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <AssemblyName>System.Windows.Forms</AssemblyName>
+    <AssemblyVersion>8.0.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <CLSCompliant>true</CLSCompliant>
     <Nullable>enable</Nullable>
@@ -11,11 +12,39 @@
       IL Trim warnings which should be removed in order to make WinForms trimmable
       See https://github.com/dotnet/winforms/issues/4649
     -->
-    <NoWarn>$(NoWarn);IL2026;IL2050;IL2057;IL2062;IL2067;IL2070;IL2072;IL2075;IL2077;IL2080;IL2092;IL2093;IL2094;IL2096;IL2111</NoWarn>
+    <!--CS0114;CS0108;CS8765;CS8622;CS0184;CS0169;CS0414;SA1507 Additional suppressions relating to use of nullability were put in to handle the DAT warnings. 
+    ToDo: Remove the suppresions one at a time to adhere to the recommended coding styles.-->
+    <NoWarn>$(NoWarn);CS8605;CA1052;CS0114;CS0108;CS8765;CS8622;CS0184;CS0169;CS0414;SA1507;IL2026;IL2050;IL2057;IL2062;IL2067;IL2070;IL2072;IL2075;IL2077;IL2080;IL2092;IL2093;IL2094;IL2096;IL2111;CSIsNull001;CSIsNull002;SA1129;WFDEV001;CA1822;CA1823;SA1518;SA1400;CA1066;CS8769;CS8625;CS8600;CS8603;CS8618;CS8601;CS8602;SA1508;SA1505;CA1507;CS8604;CS0649;CA1805;SA1131;</NoWarn>
     <Win32Manifest>Resources\System\Windows\Forms\XPThemes.manifest</Win32Manifest>
     <Deterministic>true</Deterministic>
     <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
-    <UsePublicApiAnalyzers>true</UsePublicApiAnalyzers>
+
+    <!--
+      Microsoft use Arcade to handle the building of WinForms (and other things .net).
+      See: https://github.com/dotnet/arcade/blob/main/Documentation/Overview.md
+
+      Arcade puts everything in the Artifacts folder of this repo.
+      DAT needs all output to be in the Bin folder of the repo, so we need to override Arcade
+
+      The RepoRoot variable was discovered by opening Developer Command Prompt for VS 2022 and running:
+        msbuild src\System.Windows.Forms\src\WTG.System.Windows.Forms.csproj -preprocess:out.xml
+    -->
+    <OutputPath>$([System.IO.Path]::GetFullPath('$(RepoRoot)Bin\$(OutDirName)\'))</OutputPath>
+
+    <!--<UsePublicApiAnalyzers>true</UsePublicApiAnalyzers>-->
+    <!--<NoWarn>CSIsNull001</NoWarn>
+    <NoWarn>CSIsNull002</NoWarn>
+    <NoWarn>SA1129</NoWarn>
+    <NoWarn>WFDEV001</NoWarn>
+    <NoWarn>CA1822</NoWarn>-->
+
+    <IsPackable>true</IsPackable>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <PackageId>WTG.System.Windows.Forms</PackageId>
+    <PackageDescription>WiseTech Global forked version of System.Windows.Forms that includes controls that were deprecated in .NET Core 3.1 and .NET 5, like DataGrid, Menu, ToolBar and StatusBar.</PackageDescription>
+    <Authors>WiseTech Global</Authors>
+    <Copyright>© WiseTech Global Limited. All rights reserved.</Copyright>
+
   </PropertyGroup>
 
   <ItemGroup>
@@ -23,17 +52,15 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\System.Windows.Forms.PrivateSourceGenerators\src\System.Windows.Forms.PrivateSourceGenerators.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Accessibility\src\Accessibility.ilproj" />
     <ProjectReference Include="..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
+    <ProjectReference Include="..\..\System.Windows.Forms.PrivateSourceGenerators\src\System.Windows.Forms.PrivateSourceGenerators.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Accessibility" Version="4.6.0-preview3-27504-2" />
     <PackageReference Include="Microsoft.Win32.SystemEvents" Version="$(MicrosoftWin32SystemEventsPackageVersion)" />
     <PackageReference Include="System.Configuration.ConfigurationManager" Version="$(SystemConfigurationConfigurationManagerPackageVersion)" />
+    <PackageReference Include="System.Drawing.Common" Version="$(SystemDrawingCommonPackageVersion)" />
     <PackageReference Include="System.Resources.Extensions" Version="$(SystemResourcesExtensionsPackageVersion)" />
     <PackageReference Include="System.Windows.Extensions" Version="$(SystemWindowsExtensionsPackageVersion)" />
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafePackageVersion)" />
@@ -83,4 +110,5 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/AxHost.cs b/src/System.Windows.Forms/src/System/Windows/Forms/AxHost.cs
index e26b328228a..756bd881f6d 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/AxHost.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/AxHost.cs
@@ -464,6 +464,20 @@ private void OnContainerVisibleChanged(object? sender, EventArgs e)
         }
     }
 
+    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+    public override ContextMenu ContextMenu
+    {
+        get
+        {
+            return base.ContextMenu;
+        }
+
+        set
+        {
+            base.ContextMenu = value;
+        }
+    }
+
     /// <summary>
     ///  Determines if the control is in edit mode.
     /// </summary>
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/BindingContext.cs b/src/System.Windows.Forms/src/System/Windows/Forms/BindingContext.cs
index 04ae1e3a8fd..636461b5635 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/BindingContext.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/BindingContext.cs
@@ -13,7 +13,7 @@ namespace System.Windows.Forms;
 [DefaultEvent(nameof(CollectionChanged))]
 public partial class BindingContext : ICollection
 {
-    private readonly Dictionary<HashKey, WeakReference> _listManagers;
+    private readonly Hashtable _listManagers;
 
     /// <summary>
     ///  Initializes a new instance of the System.Windows.Forms.BindingContext class.
@@ -42,7 +42,7 @@ int ICollection.Count
     void ICollection.CopyTo(Array ar, int index)
     {
         ScrubWeakRefs();
-        _listManagers.HashtableCopyTo(ar, index);
+        _listManagers.CopyTo(ar, index);
     }
 
     /// <summary>
@@ -213,6 +213,7 @@ protected virtual void RemoveCore(object dataSource)
     private BindingManagerBase EnsureListManager(object dataSource, string? dataMember)
     {
         BindingManagerBase? bindingManagerBase = null;
+        WeakReference? wRef = null;
 
         dataMember ??= string.Empty;
 
@@ -229,8 +230,9 @@ private BindingManagerBase EnsureListManager(object dataSource, string? dataMemb
 
         // Check for previously created binding manager
         HashKey key = GetKey(dataSource, dataMember);
-        if (_listManagers.TryGetValue(key, out WeakReference? wRef) && wRef is not null)
+        if (_listManagers.ContainsKey(key))
         {
+            wRef = (WeakReference)_listManagers[key];
             bindingManagerBase = (BindingManagerBase?)wRef.Target;
         }
 
@@ -320,13 +322,13 @@ private static void CheckPropertyBindingCycles(BindingContext newBindingContext,
     private void ScrubWeakRefs()
     {
         List<HashKey>? cleanupList = null;
-        foreach (KeyValuePair<HashKey, WeakReference> de in _listManagers)
+        foreach (System.Collections.DictionaryEntry de in _listManagers)
         {
-            if (de.Value.Target is null)
+            if (((WeakReference)de.Value).Target is null)
             {
                 cleanupList ??= new();
 
-                cleanupList.Add(de.Key);
+                cleanupList.Add((HashKey)de.Key);
             }
         }
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ComboBox.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ComboBox.cs
index 5c9d98ed684..e959b7d1297 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ComboBox.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ComboBox.cs
@@ -1832,7 +1832,7 @@ private void ChildWndProc(ref Message m)
                 _mousePressed = true;
                 _mouseEvents = true;
 
-                if (ContextMenuStrip is not null)
+                if (ContextMenuStrip is not null || ContextMenu is not null)
                 {
                     // Set the mouse capture as this is the child Wndproc.
                     Capture = true;
@@ -1858,6 +1858,11 @@ private void ChildWndProc(ref Message m)
                 _mousePressed = false;
                 _mouseEvents = false;
 
+                if (ContextMenu is not null)
+                {
+                    Capture = false;
+                }
+
                 DefChildWndProc(ref m);
 
                 // The message gets fired from Combo-box's WndPrc - convert to Combobox coordinates
@@ -1868,7 +1873,7 @@ private void ChildWndProc(ref Message m)
 
             case PInvoke.WM_CONTEXTMENU:
                 // Forward context menu messages to the parent control
-                if (ContextMenuStrip is not null)
+                if (ContextMenuStrip is not null || ContextMenu is not null)
                 {
                     PInvoke.SendMessage(this, PInvoke.WM_CONTEXTMENU, m.WParamInternal, m.LParamInternal);
                 }
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ContextMenu.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ContextMenu.cs
new file mode 100644
index 00000000000..5593d3e04a0
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ContextMenu.cs
@@ -0,0 +1,227 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  This class is used to put context menus on your form and show them for
+    ///  controls at runtime.  It basically acts like a regular Menu control,
+    ///  but can be set for the ContextMenu property that most controls have.
+    /// </summary>
+    [DefaultEvent(nameof(Popup))]
+    public class ContextMenu : Menu
+    {
+        private EventHandler onPopup;
+        private EventHandler onCollapse;
+        internal Control? sourceControl;
+
+        private RightToLeft rightToLeft = System.Windows.Forms.RightToLeft.Inherit;
+
+        /// <summary>
+        ///  Creates a new ContextMenu object with no items in it by default.
+        /// </summary>
+        public ContextMenu()
+            : base(null)
+        {
+        }
+
+        /// <summary>
+        ///  Creates a ContextMenu object with the given MenuItems.
+        /// </summary>
+        public ContextMenu(MenuItem[] menuItems)
+            : base(menuItems)
+        {
+        }
+
+        /// <summary>
+        ///  The last control that was acted upon that resulted in this context
+        ///  menu being displayed.
+        /// </summary>
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.ContextMenuSourceControlDescr))
+        ]
+        public Control SourceControl
+        {
+            get
+            {
+                return sourceControl;
+            }
+        }
+
+        [SRDescription(nameof(SR.MenuItemOnInitDescr))]
+        public event EventHandler Popup
+        {
+            add => onPopup += value;
+            remove => onPopup -= value;
+        }
+
+        /// <summary>
+        ///  Fires when the context menu collapses.
+        /// </summary>
+        [SRDescription(nameof(SR.ContextMenuCollapseDescr))]
+        public event EventHandler Collapse
+        {
+            add => onCollapse += value;
+            remove => onCollapse -= value;
+        }
+
+        /// <summary>
+        ///  This is used for international applications where the language
+        ///  is written from RightToLeft. When this property is true,
+        ///  text alignment and reading order will be from right to left.
+        /// </summary>
+        // Add a DefaultValue attribute so that the Reset context menu becomes
+        // available in the Property Grid but the default value remains No.
+        [
+        Localizable(true),
+        DefaultValue(RightToLeft.No),
+        SRDescription(nameof(SR.MenuRightToLeftDescr))
+        ]
+        public virtual RightToLeft RightToLeft
+        {
+            get
+            {
+                if (System.Windows.Forms.RightToLeft.Inherit == rightToLeft)
+                {
+                    if (sourceControl is not null)
+                    {
+                        return ((Control)sourceControl).RightToLeft;
+                    }
+                    else
+                    {
+                        return RightToLeft.No;
+                    }
+                }
+                else
+                {
+                    return rightToLeft;
+                }
+            }
+            set
+            {
+
+                //valid values are 0x0 to 0x2.
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)RightToLeft.No, (int)RightToLeft.Inherit))
+                {
+                    throw new InvalidEnumArgumentException(nameof(RightToLeft), (int)value, typeof(RightToLeft));
+                }
+
+                if (RightToLeft != value)
+                {
+                    rightToLeft = value;
+                    UpdateRtl((value == System.Windows.Forms.RightToLeft.Yes));
+                }
+
+            }
+        }
+
+        internal override bool RenderIsRightToLeft
+        {
+            get
+            {
+                return (rightToLeft == System.Windows.Forms.RightToLeft.Yes);
+            }
+        }
+
+        /// <summary>
+        ///  Fires the popup event
+        /// </summary>
+        protected internal virtual void OnPopup(EventArgs e)
+        {
+            onPopup?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Fires the collapse event
+        /// </summary>
+        protected internal virtual void OnCollapse(EventArgs e)
+        {
+            onCollapse?.Invoke(this, e);
+        }
+
+        protected internal virtual bool ProcessCmdKey(ref Message msg, Keys keyData, Control control)
+        {
+            sourceControl = control;
+            return ProcessCmdKey(ref msg, keyData);
+        }
+
+        private void ResetRightToLeft()
+        {
+            RightToLeft = RightToLeft.No;
+        }
+
+        /// <summary>
+        ///  Returns true if the RightToLeft should be persisted in code gen.
+        /// </summary>
+        internal virtual bool ShouldSerializeRightToLeft()
+        {
+            if (System.Windows.Forms.RightToLeft.Inherit == rightToLeft)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        ///  Displays the context menu at the specified position.  This method
+        ///  doesn't return until the menu is dismissed.
+        /// </summary>
+        public void Show(Control control, Point pos)
+        {
+            Show(control, pos, NativeMethods.TPM_VERTICAL | NativeMethods.TPM_RIGHTBUTTON);
+        }
+
+        /// <summary>
+        ///  Displays the context menu at the specified position.  This method
+        ///  doesn't return until the menu is dismissed.
+        /// </summary>
+        public void Show(Control control, Point pos, LeftRightAlignment alignment)
+        {
+            // This code below looks wrong but it's correct.
+            // WinForms Left alignment means we want the menu to show up left of the point it is invoked from.
+            // We specify TPM_RIGHTALIGN which tells win32 to align the right side of this
+            // menu with the point (which aligns it Left visually)
+            if (alignment == LeftRightAlignment.Left)
+            {
+                Show(control, pos, NativeMethods.TPM_VERTICAL | NativeMethods.TPM_RIGHTBUTTON | NativeMethods.TPM_RIGHTALIGN);
+            }
+            else
+            {
+                Show(control, pos, NativeMethods.TPM_VERTICAL | NativeMethods.TPM_RIGHTBUTTON | NativeMethods.TPM_LEFTALIGN);
+            }
+        }
+
+        private void Show(Control control, Point pos, int flags)
+        {
+            if (control == null)
+            {
+                throw new ArgumentNullException(nameof(control));
+            }
+
+            if (!control.IsHandleCreated || !control.Visible)
+            {
+                throw new ArgumentException(SR.ContextMenuInvalidParent, "control");
+            }
+
+            sourceControl = control;
+
+            OnPopup(EventArgs.Empty);
+            pos = control.PointToScreen(pos);
+            SafeNativeMethods.TrackPopupMenuEx(new HandleRef(this, Handle),
+                flags,
+                pos.X,
+                pos.Y,
+                new HandleRef(control, control.Handle),
+                null);
+        }
+
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/Control.cs b/src/System.Windows.Forms/src/System/Windows/Forms/Control.cs
index d90366ec2bc..7183f6e20be 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/Control.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/Control.cs
@@ -199,6 +199,164 @@ private protected void TraceCanProcessMnemonic()
     private static MessageId s_threadCallbackMessage;
     private static ContextCallback? s_invokeMarshaledCallbackHelperDelegate;
 
+    internal static IntPtr SetUpPalette(IntPtr dc, bool force, bool realizePalette)
+    {
+        Debug.WriteLineIf(s_paletteTracing.TraceVerbose, "SetUpPalette(force:=" + force + ", ralizePalette:=" + realizePalette + ")");
+
+        IntPtr halftonePalette = Graphics.GetHalftonePalette();
+
+        Debug.WriteLineIf(s_paletteTracing.TraceVerbose, "select palette " + !force);
+        IntPtr result = Gdi32.SelectPalette(dc, halftonePalette, force ? BOOL.FALSE : BOOL.TRUE);
+        if (result != IntPtr.Zero && realizePalette)
+        {
+            Gdi32.RealizePalette(dc);
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    ///  Handles the WM_MENUSELECT message
+    /// </summary>
+    private void WmMenuSelect(ref Message m)
+    {
+        int item = NativeMethods.Util.LOWORD(m.WParam);
+        User32.MF flags = (User32.MF)NativeMethods.Util.HIWORD(m.WParam);
+        IntPtr hmenu = m.LParam;
+        MenuItem mi = null;
+
+        if ((flags & User32.MF.SYSMENU) != 0)
+        {
+            // nothing
+        }
+        else if ((flags & User32.MF.POPUP) == 0)
+        {
+            Command cmd = Command.GetCommandFromID(item);
+            if (cmd != null)
+            {
+                object reference = cmd.Target;
+                if (reference != null && reference is MenuItem.MenuItemData)
+                {
+                    mi = ((MenuItem.MenuItemData)reference).baseItem;
+                }
+            }
+        }
+        else
+        {
+            mi = GetMenuItemFromHandleId(hmenu, item);
+        }
+
+        if (mi != null)
+        {
+            mi.PerformSelect();
+        }
+
+        DefWndProc(ref m);
+    }
+
+    /// <summary>
+    ///  WM_DRAWITEM handler
+    /// </summary>
+    private void WmDrawItem(ref Message m)
+    {
+        // If the wparam is zero, then the message was sent by a menu.
+        // See WM_DRAWITEM in MSDN.
+        if (m.WParamInternal == 0u)
+        {
+            WmDrawItemMenuItem(ref m);
+        }
+        else
+        {
+            WmOwnerDraw(ref m);
+        }
+    }
+
+    private unsafe void WmDrawItemMenuItem(ref Message m)
+    {
+        // Obtain the menu item object
+        User32.DRAWITEMSTRUCT* dis = (User32.DRAWITEMSTRUCT*)m.LParam;
+
+        // A pointer to the correct MenuItem is stored in the draw item
+        // information sent with the message.
+        // (See MenuItem.CreateMenuItemInfo)
+        MenuItem menuItem = MenuItem.GetMenuItemFromItemData(dis->itemData);
+
+        // Delegate this message to the menu item
+        menuItem?.WmDrawItem(ref m);
+    }
+
+    /// <summary>
+    ///  WM_MEASUREITEM handler
+    /// </summary>
+    private unsafe void WmMeasureItem(ref Message m)
+    {
+        // If the wparam is zero, then the message was sent by a menu.
+        // See WM_MEASUREITEM in MSDN.
+        if (m.WParamInternal == 0u)
+        {
+            // Obtain the menu item object
+            Debug.Assert(m.LParam != IntPtr.Zero, "m.lparam is null");
+            User32.MEASUREITEMSTRUCT* mis = (User32.MEASUREITEMSTRUCT*)m.LParam;
+
+            // A pointer to the correct MenuItem is stored in the measure item
+            // information sent with the message.
+            // (See MenuItem.CreateMenuItemInfo)
+            MenuItem menuItem = MenuItem.GetMenuItemFromItemData(mis->itemData);
+            Debug.Assert(menuItem != null, "UniqueID is not associated with a menu item");
+
+            // Delegate this message to the menu item
+            menuItem?.WmMeasureItem(ref m);
+        }
+        else
+        {
+            WmOwnerDraw(ref m);
+        }
+    }
+
+    private MenuItem GetMenuItemFromHandleId(IntPtr hmenu, int item)
+    {
+        MenuItem mi = null;
+        int id = User32.GetMenuItemID(hmenu, item);
+        if (id == unchecked((int)0xFFFFFFFF))
+        {
+            IntPtr childMenu = IntPtr.Zero;
+            childMenu = User32.GetSubMenu(hmenu, item);
+            int count = User32.GetMenuItemCount(childMenu);
+            MenuItem found = null;
+            for (int i = 0; i < count; i++)
+            {
+                found = GetMenuItemFromHandleId(childMenu, i);
+                if (found != null)
+                {
+                    Menu parent = found.Parent;
+                    if (parent != null && parent is MenuItem)
+                    {
+                        found = (MenuItem)parent;
+                        break;
+                    }
+
+                    found = null;
+                }
+            }
+
+            mi = found;
+        }
+        else
+        {
+            Command cmd = Command.GetCommandFromID(id);
+            if (cmd != null)
+            {
+                object reference = cmd.Target;
+                if (reference != null && reference is MenuItem.MenuItemData)
+                {
+                    mi = ((MenuItem.MenuItemData)reference).baseItem;
+                }
+            }
+        }
+
+        return mi;
+    }
+
 #pragma warning disable IDE1006 // Naming Styles
     [ThreadStatic]
     private static bool t_inCrossThreadSafeCall;
@@ -1377,6 +1535,90 @@ public bool ContainsFocus
         }
     }
 
+    private static readonly int s_contextMenuProperty = PropertyStore.CreateKey();
+
+    private void DetachContextMenu(object sender, EventArgs e) => ContextMenu = null;
+
+    private static readonly object s_contextMenuEvent = new object();
+
+    [EditorBrowsable(EditorBrowsableState.Advanced)]
+    protected virtual void OnContextMenuChanged(EventArgs e)
+    {
+        if (Events[s_contextMenuEvent] is EventHandler eh)
+        {
+            eh(this, e);
+        }
+    }
+
+    /// <summary>
+    ///  Handles the WM_MENUCHAR message
+    /// </summary>
+    private void WmMenuChar(ref Message m)
+    {
+        Menu menu = ContextMenu;
+        if (menu != null)
+        {
+            menu.WmMenuChar(ref m);
+            if (m.Result != IntPtr.Zero)
+            {
+                // This char is a mnemonic on our menu.
+                return;
+            }
+        }
+    }
+
+    /// <summary>
+    ///  The contextMenu associated with this control. The contextMenu
+    ///  will be shown when the user right clicks the mouse on the control.
+    ///
+    ///  Whidbey: ContextMenu is browsable false.  In all cases where both a context menu
+    ///  and a context menu strip are assigned, context menu will be shown instead of context menu strip.
+    /// </summary>
+    [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(null),
+        SRDescription(nameof(SR.ControlContextMenuDescr)),
+        Browsable(false)
+    ]
+    public virtual ContextMenu? ContextMenu
+    {
+        get => (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+        set
+        {
+            ContextMenu oldValue = (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+
+            if (oldValue != value)
+            {
+                EventHandler disposedHandler = new EventHandler(DetachContextMenu);
+
+                if (oldValue != null)
+                {
+                    oldValue.Disposed -= disposedHandler;
+                }
+
+                Properties.SetObject(s_contextMenuProperty, value);
+
+                if (value != null)
+                {
+                    value.Disposed += disposedHandler;
+                }
+
+                OnContextMenuChanged(EventArgs.Empty);
+            }
+        }
+    }
+
+    [
+        SRCategory(nameof(SR.CatPropertyChanged)),
+        SRDescription(nameof(SR.ControlOnContextMenuChangedDescr)),
+        Browsable(false)
+    ]
+    public event EventHandler ContextMenuChanged
+    {
+        add => Events.AddHandler(s_contextMenuEvent, value);
+        remove => Events.RemoveHandler(s_contextMenuEvent, value);
+    }
+
     /// <summary>
     ///  The contextMenuStrip associated with this control. The contextMenuStrip
     ///  will be shown when the user right clicks the mouse on the control.
@@ -1421,6 +1663,31 @@ public event EventHandler? ContextMenuStripChanged
         remove => Events.RemoveHandler(s_contextMenuStripEvent, value);
     }
 
+    /// <summary>
+    ///  Sends a Win32 message to this control.  If the control does not yet
+    ///  have a handle, it will be created.
+    /// </summary>
+    internal IntPtr SendMessage(int msg, int wparam, int lparam)
+    {
+        return UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), msg, wparam, lparam);
+    }
+
+    /// <summary>
+    ///  Sends a Win32 message to this control.  If the control does not yet
+    ///  have a handle, it will be created.
+    /// </summary>
+    internal IntPtr SendMessage(int msg, int wparam, string lparam)
+    {
+        Debug.Assert(IsHandleCreated, "Performance alert!  Calling Control::SendMessage and forcing handle creation.  Re-work control so handle creation is not required to set properties.  If there is no work around, wrap the call in an IsHandleCreated check.");
+        return UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), msg, wparam, lparam);
+    }
+
+    internal IntPtr SendMessage(int msg, IntPtr wparam, IntPtr lparam)
+    {
+        Debug.Assert(IsHandleCreated, "Performance alert!  Calling Control::SendMessage and forcing handle creation.  Re-work control so handle creation is not required to set properties.  If there is no work around, wrap the call in an IsHandleCreated check.");
+        return UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), msg, wparam, lparam);
+    }
+
     /// <summary>
     ///  Collection of child controls.
     /// </summary>
@@ -2459,6 +2726,8 @@ public bool HasChildren
         }
     }
 
+    internal virtual bool HasMenu => false;
+
     /// <summary>
     ///  The height of this control
     /// </summary>
@@ -5097,6 +5366,12 @@ protected override void Dispose(bool disposing)
                 DisposeAxControls();
                 ((ActiveXImpl?)Properties.GetObject(s_activeXImplProperty))?.Dispose();
 
+                ContextMenu contextMenu = (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+                if (contextMenu != null)
+                {
+                    contextMenu.Disposed -= new EventHandler(DetachContextMenu);
+                }
+
                 ResetBindings();
 
                 if (IsHandleCreated)
@@ -5706,11 +5981,11 @@ protected virtual Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, Boun
         CreateParams cp = CreateParams;
 
         // We would need to get adornments metrics for both (old and new) Dpi in case application is in PerMonitorV2 mode and Dpi changed.
-        AdjustWindowRectExForControlDpi(ref adornmentsAfterDpiChange, (WINDOW_STYLE)cp.Style, bMenu: false, (WINDOW_EX_STYLE)cp.ExStyle);
+        AdjustWindowRectExForControlDpi(ref adornmentsAfterDpiChange, (WINDOW_STYLE)cp.Style, bMenu: HasMenu, (WINDOW_EX_STYLE)cp.ExStyle);
 
         if (_oldDeviceDpi != _deviceDpi && OsVersion.IsWindows10_1703OrGreater())
         {
-            AdjustWindowRectExForDpi(ref adornmentsBeforeDpiChange, (WINDOW_STYLE)cp.Style, bMenu: false, (WINDOW_EX_STYLE)cp.ExStyle, _oldDeviceDpi);
+            AdjustWindowRectExForDpi(ref adornmentsBeforeDpiChange, (WINDOW_STYLE)cp.Style, bMenu: HasMenu, (WINDOW_EX_STYLE)cp.ExStyle, _oldDeviceDpi);
         }
         else
         {
@@ -9231,6 +9506,12 @@ protected virtual bool ProcessCmdKey(ref Message msg, Keys keyData)
     {
         s_controlKeyboardRouting.TraceVerbose($"Control.ProcessCmdKey {msg}");
 
+        ContextMenu contextMenu = (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+        if (contextMenu != null && contextMenu.ProcessCmdKey(ref msg, keyData, this))
+        {
+            return true;
+        }
+
         if (_parent is not null)
         {
             return _parent.ProcessCmdKey(ref msg, keyData);
@@ -10347,7 +10628,7 @@ protected virtual void ScaleControl(SizeF factor, BoundsSpecified specified)
     {
         CreateParams cp = CreateParams;
         RECT adornments = default;
-        AdjustWindowRectExForControlDpi(ref adornments, (WINDOW_STYLE)cp.Style, false, (WINDOW_EX_STYLE)cp.ExStyle);
+        AdjustWindowRectExForControlDpi(ref adornments, (WINDOW_STYLE)cp.Style, HasMenu, (WINDOW_EX_STYLE)cp.ExStyle);
         Size minSize = MinimumSize;
         Size maxSize = MaximumSize;
 
@@ -10829,7 +11110,7 @@ internal Size SizeFromClientSizeInternal(Size size)
     {
         RECT rect = new(size);
         CreateParams cp = CreateParams;
-        AdjustWindowRectExForControlDpi(ref rect, (WINDOW_STYLE)cp.Style, false, (WINDOW_EX_STYLE)cp.ExStyle);
+        AdjustWindowRectExForControlDpi(ref rect, (WINDOW_STYLE)cp.Style, HasMenu, (WINDOW_EX_STYLE)cp.ExStyle);
         return rect.Size;
     }
 
@@ -11836,8 +12117,9 @@ internal virtual void WmContextMenu(ref Message m)
     /// </summary>
     internal void WmContextMenu(ref Message m, Control sourceControl)
     {
+        var contextMenu = Properties.GetObject(s_contextMenuProperty) as ContextMenu;
         var contextMenuStrip = (ContextMenuStrip?)Properties.GetObject(s_contextMenuStripProperty);
-        if (contextMenuStrip is not null)
+        if (contextMenu != null || contextMenuStrip != null)
         {
             int x = PARAM.SignedLOWORD(m.LParamInternal);
             int y = PARAM.SignedHIWORD(m.LParamInternal);
@@ -11855,9 +12137,22 @@ internal void WmContextMenu(ref Message m, Control sourceControl)
                 client = PointToClient(new Point(x, y));
             }
 
+            // VisualStudio7 # 156, only show the context menu when clicked in the client area
             if (ClientRectangle.Contains(client))
             {
-                contextMenuStrip.ShowInternal(sourceControl, client, keyboardActivated);
+                if (contextMenu != null)
+                {
+                    contextMenu.Show(sourceControl, client);
+                }
+                else if (contextMenuStrip != null)
+                {
+                    contextMenuStrip.ShowInternal(sourceControl, client, keyboardActivated);
+                }
+                else
+                {
+                    Debug.Fail("contextmenu and contextmenustrip are both null... hmm how did we get here?");
+                    DefWndProc(ref m);
+                }
             }
             else
             {
@@ -11928,6 +12223,26 @@ private void WmEraseBkgnd(ref Message m)
         }
     }
 
+    /// <summary>
+    ///  Handles the WM_EXITMENULOOP message. If this control has a context menu, its
+    ///  Collapse event is raised.
+    /// </summary>
+    private void WmExitMenuLoop(ref Message m)
+    {
+        bool isContextMenu = (unchecked((int)(long)m.WParam) == 0) ? false : true;
+
+        if (isContextMenu)
+        {
+            ContextMenu contextMenu = (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+            if (contextMenu != null)
+            {
+                contextMenu.OnCollapse(EventArgs.Empty);
+            }
+        }
+
+        DefWndProc(ref m);
+    }
+
     /// <summary>
     ///  Handles the WM_GETCONTROLNAME message. Returns the name of the control.
     /// </summary>
@@ -12037,6 +12352,24 @@ private unsafe void WmHelp(ref Message m)
         }
     }
 
+    /// <summary>
+    ///  Handles the WM_INITMENUPOPUP message
+    /// </summary>
+    private void WmInitMenuPopup(ref Message m)
+    {
+        ContextMenu contextMenu = (ContextMenu)Properties.GetObject(s_contextMenuProperty);
+        if (contextMenu != null)
+        {
+
+            if (contextMenu.ProcessInitMenuPopup(m.WParam))
+            {
+                return;
+            }
+        }
+
+        DefWndProc(ref m);
+    }
+
     /// <summary>
     ///  Handles the WM_CREATE message
     /// </summary>
@@ -12955,17 +13288,17 @@ protected virtual void WndProc(ref Message m)
                 break;
 
             case PInvoke.WM_DRAWITEM:
-                if (m.WParamInternal != 0u)
-                {
-                    WmOwnerDraw(ref m);
-                }
-
+                WmDrawItem(ref m);
                 break;
 
             case PInvoke.WM_ERASEBKGND:
                 WmEraseBkgnd(ref m);
                 break;
 
+            case PInvoke.WM_EXITMENULOOP:
+                WmExitMenuLoop(ref m);
+                break;
+
             case PInvoke.WM_HELP:
                 WmHelp(ref m);
                 break;
@@ -12994,6 +13327,10 @@ protected virtual void WndProc(ref Message m)
 
                 break;
 
+            case WindowMessages.WM_INITMENUPOPUP:
+                WmInitMenuPopup(ref m);
+                break;
+
             case PInvoke.WM_SYSCOMMAND:
                 if ((m.WParamInternal & 0xFFF0) == PInvoke.SC_KEYMENU)
                 {
@@ -13020,11 +13357,7 @@ protected virtual void WndProc(ref Message m)
                 break;
 
             case PInvoke.WM_MEASUREITEM:
-                if (m.WParamInternal != 0u)
-                {
-                    WmOwnerDraw(ref m);
-                }
-
+                WmMeasureItem(ref m);
                 break;
 
             case PInvoke.WM_SETCURSOR:
@@ -13242,9 +13575,9 @@ protected virtual void WndProc(ref Message m)
                 WmParentNotify(ref m);
                 break;
 
-            case PInvoke.WM_EXITMENULOOP:
-            case PInvoke.WM_INITMENUPOPUP:
             case PInvoke.WM_MENUSELECT:
+                WmMenuSelect(ref m);
+                break;
             default:
 
                 // If we received a thread execute message, then execute it.
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ControlPaint.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ControlPaint.cs
index e920050cc25..54869817352 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ControlPaint.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ControlPaint.cs
@@ -6,6 +6,7 @@
 using System.Drawing.Drawing2D;
 using System.Drawing.Imaging;
 using System.Runtime.InteropServices;
+using static Interop;
 
 namespace System.Windows.Forms;
 
@@ -352,6 +353,26 @@ internal static unsafe HBRUSH CreateHalftoneHBRUSH()
         return PInvoke.CreateBrushIndirect(&lb);
     }
 
+    internal static unsafe Interop.Gdi32.HBRUSH CreateHalftoneHBRUSH2()
+    {
+        short* grayPattern = stackalloc short[8];
+        for (int i = 0; i < 8; i++)
+        {
+            grayPattern[i] = (short)(0x5555 << (i & 1));
+        }
+
+        using PInvoke.CreateBitmapScope hBitmap = new(8, 8, 1, 1, grayPattern);
+
+        LOGBRUSH lb = new()
+        {
+            lbStyle = BRUSH_STYLE.BS_PATTERN,
+            lbColor = default, // color is ignored since style is BS.PATTERN
+            lbHatch = (nuint)(IntPtr)hBitmap
+        };
+
+        return Gdi32.CreateBrushIndirect(ref lb);
+    }
+
     /// <summary>
     ///  Draws a border of the specified style and color to the given graphics.
     /// </summary>
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGrid.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGrid.cs
new file mode 100644
index 00000000000..dc519cab57e
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGrid.cs
@@ -0,0 +1,10766 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Drawing;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Text;
+using static System.Windows.Forms.Triangle;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Displays ADO.NET data in a scrollable grid.
+    /// </summary>
+    [
+    ComVisible(true),
+    ClassInterface(ClassInterfaceType.AutoDispatch),
+    Designer("System.Windows.Forms.Design.DataGridDesigner, " + AssemblyRef.SystemDesign),
+    DefaultProperty(nameof(DataSource)),
+    DefaultEvent(nameof(Navigate)),
+    ComplexBindingProperties(nameof(DataSource), nameof(DataMember)),
+    ]
+    public class DataGrid : Control, ISupportInitialize, IDataGridEditingService
+    {
+#if DEBUG
+        internal TraceSwitch DataGridAcc = new TraceSwitch("DataGridAcc", "Trace Windows Forms DataGrid Accessibility");
+#else
+            internal TraceSwitch DataGridAcc = null;
+#endif
+
+        private const int GRIDSTATE_allowSorting = 0x00000001;
+        private const int GRIDSTATE_columnHeadersVisible = 0x00000002;
+        private const int GRIDSTATE_rowHeadersVisible = 0x00000004;
+        private const int GRIDSTATE_trackColResize = 0x00000008;
+        private const int GRIDSTATE_trackRowResize = 0x00000010;
+        private const int GRIDSTATE_isLedgerStyle = 0x00000020;
+        private const int GRIDSTATE_isFlatMode = 0x00000040;
+        private const int GRIDSTATE_listHasErrors = 0x00000080;
+        private const int GRIDSTATE_dragging = 0x00000100;
+        private const int GRIDSTATE_inListAddNew = 0x00000200;
+        private const int GRIDSTATE_inDeleteRow = 0x00000400;
+        private const int GRIDSTATE_canFocus = 0x00000800;
+        private const int GRIDSTATE_readOnlyMode = 0x00001000;
+        private const int GRIDSTATE_allowNavigation = 0x00002000;
+        private const int GRIDSTATE_isNavigating = 0x00004000;
+        private const int GRIDSTATE_isEditing = 0x00008000;
+        private const int GRIDSTATE_editControlChanging = 0x00010000;
+        private const int GRIDSTATE_isScrolling = 0x00020000;
+        private const int GRIDSTATE_overCaption = 0x00040000;
+        private const int GRIDSTATE_childLinkFocused = 0x00080000;
+        private const int GRIDSTATE_inAddNewRow = 0x00100000;
+        private const int GRIDSTATE_inSetListManager = 0x00200000;
+        private const int GRIDSTATE_metaDataChanged = 0x00400000;
+        private const int GRIDSTATE_exceptionInPaint = 0x00800000;
+        private const int GRIDSTATE_layoutSuspended = 0x01000000;
+
+        // PERF: take all the bools and put them into a state variable
+        private Collections.Specialized.BitVector32 gridState;                  // see GRIDSTATE_ consts above
+
+        // for column widths
+        private const int NumRowsForAutoResize = 10;
+
+        private const int errorRowBitmapWidth = 15;
+
+        private const DataGridParentRowsLabelStyle defaultParentRowsLabelStyle = DataGridParentRowsLabelStyle.Both;
+
+        private const BorderStyle defaultBorderStyle = BorderStyle.Fixed3D;
+
+        private const bool defaultCaptionVisible = true;
+
+        private const bool defaultParentRowsVisible = true;
+
+        private readonly DataGridTableStyle defaultTableStyle = new DataGridTableStyle(true);
+
+        // private bool allowSorting = true;
+
+        private SolidBrush alternatingBackBrush = DefaultAlternatingBackBrush;
+
+        // private bool columnHeadersVisible = true;
+
+        private SolidBrush gridLineBrush = DefaultGridLineBrush;
+
+        private const DataGridLineStyle defaultGridLineStyle = DataGridLineStyle.Solid;
+        private DataGridLineStyle gridLineStyle = defaultGridLineStyle;
+
+        private SolidBrush headerBackBrush = DefaultHeaderBackBrush;
+
+        private Font headerFont; // this is ambient property to Font value
+
+        private SolidBrush headerForeBrush = DefaultHeaderForeBrush;
+        private Pen headerForePen = DefaultHeaderForePen;
+
+        private SolidBrush linkBrush = DefaultLinkBrush;
+
+        private const int defaultPreferredColumnWidth = 75;
+        private int preferredColumnWidth = defaultPreferredColumnWidth;
+
+        private static readonly int defaultFontHeight = Control.DefaultFont.Height;
+        private int preferredRowHeight = defaultFontHeight + 3;
+
+        // private bool rowHeadersVisible = true;
+        private const int defaultRowHeaderWidth = 35;
+        private int rowHeaderWidth = defaultRowHeaderWidth;
+        private int minRowHeaderWidth;
+
+        private SolidBrush selectionBackBrush = DefaultSelectionBackBrush;
+        private SolidBrush selectionForeBrush = DefaultSelectionForeBrush;
+
+        // parent rows
+        //
+        private readonly DataGridParentRows parentRows;
+        // Set_ListManager uses the originalState to determine
+        // if the grid should disconnect from all the MetaDataChangedEvents
+        // keep "originalState != null" when navigating back and forth in the grid
+        // and use Add/RemoveMetaDataChanged methods.
+        private DataGridState originalState;
+
+        // ui state
+        //
+        // Don't use dataGridRows, use the accessor!!!
+        private DataGridRow[] dataGridRows = Array.Empty<DataGridRow>();
+        private int dataGridRowsLength;
+
+        // for toolTip
+        private int toolTipId;
+        private DataGridToolTip toolTipProvider;
+
+        private DataGridAddNewRow addNewRow;
+        private LayoutData layout = new LayoutData();
+        private RECT[] cachedScrollableRegion;
+
+        // header namespace goo
+        //
+
+        // these are actually get/set by ColumnBehavior
+        internal bool allowColumnResize = true;
+
+        internal bool allowRowResize = true;
+
+        internal DataGridParentRowsLabelStyle parentRowsLabels = defaultParentRowsLabelStyle;
+
+        // information for col/row resizing
+        // private bool       trackColResize         = false;
+        private int trackColAnchor;
+        private int trackColumn;
+        // private bool       trackRowResize         = false;
+        private int trackRowAnchor;
+        private int trackRow;
+        private PropertyDescriptor trackColumnHeader;
+        private MouseEventArgs lastSplitBar;
+
+        // private bool isLedgerStyle = true;
+        // private bool isFlatMode    = false;
+        private Font linkFont;
+
+        private SolidBrush backBrush = DefaultBackBrush;
+        private SolidBrush foreBrush = DefaultForeBrush;
+        private SolidBrush backgroundBrush = DefaultBackgroundBrush;
+
+        // font cacheing info
+        private int fontHeight = -1;
+        private int linkFontHeight = -1;
+        private int captionFontHeight = -1;
+        private int headerFontHeight = -1;
+
+        // the preffered height of the row.
+
+        // if the list has items with errors
+
+        // private bool listHasErrors = false;
+
+        // caption
+        private readonly DataGridCaption caption;
+
+        // Border
+        //
+        private BorderStyle borderStyle;
+
+        // data binding
+        //
+        private object dataSource;
+        private string dataMember = string.Empty;
+        private CurrencyManager listManager;
+
+        // currently focused control
+        // we want to unparent it either when rebinding the grid or when the grid is disposed
+        Control toBeDisposedEditingControl;
+
+        // persistent data state
+        //
+        internal GridTableStylesCollection dataGridTables;
+        // SET myGridTable in SetDataGridTable ONLY
+        internal DataGridTableStyle myGridTable;
+        internal bool checkHierarchy = true;
+        internal bool inInit;
+
+        // Selection
+        internal int currentRow;
+        internal int currentCol;
+        private int numSelectedRows;
+        private int lastRowSelected = -1;
+
+        // dragging:
+        // private bool dragging = false;
+
+        // addNewRow
+        // private bool inAddNewRow = false;
+        // delete Row
+        // private bool inDeleteRow = false;
+
+        // when we leave, we call CommitEdit
+        // if we leave, then do not focus the dataGrid.
+        // so we can't focus the grid at the following moments:
+        // 1. while processing the OnLayout event
+        // 2. while processing the OnLeave event
+        // private bool canFocus = true;
+
+        // for CurrentCell
+#if DEBUG
+        private bool inDataSource_PositionChanged;
+#endif // DEBUG
+
+        // Policy
+        // private bool   readOnlyMode = false;
+        private readonly Policy policy = new Policy();
+        // private bool allowNavigation = true;
+
+        // editing
+        // private bool isNavigating = false;
+        // private bool isEditing = false;
+        // private bool editControlChanging = false;
+        private DataGridColumnStyle editColumn;
+        private DataGridRow editRow;
+
+        // scrolling
+        //
+        private readonly ScrollBar horizScrollBar = new HScrollBar();
+        private readonly ScrollBar vertScrollBar = new VScrollBar();
+
+        // the sum of the widths of the columns preceding the firstVisibleColumn
+        //
+        private int horizontalOffset;
+
+        // the number of pixels of the firstVisibleColumn which are not visible
+        //
+        private int negOffset;
+
+        private int wheelDelta;
+        // private bool      isScrolling = false;
+
+        // Visibility
+        //
+        internal int firstVisibleRow;
+        internal int firstVisibleCol;
+        private int numVisibleRows;
+        // the number of columns which are visible
+        private int numVisibleCols;
+        private int numTotallyVisibleRows;
+        // lastTotallyVisibleCol == -1 means that the data grid does not show any column in its entirety
+        private int lastTotallyVisibleCol;
+
+        // mouse move hot-tracking
+        //
+        private int oldRow = -1;
+        // private bool overCaption = true;
+
+        // child relationships focused
+        //
+        // private bool childLinkFocused = false;
+
+        // private static readonly object EVENT_COLUMNHEADERCLICK = new object();
+        private static readonly object EVENT_CURRENTCELLCHANGED = new object();
+        // private static readonly object EVENT_COLUMNRESIZE = new object();
+        // private static readonly object EVENT_LINKCLICKED = new object();
+        private static readonly object EVENT_NODECLICKED = new object();
+        // private static readonly object EVENT_ROWRESIZE = new object();
+        private static readonly object EVENT_SCROLL = new object();
+        private static readonly object EVENT_BACKBUTTONCLICK = new object();
+        private static readonly object EVENT_DOWNBUTTONCLICK = new object();
+
+        // event handlers
+        //
+        private readonly ItemChangedEventHandler itemChangedHandler;
+        private readonly EventHandler positionChangedHandler;
+        private readonly EventHandler currentChangedHandler;
+        private readonly EventHandler metaDataChangedHandler;
+
+        // we have to know when the collection of dataGridTableStyles changes
+        private readonly CollectionChangeEventHandler dataGridTableStylesCollectionChanged;
+
+        private readonly EventHandler backButtonHandler;
+        private readonly EventHandler downButtonHandler;
+
+        private NavigateEventHandler onNavigate;
+
+        private EventHandler onRowHeaderClick;
+
+        // forDebug
+        //
+        // private int forDebug = 0;
+
+        // =-----------------------------------------------------------------
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGrid'/>
+        ///  class.
+        /// </summary>
+        public DataGrid() : base()
+        {
+            SetStyle(ControlStyles.UserPaint, true);
+            SetStyle(ControlStyles.Opaque, false);
+            SetStyle(ControlStyles.SupportsTransparentBackColor, false);
+            SetStyle(ControlStyles.UserMouse, true);
+            gridState = new Collections.Specialized.BitVector32(0x00042827);
+
+            dataGridTables = new GridTableStylesCollection(this);
+            layout = CreateInitialLayoutState();
+            parentRows = new DataGridParentRows(this);
+
+            horizScrollBar.Top = ClientRectangle.Height - horizScrollBar.Height;
+            horizScrollBar.Left = 0;
+            horizScrollBar.Visible = false;
+            horizScrollBar.Scroll += new ScrollEventHandler(GridHScrolled);
+            Controls.Add(horizScrollBar);
+
+            vertScrollBar.Top = 0;
+            vertScrollBar.Left = ClientRectangle.Width - vertScrollBar.Width;
+            vertScrollBar.Visible = false;
+            vertScrollBar.Scroll += new ScrollEventHandler(GridVScrolled);
+            Controls.Add(vertScrollBar);
+
+            BackColor = DefaultBackBrush.Color;
+            ForeColor = DefaultForeBrush.Color;
+            borderStyle = defaultBorderStyle;
+
+            // create the event handlers
+            //
+            currentChangedHandler = new EventHandler(DataSource_RowChanged);
+            positionChangedHandler = new EventHandler(DataSource_PositionChanged);
+            itemChangedHandler = new ItemChangedEventHandler(DataSource_ItemChanged);
+            metaDataChangedHandler = new EventHandler(DataSource_MetaDataChanged);
+            dataGridTableStylesCollectionChanged = new CollectionChangeEventHandler(TableStylesCollectionChanged);
+            dataGridTables.CollectionChanged += dataGridTableStylesCollectionChanged;
+
+            SetDataGridTable(defaultTableStyle, true);
+
+            backButtonHandler = new EventHandler(OnBackButtonClicked);
+            downButtonHandler = new EventHandler(OnShowParentDetailsButtonClicked);
+
+            caption = new DataGridCaption(this);
+            caption.BackwardClicked += backButtonHandler;
+            caption.DownClicked += downButtonHandler;
+
+            RecalculateFonts();
+            Size = new Size(130, 80);
+            Invalidate();
+            PerformLayout();
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the grid can be resorted by clicking on
+        ///  a column header.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(true),
+        SRDescription(nameof(SR.DataGridAllowSortingDescr))
+        ]
+        public bool AllowSorting
+        {
+            get
+            {
+                return gridState[GRIDSTATE_allowSorting];
+            }
+            set
+            {
+                if (AllowSorting != value)
+                {
+                    gridState[GRIDSTATE_allowSorting] = value;
+                    if (!value && listManager != null)
+                    {
+                        IList list = listManager.List;
+                        if (list is IBindingList)
+                        {
+                            ((IBindingList)list).RemoveSort();
+                        }
+                    }
+                }
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridAlternatingBackColorDescr))
+        ]
+        public Color AlternatingBackColor
+        {
+            get
+            {
+                return alternatingBackBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor,
+                                                              "AlternatingBackColor"));
+                }
+
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentAlternatingBackColorNotAllowed);
+                }
+
+                if (!alternatingBackBrush.Color.Equals(value))
+                {
+                    alternatingBackBrush = new SolidBrush(value);
+                    InvalidateInside();
+                }
+            }
+        }
+
+        public void ResetAlternatingBackColor()
+        {
+            if (ShouldSerializeAlternatingBackColor())
+            {
+                AlternatingBackColor = DefaultAlternatingBackBrush.Color;
+                InvalidateInside();
+            }
+        }
+
+        protected virtual bool ShouldSerializeAlternatingBackColor()
+        {
+            return !AlternatingBackBrush.Equals(DefaultAlternatingBackBrush);
+        }
+
+        internal Brush AlternatingBackBrush
+        {
+            get
+            {
+                return alternatingBackBrush;
+            }
+        }
+
+        // overrode those properties just to move the BackColor and the ForeColor
+        // from the Appearance group onto the Color Group
+        /// <summary>
+        ///  Gets or sets the background color of the grid.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.ControlBackColorDescr))
+        ]
+        public override Color BackColor
+        {
+            // overrode those properties just to move the BackColor and the ForeColor
+            // from the Appearance group onto the Color Group
+            get
+            {
+                return base.BackColor;
+            }
+            set
+            {
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentBackColorNotAllowed);
+                }
+
+                base.BackColor = value;
+            }
+        }
+
+        public override void ResetBackColor()
+        {
+            if (!BackColor.Equals(DefaultBackBrush.Color))
+            {
+                BackColor = DefaultBackBrush.Color;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.ControlForeColorDescr))
+        ]
+        public override Color ForeColor
+        {
+            get
+            {
+                return base.ForeColor;
+            }
+            set
+            {
+                base.ForeColor = value;
+            }
+        }
+
+        public override void ResetForeColor()
+        {
+            if (!ForeColor.Equals(DefaultForeBrush.Color))
+            {
+                ForeColor = DefaultForeBrush.Color;
+            }
+        }
+
+        /// <summary>
+        ///  Gets a value
+        ///  indicating whether the <see cref='AlternatingBackColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        internal SolidBrush BackBrush
+        {
+            get
+            {
+                return backBrush;
+            }
+        }
+
+        internal SolidBrush ForeBrush
+        {
+            get
+            {
+                return foreBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the border style.
+        /// </summary>
+        [SRCategory(nameof(SR.CatAppearance))]
+        [DefaultValue(defaultBorderStyle)]
+        [DispId((int)Ole32.DispatchID.BORDERSTYLE)]
+        [SRDescription(nameof(SR.DataGridBorderStyleDescr))]
+        public BorderStyle BorderStyle
+        {
+            get => borderStyle;
+            set
+            {
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)BorderStyle.None, (int)BorderStyle.Fixed3D))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(BorderStyle));
+                }
+
+                if (borderStyle != value)
+                {
+                    borderStyle = value;
+                    PerformLayout();
+                    Invalidate();
+                    OnBorderStyleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_BORDERSTYLECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnBorderStyleChangedDescr))]
+        public event EventHandler BorderStyleChanged
+        {
+            add => Events.AddHandler(EVENT_BORDERSTYLECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_BORDERSTYLECHANGED, value);
+        }
+
+        private int BorderWidth
+        {
+            get
+            {
+                if (BorderStyle == BorderStyle.Fixed3D)
+                {
+                    return SystemInformation.Border3DSize.Width;
+                }
+                else if (BorderStyle == BorderStyle.FixedSingle)
+                {
+                    return 2;
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+        }
+
+        protected override Size DefaultSize
+        {
+            get
+            {
+                return new Size(130, 80);
+            }
+        }
+
+        private static SolidBrush DefaultSelectionBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaption;
+            }
+        }
+
+        private static SolidBrush DefaultSelectionForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaptionText;
+            }
+        }
+
+        internal static SolidBrush DefaultBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Window;
+            }
+        }
+
+        internal static SolidBrush DefaultForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.WindowText;
+            }
+        }
+
+        private static SolidBrush DefaultBackgroundBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.AppWorkspace;
+            }
+        }
+
+        internal static SolidBrush DefaultParentRowsForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.WindowText;
+            }
+        }
+
+        internal static SolidBrush DefaultParentRowsBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Control;
+            }
+        }
+
+        internal static SolidBrush DefaultAlternatingBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Window;
+            }
+        }
+
+        private static SolidBrush DefaultGridLineBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Control;
+            }
+        }
+
+        private static SolidBrush DefaultHeaderBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Control;
+            }
+        }
+
+        private static SolidBrush DefaultHeaderForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ControlText;
+            }
+        }
+
+        private static Pen DefaultHeaderForePen
+        {
+            get
+            {
+                return new Pen(SystemColors.ControlText);
+            }
+        }
+
+        private static SolidBrush DefaultLinkBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.HotTrack;
+            }
+        }
+
+        private bool ListHasErrors
+        {
+            get
+            {
+                return gridState[GRIDSTATE_listHasErrors];
+            }
+            set
+            {
+                if (ListHasErrors != value)
+                {
+                    gridState[GRIDSTATE_listHasErrors] = value;
+                    ComputeMinimumRowHeaderWidth();
+                    if (!layout.RowHeadersVisible)
+                    {
+                        return;
+                    }
+
+                    if (value)
+                    {
+                        if (myGridTable.IsDefault)
+                        {
+                            RowHeaderWidth += errorRowBitmapWidth;
+                        }
+                        else
+                        {
+                            myGridTable.RowHeaderWidth += errorRowBitmapWidth;
+                        }
+                    }
+                    else
+                    {
+                        if (myGridTable.IsDefault)
+                        {
+                            RowHeaderWidth -= errorRowBitmapWidth;
+                        }
+                        else
+                        {
+                            myGridTable.RowHeaderWidth -= errorRowBitmapWidth;
+                        }
+                    }
+                }
+            }
+        }
+
+        private bool Bound
+        {
+            get
+            {
+                return !(listManager == null || myGridTable == null);
+            }
+        }
+
+        internal DataGridCaption Caption
+        {
+            get
+            {
+                return caption;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the background color of the caption area.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridCaptionBackColorDescr))
+        ]
+        public Color CaptionBackColor
+        {
+            get
+            {
+                return Caption.BackColor;
+            }
+            set
+            {
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentCaptionBackColorNotAllowed);
+                }
+
+                Caption.BackColor = value;
+            }
+        }
+
+        private void ResetCaptionBackColor()
+        {
+            Caption.ResetBackColor();
+        }
+
+        /// <summary>
+        ///  Gets a value
+        ///  indicating whether the <see cref='CaptionBackColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        protected virtual bool ShouldSerializeCaptionBackColor()
+        {
+            return Caption.ShouldSerializeBackColor();
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets the foreground color
+        ///  of the caption area.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridCaptionForeColorDescr))
+        ]
+        public Color CaptionForeColor
+        {
+            get
+            {
+                return Caption.ForeColor;
+            }
+            set
+            {
+                Caption.ForeColor = value;
+            }
+        }
+
+        private void ResetCaptionForeColor()
+        {
+            Caption.ResetForeColor();
+        }
+
+        /// <summary>
+        ///  Gets a value
+        ///  indicating whether the <see cref='CaptionForeColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        protected virtual bool ShouldSerializeCaptionForeColor()
+        {
+            return Caption.ShouldSerializeForeColor();
+        }
+
+        /// <summary>
+        ///  Gets or sets the font of the grid's caption.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         Localizable(true),
+         AmbientValue(null),
+         SRDescription(nameof(SR.DataGridCaptionFontDescr))
+        ]
+        public Font CaptionFont
+        {
+            get
+            {
+                return Caption.Font;
+            }
+            set
+            {
+                Caption.Font = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the
+        ///  caption's font is persisted.
+        /// </summary>
+        private bool ShouldSerializeCaptionFont()
+        {
+            return Caption.ShouldSerializeFont();
+        }
+
+        private void ResetCaptionFont()
+        {
+            Caption.ResetFont();
+        }
+
+        /// <summary>
+        ///  Gets or sets the text of the grid's caption.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         DefaultValue(""),
+         Localizable(true),
+         SRDescription(nameof(SR.DataGridCaptionTextDescr))
+        ]
+        public string CaptionText
+        {
+            get
+            {
+                return Caption.Text;
+            }
+            set
+            {
+                Caption.Text = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates
+        ///  whether the grid's caption is visible.
+        /// </summary>
+        [
+         DefaultValue(true),
+         SRCategory(nameof(SR.CatDisplay)),
+         SRDescription(nameof(SR.DataGridCaptionVisibleDescr))
+        ]
+        public bool CaptionVisible
+        {
+            get
+            {
+                return layout.CaptionVisible;
+            }
+            set
+            {
+                if (layout.CaptionVisible != value)
+                {
+                    layout.CaptionVisible = value;
+                    PerformLayout();
+                    Invalidate();
+                    OnCaptionVisibleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_CAPTIONVISIBLECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnCaptionVisibleChangedDescr))]
+        public event EventHandler CaptionVisibleChanged
+        {
+            add => Events.AddHandler(EVENT_CAPTIONVISIBLECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_CAPTIONVISIBLECHANGED, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets which cell has the focus. Not available at design time.
+        /// </summary>
+        [
+         Browsable(false),
+         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+         SRDescription(nameof(SR.DataGridCurrentCellDescr))
+        ]
+        public DataGridCell CurrentCell
+        {
+            get
+            {
+                return new DataGridCell(currentRow, currentCol);
+            }
+            set
+            {
+                // if the OnLayout event was not set in the grid, then we can't
+                // reliably set the currentCell on the grid.
+                if (layout.dirty)
+                {
+                    throw new ArgumentException(SR.DataGridSettingCurrentCellNotGood);
+                }
+
+                if (value.RowNumber == currentRow && value.ColumnNumber == currentCol)
+                {
+                    return;
+                }
+
+                // should we throw an exception, maybe?
+                if (DataGridRowsLength == 0 || myGridTable.GridColumnStyles == null || myGridTable.GridColumnStyles.Count == 0)
+                {
+                    return;
+                }
+
+                EnsureBound();
+
+                int currentRowSaved = currentRow;
+                int currentColSaved = currentCol;
+                bool wasEditing = gridState[GRIDSTATE_isEditing];
+                bool cellChanged = false;
+
+                // if the position in the listManager changed under the DataGrid,
+                // then do not edit after setting the current cell
+                bool doNotEdit = false;
+
+                int newCol = value.ColumnNumber;
+                int newRow = value.RowNumber;
+
+                string errorMessage = null;
+
+                try
+                {
+                    int columnCount = myGridTable.GridColumnStyles.Count;
+                    if (newCol < 0)
+                    {
+                        newCol = 0;
+                    }
+
+                    if (newCol >= columnCount)
+                    {
+                        newCol = columnCount - 1;
+                    }
+
+                    int localGridRowsLength = DataGridRowsLength;
+                    DataGridRow[] localGridRows = DataGridRows;
+
+                    if (newRow < 0)
+                    {
+                        newRow = 0;
+                    }
+
+                    if (newRow >= localGridRowsLength)
+                    {
+                        newRow = localGridRowsLength - 1;
+                    }
+
+                    // Current Column changing
+                    //
+                    if (currentCol != newCol)
+                    {
+                        cellChanged = true;
+                        int currentListManagerPosition = ListManager.Position;
+                        int currentListManagerCount = ListManager.List.Count;
+
+                        EndEdit();
+
+                        if (ListManager.Position != currentListManagerPosition ||
+                            currentListManagerCount != ListManager.List.Count)
+                        {
+                            // EndEdit changed the list.
+                            // Reset the data grid rows and the current row inside the datagrid.
+                            // And then exit the method.
+                            RecreateDataGridRows();
+                            if (ListManager.List.Count > 0)
+                            {
+                                currentRow = ListManager.Position;
+                                Edit();
+                            }
+                            else
+                            {
+                                currentRow = -1;
+                            }
+
+                            return;
+                        }
+
+                        currentCol = newCol;
+                        InvalidateRow(currentRow);
+                    }
+
+                    // Current Row changing
+                    //
+                    if (currentRow != newRow)
+                    {
+                        cellChanged = true;
+                        int currentListManagerPosition = ListManager.Position;
+                        int currentListManagerCount = ListManager.List.Count;
+
+                        EndEdit();
+
+                        if (ListManager.Position != currentListManagerPosition ||
+                            currentListManagerCount != ListManager.List.Count)
+                        {
+                            // EndEdit changed the list.
+                            // Reset the data grid rows and the current row inside the datagrid.
+                            // And then exit the method.
+                            RecreateDataGridRows();
+                            if (ListManager.List.Count > 0)
+                            {
+                                currentRow = ListManager.Position;
+                                Edit();
+                            }
+                            else
+                            {
+                                currentRow = -1;
+                            }
+
+                            return;
+                        }
+
+                        if (currentRow < localGridRowsLength)
+                        {
+                            localGridRows[currentRow].OnRowLeave();
+                        }
+
+                        localGridRows[newRow].OnRowEnter();
+                        currentRow = newRow;
+                        if (currentRowSaved < localGridRowsLength)
+                        {
+                            InvalidateRow(currentRowSaved);
+                        }
+
+                        InvalidateRow(currentRow);
+
+                        if (currentRowSaved != listManager.Position)
+                        {
+                            // not in sync
+#if DEBUG
+                            Debug.Assert(inDataSource_PositionChanged, "currentRow and listManager.Position can be out of sync only when the listManager changes its position under the DataGrid or when navigating back");
+                            Debug.Assert(ListManager.Position == currentRow || listManager.Position == -1, "DataSource_PositionChanged changes the position in the grid to the position in the listManager");
+#endif //DEBUG
+                            doNotEdit = true;
+                            if (gridState[GRIDSTATE_isEditing])
+                            {
+                                AbortEdit();
+                            }
+                        }
+                        else if (gridState[GRIDSTATE_inAddNewRow])
+                        {
+#if DEBUG
+                            int currentRowCount = DataGridRowsLength;
+#endif // debug
+                            // cancelCurrentEdit will change the position in the list
+                            // to the last element in the list. and the grid will get an on position changed
+                            // event, and will set the current cell to the last element in the dataSource.
+                            // so unhook the PositionChanged event from the listManager;
+                            ListManager.PositionChanged -= positionChangedHandler;
+                            ListManager.CancelCurrentEdit();
+                            ListManager.Position = currentRow;
+                            ListManager.PositionChanged += positionChangedHandler;
+#if DEBUG
+
+                            Debug.Assert(currentRowSaved > currentRow, "we can only go up when we are inAddNewRow");
+                            Debug.Assert(currentRowCount == DataGridRowsLength, "the number of rows in the dataGrid should not change");
+                            Debug.Assert(currentRowCount == ListManager.Count + 1, "the listManager should have one less record");
+#endif // debug
+                            localGridRows[DataGridRowsLength - 1] = new DataGridAddNewRow(this, myGridTable, DataGridRowsLength - 1);
+                            SetDataGridRows(localGridRows, DataGridRowsLength);
+                            gridState[GRIDSTATE_inAddNewRow] = false;
+                        }
+                        else
+                        {
+                            ListManager.EndCurrentEdit();
+                            // some special care must be given when setting the
+                            // position in the listManager.
+                            // if EndCurrentEdit() deleted the current row
+                            //  ( because of some filtering problem, say )
+                            // then we cannot go over the last row
+                            //
+                            if (localGridRowsLength != DataGridRowsLength)
+                            {
+                                Debug.Assert(localGridRowsLength == DataGridRowsLength + 1, "this is the only change that could have happened");
+                                currentRow = (currentRow == localGridRowsLength - 1) ? DataGridRowsLength - 1 : currentRow;
+                            }
+
+                            if (currentRow == dataGridRowsLength - 1 && policy.AllowAdd)
+                            {
+                                // it may be case ( see previous comment )
+                                // that listManager.EndCurrentEdit changed the number of rows
+                                // in the grid. in this case, we should not be using the old
+                                // localGridRows in our assertion, cause they are outdated now
+                                //
+                                Debug.Assert(DataGridRows[currentRow] is DataGridAddNewRow, "the last row is the DataGridAddNewRow");
+                                AddNewRow();
+                                Debug.Assert(ListManager.Position == currentRow || listManager.Position == -1, "the listManager should be positioned at the last row");
+                            }
+                            else
+                            {
+                                ListManager.Position = currentRow;
+                            }
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    errorMessage = e.Message;
+                }
+
+                if (errorMessage != null)
+                {
+                    DialogResult result = RTLAwareMessageBox.Show(null,
+                        string.Format(SR.DataGridPushedIncorrectValueIntoColumn, errorMessage),
+                        SR.DataGridErrorMessageBoxCaption, MessageBoxButtons.YesNo,
+                        MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
+
+                    if (result == DialogResult.Yes)
+                    {
+                        currentRow = currentRowSaved;
+                        currentCol = currentColSaved;
+                        Debug.Assert(currentRow == ListManager.Position || listManager.Position == -1, "the position in the list manager (" + ListManager.Position + ") is out of sync with the currentRow (" + currentRow + ")" + " and the exception is '" + errorMessage + "'");
+                        // this will make sure the newRow will not paint the
+                        // row selector.
+                        InvalidateRowHeader(newRow);
+                        // also, make sure that we get the row selector on the currentrow, too
+                        InvalidateRowHeader(currentRow);
+                        if (wasEditing)
+                        {
+                            Edit();
+                        }
+                    }
+                    else
+                    {
+                        // if the user committed a row that used to be addNewRow and the backEnd rejects it,
+                        // and then it tries to navigate down then we should stay in the addNewRow
+                        // in this particular scenario, CancelCurrentEdit will cause the last row to be deleted,
+                        // and this will ultimately call InvalidateRow w/ a row number larger than the number of rows
+                        // so set the currentRow here:
+                        if (currentRow == DataGridRowsLength - 1 && currentRowSaved == DataGridRowsLength - 2 && DataGridRows[currentRow] is DataGridAddNewRow)
+                        {
+                            newRow = currentRowSaved;
+                        }
+
+                        currentRow = newRow;
+                        Debug.Assert(result == DialogResult.No, "we only put cancel and ok on the error message box");
+                        listManager.PositionChanged -= positionChangedHandler;
+                        listManager.CancelCurrentEdit();
+                        listManager.Position = newRow;
+                        listManager.PositionChanged += positionChangedHandler;
+                        currentRow = newRow;
+                        currentCol = newCol;
+                        if (wasEditing)
+                        {
+                            Edit();
+                        }
+                    }
+                }
+
+                if (cellChanged)
+                {
+                    EnsureVisible(currentRow, currentCol);
+                    OnCurrentCellChanged(EventArgs.Empty);
+
+                    // if the user changed the current cell using the UI, edit the new cell
+                    // but if the user changed the current cell by changing the position in the
+                    // listManager, then do not continue the edit
+                    //
+                    if (!doNotEdit)
+                    {
+#if DEBUG
+                        Debug.Assert(!inDataSource_PositionChanged, "if the user changed the current cell using the UI, then do not edit");
+#endif // debug
+                        Edit();
+                    }
+
+                    AccessibilityNotifyClients(AccessibleEvents.Focus, CurrentCellAccIndex);
+                    AccessibilityNotifyClients(AccessibleEvents.Selection, CurrentCellAccIndex);
+                }
+
+                Debug.Assert(currentRow == ListManager.Position || listManager.Position == -1, "the position in the list manager is out of sync with the currentRow");
+            }
+        }
+
+        internal int CurrentCellAccIndex
+        {
+            get
+            {
+                int currentCellAccIndex = 0;
+                currentCellAccIndex++;                                                 // ParentRowsAccessibleObject
+                currentCellAccIndex += myGridTable.GridColumnStyles.Count;         // ColumnHeaderAccessibleObject
+                currentCellAccIndex += DataGridRows.Length;                        // DataGridRowAccessibleObject
+                if (horizScrollBar.Visible)                                        // Horizontal Scroll Bar Accessible Object
+                {
+                    currentCellAccIndex++;
+                }
+
+                if (vertScrollBar.Visible)                                         // Vertical Scroll Bar Accessible Object
+                {
+                    currentCellAccIndex++;
+                }
+
+                currentCellAccIndex += (currentRow * myGridTable.GridColumnStyles.Count) + currentCol;
+                return currentCellAccIndex;
+            }
+        }
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnCurrentCellChangedDescr))]
+        public event EventHandler CurrentCellChanged
+        {
+            add => Events.AddHandler(EVENT_CURRENTCELLCHANGED, value);
+            remove => Events.RemoveHandler(EVENT_CURRENTCELLCHANGED, value);
+        }
+
+        private int CurrentColumn
+        {
+            get
+            {
+                return CurrentCell.ColumnNumber;
+            }
+            set
+            {
+                CurrentCell = new DataGridCell(currentRow, value);
+            }
+        }
+
+        private int CurrentRow
+        {
+            get
+            {
+                return CurrentCell.RowNumber;
+            }
+            set
+            {
+                CurrentCell = new DataGridCell(value, currentCol);
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridSelectionBackColorDescr))
+        ]
+        public Color SelectionBackColor
+        {
+            get
+            {
+                return selectionBackBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "SelectionBackColor"));
+                }
+
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentSelectionBackColorNotAllowed);
+                }
+
+                if (!value.Equals(selectionBackBrush.Color))
+                {
+                    selectionBackBrush = new SolidBrush(value);
+
+                    InvalidateInside();
+                }
+            }
+        }
+
+        internal SolidBrush SelectionBackBrush
+        {
+            get
+            {
+                return selectionBackBrush;
+            }
+        }
+
+        internal SolidBrush SelectionForeBrush
+        {
+            get
+            {
+                return selectionForeBrush;
+            }
+        }
+
+        protected bool ShouldSerializeSelectionBackColor()
+        {
+            return !DefaultSelectionBackBrush.Equals(selectionBackBrush);
+        }
+
+        public void ResetSelectionBackColor()
+        {
+            if (ShouldSerializeSelectionBackColor())
+            {
+                SelectionBackColor = DefaultSelectionBackBrush.Color;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridSelectionForeColorDescr))
+        ]
+        public Color SelectionForeColor
+        {
+            get
+            {
+                return selectionForeBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "SelectionForeColor"));
+                }
+
+                if (!value.Equals(selectionForeBrush.Color))
+                {
+                    selectionForeBrush = new SolidBrush(value);
+
+                    InvalidateInside();
+                }
+            }
+        }
+
+        protected virtual bool ShouldSerializeSelectionForeColor()
+        {
+            return !SelectionForeBrush.Equals(DefaultSelectionForeBrush);
+        }
+
+        public void ResetSelectionForeColor()
+        {
+            if (ShouldSerializeSelectionForeColor())
+            {
+                SelectionForeColor = DefaultSelectionForeBrush.Color;
+            }
+        }
+
+        internal override bool ShouldSerializeForeColor()
+        {
+            return !DefaultForeBrush.Color.Equals(ForeColor);
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='BackColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        internal override bool ShouldSerializeBackColor()
+        {
+            return !DefaultBackBrush.Color.Equals(BackColor);
+        }
+
+        // Don't use dataGridRows, use the accessor!!!
+        internal DataGridRow[] DataGridRows
+        {
+            get
+            {
+                if (dataGridRows == null)
+                {
+                    CreateDataGridRows();
+                }
+
+                return dataGridRows;
+            }
+        }
+
+        // ToolTipping
+        internal DataGridToolTip ToolTipProvider
+        {
+            get
+            {
+                return toolTipProvider;
+            }
+        }
+
+        internal int ToolTipId
+        {
+            get
+            {
+                return toolTipId;
+            }
+            set
+            {
+                toolTipId = value;
+            }
+        }
+
+        private void ResetToolTip()
+        {
+            // remove all the tool tips which are stored
+            for (int i = 0; i < ToolTipId; i++)
+            {
+                ToolTipProvider.RemoveToolTip(new IntPtr(i));
+            }
+
+            // add toolTips for the backButton and
+            // details button on the caption.
+            if (!parentRows.IsEmpty())
+            {
+                bool alignRight = isRightToLeft();
+                int detailsButtonWidth = Caption.GetDetailsButtonWidth();
+                Rectangle backButton = Caption.GetBackButtonRect(layout.Caption, alignRight, detailsButtonWidth);
+                Rectangle detailsButton = Caption.GetDetailsButtonRect(layout.Caption, alignRight);
+
+                // mirror the buttons wrt RTL property
+                backButton.X = MirrorRectangle(backButton, layout.Inside, isRightToLeft());
+                detailsButton.X = MirrorRectangle(detailsButton, layout.Inside, isRightToLeft());
+
+                ToolTipProvider.AddToolTip(SR.DataGridCaptionBackButtonToolTip, new IntPtr(0), backButton);
+                ToolTipProvider.AddToolTip(SR.DataGridCaptionDetailsButtonToolTip, new IntPtr(1), detailsButton);
+                ToolTipId = 2;
+            }
+            else
+            {
+                ToolTipId = 0;
+            }
+        }
+
+        /// <summary>
+        ///  Given a cursor, this will Create the right DataGridRows
+        /// </summary>
+        private void CreateDataGridRows()
+        {
+            CurrencyManager listManager = ListManager;
+            DataGridTableStyle dgt = myGridTable;
+            InitializeColumnWidths();
+
+            if (listManager == null)
+            {
+                SetDataGridRows(Array.Empty<DataGridRow>(), 0);
+                return;
+            }
+
+            int nDataGridRows = listManager.Count;
+            if (policy.AllowAdd)
+            {
+                nDataGridRows++;
+            }
+
+            DataGridRow[] rows = new DataGridRow[nDataGridRows];
+            for (int r = 0; r < listManager.Count; r++)
+            {
+                rows[r] = new DataGridRelationshipRow(this, dgt, r);
+            }
+
+            if (policy.AllowAdd)
+            {
+                addNewRow = new DataGridAddNewRow(this, dgt, nDataGridRows - 1);
+                rows[nDataGridRows - 1] = addNewRow;
+            }
+            else
+            {
+                addNewRow = null;
+            }
+
+            // SetDataGridRows(rows, rows.Length);
+            SetDataGridRows(rows, nDataGridRows);
+        }
+
+        private void RecreateDataGridRows()
+        {
+            int nDataGridRows = 0;
+            CurrencyManager listManager = ListManager;
+
+            if (listManager != null)
+            {
+                nDataGridRows = listManager.Count;
+                if (policy.AllowAdd)
+                {
+                    nDataGridRows++;
+                }
+            }
+
+            SetDataGridRows(null, nDataGridRows);
+        }
+
+        /// <summary>
+        ///  Sets the array of DataGridRow objects used for
+        ///  all row-related logic in the DataGrid.
+        /// </summary>
+        internal void SetDataGridRows(DataGridRow[] newRows, int newRowsLength)
+        {
+            dataGridRows = newRows;
+            dataGridRowsLength = newRowsLength;
+
+            // update the vertical scroll bar
+            vertScrollBar.Maximum = Math.Max(0, DataGridRowsLength - 1);
+            if (firstVisibleRow > newRowsLength)
+            {
+                vertScrollBar.Value = 0;
+                firstVisibleRow = 0;
+            }
+
+            ResetUIState();
+#if DEBUG
+            // sanity check: all the rows should have the same
+            // dataGridTable
+            if (newRows != null && newRowsLength > 0)
+            {
+                DataGridTableStyle dgTable = newRows[0].DataGridTableStyle;
+                for (int i = 0; i < newRowsLength; i++)
+                {
+                    Debug.Assert(dgTable == newRows[i].DataGridTableStyle, "how can two rows have different tableStyles?");
+                }
+            }
+#endif // DEBUG
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: There are now " + DataGridRowsLength.ToString(CultureInfo.InvariantCulture) + " rows.");
+        }
+
+        internal int DataGridRowsLength
+        {
+            get
+            {
+                return dataGridRowsLength;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the data source that the grid is displaying data for.
+        /// </summary>
+        [
+         DefaultValue(null),
+         SRCategory(nameof(SR.CatData)),
+         RefreshProperties(RefreshProperties.Repaint),
+         AttributeProvider(typeof(IListSource)),
+         SRDescription(nameof(SR.DataGridDataSourceDescr))
+        ]
+        public object DataSource
+        {
+            get
+            {
+                return dataSource;
+            }
+
+            set
+            {
+                if (value != null && !(value is IList || value is IListSource))
+                {
+                    throw new ArgumentException(SR.BadDataSourceForComplexBinding);
+                }
+
+                if (dataSource != null && dataSource.Equals(value))
+                {
+                    return;
+                }
+
+                // when the designer resets the dataSource to null, set the dataMember to null, too
+                if ((value == null || value == Convert.DBNull) && DataMember != null && DataMember.Length != 0)
+                {
+                    dataSource = null;
+                    DataMember = string.Empty;
+                    return;
+                }
+
+                // if we are setting the dataSource and the dataMember is not a part
+                // of the properties in the dataSource, then set the dataMember to ""
+                //
+                if (value != null)
+                {
+                    EnforceValidDataMember(value);
+                }
+
+                Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource being set to " + ((value == null) ? "null" : value.ToString()));
+
+                // when we change the dataSource, we need to clear the parent rows.
+                // the same goes for all the caption UI: reset it when the datasource changes.
+                //
+                ResetParentRows();
+                Set_ListManager(value, DataMember, false);
+            }
+        }
+
+        private static readonly object EVENT_DATASOURCECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnDataSourceChangedDescr))]
+        public event EventHandler DataSourceChanged
+        {
+            add => Events.AddHandler(EVENT_DATASOURCECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_DATASOURCECHANGED, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets the specific table in a DataSource for the control.
+        /// </summary>
+        [
+         DefaultValue(null),
+         SRCategory(nameof(SR.CatData)),
+         Editor("System.Windows.Forms.Design.DataMemberListEditor, " + AssemblyRef.SystemDesign, typeof(Drawing.Design.UITypeEditor)),
+         SRDescription(nameof(SR.DataGridDataMemberDescr))
+        ]
+        public string DataMember
+        {
+            get
+            {
+                return dataMember;
+            }
+            set
+            {
+                if (dataMember != null && dataMember.Equals(value))
+                {
+                    return;
+                }
+
+                Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource being set to " + ((value == null) ? "null" : value.ToString()));
+                // when we change the dataMember, we need to clear the parent rows.
+                // the same goes for all the caption UI: reset it when the datamember changes.
+                //
+                ResetParentRows();
+                Set_ListManager(DataSource, value, false);
+            }
+        }
+
+        public void SetDataBinding(object dataSource, string dataMember)
+        {
+            parentRows.Clear();
+            originalState = null;
+            caption.BackButtonActive = caption.DownButtonActive = caption.BackButtonVisible = false;
+            caption.SetDownButtonDirection(!layout.ParentRowsVisible);
+
+            Set_ListManager(dataSource, dataMember, false);
+        }
+
+        [
+         Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
+         SRDescription(nameof(SR.DataGridListManagerDescr))
+        ]
+        internal protected CurrencyManager ListManager
+        {
+            get
+            {
+                //try to return something useful:
+                if (listManager == null && BindingContext != null && DataSource != null)
+                {
+                    return (CurrencyManager)BindingContext[DataSource, DataMember];
+                }
+                else
+                {
+                    return listManager;
+                }
+            }
+            set
+            {
+                throw new NotSupportedException(SR.DataGridSetListManager);
+            }
+        }
+
+        internal void Set_ListManager(object newDataSource, string newDataMember, bool force)
+        {
+            Set_ListManager(newDataSource, newDataMember, force, true);        // true for forcing column creation
+        }
+
+        //
+        // prerequisite: the dataMember and the dataSource should be set to the new values
+        //
+        // will do the following:
+        // call EndEdit on the current listManager, will unWire the listManager events, will set the listManager to the new
+        // reality, will wire the new listManager, will update the policy, will set the dataGridTable, will reset the ui state.
+        //
+        internal void Set_ListManager(object newDataSource, string newDataMember, bool force, bool forceColumnCreation)
+        {
+            bool dataSourceChanged = DataSource != newDataSource;
+            bool dataMemberChanged = DataMember != newDataMember;
+
+            // if nothing happened, then why do any work?
+            if (!force && !dataSourceChanged && !dataMemberChanged && gridState[GRIDSTATE_inSetListManager])
+            {
+                return;
+            }
+
+            gridState[GRIDSTATE_inSetListManager] = true;
+            if (toBeDisposedEditingControl != null)
+            {
+                Debug.Assert(Controls.Contains(toBeDisposedEditingControl));
+                Controls.Remove(toBeDisposedEditingControl);
+                toBeDisposedEditingControl = null;
+            }
+
+            bool beginUpdateInternal = true;
+            try
+            {
+                // will endEdit on the current listManager
+                UpdateListManager();
+
+                // unwire the events:
+                if (listManager != null)
+                {
+                    UnWireDataSource();
+                }
+
+                CurrencyManager oldListManager = listManager;
+                bool listManagerChanged = false;
+                // set up the new listManager
+                // CAUTION: we need to set up the listManager in the grid before setting the dataSource/dataMember props
+                // in the grid. the reason is that if the BindingContext was not yet requested, and it is created in the BindingContext prop
+                // then the grid will call Set_ListManager again, and eventually that means that the dataGrid::listManager will
+                // be hooked up twice to all the events (PositionChanged, ItemChanged, CurrentChanged)
+                if (newDataSource != null && BindingContext != null && !(newDataSource == Convert.DBNull))
+                {
+                    listManager = (CurrencyManager)BindingContext[newDataSource, newDataMember];
+                }
+                else
+                {
+                    listManager = null;
+                }
+
+                // update the dataSource and the dateMember
+                dataSource = newDataSource;
+                dataMember = newDataMember ?? "";
+
+                listManagerChanged = (listManager != oldListManager);
+
+                // wire the events
+                if (listManager != null)
+                {
+                    WireDataSource();
+                    // update the policy
+                    policy.UpdatePolicy(listManager, ReadOnly);
+                }
+
+                if (!Initializing)
+                {
+                    if (listManager == null)
+                    {
+                        if (ContainsFocus && ParentInternal == null)
+                        {
+                            Debug.Assert(toBeDisposedEditingControl == null, "we should have removed the toBeDisposedEditingControl already");
+                            // if we unparent the active control then the form won't close
+                            for (int i = 0; i < Controls.Count; i++)
+                            {
+                                if (Controls[i].Focused)
+                                {
+                                    toBeDisposedEditingControl = Controls[i];
+                                    break;
+                                }
+                            }
+
+                            if (toBeDisposedEditingControl == horizScrollBar || toBeDisposedEditingControl == vertScrollBar)
+                            {
+                                toBeDisposedEditingControl = null;
+                            }
+
+#if DEBUG
+                            else
+                            {
+                                Debug.Assert(toBeDisposedEditingControl != null, "if the grid contains the focus, then the active control should be in the children of data grid control");
+                                Debug.Assert(editColumn != null, "if we have an editing control should be a control in the data grid column");
+                                if (editColumn is DataGridTextBoxColumn)
+                                {
+                                    Debug.Assert(((DataGridTextBoxColumn)editColumn).TextBox == toBeDisposedEditingControl, "if we have an editing control should be a control in the data grid column");
+                                }
+                            }
+#endif // debug;
+
+                        }
+
+                        SetDataGridRows(null, 0);
+                        defaultTableStyle.GridColumnStyles.Clear();
+                        SetDataGridTable(defaultTableStyle, forceColumnCreation);
+
+                        if (toBeDisposedEditingControl != null)
+                        {
+                            Controls.Add(toBeDisposedEditingControl);
+                        }
+                    }
+                }
+
+                // PERF: if the listManager did not change, then do not:
+                //      1. create new rows
+                //      2. create new columns
+                //      3. compute the errors in the list
+                //
+                // when the metaDataChanges, we need to recreate
+                // the rows and the columns
+                //
+                if (listManagerChanged || gridState[GRIDSTATE_metaDataChanged])
+                {
+                    if (Visible)
+                    {
+                        BeginUpdateInternal();
+                    }
+
+                    if (listManager != null)
+                    {
+                        // get rid of the old gridColumns
+                        // we need to clear the old column collection even when navigating to
+                        // a list that has a table style associated w/ it. Why? because the
+                        // old column collection will be used by the parent rows to paint
+                        defaultTableStyle.GridColumnStyles.ResetDefaultColumnCollection();
+
+                        DataGridTableStyle newGridTable = dataGridTables[listManager.GetListName()];
+                        if (newGridTable == null)
+                        {
+                            SetDataGridTable(defaultTableStyle, forceColumnCreation);
+                        }
+                        else
+                        {
+                            SetDataGridTable(newGridTable, forceColumnCreation);
+                        }
+
+                        // set the currentRow in ssync w/ the position in the listManager
+                        currentRow = listManager.Position == -1 ? 0 : listManager.Position;
+                    }
+
+                    // when we create the rows we need to use the current dataGridTable
+                    //
+                    RecreateDataGridRows();
+                    if (Visible)
+                    {
+                        EndUpdateInternal();
+                    }
+
+                    beginUpdateInternal = false;
+
+                    ComputeMinimumRowHeaderWidth();
+                    if (myGridTable.IsDefault)
+                    {
+                        RowHeaderWidth = Math.Max(minRowHeaderWidth, RowHeaderWidth);
+                    }
+                    else
+                    {
+                        myGridTable.RowHeaderWidth = Math.Max(minRowHeaderWidth, RowHeaderWidth);
+                    }
+
+                    ListHasErrors = DataGridSourceHasErrors();
+
+                    // build the list of columns and relationships
+                    // wipe out the now invalid states
+                    //ResetMouseState();
+
+                    ResetUIState();
+
+                    //layout.CaptionVisible = dataCursor == null ? false : true;
+
+                    OnDataSourceChanged(EventArgs.Empty);
+                }
+            }
+            finally
+            {
+                gridState[GRIDSTATE_inSetListManager] = false;
+                // start painting again
+                if (beginUpdateInternal && Visible)
+                {
+                    EndUpdateInternal();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets index of the selected row.
+        /// </summary>
+        // will set the position in the ListManager
+        //
+        [
+         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+         Browsable(false),
+         SRDescription(nameof(SR.DataGridSelectedIndexDescr))
+        ]
+        public int CurrentRowIndex
+        {
+            get
+            {
+                if (originalState == null)
+                {
+                    return listManager == null ? -1 : listManager.Position;
+                }
+                else
+                {
+                    if (BindingContext == null)
+                    {
+                        return -1;
+                    }
+
+                    CurrencyManager originalListManager = (CurrencyManager)BindingContext[originalState.DataSource, originalState.DataMember];
+                    return originalListManager.Position;
+                }
+            }
+            set
+            {
+                if (listManager == null)
+                {
+                    throw new InvalidOperationException(SR.DataGridSetSelectIndex);
+                }
+
+                if (originalState == null)
+                {
+                    listManager.Position = value;
+                    currentRow = value;
+                    return;
+                }
+
+                // if we have a this.ListManager, then this.BindingManager cannot be null
+                //
+                CurrencyManager originalListManager = (CurrencyManager)BindingContext[originalState.DataSource, originalState.DataMember];
+                originalListManager.Position = value;
+
+                // this is for parent rows
+                originalState.LinkingRow = originalState.DataGridRows[value];
+
+                // Invalidate everything
+                Invalidate();
+            }
+        }
+
+        /// <summary>
+        ///  Gets the collection of tables for the grid.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatData)),
+         DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
+         Localizable(true),
+         SRDescription(nameof(SR.DataGridGridTablesDescr))
+        ]
+        public GridTableStylesCollection TableStyles
+        {
+            get
+            {
+                return dataGridTables;
+            }
+        }
+
+        internal new int FontHeight
+        {
+            get
+            {
+                return fontHeight;
+            }
+        }
+
+        internal AccessibleObject ParentRowsAccessibleObject
+        {
+            get
+            {
+                return parentRows.AccessibleObject;
+            }
+        }
+
+        internal Rectangle ParentRowsBounds
+        {
+            get
+            {
+                return layout.ParentRows;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the color of the grid lines.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridGridLineColorDescr))
+        ]
+        public Color GridLineColor
+        {
+            get
+            {
+                return gridLineBrush.Color;
+            }
+            set
+            {
+                if (gridLineBrush.Color != value)
+                {
+                    if (value.IsEmpty)
+                    {
+                        throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "GridLineColor"));
+                    }
+
+                    gridLineBrush = new SolidBrush(value);
+
+                    Invalidate(layout.Data);
+                }
+            }
+        }
+
+        protected virtual bool ShouldSerializeGridLineColor()
+        {
+            return !GridLineBrush.Equals(DefaultGridLineBrush);
+        }
+
+        public void ResetGridLineColor()
+        {
+            if (ShouldSerializeGridLineColor())
+            {
+                GridLineColor = DefaultGridLineBrush.Color;
+            }
+        }
+
+        internal SolidBrush GridLineBrush
+        {
+            get
+            {
+                return gridLineBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the line style of the grid.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         DefaultValue(defaultGridLineStyle),
+         SRDescription(nameof(SR.DataGridGridLineStyleDescr))
+        ]
+        public DataGridLineStyle GridLineStyle
+        {
+            get
+            {
+                return gridLineStyle;
+            }
+            set
+            {
+                //valid values are 0x0 to 0x1.
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)DataGridLineStyle.None, (int)DataGridLineStyle.Solid))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(DataGridLineStyle));
+                }
+
+                if (gridLineStyle != value)
+                {
+                    gridLineStyle = value;
+                    myGridTable.ResetRelationsUI();
+                    Invalidate(layout.Data);
+                }
+            }
+        }
+
+        internal int GridLineWidth
+        {
+            get
+            {
+                Debug.Assert(GridLineStyle == DataGridLineStyle.Solid || GridLineStyle == DataGridLineStyle.None, "are there any other styles?");
+                return GridLineStyle == DataGridLineStyle.Solid ? 1 : 0;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or
+        ///  sets the
+        ///  way parent row labels are displayed.
+        /// </summary>
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+         DefaultValue(defaultParentRowsLabelStyle),
+         SRCategory(nameof(SR.CatDisplay)),
+         SRDescription(nameof(SR.DataGridParentRowsLabelStyleDescr))
+        ]
+        public DataGridParentRowsLabelStyle ParentRowsLabelStyle
+        {
+            get
+            {
+                return parentRowsLabels;
+            }
+
+            set
+            {
+                //valid values are 0x0 to 0x3
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)DataGridParentRowsLabelStyle.None, (int)DataGridParentRowsLabelStyle.Both))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(DataGridParentRowsLabelStyle));
+                }
+
+                if (parentRowsLabels != value)
+                {
+                    parentRowsLabels = value;
+                    Invalidate(layout.ParentRows);
+                    OnParentRowsLabelStyleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_PARENTROWSLABELSTYLECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnParentRowsLabelStyleChangedDescr))]
+        public event EventHandler ParentRowsLabelStyleChanged
+        {
+            add => Events.AddHandler(EVENT_PARENTROWSLABELSTYLECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_PARENTROWSLABELSTYLECHANGED, value);
+        }
+
+        internal bool Initializing
+        {
+            get
+            {
+                return inInit;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the index of the first visible column in a grid.
+        /// </summary>
+        [
+         Browsable(false),
+         SRDescription(nameof(SR.DataGridFirstVisibleColumnDescr))
+        ]
+        public int FirstVisibleColumn
+        {
+            get
+            {
+                return firstVisibleCol;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the grid displays in flat mode.
+        /// </summary>
+        [
+         DefaultValue(false),
+         SRCategory(nameof(SR.CatAppearance)),
+         SRDescription(nameof(SR.DataGridFlatModeDescr))
+        ]
+        public bool FlatMode
+        {
+            get
+            {
+                return gridState[GRIDSTATE_isFlatMode];
+            }
+            set
+            {
+                if (value != FlatMode)
+                {
+                    gridState[GRIDSTATE_isFlatMode] = value;
+                    Invalidate(layout.Inside);
+                    OnFlatModeChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_FLATMODECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnFlatModeChangedDescr))]
+        public event EventHandler FlatModeChanged
+        {
+            add => Events.AddHandler(EVENT_FLATMODECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_FLATMODECHANGED, value);
+        }
+
+        /// <summary>
+        ///  Gets or
+        ///  sets the background color of all row and column headers.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridHeaderBackColorDescr))
+        ]
+        public Color HeaderBackColor
+        {
+            get
+            {
+                return headerBackBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "HeaderBackColor"));
+                }
+
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentHeaderBackColorNotAllowed);
+                }
+
+                if (!value.Equals(headerBackBrush.Color))
+                {
+                    headerBackBrush = new SolidBrush(value);
+
+                    if (layout.RowHeadersVisible)
+                    {
+                        Invalidate(layout.RowHeaders);
+                    }
+
+                    if (layout.ColumnHeadersVisible)
+                    {
+                        Invalidate(layout.ColumnHeaders);
+                    }
+
+                    Invalidate(layout.TopLeftHeader);
+                }
+            }
+        }
+
+        internal SolidBrush HeaderBackBrush
+        {
+            get
+            {
+                return headerBackBrush;
+            }
+        }
+
+        protected virtual bool ShouldSerializeHeaderBackColor()
+        {
+            return !HeaderBackBrush.Equals(DefaultHeaderBackBrush);
+        }
+
+        public void ResetHeaderBackColor()
+        {
+            if (ShouldSerializeHeaderBackColor())
+            {
+                HeaderBackColor = DefaultHeaderBackBrush.Color;
+            }
+        }
+
+        internal SolidBrush BackgroundBrush
+        {
+            get
+            {
+                return backgroundBrush;
+            }
+        }
+
+        private void ResetBackgroundColor()
+        {
+            if (backgroundBrush != null && BackgroundBrush != DefaultBackgroundBrush)
+            {
+                backgroundBrush.Dispose();
+                backgroundBrush = null;
+            }
+
+            backgroundBrush = DefaultBackgroundBrush;
+        }
+
+        protected virtual bool ShouldSerializeBackgroundColor()
+        {
+            return !BackgroundBrush.Equals(DefaultBackgroundBrush);
+        }
+
+        // using this property, the user can set the backGround color
+        /// <summary>
+        ///  Gets or sets the background color of the grid.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridBackgroundColorDescr))
+        ]
+        public Color BackgroundColor
+        {
+            get
+            {
+                return backgroundBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "BackgroundColor"));
+                }
+
+                if (!value.Equals(backgroundBrush.Color))
+                {
+                    if (backgroundBrush != null && BackgroundBrush != DefaultBackgroundBrush)
+                    {
+                        backgroundBrush.Dispose();
+                        backgroundBrush = null;
+                    }
+
+                    backgroundBrush = new SolidBrush(value);
+
+                    Invalidate(layout.Inside);
+                    OnBackgroundColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_BACKGROUNDCOLORCHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnBackgroundColorChangedDescr))]
+        public event EventHandler BackgroundColorChanged
+        {
+            add => Events.AddHandler(EVENT_BACKGROUNDCOLORCHANGED, value);
+            remove => Events.RemoveHandler(EVENT_BACKGROUNDCOLORCHANGED, value);
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='HeaderFont'/> property should be persisted.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         SRDescription(nameof(SR.DataGridHeaderFontDescr))
+        ]
+        public Font HeaderFont
+        {
+            get
+            {
+                return (headerFont ?? Font);
+            }
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(HeaderFont));
+                }
+
+                if (!value.Equals(headerFont))
+                {
+                    headerFont = value;
+                    RecalculateFonts();
+                    PerformLayout();
+                    Invalidate(layout.Inside);
+                }
+            }
+        }
+
+        protected bool ShouldSerializeHeaderFont()
+        {
+            return (headerFont != null);
+        }
+
+        public void ResetHeaderFont()
+        {
+            if (headerFont != null)
+            {
+                headerFont = null;
+                RecalculateFonts();
+                PerformLayout();
+                Invalidate(layout.Inside);
+            }
+        }
+
+        /// <summary>
+        ///  Resets the <see cref='HeaderFont'/> property to its default value.
+        /// </summary>
+        /// <summary>
+        ///  Gets or sets the foreground color of the grid's headers.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridHeaderForeColorDescr))
+        ]
+        public Color HeaderForeColor
+        {
+            get
+            {
+                return headerForePen.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "HeaderForeColor"));
+                }
+
+                if (!value.Equals(headerForePen.Color))
+                {
+                    headerForePen = new Pen(value);
+                    headerForeBrush = new SolidBrush(value);
+
+                    if (layout.RowHeadersVisible)
+                    {
+                        Invalidate(layout.RowHeaders);
+                    }
+
+                    if (layout.ColumnHeadersVisible)
+                    {
+                        Invalidate(layout.ColumnHeaders);
+                    }
+
+                    Invalidate(layout.TopLeftHeader);
+                }
+            }
+        }
+
+        protected virtual bool ShouldSerializeHeaderForeColor()
+        {
+            return !HeaderForePen.Equals(DefaultHeaderForePen);
+        }
+
+        public void ResetHeaderForeColor()
+        {
+            if (ShouldSerializeHeaderForeColor())
+            {
+                HeaderForeColor = DefaultHeaderForeBrush.Color;
+            }
+        }
+
+        internal SolidBrush HeaderForeBrush
+        {
+            get
+            {
+                return headerForeBrush;
+            }
+        }
+
+        internal Pen HeaderForePen
+        {
+            get
+            {
+                return headerForePen;
+            }
+        }
+
+        private void ResetHorizontalOffset()
+        {
+            horizontalOffset = 0;
+            negOffset = 0;
+            firstVisibleCol = 0;
+            numVisibleCols = 0;
+            lastTotallyVisibleCol = -1;
+        }
+
+        internal int HorizontalOffset
+        {
+            get
+            {
+                return horizontalOffset;
+            }
+            set
+            {
+                //if (CompModSwitches.DataGridScrolling.TraceVerbose) Debug.WriteLine("DataGridScrolling: Set_HorizontalOffset, value = " + value.ToString());
+                if (value < 0)
+                {
+                    value = 0;
+                }
+
+                //
+                //  if the dataGrid is not bound ( listManager == null || gridTable == null)
+                //  then use ResetHorizontalOffset();
+                //
+
+                int totalWidth = GetColumnWidthSum();
+                int widthNotVisible = totalWidth - layout.Data.Width;
+                if (value > widthNotVisible && widthNotVisible > 0)
+                {
+                    value = widthNotVisible;
+                }
+
+                if (value == horizontalOffset)
+                {
+                    return;
+                }
+
+                int change = horizontalOffset - value;
+                horizScrollBar.Value = value;
+                Rectangle scroll = layout.Data;
+                if (layout.ColumnHeadersVisible)
+                {
+                    scroll = Rectangle.Union(scroll, layout.ColumnHeaders);
+                }
+
+                horizontalOffset = value;
+
+                firstVisibleCol = ComputeFirstVisibleColumn();
+                // update the lastTotallyVisibleCol
+                ComputeVisibleColumns();
+
+                if (gridState[GRIDSTATE_isScrolling])
+                {
+                    // if the user did not click on the grid yet, then do not put the edit
+                    // control when scrolling
+                    if (currentCol >= firstVisibleCol && currentCol < firstVisibleCol + numVisibleCols - 1 && (gridState[GRIDSTATE_isEditing] || gridState[GRIDSTATE_isNavigating]))
+                    {
+                        Edit();
+                    }
+                    else
+                    {
+                        EndEdit();
+                    }
+
+                    // isScrolling is set to TRUE when the user scrolls.
+                    // once we move the edit box, we finished processing the scroll event, so set isScrolling to FALSE
+                    // to set isScrolling to TRUE, we need another scroll event.
+                    gridState[GRIDSTATE_isScrolling] = false;
+                }
+                else
+                {
+                    EndEdit();
+                }
+
+                RECT[] rects = CreateScrollableRegion(scroll);
+                ScrollRectangles(rects, change);
+                OnScroll(EventArgs.Empty);
+            }
+        }
+
+        private void ScrollRectangles(RECT[] rects, int change)
+        {
+            if (rects != null)
+            {
+                RECT scroll;
+                if (isRightToLeft())
+                {
+                    change = -change;
+                }
+
+                for (int r = 0; r < rects.Length; r++)
+                {
+                    scroll = rects[r];
+                    User32.ScrollWindow(this,
+                                        change,
+                                        0,
+                                        ref scroll,
+                                        ref scroll);
+                }
+            }
+        }
+
+        [
+         SRDescription(nameof(SR.DataGridHorizScrollBarDescr))
+        ]
+        protected ScrollBar HorizScrollBar
+        {
+            get
+            {
+                return horizScrollBar;
+            }
+        }
+
+        /// <summary>
+        ///  Retrieves a value indicating whether odd and even
+        ///  rows are painted using a different background color.
+        /// </summary>
+        // Cleanup eventually to be static.
+        internal bool LedgerStyle
+        {
+            get
+            {
+                return gridState[GRIDSTATE_isLedgerStyle];
+            }
+
+            /*
+            set {
+                if (isLedgerStyle != value) {
+                    isLedgerStyle = value;
+                    InvalidateInside();
+                }
+            }
+            */
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='LinkColor'/> property should be persisted.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridLinkColorDescr))
+        ]
+        public Color LinkColor
+        {
+            get
+            {
+                return linkBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "LinkColor"));
+                }
+
+                if (!linkBrush.Color.Equals(value))
+                {
+                    linkBrush = new SolidBrush(value);
+                    Invalidate(layout.Data);
+                }
+            }
+        }
+
+        internal virtual bool ShouldSerializeLinkColor()
+        {
+            return !LinkBrush.Equals(DefaultLinkBrush);
+        }
+
+        public void ResetLinkColor()
+        {
+            if (ShouldSerializeLinkColor())
+            {
+                LinkColor = DefaultLinkBrush.Color;
+            }
+        }
+
+        internal Brush LinkBrush
+        {
+            get
+            {
+                return linkBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets the color a link changes to when
+        ///  the mouse pointer moves over it.
+        /// </summary>
+        [
+         SRDescription(nameof(SR.DataGridLinkHoverColorDescr)),
+         SRCategory(nameof(SR.CatColors)),
+         Browsable(false),
+         EditorBrowsable(EditorBrowsableState.Never)
+
+        ]
+        public Color LinkHoverColor
+        {
+            get
+            {
+                return LinkColor;
+            }
+            set
+            {
+            }
+        }
+
+        protected virtual bool ShouldSerializeLinkHoverColor()
+        {
+            return false;
+            // return !LinkHoverBrush.Equals(defaultLinkHoverBrush);
+        }
+
+        public void ResetLinkHoverColor()
+        {
+            /*
+            if (ShouldSerializeLinkHoverColor())
+                LinkHoverColor = defaultLinkHoverBrush.Color;*/
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='LinkHoverColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        internal Font LinkFont
+        {
+            get
+            {
+                return linkFont;
+            }
+        }
+
+        internal int LinkFontHeight
+        {
+            get
+            {
+                return linkFontHeight;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value
+        ///  that specifies which links are shown and in what context.
+        /// </summary>
+        [
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridNavigationModeDescr)),
+         SRCategory(nameof(SR.CatBehavior))
+        ]
+        public bool AllowNavigation
+        {
+            get
+            {
+                return gridState[GRIDSTATE_allowNavigation];
+            }
+            set
+            {
+                if (AllowNavigation != value)
+                {
+                    gridState[GRIDSTATE_allowNavigation] = value;
+                    // let the Caption know about this:
+                    Caption.BackButtonActive = !parentRows.IsEmpty() && (value);
+                    Caption.BackButtonVisible = Caption.BackButtonActive;
+                    RecreateDataGridRows();
+
+                    OnAllowNavigationChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_ALLOWNAVIGATIONCHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnNavigationModeChangedDescr))]
+        public event EventHandler AllowNavigationChanged
+        {
+            add => Events.AddHandler(EVENT_ALLOWNAVIGATIONCHANGED, value);
+            remove => Events.RemoveHandler(EVENT_ALLOWNAVIGATIONCHANGED, value);
+        }
+
+        [
+            Browsable(false), EditorBrowsable(EditorBrowsableState.Never)
+        ]
+        public override Cursor Cursor
+        {
+            // get the cursor out of the propertyGrid.
+            get
+            {
+                return base.Cursor;
+            }
+
+            set
+            {
+                base.Cursor = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler CursorChanged
+        {
+            add => base.CursorChanged += value;
+            remove => base.CursorChanged -= value;
+        }
+
+        [
+            Browsable(false), EditorBrowsable(EditorBrowsableState.Never)
+        ]
+        public override Image BackgroundImage
+        {
+            // get the BackgroundImage out of the propertyGrid.
+            get
+            {
+                return base.BackgroundImage;
+            }
+
+            set
+            {
+                base.BackgroundImage = value;
+            }
+        }
+
+        [
+            Browsable(false), EditorBrowsable(EditorBrowsableState.Never)
+        ]
+        public override ImageLayout BackgroundImageLayout
+        {
+            // get the BackgroundImage out of the propertyGrid.
+            get
+            {
+                return base.BackgroundImageLayout;
+            }
+
+            set
+            {
+                base.BackgroundImageLayout = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageChanged
+        {
+            add => base.BackgroundImageChanged += value;
+            remove => base.BackgroundImageChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageLayoutChanged
+        {
+            add => base.BackgroundImageLayoutChanged += value;
+            remove => base.BackgroundImageLayoutChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets or sets the background color of parent rows.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridParentRowsBackColorDescr))
+        ]
+        public Color ParentRowsBackColor
+        {
+            get
+            {
+                return parentRows.BackColor;
+            }
+            set
+            {
+                if (IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTransparentParentRowsBackColorNotAllowed);
+                }
+
+                parentRows.BackColor = value;
+            }
+        }
+
+        internal SolidBrush ParentRowsBackBrush
+        {
+            get
+            {
+                return parentRows.BackBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='ParentRowsBackColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        protected virtual bool ShouldSerializeParentRowsBackColor()
+        {
+            return !ParentRowsBackBrush.Equals(DefaultParentRowsBackBrush);
+        }
+
+        private void ResetParentRowsBackColor()
+        {
+            if (ShouldSerializeParentRowsBackColor())
+            {
+                parentRows.BackBrush = DefaultParentRowsBackBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the foreground color of parent rows.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridParentRowsForeColorDescr))
+        ]
+        public Color ParentRowsForeColor
+        {
+            get
+            {
+                return parentRows.ForeColor;
+            }
+            set
+            {
+                parentRows.ForeColor = value;
+            }
+        }
+
+        internal SolidBrush ParentRowsForeBrush
+        {
+            get
+            {
+                return parentRows.ForeBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Indicates whether the <see cref='ParentRowsForeColor'/> property should be
+        ///  persisted.
+        /// </summary>
+        protected virtual bool ShouldSerializeParentRowsForeColor()
+        {
+            return !ParentRowsForeBrush.Equals(DefaultParentRowsForeBrush);
+        }
+
+        private void ResetParentRowsForeColor()
+        {
+            if (ShouldSerializeParentRowsForeColor())
+            {
+                parentRows.ForeBrush = DefaultParentRowsForeBrush;
+            }
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets the default width of the grid columns in
+        ///  pixels.
+        /// </summary>
+        [
+         DefaultValue(defaultPreferredColumnWidth),
+         SRCategory(nameof(SR.CatLayout)),
+         SRDescription(nameof(SR.DataGridPreferredColumnWidthDescr)),
+         TypeConverter(typeof(DataGridPreferredColumnWidthTypeConverter))
+        ]
+        public int PreferredColumnWidth
+        {
+            get
+            {
+                return preferredColumnWidth;
+            }
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException(SR.DataGridColumnWidth, "PreferredColumnWidth");
+                }
+
+                if (preferredColumnWidth != value)
+                {
+                    preferredColumnWidth = value;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the preferred row height for the <see cref='DataGrid'/> control.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatLayout)),
+         SRDescription(nameof(SR.DataGridPreferredRowHeightDescr))
+        ]
+        public int PreferredRowHeight
+        {
+            get
+            {
+                return preferredRowHeight;
+            }
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentException(SR.DataGridRowRowHeight);
+                }
+
+                preferredRowHeight = value;
+            }
+        }
+
+        private void ResetPreferredRowHeight()
+        {
+            preferredRowHeight = defaultFontHeight + 3;
+        }
+
+        protected bool ShouldSerializePreferredRowHeight()
+        {
+            return preferredRowHeight != defaultFontHeight + 3;
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the grid
+        ///  is in read-only mode.
+        /// </summary>
+        [
+         DefaultValue(false),
+         SRCategory(nameof(SR.CatBehavior)),
+         SRDescription(nameof(SR.DataGridReadOnlyDescr))
+        ]
+        public bool ReadOnly
+        {
+            get
+            {
+                return gridState[GRIDSTATE_readOnlyMode];
+            }
+            set
+            {
+                if (ReadOnly != value)
+                {
+                    bool recreateRows = false;
+                    if (value)
+                    {
+                        // AllowAdd happens to have the same boolean value as whether we need to recreate rows.
+                        recreateRows = policy.AllowAdd;
+
+                        policy.AllowRemove = false;
+                        policy.AllowEdit = false;
+                        policy.AllowAdd = false;
+                    }
+                    else
+                    {
+                        recreateRows |= policy.UpdatePolicy(listManager, value);
+                    }
+
+                    gridState[GRIDSTATE_readOnlyMode] = value;
+                    DataGridRow[] dataGridRows = DataGridRows;
+                    if (recreateRows)
+                    {
+                        RecreateDataGridRows();
+
+                        // keep the selected rows
+                        DataGridRow[] currentDataGridRows = DataGridRows;
+                        int rowCount = Math.Min(currentDataGridRows.Length, dataGridRows.Length);
+                        for (int i = 0; i < rowCount; i++)
+                        {
+                            if (dataGridRows[i].Selected)
+                            {
+                                currentDataGridRows[i].Selected = true;
+                            }
+                        }
+                    }
+
+                    // the addnew row needs to be updated.
+                    PerformLayout();
+                    InvalidateInside();
+                    OnReadOnlyChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_READONLYCHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnReadOnlyChangedDescr))]
+        public event EventHandler ReadOnlyChanged
+        {
+            add => Events.AddHandler(EVENT_READONLYCHANGED, value);
+            remove => Events.RemoveHandler(EVENT_READONLYCHANGED, value);
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets a value indicating if the grid's column headers are visible.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatDisplay)),
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridColumnHeadersVisibleDescr))
+        ]
+        public bool ColumnHeadersVisible
+        {
+            get
+            {
+                return gridState[GRIDSTATE_columnHeadersVisible];
+            }
+            set
+            {
+                if (ColumnHeadersVisible != value)
+                {
+                    gridState[GRIDSTATE_columnHeadersVisible] = value;
+                    layout.ColumnHeadersVisible = value;
+                    PerformLayout();
+                    InvalidateInside();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the parent rows of a table are
+        ///  visible.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatDisplay)),
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridParentRowsVisibleDescr))
+        ]
+        public bool ParentRowsVisible
+        {
+            get
+            {
+                return layout.ParentRowsVisible;
+            }
+            set
+            {
+                if (layout.ParentRowsVisible != value)
+                {
+                    SetParentRowsVisibility(value);
+
+                    // update the caption: parentDownVisible == false corresponds to DownButtonDown == true;
+                    //
+                    caption.SetDownButtonDirection(!value);
+
+                    OnParentRowsVisibleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        private static readonly object EVENT_PARENTROWSVISIBLECHANGED = new object();
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.DataGridOnParentRowsVisibleChangedDescr))]
+        public event EventHandler ParentRowsVisibleChanged
+        {
+            add => Events.AddHandler(EVENT_PARENTROWSVISIBLECHANGED, value);
+            remove => Events.RemoveHandler(EVENT_PARENTROWSVISIBLECHANGED, value);
+        }
+
+        internal bool ParentRowsIsEmpty()
+        {
+            return parentRows.IsEmpty();
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the data grid's row headers are
+        ///  visible.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatDisplay)),
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridRowHeadersVisibleDescr))
+        ]
+        public bool RowHeadersVisible
+        {
+            get
+            {
+                return gridState[GRIDSTATE_rowHeadersVisible];
+            }
+            set
+            {
+                if (RowHeadersVisible != value)
+                {
+                    gridState[GRIDSTATE_rowHeadersVisible] = value;
+                    PerformLayout();
+                    InvalidateInside();
+                }
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatLayout)),
+         DefaultValue(defaultRowHeaderWidth),
+         SRDescription(nameof(SR.DataGridRowHeaderWidthDescr))
+        ]
+        public int RowHeaderWidth
+        {
+            get
+            {
+                return rowHeaderWidth;
+            }
+            set
+            {
+                value = Math.Max(minRowHeaderWidth, value);
+                if (rowHeaderWidth != value)
+                {
+                    rowHeaderWidth = value;
+                    if (layout.RowHeadersVisible)
+                    {
+                        PerformLayout();
+                        InvalidateInside();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the width of headers.
+        /// </summary>
+        [
+         Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
+         DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+         Bindable(false)
+        ]
+        public override string Text
+        {
+            get
+            {
+                return base.Text;
+            }
+            set
+            {
+                base.Text = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler TextChanged
+        {
+            add => base.TextChanged += value;
+            remove => base.TextChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets the vertical scroll bar of the control.
+        /// </summary>
+        [
+         Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
+         SRDescription(nameof(SR.DataGridVertScrollBarDescr))
+        ]
+        protected ScrollBar VertScrollBar
+        {
+            get
+            {
+                return vertScrollBar;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the number of visible columns.
+        /// </summary>
+        [
+         Browsable(false),
+         SRDescription(nameof(SR.DataGridVisibleColumnCountDescr))
+        ]
+        public int VisibleColumnCount
+        {
+            get
+            {
+                return Math.Min(numVisibleCols, myGridTable == null ? 0 : myGridTable.GridColumnStyles.Count);
+            }
+        }
+
+        /// <summary>
+        ///  Gets the number of rows visible.
+        /// </summary>
+        [
+         Browsable(false),
+         SRDescription(nameof(SR.DataGridVisibleRowCountDescr))
+        ]
+        public int VisibleRowCount
+        {
+            get
+            {
+                return numVisibleRows;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the value of the cell at
+        ///  the specified the row and column.
+        /// </summary>
+        public object this[int rowIndex, int columnIndex]
+        {
+            get
+            {
+                EnsureBound();
+                if (rowIndex < 0 || rowIndex >= DataGridRowsLength)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(rowIndex));
+                }
+
+                if (columnIndex < 0 || columnIndex >= myGridTable.GridColumnStyles.Count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(columnIndex));
+                }
+
+                CurrencyManager listManager = this.listManager;
+                DataGridColumnStyle column = myGridTable.GridColumnStyles[columnIndex];
+                return column.GetColumnValueAtRow(listManager, rowIndex);
+            }
+            set
+            {
+                EnsureBound();
+                if (rowIndex < 0 || rowIndex >= DataGridRowsLength)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(rowIndex));
+                }
+
+                if (columnIndex < 0 || columnIndex >= myGridTable.GridColumnStyles.Count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(columnIndex));
+                }
+
+                CurrencyManager listManager = this.listManager;
+                if (listManager.Position != rowIndex)
+                {
+                    listManager.Position = rowIndex;
+                }
+
+                DataGridColumnStyle column = myGridTable.GridColumnStyles[columnIndex];
+                column.SetColumnValueAtRow(listManager, rowIndex, value);
+
+                // invalidate the bounds of the cell only if the cell is visible
+                if (columnIndex >= firstVisibleCol && columnIndex <= firstVisibleCol + numVisibleCols - 1 &&
+                    rowIndex >= firstVisibleRow && rowIndex <= firstVisibleRow + numVisibleRows)
+                {
+                    Rectangle bounds = GetCellBounds(rowIndex, columnIndex);
+                    Invalidate(bounds);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the value of a specified <see cref='DataGridCell'/>.
+        /// </summary>
+        public object this[DataGridCell cell]
+        {
+            get
+            {
+                return this[cell.RowNumber, cell.ColumnNumber];
+            }
+            set
+            {
+                this[cell.RowNumber, cell.ColumnNumber] = value;
+            }
+        }
+
+        private void WireTableStylePropChanged(DataGridTableStyle gridTable)
+        {
+            gridTable.GridLineColorChanged += new EventHandler(GridLineColorChanged);
+            gridTable.GridLineStyleChanged += new EventHandler(GridLineStyleChanged);
+            gridTable.HeaderBackColorChanged += new EventHandler(HeaderBackColorChanged);
+            gridTable.HeaderFontChanged += new EventHandler(HeaderFontChanged);
+            gridTable.HeaderForeColorChanged += new EventHandler(HeaderForeColorChanged);
+            gridTable.LinkColorChanged += new EventHandler(LinkColorChanged);
+            gridTable.LinkHoverColorChanged += new EventHandler(LinkHoverColorChanged);
+            gridTable.PreferredColumnWidthChanged += new EventHandler(PreferredColumnWidthChanged);
+            gridTable.RowHeadersVisibleChanged += new EventHandler(RowHeadersVisibleChanged);
+            gridTable.ColumnHeadersVisibleChanged += new EventHandler(ColumnHeadersVisibleChanged);
+            gridTable.RowHeaderWidthChanged += new EventHandler(RowHeaderWidthChanged);
+            gridTable.AllowSortingChanged += new EventHandler(AllowSortingChanged);
+        }
+
+        private void UnWireTableStylePropChanged(DataGridTableStyle gridTable)
+        {
+            gridTable.GridLineColorChanged -= new EventHandler(GridLineColorChanged);
+            gridTable.GridLineStyleChanged -= new EventHandler(GridLineStyleChanged);
+            gridTable.HeaderBackColorChanged -= new EventHandler(HeaderBackColorChanged);
+            gridTable.HeaderFontChanged -= new EventHandler(HeaderFontChanged);
+            gridTable.HeaderForeColorChanged -= new EventHandler(HeaderForeColorChanged);
+            gridTable.LinkColorChanged -= new EventHandler(LinkColorChanged);
+            gridTable.LinkHoverColorChanged -= new EventHandler(LinkHoverColorChanged);
+            gridTable.PreferredColumnWidthChanged -= new EventHandler(PreferredColumnWidthChanged);
+            gridTable.RowHeadersVisibleChanged -= new EventHandler(RowHeadersVisibleChanged);
+            gridTable.ColumnHeadersVisibleChanged -= new EventHandler(ColumnHeadersVisibleChanged);
+            gridTable.RowHeaderWidthChanged -= new EventHandler(RowHeaderWidthChanged);
+            gridTable.AllowSortingChanged -= new EventHandler(AllowSortingChanged);
+        }
+
+        /// <summary>
+        ///  DataSource events are handled
+        /// </summary>
+        private void WireDataSource()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: WireDataSource");
+            Debug.Assert(listManager != null, "Can't wire up to a null DataSource");
+            listManager.CurrentChanged += currentChangedHandler;
+            listManager.PositionChanged += positionChangedHandler;
+            listManager.ItemChanged += itemChangedHandler;
+            listManager.MetaDataChanged += metaDataChangedHandler;
+        }
+
+        private void UnWireDataSource()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: UnWireDataSource");
+            Debug.Assert(listManager != null, "Can't un wire from a null DataSource");
+            listManager.CurrentChanged -= currentChangedHandler;
+            listManager.PositionChanged -= positionChangedHandler;
+            listManager.ItemChanged -= itemChangedHandler;
+            listManager.MetaDataChanged -= metaDataChangedHandler;
+        }
+
+        // This is called after a row has been added.  And I think whenever
+        // a row gets deleted, etc.
+        // We recreate our datagrid rows at this point.
+        private void DataSource_Changed(object sender, EventArgs ea)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource_Changed");
+
+            // the grid will receive the dataSource_Changed event when
+            // allowAdd changes on the dataView.
+            policy.UpdatePolicy(ListManager, ReadOnly);
+            if (gridState[GRIDSTATE_inListAddNew])
+            {
+                // we are adding a new row
+                // keep the old rows, w/ their height, expanded/collapsed information
+                //
+                Debug.Assert(policy.AllowAdd, "how can we add a new row if the policy does not allow this?");
+                Debug.Assert(DataGridRowsLength == DataGridRows.Length, "how can this fail?");
+
+                DataGridRow[] gridRows = DataGridRows;
+                int currentRowCount = DataGridRowsLength;
+                // put the added row:
+                //
+                gridRows[currentRowCount - 1] = new DataGridRelationshipRow(this, myGridTable, currentRowCount - 1);
+                SetDataGridRows(gridRows, currentRowCount);
+            }
+            else if (gridState[GRIDSTATE_inAddNewRow] && !gridState[GRIDSTATE_inDeleteRow])
+            {
+                // when the backEnd adds a row and we are still inAddNewRow
+                listManager.CancelCurrentEdit();
+                gridState[GRIDSTATE_inAddNewRow] = false;
+                RecreateDataGridRows();
+            }
+            else if (!gridState[GRIDSTATE_inDeleteRow])
+            {
+                RecreateDataGridRows();
+                currentRow = Math.Min(currentRow, listManager.Count);
+            }
+
+            bool oldListHasErrors = ListHasErrors;
+            ListHasErrors = DataGridSourceHasErrors();
+            // if we changed the ListHasErrors, then the grid is already invalidated
+            if (oldListHasErrors == ListHasErrors)
+            {
+                InvalidateInside();
+            }
+        }
+
+        private void GridLineColorChanged(object sender, EventArgs e)
+        {
+            Invalidate(layout.Data);
+        }
+
+        private void GridLineStyleChanged(object sender, EventArgs e)
+        {
+            myGridTable.ResetRelationsUI();
+            Invalidate(layout.Data);
+        }
+
+        private void HeaderBackColorChanged(object sender, EventArgs e)
+        {
+            if (layout.RowHeadersVisible)
+            {
+                Invalidate(layout.RowHeaders);
+            }
+
+            if (layout.ColumnHeadersVisible)
+            {
+                Invalidate(layout.ColumnHeaders);
+            }
+
+            Invalidate(layout.TopLeftHeader);
+        }
+
+        private void HeaderFontChanged(object sender, EventArgs e)
+        {
+            RecalculateFonts();
+            PerformLayout();
+            Invalidate(layout.Inside);
+        }
+
+        private void HeaderForeColorChanged(object sender, EventArgs e)
+        {
+            if (layout.RowHeadersVisible)
+            {
+                Invalidate(layout.RowHeaders);
+            }
+
+            if (layout.ColumnHeadersVisible)
+            {
+                Invalidate(layout.ColumnHeaders);
+            }
+
+            Invalidate(layout.TopLeftHeader);
+        }
+
+        private void LinkColorChanged(object sender, EventArgs e)
+        {
+            Invalidate(layout.Data);
+        }
+
+        private void LinkHoverColorChanged(object sender, EventArgs e)
+        {
+            Invalidate(layout.Data);
+        }
+
+        private void PreferredColumnWidthChanged(object sender, EventArgs e)
+        {
+            // reset the dataGridRows
+            SetDataGridRows(null, DataGridRowsLength);
+            // layout the horizontal scroll bar
+            PerformLayout();
+            // invalidate everything
+            Invalidate();
+        }
+
+        private void RowHeadersVisibleChanged(object sender, EventArgs e)
+        {
+            layout.RowHeadersVisible = myGridTable == null ? false : myGridTable.RowHeadersVisible;
+            PerformLayout();
+            InvalidateInside();
+        }
+
+        private void ColumnHeadersVisibleChanged(object sender, EventArgs e)
+        {
+            layout.ColumnHeadersVisible = myGridTable == null ? false : myGridTable.ColumnHeadersVisible;
+            PerformLayout();
+            InvalidateInside();
+        }
+
+        private void RowHeaderWidthChanged(object sender, EventArgs e)
+        {
+            if (layout.RowHeadersVisible)
+            {
+                PerformLayout();
+                InvalidateInside();
+            }
+        }
+
+        private void AllowSortingChanged(object sender, EventArgs e)
+        {
+            if (!myGridTable.AllowSorting && listManager != null)
+            {
+                IList list = listManager.List;
+                if (list is IBindingList)
+                {
+                    ((IBindingList)list).RemoveSort();
+                }
+            }
+        }
+
+        private void DataSource_RowChanged(object sender, EventArgs ea)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource_RowChanged");
+            // it may be the case that our cache was not updated
+            // to the latest changes in the list : CurrentChanged is fired before
+            // ListChanged.
+            // So invalidate the row if there is something to invalidate
+            DataGridRow[] rows = DataGridRows;
+            if (currentRow < DataGridRowsLength)
+            {
+                InvalidateRow(currentRow);
+            }
+        }
+
+        /// <summary>
+        ///  Fired by the DataSource when row position moves.
+        /// </summary>
+        private void DataSource_PositionChanged(object sender, EventArgs ea)
+        {
+#if DEBUG
+            inDataSource_PositionChanged = true;
+#endif
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource_PositionChanged to " + listManager.Position.ToString(CultureInfo.InvariantCulture));
+            // the grid will get the PositionChanged event
+            // before the OnItemChanged event when a row will be deleted in the backEnd;
+            // we still want to keep the old rows when the user deletes the rows using the grid
+            // and we do not want to do the same work twice when the user adds a row via the grid
+            if (DataGridRowsLength > listManager.Count + (policy.AllowAdd ? 1 : 0) && !gridState[GRIDSTATE_inDeleteRow])
+            {
+                Debug.Assert(!gridState[GRIDSTATE_inAddNewRow] && !gridState[GRIDSTATE_inListAddNew], "how can the list decrease when we are adding a row?");
+                RecreateDataGridRows();
+            }
+
+            if (ListManager.Position != currentRow)
+            {
+                CurrentCell = new DataGridCell(listManager.Position, currentCol);
+            }
+#if DEBUG
+            inDataSource_PositionChanged = false;
+#endif
+        }
+
+        internal void DataSource_MetaDataChanged(object sender, EventArgs e)
+        {
+            MetaDataChanged();
+        }
+
+        private bool DataGridSourceHasErrors()
+        {
+            if (listManager == null)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < listManager.Count; i++)
+            {
+                object errObj = listManager[i];
+                if (errObj is IDataErrorInfo)
+                {
+                    string errString = ((IDataErrorInfo)errObj).Error;
+                    if (errString != null && errString.Length != 0)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private void TableStylesCollectionChanged(object sender, CollectionChangeEventArgs ccea)
+        {
+            // if the users changed the collection of tableStyles
+            if (sender != dataGridTables)
+            {
+                return;
+            }
+
+            if (listManager == null)
+            {
+                return;
+            }
+
+            if (ccea.Action == CollectionChangeAction.Add)
+            {
+                DataGridTableStyle tableStyle = (DataGridTableStyle)ccea.Element;
+                if (listManager.GetListName().Equals(tableStyle.MappingName))
+                {
+                    Debug.Assert(myGridTable.IsDefault, "if the table is not default, then it had a name. how can one add another table to the collection w/ the same name and not throw an exception");
+                    SetDataGridTable(tableStyle, true);                // true for forcing column creation
+                    SetDataGridRows(null, 0);
+                }
+            }
+            else if (ccea.Action == CollectionChangeAction.Remove)
+            {
+                DataGridTableStyle tableStyle = (DataGridTableStyle)ccea.Element;
+                if (myGridTable.MappingName.Equals(tableStyle.MappingName))
+                {
+                    Debug.Assert(myGridTable.IsDefault, "if the table is not default, then it had a name. how can one add another table to the collection w/ the same name and not throw an exception");
+                    defaultTableStyle.GridColumnStyles.ResetDefaultColumnCollection();
+                    SetDataGridTable(defaultTableStyle, true);    // true for forcing column creation
+                    SetDataGridRows(null, 0);
+                }
+            }
+            else
+            {
+                Debug.Assert(ccea.Action == CollectionChangeAction.Refresh, "what else is possible?");
+                // we have to search to see if the collection of table styles contains one
+                // w/ the same name as the list in the dataGrid
+
+                DataGridTableStyle newGridTable = dataGridTables[listManager.GetListName()];
+                if (newGridTable == null)
+                {
+                    if (!myGridTable.IsDefault)
+                    {
+                        // get rid of the old gridColumns
+                        defaultTableStyle.GridColumnStyles.ResetDefaultColumnCollection();
+                        SetDataGridTable(defaultTableStyle, true);    // true for forcing column creation
+                        SetDataGridRows(null, 0);
+                    }
+                }
+                else
+                {
+                    SetDataGridTable(newGridTable, true);              // true for forcing column creation
+                    SetDataGridRows(null, 0);
+                }
+            }
+        }
+
+        private void DataSource_ItemChanged(object sender, ItemChangedEventArgs ea)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: DataSource_ItemChanged at index " + ea.Index.ToString(CultureInfo.InvariantCulture));
+
+            // if ea.Index == -1, then we invalidate all rows.
+            if (ea.Index == -1)
+            {
+                DataSource_Changed(sender, EventArgs.Empty);
+                /*
+                // if there are rows which are invisible, it is more efficient to invalidata layout.Data
+                if (numVisibleRows <= dataGridRowsLength)
+                    Invalidate(layout.Data);
+                else
+                {
+                    Debug.Assert(firstVisibleRow == 0, "if all rows are visible, then how come that first row is not visible?");
+                    for (int i = 0; i < numVisibleRows; i++)
+                        InvalidateRow(firstVisibleRow + numVisibleRows);
+                }
+                */
+            }
+            else
+            {
+                // let's see how we are doing w/ the errors
+                object errObj = listManager[ea.Index];
+                bool oldListHasErrors = ListHasErrors;
+                if (errObj is IDataErrorInfo)
+                {
+                    if (((IDataErrorInfo)errObj).Error.Length != 0)
+                    {
+                        ListHasErrors = true;
+                    }
+                    else if (ListHasErrors)
+                    {
+                        // maybe there was an error that now is fixed
+                        ListHasErrors = DataGridSourceHasErrors();
+                    }
+                }
+
+                // Invalidate the row only if we did not change the ListHasErrors
+                if (oldListHasErrors == ListHasErrors)
+                {
+                    InvalidateRow(ea.Index);
+                }
+
+                // we need to update the edit box:
+                // we update the text in the edit box only when the currentRow
+                // equals the ea.Index
+                if (editColumn != null && ea.Index == currentRow)
+                {
+                    editColumn.UpdateUI(ListManager, ea.Index, null);
+                }
+            }
+        }
+
+        protected virtual void OnBorderStyleChanged(EventArgs e)
+        {
+            if (Events[EVENT_BORDERSTYLECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnCaptionVisibleChanged(EventArgs e)
+        {
+            if (Events[EVENT_CAPTIONVISIBLECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnCurrentCellChanged(EventArgs e)
+        {
+            if (Events[EVENT_CURRENTCELLCHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnFlatModeChanged(EventArgs e)
+        {
+            if (Events[EVENT_FLATMODECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnBackgroundColorChanged(EventArgs e)
+        {
+            if (Events[EVENT_BACKGROUNDCOLORCHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnAllowNavigationChanged(EventArgs e)
+        {
+            if (Events[EVENT_ALLOWNAVIGATIONCHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnParentRowsVisibleChanged(EventArgs e)
+        {
+            if (Events[EVENT_PARENTROWSVISIBLECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnParentRowsLabelStyleChanged(EventArgs e)
+        {
+            if (Events[EVENT_PARENTROWSLABELSTYLECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnReadOnlyChanged(EventArgs e)
+        {
+            if (Events[EVENT_READONLYCHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Navigate'/>
+        ///  event.
+        /// </summary>
+        protected void OnNavigate(NavigateEventArgs e)
+        {
+            onNavigate?.Invoke(this, e);
+        }
+
+        /*
+        /// <summary>
+        ///  Raises the <see cref='System.Windows.Forms.DataGrid.ColumnResize'/> event.
+        /// </summary>
+        protected void OnColumnResize(EventArgs e) {
+            RaiseEvent(EVENT_COLUMNRESIZE, e);
+        }
+
+        internal void OnLinkClick(EventArgs e) {
+            RaiseEvent(EVENT_LINKCLICKED, e);
+        }
+        */
+
+        internal void OnNodeClick(EventArgs e)
+        {
+            // if we expanded/collapsed the RelationshipRow
+            // then we need to layout the vertical scroll bar
+            //
+            PerformLayout();
+
+            // also, we need to let the hosted edit control that its
+            // boundaries possibly changed. do this with a call to Edit()
+            // do this only if the firstVisibleColumn is the editColumn
+            //
+            GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+            if (firstVisibleCol > -1 && firstVisibleCol < columns.Count && columns[firstVisibleCol] == editColumn)
+            {
+                Edit();
+            }
+
+            // Raise the event for the event listeners
+            ((EventHandler)Events[EVENT_NODECLICKED])?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='RowHeaderClick'/> event.
+        /// </summary>
+        protected void OnRowHeaderClick(EventArgs e)
+        {
+            onRowHeaderClick?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Scroll'/> event.
+        /// </summary>
+        protected void OnScroll(EventArgs e)
+        {
+            // reset the toolTip information
+            if (ToolTipProvider != null)
+            {
+                ResetToolTip();
+            }
+
+((EventHandler)Events[EVENT_SCROLL])?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Listens
+        ///  for the horizontal scrollbar's scroll
+        ///  event.
+        /// </summary>
+        protected virtual void GridHScrolled(object sender, ScrollEventArgs se)
+        {
+            if (!Enabled)
+            {
+                return;
+            }
+
+            if (DataSource == null)
+            {
+                Debug.Fail("Horizontal Scrollbar should be disabled without a DataSource.");
+                return;
+            }
+
+            gridState[GRIDSTATE_isScrolling] = true;
+
+#if DEBUG
+
+            Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: in GridHScrolled: the scroll event type:");
+            switch (se.Type)
+            {
+                case ScrollEventType.SmallIncrement:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "small increment");
+                    break;
+                case ScrollEventType.SmallDecrement:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "small decrement");
+                    break;
+                case ScrollEventType.LargeIncrement:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "Large decrement");
+                    break;
+                case ScrollEventType.LargeDecrement:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "small decrement");
+                    break;
+                case ScrollEventType.ThumbPosition:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "Thumb Position");
+                    break;
+                case ScrollEventType.ThumbTrack:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "Thumb Track");
+                    break;
+                case ScrollEventType.First:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "First");
+                    break;
+                case ScrollEventType.Last:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "Last");
+                    break;
+                case ScrollEventType.EndScroll:
+                    Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "EndScroll");
+                    break;
+            }
+
+#endif // DEBUG
+
+            if (se.Type == ScrollEventType.SmallIncrement ||
+                se.Type == ScrollEventType.SmallDecrement)
+            {
+                int dCols = (se.Type == ScrollEventType.SmallIncrement) ? 1 : -1;
+                if (se.Type == ScrollEventType.SmallDecrement && negOffset == 0)
+                {
+                    GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+                    // if the column before the first visible column has width == 0 then skip it
+                    for (int i = firstVisibleCol - 1; i >= 0 && cols[i].Width == 0; i--)
+                    {
+                        dCols--;
+                    }
+                }
+
+                if (se.Type == ScrollEventType.SmallIncrement && negOffset == 0)
+                {
+                    GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+                    for (int i = firstVisibleCol; i > -1 && i < cols.Count && cols[i].Width == 0; i++)
+                    {
+                        dCols++;
+                    }
+                }
+
+                ScrollRight(dCols);
+                se.NewValue = HorizontalOffset;
+            }
+            else if (se.Type != ScrollEventType.EndScroll)
+            {
+                HorizontalOffset = se.NewValue;
+            }
+
+            gridState[GRIDSTATE_isScrolling] = false;
+        }
+
+        /// <summary>
+        ///  Listens
+        ///  for the vertical scrollbar's scroll event.
+        /// </summary>
+        protected virtual void GridVScrolled(object sender, ScrollEventArgs se)
+        {
+            if (!Enabled)
+            {
+                return;
+            }
+
+            if (DataSource == null)
+            {
+                Debug.Fail("Vertical Scrollbar should be disabled without a DataSource.");
+                return;
+            }
+
+            gridState[GRIDSTATE_isScrolling] = true;
+
+            try
+            {
+                se.NewValue = Math.Min(se.NewValue, DataGridRowsLength - numTotallyVisibleRows);
+                int dRows = se.NewValue - firstVisibleRow;
+                ScrollDown(dRows);
+            }
+            finally
+            {
+                gridState[GRIDSTATE_isScrolling] = false;
+            }
+        }
+
+        private void HandleEndCurrentEdit()
+        {
+            int currentRowSaved = currentRow;
+            int currentColSaved = currentCol;
+
+            string errorMessage = null;
+
+            try
+            {
+                listManager.EndCurrentEdit();
+            }
+            catch (Exception e)
+            {
+                errorMessage = e.Message;
+            }
+
+            if (errorMessage != null)
+            {
+                DialogResult result = RTLAwareMessageBox.Show(null, string.Format(SR.DataGridPushedIncorrectValueIntoColumn,
+                        errorMessage), SR.DataGridErrorMessageBoxCaption, MessageBoxButtons.YesNo,
+                        MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
+
+                if (result == DialogResult.Yes)
+                {
+                    currentRow = currentRowSaved;
+                    currentCol = currentColSaved;
+                    Debug.Assert(currentRow == ListManager.Position || listManager.Position == -1, "the position in the list manager (" + ListManager.Position + ") is out of sync with the currentRow (" + currentRow + ")" + " and the exception is '" + errorMessage + "'");
+                    // also, make sure that we get the row selector on the currentrow, too
+                    InvalidateRowHeader(currentRow);
+                    Edit();
+                }
+                else
+                {
+                    // if the user committed a row that used to be addNewRow and the backEnd rejects it,
+                    // and then it tries to navigate down then we should stay in the addNewRow
+                    // in this particular scenario, CancelCurrentEdit will cause the last row to be deleted,
+                    // and this will ultimately call InvalidateRow w/ a row number larger than the number of rows
+                    // so set the currentRow here:
+                    Debug.Assert(result == DialogResult.No, "we only put cancel and ok on the error message box");
+                    listManager.PositionChanged -= positionChangedHandler;
+                    listManager.CancelCurrentEdit();
+                    listManager.Position = currentRow;
+                    listManager.PositionChanged += positionChangedHandler;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Listens
+        ///  for the caption's back button clicked event.
+        /// </summary>
+        protected void OnBackButtonClicked(object sender, EventArgs e)
+        {
+            NavigateBack();
+
+            ((EventHandler)Events[EVENT_BACKBUTTONCLICK])?.Invoke(this, e);
+        }
+
+        protected override void OnBackColorChanged(EventArgs e)
+        {
+            backBrush = new SolidBrush(BackColor);
+            Invalidate();
+
+            base.OnBackColorChanged(e);
+        }
+
+        protected override void OnBindingContextChanged(EventArgs e)
+        {
+            if (DataSource != null && !gridState[GRIDSTATE_inSetListManager])
+            {
+                try
+                {
+                    Set_ListManager(DataSource, DataMember, true, false);     // we do not want to create columns
+                                                                              // if the columns are already created
+                                                                              // the grid should not rely on OnBindingContextChanged
+                                                                              // to create columns.
+                }
+                catch
+                {
+                    // at runtime we will rethrow the exception
+                    if (Site == null || !Site.DesignMode)
+                    {
+                        throw;
+                    }
+
+                    RTLAwareMessageBox.Show(null, SR.DataGridExceptionInPaint, null,
+                        MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
+
+                    if (Visible)
+                    {
+                        BeginUpdateInternal();
+                    }
+
+                    ResetParentRows();
+
+                    Set_ListManager(null, string.Empty, true);
+                    if (Visible)
+                    {
+                        EndUpdateInternal();
+                    }
+                }
+            }
+
+            base.OnBindingContextChanged(e);
+        }
+
+        protected virtual void OnDataSourceChanged(EventArgs e)
+        {
+            if (Events[EVENT_DATASOURCECHANGED] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Listens for
+        ///  the caption's down button clicked event.
+        /// </summary>
+        protected void OnShowParentDetailsButtonClicked(object sender, EventArgs e)
+        {
+            // we need to fire the ParentRowsVisibleChanged event
+            // and the ParentRowsVisible property just calls SetParentRowsVisibility and
+            // then fires the event.
+            ParentRowsVisible = !caption.ToggleDownButtonDirection();
+
+            ((EventHandler)Events[EVENT_DOWNBUTTONCLICK])?.Invoke(this, e);
+        }
+
+        protected override void OnForeColorChanged(EventArgs e)
+        {
+            foreBrush = new SolidBrush(ForeColor);
+            Invalidate();
+
+            base.OnForeColorChanged(e);
+        }
+
+        protected override void OnFontChanged(EventArgs e)
+        {
+            // let the caption know about the event changed
+            //
+            Caption.OnGridFontChanged();
+            RecalculateFonts();
+            RecreateDataGridRows();
+            // get all the rows in the parentRows stack, and modify their height
+            if (originalState != null)
+            {
+                Debug.Assert(!parentRows.IsEmpty(), "if the originalState is not null, then parentRows contains at least one row");
+                Stack parentStack = new Stack();
+                // this is a huge performance hit:
+                // everytime we get/put something from/to
+                // the parentRows, the buttons in the dataGridCaption
+                // are invalidated
+                while (!parentRows.IsEmpty())
+                {
+                    DataGridState dgs = parentRows.PopTop();
+                    int rowCount = dgs.DataGridRowsLength;
+
+                    for (int i = 0; i < rowCount; i++)
+                    {
+                        // performance hit: this will cause to invalidate a bunch of
+                        // stuff
+
+                        dgs.DataGridRows[i].Height = dgs.DataGridRows[i].MinimumRowHeight(dgs.GridColumnStyles);
+                    }
+
+                    parentStack.Push(dgs);
+                }
+
+                while (parentStack.Count != 0)
+                {
+                    parentRows.AddParent((DataGridState)parentStack.Pop());
+                }
+            }
+
+            base.OnFontChanged(e);
+        }
+
+#pragma warning disable CS0419 // Ambiguous reference in cref attribute
+        /// <summary>
+        ///  Raises the <see cref='Control.PaintBackground'/>
+        ///  event.
+        /// </summary>
+        protected override void OnPaintBackground(PaintEventArgs ebe)
+#pragma warning restore CS0419 // Ambiguous reference in cref attribute
+        {
+            // null body
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.Layout'/> event which
+        ///  repositions controls
+        ///  and updates scroll bars.
+        /// </summary>
+        protected override void OnLayout(LayoutEventArgs levent)
+        {
+            // if we get a OnLayout event while the editControl changes, then just
+            // ignore it
+            //
+            if (gridState[GRIDSTATE_editControlChanging])
+            {
+                return;
+            }
+
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: OnLayout");
+            base.OnLayout(levent);
+
+            if (gridState[GRIDSTATE_layoutSuspended])
+            {
+                return;
+            }
+
+            gridState[GRIDSTATE_canFocus] = false;
+            try
+            {
+                if (IsHandleCreated)
+                {
+                    if (layout.ParentRowsVisible)
+                    {
+                        parentRows.OnLayout();
+                    }
+
+                    // reset the toolTip information
+                    if (ToolTipProvider != null)
+                    {
+                        ResetToolTip();
+                    }
+
+                    ComputeLayout();
+                }
+            }
+            finally
+            {
+                gridState[GRIDSTATE_canFocus] = true;
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.CreateHandle'/>
+        ///  event.
+        /// </summary>
+        protected override void OnHandleCreated(EventArgs e)
+        {
+            base.OnHandleCreated(e);
+
+            // toolTipping
+            toolTipProvider = new DataGridToolTip(this);
+            toolTipProvider.CreateToolTipHandle();
+            toolTipId = 0;
+
+            PerformLayout();
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.DestroyHandle'/>
+        ///  event.
+        /// </summary>
+        protected override void OnHandleDestroyed(EventArgs e)
+        {
+            base.OnHandleDestroyed(e);
+
+            // toolTipping
+            if (toolTipProvider != null)
+            {
+                toolTipProvider.Destroy();
+                toolTipProvider = null;
+            }
+
+            toolTipId = 0;
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.Enter'/>
+        ///  event.
+        /// </summary>
+        protected override void OnEnter(EventArgs e)
+        {
+            if (gridState[GRIDSTATE_canFocus] && !gridState[GRIDSTATE_editControlChanging])
+            {
+                if (Bound)
+                {
+                    Edit();
+                }
+
+                base.OnEnter(e);
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.Leave'/>
+        ///  event.
+        /// </summary>
+        protected override void OnLeave(EventArgs e)
+        {
+            OnLeave_Grid();
+            base.OnLeave(e);
+        }
+
+        private void OnLeave_Grid()
+        {
+            gridState[GRIDSTATE_canFocus] = false;
+            try
+            {
+                EndEdit();
+                if (listManager != null && !gridState[GRIDSTATE_editControlChanging])
+                {
+                    if (gridState[GRIDSTATE_inAddNewRow])
+                    {
+                        // if the user did not type anything
+                        // in the addNewRow, then cancel the currentedit
+                        listManager.CancelCurrentEdit();
+                        // set the addNewRow back
+                        DataGridRow[] localGridRows = DataGridRows;
+                        localGridRows[DataGridRowsLength - 1] = new DataGridAddNewRow(this, myGridTable, DataGridRowsLength - 1);
+                        SetDataGridRows(localGridRows, DataGridRowsLength);
+                    }
+                    else
+                    {
+                        // this.listManager.EndCurrentEdit();
+                        HandleEndCurrentEdit();
+                    }
+                }
+            }
+            finally
+            {
+                gridState[GRIDSTATE_canFocus] = true;
+                // inAddNewRow should be set to false if the control was
+                // not changing
+                if (!gridState[GRIDSTATE_editControlChanging])
+                {
+                    gridState[GRIDSTATE_inAddNewRow] = false;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.KeyDown'/>
+        ///  event.
+        /// </summary>
+        protected override void OnKeyDown(KeyEventArgs ke)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridKeys.TraceVerbose, "DataGridKeys: OnKeyDown ");
+            base.OnKeyDown(ke);
+            ProcessGridKey(ke);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.KeyPress'/> event.
+        /// </summary>
+        protected override void OnKeyPress(KeyPressEventArgs kpe)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridKeys.TraceVerbose, "DataGridKeys: OnKeyPress " + TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString(kpe.KeyChar));
+
+            base.OnKeyPress(kpe);
+            GridColumnStylesCollection coll = myGridTable.GridColumnStyles;
+            if (coll != null && currentCol > 0 && currentCol < coll.Count)
+            {
+                if (!coll[currentCol].ReadOnly)
+                {
+                    if (kpe.KeyChar > 32)
+                    {
+                        Edit(new string(new char[] { (char)kpe.KeyChar }));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.MouseDown'/> event.
+        /// </summary>
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            base.OnMouseDown(e);
+
+            gridState[GRIDSTATE_childLinkFocused] = false;
+            gridState[GRIDSTATE_dragging] = false;
+            if (listManager == null)
+            {
+                return;
+            }
+
+            HitTestInfo location = HitTest(e.X, e.Y);
+            Keys nModifier = ModifierKeys;
+            bool isControlDown = (nModifier & Keys.Control) == Keys.Control && (nModifier & Keys.Alt) == 0;
+            bool isShiftDown = (nModifier & Keys.Shift) == Keys.Shift;
+
+            // Only left clicks for now
+            if (e.Button != MouseButtons.Left)
+            {
+                return;
+            }
+
+            // Check column resize
+            if (location.type == HitTestType.ColumnResize)
+            {
+                if (e.Clicks > 1)
+                {
+                    ColAutoResize(location.col);
+                }
+                else
+                {
+                    ColResizeBegin(e, location.col);
+                }
+
+                return;
+            }
+
+            // Check row resize
+            if (location.type == HitTestType.RowResize)
+            {
+                if (e.Clicks > 1)
+                {
+                    RowAutoResize(location.row);
+                }
+                else
+                {
+                    RowResizeBegin(e, location.row);
+                }
+
+                return;
+            }
+
+            // Check column headers
+            if (location.type == HitTestType.ColumnHeader)
+            {
+                trackColumnHeader = myGridTable.GridColumnStyles[location.col].PropertyDescriptor;
+                return;
+            }
+
+            if (location.type == HitTestType.Caption)
+            {
+                Rectangle captionRect = layout.Caption;
+                caption.MouseDown(e.X - captionRect.X, e.Y - captionRect.Y);
+                return;
+            }
+
+            if (layout.Data.Contains(e.X, e.Y) || layout.RowHeaders.Contains(e.X, e.Y))
+            {
+                // Check with the row underneath the mouse
+                int row = GetRowFromY(e.Y);
+                if (row > -1)
+                {
+                    Point p = NormalizeToRow(e.X, e.Y, row);
+                    DataGridRow[] localGridRows = DataGridRows;
+                    if (localGridRows[row].OnMouseDown(p.X, p.Y,
+                                                       layout.RowHeaders,
+                                                       isRightToLeft()))
+                    {
+                        CommitEdit();
+
+                        // possibly this was the last row, so then the link may not
+                        // be visible. make it visible, by making the row visible.
+                        // how can we be sure that the user did not click
+                        // on a relationship and navigated to the child rows?
+                        // check if the row is expanded: if the row is expanded, then the user clicked
+                        // on the node. when we navigate to child rows the rows are recreated
+                        // and are initially collapsed
+                        localGridRows = DataGridRows;
+                        if (row < DataGridRowsLength && (localGridRows[row] is DataGridRelationshipRow) && ((DataGridRelationshipRow)localGridRows[row]).Expanded)
+                        {
+                            EnsureVisible(row, 0);
+                        }
+
+                        // show the edit box
+                        //
+                        Edit();
+                        return;
+                    }
+                }
+            }
+
+            // Check row headers
+            //
+            if (location.type == HitTestType.RowHeader)
+            {
+                EndEdit();
+                if (!(DataGridRows[location.row] is DataGridAddNewRow))
+                {
+                    int savedCurrentRow = currentRow;
+                    CurrentCell = new DataGridCell(location.row, currentCol);
+                    if (location.row != savedCurrentRow &&
+                        currentRow != location.row &&
+                        currentRow == savedCurrentRow)
+                    {
+                        // The data grid was not able to move away from its previous current row.
+                        // Be defensive and don't select the row.
+                        return;
+                    }
+                }
+
+                if (isControlDown)
+                {
+                    if (IsSelected(location.row))
+                    {
+                        UnSelect(location.row);
+                    }
+                    else
+                    {
+                        Select(location.row);
+                    }
+                }
+                else
+                {
+                    if (lastRowSelected == -1 || !isShiftDown)
+                    {
+                        ResetSelection();
+                        Select(location.row);
+                    }
+                    else
+                    {
+                        int lowerRow = Math.Min(lastRowSelected, location.row);
+                        int upperRow = Math.Max(lastRowSelected, location.row);
+
+                        // we need to reset the old SelectedRows.
+                        // ResetSelection() will also reset lastRowSelected, so we
+                        // need to save it
+                        int saveLastRowSelected = lastRowSelected;
+                        ResetSelection();
+                        lastRowSelected = saveLastRowSelected;
+
+                        DataGridRow[] rows = DataGridRows;
+                        for (int i = lowerRow; i <= upperRow; i++)
+                        {
+                            rows[i].Selected = true;
+                            numSelectedRows++;
+                        }
+
+                        // hide the edit box:
+                        //
+                        EndEdit();
+                        return;
+                    }
+                }
+
+                lastRowSelected = location.row;
+                // OnRowHeaderClick(EventArgs.Empty);
+                return;
+            }
+
+            // Check parentRows
+            //
+            if (location.type == HitTestType.ParentRows)
+            {
+                EndEdit();
+                parentRows.OnMouseDown(e.X, e.Y, isRightToLeft());
+            }
+
+            // Check cell clicks
+            //
+            if (location.type == HitTestType.Cell)
+            {
+                if (myGridTable.GridColumnStyles[location.col].MouseDown(location.row, e.X, e.Y))
+                {
+                    return;
+                }
+
+                DataGridCell target = new DataGridCell(location.row, location.col);
+                if (policy.AllowEdit && CurrentCell.Equals(target))
+                {
+                    ResetSelection();
+                    //
+                    // what if only a part of the current cell is visible?
+                    //
+                    EnsureVisible(currentRow, currentCol);
+                    Edit();
+                }
+                else
+                {
+                    ResetSelection();
+                    CurrentCell = target;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Creates the <see cref='Control.MouseLeave'/>
+        ///  event.
+        /// </summary>
+        protected override void OnMouseLeave(EventArgs e)
+        {
+            base.OnMouseLeave(e);
+            if (oldRow != -1)
+            {
+                DataGridRow[] localGridRows = DataGridRows;
+                localGridRows[oldRow].OnMouseLeft(layout.RowHeaders, isRightToLeft());
+            }
+
+            if (gridState[GRIDSTATE_overCaption])
+            {
+                caption.MouseLeft();
+            }
+
+            // when the mouse leaves the grid control, reset the cursor to arrow
+            Cursor = null;
+        }
+
+        internal void TextBoxOnMouseWheel(MouseEventArgs e)
+        {
+            OnMouseWheel(e);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.MouseMove'/>
+        ///  event.
+        /// </summary>
+        protected override void OnMouseMove(MouseEventArgs e)
+        {
+            base.OnMouseMove(e);
+            if (listManager == null)
+            {
+                return;
+            }
+
+            HitTestInfo location = HitTest(e.X, e.Y);
+
+            bool alignToRight = isRightToLeft();
+
+            // We need to give UI feedback when the user is resizing a column
+            if (gridState[GRIDSTATE_trackColResize])
+            {
+                ColResizeMove(e);
+            }
+
+            if (gridState[GRIDSTATE_trackRowResize])
+            {
+                RowResizeMove(e);
+            }
+
+            if (gridState[GRIDSTATE_trackColResize] || location.type == HitTestType.ColumnResize)
+            {
+                Cursor = Cursors.SizeWE;
+                return;
+            }
+            else if (gridState[GRIDSTATE_trackRowResize] || location.type == HitTestType.RowResize)
+            {
+                Cursor = Cursors.SizeNS;
+                return;
+            }
+            else
+            {
+                Cursor = null;
+            }
+
+            if ((layout.Data.Contains(e.X, e.Y)
+                || (layout.RowHeadersVisible && layout.RowHeaders.Contains(e.X, e.Y))))
+            {
+                // && (isNavigating || isEditing)) {
+                DataGridRow[] localGridRows = DataGridRows;
+                // If we are over a row, let it know about the mouse move.
+                int rowOver = GetRowFromY(e.Y);
+                // set the dragging bit:
+                if (lastRowSelected != -1 && !gridState[GRIDSTATE_dragging])
+                {
+                    int topRow = GetRowTop(lastRowSelected);
+                    int bottomRow = topRow + localGridRows[lastRowSelected].Height;
+                    int dragHeight = SystemInformation.DragSize.Height;
+                    gridState[GRIDSTATE_dragging] = ((e.Y - topRow < dragHeight && topRow - e.Y < dragHeight) || (e.Y - bottomRow < dragHeight && bottomRow - e.Y < dragHeight));
+                }
+
+                if (rowOver > -1)
+                {
+                    Point p = NormalizeToRow(e.X, e.Y, rowOver);
+                    if (!localGridRows[rowOver].OnMouseMove(p.X, p.Y, layout.RowHeaders, alignToRight) && gridState[GRIDSTATE_dragging])
+                    {
+                        // if the row did not use this, see if selection can use it
+                        MouseButtons mouse = MouseButtons;
+                        if (lastRowSelected != -1 && (mouse & MouseButtons.Left) == MouseButtons.Left
+                            && !(((Control.ModifierKeys & Keys.Control) == Keys.Control) && (Control.ModifierKeys & Keys.Alt) == 0))
+                        {
+                            // ResetSelection() will reset the lastRowSelected too
+                            //
+                            int saveLastRowSelected = lastRowSelected;
+                            ResetSelection();
+                            lastRowSelected = saveLastRowSelected;
+
+                            int lowerRow = Math.Min(lastRowSelected, rowOver);
+                            int upperRow = Math.Max(lastRowSelected, rowOver);
+
+                            DataGridRow[] rows = DataGridRows;
+                            for (int i = lowerRow; i <= upperRow; i++)
+                            {
+                                rows[i].Selected = true;
+                                numSelectedRows++;
+                            }
+                        }
+                    }
+                }
+
+                if (oldRow != rowOver && oldRow != -1)
+                {
+                    localGridRows[oldRow].OnMouseLeft(layout.RowHeaders, alignToRight);
+                }
+
+                oldRow = rowOver;
+            }
+
+            // check parentRows
+            //
+            if (location.type == HitTestType.ParentRows)
+            {
+                if (parentRows != null)
+                {
+                    parentRows.OnMouseMove(e.X, e.Y);
+                }
+            }
+
+            if (location.type == HitTestType.Caption)
+            {
+                gridState[GRIDSTATE_overCaption] = true;
+                Rectangle captionRect = layout.Caption;
+                caption.MouseOver(e.X - captionRect.X, e.Y - captionRect.Y);
+                return;
+            }
+            else
+            {
+                if (gridState[GRIDSTATE_overCaption])
+                {
+                    gridState[GRIDSTATE_overCaption] = false;
+                    caption.MouseLeft();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.MouseUp'/> event.
+        /// </summary>
+        protected override void OnMouseUp(MouseEventArgs e)
+        {
+            base.OnMouseUp(e);
+            gridState[GRIDSTATE_dragging] = false;
+            if (listManager == null || myGridTable == null)
+            {
+                return;
+            }
+
+            if (gridState[GRIDSTATE_trackColResize])
+            {
+                ColResizeEnd(e);
+            }
+
+            if (gridState[GRIDSTATE_trackRowResize])
+            {
+                RowResizeEnd(e);
+            }
+
+            gridState[GRIDSTATE_trackColResize] = false;
+            gridState[GRIDSTATE_trackRowResize] = false;
+
+            HitTestInfo ci = HitTest(e.X, e.Y);
+            if ((ci.type & HitTestType.Caption) == HitTestType.Caption)
+            {
+                caption.MouseUp(e.X, e.Y);
+            }
+
+            // Check column headers
+            if (ci.type == HitTestType.ColumnHeader)
+            {
+                PropertyDescriptor prop = myGridTable.GridColumnStyles[ci.col].PropertyDescriptor;
+                if (prop == trackColumnHeader)
+                {
+                    ColumnHeaderClicked(trackColumnHeader);
+                }
+            }
+
+            trackColumnHeader = null;
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.MouseWheel'/> event.
+        /// </summary>
+        protected override void OnMouseWheel(MouseEventArgs e)
+        {
+            base.OnMouseWheel(e);
+
+            if (e is HandledMouseEventArgs)
+            {
+                if (((HandledMouseEventArgs)e).Handled)
+                {
+                    // The application event handler handled the scrolling - don't do anything more.
+                    return;
+                }
+
+                ((HandledMouseEventArgs)e).Handled = true;
+            }
+
+            bool wheelingDown = true;
+            if ((ModifierKeys & Keys.Control) != 0)
+            {
+                wheelingDown = false;
+            }
+
+            if (listManager == null || myGridTable == null)
+            {
+                return;
+            }
+
+            ScrollBar sb = wheelingDown ? vertScrollBar : horizScrollBar;
+            if (!sb.Visible)
+            {
+                return;
+            }
+
+            // so we scroll. we have to know this, cause otherwise we will call EndEdit
+            // and that would be wrong.
+            gridState[GRIDSTATE_isScrolling] = true;
+            wheelDelta += e.Delta;
+            float movePerc = (float)wheelDelta / (float)NativeMethods.WHEEL_DELTA;
+            int move = (int)((float)SystemInformation.MouseWheelScrollLines * movePerc);
+            if (move != 0)
+            {
+                wheelDelta = 0;
+                Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: OnMouseWheel move=" + move.ToString(CultureInfo.InvariantCulture));
+                if (wheelingDown)
+                {
+                    int newRow = firstVisibleRow - move;
+                    newRow = Math.Max(0, Math.Min(newRow, DataGridRowsLength - numTotallyVisibleRows));
+                    ScrollDown(newRow - firstVisibleRow);
+                }
+                else
+                {
+                    int newValue = horizScrollBar.Value + (move < 0 ? 1 : -1) * horizScrollBar.LargeChange;
+                    HorizontalOffset = newValue;
+                }
+            }
+
+            gridState[GRIDSTATE_isScrolling] = false;
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.Paint'/>
+        ///  event.
+        /// </summary>
+        protected override void OnPaint(PaintEventArgs pe)
+        {
+            try
+            {
+                CheckHierarchyState();
+
+                if (layout.dirty)
+                {
+                    ComputeLayout();
+                }
+
+                Graphics g = pe.Graphics;
+
+                Region clipRegion = g.Clip;
+                if (layout.CaptionVisible)
+                {
+                    caption.Paint(g, layout.Caption, isRightToLeft());
+                }
+
+                if (layout.ParentRowsVisible)
+                {
+                    Debug.WriteLineIf(CompModSwitches.DataGridParents.TraceVerbose, "DataGridParents: Painting ParentRows " + layout.ParentRows.ToString());
+                    g.FillRectangle(SystemBrushes.AppWorkspace, layout.ParentRows);
+                    parentRows.Paint(g, layout.ParentRows, isRightToLeft());
+                }
+
+                Rectangle gridRect = layout.Data;
+                if (layout.RowHeadersVisible)
+                {
+                    gridRect = Rectangle.Union(gridRect, layout.RowHeaders);
+                }
+
+                if (layout.ColumnHeadersVisible)
+                {
+                    gridRect = Rectangle.Union(gridRect, layout.ColumnHeaders);
+                }
+
+                g.SetClip(gridRect);
+                PaintGrid(g, gridRect);
+                g.Clip = clipRegion;
+                clipRegion.Dispose();
+                PaintBorder(g, layout.ClientRectangle);
+
+                g.FillRectangle(DefaultHeaderBackBrush, layout.ResizeBoxRect);
+
+                base.OnPaint(pe); // raise paint event
+            }
+            catch
+            {
+                // at runtime we will rethrow the exception
+                if (Site == null || !Site.DesignMode)
+                {
+                    throw;
+                }
+
+                gridState[GRIDSTATE_exceptionInPaint] = true;
+                try
+                {
+                    RTLAwareMessageBox.Show(null, SR.DataGridExceptionInPaint, null, MessageBoxButtons.OK,
+                        MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
+
+                    if (Visible)
+                    {
+                        BeginUpdateInternal();
+                    }
+
+                    ResetParentRows();
+
+                    Set_ListManager(null, string.Empty, true);
+                }
+                finally
+                {
+                    gridState[GRIDSTATE_exceptionInPaint] = false;
+                    if (Visible)
+                    {
+                        EndUpdateInternal();
+                    }
+                }
+            }
+        }
+
+        // Since Win32 only invalidates the area that gets uncovered,
+        // we have to manually invalidate the old border area
+        /// <summary>
+        ///  Raises the <see cref='Control.Resize'/> event.
+        /// </summary>
+        protected override void OnResize(EventArgs e)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: OnResize");
+
+            if (layout.CaptionVisible)
+            {
+                Invalidate(layout.Caption);
+            }
+
+            if (layout.ParentRowsVisible)
+            {
+                parentRows.OnResize(layout.ParentRows);
+            }
+
+            int borderWidth = BorderWidth;
+            Rectangle right;
+            Rectangle bottom;
+            Rectangle oldClientRectangle = layout.ClientRectangle;
+
+            right = new Rectangle(oldClientRectangle.X + oldClientRectangle.Width - borderWidth,
+                                  oldClientRectangle.Y,
+                                  borderWidth,
+                                  oldClientRectangle.Height);
+            bottom = new Rectangle(oldClientRectangle.X,
+                                   oldClientRectangle.Y + oldClientRectangle.Height - borderWidth,
+                                   oldClientRectangle.Width,
+                                   borderWidth);
+
+            Rectangle newClientRectangle = ClientRectangle;
+            if (newClientRectangle.Width != oldClientRectangle.Width)
+            {
+                Invalidate(right);
+                right = new Rectangle(newClientRectangle.X + newClientRectangle.Width - borderWidth,
+                                      newClientRectangle.Y,
+                                      borderWidth,
+                                      newClientRectangle.Height);
+                Invalidate(right);
+            }
+
+            if (newClientRectangle.Height != oldClientRectangle.Height)
+            {
+                Invalidate(bottom);
+                bottom = new Rectangle(newClientRectangle.X,
+                                       newClientRectangle.Y + newClientRectangle.Height - borderWidth,
+                                       newClientRectangle.Width,
+                                       borderWidth);
+                Invalidate(bottom);
+            }
+
+            //also, invalidate the ResizeBoxRect
+            if (!layout.ResizeBoxRect.IsEmpty)
+            {
+                Invalidate(layout.ResizeBoxRect);
+            }
+
+            layout.ClientRectangle = newClientRectangle;
+
+            int oldFirstVisibleRow = firstVisibleRow;
+            base.OnResize(e);
+            if (isRightToLeft() || oldFirstVisibleRow != firstVisibleRow)
+            {
+                Invalidate();
+            }
+        }
+
+        internal void OnRowHeightChanged(DataGridRow row)
+        {
+            ClearRegionCache();
+            int cy = GetRowTop(row.RowNumber);
+            if (cy > 0)
+            {
+                Rectangle refresh = new Rectangle
+                {
+                    Y = cy,
+                    X = layout.Inside.X,
+                    Width = layout.Inside.Width,
+                    Height = layout.Inside.Bottom - cy
+                };
+                Invalidate(refresh);
+            }
+        }
+
+        internal void ParentRowsDataChanged()
+        {
+            Debug.Assert(originalState != null, "how can we get a list changed event from another listmanager/list while not navigating");
+
+            // do the reset work that is done in SetDataBindings, set_DataSource, set_DataMember;
+            parentRows.Clear();
+            caption.BackButtonActive = caption.DownButtonActive = caption.BackButtonVisible = false;
+            caption.SetDownButtonDirection(!layout.ParentRowsVisible);
+            object dSource = originalState.DataSource;
+            string dMember = originalState.DataMember;
+            // we don't need to set the GRIDSTATE_metaDataChanged bit, cause
+            // the listManager from the originalState should be different from the current listManager
+            //
+            // set the originalState to null so that Set_ListManager knows that
+            // it has to unhook the MetaDataChanged events
+            originalState = null;
+            Set_ListManager(dSource, dMember, true);
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        private void AbortEdit()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: \t! AbortEdit");
+
+            // the same rules from editColumn.OnEdit
+            // while changing the editControl's visibility, do not
+            // PerformLayout on the entire DataGrid
+            gridState[GRIDSTATE_editControlChanging] = true;
+
+            editColumn.Abort(editRow.RowNumber);
+
+            // reset the editControl flag:
+            gridState[GRIDSTATE_editControlChanging] = false;
+
+            gridState[GRIDSTATE_isEditing] = false;
+            editRow = null;
+            editColumn = null;
+        }
+
+        /// <summary>
+        ///  Occurs when the user navigates to a new table.
+        /// </summary>
+        [SRCategory(nameof(SR.CatAction)), SRDescription(nameof(SR.DataGridNavigateEventDescr))]
+        public event NavigateEventHandler Navigate
+        {
+            add => onNavigate += value;
+            remove => onNavigate -= value;
+        }
+
+        /// <summary>
+        ///  Occurs when a row header is clicked.
+        /// </summary>
+        protected event EventHandler RowHeaderClick
+        {
+            add => onRowHeaderClick += value;
+            remove => onRowHeaderClick -= value;
+        }
+
+        /// <summary>
+        ///  Adds an event handler for the 'System.Windows.Forms.DataGrid.OnNodeClick'
+        ///  event.
+        /// </summary>
+        [SRCategory(nameof(SR.CatAction)), SRDescription(nameof(SR.DataGridNodeClickEventDescr))]
+        internal event EventHandler NodeClick
+        {
+            add => Events.AddHandler(EVENT_NODECLICKED, value);
+            remove => Events.RemoveHandler(EVENT_NODECLICKED, value);
+        }
+
+        /// <summary>
+        ///  Occurs when the user scrolls the <see cref='DataGrid'/> control.
+        /// </summary>
+        [SRCategory(nameof(SR.CatAction)), SRDescription(nameof(SR.DataGridScrollEventDescr))]
+        public event EventHandler Scroll
+        {
+            add => Events.AddHandler(EVENT_SCROLL, value);
+            remove => Events.RemoveHandler(EVENT_SCROLL, value);
+        }
+
+        public override ISite Site
+        {
+            get
+            {
+                return base.Site;
+            }
+            set
+            {
+                ISite temp = Site;
+                base.Site = value;
+                if (value != temp && !Disposing)
+                {
+                    // we should site the tables and the columns
+                    // only when our site changes
+                    SubObjectsSiteChange(false);
+                    SubObjectsSiteChange(true);
+                }
+            }
+        }
+
+        internal void AddNewRow()
+        {
+            EnsureBound();
+            ResetSelection();
+            // EndEdit();
+            UpdateListManager();
+            gridState[GRIDSTATE_inListAddNew] = true;
+            gridState[GRIDSTATE_inAddNewRow] = true;
+            try
+            {
+                ListManager.AddNew();
+            }
+            catch
+            {
+                gridState[GRIDSTATE_inListAddNew] = false;
+                gridState[GRIDSTATE_inAddNewRow] = false;
+                PerformLayout();
+                InvalidateInside();
+                throw;
+            }
+
+            gridState[GRIDSTATE_inListAddNew] = false;
+        }
+
+        /// <summary>
+        ///  Attempts to
+        ///  put the grid into a state where editing is
+        ///  allowed.
+        /// </summary>
+        public bool BeginEdit(DataGridColumnStyle gridColumn, int rowNumber)
+        {
+            if (DataSource == null || myGridTable == null)
+            {
+                return false;
+            }
+
+            // We deny edit requests if we are already editing a cell.
+            if (gridState[GRIDSTATE_isEditing])
+            {
+                return false;
+            }
+            else
+            {
+                int col = -1;
+                if ((col = myGridTable.GridColumnStyles.IndexOf(gridColumn)) < 0)
+                {
+                    return false;
+                }
+
+                CurrentCell = new DataGridCell(rowNumber, col);
+                ResetSelection();
+                Edit();
+                return true;
+            }
+        }
+
+        /// <summary>
+        ///  Specifies the beginning of the initialization code.
+        /// </summary>
+        public void BeginInit()
+        {
+            if (inInit)
+            {
+                throw new InvalidOperationException(SR.DataGridBeginInit);
+            }
+
+            inInit = true;
+        }
+
+        private Rectangle CalcRowResizeFeedbackRect(MouseEventArgs e)
+        {
+            Rectangle inside = layout.Data;
+            Rectangle r = new Rectangle(inside.X, e.Y, inside.Width, 3);
+            r.Y = Math.Min(inside.Bottom - 3, r.Y);
+            r.Y = Math.Max(r.Y, 0);
+            return r;
+        }
+
+        private Rectangle CalcColResizeFeedbackRect(MouseEventArgs e)
+        {
+            Rectangle inside = layout.Data;
+            Rectangle r = new Rectangle(e.X, inside.Y, 3, inside.Height);
+            r.X = Math.Min(inside.Right - 3, r.X);
+            r.X = Math.Max(r.X, 0);
+            return r;
+        }
+
+        private void CancelCursorUpdate()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: Requesting CancelEdit()");
+            if (listManager != null)
+            {
+                EndEdit();
+                listManager.CancelCurrentEdit();
+            }
+        }
+
+        private void CheckHierarchyState()
+        {
+            if (checkHierarchy && listManager != null && myGridTable != null)
+            {
+                if (myGridTable == null)
+                {
+                    // there was nothing to check
+                    return;
+                }
+
+                for (int j = 0; j < myGridTable.GridColumnStyles.Count; j++)
+                {
+                    DataGridColumnStyle gridColumn = myGridTable.GridColumnStyles[j];
+                }
+
+                checkHierarchy = false;
+            }
+        }
+
+        /// <summary>
+        ///  The DataGrid caches an array of rectangular areas
+        ///  which represent the area which scrolls left to right.
+        ///  This method is invoked whenever the DataGrid's
+        ///  scrollable regions change in such a way as to require
+        ///  a re-recalculation.
+        /// </summary>
+        private void ClearRegionCache()
+        {
+            cachedScrollableRegion = null;
+        }
+
+        /// <summary>
+        ///  Determines the best fit size for the given column.
+        /// </summary>
+        private void ColAutoResize(int col)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ColAutoResize");
+            EndEdit();
+            CurrencyManager listManager = this.listManager;
+            if (listManager == null)
+            {
+                return;
+            }
+
+            int size;
+            Graphics g = CreateGraphicsInternal();
+            try
+            {
+                DataGridColumnStyle column = myGridTable.GridColumnStyles[col];
+                string columnName = column.HeaderText;
+
+                Font headerFont;
+                if (myGridTable.IsDefault)
+                {
+                    headerFont = HeaderFont;
+                }
+                else
+                {
+                    headerFont = myGridTable.HeaderFont;
+                }
+
+                size = (int)g.MeasureString(columnName, headerFont).Width + layout.ColumnHeaders.Height + 1; // The sort triangle's width is equal to it's height
+                int rowCount = listManager.Count;
+                for (int row = 0; row < rowCount; ++row)
+                {
+                    object value = column.GetColumnValueAtRow(listManager, row);
+                    int width = column.GetPreferredSize(g, value).Width;
+                    if (width > size)
+                    {
+                        size = width;
+                    }
+                }
+
+                if (column.Width != size)
+                {
+                    column._width = size;
+
+                    ComputeVisibleColumns();
+
+                    bool lastColumnIsLastTotallyVisibleCol = true;
+                    if (lastTotallyVisibleCol != -1)
+                    {
+                        for (int i = lastTotallyVisibleCol + 1; i < myGridTable.GridColumnStyles.Count; i++)
+                        {
+                            if (myGridTable.GridColumnStyles[i].PropertyDescriptor != null)
+                            {
+                                lastColumnIsLastTotallyVisibleCol = false;
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        lastColumnIsLastTotallyVisibleCol = false;
+                    }
+
+                    // if the column shrank and the last totally visible column was the last column
+                    // then we need to recompute the horizontalOffset, firstVisibleCol, negOffset.
+                    // lastTotallyVisibleCol remains the last column
+                    if (lastColumnIsLastTotallyVisibleCol &&
+                        (negOffset != 0 || horizontalOffset != 0))
+                    {
+                        // update the column width
+                        column._width = size;
+
+                        int cx = 0;
+                        int colCount = myGridTable.GridColumnStyles.Count;
+                        int visibleWidth = layout.Data.Width;
+                        GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+
+                        // assume everything fits
+                        negOffset = 0;
+                        horizontalOffset = 0;
+                        firstVisibleCol = 0;
+
+                        for (int i = colCount - 1; i >= 0; i--)
+                        {
+                            if (cols[i].PropertyDescriptor == null)
+                            {
+                                continue;
+                            }
+
+                            cx += cols[i].Width;
+                            if (cx > visibleWidth)
+                            {
+                                if (negOffset == 0)
+                                {
+                                    firstVisibleCol = i;
+                                    negOffset = cx - visibleWidth;
+                                    horizontalOffset = negOffset;
+                                    numVisibleCols++;
+                                }
+                                else
+                                {
+                                    horizontalOffset += cols[i].Width;
+                                }
+                            }
+                            else
+                            {
+                                numVisibleCols++;
+                            }
+                        }
+
+                        // refresh the horizontal scrollbar
+                        PerformLayout();
+
+                        // we need to invalidate the layout.Data and layout.ColumnHeaders
+                        Invalidate(Rectangle.Union(layout.Data, layout.ColumnHeaders));
+                    }
+                    else
+                    {
+                        // need to refresh the scroll bar
+                        PerformLayout();
+
+                        Rectangle rightArea = layout.Data;
+                        if (layout.ColumnHeadersVisible)
+                        {
+                            rightArea = Rectangle.Union(rightArea, layout.ColumnHeaders);
+                        }
+
+                        int left = GetColBeg(col);
+
+                        if (!isRightToLeft())
+                        {
+                            rightArea.Width -= left - rightArea.X;
+                            rightArea.X = left;
+                        }
+                        else
+                        {
+                            rightArea.Width -= left;
+                        }
+
+                        Invalidate(rightArea);
+                    }
+                }
+            }
+            finally
+            {
+                g.Dispose();
+            }
+
+            if (horizScrollBar.Visible)
+            {
+                horizScrollBar.Value = HorizontalOffset;
+            }
+
+            // OnColumnResize(EventArgs.Empty);
+        }
+
+        /// <summary>
+        ///  Collapses child relations, if any exist for all rows, or for a
+        ///  specified row.
+        /// </summary>
+        public void Collapse(int row)
+        {
+            SetRowExpansionState(row, false);
+        }
+
+        private void ColResizeBegin(MouseEventArgs e, int col)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ColResizeBegin");
+            Debug.Assert(myGridTable != null, "Column resizing operations can't be called when myGridTable == null.");
+
+            int x = e.X;
+            EndEdit();
+            Rectangle clip = Rectangle.Union(layout.ColumnHeaders, layout.Data);
+            if (isRightToLeft())
+            {
+                clip.Width = GetColBeg(col) - layout.Data.X - 2;
+            }
+            else
+            {
+                int leftEdge = GetColBeg(col);
+                clip.X = leftEdge + 3;
+                clip.Width = layout.Data.X + layout.Data.Width - leftEdge - 2;
+            }
+
+            Capture = true;
+            Cursor.Clip = RectangleToScreen(clip);
+            gridState[GRIDSTATE_trackColResize] = true;
+            trackColAnchor = x;
+            trackColumn = col;
+
+            DrawColSplitBar(e);
+            lastSplitBar = e;
+        }
+
+        private void ColResizeMove(MouseEventArgs e)
+        {
+            if (lastSplitBar != null)
+            {
+                DrawColSplitBar(lastSplitBar);
+                lastSplitBar = e;
+            }
+
+            DrawColSplitBar(e);
+        }
+
+        private void ColResizeEnd(MouseEventArgs e)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ColResizeEnd");
+            Debug.Assert(myGridTable != null, "Column resizing operations can't be called when myGridTable == null.");
+
+            gridState[GRIDSTATE_layoutSuspended] = true;
+            try
+            {
+                if (lastSplitBar != null)
+                {
+                    DrawColSplitBar(lastSplitBar);
+                    lastSplitBar = null;
+                }
+
+                bool rightToLeft = isRightToLeft();
+
+                int x = rightToLeft ? Math.Max(e.X, layout.Data.X) : Math.Min(e.X, layout.Data.Right + 1);
+                int delta = x - GetColEnd(trackColumn);
+                if (rightToLeft)
+                {
+                    delta = -delta;
+                }
+
+                if (trackColAnchor != x && delta != 0)
+                {
+                    DataGridColumnStyle column = myGridTable.GridColumnStyles[trackColumn];
+                    int proposed = column.Width + delta;
+                    proposed = Math.Max(proposed, 3);
+                    column.Width = proposed;
+
+                    // refresh scrolling data: horizontalOffset, negOffset, firstVisibleCol, numVisibleCols, lastTotallyVisibleCol
+                    ComputeVisibleColumns();
+
+                    bool lastColumnIsLastTotallyVisibleCol = true;
+                    for (int i = lastTotallyVisibleCol + 1; i < myGridTable.GridColumnStyles.Count; i++)
+                    {
+                        if (myGridTable.GridColumnStyles[i].PropertyDescriptor != null)
+                        {
+                            lastColumnIsLastTotallyVisibleCol = false;
+                            break;
+                        }
+                    }
+
+                    if (lastColumnIsLastTotallyVisibleCol &&
+                        (negOffset != 0 || horizontalOffset != 0))
+                    {
+                        int cx = 0;
+                        int colCount = myGridTable.GridColumnStyles.Count;
+                        int visibleWidth = layout.Data.Width;
+                        GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+
+                        // assume everything fits
+                        negOffset = 0;
+                        horizontalOffset = 0;
+                        firstVisibleCol = 0;
+
+                        for (int i = colCount - 1; i > -1; i--)
+                        {
+                            if (cols[i].PropertyDescriptor == null)
+                            {
+                                continue;
+                            }
+
+                            cx += cols[i].Width;
+
+                            if (cx > visibleWidth)
+                            {
+                                if (negOffset == 0)
+                                {
+                                    negOffset = cx - visibleWidth;
+                                    firstVisibleCol = i;
+                                    horizontalOffset = negOffset;
+                                    numVisibleCols++;
+                                }
+                                else
+                                {
+                                    horizontalOffset += cols[i].Width;
+                                }
+                            }
+                            else
+                            {
+                                numVisibleCols++;
+                            }
+                        }
+
+                        // and invalidate pretty much everything
+                        Invalidate(Rectangle.Union(layout.Data, layout.ColumnHeaders));
+                    }
+                    else
+                    {
+                        Rectangle rightArea = Rectangle.Union(layout.ColumnHeaders, layout.Data);
+                        int left = GetColBeg(trackColumn);
+                        rightArea.Width -= rightToLeft ? rightArea.Right - left : left - rightArea.X;
+                        rightArea.X = rightToLeft ? layout.Data.X : left;
+                        Invalidate(rightArea);
+                    }
+                }
+            }
+            finally
+            {
+                Cursor.Clip = Rectangle.Empty;
+                Capture = false;
+                gridState[GRIDSTATE_layoutSuspended] = false;
+            }
+
+            PerformLayout();
+
+            if (horizScrollBar.Visible)
+            {
+                horizScrollBar.Value = HorizontalOffset;
+            }
+
+            // OnColumnResize(EventArgs.Empty);
+        }
+
+        private void MetaDataChanged()
+        {
+            // when we reset the Binding in the grid, we need to clear the parent rows.
+            // the same goes for all the caption UI: reset it when the datasource changes.
+            //
+            parentRows.Clear();
+            caption.BackButtonActive = caption.DownButtonActive = caption.BackButtonVisible = false;
+            caption.SetDownButtonDirection(!layout.ParentRowsVisible);
+
+            gridState[GRIDSTATE_metaDataChanged] = true;
+            try
+            {
+                if (originalState != null)
+                {
+                    // set the originalState to null so that Set_ListManager knows that
+                    // it has to unhook the MetaDataChanged events
+                    Set_ListManager(originalState.DataSource, originalState.DataMember, true);
+                    originalState = null;
+                }
+                else
+                {
+                    Set_ListManager(DataSource, DataMember, true);
+                }
+            }
+            finally
+            {
+                gridState[GRIDSTATE_metaDataChanged] = false;
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Functions to resize rows
+        // =------------------------------------------------------------------
+
+        // will autoResize "row"
+        private void RowAutoResize(int row)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: RowAutoResize");
+
+            EndEdit();
+            CurrencyManager listManager = ListManager;
+            if (listManager == null)
+            {
+                return;
+            }
+
+            Graphics g = CreateGraphicsInternal();
+            try
+            {
+                GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+                DataGridRow resizeRow = DataGridRows[row];
+                int rowCount = listManager.Count;
+                int resizeHeight = 0;
+
+                // compute the height that we should resize to:
+                int columnsCount = columns.Count;
+                for (int col = 0; col < columnsCount; col++)
+                {
+                    object value = columns[col].GetColumnValueAtRow(listManager, row);
+                    resizeHeight = Math.Max(resizeHeight, columns[col].GetPreferredHeight(g, value));
+                }
+
+                if (resizeRow.Height != resizeHeight)
+                {
+                    resizeRow.Height = resizeHeight;
+
+                    // needed to refresh scrollbar properties
+                    PerformLayout();
+
+                    Rectangle rightArea = layout.Data;
+                    if (layout.RowHeadersVisible)
+                    {
+                        rightArea = Rectangle.Union(rightArea, layout.RowHeaders);
+                    }
+
+                    int top = GetRowTop(row);
+                    rightArea.Height -= rightArea.Y - top;
+                    rightArea.Y = top;
+                    Invalidate(rightArea);
+                }
+            }
+            finally
+            {
+                g.Dispose();
+            }
+
+            // OnRowResize(EventArgs.Empty);
+            return;
+        }
+
+        private void RowResizeBegin(MouseEventArgs e, int row)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: RowResizeBegin");
+            Debug.Assert(myGridTable != null, "Row resizing operations can't be called when myGridTable == null.");
+
+            int y = e.Y;
+            EndEdit();
+            Rectangle clip = Rectangle.Union(layout.RowHeaders, layout.Data);
+            int topEdge = GetRowTop(row);
+            clip.Y = topEdge + 3;
+            clip.Height = layout.Data.Y + layout.Data.Height - topEdge - 2;
+
+            Capture = true;
+            Cursor.Clip = RectangleToScreen(clip);
+            gridState[GRIDSTATE_trackRowResize] = true;
+            trackRowAnchor = y;
+            trackRow = row;
+
+            DrawRowSplitBar(e);
+            lastSplitBar = e;
+        }
+
+        private void RowResizeMove(MouseEventArgs e)
+        {
+            if (lastSplitBar != null)
+            {
+                DrawRowSplitBar(lastSplitBar);
+                lastSplitBar = e;
+            }
+
+            DrawRowSplitBar(e);
+        }
+
+        private void RowResizeEnd(MouseEventArgs e)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: RowResizeEnd");
+            Debug.Assert(myGridTable != null, "Row resizing operations can't be called when myGridTable == null.");
+
+            try
+            {
+                if (lastSplitBar != null)
+                {
+                    DrawRowSplitBar(lastSplitBar);
+                    lastSplitBar = null;
+                }
+
+                int y = Math.Min(e.Y, layout.Data.Y + layout.Data.Height + 1);
+                int delta = y - GetRowBottom(trackRow);
+                if (trackRowAnchor != y && delta != 0)
+                {
+                    DataGridRow row = DataGridRows[trackRow];
+                    int proposed = row.Height + delta;
+                    proposed = Math.Max(proposed, 3);
+                    row.Height = proposed;
+
+                    // needed to refresh scrollbar properties
+                    PerformLayout();
+
+                    Rectangle rightArea = Rectangle.Union(layout.RowHeaders, layout.Data);
+                    int top = GetRowTop(trackRow);
+                    rightArea.Height -= rightArea.Y - top;
+                    rightArea.Y = top;
+                    Invalidate(rightArea);
+                }
+            }
+            finally
+            {
+                Cursor.Clip = Rectangle.Empty;
+                Capture = false;
+            }
+
+            // OnRowResize(EventArgs.Empty);
+        }
+
+        /// <summary>
+        ///  Fires the ColumnHeaderClicked event and handles column
+        ///  sorting.
+        /// </summary>
+        private void ColumnHeaderClicked(PropertyDescriptor prop)
+        {
+            if (!CommitEdit())
+            {
+                return;
+            }
+
+            // OnColumnHeaderClick(EventArgs.Empty);
+            bool allowSorting;
+            if (myGridTable.IsDefault)
+            {
+                allowSorting = AllowSorting;
+            }
+            else
+            {
+                allowSorting = myGridTable.AllowSorting;
+            }
+
+            if (!allowSorting)
+            {
+                return;
+            }
+
+            // if (CompModSwitches.DataGridCursor.OutputVerbose) Debug.WriteLine("DataGridCursor: We are about to sort column " + col.ToString());
+            ListSortDirection direction = ListManager.GetSortDirection();
+            PropertyDescriptor sortColumn = ListManager.GetSortProperty();
+            if (sortColumn != null && sortColumn.Equals(prop))
+            {
+                direction = (direction == ListSortDirection.Ascending) ? ListSortDirection.Descending : ListSortDirection.Ascending;
+            }
+            else
+            {
+                // defaultSortDirection : ascending
+                direction = ListSortDirection.Ascending;
+            }
+
+            if (listManager.Count == 0)
+            {
+                return;
+            }
+
+            ListManager.SetSort(prop, direction);
+            ResetSelection();
+
+            InvalidateInside();
+        }
+
+        /// <summary>
+        ///  Attempts to commit editing if a cell is being edited.
+        ///  Return true if successfully commited editing.
+        ///  Return false if editing can not be completed and the gird must
+        ///  remain in our current Edit state.
+        /// </summary>
+        private bool CommitEdit()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: \t  CommitEdit " + (editRow == null ? "" : editRow.RowNumber.ToString(CultureInfo.InvariantCulture)));
+
+            // we want to commit the editing if
+            // 1. the user was editing or navigating around the data grid and
+            // 2. this is not the result of moving focus inside the data grid and
+            // 3. if the user was scrolling
+#pragma warning disable SA1408 // Conditional expressions should declare precedence
+            if (!gridState[GRIDSTATE_isEditing] && !gridState[GRIDSTATE_isNavigating] || (gridState[GRIDSTATE_editControlChanging] && !gridState[GRIDSTATE_isScrolling]))
+#pragma warning restore SA1408 // Conditional expressions should declare precedence
+            {
+                return true;
+            }
+
+            // the same rules from editColumn.OnEdit
+            // flag that we are editing the Edit control, so if we get a OnLayout on the
+            // datagrid side of things while the edit control changes its visibility and bounds
+            // the datagrid does not perform a layout
+            gridState[GRIDSTATE_editControlChanging] = true;
+
+            if ((editColumn != null && editColumn.ReadOnly) || gridState[GRIDSTATE_inAddNewRow])
+            {
+                bool focusTheGrid = false;
+                if (ContainsFocus)
+                {
+                    focusTheGrid = true;
+                }
+
+                if (focusTheGrid && gridState[GRIDSTATE_canFocus])
+                {
+                    Focus();
+                }
+
+                editColumn.ConcedeFocus();
+
+                // set the focus back to the grid
+                if (focusTheGrid && gridState[GRIDSTATE_canFocus] && CanFocus && !Focused)
+                {
+                    Focus();
+                }
+
+                // reset the editControl flag
+                gridState[GRIDSTATE_editControlChanging] = false;
+                return true;
+            }
+
+            bool retVal = editColumn?.Commit(ListManager, currentRow) ?? true;
+
+            // reset the editControl flag
+            gridState[GRIDSTATE_editControlChanging] = false;
+
+            if (retVal)
+            {
+                gridState[GRIDSTATE_isEditing] = false;
+            }
+
+            return retVal;
+        }
+
+        /// <summary>
+        ///  Figure out how many rows we need to scroll down
+        ///  to move targetRow into visibility.
+        /// </summary>
+        private int ComputeDeltaRows(int targetRow)
+        {
+            //Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: ComputeDeltaRows, firstVisibleRow = "
+            //                  + firstVisibleRow.ToString() + ", "
+            //                  + "targetRow = " + targetRow.ToString());
+
+            if (firstVisibleRow == targetRow)
+            {
+                return 0;
+            }
+
+            int dRows = 0;
+            int firstVisibleRowLogicalTop = -1;
+            int targetRowLogicalTop = -1;
+            int nRows = DataGridRowsLength;
+            int cy = 0;
+            DataGridRow[] localGridRows = DataGridRows;
+
+            for (int row = 0; row < nRows; ++row)
+            {
+                if (row == firstVisibleRow)
+                {
+                    firstVisibleRowLogicalTop = cy;
+                }
+
+                if (row == targetRow)
+                {
+                    targetRowLogicalTop = cy;
+                }
+
+                if (targetRowLogicalTop != -1 && firstVisibleRowLogicalTop != -1)
+                {
+                    break;
+                }
+
+                cy += localGridRows[row].Height;
+            }
+
+            int targetRowLogicalBottom = targetRowLogicalTop + localGridRows[targetRow].Height;
+            int dataLogicalBottom = layout.Data.Height + firstVisibleRowLogicalTop;
+            if (targetRowLogicalBottom > dataLogicalBottom)
+            {
+                // we need to move down.
+                int downDelta = targetRowLogicalBottom - dataLogicalBottom;
+                firstVisibleRowLogicalTop += downDelta;
+            }
+            else if (firstVisibleRowLogicalTop < targetRowLogicalTop)
+            {
+                // we don't need to move
+                return 0;
+            }
+            else
+            {
+                // we need to move up.
+                int upDelta = firstVisibleRowLogicalTop - targetRowLogicalTop;
+                firstVisibleRowLogicalTop -= upDelta;
+            }
+
+            int newFirstRow = ComputeFirstVisibleRow(firstVisibleRowLogicalTop);
+            dRows = (newFirstRow - firstVisibleRow);
+            //Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: ComputeDeltaRows returning " + dRows.ToString());
+            return dRows;
+        }
+
+        /// <summary>
+        ///  Given the a logical vertical offset, figure out
+        ///  which row number should be the first fully visible
+        ///  row on or after the offset.
+        /// </summary>
+        private int ComputeFirstVisibleRow(int firstVisibleRowLogicalTop)
+        {
+            int first;
+            int nRows = DataGridRowsLength;
+            int cy = 0;
+            DataGridRow[] localGridRows = DataGridRows;
+            for (first = 0; first < nRows; ++first)
+            {
+                if (cy >= firstVisibleRowLogicalTop)
+                {
+                    break;
+                }
+
+                cy += localGridRows[first].Height;
+            }
+
+            return first;
+        }
+
+        /// <summary>
+        ///  Constructs an updated Layout object.
+        /// </summary>
+        private void ComputeLayout()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ComputeLayout");
+
+            bool alignLeft = !isRightToLeft();
+            Rectangle oldResizeRect = layout.ResizeBoxRect;
+
+            // hide the EditBox
+            EndEdit();
+
+            ClearRegionCache();
+
+            // NOTE : Since Rectangles are structs, then assignment is a
+            //      : copy. Therefore, after saying "Rectangle inside = newLayout.Inside",
+            //      : we must always assign back to newLayout.Inside.
+            //
+
+            // Important since all of the visibility flags will move
+            // to the new layout here.
+            LayoutData newLayout = new LayoutData(layout)
+            {
+                // Inside
+                Inside = ClientRectangle
+            };
+            Rectangle inside = newLayout.Inside;
+            int borderWidth = BorderWidth;
+            inside.Inflate(-borderWidth, -borderWidth);
+
+            Rectangle insideLeft = inside;
+
+            // Caption
+            if (layout.CaptionVisible)
+            {
+                int captionHeight = captionFontHeight + 6;
+                Rectangle cap = newLayout.Caption;
+                cap = insideLeft;
+                cap.Height = captionHeight;
+                insideLeft.Y += captionHeight;
+                insideLeft.Height -= captionHeight;
+
+                newLayout.Caption = cap;
+            }
+            else
+            {
+                newLayout.Caption = Rectangle.Empty;
+            }
+
+            // Parent Rows
+            if (layout.ParentRowsVisible)
+            {
+                Rectangle parents = newLayout.ParentRows;
+                int parentHeight = parentRows.Height;
+                parents = insideLeft;
+                parents.Height = parentHeight;
+                insideLeft.Y += parentHeight;
+                insideLeft.Height -= parentHeight;
+
+                newLayout.ParentRows = parents;
+            }
+            else
+            {
+                newLayout.ParentRows = Rectangle.Empty;
+            }
+
+            // Headers
+            //
+            int columnHeaderHeight = headerFontHeight + 6;
+            if (layout.ColumnHeadersVisible)
+            {
+                Rectangle colHeaders = newLayout.ColumnHeaders;
+                colHeaders = insideLeft;
+                colHeaders.Height = columnHeaderHeight;
+                insideLeft.Y += columnHeaderHeight;
+                insideLeft.Height -= columnHeaderHeight;
+
+                newLayout.ColumnHeaders = colHeaders;
+            }
+            else
+            {
+                newLayout.ColumnHeaders = Rectangle.Empty;
+            }
+
+            bool newRowHeadersVisible = myGridTable.IsDefault ? RowHeadersVisible : myGridTable.RowHeadersVisible;
+            int newRowHeaderWidth = myGridTable.IsDefault ? RowHeaderWidth : myGridTable.RowHeaderWidth;
+            newLayout.RowHeadersVisible = newRowHeadersVisible;
+            if (myGridTable != null && newRowHeadersVisible)
+            {
+                Rectangle rowHeaders = newLayout.RowHeaders;
+                if (alignLeft)
+                {
+                    rowHeaders = insideLeft;
+                    rowHeaders.Width = newRowHeaderWidth;
+                    insideLeft.X += newRowHeaderWidth;
+                    insideLeft.Width -= newRowHeaderWidth;
+                }
+                else
+                {
+                    rowHeaders = insideLeft;
+                    rowHeaders.Width = newRowHeaderWidth;
+                    rowHeaders.X = insideLeft.Right - newRowHeaderWidth;
+                    insideLeft.Width -= newRowHeaderWidth;
+                }
+
+                newLayout.RowHeaders = rowHeaders;
+
+                if (layout.ColumnHeadersVisible)
+                {
+                    Rectangle topLeft = newLayout.TopLeftHeader;
+                    Rectangle colHeaders = newLayout.ColumnHeaders;
+                    if (alignLeft)
+                    {
+                        topLeft = colHeaders;
+                        topLeft.Width = newRowHeaderWidth;
+                        colHeaders.Width -= newRowHeaderWidth;
+                        colHeaders.X += newRowHeaderWidth;
+                    }
+                    else
+                    {
+                        topLeft = colHeaders;
+                        topLeft.Width = newRowHeaderWidth;
+                        topLeft.X = colHeaders.Right - newRowHeaderWidth;
+                        colHeaders.Width -= newRowHeaderWidth;
+                    }
+
+                    newLayout.TopLeftHeader = topLeft;
+                    newLayout.ColumnHeaders = colHeaders;
+                }
+                else
+                {
+                    newLayout.TopLeftHeader = Rectangle.Empty;
+                }
+            }
+            else
+            {
+                newLayout.RowHeaders = Rectangle.Empty;
+                newLayout.TopLeftHeader = Rectangle.Empty;
+            }
+
+            // The Data region
+            newLayout.Data = insideLeft;
+            newLayout.Inside = inside;
+
+            layout = newLayout;
+
+            LayoutScrollBars();
+
+            // if the user shrank the grid client area, then OnResize invalidated the old
+            // resize area. however, we need to invalidate the left upper corner in the new ResizeArea
+            // note that we can't take the Invalidate call from the OnResize method, because if the
+            // user enlarges the form then the old area will not be invalidated.
+            //
+            if (!oldResizeRect.Equals(layout.ResizeBoxRect) && !layout.ResizeBoxRect.IsEmpty)
+            {
+                Invalidate(layout.ResizeBoxRect);
+            }
+
+            layout.dirty = false;
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: " + layout.ToString());
+        }
+
+        /// <summary>
+        ///  Computes the number of pixels to scroll to scroll from one
+        ///  row to another.
+        /// </summary>
+        private int ComputeRowDelta(int from, int to)
+        {
+            int first = from;
+            int last = to;
+            int sign = -1;
+            if (first > last)
+            {
+                first = to;
+                last = from;
+                sign = 1;
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+            int delta = 0;
+            for (int row = first; row < last; ++row)
+            {
+                delta += localGridRows[row].Height;
+            }
+
+            return sign * delta;
+        }
+
+        internal int MinimumRowHeaderWidth()
+        {
+            return minRowHeaderWidth;
+        }
+
+        internal void ComputeMinimumRowHeaderWidth()
+        {
+            minRowHeaderWidth = errorRowBitmapWidth; // the size of the pencil, star and row selector images are the same as the image for the error bitmap
+            if (ListHasErrors)
+            {
+                minRowHeaderWidth += errorRowBitmapWidth;
+            }
+
+            if (myGridTable != null && myGridTable.RelationsList.Count != 0)
+            {
+                minRowHeaderWidth += 15; // the size of the plus/minus glyph and spacing around it
+            }
+        }
+
+        /// <summary>
+        ///  Updates the internal variables with the number of columns visible
+        ///  inside the Grid's client rectangle.
+        /// </summary>
+        private void ComputeVisibleColumns()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ComputeVisibleColumns");
+            EnsureBound();
+
+            GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+
+            int nGridCols = columns.Count;
+            int cx = -negOffset;
+            int visibleColumns = 0;
+            int visibleWidth = layout.Data.Width;
+            int curCol = firstVisibleCol;
+
+            // the same problem with negative numbers:
+            // if the width passed in is negative, then return 0
+            //
+            // added the check for the columns.Count == 0
+            //
+            if (visibleWidth < 0 || columns.Count == 0)
+            {
+                numVisibleCols = firstVisibleCol = 0;
+                lastTotallyVisibleCol = -1;
+                return;
+            }
+
+            while (cx < visibleWidth && curCol < nGridCols)
+            {
+                // if (columns.Visible && columns.PropertyDescriptor != null)
+                if (columns[curCol].PropertyDescriptor != null)
+                {
+                    cx += columns[curCol].Width;
+                }
+
+                curCol++;
+                visibleColumns++;
+            }
+
+            numVisibleCols = visibleColumns;
+
+            // if we inflate the data area
+            // then we paint columns to the left of firstVisibleColumn
+            if (cx < visibleWidth)
+            {
+                for (int i = firstVisibleCol - 1; i > 0; i--)
+                {
+                    if (cx + columns[i].Width > visibleWidth)
+                    {
+                        break;
+                    }
+
+                    // if (columns.Visible && columns.PropertyDescriptor != null)
+                    if (columns[i].PropertyDescriptor != null)
+                    {
+                        cx += columns[i].Width;
+                    }
+
+                    visibleColumns++;
+                    firstVisibleCol--;
+                }
+
+                if (numVisibleCols != visibleColumns)
+                {
+                    Debug.Assert(numVisibleCols < visibleColumns, "the number of visible columns can only grow");
+                    // is there space for more columns than were visible?
+                    // if so, then we need to repaint Data and ColumnHeaders
+                    Invalidate(layout.Data);
+                    Invalidate(layout.ColumnHeaders);
+
+                    // update the number of visible columns to the new reality
+                    numVisibleCols = visibleColumns;
+                }
+            }
+
+            lastTotallyVisibleCol = firstVisibleCol + numVisibleCols - 1;
+            if (cx > visibleWidth)
+            {
+                if (numVisibleCols <= 1 || (numVisibleCols == 2 && negOffset != 0))
+                {
+                    // no column is entirely visible
+                    lastTotallyVisibleCol = -1;
+                }
+                else
+                {
+                    lastTotallyVisibleCol--;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Determines which column is the first visible given
+        ///  the object's horizontalOffset.
+        /// </summary>
+        private int ComputeFirstVisibleColumn()
+        {
+            int first = 0;
+            if (horizontalOffset == 0)
+            {
+                negOffset = 0;
+                return 0;
+            }
+
+            // we will check to see if myGridTables.GridColumns.Count != 0
+            // because when we reset the dataGridTable, we don't have any columns, and we still
+            // call HorizontalOffset = 0, and that will call ComputeFirstVisibleColumn with an empty collection of columns.
+            if (myGridTable != null && myGridTable.GridColumnStyles != null && myGridTable.GridColumnStyles.Count != 0)
+            {
+                GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+                int cx = 0;
+                int nGridCols = columns.Count;
+
+                if (columns[0].Width == -1)
+                {
+                    // the columns are not initialized yet
+                    //
+#if DEBUG
+                    for (int i = 0; i < nGridCols; i++)
+                    {
+                        Debug.Assert(columns[i].Width == -1, "the columns' widths should not be initialized");
+                    }
+#endif // DEBUG
+                    negOffset = 0;
+                    return 0;
+                }
+
+                for (first = 0; first < nGridCols; first++)
+                {
+                    // if (columns[first].Visible && columns[first].PropertyDescriptor != null);
+                    if (columns[first].PropertyDescriptor != null)
+                    {
+                        cx += columns[first].Width;
+                    }
+
+                    if (cx > horizontalOffset)
+                    {
+                        break;
+                    }
+                }
+
+                // first may actually be the number of columns
+                // in that case all the columns fit in the layout data
+                if (first == nGridCols)
+                {
+                    Debug.Assert(cx <= horizontalOffset, "look at the for loop before: we only exit that loop early if the cx is over the horizontal offset");
+                    negOffset = 0;
+                    return 0;
+                }
+
+                negOffset = columns[first].Width - (cx - horizontalOffset);
+                //Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: ComputeFirstVisibleColumn, ret = " + first.ToString() + ", negOffset = " + negOffset.ToString());
+            }
+
+            return first;
+        }
+
+        /// <summary>
+        ///  Updates the internal variables with the number of rows visible
+        ///  in a given DataGrid Layout.
+        /// </summary>
+        private void ComputeVisibleRows()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: ComputeVisibleRows");
+            EnsureBound();
+
+            Rectangle data = layout.Data;
+            int visibleHeight = data.Height;
+            int cy = 0;
+            int visibleRows = 0;
+            DataGridRow[] localGridRows = DataGridRows;
+            int numRows = DataGridRowsLength;
+
+            // when minimizing the dataGrid window, we will get negative values for the
+            // layout.Data.Width and layout.Data.Height ( is this a
+
+            if (visibleHeight < 0)
+            {
+                numVisibleRows = numTotallyVisibleRows = 0;
+                return;
+            }
+
+            for (int i = firstVisibleRow; i < numRows; ++i)
+            {
+                if (cy > visibleHeight)
+                {
+                    break;
+                }
+
+                cy += localGridRows[i].Height;
+                visibleRows++;
+            }
+
+            if (cy < visibleHeight)
+            {
+                for (int i = firstVisibleRow - 1; i >= 0; i--)
+                {
+                    int height = localGridRows[i].Height;
+                    if (cy + height > visibleHeight)
+                    {
+                        break;
+                    }
+
+                    cy += height;
+                    firstVisibleRow--;
+                    visibleRows++;
+                }
+            }
+
+            numVisibleRows = numTotallyVisibleRows = visibleRows;
+            if (cy > visibleHeight)
+            {
+                numTotallyVisibleRows--;
+            }
+
+            Debug.Assert(numVisibleRows >= 0, "the number of visible rows can't be negative");
+            Debug.Assert(numTotallyVisibleRows >= 0, "the number of totally visible rows can't be negative");
+        }
+
+        /// <summary>
+        ///  Constructs the new instance of the accessibility object for this control. Subclasses
+        ///  should not call base.CreateAccessibilityObject.
+        /// </summary>
+        protected override AccessibleObject CreateAccessibilityInstance()
+        {
+            return new DataGridAccessibleObject(this);
+        }
+
+        /// <summary>
+        ///  Creates a DataGridState representing the child table retrieved
+        ///  from the passed DataRelation.
+        /// </summary>
+        private DataGridState CreateChildState(string relationName, DataGridRow source)
+        {
+            DataGridState dgs = new DataGridState();
+
+            string newDataMember;
+            if (string.IsNullOrEmpty(DataMember))
+            {
+                newDataMember = relationName;
+            }
+            else
+            {
+                newDataMember = DataMember + "." + relationName;
+            }
+
+            CurrencyManager childLM = (CurrencyManager)BindingContext[DataSource, newDataMember];
+
+            dgs.DataSource = DataSource;
+            dgs.DataMember = newDataMember;
+            dgs.ListManager = childLM;
+
+            dgs.DataGridRows = null;
+            dgs.DataGridRowsLength = childLM.Count + (policy.AllowAdd ? 1 : 0);
+
+            return dgs;
+        }
+
+        /// <summary>
+        ///  Constructs a Layout object containing the state
+        ///  for a newly constructed DataGrid.
+        /// </summary>
+        private LayoutData CreateInitialLayoutState()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridLayout.TraceVerbose, "DataGridLayout: CreateInitialLayoutState");
+            LayoutData newLayout = new LayoutData
+            {
+                Inside = new Rectangle(),
+                TopLeftHeader = new Rectangle(),
+                ColumnHeaders = new Rectangle(),
+                RowHeaders = new Rectangle(),
+                Data = new Rectangle(),
+                Caption = new Rectangle(),
+                ParentRows = new Rectangle(),
+                ResizeBoxRect = new Rectangle(),
+                ColumnHeadersVisible = true,
+                RowHeadersVisible = true,
+                CaptionVisible = defaultCaptionVisible,
+                ParentRowsVisible = defaultParentRowsVisible,
+                ClientRectangle = ClientRectangle
+            };
+            return newLayout;
+        }
+
+        /// <summary>
+        ///  The DataGrid caches an array of rectangular areas
+        ///  which represent the area which scrolls left to right.
+        ///  This method is invoked whenever the DataGrid needs
+        ///  this scrollable region.
+        /// </summary>
+        private RECT[] CreateScrollableRegion(Rectangle scroll)
+        {
+            if (cachedScrollableRegion != null)
+            {
+                return cachedScrollableRegion;
+            }
+
+            bool alignToRight = isRightToLeft();
+
+            using (Region region = new Region(scroll))
+            {
+                int nRows = numVisibleRows;
+                int cy = layout.Data.Y;
+                int cx = layout.Data.X;
+                DataGridRow[] localGridRows = DataGridRows;
+                for (int r = firstVisibleRow; r < nRows; r++)
+                {
+                    int rowHeight = localGridRows[r].Height;
+                    Rectangle rowExclude = localGridRows[r].GetNonScrollableArea();
+                    rowExclude.X += cx;
+                    rowExclude.X = MirrorRectangle(rowExclude, layout.Data, alignToRight);
+                    if (!rowExclude.IsEmpty)
+                    {
+                        region.Exclude(new Rectangle(rowExclude.X,
+                                                     rowExclude.Y + cy,
+                                                     rowExclude.Width,
+                                                     rowExclude.Height));
+                    }
+
+                    cy += rowHeight;
+                }
+
+                using (Graphics graphics = CreateGraphicsInternal())
+                {
+                    Gdi32.HRGN hrgn = default;
+                    hrgn = (Gdi32.HRGN)region.GetHrgn(graphics);
+
+                    if (!hrgn.IsNull)
+                    {
+                        cachedScrollableRegion = hrgn.GetRegionRects();
+                        region.ReleaseHrgn((IntPtr)hrgn);
+                    }
+                }
+            }
+
+            return cachedScrollableRegion;
+        }
+
+        /// <summary>
+        ///  Disposes of the resources (other than memory) used
+        ///  by the <see cref='DataGrid'/>.
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (vertScrollBar != null)
+                {
+                    vertScrollBar.Dispose();
+                }
+
+                if (horizScrollBar != null)
+                {
+                    horizScrollBar.Dispose();
+                }
+
+                if (toBeDisposedEditingControl != null)
+                {
+                    toBeDisposedEditingControl.Dispose();
+                    toBeDisposedEditingControl = null;
+                }
+
+                GridTableStylesCollection tables = TableStyles;
+                if (tables != null)
+                {
+#if DEBUG
+                    Debug.Assert(myGridTable == null || myGridTable.IsDefault || tables.Contains(myGridTable), "how come that the currentTable is not in the list of tables?");
+#endif // DEBUG
+                    for (int i = 0; i < tables.Count; i++)
+                    {
+                        tables[i].Dispose();
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Draws an XOR region to give UI feedback for Column Resizing.
+        ///  This looks just like the Splitter control's UI when resizing.
+        /// </summary>
+        private void DrawColSplitBar(MouseEventArgs e)
+        {
+            Rectangle r = CalcColResizeFeedbackRect(e);
+            DrawSplitBar(r);
+        }
+
+        /// <summary>
+        ///  Draws an XOR region to give UI feedback for Row Resizing.
+        ///  This looks just like the Splitter control's UI when resizing.
+        /// </summary>
+        private void DrawRowSplitBar(MouseEventArgs e)
+        {
+            Rectangle r = CalcRowResizeFeedbackRect(e);
+            DrawSplitBar(r);
+        }
+
+        /// <summary>
+        ///  Draws an XOR region to give UI feedback for Column/Row Resizing.
+        ///  This looks just like the Splitter control's UI when resizing.
+        /// </summary>
+        private void DrawSplitBar(Rectangle r)
+        {
+            Gdi32.HDC dc = User32.GetDCEx(this, IntPtr.Zero, User32.DCX.CACHE | User32.DCX.LOCKWINDOWUPDATE);
+            Gdi32.HBRUSH halftone = ControlPaint.CreateHalftoneHBRUSH2();
+            Gdi32.HGDIOBJ saveBrush = Gdi32.SelectObject(dc, halftone);
+            Gdi32.PatBlt(dc, r.X, r.Y, r.Width, r.Height, Gdi32.ROP.PATINVERT);
+            Gdi32.SelectObject(dc, saveBrush);
+            Gdi32.DeleteObject(halftone);
+            User32.ReleaseDC(new HandleRef(this, Handle), dc);
+        }
+
+        /// <summary>
+        ///  Begin in-place editing of a cell.  Any editing is commited
+        ///  before the new edit takes place.
+        ///
+        ///  This will always edit the currentCell
+        ///  If you want to edit another cell than the current one, just reset CurrentCell
+        /// </summary>
+        private void Edit()
+        {
+            Edit(null);
+        }
+
+        private void Edit(string displayText)
+        {
+            EnsureBound();
+
+            // we want to be able to edit a cell which is not visible, as in the case with editing and scrolling
+            // at the same time. So do not call Ensure Visible
+            //
+            // EnsureVisible(currentRow, currentCol);
+
+            bool cellIsVisible = true;
+
+            // whoever needs to call ResetSelection should not rely on
+            // Edit() to call it;
+            //
+            // ResetSelection();
+
+            EndEdit();
+
+            Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: Edit, currentRow = " + currentRow.ToString(CultureInfo.InvariantCulture) +
+                                                                           ", currentCol = " + currentCol.ToString(CultureInfo.InvariantCulture) + (displayText != null ? ", displayText= " + displayText : ""));
+
+            /* allow navigation even if the policy does not allow editing
+            if (!policy.AllowEdit)
+                return;
+            */
+
+            DataGridRow[] localGridRows = DataGridRows;
+
+            // what do you want to edit when there are no rows?
+            if (DataGridRowsLength == 0)
+            {
+                return;
+            }
+
+            localGridRows[currentRow].OnEdit();
+            editRow = localGridRows[currentRow];
+
+            // if the list has no columns, then what good is an edit?
+            if (myGridTable.GridColumnStyles.Count == 0)
+            {
+                return;
+            }
+
+            // what if the currentCol does not have a propDesc?
+            editColumn = myGridTable.GridColumnStyles[currentCol];
+            if (editColumn.PropertyDescriptor == null)
+            {
+                return;
+            }
+
+            Rectangle cellBounds = Rectangle.Empty;
+            if (currentRow < firstVisibleRow || currentRow > firstVisibleRow + numVisibleRows ||
+                currentCol < firstVisibleCol || currentCol > firstVisibleCol + numVisibleCols - 1 ||
+                (currentCol == firstVisibleCol && negOffset != 0))
+            {
+                cellIsVisible = false;
+            }
+            else
+            {
+                cellBounds = GetCellBounds(currentRow, currentCol);
+            }
+
+            gridState[GRIDSTATE_isNavigating] = true;
+            gridState[GRIDSTATE_isEditing] = false;
+
+            // once we call editColumn.Edit on a DataGridTextBoxColumn
+            // the edit control will become visible, and its bounds will get set.
+            // both actions cause Edit.Parent.OnLayout
+            // so we flag this change, cause we don't want to PerformLayout on the entire DataGrid
+            // everytime the edit column gets edited
+            gridState[GRIDSTATE_editControlChanging] = true;
+
+            editColumn.Edit(ListManager,
+                              currentRow,
+                              cellBounds,
+                              myGridTable.ReadOnly || ReadOnly || !policy.AllowEdit,
+                              displayText,
+                              cellIsVisible);
+
+            // reset the editControlChanging to false
+            gridState[GRIDSTATE_editControlChanging] = false;
+        }
+
+        /// <summary>
+        ///  Requests an end to an edit operation taking place on the
+        ///  <see cref='DataGrid'/>
+        ///  control.
+        /// </summary>
+        public bool EndEdit(DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort)
+        {
+            bool ret = false;
+            if (gridState[GRIDSTATE_isEditing])
+            {
+                if (gridColumn != editColumn)
+                {
+                    Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: EndEdit requested on a column we are not editing.");
+                }
+
+                if (rowNumber != editRow.RowNumber)
+                {
+                    Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: EndEdit requested on a row we are not editing.");
+                }
+
+                if (shouldAbort)
+                {
+                    AbortEdit();
+                    ret = true;
+                }
+                else
+                {
+                    ret = CommitEdit();
+                }
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        ///  Ends any editing in progress by attempting to commit and then
+        ///  aborting if not possible.
+        /// </summary>
+        private void EndEdit()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridEditing.TraceVerbose, "DataGridEditing: EndEdit");
+
+            if (!gridState[GRIDSTATE_isEditing] && !gridState[GRIDSTATE_isNavigating])
+            {
+                return;
+            }
+
+            if (!CommitEdit())
+            {
+                AbortEdit();
+            }
+        }
+
+        // PERF: we attempt to create a ListManager for the DataSource/DateMember combination
+        // we do this in order to check for a valid DataMember
+        // if the check succeeds, then it means that we actully put the listManager in the BindingContext's
+        // list of BindingManagers. this is fine, cause if the check succeds, then Set_ListManager
+        // will be called, and this will get the listManager from the bindingManagerBase hashTable kept in the BindingContext
+        //
+        // this will work if the dataMember does not contain any dots ('.')
+        // if the dataMember contains dots, then it will be more complicated: maybe part of the binding path
+        // is valid w/ the new dataSource
+        // but we can leave w/ this, cause in the designer the dataMember will be only a column name. and the DataSource/DataMember
+        // properties are for use w/ the designer.
+        //
+        private void EnforceValidDataMember(object value)
+        {
+            Debug.Assert(value != null, "we should not have a null dataSource when we want to check for a valid dataMember");
+            if (DataMember == null || DataMember.Length == 0)
+            {
+                return;
+            }
+
+            if (BindingContext == null)
+            {
+                return;
+            }
+
+            //
+            try
+            {
+                BindingManagerBase bm = BindingContext[value, dataMember];
+            }
+            catch
+            {
+                dataMember = string.Empty;
+            }
+        }
+
+        // will be used by the columns to tell the grid that
+        // editing is taken place (ie, the grid is no longer in the
+        // editOrNavigateMode)
+        //
+        // also, tell the current row to lose child focus
+        //
+        internal protected virtual void ColumnStartedEditing(Rectangle bounds)
+        {
+            Debug.Assert(currentRow >= firstVisibleRow && currentRow <= firstVisibleRow + numVisibleRows, "how can one edit a row which is invisible?");
+            DataGridRow[] localGridRows = DataGridRows;
+
+            if (bounds.IsEmpty && editColumn is DataGridTextBoxColumn && currentRow != -1 && currentCol != -1)
+            {
+                // set the bounds on the control
+                // this will only work w/ our DataGridTexBox control
+                DataGridTextBoxColumn col = editColumn as DataGridTextBoxColumn;
+                Rectangle editBounds = GetCellBounds(currentRow, currentCol);
+
+                gridState[GRIDSTATE_editControlChanging] = true;
+                try
+                {
+                    col.TextBox.Bounds = editBounds;
+                }
+                finally
+                {
+                    gridState[GRIDSTATE_editControlChanging] = false;
+                }
+            }
+
+            if (gridState[GRIDSTATE_inAddNewRow])
+            {
+                int currentRowCount = DataGridRowsLength;
+                DataGridRow[] newDataGridRows = new DataGridRow[currentRowCount + 1];
+                for (int i = 0; i < currentRowCount; i++)
+                {
+                    newDataGridRows[i] = localGridRows[i];
+                }
+
+                // put the AddNewRow
+                newDataGridRows[currentRowCount] = new DataGridAddNewRow(this, myGridTable, currentRowCount);
+                SetDataGridRows(newDataGridRows, currentRowCount + 1);
+
+                Edit();
+                // put this after the call to edit so that
+                // CommitEdit knows that the inAddNewRow is true;
+                gridState[GRIDSTATE_inAddNewRow] = false;
+                gridState[GRIDSTATE_isEditing] = true;
+                gridState[GRIDSTATE_isNavigating] = false;
+                return;
+            }
+
+            gridState[GRIDSTATE_isEditing] = true;
+            gridState[GRIDSTATE_isNavigating] = false;
+            InvalidateRowHeader(currentRow);
+
+            // tell the current row to lose the childFocuse
+            if (currentRow < localGridRows.Length)
+            {
+                localGridRows[currentRow].LoseChildFocus(layout.RowHeaders, isRightToLeft());
+            }
+        }
+
+        internal protected virtual void ColumnStartedEditing(Control editingControl)
+        {
+            if (editingControl == null)
+            {
+                return;
+            }
+
+            ColumnStartedEditing(editingControl.Bounds);
+        }
+
+        /// <summary>
+        ///  Displays child relations, if any exist, for all rows or a
+        ///  specific row.
+        /// </summary>
+        public void Expand(int row)
+        {
+            SetRowExpansionState(row, true);
+        }
+
+        /// <summary>
+        ///  Creates a <see cref='DataGridColumnStyle'/> using the specified <see cref='PropertyDescriptor'/>.
+        /// </summary>
+        // protected and virtual because the SimpleDropdownDataGrid will override this
+        protected virtual DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop, bool isDefault)
+        {
+            return myGridTable?.CreateGridColumn(prop, isDefault);
+        }
+
+        protected virtual DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop)
+        {
+            return myGridTable?.CreateGridColumn(prop);
+        }
+
+#if PARENT_LINKS
+
+            private ListManager ListManagerForChildColumn(ListManager childListManager, PropertyDescriptor prop)
+            {
+                /*
+                DataKey key;
+                RelationsCollection relCollection = dataColumn.Table.ParentRelations;
+                */
+
+                // this will give us the list of properties of the child
+                PropertyDescriptorCollection propCollection = childListManager.GetItemProperties();
+
+                int relCount = propCollection.Count;
+                for (int i=0;i<relCount;i++)
+                {
+                    PropertyDescriptor currRelation = propCollection[i];
+                    if (typeof(IList).IsAssignableFrom(currRelation.PropertyType))
+                    {
+                        object childRelation = currRelation.GetValue(childListManager.Current);
+                        ListManager childTable = this.BindingContexgt == null ? null : this.BindingManager[childRelation, ""];
+                        if (childTable == null)
+                            continue;
+
+                        // now loop thru all properties in the childTable...
+                        PropertyDescriptorCollection childProps = childTable.GetItemProperties();
+                        int colCount = childProps.Count;
+                        for (int j = 0; j < colCount; j++)
+                        {
+                            PropertyDescriptor currCol = childProps[j];
+                            if (currCol.Name != null && currCol.Name.Equals(prop.Name))
+                                // there is a column in the parent with the same name
+                                return childTable;
+                        }
+                    }
+
+                    /*
+                    DataColumn[] childCols = relCollection[i].ChildColumns;
+                    DataColumn[] parentCols = relCollection[i].ParentColumns;
+
+                    // if the relationship involves more than one column in the child
+                    // table, then look at the next relationship
+                    if (childCols.Count != 1)
+                        continue;
+
+                    // if the relationship involves more than one column in the parent
+                    // table, then look at the next relationship
+                    if (parentCols.Count != 1)
+                        continue;
+
+                    if (childCols[0] == dataColumn)
+                    {
+                        dataColumn = parentCols[0];
+                        return new DataSource(relCollection[i].ParentTable);
+                    }
+                    */
+                }
+
+                return null;
+            }
+
+#endif
+
+        /// <summary>
+        ///  Specifies the end of the initialization code.
+        /// </summary>
+        public void EndInit()
+        {
+            inInit = false;
+            if (myGridTable == null && ListManager != null)
+            {
+                SetDataGridTable(TableStyles[ListManager.GetListName()], true);      // true for forcing column creation
+            }
+
+            if (myGridTable != null)
+            {
+                myGridTable.DataGrid = this;
+            }
+        }
+
+        /// <summary>
+        ///  Given a x coordinate, returns the column it is over.
+        /// </summary>
+        private int GetColFromX(int x)
+        {
+            if (myGridTable == null)
+            {
+                return -1;
+            }
+
+            Rectangle inside = layout.Data;
+            Debug.Assert(x >= inside.X && x < inside.Right, "x must be inside the horizontal bounds of layout.Data");
+
+            x = MirrorPoint(x, inside, isRightToLeft());
+
+            GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+            int columnCount = columns.Count;
+
+            int cx = inside.X - negOffset;
+            int col = firstVisibleCol;
+            while (cx < inside.Width + inside.X && col < columnCount)
+            {
+                // if (columns[col].Visible && columns[col].PropertyDescriptor != null)
+                if (columns[col].PropertyDescriptor != null)
+                {
+                    cx += columns[col].Width;
+                }
+
+                if (cx > x)
+                {
+                    return col;
+                }
+
+                ++col;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        ///  Returns the coordinate of the left edge of the given column
+        ///  Bi-Di: if the grid has the RightToLeft property set to RightToLeft.Yes, this will
+        ///  return what appears as the right edge of the column
+        /// </summary>
+        internal int GetColBeg(int col)
+        {
+            Debug.Assert(myGridTable != null, "GetColBeg can't be called when myGridTable == null.");
+
+            int offset = layout.Data.X - negOffset;
+            GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+
+            int lastCol = Math.Min(col, columns.Count);
+            for (int i = firstVisibleCol; i < lastCol; ++i)
+            {
+                // if (columns[i].Visible && columns[i].PropertyDescriptor != null)
+                if (columns[i].PropertyDescriptor != null)
+                {
+                    offset += columns[i].Width;
+                }
+            }
+
+            return MirrorPoint(offset, layout.Data, isRightToLeft());
+        }
+
+        /// <summary>
+        ///  Returns the coordinate of the right edge of the given column
+        ///  Bi-Di: if the grid has the RightToLeft property set to RightToLeft.Yes, this will
+        ///  return what appears as the left edge of the column
+        /// </summary>
+        internal int GetColEnd(int col)
+        {
+            // return MirrorPoint(GetColBeg(col) + myGridTable.GridColumnStyles[col].Width, layout.Data, isRightToLeft());
+            int colBeg = GetColBeg(col);
+            Debug.Assert(myGridTable.GridColumnStyles[col].PropertyDescriptor != null, "why would we need the coordinate of a column that is not visible?");
+            int width = myGridTable.GridColumnStyles[col].Width;
+            return isRightToLeft() ? colBeg - width : colBeg + width;
+        }
+
+        private int GetColumnWidthSum()
+        {
+            int sum = 0;
+            if (myGridTable != null && myGridTable.GridColumnStyles != null)
+            {
+                GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+
+                int columnsCount = columns.Count;
+                for (int i = 0; i < columnsCount; i++)
+                {
+                    // if (columns[i].Visible && columns[i].PropertyDescriptor != null)
+                    if (columns[i].PropertyDescriptor != null)
+                    {
+                        sum += columns[i].Width;
+                    }
+                }
+            }
+
+            return sum;
+        }
+
+        /// <summary>
+        ///  Not all rows in the DataGrid are expandable,
+        ///  this computes which ones are and returns an array
+        ///  of references to them.
+        /// </summary>
+        private DataGridRelationshipRow[] GetExpandableRows()
+        {
+            int nExpandableRows = DataGridRowsLength;
+            DataGridRow[] localGridRows = DataGridRows;
+            if (policy.AllowAdd)
+            {
+                nExpandableRows = Math.Max(nExpandableRows - 1, 0);
+            }
+
+            DataGridRelationshipRow[] expandableRows = new DataGridRelationshipRow[nExpandableRows];
+            for (int i = 0; i < nExpandableRows; i++)
+            {
+                expandableRows[i] = (DataGridRelationshipRow)localGridRows[i];
+            }
+
+            return expandableRows;
+        }
+
+        /// <summary>
+        ///  Returns the row number underneath the given y coordinate.
+        /// </summary>
+        private int GetRowFromY(int y)
+        {
+            Rectangle inside = layout.Data;
+            Debug.Assert(y >= inside.Y && y < inside.Bottom, "y must be inside the vertical bounds of the data");
+
+            int cy = inside.Y;
+            int row = firstVisibleRow;
+            int rowCount = DataGridRowsLength;
+            DataGridRow[] localGridRows = DataGridRows;
+            int bottom = inside.Bottom;
+            while (cy < bottom && row < rowCount)
+            {
+                cy += localGridRows[row].Height;
+                if (cy > y)
+                {
+                    return row;
+                }
+
+                ++row;
+            }
+
+            return -1;
+        }
+
+        internal Rectangle GetRowHeaderRect()
+        {
+            return layout.RowHeaders;
+        }
+
+        internal Rectangle GetColumnHeadersRect()
+        {
+            return layout.ColumnHeaders;
+        }
+
+        /// <summary>
+        ///  Determines where on the control's ClientRectangle a given row is
+        ///  painting to.
+        /// </summary>
+        private Rectangle GetRowRect(int rowNumber)
+        {
+            Rectangle inside = layout.Data;
+            int cy = inside.Y;
+            DataGridRow[] localGridRows = DataGridRows;
+            for (int row = firstVisibleRow; row <= rowNumber; ++row)
+            {
+                if (cy > inside.Bottom)
+                {
+                    break;
+                }
+
+                if (row == rowNumber)
+                {
+                    Rectangle rowRect = new Rectangle(inside.X,
+                                                      cy,
+                                                      inside.Width,
+                                                      localGridRows[row].Height);
+                    if (layout.RowHeadersVisible)
+                    {
+                        rowRect.Width += layout.RowHeaders.Width;
+                        rowRect.X -= isRightToLeft() ? 0 : layout.RowHeaders.Width;
+                    }
+
+                    return rowRect;
+                }
+
+                cy += localGridRows[row].Height;
+            }
+
+            return Rectangle.Empty;
+        }
+
+        /// <summary>
+        ///  Returns the coordinate of the top edge of the given row
+        /// </summary>
+        private int GetRowTop(int row)
+        {
+            DataGridRow[] localGridRows = DataGridRows;
+            int offset = layout.Data.Y;
+            int lastRow = Math.Min(row, DataGridRowsLength);
+            for (int i = firstVisibleRow; i < lastRow; ++i)
+            {
+                offset += localGridRows[i].Height;
+            }
+
+            for (int i = firstVisibleRow; i > lastRow; i--)
+            {
+                offset -= localGridRows[i].Height;
+            }
+
+            return offset;
+        }
+
+        /// <summary>
+        ///  Returns the coordinate of the bottom edge of the given row
+        /// </summary>
+        private int GetRowBottom(int row)
+        {
+            DataGridRow[] localGridRows = DataGridRows;
+
+            return GetRowTop(row) + localGridRows[row].Height;
+        }
+
+        /// <summary>
+        ///  This method is called on methods that need the grid
+        ///  to be bound to a DataTable to work.
+        /// </summary>
+        private void EnsureBound()
+        {
+            if (!Bound)
+            {
+                throw new InvalidOperationException(SR.DataGridUnbound);
+            }
+        }
+
+        private void EnsureVisible(int row, int col)
+        {
+            if (row < firstVisibleRow
+                || row >= firstVisibleRow + numTotallyVisibleRows)
+            {
+                int dRows = ComputeDeltaRows(row);
+                ScrollDown(dRows);
+            }
+
+            if (firstVisibleCol == 0 && numVisibleCols == 0 && lastTotallyVisibleCol == -1)
+            {
+                // no columns are displayed whatsoever
+                // some sanity checks
+                Debug.Assert(negOffset == 0, " no columns are displayed so the negative offset should be 0");
+                return;
+            }
+
+            int previousFirstVisibleCol = firstVisibleCol;
+            int previousNegOffset = negOffset;
+            int previousLastTotallyVisibleCol = lastTotallyVisibleCol;
+
+            while (col < firstVisibleCol
+#pragma warning disable SA1408 // Conditional expressions should declare precedence
+                || col == firstVisibleCol && negOffset != 0
+                || lastTotallyVisibleCol == -1 && col > firstVisibleCol
+                || lastTotallyVisibleCol > -1 && col > lastTotallyVisibleCol)
+#pragma warning restore SA1408 // Conditional expressions should declare precedence
+            {
+                ScrollToColumn(col);
+
+                if (previousFirstVisibleCol == firstVisibleCol &&
+                    previousNegOffset == negOffset &&
+                    previousLastTotallyVisibleCol == lastTotallyVisibleCol)
+                {
+                    // nothing changed since the last iteration
+                    // don't get into an infinite loop
+                    break;
+                }
+
+                previousFirstVisibleCol = firstVisibleCol;
+                previousNegOffset = negOffset;
+                previousLastTotallyVisibleCol = lastTotallyVisibleCol;
+
+                // continue to scroll to the right until the scrollTo column is the totally last visible column or it is the first visible column
+            }
+        }
+
+        /// <summary>
+        ///  Gets a <see cref='T:System.Drawing.Rectangle'/>
+        ///  that specifies the four corners of the selected cell.
+        /// </summary>
+        public Rectangle GetCurrentCellBounds()
+        {
+            DataGridCell current = CurrentCell;
+            return GetCellBounds(current.RowNumber, current.ColumnNumber);
+        }
+
+        /// <summary>
+        ///  Gets the <see cref='T:System.Drawing.Rectangle'/> of the cell specified by row and column number.
+        /// </summary>
+        public Rectangle GetCellBounds(int row, int col)
+        {
+            DataGridRow[] localGridRows = DataGridRows;
+            Rectangle cellBounds = localGridRows[row].GetCellBounds(col);
+            cellBounds.Y += GetRowTop(row);
+            cellBounds.X += layout.Data.X - negOffset;
+            cellBounds.X = MirrorRectangle(cellBounds, layout.Data, isRightToLeft());
+            return cellBounds;
+        }
+
+        /// <summary>
+        ///  Gets the <see cref='T:System.Drawing.Rectangle'/> of the cell specified by <see cref='DataGridCell'/>.
+        /// </summary>
+        public Rectangle GetCellBounds(DataGridCell dgc)
+        {
+            return GetCellBounds(dgc.RowNumber, dgc.ColumnNumber);
+        }
+
+        //
+
+        internal Rectangle GetRowBounds(DataGridRow row)
+        {
+            Rectangle rowBounds = new Rectangle
+            {
+                Y = GetRowTop(row.RowNumber),
+                X = layout.Data.X,
+                Height = row.Height,
+                Width = layout.Data.Width
+            };
+            return rowBounds;
+        }
+
+        /// <summary>
+        ///  Gets information, such as row and column number of a
+        ///  clicked point on
+        ///  the grid,
+        ///  using the x
+        ///  and y coordinate passed to the method.
+        /// </summary>
+        public HitTestInfo HitTest(int x, int y)
+        {
+            int topOfData = layout.Data.Y;
+            HitTestInfo ci = new HitTestInfo();
+
+            if (layout.CaptionVisible && layout.Caption.Contains(x, y))
+            {
+                ci.type = HitTestType.Caption;
+                return ci;
+            }
+
+            if (layout.ParentRowsVisible && layout.ParentRows.Contains(x, y))
+            {
+                ci.type = HitTestType.ParentRows;
+                return ci;
+            }
+
+            if (!layout.Inside.Contains(x, y))
+            {
+                return ci;
+            }
+
+            if (layout.TopLeftHeader.Contains(x, y))
+            {
+                return ci;
+            }
+
+            // check for column resize
+            if (layout.ColumnHeaders.Contains(x, y))
+            {
+                ci.type = HitTestType.ColumnHeader;
+                ci.col = GetColFromX(x);
+                if (ci.col < 0)
+                {
+                    return HitTestInfo.Nowhere;
+                }
+
+                int right = GetColBeg(ci.col + 1);
+                bool rightToLeft = isRightToLeft();
+                if ((rightToLeft && x - right < 8) || (!rightToLeft && right - x < 8))
+                {
+                    ci.type = HitTestType.ColumnResize;
+                }
+
+                return (allowColumnResize ? ci : HitTestInfo.Nowhere);
+            }
+
+            //check for RowResize:
+            if (layout.RowHeaders.Contains(x, y))
+            {
+                ci.type = HitTestType.RowHeader;
+                ci.row = GetRowFromY(y);
+                if (ci.row < 0)
+                {
+                    return HitTestInfo.Nowhere;
+                }
+
+                // find out if the click was a RowResize click
+                DataGridRow[] localGridRows = DataGridRows;
+                int bottomBorder = GetRowTop(ci.row) + localGridRows[ci.row].Height;
+                if (bottomBorder - y - BorderWidth < 2 && !(localGridRows[ci.row] is DataGridAddNewRow))
+                {
+                    ci.type = HitTestType.RowResize;
+                }
+
+                return (allowRowResize ? ci : HitTestInfo.Nowhere);
+            }
+
+            if (layout.Data.Contains(x, y))
+            {
+                ci.type = HitTestType.Cell;
+                ci.col = GetColFromX(x);
+                ci.row = GetRowFromY(y);
+                if (ci.col < 0 || ci.row < 0)
+                {
+                    return HitTestInfo.Nowhere;
+                }
+
+                return ci;
+            }
+
+            return ci;
+        }
+
+        /// <summary>
+        ///  Gets information, such as row and column number of a
+        ///  clicked point on the grid, about the
+        ///  grid using a specific
+        ///  <see cref='Point'/>.
+        /// </summary>
+        public HitTestInfo HitTest(Point position)
+        {
+            return HitTest(position.X, position.Y);
+        }
+
+        /// <summary>
+        ///  Initializes the values for column widths in the table.
+        /// </summary>
+        private void InitializeColumnWidths()
+        {
+            if (myGridTable == null)
+            {
+                return;
+            }
+
+            GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+            int numCols = columns.Count;
+
+            // Resize the columns to a approximation of a best fit.
+            // We find the best fit width of NumRowsForAutoResize rows
+            // and use it for each column.
+            int preferredColumnWidth = myGridTable.IsDefault ? PreferredColumnWidth : myGridTable.PreferredColumnWidth;
+            // if we set the PreferredColumnWidth to something else than AutoColumnSize
+            // then use that value
+            //
+            for (int col = 0; col < numCols; col++)
+            {
+                // if the column width is not -1, then this column was initialized already
+                if (columns[col]._width != -1)
+                {
+                    continue;
+                }
+
+                columns[col]._width = preferredColumnWidth;
+            }
+        }
+
+        /// <summary>
+        ///  Invalidates the scrollable area of the DataGrid.
+        /// </summary>
+        internal void InvalidateInside()
+        {
+            Invalidate(layout.Inside);
+        }
+
+        /// <summary>
+        ///  Invalidates the caption area of the DataGrid.
+        /// </summary>
+        internal void InvalidateCaption()
+        {
+            if (layout.CaptionVisible)
+            {
+                Invalidate(layout.Caption);
+            }
+        }
+
+        /// <summary>
+        ///  Invalidates a rectangle normalized to the caption's
+        ///  visual bounds.
+        /// </summary>
+        internal void InvalidateCaptionRect(Rectangle r)
+        {
+            if (layout.CaptionVisible)
+            {
+                Invalidate(r);
+            }
+        }
+
+        /// <summary>
+        ///  Invalidates the display region of a given DataGridColumn.
+        /// </summary>
+        internal void InvalidateColumn(int column)
+        {
+            GridColumnStylesCollection gridColumns = myGridTable.GridColumnStyles;
+            if (column < 0 || gridColumns == null || gridColumns.Count <= column)
+            {
+                return;
+            }
+
+            Debug.Assert(gridColumns[column].PropertyDescriptor != null, "how can we invalidate a column that is invisible?");
+            // bail if the column is not visible.
+            if (column < firstVisibleCol || column > firstVisibleCol + numVisibleCols - 1)
+            {
+                return;
+            }
+
+            Rectangle columnArea = new Rectangle
+            {
+                Height = layout.Data.Height,
+                Width = gridColumns[column].Width,
+                Y = layout.Data.Y
+            };
+
+            int x = layout.Data.X - negOffset;
+            int gridColumnsCount = gridColumns.Count;
+            for (int i = firstVisibleCol; i < gridColumnsCount; ++i)
+            {
+                if (i == column)
+                {
+                    break;
+                }
+
+                x += gridColumns[i].Width;
+            }
+
+            columnArea.X = x;
+            columnArea.X = MirrorRectangle(columnArea, layout.Data, isRightToLeft());
+            Invalidate(columnArea);
+        }
+
+        /// <summary>
+        ///  Invalidates the parent rows area of the DataGrid
+        /// </summary>
+        internal void InvalidateParentRows()
+        {
+            if (layout.ParentRowsVisible)
+            {
+                Invalidate(layout.ParentRows);
+            }
+        }
+
+        /// <summary>
+        ///  Invalidates a rectangle normalized to the parent
+        ///  rows area's visual bounds.
+        /// </summary>
+        internal void InvalidateParentRowsRect(Rectangle r)
+        {
+            Rectangle parentRowsRect = layout.ParentRows;
+            Invalidate(r);
+            if (!parentRowsRect.IsEmpty)
+            {
+                //Invalidate(new Rectangle(parentRowsRect.X + r.X, parentRowsRect.Y + r.Y,
+                // r.Width, r.Height));
+            }
+        }
+
+        /// <summary>
+        ///  Invalidate the painting region for the row specified.
+        /// </summary>
+        internal void InvalidateRow(int rowNumber)
+        {
+            Rectangle rowRect = GetRowRect(rowNumber);
+            if (!rowRect.IsEmpty)
+            {
+                Debug.WriteLineIf(CompModSwitches.DataGridPainting.TraceVerbose, "DataGridPainting: Invalidating row " + rowNumber.ToString(CultureInfo.InvariantCulture));
+                Invalidate(rowRect);
+            }
+        }
+
+        private void InvalidateRowHeader(int rowNumber)
+        {
+            if (rowNumber >= firstVisibleRow && rowNumber < firstVisibleRow + numVisibleRows)
+            {
+                if (!layout.RowHeadersVisible)
+                {
+                    return;
+                }
+
+                Rectangle invalid = new Rectangle
+                {
+                    Y = GetRowTop(rowNumber),
+                    X = layout.RowHeaders.X,
+                    Width = layout.RowHeaders.Width,
+                    Height = DataGridRows[rowNumber].Height
+                };
+                Invalidate(invalid);
+            }
+        }
+
+        // NOTE:
+        // because of Rtl, we assume that the only place that calls InvalidateRowRect is
+        // the DataGridRelationshipRow
+        internal void InvalidateRowRect(int rowNumber, Rectangle r)
+        {
+            Rectangle rowRect = GetRowRect(rowNumber);
+            if (!rowRect.IsEmpty)
+            {
+                Debug.WriteLineIf(CompModSwitches.DataGridPainting.TraceVerbose, "DataGridPainting: Invalidating a rect in row " + rowNumber.ToString(CultureInfo.InvariantCulture));
+                Rectangle inner = new Rectangle(rowRect.X + r.X, rowRect.Y + r.Y, r.Width, r.Height);
+                if (vertScrollBar.Visible && isRightToLeft())
+                {
+                    inner.X -= vertScrollBar.Width;
+                }
+
+                Invalidate(inner);
+            }
+        }
+
+        /// <summary>
+        ///  Gets a value that indicates whether a specified row's node is expanded or collapsed.
+        /// </summary>
+        public bool IsExpanded(int rowNumber)
+        {
+            if (rowNumber < 0 || rowNumber > DataGridRowsLength)
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowNumber));
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+
+            //
+
+            DataGridRow row = localGridRows[rowNumber];
+            if (row is DataGridRelationshipRow relRow)
+            {
+                return relRow.Expanded;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether a
+        ///  specified row is selected.
+        /// </summary>
+        public bool IsSelected(int row)
+        {
+            //
+            DataGridRow[] localGridRows = DataGridRows;
+            return localGridRows[row].Selected;
+        }
+
+        internal static bool IsTransparentColor(Color color)
+        {
+            return color.A < 255;
+        }
+
+        /// <summary>
+        ///  Determines if Scrollbars should be visible,
+        ///  updates their bounds and the bounds of all
+        ///  other regions in the DataGrid's Layout.
+        /// </summary>
+        private void LayoutScrollBars()
+        {
+            // if we set the dataSource to null, then take away the scrollbars.
+            if (listManager == null || myGridTable == null)
+            {
+                horizScrollBar.Visible = false;
+                vertScrollBar.Visible = false;
+                return;
+            }
+
+            // Scrollbars are a tricky issue.
+            // We need to see if we can cram our columns and rows
+            // in without scrollbars and if they don't fit, we make
+            // scrollbars visible and then fixup our regions for the
+            // data and headers.
+            bool needHorizScrollbar = false;
+            bool needVertScrollbar = false;
+            bool recountRows = false;
+            bool alignToRight = isRightToLeft();
+
+            int nGridCols = myGridTable.GridColumnStyles.Count;
+
+            // if we call LayoutScrollBars before CreateDataGridRows
+            // then the columns will have their default width ( 100 )
+            // CreateDataGridRows will possibly change the columns' width
+            //
+            // and anyway, ComputeVisibleRows will call the DataGridRows accessor
+            //
+            DataGridRow[] gridRows = DataGridRows;
+
+            // at this stage, the data grid columns may have their width set to -1 ( ie, their width is uninitialized )
+            // make sure that the totalWidth is at least 0
+            int totalWidth = Math.Max(0, GetColumnWidthSum());
+
+            if (totalWidth > layout.Data.Width && !needHorizScrollbar)
+            {
+                int horizHeight = horizScrollBar.Height;
+                layout.Data.Height -= horizHeight;
+                if (layout.RowHeadersVisible)
+                {
+                    layout.RowHeaders.Height -= horizHeight;
+                }
+
+                needHorizScrollbar = true;
+            }
+
+            int oldFirstVisibleRow = firstVisibleRow;
+
+            ComputeVisibleRows();
+            if (numTotallyVisibleRows != DataGridRowsLength && !needVertScrollbar)
+            {
+                int vertWidth = vertScrollBar.Width;
+                layout.Data.Width -= vertWidth;
+                if (layout.ColumnHeadersVisible)
+                {
+                    if (alignToRight)
+                    {
+                        layout.ColumnHeaders.X += vertWidth;
+                    }
+
+                    layout.ColumnHeaders.Width -= vertWidth;
+                }
+
+                needVertScrollbar = true;
+            }
+
+            firstVisibleCol = ComputeFirstVisibleColumn();
+            // we compute the number of visible columns only after we set up the vertical scroll bar.
+            ComputeVisibleColumns();
+
+            if (needVertScrollbar && totalWidth > layout.Data.Width && !needHorizScrollbar)
+            {
+                firstVisibleRow = oldFirstVisibleRow;
+                int horizHeight = horizScrollBar.Height;
+                layout.Data.Height -= horizHeight;
+                if (layout.RowHeadersVisible)
+                {
+                    layout.RowHeaders.Height -= horizHeight;
+                }
+
+                needHorizScrollbar = true;
+                recountRows = true;
+            }
+
+            if (recountRows)
+            {
+                ComputeVisibleRows();
+                if (numTotallyVisibleRows != DataGridRowsLength && !needVertScrollbar)
+                {
+                    int vertWidth = vertScrollBar.Width;
+                    layout.Data.Width -= vertWidth;
+                    if (layout.ColumnHeadersVisible)
+                    {
+                        if (alignToRight)
+                        {
+                            layout.ColumnHeaders.X += vertWidth;
+                        }
+
+                        layout.ColumnHeaders.Width -= vertWidth;
+                    }
+
+                    needVertScrollbar = true;
+                }
+            }
+
+            layout.ResizeBoxRect = new Rectangle();
+            if (needVertScrollbar && needHorizScrollbar)
+            {
+                Rectangle data = layout.Data;
+                layout.ResizeBoxRect = new Rectangle(alignToRight ? data.X : data.Right,
+                                               data.Bottom,
+                                               vertScrollBar.Width,
+                                               horizScrollBar.Height);
+            }
+
+            if (needHorizScrollbar && nGridCols > 0)
+            {
+                //Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: foo");
+
+                int widthNotVisible = totalWidth - layout.Data.Width;
+
+                horizScrollBar.Minimum = 0;
+                horizScrollBar.Maximum = totalWidth;
+                horizScrollBar.SmallChange = 1;
+                horizScrollBar.LargeChange = Math.Max(totalWidth - widthNotVisible, 0);
+                horizScrollBar.Enabled = Enabled;
+                horizScrollBar.RightToLeft = RightToLeft;
+                horizScrollBar.Bounds = new Rectangle(alignToRight ? layout.Inside.X + layout.ResizeBoxRect.Width : layout.Inside.X,
+                                                            layout.Data.Bottom,
+                                                            layout.Inside.Width - layout.ResizeBoxRect.Width,
+                                                            horizScrollBar.Height);
+                horizScrollBar.Visible = true;
+            }
+            else
+            {
+                HorizontalOffset = 0;
+                horizScrollBar.Visible = false;
+            }
+
+            if (needVertScrollbar)
+            {
+                int vertScrollBarTop = layout.Data.Y;
+                if (layout.ColumnHeadersVisible)
+                {
+                    vertScrollBarTop = layout.ColumnHeaders.Y;
+                }
+
+                // if numTotallyVisibleRows == 0 ( the height of the row is bigger than the height of
+                // the grid ) then scroll in increments of 1.
+                vertScrollBar.LargeChange = numTotallyVisibleRows != 0 ? numTotallyVisibleRows : 1;
+                vertScrollBar.Bounds = new Rectangle(alignToRight ? layout.Data.X : layout.Data.Right,
+                                                     vertScrollBarTop,
+                                                     vertScrollBar.Width,
+                                                     layout.Data.Height + layout.ColumnHeaders.Height);
+                vertScrollBar.Enabled = Enabled;
+                vertScrollBar.Visible = true;
+                if (alignToRight)
+                {
+                    layout.Data.X += vertScrollBar.Width;
+                }
+            }
+            else
+            {
+                vertScrollBar.Visible = false;
+            }
+        }
+
+        /// <summary>
+        ///  Navigates back to the table previously displayed in the grid.
+        /// </summary>
+        public void NavigateBack()
+        {
+            if (!CommitEdit() || parentRows.IsEmpty())
+            {
+                return;
+            }
+
+            // when navigating back, if the grid is inAddNewRow state, cancel the currentEdit.
+            // we do not need to recreate the rows cause we are navigating back.
+            // the grid will catch any exception that happens.
+            if (gridState[GRIDSTATE_inAddNewRow])
+            {
+                gridState[GRIDSTATE_inAddNewRow] = false;
+                try
+                {
+                    listManager.CancelCurrentEdit();
+                }
+                catch
+                {
+                }
+            }
+            else
+            {
+                UpdateListManager();
+            }
+
+            DataGridState newState = parentRows.PopTop();
+
+            ResetMouseState();
+
+            newState.PullState(this, false);                // we do not want to create columns when navigating back
+
+            // we need to have originalState != null when we process
+            // Set_ListManager in the NavigateBack/NavigateTo methods.
+            // otherwise the DataSource_MetaDataChanged event will not get registered
+            // properly
+            if (parentRows.GetTopParent() == null)
+            {
+                originalState = null;
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+            // what if the user changed the ReadOnly property
+            // on the grid while the user was navigating to the child rows?
+            //
+            // what if the policy does not allow for allowAdd?
+            //
+            if ((ReadOnly || !policy.AllowAdd) == (localGridRows[DataGridRowsLength - 1] is DataGridAddNewRow))
+            {
+                int newDataGridRowsLength = (ReadOnly || !policy.AllowAdd) ? DataGridRowsLength - 1 : DataGridRowsLength + 1;
+                DataGridRow[] newDataGridRows = new DataGridRow[newDataGridRowsLength];
+                for (int i = 0; i < Math.Min(newDataGridRowsLength, DataGridRowsLength); i++)
+                {
+                    newDataGridRows[i] = DataGridRows[i];
+                }
+
+                if (!ReadOnly && policy.AllowAdd)
+                {
+                    newDataGridRows[newDataGridRowsLength - 1] = new DataGridAddNewRow(this, myGridTable, newDataGridRowsLength - 1);
+                }
+
+                SetDataGridRows(newDataGridRows, newDataGridRowsLength);
+            }
+
+            // when we navigate back from a child table,
+            // it may be the case that in between the user added a tableStyle that is different
+            // from the one that is currently in the grid
+            // in that case, we need to reset the dataGridTableStyle in the rows
+            localGridRows = DataGridRows;
+            if (localGridRows != null && localGridRows.Length != 0)
+            {
+                DataGridTableStyle dgTable = localGridRows[0].DataGridTableStyle;
+                if (dgTable != myGridTable)
+                {
+                    for (int i = 0; i < localGridRows.Length; i++)
+                    {
+                        localGridRows[i].DataGridTableStyle = myGridTable;
+                    }
+                }
+            }
+
+            // if we have the default table, when we navigate back
+            // we also have the default gridColumns, w/ width = -1
+            // we need to set the width on the new gridColumns
+            //
+            if (myGridTable.GridColumnStyles.Count > 0 && myGridTable.GridColumnStyles[0].Width == -1)
+            {
+#if DEBUG
+                GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+                for (int i = 0; i < cols.Count; i++)
+                {
+                    Debug.Assert(cols[i].Width == -1, "Sanity check");
+                }
+
+                Debug.Assert(myGridTable.IsDefault, "when we navigate to the parent rows and the columns have widths -1 we are using the default table");
+#endif // DEBUG
+                InitializeColumnWidths();
+            }
+
+            // reset the currentRow to the old position in the listmanager:
+            currentRow = ListManager.Position == -1 ? 0 : ListManager.Position;
+
+            // if the AllowNavigation changed while the user was navigating the
+            // child tables, so that the new navigation mode does not allow childNavigation anymore
+            // then reset the rows
+            if (!AllowNavigation)
+            {
+                RecreateDataGridRows();
+            }
+
+            caption.BackButtonActive = (parentRows.GetTopParent() != null) && AllowNavigation;
+            caption.BackButtonVisible = caption.BackButtonActive;
+            caption.DownButtonActive = (parentRows.GetTopParent() != null);
+
+            PerformLayout();
+            Invalidate();
+            // reposition the scroll bar
+            if (vertScrollBar.Visible)
+            {
+                vertScrollBar.Value = firstVisibleRow;
+            }
+
+            if (horizScrollBar.Visible)
+            {
+                horizScrollBar.Value = HorizontalOffset + negOffset;
+            }
+
+            Edit();
+            OnNavigate(new NavigateEventArgs(false));
+        }
+
+        /// <summary>
+        ///  Navigates to the table specified by row and relation
+        ///  name.
+        /// </summary>
+        public void NavigateTo(int rowNumber, string relationName)
+        {
+            // do not navigate if AllowNavigation is set to false
+            if (!AllowNavigation)
+            {
+                return;
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+            if (rowNumber < 0 || rowNumber > DataGridRowsLength - (policy.AllowAdd ? 2 : 1))
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowNumber));
+            }
+
+            EnsureBound();
+
+            DataGridRow source = localGridRows[rowNumber];
+
+            NavigateTo(relationName, source, false);
+        }
+
+        internal void NavigateTo(string relationName, DataGridRow source, bool fromRow)
+        {
+            // do not navigate if AllowNavigation is set to false
+            if (!AllowNavigation)
+            {
+                return;
+            }
+
+            // Commit the edit if possible
+            if (!CommitEdit())
+            {
+                return;
+            }
+
+            DataGridState childState;
+            try
+            {
+                childState = CreateChildState(relationName, source);
+            }
+            catch
+            {
+                // if we get an error when creating the RelatedCurrencyManager
+                // then navigateBack and ignore the exception.
+                //
+                NavigateBack();
+                return;
+            }
+
+            // call EndCurrentEdit before navigating.
+            // if we get an exception, we do not navigate.
+            //
+            try
+            {
+                listManager.EndCurrentEdit();
+            }
+            catch
+            {
+                return;
+            }
+
+            // Preserve our current state
+            // we need to do this after the EndCurrentEdit, otherwise the
+            // DataGridState will get the listChanged event from the EndCurrentEdit
+            DataGridState dgs = new DataGridState(this)
+            {
+                LinkingRow = source
+            };
+
+            // we need to update the Position in the ListManager
+            // ( the RelatedListManager uses only the position in the parentManager
+            //   to create the childRows
+            //
+            // before the code was calling CurrentCell = this and such
+            // we should only call EndCurrentEdit ( which the code was doing anyway )
+            // and then set the position in the listManager to the new row.
+            //
+            if (source.RowNumber != CurrentRow)
+            {
+                listManager.Position = source.RowNumber;
+            }
+
+            // We save our state if the parent rows stack is empty.
+            if (parentRows.GetTopParent() == null)
+            {
+                originalState = dgs;
+            }
+
+            parentRows.AddParent(dgs);
+
+            NavigateTo(childState);
+
+            OnNavigate(new NavigateEventArgs(true));
+            if (fromRow)
+            {
+                // OnLinkClick(EventArgs.Empty);
+            }
+        }
+
+        private void NavigateTo(DataGridState childState)
+        {
+            // we are navigating... better stop editing.
+            EndEdit();
+
+            // also, we are no longer in editOrNavigate mode either
+            gridState[GRIDSTATE_isNavigating] = false;
+
+            // reset hot tracking
+            ResetMouseState();
+
+            // Retrieve the child state
+            childState.PullState(this, true);               // true for creating columns when we navigate to child rows
+
+            if (listManager.Position != currentRow)
+            {
+                currentRow = listManager.Position == -1 ? 0 : listManager.Position;
+            }
+
+            if (parentRows.GetTopParent() != null)
+            {
+                caption.BackButtonActive = AllowNavigation;
+                caption.BackButtonVisible = caption.BackButtonActive;
+                caption.DownButtonActive = true;
+            }
+
+            HorizontalOffset = 0;
+            PerformLayout();
+            Invalidate();
+        }
+
+        /// <summary>
+        ///  Given a coordinate in the control this method returns
+        ///  the equivalent point for a row.
+        /// </summary>
+        private Point NormalizeToRow(int x, int y, int row)
+        {
+            Debug.Assert(row >= firstVisibleRow && row < firstVisibleRow + numVisibleRows,
+                         "Row " + row.ToString(CultureInfo.InvariantCulture) + "is not visible! firstVisibleRow = " +
+                         firstVisibleRow.ToString(CultureInfo.InvariantCulture) + ", numVisibleRows = " +
+                         numVisibleRows.ToString(CultureInfo.InvariantCulture));
+            Point origin = new Point(0, layout.Data.Y);
+
+            DataGridRow[] localGridRows = DataGridRows;
+            for (int r = firstVisibleRow; r < row; ++r)
+            {
+                origin.Y += localGridRows[r].Height;
+            }
+
+            // when hittesting for the PlusMinus, the code in the DataGridRelationshipRow
+            // will use real X coordinate ( the one from layout.RowHeaders ) to paint the glyph
+            //
+            return new Point(x, y - origin.Y);
+        }
+
+        internal void OnColumnCollectionChanged(object sender, CollectionChangeEventArgs e)
+        {
+            DataGridTableStyle table = (DataGridTableStyle)sender;
+            if (table.Equals(myGridTable))
+            {
+                // if we changed the column collection, then we need to set the property
+                // descriptors in the column collection.
+                // unless the user set the propertyDescriptor in the columnCollection
+                //
+                if (!myGridTable.IsDefault)
+                {
+                    // if the element in the collectionChangeEventArgs is not null
+                    // and the action is refresh, then it means that the user
+                    // set the propDesc. we do not want to override this.
+                    if (e.Action != CollectionChangeAction.Refresh || e.Element == null)
+                    {
+                        PairTableStylesAndGridColumns(listManager, myGridTable, false);
+                    }
+                }
+
+                Invalidate();
+                PerformLayout();
+            }
+        }
+
+        /// <summary>
+        ///  Paints column headers.
+        /// </summary>
+        private void PaintColumnHeaders(Graphics g)
+        {
+            bool alignToLeft = isRightToLeft();
+            Rectangle boundingRect = layout.ColumnHeaders;
+            if (!alignToLeft)
+            {
+                boundingRect.X -= negOffset;
+            }
+
+            boundingRect.Width += negOffset;
+
+            int columnHeaderWidth = PaintColumnHeaderText(g, boundingRect);
+
+            if (alignToLeft)
+            {
+                boundingRect.X = boundingRect.Right - columnHeaderWidth;
+            }
+
+            boundingRect.Width = columnHeaderWidth;
+            if (!FlatMode)
+            {
+                ControlPaint.DrawBorder3D(g, boundingRect, Border3DStyle.RaisedInner);
+                boundingRect.Inflate(-1, -1);
+                // g.SetPen(OldSystemPens.Control);
+                // g.OldBrush = (OldSystemBrushes.Hollow);
+                boundingRect.Width--;
+                boundingRect.Height--;
+                g.DrawRectangle(SystemPens.Control, boundingRect);
+            }
+        }
+
+        private int PaintColumnHeaderText(Graphics g, Rectangle boundingRect)
+        {
+            int cx = 0;
+            Rectangle textBounds = boundingRect;
+            GridColumnStylesCollection gridColumns = myGridTable.GridColumnStyles;
+            bool alignRight = isRightToLeft();
+
+            int nGridCols = gridColumns.Count;
+            // for sorting
+            PropertyDescriptor sortProperty = null;
+            sortProperty = ListManager.GetSortProperty();
+
+            // Now paint the column header text!
+            for (int col = firstVisibleCol; col < nGridCols; ++col)
+            {
+                if (gridColumns[col].PropertyDescriptor == null)
+                {
+                    continue;
+                }
+
+                if (cx > boundingRect.Width)
+                {
+                    break;
+                }
+
+                bool columnSorted = sortProperty != null && sortProperty.Equals(gridColumns[col].PropertyDescriptor);
+                TriangleDirection whichWay = TriangleDirection.Up;
+                if (columnSorted)
+                {
+                    ListSortDirection direction = ListManager.GetSortDirection();
+                    if (direction == ListSortDirection.Descending)
+                    {
+                        whichWay = TriangleDirection.Down;
+                    }
+                }
+
+                if (alignRight)
+                {
+                    textBounds.Width = gridColumns[col].Width -
+                                       (columnSorted ? textBounds.Height : 0);
+                    textBounds.X = boundingRect.Right - cx - textBounds.Width;
+                }
+                else
+                {
+                    textBounds.X = boundingRect.X + cx;
+                    textBounds.Width = gridColumns[col].Width -
+                                       (columnSorted ? textBounds.Height : 0);
+                }
+
+                // at the moment we paint some pixels twice.
+                // we should not call FilLRectangle, once the real GDI+ is there, we will have no need to do that
+
+                // if the user set the HeaderBackBrush property on the
+                // dataGrid, then use that property
+                Brush headerBrush;
+                if (myGridTable.IsDefault)
+                {
+                    headerBrush = HeaderBackBrush;
+                }
+                else
+                {
+                    headerBrush = myGridTable.HeaderBackBrush;
+                }
+
+                g.FillRectangle(headerBrush, textBounds);
+                // granted, the code would be a lot cleaner if we were using a "new Rectangle"
+                // but like this will be faster
+                if (alignRight)
+                {
+                    textBounds.X -= 2;
+                    textBounds.Y += 2;
+                }
+                else
+                {
+                    textBounds.X += 2;
+                    textBounds.Y += 2;
+                }
+
+                StringFormat format = new StringFormat();
+
+                // the columnHeaderText alignment should be the same as
+                // the alignment in the column
+                //
+                HorizontalAlignment colAlignment = gridColumns[col].Alignment;
+                format.Alignment = colAlignment == HorizontalAlignment.Right ? StringAlignment.Far :
+                                   colAlignment == HorizontalAlignment.Center ? StringAlignment.Center :
+                                                                                 StringAlignment.Near;
+
+                // part 1, section 1: the column headers should not wrap
+                format.FormatFlags |= StringFormatFlags.NoWrap;
+
+                if (alignRight)
+                {
+                    format.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                    format.Alignment = StringAlignment.Near;
+                }
+
+                g.DrawString(gridColumns[col].HeaderText,
+                             myGridTable.IsDefault ? HeaderFont : myGridTable.HeaderFont,
+                             myGridTable.IsDefault ? HeaderForeBrush : myGridTable.HeaderForeBrush,
+                             textBounds,
+                             format);
+                format.Dispose();
+
+                if (alignRight)
+                {
+                    textBounds.X += 2;
+                    textBounds.Y -= 2;
+                }
+                else
+                {
+                    textBounds.X -= 2;
+                    textBounds.Y -= 2;
+                }
+
+                if (columnSorted)
+                {
+                    //
+
+                    Rectangle triBounds = new Rectangle(alignRight ? textBounds.X - textBounds.Height : textBounds.Right,
+                                                        textBounds.Y,
+                                                        textBounds.Height,
+                                                        textBounds.Height);
+
+                    g.FillRectangle(headerBrush, triBounds);
+                    int deflateValue = Math.Max(0, (textBounds.Height - 5) / 2);
+                    triBounds.Inflate(-deflateValue, -deflateValue);
+
+                    Pen pen1 = new Pen(BackgroundBrush);
+                    Pen pen2 = new Pen(myGridTable.BackBrush);
+                    Triangle.Paint(g, triBounds, whichWay, headerBrush, pen1, pen2, pen1, true);
+                    pen1.Dispose();
+                    pen2.Dispose();
+                }
+
+                int paintedWidth = textBounds.Width + (columnSorted ? textBounds.Height : 0);
+
+                if (!FlatMode)
+                {
+                    if (alignRight && columnSorted)
+                    {
+                        textBounds.X -= textBounds.Height;
+                    }
+
+                    textBounds.Width = paintedWidth;
+
+                    ControlPaint.DrawBorder3D(g, textBounds, Border3DStyle.RaisedInner);
+                }
+
+                cx += paintedWidth;
+            }
+
+            // paint the possible exposed portion to the right ( or left, as the case may be)
+            if (cx < boundingRect.Width)
+            {
+                textBounds = boundingRect;
+
+                if (!alignRight)
+                {
+                    textBounds.X += cx;
+                }
+
+                textBounds.Width -= cx;
+                g.FillRectangle(backgroundBrush, textBounds);
+            }
+
+            return cx;
+        }
+
+        /// <summary>
+        ///  Paints a border around the bouding rectangle given
+        /// </summary>
+        private void PaintBorder(Graphics g, Rectangle bounds)
+        {
+            if (BorderStyle == BorderStyle.None)
+            {
+                return;
+            }
+
+            if (BorderStyle == BorderStyle.Fixed3D)
+            {
+                Border3DStyle style = Border3DStyle.Sunken;
+                ControlPaint.DrawBorder3D(g, bounds, style);
+            }
+            else if (BorderStyle == BorderStyle.FixedSingle)
+            {
+                Brush br;
+
+                if (myGridTable.IsDefault)
+                {
+                    br = HeaderForeBrush;
+                }
+                else
+                {
+                    br = myGridTable.HeaderForeBrush;
+                }
+
+                g.FillRectangle(br, bounds.X, bounds.Y, bounds.Width + 2, 2);
+                g.FillRectangle(br, bounds.Right - 2, bounds.Y, 2, bounds.Height + 2);
+                g.FillRectangle(br, bounds.X, bounds.Bottom - 2, bounds.Width + 2, 2);
+                g.FillRectangle(br, bounds.X, bounds.Y, 2, bounds.Height + 2);
+            }
+            else
+            {
+                Pen pen = SystemPens.WindowFrame;
+                bounds.Width--;
+                bounds.Height--;
+                g.DrawRectangle(pen, bounds);
+            }
+        }
+
+        /// <summary>
+        ///  Paints the grid in the bounding rectangle given.
+        ///  This includes the column headers and each visible row.
+        /// </summary>
+        private void PaintGrid(Graphics g, Rectangle gridBounds)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridPainting.TraceVerbose, "DataGridPainting: PaintGrid on " + gridBounds.ToString());
+
+            Rectangle rc = gridBounds;
+
+            if (listManager != null)
+            {
+                if (layout.ColumnHeadersVisible)
+                {
+                    Region r = g.Clip;
+                    g.SetClip(layout.ColumnHeaders);
+                    PaintColumnHeaders(g);
+                    g.Clip = r;
+                    r.Dispose();
+                    int columnHeaderHeight = layout.ColumnHeaders.Height;
+                    rc.Y += columnHeaderHeight;
+                    rc.Height -= columnHeaderHeight;
+                }
+
+                if (layout.TopLeftHeader.Width > 0)
+                {
+                    if (myGridTable.IsDefault)
+                    {
+                        g.FillRectangle(HeaderBackBrush, layout.TopLeftHeader);
+                    }
+                    else
+                    {
+                        g.FillRectangle(myGridTable.HeaderBackBrush, layout.TopLeftHeader);
+                    }
+
+                    if (!FlatMode)
+                    {
+                        ControlPaint.DrawBorder3D(g, layout.TopLeftHeader, Border3DStyle.RaisedInner);
+                    }
+                }
+
+                PaintRows(g, ref rc);
+            }
+
+            // paint the possible exposed portion below
+            if (rc.Height > 0)
+            {
+                g.FillRectangle(backgroundBrush, rc);
+            }
+        }
+
+        private void DeleteDataGridRows(int deletedRows)
+        {
+            if (deletedRows == 0)
+            {
+                return;
+            }
+
+            int currentRowCount = DataGridRowsLength;
+            int newDataGridRowsLength = currentRowCount - deletedRows + (gridState[GRIDSTATE_inAddNewRow] ? 1 : 0);
+            DataGridRow[] newDataGridRows = new DataGridRow[newDataGridRowsLength];
+            DataGridRow[] gridRows = DataGridRows;
+
+            // the number of selected entries so far in the array
+            int selectedEntries = 0;
+
+            for (int i = 0; i < currentRowCount; i++)
+            {
+                if (gridRows[i].Selected)
+                {
+                    selectedEntries++;
+                }
+                else
+                {
+                    newDataGridRows[i - selectedEntries] = gridRows[i];
+                    newDataGridRows[i - selectedEntries].number = i - selectedEntries;
+                }
+            }
+
+            if (gridState[GRIDSTATE_inAddNewRow])
+            {
+                newDataGridRows[currentRowCount - selectedEntries] = new DataGridAddNewRow(this, myGridTable, currentRowCount - selectedEntries);
+                gridState[GRIDSTATE_inAddNewRow] = false;
+            }
+
+            Debug.Assert(selectedEntries == deletedRows, "all the rows that would have been deleted should have been selected: selectedGridEntries " + selectedEntries.ToString(CultureInfo.InvariantCulture) + " deletedRows " + deletedRows.ToString(CultureInfo.InvariantCulture));
+
+            SetDataGridRows(newDataGridRows, newDataGridRowsLength);
+        }
+
+        /// <summary>
+        ///  Paints the visible rows on the grid.
+        /// </summary>
+        private void PaintRows(Graphics g, ref Rectangle boundingRect)
+        {
+            int cy = 0;
+            bool alignRight = isRightToLeft();
+            Rectangle rowBounds = boundingRect;
+            Rectangle dataBounds = Rectangle.Empty;
+            bool paintRowHeaders = layout.RowHeadersVisible;
+            Rectangle headerBounds = Rectangle.Empty;
+
+            int numRows = DataGridRowsLength;
+            DataGridRow[] localGridRows = DataGridRows;
+            int numCols = myGridTable.GridColumnStyles.Count - firstVisibleCol;
+
+            for (int row = firstVisibleRow; row < numRows; row++)
+            {
+                if (cy > boundingRect.Height)
+                {
+                    break;
+                }
+
+                rowBounds = boundingRect;
+                rowBounds.Height = localGridRows[row].Height;
+                rowBounds.Y = boundingRect.Y + cy;
+
+                // will add some errors
+#if false
+                    if (forDebug == 0 || forDebug == 1)
+                    {
+                        object dRowView = listManager[row];
+                        DataRow dRow= ((DataRowView) dRowView).Row;
+                        // dRow.RowError = "Error " + forDebug.ToString();
+                        dRow.SetColumnError(forDebug, "another error " + forDebug.ToString());
+
+                        /*
+                        if (localGridRows[row].DataRow != null)
+                        {
+                            localGridRows[row].DataRow.RowError = "error " + forDebug.ToString();
+                            localGridRows[row].DataRow.SetColumnError(forDebug, "another error " + forDebug.ToString());
+                        }
+                        */
+                        forDebug ++;
+                    }
+#endif // false
+                if (paintRowHeaders)
+                {
+                    headerBounds = rowBounds;
+                    headerBounds.Width = layout.RowHeaders.Width;
+
+                    if (alignRight)
+                    {
+                        headerBounds.X = rowBounds.Right - headerBounds.Width;
+                    }
+
+                    if (g.IsVisible(headerBounds))
+                    {
+                        localGridRows[row].PaintHeader(g, headerBounds, alignRight, gridState[GRIDSTATE_isEditing]);
+                        g.ExcludeClip(headerBounds);
+                    }
+
+                    if (!alignRight)
+                    {
+                        rowBounds.X += headerBounds.Width;
+                    }
+
+                    rowBounds.Width -= headerBounds.Width;
+                }
+
+                if (g.IsVisible(rowBounds))
+                {
+                    dataBounds = rowBounds;
+                    if (!alignRight)
+                    {
+                        dataBounds.X -= negOffset;
+                    }
+
+                    dataBounds.Width += negOffset;
+
+                    localGridRows[row].Paint(g, dataBounds, rowBounds, firstVisibleCol, numCols, alignRight);
+                }
+
+                cy += rowBounds.Height;
+            }
+
+            boundingRect.Y += cy;
+            boundingRect.Height -= cy;
+        }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates whether a key should be processed
+        ///  further.
+        /// </summary>
+        protected override bool ProcessDialogKey(Keys keyData)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridKeys.TraceVerbose, "DataGridKeys: ProcessDialogKey " + TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString(keyData));
+            DataGridRow[] localGridRows = DataGridRows;
+            if (listManager != null && DataGridRowsLength > 0 && localGridRows[currentRow].OnKeyPress(keyData))
+            {
+                Debug.WriteLineIf(CompModSwitches.DataGridKeys.TraceVerbose, "DataGridKeys: Current Row ate the keystroke");
+                return true;
+            }
+
+            switch (keyData & Keys.KeyCode)
+            {
+                case Keys.Tab:
+                case Keys.Up:
+                case Keys.Down:
+                case Keys.Left:
+                case Keys.Right:
+                case Keys.Next:
+                case Keys.Prior:
+                case Keys.Enter:
+                case Keys.Escape:
+                case Keys.Oemplus:
+                case Keys.Add:
+                case Keys.OemMinus:
+                case Keys.Subtract:
+                case Keys.Space:
+                case Keys.Delete:
+                case Keys.A:
+                    KeyEventArgs ke = new KeyEventArgs(keyData);
+                    if (ProcessGridKey(ke))
+                    {
+                        return true;
+                    }
+
+                    break;
+
+                case Keys.C:
+                    if ((keyData & Keys.Control) != 0 && (keyData & Keys.Alt) == 0)
+                    {
+                        // the user pressed Ctrl-C
+                        if (!Bound)
+                        {
+                            break;
+                        }
+
+                        // need to distinguish between selecting a set of rows, and
+                        // selecting just one column.
+                        if (numSelectedRows == 0)
+                        {
+                            // copy the data from one column only
+                            if (currentRow < ListManager.Count)
+                            {
+                                GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+                                if (currentCol >= 0 && currentCol < columns.Count)
+                                {
+                                    DataGridColumnStyle column = columns[currentCol];
+                                    string text = column.GetDisplayText(column.GetColumnValueAtRow(ListManager, currentRow));
+
+                                    // copy the data to the clipboard
+                                    Clipboard.SetDataObject(text);
+                                    return true;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // the user selected a set of rows to copy the data from
+
+                            int numRowsOutputted = 0;           // the number of rows written to "text"
+                            string text = string.Empty;
+
+                            for (int i = 0; i < DataGridRowsLength; ++i)
+                            {
+                                if (localGridRows[i].Selected)
+                                {
+                                    GridColumnStylesCollection columns = myGridTable.GridColumnStyles;
+                                    int numCols = columns.Count;
+                                    for (int j = 0; j < numCols; j++)
+                                    {
+                                        DataGridColumnStyle column = columns[j];
+                                        text += column.GetDisplayText(column.GetColumnValueAtRow(ListManager, i));
+
+                                        // do not put the delimiter at the end of the last column
+                                        if (j < numCols - 1)
+                                        {
+                                            text += GetOutputTextDelimiter();
+                                        }
+                                    }
+
+                                    // put the hard enter "\r\n" only if this is not the last selected row
+                                    if (numRowsOutputted < numSelectedRows - 1)
+                                    {
+                                        text += "\r\n";
+                                    }
+
+                                    numRowsOutputted++;
+                                }
+                            }
+
+                            // copy the data to the clipboard
+                            Clipboard.SetDataObject(text);
+                            return true;
+                        }
+                    }
+
+                    break;
+            }
+
+            return base.ProcessDialogKey(keyData);
+        }
+
+        private void DeleteRows(DataGridRow[] localGridRows)
+        {
+            int rowsDeleted = 0;
+
+            int currentRowsCount = listManager == null ? 0 : listManager.Count;
+
+            if (Visible)
+            {
+                BeginUpdateInternal();
+            }
+
+            try
+            {
+                if (ListManager != null)
+                {
+                    for (int i = 0; i < DataGridRowsLength; i++)
+                    {
+                        if (localGridRows[i].Selected)
+                        {
+                            if (localGridRows[i] is DataGridAddNewRow)
+                            {
+                                Debug.Assert(i == DataGridRowsLength - 1, "the location of addNewRow is " + i.ToString(CultureInfo.InvariantCulture) + " and there are " + DataGridRowsLength.ToString(CultureInfo.InvariantCulture) + " rows ");
+                                localGridRows[i].Selected = false;
+                            }
+                            else
+                            {
+                                ListManager.RemoveAt(i - rowsDeleted);
+                                rowsDeleted++;
+                            }
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                // if we got an exception from the back end
+                // when deleting the rows then we should reset
+                // our rows and re-throw the exception
+                //
+                RecreateDataGridRows();
+                gridState[GRIDSTATE_inDeleteRow] = false;
+                if (Visible)
+                {
+                    EndUpdateInternal();
+                }
+
+                throw;
+            }
+
+            // keep the copy of the old rows in place
+            // it may be the case that deleting one row could cause multiple rows to be deleted in the same list
+            //
+            if (listManager != null && currentRowsCount == listManager.Count + rowsDeleted)
+            {
+                DeleteDataGridRows(rowsDeleted);
+            }
+            else
+            {
+                RecreateDataGridRows();
+            }
+
+            gridState[GRIDSTATE_inDeleteRow] = false;
+            if (Visible)
+            {
+                EndUpdateInternal();
+            }
+
+            if (listManager != null && currentRowsCount != listManager.Count + rowsDeleted)
+            {
+                Invalidate();
+            }
+        }
+
+        // convention:
+        // if we return -1 it means that the user was going left and there were no visible columns to the left of the current one
+        // if we return cols.Count + 1 it means that the user was going right and there were no visible columns to the right of the currrent
+        private int MoveLeftRight(GridColumnStylesCollection cols, int startCol, bool goRight)
+        {
+            int i;
+            if (goRight)
+            {
+                for (i = startCol + 1; i < cols.Count; i++)
+                {
+                    // if (cols[i].Visible && cols[i].PropertyDescriptor != null)
+                    if (cols[i].PropertyDescriptor != null)
+                    {
+                        return i;
+                    }
+                }
+
+                return i;
+            }
+            else
+            {
+                for (i = startCol - 1; i >= 0; i--)
+                {
+                    // if (cols[i].Visible && cols[i].PropertyDescriptor != null)
+                    if (cols[i].PropertyDescriptor != null)
+                    {
+                        return i;
+                    }
+                }
+
+                return i;
+            }
+        }
+
+        /// <summary>
+        ///  Processes keys for grid navigation.
+        /// </summary>
+        protected bool ProcessGridKey(KeyEventArgs ke)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridKeys.TraceVerbose, "DataGridKeys: ProcessGridKey " + TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString(ke.KeyCode));
+            if (listManager == null || myGridTable == null)
+            {
+                return false;
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+            KeyEventArgs biDiKe = ke;
+            // check for Bi-Di
+            //
+            if (isRightToLeft())
+            {
+                switch (ke.KeyCode)
+                {
+                    case Keys.Left:
+                        biDiKe = new KeyEventArgs((Keys.Right | ke.Modifiers));
+                        break;
+                    case Keys.Right:
+                        biDiKe = new KeyEventArgs((Keys.Left | ke.Modifiers));
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+            int firstColumnMarkedVisible = 0;
+            int lastColumnMarkedVisible = cols.Count;
+            for (int i = 0; i < cols.Count; i++)
+            {
+                if (cols[i].PropertyDescriptor != null)
+                {
+                    firstColumnMarkedVisible = i;
+                    break;
+                }
+            }
+
+            for (int i = cols.Count - 1; i >= 0; i--)
+            {
+                if (cols[i].PropertyDescriptor != null)
+                {
+                    lastColumnMarkedVisible = i;
+                    break;
+                }
+            }
+
+            switch (biDiKe.KeyCode)
+            {
+                case Keys.Tab:
+                    return ProcessTabKey(biDiKe.KeyData);
+                case Keys.Up:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        if (biDiKe.Shift)
+                        {
+                            DataGridRow[] gridRows = DataGridRows;
+
+                            int savedCurrentRow = currentRow;
+                            CurrentRow = 0;
+
+                            ResetSelection();
+
+                            for (int i = 0; i <= savedCurrentRow; i++)
+                            {
+                                gridRows[i].Selected = true;
+                            }
+
+                            numSelectedRows = savedCurrentRow + 1;
+                            // hide the edit box
+                            //
+                            EndEdit();
+                            return true;
+                        }
+
+                        // do not make the parentRowsVisible = false;
+                        // ParentRowsVisible = false;
+                        ResetSelection();
+                        CurrentRow = 0;
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+                    else if (biDiKe.Shift)
+                    {
+                        DataGridRow[] gridRows = DataGridRows;
+                        // keep a continous selected region
+                        if (gridRows[currentRow].Selected)
+                        {
+                            if (currentRow >= 1)
+                            {
+                                if (gridRows[currentRow - 1].Selected)
+                                {
+                                    if (currentRow >= DataGridRowsLength - 1 || !gridRows[currentRow + 1].Selected)
+                                    {
+                                        numSelectedRows--;
+                                        gridRows[currentRow].Selected = false;
+                                    }
+                                }
+                                else
+                                {
+                                    numSelectedRows += gridRows[currentRow - 1].Selected ? 0 : 1;
+                                    gridRows[currentRow - 1].Selected = true;
+                                }
+
+                                CurrentRow--;
+                            }
+                        }
+                        else
+                        {
+                            numSelectedRows++;
+                            gridRows[currentRow].Selected = true;
+                            if (currentRow >= 1)
+                            {
+                                numSelectedRows += gridRows[currentRow - 1].Selected ? 0 : 1;
+                                gridRows[currentRow - 1].Selected = true;
+                                CurrentRow--;
+                            }
+                        }
+
+                        // hide the edit box:
+                        //
+                        EndEdit();
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+                    else if (biDiKe.Alt)
+                    {
+                        // will need to collapse all child table links
+                        // -1 is for all rows, and false is for collapsing the rows
+                        SetRowExpansionState(-1, false);
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+
+                    ResetSelection();
+                    CurrentRow -= 1;
+                    Edit();
+                    Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                    break;
+                case Keys.Down:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        if (biDiKe.Shift)
+                        {
+                            int savedCurrentRow = currentRow;
+                            CurrentRow = Math.Max(0, DataGridRowsLength - (policy.AllowAdd ? 2 : 1));
+                            DataGridRow[] gridRows = DataGridRows;
+
+                            ResetSelection();
+
+                            for (int i = savedCurrentRow; i <= currentRow; i++)
+                            {
+                                gridRows[i].Selected = true;
+                            }
+
+                            numSelectedRows = currentRow - savedCurrentRow + 1;
+                            // hide the edit box
+                            //
+                            EndEdit();
+                            return true;
+                        }
+
+                        // do not make the parentRowsVisible = true;
+                        // ParentRowsVisible = true;
+                        ResetSelection();
+                        CurrentRow = Math.Max(0, DataGridRowsLength - (policy.AllowAdd ? 2 : 1));
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+                    else if (biDiKe.Shift)
+                    {
+                        DataGridRow[] gridRows = DataGridRows;
+
+                        // keep a continous selected region
+                        if (gridRows[currentRow].Selected)
+                        {
+                            // -1 because we index from 0
+                            if (currentRow < DataGridRowsLength - (policy.AllowAdd ? 1 : 0) - 1)
+                            {
+                                if (gridRows[currentRow + 1].Selected)
+                                {
+                                    if (currentRow == 0 || !gridRows[currentRow - 1].Selected)
+                                    {
+                                        numSelectedRows--;
+                                        gridRows[currentRow].Selected = false;
+                                    }
+                                }
+                                else
+                                {
+                                    numSelectedRows += gridRows[currentRow + 1].Selected ? 0 : 1;
+                                    gridRows[currentRow + 1].Selected = true;
+                                }
+
+                                CurrentRow++;
+                            }
+                        }
+                        else
+                        {
+                            numSelectedRows++;
+                            gridRows[currentRow].Selected = true;
+                            // -1 because we index from 0, and -1 so this is not the last row
+                            // so it adds to -2
+                            if (currentRow < DataGridRowsLength - (policy.AllowAdd ? 1 : 0) - 1)
+                            {
+                                CurrentRow++;
+                                numSelectedRows += gridRows[currentRow].Selected ? 0 : 1;
+                                gridRows[currentRow].Selected = true;
+                            }
+                        }
+
+                        // hide the edit box:
+                        //
+                        EndEdit();
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+                    else if (biDiKe.Alt)
+                    {
+                        // will need to expande all child table links
+                        // -1 is for all rows, and true is for expanding the rows
+                        SetRowExpansionState(-1, true);
+                        return true;
+                    }
+
+                    ResetSelection();
+                    Edit();
+                    CurrentRow += 1;
+                    Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                    break;
+                case Keys.OemMinus:
+                case Keys.Subtract:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        SetRowExpansionState(-1, false);
+                        return true;
+                    }
+
+                    return false;
+                case Keys.Oemplus:
+                case Keys.Add:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (biDiKe.Control)
+                    {
+                        SetRowExpansionState(-1, true);
+                        // hide the edit box
+                        //
+                        EndEdit();
+                        return true;
+                    }
+
+                    return false;
+                case Keys.Space:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    if (biDiKe.Shift)
+                    {
+                        ResetSelection();
+                        EndEdit();
+                        DataGridRow[] gridRows = DataGridRows;
+                        gridRows[currentRow].Selected = true;
+                        numSelectedRows = 1;
+
+                        return true;
+                    }
+
+                    return false;
+                case Keys.Next:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    if (biDiKe.Shift)
+                    {
+                        int savedCurrentRow = currentRow;
+                        CurrentRow = Math.Min(DataGridRowsLength - (policy.AllowAdd ? 2 : 1), currentRow + numTotallyVisibleRows);
+
+                        DataGridRow[] gridRows = DataGridRows;
+                        for (int i = savedCurrentRow; i <= currentRow; i++)
+                        {
+                            if (!gridRows[i].Selected)
+                            {
+                                gridRows[i].Selected = true;
+                                numSelectedRows++;
+                            }
+                        }
+
+                        // hide edit box
+                        //
+                        EndEdit();
+                    }
+                    else if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        // map ctrl-pageDown to show the parentRows
+                        ParentRowsVisible = true;
+                    }
+                    else
+                    {
+                        ResetSelection();
+                        CurrentRow = Math.Min(DataGridRowsLength - (policy.AllowAdd ? 2 : 1),
+                                              CurrentRow + numTotallyVisibleRows);
+                    }
+
+                    break;
+                case Keys.Prior:
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (biDiKe.Shift)
+                    {
+                        int savedCurrentRow = currentRow;
+                        CurrentRow = Math.Max(0, CurrentRow - numTotallyVisibleRows);
+
+                        DataGridRow[] gridRows = DataGridRows;
+                        for (int i = savedCurrentRow; i >= currentRow; i--)
+                        {
+                            if (!gridRows[i].Selected)
+                            {
+                                gridRows[i].Selected = true;
+                                numSelectedRows++;
+                            }
+                        }
+
+                        // hide the edit box
+                        //
+                        EndEdit();
+                    }
+                    else if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        // map ctrl-pageUp to hide the parentRows
+                        ParentRowsVisible = false;
+                    }
+                    else
+                    {
+                        ResetSelection();
+                        CurrentRow = Math.Max(0,
+                                              CurrentRow - numTotallyVisibleRows);
+                    }
+
+                    break;
+                case Keys.Left:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    ResetSelection();
+                    if ((biDiKe.Modifiers & Keys.Modifiers) == Keys.Alt)
+                    {
+                        if (Caption.BackButtonVisible)
+                        {
+                            NavigateBack();
+                        }
+
+                        return true;
+                    }
+
+                    if ((biDiKe.Modifiers & Keys.Control) == Keys.Control)
+                    {
+                        // we should navigate to the first visible column
+                        CurrentColumn = firstColumnMarkedVisible;
+                        break;
+                    }
+
+                    if (currentCol == firstColumnMarkedVisible && currentRow != 0)
+                    {
+                        CurrentRow -= 1;
+                        int newCol = MoveLeftRight(myGridTable.GridColumnStyles, myGridTable.GridColumnStyles.Count, false);
+                        Debug.Assert(newCol != -1, "there should be at least a visible column, right?");
+                        CurrentColumn = newCol;
+                    }
+                    else
+                    {
+                        int newCol = MoveLeftRight(myGridTable.GridColumnStyles, currentCol, false);
+                        if (newCol == -1)
+                        {
+                            if (currentRow == 0)
+                            {
+                                return true;
+                            }
+                            else
+                            {
+                                // go to the previous row:
+                                CurrentRow -= 1;
+                                CurrentColumn = lastColumnMarkedVisible;
+                            }
+                        }
+                        else
+                        {
+                            CurrentColumn = newCol;
+                        }
+                    }
+
+                    break;
+                case Keys.Right:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    ResetSelection();
+                    if ((biDiKe.Modifiers & Keys.Control) == Keys.Control && !biDiKe.Alt)
+                    {
+                        // we should navigate to the last column that is marked as Visible
+                        CurrentColumn = lastColumnMarkedVisible;
+                        break;
+                    }
+
+                    if (currentCol == lastColumnMarkedVisible && currentRow != DataGridRowsLength - 1)
+                    {
+                        CurrentRow += 1;
+                        // navigate to the first visible column
+                        CurrentColumn = firstColumnMarkedVisible;
+                    }
+                    else
+                    {
+                        int newCol = MoveLeftRight(myGridTable.GridColumnStyles, currentCol, true);
+                        if (newCol == cols.Count + 1)
+                        {
+                            // navigate to the first visible column
+                            // and the next row
+                            //
+                            CurrentColumn = firstColumnMarkedVisible;
+                            CurrentRow++;
+                        }
+                        else
+                        {
+                            CurrentColumn = newCol;
+                        }
+                    }
+
+                    break;
+                case Keys.F2:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    ResetSelection();
+                    Edit();
+                    break;
+#if DEBUG
+                case Keys.F12:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    AddNewRow();
+                    break;
+#endif
+                case Keys.Home:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    ResetSelection();
+                    CurrentColumn = 0;
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        int currentRowSaved = currentRow;
+                        CurrentRow = 0;
+
+                        if (biDiKe.Shift)
+                        {
+                            // Ctrl-Shift-Home will select all the rows up to the first one
+                            DataGridRow[] gridRows = DataGridRows;
+                            for (int i = 0; i <= currentRowSaved; i++)
+                            {
+                                gridRows[i].Selected = true;
+                                numSelectedRows++;
+                            }
+
+                            // hide the edit box:
+                            EndEdit();
+                        }
+
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+
+                    Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                    break;
+                case Keys.Delete:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (policy.AllowRemove && numSelectedRows > 0)
+                    {
+#if DEBUG
+                        // when the list is empty, then the position
+                        // in the listManager is -1, and the currentPosition in the grid is 0
+                        if (ListManager != null && ListManager.Count > 0)
+                        {
+                            Debug.Assert(ListManager.Position == currentRow,
+                                            "Current row out of sync with DataSource",
+                                            "The DataSource's Position property should be mirrored by the CurrentCell.RowNumber of the DataGrid.");
+                        }
+#endif // DEBUG
+
+                        gridState[GRIDSTATE_inDeleteRow] = true;
+                        DeleteRows(localGridRows);
+                        // set the currentRow to the position in the list
+                        currentRow = listManager.Count == 0 ? 0 : listManager.Position;
+                        numSelectedRows = 0;
+                    }
+                    else
+                    {
+                        // if we did not use the the Delete key, let the dataGridTextBox use it
+                        return false;
+                    }
+
+                    break;
+                case Keys.End:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (dataGridRowsLength == 0)
+                    {
+                        return true;
+                    }
+
+                    ResetSelection();
+                    // go the the last visible column
+                    CurrentColumn = lastColumnMarkedVisible;
+
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        int savedCurrentRow = currentRow;
+                        CurrentRow = Math.Max(0, DataGridRowsLength - (policy.AllowAdd ? 2 : 1));
+
+                        if (biDiKe.Shift)
+                        {
+                            // Ctrl-Shift-Home will select all the rows up to the first one
+                            DataGridRow[] gridRows = DataGridRows;
+                            for (int i = savedCurrentRow; i <= currentRow; i++)
+                            {
+                                gridRows[i].Selected = true;
+                            }
+
+                            numSelectedRows = currentRow - savedCurrentRow + 1;
+                            // hide the edit box
+                            //
+                            EndEdit();
+                        }
+
+                        Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                        return true;
+                    }
+
+                    Debug.Assert(ListManager.Position == CurrentCell.RowNumber || listManager.Count == 0, "current row out of ssync with DataSource");
+                    break;
+                case Keys.Enter:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    ResetSelection();
+
+                    // yield the return key if there is no editing
+                    if (!gridState[GRIDSTATE_isEditing])
+                    {
+                        return false;
+                    }
+
+                    // Ctrl-Enter will call EndCurrentEdit
+                    if ((biDiKe.Modifiers & Keys.Control) != 0 && !biDiKe.Alt)
+                    {
+                        EndEdit();
+                        HandleEndCurrentEdit();
+                        Edit();                 // put the edit box on the screen
+                    }
+                    else
+                    {
+                        // Do not commit the edit, cause reseting the
+                        // current cell will do that
+                        //
+                        // CommitEdit();
+
+                        CurrentRow = currentRow + 1;
+                    }
+
+                    break;
+                case Keys.A:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    if (biDiKe.Control && !biDiKe.Alt)
+                    {
+                        DataGridRow[] gridRows = DataGridRows;
+                        for (int i = 0; i < DataGridRowsLength; i++)
+                        {
+                            if (gridRows[i] is DataGridRelationshipRow)
+                            {
+                                gridRows[i].Selected = true;
+                            }
+                        }
+
+                        numSelectedRows = DataGridRowsLength - (policy.AllowAdd ? 1 : 0);
+                        // hide the edit box
+                        //
+                        EndEdit();
+                        return true;
+                    }
+
+                    return false;
+                case Keys.Escape:
+                    gridState[GRIDSTATE_childLinkFocused] = false;
+                    ResetSelection();
+                    if (gridState[GRIDSTATE_isEditing])
+                    {
+                        // rollback
+                        AbortEdit();
+
+                        // we have to invalidate the row header ( make it display the row selector instead of the pencil )
+                        if (layout.RowHeadersVisible && currentRow > -1)
+                        {
+                            Rectangle rowHdrRect = GetRowRect(currentRow);
+                            rowHdrRect.Width = layout.RowHeaders.Width;
+                            Invalidate(rowHdrRect);
+                        }
+
+                        // now put the edit column back on the screen
+                        Edit();
+                    }
+                    else
+                    {
+                        // add this protected virtual method for the XML designer team
+                        CancelEditing();
+                        Edit();
+                        return false;
+                    }
+
+                    break;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        ///  Previews a keyboard message and returns a value indicating if the key was
+        ///  consumed.
+        /// </summary>
+        protected override bool ProcessKeyPreview(ref Message m)
+        {
+            if (m.Msg == (int)User32.WM.KEYDOWN)
+            {
+                KeyEventArgs ke = new KeyEventArgs((Keys)(unchecked((int)(long)m.WParam)) | ModifierKeys);
+                switch (ke.KeyCode)
+                {
+                    case Keys.Up:
+                    case Keys.Down:
+                    case Keys.Prior:
+                    case Keys.Next:
+                    case Keys.Right:
+                    case Keys.Left:
+                    case Keys.Tab:
+                    case Keys.Escape:
+                    case Keys.Enter:
+                    case Keys.OemMinus:
+                    case Keys.Subtract:
+                    case Keys.Oemplus:
+                    case Keys.Add:
+                    case Keys.Space:
+                    case Keys.Home:
+                    case Keys.End:
+                    case Keys.F2:
+                    case Keys.Delete:
+                    case Keys.A:
+                        return ProcessGridKey(ke);
+                }
+
+                // Ctrl-Tab will be sent as a tab paired w/ a control on the KeyUp message
+                //
+            }
+            else if (m.Msg == (int)User32.WM.KEYUP)
+            {
+                KeyEventArgs ke = new KeyEventArgs((Keys)(unchecked((int)(long)m.WParam)) | ModifierKeys);
+                if (ke.KeyCode == Keys.Tab)
+                {
+                    return ProcessGridKey(ke);
+                }
+            }
+
+            return base.ProcessKeyPreview(ref m);
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the Tab key should be processed.
+        /// </summary>
+        protected bool ProcessTabKey(Keys keyData)
+        {
+            if (listManager == null || myGridTable == null)
+            {
+                return false;
+            }
+
+            bool wasEditing = false;
+            int columnCount = myGridTable.GridColumnStyles.Count;
+            bool biDi = isRightToLeft();
+            ResetSelection();
+
+            // Try to commit changes to cell if we were editing
+            if (gridState[GRIDSTATE_isEditing])
+            {
+                wasEditing = true;
+                if (!CommitEdit())
+                {
+                    //MessageBox.Show("Could not commit changes!  Press Escape to abort edit");
+                    Edit();         // if we can't commit the value put the edit box so that the user sees where the focus is
+                    return true;
+                }
+            }
+
+            if ((keyData & Keys.Control) == Keys.Control)
+            {
+                // when the user hits ctrl-alt-tab just ignore it.
+                if ((keyData & Keys.Alt) == Keys.Alt)
+                {
+                    return true;
+                }
+
+                // navigate to the next control in the form
+                Keys ke = keyData & ~(Keys.Control);
+                EndEdit();
+
+                gridState[GRIDSTATE_editControlChanging] = true;
+                try
+                {
+                    Focus();
+                }
+                finally
+                {
+                    gridState[GRIDSTATE_editControlChanging] = false;
+                }
+
+                return base.ProcessDialogKey(ke);
+            }
+
+            // see if the child relationships can use this TAB key
+            DataGridRow[] localRows = DataGridRows;
+            GridColumnStylesCollection cols = myGridTable.GridColumnStyles;
+
+            int lastColumnMarkedVisible = 0;
+            int firstColumnMarkedVisible = cols.Count - 1;
+            //
+
+            if (localRows.Length == 0)
+            {
+                EndEdit();
+
+                return base.ProcessDialogKey(keyData);
+            }
+
+            for (int i = 0; i < cols.Count; i++)
+            {
+                // if (cols[i].Visible && cols[i].PropertyDescriptor != null) {
+                if (cols[i].PropertyDescriptor != null)
+                {
+                    firstColumnMarkedVisible = i;
+                    break;
+                }
+            }
+
+            for (int i = cols.Count - 1; i >= 0; i--)
+            {
+                // if (cols[i].Visible && cols[i].PropertyDescriptor != null) {
+                if (cols[i].PropertyDescriptor != null)
+                {
+                    lastColumnMarkedVisible = i;
+                    break;
+                }
+            }
+
+            if (CurrentColumn == lastColumnMarkedVisible)
+            {
+                if (gridState[GRIDSTATE_childLinkFocused] || (!gridState[GRIDSTATE_childLinkFocused] && (keyData & Keys.Shift) != Keys.Shift))
+                {
+                    if (localRows[CurrentRow].ProcessTabKey(keyData, layout.RowHeaders, isRightToLeft()))
+                    {
+                        if (cols.Count > 0)
+                        {
+                            cols[CurrentColumn].ConcedeFocus();
+                        }
+
+                        gridState[GRIDSTATE_childLinkFocused] = true;
+                        // let the grid regain focus
+                        // introduced because of that BeginInvoke thing in the OnLeave method....
+                        if (gridState[GRIDSTATE_canFocus] && CanFocus && !Focused)
+                        {
+                            Focus();
+                        }
+
+                        return true;
+                    }
+                }
+
+                // actually, it turns out that we should leave the
+                // control if we are in the last row
+                if ((currentRow == DataGridRowsLength - 1) && ((keyData & Keys.Shift) == 0))
+                {
+                    EndEdit();
+                    return base.ProcessDialogKey(keyData);
+                }
+            }
+
+            if (CurrentColumn == firstColumnMarkedVisible)
+            {
+                // if the childLink is focused, then navigate within the relations
+                // in the row, otherwise expand the relations list for the row above
+                if (!gridState[GRIDSTATE_childLinkFocused])
+                {
+                    if (CurrentRow != 0 && (keyData & Keys.Shift) == Keys.Shift)
+                    {
+                        if (localRows[CurrentRow - 1].ProcessTabKey(keyData, layout.RowHeaders, isRightToLeft()))
+                        {
+                            CurrentRow--;
+                            if (cols.Count > 0)
+                            {
+                                cols[CurrentColumn].ConcedeFocus();
+                            }
+
+                            gridState[GRIDSTATE_childLinkFocused] = true;
+                            // let the grid regain focus
+                            // introduced because of that BeginInvoke thing in the OnLeave method....
+                            if (gridState[GRIDSTATE_canFocus] && CanFocus && !Focused)
+                            {
+                                Focus();
+                            }
+
+                            return true;
+                        }
+                    }
+                }
+                else
+                {
+                    if (localRows[CurrentRow].ProcessTabKey(keyData, layout.RowHeaders, isRightToLeft()))
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        // we were on the firstColumn, previously the link was focused
+                        // we have to navigate to the last column
+                        gridState[GRIDSTATE_childLinkFocused] = false;
+                        CurrentColumn = lastColumnMarkedVisible;
+                        return true;
+                    }
+                }
+
+                // if we are on the first cell ( not on the addNewRow )
+                // then shift - tab should move to the next control on the form
+                if (currentRow == 0 && ((keyData & Keys.Shift) == Keys.Shift))
+                {
+                    EndEdit();
+                    return base.ProcessDialogKey(keyData);
+                }
+            }
+
+            // move
+            if ((keyData & Keys.Shift) != Keys.Shift)
+            {
+                // forward
+                if (CurrentColumn == lastColumnMarkedVisible)
+                {
+                    if (CurrentRow != DataGridRowsLength - 1)
+                    {
+                        CurrentColumn = firstColumnMarkedVisible;
+                    }
+
+                    CurrentRow += 1;
+                }
+                else
+                {
+                    int nextCol = MoveLeftRight(cols, currentCol, true);        // true for going right;
+                    Debug.Assert(nextCol < cols.Count, "we already checked that we are not at the lastColumnMarkedVisible");
+                    CurrentColumn = nextCol;
+                }
+            }
+            else
+            {
+                // backward
+                if (CurrentColumn == firstColumnMarkedVisible)
+                {
+                    if (CurrentRow != 0)
+                    {
+                        CurrentColumn = lastColumnMarkedVisible;
+                    }
+
+                    if (!gridState[GRIDSTATE_childLinkFocused])             //
+                    {
+                        CurrentRow--;
+                    }
+                }
+                else if (gridState[GRIDSTATE_childLinkFocused] && CurrentColumn == lastColumnMarkedVisible)
+                {
+                    // part deux: when we hilite the childLink and then press shift-tab, we
+                    // don't want to navigate at the second to last column
+                    InvalidateRow(currentRow);
+                    Edit();
+                }
+                else
+                {
+                    int prevCol = MoveLeftRight(cols, currentCol, false);       // false for going left
+                    Debug.Assert(prevCol != -1, "we already checked that we are not at the first columnMarked visible");
+                    CurrentColumn = prevCol;
+                }
+            }
+
+            // if we got here, then invalidate childLinkFocused
+            //
+            gridState[GRIDSTATE_childLinkFocused] = false;
+
+            // Begin another edit if we were editing before
+            if (wasEditing)
+            {
+                ResetSelection();
+                Edit();
+            }
+
+            return true;
+        }
+
+        virtual protected void CancelEditing()
+        {
+            CancelCursorUpdate();
+            // yield the escape key if there is no editing
+            // make the last row a DataGridAddNewRow
+            if (gridState[GRIDSTATE_inAddNewRow])
+            {
+                gridState[GRIDSTATE_inAddNewRow] = false;
+                DataGridRow[] localGridRows = DataGridRows;
+
+                localGridRows[DataGridRowsLength - 1] = new DataGridAddNewRow(this, myGridTable, DataGridRowsLength - 1);
+                SetDataGridRows(localGridRows, DataGridRowsLength);
+            }
+        }
+
+        internal void RecalculateFonts()
+        {
+            try
+            {
+                linkFont = new Font(Font, FontStyle.Underline);
+            }
+            catch
+            {
+            }
+
+            fontHeight = Font.Height;
+            linkFontHeight = LinkFont.Height;
+            captionFontHeight = CaptionFont.Height;
+
+            if (myGridTable == null || myGridTable.IsDefault)
+            {
+                headerFontHeight = HeaderFont.Height;
+            }
+            else
+            {
+                headerFontHeight = myGridTable.HeaderFont.Height;
+            }
+        }
+
+        // the BackButtonClicked event:
+        //
+        /// <summary>
+        ///  Occurs when the BackButton is clicked.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAction)),
+         SRDescription(nameof(SR.DataGridBackButtonClickDescr))
+        ]
+        public event EventHandler BackButtonClick
+        {
+            add => Events.AddHandler(EVENT_BACKBUTTONCLICK, value);
+            remove => Events.RemoveHandler(EVENT_BACKBUTTONCLICK, value);
+        }
+
+        // the DownButtonClick event
+        //
+        /// <summary>
+        ///  Occurs when the Down button is clicked.
+        /// </summary>
+        [
+         SRCategory(nameof(SR.CatAction)),
+         SRDescription(nameof(SR.DataGridDownButtonClickDescr))
+        ]
+        public event EventHandler ShowParentDetailsButtonClick
+        {
+            add => Events.AddHandler(EVENT_DOWNBUTTONCLICK, value);
+            remove => Events.RemoveHandler(EVENT_DOWNBUTTONCLICK, value);
+        }
+
+        private void ResetMouseState()
+        {
+            oldRow = -1;
+            gridState[GRIDSTATE_overCaption] = true;
+        }
+
+        /// <summary>
+        ///  Turns off selection for all rows that are selected.
+        /// </summary>
+        protected void ResetSelection()
+        {
+            if (numSelectedRows > 0)
+            {
+                DataGridRow[] localGridRows = DataGridRows;
+                for (int i = 0; i < DataGridRowsLength; ++i)
+                {
+                    if (localGridRows[i].Selected)
+                    {
+                        localGridRows[i].Selected = false;
+                    }
+                }
+            }
+
+            numSelectedRows = 0;
+            lastRowSelected = -1;
+        }
+
+        private void ResetParentRows()
+        {
+            parentRows.Clear();
+            originalState = null;
+            caption.BackButtonActive = caption.DownButtonActive = caption.BackButtonVisible = false;
+            caption.SetDownButtonDirection(!layout.ParentRowsVisible);
+        }
+
+        /// <summary>
+        ///  Re-initializes all UI related state.
+        /// </summary>
+        private void ResetUIState()
+        {
+            gridState[GRIDSTATE_childLinkFocused] = false;
+            ResetSelection();
+            ResetMouseState();
+            PerformLayout();
+            Invalidate();               // we want to invalidate after we set up the scrollbars
+
+            // invalidate the horizontalscrollbar and the vertical scrollbar
+            //
+            if (horizScrollBar.Visible)
+            {
+                horizScrollBar.Invalidate();
+            }
+
+            if (vertScrollBar.Visible)
+            {
+                vertScrollBar.Invalidate();
+            }
+        }
+
+        /// <summary>
+        ///  Scrolls the datagrid down an arbritrary number of rows.
+        /// </summary>
+        private void ScrollDown(int rows)
+        {
+            //Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: ScrollDown, rows = " + rows.ToString());
+            if (rows != 0)
+            {
+                ClearRegionCache();
+
+                // we should put "dataGridRowsLength -1"
+                int newFirstRow = Math.Max(0, Math.Min(firstVisibleRow + rows, DataGridRowsLength - 1));
+                int oldFirstRow = firstVisibleRow;
+                firstVisibleRow = newFirstRow;
+                vertScrollBar.Value = newFirstRow;
+                bool wasEditing = gridState[GRIDSTATE_isEditing];
+                ComputeVisibleRows();
+
+                if (gridState[GRIDSTATE_isScrolling])
+                {
+                    Edit();
+                    // isScrolling is set to TRUE when the user scrolls.
+                    // once we move the edit box, we finished processing the scroll event, so set isScrolling to FALSE
+                    // to set isScrolling to TRUE, we need another scroll event.
+                    gridState[GRIDSTATE_isScrolling] = false;
+                }
+                else
+                {
+                    EndEdit();
+                }
+
+                int deltaY = ComputeRowDelta(oldFirstRow, newFirstRow);
+                Rectangle rowsRect = layout.Data;
+                if (layout.RowHeadersVisible)
+                {
+                    rowsRect = Rectangle.Union(rowsRect, layout.RowHeaders);
+                }
+
+                RECT scrollArea = rowsRect;
+                User32.ScrollWindow(this, 0, deltaY, ref scrollArea, ref scrollArea);
+                OnScroll(EventArgs.Empty);
+
+                if (wasEditing)
+                {
+                    // invalidate the rowHeader for the
+                    InvalidateRowHeader(currentRow);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Scrolls the datagrid right an arbritrary number of columns.
+        /// </summary>
+        private void ScrollRight(int columns)
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridScrolling.TraceVerbose, "DataGridScrolling: ScrollRight, columns = " + columns.ToString(CultureInfo.InvariantCulture));
+            int newCol = firstVisibleCol + columns;
+
+            GridColumnStylesCollection gridColumns = myGridTable.GridColumnStyles;
+            int newColOffset = 0;
+            int nGridCols = gridColumns.Count;
+            int nVisibleCols = 0;
+
+            // if we try to scroll past the last totally visible column,
+            // then the toolTips will dissapear
+            if (myGridTable.IsDefault)
+            {
+                nVisibleCols = nGridCols;
+            }
+            else
+            {
+                for (int i = 0; i < nGridCols; i++)
+                {
+                    if (gridColumns[i].PropertyDescriptor != null)
+                    {
+                        nVisibleCols++;
+                    }
+                }
+            }
+
+#pragma warning disable SA1408 // Conditional expressions should declare precedence
+            if (lastTotallyVisibleCol == nVisibleCols - 1 && columns > 0 ||
+                firstVisibleCol == 0 && columns < 0 && negOffset == 0)
+#pragma warning restore SA1408 // Conditional expressions should declare precedence
+            {
+                return;
+            }
+
+            newCol = Math.Min(newCol, nGridCols - 1);
+
+            for (int i = 0; i < newCol; i++)
+            {
+                // if (gridColumns[i].Visible && gridColumns[i].PropertyDescriptor != null)
+                if (gridColumns[i].PropertyDescriptor != null)
+                {
+                    newColOffset += gridColumns[i].Width;
+                }
+            }
+
+            HorizontalOffset = newColOffset;
+        }
+
+        /// <summary>
+        ///  Scrolls a given column into visibility.
+        /// </summary>
+        private void ScrollToColumn(int targetCol)
+        {
+            // do not flush the columns to the left
+            // so, scroll only as many columns as is necessary.
+            //
+
+            int dCols = targetCol - firstVisibleCol;
+
+            if (targetCol > lastTotallyVisibleCol && lastTotallyVisibleCol != -1)
+            {
+                dCols = targetCol - lastTotallyVisibleCol;
+            }
+
+            // if only part of the currentCol is visible
+            // then we should still scroll
+            if (dCols != 0 || negOffset != 0)
+            {
+                ScrollRight(dCols);
+            }
+        }
+
+        /// <summary>
+        ///  Selects a given row
+        /// </summary>
+        public void Select(int row)
+        {
+            //
+            Debug.WriteLineIf(CompModSwitches.DataGridSelection.TraceVerbose, "Selecting row " + row.ToString(CultureInfo.InvariantCulture));
+            DataGridRow[] localGridRows = DataGridRows;
+            if (!localGridRows[row].Selected)
+            {
+                localGridRows[row].Selected = true;
+                numSelectedRows++;
+            }
+
+            // when selecting a row, hide the edit box
+            //
+            EndEdit();
+        }
+
+        // this function will pair the listManager w/ a table from the TableStylesCollection.
+        // and for each column in the TableStylesCollection will pair them w/ a propertyDescriptor
+        // from the listManager
+        //
+        // prerequisite: the current table is either the default table, or has the same name as the
+        // list in the listManager.
+        //
+        private void PairTableStylesAndGridColumns(CurrencyManager lm, DataGridTableStyle gridTable, bool forceColumnCreation)
+        {
+            PropertyDescriptorCollection props = lm.GetItemProperties();
+            GridColumnStylesCollection gridCols = gridTable.GridColumnStyles;
+
+            // ]it is possible to have a dataTable w/ an empty string for a name.
+            if (!gridTable.IsDefault && string.Compare(lm.GetListName(), gridTable.MappingName, true, CultureInfo.InvariantCulture) == 0)
+            {
+                // we will force column creation only at runtime
+                if (gridTable.GridColumnStyles.Count == 0 && !DesignMode)
+                {
+                    // we have to create some default columns for each of the propertyDescriptors
+                    //
+                    if (forceColumnCreation)
+                    {
+                        gridTable.SetGridColumnStylesCollection(lm);
+                    }
+                    else
+                    {
+                        gridTable.SetRelationsList(lm);
+                    }
+                }
+                else
+                {
+                    // it may the case that the user will have two lists w/ the same name.
+                    // When switching binding between those different lists, we need to invalidate
+                    // the propertyDescriptors from the current gridColumns
+                    //
+                    for (int i = 0; i < gridCols.Count; i++)
+                    {
+                        gridCols[i].PropertyDescriptor = null;
+                    }
+
+                    // pair the propertyDescriptor from each column to the actual property descriptor
+                    // from the listManager
+                    //
+                    for (int i = 0; i < props.Count; i++)
+                    {
+                        DataGridColumnStyle col = gridCols.MapColumnStyleToPropertyName(props[i].Name);
+                        if (col != null)
+                        {
+                            col.PropertyDescriptor = props[i];
+                        }
+                    }
+
+                    // TableStyle::SetGridColumnStylesCollection will also set the
+                    // relations list in the tableStyle.
+                    gridTable.SetRelationsList(lm);
+                }
+            }
+            else
+            {
+                // we should put an assert, that this is the default Table Style
+#if DEBUG
+                Debug.Assert(gridTable.IsDefault, "if we don't have a match, then the dataGRid should have the default table");
+#endif // DEBUG
+                gridTable.SetGridColumnStylesCollection(lm);
+                if (gridTable.GridColumnStyles.Count > 0 && gridTable.GridColumnStyles[0].Width == -1)
+                {
+#if DEBUG
+                    GridColumnStylesCollection cols = gridTable.GridColumnStyles;
+                    for (int i = 0; i < cols.Count; i++)
+                    {
+                        Debug.Assert(cols[i].Width == -1, "if one column's width is not initialized, the same should be happening for the rest of the columns");
+                    }
+#endif // DEBUG
+                    InitializeColumnWidths();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Sets the current GridTable for the DataGrid.
+        ///  This GridTable is the table which is currently
+        ///  being displayed on the grid.
+        /// </summary>
+        internal void SetDataGridTable(DataGridTableStyle newTable, bool forceColumnCreation)
+        {
+            // we have to listen to the dataGridTable for the propertyChangedEvent
+            if (myGridTable != null)
+            {
+                // unwire the propertyChanged event
+                UnWireTableStylePropChanged(myGridTable);
+
+                if (myGridTable.IsDefault)
+                {
+                    // reset the propertyDescriptors on the default table.
+                    myGridTable.GridColumnStyles.ResetPropertyDescriptors();
+
+                    // reset the relationship list from the default table
+                    myGridTable.ResetRelationsList();
+                }
+            }
+
+            myGridTable = newTable;
+
+            WireTableStylePropChanged(myGridTable);
+
+            layout.RowHeadersVisible = newTable.IsDefault ? RowHeadersVisible : newTable.RowHeadersVisible;
+
+            // we need to force the grid into the dataGridTableStyle
+            // this way the controls in the columns will be parented
+            // consider this scenario: when the user finished InitializeComponent, it added
+            // a bunch of tables. all of those tables will have the DataGrid property set to this
+            // grid. however, in InitializeComponent the tables will not have parented the
+            // edit controls w/ the grid.
+            //
+            // the code in DataGridTextBoxColumn already checks to see if the edits are parented
+            // before parenting them.
+            //
+            if (newTable != null)
+            {
+                newTable.DataGrid = this;
+            }
+
+            // pair the tableStyles and GridColumns
+            //
+            if (listManager != null)
+            {
+                PairTableStylesAndGridColumns(listManager, myGridTable, forceColumnCreation);
+            }
+
+            // reset the relations UI on the newTable
+            if (newTable != null)
+            {
+                newTable.ResetRelationsUI();
+            }
+
+            // set the isNavigating to false
+            gridState[GRIDSTATE_isNavigating] = false;
+
+            horizScrollBar.Value = 0;
+            firstVisibleRow = 0;
+            currentCol = 0;
+            // if we add a tableStyle that mapps to the
+            // current listName, then we should set the currentRow to the
+            // position in the listManager
+            if (listManager == null)
+            {
+                currentRow = 0;
+            }
+            else
+            {
+                currentRow = listManager.Position == -1 ? 0 : listManager.Position;
+            }
+
+            ResetHorizontalOffset();
+            negOffset = 0;
+            ResetUIState();
+
+            // check the hierarchy
+            checkHierarchy = true;
+        }
+
+        /// <summary>
+        ///  Scrolls the data area down to make room for the parent rows
+        ///  and lays out the different regions of the DataGrid.
+        /// </summary>
+        internal void SetParentRowsVisibility(bool visible)
+        {
+            Rectangle parentRowsRect = layout.ParentRows;
+            Rectangle underParentRows = layout.Data;
+
+            if (layout.RowHeadersVisible)
+            {
+                underParentRows.X -= isRightToLeft() ? 0 : layout.RowHeaders.Width;
+                underParentRows.Width += layout.RowHeaders.Width;
+            }
+
+            if (layout.ColumnHeadersVisible)
+            {
+                underParentRows.Y -= layout.ColumnHeaders.Height;
+                underParentRows.Height += layout.ColumnHeaders.Height;
+            }
+
+            // hide the Edit Box
+            EndEdit();
+
+            if (visible)
+            {
+                layout.ParentRowsVisible = true;
+                PerformLayout();
+                Invalidate();
+            }
+            else
+            {
+                RECT scrollRECT = new Rectangle(underParentRows.X, underParentRows.Y - layout.ParentRows.Height, underParentRows.Width, underParentRows.Height + layout.ParentRows.Height);
+
+                User32.ScrollWindow(this, 0, -parentRowsRect.Height, ref scrollRECT, ref scrollRECT);
+
+                // If the vertical scrollbar was visible before and not after
+                // the ScrollWindow call, then we will not get invalidated
+                // completely.  We need to translate the visual bounds of
+                // the scrollbar's old location up and invalidate.
+                //
+                if (vertScrollBar.Visible)
+                {
+                    Rectangle fixupRect = vertScrollBar.Bounds;
+                    fixupRect.Y -= parentRowsRect.Height;
+                    fixupRect.Height += parentRowsRect.Height;
+                    Invalidate(fixupRect);
+                }
+
+                Debug.WriteLineIf(CompModSwitches.DataGridParents.TraceVerbose, "DataGridParents: Making parent rows invisible.");
+                layout.ParentRowsVisible = false;
+                PerformLayout();
+            }
+        }
+
+        /// <summary>
+        ///  Sets whether a row is expanded or not.
+        /// </summary>
+        private void SetRowExpansionState(int row, bool expanded)
+        {
+            if (row < -1 || row > DataGridRowsLength - (policy.AllowAdd ? 2 : 1))
+            {
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+
+            DataGridRow[] localGridRows = DataGridRows;
+            if (row == -1)
+            {
+                DataGridRelationshipRow[] expandableRows = GetExpandableRows();
+                bool repositionEditControl = false;
+
+                for (int r = 0; r < expandableRows.Length; ++r)
+                {
+                    if (expandableRows[r].Expanded != expanded)
+                    {
+                        expandableRows[r].Expanded = expanded;
+                        repositionEditControl = true;
+                    }
+                }
+
+                if (repositionEditControl)
+                {
+                    // we need to reposition the edit control
+                    if (gridState[GRIDSTATE_isNavigating] || gridState[GRIDSTATE_isEditing])
+                    {
+                        ResetSelection();
+                        Edit();
+                    }
+                }
+            }
+            else if (localGridRows[row] is DataGridRelationshipRow expandableRow)
+            {
+                if (expandableRow.Expanded != expanded)
+                {
+                    // we need to reposition the edit control
+                    if (gridState[GRIDSTATE_isNavigating] || gridState[GRIDSTATE_isEditing])
+                    {
+                        ResetSelection();
+                        Edit();
+                    }
+
+                    expandableRow.Expanded = expanded;
+                }
+            }
+        }
+
+        private void ObjectSiteChange(IContainer container, IComponent component, bool site)
+        {
+            if (site)
+            {
+                if (component.Site == null)
+                {
+                    container.Add(component);
+                }
+            }
+            else
+            {
+                if (component.Site != null && component.Site.Container == container)
+                {
+                    container.Remove(component);
+                }
+            }
+        }
+
+        public void SubObjectsSiteChange(bool site)
+        {
+            DataGrid dgrid = this;
+            if (dgrid.DesignMode && dgrid.Site != null)
+            {
+                IDesignerHost host = (IDesignerHost)dgrid.Site.GetService(typeof(IDesignerHost));
+                if (host != null)
+                {
+                    DesignerTransaction trans = host.CreateTransaction();
+                    try
+                    {
+                        IContainer container = dgrid.Site.Container;
+
+                        DataGridTableStyle[] tables = new DataGridTableStyle[dgrid.TableStyles.Count];
+                        dgrid.TableStyles.CopyTo(tables, 0);
+
+                        for (int i = 0; i < tables.Length; i++)
+                        {
+                            DataGridTableStyle table = tables[i];
+                            ObjectSiteChange(container, table, site);
+
+                            DataGridColumnStyle[] columns = new DataGridColumnStyle[table.GridColumnStyles.Count];
+                            table.GridColumnStyles.CopyTo(columns, 0);
+
+                            for (int j = 0; j < columns.Length; j++)
+                            {
+                                DataGridColumnStyle column = columns[j];
+                                ObjectSiteChange(container, column, site);
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        trans.Commit();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Unselects a given row
+        /// </summary>
+        public void UnSelect(int row)
+        {
+            //
+            Debug.WriteLineIf(CompModSwitches.DataGridSelection.TraceVerbose, "DataGridSelection: Unselecting row " + row.ToString(CultureInfo.InvariantCulture));
+            DataGridRow[] localGridRows = DataGridRows;
+            if (localGridRows[row].Selected)
+            {
+                localGridRows[row].Selected = false;
+                numSelectedRows--;
+            }
+        }
+
+        /// <summary>
+        ///  Asks the cursor to update.
+        /// </summary>
+        private void UpdateListManager()
+        {
+            Debug.WriteLineIf(CompModSwitches.DataGridCursor.TraceVerbose, "DataGridCursor: Requesting EndEdit()");
+            try
+            {
+                if (listManager != null)
+                {
+                    EndEdit();
+                    listManager.EndCurrentEdit();
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        /// <summary>
+        ///  Will return the string that will be used as a delimiter between columns
+        ///  when copying rows contents to the Clipboard.
+        ///  At the moment, return "\t"
+        /// </summary>
+        protected virtual string GetOutputTextDelimiter()
+        {
+            return "\t";
+        }
+
+        /// <summary>
+        ///  The accessible object class for a DataGrid. The child accessible objects
+        ///  are accessible objects corresponding to the propertygrid entries.
+        /// </summary>
+        [ComVisible(true)]
+        internal class DataGridAccessibleObject : ControlAccessibleObject
+        {
+            /// <summary>
+            ///  Construct a PropertyGridViewAccessibleObject
+            /// </summary>
+            public DataGridAccessibleObject(DataGrid owner) : base(owner)
+            {
+            }
+
+            internal DataGrid DataGrid
+            {
+                get
+                {
+                    return (DataGrid)Owner;
+                }
+            }
+
+            private int ColumnCountPrivate
+            {
+                get
+                {
+                    return ((DataGrid)Owner).myGridTable.GridColumnStyles.Count;
+                }
+            }
+
+            private int RowCountPrivate
+            {
+                get
+                {
+                    return ((DataGrid)Owner).dataGridRows.Length;
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    // Special case: If an explicit name has been set in the AccessibleName property, use that.
+                    // Note: Any non-null value in AccessibleName overrides the default accessible name logic,
+                    // even an empty string (this is the only way to *force* the accessible name to be blank).
+                    string name = Owner.AccessibleName;
+                    if (name != null)
+                    {
+                        return name;
+                    }
+
+                    // Otherwise just return the default label string, minus any mnemonics
+                    return "DataGrid";
+                }
+
+                set
+                {
+                    // If anyone tries to set the accessible name, just cache the value in the control's
+                    // AccessibleName property. This value will then end up overriding the normal accessible
+                    // name logic, until such time as AccessibleName is set back to null.
+                    Owner.AccessibleName = value;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    AccessibleRole role = Owner.AccessibleRole;
+                    if (role != AccessibleRole.Default)
+                    {
+                        return role;
+                    }
+
+                    return AccessibleRole.Table;
+                }
+            }
+
+            public override AccessibleObject GetChild(int index)
+            {
+                DataGrid dataGrid = (DataGrid)Owner;
+
+                int cols = ColumnCountPrivate;
+                int rows = RowCountPrivate;
+
+                if (dataGrid.dataGridRows == null)
+                {
+                    dataGrid.CreateDataGridRows();
+                }
+
+                if (index < 1)
+                {
+                    return dataGrid.ParentRowsAccessibleObject;
+                }
+                else
+                {
+                    index -= 1;
+                    if (index < cols)
+                    {
+                        return dataGrid.myGridTable.GridColumnStyles[index].HeaderAccessibleObject;
+                    }
+                    else
+                    {
+                        index -= cols;
+
+                        if (index < rows)
+                        {
+                            Debug.Assert(dataGrid.dataGridRows[index].RowNumber == index, "Row number is wrong!");
+                            return dataGrid.dataGridRows[index].AccessibleObject;
+                        }
+                        else
+                        {
+                            index -= rows;
+
+                            if (dataGrid.horizScrollBar.Visible)
+                            {
+                                if (index == 0)
+                                {
+                                    return dataGrid.horizScrollBar.AccessibilityObject;
+                                }
+
+                                index--;
+                            }
+
+                            if (dataGrid.vertScrollBar.Visible)
+                            {
+                                if (index == 0)
+                                {
+                                    return dataGrid.vertScrollBar.AccessibilityObject;
+                                }
+
+                                index--;
+                            }
+
+                            int colCount = dataGrid.myGridTable.GridColumnStyles.Count;
+                            int rowCount = dataGrid.dataGridRows.Length;
+                            int currentRow = index / colCount;
+                            int currentCol = index % colCount;
+
+                            if (currentRow < dataGrid.dataGridRows.Length && currentCol < dataGrid.myGridTable.GridColumnStyles.Count)
+                            {
+                                return dataGrid.dataGridRows[currentRow].AccessibleObject.GetChild(currentCol);
+                            }
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            public override int GetChildCount()
+            {
+                int n = 1 + ColumnCountPrivate + ((DataGrid)Owner).DataGridRowsLength;
+                if (DataGrid.horizScrollBar.Visible)
+                {
+                    n++;
+                }
+
+                if (DataGrid.vertScrollBar.Visible)
+                {
+                    n++;
+                }
+
+                n += DataGrid.DataGridRows.Length * DataGrid.myGridTable.GridColumnStyles.Count;
+                return n;
+            }
+
+            public override AccessibleObject GetFocused()
+            {
+                if (DataGrid.Focused)
+                {
+                    return GetSelected();
+                }
+
+                return null;
+            }
+
+            public override AccessibleObject GetSelected()
+            {
+                if (DataGrid.DataGridRows.Length == 0 || DataGrid.myGridTable.GridColumnStyles.Count == 0)
+                {
+                    return null;
+                }
+
+                DataGridCell cell = DataGrid.CurrentCell;
+                return GetChild(1 + ColumnCountPrivate + cell.RowNumber).GetChild(cell.ColumnNumber);
+            }
+
+            public override AccessibleObject HitTest(int x, int y)
+            {
+                Point client = DataGrid.PointToClient(new Point(x, y));
+                HitTestInfo hti = DataGrid.HitTest(client.X, client.Y);
+
+                switch (hti.Type)
+                {
+                    case HitTestType.RowHeader:
+                        return GetChild(1 + ColumnCountPrivate + hti.Row);
+                    case HitTestType.Cell:
+                        return GetChild(1 + ColumnCountPrivate + hti.Row).GetChild(hti.Column);
+                    case HitTestType.ColumnHeader:
+                        return GetChild(1 + hti.Column);
+                    case HitTestType.ParentRows:
+                        return DataGrid.ParentRowsAccessibleObject;
+                    case HitTestType.None:
+                    case HitTestType.ColumnResize:
+                    case HitTestType.RowResize:
+                    case HitTestType.Caption:
+                        break;
+                }
+
+                return null;
+            }
+
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                // We're only handling FirstChild and LastChild here
+                if (GetChildCount() > 0)
+                {
+                    switch (navdir)
+                    {
+                        case AccessibleNavigation.FirstChild:
+                            return GetChild(0);
+                        case AccessibleNavigation.LastChild:
+                            return GetChild(GetChildCount() - 1);
+                    }
+                }
+
+                return null;    // Perform default behavior
+            }
+        }
+
+        // <summary>
+        //      This simple data structure holds all of the layout information
+        //      for the DataGrid.
+        // </summary>
+        internal class LayoutData
+        {
+            internal bool dirty = true;
+            // region inside the Control's borders.
+            public Rectangle Inside = Rectangle.Empty;
+
+            public Rectangle RowHeaders = Rectangle.Empty;
+
+            public Rectangle TopLeftHeader = Rectangle.Empty;
+            public Rectangle ColumnHeaders = Rectangle.Empty;
+            public Rectangle Data = Rectangle.Empty;
+
+            public Rectangle Caption = Rectangle.Empty;
+            public Rectangle ParentRows = Rectangle.Empty;
+
+            public Rectangle ResizeBoxRect = Rectangle.Empty;
+
+            public bool ColumnHeadersVisible;
+            public bool RowHeadersVisible;
+            public bool CaptionVisible;
+            public bool ParentRowsVisible;
+
+            // used for resizing.
+            public Rectangle ClientRectangle = Rectangle.Empty;
+
+            public LayoutData()
+            {
+            }
+
+            public LayoutData(LayoutData src)
+            {
+                GrabLayout(src);
+            }
+
+            private void GrabLayout(LayoutData src)
+            {
+                Inside = src.Inside;
+                TopLeftHeader = src.TopLeftHeader;
+                ColumnHeaders = src.ColumnHeaders;
+                RowHeaders = src.RowHeaders;
+                Data = src.Data;
+                Caption = src.Caption;
+                ParentRows = src.ParentRows;
+                ResizeBoxRect = src.ResizeBoxRect;
+                ColumnHeadersVisible = src.ColumnHeadersVisible;
+                RowHeadersVisible = src.RowHeadersVisible;
+                CaptionVisible = src.CaptionVisible;
+                ParentRowsVisible = src.ParentRowsVisible;
+                ClientRectangle = src.ClientRectangle;
+            }
+
+            public override string ToString()
+            {
+                StringBuilder sb = new StringBuilder(200);
+                sb.Append(base.ToString());
+                sb.Append(" { \n");
+                sb.Append("Inside = ");
+                sb.Append(Inside.ToString());
+                sb.Append('\n');
+                sb.Append("TopLeftHeader = ");
+                sb.Append(TopLeftHeader.ToString());
+                sb.Append('\n');
+                sb.Append("ColumnHeaders = ");
+                sb.Append(ColumnHeaders.ToString());
+                sb.Append('\n');
+                sb.Append("RowHeaders = ");
+                sb.Append(RowHeaders.ToString());
+                sb.Append('\n');
+                sb.Append("Data = ");
+                sb.Append(Data.ToString());
+                sb.Append('\n');
+                sb.Append("Caption = ");
+                sb.Append(Caption.ToString());
+                sb.Append('\n');
+                sb.Append("ParentRows = ");
+                sb.Append(ParentRows.ToString());
+                sb.Append('\n');
+                sb.Append("ResizeBoxRect = ");
+                sb.Append(ResizeBoxRect.ToString());
+                sb.Append('\n');
+                sb.Append("ColumnHeadersVisible = ");
+                sb.Append(ColumnHeadersVisible);
+                sb.Append('\n');
+                sb.Append("RowHeadersVisible = ");
+                sb.Append(RowHeadersVisible);
+                sb.Append('\n');
+                sb.Append("CaptionVisible = ");
+                sb.Append(CaptionVisible);
+                sb.Append('\n');
+                sb.Append("ParentRowsVisible = ");
+                sb.Append(ParentRowsVisible);
+                sb.Append('\n');
+                sb.Append("ClientRectangle = ");
+                sb.Append(ClientRectangle.ToString());
+                sb.Append(" } ");
+                return sb.ToString();
+            }
+        }
+
+        /// <summary>
+        ///  Contains information
+        ///  about the part of the <see cref='DataGrid'/> control the user
+        ///  has clicked. This class cannot be inherited.
+        /// </summary>
+        public sealed class HitTestInfo
+        {
+            internal HitTestType type = HitTestType.None;
+
+            internal int row;
+            internal int col;
+
+            /// <summary>
+            ///  Allows the <see cref='HitTestInfo'/> object to inform you the
+            ///  extent of the grid.
+            /// </summary>
+            public static readonly HitTestInfo Nowhere = new HitTestInfo();
+
+            internal HitTestInfo()
+            {
+                type = (HitTestType)0;
+                row = col = -1;
+            }
+
+            internal HitTestInfo(HitTestType type)
+            {
+                this.type = type;
+                row = col = -1;
+            }
+
+            /// <summary>
+            ///  Gets the number of the clicked column.
+            /// </summary>
+            public int Column
+            {
+                get
+                {
+                    return col;
+                }
+            }
+
+            /// <summary>
+            ///  Gets the
+            ///  number of the clicked row.
+            /// </summary>
+            public int Row
+            {
+                get
+                {
+                    return row;
+                }
+            }
+
+            /// <summary>
+            ///  Gets the part of the <see cref='DataGrid'/> control, other than the row or column, that was
+            ///  clicked.
+            /// </summary>
+            public HitTestType Type
+            {
+                get
+                {
+                    return type;
+                }
+            }
+
+            /// <summary>
+            ///  Indicates whether two objects are identical.
+            /// </summary>
+            public override bool Equals(object value)
+            {
+                if (value is HitTestInfo ci)
+                {
+                    return (type == ci.type &&
+                           row == ci.row &&
+                           col == ci.col);
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            ///  Gets the hash code for the <see cref='HitTestInfo'/> instance.
+            /// </summary>
+            public override int GetHashCode() => HashCode.Combine(type, row, col);
+
+            /// <summary>
+            ///  Gets the type, row number, and column number.
+            /// </summary>
+            public override string ToString()
+            {
+                return "{ " + ((type).ToString()) + "," + row.ToString(CultureInfo.InvariantCulture) + "," + col.ToString(CultureInfo.InvariantCulture) + "}";
+            }
+        }
+
+        /// <summary>
+        ///  Specifies the part of the <see cref='DataGrid'/>
+        ///  control the user has clicked.
+        /// </summary>
+        [Flags]
+        public enum HitTestType
+        {
+            None = 0x00000000,
+            Cell = 0x00000001,
+            ColumnHeader = 0x00000002,
+            RowHeader = 0x00000004,
+            ColumnResize = 0x00000008,
+            RowResize = 0x00000010,
+            Caption = 0x00000020,
+            ParentRows = 0x00000040
+        }
+
+        /// <summary>
+        ///  Holds policy information for what the grid can and cannot do.
+        /// </summary>
+        private class Policy
+        {
+            private bool allowAdd = true;
+            private bool allowEdit = true;
+            private bool allowRemove = true;
+
+            public Policy()
+            {
+            }
+
+            public bool AllowAdd
+            {
+                get
+                {
+                    return allowAdd;
+                }
+                set
+                {
+                    if (allowAdd != value)
+                    {
+                        allowAdd = value;
+                    }
+                }
+            }
+
+            public bool AllowEdit
+            {
+                get
+                {
+                    return allowEdit;
+                }
+                set
+                {
+                    if (allowEdit != value)
+                    {
+                        allowEdit = value;
+                    }
+                }
+            }
+
+            public bool AllowRemove
+            {
+                get
+                {
+                    return allowRemove;
+                }
+                set
+                {
+                    if (allowRemove != value)
+                    {
+                        allowRemove = value;
+                    }
+                }
+            }
+
+            // returns true if the UI needs to be updated (here because addnew has changed)
+            public bool UpdatePolicy(CurrencyManager listManager, bool gridReadOnly)
+            {
+                bool change = false;
+                // only IBindingList can have an AddNewRow
+                IBindingList bl = listManager == null ? null : listManager.List as IBindingList;
+                if (listManager == null)
+                {
+                    if (!allowAdd)
+                    {
+                        change = true;
+                    }
+
+                    allowAdd = allowEdit = allowRemove = true;
+                }
+                else
+                {
+                    if (AllowAdd != listManager.AllowAdd && !gridReadOnly)
+                    {
+                        change = true;
+                    }
+
+                    AllowAdd = listManager.AllowAdd && !gridReadOnly && bl != null && bl.SupportsChangeNotification;
+                    AllowEdit = listManager.AllowEdit && !gridReadOnly;
+                    AllowRemove = listManager.AllowRemove && !gridReadOnly && bl != null && bl.SupportsChangeNotification;     //
+                }
+
+                return change;
+            }
+        }
+
+        //
+        //  Given the x coordinate  and the Width of rectangle R1 inside rectangle rect,
+        //  this function returns the x coordinate of the rectangle that
+        //  corresponds to the Bi-Di transformation
+        //
+        private int MirrorRectangle(Rectangle R1, Rectangle rect, bool rightToLeft)
+        {
+            if (rightToLeft)
+            {
+                return rect.Right + rect.X - R1.Right;
+            }
+            else
+            {
+                return R1.X;
+            }
+        }
+
+        //
+        //  Given the x coordinate of a point inside rectangle rect,
+        //  this function returns the x coordinate of the point that
+        //  corresponds to the Bi-Di transformation
+        //
+        private int MirrorPoint(int x, Rectangle rect, bool rightToLeft)
+        {
+            if (rightToLeft)
+            {
+                return rect.Right + rect.X - x;
+            }
+            else
+            {
+                return x;
+            }
+        }
+
+        // This function will return true if the RightToLeft property of the dataGrid is
+        // set to YES
+        private bool isRightToLeft()
+        {
+            return (RightToLeft == RightToLeft.Yes);
+        }
+    }
+}
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridAddNewRow.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridAddNewRow.cs
new file mode 100644
index 00000000000..452d0fcc99b
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridAddNewRow.cs
@@ -0,0 +1,128 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Drawing;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  This class fully encapsulates the painting logic for an addnew row
+    ///  appearing in a DataGrid.
+    /// </summary>
+    internal class DataGridAddNewRow : DataGridRow
+    {
+        private bool dataBound;
+
+        public DataGridAddNewRow(DataGrid dGrid, DataGridTableStyle gridTable, int rowNum)
+            : base(dGrid, gridTable, rowNum)
+        {
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Since the DataView does not return a valid DataRow for
+        ///  a newly added row, the DataGrid sets this property to
+        ///  true to signal that the AddNewRow can safely render
+        ///  row contents and permit editing, etc because a DataRecord
+        ///  exists in the cursor that created this row.
+        /// </summary>
+        public bool DataBound
+        {
+            get
+            {
+                return dataBound;
+            }
+            set
+            {
+                dataBound = value;
+            }
+        }
+
+        public override void OnEdit()
+        {
+            if (!DataBound)
+            {
+                DataGrid.AddNewRow();
+            }
+        }
+
+        public override void OnRowLeave()
+        {
+            if (DataBound)
+            {
+                DataBound = false;
+            }
+        }
+
+        // the addNewRow has nothing to do with losing focus
+        //
+        internal override void LoseChildFocus(Rectangle rowHeader, bool alignToRight)
+        {
+        }
+
+        // the newDataRow has nothing to do with TAB keys
+        //
+        internal override bool ProcessTabKey(Keys keyData, Rectangle rowHeaders, bool alignToRight)
+        {
+            return false;
+        }
+
+        /// <summary>
+        ///  Paints the row.
+        /// </summary>
+        public override int Paint(Graphics g, Rectangle bounds, Rectangle trueRowBounds, int firstVisibleColumn, int columnCount)
+        {
+            return Paint(g, bounds, trueRowBounds, firstVisibleColumn, columnCount, false);
+        }
+
+        public override int Paint(Graphics g,
+                                  Rectangle bounds,
+                                  Rectangle trueRowBounds,
+                                  int firstVisibleColumn,
+                                  int columnCount,
+                                  bool alignToRight)
+        {
+            Rectangle dataBounds = bounds;
+            DataGridLineStyle gridStyle;
+            if (dgTable.IsDefault)
+            {
+                gridStyle = DataGrid.GridLineStyle;
+            }
+            else
+            {
+                gridStyle = dgTable.GridLineStyle;
+            }
+
+            int bWidth = DataGrid == null ? 0 : gridStyle == DataGridLineStyle.Solid ? 1 : 0;
+            dataBounds.Height -= bWidth;
+            int cx = base.PaintData(g, dataBounds, firstVisibleColumn, columnCount, alignToRight);
+
+            if (bWidth > 0)
+            {
+                PaintBottomBorder(g, bounds, cx, bWidth, alignToRight);
+            }
+
+            return cx;
+        }
+
+        protected override void PaintCellContents(Graphics g, Rectangle cellBounds, DataGridColumnStyle column,
+                                                  Brush backBr, Brush foreBrush, bool alignToRight)
+        {
+            if (DataBound)
+            {
+                CurrencyManager listManager = DataGrid.ListManager;
+                column.Paint(g, cellBounds, listManager, RowNumber, alignToRight);
+            }
+            else
+            {
+                base.PaintCellContents(g, cellBounds, column, backBr, foreBrush, alignToRight);
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridBoolColumn.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridBoolColumn.cs
new file mode 100644
index 00000000000..031fcb5a31e
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridBoolColumn.cs
@@ -0,0 +1,538 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.ComponentModel;
+using System.Drawing;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies a column in
+    ///  which each cell contains a check box for representing
+    ///  a boolean value.
+    /// </summary>
+    public class DataGridBoolColumn : DataGridColumnStyle
+    {
+        private const int idealCheckSize = 14;
+
+        private bool isEditing;
+        private bool isSelected;
+        private bool allowNull = true;
+        private int editingRow = -1;
+        private object currentValue = Convert.DBNull;
+
+        private object trueValue = true;
+        private object falseValue = false;
+        private object nullValue = Convert.DBNull;
+
+        private static readonly object EventTrueValue = new object();
+        private static readonly object EventFalseValue = new object();
+        private static readonly object EventAllowNull = new object();
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGridBoolColumn'/> class.
+        /// </summary>
+        public DataGridBoolColumn() : base() { }
+
+        /// <summary>
+        ///  Initializes a new instance of a <see cref='DataGridBoolColumn'/> with the specified <see cref='Data.DataColumn'/>.
+        /// </summary>
+        public DataGridBoolColumn(PropertyDescriptor prop)
+            : base(prop) { }
+
+        public DataGridBoolColumn(PropertyDescriptor prop, bool isDefault)
+            : base(prop, isDefault) { }
+
+        /// <summary>
+        ///  Gets or sets the actual value used when setting the
+        ///  value of the column to <see langword='true'/> .
+        /// </summary>
+        [TypeConverter(typeof(StringConverter)),
+        DefaultValue(true)]
+        public object TrueValue
+        {
+            get
+            {
+                return trueValue;
+            }
+            set
+            {
+                if (!trueValue.Equals(value))
+                {
+                    trueValue = value;
+                    OnTrueValueChanged(EventArgs.Empty);
+                    Invalidate();
+                }
+            }
+        }
+
+        public event EventHandler TrueValueChanged
+        {
+            add => Events.AddHandler(EventTrueValue, value);
+            remove => Events.RemoveHandler(EventTrueValue, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets the actual value used when setting the value of the column to
+        ///  <see langword='false'/>.
+        /// </summary>
+        [TypeConverter(typeof(StringConverter)), DefaultValue(false)]
+        public object FalseValue
+        {
+            get
+            {
+                return falseValue;
+            }
+            set
+            {
+                if (!falseValue.Equals(value))
+                {
+                    falseValue = value;
+                    OnFalseValueChanged(EventArgs.Empty);
+                    Invalidate();
+                }
+            }
+        }
+
+        public event EventHandler FalseValueChanged
+        {
+            add => Events.AddHandler(EventFalseValue, value);
+            remove => Events.RemoveHandler(EventFalseValue, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets the actual value used when setting the value of the column to
+        ///  <see langword='null'/>.
+        /// </summary>
+        [TypeConverter(typeof(StringConverter))]
+        public object NullValue
+        {
+            get
+            {
+                return nullValue;
+            }
+            set
+            {
+                if (!nullValue.Equals(value))
+                {
+                    nullValue = value;
+                    OnFalseValueChanged(EventArgs.Empty);
+                    Invalidate();
+                }
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        // when the grid is in addNewRow it means that the user did not start typing
+        // so there is no data to be pushed back into the backEnd.
+        // make isEditing false so that in the Commit call we do not do any work.
+        //
+        protected internal override void ConcedeFocus()
+        {
+            base.ConcedeFocus();
+            isSelected = false;
+            isEditing = false;
+        }
+
+        private Rectangle GetCheckBoxBounds(Rectangle bounds, bool alignToRight)
+        {
+            if (alignToRight)
+            {
+                return new Rectangle(bounds.X + ((bounds.Width - idealCheckSize) / 2),
+                                     bounds.Y + ((bounds.Height - idealCheckSize) / 2),
+                                     bounds.Width < idealCheckSize ? bounds.Width : idealCheckSize,
+                                     idealCheckSize);
+            }
+            else
+            {
+                return new Rectangle(Math.Max(0, bounds.X + ((bounds.Width - idealCheckSize) / 2)),
+                                     Math.Max(0, bounds.Y + ((bounds.Height - idealCheckSize) / 2)),
+                                     bounds.Width < idealCheckSize ? bounds.Width : idealCheckSize,
+                                     idealCheckSize);
+            }
+        }
+
+        /// <summary>
+        ///  Gets the value at the specified row.
+        /// </summary>
+        protected internal override object GetColumnValueAtRow(CurrencyManager lm, int row)
+        {
+            object baseValue = base.GetColumnValueAtRow(lm, row);
+            object value = Convert.DBNull;
+            if (baseValue.Equals(trueValue))
+            {
+                value = true;
+            }
+            else if (baseValue.Equals(falseValue))
+            {
+                value = false;
+            }
+
+            return value;
+        }
+
+        private bool IsReadOnly()
+        {
+            bool ret = ReadOnly;
+            if (DataGridTableStyle != null)
+            {
+                ret = ret || DataGridTableStyle.ReadOnly;
+                if (DataGridTableStyle.DataGrid != null)
+                {
+                    ret = ret || DataGridTableStyle.DataGrid.ReadOnly;
+                }
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        ///  Sets the value a a specified row.
+        /// </summary>
+        protected internal override void SetColumnValueAtRow(CurrencyManager lm, int row, object value)
+        {
+            object baseValue = null;
+            if (true.Equals(value))
+            {
+                baseValue = TrueValue;
+            }
+            else if (false.Equals(value))
+            {
+                baseValue = FalseValue;
+            }
+            else if (Convert.IsDBNull(value))
+            {
+                baseValue = NullValue;
+            }
+
+            currentValue = baseValue;
+            base.SetColumnValueAtRow(lm, row, baseValue);
+        }
+
+        /// <summary>
+        ///  Gets the optimum width and height of a cell given
+        ///  a specific value to contain.
+        /// </summary>
+        protected internal override Size GetPreferredSize(Graphics g, object value)
+        {
+            return new Size(idealCheckSize + 2, idealCheckSize + 2);
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  the height of a cell in a column.
+        /// </summary>
+        protected internal override int GetMinimumHeight()
+        {
+            return idealCheckSize + 2;
+        }
+
+        /// <summary>
+        ///  Gets the height used when resizing columns.
+        /// </summary>
+        protected internal override int GetPreferredHeight(Graphics g, object value)
+        {
+            return idealCheckSize + 2;
+        }
+
+        /// <summary>
+        ///  Initiates a request to interrupt an edit procedure.
+        /// </summary>
+        protected internal override void Abort(int rowNum)
+        {
+            isSelected = false;
+            isEditing = false;
+            Invalidate();
+            return;
+        }
+
+        /// <summary>
+        ///  Initiates a request to complete an editing procedure.
+        /// </summary>
+        protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+        {
+            isSelected = false;
+            // always invalidate
+            Invalidate();
+            if (!isEditing)
+            {
+                return true;
+            }
+
+            SetColumnValueAtRow(dataSource, rowNum, currentValue);
+            isEditing = false;
+            return true;
+        }
+
+        /// <summary>
+        ///  Prepares the cell for editing a value.
+        /// </summary>
+        protected internal override void Edit(CurrencyManager source,
+                                    int rowNum,
+                                    Rectangle bounds,
+                                    bool readOnly,
+                                    string displayText,
+                                    bool cellIsVisible)
+        {
+            // toggle state right now...
+            isSelected = true;
+
+            // move the focus away from the previous column and give it to the grid
+            //
+            DataGrid grid = DataGridTableStyle.DataGrid;
+            if (!grid.Focused)
+            {
+                grid.Focus();
+            }
+
+            if (!readOnly && !IsReadOnly())
+            {
+                editingRow = rowNum;
+                currentValue = GetColumnValueAtRow(source, rowNum);
+            }
+
+            base.Invalidate();
+        }
+
+        /// <summary>
+        ///  Provides a handler for determining which key was pressed, and whether to
+        ///  process it.
+        /// </summary>
+        internal override bool KeyPress(int rowNum, Keys keyData)
+        {
+            if (isSelected && editingRow == rowNum && !IsReadOnly())
+            {
+                if ((keyData & Keys.KeyCode) == Keys.Space)
+                {
+                    ToggleValue();
+                    Invalidate();
+                    return true;
+                }
+            }
+
+            return base.KeyPress(rowNum, keyData);
+        }
+
+        /// <summary>
+        ///  Indicates whether the a mouse down event occurred at the specified row, at
+        ///  the specified x and y coordinates.
+        /// </summary>
+        internal override bool MouseDown(int rowNum, int x, int y)
+        {
+            base.MouseDown(rowNum, x, y);
+            if (isSelected && editingRow == rowNum && !IsReadOnly())
+            {
+                ToggleValue();
+                Invalidate();
+                return true;
+            }
+
+            return false;
+        }
+
+        private void OnTrueValueChanged(EventArgs e)
+        {
+            if (Events[EventTrueValue] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        private void OnFalseValueChanged(EventArgs e)
+        {
+            if (Events[EventFalseValue] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        private void OnAllowNullChanged(EventArgs e)
+        {
+            if (Events[EventAllowNull] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Draws the <see cref='DataGridBoolColumn'/>
+        ///  with the given <see cref='Graphics'/>,
+        /// <see cref='Rectangle'/> and row number.
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+        {
+            Paint(g, bounds, source, rowNum, false);
+        }
+
+        /// <summary>
+        ///  Draws the <see cref='DataGridBoolColumn'/>
+        ///  with the given <see cref='Graphics'/>, <see cref='Rectangle'/>,
+        ///  row number, and alignment settings.
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+        {
+            Paint(g, bounds, source, rowNum, DataGridTableStyle.BackBrush, DataGridTableStyle.ForeBrush, alignToRight);
+        }
+
+        /// <summary>
+        ///  Draws the <see cref='DataGridBoolColumn'/> with the given <see cref='Graphics'/>, <see cref='Rectangle'/>,
+        ///  row number, <see cref='Brush'/>, and <see cref='Color'/>.
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum,
+                                     Brush backBrush, Brush foreBrush,
+                                     bool alignToRight)
+        {
+            object value = (isEditing && editingRow == rowNum) ? currentValue : GetColumnValueAtRow(source, rowNum);
+            ButtonState checkedState = ButtonState.Inactive;
+            if (!Convert.IsDBNull(value))
+            {
+                checkedState = ((bool)value ? ButtonState.Checked : ButtonState.Normal);
+            }
+
+            Rectangle box = GetCheckBoxBounds(bounds, alignToRight);
+
+            Region r = g.Clip;
+            g.ExcludeClip(box);
+
+            Brush selectionBrush = DataGridTableStyle.IsDefault ? DataGridTableStyle.DataGrid.SelectionBackBrush : DataGridTableStyle.SelectionBackBrush;
+            if (isSelected && editingRow == rowNum && !IsReadOnly())
+            {
+                g.FillRectangle(selectionBrush, bounds);
+            }
+            else
+            {
+                g.FillRectangle(backBrush, bounds);
+            }
+
+            g.Clip = r;
+
+            if (checkedState == ButtonState.Inactive)
+            {
+                ControlPaint.DrawMixedCheckBox(g, box, ButtonState.Checked);
+            }
+            else
+            {
+                ControlPaint.DrawCheckBox(g, box, checkedState);
+            }
+
+            // if the column is read only we should still show selection
+            if (IsReadOnly() && isSelected && source.Position == rowNum)
+            {
+                bounds.Inflate(-1, -1);
+                Pen pen = new Pen(selectionBrush)
+                {
+                    DashStyle = System.Drawing.Drawing2D.DashStyle.Dash
+                };
+                g.DrawRectangle(pen, bounds);
+                pen.Dispose();
+                // restore the bounds rectangle
+                bounds.Inflate(1, 1);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether null values are allowed.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(true),
+        SRDescription(nameof(SR.DataGridBoolColumnAllowNullValue))
+        ]
+        public bool AllowNull
+        {
+            get
+            {
+                return allowNull;
+            }
+            set
+            {
+                if (allowNull != value)
+                {
+                    allowNull = value;
+                    // if we do not allow null, and the gridColumn had
+                    // a null in it, discard it
+                    if (!value && Convert.IsDBNull(currentValue))
+                    {
+                        currentValue = false;
+                        Invalidate();
+                    }
+
+                    OnAllowNullChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler AllowNullChanged
+        {
+            add => Events.AddHandler(EventAllowNull, value);
+            remove => Events.RemoveHandler(EventAllowNull, value);
+        }
+
+        /// <summary>
+        ///  Enters a <see langword='null'/> into the column.
+        /// </summary>
+        protected internal override void EnterNullValue()
+        {
+            // do not throw an exception when the column is marked as readOnly or
+            // does not allowNull
+            if (!AllowNull || IsReadOnly())
+            {
+                return;
+            }
+
+            if (currentValue != Convert.DBNull)
+            {
+                currentValue = Convert.DBNull;
+                Invalidate();
+            }
+        }
+
+        private void ResetNullValue()
+        {
+            NullValue = Convert.DBNull;
+        }
+
+        private bool ShouldSerializeNullValue()
+        {
+            return nullValue != Convert.DBNull;
+        }
+
+        private void ToggleValue()
+        {
+            if (currentValue is bool && ((bool)currentValue) == false)
+            {
+                currentValue = true;
+            }
+            else
+            {
+                if (AllowNull)
+                {
+                    if (Convert.IsDBNull(currentValue))
+                    {
+                        currentValue = false;
+                    }
+                    else
+                    {
+                        currentValue = Convert.DBNull;
+                    }
+                }
+                else
+                {
+                    currentValue = false;
+                }
+            }
+
+            // we started editing
+            isEditing = true;
+            // tell the dataGrid that things are changing
+            // we put Rectangle.Empty cause toggle will invalidate the row anyhow
+            DataGridTableStyle.DataGrid.ColumnStartedEditing(Rectangle.Empty);
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCaption.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCaption.cs
new file mode 100644
index 00000000000..aacd7f25a26
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCaption.cs
@@ -0,0 +1,924 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Globalization;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a caption in the DataGrid control.
+    /// </summary>
+    internal class DataGridCaption
+    {
+        internal EventHandlerList events;
+
+        private const int xOffset = 3;
+        private const int yOffset = 1;
+        private const int textPadding = 2;
+        private const int buttonToText = 4;
+        private static readonly ColorMap[] colorMap = new ColorMap[] { new ColorMap() };
+
+        private static readonly Point minimumBounds = new Point(50, 30);
+
+        private readonly DataGrid dataGrid;
+        private bool backButtonVisible;
+        private bool downButtonVisible;
+
+        private SolidBrush backBrush = DefaultBackBrush;
+        private SolidBrush foreBrush = DefaultForeBrush;
+        private readonly Pen textBorderPen = DefaultTextBorderPen;
+
+        private string text = string.Empty;
+        private bool textBorderVisible;
+        private Font textFont;
+
+        // use the datagridFont when the textFont is not set
+        // we cache this font ( cause we have to make it bold every time we paint the caption )
+        //
+        private Font dataGridFont;
+
+        private bool backActive;
+        private bool downActive;
+        private bool backPressed;
+        private bool downPressed;
+
+        // if the downButton should point down or not
+        private bool downButtonDown;
+
+        private static Bitmap leftButtonBitmap;
+        private static Bitmap leftButtonBitmap_bidi;
+        private static Bitmap magnifyingGlassBitmap;
+
+        private Rectangle backButtonRect;
+        private Rectangle downButtonRect;
+        private Rectangle textRect;
+
+        private CaptionLocation lastMouseLocation = CaptionLocation.Nowhere;
+
+        private EventEntry eventList;
+        private static readonly object EVENT_BACKWARDCLICKED = new object();
+        private static readonly object EVENT_DOWNCLICKED = new object();
+        private static readonly object EVENT_CAPTIONCLICKED = new object();
+
+        internal DataGridCaption(DataGrid dataGrid)
+        {
+            this.dataGrid = dataGrid;
+            downButtonVisible = dataGrid.ParentRowsVisible;
+            colorMap[0].OldColor = Color.White;
+            colorMap[0].NewColor = ForeColor;
+            OnGridFontChanged();
+        }
+
+        internal void OnGridFontChanged()
+        {
+            if (dataGridFont == null || !dataGridFont.Equals(dataGrid.Font))
+            {
+                try
+                {
+                    dataGridFont = new Font(dataGrid.Font, FontStyle.Bold);
+                }
+                catch
+                {
+                }
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        internal bool BackButtonActive
+        {
+            get
+            {
+                return backActive;
+            }
+            set
+            {
+                if (backActive != value)
+                {
+                    backActive = value;
+                    InvalidateCaptionRect(backButtonRect);
+                }
+            }
+        }
+
+        internal bool DownButtonActive
+        {
+            get
+            {
+                return downActive;
+            }
+            set
+            {
+                if (downActive != value)
+                {
+                    downActive = value;
+                    InvalidateCaptionRect(downButtonRect);
+                }
+            }
+        }
+
+        internal static SolidBrush DefaultBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaption;
+            }
+        }
+
+        internal static Pen DefaultTextBorderPen
+        {
+            get
+            {
+                return new Pen(SystemColors.ActiveCaptionText);
+            }
+        }
+
+        internal static SolidBrush DefaultForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaptionText;
+            }
+        }
+
+        internal Color BackColor
+        {
+            get
+            {
+                return backBrush.Color;
+            }
+            set
+            {
+                if (!backBrush.Color.Equals(value))
+                {
+                    if (value.IsEmpty)
+                    {
+                        throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "Caption BackColor"));
+                    }
+
+                    backBrush = new SolidBrush(value);
+                    Invalidate();
+                }
+            }
+        }
+
+        internal EventHandlerList Events
+        {
+            get
+            {
+                if (events == null)
+                {
+                    events = new EventHandlerList();
+                }
+
+                return events;
+            }
+        }
+
+        internal Font Font
+        {
+            get
+            {
+                // use the dataGridFont only if the user
+                // did not set the CaptionFont
+                //
+                if (textFont == null)
+                {
+                    return dataGridFont;
+                }
+                else
+                {
+                    return textFont;
+                }
+            }
+            set
+            {
+                if (textFont == null || !textFont.Equals(value))
+                {
+                    textFont = value;
+                    // this property gets called in the constructor before dataGrid has a caption
+                    // and we don't need this special-handling then...
+                    if (dataGrid.Caption != null)
+                    {
+                        dataGrid.RecalculateFonts();
+                        dataGrid.PerformLayout();
+                        dataGrid.Invalidate(); // smaller invalidate rect?
+                    }
+                }
+            }
+        }
+
+        internal bool ShouldSerializeFont()
+        {
+            return textFont != null && !textFont.Equals(dataGridFont);
+        }
+
+        internal bool ShouldSerializeBackColor()
+        {
+            return !backBrush.Equals(DefaultBackBrush);
+        }
+
+        internal void ResetBackColor()
+        {
+            if (ShouldSerializeBackColor())
+            {
+                backBrush = DefaultBackBrush;
+                Invalidate();
+            }
+        }
+
+        internal void ResetForeColor()
+        {
+            if (ShouldSerializeForeColor())
+            {
+                foreBrush = DefaultForeBrush;
+                Invalidate();
+            }
+        }
+
+        internal bool ShouldSerializeForeColor()
+        {
+            return !foreBrush.Equals(DefaultForeBrush);
+        }
+
+        internal void ResetFont()
+        {
+            textFont = null;
+            Invalidate();
+        }
+
+        internal string Text
+        {
+            get
+            {
+                return text;
+            }
+            set
+            {
+                if (value == null)
+                {
+                    text = string.Empty;
+                }
+                else
+                {
+                    text = value;
+                }
+
+                Invalidate();
+            }
+        }
+
+        internal bool TextBorderVisible
+        {
+            get
+            {
+                return textBorderVisible;
+            }
+            set
+            {
+                textBorderVisible = value;
+                Invalidate();
+            }
+        }
+
+        internal Color ForeColor
+        {
+            get
+            {
+                return foreBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "Caption ForeColor"));
+                }
+
+                foreBrush = new SolidBrush(value);
+                colorMap[0].NewColor = ForeColor;
+                Invalidate();
+            }
+        }
+
+        internal Point MinimumBounds
+        {
+            get
+            {
+                return minimumBounds;
+            }
+        }
+
+        internal bool BackButtonVisible
+        {
+            get
+            {
+                return backButtonVisible;
+            }
+            set
+            {
+                if (backButtonVisible != value)
+                {
+                    backButtonVisible = value;
+                    Invalidate();
+                }
+            }
+        }
+
+        internal bool DownButtonVisible
+        {
+            get
+            {
+                return downButtonVisible;
+            }
+            set
+            {
+                if (downButtonVisible != value)
+                {
+                    downButtonVisible = value;
+                    Invalidate();
+                }
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        protected virtual void AddEventHandler(object key, Delegate handler)
+        {
+            // Locking 'this' here is ok since this is an internal class.
+            lock (this)
+            {
+                if (handler == null)
+                {
+                    return;
+                }
+
+                for (EventEntry e = eventList; e != null; e = e.next)
+                {
+                    if (e.key == key)
+                    {
+                        e.handler = Delegate.Combine(e.handler, handler);
+                        return;
+                    }
+                }
+
+                eventList = new EventEntry(eventList, key, handler);
+            }
+        }
+
+        /// <summary>
+        ///  Adds a listener for the BackwardClicked event.
+        /// </summary>
+        internal event EventHandler BackwardClicked
+        {
+            add => Events.AddHandler(EVENT_BACKWARDCLICKED, value);
+            remove => Events.RemoveHandler(EVENT_BACKWARDCLICKED, value);
+        }
+
+        /// <summary>
+        ///  Adds a listener for the CaptionClicked event.
+        /// </summary>
+        internal event EventHandler CaptionClicked
+        {
+            add => Events.AddHandler(EVENT_CAPTIONCLICKED, value);
+            remove => Events.RemoveHandler(EVENT_CAPTIONCLICKED, value);
+        }
+
+        internal event EventHandler DownClicked
+        {
+            add => Events.AddHandler(EVENT_DOWNCLICKED, value);
+            remove => Events.RemoveHandler(EVENT_DOWNCLICKED, value);
+        }
+
+        private void Invalidate()
+        {
+            if (dataGrid != null)
+            {
+                dataGrid.InvalidateCaption();
+            }
+        }
+
+        private void InvalidateCaptionRect(Rectangle r)
+        {
+            if (dataGrid != null)
+            {
+                dataGrid.InvalidateCaptionRect(r);
+            }
+        }
+
+        private void InvalidateLocation(CaptionLocation loc)
+        {
+            Rectangle r;
+            switch (loc)
+            {
+                case CaptionLocation.BackButton:
+                    r = backButtonRect;
+                    r.Inflate(1, 1);
+                    InvalidateCaptionRect(r);
+                    break;
+                case CaptionLocation.DownButton:
+                    r = downButtonRect;
+                    r.Inflate(1, 1);
+                    InvalidateCaptionRect(r);
+                    break;
+            }
+        }
+
+        protected void OnBackwardClicked(EventArgs e)
+        {
+            if (backActive)
+            {
+                ((EventHandler)Events[EVENT_BACKWARDCLICKED])?.Invoke(this, e);
+            }
+        }
+
+        protected void OnCaptionClicked(EventArgs e)
+        {
+            ((EventHandler)Events[EVENT_CAPTIONCLICKED])?.Invoke(this, e);
+        }
+
+        protected void OnDownClicked(EventArgs e)
+        {
+            if (downActive && downButtonVisible)
+            {
+                ((EventHandler)Events[EVENT_DOWNCLICKED])?.Invoke(this, e);
+            }
+        }
+
+        private Bitmap GetBitmap(string bitmapName)
+        {
+            try
+            {
+                return DpiHelper.GetBitmapFromIcon(typeof(DataGridCaption), bitmapName);
+            }
+            catch (Exception e)
+            {
+                Debug.Fail("Failed to load bitmap: " + bitmapName, e.ToString());
+                return null;
+            }
+        }
+
+        private Bitmap GetBackButtonBmp(bool alignRight)
+        {
+            if (alignRight)
+            {
+                if (leftButtonBitmap_bidi == null)
+                {
+                    leftButtonBitmap_bidi = GetBitmap("DataGridCaption.backarrow_bidi");
+                }
+
+                return leftButtonBitmap_bidi;
+            }
+            else
+            {
+                if (leftButtonBitmap == null)
+                {
+                    leftButtonBitmap = GetBitmap("DataGridCaption.backarrow");
+                }
+
+                return leftButtonBitmap;
+            }
+        }
+
+        private Bitmap GetDetailsBmp()
+        {
+            if (magnifyingGlassBitmap == null)
+            {
+                magnifyingGlassBitmap = GetBitmap("DataGridCaption.Details");
+            }
+
+            return magnifyingGlassBitmap;
+        }
+
+        protected virtual Delegate GetEventHandler(object key)
+        {
+            // Locking 'this' here is ok since this is an internal class.
+            lock (this)
+            {
+                for (EventEntry e = eventList; e != null; e = e.next)
+                {
+                    if (e.key == key)
+                    {
+                        return e.handler;
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        internal Rectangle GetBackButtonRect(Rectangle bounds, bool alignRight, int downButtonWidth)
+        {
+            Bitmap backButtonBmp = GetBackButtonBmp(false);
+            Size backButtonSize;
+            lock (backButtonBmp)
+            {
+                backButtonSize = backButtonBmp.Size;
+            }
+
+            return new Rectangle(bounds.Right - xOffset * 4 - downButtonWidth - backButtonSize.Width,
+                                  bounds.Y + yOffset + textPadding,
+                                  backButtonSize.Width,
+                                  backButtonSize.Height);
+        }
+
+        internal int GetDetailsButtonWidth()
+        {
+            int width = 0;
+            Bitmap detailsBmp = GetDetailsBmp();
+            lock (detailsBmp)
+            {
+                width = detailsBmp.Size.Width;
+            }
+
+            return width;
+        }
+
+        internal Rectangle GetDetailsButtonRect(Rectangle bounds, bool alignRight)
+        {
+            Size downButtonSize;
+            Bitmap detailsBmp = GetDetailsBmp();
+            lock (detailsBmp)
+            {
+                downButtonSize = detailsBmp.Size;
+            }
+
+            int downButtonWidth = downButtonSize.Width;
+            return new Rectangle(bounds.Right - xOffset * 2 - downButtonWidth,
+                                  bounds.Y + yOffset + textPadding,
+                                  downButtonWidth,
+                                  downButtonSize.Height);
+        }
+
+        /// <summary>
+        ///  Called by the dataGrid when it needs the caption
+        ///  to repaint.
+        /// </summary>
+        internal void Paint(Graphics g, Rectangle bounds, bool alignRight)
+        {
+            Size textSize = new Size((int)g.MeasureString(text, Font).Width + 2, Font.Height + 2);
+
+            downButtonRect = GetDetailsButtonRect(bounds, alignRight);
+            int downButtonWidth = GetDetailsButtonWidth();
+            backButtonRect = GetBackButtonRect(bounds, alignRight, downButtonWidth);
+
+            int backButtonArea = backButtonVisible ? backButtonRect.Width + xOffset + buttonToText : 0;
+            int downButtonArea = downButtonVisible && !dataGrid.ParentRowsIsEmpty() ? downButtonWidth + xOffset + buttonToText : 0;
+
+            int textWidthLeft = bounds.Width - xOffset - backButtonArea - downButtonArea;
+
+            textRect = new Rectangle(
+                                    bounds.X,
+                                    bounds.Y + yOffset,
+                                    Math.Min(textWidthLeft, 2 * textPadding + textSize.Width),
+                                    2 * textPadding + textSize.Height);
+
+            // align the caption text box, downButton, and backButton
+            // if the RigthToLeft property is set to true
+            if (alignRight)
+            {
+                textRect.X = bounds.Right - textRect.Width;
+                backButtonRect.X = bounds.X + xOffset * 4 + downButtonWidth;
+                downButtonRect.X = bounds.X + xOffset * 2;
+            }
+
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "text size = " + textSize.ToString());
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "downButtonWidth = " + downButtonWidth.ToString(CultureInfo.InvariantCulture));
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "textWidthLeft = " + textWidthLeft.ToString(CultureInfo.InvariantCulture));
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "backButtonRect " + backButtonRect.ToString());
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "textRect " + textRect.ToString());
+            Debug.WriteLineIf(CompModSwitches.DGCaptionPaint.TraceVerbose, "downButtonRect " + downButtonRect.ToString());
+
+            // we should use the code that is commented out
+            // with today's code, there are pixels on the backButtonRect and the downButtonRect
+            // that are getting painted twice
+            //
+            g.FillRectangle(backBrush, bounds);
+
+            if (backButtonVisible)
+            {
+                PaintBackButton(g, backButtonRect, alignRight);
+                if (backActive)
+                {
+                    if (lastMouseLocation == CaptionLocation.BackButton)
+                    {
+                        backButtonRect.Inflate(1, 1);
+                        ControlPaint.DrawBorder3D(g, backButtonRect,
+                                                  backPressed ? Border3DStyle.SunkenInner : Border3DStyle.RaisedInner);
+                    }
+                }
+            }
+
+            PaintText(g, textRect, alignRight);
+
+            if (downButtonVisible && !dataGrid.ParentRowsIsEmpty())
+            {
+                PaintDownButton(g, downButtonRect);
+                // the rules have changed, yet again.
+                // now: if we show the parent rows and the mouse is
+                // not on top of this icon, then let the icon be depressed.
+                // if the mouse is pressed over the icon, then show the icon pressed
+                // if the mouse is over the icon and not pressed, then show the icon SunkenInner;
+                //
+                if (lastMouseLocation == CaptionLocation.DownButton)
+                {
+                    downButtonRect.Inflate(1, 1);
+                    ControlPaint.DrawBorder3D(g, downButtonRect,
+                                              downPressed ? Border3DStyle.SunkenInner : Border3DStyle.RaisedInner);
+                }
+            }
+        }
+
+        private void PaintIcon(Graphics g, Rectangle bounds, Bitmap b)
+        {
+            ImageAttributes attr = new ImageAttributes();
+            attr.SetRemapTable(colorMap, ColorAdjustType.Bitmap);
+            g.DrawImage(b, bounds, 0, 0, bounds.Width, bounds.Height, GraphicsUnit.Pixel, attr);
+            attr.Dispose();
+        }
+
+        private void PaintBackButton(Graphics g, Rectangle bounds, bool alignRight)
+        {
+            Bitmap backButtonBmp = GetBackButtonBmp(alignRight);
+            lock (backButtonBmp)
+            {
+                PaintIcon(g, bounds, backButtonBmp);
+            }
+        }
+
+        private void PaintDownButton(Graphics g, Rectangle bounds)
+        {
+            Bitmap detailsBmp = GetDetailsBmp();
+            lock (detailsBmp)
+            {
+                PaintIcon(g, bounds, detailsBmp);
+            }
+        }
+
+        private void PaintText(Graphics g, Rectangle bounds, bool alignToRight)
+        {
+            Rectangle textBounds = bounds;
+
+            if (textBounds.Width <= 0 || textBounds.Height <= 0)
+            {
+                return;
+            }
+
+            if (textBorderVisible)
+            {
+                g.DrawRectangle(textBorderPen, textBounds.X, textBounds.Y, textBounds.Width - 1, textBounds.Height - 1);
+                textBounds.Inflate(-1, -1);
+            }
+
+            if (textPadding > 0)
+            {
+                Rectangle border = textBounds;
+                border.Height = textPadding;
+                g.FillRectangle(backBrush, border);
+
+                border.Y = textBounds.Bottom - textPadding;
+                g.FillRectangle(backBrush, border);
+
+                border = new Rectangle(textBounds.X, textBounds.Y + textPadding,
+                                       textPadding, textBounds.Height - 2 * textPadding);
+                g.FillRectangle(backBrush, border);
+
+                border.X = textBounds.Right - textPadding;
+                g.FillRectangle(backBrush, border);
+                textBounds.Inflate(-textPadding, -textPadding);
+            }
+
+            g.FillRectangle(backBrush, textBounds);
+
+            // Brush foreBrush = new SolidBrush(dataGrid.CaptionForeColor);
+            StringFormat format = new StringFormat();
+            if (alignToRight)
+            {
+                format.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                format.Alignment = StringAlignment.Far;
+            }
+
+            g.DrawString(text, Font, foreBrush, textBounds, format);
+            format.Dispose();
+            // foreBrush.Dispose();
+        }
+
+        private CaptionLocation FindLocation(int x, int y)
+        {
+            if (!backButtonRect.IsEmpty)
+            {
+                if (backButtonRect.Contains(x, y))
+                {
+                    return CaptionLocation.BackButton;
+                }
+            }
+
+            if (!downButtonRect.IsEmpty)
+            {
+                if (downButtonRect.Contains(x, y))
+                {
+                    return CaptionLocation.DownButton;
+                }
+            }
+
+            if (!textRect.IsEmpty)
+            {
+                if (textRect.Contains(x, y))
+                {
+                    return CaptionLocation.Text;
+                }
+            }
+
+            return CaptionLocation.Nowhere;
+        }
+
+        private bool DownButtonDown
+        {
+            get
+            {
+                return downButtonDown;
+            }
+            set
+            {
+                if (downButtonDown != value)
+                {
+                    downButtonDown = value;
+                    InvalidateLocation(CaptionLocation.DownButton);
+                }
+            }
+        }
+
+        internal bool GetDownButtonDirection()
+        {
+            return DownButtonDown;
+        }
+
+        /// <summary>
+        ///  Called by the dataGrid when the mouse is pressed
+        ///  inside the caption.
+        /// </summary>
+        internal void MouseDown(int x, int y)
+        {
+            CaptionLocation loc = FindLocation(x, y);
+            switch (loc)
+            {
+                case CaptionLocation.BackButton:
+                    backPressed = true;
+                    InvalidateLocation(loc);
+                    break;
+                case CaptionLocation.DownButton:
+                    downPressed = true;
+                    InvalidateLocation(loc);
+                    break;
+                case CaptionLocation.Text:
+                    OnCaptionClicked(EventArgs.Empty);
+                    break;
+            }
+        }
+
+        /// <summary>
+        ///  Called by the dataGrid when the mouse is released
+        ///  inside the caption.
+        /// </summary>
+        internal void MouseUp(int x, int y)
+        {
+            CaptionLocation loc = FindLocation(x, y);
+            switch (loc)
+            {
+                case CaptionLocation.DownButton:
+                    if (downPressed == true)
+                    {
+                        downPressed = false;
+                        OnDownClicked(EventArgs.Empty);
+                    }
+
+                    break;
+                case CaptionLocation.BackButton:
+                    if (backPressed == true)
+                    {
+                        backPressed = false;
+                        OnBackwardClicked(EventArgs.Empty);
+                    }
+
+                    break;
+            }
+        }
+
+        /// <summary>
+        ///  Called by the dataGrid when the mouse leaves
+        ///  the caption area.
+        /// </summary>
+        internal void MouseLeft()
+        {
+            CaptionLocation oldLoc = lastMouseLocation;
+            lastMouseLocation = CaptionLocation.Nowhere;
+            InvalidateLocation(oldLoc);
+        }
+
+        /// <summary>
+        ///  Called by the dataGrid when the mouse is
+        ///  inside the caption.
+        /// </summary>
+        internal void MouseOver(int x, int y)
+        {
+            CaptionLocation newLoc = FindLocation(x, y);
+
+            InvalidateLocation(lastMouseLocation);
+            InvalidateLocation(newLoc);
+            lastMouseLocation = newLoc;
+        }
+
+        protected virtual void RaiseEvent(object key, EventArgs e)
+        {
+            Delegate handler = GetEventHandler(key);
+            if (handler != null)
+            {
+                ((EventHandler)handler)(this, e);
+            }
+        }
+
+        protected virtual void RemoveEventHandler(object key, Delegate handler)
+        {
+            // Locking 'this' here is ok since this is an internal class.
+            lock (this)
+            {
+                if (handler == null)
+                {
+                    return;
+                }
+
+                for (EventEntry e = eventList, prev = null; e != null; prev = e, e = e.next)
+                {
+                    if (e.key == key)
+                    {
+                        e.handler = Delegate.Remove(e.handler, handler);
+                        if (e.handler == null)
+                        {
+                            if (prev == null)
+                            {
+                                eventList = e.next;
+                            }
+                            else
+                            {
+                                prev.next = e.next;
+                            }
+                        }
+
+                        return;
+                    }
+                }
+            }
+        }
+
+        protected virtual void RemoveEventHandlers()
+        {
+            eventList = null;
+        }
+
+        internal void SetDownButtonDirection(bool pointDown)
+        {
+            DownButtonDown = pointDown;
+        }
+
+        /// <summary>
+        ///  Toggles the direction the "Down Button" is pointing.
+        /// </summary>
+        internal bool ToggleDownButtonDirection()
+        {
+            DownButtonDown = !DownButtonDown;
+            return DownButtonDown;
+        }
+
+        internal enum CaptionLocation
+        {
+            Nowhere,
+            BackButton,
+            DownButton,
+            Text
+        }
+
+        private sealed class EventEntry
+        {
+            internal EventEntry next;
+            internal object key;
+            internal Delegate handler;
+
+            internal EventEntry(EventEntry next, object key, Delegate handler)
+            {
+                this.next = next;
+                this.key = key;
+                this.handler = handler;
+            }
+        }
+    }
+}
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCell.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCell.cs
new file mode 100644
index 00000000000..44d9e7ace01
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridCell.cs
@@ -0,0 +1,60 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Identifies a cell in the grid.
+    /// </summary>
+    public struct DataGridCell
+    {
+        /// <summary>
+        ///  Gets or sets the number of a column in the <see cref='DataGrid'/> control.
+        /// </summary>
+        public int ColumnNumber { get; set; }
+
+        /// <summary>
+        ///  Gets or sets the number of a row in the <see cref='DataGrid'/> control.
+        /// </summary>
+        public int RowNumber { get; set; }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGridCell'/> class.
+        /// </summary>
+        public DataGridCell(int r, int c)
+        {
+            RowNumber = r;
+            ColumnNumber = c;
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the <see cref='DataGridCell'/> is
+        ///  identical to a second <see cref='DataGridCell'/>.
+        /// </summary>
+        public override bool Equals(object o)
+        {
+            if (!(o is DataGridCell rhs))
+            {
+                return false;
+            }
+
+            return rhs.RowNumber == RowNumber && rhs.ColumnNumber == ColumnNumber;
+        }
+
+        /// <summary>
+        ///  Gets a hash value that uniquely identifies the cell.
+        /// </summary>
+        public override int GetHashCode() => HashCode.Combine(RowNumber, ColumnNumber);
+
+        /// <summary>
+        ///  Gets the row number and column number of the cell.
+        /// </summary>
+        public override string ToString()
+        {
+            return "DataGridCell {RowNumber = " + RowNumber + ", ColumnNumber = " + ColumnNumber + "}";
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridColumnStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridColumnStyle.cs
new file mode 100644
index 00000000000..0b0ff1e1627
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridColumnStyle.cs
@@ -0,0 +1,787 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the appearance and text formatting and behavior of a <see cref='DataGrid'/> control column.
+    /// </summary>
+    [ToolboxItem(false)]
+    [DesignTimeVisible(false)]
+    [DefaultProperty(nameof(HeaderText))]
+    public abstract class DataGridColumnStyle : Component, IDataGridColumnStyleEditingNotificationService
+    {
+        private HorizontalAlignment _alignment = HorizontalAlignment.Left;
+        private PropertyDescriptor _propertyDescriptor;
+        private DataGridTableStyle _dataGridTableStyle;
+        private string _mappingName = string.Empty;
+        private string _headerName = string.Empty;
+        private bool _invalid;
+        private string _nullText = SR.DataGridNullText;
+        private bool _readOnly;
+        private bool _updating;
+        internal int _width = -1;
+        private AccessibleObject _headerAccessibleObject;
+
+        private static readonly object s_alignmentEvent = new object();
+        private static readonly object s_propertyDescriptorEvent = new object();
+        private static readonly object s_headerTextEvent = new object();
+        private static readonly object s_mappingNameEvent = new object();
+        private static readonly object s_nullTextEvent = new object();
+        private static readonly object s_readOnlyEvent = new object();
+        private static readonly object s_widthEvent = new object();
+
+        /// <summary>
+        ///  In a derived class, initializes a new instance of the
+        /// <see cref='DataGridColumnStyle'/> class.
+        /// </summary>
+        public DataGridColumnStyle()
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGridColumnStyle'/>
+        ///  class with the specified <see cref='T:System.ComponentModel.PropertyDescriptor'/>.
+        /// </summary>
+        public DataGridColumnStyle(PropertyDescriptor prop) : this()
+        {
+            PropertyDescriptor = prop;
+            if (prop != null)
+            {
+                _readOnly = prop.IsReadOnly;
+            }
+        }
+
+        private protected DataGridColumnStyle(PropertyDescriptor prop, bool isDefault) : this(prop)
+        {
+#if DEBUG
+            IsDefault = isDefault;
+#endif
+            if (isDefault && prop != null)
+            {
+                // take the header name from the property name
+                _headerName = prop.Name;
+                _mappingName = prop.Name;
+            }
+        }
+
+#if DEBUG
+        internal bool IsDefault { get; }
+#endif
+
+        /// <summary>
+        ///  Gets or sets the alignment of text in a column.
+        /// </summary>
+        [SRCategory(nameof(SR.CatDisplay))]
+        [Localizable(true)]
+        [DefaultValue(HorizontalAlignment.Left)]
+        public virtual HorizontalAlignment Alignment
+        {
+            get => _alignment;
+            set
+            {
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)HorizontalAlignment.Left, (int)HorizontalAlignment.Center))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(DataGridLineStyle));
+                }
+
+                if (_alignment != value)
+                {
+                    _alignment = value;
+                    OnAlignmentChanged(EventArgs.Empty);
+                    Invalidate();
+                }
+            }
+        }
+
+        public event EventHandler AlignmentChanged
+        {
+            add => Events.AddHandler(s_alignmentEvent, value);
+            remove => Events.RemoveHandler(s_alignmentEvent, value);
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, updates the value of a specified row with
+        ///  the given text.
+        /// </summary>
+        protected internal virtual void UpdateUI(CurrencyManager source, int rowNum, string displayText)
+        {
+        }
+
+        /// <summary>
+        ///  Gets or sets the background color of the column.
+        /// </summary>
+        [Browsable(false)]
+        public AccessibleObject HeaderAccessibleObject
+        {
+            get => _headerAccessibleObject ?? (_headerAccessibleObject = CreateHeaderAccessibleObject());
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='Data.DataColumn'/> that determines the
+        ///  attributes of data displayed by the <see cref='DataGridColumnStyle'/>.
+        /// </summary>
+        [DefaultValue(null)]
+        [Browsable(false)]
+        [EditorBrowsable(EditorBrowsableState.Advanced)]
+        public virtual PropertyDescriptor PropertyDescriptor
+        {
+            get => _propertyDescriptor;
+            set
+            {
+                if (_propertyDescriptor != value)
+                {
+                    _propertyDescriptor = value;
+                    OnPropertyDescriptorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)]
+        public event EventHandler PropertyDescriptorChanged
+        {
+            add => Events.AddHandler(s_propertyDescriptorEvent, value);
+            remove => Events.RemoveHandler(s_propertyDescriptorEvent, value);
+        }
+
+        protected virtual AccessibleObject CreateHeaderAccessibleObject()
+        {
+            return new DataGridColumnHeaderAccessibleObject(this);
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, sets the <see cref='DataGrid'/>
+        ///  control that this column belongs to.
+        /// </summary>
+        protected virtual void SetDataGrid(DataGrid value)
+        {
+            SetDataGridInColumn(value);
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, sets the <see cref='DataGrid'/>
+        ///  for the column.
+        /// </summary>
+        protected virtual void SetDataGridInColumn(DataGrid value)
+        {
+            // we need to set up the PropertyDescriptor
+            if (PropertyDescriptor == null && value != null)
+            {
+                CurrencyManager lm = value.ListManager;
+                if (lm == null)
+                {
+                    return;
+                }
+
+                PropertyDescriptorCollection propCollection = lm.GetItemProperties();
+                int propCount = propCollection.Count;
+                for (int i = 0; i < propCollection.Count; i++)
+                {
+                    PropertyDescriptor prop = propCollection[i];
+                    if (!typeof(IList).IsAssignableFrom(prop.PropertyType) && prop.Name.Equals(HeaderText))
+                    {
+                        PropertyDescriptor = prop;
+                        return;
+                    }
+                }
+            }
+        }
+
+        internal void SetDataGridInternalInColumn(DataGrid value)
+        {
+            if (value == null || value.Initializing)
+            {
+                return;
+            }
+
+            SetDataGridInColumn(value);
+        }
+
+        /// <summary>
+        ///  Gets the System.Windows.Forms.DataGridTableStyle for the column.
+        /// </summary>
+        [Browsable(false)]
+        public virtual DataGridTableStyle DataGridTableStyle => _dataGridTableStyle;
+
+        internal void SetDataGridTableInColumn(DataGridTableStyle value, bool force)
+        {
+            if (_dataGridTableStyle != null && _dataGridTableStyle.Equals(value) && !force)
+            {
+                return;
+            }
+
+            if (value != null && value.DataGrid != null && !value.DataGrid.Initializing)
+            {
+                SetDataGridInColumn(value.DataGrid);
+            }
+
+            _dataGridTableStyle = value;
+        }
+
+        /// <summary>
+        ///  Gets the height of the column's font.
+        /// </summary>
+        protected int FontHeight
+        {
+            get => DataGridTableStyle?.DataGrid?.FontHeight ?? DataGridTableStyle.defaultFontHeight;
+        }
+
+        public event EventHandler FontChanged
+        {
+            add { }
+            remove { }
+        }
+
+        /// <summary>
+        ///  Gets or sets the text of the column header.
+        /// </summary>
+        [Localizable(true)]
+        [SRCategory(nameof(SR.CatDisplay))]
+        public virtual string HeaderText
+        {
+            get => _headerName;
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (!_headerName.Equals(value))
+                {
+                    _headerName = value;
+                    OnHeaderTextChanged(EventArgs.Empty);
+                    // we only invalidate columns that are visible ( ie, their propertyDescriptor is not null)
+                    if (PropertyDescriptor != null)
+                    {
+                        Invalidate();
+                    }
+                }
+            }
+        }
+
+        public event EventHandler HeaderTextChanged
+        {
+            add => Events.AddHandler(s_headerTextEvent, value);
+            remove => Events.RemoveHandler(s_headerTextEvent, value);
+        }
+
+        [Editor("System.Windows.Forms.Design.DataGridColumnStyleMappingNameEditor, " + AssemblyRef.SystemDesign, typeof(Drawing.Design.UITypeEditor))]
+        [Localizable(true)]
+        [DefaultValue("")]
+        public string MappingName
+        {
+            get => _mappingName;
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (!_mappingName.Equals(value))
+                {
+                    string originalMappingName = _mappingName;
+                    _mappingName = value;
+                    try
+                    {
+                        _dataGridTableStyle?.GridColumnStyles.CheckForMappingNameDuplicates(this);
+                    }
+                    catch
+                    {
+                        _mappingName = originalMappingName;
+                        throw;
+                    }
+
+                    OnMappingNameChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler MappingNameChanged
+        {
+            add => Events.AddHandler(s_mappingNameEvent, value);
+            remove => Events.RemoveHandler(s_mappingNameEvent, value);
+        }
+
+        /// <summary>
+        ///  Indicates whether the System.Windows.Forms.DataGridColumnStyle.HeaderText property
+        ///  should be persisted.
+        /// </summary>
+        private bool ShouldSerializeHeaderText()
+        {
+            return (_headerName.Length != 0);
+        }
+
+        /// <summary>
+        ///  Resets the System.Windows.Forms.DataGridColumnStyle.HeaderText to its default value.
+        /// </summary>
+        public void ResetHeaderText() => HeaderText = string.Empty;
+
+        /// <summary>
+        ///  Gets or sets the text that is displayed when the column contains a null
+        ///  value.
+        /// </summary>
+        [Localizable(true)]
+        [SRCategory(nameof(SR.CatDisplay))]
+        public virtual string NullText
+        {
+            get => _nullText;
+            set
+            {
+                if (_nullText != value)
+                {
+                    _nullText = value;
+                    OnNullTextChanged(EventArgs.Empty);
+                    Invalidate();
+                }
+            }
+        }
+
+        public event EventHandler NullTextChanged
+        {
+            add => Events.AddHandler(s_nullTextEvent, value);
+            remove => Events.RemoveHandler(s_nullTextEvent, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the data in the column cannot be edited.
+        /// </summary>
+        [DefaultValue(false)]
+        public virtual bool ReadOnly
+        {
+            get => _readOnly;
+            set
+            {
+                if (_readOnly != value)
+                {
+                    _readOnly = value;
+                    OnReadOnlyChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler ReadOnlyChanged
+        {
+            add => Events.AddHandler(s_readOnlyEvent, value);
+            remove => Events.RemoveHandler(s_readOnlyEvent, value);
+        }
+
+        /// <summary>
+        ///  Gets or sets the width of the column.
+        /// </summary>
+        [SRCategory(nameof(SR.CatLayout))]
+        [Localizable(true)]
+        [DefaultValue(100)]
+        public virtual int Width
+        {
+            get => _width;
+            set
+            {
+                if (_width != value)
+                {
+                    _width = value;
+                    DataGrid grid = DataGridTableStyle?.DataGrid;
+                    if (grid != null)
+                    {
+                        // rearrange the scroll bars
+                        grid.PerformLayout();
+
+                        // force the grid to repaint
+                        grid.InvalidateInside();
+                    }
+
+                    OnWidthChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler WidthChanged
+        {
+            add => Events.AddHandler(s_widthEvent, value);
+            remove => Events.RemoveHandler(s_widthEvent, value);
+        }
+
+        /// <summary>
+        ///  Suspends the painting of the column until the <see cref='EndUpdate'/>
+        ///  method is called.
+        /// </summary>
+        protected void BeginUpdate() => _updating = true;
+
+        /// <summary>
+        ///  Resumes the painting of columns suspended by calling the
+        /// <see cref='BeginUpdate'/> method.
+        /// </summary>
+        protected void EndUpdate()
+        {
+            _updating = false;
+            if (_invalid)
+            {
+                _invalid = false;
+                Invalidate();
+            }
+        }
+
+        internal virtual string GetDisplayText(object value) => value.ToString();
+
+        private void ResetNullText() => NullText = SR.DataGridNullText;
+
+        private bool ShouldSerializeNullText() => !SR.DataGridNullText.Equals(_nullText);
+
+        /// <summary>
+        ///  When overridden in a derived class, gets the optimum width and height of the
+        ///  specified value.
+        /// </summary>
+        protected internal abstract Size GetPreferredSize(Graphics g, object value);
+
+        /// <summary>
+        ///  Gets the minimum height of a row.
+        /// </summary>
+        protected internal abstract int GetMinimumHeight();
+
+        /// <summary>
+        ///  When overridden in a derived class, gets the height to be used in for
+        ///  automatically resizing columns.
+        /// </summary>
+        protected internal abstract int GetPreferredHeight(Graphics g, object value);
+
+        /// <summary>
+        ///  Gets the value in the specified row from the specified System.Windows.Forms.ListManager.
+        /// </summary>
+        protected internal virtual object GetColumnValueAtRow(CurrencyManager source, int rowNum)
+        {
+            CheckValidDataSource(source);
+            PropertyDescriptor descriptor = PropertyDescriptor;
+            if (descriptor == null)
+            {
+                throw new InvalidOperationException(SR.DataGridColumnNoPropertyDescriptor);
+            }
+
+            return descriptor.GetValue(source[rowNum]);
+        }
+
+        /// <summary>
+        ///  Redraws the column and causes a paint message to be sent to the control.
+        /// </summary>
+        protected virtual void Invalidate()
+        {
+            if (_updating)
+            {
+                _invalid = true;
+                return;
+            }
+
+            DataGridTableStyle?.InvalidateColumn(this);
+        }
+
+        /// <summary>
+        ///  Checks if the specified DataView is valid.
+        /// </summary>
+        protected void CheckValidDataSource(CurrencyManager value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            // The code may delete a gridColumn that was editing.
+            // In that case, we still have to push the value into the backend
+            // and we only need the propertyDescriptor to push the value.
+            // (take a look at gridEditAndDeleteEditColumn)
+            if (PropertyDescriptor == null)
+            {
+                throw new InvalidOperationException(string.Format(SR.DataGridColumnUnbound, HeaderText));
+            }
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, initiates a request to interrrupt an edit
+        ///  procedure.
+        /// </summary>
+        protected internal abstract void Abort(int rowNum);
+
+        /// <summary>
+        ///  When overridden in a derived class, inititates a request to complete an
+        ///  editing procedure.
+        /// </summary>
+        protected internal abstract bool Commit(CurrencyManager dataSource, int rowNum);
+
+        /// <summary>
+        ///  When overridden in a deriving class, prepares a cell for editing.
+        /// </summary>
+        protected internal virtual void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly)
+        {
+            Edit(source, rowNum, bounds, readOnly, null, true);
+        }
+
+        /// <summary>
+        ///  Prepares the cell for editing, passing the specified <see cref='Data.DataView'/>,
+        ///  row number, <see cref='Rectangle'/>, argument indicating whether
+        ///  the column is read-only, and the text to display in the new control.
+        /// </summary>
+        protected internal virtual void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText)
+        {
+            Edit(source, rowNum, bounds, readOnly, displayText, true);
+        }
+
+        /// <summary>
+        ///  When overridden in a deriving class, prepares a cell for editing.
+        /// </summary>
+        protected internal abstract void Edit(CurrencyManager source, int rowNum, Rectangle bounds, bool readOnly, string displayText, bool cellIsVisible);
+
+        /// <summary>
+        ///  Indicates whether the a mouse down event occurred at the specified row, at
+        ///  the specified x and y coordinates.
+        /// </summary>
+        internal virtual bool MouseDown(int rowNum, int x, int y)
+        {
+            return false;
+        }
+
+        /// <summary>
+        ///  When overriden in a derived class, enters a <see cref='T:System.DBNull.Value' qualify='true'/>
+        ///  into the column.
+        /// </summary>
+        protected internal virtual void EnterNullValue()
+        {
+        }
+
+        /// <summary>
+        ///  Provides a handler for determining which key was pressed, and whether to
+        ///  process it.
+        /// </summary>
+        internal virtual bool KeyPress(int rowNum, Keys keyData)
+        {
+            // if this is read only then do not do anything
+            if (ReadOnly || (DataGridTableStyle != null && DataGridTableStyle.DataGrid != null && DataGridTableStyle.DataGrid.ReadOnly))
+            {
+                return false;
+            }
+
+            if (keyData == (Keys.Control | Keys.NumPad0) || keyData == (Keys.Control | Keys.D0))
+            {
+                EnterNullValue();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, directs the column to concede focus with
+        ///  an appropriate action.
+        /// </summary>
+        protected internal virtual void ConcedeFocus()
+        {
+        }
+
+        /// <summary>
+        ///  Paints the a <see cref='DataGridColumnStyle'/> with the specified
+        /// <see cref='Graphics'/>, <see cref='Rectangle'/>,
+        ///  System.Windows.Forms.CurrencyManager, and row number.
+        /// </summary>
+        protected internal abstract void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum);
+
+        /// <summary>
+        ///  When overridden in a derived class, paints a <see cref='DataGridColumnStyle'/>
+        ///  with the specified <see cref='Graphics'/>, <see cref='Rectangle'/>,
+        ///  see Rectangle, row number, and alignment.
+        /// </summary>
+        protected internal abstract void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight);
+
+        /// <summary>
+        ///  Paints a <see cref='DataGridColumnStyle'/> with the specified <see cref='Graphics'/>, <see cref='Rectangle'/>, see System.Data.DataView, row number, background color, foreground color, and alignment.
+        /// </summary>
+        protected internal virtual void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum,
+                                    Brush backBrush, Brush foreBrush, bool alignToRight)
+        {
+            Paint(g, bounds, source, rowNum, alignToRight);
+        }
+
+        private void OnPropertyDescriptorChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_propertyDescriptorEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnAlignmentChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_alignmentEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnHeaderTextChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_headerTextEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnMappingNameChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_mappingNameEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnReadOnlyChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_readOnlyEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnNullTextChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_nullTextEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        private void OnWidthChanged(EventArgs e)
+        {
+            EventHandler eh = Events[s_widthEvent] as EventHandler;
+            eh?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Sets the value in a specified row with the value from a specified see DataView.
+        /// </summary>
+        protected internal virtual void SetColumnValueAtRow(CurrencyManager source, int rowNum, object value)
+        {
+            CheckValidDataSource(source);
+            PropertyDescriptor descriptor = PropertyDescriptor;
+            if (descriptor == null)
+            {
+                throw new InvalidOperationException(SR.DataGridColumnNoPropertyDescriptor);
+            }
+
+            if (source.Position != rowNum)
+            {
+                throw new ArgumentException(SR.DataGridColumnListManagerPosition, nameof(rowNum));
+            }
+
+            if (source[rowNum] is IEditableObject editableObject)
+            {
+                editableObject.BeginEdit();
+            }
+
+            descriptor.SetValue(source[rowNum], value);
+        }
+
+        protected internal virtual void ColumnStartedEditing(Control editingControl)
+        {
+            DataGridTableStyle?.DataGrid?.ColumnStartedEditing(editingControl);
+        }
+
+        void IDataGridColumnStyleEditingNotificationService.ColumnStartedEditing(Control editingControl)
+        {
+            ColumnStartedEditing(editingControl);
+        }
+
+        protected internal virtual void ReleaseHostedControl()
+        {
+        }
+
+        protected class CompModSwitches
+        {
+            private static TraceSwitch dgEditColumnEditing;
+
+            public static TraceSwitch DGEditColumnEditing
+            {
+                get
+                {
+                    if (dgEditColumnEditing == null)
+                    {
+                        dgEditColumnEditing = new TraceSwitch("DGEditColumnEditing", "Editing related tracing");
+                    }
+
+                    return dgEditColumnEditing;
+                }
+            }
+        }
+
+        [ComVisible(true)]
+        protected class DataGridColumnHeaderAccessibleObject : AccessibleObject
+        {
+            public DataGridColumnHeaderAccessibleObject(DataGridColumnStyle owner) : this()
+            {
+                Debug.Assert(owner != null, "DataGridColumnHeaderAccessibleObject must have a valid owner DataGridColumn");
+                Owner = owner;
+            }
+
+            public DataGridColumnHeaderAccessibleObject() : base()
+            {
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    // we need to get the width and the X coordinate of this column on the screen
+                    // we can't just cache this, cause the column may be moved in the collection
+                    if (Owner.PropertyDescriptor == null)
+                    {
+                        return Rectangle.Empty;
+                    }
+
+                    DataGrid dg = DataGrid;
+                    if (dg.DataGridRowsLength == 0)
+                    {
+                        return Rectangle.Empty;
+                    }
+
+                    // We need to find this column's offset in the gridColumnCollection.
+                    GridColumnStylesCollection cols = Owner._dataGridTableStyle.GridColumnStyles;
+                    int offset = -1;
+                    for (int i = 0; i < cols.Count; i++)
+                    {
+                        if (cols[i] == Owner)
+                        {
+                            offset = i;
+                            break;
+                        }
+                    }
+
+                    Debug.Assert(offset >= 0, "this column must be in a collection, otherwise its bounds are useless");
+                    Rectangle rect = dg.GetCellBounds(0, offset);
+                    // Now add the Y coordinate of the datagrid.Layout.Data.
+                    // It should be the same as dataGrid.Layout.ColumnHeaders
+                    rect.Y = dg.GetColumnHeadersRect().Y;
+                    return dg.RectangleToScreen(rect);
+                }
+            }
+
+            public override string Name => Owner._headerName;
+
+            protected DataGridColumnStyle Owner { get; }
+
+            public override AccessibleObject Parent => DataGrid.AccessibilityObject;
+
+            private DataGrid DataGrid => Owner._dataGridTableStyle.dataGrid;
+
+            public override AccessibleRole Role => AccessibleRole.ColumnHeader;
+
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                    case AccessibleNavigation.Down:
+                        return Parent.GetChild(1 + Owner._dataGridTableStyle.GridColumnStyles.IndexOf(Owner) + 1);
+                    case AccessibleNavigation.Up:
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        return Parent.GetChild(1 + Owner._dataGridTableStyle.GridColumnStyles.IndexOf(Owner) - 1);
+                }
+
+                return null;
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridLineStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridLineStyle.cs
new file mode 100644
index 00000000000..6464f1606ae
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridLineStyle.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the style of gridlines in a <see cref='DataGrid'/>.
+    /// </summary>
+    public enum DataGridLineStyle
+    {
+        /// <summary>
+        ///  No gridlines between cells.
+        /// </summary>
+        None,
+
+        /// <summary>
+        ///  Solid gridlines between cells.
+        /// </summary>
+        Solid
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRows.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRows.cs
new file mode 100644
index 00000000000..89d16919e76
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRows.cs
@@ -0,0 +1,1410 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace System.Windows.Forms
+{
+    internal class DataGridParentRows
+    {
+        // siting
+        //
+        private readonly DataGrid dataGrid;
+
+        // ui
+        //
+        // private Color backColor = DataGrid.defaultParentRowsBackColor;
+        // private Color foreColor = DataGrid.defaultParentRowsForeColor;
+
+        private SolidBrush backBrush = DataGrid.DefaultParentRowsBackBrush;
+        private SolidBrush foreBrush = DataGrid.DefaultParentRowsForeBrush;
+
+        private readonly int borderWidth = 1;
+        // private Color borderColor = SystemColors.WindowFrame;
+        private Brush borderBrush = new SolidBrush(SystemColors.WindowFrame);
+
+        private static Bitmap rightArrow;
+        private static Bitmap leftArrow;
+
+        private readonly ColorMap[] colorMap = new ColorMap[] { new ColorMap() };
+
+        // private bool gridLineDots = false;
+        // private Color gridLineColor = SystemColors.Control;
+        // private Brush gridLineBrush = SystemBrushes.Control;
+        private readonly Pen gridLinePen = SystemPens.Control;
+
+        private int totalHeight;
+        private int textRegionHeight;
+
+        // now that we have left and right arrows, we also have layout
+        private readonly Layout layout = new Layout();
+
+        // mouse info
+        //
+        // private bool overLeftArrow = false;
+        // private bool overRightArrow = false;
+        private bool downLeftArrow;
+        private bool downRightArrow;
+
+        // a horizOffset of 0 means that the layout for the parent
+        // rows is left aligned.
+        // a horizOffset of 1 means that the leftmost unit of information ( let it be a
+        // table name, a column name or a column value ) is not visible.
+        // a horizOffset of 2 means that the leftmost 2 units of information are not visible, and so on
+        //
+        private int horizOffset;
+
+        // storage for parent row states
+        //
+        private readonly ArrayList parents = new ArrayList();
+        private int parentsCount;
+        private readonly ArrayList rowHeights = new ArrayList();
+        AccessibleObject accessibleObject;
+
+        internal DataGridParentRows(DataGrid dataGrid)
+        {
+            colorMap[0].OldColor = Color.Black;
+            this.dataGrid = dataGrid;
+            // UpdateGridLinePen();
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        public AccessibleObject AccessibleObject
+        {
+            get
+            {
+                if (accessibleObject == null)
+                {
+                    accessibleObject = new DataGridParentRowsAccessibleObject(this);
+                }
+
+                return accessibleObject;
+            }
+        }
+
+        internal Color BackColor
+        {
+            get
+            {
+                return backBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "Parent Rows BackColor"));
+                }
+
+                if (value != backBrush.Color)
+                {
+                    backBrush = new SolidBrush(value);
+                    Invalidate();
+                }
+            }
+        }
+
+        internal SolidBrush BackBrush
+        {
+            get
+            {
+                return backBrush;
+            }
+            set
+            {
+                if (value != backBrush)
+                {
+                    CheckNull(value, "BackBrush");
+                    backBrush = value;
+                    Invalidate();
+                }
+            }
+        }
+
+        internal SolidBrush ForeBrush
+        {
+            get
+            {
+                return foreBrush;
+            }
+            set
+            {
+                if (value != foreBrush)
+                {
+                    CheckNull(value, "BackBrush");
+                    foreBrush = value;
+                    Invalidate();
+                }
+            }
+        }
+
+        // since the layout of the parentRows is computed on every paint message,
+        // we can actually return true ClientRectangle coordinates
+        internal Rectangle GetBoundsForDataGridStateAccesibility(DataGridState dgs)
+        {
+            Rectangle ret = Rectangle.Empty;
+            int rectY = 0;
+            for (int i = 0; i < parentsCount; i++)
+            {
+                int height = (int)rowHeights[i];
+                if (parents[i] == dgs)
+                {
+                    ret.X = layout.leftArrow.IsEmpty ? layout.data.X : layout.leftArrow.Right;
+                    ret.Height = height;
+                    ret.Y = rectY;
+                    ret.Width = layout.data.Width;
+                    return ret;
+                }
+
+                rectY += height;
+            }
+
+            return ret;
+        }
+
+        /*
+        internal Color BorderColor {
+            get {
+                return borderColor;
+            }
+            set {
+                if (value != borderColor) {
+                    borderColor = value;
+                    Invalidate();
+                }
+            }
+        }
+        */
+
+        internal Brush BorderBrush
+        {
+            get
+            {
+                return borderBrush;
+            }
+            set
+            {
+                if (value != borderBrush)
+                {
+                    borderBrush = value;
+                    Invalidate();
+                }
+            }
+        }
+
+        /*
+        internal Brush GridLineBrush {
+            get {
+                return gridLineBrush;
+            }
+            set {
+                if (value != gridLineBrush) {
+                    gridLineBrush = value;
+                    UpdateGridLinePen();
+                    Invalidate();
+                }
+            }
+        }
+
+        internal bool GridLineDots {
+            get {
+                return gridLineDots;
+            }
+            set {
+                if (gridLineDots != value) {
+                    gridLineDots = value;
+                    UpdateGridLinePen();
+                    Invalidate();
+                }
+            }
+        }
+        */
+
+        internal int Height
+        {
+            get
+            {
+                return totalHeight;
+            }
+        }
+
+        internal Color ForeColor
+        {
+            get
+            {
+                return foreBrush.Color;
+            }
+            set
+            {
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, "Parent Rows ForeColor"));
+                }
+
+                if (value != foreBrush.Color)
+                {
+                    foreBrush = new SolidBrush(value);
+                    Invalidate();
+                }
+            }
+        }
+
+        internal bool Visible
+        {
+            get
+            {
+                return dataGrid.ParentRowsVisible;
+            }
+            set
+            {
+                dataGrid.ParentRowsVisible = value;
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Adds a DataGridState object to the top of the list of parents.
+        /// </summary>
+        internal void AddParent(DataGridState dgs)
+        {
+            CurrencyManager childDataSource = (CurrencyManager)dataGrid.BindingContext[dgs.DataSource, dgs.DataMember];
+            parents.Add(dgs);
+            SetParentCount(parentsCount + 1);
+            Debug.Assert(GetTopParent() != null, "we should have a parent at least");
+        }
+
+        internal void Clear()
+        {
+            for (int i = 0; i < parents.Count; i++)
+            {
+                DataGridState dgs = parents[i] as DataGridState;
+                dgs.RemoveChangeNotification();
+            }
+
+            parents.Clear();
+            rowHeights.Clear();
+            totalHeight = 0;
+            SetParentCount(0);
+        }
+
+        internal void SetParentCount(int count)
+        {
+            parentsCount = count;
+            dataGrid.Caption.BackButtonVisible = (parentsCount > 0) && (dataGrid.AllowNavigation);
+        }
+
+        internal void CheckNull(object value, string propName)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(propName));
+            }
+        }
+
+        internal void Dispose()
+        {
+            gridLinePen.Dispose();
+        }
+
+        /// <summary>
+        ///  Retrieves the top most parent in the list of parents.
+        /// </summary>
+        internal DataGridState GetTopParent()
+        {
+            if (parentsCount < 1)
+            {
+                return null;
+            }
+
+            return (DataGridState)(((ICloneable)(parents[parentsCount - 1])).Clone());
+        }
+
+        /// <summary>
+        ///  Determines if there are any parent rows contained in this object.
+        /// </summary>
+        internal bool IsEmpty()
+        {
+            return parentsCount == 0;
+        }
+
+        /// <summary>
+        ///  Similar to GetTopParent() but also removes it.
+        /// </summary>
+        internal DataGridState PopTop()
+        {
+            if (parentsCount < 1)
+            {
+                return null;
+            }
+
+            SetParentCount(parentsCount - 1);
+            DataGridState ret = (DataGridState)parents[parentsCount];
+            ret.RemoveChangeNotification();
+            parents.RemoveAt(parentsCount);
+            return ret;
+        }
+
+        internal void Invalidate()
+        {
+            if (dataGrid != null)
+            {
+                dataGrid.InvalidateParentRows();
+            }
+        }
+
+        internal void InvalidateRect(Rectangle rect)
+        {
+            if (dataGrid != null)
+            {
+                Rectangle r = new Rectangle(rect.X, rect.Y, rect.Width + borderWidth, rect.Height + borderWidth);
+                dataGrid.InvalidateParentRowsRect(r);
+            }
+        }
+
+        // called from DataGrid::OnLayout
+        internal void OnLayout()
+        {
+            if (parentsCount == rowHeights.Count)
+            {
+                return;
+            }
+
+            int height = 0;
+            if (totalHeight == 0)
+            {
+                totalHeight += 2 * borderWidth;
+            }
+
+            // figure out how tall each row's text will be
+            //
+            textRegionHeight = (int)dataGrid.Font.Height + 2;
+
+            // make the height of the Column.Font count for the height
+            // of the parentRows;
+            //
+            // if the user wants to programatically
+            // navigate to a relation in the constructor of the form
+            // ( ie, when the form does not process PerformLayout )
+            // the grid will receive an OnLayout message when there is more
+            // than one parent in the grid
+            if (parentsCount > rowHeights.Count)
+            {
+                Debug.Assert(parentsCount == rowHeights.Count + 1 || rowHeights.Count == 0, "see comment above for more info");
+                int rowHeightsCount = rowHeights.Count;
+                for (int i = rowHeightsCount; i < parentsCount; i++)
+                {
+                    DataGridState dgs = (DataGridState)parents[i];
+                    GridColumnStylesCollection cols = dgs.GridColumnStyles;
+
+                    int colsHeight = 0;
+
+                    for (int j = 0; j < cols.Count; j++)
+                    {
+                        colsHeight = Math.Max(colsHeight, cols[j].GetMinimumHeight());
+                    }
+
+                    height = Math.Max(colsHeight, textRegionHeight);
+
+                    // the height of the bottom border
+                    height++;
+                    rowHeights.Add(height);
+
+                    totalHeight += height;
+                }
+            }
+            else
+            {
+                Debug.Assert(parentsCount == rowHeights.Count - 1, "we do layout only for push/popTop");
+                if (parentsCount == 0)
+                {
+                    totalHeight = 0;
+                }
+                else
+                {
+                    totalHeight -= (int)rowHeights[rowHeights.Count - 1];
+                }
+
+                rowHeights.RemoveAt(rowHeights.Count - 1);
+            }
+        }
+
+        private int CellCount()
+        {
+            int cellCount = 0;
+            cellCount = ColsCount();
+
+            if (dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.TableName ||
+                dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.Both)
+            {
+                cellCount++;
+            }
+
+            return cellCount;
+        }
+
+        private void ResetMouseInfo()
+        {
+            // overLeftArrow = false;
+            // overRightArrow = false;
+            downLeftArrow = false;
+            downRightArrow = false;
+        }
+
+        private void LeftArrowClick(int cellCount)
+        {
+            if (horizOffset > 0)
+            {
+                ResetMouseInfo();
+                horizOffset -= 1;
+                Invalidate();
+            }
+            else
+            {
+                ResetMouseInfo();
+                InvalidateRect(layout.leftArrow);
+            }
+        }
+
+        private void RightArrowClick(int cellCount)
+        {
+            if (horizOffset < cellCount - 1)
+            {
+                ResetMouseInfo();
+                horizOffset += 1;
+                Invalidate();
+            }
+            else
+            {
+                ResetMouseInfo();
+                InvalidateRect(layout.rightArrow);
+            }
+        }
+
+        // the only mouse clicks that are handled are
+        // the mouse clicks on the LeftArrow and RightArrow
+        //
+        internal void OnMouseDown(int x, int y, bool alignToRight)
+        {
+            if (layout.rightArrow.IsEmpty)
+            {
+                Debug.Assert(layout.leftArrow.IsEmpty, "we can't have the leftArrow w/o the rightArrow");
+                return;
+            }
+
+            int cellCount = CellCount();
+
+            if (layout.rightArrow.Contains(x, y))
+            {
+                // draw a nice sunken border around the right arrow area
+                // we want to keep a cell on the screen
+
+                downRightArrow = true;
+
+                if (alignToRight)
+                {
+                    LeftArrowClick(cellCount);
+                }
+                else
+                {
+                    RightArrowClick(cellCount);
+                }
+            }
+            else if (layout.leftArrow.Contains(x, y))
+            {
+                downLeftArrow = true;
+
+                if (alignToRight)
+                {
+                    RightArrowClick(cellCount);
+                }
+                else
+                {
+                    LeftArrowClick(cellCount);
+                }
+            }
+            else
+            {
+                if (downLeftArrow)
+                {
+                    downLeftArrow = false;
+                    InvalidateRect(layout.leftArrow);
+                }
+
+                if (downRightArrow)
+                {
+                    downRightArrow = false;
+                    InvalidateRect(layout.rightArrow);
+                }
+            }
+        }
+
+        internal void OnMouseLeave()
+        {
+            if (downLeftArrow)
+            {
+                downLeftArrow = false;
+                InvalidateRect(layout.leftArrow);
+            }
+
+            if (downRightArrow)
+            {
+                downRightArrow = false;
+                InvalidateRect(layout.rightArrow);
+            }
+        }
+
+        internal void OnMouseMove(int x, int y)
+        {
+            /*
+            if (!layout.leftArrow.IsEmpty && layout.leftArrow.Contains(x,y))
+            {
+                ResetMouseInfo();
+                overLeftArrow = true;
+                InvalidateRect(layout.leftArrow);
+                return;
+            }
+            if (!layout.rightArrow.IsEmpty && layout.rightArrow.Contains(x,y))
+            {
+                ResetMouseInfo();
+                overRightArrow = true;
+                InvalidateRect(layout.rightArrow);
+                return;
+            }
+            */
+
+            if (downLeftArrow)
+            {
+                downLeftArrow = false;
+                InvalidateRect(layout.leftArrow);
+            }
+
+            if (downRightArrow)
+            {
+                downRightArrow = false;
+                InvalidateRect(layout.rightArrow);
+            }
+        }
+
+        internal void OnMouseUp(int x, int y)
+        {
+            ResetMouseInfo();
+            if (!layout.rightArrow.IsEmpty && layout.rightArrow.Contains(x, y))
+            {
+                InvalidateRect(layout.rightArrow);
+                return;
+            }
+
+            if (!layout.leftArrow.IsEmpty && layout.leftArrow.Contains(x, y))
+            {
+                InvalidateRect(layout.leftArrow);
+                return;
+            }
+        }
+
+        internal void OnResize(Rectangle oldBounds)
+        {
+            Invalidate();
+        }
+
+        /// <summary>
+        ///  Paints the parent rows
+        /// </summary>
+        internal void Paint(Graphics g, Rectangle visualbounds, bool alignRight)
+        {
+            Rectangle bounds = visualbounds;
+            // Paint the border around our bounds
+            if (borderWidth > 0)
+            {
+                PaintBorder(g, bounds);
+                bounds.Inflate(-borderWidth, -borderWidth);
+            }
+
+            PaintParentRows(g, bounds, alignRight);
+        }
+
+        private void PaintBorder(Graphics g, Rectangle bounds)
+        {
+            Rectangle border = bounds;
+
+            // top
+            border.Height = borderWidth;
+            g.FillRectangle(borderBrush, border);
+
+            // bottom
+            border.Y = bounds.Bottom - borderWidth;
+            g.FillRectangle(borderBrush, border);
+
+            // left
+            border = new Rectangle(bounds.X, bounds.Y + borderWidth,
+                                   borderWidth, bounds.Height - 2 * borderWidth);
+            g.FillRectangle(borderBrush, border);
+
+            // right
+            border.X = bounds.Right - borderWidth;
+            g.FillRectangle(borderBrush, border);
+        }
+
+        // will return the width of the text box that will fit all the
+        // tables names
+        private int GetTableBoxWidth(Graphics g, Font font)
+        {
+            // try to make the font BOLD
+            Font textFont = font;
+            try
+            {
+                textFont = new Font(font, FontStyle.Bold);
+            }
+            catch
+            {
+            }
+
+            int width = 0;
+            for (int row = 0; row < parentsCount; row++)
+            {
+                DataGridState dgs = (DataGridState)parents[row];
+                // Graphics.MeasureString(...) returns different results for ": " than for " :"
+                //
+                string displayTableName = dgs.ListManager.GetListName() + " :";
+                int size = (int)g.MeasureString(displayTableName, textFont).Width;
+                width = Math.Max(size, width);
+            }
+
+            return width;
+        }
+
+        // will return the width of the text box that will
+        // fit all the column names
+        private int GetColBoxWidth(Graphics g, Font font, int colNum)
+        {
+            int width = 0;
+
+            for (int row = 0; row < parentsCount; row++)
+            {
+                DataGridState dgs = (DataGridState)parents[row];
+                GridColumnStylesCollection columns = dgs.GridColumnStyles;
+                if (colNum < columns.Count)
+                {
+                    // Graphics.MeasureString(...) returns different results for ": " than for " :"
+                    //
+                    string colName = columns[colNum].HeaderText + " :";
+                    int size = (int)g.MeasureString(colName, font).Width;
+                    width = Math.Max(size, width);
+                }
+            }
+
+            return width;
+        }
+
+        // will return the width of the best fit for the column
+        //
+        private int GetColDataBoxWidth(Graphics g, int colNum)
+        {
+            int width = 0;
+            for (int row = 0; row < parentsCount; row++)
+            {
+                DataGridState dgs = (DataGridState)parents[row];
+                GridColumnStylesCollection columns = dgs.GridColumnStyles;
+                if (colNum < columns.Count)
+                {
+                    object value = columns[colNum].GetColumnValueAtRow((CurrencyManager)dataGrid.BindingContext[dgs.DataSource, dgs.DataMember],
+                                                                        dgs.LinkingRow.RowNumber);
+                    int size = columns[colNum].GetPreferredSize(g, value).Width;
+                    width = Math.Max(size, width);
+                }
+            }
+
+            return width;
+        }
+
+        // will return the count of the table with the largest number of columns
+        private int ColsCount()
+        {
+            int colNum = 0;
+            for (int row = 0; row < parentsCount; row++)
+            {
+                DataGridState dgs = (DataGridState)parents[row];
+                colNum = Math.Max(colNum, dgs.GridColumnStyles.Count);
+            }
+
+            return colNum;
+        }
+
+        // will return the total width required to paint the parentRows
+        private int TotalWidth(int tableNameBoxWidth, int[] colsNameWidths, int[] colsDataWidths)
+        {
+            int totalWidth = 0;
+            totalWidth += tableNameBoxWidth;
+            Debug.Assert(colsNameWidths.Length == colsDataWidths.Length, "both arrays are as long as the largest column count in dgs");
+            for (int i = 0; i < colsNameWidths.Length; i++)
+            {
+                totalWidth += colsNameWidths[i];
+                totalWidth += colsDataWidths[i];
+            }
+
+            // let 3 pixels in between datacolumns
+            // see DonnaWa
+            totalWidth += 3 * (colsNameWidths.Length - 1);
+            return totalWidth;
+        }
+
+        // computes the layout for the parent rows
+        //
+        private void ComputeLayout(Rectangle bounds, int tableNameBoxWidth, int[] colsNameWidths, int[] colsDataWidths)
+        {
+            int totalWidth = TotalWidth(tableNameBoxWidth, colsNameWidths, colsDataWidths);
+            if (totalWidth > bounds.Width)
+            {
+                layout.leftArrow = new Rectangle(bounds.X, bounds.Y, 15, bounds.Height);
+                layout.data = new Rectangle(layout.leftArrow.Right, bounds.Y, bounds.Width - 30, bounds.Height);
+                layout.rightArrow = new Rectangle(layout.data.Right, bounds.Y, 15, bounds.Height);
+            }
+            else
+            {
+                layout.data = bounds;
+                layout.leftArrow = Rectangle.Empty;
+                layout.rightArrow = Rectangle.Empty;
+            }
+        }
+
+        private void PaintParentRows(Graphics g, Rectangle bounds, bool alignToRight)
+        {
+            // variables needed for aligning the table and column names
+            int tableNameBoxWidth = 0;
+            int numCols = ColsCount();
+            int[] colsNameWidths = new int[numCols];
+            int[] colsDataWidths = new int[numCols];
+
+            // compute the size of the box that will contain the tableName
+            //
+            if (dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.TableName ||
+                dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.Both)
+            {
+                tableNameBoxWidth = GetTableBoxWidth(g, dataGrid.Font);
+            }
+
+            // initialiaze the arrays that contain the column names and the column size
+            //
+            for (int i = 0; i < numCols; i++)
+            {
+                if (dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.ColumnName ||
+                    dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.Both)
+                {
+                    colsNameWidths[i] = GetColBoxWidth(g, dataGrid.Font, i);
+                }
+                else
+                {
+                    colsNameWidths[i] = 0;
+                }
+
+                colsDataWidths[i] = GetColDataBoxWidth(g, i);
+            }
+
+            // compute the layout
+            //
+            ComputeLayout(bounds, tableNameBoxWidth, colsNameWidths, colsDataWidths);
+
+            // paint the navigation arrows, if necessary
+            //
+            if (!layout.leftArrow.IsEmpty)
+            {
+                g.FillRectangle(BackBrush, layout.leftArrow);
+                PaintLeftArrow(g, layout.leftArrow, alignToRight);
+            }
+
+            // paint the parent rows:
+            //
+            Rectangle rowBounds = layout.data;
+            for (int row = 0; row < parentsCount; ++row)
+            {
+                rowBounds.Height = (int)rowHeights[row];
+                if (rowBounds.Y > bounds.Bottom)
+                {
+                    break;
+                }
+
+                int paintedWidth = PaintRow(g, rowBounds, row, dataGrid.Font, alignToRight, tableNameBoxWidth, colsNameWidths, colsDataWidths);
+                if (row == parentsCount - 1)
+                {
+                    break;
+                }
+
+                // draw the grid line below
+                g.DrawLine(gridLinePen, rowBounds.X, rowBounds.Bottom,
+                           rowBounds.X + paintedWidth,
+                           rowBounds.Bottom);
+                rowBounds.Y += rowBounds.Height;
+            }
+
+            if (!layout.rightArrow.IsEmpty)
+            {
+                g.FillRectangle(BackBrush, layout.rightArrow);
+                PaintRightArrow(g, layout.rightArrow, alignToRight);
+            }
+        }
+
+        private Bitmap GetBitmap(string bitmapName)
+        {
+            try
+            {
+                return DpiHelper.GetBitmapFromIcon(typeof(DataGridParentRows), bitmapName);
+            }
+            catch (Exception e)
+            {
+                Debug.Fail("Failed to load bitmap: " + bitmapName, e.ToString());
+                return null;
+            }
+        }
+
+        private Bitmap GetRightArrowBitmap()
+        {
+            if (rightArrow == null)
+            {
+                rightArrow = GetBitmap("DataGridParentRows.RightArrow");
+            }
+
+            return rightArrow;
+        }
+
+        private Bitmap GetLeftArrowBitmap()
+        {
+            if (leftArrow == null)
+            {
+                leftArrow = GetBitmap("DataGridParentRows.LeftArrow");
+            }
+
+            return leftArrow;
+        }
+
+        private void PaintBitmap(Graphics g, Bitmap b, Rectangle bounds)
+        {
+            // center the bitmap in the bounds:
+            int bmpX = bounds.X + (bounds.Width - b.Width) / 2;
+            int bmpY = bounds.Y + (bounds.Height - b.Height) / 2;
+            Rectangle bmpRect = new Rectangle(bmpX, bmpY, b.Width, b.Height);
+
+            g.FillRectangle(BackBrush, bmpRect);
+
+            // now draw the bitmap
+            ImageAttributes attr = new ImageAttributes();
+            colorMap[0].NewColor = ForeColor;
+            attr.SetRemapTable(colorMap, ColorAdjustType.Bitmap);
+            g.DrawImage(b, bmpRect, 0, 0, bmpRect.Width, bmpRect.Height, GraphicsUnit.Pixel, attr);
+            attr.Dispose();
+        }
+
+        /*
+        private void PaintOverButton(Graphics g, Rectangle bounds)
+        {
+        }
+        */
+
+        private void PaintDownButton(Graphics g, Rectangle bounds)
+        {
+            g.DrawLine(Pens.Black, bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);  // the top
+            g.DrawLine(Pens.White, bounds.X + bounds.Width, bounds.Y, bounds.X + bounds.Width, bounds.Y + bounds.Height);  // the right side
+            g.DrawLine(Pens.White, bounds.X + bounds.Width, bounds.Y + bounds.Height, bounds.X, bounds.Y + bounds.Height);  // the right side
+            g.DrawLine(Pens.Black, bounds.X, bounds.Y + bounds.Height, bounds.X, bounds.Y);  // the left side
+        }
+
+        private void PaintLeftArrow(Graphics g, Rectangle bounds, bool alignToRight)
+        {
+            Bitmap bmp = GetLeftArrowBitmap();
+            // paint the border around this bitmap if this is the case
+            //
+            /*
+            if (overLeftArrow)
+            {
+                Debug.Assert(!downLeftArrow, "can both of those happen?");
+                PaintOverButton(g, bounds);
+                layout.leftArrow.Inflate(-1,-1);
+            }
+            */
+            if (downLeftArrow)
+            {
+                PaintDownButton(g, bounds);
+                layout.leftArrow.Inflate(-1, -1);
+                lock (bmp)
+                {
+                    PaintBitmap(g, bmp, bounds);
+                }
+
+                layout.leftArrow.Inflate(1, 1);
+            }
+            else
+            {
+                lock (bmp)
+                {
+                    PaintBitmap(g, bmp, bounds);
+                }
+            }
+        }
+
+        private void PaintRightArrow(Graphics g, Rectangle bounds, bool alignToRight)
+        {
+            Bitmap bmp = GetRightArrowBitmap();
+            // paint the border around this bitmap if this is the case
+            //
+            /*
+            if (overRightArrow)
+            {
+                Debug.Assert(!downRightArrow, "can both of those happen?");
+                PaintOverButton(g, bounds);
+                layout.rightArrow.Inflate(-1,-1);
+            }
+            */
+            if (downRightArrow)
+            {
+                PaintDownButton(g, bounds);
+                layout.rightArrow.Inflate(-1, -1);
+                lock (bmp)
+                {
+                    PaintBitmap(g, bmp, bounds);
+                }
+
+                layout.rightArrow.Inflate(1, 1);
+            }
+            else
+            {
+                lock (bmp)
+                {
+                    PaintBitmap(g, bmp, bounds);
+                }
+            }
+        }
+
+        private int PaintRow(Graphics g, Rectangle bounds, int row, Font font, bool alignToRight,
+                             int tableNameBoxWidth, int[] colsNameWidths, int[] colsDataWidths)
+        {
+            DataGridState dgs = (DataGridState)parents[row];
+            Rectangle paintBounds = bounds;
+            Rectangle rowBounds = bounds;
+            paintBounds.Height = (int)rowHeights[row];
+            rowBounds.Height = (int)rowHeights[row];
+
+            int paintedWidth = 0;
+            // used for scrolling: when paiting, we will skip horizOffset cells in the dataGrid ParentRows
+            int skippedCells = 0;
+
+            // paint the table name
+            if (dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.TableName ||
+                 dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.Both)
+            {
+                if (skippedCells < horizOffset)
+                {
+                    // skip this
+                    skippedCells++;
+                }
+                else
+                {
+                    paintBounds.Width = Math.Min(paintBounds.Width, tableNameBoxWidth);
+                    paintBounds.X = MirrorRect(bounds, paintBounds, alignToRight);
+                    string displayTableName = dgs.ListManager.GetListName() + ": ";
+                    PaintText(g, paintBounds, displayTableName, font, true, alignToRight);      // true is for painting bold
+                    paintedWidth += paintBounds.Width;
+                }
+            }
+
+            if (paintedWidth >= bounds.Width)
+            {
+                return bounds.Width;        // we painted everything
+            }
+
+            rowBounds.Width -= paintedWidth;
+            rowBounds.X += alignToRight ? 0 : paintedWidth;
+            paintedWidth += PaintColumns(g, rowBounds, dgs, font, alignToRight, colsNameWidths, colsDataWidths, skippedCells);
+
+            // paint the possible space left after columns
+            if (paintedWidth < bounds.Width)
+            {
+                paintBounds.X = bounds.X + paintedWidth;
+                paintBounds.Width = bounds.Width - paintedWidth;
+                paintBounds.X = MirrorRect(bounds, paintBounds, alignToRight);
+                g.FillRectangle(BackBrush, paintBounds);
+            }
+
+            return paintedWidth;
+        }
+
+        private int PaintColumns(Graphics g, Rectangle bounds, DataGridState dgs, Font font, bool alignToRight,
+                                 int[] colsNameWidths, int[] colsDataWidths, int skippedCells)
+        {
+            Rectangle paintBounds = bounds;
+            Rectangle rowBounds = bounds;
+            GridColumnStylesCollection cols = dgs.GridColumnStyles;
+            int cx = 0;
+
+            for (int i = 0; i < cols.Count; i++)
+            {
+                if (cx >= bounds.Width)
+                {
+                    break;
+                }
+
+                // paint the column name, if we have to
+                if (dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.ColumnName ||
+                    dataGrid.ParentRowsLabelStyle == DataGridParentRowsLabelStyle.Both)
+                {
+                    if (skippedCells < horizOffset)
+                    {
+                        // skip this column
+                    }
+                    else
+                    {
+                        paintBounds.X = bounds.X + cx;
+                        paintBounds.Width = Math.Min(bounds.Width - cx, colsNameWidths[i]);
+                        paintBounds.X = MirrorRect(bounds, paintBounds, alignToRight);
+
+                        string colName = cols[i].HeaderText + ": ";
+                        PaintText(g, paintBounds, colName, font, false, alignToRight);      // false is for not painting bold
+
+                        cx += paintBounds.Width;
+                    }
+                }
+
+                if (cx >= bounds.Width)
+                {
+                    break;
+                }
+
+                if (skippedCells < horizOffset)
+                {
+                    // skip this cell
+                    skippedCells++;
+                }
+                else
+                {
+                    // paint the cell contents
+                    paintBounds.X = bounds.X + cx;
+                    paintBounds.Width = Math.Min(bounds.Width - cx, colsDataWidths[i]);
+                    paintBounds.X = MirrorRect(bounds, paintBounds, alignToRight);
+
+                    // when we paint the data grid parent rows, we want to paint the data at the position
+                    // stored in the currency manager.
+                    cols[i].Paint(g, paintBounds, (CurrencyManager)dataGrid.BindingContext[dgs.DataSource, dgs.DataMember],
+                                    dataGrid.BindingContext[dgs.DataSource, dgs.DataMember].Position, BackBrush, ForeBrush, alignToRight);
+
+                    cx += paintBounds.Width;
+
+                    // draw the line to the right (or left, according to alignRight)
+                    //
+                    g.DrawLine(new Pen(SystemColors.ControlDark),
+                               alignToRight ? paintBounds.X : paintBounds.Right,
+                               paintBounds.Y,
+                               alignToRight ? paintBounds.X : paintBounds.Right,
+                               paintBounds.Bottom);
+
+                    // this is how wide the line is....
+                    cx++;
+
+                    // put 3 pixels in between columns
+                    // see DonnaWa
+                    //
+                    if (i < cols.Count - 1)
+                    {
+                        paintBounds.X = bounds.X + cx;
+                        paintBounds.Width = Math.Min(bounds.Width - cx, 3);
+                        paintBounds.X = MirrorRect(bounds, paintBounds, alignToRight);
+
+                        g.FillRectangle(BackBrush, paintBounds);
+                        cx += 3;
+                    }
+                }
+            }
+
+            return cx;
+        }
+
+        /// <summary>
+        ///  Draws on the screen the text. It is used only to paint the Table Name and the column Names
+        ///  Returns the width of bounding rectangle that was passed in
+        /// </summary>
+        private int PaintText(Graphics g, Rectangle textBounds, string text, Font font, bool bold, bool alignToRight)
+        {
+            Font textFont = font;
+            if (bold)
+            {
+                try
+                {
+                    textFont = new Font(font, FontStyle.Bold);
+                }
+                catch { }
+            }
+            else
+            {
+                textFont = font;
+            }
+
+            // right now, we paint the entire box, cause it will be used anyway
+            g.FillRectangle(BackBrush, textBounds);
+            StringFormat format = new StringFormat();
+            if (alignToRight)
+            {
+                format.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                format.Alignment = StringAlignment.Far;
+            }
+
+            format.FormatFlags |= StringFormatFlags.NoWrap;
+            // part 1, section 3: put the table and the column name in the
+            // parent rows at the same height as the dataGridTextBoxColumn draws the string
+            //
+            textBounds.Offset(0, 2);
+            textBounds.Height -= 2;
+            g.DrawString(text, textFont, ForeBrush, textBounds, format);
+            format.Dispose();
+            return textBounds.Width;
+        }
+
+        // will return the X coordinate of the containedRect mirrored within the surroundingRect
+        // according to the value of alignToRight
+        private int MirrorRect(Rectangle surroundingRect, Rectangle containedRect, bool alignToRight)
+        {
+            Debug.Assert(containedRect.X >= surroundingRect.X && containedRect.Right <= surroundingRect.Right, "containedRect is not contained in surroundingRect");
+            if (alignToRight)
+            {
+                return surroundingRect.Right - containedRect.Right + surroundingRect.X;
+            }
+            else
+            {
+                return containedRect.X;
+            }
+        }
+
+        private class Layout
+        {
+            public Rectangle data;
+            public Rectangle leftArrow;
+            public Rectangle rightArrow;
+
+            public Layout()
+            {
+                data = Rectangle.Empty;
+                leftArrow = Rectangle.Empty;
+                rightArrow = Rectangle.Empty;
+            }
+
+            public override string ToString()
+            {
+                StringBuilder sb = new StringBuilder(200);
+                sb.Append("ParentRows Layout: \n");
+                sb.Append("data = ");
+                sb.Append(data.ToString());
+                sb.Append("\n leftArrow = ");
+                sb.Append(leftArrow.ToString());
+                sb.Append("\n rightArrow = ");
+                sb.Append(rightArrow.ToString());
+                sb.Append('\n');
+
+                return sb.ToString();
+            }
+        }
+
+        [ComVisible(true)]
+        protected internal class DataGridParentRowsAccessibleObject : AccessibleObject
+        {
+            readonly DataGridParentRows owner;
+
+            public DataGridParentRowsAccessibleObject(DataGridParentRows owner) : base()
+            {
+                Debug.Assert(owner != null, "DataGridParentRowsAccessibleObject must have a valid owner");
+                this.owner = owner;
+            }
+
+            internal DataGridParentRows Owner
+            {
+                get
+                {
+                    return owner;
+                }
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    return owner.dataGrid.RectangleToScreen(owner.dataGrid.ParentRowsBounds);
+                }
+            }
+
+            public override string DefaultAction
+            {
+                get
+                {
+                    return SR.AccDGNavigateBack;
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    return SR.AccDGParentRows;
+                }
+            }
+
+            public override AccessibleObject Parent
+            {
+                get
+                {
+                    return owner.dataGrid.AccessibilityObject;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    return AccessibleRole.List;
+                }
+            }
+
+            public override AccessibleStates State
+            {
+                get
+                {
+                    AccessibleStates state = AccessibleStates.ReadOnly;
+
+                    if (owner.parentsCount == 0)
+                    {
+                        state |= AccessibleStates.Invisible;
+                    }
+
+                    if (owner.dataGrid.ParentRowsVisible)
+                    {
+                        state |= AccessibleStates.Expanded;
+                    }
+                    else
+                    {
+                        state |= AccessibleStates.Collapsed;
+                    }
+
+                    return state;
+                }
+            }
+
+            public override string Value
+            {
+                get
+                {
+                    return null;
+                }
+            }
+
+            public override void DoDefaultAction()
+            {
+                owner.dataGrid.NavigateBack();
+            }
+
+            public override AccessibleObject GetChild(int index)
+            {
+                return ((DataGridState)owner.parents[index]).ParentRowAccessibleObject;
+            }
+
+            public override int GetChildCount()
+            {
+                return owner.parentsCount;
+            }
+
+            /// <summary>
+            ///  Returns the currently focused child, if any.
+            ///  Returns this if the object itself is focused.
+            /// </summary>
+            public override AccessibleObject GetFocused()
+            {
+                return null;
+            }
+
+            internal AccessibleObject GetNext(AccessibleObject child)
+            {
+                int children = GetChildCount();
+                bool hit = false;
+
+                for (int i = 0; i < children; i++)
+                {
+                    if (hit)
+                    {
+                        return GetChild(i);
+                    }
+
+                    if (GetChild(i) == child)
+                    {
+                        hit = true;
+                    }
+                }
+
+                return null;
+            }
+
+            internal AccessibleObject GetPrev(AccessibleObject child)
+            {
+                int children = GetChildCount();
+                bool hit = false;
+
+                for (int i = children - 1; i >= 0; i--)
+                {
+                    if (hit)
+                    {
+                        return GetChild(i);
+                    }
+
+                    if (GetChild(i) == child)
+                    {
+                        hit = true;
+                    }
+                }
+
+                return null;
+            }
+
+            /// <summary>
+            ///  Navigate to the next or previous grid entry.
+            /// </summary>
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                    case AccessibleNavigation.Down:
+                        return Parent.GetChild(1);
+                    case AccessibleNavigation.Up:
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        return Parent.GetChild(GetChildCount() - 1);
+                    case AccessibleNavigation.FirstChild:
+                        if (GetChildCount() > 0)
+                        {
+                            return GetChild(0);
+                        }
+
+                        break;
+                    case AccessibleNavigation.LastChild:
+                        if (GetChildCount() > 0)
+                        {
+                            return GetChild(GetChildCount() - 1);
+                        }
+
+                        break;
+                }
+
+                return null;
+            }
+
+            public override void Select(AccessibleSelection flags)
+            {
+            }
+        }
+    }
+}
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRowsLabelStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRowsLabelStyle.cs
new file mode 100644
index 00000000000..151e1e62706
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridParentRowsLabelStyle.cs
@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies how parent row labels of a DataGrid
+    ///  control are displayed.
+    /// </summary>
+    public enum DataGridParentRowsLabelStyle
+    {
+        /// <summary>
+        ///  Display no parent row labels.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        ///  Displaya the parent table name.
+        /// </summary>
+        TableName = 1,
+
+        /// <summary>
+        ///  Displaya the parent column name.
+        /// </summary>
+        ColumnName = 2,
+
+        /// <summary>
+        ///  Displays
+        ///  both the parent table and column names.
+        /// </summary>
+        Both = 3,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridPreferredColumnWidthTypeConverter.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridPreferredColumnWidthTypeConverter.cs
new file mode 100644
index 00000000000..ddb041dfa54
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridPreferredColumnWidthTypeConverter.cs
@@ -0,0 +1,77 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.ComponentModel;
+using System.Globalization;
+
+namespace System.Windows.Forms
+{
+    public class DataGridPreferredColumnWidthTypeConverter : TypeConverter
+    {
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string) || sourceType == typeof(int))
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(string))
+            {
+                if (value.GetType() == typeof(int))
+                {
+                    int pulica = (int)value;
+                    if (pulica == -1)
+                    {
+                        return "AutoColumnResize (-1)";
+                    }
+                    else
+                    {
+                        return pulica.ToString(CultureInfo.CurrentCulture);
+                    }
+                }
+                else
+                {
+                    return base.ConvertTo(context, culture, value, destinationType);
+                }
+            }
+            else
+            {
+                return base.ConvertTo(context, culture, value, destinationType);
+            }
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value.GetType() == typeof(string))
+            {
+                string text = value.ToString();
+                if (text.Equals("AutoColumnResize (-1)"))
+                {
+                    return -1;
+                }
+                else
+                {
+                    return int.Parse(text, CultureInfo.CurrentCulture);
+                }
+            }
+            else if (value.GetType() == typeof(int))
+            {
+                return (int)value;
+            }
+            else
+            {
+                throw GetConvertFromException(value);
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRelationshipRow.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRelationshipRow.cs
new file mode 100644
index 00000000000..016e4f7cb77
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRelationshipRow.cs
@@ -0,0 +1,1282 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  This class fully encapsulates the painting logic for a row
+    ///  appearing in a DataGrid.
+    /// </summary>
+    internal class DataGridRelationshipRow : DataGridRow
+    {
+        private const bool defaultOpen = false;
+        private const int expandoBoxWidth = 14;
+        private const int indentWidth = 20;
+        // private const int  relationshipSpacing = 1;
+        private const int triangleSize = 5;
+
+        private bool expanded = defaultOpen;
+        // private bool hasRelationships = false;
+        // private Font linkFont = null;
+        // private new DataGrid dataGrid; // Currently used only to obtain a Graphics object for measuring text
+
+        // private Rectangle relationshipRect   = Rectangle.Empty;
+        // private int       relationshipHeight = 0;
+
+        // relationships
+        // we should get this directly from the dgTable.
+        // private ArrayList     relationships;
+        // private int            focusedRelation = -1;
+        // private int          focusedTextWidth;
+
+        public DataGridRelationshipRow(DataGrid dataGrid, DataGridTableStyle dgTable, int rowNumber)
+        : base(dataGrid, dgTable, rowNumber)
+        {
+            // this.dataGrid = dataGrid;
+            // linkFont = dataGrid.LinkFont;
+            // relationshipHeight = dataGrid.LinkFontHeight + this.dgTable.relationshipSpacing;
+
+            // if (DataGrid.AllowNavigation) {
+            //     hasRelationships = dgTable.RelationsList.Count > 0;
+            // }
+        }
+
+        internal protected override int MinimumRowHeight(GridColumnStylesCollection cols)
+        {
+            /*
+            if (DataGrid != null && DataGrid.LinkFontHeight + this.dgTable.relationshipSpacing != relationshipHeight) {
+                relationshipRect = Rectangle.Empty;
+                relationshipHeight = DataGrid.LinkFontHeight + this.dgTable.relationshipSpacing;
+            }
+            */
+
+            return base.MinimumRowHeight(cols) + (expanded ? GetRelationshipRect().Height : 0);
+        }
+
+        internal protected override int MinimumRowHeight(DataGridTableStyle dgTable)
+        {
+            /*
+            if (DataGrid != null && DataGrid.LinkFontHeight + this.dgTable.relationshipSpacing != relationshipHeight) {
+                relationshipRect = Rectangle.Empty;
+                relationshipHeight = DataGrid.LinkFontHeight + this.dgTable.relationshipSpacing;
+            }
+            */
+
+            return base.MinimumRowHeight(dgTable) + (expanded ? GetRelationshipRect().Height : 0);
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        public virtual bool Expanded
+        {
+            get
+            {
+                return expanded;
+            }
+            set
+            {
+                if (expanded == value)
+                {
+                    return;
+                }
+
+                if (expanded)
+                {
+                    Collapse();
+                }
+                else
+                {
+                    Expand();
+                }
+            }
+        }
+
+        /*
+        private Color BorderColor {
+            get {
+                if (DataGrid == null)
+                    return Color.Empty;
+                return DataGrid.GridLineColor;
+            }
+        }
+        */
+
+#if FALSE
+        private int BorderWidth {
+            get {
+                DataGrid dataGrid = this.DataGrid;
+                if (dataGrid == null)
+                    return 0;
+                // if the user set the GridLineStyle property on the dataGrid.
+                // then use the value of that property
+                DataGridLineStyle gridStyle;
+                int gridLineWidth;
+                if (this.dgTable.IsDefault) {
+                    gridStyle = this.DataGrid.GridLineStyle;
+                    gridLineWidth = this.DataGrid.GridLineWidth;
+                } else {
+                    gridStyle = this.dgTable.GridLineStyle;
+                    gridLineWidth = this.dgTable.GridLineWidth;
+                }
+
+                if (gridStyle == DataGridLineStyle.None)
+                    return 0;
+
+                return gridLineWidth;
+            }
+        }
+#endif //FALSE
+
+        private int FocusedRelation
+        {
+            get
+            {
+                return dgTable.FocusedRelation;
+            }
+            set
+            {
+                dgTable.FocusedRelation = value;
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        private void Collapse()
+        {
+            Debug.Assert(dgTable.DataGrid.AllowNavigation, "how can the user collapse the relations if the grid does not allow navigation?");
+            if (expanded)
+            {
+                expanded = false;
+                // relationshipRect = Rectangle.Empty;
+                FocusedRelation = -1;
+                DataGrid.OnRowHeightChanged(this);
+            }
+        }
+
+        protected override AccessibleObject CreateAccessibleObject()
+        {
+            return new DataGridRelationshipRowAccessibleObject(this);
+        }
+
+        private void Expand()
+        {
+            Debug.Assert(dgTable.DataGrid.AllowNavigation, "how can the user expand the relations if the grid does not allow navigation?");
+            if (expanded == false
+                && DataGrid != null
+                && dgTable != null
+                && dgTable.RelationsList.Count > 0)
+            {
+                expanded = true;
+                FocusedRelation = -1;
+
+                // relationshipRect = Rectangle.Empty;
+                DataGrid.OnRowHeightChanged(this);
+            }
+        }
+
+        public override int Height
+        {
+            get
+            {
+                int height = base.Height;
+                if (expanded)
+                {
+                    return height + GetRelationshipRect().Height;
+                }
+                else
+                {
+                    return height;
+                }
+            }
+            set
+            {
+                // we should use the RelationshipRect only when the row is expanded
+                if (expanded)
+                {
+                    base.Height = value - GetRelationshipRect().Height;
+                }
+                else
+                {
+                    base.Height = value;
+                }
+            }
+        }
+
+        // so the edit box will not paint under the
+        // grid line of the row
+        public override Rectangle GetCellBounds(int col)
+        {
+            Rectangle cellBounds = base.GetCellBounds(col);
+            // decrement base.Height by 1, so the edit box will not
+            // paint over the bottom line.
+            cellBounds.Height = base.Height - 1;
+            return cellBounds;
+        }
+
+        /// <summary>
+        ///  Given an origin, this procedure returns
+        ///  a rectangle that describes the location of an outline box.
+        /// </summary>
+        private Rectangle GetOutlineRect(int xOrigin, int yOrigin)
+        {
+            Rectangle outline = new Rectangle(xOrigin + 2,
+                                              yOrigin + 2,
+                                              9,
+                                              9);
+            return outline;
+        }
+
+        public override Rectangle GetNonScrollableArea()
+        {
+            if (expanded)
+            {
+                return GetRelationshipRect();
+            }
+            else
+            {
+                return Rectangle.Empty;
+            }
+        }
+
+        private Rectangle GetRelationshipRect()
+        {
+            Debug.Assert(expanded, "we should need this rectangle only when the row is expanded");
+            Rectangle ret = dgTable.RelationshipRect;
+            ret.Y = base.Height - dgTable.BorderWidth;
+            return ret;
+        }
+
+#if FALSE
+        private Rectangle GetRelationshipRect() {
+            if (relationshipRect.IsEmpty) {
+                Debug.WriteLineIf(CompModSwitches.DGRelationShpRowLayout.TraceVerbose, "GetRelationshipRect grinding away");
+                if (!expanded) {
+                    return(relationshipRect = new Rectangle(0,0,0,0));
+                }
+                Graphics g = DataGrid.CreateGraphicsInternal();
+                relationshipRect = new Rectangle();
+                relationshipRect.X = 0; //indentWidth;
+                relationshipRect.Y = base.Height - this.dgTable.BorderWidth;
+
+                // Determine the width of the widest relationship name
+                int longestRelationship = 0;
+                for (int r = 0; r < this.dgTable.RelationsList.Count; ++r) {
+                    int rwidth = (int) Math.Ceiling(g.MeasureString(((string) this.dgTable.RelationsList[r]), this.DataGrid.LinkFont).Width);
+                    if (rwidth > longestRelationship)
+                        longestRelationship = rwidth;
+                }
+
+                g.Dispose();
+
+                relationshipRect.Width = longestRelationship + 5;
+                relationshipRect.Width += 2; // relationshipRect border;
+                relationshipRect.Height = this.dgTable.BorderWidth + relationshipHeight * this.dgTable.RelationsList.Count;
+                relationshipRect.Height += 2; // relationship border
+                if (this.dgTable.RelationsList.Count > 0)
+                    relationshipRect.Height += 2 * System.Windows.Forms.DataGridTableStyle.relationshipSpacing;
+            }
+            return relationshipRect;
+        }
+
+#endif// FALSE
+
+        private Rectangle GetRelationshipRectWithMirroring()
+        {
+            Rectangle relRect = GetRelationshipRect();
+            bool rowHeadersVisible = dgTable.IsDefault ? DataGrid.RowHeadersVisible : dgTable.RowHeadersVisible;
+            if (rowHeadersVisible)
+            {
+                int rowHeaderWidth = dgTable.IsDefault ? DataGrid.RowHeaderWidth : dgTable.RowHeaderWidth;
+                relRect.X += DataGrid.GetRowHeaderRect().X + rowHeaderWidth;
+            }
+
+            relRect.X = MirrorRelationshipRectangle(relRect, DataGrid.GetRowHeaderRect(), DataGrid.RightToLeft == RightToLeft.Yes);
+            return relRect;
+        }
+
+        /// <summary>
+        ///  Called by the DataGrid when a click occurs in the row's client
+        ///  area.  The coordinates are normalized to the rectangle's top
+        ///  left point.
+        /// </summary>
+        private bool PointOverPlusMinusGlyph(int x, int y, Rectangle rowHeaders, bool alignToRight)
+        {
+            if (dgTable == null || dgTable.DataGrid == null || !dgTable.DataGrid.AllowNavigation)
+            {
+                return false;
+            }
+
+            Rectangle insideRowHeaders = rowHeaders;
+            if (!DataGrid.FlatMode)
+            {
+                insideRowHeaders.Inflate(-1, -1);
+            }
+
+            Rectangle outline = GetOutlineRect(insideRowHeaders.Right - expandoBoxWidth, 0);
+
+            outline.X = MirrorRectangle(outline.X, outline.Width, insideRowHeaders, alignToRight);
+
+            return outline.Contains(x, y);
+        }
+
+        public override bool OnMouseDown(int x, int y, Rectangle rowHeaders, bool alignToRight)
+        {
+            bool rowHeadersVisible = dgTable.IsDefault ? DataGrid.RowHeadersVisible : dgTable.RowHeadersVisible;
+            if (rowHeadersVisible)
+            {
+                if (PointOverPlusMinusGlyph(x, y, rowHeaders, alignToRight))
+                {
+                    if (dgTable.RelationsList.Count == 0)
+                    {
+                        return false;
+                    }
+                    else if (expanded)
+                    {
+                        Collapse();
+                    }
+                    else
+                    {
+                        Expand();
+                    }
+
+                    DataGrid.OnNodeClick(EventArgs.Empty);
+                    return true;
+                }
+            }
+
+            if (!expanded)
+            {
+                return base.OnMouseDown(x, y, rowHeaders, alignToRight);
+            }
+
+            // hit test for relationships
+            Rectangle relRect = GetRelationshipRectWithMirroring();
+
+            if (relRect.Contains(x, y))
+            {
+                int r = RelationFromY(y);
+                if (r != -1)
+                {
+                    // first, reset the FocusedRelation
+                    FocusedRelation = -1;
+                    DataGrid.NavigateTo(((string)dgTable.RelationsList[r]), this, true);
+                }
+
+                // DataGrid.OnLinkClick(EventArgs.Empty);
+                return true;
+            }
+
+            return base.OnMouseDown(x, y, rowHeaders, alignToRight);
+        }
+
+        public override bool OnMouseMove(int x, int y, Rectangle rowHeaders, bool alignToRight)
+        {
+            if (!expanded)
+            {
+                return false;
+            }
+
+            Rectangle relRect = GetRelationshipRectWithMirroring();
+
+            if (relRect.Contains(x, y))
+            {
+                DataGrid.Cursor = Cursors.Hand;
+                return true;
+            }
+
+            DataGrid.Cursor = Cursors.Default;
+            return base.OnMouseMove(x, y, rowHeaders, alignToRight);
+        }
+
+        // this function will not invalidate all of the
+        // row
+        public override void OnMouseLeft(Rectangle rowHeaders, bool alignToRight)
+        {
+            if (!expanded)
+            {
+                return;
+            }
+
+            Rectangle relRect = GetRelationshipRect();
+            relRect.X += rowHeaders.X + dgTable.RowHeaderWidth;
+            relRect.X = MirrorRelationshipRectangle(relRect, rowHeaders, alignToRight);
+
+            if (FocusedRelation != -1)
+            {
+                InvalidateRowRect(relRect);
+                FocusedRelation = -1;
+            }
+        }
+
+        public override void OnMouseLeft()
+        {
+            if (!expanded)
+            {
+                return;
+            }
+
+            if (FocusedRelation != -1)
+            {
+                InvalidateRow();
+                FocusedRelation = -1;
+            }
+
+            base.OnMouseLeft();
+        }
+
+        /// <summary>
+        ///  Called by the DataGrid when a keypress occurs on a row with "focus."
+        /// </summary>
+        public override bool OnKeyPress(Keys keyData)
+        {
+            // ignore the shift key if it is not paired w/ the TAB key
+            if ((keyData & Keys.Modifiers) == Keys.Shift && (keyData & Keys.KeyCode) != Keys.Tab)
+            {
+                return false;
+            }
+
+            switch (keyData & Keys.KeyCode)
+            {
+                case Keys.F5:
+                    if (dgTable == null || dgTable.DataGrid == null || !dgTable.DataGrid.AllowNavigation)
+                    {
+                        return false;
+                    }
+
+                    if (expanded)
+                    {
+                        Collapse();
+                    }
+                    else
+                    {
+                        Expand();
+                    }
+
+                    FocusedRelation = -1;
+                    return true;
+
+                // to make the gridTest run w/ the numLock key on
+                //
+                case Keys.NumLock:
+                    if (FocusedRelation != -1)
+                    {
+                        return false;
+                    }
+                    else
+                    {
+                        return base.OnKeyPress(keyData);
+                    }
+
+                case Keys.Enter:
+                    if (FocusedRelation != -1)
+                    {
+                        // somebody set the relation number up already
+                        // navigate to the relation
+                        DataGrid.NavigateTo(((string)dgTable.RelationsList[FocusedRelation]), this, true);
+
+                        // now reset the FocusedRelation
+                        FocusedRelation = -1;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+
+                case Keys.Tab:
+                    return false;
+
+                default:
+                    FocusedRelation = -1;
+                    return base.OnKeyPress(keyData);
+            }
+        }
+
+        // will reset the FocusedRelation and will invalidate the
+        // rectangle so that the linkFont is no longer shown
+        internal override void LoseChildFocus(Rectangle rowHeaders, bool alignToRight)
+        {
+            // we only invalidate stuff if the row is expanded.
+            if (FocusedRelation == -1 || !expanded)
+            {
+                return;
+            }
+
+            FocusedRelation = -1;
+            Rectangle relRect = GetRelationshipRect();
+            relRect.X += rowHeaders.X + dgTable.RowHeaderWidth;
+            relRect.X = MirrorRelationshipRectangle(relRect, rowHeaders, alignToRight);
+            InvalidateRowRect(relRect);
+        }
+
+        // here is the logic for FOCUSED:
+        //
+        // first the dataGrid gets the KeyPress.
+        // the dataGrid passes it to the currentRow. if it is anything other
+        // than Enter or TAB, the currentRow resets the FocusedRelation variable.
+        //
+        // Then the dataGrid takes another look at the TAB key and if it is the case
+        // it passes it to the row. If the dataRelationshipRow can become focused,
+        // then it eats the TAB key, otherwise it will give it back to the dataGrid.
+        //
+        internal override bool ProcessTabKey(Keys keyData, Rectangle rowHeaders, bool alignToRight)
+        {
+            Debug.Assert((keyData & Keys.Control) != Keys.Control, "the DataGridRelationshipRow only handles TAB and TAB-SHIFT");
+            Debug.Assert((keyData & Keys.Alt) != Keys.Alt, "the DataGridRelationshipRow only handles TAB and TAB-SHIFT");
+
+            // if there are no relationships, this row can't do anything with the
+            // key
+            if (dgTable.RelationsList.Count == 0 || dgTable.DataGrid == null || !dgTable.DataGrid.AllowNavigation)
+            {
+                return false;
+            }
+
+            // expand the relationship box
+            if (!expanded)
+            {
+                Expand();
+            }
+
+            if ((keyData & Keys.Shift) == Keys.Shift)
+            {
+                if (FocusedRelation == 0)
+                {
+                    // if user hits TAB-SHIFT and the focus was on the first relationship then
+                    // reset FocusedRelation and let the dataGrid use the key
+                    //
+                    // consider: Microsoft: if the relationships box is expanded, should we collapse it on leave?
+                    FocusedRelation = -1;
+                    return false;
+                }
+
+                // we need to invalidate the relationshipRectangle, and cause the linkFont to move
+                // to the next relation
+                Rectangle relRect = GetRelationshipRect();
+                relRect.X += rowHeaders.X + dgTable.RowHeaderWidth;
+                relRect.X = MirrorRelationshipRectangle(relRect, rowHeaders, alignToRight);
+                InvalidateRowRect(relRect);
+
+                if (FocusedRelation == -1)
+                {
+                    // is the first time that the user focuses on this
+                    // set of relationships
+                    FocusedRelation = dgTable.RelationsList.Count - 1;
+                }
+                else
+                {
+                    FocusedRelation--;
+                }
+
+                return true;
+            }
+            else
+            {
+                if (FocusedRelation == dgTable.RelationsList.Count - 1)
+                {
+                    // if the user hits TAB and the focus was on the last relationship then
+                    // reset FocusedRelation and let the dataGrid use the key
+                    //
+                    // consider: Microsoft: if the relationships box is expanded, should we collapse it on leave?
+                    FocusedRelation = -1;
+                    return false;
+                }
+
+                // we need to invalidate the relationshipRectangle, and cause the linkFont to move
+                // to the next relation
+                Rectangle relRect = GetRelationshipRect();
+                relRect.X += rowHeaders.X + dgTable.RowHeaderWidth;
+                relRect.X = MirrorRelationshipRectangle(relRect, rowHeaders, alignToRight);
+                InvalidateRowRect(relRect);
+
+                FocusedRelation++;
+                return true;
+            }
+        }
+
+        /// <summary>
+        ///  Paints the row.
+        /// </summary>
+        public override int Paint(Graphics g, Rectangle bounds, Rectangle trueRowBounds, int firstVisibleColumn, int numVisibleColumns)
+        {
+            return Paint(g, bounds, trueRowBounds, firstVisibleColumn, numVisibleColumns, false);
+        }
+
+        public override int Paint(Graphics g,
+                                  Rectangle bounds,          // negative offsetted row bounds
+                                  Rectangle trueRowBounds,   // real row bounds.
+                                  int firstVisibleColumn,
+                                  int numVisibleColumns,
+                                  bool alignToRight)
+        {
+            if (CompModSwitches.DGRelationShpRowPaint.TraceVerbose)
+            {
+                Debug.WriteLine("Painting row " + RowNumber.ToString(CultureInfo.InvariantCulture) + " with bounds " + bounds.ToString());
+            }
+
+            int bWidth = dgTable.BorderWidth;
+
+            // paint the data cells
+            Rectangle dataBounds = bounds;
+            dataBounds.Height = base.Height - bWidth;
+            int dataWidth = PaintData(g, dataBounds, firstVisibleColumn, numVisibleColumns, alignToRight);
+            int dataWidthOffsetted = dataWidth + bounds.X - trueRowBounds.X;
+
+            dataBounds.Offset(0, bWidth);       // use bWidth, not 1
+            if (bWidth > 0)
+            {
+                PaintBottomBorder(g, dataBounds, dataWidth, bWidth, alignToRight);
+            }
+
+            if (expanded && dgTable.RelationsList.Count > 0)
+            {
+                // paint the relationships
+                Rectangle relationBounds = new Rectangle(trueRowBounds.X,
+                                                         dataBounds.Bottom,
+                                                         trueRowBounds.Width,
+                                                         trueRowBounds.Height - dataBounds.Height - 2 * bWidth);
+                PaintRelations(g, relationBounds, trueRowBounds, dataWidthOffsetted,
+                               firstVisibleColumn, numVisibleColumns, alignToRight);
+                relationBounds.Height += 1;
+                if (bWidth > 0)
+                {
+                    PaintBottomBorder(g, relationBounds, dataWidthOffsetted, bWidth, alignToRight);
+                }
+            }
+
+            return dataWidth;
+        }
+
+        protected override void PaintCellContents(Graphics g, Rectangle cellBounds, DataGridColumnStyle column,
+                                                  Brush backBr, Brush foreBrush, bool alignToRight)
+        {
+            CurrencyManager listManager = DataGrid.ListManager;
+
+            // painting the error..
+            //
+            string errString = string.Empty;
+            Rectangle bounds = cellBounds;
+            object errInfo = DataGrid.ListManager[number];
+            if (errInfo is IDataErrorInfo)
+            {
+                errString = ((IDataErrorInfo)errInfo)[column.PropertyDescriptor.Name];
+            }
+
+            if (!string.IsNullOrEmpty(errString))
+            {
+                Bitmap bmp = GetErrorBitmap();
+                Rectangle errRect;
+                lock (bmp)
+                {
+                    errRect = PaintIcon(g, bounds, true, alignToRight, bmp, backBr);
+                }
+
+                // paint the errors correctly when RTL = true
+                if (alignToRight)
+                {
+                    bounds.Width -= errRect.Width + xOffset;
+                }
+                else
+                {
+                    bounds.X += errRect.Width + xOffset;
+                }
+
+                DataGrid.ToolTipProvider.AddToolTip(errString, (IntPtr)(DataGrid.ToolTipId++), errRect);
+            }
+
+            column.Paint(g, bounds, listManager, RowNumber, backBr, foreBrush, alignToRight);
+        }
+
+        public override void PaintHeader(Graphics g, Rectangle bounds, bool alignToRight, bool isDirty)
+        {
+            DataGrid grid = DataGrid;
+
+            Rectangle insideBounds = bounds;
+
+            if (!grid.FlatMode)
+            {
+                ControlPaint.DrawBorder3D(g, insideBounds, Border3DStyle.RaisedInner);
+                insideBounds.Inflate(-1, -1);
+            }
+
+            if (dgTable.IsDefault)
+            {
+                PaintHeaderInside(g, insideBounds, DataGrid.HeaderBackBrush, alignToRight, isDirty);
+            }
+            else
+            {
+                PaintHeaderInside(g, insideBounds, dgTable.HeaderBackBrush, alignToRight, isDirty);
+            }
+        }
+
+        public void PaintHeaderInside(Graphics g, Rectangle bounds, Brush backBr, bool alignToRight, bool isDirty)
+        {
+            // paint the row header
+            bool paintPlusMinus = dgTable.RelationsList.Count > 0 && dgTable.DataGrid.AllowNavigation;
+            int rowHeaderBoundsX = MirrorRectangle(bounds.X,
+                                                   bounds.Width - (paintPlusMinus ? expandoBoxWidth : 0),
+                                                   bounds, alignToRight);
+
+            if (!alignToRight)
+            {
+                Debug.Assert(bounds.X == rowHeaderBoundsX, "what's up doc?");
+            }
+
+            Rectangle rowHeaderBounds = new Rectangle(rowHeaderBoundsX,
+                                                      bounds.Y,
+                                                      bounds.Width - (paintPlusMinus ? expandoBoxWidth : 0),
+                                                      bounds.Height);
+
+            base.PaintHeader(g, rowHeaderBounds, alignToRight, isDirty);
+
+            // Paint the expando on the right
+            int expandoBoxX = MirrorRectangle(bounds.X + rowHeaderBounds.Width, expandoBoxWidth, bounds, alignToRight);
+
+            if (!alignToRight)
+            {
+                Debug.Assert(rowHeaderBounds.Right == expandoBoxX, "what's up doc?");
+            }
+
+            Rectangle expandoBox = new Rectangle(expandoBoxX,
+                                                 bounds.Y,
+                                                 expandoBoxWidth,
+                                                 bounds.Height);
+            if (paintPlusMinus)
+            {
+                PaintPlusMinusGlyph(g, expandoBox, backBr, alignToRight);
+            }
+        }
+
+        /// <summary>
+        ///  Paints the relationships below the data area.
+        /// </summary>
+        private void PaintRelations(Graphics g, Rectangle bounds, Rectangle trueRowBounds,
+                                    int dataWidth, int firstCol, int nCols, bool alignToRight)
+        {
+            // Calculate the relationship rect.
+            // relationshipRect = Rectangle.Empty;
+            Rectangle relRect = GetRelationshipRect();
+            //relRect.Offset(trueRowBounds.X, trueRowBounds.Y);
+            relRect.X = alignToRight ? bounds.Right - relRect.Width : bounds.X;
+            relRect.Y = bounds.Y;
+            int paintedWidth = Math.Max(dataWidth, relRect.Width);
+
+            // Paint the stuff to the right , or left (Bi-Di) of the relationship rect.
+            Region r = g.Clip;
+            g.ExcludeClip(relRect);
+
+            g.FillRectangle(GetBackBrush(),
+                            alignToRight ? bounds.Right - dataWidth : bounds.X,
+                            bounds.Y,
+                            dataWidth,
+                            bounds.Height);
+
+            // Paint the relations' text
+            g.SetClip(bounds);
+
+            relRect.Height -= dgTable.BorderWidth;     // use bWidth not 1
+            g.DrawRectangle(SystemPens.ControlText, relRect.X, relRect.Y, relRect.Width - 1, relRect.Height - 1);
+            relRect.Inflate(-1, -1);
+
+            int cy = PaintRelationText(g, relRect, alignToRight);
+
+            if (cy < relRect.Height)
+            {
+                g.FillRectangle(GetBackBrush(), relRect.X, relRect.Y + cy, relRect.Width, relRect.Height - cy);
+            }
+
+            g.Clip = r;
+
+            // paint any exposed area to the right or to the left (BI-DI)
+            if (paintedWidth < bounds.Width)
+            {
+                int bWidth;
+                if (dgTable.IsDefault)
+                {
+                    bWidth = DataGrid.GridLineWidth;
+                }
+                else
+                {
+                    bWidth = dgTable.GridLineWidth;
+                }
+
+                g.FillRectangle(DataGrid.BackgroundBrush,
+                                alignToRight ? bounds.X : bounds.X + paintedWidth,
+                                bounds.Y,
+                                bounds.Width - paintedWidth - bWidth + 1, // + 1 cause the relationship rectangle was deflated
+                                bounds.Height);
+
+                // Paint the border to the right of each cell
+                if (bWidth > 0)
+                {
+                    Brush br;
+                    // if the user changed the gridLineColor on the dataGrid
+                    // from the defaultValue, then use that value;
+                    if (dgTable.IsDefault)
+                    {
+                        br = DataGrid.GridLineBrush;
+                    }
+                    else
+                    {
+                        br = dgTable.GridLineBrush;
+                    }
+
+                    g.FillRectangle(br,
+                                    alignToRight ? bounds.Right - bWidth - paintedWidth : bounds.X + paintedWidth - bWidth,
+                                    bounds.Y,
+                                    bWidth,
+                                    bounds.Height);
+                }
+            }
+        }
+
+        private int PaintRelationText(Graphics g, Rectangle bounds, bool alignToRight)
+        {
+            g.FillRectangle(GetBackBrush(), bounds.X, bounds.Y, bounds.Width, System.Windows.Forms.DataGridTableStyle.relationshipSpacing);
+
+            int relationshipHeight = dgTable.RelationshipHeight;
+            Rectangle textBounds = new Rectangle(bounds.X, bounds.Y + System.Windows.Forms.DataGridTableStyle.relationshipSpacing,
+                                                 bounds.Width,
+                                                 relationshipHeight);
+            int cy = System.Windows.Forms.DataGridTableStyle.relationshipSpacing;
+            for (int r = 0; r < dgTable.RelationsList.Count; ++r)
+            {
+                if (cy > bounds.Height)
+                {
+                    break;
+                }
+
+                Brush textBrush = dgTable.IsDefault ? DataGrid.LinkBrush : dgTable.LinkBrush;
+
+                Font textFont = DataGrid.Font;
+                textBrush = dgTable.IsDefault ? DataGrid.LinkBrush : dgTable.LinkBrush;
+                textFont = DataGrid.LinkFont;
+
+                g.FillRectangle(GetBackBrush(), textBounds);
+
+                StringFormat format = new StringFormat();
+                if (alignToRight)
+                {
+                    format.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+                    format.Alignment = StringAlignment.Far;
+                }
+
+                g.DrawString(((string)dgTable.RelationsList[r]), textFont, textBrush, textBounds,
+                             format);
+                if (r == FocusedRelation && number == DataGrid.CurrentCell.RowNumber)
+                {
+                    textBounds.Width = dgTable.FocusedTextWidth;
+                    ControlPaint.DrawFocusRectangle(g, textBounds, ((SolidBrush)textBrush).Color, ((SolidBrush)GetBackBrush()).Color);
+                    textBounds.Width = bounds.Width;
+                }
+
+                format.Dispose();
+
+                textBounds.Y += relationshipHeight;
+                cy += textBounds.Height;
+            }
+
+            return cy;
+        }
+
+        private void PaintPlusMinusGlyph(Graphics g, Rectangle bounds, Brush backBr, bool alignToRight)
+        {
+            if (CompModSwitches.DGRelationShpRowPaint.TraceVerbose)
+            {
+                Debug.WriteLine("PlusMinusGlyph painting in bounds    -> " + bounds.ToString());
+            }
+
+            Rectangle outline = GetOutlineRect(bounds.X, bounds.Y);
+
+            outline = Rectangle.Intersect(bounds, outline);
+            if (outline.IsEmpty)
+            {
+                return;
+            }
+
+            g.FillRectangle(backBr, bounds);
+
+            if (CompModSwitches.DGRelationShpRowPaint.TraceVerbose)
+            {
+                Debug.WriteLine("Painting PlusMinusGlyph with outline -> " + outline.ToString());
+            }
+
+            // draw the +/- box
+            Pen drawPen = dgTable.IsDefault ? DataGrid.HeaderForePen : dgTable.HeaderForePen;
+            g.DrawRectangle(drawPen, outline.X, outline.Y, outline.Width - 1, outline.Height - 1);
+
+            int indent = 2;
+            // draw the -
+            g.DrawLine(drawPen,
+                       outline.X + indent, outline.Y + outline.Width / 2,
+                       outline.Right - indent - 1, outline.Y + outline.Width / 2);        // -1 on the y coordinate
+
+            if (!expanded)
+            {
+                // draw the vertical line to make +
+                g.DrawLine(drawPen,
+                           outline.X + outline.Height / 2, outline.Y + indent,
+                           outline.X + outline.Height / 2, outline.Bottom - indent - 1); // -1... hinting
+            }
+            else
+            {
+                Point[] points = new Point[3];
+                points[0] = new Point(outline.X + outline.Height / 2, outline.Bottom);
+
+                points[1] = new Point(points[0].X, bounds.Y + 2 * indent + base.Height);
+
+                points[2] = new Point(alignToRight ? bounds.X : bounds.Right,
+                                      points[1].Y);
+                g.DrawLines(drawPen, points);
+            }
+        }
+
+        private int RelationFromY(int y)
+        {
+            int relation = -1;
+            int relationshipHeight = dgTable.RelationshipHeight;
+            Rectangle relRect = GetRelationshipRect();
+            int cy = base.Height - dgTable.BorderWidth + System.Windows.Forms.DataGridTableStyle.relationshipSpacing;
+            while (cy < relRect.Bottom)
+            {
+                if (cy > y)
+                {
+                    break;
+                }
+
+                cy += relationshipHeight;
+                relation++;
+            }
+
+            if (relation >= dgTable.RelationsList.Count)
+            {
+                return -1;
+            }
+
+            return relation;
+        }
+
+        // given the relRect and the rowHeader, this function will return the
+        // X coordinate of the relationship rectangle as it should appear on the screen
+        private int MirrorRelationshipRectangle(Rectangle relRect, Rectangle rowHeader, bool alignToRight)
+        {
+            if (alignToRight)
+            {
+                return rowHeader.X - relRect.Width;
+            }
+            else
+            {
+                return relRect.X;
+            }
+        }
+
+        // given the X and Width of a rectangle R1 contained in rect,
+        // this will return the X coordinate of the rectangle that corresponds to R1 in Bi-Di transformation
+        private int MirrorRectangle(int x, int width, Rectangle rect, bool alignToRight)
+        {
+            if (alignToRight)
+            {
+                return rect.Right + rect.X - width - x;
+            }
+            else
+            {
+                return x;
+            }
+        }
+
+        [ComVisible(true)]
+        protected class DataGridRelationshipRowAccessibleObject : DataGridRowAccessibleObject
+        {
+            public DataGridRelationshipRowAccessibleObject(DataGridRow owner) : base(owner)
+            {
+            }
+
+            protected override void AddChildAccessibleObjects(IList children)
+            {
+                base.AddChildAccessibleObjects(children);
+                DataGridRelationshipRow row = (DataGridRelationshipRow)Owner;
+                if (row.dgTable.RelationsList != null)
+                {
+                    for (int i = 0; i < row.dgTable.RelationsList.Count; i++)
+                    {
+                        children.Add(new DataGridRelationshipAccessibleObject(row, i));
+                    }
+                }
+            }
+
+            private DataGridRelationshipRow RelationshipRow
+            {
+                get
+                {
+                    return (DataGridRelationshipRow)Owner;
+                }
+            }
+
+            public override string DefaultAction
+            {
+                get
+                {
+                    if (RelationshipRow.dgTable.RelationsList.Count > 0)
+                    {
+                        if (RelationshipRow.Expanded)
+                        {
+                            return SR.AccDGCollapse;
+                        }
+                        else
+                        {
+                            return SR.AccDGExpand;
+                        }
+                    }
+
+                    return null;
+                }
+            }
+
+            public override AccessibleStates State
+            {
+                get
+                {
+                    AccessibleStates state = base.State;
+                    if (RelationshipRow.dgTable.RelationsList.Count > 0)
+                    {
+                        if (((DataGridRelationshipRow)Owner).Expanded)
+                        {
+                            state |= AccessibleStates.Expanded;
+                        }
+                        else
+                        {
+                            state |= AccessibleStates.Collapsed;
+                        }
+                    }
+
+                    return state;
+                }
+            }
+
+            public override void DoDefaultAction()
+            {
+                if (RelationshipRow.dgTable.RelationsList.Count > 0)
+                {
+                    ((DataGridRelationshipRow)Owner).Expanded = !((DataGridRelationshipRow)Owner).Expanded;
+                }
+            }
+
+            public override AccessibleObject GetFocused()
+            {
+                DataGridRelationshipRow row = (DataGridRelationshipRow)Owner;
+                int focusRel = row.dgTable.FocusedRelation;
+                if (focusRel == -1)
+                {
+                    return base.GetFocused();
+                }
+                else
+                {
+                    return GetChild(GetChildCount() - row.dgTable.RelationsList.Count + focusRel);
+                }
+            }
+        }
+
+        [ComVisible(true)]
+        protected class DataGridRelationshipAccessibleObject : AccessibleObject
+        {
+            readonly DataGridRelationshipRow owner;
+            readonly int relationship;
+
+            public DataGridRelationshipAccessibleObject(DataGridRelationshipRow owner, int relationship) : base()
+            {
+                Debug.Assert(owner != null, "DataGridRelationshipAccessibleObject must have a valid owner DataGridRow");
+                this.owner = owner;
+                this.relationship = relationship;
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    Rectangle rowBounds = DataGrid.GetRowBounds(owner);
+
+                    Rectangle bounds = owner.Expanded ? owner.GetRelationshipRectWithMirroring() : Rectangle.Empty;
+                    bounds.Y += owner.dgTable.RelationshipHeight * relationship;
+                    bounds.Height = owner.Expanded ? owner.dgTable.RelationshipHeight : 0;      // when the row is collapsed the height of the relationship object should be 0
+                    // GetRelationshipRectWithMirroring will use the row headers width
+                    if (!owner.Expanded)
+                    {
+                        bounds.X += rowBounds.X;
+                    }
+
+                    bounds.Y += rowBounds.Y;
+
+                    return owner.DataGrid.RectangleToScreen(bounds);
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    return (string)owner.dgTable.RelationsList[relationship];
+                }
+            }
+
+            protected DataGridRelationshipRow Owner
+            {
+                get
+                {
+                    return owner;
+                }
+            }
+
+            public override AccessibleObject Parent
+            {
+                get
+                {
+                    return owner.AccessibleObject;
+                }
+            }
+
+            protected DataGrid DataGrid
+            {
+                get
+                {
+                    return owner.DataGrid;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    return AccessibleRole.Link;
+                }
+            }
+
+            public override AccessibleStates State
+            {
+                get
+                {
+                    DataGridRow[] dgRows = DataGrid.DataGridRows;
+                    if (Array.IndexOf(dgRows, owner) == -1)
+                    {
+                        return AccessibleStates.Unavailable;
+                    }
+
+                    AccessibleStates state = AccessibleStates.Selectable
+                        | AccessibleStates.Focusable
+                        | AccessibleStates.Linked;
+
+                    if (!owner.Expanded)
+                    {
+                        state |= AccessibleStates.Invisible;
+                    }
+
+                    if (DataGrid.Focused && Owner.dgTable.FocusedRelation == relationship)
+                    {
+                        state |= AccessibleStates.Focused;
+                    }
+
+                    return state;
+                }
+            }
+
+            public override string Value
+            {
+                get
+                {
+                    DataGridRow[] dgRows = DataGrid.DataGridRows;
+                    if (Array.IndexOf(dgRows, owner) == -1)
+                    {
+                        return null;
+                    }
+                    else
+                    {
+                        return (string)owner.dgTable.RelationsList[relationship];
+                    }
+                }
+                set
+                {
+                    // not supported
+                }
+            }
+
+            public override string DefaultAction
+            {
+                get
+                {
+                    return SR.AccDGNavigate;
+                }
+            }
+
+            public override void DoDefaultAction()
+            {
+                ((DataGridRelationshipRow)Owner).Expanded = true;
+                owner.FocusedRelation = -1;
+                DataGrid.NavigateTo((string)owner.dgTable.RelationsList[relationship], owner, true);
+                DataGrid.BeginInvoke(new MethodInvoker(ResetAccessibilityLayer));
+            }
+
+            private void ResetAccessibilityLayer()
+            {
+                ((DataGrid.DataGridAccessibleObject)DataGrid.AccessibilityObject).NotifyClients(AccessibleEvents.Reorder, 0);
+                ((DataGrid.DataGridAccessibleObject)DataGrid.AccessibilityObject).NotifyClients(AccessibleEvents.Focus, DataGrid.CurrentCellAccIndex);
+                ((DataGrid.DataGridAccessibleObject)DataGrid.AccessibilityObject).NotifyClients(AccessibleEvents.Selection, DataGrid.CurrentCellAccIndex);
+            }
+
+            /// <summary>
+            ///  Navigate to the next or previous grid entry.
+            /// </summary>
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                    case AccessibleNavigation.Down:
+                        if (relationship + 1 < owner.dgTable.RelationsList.Count)
+                        {
+                            return Parent.GetChild(Parent.GetChildCount() - owner.dgTable.RelationsList.Count + relationship + 1);
+                        }
+
+                        break;
+                    case AccessibleNavigation.Up:
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        if (relationship > 0)
+                        {
+                            return Parent.GetChild(Parent.GetChildCount() - owner.dgTable.RelationsList.Count + relationship - 1);
+                        }
+
+                        break;
+                }
+
+                return null;
+            }
+
+            public override void Select(AccessibleSelection flags)
+            {
+                // Focus the PropertyGridView window
+                //
+                if ((flags & AccessibleSelection.TakeFocus) == AccessibleSelection.TakeFocus)
+                {
+                    DataGrid.Focus();
+                }
+
+                if ((flags & AccessibleSelection.TakeSelection) == AccessibleSelection.TakeSelection)
+                {
+                    Owner.FocusedRelation = relationship;
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRow.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRow.cs
new file mode 100644
index 00000000000..6f0b0f00c39
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridRow.cs
@@ -0,0 +1,1199 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Encapsulates the painting logic for a new row added to a <see cref='Forms.DataGrid'/> control.
+    /// </summary>
+    internal abstract class DataGridRow : MarshalByRefObject
+    {
+        internal protected int number;             // row number
+        private bool selected;
+        private int height;
+        // protected DataRow   dataRow;
+        private IntPtr tooltipID = new IntPtr(-1);
+        private string tooltip = string.Empty;
+        AccessibleObject accessibleObject;
+
+        // for accessibility...
+        //
+        // internal DataGrid  dataGrid;
+
+        // will need this for the painting information ( row header color )
+        //
+        protected DataGridTableStyle dgTable;
+
+        // we will be mapping only the black color to
+        // the HeaderForeColor
+        //
+        private static readonly ColorMap[] colorMap = new ColorMap[] { new ColorMap() };
+
+        // bitmaps
+        //
+        private static Bitmap rightArrow;
+        private static Bitmap leftArrow;
+        private static Bitmap errorBmp;
+        private static Bitmap pencilBmp;
+        private static Bitmap starBmp;
+        protected const int xOffset = 3;
+        protected const int yOffset = 2;
+
+        /// <summary>
+        ///  Initializes a new instance of a <see cref='DataGridRow'/> .
+        /// </summary>
+        public DataGridRow(DataGrid dataGrid, DataGridTableStyle dgTable, int rowNumber)
+        {
+            if (dataGrid == null || dgTable.DataGrid == null)
+            {
+                throw new ArgumentNullException(nameof(dataGrid));
+            }
+
+            if (rowNumber < 0)
+            {
+                throw new ArgumentException(SR.DataGridRowRowNumber, nameof(rowNumber));
+            }
+
+            // this.dataGrid = dataGrid;
+            number = rowNumber;
+
+            // map the black color in the pictures to the DataGrid's HeaderForeColor
+            //
+            colorMap[0].OldColor = Color.Black;
+            colorMap[0].NewColor = dgTable.HeaderForeColor;
+
+            this.dgTable = dgTable;
+            height = MinimumRowHeight(dgTable);
+        }
+
+        public AccessibleObject AccessibleObject
+        {
+            get
+            {
+                if (accessibleObject == null)
+                {
+                    accessibleObject = CreateAccessibleObject();
+                }
+
+                return accessibleObject;
+            }
+        }
+
+        protected virtual AccessibleObject CreateAccessibleObject()
+        {
+            return new DataGridRowAccessibleObject(this);
+        }
+
+        internal protected virtual int MinimumRowHeight(DataGridTableStyle dgTable)
+        {
+            return MinimumRowHeight(dgTable.GridColumnStyles);
+        }
+
+        internal protected virtual int MinimumRowHeight(GridColumnStylesCollection columns)
+        {
+            int h = dgTable.IsDefault ? DataGrid.PreferredRowHeight : dgTable.PreferredRowHeight;
+
+            try
+            {
+                if (dgTable.DataGrid.DataSource != null)
+                {
+                    int nCols = columns.Count;
+                    for (int i = 0; i < nCols; ++i)
+                    {
+                        // if (columns[i].Visible && columns[i].PropertyDescriptor != null)
+                        if (columns[i].PropertyDescriptor != null)
+                        {
+                            h = Math.Max(h, columns[i].GetMinimumHeight());
+                        }
+                    }
+                }
+            }
+            catch
+            {
+            }
+
+            return h;
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Gets the <see cref='Forms.DataGrid'/> control the row belongs to.
+        /// </summary>
+        public DataGrid DataGrid
+        {
+            get
+            {
+                return dgTable.DataGrid;
+            }
+        }
+
+        internal DataGridTableStyle DataGridTableStyle
+        {
+            get
+            {
+                return dgTable;
+            }
+            set
+            {
+                dgTable = value;
+            }
+        }
+
+        /*
+        public DataGridTable DataGridTable {
+            get {
+                return dgTable;
+            }
+        }
+        */
+
+        /*
+        public DataRow DataRow {
+            get {
+                return dataRow;
+            }
+        }
+        */
+
+        /// <summary>
+        ///  Gets or sets the height of the row.
+        /// </summary>
+        public virtual int Height
+        {
+            get
+            {
+                return height;
+            }
+            set
+            {
+                // the height of the row should be at least 0.
+                // this way, if the row has a relationship list and the user resizes the row such that
+                // the new height does not accomodate the height of the relationship list
+                // the row will at least show the relationship list ( and not paint on the portion of the row above this one )
+                height = Math.Max(0, value);
+                // when we resize the row, or when we set the PreferredRowHeigth on the
+                // DataGridTableStyle, we change the height of the Row, which will cause to invalidate,
+                // then the grid itself will do another invalidate call.
+                dgTable.DataGrid.OnRowHeightChanged(this);
+            }
+        }
+
+        /// <summary>
+        ///  Gets the row's number.
+        /// </summary>
+        public int RowNumber
+        {
+            get
+            {
+                return number;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the row is selected.
+        /// </summary>
+        public virtual bool Selected
+        {
+            get
+            {
+                return selected;
+            }
+            set
+            {
+                selected = value;
+                InvalidateRow();
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Gets the bitmap associated with the row.
+        /// </summary>
+        protected Bitmap GetBitmap(string bitmapName)
+        {
+            try
+            {
+                return DpiHelper.GetBitmapFromIcon(typeof(DataGridCaption), bitmapName);
+            }
+            catch (Exception e)
+            {
+                Debug.Fail("Failed to load bitmap: " + bitmapName, e.ToString());
+                throw;
+            }
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, gets the <see cref='Rectangle'/>
+        ///  where a cell's contents gets painted.
+        /// </summary>
+        public virtual Rectangle GetCellBounds(int col)
+        {
+            int firstVisibleCol = dgTable.DataGrid.FirstVisibleColumn;
+            int cx = 0;
+            Rectangle cellBounds = new Rectangle();
+            GridColumnStylesCollection columns = dgTable.GridColumnStyles;
+            if (columns != null)
+            {
+                for (int i = firstVisibleCol; i < col; i++)
+                {
+                    if (columns[i].PropertyDescriptor != null)
+                    {
+                        cx += columns[i].Width;
+                    }
+                }
+
+                int borderWidth = dgTable.GridLineWidth;
+                cellBounds = new Rectangle(cx,
+                                     0,
+                                     columns[col].Width - borderWidth,
+                                     Height - borderWidth);
+            }
+
+            return cellBounds;
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, gets the <see cref='Rectangle'/> of the non-scrollable area of
+        ///  the row.
+        /// </summary>
+        public virtual Rectangle GetNonScrollableArea()
+        {
+            return Rectangle.Empty;
+        }
+
+        /// <summary>
+        ///  Gets or sets the bitmap displayed in the row header of a new row.
+        /// </summary>
+        protected Bitmap GetStarBitmap()
+        {
+            if (starBmp == null)
+            {
+                starBmp = GetBitmap("DataGridRow.star");
+            }
+
+            return starBmp;
+        }
+
+        /// <summary>
+        ///  Gets or sets the bitmap displayed in the row header that indicates a row can
+        ///  be edited.
+        /// </summary>
+        protected Bitmap GetPencilBitmap()
+        {
+            if (pencilBmp == null)
+            {
+                pencilBmp = GetBitmap("DataGridRow.pencil");
+            }
+
+            return pencilBmp;
+        }
+
+        /// <summary>
+        ///  Gets or sets the bitmap displayed on a row with an error.
+        /// </summary>
+        protected Bitmap GetErrorBitmap()
+        {
+            if (errorBmp == null)
+            {
+                errorBmp = GetBitmap("DataGridRow.error");
+            }
+
+            return errorBmp;
+        }
+
+        protected Bitmap GetLeftArrowBitmap()
+        {
+            if (leftArrow == null)
+            {
+                leftArrow = GetBitmap("DataGridRow.left");
+            }
+
+            return leftArrow;
+        }
+
+        protected Bitmap GetRightArrowBitmap()
+        {
+            if (rightArrow == null)
+            {
+                rightArrow = GetBitmap("DataGridRow.right");
+            }
+
+            return rightArrow;
+        }
+
+        public virtual void InvalidateRow()
+        {
+            dgTable.DataGrid.InvalidateRow(number);
+        }
+
+        public virtual void InvalidateRowRect(Rectangle r)
+        {
+            dgTable.DataGrid.InvalidateRowRect(number, r);
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, notifies the grid that an edit will
+        ///  occur.
+        /// </summary>
+        public virtual void OnEdit()
+        {
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, called by the <see cref='Forms.DataGrid'/> control when a key press occurs on a row with focus.
+        /// </summary>
+        public virtual bool OnKeyPress(Keys keyData)
+        {
+            int currentColIndex = dgTable.DataGrid.CurrentCell.ColumnNumber;
+            GridColumnStylesCollection columns = dgTable.GridColumnStyles;
+            if (columns != null && currentColIndex >= 0 && currentColIndex < columns.Count)
+            {
+                DataGridColumnStyle currentColumn = columns[currentColIndex];
+                if (currentColumn.KeyPress(RowNumber, keyData))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///  Called by the <see cref='Forms.DataGrid'/> when a click occurs in the row's client area
+        ///  specifed by the x and y coordinates and the specified <see cref='Rectangle'/>
+        ///  .
+        /// </summary>
+        public virtual bool OnMouseDown(int x, int y, Rectangle rowHeaders)
+        {
+            return OnMouseDown(x, y, rowHeaders, false);
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, is called by the <see cref='Forms.DataGrid'/> when a click occurs
+        ///  in the row's
+        ///  client area, specified by x and y coordinates.
+        /// </summary>
+        public virtual bool OnMouseDown(int x, int y, Rectangle rowHeaders, bool alignToRight)
+        {
+            // if we call base.OnMouseDown, then the row could not use this
+            // mouse click at all. in that case LoseChildFocus, so the edit control
+            // will become visible
+            LoseChildFocus(rowHeaders, alignToRight);
+
+            // we did not use this click at all.
+            return false;
+        }
+
+        public virtual bool OnMouseMove(int x, int y, Rectangle rowHeaders)
+        {
+            return false;
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, is called by the <see cref='Forms.DataGrid'/> when
+        ///  the mouse moves within the row's client area.
+        /// </summary>
+        public virtual bool OnMouseMove(int x, int y, Rectangle rowHeaders, bool alignToRight)
+        {
+            return false;
+        }
+
+        public virtual void OnMouseLeft(Rectangle rowHeaders, bool alignToRight)
+        {
+        }
+
+        public virtual void OnMouseLeft()
+        {
+        }
+
+        /// <summary>
+        ///  When overridden in a derived class, causes the RowEnter event to occur.
+        /// </summary>
+        public virtual void OnRowEnter() { }
+        public virtual void OnRowLeave() { }
+
+        // processes the Tab Key
+        // returns TRUE if the TAB key is processed
+        internal abstract bool ProcessTabKey(Keys keyData, Rectangle rowHeaders, bool alignToRight);
+
+        // tells the dataGridRow that it lost the focus
+        internal abstract void LoseChildFocus(Rectangle rowHeaders, bool alignToRight);
+
+        /// <summary>
+        ///  Paints the row.
+        /// </summary>
+        public abstract int Paint(Graphics g,
+                                 Rectangle dataBounds,
+                                 Rectangle rowBounds,
+                                 int firstVisibleColumn,
+                                 int numVisibleColumns);
+
+        public abstract int Paint(Graphics g,
+                                  Rectangle dataBounds,
+                                  Rectangle rowBounds,
+                                  int firstVisibleColumn,
+                                  int numVisibleColumns,
+                                  bool alignToRight);
+
+        /// <summary>
+        ///  Draws a border on the bottom DataGrid.GridLineWidth pixels
+        ///  of the bounding rectangle passed in.
+        /// </summary>
+        protected virtual void PaintBottomBorder(Graphics g, Rectangle bounds, int dataWidth)
+        {
+            PaintBottomBorder(g, bounds, dataWidth, dgTable.GridLineWidth, false);
+        }
+
+        protected virtual void PaintBottomBorder(Graphics g, Rectangle bounds, int dataWidth, int borderWidth, bool alignToRight)
+        {
+            // paint bottom border
+            Rectangle bottomBorder = new Rectangle(alignToRight ? bounds.Right - dataWidth : bounds.X,
+                                                   bounds.Bottom - borderWidth,
+                                                   dataWidth,
+                                                   borderWidth);
+
+            g.FillRectangle(dgTable.IsDefault ? DataGrid.GridLineBrush : dgTable.GridLineBrush, bottomBorder);
+
+            // paint any exposed region to the right
+            if (dataWidth < bounds.Width)
+            {
+                g.FillRectangle(dgTable.DataGrid.BackgroundBrush,
+                                alignToRight ? bounds.X : bottomBorder.Right,
+                                bottomBorder.Y,
+                                bounds.Width - bottomBorder.Width,
+                                borderWidth);
+            }
+        }
+
+        /// <summary>
+        ///  Paints the row.
+        /// </summary>
+        public virtual int PaintData(Graphics g,
+                                     Rectangle bounds,
+                                     int firstVisibleColumn,
+                                     int columnCount)
+        {
+            return PaintData(g, bounds, firstVisibleColumn, columnCount, false);
+        }
+
+        public virtual int PaintData(Graphics g,
+                                     Rectangle bounds,
+                                     int firstVisibleColumn,
+                                     int columnCount,
+                                     bool alignToRight)
+        {
+            Debug.WriteLineIf(CompModSwitches.DGRowPaint.TraceVerbose, "Painting DataGridAddNewRow: bounds = " + bounds.ToString());
+
+            Rectangle cellBounds = bounds;
+            int bWidth = dgTable.IsDefault ? DataGrid.GridLineWidth : dgTable.GridLineWidth;
+            int cx = 0;
+
+            DataGridCell current = dgTable.DataGrid.CurrentCell;
+
+            GridColumnStylesCollection columns = dgTable.GridColumnStyles;
+            int nCols = columns.Count;
+            for (int col = firstVisibleColumn; col < nCols; ++col)
+            {
+                if (cx > bounds.Width)
+                {
+                    break;
+                }
+
+                // if (!columns[col].Visible || columns[col].PropertyDescriptor == null)
+                if (columns[col].PropertyDescriptor == null || columns[col].Width <= 0)
+                {
+                    continue;
+                }
+
+                cellBounds.Width = columns[col].Width - bWidth;
+
+                if (alignToRight)
+                {
+                    cellBounds.X = bounds.Right - cx - cellBounds.Width;
+                }
+                else
+                {
+                    cellBounds.X = bounds.X + cx;
+                }
+
+                // Paint the data with the the DataGridColumn
+                Brush backBr = BackBrushForDataPaint(ref current, columns[col], col);
+                Brush foreBrush = ForeBrushForDataPaint(ref current, columns[col], col);
+
+                PaintCellContents(g,
+                                  cellBounds,
+                                  columns[col],
+                                  backBr,
+                                  foreBrush,
+                                  alignToRight);
+
+                // Paint the border to the right of each cell
+                if (bWidth > 0)
+                {
+                    g.FillRectangle(dgTable.IsDefault ? DataGrid.GridLineBrush : dgTable.GridLineBrush,
+                                    alignToRight ? cellBounds.X - bWidth : cellBounds.Right,
+                                    cellBounds.Y,
+                                    bWidth,
+                                    cellBounds.Height);
+                }
+
+                cx += cellBounds.Width + bWidth;
+            }
+
+            // Paint any exposed area to the right ( or left ) of the data cell area
+            if (cx < bounds.Width)
+            {
+                g.FillRectangle(dgTable.DataGrid.BackgroundBrush,
+                                alignToRight ? bounds.X : bounds.X + cx,
+                                bounds.Y,
+                                bounds.Width - cx,
+                                bounds.Height);
+            }
+
+            return cx;
+        }
+
+        protected virtual void PaintCellContents(Graphics g, Rectangle cellBounds, DataGridColumnStyle column,
+                                                 Brush backBr, Brush foreBrush)
+        {
+            PaintCellContents(g, cellBounds, column, backBr, foreBrush, false);
+        }
+
+        protected virtual void PaintCellContents(Graphics g, Rectangle cellBounds, DataGridColumnStyle column,
+                                                 Brush backBr, Brush foreBrush, bool alignToRight)
+        {
+            g.FillRectangle(backBr, cellBounds);
+        }
+
+        //
+        // This function will do the following: if paintIcon is set to true, then
+        // will draw the image on the RowHeader. if paintIcon is set to false,
+        // then this function will fill the rectangle on which otherwise will
+        // have been drawn the image
+        //
+        // will return the rectangle that includes the Icon
+        //
+        protected Rectangle PaintIcon(Graphics g, Rectangle visualBounds, bool paintIcon, bool alignToRight, Bitmap bmp)
+        {
+            return PaintIcon(g, visualBounds, paintIcon, alignToRight, bmp,
+                             dgTable.IsDefault ? DataGrid.HeaderBackBrush : dgTable.HeaderBackBrush);
+        }
+
+        protected Rectangle PaintIcon(Graphics g, Rectangle visualBounds, bool paintIcon, bool alignToRight, Bitmap bmp, Brush backBrush)
+        {
+            Size bmpSize = bmp.Size;
+            Rectangle bmpRect = new Rectangle(alignToRight ? visualBounds.Right - xOffset - bmpSize.Width : visualBounds.X + xOffset,
+                                              visualBounds.Y + yOffset,
+                                              bmpSize.Width,
+                                              bmpSize.Height);
+            g.FillRectangle(backBrush, visualBounds);
+            if (paintIcon)
+            {
+                colorMap[0].NewColor = dgTable.IsDefault ? DataGrid.HeaderForeColor : dgTable.HeaderForeColor;
+                colorMap[0].OldColor = Color.Black;
+                ImageAttributes attr = new ImageAttributes();
+                attr.SetRemapTable(colorMap, ColorAdjustType.Bitmap);
+                g.DrawImage(bmp, bmpRect, 0, 0, bmpRect.Width, bmpRect.Height, GraphicsUnit.Pixel, attr);
+                // g.DrawImage(bmp, bmpRect);
+                attr.Dispose();
+            }
+
+            return bmpRect;
+        }
+
+        // assume that the row is not aligned to right, and that the row is not dirty
+        public virtual void PaintHeader(Graphics g, Rectangle visualBounds)
+        {
+            PaintHeader(g, visualBounds, false);
+        }
+
+        // assume that the row is not dirty
+        public virtual void PaintHeader(Graphics g, Rectangle visualBounds, bool alignToRight)
+        {
+            PaintHeader(g, visualBounds, alignToRight, false);
+        }
+
+        public virtual void PaintHeader(Graphics g, Rectangle visualBounds, bool alignToRight, bool rowIsDirty)
+        {
+            Rectangle bounds = visualBounds;
+
+            // paint the first part of the row header: the Arror or Pencil/Star
+            Bitmap bmp;
+            if (this is DataGridAddNewRow)
+            {
+                bmp = GetStarBitmap();
+                lock (bmp)
+                {
+                    bounds.X += PaintIcon(g, bounds, true, alignToRight, bmp).Width + xOffset;
+                }
+
+                return;
+            }
+            else if (rowIsDirty)
+            {
+                bmp = GetPencilBitmap();
+                lock (bmp)
+                {
+                    bounds.X += PaintIcon(g, bounds, RowNumber == DataGrid.CurrentCell.RowNumber, alignToRight, bmp).Width + xOffset;
+                }
+            }
+            else
+            {
+                bmp = alignToRight ? GetLeftArrowBitmap() : GetRightArrowBitmap();
+                lock (bmp)
+                {
+                    bounds.X += PaintIcon(g, bounds, RowNumber == DataGrid.CurrentCell.RowNumber, alignToRight, bmp).Width + xOffset;
+                }
+            }
+
+            // Paint the error icon
+            //
+            object errorInfo = DataGrid.ListManager[number];
+            if (!(errorInfo is IDataErrorInfo))
+            {
+                return;
+            }
+
+            string errString = ((IDataErrorInfo)errorInfo).Error;
+            if (errString == null)
+            {
+                errString = string.Empty;
+            }
+
+            if (tooltip != errString)
+            {
+                if (!string.IsNullOrEmpty(tooltip))
+                {
+                    DataGrid.ToolTipProvider.RemoveToolTip(tooltipID);
+                    tooltip = string.Empty;
+                    tooltipID = new IntPtr(-1);
+                }
+            }
+
+            if (string.IsNullOrEmpty(errString))
+            {
+                return;
+            }
+
+            // we now have an error string: paint the errorIcon and add the tooltip
+            Rectangle errRect;
+            bmp = GetErrorBitmap();
+            lock (bmp)
+            {
+                errRect = PaintIcon(g, bounds, true, alignToRight, bmp);
+            }
+
+            bounds.X += errRect.Width + xOffset;
+
+            tooltip = errString;
+            tooltipID = (IntPtr)((int)DataGrid.ToolTipId++);
+            DataGrid.ToolTipProvider.AddToolTip(tooltip, tooltipID, errRect);
+        }
+
+        protected Brush GetBackBrush()
+        {
+            Brush br = dgTable.IsDefault ? DataGrid.BackBrush : dgTable.BackBrush;
+            if (DataGrid.LedgerStyle && (RowNumber % 2 == 1))
+            {
+                br = dgTable.IsDefault ? DataGrid.AlternatingBackBrush : dgTable.AlternatingBackBrush;
+            }
+
+            return br;
+        }
+
+        /// <summary>
+        ///  Returns the BackColor and TextColor  that the Graphics object should use
+        ///  for the appropriate values for a given row and column when painting the data.
+        /// </summary>
+        protected Brush BackBrushForDataPaint(ref DataGridCell current, DataGridColumnStyle gridColumn, int column)
+        {
+            Brush backBr = GetBackBrush();
+
+            if (Selected)
+            {
+                backBr = dgTable.IsDefault ? DataGrid.SelectionBackBrush : dgTable.SelectionBackBrush;
+            }
+
+            /*
+            if (RowNumber == current.RowNumber && column == current.ColumnNumber) {
+                backBr = grid.CurrentCellBackBrush;
+            }
+            */
+            return backBr;
+        }
+
+        protected Brush ForeBrushForDataPaint(ref DataGridCell current, DataGridColumnStyle gridColumn, int column)
+        {
+            // Brush foreBrush = gridColumn.ForeBrush;
+            Brush foreBrush = dgTable.IsDefault ? DataGrid.ForeBrush : dgTable.ForeBrush;
+
+            if (Selected)
+            {
+                foreBrush = dgTable.IsDefault ? DataGrid.SelectionForeBrush : dgTable.SelectionForeBrush;
+            }
+
+            /*
+            if (RowNumber == current.RowNumber && column == current.ColumnNumber) {
+                foreColor = grid.CurrentCellForeColor;
+            }
+            */
+            return foreBrush;
+        }
+
+        [ComVisible(true)]
+        protected class DataGridRowAccessibleObject : AccessibleObject
+        {
+            ArrayList cells;
+            readonly DataGridRow owner;
+
+            internal static string CellToDisplayString(DataGrid grid, int row, int column)
+            {
+                if (column < grid.myGridTable.GridColumnStyles.Count)
+                {
+                    return grid.myGridTable.GridColumnStyles[column].PropertyDescriptor.Converter.ConvertToString(grid[row, column]);
+                }
+                else
+                {
+                    return "";
+                }
+            }
+
+            internal static object DisplayStringToCell(DataGrid grid, int row, int column, string value)
+            {
+                if (column < grid.myGridTable.GridColumnStyles.Count)
+                {
+                    return grid.myGridTable.GridColumnStyles[column].PropertyDescriptor.Converter.ConvertFromString(value);
+                }
+
+                // ignore...
+                //
+                return null;
+            }
+
+            public DataGridRowAccessibleObject(DataGridRow owner) : base()
+            {
+                Debug.Assert(owner != null, "DataGridRowAccessibleObject must have a valid owner DataGridRow");
+                this.owner = owner;
+                DataGrid grid = DataGrid;
+                Debug.WriteLineIf(DataGrid.DataGridAcc.TraceVerbose, "Create row accessible object");
+
+                EnsureChildren();
+            }
+
+            private void EnsureChildren()
+            {
+                if (cells == null)
+                {
+                    // default size... little extra for relationships...
+                    //
+                    cells = new ArrayList(DataGrid.myGridTable.GridColumnStyles.Count + 2);
+                    AddChildAccessibleObjects(cells);
+                }
+            }
+
+            protected virtual void AddChildAccessibleObjects(IList children)
+            {
+                Debug.WriteLineIf(DataGrid.DataGridAcc.TraceVerbose, "Create row's accessible children");
+                Debug.Indent();
+                GridColumnStylesCollection cols = DataGrid.myGridTable.GridColumnStyles;
+                int len = cols.Count;
+                Debug.WriteLineIf(DataGrid.DataGridAcc.TraceVerbose, len + " columns present");
+                for (int i = 0; i < len; i++)
+                {
+                    children.Add(CreateCellAccessibleObject(i));
+                }
+
+                Debug.Unindent();
+            }
+
+            protected virtual AccessibleObject CreateCellAccessibleObject(int column)
+            {
+                return new DataGridCellAccessibleObject(owner, column);
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    return DataGrid.RectangleToScreen(DataGrid.GetRowBounds(owner));
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    if (owner is DataGridAddNewRow)
+                    {
+                        return SR.AccDGNewRow;
+                    }
+                    else
+                    {
+                        return DataGridRowAccessibleObject.CellToDisplayString(DataGrid, owner.RowNumber, 0);
+                    }
+                }
+            }
+
+            protected DataGridRow Owner
+            {
+                get
+                {
+                    return owner;
+                }
+            }
+
+            public override AccessibleObject Parent
+            {
+                get
+                {
+                    return DataGrid.AccessibilityObject;
+                }
+            }
+
+            private DataGrid DataGrid
+            {
+                get
+                {
+                    return owner.DataGrid;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    return AccessibleRole.Row;
+                }
+            }
+
+            public override AccessibleStates State
+            {
+                get
+                {
+                    AccessibleStates state = AccessibleStates.Selectable | AccessibleStates.Focusable;
+
+                    // Determine focus
+                    //
+                    if (DataGrid.CurrentCell.RowNumber == owner.RowNumber)
+                    {
+                        state |= AccessibleStates.Focused;
+                    }
+
+                    // Determine selected
+                    //
+                    if (DataGrid.CurrentRowIndex == owner.RowNumber)
+                    {
+                        state |= AccessibleStates.Selected;
+                    }
+
+                    return state;
+                }
+            }
+
+            public override string Value
+            {
+                get
+                {
+                    return Name;
+                }
+            }
+
+            public override AccessibleObject GetChild(int index)
+            {
+                if (index < cells.Count)
+                {
+                    return (AccessibleObject)cells[index];
+                }
+
+                return null;
+            }
+
+            public override int GetChildCount()
+            {
+                return cells.Count;
+            }
+
+            /// <summary>
+            ///  Returns the currently focused child, if any.
+            ///  Returns this if the object itself is focused.
+            /// </summary>
+            public override AccessibleObject GetFocused()
+            {
+                if (DataGrid.Focused)
+                {
+                    DataGridCell cell = DataGrid.CurrentCell;
+                    if (cell.RowNumber == owner.RowNumber)
+                    {
+                        return (AccessibleObject)cells[cell.ColumnNumber];
+                    }
+                }
+
+                return null;
+            }
+
+            /// <summary>
+            ///  Navigate to the next or previous grid entry.entry.
+            /// </summary>
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Down:
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                        return DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber + 1);
+
+                    case AccessibleNavigation.Up:
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        return DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber - 1);
+
+                    case AccessibleNavigation.FirstChild:
+                        if (GetChildCount() > 0)
+                        {
+                            return GetChild(0);
+                        }
+
+                        break;
+                    case AccessibleNavigation.LastChild:
+                        if (GetChildCount() > 0)
+                        {
+                            return GetChild(GetChildCount() - 1);
+                        }
+
+                        break;
+                }
+
+                return null;
+            }
+
+            public override void Select(AccessibleSelection flags)
+            {
+                // Focus the PropertyGridView window
+                //
+                if ((flags & AccessibleSelection.TakeFocus) == AccessibleSelection.TakeFocus)
+                {
+                    DataGrid.Focus();
+                }
+
+                // Select the grid entry
+                //
+                if ((flags & AccessibleSelection.TakeSelection) == AccessibleSelection.TakeSelection)
+                {
+                    DataGrid.CurrentRowIndex = owner.RowNumber;
+                }
+            }
+        }
+
+        [ComVisible(true)]
+        protected class DataGridCellAccessibleObject : AccessibleObject
+        {
+            readonly DataGridRow owner;
+            readonly int column;
+
+            public DataGridCellAccessibleObject(DataGridRow owner, int column) : base()
+            {
+                Debug.Assert(owner != null, "DataGridColumnAccessibleObject must have a valid owner DataGridRow");
+                this.owner = owner;
+                this.column = column;
+                Debug.WriteLineIf(DataGrid.DataGridAcc.TraceVerbose, "Create cell accessible object");
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    return DataGrid.RectangleToScreen(DataGrid.GetCellBounds(new DataGridCell(owner.RowNumber, column)));
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    return DataGrid.myGridTable.GridColumnStyles[column].HeaderText;
+                }
+            }
+
+            public override AccessibleObject Parent
+            {
+                get
+                {
+                    return owner.AccessibleObject;
+                }
+            }
+
+            protected DataGrid DataGrid
+            {
+                get
+                {
+                    return owner.DataGrid;
+                }
+            }
+
+            public override string DefaultAction
+            {
+                get
+                {
+                    return SR.AccDGEdit;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    return AccessibleRole.Cell;
+                }
+            }
+
+            public override AccessibleStates State
+            {
+                get
+                {
+                    AccessibleStates state = AccessibleStates.Selectable | AccessibleStates.Focusable;
+
+                    // Determine focus
+                    //
+                    if (DataGrid.CurrentCell.RowNumber == owner.RowNumber
+                        && DataGrid.CurrentCell.ColumnNumber == column)
+                    {
+                        if (DataGrid.Focused)
+                        {
+                            state |= AccessibleStates.Focused;
+                        }
+
+                        state |= AccessibleStates.Selected;
+                    }
+
+                    return state;
+                }
+            }
+
+            public override string Value
+            {
+                get
+                {
+                    if (owner is DataGridAddNewRow)
+                    {
+                        return null;
+                    }
+                    else
+                    {
+                        return DataGridRowAccessibleObject.CellToDisplayString(DataGrid, owner.RowNumber, column);
+                    }
+                }
+
+                set
+                {
+                    if (!(owner is DataGridAddNewRow))
+                    {
+                        object realValue = DataGridRowAccessibleObject.DisplayStringToCell(DataGrid, owner.RowNumber, column, value);
+                        DataGrid[owner.RowNumber, column] = realValue;
+                    }
+                }
+            }
+
+            public override void DoDefaultAction()
+            {
+                Select(AccessibleSelection.TakeFocus | AccessibleSelection.TakeSelection);
+            }
+
+            /// <summary>
+            ///  Returns the currently focused child, if any.
+            ///  Returns this if the object itself is focused.
+            /// </summary>
+            public override AccessibleObject GetFocused()
+            {
+                // Datagrid always returns the cell as the focused thing... so do we!
+                //
+                return DataGrid.AccessibilityObject.GetFocused();
+            }
+
+            /// <summary>
+            ///  Navigate to the next or previous grid entry.
+            /// </summary>
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                        if (column < owner.AccessibleObject.GetChildCount() - 1)
+                        {
+                            return owner.AccessibleObject.GetChild(column + 1);
+                        }
+                        else
+                        {
+                            AccessibleObject o = DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber + 1);
+                            if (o != null)
+                            {
+                                return o.Navigate(AccessibleNavigation.FirstChild);
+                            }
+                        }
+
+                        break;
+                    case AccessibleNavigation.Down:
+                        return DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber + 1).Navigate(AccessibleNavigation.FirstChild);
+                    case AccessibleNavigation.Up:
+                        return DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber - 1).Navigate(AccessibleNavigation.FirstChild);
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        if (column > 0)
+                        {
+                            return owner.AccessibleObject.GetChild(column - 1);
+                        }
+                        else
+                        {
+                            AccessibleObject o = DataGrid.AccessibilityObject.GetChild(1 + owner.dgTable.GridColumnStyles.Count + owner.RowNumber - 1);
+                            if (o != null)
+                            {
+                                return o.Navigate(AccessibleNavigation.LastChild);
+                            }
+                        }
+
+                        break;
+
+                    case AccessibleNavigation.FirstChild:
+                    case AccessibleNavigation.LastChild:
+
+                        break;
+                }
+
+                return null;
+            }
+
+            public override void Select(AccessibleSelection flags)
+            {
+                // Focus the PropertyGridView window
+                //
+                if ((flags & AccessibleSelection.TakeFocus) == AccessibleSelection.TakeFocus)
+                {
+                    DataGrid.Focus();
+                }
+
+                // Select the grid entry
+                //
+                if ((flags & AccessibleSelection.TakeSelection) == AccessibleSelection.TakeSelection)
+                {
+                    DataGrid.CurrentCell = new DataGridCell(owner.RowNumber, column);
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridState.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridState.cs
new file mode 100644
index 00000000000..22b36e98ddc
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridState.cs
@@ -0,0 +1,262 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Encapsulates the state of a DataGrid that changes when the
+    ///  user navigates back and forth through ADO.NET data relations.
+    /// </summary>
+    internal sealed class DataGridState : ICloneable
+    {
+        // fields
+        //
+        public object DataSource;
+        public string DataMember;
+        public CurrencyManager ListManager;
+        public DataGridRow[] DataGridRows = Array.Empty<DataGridRow>();
+        public DataGrid DataGrid;
+        public int DataGridRowsLength;
+        public GridColumnStylesCollection GridColumnStyles;
+
+        public int FirstVisibleRow;
+        public int FirstVisibleCol;
+
+        public int CurrentRow;
+        public int CurrentCol;
+
+        public DataGridRow LinkingRow;
+        AccessibleObject parentRowAccessibleObject;
+
+        public DataGridState()
+        {
+        }
+
+        public DataGridState(DataGrid dataGrid)
+        {
+            PushState(dataGrid);
+        }
+
+        internal AccessibleObject ParentRowAccessibleObject
+        {
+            get
+            {
+                if (parentRowAccessibleObject == null)
+                {
+                    parentRowAccessibleObject = new DataGridStateParentRowAccessibleObject(this);
+                }
+
+                return parentRowAccessibleObject;
+            }
+        }
+
+        // methods
+        //
+
+        public object Clone()
+        {
+            DataGridState dgs = new DataGridState
+            {
+                DataGridRows = DataGridRows,
+                DataSource = DataSource,
+                DataMember = DataMember,
+                FirstVisibleRow = FirstVisibleRow,
+                FirstVisibleCol = FirstVisibleCol,
+                CurrentRow = CurrentRow,
+                CurrentCol = CurrentCol,
+                GridColumnStyles = GridColumnStyles,
+                ListManager = ListManager,
+                DataGrid = DataGrid
+            };
+            return dgs;
+        }
+
+        /// <summary>
+        ///  Called by a DataGrid when it wishes to preserve its
+        ///  transient state in the current DataGridState object.
+        /// </summary>
+        public void PushState(DataGrid dataGrid)
+        {
+            DataSource = dataGrid.DataSource;
+            DataMember = dataGrid.DataMember;
+            DataGrid = dataGrid;
+            DataGridRows = dataGrid.DataGridRows;
+            DataGridRowsLength = dataGrid.DataGridRowsLength;
+            FirstVisibleRow = dataGrid.firstVisibleRow;
+            FirstVisibleCol = dataGrid.firstVisibleCol;
+            CurrentRow = dataGrid.currentRow;
+            GridColumnStyles = new GridColumnStylesCollection(dataGrid.myGridTable);
+
+            GridColumnStyles.Clear();
+            foreach (DataGridColumnStyle style in dataGrid.myGridTable.GridColumnStyles)
+            {
+                GridColumnStyles.Add(style);
+            }
+
+            ListManager = dataGrid.ListManager;
+            ListManager.ItemChanged += new ItemChangedEventHandler(DataSource_Changed);
+            ListManager.MetaDataChanged += new EventHandler(DataSource_MetaDataChanged);
+            CurrentCol = dataGrid.currentCol;
+        }
+
+        // this is needed so that the parent rows will remove notification from the list
+        // when the datagridstate is no longer needed;
+        public void RemoveChangeNotification()
+        {
+            ListManager.ItemChanged -= new ItemChangedEventHandler(DataSource_Changed);
+            ListManager.MetaDataChanged -= new EventHandler(DataSource_MetaDataChanged);
+        }
+
+        /// <summary>
+        ///  Called by a grid when it wishes to match its transient
+        ///  state with the current DataGridState object.
+        /// </summary>
+        public void PullState(DataGrid dataGrid, bool createColumn)
+        {
+            // dataGrid.DataSource = DataSource;
+            // dataGrid.DataMember = DataMember;
+            dataGrid.Set_ListManager(DataSource, DataMember, true, createColumn);   // true for forcing new listManager,
+
+            /*
+            if (DataSource.Table.ParentRelations.Count > 0)
+                dataGrid.PopulateColumns();
+            */
+
+            dataGrid.firstVisibleRow = FirstVisibleRow;
+            dataGrid.firstVisibleCol = FirstVisibleCol;
+            dataGrid.currentRow = CurrentRow;
+            dataGrid.currentCol = CurrentCol;
+            dataGrid.SetDataGridRows(DataGridRows, DataGridRowsLength);
+        }
+
+        private void DataSource_Changed(object sender, ItemChangedEventArgs e)
+        {
+            if (DataGrid != null && ListManager.Position == e.Index)
+            {
+                DataGrid.InvalidateParentRows();
+                return;
+            }
+
+            if (DataGrid != null)
+            {
+                DataGrid.ParentRowsDataChanged();
+            }
+        }
+
+        private void DataSource_MetaDataChanged(object sender, EventArgs e)
+        {
+            if (DataGrid != null)
+            {
+                DataGrid.ParentRowsDataChanged();
+            }
+        }
+
+        [ComVisible(true)]
+        internal class DataGridStateParentRowAccessibleObject : AccessibleObject
+        {
+            readonly DataGridState owner;
+
+            public DataGridStateParentRowAccessibleObject(DataGridState owner) : base()
+            {
+                Debug.Assert(owner != null, "DataGridRowAccessibleObject must have a valid owner DataGridRow");
+                this.owner = owner;
+            }
+
+            public override Rectangle Bounds
+            {
+                get
+                {
+                    DataGridParentRows dataGridParentRows = ((DataGridParentRows.DataGridParentRowsAccessibleObject)Parent).Owner;
+                    DataGrid g = owner.LinkingRow.DataGrid;
+                    Rectangle r = dataGridParentRows.GetBoundsForDataGridStateAccesibility(owner);
+                    r.Y += g.ParentRowsBounds.Y;
+                    return g.RectangleToScreen(r);
+                }
+            }
+
+            public override string Name
+            {
+                get
+                {
+                    return SR.AccDGParentRow;
+                }
+            }
+
+            public override AccessibleObject Parent
+            {
+                get
+                {
+                    return owner.LinkingRow.DataGrid.ParentRowsAccessibleObject;
+                }
+            }
+
+            public override AccessibleRole Role
+            {
+                get
+                {
+                    return AccessibleRole.ListItem;
+                }
+            }
+
+            public override string Value
+            {
+                get
+                {
+                    StringBuilder sb = new StringBuilder();
+
+                    CurrencyManager source = (CurrencyManager)owner.LinkingRow.DataGrid.BindingContext[owner.DataSource, owner.DataMember];
+
+                    sb.Append(owner.ListManager.GetListName());
+                    sb.Append(": ");
+
+                    bool needComma = false;
+                    foreach (DataGridColumnStyle col in owner.GridColumnStyles)
+                    {
+                        if (needComma)
+                        {
+                            sb.Append(", ");
+                        }
+
+                        string colName = col.HeaderText;
+                        string cellValue = col.PropertyDescriptor.Converter.ConvertToString(col.PropertyDescriptor.GetValue(source.Current));
+                        sb.Append(colName);
+                        sb.Append(": ");
+                        sb.Append(cellValue);
+                        needComma = true;
+                    }
+
+                    return sb.ToString();
+                }
+            }
+
+            /// <summary>
+            ///  Navigate to the next or previous grid entry.
+            /// </summary>
+            public override AccessibleObject Navigate(AccessibleNavigation navdir)
+            {
+                DataGridParentRows.DataGridParentRowsAccessibleObject parentAcc = (DataGridParentRows.DataGridParentRowsAccessibleObject)Parent;
+
+                switch (navdir)
+                {
+                    case AccessibleNavigation.Down:
+                    case AccessibleNavigation.Right:
+                    case AccessibleNavigation.Next:
+                        return parentAcc.GetNext(this);
+                    case AccessibleNavigation.Up:
+                    case AccessibleNavigation.Left:
+                    case AccessibleNavigation.Previous:
+                        return parentAcc.GetPrev(this);
+                }
+
+                return null;
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTableStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTableStyle.cs
new file mode 100644
index 00000000000..f7ae92ee159
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTableStyle.cs
@@ -0,0 +1,1812 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents the table drawn by the <see cref='Forms.DataGrid'/> control at run time.
+    /// </summary>
+    [
+    ToolboxItem(false),
+    DesignTimeVisible(false),
+    //DefaultProperty("GridTableName")
+    ]
+    public class DataGridTableStyle : Component, IDataGridEditingService
+    {
+        // internal for DataGridColumn accessibility...
+        //
+        internal DataGrid dataGrid;
+
+        // relationship UI
+        private int relationshipHeight;
+        internal const int relationshipSpacing = 1;
+        private Rectangle relationshipRect = Rectangle.Empty;
+        private int focusedRelation = -1;
+        private int focusedTextWidth;
+
+        // will contain a list of relationships that this table has
+        private readonly ArrayList relationsList = new ArrayList(2);
+
+        // the name of the table
+        private string mappingName = string.Empty;
+        private readonly GridColumnStylesCollection gridColumns;
+        private bool readOnly;
+        private readonly bool isDefaultTableStyle;
+
+        private static readonly object EventAllowSorting = new object();
+        private static readonly object EventGridLineColor = new object();
+        private static readonly object EventGridLineStyle = new object();
+        private static readonly object EventHeaderBackColor = new object();
+        private static readonly object EventHeaderForeColor = new object();
+        private static readonly object EventHeaderFont = new object();
+        private static readonly object EventLinkColor = new object();
+        private static readonly object EventLinkHoverColor = new object();
+        private static readonly object EventPreferredColumnWidth = new object();
+        private static readonly object EventPreferredRowHeight = new object();
+        private static readonly object EventColumnHeadersVisible = new object();
+        private static readonly object EventRowHeaderWidth = new object();
+        private static readonly object EventSelectionBackColor = new object();
+        private static readonly object EventSelectionForeColor = new object();
+        private static readonly object EventMappingName = new object();
+        private static readonly object EventAlternatingBackColor = new object();
+        private static readonly object EventBackColor = new object();
+        private static readonly object EventForeColor = new object();
+        private static readonly object EventReadOnly = new object();
+        private static readonly object EventRowHeadersVisible = new object();
+
+        // add a bunch of properties, taken from the dataGrid
+        //
+
+        // default values
+        //
+        private const bool defaultAllowSorting = true;
+        private const DataGridLineStyle defaultGridLineStyle = DataGridLineStyle.Solid;
+        private const int defaultPreferredColumnWidth = 75;
+        private const int defaultRowHeaderWidth = 35;
+        internal static readonly Font defaultFont = Control.DefaultFont;
+        internal static readonly int defaultFontHeight = defaultFont.Height;
+
+        // the actual place holders for properties
+        //
+        private bool allowSorting = defaultAllowSorting;
+        private SolidBrush alternatingBackBrush = DefaultAlternatingBackBrush;
+        private SolidBrush backBrush = DefaultBackBrush;
+        private SolidBrush foreBrush = DefaultForeBrush;
+        private SolidBrush gridLineBrush = DefaultGridLineBrush;
+        private DataGridLineStyle gridLineStyle = defaultGridLineStyle;
+        internal SolidBrush headerBackBrush = DefaultHeaderBackBrush;
+        internal Font headerFont; // this is ambient property to Font value.
+        internal SolidBrush headerForeBrush = DefaultHeaderForeBrush;
+        internal Pen headerForePen = DefaultHeaderForePen;
+        private SolidBrush linkBrush = DefaultLinkBrush;
+        internal int preferredColumnWidth = defaultPreferredColumnWidth;
+        private int preferredRowHeight = defaultFontHeight + 3;
+        private SolidBrush selectionBackBrush = DefaultSelectionBackBrush;
+        private SolidBrush selectionForeBrush = DefaultSelectionForeBrush;
+        private int rowHeaderWidth = defaultRowHeaderWidth;
+        private bool rowHeadersVisible = true;
+        private bool columnHeadersVisible = true;
+
+        // the dataGrid would need to know when the ColumnHeaderVisible, RowHeadersVisible, RowHeaderWidth
+        // and preferredColumnWidth, preferredRowHeight properties are changed in the current dataGridTableStyle
+        // also: for GridLineStyle, GridLineColor, ForeColor, BackColor, HeaderBackColor, HeaderFont, HeaderForeColor
+        // LinkColor, LinkHoverColor
+        //
+
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(defaultAllowSorting),
+        SRDescription(nameof(SR.DataGridAllowSortingDescr))
+        ]
+        public bool AllowSorting
+        {
+            get
+            {
+                return allowSorting;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(AllowSorting)));
+                }
+
+                if (allowSorting != value)
+                {
+                    allowSorting = value;
+                    OnAllowSortingChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  [To be  supplied]
+        /// </summary>
+        public event EventHandler AllowSortingChanged
+        {
+            add => Events.AddHandler(EventAllowSorting, value);
+            remove => Events.RemoveHandler(EventAllowSorting, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridAlternatingBackColorDescr))
+        ]
+        public Color AlternatingBackColor
+        {
+            get
+            {
+                return alternatingBackBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(AlternatingBackColor)));
+                }
+
+                if (System.Windows.Forms.DataGrid.IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTableStyleTransparentAlternatingBackColorNotAllowed, nameof(value));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(AlternatingBackColor)), nameof(value));
+                }
+
+                if (!alternatingBackBrush.Color.Equals(value))
+                {
+                    alternatingBackBrush = new SolidBrush(value);
+                    InvalidateInside();
+                    OnAlternatingBackColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler AlternatingBackColorChanged
+        {
+            add => Events.AddHandler(EventAlternatingBackColor, value);
+            remove => Events.RemoveHandler(EventAlternatingBackColor, value);
+        }
+
+        public void ResetAlternatingBackColor()
+        {
+            if (ShouldSerializeAlternatingBackColor())
+            {
+                AlternatingBackColor = DefaultAlternatingBackBrush.Color;
+                InvalidateInside();
+            }
+        }
+
+        protected virtual bool ShouldSerializeAlternatingBackColor()
+        {
+            return !AlternatingBackBrush.Equals(DefaultAlternatingBackBrush);
+        }
+
+        internal SolidBrush AlternatingBackBrush
+        {
+            get
+            {
+                return alternatingBackBrush;
+            }
+        }
+
+        protected bool ShouldSerializeBackColor()
+        {
+            return !System.Windows.Forms.DataGridTableStyle.DefaultBackBrush.Equals(backBrush);
+        }
+
+        protected bool ShouldSerializeForeColor()
+        {
+            return !System.Windows.Forms.DataGridTableStyle.DefaultForeBrush.Equals(foreBrush);
+        }
+
+        internal SolidBrush BackBrush
+        {
+            get
+            {
+                return backBrush;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.ControlBackColorDescr))
+        ]
+        public Color BackColor
+        {
+            get
+            {
+                return backBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(BackColor)));
+                }
+
+                if (System.Windows.Forms.DataGrid.IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTableStyleTransparentBackColorNotAllowed, nameof(value));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(BackColor)), nameof(value));
+                }
+
+                if (!backBrush.Color.Equals(value))
+                {
+                    backBrush = new SolidBrush(value);
+                    InvalidateInside();
+                    OnBackColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler BackColorChanged
+        {
+            add => Events.AddHandler(EventBackColor, value);
+            remove => Events.RemoveHandler(EventBackColor, value);
+        }
+
+        public void ResetBackColor()
+        {
+            if (!backBrush.Equals(DefaultBackBrush))
+            {
+                BackColor = DefaultBackBrush.Color;
+            }
+        }
+
+        internal int BorderWidth
+        {
+            get
+            {
+                DataGrid dataGrid = DataGrid;
+                if (dataGrid == null)
+                {
+                    return 0;
+                }
+
+                // if the user set the GridLineStyle property on the dataGrid.
+                // then use the value of that property
+                DataGridLineStyle gridStyle;
+                int gridLineWidth;
+                if (IsDefault)
+                {
+                    gridStyle = DataGrid.GridLineStyle;
+                    gridLineWidth = DataGrid.GridLineWidth;
+                }
+                else
+                {
+                    gridStyle = GridLineStyle;
+                    gridLineWidth = GridLineWidth;
+                }
+
+                if (gridStyle == DataGridLineStyle.None)
+                {
+                    return 0;
+                }
+
+                return gridLineWidth;
+            }
+        }
+
+        internal static SolidBrush DefaultAlternatingBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Window;
+            }
+        }
+
+        internal static SolidBrush DefaultBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Window;
+            }
+        }
+
+        internal static SolidBrush DefaultForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.WindowText;
+            }
+        }
+
+        private static SolidBrush DefaultGridLineBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Control;
+            }
+        }
+
+        private static SolidBrush DefaultHeaderBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.Control;
+            }
+        }
+
+        private static SolidBrush DefaultHeaderForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ControlText;
+            }
+        }
+
+        private static Pen DefaultHeaderForePen
+        {
+            get
+            {
+                return new Pen(SystemColors.ControlText);
+            }
+        }
+
+        private static SolidBrush DefaultLinkBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.HotTrack;
+            }
+        }
+
+        private static SolidBrush DefaultSelectionBackBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaption;
+            }
+        }
+
+        private static SolidBrush DefaultSelectionForeBrush
+        {
+            get
+            {
+                return (SolidBrush)SystemBrushes.ActiveCaptionText;
+            }
+        }
+
+        internal int FocusedRelation
+        {
+            get
+            {
+                return focusedRelation;
+            }
+            set
+            {
+                if (focusedRelation != value)
+                {
+                    focusedRelation = value;
+                    if (focusedRelation == -1)
+                    {
+                        focusedTextWidth = 0;
+                    }
+                    else
+                    {
+                        Graphics g = DataGrid.CreateGraphicsInternal();
+                        focusedTextWidth = (int)Math.Ceiling(g.MeasureString(((string)RelationsList[focusedRelation]), DataGrid.LinkFont).Width);
+                        g.Dispose();
+                    }
+                }
+            }
+        }
+
+        internal int FocusedTextWidth
+        {
+            get
+            {
+                return focusedTextWidth;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.ControlForeColorDescr))
+        ]
+        public Color ForeColor
+        {
+            get
+            {
+                return foreBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(ForeColor)));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(ForeColor)), nameof(value));
+                }
+
+                if (!foreBrush.Color.Equals(value))
+                {
+                    foreBrush = new SolidBrush(value);
+                    InvalidateInside();
+                    OnForeColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler ForeColorChanged
+        {
+            add => Events.AddHandler(EventForeColor, value);
+            remove => Events.RemoveHandler(EventForeColor, value);
+        }
+
+        internal SolidBrush ForeBrush
+        {
+            get
+            {
+                return foreBrush;
+            }
+        }
+
+        public void ResetForeColor()
+        {
+            if (!foreBrush.Equals(DefaultForeBrush))
+            {
+                ForeColor = DefaultForeBrush.Color;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridGridLineColorDescr))
+        ]
+        public Color GridLineColor
+        {
+            get
+            {
+                return gridLineBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(GridLineColor)));
+                }
+
+                if (gridLineBrush.Color != value)
+                {
+                    if (value.IsEmpty)
+                    {
+                        throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(GridLineColor)), nameof(value));
+                    }
+
+                    gridLineBrush = new SolidBrush(value);
+                    OnGridLineColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler GridLineColorChanged
+        {
+            add => Events.AddHandler(EventGridLineColor, value);
+            remove => Events.RemoveHandler(EventGridLineColor, value);
+        }
+
+        protected virtual bool ShouldSerializeGridLineColor()
+        {
+            return !GridLineBrush.Equals(DefaultGridLineBrush);
+        }
+
+        public void ResetGridLineColor()
+        {
+            if (ShouldSerializeGridLineColor())
+            {
+                GridLineColor = DefaultGridLineBrush.Color;
+            }
+        }
+
+        internal SolidBrush GridLineBrush
+        {
+            get
+            {
+                return gridLineBrush;
+            }
+        }
+
+        internal int GridLineWidth
+        {
+            get
+            {
+                Debug.Assert(GridLineStyle == DataGridLineStyle.Solid || GridLineStyle == DataGridLineStyle.None, "are there any other styles?");
+                return GridLineStyle == DataGridLineStyle.Solid ? 1 : 0;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         DefaultValue(defaultGridLineStyle),
+         SRDescription(nameof(SR.DataGridGridLineStyleDescr))
+        ]
+        public DataGridLineStyle GridLineStyle
+        {
+            get
+            {
+                return gridLineStyle;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(GridLineStyle)));
+                }
+
+                //valid values are 0x0 to 0x1.
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)DataGridLineStyle.None, (int)DataGridLineStyle.Solid))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(DataGridLineStyle));
+                }
+
+                if (gridLineStyle != value)
+                {
+                    gridLineStyle = value;
+                    OnGridLineStyleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler GridLineStyleChanged
+        {
+            add => Events.AddHandler(EventGridLineStyle, value);
+            remove => Events.RemoveHandler(EventGridLineStyle, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridHeaderBackColorDescr))
+        ]
+        public Color HeaderBackColor
+        {
+            get
+            {
+                return headerBackBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(HeaderBackColor)));
+                }
+
+                if (System.Windows.Forms.DataGrid.IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTableStyleTransparentHeaderBackColorNotAllowed, nameof(value));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(HeaderBackColor)), nameof(value));
+                }
+
+                if (!value.Equals(headerBackBrush.Color))
+                {
+                    headerBackBrush = new SolidBrush(value);
+                    OnHeaderBackColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler HeaderBackColorChanged
+        {
+            add => Events.AddHandler(EventHeaderBackColor, value);
+            remove => Events.RemoveHandler(EventHeaderBackColor, value);
+        }
+
+        internal SolidBrush HeaderBackBrush
+        {
+            get
+            {
+                return headerBackBrush;
+            }
+        }
+
+        protected virtual bool ShouldSerializeHeaderBackColor()
+        {
+            return !HeaderBackBrush.Equals(DefaultHeaderBackBrush);
+        }
+
+        public void ResetHeaderBackColor()
+        {
+            if (ShouldSerializeHeaderBackColor())
+            {
+                HeaderBackColor = DefaultHeaderBackBrush.Color;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatAppearance)),
+         Localizable(true),
+         AmbientValue(null),
+         SRDescription(nameof(SR.DataGridHeaderFontDescr))
+        ]
+        public Font HeaderFont
+        {
+            get
+            {
+                return (headerFont ?? (DataGrid == null ? Control.DefaultFont : DataGrid.Font));
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(HeaderFont)));
+                }
+
+                if ((value == null && headerFont != null) || (value != null && !value.Equals(headerFont)))
+                {
+                    headerFont = value;
+                    OnHeaderFontChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler HeaderFontChanged
+        {
+            add => Events.AddHandler(EventHeaderFont, value);
+            remove => Events.RemoveHandler(EventHeaderFont, value);
+        }
+
+        private bool ShouldSerializeHeaderFont()
+        {
+            return (headerFont != null);
+        }
+
+        public void ResetHeaderFont()
+        {
+            if (headerFont != null)
+            {
+                headerFont = null;
+                OnHeaderFontChanged(EventArgs.Empty);
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridHeaderForeColorDescr))
+        ]
+        public Color HeaderForeColor
+        {
+            get
+            {
+                return headerForePen.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(HeaderForeColor)));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(HeaderForeColor)), nameof(value));
+                }
+
+                if (!value.Equals(headerForePen.Color))
+                {
+                    headerForePen = new Pen(value);
+                    headerForeBrush = new SolidBrush(value);
+                    OnHeaderForeColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler HeaderForeColorChanged
+        {
+            add => Events.AddHandler(EventHeaderForeColor, value);
+            remove => Events.RemoveHandler(EventHeaderForeColor, value);
+        }
+
+        protected virtual bool ShouldSerializeHeaderForeColor()
+        {
+            return !HeaderForePen.Equals(DefaultHeaderForePen);
+        }
+
+        public void ResetHeaderForeColor()
+        {
+            if (ShouldSerializeHeaderForeColor())
+            {
+                HeaderForeColor = DefaultHeaderForeBrush.Color;
+            }
+        }
+
+        internal SolidBrush HeaderForeBrush
+        {
+            get
+            {
+                return headerForeBrush;
+            }
+        }
+
+        internal Pen HeaderForePen
+        {
+            get
+            {
+                return headerForePen;
+            }
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridLinkColorDescr))
+        ]
+        public Color LinkColor
+        {
+            get
+            {
+                return linkBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(LinkColor)));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(LinkColor)), nameof(value));
+                }
+
+                if (!linkBrush.Color.Equals(value))
+                {
+                    linkBrush = new SolidBrush(value);
+                    OnLinkColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler LinkColorChanged
+        {
+            add => Events.AddHandler(EventLinkColor, value);
+            remove => Events.RemoveHandler(EventLinkColor, value);
+        }
+
+        protected virtual bool ShouldSerializeLinkColor()
+        {
+            return !LinkBrush.Equals(DefaultLinkBrush);
+        }
+
+        public void ResetLinkColor()
+        {
+            if (ShouldSerializeLinkColor())
+            {
+                LinkColor = DefaultLinkBrush.Color;
+            }
+        }
+
+        internal Brush LinkBrush
+        {
+            get
+            {
+                return linkBrush;
+            }
+        }
+
+        [
+         SRDescription(nameof(SR.DataGridLinkHoverColorDescr)),
+         SRCategory(nameof(SR.CatColors)),
+         Browsable(false),
+         EditorBrowsable(EditorBrowsableState.Never)
+        ]
+        public Color LinkHoverColor
+        {
+            get
+            {
+                return LinkColor;
+            }
+            set
+            {
+            }
+        }
+
+        public event EventHandler LinkHoverColorChanged
+        {
+            add => Events.AddHandler(EventLinkHoverColor, value);
+            remove => Events.RemoveHandler(EventLinkHoverColor, value);
+        }
+
+        protected virtual bool ShouldSerializeLinkHoverColor()
+        {
+            return false;
+        }
+
+        internal Rectangle RelationshipRect
+        {
+            get
+            {
+                if (relationshipRect.IsEmpty)
+                {
+                    ComputeRelationshipRect();
+                }
+
+                return relationshipRect;
+            }
+        }
+
+        private Rectangle ComputeRelationshipRect()
+        {
+            if (relationshipRect.IsEmpty && DataGrid.AllowNavigation)
+            {
+                Debug.WriteLineIf(CompModSwitches.DGRelationShpRowLayout.TraceVerbose, "GetRelationshipRect grinding away");
+                Graphics g = DataGrid.CreateGraphicsInternal();
+                relationshipRect = new Rectangle
+                {
+                    X = 0 //indentWidth;
+                };
+                // relationshipRect.Y = base.Height - BorderWidth;
+
+                // Determine the width of the widest relationship name
+                int longestRelationship = 0;
+                for (int r = 0; r < RelationsList.Count; ++r)
+                {
+                    int rwidth = (int)Math.Ceiling(g.MeasureString(((string)RelationsList[r]), DataGrid.LinkFont).Width)
+;
+                    if (rwidth > longestRelationship)
+                    {
+                        longestRelationship = rwidth;
+                    }
+                }
+
+                g.Dispose();
+
+                relationshipRect.Width = longestRelationship + 5;
+                relationshipRect.Width += 2; // relationshipRect border;
+                relationshipRect.Height = BorderWidth + relationshipHeight * RelationsList.Count;
+                relationshipRect.Height += 2; // relationship border
+                if (RelationsList.Count > 0)
+                {
+                    relationshipRect.Height += 2 * relationshipSpacing;
+                }
+            }
+
+            return relationshipRect;
+        }
+
+        internal void ResetRelationsUI()
+        {
+            relationshipRect = Rectangle.Empty;
+            focusedRelation = -1;
+            relationshipHeight = dataGrid.LinkFontHeight + relationshipSpacing;
+        }
+
+        internal int RelationshipHeight
+        {
+            get
+            {
+                return relationshipHeight;
+            }
+        }
+
+        public void ResetLinkHoverColor()
+        {
+        }
+
+        [
+         DefaultValue(defaultPreferredColumnWidth),
+         SRCategory(nameof(SR.CatLayout)),
+         Localizable(true),
+         SRDescription(nameof(SR.DataGridPreferredColumnWidthDescr)),
+         TypeConverter(typeof(DataGridPreferredColumnWidthTypeConverter))
+        ]
+        public int PreferredColumnWidth
+        {
+            get
+            {
+                return preferredColumnWidth;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(PreferredColumnWidth)));
+                }
+
+                if (value < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value, SR.DataGridColumnWidth);
+                }
+
+                if (preferredColumnWidth != value)
+                {
+                    preferredColumnWidth = value;
+                    OnPreferredColumnWidthChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler PreferredColumnWidthChanged
+        {
+            add => Events.AddHandler(EventPreferredColumnWidth, value);
+            remove => Events.RemoveHandler(EventPreferredColumnWidth, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatLayout)),
+         Localizable(true),
+         SRDescription(nameof(SR.DataGridPreferredRowHeightDescr))
+        ]
+        public int PreferredRowHeight
+        {
+            get
+            {
+                return preferredRowHeight;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(PreferredRowHeight)));
+                }
+
+                if (value < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value, SR.DataGridRowRowHeight);
+                }
+
+                if (preferredRowHeight != value)
+                {
+                    preferredRowHeight = value;
+                    OnPreferredRowHeightChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler PreferredRowHeightChanged
+        {
+            add => Events.AddHandler(EventPreferredRowHeight, value);
+            remove => Events.RemoveHandler(EventPreferredRowHeight, value);
+        }
+
+        private void ResetPreferredRowHeight()
+        {
+            PreferredRowHeight = defaultFontHeight + 3;
+        }
+
+        protected bool ShouldSerializePreferredRowHeight()
+        {
+            return preferredRowHeight != defaultFontHeight + 3;
+        }
+
+        [
+         SRCategory(nameof(SR.CatDisplay)),
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridColumnHeadersVisibleDescr))
+        ]
+        public bool ColumnHeadersVisible
+        {
+            get
+            {
+                return columnHeadersVisible;
+            }
+            set
+            {
+                if (columnHeadersVisible != value)
+                {
+                    columnHeadersVisible = value;
+                    OnColumnHeadersVisibleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler ColumnHeadersVisibleChanged
+        {
+            add => Events.AddHandler(EventColumnHeadersVisible, value);
+            remove => Events.RemoveHandler(EventColumnHeadersVisible, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatDisplay)),
+         DefaultValue(true),
+         SRDescription(nameof(SR.DataGridRowHeadersVisibleDescr))
+        ]
+        public bool RowHeadersVisible
+        {
+            get
+            {
+                return rowHeadersVisible;
+            }
+            set
+            {
+                if (rowHeadersVisible != value)
+                {
+                    rowHeadersVisible = value;
+                    OnRowHeadersVisibleChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler RowHeadersVisibleChanged
+        {
+            add => Events.AddHandler(EventRowHeadersVisible, value);
+            remove => Events.RemoveHandler(EventRowHeadersVisible, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatLayout)),
+         DefaultValue(defaultRowHeaderWidth),
+         Localizable(true),
+         SRDescription(nameof(SR.DataGridRowHeaderWidthDescr))
+        ]
+        public int RowHeaderWidth
+        {
+            get
+            {
+                return rowHeaderWidth;
+            }
+            set
+            {
+                if (DataGrid != null)
+                {
+                    value = Math.Max(DataGrid.MinimumRowHeaderWidth(), value);
+                }
+
+                if (rowHeaderWidth != value)
+                {
+                    rowHeaderWidth = value;
+                    OnRowHeaderWidthChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler RowHeaderWidthChanged
+        {
+            add => Events.AddHandler(EventRowHeaderWidth, value);
+            remove => Events.RemoveHandler(EventRowHeaderWidth, value);
+        }
+
+        [
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridSelectionBackColorDescr))
+        ]
+        public Color SelectionBackColor
+        {
+            get
+            {
+                return selectionBackBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(SelectionBackColor)));
+                }
+
+                if (System.Windows.Forms.DataGrid.IsTransparentColor(value))
+                {
+                    throw new ArgumentException(SR.DataGridTableStyleTransparentSelectionBackColorNotAllowed, nameof(value));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(SelectionBackColor)), nameof(value));
+                }
+
+                if (!value.Equals(selectionBackBrush.Color))
+                {
+                    selectionBackBrush = new SolidBrush(value);
+                    InvalidateInside();
+                    OnSelectionBackColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler SelectionBackColorChanged
+        {
+            add => Events.AddHandler(EventSelectionBackColor, value);
+            remove => Events.RemoveHandler(EventSelectionBackColor, value);
+        }
+
+        internal SolidBrush SelectionBackBrush
+        {
+            get
+            {
+                return selectionBackBrush;
+            }
+        }
+
+        internal SolidBrush SelectionForeBrush
+        {
+            get
+            {
+                return selectionForeBrush;
+            }
+        }
+
+        protected bool ShouldSerializeSelectionBackColor()
+        {
+            return !DefaultSelectionBackBrush.Equals(selectionBackBrush);
+        }
+
+        public void ResetSelectionBackColor()
+        {
+            if (ShouldSerializeSelectionBackColor())
+            {
+                SelectionBackColor = DefaultSelectionBackBrush.Color;
+            }
+        }
+
+        [
+         Description("The foreground color for the current data grid row"),
+         SRCategory(nameof(SR.CatColors)),
+         SRDescription(nameof(SR.DataGridSelectionForeColorDescr))
+        ]
+        public Color SelectionForeColor
+        {
+            get
+            {
+                return selectionForeBrush.Color;
+            }
+            set
+            {
+                if (isDefaultTableStyle)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridDefaultTableSet, nameof(SelectionForeColor)));
+                }
+
+                if (value.IsEmpty)
+                {
+                    throw new ArgumentException(string.Format(SR.DataGridEmptyColor, nameof(SelectionForeColor)), nameof(value));
+                }
+
+                if (!value.Equals(selectionForeBrush.Color))
+                {
+                    selectionForeBrush = new SolidBrush(value);
+                    InvalidateInside();
+                    OnSelectionForeColorChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler SelectionForeColorChanged
+        {
+            add => Events.AddHandler(EventSelectionForeColor, value);
+            remove => Events.RemoveHandler(EventSelectionForeColor, value);
+        }
+
+        protected virtual bool ShouldSerializeSelectionForeColor()
+        {
+            return !SelectionForeBrush.Equals(DefaultSelectionForeBrush);
+        }
+
+        public void ResetSelectionForeColor()
+        {
+            if (ShouldSerializeSelectionForeColor())
+            {
+                SelectionForeColor = DefaultSelectionForeBrush.Color;
+            }
+        }
+
+        // will need this function from the dataGrid
+        //
+        private void InvalidateInside()
+        {
+            if (DataGrid != null)
+            {
+                DataGrid.InvalidateInside();
+            }
+        }
+
+        public static readonly DataGridTableStyle DefaultTableStyle = new DataGridTableStyle(true);
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGridTableStyle'/> class.
+        /// </summary>
+        public DataGridTableStyle(bool isDefaultTableStyle)
+        {
+            gridColumns = new GridColumnStylesCollection(this, isDefaultTableStyle);
+            gridColumns.CollectionChanged += new CollectionChangeEventHandler(OnColumnCollectionChanged);
+            this.isDefaultTableStyle = isDefaultTableStyle;
+        }
+
+        public DataGridTableStyle() : this(false)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='DataGridTableStyle'/> class with the specified
+        /// <see cref='CurrencyManager'/>.
+        /// </summary>
+        public DataGridTableStyle(CurrencyManager listManager) : this()
+        {
+            Debug.Assert(listManager != null, "the DataGridTabel cannot use a null listManager");
+            mappingName = listManager.GetListName();
+            // set up the Relations and the columns
+            SetGridColumnStylesCollection(listManager);
+        }
+
+        internal void SetRelationsList(CurrencyManager listManager)
+        {
+            PropertyDescriptorCollection propCollection = listManager.GetItemProperties();
+            Debug.Assert(!IsDefault, "the grid can set the relations only on a table that was manually added by the user");
+            int propCount = propCollection.Count;
+            if (relationsList.Count > 0)
+            {
+                relationsList.Clear();
+            }
+
+            for (int i = 0; i < propCount; i++)
+            {
+                PropertyDescriptor prop = propCollection[i];
+                Debug.Assert(prop != null, "prop is null: how that happened?");
+                if (PropertyDescriptorIsARelation(prop))
+                {
+                    // relation
+                    relationsList.Add(prop.Name);
+                }
+            }
+        }
+
+        internal void SetGridColumnStylesCollection(CurrencyManager listManager)
+        {
+            // when we are setting the gridColumnStyles, do not handle any gridColumnCollectionChanged events
+            gridColumns.CollectionChanged -= new CollectionChangeEventHandler(OnColumnCollectionChanged);
+
+            PropertyDescriptorCollection propCollection = listManager.GetItemProperties();
+
+            // we need to clear the relations list
+            if (relationsList.Count > 0)
+            {
+                relationsList.Clear();
+            }
+
+            Debug.Assert(propCollection != null, "propCollection is null: how that happened?");
+            int propCount = propCollection.Count;
+            for (int i = 0; i < propCount; i++)
+            {
+                PropertyDescriptor prop = propCollection[i];
+                Debug.Assert(prop != null, "prop is null: how that happened?");
+                // do not take into account the properties that are browsable.
+                if (!prop.IsBrowsable)
+                {
+                    continue;
+                }
+
+                if (PropertyDescriptorIsARelation(prop))
+                {
+                    // relation
+                    relationsList.Add(prop.Name);
+                }
+                else
+                {
+                    // column
+                    DataGridColumnStyle col = CreateGridColumn(prop, isDefaultTableStyle);
+                    if (isDefaultTableStyle)
+                    {
+                        gridColumns.AddDefaultColumn(col);
+                    }
+                    else
+                    {
+                        col.MappingName = prop.Name;
+                        col.HeaderText = prop.Name;
+                        gridColumns.Add(col);
+                    }
+                }
+            }
+
+            // now we are able to handle the collectionChangeEvents
+            gridColumns.CollectionChanged += new CollectionChangeEventHandler(OnColumnCollectionChanged);
+        }
+
+        private static bool PropertyDescriptorIsARelation(PropertyDescriptor prop)
+        {
+            return typeof(IList).IsAssignableFrom(prop.PropertyType) && !typeof(Array).IsAssignableFrom(prop.PropertyType);
+        }
+
+        internal protected virtual DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop)
+        {
+            return CreateGridColumn(prop, false);
+        }
+
+        internal protected virtual DataGridColumnStyle CreateGridColumn(PropertyDescriptor prop, bool isDefault)
+        {
+            if (prop == null)
+            {
+                throw new ArgumentNullException(nameof(prop));
+            }
+
+            DataGridColumnStyle ret = null;
+            Type dataType = prop.PropertyType;
+
+            if (dataType.Equals(typeof(bool)))
+            {
+                ret = new DataGridBoolColumn(prop, isDefault);
+            }
+            else if (dataType.Equals(typeof(string)))
+            {
+                ret = new DataGridTextBoxColumn(prop, isDefault);
+            }
+            else if (dataType.Equals(typeof(DateTime)))
+            {
+                ret = new DataGridTextBoxColumn(prop, "d", isDefault);
+            }
+            else if (dataType.Equals(typeof(short)) ||
+                     dataType.Equals(typeof(int)) ||
+                     dataType.Equals(typeof(long)) ||
+                     dataType.Equals(typeof(ushort)) ||
+                     dataType.Equals(typeof(uint)) ||
+                     dataType.Equals(typeof(ulong)) ||
+                     dataType.Equals(typeof(decimal)) ||
+                     dataType.Equals(typeof(double)) ||
+                     dataType.Equals(typeof(float)) ||
+                     dataType.Equals(typeof(byte)) ||
+                     dataType.Equals(typeof(sbyte)))
+            {
+                ret = new DataGridTextBoxColumn(prop, "G", isDefault);
+            }
+            else
+            {
+                ret = new DataGridTextBoxColumn(prop, isDefault);
+            }
+
+            return ret;
+        }
+
+        internal void ResetRelationsList()
+        {
+            if (isDefaultTableStyle)
+            {
+                relationsList.Clear();
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Gets the name of this grid table.
+        /// </summary>
+        [Editor("System.Windows.Forms.Design.DataGridTableStyleMappingNameEditor, " + AssemblyRef.SystemDesign, typeof(Drawing.Design.UITypeEditor)), DefaultValue("")]
+        public string MappingName
+        {
+            get
+            {
+                return mappingName;
+            }
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (value.Equals(mappingName))
+                {
+                    return;
+                }
+
+                string originalMappingName = MappingName;
+                mappingName = value;
+
+                // this could throw
+                try
+                {
+                    if (DataGrid != null)
+                    {
+                        DataGrid.TableStyles.CheckForMappingNameDuplicates(this);
+                    }
+                }
+                catch
+                {
+                    mappingName = originalMappingName;
+                    throw;
+                }
+
+                OnMappingNameChanged(EventArgs.Empty);
+            }
+        }
+
+        public event EventHandler MappingNameChanged
+        {
+            add => Events.AddHandler(EventMappingName, value);
+            remove => Events.RemoveHandler(EventMappingName, value);
+        }
+
+        /// <summary>
+        ///  Gets the
+        ///  list of relation objects for the grid table.
+        /// </summary>
+        internal ArrayList RelationsList
+        {
+            get
+            {
+                return relationsList;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the collection of columns drawn for this table.
+        /// </summary>
+        [
+        Localizable(true),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Content)
+        ]
+        public virtual GridColumnStylesCollection GridColumnStyles
+        {
+            get
+            {
+                return gridColumns;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='Forms.DataGrid'/>
+        ///  control displaying the table.
+        /// </summary>
+        internal void SetInternalDataGrid(DataGrid dG, bool force)
+        {
+            if (dataGrid != null && dataGrid.Equals(dG) && !force)
+            {
+                return;
+            }
+            else
+            {
+                dataGrid = dG;
+                if (dG != null && dG.Initializing)
+                {
+                    return;
+                }
+
+                int nCols = gridColumns.Count;
+                for (int i = 0; i < nCols; i++)
+                {
+                    gridColumns[i].SetDataGridInternalInColumn(dG);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='Forms.DataGrid'/> control for the drawn table.
+        /// </summary>
+        [Browsable(false)]
+        public virtual DataGrid DataGrid
+        {
+            get
+            {
+                return dataGrid;
+            }
+            set
+            {
+                SetInternalDataGrid(value, true);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether columns can be
+        ///  edited.
+        /// </summary>
+        [DefaultValue(false)]
+        public virtual bool ReadOnly
+        {
+            get
+            {
+                return readOnly;
+            }
+            set
+            {
+                if (readOnly != value)
+                {
+                    readOnly = value;
+                    OnReadOnlyChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler ReadOnlyChanged
+        {
+            add => Events.AddHandler(EventReadOnly, value);
+            remove => Events.RemoveHandler(EventReadOnly, value);
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Requests an edit operation.
+        /// </summary>
+        public bool BeginEdit(DataGridColumnStyle gridColumn, int rowNumber)
+        {
+            DataGrid grid = DataGrid;
+            if (grid == null)
+            {
+                return false;
+            }
+            else
+            {
+                return grid.BeginEdit(gridColumn, rowNumber);
+            }
+        }
+
+        /// <summary>
+        ///  Requests an end to an edit
+        ///  operation.
+        /// </summary>
+        public bool EndEdit(DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort)
+        {
+            DataGrid grid = DataGrid;
+            if (grid == null)
+            {
+                return false;
+            }
+            else
+            {
+                return grid.EndEdit(gridColumn, rowNumber, shouldAbort);
+            }
+        }
+
+        internal void InvalidateColumn(DataGridColumnStyle column)
+        {
+            int index = GridColumnStyles.IndexOf(column);
+            if (index >= 0 && DataGrid != null)
+            {
+                DataGrid.InvalidateColumn(index);
+            }
+        }
+
+        private void OnColumnCollectionChanged(object sender, CollectionChangeEventArgs e)
+        {
+            gridColumns.CollectionChanged -= new CollectionChangeEventHandler(OnColumnCollectionChanged);
+
+            try
+            {
+                DataGrid grid = DataGrid;
+                DataGridColumnStyle col = e.Element as DataGridColumnStyle;
+                if (e.Action == CollectionChangeAction.Add)
+                {
+                    if (col != null)
+                    {
+                        col.SetDataGridInternalInColumn(grid);
+                    }
+                }
+                else if (e.Action == CollectionChangeAction.Remove)
+                {
+                    if (col != null)
+                    {
+                        col.SetDataGridInternalInColumn(null);
+                    }
+                }
+                else
+                {
+                    // refresh
+                    Debug.Assert(e.Action == CollectionChangeAction.Refresh, "there are only Add, Remove and Refresh in the CollectionChangeAction");
+                    // if we get a column in this collectionChangeEventArgs it means
+                    // that the propertyDescriptor in that column changed.
+                    if (e.Element != null)
+                    {
+                        for (int i = 0; i < gridColumns.Count; i++)
+                        {
+                            gridColumns[i].SetDataGridInternalInColumn(null);
+                        }
+                    }
+                }
+
+                if (grid != null)
+                {
+                    grid.OnColumnCollectionChanged(this, e);
+                }
+            }
+            finally
+            {
+                gridColumns.CollectionChanged += new CollectionChangeEventHandler(OnColumnCollectionChanged);
+            }
+        }
+
+#if false
+        /// <summary>
+        ///  The DataColumnCollection class actually wires up this
+        ///  event handler to the PropertyChanged events of
+        ///  a DataGridTable's columns.
+        /// </summary>
+        internal void OnColumnChanged(object sender, PropertyChangedEvent event) {
+            if (event.PropertyName.Equals("Visible"))
+                GenerateVisibleColumnsCache();
+        }
+#endif
+        protected virtual void OnReadOnlyChanged(EventArgs e)
+        {
+            if (Events[EventReadOnly] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnMappingNameChanged(EventArgs e)
+        {
+            if (Events[EventMappingName] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnAlternatingBackColorChanged(EventArgs e)
+        {
+            if (Events[EventAlternatingBackColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnForeColorChanged(EventArgs e)
+        {
+            if (Events[EventForeColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnBackColorChanged(EventArgs e)
+        {
+            if (Events[EventBackColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnAllowSortingChanged(EventArgs e)
+        {
+            if (Events[EventAllowSorting] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnGridLineColorChanged(EventArgs e)
+        {
+            if (Events[EventGridLineColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnGridLineStyleChanged(EventArgs e)
+        {
+            if (Events[EventGridLineStyle] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnHeaderBackColorChanged(EventArgs e)
+        {
+            if (Events[EventHeaderBackColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnHeaderFontChanged(EventArgs e)
+        {
+            if (Events[EventHeaderFont] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnHeaderForeColorChanged(EventArgs e)
+        {
+            if (Events[EventHeaderForeColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnLinkColorChanged(EventArgs e)
+        {
+            if (Events[EventLinkColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnLinkHoverColorChanged(EventArgs e)
+        {
+            if (Events[EventLinkHoverColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnPreferredRowHeightChanged(EventArgs e)
+        {
+            if (Events[EventPreferredRowHeight] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnPreferredColumnWidthChanged(EventArgs e)
+        {
+            if (Events[EventPreferredColumnWidth] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnColumnHeadersVisibleChanged(EventArgs e)
+        {
+            if (Events[EventColumnHeadersVisible] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnRowHeadersVisibleChanged(EventArgs e)
+        {
+            if (Events[EventRowHeadersVisible] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnRowHeaderWidthChanged(EventArgs e)
+        {
+            if (Events[EventRowHeaderWidth] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnSelectionForeColorChanged(EventArgs e)
+        {
+            if (Events[EventSelectionForeColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected virtual void OnSelectionBackColorChanged(EventArgs e)
+        {
+            if (Events[EventSelectionBackColor] is EventHandler eh)
+            {
+                eh(this, e);
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                GridColumnStylesCollection cols = GridColumnStyles;
+                if (cols != null)
+                {
+                    for (int i = 0; i < cols.Count; i++)
+                    {
+                        cols[i].Dispose();
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        internal bool IsDefault
+        {
+            get
+            {
+                return isDefaultTableStyle;
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBox.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBox.cs
new file mode 100644
index 00000000000..505cc301c72
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBox.cs
@@ -0,0 +1,302 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a <see cref='TextBox'/> control that is hosted in a
+    /// <see cref='DataGridTextBoxColumn'/> .
+    /// </summary>
+    [
+    ComVisible(true),
+    ClassInterface(ClassInterfaceType.AutoDispatch),
+    ToolboxItem(false),
+    DesignTimeVisible(false)
+    ]
+    public class DataGridTextBox : TextBox
+    {
+        private bool isInEditOrNavigateMode = true;
+
+        // only needed to signal the dataGrid that an edit
+        // takes place
+        private DataGrid dataGrid;
+
+        public DataGridTextBox() : base()
+        {
+            TabStop = false;
+        }
+
+        /// <summary>
+        ///  Sets the <see cref='DataGrid'/> to which this <see cref='TextBox'/> control belongs.
+        /// </summary>
+        public void SetDataGrid(DataGrid parentGrid)
+        {
+            dataGrid = parentGrid;
+        }
+
+        protected override void WndProc(ref Message m)
+        {
+            // but what if we get a CtrlV?
+            // what about deleting from the menu?
+            if (m.Msg == (int)Interop.User32.WM.PASTE || m.Msg == (int)Interop.User32.WM.CUT || m.Msg == (int)Interop.User32.WM.CLEAR)
+            {
+                IsInEditOrNavigateMode = false;
+                dataGrid.ColumnStartedEditing(Bounds);
+            }
+
+            base.WndProc(ref m);
+        }
+
+        protected override void OnMouseWheel(MouseEventArgs e)
+        {
+            dataGrid.TextBoxOnMouseWheel(e);
+        }
+
+        protected override void OnKeyPress(KeyPressEventArgs e)
+        {
+            base.OnKeyPress(e);
+
+            // Shift-Space should not cause the grid to
+            // be put in edit mode
+            if (e.KeyChar == ' ' && (Control.ModifierKeys & Keys.Shift) == Keys.Shift)
+            {
+                return;
+            }
+
+            // if the edit box is in ReadOnly mode, then do not tell the DataGrid about the
+            // edit
+            if (ReadOnly)
+            {
+                return;
+            }
+
+            // Ctrl-* should not put the grid in edit mode
+            if ((Control.ModifierKeys & Keys.Control) == Keys.Control && ((Control.ModifierKeys & Keys.Alt) == 0))
+            {
+                return;
+            }
+
+            IsInEditOrNavigateMode = false;
+
+            // let the DataGrid know about the edit
+            dataGrid.ColumnStartedEditing(Bounds);
+        }
+
+        protected internal override bool ProcessKeyMessage(ref Message m)
+        {
+            Keys key = (Keys)unchecked((int)(long)m.WParam);
+            Keys modifierKeys = ModifierKeys;
+
+            if ((key | modifierKeys) == Keys.Enter || (key | modifierKeys) == Keys.Escape || ((key | modifierKeys) == (Keys.Enter | Keys.Control))
+            )
+            {
+                // enter and escape keys are sent directly to the DataGrid
+                // for those keys, eat the WM_CHAR part of the KeyMessage
+                //
+                if (m.Msg == (int)Interop.User32.WM.CHAR)
+                {
+                    return true;
+                }
+
+                return ProcessKeyPreview(ref m);
+            }
+
+            if (m.Msg == (int)Interop.User32.WM.CHAR)
+            {
+                if (key == Keys.LineFeed)           // eat the LineFeed we get when the user presses Ctrl-Enter in a gridTextBox
+                {
+                    return true;
+                }
+
+                return ProcessKeyEventArgs(ref m);
+            }
+
+            // now the edit control will be always on top of the grid
+            // we only want to process the WM_KEYUP message ( the same way the grid was doing when the grid was getting all
+            // the keys )
+            if (m.Msg == (int)Interop.User32.WM.KEYUP)
+            {
+                return true;
+            }
+
+            Keys keyData = key & Keys.KeyCode;
+
+            switch (keyData)
+            {
+                case Keys.Right:
+                    // here is the deal with Keys.Right:
+                    // if the end of the selection is at the end of the string
+                    // send this character to the dataGrid
+                    // else, process the KeyEvent
+                    //
+                    if (SelectionStart + SelectionLength == Text.Length)
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.Left:
+                    // if the end of the selection is at the begining of the string
+                    // or if the entire text is selected and we did not start editing
+                    // send this character to the dataGrid
+                    // else, process the KeyEvent
+                    //
+                    if (SelectionStart + SelectionLength == 0 ||
+                        (IsInEditOrNavigateMode && SelectionLength == Text.Length))
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.Down:
+                    // if the end of the selection is on the last line of the text then
+                    // send this character to the dataGrid
+                    // else, process the KeyEvent
+                    //
+                    int end = SelectionStart + SelectionLength;
+                    if (Text.IndexOf("\r\n", end) == -1)
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.Up:
+                    // if the end of the selection is on the first line of the text then
+                    // send this character to the dataGrid
+                    // else, process the KeyEvent
+                    //
+                    if (Text.IndexOf("\r\n") < 0 || SelectionStart + SelectionLength < Text.IndexOf("\r\n"))
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.Home:
+                case Keys.End:
+                    if (SelectionLength == Text.Length)
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+                    else
+                    {
+                        return ProcessKeyEventArgs(ref m);
+                    }
+
+                case Keys.Prior:
+                case Keys.Next:
+                case Keys.Oemplus:
+                case Keys.Add:
+                case Keys.OemMinus:
+                case Keys.Subtract:
+                    if (IsInEditOrNavigateMode)
+                    {
+                        // this will ultimately call parent's ProcessKeyPreview
+                        // in our case, DataGrid's ProcessKeyPreview
+                        return ProcessKeyPreview(ref m);
+                    }
+                    else
+                    {
+                        return ProcessKeyEventArgs(ref m);
+                    }
+
+                case Keys.Space:
+                    if (IsInEditOrNavigateMode && (Control.ModifierKeys & Keys.Shift) == Keys.Shift)
+                    {
+                        // when we get a SHIFT-SPACEBAR message, disregard the WM_CHAR part of the message
+                        if (m.Msg == (int)Interop.User32.WM.CHAR)
+                        {
+                            return true;
+                        }
+
+                        // if the user pressed the SHIFT key at the same time with
+                        // the space key, send the key message to the DataGrid
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.A:
+                    if (IsInEditOrNavigateMode && (Control.ModifierKeys & Keys.Control) == Keys.Control)
+                    {
+                        // when we get a Control-A message, disregard the WM_CHAR part of the message
+                        if (m.Msg == (int)Interop.User32.WM.CHAR)
+                        {
+                            return true;
+                        }
+
+                        // if the user pressed the Control key at the same time with
+                        // the space key, send the key message to the DataGrid
+                        return ProcessKeyPreview(ref m);
+                    }
+
+                    return ProcessKeyEventArgs(ref m);
+                case Keys.F2:
+                    IsInEditOrNavigateMode = false;
+                    // do not select all the text, but
+                    // position the caret at the end of the text
+                    SelectionStart = Text.Length;
+                    return true;
+                case Keys.Delete:
+                    if (IsInEditOrNavigateMode)
+                    {
+                        // pass the delete to the parent, in our case, the DataGrid
+                        // if the dataGrid used the key, then we aren't gonne
+                        // use it anymore, else we are
+                        if (ProcessKeyPreview(ref m))
+                        {
+                            return true;
+                        }
+                        else
+                        {
+                            // the edit control will use the
+                            // delete key: we are in Edit mode now:
+                            IsInEditOrNavigateMode = false;
+                            dataGrid.ColumnStartedEditing(Bounds);
+
+                            return ProcessKeyEventArgs(ref m);
+                        }
+                    }
+                    else
+                    {
+                        return ProcessKeyEventArgs(ref m);
+                    }
+
+                case Keys.Tab:
+                    // the TextBox gets the Control-Tab messages,
+                    // not the parent
+                    if ((ModifierKeys & Keys.Control) == Keys.Control)
+                    {
+                        return ProcessKeyPreview(ref m);
+                    }
+                    else
+                    {
+                        return ProcessKeyEventArgs(ref m);
+                    }
+
+                default:
+                    return ProcessKeyEventArgs(ref m);
+            }
+        }
+
+        public bool IsInEditOrNavigateMode
+        {
+            get
+            {
+                return isInEditOrNavigateMode;
+            }
+            set
+            {
+                isInEditOrNavigateMode = value;
+                if (value)
+                {
+                    SelectAll();
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBoxColumn.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBoxColumn.cs
new file mode 100644
index 00000000000..a43eff8935c
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridTextBoxColumn.cs
@@ -0,0 +1,645 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Hosts a System.Windows.Forms.TextBox control in a cell of a System.Windows.Forms.DataGridColumnStyle for editing strings.
+    /// </summary>
+    public class DataGridTextBoxColumn : DataGridColumnStyle
+    {
+        // ui State
+        private readonly int xMargin = 2;
+        private readonly int yMargin = 1;
+        // private int   fontHandle =        0;
+        private string format;
+        private TypeConverter typeConverter;
+        private IFormatProvider formatInfo;
+        private Reflection.MethodInfo parseMethod;
+
+        // hosted control
+        private readonly DataGridTextBox edit;
+
+        // editing state
+        private string oldValue;
+        private int editRow = -1;
+
+        /// <summary>
+        ///  Initializes a new instance of the System.Windows.Forms.DataGridTextBoxColumn
+        ///  class.
+        /// </summary>
+        public DataGridTextBoxColumn() : this(null, null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of a System.Windows.Forms.DataGridTextBoxColumn with
+        ///  a specified System.Data.DataColumn.
+        /// </summary>
+        public DataGridTextBoxColumn(PropertyDescriptor prop)
+        : this(prop, null, false)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of a System.Windows.Forms.DataGridTextBoxColumn. with
+        ///  the specified System.Data.DataColumn and System.Windows.Forms.ComponentModel.Format.
+        /// </summary>
+        public DataGridTextBoxColumn(PropertyDescriptor prop, string format) : this(prop, format, false) { }
+
+        public DataGridTextBoxColumn(PropertyDescriptor prop, string format, bool isDefault) : base(prop, isDefault)
+        {
+            edit = new DataGridTextBox
+            {
+                BorderStyle = BorderStyle.None,
+                Multiline = true,
+                AcceptsReturn = true,
+                Visible = false
+            };
+            Format = format;
+        }
+
+        public DataGridTextBoxColumn(PropertyDescriptor prop, bool isDefault) : this(prop, null, isDefault) { }
+
+        // =------------------------------------------------------------------
+        // =        Properties
+        // =------------------------------------------------------------------
+
+        /// <summary>
+        ///  Gets the hosted System.Windows.Forms.TextBox control.
+        /// </summary>
+        [Browsable(false)]
+        public virtual TextBox TextBox
+        {
+            get
+            {
+                return edit;
+            }
+        }
+
+        internal override bool KeyPress(int rowNum, Keys keyData)
+        {
+            if (edit.IsInEditOrNavigateMode)
+            {
+                return base.KeyPress(rowNum, keyData);
+            }
+
+            // if the edit box is editing, then
+            // pass this keystroke to the edit box
+            //
+            return false;
+        }
+
+        /// <summary>
+        ///  Adds a System.Windows.Forms.TextBox control to the System.Windows.Forms.DataGrid control's System.Windows.Forms.Control.ControlCollection
+        ///  .
+        /// </summary>
+        protected override void SetDataGridInColumn(DataGrid value)
+        {
+            base.SetDataGridInColumn(value);
+            if (edit.ParentInternal != null)
+            {
+                edit.ParentInternal.Controls.Remove(edit);
+            }
+
+            if (value != null)
+            {
+                value.Controls.Add(edit);
+            }
+
+            // we have to tell the edit control about its dataGrid
+            edit.SetDataGrid(value);
+        }
+
+        /* CUT as part of the new DataGridTableStyleSheet thing
+        public override Font Font {
+            set {
+                base.Font = value;
+                Font f = base.Font;
+                edit.Font = f;
+                // if (f != null) {
+                    // fontHandle = f.Handle;
+                // }
+            }
+        }
+        */
+
+        /// <summary>
+        ///  Gets or sets the System.Windows.Forms.ComponentModel.Format for the System.Windows.Forms.DataGridTextBoxColumn
+        ///  .
+        /// </summary>
+        [
+        SRDescription(nameof(SR.FormatControlFormatDescr)),
+        DefaultValue(null)
+        ]
+        public override PropertyDescriptor PropertyDescriptor
+        {
+            set
+            {
+                base.PropertyDescriptor = value;
+                if (PropertyDescriptor != null)
+                {
+                    if (PropertyDescriptor.PropertyType != typeof(object))
+                    {
+                        typeConverter = TypeDescriptor.GetConverter(PropertyDescriptor.PropertyType);
+                        parseMethod = PropertyDescriptor.PropertyType.GetMethod("Parse", new Type[] { typeof(string), typeof(IFormatProvider) });
+                    }
+                }
+            }
+        }
+
+        // add the corresponding value Editor: rip one from the valueEditor for the DisplayMember in the
+        // format object
+        [DefaultValue(null), Editor("System.Windows.Forms.Design.DataGridColumnStyleFormatEditor, " + AssemblyRef.SystemDesign, typeof(Drawing.Design.UITypeEditor))]
+        public string Format
+        {
+            get
+            {
+                return format;
+            }
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (format == null || !format.Equals(value))
+                {
+                    format = value;
+
+                    // if the associated typeConverter cannot convert from string,
+                    // then we can't modify the column value. hence, make it readOnly
+                    //
+                    if (format.Length == 0)
+                    {
+                        if (typeConverter != null && !typeConverter.CanConvertFrom(typeof(string)))
+                        {
+                            ReadOnly = true;
+                        }
+                    }
+
+                    Invalidate();
+                }
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced)]
+        public IFormatProvider FormatInfo
+        {
+            get
+            {
+                return formatInfo;
+            }
+            set
+            {
+                if (formatInfo == null || !formatInfo.Equals(value))
+                {
+                    formatInfo = value;
+                }
+            }
+        }
+
+        public override bool ReadOnly
+        {
+            get
+            {
+                return base.ReadOnly;
+            }
+            set
+            {
+                // if the gridColumn is can't convert the string to
+                // the backGround propertyDescriptor, then make the column ReadOnly
+                if (!value && (format == null || format.Length == 0))
+                {
+                    if (typeConverter != null && !typeConverter.CanConvertFrom(typeof(string)))
+                    {
+                        return;
+                    }
+                }
+
+                base.ReadOnly = value;
+            }
+        }
+
+        // =------------------------------------------------------------------
+        // =        Methods
+        // =------------------------------------------------------------------
+
+        private void DebugOut(string s)
+        {
+            Debug.WriteLineIf(CompModSwitches.DGEditColumnEditing.TraceVerbose, "DGEditColumnEditing: " + s);
+        }
+
+        // will hide the edit control
+        /// <summary>
+        ///  Informs the column the focus is being conceded.
+        /// </summary>
+        protected internal override void ConcedeFocus()
+        {
+            edit.Bounds = Rectangle.Empty;
+            // edit.Visible = false;
+            // HideEditBox();
+        }
+
+        /// <summary>
+        ///  Hides the System.Windows.Forms.TextBox
+        ///  control and moves the focus to the System.Windows.Forms.DataGrid
+        ///  control.
+        /// </summary>
+        protected void HideEditBox()
+        {
+            bool wasFocused = edit.Focused;
+            edit.Visible = false;
+
+            // it seems that edit.Visible = false will take away the focus from
+            // the edit control. And this means that we will not give the focus to the grid
+            // If all the columns would have an edit control this would not be bad
+            // ( or if the grid is the only control on the form ),
+            // but when we have a DataGridBoolColumn then the focus will be taken away
+            // by the next control in the form.
+            //
+            // if (edit.Focused && this.DataGridTableStyle.DataGrid.CanFocus) {
+
+            // when the user deletes the current ( ie active ) column from the
+            // grid, the grid should still call EndEdit ( so that the changes that the user made
+            // before deleting the column will go to the backEnd)
+            // however, in that situation, we are left w/ the editColumn which is not parented.
+            // the grid will call Edit to reset the EditColumn
+            if (wasFocused && DataGridTableStyle != null && DataGridTableStyle.DataGrid != null && DataGridTableStyle.DataGrid.CanFocus)
+            {
+                DataGridTableStyle.DataGrid.Focus();
+                Debug.Assert(!edit.Focused, "the edit control just conceeded focus to the dataGrid");
+            }
+        }
+
+        protected internal override void UpdateUI(CurrencyManager source, int rowNum, string displayText)
+        {
+            edit.Text = GetText(GetColumnValueAtRow(source, rowNum));
+            if (!edit.ReadOnly && displayText != null)
+            {
+                edit.Text = displayText;
+            }
+        }
+
+        /// <summary>
+        ///  Ends an edit operation on the System.Windows.Forms.DataGridColumnStyle
+        ///  .
+        /// </summary>
+        protected void EndEdit()
+        {
+            edit.IsInEditOrNavigateMode = true;
+            DebugOut("Ending Edit");
+            Invalidate();
+        }
+
+        /// <summary>
+        ///  Returns the optimum width and
+        ///  height of the cell in a specified row relative
+        ///  to the specified value.
+        /// </summary>
+        protected internal override Size GetPreferredSize(Graphics g, object value)
+        {
+            Size extents = Size.Ceiling(g.MeasureString(GetText(value), DataGridTableStyle.DataGrid.Font));
+            extents.Width += xMargin * 2 + DataGridTableStyle.GridLineWidth;
+            extents.Height += yMargin;
+            return extents;
+        }
+
+        /// <summary>
+        ///  Gets the height of a cell in a System.Windows.Forms.DataGridColumnStyle
+        ///  .
+        /// </summary>
+        protected internal override int GetMinimumHeight()
+        {
+            // why + 3? cause we have to give some way to the edit box.
+            return FontHeight + yMargin + 3;
+        }
+
+        /// <summary>
+        ///  Gets the height to be used in for automatically resizing columns.
+        /// </summary>
+        protected internal override int GetPreferredHeight(Graphics g, object value)
+        {
+            int newLineIndex = 0;
+            int newLines = 0;
+            string valueString = GetText(value);
+            while (newLineIndex != -1 && newLineIndex < valueString.Length)
+            {
+                newLineIndex = valueString.IndexOf("\r\n", newLineIndex + 1);
+                newLines++;
+            }
+
+            return FontHeight * newLines + yMargin;
+        }
+
+        /// <summary>
+        ///  Initiates a request to interrupt an edit procedure.
+        /// </summary>
+        protected internal override void Abort(int rowNum)
+        {
+            RollBack();
+            HideEditBox();
+            EndEdit();
+        }
+
+        // used for Alt0 functionality
+        /// <summary>
+        ///  Enters a <see langword='null'/> in the column.
+        /// </summary>
+        protected internal override void EnterNullValue()
+        {
+            if (ReadOnly)
+            {
+                return;
+            }
+
+            // if the edit box is not visible, then
+            // do not put the edit text in it
+            if (!edit.Visible)
+            {
+                return;
+            }
+
+            // if we are editing, then we should be able to enter alt-0 in a cell.
+            //
+            if (!edit.IsInEditOrNavigateMode)
+            {
+                return;
+            }
+
+            edit.Text = NullText;
+            // edit.Visible = true;
+            edit.IsInEditOrNavigateMode = false;
+            // tell the dataGrid that there is an edit:
+            if (DataGridTableStyle != null && DataGridTableStyle.DataGrid != null)
+            {
+                DataGridTableStyle.DataGrid.ColumnStartedEditing(edit.Bounds);
+            }
+        }
+
+        /// <summary>
+        ///  Inititates a request to complete an editing procedure.
+        /// </summary>
+        protected internal override bool Commit(CurrencyManager dataSource, int rowNum)
+        {
+            // always hide the edit box
+            // HideEditBox();
+            edit.Bounds = Rectangle.Empty;
+
+            if (edit.IsInEditOrNavigateMode)
+            {
+                return true;
+            }
+
+            try
+            {
+                object value = edit.Text;
+                if (NullText.Equals(value))
+                {
+                    value = Convert.DBNull;
+                    edit.Text = NullText;
+                }
+                else if (format != null && format.Length != 0 && parseMethod != null && FormatInfo != null)
+                {
+                    // use reflection to get the Parse method on the
+                    // type of the propertyDescriptor.
+                    value = (object)parseMethod.Invoke(null, new object[] { edit.Text, FormatInfo });
+                    if (value is IFormattable)
+                    {
+                        edit.Text = ((IFormattable)value).ToString(format, formatInfo);
+                    }
+                    else
+                    {
+                        edit.Text = value.ToString();
+                    }
+                }
+                else if (typeConverter != null && typeConverter.CanConvertFrom(typeof(string)))
+                {
+                    value = typeConverter.ConvertFromString(edit.Text);
+                    edit.Text = typeConverter.ConvertToString(value);
+                }
+
+                SetColumnValueAtRow(dataSource, rowNum, value);
+            }
+            catch
+            {
+                // MessageBox.Show("There was an error caught setting field \""
+                //                 + this.PropertyDescriptor.Name + "\" to the value \"" + edit.Text + "\"\n"
+                //                 + "The value is being rolled back to the original.\n"
+                //                 + "The error was a '" + e.Message + "' "  + e.StackTrace
+                //                 , "Error commiting changes...", MessageBox.IconError);
+                // Debug.WriteLine(e.GetType().Name);
+                RollBack();
+                return false;
+            }
+
+            DebugOut("OnCommit completed without Exception.");
+            EndEdit();
+            return true;
+        }
+
+        /// <summary>
+        ///  Prepares a cell for editing.
+        /// </summary>
+        protected internal override void Edit(CurrencyManager source,
+                                    int rowNum,
+                                    Rectangle bounds,
+                                    bool readOnly,
+                                    string displayText,
+                                    bool cellIsVisible)
+        {
+            DebugOut("Begining Edit, rowNum :" + rowNum.ToString(CultureInfo.InvariantCulture));
+
+            Rectangle originalBounds = bounds;
+
+            edit.ReadOnly = readOnly || ReadOnly || DataGridTableStyle.ReadOnly;
+
+            edit.Text = GetText(GetColumnValueAtRow(source, rowNum));
+            if (!edit.ReadOnly && displayText != null)
+            {
+                // tell the grid that we are changing stuff
+                DataGridTableStyle.DataGrid.ColumnStartedEditing(bounds);
+                // tell the edit control that the user changed it
+                edit.IsInEditOrNavigateMode = false;
+                edit.Text = displayText;
+            }
+
+            if (cellIsVisible)
+            {
+                bounds.Offset(xMargin, 2 * yMargin);
+                bounds.Width -= xMargin;
+                bounds.Height -= 2 * yMargin;
+                DebugOut("edit bounds: " + bounds.ToString());
+                edit.Bounds = bounds;
+
+                edit.Visible = true;
+
+                edit.TextAlign = Alignment;
+            }
+            else
+            {
+                edit.Bounds = Rectangle.Empty;
+                // edit.Bounds = originalBounds;
+                // edit.Visible = false;
+            }
+
+            edit.RightToLeft = DataGridTableStyle.DataGrid.RightToLeft;
+
+            edit.Focus();
+
+            editRow = rowNum;
+
+            if (!edit.ReadOnly)
+            {
+                oldValue = edit.Text;
+            }
+
+            // select the text even if the text box is read only
+            // because the navigation code in the DataGridTextBox::ProcessKeyMessage
+            // uses the SelectedText property
+            if (displayText == null)
+            {
+                edit.SelectAll();
+            }
+            else
+            {
+                int end = edit.Text.Length;
+                edit.Select(end, 0);
+            }
+
+            if (edit.Visible)
+            {
+                DataGridTableStyle.DataGrid.Invalidate(originalBounds);
+            }
+        }
+
+        internal override string GetDisplayText(object value)
+        {
+            return GetText(value);
+        }
+
+        private string GetText(object value)
+        {
+            if (value is DBNull)
+            {
+                return NullText;
+            }
+            else if (format != null && format.Length != 0 && (value is IFormattable))
+            {
+                try
+                {
+                    return ((IFormattable)value).ToString(format, formatInfo);
+                }
+                catch
+                {
+                    //
+                }
+            }
+            else
+            {
+                // use the typeConverter:
+                if (typeConverter != null && typeConverter.CanConvertTo(typeof(string)))
+                {
+                    return (string)typeConverter.ConvertTo(value, typeof(string));
+                }
+            }
+
+            return (value != null ? value.ToString() : "");
+        }
+
+        /// <summary>
+        ///  Paints the a System.Windows.Forms.DataGridColumnStyle with the specified System.Drawing.Graphics,
+        ///  System.Drawing.Rectangle, DataView.Rectangle, and row number.
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum)
+        {
+            Paint(g, bounds, source, rowNum, false);
+        }
+
+        /// <summary>
+        ///  Paints a System.Windows.Forms.DataGridColumnStyle with the specified System.Drawing.Graphics, System.Drawing.Rectangle, DataView, row number, and alignment.
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum, bool alignToRight)
+        {
+            string text = GetText(GetColumnValueAtRow(source, rowNum));
+            PaintText(g, bounds, text, alignToRight);
+        }
+
+        /// <summary>
+        ///  Paints a System.Windows.Forms.DataGridColumnStyle with the specified System.Drawing.Graphics,
+        ///  System.Drawing.Rectangle, DataView.Rectangle, row number, background color,
+        ///  and foreground color..
+        /// </summary>
+        protected internal override void Paint(Graphics g, Rectangle bounds, CurrencyManager source, int rowNum,
+                                     Brush backBrush, Brush foreBrush, bool alignToRight)
+        {
+            string text = GetText(GetColumnValueAtRow(source, rowNum));
+            PaintText(g, bounds, text, backBrush, foreBrush, alignToRight);
+        }
+
+        /// <summary>
+        ///  Draws the text and
+        ///  rectangle at the given location with the specified alignment.
+        /// </summary>
+        protected void PaintText(Graphics g, Rectangle bounds, string text, bool alignToRight)
+        {
+            PaintText(g, bounds, text, DataGridTableStyle.BackBrush, DataGridTableStyle.ForeBrush, alignToRight);
+        }
+
+        /// <summary>
+        ///  Draws the text and rectangle at the specified location with the
+        ///  specified colors and alignment.
+        /// </summary>
+        protected void PaintText(Graphics g, Rectangle textBounds, string text, Brush backBrush, Brush foreBrush, bool alignToRight)
+        {
+            /*
+            if (edit.Visible)
+                g.BackColor = BackColor;
+            */
+
+            Rectangle rect = textBounds;
+
+            StringFormat format = new StringFormat();
+            if (alignToRight)
+            {
+                format.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
+            }
+
+            format.Alignment = Alignment == HorizontalAlignment.Left ? StringAlignment.Near : Alignment == HorizontalAlignment.Center ? StringAlignment.Center : StringAlignment.Far;
+
+            // do not wrap the text
+            //
+            format.FormatFlags |= StringFormatFlags.NoWrap;
+
+            g.FillRectangle(backBrush, rect);
+            // by design, painting  leaves a little padding around the rectangle.
+            // so do not deflate the rectangle.
+            rect.Offset(0, 2 * yMargin);
+            rect.Height -= 2 * yMargin;
+            g.DrawString(text, DataGridTableStyle.DataGrid.Font, foreBrush, rect, format);
+            format.Dispose();
+        }
+
+        private void RollBack()
+        {
+            Debug.Assert(!edit.IsInEditOrNavigateMode, "Must be editing to rollback changes...");
+            edit.Text = oldValue;
+        }
+
+        protected internal override void ReleaseHostedControl()
+        {
+            if (edit.ParentInternal != null)
+            {
+                edit.ParentInternal.Controls.Remove(edit);
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DataGridToolTip.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridToolTip.cs
new file mode 100644
index 00000000000..483eb661bdc
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DataGridToolTip.cs
@@ -0,0 +1,86 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Drawing;
+using System.Runtime.InteropServices;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    // this class is basically a NativeWindow that does toolTipping
+    // should be one for the entire grid
+    internal class DataGridToolTip : MarshalByRefObject
+    {
+        // the toolTip control
+        private NativeWindow tipWindow;
+
+        // the dataGrid which contains this toolTip
+        private readonly DataGrid dataGrid;
+
+        // CONSTRUCTOR
+        public DataGridToolTip(DataGrid dataGrid)
+        {
+            Debug.Assert(dataGrid != null, "can't attach a tool tip to a null grid");
+            this.dataGrid = dataGrid;
+        }
+
+        // will ensure that the toolTip window was created
+        public void CreateToolTipHandle()
+        {
+            if (tipWindow == null || tipWindow.Handle == IntPtr.Zero)
+            {
+                var icc = new ComCtl32.INITCOMMONCONTROLSEX
+                {
+                    dwICC = ComCtl32.ICC.TAB_CLASSES
+                };
+                ComCtl32.InitCommonControlsEx(ref icc);
+
+                var cparams = new CreateParams
+                {
+                    Parent = dataGrid.Handle,
+                    ClassName = ComCtl32.WindowClasses.TOOLTIPS_CLASS,
+                    Style = (int)ComCtl32.TTS.ALWAYSTIP,
+                };
+                tipWindow = new NativeWindow();
+                tipWindow.CreateHandle(cparams);
+
+                User32.SendMessageW((IHandle<HWND>)tipWindow, (User32.WM)ComCtl32.TTM.SETMAXTIPWIDTH, IntPtr.Zero, (IntPtr)SystemInformation.MaxWindowTrackSize.Width);
+                User32.SetWindowPos(
+                    new HandleRef(tipWindow, tipWindow.Handle),
+                    User32.HWND_NOTOPMOST,
+                    flags: User32.SWP.NOSIZE | User32.SWP.NOMOVE | User32.SWP.NOACTIVATE);
+                User32.SendMessageW((IHandle<HWND>)tipWindow, (User32.WM)ComCtl32.TTM.SETDELAYTIME, (IntPtr)ComCtl32.TTDT.INITIAL, (IntPtr)0);
+            }
+        }
+
+        public void AddToolTip(string toolTipString, IntPtr toolTipId, Rectangle iconBounds)
+        {
+            Debug.Assert(tipWindow != null && tipWindow.Handle != IntPtr.Zero, "the tipWindow was not initialized, bailing out");
+            if (iconBounds.IsEmpty)
+                throw new ArgumentNullException(nameof(iconBounds), SR.DataGridToolTipEmptyIcon);
+
+            if (toolTipString == null)
+                throw new ArgumentNullException(nameof(toolTipString));
+
+            var info = new ComCtl32.ToolInfoWrapper<DataGrid>(dataGrid, toolTipId, TOOLTIP_FLAGS.TTF_SUBCLASS, toolTipString, iconBounds);
+            info.SendMessage(tipWindow, PInvoke.TTM_ADDTOOLW);
+        }
+
+        public void RemoveToolTip(IntPtr toolTipId)
+        {
+            var info = new ComCtl32.ToolInfoWrapper<DataGrid>(dataGrid, toolTipId);
+            info.SendMessage(tipWindow, PInvoke.TTM_ADDTOOLW);
+        }
+
+        // will destroy the tipWindow
+        public void Destroy()
+        {
+            Debug.Assert(tipWindow != null, "how can one destroy a null window");
+            tipWindow.DestroyHandle();
+            tipWindow = null;
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/DateTimePicker.cs b/src/System.Windows.Forms/src/System/Windows/Forms/DateTimePicker.cs
index b0a0152816b..1084b7dbaa7 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/DateTimePicker.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/DateTimePicker.cs
@@ -9,6 +9,7 @@
 using SourceGenerated;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ErrorProvider.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ErrorProvider.cs
index 67969cec02c..dbea2dc4c08 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ErrorProvider.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ErrorProvider.cs
@@ -678,7 +678,7 @@ public void Clear()
     /// </summary>
     public bool CanExtend(object? extendee)
     {
-        return extendee is Control && extendee is not Form;
+        return extendee is Control && extendee is not Form && extendee is not ToolBar;
     }
 
     /// <summary>
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/FileDialog.cs b/src/System.Windows.Forms/src/System/Windows/Forms/FileDialog.cs
index 1b2438f9850..7dcdc1984c2 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/FileDialog.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/FileDialog.cs
@@ -457,13 +457,16 @@ private protected static bool FileExists(string? fileName)
     private static string[] GetMultiselectFiles(ReadOnlySpan<char> fileBuffer)
     {
         var directory = fileBuffer.SliceAtFirstNull();
-        var fileNames = fileBuffer[directory.Length..];
-        if (fileNames.Length == 0)
+        var fileNames = fileBuffer[(directory.Length + 1)..];
+
+        // When a single file is returned, the directory is not null delimited.
+        // So we check here to see if the filename starts with a null.
+        if (fileNames.Length == 0 || fileNames[0] == '\0')
         {
             return new string[] { directory.ToString() };
         }
 
-        List<string> names = new List<string>();
+        List<string> names = [];
         var fileName = fileNames.SliceAtFirstNull();
         while (fileName.Length > 0)
         {
@@ -471,7 +474,7 @@ private static string[] GetMultiselectFiles(ReadOnlySpan<char> fileBuffer)
                 ? fileName.ToString()
                 : Path.Join(directory, fileName));
 
-            fileNames = fileNames[fileName.Length..];
+            fileNames = fileNames[(fileName.Length + 1)..];
             fileName = fileNames.SliceAtFirstNull();
         }
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/Form.cs b/src/System.Windows.Forms/src/System/Windows/Forms/Form.cs
index 45dd6330a3d..cd35ccbdd6c 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/Form.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/Form.cs
@@ -131,6 +131,8 @@ public partial class Form : ContainerControl
     private static readonly int PropOpacity = PropertyStore.CreateKey();
     private static readonly int PropTransparencyKey = PropertyStore.CreateKey();
 
+    private static readonly int PropMainMenu = PropertyStore.CreateKey();
+
     // Form per instance members
     // Note: Do not add anything to this list unless absolutely necessary.
 
@@ -715,6 +717,263 @@ public FormBorderStyle FormBorderStyle
         }
     }
 
+    /// <summary>
+    ///  Gets or sets the <see cref='MainMenu'/>
+    ///  that is displayed in the form.
+    /// </summary>
+    [
+        SRCategory(nameof(SR.CatWindowStyle)),
+        DefaultValue(null),
+        SRDescription(nameof(SR.FormMenuDescr)),
+        TypeConverter(typeof(ReferenceConverter)),
+        Browsable(false),
+    ]
+    public MainMenu? Menu
+    {
+        get
+        {
+            return (MainMenu)Properties.GetObject(PropMainMenu);
+        }
+        set
+        {
+            MainMenu mainMenu = Menu;
+
+            if (mainMenu != value)
+            {
+                if (mainMenu != null)
+                {
+                    mainMenu._form = null;
+                }
+
+                Properties.SetObject(PropMainMenu, value);
+
+                if (value != null)
+                {
+                    if (value._form != null)
+                    {
+                        value._form.Menu = null;
+                    }
+
+                    value._form = this;
+                }
+
+                if (_formState[FormStateSetClientSize] == 1 && !IsHandleCreated)
+                {
+                    ClientSize = ClientSize;
+                }
+
+                MenuChanged(Windows.Forms.Menu.CHANGE_ITEMS, value);
+            }
+        }
+    }
+
+    // Package scope for menu interop
+    internal void MenuChanged(int change, Menu menu)
+    {
+        Form parForm = ParentForm;
+        if (parForm != null && this == parForm.ActiveMdiChildInternal)
+        {
+            parForm.MenuChanged(change, menu);
+            return;
+        }
+
+        switch (change)
+        {
+            case Windows.Forms.Menu.CHANGE_ITEMS:
+            case Windows.Forms.Menu.CHANGE_MERGE:
+                if (_ctlClient == null || !_ctlClient.IsHandleCreated)
+                {
+                    if (menu == Menu && change == Windows.Forms.Menu.CHANGE_ITEMS)
+                    {
+                        UpdateMenuHandles();
+                    }
+
+                    break;
+                }
+
+                // Tell the children to toss their mergedMenu.
+                if (IsHandleCreated)
+                {
+                    UpdateMenuHandles(null, false);
+                }
+
+                Control.ControlCollection children = _ctlClient.Controls;
+                for (int i = children.Count; i-- > 0;)
+                {
+                    Control ctl = children[i];
+                    if (ctl is Form && ctl.Properties.ContainsObject(PropMergedMenu))
+                    {
+                        if (ctl.Properties.GetObject(PropMergedMenu) is MainMenu mainMenu && mainMenu.ownerForm == ctl)
+                        {
+                            mainMenu.Dispose();
+                        }
+
+                        ctl.Properties.SetObject(PropMergedMenu, null);
+                    }
+                }
+
+                UpdateMenuHandles();
+                break;
+            case Windows.Forms.Menu.CHANGE_VISIBLE:
+                if (menu == Menu || (ActiveMdiChildInternal != null && menu == ActiveMdiChildInternal.Menu))
+                {
+                    UpdateMenuHandles();
+                }
+
+                break;
+            case Windows.Forms.Menu.CHANGE_MDI:
+                if (_ctlClient != null && _ctlClient.IsHandleCreated)
+                {
+                    UpdateMenuHandles();
+                }
+
+                break;
+        }
+    }
+
+    private static readonly int PropCurMenu = PropertyStore.CreateKey();
+    private static readonly int PropDummyMenu = PropertyStore.CreateKey();
+
+    private void UpdateMenuHandles()
+    {
+        Form form;
+
+        // Forget the current menu.
+        if (Properties.GetObject(PropCurMenu) != null)
+        {
+            Properties.SetObject(PropCurMenu, null);
+        }
+
+        if (IsHandleCreated)
+        {
+            if (!TopLevel)
+            {
+                UpdateMenuHandles(null, true);
+            }
+            else
+            {
+                form = ActiveMdiChildInternal;
+                if (form != null)
+                {
+                    UpdateMenuHandles(form.MergedMenuPrivate, true);
+                }
+                else
+                {
+                    UpdateMenuHandles(Menu, true);
+                }
+            }
+        }
+    }
+
+    private void UpdateMenuHandles(MainMenu menu, bool forceRedraw)
+    {
+        Debug.Assert(IsHandleCreated, "shouldn't call when handle == 0");
+
+        int suspendCount = _formStateEx[FormStateExUpdateMenuHandlesSuspendCount];
+        if (suspendCount > 0 && menu != null)
+        {
+            _formStateEx[FormStateExUpdateMenuHandlesDeferred] = 1;
+            return;
+        }
+
+        MainMenu curMenu = menu;
+        if (curMenu != null)
+        {
+            curMenu._form = this;
+        }
+
+        if (curMenu != null || Properties.ContainsObject(PropCurMenu))
+        {
+            Properties.SetObject(PropCurMenu, curMenu);
+        }
+
+        if (_ctlClient == null || !_ctlClient.IsHandleCreated)
+        {
+            if (menu != null)
+            {
+                User32.SetMenu(this, new HandleRef(menu, menu.Handle));
+            }
+            else
+            {
+                User32.SetMenu(this, NativeMethods.NullHandleRef);
+            }
+        }
+        else
+        {
+            Debug.Assert(IsMdiContainer, "Not an MDI container!");
+            // when both MainMenuStrip and Menu are set, we honor the win32 menu over
+            // the MainMenuStrip as the place to store the system menu controls for the maximized MDI child.
+
+            MenuStrip mainMenuStrip = MainMenuStrip;
+            if (mainMenuStrip == null || menu != null)
+            {  // We are dealing with a Win32 Menu; MenuStrip doesn't have control buttons.
+
+                // We have a MainMenu and we're going to use it
+
+                // We need to set the "dummy" menu even when a menu is being removed
+                // (set to null) so that duplicate control buttons are not placed on the menu bar when
+                // an ole menu is being removed.
+                // Make MDI forget the mdi item position.
+                MainMenu dummyMenu = (MainMenu)Properties.GetObject(PropDummyMenu);
+
+                if (dummyMenu == null)
+                {
+                    dummyMenu = new MainMenu
+                    {
+                        ownerForm = this
+                    };
+                    Properties.SetObject(PropDummyMenu, dummyMenu);
+                }
+
+                UnsafeNativeMethods.SendMessage(new HandleRef(_ctlClient, _ctlClient.Handle), WindowMessages.WM_MDISETMENU, dummyMenu.Handle, IntPtr.Zero);
+
+                if (menu != null)
+                {
+
+                    // Microsoft, 5/2/1998 - don't use Win32 native Mdi lists...
+                    //
+                    UnsafeNativeMethods.SendMessage(new HandleRef(_ctlClient, _ctlClient.Handle), WindowMessages.WM_MDISETMENU, menu.Handle, IntPtr.Zero);
+                }
+            }
+
+            // (New fix: Only destroy Win32 Menu if using a MenuStrip)
+            if (menu == null && mainMenuStrip != null)
+            { // If MainMenuStrip, we need to remove any Win32 Menu to make room for it.
+                IntPtr hMenu = User32.GetMenu(this);
+                if (hMenu != IntPtr.Zero)
+                {
+
+                    // We had a MainMenu and now we're switching over to MainMenuStrip
+
+                    // Remove the current menu.
+                    User32.SetMenu(this, NativeMethods.NullHandleRef);
+
+                    // because we have messed with the child's system menu by shoving in our own dummy menu,
+                    // once we clear the main menu we're in trouble - this eats the close, minimize, maximize gadgets
+                    // of the child form. (See WM_MDISETMENU in MSDN)
+                    Form activeMdiChild = ActiveMdiChildInternal;
+                    if (activeMdiChild != null && activeMdiChild.WindowState == FormWindowState.Maximized)
+                    {
+                        activeMdiChild.RecreateHandle();
+                    }
+
+                    // Since we're removing a menu but we possibly had a menu previously,
+                    // we need to clear the cached size so that new size calculations will be performed correctly.
+                    CommonProperties.xClearPreferredSizeCache(this);
+                }
+            }
+        }
+
+        if (forceRedraw)
+        {
+            SafeNativeMethods.DrawMenuBar(new HandleRef(this, Handle));
+        }
+
+        _formStateEx[FormStateExUpdateMenuHandlesDeferred] = 0;
+    }
+
+    private static readonly int PropMergedMenu = PropertyStore.CreateKey();
+
     /// <summary>
     ///  Gets
     ///  or
@@ -994,6 +1253,26 @@ public DialogResult DialogResult
         }
     }
 
+    internal override bool HasMenu
+    {
+        get
+        {
+            bool hasMenu = false;
+
+            // Verify that the menu actually contains items so that any
+            // size calculations will only include a menu height if the menu actually exists.
+            // Note that Windows will not draw a menu bar for a menu that does not contain
+            // any items.
+            Menu menu = Menu;
+            if (TopLevel && menu != null && menu.ItemCount > 0)
+            {
+                hasMenu = true;
+            }
+
+            return hasMenu;
+        }
+    }
+
     /// <summary>
     ///  Gets or sets a value indicating whether a
     ///  help button should be displayed in the caption box of the form.
@@ -1340,7 +1619,7 @@ public MenuStrip? MainMenuStrip
             Properties.SetObject(PropMainMenuStrip, value);
             if (IsHandleCreated)
             {
-                UpdateMenuHandles(recreateMenu: true);
+                UpdateMenuHandles();
             }
         }
     }
@@ -3081,7 +3360,7 @@ private Size ComputeWindowSize(Size clientSize)
     private Size ComputeWindowSize(Size clientSize, WINDOW_STYLE style, WINDOW_EX_STYLE exStyle)
     {
         RECT result = new(clientSize);
-        AdjustWindowRectExForControlDpi(ref result, style, false, exStyle);
+        AdjustWindowRectExForControlDpi(ref result, style, HasMenu, exStyle);
         return result.Size;
     }
 
@@ -3203,7 +3482,7 @@ protected override void CreateHandle()
             }
 
             // avoid extra SetMenu calls for perf
-            if (!TopLevel || IsMdiContainer)
+            if (Menu != null || !TopLevel || IsMdiContainer)
             {
                 UpdateMenuHandles();
             }
@@ -3389,10 +3668,46 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
             _ctlClient = null;
 
-            if (Properties.TryGetObject(PropDummyMdiMenu, out HMENU dummyMenu) && !dummyMenu.IsNull)
+            MainMenu mainMenu = Menu;
+
+            // We should only dispose this form's menus!
+            if (mainMenu != null && mainMenu.ownerForm == this)
+            {
+                mainMenu.Dispose();
+                Properties.SetObject(PropMainMenu, null);
+            }
+
+            if (Properties.GetObject(PropCurMenu) != null)
+            {
+                Properties.SetObject(PropCurMenu, null);
+            }
+
+            MenuChanged(Windows.Forms.Menu.CHANGE_ITEMS, null);
+
+            MainMenu dummyMenu = (MainMenu)Properties.GetObject(PropDummyMenu);
+
+            if (dummyMenu != null)
+            {
+                dummyMenu.Dispose();
+                Properties.SetObject(PropDummyMenu, null);
+            }
+
+            MainMenu mergedMenu = (MainMenu)Properties.GetObject(PropMergedMenu);
+
+            if (mergedMenu != null)
+            {
+                if (mergedMenu.ownerForm == this || mergedMenu._form == null)
+                {
+                    mergedMenu.Dispose();
+                }
+
+                Properties.SetObject(PropMergedMenu, null);
+            }
+
+            if (Properties.TryGetObject(PropDummyMdiMenu, out HMENU dummyMdiMenu) && !dummyMdiMenu.IsNull)
             {
                 Properties.RemoveObject(PropDummyMdiMenu);
-                PInvoke.DestroyMenu(dummyMenu);
+                PInvoke.DestroyMenu(dummyMdiMenu);
             }
         }
         else
@@ -3991,6 +4306,7 @@ protected override void OnHandleCreated(EventArgs e)
         _formStateEx[FormStateExUseMdiChildProc] = (IsMdiChild && Visible) ? 1 : 0;
         base.OnHandleCreated(e);
         UpdateLayered();
+        UpdateMenuHandles();
     }
 
     /// <summary>
@@ -4503,6 +4819,9 @@ protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
         msg.LParamInternal = win32Message.lParam;
         msg.HWnd = win32Message.hwnd;
 
+        // Process main menu accelerator keys.
+        retValue = Menu?.ProcessCmdKey(ref msg, keyData) == true || retValue;
+
         return retValue;
     }
 
@@ -5651,71 +5970,6 @@ private void UpdateLayered()
         }
     }
 
-    private void UpdateMenuHandles(bool recreateMenu = false)
-    {
-        if (!IsHandleCreated)
-        {
-            return;
-        }
-
-        if (_ctlClient is null || !_ctlClient.IsHandleCreated)
-        {
-            PInvoke.SetMenu(this, HMENU.Null);
-        }
-        else
-        {
-            Debug.Assert(IsMdiContainer, "Not an MDI container!");
-            // when both MainMenuStrip and Menu are set, we honor the win32 menu over
-            // the MainMenuStrip as the place to store the system menu controls for the maximized MDI child.
-
-            MenuStrip? mainMenuStrip = MainMenuStrip;
-            if (mainMenuStrip is null)
-            {
-                // We are dealing with a Win32 Menu; MenuStrip doesn't have control buttons.
-
-                // We need to set the "dummy" menu even when a menu is being removed
-                // (set to null) so that duplicate control buttons are not placed on the menu bar when
-                // an ole menu is being removed.
-                // Make MDI forget the mdi item position.
-                if (!Properties.TryGetObject(PropDummyMdiMenu, out HMENU dummyMenu) || dummyMenu.IsNull || recreateMenu)
-                {
-                    dummyMenu = PInvoke.CreateMenu();
-                    Properties.SetObject(PropDummyMdiMenu, dummyMenu);
-                }
-
-                PInvoke.SendMessage(_ctlClient, PInvoke.WM_MDISETMENU, (WPARAM)dummyMenu.Value);
-            }
-
-            // (New fix: Only destroy Win32 Menu if using a MenuStrip)
-            if (mainMenuStrip is not null)
-            {
-                // If MainMenuStrip, we need to remove any Win32 Menu to make room for it.
-                HMENU hMenu = PInvoke.GetMenu(this);
-                if (hMenu != HMENU.Null)
-                {
-                    // Remove the current menu.
-                    PInvoke.SetMenu(this, HMENU.Null);
-
-                    // because we have messed with the child's system menu by shoving in our own dummy menu,
-                    // once we clear the main menu we're in trouble - this eats the close, minimize, maximize gadgets
-                    // of the child form. (See WM_MDISETMENU in MSDN)
-                    Form? activeMdiChild = ActiveMdiChildInternal;
-                    if (activeMdiChild is not null && activeMdiChild.WindowState == FormWindowState.Maximized)
-                    {
-                        activeMdiChild.RecreateHandle();
-                    }
-
-                    // Since we're removing a menu but we possibly had a menu previously,
-                    // we need to clear the cached size so that new size calculations will be performed correctly.
-                    CommonProperties.xClearPreferredSizeCache(this);
-                }
-            }
-        }
-
-        PInvoke.DrawMenuBar(this);
-        _formStateEx[FormStateExUpdateMenuHandlesDeferred] = 0;
-    }
-
     // Call this function instead of UpdateStyles() when the form's client-size must
     // be preserved e.g. when changing the border style.
     //
@@ -5787,6 +6041,66 @@ private void UpdateToolStrip()
         UpdateMdiControlStrip(activeMdiForm is not null && activeMdiForm.IsMaximized);
     }
 
+    /// <summary>
+    ///  Gets the merged menu for the
+    ///  form.
+    /// </summary>
+    [
+        SRCategory(nameof(SR.CatWindowStyle)),
+        Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.FormMergedMenuDescr)),
+    ]
+    public MainMenu MergedMenu
+    {
+        get
+        {
+            return MergedMenuPrivate;
+        }
+    }
+
+    private MainMenu MergedMenuPrivate
+    {
+        get
+        {
+            Form formMdiParent = (Form)Properties.GetObject(PropFormMdiParent);
+            if (formMdiParent == null)
+            {
+                return null;
+            }
+
+            MainMenu mergedMenu = (MainMenu)Properties.GetObject(PropMergedMenu);
+            if (mergedMenu != null)
+            {
+                return mergedMenu;
+            }
+
+            MainMenu parentMenu = formMdiParent.Menu;
+            MainMenu mainMenu = Menu;
+
+            if (mainMenu == null)
+            {
+                return parentMenu;
+            }
+
+            if (parentMenu == null)
+            {
+                return mainMenu;
+            }
+
+            // Create a menu that merges the two and save it for next time.
+            mergedMenu = new MainMenu
+            {
+                ownerForm = this
+            };
+
+            mergedMenu.MergeMenu(parentMenu);
+            mergedMenu.MergeMenu(mainMenu);
+            Properties.SetObject(PropMergedMenu, mergedMenu);
+            return mergedMenu;
+        }
+    }
+
     private void UpdateMdiControlStrip(bool maximized)
     {
         if (_formStateEx[FormStateExInUpdateMdiControlStrip] != 0)
@@ -6406,6 +6720,57 @@ private unsafe void WmGetMinMaxInfoHelper(ref Message m, Size minTrack, Size max
         m.ResultInternal = (LRESULT)0;
     }
 
+    /// <summary>
+    ///  WM_INITMENUPOPUP handler
+    /// </summary>
+    private void WmInitMenuPopup(ref Message m)
+    {
+        MainMenu curMenu = (MainMenu)Properties.GetObject(PropCurMenu);
+        if (curMenu != null)
+        {
+
+            //curMenu.UpdateRtl((RightToLeft == RightToLeft.Yes));
+
+            if (curMenu.ProcessInitMenuPopup(m.WParam))
+            {
+                return;
+            }
+        }
+
+        base.WndProc(ref m);
+    }
+
+    /// <summary>
+    ///  Handles the WM_MENUCHAR message
+    /// </summary>
+    private void WmMenuChar(ref Message m)
+    {
+        MainMenu curMenu = (MainMenu)Properties.GetObject(PropCurMenu);
+        if (curMenu == null)
+        {
+
+            Form formMdiParent = (Form)Properties.GetObject(PropFormMdiParent);
+            if (formMdiParent != null && formMdiParent.Menu != null)
+            {
+                PInvoke.PostMessage(formMdiParent, WindowMessages.WM_SYSCOMMAND, NativeMethods.SC_KEYMENU, m.WParam);
+                m.Result = (IntPtr)NativeMethods.Util.MAKELONG(0, 1);
+                return;
+            }
+        }
+
+        if (curMenu != null)
+        {
+            curMenu.WmMenuChar(ref m);
+            if (m.Result != IntPtr.Zero)
+            {
+                // This char is a mnemonic on our menu.
+                return;
+            }
+        }
+
+        base.WndProc(ref m);
+    }
+
     /// <summary>
     ///  WM_MDIACTIVATE handler
     /// </summary>
@@ -6593,6 +6958,18 @@ private void WmSize(ref Message m)
         }
     }
 
+    /// <summary>
+    ///  WM_UNINITMENUPOPUP handler
+    /// </summary>
+    private void WmUnInitMenuPopup(ref Message m)
+    {
+        if (Menu != null)
+        {
+            //Whidbey addition - also raise the MainMenu.Collapse event for the current menu
+            Menu.OnCollapse(EventArgs.Empty);
+        }
+    }
+
     /// <summary>
     ///  WM_WINDOWPOSCHANGED handler
     /// </summary>
@@ -6657,6 +7034,16 @@ protected override void WndProc(ref Message m)
                 WmEraseBkgnd(ref m);
                 break;
 
+            case WindowMessages.WM_INITMENUPOPUP:
+                WmInitMenuPopup(ref m);
+                break;
+            case WindowMessages.WM_UNINITMENUPOPUP:
+                WmUnInitMenuPopup(ref m);
+                break;
+            case WindowMessages.WM_MENUCHAR:
+                WmMenuChar(ref m);
+                break;
+
             case PInvoke.WM_NCDESTROY:
                 WmNCDestroy(ref m);
                 break;
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/GridColumnStylesCollection.cs b/src/System.Windows.Forms/src/System/Windows/Forms/GridColumnStylesCollection.cs
new file mode 100644
index 00000000000..f47fbb47da1
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/GridColumnStylesCollection.cs
@@ -0,0 +1,566 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing.Design;
+using System.Globalization;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a collection of System.Windows.Forms.DataGridColumnStyle objects in the <see cref='DataGrid'/>
+    ///  control.
+    /// </summary>
+    [
+    Editor("System.Windows.Forms.Design.DataGridColumnCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
+    ListBindable(false)
+    ]
+    public class GridColumnStylesCollection : BaseCollection, IList
+    {
+        CollectionChangeEventHandler onCollectionChanged;
+        readonly ArrayList items = new ArrayList();
+        readonly DataGridTableStyle owner;
+        private readonly bool isDefault;
+
+        // we have to implement IList for the Collection editor to work
+        //
+        int IList.Add(object value)
+        {
+            return Add((DataGridColumnStyle)value);
+        }
+
+        void IList.Clear()
+        {
+            Clear();
+        }
+
+        bool IList.Contains(object value)
+        {
+            return items.Contains(value);
+        }
+
+        int IList.IndexOf(object value)
+        {
+            return items.IndexOf(value);
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            throw new NotSupportedException();
+        }
+
+        void IList.Remove(object value)
+        {
+            Remove((DataGridColumnStyle)value);
+        }
+
+        void IList.RemoveAt(int index)
+        {
+            RemoveAt(index);
+        }
+
+        bool IList.IsFixedSize
+        {
+            get { return false; }
+        }
+
+        bool IList.IsReadOnly
+        {
+            get { return false; }
+        }
+
+        object IList.this[int index]
+        {
+            get { return items[index]; }
+            set { throw new NotSupportedException(); }
+        }
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            items.CopyTo(array, index);
+        }
+
+        int ICollection.Count
+        {
+            get { return items.Count; }
+        }
+
+        bool ICollection.IsSynchronized
+        {
+            get { return false; }
+        }
+
+        object ICollection.SyncRoot
+        {
+            get { return this; }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
+
+        internal GridColumnStylesCollection(DataGridTableStyle table)
+        {
+            owner = table;
+        }
+
+        internal GridColumnStylesCollection(DataGridTableStyle table, bool isDefault) : this(table)
+        {
+            this.isDefault = isDefault;
+        }
+
+        /// <summary>
+        ///  Gets the list of items in the collection.
+        /// </summary>
+        protected override ArrayList List
+        {
+            get
+            {
+                return items;
+            }
+        }
+
+        /* implemented in BaseCollection
+        /// <summary>
+        ///  Gets the number of System.Windows.Forms.DataGridColumnStyle objects in the collection.
+        /// </summary>
+        /// <value>
+        ///  The number of System.Windows.Forms.DataGridColumnStyle objects in the System.Windows.Forms.GridColumnsStyleCollection .
+        /// </value>
+        /// <example>
+        ///  The following example uses the <see cref='System.Windows.Forms.GridColumnsCollection.Count'/>
+        ///  property to determine how many System.Windows.Forms.DataGridColumnStyle objects are in a System.Windows.Forms.GridColumnsStyleCollection, and uses that number to iterate through the
+        ///  collection.
+        ///  <code lang='VB'>
+        ///  Private Sub PrintGridColumns()
+        ///  Dim colsCount As Integer
+        ///  colsCount = DataGrid1.GridColumns.Count
+        ///  Dim i As Integer
+        ///  For i = 0 to colsCount - 1
+        ///  Debug.Print DataGrid1.GridColumns(i).GetType.ToString
+        ///  Next i
+        ///  End Sub
+        ///  </code>
+        /// </example>
+        /// <seealso cref='System.Windows.Forms.GridColumnsCollection.Add'/>
+        /// <seealso cref='System.Windows.Forms.GridColumnsCollection.Remove'/>
+        public override int Count {
+            get {
+                return items.Count;
+            }
+        }
+        */
+
+        /// <summary>
+        ///  Gets the System.Windows.Forms.DataGridColumnStyle at a specified index.
+        /// </summary>
+        public DataGridColumnStyle this[int index]
+        {
+            get
+            {
+                return (DataGridColumnStyle)items[index];
+            }
+        }
+
+        /// <summary>
+        ///  Gets the System.Windows.Forms.DataGridColumnStyle
+        ///  with the specified name.
+        /// </summary>
+        public DataGridColumnStyle this[string columnName]
+        {
+            get
+            {
+                int itemCount = items.Count;
+                for (int i = 0; i < itemCount; ++i)
+                {
+                    DataGridColumnStyle column = (DataGridColumnStyle)items[i];
+                    // NOTE: case-insensitive
+                    if (string.Equals(column.MappingName, columnName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return column;
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        internal DataGridColumnStyle MapColumnStyleToPropertyName(string mappingName)
+        {
+            int itemCount = items.Count;
+            for (int i = 0; i < itemCount; ++i)
+            {
+                DataGridColumnStyle column = (DataGridColumnStyle)items[i];
+                // NOTE: case-insensitive
+                if (string.Equals(column.MappingName, mappingName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return column;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        ///  Gets the System.Windows.Forms.DataGridColumnStyle associated with the
+        ///  specified <see cref='Data.DataColumn'/>.
+        /// </summary>
+        public DataGridColumnStyle this[PropertyDescriptor propertyDesciptor]
+        {
+            get
+            {
+                int itemCount = items.Count;
+                for (int i = 0; i < itemCount; ++i)
+                {
+                    DataGridColumnStyle column = (DataGridColumnStyle)items[i];
+                    if (propertyDesciptor.Equals(column.PropertyDescriptor))
+                    {
+                        return column;
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        internal DataGridTableStyle DataGridTableStyle
+        {
+            get
+            {
+                return owner;
+            }
+        }
+
+        /// <summary>
+        ///  Adds a System.Windows.Forms.DataGridColumnStyle to the System.Windows.Forms.GridColumnStylesCollection
+        /// </summary>
+        internal void CheckForMappingNameDuplicates(DataGridColumnStyle column)
+        {
+            if (string.IsNullOrEmpty(column.MappingName))
+            {
+                return;
+            }
+
+            for (int i = 0; i < items.Count; i++)
+            {
+                if (((DataGridColumnStyle)items[i]).MappingName.Equals(column.MappingName) && column != items[i])
+                {
+                    throw new ArgumentException(SR.DataGridColumnStyleDuplicateMappingName, nameof(column));
+                }
+            }
+        }
+
+        private void ColumnStyleMappingNameChanged(object sender, EventArgs pcea)
+        {
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null));
+        }
+
+        private void ColumnStylePropDescChanged(object sender, EventArgs pcea)
+        {
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, (DataGridColumnStyle)sender));
+        }
+
+        public virtual int Add(DataGridColumnStyle column)
+        {
+            if (isDefault)
+            {
+                throw new ArgumentException(SR.DataGridDefaultColumnCollectionChanged);
+            }
+
+            CheckForMappingNameDuplicates(column);
+
+            column.SetDataGridTableInColumn(owner, true);
+            column.MappingNameChanged += new EventHandler(ColumnStyleMappingNameChanged);
+            column.PropertyDescriptorChanged += new EventHandler(ColumnStylePropDescChanged);
+
+            // columns which are not the default should have a default
+            // width of DataGrid.PreferredColumnWidth
+            if (DataGridTableStyle != null && column.Width == -1)
+            {
+                column._width = DataGridTableStyle.PreferredColumnWidth;
+            }
+#if false
+            column.AddOnPropertyChanged(owner.OnColumnChanged);
+#endif
+            int index = items.Add(column);
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Add, column));
+            return index;
+        }
+
+        public void AddRange(DataGridColumnStyle[] columns)
+        {
+            if (columns == null)
+            {
+                throw new ArgumentNullException(nameof(columns));
+            }
+
+            for (int i = 0; i < columns.Length; i++)
+            {
+                Add(columns[i]);
+            }
+        }
+
+        // the dataGrid will need to add default columns to a default
+        // table when there is no match for the listName in the tableStyle
+        internal void AddDefaultColumn(DataGridColumnStyle column)
+        {
+#if DEBUG
+            Debug.Assert(isDefault, "we should be calling this function only for default tables");
+            Debug.Assert(column.IsDefault, "we should be a default column");
+#endif // DEBUG
+            column.SetDataGridTableInColumn(owner, true);
+            items.Add(column);
+        }
+
+        internal void ResetDefaultColumnCollection()
+        {
+            Debug.Assert(isDefault, "we should be calling this function only for default tables");
+            // unparent the edit controls
+            for (int i = 0; i < Count; i++)
+            {
+                this[i].ReleaseHostedControl();
+            }
+
+            // get rid of the old list and get a new empty list
+            items.Clear();
+        }
+
+        /// <summary>
+        ///  Occurs when a change is made to the System.Windows.Forms.GridColumnStylesCollection.
+        /// </summary>
+        public event CollectionChangeEventHandler CollectionChanged
+        {
+            add => onCollectionChanged += value;
+            remove => onCollectionChanged -= value;
+        }
+
+        public void Clear()
+        {
+            for (int i = 0; i < Count; i++)
+            {
+                this[i].ReleaseHostedControl();
+            }
+
+            items.Clear();
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null));
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the System.Windows.Forms.GridColumnStylesCollection contains a System.Windows.Forms.DataGridColumnStyle associated with the
+        ///  specified <see cref='Data.DataColumn'/>.
+        /// </summary>
+        public bool Contains(PropertyDescriptor propertyDescriptor)
+        {
+            return this[propertyDescriptor] != null;
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the System.Windows.Forms.GridColumnsStyleCollection contains the specified System.Windows.Forms.DataGridColumnStyle.
+        /// </summary>
+        public bool Contains(DataGridColumnStyle column)
+        {
+            int index = items.IndexOf(column);
+            return index != -1;
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the System.Windows.Forms.GridColumnsStyleCollection contains the System.Windows.Forms.DataGridColumnStyle with the specified name.
+        /// </summary>
+        public bool Contains(string name)
+        {
+            IEnumerator e = items.GetEnumerator();
+            while (e.MoveNext())
+            {
+                DataGridColumnStyle column = (DataGridColumnStyle)e.Current;
+                // NOTE: case-insensitive
+                if (string.Compare(column.MappingName, name, true, CultureInfo.InvariantCulture) == 0)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /* implemented at BaseCollection
+        /// <overload>
+        ///  Gets an enumerator for the System.Windows.Forms.GridColumnsStyleCollection.
+        /// </overload>
+        /// <summary>
+        ///  Gets an enumerator for the System.Windows.Forms.GridColumnsStyleCollection.
+        /// </summary>
+        /// <returns>
+        ///  An <see cref='System.Collections.IEnumerator'/>
+        ///  that can be used to iterate through the collection.
+        /// </returns>
+        /// <example>
+        ///  The following example gets an <see cref='System.Collections.IEnumerator'/> that iterates through the System.Windows.Forms.GridColumnsStyleCollection. and prints the
+        ///  <see cref='System.Windows.Forms.GridColumnsCollection.Caption'/> of each <see cref='System.Data.DataColumn'/>
+        ///  associated with the object.
+            /// <code lang='VB'>
+        ///  Private Sub EnumerateThroughGridColumns()
+        ///  Dim ie As System.Collections.IEnumerator
+        ///  Dim dgCol As DataGridColumn
+        ///  Set ie = DataGrid1.GridColumns.GetEnumerator
+        ///  Do While ie.GetNext = True
+        ///  Set dgCol = ie.GetObject
+        ///  Debug.Print dgCol.DataColumn.Caption
+        ///  Loop
+        ///  End Sub
+        /// </code>
+        /// </example>
+        /// <seealso cref='System.Data.DataColumn'/>
+        /// <seealso cref='System.Collections.IEnumerator'/>
+        /// <seealso cref='System.Windows.Forms.IEnumerator.GetNext'/>
+        /// <seealso cref='System.Windows.Forms.IEnumerator.GetObject'/>
+        public override IEnumerator GetEnumerator() {
+            return items.GetEnumerator();
+        }
+
+        /// <summary>
+        ///  Gets an enumerator for the System.Windows.Forms.GridColumnsStyleCollection
+        ///  .
+        /// </summary>
+        /// <param name='allowRemove'>
+        ///  A value that indicates if the enumerator can remove elements. <see langword='true'/>, if removals are allowed; otherwise, <see langword='false'/>. The default is <see langword='false'/>.
+        /// </param>
+        /// <returns>
+        ///  An <see cref='System.Collections.IEnumerator'/> that can be used to iterate through the
+        ///  collection.
+        /// </returns>
+        /// <exception cref='NotSupportedException'>
+        ///  An attempt was made to remove the System.Windows.Forms.DataGridColumnStyle through the <see cref='System.Collections.Enumerator'/> object's <see cref='System.Windows.Forms.Enumerator.Remove'/> method. Use the System.Windows.Forms.GridColumnsStyleCollection object's <see cref='System.Windows.Forms.GridColumnsCollection.Remove'/> method instead.
+        /// </exception>
+        /// <remarks>
+        ///  Because this implementation doesn't support the removal
+        ///  of System.Windows.Forms.DataGridColumnStyle objects through the <see cref='System.Collections.Enumerator'/>
+        ///  class's <see cref='System.Windows.Forms.Enumerator.Remove'/> method, you must use the <see cref='System.Windows.Forms.DataGridCollection'/> class's <see cref='System.Windows.Forms.GridColumnsCollection.Remove'/>
+        ///  method instead.
+        /// </remarks>
+        /// <example>
+        ///  The following example gets an <see cref='System.Collections.IEnumerator'/> for that iterates through the System.Windows.Forms.GridColumnsStyleCollection. If a column in the collection is of type <see cref='System.Windows.Forms.DataGridBoolColumn'/>, it is deleted.
+        ///  <code lang='VB'>
+        ///  Private Sub RemoveBoolColumns()
+        ///  Dim ie As System.Collections.IEnumerator
+        ///  Dim dgCol As DataGridColumn
+        ///  Set ie = DataGrid1.GridColumns.GetEnumerator(true)
+        ///  Do While ie.GetNext
+        ///  Set dgCol = ie.GetObject
+        ///
+        ///  If dgCol.ToString = "DataGridBoolColumn" Then
+        ///  DataGrid1.GridColumns.Remove dgCol
+        ///  End If
+        ///  Loop
+        ///  End If
+        ///  </code>
+        /// </example>
+        /// <seealso cref='System.Collections.IEnumerator'/>
+        /// <seealso cref='System.Windows.Forms.IEnumerator.GetNext'/>
+        /// <seealso cref='System.Windows.Forms.IEnumerator.GetObject'/>
+        /// <seealso cref='System.Windows.Forms.GridColumnsCollection.Remove'/>
+        public override IEnumerator GetEnumerator(bool allowRemove) {
+            if (!allowRemove)
+                return GetEnumerator();
+            else
+                throw new NotSupportedException(SR.DataGridColumnCollectionGetEnumerator);
+        }
+        */
+
+        /// <summary>
+        ///  Gets the index of a specified System.Windows.Forms.DataGridColumnStyle.
+        /// </summary>
+        public int IndexOf(DataGridColumnStyle element)
+        {
+            int itemCount = items.Count;
+            for (int i = 0; i < itemCount; ++i)
+            {
+                DataGridColumnStyle column = (DataGridColumnStyle)items[i];
+                if (element == column)
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        ///  Raises the System.Windows.Forms.GridColumnsCollection.CollectionChanged event.
+        /// </summary>
+        protected void OnCollectionChanged(CollectionChangeEventArgs e)
+        {
+            onCollectionChanged?.Invoke(this, e);
+
+            DataGrid grid = owner.DataGrid;
+            if (grid != null)
+            {
+                grid.checkHierarchy = true;
+            }
+        }
+
+        /// <summary>
+        ///  Removes the specified System.Windows.Forms.DataGridColumnStyle from the System.Windows.Forms.GridColumnsStyleCollection.
+        /// </summary>
+        public void Remove(DataGridColumnStyle column)
+        {
+            if (isDefault)
+            {
+                throw new ArgumentException(SR.DataGridDefaultColumnCollectionChanged);
+            }
+
+            int columnIndex = -1;
+            int itemsCount = items.Count;
+            for (int i = 0; i < itemsCount; ++i)
+            {
+                if (items[i] == column)
+                {
+                    columnIndex = i;
+                    break;
+                }
+            }
+
+            if (columnIndex == -1)
+            {
+                throw new InvalidOperationException(SR.DataGridColumnCollectionMissing);
+            }
+            else
+            {
+                RemoveAt(columnIndex);
+            }
+        }
+
+        /// <summary>
+        ///  Removes the System.Windows.Forms.DataGridColumnStyle with the specified index from the System.Windows.Forms.GridColumnsStyleCollection.
+        /// </summary>
+        public void RemoveAt(int index)
+        {
+            if (isDefault)
+            {
+                throw new ArgumentException(SR.DataGridDefaultColumnCollectionChanged);
+            }
+
+            DataGridColumnStyle toRemove = (DataGridColumnStyle)items[index];
+            toRemove.SetDataGridTableInColumn(null, true);
+            toRemove.MappingNameChanged -= new EventHandler(ColumnStyleMappingNameChanged);
+            toRemove.PropertyDescriptorChanged -= new EventHandler(ColumnStylePropDescChanged);
+#if false
+            toRemove.RemoveOnPropertyChange(owner.OnColumnChanged);
+#endif
+            items.RemoveAt(index);
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Remove, toRemove));
+        }
+
+        public void ResetPropertyDescriptors()
+        {
+            for (int i = 0; i < Count; i++)
+            {
+                this[i].PropertyDescriptor = null;
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/GridTableStylesCollection.cs b/src/System.Windows.Forms/src/System/Windows/Forms/GridTableStylesCollection.cs
new file mode 100644
index 00000000000..0a57466ed37
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/GridTableStylesCollection.cs
@@ -0,0 +1,342 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a collection of <see cref='DataGridTableStyle'/> objects in the <see cref='DataGrid'/>
+    ///  control.
+    /// </summary>
+    [ListBindable(false)]
+    public class GridTableStylesCollection : BaseCollection, IList
+    {
+        CollectionChangeEventHandler onCollectionChanged;
+        readonly ArrayList items = new ArrayList();
+        readonly DataGrid owner;
+
+        int IList.Add(object value)
+        {
+            return Add((DataGridTableStyle)value);
+        }
+
+        void IList.Clear()
+        {
+            Clear();
+        }
+
+        bool IList.Contains(object value)
+        {
+            return items.Contains(value);
+        }
+
+        int IList.IndexOf(object value)
+        {
+            return items.IndexOf(value);
+        }
+
+        void IList.Insert(int index, object value)
+        {
+            throw new NotSupportedException();
+        }
+
+        void IList.Remove(object value)
+        {
+            Remove((DataGridTableStyle)value);
+        }
+
+        void IList.RemoveAt(int index)
+        {
+            RemoveAt(index);
+        }
+
+        bool IList.IsFixedSize
+        {
+            get { return false; }
+        }
+
+        bool IList.IsReadOnly
+        {
+            get { return false; }
+        }
+
+        object IList.this[int index]
+        {
+            get { return items[index]; }
+            set { throw new NotSupportedException(); }
+        }
+
+        void ICollection.CopyTo(Array array, int index)
+        {
+            items.CopyTo(array, index);
+        }
+
+        int ICollection.Count
+        {
+            get { return items.Count; }
+        }
+
+        bool ICollection.IsSynchronized
+        {
+            get { return false; }
+        }
+
+        object ICollection.SyncRoot
+        {
+            get { return this; }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return items.GetEnumerator();
+        }
+
+        internal GridTableStylesCollection(DataGrid grid)
+        {
+            owner = grid;
+        }
+
+        protected override ArrayList List
+        {
+            get
+            {
+                return items;
+            }
+        }
+
+        /* implemented in BaseCollection
+        /// <summary>
+        ///  Retrieves the number of GridTables in the collection.
+        /// </summary>
+        /// <returns>
+        ///  The number of GridTables in the collection.
+        /// </returns>
+        public override int Count {
+            get {
+                return items.Count;
+            }
+        }
+        */
+
+        /// <summary>
+        ///  Retrieves the DataGridTable with the specified index.
+        /// </summary>
+        public DataGridTableStyle this[int index]
+        {
+            get
+            {
+                return (DataGridTableStyle)items[index];
+            }
+        }
+
+        /// <summary>
+        ///  Retrieves the DataGridTable with the name provided.
+        /// </summary>
+        public DataGridTableStyle this[string tableName]
+        {
+            get
+            {
+                if (tableName == null)
+                {
+                    throw new ArgumentNullException(nameof(tableName));
+                }
+
+                int itemCount = items.Count;
+                for (int i = 0; i < itemCount; ++i)
+                {
+                    DataGridTableStyle table = (DataGridTableStyle)items[i];
+                    // NOTE: case-insensitive
+                    if (string.Equals(table.MappingName, tableName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return table;
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        internal void CheckForMappingNameDuplicates(DataGridTableStyle table)
+        {
+            if (string.IsNullOrEmpty(table.MappingName))
+            {
+                return;
+            }
+
+            for (int i = 0; i < items.Count; i++)
+            {
+                if (((DataGridTableStyle)items[i]).MappingName.Equals(table.MappingName) && table != items[i])
+                {
+                    throw new ArgumentException(SR.DataGridTableStyleDuplicateMappingName, nameof(table));
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Adds a <see cref='DataGridTableStyle'/> to this collection.
+        /// </summary>
+        public virtual int Add(DataGridTableStyle table)
+        {
+            // set the rowHeaderWidth on the newly added table to at least the minimum value
+            // on its owner
+            if (owner != null && owner.MinimumRowHeaderWidth() > table.RowHeaderWidth)
+            {
+                table.RowHeaderWidth = owner.MinimumRowHeaderWidth();
+            }
+
+            if (table.DataGrid != owner && table.DataGrid != null)
+            {
+                throw new ArgumentException(SR.DataGridTableStyleCollectionAddedParentedTableStyle, nameof(table));
+            }
+
+            table.DataGrid = owner;
+            CheckForMappingNameDuplicates(table);
+            table.MappingNameChanged += new EventHandler(TableStyleMappingNameChanged);
+            int index = items.Add(table);
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Add, table));
+
+            return index;
+        }
+
+        private void TableStyleMappingNameChanged(object sender, EventArgs pcea)
+        {
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null));
+        }
+
+        public virtual void AddRange(DataGridTableStyle[] tables)
+        {
+            if (tables == null)
+            {
+                throw new ArgumentNullException(nameof(tables));
+            }
+
+            foreach (DataGridTableStyle table in tables)
+            {
+                table.DataGrid = owner;
+                table.MappingNameChanged += new EventHandler(TableStyleMappingNameChanged);
+                items.Add(table);
+            }
+
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null));
+        }
+
+        public event CollectionChangeEventHandler CollectionChanged
+        {
+            add => onCollectionChanged += value;
+            remove => onCollectionChanged -= value;
+        }
+
+        public void Clear()
+        {
+            for (int i = 0; i < items.Count; i++)
+            {
+                DataGridTableStyle element = (DataGridTableStyle)items[i];
+                element.MappingNameChanged -= new EventHandler(TableStyleMappingNameChanged);
+            }
+
+            items.Clear();
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null));
+        }
+
+        /// <summary>
+        ///  Checks to see if a DataGridTableStyle is contained in this collection.
+        /// </summary>
+        public bool Contains(DataGridTableStyle table)
+        {
+            int index = items.IndexOf(table);
+            return index != -1;
+        }
+
+        /// <summary>
+        ///  Checks to see if a <see cref='DataGridTableStyle'/> with the given name
+        ///  is contained in this collection.
+        /// </summary>
+        public bool Contains(string name)
+        {
+            int itemCount = items.Count;
+            for (int i = 0; i < itemCount; ++i)
+            {
+                DataGridTableStyle table = (DataGridTableStyle)items[i];
+                // NOTE: case-insensitive
+                if (string.Compare(table.MappingName, name, true, CultureInfo.InvariantCulture) == 0)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /*
+        public override IEnumerator GetEnumerator() {
+            return items.GetEnumerator();
+        }
+
+        public override IEnumerator GetEnumerator(bool allowRemove) {
+            if (!allowRemove)
+                return GetEnumerator();
+            else
+                throw new NotSupportedException(SR.DataGridTableCollectionGetEnumerator);
+        }
+        */
+
+        protected void OnCollectionChanged(CollectionChangeEventArgs e)
+        {
+            onCollectionChanged?.Invoke(this, e);
+
+            DataGrid grid = owner;
+            if (grid != null)
+            {
+                /* FOR DEMO: Microsoft: TableStylesCollection::OnCollectionChanged: set the datagridtble
+                DataView dataView = ((DataView) grid.DataSource);
+                if (dataView != null) {
+                    DataTable dataTable = dataView.Table;
+                    if (dataTable != null) {
+                        if (Contains(dataTable)) {
+                            grid.SetDataGridTable(this[dataTable]);
+                        }
+                    }
+                }
+                */
+                grid.checkHierarchy = true;
+            }
+        }
+
+        public void Remove(DataGridTableStyle table)
+        {
+            int tableIndex = -1;
+            int itemsCount = items.Count;
+            for (int i = 0; i < itemsCount; ++i)
+            {
+                if (items[i] == table)
+                {
+                    tableIndex = i;
+                    break;
+                }
+            }
+
+            if (tableIndex == -1)
+            {
+                throw new ArgumentException(SR.DataGridTableCollectionMissingTable, nameof(table));
+            }
+            else
+            {
+                RemoveAt(tableIndex);
+            }
+        }
+
+        public void RemoveAt(int index)
+        {
+            DataGridTableStyle element = (DataGridTableStyle)items[index];
+            element.MappingNameChanged -= new EventHandler(TableStyleMappingNameChanged);
+            items.RemoveAt(index);
+            OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Remove, element));
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/GridTablesFactory.cs b/src/System.Windows.Forms/src/System/Windows/Forms/GridTablesFactory.cs
new file mode 100644
index 00000000000..401f8f555f0
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/GridTablesFactory.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.System.Windows.Forms
+{
+    public static class GridTablesFactory
+    {
+        /// <summary>
+        ///  Takes a DataView and creates an intelligent mapping of DataView storage
+        ///  types into available DataColumn types.
+        /// </summary>
+        public static DataGridTableStyle[] CreateGridTables(DataGridTableStyle gridTable, object dataSource, string dataMember, BindingContext bindingManager)
+        {
+            return new DataGridTableStyle[] { gridTable };
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/IDataGridEditingService.cs b/src/System.Windows.Forms/src/System/Windows/Forms/IDataGridEditingService.cs
new file mode 100644
index 00000000000..911af12452a
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/IDataGridEditingService.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  The DataGrid exposes hooks to request editing commands via this interface.
+    /// </summary>
+    public interface IDataGridEditingService
+    {
+        bool BeginEdit(DataGridColumnStyle gridColumn, int rowNumber);
+        bool EndEdit(DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort);
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/Layout/DefaultLayout.cs b/src/System.Windows.Forms/src/System/Windows/Forms/Layout/DefaultLayout.cs
index 99966ff8f27..47003f2d521 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/Layout/DefaultLayout.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/Layout/DefaultLayout.cs
@@ -790,24 +790,12 @@ private static void UpdateAnchorInfo(IArrangedElement element)
         AnchorStyles anchor = GetAnchor(element);
         if (IsAnchored(anchor, AnchorStyles.Right))
         {
-            if (DpiHelper.IsScalingRequirementMet && (anchorInfo.Right - parentWidth > 0) && (oldAnchorInfo.Right < 0))
-            {
-                // Parent was resized to fit its parent, or screen, we need to reuse old anchors info to prevent losing control beyond right edge.
-                anchorInfo.Right = oldAnchorInfo.Right;
-                if (!IsAnchored(anchor, AnchorStyles.Left))
-                {
-                    // Control might have been resized, update Left anchors.
-                    anchorInfo.Left = oldAnchorInfo.Right - cachedBounds.Width;
-                }
-            }
-            else
-            {
-                anchorInfo.Right -= parentWidth;
+            // This differs from the official WinForms implementation because we encountered an issue with DPI handling. See WI00955507.
+            anchorInfo.Right -= parentWidth;
 
-                if (!IsAnchored(anchor, AnchorStyles.Left))
-                {
-                    anchorInfo.Left -= parentWidth;
-                }
+            if (!IsAnchored(anchor, AnchorStyles.Left))
+            {
+                anchorInfo.Left -= parentWidth;
             }
         }
         else if (!IsAnchored(anchor, AnchorStyles.Left))
@@ -818,25 +806,12 @@ private static void UpdateAnchorInfo(IArrangedElement element)
 
         if (IsAnchored(anchor, AnchorStyles.Bottom))
         {
-            if (DpiHelper.IsScalingRequirementMet && (anchorInfo.Bottom - parentHeight > 0) && (oldAnchorInfo.Bottom < 0))
-            {
-                // The parent was resized to fit its parent or the screen, we need to reuse the old anchors info to prevent positioning the control beyond the bottom edge.
-                anchorInfo.Bottom = oldAnchorInfo.Bottom;
+            // This differs from the official WinForms implementation because we encountered an issue with DPI handling. See WI00955507.
+            anchorInfo.Bottom -= parentHeight;
 
-                if (!IsAnchored(anchor, AnchorStyles.Top))
-                {
-                    // The control might have been resized, update the Top anchor.
-                    anchorInfo.Top = oldAnchorInfo.Bottom - cachedBounds.Height;
-                }
-            }
-            else
+            if (!IsAnchored(anchor, AnchorStyles.Top))
             {
-                anchorInfo.Bottom -= parentHeight;
-
-                if (!IsAnchored(anchor, AnchorStyles.Top))
-                {
-                    anchorInfo.Top -= parentHeight;
-                }
+                anchorInfo.Top -= parentHeight;
             }
         }
         else if (!IsAnchored(anchor, AnchorStyles.Top))
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ListView.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ListView.cs
index d9c790b1421..2a1c8e2adb9 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ListView.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ListView.cs
@@ -14,6 +14,7 @@
 using static System.Windows.Forms.ListViewGroup;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/MainMenu.cs b/src/System.Windows.Forms/src/System/Windows/Forms/MainMenu.cs
new file mode 100644
index 00000000000..84443373549
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/MainMenu.cs
@@ -0,0 +1,355 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using System.Drawing;
+using static System.Windows.Forms.ToolStrip;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a menu structure for a form.
+    /// </summary>
+    [ToolboxItemFilter("System.Windows.Forms.MainMenu")]
+    public class MainMenu : Menu
+    {
+        internal Form? _form;
+        internal Form ownerForm;  // this is the form that created this menu, and is the only form allowed to dispose it.
+        private RightToLeft _rightToLeft = RightToLeft.Inherit;
+        private EventHandler _onCollapse;
+
+
+#if DEBUG
+        internal static readonly TraceSwitch s_selectionDebug = new("SelectionDebug", "Debug ToolStrip Selection code");
+        internal static readonly TraceSwitch s_dropTargetDebug = new("DropTargetDebug", "Debug ToolStrip Drop code");
+        internal static readonly TraceSwitch s_layoutDebugSwitch = new("Layout debug", "Debug ToolStrip layout code");
+        internal static readonly TraceSwitch s_mouseActivateDebug = new("ToolStripMouseActivate", "Debug ToolStrip WM_MOUSEACTIVATE code");
+        internal static readonly TraceSwitch s_mergeDebug = new("ToolStripMergeDebug", "Debug toolstrip merging");
+        internal static readonly TraceSwitch s_snapFocusDebug = new("SnapFocus", "Debug snapping/restoration of focus");
+        internal static readonly TraceSwitch s_flickerDebug = new("FlickerDebug", "Debug excessive calls to Invalidate()");
+        internal static readonly TraceSwitch s_itemReorderDebug = new("ItemReorderDebug", "Debug excessive calls to Invalidate()");
+        internal static readonly TraceSwitch s_mdiMergeDebug = new("MDIMergeDebug", "Debug toolstrip MDI merging");
+        internal static readonly TraceSwitch s_menuAutoExpandDebug = new("MenuAutoExpand", "Debug menu auto expand");
+        internal static readonly TraceSwitch s_controlTabDebug = new("ControlTab", "Debug ToolStrip Control+Tab selection");
+#else
+    internal static readonly TraceSwitch? s_selectionDebug;
+    internal static readonly TraceSwitch? s_dropTargetDebug;
+    internal static readonly TraceSwitch? s_layoutDebugSwitch;
+    internal static readonly TraceSwitch? s_mouseActivateDebug;
+    internal static readonly TraceSwitch? s_mergeDebug;
+    internal static readonly TraceSwitch? s_snapFocusDebug;
+    internal static readonly TraceSwitch? s_flickerDebug;
+    internal static readonly TraceSwitch? s_itemReorderDebug;
+    internal static readonly TraceSwitch? s_mdiMergeDebug;
+    internal static readonly TraceSwitch? s_menuAutoExpandDebug;
+    internal static readonly TraceSwitch? s_controlTabDebug;
+#endif
+
+        private Point _mouseEnterWhenShown = s_invalidMouseEnter;
+        internal static Point s_invalidMouseEnter = new(int.MaxValue, int.MaxValue);
+        private HWND _hwndThatLostFocus;
+
+        /// <summary> handy check for painting and sizing </summary>
+        [Browsable(false)]
+        public bool IsDropDown
+        {
+            get { return (this is ToolStripDropDown); }
+        }
+
+        // remembers the current mouse location so we can determine
+        // later if we need to shift selection.
+        internal void SnapMouseLocation()
+        {
+            _mouseEnterWhenShown = WindowsFormsUtils.LastCursorPoint;
+        }
+
+        /// <summary> SnapFocus
+        ///  When get focus to the toolstrip (and we're not participating in the tab order)
+        ///  it's probably cause someone hit the ALT key. We need to remember who that was
+        ///  so when we're done here we can RestoreFocus back to it.
+        ///
+        ///  We're called from WM_SETFOCUS, and otherHwnd is the HWND losing focus.
+        ///
+        ///  Required checks
+        ///  - make sure it's not a dropdown
+        ///  - make sure it's not a child control of this control.
+        ///  - make sure the control is on this window
+        /// </summary>
+        private void SnapFocus(HWND otherHwnd)
+        {
+#if DEBUG
+            Debug.WriteLineIf(s_snapFocusDebug.TraceVerbose, $"{!Environment.StackTrace.Contains("FocusInternal")}", "who is setting focus to us?");
+#endif
+            // we need to know who sent us focus so we know who to send it back to later.
+
+            if (!TabStop && !IsDropDown)
+            {
+                bool snapFocus = false;
+                if (Focused && (otherHwnd != Handle))
+                {
+                    // the case here is a label before a combo box calling FocusInternal in ProcessMnemonic.
+                    // we'll filter out children later.
+                    snapFocus = true;
+                }
+                else if (!ContainsFocus && !Focused)
+                {
+                    snapFocus = true;
+                }
+
+                if (snapFocus)
+                {
+                    // remember the current mouse position so that we can check later if it actually moved
+                    // otherwise we'd unexpectedly change selection to whatever the cursor was over at this moment.
+                    SnapMouseLocation();
+
+                    // make sure the otherHandle is not a child of thisHandle
+                    if ((Handle != otherHwnd) && !PInvoke.IsChild(this, otherHwnd))
+                    {
+                        // make sure the root window of the otherHwnd is the same as
+                        // the root window of thisHwnd.
+                        HWND thisHwndRoot = PInvoke.GetAncestor(this, GET_ANCESTOR_FLAGS.GA_ROOT);
+                        HWND otherHwndRoot = PInvoke.GetAncestor(otherHwnd, GET_ANCESTOR_FLAGS.GA_ROOT);
+
+                        if (thisHwndRoot == otherHwndRoot && !thisHwndRoot.IsNull)
+                        {
+                            s_snapFocusDebug.TraceVerbose(
+                                $"[ToolStrip SnapFocus]: Caching for return focus:{WindowsFormsUtils.GetControlInformation(otherHwnd)}");
+
+                            // We know we're in the same window heirarchy.
+                            _hwndThatLostFocus = otherHwnd;
+                        }
+                    }
+                }
+            }
+        }
+
+        private ToolStripItem? _lastMouseActiveItem;
+        private ToolStripItem? _lastMouseDownedItem;
+
+        internal bool IsInDesignMode
+        {
+            get
+            {
+                return DesignMode;
+            }
+        }
+
+        protected override void WndProc(ref Message m)
+        {
+            if (m.MsgInternal == PInvoke.WM_SETFOCUS)
+            {
+                SnapFocus((HWND)(nint)m.WParamInternal);
+            }
+
+            if (m.MsgInternal == PInvoke.WM_MOUSEACTIVATE)
+            {
+                // We want to prevent taking focus if someone clicks on the toolstrip dropdown itself. The mouse message
+                // will still go through, but focus won't be taken. If someone clicks on a child control (combobox,
+                // textbox, etc) focus will be taken - but we'll handle that in WM_NCACTIVATE handler.
+                Point pt = PointToClient(WindowsFormsUtils.LastCursorPoint);
+                HWND hwndClicked = PInvoke.ChildWindowFromPointEx(
+                    this,
+                    pt,
+                    CWP_FLAGS.CWP_SKIPINVISIBLE | CWP_FLAGS.CWP_SKIPDISABLED | CWP_FLAGS.CWP_SKIPTRANSPARENT);
+
+                // If we click on the toolstrip itself, eat the activation.
+                // If we click on a child control, allow the toolstrip to activate.
+                if (hwndClicked == HWND)
+                {
+                    _lastMouseDownedItem = null;
+                    m.ResultInternal = (LRESULT)(nint)PInvoke.MA_NOACTIVATE;
+
+                    if (!IsDropDown && !IsInDesignMode)
+                    {
+                        // If our root HWND is not the active hwnd,eat the mouse message and bring the form to the front.
+                        HWND rootHwnd = PInvoke.GetAncestor(this, GET_ANCESTOR_FLAGS.GA_ROOT);
+                        if (!rootHwnd.IsNull)
+                        {
+                            // snap the active window and compare to our root window.
+                            HWND hwndActive = PInvoke.GetActiveWindow();
+                            if (hwndActive != rootHwnd)
+                            {
+                                // Activate the window, and discard the mouse message.
+                                // this appears to be the same behavior as office.
+                                m.ResultInternal = (LRESULT)(nint)PInvoke.MA_ACTIVATEANDEAT;
+                            }
+                        }
+                    }
+
+                    return;
+                }
+                else
+                {
+                    // We're setting focus to a child control - remember who gave it to us so we can restore it on ESC.
+                    SnapFocus(PInvoke.GetFocus());
+                    if (!IsDropDown && !TabStop)
+                    {
+                        s_snapFocusDebug.TraceVerbose("Installing restoreFocusFilter");
+                        // PERF
+                        //Application.ThreadContext.FromCurrent().AddMessageFilter(RestoreFocusFilter);
+                    }
+                }
+            }
+
+            base.WndProc(ref m);
+
+            if (m.Msg == (int)PInvoke.WM_NCDESTROY)
+            {
+                // Destroy the owner window, if we created one.  We
+                // cannot do this in OnHandleDestroyed, because at
+                // that point our handle is not actually destroyed so
+                // destroying our parent actually causes a recursive
+                // WM_DESTROY.
+                _dropDownOwnerWindow?.DestroyHandle();
+            }
+        }
+
+        private NativeWindow? _dropDownOwnerWindow;
+
+        private RestoreFocusMessageFilter? _restoreFocusFilter;
+
+        internal RestoreFocusMessageFilter RestoreFocusFilter
+        {
+            get
+            {
+                //_restoreFocusFilter ??= new RestoreFocusMessageFilter(this);
+
+                return _restoreFocusFilter;
+            }
+        }
+
+        /// <summary>
+        ///  Creates a new MainMenu control.
+        /// </summary>
+        public MainMenu() : base(null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='MainMenu'/> class with the specified container.
+        /// </summary>
+        public MainMenu(IContainer container) : this()
+        {
+            if (container == null)
+            {
+                throw new ArgumentNullException(nameof(container));
+            }
+
+            container.Add(this);
+        }
+
+        /// <summary>
+        ///  Creates a new MainMenu control with the given items to start with.
+        /// </summary>
+        public MainMenu(MenuItem[] items) : base(items)
+        {
+        }
+
+        [SRDescription(nameof(SR.MainMenuCollapseDescr))]
+        public event EventHandler Collapse
+        {
+            add => _onCollapse += value;
+            remove => _onCollapse -= value;
+        }
+
+        /// <summary>
+        ///  This is used for international applications where the language is written from RightToLeft.
+        ///  When this property is true, text alignment and reading order will be from right to left.
+        /// </summary>
+        [Localizable(true)]
+        [AmbientValue(RightToLeft.Inherit)]
+        [SRDescription(nameof(SR.MenuRightToLeftDescr))]
+        public virtual RightToLeft RightToLeft
+        {
+            get
+            {
+                if (_rightToLeft == RightToLeft.Inherit)
+                {
+                    if (_form != null)
+                    {
+                        return _form.RightToLeft;
+                    }
+
+                    return RightToLeft.Inherit;
+                }
+
+                return _rightToLeft;
+            }
+            set
+            {
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)RightToLeft.No, (int)RightToLeft.Inherit))
+                {
+                    throw new InvalidEnumArgumentException(nameof(RightToLeft), (int)value, typeof(RightToLeft));
+                }
+
+                if (_rightToLeft != value)
+                {
+                    _rightToLeft = value;
+                    UpdateRtl((value == RightToLeft.Yes));
+                }
+            }
+        }
+
+        internal override bool RenderIsRightToLeft => (RightToLeft == RightToLeft.Yes && (_form == null || !_form.IsMirrored));
+
+        /// <summary>
+        ///  Creates a new MainMenu object which is a dupliate of this one.
+        /// </summary>
+        public virtual MainMenu CloneMenu()
+        {
+            var newMenu = new MainMenu();
+            newMenu.CloneMenu(this);
+            return newMenu;
+        }
+
+        protected override IntPtr CreateMenuHandle() => User32.CreateMenu();
+
+        /// <summary>
+        ///  Clears out this MainMenu object and discards all of it's resources.
+        ///  If the menu is parented in a form, it is disconnected from that as
+        ///  well.
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_form != null && (ownerForm == null || _form == ownerForm))
+                {
+                    _form.Menu = null;
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Indicates which form in which we are currently residing [if any]
+        /// </summary>
+        public Form GetForm() => _form;
+
+        internal override void ItemsChanged(int change)
+        {
+            base.ItemsChanged(change);
+            _form?.MenuChanged(change, this);
+        }
+
+        internal virtual void ItemsChanged(int change, Menu menu) => _form?.MenuChanged(change, menu);
+
+        /// <summary>
+        ///  Fires the collapse event
+        /// </summary>
+        protected internal virtual void OnCollapse(EventArgs e) => _onCollapse?.Invoke(this, e);
+
+        /// <summary>
+        ///  Returns true if the RightToLeft should be persisted in code gen.
+        /// </summary>
+        internal virtual bool ShouldSerializeRightToLeft() => _rightToLeft == RightToLeft.Inherit;
+
+        /// <summary>
+        ///  Returns a string representation for this control.
+        /// </summary>
+        public override string ToString() => base.ToString();
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/Menu.cs b/src/System.Windows.Forms/src/System/Windows/Forms/Menu.cs
new file mode 100644
index 00000000000..951128c5e60
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/Menu.cs
@@ -0,0 +1,1262 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.ComponentModel;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  This is the base class for all menu components (MainMenu, MenuItem, and ContextMenu).
+    /// </summary>
+    [ToolboxItemFilter("System.Windows.Forms")]
+    [ListBindable(false)]
+    public abstract class Menu : ScrollableControl
+    {
+        internal const int CHANGE_ITEMS = 0; // item(s) added or removed
+        internal const int CHANGE_VISIBLE = 1; // item(s) hidden or shown
+        internal const int CHANGE_MDI = 2; // mdi item changed
+        internal const int CHANGE_MERGE = 3; // mergeType or mergeOrder changed
+        internal const int CHANGE_ITEMADDED = 4; // mergeType or mergeOrder changed
+
+        /// <summary>
+        ///  Used by findMenuItem
+        /// </summary>
+        public const int FindHandle = 0;
+        /// <summary>
+        ///  Used by findMenuItem
+        /// </summary>
+        public const int FindShortcut = 1;
+
+        private MenuItemCollection itemsCollection;
+        internal MenuItem[] items;
+        private int _itemCount;
+        internal IntPtr handle;
+        internal bool created;
+        private object userData;
+        private string name;
+
+        /// <summary>
+        ///  This is an abstract class.  Instances cannot be created, so the constructor
+        ///  is only called from derived classes.
+        /// </summary>
+        protected Menu(MenuItem[] items)
+        {
+            if (items != null)
+            {
+                MenuItems.AddRange(items);
+            }
+        }
+
+        /// <summary>
+        ///  The HMENU handle corresponding to this menu.
+        /// </summary>
+        [
+        Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.ControlHandleDescr))
+        ]
+        public IntPtr Handle
+        {
+            get
+            {
+                if (handle == IntPtr.Zero)
+                {
+                    handle = CreateMenuHandle();
+                }
+
+                CreateMenuItems();
+                return handle;
+            }
+        }
+
+        /// <summary>
+        ///  Specifies whether this menu contains any items.
+        /// </summary>
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.MenuIsParentDescr))
+        ]
+        public virtual bool IsParent
+        {
+            get
+            {
+                return null != items && ItemCount > 0;
+            }
+        }
+
+        internal int ItemCount
+        {
+            get
+            {
+                return _itemCount;
+            }
+        }
+
+        /// <summary>
+        ///  The MenuItem that contains the list of MDI child windows.
+        /// </summary>
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.MenuMDIListItemDescr))
+        ]
+        public MenuItem MdiListItem
+        {
+            get
+            {
+                for (int i = 0; i < ItemCount; i++)
+                {
+                    MenuItem item = items[i];
+                    if (item.MdiList)
+                    {
+                        return item;
+                    }
+
+                    if (item.IsParent)
+                    {
+                        item = item.MdiListItem;
+                        if (item != null)
+                        {
+                            return item;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        ///  Name of this control. The designer will set this to the same
+        ///  as the programatic Id "(name)" of the control - however this
+        ///  property has no bearing on the runtime aspects of this control.
+        /// </summary>
+        [
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        Browsable(false)
+        ]
+        public string Name
+        {
+            get
+            {
+                return WindowsFormsUtils.GetComponentName(this, name);
+            }
+            set
+            {
+                if (value == null || value.Length == 0)
+                {
+                    name = null;
+                }
+                else
+                {
+                    name = value;
+                }
+
+                if (Site != null)
+                {
+                    Site.Name = name;
+                }
+            }
+        }
+
+        [
+        Browsable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
+        SRDescription(nameof(SR.MenuMenuItemsDescr)),
+        MergableProperty(false)
+        ]
+        public MenuItemCollection MenuItems
+        {
+            get
+            {
+                if (itemsCollection == null)
+                {
+                    itemsCollection = new MenuItemCollection(this);
+                }
+
+                return itemsCollection;
+            }
+        }
+
+        internal virtual bool RenderIsRightToLeft
+        {
+            get
+            {
+                Debug.Assert(true, "Should never get called");
+                return false;
+
+            }
+        }
+
+        [
+        SRCategory(nameof(SR.CatData)),
+        Localizable(false),
+        Bindable(true),
+        SRDescription(nameof(SR.ControlTagDescr)),
+        DefaultValue(null),
+        TypeConverter(typeof(StringConverter)),
+        ]
+        public object Tag
+        {
+            get
+            {
+                return userData;
+            }
+            set
+            {
+                userData = value;
+            }
+        }
+
+        /// <summary>
+        ///  Notifies Menu that someone called Windows.DeleteMenu on its handle.
+        /// </summary>
+        internal void ClearHandles()
+        {
+            if (handle != IntPtr.Zero)
+            {
+                User32.DestroyMenu(new HandleRef(this, handle));
+            }
+
+            handle = IntPtr.Zero;
+            if (created)
+            {
+                for (int i = 0; i < ItemCount; i++)
+                {
+                    items[i].ClearHandles();
+                }
+
+                created = false;
+            }
+        }
+
+        /// <summary>
+        ///  Sets this menu to be an identical copy of another menu.
+        /// </summary>
+        protected internal void CloneMenu(Menu menuSrc)
+        {
+            if (menuSrc == null)
+            {
+                throw new ArgumentNullException(nameof(menuSrc));
+            }
+
+            MenuItem[] newItems = null;
+            if (menuSrc.items != null)
+            {
+                int count = menuSrc.MenuItems.Count;
+                newItems = new MenuItem[count];
+                for (int i = 0; i < count; i++)
+                {
+                    newItems[i] = menuSrc.MenuItems[i].CloneMenu();
+                }
+            }
+
+            MenuItems.Clear();
+            if (newItems != null)
+            {
+                MenuItems.AddRange(newItems);
+            }
+        }
+
+        protected virtual IntPtr CreateMenuHandle() => User32.CreatePopupMenu();
+
+        internal void CreateMenuItems()
+        {
+            if (!created)
+            {
+                for (int i = 0; i < ItemCount; i++)
+                {
+                    items[i].CreateMenuItem();
+                }
+
+                created = true;
+            }
+        }
+
+        internal void DestroyMenuItems()
+        {
+            if (created)
+            {
+                for (int i = 0; i < ItemCount; i++)
+                {
+                    items[i].ClearHandles();
+                }
+
+                while (User32.GetMenuItemCount(new HandleRef(this, handle)) > 0)
+                {
+                    User32.RemoveMenu(new HandleRef(this, handle), 0, User32.MF.BYPOSITION);
+                }
+
+                created = false;
+            }
+        }
+
+        /// <summary>
+        ///  Disposes of the component.  Call dispose when the component is no longer needed.
+        ///  This method removes the component from its container (if the component has a site)
+        ///  and triggers the dispose event.
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                while (ItemCount > 0)
+                {
+                    MenuItem item = items[--_itemCount];
+
+                    // remove the item before we dispose it so it still has valid state
+                    // for undo/redo
+                    //
+                    if (item.Site != null && item.Site.Container != null)
+                    {
+                        item.Site.Container.Remove(item);
+                    }
+
+                    item.Parent = null;
+                    item.Dispose();
+                }
+
+                items = null;
+            }
+
+            if (handle != IntPtr.Zero)
+            {
+                User32.DestroyMenu(new HandleRef(this, handle));
+                handle = IntPtr.Zero;
+                if (disposing)
+                {
+                    ClearHandles();
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        public MenuItem FindMenuItem(int type, IntPtr value)
+        {
+            for (int i = 0; i < ItemCount; i++)
+            {
+                MenuItem item = items[i];
+                switch (type)
+                {
+                    case FindHandle:
+                        if (item.handle == value)
+                        {
+                            return item;
+                        }
+
+                        break;
+                    case FindShortcut:
+                        if (item.Shortcut == (Shortcut)(int)value)
+                        {
+                            return item;
+                        }
+
+                        break;
+                }
+
+                item = item.FindMenuItem(type, value);
+                if (item != null)
+                {
+                    return item;
+                }
+            }
+
+            return null;
+        }
+
+        protected int FindMergePosition(int mergeOrder)
+        {
+            int iMin, iLim, iT;
+
+            for (iMin = 0, iLim = ItemCount; iMin < iLim;)
+            {
+                iT = (iMin + iLim) / 2;
+                if (items[iT].MergeOrder <= mergeOrder)
+                {
+                    iMin = iT + 1;
+                }
+                else
+                {
+                    iLim = iT;
+                }
+            }
+
+            return iMin;
+        }
+
+        // A new method for finding the approximate merge position. The original
+        // method assumed (incorrectly) that the MergeOrder of the target menu would be sequential
+        // as it's guaranteed to be in the MDI imlementation of merging container and child
+        // menus. However, user code can call MergeMenu independently on a source and target
+        // menu whose MergeOrder values are not necessarily pre-sorted.
+        internal int xFindMergePosition(int mergeOrder)
+        {
+            int nPosition = 0;
+
+            // Iterate from beginning to end since we can't assume any sequential ordering to MergeOrder
+            for (int nLoop = 0; nLoop < ItemCount; nLoop++)
+            {
+
+                if (items[nLoop].MergeOrder > mergeOrder)
+                {
+                    // We didn't find what we're looking for, but we've found a stopping point.
+                    break;
+                }
+                else if (items[nLoop].MergeOrder < mergeOrder)
+                {
+                    // We might have found what we're looking for, but we'll have to come around again
+                    // to know.
+                    nPosition = nLoop + 1;
+                }
+                else if (mergeOrder == items[nLoop].MergeOrder)
+                {
+                    // We've found what we're looking for, so use this value for the merge order
+                    nPosition = nLoop;
+                    break;
+                }
+            }
+
+            return nPosition;
+        }
+
+        //There's a win32 problem that doesn't allow menus to cascade right to left
+        //unless we explicitely set the bit on the menu the first time it pops up
+        internal void UpdateRtl(bool setRightToLeftBit)
+        {
+            foreach (MenuItem item in MenuItems)
+            {
+                item.UpdateItemRtl(setRightToLeftBit);
+                item.UpdateRtl(setRightToLeftBit);
+            }
+        }
+
+        /// <summary>
+        ///  Returns the ContextMenu that contains this menu.  The ContextMenu
+        ///  is at the top of this menu's parent chain.
+        ///  Returns null if this menu is not contained in a ContextMenu.
+        ///  This can occur if it's contained in a MainMenu or if it isn't
+        ///  currently contained in any menu at all.
+        /// </summary>
+        public ContextMenu GetContextMenu()
+        {
+            Menu menuT;
+            for (menuT = this; !(menuT is ContextMenu);)
+            {
+                if (!(menuT is MenuItem))
+                {
+                    return null;
+                }
+
+                menuT = ((MenuItem)menuT).Parent;
+            }
+
+            return (ContextMenu)menuT;
+
+        }
+
+        /// <summary>
+        ///  Returns the MainMenu item that contains this menu.  The MainMenu
+        ///  is at the top of this menu's parent chain.
+        ///  Returns null if this menu is not contained in a MainMenu.
+        ///  This can occur if it's contained in a ContextMenu or if it isn't
+        ///  currently contained in any menu at all.
+        /// </summary>
+        public MainMenu GetMainMenu()
+        {
+            Menu menuT;
+            for (menuT = this; !(menuT is MainMenu);)
+            {
+                if (!(menuT is MenuItem))
+                {
+                    return null;
+                }
+
+                menuT = ((MenuItem)menuT).Parent;
+            }
+
+            return (MainMenu)menuT;
+        }
+
+        internal virtual void ItemsChanged(int change)
+        {
+            switch (change)
+            {
+                case CHANGE_ITEMS:
+                case CHANGE_VISIBLE:
+                    DestroyMenuItems();
+                    break;
+            }
+        }
+
+        /// <summary>
+        ///  Walks the menu item collection, using a caller-supplied delegate to find one
+        ///  with a matching access key. Walk starts at specified item index and performs one
+        ///  full pass of the entire collection, looping back to the top if necessary.
+        ///
+        ///  Return value is intended for return from WM_MENUCHAR message. It includes both
+        ///  index of matching item, and action for OS to take (execute or select). Zero is
+        ///  used to indicate that no match was found (OS should ignore key and beep).
+        /// </summary>
+        private IntPtr MatchKeyToMenuItem(int startItem, char key, MenuItemKeyComparer comparer)
+        {
+            int firstMatch = -1;
+            bool multipleMatches = false;
+
+            for (int i = 0; i < items.Length && !multipleMatches; ++i)
+            {
+                int itemIndex = (startItem + i) % items.Length;
+                MenuItem mi = items[itemIndex];
+                if (mi != null && comparer(mi, key))
+                {
+                    if (firstMatch < 0)
+                    {
+                        // Using Index doesnt respect hidden items.
+                        firstMatch = mi.MenuIndex;
+                    }
+                    else
+                    {
+                        multipleMatches = true;
+                    }
+                }
+            }
+
+            if (firstMatch < 0)
+            {
+                return IntPtr.Zero;
+            }
+
+            int action = multipleMatches ? NativeMethods.MNC_SELECT : NativeMethods.MNC_EXECUTE;
+            return (IntPtr)NativeMethods.Util.MAKELONG(firstMatch, action);
+        }
+
+        ///  Delegate type used by MatchKeyToMenuItem
+        private delegate bool MenuItemKeyComparer(MenuItem mi, char key);
+
+        /// <summary>
+        ///  Merges another menu's items with this one's.  Menu items are merged according to their
+        ///  mergeType and mergeOrder properties.  This function is typically used to
+        ///  merge an MDI container's menu with that of its active MDI child.
+        /// </summary>
+        public virtual void MergeMenu(Menu menuSrc)
+        {
+            if (menuSrc == null)
+            {
+                throw new ArgumentNullException(nameof(menuSrc));
+            }
+
+            if (menuSrc == this)
+            {
+                throw new ArgumentException(SR.MenuMergeWithSelf, nameof(menuSrc));
+            }
+
+            int i, j;
+            MenuItem item;
+            MenuItem itemDst;
+
+            if (menuSrc.items != null && items == null)
+            {
+                MenuItems.Clear();
+            }
+
+            for (i = 0; i < menuSrc.ItemCount; i++)
+            {
+                item = menuSrc.items[i];
+
+                switch (item.MergeType)
+                {
+                    default:
+                        continue;
+                    case MenuMerge.Add:
+                        MenuItems.Add(FindMergePosition(item.MergeOrder), item.MergeMenu());
+                        continue;
+                    case MenuMerge.Replace:
+                    case MenuMerge.MergeItems:
+                        break;
+                }
+
+                int mergeOrder = item.MergeOrder;
+                // Can we find a menu item with a matching merge order?
+                // Use new method to find the approximate merge position. The original
+                // method assumed (incorrectly) that the MergeOrder of the target menu would be sequential
+                // as it's guaranteed to be in the MDI imlementation of merging container and child
+                // menus. However, user code can call MergeMenu independently on a source and target
+                // menu whose MergeOrder values are not necessarily pre-sorted.
+                for (j = xFindMergePosition(mergeOrder); ; j++)
+                {
+
+                    if (j >= ItemCount)
+                    {
+                        // A matching merge position could not be found,
+                        // so simply append this menu item to the end.
+                        MenuItems.Add(j, item.MergeMenu());
+                        break;
+                    }
+
+                    itemDst = items[j];
+                    if (itemDst.MergeOrder != mergeOrder)
+                    {
+                        MenuItems.Add(j, item.MergeMenu());
+                        break;
+                    }
+
+                    if (itemDst.MergeType != MenuMerge.Add)
+                    {
+                        if (item.MergeType != MenuMerge.MergeItems
+                            || itemDst.MergeType != MenuMerge.MergeItems)
+                        {
+                            itemDst.Dispose();
+                            MenuItems.Add(j, item.MergeMenu());
+                        }
+                        else
+                        {
+                            itemDst.MergeMenu(item);
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        internal virtual bool ProcessInitMenuPopup(IntPtr handle)
+        {
+            MenuItem item = FindMenuItem(FindHandle, handle);
+            if (item != null)
+            {
+                item.OnInitMenuPopup(EventArgs.Empty);
+                item.CreateMenuItems();
+                return true;
+            }
+
+            return false;
+        }
+
+        protected internal virtual bool ProcessCmdKey(ref Message msg, Keys keyData)
+        {
+            MenuItem item = FindMenuItem(FindShortcut, (IntPtr)(int)keyData);
+            return item != null ? item.ShortcutClick() : false;
+        }
+
+        /// <summary>
+        ///  Returns index of currently selected menu item in
+        ///  this menu, or -1 if no item is currently selected.
+        /// </summary>
+        internal int SelectedMenuItemIndex
+        {
+            get
+            {
+                for (int i = 0; i < items.Length; ++i)
+                {
+                    MenuItem mi = items[i];
+                    if (mi != null && mi.Selected)
+                    {
+                        return i;
+                    }
+                }
+
+                return -1;
+            }
+        }
+
+        /// <summary>
+        ///  Returns a string representation for this control.
+        /// </summary>
+        public override string ToString()
+        {
+            string s = base.ToString();
+            return s + ", Items.Count: " + ItemCount.ToString(CultureInfo.CurrentCulture);
+        }
+
+        /// <summary>
+        ///  Handles the WM_MENUCHAR message, forwarding it to the intended Menu
+        ///  object. All the real work is done inside WmMenuCharInternal().
+        /// </summary>
+        internal void WmMenuChar(ref Message m)
+        {
+            Menu menu = (m.LParam == handle) ? this : FindMenuItem(FindHandle, m.LParam);
+
+            if (menu == null)
+            {
+                return;
+            }
+
+            char menuKey = char.ToUpper((char)NativeMethods.Util.LOWORD(m.WParam), CultureInfo.CurrentCulture);
+
+            m.Result = menu.WmMenuCharInternal(menuKey);
+        }
+
+        /// <summary>
+        ///  Handles WM_MENUCHAR to provide access key support for owner-draw menu items (which
+        ///  means *all* menu items on a menu when IsImageMarginPresent == true). Attempts to
+        ///  simulate the exact behavior that the OS provides for non owner-draw menu items.
+        /// </summary>
+        internal IntPtr WmMenuCharInternal(char key)
+        {
+            // Start looking just beyond the current selected item (otherwise just start at the top)
+            int startItem = (SelectedMenuItemIndex + 1) % items.Length;
+
+            // First, search for match among owner-draw items with explicitly defined access keys (eg. "S&ave")
+            IntPtr result = MatchKeyToMenuItem(startItem, key, new MenuItemKeyComparer(CheckOwnerDrawItemWithMnemonic));
+
+            // Next, search for match among owner-draw items with no access keys (looking at first char of item text)
+            if (result == IntPtr.Zero)
+            {
+                result = MatchKeyToMenuItem(startItem, key, new MenuItemKeyComparer(CheckOwnerDrawItemNoMnemonic));
+            }
+
+            return result;
+        }
+
+        ///  MenuItemKeyComparer delegate used by WmMenuCharInternal
+        private bool CheckOwnerDrawItemWithMnemonic(MenuItem mi, char key)
+        {
+            return mi.OwnerDraw &&
+                   mi.Mnemonic == key;
+        }
+
+        ///  MenuItemKeyComparer delegate used by WmMenuCharInternal
+        private bool CheckOwnerDrawItemNoMnemonic(MenuItem mi, char key)
+        {
+            return mi.OwnerDraw &&
+                   mi.Mnemonic == 0 &&
+                   mi.Text.Length > 0 &&
+                   char.ToUpper(mi.Text[0], CultureInfo.CurrentCulture) == key;
+        }
+
+        [ListBindable(false)]
+        public class MenuItemCollection : IList
+        {
+            private readonly Menu owner;
+
+            ///  A caching mechanism for key accessor
+            ///  We use an index here rather than control so that we don't have lifetime
+            ///  issues by holding on to extra references.
+            private int lastAccessedIndex = -1;
+
+            public MenuItemCollection(Menu owner)
+            {
+                this.owner = owner;
+            }
+
+            public virtual MenuItem this[int index]
+            {
+                get
+                {
+                    if (index < 0 || index >= owner.ItemCount)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                    }
+
+                    return owner.items[index];
+                }
+
+                // set not supported
+            }
+
+            object IList.this[int index]
+            {
+                get
+                {
+                    return this[index];
+                }
+                set
+                {
+                    throw new NotSupportedException();
+                }
+            }
+
+            /// <summary>
+            ///  Retrieves the child control with the specified key.
+            /// </summary>
+            public virtual MenuItem this[string key]
+            {
+                get
+                {
+                    // We do not support null and empty string as valid keys.
+                    if (string.IsNullOrEmpty(key))
+                    {
+                        return null;
+                    }
+
+                    // Search for the key in our collection
+                    int index = IndexOfKey(key);
+                    if (IsValidIndex(index))
+                    {
+                        return this[index];
+                    }
+                    else
+                    {
+                        return null;
+                    }
+
+                }
+            }
+
+            public int Count
+            {
+                get
+                {
+                    return owner.ItemCount;
+                }
+            }
+
+            object ICollection.SyncRoot
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            bool ICollection.IsSynchronized
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            bool IList.IsFixedSize
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            public bool IsReadOnly
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Adds a new MenuItem to the end of this menu with the specified caption.
+            /// </summary>
+            public virtual MenuItem Add(string caption)
+            {
+                MenuItem item = new MenuItem(caption);
+                Add(item);
+                return item;
+            }
+
+            /// <summary>
+            ///  Adds a new MenuItem to the end of this menu with the specified caption,
+            ///  and click handler.
+            /// </summary>
+            public virtual MenuItem Add(string caption, EventHandler onClick)
+            {
+                MenuItem item = new MenuItem(caption, onClick);
+                Add(item);
+                return item;
+            }
+
+            /// <summary>
+            ///  Adds a new MenuItem to the end of this menu with the specified caption,
+            ///  click handler, and items.
+            /// </summary>
+            public virtual MenuItem Add(string caption, MenuItem[] items)
+            {
+                MenuItem item = new MenuItem(caption, items);
+                Add(item);
+                return item;
+            }
+
+            /// <summary>
+            ///  Adds a MenuItem to the end of this menu
+            ///  MenuItems can only be contained in one menu at a time, and may not be added
+            ///  more than once to the same menu.
+            /// </summary>
+            public virtual int Add(MenuItem item)
+            {
+                return Add(owner.ItemCount, item);
+            }
+
+            /// <summary>
+            ///  Adds a MenuItem to this menu at the specified index.  The item currently at
+            ///  that index, and all items after it, will be moved up one slot.
+            ///  MenuItems can only be contained in one menu at a time, and may not be added
+            ///  more than once to the same menu.
+            /// </summary>
+            public virtual int Add(int index, MenuItem item)
+            {
+                if (item == null)
+                {
+                    throw new ArgumentNullException(nameof(item));
+                }
+
+                // MenuItems can only belong to one menu at a time
+                if (item.Parent != null)
+                {
+
+                    // First check that we're not adding ourself, i.e. walk
+                    // the parent chain for equality
+                    if (owner is MenuItem parent)
+                    {
+                        while (parent != null)
+                        {
+                            if (parent.Equals(item))
+                            {
+                                throw new ArgumentException(string.Format(SR.MenuItemAlreadyExists, item.Text), "item");
+                            }
+
+                            if (parent.Parent is MenuItem)
+                            {
+                                parent = (MenuItem)parent.Parent;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+
+                    //if we're re-adding an item back to the same collection
+                    //the target index needs to be decremented since we're
+                    //removing an item from the collection
+                    if (item.Parent.Equals(owner) && index > 0)
+                    {
+                        index--;
+                    }
+
+                    item.Parent.MenuItems.Remove(item);
+                }
+
+                // Validate our index
+                if (index < 0 || index > owner.ItemCount)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                }
+
+                if (owner.items == null || owner.items.Length == owner.ItemCount)
+                {
+                    MenuItem[] newItems = new MenuItem[owner.ItemCount < 2 ? 4 : owner.ItemCount * 2];
+                    if (owner.ItemCount > 0)
+                    {
+                        System.Array.Copy(owner.items, 0, newItems, 0, owner.ItemCount);
+                    }
+
+                    owner.items = newItems;
+                }
+
+                System.Array.Copy(owner.items, index, owner.items, index + 1, owner.ItemCount - index);
+                owner.items[index] = item;
+                owner._itemCount++;
+                item.Parent = owner;
+                owner.ItemsChanged(CHANGE_ITEMS);
+                if (owner is MenuItem)
+                {
+                    ((MenuItem)owner).ItemsChanged(CHANGE_ITEMADDED, item);
+                }
+
+                return index;
+            }
+
+            public virtual void AddRange(MenuItem[] items)
+            {
+                if (items == null)
+                {
+                    throw new ArgumentNullException(nameof(items));
+                }
+
+                foreach (MenuItem item in items)
+                {
+                    Add(item);
+                }
+            }
+
+            int IList.Add(object value)
+            {
+                if (value is MenuItem)
+                {
+                    return Add((MenuItem)value);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.MenuBadMenuItem, "value");
+                }
+            }
+
+            public bool Contains(MenuItem value)
+            {
+                return IndexOf(value) != -1;
+            }
+
+            bool IList.Contains(object value)
+            {
+                if (value is MenuItem)
+                {
+                    return Contains((MenuItem)value);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Returns true if the collection contains an item with the specified key, false otherwise.
+            /// </summary>
+            public virtual bool ContainsKey(string key)
+            {
+                return IsValidIndex(IndexOfKey(key));
+            }
+
+            /// <summary>
+            ///  Searches for Controls by their Name property, builds up an array
+            ///  of all the controls that match.
+            /// </summary>
+            public MenuItem[] Find(string key, bool searchAllChildren)
+            {
+
+                if ((key == null) || (key.Length == 0))
+                {
+                    throw new ArgumentNullException(nameof(key), SR.FindKeyMayNotBeEmptyOrNull);
+                }
+
+                ArrayList foundMenuItems = FindInternal(key, searchAllChildren, this, new ArrayList());
+
+                // Make this a stongly typed collection.
+                MenuItem[] stronglyTypedfoundMenuItems = new MenuItem[foundMenuItems.Count];
+                foundMenuItems.CopyTo(stronglyTypedfoundMenuItems, 0);
+
+                return stronglyTypedfoundMenuItems;
+            }
+
+            /// <summary>
+            ///  Searches for Controls by their Name property, builds up an array list
+            ///  of all the controls that match.
+            /// </summary>
+            private ArrayList FindInternal(string key, bool searchAllChildren, MenuItemCollection menuItemsToLookIn, ArrayList foundMenuItems)
+            {
+                if ((menuItemsToLookIn == null) || (foundMenuItems == null))
+                {
+                    return null;  //
+                }
+
+                // Perform breadth first search - as it's likely people will want controls belonging
+                // to the same parent close to each other.
+
+                for (int i = 0; i < menuItemsToLookIn.Count; i++)
+                {
+                    if (menuItemsToLookIn[i] == null)
+                    {
+                        continue;
+                    }
+
+                    if (WindowsFormsUtils.SafeCompareStrings(menuItemsToLookIn[i].Name, key, /* ignoreCase = */ true))
+                    {
+                        foundMenuItems.Add(menuItemsToLookIn[i]);
+                    }
+                }
+
+                // Optional recurive search for controls in child collections.
+
+                if (searchAllChildren)
+                {
+                    for (int i = 0; i < menuItemsToLookIn.Count; i++)
+                    {
+                        if (menuItemsToLookIn[i] == null)
+                        {
+                            continue;
+                        }
+
+                        if ((menuItemsToLookIn[i].MenuItems != null) && menuItemsToLookIn[i].MenuItems.Count > 0)
+                        {
+                            // if it has a valid child collecion, append those results to our collection
+                            foundMenuItems = FindInternal(key, searchAllChildren, menuItemsToLookIn[i].MenuItems, foundMenuItems);
+                        }
+                    }
+                }
+
+                return foundMenuItems;
+            }
+
+            public int IndexOf(MenuItem value)
+            {
+                for (int index = 0; index < Count; ++index)
+                {
+                    if (this[index] == value)
+                    {
+                        return index;
+                    }
+                }
+
+                return -1;
+            }
+
+            int IList.IndexOf(object value)
+            {
+                if (value is MenuItem)
+                {
+                    return IndexOf((MenuItem)value);
+                }
+                else
+                {
+                    return -1;
+                }
+            }
+
+            /// <summary>
+            ///  The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
+            /// </summary>
+            public virtual int IndexOfKey(string key)
+            {
+                // Step 0 - Arg validation
+                if (string.IsNullOrEmpty(key))
+                {
+                    return -1; // we dont support empty or null keys.
+                }
+
+                // step 1 - check the last cached item
+                if (IsValidIndex(lastAccessedIndex))
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[lastAccessedIndex].Name, key, /* ignoreCase = */ true))
+                    {
+                        return lastAccessedIndex;
+                    }
+                }
+
+                // step 2 - search for the item
+                for (int i = 0; i < Count; i++)
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true))
+                    {
+                        lastAccessedIndex = i;
+                        return i;
+                    }
+                }
+
+                // step 3 - we didn't find it.  Invalidate the last accessed index and return -1.
+                lastAccessedIndex = -1;
+                return -1;
+            }
+
+            void IList.Insert(int index, object value)
+            {
+                if (value is MenuItem)
+                {
+                    Add(index, (MenuItem)value);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.MenuBadMenuItem, "value");
+                }
+            }
+
+            /// <summary>
+            ///  Determines if the index is valid for the collection.
+            /// </summary>
+            private bool IsValidIndex(int index)
+            {
+                return ((index >= 0) && (index < Count));
+            }
+
+            /// <summary>
+            ///  Removes all existing MenuItems from this menu
+            /// </summary>
+            public virtual void Clear()
+            {
+                if (owner.ItemCount > 0)
+                {
+
+                    for (int i = 0; i < owner.ItemCount; i++)
+                    {
+                        owner.items[i].Parent = null;
+                    }
+
+                    owner._itemCount = 0;
+                    owner.items = null;
+
+                    owner.ItemsChanged(CHANGE_ITEMS);
+
+                    if (owner is MenuItem)
+                    {
+                        ((MenuItem)(owner)).UpdateMenuItem(true);
+                    }
+                }
+            }
+
+            public void CopyTo(Array dest, int index)
+            {
+                if (owner.ItemCount > 0)
+                {
+                    System.Array.Copy(owner.items, 0, dest, index, owner.ItemCount);
+                }
+            }
+
+            public IEnumerator GetEnumerator()
+            {
+                return new WindowsFormsUtils.ArraySubsetEnumerator(owner.items, owner.ItemCount);
+            }
+
+            /// <summary>
+            ///  Removes the item at the specified index in this menu.  All subsequent
+            ///  items are moved up one slot.
+            /// </summary>
+            public virtual void RemoveAt(int index)
+            {
+                if (index < 0 || index >= owner.ItemCount)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                }
+
+                MenuItem item = owner.items[index];
+                item.Parent = null;
+                owner._itemCount--;
+                System.Array.Copy(owner.items, index + 1, owner.items, index, owner.ItemCount - index);
+                owner.items[owner.ItemCount] = null;
+                owner.ItemsChanged(CHANGE_ITEMS);
+
+                //if the last item was removed, clear the collection
+                //
+                if (owner.ItemCount == 0)
+                {
+                    Clear();
+                }
+
+            }
+
+            /// <summary>
+            ///  Removes the menu iteml with the specified key.
+            /// </summary>
+            public virtual void RemoveByKey(string key)
+            {
+                int index = IndexOfKey(key);
+                if (IsValidIndex(index))
+                {
+                    RemoveAt(index);
+                }
+            }
+
+            /// <summary>
+            ///  Removes the specified item from this menu.  All subsequent
+            ///  items are moved down one slot.
+            /// </summary>
+            public virtual void Remove(MenuItem item)
+            {
+                if (item.Parent == owner)
+                {
+                    RemoveAt(item.Index);
+                }
+            }
+
+            void IList.Remove(object value)
+            {
+                if (value is MenuItem)
+                {
+                    Remove((MenuItem)value);
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/MenuItem.cs b/src/System.Windows.Forms/src/System/Windows/Forms/MenuItem.cs
new file mode 100644
index 00000000000..e68b979a307
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/MenuItem.cs
@@ -0,0 +1,1802 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents an individual item that is displayed within a <see cref='Menu'/>
+    ///  or <see cref='Menu'/>.
+    /// </summary>
+    [ToolboxItem(false)]
+    [DesignTimeVisible(false)]
+    [DefaultEvent(nameof(Click))]
+    [DefaultProperty(nameof(Text))]
+    public class MenuItem : Menu
+    {
+        private const int StateBarBreak = 0x00000020;
+        private const int StateBreak = 0x00000040;
+        private const int StateChecked = 0x00000008;
+        private const int StateDefault = 0x00001000;
+        private const int StateDisabled = 0x00000003;
+        private const int StateRadioCheck = 0x00000200;
+        private const int StateHidden = 0x00010000;
+        private const int StateMdiList = 0x00020000;
+        private const int StateCloneMask = 0x0003136B;
+        private const int StateOwnerDraw = 0x00000100;
+        private const int StateInMdiPopup = 0x00000200;
+        private const int StateHiLite = 0x00000080;
+
+        private bool _hasHandle;
+        private MenuItemData _data;
+        private int _dataVersion;
+        private MenuItem _nextLinkedItem; // Next item linked to the same MenuItemData.
+
+        // We need to store a table of all created menuitems, so that other objects
+        // such as ContainerControl can get a reference to a particular menuitem,
+        // given a unique ID.
+        private static readonly Hashtable s_allCreatedMenuItems = new Hashtable();
+        private const uint FirstUniqueID = 0xC0000000;
+        private static long s_nextUniqueID = FirstUniqueID;
+        private uint _uniqueID = 0;
+        private IntPtr _msaaMenuInfoPtr = IntPtr.Zero;
+        private bool _menuItemIsCreated = false;
+
+#if DEBUG
+        private string _debugText;
+        private readonly int _creationNumber;
+        private static int CreateCount;
+#endif
+
+        /// <summary>
+        ///  Initializes a <see cref='MenuItem'/> with a blank caption.
+        /// </summary>
+        public MenuItem() : this(MenuMerge.Add, 0, 0, null, null, null, null, null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='MenuItem'/> class
+        ///  with a specified caption for the menu item.
+        /// </summary>
+        public MenuItem(string text) : this(MenuMerge.Add, 0, 0, text, null, null, null, null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the class with a specified caption and event handler
+        ///  for the menu item.
+        /// </summary>
+        public MenuItem(string text, EventHandler onClick) : this(MenuMerge.Add, 0, 0, text, onClick, null, null, null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the class with a specified caption, event handler,
+        ///  and associated shorcut key for the menu item.
+        /// </summary>
+        public MenuItem(string text, EventHandler onClick, Shortcut shortcut) : this(MenuMerge.Add, 0, shortcut, text, onClick, null, null, null)
+        {
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the class with a specified caption and an array of
+        ///  submenu items defined for the menu item.
+        /// </summary>
+        public MenuItem(string text, MenuItem[] items) : this(MenuMerge.Add, 0, 0, text, null, null, null, items)
+        {
+        }
+
+        internal MenuItem(MenuItemData data) : base(null)
+        {
+            data.AddItem(this);
+
+#if DEBUG
+            _debugText = data._caption;
+#endif
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the class with a specified caption, defined
+        ///  event-handlers for the Click, Select and Popup events, a shortcut key,
+        ///  a merge type, and order specified for the menu item.
+        /// </summary>
+        public MenuItem(MenuMerge mergeType, int mergeOrder, Shortcut shortcut,
+                        string text, EventHandler onClick, EventHandler onPopup,
+                        EventHandler onSelect, MenuItem[] items) : base(items)
+        {
+            new MenuItemData(this, mergeType, mergeOrder, shortcut, true,
+                             text, onClick, onPopup, onSelect, null, null);
+
+#if DEBUG
+            _debugText = text;
+            _creationNumber = CreateCount++;
+#endif
+        }
+
+        internal unsafe void WmDrawItem(ref Message m)
+        {
+            // Handles the OnDrawItem message sent from ContainerControl
+            User32.DRAWITEMSTRUCT* dis = (User32.DRAWITEMSTRUCT*)m.LParam;
+            Debug.WriteLineIf(Control.s_paletteTracing.TraceVerbose, Handle + ": Force set palette in MenuItem drawitem");
+            IntPtr oldPal = Control.SetUpPalette(dis->hDC, force: false, realizePalette: false);
+            try
+            {
+                Graphics g = Graphics.FromHdcInternal(dis->hDC);
+                OnDrawItem(new DrawItemEventArgs(g, SystemInformation.MenuFont, dis->rcItem, Index, (DrawItemState)dis->itemState));
+            }
+            finally
+            {
+                if (oldPal != IntPtr.Zero)
+                {
+                    Gdi32.SelectPalette(dis->hDC, oldPal, BOOL.FALSE);
+                }
+            }
+
+            m.Result = (IntPtr)1;
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the item is placed on a new line (for a
+        ///  menu item added to a <see cref='MainMenu'/> object) or in a
+        ///  new column (for a submenu or menu displayed in a <see cref='ContextMenu'/>).
+        /// </summary>
+        [Browsable(false)]
+        [DefaultValue(false)]
+        public bool BarBreak
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateBarBreak) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetState(StateBarBreak, value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the item is placed on a new line (for a
+        ///  menu item added to a <see cref='MainMenu'/> object) or in a
+        ///  new column (for a submenu or menu displayed in a <see cref='ContextMenu'/>).
+        /// </summary>
+        [Browsable(false)]
+        [DefaultValue(false)]
+        public bool Break
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateBreak) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetState(StateBreak, value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether a checkmark appears beside the text of
+        ///  the menu item.
+        /// </summary>
+        [DefaultValue(false)]
+        [SRDescription(nameof(SR.MenuItemCheckedDescr))]
+        public bool Checked
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateChecked) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+
+                if (value && (ItemCount != 0 || Parent is MainMenu))
+                {
+                    throw new ArgumentException(SR.MenuItemInvalidCheckProperty, nameof(value));
+                }
+
+                _data.SetState(StateChecked, value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the menu item is the default.
+        /// </summary>
+        [DefaultValue(false)]
+        [SRDescription(nameof(SR.MenuItemDefaultDescr))]
+        public bool DefaultItem
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateDefault) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                if (Parent != null)
+                {
+                    if (value)
+                    {
+                        User32.SetMenuDefaultItem(new HandleRef(Parent, Parent.handle), MenuID, BOOL.FALSE);
+                    }
+                    else if (DefaultItem)
+                    {
+                        User32.SetMenuDefaultItem(new HandleRef(Parent, Parent.handle), -1, BOOL.FALSE);
+                    }
+                }
+
+                _data.SetState(StateDefault, value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether code that you provide draws the menu
+        ///  item or Windows draws the menu item.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior))]
+        [DefaultValue(false)]
+        [SRDescription(nameof(SR.MenuItemOwnerDrawDescr))]
+        public bool OwnerDraw
+        {
+            get
+            {
+                CheckIfDisposed();
+                return ((_data.State & StateOwnerDraw) != 0);
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetState(StateOwnerDraw, value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the menu item is enabled.
+        /// </summary>
+        [Localizable(true)]
+        [DefaultValue(true)]
+        [SRDescription(nameof(SR.MenuItemEnabledDescr))]
+        public bool Enabled
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateDisabled) == 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetState(StateDisabled, !value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the menu item's position in its parent menu.
+        /// </summary>
+        [Browsable(false)]
+        public int Index
+        {
+            get
+            {
+                if (Parent != null)
+                {
+                    for (int i = 0; i < Parent.ItemCount; i++)
+                    {
+                        if (Parent.items[i] == this)
+                        {
+                            return i;
+                        }
+                    }
+                }
+
+                return -1;
+            }
+            set
+            {
+                int oldIndex = Index;
+                if (oldIndex >= 0)
+                {
+                    if (value < 0 || value >= Parent.ItemCount)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(value), string.Format(SR.InvalidArgument, nameof(Index), value));
+                    }
+
+                    if (value != oldIndex)
+                    {
+                        // The menu reverts to null when we're removed, so hold onto it in a
+                        // local variable
+                        Menu parent = Parent;
+                        parent.MenuItems.RemoveAt(oldIndex);
+                        parent.MenuItems.Add(value, this);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets a value indicating whether the menu item contains child menu items.
+        /// </summary>
+        [Browsable(false)]
+        public override bool IsParent
+        {
+            get
+            {
+                if (_data != null && MdiList)
+                {
+                    for (int i = 0; i < ItemCount; i++)
+                    {
+                        if (!(items[i]._data.UserData is MdiListUserData))
+                        {
+                            return true;
+                        }
+                    }
+
+                    if (FindMdiForms().Length > 0)
+                    {
+                        return true;
+                    }
+
+                    if (Parent != null && !(Parent is MenuItem))
+                    {
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                return base.IsParent;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the menu item will be populated with a
+        ///  list of the MDI child windows that are displayed within the associated form.
+        /// </summary>
+        [DefaultValue(false)]
+        [SRDescription(nameof(SR.MenuItemMDIListDescr))]
+        public bool MdiList
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateMdiList) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.MdiList = value;
+                CleanListItems(this);
+            }
+        }
+
+        /// <summary>
+        ///  Gets the Windows identifier for this menu item.
+        /// </summary>
+        protected int MenuID
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data.GetMenuID();
+            }
+        }
+
+        /// <summary>
+        ///  Is this menu item currently selected (highlighted) by the user?
+        /// </summary>
+        internal bool Selected
+        {
+            get
+            {
+                if (Parent == null)
+                {
+                    return false;
+                }
+
+                var info = new NativeMethods.MENUITEMINFO_T
+                {
+                    cbSize = Marshal.SizeOf<NativeMethods.MENUITEMINFO_T>(),
+                    fMask = NativeMethods.MIIM_STATE
+                };
+                UnsafeNativeMethods.GetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, info);
+
+                return (info.fState & StateHiLite) != 0;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the zero-based index of this menu item in the parent menu, or -1 if this
+        ///  menu item is not associated with a parent menu.
+        /// </summary>
+        internal int MenuIndex
+        {
+            get
+            {
+                if (Parent == null)
+                {
+                    return -1;
+                }
+
+                int count = User32.GetMenuItemCount(new HandleRef(Parent, Parent.Handle));
+                int id = MenuID;
+                NativeMethods.MENUITEMINFO_T info = new NativeMethods.MENUITEMINFO_T
+                {
+                    cbSize = Marshal.SizeOf<NativeMethods.MENUITEMINFO_T>(),
+                    fMask = NativeMethods.MIIM_ID | NativeMethods.MIIM_SUBMENU
+                };
+
+                for (int i = 0; i < count; i++)
+                {
+                    UnsafeNativeMethods.GetMenuItemInfo(new HandleRef(Parent, Parent.handle), i, true, info);
+
+                    // For sub menus, the handle is always valid.
+                    // For items, however, it is always zero.
+                    if ((info.hSubMenu == IntPtr.Zero || info.hSubMenu == Handle) && info.wID == id)
+                    {
+                        return i;
+                    }
+                }
+
+                return -1;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates the behavior of this
+        ///  menu item when its menu is merged with another.
+        /// </summary>
+        [DefaultValue(MenuMerge.Add)]
+        [SRDescription(nameof(SR.MenuItemMergeTypeDescr))]
+        public MenuMerge MergeType
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data._mergeType;
+            }
+            set
+            {
+                CheckIfDisposed();
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)MenuMerge.Add, (int)MenuMerge.Remove))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(MenuMerge));
+                }
+
+                _data.MergeType = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the relative position the menu item when its
+        ///  menu is merged with another.
+        /// </summary>
+        [DefaultValue(0)]
+        [SRDescription(nameof(SR.MenuItemMergeOrderDescr))]
+        public int MergeOrder
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data._mergeOrder;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.MergeOrder = value;
+            }
+        }
+
+        /// <summary>
+        ///  Retrieves the hotkey mnemonic that is associated with this menu item.
+        ///  The mnemonic is the first character after an ampersand symbol in the menu's text
+        ///  that is not itself an ampersand symbol. If no such mnemonic is defined this
+        ///  will return zero.
+        /// </summary>
+        [Browsable(false)]
+        public char Mnemonic
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data.Mnemonic;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the menu in which this menu item appears.
+        /// </summary>
+        [Browsable(false)]
+        public Menu Parent { get; internal set; }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates whether the menu item, if checked,
+        ///  displays a radio-button mark instead of a check mark.
+        /// </summary>
+        [DefaultValue(false)]
+        [SRDescription(nameof(SR.MenuItemRadioCheckDescr))]
+        public bool RadioCheck
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateRadioCheck) != 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetState(StateRadioCheck, value);
+            }
+        }
+
+        internal override bool RenderIsRightToLeft => Parent != null && Parent.RenderIsRightToLeft;
+
+        /// <summary>
+        ///  Gets or sets the text of the menu item.
+        /// </summary>
+        [Localizable(true)]
+        [SRDescription(nameof(SR.MenuItemTextDescr))]
+        public string Text
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data._caption;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.SetCaption(value);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the shortcut key associated with the menu item.
+        /// </summary>
+        [Localizable(true)]
+        [DefaultValue(Shortcut.None)]
+        [SRDescription(nameof(SR.MenuItemShortCutDescr))]
+        public Shortcut Shortcut
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data._shortcut;
+            }
+            set
+            {
+                CheckIfDisposed();
+                if (!Enum.IsDefined(typeof(Shortcut), value))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(Shortcut));
+                }
+
+                _data._shortcut = value;
+                UpdateMenuItem(force: true);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates whether the shortcut key that is associated
+        ///  with the menu item is displayed next to the menu item caption.
+        /// </summary>
+        [DefaultValue(true),
+        Localizable(true)]
+        [SRDescription(nameof(SR.MenuItemShowShortCutDescr))]
+        public bool ShowShortcut
+        {
+            get
+            {
+                CheckIfDisposed();
+                return _data._showShortcut;
+            }
+            set
+            {
+                CheckIfDisposed();
+                if (value != _data._showShortcut)
+                {
+                    _data._showShortcut = value;
+                    UpdateMenuItem(force: true);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value that indicates whether the menu item is visible on its
+        ///  parent menu.
+        /// </summary>
+        [Localizable(true)]
+        [DefaultValue(true)]
+        [SRDescription(nameof(SR.MenuItemVisibleDescr))]
+        public bool Visible
+        {
+            get
+            {
+                CheckIfDisposed();
+                return (_data.State & StateHidden) == 0;
+            }
+            set
+            {
+                CheckIfDisposed();
+                _data.Visible = value;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when the menu item is clicked or selected using a shortcut key defined
+        ///  for the menu item.
+        /// </summary>
+        [SRDescription(nameof(SR.MenuItemOnClickDescr))]
+        public event EventHandler Click
+        {
+            add
+            {
+                CheckIfDisposed();
+                _data._onClick += value;
+            }
+            remove
+            {
+                CheckIfDisposed();
+                _data._onClick -= value;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when when the property of a menu item is set to <see langword='true'/> and
+        ///  a request is made to draw the menu item.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior)), SRDescription(nameof(SR.drawItemEventDescr))]
+        public event DrawItemEventHandler DrawItem
+        {
+            add
+            {
+                CheckIfDisposed();
+                _data._onDrawItem += value;
+            }
+            remove
+            {
+                CheckIfDisposed();
+                _data._onDrawItem -= value;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when when the menu needs to know the size of a menu item before drawing it.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior)), SRDescription(nameof(SR.measureItemEventDescr))]
+        public event MeasureItemEventHandler MeasureItem
+        {
+            add
+            {
+                CheckIfDisposed();
+                _data._onMeasureItem += value;
+            }
+            remove
+            {
+                CheckIfDisposed();
+                _data._onMeasureItem -= value;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs before a menu item's list of menu items is displayed.
+        /// </summary>
+        [SRDescription(nameof(SR.MenuItemOnInitDescr))]
+        public event EventHandler Popup
+        {
+            add
+            {
+                CheckIfDisposed();
+                _data._onPopup += value;
+            }
+            remove
+            {
+                CheckIfDisposed();
+                _data._onPopup -= value;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when the user hovers their mouse over a menu item or selects it with the
+        ///  keyboard but has not activated it.
+        /// </summary>
+        [SRDescription(nameof(SR.MenuItemOnSelectDescr))]
+        public event EventHandler Select
+        {
+            add
+            {
+                CheckIfDisposed();
+                _data._onSelect += value;
+            }
+            remove
+            {
+                CheckIfDisposed();
+                _data._onSelect -= value;
+            }
+        }
+
+        private static void CleanListItems(MenuItem senderMenu)
+        {
+            // Remove dynamic items.
+            for (int i = senderMenu.MenuItems.Count - 1; i >= 0; i--)
+            {
+                MenuItem item = senderMenu.MenuItems[i];
+                if (item._data.UserData is MdiListUserData)
+                {
+                    item.Dispose();
+                    continue;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Creates and returns an identical copy of this menu item.
+        /// </summary>
+        public virtual MenuItem CloneMenu()
+        {
+            var newItem = new MenuItem();
+            newItem.CloneMenu(this);
+            return newItem;
+        }
+
+        /// <summary>
+        ///  Creates a copy of the specified menu item.
+        /// </summary>
+        protected void CloneMenu(MenuItem itemSrc)
+        {
+            base.CloneMenu(itemSrc);
+            int state = itemSrc._data.State;
+            new MenuItemData(this,
+                             itemSrc.MergeType, itemSrc.MergeOrder, itemSrc.Shortcut, itemSrc.ShowShortcut,
+                             itemSrc.Text, itemSrc._data._onClick, itemSrc._data._onPopup, itemSrc._data._onSelect,
+                             itemSrc._data._onDrawItem, itemSrc._data._onMeasureItem);
+            _data.SetState(state & StateCloneMask, true);
+        }
+
+        internal virtual void CreateMenuItem()
+        {
+            if ((_data.State & StateHidden) == 0)
+            {
+                NativeMethods.MENUITEMINFO_T info = CreateMenuItemInfo();
+                UnsafeNativeMethods.InsertMenuItem(new HandleRef(Parent, Parent.handle), -1, true, info);
+
+                _hasHandle = info.hSubMenu != IntPtr.Zero;
+                _dataVersion = _data._version;
+
+                _menuItemIsCreated = true;
+                if (RenderIsRightToLeft)
+                {
+                    Parent.UpdateRtl(true);
+                }
+
+#if DEBUG
+                NativeMethods.MENUITEMINFO_T infoVerify = new NativeMethods.MENUITEMINFO_T
+                {
+                    cbSize = Marshal.SizeOf<NativeMethods.MENUITEMINFO_T>(),
+                    fMask = NativeMethods.MIIM_ID | NativeMethods.MIIM_STATE |
+                                   NativeMethods.MIIM_SUBMENU | NativeMethods.MIIM_TYPE
+                };
+                UnsafeNativeMethods.GetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, infoVerify);
+#endif
+            }
+        }
+
+        private NativeMethods.MENUITEMINFO_T CreateMenuItemInfo()
+        {
+            var info = new NativeMethods.MENUITEMINFO_T
+            {
+                fMask = NativeMethods.MIIM_ID | NativeMethods.MIIM_STATE |
+                         NativeMethods.MIIM_SUBMENU | NativeMethods.MIIM_TYPE | NativeMethods.MIIM_DATA,
+                fType = _data.State & (StateBarBreak | StateBreak | StateRadioCheck | StateOwnerDraw)
+            };
+
+            // Top level menu items shouldn't have barbreak or break bits set on them.
+            bool isTopLevel = Parent == GetMainMenu();
+
+            if (_data._caption.Equals("-"))
+            {
+                if (isTopLevel)
+                {
+                    _data._caption = " ";
+                    info.fType |= NativeMethods.MFT_MENUBREAK;
+                }
+                else
+                {
+                    info.fType |= NativeMethods.MFT_SEPARATOR;
+                }
+            }
+
+            info.fState = _data.State & (StateChecked | StateDefault | StateDisabled);
+
+            info.wID = MenuID;
+            if (IsParent)
+            {
+                info.hSubMenu = Handle;
+            }
+
+            info.hbmpChecked = IntPtr.Zero;
+            info.hbmpUnchecked = IntPtr.Zero;
+
+            // Assign a unique ID to this menu item object.
+            // The ID is stored in the dwItemData of the corresponding Win32 menu item, so
+            // that when we get Win32 messages about the item later, we can delegate to the
+            // original object menu item object. A static hash table is used to map IDs to
+            // menu item objects.
+            if (_uniqueID == 0)
+            {
+                lock (s_allCreatedMenuItems)
+                {
+                    _uniqueID = (uint)Interlocked.Increment(ref s_nextUniqueID);
+                    Debug.Assert(_uniqueID >= FirstUniqueID); // ...check for ID range exhaustion (unlikely!)
+                    // We add a weak ref wrapping a MenuItem to the static hash table, as
+                    // supposed to adding the item ref itself, to allow the item to be finalized
+                    // in case it is not disposed and no longer referenced anywhere else, hence
+                    // preventing leaks.
+                    s_allCreatedMenuItems.Add(_uniqueID, new WeakReference(this));
+                }
+            }
+
+            if (IntPtr.Size == 4)
+            {
+                // Store the unique ID in the dwItemData..
+                // For simple menu items, we can just put the unique ID in the dwItemData.
+                // But for owner-draw items, we need to point the dwItemData at an MSAAMENUINFO
+                // structure so that MSAA can get the item text.
+                // To allow us to reliably distinguish between IDs and structure pointers later
+                // on, we keep IDs in the 0xC0000000-0xFFFFFFFF range. This is the top 1Gb of
+                // unmananged process memory, where an app's heap allocations should never come
+                // from. So that we can still get the ID from the dwItemData for an owner-draw
+                // item later on, a copy of the ID is tacked onto the end of the MSAAMENUINFO
+                // structure.
+                if (_data.OwnerDraw)
+                {
+                    info.dwItemData = AllocMsaaMenuInfo();
+                }
+                else
+                {
+                    info.dwItemData = (IntPtr)unchecked((int)_uniqueID);
+                }
+            }
+            else
+            {
+                // On Win64, there are no reserved address ranges we can use for menu item IDs. So instead we will
+                // have to allocate an MSAMENUINFO heap structure for all menu items, not just owner-drawn ones.
+                info.dwItemData = AllocMsaaMenuInfo();
+            }
+
+            // We won't render the shortcut if: 1) it's not set, 2) we're a parent, 3) we're toplevel
+            if (_data._showShortcut && _data._shortcut != 0 && !IsParent && !isTopLevel)
+            {
+                info.dwTypeData = _data._caption + "\t" + TypeDescriptor.GetConverter(typeof(Keys)).ConvertToString((Keys)(int)_data._shortcut);
+            }
+            else
+            {
+                // Windows issue: Items with empty captions sometimes block keyboard
+                // access to other items in same menu.
+                info.dwTypeData = (_data._caption.Length == 0 ? " " : _data._caption);
+            }
+
+            info.cch = 0;
+
+            return info;
+        }
+
+        /// <summary>
+        ///  Disposes the <see cref='MenuItem'/>.
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Parent?.MenuItems.Remove(this);
+                _data?.RemoveItem(this);
+                lock (s_allCreatedMenuItems)
+                {
+                    s_allCreatedMenuItems.Remove(_uniqueID);
+                }
+
+                _uniqueID = 0;
+
+            }
+
+            FreeMsaaMenuInfo();
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Given a unique menu item ID, find the corresponding MenuItem
+        ///  object, using the master lookup table of all created MenuItems.
+        /// </summary>
+        internal static MenuItem GetMenuItemFromUniqueID(uint uniqueID)
+        {
+            WeakReference weakRef = (WeakReference)s_allCreatedMenuItems[uniqueID];
+            if (weakRef != null && weakRef.IsAlive)
+            {
+                return (MenuItem)weakRef.Target;
+            }
+
+            Debug.Fail("Weakref for menu item has expired or has been removed!  Who is trying to access this ID?");
+            return null;
+        }
+
+        /// <summary>
+        ///  Given the "item data" value of a Win32 menu item, find the corresponding MenuItem object (using
+        ///  the master lookup table of all created MenuItems). The item data may be either the unique menu
+        ///  item ID, or a pointer to an MSAAMENUINFO structure with a copy of the unique ID tacked to the end.
+        ///  To reliably tell IDs and structure addresses apart, IDs live in the 0xC0000000-0xFFFFFFFF range.
+        ///  This is the top 1Gb of unmananged process memory, where an app's heap allocations should never be.
+        /// </summary>
+        internal static MenuItem GetMenuItemFromItemData(IntPtr itemData)
+        {
+            uint uniqueID = (uint)(ulong)itemData;
+            if (uniqueID == 0)
+            {
+                return null;
+            }
+
+            if (IntPtr.Size == 4)
+            {
+                if (uniqueID < FirstUniqueID)
+                {
+                    MsaaMenuInfoWithId msaaMenuInfo = Marshal.PtrToStructure<MsaaMenuInfoWithId>(itemData);
+                    uniqueID = msaaMenuInfo._uniqueID;
+                }
+            }
+            else
+            {
+                // Its always a pointer on Win64 (see CreateMenuItemInfo)
+                MsaaMenuInfoWithId msaaMenuInfo = Marshal.PtrToStructure<MsaaMenuInfoWithId>(itemData);
+                uniqueID = msaaMenuInfo._uniqueID;
+            }
+
+            return GetMenuItemFromUniqueID(uniqueID);
+        }
+
+        /// <summary>
+        ///  MsaaMenuInfoWithId is an MSAAMENUINFO structure with a menu item ID field tacked onto the
+        ///  end. This allows us to pass the data we need to Win32 / MSAA, and still be able to get the ID
+        ///  out again later on, so we can delegate Win32 menu messages back to the correct MenuItem object.
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        private struct MsaaMenuInfoWithId
+        {
+            public readonly NativeMethods.MSAAMENUINFO _msaaMenuInfo;
+            public readonly uint _uniqueID;
+
+            public MsaaMenuInfoWithId(string text, uint uniqueID)
+            {
+                _msaaMenuInfo = new NativeMethods.MSAAMENUINFO(text);
+                _uniqueID = uniqueID;
+            }
+        }
+
+        /// <summary>
+        ///  Creates an MSAAMENUINFO structure (in the unmanaged heap) based on the current state
+        ///  of this MenuItem object. Address of this structure is cached in the object so we can
+        ///  free it later on using FreeMsaaMenuInfo(). If structure has already been allocated,
+        ///  it is destroyed and a new one created.
+        /// </summary>
+        private IntPtr AllocMsaaMenuInfo()
+        {
+            FreeMsaaMenuInfo();
+            _msaaMenuInfoPtr = Marshal.AllocHGlobal(Marshal.SizeOf<MsaaMenuInfoWithId>());
+
+            if (IntPtr.Size == 4)
+            {
+                // We only check this on Win32, irrelevant on Win64 (see CreateMenuItemInfo)
+                // Check for incursion into menu item ID range (unlikely!)
+                Debug.Assert(((uint)(ulong)_msaaMenuInfoPtr) < FirstUniqueID);
+            }
+
+            MsaaMenuInfoWithId msaaMenuInfoStruct = new MsaaMenuInfoWithId(_data._caption, _uniqueID);
+            Marshal.StructureToPtr(msaaMenuInfoStruct, _msaaMenuInfoPtr, false);
+            Debug.Assert(_msaaMenuInfoPtr != IntPtr.Zero);
+            return _msaaMenuInfoPtr;
+        }
+
+        /// <summary>
+        ///  Frees the MSAAMENUINFO structure (in the unmanaged heap) for the current MenuObject
+        ///  object, if one has previously been allocated. Takes care to free sub-structures too,
+        ///  to avoid leaks!
+        /// </summary>
+        private void FreeMsaaMenuInfo()
+        {
+            if (_msaaMenuInfoPtr != IntPtr.Zero)
+            {
+                Marshal.DestroyStructure(_msaaMenuInfoPtr, typeof(MsaaMenuInfoWithId));
+                Marshal.FreeHGlobal(_msaaMenuInfoPtr);
+                _msaaMenuInfoPtr = IntPtr.Zero;
+            }
+        }
+
+        internal override void ItemsChanged(int change)
+        {
+            base.ItemsChanged(change);
+
+            if (change == CHANGE_ITEMS)
+            {
+                // when the menu collection changes deal with it locally
+                Debug.Assert(!created, "base.ItemsChanged should have wiped out our handles");
+                if (Parent != null && Parent.created)
+                {
+                    UpdateMenuItem(force: true);
+                    CreateMenuItems();
+                }
+            }
+            else
+            {
+                if (!_hasHandle && IsParent)
+                {
+                    UpdateMenuItem(force: true);
+                }
+
+                MainMenu main = GetMainMenu();
+                if (main != null && ((_data.State & StateInMdiPopup) == 0))
+                {
+                    main.ItemsChanged(change, this);
+                }
+            }
+        }
+
+        internal void ItemsChanged(int change, MenuItem item)
+        {
+            if (change == CHANGE_ITEMADDED &&
+                _data != null &&
+                _data.baseItem != null &&
+                _data.baseItem.MenuItems.Contains(item))
+            {
+                if (Parent != null && Parent.created)
+                {
+                    UpdateMenuItem(force: true);
+                    CreateMenuItems();
+                }
+                else if (_data != null)
+                {
+                    MenuItem currentMenuItem = _data.firstItem;
+                    while (currentMenuItem != null)
+                    {
+                        if (currentMenuItem.created)
+                        {
+                            MenuItem newItem = item.CloneMenu();
+                            item._data.AddItem(newItem);
+                            currentMenuItem.MenuItems.Add(newItem);
+                            break;
+                        }
+
+                        currentMenuItem = currentMenuItem._nextLinkedItem;
+                    }
+                }
+            }
+        }
+
+        internal Form[] FindMdiForms()
+        {
+            Form[] forms = null;
+            MainMenu main = GetMainMenu();
+            Form menuForm = null;
+            if (main != null)
+            {
+                menuForm = main.GetForm();
+            }
+
+            if (menuForm != null)
+            {
+                forms = menuForm.MdiChildren;
+            }
+
+            if (forms == null)
+            {
+                forms = Array.Empty<Form>();
+            }
+
+            return forms;
+        }
+
+        /// <summary>
+        ///  See the similar code in MdiWindowListStrip.PopulateItems, which is
+        ///  unfortunately just different enough in its working environment that we
+        ///  can't readily combine the two. But if you're fixing something here, chances
+        ///  are that the same issue will need scrutiny over there.
+        ///</summary>
+// "-" is OK
+        private void PopulateMdiList()
+        {
+            MenuItem senderMenu = this;
+            _data.SetState(StateInMdiPopup, true);
+            try
+            {
+                CleanListItems(this);
+
+                // Add new items
+                Form[] forms = FindMdiForms();
+                if (forms != null && forms.Length > 0)
+                {
+
+                    Form activeMdiChild = GetMainMenu().GetForm().ActiveMdiChild;
+
+                    if (senderMenu.MenuItems.Count > 0)
+                    {
+                        MenuItem sep = (MenuItem)Activator.CreateInstance(GetType());
+                        sep._data.UserData = new MdiListUserData();
+                        sep.Text = "-";
+                        senderMenu.MenuItems.Add(sep);
+                    }
+
+                    // Build a list of child windows to be displayed in
+                    // the MDIList menu item...
+                    // Show the first maxMenuForms visible elements of forms[] as Window menu items, except:
+                    // Always show the active form, even if it's not in the first maxMenuForms visible elements of forms[].
+                    // If the active form isn't in the first maxMenuForms forms, then show the first maxMenuForms-1 elements
+                    // in forms[], and make the active form the last one on the menu.
+                    // Don't count nonvisible forms against the limit on Window menu items.
+
+                    const int MaxMenuForms = 9; // Max number of Window menu items for forms
+                    int visibleChildren = 0;    // the number of visible child forms (so we know to show More Windows...)
+                    int accel = 1;              // prefix the form name with this digit, underlined, as an accelerator
+                    int formsAddedToMenu = 0;
+                    bool activeFormAdded = false;
+                    for (int i = 0; i < forms.Length; i++)
+                    {
+                        if (forms[i].Visible)
+                        {
+                            visibleChildren++;
+                            if ((activeFormAdded && (formsAddedToMenu < MaxMenuForms)) ||   // don't exceed max
+#pragma warning disable SA1408 // Conditional expressions should declare precedence
+                                (!activeFormAdded && (formsAddedToMenu < (MaxMenuForms - 1)) ||   // save room for active if it's not in yet
+#pragma warning restore SA1408 // Conditional expressions should declare precedence
+                                (forms[i].Equals(activeMdiChild))))
+                            {
+                                // there's always room for activeMdiChild
+                                MenuItem windowItem = (MenuItem)Activator.CreateInstance(GetType());
+                                windowItem._data.UserData = new MdiListFormData(this, i);
+
+                                if (forms[i].Equals(activeMdiChild))
+                                {
+                                    windowItem.Checked = true;
+                                    activeFormAdded = true;
+                                }
+
+                                windowItem.Text = string.Format(CultureInfo.CurrentUICulture, "&{0} {1}", accel, forms[i].Text);
+                                accel++;
+                                formsAddedToMenu++;
+                                senderMenu.MenuItems.Add(windowItem);
+                            }
+                        }
+                    }
+
+                    // Display the More Windows menu option when there are more than 9 MDI
+                    // Child menu items to be displayed. This is necessary because we're managing our own
+                    // MDI lists, rather than letting Windows do this for us.
+                    if (visibleChildren > MaxMenuForms)
+                    {
+                        MenuItem moreWindows = (MenuItem)Activator.CreateInstance(GetType());
+                        moreWindows._data.UserData = new MdiListMoreWindowsData(this);
+                        moreWindows.Text = SR.MDIMenuMoreWindows;
+                        senderMenu.MenuItems.Add(moreWindows);
+                    }
+                }
+            }
+            finally
+            {
+                _data.SetState(StateInMdiPopup, false);
+            }
+        }
+
+        /// <summary>
+        ///  Merges this menu item with another menu item and returns the resulting merged
+        /// <see cref='MenuItem'/>.
+        /// </summary>
+        public virtual MenuItem MergeMenu()
+        {
+            CheckIfDisposed();
+
+            MenuItem newItem = (MenuItem)Activator.CreateInstance(GetType());
+            _data.AddItem(newItem);
+            newItem.MergeMenu(this);
+            return newItem;
+        }
+
+        /// <summary>
+        ///  Merges another menu item with this menu item.
+        /// </summary>
+        public void MergeMenu(MenuItem itemSrc)
+        {
+            base.MergeMenu(itemSrc);
+            itemSrc._data.AddItem(this);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Click'/> event.
+        /// </summary>
+        protected virtual void OnClick(EventArgs e)
+        {
+            CheckIfDisposed();
+
+            if (_data.UserData is MdiListUserData)
+            {
+                ((MdiListUserData)_data.UserData).OnClick(e);
+            }
+            else if (_data.baseItem != this)
+            {
+                _data.baseItem.OnClick(e);
+            }
+            else
+            {
+                _data._onClick?.Invoke(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='DrawItem'/> event.
+        /// </summary>
+        protected virtual void OnDrawItem(DrawItemEventArgs e)
+        {
+            CheckIfDisposed();
+
+            if (_data.baseItem != this)
+            {
+                _data.baseItem.OnDrawItem(e);
+            }
+            else
+            {
+                _data._onDrawItem?.Invoke(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='MeasureItem'/> event.
+        /// </summary>
+        protected virtual void OnMeasureItem(MeasureItemEventArgs e)
+        {
+            CheckIfDisposed();
+
+            if (_data.baseItem != this)
+            {
+                _data.baseItem.OnMeasureItem(e);
+            }
+            else
+            {
+                _data._onMeasureItem?.Invoke(this, e);
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Popup'/> event.
+        /// </summary>
+        protected virtual void OnPopup(EventArgs e)
+        {
+            CheckIfDisposed();
+
+            bool recreate = false;
+            for (int i = 0; i < ItemCount; i++)
+            {
+                if (items[i].MdiList)
+                {
+                    recreate = true;
+                    items[i].UpdateMenuItem(force: true);
+                }
+            }
+
+            if (recreate || (_hasHandle && !IsParent))
+            {
+                UpdateMenuItem(force: true);
+            }
+
+            if (_data.baseItem != this)
+            {
+                _data.baseItem.OnPopup(e);
+            }
+            else
+            {
+                _data._onPopup?.Invoke(this, e);
+            }
+
+            // Update any subitem states that got changed in the event
+            for (int i = 0; i < ItemCount; i++)
+            {
+                MenuItem item = items[i];
+                if (item._dataVersion != item._data._version)
+                {
+                    item.UpdateMenuItem(force: true);
+                }
+            }
+
+            if (MdiList)
+            {
+                PopulateMdiList();
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Select'/> event.
+        /// </summary>
+        protected virtual void OnSelect(EventArgs e)
+        {
+            CheckIfDisposed();
+
+            if (_data.baseItem != this)
+            {
+                _data.baseItem.OnSelect(e);
+            }
+            else
+            {
+                _data._onSelect?.Invoke(this, e);
+            }
+        }
+
+        protected internal virtual void OnInitMenuPopup(EventArgs e) => OnPopup(e);
+
+        /// <summary>
+        ///  Generates a <see cref='Control.Click'/> event for the MenuItem,
+        ///  simulating a click by a user.
+        /// </summary>
+        public void PerformClick() => OnClick(EventArgs.Empty);
+
+        /// <summary>
+        ///  Raises the <see cref='Select'/> event for this menu item.
+        /// </summary>
+        public virtual void PerformSelect() => OnSelect(EventArgs.Empty);
+
+        internal virtual bool ShortcutClick()
+        {
+            if (Parent is MenuItem parent)
+            {
+                if (!parent.ShortcutClick() || Parent != parent)
+                {
+                    return false;
+                }
+            }
+
+            if ((_data.State & StateDisabled) != 0)
+            {
+                return false;
+            }
+
+            if (ItemCount > 0)
+            {
+                OnPopup(EventArgs.Empty);
+            }
+            else
+            {
+                OnClick(EventArgs.Empty);
+            }
+
+            return true;
+        }
+
+        public override string ToString()
+        {
+            string s = base.ToString();
+            string menuItemText = _data?._caption ?? string.Empty;
+            ;
+            return s + ", Text: " + menuItemText;
+        }
+
+        internal void UpdateItemRtl(bool setRightToLeftBit)
+        {
+            if (!_menuItemIsCreated)
+            {
+                return;
+            }
+
+            var info = new NativeMethods.MENUITEMINFO_T
+            {
+                fMask = NativeMethods.MIIM_TYPE | NativeMethods.MIIM_STATE | NativeMethods.MIIM_SUBMENU,
+                dwTypeData = new string('\0', Text.Length + 2),
+                cbSize = Marshal.SizeOf<NativeMethods.MENUITEMINFO_T>()
+            };
+            info.cch = info.dwTypeData.Length - 1;
+            UnsafeNativeMethods.GetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, info);
+            if (setRightToLeftBit)
+            {
+                info.fType |= NativeMethods.MFT_RIGHTJUSTIFY | NativeMethods.MFT_RIGHTORDER;
+            }
+            else
+            {
+                info.fType &= ~(NativeMethods.MFT_RIGHTJUSTIFY | NativeMethods.MFT_RIGHTORDER);
+            }
+
+            UnsafeNativeMethods.SetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, info);
+        }
+
+        internal void UpdateMenuItem(bool force)
+        {
+            if (Parent == null || !Parent.created)
+            {
+                return;
+            }
+
+            if (force || Parent is MainMenu || Parent is ContextMenu)
+            {
+                NativeMethods.MENUITEMINFO_T info = CreateMenuItemInfo();
+                UnsafeNativeMethods.SetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, info);
+#if DEBUG
+                var infoVerify = new NativeMethods.MENUITEMINFO_T
+                {
+                    cbSize = Marshal.SizeOf<NativeMethods.MENUITEMINFO_T>(),
+                    fMask = NativeMethods.MIIM_ID | NativeMethods.MIIM_STATE |
+                                   NativeMethods.MIIM_SUBMENU | NativeMethods.MIIM_TYPE
+                };
+                UnsafeNativeMethods.GetMenuItemInfo(new HandleRef(Parent, Parent.handle), MenuID, false, infoVerify);
+#endif
+
+                if (_hasHandle && info.hSubMenu == IntPtr.Zero)
+                {
+                    ClearHandles();
+                }
+
+                _hasHandle = info.hSubMenu != IntPtr.Zero;
+                _dataVersion = _data._version;
+                if (Parent is MainMenu mainMenu)
+                {
+                    Form f = mainMenu.GetForm();
+                    if (f != null)
+                    {
+                        SafeNativeMethods.DrawMenuBar(new HandleRef(f, f.Handle));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Handles the OnMeasureItem message sent from ContainerControl
+        /// </summary>
+        internal unsafe void WmMeasureItem(ref Message m)
+        {
+            // Obtain the measure item struct
+            User32.MEASUREITEMSTRUCT* mis = (User32.MEASUREITEMSTRUCT*)m.LParam;
+
+            // The OnMeasureItem handler now determines the height and width of the item
+            using var screendc = GetDcScope.ScreenDC;
+            using Graphics graphics = Graphics.FromHdcInternal(screendc);
+
+            var mie = new MeasureItemEventArgs(graphics, Index);
+            OnMeasureItem(mie);
+
+            // Update the measure item struct with the new width and height
+            mis->itemHeight = unchecked((uint)mie.ItemHeight);
+            mis->itemWidth = unchecked((uint)mie.ItemWidth);
+
+            m.Result = (IntPtr)1;
+        }
+
+        private void CheckIfDisposed()
+        {
+            if (_data == null)
+            {
+                throw new ObjectDisposedException(GetType().FullName);
+            }
+        }
+
+        internal class MenuItemData : ICommandExecutor
+        {
+            internal MenuItem baseItem;
+            internal MenuItem firstItem;
+
+            private int _state;
+            internal int _version;
+            internal MenuMerge _mergeType;
+            internal int _mergeOrder;
+            internal string _caption;
+            internal short _mnemonic;
+            internal Shortcut _shortcut;
+            internal bool _showShortcut;
+            internal EventHandler _onClick;
+            internal EventHandler _onPopup;
+            internal EventHandler _onSelect;
+            internal DrawItemEventHandler _onDrawItem;
+            internal MeasureItemEventHandler _onMeasureItem;
+
+            private Command _cmd;
+
+            internal MenuItemData(MenuItem baseItem, MenuMerge mergeType, int mergeOrder, Shortcut shortcut, bool showShortcut,
+                                  string caption, EventHandler onClick, EventHandler onPopup, EventHandler onSelect,
+                                  DrawItemEventHandler onDrawItem, MeasureItemEventHandler onMeasureItem)
+            {
+                AddItem(baseItem);
+                _mergeType = mergeType;
+                _mergeOrder = mergeOrder;
+                _shortcut = shortcut;
+                _showShortcut = showShortcut;
+                _caption = caption ?? string.Empty;
+                _onClick = onClick;
+                _onPopup = onPopup;
+                _onSelect = onSelect;
+                _onDrawItem = onDrawItem;
+                _onMeasureItem = onMeasureItem;
+                _version = 1;
+                _mnemonic = -1;
+            }
+
+            internal bool OwnerDraw
+            {
+                get => ((State & StateOwnerDraw) != 0);
+                set => SetState(StateOwnerDraw, value);
+            }
+
+            internal bool MdiList
+            {
+                get => ((State & StateMdiList) == StateMdiList);
+                set
+                {
+                    if (((_state & StateMdiList) != 0) != value)
+                    {
+                        SetState(StateMdiList, value);
+                        for (MenuItem item = firstItem; item != null; item = item._nextLinkedItem)
+                        {
+                            item.ItemsChanged(Menu.CHANGE_MDI);
+                        }
+                    }
+                }
+            }
+
+            internal MenuMerge MergeType
+            {
+                get => _mergeType;
+                set
+                {
+                    if (_mergeType != value)
+                    {
+                        _mergeType = value;
+                        ItemsChanged(Menu.CHANGE_MERGE);
+                    }
+                }
+            }
+
+            internal int MergeOrder
+            {
+                get => _mergeOrder;
+                set
+                {
+                    if (_mergeOrder != value)
+                    {
+                        _mergeOrder = value;
+                        ItemsChanged(Menu.CHANGE_MERGE);
+                    }
+                }
+            }
+
+            internal char Mnemonic
+            {
+                get
+                {
+                    if (_mnemonic == -1)
+                    {
+                        _mnemonic = (short)WindowsFormsUtils.GetMnemonic(_caption, true);
+                    }
+
+                    return (char)_mnemonic;
+                }
+            }
+
+            internal int State => _state;
+
+            internal bool Visible
+            {
+                get => (_state & MenuItem.StateHidden) == 0;
+                set
+                {
+                    if (((_state & MenuItem.StateHidden) == 0) != value)
+                    {
+                        _state = value ? _state & ~MenuItem.StateHidden : _state | MenuItem.StateHidden;
+                        ItemsChanged(Menu.CHANGE_VISIBLE);
+                    }
+                }
+            }
+
+            internal object UserData { get; set; }
+
+            internal void AddItem(MenuItem item)
+            {
+                if (item._data != this)
+                {
+                    item._data?.RemoveItem(item);
+
+                    item._nextLinkedItem = firstItem;
+                    firstItem = item;
+                    if (baseItem == null)
+                    {
+                        baseItem = item;
+                    }
+
+                    item._data = this;
+                    item._dataVersion = 0;
+                    item.UpdateMenuItem(false);
+                }
+            }
+
+            public void Execute()
+            {
+                baseItem?.OnClick(EventArgs.Empty);
+            }
+
+            internal int GetMenuID()
+            {
+                if (_cmd == null)
+                {
+                    _cmd = new Command(this);
+                }
+
+                return _cmd.ID;
+            }
+
+            internal void ItemsChanged(int change)
+            {
+                for (MenuItem item = firstItem; item != null; item = item._nextLinkedItem)
+                {
+                    item.Parent?.ItemsChanged(change);
+                }
+            }
+
+            internal void RemoveItem(MenuItem item)
+            {
+                Debug.Assert(item._data == this, "bad item passed to MenuItemData.removeItem");
+
+                if (item == firstItem)
+                {
+                    firstItem = item._nextLinkedItem;
+                }
+                else
+                {
+                    MenuItem itemT;
+                    for (itemT = firstItem; item != itemT._nextLinkedItem;)
+                    {
+                        itemT = itemT._nextLinkedItem;
+                    }
+
+                    itemT._nextLinkedItem = item._nextLinkedItem;
+                }
+
+                item._nextLinkedItem = null;
+                item._data = null;
+                item._dataVersion = 0;
+
+                if (item == baseItem)
+                {
+                    baseItem = firstItem;
+                }
+
+                if (firstItem == null)
+                {
+                    // No longer needed. Toss all references and the Command object.
+                    Debug.Assert(baseItem == null, "why isn't baseItem null?");
+                    _onClick = null;
+                    _onPopup = null;
+                    _onSelect = null;
+                    _onDrawItem = null;
+                    _onMeasureItem = null;
+                    if (_cmd != null)
+                    {
+                        _cmd.Dispose();
+                        _cmd = null;
+                    }
+                }
+            }
+
+            internal void SetCaption(string value)
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (!_caption.Equals(value))
+                {
+                    _caption = value;
+                    UpdateMenuItems();
+                }
+
+#if DEBUG
+                if (value.Length > 0)
+                {
+                    baseItem._debugText = value;
+                }
+#endif
+            }
+
+            internal void SetState(int flag, bool value)
+            {
+                if (((_state & flag) != 0) != value)
+                {
+                    _state = value ? _state | flag : _state & ~flag;
+                    UpdateMenuItems();
+                }
+            }
+
+            internal void UpdateMenuItems()
+            {
+                _version++;
+                for (MenuItem item = firstItem; item != null; item = item._nextLinkedItem)
+                {
+                    item.UpdateMenuItem(force: true);
+                }
+            }
+
+        }
+
+        private class MdiListUserData
+        {
+            public virtual void OnClick(EventArgs e)
+            {
+            }
+        }
+
+        private class MdiListFormData : MdiListUserData
+        {
+            private readonly MenuItem _parent;
+            private readonly int _boundIndex;
+
+            public MdiListFormData(MenuItem parentItem, int boundFormIndex)
+            {
+                _boundIndex = boundFormIndex;
+                _parent = parentItem;
+            }
+
+            public override void OnClick(EventArgs e)
+            {
+                if (_boundIndex != -1)
+                {
+                    Form[] forms = _parent.FindMdiForms();
+                    Debug.Assert(forms != null, "Didn't get a list of the MDI Forms.");
+
+                    if (forms != null && forms.Length > _boundIndex)
+                    {
+                        Form boundForm = forms[_boundIndex];
+                        boundForm.Activate();
+                        if (boundForm.ActiveControl != null && !boundForm.ActiveControl.Focused)
+                        {
+                            boundForm.ActiveControl.Focus();
+                        }
+                    }
+                }
+            }
+        }
+
+        private class MdiListMoreWindowsData : MdiListUserData
+        {
+            private readonly MenuItem _parent;
+
+            public MdiListMoreWindowsData(MenuItem parent)
+            {
+                _parent = parent;
+            }
+
+            public override void OnClick(EventArgs e)
+            {
+                Form[] forms = _parent.FindMdiForms();
+                Debug.Assert(forms != null, "Didn't get a list of the MDI Forms.");
+                Form active = _parent.GetMainMenu().GetForm().ActiveMdiChild;
+                Debug.Assert(active != null, "Didn't get the active MDI child");
+                if (forms != null && forms.Length > 0 && active != null)
+                {
+                    using (var dialog = new MdiWindowDialog())
+                    {
+                        dialog.SetItems(active, forms);
+                        DialogResult result = dialog.ShowDialog();
+                        if (result == DialogResult.OK)
+                        {
+                            dialog.ActiveChildForm.Activate();
+                            if (dialog.ActiveChildForm.ActiveControl != null && !dialog.ActiveChildForm.ActiveControl.Focused)
+                            {
+                                dialog.ActiveChildForm.ActiveControl.Focus();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/MenuMerge.cs b/src/System.Windows.Forms/src/System/Windows/Forms/MenuMerge.cs
new file mode 100644
index 00000000000..d7e4cc08ff8
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/MenuMerge.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the behavior of a <see cref='MenuItem'/> when it is merged with items in another menu.
+    /// </summary>
+    public enum MenuMerge
+    {
+        /// <summary>
+        ///  The <see cref='MenuItem'/> is added to the
+        ///  existing <see cref='MenuItem'/> objects in a
+        ///  merged menu.
+        /// </summary>
+        Add = 0,
+
+        /// <summary>
+        ///  The <see cref='MenuItem'/> replaces the
+        ///  existing <see cref='MenuItem'/> at the same
+        ///  position in a merged menu.
+        /// </summary>
+        Replace = 1,
+
+        /// <summary>
+        ///  Subitems of this <see cref='MenuItem'/> are merged
+        ///  with those of existing <see cref='MenuItem'/>
+        ///  objects at the same position in a merged menu.
+        /// </summary>
+        MergeItems = 2,
+
+        /// <summary>
+        ///  The <see cref='MenuItem'/> is not included in a
+        ///  merged menu.
+        /// </summary>
+        Remove = 3,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/MonthCalendar.cs b/src/System.Windows.Forms/src/System/Windows/Forms/MonthCalendar.cs
index 83362dea105..934fc8b3569 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/MonthCalendar.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/MonthCalendar.cs
@@ -8,6 +8,7 @@
 using Microsoft.Win32;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/NotifyIcon.cs b/src/System.Windows.Forms/src/System/Windows/Forms/NotifyIcon.cs
index bb92ad1bdc3..c2897a419fb 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/NotifyIcon.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/NotifyIcon.cs
@@ -48,6 +48,7 @@ public sealed partial class NotifyIcon : Component
     private static uint s_nextId;
     private object? _userData;
     private bool _doubleClick; // checks if doubleclick is fired
+    private ContextMenu contextMenu = null;
 
     // Visible defaults to false, but the NotifyIconDesigner makes it seem like the default is
     // true.  We do this because while visible is the more common case, if it was a true default,
@@ -74,6 +75,29 @@ public NotifyIcon(IContainer container) : this()
         container.Add(this);
     }
 
+    /// <summary>
+    ///  Gets or sets context menu
+    ///  for the tray icon.
+    /// </summary>
+    [
+        Browsable(false),
+        DefaultValue(null),
+        SRCategory(nameof(SR.CatBehavior)),
+        SRDescription(nameof(SR.NotifyIconMenuDescr))
+    ]
+    public ContextMenu ContextMenu
+    {
+        get
+        {
+            return contextMenu;
+        }
+
+        set
+        {
+            contextMenu = value;
+        }
+    }
+
     /// <summary>
     ///  Gets or sets the BalloonTip text displayed when
     ///  the mouse hovers over a system tray icon.
@@ -398,6 +422,7 @@ protected override void Dispose(bool disposing)
                 _window.DestroyHandle();
                 _window = null!;
                 _contextMenuStrip = null;
+                contextMenu = null;
             }
         }
         else
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/Printing/PrintPreviewDialog.cs b/src/System.Windows.Forms/src/System/Windows/Forms/Printing/PrintPreviewDialog.cs
index 7a3ffff7956..bf111b913e9 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/Printing/PrintPreviewDialog.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/Printing/PrintPreviewDialog.cs
@@ -267,6 +267,23 @@ public override ContextMenuStrip? ContextMenuStrip
         set => base.KeyPreview = value;
     }
 
+    /// <summary>
+    ///  The contextMenu associated with this control. The contextMenu
+    ///  will be shown when the user right clicks the mouse on the control.
+    /// </summary>
+    [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+    public override ContextMenu? ContextMenu
+    {
+        get
+        {
+            return base.ContextMenu;
+        }
+        set
+        {
+            base.ContextMenu = value;
+        }
+    }
+
     /// <summary>
     ///  Gets or Sets the maximum size the dialog can be resized to.
     /// </summary>
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/RichTextBox.OleCallback.cs b/src/System.Windows.Forms/src/System/Windows/Forms/RichTextBox.OleCallback.cs
index bafd2e42965..b57ef64bfa9 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/RichTextBox.OleCallback.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/RichTextBox.OleCallback.cs
@@ -314,15 +314,64 @@ public HRESULT GetContextMenu(
             CHARRANGE* lpchrg,
             HMENU* hmenu)
         {
-            RichTextDbg.TraceVerbose("IRichEditOleCallback::GetContextMenu");
-
-            // Do nothing, we don't have ContextMenu any longer
-            if (hmenu is not null)
+            Debug.WriteLineIf(RichTextDbg.TraceVerbose, "IRichEditOleCallback::GetContextMenu");
+            ContextMenu cm = _owner.ContextMenu;
+            if (cm == null || _owner.ShortcutsEnabled == false)
             {
-                *hmenu = HMENU.Null;
+                hmenu = (HMENU*)IntPtr.Zero;
+            }
+            else
+            {
+                cm.sourceControl = _owner;
+                cm.OnPopup(EventArgs.Empty);
+                // RichEd calls DestroyMenu after displaying the context menu
+                IntPtr handle = cm.Handle;
+                // if another control shares the same context menu
+                // then we have to mark the context menu's handles empty because
+                // RichTextBox will delete the menu handles once the popup menu is dismissed.
+                Menu menu = cm;
+                while (true)
+                {
+                    int i = 0;
+                    int count = menu.ItemCount;
+                    for (; i < count; i++)
+                    {
+                        if (menu.items[i].handle != IntPtr.Zero)
+                        {
+                            menu = menu.items[i];
+                            break;
+                        }
+                    }
+
+                    if (i == count)
+                    {
+                        menu.handle = IntPtr.Zero;
+                        menu.created = false;
+                        if (menu == cm)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            menu = ((MenuItem)menu).Parent;
+                        }
+                    }
+                }
+
+                hmenu = (HMENU*)handle;
             }
 
             return HRESULT.S_OK;
+
+            //RichTextDbg.TraceVerbose("IRichEditOleCallback::GetContextMenu");
+
+            //// Do nothing, we don't have ContextMenu any longer
+            //if (hmenu is not null)
+            //{
+            //    *hmenu = HMENU.Null;
+            //}
+
+            //return HRESULT.S_OK;
         }
 
         private void UpdateDropDescription(DragEventArgs e)
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/SimpleDataGrid.cs b/src/System.Windows.Forms/src/System/Windows/Forms/SimpleDataGrid.cs
new file mode 100644
index 00000000000..27c6e027fde
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/SimpleDataGrid.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+namespace System.Windows.Forms
+{
+    public class SimpleDataGrid : Control
+    {
+        public SimpleDataGrid()
+        {
+        }
+
+        public string Hello { get; set; } = "Hello, WTG";
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBar.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBar.cs
new file mode 100644
index 00000000000..b49b0482fc4
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBar.cs
@@ -0,0 +1,1947 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Windows.Forms.VisualStyles;
+using WTG.System.Windows.Forms.System.Windows.Forms;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a Windows status bar control.
+    /// </summary>
+    [
+    ComVisible(true),
+    ClassInterface(ClassInterfaceType.AutoDispatch),
+    DefaultEvent(nameof(PanelClick)),
+    DefaultProperty(nameof(Text)),
+    Designer("System.Windows.Forms.Design.StatusBarDesigner, " + AssemblyRef.SystemDesign),
+    ]
+    public class StatusBar : Control
+    {
+        private int sizeGripWidth = 0;
+        private const int SIMPLE_INDEX = 0xFF;
+
+        private static readonly object EVENT_PANELCLICK = new object();
+        private static readonly object EVENT_SBDRAWITEM = new object();
+
+        private bool showPanels;
+        private bool layoutDirty;
+        private int panelsRealized;
+        private bool sizeGrip = true;
+        private string simpleText;
+        private Point lastClick = new Point(0, 0);
+        private readonly IList panels = new ArrayList();
+        private StatusBarPanelCollection panelsCollection;
+        private ControlToolTip tooltips;
+
+        private ToolTip mainToolTip = null;
+        private bool toolTipSet = false;
+
+        /// <summary>
+        ///  Initializes a new default instance of the <see cref='StatusBar'/> class.
+        /// </summary>
+        public StatusBar()
+        : base()
+        {
+            base.SetStyle(ControlStyles.UserPaint | ControlStyles.Selectable, false);
+
+            Dock = DockStyle.Bottom;
+            TabStop = false;
+        }
+
+        private static VisualStyleRenderer renderer = null;
+
+        /// <summary>
+        ///  A VisualStyleRenderer we can use to get information about the current UI theme
+        /// </summary>
+        private static VisualStyleRenderer VisualStyleRenderer
+        {
+            get
+            {
+                if (VisualStyleRenderer.IsSupported)
+                {
+                    if (renderer == null)
+                    {
+                        renderer = new VisualStyleRenderer(VisualStyleElement.ToolBar.Button.Normal);
+                    }
+                }
+                else
+                {
+                    renderer = null;
+                }
+
+                return renderer;
+            }
+
+        }
+
+        private int SizeGripWidth
+        {
+            get
+            {
+                if (sizeGripWidth == 0)
+                {
+                    if (Application.RenderWithVisualStyles && VisualStyleRenderer != null)
+                    {
+                        // Need to build up accurate gripper width to avoid cutting off other panes.
+                        VisualStyleRenderer vsRenderer = VisualStyleRenderer;
+                        VisualStyleElement thisElement;
+                        Size elementSize;
+
+                        // gripper pane width...
+                        thisElement = VisualStyleElement.Status.GripperPane.Normal;
+                        vsRenderer.SetParameters(thisElement);
+                        elementSize = vsRenderer.GetPartSize(Graphics.FromHwndInternal(Handle), ThemeSizeType.True);
+                        sizeGripWidth = elementSize.Width;
+
+                        // ...plus gripper width
+                        thisElement = VisualStyleElement.Status.Gripper.Normal;
+                        vsRenderer.SetParameters(thisElement);
+                        elementSize = vsRenderer.GetPartSize(Graphics.FromHwndInternal(Handle), ThemeSizeType.True);
+                        sizeGripWidth += elementSize.Width;
+
+                        // Either GetPartSize could have returned a width of zero, so make sure we have a reasonable number:
+                        sizeGripWidth = Math.Max(sizeGripWidth, 16);
+                    }
+                    else
+                    {
+                        sizeGripWidth = 16;
+                    }
+                }
+
+                return sizeGripWidth;
+            }
+        }
+
+        /// <summary>
+        ///  The background color of this control. This is an ambient property and will
+        ///  always return a non-null value.
+        /// </summary>
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Color BackColor
+        {
+            get
+            {
+                // not supported, always return CONTROL
+                return SystemColors.Control;
+            }
+            set
+            {
+                // no op, not supported.
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackColorChanged
+        {
+            add => base.BackColorChanged += value;
+            remove => base.BackColorChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets or sets the image rendered on the background of the
+        ///  <see cref='StatusBar'/>
+        ///  control.
+        /// </summary>
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Image BackgroundImage
+        {
+            get
+            {
+                return base.BackgroundImage;
+            }
+            set
+            {
+                base.BackgroundImage = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageChanged
+        {
+            add => base.BackgroundImageChanged += value;
+            remove => base.BackgroundImageChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override ImageLayout BackgroundImageLayout
+        {
+            get
+            {
+                return base.BackgroundImageLayout;
+            }
+            set
+            {
+                base.BackgroundImageLayout = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageLayoutChanged
+        {
+            add => base.BackgroundImageLayoutChanged += value;
+            remove => base.BackgroundImageLayoutChanged -= value;
+        }
+
+        /// <summary>
+        ///  Returns the CreateParams used to create the handle for this control.
+        ///  Inheriting classes should call base.getCreateParams in the manor below:
+        /// </summary>
+        protected override CreateParams CreateParams
+        {
+            get
+            {
+                CreateParams cp = base.CreateParams;
+                cp.ClassName = NativeMethods.WC_STATUSBAR;
+
+                if (sizeGrip)
+                {
+                    cp.Style |= NativeMethods.SBARS_SIZEGRIP;
+                }
+                else
+                {
+                    cp.Style &= (~NativeMethods.SBARS_SIZEGRIP);
+                }
+
+                cp.Style |= NativeMethods.CCS_NOPARENTALIGN | NativeMethods.CCS_NORESIZE;
+
+                return cp;
+            }
+        }
+
+        protected override ImeMode DefaultImeMode
+        {
+            get
+            {
+                return ImeMode.Disable;
+            }
+        }
+
+        /// <summary>
+        ///  Deriving classes can override this to configure a default size for their control.
+        ///  This is more efficient than setting the size in the control's constructor.
+        /// </summary>
+        protected override Size DefaultSize
+        {
+            get
+            {
+                return new Size(100, 22);
+            }
+        }
+
+        /// <summary>
+        ///  This property is overridden and hidden from statement completion
+        ///  on controls that are based on Win32 Native Controls.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        protected override bool DoubleBuffered
+        {
+            get
+            {
+                return base.DoubleBuffered;
+            }
+            set
+            {
+                base.DoubleBuffered = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the docking behavior of the <see cref='StatusBar'/> control.
+        /// </summary>
+        [
+        Localizable(true),
+        DefaultValue(DockStyle.Bottom)
+        ]
+        public override DockStyle Dock
+        {
+            get
+            {
+                return base.Dock;
+            }
+            set
+            {
+                base.Dock = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the font the <see cref='StatusBar'/>
+        ///  control will use to display
+        ///  information.
+        /// </summary>
+        [
+        Localizable(true)
+        ]
+        public override Font Font
+        {
+            get { return base.Font; }
+            set
+            {
+                base.Font = value;
+                SetPanelContentsWidths(false);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets
+        ///  the forecolor for the control.
+        /// </summary>
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Color ForeColor
+        {
+            get
+            {
+                return base.ForeColor;
+            }
+            set
+            {
+                base.ForeColor = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler ForeColorChanged
+        {
+            add => base.ForeColorChanged += value;
+            remove => base.ForeColorChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public ImeMode ImeMode
+        {
+            get
+            {
+                return base.ImeMode;
+            }
+            set
+            {
+                base.ImeMode = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public new event EventHandler ImeModeChanged
+        {
+            add => base.ImeModeChanged += value;
+            remove => base.ImeModeChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets the collection of <see cref='StatusBar'/>
+        ///  panels contained within the
+        ///  control.
+        /// </summary>
+        [
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
+        SRDescription(nameof(SR.StatusBarPanelsDescr)),
+        Localizable(true),
+        SRCategory(nameof(SR.CatAppearance)),
+        MergableProperty(false)
+        ]
+        public StatusBarPanelCollection Panels
+        {
+            get
+            {
+                if (panelsCollection == null)
+                {
+                    panelsCollection = new StatusBarPanelCollection(this);
+                }
+
+                return panelsCollection;
+            }
+        }
+
+        /// <summary>
+        ///  The status bar text.
+        /// </summary>
+        [
+        Localizable(true)
+        ]
+        public override string Text
+        {
+            get
+            {
+                if (simpleText == null)
+                {
+                    return "";
+                }
+                else
+                {
+                    return simpleText;
+                }
+            }
+            set
+            {
+                SetSimpleText(value);
+                if (simpleText != value)
+                {
+                    simpleText = value;
+                    OnTextChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether panels should be shown.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(false),
+        SRDescription(nameof(SR.StatusBarShowPanelsDescr))
+        ]
+        public bool ShowPanels
+        {
+            get
+            {
+                return showPanels;
+            }
+            set
+            {
+                if (showPanels != value)
+                {
+                    showPanels = value;
+
+                    layoutDirty = true;
+                    if (IsHandleCreated)
+                    {
+                        int bShowPanels = (!showPanels) ? 1 : 0;
+
+                        SendMessage(NativeMethods.SB_SIMPLE, bShowPanels, 0);
+
+                        if (showPanels)
+                        {
+                            PerformLayout();
+                            RealizePanels();
+                        }
+                        else if (tooltips != null)
+                        {
+                            for (int i = 0; i < panels.Count; i++)
+                            {
+                                tooltips.SetTool(panels[i], null);
+                            }
+                        }
+
+                        SetSimpleText(simpleText);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether a sizing grip
+        ///  will be rendered on the corner of the <see cref='StatusBar'/>
+        ///  control.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(true),
+        SRDescription(nameof(SR.StatusBarSizingGripDescr))
+        ]
+        public bool SizingGrip
+        {
+            get
+            {
+                return sizeGrip;
+            }
+            set
+            {
+                if (value != sizeGrip)
+                {
+                    sizeGrip = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the user will be able to tab to the
+        ///  <see cref='StatusBar'/> .
+        /// </summary>
+        [DefaultValue(false)]
+        new public bool TabStop
+        {
+            get
+            {
+                return base.TabStop;
+            }
+            set
+            {
+                base.TabStop = value;
+            }
+        }
+
+        internal bool ToolTipSet
+        {
+            get
+            {
+                return toolTipSet;
+            }
+        }
+
+        internal ToolTip MainToolTip
+        {
+            get
+            {
+                return mainToolTip;
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when a visual aspect of an owner-drawn status bar changes.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior)), SRDescription(nameof(SR.StatusBarDrawItem))]
+        public event StatusBarDrawItemEventHandler DrawItem
+        {
+            add => Events.AddHandler(EVENT_SBDRAWITEM, value);
+            remove => Events.RemoveHandler(EVENT_SBDRAWITEM, value);
+        }
+
+        /// <summary>
+        ///  Occurs when a panel on the status bar is clicked.
+        /// </summary>
+        [SRCategory(nameof(SR.CatMouse)), SRDescription(nameof(SR.StatusBarOnPanelClickDescr))]
+        public event StatusBarPanelClickEventHandler PanelClick
+        {
+            add => Events.AddHandler(EVENT_PANELCLICK, value);
+            remove => Events.RemoveHandler(EVENT_PANELCLICK, value);
+        }
+
+        /// <summary>
+        ///  StatusBar Onpaint.
+        /// </summary>
+        /// <hideinheritance/>
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public new event PaintEventHandler Paint
+        {
+            add => base.Paint += value;
+            remove => base.Paint -= value;
+        }
+
+        /// <summary>
+        ///  Tells whether the panels have been realized.
+        /// </summary>
+        internal bool ArePanelsRealized()
+        {
+            return showPanels && IsHandleCreated;
+        }
+
+        internal void DirtyLayout()
+        {
+            layoutDirty = true;
+        }
+
+        /// <summary>
+        ///  Makes the panel according to the sizes in the panel list.
+        /// </summary>
+        private void ApplyPanelWidths()
+        {
+            // This forces handle creation every time any time the StatusBar
+            // has to be re-laidout.
+            if (!IsHandleCreated)
+            {
+                return;
+            }
+
+            StatusBarPanel panel = null;
+            int length = panels.Count;
+
+            if (length == 0)
+            {
+                Size sz = Size;
+                int[] offsets = new int[1];
+                offsets[0] = sz.Width;
+                if (sizeGrip)
+                {
+                    offsets[0] -= SizeGripWidth;
+                }
+
+                UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.SB_SETPARTS, 1, offsets);
+                SendMessage(NativeMethods.SB_SETICON, 0, (int)IntPtr.Zero);
+
+                return;
+            }
+
+            int[] offsets2 = new int[length];
+            int currentOffset = 0;
+            for (int i = 0; i < length; i++)
+            {
+                panel = (StatusBarPanel)panels[i];
+                currentOffset += panel.Width;
+                offsets2[i] = currentOffset;
+                panel.Right = offsets2[i];
+            }
+
+            UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.SB_SETPARTS, length, offsets2);
+
+            // Tooltip setup...
+            for (int i = 0; i < length; i++)
+            {
+                panel = (StatusBarPanel)panels[i];
+                UpdateTooltip(panel);
+            }
+
+            layoutDirty = false;
+        }
+
+        protected override void CreateHandle()
+        {
+            if (!RecreatingHandle)
+            {
+                IntPtr userCookie = UnsafeNativeMethodsCore.ThemingScope.Activate();
+
+                try
+                {
+                    NativeMethods.INITCOMMONCONTROLSEX icc = new NativeMethods.INITCOMMONCONTROLSEX
+                    {
+                        dwICC = NativeMethods.ICC_BAR_CLASSES
+                    };
+                    SafeNativeMethods.InitCommonControlsEx(icc);
+                }
+                finally
+                {
+                    UnsafeNativeMethodsCore.ThemingScope.Deactivate(userCookie);
+                }
+            }
+
+            base.CreateHandle();
+        }
+
+        /// <summary>
+        ///  Disposes this control
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (panelsCollection != null)
+                {
+                    StatusBarPanel[] panelCopy = new StatusBarPanel[panelsCollection.Count];
+                    ((ICollection)panelsCollection).CopyTo(panelCopy, 0);
+                    panelsCollection.Clear();
+
+                    foreach (StatusBarPanel p in panelCopy)
+                    {
+                        p.Dispose();
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Forces the panels to be updated, location, repainting, etc.
+        /// </summary>
+        private void ForcePanelUpdate()
+        {
+            if (ArePanelsRealized())
+            {
+                layoutDirty = true;
+                SetPanelContentsWidths(true);
+                PerformLayout();
+                RealizePanels();
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='Control.CreateHandle'/>
+        ///  event.
+        /// </summary>
+        protected override void OnHandleCreated(EventArgs e)
+        {
+            base.OnHandleCreated(e);
+            if (!DesignMode)
+            {
+                tooltips = new ControlToolTip(this);
+            }
+
+            if (!showPanels)
+            {
+                SendMessage(NativeMethods.SB_SIMPLE, 1, 0);
+                SetSimpleText(simpleText);
+            }
+            else
+            {
+                ForcePanelUpdate();
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='OnHandleDestroyed'/> event.
+        /// </summary>
+        protected override void OnHandleDestroyed(EventArgs e)
+        {
+            base.OnHandleDestroyed(e);
+            if (tooltips != null)
+            {
+                tooltips.Dispose();
+                tooltips = null;
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='OnMouseDown'/> event.
+        /// </summary>
+        protected override void OnMouseDown(MouseEventArgs e)
+        {
+            lastClick.X = e.X;
+            lastClick.Y = e.Y;
+            base.OnMouseDown(e);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='PanelClick'/> event.
+        /// </summary>
+        protected virtual void OnPanelClick(StatusBarPanelClickEventArgs e)
+        {
+            ((StatusBarPanelClickEventHandler)Events[EVENT_PANELCLICK])?.Invoke(this, e);
+        }
+
+        protected override void OnLayout(LayoutEventArgs levent)
+        {
+            if (showPanels)
+            {
+                LayoutPanels();
+                if (IsHandleCreated && panelsRealized != panels.Count)
+                {
+                    RealizePanels();
+                }
+            }
+
+            base.OnLayout(levent);
+        }
+
+        /// <summary>
+        ///  This function sets up all the panel on the status bar according to
+        ///  the internal this.panels List.
+        /// </summary>
+        internal void RealizePanels()
+        {
+            StatusBarPanel panel = null;
+            int length = panels.Count;
+            int old = panelsRealized;
+
+            panelsRealized = 0;
+
+            if (length == 0)
+            {
+                SendMessage(NativeMethods.SB_SETTEXT, 0, "");
+            }
+
+            int i;
+            for (i = 0; i < length; i++)
+            {
+                panel = (StatusBarPanel)panels[i];
+                try
+                {
+                    panel.Realize();
+                    panelsRealized++;
+                }
+                catch
+                {
+                }
+            }
+
+            for (; i < old; i++)
+            {
+                SendMessage(NativeMethods.SB_SETTEXT, 0, null);
+            }
+        }
+
+        /// <summary>
+        ///  Remove the internal list of panels without updating the control.
+        /// </summary>
+        internal void RemoveAllPanelsWithoutUpdate()
+        {
+            int size = panels.Count;
+            // remove the parent reference
+            for (int i = 0; i < size; i++)
+            {
+                StatusBarPanel sbp = (StatusBarPanel)panels[i];
+                sbp.ParentInternal = null;
+            }
+
+            panels.Clear();
+            if (showPanels == true)
+            {
+                ApplyPanelWidths();
+                ForcePanelUpdate();
+            }
+
+        }
+
+        /// <summary>
+        ///  Sets the widths of any panels that have the
+        ///  StatusBarPanelAutoSize.CONTENTS property set.
+        /// </summary>
+        internal void SetPanelContentsWidths(bool newPanels)
+        {
+            int size = panels.Count;
+            bool changed = false;
+            for (int i = 0; i < size; i++)
+            {
+                StatusBarPanel sbp = (StatusBarPanel)panels[i];
+                if (sbp.AutoSize == StatusBarPanelAutoSize.Contents)
+                {
+                    int newWidth = sbp.GetContentsWidth(newPanels);
+                    if (sbp.Width != newWidth)
+                    {
+                        sbp.Width = newWidth;
+                        changed = true;
+                    }
+                }
+            }
+
+            if (changed)
+            {
+                DirtyLayout();
+                PerformLayout();
+            }
+        }
+
+        private void SetSimpleText(string simpleText)
+        {
+            if (!showPanels && IsHandleCreated)
+            {
+
+                int wparam = SIMPLE_INDEX + NativeMethods.SBT_NOBORDERS;
+                if (RightToLeft == RightToLeft.Yes)
+                {
+                    wparam |= NativeMethods.SBT_RTLREADING;
+                }
+
+                SendMessage(NativeMethods.SB_SETTEXT, wparam, simpleText);
+            }
+        }
+
+        /// <summary>
+        ///  Sizes the the panels appropriately.  It looks at the SPRING AutoSize
+        ///  property.
+        /// </summary>
+        private void LayoutPanels()
+        {
+            StatusBarPanel panel = null;
+            int barPanelWidth = 0;
+            int springNum = 0;
+            StatusBarPanel[] pArray = new StatusBarPanel[panels.Count];
+            bool changed = false;
+
+            for (int i = 0; i < pArray.Length; i++)
+            {
+                panel = (StatusBarPanel)panels[i];
+                if (panel.AutoSize == StatusBarPanelAutoSize.Spring)
+                {
+                    pArray[springNum] = panel;
+                    springNum++;
+                }
+                else
+                {
+                    barPanelWidth += panel.Width;
+                }
+            }
+
+            if (springNum > 0)
+            {
+                Rectangle rect = Bounds;
+                int springPanelsLeft = springNum;
+                int leftoverWidth = rect.Width - barPanelWidth;
+                if (sizeGrip)
+                {
+                    leftoverWidth -= SizeGripWidth;
+                }
+
+                int copyOfLeftoverWidth = unchecked((int)0x80000000);
+                while (springPanelsLeft > 0)
+                {
+
+                    int widthOfSpringPanel = (leftoverWidth) / springPanelsLeft;
+                    if (leftoverWidth == copyOfLeftoverWidth)
+                    {
+                        break;
+                    }
+
+                    copyOfLeftoverWidth = leftoverWidth;
+
+                    for (int i = 0; i < springNum; i++)
+                    {
+                        panel = pArray[i];
+                        if (panel == null)
+                        {
+                            continue;
+                        }
+
+                        if (widthOfSpringPanel < panel.MinWidth)
+                        {
+                            if (panel.Width != panel.MinWidth)
+                            {
+                                changed = true;
+                            }
+
+                            panel.Width = panel.MinWidth;
+                            pArray[i] = null;
+                            springPanelsLeft--;
+                            leftoverWidth -= panel.MinWidth;
+                        }
+                        else
+                        {
+                            if (panel.Width != widthOfSpringPanel)
+                            {
+                                changed = true;
+                            }
+
+                            panel.Width = widthOfSpringPanel;
+                        }
+                    }
+                }
+            }
+
+            if (changed || layoutDirty)
+            {
+                ApplyPanelWidths();
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='OnDrawItem'/>
+        ///  event.
+        /// </summary>
+        protected virtual void OnDrawItem(StatusBarDrawItemEventArgs sbdievent)
+        {
+            ((StatusBarDrawItemEventHandler)Events[EVENT_SBDRAWITEM])?.Invoke(this, sbdievent);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='OnResize'/> event.
+        /// </summary>
+        protected override void OnResize(EventArgs e)
+        {
+            Invalidate();
+            base.OnResize(e);
+        }
+
+        /// <summary>
+        ///  Returns a string representation for this control.
+        /// </summary>
+        public override string ToString()
+        {
+            string s = base.ToString();
+            if (Panels != null)
+            {
+                s += ", Panels.Count: " + Panels.Count.ToString(CultureInfo.CurrentCulture);
+                if (Panels.Count > 0)
+                {
+                    s += ", Panels[0]: " + Panels[0].ToString();
+                }
+            }
+
+            return s;
+        }
+
+        // call this when System.Windows.forms.toolTip is Associated with Statusbar....
+        internal void SetToolTip(ToolTip t)
+        {
+            mainToolTip = t;
+            toolTipSet = true;
+
+        }
+
+        internal void UpdateTooltip(StatusBarPanel panel)
+        {
+            if (tooltips == null)
+            {
+                if (IsHandleCreated && !DesignMode)
+                {
+                    //This shouldn't happen: tooltips should've already been set.  The best we can
+                    //do here is reset it.
+                    tooltips = new ControlToolTip(this);
+                }
+                else
+                {
+                    return;
+                }
+            }
+
+            if (panel.Parent == this && panel.ToolTipText.Length > 0)
+            {
+                int border = SystemInformation.Border3DSize.Width;
+                ControlToolTip.Tool t = tooltips.GetTool(panel);
+                if (t == null)
+                {
+                    t = new ControlToolTip.Tool();
+                }
+
+                t.text = panel.ToolTipText;
+                t.rect = new Rectangle(panel.Right - panel.Width + border, 0, panel.Width - border, Height);
+                tooltips.SetTool(panel, t);
+            }
+            else
+            {
+                tooltips.SetTool(panel, null);
+            }
+        }
+
+        private void UpdatePanelIndex()
+        {
+            int length = panels.Count;
+            for (int i = 0; i < length; i++)
+            {
+                ((StatusBarPanel)panels[i]).Index = i;
+            }
+        }
+
+        /// <summary>
+        ///  Processes messages for ownerdraw panels.
+        /// </summary>
+        private void WmDrawItem(ref Message m)
+        {
+            NativeMethods.DRAWITEMSTRUCT dis = (NativeMethods.DRAWITEMSTRUCT)m.GetLParam(typeof(NativeMethods.DRAWITEMSTRUCT));
+
+            int length = panels.Count;
+            if (dis.itemID < 0 || dis.itemID >= length)
+            {
+                Debug.Fail("OwnerDraw item out of range");
+            }
+
+            StatusBarPanel panel = (StatusBarPanel)
+                                   panels[dis.itemID];
+
+            Graphics g = Graphics.FromHdcInternal(dis.hDC);
+            Rectangle r = Rectangle.FromLTRB(dis.rcItem.left, dis.rcItem.top, dis.rcItem.right, dis.rcItem.bottom);
+
+            //The itemstate is not defined for a statusbar control
+            OnDrawItem(new StatusBarDrawItemEventArgs(g, Font, r, dis.itemID, DrawItemState.None, panel, ForeColor, BackColor));
+            g.Dispose();
+        }
+
+        private void WmNotifyNMClick(NativeMethods.NMHDR note)
+        {
+            if (!showPanels)
+            {
+                return;
+            }
+
+            int size = panels.Count;
+            int currentOffset = 0;
+            int index = -1;
+            for (int i = 0; i < size; i++)
+            {
+                StatusBarPanel panel = (StatusBarPanel)panels[i];
+                currentOffset += panel.Width;
+                if (lastClick.X < currentOffset)
+                {
+                    // this is where the mouse was clicked.
+                    index = i;
+                    break;
+                }
+            }
+
+            if (index != -1)
+            {
+                MouseButtons button = MouseButtons.Left;
+                int clicks = 0;
+                switch (note.code)
+                {
+                    case NativeMethods.NM_CLICK:
+                        button = MouseButtons.Left;
+                        clicks = 1;
+                        break;
+                    case NativeMethods.NM_RCLICK:
+                        button = MouseButtons.Right;
+                        clicks = 1;
+                        break;
+                    case NativeMethods.NM_DBLCLK:
+                        button = MouseButtons.Left;
+                        clicks = 2;
+                        break;
+                    case NativeMethods.NM_RDBLCLK:
+                        button = MouseButtons.Right;
+                        clicks = 2;
+                        break;
+                }
+
+                Point pt = lastClick;
+                StatusBarPanel panel = (StatusBarPanel)panels[index];
+
+                StatusBarPanelClickEventArgs sbpce = new StatusBarPanelClickEventArgs(panel,
+                                                                                      button, clicks, pt.X, pt.Y);
+                OnPanelClick(sbpce);
+            }
+        }
+
+        private void WmNCHitTest(ref Message m)
+        {
+            int x = NativeMethods.Util.LOWORD(m.LParam);
+            Rectangle bounds = Bounds;
+            bool callSuper = true;
+
+            // The default implementation of the statusbar
+            // will let you size the form when it is docked on the bottom,
+            // but when it is anywhere else, the statusbar will be resized.
+            // to prevent that we provide a little bit a sanity to only
+            // allow resizing, when it would resize the form.
+            if (x > bounds.X + bounds.Width - SizeGripWidth)
+            {
+                Control parent = ParentInternal;
+                if (parent != null && parent is Form)
+                {
+                    FormBorderStyle bs = ((Form)parent).FormBorderStyle;
+
+                    if (bs != FormBorderStyle.Sizable
+                        && bs != FormBorderStyle.SizableToolWindow)
+                    {
+                        callSuper = false;
+                    }
+
+                    if (!((Form)parent).TopLevel
+                        || Dock != DockStyle.Bottom)
+                    {
+
+                        callSuper = false;
+                    }
+
+                    if (callSuper)
+                    {
+                        ControlCollection children = parent.Controls;
+                        int c = children.Count;
+                        for (int i = 0; i < c; i++)
+                        {
+                            Control ctl = children[i];
+                            if (ctl != this && ctl.Dock == DockStyle.Bottom)
+                            {
+                                if (ctl.Top > Top)
+                                {
+                                    callSuper = false;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    callSuper = false;
+                }
+            }
+
+            if (callSuper)
+            {
+                base.WndProc(ref m);
+            }
+            else
+            {
+                m.Result = (IntPtr)NativeMethods.HTCLIENT;
+            }
+        }
+
+        /// <summary>
+        ///  Base wndProc. All messages are sent to wndProc after getting filtered through
+        ///  the preProcessMessage function. Inheriting controls should call base.wndProc
+        ///  for any messages that they don't handle.
+        /// </summary>
+        protected override void WndProc(ref Message m)
+        {
+            switch (m.Msg)
+            {
+                case WindowMessages.WM_NCHITTEST:
+                    WmNCHitTest(ref m);
+                    break;
+                case WindowMessages.WM_REFLECT + WindowMessages.WM_DRAWITEM:
+                    WmDrawItem(ref m);
+                    break;
+                case WindowMessages.WM_NOTIFY:
+                case WindowMessages.WM_NOTIFY + WindowMessages.WM_REFLECT:
+                    NativeMethods.NMHDR note = (NativeMethods.NMHDR)m.GetLParam(typeof(NativeMethods.NMHDR));
+                    switch (note.code)
+                    {
+                        case NativeMethods.NM_CLICK:
+                        case NativeMethods.NM_RCLICK:
+                        case NativeMethods.NM_DBLCLK:
+                        case NativeMethods.NM_RDBLCLK:
+                            WmNotifyNMClick(note);
+                            break;
+                        default:
+                            base.WndProc(ref m);
+                            break;
+                    }
+
+                    break;
+
+                default:
+                    base.WndProc(ref m);
+                    break;
+            }
+        }
+
+        /// <summary>
+        ///  The collection of StatusBarPanels that the StatusBar manages.
+        ///  event.
+        /// </summary>
+        [ListBindable(false)]
+        public class StatusBarPanelCollection : IList
+        {
+            private readonly StatusBar owner;
+
+            // A caching mechanism for key accessor
+            // We use an index here rather than control so that we don't have lifetime
+            // issues by holding on to extra references.
+            private int lastAccessedIndex = -1;
+
+            /// <summary>
+            ///  Constructor for the StatusBarPanelCollection class
+            /// </summary>
+            public StatusBarPanelCollection(StatusBar owner)
+            {
+                this.owner = owner;
+            }
+
+            /// <summary>
+            ///  This method will return an individual StatusBarPanel with the appropriate index.
+            /// </summary>
+            public virtual StatusBarPanel this[int index]
+            {
+                get
+                {
+                    return (StatusBarPanel)owner.panels[index];
+                }
+                set
+                {
+
+                    if (value == null)
+                    {
+                        throw new ArgumentNullException(nameof(StatusBarPanel));
+                    }
+
+                    owner.layoutDirty = true;
+
+                    if (value.Parent != null)
+                    {
+                        throw new ArgumentException(SR.ObjectHasParent, "value");
+                    }
+
+                    int length = owner.panels.Count;
+
+                    if (index < 0 || index >= length)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                    }
+
+                    StatusBarPanel oldPanel = (StatusBarPanel)owner.panels[index];
+                    oldPanel.ParentInternal = null;
+                    value.ParentInternal = owner;
+                    if (value.AutoSize == StatusBarPanelAutoSize.Contents)
+                    {
+                        value.Width = value.GetContentsWidth(true);
+                    }
+
+                    owner.panels[index] = value;
+                    value.Index = index;
+
+                    if (owner.ArePanelsRealized())
+                    {
+                        owner.PerformLayout();
+                        value.Realize();
+                    }
+                }
+            }
+
+            object IList.this[int index]
+            {
+                get
+                {
+                    return this[index];
+                }
+                set
+                {
+                    if (value is StatusBarPanel)
+                    {
+                        this[index] = (StatusBarPanel)value;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(SR.StatusBarBadStatusBarPanel, "value");
+                    }
+                }
+            }
+
+            /// <summary>
+            ///  Retrieves the child control with the specified key.
+            /// </summary>
+            public virtual StatusBarPanel this[string key]
+            {
+                get
+                {
+                    // We do not support null and empty string as valid keys.
+                    if (string.IsNullOrEmpty(key))
+                    {
+                        return null;
+                    }
+
+                    // Search for the key in our collection
+                    int index = IndexOfKey(key);
+                    if (IsValidIndex(index))
+                    {
+                        return this[index];
+                    }
+                    else
+                    {
+                        return null;
+                    }
+
+                }
+            }
+
+            /// <summary>
+            ///  Returns an integer representing the number of StatusBarPanels
+            ///  in this collection.
+            /// </summary>
+            [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+            public int Count
+            {
+                get
+                {
+                    return owner.panels.Count;
+                }
+            }
+
+            object ICollection.SyncRoot
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            bool ICollection.IsSynchronized
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            bool IList.IsFixedSize
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            public bool IsReadOnly
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Adds a StatusBarPanel to the collection.
+            /// </summary>
+            public virtual StatusBarPanel Add(string text)
+            {
+                StatusBarPanel panel = new StatusBarPanel
+                {
+                    Text = text
+                };
+                Add(panel);
+                return panel;
+            }
+
+            /// <summary>
+            ///  Adds a StatusBarPanel to the collection.
+            /// </summary>
+            public virtual int Add(StatusBarPanel value)
+            {
+                int index = owner.panels.Count;
+                Insert(index, value);
+                return index;
+            }
+
+            int IList.Add(object value)
+            {
+                if (value is StatusBarPanel)
+                {
+                    return Add((StatusBarPanel)value);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.StatusBarBadStatusBarPanel, "value");
+                }
+            }
+
+            public virtual void AddRange(StatusBarPanel[] panels)
+            {
+                if (panels == null)
+                {
+                    throw new ArgumentNullException(nameof(panels));
+                }
+
+                foreach (StatusBarPanel panel in panels)
+                {
+                    Add(panel);
+                }
+            }
+
+            public bool Contains(StatusBarPanel panel)
+            {
+                return IndexOf(panel) != -1;
+            }
+
+            bool IList.Contains(object panel)
+            {
+                if (panel is StatusBarPanel)
+                {
+                    return Contains((StatusBarPanel)panel);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Returns true if the collection contains an item with the specified key, false otherwise.
+            /// </summary>
+            public virtual bool ContainsKey(string key)
+            {
+                return IsValidIndex(IndexOfKey(key));
+            }
+
+            public int IndexOf(StatusBarPanel panel)
+            {
+                for (int index = 0; index < Count; ++index)
+                {
+                    if (this[index] == panel)
+                    {
+                        return index;
+                    }
+                }
+
+                return -1;
+            }
+
+            int IList.IndexOf(object panel)
+            {
+                if (panel is StatusBarPanel)
+                {
+                    return IndexOf((StatusBarPanel)panel);
+                }
+                else
+                {
+                    return -1;
+                }
+            }
+
+            /// <summary>
+            ///  The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
+            /// </summary>
+            public virtual int IndexOfKey(string key)
+            {
+                // Step 0 - Arg validation
+                if (string.IsNullOrEmpty(key))
+                {
+                    return -1; // we dont support empty or null keys.
+                }
+
+                // step 1 - check the last cached item
+                if (IsValidIndex(lastAccessedIndex))
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[lastAccessedIndex].Name, key, /* ignoreCase = */ true))
+                    {
+                        return lastAccessedIndex;
+                    }
+                }
+
+                // step 2 - search for the item
+                for (int i = 0; i < Count; i++)
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true))
+                    {
+                        lastAccessedIndex = i;
+                        return i;
+                    }
+                }
+
+                // step 3 - we didn't find it.  Invalidate the last accessed index and return -1.
+                lastAccessedIndex = -1;
+                return -1;
+            }
+
+            /// <summary>
+            ///  Inserts a StatusBarPanel in the collection.
+            /// </summary>
+            public virtual void Insert(int index, StatusBarPanel value)
+            {
+
+                //check for the value not to be null
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+
+                //end check
+
+                owner.layoutDirty = true;
+                if (value.Parent != owner && value.Parent != null)
+                {
+                    throw new ArgumentException(SR.ObjectHasParent, "value");
+                }
+
+                int length = owner.panels.Count;
+
+                if (index < 0 || index > length)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                }
+
+                value.ParentInternal = owner;
+
+                switch (value.AutoSize)
+                {
+                    case StatusBarPanelAutoSize.None:
+                    case StatusBarPanelAutoSize.Spring:
+                        break;
+                    case StatusBarPanelAutoSize.Contents:
+                        value.Width = value.GetContentsWidth(true);
+                        break;
+                }
+
+                owner.panels.Insert(index, value);
+                owner.UpdatePanelIndex();
+
+                owner.ForcePanelUpdate();
+            }
+
+            void IList.Insert(int index, object value)
+            {
+                if (value is StatusBarPanel)
+                {
+                    Insert(index, (StatusBarPanel)value);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.StatusBarBadStatusBarPanel, "value");
+                }
+            }
+
+            /// <summary>
+            ///  Determines if the index is valid for the collection.
+            /// </summary>
+            private bool IsValidIndex(int index)
+            {
+                return ((index >= 0) && (index < Count));
+            }
+
+            /// <summary>
+            ///  Removes all the StatusBarPanels in the collection.
+            /// </summary>
+            public virtual void Clear()
+            {
+                owner.RemoveAllPanelsWithoutUpdate();
+                owner.PerformLayout();
+
+            }
+
+            /// <summary>
+            ///  Removes an individual StatusBarPanel in the collection.
+            /// </summary>
+            public virtual void Remove(StatusBarPanel value)
+            {
+
+                //check for the value not to be null
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(StatusBarPanel));
+                }
+
+                if (value.Parent != owner)
+                {
+                    return;
+                }
+
+                RemoveAt(value.Index);
+            }
+
+            void IList.Remove(object value)
+            {
+                if (value is StatusBarPanel)
+                {
+                    Remove((StatusBarPanel)value);
+                }
+            }
+
+            /// <summary>
+            ///  Removes an individual StatusBarPanel in the collection at the given index.
+            /// </summary>
+            public virtual void RemoveAt(int index)
+            {
+                int length = Count;
+                if (index < 0 || index >= length)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                }
+
+                // clear any tooltip
+                //
+                StatusBarPanel panel = (StatusBarPanel)owner.panels[index];
+
+                owner.panels.RemoveAt(index);
+                panel.ParentInternal = null;
+
+                // this will cause the panels tooltip to be removed since it's no longer a child
+                // of this StatusBar.
+                owner.UpdateTooltip(panel);
+
+                // We must reindex the panels after a removal...
+                owner.UpdatePanelIndex();
+                owner.ForcePanelUpdate();
+            }
+
+            /// <summary>
+            ///  Removes the child control with the specified key.
+            /// </summary>
+            public virtual void RemoveByKey(string key)
+            {
+                int index = IndexOfKey(key);
+                if (IsValidIndex(index))
+                {
+                    RemoveAt(index);
+                }
+            }
+
+            void ICollection.CopyTo(Array dest, int index)
+            {
+                owner.panels.CopyTo(dest, index);
+            }
+
+            /// <summary>
+            ///  Returns the Enumerator for this collection.
+            /// </summary>
+            public IEnumerator GetEnumerator()
+            {
+                if (owner.panels != null)
+                {
+                    return owner.panels.GetEnumerator();
+                }
+                else
+                {
+                    return Array.Empty<StatusBarPanel>().GetEnumerator();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  This is a tooltip control that provides tips for a single
+        ///  control. Each "tool" region is defined by a rectangle and
+        ///  the string that should be displayed. This implementation
+        ///  is based on System.Windows.Forms.ToolTip, but this control
+        ///  is lighter weight and provides less functionality... however
+        ///  this control binds to rectangular regions, instead of
+        ///  full controls.
+        /// </summary>
+        private class ControlToolTip : IHandle<HWND>
+        {
+            public class Tool
+            {
+                public Rectangle rect = Rectangle.Empty;
+                public string text;
+                internal IntPtr id = new IntPtr(-1);
+            }
+
+            private readonly Hashtable tools = new Hashtable();
+            private readonly ToolTipNativeWindow window = null;
+            private readonly Control parent = null;
+            private int nextId = 0;
+
+            /// <summary>
+            ///  Creates a new ControlToolTip.
+            /// </summary>
+            public ControlToolTip(Control parent)
+            {
+                window = new ToolTipNativeWindow(this);
+                this.parent = parent;
+            }
+
+            /// <summary>
+            ///  Returns the createParams to create the window.
+            /// </summary>
+            protected CreateParams CreateParams
+            {
+                get
+                {
+                    NativeMethods.INITCOMMONCONTROLSEX icc = new NativeMethods.INITCOMMONCONTROLSEX
+                    {
+                        dwICC = NativeMethods.ICC_TAB_CLASSES
+                    };
+                    SafeNativeMethods.InitCommonControlsEx(icc);
+                    CreateParams cp = new CreateParams
+                    {
+                        Parent = IntPtr.Zero,
+                        ClassName = NativeMethods.TOOLTIPS_CLASS
+                    };
+                    cp.Style |= NativeMethods.TTS_ALWAYSTIP;
+                    cp.ExStyle = 0;
+                    cp.Caption = null;
+                    return cp;
+                }
+            }
+
+            public HWND Handle
+            {
+                get
+                {
+                    if (window.Handle == IntPtr.Zero)
+                    {
+                        CreateHandle();
+                    }
+
+                    return (HWND)window.Handle;
+                }
+            }
+
+            private bool IsHandleCreated
+            {
+                get { return window.Handle != IntPtr.Zero; }
+            }
+
+            private void AssignId(Tool tool)
+            {
+                tool.id = (IntPtr)nextId;
+                nextId++;
+            }
+
+            /// <summary>
+            ///  Sets the tool for the specified key. Keep in mind
+            ///  that as soon as setTool is called, the handle for
+            ///  the ControlToolTip is created, and the handle for
+            ///  the parent control is also created. If the parent
+            ///  handle is recreated in the future, all tools must
+            ///  be re-added. The old tool for the specified key
+            ///  will be removed. Passing null in for the
+            ///  tool parameter will result in the tool
+            ///  region being removed.
+            /// </summary>
+            public void SetTool(object key, Tool tool)
+            {
+                bool remove = false;
+                bool add = false;
+                bool update = false;
+
+                Tool toRemove = null;
+                if (tools.ContainsKey(key))
+                {
+                    toRemove = (Tool)tools[key];
+                }
+
+                if (toRemove != null)
+                {
+                    remove = true;
+                }
+
+                if (tool != null)
+                {
+                    add = true;
+                }
+
+                if (tool != null && toRemove != null
+                    && tool.id == toRemove.id)
+                {
+                    update = true;
+                }
+
+                if (update)
+                {
+                    UpdateTool(tool);
+                }
+                else
+                {
+                    if (remove)
+                    {
+                        RemoveTool(toRemove);
+                    }
+
+                    if (add)
+                    {
+                        AddTool(tool);
+                    }
+                }
+
+                if (tool != null)
+                {
+                    tools[key] = tool;
+                }
+                else
+                {
+                    tools.Remove(key);
+                }
+
+            }
+
+            /// <summary>
+            ///  Returns the tool associated with the specified key,
+            ///  or null if there is no area.
+            /// </summary>
+            public Tool GetTool(object key)
+            {
+                return (Tool)tools[key];
+            }
+
+            private void AddTool(Tool tool)
+            {
+                if (tool != null && tool.text != null && tool.text.Length > 0)
+                {
+                    StatusBar p = (StatusBar)parent;
+
+                    ComCtl32.ToolInfoWrapper<Control> info = GetTOOLINFO(tool);
+                    if (info.SendMessage(p.ToolTipSet ? (IHandle<HWND>)p.mainToolTip : this, WindowMessages.TTM_ADDTOOLW) == IntPtr.Zero)
+                    {
+                        throw new InvalidOperationException(SR.StatusBarAddFailed);
+                    }
+                }
+            }
+
+            private void RemoveTool(Tool tool)
+            {
+                if (tool != null && tool.text != null && tool.text.Length > 0 && (int)tool.id >= 0)
+                {
+                    ComCtl32.ToolInfoWrapper<Control> info = GetMinTOOLINFO(tool);
+                    info.SendMessage(this, WindowMessages.TTM_DELTOOLW);
+                }
+            }
+
+            private void UpdateTool(Tool tool)
+            {
+                if (tool != null && tool.text != null && tool.text.Length > 0 && (int)tool.id >= 0)
+                {
+                    ComCtl32.ToolInfoWrapper<Control> info = GetTOOLINFO(tool);
+                    info.SendMessage(this, WindowMessages.TTM_SETTOOLINFOW);
+                }
+            }
+
+            /// <summary>
+            ///  Creates the handle for the control.
+            /// </summary>
+            protected void CreateHandle()
+            {
+                if (IsHandleCreated)
+                {
+                    return;
+                }
+
+                window.CreateHandle(CreateParams);
+                SafeNativeMethods.SetWindowPos(new HandleRef(this, Handle), NativeMethods.HWND_TOPMOST,
+                                     0, 0, 0, 0,
+                                     NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOSIZE |
+                                     NativeMethods.SWP_NOACTIVATE);
+
+                // Setting the max width has the added benefit of enabling multiline tool tips
+                User32.SendMessageW(this, (User32.WM)WindowMessages.TTM_SETMAXTIPWIDTH, IntPtr.Zero, (IntPtr)SystemInformation.MaxWindowTrackSize.Width);
+            }
+
+            /// <summary>
+            ///  Destroys the handle for this control.
+            /// </summary>
+            protected void DestroyHandle()
+            {
+                if (IsHandleCreated)
+                {
+                    window.DestroyHandle();
+                    tools.Clear();
+                }
+            }
+
+            /// <summary>
+            ///  Disposes of the component.  Call dispose when the component is no longer needed.
+            ///  This method removes the component from its container (if the component has a site)
+            ///  and triggers the dispose event.
+            /// </summary>
+            public void Dispose()
+            {
+                DestroyHandle();
+            }
+
+            /// <summary>
+            ///  Returns a new instance of the TOOLINFO_T structure with the minimum
+            ///  required data to uniquely identify a region. This is used primarily
+            ///  for delete operations. NOTE: This cannot force the creation of a handle.
+            /// </summary>
+            private ComCtl32.ToolInfoWrapper<Control> GetMinTOOLINFO(Tool tool)
+            {
+                if ((int)tool.id < 0)
+                {
+                    AssignId(tool);
+                }
+
+                return new ComCtl32.ToolInfoWrapper<Control>(
+                    parent,
+                    id: parent is StatusBar sb ? sb.Handle : tool.id);
+            }
+
+            /// <summary>
+            ///  Returns a detailed TOOLINFO_T structure that represents the specified
+            ///  region. NOTE: This may force the creation of a handle.
+            /// </summary>
+            private ComCtl32.ToolInfoWrapper<Control> GetTOOLINFO(Tool tool)
+            {
+                ComCtl32.ToolInfoWrapper<Control> ti = GetMinTOOLINFO(tool);
+                ti.Info.uFlags |= (TOOLTIP_FLAGS)(ComCtl32.TTF.TRANSPARENT | ComCtl32.TTF.SUBCLASS);
+
+                // RightToLeft reading order
+                Control richParent = parent;
+                if (richParent != null && richParent.RightToLeft == RightToLeft.Yes)
+                {
+                    ti.Info.uFlags |= (TOOLTIP_FLAGS)ComCtl32.TTF.RTLREADING;
+                }
+
+                ti.Text = tool.text;
+                ti.Info.rect = tool.rect;
+                return ti;
+            }
+
+            ~ControlToolTip()
+            {
+                DestroyHandle();
+            }
+
+            protected void WndProc(ref Message msg)
+            {
+                switch (msg.Msg)
+                {
+                    case WindowMessages.WM_SETFOCUS:
+                        return;
+                    default:
+                        window.DefWndProc(ref msg);
+                        break;
+                }
+            }
+
+            private class ToolTipNativeWindow : NativeWindow
+            {
+                readonly ControlToolTip control;
+
+                internal ToolTipNativeWindow(ControlToolTip control)
+                {
+                    this.control = control;
+                }
+
+                protected override void WndProc(ref Message m)
+                {
+                    if (control != null)
+                    {
+                        control.WndProc(ref m);
+                    }
+                }
+            }
+        }
+    }
+}
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventArgs.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventArgs.cs
new file mode 100644
index 00000000000..5d0e2ff0066
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventArgs.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Drawing;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Provides data for the <see cref='StatusBar.OnDrawItem'/>
+    ///  event.
+    /// </summary>
+    public class StatusBarDrawItemEventArgs : DrawItemEventArgs
+    {
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='StatusBarDrawItemEventArgs'/>
+        ///  class.
+        /// </summary>
+        public StatusBarDrawItemEventArgs(Graphics g, Font font, Rectangle r, int itemId,
+            DrawItemState itemState, StatusBarPanel panel)
+            : base(g, font, r, itemId, itemState)
+        {
+            Panel = panel;
+        }
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='StatusBarDrawItemEventArgs'/>
+        ///  class using the Forecolor and Backcolor.
+        /// </summary>
+        public StatusBarDrawItemEventArgs(Graphics g, Font font, Rectangle r, int itemId,
+            DrawItemState itemState, StatusBarPanel panel,
+            Color foreColor, Color backColor)
+            : base(g, font, r, itemId, itemState, foreColor, backColor)
+        {
+            Panel = panel;
+        }
+
+        /// <summary>
+        ///  Specifies the <see cref='StatusBarPanel'/> to draw.
+        /// </summary>
+        public StatusBarPanel Panel { get; }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventHandler.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventHandler.cs
new file mode 100644
index 00000000000..dea78084975
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarDrawItemEventHandler.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a method that will handle the <see cref='StatusBar.OnDrawItem'/>
+    ///  event of a <see cref='StatusBar'/>.
+    /// </summary>
+    public delegate void StatusBarDrawItemEventHandler(object sender, StatusBarDrawItemEventArgs sbdevent);
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanel.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanel.cs
new file mode 100644
index 00000000000..224dc8d9285
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanel.cs
@@ -0,0 +1,735 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Stores the <see cref='StatusBar'/>
+    ///  control panel's information.
+    /// </summary>
+    [
+    ToolboxItem(false),
+    DesignTimeVisible(false),
+    DefaultProperty(nameof(Text))
+    ]
+    public class StatusBarPanel : Component, ISupportInitialize
+    {
+        private const int DEFAULTWIDTH = 100;
+        private const int DEFAULTMINWIDTH = 10;
+        private const int PANELTEXTINSET = 3;
+        private const int PANELGAP = 2;
+
+        private string text = string.Empty;
+        private string name = string.Empty;
+        private string toolTipText = string.Empty;
+        private Icon icon = null;
+
+        private HorizontalAlignment alignment = HorizontalAlignment.Left;
+        private StatusBarPanelBorderStyle borderStyle = System.Windows.Forms.StatusBarPanelBorderStyle.Sunken;
+        private StatusBarPanelStyle style = StatusBarPanelStyle.Text;
+
+        // these are package scope so the parent can get at them.
+        //
+        private StatusBar parent = null;
+        private int width = DEFAULTWIDTH;
+        private int right = 0;
+        private int minWidth = DEFAULTMINWIDTH;
+        private int index = 0;
+        private StatusBarPanelAutoSize autoSize = StatusBarPanelAutoSize.None;
+
+        private bool initializing = false;
+
+        private object userData;
+
+        /// <summary>
+        ///  Initializes a new default instance of the <see cref='StatusBarPanel'/> class.
+        /// </summary>
+        public StatusBarPanel()
+        {
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='Alignment'/>
+        ///  property.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(HorizontalAlignment.Left),
+        Localizable(true),
+        SRDescription(nameof(SR.StatusBarPanelAlignmentDescr))
+        ]
+        public HorizontalAlignment Alignment
+        {
+            get
+            {
+                return alignment;
+            }
+
+            set
+            {
+                //valid values are 0x0 to 0x2
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)HorizontalAlignment.Left, (int)HorizontalAlignment.Center))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(HorizontalAlignment));
+                }
+
+                if (alignment != value)
+                {
+                    alignment = value;
+                    Realize();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='AutoSize'/>
+        ///  property.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(StatusBarPanelAutoSize.None),
+        RefreshProperties(RefreshProperties.All),
+        SRDescription(nameof(SR.StatusBarPanelAutoSizeDescr))
+        ]
+        public StatusBarPanelAutoSize AutoSize
+        {
+            get
+            {
+                return autoSize;
+            }
+
+            set
+            {
+                //valid values are 0x1 to 0x3
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)StatusBarPanelAutoSize.None, (int)StatusBarPanelAutoSize.Contents))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(StatusBarPanelAutoSize));
+                }
+
+                if (autoSize != value)
+                {
+                    autoSize = value;
+                    UpdateSize();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='BorderStyle'/>
+        ///
+        ///  property.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(System.Windows.Forms.StatusBarPanelBorderStyle.Sunken),
+        DispId(NativeMethods.ActiveX.DISPID_BORDERSTYLE),
+        SRDescription(nameof(SR.StatusBarPanelBorderStyleDescr))
+        ]
+        public StatusBarPanelBorderStyle BorderStyle
+        {
+            get
+            {
+                return borderStyle;
+            }
+
+            set
+            {
+                //valid values are 0x1 to 0x3
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)StatusBarPanelBorderStyle.None, (int)StatusBarPanelBorderStyle.Sunken))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(StatusBarPanelBorderStyle));
+                }
+
+                if (borderStyle != value)
+                {
+                    borderStyle = value;
+                    Realize();
+                    if (Created)
+                    {
+                        parent.Invalidate();
+                    }
+                }
+            }
+        }
+
+        internal bool Created
+        {
+            get
+            {
+                return parent != null && parent.ArePanelsRealized();
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the <see cref='Icon'/>
+        ///  property.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(null),
+        Localizable(true),
+        SRDescription(nameof(SR.StatusBarPanelIconDescr))
+        ]
+        public Icon Icon
+        {
+            get
+            {
+                // unfortunately we have no way of getting the icon from the control.
+                return icon;
+            }
+
+            set
+            {
+
+                if (value != null && (((Icon)value).Height > SystemInformation.SmallIconSize.Height || ((Icon)value).Width > SystemInformation.SmallIconSize.Width))
+                {
+                    icon = new Icon(value, SystemInformation.SmallIconSize);
+                }
+                else
+                {
+                    icon = value;
+                }
+
+                if (Created)
+                {
+                    IntPtr handle = (icon == null) ? IntPtr.Zero : icon.Handle;
+                    parent.SendMessage(NativeMethods.SB_SETICON, (IntPtr)GetIndex(), handle);
+
+                }
+
+                UpdateSize();
+                if (Created)
+                {
+                    parent.Invalidate();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Expose index internally
+        /// </summary>
+        internal int Index
+        {
+            get
+            {
+                return index;
+            }
+            set
+            {
+                index = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the minimum width the <see cref='StatusBarPanel'/> can be within the <see cref='StatusBar'/>
+        ///  control.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(DEFAULTMINWIDTH),
+        Localizable(true),
+        RefreshProperties(RefreshProperties.All),
+        SRDescription(nameof(SR.StatusBarPanelMinWidthDescr))
+        ]
+        public int MinWidth
+        {
+            get
+            {
+                return minWidth;
+            }
+            set
+            {
+                if (value < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value, string.Format(SR.InvalidLowBoundArgumentEx, nameof(MinWidth), value, 0));
+                }
+
+                if (value != minWidth)
+                {
+                    minWidth = value;
+
+                    UpdateSize();
+                    if (minWidth > Width)
+                    {
+                        Width = value;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the name of the panel.
+        /// </summary>
+        [
+            SRCategory(nameof(SR.CatAppearance)),
+            Localizable(true),
+            SRDescription(nameof(SR.StatusBarPanelNameDescr))
+            ]
+        public string Name
+        {
+            get
+            {
+                return WindowsFormsUtils.GetComponentName(this, name);
+            }
+            set
+            {
+                name = value;
+                if (Site != null)
+                {
+                    Site.Name = name;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Represents the <see cref='StatusBar'/>
+        ///  control which hosts the
+        ///  panel.
+        /// </summary>
+        [Browsable(false)]
+        public StatusBar Parent
+        {
+            get
+            {
+                return parent;
+            }
+        }
+
+        /// <summary>
+        ///  Expose a direct setter for parent internally
+        /// </summary>
+        internal StatusBar ParentInternal
+        {
+            set
+            {
+                parent = value;
+            }
+        }
+
+        /// <summary>
+        ///  Expose right internally
+        /// </summary>
+        internal int Right
+        {
+            get
+            {
+                return right;
+            }
+            set
+            {
+                right = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the style of the panel.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(StatusBarPanelStyle.Text),
+        SRDescription(nameof(SR.StatusBarPanelStyleDescr))
+        ]
+        public StatusBarPanelStyle Style
+        {
+            get { return style; }
+            set
+            {
+                //valid values are 0x1 to 0x2
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)StatusBarPanelStyle.Text, (int)StatusBarPanelStyle.OwnerDraw))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(StatusBarPanelStyle));
+                }
+
+                if (style != value)
+                {
+                    style = value;
+                    Realize();
+                    if (Created)
+                    {
+                        parent.Invalidate();
+                    }
+                }
+            }
+        }
+
+        [
+        SRCategory(nameof(SR.CatData)),
+        Localizable(false),
+        Bindable(true),
+        SRDescription(nameof(SR.ControlTagDescr)),
+        DefaultValue(null),
+        TypeConverter(typeof(StringConverter)),
+        ]
+        public object Tag
+        {
+            get
+            {
+                return userData;
+            }
+            set
+            {
+                userData = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the text of the panel.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        Localizable(true),
+        DefaultValue(""),
+        SRDescription(nameof(SR.StatusBarPanelTextDescr))
+        ]
+        public string Text
+        {
+            get
+            {
+                if (text == null)
+                {
+                    return "";
+                }
+                else
+                {
+                    return text;
+                }
+            }
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (!Text.Equals(value))
+                {
+
+                    if (value.Length == 0)
+                    {
+                        text = null;
+                    }
+                    else
+                    {
+                        text = value;
+                    }
+
+                    Realize();
+                    UpdateSize();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets the panel's tool tip text.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        Localizable(true),
+        DefaultValue(""),
+        SRDescription(nameof(SR.StatusBarPanelToolTipTextDescr))
+        ]
+        public string ToolTipText
+        {
+            get
+            {
+                if (toolTipText == null)
+                {
+                    return "";
+                }
+                else
+                {
+                    return toolTipText;
+                }
+            }
+            set
+            {
+                if (value == null)
+                {
+                    value = string.Empty;
+                }
+
+                if (!ToolTipText.Equals(value))
+                {
+
+                    if (value.Length == 0)
+                    {
+                        toolTipText = null;
+                    }
+                    else
+                    {
+                        toolTipText = value;
+                    }
+
+                    if (Created)
+                    {
+                        parent.UpdateTooltip(this);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets the width of the <see cref='StatusBarPanel'/> within the <see cref='StatusBar'/>
+        ///  control.
+        /// </summary>
+        [
+        Localizable(true),
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(DEFAULTWIDTH),
+        SRDescription(nameof(SR.StatusBarPanelWidthDescr))
+        ]
+        public int Width
+        {
+            get
+            {
+                return width;
+            }
+            set
+            {
+                if (!initializing && value < minWidth)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(Width), SR.WidthGreaterThanMinWidth);
+                }
+
+                width = value;
+                UpdateSize();
+            }
+        }
+
+        /// <summary>
+        ///  Handles tasks required when the control is being initialized.
+        /// </summary>
+        public void BeginInit()
+        {
+            initializing = true;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (parent != null)
+                {
+                    int index = GetIndex();
+                    if (index != -1)
+                    {
+                        parent.Panels.RemoveAt(index);
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Called when initialization of the control is complete.
+        /// </summary>
+        public void EndInit()
+        {
+            initializing = false;
+
+            if (Width < MinWidth)
+            {
+                Width = MinWidth;
+            }
+        }
+
+        /// <summary>
+        ///  Gets the width of the contents of the panel
+        /// </summary>
+        internal int GetContentsWidth(bool newPanel)
+        {
+            string text;
+            if (newPanel)
+            {
+                if (this.text == null)
+                {
+                    text = string.Empty;
+                }
+                else
+                {
+                    text = this.text;
+                }
+            }
+            else
+            {
+                text = Text;
+            }
+
+            Graphics g = parent.CreateGraphicsInternal();
+            Size sz = Size.Ceiling(g.MeasureString(text, parent.Font));
+            if (icon != null)
+            {
+                sz.Width += icon.Size.Width + 5;
+            }
+
+            g.Dispose();
+
+            int width = sz.Width + SystemInformation.BorderSize.Width * 2 + PANELTEXTINSET * 2 + PANELGAP;
+            return Math.Max(width, minWidth);
+        }
+
+        /// <summary>
+        ///  Returns the index of the panel by making the parent control search
+        ///  for it within its list.
+        /// </summary>
+        private int GetIndex()
+        {
+            return index;
+        }
+
+        /// <summary>
+        ///  Sets all the properties for this panel.
+        /// </summary>
+        internal void Realize()
+        {
+            if (Created)
+            {
+                string text;
+                string sendText;
+                int border = 0;
+
+                if (this.text == null)
+                {
+                    text = string.Empty;
+                }
+                else
+                {
+                    text = this.text;
+                }
+
+                HorizontalAlignment align = alignment;
+                // Translate the alignment for Rtl apps
+                //
+                if (parent.RightToLeft == RightToLeft.Yes)
+                {
+                    switch (align)
+                    {
+                        case HorizontalAlignment.Left:
+                            align = HorizontalAlignment.Right;
+                            break;
+                        case HorizontalAlignment.Right:
+                            align = HorizontalAlignment.Left;
+                            break;
+                    }
+                }
+
+                switch (align)
+                {
+                    case HorizontalAlignment.Center:
+                        sendText = "\t" + text;
+                        break;
+                    case HorizontalAlignment.Right:
+                        sendText = "\t\t" + text;
+                        break;
+                    default:
+                        sendText = text;
+                        break;
+                }
+
+                switch (borderStyle)
+                {
+                    case StatusBarPanelBorderStyle.None:
+                        border |= NativeMethods.SBT_NOBORDERS;
+                        break;
+                    case StatusBarPanelBorderStyle.Sunken:
+                        break;
+                    case StatusBarPanelBorderStyle.Raised:
+                        border |= NativeMethods.SBT_POPOUT;
+                        break;
+                }
+
+                switch (style)
+                {
+                    case StatusBarPanelStyle.Text:
+                        break;
+                    case StatusBarPanelStyle.OwnerDraw:
+                        border |= NativeMethods.SBT_OWNERDRAW;
+                        break;
+                }
+
+                int wparam = GetIndex() | border;
+                if (parent.RightToLeft == RightToLeft.Yes)
+                {
+                    wparam |= NativeMethods.SBT_RTLREADING;
+                }
+
+                int result = (int)UnsafeNativeMethods.SendMessage(new HandleRef(parent, parent.Handle), NativeMethods.SB_SETTEXT, (IntPtr)wparam, sendText);
+
+                if (result == 0)
+                {
+                    throw new InvalidOperationException(SR.UnableToSetPanelText);
+                }
+
+                if (icon != null && style != StatusBarPanelStyle.OwnerDraw)
+                {
+                    parent.SendMessage(NativeMethods.SB_SETICON, (IntPtr)GetIndex(), icon.Handle);
+                }
+                else
+                {
+                    parent.SendMessage(NativeMethods.SB_SETICON, (IntPtr)GetIndex(), IntPtr.Zero);
+                }
+
+                if (style == StatusBarPanelStyle.OwnerDraw)
+                {
+                    RECT rect = new RECT();
+                    result = (int)UnsafeNativeMethods.SendMessage(new HandleRef(parent, parent.Handle), NativeMethods.SB_GETRECT, (IntPtr)GetIndex(), ref rect);
+
+                    if (result != 0)
+                    {
+                        parent.Invalidate(Rectangle.FromLTRB(rect.left, rect.top, rect.right, rect.bottom));
+                    }
+                }
+            }
+        }
+
+        private void UpdateSize()
+        {
+            if (autoSize == StatusBarPanelAutoSize.Contents)
+            {
+                ApplyContentSizing();
+            }
+            else
+            {
+                if (Created)
+                {
+                    parent.DirtyLayout();
+                    parent.PerformLayout();
+                }
+            }
+        }
+
+        private void ApplyContentSizing()
+        {
+            if (autoSize == StatusBarPanelAutoSize.Contents &&
+                parent != null)
+            {
+                int newWidth = GetContentsWidth(false);
+                if (newWidth != Width)
+                {
+                    Width = newWidth;
+                    if (Created)
+                    {
+                        parent.DirtyLayout();
+                        parent.PerformLayout();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Retrieves a string that contains information about the
+        ///  panel.
+        /// </summary>
+        public override string ToString()
+        {
+            return "StatusBarPanel: {" + Text + "}";
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelAutoSize.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelAutoSize.cs
new file mode 100644
index 00000000000..329b982eb20
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelAutoSize.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies how a panel on a status bar changes when the status bar resizes.
+    /// </summary>
+    public enum StatusBarPanelAutoSize
+    {
+        /// <summary>
+        ///  The panel does not change its size when the status bar resizes.
+        /// </summary>
+        None = 1,
+
+        /// <summary>
+        ///  The panel shares the available status bar space (the space not taken
+        ///  up by panels with the <see cref='None'/> and <see cref='Contents'/>
+        ///  settings) with other panels that have the <see cref='Spring'/> setting.
+        /// </summary>
+        Spring = 2,
+
+        /// <summary>
+        ///  The width of the panel is determined by its contents.
+        /// </summary>
+        Contents = 3,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelBorderStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelBorderStyle.cs
new file mode 100644
index 00000000000..d339f8f2d99
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelBorderStyle.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the border style of a panel on the <see cref='StatusBar'/>.
+    /// </summary>
+    public enum StatusBarPanelBorderStyle
+    {
+        /// <summary>
+        ///  No border.
+        /// </summary>
+        None = 1,
+
+        /// <summary>
+        ///  A raised border.
+        /// </summary>
+        Raised = 2,
+
+        /// <summary>
+        ///  A sunken border.
+        /// </summary>
+        Sunken = 3,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventArgs.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventArgs.cs
new file mode 100644
index 00000000000..bc7de6d276d
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventArgs.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Provides data for the <see cref='StatusBar.OnPanelClick'/>
+    ///  event.
+    /// </summary>
+    public class StatusBarPanelClickEventArgs : MouseEventArgs
+    {
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='StatusBarPanelClickEventArgs'/>
+        ///  class.
+        /// </summary>
+        public StatusBarPanelClickEventArgs(StatusBarPanel statusBarPanel, MouseButtons button, int clicks, int x, int y) : base(button, clicks, x, y, 0)
+        {
+            StatusBarPanel = statusBarPanel;
+        }
+
+        /// <summary>
+        ///  Specifies the <see cref='Forms.StatusBarPanel'/> that represents the clicked panel.
+        /// </summary>
+        public StatusBarPanel StatusBarPanel { get; }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventHandler.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventHandler.cs
new file mode 100644
index 00000000000..c20ea1a5a81
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelClickEventHandler.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a method that will handle the <see cref='StatusBar.OnPanelClick'/>
+    ///  event of a <see cref='StatusBar'/>.
+    /// </summary>
+    public delegate void StatusBarPanelClickEventHandler(object sender, StatusBarPanelClickEventArgs e);
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelStyle.cs
new file mode 100644
index 00000000000..577bd23650f
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/StatusBarPanelStyle.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies whether a panel on a status bar is owner drawn or system drawn.
+    /// </summary>
+    public enum StatusBarPanelStyle
+    {
+        /// <summary>
+        ///  The panel is drawn by the system.
+        /// </summary>
+        Text = 1,
+
+        /// <summary>
+        ///  The panel is drawn by the owner.
+        /// </summary>
+        OwnerDraw = 2,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/TabControl.cs b/src/System.Windows.Forms/src/System/Windows/Forms/TabControl.cs
index f4d034a0a4c..9752d11e556 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/TabControl.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/TabControl.cs
@@ -9,6 +9,7 @@
 using System.Windows.Forms.Layout;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
@@ -1968,7 +1969,14 @@ private bool WmSelChange()
             if (IsAccessibilityObjectCreated && SelectedTab?.ParentInternal is TabControl)
             {
                 SelectedTab.TabAccessibilityObject.RaiseAutomationEvent(UiaCore.UIA.SelectionItem_ElementSelectedEventId);
-                BeginInvoke((MethodInvoker)(() => SelectedTab.TabAccessibilityObject.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId)));
+                BeginInvoke((MethodInvoker)(() =>
+                {
+                    if (IsAccessibilityObjectCreated && SelectedTab?.ParentInternal is TabControl &&
+                         !SelectedTab.IsDisposed && SelectedTab.TabAccessibilityObject is not null)
+                    {
+                        SelectedTab.TabAccessibilityObject.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
+                    }
+                }));
             }
         }
         else
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/TextRenderer.cs b/src/System.Windows.Forms/src/System/Windows/Forms/TextRenderer.cs
index 7a0e7b69ba4..5704b6ab95e 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/TextRenderer.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/TextRenderer.cs
@@ -630,7 +630,7 @@ internal static ApplyGraphicsProperties GetApplyStateFlags(IDeviceContext device
             // translation (rotation for example), and this likely impacted the decision to only have a translation
             // flag when this was originally written.
 
-            Debug.Assert(apply.HasFlag(ApplyGraphicsProperties.Clipping)
+/*            Debug.Assert(apply.HasFlag(ApplyGraphicsProperties.Clipping)
                 || graphics.Clip is null
                 || graphics.Clip.GetHrgn(graphics) == IntPtr.Zero,
                 "Must preserve Graphics clipping region!");
@@ -638,7 +638,7 @@ internal static ApplyGraphicsProperties GetApplyStateFlags(IDeviceContext device
             Debug.Assert(apply.HasFlag(ApplyGraphicsProperties.TranslateTransform)
                 || graphics.Transform is null
                 || graphics.Transform.IsIdentity,
-                "Must preserve Graphics transformation!");
+                "Must preserve Graphics transformation!");*/
         }
 #endif
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBar.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBar.cs
new file mode 100644
index 00000000000..8e25db545e5
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBar.cs
@@ -0,0 +1,2243 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using static Interop;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a Windows toolbar.
+    /// </summary>
+    [
+    ComVisible(true),
+    ClassInterface(ClassInterfaceType.AutoDispatch),
+    DefaultEvent(nameof(ButtonClick)),
+    Designer("System.Windows.Forms.Design.ToolBarDesigner, " + AssemblyRef.SystemDesign),
+    DefaultProperty(nameof(Buttons))
+    ]
+    public class ToolBar : Control
+    {
+        private readonly ToolBarButtonCollection buttonsCollection;
+
+        /// <summary>
+        ///  The size of a button in the ToolBar
+        /// </summary>
+        internal Size buttonSize = System.Drawing.Size.Empty;
+
+        /// <summary>
+        ///  This is used by our autoSizing support.
+        /// </summary>
+        private int requestedSize;
+        /// <summary>
+        ///  This represents the width of the drop down arrow we have if the
+        ///  DropDownArrows property is true.  this value is used by the ToolBarButton
+        ///  objects to compute their size
+        /// </summary>
+        internal const int DDARROW_WIDTH = 15;
+
+        /// <summary>
+        ///  Indicates what our appearance will be.  This will either be normal
+        ///  or flat.
+        /// </summary>
+        private ToolBarAppearance appearance = ToolBarAppearance.Normal;
+
+        /// <summary>
+        ///  Indicates whether or not we have a border
+        /// </summary>
+        private BorderStyle borderStyle = System.Windows.Forms.BorderStyle.None;
+
+        /// <summary>
+        ///  The array of buttons we're working with.
+        /// </summary>
+        private ToolBarButton[] buttons;
+
+        /// <summary>
+        ///  The number of buttons we're working with
+        /// </summary>
+        private int buttonCount = 0;
+
+        /// <summary>
+        ///  Indicates if text captions should go underneath images in buttons or
+        ///  to the right of them
+        /// </summary>
+        private ToolBarTextAlign textAlign = ToolBarTextAlign.Underneath;
+
+        /// <summary>
+        ///  The ImageList object that contains the main images for our control.
+        /// </summary>
+        private ImageList imageList = null;
+
+        /// <summary>
+        ///  The maximum width of buttons currently being displayed.  This is needed
+        ///  by our autoSizing code.  If this value is -1, it needs to be recomputed.
+        /// </summary>
+        private int maxWidth = -1;
+        private int hotItem = -1;
+
+        // Track the current scale factor so we can scale our buttons
+        private float currentScaleDX = 1.0F;
+        private float currentScaleDY = 1.0F;
+
+        private const int TOOLBARSTATE_wrappable = 0x00000001;
+        private const int TOOLBARSTATE_dropDownArrows = 0x00000002;
+        private const int TOOLBARSTATE_divider = 0x00000004;
+        private const int TOOLBARSTATE_showToolTips = 0x00000008;
+        private const int TOOLBARSTATE_autoSize = 0x00000010;
+
+        // PERF: take all the bools and put them into a state variable
+        private Collections.Specialized.BitVector32 toolBarState; // see TOOLBARSTATE_ consts above
+
+        // event handlers
+        //
+        private ToolBarButtonClickEventHandler onButtonClick = null;
+        private ToolBarButtonClickEventHandler onButtonDropDown = null;
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='ToolBar'/> class.
+        /// </summary>
+        public ToolBar()
+        : base()
+        {
+            // Set this BEFORE calling any other methods so that these defaults will be propagated
+            toolBarState = new Collections.Specialized.BitVector32(TOOLBARSTATE_autoSize |
+                                                                          TOOLBARSTATE_showToolTips |
+                                                                          TOOLBARSTATE_divider |
+                                                                          TOOLBARSTATE_dropDownArrows |
+                                                                          TOOLBARSTATE_wrappable);
+
+            SetStyle(ControlStyles.UserPaint, false);
+            SetStyle(ControlStyles.FixedHeight, AutoSize);
+            SetStyle(ControlStyles.FixedWidth, false);
+            TabStop = false;
+            Dock = DockStyle.Top;
+            buttonsCollection = new ToolBarButtonCollection(this);
+        }
+
+        /// <summary>
+        ///  Gets or sets the appearance of the toolbar
+        ///  control and its buttons.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(ToolBarAppearance.Normal),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarAppearanceDescr))
+        ]
+        public ToolBarAppearance Appearance
+        {
+            get
+            {
+                return appearance;
+            }
+
+            set
+            {
+                //valid values are 0x0 to 0x1
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarAppearance.Normal, (int)ToolBarAppearance.Flat))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(ToolBarAppearance));
+                }
+
+                if (value != appearance)
+                {
+                    appearance = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates whether the toolbar
+        ///  adjusts its size automatically based on the size of the buttons and the
+        ///  dock style.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(true),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarAutoSizeDescr)),
+        Browsable(true),
+        EditorBrowsable(EditorBrowsableState.Always),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)
+        ]
+        public override bool AutoSize
+        {
+            get
+            {
+                return toolBarState[TOOLBARSTATE_autoSize];
+            }
+
+            set
+            {
+                // Note that we intentionally do not call base.  Toolbars size themselves by
+                // overriding SetBoundsCore (old RTM code).  We let CommonProperties.GetAutoSize
+                // continue to return false to keep our LayoutEngines from messing with TextBoxes.
+                // This is done for backwards compatibility since the new AutoSize behavior differs.
+                if (AutoSize != value)
+                {
+                    toolBarState[TOOLBARSTATE_autoSize] = value;
+                    if (Dock == DockStyle.Left || Dock == DockStyle.Right)
+                    {
+                        SetStyle(ControlStyles.FixedWidth, AutoSize);
+                        SetStyle(ControlStyles.FixedHeight, false);
+                    }
+                    else
+                    {
+                        SetStyle(ControlStyles.FixedHeight, AutoSize);
+                        SetStyle(ControlStyles.FixedWidth, false);
+                    }
+
+                    AdjustSize(Dock);
+                    OnAutoSizeChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        [SRCategory(nameof(SR.CatPropertyChanged)), SRDescription(nameof(SR.ControlOnAutoSizeChangedDescr))]
+        [Browsable(true), EditorBrowsable(EditorBrowsableState.Always)]
+        new public event EventHandler AutoSizeChanged
+        {
+            add => base.AutoSizeChanged += value;
+            remove => base.AutoSizeChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Color BackColor
+        {
+            get
+            {
+                return base.BackColor;
+            }
+            set
+            {
+                base.BackColor = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackColorChanged
+        {
+            add => base.BackColorChanged += value;
+            remove => base.BackColorChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Image BackgroundImage
+        {
+            get
+            {
+                return base.BackgroundImage;
+            }
+            set
+            {
+                base.BackgroundImage = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageChanged
+        {
+            add => base.BackgroundImageChanged += value;
+            remove => base.BackgroundImageChanged -= value;
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override ImageLayout BackgroundImageLayout
+        {
+            get
+            {
+                return base.BackgroundImageLayout;
+            }
+            set
+            {
+                base.BackgroundImageLayout = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler BackgroundImageLayoutChanged
+        {
+            add => base.BackgroundImageLayoutChanged += value;
+            remove => base.BackgroundImageLayoutChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets or sets
+        ///  the border style of the toolbar control.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(BorderStyle.None),
+        DispId(PInvoke.DISPID_BORDERSTYLE),
+        SRDescription(nameof(SR.ToolBarBorderStyleDescr))
+        ]
+        public BorderStyle BorderStyle
+        {
+            get
+            {
+                return borderStyle;
+            }
+
+            set
+            {
+                //valid values are 0x0 to 0x2
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)BorderStyle.None, (int)BorderStyle.Fixed3D))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(BorderStyle));
+                }
+
+                if (borderStyle != value)
+                {
+                    borderStyle = value;
+
+                    //UpdateStyles();
+                    RecreateHandle();   // Looks like we need to recreate the handle to avoid painting glitches
+                }
+            }
+        }
+
+        /// <summary>
+        ///  A collection of <see cref='ToolBarButton'/> controls assigned to the
+        ///  toolbar control. The property is read-only.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarButtonsDescr)),
+        MergableProperty(false)
+        ]
+        public ToolBarButtonCollection Buttons
+        {
+            get
+            {
+                return buttonsCollection;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets
+        ///  the size of the buttons on the toolbar control.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        RefreshProperties(RefreshProperties.All),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarButtonSizeDescr))
+        ]
+        public Size ButtonSize
+        {
+            get
+            {
+                if (buttonSize.IsEmpty)
+                {
+
+                    // Obtain the current buttonsize of the first button from the winctl control
+                    //
+                    if (IsHandleCreated && buttons != null && buttonCount > 0)
+                    {
+                        int result = (int)PInvoke.SendMessage(this, PInvoke.TB_GETBUTTONSIZE, 0, 0);
+                        if (result > 0)
+                        {
+                            return new Size(NativeMethods.Util.LOWORD(result), NativeMethods.Util.HIWORD(result));
+                        }
+                    }
+
+                    if (TextAlign == ToolBarTextAlign.Underneath)
+                    {
+                        return new Size(39, 36);    // Default button size
+                    }
+                    else
+                    {
+                        return new Size(23, 22);    // Default button size
+                    }
+                }
+                else
+                {
+                    return buttonSize;
+                }
+            }
+
+            set
+            {
+
+                if (value.Width < 0 || value.Height < 0)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(value), value, string.Format(SR.InvalidArgument, nameof(ButtonSize), value));
+                }
+
+                if (buttonSize != value)
+                {
+                    buttonSize = value;
+                    maxWidth = -1; // Force recompute of maxWidth
+                    RecreateHandle();
+                    AdjustSize(Dock);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Returns the parameters needed to create the handle.  Inheriting classes
+        ///  can override this to provide extra functionality.  They should not,
+        ///  however, forget to get base.CreateParams first to get the struct
+        ///  filled up with the basic info.
+        /// </summary>
+        protected override CreateParams CreateParams
+        {
+            get
+            {
+                CreateParams cp = base.CreateParams;
+                cp.ClassName = ComCtl32.WindowClasses.WC_TOOLBAR;
+
+                // windows forms has it's own docking code.
+                //
+                cp.Style |= PInvoke.CCS_NOPARENTALIGN
+                            | PInvoke.CCS_NORESIZE;
+                // | NativeMethods.WS_CHILD was commented out since setTopLevel should be able to work.
+
+                if (!Divider)
+                {
+                    cp.Style |= PInvoke.CCS_NODIVIDER;
+                }
+
+                if (Wrappable)
+                {
+                    cp.Style |= (int)PInvoke.TBSTYLE_WRAPABLE;
+                }
+
+                if (ShowToolTips && !DesignMode)
+                {
+                    cp.Style |= (int)PInvoke.TBSTYLE_TOOLTIPS;
+                }
+
+                cp.ExStyle &= (~(int)WINDOW_EX_STYLE.WS_EX_CLIENTEDGE);
+                cp.Style &= (~(int)WINDOW_STYLE.WS_BORDER);
+                switch (borderStyle)
+                {
+                    case BorderStyle.Fixed3D:
+                        cp.ExStyle |= (int)WINDOW_EX_STYLE.WS_EX_CLIENTEDGE;
+                        break;
+                    case BorderStyle.FixedSingle:
+                        cp.Style |= (int)WINDOW_STYLE.WS_BORDER;
+                        break;
+                }
+
+                switch (appearance)
+                {
+                    case ToolBarAppearance.Normal:
+                        break;
+                    case ToolBarAppearance.Flat:
+                        cp.Style |= (int)PInvoke.TBSTYLE_FLAT;
+                        break;
+                }
+
+                switch (textAlign)
+                {
+                    case ToolBarTextAlign.Underneath:
+                        break;
+                    case ToolBarTextAlign.Right:
+                        cp.Style |= (int)PInvoke.TBSTYLE_LIST;
+                        break;
+                }
+
+                return cp;
+            }
+        }
+
+        protected override ImeMode DefaultImeMode
+        {
+            get
+            {
+                return ImeMode.Disable;
+            }
+        }
+
+        /// <summary>
+        ///  Deriving classes can override this to configure a default size for their control.
+        ///  This is more efficient than setting the size in the control's constructor.
+        /// </summary>
+        protected override Size DefaultSize
+        {
+            get
+            {
+                return new Size(100, 22);
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating
+        ///  whether the toolbar displays a divider.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(true),
+        SRDescription(nameof(SR.ToolBarDividerDescr))
+        ]
+        public bool Divider
+        {
+            get
+            {
+                return toolBarState[TOOLBARSTATE_divider];
+            }
+
+            set
+            {
+                if (Divider != value)
+                {
+
+                    toolBarState[TOOLBARSTATE_divider] = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Sets the way in which this ToolBar is docked to its parent. We need to
+        ///  override this to ensure autoSizing works correctly
+        /// </summary>
+        [
+        Localizable(true),
+        DefaultValue(DockStyle.Top)
+        ]
+        public override DockStyle Dock
+        {
+            get { return base.Dock; }
+
+            set
+            {
+                //valid values are 0x0 to 0x5
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)DockStyle.None, (int)DockStyle.Fill))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(DockStyle));
+                }
+
+                if (Dock != value)
+                {
+                    if (value == DockStyle.Left || value == DockStyle.Right)
+                    {
+                        SetStyle(ControlStyles.FixedWidth, AutoSize);
+                        SetStyle(ControlStyles.FixedHeight, false);
+                    }
+                    else
+                    {
+                        SetStyle(ControlStyles.FixedHeight, AutoSize);
+                        SetStyle(ControlStyles.FixedWidth, false);
+                    }
+
+                    AdjustSize(value);
+                    base.Dock = value;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  This property is overridden and hidden from statement completion
+        ///  on controls that are based on Win32 Native Controls.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        protected override bool DoubleBuffered
+        {
+            get
+            {
+                return base.DoubleBuffered;
+            }
+            set
+            {
+                base.DoubleBuffered = value;
+            }
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether drop-down buttons on a
+        ///  toolbar display down arrows.
+        /// </summary>
+        [
+        DefaultValue(false),
+        SRCategory(nameof(SR.CatAppearance)),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarDropDownArrowsDescr))
+        ]
+        public bool DropDownArrows
+        {
+            get
+            {
+                return toolBarState[TOOLBARSTATE_dropDownArrows];
+            }
+
+            set
+            {
+
+                if (DropDownArrows != value)
+                {
+                    toolBarState[TOOLBARSTATE_dropDownArrows] = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override Color ForeColor
+        {
+            get
+            {
+                return base.ForeColor;
+            }
+            set
+            {
+                base.ForeColor = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler ForeColorChanged
+        {
+            add => base.ForeColorChanged += value;
+            remove => base.ForeColorChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets or sets the collection of images available to the toolbar button
+        ///  controls.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(null),
+        SRDescription(nameof(SR.ToolBarImageListDescr))
+        ]
+        public ImageList ImageList
+        {
+            get
+            {
+                return imageList;
+            }
+            set
+            {
+                if (value != imageList)
+                {
+                    EventHandler recreateHandler = new EventHandler(ImageListRecreateHandle);
+                    EventHandler disposedHandler = new EventHandler(DetachImageList);
+
+                    if (imageList != null)
+                    {
+                        imageList.Disposed -= disposedHandler;
+                        imageList.RecreateHandle -= recreateHandler;
+                    }
+
+                    imageList = value;
+
+                    if (value != null)
+                    {
+                        value.Disposed += disposedHandler;
+                        value.RecreateHandle += recreateHandler;
+                    }
+
+                    if (IsHandleCreated)
+                    {
+                        RecreateHandle();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Gets the size of the images in the image list assigned to the
+        ///  toolbar.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
+        SRDescription(nameof(SR.ToolBarImageSizeDescr))
+        ]
+        public Size ImageSize
+        {
+            get
+            {
+                if (imageList != null)
+                {
+                    return imageList.ImageSize;
+                }
+                else
+                {
+                    return new Size(0, 0);
+                }
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public ImeMode ImeMode
+        {
+            get
+            {
+                return base.ImeMode;
+            }
+            set
+            {
+                base.ImeMode = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public new event EventHandler ImeModeChanged
+        {
+            add => base.ImeModeChanged += value;
+            remove => base.ImeModeChanged -= value;
+        }
+
+        /// <summary>
+        ///  The preferred height for this ToolBar control.  This is
+        ///  used by the AutoSizing code.
+        /// </summary>
+        internal int PreferredHeight
+        {
+            get
+            {
+                int height = 0;
+
+                if (buttons == null || buttonCount == 0 || !IsHandleCreated)
+                {
+                    height = ButtonSize.Height;
+                }
+                else
+                {
+                    // get the first visible button and get it's height
+                    //
+                    RECT rect = new RECT();
+                    int firstVisible;
+
+                    for (firstVisible = 0; firstVisible < buttons.Length; firstVisible++)
+                    {
+                        if (buttons[firstVisible] != null && buttons[firstVisible].Visible)
+                        {
+                            break;
+                        }
+                    }
+
+                    if (firstVisible == buttons.Length)
+                    {
+                        firstVisible = 0;
+                    }
+
+                    PInvoke.SendMessage(this, PInvoke.TB_GETRECT, (WPARAM)firstVisible, ref rect);
+
+                    // height is the button's height plus some extra goo
+                    //
+                    height = rect.bottom - rect.top;
+                }
+
+                // if the ToolBar is wrappable, and there is more than one row, make
+                // sure the height is correctly adjusted
+                //
+                if (Wrappable && IsHandleCreated)
+                {
+                    height *= unchecked((int)PInvoke.SendMessage(this, PInvoke.TB_GETROWS, 0, 0));
+                }
+
+                height = (height > 0) ? height : 1;
+
+                switch (borderStyle)
+                {
+                    case BorderStyle.FixedSingle:
+                        height += SystemInformation.BorderSize.Height;
+                        break;
+                    case BorderStyle.Fixed3D:
+                        height += SystemInformation.Border3DSize.Height;
+                        break;
+                }
+
+                if (Divider)
+                {
+                    height += 2;
+                }
+
+                height += 4;
+
+                return height;
+            }
+
+        }
+
+        /// <summary>
+        ///  The preferred width for this ToolBar control.  This is
+        ///  used by AutoSizing code.
+        ///  NOTE!!!!!!!!! This function assumes it's only going to get called
+        ///  if the control is docked left or right [ie, it really
+        ///  just returns a max width]
+        /// </summary>
+        internal int PreferredWidth
+        {
+            get
+            {
+                int width;
+
+                // fortunately, we compute this value sometimes, so we can just
+                // use it if we have it.
+                //
+                if (maxWidth == -1)
+                {
+                    // don't have it, have to recompute
+                    //
+                    if (!IsHandleCreated || buttons == null)
+                    {
+                        maxWidth = ButtonSize.Width;
+                    }
+                    else
+                    {
+
+                        RECT rect = new RECT();
+
+                        for (int x = 0; x < buttonCount; x++)
+                        {
+                            PInvoke.SendMessage(this, PInvoke.TB_GETRECT, 0, ref rect);
+                            if ((rect.right - rect.left) > maxWidth)
+                            {
+                                maxWidth = rect.right - rect.left;
+                            }
+                        }
+                    }
+                }
+
+                width = maxWidth;
+
+                if (borderStyle != BorderStyle.None)
+                {
+                    width += SystemInformation.BorderSize.Height * 4 + 3;
+                }
+
+                return width;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public override RightToLeft RightToLeft
+        {
+            get
+            {
+                return base.RightToLeft;
+            }
+            set
+            {
+                base.RightToLeft = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public new event EventHandler RightToLeftChanged
+        {
+            add => base.RightToLeftChanged += value;
+            remove => base.RightToLeftChanged -= value;
+        }
+
+        /// <summary>
+        ///  We need to track the current scale factor so that we can tell the
+        ///  unmanaged control how to scale its buttons.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        protected override void ScaleCore(float dx, float dy)
+        {
+            currentScaleDX = dx;
+            currentScaleDY = dy;
+            base.ScaleCore(dx, dy);
+            UpdateButtons();
+        }
+
+        /// <summary>
+        ///  We need to track the current scale factor so that we can tell the
+        ///  unmanaged control how to scale its buttons.
+        /// </summary>
+        protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
+        {
+            currentScaleDX = factor.Width;
+            currentScaleDY = factor.Height;
+            base.ScaleControl(factor, specified);
+        }
+
+        /// <summary>
+        ///  Gets or sets a value indicating whether the toolbar displays a
+        ///  tool tip for each button.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(false),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarShowToolTipsDescr))
+        ]
+        public bool ShowToolTips
+        {
+            get
+            {
+                return toolBarState[TOOLBARSTATE_showToolTips];
+            }
+            set
+            {
+                if (ShowToolTips != value)
+                {
+
+                    toolBarState[TOOLBARSTATE_showToolTips] = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        [DefaultValue(false)]
+        new public bool TabStop
+        {
+            get
+            {
+                return base.TabStop;
+            }
+            set
+            {
+                base.TabStop = value;
+            }
+        }
+
+        [
+        Browsable(false), EditorBrowsable(EditorBrowsableState.Never),
+        Bindable(false),
+        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
+        ]
+        public override string Text
+        {
+            get
+            {
+                return base.Text;
+            }
+            set
+            {
+                base.Text = value;
+            }
+        }
+
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        new public event EventHandler TextChanged
+        {
+            add => base.TextChanged += value;
+            remove => base.TextChanged -= value;
+        }
+
+        /// <summary>
+        ///  Gets or sets the alignment of text in relation to each
+        ///  image displayed on
+        ///  the toolbar button controls.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatAppearance)),
+        DefaultValue(ToolBarTextAlign.Underneath),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarTextAlignDescr))
+        ]
+        public ToolBarTextAlign TextAlign
+        {
+            get
+            {
+                return textAlign;
+            }
+            set
+            {
+                //valid values are 0x0 to 0x1
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarTextAlign.Underneath, (int)ToolBarTextAlign.Right))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(ToolBarTextAlign));
+                }
+
+                if (textAlign == value)
+                {
+                    return;
+                }
+
+                textAlign = value;
+                RecreateHandle();
+            }
+        }
+
+        /// <summary>
+        ///  Gets
+        ///  or sets a value
+        ///  indicating whether the toolbar buttons wrap to the next line if the
+        ///  toolbar becomes too small to display all the buttons
+        ///  on the same line.
+        /// </summary>
+        [
+        SRCategory(nameof(SR.CatBehavior)),
+        DefaultValue(true),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarWrappableDescr))
+        ]
+        public bool Wrappable
+        {
+            get
+            {
+                return toolBarState[TOOLBARSTATE_wrappable];
+            }
+            set
+            {
+                if (Wrappable != value)
+                {
+                    toolBarState[TOOLBARSTATE_wrappable] = value;
+                    RecreateHandle();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Occurs when a <see cref='ToolBarButton'/> on the <see cref='ToolBar'/> is clicked.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior)), SRDescription(nameof(SR.ToolBarButtonClickDescr))]
+        public event ToolBarButtonClickEventHandler ButtonClick
+        {
+            add => onButtonClick += value;
+            remove => onButtonClick -= value;
+        }
+
+        /// <summary>
+        ///  Occurs when a drop-down style <see cref='ToolBarButton'/> or its down arrow is clicked.
+        /// </summary>
+        [SRCategory(nameof(SR.CatBehavior)), SRDescription(nameof(SR.ToolBarButtonDropDownDescr))]
+        public event ToolBarButtonClickEventHandler ButtonDropDown
+        {
+            add => onButtonDropDown += value;
+            remove => onButtonDropDown -= value;
+        }
+
+        /// <summary>
+        ///  ToolBar Onpaint.
+        /// </summary>
+        /// <hideinheritance/>
+        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
+        public new event PaintEventHandler Paint
+        {
+            add => base.Paint += value;
+            remove => base.Paint -= value;
+        }
+
+        /// <summary>
+        ///  Adjusts the height or width of the ToolBar to make sure we have enough
+        ///  room to show the buttons.
+        /// </summary>
+        // we pass in a value for dock rather than calling Dock ourselves
+        // because we can't change Dock until the size has been properly adjusted.
+        private void AdjustSize(DockStyle dock)
+        {
+            int saveSize = requestedSize;
+            try
+            {
+                if (dock == DockStyle.Left || dock == DockStyle.Right)
+                {
+                    Width = AutoSize ? PreferredWidth : saveSize;
+                }
+                else
+                {
+                    Height = AutoSize ? PreferredHeight : saveSize;
+                }
+            }
+            finally
+            {
+                requestedSize = saveSize;
+            }
+        }
+
+        /// <summary>
+        ///  This routine lets us change a bunch of things about the toolbar without
+        ///  having each operation wait for the paint to complete.  This must be
+        ///  matched up with a call to endUpdate().
+        /// </summary>
+        internal void BeginUpdate()
+        {
+            BeginUpdateInternal();
+        }
+
+        protected override void CreateHandle()
+        {
+            if (!RecreatingHandle)
+            {
+                using ThemingScope scope = new(Application.UseVisualStyles);
+                INITCOMMONCONTROLSEX icc = new INITCOMMONCONTROLSEX
+                {
+                    dwICC = INITCOMMONCONTROLSEX_ICC.ICC_BAR_CLASSES
+                };
+                PInvoke.InitCommonControlsEx(icc);
+            }
+
+            base.CreateHandle();
+        }
+
+        /// <summary>
+        ///  Resets the imageList to null.  We wire this method up to the imageList's
+        ///  Dispose event, so that we don't hang onto an imageList that's gone away.
+        /// </summary>
+        private void DetachImageList(object? sender, EventArgs e)
+        {
+            ImageList = null;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                //
+                lock (this)
+                {
+                    // We need to mark the Disposing state here so buttonsCollection won't attempt to update
+                    // the buttons.
+                    bool currentDisposing = GetState(States.Disposing);
+
+                    try
+                    {
+                        SetState(States.Disposing, true);
+
+                        if (imageList != null)
+                        {
+                            imageList.Disposed -= new EventHandler(DetachImageList);
+                            imageList = null;
+                        }
+
+                        if (buttonsCollection != null)
+                        {
+                            ToolBarButton[] buttonCopy = new ToolBarButton[buttonsCollection.Count];
+                            ((ICollection)buttonsCollection).CopyTo(buttonCopy, 0);
+                            buttonsCollection.Clear();
+
+                            foreach (ToolBarButton b in buttonCopy)
+                            {
+                                b.Dispose();
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        SetState(States.Disposing, currentDisposing);
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  This routine lets us change a bunch of things about the toolbar without
+        ///  having each operation wait for the paint to complete.  This must be
+        ///  matched up with a call to beginUpdate().
+        /// </summary>
+        internal void EndUpdate()
+        {
+            EndUpdateInternal();
+        }
+
+        /// <summary>
+        ///  Forces the button sizes based on various different things.  The default
+        ///  ToolBar button sizing rules are pretty primitive and this tends to be
+        ///  a little better, and lets us actually show things like DropDown Arrows
+        ///  for ToolBars
+        /// </summary>
+        private void ForceButtonWidths()
+        {
+            if (buttons != null && buttonSize.IsEmpty && IsHandleCreated)
+            {
+
+                // force ourselves to re-compute this each time
+                //
+                maxWidth = -1;
+
+                for (int x = 0; x < buttonCount; x++)
+                {
+
+                    NativeMethods.TBBUTTONINFO tbbi = new NativeMethods.TBBUTTONINFO
+                    {
+                        cbSize = Marshal.SizeOf<NativeMethods.TBBUTTONINFO>(),
+                        cx = buttons[x].Width
+                    };
+
+                    if (tbbi.cx > maxWidth)
+                    {
+                        maxWidth = tbbi.cx;
+                    }
+
+                    tbbi.dwMask = NativeMethods.TBIF_SIZE;
+                    PInvoke.SendMessage(this, PInvoke.TB_SETBUTTONINFO, (WPARAM)x, ref tbbi);
+                }
+            }
+        }
+
+        private void ImageListRecreateHandle(object sender, EventArgs e)
+        {
+            if (IsHandleCreated)
+            {
+                RecreateHandle();
+            }
+        }
+
+        private void Insert(int index, ToolBarButton button)
+        {
+            button.parent = this;
+
+            if (buttons == null)
+            {
+                buttons = new ToolBarButton[4];
+            }
+            else if (buttons.Length == buttonCount)
+            {
+                ToolBarButton[] newButtons = new ToolBarButton[buttonCount + 4];
+                System.Array.Copy(buttons, 0, newButtons, 0, buttonCount);
+                buttons = newButtons;
+            }
+
+            if (index < buttonCount)
+            {
+                System.Array.Copy(buttons, index, buttons, index + 1, buttonCount - index);
+            }
+
+            buttons[index] = button;
+            buttonCount++;
+        }
+
+        /// <summary>
+        ///  Inserts a button at a given location on the toolbar control.
+        /// </summary>
+        private void InsertButton(int index, ToolBarButton value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            if (index < 0 || ((buttons != null) && (index > buttonCount)))
+            {
+                throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+            }
+
+            // insert the button into our local array, and then into the
+            // real windows ToolBar control
+            //
+            Insert(index, value);
+            if (IsHandleCreated)
+            {
+                NativeMethods.TBBUTTON tbbutton = value.GetTBBUTTON(index);
+                PInvoke.SendMessage(this, PInvoke.TB_INSERTBUTTON, (WPARAM)index, ref tbbutton);
+            }
+
+            UpdateButtons();
+        }
+
+        /// <summary>
+        ///  Adds a button to the ToolBar
+        /// </summary>
+        private int InternalAddButton(ToolBarButton button)
+        {
+            if (button == null)
+            {
+                throw new ArgumentNullException(nameof(button));
+            }
+
+            int index = buttonCount;
+            Insert(index, button);
+            return index;
+        }
+
+        /// <summary>
+        ///  Changes the data for a button in the ToolBar, and then does the appropriate
+        ///  work to update the ToolBar control.
+        /// </summary>
+        internal void InternalSetButton(int index, ToolBarButton value, bool recreate, bool updateText)
+        {
+            // tragically, there doesn't appear to be a way to remove the
+            // string for the button if it has one, so we just have to leave
+            // it in there.
+            //
+            buttons[index].parent = null;
+            buttons[index].stringIndex = (IntPtr)(-1);
+            buttons[index] = value;
+            buttons[index].parent = this;
+
+            if (IsHandleCreated)
+            {
+                NativeMethods.TBBUTTONINFO tbbi = value.GetTBBUTTONINFO(updateText, index);
+                PInvoke.SendMessage(this, PInvoke.TB_SETBUTTONINFO, (WPARAM)index, ref tbbi);
+
+                if (tbbi.pszText != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(tbbi.pszText);
+                }
+
+                if (recreate)
+                {
+                    UpdateButtons();
+                }
+                else
+                {
+                    // after doing anything with the comctl ToolBar control, this
+                    // appears to be a good idea.
+                    //
+                    PInvoke.SendMessage(this, PInvoke.TB_AUTOSIZE, 0, 0);
+
+                    ForceButtonWidths();
+                    Invalidate();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='ButtonClick'/>
+        ///  event.
+        /// </summary>
+        protected virtual void OnButtonClick(ToolBarButtonClickEventArgs e)
+        {
+            onButtonClick?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Raises the <see cref='ButtonDropDown'/>
+        ///  event.
+        /// </summary>
+        protected virtual void OnButtonDropDown(ToolBarButtonClickEventArgs e)
+        {
+            onButtonDropDown?.Invoke(this, e);
+        }
+
+        /// <summary>
+        ///  Overridden from the control class so we can add all the buttons
+        ///  and do whatever work needs to be done.
+        ///  Don't forget to call base.OnHandleCreated.
+        /// </summary>
+        protected override void OnHandleCreated(EventArgs e)
+        {
+            base.OnHandleCreated(e);
+
+            // we have to set the button struct size, because they don't.
+            //
+            PInvoke.SendMessage(this, PInvoke.TB_BUTTONSTRUCTSIZE, (WPARAM)Marshal.SizeOf<NativeMethods.TBBUTTON>(), 0);
+
+            // set up some extra goo
+            //
+            if (DropDownArrows)
+            {
+                PInvoke.SendMessage(this, PInvoke.TB_SETEXTENDEDSTYLE, 0, (LPARAM)PInvoke.TBSTYLE_EX_DRAWDDARROWS);
+            }
+
+            // if we have an imagelist, add it in now.
+            //
+            if (imageList != null)
+            {
+                PInvoke.SendMessage(this, PInvoke.TB_SETIMAGELIST, 0, imageList.Handle);
+            }
+
+            RealizeButtons();
+
+            // Force a repaint, as occasionally the ToolBar border does not paint properly
+            // (comctl ToolBar is flaky)
+            //
+            BeginUpdate();
+            try
+            {
+                Size size = Size;
+                Size = new Size(size.Width + 1, size.Height);
+                Size = size;
+            }
+            finally
+            {
+                EndUpdate();
+            }
+        }
+
+        /// <summary>
+        ///  The control is being resized. Make sure the width/height are correct.
+        /// </summary>
+        protected override void OnResize(EventArgs e)
+        {
+            base.OnResize(e);
+            if (Wrappable)
+            {
+                AdjustSize(Dock);
+            }
+        }
+
+        /// <summary>
+        ///  Overridden to ensure that the buttons and the control resize properly
+        ///  whenever the font changes.
+        /// </summary>
+        protected override void OnFontChanged(EventArgs e)
+        {
+            base.OnFontChanged(e);
+            if (IsHandleCreated)
+            {
+                if (!buttonSize.IsEmpty)
+                {
+                    SendToolbarButtonSizeMessage();
+                }
+                else
+                {
+                    AdjustSize(Dock);
+                    ForceButtonWidths();
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Sets all the button data into the ToolBar control
+        /// </summary>
+        private void RealizeButtons()
+        {
+            if (buttons != null)
+            {
+                IntPtr ptbbuttons = IntPtr.Zero;
+                try
+                {
+                    BeginUpdate();
+                    //  go and add in all the strings for all of our buttons
+                    //
+                    for (int x = 0; x < buttonCount; x++)
+                    {
+                        if (buttons[x].Text.Length > 0)
+                        {
+                            string addString = buttons[x].Text + '\0'.ToString();
+                            buttons[x].stringIndex = PInvoke.SendMessage(this, PInvoke.TB_ADDSTRING, 0, addString);
+                        }
+                        else
+                        {
+                            buttons[x].stringIndex = (IntPtr)(-1);
+                        }
+                    }
+
+                    // insert the buttons and set their parent pointers
+                    //
+                    int cb = Marshal.SizeOf<NativeMethods.TBBUTTON>();
+                    int count = buttonCount;
+                    ptbbuttons = Marshal.AllocHGlobal(checked(cb * count));
+
+                    for (int x = 0; x < count; x++)
+                    {
+
+                        NativeMethods.TBBUTTON tbbutton = buttons[x].GetTBBUTTON(x);
+                        Marshal.StructureToPtr(tbbutton, (IntPtr)(checked((long)ptbbuttons + (cb * x))), true);
+                        buttons[x].parent = this;
+                    }
+
+                    PInvoke.SendMessage(this, PInvoke.TB_ADDBUTTONS, (WPARAM)count, ptbbuttons);
+
+                    // after doing anything with the comctl ToolBar control, this
+                    // appears to be a good idea.
+                    //
+                    PInvoke.SendMessage(this, PInvoke.TB_AUTOSIZE, 0, 0);
+
+                    // The win32 ToolBar control is somewhat unpredictable here. We
+                    // have to set the button size after we've created all the
+                    // buttons.  Otherwise, we need to manually set the width of all
+                    // the buttons so they look reasonable
+                    //
+                    if (!buttonSize.IsEmpty)
+                    {
+                        SendToolbarButtonSizeMessage();
+                    }
+                    else
+                    {
+                        ForceButtonWidths();
+                    }
+
+                    AdjustSize(Dock);
+                }
+                finally
+                {
+                    Marshal.FreeHGlobal(ptbbuttons);
+                    EndUpdate();
+                }
+            }
+        }
+
+        private void RemoveAt(int index)
+        {
+            buttons[index].parent = null;
+            buttons[index].stringIndex = (IntPtr)(-1);
+            buttonCount--;
+
+            if (index < buttonCount)
+            {
+                System.Array.Copy(buttons, index + 1, buttons, index, buttonCount - index);
+            }
+
+            buttons[buttonCount] = null;
+        }
+
+        /// <summary>
+        ///  Resets the toolbar buttons to the minimum
+        ///  size.
+        /// </summary>
+        private void ResetButtonSize()
+        {
+            buttonSize = Size.Empty;
+            RecreateHandle();
+        }
+
+        ///  Sends a TB_SETBUTTONSIZE message to the unmanaged control, with size arguments properly scaled.
+        private void SendToolbarButtonSizeMessage()
+        {
+            PInvoke.SendMessage(this, PInvoke.TB_SETBUTTONSIZE, 0, NativeMethods.Util.MAKELPARAM((int)(buttonSize.Width * currentScaleDX), (int)(buttonSize.Height * currentScaleDY)));
+        }
+
+        /// <summary>
+        ///  Overrides Control.setBoundsCore to enforce AutoSize.
+        /// </summary>
+        protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
+        {
+            int originalHeight = height;
+            int originalWidth = width;
+
+            base.SetBoundsCore(x, y, width, height, specified);
+
+            Rectangle bounds = Bounds;
+            if (Dock == DockStyle.Left || Dock == DockStyle.Right)
+            {
+                if ((specified & BoundsSpecified.Width) != BoundsSpecified.None)
+                {
+                    requestedSize = width;
+                }
+
+                if (AutoSize)
+                {
+                    width = PreferredWidth;
+                }
+
+                if (width != originalWidth && Dock == DockStyle.Right)
+                {
+                    int deltaWidth = originalWidth - width;
+                    x += deltaWidth;
+                }
+
+            }
+            else
+            {
+                if ((specified & BoundsSpecified.Height) != BoundsSpecified.None)
+                {
+                    requestedSize = height;
+                }
+
+                if (AutoSize)
+                {
+                    height = PreferredHeight;
+                }
+
+                if (height != originalHeight && Dock == DockStyle.Bottom)
+                {
+                    int deltaHeight = originalHeight - height;
+                    y += deltaHeight;
+                }
+
+            }
+
+            base.SetBoundsCore(x, y, width, height, specified);
+        }
+
+        /// <summary>
+        ///  Determines if the <see cref='ButtonSize'/> property needs to be persisted.
+        /// </summary>
+        private bool ShouldSerializeButtonSize()
+        {
+            return !buttonSize.IsEmpty;
+        }
+
+        /// <summary>
+        ///  Called by ToolTip to poke in that Tooltip into this ComCtl so that the Native ChildToolTip is not exposed.
+        /// </summary>
+        internal void SetToolTip(ToolTip toolTip)
+        {
+            PInvoke.SendMessage(this, PInvoke.TB_SETTOOLTIPS, toolTip.HWND, 0);
+
+        }
+
+        /// <summary>
+        ///  Returns a string representation for this control.
+        /// </summary>
+        public override string ToString()
+        {
+            string s = base.ToString();
+            s += ", Buttons.Count: " + buttonCount.ToString(CultureInfo.CurrentCulture);
+            if (buttonCount > 0)
+            {
+                s += ", Buttons[0]: " + buttons[0].ToString();
+            }
+
+            return s;
+        }
+
+        /// <summary>
+        ///  Updates all the information in the ToolBar.  Tragically, the win32
+        ///  control is pretty flakey, and the only real choice here is to recreate
+        ///  the handle and re-realize all the buttons.
+        /// </summary>
+        internal void UpdateButtons()
+        {
+            if (IsHandleCreated)
+            {
+                RecreateHandle();
+            }
+        }
+
+        /// <summary>
+        ///  The button clicked was a dropdown button.  If it has a menu specified,
+        ///  show it now.  Otherwise, fire an onButtonDropDown event.
+        /// </summary>
+        private void WmNotifyDropDown(ref Message m)
+        {
+            var lParam = m.GetLParam(typeof(NativeMethods.NMTOOLBAR)) ?? throw new InvalidOperationException("lparam of a received message should not be null");
+
+            NativeMethods.NMTOOLBAR nmTB = (NativeMethods.NMTOOLBAR)lParam;
+
+            ToolBarButton tbb = buttons[nmTB.iItem];
+            if (tbb == null)
+            {
+                throw new InvalidOperationException(SR.ToolBarButtonNotFound);
+            }
+
+            OnButtonDropDown(new ToolBarButtonClickEventArgs(tbb));
+
+            Menu menu = tbb.DropDownMenu;
+            if (menu != null)
+            {
+                RECT rc = new RECT();
+                NativeMethods.TPMPARAMS tpm = new NativeMethods.TPMPARAMS();
+
+                PInvoke.SendMessage(this, PInvoke.TB_GETRECT, (WPARAM)nmTB.iItem, ref rc);
+
+                if ((menu.GetType()).IsAssignableFrom(typeof(ContextMenu)))
+                {
+                    ((ContextMenu)menu).Show(this, new Point(rc.left, rc.bottom));
+                }
+                else
+                {
+                    Menu main = menu.GetMainMenu();
+                    if (main != null)
+                    {
+                        main.ProcessInitMenuPopup(menu.Handle);
+                    }
+
+                    PInvoke.MapWindowPoints((HWND)nmTB.hdr.hwndFrom, HWND.Null, ref rc);
+
+                    tpm.rcExclude_left = rc.left;
+                    tpm.rcExclude_top = rc.top;
+                    tpm.rcExclude_right = rc.right;
+                    tpm.rcExclude_bottom = rc.bottom;
+
+                    SafeNativeMethods.TrackPopupMenuEx(
+                                                  new HandleRef(menu, menu.Handle),
+                                                  NativeMethods.TPM_LEFTALIGN |
+                                                  NativeMethods.TPM_LEFTBUTTON |
+                                                  NativeMethods.TPM_VERTICAL,
+                                                  rc.left, rc.bottom,
+                                                  new HandleRef(this, Handle), tpm);
+                }
+            }
+        }
+
+        private void WmNotifyNeedText(ref Message m)
+        {
+            NativeMethods.TOOLTIPTEXT ttt = (NativeMethods.TOOLTIPTEXT)m.GetLParam(typeof(NativeMethods.TOOLTIPTEXT));
+            int commandID = (int)ttt.hdr.idFrom;
+            ToolBarButton tbb = buttons[commandID];
+
+            if (tbb != null && tbb.ToolTipText != null)
+            {
+                ttt.lpszText = tbb.ToolTipText;
+            }
+            else
+            {
+                ttt.lpszText = null;
+            }
+
+            ttt.hinst = IntPtr.Zero;
+
+            // RightToLeft reading order
+            //
+            if (RightToLeft == RightToLeft.Yes)
+            {
+                ttt.uFlags |= (int)ComCtl32.TTF.RTLREADING;
+            }
+
+            Marshal.StructureToPtr(ttt, m.LParam, false);
+        }
+
+        // Track the currently hot item since the user might be using the tab and
+        // arrow keys to navigate the toolbar and if that's the case, we'll need to know where to re-
+        // position the tooltip window when the underlying toolbar control attempts to display it.
+        private void WmNotifyHotItemChange(ref Message m)
+        {
+            var lParam = m.GetLParam(typeof(NMTBHOTITEM)) ?? throw new InvalidOperationException("lparam of a received message should not be null");
+
+            // Should we set the hot item?
+            NMTBHOTITEM nmTbHotItem = (NMTBHOTITEM)lParam;
+            if (NMTBHOTITEM_FLAGS.HICF_ENTERING == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_ENTERING))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_LEAVING == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_LEAVING))
+            {
+                hotItem = -1;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_MOUSE == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_MOUSE))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_ARROWKEYS == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_ARROWKEYS))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_ACCELERATOR == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_ACCELERATOR))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_DUPACCEL == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_DUPACCEL))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_RESELECT == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_RESELECT))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_LMOUSE == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_LMOUSE))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+            else if (NMTBHOTITEM_FLAGS.HICF_TOGGLEDROPDOWN == (nmTbHotItem.dwFlags & NMTBHOTITEM_FLAGS.HICF_TOGGLEDROPDOWN))
+            {
+                hotItem = nmTbHotItem.idNew;
+            }
+        }
+
+        private void WmReflectCommand(ref Message m)
+        {
+            int id = NativeMethods.Util.LOWORD(m.WParam);
+            ToolBarButton tbb = buttons[id];
+
+            if (tbb != null)
+            {
+                ToolBarButtonClickEventArgs e = new ToolBarButtonClickEventArgs(tbb);
+                OnButtonClick(e);
+            }
+
+            base.WndProc(ref m);
+
+            ResetMouseEventArgs();
+        }
+
+        protected override void WndProc(ref Message m)
+        {
+            switch (m.Msg)
+            {
+                case WindowMessages.WM_COMMAND + WindowMessages.WM_REFLECT:
+                    WmReflectCommand(ref m);
+                    break;
+
+                case WindowMessages.WM_NOTIFY:
+                case WindowMessages.WM_NOTIFY + WindowMessages.WM_REFLECT:
+
+                    var lParam = m.GetLParam(typeof(NMHDR)) ?? throw new InvalidOperationException("lparam of a received message should not be null");
+
+                    NMHDR note = (NMHDR)lParam;
+                    switch (note.code)
+                    {
+                        case PInvoke.TTN_NEEDTEXT:
+                            WmNotifyNeedText(ref m);
+                            m.Result = 1;
+                            return;
+                        case PInvoke.TTN_SHOW:
+                            // Prevent the tooltip from displaying in the upper left corner of the
+                            // desktop when the control is nowhere near that location.
+                            WINDOWPLACEMENT wndPlacement = new();
+                            int nRet = PInvoke.GetWindowPlacement(note.hwndFrom, ref wndPlacement);
+
+                            // Is this tooltip going to be positioned in the upper left corner of the display,
+                            // but nowhere near the toolbar button?
+                            if (wndPlacement.rcNormalPosition.left == 0 &&
+                                wndPlacement.rcNormalPosition.top == 0 &&
+                                hotItem != -1)
+                            {
+
+                                // Assume that we're going to vertically center the tooltip on the right edge of the current
+                                // hot item.
+
+                                // Where is the right edge of the current hot item?
+                                int buttonRight = 0;
+                                for (int idx = 0; idx <= hotItem; idx++)
+                                {
+                                    // How wide is the item at this index? (It could be a separator, and therefore a different width.)
+                                    buttonRight += buttonsCollection[idx].GetButtonWidth();
+                                }
+
+                                // Where can we place this tooltip so that it will be completely visible on the current display?
+                                int tooltipWidth = wndPlacement.rcNormalPosition.right - wndPlacement.rcNormalPosition.left;
+                                int tooltipHeight = wndPlacement.rcNormalPosition.bottom - wndPlacement.rcNormalPosition.top;
+
+                                // We'll need screen coordinates of this position for setting the tooltip's position
+                                int x = Location.X + buttonRight + 1;
+                                int y = Location.Y + (ButtonSize.Height / 2);
+                                var leftTop = new Point(x, y);
+                                PInvoke.ClientToScreen(HWND, ref leftTop);
+
+                                // Will the tooltip bleed off the top?
+                                if (leftTop.Y < SystemInformation.WorkingArea.Y)
+                                {
+                                    // Reposition the tooltip to be displayed below the button
+                                    leftTop.Y += (ButtonSize.Height / 2) + 1;
+                                }
+
+                                // Will the tooltip bleed off the bottom?
+                                if (leftTop.Y + tooltipHeight > SystemInformation.WorkingArea.Height)
+                                {
+                                    // Reposition the tooltip to be displayed above the button
+                                    leftTop.Y -= ((ButtonSize.Height / 2) + tooltipHeight + 1);
+                                }
+
+                                // Will the tooltip bleed off the right edge?
+                                if (leftTop.X + tooltipWidth > SystemInformation.WorkingArea.Right)
+                                {
+                                    // Move the tooltip far enough left that it will display in the working area
+                                    leftTop.X -= (ButtonSize.Width + tooltipWidth + 2);
+                                }
+
+                                PInvoke.SetWindowPos(note.hwndFrom, HWND.Null, leftTop.X, leftTop.Y, 0, 0, SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
+                                m.Result = (IntPtr)1;
+                                return;
+                            }
+
+                            break;
+
+                        case PInvoke.TBN_HOTITEMCHANGE:
+                            WmNotifyHotItemChange(ref m);
+                            break;
+
+                        case PInvoke.TBN_QUERYINSERT:
+                            m.Result = (IntPtr)1;
+                            break;
+
+                        case PInvoke.TBN_DROPDOWN:
+                            WmNotifyDropDown(ref m);
+                            break;
+                    }
+
+                    break;
+
+            }
+
+            base.WndProc(ref m);
+        }
+
+        /// <summary>
+        ///  Encapsulates a collection of <see cref='ToolBarButton'/> controls for use by the
+        /// <see cref='ToolBar'/> class.
+        /// </summary>
+        public class ToolBarButtonCollection : IList
+        {
+            private readonly ToolBar owner;
+            private bool suspendUpdate;
+            ///  A caching mechanism for key accessor
+            ///  We use an index here rather than control so that we don't have lifetime
+            ///  issues by holding on to extra references.
+            private int lastAccessedIndex = -1;
+
+            /// <summary>
+            ///  Initializes a new instance of the <see cref='ToolBarButtonCollection'/> class and assigns it to the specified toolbar.
+            /// </summary>
+            public ToolBarButtonCollection(ToolBar owner)
+            {
+                this.owner = owner;
+            }
+
+            /// <summary>
+            ///  Gets or sets the toolbar button at the specified indexed location in the
+            ///  toolbar button collection.
+            /// </summary>
+            public virtual ToolBarButton this[int index]
+            {
+                get
+                {
+                    if (index < 0 || ((owner.buttons != null) && (index >= owner.buttonCount)))
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                    }
+
+                    return owner.buttons[index];
+                }
+                set
+                {
+
+                    // Sanity check parameters
+                    //
+                    if (index < 0 || ((owner.buttons != null) && index >= owner.buttonCount))
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(index), index, string.Format(SR.InvalidArgument, nameof(index), index));
+                    }
+
+                    if (value == null)
+                    {
+                        throw new ArgumentNullException(nameof(value));
+                    }
+
+                    owner.InternalSetButton(index, value, true, true);
+                }
+            }
+
+            object IList.this[int index]
+            {
+                get
+                {
+                    return this[index];
+                }
+                set
+                {
+                    if (value is ToolBarButton)
+                    {
+                        this[index] = (ToolBarButton)value;
+                    }
+                    else
+                    {
+                        throw new ArgumentException(SR.ToolBarBadToolBarButton, "value");
+                    }
+                }
+            }
+
+            /// <summary>
+            ///  Retrieves the child control with the specified key.
+            /// </summary>
+            public virtual ToolBarButton this[string key]
+            {
+                get
+                {
+                    // We do not support null and empty string as valid keys.
+                    if (string.IsNullOrEmpty(key))
+                    {
+                        return null;
+                    }
+
+                    // Search for the key in our collection
+                    int index = IndexOfKey(key);
+                    if (IsValidIndex(index))
+                    {
+                        return this[index];
+                    }
+                    else
+                    {
+                        return null;
+                    }
+
+                }
+            }
+
+            /// <summary>
+            ///  Gets the number of buttons in the toolbar button collection.
+            /// </summary>
+            [Browsable(false)]
+            public int Count
+            {
+                get
+                {
+                    return owner.buttonCount;
+                }
+            }
+
+            object ICollection.SyncRoot
+            {
+                get
+                {
+                    return this;
+                }
+            }
+
+            bool ICollection.IsSynchronized
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            bool IList.IsFixedSize
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            public bool IsReadOnly
+            {
+                get
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Adds a new toolbar button to
+            ///  the end of the toolbar button collection.
+            /// </summary>
+            public int Add(ToolBarButton button)
+            {
+
+                int index = owner.InternalAddButton(button);
+
+                if (!suspendUpdate)
+                {
+                    owner.UpdateButtons();
+                }
+
+                return index;
+            }
+
+            public int Add(string text)
+            {
+                ToolBarButton button = new ToolBarButton(text);
+                return Add(button);
+            }
+
+            int IList.Add(object button)
+            {
+                if (button is ToolBarButton)
+                {
+                    return Add((ToolBarButton)button);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.ToolBarBadToolBarButton, "button");
+                }
+            }
+
+            public void AddRange(ToolBarButton[] buttons)
+            {
+                if (buttons == null)
+                {
+                    throw new ArgumentNullException(nameof(buttons));
+                }
+
+                try
+                {
+                    suspendUpdate = true;
+                    foreach (ToolBarButton button in buttons)
+                    {
+                        Add(button);
+                    }
+                }
+                finally
+                {
+                    suspendUpdate = false;
+                    owner.UpdateButtons();
+                }
+            }
+
+            /// <summary>
+            ///  Removes
+            ///  all buttons from the toolbar button collection.
+            /// </summary>
+            public void Clear()
+            {
+
+                if (owner.buttons == null)
+                {
+                    return;
+                }
+
+                for (int x = owner.buttonCount; x > 0; x--)
+                {
+                    if (owner.IsHandleCreated)
+                    {
+                        PInvoke.SendMessage(owner, PInvoke.TB_DELETEBUTTON, (WPARAM)(x - 1), 0);
+                    }
+
+                    owner.RemoveAt(x - 1);
+                }
+
+                owner.buttons = null;
+                owner.buttonCount = 0;
+                if (!owner.Disposing)
+                {
+                    owner.UpdateButtons();
+                }
+            }
+
+            public bool Contains(ToolBarButton button)
+            {
+                return IndexOf(button) != -1;
+            }
+
+            bool IList.Contains(object button)
+            {
+                if (button is ToolBarButton)
+                {
+                    return Contains((ToolBarButton)button);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            /// <summary>
+            ///  Returns true if the collection contains an item with the specified key, false otherwise.
+            /// </summary>
+            public virtual bool ContainsKey(string key)
+            {
+                return IsValidIndex(IndexOfKey(key));
+            }
+
+            void ICollection.CopyTo(Array dest, int index)
+            {
+                if (owner.buttonCount > 0)
+                {
+                    System.Array.Copy(owner.buttons, 0, dest, index, owner.buttonCount);
+                }
+            }
+
+            public int IndexOf(ToolBarButton button)
+            {
+                for (int index = 0; index < Count; ++index)
+                {
+                    if (this[index] == button)
+                    {
+                        return index;
+                    }
+                }
+
+                return -1;
+            }
+
+            int IList.IndexOf(object button)
+            {
+                if (button is ToolBarButton)
+                {
+                    return IndexOf((ToolBarButton)button);
+                }
+                else
+                {
+                    return -1;
+                }
+            }
+
+            /// <summary>
+            ///  The zero-based index of the first occurrence of value within the entire CollectionBase, if found; otherwise, -1.
+            /// </summary>
+            public virtual int IndexOfKey(string key)
+            {
+                // Step 0 - Arg validation
+                if (string.IsNullOrEmpty(key))
+                {
+                    return -1; // we dont support empty or null keys.
+                }
+
+                // step 1 - check the last cached item
+                if (IsValidIndex(lastAccessedIndex))
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[lastAccessedIndex].Name, key, /* ignoreCase = */ true))
+                    {
+                        return lastAccessedIndex;
+                    }
+                }
+
+                // step 2 - search for the item
+                for (int i = 0; i < Count; i++)
+                {
+                    if (WindowsFormsUtils.SafeCompareStrings(this[i].Name, key, /* ignoreCase = */ true))
+                    {
+                        lastAccessedIndex = i;
+                        return i;
+                    }
+                }
+
+                // step 3 - we didn't find it.  Invalidate the last accessed index and return -1.
+                lastAccessedIndex = -1;
+                return -1;
+            }
+
+            public void Insert(int index, ToolBarButton button)
+            {
+                owner.InsertButton(index, button);
+            }
+
+            void IList.Insert(int index, object button)
+            {
+                if (button is ToolBarButton)
+                {
+                    Insert(index, (ToolBarButton)button);
+                }
+                else
+                {
+                    throw new ArgumentException(SR.ToolBarBadToolBarButton, "button");
+                }
+            }
+
+            /// <summary>
+            ///  Determines if the index is valid for the collection.
+            /// </summary>
+            private bool IsValidIndex(int index)
+            {
+                return ((index >= 0) && (index < Count));
+            }
+
+            /// <summary>
+            ///  Removes
+            ///  a given button from the toolbar button collection.
+            /// </summary>
+            public void RemoveAt(int index)
+            {
+                int count = (owner.buttons == null) ? 0 : owner.buttonCount;
+
+                if (index < 0 || index >= count)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index), string.Format(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
+                }
+
+                if (owner.IsHandleCreated)
+                {
+                    PInvoke.SendMessage(owner, PInvoke.TB_DELETEBUTTON, (WPARAM)index, 0);
+                }
+
+                owner.RemoveAt(index);
+                owner.UpdateButtons();
+
+            }
+
+            /// <summary>
+            ///  Removes the child control with the specified key.
+            /// </summary>
+            public virtual void RemoveByKey(string key)
+            {
+                int index = IndexOfKey(key);
+                if (IsValidIndex(index))
+                {
+                    RemoveAt(index);
+                }
+            }
+
+            public void Remove(ToolBarButton button)
+            {
+                int index = IndexOf(button);
+                if (index != -1)
+                {
+                    RemoveAt(index);
+                }
+            }
+
+            void IList.Remove(object button)
+            {
+                if (button is ToolBarButton)
+                {
+                    Remove((ToolBarButton)button);
+                }
+            }
+
+            /// <summary>
+            ///  Returns an enumerator that can be used to iterate
+            ///  through the toolbar button collection.
+            /// </summary>
+            public IEnumerator GetEnumerator()
+            {
+                return new WindowsFormsUtils.ArraySubsetEnumerator(owner.buttons, owner.buttonCount);
+            }
+        }
+
+    }
+}
+
+
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarAppearance.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarAppearance.cs
new file mode 100644
index 00000000000..464c456837b
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarAppearance.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the type of toolbar to display.
+    /// </summary>
+    public enum ToolBarAppearance
+    {
+        /// <summary>
+        ///  The toolbar and buttons appear as standard three dimensional controls.
+        /// </summary>
+        Normal = 0,
+
+        /// <summary>
+        ///  The toolbar and buttons appear flat, but the buttons change to three
+        ///  dimensional as the mouse pointer moves over them.
+        /// </summary>
+        Flat = 1,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButton.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButton.cs
new file mode 100644
index 00000000000..0bbcdcc5bed
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButton.cs
@@ -0,0 +1,881 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Design;
+using System.Text;
+using Marshal = System.Runtime.InteropServices.Marshal;
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a Windows toolbar button.
+    /// </summary>
+    [
+    Designer("System.Windows.Forms.Design.ToolBarButtonDesigner, " + AssemblyRef.SystemDesign),
+    DefaultProperty(nameof(Text)),
+    ToolboxItem(false),
+    DesignTimeVisible(false),
+    ]
+    public class ToolBarButton : Component
+    {
+        string text;
+        string name = null;
+        string tooltipText;
+        bool enabled = true;
+        bool visible = true;
+        bool pushed = false;
+        bool partialPush = false;
+        private int commandId = -1; // the cached command id of the button.
+        private ToolBarButtonImageIndexer imageIndexer;
+
+        ToolBarButtonStyle style = ToolBarButtonStyle.PushButton;
+
+        object userData;
+
+        // These variables below are used by the ToolBar control to help
+        // it manage some information about us.
+
+        /// <summary>
+        ///  If this button has a string, what it's index is in the ToolBar's
+        ///  internal list of strings.  Needs to be package protected.
+        /// </summary>
+        internal IntPtr stringIndex = (IntPtr)(-1);
+
+        /// <summary>
+        ///  Our parent ToolBar control.
+        /// </summary>
+        internal ToolBar parent;
+
+        /// <summary>
+        ///  For DropDown buttons, we can optionally show a
+        ///  context menu when the button is dropped down.
+        /// </summary>
+        internal Menu dropDownMenu = null;
+
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='ToolBarButton'/> class.
+        /// </summary>
+        public ToolBarButton()
+        {
+        }
+
+        public ToolBarButton(string text) : base()
+        {
+            Text = text;
+        }
+
+        // We need a special way to defer to the ToolBar's image
+        // list for indexing purposes.
+        internal class ToolBarButtonImageIndexer : ImageList.Indexer
+        {
+            private readonly ToolBarButton owner;
+
+            public ToolBarButtonImageIndexer(ToolBarButton button)
+            {
+                owner = button;
+            }
+
+            public override ImageList ImageList
+            {
+                get
+                {
+                    if ((owner != null) && (owner.parent != null))
+                    {
+                        return owner.parent.ImageList;
+                    }
+
+                    return null;
+                }
+                set { Debug.Assert(false, "We should never set the image list"); }
+            }
+        }
+
+        internal ToolBarButtonImageIndexer ImageIndexer
+        {
+            get
+            {
+                return imageIndexer ??= new ToolBarButtonImageIndexer(this);
+            }
+        }
+
+        /// <summary>
+        ///
+        ///  Indicates the menu to be displayed in
+        ///  the drop-down toolbar button.
+        /// </summary>
+        [
+        DefaultValue(null),
+        TypeConverter(typeof(ReferenceConverter)),
+        SRDescription(nameof(SR.ToolBarButtonMenuDescr))
+        ]
+        public Menu DropDownMenu
+        {
+            get
+            {
+                return dropDownMenu;
+            }
+
+            set
+            {
+                //The dropdownmenu must be of type ContextMenu, Main & Items are invalid.
+                //
+                if (value != null && !(value is ContextMenu))
+                {
+                    throw new ArgumentException(SR.ToolBarButtonInvalidDropDownMenuType);
+                }
+
+                dropDownMenu = value;
+            }
+        }
+
+        /// <summary>
+        ///  Indicates whether the button is enabled or not.
+        /// </summary>
+        [
+        DefaultValue(true),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarButtonEnabledDescr))
+        ]
+        public bool Enabled
+        {
+            get
+            {
+                return enabled;
+            }
+
+            set
+            {
+                if (enabled != value)
+                {
+
+                    enabled = value;
+
+                    if (parent != null && parent.IsHandleCreated)
+                    {
+                        PInvoke.SendMessage(parent, PInvoke.TB_ENABLEBUTTON, (WPARAM)FindButtonIndex(),
+                            enabled ? 1 : 0);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the index
+        ///  value of the image assigned to the button.
+        /// </summary>
+        [
+        TypeConverter(typeof(ImageIndexConverter)),
+        Editor("System.Windows.Forms.Design.ImageIndexEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
+        DefaultValue(-1),
+        RefreshProperties(RefreshProperties.Repaint),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarButtonImageIndexDescr))
+        ]
+        public int ImageIndex
+        {
+            get
+            {
+                return ImageIndexer.Index;
+            }
+            set
+            {
+                if (ImageIndexer.Index != value)
+                {
+                    if (value < -1)
+                    {
+                        throw new ArgumentOutOfRangeException(nameof(ImageIndex), string.Format(SR.InvalidLowBoundArgumentEx, nameof(ImageIndex), value, -1));
+                    }
+
+                    ImageIndexer.Index = value;
+                    UpdateButton(false);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the index
+        ///  value of the image assigned to the button.
+        /// </summary>
+        [
+        TypeConverter(typeof(ImageKeyConverter)),
+        Editor("System.Windows.Forms.Design.ImageIndexEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor)),
+        DefaultValue(""),
+        Localizable(true),
+        RefreshProperties(RefreshProperties.Repaint),
+        SRDescription(nameof(SR.ToolBarButtonImageIndexDescr))
+        ]
+        public string ImageKey
+        {
+            get
+            {
+                return ImageIndexer.Key;
+            }
+            set
+            {
+                if (ImageIndexer.Key != value)
+                {
+                    ImageIndexer.Key = value;
+                    UpdateButton(false);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Name of this control. The designer will set this to the same
+        ///  as the programatic Id "(name)" of the control - however this
+        ///  property has no bearing on the runtime aspects of this control.
+        /// </summary>
+        [Browsable(false)]
+        public string Name
+        {
+            get
+            {
+                return WindowsFormsUtils.GetComponentName(this, name);
+            }
+            set
+            {
+                if (value == null || value.Length == 0)
+                {
+                    name = null;
+                }
+                else
+                {
+                    name = value;
+                }
+
+                if (Site != null)
+                {
+                    Site.Name = name;
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the toolbar control that the toolbar button is assigned to. This property is
+        ///  read-only.
+        /// </summary>
+        [
+            Browsable(false),
+        ]
+        public ToolBar Parent
+        {
+            get
+            {
+                return parent;
+            }
+        }
+
+        /// <summary>
+        ///
+        ///  Indicates whether a toggle-style toolbar button
+        ///  is partially pushed.
+        /// </summary>
+        [
+        DefaultValue(false),
+        SRDescription(nameof(SR.ToolBarButtonPartialPushDescr))
+        ]
+        public bool PartialPush
+        {
+            get
+            {
+                if (parent == null || !parent.IsHandleCreated)
+                {
+                    return partialPush;
+                }
+                else
+                {
+                    if ((int)PInvoke.SendMessage(parent, PInvoke.TB_ISBUTTONINDETERMINATE, (WPARAM)FindButtonIndex(), 0) != 0)
+                    {
+                        partialPush = true;
+                    }
+                    else
+                    {
+                        partialPush = false;
+                    }
+
+                    return partialPush;
+                }
+            }
+            set
+            {
+                if (partialPush != value)
+                {
+                    partialPush = value;
+                    UpdateButton(false);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates whether a toggle-style toolbar button is currently in the pushed state.
+        /// </summary>
+        [
+        DefaultValue(false),
+        SRDescription(nameof(SR.ToolBarButtonPushedDescr))
+        ]
+        public bool Pushed
+        {
+            get
+            {
+                if (parent == null || !parent.IsHandleCreated)
+                {
+                    return pushed;
+                }
+                else
+                {
+                    return GetPushedState();
+                }
+            }
+            set
+            {
+                if (value != Pushed)
+                { // Getting property Pushed updates pushed member variable
+                    pushed = value;
+                    UpdateButton(false, false, false);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the bounding rectangle for a toolbar button. This property is
+        ///  read-only.
+        /// </summary>
+        public Rectangle Rectangle
+        {
+            get
+            {
+                if (parent != null)
+                {
+                    RECT rc = new RECT();
+                    PInvoke.SendMessage(parent, PInvoke.TB_GETRECT, (WPARAM)FindButtonIndex(), ref rc);
+                    return Rectangle.FromLTRB(rc.left, rc.top, rc.right, rc.bottom);
+                }
+
+                return Rectangle.Empty;
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the style of the
+        ///  toolbar button.
+        /// </summary>
+        [
+        DefaultValue(ToolBarButtonStyle.PushButton),
+        SRDescription(nameof(SR.ToolBarButtonStyleDescr)),
+        RefreshProperties(RefreshProperties.Repaint)
+        ]
+        public ToolBarButtonStyle Style
+        {
+            get
+            {
+                return style;
+            }
+            set
+            {
+                //valid values are 0x1 to 0x4
+                if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolBarButtonStyle.PushButton, (int)ToolBarButtonStyle.DropDownButton))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value), (int)value, typeof(ToolBarButtonStyle));
+                }
+
+                if (style == value)
+                {
+                    return;
+                }
+
+                style = value;
+                UpdateButton(true);
+            }
+        }
+
+        [
+        SRCategory(nameof(SR.CatData)),
+        Localizable(false),
+        Bindable(true),
+        SRDescription(nameof(SR.ControlTagDescr)),
+        DefaultValue(null),
+        TypeConverter(typeof(StringConverter)),
+        ]
+        public object Tag
+        {
+            get
+            {
+                return userData;
+            }
+            set
+            {
+                userData = value;
+            }
+        }
+
+        /// <summary>
+        ///  Indicates the text that is displayed on the toolbar button.
+        /// </summary>
+        [
+        Localizable(true),
+        DefaultValue(""),
+        SRDescription(nameof(SR.ToolBarButtonTextDescr))
+        ]
+        public string Text
+        {
+            get
+            {
+                return text ?? "";
+            }
+            set
+            {
+                if (string.IsNullOrEmpty(value))
+                {
+                    value = null;
+                }
+
+                if ((value == null && text != null) ||
+                     (value != null && (text == null || !text.Equals(value))))
+                {
+                    text = value;
+                    // Adding a mnemonic requires a handle recreate.
+                    UpdateButton(WindowsFormsUtils.ContainsMnemonic(text), true, true);
+                }
+            }
+        }
+
+        /// <summary>
+        ///
+        ///  Indicates
+        ///  the text that appears as a tool tip for a control.
+        /// </summary>
+        [
+        Localizable(true),
+        DefaultValue(""),
+        SRDescription(nameof(SR.ToolBarButtonToolTipTextDescr))
+        ]
+        public string ToolTipText
+        {
+            get
+            {
+                return tooltipText ?? "";
+            }
+            set
+            {
+                tooltipText = value;
+            }
+        }
+
+        /// <summary>
+        ///
+        ///  Indicates whether the toolbar button
+        ///  is visible.
+        /// </summary>
+        [
+        DefaultValue(true),
+        Localizable(true),
+        SRDescription(nameof(SR.ToolBarButtonVisibleDescr))
+        ]
+        public bool Visible
+        {
+            get
+            {
+                return visible;
+            }
+            set
+            {
+                if (visible != value)
+                {
+                    visible = value;
+                    UpdateButton(false);
+                }
+            }
+        }
+
+        /// <summary>
+        ///  This is somewhat nasty -- by default, the windows ToolBar isn't very
+        ///  clever about setting the width of buttons, and has a very primitive
+        ///  algorithm that doesn't include for things like drop down arrows, etc.
+        ///  We need to do a bunch of work here to get all the widths correct. Ugh.
+        /// </summary>
+        internal short Width
+        {
+            get
+            {
+                Debug.Assert(parent != null, "Parent should be non-null when button width is requested");
+
+                int width = 0;
+                ToolBarButtonStyle style = Style;
+
+                Size edge = SystemInformation.Border3DSize;
+                if (style != ToolBarButtonStyle.Separator)
+                {
+
+                    // COMPAT: this will force handle creation.
+                    // we could use the measurement graphics, but it looks like this has been like this since Everett.
+                    using (Graphics g = parent.CreateGraphicsInternal())
+                    {
+
+                        Size buttonSize = parent.buttonSize;
+                        if (!(buttonSize.IsEmpty))
+                        {
+                            width = buttonSize.Width;
+                        }
+                        else
+                        {
+                            if (parent.ImageList != null || !string.IsNullOrEmpty(Text))
+                            {
+                                Size imageSize = parent.ImageSize;
+                                Size textSize = Size.Ceiling(g.MeasureString(Text, parent.Font));
+                                if (parent.TextAlign == ToolBarTextAlign.Right)
+                                {
+                                    if (textSize.Width == 0)
+                                    {
+                                        width = imageSize.Width + edge.Width * 4;
+                                    }
+                                    else
+                                    {
+                                        width = imageSize.Width + textSize.Width + edge.Width * 6;
+                                    }
+                                }
+                                else
+                                {
+                                    if (imageSize.Width > textSize.Width)
+                                    {
+                                        width = imageSize.Width + edge.Width * 4;
+                                    }
+                                    else
+                                    {
+                                        width = textSize.Width + edge.Width * 4;
+                                    }
+                                }
+
+                                if (style == ToolBarButtonStyle.DropDownButton && parent.DropDownArrows)
+                                {
+                                    width += ToolBar.DDARROW_WIDTH;
+                                }
+                            }
+                            else
+                            {
+                                width = parent.ButtonSize.Width;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    width = edge.Width * 2;
+                }
+
+                return (short)width;
+            }
+
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (parent != null)
+                {
+                    int index = FindButtonIndex();
+                    if (index != -1)
+                    {
+                        parent.Buttons.RemoveAt(index);
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        ///  Finds out index in the parent.
+        /// </summary>
+        private int FindButtonIndex()
+        {
+            for (int x = 0; x < parent.Buttons.Count; x++)
+            {
+                if (parent.Buttons[x] == this)
+                {
+                    return x;
+                }
+            }
+
+            return -1;
+        }
+
+        // This is necessary to get the width of the buttons in the toolbar,
+        // including the width of separators, so that we can accurately position the tooltip adjacent
+        // to the currently hot button when the user uses keyboard navigation to access the toolbar.
+        internal int GetButtonWidth()
+        {
+            // Assume that this button is the same width as the parent's ButtonSize's Width
+            int buttonWidth = Parent.ButtonSize.Width;
+
+            NativeMethods.TBBUTTONINFO button = new NativeMethods.TBBUTTONINFO
+            {
+                cbSize = Marshal.SizeOf<NativeMethods.TBBUTTONINFO>(),
+                dwMask = NativeMethods.TBIF_SIZE
+            };
+
+            int buttonID = (int)PInvoke.SendMessage(Parent, PInvoke.TB_GETBUTTONINFO, (WPARAM)commandId, ref button);
+            if (buttonID != -1)
+            {
+                buttonWidth = button.cx;
+            }
+
+            return buttonWidth;
+        }
+
+        private bool GetPushedState()
+        {
+            if ((int)PInvoke.SendMessage(parent, PInvoke.TB_ISBUTTONCHECKED, (WPARAM)FindButtonIndex(), 0) != 0)
+            {
+                pushed = true;
+            }
+            else
+            {
+                pushed = false;
+            }
+
+            return pushed;
+        }
+
+        /// <summary>
+        ///  Returns a TBBUTTON object that represents this ToolBarButton.
+        /// </summary>
+        internal NativeMethods.TBBUTTON GetTBBUTTON(int commandId)
+        {
+            NativeMethods.TBBUTTON button = new NativeMethods.TBBUTTON
+            {
+                iBitmap = ImageIndexer.ActualIndex,
+
+                // set up the state of the button
+                //
+                fsState = 0
+            };
+            if (enabled)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_ENABLED;
+            }
+
+            if (partialPush && style == ToolBarButtonStyle.ToggleButton)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_INDETERMINATE;
+            }
+
+            if (pushed)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_CHECKED;
+            }
+
+            if (!visible)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_HIDDEN;
+            }
+
+            // set the button style
+            //
+            switch (style)
+            {
+                case ToolBarButtonStyle.PushButton:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_BUTTON;
+                    break;
+                case ToolBarButtonStyle.ToggleButton:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_CHECK;
+                    break;
+                case ToolBarButtonStyle.Separator:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_SEP;
+                    break;
+                case ToolBarButtonStyle.DropDownButton:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_DROPDOWN;
+                    break;
+
+            }
+
+            button.dwData = (IntPtr)0;
+            button.iString = stringIndex;
+            this.commandId = commandId;
+            button.idCommand = commandId;
+
+            return button;
+        }
+
+        /// <summary>
+        ///  Returns a TBBUTTONINFO object that represents this ToolBarButton.
+        /// </summary>
+        internal NativeMethods.TBBUTTONINFO GetTBBUTTONINFO(bool updateText, int newCommandId)
+        {
+            NativeMethods.TBBUTTONINFO button = new NativeMethods.TBBUTTONINFO
+            {
+                cbSize = Marshal.SizeOf<NativeMethods.TBBUTTONINFO>(),
+                dwMask = NativeMethods.TBIF_IMAGE
+                            | NativeMethods.TBIF_STATE | NativeMethods.TBIF_STYLE
+            };
+
+            // Older platforms interpret null strings as empty, which forces the button to
+            // leave space for text.
+            // The only workaround is to avoid having comctl update the text.
+            if (updateText)
+            {
+                button.dwMask |= NativeMethods.TBIF_TEXT;
+            }
+
+            button.iImage = ImageIndexer.ActualIndex;
+
+            if (newCommandId != commandId)
+            {
+                commandId = newCommandId;
+                button.idCommand = newCommandId;
+                button.dwMask |= NativeMethods.TBIF_COMMAND;
+            }
+
+            // set up the state of the button
+            //
+            button.fsState = 0;
+            if (enabled)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_ENABLED;
+            }
+
+            if (partialPush && style == ToolBarButtonStyle.ToggleButton)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_INDETERMINATE;
+            }
+
+            if (pushed)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_CHECKED;
+            }
+
+            if (!visible)
+            {
+                button.fsState |= (byte)PInvoke.TBSTATE_HIDDEN;
+            }
+
+            // set the button style
+            //
+            switch (style)
+            {
+                case ToolBarButtonStyle.PushButton:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_BUTTON;
+                    break;
+                case ToolBarButtonStyle.ToggleButton:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_CHECK;
+                    break;
+                case ToolBarButtonStyle.Separator:
+                    button.fsStyle = (byte)PInvoke.TBSTYLE_SEP;
+                    break;
+            }
+
+            if (text == null)
+            {
+                button.pszText = Marshal.StringToHGlobalAuto("\0\0");
+            }
+            else
+            {
+                string textValue = text;
+                PrefixAmpersands(ref textValue);
+                button.pszText = Marshal.StringToHGlobalAuto(textValue);
+            }
+
+            return button;
+        }
+
+        private void PrefixAmpersands(ref string value)
+        {
+            // Due to a comctl32 problem, ampersands underline the next letter in the
+            // text string, but the accelerators don't work.
+            // So in this function, we prefix ampersands with another ampersand
+            // so that they actually appear as ampersands.
+            //
+
+            // Sanity check parameter
+            //
+            if (value == null || value.Length == 0)
+            {
+                return;
+            }
+
+            // If there are no ampersands, we don't need to do anything here
+            //
+            if (value.IndexOf('&') < 0)
+            {
+                return;
+            }
+
+            // Insert extra ampersands
+            //
+            StringBuilder newString = new StringBuilder();
+            for (int i = 0; i < value.Length; ++i)
+            {
+                if (value[i] == '&')
+                {
+                    if (i < value.Length - 1 && value[i + 1] == '&')
+                    {
+                        ++i;    // Skip the second ampersand
+                    }
+
+                    newString.Append("&&");
+                }
+                else
+                {
+                    newString.Append(value[i]);
+                }
+            }
+
+            value = newString.ToString();
+        }
+
+        public override string ToString()
+        {
+            return "ToolBarButton: " + Text + ", Style: " + Style.ToString("G");
+        }
+
+        /// <summary>
+        ///  When a button property changes and the parent control is created,
+        ///  we need to make sure it gets the new button information.
+        ///  If Text was changed, call the next overload.
+        /// </summary>
+        internal void UpdateButton(bool recreate)
+        {
+            UpdateButton(recreate, false, true);
+        }
+
+        /// <summary>
+        ///  When a button property changes and the parent control is created,
+        ///  we need to make sure it gets the new button information.
+        /// </summary>
+        private void UpdateButton(bool recreate, bool updateText, bool updatePushedState)
+        {
+            // It looks like ToolBarButtons with a DropDownButton tend to
+            // lose the DropDownButton very easily - so we need to recreate
+            // the button each time it changes just to be sure.
+            //
+            if (style == ToolBarButtonStyle.DropDownButton && parent != null && parent.DropDownArrows)
+            {
+                recreate = true;
+            }
+
+            // we just need to get the Pushed state : this asks the Button its states and sets
+            // the private member "pushed" to right value..
+
+            // this member is used in "InternalSetButton" which calls GetTBBUTTONINFO(bool updateText)
+            // the GetButtonInfo method uses the "pushed" variable..
+
+            //rather than setting it ourselves .... we asks the button to set it for us..
+            if (updatePushedState && parent != null && parent.IsHandleCreated)
+            {
+                GetPushedState();
+            }
+
+            if (parent != null)
+            {
+                int index = FindButtonIndex();
+                if (index != -1)
+                {
+                    parent.InternalSetButton(index, this, recreate, updateText);
+                }
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventArgs.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventArgs.cs
new file mode 100644
index 00000000000..0256dfba763
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventArgs.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Provides data for the <see cref='ToolBar.ButtonClick'/>
+    ///  event.
+    /// </summary>
+    public class ToolBarButtonClickEventArgs : EventArgs
+    {
+        /// <summary>
+        ///  Initializes a new instance of the <see cref='ToolBarButtonClickEventArgs'/>
+        ///  class.
+        /// </summary>
+        public ToolBarButtonClickEventArgs(ToolBarButton button)
+        {
+            Button = button;
+        }
+
+        /// <summary>
+        ///  Specifies the <see cref='ToolBarButton'/>
+        ///  that was clicked.
+        /// </summary>
+        public ToolBarButton Button { get; set; }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventHandler.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventHandler.cs
new file mode 100644
index 00000000000..e41f8559afa
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonClickEventHandler.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Represents a method that will handle the <see cref='ToolBar.ButtonClick'/>
+    ///  event of a <see cref='ToolBar'/>.
+    /// </summary>
+    public delegate void ToolBarButtonClickEventHandler(object sender, ToolBarButtonClickEventArgs e);
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonStyle.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonStyle.cs
new file mode 100644
index 00000000000..ea4872efb30
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarButtonStyle.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    public enum ToolBarButtonStyle
+    {
+        /// <summary>
+        ///  A standard, three-dimensional button.
+        /// </summary>
+        PushButton = 1,
+
+        /// <summary>
+        ///  A toggle button that appears sunken when clicked and retains the
+        ///  sunken appearance until clicked again.
+        /// </summary>
+        ToggleButton = 2,
+
+        /// <summary>
+        ///  A space or line between toolbar buttons. The appearance depends on
+        ///  the value of the <see cref='ToolBar.Appearance'/>
+        ///  property.
+        /// </summary>
+        Separator = 3,
+
+        /// <summary>
+        ///  A drop down control that displays a menu or other window when
+        ///  clicked.
+        /// </summary>
+        DropDownButton = 4,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarTextAlign.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarTextAlign.cs
new file mode 100644
index 00000000000..72dcf8156c9
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolBarTextAlign.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System.Windows.Forms
+{
+    /// <summary>
+    ///  Specifies the alignment of text on the toolbar button control.
+    /// </summary>
+    public enum ToolBarTextAlign
+    {
+        /// <summary>
+        ///  The text is aligned underneath the toolbar button image.
+        /// </summary>
+        Underneath = 0,
+
+        /// <summary>
+        ///  The text is aligned to the right of the toolbar button image.
+        /// </summary>
+        Right = 1,
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripDropDown.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripDropDown.cs
index 56356817a6a..ea5ce231c91 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripDropDown.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripDropDown.cs
@@ -503,6 +503,14 @@ public override Font Font
         remove => base.ImeModeChanged -= value;
     }
 
+    [Browsable(false)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public new ContextMenu ContextMenu
+    {
+        get { return base.ContextMenu; }
+        set { base.ContextMenu = value; }
+    }
+
     /// <summary>
     ///  determines whether this dropdown was autogenerated.
     /// </summary>
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControl.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControl.cs
index 79f2d9ef73d..168d5a5dbe8 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControl.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControl.cs
@@ -30,7 +30,7 @@ private RECT AbsoluteClientRECT
                 RECT rect = default;
                 CreateParams cp = CreateParams;
 
-                AdjustWindowRectExForControlDpi(ref rect, (WINDOW_STYLE)cp.Style, false, (WINDOW_EX_STYLE)cp.ExStyle);
+                AdjustWindowRectExForControlDpi(ref rect, (WINDOW_STYLE)cp.Style, HasMenu, (WINDOW_EX_STYLE)cp.ExStyle);
 
                 // the coordinates we get back are negative, we need to translate this back to positive.
                 int offsetX = -rect.left; // one to get back to 0,0, another to translate
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/ToolTip.cs b/src/System.Windows.Forms/src/System/Windows/Forms/ToolTip.cs
index 04cdc38adf7..a7614a9909f 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/ToolTip.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/ToolTip.cs
@@ -6,6 +6,7 @@
 using System.Globalization;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/TreeNode.cs b/src/System.Windows.Forms/src/System/Windows/Forms/TreeNode.cs
index 15ed4dde3d8..a56e26f9a55 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/TreeNode.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/TreeNode.cs
@@ -54,6 +54,7 @@ public partial class TreeNode : MarshalByRefObject, ICloneable, ISerializable
     private TreeNodeImageIndexer stateImageIndexer;
 
     private string toolTipText = string.Empty;
+    private ContextMenu contextMenu = null;
     private ContextMenuStrip _contextMenuStrip;
     internal bool nodesCleared;
 
@@ -364,6 +365,27 @@ public bool Checked
         }
     }
 
+    /// <summary>
+    ///  The contextMenu associated with this tree node. The contextMenu
+    ///  will be shown when the user right clicks the mouse on the control.
+    /// </summary>
+    [
+    SRCategory(nameof(SR.CatBehavior)),
+    DefaultValue(null),
+    SRDescription(nameof(SR.ControlContextMenuDescr))
+    ]
+    public virtual ContextMenu ContextMenu
+    {
+        get
+        {
+            return contextMenu;
+        }
+        set
+        {
+            contextMenu = value;
+        }
+    }
+
     /// <summary>
     ///  The <see cref="Forms.ContextMenuStrip"/> associated with this tree node. This menu
     ///  will be shown when the user right clicks the mouse on the control.
@@ -1169,7 +1191,7 @@ public TreeView TreeView
     }
 
     internal TreeNodeAccessibleObject AccessibilityObject
-        => _accessibleObject ??= new TreeNodeAccessibleObject(this, TreeView);
+        => _accessibleObject ??= TreeView is null ? null : new TreeNodeAccessibleObject(this, TreeView);
 
     /// <summary>
     ///  Adds a new child node at the appropriate sorted position
@@ -1424,6 +1446,7 @@ public virtual object Clone()
 
         node.StateImageIndexer.Index = StateImageIndexer.Index;
         node.ToolTipText = toolTipText;
+        node.ContextMenu = contextMenu;
         node.ContextMenuStrip = _contextMenuStrip;
 
         // only set the key if it's set to something useful
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/TreeView.cs b/src/System.Windows.Forms/src/System/Windows/Forms/TreeView.cs
index f58067c52c2..c9220033736 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/TreeView.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/TreeView.cs
@@ -12,6 +12,7 @@
 using System.Windows.Forms.VisualStyles;
 using static Interop;
 using static Interop.ComCtl32;
+using INITCOMMONCONTROLSEX = Windows.Win32.UI.Controls.INITCOMMONCONTROLSEX;
 
 namespace System.Windows.Forms;
 
@@ -1650,6 +1651,11 @@ protected override void Dispose(bool disposing)
     {
         if (disposing)
         {
+            foreach (TreeNode node in Nodes)
+            {
+                node.ContextMenu = null;
+            }
+
             lock (this)
             {
                 DetachImageListHandlers();
@@ -2206,9 +2212,9 @@ protected virtual void OnAfterLabelEdit(NodeLabelEditEventArgs e)
 
         // Raise an event to highlight & announce the edited node
         // if editing hasn't been canceled.
-        if (IsAccessibilityObjectCreated && !e.CancelEdit)
+        if (IsAccessibilityObjectCreated && !e.CancelEdit && e.Node is not null)
         {
-            e.Node.AccessibilityObject.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
+            e.Node.AccessibilityObject?.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
         }
     }
 
@@ -2228,9 +2234,14 @@ protected virtual void OnAfterCheck(TreeViewEventArgs e)
         onAfterCheck?.Invoke(this, e);
 
         // Raise an event to announce a toggle state change.
-        if (IsAccessibilityObjectCreated)
+        if (IsAccessibilityObjectCreated && e.Node is not null)
         {
-            AccessibleObject nodeAccessibleObject = e.Node.AccessibilityObject;
+            TreeNode.TreeNodeAccessibleObject nodeAccessibleObject = e.Node.AccessibilityObject;
+            if (nodeAccessibleObject is null)
+            {
+                return;
+            }
+
             UiaCore.ToggleState newState = nodeAccessibleObject.ToggleState;
             UiaCore.ToggleState oldState = newState == UiaCore.ToggleState.On
                 ? UiaCore.ToggleState.Off
@@ -2259,9 +2270,9 @@ protected internal virtual void OnAfterCollapse(TreeViewEventArgs e)
         onAfterCollapse?.Invoke(this, e);
 
         // Raise an event to announce the expand-collapse state change.
-        if (IsAccessibilityObjectCreated)
+        if (IsAccessibilityObjectCreated && e.Node is not null)
         {
-            e.Node.AccessibilityObject.RaiseAutomationPropertyChangedEvent(
+            e.Node.AccessibilityObject?.RaiseAutomationPropertyChangedEvent(
                 UiaCore.UIA.ExpandCollapseExpandCollapseStatePropertyId,
                 oldValue: UiaCore.ExpandCollapseState.Expanded,
                 newValue: UiaCore.ExpandCollapseState.Collapsed);
@@ -2283,10 +2294,10 @@ protected virtual void OnAfterExpand(TreeViewEventArgs e)
     {
         onAfterExpand?.Invoke(this, e);
 
-        // Raise anevent to announce the expand-collapse state change.
-        if (IsAccessibilityObjectCreated)
+        // Raise an event to announce the expand-collapse state change.
+        if (IsAccessibilityObjectCreated && e.Node is not null)
         {
-            e.Node.AccessibilityObject.RaiseAutomationPropertyChangedEvent(
+            e.Node.AccessibilityObject?.RaiseAutomationPropertyChangedEvent(
                 UiaCore.UIA.ExpandCollapseExpandCollapseStatePropertyId,
                 oldValue: UiaCore.ExpandCollapseState.Collapsed,
                 newValue: UiaCore.ExpandCollapseState.Expanded);
@@ -2325,9 +2336,14 @@ protected virtual void OnAfterSelect(TreeViewEventArgs e)
         onAfterSelect?.Invoke(this, e);
 
         // Raise an event to highlight & announce the selected node.
-        if (IsAccessibilityObjectCreated)
+        if (IsAccessibilityObjectCreated && e.Node is not null)
         {
-            AccessibleObject nodeAccessibleObject = e.Node.AccessibilityObject;
+            TreeNode.TreeNodeAccessibleObject nodeAccessibleObject = e.Node.AccessibilityObject;
+            if (nodeAccessibleObject is null)
+            {
+                return;
+            }
+
             nodeAccessibleObject.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
             nodeAccessibleObject.RaiseAutomationEvent(UiaCore.UIA.SelectionItem_ElementSelectedEventId);
 
@@ -2948,14 +2964,14 @@ private unsafe void CustomDraw(ref Message m)
                             {
                                 g.FillRectangle(SystemBrushes.Highlight, bounds);
                                 ControlPaint.DrawFocusRectangle(g, bounds, color, SystemColors.Highlight);
-                                TextRenderer.DrawText(g, e.Node.Text, font, bounds, color, TextFormatFlags.Default);
+                                TextRenderer.DrawText(g, node.Text, font, bounds, color, TextFormatFlags.Default);
                             }
                             else
                             {
                                 using var brush = BackColor.GetCachedSolidBrushScope();
                                 g.FillRectangle(brush, bounds);
 
-                                TextRenderer.DrawText(g, e.Node.Text, font, bounds, color, TextFormatFlags.Default);
+                                TextRenderer.DrawText(g, node.Text, font, bounds, color, TextFormatFlags.Default);
                             }
                         }
                     }
@@ -3155,7 +3171,7 @@ private unsafe void WmNotify(ref Message m)
                     if ((int)nmtv->nmhdr.code == (int)NM.RCLICK)
                     {
                         TreeNode treeNode = NodeFromHandle(hnode);
-                        if (treeNode is not null && treeNode.ContextMenuStrip is not null)
+                        if (treeNode != null && (treeNode.ContextMenu != null || treeNode.ContextMenuStrip != null))
                         {
                             ShowContextMenu(treeNode);
                         }
@@ -3194,7 +3210,7 @@ protected override void OnGotFocus(EventArgs e)
         // Raise an event to highlight & announce the selected node.
         if (IsAccessibilityObjectCreated)
         {
-            SelectedNode?.AccessibilityObject.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
+            SelectedNode?.AccessibilityObject?.RaiseAutomationEvent(UiaCore.UIA.AutomationFocusChangedEventId);
         }
     }
 
@@ -3209,14 +3225,39 @@ protected override void OnLostFocus(EventArgs e)
     /// </summary>
     private void ShowContextMenu(TreeNode treeNode)
     {
-        if (treeNode.ContextMenuStrip is not null)
+        if (treeNode.ContextMenu != null || treeNode.ContextMenuStrip is not null)
         {
+            ContextMenu contextMenu = treeNode.ContextMenu;
             ContextMenuStrip menu = treeNode.ContextMenuStrip;
 
-            // Need to send TVM_SELECTITEM to highlight the node while the contextMenuStrip is being shown.
-            PInvoke.PostMessage(this, PInvoke.TVM_SELECTITEM, (WPARAM)PInvoke.TVGN_DROPHILITE, (LPARAM)treeNode.Handle);
-            menu.ShowInternal(this, PointToClient(MousePosition), /*keyboardActivated*/false);
-            menu.Closing += new ToolStripDropDownClosingEventHandler(ContextMenuStripClosing);
+            if (contextMenu != null)
+            {
+                PInvoke.GetCursorPos(out Point pt);
+
+                // Summary: the current window must be made the foreground window
+                // before calling TrackPopupMenuEx, and a task switch must be
+                // forced after the call.
+                PInvoke.SetForegroundWindow(this);
+
+                contextMenu.OnPopup(EventArgs.Empty);
+
+                SafeNativeMethods.TrackPopupMenuEx(new HandleRef(contextMenu, contextMenu.Handle),
+                                         NativeMethods.TPM_VERTICAL,
+                                         pt.X,
+                                         pt.Y,
+                                         new HandleRef(this, Handle),
+                                         null);
+
+                // Force task switch (see above)
+                PInvoke.PostMessage(this, PInvoke.WM_NULL, (WPARAM)IntPtr.Zero, IntPtr.Zero);
+            }
+            else if (menu is not null)
+            {
+                // Need to send TVM_SELECTITEM to highlight the node while the contextMenuStrip is being shown.
+                PInvoke.PostMessage(this, PInvoke.TVM_SELECTITEM, (WPARAM)PInvoke.TVGN_DROPHILITE, (LPARAM)treeNode.Handle);
+                menu.ShowInternal(this, PointToClient(MousePosition), /*keyboardActivated*/false);
+                menu.Closing += new ToolStripDropDownClosingEventHandler(ContextMenuStripClosing);
+            }
         }
     }
 
@@ -3525,15 +3566,22 @@ protected override unsafe void WndProc(ref Message m)
                 {
                     // this is the Shift + F10 Case....
                     TreeNode treeNode = SelectedNode;
-                    if (treeNode is not null && treeNode.ContextMenuStrip is not null)
+                    if (treeNode is not null && (treeNode.ContextMenu is not null || treeNode.ContextMenuStrip is not null))
                     {
                         Point client;
                         client = new Point(treeNode.Bounds.X, treeNode.Bounds.Y + treeNode.Bounds.Height / 2);
                         // VisualStudio7 # 156, only show the context menu when clicked in the client area
-                        if (ClientRectangle.Contains(client) && treeNode.ContextMenuStrip is not null)
+                        if (ClientRectangle.Contains(client))
                         {
-                            bool keyboardActivated = m.LParamInternal == -1;
-                            treeNode.ContextMenuStrip.ShowInternal(this, client, keyboardActivated);
+                            if (treeNode.ContextMenu is not null)
+                            {
+                                treeNode.ContextMenu.Show(this, client);
+                            }
+                            else if (ContextMenuStrip is not null)
+                            {
+                                bool keyboardActivated = m.LParamInternal == -1;
+                                treeNode.ContextMenuStrip.ShowInternal(this, client, keyboardActivated);
+                            }
                         }
                     }
                     else
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/UnsafeNativeMethodsCore.cs b/src/System.Windows.Forms/src/System/Windows/Forms/UnsafeNativeMethodsCore.cs
new file mode 100644
index 00000000000..f7f5638a3ba
--- /dev/null
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/UnsafeNativeMethodsCore.cs
@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace WTG.System.Windows.Forms.System.Windows.Forms
+{
+    internal class UnsafeNativeMethodsCore
+    {
+
+        /// <summary>
+        ///  This class provides static methods to create, activate and deactivate the theming scope.
+        /// </summary>
+        internal class ThemingScope
+        {
+            private static ACTCTX enableThemingActivationContext;
+            private static IntPtr hActCtx;
+            private static bool contextCreationSucceeded;
+
+            /// <summary>
+            ///  We now use explicitactivate everywhere and use this method to determine if we
+            ///  really need to activate the activationcontext.  This should be pretty fast.
+            /// </summary>
+            private static bool IsContextActive()
+            {
+                IntPtr current = IntPtr.Zero;
+
+                if (contextCreationSucceeded && GetCurrentActCtx(out current))
+                {
+                    return current == hActCtx;
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            ///  Activate() does nothing if a theming context is already active on the current thread, which is good
+            ///  for perf reasons. However, in some cases, like in the Timer callback, we need to put another context
+            ///  on the stack even if one is already present. In such cases, this method helps - you get to manage
+            ///  the cookie yourself though.
+            /// </summary>
+            public static IntPtr Activate()
+            {
+                IntPtr userCookie = IntPtr.Zero;
+
+                if (Application.UseVisualStyles && contextCreationSucceeded && OSFeature.Feature.IsPresent(OSFeature.Themes))
+                {
+                    if (!IsContextActive())
+                    {
+                        if (!ActivateActCtx(hActCtx, out userCookie))
+                        {
+                            // Be sure cookie always zero if activation failed
+                            userCookie = IntPtr.Zero;
+                        }
+                    }
+                }
+
+                return userCookie;
+            }
+
+            /// <summary>
+            ///  Use this to deactivate a context activated by calling ExplicitActivate.
+            /// </summary>
+            public static IntPtr Deactivate(IntPtr userCookie)
+            {
+                if (userCookie != IntPtr.Zero && OSFeature.Feature.IsPresent(OSFeature.Themes))
+                {
+                    if (DeactivateActCtx(0, userCookie))
+                    {
+                        // deactivation succeeded...
+                        userCookie = IntPtr.Zero;
+                    }
+                }
+
+                return userCookie;
+            }
+
+            public static bool CreateActivationContext(string dllPath, int nativeResourceManifestID)
+            {
+                lock (typeof(ThemingScope))
+                {
+                    if (!contextCreationSucceeded && OSFeature.Feature.IsPresent(OSFeature.Themes))
+                    {
+
+                        enableThemingActivationContext = new ACTCTX
+                        {
+                            cbSize = Marshal.SizeOf<ACTCTX>(),
+                            lpSource = dllPath,
+                            lpResourceName = (IntPtr)nativeResourceManifestID,
+                            dwFlags = ACTCTX_FLAG_RESOURCE_NAME_VALID
+                        };
+
+                        hActCtx = CreateActCtx(ref enableThemingActivationContext);
+                        contextCreationSucceeded = (hActCtx != new IntPtr(-1));
+                    }
+
+                    return contextCreationSucceeded;
+                }
+            }
+
+            // All the pinvoke goo...
+            [DllImport(ExternDll.Kernel32)]
+
+            private extern static IntPtr CreateActCtx(ref ACTCTX actctx);
+            [DllImport(ExternDll.Kernel32)]
+
+            private extern static bool ActivateActCtx(IntPtr hActCtx, out IntPtr lpCookie);
+            [DllImport(ExternDll.Kernel32)]
+
+            private extern static bool DeactivateActCtx(int dwFlags, IntPtr lpCookie);
+            [DllImport(ExternDll.Kernel32)]
+
+            private extern static bool GetCurrentActCtx(out IntPtr handle);
+
+            private const int ACTCTX_FLAG_RESOURCE_NAME_VALID = 0x008;
+
+            private struct ACTCTX
+            {
+                public int cbSize;
+                public uint dwFlags;
+                public string lpSource;
+                public ushort wProcessorArchitecture;
+                public ushort wLangId;
+                public string lpAssemblyDirectory;
+                public IntPtr lpResourceName;
+                public string lpApplicationName;
+            }
+        }
+    }
+}
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/UpDownBase.UpDownEdit.cs b/src/System.Windows.Forms/src/System/Windows/Forms/UpDownBase.UpDownEdit.cs
index e497e297d73..31b19ec4428 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/UpDownBase.UpDownEdit.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/UpDownBase.UpDownEdit.cs
@@ -87,7 +87,7 @@ protected override void OnMouseUp(MouseEventArgs e)
         internal override void WmContextMenu(ref Message m)
         {
             // Want to make the SourceControl to be the UpDownBase, not the Edit.
-            if (ContextMenuStrip is not null)
+            if (ContextMenuStrip is not null || ContextMenu is not null)
             {
                 WmContextMenu(ref m, _parent);
             }
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowser.WebBrowserEvent.cs b/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowser.WebBrowserEvent.cs
index df667609bd2..4c1fbbe6f57 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowser.WebBrowserEvent.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowser.WebBrowserEvent.cs
@@ -13,12 +13,25 @@ public partial class WebBrowser
     [ClassInterface(ClassInterfaceType.None)]
     private class WebBrowserEvent : StandardOleMarshalObject, SHDocVw.DWebBrowserEvents2
     {
-        private readonly WebBrowser _parent;
+        private readonly WeakReference<WebBrowser> _parent;
+        private WebBrowser Parent
+        {
+            get
+            {
+                if (_parent.TryGetTarget(out var target))
+                {
+                    return target;
+                }
+
+                return null;
+            }
+        }
+
         private bool _haveNavigated;
 
         public WebBrowserEvent(WebBrowser parent)
         {
-            _parent = parent;
+            _parent = new(parent);
         }
 
         public bool AllowNavigation { get; set; }
@@ -27,11 +40,11 @@ public void CommandStateChange(SHDocVw.CSC command, bool enable)
         {
             if (command == SHDocVw.CSC.NAVIGATEBACK)
             {
-                _parent.CanGoBackInternal = enable;
+                Parent.CanGoBackInternal = enable;
             }
             else if (command == SHDocVw.CSC.NAVIGATEFORWARD)
             {
-                _parent.CanGoForwardInternal = enable;
+                Parent.CanGoForwardInternal = enable;
             }
         }
 
@@ -44,7 +57,7 @@ public void BeforeNavigate2(
             ref object? headers,
             ref bool cancel)
         {
-            Debug.Assert(_parent is not null, "Parent should have been set");
+            Debug.Assert(Parent is not null, "Parent should have been set");
             //Note: we want to allow navigation if we haven't already navigated.
             if (AllowNavigation || !_haveNavigated)
             {
@@ -62,7 +75,7 @@ public void BeforeNavigate2(
                 string urlString = urlObject is null ? string.Empty : (string)urlObject;
                 WebBrowserNavigatingEventArgs e = new WebBrowserNavigatingEventArgs(
                     new Uri(urlString), targetFrameName is null ? string.Empty : (string)targetFrameName);
-                _parent.OnNavigating(e);
+                Parent.OnNavigating(e);
                 cancel = e.Cancel;
             }
             else
@@ -75,38 +88,38 @@ public unsafe void DocumentComplete(object pDisp, ref object? urlObject)
         {
             Debug.Assert(urlObject is null || urlObject is string, "invalid url");
             _haveNavigated = true;
-            if (_parent._documentStreamToSetOnLoad is not null && (string?)urlObject == "about:blank")
+            if (Parent._documentStreamToSetOnLoad is not null && (string?)urlObject == "about:blank")
             {
-                HtmlDocument? htmlDocument = _parent.Document;
+                HtmlDocument? htmlDocument = Parent.Document;
                 if (htmlDocument is not null)
                 {
                     IPersistStreamInit.Interface? psi = htmlDocument.DomDocument as IPersistStreamInit.Interface;
                     Debug.Assert(psi is not null, "The Document does not implement IPersistStreamInit");
-                    using var pStream = ComHelpers.GetComScope<IStream>(new Ole32.GPStream(_parent._documentStreamToSetOnLoad));
+                    using var pStream = ComHelpers.GetComScope<IStream>(new Ole32.GPStream(Parent._documentStreamToSetOnLoad));
                     psi.Load(pStream);
                     htmlDocument.Encoding = "unicode";
                 }
 
-                _parent._documentStreamToSetOnLoad = null;
+                Parent._documentStreamToSetOnLoad = null;
             }
             else
             {
                 string urlString = urlObject is null ? string.Empty : urlObject.ToString()!;
                 WebBrowserDocumentCompletedEventArgs e = new WebBrowserDocumentCompletedEventArgs(
                         new Uri(urlString));
-                _parent.OnDocumentCompleted(e);
+                Parent.OnDocumentCompleted(e);
             }
         }
 
         public void TitleChange(string text)
         {
-            _parent.OnDocumentTitleChanged(EventArgs.Empty);
+            Parent.OnDocumentTitleChanged(EventArgs.Empty);
         }
 
         public void SetSecureLockIcon(int secureLockIcon)
         {
-            _parent._encryptionLevel = (WebBrowserEncryptionLevel)secureLockIcon;
-            _parent.OnEncryptionLevelChanged(EventArgs.Empty);
+            Parent._encryptionLevel = (WebBrowserEncryptionLevel)secureLockIcon;
+            Parent.OnEncryptionLevelChanged(EventArgs.Empty);
         }
 
         public void NavigateComplete2(object pDisp, ref object? urlObject)
@@ -115,29 +128,29 @@ public void NavigateComplete2(object pDisp, ref object? urlObject)
             string urlString = urlObject is null ? string.Empty : (string)urlObject;
             WebBrowserNavigatedEventArgs e = new WebBrowserNavigatedEventArgs(
                     new Uri(urlString));
-            _parent.OnNavigated(e);
+            Parent.OnNavigated(e);
         }
 
         public void NewWindow2(ref object ppDisp, ref bool cancel)
         {
             CancelEventArgs e = new CancelEventArgs();
-            _parent.OnNewWindow(e);
+            Parent.OnNewWindow(e);
             cancel = e.Cancel;
         }
 
         public void ProgressChange(int progress, int progressMax)
         {
             WebBrowserProgressChangedEventArgs e = new WebBrowserProgressChangedEventArgs(progress, progressMax);
-            _parent.OnProgressChanged(e);
+            Parent.OnProgressChanged(e);
         }
 
         public void StatusTextChange(string text)
         {
-            _parent._statusText = text ?? string.Empty;
-            _parent.OnStatusTextChanged(EventArgs.Empty);
+            Parent._statusText = text ?? string.Empty;
+            Parent.OnStatusTextChanged(EventArgs.Empty);
         }
 
-        public void DownloadBegin() => _parent.OnFileDownload(EventArgs.Empty);
+        public void DownloadBegin() => Parent.OnFileDownload(EventArgs.Empty);
 
         public void FileDownload(ref bool cancel)
         {
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowserSiteBase.cs b/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowserSiteBase.cs
index 8a68e12caaa..ab407d5890c 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowserSiteBase.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/WebBrowserSiteBase.cs
@@ -30,7 +30,7 @@ public unsafe class WebBrowserSiteBase :
     IPropertyNotifySink.Interface,
     IDisposable
 {
-    private readonly WebBrowserBase host;
+    private readonly WeakReference<WebBrowserBase> host;
     private AxHost.ConnectionPointCookie? connectionPoint;
 
     //
@@ -40,7 +40,7 @@ public unsafe class WebBrowserSiteBase :
     //
     internal WebBrowserSiteBase(WebBrowserBase h)
     {
-        host = h.OrThrowIfNull();
+        host = new(h.OrThrowIfNull());
     }
 
     /// <summary>
@@ -65,7 +65,18 @@ protected virtual void Dispose(bool disposing)
     /// <summary>
     ///  Retrieves the WebBrowserBase object set in the constructor.
     /// </summary>
-    internal WebBrowserBase Host => host;
+    internal WebBrowserBase Host
+    {
+        get
+        {
+            if (host.TryGetTarget(out var target))
+            {
+                return target;
+            }
+
+            return null;
+        }
+    }
 
     // IOleControlSite methods:
     HRESULT IOleControlSite.Interface.OnControlInfoChanged() => HRESULT.S_OK;
diff --git a/src/System.Windows.Forms/src/System/Windows/Forms/WinFormsUtils.cs b/src/System.Windows.Forms/src/System/Windows/Forms/WinFormsUtils.cs
index a7f07670528..62358ac4d6a 100644
--- a/src/System.Windows.Forms/src/System/Windows/Forms/WinFormsUtils.cs
+++ b/src/System.Windows.Forms/src/System/Windows/Forms/WinFormsUtils.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections;
 using System.ComponentModel;
 using System.Drawing;
 using System.Globalization;
@@ -11,6 +12,40 @@ namespace System.Windows.Forms;
 
 internal sealed partial class WindowsFormsUtils
 {
+    public class ArraySubsetEnumerator : IEnumerator
+    {
+        private readonly object[] _array;
+        private readonly int _total;
+        private int _current;
+
+        public ArraySubsetEnumerator(object[] array, int count)
+        {
+            Debug.Assert(count == 0 || array != null, "if array is null, count should be 0");
+            Debug.Assert(array == null || count <= array.Length, "Trying to enumerate more than the array contains");
+            _array = array;
+            _total = count;
+            _current = -1;
+        }
+
+        public bool MoveNext()
+        {
+            if (_current < _total - 1)
+            {
+                _current++;
+                return true;
+            }
+
+            return false;
+        }
+
+        public void Reset()
+        {
+            _current = -1;
+        }
+
+        public object Current => _current == -1 ? null : _array[_current];
+    }
+
     public const ContentAlignment AnyRightAlign = ContentAlignment.TopRight | ContentAlignment.MiddleRight | ContentAlignment.BottomRight;
     public const ContentAlignment AnyLeftAlign = ContentAlignment.TopLeft | ContentAlignment.MiddleLeft | ContentAlignment.BottomLeft;
     public const ContentAlignment AnyTopAlign = ContentAlignment.TopLeft | ContentAlignment.TopCenter | ContentAlignment.TopRight;
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.csproj b/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.csproj
deleted file mode 100644
index 893fee5eac4..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.csproj
+++ /dev/null
@@ -1,39 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <RootNamespace>Accessibility_Core_App</RootNamespace>
-    <AssemblyName>Accessibility_Core_App</AssemblyName>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing.Common\src\System.Drawing.Common.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Update="Properties\Resources.Designer.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Update="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="HTMLPage1.html">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.sln b/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.sln
deleted file mode 100644
index f68d55595eb..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Accessibility_Core_App.sln
+++ /dev/null
@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.3.32622.301
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Accessibility_Core_App", "Accessibility_Core_App.csproj", "{D7BB93BE-9D7E-407F-85DB-DC8BBB364FFD}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D7BB93BE-9D7E-407F-85DB-DC8BBB364FFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D7BB93BE-9D7E-407F-85DB-DC8BBB364FFD}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D7BB93BE-9D7E-407F-85DB-DC8BBB364FFD}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D7BB93BE-9D7E-407F-85DB-DC8BBB364FFD}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {1651E338-125D-4AAD-BAA2-00625873964D}
-	EndGlobalSection
-EndGlobal
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.Designer.cs
deleted file mode 100644
index 5bd00f214a2..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.Designer.cs
+++ /dev/null
@@ -1,765 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class CommonControl1
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.Windows.Forms.ListViewItem listViewItem1 = new System.Windows.Forms.ListViewItem("1");
-        System.Windows.Forms.ListViewItem listViewItem2 = new System.Windows.Forms.ListViewItem("2");
-        System.Windows.Forms.ListViewItem listViewItem3 = new System.Windows.Forms.ListViewItem("3");
-        System.Windows.Forms.ListViewItem listViewItem4 = new System.Windows.Forms.ListViewItem("4");
-        this.groupBox1 = new System.Windows.Forms.GroupBox();
-        this.button12 = new System.Windows.Forms.Button();
-        this.button1 = new System.Windows.Forms.Button();
-        this.button10 = new System.Windows.Forms.Button();
-        this.button9 = new System.Windows.Forms.Button();
-        this.button8 = new System.Windows.Forms.Button();
-        this.button3 = new System.Windows.Forms.Button();
-        this.button4 = new System.Windows.Forms.Button();
-        this.button5 = new System.Windows.Forms.Button();
-        this.button2 = new System.Windows.Forms.Button();
-        this.button6 = new System.Windows.Forms.Button();
-        this.groupBox2 = new System.Windows.Forms.GroupBox();
-        this.checkedListBox1 = new System.Windows.Forms.CheckedListBox();
-        this.label7 = new System.Windows.Forms.Label();
-        this.checkBox3 = new System.Windows.Forms.CheckBox();
-        this.checkBox2 = new System.Windows.Forms.CheckBox();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.groupBox3 = new System.Windows.Forms.GroupBox();
-        this.comboBox2 = new System.Windows.Forms.ComboBox();
-        this.label11 = new System.Windows.Forms.Label();
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.label10 = new System.Windows.Forms.Label();
-        this.groupBox4 = new System.Windows.Forms.GroupBox();
-        this.listView1 = new System.Windows.Forms.ListView();
-        this.label8 = new System.Windows.Forms.Label();
-        this.groupBox5 = new System.Windows.Forms.GroupBox();
-        this.linkLabel6 = new System.Windows.Forms.LinkLabel();
-        this.linkLabel5 = new System.Windows.Forms.LinkLabel();
-        this.linkLabel4 = new System.Windows.Forms.LinkLabel();
-        this.linkLabel3 = new System.Windows.Forms.LinkLabel();
-        this.label6 = new System.Windows.Forms.Label();
-        this.label5 = new System.Windows.Forms.Label();
-        this.label4 = new System.Windows.Forms.Label();
-        this.label3 = new System.Windows.Forms.Label();
-        this.linkLabel2 = new System.Windows.Forms.LinkLabel();
-        this.linkLabel1 = new System.Windows.Forms.LinkLabel();
-        this.label2 = new System.Windows.Forms.Label();
-        this.label1 = new System.Windows.Forms.Label();
-        this.groupBox6 = new System.Windows.Forms.GroupBox();
-        this.listBox1 = new System.Windows.Forms.ListBox();
-        this.label12 = new System.Windows.Forms.Label();
-        this.groupBox7 = new System.Windows.Forms.GroupBox();
-        this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox();
-        this.label9 = new System.Windows.Forms.Label();
-        this.groupBox8 = new System.Windows.Forms.GroupBox();
-        this.dateTimePicker3 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker2 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker1 = new System.Windows.Forms.DateTimePicker();
-        this.groupBox1.SuspendLayout();
-        this.groupBox2.SuspendLayout();
-        this.groupBox3.SuspendLayout();
-        this.groupBox4.SuspendLayout();
-        this.groupBox5.SuspendLayout();
-        this.groupBox6.SuspendLayout();
-        this.groupBox7.SuspendLayout();
-        this.groupBox8.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // groupBox1
-        // 
-        this.groupBox1.Controls.Add(this.button12);
-        this.groupBox1.Controls.Add(this.button1);
-        this.groupBox1.Controls.Add(this.button10);
-        this.groupBox1.Controls.Add(this.button9);
-        this.groupBox1.Controls.Add(this.button8);
-        this.groupBox1.Controls.Add(this.button3);
-        this.groupBox1.Controls.Add(this.button4);
-        this.groupBox1.Controls.Add(this.button5);
-        this.groupBox1.Controls.Add(this.button2);
-        this.groupBox1.Controls.Add(this.button6);
-        this.groupBox1.Location = new System.Drawing.Point(32, 4);
-        this.groupBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox1.Name = "groupBox1";
-        this.groupBox1.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox1.Size = new System.Drawing.Size(771, 380);
-        this.groupBox1.TabIndex = 0;
-        this.groupBox1.TabStop = false;
-        this.groupBox1.Text = "Button";
-        // 
-        // button12
-        // 
-        this.button12.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.button12.Location = new System.Drawing.Point(15, 309);
-        this.button12.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button12.Name = "button12";
-        this.button12.Size = new System.Drawing.Size(130, 58);
-        this.button12.TabIndex = 4;
-        this.button12.Text = "System";
-        this.button12.UseVisualStyleBackColor = true;
-        // 
-        // button1
-        // 
-        this.button1.Anchor = System.Windows.Forms.AnchorStyles.Left;
-        this.button1.Location = new System.Drawing.Point(240, 245);
-        this.button1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(130, 58);
-        this.button1.TabIndex = 8;
-        this.button1.Text = "Details";
-        this.button1.UseVisualStyleBackColor = true;
-        this.button1.Click += new System.EventHandler(this.button1_Click);
-        // 
-        // button10
-        // 
-        this.button10.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-        this.button10.Location = new System.Drawing.Point(15, 105);
-        this.button10.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button10.Name = "button10";
-        this.button10.Size = new System.Drawing.Size(130, 58);
-        this.button10.TabIndex = 1;
-        this.button10.Text = "Flat";
-        this.button10.UseVisualStyleBackColor = true;
-        // 
-        // button9
-        // 
-        this.button9.Location = new System.Drawing.Point(15, 245);
-        this.button9.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button9.Name = "button9";
-        this.button9.Size = new System.Drawing.Size(130, 58);
-        this.button9.TabIndex = 3;
-        this.button9.Text = "Standard";
-        this.button9.UseVisualStyleBackColor = true;
-        // 
-        // button8
-        // 
-        this.button8.FlatStyle = System.Windows.Forms.FlatStyle.Popup;
-        this.button8.Location = new System.Drawing.Point(15, 175);
-        this.button8.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button8.Name = "button8";
-        this.button8.Size = new System.Drawing.Size(130, 58);
-        this.button8.TabIndex = 2;
-        this.button8.Text = "PopUp";
-        this.button8.UseVisualStyleBackColor = true;
-        // 
-        // button3
-        // 
-        this.button3.Anchor = System.Windows.Forms.AnchorStyles.Right;
-        this.button3.Location = new System.Drawing.Point(15, 34);
-        this.button3.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button3.Name = "button3";
-        this.button3.Size = new System.Drawing.Size(130, 58);
-        this.button3.TabIndex = 0;
-        this.button3.Text = "List";
-        this.button3.UseVisualStyleBackColor = false;
-        this.button3.Click += new System.EventHandler(this.button3_Click);
-        // 
-        // button4
-        // 
-        this.button4.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
-        this.button4.Location = new System.Drawing.Point(240, 309);
-        this.button4.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button4.Name = "button4";
-        this.button4.Size = new System.Drawing.Size(156, 58);
-        this.button4.TabIndex = 9;
-        this.button4.Text = "SmallIcon";
-        this.button4.UseVisualStyleBackColor = true;
-        this.button4.Click += new System.EventHandler(this.button4_Click);
-        // 
-        // button5
-        // 
-        this.button5.AutoSize = true;
-        this.button5.Location = new System.Drawing.Point(240, 100);
-        this.button5.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button5.Name = "button5";
-        this.button5.Size = new System.Drawing.Size(175, 63);
-        this.button5.TabIndex = 6;
-        this.button5.Text = "AutoSizeTrue";
-        this.button5.UseVisualStyleBackColor = true;
-        // 
-        // button2
-        // 
-        this.button2.Anchor = System.Windows.Forms.AnchorStyles.Top;
-        this.button2.Location = new System.Drawing.Point(241, 34);
-        this.button2.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(156, 58);
-        this.button2.TabIndex = 5;
-        this.button2.Text = "LargeIcon";
-        this.button2.UseVisualStyleBackColor = true;
-        this.button2.Click += new System.EventHandler(this.button2_Click);
-        // 
-        // button6
-        // 
-        this.button6.Location = new System.Drawing.Point(240, 175);
-        this.button6.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.button6.Name = "button6";
-        this.button6.Size = new System.Drawing.Size(175, 58);
-        this.button6.TabIndex = 7;
-        this.button6.Text = "AutoSizeFalse";
-        this.button6.UseVisualStyleBackColor = true;
-        // 
-        // groupBox2
-        // 
-        this.groupBox2.Controls.Add(this.checkedListBox1);
-        this.groupBox2.Controls.Add(this.label7);
-        this.groupBox2.Controls.Add(this.checkBox3);
-        this.groupBox2.Controls.Add(this.checkBox2);
-        this.groupBox2.Controls.Add(this.checkBox1);
-        this.groupBox2.Location = new System.Drawing.Point(32, 397);
-        this.groupBox2.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox2.Name = "groupBox2";
-        this.groupBox2.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox2.Size = new System.Drawing.Size(771, 269);
-        this.groupBox2.TabIndex = 1;
-        this.groupBox2.TabStop = false;
-        this.groupBox2.Text = "CheckedBox";
-        // 
-        // checkedListBox1
-        // 
-        this.checkedListBox1.FormattingEnabled = true;
-        this.checkedListBox1.Items.AddRange(new object[] {
-        "Winforms1",
-        "Winforms2",
-        "Winforms3"});
-        this.checkedListBox1.Location = new System.Drawing.Point(299, 83);
-        this.checkedListBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.checkedListBox1.Name = "checkedListBox1";
-        this.checkedListBox1.Size = new System.Drawing.Size(255, 148);
-        this.checkedListBox1.TabIndex = 4;
-        // 
-        // label7
-        // 
-        this.label7.AutoSize = true;
-        this.label7.Location = new System.Drawing.Point(301, 32);
-        this.label7.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label7.Name = "label7";
-        this.label7.Size = new System.Drawing.Size(180, 32);
-        this.label7.TabIndex = 3;
-        this.label7.Text = "CheckedListBox";
-        // 
-        // checkBox3
-        // 
-        this.checkBox3.AutoSize = true;
-        this.checkBox3.Location = new System.Drawing.Point(15, 137);
-        this.checkBox3.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.checkBox3.Name = "checkBox3";
-        this.checkBox3.Size = new System.Drawing.Size(160, 36);
-        this.checkBox3.TabIndex = 2;
-        this.checkBox3.Text = "ThreeState";
-        this.checkBox3.ThreeState = true;
-        this.checkBox3.UseVisualStyleBackColor = true;
-        // 
-        // checkBox2
-        // 
-        this.checkBox2.AutoSize = true;
-        this.checkBox2.Location = new System.Drawing.Point(15, 83);
-        this.checkBox2.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.checkBox2.Name = "checkBox2";
-        this.checkBox2.Size = new System.Drawing.Size(168, 36);
-        this.checkBox2.TabIndex = 1;
-        this.checkBox2.Text = "UnChecked";
-        this.checkBox2.UseVisualStyleBackColor = true;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Checked = true;
-        this.checkBox1.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.checkBox1.Location = new System.Drawing.Point(15, 30);
-        this.checkBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(138, 36);
-        this.checkBox1.TabIndex = 0;
-        this.checkBox1.Text = "Checked";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // groupBox3
-        // 
-        this.groupBox3.Controls.Add(this.comboBox2);
-        this.groupBox3.Controls.Add(this.label11);
-        this.groupBox3.Controls.Add(this.comboBox1);
-        this.groupBox3.Controls.Add(this.label10);
-        this.groupBox3.Location = new System.Drawing.Point(839, 4);
-        this.groupBox3.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox3.Name = "groupBox3";
-        this.groupBox3.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox3.Size = new System.Drawing.Size(600, 380);
-        this.groupBox3.TabIndex = 4;
-        this.groupBox3.TabStop = false;
-        this.groupBox3.Text = "ComboBox";
-        // 
-        // comboBox2
-        // 
-        this.comboBox2.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox2.FormattingEnabled = true;
-        this.comboBox2.Items.AddRange(new object[] {
-        "1",
-        "2",
-        "3",
-        "4",
-        "5"});
-        this.comboBox2.Location = new System.Drawing.Point(314, 85);
-        this.comboBox2.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.comboBox2.Name = "comboBox2";
-        this.comboBox2.Size = new System.Drawing.Size(257, 266);
-        this.comboBox2.TabIndex = 3;
-        // 
-        // label11
-        // 
-        this.label11.AutoSize = true;
-        this.label11.Location = new System.Drawing.Point(371, 34);
-        this.label11.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label11.Name = "label11";
-        this.label11.Size = new System.Drawing.Size(138, 32);
-        this.label11.TabIndex = 2;
-        this.label11.Text = "SimpleStyle";
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Items.AddRange(new object[] {
-        "1",
-        "2",
-        "3",
-        "4",
-        "5"});
-        this.comboBox1.Location = new System.Drawing.Point(15, 90);
-        this.comboBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(257, 40);
-        this.comboBox1.TabIndex = 1;
-        // 
-        // label10
-        // 
-        this.label10.AutoSize = true;
-        this.label10.Location = new System.Drawing.Point(15, 41);
-        this.label10.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label10.Name = "label10";
-        this.label10.Size = new System.Drawing.Size(180, 32);
-        this.label10.TabIndex = 0;
-        this.label10.Text = "DropDownStyle";
-        // 
-        // groupBox4
-        // 
-        this.groupBox4.Controls.Add(this.listView1);
-        this.groupBox4.Controls.Add(this.label8);
-        this.groupBox4.Location = new System.Drawing.Point(839, 397);
-        this.groupBox4.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox4.Name = "groupBox4";
-        this.groupBox4.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox4.Size = new System.Drawing.Size(598, 269);
-        this.groupBox4.TabIndex = 5;
-        this.groupBox4.TabStop = false;
-        this.groupBox4.Text = "ListView";
-        // 
-        // listView1
-        // 
-        this.listView1.Items.AddRange(new System.Windows.Forms.ListViewItem[] {
-        listViewItem1,
-        listViewItem2,
-        listViewItem3,
-        listViewItem4});
-        this.listView1.Location = new System.Drawing.Point(149, 83);
-        this.listView1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.listView1.Name = "listView1";
-        this.listView1.Size = new System.Drawing.Size(257, 151);
-        this.listView1.TabIndex = 1;
-        this.listView1.UseCompatibleStateImageBehavior = false;
-        // 
-        // label8
-        // 
-        this.label8.AutoSize = true;
-        this.label8.Location = new System.Drawing.Point(223, 30);
-        this.label8.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label8.Name = "label8";
-        this.label8.Size = new System.Drawing.Size(100, 32);
-        this.label8.TabIndex = 0;
-        this.label8.Text = "ListView";
-        // 
-        // groupBox5
-        // 
-        this.groupBox5.Controls.Add(this.linkLabel6);
-        this.groupBox5.Controls.Add(this.linkLabel5);
-        this.groupBox5.Controls.Add(this.linkLabel4);
-        this.groupBox5.Controls.Add(this.linkLabel3);
-        this.groupBox5.Controls.Add(this.label6);
-        this.groupBox5.Controls.Add(this.label5);
-        this.groupBox5.Controls.Add(this.label4);
-        this.groupBox5.Controls.Add(this.label3);
-        this.groupBox5.Controls.Add(this.linkLabel2);
-        this.groupBox5.Controls.Add(this.linkLabel1);
-        this.groupBox5.Controls.Add(this.label2);
-        this.groupBox5.Controls.Add(this.label1);
-        this.groupBox5.Location = new System.Drawing.Point(33, 678);
-        this.groupBox5.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox5.Name = "groupBox5";
-        this.groupBox5.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox5.Size = new System.Drawing.Size(769, 271);
-        this.groupBox5.TabIndex = 2;
-        this.groupBox5.TabStop = false;
-        this.groupBox5.Text = "Label";
-        // 
-        // linkLabel6
-        // 
-        this.linkLabel6.Anchor = System.Windows.Forms.AnchorStyles.Top;
-        this.linkLabel6.AutoSize = true;
-        this.linkLabel6.Location = new System.Drawing.Point(386, 38);
-        this.linkLabel6.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel6.Name = "linkLabel6";
-        this.linkLabel6.Size = new System.Drawing.Size(44, 32);
-        this.linkLabel6.TabIndex = 5;
-        this.linkLabel6.TabStop = true;
-        this.linkLabel6.Text = "Up";
-        // 
-        // linkLabel5
-        // 
-        this.linkLabel5.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
-        this.linkLabel5.AutoSize = true;
-        this.linkLabel5.Location = new System.Drawing.Point(340, 207);
-        this.linkLabel5.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel5.Name = "linkLabel5";
-        this.linkLabel5.Size = new System.Drawing.Size(93, 32);
-        this.linkLabel5.TabIndex = 9;
-        this.linkLabel5.TabStop = true;
-        this.linkLabel5.Text = "Bottom";
-        // 
-        // linkLabel4
-        // 
-        this.linkLabel4.Anchor = System.Windows.Forms.AnchorStyles.Right;
-        this.linkLabel4.AutoSize = true;
-        this.linkLabel4.Location = new System.Drawing.Point(598, 143);
-        this.linkLabel4.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel4.Name = "linkLabel4";
-        this.linkLabel4.Size = new System.Drawing.Size(70, 32);
-        this.linkLabel4.TabIndex = 11;
-        this.linkLabel4.TabStop = true;
-        this.linkLabel4.Text = "Right";
-        // 
-        // linkLabel3
-        // 
-        this.linkLabel3.Anchor = System.Windows.Forms.AnchorStyles.Left;
-        this.linkLabel3.AutoSize = true;
-        this.linkLabel3.Location = new System.Drawing.Point(17, 143);
-        this.linkLabel3.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel3.Name = "linkLabel3";
-        this.linkLabel3.Size = new System.Drawing.Size(54, 32);
-        this.linkLabel3.TabIndex = 1;
-        this.linkLabel3.TabStop = true;
-        this.linkLabel3.Text = "Left";
-        // 
-        // label6
-        // 
-        this.label6.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
-        this.label6.AutoSize = true;
-        this.label6.Location = new System.Drawing.Point(154, 207);
-        this.label6.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label6.Name = "label6";
-        this.label6.Size = new System.Drawing.Size(93, 32);
-        this.label6.TabIndex = 8;
-        this.label6.Text = "Bottom";
-        // 
-        // label5
-        // 
-        this.label5.Anchor = System.Windows.Forms.AnchorStyles.Left;
-        this.label5.AutoSize = true;
-        this.label5.Location = new System.Drawing.Point(15, 87);
-        this.label5.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label5.Name = "label5";
-        this.label5.Size = new System.Drawing.Size(54, 32);
-        this.label5.TabIndex = 0;
-        this.label5.Text = "Left";
-        // 
-        // label4
-        // 
-        this.label4.Anchor = System.Windows.Forms.AnchorStyles.Right;
-        this.label4.AutoSize = true;
-        this.label4.Location = new System.Drawing.Point(598, 87);
-        this.label4.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label4.Name = "label4";
-        this.label4.Size = new System.Drawing.Size(70, 32);
-        this.label4.TabIndex = 10;
-        this.label4.Text = "Right";
-        // 
-        // label3
-        // 
-        this.label3.Anchor = System.Windows.Forms.AnchorStyles.Top;
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(171, 41);
-        this.label3.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(44, 32);
-        this.label3.TabIndex = 4;
-        this.label3.Text = "Up";
-        // 
-        // linkLabel2
-        // 
-        this.linkLabel2.Location = new System.Drawing.Point(340, 143);
-        this.linkLabel2.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel2.Name = "linkLabel2";
-        this.linkLabel2.Size = new System.Drawing.Size(217, 58);
-        this.linkLabel2.TabIndex = 7;
-        this.linkLabel2.TabStop = true;
-        this.linkLabel2.Text = "AutoSizeFalse";
-        // 
-        // linkLabel1
-        // 
-        this.linkLabel1.AutoSize = true;
-        this.linkLabel1.Location = new System.Drawing.Point(340, 87);
-        this.linkLabel1.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.linkLabel1.Name = "linkLabel1";
-        this.linkLabel1.Size = new System.Drawing.Size(154, 32);
-        this.linkLabel1.TabIndex = 6;
-        this.linkLabel1.TabStop = true;
-        this.linkLabel1.Text = "AutoSizeTrue";
-        // 
-        // label2
-        // 
-        this.label2.Location = new System.Drawing.Point(121, 143);
-        this.label2.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(217, 58);
-        this.label2.TabIndex = 3;
-        this.label2.Text = "AutoSizeFalse";
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(121, 87);
-        this.label1.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(154, 32);
-        this.label1.TabIndex = 2;
-        this.label1.Text = "AutoSizeTrue";
-        // 
-        // groupBox6
-        // 
-        this.groupBox6.Controls.Add(this.listBox1);
-        this.groupBox6.Controls.Add(this.label12);
-        this.groupBox6.Location = new System.Drawing.Point(839, 678);
-        this.groupBox6.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox6.Name = "groupBox6";
-        this.groupBox6.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox6.Size = new System.Drawing.Size(598, 271);
-        this.groupBox6.TabIndex = 6;
-        this.groupBox6.TabStop = false;
-        this.groupBox6.Text = "ListBox";
-        // 
-        // listBox1
-        // 
-        this.listBox1.FormattingEnabled = true;
-        this.listBox1.ItemHeight = 32;
-        this.listBox1.Items.AddRange(new object[] {
-        "1",
-        "2",
-        "3",
-        "4"});
-        this.listBox1.Location = new System.Drawing.Point(150, 77);
-        this.listBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.listBox1.Name = "listBox1";
-        this.listBox1.Size = new System.Drawing.Size(255, 164);
-        this.listBox1.TabIndex = 1;
-        // 
-        // label12
-        // 
-        this.label12.AutoSize = true;
-        this.label12.Location = new System.Drawing.Point(223, 38);
-        this.label12.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label12.Name = "label12";
-        this.label12.Size = new System.Drawing.Size(83, 32);
-        this.label12.TabIndex = 0;
-        this.label12.Text = "listbox";
-        // 
-        // groupBox7
-        // 
-        this.groupBox7.Controls.Add(this.maskedTextBox1);
-        this.groupBox7.Controls.Add(this.label9);
-        this.groupBox7.Location = new System.Drawing.Point(702, 983);
-        this.groupBox7.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox7.Name = "groupBox7";
-        this.groupBox7.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox7.Size = new System.Drawing.Size(735, 277);
-        this.groupBox7.TabIndex = 7;
-        this.groupBox7.TabStop = false;
-        this.groupBox7.Text = "MaskedTextBox";
-        // 
-        // maskedTextBox1
-        // 
-        this.maskedTextBox1.Location = new System.Drawing.Point(288, 119);
-        this.maskedTextBox1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.maskedTextBox1.Name = "maskedTextBox1";
-        this.maskedTextBox1.Size = new System.Drawing.Size(212, 39);
-        this.maskedTextBox1.TabIndex = 1;
-        // 
-        // label9
-        // 
-        this.label9.AutoSize = true;
-        this.label9.Location = new System.Drawing.Point(15, 126);
-        this.label9.Margin = new System.Windows.Forms.Padding(7, 0, 7, 0);
-        this.label9.Name = "label9";
-        this.label9.Size = new System.Drawing.Size(171, 32);
-        this.label9.TabIndex = 0;
-        this.label9.Text = "MaskedTextBix";
-        // 
-        // groupBox8
-        // 
-        this.groupBox8.Controls.Add(this.dateTimePicker3);
-        this.groupBox8.Controls.Add(this.dateTimePicker2);
-        this.groupBox8.Controls.Add(this.dateTimePicker1);
-        this.groupBox8.Location = new System.Drawing.Point(33, 983);
-        this.groupBox8.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox8.Name = "groupBox8";
-        this.groupBox8.Padding = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.groupBox8.Size = new System.Drawing.Size(570, 277);
-        this.groupBox8.TabIndex = 3;
-        this.groupBox8.TabStop = false;
-        this.groupBox8.Text = "DataTimerPicker";
-        // 
-        // dateTimePicker3
-        // 
-        this.dateTimePicker3.AccessibleName = "DTP2";
-        this.dateTimePicker3.Location = new System.Drawing.Point(37, 126);
-        this.dateTimePicker3.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.dateTimePicker3.Name = "dateTimePicker3";
-        this.dateTimePicker3.Size = new System.Drawing.Size(429, 39);
-        this.dateTimePicker3.TabIndex = 1;
-        // 
-        // dateTimePicker2
-        // 
-        this.dateTimePicker2.AccessibleName = "DTP3";
-        this.dateTimePicker2.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
-        this.dateTimePicker2.Location = new System.Drawing.Point(37, 205);
-        this.dateTimePicker2.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.dateTimePicker2.Name = "dateTimePicker2";
-        this.dateTimePicker2.RightToLeft = System.Windows.Forms.RightToLeft.Yes;
-        this.dateTimePicker2.Size = new System.Drawing.Size(429, 39);
-        this.dateTimePicker2.TabIndex = 2;
-        // 
-        // dateTimePicker1
-        // 
-        this.dateTimePicker1.AccessibleName = "DTP1";
-        this.dateTimePicker1.CalendarForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(192)))), ((int)(((byte)(128)))));
-        this.dateTimePicker1.CalendarMonthBackground = System.Drawing.Color.Yellow;
-        this.dateTimePicker1.CalendarTitleBackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(192)))), ((int)(((byte)(255)))));
-        this.dateTimePicker1.CalendarTitleForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(224)))), ((int)(((byte)(192)))));
-        this.dateTimePicker1.CalendarTrailingForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(192)))), ((int)(((byte)(255)))), ((int)(((byte)(255)))));
-        this.dateTimePicker1.Location = new System.Drawing.Point(37, 47);
-        this.dateTimePicker1.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.dateTimePicker1.Name = "dateTimePicker1";
-        this.dateTimePicker1.ShowCheckBox = true;
-        this.dateTimePicker1.Size = new System.Drawing.Size(457, 39);
-        this.dateTimePicker1.TabIndex = 0;
-        // 
-        // CommonControl1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(13F, 32F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.AutoScroll = true;
-        this.ClientSize = new System.Drawing.Size(1482, 1291);
-        this.Controls.Add(this.groupBox8);
-        this.Controls.Add(this.groupBox7);
-        this.Controls.Add(this.groupBox6);
-        this.Controls.Add(this.groupBox5);
-        this.Controls.Add(this.groupBox4);
-        this.Controls.Add(this.groupBox3);
-        this.Controls.Add(this.groupBox2);
-        this.Controls.Add(this.groupBox1);
-        this.Margin = new System.Windows.Forms.Padding(7, 6, 7, 6);
-        this.Name = "CommonControl1";
-        this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
-        this.Text = "CommonControl1";
-        this.Load += new System.EventHandler(this.MainForm_Load);
-        this.groupBox1.ResumeLayout(false);
-        this.groupBox1.PerformLayout();
-        this.groupBox2.ResumeLayout(false);
-        this.groupBox2.PerformLayout();
-        this.groupBox3.ResumeLayout(false);
-        this.groupBox3.PerformLayout();
-        this.groupBox4.ResumeLayout(false);
-        this.groupBox4.PerformLayout();
-        this.groupBox5.ResumeLayout(false);
-        this.groupBox5.PerformLayout();
-        this.groupBox6.ResumeLayout(false);
-        this.groupBox6.PerformLayout();
-        this.groupBox7.ResumeLayout(false);
-        this.groupBox7.PerformLayout();
-        this.groupBox8.ResumeLayout(false);
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.GroupBox groupBox1;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Button button3;
-    private System.Windows.Forms.Button button4;
-    private System.Windows.Forms.Button button5;
-    private System.Windows.Forms.Button button6;
-    private System.Windows.Forms.Button button12;
-    private System.Windows.Forms.Button button10;
-    private System.Windows.Forms.Button button9;
-    private System.Windows.Forms.Button button8;
-    private System.Windows.Forms.Button button2;
-    private System.Windows.Forms.GroupBox groupBox2;
-    private System.Windows.Forms.CheckBox checkBox3;
-    private System.Windows.Forms.CheckBox checkBox2;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.GroupBox groupBox3;
-    private System.Windows.Forms.GroupBox groupBox4;
-    private System.Windows.Forms.GroupBox groupBox5;
-    private System.Windows.Forms.LinkLabel linkLabel2;
-    private System.Windows.Forms.LinkLabel linkLabel1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.LinkLabel linkLabel6;
-    private System.Windows.Forms.LinkLabel linkLabel5;
-    private System.Windows.Forms.LinkLabel linkLabel4;
-    private System.Windows.Forms.LinkLabel linkLabel3;
-    private System.Windows.Forms.Label label6;
-    private System.Windows.Forms.Label label5;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.GroupBox groupBox6;
-    private System.Windows.Forms.GroupBox groupBox7;
-    private System.Windows.Forms.GroupBox groupBox8;
-    private System.Windows.Forms.DateTimePicker dateTimePicker2;
-    private System.Windows.Forms.DateTimePicker dateTimePicker1;
-    private System.Windows.Forms.DateTimePicker dateTimePicker3;
-    private System.Windows.Forms.CheckedListBox checkedListBox1;
-    private System.Windows.Forms.Label label7;
-    private System.Windows.Forms.ListView listView1;
-    private System.Windows.Forms.Label label8;
-    private System.Windows.Forms.MaskedTextBox maskedTextBox1;
-    private System.Windows.Forms.Label label9;
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.Label label10;
-    private System.Windows.Forms.ComboBox comboBox2;
-    private System.Windows.Forms.Label label11;
-    private System.Windows.Forms.ListBox listBox1;
-    private System.Windows.Forms.Label label12;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.cs
deleted file mode 100644
index e3a4138981d..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class CommonControl1 : Form
-{
-    public CommonControl1()
-    {
-        InitializeComponent();
-    }
-
-    private void MainForm_Load(object sender, EventArgs e)
-    {
-        ImageList imageListSmall = new ImageList();
-        ImageList imageListLarge = new ImageList();
-        listView1.LargeImageList = imageListLarge;
-        listView1.SmallImageList = imageListSmall;
-    }
-
-    private void button2_Click(object sender, EventArgs e)
-    {
-        listView1.View = View.LargeIcon;
-    }
-
-    private void button4_Click(object sender, EventArgs e)
-    {
-        listView1.View = View.SmallIcon;
-    }
-
-    private void button1_Click(object sender, EventArgs e)
-    {
-        listView1.View = View.Details;
-    }
-
-    private void button3_Click(object sender, EventArgs e)
-    {
-        listView1.View = View.List;
-    }
-
-    private void button11_Click(object sender, EventArgs e)
-    {
-        listView1.ShowGroups = true;
-        listView1.Groups[0].Items.Add(listView1.Items[0]);
-        listView1.Groups[1].Items.AddRange(new ListViewItem[] { listView1.Items[1], listView1.Items[2] });
-    }
-
-    private void button7_Click(object sender, EventArgs e)
-    {
-        listView1.ShowGroups = false;
-    }
-
-    private void maskedTextBox1_MaskInputRejected(object sender, MaskInputRejectedEventArgs e)
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.resx b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl1.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.Designer.cs
deleted file mode 100644
index b473b799111..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.Designer.cs
+++ /dev/null
@@ -1,308 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class CommonControl2
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.Windows.Forms.TreeNode treeNode1 = new System.Windows.Forms.TreeNode("Node10WinformsTeam");
-        System.Windows.Forms.TreeNode treeNode2 = new System.Windows.Forms.TreeNode("Node11");
-        System.Windows.Forms.TreeNode treeNode3 = new System.Windows.Forms.TreeNode("Node1", new System.Windows.Forms.TreeNode[] {
-        treeNode1,
-        treeNode2});
-        System.Windows.Forms.TreeNode treeNode4 = new System.Windows.Forms.TreeNode("Node20");
-        System.Windows.Forms.TreeNode treeNode5 = new System.Windows.Forms.TreeNode("Node2", new System.Windows.Forms.TreeNode[] {
-        treeNode4});
-        System.Windows.Forms.TreeNode treeNode6 = new System.Windows.Forms.TreeNode("Node0", new System.Windows.Forms.TreeNode[] {
-        treeNode3,
-        treeNode5});
-        System.Windows.Forms.TreeNode treeNode7 = new System.Windows.Forms.TreeNode("Node4");
-        System.Windows.Forms.TreeNode treeNode8 = new System.Windows.Forms.TreeNode("Node3", new System.Windows.Forms.TreeNode[] {
-        treeNode7});
-        this.label3 = new System.Windows.Forms.Label();
-        this.pictureBox1 = new System.Windows.Forms.PictureBox();
-        this.label4 = new System.Windows.Forms.Label();
-        this.progressBar1 = new System.Windows.Forms.ProgressBar();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.label5 = new System.Windows.Forms.Label();
-        this.richTextBox1 = new System.Windows.Forms.RichTextBox();
-        this.label6 = new System.Windows.Forms.Label();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.label7 = new System.Windows.Forms.Label();
-        this.treeView1 = new System.Windows.Forms.TreeView();
-        this.label8 = new System.Windows.Forms.Label();
-        this.webBrowser1 = new System.Windows.Forms.WebBrowser();
-        this.label1 = new System.Windows.Forms.Label();
-        this.monthCalendar1 = new System.Windows.Forms.MonthCalendar();
-        this.label2 = new System.Windows.Forms.Label();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // label3
-        // 
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(18, 278);
-        this.label3.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(64, 15);
-        this.label3.TabIndex = 4;
-        this.label3.Text = "PictureBox";
-        // 
-        // pictureBox1
-        // 
-        this.pictureBox1.Image = global::Accessibility_Core_App.Properties.Resources.TestResult;
-        this.pictureBox1.Location = new System.Drawing.Point(18, 301);
-        this.pictureBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.pictureBox1.Name = "pictureBox1";
-        this.pictureBox1.Size = new System.Drawing.Size(231, 141);
-        this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
-        this.pictureBox1.TabIndex = 5;
-        this.pictureBox1.TabStop = false;
-        // 
-        // label4
-        // 
-        this.label4.AutoSize = true;
-        this.label4.Location = new System.Drawing.Point(517, 153);
-        this.label4.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label4.Name = "label4";
-        this.label4.Size = new System.Drawing.Size(81, 15);
-        this.label4.TabIndex = 6;
-        this.label4.Text = "ProgressBar01";
-        // 
-        // progressBar1
-        // 
-        this.progressBar1.BackColor = System.Drawing.Color.Lime;
-        this.progressBar1.Location = new System.Drawing.Point(517, 175);
-        this.progressBar1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.progressBar1.Name = "progressBar1";
-        this.progressBar1.Size = new System.Drawing.Size(223, 27);
-        this.progressBar1.TabIndex = 7;
-        this.progressBar1.Value = 60;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.AutoSize = true;
-        this.radioButton1.Checked = true;
-        this.radioButton1.Location = new System.Drawing.Point(18, 459);
-        this.radioButton1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(94, 19);
-        this.radioButton1.TabIndex = 8;
-        this.radioButton1.TabStop = true;
-        this.radioButton1.Text = "radioButton1";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // label5
-        // 
-        this.label5.AutoSize = true;
-        this.label5.Location = new System.Drawing.Point(309, 10);
-        this.label5.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label5.Name = "label5";
-        this.label5.Size = new System.Drawing.Size(71, 15);
-        this.label5.TabIndex = 9;
-        this.label5.Text = "RichTextBox";
-        // 
-        // richTextBox1
-        // 
-        this.richTextBox1.BackColor = System.Drawing.SystemColors.Window;
-        this.richTextBox1.Location = new System.Drawing.Point(313, 36);
-        this.richTextBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.richTextBox1.Name = "richTextBox1";
-        this.richTextBox1.Size = new System.Drawing.Size(130, 104);
-        this.richTextBox1.TabIndex = 10;
-        this.richTextBox1.Text = "winforms\nclickonce\ncontrols\nteam\nwinforms1\nwinforms2\nwinforms3";
-        // 
-        // label6
-        // 
-        this.label6.AutoSize = true;
-        this.label6.Location = new System.Drawing.Point(313, 153);
-        this.label6.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label6.Name = "label6";
-        this.label6.Size = new System.Drawing.Size(48, 15);
-        this.label6.TabIndex = 11;
-        this.label6.Text = "TextBox";
-        // 
-        // textBox1
-        // 
-        this.textBox1.AutoCompleteCustomSource.AddRange(new string[] {
-        "winforms",
-        "Team",
-        "MTP",
-        "FXBVT"});
-        this.textBox1.Location = new System.Drawing.Point(313, 175);
-        this.textBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(116, 23);
-        this.textBox1.TabIndex = 12;
-        // 
-        // label7
-        // 
-        this.label7.AutoSize = true;
-        this.label7.Location = new System.Drawing.Point(517, 10);
-        this.label7.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label7.Name = "label7";
-        this.label7.Size = new System.Drawing.Size(53, 15);
-        this.label7.TabIndex = 13;
-        this.label7.Text = "TreeView";
-        // 
-        // treeView1
-        // 
-        this.treeView1.Location = new System.Drawing.Point(517, 36);
-        this.treeView1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.treeView1.Name = "treeView1";
-        treeNode1.Name = "Node10";
-        treeNode1.Text = "Node10WinformsTeam";
-        treeNode2.Name = "Node11";
-        treeNode2.Text = "Node11";
-        treeNode3.Name = "Node1";
-        treeNode3.Text = "Node1";
-        treeNode4.Name = "Node20";
-        treeNode4.Text = "Node20";
-        treeNode5.Name = "Node2";
-        treeNode5.Text = "Node2";
-        treeNode6.Name = "Node0";
-        treeNode6.Text = "Node0";
-        treeNode7.Name = "Node4";
-        treeNode7.Text = "Node4";
-        treeNode8.Name = "Node3";
-        treeNode8.Text = "Node3";
-        this.treeView1.Nodes.AddRange(new System.Windows.Forms.TreeNode[] {
-        treeNode6,
-        treeNode8});
-        this.treeView1.Size = new System.Drawing.Size(220, 104);
-        this.treeView1.TabIndex = 14;
-        // 
-        // label8
-        // 
-        this.label8.AutoSize = true;
-        this.label8.Location = new System.Drawing.Point(313, 218);
-        this.label8.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label8.Name = "label8";
-        this.label8.Size = new System.Drawing.Size(73, 15);
-        this.label8.TabIndex = 15;
-        this.label8.Text = "WebBrowser";
-        // 
-        // webBrowser1
-        // 
-        this.webBrowser1.Location = new System.Drawing.Point(313, 236);
-        this.webBrowser1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.webBrowser1.MinimumSize = new System.Drawing.Size(23, 23);
-        this.webBrowser1.Name = "webBrowser1";
-        this.webBrowser1.ScriptErrorsSuppressed = true;
-        this.webBrowser1.Size = new System.Drawing.Size(512, 242);
-        this.webBrowser1.TabIndex = 16;
-        //this.webBrowser1.Url = new System.Uri("https://www.bing.com/", System.UriKind.Absolute);
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(14, 10);
-        this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(90, 15);
-        this.label1.TabIndex = 0;
-        this.label1.Text = "MonthCalendar";
-        // 
-        // monthCalendar1
-        // 
-        this.monthCalendar1.Location = new System.Drawing.Point(18, 36);
-        this.monthCalendar1.Margin = new System.Windows.Forms.Padding(10);
-        this.monthCalendar1.Name = "monthCalendar1";
-        this.monthCalendar1.TabIndex = 1;
-        // 
-        // label2
-        // 
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(18, 218);
-        this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(102, 15);
-        this.label2.TabIndex = 2;
-        this.label2.Text = "numericUpdown";
-        // 
-        // numericUpDown1
-        // 
-        this.numericUpDown1.Location = new System.Drawing.Point(18, 236);
-        this.numericUpDown1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.numericUpDown1.Name = "numericUpDown1";
-        this.numericUpDown1.Size = new System.Drawing.Size(140, 23);
-        this.numericUpDown1.TabIndex = 3;
-        // 
-        // CommonControl2
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.AutoScroll = true;
-        this.ClientSize = new System.Drawing.Size(850, 501);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.monthCalendar1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.numericUpDown1);
-        this.Controls.Add(this.label3);
-        this.Controls.Add(this.pictureBox1);
-        this.Controls.Add(this.label4);
-        this.Controls.Add(this.progressBar1);
-        this.Controls.Add(this.radioButton1);
-        this.Controls.Add(this.label5);
-        this.Controls.Add(this.richTextBox1);
-        this.Controls.Add(this.label6);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.label7);
-        this.Controls.Add(this.treeView1);
-        this.Controls.Add(this.label8);
-        this.Controls.Add(this.webBrowser1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "CommonControl2";
-        this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
-        this.Text = "CommonControl2";
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.PictureBox pictureBox1;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.ProgressBar progressBar1;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.Label label5;
-    private System.Windows.Forms.RichTextBox richTextBox1;
-    private System.Windows.Forms.Label label6;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.Label label7;
-    private System.Windows.Forms.TreeView treeView1;
-    private System.Windows.Forms.Label label8;
-    private System.Windows.Forms.WebBrowser webBrowser1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.MonthCalendar monthCalendar1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.cs
deleted file mode 100644
index c8a0cdd8eda..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class CommonControl2 : Form
-{
-    public CommonControl2()
-    {
-        InitializeComponent();
-        
-        string executable = Environment.ProcessPath;
-        string executablePath = Path.GetDirectoryName(executable);
-        var page = Path.Combine(executablePath, "HTMLPage1.html");
-        this.webBrowser1.Url = new System.Uri($"file://{page}", System.UriKind.Absolute);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.resx b/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CommonControl2.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.Designer.cs
deleted file mode 100644
index bd86222eaae..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.Designer.cs
+++ /dev/null
@@ -1,919 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class ContainerControls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.flowLayoutPanel2 = new System.Windows.Forms.FlowLayoutPanel();
-        this.button2 = new System.Windows.Forms.Button();
-        this.button5 = new System.Windows.Forms.Button();
-        this.button6 = new System.Windows.Forms.Button();
-        this.label2 = new System.Windows.Forms.Label();
-        this.label3 = new System.Windows.Forms.Label();
-        this.label4 = new System.Windows.Forms.Label();
-        this.groupBox1 = new System.Windows.Forms.GroupBox();
-        this.button7 = new System.Windows.Forms.Button();
-        this.groupBox2 = new System.Windows.Forms.GroupBox();
-        this.button8 = new System.Windows.Forms.Button();
-        this.groupBox3 = new System.Windows.Forms.GroupBox();
-        this.button9 = new System.Windows.Forms.Button();
-        this.groupBox4 = new System.Windows.Forms.GroupBox();
-        this.button10 = new System.Windows.Forms.Button();
-        this.label6 = new System.Windows.Forms.Label();
-        this.label7 = new System.Windows.Forms.Label();
-        this.radioButton6 = new System.Windows.Forms.RadioButton();
-        this.radioButton5 = new System.Windows.Forms.RadioButton();
-        this.radioButton4 = new System.Windows.Forms.RadioButton();
-        this.checkBox2 = new System.Windows.Forms.CheckBox();
-        this.radioButton3 = new System.Windows.Forms.RadioButton();
-        this.radioButton2 = new System.Windows.Forms.RadioButton();
-        this.button18 = new System.Windows.Forms.Button();
-        this.button17 = new System.Windows.Forms.Button();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.label10 = new System.Windows.Forms.Label();
-        this.tabControl5 = new System.Windows.Forms.TabControl();
-        this.tabPage9 = new System.Windows.Forms.TabPage();
-        this.button19 = new System.Windows.Forms.Button();
-        this.tabPage10 = new System.Windows.Forms.TabPage();
-        this.tabControl6 = new System.Windows.Forms.TabControl();
-        this.tabPage11 = new System.Windows.Forms.TabPage();
-        this.button20 = new System.Windows.Forms.Button();
-        this.tabPage12 = new System.Windows.Forms.TabPage();
-        this.button21 = new System.Windows.Forms.Button();
-        this.flowLayoutPanel1 = new System.Windows.Forms.FlowLayoutPanel();
-        this.button4 = new System.Windows.Forms.Button();
-        this.button1 = new System.Windows.Forms.Button();
-        this.button3 = new System.Windows.Forms.Button();
-        this.label1 = new System.Windows.Forms.Label();
-        this.panel2 = new System.Windows.Forms.Panel();
-        this.tabControl2 = new System.Windows.Forms.TabControl();
-        this.tabPage1 = new System.Windows.Forms.TabPage();
-        this.tabPage2 = new System.Windows.Forms.TabPage();
-        this.button12 = new System.Windows.Forms.Button();
-        this.label5 = new System.Windows.Forms.Label();
-        this.panel1 = new System.Windows.Forms.Panel();
-        this.tabControl1 = new System.Windows.Forms.TabControl();
-        this.tabPage3 = new System.Windows.Forms.TabPage();
-        this.button11 = new System.Windows.Forms.Button();
-        this.tabPage4 = new System.Windows.Forms.TabPage();
-        this.button13 = new System.Windows.Forms.Button();
-        this.flowLayoutPanel3 = new System.Windows.Forms.FlowLayoutPanel();
-        this.button14 = new System.Windows.Forms.Button();
-        this.button22 = new System.Windows.Forms.Button();
-        this.button23 = new System.Windows.Forms.Button();
-        this.panel3 = new System.Windows.Forms.Panel();
-        this.tabControl3 = new System.Windows.Forms.TabControl();
-        this.tabPage5 = new System.Windows.Forms.TabPage();
-        this.tabPage6 = new System.Windows.Forms.TabPage();
-        this.button24 = new System.Windows.Forms.Button();
-        this.flowLayoutPanel2.SuspendLayout();
-        this.groupBox1.SuspendLayout();
-        this.groupBox2.SuspendLayout();
-        this.groupBox3.SuspendLayout();
-        this.groupBox4.SuspendLayout();
-        this.tabControl5.SuspendLayout();
-        this.tabPage9.SuspendLayout();
-        this.tabPage10.SuspendLayout();
-        this.tabControl6.SuspendLayout();
-        this.tabPage11.SuspendLayout();
-        this.tabPage12.SuspendLayout();
-        this.flowLayoutPanel1.SuspendLayout();
-        this.panel2.SuspendLayout();
-        this.tabControl2.SuspendLayout();
-        this.tabPage2.SuspendLayout();
-        this.panel1.SuspendLayout();
-        this.tabControl1.SuspendLayout();
-        this.tabPage3.SuspendLayout();
-        this.tabPage4.SuspendLayout();
-        this.flowLayoutPanel3.SuspendLayout();
-        this.panel3.SuspendLayout();
-        this.tabControl3.SuspendLayout();
-        this.tabPage6.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // flowLayoutPanel2
-        // 
-        this.flowLayoutPanel2.AutoScroll = true;
-        this.flowLayoutPanel2.BackColor = System.Drawing.Color.White;
-        this.flowLayoutPanel2.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
-        this.flowLayoutPanel2.Controls.Add(this.button2);
-        this.flowLayoutPanel2.Controls.Add(this.button5);
-        this.flowLayoutPanel2.Controls.Add(this.button6);
-        this.flowLayoutPanel2.FlowDirection = System.Windows.Forms.FlowDirection.RightToLeft;
-        this.flowLayoutPanel2.Location = new System.Drawing.Point(26, 31);
-        this.flowLayoutPanel2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.flowLayoutPanel2.Name = "flowLayoutPanel2";
-        this.flowLayoutPanel2.Size = new System.Drawing.Size(186, 106);
-        this.flowLayoutPanel2.TabIndex = 1;
-        // 
-        // button2
-        // 
-        this.button2.Location = new System.Drawing.Point(90, 3);
-        this.button2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(88, 27);
-        this.button2.TabIndex = 0;
-        this.button2.Text = "button2";
-        this.button2.UseVisualStyleBackColor = true;
-        // 
-        // button5
-        // 
-        this.button5.Location = new System.Drawing.Point(90, 36);
-        this.button5.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button5.Name = "button5";
-        this.button5.Size = new System.Drawing.Size(88, 27);
-        this.button5.TabIndex = 1;
-        this.button5.Text = "button5";
-        this.button5.UseVisualStyleBackColor = true;
-        // 
-        // button6
-        // 
-        this.button6.Location = new System.Drawing.Point(90, 69);
-        this.button6.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button6.Name = "button6";
-        this.button6.Size = new System.Drawing.Size(88, 27);
-        this.button6.TabIndex = 2;
-        this.button6.Text = "button6";
-        this.button6.UseVisualStyleBackColor = true;
-        // 
-        // label2
-        // 
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(26, 172);
-        this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(203, 15);
-        this.label2.TabIndex = 6;
-        this.label2.Text = "Fixed3D_RightToLeft_AutoScroll:False";
-        // 
-        // label3
-        // 
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(26, 10);
-        this.label3.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(97, 15);
-        this.label3.TabIndex = 0;
-        this.label3.Text = "FlowLayoutPanel";
-        // 
-        // label4
-        // 
-        this.label4.AutoSize = true;
-        this.label4.Location = new System.Drawing.Point(28, 427);
-        this.label4.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label4.Name = "label4";
-        this.label4.Size = new System.Drawing.Size(60, 15);
-        this.label4.TabIndex = 14;
-        this.label4.Text = "GroupBox";
-        // 
-        // groupBox1
-        // 
-        this.groupBox1.Controls.Add(this.button7);
-        this.groupBox1.Location = new System.Drawing.Point(194, 445);
-        this.groupBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox1.Name = "groupBox1";
-        this.groupBox1.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox1.Size = new System.Drawing.Size(130, 69);
-        this.groupBox1.TabIndex = 16;
-        this.groupBox1.TabStop = false;
-        this.groupBox1.Text = "FlatStyle=Standard";
-        // 
-        // button7
-        // 
-        this.button7.Location = new System.Drawing.Point(12, 22);
-        this.button7.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button7.Name = "button7";
-        this.button7.Size = new System.Drawing.Size(88, 27);
-        this.button7.TabIndex = 0;
-        this.button7.Text = "button7";
-        this.button7.UseVisualStyleBackColor = true;
-        // 
-        // groupBox2
-        // 
-        this.groupBox2.Controls.Add(this.button8);
-        this.groupBox2.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-        this.groupBox2.Location = new System.Drawing.Point(33, 445);
-        this.groupBox2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox2.Name = "groupBox2";
-        this.groupBox2.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox2.Size = new System.Drawing.Size(130, 69);
-        this.groupBox2.TabIndex = 15;
-        this.groupBox2.TabStop = false;
-        this.groupBox2.Text = "FlatStyle=Flat";
-        // 
-        // button8
-        // 
-        this.button8.Location = new System.Drawing.Point(12, 22);
-        this.button8.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button8.Name = "button8";
-        this.button8.Size = new System.Drawing.Size(88, 27);
-        this.button8.TabIndex = 0;
-        this.button8.Text = "button8";
-        this.button8.UseVisualStyleBackColor = true;
-        // 
-        // groupBox3
-        // 
-        this.groupBox3.Controls.Add(this.button9);
-        this.groupBox3.FlatStyle = System.Windows.Forms.FlatStyle.Popup;
-        this.groupBox3.Location = new System.Drawing.Point(522, 445);
-        this.groupBox3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox3.Name = "groupBox3";
-        this.groupBox3.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox3.Size = new System.Drawing.Size(130, 69);
-        this.groupBox3.TabIndex = 18;
-        this.groupBox3.TabStop = false;
-        this.groupBox3.Text = "FlatStyle=Popup";
-        // 
-        // button9
-        // 
-        this.button9.Location = new System.Drawing.Point(12, 22);
-        this.button9.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button9.Name = "button9";
-        this.button9.Size = new System.Drawing.Size(88, 27);
-        this.button9.TabIndex = 0;
-        this.button9.Text = "button9";
-        this.button9.UseVisualStyleBackColor = true;
-        // 
-        // groupBox4
-        // 
-        this.groupBox4.Controls.Add(this.button10);
-        this.groupBox4.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.groupBox4.Location = new System.Drawing.Point(350, 445);
-        this.groupBox4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox4.Name = "groupBox4";
-        this.groupBox4.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox4.Size = new System.Drawing.Size(130, 69);
-        this.groupBox4.TabIndex = 17;
-        this.groupBox4.TabStop = false;
-        this.groupBox4.Text = "FlatStyle=System";
-        // 
-        // button10
-        // 
-        this.button10.Location = new System.Drawing.Point(12, 22);
-        this.button10.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button10.Name = "button10";
-        this.button10.Size = new System.Drawing.Size(88, 27);
-        this.button10.TabIndex = 0;
-        this.button10.Text = "button10";
-        this.button10.UseVisualStyleBackColor = true;
-        // 
-        // label6
-        // 
-        this.label6.AutoSize = true;
-        this.label6.Location = new System.Drawing.Point(285, 172);
-        this.label6.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label6.Name = "label6";
-        this.label6.Size = new System.Drawing.Size(186, 15);
-        this.label6.TabIndex = 8;
-        this.label6.Text = "Panel_FixedSingle_AutoScroll:True";
-        // 
-        // label7
-        // 
-        this.label7.AutoSize = true;
-        this.label7.Location = new System.Drawing.Point(561, 172);
-        this.label7.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label7.Name = "label7";
-        this.label7.Size = new System.Drawing.Size(172, 15);
-        this.label7.TabIndex = 10;
-        this.label7.Text = "Panel_Fixed3D_AutoScroll:False";
-        // 
-        // radioButton6
-        // 
-        this.radioButton6.AutoSize = true;
-        this.radioButton6.Location = new System.Drawing.Point(223, 72);
-        this.radioButton6.Name = "radioButton6";
-        this.radioButton6.Size = new System.Drawing.Size(15, 17);
-        this.radioButton6.TabIndex = 9;
-        this.radioButton6.Text = "radioButton6";
-        this.radioButton6.UseVisualStyleBackColor = true;
-        // 
-        // radioButton5
-        // 
-        this.radioButton5.AutoSize = true;
-        this.radioButton5.Location = new System.Drawing.Point(203, 72);
-        this.radioButton5.Name = "radioButton5";
-        this.radioButton5.Size = new System.Drawing.Size(14, 17);
-        this.radioButton5.TabIndex = 8;
-        this.radioButton5.Text = "radioButton5";
-        this.radioButton5.UseVisualStyleBackColor = true;
-        // 
-        // radioButton4
-        // 
-        this.radioButton4.AutoSize = true;
-        this.radioButton4.Location = new System.Drawing.Point(183, 72);
-        this.radioButton4.Name = "radioButton4";
-        this.radioButton4.Size = new System.Drawing.Size(14, 17);
-        this.radioButton4.TabIndex = 7;
-        this.radioButton4.Text = "radioButton4";
-        this.radioButton4.UseVisualStyleBackColor = true;
-        // 
-        // checkBox2
-        // 
-        this.checkBox2.AutoSize = true;
-        this.checkBox2.Checked = true;
-        this.checkBox2.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.checkBox2.Location = new System.Drawing.Point(93, 72);
-        this.checkBox2.Name = "checkBox2";
-        this.checkBox2.Size = new System.Drawing.Size(80, 17);
-        this.checkBox2.TabIndex = 6;
-        this.checkBox2.Text = "checkBox2";
-        this.checkBox2.UseVisualStyleBackColor = true;
-        // 
-        // radioButton3
-        // 
-        this.radioButton3.AutoSize = true;
-        this.radioButton3.Checked = true;
-        this.radioButton3.Location = new System.Drawing.Point(223, 3);
-        this.radioButton3.Name = "radioButton3";
-        this.radioButton3.Size = new System.Drawing.Size(15, 17);
-        this.radioButton3.TabIndex = 4;
-        this.radioButton3.TabStop = true;
-        this.radioButton3.Text = "radioButton3";
-        this.radioButton3.UseVisualStyleBackColor = true;
-        // 
-        // radioButton2
-        // 
-        this.radioButton2.AutoSize = true;
-        this.radioButton2.Location = new System.Drawing.Point(203, 3);
-        this.radioButton2.Name = "radioButton2";
-        this.radioButton2.Size = new System.Drawing.Size(14, 17);
-        this.radioButton2.TabIndex = 3;
-        this.radioButton2.Text = "radioButton2";
-        this.radioButton2.UseVisualStyleBackColor = true;
-        // 
-        // button18
-        // 
-        this.button18.Location = new System.Drawing.Point(93, 3);
-        this.button18.Name = "button18";
-        this.button18.Size = new System.Drawing.Size(75, 23);
-        this.button18.TabIndex = 1;
-        this.button18.Text = "button18";
-        this.button18.UseVisualStyleBackColor = true;
-        // 
-        // button17
-        // 
-        this.button17.Location = new System.Drawing.Point(3, 3);
-        this.button17.Name = "button17";
-        this.button17.Size = new System.Drawing.Size(75, 23);
-        this.button17.TabIndex = 0;
-        this.button17.Text = "button17";
-        this.button17.UseVisualStyleBackColor = true;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.AutoSize = true;
-        this.radioButton1.Location = new System.Drawing.Point(183, 3);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(14, 17);
-        this.radioButton1.TabIndex = 2;
-        this.radioButton1.Text = "radioButton1";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(3, 72);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(80, 17);
-        this.checkBox1.TabIndex = 5;
-        this.checkBox1.Text = "checkBox1";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // label10
-        // 
-        this.label10.AutoSize = true;
-        this.label10.Location = new System.Drawing.Point(561, 10);
-        this.label10.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label10.Name = "label10";
-        this.label10.Size = new System.Drawing.Size(70, 15);
-        this.label10.TabIndex = 4;
-        this.label10.Text = "Tab_Control";
-        // 
-        // tabControl5
-        // 
-        this.tabControl5.Controls.Add(this.tabPage9);
-        this.tabControl5.Controls.Add(this.tabPage10);
-        this.tabControl5.Location = new System.Drawing.Point(561, 31);
-        this.tabControl5.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl5.Name = "tabControl5";
-        this.tabControl5.SelectedIndex = 0;
-        this.tabControl5.Size = new System.Drawing.Size(219, 138);
-        this.tabControl5.TabIndex = 5;
-        // 
-        // tabPage9
-        // 
-        this.tabPage9.Controls.Add(this.button19);
-        this.tabPage9.Location = new System.Drawing.Point(4, 24);
-        this.tabPage9.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage9.Name = "tabPage9";
-        this.tabPage9.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage9.Size = new System.Drawing.Size(211, 110);
-        this.tabPage9.TabIndex = 0;
-        this.tabPage9.Text = "tabPage9";
-        this.tabPage9.UseVisualStyleBackColor = true;
-        // 
-        // button19
-        // 
-        this.button19.Location = new System.Drawing.Point(16, 24);
-        this.button19.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button19.Name = "button19";
-        this.button19.Size = new System.Drawing.Size(88, 27);
-        this.button19.TabIndex = 0;
-        this.button19.Text = "button19";
-        this.button19.UseVisualStyleBackColor = true;
-        // 
-        // tabPage10
-        // 
-        this.tabPage10.Controls.Add(this.tabControl6);
-        this.tabPage10.Location = new System.Drawing.Point(4, 24);
-        this.tabPage10.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage10.Name = "tabPage10";
-        this.tabPage10.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage10.Size = new System.Drawing.Size(211, 110);
-        this.tabPage10.TabIndex = 1;
-        this.tabPage10.Text = "tabPage10";
-        this.tabPage10.UseVisualStyleBackColor = true;
-        // 
-        // tabControl6
-        // 
-        this.tabControl6.Controls.Add(this.tabPage11);
-        this.tabControl6.Controls.Add(this.tabPage12);
-        this.tabControl6.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.tabControl6.Location = new System.Drawing.Point(4, 3);
-        this.tabControl6.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl6.Name = "tabControl6";
-        this.tabControl6.SelectedIndex = 0;
-        this.tabControl6.Size = new System.Drawing.Size(203, 104);
-        this.tabControl6.TabIndex = 0;
-        // 
-        // tabPage11
-        // 
-        this.tabPage11.Controls.Add(this.button20);
-        this.tabPage11.Location = new System.Drawing.Point(4, 24);
-        this.tabPage11.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage11.Name = "tabPage11";
-        this.tabPage11.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage11.Size = new System.Drawing.Size(195, 76);
-        this.tabPage11.TabIndex = 0;
-        this.tabPage11.Text = "tabPage11";
-        this.tabPage11.UseVisualStyleBackColor = true;
-        // 
-        // button20
-        // 
-        this.button20.Location = new System.Drawing.Point(0, 0);
-        this.button20.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button20.Name = "button20";
-        this.button20.Size = new System.Drawing.Size(88, 27);
-        this.button20.TabIndex = 0;
-        this.button20.Text = "button20";
-        this.button20.UseVisualStyleBackColor = true;
-        // 
-        // tabPage12
-        // 
-        this.tabPage12.Controls.Add(this.button21);
-        this.tabPage12.Location = new System.Drawing.Point(4, 24);
-        this.tabPage12.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage12.Name = "tabPage12";
-        this.tabPage12.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage12.Size = new System.Drawing.Size(195, 76);
-        this.tabPage12.TabIndex = 1;
-        this.tabPage12.Text = "tabPage12";
-        this.tabPage12.UseVisualStyleBackColor = true;
-        // 
-        // button21
-        // 
-        this.button21.Location = new System.Drawing.Point(9, 9);
-        this.button21.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button21.Name = "button21";
-        this.button21.Size = new System.Drawing.Size(88, 27);
-        this.button21.TabIndex = 0;
-        this.button21.Text = "button21";
-        this.button21.UseVisualStyleBackColor = true;
-        // 
-        // flowLayoutPanel1
-        // 
-        this.flowLayoutPanel1.AutoScroll = true;
-        this.flowLayoutPanel1.BackColor = System.Drawing.Color.White;
-        this.flowLayoutPanel1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.flowLayoutPanel1.Controls.Add(this.button4);
-        this.flowLayoutPanel1.Controls.Add(this.button1);
-        this.flowLayoutPanel1.Controls.Add(this.button3);
-        this.flowLayoutPanel1.Location = new System.Drawing.Point(26, 192);
-        this.flowLayoutPanel1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.flowLayoutPanel1.Name = "flowLayoutPanel1";
-        this.flowLayoutPanel1.Size = new System.Drawing.Size(203, 102);
-        this.flowLayoutPanel1.TabIndex = 7;
-        // 
-        // button4
-        // 
-        this.button4.Location = new System.Drawing.Point(4, 3);
-        this.button4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button4.Name = "button4";
-        this.button4.Size = new System.Drawing.Size(88, 27);
-        this.button4.TabIndex = 0;
-        this.button4.Text = "button4";
-        this.button4.UseVisualStyleBackColor = true;
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(100, 3);
-        this.button1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(88, 27);
-        this.button1.TabIndex = 1;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // button3
-        // 
-        this.button3.Location = new System.Drawing.Point(4, 36);
-        this.button3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button3.Name = "button3";
-        this.button3.Size = new System.Drawing.Size(88, 27);
-        this.button3.TabIndex = 2;
-        this.button3.Text = "button3";
-        this.button3.UseVisualStyleBackColor = true;
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(26, 308);
-        this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(217, 15);
-        this.label1.TabIndex = 12;
-        this.label1.Text = "FixedSingle_LeftToRight_AutoScroll:True";
-        // 
-        // panel2
-        // 
-        this.panel2.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
-        this.panel2.Controls.Add(this.tabControl2);
-        this.panel2.Location = new System.Drawing.Point(285, 199);
-        this.panel2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.panel2.Name = "panel2";
-        this.panel2.Size = new System.Drawing.Size(204, 144);
-        this.panel2.TabIndex = 9;
-        // 
-        // tabControl2
-        // 
-        this.tabControl2.Controls.Add(this.tabPage1);
-        this.tabControl2.Controls.Add(this.tabPage2);
-        this.tabControl2.Location = new System.Drawing.Point(8, 12);
-        this.tabControl2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl2.Name = "tabControl2";
-        this.tabControl2.SelectedIndex = 0;
-        this.tabControl2.Size = new System.Drawing.Size(172, 122);
-        this.tabControl2.TabIndex = 1;
-        // 
-        // tabPage1
-        // 
-        this.tabPage1.Location = new System.Drawing.Point(4, 24);
-        this.tabPage1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage1.Name = "tabPage1";
-        this.tabPage1.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage1.Size = new System.Drawing.Size(164, 94);
-        this.tabPage1.TabIndex = 2;
-        this.tabPage1.Text = "tabPage1";
-        this.tabPage1.UseVisualStyleBackColor = true;
-        // 
-        // tabPage2
-        // 
-        this.tabPage2.Controls.Add(this.button12);
-        this.tabPage2.Location = new System.Drawing.Point(4, 24);
-        this.tabPage2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage2.Name = "tabPage2";
-        this.tabPage2.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage2.Size = new System.Drawing.Size(164, 94);
-        this.tabPage2.TabIndex = 3;
-        this.tabPage2.Text = "tabPage2";
-        this.tabPage2.UseVisualStyleBackColor = true;
-        // 
-        // button12
-        // 
-        this.button12.Location = new System.Drawing.Point(17, 24);
-        this.button12.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button12.Name = "button12";
-        this.button12.Size = new System.Drawing.Size(88, 27);
-        this.button12.TabIndex = 0;
-        this.button12.Text = "button12";
-        this.button12.UseVisualStyleBackColor = true;
-        // 
-        // label5
-        // 
-        this.label5.AutoSize = true;
-        this.label5.Location = new System.Drawing.Point(286, 9);
-        this.label5.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label5.Name = "label5";
-        this.label5.Size = new System.Drawing.Size(36, 15);
-        this.label5.TabIndex = 2;
-        this.label5.Text = "Panel";
-        // 
-        // panel1
-        // 
-        this.panel1.AutoScroll = true;
-        this.panel1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.panel1.Controls.Add(this.tabControl1);
-        this.panel1.Location = new System.Drawing.Point(286, 30);
-        this.panel1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.panel1.Name = "panel1";
-        this.panel1.Size = new System.Drawing.Size(192, 128);
-        this.panel1.TabIndex = 3;
-        // 
-        // tabControl1
-        // 
-        this.tabControl1.Controls.Add(this.tabPage3);
-        this.tabControl1.Controls.Add(this.tabPage4);
-        this.tabControl1.Location = new System.Drawing.Point(5, 4);
-        this.tabControl1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl1.Name = "tabControl1";
-        this.tabControl1.SelectedIndex = 0;
-        this.tabControl1.Size = new System.Drawing.Size(156, 102);
-        this.tabControl1.TabIndex = 0;
-        // 
-        // tabPage3
-        // 
-        this.tabPage3.Controls.Add(this.button11);
-        this.tabPage3.Location = new System.Drawing.Point(4, 24);
-        this.tabPage3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage3.Name = "tabPage3";
-        this.tabPage3.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage3.Size = new System.Drawing.Size(148, 74);
-        this.tabPage3.TabIndex = 0;
-        this.tabPage3.Text = "tabPage3";
-        this.tabPage3.UseVisualStyleBackColor = true;
-        // 
-        // button11
-        // 
-        this.button11.Location = new System.Drawing.Point(9, 9);
-        this.button11.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button11.Name = "button11";
-        this.button11.Size = new System.Drawing.Size(88, 27);
-        this.button11.TabIndex = 0;
-        this.button11.Text = "button11";
-        this.button11.UseVisualStyleBackColor = true;
-        // 
-        // tabPage4
-        // 
-        this.tabPage4.Controls.Add(this.button13);
-        this.tabPage4.Location = new System.Drawing.Point(4, 24);
-        this.tabPage4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage4.Name = "tabPage4";
-        this.tabPage4.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage4.Size = new System.Drawing.Size(148, 74);
-        this.tabPage4.TabIndex = 1;
-        this.tabPage4.Text = "tabPage4";
-        this.tabPage4.UseVisualStyleBackColor = true;
-        // 
-        // button13
-        // 
-        this.button13.Location = new System.Drawing.Point(9, 9);
-        this.button13.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button13.Name = "button13";
-        this.button13.Size = new System.Drawing.Size(88, 27);
-        this.button13.TabIndex = 0;
-        this.button13.Text = "button13";
-        this.button13.UseVisualStyleBackColor = true;
-        // 
-        // flowLayoutPanel3
-        // 
-        this.flowLayoutPanel3.AutoScroll = true;
-        this.flowLayoutPanel3.BackColor = System.Drawing.Color.White;
-        this.flowLayoutPanel3.Controls.Add(this.button14);
-        this.flowLayoutPanel3.Controls.Add(this.button22);
-        this.flowLayoutPanel3.Controls.Add(this.button23);
-        this.flowLayoutPanel3.Location = new System.Drawing.Point(26, 326);
-        this.flowLayoutPanel3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.flowLayoutPanel3.Name = "flowLayoutPanel3";
-        this.flowLayoutPanel3.Size = new System.Drawing.Size(180, 98);
-        this.flowLayoutPanel3.TabIndex = 13;
-        // 
-        // button14
-        // 
-        this.button14.Location = new System.Drawing.Point(4, 3);
-        this.button14.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button14.Name = "button14";
-        this.button14.Size = new System.Drawing.Size(88, 27);
-        this.button14.TabIndex = 0;
-        this.button14.Text = "button14";
-        this.button14.UseVisualStyleBackColor = true;
-        // 
-        // button22
-        // 
-        this.button22.Location = new System.Drawing.Point(4, 36);
-        this.button22.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button22.Name = "button22";
-        this.button22.Size = new System.Drawing.Size(88, 27);
-        this.button22.TabIndex = 1;
-        this.button22.Text = "button22";
-        this.button22.UseVisualStyleBackColor = true;
-        // 
-        // button23
-        // 
-        this.button23.Location = new System.Drawing.Point(4, 69);
-        this.button23.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button23.Name = "button23";
-        this.button23.Size = new System.Drawing.Size(88, 27);
-        this.button23.TabIndex = 2;
-        this.button23.Text = "button23";
-        this.button23.UseVisualStyleBackColor = true;
-        // 
-        // panel3
-        // 
-        this.panel3.Controls.Add(this.tabControl3);
-        this.panel3.Location = new System.Drawing.Point(561, 199);
-        this.panel3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.panel3.Name = "panel3";
-        this.panel3.Size = new System.Drawing.Size(211, 136);
-        this.panel3.TabIndex = 11;
-        // 
-        // tabControl3
-        // 
-        this.tabControl3.Controls.Add(this.tabPage5);
-        this.tabControl3.Controls.Add(this.tabPage6);
-        this.tabControl3.Location = new System.Drawing.Point(12, 14);
-        this.tabControl3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl3.Name = "tabControl3";
-        this.tabControl3.SelectedIndex = 0;
-        this.tabControl3.Size = new System.Drawing.Size(187, 118);
-        this.tabControl3.TabIndex = 1;
-        // 
-        // tabPage5
-        // 
-        this.tabPage5.Location = new System.Drawing.Point(4, 24);
-        this.tabPage5.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage5.Name = "tabPage5";
-        this.tabPage5.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage5.Size = new System.Drawing.Size(179, 90);
-        this.tabPage5.TabIndex = 2;
-        this.tabPage5.Text = "tabPage5";
-        this.tabPage5.UseVisualStyleBackColor = true;
-        // 
-        // tabPage6
-        // 
-        this.tabPage6.Controls.Add(this.button24);
-        this.tabPage6.Location = new System.Drawing.Point(4, 24);
-        this.tabPage6.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage6.Name = "tabPage6";
-        this.tabPage6.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage6.Size = new System.Drawing.Size(179, 90);
-        this.tabPage6.TabIndex = 3;
-        this.tabPage6.Text = "tabPage6";
-        this.tabPage6.UseVisualStyleBackColor = true;
-        // 
-        // button24
-        // 
-        this.button24.Location = new System.Drawing.Point(19, 23);
-        this.button24.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button24.Name = "button24";
-        this.button24.Size = new System.Drawing.Size(88, 27);
-        this.button24.TabIndex = 0;
-        this.button24.Text = "button24";
-        this.button24.UseVisualStyleBackColor = true;
-        // 
-        // ContainerControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.AutoScroll = true;
-        this.ClientSize = new System.Drawing.Size(795, 523);
-        this.Controls.Add(this.panel3);
-        this.Controls.Add(this.flowLayoutPanel3);
-        this.Controls.Add(this.panel1);
-        this.Controls.Add(this.label5);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.flowLayoutPanel1);
-        this.Controls.Add(this.tabControl5);
-        this.Controls.Add(this.label10);
-        this.Controls.Add(this.label7);
-        this.Controls.Add(this.label6);
-        this.Controls.Add(this.panel2);
-        this.Controls.Add(this.groupBox4);
-        this.Controls.Add(this.groupBox3);
-        this.Controls.Add(this.groupBox2);
-        this.Controls.Add(this.groupBox1);
-        this.Controls.Add(this.label4);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.label3);
-        this.Controls.Add(this.flowLayoutPanel2);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "ContainerControls";
-        this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
-        this.Text = "Winforms_Containers";
-        this.flowLayoutPanel2.ResumeLayout(false);
-        this.groupBox1.ResumeLayout(false);
-        this.groupBox2.ResumeLayout(false);
-        this.groupBox3.ResumeLayout(false);
-        this.groupBox4.ResumeLayout(false);
-        this.tabControl5.ResumeLayout(false);
-        this.tabPage9.ResumeLayout(false);
-        this.tabPage10.ResumeLayout(false);
-        this.tabControl6.ResumeLayout(false);
-        this.tabPage11.ResumeLayout(false);
-        this.tabPage12.ResumeLayout(false);
-        this.flowLayoutPanel1.ResumeLayout(false);
-        this.panel2.ResumeLayout(false);
-        this.tabControl2.ResumeLayout(false);
-        this.tabPage2.ResumeLayout(false);
-        this.panel1.ResumeLayout(false);
-        this.tabControl1.ResumeLayout(false);
-        this.tabPage3.ResumeLayout(false);
-        this.tabPage4.ResumeLayout(false);
-        this.flowLayoutPanel3.ResumeLayout(false);
-        this.panel3.ResumeLayout(false);
-        this.tabControl3.ResumeLayout(false);
-        this.tabPage6.ResumeLayout(false);
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel2;
-    private System.Windows.Forms.Button button2;
-    private System.Windows.Forms.Button button5;
-    private System.Windows.Forms.Button button6;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.GroupBox groupBox1;
-    private System.Windows.Forms.Button button7;
-    private System.Windows.Forms.GroupBox groupBox2;
-    private System.Windows.Forms.Button button8;
-    private System.Windows.Forms.GroupBox groupBox3;
-    private System.Windows.Forms.Button button9;
-    private System.Windows.Forms.GroupBox groupBox4;
-    private System.Windows.Forms.Button button10;
-    private System.Windows.Forms.Label label6;
-    private System.Windows.Forms.Label label7;
-    private System.Windows.Forms.RadioButton radioButton6;
-    private System.Windows.Forms.RadioButton radioButton5;
-    private System.Windows.Forms.RadioButton radioButton4;
-    private System.Windows.Forms.CheckBox checkBox2;
-    private System.Windows.Forms.RadioButton radioButton3;
-    private System.Windows.Forms.RadioButton radioButton2;
-    private System.Windows.Forms.Button button18;
-    private System.Windows.Forms.Button button17;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.Label label10;
-    private System.Windows.Forms.TabControl tabControl5;
-    private System.Windows.Forms.TabPage tabPage9;
-    private System.Windows.Forms.Button button19;
-    private System.Windows.Forms.TabPage tabPage10;
-    private System.Windows.Forms.TabControl tabControl6;
-    private System.Windows.Forms.TabPage tabPage11;
-    private System.Windows.Forms.Button button20;
-    private System.Windows.Forms.TabPage tabPage12;
-    private System.Windows.Forms.Button button21;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel1;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Button button3;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Panel panel2;
-    private System.Windows.Forms.TabControl tabControl2;
-    private System.Windows.Forms.TabPage tabPage1;
-    private System.Windows.Forms.TabPage tabPage2;
-    private System.Windows.Forms.Button button12;
-    private System.Windows.Forms.Label label5;
-    private System.Windows.Forms.Panel panel1;
-    private System.Windows.Forms.TabControl tabControl1;
-    private System.Windows.Forms.TabPage tabPage3;
-    private System.Windows.Forms.Button button11;
-    private System.Windows.Forms.TabPage tabPage4;
-    private System.Windows.Forms.Button button13;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel3;
-    private System.Windows.Forms.Button button14;
-    private System.Windows.Forms.Button button22;
-    private System.Windows.Forms.Button button23;
-    private System.Windows.Forms.Panel panel3;
-    private System.Windows.Forms.TabControl tabControl3;
-    private System.Windows.Forms.TabPage tabPage5;
-    private System.Windows.Forms.TabPage tabPage6;
-    private System.Windows.Forms.Button button24;
-    private System.Windows.Forms.Button button4;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.cs
deleted file mode 100644
index 66b8c7f6ef6..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class ContainerControls : Form
-{
-    public ContainerControls()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.Designer.cs
deleted file mode 100644
index 77fb285f681..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.Designer.cs
+++ /dev/null
@@ -1,482 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class ContainerControls2
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.label8 = new System.Windows.Forms.Label();
-        this.splitContainer1 = new System.Windows.Forms.SplitContainer();
-        this.button15 = new System.Windows.Forms.Button();
-        this.button16 = new System.Windows.Forms.Button();
-        this.label9 = new System.Windows.Forms.Label();
-        this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
-        this.radioButton6 = new System.Windows.Forms.RadioButton();
-        this.radioButton5 = new System.Windows.Forms.RadioButton();
-        this.radioButton4 = new System.Windows.Forms.RadioButton();
-        this.checkBox2 = new System.Windows.Forms.CheckBox();
-        this.radioButton3 = new System.Windows.Forms.RadioButton();
-        this.radioButton2 = new System.Windows.Forms.RadioButton();
-        this.button18 = new System.Windows.Forms.Button();
-        this.button17 = new System.Windows.Forms.Button();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.label13 = new System.Windows.Forms.Label();
-        this.flowLayoutPanel4 = new System.Windows.Forms.FlowLayoutPanel();
-        this.label14 = new System.Windows.Forms.Label();
-        this.groupBox5 = new System.Windows.Forms.GroupBox();
-        this.label15 = new System.Windows.Forms.Label();
-        this.panel4 = new System.Windows.Forms.Panel();
-        this.label16 = new System.Windows.Forms.Label();
-        this.splitContainer2 = new System.Windows.Forms.SplitContainer();
-        this.label17 = new System.Windows.Forms.Label();
-        this.tabControl4 = new System.Windows.Forms.TabControl();
-        this.tabPage7 = new System.Windows.Forms.TabPage();
-        this.tabPage8 = new System.Windows.Forms.TabPage();
-        this.label18 = new System.Windows.Forms.Label();
-        this.tableLayoutPanel2 = new System.Windows.Forms.TableLayoutPanel();
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
-        this.splitContainer1.Panel1.SuspendLayout();
-        this.splitContainer1.Panel2.SuspendLayout();
-        this.splitContainer1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).BeginInit();
-        this.splitContainer2.SuspendLayout();
-        this.tabControl4.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // label8
-        // 
-        this.label8.AutoSize = true;
-        this.label8.Location = new System.Drawing.Point(13, 21);
-        this.label8.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label8.Name = "label8";
-        this.label8.Size = new System.Drawing.Size(295, 15);
-        this.label8.TabIndex = 0;
-        this.label8.Text = "SplitContainer_SetBackColor_Panel1_Silver_Panel2_Red";
-        // 
-        // splitContainer1
-        // 
-        this.splitContainer1.Location = new System.Drawing.Point(13, 45);
-        this.splitContainer1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.splitContainer1.Name = "splitContainer1";
-        // 
-        // splitContainer1.Panel1
-        // 
-        this.splitContainer1.Panel1.BackColor = System.Drawing.Color.Silver;
-        this.splitContainer1.Panel1.Controls.Add(this.button15);
-        this.splitContainer1.Panel1.RightToLeft = System.Windows.Forms.RightToLeft.No;
-        // 
-        // splitContainer1.Panel2
-        // 
-        this.splitContainer1.Panel2.BackColor = System.Drawing.Color.Red;
-        this.splitContainer1.Panel2.Controls.Add(this.button16);
-        this.splitContainer1.Panel2.RightToLeft = System.Windows.Forms.RightToLeft.No;
-        this.splitContainer1.RightToLeft = System.Windows.Forms.RightToLeft.No;
-        this.splitContainer1.Size = new System.Drawing.Size(273, 142);
-        this.splitContainer1.SplitterDistance = 98;
-        this.splitContainer1.SplitterWidth = 5;
-        this.splitContainer1.TabIndex = 1;
-        // 
-        // button15
-        // 
-        this.button15.Location = new System.Drawing.Point(10, 57);
-        this.button15.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button15.Name = "button15";
-        this.button15.Size = new System.Drawing.Size(74, 27);
-        this.button15.TabIndex = 0;
-        this.button15.Text = "button15";
-        this.button15.UseVisualStyleBackColor = true;
-        // 
-        // button16
-        // 
-        this.button16.Location = new System.Drawing.Point(21, 57);
-        this.button16.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button16.Name = "button16";
-        this.button16.Size = new System.Drawing.Size(88, 27);
-        this.button16.TabIndex = 0;
-        this.button16.Text = "button16";
-        this.button16.UseVisualStyleBackColor = true;
-        // 
-        // label9
-        // 
-        this.label9.AutoSize = true;
-        this.label9.Location = new System.Drawing.Point(27, 294);
-        this.label9.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label9.Name = "label9";
-        this.label9.Size = new System.Drawing.Size(199, 15);
-        this.label9.TabIndex = 10;
-        this.label9.Text = "TableLayoutPanel_SetBackColor_Red";
-        // 
-        // tableLayoutPanel1
-        // 
-        this.tableLayoutPanel1.BackColor = System.Drawing.Color.Red;
-        this.tableLayoutPanel1.ColumnCount = 5;
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 23F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 23F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 25F));
-        this.tableLayoutPanel1.Location = new System.Drawing.Point(27, 329);
-        this.tableLayoutPanel1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tableLayoutPanel1.Name = "tableLayoutPanel1";
-        this.tableLayoutPanel1.RowCount = 2;
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 23F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 23F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 23F));
-        this.tableLayoutPanel1.Size = new System.Drawing.Size(259, 103);
-        this.tableLayoutPanel1.TabIndex = 11;
-        // 
-        // radioButton6
-        // 
-        this.radioButton6.AutoSize = true;
-        this.radioButton6.Location = new System.Drawing.Point(223, 72);
-        this.radioButton6.Name = "radioButton6";
-        this.radioButton6.Size = new System.Drawing.Size(15, 17);
-        this.radioButton6.TabIndex = 9;
-        this.radioButton6.Text = "radioButton6";
-        this.radioButton6.UseVisualStyleBackColor = true;
-        // 
-        // radioButton5
-        // 
-        this.radioButton5.AutoSize = true;
-        this.radioButton5.Location = new System.Drawing.Point(203, 72);
-        this.radioButton5.Name = "radioButton5";
-        this.radioButton5.Size = new System.Drawing.Size(14, 17);
-        this.radioButton5.TabIndex = 8;
-        this.radioButton5.Text = "radioButton5";
-        this.radioButton5.UseVisualStyleBackColor = true;
-        // 
-        // radioButton4
-        // 
-        this.radioButton4.AutoSize = true;
-        this.radioButton4.Location = new System.Drawing.Point(183, 72);
-        this.radioButton4.Name = "radioButton4";
-        this.radioButton4.Size = new System.Drawing.Size(14, 17);
-        this.radioButton4.TabIndex = 7;
-        this.radioButton4.Text = "radioButton4";
-        this.radioButton4.UseVisualStyleBackColor = true;
-        // 
-        // checkBox2
-        // 
-        this.checkBox2.AutoSize = true;
-        this.checkBox2.Checked = true;
-        this.checkBox2.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.checkBox2.Location = new System.Drawing.Point(93, 72);
-        this.checkBox2.Name = "checkBox2";
-        this.checkBox2.Size = new System.Drawing.Size(80, 17);
-        this.checkBox2.TabIndex = 6;
-        this.checkBox2.Text = "checkBox2";
-        this.checkBox2.UseVisualStyleBackColor = true;
-        // 
-        // radioButton3
-        // 
-        this.radioButton3.AutoSize = true;
-        this.radioButton3.Checked = true;
-        this.radioButton3.Location = new System.Drawing.Point(223, 3);
-        this.radioButton3.Name = "radioButton3";
-        this.radioButton3.Size = new System.Drawing.Size(15, 17);
-        this.radioButton3.TabIndex = 4;
-        this.radioButton3.TabStop = true;
-        this.radioButton3.Text = "radioButton3";
-        this.radioButton3.UseVisualStyleBackColor = true;
-        // 
-        // radioButton2
-        // 
-        this.radioButton2.AutoSize = true;
-        this.radioButton2.Location = new System.Drawing.Point(203, 3);
-        this.radioButton2.Name = "radioButton2";
-        this.radioButton2.Size = new System.Drawing.Size(14, 17);
-        this.radioButton2.TabIndex = 3;
-        this.radioButton2.Text = "radioButton2";
-        this.radioButton2.UseVisualStyleBackColor = true;
-        // 
-        // button18
-        // 
-        this.button18.Location = new System.Drawing.Point(93, 3);
-        this.button18.Name = "button18";
-        this.button18.Size = new System.Drawing.Size(75, 23);
-        this.button18.TabIndex = 1;
-        this.button18.Text = "button18";
-        this.button18.UseVisualStyleBackColor = true;
-        // 
-        // button17
-        // 
-        this.button17.Location = new System.Drawing.Point(3, 3);
-        this.button17.Name = "button17";
-        this.button17.Size = new System.Drawing.Size(75, 23);
-        this.button17.TabIndex = 0;
-        this.button17.Text = "button17";
-        this.button17.UseVisualStyleBackColor = true;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.AutoSize = true;
-        this.radioButton1.Location = new System.Drawing.Point(183, 3);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(14, 17);
-        this.radioButton1.TabIndex = 2;
-        this.radioButton1.Text = "radioButton1";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(3, 72);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(80, 17);
-        this.checkBox1.TabIndex = 5;
-        this.checkBox1.Text = "checkBox1";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // label13
-        // 
-        this.label13.AutoSize = true;
-        this.label13.Location = new System.Drawing.Point(337, 21);
-        this.label13.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label13.Name = "label13";
-        this.label13.Size = new System.Drawing.Size(218, 15);
-        this.label13.TabIndex = 2;
-        this.label13.Text = "Empty_FlowLayout_SetBackColor_Green";
-        // 
-        // flowLayoutPanel4
-        // 
-        this.flowLayoutPanel4.BackColor = System.Drawing.Color.Green;
-        this.flowLayoutPanel4.Location = new System.Drawing.Point(337, 45);
-        this.flowLayoutPanel4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.flowLayoutPanel4.Name = "flowLayoutPanel4";
-        this.flowLayoutPanel4.Size = new System.Drawing.Size(153, 84);
-        this.flowLayoutPanel4.TabIndex = 3;
-        // 
-        // label14
-        // 
-        this.label14.AutoSize = true;
-        this.label14.Location = new System.Drawing.Point(337, 157);
-        this.label14.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label14.Name = "label14";
-        this.label14.Size = new System.Drawing.Size(210, 15);
-        this.label14.TabIndex = 6;
-        this.label14.Text = "Empty_GroupBox_SetBackColor_Green";
-        // 
-        // groupBox5
-        // 
-        this.groupBox5.BackColor = System.Drawing.Color.Green;
-        this.groupBox5.Location = new System.Drawing.Point(337, 182);
-        this.groupBox5.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox5.Name = "groupBox5";
-        this.groupBox5.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.groupBox5.Size = new System.Drawing.Size(153, 88);
-        this.groupBox5.TabIndex = 7;
-        this.groupBox5.TabStop = false;
-        this.groupBox5.Text = "groupBox5";
-        // 
-        // label15
-        // 
-        this.label15.AutoSize = true;
-        this.label15.Location = new System.Drawing.Point(337, 294);
-        this.label15.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label15.Name = "label15";
-        this.label15.Size = new System.Drawing.Size(186, 15);
-        this.label15.TabIndex = 12;
-        this.label15.Text = "Empty_Panel_SetBackColor_Green";
-        // 
-        // panel4
-        // 
-        this.panel4.BackColor = System.Drawing.Color.Green;
-        this.panel4.Location = new System.Drawing.Point(337, 329);
-        this.panel4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.panel4.Name = "panel4";
-        this.panel4.Size = new System.Drawing.Size(164, 103);
-        this.panel4.TabIndex = 13;
-        // 
-        // label16
-        // 
-        this.label16.AutoSize = true;
-        this.label16.Location = new System.Drawing.Point(582, 21);
-        this.label16.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label16.Name = "label16";
-        this.label16.Size = new System.Drawing.Size(337, 15);
-        this.label16.TabIndex = 4;
-        this.label16.Text = "Empty_SplitContainer_SetBackColor_Panel1_Green_Panel2_Red";
-        // 
-        // splitContainer2
-        // 
-        this.splitContainer2.Location = new System.Drawing.Point(586, 39);
-        this.splitContainer2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.splitContainer2.Name = "splitContainer2";
-        // 
-        // splitContainer2.Panel1
-        // 
-        this.splitContainer2.Panel1.BackColor = System.Drawing.Color.Green;
-        // 
-        // splitContainer2.Panel2
-        // 
-        this.splitContainer2.Panel2.BackColor = System.Drawing.Color.Red;
-        this.splitContainer2.Size = new System.Drawing.Size(262, 90);
-        this.splitContainer2.SplitterDistance = 83;
-        this.splitContainer2.SplitterWidth = 5;
-        this.splitContainer2.TabIndex = 5;
-        // 
-        // label17
-        // 
-        this.label17.AutoSize = true;
-        this.label17.Location = new System.Drawing.Point(582, 157);
-        this.label17.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label17.Name = "label17";
-        this.label17.Size = new System.Drawing.Size(350, 15);
-        this.label17.TabIndex = 8;
-        this.label17.Text = "Empty_TabControl_SetBackColor_TabPage7_Green_TabPage8_Red";
-        // 
-        // tabControl4
-        // 
-        this.tabControl4.Controls.Add(this.tabPage7);
-        this.tabControl4.Controls.Add(this.tabPage8);
-        this.tabControl4.Location = new System.Drawing.Point(582, 182);
-        this.tabControl4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl4.Name = "tabControl4";
-        this.tabControl4.SelectedIndex = 0;
-        this.tabControl4.Size = new System.Drawing.Size(262, 88);
-        this.tabControl4.TabIndex = 9;
-        // 
-        // tabPage7
-        // 
-        this.tabPage7.BackColor = System.Drawing.Color.Green;
-        this.tabPage7.Location = new System.Drawing.Point(4, 24);
-        this.tabPage7.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage7.Name = "tabPage7";
-        this.tabPage7.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage7.Size = new System.Drawing.Size(254, 60);
-        this.tabPage7.TabIndex = 0;
-        this.tabPage7.Text = "tabPage7";
-        // 
-        // tabPage8
-        // 
-        this.tabPage8.BackColor = System.Drawing.Color.Red;
-        this.tabPage8.Location = new System.Drawing.Point(4, 24);
-        this.tabPage8.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage8.Name = "tabPage8";
-        this.tabPage8.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage8.Size = new System.Drawing.Size(254, 60);
-        this.tabPage8.TabIndex = 1;
-        this.tabPage8.Text = "tabPage8";
-        // 
-        // label18
-        // 
-        this.label18.AutoSize = true;
-        this.label18.Location = new System.Drawing.Point(582, 294);
-        this.label18.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label18.Name = "label18";
-        this.label18.Size = new System.Drawing.Size(211, 15);
-        this.label18.TabIndex = 14;
-        this.label18.Text = "Empty_TabLayout_SetBackColor_Green";
-        // 
-        // tableLayoutPanel2
-        // 
-        this.tableLayoutPanel2.BackColor = System.Drawing.Color.Green;
-        this.tableLayoutPanel2.ColumnCount = 2;
-        this.tableLayoutPanel2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.Location = new System.Drawing.Point(582, 329);
-        this.tableLayoutPanel2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tableLayoutPanel2.Name = "tableLayoutPanel2";
-        this.tableLayoutPanel2.RowCount = 2;
-        this.tableLayoutPanel2.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.Size = new System.Drawing.Size(258, 103);
-        this.tableLayoutPanel2.TabIndex = 15;
-        // 
-        // ContainerControls2
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.AutoScroll = true;
-        this.ClientSize = new System.Drawing.Size(945, 464);
-        this.Controls.Add(this.tableLayoutPanel2);
-        this.Controls.Add(this.label18);
-        this.Controls.Add(this.tabControl4);
-        this.Controls.Add(this.label17);
-        this.Controls.Add(this.splitContainer2);
-        this.Controls.Add(this.label16);
-        this.Controls.Add(this.panel4);
-        this.Controls.Add(this.label15);
-        this.Controls.Add(this.groupBox5);
-        this.Controls.Add(this.label14);
-        this.Controls.Add(this.flowLayoutPanel4);
-        this.Controls.Add(this.label13);
-        this.Controls.Add(this.tableLayoutPanel1);
-        this.Controls.Add(this.label9);
-        this.Controls.Add(this.splitContainer1);
-        this.Controls.Add(this.label8);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "ContainerControls2";
-        this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
-        this.Text = "Winforms_Containers";
-        this.Load += new System.EventHandler(this.ContainerControls2_Load);
-        this.splitContainer1.Panel1.ResumeLayout(false);
-        this.splitContainer1.Panel2.ResumeLayout(false);
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
-        this.splitContainer1.ResumeLayout(false);
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer2)).EndInit();
-        this.splitContainer2.ResumeLayout(false);
-        this.tabControl4.ResumeLayout(false);
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-    private System.Windows.Forms.Label label8;
-    private System.Windows.Forms.SplitContainer splitContainer1;
-    private System.Windows.Forms.Button button15;
-    private System.Windows.Forms.Button button16;
-    private System.Windows.Forms.Label label9;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
-    private System.Windows.Forms.RadioButton radioButton6;
-    private System.Windows.Forms.RadioButton radioButton5;
-    private System.Windows.Forms.RadioButton radioButton4;
-    private System.Windows.Forms.CheckBox checkBox2;
-    private System.Windows.Forms.RadioButton radioButton3;
-    private System.Windows.Forms.RadioButton radioButton2;
-    private System.Windows.Forms.Button button18;
-    private System.Windows.Forms.Button button17;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.Label label13;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel4;
-    private System.Windows.Forms.Label label14;
-    private System.Windows.Forms.GroupBox groupBox5;
-    private System.Windows.Forms.Label label15;
-    private System.Windows.Forms.Panel panel4;
-    private System.Windows.Forms.Label label16;
-    private System.Windows.Forms.SplitContainer splitContainer2;
-    private System.Windows.Forms.Label label17;
-    private System.Windows.Forms.TabControl tabControl4;
-    private System.Windows.Forms.TabPage tabPage7;
-    private System.Windows.Forms.TabPage tabPage8;
-    private System.Windows.Forms.Label label18;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel2;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.cs
deleted file mode 100644
index 500d5f99976..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class ContainerControls2 : Form
-{
-    public ContainerControls2()
-    {
-        InitializeComponent();
-    }
-
-    private void ContainerControls2_Load(object sender, EventArgs e)
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.resx b/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ContainerControls2.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.Designer.cs
deleted file mode 100644
index d20f05440b4..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.Designer.cs
+++ /dev/null
@@ -1,1234 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class CustomAccessiblePropertiesForm
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(CustomAccessiblePropertiesForm));
-        this.button1 = new System.Windows.Forms.Button();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.checkedListBox1 = new System.Windows.Forms.CheckedListBox();
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
-        this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripComboBox1 = new System.Windows.Forms.ToolStripComboBox();
-        this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-        this.toolStripTextBox1 = new System.Windows.Forms.ToolStripTextBox();
-        this.dateTimePicker1 = new System.Windows.Forms.DateTimePicker();
-        this.linkLabel1 = new System.Windows.Forms.LinkLabel();
-        this.label1 = new System.Windows.Forms.Label();
-        this.hScrollBar1 = new System.Windows.Forms.HScrollBar();
-        this.groupBox1 = new System.Windows.Forms.GroupBox();
-        this.flowLayoutPanel1 = new System.Windows.Forms.FlowLayoutPanel();
-        this.domainUpDown1 = new System.Windows.Forms.DomainUpDown();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.monthCalendar1 = new System.Windows.Forms.MonthCalendar();
-        this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox();
-        this.listView1 = new System.Windows.Forms.ListView();
-        this.listBox1 = new System.Windows.Forms.ListBox();
-        this.pictureBox1 = new System.Windows.Forms.PictureBox();
-        this.panel1 = new System.Windows.Forms.Panel();
-        this.menuStrip1 = new System.Windows.Forms.MenuStrip();
-        this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.newToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator = new System.Windows.Forms.ToolStripSeparator();
-        this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator();
-        this.printToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.printPreviewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator();
-        this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.undoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.redoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator();
-        this.cutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.copyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.pasteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator5 = new System.Windows.Forms.ToolStripSeparator();
-        this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.customizeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.optionsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.contentsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.indexToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.searchToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator6 = new System.Windows.Forms.ToolStripSeparator();
-        this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripComboBox2 = new System.Windows.Forms.ToolStripComboBox();
-        this.toolStripTextBox2 = new System.Windows.Forms.ToolStripTextBox();
-        this.vScrollBar1 = new System.Windows.Forms.VScrollBar();
-        this.treeView1 = new System.Windows.Forms.TreeView();
-        this.trackBar1 = new System.Windows.Forms.TrackBar();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
-        this.tabControl1 = new System.Windows.Forms.TabControl();
-        this.tabPage1 = new System.Windows.Forms.TabPage();
-        this.tabPage2 = new System.Windows.Forms.TabPage();
-        this.toolStrip1 = new System.Windows.Forms.ToolStrip();
-        this.toolStripButton1 = new System.Windows.Forms.ToolStripButton();
-        this.toolStripLabel1 = new System.Windows.Forms.ToolStripLabel();
-        this.toolStripSplitButton2 = new System.Windows.Forms.ToolStripSplitButton();
-        this.toolStripDropDownButton2 = new System.Windows.Forms.ToolStripDropDownButton();
-        this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator();
-        this.toolStripComboBox3 = new System.Windows.Forms.ToolStripComboBox();
-        this.toolStripTextBox3 = new System.Windows.Forms.ToolStripTextBox();
-        this.toolStripProgressBar2 = new System.Windows.Forms.ToolStripProgressBar();
-        this.webBrowser1 = new System.Windows.Forms.WebBrowser();
-        this.splitContainer1 = new System.Windows.Forms.SplitContainer();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.progressBar1 = new System.Windows.Forms.ProgressBar();
-        this.printPreviewControl1 = new System.Windows.Forms.PrintPreviewControl();
-        this.splitter1 = new System.Windows.Forms.Splitter();
-        this.statusStrip1 = new System.Windows.Forms.StatusStrip();
-        this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel();
-        this.toolStripProgressBar1 = new System.Windows.Forms.ToolStripProgressBar();
-        this.toolStripDropDownButton1 = new System.Windows.Forms.ToolStripDropDownButton();
-        this.toolStripSplitButton1 = new System.Windows.Forms.ToolStripSplitButton();
-        this.dataGridView1 = new System.Windows.Forms.DataGridView();
-        this.Column1 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column2 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column3 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column4 = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.toolStripContainer1 = new System.Windows.Forms.ToolStripContainer();
-        this.richTextBox1 = new System.Windows.Forms.RichTextBox();
-        this.contextMenuStrip1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
-        this.menuStrip1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).BeginInit();
-        this.tabControl1.SuspendLayout();
-        this.toolStrip1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
-        this.splitContainer1.SuspendLayout();
-        this.statusStrip1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.AccessibleDescription = "This is Button1";
-        this.button1.AccessibleName = "TestButton";
-        this.button1.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuBar;
-        this.button1.Location = new System.Drawing.Point(6, 61);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(120, 33);
-        this.button1.TabIndex = 1;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AccessibleDescription = "This is CheckBox1";
-        this.checkBox1.AccessibleName = "TestCheckBox";
-        this.checkBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.ScrollBar;
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(9, 105);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(83, 19);
-        this.checkBox1.TabIndex = 2;
-        this.checkBox1.Text = "checkBox1";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // checkedListBox1
-        // 
-        this.checkedListBox1.AccessibleDescription = "This is CheckedListBox1";
-        this.checkedListBox1.AccessibleName = "TestCheckedListBox";
-        this.checkedListBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Grip;
-        this.checkedListBox1.FormattingEnabled = true;
-        this.checkedListBox1.Location = new System.Drawing.Point(6, 131);
-        this.checkedListBox1.Name = "checkedListBox1";
-        this.checkedListBox1.Size = new System.Drawing.Size(120, 94);
-        this.checkedListBox1.TabIndex = 3;
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.AccessibleDescription = "This is ComboBox1";
-        this.comboBox1.AccessibleName = "TestComboBox";
-        this.comboBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Window;
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Location = new System.Drawing.Point(6, 232);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(121, 23);
-        this.comboBox1.TabIndex = 4;
-        // 
-        // contextMenuStrip1
-        // 
-        this.contextMenuStrip1.AccessibleDescription = "This is ContextMenuStrip";
-        this.contextMenuStrip1.AccessibleName = "TestContextMenuStrip";
-        this.contextMenuStrip1.AccessibleRole = System.Windows.Forms.AccessibleRole.Cursor;
-        this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripMenuItem1,
-        this.toolStripComboBox1,
-        this.toolStripSeparator1,
-        this.toolStripTextBox1});
-        this.contextMenuStrip1.Name = "contextMenuStrip1";
-        this.contextMenuStrip1.Size = new System.Drawing.Size(182, 84);
-        // 
-        // toolStripMenuItem1
-        // 
-        this.toolStripMenuItem1.AccessibleDescription = "This is toolStripMenuItem";
-        this.toolStripMenuItem1.AccessibleName = "TestToolStripMenuItem";
-        this.toolStripMenuItem1.AccessibleRole = System.Windows.Forms.AccessibleRole.Sound;
-        this.toolStripMenuItem1.Name = "toolStripMenuItem1";
-        this.toolStripMenuItem1.Size = new System.Drawing.Size(181, 22);
-        this.toolStripMenuItem1.Text = "toolStripMenuItem1";
-        // 
-        // toolStripComboBox1
-        // 
-        this.toolStripComboBox1.AccessibleDescription = "This is toolStripComboBox";
-        this.toolStripComboBox1.AccessibleName = "TestToolStripComboBox";
-        this.toolStripComboBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Alert;
-        this.toolStripComboBox1.Name = "toolStripComboBox1";
-        this.toolStripComboBox1.Size = new System.Drawing.Size(121, 23);
-        // 
-        // toolStripSeparator1
-        // 
-        this.toolStripSeparator1.AccessibleDescription = "This is toolStripSeparator";
-        this.toolStripSeparator1.AccessibleName = "TestToolStripSeparator";
-        this.toolStripSeparator1.AccessibleRole = System.Windows.Forms.AccessibleRole.Client;
-        this.toolStripSeparator1.Name = "toolStripSeparator1";
-        this.toolStripSeparator1.Size = new System.Drawing.Size(178, 6);
-        // 
-        // toolStripTextBox1
-        // 
-        this.toolStripTextBox1.AccessibleDescription = "This is toolStripTextBox";
-        this.toolStripTextBox1.AccessibleName = "TestToolStripTextBox";
-        this.toolStripTextBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuPopup;
-        this.toolStripTextBox1.Name = "toolStripTextBox1";
-        this.toolStripTextBox1.Size = new System.Drawing.Size(100, 23);
-        // 
-        // dateTimePicker1
-        // 
-        this.dateTimePicker1.AccessibleDescription = "This is DateTimePicker1";
-        this.dateTimePicker1.AccessibleName = "TestDateTimePicker";
-        this.dateTimePicker1.AccessibleRole = System.Windows.Forms.AccessibleRole.Caret;
-        this.dateTimePicker1.Location = new System.Drawing.Point(6, 266);
-        this.dateTimePicker1.Name = "dateTimePicker1";
-        this.dateTimePicker1.Size = new System.Drawing.Size(200, 23);
-        this.dateTimePicker1.TabIndex = 7;
-        // 
-        // linkLabel1
-        // 
-        this.linkLabel1.AccessibleDescription = "This is LinkLabel";
-        this.linkLabel1.AccessibleName = "TestLinkLabel";
-        this.linkLabel1.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuPopup;
-        this.linkLabel1.AutoSize = true;
-        this.linkLabel1.Location = new System.Drawing.Point(209, 299);
-        this.linkLabel1.Name = "linkLabel1";
-        this.linkLabel1.Size = new System.Drawing.Size(60, 15);
-        this.linkLabel1.TabIndex = 13;
-        this.linkLabel1.TabStop = true;
-        this.linkLabel1.Text = "linkLabel1";
-        // 
-        // label1
-        // 
-        this.label1.AccessibleDescription = "This is Label";
-        this.label1.AccessibleName = "TestLabel";
-        this.label1.AccessibleRole = System.Windows.Forms.AccessibleRole.PageTab;
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(143, 299);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(38, 15);
-        this.label1.TabIndex = 12;
-        this.label1.Text = "label1";
-        // 
-        // hScrollBar1
-        // 
-        this.hScrollBar1.AccessibleDescription = "This is HScrollBar";
-        this.hScrollBar1.AccessibleName = "TestHScrollBar";
-        this.hScrollBar1.AccessibleRole = System.Windows.Forms.AccessibleRole.Sound;
-        this.hScrollBar1.Location = new System.Drawing.Point(9, 547);
-        this.hScrollBar1.Name = "hScrollBar1";
-        this.hScrollBar1.Size = new System.Drawing.Size(198, 17);
-        this.hScrollBar1.TabIndex = 11;
-        // 
-        // groupBox1
-        // 
-        this.groupBox1.AccessibleDescription = "This is GroupBox";
-        this.groupBox1.AccessibleName = "TestGroupBox";
-        this.groupBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Border;
-        this.groupBox1.Location = new System.Drawing.Point(7, 435);
-        this.groupBox1.Name = "groupBox1";
-        this.groupBox1.Size = new System.Drawing.Size(200, 100);
-        this.groupBox1.TabIndex = 10;
-        this.groupBox1.TabStop = false;
-        this.groupBox1.Text = "groupBox1";
-        // 
-        // flowLayoutPanel1
-        // 
-        this.flowLayoutPanel1.AccessibleDescription = "This is FlowLayoutPanel";
-        this.flowLayoutPanel1.AccessibleName = "TestFlowLayoutPanel";
-        this.flowLayoutPanel1.AccessibleRole = System.Windows.Forms.AccessibleRole.Document;
-        this.flowLayoutPanel1.BackColor = System.Drawing.SystemColors.ActiveCaption;
-        this.flowLayoutPanel1.Location = new System.Drawing.Point(7, 329);
-        this.flowLayoutPanel1.Name = "flowLayoutPanel1";
-        this.flowLayoutPanel1.Size = new System.Drawing.Size(200, 100);
-        this.flowLayoutPanel1.TabIndex = 9;
-        // 
-        // domainUpDown1
-        // 
-        this.domainUpDown1.AccessibleDescription = "This is DomainUpDown";
-        this.domainUpDown1.AccessibleName = "TestDomainUpDown";
-        this.domainUpDown1.AccessibleRole = System.Windows.Forms.AccessibleRole.Indicator;
-        this.domainUpDown1.Location = new System.Drawing.Point(7, 299);
-        this.domainUpDown1.Name = "domainUpDown1";
-        this.domainUpDown1.Size = new System.Drawing.Size(120, 23);
-        this.domainUpDown1.TabIndex = 8;
-        this.domainUpDown1.Text = "domainUpDown1";
-        // 
-        // numericUpDown1
-        // 
-        this.numericUpDown1.AccessibleDescription = "This is a test numericUpDown.";
-        this.numericUpDown1.AccessibleName = "numericUpDownTestControl";
-        this.numericUpDown1.AccessibleRole = System.Windows.Forms.AccessibleRole.Sound;
-        this.numericUpDown1.Location = new System.Drawing.Point(214, 570);
-        this.numericUpDown1.Name = "numericUpDown1";
-        this.numericUpDown1.Size = new System.Drawing.Size(120, 23);
-        this.numericUpDown1.TabIndex = 18;
-        // 
-        // monthCalendar1
-        // 
-        this.monthCalendar1.AccessibleDescription = "This is a test MonthCalendar.";
-        this.monthCalendar1.AccessibleName = "monthCalendarTestControl";
-        this.monthCalendar1.AccessibleRole = System.Windows.Forms.AccessibleRole.Window;
-        this.monthCalendar1.Location = new System.Drawing.Point(345, 252);
-        this.monthCalendar1.Name = "monthCalendar1";
-        this.monthCalendar1.TabIndex = 17;
-        // 
-        // maskedTextBox1
-        // 
-        this.maskedTextBox1.AccessibleDescription = "This is a maskedTextBox control to test Accessibility.";
-        this.maskedTextBox1.AccessibleName = "maskedTextBoxTestControl";
-        this.maskedTextBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Grip;
-        this.maskedTextBox1.Location = new System.Drawing.Point(214, 541);
-        this.maskedTextBox1.Name = "maskedTextBox1";
-        this.maskedTextBox1.Size = new System.Drawing.Size(121, 23);
-        this.maskedTextBox1.TabIndex = 16;
-        // 
-        // listView1
-        // 
-        this.listView1.AccessibleDescription = "This is a listView control to test Accessibility.";
-        this.listView1.AccessibleName = "listViewTestControl";
-        this.listView1.AccessibleRole = System.Windows.Forms.AccessibleRole.Window;
-        this.listView1.HideSelection = false;
-        this.listView1.Location = new System.Drawing.Point(214, 438);
-        this.listView1.Name = "listView1";
-        this.listView1.Size = new System.Drawing.Size(121, 97);
-        this.listView1.TabIndex = 15;
-        this.listView1.UseCompatibleStateImageBehavior = false;
-        // 
-        // listBox1
-        // 
-        this.listBox1.AccessibleDescription = "This is a listBox control to test Accessibility.";
-        this.listBox1.AccessibleName = "listBoxTestControl";
-        this.listBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.TitleBar;
-        this.listBox1.FormattingEnabled = true;
-        this.listBox1.ItemHeight = 15;
-        this.listBox1.Location = new System.Drawing.Point(214, 329);
-        this.listBox1.Name = "listBox1";
-        this.listBox1.Size = new System.Drawing.Size(120, 94);
-        this.listBox1.TabIndex = 14;
-        // 
-        // pictureBox1
-        // 
-        this.pictureBox1.AccessibleDescription = "This is a test PictureBox.";
-        this.pictureBox1.AccessibleName = "pictureBoxTestControl";
-        this.pictureBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Chart;
-        this.pictureBox1.BackColor = System.Drawing.SystemColors.ActiveBorder;
-        this.pictureBox1.Location = new System.Drawing.Point(350, 438);
-        this.pictureBox1.Name = "pictureBox1";
-        this.pictureBox1.Size = new System.Drawing.Size(211, 155);
-        this.pictureBox1.TabIndex = 20;
-        this.pictureBox1.TabStop = false;
-        // 
-        // panel1
-        // 
-        this.panel1.AccessibleDescription = "This is a test Panel.";
-        this.panel1.AccessibleName = "panelTestControl";
-        this.panel1.AccessibleRole = System.Windows.Forms.AccessibleRole.Application;
-        this.panel1.BackColor = System.Drawing.SystemColors.ActiveCaption;
-        this.panel1.Location = new System.Drawing.Point(464, 62);
-        this.panel1.Name = "panel1";
-        this.panel1.Size = new System.Drawing.Size(183, 174);
-        this.panel1.TabIndex = 19;
-        // 
-        // menuStrip1
-        // 
-        this.menuStrip1.AccessibleDescription = "MenuStrip to test Accessibility.";
-        this.menuStrip1.AccessibleName = "menuStripTestControl";
-        this.menuStrip1.AccessibleRole = System.Windows.Forms.AccessibleRole.Caret;
-        this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.fileToolStripMenuItem,
-        this.editToolStripMenuItem,
-        this.toolsToolStripMenuItem,
-        this.helpToolStripMenuItem,
-        this.toolStripComboBox2,
-        this.toolStripTextBox2});
-        this.menuStrip1.Location = new System.Drawing.Point(0, 0);
-        this.menuStrip1.Name = "menuStrip1";
-        this.menuStrip1.Size = new System.Drawing.Size(914, 27);
-        this.menuStrip1.TabIndex = 21;
-        this.menuStrip1.Text = "menuStrip1";
-        // 
-        // fileToolStripMenuItem
-        // 
-        this.fileToolStripMenuItem.AccessibleDescription = "This is a test item in MenuStrip.";
-        this.fileToolStripMenuItem.AccessibleName = "fileTestItem";
-        this.fileToolStripMenuItem.AccessibleRole = System.Windows.Forms.AccessibleRole.Border;
-        this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.newToolStripMenuItem,
-        this.openToolStripMenuItem,
-        this.toolStripSeparator,
-        this.saveToolStripMenuItem,
-        this.saveAsToolStripMenuItem,
-        this.toolStripSeparator2,
-        this.printToolStripMenuItem,
-        this.printPreviewToolStripMenuItem,
-        this.toolStripSeparator3,
-        this.exitToolStripMenuItem});
-        this.fileToolStripMenuItem.Name = "fileToolStripMenuItem";
-        this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 23);
-        this.fileToolStripMenuItem.Text = "&File";
-        // 
-        // newToolStripMenuItem
-        // 
-        this.newToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.newToolStripMenuItem.Name = "newToolStripMenuItem";
-        this.newToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.N)));
-        this.newToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.newToolStripMenuItem.Text = "&New";
-        // 
-        // openToolStripMenuItem
-        // 
-        this.openToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.openToolStripMenuItem.Name = "openToolStripMenuItem";
-        this.openToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.O)));
-        this.openToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.openToolStripMenuItem.Text = "&Open";
-        // 
-        // toolStripSeparator
-        // 
-        this.toolStripSeparator.Name = "toolStripSeparator";
-        this.toolStripSeparator.Size = new System.Drawing.Size(143, 6);
-        // 
-        // saveToolStripMenuItem
-        // 
-        this.saveToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.saveToolStripMenuItem.Name = "saveToolStripMenuItem";
-        this.saveToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.S)));
-        this.saveToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.saveToolStripMenuItem.Text = "&Save";
-        // 
-        // saveAsToolStripMenuItem
-        // 
-        this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem";
-        this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.saveAsToolStripMenuItem.Text = "Save &As";
-        // 
-        // toolStripSeparator2
-        // 
-        this.toolStripSeparator2.Name = "toolStripSeparator2";
-        this.toolStripSeparator2.Size = new System.Drawing.Size(143, 6);
-        // 
-        // printToolStripMenuItem
-        // 
-        this.printToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.printToolStripMenuItem.Name = "printToolStripMenuItem";
-        this.printToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.P)));
-        this.printToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.printToolStripMenuItem.Text = "&Print";
-        // 
-        // printPreviewToolStripMenuItem
-        // 
-        this.printPreviewToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.printPreviewToolStripMenuItem.Name = "printPreviewToolStripMenuItem";
-        this.printPreviewToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.printPreviewToolStripMenuItem.Text = "Print Pre&view";
-        // 
-        // toolStripSeparator3
-        // 
-        this.toolStripSeparator3.Name = "toolStripSeparator3";
-        this.toolStripSeparator3.Size = new System.Drawing.Size(143, 6);
-        // 
-        // exitToolStripMenuItem
-        // 
-        this.exitToolStripMenuItem.Name = "exitToolStripMenuItem";
-        this.exitToolStripMenuItem.Size = new System.Drawing.Size(146, 22);
-        this.exitToolStripMenuItem.Text = "E&xit";
-        // 
-        // editToolStripMenuItem
-        // 
-        this.editToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.undoToolStripMenuItem,
-        this.redoToolStripMenuItem,
-        this.toolStripSeparator4,
-        this.cutToolStripMenuItem,
-        this.copyToolStripMenuItem,
-        this.pasteToolStripMenuItem,
-        this.toolStripSeparator5,
-        this.selectAllToolStripMenuItem});
-        this.editToolStripMenuItem.Name = "editToolStripMenuItem";
-        this.editToolStripMenuItem.Size = new System.Drawing.Size(39, 23);
-        this.editToolStripMenuItem.Text = "&Edit";
-        // 
-        // undoToolStripMenuItem
-        // 
-        this.undoToolStripMenuItem.Name = "undoToolStripMenuItem";
-        this.undoToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Z)));
-        this.undoToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.undoToolStripMenuItem.Text = "&Undo";
-        // 
-        // redoToolStripMenuItem
-        // 
-        this.redoToolStripMenuItem.Name = "redoToolStripMenuItem";
-        this.redoToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Y)));
-        this.redoToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.redoToolStripMenuItem.Text = "&Redo";
-        // 
-        // toolStripSeparator4
-        // 
-        this.toolStripSeparator4.Name = "toolStripSeparator4";
-        this.toolStripSeparator4.Size = new System.Drawing.Size(141, 6);
-        // 
-        // cutToolStripMenuItem
-        // 
-        this.cutToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.cutToolStripMenuItem.Name = "cutToolStripMenuItem";
-        this.cutToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.X)));
-        this.cutToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.cutToolStripMenuItem.Text = "Cu&t";
-        // 
-        // copyToolStripMenuItem
-        // 
-        this.copyToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.copyToolStripMenuItem.Name = "copyToolStripMenuItem";
-        this.copyToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.C)));
-        this.copyToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.copyToolStripMenuItem.Text = "&Copy";
-        // 
-        // pasteToolStripMenuItem
-        // 
-        this.pasteToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.pasteToolStripMenuItem.Name = "pasteToolStripMenuItem";
-        this.pasteToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.V)));
-        this.pasteToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.pasteToolStripMenuItem.Text = "&Paste";
-        // 
-        // toolStripSeparator5
-        // 
-        this.toolStripSeparator5.Name = "toolStripSeparator5";
-        this.toolStripSeparator5.Size = new System.Drawing.Size(141, 6);
-        // 
-        // selectAllToolStripMenuItem
-        // 
-        this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem";
-        this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(144, 22);
-        this.selectAllToolStripMenuItem.Text = "Select &All";
-        // 
-        // toolsToolStripMenuItem
-        // 
-        this.toolsToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.customizeToolStripMenuItem,
-        this.optionsToolStripMenuItem});
-        this.toolsToolStripMenuItem.Name = "toolsToolStripMenuItem";
-        this.toolsToolStripMenuItem.Size = new System.Drawing.Size(46, 23);
-        this.toolsToolStripMenuItem.Text = "&Tools";
-        // 
-        // customizeToolStripMenuItem
-        // 
-        this.customizeToolStripMenuItem.Name = "customizeToolStripMenuItem";
-        this.customizeToolStripMenuItem.Size = new System.Drawing.Size(130, 22);
-        this.customizeToolStripMenuItem.Text = "&Customize";
-        // 
-        // optionsToolStripMenuItem
-        // 
-        this.optionsToolStripMenuItem.Name = "optionsToolStripMenuItem";
-        this.optionsToolStripMenuItem.Size = new System.Drawing.Size(130, 22);
-        this.optionsToolStripMenuItem.Text = "&Options";
-        // 
-        // helpToolStripMenuItem
-        // 
-        this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.contentsToolStripMenuItem,
-        this.indexToolStripMenuItem,
-        this.searchToolStripMenuItem,
-        this.toolStripSeparator6,
-        this.aboutToolStripMenuItem});
-        this.helpToolStripMenuItem.Name = "helpToolStripMenuItem";
-        this.helpToolStripMenuItem.Size = new System.Drawing.Size(44, 23);
-        this.helpToolStripMenuItem.Text = "&Help";
-        // 
-        // contentsToolStripMenuItem
-        // 
-        this.contentsToolStripMenuItem.Name = "contentsToolStripMenuItem";
-        this.contentsToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.contentsToolStripMenuItem.Text = "&Contents";
-        // 
-        // indexToolStripMenuItem
-        // 
-        this.indexToolStripMenuItem.Name = "indexToolStripMenuItem";
-        this.indexToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.indexToolStripMenuItem.Text = "&Index";
-        // 
-        // searchToolStripMenuItem
-        // 
-        this.searchToolStripMenuItem.Name = "searchToolStripMenuItem";
-        this.searchToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.searchToolStripMenuItem.Text = "&Search";
-        // 
-        // toolStripSeparator6
-        // 
-        this.toolStripSeparator6.Name = "toolStripSeparator6";
-        this.toolStripSeparator6.Size = new System.Drawing.Size(119, 6);
-        // 
-        // aboutToolStripMenuItem
-        // 
-        this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem";
-        this.aboutToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.aboutToolStripMenuItem.Text = "&About...";
-        // 
-        // toolStripComboBox2
-        // 
-        this.toolStripComboBox2.AccessibleDescription = "This is a combobox item in MenuStrip.";
-        this.toolStripComboBox2.AccessibleName = "comboBoxTestItem";
-        this.toolStripComboBox2.AccessibleRole = System.Windows.Forms.AccessibleRole.Pane;
-        this.toolStripComboBox2.Items.AddRange(new object[] {
-        "A",
-        "B",
-        "C",
-        "D"});
-        this.toolStripComboBox2.Name = "toolStripComboBox2";
-        this.toolStripComboBox2.Size = new System.Drawing.Size(121, 23);
-        this.toolStripComboBox2.Text = "A";
-        // 
-        // toolStripTextBox2
-        // 
-        this.toolStripTextBox2.AccessibleDescription = "This is a textBox item in MenuStrip.";
-        this.toolStripTextBox2.AccessibleName = "textBoxItem";
-        this.toolStripTextBox2.AccessibleRole = System.Windows.Forms.AccessibleRole.Row;
-        this.toolStripTextBox2.Name = "toolStripTextBox2";
-        this.toolStripTextBox2.Size = new System.Drawing.Size(100, 23);
-        this.toolStripTextBox2.Text = "TextBox";
-        // 
-        // vScrollBar1
-        // 
-        this.vScrollBar1.AccessibleDescription = "This is a VScrollBar";
-        this.vScrollBar1.AccessibleName = "TestVScrollBar";
-        this.vScrollBar1.AccessibleRole = System.Windows.Forms.AccessibleRole.Equation;
-        this.vScrollBar1.Location = new System.Drawing.Point(585, 252);
-        this.vScrollBar1.Name = "vScrollBar1";
-        this.vScrollBar1.Size = new System.Drawing.Size(17, 220);
-        this.vScrollBar1.TabIndex = 27;
-        // 
-        // treeView1
-        // 
-        this.treeView1.AccessibleDescription = "This is a TreeView";
-        this.treeView1.AccessibleName = "TestTreeView";
-        this.treeView1.AccessibleRole = System.Windows.Forms.AccessibleRole.ButtonDropDown;
-        this.treeView1.Location = new System.Drawing.Point(613, 363);
-        this.treeView1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.treeView1.Name = "treeView1";
-        this.treeView1.Size = new System.Drawing.Size(233, 112);
-        this.treeView1.TabIndex = 26;
-        // 
-        // trackBar1
-        // 
-        this.trackBar1.AccessibleDescription = "This is a TrackBar";
-        this.trackBar1.AccessibleName = "TestTrackBar";
-        this.trackBar1.AccessibleRole = System.Windows.Forms.AccessibleRole.ButtonMenu;
-        this.trackBar1.Location = new System.Drawing.Point(613, 510);
-        this.trackBar1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.trackBar1.Name = "trackBar1";
-        this.trackBar1.Size = new System.Drawing.Size(194, 45);
-        this.trackBar1.TabIndex = 25;
-        // 
-        // textBox1
-        // 
-        this.textBox1.AccessibleDescription = "This is a TextBox";
-        this.textBox1.AccessibleName = "TestTextBox";
-        this.textBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.SplitButton;
-        this.textBox1.Location = new System.Drawing.Point(613, 481);
-        this.textBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(233, 23);
-        this.textBox1.TabIndex = 24;
-        // 
-        // tableLayoutPanel1
-        // 
-        this.tableLayoutPanel1.AccessibleDescription = "This is a TableLayoutPanel";
-        this.tableLayoutPanel1.AccessibleName = "TestTableLayoutPanel";
-        this.tableLayoutPanel1.AccessibleRole = System.Windows.Forms.AccessibleRole.IpAddress;
-        this.tableLayoutPanel1.BackColor = System.Drawing.SystemColors.ControlDark;
-        this.tableLayoutPanel1.ColumnCount = 2;
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.Location = new System.Drawing.Point(613, 242);
-        this.tableLayoutPanel1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tableLayoutPanel1.Name = "tableLayoutPanel1";
-        this.tableLayoutPanel1.RowCount = 2;
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel1.Size = new System.Drawing.Size(233, 115);
-        this.tableLayoutPanel1.TabIndex = 23;
-        // 
-        // tabControl1
-        // 
-        this.tabControl1.AccessibleDescription = "This is a TabControl";
-        this.tabControl1.AccessibleName = "TestTabControl";
-        this.tabControl1.AccessibleRole = System.Windows.Forms.AccessibleRole.OutlineButton;
-        this.tabControl1.Controls.Add(this.tabPage1);
-        this.tabControl1.Controls.Add(this.tabPage2);
-        this.tabControl1.Location = new System.Drawing.Point(657, 62);
-        this.tabControl1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabControl1.Name = "tabControl1";
-        this.tabControl1.SelectedIndex = 0;
-        this.tabControl1.Size = new System.Drawing.Size(222, 174);
-        this.tabControl1.TabIndex = 22;
-        // 
-        // tabPage1
-        // 
-        this.tabPage1.Location = new System.Drawing.Point(4, 24);
-        this.tabPage1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage1.Name = "tabPage1";
-        this.tabPage1.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage1.Size = new System.Drawing.Size(214, 146);
-        this.tabPage1.TabIndex = 0;
-        this.tabPage1.Text = "tabPage1";
-        this.tabPage1.UseVisualStyleBackColor = true;
-        // 
-        // tabPage2
-        // 
-        this.tabPage2.Location = new System.Drawing.Point(4, 24);
-        this.tabPage2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage2.Name = "tabPage2";
-        this.tabPage2.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.tabPage2.Size = new System.Drawing.Size(214, 146);
-        this.tabPage2.TabIndex = 1;
-        this.tabPage2.Text = "tabPage2";
-        this.tabPage2.UseVisualStyleBackColor = true;
-        // 
-        // toolStrip1
-        // 
-        this.toolStrip1.AccessibleDescription = "This is a ToolStrip";
-        this.toolStrip1.AccessibleName = "TestToolStrip";
-        this.toolStrip1.AccessibleRole = System.Windows.Forms.AccessibleRole.Clock;
-        this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripButton1,
-        this.toolStripLabel1,
-        this.toolStripSplitButton2,
-        this.toolStripDropDownButton2,
-        this.toolStripSeparator7,
-        this.toolStripComboBox3,
-        this.toolStripTextBox3,
-        this.toolStripProgressBar2});
-        this.toolStrip1.Location = new System.Drawing.Point(0, 27);
-        this.toolStrip1.Name = "toolStrip1";
-        this.toolStrip1.Size = new System.Drawing.Size(914, 25);
-        this.toolStrip1.TabIndex = 28;
-        this.toolStrip1.Text = "toolStrip1";
-        // 
-        // toolStripButton1
-        // 
-        this.toolStripButton1.AccessibleDescription = "This is toolStripButton";
-        this.toolStripButton1.AccessibleName = "TestToolStripButton";
-        this.toolStripButton1.AccessibleRole = System.Windows.Forms.AccessibleRole.TitleBar;
-        this.toolStripButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton1.Image")));
-        this.toolStripButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripButton1.Name = "toolStripButton1";
-        this.toolStripButton1.Size = new System.Drawing.Size(23, 22);
-        this.toolStripButton1.Text = "toolStripButton1";
-        // 
-        // toolStripLabel1
-        // 
-        this.toolStripLabel1.AccessibleDescription = "This is toolStripLabel";
-        this.toolStripLabel1.AccessibleName = "TestToolStripLabel";
-        this.toolStripLabel1.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuBar;
-        this.toolStripLabel1.Name = "toolStripLabel1";
-        this.toolStripLabel1.Size = new System.Drawing.Size(86, 22);
-        this.toolStripLabel1.Text = "toolStripLabel1";
-        // 
-        // toolStripSplitButton2
-        // 
-        this.toolStripSplitButton2.AccessibleDescription = "This is toolStripSplitButton";
-        this.toolStripSplitButton2.AccessibleName = "TestToolStripSplitButton";
-        this.toolStripSplitButton2.AccessibleRole = System.Windows.Forms.AccessibleRole.ScrollBar;
-        this.toolStripSplitButton2.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripSplitButton2.Image = ((System.Drawing.Image)(resources.GetObject("toolStripSplitButton2.Image")));
-        this.toolStripSplitButton2.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripSplitButton2.Name = "toolStripSplitButton2";
-        this.toolStripSplitButton2.Size = new System.Drawing.Size(32, 22);
-        this.toolStripSplitButton2.Text = "toolStripSplitButton2";
-        // 
-        // toolStripDropDownButton2
-        // 
-        this.toolStripDropDownButton2.AccessibleDescription = "This is toolStripDropDownButton";
-        this.toolStripDropDownButton2.AccessibleName = "TestToolStripDropDownButton";
-        this.toolStripDropDownButton2.AccessibleRole = System.Windows.Forms.AccessibleRole.Grip;
-        this.toolStripDropDownButton2.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripDropDownButton2.Image = ((System.Drawing.Image)(resources.GetObject("toolStripDropDownButton2.Image")));
-        this.toolStripDropDownButton2.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripDropDownButton2.Name = "toolStripDropDownButton2";
-        this.toolStripDropDownButton2.Size = new System.Drawing.Size(29, 22);
-        this.toolStripDropDownButton2.Text = "toolStripDropDownButton2";
-        // 
-        // toolStripSeparator7
-        // 
-        this.toolStripSeparator7.AccessibleDescription = "This is toolStripSeparator";
-        this.toolStripSeparator7.AccessibleName = "TestToolStripSeparator";
-        this.toolStripSeparator7.AccessibleRole = System.Windows.Forms.AccessibleRole.Sound;
-        this.toolStripSeparator7.Name = "toolStripSeparator7";
-        this.toolStripSeparator7.Size = new System.Drawing.Size(6, 25);
-        // 
-        // toolStripComboBox3
-        // 
-        this.toolStripComboBox3.AccessibleDescription = "This is toolStripComboBox";
-        this.toolStripComboBox3.AccessibleName = "TestToolStripComboBox";
-        this.toolStripComboBox3.AccessibleRole = System.Windows.Forms.AccessibleRole.Cursor;
-        this.toolStripComboBox3.Name = "toolStripComboBox3";
-        this.toolStripComboBox3.Size = new System.Drawing.Size(121, 25);
-        // 
-        // toolStripTextBox3
-        // 
-        this.toolStripTextBox3.AccessibleDescription = "This is toolStripTextBox";
-        this.toolStripTextBox3.AccessibleName = "TestToolStripTextBox";
-        this.toolStripTextBox3.AccessibleRole = System.Windows.Forms.AccessibleRole.Caret;
-        this.toolStripTextBox3.Name = "toolStripTextBox3";
-        this.toolStripTextBox3.Size = new System.Drawing.Size(100, 25);
-        // 
-        // toolStripProgressBar2
-        // 
-        this.toolStripProgressBar2.AccessibleDescription = "This is toolStripProgressBar";
-        this.toolStripProgressBar2.AccessibleName = "TestToolStripProgressBar";
-        this.toolStripProgressBar2.AccessibleRole = System.Windows.Forms.AccessibleRole.Client;
-        this.toolStripProgressBar2.Name = "toolStripProgressBar2";
-        this.toolStripProgressBar2.Size = new System.Drawing.Size(100, 22);
-        // 
-        // webBrowser1
-        // 
-        this.webBrowser1.AccessibleDescription = "This is a WebBrowser";
-        this.webBrowser1.AccessibleName = "TestWebBrowser";
-        this.webBrowser1.AccessibleRole = System.Windows.Forms.AccessibleRole.Animation;
-        this.webBrowser1.Location = new System.Drawing.Point(350, 620);
-        this.webBrowser1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.webBrowser1.MinimumSize = new System.Drawing.Size(23, 23);
-        this.webBrowser1.Name = "webBrowser1";
-        this.webBrowser1.Size = new System.Drawing.Size(200, 165);
-        this.webBrowser1.TabIndex = 8;
-        // 
-        // splitContainer1
-        // 
-        this.splitContainer1.AccessibleDescription = "This is a splitContainer";
-        this.splitContainer1.AccessibleName = "splitContainerTest";
-        this.splitContainer1.AccessibleRole = System.Windows.Forms.AccessibleRole.SplitButton;
-        this.splitContainer1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(128)))), ((int)(((byte)(255)))), ((int)(((byte)(128)))));
-        this.splitContainer1.Location = new System.Drawing.Point(613, 554);
-        this.splitContainer1.Name = "splitContainer1";
-        this.splitContainer1.Size = new System.Drawing.Size(179,99);
-        this.splitContainer1.SplitterDistance = 69;
-        this.splitContainer1.TabIndex = 34;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.AccessibleDescription = "This is a radioButton";
-        this.radioButton1.AccessibleName = "radioButtonTest";
-        this.radioButton1.AccessibleRole = System.Windows.Forms.AccessibleRole.Grouping;
-        this.radioButton1.AutoSize = true;
-        this.radioButton1.Location = new System.Drawing.Point(15, 606);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(94, 19);
-        this.radioButton1.TabIndex = 32;
-        this.radioButton1.TabStop = true;
-        this.radioButton1.Text = "radioButton1";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // propertyGrid1
-        // 
-        this.propertyGrid1.AccessibleDescription = "This is a propertyGrid";
-        this.propertyGrid1.AccessibleName = "propertyGridTest";
-        this.propertyGrid1.AccessibleRole = System.Windows.Forms.AccessibleRole.PropertyPage;
-        this.propertyGrid1.Location = new System.Drawing.Point(159, 610);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(176, 174);
-        this.propertyGrid1.TabIndex = 31;
-        // 
-        // progressBar1
-        // 
-        this.progressBar1.AccessibleDescription = "This is a progressBar";
-        this.progressBar1.AccessibleName = "progressBarTest";
-        this.progressBar1.AccessibleRole = System.Windows.Forms.AccessibleRole.ProgressBar;
-        this.progressBar1.Location = new System.Drawing.Point(15, 572);
-        this.progressBar1.Name = "progressBar1";
-        this.progressBar1.Size = new System.Drawing.Size(100, 23);
-        this.progressBar1.TabIndex = 30;
-        // 
-        // printPreviewControl1
-        // 
-        this.printPreviewControl1.AccessibleDescription = "This is a printPreviewControl";
-        this.printPreviewControl1.AccessibleName = "printPreviewControlTest";
-        this.printPreviewControl1.AccessibleRole = System.Windows.Forms.AccessibleRole.Window;
-        this.printPreviewControl1.Location = new System.Drawing.Point(15, 640);
-        this.printPreviewControl1.Name = "printPreviewControl1";
-        this.printPreviewControl1.Size = new System.Drawing.Size(133, 140);
-        this.printPreviewControl1.TabIndex = 29;
-        // 
-        // splitter1
-        // 
-        this.splitter1.AccessibleDescription = "This is a splitter";
-        this.splitter1.AccessibleName = "splitterTest";
-        this.splitter1.AccessibleRole = System.Windows.Forms.AccessibleRole.SplitButton;
-        this.splitter1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(128)))), ((int)(((byte)(128)))));
-        this.splitter1.Dock = System.Windows.Forms.DockStyle.Right;
-        this.splitter1.Location = new System.Drawing.Point(883, 52);
-        this.splitter1.Name = "splitter1";
-        this.splitter1.Size = new System.Drawing.Size(31, 765);
-        this.splitter1.TabIndex = 35;
-        this.splitter1.TabStop = false;
-        // 
-        // statusStrip1
-        // 
-        this.statusStrip1.AccessibleDescription = "This is a statusStrip";
-        this.statusStrip1.AccessibleName = "statusStripTest";
-        this.statusStrip1.AccessibleRole = System.Windows.Forms.AccessibleRole.StatusBar;
-        this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripStatusLabel1,
-        this.toolStripProgressBar1,
-        this.toolStripDropDownButton1,
-        this.toolStripSplitButton1});
-        this.statusStrip1.Location = new System.Drawing.Point(0, 795);
-        this.statusStrip1.Name = "statusStrip1";
-        this.statusStrip1.Size = new System.Drawing.Size(883, 22);
-        this.statusStrip1.TabIndex = 36;
-        this.statusStrip1.Text = "statusStrip1";
-        // 
-        // toolStripStatusLabel1
-        // 
-        this.toolStripStatusLabel1.AccessibleDescription = "This is toolStripStatusLabel";
-        this.toolStripStatusLabel1.AccessibleName = "TestToolStripStatusLabel";
-        this.toolStripStatusLabel1.AccessibleRole = System.Windows.Forms.AccessibleRole.MenuBar;
-        this.toolStripStatusLabel1.Name = "toolStripStatusLabel1";
-        this.toolStripStatusLabel1.Size = new System.Drawing.Size(118, 17);
-        this.toolStripStatusLabel1.Text = "toolStripStatusLabel1";
-        // 
-        // toolStripProgressBar1
-        // 
-        this.toolStripProgressBar1.AccessibleDescription = "This is toolStripProgressBar";
-        this.toolStripProgressBar1.AccessibleName = "TestToolStripProgressBar";
-        this.toolStripProgressBar1.AccessibleRole = System.Windows.Forms.AccessibleRole.ScrollBar;
-        this.toolStripProgressBar1.Name = "toolStripProgressBar1";
-        this.toolStripProgressBar1.Size = new System.Drawing.Size(100, 16);
-        // 
-        // toolStripDropDownButton1
-        // 
-        this.toolStripDropDownButton1.AccessibleDescription = "This is toolStripDropDownButton";
-        this.toolStripDropDownButton1.AccessibleName = "TestToolStripDropDownButton";
-        this.toolStripDropDownButton1.AccessibleRole = System.Windows.Forms.AccessibleRole.Grip;
-        this.toolStripDropDownButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripDropDownButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripDropDownButton1.Image")));
-        this.toolStripDropDownButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripDropDownButton1.Name = "toolStripDropDownButton1";
-        this.toolStripDropDownButton1.Size = new System.Drawing.Size(29, 20);
-        this.toolStripDropDownButton1.Text = "toolStripDropDownButton1";
-        // 
-        // toolStripSplitButton1
-        // 
-        this.toolStripSplitButton1.AccessibleDescription = "This is toolStripSplitButton";
-        this.toolStripSplitButton1.AccessibleName = "TestToolStripSplitButton";
-        this.toolStripSplitButton1.AccessibleRole = System.Windows.Forms.AccessibleRole.Sound;
-        this.toolStripSplitButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripSplitButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripSplitButton1.Image")));
-        this.toolStripSplitButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripSplitButton1.Name = "toolStripSplitButton1";
-        this.toolStripSplitButton1.Size = new System.Drawing.Size(32, 20);
-        this.toolStripSplitButton1.Text = "toolStripSplitButton1";
-        // 
-        // dataGridView1
-        // 
-        this.dataGridView1.AccessibleDescription = "This is dataGridView1";
-        this.dataGridView1.AccessibleName = "TestDataGridView";
-        this.dataGridView1.AccessibleRole = System.Windows.Forms.AccessibleRole.Alert;
-        this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView1.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
-        this.Column1,
-        this.Column2,
-        this.Column3,
-        this.Column4});
-        this.dataGridView1.Location = new System.Drawing.Point(133, 62);
-        this.dataGridView1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.dataGridView1.Name = "dataGridView1";
-        this.dataGridView1.Size = new System.Drawing.Size(324, 174);
-        this.dataGridView1.TabIndex = 37;
-        // 
-        // Column1
-        // 
-        this.Column1.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.ComboBox;
-        this.Column1.HeaderText = "CBColumn1";
-        this.Column1.Name = "Column1";
-        // 
-        // Column2
-        // 
-        this.Column2.HeaderText = "CBColumn2";
-        this.Column2.Name = "Column2";
-        // 
-        // Column3
-        // 
-        this.Column3.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.Nothing;
-        this.Column3.HeaderText = "CBColumn3";
-        this.Column3.Name = "Column3";
-        // 
-        // Column4
-        // 
-        this.Column4.HeaderText = "TBColumn";
-        this.Column4.Name = "Column4";
-        // 
-        // toolStripContainer1
-        // 
-        this.toolStripContainer1.AccessibleDescription = "This is a ToolStripContainer";
-        this.toolStripContainer1.AccessibleName = "TestToolStripContainer";
-        this.toolStripContainer1.AccessibleRole = System.Windows.Forms.AccessibleRole.PageTabList;
-        // 
-        // 
-        // 
-        this.toolStripContainer1.BottomToolStripPanel.Location = new System.Drawing.Point(0, 0);
-        this.toolStripContainer1.BottomToolStripPanel.Name = "";
-        this.toolStripContainer1.BottomToolStripPanel.Orientation = System.Windows.Forms.Orientation.Horizontal;
-        this.toolStripContainer1.BottomToolStripPanel.RowMargin = new System.Windows.Forms.Padding(3, 0, 0, 0);
-        // 
-        // 
-        // 
-        this.toolStripContainer1.ContentPanel.AccessibleDescription = "This is a ToolStripContainer.ContentPanel";
-        this.toolStripContainer1.ContentPanel.AccessibleName = "TestToolStripContainer.ContentPanel";
-        this.toolStripContainer1.ContentPanel.AccessibleRole = System.Windows.Forms.AccessibleRole.WhiteSpace;
-        this.toolStripContainer1.ContentPanel.Size = new System.Drawing.Size(202, 123);
-        // 
-        // 
-        // 
-        this.toolStripContainer1.LeftToolStripPanel.Location = new System.Drawing.Point(0, 0);
-        this.toolStripContainer1.LeftToolStripPanel.Name = "";
-        this.toolStripContainer1.LeftToolStripPanel.Orientation = System.Windows.Forms.Orientation.Horizontal;
-        this.toolStripContainer1.LeftToolStripPanel.RowMargin = new System.Windows.Forms.Padding(3, 0, 0, 0);
-        this.toolStripContainer1.Location = new System.Drawing.Point(613, 670);
-        this.toolStripContainer1.Name = "toolStripContainer1";
-        // 
-        // 
-        // 
-        this.toolStripContainer1.RightToolStripPanel.Location = new System.Drawing.Point(0, 0);
-        this.toolStripContainer1.RightToolStripPanel.Name = "";
-        this.toolStripContainer1.RightToolStripPanel.Orientation = System.Windows.Forms.Orientation.Horizontal;
-        this.toolStripContainer1.RightToolStripPanel.RowMargin = new System.Windows.Forms.Padding(3, 0, 0, 0);
-        this.toolStripContainer1.Size = new System.Drawing.Size(202, 123);
-        this.toolStripContainer1.TabIndex = 0;
-        this.toolStripContainer1.Text = "toolStripContainer1";
-        // 
-        // 
-        // 
-        this.toolStripContainer1.TopToolStripPanel.Location = new System.Drawing.Point(0, 0);
-        this.toolStripContainer1.TopToolStripPanel.Name = "";
-        this.toolStripContainer1.TopToolStripPanel.Orientation = System.Windows.Forms.Orientation.Horizontal;
-        this.toolStripContainer1.TopToolStripPanel.RowMargin = new System.Windows.Forms.Padding(3, 0, 0, 0);
-        // 
-        // richTextBox1
-        // 
-        this.richTextBox1.AccessibleDescription = "This is RichTextBox";
-        this.richTextBox1.AccessibleName = "TestRichTextBox";
-        this.richTextBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Border;
-        this.richTextBox1.Location = new System.Drawing.Point(799, 554);
-        this.richTextBox1.Name = "richTextBox1";
-        this.richTextBox1.Size = new System.Drawing.Size(100, 96);
-        this.richTextBox1.TabIndex = 38;
-        this.richTextBox1.Text = "";
-        // 
-        // CustomAccessiblePropertiesForm
-        // 
-        this.AccessibleDescription = "This is customAccessiblePropertiesForm";
-        this.AccessibleName = "testForm";
-        this.AccessibleRole = System.Windows.Forms.AccessibleRole.Window;
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(944, 817);
-        this.ContextMenuStrip = this.contextMenuStrip1;
-        this.Controls.Add(this.richTextBox1);
-        this.Controls.Add(this.dataGridView1);
-        this.Controls.Add(this.toolStripContainer1);
-        this.Controls.Add(this.statusStrip1);
-        this.Controls.Add(this.splitter1);
-        this.Controls.Add(this.splitContainer1);
-        this.Controls.Add(this.radioButton1);
-        this.Controls.Add(this.propertyGrid1);
-        this.Controls.Add(this.progressBar1);
-        this.Controls.Add(this.printPreviewControl1);
-        this.Controls.Add(this.webBrowser1);
-        this.Controls.Add(this.toolStrip1);
-        this.Controls.Add(this.vScrollBar1);
-        this.Controls.Add(this.treeView1);
-        this.Controls.Add(this.trackBar1);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.tableLayoutPanel1);
-        this.Controls.Add(this.tabControl1);
-        this.Controls.Add(this.menuStrip1);
-        this.Controls.Add(this.pictureBox1);
-        this.Controls.Add(this.panel1);
-        this.Controls.Add(this.numericUpDown1);
-        this.Controls.Add(this.monthCalendar1);
-        this.Controls.Add(this.maskedTextBox1);
-        this.Controls.Add(this.listView1);
-        this.Controls.Add(this.listBox1);
-        this.Controls.Add(this.linkLabel1);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.hScrollBar1);
-        this.Controls.Add(this.groupBox1);
-        this.Controls.Add(this.flowLayoutPanel1);
-        this.Controls.Add(this.domainUpDown1);
-        this.Controls.Add(this.dateTimePicker1);
-        this.Controls.Add(this.comboBox1);
-        this.Controls.Add(this.checkedListBox1);
-        this.Controls.Add(this.checkBox1);
-        this.Controls.Add(this.button1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "CustomAccessiblePropertiesForm";
-        this.Text = "CustomAccessiblePropertiesForm";
-        this.contextMenuStrip1.ResumeLayout(false);
-        this.contextMenuStrip1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
-        this.menuStrip1.ResumeLayout(false);
-        this.menuStrip1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).EndInit();
-        this.tabControl1.ResumeLayout(false);
-        this.toolStrip1.ResumeLayout(false);
-        this.toolStrip1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
-        this.splitContainer1.ResumeLayout(false);
-        this.statusStrip1.ResumeLayout(false);
-        this.statusStrip1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.CheckedListBox checkedListBox1;
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
-    private System.Windows.Forms.DateTimePicker dateTimePicker1;
-    private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem1;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox1;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator1;
-    private System.Windows.Forms.ToolStripTextBox toolStripTextBox1;
-    private System.Windows.Forms.LinkLabel linkLabel1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.HScrollBar hScrollBar1;
-    private System.Windows.Forms.GroupBox groupBox1;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel1;
-    private System.Windows.Forms.DomainUpDown domainUpDown1;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-    private System.Windows.Forms.MonthCalendar monthCalendar1;
-    private System.Windows.Forms.MaskedTextBox maskedTextBox1;
-    private System.Windows.Forms.ListView listView1;
-    private System.Windows.Forms.ListBox listBox1;
-    private System.Windows.Forms.PictureBox pictureBox1;
-    private System.Windows.Forms.Panel panel1;
-    private System.Windows.Forms.MenuStrip menuStrip1;
-    private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator;
-    private System.Windows.Forms.ToolStripMenuItem saveToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem saveAsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator2;
-    private System.Windows.Forms.ToolStripMenuItem printToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem printPreviewToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator3;
-    private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem undoToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem redoToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator4;
-    private System.Windows.Forms.ToolStripMenuItem cutToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem copyToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem pasteToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator5;
-    private System.Windows.Forms.ToolStripMenuItem selectAllToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem toolsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem customizeToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem optionsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem contentsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem indexToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem searchToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator6;
-    private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox2;
-    private System.Windows.Forms.ToolStripTextBox toolStripTextBox2;
-    private System.Windows.Forms.VScrollBar vScrollBar1;
-    private System.Windows.Forms.TreeView treeView1;
-    private System.Windows.Forms.TrackBar trackBar1;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
-    private System.Windows.Forms.TabControl tabControl1;
-    private System.Windows.Forms.TabPage tabPage1;
-    private System.Windows.Forms.TabPage tabPage2;
-    private System.Windows.Forms.ToolStrip toolStrip1;
-    private System.Windows.Forms.WebBrowser webBrowser1;
-    private System.Windows.Forms.SplitContainer splitContainer1;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-    private System.Windows.Forms.ProgressBar progressBar1;
-    private System.Windows.Forms.PrintPreviewControl printPreviewControl1;
-    private System.Windows.Forms.Splitter splitter1;
-    private System.Windows.Forms.StatusStrip statusStrip1;
-    private System.Windows.Forms.DataGridView dataGridView1;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column1;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column2;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column3;
-    private System.Windows.Forms.DataGridViewTextBoxColumn Column4;
-    private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1;
-    private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar1;
-    private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButton1;
-    private System.Windows.Forms.ToolStripSplitButton toolStripSplitButton1;
-    private System.Windows.Forms.ToolStripButton toolStripButton1;
-    private System.Windows.Forms.ToolStripLabel toolStripLabel1;
-    private System.Windows.Forms.ToolStripSplitButton toolStripSplitButton2;
-    private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButton2;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator7;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox3;
-    private System.Windows.Forms.ToolStripTextBox toolStripTextBox3;
-    private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar2;
-    private System.Windows.Forms.ToolStripContainer toolStripContainer1;
-    private System.Windows.Forms.RichTextBox richTextBox1;
-}
-
-
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.cs b/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.cs
deleted file mode 100644
index d70cdcc799b..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class CustomAccessiblePropertiesForm : Form
-{
-    public CustomAccessiblePropertiesForm()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.resx b/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.resx
deleted file mode 100644
index bfcbcbe074c..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/CustomAccessiblePropertiesForm.resx
+++ /dev/null
@@ -1,109 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Drawing.Common" name="System.Drawing.Common, Version=5.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51" />
-  <data name="toolStripButton1.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACRSURBVDhPY/j27dt/SjDYACcnJ7IwigEf3n8kCZNswPNb
-        J/+f6DYF0yA+yQac6Db5f6hWCmwIiE+mC0wIu2DS2Vf/F1x6DefjwlgNyNr34r/0wkdgTMgQDAOQNRNj
-        CIoBOg0rMTTDMLIhIHbriZeYBmDTiIxBGkEYxge5liQDsGGQqykyAISpZwAlmIEywMAAAAc1/Jwvt6sN
-        AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="toolStripSplitButton2.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACRSURBVDhPY/j27dt/SjDYACcnJ7IwigEf3n8kCZNswPNb
-        J/+f6DYF0yA+yQac6Db5f6hWCmwIiE+mC0wIu2DS2Vf/F1x6DefjwlgNyNr34r/0wkdgTMgQDAOQNRNj
-        CIoBOg0rMTTDMLIhIHbriZeYBmDTiIxBGkEYxge5liQDsGGQqykyAISpZwAlmIEywMAAAAc1/Jwvt6sN
-        AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="toolStripDropDownButton2.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACRSURBVDhPY/j27dt/SjDYACcnJ7IwigEf3n8kCZNswPNb
-        J/+f6DYF0yA+yQac6Db5f6hWCmwIiE+mC0wIu2DS2Vf/F1x6DefjwlgNyNr34r/0wkdgTMgQDAOQNRNj
-        CIoBOg0rMTTDMLIhIHbriZeYBmDTiIxBGkEYxge5liQDsGGQqykyAISpZwAlmIEywMAAAAc1/Jwvt6sN
-        AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="toolStripDropDownButton1.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACRSURBVDhPY/j27dt/SjDYACcnJ7IwigEf3n8kCZNswPNb
-        J/+f6DYF0yA+yQac6Db5f6hWCmwIiE+mC0wIu2DS2Vf/F1x6DefjwlgNyNr34r/0wkdgTMgQDAOQNRNj
-        CIoBOg0rMTTDMLIhIHbriZeYBmDTiIxBGkEYxge5liQDsGGQqykyAISpZwAlmIEywMAAAAc1/Jwvt6sN
-        AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="toolStripSplitButton1.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAACRSURBVDhPY/j27dt/SjDYACcnJ7IwigEf3n8kCZNswPNb
-        J/+f6DYF0yA+yQac6Db5f6hWCmwIiE+mC0wIu2DS2Vf/F1x6DefjwlgNyNr34r/0wkdgTMgQDAOQNRNj
-        CIoBOg0rMTTDMLIhIHbriZeYBmDTiIxBGkEYxge5liQDsGGQqykyAISpZwAlmIEywMAAAAc1/Jwvt6sN
-        AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <metadata name="$this.TrayHeight" type="System.Int32, System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e">
-    <value>74</value>
-  </metadata>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.Designer.cs
deleted file mode 100644
index 8b42763598b..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.Designer.cs
+++ /dev/null
@@ -1,312 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class DataBindingExample
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-    #region Windows Form Designer generated code
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.dataGridView1 = new System.Windows.Forms.DataGridView();
-        this.panel1 = new System.Windows.Forms.Panel();
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.label1 = new System.Windows.Forms.Label();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.button1 = new System.Windows.Forms.Button();
-        this.linkLabel1 = new System.Windows.Forms.LinkLabel();
-        this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.richTextBox1 = new System.Windows.Forms.RichTextBox();
-        this.domainUpDown1 = new System.Windows.Forms.DomainUpDown();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.label2 = new System.Windows.Forms.Label();
-        this.treeView1 = new System.Windows.Forms.TreeView();
-        this.label3 = new System.Windows.Forms.Label();
-        this.listView1 = new System.Windows.Forms.ListView();
-        this.label4 = new System.Windows.Forms.Label();
-        this.listBox1 = new System.Windows.Forms.ListBox();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
-        this.panel1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.AccessibleDescription = "CB1";
-        this.comboBox1.AccessibleName = "CB1";
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Location = new System.Drawing.Point(10, 9);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(121, 23);
-        this.comboBox1.TabIndex = 2;
-        this.comboBox1.Text = "ComboBox_DropDown";
-        // 
-        // dataGridView1
-        // 
-        this.dataGridView1.AccessibleDescription = "DGV1";
-        this.dataGridView1.AccessibleName = "DGV1";
-        this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView1.Location = new System.Drawing.Point(12, 21);
-        this.dataGridView1.Name = "dataGridView1";
-        this.dataGridView1.Size = new System.Drawing.Size(240, 150);
-        this.dataGridView1.TabIndex = 0;
-        this.dataGridView1.StandardTab = true;
-        this.dataGridView1.Text = "dataGridView1";
-        // 
-        // label1
-        // 
-        this.label1.AccessibleDescription = "L1";
-        this.label1.AccessibleName = "L1";
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(10, 48);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(109, 15);
-        this.label1.TabIndex = 3;
-        this.label1.Text = "StudentPhoneNum";
-        // 
-        // textBox1
-        // 
-        this.textBox1.AccessibleDescription = "TB1";
-        this.textBox1.AccessibleName = "TB1";
-        this.textBox1.Location = new System.Drawing.Point(10, 77);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(142, 23);
-        this.textBox1.TabIndex = 4;
-        this.textBox1.Text = "TextBox";
-        // 
-        // button1
-        // 
-        this.button1.AccessibleDescription = "BT1";
-        this.button1.AccessibleName = "BT1";
-        this.button1.Location = new System.Drawing.Point(10, 136);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(75, 23);
-        this.button1.TabIndex = 5;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // panel1
-        // 
-        this.panel1.AccessibleDescription = "Pane1";
-        this.panel1.AccessibleName = "Panel1";
-        this.panel1.Controls.Add(this.comboBox1);
-        this.panel1.Controls.Add(this.label1);
-        this.panel1.Controls.Add(this.textBox1);
-        this.panel1.Controls.Add(this.button1);
-        this.panel1.Controls.Add(this.linkLabel1);
-        this.panel1.Controls.Add(this.maskedTextBox1);
-        this.panel1.Controls.Add(this.checkBox1);
-        this.panel1.Controls.Add(this.richTextBox1);
-        this.panel1.Controls.Add(this.domainUpDown1);
-        this.panel1.Controls.Add(this.numericUpDown1);
-        this.panel1.Controls.Add(this.radioButton1);
-        this.panel1.Location = new System.Drawing.Point(272, 12);
-        this.panel1.Name = "panel1";
-        this.panel1.Size = new System.Drawing.Size(479, 198);
-        this.panel1.TabIndex = 1;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.AccessibleDescription = "RB1";
-        this.radioButton1.AccessibleName = "RB1";
-        this.radioButton1.AutoSize = true;
-        this.radioButton1.Location = new System.Drawing.Point(336, 77);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(84, 19);
-        this.radioButton1.TabIndex = 12;
-        this.radioButton1.TabStop = true;
-        this.radioButton1.Text = "Agreement";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // numericUpDown1
-        // 
-        this.numericUpDown1.AccessibleDescription = "NUO1";
-        this.numericUpDown1.AccessibleName = "NUO1";
-        this.numericUpDown1.Location = new System.Drawing.Point(336, 39);
-        this.numericUpDown1.Name = "numericUpDown1";
-        this.numericUpDown1.Size = new System.Drawing.Size(120, 23);
-        this.numericUpDown1.TabIndex = 11;
-        // 
-        // domainUpDown1
-        // 
-        this.domainUpDown1.AccessibleDescription = "DUO1";
-        this.domainUpDown1.AccessibleName = "DUO1";
-        this.domainUpDown1.Location = new System.Drawing.Point(336, 10);
-        this.domainUpDown1.Name = "domainUpDown1";
-        this.domainUpDown1.Size = new System.Drawing.Size(120, 23);
-        this.domainUpDown1.TabIndex = 10;
-        this.domainUpDown1.Text = "Student count";
-        // 
-        // richTextBox1
-        // 
-        this.richTextBox1.AccessibleDescription = "RT1";
-        this.richTextBox1.AccessibleName = "RT1";
-        this.richTextBox1.Location = new System.Drawing.Point(169, 102);
-        this.richTextBox1.Name = "richTextBox1";
-        this.richTextBox1.Size = new System.Drawing.Size(151, 85);
-        this.richTextBox1.TabIndex = 9;
-        this.richTextBox1.Text = "RichTestBox";
-        this.richTextBox1.BackColor = System.Drawing.SystemColors.Window;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AccessibleDescription = "CB2";
-        this.checkBox1.AccessibleName = "CB2";
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(169, 77);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(80, 19);
-        this.checkBox1.TabIndex = 8;
-        this.checkBox1.Text = "Is_Student";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // maskedTextBox1
-        // 
-        this.maskedTextBox1.AccessibleDescription = "MT1";
-        this.maskedTextBox1.AccessibleName = "MT1";
-        this.maskedTextBox1.Location = new System.Drawing.Point(169, 45);
-        this.maskedTextBox1.Name = "maskedTextBox1";
-        this.maskedTextBox1.Size = new System.Drawing.Size(142, 23);
-        this.maskedTextBox1.TabIndex = 7;
-        this.maskedTextBox1.Text = "MaskedTextBox";
-        // 
-        // linkLabel1
-        // 
-        this.linkLabel1.AccessibleDescription = "IL1";
-        this.linkLabel1.AccessibleName = "IL1";
-        this.linkLabel1.AutoSize = true;
-        this.linkLabel1.Location = new System.Drawing.Point(169, 12);
-        this.linkLabel1.Name = "linkLabel1";
-        this.linkLabel1.Size = new System.Drawing.Size(84, 15);
-        this.linkLabel1.TabIndex = 6;
-        this.linkLabel1.TabStop = true;
-        this.linkLabel1.Text = "HomeNumber";
-        // 
-        // label2
-        // 
-        this.label2.AccessibleDescription = "L2";
-        this.label2.AccessibleName = "L2";
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(37, 224);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(53, 15);
-        this.label2.TabIndex = 13;
-        this.label2.Text = "TreeView";
-        // 
-        // treeView1
-        // 
-        this.treeView1.AccessibleDescription = "TV1";
-        this.treeView1.AccessibleName = "TV1";
-        this.treeView1.Location = new System.Drawing.Point(12, 242);
-        this.treeView1.Name = "treeView1";
-        this.treeView1.Size = new System.Drawing.Size(129, 101);
-        this.treeView1.TabIndex = 14;
-        // 
-        // label3
-        // 
-        this.label3.AccessibleDescription = "L3";
-        this.label3.AccessibleName = "L3";
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(244, 225);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(50, 15);
-        this.label3.TabIndex = 15;
-        this.label3.Text = "ListView";
-        // 
-        // listView1
-        // 
-        this.listView1.AccessibleDescription = "LV1";
-        this.listView1.AccessibleName = "LV1";
-        this.listView1.HideSelection = false;
-        this.listView1.Location = new System.Drawing.Point(162, 246);
-        this.listView1.Name = "listView1";
-        this.listView1.Size = new System.Drawing.Size(203, 97);
-        this.listView1.TabIndex = 16;
-        this.listView1.UseCompatibleStateImageBehavior = false;
-        this.listView1.View = System.Windows.Forms.View.Details;
-        // 
-        // label4
-        // 
-        this.label4.AccessibleDescription = "L5";
-        this.label4.AccessibleName = "L5";
-        this.label4.AutoSize = true;
-        this.label4.Location = new System.Drawing.Point(476, 225);
-        this.label4.Name = "label5";
-        this.label4.Size = new System.Drawing.Size(45, 15);
-        this.label4.TabIndex = 17;
-        this.label4.Text = "ListBox";
-        // 
-        // listBox1
-        // 
-        this.listBox1.AccessibleDescription = "LB5";
-        this.listBox1.AccessibleName = "LB5";
-        this.listBox1.FormattingEnabled = true;
-        this.listBox1.ItemHeight = 15;
-        this.listBox1.Location = new System.Drawing.Point(453, 249);
-        this.listBox1.Name = "listBox1";
-        this.listBox1.Size = new System.Drawing.Size(120, 94);
-        this.listBox1.TabIndex = 18;
-        // 
-        // DataBindingExample
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(785, 383);
-        this.Controls.Add(this.dataGridView1);
-        this.Controls.Add(this.panel1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.treeView1);
-        this.Controls.Add(this.listBox1);
-        this.Controls.Add(this.label3);
-        this.Controls.Add(this.listView1);
-        this.Controls.Add(this.label4);
-        this.Name = "DataBindingExample";
-        this.Text = "DataBindingExampleForControls";
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
-        this.panel1.ResumeLayout(false);
-        this.panel1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-    }
-    #endregion
-    private System.Windows.Forms.DataGridView dataGridView1;
-    private System.Windows.Forms.Panel panel1;
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.LinkLabel linkLabel1;
-    private System.Windows.Forms.MaskedTextBox maskedTextBox1;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.RichTextBox richTextBox1;
-    private System.Windows.Forms.DomainUpDown domainUpDown1;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.TreeView treeView1;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.ListView listView1;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.ListBox listBox1;
-}
-
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.cs
deleted file mode 100644
index 9eb2dd5a1fb..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Data;
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class DataBindingExample : Form
-{
-    private readonly List<Student> _studentA = new();
-    private readonly List<Student> _studentB = new();
-
-    public DataBindingExample()
-    {
-        InitializeComponent();
-    }
-
-    protected override void OnLoad(EventArgs e)
-    {
-        BindingData();
-    }
-
-    private void BindingData()
-    {
-        for (int i = 0; i < 6; i++)
-        {
-            _studentA.Add(new Student(i, $"Name 1{i}", "Male"));
-            _studentB.Add(new Student(i * 2, $"Name 11{i * 2}", "Female"));
-        }
-
-        // Binding Data For ListBox & ComboBox & CheckedListBox controls by using DataSource property
-        listBox1.DataSource = _studentA;
-        comboBox1.DataSource = _studentB;
-
-        listBox1.DisplayMember = nameof(Student.Name);
-        comboBox1.DisplayMember = nameof(Student.Name);
-
-        // Binding Data For DataGridView control by using DadSource property
-        dataGridView1.DataSource = new List<Student>
-        {
-            new Student(1, "StudentA", "Female", 12121, "1001", "Basketball", false, 10, 11),
-            new Student(2, "StudentB", "Male", 12122, "1002", "Basketball", true, 10, 11),
-            new Student(3, "StudentC", "Female", 12123, "1003", "Football", false, 10, 11),
-            new Student(4, "StudentD", "Male", 12124, "1004", "Football", true, 10, 11),
-        };
-
-        // Binding Data For TextBox/Label/DomainUpDown/NumericUpDown/LinkLabel/CheckBox/RadioButton/RichTextBox/MaskedTextBox/Button controls by using DadaBindings property
-        Student stu = new Student(1, "StudentNumber", "Female", 12121, "HomeNumber", "Habits\nBasketball\nFootball", true, 10, 11);
-        textBox1.DataBindings.Add("Text", stu, "StudentNumber");
-        domainUpDown1.DataBindings.Add("Text", stu, "LuckyNumber");
-        numericUpDown1.DataBindings.Add("Text", stu, "Count");
-        label1.DataBindings.Add("Text", stu, "Name");
-        button1.DataBindings.Add("Text", stu, "Sex");
-        maskedTextBox1.DataBindings.Add("Text", stu, "PhoneNumber");
-        linkLabel1.DataBindings.Add("Text", stu, "HomeNumber");
-        richTextBox1.DataBindings.Add("Text", stu, "Hobby");
-        checkBox1.DataBindings.Add("Checked", stu, "IsStudent");
-        radioButton1.DataBindings.Add("Checked", stu, "IsStudent");
-
-        // Binding Data For TreeView control by using DataSet
-        BindTreeView();
-
-        // Binding Data For ListView control by using DataSet
-        BindListView();
-    }
-
-    private void BindTreeView()
-    {
-        using DataSet dataSet = CreateDataSet();
-
-        if (dataSet.Tables[0].Rows.Count > 0)
-        {
-            for (int i = 0; i < dataSet.Tables[0].Rows.Count; i++)
-            {
-                TreeNode node = new TreeNode();
-                node.Text = dataSet.Tables[0].Rows[i]["StuName"].ToString();
-                treeView1.Nodes.Add(node);
-            }
-        }
-    }
-
-    private void BindListView()
-    {
-        listView1.View = View.Details;
-        using DataSet dataSet = CreateDataSet();
-
-        int row_Count = dataSet.Tables[0].Rows.Count;
-        int col_Count = dataSet.Tables[0].Columns.Count;
-
-        for (int j = 0; j < col_Count; j++)
-        {
-            string colName = dataSet.Tables[0].Columns[j].ColumnName;
-            listView1.Columns.Add(colName);
-        }
-
-        for (int i = 0; i < row_Count; i++)
-        {
-            string itemName = dataSet.Tables[0].Rows[i][0].ToString();
-            ListViewItem item = new ListViewItem(itemName, i);
-            listView1.Items.Add(item);
-
-            for (int j = 1; j < col_Count; j++)
-            {
-                item.SubItems.Add(dataSet.Tables[0].Rows[i][j].ToString());
-            }
-        }
-    }
-
-    // Create DataSet
-    public DataSet CreateDataSet()
-    {
-        DataSet stuDS = new DataSet();
-        DataTable stuTable = new DataTable("Students");
-
-        stuTable.Columns.Add("StuName", typeof(string));
-        stuTable.Columns.Add("StuSex", typeof(string));
-        stuTable.Columns.Add("StuAge", typeof(int));
-
-        DataRow stuRow = stuTable.NewRow();
-        stuRow["StuName"] = "sofie";
-        stuRow["StuSex"] = "male";
-        stuRow["StuAge"] = 21;
-        stuTable.Rows.Add(stuRow);
-
-        stuRow = stuTable.NewRow();
-        stuRow["StuName"] = "Jrain";
-        stuRow["StuSex"] = "Female";
-        stuRow["StuAge"] = 21;
-        stuTable.Rows.Add(stuRow);
-
-        stuRow = stuTable.NewRow();
-        stuRow["StuName"] = "Lida";
-        stuRow["StuSex"] = "male";
-        stuRow["StuAge"] = 21;
-        stuTable.Rows.Add(stuRow);
-        stuDS.Tables.Add(stuTable);
-
-        return stuDS;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.resx b/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.resx
deleted file mode 100644
index da834e20291..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataBindingExample.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.Designer.cs
deleted file mode 100644
index 76afdf7fb37..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.Designer.cs
+++ /dev/null
@@ -1,405 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class DataControls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(DataControls));
-        this.bindingNavigator1 = new System.Windows.Forms.BindingNavigator(this.components);
-        this.bindingNavigatorAddNewItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorCountItem = new System.Windows.Forms.ToolStripLabel();
-        this.bindingNavigatorDeleteItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorMoveFirstItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorMovePreviousItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorSeparator = new System.Windows.Forms.ToolStripSeparator();
-        this.bindingNavigatorPositionItem = new System.Windows.Forms.ToolStripTextBox();
-        this.bindingNavigatorSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-        this.bindingNavigatorMoveNextItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorMoveLastItem = new System.Windows.Forms.ToolStripButton();
-        this.bindingNavigatorSeparator2 = new System.Windows.Forms.ToolStripSeparator();
-        this.toolStripButton1 = new System.Windows.Forms.ToolStripButton();
-        this.toolStripLabel1 = new System.Windows.Forms.ToolStripLabel();
-        this.toolStripSplitButton1 = new System.Windows.Forms.ToolStripSplitButton();
-        this.toolStripDropDownButton1 = new System.Windows.Forms.ToolStripDropDownButton();
-        this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-        this.toolStripComboBox1 = new System.Windows.Forms.ToolStripComboBox();
-        this.toolStripTextBox1 = new System.Windows.Forms.ToolStripTextBox();
-        this.toolStripProgressBar1 = new System.Windows.Forms.ToolStripProgressBar();
-        this.toolStripLabel2 = new System.Windows.Forms.ToolStripLabel();
-        this.dataGridView1 = new System.Windows.Forms.DataGridView();
-        this.Column1 = new System.Windows.Forms.DataGridViewButtonColumn();
-        this.Column2 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column3 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column4 = new System.Windows.Forms.DataGridViewCheckBoxColumn();
-        this.Column5 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.Column6 = new System.Windows.Forms.DataGridViewImageColumn();
-        this.Column7 = new System.Windows.Forms.DataGridViewLinkColumn();
-        this.Column8 = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.dataGridView2 = new System.Windows.Forms.DataGridView();
-        this.bindingSource1 = new System.Windows.Forms.BindingSource(this.components);
-        ((System.ComponentModel.ISupportInitialize)(this.bindingNavigator1)).BeginInit();
-        this.bindingNavigator1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView2)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // bindingNavigator1
-        // 
-        this.bindingNavigator1.AddNewItem = this.bindingNavigatorAddNewItem;
-        this.bindingNavigator1.CountItem = this.bindingNavigatorCountItem;
-        this.bindingNavigator1.DeleteItem = this.bindingNavigatorDeleteItem;
-        this.bindingNavigator1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.bindingNavigatorMoveFirstItem,
-        this.bindingNavigatorMovePreviousItem,
-        this.bindingNavigatorSeparator,
-        this.bindingNavigatorPositionItem,
-        this.bindingNavigatorCountItem,
-        this.bindingNavigatorSeparator1,
-        this.bindingNavigatorMoveNextItem,
-        this.bindingNavigatorMoveLastItem,
-        this.bindingNavigatorSeparator2,
-        this.bindingNavigatorAddNewItem,
-        this.bindingNavigatorDeleteItem,
-        this.toolStripButton1,
-        this.toolStripLabel1,
-        this.toolStripSplitButton1,
-        this.toolStripDropDownButton1,
-        this.toolStripSeparator1,
-        this.toolStripComboBox1,
-        this.toolStripTextBox1,
-        this.toolStripProgressBar1,
-        this.toolStripLabel2});
-        this.bindingNavigator1.Location = new System.Drawing.Point(0, 0);
-        this.bindingNavigator1.MoveFirstItem = this.bindingNavigatorMoveFirstItem;
-        this.bindingNavigator1.MoveLastItem = this.bindingNavigatorMoveLastItem;
-        this.bindingNavigator1.MoveNextItem = this.bindingNavigatorMoveNextItem;
-        this.bindingNavigator1.MovePreviousItem = this.bindingNavigatorMovePreviousItem;
-        this.bindingNavigator1.Name = "bindingNavigator1";
-        this.bindingNavigator1.PositionItem = this.bindingNavigatorPositionItem;
-        this.bindingNavigator1.Size = new System.Drawing.Size(868, 28);
-        this.bindingNavigator1.TabIndex = 0;
-        this.bindingNavigator1.TabStop = true;
-        this.bindingNavigator1.Text = "bindingNavigator1";
-        // 
-        // bindingNavigatorAddNewItem
-        // 
-        this.bindingNavigatorAddNewItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorAddNewItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorAddNewItem.Image")));
-        this.bindingNavigatorAddNewItem.Name = "bindingNavigatorAddNewItem";
-        this.bindingNavigatorAddNewItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorAddNewItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorAddNewItem.Text = "Add new";
-        this.bindingNavigatorAddNewItem.Click += new System.EventHandler(this.bindingNavigatorAddNewItem_Click);
-        // 
-        // bindingNavigatorCountItem
-        // 
-        this.bindingNavigatorCountItem.Name = "bindingNavigatorCountItem";
-        this.bindingNavigatorCountItem.Size = new System.Drawing.Size(35, 25);
-        this.bindingNavigatorCountItem.Text = "of {0}";
-        this.bindingNavigatorCountItem.ToolTipText = "Total number of items";
-        // 
-        // bindingNavigatorDeleteItem
-        // 
-        this.bindingNavigatorDeleteItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorDeleteItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorDeleteItem.Image")));
-        this.bindingNavigatorDeleteItem.Name = "bindingNavigatorDeleteItem";
-        this.bindingNavigatorDeleteItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorDeleteItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorDeleteItem.Text = "Delete";
-        // 
-        // bindingNavigatorMoveFirstItem
-        // 
-        this.bindingNavigatorMoveFirstItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorMoveFirstItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorMoveFirstItem.Image")));
-        this.bindingNavigatorMoveFirstItem.Name = "bindingNavigatorMoveFirstItem";
-        this.bindingNavigatorMoveFirstItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorMoveFirstItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorMoveFirstItem.Text = "Move first";
-        // 
-        // bindingNavigatorMovePreviousItem
-        // 
-        this.bindingNavigatorMovePreviousItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorMovePreviousItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorMovePreviousItem.Image")));
-        this.bindingNavigatorMovePreviousItem.Name = "bindingNavigatorMovePreviousItem";
-        this.bindingNavigatorMovePreviousItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorMovePreviousItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorMovePreviousItem.Text = "Move previous";
-        // 
-        // bindingNavigatorSeparator
-        // 
-        this.bindingNavigatorSeparator.Name = "bindingNavigatorSeparator";
-        this.bindingNavigatorSeparator.Size = new System.Drawing.Size(6, 28);
-        // 
-        // bindingNavigatorPositionItem
-        // 
-        this.bindingNavigatorPositionItem.AccessibleName = "Position";
-        this.bindingNavigatorPositionItem.AutoSize = false;
-        this.bindingNavigatorPositionItem.Name = "bindingNavigatorPositionItem";
-        this.bindingNavigatorPositionItem.Size = new System.Drawing.Size(58, 23);
-        this.bindingNavigatorPositionItem.Text = "0";
-        this.bindingNavigatorPositionItem.ToolTipText = "Current position";
-        // 
-        // bindingNavigatorSeparator1
-        // 
-        this.bindingNavigatorSeparator1.Name = "bindingNavigatorSeparator1";
-        this.bindingNavigatorSeparator1.Size = new System.Drawing.Size(6, 28);
-        // 
-        // bindingNavigatorMoveNextItem
-        // 
-        this.bindingNavigatorMoveNextItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorMoveNextItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorMoveNextItem.Image")));
-        this.bindingNavigatorMoveNextItem.Name = "bindingNavigatorMoveNextItem";
-        this.bindingNavigatorMoveNextItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorMoveNextItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorMoveNextItem.Text = "Move next";
-        // 
-        // bindingNavigatorMoveLastItem
-        // 
-        this.bindingNavigatorMoveLastItem.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.bindingNavigatorMoveLastItem.Image = ((System.Drawing.Image)(resources.GetObject("bindingNavigatorMoveLastItem.Image")));
-        this.bindingNavigatorMoveLastItem.Name = "bindingNavigatorMoveLastItem";
-        this.bindingNavigatorMoveLastItem.RightToLeftAutoMirrorImage = true;
-        this.bindingNavigatorMoveLastItem.Size = new System.Drawing.Size(23, 25);
-        this.bindingNavigatorMoveLastItem.Text = "Move last";
-        // 
-        // bindingNavigatorSeparator2
-        // 
-        this.bindingNavigatorSeparator2.Name = "bindingNavigatorSeparator2";
-        this.bindingNavigatorSeparator2.Size = new System.Drawing.Size(6, 28);
-        // 
-        // toolStripButton1
-        // 
-        this.toolStripButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton1.Image")));
-        this.toolStripButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripButton1.Name = "toolStripButton1";
-        this.toolStripButton1.Size = new System.Drawing.Size(114, 25);
-        this.toolStripButton1.Text = "toolStripButton1";
-        // 
-        // toolStripLabel1
-        // 
-        this.toolStripLabel1.Name = "toolStripLabel1";
-        this.toolStripLabel1.Size = new System.Drawing.Size(86, 25);
-        this.toolStripLabel1.Text = "toolStripLabel1";
-        // 
-        // toolStripSplitButton1
-        // 
-        this.toolStripSplitButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripSplitButton1.Image")));
-        this.toolStripSplitButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripSplitButton1.Name = "toolStripSplitButton1";
-        this.toolStripSplitButton1.Size = new System.Drawing.Size(149, 25);
-        this.toolStripSplitButton1.Text = "toolStripSplitButton1";
-        // 
-        // toolStripDropDownButton1
-        // 
-        this.toolStripDropDownButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripDropDownButton1.Image")));
-        this.toolStripDropDownButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripDropDownButton1.Name = "toolStripDropDownButton1";
-        this.toolStripDropDownButton1.Size = new System.Drawing.Size(180, 25);
-        this.toolStripDropDownButton1.Text = "toolStripDropDownButton1";
-        // 
-        // toolStripSeparator1
-        // 
-        this.toolStripSeparator1.Name = "toolStripSeparator1";
-        this.toolStripSeparator1.Size = new System.Drawing.Size(6, 28);
-        // 
-        // toolStripComboBox1
-        // 
-        this.toolStripComboBox1.AccessibleName = "CB1";
-        this.toolStripComboBox1.Items.AddRange(new object[] {
-        "Test1",
-        "Test2"});
-        this.toolStripComboBox1.Name = "toolStripComboBox1";
-        this.toolStripComboBox1.Size = new System.Drawing.Size(140, 23);
-        this.toolStripComboBox1.Text = "Test1";
-        // 
-        // toolStripTextBox1
-        // 
-        this.toolStripTextBox1.Name = "toolStripTextBox1";
-        this.toolStripTextBox1.Size = new System.Drawing.Size(116, 23);
-        this.toolStripTextBox1.Text = "Test1";
-        // 
-        // toolStripProgressBar1
-        // 
-        this.toolStripProgressBar1.AccessibleDescription = "This is PB";
-        this.toolStripProgressBar1.AccessibleName = "PB1";
-        this.toolStripProgressBar1.Name = "toolStripProgressBar1";
-        this.toolStripProgressBar1.Size = new System.Drawing.Size(117, 25);
-        this.toolStripProgressBar1.Tag = "PB";
-        this.toolStripProgressBar1.ToolTipText = "ProgressBar1";
-        this.toolStripProgressBar1.Value = 50;
-        // 
-        // toolStripLabel2
-        // 
-        this.toolStripLabel2.Name = "toolStripLabel2";
-        this.toolStripLabel2.Size = new System.Drawing.Size(282, 15);
-        this.toolStripLabel2.Text = "The current progress percentage of ProgressBar is 50";
-        // 
-        // dataGridView1
-        // 
-        this.dataGridView1.AccessibleName = "DGV1";
-        this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView1.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
-        this.Column1,
-        this.Column2,
-        this.Column3,
-        this.Column4,
-        this.Column5,
-        this.Column6,
-        this.Column7,
-        this.Column8});
-        this.dataGridView1.Location = new System.Drawing.Point(13, 323);
-        this.dataGridView1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.dataGridView1.Name = "dataGridView1";
-        this.dataGridView1.Size = new System.Drawing.Size(844, 115);
-        this.dataGridView1.StandardTab = true;
-        this.dataGridView1.TabIndex = 2;
-        // 
-        // Column1
-        // 
-        this.Column1.HeaderText = "Name";
-        this.Column1.Name = "Column1";
-        // 
-        // Column2
-        // 
-        this.Column2.HeaderText = "City";
-        this.Column2.Items.AddRange(new object[] {
-        "City1",
-        "City2"});
-        this.Column2.Name = "Column2";
-        // 
-        // Column3
-        // 
-        this.Column3.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.ComboBox;
-        this.Column3.HeaderText = "Country";
-        this.Column3.Items.AddRange(new object[] {
-        "Country1",
-        "Country2"});
-        this.Column3.Name = "Column3";
-        // 
-        // Column4
-        // 
-        this.Column4.HeaderText = "IsHealthy";
-        this.Column4.Name = "Column4";
-        // 
-        // Column5
-        // 
-        this.Column5.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.Nothing;
-        this.Column5.HeaderText = "Gender";
-        this.Column5.Items.AddRange(new object[] {
-        "Male",
-        "Female"});
-        this.Column5.Name = "Column5";
-        // 
-        // Column6
-        // 
-        this.Column6.HeaderText = "Photo";
-        this.Column6.Name = "Column6";
-        // 
-        // Column7
-        // 
-        this.Column7.HeaderText = "Address";
-        this.Column7.Name = "Column7";
-        this.Column7.Text = "Address1";
-        this.Column7.UseColumnTextForLinkValue = true;
-        // 
-        // Column8
-        // 
-        this.Column8.HeaderText = "Comment";
-        this.Column8.Name = "Column8";
-        // 
-        // dataGridView2
-        // 
-        this.dataGridView2.AccessibleName = "DGV2";
-        this.dataGridView2.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView2.Location = new System.Drawing.Point(13, 46);
-        this.dataGridView2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.dataGridView2.Name = "dataGridView2";
-        this.dataGridView2.Size = new System.Drawing.Size(408, 258);
-        this.dataGridView2.StandardTab = true;
-        this.dataGridView2.TabIndex = 1;
-        // 
-        // DataControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.AutoScroll = true;
-        this.ClientSize = new System.Drawing.Size(868, 450);
-        this.Controls.Add(this.dataGridView2);
-        this.Controls.Add(this.dataGridView1);
-        this.Controls.Add(this.bindingNavigator1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "DataControls";
-        this.Text = "DataControls";
-        this.Load += new System.EventHandler(this.DataControls_Load);
-        ((System.ComponentModel.ISupportInitialize)(this.bindingNavigator1)).EndInit();
-        this.bindingNavigator1.ResumeLayout(false);
-        this.bindingNavigator1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView2)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.bindingSource1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.BindingNavigator bindingNavigator1;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorAddNewItem;
-    private System.Windows.Forms.ToolStripLabel bindingNavigatorCountItem;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorDeleteItem;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorMoveFirstItem;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorMovePreviousItem;
-    private System.Windows.Forms.ToolStripSeparator bindingNavigatorSeparator;
-    private System.Windows.Forms.ToolStripTextBox bindingNavigatorPositionItem;
-    private System.Windows.Forms.ToolStripSeparator bindingNavigatorSeparator1;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorMoveNextItem;
-    private System.Windows.Forms.ToolStripButton bindingNavigatorMoveLastItem;
-    private System.Windows.Forms.ToolStripSeparator bindingNavigatorSeparator2;
-    private System.Windows.Forms.DataGridView dataGridView1;
-    private System.Windows.Forms.DataGridViewButtonColumn Column1;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column2;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column3;
-    private System.Windows.Forms.DataGridViewCheckBoxColumn Column4;
-    private System.Windows.Forms.DataGridViewComboBoxColumn Column5;
-    private System.Windows.Forms.DataGridViewImageColumn Column6;
-    private System.Windows.Forms.DataGridViewLinkColumn Column7;
-    private System.Windows.Forms.DataGridViewTextBoxColumn Column8;
-    private System.Windows.Forms.ToolStripButton toolStripButton1;
-    private System.Windows.Forms.ToolStripLabel toolStripLabel1;
-    private System.Windows.Forms.ToolStripSplitButton toolStripSplitButton1;
-    private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButton1;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator1;
-    private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar1;
-    private System.Windows.Forms.ToolStripTextBox toolStripTextBox1;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox1;
-    private System.Windows.Forms.DataGridView dataGridView2;
-    private System.Windows.Forms.BindingSource bindingSource1;
-    private System.Windows.Forms.ToolStripLabel toolStripLabel2;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.cs
deleted file mode 100644
index aec77759dc4..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Data;
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class DataControls : Form
-{
-    public DataControls()
-    {
-        InitializeComponent();
-    }
-
-    private void DataControls_Load(object sender, EventArgs e)
-    {
-        DataTable dataTable = new DataTable();
-        dataTable.Columns.Add("Name");
-        dataTable.Columns.Add("Id");
-        dataTable.Columns.Add("Desc");
-        for (int i = 0; i < 20; i++)
-        {
-            DataRow dataRow = dataTable.NewRow();
-            dataRow[0] = $"Jack{i}";
-            dataRow[1] = i * 10;
-            dataRow[2] = $"I like{i}";
-            dataTable.Rows.Add(dataRow);
-        }
-
-        bindingSource1.DataSource = dataTable;
-        dataGridView2.DataSource = bindingSource1;
-        bindingNavigator1.BindingSource = bindingSource1;
-
-        dataGridView1.Rows[0].Cells[0].Value = "Rose";
-        dataGridView1.CurrentCell = dataGridView1.Rows[0].Cells[0];
-        dataGridView1.BeginEdit(false);
-        DataGridViewComboBoxEditingControl cbox = dataGridView1.EditingControl as DataGridViewComboBoxEditingControl;
-        if (cbox is not null)
-            cbox.DroppedDown = true;
-    }
-
-    private void bindingNavigatorAddNewItem_Click(object sender, EventArgs e)
-    {
-        dataGridView2.Focus();
-        bindingNavigator1.AccessibilityObject.RaiseAutomationNotification(
-            System.Windows.Forms.Automation.AutomationNotificationKind.Other,
-          System.Windows.Forms.Automation.AutomationNotificationProcessing.CurrentThenMostRecent,
-          "Please enter first name now");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.resx
deleted file mode 100644
index 43467020d76..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DataControls.resx
+++ /dev/null
@@ -1,194 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="bindingNavigatorAddNewItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAAUpJREFUOE9jGLzg7gL2/7fmcf6/Oofr/8UZvP+hwsSD60CNfx41/v/zsOH/yckC
-        pBtwfjov3ICDPSKkG3B8kiBQc93/Pw+q/u9oFydswKWZPP/PTuX7fxKo8Ui/0P993SJAzeX//94r+r++
-        Qeb/qhq5/0srFf/PL1X+P6tIFdPAU0B//nlYD9RUC8SV///cKwHivP9/72b+/3sn+f/f23H//92MAOKQ
-        /5NyNDENONQrDHbu3/ulQI0FQI3ZQI2pQI0J///digZqDPv/70bQ/3/X/f53peliGrCzXeL/lmap/+vA
-        zpX/v6RC8f/fWzFAjeH/p+Zp/J+QpfW/O0P3f3uq/v/mREPCYTIb6E+Qc//dCPjfk6FDWAM6APnz3w1/
-        IPb735qsT7oB3em6YP+CcH2cEekGtCQZ/G+IN/xfE2v8vzLahHQD6AQYGAAkI9iedfyIaQAAAABJRU5E
-        rkJggg==
-</value>
-  </data>
-  <data name="bindingNavigatorDeleteItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAAW9JREFUOE+1kE0ow2Ecx3dV3krt4oJaOSCTvIRkMqSxyITIzCQHDouEdnFwIOVC
-        DrhIDiQl5UTiNG/z2ppafy1S2gX/uDwfY6i1v7Hie3nqeb7fz+/7/FR/Ilwn0G0Exw4fV5GJlXlEZxXC
-        rIet9bAQvB5Ymgn2sLYAvSZEux7RUQFzE4qQt4bCXAYjPaHvnDoCkLpsRGMB2JqCTGLIijDlwqQ9bEMV
-        i9OIytR3EMNWcJ/BWH8A6j8/bOGFxwXNxYEvGbMQ9XnQ1/K78KfY3/VXzkMY0qFGG2H4RoLGQshJQNbG
-        86CNhdrsX9a/uQZTPhQl4rMY4OLofbl3aX7I8uwPC7y/g1YdjyVJuEvT8e1tfwUYteHUxCCfHChDeHmG
-        QQvokjlOU+PbWA0x3pZnILVVI3uvQyHsbiLnqnGmRCF1NYD8pDhpRxOH7HQoAKZGkFKjceszQbpSrumX
-        bO+G80MFwKUTxgfgcO/b8D9IpXoFiiMDHIQm0skAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="bindingNavigatorMoveFirstItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAASpJREFUOE9jGDygcNbz/00Lnv/PnPj4P1QIA4S3P8Apx5A789n/VUfe/8elKL77
-        wf/ghmu4DciY8vT/wn0fsCqK73n4f+n+///9qy/gNiCh58n/aVveYyiKaL8P1pw56/9/r9ITuA2I7Hr0
-        v3f1BxRFoa33wJpb1wFt7/z73yX/AG4DApsf/q+b/w6uKLjl7v9Fe///7wBqzpjz879d3c//9hnbcRvg
-        UXX/f/60NyiK7Ipv/0+f8/u/f9e3/zqF7/5bJKzHbYB96d3/2ZNfYyjSTzn/36ToxX+VrE//jSOX4TbA
-        Iu/O/9T+11gVGSSd+C+b9vW/bvA83AYYZt3+H9byEqci/dTL/zV8p+E2QCftxn+/6od4Fal4TMBtgFPu
-        lf8gBXgVDULAwAAA8HbAq6XlmnAAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="bindingNavigatorMovePreviousItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAALZJREFUOE9jGDogvP3BfyiTdBDf/eB/cMM18gyI73n4f+n+///9qy+QbkBE+32w
-        5sxZ//97lZ4gzYDQ1ntgza3rgLZ3/v3vkn+AeAOCW+7+X7T3//8OoOaMOT//29X9/G+fsZ00F9gV3/6f
-        Puf3f/+ub/91Ct/9t0hYT3oY6Kec/29S9OK/Stan/8aRy0g3AAQMkk78l037+l83eB55BoCAfurl/xq+
-        08g3AARUPCZQZsBgBQwMANAUYJgEulBVAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="bindingNavigatorMoveNextItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAAKNJREFUOE9jGHygcNbz/1AmeSB35rP/Cd33yDckY8rT//P2//6f0HWHPEMSep78
-        n73v1//OrX//u5VeJt2QyK5H/6ds+/W/ZOnf/wnT//63yT1LmiGBzQ//t659D9ZsXPLlv3T0tf/GkcuI
-        N8Sj6v7/krnv4JoVXXpIc4F96d3/gS3PyNMMAhZ5d/7bFFwhTzMIGGbdJl8zCOik3SBf81AEDAwAoH5f
-        oAc0QjgAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="bindingNavigatorMoveLastItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
-        vAAADrwBlbxySQAAASxJREFUOE9jGFygcNbz/1AmBgDJNS14/j9z4mOcahhyZz77n9B9D6sCkNyqI+//
-        h7c/wG1AxpSn/+ft//0/oesOhiKQ3MJ9H/4HN1zDbUBCz5P/s/f9+t+59e9/t9LLKApBctO2vP/vX30B
-        twGRXY/+T9n263/J0r//E6b//W+TexauGCTXu/rDf6/SE7gNCGx++L917XuwZuOSL/+lo6/9N45cBtYA
-        kqub/+6/S/4B3AZ4VN3/XzL3HVyzoksPXDFILn/am//2GdtxG2Bfevd/YMszDM0gAJLLnvz6v0XCetwG
-        WOTd+W9TcAVDMwiA5FL7X8O9hBUYZt3GqhkEQHJhLS//6wbPw22ATtoNnJIgOb/qh/81fKfhNgAfcMq9
-        8l/FYwIYQ4UGBWBgAAC+0b+zuQxOnAAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripSplitButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripDropDownButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <metadata name="Column1.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column2.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column3.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column4.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column5.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column6.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="bindingSource1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>45</value>
-  </metadata>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.Designer.cs
deleted file mode 100644
index 539f0f8c598..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.Designer.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class DialogControls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.ColorDialog = new System.Windows.Forms.Button();
-        this.FolderBrowserDialog = new System.Windows.Forms.Button();
-        this.OpenFileDialog = new System.Windows.Forms.Button();
-        this.SaveFileDialog = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // ColorDialog
-        // 
-        this.ColorDialog.Location = new System.Drawing.Point(42, 12);
-        this.ColorDialog.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.ColorDialog.Name = "ColorDialog";
-        this.ColorDialog.Size = new System.Drawing.Size(88, 27);
-        this.ColorDialog.TabIndex = 0;
-        this.ColorDialog.Text = "ColorDialog";
-        this.ColorDialog.UseVisualStyleBackColor = true;
-        this.ColorDialog.Click += new System.EventHandler(this.ColorDialog_Click);
-        // 
-        // FolderBrowserDialog
-        // 
-        this.FolderBrowserDialog.Location = new System.Drawing.Point(42, 67);
-        this.FolderBrowserDialog.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.FolderBrowserDialog.Name = "FolderBrowserDialog";
-        this.FolderBrowserDialog.Size = new System.Drawing.Size(153, 27);
-        this.FolderBrowserDialog.TabIndex = 1;
-        this.FolderBrowserDialog.Text = "FolderBrowserDialog";
-        this.FolderBrowserDialog.UseVisualStyleBackColor = true;
-        this.FolderBrowserDialog.Click += new System.EventHandler(this.FolderBrowserDialog_Click);
-        // 
-        // OpenFileDialog
-        // 
-        this.OpenFileDialog.Location = new System.Drawing.Point(42, 125);
-        this.OpenFileDialog.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.OpenFileDialog.Name = "OpenFileDialog";
-        this.OpenFileDialog.Size = new System.Drawing.Size(108, 27);
-        this.OpenFileDialog.TabIndex = 2;
-        this.OpenFileDialog.Text = "OpenFileDialog";
-        this.OpenFileDialog.UseVisualStyleBackColor = true;
-        this.OpenFileDialog.Click += new System.EventHandler(this.OpenFileDialog_Click);
-        // 
-        // SaveFileDialog
-        // 
-        this.SaveFileDialog.Location = new System.Drawing.Point(42, 181);
-        this.SaveFileDialog.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.SaveFileDialog.Name = "SaveFileDialog";
-        this.SaveFileDialog.Size = new System.Drawing.Size(114, 27);
-        this.SaveFileDialog.TabIndex = 3;
-        this.SaveFileDialog.Text = "SaveFileDialog";
-        this.SaveFileDialog.UseVisualStyleBackColor = true;
-        this.SaveFileDialog.Click += new System.EventHandler(this.SaveFileDialog_Click);
-        // 
-        // DialogControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(268, 233);
-        this.Controls.Add(this.SaveFileDialog);
-        this.Controls.Add(this.OpenFileDialog);
-        this.Controls.Add(this.FolderBrowserDialog);
-        this.Controls.Add(this.ColorDialog);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "DialogControls";
-        this.Text = "DialogsTesting";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button ColorDialog;
-    private System.Windows.Forms.Button FolderBrowserDialog;
-    private System.Windows.Forms.Button OpenFileDialog;
-    private System.Windows.Forms.Button SaveFileDialog;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.cs
deleted file mode 100644
index 7c46a47388c..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class DialogControls : Form
-{
-    public DialogControls()
-    {
-        InitializeComponent();
-    }
-
-    private void ColorDialog_Click(object sender, EventArgs e)
-    {
-        ColorDialog colorDialog = new ColorDialog();
-        colorDialog.ShowDialog();
-    }
-
-    private void FolderBrowserDialog_Click(object sender, EventArgs e)
-    {
-        FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
-        folderBrowserDialog.ShowDialog();
-    }
-
-    private void OpenFileDialog_Click(object sender, EventArgs e)
-    {
-        OpenFileDialog openFileDialog = new OpenFileDialog();
-        openFileDialog.ShowDialog();
-    }
-
-    private void SaveFileDialog_Click(object sender, EventArgs e)
-    {
-        SaveFileDialog saveFileDialog = new SaveFileDialog();
-        saveFileDialog.ShowDialog();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/DialogControls.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/HTMLPage1.html b/src/System.Windows.Forms/tests/AccessibilityTests/HTMLPage1.html
deleted file mode 100644
index b2cd84084d4..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/HTMLPage1.html
+++ /dev/null
@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-
-<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
-<head>
-    <meta charset="utf-8" />
-    <title>Test Title</title>
-</head>
-<body>
-    <H1> This is my HTML Doc</H1>
-    This is some normal text
-    <OL>
-        <LI> One</LI>
-	<LI> Two</LI>
-    </OL>
-</body>
-</html>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Main.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Main.Designer.cs
deleted file mode 100644
index 209f4f1ba4e..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Main.Designer.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-using System.Windows.Forms;
-namespace Accessibility_Core_App;
-
-partial class Main
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.button1 = new System.Windows.Forms.Button();
-        this.button2 = new System.Windows.Forms.Button();
-        this.button3 = new System.Windows.Forms.Button();
-        this.button4 = new System.Windows.Forms.Button();
-        this.button5 = new System.Windows.Forms.Button();
-        this.button6 = new System.Windows.Forms.Button();
-        this.button7 = new System.Windows.Forms.Button();
-        this.button8 = new System.Windows.Forms.Button();
-        this.button9 = new System.Windows.Forms.Button();
-        this.button10 = new System.Windows.Forms.Button();
-        this.button11 = new System.Windows.Forms.Button();
-        this.button12 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(14, 14);
-        this.button1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(531, 27);
-        this.button1.TabIndex = 0;
-        this.button1.Text = "Common_Controls1: Testing the controls under the Common_Controls Tab";
-        this.button1.UseVisualStyleBackColor = true;
-        this.button1.Click += new System.EventHandler(this.Button1_Click);
-        // 
-        // button2
-        // 
-        this.button2.Location = new System.Drawing.Point(14, 60);
-        this.button2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(531, 27);
-        this.button2.TabIndex = 1;
-        this.button2.Text = "Common_Controls2: Testing the controls under the Common_Controls Tab";
-        this.button2.UseVisualStyleBackColor = true;
-        this.button2.Click += new System.EventHandler(this.Button2_Click);
-        // 
-        // button3
-        // 
-        this.button3.Location = new System.Drawing.Point(13, 105);
-        this.button3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button3.Name = "button3";
-        this.button3.Size = new System.Drawing.Size(531, 27);
-        this.button3.TabIndex = 2;
-        this.button3.Text = "Data_Controls: Testing the controls under the Data Tab";
-        this.button3.UseVisualStyleBackColor = true;
-        this.button3.Click += new System.EventHandler(this.Button3_Click);
-        // 
-        // button4
-        // 
-        this.button4.Location = new System.Drawing.Point(13, 152);
-        this.button4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button4.Name = "button4";
-        this.button4.Size = new System.Drawing.Size(531, 27);
-        this.button4.TabIndex = 3;
-        this.button4.Text = "Dialogs_Controls: Testing the controls under the Dialogs Tab";
-        this.button4.UseVisualStyleBackColor = true;
-        this.button4.Click += new System.EventHandler(this.Button4_Click);
-        // 
-        // button5
-        // 
-        this.button5.Location = new System.Drawing.Point(13, 199);
-        this.button5.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button5.Name = "button5";
-        this.button5.Size = new System.Drawing.Size(531, 27);
-        this.button5.TabIndex = 4;
-        this.button5.Text = "MenuToolbars_Controls: Testing the controls under the Menu & Toolbars Tab";
-        this.button5.UseVisualStyleBackColor = true;
-        this.button5.Click += new System.EventHandler(this.Button5_Click);
-        // 
-        // button6
-        // 
-        this.button6.Location = new System.Drawing.Point(14, 247);
-        this.button6.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button6.Name = "button6";
-        this.button6.Size = new System.Drawing.Size(531, 27);
-        this.button6.TabIndex = 5;
-        this.button6.Text = "Printing_Controls: Testing the controls under the Printing Tab";
-        this.button6.UseVisualStyleBackColor = true;
-        this.button6.Click += new System.EventHandler(this.Button6_Click);
-        // 
-        // button7
-        // 
-        this.button7.Location = new System.Drawing.Point(13, 292);
-        this.button7.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button7.Name = "button7";
-        this.button7.Size = new System.Drawing.Size(531, 27);
-        this.button7.TabIndex = 6;
-        this.button7.Text = "Remaining_Controls_Testing";
-        this.button7.UseVisualStyleBackColor = true;
-        this.button7.Click += new System.EventHandler(this.Button7_Click);
-        // 
-        // button8
-        // 
-        this.button8.Location = new System.Drawing.Point(14, 336);
-        this.button8.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button8.Name = "button8";
-        this.button8.Size = new System.Drawing.Size(531, 27);
-        this.button8.TabIndex = 7;
-        this.button8.Text = "Containers_Controls: Testing the controls under the Containers Tab";
-        this.button8.UseVisualStyleBackColor = true;
-        this.button8.Click += new System.EventHandler(this.Button8_Click);
-        // 
-        // button9
-        // 
-        this.button9.Location = new System.Drawing.Point(13, 380);
-        this.button9.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button9.Name = "button9";
-        this.button9.Size = new System.Drawing.Size(531, 27);
-        this.button9.TabIndex = 8;
-        this.button9.Text = "Containers_Controls_2: Testing the controls under the Containers Tab";
-        this.button9.UseVisualStyleBackColor = true;
-        this.button9.Click += new System.EventHandler(this.button9_Click);
-        // 
-        // button10
-        // 
-        this.button10.Location = new System.Drawing.Point(14, 425);
-        this.button10.Name = "button10";
-        this.button10.Size = new System.Drawing.Size(530, 27);
-        this.button10.TabIndex = 9;
-        this.button10.Text = "TaskDialog: Testing the task dialog";
-        this.button10.UseVisualStyleBackColor = true;
-        this.button10.Click += new System.EventHandler(this.button10_Click);
-        // 
-        // button11
-        // 
-        this.button11.Location = new System.Drawing.Point(14, 469);
-        this.button11.Name = "button11";
-        this.button11.Size = new System.Drawing.Size(530, 28);
-        this.button11.TabIndex = 10;
-        this.button11.Text = "Accessible properties: Testing controls with custom accessible name, role, and de" +
-"scription";
-        this.button11.UseVisualStyleBackColor = true;
-        this.button11.Click += new System.EventHandler(this.button11_Click);
-        // 
-        // button12
-        // 
-        this.button12.Location = new System.Drawing.Point(14, 514);
-        this.button12.Name = "button12";
-        this.button12.Size = new System.Drawing.Size(530, 23);
-        this.button12.TabIndex = 11;
-        this.button12.Text = "DataBinding Example";
-        this.button12.UseVisualStyleBackColor = true;
-        this.button12.Click += new System.EventHandler(this.button12_Click);
-        // 
-        // Main
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(576, 538);
-        this.Controls.Add(this.button12);
-        this.Controls.Add(this.button11);
-        this.Controls.Add(this.button10);
-        this.Controls.Add(this.button9);
-        this.Controls.Add(this.button8);
-        this.Controls.Add(this.button7);
-        this.Controls.Add(this.button6);
-        this.Controls.Add(this.button5);
-        this.Controls.Add(this.button4);
-        this.Controls.Add(this.button3);
-        this.Controls.Add(this.button2);
-        this.Controls.Add(this.button1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "Main";
-        this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
-        this.Text = "MainForm";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Button button2;
-    private System.Windows.Forms.Button button3;
-    private System.Windows.Forms.Button button4;
-    private System.Windows.Forms.Button button5;
-    private System.Windows.Forms.Button button6;
-    private System.Windows.Forms.Button button7;
-    private System.Windows.Forms.Button button8;
-    private Button button9;
-    private Button button10;
-    private Button button11;
-    private Button button12;
-}
-
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Main.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Main.cs
deleted file mode 100644
index 6655cf4f2e1..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Main.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class Main : Form
-{
-    public Main()
-    {
-        InitializeComponent();
-    }
-
-    private void Button1_Click(object sender, EventArgs e)
-    {
-        CommonControl1 commonControl1 = new CommonControl1();
-        commonControl1.Show();
-    }
-
-    private void Button2_Click(object sender, EventArgs e)
-    {
-        CommonControl2 commonControl2 = new CommonControl2();
-        commonControl2.Show();
-    }
-
-    private void Button3_Click(object sender, EventArgs e)
-    {
-        DataControls dataControls = new DataControls();
-        dataControls.Show();
-    }
-
-    private void Button4_Click(object sender, EventArgs e)
-    {
-        DialogControls dialogsTesting = new DialogControls();
-        dialogsTesting.Show();
-    }
-
-    private void Button5_Click(object sender, EventArgs e)
-    {
-        MenuForm menuForm = new MenuForm();
-        menuForm.Show();
-    }
-
-    private void Button6_Click(object sender, EventArgs e)
-    {
-        PrintingControls printingTesting = new PrintingControls();
-        printingTesting.Show();
-    }
-
-    private void Button7_Click(object sender, EventArgs e)
-    {
-        RemainingControls remainingControls = new RemainingControls();
-        remainingControls.Show();
-    }
-
-    private void Button8_Click(object sender, EventArgs e)
-    {
-        ContainerControls containerControl = new ContainerControls();
-        containerControl.Show();
-    }
-
-    private void button9_Click(object sender, EventArgs e)
-    {
-        ContainerControls2 containerControl2 = new ContainerControls2();
-        containerControl2.Show();
-    }
-
-    private void button10_Click(object sender, EventArgs e)
-    {
-        TaskDialogTesting taskDialogTesting = new();
-        taskDialogTesting.ShowEventsDemoTaskDialog();
-    }
-
-    private void button11_Click(object sender, EventArgs e)
-    {
-        CustomAccessiblePropertiesForm cusAcccName = new();
-        cusAcccName.StartPosition = FormStartPosition.CenterParent;
-        cusAcccName.Show();
-    }
-
-    private void button12_Click(object sender, EventArgs e)
-    {
-        DataBindingExample dataBindingExample = new();
-        dataBindingExample.Show();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Main.resx b/src/System.Windows.Forms/tests/AccessibilityTests/Main.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Main.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.Designer.cs
deleted file mode 100644
index a6beab9d4e0..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.Designer.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class MenuForm
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.button1 = new System.Windows.Forms.Button();
-        this.button2 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(78, 46);
-        this.button1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(88, 27);
-        this.button1.TabIndex = 0;
-        this.button1.Text = "StripControls";
-        this.button1.UseVisualStyleBackColor = true;
-        this.button1.Click += new System.EventHandler(this.Button1_Click);
-        // 
-        // button2
-        // 
-        this.button2.Location = new System.Drawing.Point(264, 46);
-        this.button2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(122, 27);
-        this.button2.TabIndex = 1;
-        this.button2.Text = "ToolStripContainer";
-        this.button2.UseVisualStyleBackColor = true;
-        this.button2.Click += new System.EventHandler(this.Button2_Click);
-        // 
-        // MenuForm
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(467, 441);
-        this.Controls.Add(this.button2);
-        this.Controls.Add(this.button1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "MenuForm";
-        this.Text = "MenuForm";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Button button2;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.cs b/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.cs
deleted file mode 100644
index 5b1b8b801df..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class MenuForm : Form
-{
-    public MenuForm()
-    {
-        InitializeComponent();
-    }
-
-    private void Button1_Click(object sender, EventArgs e)
-    {
-        Menu_Toolbars_controls stripControls = new Menu_Toolbars_controls();
-        stripControls.Show();
-    }
-
-    private void Button2_Click(object sender, EventArgs e)
-    {
-        ToolStripContainer toolStripContainer = new ToolStripContainer();
-        toolStripContainer.Show();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.resx b/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/MenuForm.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.Designer.cs
deleted file mode 100644
index 6f4690171e5..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.Designer.cs
+++ /dev/null
@@ -1,679 +0,0 @@
-using System.Drawing;
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-partial class Menu_Toolbars_controls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-/// <summary>
-/// Clean up any resources being used.
-/// </summary>
-/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-protected override void Dispose(bool disposing)
-{
-    if (disposing && (components != null))
-    {
-        components.Dispose();
-    }
-    base.Dispose(disposing);
-}
-
-#region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Menu_Toolbars_controls));
-        menuStrip1 = new MenuStrip();
-        contextMenuStrip1 = new ContextMenuStrip(components);
-        menuStripToolStripMenuItem = new ToolStripMenuItem();
-        item1ToolStripMenuItem = new ToolStripMenuItem();
-        shortCutsToolStripMenuItem = new ToolStripMenuItem();
-        item2ToolStripMenuItem = new ToolStripMenuItem();
-        fileToolStripMenuItem = new ToolStripMenuItem();
-        newToolStripMenuItem = new ToolStripMenuItem();
-        openToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator = new ToolStripSeparator();
-        saveToolStripMenuItem = new ToolStripMenuItem();
-        saveAsToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator1 = new ToolStripSeparator();
-        printToolStripMenuItem = new ToolStripMenuItem();
-        printPreviewToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator2 = new ToolStripSeparator();
-        exitToolStripMenuItem = new ToolStripMenuItem();
-        editToolStripMenuItem = new ToolStripMenuItem();
-        undoToolStripMenuItem = new ToolStripMenuItem();
-        redoToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator3 = new ToolStripSeparator();
-        cutToolStripMenuItem = new ToolStripMenuItem();
-        copyToolStripMenuItem = new ToolStripMenuItem();
-        pasteToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator4 = new ToolStripSeparator();
-        selectAllToolStripMenuItem = new ToolStripMenuItem();
-        toolsToolStripMenuItem = new ToolStripMenuItem();
-        customizeToolStripMenuItem = new ToolStripMenuItem();
-        optionsToolStripMenuItem = new ToolStripMenuItem();
-        helpToolStripMenuItem = new ToolStripMenuItem();
-        contentsToolStripMenuItem = new ToolStripMenuItem();
-        indexToolStripMenuItem = new ToolStripMenuItem();
-        searchToolStripMenuItem = new ToolStripMenuItem();
-        toolStripSeparator5 = new ToolStripSeparator();
-        aboutToolStripMenuItem = new ToolStripMenuItem();
-        toolStripMenuItem1 = new ToolStripMenuItem();
-        uncheckedCheckOnClickToolStripMenuItem = new ToolStripMenuItem();
-        checkCheckOnClickToolStripMenuItem = new ToolStripMenuItem();
-        checkedCheckOnClickFToolStripMenuItem = new ToolStripMenuItem();
-        indeterminateToolStripMenuItem = new ToolStripMenuItem();
-        indeterminateCheckOnClickFToolStripMenuItem = new ToolStripMenuItem();
-        toolStripComboBox1 = new ToolStripComboBox();
-        toolStripTextBox1 = new ToolStripTextBox();
-        statusStrip1 = new StatusStrip();
-        toolStripDropDownButton1 = new ToolStripDropDownButton();
-        toolStripSeparator9 = new ToolStripSeparator();
-        toolStripTextBox3 = new ToolStripTextBox();
-        toolStripMenuItem3 = new ToolStripMenuItem();
-        toolStripSplitButton1 = new ToolStripSplitButton();
-        toolStripTextBox2 = new ToolStripTextBox();
-        toolStripSeparator8 = new ToolStripSeparator();
-        toolStripComboBox2 = new ToolStripComboBox();
-        toolStripMenuItem2 = new ToolStripMenuItem();
-        toolStripStatusLabel1 = new ToolStripStatusLabel();
-        toolStripProgressBar1 = new ToolStripProgressBar();
-        toolStrip1 = new ToolStrip();
-        newToolStripButton = new ToolStripButton();
-        toolStripSeparator7 = new ToolStripSeparator();
-        toolStripButton1 = new ToolStripButton();
-        toolStripButton2 = new ToolStripButton();
-        toolStripButton3 = new ToolStripButton();
-        toolStripButton4 = new ToolStripButton();
-        toolStripButton5 = new ToolStripButton();
-        toolStripButton6 = new ToolStripButton();
-        menuStrip1.SuspendLayout();
-        contextMenuStrip1.SuspendLayout();
-        statusStrip1.SuspendLayout();
-        toolStrip1.SuspendLayout();
-        SuspendLayout();
-        // 
-        // menuStrip1
-        // 
-        menuStrip1.ContextMenuStrip = contextMenuStrip1;
-        menuStrip1.ImageScalingSize = new Size(20, 20);
-        menuStrip1.Items.AddRange(new ToolStripItem[] { fileToolStripMenuItem, editToolStripMenuItem, toolsToolStripMenuItem, helpToolStripMenuItem, toolStripMenuItem1, toolStripComboBox1, toolStripTextBox1 });
-        menuStrip1.Location = new Point(0, 0);
-        menuStrip1.Name = "menuStrip1";
-        menuStrip1.Padding = new Padding(8, 3, 0, 3);
-        menuStrip1.ShowItemToolTips = true;
-        menuStrip1.Size = new Size(1287, 34);
-        menuStrip1.TabIndex = 0;
-        menuStrip1.TabStop = true;
-        menuStrip1.Text = "menuStrip1";
-        // 
-        // contextMenuStrip1
-        // 
-        contextMenuStrip1.ImageScalingSize = new Size(20, 20);
-        contextMenuStrip1.Items.AddRange(new ToolStripItem[] { menuStripToolStripMenuItem, shortCutsToolStripMenuItem });
-        contextMenuStrip1.Name = "contextMenuStrip1";
-        contextMenuStrip1.Size = new Size(147, 52);
-        contextMenuStrip1.TabStop = true;
-        // 
-        // menuStripToolStripMenuItem
-        // 
-        menuStripToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { item1ToolStripMenuItem });
-        menuStripToolStripMenuItem.Name = "menuStripToolStripMenuItem";
-        menuStripToolStripMenuItem.Size = new Size(146, 24);
-        menuStripToolStripMenuItem.Text = "MenuStrip";
-        // 
-        // item1ToolStripMenuItem
-        // 
-        item1ToolStripMenuItem.Name = "item1ToolStripMenuItem";
-        item1ToolStripMenuItem.Size = new Size(130, 26);
-        item1ToolStripMenuItem.Text = "Item1";
-        // 
-        // shortCutsToolStripMenuItem
-        // 
-        shortCutsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { item2ToolStripMenuItem });
-        shortCutsToolStripMenuItem.Name = "shortCutsToolStripMenuItem";
-        shortCutsToolStripMenuItem.Size = new Size(146, 24);
-        shortCutsToolStripMenuItem.Text = "ShortCuts";
-        // 
-        // item2ToolStripMenuItem
-        // 
-        item2ToolStripMenuItem.Name = "item2ToolStripMenuItem";
-        item2ToolStripMenuItem.Size = new Size(130, 26);
-        item2ToolStripMenuItem.Text = "Item2";
-        // 
-        // fileToolStripMenuItem
-        // 
-        fileToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newToolStripMenuItem, openToolStripMenuItem, toolStripSeparator, saveToolStripMenuItem, saveAsToolStripMenuItem, toolStripSeparator1, printToolStripMenuItem, printPreviewToolStripMenuItem, toolStripSeparator2, exitToolStripMenuItem });
-        fileToolStripMenuItem.Name = "fileToolStripMenuItem";
-        fileToolStripMenuItem.Size = new Size(46, 28);
-        fileToolStripMenuItem.Text = "&File";
-        fileToolStripMenuItem.ToolTipText = "File";
-        // 
-        // newToolStripMenuItem
-        // 
-        newToolStripMenuItem.Image = (Image)resources.GetObject("newToolStripMenuItem.Image");
-        newToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        newToolStripMenuItem.Name = "newToolStripMenuItem";
-        newToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.N;
-        newToolStripMenuItem.Size = new Size(181, 26);
-        newToolStripMenuItem.Text = "&New";
-        // 
-        // openToolStripMenuItem
-        // 
-        openToolStripMenuItem.Image = (Image)resources.GetObject("openToolStripMenuItem.Image");
-        openToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        openToolStripMenuItem.Name = "openToolStripMenuItem";
-        openToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.O;
-        openToolStripMenuItem.Size = new Size(181, 26);
-        openToolStripMenuItem.Text = "&Open";
-        // 
-        // toolStripSeparator
-        // 
-        toolStripSeparator.Name = "toolStripSeparator";
-        toolStripSeparator.Size = new Size(178, 6);
-        // 
-        // saveToolStripMenuItem
-        // 
-        saveToolStripMenuItem.Image = (Image)resources.GetObject("saveToolStripMenuItem.Image");
-        saveToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        saveToolStripMenuItem.Name = "saveToolStripMenuItem";
-        saveToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.S;
-        saveToolStripMenuItem.Size = new Size(181, 26);
-        saveToolStripMenuItem.Text = "&Save";
-        // 
-        // saveAsToolStripMenuItem
-        // 
-        saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem";
-        saveAsToolStripMenuItem.Size = new Size(181, 26);
-        saveAsToolStripMenuItem.Text = "Save &As";
-        // 
-        // toolStripSeparator1
-        // 
-        toolStripSeparator1.Name = "toolStripSeparator1";
-        toolStripSeparator1.Size = new Size(178, 6);
-        // 
-        // printToolStripMenuItem
-        // 
-        printToolStripMenuItem.Image = (Image)resources.GetObject("printToolStripMenuItem.Image");
-        printToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        printToolStripMenuItem.Name = "printToolStripMenuItem";
-        printToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.P;
-        printToolStripMenuItem.Size = new Size(181, 26);
-        printToolStripMenuItem.Text = "&Print";
-        // 
-        // printPreviewToolStripMenuItem
-        // 
-        printPreviewToolStripMenuItem.Image = (Image)resources.GetObject("printPreviewToolStripMenuItem.Image");
-        printPreviewToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        printPreviewToolStripMenuItem.Name = "printPreviewToolStripMenuItem";
-        printPreviewToolStripMenuItem.Size = new Size(181, 26);
-        printPreviewToolStripMenuItem.Text = "Print Pre&view";
-        // 
-        // toolStripSeparator2
-        // 
-        toolStripSeparator2.Name = "toolStripSeparator2";
-        toolStripSeparator2.Size = new Size(178, 6);
-        // 
-        // exitToolStripMenuItem
-        // 
-        exitToolStripMenuItem.Name = "exitToolStripMenuItem";
-        exitToolStripMenuItem.Size = new Size(181, 26);
-        exitToolStripMenuItem.Text = "E&xit";
-        // 
-        // editToolStripMenuItem
-        // 
-        editToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { undoToolStripMenuItem, redoToolStripMenuItem, toolStripSeparator3, cutToolStripMenuItem, copyToolStripMenuItem, pasteToolStripMenuItem, toolStripSeparator4, selectAllToolStripMenuItem });
-        editToolStripMenuItem.Name = "editToolStripMenuItem";
-        editToolStripMenuItem.Size = new Size(49, 28);
-        editToolStripMenuItem.Text = "&Edit";
-        editToolStripMenuItem.ToolTipText = "Edit";
-        // 
-        // undoToolStripMenuItem
-        // 
-        undoToolStripMenuItem.Name = "undoToolStripMenuItem";
-        undoToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.Z;
-        undoToolStripMenuItem.Size = new Size(179, 26);
-        undoToolStripMenuItem.Text = "&Undo";
-        // 
-        // redoToolStripMenuItem
-        // 
-        redoToolStripMenuItem.Name = "redoToolStripMenuItem";
-        redoToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.Y;
-        redoToolStripMenuItem.Size = new Size(179, 26);
-        redoToolStripMenuItem.Text = "&Redo";
-        // 
-        // toolStripSeparator3
-        // 
-        toolStripSeparator3.Name = "toolStripSeparator3";
-        toolStripSeparator3.Size = new Size(176, 6);
-        // 
-        // cutToolStripMenuItem
-        // 
-        cutToolStripMenuItem.Image = (Image)resources.GetObject("cutToolStripMenuItem.Image");
-        cutToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        cutToolStripMenuItem.Name = "cutToolStripMenuItem";
-        cutToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.X;
-        cutToolStripMenuItem.Size = new Size(179, 26);
-        cutToolStripMenuItem.Text = "Cu&t";
-        // 
-        // copyToolStripMenuItem
-        // 
-        copyToolStripMenuItem.Image = (Image)resources.GetObject("copyToolStripMenuItem.Image");
-        copyToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        copyToolStripMenuItem.Name = "copyToolStripMenuItem";
-        copyToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.C;
-        copyToolStripMenuItem.Size = new Size(179, 26);
-        copyToolStripMenuItem.Text = "&Copy";
-        // 
-        // pasteToolStripMenuItem
-        // 
-        pasteToolStripMenuItem.Image = (Image)resources.GetObject("pasteToolStripMenuItem.Image");
-        pasteToolStripMenuItem.ImageTransparentColor = Color.Magenta;
-        pasteToolStripMenuItem.Name = "pasteToolStripMenuItem";
-        pasteToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.V;
-        pasteToolStripMenuItem.Size = new Size(179, 26);
-        pasteToolStripMenuItem.Text = "&Paste";
-        // 
-        // toolStripSeparator4
-        // 
-        toolStripSeparator4.Name = "toolStripSeparator4";
-        toolStripSeparator4.Size = new Size(176, 6);
-        // 
-        // selectAllToolStripMenuItem
-        // 
-        selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem";
-        selectAllToolStripMenuItem.Size = new Size(179, 26);
-        selectAllToolStripMenuItem.Text = "Select &All";
-        // 
-        // toolsToolStripMenuItem
-        // 
-        toolsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { customizeToolStripMenuItem, optionsToolStripMenuItem });
-        toolsToolStripMenuItem.Name = "toolsToolStripMenuItem";
-        toolsToolStripMenuItem.Size = new Size(58, 28);
-        toolsToolStripMenuItem.Text = "&Tools";
-        toolsToolStripMenuItem.ToolTipText = "Tools";
-        // 
-        // customizeToolStripMenuItem
-        // 
-        customizeToolStripMenuItem.Name = "customizeToolStripMenuItem";
-        customizeToolStripMenuItem.Size = new Size(161, 26);
-        customizeToolStripMenuItem.Text = "&Customize";
-        // 
-        // optionsToolStripMenuItem
-        // 
-        optionsToolStripMenuItem.Name = "optionsToolStripMenuItem";
-        optionsToolStripMenuItem.Size = new Size(161, 26);
-        optionsToolStripMenuItem.Text = "&Options";
-        // 
-        // helpToolStripMenuItem
-        // 
-        helpToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { contentsToolStripMenuItem, indexToolStripMenuItem, searchToolStripMenuItem, toolStripSeparator5, aboutToolStripMenuItem });
-        helpToolStripMenuItem.Name = "helpToolStripMenuItem";
-        helpToolStripMenuItem.Size = new Size(55, 28);
-        helpToolStripMenuItem.Text = "&Help";
-        helpToolStripMenuItem.ToolTipText = "Help";
-        // 
-        // contentsToolStripMenuItem
-        // 
-        contentsToolStripMenuItem.Name = "contentsToolStripMenuItem";
-        contentsToolStripMenuItem.Size = new Size(150, 26);
-        contentsToolStripMenuItem.Text = "&Contents";
-        // 
-        // indexToolStripMenuItem
-        // 
-        indexToolStripMenuItem.Name = "indexToolStripMenuItem";
-        indexToolStripMenuItem.Size = new Size(150, 26);
-        indexToolStripMenuItem.Text = "&Index";
-        // 
-        // searchToolStripMenuItem
-        // 
-        searchToolStripMenuItem.Name = "searchToolStripMenuItem";
-        searchToolStripMenuItem.Size = new Size(150, 26);
-        searchToolStripMenuItem.Text = "&Search";
-        // 
-        // toolStripSeparator5
-        // 
-        toolStripSeparator5.Name = "toolStripSeparator5";
-        toolStripSeparator5.Size = new Size(147, 6);
-        // 
-        // aboutToolStripMenuItem
-        // 
-        aboutToolStripMenuItem.Name = "aboutToolStripMenuItem";
-        aboutToolStripMenuItem.Size = new Size(150, 26);
-        aboutToolStripMenuItem.Text = "&About...";
-        // 
-        // toolStripMenuItem1
-        // 
-        toolStripMenuItem1.DropDownItems.AddRange(new ToolStripItem[] { uncheckedCheckOnClickToolStripMenuItem, checkCheckOnClickToolStripMenuItem, checkedCheckOnClickFToolStripMenuItem, indeterminateToolStripMenuItem, indeterminateCheckOnClickFToolStripMenuItem });
-        toolStripMenuItem1.Name = "toolStripMenuItem1";
-        toolStripMenuItem1.Size = new Size(156, 28);
-        toolStripMenuItem1.Text = "CheckState Samples";
-        toolStripMenuItem1.ToolTipText = "CheckState Samples";
-        // 
-        // uncheckedCheckOnClickToolStripMenuItem
-        // 
-        uncheckedCheckOnClickToolStripMenuItem.CheckOnClick = true;
-        uncheckedCheckOnClickToolStripMenuItem.Name = "uncheckedCheckOnClickToolStripMenuItem";
-        uncheckedCheckOnClickToolStripMenuItem.Size = new Size(298, 26);
-        uncheckedCheckOnClickToolStripMenuItem.Text = "Unchecked_CheckOnClick(T)";
-        // 
-        // checkCheckOnClickToolStripMenuItem
-        // 
-        checkCheckOnClickToolStripMenuItem.Checked = true;
-        checkCheckOnClickToolStripMenuItem.CheckOnClick = true;
-        checkCheckOnClickToolStripMenuItem.CheckState = CheckState.Checked;
-        checkCheckOnClickToolStripMenuItem.Name = "checkCheckOnClickToolStripMenuItem";
-        checkCheckOnClickToolStripMenuItem.Size = new Size(298, 26);
-        checkCheckOnClickToolStripMenuItem.Text = "Checked_CheckOnClick(T)";
-        // 
-        // checkedCheckOnClickFToolStripMenuItem
-        // 
-        checkedCheckOnClickFToolStripMenuItem.Checked = true;
-        checkedCheckOnClickFToolStripMenuItem.CheckState = CheckState.Checked;
-        checkedCheckOnClickFToolStripMenuItem.Name = "checkedCheckOnClickFToolStripMenuItem";
-        checkedCheckOnClickFToolStripMenuItem.Size = new Size(298, 26);
-        checkedCheckOnClickFToolStripMenuItem.Text = "Checked_CheckOnClick(F)";
-        // 
-        // indeterminateToolStripMenuItem
-        // 
-        indeterminateToolStripMenuItem.Checked = true;
-        indeterminateToolStripMenuItem.CheckOnClick = true;
-        indeterminateToolStripMenuItem.CheckState = CheckState.Indeterminate;
-        indeterminateToolStripMenuItem.Name = "indeterminateToolStripMenuItem";
-        indeterminateToolStripMenuItem.Size = new Size(298, 26);
-        indeterminateToolStripMenuItem.Text = "Indeterminate_CheckOnClick(T)";
-        // 
-        // indeterminateCheckOnClickFToolStripMenuItem
-        // 
-        indeterminateCheckOnClickFToolStripMenuItem.Checked = true;
-        indeterminateCheckOnClickFToolStripMenuItem.CheckState = CheckState.Indeterminate;
-        indeterminateCheckOnClickFToolStripMenuItem.Name = "indeterminateCheckOnClickFToolStripMenuItem";
-        indeterminateCheckOnClickFToolStripMenuItem.Size = new Size(298, 26);
-        indeterminateCheckOnClickFToolStripMenuItem.Text = "Indeterminate_CheckOnClick(F)";
-        // 
-        // toolStripComboBox1
-        // 
-        toolStripComboBox1.AccessibleName = "toolStripCombo_Box";
-        toolStripComboBox1.Name = "toolStripComboBox1";
-        toolStripComboBox1.Size = new Size(159, 28);
-        toolStripComboBox1.ToolTipText = "toolStripComboBox1";
-        // 
-        // toolStripTextBox1
-        // 
-        toolStripTextBox1.AccessibleName = "toolStripText_Box1";
-        toolStripTextBox1.Name = "toolStripTextBox1";
-        toolStripTextBox1.Size = new Size(132, 28);
-        toolStripTextBox1.Text = "toolStripTextBox1";
-        // 
-        // statusStrip1
-        // 
-        statusStrip1.ImageScalingSize = new Size(20, 20);
-        statusStrip1.Items.AddRange(new ToolStripItem[] { toolStripDropDownButton1, toolStripSplitButton1, toolStripStatusLabel1, toolStripProgressBar1 });
-        statusStrip1.Location = new Point(0, 520);
-        statusStrip1.Name = "statusStrip1";
-        statusStrip1.Padding = new Padding(1, 0, 18, 0);
-        statusStrip1.ShowItemToolTips = true;
-        statusStrip1.Size = new Size(1287, 29);
-        statusStrip1.TabIndex = 2;
-        statusStrip1.TabStop = true;
-        statusStrip1.Text = "statusStrip1";
-        // 
-        // toolStripDropDownButton1
-        // 
-        toolStripDropDownButton1.DisplayStyle = ToolStripItemDisplayStyle.Image;
-        toolStripDropDownButton1.DropDownItems.AddRange(new ToolStripItem[] { toolStripSeparator9, toolStripTextBox3, toolStripMenuItem3 });
-        toolStripDropDownButton1.Image = (Image)resources.GetObject("toolStripDropDownButton1.Image");
-        toolStripDropDownButton1.ImageTransparentColor = Color.Magenta;
-        toolStripDropDownButton1.Name = "toolStripDropDownButton1";
-        toolStripDropDownButton1.Size = new Size(34, 27);
-        toolStripDropDownButton1.Text = "toolStripDropDownButton1";
-        // 
-        // toolStripSeparator9
-        // 
-        toolStripSeparator9.Name = "toolStripSeparator9";
-        toolStripSeparator9.Size = new Size(222, 6);
-        // 
-        // toolStripTextBox3
-        // 
-        toolStripTextBox3.Name = "toolStripTextBox3";
-        toolStripTextBox3.Size = new Size(100, 27);
-        // 
-        // toolStripMenuItem3
-        // 
-        toolStripMenuItem3.Name = "toolStripMenuItem3";
-        toolStripMenuItem3.Size = new Size(225, 26);
-        toolStripMenuItem3.Text = "toolStripMenuItem3";
-        // 
-        // toolStripSplitButton1
-        // 
-        toolStripSplitButton1.DisplayStyle = ToolStripItemDisplayStyle.Image;
-        toolStripSplitButton1.DropDownItems.AddRange(new ToolStripItem[] { toolStripTextBox2, toolStripSeparator8, toolStripComboBox2, toolStripMenuItem2 });
-        toolStripSplitButton1.Image = (Image)resources.GetObject("toolStripSplitButton1.Image");
-        toolStripSplitButton1.ImageTransparentColor = Color.Magenta;
-        toolStripSplitButton1.Name = "toolStripSplitButton1";
-        toolStripSplitButton1.Size = new Size(39, 27);
-        toolStripSplitButton1.Text = "toolStripSplitButton1";
-        // 
-        // toolStripTextBox2
-        // 
-        toolStripTextBox2.Name = "toolStripTextBox2";
-        toolStripTextBox2.Size = new Size(100, 27);
-        // 
-        // toolStripSeparator8
-        // 
-        toolStripSeparator8.Name = "toolStripSeparator8";
-        toolStripSeparator8.Size = new Size(222, 6);
-        // 
-        // toolStripComboBox2
-        // 
-        toolStripComboBox2.Name = "toolStripComboBox2";
-        toolStripComboBox2.Size = new Size(121, 28);
-        // 
-        // toolStripMenuItem2
-        // 
-        toolStripMenuItem2.Name = "toolStripMenuItem2";
-        toolStripMenuItem2.Size = new Size(225, 26);
-        toolStripMenuItem2.Text = "toolStripMenuItem2";
-        // 
-        // toolStripStatusLabel1
-        // 
-        toolStripStatusLabel1.Name = "toolStripStatusLabel1";
-        toolStripStatusLabel1.Size = new Size(151, 23);
-        toolStripStatusLabel1.Text = "toolStripStatusLabel1";
-        toolStripStatusLabel1.ToolTipText = "toolStripStatusLabel1";
-        // 
-        // toolStripProgressBar1
-        // 
-        toolStripProgressBar1.AccessibleName = "Progress_Bar";
-        toolStripProgressBar1.Name = "toolStripProgressBar1";
-        toolStripProgressBar1.Size = new Size(134, 21);
-        // 
-        // toolStrip1
-        // 
-        toolStrip1.ImageScalingSize = new Size(20, 20);
-        toolStrip1.Items.AddRange(new ToolStripItem[] { newToolStripButton, toolStripSeparator7, toolStripButton1, toolStripButton2, toolStripButton3, toolStripButton4, toolStripButton5, toolStripButton6 });
-        toolStrip1.Location = new Point(0, 34);
-        toolStrip1.Name = "toolStrip1";
-        toolStrip1.Size = new Size(1287, 31);
-        toolStrip1.TabIndex = 1;
-        toolStrip1.TabStop = true;
-        toolStrip1.Text = "toolStrip1";
-        // 
-        // newToolStripButton
-        // 
-        newToolStripButton.Image = (Image)resources.GetObject("newToolStripButton.Image");
-        newToolStripButton.ImageTransparentColor = Color.Magenta;
-        newToolStripButton.Name = "newToolStripButton";
-        newToolStripButton.Size = new Size(63, 28);
-        newToolStripButton.Text = "&New";
-        // 
-        // toolStripSeparator7
-        // 
-        toolStripSeparator7.Name = "toolStripSeparator7";
-        toolStripSeparator7.Size = new Size(6, 31);
-        // 
-        // toolStripButton1
-        // 
-        toolStripButton1.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton1.Image = (Image)resources.GetObject("toolStripButton1.Image");
-        toolStripButton1.ImageTransparentColor = Color.Magenta;
-        toolStripButton1.Name = "toolStripButton1";
-        toolStripButton1.Size = new Size(197, 28);
-        toolStripButton1.Text = "Unchecked_CheckOnClick(F)";
-        // 
-        // toolStripButton2
-        // 
-        toolStripButton2.CheckOnClick = true;
-        toolStripButton2.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton2.Image = (Image)resources.GetObject("toolStripButton2.Image");
-        toolStripButton2.ImageTransparentColor = Color.Magenta;
-        toolStripButton2.Name = "toolStripButton2";
-        toolStripButton2.Size = new Size(198, 28);
-        toolStripButton2.Text = "Unchecked_CheckOnClick(T)";
-        // 
-        // toolStripButton3
-        // 
-        toolStripButton3.Checked = true;
-        toolStripButton3.CheckOnClick = true;
-        toolStripButton3.CheckState = CheckState.Checked;
-        toolStripButton3.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton3.Image = (Image)resources.GetObject("toolStripButton3.Image");
-        toolStripButton3.ImageTransparentColor = Color.Magenta;
-        toolStripButton3.Name = "toolStripButton3";
-        toolStripButton3.Size = new Size(182, 28);
-        toolStripButton3.Text = "Checked_CheckOnClick(T)";
-        // 
-        // toolStripButton4
-        // 
-        toolStripButton4.Checked = true;
-        toolStripButton4.CheckState = CheckState.Checked;
-        toolStripButton4.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton4.Image = (Image)resources.GetObject("toolStripButton4.Image");
-        toolStripButton4.ImageTransparentColor = Color.Magenta;
-        toolStripButton4.Name = "toolStripButton4";
-        toolStripButton4.Size = new Size(181, 28);
-        toolStripButton4.Text = "Checked_CheckOnClick(F)";
-        // 
-        // toolStripButton5
-        // 
-        toolStripButton5.Checked = true;
-        toolStripButton5.CheckOnClick = true;
-        toolStripButton5.CheckState = CheckState.Indeterminate;
-        toolStripButton5.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton5.Image = (Image)resources.GetObject("toolStripButton5.Image");
-        toolStripButton5.ImageTransparentColor = Color.Magenta;
-        toolStripButton5.Name = "toolStripButton5";
-        toolStripButton5.Size = new Size(219, 28);
-        toolStripButton5.Text = "Indeterminate_CheckOnClick(T)";
-        // 
-        // toolStripButton6
-        // 
-        toolStripButton6.Checked = true;
-        toolStripButton6.CheckState = CheckState.Indeterminate;
-        toolStripButton6.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        toolStripButton6.Image = (Image)resources.GetObject("toolStripButton6.Image");
-        toolStripButton6.ImageTransparentColor = Color.Magenta;
-        toolStripButton6.Name = "toolStripButton6";
-        toolStripButton6.Size = new Size(218, 24);
-        toolStripButton6.Text = "Indeterminate_CheckOnClick(F)";
-        // 
-        // Menu_Toolbars_controls
-        // 
-        AutoScaleDimensions = new SizeF(8F, 20F);
-        AutoScaleMode = AutoScaleMode.Font;
-        ClientSize = new Size(1287, 549);
-        Controls.Add(toolStrip1);
-        Controls.Add(statusStrip1);
-        Controls.Add(menuStrip1);
-        MainMenuStrip = menuStrip1;
-        Margin = new Padding(5, 4, 5, 4);
-        Name = "Menu_Toolbars_controls";
-        Text = "StripControls";
-        menuStrip1.ResumeLayout(false);
-        menuStrip1.PerformLayout();
-        contextMenuStrip1.ResumeLayout(false);
-        statusStrip1.ResumeLayout(false);
-        statusStrip1.PerformLayout();
-        toolStrip1.ResumeLayout(false);
-        toolStrip1.PerformLayout();
-        ResumeLayout(false);
-        PerformLayout();
-    }
-
-#endregion
-
-    private MenuStrip menuStrip1;
-    private ContextMenuStrip contextMenuStrip1;
-    private ToolStripMenuItem fileToolStripMenuItem;
-    private ToolStripMenuItem newToolStripMenuItem;
-    private ToolStripMenuItem openToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator;
-    private ToolStripMenuItem saveToolStripMenuItem;
-    private ToolStripMenuItem saveAsToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator1;
-    private ToolStripMenuItem printToolStripMenuItem;
-    private ToolStripMenuItem printPreviewToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator2;
-    private ToolStripMenuItem exitToolStripMenuItem;
-    private ToolStripMenuItem editToolStripMenuItem;
-    private ToolStripMenuItem undoToolStripMenuItem;
-    private ToolStripMenuItem redoToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator3;
-    private ToolStripMenuItem cutToolStripMenuItem;
-    private ToolStripMenuItem copyToolStripMenuItem;
-    private ToolStripMenuItem pasteToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator4;
-    private ToolStripMenuItem selectAllToolStripMenuItem;
-    private ToolStripMenuItem toolsToolStripMenuItem;
-    private ToolStripMenuItem customizeToolStripMenuItem;
-    private ToolStripMenuItem optionsToolStripMenuItem;
-    private ToolStripMenuItem helpToolStripMenuItem;
-    private ToolStripMenuItem contentsToolStripMenuItem;
-    private ToolStripMenuItem indexToolStripMenuItem;
-    private ToolStripMenuItem searchToolStripMenuItem;
-    private ToolStripSeparator toolStripSeparator5;
-    private ToolStripMenuItem aboutToolStripMenuItem;
-    private StatusStrip statusStrip1;
-    private ToolStripStatusLabel toolStripStatusLabel1;
-    private ToolStripDropDownButton toolStripDropDownButton1;
-    private ToolStripSplitButton toolStripSplitButton1;
-    private ToolStrip toolStrip1;
-    private ToolStripButton newToolStripButton;
-    private ToolStripSeparator toolStripSeparator7;
-    private ToolStripMenuItem menuStripToolStripMenuItem;
-    private ToolStripMenuItem shortCutsToolStripMenuItem;
-    private ToolStripMenuItem toolStripMenuItem1;
-    private ToolStripComboBox toolStripComboBox1;
-    private ToolStripMenuItem item1ToolStripMenuItem;
-    private ToolStripMenuItem item2ToolStripMenuItem;
-    private ToolStripTextBox toolStripTextBox1;
-    private ToolStripSeparator toolStripSeparator9;
-    private ToolStripTextBox toolStripTextBox3;
-    private ToolStripMenuItem toolStripMenuItem3;
-    private ToolStripTextBox toolStripTextBox2;
-    private ToolStripSeparator toolStripSeparator8;
-    private ToolStripComboBox toolStripComboBox2;
-    private ToolStripMenuItem toolStripMenuItem2;
-    private ToolStripProgressBar toolStripProgressBar1;
-    private ToolStripMenuItem uncheckedCheckOnClickToolStripMenuItem;
-    private ToolStripMenuItem checkCheckOnClickToolStripMenuItem;
-    private ToolStripMenuItem checkedCheckOnClickFToolStripMenuItem;
-    private ToolStripMenuItem indeterminateToolStripMenuItem;
-    private ToolStripMenuItem indeterminateCheckOnClickFToolStripMenuItem;
-    private ToolStripButton toolStripButton1;
-    private ToolStripButton toolStripButton2;
-    private ToolStripButton toolStripButton3;
-    private ToolStripButton toolStripButton4;
-    private ToolStripButton toolStripButton5;
-    private ToolStripButton toolStripButton6;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.cs
deleted file mode 100644
index 51543c0cfb0..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class Menu_Toolbars_controls : Form
-{
-    public Menu_Toolbars_controls()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.resx
deleted file mode 100644
index 57a6bde133b..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Menu_Toolbars_controls.resx
+++ /dev/null
@@ -1,324 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Drawing.Common" name="System.Drawing.Common, Version=5.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51" />
-  <data name="newToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAERSURBVDhPrZDbSgJRGIXnpewd6jXsjSQvIrwoI0RQMChU
-        0iiDPCGiE3ZCRkvR8VzTeBhnyR5/ccaZNnPhB4t9sdf6Ln5hb8QeathNJFVFKF5C8DqL4ksDVHWGDf7j
-        LHyPg6NjviSaFqlu5yQYR+KpupaIkrMknCxT3Y7v/NYYb0ITK1c3BarbWWhLQ7IR0cTKReyZ6lZ0XYei
-        ztHpK4bAc+h1FgQijzSxMptrGIxVSO0xX3AaStFki7bUMVFmaMm/eJMGfIH/MkGzLep0AXn4h/r3CJV3
-        mS9gn2bY4UY/UzQ7E9TqfeTFtnuB+XAfzSHKr11kSl/uBebDiZ89ZCst3OUkdwL28sIVsE83ock+EIQV
-        2Mz2wxeg6/UAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="openToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJHSURBVDhPxZBdSNNhFMb/F110ZZEVhVBgeeHNICiiuggp
-        olAUyyxI0oSaH1QYC3N+tKnp5ubm1JUua5uuqdNKMwr7kApFItTUkWZqVhSVYmao5Nevvy7UoYR3HXh4
-        4XCe33nOKyy3lAY7l9RWMo0O/raWXxEyo5spVYTNvOGyfIRPfW+ptOkXqaPl6T83hcRmExSdgzAz3NVm
-        YWyoYla/B+1M9JtxWLPpaH22JORIjI6gKAMB0jyEimIdo4OlbuaprwVMOOMovammpDADc34qppwUrmnl
-        5Kni3aFlFg2j3y1z5mnRTJccnNIltQhwq0jFry+mOXNtpWZWDx1Z1NhV3C3JwGFOw25SYjVe5oYhiUKd
-        HKMmwQUrMWUw/CF3NnZvvYKqUh1TvUroS3fXe7HXkwidMngTS2t5KLbregSzMY2f3Wr4qKW6LJvGR1rX
-        0MLor8OhKYTJBn/GHvvxrliCTBrsOqXIoOBHh5K+hmSq7FqmexTQHuUytkaKxuNMNgYyVneA4Qd7GKjc
-        hjLaRzxH7gIU6JIZaEvgtk1D8wsxSWecCDgNzWFMvwxm/PkhRmr3Mli1nW9lvjRdWc0Jf+/5jzRmyWmv
-        S+GOLQu6U6BFjPvqKOP1AYw88WOoZif9DgmfLVtxaj1RSLdwNvrkPCA3M54KqxrnvRia9MKcGrUrqFOt
-        5H7qKsqT1mGO9+Lqhc2ELdw+U/r0i+gVZ8hMiCDx3DHORwZyKnQ/hw/uYt9uCTskPvh6e7Fp41rWr/Fg
-        g6eHO+A/lyD8ARfG3mk9fv1YAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="saveToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIySURBVDhPrZLfS5NRGMfff6H7boIuuq2pMZyL1eAt11CW
-        DcOKsB9vpFmaLtNExco0av6CbIVLJ61Wk3BSkT/AFCkRZSpZmrmiJQ41xSaCwdfznL15XEUX0Reem5f3
-        8znnec4j/Zc8fxYGla91CS3eRTx0z6OpMYS7jmnU1X6B/VYA18snUVoyjsKCt8jLHcH5c36ouCQR2NUJ
-        1Nas4G9ZXlmFKbULh1Kf8lJxSfI+WeCCyopv6q+/h+DQ/DJ2WV5Ao1FgPegRAveDOS4oLfmq/h6dn/DH
-        4AJizD4UXJrCAUuzEDgbZrjgou2DiohshIcnQtgme5GTPYbkJKcQ1N8OckHW2REVi+RXuM8fxGaDG4oy
-        ALPZIQQ11Z+5QDk1oKJ/hjv7P2FTfCMOH3mFxMQ6IbhROYWOdrCnBI4dfwPr0V4+bRoY9UzXppMjcDdS
-        rC8hy3YhuFI2gTYf2A4Aza4f7N2/o/zaLB8qDYx6zszwr8P7k1thNFYIweXCMXgeAfedq2xxwjClZUeV
-        Jd2GtDNFETiJwfs8MBjKhMCWN8pgoLoqzE8miH1GjE7G4PsZjE7OQsm9ij2mFg7rdrug1xcJAa2l4w7W
-        r00Cgk/n38S7wBwC04u4UGxHrMHF4CbEJtyDLj5fCDIzhljfSxzeavRgyw4Zj9t64GvvQ0d3P3pfD2Kv
-        2QqNvgFxDN6urYdWmyMElJMnevh60obRktA701PRtGlg1DOdSkXwzrisaMG/RZLWAE60OMW5fNhvAAAA
-        AElFTkSuQmCC
-</value>
-  </data>
-  <data name="printToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIpSURBVDhPtZL/T1JRGMb5p1itrVZbbRpqZbawnBENV1I0
-        jGlByTSyJTXJwq2oKZQb1KAv6JCYWSxvBrkkZUq4CeQEiRABFeLL072Xa0zRra31bO8v57zP5znnPYf1
-        X+TxhWF6O7VtGYcnwbSWijKPOLzYrPSvLPwLS3huGUMlT7o9wGD9grVUBj+icdid03S9tDmgNxNwTgVQ
-        J+rA8XNtWwM+uuZATMwxmQVRycuJFNyzIRitDlScugKzjSgFRGJJaIwEsrk8AsHIhnSL/Ssck37UNipQ
-        I5DjtuYV7uksRYhr2kebhx2eP6nrycFIEh5fBA/1Nvru8q5+PDaOovK0rABwfwugWzcErfkzHhjsePL6
-        E7q1VrTdNUDcrgGvSYlDZHN5XTNOnL8BVe8AJAoNDtZfLgDu9L1BPJmikzcrk81hlRwodZJwdBXziwnI
-        OrVoaOkiT8C8hKLHBPO7CbywOaE1jeC+bhAd6meQdvZC1KoG/5IS3MZ2HObLUHZSggvkWq3wOvbWiAqA
-        VpWeyStVfCUNf3AZ4zNhfHCFMEDMgye+hYr6FrDLzxQAUuVTpr0ocn74mchg5vsKRt1RcHp2Qv9+kZ78
-        UcE17KkWFgHNN/uQzgBkGKLJPBZiecyGchjzrmFwPIF++xJUbDbUQzEacIArLpopSRSP4CUN1Obf1Abz
-        uqob5KjiXwWH/GVl5HPt5zZh37GL2H1EiF1VZ7GDI6CNW5r/TSzWbwHYL0mKJ5czAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="printPreviewToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGCSURBVDhPnZK9S0JRGMb9F1xb2gqaq6mhwCGDtvYIIyLI
-        cJOE1paoIYpMKUjFRDH87lpoakGlIZF9DA2hZJEQhJXl1xPn3HPV29WQfvBwOfA+P95zuDJ39A6/4wyl
-        YOOSMHvOcHGThuwvSKEVRvsR+pQqWD3R1pK98DUbl7Jm5hA8SfESd6S5xH5wycalrO4E0D8yWQuriLH6
-        E2xcSqlcoRJBxCpiTO5TNi4m/ZgDF4nDsOulsfujyGRzUsmWM8YqdcggKbveS3A88bEkslRye58RSzZt
-        IVarY/FFaPmlwp+fUaESYRNW5Vm3BPmpBpZNvppACDmTLbS6FbGAPFAj5OGI4PALOK/yZfIlAlk4j7n5
-        xdaCarWKj0KRXmE2+UklJEJZZ/RCPTPdWvBdLOP1rYD41QNcgRiVkKJQ1mjGsa2VNxeQb2OWDC7sh47p
-        ddQLeoyOTSFiVAAFvVhChsmv2k6Uvd3Icx1UolMNiDdpl4nhLiohW/xb0tMph2JwCJxjAz9A30JI8zYA
-        tAAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="cutToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGDSURBVDhPrZFNSwJRGIX9NYGbFoUlFElY1EJQKEYhCJsi
-        LaVsERnRF5iCaSZJO1toCDVGFkgoFpWQWWRR2aIvUxm1BKN1wSnHCFw4TOCzue+9nPNw4eVVnav4Izzb
-        QfxeGZ5TWaxT/rK3irzmC7CsusvC1G4IkbNLboIiDieF4GGUKeTeClDpppF8eeEu2PIfwfrzizSdw3Hk
-        EnKlFpkMzV2wH77AosOFTV8A+vkl9CiHuJeLJNNZjM8tYWB0FkTvMAwmy/8ERTR6CwjlGAi1Ccence6C
-        1NsXzN4PKIxJLLgeIJ2MoXvmFraNBKK3eXZRIveJPvs7FIYniEkXZENOdE+GIZ2Ko10TwLK7tJmKmL0F
-        EEYarYM+NMnt0C1sQzpx/lcSEnZ2gcKY/gs0dlmZuWvmjjmpwA1qxVp2AWFIMAF/OAGBzMjMI7ZrtJCb
-        4Df3o4Zfxy7QrdxDRFKol5khkpR2H4qmIOzUQNBGwrsXYxccnNOQqNbQ0KGGZ+eEPVwdeLxvqqrf4wGh
-        TNAAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="copyToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHkSURBVDhPvZHfS1NhHIf3p5QypLr2D4goMwoMCi/qIugH
-        Xe1Cr7qKDIMkZixwNhfWLGWbnuki0kXKzLU023KubBNPJrbRdOzocm6e2dPOO21mMS+CHvjcvOf9PF++
-        79H9M+7RT2iRRsIi9sEAXe43yAvf2LpSHq28G9uAnytNT4jMLewtcQ2Ht2pF8ps/aOt+gccX5lxD694S
-        +1BQFD1RkN5DSFa4Z3uONKbgHE3h8KZ4OJTC1J8UiSzmfhd2uf1CoJHbyKOsZokl0kKwm+aeJaov+wjO
-        rpQkVqdXfOz0bWAcVLghfaXxkUz3y2VxvpMGSwL3uMKh+gHezSSLEnNhX23vtYzKUirDfGyFj/Iy1mdx
-        UWqR8iKhwtQLxjgH659y4EwvVXWPiwJt3/Ws+muywRrlqvkDdx3zQrCN8l1ldnEd3/QqFmkS/akHJYGS
-        zjLzOUEwEsMf+sLI2zmaOou/93pPGoM5zvk7UU7fnBKxSBPoT7SXBNW1F/9Io2lKCNTCeomUyrS8xnBA
-        wfUqyf1eP5U1ptJD/o1LzeNCsHPydtqdr6k4aiwvOHvNSya3ibU/QIdrEkvfhJislc32MfYfuV1eUGPw
-        FF7bIVJVZ0N/soPK421UHGstlFvYd/hWecF/Qqf7CR0A5wwgSQA2AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="pasteToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJSSURBVDhPtZJrSJNRGMdf6IN9KbpQn/pUEH2JIoLqQ0Zh
-        FqYZRmJG1iKmUqKyLB2pqSm6vC1Nm5GXoeatEsVJ0RASR3eNzegikRq5lrV3857Fr/d9ddlICoL+8OfA
-        Oef/e57zcIT/os7WLMw302muSGJ2689qqi7A44q8IzjtNYzarzHQm8tZtT8FmRqu6LToMxN+B8qhCbGR
-        KVcDE85ajKUaxoaryEuL4UVXIudPB5Ko2oy98xjDptXERuz3hsgAOTzlqqMk6yjdllzE90UM9Wp5azlB
-        S1kwkeG+1CSv4mmBQPThfd6Ahqq8GYB4A11yBKmaMLQxoZyLDkGjDiZOFUhUuB+FsWsUQFiArzegtlzH
-        pFjPpMPA2GA2jucx2KqWK7ZWLqO7dBGP9D5KWLbfto3eAKMhi3FHBeP9GYy9PMXos4OIrYvJrzSRbWjm
-        wuV6EnVG4tLLiEzSExGf4w0oL05nZEDPaK+akceBuO9v4uPtFUrYo6npbzhdE/QPOQmNSiPouHYOUpaf
-        gvgqA/dDf9wd63G1r2SgUlAqyyq/1anYUGfG2mdXwne7bOwJUc1AinOS+NxzBpd5HWLbUhyNPvRdF5S2
-        v05/54tbqvzBifWNHUvPOwLC4/CXwrv2HsB3+w6EwosJOB5ESeElfGpayGD1AmwlArHSm+W2PR1clToo
-        MrbT0mFTVtlbN6xFuJQar3wQz5Q9VksD+7XyPctrJdx4p5s605M5gKz8lJPSDwtGFbKboJ1blAN52vKb
-        PdXm80/AfDokTVu+8DfPXv9XCcIPTvjvLQ8YoakAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="toolStripDropDownButton1.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripSplitButton1.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="newToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAERSURBVDhPrZDbSgJRGIXnpewd6jXsjSQvIrwoI0RQMChU
-        0iiDPCGiE3ZCRkvR8VzTeBhnyR5/ccaZNnPhB4t9sdf6Ln5hb8QeathNJFVFKF5C8DqL4ksDVHWGDf7j
-        LHyPg6NjviSaFqlu5yQYR+KpupaIkrMknCxT3Y7v/NYYb0ITK1c3BarbWWhLQ7IR0cTKReyZ6lZ0XYei
-        ztHpK4bAc+h1FgQijzSxMptrGIxVSO0xX3AaStFki7bUMVFmaMm/eJMGfIH/MkGzLep0AXn4h/r3CJV3
-        mS9gn2bY4UY/UzQ7E9TqfeTFtnuB+XAfzSHKr11kSl/uBebDiZ89ZCst3OUkdwL28sIVsE83ock+EIQV
-        2Mz2wxeg6/UAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="openToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJHSURBVDhPxZBdSNNhFMb/F110ZZEVhVBgeeHNICiiuggp
-        olAUyyxI0oSaH1QYC3N+tKnp5ubm1JUua5uuqdNKMwr7kApFItTUkWZqVhSVYmao5Nevvy7UoYR3HXh4
-        4XCe33nOKyy3lAY7l9RWMo0O/raWXxEyo5spVYTNvOGyfIRPfW+ptOkXqaPl6T83hcRmExSdgzAz3NVm
-        YWyoYla/B+1M9JtxWLPpaH22JORIjI6gKAMB0jyEimIdo4OlbuaprwVMOOMovammpDADc34qppwUrmnl
-        5Kni3aFlFg2j3y1z5mnRTJccnNIltQhwq0jFry+mOXNtpWZWDx1Z1NhV3C3JwGFOw25SYjVe5oYhiUKd
-        HKMmwQUrMWUw/CF3NnZvvYKqUh1TvUroS3fXe7HXkwidMngTS2t5KLbregSzMY2f3Wr4qKW6LJvGR1rX
-        0MLor8OhKYTJBn/GHvvxrliCTBrsOqXIoOBHh5K+hmSq7FqmexTQHuUytkaKxuNMNgYyVneA4Qd7GKjc
-        hjLaRzxH7gIU6JIZaEvgtk1D8wsxSWecCDgNzWFMvwxm/PkhRmr3Mli1nW9lvjRdWc0Jf+/5jzRmyWmv
-        S+GOLQu6U6BFjPvqKOP1AYw88WOoZif9DgmfLVtxaj1RSLdwNvrkPCA3M54KqxrnvRia9MKcGrUrqFOt
-        5H7qKsqT1mGO9+Lqhc2ELdw+U/r0i+gVZ8hMiCDx3DHORwZyKnQ/hw/uYt9uCTskPvh6e7Fp41rWr/Fg
-        g6eHO+A/lyD8ARfG3mk9fv1YAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="saveToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIySURBVDhPrZLfS5NRGMfff6H7boIuuq2pMZyL1eAt11CW
-        DcOKsB9vpFmaLtNExco0av6CbIVLJ61Wk3BSkT/AFCkRZSpZmrmiJQ41xSaCwdfznL15XEUX0Reem5f3
-        8znnec4j/Zc8fxYGla91CS3eRTx0z6OpMYS7jmnU1X6B/VYA18snUVoyjsKCt8jLHcH5c36ouCQR2NUJ
-        1Nas4G9ZXlmFKbULh1Kf8lJxSfI+WeCCyopv6q+/h+DQ/DJ2WV5Ao1FgPegRAveDOS4oLfmq/h6dn/DH
-        4AJizD4UXJrCAUuzEDgbZrjgou2DiohshIcnQtgme5GTPYbkJKcQ1N8OckHW2REVi+RXuM8fxGaDG4oy
-        ALPZIQQ11Z+5QDk1oKJ/hjv7P2FTfCMOH3mFxMQ6IbhROYWOdrCnBI4dfwPr0V4+bRoY9UzXppMjcDdS
-        rC8hy3YhuFI2gTYf2A4Aza4f7N2/o/zaLB8qDYx6zszwr8P7k1thNFYIweXCMXgeAfedq2xxwjClZUeV
-        Jd2GtDNFETiJwfs8MBjKhMCWN8pgoLoqzE8miH1GjE7G4PsZjE7OQsm9ij2mFg7rdrug1xcJAa2l4w7W
-        r00Cgk/n38S7wBwC04u4UGxHrMHF4CbEJtyDLj5fCDIzhljfSxzeavRgyw4Zj9t64GvvQ0d3P3pfD2Kv
-        2QqNvgFxDN6urYdWmyMElJMnevh60obRktA701PRtGlg1DOdSkXwzrisaMG/RZLWAE60OMW5fNhvAAAA
-        AElFTkSuQmCC
-</value>
-  </data>
-  <data name="printToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIpSURBVDhPtZL/T1JRGMb5p1itrVZbbRpqZbawnBENV1I0
-        jGlByTSyJTXJwq2oKZQb1KAv6JCYWSxvBrkkZUq4CeQEiRABFeLL072Xa0zRra31bO8v57zP5znnPYf1
-        X+TxhWF6O7VtGYcnwbSWijKPOLzYrPSvLPwLS3huGUMlT7o9wGD9grVUBj+icdid03S9tDmgNxNwTgVQ
-        J+rA8XNtWwM+uuZATMwxmQVRycuJFNyzIRitDlScugKzjSgFRGJJaIwEsrk8AsHIhnSL/Ssck37UNipQ
-        I5DjtuYV7uksRYhr2kebhx2eP6nrycFIEh5fBA/1Nvru8q5+PDaOovK0rABwfwugWzcErfkzHhjsePL6
-        E7q1VrTdNUDcrgGvSYlDZHN5XTNOnL8BVe8AJAoNDtZfLgDu9L1BPJmikzcrk81hlRwodZJwdBXziwnI
-        OrVoaOkiT8C8hKLHBPO7CbywOaE1jeC+bhAd6meQdvZC1KoG/5IS3MZ2HObLUHZSggvkWq3wOvbWiAqA
-        VpWeyStVfCUNf3AZ4zNhfHCFMEDMgye+hYr6FrDLzxQAUuVTpr0ocn74mchg5vsKRt1RcHp2Qv9+kZ78
-        UcE17KkWFgHNN/uQzgBkGKLJPBZiecyGchjzrmFwPIF++xJUbDbUQzEacIArLpopSRSP4CUN1Obf1Abz
-        uqob5KjiXwWH/GVl5HPt5zZh37GL2H1EiF1VZ7GDI6CNW5r/TSzWbwHYL0mKJ5czAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="cutToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGDSURBVDhPrZFNSwJRGIX9NYGbFoUlFElY1EJQKEYhCJsi
-        LaVsERnRF5iCaSZJO1toCDVGFkgoFpWQWWRR2aIvUxm1BKN1wSnHCFw4TOCzue+9nPNw4eVVnav4Izzb
-        QfxeGZ5TWaxT/rK3irzmC7CsusvC1G4IkbNLboIiDieF4GGUKeTeClDpppF8eeEu2PIfwfrzizSdw3Hk
-        EnKlFpkMzV2wH77AosOFTV8A+vkl9CiHuJeLJNNZjM8tYWB0FkTvMAwmy/8ERTR6CwjlGAi1Ccence6C
-        1NsXzN4PKIxJLLgeIJ2MoXvmFraNBKK3eXZRIveJPvs7FIYniEkXZENOdE+GIZ2Ko10TwLK7tJmKmL0F
-        EEYarYM+NMnt0C1sQzpx/lcSEnZ2gcKY/gs0dlmZuWvmjjmpwA1qxVp2AWFIMAF/OAGBzMjMI7ZrtJCb
-        4Df3o4Zfxy7QrdxDRFKol5khkpR2H4qmIOzUQNBGwrsXYxccnNOQqNbQ0KGGZ+eEPVwdeLxvqqrf4wGh
-        TNAAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="copyToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHkSURBVDhPvZHfS1NhHIf3p5QypLr2D4goMwoMCi/qIugH
-        Xe1Cr7qKDIMkZixwNhfWLGWbnuki0kXKzLU023KubBNPJrbRdOzocm6e2dPOO21mMS+CHvjcvOf9PF++
-        79H9M+7RT2iRRsIi9sEAXe43yAvf2LpSHq28G9uAnytNT4jMLewtcQ2Ht2pF8ps/aOt+gccX5lxD694S
-        +1BQFD1RkN5DSFa4Z3uONKbgHE3h8KZ4OJTC1J8UiSzmfhd2uf1CoJHbyKOsZokl0kKwm+aeJaov+wjO
-        rpQkVqdXfOz0bWAcVLghfaXxkUz3y2VxvpMGSwL3uMKh+gHezSSLEnNhX23vtYzKUirDfGyFj/Iy1mdx
-        UWqR8iKhwtQLxjgH659y4EwvVXWPiwJt3/Ws+muywRrlqvkDdx3zQrCN8l1ldnEd3/QqFmkS/akHJYGS
-        zjLzOUEwEsMf+sLI2zmaOou/93pPGoM5zvk7UU7fnBKxSBPoT7SXBNW1F/9Io2lKCNTCeomUyrS8xnBA
-        wfUqyf1eP5U1ptJD/o1LzeNCsHPydtqdr6k4aiwvOHvNSya3ibU/QIdrEkvfhJislc32MfYfuV1eUGPw
-        FF7bIVJVZ0N/soPK421UHGstlFvYd/hWecF/Qqf7CR0A5wwgSQA2AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="pasteToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJSSURBVDhPtZJrSJNRGMdf6IN9KbpQn/pUEH2JIoLqQ0Zh
-        FqYZRmJG1iKmUqKyLB2pqSm6vC1Nm5GXoeatEsVJ0RASR3eNzegikRq5lrV3857Fr/d9ddlICoL+8OfA
-        Oef/e57zcIT/os7WLMw302muSGJ2689qqi7A44q8IzjtNYzarzHQm8tZtT8FmRqu6LToMxN+B8qhCbGR
-        KVcDE85ajKUaxoaryEuL4UVXIudPB5Ko2oy98xjDptXERuz3hsgAOTzlqqMk6yjdllzE90UM9Wp5azlB
-        S1kwkeG+1CSv4mmBQPThfd6Ahqq8GYB4A11yBKmaMLQxoZyLDkGjDiZOFUhUuB+FsWsUQFiArzegtlzH
-        pFjPpMPA2GA2jucx2KqWK7ZWLqO7dBGP9D5KWLbfto3eAKMhi3FHBeP9GYy9PMXos4OIrYvJrzSRbWjm
-        wuV6EnVG4tLLiEzSExGf4w0oL05nZEDPaK+akceBuO9v4uPtFUrYo6npbzhdE/QPOQmNSiPouHYOUpaf
-        gvgqA/dDf9wd63G1r2SgUlAqyyq/1anYUGfG2mdXwne7bOwJUc1AinOS+NxzBpd5HWLbUhyNPvRdF5S2
-        v05/54tbqvzBifWNHUvPOwLC4/CXwrv2HsB3+w6EwosJOB5ESeElfGpayGD1AmwlArHSm+W2PR1clToo
-        MrbT0mFTVtlbN6xFuJQar3wQz5Q9VksD+7XyPctrJdx4p5s605M5gKz8lJPSDwtGFbKboJ1blAN52vKb
-        PdXm80/AfDokTVu+8DfPXv9XCcIPTvjvLQ8YoakAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="helpToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing.Common" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIVSURBVDhPtVJNaxNRFM1PyE+Yn1AUXLjK0uWgDWQZwUUX
-        KsGFBEEcCkIwqBEpGiydsSo2kupsasdo7Yi2toh0sFZjG5JpiZo20/TpVOmH5njvm8BYahEXHji8+968
-        c+55l4n8F0zM+rhVWkHmdg29A/PoK1Yw8uIjOp/3xpvqBgrjLeilZbjNLXxZ34bwt6jexMVCGRndQenl
-        0p+NWHzPXoP3rQ3bAbQhQM0E5Np2BKprbZzrm8TIs8puE+68+r0NwwZiacCwALEBCVcAqet8JlAjk1PZ
-        JzsNJt6u4+FMS3ZmMV9mmFNAMhesbBZLC6oFdOsd8oVXocmdx018Ej9k1FgqiJ0zgS6qlR6BVI4iEFRN
-        IJlxMF/1cfTMcGiQvbskB6ZqgairJ6BCTJKYu9tlAUW1oSRsNDwfB+JXQ4PzN6s07W0ZPxDS5aSgJEFn
-        06Y9CaOqSauJRvMr9qmXQ4P8/RoWvU16eyBUEq5kbigwiKoOMTBQ0zbKlTq6TxihwejkZ1iOJwfEwmiC
-        BQ49yaW50J7Fh0xJw3IxbM3hwo2x0ICRHZzFgveTunYERK5lgo5YMxx8WPFw5Li+U8wYm66jNz+Naov+
-        Beqiao58N5NrPluoryJO0QeKU7sNGKPPazh9aRzGo/eYmVvEMk270fTlmzl2N3XW9xL/jv7iaxw7+wAH
-        E9ew//AVxE8OItv/9O/Cf0ck8gud2vKswuxNZgAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <metadata name="$this.TrayHeight" type="System.Int32, System.Private.CoreLib, Version=5.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e">
-    <value>31</value>
-  </metadata>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.Designer.cs
deleted file mode 100644
index e5af969cbd6..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.Designer.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class PrintingControls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(PrintingControls));
-        this.pageSetupDialog1 = new System.Windows.Forms.PageSetupDialog();
-        this.printDocument1 = new System.Drawing.Printing.PrintDocument();
-        this.printDialog1 = new System.Windows.Forms.PrintDialog();
-        this.printPreviewDialog1 = new System.Windows.Forms.PrintPreviewDialog();
-        this.label1 = new System.Windows.Forms.Label();
-        this.txtPrint = new System.Windows.Forms.TextBox();
-        this.btnSetting = new System.Windows.Forms.Button();
-        this.btnPreView = new System.Windows.Forms.Button();
-        this.btnPrint = new System.Windows.Forms.Button();
-        this.button1 = new System.Windows.Forms.Button();
-        this.label2 = new System.Windows.Forms.Label();
-        this.printPreviewControl1 = new System.Windows.Forms.PrintPreviewControl();
-        this.SuspendLayout();
-        // 
-        // pageSetupDialog1
-        // 
-        this.pageSetupDialog1.Document = this.printDocument1;
-        // 
-        // printDocument1
-        // 
-        this.printDocument1.PrintPage += new System.Drawing.Printing.PrintPageEventHandler(this.printDocument1_PrintPage);
-        // 
-        // printDialog1
-        // 
-        this.printDialog1.Document = this.printDocument1;
-        this.printDialog1.UseEXDialog = true;
-        // 
-        // printPreviewDialog1
-        // 
-        this.printPreviewDialog1.AutoScrollMargin = new System.Drawing.Size(0, 0);
-        this.printPreviewDialog1.AutoScrollMinSize = new System.Drawing.Size(0, 0);
-        this.printPreviewDialog1.ClientSize = new System.Drawing.Size(400, 300);
-        this.printPreviewDialog1.Document = this.printDocument1;
-        this.printPreviewDialog1.Enabled = true;
-        this.printPreviewDialog1.Icon = ((System.Drawing.Icon)(resources.GetObject("printPreviewDialog1.Icon")));
-        this.printPreviewDialog1.Name = "printPreviewDialog1";
-        this.printPreviewDialog1.Visible = false;
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(14, 10);
-        this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(165, 15);
-        this.label1.TabIndex = 0;
-        this.label1.Text = "Please &input text you want to print";
-        // 
-        // txtPrint
-        // 
-        this.txtPrint.Location = new System.Drawing.Point(191, 7);
-        this.txtPrint.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.txtPrint.Name = "txtPrint";
-        this.txtPrint.Size = new System.Drawing.Size(213, 23);
-        this.txtPrint.TabIndex = 1;
-        this.txtPrint.Text = "This is the test message.";
-        // 
-        // btnSetting
-        // 
-        this.btnSetting.Location = new System.Drawing.Point(18, 43);
-        this.btnSetting.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.btnSetting.Name = "btnSetting";
-        this.btnSetting.Size = new System.Drawing.Size(88, 27);
-        this.btnSetting.TabIndex = 2;
-        this.btnSetting.Text = "&Setting";
-        this.btnSetting.UseVisualStyleBackColor = true;
-        this.btnSetting.Click += new System.EventHandler(this.BtnSetting_Click);
-        // 
-        // btnPreView
-        // 
-        this.btnPreView.Location = new System.Drawing.Point(112, 43);
-        this.btnPreView.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.btnPreView.Name = "btnPreView";
-        this.btnPreView.Size = new System.Drawing.Size(88, 27);
-        this.btnPreView.TabIndex = 3;
-        this.btnPreView.Text = "P&review";
-        this.btnPreView.UseVisualStyleBackColor = true;
-        this.btnPreView.Click += new System.EventHandler(this.BtnPreView_Click);
-        // 
-        // btnPrint
-        // 
-        this.btnPrint.Location = new System.Drawing.Point(206, 43);
-        this.btnPrint.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.btnPrint.Name = "btnPrint";
-        this.btnPrint.Size = new System.Drawing.Size(88, 27);
-        this.btnPrint.TabIndex = 4;
-        this.btnPrint.Text = "&Print";
-        this.btnPrint.UseVisualStyleBackColor = true;
-        this.btnPrint.Click += new System.EventHandler(this.BtnPrint_Click);
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(301, 43);
-        this.button1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(104, 27);
-        this.button1.TabIndex = 6;
-        this.button1.Text = "Preview &Control";
-        this.button1.UseVisualStyleBackColor = true;
-        this.button1.Click += new System.EventHandler(this.Button1_Click);
-        // 
-        // label2
-        // 
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(18, 86);
-        this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(91, 15);
-        this.label2.TabIndex = 7;
-        this.label2.Text = "View your page:";
-        // 
-        // printPreviewControl1
-        //
-        this.printPreviewControl1.AccessibleName = "Image layout ready for printing";
-        this.printPreviewControl1.AutoZoom = false;
-        this.printPreviewControl1.Document = this.printDocument1;
-        this.printPreviewControl1.Location = new System.Drawing.Point(18, 104);
-        this.printPreviewControl1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.printPreviewControl1.Name = "printPreviewControl1";
-        this.printPreviewControl1.Rows = 24;
-        this.printPreviewControl1.Size = new System.Drawing.Size(387, 408);
-        this.printPreviewControl1.TabIndex = 8;
-        this.printPreviewControl1.TabStop = true;
-        this.printPreviewControl1.Zoom = 0.36454545454545456D;
-        // 
-        // PrintingControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(426, 522);
-        this.Controls.Add(this.printPreviewControl1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.button1);
-        this.Controls.Add(this.btnPrint);
-        this.Controls.Add(this.btnPreView);
-        this.Controls.Add(this.btnSetting);
-        this.Controls.Add(this.txtPrint);
-        this.Controls.Add(this.label1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "PrintingControls";
-        this.Text = "PrintingTesting";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.PageSetupDialog pageSetupDialog1;
-    private System.Windows.Forms.PrintDialog printDialog1;
-    private System.Drawing.Printing.PrintDocument printDocument1;
-    private System.Windows.Forms.PrintPreviewDialog printPreviewDialog1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.TextBox txtPrint;
-    private System.Windows.Forms.Button btnSetting;
-    private System.Windows.Forms.Button btnPreView;
-    private System.Windows.Forms.Button btnPrint;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.PrintPreviewControl printPreviewControl1;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.cs
deleted file mode 100644
index 399a6f38002..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class PrintingControls : Form
-{
-    public PrintingControls()
-    {
-        InitializeComponent();
-    }
-
-    int totalNumber;//this is for total number of items of the list or array
-    int itemPerpage;//this is for no of item per page 
-    private void printDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
-    {
-        float currentY = 50;// declare  one variable for height measurement
-        Font font = new Font("Times New Roman", 30);
-        Brush brush = Brushes.Blue;
-
-        while (totalNumber <= 500) // check the number of items
-        {
-            //print each item
-            e.Graphics.DrawString($"{txtPrint.Text} {totalNumber}", font, brush, 50, currentY);
-            currentY += 50; // set a gap between every item
-            totalNumber += 1; //increment count by 1
-            if (itemPerpage < 20) // check whether  the number of item(per page) is more than 20 or not
-            {
-                itemPerpage += 1; // increment itemperpage by 1
-                e.HasMorePages = false; // set the HasMorePages property to false , so that no other page will not be added
-            }
-
-            else // if the number of item(per page) is more than 20 then add one page
-            {
-                itemPerpage = 0; //initiate itemperpage to 0 .
-                e.HasMorePages = true; //e.HasMorePages raised the PrintPage event once per page .
-                return;//It will call PrintPage event again
-            }
-        }
-    }
-
-    private void BtnSetting_Click(object sender, EventArgs e)
-    {
-        pageSetupDialog1.Document = printDocument1;
-        pageSetupDialog1.ShowDialog();
-    }
-
-    private void BtnPreView_Click(object sender, EventArgs e)
-    {
-        //here we are printing 50 numbers sequentially by using loop. 
-        //For each button click event we have to reset below two variables to 0     
-        // because every time  PrintPage event fires automatically. 
-
-        itemPerpage = totalNumber = 0;
-        printPreviewDialog1.Document = printDocument1;
-
-        ((ToolStripButton)((ToolStrip)printPreviewDialog1.Controls[1]).Items[0]).Enabled = false;//disable the direct print from printpreview.as when we click that Print button PrintPage event fires again.
-
-        printPreviewDialog1.ShowDialog();
-    }
-
-    private void BtnPrint_Click(object sender, EventArgs e)
-    {
-        if (printDialog1.ShowDialog() == DialogResult.OK)
-        {
-            printDocument1.Print();
-        }
-    }
-
-    private void Button1_Click(object sender, EventArgs e)
-    {
-        printPreviewControl1.Document = printDocument1;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.resx
deleted file mode 100644
index 50a469554a5..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/PrintingControls.resx
+++ /dev/null
@@ -1,246 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="pageSetupDialog1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <metadata name="printDocument1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>288, 17</value>
-  </metadata>
-  <metadata name="printDialog1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>169, 17</value>
-  </metadata>
-  <metadata name="printPreviewDialog1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>429, 17</value>
-  </metadata>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="printPreviewDialog1.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        AAABAAYAICAQAAAAAADoAgAAZgAAABAQEAAAAAAAKAEAAE4DAAAgIAAAAQAIAKgIAAB2BAAAEBAAAAEA
-        CABoBQAAHg0AACAgAAABACAAqBAAAIYSAAAQEAAAAQAgAGgEAAAuIwAAKAAAACAAAABAAAAAAQAEAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAACAgACAAAAAgACAAICAAACAgIAAwMDAAAAA
-        /wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIoiI
-        iIiIiIiIiIiIiIiIiIiCIigiIiIozMzMzMzMyCIogiIoIiIiKM7m5ubm5sgiKIIiKCIiIijObm5ubm7I
-        IiiCIigiIiIozubm5ubmyCIogiIoIiIiKM5ubm5ubsgiKIIiKCIiIijO5ubm5ubIIiiIiIiIiIiIzm5u
-        bm5uyCIogRERERERGM7u7u7u7sgiKIHZWVlZWRjMzMzMzMzIIiiB1ZWVlZUYiIiIiIiIiIiIgdlZWVlZ
-        GDMzMzMzMzMzOIHVlZWVlRg/uLi4uLi4uDiB2VlZWVkYP7uLi4uLi4s4gdWVlZWVGD+4uLi4uLi4OIHZ
-        WVlZWRg/u4uLi4uLiziB1ZWVlZUYP7i4uLi4uLg4gdlZWVlZGD+7i4uLi4uLOIHVlZWVlRg/uLi4uLi4
-        uDiB3d3d3d0YP7uLi4uLi4s4gRERERERGD+4uLi4uLi4OIiIiIiIiIg/u4uLi4uLiziCIiIiIiIoP7i4
-        uLi4uLg4giIiIiIiKD+7i4uLi4uLOIIiIiIiIig/uLi4uLi4uDiCIiIiIiIoP7u7u7u7u7s4giIiIiIi
-        KD//////////OIIiIiIiIigzMzMzMzMzMziIiIiIiIiIiIiIiIiIiIiIIiIiIiIiIiIiIiIiIiIiIv//
-        ////////AAAAAHv4AA57+AAOe/gADnv4AA57+AAOe/gADgAAAA4AAAAOAAAADgAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH/4AAB/+AAAf/gAAH/4AAB/+AAAf/gAAAAA
-        AAD/////KAAAABAAAAAgAAAAAQAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAACA
-        gACAAAAAgACAAICAAACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAiIiIiIiIiIoiI
-        iIiIiIiIgigijMzMyCiCKCKM5mbIKIiIiIzu7sgogRERjMzMyCiB2ZGIiIiIiIHZkYMzMzM4gdmRg/u7
-        uziB3dGD+7u7OIEREYP7u7s4iIiIg/u7uziCIiKD+7u7OIIiIoP///84giIigzMzMziIiIiIiIiIiP//
-        KCIAACjObALm5mwCIigAAoiIAAKIzgAAbm4AACIoAAAREQAAGM4AAO7uAAAiKHwAWVl8ABjMfADMzAAA
-        IigoAAAAIAAAAEAAAAABAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAgAAAAICAAIAA
-        AACAAIAAgIAAAICAgADA3MAA8MqmAKo/KgD/PyoAAF8qAFVfKgCqXyoA/18qAAB/KgBVfyoAqn8qAP9/
-        KgAAnyoAVZ8qAKqfKgD/nyoAAL8qAFW/KgCqvyoA/78qAADfKgBV3yoAqt8qAP/fKgAA/yoAVf8qAKr/
-        KgD//yoAAABVAFUAVQCqAFUA/wBVAAAfVQBVH1UAqh9VAP8fVQAAP1UAVT9VAKo/VQD/P1UAAF9VAFVf
-        VQCqX1UA/19VAAB/VQBVf1UAqn9VAP9/VQAAn1UAVZ9VAKqfVQD/n1UAAL9VAFW/VQCqv1UA/79VAADf
-        VQBV31UAqt9VAP/fVQAA/1UAVf9VAKr/VQD//1UAAAB/AFUAfwCqAH8A/wB/AAAffwBVH38Aqh9/AP8f
-        fwAAP38AVT9/AKo/fwD/P38AAF9/AFVffwCqX38A/19/AAB/fwBVf38Aqn9/AP9/fwAAn38AVZ9/AKqf
-        fwD/n38AAL9/AFW/fwCqv38A/79/AADffwBV338Aqt9/AP/ffwAA/38AVf9/AKr/fwD//38AAACqAFUA
-        qgCqAKoA/wCqAAAfqgBVH6oAqh+qAP8fqgAAP6oAVT+qAKo/qgD/P6oAAF+qAFVfqgCqX6oA/1+qAAB/
-        qgBVf6oAqn+qAP9/qgAAn6oAVZ+qAKqfqgD/n6oAAL+qAFW/qgCqv6oA/7+qAADfqgBV36oAqt+qAP/f
-        qgAA/6oAVf+qAKr/qgD//6oAAADUAFUA1ACqANQA/wDUAAAf1ABVH9QAqh/UAP8f1AAAP9QAVT/UAKo/
-        1AD/P9QAAF/UAFVf1ACqX9QA/1/UAAB/1ABVf9QAqn/UAP9/1AAAn9QAVZ/UAKqf1AD/n9QAAL/UAFW/
-        1ACqv9QA/7/UAADf1ABV39QAqt/UAP/f1AAA/9QAVf/UAKr/1AD//9QAVQD/AKoA/wAAH/8AVR//AKof
-        /wD/H/8AAD//AFU//wCqP/8A/z//AABf/wBVX/8Aql//AP9f/wAAf/8AVX//AKp//wD/f/8AAJ//AFWf
-        /wCqn/8A/5//AAC//wBVv/8Aqr//AP+//wAA3/8AVd//AKrf/wD/3/8AVf//AKr//wD/zMwA/8z/AP//
-        MwD//2YA//+ZAP//zAAAfwAAVX8AAKp/AAD/fwAAAJ8AAFWfAACqnwAA/58AAAC/AABVvwAAqr8AAP+/
-        AAAA3wAAVd8AAKrfAAD/3wAAVf8AAKr/AAAAACoAVQAqAKoAKgD/ACoAAB8qAFUfKgCqHyoA/x8qAAA/
-        KgBVPyoA8Pv/AKSgoACAgIAAAAD/AAD/AAAA//8A/wAAAAAAAAD//wAA////AP39/f39/f39/f39/f39
-        /f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39
-        /f39/f39/f39/f39/f39/f39/f39/f39qoYIqoYIhqoIqgiqCaoIqgiqhqqGhoYIhoYIqv39/f0I/f39
-        /ar9/f39/YY2Ng4yDg4ODgoOCgoKCgqG/f39/Yb9/f39CP39/f39qjY7Ozs3Nzc3NjMSMjIOCqr9/f39
-        qv39/f2G/f39/f0IN19fOzs3Nzc3NjcODg4KCP39/f0I/f39/ar9/f39/ao6X19fXzs7Ozc3NzY3NgqG
-        /f39/Yb9/f39CP39/f39hl9jY19jX187Ozs7Nzc3Dqr9/f39qv39/f2G/f39/f0IOodjh19jX19fXztf
-        OzcOCP39/f0ICAmqCAiqCKoICapfCYdjh2ODY19fXzs7Ow6q/f39/QhITEwoSCUoKSQoqmMJCYcJCWNj
-        Y2NfY19fNgj9/f39qkyZmZmYmJRwlCmqX19fXl9fX186WzY3Njc2gv39/f0JcJ2dmZmZlJmUJAmqCaoJ
-        hggIqggICKoIqggI/f39/YZwnp2dnZmZmJVMqnx8fHx8fFR8VHhUVFRUVKr9/f39CHChoZ2dnZ2ZmUwJ
-        fKSkxqSkxqSkpKSkpKBUCP39/f2qcKLDoqGdnZ2ZTKp8ysakxqSkxqSkxqSkpFSq/f39/QiUpqbDoqHE
-        nZ1Mq3ykqMakyqSkxqSkpKSkVAj9/f39hpTIyKbHoqGhoXAIfMrLpMqkxqSkxqTGpKRUqv39/f0IlMym
-        yKbIpcShcAh8y6jKpMqkxsqkpKSkxlQI/f39/aqUzMzMyKbIpqJwqnzLy8qpxsqkpMakxqSkeAj9/f39
-        CJSUlJSUlJSUlJQJgMupy8qpysqkyqSkxqRUqv39/f2GCKoIqgiqCKoIhgigrcvPqcuoy8qkxsqkxnyG
-        /f39/ar9/f39/f39/f39qnzPz6nLy8uoyqnKpKTKVAj9/f39CP39/f39/f39/f0IfNDPz8+py8upyqjG
-        yqR8hv39/f2G/f39/f39/f39/Qik0K7P0M+ty8vLy6jKpXyq/f39/ar9/f39/f39/f39CHzQ09Ctz8/P
-        qcupy6jKeAj9/f39CP39/f39/f39/f2qoNPQ0NPQ0M/Qz8vLy6l8CP39/f2G/f39/f39/f39/QmkfKR8
-        oHx8fHx8fHx8fHyG/f39/aoIqgiqCKoIqgiqCKoIqgiqCKoIqgiqCKoIqgj9/f39/f39/f39/f39/f39
-        /f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/f3/////////////
-        ///AAAAD3vgAA974AAPe+AAD3vgAA974AAPe+AADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AA
-        AAPAAAADwAAAA8AAAAPAAAADwAAAA9/4AAPf+AAD3/gAA9/4AAPf+AAD3/gAA8AAAAP//////////ygA
-        AAAQAAAAIAAAAAEACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAA
-        gACAgAAAgICAAMDcwADwyqYAqj8qAP8/KgAAXyoAVV8qAKpfKgD/XyoAAH8qAFV/KgCqfyoA/38qAACf
-        KgBVnyoAqp8qAP+fKgAAvyoAVb8qAKq/KgD/vyoAAN8qAFXfKgCq3yoA/98qAAD/KgBV/yoAqv8qAP//
-        KgAAAFUAVQBVAKoAVQD/AFUAAB9VAFUfVQCqH1UA/x9VAAA/VQBVP1UAqj9VAP8/VQAAX1UAVV9VAKpf
-        VQD/X1UAAH9VAFV/VQCqf1UA/39VAACfVQBVn1UAqp9VAP+fVQAAv1UAVb9VAKq/VQD/v1UAAN9VAFXf
-        VQCq31UA/99VAAD/VQBV/1UAqv9VAP//VQAAAH8AVQB/AKoAfwD/AH8AAB9/AFUffwCqH38A/x9/AAA/
-        fwBVP38Aqj9/AP8/fwAAX38AVV9/AKpffwD/X38AAH9/AFV/fwCqf38A/39/AACffwBVn38Aqp9/AP+f
-        fwAAv38AVb9/AKq/fwD/v38AAN9/AFXffwCq338A/99/AAD/fwBV/38Aqv9/AP//fwAAAKoAVQCqAKoA
-        qgD/AKoAAB+qAFUfqgCqH6oA/x+qAAA/qgBVP6oAqj+qAP8/qgAAX6oAVV+qAKpfqgD/X6oAAH+qAFV/
-        qgCqf6oA/3+qAACfqgBVn6oAqp+qAP+fqgAAv6oAVb+qAKq/qgD/v6oAAN+qAFXfqgCq36oA/9+qAAD/
-        qgBV/6oAqv+qAP//qgAAANQAVQDUAKoA1AD/ANQAAB/UAFUf1ACqH9QA/x/UAAA/1ABVP9QAqj/UAP8/
-        1AAAX9QAVV/UAKpf1AD/X9QAAH/UAFV/1ACqf9QA/3/UAACf1ABVn9QAqp/UAP+f1AAAv9QAVb/UAKq/
-        1AD/v9QAAN/UAFXf1ACq39QA/9/UAAD/1ABV/9QAqv/UAP//1ABVAP8AqgD/AAAf/wBVH/8Aqh//AP8f
-        /wAAP/8AVT//AKo//wD/P/8AAF//AFVf/wCqX/8A/1//AAB//wBVf/8Aqn//AP9//wAAn/8AVZ//AKqf
-        /wD/n/8AAL//AFW//wCqv/8A/7//AADf/wBV3/8Aqt//AP/f/wBV//8Aqv//AP/MzAD/zP8A//8zAP//
-        ZgD//5kA///MAAB/AABVfwAAqn8AAP9/AAAAnwAAVZ8AAKqfAAD/nwAAAL8AAFW/AACqvwAA/78AAADf
-        AABV3wAAqt8AAP/fAABV/wAAqv8AAAAAKgBVACoAqgAqAP8AKgAAHyoAVR8qAKofKgD/HyoAAD8qAFU/
-        KgDw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAAAAAAAP//AAD///8A/f39/f39/f39/f39/f39/f0I
-        hgiqCKoICKoICKaGCP39qv39hv2GNg4ODjII/ar9/Yb9/ar9qjdjXzsOCP2G/f0IhquGCAleCWNfNob9
-        qv39qkxMTEgIX19fX18I/Qj9/QhwnZlMqoYIqggIqgiG/f2qcKadcAl8fFQDVFQDqv39CHDMpnCqfMvL
-        ysrKVAj9/QiUlHBwCYDPy8/LylSG/f2GqoYIqgig0M/Py8t8qv39CP39/f2GpNDQ0M/PfAn9/ar9/f39
-        qqT20NDQ0Hyq/f2G/f39/QmkpKSloKR8CP39CKoIhgiqCIYIqgiGCKr9/f39/f39/f39/f39/f39/f//
-        hv2AAf0ItAX9/bQFX2OABWNfgAU7O4ABNzeAAf39gAGq/YAB/YaAAf39vAE6h7wBX2O8AV9fgAE7N///
-        /f0oAAAAIAAAAEAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAADCv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wAAAAAAAAAAAAAAAAAA
-        AAAAAAAAwr/B/7Z3Sf+zckT/rm0//6toO/+nYjb/pF4y/6BZLv+dVCr/mlEn/5dNI/+VSiH/kkce/5FE
-        HP+RRBz/kUUb/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/AAAAAAAA
-        AAAAAAAAAAAAAAAAAADCv8H/v4JS//+aZv//lWD/+5Bc//WLV//uh1P/54FO/997S//Wdkb/zXBD/8Vr
-        QP+9Zj3/tGI5/65dN/+RRRz/wr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/AAAAAAAAAAAAAAAAAAAAAMK/
-        wf8AAAAAAAAAAAAAAAAAAAAAAAAAAMK/wf/GjFv//6Rz//+fbf//m2f//5Zh//yRXf/3jVj/8IhV/+mD
-        UP/hfUz/2HhI/9ByRP/HbED/v2c9/5VJIf/Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8AAAAAAAAAAAAA
-        AAAAAAAAwr/B/wAAAAAAAAAAAAAAAAAAAAAAAAAAwr/B/86WZP//r4L//6p7//+mdf//oW7//5xo//+X
-        Yv/9kl7/+I5a//KJVf/rhFH/4n5N/9t4SP/Sc0X/mlEm/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wAA
-        AAAAAAAAAAAAAAAAAADCv8H/AAAAAAAAAAAAAAAAAAAAAAAAAADCv8H/1J9s//+4kf//tIv//6+E//+r
-        ff//p3f//6Jw//+eav//mWT//pRf//qQWv/0i1b/7IVS/+V/Tv+gWC7/wr/B/wAAAAAAAAAAAAAAAAAA
-        AADCv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8AAAAAAAAAAAAAAAAAAAAAAAAAAMK/wf/apnP//7+d//+7
-        mP//uJL//7WM//+whv//rH///6d4//+jcf//n2v//5ll//+VYP/6kVv/9YxY/6diN//Cv8H/AAAAAAAA
-        AAAAAAAAAAAAAMK/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/96t
-        eP//wqL//8Gi//+/nv//vJn//7mT//+2jv//sYj//66A//+pev//pHP//6Bt//+bZ///l2L/r20//8K/
-        wf8AAAAAAAAAAAAAAAAAAAAAwr/B/xYXev8XF3b/GBVx/xkUbf8ZFGr/GhNm/xoSY/8bEV//HBFd/xwQ
-        W//Cv8H/4K96///Cov//wqL//8Ki///Cov//wJ///72b//+6lf//t4///7KJ//+ugv//qnv//6V0//+h
-        bv+3d0n/wr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/FRqE/0dN1v8/RNL/Nz3Q/y40zv8nLcz/ISfK/xwh
-        yf8WHMf/GxJh/8K/wf/gr3r/4K96/+Cvev/gr3r/3614/9yqdf/apnL/16Nw/9Sea//Rmmj/zZZk/8qR
-        X//GjFz/w4dW/7+CUv/Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8SHZD/WF3a/05U1/9FS9X/PUPS/zU7
-        0P8uM83/JyzL/yAmyf8aFGn/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/xAfnP9obt7/YGTc/1Zb
-        2f9NU9f/RUrU/ztB0v80OdD/LDHO/xgWcv/Cv8H/Dn+n/w18pP8MeqH/DHie/wt1m/8Kc5j/CXGV/wlv
-        k/8JbJD/CGqN/wdpi/8HZ4j/BmWH/wZkhf8GYoP/wr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/DiKp/3l+
-        4/9vdeH/Zmze/11i2/9UWtn/S1HW/0NI1P86P9H/Fhh9/8K/wf8Ogar/Barp/wGo6P8Apef/AKPm/wCi
-        5P8An+L/AJ7h/wCd3/8AnN7/AJnc/wCY2/8AmNn/AJbX/wZjhP/Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/
-        wf8MJbX/iI7n/4CF5v93fOP/bnPg/2Vr3f9bYdv/UljY/0lP1v8UGoj/wr/B/w+Erf8Lrur/Bqvq/wOo
-        6f8Apuf/AKTm/wCi5f8AoOT/AJ/i/wCd4f8AnN//AJrd/wCZ2/8AmNr/BmWH/8K/wf8AAAAAAAAAAAAA
-        AAAAAAAAwr/B/wkowP+WnOz/jpTq/4aL6P9+hOX/dXri/2xx4P9jaN3/WV/b/xEek//Cv8H/EIaw/xay
-        7P8Or+z/Cavr/wWq6v8Bp+j/AKbn/wCj5f8AoeT/AJ/j/wCe4f8AnOD/AJve/wCa3f8HZ4n/wr/B/wAA
-        AAAAAAAAAAAAAAAAAADCv8H/CCrK/6Ko7/+coe7/lZrr/42T6f+Fiub/fIHl/3N54v9rcN//ECGg/8K/
-        wf8QiLP/I7nu/xq07f8Ssez/C63r/war6v8Cqen/AKbo/wCk5v8AouX/AKHk/wCf4f8AneH/AJzf/who
-        i//Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8GLNP/q7Hy/6as8P+hpu//mp/u/5OY6/+LkOj/g4nm/3qA
-        5P8NI6z/wr/B/xCKtv8xvvD/J7rv/x627f8Vsuz/Dq/s/wmr6/8Equn/Aafo/wCl5/8Ao+X/AKHk/wCf
-        4v8AnuH/CGqO/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wUu2/+vtPP/r7Tz/6qv8v+mq/D/oKXv/5me
-        7f+Sl+v/io/p/wsmt//Cv8H/Eo24/0HF8f82wfD/LLzv/yK47v8atO3/EbHs/wut6/8Gq+r/A6np/wCm
-        6P8Apeb/AKLl/wCh5P8IbJD/wr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/BC/h/wQv3/8FL9z/BS3Z/wYt
-        1v8GLNL/ByvP/wgqy/8IKcb/CSnC/8K/wf8Sjrv/Uszy/0fH8f87w/H/Mb7v/ye67/8et+7/FbPt/w6v
-        6/8IrOv/BKnp/wGo6P8Apef/AKPl/wluk//Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/xKRvf9j0/P/WM/z/0zK8f9BxfH/N8Hw/yy8
-        7/8iuO7/GbTt/xGx7P8Lruv/Bqrq/wOo6f8Apuf/CnGV/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCv8H/E5LA/3Ta8/9q1fP/XtHz/1LM
-        8v9Hx/H/O8Pw/zG+7/8nu+//Hrbt/xay7f8Or+v/CKzq/wSq6f8Kc5j/wr/B/wAAAAAAAAAAAAAAAAAA
-        AADCv8H/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMK/wf8UlMH/hOD1/3rc
-        9f9v2PP/ZNTy/1jO8v9NyvH/Qsbx/zbB8P8svO//I7ju/xm07f8SsOz/C67r/wt2m//Cv8H/AAAAAAAA
-        AAAAAAAAAAAAAMK/wf8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwr/B/xSW
-        w/+T5vb/iuL1/3/e9P912vT/adbz/13R8/9SzPL/R8jx/zzD8P8xvvD/J7rv/x627v8Vsuz/C3ie/8K/
-        wf8AAAAAAAAAAAAAAAAAAAAAwr/B/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AADCv8H/FJbG/57r9/+X6Pb/juT1/4Th9f963fX/b9j0/2PT8/9Yz/L/TMrx/0HF8f83wO//LLzv/yK4
-        7v8MeqH/wr/B/wAAAAAAAAAAAAAAAAAAAADCv8H/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAMK/wf8VmMf/qO/3/6Lt9/+b6vb/kub2/4rj9f9/3vX/dNrz/2rV8/9d0fP/Uszy/0fI
-        8f88w/D/Mr7v/w19pP/Cv8H/AAAAAAAAAAAAAAAAAAAAAMK/wf8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAwr/B/xWZyP8UmMf/FZfF/xSVw/8TlML/E5K//xOQvf8Sjrv/EYy4/xGK
-        tv8QiLL/D4Ww/w+Erf8Pgar/Dn+n/8K/wf8AAAAAAAAAAAAAAAAAAAAAwr/B/8K/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/
-        wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/8K/wf/Cv8H/wr/B/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//
-        /////////////8AAAAPe+AAD3vgAA974AAPe+AAD3vgAA974AAPAAAADwAAAA8AAAAPAAAADwAAAA8AA
-        AAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAAD3/gAA9/4AAPf+AAD3/gAA9/4AAPf+AADwAAAA///
-        ////////KAAAABAAAAAgAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMDA/8DA
-        wP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP8AAAAAAAAAAMDA
-        wP8AAAAAAAAAAMDAwP8AAAAAwMDA/8F2R/+9bj//umc6/7diNf+3YjX/wMDA/wAAAADAwMD/AAAAAAAA
-        AADAwMD/AAAAAAAAAADAwMD/AAAAAMDAwP/RkmD//7aP//+ldP/8kl3/vW0//8DAwP8AAAAAwMDA/wAA
-        AAAAAAAAwMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/3ap2///Cov//to7//6V0/8uJWP/AwMD/AAAAAMDA
-        wP8AAAAAAAAAAMDAwP8THI7/FBqF/xYYfP8XFnP/wMDA/+Cvev/gr3r/4K96/92qdv/ao3D/wMDA/wAA
-        AADAwMD/AAAAAAAAAADAwMD/ECCd/2Fn3P8zOc//FRmC/8DAwP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DA
-        wP/AwMD/wMDA/wAAAAAAAAAAwMDA/w0krP+Pler/YWbd/xIcj//AwMD/DHmf/wpzmP8Ib5L/B2uO/wdq
-        jf8Gao3/B2qN/8DAwP8AAAAAAAAAAMDAwP8KJrv/r7Tz/5CU6v8PIJ//wMDA/w+Dq/87y/z/Kcb8/xrD
-        /P8QwPv/EMD7/wdqjf/AwMD/AAAAAAAAAADAwMD/CCrI/woowP8LJrf/DSSu/8DAwP8Sjbj/Zdb9/0/Q
-        /P88y/v/Kcf7/xrC+/8IbZD/wMDA/wAAAAAAAAAAwMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/FpfG/43h
-        /f962/3/Zdb8/0/Q/P87zPz/CXSZ/8DAwP8AAAAAAAAAAMDAwP8AAAAAAAAAAAAAAAAAAAAAwMDA/xif
-        z/+u6f7/n+X9/47h/f953P3/ZNb9/w19pP/AwMD/AAAAAAAAAADAwMD/AAAAAAAAAAAAAAAAAAAAAMDA
-        wP8apNX/uez+/7ns/v+u6f7/oOX9/43h/f8Rh7H/wMDA/wAAAAAAAAAAwMDA/wAAAAAAAAAAAAAAAAAA
-        AADAwMD/GqTV/xqk1f8apNX/GaHR/xecy/8WmMb/FJK+/8DAwP8AAAAAAAAAAMDAwP/AwMD/wMDA/8DA
-        wP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/wMDA/8DAwP/AwMD/AAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAAgAEAALQF
-        wf+0BQAAgAUAAIAFAACAAQAAgAHB/4ABAACAAQAAgAEAALwBAAC8AQAAvAHB/4ABbP///5H/
-</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Program.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Program.cs
deleted file mode 100644
index 2216c860adc..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Program.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-internal static class Program
-{
-    /// <summary>
-    ///  The main entry point for the application.
-    /// </summary>
-    [STAThread]
-    static void Main()
-    {
-        Application.SetHighDpiMode(HighDpiMode.PerMonitorV2);
-        Application.EnableVisualStyles();
-        Application.SetCompatibleTextRenderingDefault(false);
-        Application.Run(new Main());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.Designer.cs
deleted file mode 100644
index 098f32ef98d..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.Designer.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace Accessibility_Core_App.Properties; 
-using System;
-
-
-/// <summary>
-///   A strongly-typed resource class, for looking up localized strings, etc.
-/// </summary>
-// This class was auto-generated by the StronglyTypedResourceBuilder
-// class via a tool like ResGen or Visual Studio.
-// To add or remove a member, edit your .ResX file then rerun ResGen
-// with the /str option, or rebuild your VS project.
-[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
-[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-internal class Resources {
-    
-    private static global::System.Resources.ResourceManager resourceMan;
-    
-    private static global::System.Globalization.CultureInfo resourceCulture;
-    
-    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-    internal Resources() {
-    }
-    
-    /// <summary>
-    ///   Returns the cached ResourceManager instance used by this class.
-    /// </summary>
-    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-    internal static global::System.Resources.ResourceManager ResourceManager {
-        get {
-            if (object.ReferenceEquals(resourceMan, null)) {
-                global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Accessibility_Core_App.Properties.Resources", typeof(Resources).Assembly);
-                resourceMan = temp;
-            }
-            return resourceMan;
-        }
-    }
-    
-    /// <summary>
-    ///   Overrides the current thread's CurrentUICulture property for all
-    ///   resource lookups using this strongly typed resource class.
-    /// </summary>
-    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-    internal static global::System.Globalization.CultureInfo Culture {
-        get {
-            return resourceCulture;
-        }
-        set {
-            resourceCulture = value;
-        }
-    }
-    
-    /// <summary>
-    ///   Looks up a localized resource of type System.Drawing.Bitmap.
-    /// </summary>
-    internal static System.Drawing.Bitmap TestResult {
-        get {
-            object obj = ResourceManager.GetObject("TestResult", resourceCulture);
-            return ((System.Drawing.Bitmap)(obj));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.resx b/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.resx
deleted file mode 100644
index e546aadddd1..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Properties/Resources.resx
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="TestResult" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\TestResult.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.Designer.cs
deleted file mode 100644
index b86b8cb7adc..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.Designer.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class RemainingControls
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.hScrollBar1 = new System.Windows.Forms.HScrollBar();
-        this.vScrollBar1 = new System.Windows.Forms.VScrollBar();
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.propertyGrid2 = new System.Windows.Forms.PropertyGrid();
-        this.label1 = new System.Windows.Forms.Label();
-        this.domainUpDown1 = new System.Windows.Forms.DomainUpDown();
-        this.label2 = new System.Windows.Forms.Label();
-        this.trackBar1 = new System.Windows.Forms.TrackBar();
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // hScrollBar1
-        // 
-        this.hScrollBar1.Dock = System.Windows.Forms.DockStyle.Bottom;
-        this.hScrollBar1.Location = new System.Drawing.Point(0, 406);
-        this.hScrollBar1.Name = "hScrollBar1";
-        this.hScrollBar1.Size = new System.Drawing.Size(593, 17);
-        this.hScrollBar1.TabIndex = 7;
-        this.hScrollBar1.TabStop = true;
-        // 
-        // vScrollBar1
-        // 
-        this.vScrollBar1.Dock = System.Windows.Forms.DockStyle.Right;
-        this.vScrollBar1.Location = new System.Drawing.Point(576, 0);
-        this.vScrollBar1.Name = "vScrollBar1";
-        this.vScrollBar1.Size = new System.Drawing.Size(17, 406);
-        this.vScrollBar1.TabIndex = 4;
-        this.vScrollBar1.TabStop = true;
-        // 
-        // propertyGrid1
-        // 
-        this.propertyGrid1.Location = new System.Drawing.Point(19, 80);
-        this.propertyGrid1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(266, 282);
-        this.propertyGrid1.TabIndex = 5;
-        // 
-        // propertyGrid2
-        // 
-        this.propertyGrid2.Location = new System.Drawing.Point(292, 80);
-        this.propertyGrid2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.propertyGrid2.Name = "propertyGrid2";
-        this.propertyGrid2.Size = new System.Drawing.Size(260, 282);
-        this.propertyGrid2.TabIndex = 6;
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(19, 33);
-        this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(156, 15);
-        this.label1.TabIndex = 0;
-        this.label1.Text = "Setting for DomainUpDown:";
-        // 
-        // domainUpDown1
-        // 
-        this.domainUpDown1.Location = new System.Drawing.Point(192, 31);
-        this.domainUpDown1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.domainUpDown1.Name = "domainUpDown1";
-        this.domainUpDown1.Size = new System.Drawing.Size(140, 23);
-        this.domainUpDown1.TabIndex = 1;
-        this.domainUpDown1.Text = "domainUpDown1";
-        // 
-        // label2
-        // 
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(373, 33);
-        this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(37, 15);
-        this.label2.TabIndex = 2;
-        this.label2.Text = "Track:";
-        // 
-        // trackBar1
-        // 
-        this.trackBar1.Location = new System.Drawing.Point(431, 29);
-        this.trackBar1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.trackBar1.Name = "trackBar1";
-        this.trackBar1.Size = new System.Drawing.Size(121, 45);
-        this.trackBar1.TabIndex = 3;
-        // 
-        // RemainingControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(593, 423);
-        this.Controls.Add(this.trackBar1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.domainUpDown1);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.propertyGrid2);
-        this.Controls.Add(this.propertyGrid1);
-        this.Controls.Add(this.vScrollBar1);
-        this.Controls.Add(this.hScrollBar1);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "RemainingControls";
-        this.Text = "RemainingControls";
-        this.Load += new System.EventHandler(this.Form1_Load);
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-    private System.Windows.Forms.HScrollBar hScrollBar1;
-    private System.Windows.Forms.VScrollBar vScrollBar1;
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-    private System.Windows.Forms.PropertyGrid propertyGrid2;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.DomainUpDown domainUpDown1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.TrackBar trackBar1;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.cs b/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.cs
deleted file mode 100644
index e0b0c6b48ff..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class RemainingControls : Form
-{
-    public RemainingControls()
-    {
-        InitializeComponent();
-    }
-
-    private void Form1_Load(object sender, EventArgs e)
-    {
-        propertyGrid1.SelectedObject = domainUpDown1;
-        propertyGrid2.SelectedObject = trackBar1;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.resx b/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/RemainingControls.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Resources/TestResult.png b/src/System.Windows.Forms/tests/AccessibilityTests/Resources/TestResult.png
deleted file mode 100644
index caa694fdb73..00000000000
Binary files a/src/System.Windows.Forms/tests/AccessibilityTests/Resources/TestResult.png and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/Student.cs b/src/System.Windows.Forms/tests/AccessibilityTests/Student.cs
deleted file mode 100644
index 1379e7ab848..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/Student.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Accessibility_Core_App;
-
-public class Student
-{
-    public Student(int studentNumber, string name, string sex)
-    {
-        StudentNumber = studentNumber;
-        Name = name;
-        Sex = sex;
-    }
-
-    public Student(int studentNumber, string name, string sex, int phoneNumber, string homeNumber, string hobby, bool isStudent, int count, int luckyNumber)
-    {
-        StudentNumber = studentNumber;
-        Name = name;
-        Sex = sex;
-        PhoneNumber = phoneNumber;
-        HomeNumber = homeNumber;
-        IsStudent = isStudent;
-        Hobby = hobby;
-        Count = count;
-        LuckyNumber = luckyNumber;
-    }
-
-    public int StudentNumber { get; set; }
-
-    public string Name { get; set; }
-
-    public string Sex { get; set; }
-
-    public int PhoneNumber { get; set; }
-
-    public string HomeNumber { get; set; }
-
-    public string Hobby { get; set; }
-
-    public bool IsStudent { get; set; }
-
-    public int Count { get; set; }
-
-    public int LuckyNumber { get; set; }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/TaskDialogTesting.cs b/src/System.Windows.Forms/tests/AccessibilityTests/TaskDialogTesting.cs
deleted file mode 100644
index 3e3773acaa3..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/TaskDialogTesting.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class TaskDialogTesting
-{
-    internal void ShowEventsDemoTaskDialog()
-    {
-        var page1 = new TaskDialogPage()
-        {
-            Caption = nameof(TaskDialogTesting),
-            Heading = "Event Demo",
-            Text = "Event Demo...",
-        };
-
-        page1.Created += (s, e) => Console.WriteLine("Page1 Created");
-        page1.Destroyed += (s, e) => Console.WriteLine("Page1 Destroyed");
-        page1.HelpRequest += (s, e) => Console.WriteLine("Page1 HelpRequest");
-
-        page1.Expander = new TaskDialogExpander("Expander")
-        {
-            Position = TaskDialogExpanderPosition.AfterFootnote
-        };
-
-        page1.Expander.ExpandedChanged += (s, e) => Console.WriteLine($"Expander ExpandedChanged: {page1.Expander.Expanded}");
-
-        var buttonOK = TaskDialogButton.OK;
-        var buttonHelp = TaskDialogButton.Help;
-        var buttonCancelClose = new TaskDialogCommandLinkButton("C&ancel Close", allowCloseDialog: false);
-        var buttonShowInnerDialog = new TaskDialogCommandLinkButton("&Show (modeless) Inner Dialog", "(and don't cancel the Close)");
-        var buttonNavigate = new TaskDialogCommandLinkButton("&Navigate", allowCloseDialog: false);
-
-        page1.Buttons.Add(buttonOK);
-        page1.Buttons.Add(buttonHelp);
-        page1.Buttons.Add(buttonCancelClose);
-        page1.Buttons.Add(buttonShowInnerDialog);
-        page1.Buttons.Add(buttonNavigate);
-
-        buttonOK.Click += (s, e) => Console.WriteLine($"Button '{s}' Click");
-        buttonHelp.Click += (s, e) => Console.WriteLine($"Button '{s}' Click");
-
-        buttonCancelClose.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-        };
-
-        buttonShowInnerDialog.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-            TaskDialog.ShowDialog(new TaskDialogPage()
-            {
-                Text = "Inner Dialog"
-            });
-            Console.WriteLine($"(returns) Button '{s}' Click");
-        };
-
-        buttonNavigate.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-
-            // Navigate to a new page.
-            var page2 = new TaskDialogPage()
-            {
-                Heading = "AfterNavigation.",
-                Buttons =
-                {
-                    TaskDialogButton.Close
-                }
-            };
-            page2.Created += (s, e) => Console.WriteLine("Page2 Created");
-            page2.Destroyed += (s, e) => Console.WriteLine("Page2 Destroyed");
-
-            page1.Navigate(page2);
-        };
-
-        page1.Verification = new TaskDialogVerificationCheckBox("&CheckBox1");
-        page1.Verification.CheckedChanged += (s, e) => Console.WriteLine($"CheckBox CheckedChanged: {page1.Verification.Checked}");
-
-        var radioButton1 = page1.RadioButtons.Add("Radi&oButton1");
-        var radioButton2 = page1.RadioButtons.Add("RadioB&utton2");
-
-        radioButton1.CheckedChanged += (s, e) => Console.WriteLine($"RadioButton1 CheckedChanged: {radioButton1.Checked}");
-        radioButton2.CheckedChanged += (s, e) => Console.WriteLine($"RadioButton2 CheckedChanged: {radioButton2.Checked}");
-
-        var dialogResult = TaskDialog.ShowDialog(page1);
-        Console.WriteLine($"---> Dialog Result: {dialogResult}");
-    }
-}
-
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.Designer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.Designer.cs
deleted file mode 100644
index 6f82e6dd89c..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.Designer.cs
+++ /dev/null
@@ -1,673 +0,0 @@
-namespace Accessibility_Core_App;
-
-partial class ToolStripContainer
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ToolStripContainer));
-        this.toolStripContainer2 = new System.Windows.Forms.ToolStripContainer();
-        this.toolStrip1 = new System.Windows.Forms.ToolStrip();
-        this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
-        this.toolStripButton1 = new System.Windows.Forms.ToolStripButton();
-        this.toolStripSplitButton1 = new System.Windows.Forms.ToolStripSplitButton();
-        this.toolStripToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.newToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.openToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.saveToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.printToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.toolStripSeparator6 = new System.Windows.Forms.ToolStripSeparator();
-        this.cutToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.copyToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.pasteToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator();
-        this.helpToolStripButton = new System.Windows.Forms.ToolStripButton();
-        this.toolStripComboBox1 = new System.Windows.Forms.ToolStripComboBox();
-        this.statusStrip1 = new System.Windows.Forms.StatusStrip();
-        this.toolStripDropDownButton1 = new System.Windows.Forms.ToolStripDropDownButton();
-        this.statusStripToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSplitButton2 = new System.Windows.Forms.ToolStripSplitButton();
-        this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel();
-        this.toolStripStatusLabel2 = new System.Windows.Forms.ToolStripStatusLabel();
-        this.menuStrip1 = new System.Windows.Forms.MenuStrip();
-        this.menuStripToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.menuStripItem1ToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.newToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator = new System.Windows.Forms.ToolStripSeparator();
-        this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-        this.printToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.printPreviewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator();
-        this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.undoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.redoToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator();
-        this.cutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.copyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.pasteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator();
-        this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.customizeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.optionsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.contentsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.indexToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.searchToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator5 = new System.Windows.Forms.ToolStripSeparator();
-        this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.button1 = new System.Windows.Forms.Button();
-        this.toolStripContainer2.ContentPanel.SuspendLayout();
-        this.toolStripContainer2.TopToolStripPanel.SuspendLayout();
-        this.toolStripContainer2.SuspendLayout();
-        this.toolStrip1.SuspendLayout();
-        this.statusStrip1.SuspendLayout();
-        this.menuStrip1.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // toolStripContainer2
-        // 
-        // 
-        // toolStripContainer2.ContentPanel
-        // 
-        this.toolStripContainer2.ContentPanel.Controls.Add(this.toolStrip1);
-        this.toolStripContainer2.ContentPanel.Controls.Add(this.statusStrip1);
-        this.toolStripContainer2.ContentPanel.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.toolStripContainer2.ContentPanel.Size = new System.Drawing.Size(486, 239);
-        this.toolStripContainer2.Location = new System.Drawing.Point(76, 44);
-        this.toolStripContainer2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.toolStripContainer2.Name = "toolStripContainer2";
-        this.toolStripContainer2.Size = new System.Drawing.Size(486, 263);
-        this.toolStripContainer2.TabIndex = 2;
-        this.toolStripContainer2.Text = "toolStripContainer2";
-        // 
-        // toolStripContainer2.TopToolStripPanel
-        // 
-        this.toolStripContainer2.TopToolStripPanel.Controls.Add(this.menuStrip1);
-        // 
-        // toolStrip1
-        // 
-        this.toolStrip1.ContextMenuStrip = this.contextMenuStrip1;
-        this.toolStrip1.Dock = System.Windows.Forms.DockStyle.Bottom;
-        this.toolStrip1.ImageScalingSize = new System.Drawing.Size(32, 32);
-        this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.toolStripButton1,
-            this.toolStripSplitButton1,
-            this.newToolStripButton,
-            this.openToolStripButton,
-            this.saveToolStripButton,
-            this.printToolStripButton,
-            this.toolStripSeparator6,
-            this.cutToolStripButton,
-            this.copyToolStripButton,
-            this.pasteToolStripButton,
-            this.toolStripSeparator7,
-            this.helpToolStripButton,
-            this.toolStripComboBox1});
-        this.toolStrip1.Location = new System.Drawing.Point(0, 200);
-        this.toolStrip1.Name = "toolStrip1";
-        this.toolStrip1.Padding = new System.Windows.Forms.Padding(0, 0, 2, 0);
-        this.toolStrip1.Size = new System.Drawing.Size(486, 39);
-        this.toolStrip1.TabIndex = 1;
-        this.toolStrip1.TabStop = true;
-        this.toolStrip1.Text = "toolStrip1";
-        // 
-        // contextMenuStrip1
-        // 
-        this.contextMenuStrip1.ImageScalingSize = new System.Drawing.Size(32, 32);
-        this.contextMenuStrip1.Name = "contextMenuStrip1";
-        this.contextMenuStrip1.Size = new System.Drawing.Size(61, 4);
-        // 
-        // toolStripButton1
-        // 
-        this.toolStripButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton1.Image")));
-        this.toolStripButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripButton1.Name = "toolStripButton1";
-        this.toolStripButton1.Size = new System.Drawing.Size(36, 36);
-        this.toolStripButton1.Text = "toolStrip_Button1";
-        // 
-        // toolStripSplitButton1
-        // 
-        this.toolStripSplitButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripSplitButton1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.toolStripToolStripMenuItem});
-        this.toolStripSplitButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripSplitButton1.Image")));
-        this.toolStripSplitButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripSplitButton1.Name = "toolStripSplitButton1";
-        this.toolStripSplitButton1.Size = new System.Drawing.Size(48, 36);
-        this.toolStripSplitButton1.Text = "toolStrip_SplitButton1";
-        // 
-        // toolStripToolStripMenuItem
-        // 
-        this.toolStripToolStripMenuItem.Name = "toolStripToolStripMenuItem";
-        this.toolStripToolStripMenuItem.Size = new System.Drawing.Size(180, 22);
-        this.toolStripToolStripMenuItem.Text = "ToolStrip";
-        // 
-        // newToolStripButton
-        // 
-        this.newToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.newToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("newToolStripButton.Image")));
-        this.newToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.newToolStripButton.Name = "newToolStripButton";
-        this.newToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.newToolStripButton.Text = "&New";
-        // 
-        // openToolStripButton
-        // 
-        this.openToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.openToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("openToolStripButton.Image")));
-        this.openToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.openToolStripButton.Name = "openToolStripButton";
-        this.openToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.openToolStripButton.Text = "&Open";
-        // 
-        // saveToolStripButton
-        // 
-        this.saveToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.saveToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("saveToolStripButton.Image")));
-        this.saveToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.saveToolStripButton.Name = "saveToolStripButton";
-        this.saveToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.saveToolStripButton.Text = "&Save";
-        // 
-        // printToolStripButton
-        // 
-        this.printToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.printToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("printToolStripButton.Image")));
-        this.printToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.printToolStripButton.Name = "printToolStripButton";
-        this.printToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.printToolStripButton.Text = "&Print";
-        // 
-        // toolStripSeparator6
-        // 
-        this.toolStripSeparator6.Name = "toolStripSeparator6";
-        this.toolStripSeparator6.Size = new System.Drawing.Size(6, 39);
-        // 
-        // cutToolStripButton
-        // 
-        this.cutToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.cutToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("cutToolStripButton.Image")));
-        this.cutToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.cutToolStripButton.Name = "cutToolStripButton";
-        this.cutToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.cutToolStripButton.Text = "C&ut";
-        // 
-        // copyToolStripButton
-        // 
-        this.copyToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.copyToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("copyToolStripButton.Image")));
-        this.copyToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.copyToolStripButton.Name = "copyToolStripButton";
-        this.copyToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.copyToolStripButton.Text = "&Copy";
-        // 
-        // pasteToolStripButton
-        // 
-        this.pasteToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.pasteToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("pasteToolStripButton.Image")));
-        this.pasteToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.pasteToolStripButton.Name = "pasteToolStripButton";
-        this.pasteToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.pasteToolStripButton.Text = "&Paste";
-        // 
-        // toolStripSeparator7
-        // 
-        this.toolStripSeparator7.Name = "toolStripSeparator7";
-        this.toolStripSeparator7.Size = new System.Drawing.Size(6, 39);
-        // 
-        // helpToolStripButton
-        // 
-        this.helpToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.helpToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("helpToolStripButton.Image")));
-        this.helpToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.helpToolStripButton.Name = "helpToolStripButton";
-        this.helpToolStripButton.Size = new System.Drawing.Size(36, 36);
-        this.helpToolStripButton.Text = "He&lp";
-        // 
-        // toolStripComboBox1
-        // 
-        this.toolStripComboBox1.AccessibleName = "ComBo_Box";
-        this.toolStripComboBox1.Items.AddRange(new object[] {
-            "1",
-            "2",
-            "3",
-            "4",
-            "5"});
-        this.toolStripComboBox1.Name = "toolStripComboBox1";
-        this.toolStripComboBox1.Size = new System.Drawing.Size(106, 23);
-        // 
-        // statusStrip1
-        // 
-        this.statusStrip1.Dock = System.Windows.Forms.DockStyle.Top;
-        this.statusStrip1.ImageScalingSize = new System.Drawing.Size(32, 32);
-        this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.toolStripDropDownButton1,
-            this.toolStripSplitButton2,
-            this.toolStripStatusLabel1,
-            this.toolStripStatusLabel2});
-        this.statusStrip1.Location = new System.Drawing.Point(0, 0);
-        this.statusStrip1.Name = "statusStrip1";
-        this.statusStrip1.Padding = new System.Windows.Forms.Padding(1, 0, 16, 0);
-        this.statusStrip1.ShowItemToolTips = true;
-        this.statusStrip1.Size = new System.Drawing.Size(486, 38);
-        this.statusStrip1.TabIndex = 0;
-        this.statusStrip1.TabStop = true;
-        this.statusStrip1.Text = "statusStrip1";
-        // 
-        // toolStripDropDownButton1
-        // 
-        this.toolStripDropDownButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripDropDownButton1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.statusStripToolStripMenuItem});
-        this.toolStripDropDownButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripDropDownButton1.Image")));
-        this.toolStripDropDownButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripDropDownButton1.Name = "toolStripDropDownButton1";
-        this.toolStripDropDownButton1.Size = new System.Drawing.Size(45, 36);
-        this.toolStripDropDownButton1.Text = "toolStripDropDownButton1";
-        // 
-        // statusStripToolStripMenuItem
-        // 
-        this.statusStripToolStripMenuItem.Name = "statusStripToolStripMenuItem";
-        this.statusStripToolStripMenuItem.Size = new System.Drawing.Size(130, 22);
-        this.statusStripToolStripMenuItem.Text = "StatusStrip";
-        // 
-        // toolStripSplitButton2
-        // 
-        this.toolStripSplitButton2.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image;
-        this.toolStripSplitButton2.Image = ((System.Drawing.Image)(resources.GetObject("toolStripSplitButton2.Image")));
-        this.toolStripSplitButton2.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStripSplitButton2.Name = "toolStripSplitButton2";
-        this.toolStripSplitButton2.Size = new System.Drawing.Size(48, 36);
-        this.toolStripSplitButton2.Text = "toolStripSplitButton2";
-        // 
-        // toolStripStatusLabel1
-        // 
-        this.toolStripStatusLabel1.Name = "toolStripStatusLabel1";
-        this.toolStripStatusLabel1.Size = new System.Drawing.Size(118, 33);
-        this.toolStripStatusLabel1.Text = "toolStripStatusLabel1";
-        this.toolStripStatusLabel1.ToolTipText = "toolStripStatusLabel1";
-        // 
-        // toolStripStatusLabel2
-        // 
-        this.toolStripStatusLabel2.Name = "toolStripStatusLabel2";
-        this.toolStripStatusLabel2.Size = new System.Drawing.Size(118, 33);
-        this.toolStripStatusLabel2.Text = "toolStripStatusLabel2";
-        this.toolStripStatusLabel2.ToolTipText = "toolStripStatusLabel2";
-        // 
-        // menuStrip1
-        // 
-        this.menuStrip1.Dock = System.Windows.Forms.DockStyle.None;
-        this.menuStrip1.ImageScalingSize = new System.Drawing.Size(32, 32);
-        this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.menuStripToolStripMenuItem,
-            this.fileToolStripMenuItem,
-            this.editToolStripMenuItem,
-            this.toolsToolStripMenuItem,
-            this.helpToolStripMenuItem});
-        this.menuStrip1.Location = new System.Drawing.Point(0, 0);
-        this.menuStrip1.Name = "menuStrip1";
-        this.menuStrip1.ShowItemToolTips = true;
-        this.menuStrip1.Size = new System.Drawing.Size(486, 24);
-        this.menuStrip1.TabIndex = 0;
-        this.menuStrip1.TabStop = true;
-        this.menuStrip1.Text = "menuStrip1";
-        // 
-        // menuStripToolStripMenuItem
-        // 
-        this.menuStripToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.menuStripItem1ToolStripMenuItem});
-        this.menuStripToolStripMenuItem.Name = "menuStripToolStripMenuItem";
-        this.menuStripToolStripMenuItem.Size = new System.Drawing.Size(74, 20);
-        this.menuStripToolStripMenuItem.Text = "MenuStrip";
-        this.menuStripToolStripMenuItem.ToolTipText = "menuStripToolStripMenuItem";
-        // 
-        // menuStripItem1ToolStripMenuItem
-        // 
-        this.menuStripItem1ToolStripMenuItem.Name = "menuStripItem1ToolStripMenuItem";
-        this.menuStripItem1ToolStripMenuItem.Size = new System.Drawing.Size(159, 22);
-        this.menuStripItem1ToolStripMenuItem.Text = "MenuStripItem1";
-        this.menuStripItem1ToolStripMenuItem.ToolTipText = "MenuStripToolStripMenuItem";
-        // 
-        // fileToolStripMenuItem
-        // 
-        this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.newToolStripMenuItem,
-            this.openToolStripMenuItem,
-            this.toolStripSeparator,
-            this.saveToolStripMenuItem,
-            this.saveAsToolStripMenuItem,
-            this.toolStripSeparator1,
-            this.printToolStripMenuItem,
-            this.printPreviewToolStripMenuItem,
-            this.toolStripSeparator2,
-            this.exitToolStripMenuItem});
-        this.fileToolStripMenuItem.Name = "fileToolStripMenuItem";
-        this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 20);
-        this.fileToolStripMenuItem.Text = "&File";
-        this.fileToolStripMenuItem.ToolTipText = "File";
-        // 
-        // newToolStripMenuItem
-        // 
-        this.newToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("newToolStripMenuItem.Image")));
-        this.newToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.newToolStripMenuItem.Name = "newToolStripMenuItem";
-        this.newToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.newToolStripMenuItem.Text = "&New";
-        // 
-        // openToolStripMenuItem
-        // 
-        this.openToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("openToolStripMenuItem.Image")));
-        this.openToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.openToolStripMenuItem.Name = "openToolStripMenuItem";
-        this.openToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.openToolStripMenuItem.Text = "&Open";
-        // 
-        // toolStripSeparator
-        // 
-        this.toolStripSeparator.Name = "toolStripSeparator";
-        this.toolStripSeparator.Size = new System.Drawing.Size(140, 6);
-        // 
-        // saveToolStripMenuItem
-        // 
-        this.saveToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("saveToolStripMenuItem.Image")));
-        this.saveToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.saveToolStripMenuItem.Name = "saveToolStripMenuItem";
-        this.saveToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.saveToolStripMenuItem.Text = "&Save";
-        // 
-        // saveAsToolStripMenuItem
-        // 
-        this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem";
-        this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.saveAsToolStripMenuItem.Text = "Save &As";
-        // 
-        // toolStripSeparator1
-        // 
-        this.toolStripSeparator1.Name = "toolStripSeparator1";
-        this.toolStripSeparator1.Size = new System.Drawing.Size(140, 6);
-        // 
-        // printToolStripMenuItem
-        // 
-        this.printToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("printToolStripMenuItem.Image")));
-        this.printToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.printToolStripMenuItem.Name = "printToolStripMenuItem";
-        this.printToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.printToolStripMenuItem.Text = "&Print";
-        // 
-        // printPreviewToolStripMenuItem
-        // 
-        this.printPreviewToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("printPreviewToolStripMenuItem.Image")));
-        this.printPreviewToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.printPreviewToolStripMenuItem.Name = "printPreviewToolStripMenuItem";
-        this.printPreviewToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.printPreviewToolStripMenuItem.Text = "Print Pre&view";
-        // 
-        // toolStripSeparator2
-        // 
-        this.toolStripSeparator2.Name = "toolStripSeparator2";
-        this.toolStripSeparator2.Size = new System.Drawing.Size(140, 6);
-        // 
-        // exitToolStripMenuItem
-        // 
-        this.exitToolStripMenuItem.Name = "exitToolStripMenuItem";
-        this.exitToolStripMenuItem.Size = new System.Drawing.Size(143, 22);
-        this.exitToolStripMenuItem.Text = "E&xit";
-        // 
-        // editToolStripMenuItem
-        // 
-        this.editToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.undoToolStripMenuItem,
-            this.redoToolStripMenuItem,
-            this.toolStripSeparator3,
-            this.cutToolStripMenuItem,
-            this.copyToolStripMenuItem,
-            this.pasteToolStripMenuItem,
-            this.toolStripSeparator4,
-            this.selectAllToolStripMenuItem});
-        this.editToolStripMenuItem.Name = "editToolStripMenuItem";
-        this.editToolStripMenuItem.Size = new System.Drawing.Size(39, 20);
-        this.editToolStripMenuItem.Text = "&Edit";
-        this.editToolStripMenuItem.ToolTipText = "Edit";
-        // 
-        // undoToolStripMenuItem
-        // 
-        this.undoToolStripMenuItem.Name = "undoToolStripMenuItem";
-        this.undoToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.undoToolStripMenuItem.Text = "&Undo";
-        // 
-        // redoToolStripMenuItem
-        // 
-        this.redoToolStripMenuItem.Name = "redoToolStripMenuItem";
-        this.redoToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.redoToolStripMenuItem.Text = "&Redo";
-        // 
-        // toolStripSeparator3
-        // 
-        this.toolStripSeparator3.Name = "toolStripSeparator3";
-        this.toolStripSeparator3.Size = new System.Drawing.Size(119, 6);
-        // 
-        // cutToolStripMenuItem
-        // 
-        this.cutToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("cutToolStripMenuItem.Image")));
-        this.cutToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.cutToolStripMenuItem.Name = "cutToolStripMenuItem";
-        this.cutToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.cutToolStripMenuItem.Text = "Cu&t";
-        // 
-        // copyToolStripMenuItem
-        // 
-        this.copyToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("copyToolStripMenuItem.Image")));
-        this.copyToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.copyToolStripMenuItem.Name = "copyToolStripMenuItem";
-        this.copyToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.copyToolStripMenuItem.Text = "&Copy";
-        // 
-        // pasteToolStripMenuItem
-        // 
-        this.pasteToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("pasteToolStripMenuItem.Image")));
-        this.pasteToolStripMenuItem.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.pasteToolStripMenuItem.Name = "pasteToolStripMenuItem";
-        this.pasteToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.pasteToolStripMenuItem.Text = "&Paste";
-        // 
-        // toolStripSeparator4
-        // 
-        this.toolStripSeparator4.Name = "toolStripSeparator4";
-        this.toolStripSeparator4.Size = new System.Drawing.Size(119, 6);
-        // 
-        // selectAllToolStripMenuItem
-        // 
-        this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem";
-        this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.selectAllToolStripMenuItem.Text = "Select &All";
-        // 
-        // toolsToolStripMenuItem
-        // 
-        this.toolsToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.customizeToolStripMenuItem,
-            this.optionsToolStripMenuItem});
-        this.toolsToolStripMenuItem.Name = "toolsToolStripMenuItem";
-        this.toolsToolStripMenuItem.Size = new System.Drawing.Size(46, 20);
-        this.toolsToolStripMenuItem.Text = "&Tools";
-        this.toolsToolStripMenuItem.ToolTipText = "Tools";
-        // 
-        // customizeToolStripMenuItem
-        // 
-        this.customizeToolStripMenuItem.Name = "customizeToolStripMenuItem";
-        this.customizeToolStripMenuItem.Size = new System.Drawing.Size(130, 22);
-        this.customizeToolStripMenuItem.Text = "&Customize";
-        // 
-        // optionsToolStripMenuItem
-        // 
-        this.optionsToolStripMenuItem.Name = "optionsToolStripMenuItem";
-        this.optionsToolStripMenuItem.Size = new System.Drawing.Size(130, 22);
-        this.optionsToolStripMenuItem.Text = "&Options";
-        // 
-        // helpToolStripMenuItem
-        // 
-        this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.contentsToolStripMenuItem,
-            this.indexToolStripMenuItem,
-            this.searchToolStripMenuItem,
-            this.toolStripSeparator5,
-            this.aboutToolStripMenuItem});
-        this.helpToolStripMenuItem.Name = "helpToolStripMenuItem";
-        this.helpToolStripMenuItem.Size = new System.Drawing.Size(44, 20);
-        this.helpToolStripMenuItem.Text = "&Help";
-        this.helpToolStripMenuItem.ToolTipText = "Help";
-        // 
-        // contentsToolStripMenuItem
-        // 
-        this.contentsToolStripMenuItem.Name = "contentsToolStripMenuItem";
-        this.contentsToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.contentsToolStripMenuItem.Text = "&Contents";
-        // 
-        // indexToolStripMenuItem
-        // 
-        this.indexToolStripMenuItem.Name = "indexToolStripMenuItem";
-        this.indexToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.indexToolStripMenuItem.Text = "&Index";
-        // 
-        // searchToolStripMenuItem
-        // 
-        this.searchToolStripMenuItem.Name = "searchToolStripMenuItem";
-        this.searchToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.searchToolStripMenuItem.Text = "&Search";
-        // 
-        // toolStripSeparator5
-        // 
-        this.toolStripSeparator5.Name = "toolStripSeparator5";
-        this.toolStripSeparator5.Size = new System.Drawing.Size(119, 6);
-        // 
-        // aboutToolStripMenuItem
-        // 
-        this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem";
-        this.aboutToolStripMenuItem.Size = new System.Drawing.Size(122, 22);
-        this.aboutToolStripMenuItem.Text = "&About...";
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(40, 369);
-        this.button1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(88, 27);
-        this.button1.TabIndex = 3;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // ToolStripContainer
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(627, 362);
-        this.Controls.Add(this.button1);
-        this.Controls.Add(this.toolStripContainer2);
-        this.MainMenuStrip = this.menuStrip1;
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "ToolStripContainer";
-        this.Text = "ToolStripContainer";
-        this.toolStripContainer2.ContentPanel.ResumeLayout(false);
-        this.toolStripContainer2.ContentPanel.PerformLayout();
-        this.toolStripContainer2.TopToolStripPanel.ResumeLayout(false);
-        this.toolStripContainer2.TopToolStripPanel.PerformLayout();
-        this.toolStripContainer2.ResumeLayout(false);
-        this.toolStripContainer2.PerformLayout();
-        this.toolStrip1.ResumeLayout(false);
-        this.toolStrip1.PerformLayout();
-        this.statusStrip1.ResumeLayout(false);
-        this.statusStrip1.PerformLayout();
-        this.menuStrip1.ResumeLayout(false);
-        this.menuStrip1.PerformLayout();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-    private System.Windows.Forms.ToolStripContainer toolStripContainer2;
-    private System.Windows.Forms.ToolStrip toolStrip1;
-    private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
-    private System.Windows.Forms.ToolStripButton toolStripButton1;
-    private System.Windows.Forms.ToolStripSplitButton toolStripSplitButton1;
-    private System.Windows.Forms.ToolStripMenuItem toolStripToolStripMenuItem;
-    private System.Windows.Forms.StatusStrip statusStrip1;
-    private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButton1;
-    private System.Windows.Forms.ToolStripMenuItem statusStripToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSplitButton toolStripSplitButton2;
-    private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1;
-    private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel2;
-    private System.Windows.Forms.MenuStrip menuStrip1;
-    private System.Windows.Forms.ToolStripMenuItem menuStripToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem menuStripItem1ToolStripMenuItem;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.ToolStripButton newToolStripButton;
-    private System.Windows.Forms.ToolStripButton openToolStripButton;
-    private System.Windows.Forms.ToolStripButton saveToolStripButton;
-    private System.Windows.Forms.ToolStripButton printToolStripButton;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator6;
-    private System.Windows.Forms.ToolStripButton cutToolStripButton;
-    private System.Windows.Forms.ToolStripButton copyToolStripButton;
-    private System.Windows.Forms.ToolStripButton pasteToolStripButton;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator7;
-    private System.Windows.Forms.ToolStripButton helpToolStripButton;
-    private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator;
-    private System.Windows.Forms.ToolStripMenuItem saveToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem saveAsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator1;
-    private System.Windows.Forms.ToolStripMenuItem printToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem printPreviewToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator2;
-    private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem undoToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem redoToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator3;
-    private System.Windows.Forms.ToolStripMenuItem cutToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem copyToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem pasteToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator4;
-    private System.Windows.Forms.ToolStripMenuItem selectAllToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem toolsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem customizeToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem optionsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem contentsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem indexToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem searchToolStripMenuItem;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator5;
-    private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox1;
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.cs b/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.cs
deleted file mode 100644
index f43e91ff7ad..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace Accessibility_Core_App;
-
-public partial class ToolStripContainer : Form
-{
-    public ToolStripContainer()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.resx b/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.resx
deleted file mode 100644
index 8eb159e0050..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/ToolStripContainer.resx
+++ /dev/null
@@ -1,363 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="toolStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <metadata name="contextMenuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>122, 17</value>
-  </metadata>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="toolStripButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripSplitButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="newToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAERSURBVDhPrZDbSgJRGIXnpewd6jXsjSQvIrwoI0RQMChU
-        0iiDPCGiE3ZCRkvR8VzTeBhnyR5/ccaZNnPhB4t9sdf6Ln5hb8QeathNJFVFKF5C8DqL4ksDVHWGDf7j
-        LHyPg6NjviSaFqlu5yQYR+KpupaIkrMknCxT3Y7v/NYYb0ITK1c3BarbWWhLQ7IR0cTKReyZ6lZ0XYei
-        ztHpK4bAc+h1FgQijzSxMptrGIxVSO0xX3AaStFki7bUMVFmaMm/eJMGfIH/MkGzLep0AXn4h/r3CJV3
-        mS9gn2bY4UY/UzQ7E9TqfeTFtnuB+XAfzSHKr11kSl/uBebDiZ89ZCst3OUkdwL28sIVsE83ock+EIQV
-        2Mz2wxeg6/UAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="openToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJHSURBVDhPxZBdSNNhFMb/F110ZZEVhVBgeeHNICiiuggp
-        olAUyyxI0oSaH1QYC3N+tKnp5ubm1JUua5uuqdNKMwr7kApFItTUkWZqVhSVYmao5Nevvy7UoYR3HXh4
-        4XCe33nOKyy3lAY7l9RWMo0O/raWXxEyo5spVYTNvOGyfIRPfW+ptOkXqaPl6T83hcRmExSdgzAz3NVm
-        YWyoYla/B+1M9JtxWLPpaH22JORIjI6gKAMB0jyEimIdo4OlbuaprwVMOOMovammpDADc34qppwUrmnl
-        5Kni3aFlFg2j3y1z5mnRTJccnNIltQhwq0jFry+mOXNtpWZWDx1Z1NhV3C3JwGFOw25SYjVe5oYhiUKd
-        HKMmwQUrMWUw/CF3NnZvvYKqUh1TvUroS3fXe7HXkwidMngTS2t5KLbregSzMY2f3Wr4qKW6LJvGR1rX
-        0MLor8OhKYTJBn/GHvvxrliCTBrsOqXIoOBHh5K+hmSq7FqmexTQHuUytkaKxuNMNgYyVneA4Qd7GKjc
-        hjLaRzxH7gIU6JIZaEvgtk1D8wsxSWecCDgNzWFMvwxm/PkhRmr3Mli1nW9lvjRdWc0Jf+/5jzRmyWmv
-        S+GOLQu6U6BFjPvqKOP1AYw88WOoZif9DgmfLVtxaj1RSLdwNvrkPCA3M54KqxrnvRia9MKcGrUrqFOt
-        5H7qKsqT1mGO9+Lqhc2ELdw+U/r0i+gVZ8hMiCDx3DHORwZyKnQ/hw/uYt9uCTskPvh6e7Fp41rWr/Fg
-        g6eHO+A/lyD8ARfG3mk9fv1YAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="saveToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIySURBVDhPrZLfS5NRGMfff6H7boIuuq2pMZyL1eAt11CW
-        DcOKsB9vpFmaLtNExco0av6CbIVLJ61Wk3BSkT/AFCkRZSpZmrmiJQ41xSaCwdfznL15XEUX0Reem5f3
-        8znnec4j/Zc8fxYGla91CS3eRTx0z6OpMYS7jmnU1X6B/VYA18snUVoyjsKCt8jLHcH5c36ouCQR2NUJ
-        1Nas4G9ZXlmFKbULh1Kf8lJxSfI+WeCCyopv6q+/h+DQ/DJ2WV5Ao1FgPegRAveDOS4oLfmq/h6dn/DH
-        4AJizD4UXJrCAUuzEDgbZrjgou2DiohshIcnQtgme5GTPYbkJKcQ1N8OckHW2REVi+RXuM8fxGaDG4oy
-        ALPZIQQ11Z+5QDk1oKJ/hjv7P2FTfCMOH3mFxMQ6IbhROYWOdrCnBI4dfwPr0V4+bRoY9UzXppMjcDdS
-        rC8hy3YhuFI2gTYf2A4Aza4f7N2/o/zaLB8qDYx6zszwr8P7k1thNFYIweXCMXgeAfedq2xxwjClZUeV
-        Jd2GtDNFETiJwfs8MBjKhMCWN8pgoLoqzE8miH1GjE7G4PsZjE7OQsm9ij2mFg7rdrug1xcJAa2l4w7W
-        r00Cgk/n38S7wBwC04u4UGxHrMHF4CbEJtyDLj5fCDIzhljfSxzeavRgyw4Zj9t64GvvQ0d3P3pfD2Kv
-        2QqNvgFxDN6urYdWmyMElJMnevh60obRktA701PRtGlg1DOdSkXwzrisaMG/RZLWAE60OMW5fNhvAAAA
-        AElFTkSuQmCC
-</value>
-  </data>
-  <data name="printToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIpSURBVDhPtZL/T1JRGMb5p1itrVZbbRpqZbawnBENV1I0
-        jGlByTSyJTXJwq2oKZQb1KAv6JCYWSxvBrkkZUq4CeQEiRABFeLL072Xa0zRra31bO8v57zP5znnPYf1
-        X+TxhWF6O7VtGYcnwbSWijKPOLzYrPSvLPwLS3huGUMlT7o9wGD9grVUBj+icdid03S9tDmgNxNwTgVQ
-        J+rA8XNtWwM+uuZATMwxmQVRycuJFNyzIRitDlScugKzjSgFRGJJaIwEsrk8AsHIhnSL/Ssck37UNipQ
-        I5DjtuYV7uksRYhr2kebhx2eP6nrycFIEh5fBA/1Nvru8q5+PDaOovK0rABwfwugWzcErfkzHhjsePL6
-        E7q1VrTdNUDcrgGvSYlDZHN5XTNOnL8BVe8AJAoNDtZfLgDu9L1BPJmikzcrk81hlRwodZJwdBXziwnI
-        OrVoaOkiT8C8hKLHBPO7CbywOaE1jeC+bhAd6meQdvZC1KoG/5IS3MZ2HObLUHZSggvkWq3wOvbWiAqA
-        VpWeyStVfCUNf3AZ4zNhfHCFMEDMgye+hYr6FrDLzxQAUuVTpr0ocn74mchg5vsKRt1RcHp2Qv9+kZ78
-        UcE17KkWFgHNN/uQzgBkGKLJPBZiecyGchjzrmFwPIF++xJUbDbUQzEacIArLpopSRSP4CUN1Obf1Abz
-        uqob5KjiXwWH/GVl5HPt5zZh37GL2H1EiF1VZ7GDI6CNW5r/TSzWbwHYL0mKJ5czAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="cutToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGDSURBVDhPrZFNSwJRGIX9NYGbFoUlFElY1EJQKEYhCJsi
-        LaVsERnRF5iCaSZJO1toCDVGFkgoFpWQWWRR2aIvUxm1BKN1wSnHCFw4TOCzue+9nPNw4eVVnav4Izzb
-        QfxeGZ5TWaxT/rK3irzmC7CsusvC1G4IkbNLboIiDieF4GGUKeTeClDpppF8eeEu2PIfwfrzizSdw3Hk
-        EnKlFpkMzV2wH77AosOFTV8A+vkl9CiHuJeLJNNZjM8tYWB0FkTvMAwmy/8ERTR6CwjlGAi1Ccence6C
-        1NsXzN4PKIxJLLgeIJ2MoXvmFraNBKK3eXZRIveJPvs7FIYniEkXZENOdE+GIZ2Ko10TwLK7tJmKmL0F
-        EEYarYM+NMnt0C1sQzpx/lcSEnZ2gcKY/gs0dlmZuWvmjjmpwA1qxVp2AWFIMAF/OAGBzMjMI7ZrtJCb
-        4Df3o4Zfxy7QrdxDRFKol5khkpR2H4qmIOzUQNBGwrsXYxccnNOQqNbQ0KGGZ+eEPVwdeLxvqqrf4wGh
-        TNAAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="copyToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHkSURBVDhPvZHfS1NhHIf3p5QypLr2D4goMwoMCi/qIugH
-        Xe1Cr7qKDIMkZixwNhfWLGWbnuki0kXKzLU023KubBNPJrbRdOzocm6e2dPOO21mMS+CHvjcvOf9PF++
-        79H9M+7RT2iRRsIi9sEAXe43yAvf2LpSHq28G9uAnytNT4jMLewtcQ2Ht2pF8ps/aOt+gccX5lxD694S
-        +1BQFD1RkN5DSFa4Z3uONKbgHE3h8KZ4OJTC1J8UiSzmfhd2uf1CoJHbyKOsZokl0kKwm+aeJaov+wjO
-        rpQkVqdXfOz0bWAcVLghfaXxkUz3y2VxvpMGSwL3uMKh+gHezSSLEnNhX23vtYzKUirDfGyFj/Iy1mdx
-        UWqR8iKhwtQLxjgH659y4EwvVXWPiwJt3/Ws+muywRrlqvkDdx3zQrCN8l1ldnEd3/QqFmkS/akHJYGS
-        zjLzOUEwEsMf+sLI2zmaOou/93pPGoM5zvk7UU7fnBKxSBPoT7SXBNW1F/9Io2lKCNTCeomUyrS8xnBA
-        wfUqyf1eP5U1ptJD/o1LzeNCsHPydtqdr6k4aiwvOHvNSya3ibU/QIdrEkvfhJislc32MfYfuV1eUGPw
-        FF7bIVJVZ0N/soPK421UHGstlFvYd/hWecF/Qqf7CR0A5wwgSQA2AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="pasteToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJSSURBVDhPtZJrSJNRGMdf6IN9KbpQn/pUEH2JIoLqQ0Zh
-        FqYZRmJG1iKmUqKyLB2pqSm6vC1Nm5GXoeatEsVJ0RASR3eNzegikRq5lrV3857Fr/d9ddlICoL+8OfA
-        Oef/e57zcIT/os7WLMw302muSGJ2689qqi7A44q8IzjtNYzarzHQm8tZtT8FmRqu6LToMxN+B8qhCbGR
-        KVcDE85ajKUaxoaryEuL4UVXIudPB5Ko2oy98xjDptXERuz3hsgAOTzlqqMk6yjdllzE90UM9Wp5azlB
-        S1kwkeG+1CSv4mmBQPThfd6Ahqq8GYB4A11yBKmaMLQxoZyLDkGjDiZOFUhUuB+FsWsUQFiArzegtlzH
-        pFjPpMPA2GA2jucx2KqWK7ZWLqO7dBGP9D5KWLbfto3eAKMhi3FHBeP9GYy9PMXos4OIrYvJrzSRbWjm
-        wuV6EnVG4tLLiEzSExGf4w0oL05nZEDPaK+akceBuO9v4uPtFUrYo6npbzhdE/QPOQmNSiPouHYOUpaf
-        gvgqA/dDf9wd63G1r2SgUlAqyyq/1anYUGfG2mdXwne7bOwJUc1AinOS+NxzBpd5HWLbUhyNPvRdF5S2
-        v05/54tbqvzBifWNHUvPOwLC4/CXwrv2HsB3+w6EwosJOB5ESeElfGpayGD1AmwlArHSm+W2PR1clToo
-        MrbT0mFTVtlbN6xFuJQar3wQz5Q9VksD+7XyPctrJdx4p5s605M5gKz8lJPSDwtGFbKboJ1blAN52vKb
-        PdXm80/AfDokTVu+8DfPXv9XCcIPTvjvLQ8YoakAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="helpToolStripButton.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIVSURBVDhPtVJNaxNRFM1PyE+Yn1AUXLjK0uWgDWQZwUUX
-        KsGFBEEcCkIwqBEpGiydsSo2kupsasdo7Yi2toh0sFZjG5JpiZo20/TpVOmH5njvm8BYahEXHji8+968
-        c+55l4n8F0zM+rhVWkHmdg29A/PoK1Yw8uIjOp/3xpvqBgrjLeilZbjNLXxZ34bwt6jexMVCGRndQenl
-        0p+NWHzPXoP3rQ3bAbQhQM0E5Np2BKprbZzrm8TIs8puE+68+r0NwwZiacCwALEBCVcAqet8JlAjk1PZ
-        JzsNJt6u4+FMS3ZmMV9mmFNAMhesbBZLC6oFdOsd8oVXocmdx018Ej9k1FgqiJ0zgS6qlR6BVI4iEFRN
-        IJlxMF/1cfTMcGiQvbskB6ZqgairJ6BCTJKYu9tlAUW1oSRsNDwfB+JXQ4PzN6s07W0ZPxDS5aSgJEFn
-        06Y9CaOqSauJRvMr9qmXQ4P8/RoWvU16eyBUEq5kbigwiKoOMTBQ0zbKlTq6TxihwejkZ1iOJwfEwmiC
-        BQ49yaW50J7Fh0xJw3IxbM3hwo2x0ICRHZzFgveTunYERK5lgo5YMxx8WPFw5Li+U8wYm66jNz+Naov+
-        Beqiao58N5NrPluoryJO0QeKU7sNGKPPazh9aRzGo/eYmVvEMk270fTlmzl2N3XW9xL/jv7iaxw7+wAH
-        E9ew//AVxE8OItv/9O/Cf0ck8gud2vKswuxNZgAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <metadata name="statusStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>277, 17</value>
-  </metadata>
-  <data name="toolStripDropDownButton1.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="toolStripSplitButton2.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG
-        YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9
-        0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw
-        bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc
-        VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9
-        c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32
-        Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo
-        mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+
-        kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D
-        TgDQASA1MVpwzwAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <metadata name="menuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>393, 17</value>
-  </metadata>
-  <data name="newToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAERSURBVDhPrZDbSgJRGIXnpewd6jXsjSQvIrwoI0RQMChU
-        0iiDPCGiE3ZCRkvR8VzTeBhnyR5/ccaZNnPhB4t9sdf6Ln5hb8QeathNJFVFKF5C8DqL4ksDVHWGDf7j
-        LHyPg6NjviSaFqlu5yQYR+KpupaIkrMknCxT3Y7v/NYYb0ITK1c3BarbWWhLQ7IR0cTKReyZ6lZ0XYei
-        ztHpK4bAc+h1FgQijzSxMptrGIxVSO0xX3AaStFki7bUMVFmaMm/eJMGfIH/MkGzLep0AXn4h/r3CJV3
-        mS9gn2bY4UY/UzQ7E9TqfeTFtnuB+XAfzSHKr11kSl/uBebDiZ89ZCst3OUkdwL28sIVsE83ock+EIQV
-        2Mz2wxeg6/UAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="openToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJHSURBVDhPxZBdSNNhFMb/F110ZZEVhVBgeeHNICiiuggp
-        olAUyyxI0oSaH1QYC3N+tKnp5ubm1JUua5uuqdNKMwr7kApFItTUkWZqVhSVYmao5Nevvy7UoYR3HXh4
-        4XCe33nOKyy3lAY7l9RWMo0O/raWXxEyo5spVYTNvOGyfIRPfW+ptOkXqaPl6T83hcRmExSdgzAz3NVm
-        YWyoYla/B+1M9JtxWLPpaH22JORIjI6gKAMB0jyEimIdo4OlbuaprwVMOOMovammpDADc34qppwUrmnl
-        5Kni3aFlFg2j3y1z5mnRTJccnNIltQhwq0jFry+mOXNtpWZWDx1Z1NhV3C3JwGFOw25SYjVe5oYhiUKd
-        HKMmwQUrMWUw/CF3NnZvvYKqUh1TvUroS3fXe7HXkwidMngTS2t5KLbregSzMY2f3Wr4qKW6LJvGR1rX
-        0MLor8OhKYTJBn/GHvvxrliCTBrsOqXIoOBHh5K+hmSq7FqmexTQHuUytkaKxuNMNgYyVneA4Qd7GKjc
-        hjLaRzxH7gIU6JIZaEvgtk1D8wsxSWecCDgNzWFMvwxm/PkhRmr3Mli1nW9lvjRdWc0Jf+/5jzRmyWmv
-        S+GOLQu6U6BFjPvqKOP1AYw88WOoZif9DgmfLVtxaj1RSLdwNvrkPCA3M54KqxrnvRia9MKcGrUrqFOt
-        5H7qKsqT1mGO9+Lqhc2ELdw+U/r0i+gVZ8hMiCDx3DHORwZyKnQ/hw/uYt9uCTskPvh6e7Fp41rWr/Fg
-        g6eHO+A/lyD8ARfG3mk9fv1YAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="saveToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIySURBVDhPrZLfS5NRGMfff6H7boIuuq2pMZyL1eAt11CW
-        DcOKsB9vpFmaLtNExco0av6CbIVLJ61Wk3BSkT/AFCkRZSpZmrmiJQ41xSaCwdfznL15XEUX0Reem5f3
-        8znnec4j/Zc8fxYGla91CS3eRTx0z6OpMYS7jmnU1X6B/VYA18snUVoyjsKCt8jLHcH5c36ouCQR2NUJ
-        1Nas4G9ZXlmFKbULh1Kf8lJxSfI+WeCCyopv6q+/h+DQ/DJ2WV5Ao1FgPegRAveDOS4oLfmq/h6dn/DH
-        4AJizD4UXJrCAUuzEDgbZrjgou2DiohshIcnQtgme5GTPYbkJKcQ1N8OckHW2REVi+RXuM8fxGaDG4oy
-        ALPZIQQ11Z+5QDk1oKJ/hjv7P2FTfCMOH3mFxMQ6IbhROYWOdrCnBI4dfwPr0V4+bRoY9UzXppMjcDdS
-        rC8hy3YhuFI2gTYf2A4Aza4f7N2/o/zaLB8qDYx6zszwr8P7k1thNFYIweXCMXgeAfedq2xxwjClZUeV
-        Jd2GtDNFETiJwfs8MBjKhMCWN8pgoLoqzE8miH1GjE7G4PsZjE7OQsm9ij2mFg7rdrug1xcJAa2l4w7W
-        r00Cgk/n38S7wBwC04u4UGxHrMHF4CbEJtyDLj5fCDIzhljfSxzeavRgyw4Zj9t64GvvQ0d3P3pfD2Kv
-        2QqNvgFxDN6urYdWmyMElJMnevh60obRktA701PRtGlg1DOdSkXwzrisaMG/RZLWAE60OMW5fNhvAAAA
-        AElFTkSuQmCC
-</value>
-  </data>
-  <data name="printToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIpSURBVDhPtZL/T1JRGMb5p1itrVZbbRpqZbawnBENV1I0
-        jGlByTSyJTXJwq2oKZQb1KAv6JCYWSxvBrkkZUq4CeQEiRABFeLL072Xa0zRra31bO8v57zP5znnPYf1
-        X+TxhWF6O7VtGYcnwbSWijKPOLzYrPSvLPwLS3huGUMlT7o9wGD9grVUBj+icdid03S9tDmgNxNwTgVQ
-        J+rA8XNtWwM+uuZATMwxmQVRycuJFNyzIRitDlScugKzjSgFRGJJaIwEsrk8AsHIhnSL/Ssck37UNipQ
-        I5DjtuYV7uksRYhr2kebhx2eP6nrycFIEh5fBA/1Nvru8q5+PDaOovK0rABwfwugWzcErfkzHhjsePL6
-        E7q1VrTdNUDcrgGvSYlDZHN5XTNOnL8BVe8AJAoNDtZfLgDu9L1BPJmikzcrk81hlRwodZJwdBXziwnI
-        OrVoaOkiT8C8hKLHBPO7CbywOaE1jeC+bhAd6meQdvZC1KoG/5IS3MZ2HObLUHZSggvkWq3wOvbWiAqA
-        VpWeyStVfCUNf3AZ4zNhfHCFMEDMgye+hYr6FrDLzxQAUuVTpr0ocn74mchg5vsKRt1RcHp2Qv9+kZ78
-        UcE17KkWFgHNN/uQzgBkGKLJPBZiecyGchjzrmFwPIF++xJUbDbUQzEacIArLpopSRSP4CUN1Obf1Abz
-        uqob5KjiXwWH/GVl5HPt5zZh37GL2H1EiF1VZ7GDI6CNW5r/TSzWbwHYL0mKJ5czAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="printPreviewToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGCSURBVDhPnZK9S0JRGMb9F1xb2gqaq6mhwCGDtvYIIyLI
-        cJOE1paoIYpMKUjFRDH87lpoakGlIZF9DA2hZJEQhJXl1xPn3HPV29WQfvBwOfA+P95zuDJ39A6/4wyl
-        YOOSMHvOcHGThuwvSKEVRvsR+pQqWD3R1pK98DUbl7Jm5hA8SfESd6S5xH5wycalrO4E0D8yWQuriLH6
-        E2xcSqlcoRJBxCpiTO5TNi4m/ZgDF4nDsOulsfujyGRzUsmWM8YqdcggKbveS3A88bEkslRye58RSzZt
-        IVarY/FFaPmlwp+fUaESYRNW5Vm3BPmpBpZNvppACDmTLbS6FbGAPFAj5OGI4PALOK/yZfIlAlk4j7n5
-        xdaCarWKj0KRXmE2+UklJEJZZ/RCPTPdWvBdLOP1rYD41QNcgRiVkKJQ1mjGsa2VNxeQb2OWDC7sh47p
-        ddQLeoyOTSFiVAAFvVhChsmv2k6Uvd3Icx1UolMNiDdpl4nhLiohW/xb0tMph2JwCJxjAz9A30JI8zYA
-        tAAAAABJRU5ErkJggg==
-</value>
-  </data>
-  <data name="cutToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAGDSURBVDhPrZFNSwJRGIX9NYGbFoUlFElY1EJQKEYhCJsi
-        LaVsERnRF5iCaSZJO1toCDVGFkgoFpWQWWRR2aIvUxm1BKN1wSnHCFw4TOCzue+9nPNw4eVVnav4Izzb
-        QfxeGZ5TWaxT/rK3irzmC7CsusvC1G4IkbNLboIiDieF4GGUKeTeClDpppF8eeEu2PIfwfrzizSdw3Hk
-        EnKlFpkMzV2wH77AosOFTV8A+vkl9CiHuJeLJNNZjM8tYWB0FkTvMAwmy/8ERTR6CwjlGAi1Ccence6C
-        1NsXzN4PKIxJLLgeIJ2MoXvmFraNBKK3eXZRIveJPvs7FIYniEkXZENOdE+GIZ2Ko10TwLK7tJmKmL0F
-        EEYarYM+NMnt0C1sQzpx/lcSEnZ2gcKY/gs0dlmZuWvmjjmpwA1qxVp2AWFIMAF/OAGBzMjMI7ZrtJCb
-        4Df3o4Zfxy7QrdxDRFKol5khkpR2H4qmIOzUQNBGwrsXYxccnNOQqNbQ0KGGZ+eEPVwdeLxvqqrf4wGh
-        TNAAAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="copyToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHkSURBVDhPvZHfS1NhHIf3p5QypLr2D4goMwoMCi/qIugH
-        Xe1Cr7qKDIMkZixwNhfWLGWbnuki0kXKzLU023KubBNPJrbRdOzocm6e2dPOO21mMS+CHvjcvOf9PF++
-        79H9M+7RT2iRRsIi9sEAXe43yAvf2LpSHq28G9uAnytNT4jMLewtcQ2Ht2pF8ps/aOt+gccX5lxD694S
-        +1BQFD1RkN5DSFa4Z3uONKbgHE3h8KZ4OJTC1J8UiSzmfhd2uf1CoJHbyKOsZokl0kKwm+aeJaov+wjO
-        rpQkVqdXfOz0bWAcVLghfaXxkUz3y2VxvpMGSwL3uMKh+gHezSSLEnNhX23vtYzKUirDfGyFj/Iy1mdx
-        UWqR8iKhwtQLxjgH659y4EwvVXWPiwJt3/Ws+muywRrlqvkDdx3zQrCN8l1ldnEd3/QqFmkS/akHJYGS
-        zjLzOUEwEsMf+sLI2zmaOou/93pPGoM5zvk7UU7fnBKxSBPoT7SXBNW1F/9Io2lKCNTCeomUyrS8xnBA
-        wfUqyf1eP5U1ptJD/o1LzeNCsHPydtqdr6k4aiwvOHvNSya3ibU/QIdrEkvfhJislc32MfYfuV1eUGPw
-        FF7bIVJVZ0N/soPK421UHGstlFvYd/hWecF/Qqf7CR0A5wwgSQA2AAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="pasteToolStripMenuItem.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAJSSURBVDhPtZJrSJNRGMdf6IN9KbpQn/pUEH2JIoLqQ0Zh
-        FqYZRmJG1iKmUqKyLB2pqSm6vC1Nm5GXoeatEsVJ0RASR3eNzegikRq5lrV3857Fr/d9ddlICoL+8OfA
-        Oef/e57zcIT/os7WLMw302muSGJ2689qqi7A44q8IzjtNYzarzHQm8tZtT8FmRqu6LToMxN+B8qhCbGR
-        KVcDE85ajKUaxoaryEuL4UVXIudPB5Ko2oy98xjDptXERuz3hsgAOTzlqqMk6yjdllzE90UM9Wp5azlB
-        S1kwkeG+1CSv4mmBQPThfd6Ahqq8GYB4A11yBKmaMLQxoZyLDkGjDiZOFUhUuB+FsWsUQFiArzegtlzH
-        pFjPpMPA2GA2jucx2KqWK7ZWLqO7dBGP9D5KWLbfto3eAKMhi3FHBeP9GYy9PMXos4OIrYvJrzSRbWjm
-        wuV6EnVG4tLLiEzSExGf4w0oL05nZEDPaK+akceBuO9v4uPtFUrYo6npbzhdE/QPOQmNSiPouHYOUpaf
-        gvgqA/dDf9wd63G1r2SgUlAqyyq/1anYUGfG2mdXwne7bOwJUc1AinOS+NxzBpd5HWLbUhyNPvRdF5S2
-        v05/54tbqvzBifWNHUvPOwLC4/CXwrv2HsB3+w6EwosJOB5ESeElfGpayGD1AmwlArHSm+W2PR1clToo
-        MrbT0mFTVtlbN6xFuJQar3wQz5Q9VksD+7XyPctrJdx4p5s605M5gKz8lJPSDwtGFbKboJ1blAN52vKb
-        PdXm80/AfDokTVu+8DfPXv9XCcIPTvjvLQ8YoakAAAAASUVORK5CYII=
-</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AccessibilityTests/app.manifest b/src/System.Windows.Forms/tests/AccessibilityTests/app.manifest
deleted file mode 100644
index 20b481712bd..00000000000
--- a/src/System.Windows.Forms/tests/AccessibilityTests/app.manifest
+++ /dev/null
@@ -1,79 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-            Specifying requestedExecutionLevel element will disable file and registry virtualization. 
-            Remove this element if your application requires this virtualization for backwards
-            compatibility.
-        -->
-        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- A list of the Windows versions that this application has been tested on
-           and is designed to work with. Uncomment the appropriate elements
-           and Windows will automatically select the most compatible environment. -->
-
-      <!-- Windows Vista -->
-      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
-
-      <!-- Windows 7 -->
-      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
-
-      <!-- Windows 8 -->
-      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
-
-      <!-- Windows 8.1 -->
-      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
-
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-
-    </application>
-  </compatibility>
-
-  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
-       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
-       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
-       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. 
-       
-       Makes the application long-path aware. See https://docs.microsoft.com/windows/win32/fileio/maximum-file-path-limitation -->
-  <!--
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-      <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
-    </windowsSettings>
-  </application>
-  -->
-
-  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>
diff --git a/src/System.Windows.Forms/tests/AxHosts/AxHosts.Designer.cs b/src/System.Windows.Forms/tests/AxHosts/AxHosts.Designer.cs
deleted file mode 100644
index f3937a76949..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/AxHosts.Designer.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace AxHosts;
-
-partial class AxHosts
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AxHosts));
-        this.axWindowsMediaPlayer1 = new AxWMPLib.AxWindowsMediaPlayer();
-        ((System.ComponentModel.ISupportInitialize)(this.axWindowsMediaPlayer1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // axWindowsMediaPlayer1
-        // 
-        this.axWindowsMediaPlayer1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.axWindowsMediaPlayer1.Enabled = true;
-        this.axWindowsMediaPlayer1.Location = new System.Drawing.Point(0, 0);
-        this.axWindowsMediaPlayer1.Name = "axWindowsMediaPlayer1";
-        this.axWindowsMediaPlayer1.OcxState = ((System.Windows.Forms.AxHost.State)(resources.GetObject("axWindowsMediaPlayer1.OcxState")));
-        this.axWindowsMediaPlayer1.Size = new System.Drawing.Size(800, 450);
-        this.axWindowsMediaPlayer1.TabIndex = 0;
-        // 
-        // AxHosts
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Controls.Add(this.axWindowsMediaPlayer1);
-        this.Name = "AxHosts";
-        this.Text = "Form1";
-        ((System.ComponentModel.ISupportInitialize)(this.axWindowsMediaPlayer1)).EndInit();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private AxWMPLib.AxWindowsMediaPlayer axWindowsMediaPlayer1;
-}
diff --git a/src/System.Windows.Forms/tests/AxHosts/AxHosts.cs b/src/System.Windows.Forms/tests/AxHosts/AxHosts.cs
deleted file mode 100644
index fa2d3595374..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/AxHosts.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.IO;
-
-namespace AxHosts;
-
-public partial class AxHosts : Form
-{
-    public AxHosts()
-    {
-        InitializeComponent();
-        axWindowsMediaPlayer1.URL = Path.GetFullPath(@"./Resources/media.mpg");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/AxHosts/AxHosts.csproj b/src/System.Windows.Forms/tests/AxHosts/AxHosts.csproj
deleted file mode 100644
index 834adc85d3d..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/AxHosts.csproj
+++ /dev/null
@@ -1,62 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net472</TargetFramework>
-    <Nullable>enable</Nullable>
-    <UseWindowsForms>true</UseWindowsForms>
-    <LangVersion>10</LangVersion>
-    <SignAssembly>true</SignAssembly>
-    <StrongNameKeyId>Open</StrongNameKeyId>
-    <ImplicitUsings>disable</ImplicitUsings>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-    <SkipResolvePackageAssets>true</SkipResolvePackageAssets>
-    <ResolveComReferenceSilent>true</ResolveComReferenceSilent>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <COMReference Include="WMPLib">
-      <VersionMinor>0</VersionMinor>
-      <VersionMajor>1</VersionMajor>
-      <Guid>6bf52a50-394a-11d3-b153-00c04f79faa6</Guid>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>false</Isolated>
-      <EmbedInteropTypes>false</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="AxWMPLib">
-      <WrapperTool>aximp</WrapperTool>
-      <VersionMinor>0</VersionMinor>
-      <VersionMajor>1</VersionMajor>
-      <Guid>6bf52a50-394a-11d3-b153-00c04f79faa6</Guid>
-      <Lcid>0</Lcid>
-      <Isolated>false</Isolated>
-      <EmbedInteropTypes>false</EmbedInteropTypes>
-    </COMReference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Content Include="..\IntegrationTests\WinformsControlsTest\Resources\media.mpg" Link="Resources\media.mpg">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Resources\" />
-  </ItemGroup>
-
-  <!--
-    This project uses the installed Framework version of CSC. Build machines uses the public release version (4.4.0.0),
-    but analyzers in the preview SDK uses 4.5.0.0, causing error CS9057 in CI build. This project is a test asset, so
-    analyzers are not necessary here. To unblock CI, we skip analyzers in the build.
-  -->
-  <Target Name="RemoveAnalyzers" BeforeTargets="CoreCompile">
-    <ItemGroup>
-      <Analyzer Remove="@(Analyzer)" />
-    </ItemGroup>
-  </Target>
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AxHosts/AxHosts.resx b/src/System.Windows.Forms/tests/AxHosts/AxHosts.resx
deleted file mode 100644
index e2c3da9bab0..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/AxHosts.resx
+++ /dev/null
@@ -1,131 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="axWindowsMediaPlayer1.OcxState" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-        AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-        LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACFTeXN0
-        ZW0uV2luZG93cy5Gb3Jtcy5BeEhvc3QrU3RhdGUBAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAuQAAAAIB
-        AAAAAQAAAAAAAAAAAAAAAKQAAAABAwAACAACAAAAAAAFAAAAAAAAAPA/AwAAAAAABQAAAAAAAAAAAAgA
-        AgAAAAAAAwABAAAACwD//wMAAAAAAAsA//8IAAIAAAAAAAMAMgAAAAsAAAAIAAoAAABmAHUAbABsAAAA
-        CwAAAAsAAAALAP//CwD//wsAAAAIAAIAAAAAAAgAAgAAAAAACAACAAAAAAAIAAIAAAAAAAsAAACvUgAA
-        gi4AAAs=
-</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/AxHosts/GlobalUsings.cs b/src/System.Windows.Forms/tests/AxHosts/GlobalUsings.cs
deleted file mode 100644
index a9d638d7a43..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System;
-global using System.Windows.Forms;
diff --git a/src/System.Windows.Forms/tests/AxHosts/Program.cs b/src/System.Windows.Forms/tests/AxHosts/Program.cs
deleted file mode 100644
index 339c1ee1474..00000000000
--- a/src/System.Windows.Forms/tests/AxHosts/Program.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace AxHosts;
-
-internal static class Program
-{
-    /// <summary>
-    ///  The main entry point for the application.
-    /// </summary>
-    [STAThread]
-    static void Main()
-    {
-        Application.EnableVisualStyles();
-        Application.SetCompatibleTextRenderingDefault(false);
-        Application.Run(new AxHosts());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButton.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButton.cs
deleted file mode 100644
index d9d1c624572..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButton.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using System.Windows.Forms;
-using System.ComponentModel;
-
-namespace TestConsole;
-
-[Designer(typeof(CustomButtonDesigner), typeof(System.ComponentModel.Design.IDesigner))]
-public class CustomButton : Button
-{
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesigner.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesigner.cs
deleted file mode 100644
index 8f1152f4c56..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesigner.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.ComponentModel.Design;
-using System.Windows.Forms.Design;
-
-namespace TestConsole;
-
-public class CustomButtonDesigner : ControlDesigner
-{
-    private DesignerActionListCollection _actionLists;
-
-    public override DesignerActionListCollection ActionLists
-    {
-        get
-        {
-            _actionLists ??= new DesignerActionListCollection
-                {
-                    new CustomButtonDesignerActionList(Component)
-                };
-
-            return _actionLists;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesignerActionList.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesignerActionList.cs
deleted file mode 100644
index 0e430af3661..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/CustomButtonDesignerActionList.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-
-namespace TestConsole;
-
-public class CustomButtonDesignerActionList : DesignerActionList
-{
-    private readonly IDesignerHost _host;
-    private readonly CustomButton _control;
-    private DesignerActionItemCollection _actonListItems;
-
-    public CustomButtonDesignerActionList(IComponent component)
-        : base(component)
-    {
-        _control = component as CustomButton;
-        _host = GetService(typeof(IDesignerHost)) as IDesignerHost;
-    }
-
-    public override DesignerActionItemCollection GetSortedActionItems()
-    {
-        _actonListItems = new DesignerActionItemCollection();
-        _actonListItems.Add(new DesignerActionHeaderItem("Change color"));
-        _actonListItems.Add(new DesignerActionVerbItem(new DesignerVerb(GetActionName(), OnColorActionClick)));
-
-        return _actonListItems;
-    }
-
-    public string Name
-    {
-        get
-        {
-            string name = string.Empty;
-            if (_control is not null)
-            {
-                CustomButton control = _control;
-                name = control.Name;
-            }
-
-            return name;
-        }
-        set
-        {
-            SetValue(nameof(Name), value);
-        }
-    }
-
-    private string GetActionName()
-    {
-        PropertyDescriptor dockProp = TypeDescriptor.GetProperties(Component)[nameof(CustomButton.BackColor)];
-        if (dockProp is not null)
-        {
-            Color backColor = (Color)dockProp.GetValue(Component);
-            if (backColor != Color.Yellow)
-            {
-                return "Make Yellow";
-            }
-            else
-            {
-                return "Turn Blue";
-            }
-        }
-
-        return null;
-    }
-
-    private void OnColorActionClick(object sender, EventArgs e)
-    {
-        if (_host is null || sender is not DesignerVerb designerVerb)
-        {
-            return;
-        }
-
-        using DesignerTransaction t = _host.CreateTransaction(designerVerb.Text);
-
-        Color backColor = _control.BackColor;
-        _control.BackColor = backColor != Color.Yellow ? Color.Yellow : Color.Blue;
-
-        t.Commit();
-    }
-
-    protected void SetValue(string propertyName, object value)
-    {
-        GetProperty(propertyName).SetValue(_control, value);
-    }
-
-    protected PropertyDescriptor GetProperty(string propertyName)
-    {
-        PropertyDescriptor pd = TypeDescriptor.GetProperties(_control)[propertyName];
-        if (pd is null)
-        {
-            throw new ArgumentException($"Property {propertyName} not found in {nameof(CustomButton)}");
-        }
-        else
-        {
-            return pd;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/DesignerActionVerbItem.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/DesignerActionVerbItem.cs
deleted file mode 100644
index fe0589dc868..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/CustomControls/DesignerActionVerbItem.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System.ComponentModel.Design;
-using System.Diagnostics;
-
-namespace TestConsole;
-
-internal class DesignerActionVerbItem : DesignerActionMethodItem
-{
-    private readonly DesignerVerb _targetVerb;
-
-    public DesignerActionVerbItem(DesignerVerb verb) : base(null, null, null)
-    {
-        Debug.Assert(verb is not null, "All callers check whether the verb is null.");
-        _targetVerb = verb;
-    }
-
-    public override string Category => "Verbs";
-
-    public override string DisplayName => _targetVerb.Text;
-
-    public override void Invoke() => _targetVerb.Invoke();
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/DemoConsole.csproj b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/DemoConsole.csproj
deleted file mode 100644
index 32197d9479c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/DemoConsole.csproj
+++ /dev/null
@@ -1,39 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>DesignSurface</AssemblyName>
-    <RootNamespace>TestConsole</RootNamespace>
-    <ApplicationIcon>painter.ico</ApplicationIcon>
-    <OutputType>WinExe</OutputType>
-    <StartupObject />
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-    <NoWarn>$(NoWarn);SA1633;CS8002</NoWarn>
-    <Copyright>Copyright © Paolo Foti 2008</Copyright>
-    <Company />
-    <Authors>Paolo Foti</Authors>
-    <PackageLicenseExpression>CPOL</PackageLicenseExpression>
-    <PackageProjectUrl>https://www.codeproject.com/Articles/24385/Have-a-Great-DesignTime-Experience-with-a-Powerful</PackageProjectUrl>
-    <SuppressLicenseValidation>true</SuppressLicenseValidation>
-    <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\..\System.Windows.Forms.Design\src\System.Windows.Forms.Design.csproj" />
-    <ProjectReference Include="..\..\..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\..\..\..\System.Drawing.Common\src\System.Drawing.Common.csproj" />
-    <ProjectReference Include="..\DesignSurfaceExt\DesignSurfaceExt.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Update="Properties\Resources.resx" Generator="ResXFileCodeGenerator" LastGenOutput="Resources.Designer.cs" />
-    <Compile Update="Properties\Resources.Designer.cs" AutoGen="True" DependentUpon="Resources.resx" DesignTime="True" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="painter.ico">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.Designer.cs
deleted file mode 100644
index fa20d617056..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.Designer.cs
+++ /dev/null
@@ -1,322 +0,0 @@
-namespace TestConsole;
-
-partial class MainForm {
-/// <summary>
-/// Required designer variable.
-/// </summary>
-private System.ComponentModel.IContainer components = null;
-
-/// <summary>
-/// Clean up any resources being used.
-/// </summary>
-/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-protected override void Dispose ( bool disposing ) {
-    if ( disposing && ( components != null ) ) {
-        components.Dispose();
-    }
-    base.Dispose ( disposing );
-}
-
-#region Windows Form Designer generated code
-
-/// <summary>
-/// Required method for Designer support - do not modify
-/// the contents of this method with the code editor.
-/// </summary>
-private void InitializeComponent() {
-    System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager( typeof( MainForm ) );
-    this.splitContainer = new System.Windows.Forms.SplitContainer();
-    this.tabControl1 = new System.Windows.Forms.TabControl();
-    this.tabPage1 = new System.Windows.Forms.TabPage();
-    this.tabPage2 = new System.Windows.Forms.TabPage();
-    this.tabPage3 = new System.Windows.Forms.TabPage();
-    this.tabPage4 = new System.Windows.Forms.TabPage();
-    this.tabPage5 = new System.Windows.Forms.TabPage();
-    this.propertyGrid = new System.Windows.Forms.PropertyGrid();
-    this.menuStrip1 = new System.Windows.Forms.MenuStrip();
-    this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemUnDo = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemReDo = new System.Windows.Forms.ToolStripMenuItem();
-    this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator();
-    this.ToolStripMenuItemCut = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemCopy = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemPaste = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemDelete = new System.Windows.Forms.ToolStripMenuItem();
-    this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator();
-    this.toolStripMenuItemTools = new System.Windows.Forms.ToolStripMenuItem();
-    this.toolStripMenuItemTabOrder = new System.Windows.Forms.ToolStripMenuItem();
-    this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-    this.ToolStripMenuItemAbout = new System.Windows.Forms.ToolStripMenuItem();
-    this.splitContainer.Panel1.SuspendLayout();
-    this.splitContainer.Panel2.SuspendLayout();
-    this.splitContainer.SuspendLayout();
-    this.tabControl1.SuspendLayout();
-    this.menuStrip1.SuspendLayout();
-    this.SuspendLayout();
-    // 
-    // splitContainer
-    // 
-    this.splitContainer.Dock = System.Windows.Forms.DockStyle.Fill;
-    this.splitContainer.Location = new System.Drawing.Point( 0, 28 );
-    this.splitContainer.Margin = new System.Windows.Forms.Padding( 4 );
-    this.splitContainer.Name = "splitContainer";
-    // 
-    // splitContainer.Panel1
-    // 
-    this.splitContainer.Panel1.BackColor = System.Drawing.SystemColors.Window;
-    this.splitContainer.Panel1.Controls.Add( this.tabControl1 );
-    // 
-    // splitContainer.Panel2
-    // 
-    this.splitContainer.Panel2.Controls.Add( this.propertyGrid );
-    this.splitContainer.Size = new System.Drawing.Size( 824, 502 );
-    this.splitContainer.SplitterDistance = 593;
-    this.splitContainer.SplitterWidth = 5;
-    this.splitContainer.TabIndex = 0;
-    // 
-    // tabControl1
-    // 
-    this.tabControl1.Controls.Add( this.tabPage1 );
-    this.tabControl1.Controls.Add( this.tabPage2 );
-    this.tabControl1.Controls.Add( this.tabPage3 );
-    this.tabControl1.Controls.Add( this.tabPage4 );
-    this.tabControl1.Controls.Add( this.tabPage5 );
-    this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
-    this.tabControl1.Location = new System.Drawing.Point( 0, 0 );
-    this.tabControl1.Name = "tabControl1";
-    this.tabControl1.SelectedIndex = 0;
-    this.tabControl1.Size = new System.Drawing.Size( 593, 502 );
-    this.tabControl1.TabIndex = 0;
-    // 
-    // tabPage1
-    // 
-    this.tabPage1.Location = new System.Drawing.Point( 4, 25 );
-    this.tabPage1.Name = "tabPage1";
-    this.tabPage1.Padding = new System.Windows.Forms.Padding( 3 );
-    this.tabPage1.Size = new System.Drawing.Size( 585, 473 );
-    this.tabPage1.TabIndex = 0;
-    this.tabPage1.Text = "tabPage1";
-    this.tabPage1.UseVisualStyleBackColor = true;
-    // 
-    // tabPage2
-    // 
-    this.tabPage2.Location = new System.Drawing.Point( 4, 25 );
-    this.tabPage2.Name = "tabPage2";
-    this.tabPage2.Padding = new System.Windows.Forms.Padding( 3 );
-    this.tabPage2.Size = new System.Drawing.Size( 585, 473 );
-    this.tabPage2.TabIndex = 1;
-    this.tabPage2.Text = "tabPage2";
-    this.tabPage2.UseVisualStyleBackColor = true;
-    // 
-    // tabPage3
-    // 
-    this.tabPage3.Location = new System.Drawing.Point( 4, 25 );
-    this.tabPage3.Name = "tabPage3";
-    this.tabPage3.Padding = new System.Windows.Forms.Padding( 3 );
-    this.tabPage3.Size = new System.Drawing.Size( 585, 473 );
-    this.tabPage3.TabIndex = 2;
-    this.tabPage3.Text = "tabPage3";
-    this.tabPage3.UseVisualStyleBackColor = true;
-    // 
-    // tabPage4
-    // 
-    this.tabPage4.Location = new System.Drawing.Point( 4, 25 );
-    this.tabPage4.Name = "tabPage4";
-    this.tabPage4.Padding = new System.Windows.Forms.Padding( 3 );
-    this.tabPage4.Size = new System.Drawing.Size( 585, 473 );
-    this.tabPage4.TabIndex = 3;
-    this.tabPage4.Text = "tabPage4";
-    this.tabPage4.UseVisualStyleBackColor = true;
-    // 
-    // tabPage5
-    // 
-    this.tabPage5.Location = new System.Drawing.Point(4, 25);
-    this.tabPage5.Name = "tabPage5";
-    this.tabPage5.Padding = new System.Windows.Forms.Padding(3);
-    this.tabPage5.Size = new System.Drawing.Size(585, 473);
-    this.tabPage5.TabIndex = 3;
-    this.tabPage5.Text = "tabPage5";
-    this.tabPage5.UseVisualStyleBackColor = true;
-    // 
-    // propertyGrid
-    // 
-    this.propertyGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-    this.propertyGrid.Location = new System.Drawing.Point( 0, 0 );
-    this.propertyGrid.Margin = new System.Windows.Forms.Padding( 4 );
-    this.propertyGrid.Name = "propertyGrid";
-    this.propertyGrid.Size = new System.Drawing.Size( 226, 502 );
-    this.propertyGrid.TabIndex = 0;
-    // 
-    // menuStrip1
-    // 
-    this.menuStrip1.Items.AddRange( new System.Windows.Forms.ToolStripItem[] {
-        this.editToolStripMenuItem,
-        this.toolStripMenuItemTools,
-        this.helpToolStripMenuItem} );
-    this.menuStrip1.Location = new System.Drawing.Point( 0, 0 );
-    this.menuStrip1.Name = "menuStrip1";
-    this.menuStrip1.Padding = new System.Windows.Forms.Padding( 8, 2, 0, 2 );
-    this.menuStrip1.Size = new System.Drawing.Size( 824, 28 );
-    this.menuStrip1.TabIndex = 1;
-    this.menuStrip1.Text = "menuStrip1";
-    // 
-    // editToolStripMenuItem
-    // 
-    this.editToolStripMenuItem.DropDownItems.AddRange( new System.Windows.Forms.ToolStripItem[] {
-        this.ToolStripMenuItemUnDo,
-        this.ToolStripMenuItemReDo,
-        this.toolStripSeparator3,
-        this.ToolStripMenuItemCut,
-        this.ToolStripMenuItemCopy,
-        this.ToolStripMenuItemPaste,
-        this.ToolStripMenuItemDelete,
-        this.toolStripSeparator4} );
-    this.editToolStripMenuItem.Name = "editToolStripMenuItem";
-    this.editToolStripMenuItem.Size = new System.Drawing.Size( 47, 24 );
-    this.editToolStripMenuItem.Text = "&Edit";
-    // 
-    // ToolStripMenuItemUnDo
-    // 
-    this.ToolStripMenuItemUnDo.Name = "ToolStripMenuItemUnDo";
-    this.ToolStripMenuItemUnDo.ShortcutKeys = ((System.Windows.Forms.Keys) ((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Z)));
-    this.ToolStripMenuItemUnDo.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemUnDo.Text = "Undo";
-    this.ToolStripMenuItemUnDo.Click += new System.EventHandler( this.undoToolStripMenuItem_Click );
-    // 
-    // ToolStripMenuItemReDo
-    // 
-    this.ToolStripMenuItemReDo.Name = "ToolStripMenuItemReDo";
-    this.ToolStripMenuItemReDo.ShortcutKeys = ((System.Windows.Forms.Keys) ((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Y)));
-    this.ToolStripMenuItemReDo.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemReDo.Text = "Redo";
-    this.ToolStripMenuItemReDo.Click += new System.EventHandler( this.redoToolStripMenuItem_Click );
-    // 
-    // toolStripSeparator3
-    // 
-    this.toolStripSeparator3.Name = "toolStripSeparator3";
-    this.toolStripSeparator3.Size = new System.Drawing.Size( 162, 6 );
-    // 
-    // ToolStripMenuItemCut
-    // 
-    this.ToolStripMenuItemCut.Image = ((System.Drawing.Image) (resources.GetObject( "ToolStripMenuItemCut.Image" )));
-    this.ToolStripMenuItemCut.ImageTransparentColor = System.Drawing.Color.Magenta;
-    this.ToolStripMenuItemCut.Name = "ToolStripMenuItemCut";
-    this.ToolStripMenuItemCut.ShortcutKeys = ((System.Windows.Forms.Keys) ((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.X)));
-    this.ToolStripMenuItemCut.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemCut.Text = "Cut";
-    this.ToolStripMenuItemCut.Click += new System.EventHandler( this.OnMenuClick );
-    // 
-    // ToolStripMenuItemCopy
-    // 
-    this.ToolStripMenuItemCopy.Image = ((System.Drawing.Image) (resources.GetObject( "ToolStripMenuItemCopy.Image" )));
-    this.ToolStripMenuItemCopy.ImageTransparentColor = System.Drawing.Color.Magenta;
-    this.ToolStripMenuItemCopy.Name = "ToolStripMenuItemCopy";
-    this.ToolStripMenuItemCopy.ShortcutKeys = ((System.Windows.Forms.Keys) ((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.C)));
-    this.ToolStripMenuItemCopy.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemCopy.Text = "Copy";
-    this.ToolStripMenuItemCopy.Click += new System.EventHandler( this.OnMenuClick );
-    // 
-    // ToolStripMenuItemPaste
-    // 
-    this.ToolStripMenuItemPaste.Image = ((System.Drawing.Image) (resources.GetObject( "ToolStripMenuItemPaste.Image" )));
-    this.ToolStripMenuItemPaste.ImageTransparentColor = System.Drawing.Color.Magenta;
-    this.ToolStripMenuItemPaste.Name = "ToolStripMenuItemPaste";
-    this.ToolStripMenuItemPaste.ShortcutKeys = ((System.Windows.Forms.Keys) ((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.V)));
-    this.ToolStripMenuItemPaste.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemPaste.Text = "Paste";
-    this.ToolStripMenuItemPaste.Click += new System.EventHandler( this.OnMenuClick );
-    // 
-    // ToolStripMenuItemDelete
-    // 
-    this.ToolStripMenuItemDelete.Name = "ToolStripMenuItemDelete";
-    this.ToolStripMenuItemDelete.ShortcutKeys = System.Windows.Forms.Keys.Delete;
-    this.ToolStripMenuItemDelete.Size = new System.Drawing.Size( 165, 24 );
-    this.ToolStripMenuItemDelete.Text = "Delete";
-    this.ToolStripMenuItemDelete.Click += new System.EventHandler( this.OnMenuClick );
-    // 
-    // toolStripSeparator4
-    // 
-    this.toolStripSeparator4.Name = "toolStripSeparator4";
-    this.toolStripSeparator4.Size = new System.Drawing.Size( 162, 6 );
-    // 
-    // toolStripMenuItemTools
-    // 
-    this.toolStripMenuItemTools.DropDownItems.AddRange( new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripMenuItemTabOrder} );
-    this.toolStripMenuItemTools.Name = "toolStripMenuItemTools";
-    this.toolStripMenuItemTools.Size = new System.Drawing.Size( 57, 24 );
-    this.toolStripMenuItemTools.Text = "&Tools";
-    // 
-    // toolStripMenuItemTabOrder
-    // 
-    this.toolStripMenuItemTabOrder.Name = "toolStripMenuItemTabOrder";
-    this.toolStripMenuItemTabOrder.Size = new System.Drawing.Size( 145, 24 );
-    this.toolStripMenuItemTabOrder.Text = "Tab Order";
-    this.toolStripMenuItemTabOrder.Click += new System.EventHandler( this.toolStripMenuItemTabOrder_Click );
-    // 
-    // helpToolStripMenuItem
-    // 
-    this.helpToolStripMenuItem.DropDownItems.AddRange( new System.Windows.Forms.ToolStripItem[] {
-        this.ToolStripMenuItemAbout} );
-    this.helpToolStripMenuItem.Name = "helpToolStripMenuItem";
-    this.helpToolStripMenuItem.Size = new System.Drawing.Size( 53, 24 );
-    this.helpToolStripMenuItem.Text = "&Help";
-    // 
-    // ToolStripMenuItemAbout
-    // 
-    this.ToolStripMenuItemAbout.Name = "ToolStripMenuItemAbout";
-    this.ToolStripMenuItemAbout.Size = new System.Drawing.Size( 128, 24 );
-    this.ToolStripMenuItemAbout.Text = "About...";
-    this.ToolStripMenuItemAbout.Click += new System.EventHandler( this.OnAbout );
-    // 
-    // MainForm
-    // 
-    this.AutoScaleDimensions = new System.Drawing.SizeF( 8F, 16F );
-    this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-    this.ClientSize = new System.Drawing.Size( 824, 530 );
-    this.Controls.Add( this.splitContainer );
-    this.Controls.Add( this.menuStrip1 );
-    this.Icon = ((System.Drawing.Icon) (resources.GetObject( "$this.Icon" )));
-    this.MainMenuStrip = this.menuStrip1;
-    this.Margin = new System.Windows.Forms.Padding( 4 );
-    this.Name = "MainForm";
-    this.Text = "Tiny Form Designer";
-    this.Load += new System.EventHandler( this.MainForm_Load );
-    this.splitContainer.Panel1.ResumeLayout( false );
-    this.splitContainer.Panel2.ResumeLayout( false );
-    this.splitContainer.ResumeLayout( false );
-    this.tabControl1.ResumeLayout( false );
-    this.menuStrip1.ResumeLayout( false );
-    this.menuStrip1.PerformLayout();
-    this.ResumeLayout( false );
-    this.PerformLayout();
-
-}
-
-#endregion
-
-private System.Windows.Forms.SplitContainer splitContainer;
-private System.Windows.Forms.PropertyGrid propertyGrid;
-private System.Windows.Forms.MenuStrip menuStrip1;
-private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemUnDo;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemReDo;
-private System.Windows.Forms.ToolStripSeparator toolStripSeparator3;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemCut;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemCopy;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemPaste;
-private System.Windows.Forms.ToolStripSeparator toolStripSeparator4;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemDelete;
-private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem;
-private System.Windows.Forms.ToolStripMenuItem ToolStripMenuItemAbout;
-private System.Windows.Forms.TabControl tabControl1;
-private System.Windows.Forms.TabPage tabPage1;
-private System.Windows.Forms.TabPage tabPage2;
-private System.Windows.Forms.TabPage tabPage3;
-private System.Windows.Forms.TabPage tabPage4;
-private System.Windows.Forms.TabPage tabPage5;
-private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemTools;
-private System.Windows.Forms.ToolStripMenuItem toolStripMenuItemTabOrder;
-
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.cs
deleted file mode 100644
index eb31dc70e49..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.cs
+++ /dev/null
@@ -1,339 +0,0 @@
-using System.Drawing;
-using System.Windows.Forms;
-using System.ComponentModel.Design;
-
-using DesignSurfaceExt;
-using Timer = System.Windows.Forms.Timer;
-
-namespace TestConsole;
-
-public partial class MainForm : Form
-{
-    ISelectionService _selectionService;
-
-    private List<IDesignSurfaceExt> _listOfDesignSurface = new();
-
-    public MainForm()
-    {
-        InitializeComponent();
-    }
-
-    private void InitFormDesigner()
-    {
-        CreateDesignSurface(1);
-        CreateDesignSurface(2);
-        CreateDesignSurface(3);
-        CreateDesignSurface(4);
-        CreateDesignSurface(5);
-
-        tabPage1.Text = "Use SnapLines";
-        tabPage2.Text = "Use Grid (Snap to the grid)";
-        tabPage3.Text = "Use Grid";
-        tabPage4.Text = "Align control by hand";
-        tabPage5.Text = "TabControl and TableLayoutPanel";
-
-        //- enable the UndoEngines
-        for (int i = 0; i < tabControl1.TabCount; i++)
-        {
-            IDesignSurfaceExt isurf = _listOfDesignSurface[i];
-            isurf.GetUndoEngineExt().Enabled = true;
-        }
-
-        //- ISelectionService
-        //- try to get a ptr to ISelectionService interface
-        //- if we obtain it then hook the SelectionChanged event
-        for (int i = 0; i < tabControl1.TabCount; i++)
-        {
-            IDesignSurfaceExt isurf = _listOfDesignSurface[i];
-            _selectionService = (ISelectionService)(isurf.GetIDesignerHost().GetService(typeof(ISelectionService)));
-            if (_selectionService is not null)
-                _selectionService.SelectionChanged += new System.EventHandler(OnSelectionChanged);
-        }
-    }
-
-    //- When the selection changes this sets the PropertyGrid's selected component
-    private void OnSelectionChanged(object sender, System.EventArgs e)
-    {
-        if (_selectionService is null)
-            return;
-
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        if (isurf is not null)
-        {
-            ISelectionService selectionService = isurf.GetIDesignerHost().GetService(typeof(ISelectionService)) as ISelectionService;
-            propertyGrid.SelectedObject = selectionService.PrimarySelection;
-        }
-    }
-
-    private void CreateDesignSurface(int n)
-    {
-        //- step.0
-        //- create a DesignSurface and put it inside a Form in DesignTime
-        DesignSurfaceExt.DesignSurfaceExt surface = new DesignSurfaceExt.DesignSurfaceExt();
-        //-
-        //-
-        //- store for later use
-        _listOfDesignSurface.Add(surface);
-        //-
-        //-
-        //- step.1
-        //- choose an alignment mode...
-        switch (n)
-        {
-            case 1:
-                surface.UseSnapLines();
-                break;
-            case 2:
-                surface.UseGrid(new System.Drawing.Size(16, 16));
-                break;
-            case 3:
-                surface.UseGridWithoutSnapping(new System.Drawing.Size(32, 32));
-                break;
-            case 4:
-                surface.UseNoGuides();
-                break;
-            case 5:
-                surface.UseNoGuides();
-                break;
-            default:
-                Console.WriteLine("Invalid selection");
-                break;
-        }
-
-        //-
-        //-
-        //- step.2
-        //- create the Root component, in these cases a Form
-        try
-        {
-            Form rootComponent = null;
-            switch (n)
-            {
-                case 1:
-                    {
-                        rootComponent = surface.CreateRootComponent<Form>(new Size(400, 400));
-                        rootComponent.BackColor = Color.Gray;
-                        rootComponent.Text = "Root Component hosted by the DesignSurface N.1";
-                        //- step.3
-                        //- create some Controls at DesignTime
-                        TextBox t1 = surface.CreateControl<TextBox>(new Size(200, 23), new Point(172, 12));
-                        Button b1 = surface.CreateControl<Button>(new Size(200, 40), new Point(172, 63));
-                        CustomButton b2 = surface.CreateControl<CustomButton>(new Size(200, 40), new Point(100, 200));
-                        b1.Text = "I'm the first Button";
-                        b2.Text = "I'm the second Button";
-                        b1.BackColor = Color.LightGray;
-                        b2.BackColor = Color.LightGreen;
-
-                        RadioButton rb1 = surface.CreateControl<RadioButton>(new Size(120, 22), new Point(12, 21));
-                        rb1.Text = "Check me!";
-                        RadioButton rb2 = surface.CreateControl<RadioButton>(new Size(120, 22), new Point(12, 50));
-                        rb2.Text = "No, check me!";
-                        rb2.Checked = true;
-
-                        Panel pnl = surface.CreateControl<Panel>(new Size(130, 100), new Point(12, 21));
-                        pnl.BackColor = Color.Aquamarine;
-                        rb1.Parent = pnl;
-                        rb2.Parent = pnl;
-
-                        Label l1 = surface.CreateControl<Label>(new Size(100, 25), new Point(12, 12));
-                        Label l2 = surface.CreateControl<Label>(new Size(120, 25), new Point(12, 12));
-                        l1.Text = "I'm the first Label";
-                        l2.Text = "I'm the second Label";
-                        l1.BackColor = Color.Coral;
-                        l2.BackColor = Color.LightGreen;
-
-                        SplitContainer sct = surface.CreateControl<SplitContainer>(new Size(400, 100), new Point(0, 0));
-                        sct.Dock = DockStyle.Bottom;
-                        sct.BackColor = Color.White;
-                        l1.Parent = sct.Panel1;
-                        l2.Parent = sct.Panel2;
-
-                        PictureBox pb1 = surface.CreateControl<PictureBox>(new Size(64, 64), new Point(24, 166));
-                        pb1.Image = new Icon("painter.ico").ToBitmap();
-
-                        ContextMenuStrip cm1 = surface.CreateComponent<ContextMenuStrip>();
-
-                        surface.CreateControl<DateTimePicker>(new Size(200, 23), new Point(172, 150));
-                    }
-
-                    break;
-                case 2:
-                    {
-                        rootComponent = surface.CreateRootComponent<Form>(new Size(640, 480));
-                        rootComponent.BackColor = Color.Yellow;
-                        rootComponent.Text = "Root Component hosted by the DesignSurface N.2";
-                        //- step.3
-                        //- create some Controls at DesignTime
-                        TextBox t1 = surface.CreateControl<TextBox>(new Size(200, 20), new Point(10, 10));
-                        Button b1 = surface.CreateControl<Button>(new Size(200, 40), new Point(10, 40));
-                        Label l1 = surface.CreateControl<Label>(new Size(200, 120), new Point(48, 100));
-                        t1.Text = "I'm a TextBox";
-                        b1.Text = "I'm a Button";
-                        b1.BackColor = Color.Coral;
-                        l1.Text = "I'm a Label";
-                        l1.BackColor = Color.Coral;
-
-                        ComboBox cb1 = surface.CreateControl<ComboBox>(new Size(200, 20), new Point(288, 16));
-                        cb1.Items.AddRange(new string[] { "a1", "b2", "c3" });
-                        cb1.SelectedIndex = 1;
-
-                        ListBox lb1 = surface.CreateControl<ListBox>(new Size(200, 130), new Point(288, 100));
-                        lb1.Items.AddRange(new string[] { "a1", "b2", "c3" });
-
-                        TreeView tv1 = surface.CreateControl<TreeView>(new Size(290, 160), new Point(20, 220));
-                    }
-
-                    break;
-                case 3:
-                    {
-                        rootComponent = surface.CreateRootComponent<Form>(new Size(800, 600));
-                        rootComponent.BackColor = Color.YellowGreen;
-                        rootComponent.Text = "Root Component hosted by the DesignSurface N.3";
-                        //- step.3
-                        //- create some Controls at DesignTime
-                        Button b1 = surface.CreateControl<Button>(new Size(200, 40), new Point(10, 10));
-                        Button b2 = surface.CreateControl<Button>(new Size(200, 40), new Point(100, 100));
-                        Button b3 = surface.CreateControl<Button>(new Size(200, 40), new Point(22, 22));
-                        b1.Text = "I'm the first Button";
-                        b2.Text = "I'm the second Button";
-                        b3.Text = "I'm the third Button (belonging to the GroupBox)";
-                        GroupBox gb = surface.CreateControl<GroupBox>(new Size(300, 180), new Point(100, 200));
-                        b3.Parent = gb;
-                        b3.BackColor = Color.LightGray;
-
-                        ListView lb1 = surface.CreateControl<ListView>(new Size(290, 160), new Point(320, 30));
-                        ImageList im1 = surface.CreateComponent<ImageList>();
-                    }
-
-                    break;
-                case 4:
-                    {
-                        rootComponent = surface.CreateRootComponent<Form>(new Size(800, 600));
-                        rootComponent.BackColor = Color.Orange;
-                        rootComponent.Text = "Root Component hosted by the DesignSurface N.4";       //- step.1
-                                                                                                     //- step.3
-                                                                                                     //- create some Controls at DesignTime
-                        Button b1 = surface.CreateControl<Button>(new Size(200, 40), new Point(10, 10));
-                        Button b2 = surface.CreateControl<Button>(new Size(200, 40), new Point(10, 60));
-                        b1.Text = "I'm the first Button";
-                        b2.Text = "I'm the second Button";
-                        b1.BackColor = Color.Gold;
-                        b2.BackColor = Color.LightGreen;
-
-                        Timer tm11 = surface.CreateComponent<Timer>();
-                        FontDialog fd1 = surface.CreateComponent<FontDialog>();
-                        PrintDialog pd1 = surface.CreateComponent<PrintDialog>();
-
-                        surface.CreateControl<MonthCalendar>(new Size(230, 170), new Point(10,110));
-                    }
-
-                    break;
-                case 5:
-                    {
-                        rootComponent = surface.CreateRootComponent<Form>(new Size(800, 600));
-                        rootComponent.BackColor = Color.Orange;
-                        rootComponent.Text = "Root Component hosted by the DesignSurface N.5";
-
-                        surface.CreateControl<TabControl>(new Size(400, 100), new Point(12, 21));
-                        surface.CreateControl<TableLayoutPanel>(new Size(290, 160), new Point(20, 150));
-                    }
-
-                    break;
-                default:
-                    Console.WriteLine("Invalid selection");
-                    break;
-            }
-
-            //-
-            //-
-            //- step.4
-            //- display the DesignSurface
-            Control view = surface.GetView();
-            if (view is null)
-                return;
-            //- change some properties
-            view.Text = $"Test Form N. {n}";
-            view.Dock = DockStyle.Fill;
-            //- Note these assignments
-            switch (n)
-            {
-                case 1:
-                    view.Parent = tabPage1;
-                    break;
-                case 2:
-                    view.Parent = tabPage2;
-                    break;
-                case 3:
-                    view.Parent = tabPage3;
-                    break;
-                case 4:
-                    view.Parent = tabPage4;
-                    break;
-                case 5:
-                    view.Parent = tabPage5;
-                    break;
-                default:
-                    Console.WriteLine("Invalid selection");
-                    break;
-            }
-        }
-        catch (Exception)
-        {
-            Console.WriteLine($"{Name} the DesignSurface N. {n} has generated errors during loading!");
-            return;
-        }
-    }
-
-    private void SelectRootComponent()
-    {
-        //- find out the DesignSurfaceExt control hosted by the TabPage
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        if (isurf is not null)
-            propertyGrid.SelectedObject = isurf.GetIDesignerHost().RootComponent;
-    }
-
-    private void undoToolStripMenuItem_Click(object sender, EventArgs e)
-    {
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        isurf?.GetUndoEngineExt().Undo();
-    }
-
-    private void redoToolStripMenuItem_Click(object sender, EventArgs e)
-    {
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        isurf?.GetUndoEngineExt().Redo();
-    }
-
-    private void OnAbout(object sender, EventArgs e)
-    {
-        MessageBox.Show("Tiny Form Designer coded by Paolo Foti", "Tiny Form Designer", MessageBoxButtons.OK, MessageBoxIcon.Question);
-    }
-
-    private void toolStripMenuItemTabOrder_Click(object sender, EventArgs e)
-    {
-        //- find out the DesignSurfaceExt control hosted by the TabPage
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        isurf?.SwitchTabOrder();
-    }
-
-    private void MainForm_Load(object sender, EventArgs e)
-    {
-        InitFormDesigner();
-
-        tabControl1.Selected += new System.Windows.Forms.TabControlEventHandler(OnTabPageSelected);
-
-        //- select into the propertygrid the current Form
-        SelectRootComponent();
-    }
-
-    private void OnTabPageSelected(object sender, TabControlEventArgs e)
-    {
-        SelectRootComponent();
-    }
-
-    private void OnMenuClick(object sender, EventArgs e)
-    {
-        IDesignSurfaceExt isurf = _listOfDesignSurface[tabControl1.SelectedIndex];
-        isurf?.DoAction((sender as ToolStripMenuItem).Text);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.resx b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.resx
deleted file mode 100644
index 067483c3b0e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/MainForm.resx
+++ /dev/null
@@ -1,595 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="menuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="ToolStripMenuItemCut.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAASdAAA
-        EnQB3mYfeAAAAYdJREFUOE+t001LQlEQBuB+TdCmRVEJRRIWtRAUlKsQhFmkpZQtIiWyAlMwP5KkXS0s
-        hLqGFkgoFqWQmaRR2qIvU7FMwWhd8JZXkFx0uVGzOcNh5jkDw6mr+++4SN7B6fbju/uQecYm6a25+/Hd
-        l2IJptWNmmJyL4DwWZwZUJbtayT8RxGqIV8oQaaaRfrxkTmw4z2G+WuKbC6PYDgOkUSJp6ccc+AgdI4l
-        uwPbHh/UCxb0S0aZN5fHTmefMTVvwfDEHIiBMegMpt8BZUShNoGQTIKQGxA8TTIHMoUPGF1vEOvTWHTc
-        gqeJQahNwLqVQiRRpIdS+XcM2l4h1t2DI3WAP7oGoSYE3kwSPQofljcqm/kxjK4SCH0OXSMetItsUC26
-        wZuOVptYhI0eEOuz1YI2gZnKBdpr6iR9V2jkKOkBQpeiCryhFFr4eioft16iU7qNho4h1Dc00QOqlRuw
-        pSSa+UawuZXdByIZsPoUaOmWwrUfowcOozlwZeto7ZXDuXvCfHV/+dGfqqrf44qgu28AAAAASUVORK5C
-        YII=
-</value>
-  </data>
-  <data name="ToolStripMenuItemCopy.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAASdAAA
-        EnQB3mYfeAAAAeJJREFUOE+lk9FPklEYxv1TSsecde0f0FpZrTbbal7URVvZuuJCr7pq2WzLNWy0iSHN
-        wtIB9qG0ltLSYRJpBomUgZPMGSyU8SmJIOiv7zssCdrAzXd77s77e5/nnPdUVR20HBPfUCWNB4QsI176
-        HB8IL/9iX2y1ubTMwx6utz0nuLhcGWIfCxT153Z26ep/g9Md4FJLZ2WIZdQnAM4QSJ/BH5Z5aH6NNClj
-        m0hgdSV4MppAPxQXCq5kil31OTx7DjLbOeSNNJFYUgBKq31glfpmN76F9QLEZHOJc73ubXQjMreln7Q+
-        DdP/du0/QIsxhmNK5mjTMJ/m43mIQcmr5t5MZVlNpFiKrPM1vIbpVVQAOqSckF+ZekUX5UjTS+ouDFLb
-        +CwPUPNupbN7k7WmEDcMX3hgXSpyIP/OsrCyhXtuA6M0g+bc4wJATqaZ/x7DF4zg8f9g/OMibb355701
-        kERriHL5fojzd2aFjNI0mjPdBUD96auUqlU/KwBZJV4skWUuvMmYV8b+Ls6jQQ81DfryO3KtfUoA/p38
-        10G37T3VJ3TlARdvukhldjANeemxz2B8MS0mq80GyySHj98rD2jQOpXbtgrVNprRnO2h5lQX1Sc7leYO
-        Dh27W3nN9/WZDnroDx0A5wwhdtmtAAAAAElFTkSuQmCC
-</value>
-  </data>
-  <data name="ToolStripMenuItemPaste.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAASdAAA
-        EnQB3mYfeAAAAlBJREFUOE+1k1lIlGEUhn/owm6KFuqqq4LoJooIqouMwixMM4zEjKyJGJUSlcnSITU1
-        RSe3SdPGyGVQc6tEUSkSIXFo13CMFonUyGmy5p9xz+Lp/z8ZbGjzpgMv5+a8z1n4Pkn6H9HZnEH7zVQa
-        yxKYF7+hMg+3ynKO4LBVMWa7xmBfNme1vuSl67hi0GNMj/sVqBon5XqmnXVMOqoxF+sYH6kgJyWKF13x
-        nD/tT7xmM7bOY4y0riY6bL8nRAWo5mlnDUUZR+m2ZCO/L2C4T89bywmaSgIJD/WmKnEVT/MkIg/v8wTU
-        VeTMAuQbGBLDSNaFoI8K5lxkEDptIDEafyJCfciPXiMAIX7enoDqUgNTci1TdhPjQ5nYn0dhrVgu1Fu+
-        jO7iRTwyegmzKp9tGz0BZlMGE/YyJgbSGH95irFnB5GbF5Nb3kqmqZELl2uJN5iJSS0hPMFIWGyWJ6C0
-        MJXRQSNjfVpGH/vjur+Jj7dXCLM7pme+4XBOMjDsIDgihYDj+jlISW4S8qs0XA99cXWsx9m2ksFySXRW
-        o/RWp5Cppp3efpsw3+2ysidIMwspzErgc88ZnO3rkFuWYq/3ov+6JMb+OvOdLy6l8wcHvW9sWHre4Rca
-        g69i3rX3AN7bdyDlX4zD/iBCMS/hU8NChioXYC2SiFZ2Vsd2T3BVmaDA3EZTh1VkVVs3rEW6lBwrHoj7
-        yu6sVQ72c+d7ltfCXH+nm5rWJ3MAdY3cpJPKCwtEE7SbgJ1bBFm9trqzu9vvspjgT3FIubZa8C/N67P9
-        regHTvjvLQ3rR38AAAAASUVORK5CYII=
-</value>
-  </data>
-  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-    <value>
-        AAABAAkAMDAQAAAAAABoBgAAlgAAACAgEAAAAAAA6AIAAP4GAAAQEBAAAAAAACgBAADmCQAAMDAAAAEA
-        CACoDgAADgsAACAgAAABAAgAqAgAALYZAAAQEAAAAQAIAGgFAABeIgAAMDAAAAEAIACoJQAAxicAACAg
-        AAABACAAqBAAAG5NAAAQEAAAAQAgAGgEAAAWXgAAKAAAADAAAABgAAAAAQAEAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAIAAAAAAAACAgACAAAAAgACAAICAAADAwMAAgICAAAAA/wAA/wAAAP//AP8A
-        AAD/AP8A//8AAP///wAiIiIiKAAAAAAAAAAAAAAAAAAAAAAAAAAiIiIiiIiIiIiIiIgIB3d3d3d3d3d3
-        d3AiIiIih///9/d3eIiAB3d//////////3AiIiIih////3d3h4gIB3d//////////3AiIiIih///9/d3
-        eIiAB3d//////////3AiIiIih////3d3h4gIB3d//////////3AiIiIih///9/d3eIiAB3d/////////
-        /3AiIiIih////3d3h4gIB3d//////////3AiIiIih///9/d3eIiAB3d//////////3AiIiIih////3d3
-        h4gIB3d//////////3AiIiIih///9/d3eIiAB3d//////////3AiIiIih////3d3h4gIB3d/////////
-        /3AiIiIih///9/d3eIiAB3d//////////3AiIiIih////3d3h4gIB3d//////////3AiIiIih///9/d3
-        eIiAB3d//////////3AiIiIih////3d3h4gIB3d3/////////3AiIiIih///9/d3eIiAB3d3////////
-        /3AiIiIoiIiIiIiIAAAAAHd3/////////3AiIiIof///9/d3h4iIAHd3/////////3AiIiIof////3d3
-        eHiAgHd3/////////3AiIiIof///9/d3h4iIAHd3/////////3AiIiIof////3d3eHiAgHd3////////
-        /3AiIiIof///9/d3h4iIAHd//////////3AiIiIiiIiIiIiIiIiIB3f//////////3AiIiIiKHRsxAED
-        d3cwB3f//////////3AiIiIiKEbMQBEHP7tzB3d//////////3AiIiIiJGzEAREHc/u3MHd3////////
-        /3AiIiIiRsxAEZEHdz+7cwd3f////////3AiIiIkbMQBmREHd/P7tzB3d////////3AiIiJGzEBxkZEH
-        d/8/s4gHd3//////93AiIiRsxAdxmREHd//zN3eAd3f/////d3AiIoeAQHdxkZEHd///h/94B3d////3
-        d3AiIPd4CHdxmREHd///+HeAAHd///93d3AigPeAKHfxkZEHd////4gAAAf///d3d3AoAAACKH/xmREH
-        d/////gAgAD//3d3d3CACAAiKP/xEREHd/////+ACIj/93d3d3CIgAIiKP/4d4gHd//////4iP//d3d3
-        d3AigCIiKP/493gHd//////////3d3d3d3AiIiIiKP/493gHd//////////wAAAAAAAiIiIiKP/4iIgH
-        d//////////4////eAIiIiIiKP/4AAAHd//////////4///3gCIiIiIiKP/4AAAHd//////////4//94
-        AiIiIiIiKP/4AAAP///////////4//eAIiIiIiIiKP/4CAgP///////////4/3gCIiIiIiIiKP/4h4cP
-        ///////////494AiIiIiIiIiKP/////////////////4eAIiIiIiIiIiKP/////////////////4gCIi
-        IiIiIiIiKIiIiIiIiIiIiIiIiIiIgiIiIiL/gAAAAAAAAP8AAAAAAAAA/wAAAAAAAAD/AAAAAAAAAP8A
-        AAAAAAAA/wAAAAAAAAD/AAAAAAAAAP8AAAAAAAAA/wAAAAAAAAD/AAAAAAAAAP8AAAAAAAAA/wAAAAAA
-        AAD/AAAAAAAAAP8AAAAAAAAA/wAAAAAAAAD/AAAAAAAAAP8AAAAAAAAA/gAAAAAAAAD+AAAAAAAAAP4A
-        AAAAAAAA/gAAAAAAAAD+AAAAAAAAAP4AAAAAAAAA/wAAAAAAAAD/gAAAAAAAAP+AAAAAAAAA/4AAAAAA
-        AAD/AAAAAAAAAP4AAAAAAAAA/AAAAAAAAAD4AAAAAAAAAPAAAAAAAAAA4AAAAAAAAADAgAAAAAAAAIGA
-        AAAAAAAAA4AAAAAAAAAHgAAAAAAAAM+AAAAAAAAA/4AAAAAAAAD/gAAAAAEAAP+AAAAAAwAA/4AAAAAH
-        AAD/gAAAAA8AAP+AAAAAHwAA/4AAAAA/AAD/gAAAAH8AAP+AAAAA/wAA/4AAAAH/AAAoAAAAIAAAAEAA
-        AAABAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAICAAIAAAACAAIAAgIAAAMDA
-        wACAgIAAAAD/AAD/AAAA//8A/wAAAP8A/wD//wAA////ACIiIiAAAAAAAAAAAAAAAAAiIiKIiIiIiIB3
-        d3d3d3dwIiIih/f3eHgAd3//////cCIiIof/d3eIgHd//////3AiIiKH9/d4eAB3f/////9wIiIih/93
-        d4iAd3//////cCIiIof393h4AHd//////3AiIiKH/3d3iIB3f/////9wIiIih/f3eHgAd3//////cCIi
-        Iof/d3eIgHd//////3AiIiKH9/d4eAB3d/////9wIiIoiIiIiAAAB3f/////cCIiKH///3d4eAd3////
-        /3AiIih/f3d3h4gHd/////9wIiIof///93h4B3//////cCIiIoiIiIiIiHf//////3AiIiKEREEDdzB3
-        f/////9wIiIiRsSRBztzB3f/////cCIiJGxBkQdztzB3f////3AiIkbEcZEHfzuIB3f///9wIihwR3GR
-        B3/zd4B3f//3cCKPgIdxkQd//4+AB3//d3AoAAKH8ZEHf//4AAD/93dwhwAij/GBB3///wCA/3d3cCgC
-        Io/4eAd////wD/d3d3AiIiKP+PgHf//////wAAAAIiIij/iIB3//////+P94AiIiIo/wAAd///////j3
-        gCIiIiKP8AAP///////4eAIiIiIij/gID///////+IAiIiIiIo////////////gCIiIiIiKIiIiIiIiI
-        iIiIIiIi/gAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD8AAAA/AAAAPwAAAD4AAAA+AAAAPgA
-        AAD4AAAA/AAAAPwAAAD8AAAA+AAAAPAAAADgAAAAwAAAAIQAAAAMAAAAnAAAAPwAAAD8AAAB/AAAA/wA
-        AAf8AAAP/AAAH/wAAD8oAAAAEAAAACAAAAABAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        gAAAAAAAAICAAIAAAACAAIAAgIAAAMDAwACAgIAAAAD/AAD/AAAA//8A/wAAAP8A/wD//wAA////ACKA
-        AAAAAAAAKH/3iAd3d3Aof/d4B3//cCh/94gHf/9wKH/3eAd//3Aod3eIB3//cIf/93eAf/9wiIiIiIB/
-        /3AihEE7B3//cCJMCROwd/9wKHB5FzsH93CIB/kX+AB3cICP+If/DwAAIo/3h///j4Iij/AH//+IIiKI
-        iIiIiIIiwAAih4AAeHiAAH//gAD/cIAAIoeAAHeIAAB//wAA/3DAACKHwAB4eIAAd/8AAP9wAAAoiMAB
-        iADAA3f/wAf/cCgAAAAwAAAAYAAAAAEACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMa
-        DQA1HBAAKysDADIpDgAzMwAALCwVADUnFAA0NRcAJycnADckJAA5NSMAMzMzAFUAAABFKBkAVSsVAE0z
-        GgBQMBsAQyYjAFUrKwBINSUAVzcnAGAwIAAxTxwAAmgDABBpDQAHcQsAF2oSAA16FAATdhYALWgdADpU
-        KgArbCIATEwAAFFDLgBkRSkAR3A4AHdgMQAFDXAADCN7ACUofgBMOnsAQkZBAH5NTABQcE4AZ3lcAFF8
-        YABmZmYAfXBnAIAAAAC/ZhkAkFY9ANZwAADgegAAgU5OAIVSUgCSX18AtFRLAIpiUgC8YlEAhll2AJhp
-        aACLanwAnWN1AKFuagC9aWYAp3RtAKNufQCleXMAsHtxAMFoTgDBbFYAyXdTAMFuZADGd2MAw3p2ABOE
-        HgAajigAI5s0ACehOwAtqEUAMaxIADKxSwA6u1YAXI5FAGGSRwBPtVUAVolrAG+RbABQrHEAPcJbAD/G
-        YABFzGYAZNV1AFbgewD1jwAA2Yc1AOeVOAD9qDEAv5FRAJWacwC/i20ArIF8ALaDdACStGUAqbVyANqR
-        QwDPiFYA0oZVAM2WWADXlFsA5JVBAO6hRwD3pkMA/7BEAP61VADTjWoA2ppjAMmHeQDFknsA2Zt5ANKq
-        cADmpG0A/7xmAOeodADtsHoA8rp6AIXNdwCwwngA/8B0AAoehQAKJYgAFCiGAAgwiwARMYkADiySAAo8
-        lwARN5kALzqLABQ9pAATQpkAPkaKAApGpAAWSKwAH1KuABlMswAXVrkAKFasAANquQBHTpUAX2KFAGhk
-        kgAeXMMAFGzIACBjygA7a8IANHbHACNr0gAkdtoAJn7iAIR4igCqeIgAwX6BAAAAAABinIMAZ6qHAHSL
-        swAxg88AKILnAC2L8QAwkfcACrb1AC6y5wBNjdUAaYLAAEiX7gAAy/4AFdD/ACbS/gAz1f8AU9v+AHfj
-        /wCRh4AApoyEALOIhQC1k4sAqpqQALqwhwC2orQAxoaFAMmZhQDZmIoAyZiRANCdlQD8nZ0A2aaFAMqk
-        lADTppYA2LKZAOOthwDnsokA8rmFAOCskAD/oJ8A67eQAPC2kADUpqUAzLOpANW5qQDZubQA/ainAOO6
-        oQD4sasA47yzAP2zswC5yIAA+cWLAOrDmwD5xZUA99WZANvFrgDow6gA98ymAO3QrwD906kA6M22APjK
-        uQDq07gA/dm3APzptwCuusQAkef+ALHt/gDNzc0A1dXVAObLygD+y8cA7dXBAPzXxQDo2NMA/NzUAP7j
-        yAD988IA6+TdAP7r1wDP9f4A5+flAPPs5gD98ucA6fr/AP37+QAAAAAABBR5ABMQbQACBm0AAQEBAQEB
-        AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
-        AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBATAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw
-        MDAwMDAwAQEBAQEBAQEBAQEBOTk5ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODg4ODc3LDcwAQEBAQEB
-        AQEBAQEBOezt7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t7e3t2zcwAQEBAQEwMDABAQEBOer19fLy
-        8vLy8vLy8uXl5eXl5eXl5eXl4eHh4eHh4eHf7TgwAQEBATC3tzEwAQEBOer19fXy8vLy8vLy8vLy5eXl
-        5eXl5eXl5eHh4eHh4eHf7TgwAQEBMLemWlgtAQEBPur19fX18vLy8vLy8vLy8uXl5eXl5eXl5eXh4eHh
-        4eHf7TgwAQEwt6ZRTh0fAQEBPuv19fX19fLy8vLy8vLy8vLl5eXl5eXl5eXl4eHh4eHh7TgwATC3plFO
-        HRkcAQEBPuv19fX19fXy8vLy8vLy8vLy5eXl5eXl5eXl5eHh4eHh7TgwMLdaT04dGRkBAQEBPuv19fX1
-        9fX19fLy8vLy8vLy8uXl5eXl5eXl5eXh4eHhzTgwt1pPTh0ZGQEBAQEBPuv19fX19fX19fXy8vLy8vLy
-        8vLl5eXl5eXl5eXl4eF+ez63VE9OGRkZAQEBAQEBPuv19fX19fX19fX18vLy8vLy8vLy5eXl5eXl5eXl
-        4X17el1TT04ZGRkBAQEBAQEBPuv59fX19fX19fX19fLy8vLy8vLy8uXl5eXl5eXbfXtqXVNPHRkZGQEB
-        AQEBAQEBQ+v5+fn19fX19fX19fXy8vLy8vLy8vLl5eXl5c19e4BdU08dGRkZAQEBAQEBAQEBQ+v5+fn5
-        9fX19fX19fX18vLy8vLy8vLy5eXlfn19Xl1TTx0ZGRkBAQEBAQEBAQEBQ+v5+fn5+fX19fX19fX19fLy
-        8vLy8vLy8uF+fWpfXFNPHRkZIQEBAQEBAQEBAQEBRuv5+fn5+fn19fX19fX19fXy8vLy8vLf2359al9c
-        U08dGRkhAQEBAQEBAQEBAQEBRuv5+fn5+fn59fX19fX19fX18vLy8uV+fn2AXVxRTh0ZGR8wAQEBAQEB
-        AQEBAQEBaOv5+fn5+fn5+fX19fX19fX19fLy335+SUleVFFOHRkZJT4wAQEBAQEBAQEBAQEBaPf5+fn5
-        +fn5+fn19fX19fX19eXKfn51bW9vUU4dGRlW1z4wAQEBAQEBAQEBAQEBaPf5+fn5+fn5+fn59fX19fXy
-        28p+fUy/3ubhZB0ZGVbt1z4wAQEBAQEBAQEBAQEBaPf7+/n5+fn5+fn5+fX19d/Kyn53vtL1z8jhbyYZ
-        auXt1z4wAQEBAQEBAQEBAQEBd/f7+/v5+fn5+fn5+fnyysrKeb7P9dJMOjptSTq88vLt0z4wAQEBAQEB
-        AQEBAQEBd/f7+/v7+fn5+fn59dvKysl3z/Dsvjo8Okc8PNTy8vLt0z4wAQEBAQEBAQEBAQEBd/f7+/v7
-        +/n5+fnl28rKecLs8L9JSUlJSTx38vLy8vLt0z4wAQEBAQEBAQEBAQEBePf7+/v7+/v59dvbyr8ovfDP
-        d29vb21JPHfy8vLy8vLt0z4wAQEBAQEBAQEBAQEBePf7+/v7+/nl29vKlyeHKEy+vkzUfW08d/X18vLy
-        8vLt00UwAQEBAQEBAQEBAQEBePf7+/v79eHb27qHhIknJydMvkJM3jx39fX19fLy8vLt00UwAQEBAQEB
-        AQEBAQEBwPf7+/v75dvbmIWNhIqEJycnokxMQnf19fX19fXy8vLt00UwAQEBAQEBAQEBAQEBwPf7+/v7
-        +cWWi4uNm5uQhCcnhblCd/X19fX19fX18vLt00UwAQEBAQEBAQEBAQEBwPf7+/v76J2WlpSrqp+akISQ
-        hSei+fX19fX19fX19fLt00UwAQEBAQEBAQEBAQEBxPj7+/v2sayUkJufqqupk5qQhJj5+fn19fX19fX1
-        9fXt00UwAQEBAQEBAQEBAQEBxPv7+/u0sbGsj4+Tn6qqqp+Tr/n5+fn59fX19fX19fXt00UwAQEBAQEB
-        AQEBAQEBxPv7+/axsbGxsZWJk5+pq6uw+fn5+fn5+fX19fX19fXtw0UwAQEBAQEBAQEBAQEByPv7+7Sx
-        sbGxsbGsiZCan7D7+fn5+fn5+fn19fX19fXtw0UwAQEBAQEBAQEBAQEByPv7+7GxsbGxsbGxsZWPnfv7
-        +fn5+fn5+fn19fX19fXtw0UwAQEBAQEBAQEBAQEByPv79rGxsbGxsbGxsbGt+/v7+/n5+fn5+fn59fX1
-        9fXtw0UwAQEBAQEBAQEBAQEByfv79rGxsbGxsbGxtbP7+/v7+/n5+fn5+fn519fX09PTw7kwAQEBAQEB
-        AQEBAQEByfv79rGxsbGxsbSx+/v7+/v7+/v5+fn5+fm+ubm5ubm5Qz4wAQEBAQEBAQEBAQEBzfv7+7Gx
-        sbK1tvv7+/v7+/v7+/v7+fn5+flDdGBgYDY1Mz4BAQEBAQEBAQEBAQEBzfv7+7Kxsenotvv7+/v7+/v7
-        +/v7+/n5+flD23RjY2NrPgEBAQEBAQEBAQEBAQEBzfv7+7Wx+/v29vv7+/v7+/v7+/v7+/v5+flD4XR0
-        Y2s+AQEBAQEBAQEBAQEBAQEB2/v7++i0+/v7+/v7+/v7+/v7+/v7+/v7+flG5nx0bz4BAQEBAQEBAQEB
-        AQEBAQEB2/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/lG5nx2RQEBAQEBAQEBAQEBAQEBAQEB2/v7+/v7
-        +/v7+/v7+/v7+/v7+/v7+/v7+/to5n1FAQEBAQEBAQEBAQEBAQEBAQEB2/v7+/v7+/v7+/v7+/v7+/v7
-        +/v7+/j4+Pho5T4BAQEBAQEBAQEBAQEBAQEBAQEB2+Xl4eHf39/e3tTU1NTUx8fHx8bGxcXFxcFougEB
-        AQEBAQEBAQEBAQEBAQEBAQEB////////AAD///////8AAIAAAAAP/wAAAAAAAA//AAAAAAAAD48AAAAA
-        AAAPBwAAAAAAAA4HAAAAAAAADAcAAAAAAAAIBwAAAAAAAAAPAAAAAAAAAB8AAAAAAAAAPwAAAAAAAAB/
-        AAAAAAAAAP8AAAAAAAAB/wAAAAAAAAP/AAAAAAAAB/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAA
-        AAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAP/wAAAAAAAA//
-        AAAAAAAAD/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAA
-        AAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAH/8AAAAAAAA//wAAAAAAAH//
-        AAAAAAAA//8AAAAAAAH//wAAAAAAA///AAAAAAAH//8AAAAAAA///wAAKAAAACAAAABAAAAAAQAIAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMxoNADUcEAArKwMAMikOADMzAAAsLBUANScUADQ1
-        FwAnJycANyQkADk1IwAzMzMAVQAAAEUoGQBVKxUATTMaAFAwGwBDJiMAVSsrAEg1JQBXNycAYDAgADFP
-        HAACaAMAEGkNAAdxCwAXahIADXoUABN2FgAtaB0AOlQqACtsIgBMTAAAUUMuAGRFKQBHcDgAd2AxAAUN
-        cAAMI3sAJSh+AEw6ewBCRkEAfk1MAFBwTgBneVwAUXxgAGZmZgB9cGcAgAAAAL9mGQCQVj0A1nAAAOB6
-        AACBTk4AhVJSAJJfXwC0VEsAimJSALxiUQCGWXYAmGloAItqfACdY3UAoW5qAL1pZgCndG0Ao259AKV5
-        cwCwe3EAwWhOAMFsVgDJd1MAwW5kAMZ3YwDDenYAE4QeABqOKAAjmzQAJ6E7AC2oRQAxrEgAMrFLADq7
-        VgBcjkUAYZJHAE+1VQBWiWsAb5FsAFCscQA9wlsAP8ZgAEXMZgBk1XUAVuB7APWPAADZhzUA55U4AP2o
-        MQC/kVEAlZpzAL+LbQCsgXwAtoN0AJK0ZQCptXIA2pFDAM+IVgDShlUAzZZYANeUWwDklUEA7qFHAPem
-        QwD/sEQA/rVUANONagDammMAyYd5AMWSewDZm3kA0qpwAOakbQD/vGYA56h0AO2wegDyunoAhc13ALDC
-        eAD/wHQACh6FAAoliAAUKIYACDCLABExiQAOLJIACjyXABE3mQAvOosAFD2kABNCmQA+RooACkakABZI
-        rAAfUq4AGUyzABdWuQAoVqwAA2q5AEdOlQBfYoUAaGSSAB5cwwAUbMgAIGPKADtrwgA0dscAI2vSACR2
-        2gAmfuIAhHiKAKp4iADBfoEAAAAAAGKcgwBnqocAdIuzADGDzwAogucALYvxADCR9wAKtvUALrLnAE2N
-        1QBpgsAASJfuAADL/gAV0P8AJtL+ADPV/wBT2/4Ad+P/AJGHgACmjIQAs4iFALWTiwCqmpAAurCHALai
-        tADGhoUAyZmFANmYigDJmJEA0J2VAPydnQDZpoUAyqSUANOmlgDYspkA462HAOeyiQDyuYUA4KyQAP+g
-        nwDrt5AA8LaQANSmpQDMs6kA1bmpANm5tAD9qKcA47qhAPixqwDjvLMA/bOzALnIgAD5xYsA6sObAPnF
-        lQD31ZkA28WuAOjDqAD3zKYA7dCvAP3TqQDozbYA+Mq5AOrTuAD92bcA/Om3AK66xACR5/4Ase3+AM3N
-        zQDV1dUA5svKAP7LxwDt1cEA/NfFAOjY0wD83NQA/uPIAP3zwgDr5N0A/uvXAM/1/gDn5+UA8+zmAP3y
-        5wDp+v8A/fv5AAAAAADp+v8A/fv5AAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
-        MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDABAQEBAQEBAcDGxsbCwsLBwcHBwcHBwcHBwcHBwcHAMAEBAQEB
-        AQEB0PXx7+/v7+/v7+/v7+/v7+/v7+/v28AwAQEBMDAwAQHQ9fXy8vLy8vLy5eXl5eXh4eHh4dvlwDAB
-        ATBZLTABAdD19fXy8vLy8vLy5eXl5eXh4eHh4eXAMAEwWk4ZLgEB0PX19fXy8vLy8vLy5eXl5eXh4eHh
-        5bgwMFJNGSEBAQHR+PX19fXy8vLy8vLy5eXl5eXh4eHOfaZRTRkhAQEBAdH59fX19fXy8vLy8vLy5eXl
-        5eXhfXpdUB4eIQEBAQEB0vn59fX19fXy8vLy8vLy5eXl4X1qXVAdGSEBAQEBAQHS+fn59fX19fXy8vLy
-        8vLy5d99gF1QHholAQEBAQEBAd35+fn59fX19fXy8vLy8u/bel5UTx4eIQEBAQEBAQEB3fv5+fn59fX1
-        9fXy8vLhfdhfVE8ZGVkwAQEBAQEBAQHd+/n5+fn59fX19fXy231JbVdPHh5luDABAQEBAQEBAd37+fn5
-        +fn59fX15cp9TM/mbh4e3eXAMAEBAQEBAQEB3fv7+fn5+fn59d/Kec/svktvNN3y5cAwAQEBAQEBAQHi
-        +/v7+fn5+e/KyMLszzw6R0jl8vLlwDABAQEBAQEBAeL7+/v7+fXbyj/s0nVtSUg88vLy8uXAMAEBAQEB
-        AQEB4vv7+/nl27goKEDBTMZtSPLy8vLy5cAwAQEBAQEBAQHi+/v728aOh4aEJz1Mvkj19fXy8vLlwDAB
-        AQEBAQEBAeL7+/vni4uRm4onhCpL9fX19fXy8uXAMAEBAQEBAQEB7vv76KyWlKmrnpOIKfX59fX19fXy
-        5cAwAQEBAQEBAQHu+/qxsbGPk6CrqZz4+fn59fX19fXlwDABAQEBAQEBAe776bGxsbGaj5qw+fn5+fn5
-        9fX19eXAMAEBAQEBAQEB7/u1sbGxsbGsrvv7+fn5+fnx8e3t5cAwAQEBAQEBAQHv+7OxsbGxsbH7+/v7
-        +fn5+e/X18PDwDABAQEBAQEBAe/7tLGxsunp+/v7+/v7+fn5zXFiYWF4MAEBAQEBAQEB8vu2sba2+/v7
-        +/v7+/v7+fnafGNjbzABAQEBAQEBAQHy+/a0+/r7+/v7+/v7+/v7+d7ZdHowAQEBAQEBAQEBAfL7+/v7
-        +/v7+/v7+/v7+/v54tx6MAEBAQEBAQEBAQEB9fv7+/v7+/v7+/v7+/v7+/nixzABAQEBAQEBAQEBAQHh
-        5eXl5eXi4t7e3t7e3tTU0d67AQEBAQEBAQEBAQEB/////8AAAH+AAAB/gAAAcYAAAGGAAABBgAAAA4AA
-        AAeAAAAPgAAAH4AAAD+AAAB/gAAAf4AAAH+AAAB/gAAAf4AAAH+AAAB/gAAAf4AAAH+AAAB/gAAAf4AA
-        AH+AAAB/gAAAf4AAAH+AAAB/gAAA/4AAAf+AAAP/gAAH/4AAD/8oAAAAEAAAACAAAAABAAgAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzGg0ANRwQACsrAwAyKQ4AMzMAACwsFQA1JxQANDUXACcn
-        JwA3JCQAOTUjADMzMwBVAAAARSgZAFUrFQBNMxoAUDAbAEMmIwBVKysASDUlAFc3JwBgMCAAMU8cAAJo
-        AwAQaQ0AB3ELABdqEgANehQAE3YWAC1oHQA6VCoAK2wiAExMAABRQy4AZEUpAEdwOAB3YDEABQ1wAAwj
-        ewAlKH4ATDp7AEJGQQB+TUwAUHBOAGd5XABRfGAAZmZmAH1wZwCAAAAAv2YZAJBWPQDWcAAA4HoAAIFO
-        TgCFUlIAkl9fALRUSwCKYlIAvGJRAIZZdgCYaWgAi2p8AJ1jdQChbmoAvWlmAKd0bQCjbn0ApXlzALB7
-        cQDBaE4AwWxWAMl3UwDBbmQAxndjAMN6dgAThB4AGo4oACObNAAnoTsALahFADGsSAAysUsAOrtWAFyO
-        RQBhkkcAT7VVAFaJawBvkWwAUKxxAD3CWwA/xmAARcxmAGTVdQBW4HsA9Y8AANmHNQDnlTgA/agxAL+R
-        UQCVmnMAv4ttAKyBfAC2g3QAkrRlAKm1cgDakUMAz4hWANKGVQDNllgA15RbAOSVQQDuoUcA96ZDAP+w
-        RAD+tVQA041qANqaYwDJh3kAxZJ7ANmbeQDSqnAA5qRtAP+8ZgDnqHQA7bB6APK6egCFzXcAsMJ4AP/A
-        dAAKHoUACiWIABQohgAIMIsAETGJAA4skgAKPJcAETeZAC86iwAUPaQAE0KZAD5GigAKRqQAFkisAB9S
-        rgAZTLMAF1a5AChWrAADarkAR06VAF9ihQBoZJIAHlzDABRsyAAgY8oAO2vCADR2xwAja9IAJHbaACZ+
-        4gCEeIoAqniIAMF+gQAAAAAAYpyDAGeqhwB0i7MAMYPPACiC5wAti/EAMJH3AAq29QAusucATY3VAGmC
-        wABIl+4AAMv+ABXQ/wAm0v4AM9X/AFPb/gB34/8AkYeAAKaMhACziIUAtZOLAKqakAC6sIcAtqK0AMaG
-        hQDJmYUA2ZiKAMmYkQDQnZUA/J2dANmmhQDKpJQA06aWANiymQDjrYcA57KJAPK5hQDgrJAA/6CfAOu3
-        kADwtpAA1KalAMyzqQDVuakA2bm0AP2opwDjuqEA+LGrAOO8swD9s7MAuciAAPnFiwDqw5sA+cWVAPfV
-        mQDbxa4A6MOoAPfMpgDt0K8A/dOpAOjNtgD4yrkA6tO4AP3ZtwD86bcArrrEAJHn/gCx7f4Azc3NANXV
-        1QDmy8oA/svHAO3VwQD818UA6NjTAPzc1AD+48gA/fPCAOvk3QD+69cAz/X+AOfn5QDz7OYA/fLnAOn6
-        /wD9+/kAAAAAAOn6/wD9+/kAAAAAAAEwMDAwMDAwMDAwMDABAQFDxsbGxsXBwcHBurkwMDABaPDy8vLl
-        5eXh4ePUMFguAWjw9fLy8uXl5eHjeloeLQF39PX18vLy5eXbelIeLQEBePT19fXy8uXbaVAZJQEBAb/3
-        +fX19fLJalAZ4zABAQHE+Pn59eV5wtof3eMwAQEBxPn58snGwkhL7+/jMAEBAcT75aGERExL8vLv4zAB
-        AQHE+6eUm4M99fX17+MwAQEBxOixmqmu+Pn19e3jMAEBAcS0sbGt+/n57+/VwTABAQHEsbXp+/v7+3Jy
-        cDABAQEBxOj7+/v7+/vEfzABAQEBAcTExMTExMTExDABAQEBAQGAB/n1AAH19QAB8vIAAfLlAAPl5QAH
-        el0ABx4hAAcBAQAH+fkAB/X1AAfy8gAH8vIAB+XhAA9dUAAfIQEAPwEBKAAAADAAAABgAAAAAQAgAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMa
-        DRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQzGg0UMRgMFTMa
-        DRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQzGg0UMxoNFDMaDRQ5HA4SNxISDisrAAYAAAACAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzGg1QMxoNUDMaDVAzGg1QMxoNUDMa
-        DVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMa
-        DVAzGg1QMhwNUTMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDQaDU80HA5JMxwONzMf
-        ChkrKwAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzGg2vMxoNrzMa
-        Da8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMa
-        Da8zGg2vMxoNrzMaDbA0HA+yMxoNsDMaDbAzGg2wMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMa
-        Da4yGw2iMxoNeDMcDjc3EhIOAAAAAQAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAgAAAAEAAAABAAAAAJJf
-        X/+QXV3/j1xc/45bW/+NWlr/jFlZ/4tYWP+JVlb/h1RU/4dUVP+GU1P/hFFR/4NQUP+DUFD/g1BQ/4NQ
-        UP+DUFD/g1BQ/4NQUP+DUFD/g1BQ/4NQUP+DUFD/g1BQ/4NQUP+DUFD/g1BQ/4NQUP+DUFD/g1BQ/4NQ
-        UP+CT0//gE1N/39MTP+ATU3/MxsNoTQYDko5HA4SAAAAAgAAAAFVVQADSUkkBzckJA45KxwSORwOEjsn
-        FA0rKysGAAAAApRhYf/yzMz//8zM///MzP//zMz//8zM///MzP//zMz//8zM///MzP//zMz//8zM///M
-        zP//zMz//8zM///MzP//zMz//8zM///MzP//zMz//8zM///MzP//zMz//8zM///MzP//zMz//8zM///M
-        zP//zMz//8zM///MzP//zMz//8zM///Mmf+BT0//MxoNrjQaDU8zGg0UAAAAAzMzMwVERDMPOjMkIzgr
-        Hjs0IxVJNiASRzQmEzYxJxQaQCAgCJRhYf/MzMz//+nT///o0f//58///+bO///lzP//5Mr//+PI///j
-        xv//4sT//+HD///gwf//37///969///cuv//3bz//926///cuP//27b//9q1///Zsv//2LH//9ev///W
-        rf//1az//9Sq///TqP//06b//9Kk///Ro///0KH//86n///Ky/+CUFD/MxoNrzMaDVAuFwwWOTkcCUY6
-        LhZANic0OjAgYDgmGY01IROkMyAQoDMjE3w0KBRAMTEYFZViYv/Nzc3//+rV///p0///6NH//+fP///m
-        zv//5cz//+TK///jyP//48b//+LE///hw///4MH//+DB///fv///3r3//928///duv//3Lj//9u2///a
-        tf//2bL//9ix///Xr///1q3//9Ws///Uqv//06j//9Om///SpP//0aP//8+o///Jyf+EU1L/MxoNrzIc
-        DFIzIhoeQjopHz42J0JBQC99X5N85FmgfP9NkmX/O1428TMiEK4yJxJhNS0PIpdkZP/Ozs7//+vW///q
-        1f//6dP//+jR///nz///5s7//+XM///kyv//48j//+PG///ixP//4sX//+HC///gwf//37///969///d
-        vP//3br//9y4///btv//2rX//9my///Ysf//16///9at///VrP//1Kr//9Oo///Tpv//0qT//9Cp///I
-        yP+FVFP/NBsNsjUeEVw8Khw3PTMjUEpYRZ1hnYHyLqVF/x2SLP8LdxH/JG0f/zA4FMkyKBJmMisOJJhl
-        Zf/Q0ND//+zY///r1v//6tX//+nT///o0f//58///+bO///lzP//5Mr//+PI///jyP//4sb//+LF///h
-        wv//4MH//9+////evf//3bz//926///cuP//27b//9q1///Zsv//2LH//9ev///Wrf//1az//9Sq///T
-        qP//06b//9Gr///Gx/+HVVT/NBsPvDUiE3k4KhxtU3FdvWOtifwupUX/HZIs/wt3Ef8AZgD/GWkT/zA7
-        FbMxJxBOMzMUGZlmZv/R0dH//+za///s2P//69b//+rV///p0///6NH//+fP///mzv//5cz//+XL///k
-        yv//48j//+LG///ixf//4cL//+DB///fv///3r3//928///duv//3Lj//9u2///atf//2bL//9ix///X
-        r///1q3//9Ws///Uqv//06j//9Gs///Fxf+IV1b/NBwQ0zUhE6xagm3dV7h8/ymjPf8bjyn/C3cR/wBm
-        AP8OaAv/LmMg7TEvE2syLBMpLi4XC5xpZ//S0tL//+3c///s2v//7Nj//+vW///q1f//6dP//+jS///o
-        0P//58///+bN///ly///5Mr//+PI///ixv//4sX//+HC///gwf//37///969///dvP//3br//9y4///b
-        tv//2rX//9my///Ysf//16///9at///VrP//1Kr//9Ku/+6ykf+JWVf/OCYY7WSchflJuGv/Jp85/xiL
-        Jf8JdQ//AGYA/w9oDP8uYyDsMS8TajMoES0zMxEPVVUAA55raP/T09P//+7e///t3P//7Nr//+zZ///s
-        2P//69b//+rU///p0///6NH//+fP///mzf//5cv//+TK///jyP//4sb//+LF///hwv//4MH//9+////e
-        vf//3bz//926///cuP//27b//9q1///Zsv//2LH//9ev///Wrf/+1Kr/7LB7/+albv+LWVj/bLKW/0G4
-        YP8mnzn/GIsl/wdxC/8AZgD/EWgN/y5ZHdcwMBRjMiwTKTckEg5AQAAEAAAAAKFuav/V1dX//+/f///u
-        3v//7t3//+3b///s2v//7Nj//+vW///q1P//6dP//+jR///nz///5s3//+XL///kyv//48j//+LG///i
-        xf//4cL//+DB///fv///3r3//928///duv//3Lj//9u2///atf//2bL//9ix//zRp//pqHL/5qRt/86o
-        av9Mz2z/NrdS/yWeOP8YiyX/B3EL/wBmAP8RaQ3/L1ke1TQnD1QwKQ4lKysVDAAAAAMAAAAAAAAAAKNw
-        a//W1tb///Dh///w4P//79///+7d///t2///7Nr//+zY///r1v//6tT//+nT///o0f//58///+bN///l
-        y///5Mr//+PI///ixv//4sX//+HC///gwf//37///969///dvP//3br//9y4///btv//2rX/98ea/+mo
-        cv/mpG3/rbZu/0PMZv80tU//JZ44/xOEHv8HcAr/AGYA/xFqDv8wVB3EMScQTjUtDyIzMxoKAAAAAgAA
-        AAAAAAAAAAAAAKVybP/X19f///Hj///x4v//8OH//+/f///u3f//7dv//+za///s2P//69b//+rU///p
-        0///6NH//+fP///mzf//5cv//+TK///jyP//4sb//+LF///hwv//4MH//9+////evf//3bz//926//7a
-        tv/yvI3/6ahy/+elbv+Fx3L/Q8xm/zS0Tv8jmjT/E4Qe/wdwCv8AZgD/EGoN/zBLGrIxJhFJMSkQHzk5
-        HAkAAAACAAAAAAAAAAAAAAAAAAAAAKh1bv/Y2Nj///Ll///y5P//8eP///Dh///v3///7t3//+3b///s
-        2v//7Nj//+vW///q1P//6dP//+jR///nz///5s3//+XL///kyv//48j//+LG///ixf//4cL//+DB///f
-        v///3r3//Ney/+6zf//pqHL/26xx/2bYeP9DzGb/MbBK/yOaNP8ThB7/A2wG/wBmAP8Qag7/Mk0crDEm
-        D0M3LhIcOTkcCQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAKt4b//a2tr///Pm///z5v//8uT///Hj///w
-        4f//79///+7d///t2///7Nr//+zY///r1v//6tT//+nT///o0f//58///+bN///ly///5Mr//+PI///i
-        xv//4sX//+HC///gwf/50Kn/7K54/+mpcv/MtHT/VuB7/0HIYv8wr0n/IZkz/w9+GP8DbAb/AGYA/yZ0
-        Iv0xPBePMyYRPDUrFRgkJCQHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK57cP/b29v///To///z
-        6P//8+b///Lk///x4///8OH//+/f///u3f//7dv//+za///s2P//69b//+rU///p0///6NH//+fP///m
-        zf//5cv//+TK///jyP//4sb/+M6n//TAkv/rrXb/6alz/7DCeP9R33n/P8Zg/zCvSf8hmTP/D30X/wNs
-        Bv8AZgD/JnQi/jI3FZo1JRA+Oi4XFisrKwYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALB9
-        cf/c3Nz///Xq///06f//8+j///Pm///y5P//8eP///Dh///v3///7t3//+3b///s2v//7Nj//+vW///q
-        1P//6dP//+jR///nz///5s3//+XL///kyv/83L3/7rF7/+ytd//mrHT/jdN+/0/dd/8+w13/LqxG/yCX
-        Mf8PfRf/A2wG/wBmAP8ecxv/OjEawzUdEGAwIBAgJCQkBwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAALJ/c//d3d3///Xs///17P//9On///Po///z5v//8uT///Hj///w4f//79///+7d///t
-        2///7Nr//+zY///r1v//6tT//+nT///o0f//58///+bN//fMpP/vs33/7K13/8p3Wf/Ab1D/YdBy/zzB
-        W/8tqkT/HZIs/w58Fv8CaQP/AGYA/1F/Pf+VZmT/MhoNsTQcDFMuFwwWAAAAAwAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAALaDdP/f39////bu///27f//9ez///Tp///z6P//8+b///Lk///x
-        4///8OH//+/f///u3f//7dv//+za///s2P//69b//+rU///p0//72bn/8rmG/++xe//rrXf/1Y1t/9aK
-        V//cmGD/zZZZ/zGpRP8dkiz/DHgS/wFoAv8AZgD/XI5F//+1tf+XaGX/MxoNrzMaDVAzGg0UAAAAAgAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiFdf/g4OD///fw///37///9u3///Xs///0
-        6f//8+j///Pm///y5P//8eP///Dh///v3///7t3//+3b///s2v//7Nj//ufP//bCk//xtYD/77J8/+Sj
-        dv/DeXL/zJSU/+XAr//78sP/8NSe/7+RUf8MeBL/AWgC/wBmAP9jlEn//9LA//+0tP+YaWf/MxoNrzMa
-        DVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALuId//h4eH///ny///4
-        8f//9+////bt///17P//9On///Po///z5v//8uT///Hj///w4f//79///+7d//7s2f/5z6j/9LqF//G2
-        gP/usHv/zoh2/8iLi//cuLj/8N/d/9esrP/fsJD/8NSe/9mPV/93YDH/AGYA/6K0e///37///9DB//+y
-        sv+Zamj/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL6L
-        eP/i4uL///r0///58v//+PH///fv///27f//9ez///Tp///z6P//8+b///Lk///x4///8OH//ODD//a/
-        i//0uoX/8baA/96efP/FhIL/1amo//Ll5f/evb3/xICA/7JTT/+vSkf/0oVV/8p3Uv+tSUb/urCH///h
-        wv//4MH//9DA//+wsf+bbGr/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAMCNef/k5OT///v2///69P//+fL///jx///37///9u3///Xs///06f//8+j///Pm//7r
-        2P/6yJn/9r6J//S6hf/ssIL/y4l+/9Ompv/t2tn/5cvJ/8aHh/+0WVb/vWFM/7teS//BaE7/vWFM/7pg
-        Wf/ls6D//+LG///ixf//4cL//9DA//+wr/+cbWv/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMOQe//l5eX///v4///79v//+vT///ny///48f//9+////bt///1
-        7P//9On//d29//nCjv/3v4r/87mF/9ubgP/Qn5//5cnH/+rT0f/PmZT/yHxk/859VP/OfFL/yHJQ/8Zw
-        UP+9YUz/zYR4///ly///5Mr//+PI///ixv//4sX//8/A//+urf+db2z/MxoNrzMaDVAzGg0UAAAAAgAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWSff/m5ub///z5///7+P//+/b///r0///5
-        8v//+PH///fv//7t3P/8ypr/+cKO//e/iv/Fn4b/FCh7/7aitP/q1ND/1KWi/8+Oe//blWH/2pRf/9mQ
-        V//ViVX/y3lS/71hTP/NhXn//+fP///mzf//5cv//+TK///jyP//4sb//87A//+srf+fcW3/MxoNrzMa
-        DVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiVfv/n5+f///38///8
-        +f//+/j///v2///69P//9/D//ty6//zHk//5w47/8LuK/19ihf8BG3r/EjiQ/xQje//AeHj/x4KC/8qH
-        h//JgXn/4rWi/92ie//ThVX/vWFM/82Fev//6dP//+jR///nz///5s3//+XL///kyv//48j//86///+r
-        q/+gcm//MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqX
-        f//p6en///79///9/P///Pn///v4///v3//+z5///MiU//nDj/+1l4z/FDCF/wsxiv8MOpH/ARN1/wMK
-        cP8bEmr/wX6B/8qHh/+7Zmb/xX19/+O8s/++Y07/zYZ8///r1v//6tT//+nT///o0f//58///+bN///l
-        y///5Mr//86///+pqf+hdHD/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAM2agP/q6ur////+///+/f///fz///z5//7evf/8yJT/9MCP/25ojv8cLoX/HECT/wkx
-        iv8PNZr/Dy2U/wcVfP8AAWf/GxJq/7F7if/Gf3//wXR0/8FvZf/Nh33//+za///s2P//69b//+rU///p
-        0///6NH//+fP///mzf//5cv//82///+oqP+idXL/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAANCdgf/r6+v//////////v///v3///38//7y5v/Mq5f/S02T/y02
-        iP8qPY3/IEig/yNq0f8hY8r/FD6l/w0pkP8EDXT/Awpx/xAkh/+xfYv/wW5k/82Hfv//7t3//+3b///s
-        2v//7Nj//+vW///q1P//6dP//+jR///nz///5s3//82///+np/+jd3P/MxoNrzMaDVAzGg0UAAAAAgAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANOggv/s7Oz///////////////7///79/6Pi
-        /f8xg8//RkeR/z9Gkf8uWrH/MJD0/y+N9P8lctn/H17F/xdHrv8OLZP/FD2k/woghv8BA2r/oXWH///w
-        4f//79///+7d///t2///7Nr//+zY///r1v//6tT//+nT///o0f//58///8y///+lpf+leXT/MxoNrzMa
-        DVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANWihP/u7u7/////////
-        ////////zfX+/wbF//8Qu///Ol6n/yBMpf8bZsj/KIDh/y6O9P8ymP7/K4Xs/x1ZwP8fXsT/GUyz/wwl
-        jP9eXpv///Lk///x4///8OH//+/f///u3f//7dv//+za///s2P//69b//+rU///p0///6NH//8y+//+k
-        pP+menb/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANil
-        hf/v7+//////////////////MdX//wDM//8Byv//Cb77/wRFnf8NSKb/Fly9/yJ12P8si/D/Lovx/y6N
-        8/8nd97/HFa9/2mCwP//8+j///Pm///y5P//8eP///Dh///v3///7t3//+3b///s2v//7Nj//+vW///q
-        1P//6dP//8u+//+io/+oe3f/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAANqnhv/w8PD////////////G8///AMz//wDM//8AzP//AMz//wTH//8Fd8P/CT+c/xNV
-        tf8hcNT/K4bo/zGW/P8xk/n/R4/m///17P//9On///Po///z5v//8uT///Hj///w4f//79///+7d///t
-        2///7Nr//+zY///r1v//6tT//8u///+goP+pfXj/MxoNrzMaDVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAN2qiP/x8fH///////////841///AMz//wDM//8AzP//AMz//wDM
-        //8Ay///Ba/u/wVCm/8QTq7/GmTG/yZ83/9KnPL/+fTv///27f//9ez///Tp///z6P//8+b///Lk///x
-        4///8OH//+/f///u3f//7dv//+zZ///s1///69b//8q+//+gn/+qf3n/MxoNrzMaDVAzGg0UAAAAAgAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCtiv/z8/P///////f9//8AzP//AMz//wDM
-        //8AzP//AMz//wDM//8AzP//AMz//wLE+/8DZLT/C0Si/zZww//49fH///jx///37///9ez///Xq///0
-        6P//8+b///Ll///x4///8OH//+/f///u3v//7dz//+za///s2P//69b//8q+//+enf+rgHv/MxoNrzMa
-        DVAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOOwi//09PT//////9T2
-        //8AzP//AMz//wDM//8AzP//AMz//wDM//8AzP//AMz//wDM//8Ay///J7nt//j19P//+vT///ny///4
-        8f//9u7///Xs///16v//9Oj///Pm///y5f//8eP///Dh///v3///7t7//+3c///s2v//7Nj//8m+//+c
-        nf+sgn3/NBsNrTQaDU8zGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOWy
-        jP/19fX//////9T2//8AzP//AMz//wDM//8AzP//AMz//wDM//8AzP//AMz//1ze/v8j0v7/9/v5///7
-        +P//+/b///r0///58v//9/D///bu///17P//9er///To///z5v//8uX///Hj//+8vf//uLf//7Oz//+u
-        rv//qan//6Sk//+gn/+ug37/Nx4RozgcEUk5HA4SAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAOe0jv/29vb//////9T2//8AzP//AMz//wDM//8AzP//B83//wfN//8q1P//B83///f9
-        /v/w+/3///38///8+f//+/j///v2///69P//+PH///fw///27v//9ez///Xq///06P//8+b/upGK/7mP
-        iP+2jIb/tYqF/7OIhP+yh4P/sYaB/7BwcP+bamn/OyEVhUAgFzg7JxQNAAAAAQAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOq3j//4+Pj///////f9//8AzP//AMz//wDM//8V0P//Vd3//3/l
-        ////////8Pz///////////7///79///9/P///Pn///v4///79v//+fP///jx///38P//9u7///Xs///1
-        6v//9Oj/pXJs//+0Uv//mQD/9Y8A/+uFAP/gegD/1nAA/79mGf9+UU7XQSUZUkQiGh5VKysGAAAAAQAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO26kP/5+fn///////////8V0P//AMz//wDM
-        //+q7v//jej//3/l///////////////////////////+///+/f///fz///z5///7+P//+vX///nz///4
-        8f//9/D///bu///17P//9er/qHVu///Mmf//tFL//7BE//+rNv//qC3/2Yw5/4BTUNhAIxpXRyMcJE0z
-        GgqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPC9kf/6+vr/////////
-        //9V3f//AMz/////////////2/f//831/////////////////////////////////v///v3///38///8
-        +f//+/f///r1///58///+PH///fw///27v//9ez/q3hv///Wo///t1v//7RS//+wRP/bk0n/g1ZS2EMm
-        GldFKRwlRi4XC4AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPPA
-        kv/7+/v///////////+N6P//MdX/////////////////////////////////////////////////////
-        //////7///79///9/P//+/j///v3///69f//+fP///jx///38P//9u7/rntw///grf//u2f//7db/92b
-        W/+HWlTYQyYaV0UpHCVGLhcLgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAPXCk//9/f3/////////////////9/3/////////////////////////////////////
-        ///////////////////////////+///+/f///Pr///v4///79///+vX///nz///48f//9/D/sH1x///r
-        uP//wHT/3qFq/4pdVthDJhpXRSkcJUYuFwuAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPfElf/+/v7//v7+//7+/v/+/v7//v7+//39/f/9/f3//f39//39
-        /f/8/Pz//Pz8//z8/P/8/Pz/+/v7//v7+//7+/v/+/v7//v7+v///vz///z6///7+P//+/f///r1///5
-        8///+PH/sn9z///1wv/gqHv/jmFX2kYpHVhMKRwlRi4XC4AAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPrHl/////////////7+/v/9/f3//Pz8//z8
-        /P/7+/v/+vr6//r6+v/5+fn/+Pj4//f39//39/f/9vb2//X19f/19fX/9PT0//Pz8//z8vL/8vHw//Hw
-        7//w7uz/8O3r/+/s6f/u6+j/toN0/+zftv+OYlbkRikbaUsyJSlVKxUMgAAAAgAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7Lmf/81rH/+tSw//jR
-        rv/1z63/882r//HLqv/uyKn/7MWo/+rDpv/owaX/5b+k/+O9ov/guqH/3ref/9u1nv/as53/17Gb/9Wu
-        mv/SrJn/0KqY/86nlv/LpZX/yaOU/8agkv/EnpH/uIV1/7WCdJ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAA
-        AAAD/wAAgAAAAAH/AACAAAAAAYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAHAAAAAAAAAA8AAAAA
-        AAAAHwAAAAAAAAA/AAAAAAAAAH8AAAAAAAAA/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/
-        AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAf8AAAAA
-        AAAB/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/
-        AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAH/AAAAAAAAA/8AAAAAAAAH/wAAAAAAAA//AAAAAAAAH/8AAAAA
-        AAA//wAAAAAAAH//AAAAAAAP//8AACgAAAAgAAAAQAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAMx8KGTMcDjc0HA5JNBoNTzMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMa
-        DVAzGg1QMxoNUDMaDVAzGg1QMxoNUDMaDVAzGg1QNBoNTzQcDkkzHA43Mx8UGSsrAAYAAAABAAAAAQAA
-        AAEAAAABAAAAAAAAAAAzHA43MxoNeDIbDaIzGg2uMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMa
-        Da8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa8zGg2uNBsOojUcD3g4HA43MyIRDzMz
-        MwU5ORwJOzsnDUYuLgszMzMFAAAAANCei//ZpZn/1qOW/9Whlv/ToJX/06CV/9GelP/QnZT/zpuT/86a
-        k//OmpP/zpqT/86ak//NmZL/zZmS/82Zkv/NmZL/zZmS/8yZkv/MmJL/zJiS/8yYkf/bl4z+NBwOojYf
-        EUsxJxQaOjouFjk5Jig5NCE2PDYhLzU1IBgAAAAAzbGo//zh1///4ND//9/P///ezf//3cv//9zJ///b
-        yP//28b//tfD//7Xw//+18P//tfD//7Xw//+18P//tfD//7Xw//+18P//tfD//7Xw//+18P//8yZ/9uX
-        jP82HRCwOSIUWTguHzI5NSZDOi4fajctG4M3LhtwNjIdPQAAAADJsqj/+ezb///p0///58///+bN///k
-        yv//48f//+LF///hwv//4MD//968///duv//27f//9q0///Zsv//167//9as///Uqf//06f//9Gk///Q
-        of/90r//25eM/zghE7s7KRp1OjAhZkZSP59RgmTnP1w74jUmFKM1LBZcAAAAAMy1qf/57N3//+rV///p
-        0///58///+bN///kyv//48f//+LF///hwv//4MD//968///duv//27f//9q0///Zsv//167//9as///U
-        qf//06f//9Gk//3Sv//bl4z/OiIV0DspGqhQalXLS6Zp/xiFI/8CZwL/PEcivzMrFFoAAAAAzrer//nt
-        4P//69j//+rV///p0///58///+bN///kyv//48f//+LF///hwv//4MD//968///duv//27f//9q0///Z
-        sv//167//9as///Uqf//06f//dK//6WKgP48LB7rXolv8zOsTP8UhB7/AGYA/yttIf8xPBWVNCsROwAA
-        AADQuKz/+u7i///t2///69j//+rV///p0///58///+bN///kyv//48f//+LF///hwv//4MD//968///d
-        uv//27f//9q0///Zsv//167//9as//7TqP/ws5D/6ahy/2OvgP4uqUX/FIQe/wJoAv8qbCH7Mk4erTIr
-        E0IxMRQaAAAAANK6rv/68eb//+7e///t2///69j//+rV///p0///58///+bN///kyv//48f//+LF///h
-        wv//4MD//968///duv//27f//9q0///Zsv/906n/6614/8ivbv9IymX/KKI8/w98Fv8TcxP/Km0h+zxG
-        I5E3KxU8NTUVGCQkJAcAAAAA07yv//ry6P//8OH//+7e///t2///69j//+rV///p0///58///+bN///k
-        yv//48f//+LF///hwv//4MD//968///duv//27f/+tCo/+mocv+svHL/QMZg/yiiPP8NeRP/AGYA/y1p
-        Ifk3Qh6INCYTNj0xGBUrKysGAAAAAQAAAADWvrD/+vTr///x4///8OH//+7e///t2///69j//+rV///p
-        0///58///+bN///kyv//48f//+LF///hwv//4MD//968//fKn//lqnL/gM93/0DGYP8noTv/EHsW/xBr
-        Dv82bCryMS0TcTUlEDAtLQ8RMzMABQAAAAEAAAAAAAAAANjAsv/79e3///Ll///x4///8OH//+7e///t
-        2///69j//+rV///p0///58///+bN///kyv//48f//+LF//7fwP/zwJH/1rR3/2fZef89wlv/I5s1/xB7
-        Fv8Wdxb/L2Eh9DctFYA2JxQ0MDAQEEBAAAQAAAABAAAAAAAAAAAAAAAA2sKz//v38f//9Oj///Ll///x
-        4///8OH//+7e///t2///69j//+rV///p0///58///+bN///kyv/50az/7a94/7nIgP9Y433/ObxV/yKZ
-        Mv8Gbwn/B2sH/3aSaP06KRa4PCUXWTckGxwzMwAFAAAAAAAAAAAAAAAAAAAAAAAAAADcxLT/+/jz///1
-        6///9Oj///Ll///x4///8OH//+7e///t2///69j//+rV///p0//+5s3/9MKV/+2vef/Oflz/z4hW/0+1
-        Vf8imTL/FXsY/xR1FP+VmnP/qY2E+jcgEa88IxNRPSQYFQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAN7G
-        tv/7+vf///fu///16///9Oj///Ll///x4///8OH//+7e///t2///69j/+9u9//G3gv/mpHX/x4B1/9it
-        qv/36rr/zZpe/xt8G/8WdBT/282i//3Sv//bmIz/Nh0QrzYdEFAzGg0UAAAAAgAAAAAAAAAAAAAAAAAA
-        AAAAAAAA38e3//z7+P//+PD///fu///16///9Oj///Ll///x4///8OH//u3c//jKoP/xtoD/2JZ7/9Ki
-        ov/mzc3/yIuL/8p/ZP/blFv/kFY9/9vQp///4MD//dK//9yYjP80HA+vNh0QUDMaDRQAAAACAAAAAAAA
-        AAAAAAAAAAAAAAAAAADiyrn//P39///69P//+PD///fu///16///9Oj///Ll//zewf/3v4v/66+B/9Oc
-        lf/mzs7/0Z+f/7xmW/+7Xkv/w2pO/8FsXP/41rz//+LF///hwv/90r//3JiM/zQcD682HRBQMxoNFAAA
-        AAIAAAAAAAAAAAAAAAAAAAAAAAAAAOTMuf/8/v7///v2///69P//+PD///fu//7s2v/6ypv/8LqJ/4tq
-        fP/ly8v/27Sy/9ONZ//WjFf/0IBU/8ZvUP+/aVz//OHJ///kyv//48f//+LF//3Sv//cmI3/NBwPrzYd
-        EFAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA5s27//z//////Pn///v2///27P/+2LH/+sSQ/6aN
-        iP8JI33/AyF//51jdf/OkJD/xn11/+CskP/QglT/v2ld//zkz///58///+bN///kyv//48f//dK//9yY
-        jf80HA+vNh0QUDMaDRQAAAACAAAAAAAAAAAAAAAAAAAAAAAAAADo0L3//f/////+/P///Pn//sqX/9Ws
-        kf8+Roj/ETGK/wcwjf8LI4n/AAJo/4Ncf//DeHj/yoeF/8BrXv/859T//+rV///p0///58///+bN///k
-        yv/90r//3JiN/zQcD682HRBQMxoNFAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAOrRvv/9///////+///+
-        /P+uusT/Oj2L/y0+jv8fUq7/IWTL/xI4n/8GE3n/CyGI/0w6e//EdGn//Ona///t2///69j//+rV///p
-        0///58///+bN//3Sv//cmY3/NBwPrzYdEFAzGg0UAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA7NTA//3/
-        ////////nOr+/xG5/P9BU53/Jlq0/yyJ7P8wkff/JGzT/xtSuf8OLZP/JSh+//fq3///8OH//+7e///t
-        2///69j//+rV///p0///58///dK//9yZjf80HA+vNh0QUDMaDRQAAAACAAAAAAAAAAAAAAAAAAAAAAAA
-        AADu1sL//f///+n6//8Hzf//AMv//wbB/P8HRqD/FVm6/yZ+4v8wkff/KoHn/ztrwv/47ub///Ll///x
-        4///8OH//+7e///t2///69j//+rV///p0//90r//3JmN/zQcD682HRBQMxoNFAAAAAIAAAAAAAAAAAAA
-        AAAAAAAAAAAAAPDYw//+////qu7//wDM//8AzP//AMz//wHK//8Ffsn/D02s/x9w0v9Ln/X/+fPu///1
-        6///9Oj///Ll///x4///8OH//+7e///t2///69j//+rV//3Sv//cmY3/NRwPrjcdEE8zGg0UAAAAAgAA
-        AAAAAAAAAAAAAAAAAAAAAAAA8tnF//////9V3f//AMz//wDM//8AzP//AMz//wDM//8Ds+7/V5fR//j1
-        8v//+PD///fu///16///9Oj///Ll///x4///39f//9jQ///Qx///zML//dK//9yVif84HhGoOh8RSzYb
-        DRMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAD03Mf//////yrU//8AzP//AMz//wDM//8AzP//B83//w7O
-        /v/3+/n///r2///68///+PD///fu///16///9Of///Tm//nazv/3s7P/96ys//ahov/4mpr/2pWH/jwi
-        E5A/JhU9RCIRDwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAPbdx///////ONf//wDM//8AzP//FdD//7Hv
-        //+/8v/////+///+/P//+/j///r2///58///9/D///bu///16//98uj/5baR/+6hR//nlTj/3os2/9WC
-        Nf+/i23yRCcYYUUpHCVAICAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAA+ODK//////9/5f//B83//2rh
-        //9x4v/////////////////////+///9+////Pj///r2///58///+PD///fu//zy6f/rwJ7//71g//+p
-        Mf/8oiL/z5BR8149LHRKKyAwVTMiD1UAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD64sr//////9T2
-        //841////////+n6//////////////////////////7+///9+///+/j///r2///58///9/D//PLq/+vH
-        qP//zoX//rVU/9afaPNfQC11UDAbMEstHhFAQEAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzk
-        zP/////////////////////////////////////////////////////////////+/f///fn///v3///7
-        9f/+8+3/7dCv///Ylv/Sn3b0XkAtdU4vHzFgMCAQQEBABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAA/ufS///////+/////f////3////8/////P////v////6/v//+v7///n9///4/P//+Pv+//f5
-        +//29/j/9fb2//Px7//u0bD/17eT919ALodNMiQ4VTkrEkBAQAQAAAABAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAD+1Kv//dq5//rXtv/51rT/9tSz//TRs//xz7H/78yw/+3Lrv/syq3/6cer/+bE
-        qv/kwqj/48Gn/+G/pf/fvKT/3Lqj/9+vj8bap4YUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAAAAgAAAAYAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAAAACAAAAAgAAAAIAA
-        AAGAAAADgAAAD4AAAA+AAAAPgAAAD4AAAA+AAAAPgAAAD4AAAA+AAAAPgAAAD4AAAA+AAAAPgAAAD4AA
-        AA+AAAAPgAAAH4AAAB+AAAA/gAAAf4AAD/8oAAAAEAAAACAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAA
-        AAAAAAAAMxwONzMaDXgyGw2iMxoNrjMaDa8zGg2vMxoNrzMaDa8zGg2vMxoNrzMaDa4zGg6kNB0PhDUk
-        FVY7Lh09NTUkK657bv/ZrZ3/1qia/9OmmP/SpJf/zKGZ/8mel//GnJb/xJmV/8GWk/+2kYv/uI6L/zQe
-        EMM1JRaZOC4cfzc1Hly1gnL/5tvR///mzP//48f//+DB///du///27f//9ix///VrP//0qX//862/+69
-        pf84KBroUXxg60BjPtM2Lxptu4h1/+jf1f//6dL//+bM///jx///4MH//927///bt///2LH//9Ws//7O
-        tv/Qq23/W6V2/RV1Gv8wWyHVNC0XT8KPef/q4tv//+zY///p0v//5sz//+PH///gwf//3bv//9u3//jK
-        nv/Qq23/NK1I/xB0FP9BaTPeNCkUWDcpFSXIlXz/7Obf///v3v//7Nj//+nS///mzP//48f//t+///PA
-        kv+StGX/KKI8/whvCv87WSfmMyAQbjUkEisrKxUMz5yA/+7p5P//8eP//+/e///s2P//6dL//uLG/+yw
-        gP+hqmn/KKI8/wltCf/xxbH/MxsNszIaD1czHwoZAAAABNWig//w7On///To///x4//+7tz/+tSw/92c
-        e//RnZr/6siZ/z1iHf/bxKr/8si1/zMaDa8yGQ1RMxoNFAAAAALcqYf/8vDu///37//+5s7/57aN/9qp
-        n//UnZL/w25U/8VzY//838P//9bH//LJt/8zGg2vMxoNUDMaDRQAAAAC3KmH//Tz8//+2LP/hHiK/wgn
-        hP+jbn3/xHlx/8d2YP/85M7//+bM///Yyv/zzLr/NRwPrjcaEE8zGg0UAAAAAtyph////v3/dIuz/yZZ
-        sv8gYsn/Ch6F/4xZb//86tr//+zY///p0v//18r/8829/zggEqc6IhRLORwOEgAAAALcqYf/jej//wLJ
-        //8PdMn/J4Dl/0SE2//47uX///Hj///v3v//7Nj//87D//TJuv9BJxmRRikdPkk3JA4AAAAB3KmH/zjX
-        //8AzP//AMz//zes4//49vP///fv///06P//1cz//9XM//Wzqv/BkYbnRiwdaU40ISdgQCAIAAAAAdyp
-        h/8Ozv//Tdv//7jw/////v3///36///69f//+/X/96ZD//emQ//klUH/Ykg4lE41JT5eNigTVVUAAwAA
-        AADcqYf/jej//////////////////////////////////9yph//yunr/g2NJyVA3JFxYQCggbUkkBwAA
-        AAEAAAAA3KmH/9yph//cqYf/3KmH/9yph//cqYf/3quI/9ajhP/cqYf/4cWliQAAAAAAAAAAAAAAAAAA
-        AAAAAAAAAAAAAAAAAAAAAK7/AADm/wAA3v8AANv/AADY/wAA1f8AANP/AADP/wAAzf8AAMr/AADH/wAA
-        xf8AAcL/AAHA/wA/vP8=
-</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Program.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Program.cs
deleted file mode 100644
index f352cde3e87..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Program.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System.Windows.Forms;
-
-namespace TestConsole;
-
-class Program
-{
-    //- NOTE: the code needs to run under a thread with an STA ApartmentState
-    [STAThread]
-    static void Main(string[] args)
-    {
-        Application.EnableVisualStyles();
-        Application.SetCompatibleTextRenderingDefault(false);
-
-        try
-        {
-            Console.WriteLine("Begin the demo...");
-
-            //Form frm = new Form();
-            //IDesignSurfaceExt surface = new DesignSurfaceExt.DesignSurfaceExt();
-            //surface.CreateRootComponent( typeof( Form ), new Size( 400, 400 ) );
-            //surface.CreateControl( typeof( Button ), new Size( 100, 40 ), new Point( 10, 10 ) );
-            //TextBox t1 = (TextBox) surface.CreateControl( typeof( TextBox ), new Size( 300, 20 ), new Point( 10, 80 ) );
-            //t1.Text = "Hello World by DesignSurfaceExt";
-            //surface.GetView().Parent = frm;
-            //frm.ShowDialog();
-
-            MainForm f = new MainForm();
-            f.ShowDialog();
-
-            Console.WriteLine("Bye!");
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Exception (strike a key to quit!): {ex.Message}");
-            Console.ReadLine();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.Designer.cs
deleted file mode 100644
index 4956b5c577b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.Designer.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace TestConsole.Properties; 
-using System;
-
-
-/// <summary>
-///   A strongly-typed resource class, for looking up localized strings, etc.
-/// </summary>
-// This class was auto-generated by the StronglyTypedResourceBuilder
-// class via a tool like ResGen or Visual Studio.
-// To add or remove a member, edit your .ResX file then rerun ResGen
-// with the /str option, or rebuild your VS project.
-[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
-[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-internal class Resources {
-    
-    private static global::System.Resources.ResourceManager resourceMan;
-    
-    private static global::System.Globalization.CultureInfo resourceCulture;
-    
-    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-    internal Resources() {
-    }
-    
-    /// <summary>
-    ///   Returns the cached ResourceManager instance used by this class.
-    /// </summary>
-    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-    internal static global::System.Resources.ResourceManager ResourceManager {
-        get {
-            if (object.ReferenceEquals(resourceMan, null)) {
-                global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("TestConsole.Properties.Resources", typeof(Resources).Assembly);
-                resourceMan = temp;
-            }
-            return resourceMan;
-        }
-    }
-    
-    /// <summary>
-    ///   Overrides the current thread's CurrentUICulture property for all
-    ///   resource lookups using this strongly typed resource class.
-    /// </summary>
-    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-    internal static global::System.Globalization.CultureInfo Culture {
-        get {
-            return resourceCulture;
-        }
-        set {
-            resourceCulture = value;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.resx b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.resx
deleted file mode 100644
index 7080a7d118e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/Properties/Resources.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/painter.ico b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/painter.ico
deleted file mode 100644
index cfb99b1b04a..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DemoConsole/painter.ico and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.cs
deleted file mode 100644
index 05d639b4c59..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.cs
+++ /dev/null
@@ -1,405 +0,0 @@
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.ComponentModel;
-using System.Windows.Forms;
-using System.ComponentModel.Design.Serialization;
-
-namespace DesignSurfaceExt;
-
-public class DesignSurfaceExt : DesignSurface, IDesignSurfaceExt
-{
-    private const string _Name_ = "DesignSurfaceExt";
-
-    #region IDesignSurfaceExt Members
-
-    public void SwitchTabOrder()
-    {
-        if (IsTabOrderMode == false)
-        {
-            InvokeTabOrder();
-        }
-        else
-        {
-            DisposeTabOrder();
-        }
-    }
-
-    public void UseSnapLines()
-    {
-        IServiceContainer serviceProvider = GetService(typeof(IServiceContainer)) as IServiceContainer;
-        DesignerOptionService opsService = serviceProvider.GetService(typeof(DesignerOptionService)) as DesignerOptionService;
-        if (opsService is not null)
-        {
-            serviceProvider.RemoveService(typeof(DesignerOptionService));
-        }
-
-        DesignerOptionService opsService2 = new DesignerOptionServiceExt4SnapLines();
-        serviceProvider.AddService(typeof(DesignerOptionService), opsService2);
-    }
-
-    public void UseGrid(Size gridSize)
-    {
-        IServiceContainer serviceProvider = GetService(typeof(IServiceContainer)) as IServiceContainer;
-        DesignerOptionService opsService = serviceProvider.GetService(typeof(DesignerOptionService)) as DesignerOptionService;
-        if (opsService is not null)
-        {
-            serviceProvider.RemoveService(typeof(DesignerOptionService));
-        }
-
-        DesignerOptionService opsService2 = new DesignerOptionServiceExt4Grid(gridSize);
-        serviceProvider.AddService(typeof(DesignerOptionService), opsService2);
-    }
-
-    public void UseGridWithoutSnapping(Size gridSize)
-    {
-        IServiceContainer serviceProvider = GetService(typeof(IServiceContainer)) as IServiceContainer;
-        DesignerOptionService opsService = serviceProvider.GetService(typeof(DesignerOptionService)) as DesignerOptionService;
-        if (opsService is not null)
-        {
-            serviceProvider.RemoveService(typeof(DesignerOptionService));
-        }
-
-        DesignerOptionService opsService2 = new DesignerOptionServiceExt4GridWithoutSnapping(gridSize);
-        serviceProvider.AddService(typeof(DesignerOptionService), opsService2);
-    }
-
-    public void UseNoGuides()
-    {
-        IServiceContainer serviceProvider = GetService(typeof(IServiceContainer)) as IServiceContainer;
-        DesignerOptionService opsService = serviceProvider.GetService(typeof(DesignerOptionService)) as DesignerOptionService;
-        if (opsService is not null)
-        {
-            serviceProvider.RemoveService(typeof(DesignerOptionService));
-        }
-
-        DesignerOptionService opsService2 = new DesignerOptionServiceExt4NoGuides();
-        serviceProvider.AddService(typeof(DesignerOptionService), opsService2);
-    }
-
-    public UndoEngineExt GetUndoEngineExt()
-    {
-        return _undoEngine;
-    }
-
-    public TControl CreateRootComponent<TControl>(Size controlSize)
-        where TControl : Control, IComponent
-    {
-        try
-        {
-            //- step.1
-            //- get the IDesignerHost
-            //- if we are not not able to get it
-            //- then rollback (return without do nothing)
-            IDesignerHost host = GetIDesignerHost();
-            if (host is null)
-                return null;
-            //- check if the root component has already been set
-            //- if so then rollback (return without do nothing)
-            if (host.RootComponent is not null)
-                return null;
-            //-
-            //-
-            //- step.2
-            //- create a new root component and initialize it via its designer
-            //- if the component has not a designer
-            //- then rollback (return without do nothing)
-            //- else do the initialization
-            BeginLoad(typeof(TControl));
-            if (LoadErrors.Count > 0)
-                throw new Exception($"the BeginLoad() failed! Some error during {typeof(TControl).FullName} loding");
-            //-
-            //-
-            //- step.3
-            //- try to modify the Size of the object just created
-            IDesignerHost ihost = GetIDesignerHost();
-            //- Set the backcolor and the Size
-            Control ctrl = null;
-            Type hostType = host.RootComponent.GetType();
-            if (hostType == typeof(Form))
-            {
-                ctrl = View as Control;
-                ctrl.BackColor = Color.LightGray;
-                //- set the Size
-                PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(ctrl);
-                //- Sets a PropertyDescriptor to the specific property.
-                PropertyDescriptor pdS = pdc.Find("Size", false);
-                pdS?.SetValue(ihost.RootComponent, controlSize);
-            }
-            else if (hostType == typeof(UserControl))
-            {
-                ctrl = View as Control;
-                ctrl.BackColor = Color.DarkGray;
-                //- set the Size
-                PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(ctrl);
-                //- Sets a PropertyDescriptor to the specific property.
-                PropertyDescriptor pdS = pdc.Find("Size", false);
-                pdS?.SetValue(ihost.RootComponent, controlSize);
-            }
-            else if (hostType == typeof(Component))
-            {
-                ctrl = View as Control;
-                ctrl.BackColor = Color.White;
-                //- don't set the Size
-            }
-            else
-            {
-                throw new Exception($"Undefined Host Type: {hostType}");
-            }
-
-            return (TControl)ihost.RootComponent;
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::CreateRootComponent() - Exception: (see Inner Exception)", ex);
-        }
-    }
-
-    public TControl CreateControl<TControl>(Size controlSize, Point controlLocation)
-        where TControl : Control
-    {
-        try
-        {
-            //- step.1
-            IComponent newComp = CreateComponent<TControl>(out IDesignerHost host);
-            if (newComp is null)
-                return null;
-
-            //-
-            //-
-            //- step.3
-            //- try to modify the Size/Location of the object just created
-            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(newComp);
-            //- Sets a PropertyDescriptor to the specific property.
-            PropertyDescriptor pdS = pdc.Find("Size", false);
-            pdS?.SetValue(newComp, controlSize);
-            PropertyDescriptor pdL = pdc.Find("Location", false);
-            pdL?.SetValue(newComp, controlLocation);
-            //-
-            //-
-            //- step.4
-            //- commit the Creation Operation
-            //- adding the control to the DesignSurface's root component
-            //- and return the control just created to let further initializations
-            ((Control)newComp).Parent = host.RootComponent as Control;
-
-            return (TControl)newComp;
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::CreateControl() - Exception: (see Inner Exception)", ex);
-        }
-    }
-
-    public TComponent CreateComponent<TComponent>()
-        where TComponent : IComponent
-    {
-        return CreateComponent<TComponent>(out IDesignerHost _);
-    }
-
-    private TComponent CreateComponent<TComponent>(out IDesignerHost host)
-        where TComponent : IComponent
-    {
-        try
-        {
-            //- step.1
-            //- get the IDesignerHost
-            //- if we are not able to get it
-            //- then rollback (return without do nothing)
-            host = GetIDesignerHost();
-            if (host is null)
-                return default;
-            //- check if the root component has already been set
-            //- if not so then rollback (return without do nothing)
-            if (host.RootComponent is null)
-                return default;
-            //-
-            //-
-            //- step.2
-            //- create a new component and initialize it via its designer
-            //- if the component has not a designer
-            //- then rollback (return without do nothing)
-            //- else do the initialization
-            IComponent newComp = host.CreateComponent(typeof(TComponent));
-            if (newComp is null)
-                return default;
-            IDesigner designer = host.GetDesigner(newComp);
-            if (designer is null)
-                return default;
-            if (designer is IComponentInitializer)
-                ((IComponentInitializer)designer).InitializeNewComponent(null);
-
-            return (TComponent)newComp;
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::{nameof(CreateComponent)} - Exception: (see Inner Exception)", ex);
-        }
-    }
-
-    public IDesignerHost GetIDesignerHost()
-    {
-        return (IDesignerHost)(GetService(typeof(IDesignerHost)));
-    }
-
-    public Control GetView()
-    {
-        Control ctrl = View as Control;
-        ctrl.Dock = DockStyle.Fill;
-        return ctrl;
-    }
-
-    #endregion
-
-    #region TabOrder
-
-    private TabOrderHooker _tabOrder;
-    private bool _tabOrderMode;
-
-    public bool IsTabOrderMode
-    {
-        get { return _tabOrderMode; }
-    }
-
-    public TabOrderHooker TabOrder
-    {
-        get
-        {
-            _tabOrder ??= new TabOrderHooker();
-            return _tabOrder;
-        }
-        set { _tabOrder = value; }
-    }
-
-    public void InvokeTabOrder()
-    {
-        TabOrder.HookTabOrder(GetIDesignerHost());
-        _tabOrderMode = true;
-    }
-
-    public void DisposeTabOrder()
-    {
-        TabOrder.HookTabOrder(GetIDesignerHost());
-        _tabOrderMode = false;
-    }
-    #endregion
-
-    #region  UndoEngine
-
-    private UndoEngineExt _undoEngine;
-    private NameCreationServiceImp _nameCreationService;
-    private DesignerSerializationServiceImpl _designerSerializationService;
-    private CodeDomComponentSerializationService _codeDomComponentSerializationService;
-
-    #endregion
-
-    //- ctor
-    public DesignSurfaceExt()
-    {
-        InitServices();
-    }
-
-    //- The DesignSurface class provides several design-time services automatically.
-    //- The DesignSurface class adds all of its services in its constructor.
-    //- Most of these services can be overridden by replacing them in the
-    //- protected ServiceContainer property.To replace a service, override the constructor,
-    //- call base, and make any changes through the protected ServiceContainer property.
-    private void InitServices()
-    {
-        //- each DesignSurface has its own default services
-        //- We can leave the default services in their present state,
-        //- or we can remove them and replace them with our own.
-        //- Now add our own services using IServiceContainer
-        //-
-        //-
-        //- Note
-        //- before loading the root control in the design surface
-        //- we must add an instance of naming service to the service container.
-        //- otherwise the root component did not have a name and this caused
-        //- troubles when we try to use the UndoEngine
-        //-
-        //-
-        //- 1. NameCreationService
-        _nameCreationService = new NameCreationServiceImp();
-        if (_nameCreationService is not null)
-        {
-            ServiceContainer.RemoveService(typeof(INameCreationService), false);
-            ServiceContainer.AddService(typeof(INameCreationService), _nameCreationService);
-        }
-
-        //-
-        //-
-        //- 2. CodeDomComponentSerializationService
-        _codeDomComponentSerializationService = new CodeDomComponentSerializationService(ServiceContainer);
-        if (_codeDomComponentSerializationService is not null)
-        {
-            //- the CodeDomComponentSerializationService is ready to be replaced
-            ServiceContainer.RemoveService(typeof(ComponentSerializationService), false);
-            ServiceContainer.AddService(typeof(ComponentSerializationService), _codeDomComponentSerializationService);
-        }
-
-        //-
-        //-
-        //- 3. IDesignerSerializationService
-        _designerSerializationService = new DesignerSerializationServiceImpl(ServiceContainer);
-        if (_designerSerializationService is not null)
-        {
-            //- the IDesignerSerializationService is ready to be replaced
-            ServiceContainer.RemoveService(typeof(IDesignerSerializationService), false);
-            ServiceContainer.AddService(typeof(IDesignerSerializationService), _designerSerializationService);
-        }
-
-        //-
-        //-
-        //- 4. UndoEngine
-        _undoEngine = new UndoEngineExt(ServiceContainer);
-        //- disable the UndoEngine
-        _undoEngine.Enabled = false;
-        if (_undoEngine is not null)
-        {
-            //- the UndoEngine is ready to be replaced
-            ServiceContainer.RemoveService(typeof(UndoEngine), false);
-            ServiceContainer.AddService(typeof(UndoEngine), _undoEngine);
-        }
-
-        //-
-        //-
-        //- 5. IMenuCommandService
-        ServiceContainer.AddService(typeof(IMenuCommandService), new MenuCommandService(this));
-    }
-
-    //- do some Edit menu command using the MenuCommandService
-    public void DoAction(string command)
-    {
-        if (string.IsNullOrEmpty(command))
-        {
-            return;
-        }
-
-        IMenuCommandService ims = GetService(typeof(IMenuCommandService)) as IMenuCommandService;
-
-        try
-        {
-            CommandID commandId = command.ToUpper() switch
-            {
-                "CUT" => StandardCommands.Cut,
-                "COPY" => StandardCommands.Copy,
-                "PASTE" => StandardCommands.Paste,
-                "DELETE" => StandardCommands.Delete,
-                _ => null,
-            };
-
-            if (commandId is not null)
-            {
-                MenuCommand menuCommand = ims?.FindCommand(commandId);
-                if (menuCommand?.Enabled is true)
-                {
-                    menuCommand.Invoke();
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::DoAction() - Exception: error in performing the action: {command}(see Inner Exception)", ex);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.csproj b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.csproj
deleted file mode 100644
index 36ec7f75241..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignSurfaceExt.csproj
+++ /dev/null
@@ -1,28 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>DesignSurfaceExt</AssemblyName>
-    <RootNamespace>DesignSurfaceExt</RootNamespace>
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-    <ApplicationIcon>dll.ico</ApplicationIcon>
-    <SignAssembly>false</SignAssembly>
-
-    <NoWarn>$(NoWarn),SA1633</NoWarn>
-    <Copyright>Copyright © Paolo Foti 2008</Copyright>
-    <Company />
-    <Authors>Paolo Foti</Authors>
-    <PackageLicenseExpression>CPOL</PackageLicenseExpression>
-    <PackageProjectUrl>https://www.codeproject.com/Articles/24385/Have-a-Great-DesignTime-Experience-with-a-Powerful</PackageProjectUrl>
-
-    <SuppressLicenseValidation>true</SuppressLicenseValidation>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\..\System.Windows.Forms.Design\src\System.Windows.Forms.Design.csproj" />
-    <ProjectReference Include="..\..\..\..\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerOptionServiceExt.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerOptionServiceExt.cs
deleted file mode 100644
index 021098c069b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerOptionServiceExt.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using System.ComponentModel.Design;
-using System.Windows.Forms.Design;
-
-namespace DesignSurfaceExt;
-
-internal class DesignerOptionServiceExt4SnapLines : DesignerOptionService
-{
-    public DesignerOptionServiceExt4SnapLines() : base() { }
-
-    protected override void PopulateOptionCollection(DesignerOptionCollection options)
-    {
-        if (options.Parent is not null)
-            return;
-
-        DesignerOptions ops = new DesignerOptions();
-        ops.UseSnapLines = true;
-        ops.UseSmartTags = true;
-        DesignerOptionCollection wfd = CreateOptionCollection(options, "WindowsFormsDesigner", null);
-        CreateOptionCollection(wfd, "General", ops);
-    }
-}
-
-internal class DesignerOptionServiceExt4Grid : DesignerOptionService
-{
-    private System.Drawing.Size _gridSize;
-
-    public DesignerOptionServiceExt4Grid(System.Drawing.Size gridSize) : base() { _gridSize = gridSize; }
-
-    protected override void PopulateOptionCollection(DesignerOptionCollection options)
-    {
-        if (options.Parent is not null)
-            return;
-
-        DesignerOptions ops = new DesignerOptions();
-        ops.GridSize = _gridSize;
-        ops.SnapToGrid = true;
-        ops.ShowGrid = true;
-        ops.UseSnapLines = false;
-        ops.UseSmartTags = true;
-        DesignerOptionCollection wfd = CreateOptionCollection(options, "WindowsFormsDesigner", null);
-        CreateOptionCollection(wfd, "General", ops);
-    }
-}
-
-internal class DesignerOptionServiceExt4GridWithoutSnapping : DesignerOptionService
-{
-    private System.Drawing.Size _gridSize;
-
-    public DesignerOptionServiceExt4GridWithoutSnapping(System.Drawing.Size gridSize) : base() { _gridSize = gridSize; }
-
-    protected override void PopulateOptionCollection(DesignerOptionCollection options)
-    {
-        if (options.Parent is not null)
-            return;
-
-        DesignerOptions ops = new DesignerOptions();
-        ops.GridSize = _gridSize;
-        ops.SnapToGrid = false;
-        ops.ShowGrid = true;
-        ops.UseSnapLines = false;
-        ops.UseSmartTags = true;
-        DesignerOptionCollection wfd = CreateOptionCollection(options, "WindowsFormsDesigner", null);
-        CreateOptionCollection(wfd, "General", ops);
-    }
-}
-
-internal class DesignerOptionServiceExt4NoGuides : DesignerOptionService
-{
-    public DesignerOptionServiceExt4NoGuides() : base() { }
-
-    protected override void PopulateOptionCollection(DesignerOptionCollection options)
-    {
-        if (options.Parent is not null)
-            return;
-
-        DesignerOptions ops = new DesignerOptions();
-        ops.GridSize = new System.Drawing.Size(8, 8);
-        ops.SnapToGrid = false;
-        ops.ShowGrid = false;
-        ops.UseSnapLines = false;
-        ops.UseSmartTags = true;
-        DesignerOptionCollection wfd = CreateOptionCollection(options, "WindowsFormsDesigner", null);
-        CreateOptionCollection(wfd, "General", ops);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerSerializationServiceImpl.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerSerializationServiceImpl.cs
deleted file mode 100644
index 69f59eee789..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/DesignerSerializationServiceImpl.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Windows.Forms;
-using System.ComponentModel.Design.Serialization;
-using System.Collections;
-
-namespace DesignSurfaceExt;
-
-internal class DesignerSerializationServiceImpl : IDesignerSerializationService
-{
-    private IServiceProvider _serviceProvider;
-
-    public DesignerSerializationServiceImpl(IServiceProvider serviceProvider)
-    {
-        _serviceProvider = serviceProvider;
-    }
-
-    public System.Collections.ICollection Deserialize(object serializationData)
-    {
-        SerializationStore serializationStore = serializationData as SerializationStore;
-        if (serializationStore is not null)
-        {
-            ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
-            ICollection collection = componentSerializationService.Deserialize(serializationStore);
-            return collection;
-        }
-
-        return Array.Empty<object>();
-    }
-
-    public object Serialize(System.Collections.ICollection objects)
-    {
-        ComponentSerializationService componentSerializationService = _serviceProvider.GetService(typeof(ComponentSerializationService)) as ComponentSerializationService;
-        SerializationStore returnObject = null;
-        using (SerializationStore serializationStore = componentSerializationService.CreateStore())
-        {
-            foreach (object obj in objects)
-            {
-                if (obj is Control)
-                    componentSerializationService.Serialize(serializationStore, obj);
-            }
-
-            returnObject = serializationStore;
-        }
-
-        return returnObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/IDesignSurfaceExt.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/IDesignSurfaceExt.cs
deleted file mode 100644
index a5c2a1b0297..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/IDesignSurfaceExt.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-using System.ComponentModel.Design;
-using System.Windows.Forms;
-using System.ComponentModel;
-using System.Drawing;
-
-namespace DesignSurfaceExt;
-
-public interface IDesignSurfaceExt
-{
-    //- perform Cut/Copy/Paste/Delete commands
-    void DoAction(string command);
-
-    //- de/activate the TabOrder facility
-    void SwitchTabOrder();
-
-    //- select the controls alignment mode
-    void UseSnapLines();
-    void UseGrid(System.Drawing.Size gridSize);
-    void UseGridWithoutSnapping(System.Drawing.Size gridSize);
-    void UseNoGuides();
-
-    //- method useful to create control without the ToolBox facility
-    TControl CreateRootComponent<TControl>(Size controlSize)
-        where TControl : Control, IComponent;
-
-    TControl CreateControl<TControl>(Size controlSize, Point controlLocation)
-        where TControl : Control;
-
-    //- Get the UndoEngineExtended object
-    UndoEngineExt GetUndoEngineExt();
-
-    //- Get the IDesignerHost of the .NET 2.0 DesignSurface
-    IDesignerHost GetIDesignerHost();
-
-    //- the View of the .NET 2.0 DesignSurface is just a Control
-    //- you can manipulate this Control just like any other WinForms Control
-    //- (you can dock it and add it to another Control just to display it)
-    //- Get the View
-    Control GetView();
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/NameCreationServiceImp.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/NameCreationServiceImp.cs
deleted file mode 100644
index 77e7972db80..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/NameCreationServiceImp.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-using System.ComponentModel.Design.Serialization;
-using System.ComponentModel;
-
-//- NameCreationServiceImp - Implementing INameCreationService
-//- The INameCreationService interface is used to supply a name to the control just created
-//- In the CreateName() we use the same naming algorithm used by Visual Studio: just
-//- increment an integer counter until we find a name that isn't already in use.
-namespace DesignSurfaceExt;
-
-internal class NameCreationServiceImp : INameCreationService
-{
-    public NameCreationServiceImp() { }
-
-    public string CreateName(IContainer container, Type type)
-    {
-        if (container is null)
-            return string.Empty;
-
-        ComponentCollection cc = container.Components;
-        int min = int.MaxValue;
-        int max = int.MinValue;
-        int count = 0;
-
-        int i = 0;
-        while (i < cc.Count)
-        {
-            Component comp = cc[i] as Component;
-
-            if (comp.GetType() == type)
-            {
-                count++;
-
-                string name = comp.Site.Name;
-                if (name.StartsWith(type.Name))
-                {
-                    try
-                    {
-                        int value = int.Parse(name.Substring(type.Name.Length));
-                        if (value < min)
-                            min = value;
-                        if (value > max)
-                            max = value;
-                    }
-                    catch (Exception) { }
-                }
-            }
-
-            i++;
-        }
-
-        if (count == 0)
-        {
-            return $"{type.Name}1";
-        }
-        else if (min > 1)
-        {
-            int j = min - 1;
-            return $"{type.Name}{j}";
-        }
-        else
-        {
-            int j = max + 1;
-            return $"{type.Name}{j}";
-        }
-    }
-
-    public bool IsValidName(string name)
-    {
-        //- Check that name is "something" and that is a string with at least one char
-        if (string.IsNullOrEmpty(name))
-            return false;
-
-        //- then the first character must be a letter
-        if (!(char.IsLetter(name, 0)))
-            return false;
-
-        //- then don't allow a leading underscore
-        if (name.StartsWith("_"))
-            return false;
-
-        //- ok, it's a valid name
-        return true;
-    }
-
-    public void ValidateName(string name)
-    {
-        //-  Use our existing method to check, if it's invalid throw an exception
-        if (!(IsValidName(name)))
-            throw new ArgumentException($"Invalid name: {name}");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/Properties/AssemblyInfo.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/Properties/AssemblyInfo.cs
deleted file mode 100644
index 424e3b18481..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// using System.Reflection;
-// using System.Runtime.CompilerServices;
-// using System.Runtime.InteropServices;
-
-// // General Information about an assembly is controlled through the following
-// // set of attributes. Change these attribute values to modify the information
-// // associated with an assembly.
-// [assembly: AssemblyTitle( "DesignSurfaceExt" )]
-// [assembly: AssemblyDescription( "Design WinForms using design facilities like TabOrder,UndoEngine,SnapLines/Grid alignment" )]
-// [assembly: AssemblyConfiguration( "" )]
-// [assembly: AssemblyCompany( ";)" )]
-// [assembly: AssemblyProduct( "DesignSurfaceExt" )]
-// [assembly: AssemblyCopyright( "Copyright © Paolo Foti 2008" )]
-// [assembly: AssemblyTrademark( "" )]
-// [assembly: AssemblyCulture( "" )]
-
-// // Setting ComVisible to false makes the types in this assembly not visible
-// // to COM components.  If you need to access a type in this assembly from
-// // COM, set the ComVisible attribute to true on that type.
-// [assembly: ComVisible( false )]
-
-// // The following GUID is for the ID of the typelib if this project is exposed to COM
-// [assembly: Guid( "16345b05-5ed6-4075-8d6e-48004b0dd34d" )]
-
-// // Version information for an assembly consists of the following four values:
-// //
-// //      Major Version
-// //      Minor Version
-// //      Build Number
-// //      Revision
-// //
-// // You can specify all the values or you can default the Build and Revision Numbers
-// // by using the '*' as shown below:
-// // [assembly: AssemblyVersion("1.0.*")]
-// [assembly: AssemblyVersion( "1.0.0.0" )]
-// [assembly: AssemblyFileVersion( "1.0.0.0" )]
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/TabOrderHooker.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/TabOrderHooker.cs
deleted file mode 100644
index 1bb6a40d27f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/TabOrderHooker.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-using System.ComponentModel.Design;
-using System.Reflection;
-
-namespace DesignSurfaceExt;
-
-public class TabOrderHooker
-{
-    private const string _Name_ = "TabOrderHooker";
-
-    private object _tabOrder;
-
-    //- Enables/Disables visual TabOrder on the view.
-    //- internal override
-    public void HookTabOrder(IDesignerHost host)
-    {
-        //- the TabOrder must be called AFTER the DesignSurface has been loaded
-        //- therefore we do a little check
-        if (host.RootComponent is null)
-            throw new Exception($"{_Name_}::HookTabOrder() - Exception: the TabOrder must be invoked after the DesignSurface has been loaded! ");
-
-        try
-        {
-            System.Reflection.Assembly designAssembly = System.Reflection.Assembly.Load("System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
-            Type tabOrderType = designAssembly.GetType("System.Windows.Forms.Design.TabOrder");
-            if (_tabOrder is null)
-            {
-                //- call the ctor passing the IDesignerHost target object
-                _tabOrder = Activator.CreateInstance(tabOrderType, new object[] { host });
-            }
-            else
-            {
-                DisposeTabOrder();
-            }
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::HookTabOrder() - Exception: (see Inner Exception)", ex);
-        }
-    }
-
-    //- Disposes the tab order
-    public void DisposeTabOrder()
-    {
-        if (_tabOrder is null)
-            return;
-        try
-        {
-            System.Reflection.Assembly designAssembly = System.Reflection.Assembly.Load("System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
-            Type tabOrderType = designAssembly.GetType("System.Windows.Forms.Design.TabOrder");
-            tabOrderType.InvokeMember("Dispose", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, _tabOrder, new object[] { true });
-            _tabOrder = null;
-        }
-        catch (Exception ex)
-        {
-            throw new Exception($"{_Name_}::DisposeTabOrder() - Exception: (see Inner Exception)", ex);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/UndoEngineExt.cs b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/UndoEngineExt.cs
deleted file mode 100644
index 84b8829201b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/UndoEngineExt.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.ComponentModel.Design;
-
-namespace DesignSurfaceExt;
-
-public class UndoEngineExt : UndoEngine
-{
-    private Stack<UndoEngine.UndoUnit> undoStack = new();
-    private Stack<UndoEngine.UndoUnit> redoStack = new();
-
-    public UndoEngineExt(IServiceProvider provider) : base(provider) { }
-
-    public bool EnableUndo
-    {
-        get { return undoStack.Count > 0; }
-    }
-
-    public bool EnableRedo
-    {
-        get { return redoStack.Count > 0; }
-    }
-
-    public void Undo()
-    {
-        if (undoStack.Count > 0)
-        {
-            try
-            {
-                UndoEngine.UndoUnit unit = undoStack.Pop();
-                unit.Undo();
-                redoStack.Push(unit);
-                //Log("::Undo - undo action performed: " + unit.Name);
-            }
-            catch
-            {
-                //Log("::Undo() - Exception " + ex.Message + " (line:" + new StackFrame(true).GetFileLineNumber() + ")");
-            }
-        }
-        else
-        {
-            //Log("::Undo - NO undo action to perform!");
-        }
-    }
-
-    public void Redo()
-    {
-        if (redoStack.Count > 0)
-        {
-            try
-            {
-                UndoEngine.UndoUnit unit = redoStack.Pop();
-                unit.Undo();
-                undoStack.Push(unit);
-                //Log("::Redo - redo action performed: " + unit.Name);
-            }
-            catch
-            {
-                //Log("::Redo() - Exception " + ex.Message + " (line:" + new StackFrame(true).GetFileLineNumber() + ")");
-            }
-        }
-        else
-        {
-            //Log("::Redo - NO redo action to perform!");
-        }
-    }
-
-    protected override void AddUndoUnit(UndoEngine.UndoUnit unit)
-    {
-        undoStack.Push(unit);
-    }
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/dll.ico b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/dll.ico
deleted file mode 100644
index f6ec6182bd8..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/DesignSurfaceExt/dll.ico and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/LICENSE.txt b/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/LICENSE.txt
deleted file mode 100644
index ba15d90b240..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/DesignSurface/LICENSE.txt
+++ /dev/null
@@ -1,231 +0,0 @@
-The Code Project Open License (CPOL) 1.02
-
-Preamble
-----------
-This License governs Your use of the Work. This License is intended to allow
-developers to use the Source Code and Executable Files provided as part of the
-Work in any application in any form.
-
-The main points subject to the terms of the License are:
-
-* Source Code and Executable Files can be used in commercial applications;
-* Source Code and Executable Files can be redistributed; and
-* Source Code can be modified to create derivative works.
-* No claim of suitability, guarantee, or any warranty whatsoever is provided. The
-software is provided "as-is".
-* The Article accompanying the Work may not be distributed or republished without
-the Author's consent
-
-This License is entered between You, the individual or other entity reading or
-otherwise making use of the Work licensed pursuant to this License and the
-individual or other entity which offers the Work under the terms of this License
-("Author").
-
-License
-----------
-THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CODE PROJECT
-OPEN LICENSE ("LICENSE"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER
-APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE
-OR COPYRIGHT LAW IS PROHIBITED.
-
-BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HEREIN, YOU ACCEPT AND AGREE TO
-BE BOUND BY THE TERMS OF THIS LICENSE. THE AUTHOR GRANTS YOU THE RIGHTS CONTAINED
-HEREIN IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS. IF YOU
-DO NOT AGREE TO ACCEPT AND BE BOUND BY THE TERMS OF THIS LICENSE, YOU CANNOT
-MAKE ANY USE OF THE WORK.
-
-1. Definitions.
-
-    a. "Articles" means, collectively, all articles written by Author which
-    describes how the Source Code and Executable Files for the Work may be used
-    by a user.
-
-    b. "Author" means the individual or entity that offers the Work under the
-    terms of this License.
-
-    c. "Derivative Work" means a work based upon the Work or upon the Work and
-    other pre-existing works.
-
-    d. "Executable Files" refer to the executables, binary files, configuration
-    and any required data files included in the Work.
-
-    e. "Publisher" means the provider of the website, magazine, CD-ROM, DVD or
-    other medium from or by which the Work is obtained by You.
-
-    f. "Source Code" refers to the collection of source code and configuration
-    files used to create the Executable Files.
-
-    g. "Standard Version" refers to such a Work if it has not been modified, or
-    has been modified in accordance with the consent of the Author, such consent
-    being in the full discretion of the Author.
-
-    h. "Work" refers to the collection of files distributed by the Publisher,
-    including the Source Code, Executable Files, binaries, data files,
-    documentation, whitepapers and the Articles.
-
-    i. "You" is you, an individual or entity wishing to use the Work and
-    exercise your rights under this License.
-
-2. Fair Use/Fair Use Rights. 
-Nothing in this License is intended to reduce, limit, or restrict any rights
-arising from fair use, fair dealing, first sale or other limitations on the
-exclusive rights of the copyright owner under copyright law or other applicable
-laws.
-
-3. License Grant. 
-Subject to the terms and conditions of this License, the Author hereby grants
-You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the
-applicable copyright) license to exercise the rights in the Work as stated
-below:
-
-    a. You may use the standard version of the Source Code or Executable Files
-    in Your own applications.
-
-    b. You may apply bug fixes, portability fixes and other modifications
-    obtained from the Public Domain or from the Author. A Work modified in such
-    a way shall still be considered the standard version and will be subject to
-    this License.
-
-    c. You may otherwise modify Your copy of this Work (excluding the Articles)
-    in any way to create a Derivative Work, provided that You insert a prominent
-    notice in each changed file stating how, when and where You changed that
-    file.
-
-    d. You may distribute the standard version of the Executable Files and Source
-    Code or Derivative Work in aggregate with other (possibly commercial)
-    programs as part of a larger (possibly commercial) software distribution.
-
-    e. The Articles discussing the Work published in any form by the author may
-    not be distributed or republished without the Author's consent. The author
-    retains copyright to any such Articles. You may use the Executable Files and
-    Source Code pursuant to this License but you may not repost or republish or
-    otherwise distribute or make available the Articles, without the prior
-    written consent of the Author.
-
-Any subroutines or modules supplied by You and linked into the Source Code or
-Executable Files of this Work shall not be considered part of this Work and will
-not be subject to the terms of this License.
-
-4. Patent License.
-Subject to the terms and conditions of this License, each Author hereby grants
-to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
-irrevocable (except as stated in this section) patent license to make, have made,
-use, import, and otherwise transfer the Work.
-
-5. Restrictions.
-The license granted in Section 3 above is expressly made subject to and limited
-by the following restrictions:
-
-    a. You agree not to remove any of the original copyright, patent, trademark,
-    and attribution notices and associated disclaimers that may appear in the
-    Source Code or Executable Files.
-
-    b. You agree not to advertise or in any way imply that this Work is a
-    product of Your own.
-
-    c. The name of the Author may not be used to endorse or promote products
-    derived from the Work without the prior written consent of the Author.
-
-    d. You agree not to sell, lease, or rent any part of the Work. This does not
-    restrict you from including the Work or any part of the Work inside a larger
-    software distribution that itself is being sold. The Work by itself, though,
-    cannot be sold, leased or rented.
-
-    e. You may distribute the Executable Files and Source Code only under the
-    terms of this License, and You must include a copy of, or the Uniform
-    Resource Identifier for, this License with every copy of the Executable
-    Files or Source Code You distribute and ensure that anyone receiving such
-    Executable Files and Source Code agrees that the terms of this License apply
-    to such Executable Files and/or Source Code. You may not offer or impose any
-    terms on the Work that alter or restrict the terms of this License or the
-    recipients' exercise of the rights granted hereunder. You may not sublicense
-    the Work. You must keep intact all notices that refer to this License and to
-    the disclaimer of warranties. You may not distribute the Executable Files or
-    Source Code with any technological measures that control access or use of the
-    Work in a manner inconsistent with the terms of this License.
-
-    f. You agree not to use the Work for illegal, immoral or improper purposes,
-    or on pages containing illegal, immoral or improper material. The Work is
-    subject to applicable export laws. You agree to comply with all such laws and
-    regulations that may apply to the Work after Your receipt of the Work.
-
-6. Representations, Warranties and Disclaimer.
-THIS WORK IS PROVIDED "AS IS", "WHERE IS" AND "AS AVAILABLE", WITHOUT ANY
-EXPRESS OR IMPLIED WARRANTIES OR CONDITIONS OR GUARANTEES. YOU, THE USER,
-ASSUME ALL RISK IN ITS USE, INCLUDING COPYRIGHT INFRINGEMENT, PATENT
-INFRINGEMENT, SUITABILITY, ETC. AUTHOR EXPRESSLY DISCLAIMS ALL EXPRESS, IMPLIED
-OR STATUTORY WARRANTIES OR CONDITIONS, INCLUDING WITHOUT LIMITATION, WARRANTIES
-OR CONDITIONS OF MERCHANTABILITY, MERCHANTABLE QUALITY OR FITNESS FOR A
-PARTICULAR PURPOSE, OR ANY WARRANTY OF TITLE OR NON-INFRINGEMENT, OR THAT THE
-WORK (OR ANY PORTION THEREOF) IS CORRECT, USEFUL, BUG-FREE OR FREE OF VIRUSES.
-YOU MUST PASS THIS DISCLAIMER ON WHENEVER YOU DISTRIBUTE THE WORK OR DERIVATIVE
-WORKS.
-
-7. Indemnity.
-You agree to defend, indemnify and hold harmless the Author and the Publisher
-from and against any claims, suits, losses, damages, liabilities, costs, and
-expenses (including reasonable legal or attorneys' fees) resulting from or
-relating to any use of the Work by You.
-
-8. Limitation on Liability.
-EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL THE AUTHOR OR
-THE PUBLISHER BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL,
-CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE
-USE OF THE WORK OR OTHERWISE, EVEN IF THE AUTHOR OR THE PUBLISHER HAS BEEN
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-9. Termination.
-
-    a. This License and the rights granted hereunder will terminate automatically
-    upon any breach by You of any term of this License. Individuals or entities
-    who have received Derivative Works from You under this License, however, will
-    not have their licenses terminated provided such individuals or entities
-    remain in full compliance with those licenses. Sections 1, 2, 6, 7, 8, 9, 10
-    and 11 will survive any termination of this License.
-
-    b. If You bring a copyright, trademark, patent or any other infringement
-    claim against any contributor over infringements You claim are made by the
-    Work, your License from such contributor to the Work ends automatically.
-
-    c. Subject to the above terms and conditions, this License is perpetual
-    (for the duration of the applicable copyright in the Work). Notwithstanding
-    the above, the Author reserves the right to release the Work under different
-    license terms or to stop distributing the Work at any time; provided, however
-    that any such election will not serve to withdraw this License (or any other
-    license that has been, or is required to be, granted under the terms of this
-    License), and this License will continue in full force and effect unless
-    terminated as stated above.
-
-10. Publisher.
-The parties hereby confirm that the Publisher shall not, under any circumstances,
-be responsible for and shall not have any liability in respect of the subject
-matter of this License. The Publisher makes no warranty whatsoever in connection
-with the Work and shall not be liable to You or any party on any legal theory
-for any damages whatsoever, including without limitation any general, special,
-incidental or consequential damages arising in connection to this license.
-The Publisher reserves the right to cease making the Work available to You at
-any time without notice
-
-11. Miscellaneous
-
-    a. This License shall be governed by the laws of the location of the head
-    office of the Author or if the Author is an individual, the laws of location
-    of the principal place of residence of the Author.
-
-    b. If any provision of this License is invalid or unenforceable under
-    applicable law, it shall not affect the validity or enforceability of the
-    remainder of the terms of this License, and without further action by the
-    parties to this License, such provision shall be reformed to the minimum
-    extent necessary to make such provision valid and enforceable.
-
-    c. No term or provision of this License shall be deemed waived and no breach
-    consented to unless such waiver or consent shall be in writing and signed by
-    the party to be charged with such waiver or consent.
-
-    d. This License constitutes the entire agreement between the parties with
-    respect to the Work licensed herein. There are no understandings, agreements
-    or representations with respect to the Work not specified herein. The Author
-    shall not be bound by any additional provisions that may appear in any
-    communication from You. This License may not be modified without the mutual
-    written agreement of the Author and You.
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/Directory.Build.props b/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/Directory.Build.props
deleted file mode 100644
index 75e14573cae..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/Directory.Build.props
+++ /dev/null
@@ -1,5 +0,0 @@
-<Project>
-
-  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/MauiTestsHelper/KeyboardHelper.cs b/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/MauiTestsHelper/KeyboardHelper.cs
deleted file mode 100644
index d6cbae6c3fa..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/MauiTestsHelper/KeyboardHelper.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Runtime.InteropServices;
-using static Interop.User32;
-
-namespace System.Windows.Forms.IntegrationTests.MauiTests
-{
-    public static class KeyboardHelper
-    {
-        public unsafe static void SendKey(Keys key, bool down)
-        {
-            var input = new INPUT();
-            input.type = INPUTENUM.KEYBOARD;
-            input.inputUnion.ki.wVk = (ushort)key;
-            input.inputUnion.ki.dwFlags = 0;
-            input.inputUnion.ki.dwExtraInfo = IntPtr.Zero;
-            input.inputUnion.ki.time = 0;
-            input.inputUnion.ki.wScan = 0;
-
-            if (!down)
-                input.inputUnion.ki.dwFlags |= KEYEVENTF.KEYUP;
-
-            SendInput(1, &input, Marshal.SizeOf(input));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/References.targets b/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/References.targets
deleted file mode 100644
index 77f72132e45..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/References.targets
+++ /dev/null
@@ -1,18 +0,0 @@
-<Project>
-
-  <!-- Note that all relative paths in this file are relative to the CSPROJ that is being built, NOT relative to this file -->
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-  </ItemGroup>
-    
-  <ItemGroup>
-    <Reference Include="GenStrings">
-      <HintPath>..\lib\GenStrings.dll</HintPath>
-    </Reference>
-    <Reference Include="WinformsTestLib">
-      <HintPath>..\lib\WinformsTestLib.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/GenStrings.dll b/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/GenStrings.dll
deleted file mode 100644
index 26866c963b0..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/GenStrings.dll and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/WinformsTestLib.dll b/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/WinformsTestLib.dll
deleted file mode 100644
index ba9e91c2757..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/MauiTests/lib/WinformsTestLib.dll and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.Designer.cs
deleted file mode 100644
index 0272aee032b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.Designer.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-
-namespace NativeHost;
-
-partial class ManagedControl
-{
-    /// <summary> 
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary> 
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Component Designer generated code
-
-    /// <summary> 
-    /// Required method for Designer support - do not modify 
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.button1 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.Anchor = System.Windows.Forms.AnchorStyles.None;
-        this.button1.Location = new System.Drawing.Point(37, 59);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(75, 23);
-        this.button1.TabIndex = 0;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        this.button1.Click += new System.EventHandler(this.button1_Click);
-        // 
-        // ExampleControl
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.Controls.Add(this.button1);
-        this.Name = "ManagedControl";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button button1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.cs b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.cs
deleted file mode 100644
index fff91f6b3ba..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-using System.Windows.Forms;
-
-namespace NativeHost;
-
-[ComVisible(true)]
-[Guid("54479E5D-EABC-448C-A767-EAFF17BC28C9")]
-[ComDefaultInterface(typeof(IManagedControl))]
-public partial class ManagedControl : UserControl, IManagedControl
-{
-    public ManagedControl()
-    {
-        CompModSwitches.ActiveX.Level = System.Diagnostics.TraceLevel.Verbose;
-
-        InitializeComponent();
-    }
-
-    private void button1_Click(object sender, EventArgs e)
-    {
-        MessageBox.Show("Hello world from .NET");
-    }
-}
-
-[ComVisible(true)]
-[Guid("3223D73E-286A-462C-AF8D-392D472673BF")]
-[InterfaceType(ComInterfaceType.InterfaceIsDual)]
-public interface IManagedControl { }
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.resx b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/ManagedControl.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/NativeHost.ManagedControl.csproj b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/NativeHost.ManagedControl.csproj
deleted file mode 100644
index 2cea3f9e2a2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost.ManagedControl/NativeHost.ManagedControl.csproj
+++ /dev/null
@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>NativeHost.ManagedControl</AssemblyName>
-    <Platforms>x86;x64</Platforms>
-    <EnableComHosting>true</EnableComHosting>
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.IgnoreBuild.targets b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.IgnoreBuild.targets
deleted file mode 100644
index 54008706835..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.IgnoreBuild.targets
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <!-- provides minimum msbuild target stubs so we can reference the project in arcade without building it -->
-  <Target Name="_IsProjectRestoreSupported" Returns="@(_ValidProjectsForRestore)">
-    <ItemGroup>
-      <_ValidProjectsForRestore Include="$(MSBuildProjectFullPath)" />
-    </ItemGroup>
-  </Target>
-  <Target Name="Restore" />
-  <Target Name="Clean" />
-  <Target Name="Build" />
-  <Target Name="Rebuild" />
-  <Target Name="Pack" />
-  <Target Name="Test" />
-  <Target Name="IntegrationTest" />
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.cpp b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.cpp
deleted file mode 100644
index 1ecf519ea6b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "pch.h"
-
-class CMainWindow : public CFrameWnd
-{
-public:
-	CWnd m_control;
-
-	BOOL Create()
-	{
-		CREATESTRUCT cs{};
-		cs.style = WS_OVERLAPPEDWINDOW;
-
-		if (!PreCreateWindow(cs))
-			return FALSE;
-
-		if (!CFrameWnd::Create(cs.lpszClass, m_strTitle))
-			return FALSE;
-
-		return TRUE;
-	}
-
-	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct)
-	{
-		if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
-			return -1;
-
-		CLSID clsid;
-		if (FAILED(IIDFromString(L"{54479E5D-EABC-448C-A767-EAFF17BC28C9}", &clsid)))
-			return -1;
-
-		if (!m_control.CreateControl(clsid, NULL, AFX_WS_DEFAULT_VIEW, CRect(), this, AFX_IDW_PANE_FIRST))
-			return -1;
-
-		return 0;
-	}
-
-	afx_msg void OnSize(UINT nType, int cx, int cy)
-	{
-		if (m_control)
-			m_control.SetWindowPos(NULL, 0, 0, cx, cy, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
-	}
-
-	afx_msg void OnSetFocus(CWnd* pOldWnd)
-	{
-		if (m_control)
-			m_control.SetFocus();
-	}
-
-	DECLARE_MESSAGE_MAP()
-};
-
-BEGIN_MESSAGE_MAP(CMainWindow, CFrameWnd)
-	ON_WM_CREATE()
-	ON_WM_SIZE()
-	ON_WM_SETFOCUS()
-END_MESSAGE_MAP()
-
-class CNativeHostApp : public CWinApp
-{
-public:
-	BOOL InitInstance() override
-	{
-		CWinApp::InitInstance();
-
-		AfxEnableControlContainer();
-
-		auto pWindow = new CMainWindow;
-		if (!pWindow)
-			return FALSE;
-
-		m_pMainWnd = pWindow;
-		
-		pWindow->SetTitle(L"Native WinForms Host");
-
-		if (!pWindow->Create())
-			return FALSE;
-
-		pWindow->ShowWindow(SW_SHOW);
-		pWindow->UpdateWindow();
-
-		return TRUE;
-	}
-
-	int ExitInstance() override
-	{
-		// a clean exit is currently not possible, we would have to force a garbage collection
-		// to ensure WinForms had a chance to release its COM objects before MFC exits
-		TerminateProcess(GetCurrentProcess(), S_OK);
-
-		return CWinApp::ExitInstance();
-	}
-};
-
-CNativeHostApp app;
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj
deleted file mode 100644
index 5705da9a560..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj
+++ /dev/null
@@ -1,162 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>16.0</VCProjectVersion>
-    <Keyword>Win32Proj</Keyword>
-    <ProjectGuid>{b68fd1fc-ea37-40f2-bbbd-77577a0a1815}</ProjectGuid>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Condition="'$(BuildingInsideVisualStudio)'=='true'" Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-    <UseOfMfc>Dynamic</UseOfMfc>
-  </PropertyGroup>
-  <Import Condition="'$(BuildingInsideVisualStudio)'=='true'" Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <OutDir>$(ArtifactsBinDir)NativeHost.ManagedControl\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</OutDir>
-    <IntDir>$(ArtifactsObjDir)$(ProjectName)\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</IntDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-    <OutDir>$(ArtifactsBinDir)NativeHost.ManagedControl\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</OutDir>
-    <IntDir>$(ArtifactsObjDir)$(ProjectName)\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</IntDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-    <OutDir>$(ArtifactsBinDir)NativeHost.ManagedControl\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</OutDir>
-    <IntDir>$(ArtifactsObjDir)$(ProjectName)\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</IntDir>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-    <OutDir>$(ArtifactsBinDir)NativeHost.ManagedControl\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</OutDir>
-    <IntDir>$(ArtifactsObjDir)$(ProjectName)\$(PlatformTarget)\$(Configuration)\$(TargetFramework)\</IntDir>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level4</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-      <TreatWarningAsError>true</TreatWarningAsError>
-      <DisableSpecificWarnings>4100</DisableSpecificWarnings>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <SubSystem>Windows</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="pch.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="pch.cpp">
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="NativeHost.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <Manifest Include="app.manifest" />
-  </ItemGroup>
-  <Import Condition="'$(BuildingInsideVisualStudio)'=='true'" Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <Import Condition="'$(BuildingInsideVisualStudio)'!='true'" Project="NativeHost.IgnoreBuild.targets" />
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj.filters b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj.filters
deleted file mode 100644
index f16996bf761..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/NativeHost.vcxproj.filters
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <ClCompile Include="pch.cpp" />
-    <ClCompile Include="NativeHost.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="pch.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <Manifest Include="app.manifest" />
-  </ItemGroup>
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/app.manifest b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/app.manifest
deleted file mode 100644
index 5211bfe49a2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/app.manifest
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="app"/>
-  <file name="NativeHost.ManagedControl.comhost.dll">
-    <comClass clsid="{54479E5D-EABC-448C-A767-EAFF17BC28C9}" threadingModel="Both" />
-  </file>
-</assembly>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.cpp b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.cpp
deleted file mode 100644
index 237f4ecc56e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "pch.h"
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.h b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.h
deleted file mode 100644
index 0b1de2cde39..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/pch.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-// Including SDKDDKVer.h defines the highest available Windows platform.
-// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
-// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
-#include <sdkddkver.h>
-
-#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit
-#define _AFX_NO_MFC_CONTROLS_IN_DIALOGS // remove support for MFC controls in dialogs
-#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
-
-#include <afx.h>
-#include <afxwin.h>
-#include <afxdtctl.h>
-#include <MsHTML.h>
-
-#ifdef _DEBUG
-#define new DEBUG_NEW
-#endif
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/readme.md b/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/readme.md
deleted file mode 100644
index dcfcce77985..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/NativeHost/readme.md
+++ /dev/null
@@ -1,3 +0,0 @@
-This project contains a native MFC application for hosting a .NET Core ActiveX control
-
-Currently the Arcade infrastructure in WinForms does not support building vcxproj so this must be built from Visual Studio.
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.Designer.cs
deleted file mode 100644
index 455b9f2fb83..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.Designer.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace ScratchProject;
-
-partial class Form1
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Text = "Form1";
-    }
-
-    #endregion
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.cs b/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.cs
deleted file mode 100644
index 38c1418fe5d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Form1.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace ScratchProject;
-
-// As we can't currently design in VS in the runtime solution, mark as "Default" so this opens in code view by default.
-[DesignerCategory("Default")]
-public partial class Form1 : Form
-{
-    public Form1()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Program.cs b/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Program.cs
deleted file mode 100644
index f07b87b9fd4..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/Program.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace ScratchProject;
-
-// This project is meant for temporary testing and experimenting and should be kept as simple as possible.
-
-internal static class Program
-{
-    [STAThread]
-    static void Main()
-    {
-        Application.EnableVisualStyles();
-        Application.SetHighDpiMode(HighDpiMode.PerMonitorV2);
-        Application.Run(new Form1());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/ScratchProject.csproj b/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/ScratchProject.csproj
deleted file mode 100644
index bbcb598a8bf..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/ScratchProject.csproj
+++ /dev/null
@@ -1,25 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <Nullable>enable</Nullable>
-    <OutputType>WinExe</OutputType>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <!-- These are needed to suppress the localization step picked up from Arcade targets -->
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-  </PropertyGroup>
-
-  <!-- These normally come from $(UseWindowsForms) when $(ImplicitUsings) is enabled -->
-  <ItemGroup>
-    <Using Include="System.Drawing" />
-    <Using Include="System.Windows.Forms" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\System.Drawing.Common\src\System.Drawing.Common.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/readme.txt b/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/readme.txt
deleted file mode 100644
index 739914eee0e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/ScratchProject/readme.txt
+++ /dev/null
@@ -1 +0,0 @@
-This project is meant for doing temporary testing and should be left as simple and basic as possible.
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/GlobalUsings.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/GlobalUsings.cs
deleted file mode 100644
index 2a5b2c4ac89..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using Windows.Win32;
-global using HWND = Windows.Win32.Foundation.HWND;
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/MainFormControlsTabOrder.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/MainFormControlsTabOrder.cs
deleted file mode 100644
index 4f51505337e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/MainFormControlsTabOrder.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.IntegrationTests.Common;
-
-public enum MainFormControlsTabOrder
-{
-    ButtonsButton = 0,
-    CalendarButton,
-    MultipleControlsButton,
-    ComboBoxesButton,
-    ComboBoxesWithScrollBarsButton,
-    DateTimePickerButton,
-    DialogsButton,
-    DataGridViewButton,
-    DataGridViewInVirtualModeButton,
-    TreeViewButton,
-    ContentAlignmentButton,
-    MenusButton,
-    PanelsButton,
-    SplitterButton,
-    MdiParentButton,
-    PropertyGridButton,
-    ListViewButton,
-    FontNameEditorButton,
-    CollectionEditorsButton,
-    RichTextBoxesButton,
-    PictureBoxesButton,
-    FormBorderStylesButton,
-    FormShowInTaskbarButton,
-    ToggleIconButton,
-    ErrorProviderButton,
-    TaskDialogButton,
-    MessageBoxButton,
-    ToolStripsButton,
-    TrackBarsButton,
-    ScrollBarsButton,
-    ToolTipsButton,
-    AnchorLayoutButton,
-    DockLayoutButton,
-    DragAndDrop,
-    TextBoxesButton,
-    MediaPlayerButton,
-    FormOwnerTestButton,
-    ListBoxTestButton
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/Person.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/Person.cs
deleted file mode 100644
index c71a0abf2af..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/Person.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.IntegrationTests.Common;
-
-public class Person
-{
-    public Person(int id, string name)
-    {
-        Id = id;
-        Name = name;
-    }
-
-    public int Id { get; set; }
-    public string Name { get; set; }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/System.Windows.Forms.IntegrationTests.Common.csproj b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/System.Windows.Forms.IntegrationTests.Common.csproj
deleted file mode 100644
index e3674d38d67..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/System.Windows.Forms.IntegrationTests.Common.csproj
+++ /dev/null
@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
- 
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="$(MoqPackage)" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="$(XUnitStaFactPackage)" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-    <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestDataSources.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestDataSources.cs
deleted file mode 100644
index 32c4b02123e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestDataSources.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.IntegrationTests.Common;
-
-public static class TestDataSources
-{
-    public static List<Person> GetPersons()
-        => new()
-        {
-            new Person(1, "Name 1"),
-            new Person(2, "Name 2"),
-            new Person(3, "Name 3"),
-            new Person(4, "Name 4"),
-            new Person(5, "Name 5"),
-        };
-
-    public const string PersonDisplayMember = "Name";
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestHelpers.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestHelpers.cs
deleted file mode 100644
index 84aca654cc9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests.Common/TestHelpers.cs
+++ /dev/null
@@ -1,463 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Diagnostics;
-using System.Globalization;
-using System.Reflection;
-using Newtonsoft.Json.Linq;
-
-namespace System.Windows.Forms.IntegrationTests.Common;
-
-public static class TestHelpers
-{
-    /// <summary>
-    ///  Gets the current config
-    /// </summary>
-    private static string Config
-    {
-        get
-        {
-#if DEBUG
-            return "Debug";
-#else
-            return "Release";
-#endif
-        }
-    }
-
-    /// <summary>
-    /// Should always match the TargetFramework in the .csproj
-    /// </summary>
-    private static string TargetFramework
-    {
-        get
-        {
-            var frameworkAttribute = (Runtime.Versioning.TargetFrameworkAttribute)Assembly.GetExecutingAssembly()
-                .GetCustomAttributes(typeof(Runtime.Versioning.TargetFrameworkAttribute), false)
-                .SingleOrDefault();
-
-            string[] etractedTokens = frameworkAttribute.FrameworkName.Split("=v"); // "NetcoreApp, Version=v7.0"
-
-            return $"net{etractedTokens[1]}";
-        }
-    }
-
-    /// <summary>
-    ///  Get the output exe path for a specified project.
-    ///  Throws an exception if the path does not exist
-    /// </summary>
-    /// <param name="projectName">The name of the project</param>
-    /// <returns>The exe path</returns>
-    public static string GetExePath(string projectName)
-    {
-        if (string.IsNullOrEmpty(projectName))
-            throw new ArgumentNullException(nameof(projectName));
-
-        var repoRoot = GetRepoRoot();
-        var exePath = Path.Combine(repoRoot, $"artifacts\\bin\\{projectName}\\{Config}\\{TargetFramework}\\{projectName}.exe");
-
-        if (!File.Exists(exePath))
-            throw new FileNotFoundException("File does not exist", exePath);
-
-        return exePath;
-    }
-
-    /// <summary>
-    ///  Start a process with the specified path.
-    ///  Also searches for a local .dotnet folder and adds it to the path.
-    ///  If a local folder is not found, searches for a machine-wide install that matches
-    ///  the version specified in the global.json.
-    /// </summary>
-    /// <param name="path">The path to the file to execute</param>
-    /// <param name="setCwd">Set the current working directory to the process path</param>
-    /// <returns>The new Process</returns>
-    public static Process StartProcess(string path, bool setCwd = false)
-    {
-        if (string.IsNullOrEmpty(path))
-            throw new ArgumentNullException(nameof(path));
-
-        if (!File.Exists(path))
-            throw new FileNotFoundException("File does not exist", path);
-
-        var startInfo = new ProcessStartInfo
-        {
-            FileName = path
-        };
-        if (setCwd)
-        {
-            startInfo.WorkingDirectory = Path.GetDirectoryName(path);
-        }
-
-        return StartProcess(startInfo);
-    }
-
-    /// <summary>
-    ///  Start a process with the specified start info.
-    ///  Also searches for a local .dotnet folder and adds it to the path.
-    ///  If a local folder is not found, searches for a machine-wide install that matches
-    ///  the version specified in the global.json.
-    /// </summary>
-    /// <param name="startInfo">The start info</param>
-    /// <returns>The new Process</returns>
-    public static Process StartProcess(ProcessStartInfo startInfo)
-    {
-        var dotnetPath = GetDotNetPath();
-        if (!Directory.Exists(dotnetPath))
-            throw new DirectoryNotFoundException($"{dotnetPath} directory cannot be found.");
-
-        var process = new Process();
-
-        // Set the dotnet_root for the exe being launched
-        // This allows the exe to look for runtime dependencies (like the shared framework (NetCore.App))
-        // outside of the normal machine-wide install location (program files\dotnet)
-        startInfo.EnvironmentVariables["DOTNET_ROOT"] = dotnetPath;
-        process.StartInfo = startInfo;
-
-        process.Start();
-        process.WaitForExit(500);
-        return process;
-    }
-
-    /// <summary>
-    /// End the process.
-    /// </summary>
-    /// <returns>The process ExitCode</returns>
-    public static int EndProcess(Process process, int timeout = Timeout.Infinite)
-    {
-        try
-        {
-            process.Kill();
-        }
-        catch (Exception)
-        {
-        }
-
-        process.WaitForExit(timeout);
-        return process.ExitCode;
-    }
-
-    /// <summary>
-    ///  Get the path where dotnet is installed
-    /// </summary>
-    /// <returns>The full path of the folder containing the dotnet.exe</returns>
-    private static string GetDotNetPath()
-    {
-        string dotNetPath;
-
-        // walk the dir tree up, looking for a .dotnet folder
-        try
-        {
-            dotNetPath = RelativePathBackwardsUntilFind(".dotnet");
-        }
-        catch (DirectoryNotFoundException)
-        {
-            // If there is no private install, check for a machine-wide install
-            dotNetPath = GetGlobalDotNetPath();
-        }
-
-        return dotNetPath;
-    }
-
-    /// <summary>
-    ///  Get the path of the globally installed dotnet that matches the version specified in the global.json
-    ///
-    ///  The file looks something like this:
-    ///
-    ///  {
-    ///  "tools": {
-    ///  "dotnet": "3.0.100-preview5-011568"
-    ///  },
-    ///
-    ///  All we care about is the dotnet entry under tools
-    /// </summary>
-    /// <returns>The path to the globally installed dotnet that matches the version specified in the global.json.</returns>
-    private static string GetGlobalDotNetPath()
-    {
-        // find the repo root
-        var repoRoot = GetRepoRoot();
-
-        // make sure there's a global.json
-        var jsonFile = Path.Combine(repoRoot, "global.json");
-        if (!File.Exists(jsonFile))
-            throw new FileNotFoundException("global.json does not exist");
-
-        // parse the file into a json object
-        var jsonContents = File.ReadAllText(jsonFile);
-        var jsonObject = JObject.Parse(jsonContents);
-
-        string dotnetVersion;
-        try
-        {
-            // check if tools:dotnet is specified
-            dotnetVersion = jsonObject["tools"]["dotnet"].ToString();
-        }
-        catch
-        {
-            // no version was found, so we're done
-            throw new Exception("global.json does not contain a tools:dotnet version");
-        }
-
-        // Check to see if the matching version is installed
-        // The default install location is C:\Program Files\dotnet\sdk
-        var defaultSdkRoot = @"C:\Program Files\dotnet\sdk";
-        var sdkPath = Path.Combine(defaultSdkRoot, dotnetVersion);
-        if (!Directory.Exists(sdkPath))
-            throw new DirectoryNotFoundException($"dotnet sdk {dotnetVersion} is not installed globally");
-
-        // if we get here, there was a match
-        return sdkPath;
-    }
-
-    /// <summary>
-    ///  Get the full path to the root of the repository
-    /// </summary>
-    /// <returns>The repo root</returns>
-    private static string GetRepoRoot()
-    {
-        var gitPath = RelativePathBackwardsUntilFind(".git");
-        var repoRoot = Directory.GetParent(gitPath).FullName;
-        return repoRoot;
-    }
-
-    /// <summary>
-    ///  Looks backwards form the current executing directory until it finds a sibling directory seek, then returns the full path of that sibling
-    /// </summary>
-    /// <param name="seek">The sibling directory to look for</param>
-    /// <returns>The full path of the first sibling directory by the current executing directory, away from the root</returns>
-    private static string RelativePathBackwardsUntilFind(string seek)
-    {
-        if (string.IsNullOrEmpty(seek))
-        {
-            throw new ArgumentNullException(nameof(seek));
-        }
-
-        var codeBaseUrl = new Uri(Assembly.GetExecutingAssembly().Location);
-        var codeBasePath = Uri.UnescapeDataString(codeBaseUrl.AbsolutePath);
-        var currentDirectory = Path.GetDirectoryName(codeBasePath);
-        var root = Directory.GetDirectoryRoot(currentDirectory);
-        while (!currentDirectory.Equals(root, StringComparison.CurrentCultureIgnoreCase))
-        {
-            if (Directory.GetDirectories(currentDirectory, seek, SearchOption.TopDirectoryOnly).Length == 1)
-            {
-                var ret = Path.Combine(currentDirectory, seek);
-                return ret;
-            }
-
-            currentDirectory = Directory.GetParent(currentDirectory).FullName;
-        }
-
-        throw new DirectoryNotFoundException($"No {seek} folder was found among siblings of subfolders of {codeBasePath}.");
-    }
-
-    /// <summary>
-    ///  Presses Enter on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Enter key to</param>
-    /// <returns>Whether or not the Enter key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendEnterKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "~", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Tab on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Tab key to</param>
-    /// <returns>Whether or not the Tab key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendTabKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{TAB}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Backspace on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Backspace key to</param>
-    /// <returns>Whether or not the Backspace key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendBackspaceKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{BACKSPACE}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Right on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Right key to</param>
-    /// <returns>Whether or not the Right key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendRightArrowKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{RIGHT}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Down on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Down key to</param>
-    /// <returns>Whether or not the Down key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendDownArrowKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{DOWN}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Left on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Left key to</param>
-    /// <returns>Whether or not the Left key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendLeftArrowKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{LEFT}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Up on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Up key to</param>
-    /// <returns>Whether or not the Up key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendUpArrowKeyToProcess(Process process, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, "{UP}");
-    }
-
-    /// <summary>
-    ///  Presses Alt plus choosen letter on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Alt and key to</param>
-    /// <param name="letter">Letter in addition to Alt to send to process.</param>
-    /// <returns>Whether or not the Up key was pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendAltKeyToProcess(Process process, char letter, bool switchToMainWindow = true)
-    {
-        return SendKeysToProcess(process, $"%{{{letter}}}", switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Presses Tab any number of times on the given process if it can be made the foreground process
-    /// </summary>
-    /// <param name="process">The process to send the Tab key(s) to</param>
-    /// <param name="times">The number of times to press tab in a row</param>
-    /// <remarks>Throws an ArgumentException if number of times is zero; this is unlikely to be intended.</remarks>
-    /// <returns>Whether or not the Tab key(s) were pressed on the process</returns>
-    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
-    public static bool SendTabKeysToProcess(Process process, MainFormControlsTabOrder times, bool switchToMainWindow = true)
-    {
-        return SendTabKeysToProcess(process, (int)times, switchToMainWindow);
-    }
-
-    public static bool SendTabKeysToProcess(Process process, int times, bool switchToMainWindow = true)
-    {
-        if (times == 0)
-        {
-            return true;
-        }
-
-        string keys = string.Empty;
-        for (uint i = 0; i < times; i++)
-        {
-            keys += "{TAB}";
-        }
-
-        return SendKeysToProcess(process, keys, switchToMainWindow);
-    }
-
-    /// <summary>
-    ///  Bring the specified form to the foreground
-    /// </summary>
-    /// <param name="form">The form</param>
-    public static void BringToForeground(this Form form)
-    {
-        if (form is null)
-            throw new ArgumentNullException(nameof(form));
-
-        form.WindowState = FormWindowState.Minimized;
-        form.Show();
-        form.WindowState = FormWindowState.Normal;
-    }
-
-    /// <summary>
-    ///  Set the culture for the current thread
-    /// </summary>
-    /// <param name="culture">The culture</param>
-    public static void SetCulture(this Thread thread, string culture)
-    {
-        if (string.IsNullOrEmpty(culture))
-            throw new ArgumentNullException(nameof(culture));
-
-        var cultureInfo = new CultureInfo(culture);
-        Thread.CurrentThread.CurrentCulture = cultureInfo;
-        Thread.CurrentThread.CurrentUICulture = cultureInfo;
-    }
-
-    /// <summary>
-    ///  Presses the given keys on the given process, then waits 200ms
-    /// </summary>
-    /// <param name="process">The process to send the key(s) to</param>
-    /// <param name="keys">The key(s) to send to the process</param>
-    /// <exception cref="ArgumentException">
-    ///  <paramref name="process"/> is <see langword="null"/> or has exited or <paramref name="keys"/>
-    ///  is <see langword="null"/> or empty.
-    /// </exception>
-    /// <returns>Whether or not the key(s) were pressed on the process</returns>
-    /// <seealso cref="Process.MainWindowHandle"/>
-    /// <seealso cref="PInvoke.SetForegroundWindow{T}(T)"/>
-    /// <seealso cref="PInvoke.GetForegroundWindow()"/>
-    /// <seealso cref="SendKeys.SendWait(string)"/>
-    /// <seealso cref="Thread.Sleep(int)"/>
-    internal static bool SendKeysToProcess(Process process, string keys, bool switchToMainWindow = true)
-    {
-        if (process is null)
-        {
-            throw new ArgumentException($"{nameof(process)} must not be null.");
-        }
-
-        if (process.HasExited)
-        {
-            throw new ArgumentException($"{nameof(process)} must not have exited.");
-        }
-
-        if (string.IsNullOrEmpty(keys))
-        {
-            throw new ArgumentException($"{nameof(keys)} must not be null or empty.");
-        }
-
-        HWND mainWindowHandle = (HWND)process.MainWindowHandle;
-
-        if (switchToMainWindow)
-        {
-            PInvoke.SetForegroundWindow(mainWindowHandle);
-        }
-
-        HWND foregroundWindow = PInvoke.GetForegroundWindow();
-
-        string windowTitle = PInvoke.GetWindowText(foregroundWindow);
-
-        if (PInvoke.GetWindowThreadProcessId(foregroundWindow, out uint processId) == 0 ||
-            processId != process.Id)
-        {
-            Debug.WriteLine($"ForegroundWindow doesn't belong the test process! The current window is {windowTitle}.");
-        }
-
-        if ((switchToMainWindow && mainWindowHandle.Equals(foregroundWindow)) ||
-            (!switchToMainWindow && foregroundWindow != IntPtr.Zero))
-        {
-            SendKeys.SendWait(keys);
-
-            Thread.Sleep(200);
-
-            return true;
-        }
-        else
-        {
-            Debug.Assert(true, $"Given process could not be made to be the ForegroundWindow. The current window is {windowTitle}.");
-
-            return false;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/Mocks/MainObject.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/Mocks/MainObject.cs
deleted file mode 100644
index a62fa48c33d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/Mocks/MainObject.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.IntegrationTests.Mocks;
-
-public class MainObject : INotifyPropertyChanged
-{
-    private string text;
-    private PropertyChangedEventHandler _propertyChanged;
-
-    public string Text
-    {
-        get { return text; }
-        set
-        {
-            if (text != value)
-            {
-                text = value;
-                if (_propertyChanged is not null)
-                {
-                    _propertyChanged(this, new PropertyChangedEventArgs(nameof(Text)));
-                }
-            }
-        }
-    }
-
-    public event PropertyChangedEventHandler PropertyChanged
-    {
-        add => _propertyChanged += value;
-        remove => _propertyChanged -= value;
-    }
-
-    public bool IsPropertyChangedAssigned { get { return _propertyChanged is not null; } }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/System.Windows.Forms.IntegrationTests.csproj b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/System.Windows.Forms.IntegrationTests.csproj
deleted file mode 100644
index bab99c8eff6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/System.Windows.Forms.IntegrationTests.csproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\WinformsControlsTest\WinformsControlsTest.csproj" />
-  </ItemGroup>
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/WinformsControlsTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/WinformsControlsTest.cs
deleted file mode 100644
index 95a4cfcfba3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.IntegrationTests/WinformsControlsTest.cs
+++ /dev/null
@@ -1,225 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-//#define MAUI
-
-using System.Diagnostics;
-using System.Windows.Forms.IntegrationTests.Common;
-using Xunit;
-
-namespace System.Windows.Forms.IntegrationTests;
-
-public partial class WinformsControlsTest
-{
-    private const string ProjectName = "WinformsControlsTest";
-    private readonly string _exePath;
-
-    public WinformsControlsTest()
-    {
-        _exePath = TestHelpers.GetExePath(ProjectName);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_OpenAndClose()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-
-        Assert.NotNull(process);
-        Assert.NotNull(Process.GetProcessById(process.Id));
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Theory]
-    [InlineData(MainFormControlsTabOrder.ButtonsButton)]
-    [InlineData(MainFormControlsTabOrder.CalendarButton)]
-    [InlineData(MainFormControlsTabOrder.MultipleControlsButton)]
-    [InlineData(MainFormControlsTabOrder.ComboBoxesButton)]
-    [InlineData(MainFormControlsTabOrder.DateTimePickerButton)]
-    [InlineData(MainFormControlsTabOrder.DialogsButton)]
-    [InlineData(MainFormControlsTabOrder.DataGridViewButton)]
-    [InlineData(MainFormControlsTabOrder.TreeViewButton)]
-    [InlineData(MainFormControlsTabOrder.ContentAlignmentButton)]
-    [InlineData(MainFormControlsTabOrder.MenusButton)]
-    [InlineData(MainFormControlsTabOrder.PanelsButton)]
-    [InlineData(MainFormControlsTabOrder.SplitterButton)]
-    [InlineData(MainFormControlsTabOrder.MdiParentButton)]
-    [InlineData(MainFormControlsTabOrder.PropertyGridButton)]
-    [InlineData(MainFormControlsTabOrder.ListViewButton)]
-    [InlineData(MainFormControlsTabOrder.FontNameEditorButton)]
-    [InlineData(MainFormControlsTabOrder.CollectionEditorsButton)]
-    [InlineData(MainFormControlsTabOrder.RichTextBoxesButton)]
-    [InlineData(MainFormControlsTabOrder.PictureBoxesButton)]
-    [InlineData(MainFormControlsTabOrder.FormBorderStylesButton)]
-    [InlineData(MainFormControlsTabOrder.ToggleIconButton)]
-#endif
-    public void WinformsControlsTest_InnerForms_OpenAndClose(MainFormControlsTabOrder tabOrder)
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, tabOrder);
-        TestHelpers.SendEnterKeyToProcess(process);
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_CalendarTest()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, MainFormControlsTabOrder.CalendarButton);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false);
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_ThreadExceptionDialogTest()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, MainFormControlsTabOrder.DialogsButton);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendTabKeysToProcess(process, 3);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendTabKeysToProcess(process, 2);
-        TestHelpers.SendEnterKeyToProcess(process);
-
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_PropertyGrid_CollectionEditorTest()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, MainFormControlsTabOrder.PropertyGridButton);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendTabKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false); // once
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false); // twice
-        TestHelpers.SendTabKeysToProcess(process, 2, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_FileDialogTest()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, MainFormControlsTabOrder.DialogsButton);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendRightArrowKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendBackspaceKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-        TestHelpers.SendTabKeysToProcess(process, 1, switchToMainWindow: false);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void WinformsControlsTest_OpenFolderBrowserDialogTest()
-    {
-        Process process = TestHelpers.StartProcess(_exePath);
-        TestHelpers.SendTabKeysToProcess(process, MainFormControlsTabOrder.DialogsButton);
-        TestHelpers.SendEnterKeyToProcess(process);
-        TestHelpers.SendEnterKeyToProcess(process, switchToMainWindow: false);
-
-        TestHelpers.SendAltKeyToProcess(process, 'b', switchToMainWindow: false);
-        TestHelpers.SendAltKeyToProcess(process, 'o', switchToMainWindow: false);
-
-        process.WaitForExit(2_000);
-        Assert.False(process.HasExited);
-
-        process.Kill();
-        process.WaitForExit();
-
-        Assert.True(process.HasExited);
-    }
-
-#if MAUI
-    [Fact]
-#endif
-    public void DataBindings_remove_should_unsubscribe_INotifyPropertyChanged_PropertyChanged_event()
-    {
-        var mainObject = new Mocks.MainObject();
-        mainObject.Text = "Test text";
-        Form form = new Form();
-        TextBox textBox = new TextBox();
-        Binding binding = new Binding("Text", mainObject, "Text");
-        textBox.DataBindings.Add(binding);
-        textBox.Parent = form;
-        form.Show();
-
-        // bindings set
-        Assert.True(mainObject.IsPropertyChangedAssigned);
-
-        // remove bindings
-        textBox.DataBindings.Clear();
-
-        // bindings unset
-        Assert.False(mainObject.IsPropertyChangedAssigned);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiDataAttribute.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiDataAttribute.cs
deleted file mode 100644
index 36b579e91ea..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiDataAttribute.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Reflection;
-using Xunit;
-using Xunit.Sdk;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This is a custom xUnit memberdata attribute which allows us to execute code
-    ///  before the data is resolved. It's needed because we want to read scenario names from
-    ///  test results while still being able to use memberdata to parameterize the xUnit test,
-    ///  but the normal MemberData attribute resolves before anything else (even the constructor)
-    ///  is invoked.
-    ///
-    ///  This code is based on an example at https://tpodolak.com/blog/2017/06/19/xunit-memberdataattribute-generic-type-inheritance/
-    /// </summary>
-    [DataDiscoverer("Xunit.Sdk.MemberDataDiscoverer", "xunit.core")]
-    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-    public class MauiDataAttribute : MemberDataAttributeBase
-    {
-        /// <summary>
-        ///  The name of the maui test project to get scenarios for
-        /// </summary>
-        private readonly string _projectName;
-
-        // don't pass anything to the base class because we don't need it
-        public MauiDataAttribute(string projectName) : base(null, null)
-        {
-            _projectName = projectName;
-
-            // This makes it so visual studio doesn't try to populate the test explorer
-            // with each maui scenario before the tests are actually executed.
-            // This is important because once the data is retrieved before the tests are run,
-            // it will never be updated again unless you do a full clean/rebuild.
-            // So if you add a scenario to a maui test, for example, the new scenario won't show
-            // up in the test explorer.
-            DisableDiscoveryEnumeration = true;
-        }
-
-        /// <summary>
-        ///  This is the method that actually returns the data that will be parameterized into the
-        ///  xUnit test method. We actually don't use the base class logic at all,
-        ///  we just get the scenarios for the specified project name and return them.
-        /// </summary>
-        /// <param name="testMethod">MethodInfo of the method being decorated</param>
-        /// <returns>The test data</returns>
-        public override IEnumerable<object[]> GetData(MethodInfo testMethod)
-        {
-#if MAUI
-            // get the scenarios
-            var scenarios = MauiTestHelper.GetScenarios(_projectName);
-
-            // convert the data to the expected format
-            return scenarios.Select(x => new object[] { x });
-#else
-            return Enumerable.Empty<object[]>();
-#endif
-        }
-
-        /// <summary>
-        ///  Required to derive from MemberDataAttributeBase
-        /// </summary>
-        /// <param name="testMethod">MethodInfo of the method being decorated</param>
-        /// <param name="item">The item representing a single line of data</param>
-        /// <returns>The item as an object array</returns>
-        protected override object[] ConvertDataItem(MethodInfo testMethod, object item)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestHelper.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestHelper.cs
deleted file mode 100644
index 333ecb21ee7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestHelper.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Reflection;
-using System.Windows.Forms.IntegrationTests.Common;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class performs common operations for maui xUnit tests.
-    /// </summary>
-    public static class MauiTestHelper
-    {
-        /// <summary>
-        ///  The test runner
-        /// </summary>
-        private static readonly MauiTestRunner s_testRunner = new MauiTestRunner();
-
-        /// <summary>
-        ///  The test results, indexed by project name
-        /// </summary>
-        private static readonly Dictionary<string, TestResult> s_testResults = new Dictionary<string, TestResult>();
-
-        /// <summary>
-        ///  Get the scenarios that will run for a specified maui project
-        /// </summary>
-        /// <param name="projectName">The project</param>
-        /// <returns>The scenarios that ran</returns>
-        public static IEnumerable<string> GetScenarios(string projectName)
-        {
-            var scenarios = new List<string>();
-
-            // get the path to the maui test executable
-            var exePath = TestHelpers.GetExePath(projectName);
-
-            // make sure the dll exists too, since that's the assembly we really have to load
-            var dllPath = exePath.Replace(".exe", ".dll");
-            if (!File.Exists(dllPath))
-                throw new FileNotFoundException("Unable to get Maui scenarios, file not found", dllPath);
-
-            // Load the assembly. Note we have to load the dll instead of the exe because
-            // of an architecture mismatch. Otherwise the line below will throw a BadImageFormatException
-            var assembly = Assembly.LoadFrom(dllPath);
-
-            // Look for all methods on all types with the '[Scenario(true)]' attribute
-            foreach (var type in assembly.DefinedTypes)
-            {
-                foreach (var methodInfo in type.GetMethods())
-                {
-                    var attributes = methodInfo.GetCustomAttributes();
-                    foreach (dynamic attribute in attributes)
-                    {
-                        if (attribute.TypeId.Name != "ScenarioAttribute")
-                            continue;
-
-                        if (!attribute.IsScenario)
-                            continue;
-
-                        // if we get here, the method has [Scenario(true)]
-                        scenarios.Add(methodInfo.Name);
-                    }
-                }
-            }
-
-            return scenarios;
-        }
-
-        /// <summary>
-        ///  Validate a specified scenario passed.
-        /// </summary>
-        /// <param name="projectName">The name of the maui project</param>
-        /// <param name="scenarioName">The name of the scenario</param>
-        public static void ValidateScenarioPassed(string projectName, string scenarioName, ITestOutputHelper output = null)
-        {
-            // if the test hasn't run yet for the specified projectName, run it
-            if (!s_testResults.ContainsKey(projectName))
-            {
-                RunMauiTest(projectName);
-            }
-
-            var scenario = s_testResults[projectName].ScenarioGroup.Scenarios.SingleOrDefault(x => x.Name == scenarioName);
-
-            Assert.NotNull(scenario);
-            Assert.NotNull(scenario.Result);
-
-            if (output is not null && scenario.Result.Type != "Pass" && scenario.Text?.Length > 0)
-            {
-                output.WriteLine($"Log:{string.Join("\r\n", scenario.Text)}");
-            }
-
-            Assert.Equal("Pass", scenario.Result.Type);
-        }
-
-        /// <summary>
-        ///  Run the maui test for the specified project name and store the results
-        /// </summary>
-        /// <param name="projectName">The name of the project to run</param>
-        private static void RunMauiTest(string projectName)
-        {
-            if (string.IsNullOrEmpty(projectName))
-                throw new ArgumentNullException(nameof(projectName));
-
-            if (s_testResults.ContainsKey(projectName))
-                throw new InvalidOperationException($"Maui test for {projectName} has already run. Please double-check the project name in your test class.");
-
-            var exePath = TestHelpers.GetExePath(projectName);
-            var result = s_testRunner.RunTest(exePath);
-            Assert.NotNull(result);
-            Assert.NotNull(result.ScenarioGroup);
-
-            s_testResults[projectName] = result;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestRunner.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestRunner.cs
deleted file mode 100644
index cd170b66833..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/MauiTestRunner.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Windows.Forms.IntegrationTests.Common;
-using System.Xml.Serialization;
-using static Interop.User32;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class is used to run maui tests (exe) and gather the results.
-    ///  Maui tests are executables that run one or more scenarios, and the results are
-    ///  stored in a results.log. This class handles running the exe, deserializing the log
-    ///  into a TestCase object, and returning that object to the caller.
-    ///
-    /// </summary>
-    public class MauiTestRunner
-    {
-        /// <summary>
-        ///  Run a Maui test at the specified path and return the results
-        /// </summary>
-        /// <param name="path">The path to execute</param>
-        /// <returns>The test results</returns>
-        public TestResult RunTest(string path)
-        {
-            // run the maui test exe, making sure to set the cwd of the process
-            // (so the results.log gets generated in the right place)
-            var process = TestHelpers.StartProcess(path, true);
-            SetForegroundWindow(process.Handle);
-            process.WaitForExit();
-
-            // deserialize the results.log into a TestResult instance
-            var logDir = Path.GetDirectoryName(path);
-            var logPath = Path.Combine(logDir, "results.log");
-            using (var reader = new StreamReader(logPath))
-            {
-                var serializer = new XmlSerializer(typeof(TestResult));
-                if (!(serializer.Deserialize(reader) is TestResult testResult))
-                    throw new InvalidOperationException("Maui results log can't be parsed into a TestResult, file is probably malformed");
-
-                return testResult;
-            }
-        }
-    }
-
-    #region Serialization Classes
-
-    // The following are used to deserialize test result xml to C# classes
-    /// <remarks/>
-    [Serializable()]
-    [XmlRoot("Testcase")]
-    public class TestResult
-    {
-        [XmlAttribute("name")]
-        public string Name { get; set; }
-
-        [XmlElement()]
-        public ScenarioGroup ScenarioGroup { get; set; }
-
-        [XmlElement()]
-        public FinalResults FinalResults { get; set; }
-    }
-
-    [Serializable()]
-    public class ScenarioGroup
-    {
-        [XmlAttribute("name")]
-        public string Name { get; set; }
-
-        /// <remarks/>
-        [XmlElement("Scenario")]
-        public Scenario[] Scenarios { get; set; }
-
-        [XmlElement()]
-        public ClassResults ClassResults { get; set; }
-    }
-
-    [Serializable()]
-    public class Scenario
-    {
-        private string _name;
-
-        [XmlAttribute("method")]
-        public string Method { get; set; }
-
-        // strip the parens from the name
-        [XmlAttribute("name")]
-        public string Name
-        {
-            get => _name;
-            set
-            {
-                if (value.EndsWith("()"))
-                {
-                    _name = value.Remove(value.Length - 2);
-                }
-            }
-        }
-
-        [XmlElement()]
-        public Result Result { get; set; }
-
-        /// <remarks/>
-        [XmlText()]
-        public string[] Text { get; set; }
-    }
-
-    [Serializable()]
-    public class Result
-    {
-        [XmlAttribute("type")]
-        public string Type { get; set; }
-    }
-
-    [Serializable()]
-    public partial class ClassResults
-    {
-        [XmlAttribute("type")]
-        public string Type { get; set; }
-
-        [XmlAttribute("total")]
-        public int Total { get; set; }
-
-        [XmlAttribute("fail")]
-        public int Fail { get; set; }
-    }
-
-    [Serializable()]
-    public class FinalResults
-    {
-        [XmlAttribute("type")]
-        public string Type { get; set; }
-
-        [XmlAttribute("total")]
-        public int Total { get; set; }
-
-        [XmlAttribute("fail")]
-        public int Fail { get; set; }
-    }
-
-    #endregion Serialization Classes
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/System.Windows.Forms.Maui.IntegrationTests.csproj b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/System.Windows.Forms.Maui.IntegrationTests.csproj
deleted file mode 100644
index e195162b80c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/System.Windows.Forms.Maui.IntegrationTests.csproj
+++ /dev/null
@@ -1,12 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
-    <ProjectReference Include="..\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiComboBoxTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiComboBoxTests.cs
deleted file mode 100644
index a5853c2ea07..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiComboBoxTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiComboBoxTests
-    {
-        private const string ProjectName = "MauiComboBoxTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiComboBoxTest(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiDataGridViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiDataGridViewTests.cs
deleted file mode 100644
index fdb928901f1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiDataGridViewTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions when accessing singleton resources such as clipboard or mouse.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiDataGridViewTests
-    {
-        private const string ProjectName = "MauiDataGridViewTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiDataGridViewTest(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiImageListTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiImageListTests.cs
deleted file mode 100644
index 256cd1723cd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiImageListTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiImageListTests
-    {
-        private const string ProjectName = "MauiImageListTests";
-        private readonly ITestOutputHelper _output;
-
-        public WinformsMauiImageListTests(ITestOutputHelper output)
-        {
-            _output = output;
-        }
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiImageListTests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName, _output);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiLabelTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiLabelTests.cs
deleted file mode 100644
index ab596762852..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiLabelTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiLabelTests
-    {
-        private const string ProjectName = "MauiLabelTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiLabelTests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiListViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiListViewTests.cs
deleted file mode 100644
index 575d32d31dd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiListViewTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiListViewTests
-    {
-        private const string ProjectName = "MauiListViewTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiListViewTest(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiMDITests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiMDITests.cs
deleted file mode 100644
index 422832f062d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiMDITests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiMDITests
-    {
-        private const string ProjectName = "MauiMDITests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiMDITests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPrintPreviewDialogTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPrintPreviewDialogTests.cs
deleted file mode 100644
index a3de2874026..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPrintPreviewDialogTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiPrintPreviewDialogTests
-    {
-        private const string ProjectName = "MauiPrintPreviewDialogTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiPrintPreviewDialogTests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPropertyGridViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPropertyGridViewTests.cs
deleted file mode 100644
index 57eae6722fd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiPropertyGridViewTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiPropertyGridViewTests
-    {
-        private const string ProjectName = "MauiPropertyGridViewTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiPropertyGridViewTests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiScrollBarTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiScrollBarTests.cs
deleted file mode 100644
index 372509db338..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiScrollBarTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a seperate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to migitate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiScrollBarTests
-    {
-        private const string ProjectName = "MauiScrollBarTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiScrollBarTests(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiToolStripTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiToolStripTests.cs
deleted file mode 100644
index 3f8d257013b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/WinformsMauiToolStripTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using Xunit;
-
-namespace System.Windows.Forms.Maui.IntegrationTests
-{
-    /// <summary>
-    ///  This class runs a maui executable, which contains one or more scenarios.
-    ///
-    ///  We want to be able to represent each scenario as a separate xUnit test, but it's not
-    ///  possible to run them independently. The workaround is to have a MauiTestRunner execute all
-    ///  the scenarios once and store the results, then feed the scenario names in as member data.
-    ///
-    ///  However, MemberData is resolved before any constructors (even static) are called.
-    ///  This means the scenario names will not be available yet.
-    ///
-    ///  The solution to this is to inherit from MemberDataAttribute and execute custom code
-    ///  (running the maui test) before returning the expected data. See MauiMemberDataAttribute.cs for more info.
-    ///
-    ///  Also [Collection("Maui")] is used put all maui tests in the same collection, which makes them run sequentially
-    ///  instead of in parallel. This is to mitigate race conditions of multiple forms open at once.
-    /// </summary>
-    [Collection("Maui")]
-    public class WinformsMauiToolStripTests
-    {
-        private const string ProjectName = "MauiToolStripTests";
-
-        [Theory]
-        [MauiData(ProjectName)]
-        public void MauiToolStripTest(string scenarioName)
-        {
-            MauiTestHelper.ValidateScenarioPassed(ProjectName, scenarioName);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/readme.md b/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/readme.md
deleted file mode 100644
index 7160a402046..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/System.Windows.Forms.Maui.IntegrationTests/readme.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# Porting a Winforms Maui test to xUnit
-
-## Summary
-
-This document details how to port an existing WinForms Maui test to xUnit so it can be run as part of our continuous integration builds. 
-
-If you run into any problems, please contact Adam Yoblick.
-
-## Cloning and building source code
-
-1. If you have not already done so, clone or fork the repo at https://github.com/dotnet/winforms
-
-1. Checkout a new branch for your work with the following command:
-        
-        git checkout -b <your-new-branch-name>
-
-1. Run a build and execute integration tests with the following command:
-
-        .\build -integrationTest /m:1
-
-1. If the above step fails, **STOP**.
-
-    See https://github.com/dotnet/winforms/tree/main/Documentation for more verbose instructions on how to build this repo.
-
-## Porting the maui test
-
-See the pull request at https://github.com/dotnet/winforms/pull/1240 for an example of how to do this.
-
-1. Browse to .\src\System.Windows.Forms\tests\IntegrationTests\MauiTests. All Maui tests live under this folder, each in their own folder.
-	
-1. Create a copy of the existing MauiButtonTest folder in the same directory
-
-    1. Rename the new folder to something more appropriate for the test you are porting (`MauiComboBoxTest`, for example)
-    1. Browse into the new folder and rename the .csproj to the name you chose in step 3 (`MauiComboBoxTest.csproj`, for example)
-    1. Delete the existing MauiButtonTest.cs file
-
-1. Find the source code for the test you are porting and copy it into the new folder you created in the previous step
-
-1. Clean up the Maui test source:
-
-    1. Rename the file appropriately (`MauiComboBoxTest.cs`, for example)
-    1. Add `using System.Windows.Forms.IntegrationTests.Common;` to the using directives.
-    1. Change the namespace to `System.Windows.Forms.IntegrationTests.MauiTests`
-    1. Rename the class appropriately (`MauiComboBoxTest`, for example)
-    1. Add the following line as the first command in the constructor:
-    
-            this.BringToForeground();
-
-    1. Add the following line as the first command in Main():
-    
-            Thread.CurrentThread.SetCulture("en-US");
-
-    1. Make sure each scenario method has the `[Scenario(true)]` attribute
-    1. Remove the entire `[Scenarios]` section at the bottom of the file
-    1. Make sure each scenario method’s name describes what the test is actually doing. 
-    
-        For example, the button scenario methods are named as follows:
-            
-            Click_Fires_OnClick()
-            Hotkey_Fires_OnClick()
-            Hotkey_DoesNotFire_OnClick()
-
-    1. Clean up the code style, following visual studio suggestions (we will catch these in a PR, but it is good to clean up beforehand). For example:
-        1. Use implicit types (var) whenever possible
-        1. All fields should have access modifiers
-        1. Prefer built-in types instead of classes (“string” is preferred to “String”)
-        1. Only use “this” when necessary
-        1. Etc...
-
-## Update the WinForms solution
-
-1. Open `.\Winforms.sln` in Visual Studio
-1. In the solution explorer, browse to `tests\integration\maui`
-1. Right-click on the maui folder and click on `Add -> Existing Project...`
-1. Add the csproj you created in the previous section
-
-## Run the maui test manually
-
-1. Open a command prompt and browse to the root of your repo.
-1. Build the source code (including the test you just ported):
-
-        .\build-local.ps1
-	
-1. Browse to `.\artifacts\bin\<your-test-name>\Debug\net6.0`
-1. Double click on `<your-test-name>.exe`
-1. Check the results.log in the same directory to make sure everything passed
-1. If anything shows as a failure in the log, **STOP**. 
-
-    Figure out why the scenario  is failing and fix it before moving on.
-
-## Run the maui test through the local build
-
-1. Browse to `.\src\System.Windows.Forms\tests\IntegrationTests\System.Windows.Forms.Maui.IntegrationTests`
-1. Copy `WinformsMauiButtonTest.cs` to a new file in the same directory
-1. Rename the new file according to the Maui test you added in the earlier section (`WinformsMauiComboBoxTest.cs`, for example)
-1. Rename the class to the same thing (`WinformsMauiComboBoxTest`, for example)
-1. Change the ProjectName string to match the name of the Maui test project you added in the earlier section (`MauiComboBoxTest`, for example)
-
-    **Note that this must EXACTLY MATCH the project name for the test runner to find your Maui test executable**
-	
-1. Change the name of the single test method to match the name of your project (`MauiComboBoxTest`, for example)
-1. Open a command prompt and browse to the root of your repo.
-1. Run the following command:
-
-        .\build -integrationTest /m:1
-	
-1. Verify all the integration tests pass. If there is a failure, the following files may help:
-    - xUnit test results summary can be found at `.\artifacts\TestResults\Debug\System.Windows.Forms.Maui.IntegrationTests_net6.0_x64.html`
-    - xUnit test outputs can be found at `.\artifacts\log\Debug\System.Windows.Forms.Maui.IntegrationTests_net6.0_x64.log`
-    - The results.log for your individual Maui test can be found at `.\artifacts\bin\<your-test-name>\Debug\net6.0\results.log`
-
-## Run the maui test through the CI build
-
-1. Create a pull request from your new branch (or fork) to the winforms main at https://github.com/dotnet/winforms/compare
-1. Once the PR is created (and every time new files are pushed to the PR), the build will kick off
-1. You can see the result of the build by scrolling down to the checks section and clicking on Show All Checks
-1. If the build is not successful, try to investigate the failure
-    1. Click on Details next to the dotnet-winforms CI check
-    1. Examine the build output. You can also click on the Summary tab and download build artifacts, which will include the same logs you examined locally
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/AnchorLayoutTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/AnchorLayoutTests.cs
deleted file mode 100644
index 3d6c184d86a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/AnchorLayoutTests.cs
+++ /dev/null
@@ -1,338 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using System.Windows.Forms.Primitives;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class AnchorLayoutTests : ControlTestBase
-{
-    static AnchorStyles anchorAllDirection = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Bottom;
-
-    public AnchorLayoutTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(AnchorStyles.Top, 120, 30, 20, 30)]
-    [InlineData(AnchorStyles.Left, 20, 180, 20, 30)]
-    [InlineData(AnchorStyles.Right, 220, 180, 20, 30)]
-    [InlineData(AnchorStyles.Bottom, 120, 330, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Left, 20, 30, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Right, 220, 30, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Bottom, 120, 30, 20, 330)]
-    [InlineData(AnchorStyles.Left | AnchorStyles.Right, 20, 180, 220, 30)]
-    [InlineData(AnchorStyles.Bottom | AnchorStyles.Right | AnchorStyles.Top | AnchorStyles.Left, 20, 30, 220, 330)]
-    public void Control_ResizeAnchoredControls_ParentHandleCreated_NewAnchorsApplied(AnchorStyles anchors, int expectedX, int expectedY, int expectedWidth, int expectedHeight)
-    {
-        LaunchFormAndVerify(anchors, expectedX, expectedY, expectedWidth, expectedHeight);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AnchorStyles.Top, 120, 30, 20, 30)]
-    [InlineData(AnchorStyles.Left, 20, 180, 20, 30)]
-    [InlineData(AnchorStyles.Right, 220, 180, 20, 30)]
-    [InlineData(AnchorStyles.Bottom, 120, 330, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Left, 20, 30, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Right, 220, 30, 20, 30)]
-    [InlineData(AnchorStyles.Top | AnchorStyles.Bottom, 120, 30, 20, 330)]
-    [InlineData(AnchorStyles.Left | AnchorStyles.Right, 20, 180, 220, 30)]
-    [InlineData(AnchorStyles.Bottom | AnchorStyles.Right | AnchorStyles.Top | AnchorStyles.Left, 20, 30, 220, 330)]
-    public void Control_AnchorLayoutV2_ResizeAnchoredControls_ParentHandleCreated_NewAnchorsApplied(AnchorStyles anchors, int expectedX, int expectedY, int expectedWidth, int expectedHeight)
-    {
-        int previousLayoutSwitch = SetAnchorLayoutV2();
-
-        try
-        {
-            LaunchFormAndVerify(anchors, expectedX, expectedY, expectedWidth, expectedHeight);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousLayoutSwitch);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_NotParented_AnchorsNotComputed()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-
-        try
-        {
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            // Unparent button and resume layout.
-            form.Controls.Remove(button);
-            form.ResumeLayout(performLayout: false);
-
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_SuspendedLayout_AnchorsNotComputed()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-
-        try
-        {
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.Controls.Add(button);
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_ResumedLayout_AnchorsComputed()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-
-        try
-        {
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.Controls.Add(button);
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.ResumeLayout(performLayout: false);
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.NotNull(anchorInfo);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void ConfigSwitch_Disabled_SuspendedLayout_AnchorsComputed()
-    {
-        int previousSwitchValue = SetAnchorLayoutV1();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-
-        try
-        {
-            form.Controls.Add(button);
-
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.NotNull(anchorInfo);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void NestedContainer_AnchorsComputed()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-        try
-        {
-            using var container = new ContainerControl();
-            container.Dock = DockStyle.Fill;
-            container.SuspendLayout();
-            container.Controls.Add(button);
-
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.Controls.Add(container);
-            Assert.Null(anchorInfo);
-
-            container.ResumeLayout(false);
-            form.ResumeLayout(false);
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.NotNull(anchorInfo);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void ParentChanged_AnchorsUpdated()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-        try
-        {
-            using var container = new ContainerControl();
-            container.Dock = DockStyle.Fill;
-            container.SuspendLayout();
-            container.Controls.Add(button);
-
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.Controls.Add(container);
-            Assert.Null(anchorInfo);
-
-            container.ResumeLayout(false);
-            form.ResumeLayout(false);
-
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.NotNull(anchorInfo);
-
-            container.Controls.Remove(button);
-            Assert.NotNull(anchorInfo);
-
-            var previousDisplayRect = anchorInfo.DisplayRectangle;
-            form.Controls.Add(button);
-            Assert.NotEqual(previousDisplayRect, anchorInfo.DisplayRectangle);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    [WinFormsFact]
-    public void SetBoundsOnAnchoredControl_BoundsChanged()
-    {
-        int previousSwitchValue = SetAnchorLayoutV2();
-        (Form form, Button button) = GetFormWithAnchoredButton(anchorAllDirection);
-        try
-        {
-            form.Controls.Add(button);
-
-            DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.Null(anchorInfo);
-
-            form.ResumeLayout(false);
-
-            anchorInfo = DefaultLayout.GetAnchorInfo(button);
-            Assert.NotNull(anchorInfo);
-
-            var bounds = button.Bounds;
-            button.SetBounds(bounds.X + 5, bounds.Y + 5, bounds.Width + 10, bounds.Height + 10, BoundsSpecified.None);
-            Assert.Equal(bounds, button.Bounds); // Bounds Specified is None.
-
-            button.SetBounds(bounds.X + 5, bounds.Y + 5, bounds.Width + 10, bounds.Height + 10, BoundsSpecified.All);
-            Assert.NotEqual(bounds, button.Bounds); // Bounds Specified is None.
-
-            bounds = button.Bounds;
-            button.SetBounds(bounds.X + 5, bounds.Y + 5, bounds.Width + 10, bounds.Height + 10);
-            Assert.NotEqual(bounds, button.Bounds);
-        }
-        finally
-        {
-            // Reset switch.
-            SetAnchorLayoutV2Switch(previousSwitchValue);
-            Dispose(form, button);
-        }
-    }
-
-    private static void LaunchFormAndVerify(AnchorStyles anchors, int expectedX, int expectedY, int expectedWidth, int expectedHeight)
-    {
-        (Form form, Button button) = GetFormWithAnchoredButton(anchors);
-        Rectangle newButtonBounds = button.Bounds;
-        try
-        {
-            form.ResumeLayout(true);
-            form.Controls.Add(button);
-            form.Shown += OnFormShown;
-            form.ShowDialog();
-
-            Assert.Equal(expectedX, newButtonBounds.X);
-            Assert.Equal(expectedY, newButtonBounds.Y);
-            Assert.Equal(expectedWidth, newButtonBounds.Width);
-            Assert.Equal(expectedHeight, newButtonBounds.Height);
-        }
-        finally
-        {
-            Dispose(form, button);
-        }
-
-        return;
-
-        void OnFormShown(object? sender, EventArgs e)
-        {
-            // Resize the form to compute button anchors.
-            form.Size = new Size(400, 600);
-            newButtonBounds = button.Bounds;
-            form.Close();
-        }
-    }
-
-    private static (Form, Button) GetFormWithAnchoredButton(AnchorStyles buttonAnchors)
-    {
-        Form form = new()
-        {
-            Size = new Size(200, 300)
-        };
-
-        form.SuspendLayout();
-        Button button = new()
-        {
-            Location = new Point(20, 30),
-            Size = new Size(20, 30),
-            Anchor = buttonAnchors
-        };
-
-        DefaultLayout.AnchorInfo? anchorInfo = DefaultLayout.GetAnchorInfo(button);
-        Assert.Null(anchorInfo);
-
-        return (form, button);
-    }
-
-    private static int SetAnchorLayoutV2Switch(int value)
-    {
-        // TargetFramework on the test host.exe is NetCoreApp2.1. AppContext.TargetFrameworkName return this value
-        // while running unit tests. To avoid using this invalid target framework for unit tests, we are
-        // explicitly setting and unsetting the switch.
-        // Switch value has 3 states: 0 - unknown, 1 - true, -1 - false
-        dynamic localAppContextSwitches = typeof(LocalAppContextSwitches).TestAccessor().Dynamic;
-        int previousSwitchValue = localAppContextSwitches.s_anchorLayoutV2;
-        localAppContextSwitches.s_anchorLayoutV2 = value;
-
-        return previousSwitchValue;
-    }
-
-    private static int SetAnchorLayoutV2() => SetAnchorLayoutV2Switch(value: 1);
-
-    private static int SetAnchorLayoutV1() => SetAnchorLayoutV2Switch(value: -1);
-
-    private static void Dispose(Form form, Button button)
-    {
-        button.Dispose();
-        form.Dispose();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ApplicationTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ApplicationTests.cs
deleted file mode 100644
index e99dddf67da..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ApplicationTests.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class ApplicationTests : ControlTestBase
-{
-    public ApplicationTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task Application_OpenForms_RecreateHandle()
-    {
-        await RunTestAsync(form =>
-        {
-            form.Show();
-            using Form child = new() { RightToLeft = RightToLeft.No };
-            child.Show(form);
-
-            const int expectedFormCount = 2;
-            Assert.Equal(expectedFormCount, Application.OpenForms.Count);
-            child.RightToLeft = RightToLeft.Yes;
-            Assert.Equal(expectedFormCount, Application.OpenForms.Count);
-            child.ShowInTaskbar = !child.ShowInTaskbar;
-            Assert.Equal(expectedFormCount, Application.OpenForms.Count);
-            child.RecreateHandleCore();
-            Assert.Equal(expectedFormCount, Application.OpenForms.Count);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    private async Task RunTestAsync(Func<Form, Task> runTest)
-    {
-        await RunFormWithoutControlAsync(
-            testDriverAsync: runTest,
-            createForm: () =>
-            {
-                return new()
-                {
-                    ClientSize = new Size(640, 480)
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ButtonTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ButtonTests.cs
deleted file mode 100644
index 3e96b1e5b8f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ButtonTests.cs
+++ /dev/null
@@ -1,404 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class ButtonTests : ControlTestBase
-{
-    public ButtonTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    // These results close the window
-    [InlineData(DialogResult.Abort)]
-    [InlineData(DialogResult.Cancel)]
-    [InlineData(DialogResult.Ignore)]
-    [InlineData(DialogResult.No)]
-    [InlineData(DialogResult.OK)]
-    [InlineData(DialogResult.Retry)]
-    [InlineData(DialogResult.Yes)]
-    // This result leaves the window open
-    [InlineData(DialogResult.None)]
-    public async Task Button_DialogResult_ClickDefaultButtonToCloseFormAsync(DialogResult dialogResult)
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            Assert.Equal(DialogResult.None, button.DialogResult);
-
-            button.DialogResult = dialogResult;
-
-            await MoveMouseToControlAsync(button);
-
-            Assert.Equal(CloseReason.None, form.CloseReason);
-            Assert.Equal(DialogResult.None, form.DialogResult);
-            Assert.True(form.Visible);
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            Assert.Equal(CloseReason.None, form.CloseReason);
-            Assert.Equal(dialogResult, form.DialogResult);
-
-            // The window will only still be visible for DialogResult.None
-            Assert.Equal(dialogResult == DialogResult.None, form.Visible);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_DialogResult_SpaceToClickFocusedButtonAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            button.DialogResult = DialogResult.OK;
-
-            Assert.True(button.Focus());
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_SPACE));
-
-            Assert.Equal(DialogResult.OK, form.DialogResult);
-            Assert.False(form.Visible);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_DialogResult_EscapeDoesNotClickFocusedButtonAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            button.DialogResult = DialogResult.OK;
-
-            Assert.True(button.Focus());
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_ESCAPE));
-
-            Assert.Equal(DialogResult.None, form.DialogResult);
-            Assert.True(form.Visible);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_CancelButton_EscapeClicksCancelButtonAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            form.CancelButton = button;
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_ESCAPE));
-
-            Assert.Equal(DialogResult.Cancel, form.DialogResult);
-            Assert.False(form.Visible);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_AchorNone_NoResizeOnWindowSizeWiderAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            var originalFormSize = form.DisplayRectangle.Size;
-            var originalButtonPosition = button.DisplayRectangle;
-
-            var mouseDragHandleOnForm = new Point(form.DisplayRectangle.Right, form.DisplayRectangle.Top + form.DisplayRectangle.Height / 2);
-            await MoveMouseAsync(form, form.PointToScreen(mouseDragHandleOnForm));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseBy(form.DisplayRectangle.Width, 0)
-                    .LeftButtonUp());
-
-            Assert.True(form.DisplayRectangle.Width > originalFormSize.Width);
-            Assert.Equal(originalFormSize.Height, form.DisplayRectangle.Height);
-            Assert.Equal(originalButtonPosition, button.DisplayRectangle);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_AchorNone_NoResizeOnWindowSizeTallerAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            var originalFormSize = form.DisplayRectangle.Size;
-            var originalButtonPosition = button.DisplayRectangle;
-
-            var mouseDragHandleOnForm = new Point(form.DisplayRectangle.Left + form.DisplayRectangle.Width / 2, form.DisplayRectangle.Bottom);
-            await MoveMouseAsync(form, form.PointToScreen(mouseDragHandleOnForm));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseBy(0, form.DisplayRectangle.Height)
-                    .LeftButtonUp());
-
-            Assert.True(form.DisplayRectangle.Height > originalFormSize.Height);
-            Assert.Equal(originalFormSize.Width, form.DisplayRectangle.Width);
-            Assert.Equal(originalButtonPosition, button.DisplayRectangle);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Anchor_ResizeOnWindowSizeWiderAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            button.Anchor = AnchorStyles.Left | AnchorStyles.Right;
-
-            var originalFormSize = form.DisplayRectangle.Size;
-            var originalButtonPosition = button.DisplayRectangle;
-
-            var mouseDragHandleOnForm = new Point(form.DisplayRectangle.Right, form.DisplayRectangle.Top + form.DisplayRectangle.Height / 2);
-            await MoveMouseAsync(form, form.PointToScreen(mouseDragHandleOnForm));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseBy(form.DisplayRectangle.Width, 0)
-                    .LeftButtonUp());
-
-            Assert.True(form.DisplayRectangle.Width > originalFormSize.Width);
-            Assert.Equal(originalFormSize.Height, form.DisplayRectangle.Height);
-
-            Assert.Equal(originalButtonPosition.Location, button.DisplayRectangle.Location);
-
-            // Still anchored on right
-            Assert.Equal(originalFormSize.Width - originalButtonPosition.Right, form.DisplayRectangle.Width - button.DisplayRectangle.Right);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Anchor_ResizeOnWindowSizeTallerAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            button.Anchor = AnchorStyles.Top | AnchorStyles.Bottom;
-
-            var originalFormSize = form.DisplayRectangle.Size;
-            var originalButtonPosition = button.DisplayRectangle;
-
-            var mouseDragHandleOnForm = new Point(form.DisplayRectangle.Left + form.DisplayRectangle.Width / 2, form.DisplayRectangle.Bottom);
-            await MoveMouseAsync(form, form.PointToScreen(mouseDragHandleOnForm));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseBy(0, form.DisplayRectangle.Height)
-                    .LeftButtonUp());
-
-            Assert.True(form.DisplayRectangle.Height > originalFormSize.Height);
-            Assert.Equal(originalFormSize.Width, form.DisplayRectangle.Width);
-
-            Assert.Equal(originalButtonPosition.Location, button.DisplayRectangle.Location);
-
-            // Still anchored on bottom
-            Assert.Equal(originalFormSize.Height - originalButtonPosition.Bottom, form.DisplayRectangle.Height - button.DisplayRectangle.Bottom);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Mouse_Press_Without_Moving_Causes_Button_ClickAsync()
-    {
-        await RunControlPairTestAsync<Button, Button>(async (form, controls) =>
-        {
-            (Button control1, Button control2) = controls;
-            int control1ClickCount = 0;
-            int control2ClickCount = 0;
-            control1.Click += (sender, e) => control1ClickCount++;
-            control2.Click += (sender, e) => control2ClickCount++;
-
-            await MoveMouseToControlAsync(control1);
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            Assert.Equal(1, control1ClickCount);
-            Assert.Equal(0, control2ClickCount);
-
-            await MoveMouseToControlAsync(control2);
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            Assert.Equal(1, control1ClickCount);
-            Assert.Equal(1, control2ClickCount);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Mouse_Press_With_Drag_Off_Button_Does_Not_Cause_Button_ClickAsync()
-    {
-        await RunControlPairTestAsync<Button, Button>(async (form, controls) =>
-        {
-            (Button control1, Button control2) = controls;
-            int control1ClickCount = 0;
-            int control2ClickCount = 0;
-            control1.Click += (sender, e) => control1ClickCount++;
-            control2.Click += (sender, e) => control2ClickCount++;
-
-            await MoveMouseToControlAsync(control1);
-            Rectangle rect = control2.DisplayRectangle;
-            Point centerOfRect = GetCenter(rect);
-            Point centerOnScreen = control2.PointToScreen(centerOfRect);
-            Size primaryMonitor = SystemInformation.PrimaryMonitorSize;
-            int horizontalResolution = primaryMonitor.Width;
-            int verticalResolution = primaryMonitor.Height;
-            Point virtualPoint = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen.X),
-                (int)Math.Round(65535.0 / verticalResolution * centerOnScreen.Y));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseTo(virtualPoint.X, virtualPoint.Y)
-                    .LeftButtonUp());
-
-            Assert.Equal(0, control1ClickCount);
-            Assert.Equal(0, control2ClickCount);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Mouse_Press_With_Drag_Off_Button_And_Back_Does_Cause_Button_ClickAsync()
-    {
-        await RunControlPairTestAsync<Button, Button>(async (form, controls) =>
-        {
-            (Button control1, Button control2) = controls;
-            int control1ClickCount = 0;
-            int control2ClickCount = 0;
-            control1.Click += (sender, e) => control1ClickCount++;
-            control2.Click += (sender, e) => control2ClickCount++;
-
-            await MoveMouseToControlAsync(control1);
-            Rectangle rect = control2.DisplayRectangle;
-            Point centerOfRect = GetCenter(rect);
-            Point centerOnScreen = control2.PointToScreen(centerOfRect);
-            Rectangle rect1 = control1.DisplayRectangle;
-            Point centerOfRect1 = GetCenter(rect1);
-            Point centerOnScreen1 = control1.PointToScreen(centerOfRect1);
-            Size primaryMonitor = SystemInformation.PrimaryMonitorSize;
-            int horizontalResolution = primaryMonitor.Width;
-            int verticalResolution = primaryMonitor.Height;
-            Point virtualPoint = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen.X), (int)Math.Round(65535.0 / verticalResolution * centerOnScreen.Y));
-            Point virtualPoint1 = new((int)Math.Round(65535.0 / horizontalResolution * centerOnScreen1.X), (int)Math.Round(65535.0 / verticalResolution * centerOnScreen1.Y));
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseTo(virtualPoint.X, virtualPoint.Y)
-                    .MoveMouseTo(virtualPoint1.X, virtualPoint1.Y)
-                    .LeftButtonUp());
-
-            Assert.Equal(1, control1ClickCount);
-            Assert.Equal(0, control2ClickCount);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_PerformClick_Fires_OnClickAsync()
-    {
-        await RunTestAsync((form, button) =>
-        {
-            bool wasClicked = false;
-            button.Click += (x, y) => wasClicked = true;
-
-            button.PerformClick();
-
-            Assert.True(wasClicked);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Press_Enter_Fires_OnClickAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            bool wasClicked = false;
-
-            button.Text = "&Click";
-            button.Click += (x, y) => wasClicked = true;
-            await MoveMouseToControlAsync(button);
-
-            // Send the Enter press
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RETURN));
-
-            Assert.True(wasClicked);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Hotkey_Fires_OnClickAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            Assert.True(InputLanguage.CurrentInputLanguage.LayoutName == "US", "Please, switch to the US input language");
-            bool wasClicked = false;
-
-            button.Text = "&Click";
-            button.Click += (x, y) => wasClicked = true;
-
-            // Send the shortcut ALT+C (the same as SendKeys.SendWait("%C"))
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.ModifiedKeyStroke(VIRTUAL_KEY.VK_LMENU, VIRTUAL_KEY.VK_C));
-
-            Assert.True(wasClicked);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Button_Hotkey_DoesNotFire_OnClickAsync()
-    {
-        await RunTestAsync(async (form, button) =>
-        {
-            bool wasClicked = false;
-
-            button.Text = "&Click";
-            button.Click += (x, y) => wasClicked = true;
-
-            // Send a random ALT+L (the same as SendKeys.SendWait("%l"))
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.ModifiedKeyStroke(VIRTUAL_KEY.VK_LMENU, VIRTUAL_KEY.VK_L));
-
-            Assert.False(wasClicked);
-        });
-    }
-
-    private async Task RunTestAsync(Func<Form, Button, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                Button control = new()
-                {
-                    Location = new Point(0, 0),
-                };
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new(500, 300),
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ComboBoxTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ComboBoxTests.cs
deleted file mode 100644
index 7f9399226ae..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ComboBoxTests.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class ComboBoxTests : ControlTestBase
-{
-    public ComboBoxTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task ComboBoxTest_ChangeAutoCompleteSource_DoesntThrowAsync()
-    {
-        await RunSingleControlTestAsync<ComboBox>((form, comboBox) =>
-        {
-            // Test case captured from here.
-            // https://github.com/dotnet/winforms/issues/6953
-            comboBox.AutoCompleteCustomSource.AddRange(new[]
-            {
-                "_sss",
-                "_sss"
-            });
-            comboBox.AutoCompleteSource = AutoCompleteSource.CustomSource;
-            comboBox.AutoCompleteSource = AutoCompleteSource.CustomSource;
-            comboBox.AutoCompleteMode = AutoCompleteMode.Suggest;
-            comboBox.AutoCompleteMode = AutoCompleteMode.Suggest;
-            comboBox.AutoCompleteMode = AutoCompleteMode.Suggest;
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DataGridViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DataGridViewTests.cs
deleted file mode 100644
index 9a93fc74f48..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DataGridViewTests.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Data;
-using System.Drawing;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class DataGridViewTests : ControlTestBase
-{
-    public DataGridViewTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task DataGridView_ToolTip_DoesNot_ThrowExceptionAsync()
-    {
-        await RunTestAsync(async (form, dataGridView) =>
-        {
-            using DataTable dataTable = new();
-            dataTable.Columns.Add(columnName: "name");
-            dataTable.Rows.Add(values: "name1");
-            dataGridView.ShowCellToolTips = true;
-            dataGridView.DataSource = dataTable;
-            Rectangle cellRectangle = dataGridView.GetCellDisplayRectangle(columnIndex: 0, rowIndex: 0, cutOverflow: false);
-            Point cellCenter = GetCenter(cellRectangle);
-            Point targetPoint = ToVirtualPoint(dataGridView.PointToScreen(cellCenter));
-
-            // Move mouse cursor over any cell of the first row to trigger a tooltip.
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.MoveMouseTo(targetPoint.X, targetPoint.Y));
-
-            // Close the form to verify no exceptions thrown while showing the tooltip.
-            // Regression test for https://github.com/dotnet/winforms/issues/5496
-            form.Close();
-            dataTable.AcceptChanges();
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData("short value", false)]
-    [InlineData("very long value that will be truncated by the DataGridViewCell", true)]
-    public async Task DataGridView_MouseToolTip_Appears_IfTextIsTruncatedOnly(string cellValue, bool expected)
-    {
-        await RunTestAsync(async (form, dataGridView) =>
-        {
-            using DataTable dataTable = new();
-            dataTable.Columns.Add(columnName: "name");
-            dataTable.Rows.Add(values: cellValue);
-            dataGridView.ShowCellToolTips = true;
-            dataGridView.DataSource = dataTable;
-            Rectangle cellRectangle = dataGridView.GetCellDisplayRectangle(columnIndex: 0, rowIndex: 0, cutOverflow: false);
-            Point cellCenter = GetCenter(cellRectangle);
-            Point targetPoint = ToVirtualPoint(dataGridView.PointToScreen(cellCenter));
-
-            // Move mouse cursor over any cell of the first row to trigger a tooltip.
-            // Wait 1 second to make sure that the toolTip appeared, it has some delay (500 ms by default).
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.MoveMouseTo(targetPoint.X, targetPoint.Y).Sleep(TimeSpan.FromMilliseconds(1000)));
-
-            // DataGridViewToolTip is private so use the reflection
-            object toolTip = dataGridView.TestAccessor().Dynamic._toolTipControl;
-            object? actual = toolTip.GetType().GetProperty("Activated")?.GetValue(toolTip);
-
-            Assert.Equal(expected, actual);
-        });
-    }
-
-    private async Task RunTestAsync(Func<Form, DataGridView, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                DataGridView control = new();
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new(500, 300),
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DesignBehaviorsTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DesignBehaviorsTests.cs
deleted file mode 100644
index 825619de4eb..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DesignBehaviorsTests.cs
+++ /dev/null
@@ -1,330 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.ComponentModel.Design.Serialization;
-using System.Drawing;
-using System.Drawing.Design;
-using System.Windows.Forms.Design;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class DesignBehaviorsTests : ControlTestBase
-{
-    public DesignBehaviorsTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task DesignBehaviorsTests_can_DragDrop_ToolboxItem()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/6919, and it verifies that we can successfully
-        // drag and drop a toolbox item from a toolbox on to a designer surface.
-
-        Application.ThreadException += (s, e) =>
-        {
-            // This will preserve the full stack, which otherwise gets replaced
-            throw new Exception(e.Exception.Message, e.Exception);
-        };
-
-        await RunSingleControlTestAsync<TreeView>(async (form, treeView) =>
-        {
-            // This will indicate when the designer surface has loaded
-            SemaphoreSlim loadSignal = new(0);
-            // This will indicate when the drag and drop operation has completed
-            SemaphoreSlim dndSignal = new(0);
-
-            form.Size = new(600, 550);
-            treeView.Dock = DockStyle.Left;
-            treeView.Width = 100;
-
-            // Create a toolbox item and assign it to the node
-            // When we drag the node to the design surface, this will go through the toolbox service API
-            ToolboxItem toolboxItem = new()
-            {
-                TypeName = typeof(SampleControl).FullName,
-                DisplayName = nameof(SampleControl),
-                AssemblyName = typeof(SampleControl).Assembly.GetName()
-            };
-
-            TreeNode? node = treeView.Nodes.Add("root");
-            node.Tag = toolboxItem;
-
-            // Create the designer surface and all required plumbing
-            SampleDesignerLoader designerLoader = new();
-            ServiceContainer serviceContainer = new();
-            DesignSurface designSurface = new(serviceContainer);
-
-            var designerHost = (IDesignerHost)designSurface.GetService(typeof(IDesignerHost))!;
-            serviceContainer.RemoveService(typeof(IToolboxService), false);
-            serviceContainer.AddService(typeof(IToolboxService), new SampleToolboxService(designerHost));
-
-            if (designerHost.GetService(typeof(IComponentChangeService)) is IComponentChangeService componentChangeService)
-            {
-                componentChangeService.ComponentAdded += (s, e) =>
-                {
-                    if (e.Component is Form form)
-                    {
-                        form.Text = @"RootForm";
-                        form.Size = new Size(400, 400);
-                    }
-                    else
-                    {
-                        ((Control)e.Component!).Size = new Size(50, 50);
-                    }
-                };
-            }
-
-            designSurface.Loaded += (s, e) =>
-            {
-                Control rootView = (Control)designSurface.View;
-                rootView.Dock = DockStyle.Fill;
-                form.Controls.Add(rootView);
-                rootView.BringToFront();
-
-                // Indicate that we have finished loading the designer surface
-                loadSignal.Release();
-            };
-
-            treeView.ItemDrag += treeView_ItemDrag;
-
-            designSurface.BeginLoad(designerLoader);
-
-            // Wait for the designer surface to load
-            await loadSignal.WaitAsync(millisecondsTimeout: 3_000);
-
-            // Initiate the drag and drop and wait for the signal that it finished
-            var dndStartCoordinates = treeView.PointToScreen(node.Bounds.Location);
-            await InitiateDrangDropAsync(form, dndStartCoordinates, (Control)designSurface.View);
-            await dndSignal.WaitAsync(millisecondsTimeout: 3_000);
-
-            return;
-
-            void treeView_ItemDrag(object? sender, ItemDragEventArgs e)
-            {
-                if (designerHost?.GetService(typeof(IToolboxService)) is not IToolboxService toolboxService ||
-                    e.Item is not TreeNode node ||
-                    node.Tag is not ToolboxItem toolboxItem)
-                {
-                    return;
-                }
-
-                var dataObject = toolboxService.SerializeToolboxItem(toolboxItem) as DataObject;
-
-                var effects = node.TreeView.DoDragDrop(dataObject!, DragDropEffects.Copy);
-            }
-
-            async Task InitiateDrangDropAsync(Form form, Point startCoordinates, Control rootView)
-            {
-                var virtualPointStart = ToVirtualPoint(startCoordinates);
-                startCoordinates.Offset(110, 50);
-                var virtualPointEnd = ToVirtualPoint(startCoordinates);
-
-                await InputSimulator.SendAsync(
-                    form,
-                    inputSimulator => inputSimulator.Mouse.MoveMouseTo(virtualPointStart.X + 6, virtualPointStart.Y + 6)
-                                                          .LeftButtonDown()
-                                                          .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                                                          .LeftButtonUp());
-
-                dndSignal.Release();
-            }
-        });
-    }
-
-#pragma warning disable CS8603 // Possible null reference return.
-    internal class SampleToolboxService : IToolboxService
-    {
-        private readonly IDesignerHost _designerHost;
-
-        public SampleToolboxService(IDesignerHost designerHost)
-        {
-            _designerHost = designerHost;
-        }
-
-        public void AddCreator(ToolboxItemCreatorCallback creator, string format)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void AddCreator(ToolboxItemCreatorCallback creator, string format, IDesignerHost host)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void AddLinkedToolboxItem(ToolboxItem toolboxItem, IDesignerHost host)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void AddLinkedToolboxItem(ToolboxItem toolboxItem, string category, IDesignerHost host)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void AddToolboxItem(ToolboxItem toolboxItem)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void AddToolboxItem(ToolboxItem toolboxItem, string category)
-        {
-            // this method intentionally keep empty
-        }
-
-        public ToolboxItem DeserializeToolboxItem(object serializedObject)
-        {
-            return DeserializeToolboxItem(serializedObject, _designerHost);
-        }
-
-        public ToolboxItem DeserializeToolboxItem(object serializedObject, IDesignerHost? host)
-        {
-            ToolboxItem? item = ((DataObject)serializedObject)?.GetData(typeof(ToolboxItem)) as ToolboxItem;
-            return item!;
-        }
-
-        public ToolboxItem GetSelectedToolboxItem()
-        {
-            return GetSelectedToolboxItem(null!);
-        }
-
-        public ToolboxItem GetSelectedToolboxItem(IDesignerHost host)
-        {
-            return null;
-        }
-
-        public ToolboxItemCollection GetToolboxItems()
-        {
-            return null;
-        }
-
-        public ToolboxItemCollection GetToolboxItems(IDesignerHost host)
-        {
-            return null;
-        }
-
-        public ToolboxItemCollection GetToolboxItems(string category)
-        {
-            return null;
-        }
-
-        public ToolboxItemCollection GetToolboxItems(string category, IDesignerHost host)
-        {
-            return null;
-        }
-
-        public bool IsSupported(object serializedObject, IDesignerHost host)
-        {
-            return true;
-        }
-
-        public bool IsSupported(object serializedObject, ICollection filterAttributes)
-        {
-            return true;
-        }
-
-        public bool IsToolboxItem(object serializedObject)
-        {
-            return true;
-        }
-
-        public bool IsToolboxItem(object serializedObject, IDesignerHost host)
-        {
-            return true;
-        }
-
-        public void Refresh()
-        {
-            throw new NotImplementedException();
-        }
-
-        public void RemoveCreator(string format)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void RemoveCreator(string format, IDesignerHost host)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void RemoveToolboxItem(ToolboxItem toolboxItem)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void RemoveToolboxItem(ToolboxItem toolboxItem, string category)
-        {
-            // this method intentionally keep empty
-        }
-
-        public void SelectedToolboxItemUsed()
-        {
-            // this method intentionally keep empty
-        }
-
-        public object SerializeToolboxItem(ToolboxItem toolboxItem)
-        {
-            return new DataObject(toolboxItem);
-        }
-
-        public bool SetCursor()
-        {
-            return false;
-        }
-
-        public void SetSelectedToolboxItem(ToolboxItem toolboxItem)
-        {
-            // this method intentionally keep empty
-        }
-
-        public CategoryNameCollection CategoryNames => null;
-
-        public string SelectedCategory
-        {
-            get => null;
-            set { }
-        }
-    }
-
-    internal class SampleDesignerLoader : BasicDesignerLoader
-    {
-        protected override void PerformFlush(IDesignerSerializationManager serializationManager)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override void PerformLoad(IDesignerSerializationManager serializationManager)
-        {
-            if (LoaderHost is null)
-                return;
-
-            ArrayList errors = new();
-
-            LoaderHost.CreateComponent(typeof(Form));
-
-            LoaderHost.EndLoad(nameof(Form), true, errors);
-        }
-    }
-
-    [Designer(typeof(SampleControlDesigner))]
-    public class SampleControl : Control
-    {
-    }
-
-    internal class SampleControlDesigner : ControlDesigner
-    {
-        protected override void OnPaintAdornments(PaintEventArgs pe)
-        {
-            base.OnPaintAdornments(pe);
-
-            pe.Graphics.DrawString($"Design time \n{Control.Site?.Name} !", Control.Font, SystemBrushes.WindowText, new PointF(12, 12));
-        }
-    }
-}
-#pragma warning restore CS8603 // Possible null reference return.
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Directory.Build.props b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Directory.Build.props
deleted file mode 100644
index 75e14573cae..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Directory.Build.props
+++ /dev/null
@@ -1,5 +0,0 @@
-<Project>
-
-  <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
-
-</Project>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/DpiMessageHelper.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/DpiMessageHelper.cs
deleted file mode 100644
index 6429a845004..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/DpiMessageHelper.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.UITests.Dpi;
-
-internal static class DpiMessageHelper
-{
-    public static void TriggerDpiMessage(MessageId message, Control control, int newDpi)
-    {
-        double factor = newDpi / DpiHelper.LogicalDpi;
-        WPARAM wParam = WPARAM.MAKEWPARAM(newDpi, newDpi);
-
-        _ = (uint)message switch
-        {
-            PInvoke.WM_DPICHANGED => SendWmDpiChangedMessage(message),
-            PInvoke.WM_DPICHANGED_BEFOREPARENT => PInvoke.SendMessage(control, message, wParam),
-            PInvoke.WM_DPICHANGED_AFTERPARENT => PInvoke.SendMessage(control, message),
-            _ => throw new NotImplementedException()
-        };
-
-        nint SendWmDpiChangedMessage(MessageId message)
-        {
-            RECT suggestedRect = new(0,
-                0,
-                (int)Math.Round(control.Width * factor),
-                (int)Math.Round(control.Height * factor));
-
-            PInvoke.SendMessage(control, PInvoke.WM_GETDPISCALEDSIZE, wParam, ref suggestedRect);
-            return PInvoke.SendMessage(control, message, wParam, ref suggestedRect);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/FormDpiTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/FormDpiTests.cs
deleted file mode 100644
index f121bafdaa6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/FormDpiTests.cs
+++ /dev/null
@@ -1,253 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Primitives;
-using Windows.Win32.UI.HiDpi;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests.Dpi;
-
-public class FormDpiTests : ControlTestBase
-{
-    public FormDpiTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_Bounds(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using Form form = new();
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.Show();
-
-            Drawing.Rectangle initialBounds = form.Bounds;
-            float initialFontSize = form.Font.Size;
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-
-            // Lab machines giving strange values that I could not explain. for ex: on local machine,
-            // I get 1050*1050 for factor 3.5. This is not same on lab machines ( ex, we get 1044). For now,
-            // just verifying they are scaled.
-            Assert.NotEqual(initialBounds.Width, form.Bounds.Width);
-            Assert.NotEqual(initialBounds.Height, form.Bounds.Height);
-            Assert.NotEqual(initialFontSize, form.Font.Size);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_MinMaxSizeNotChanged_Default(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            var minSize = new Drawing.Size(100, 100);
-            var maxSize = new Drawing.Size(500, 500);
-            using var form = new Form();
-            form.MinimumSize = minSize;
-            form.MaximumSize = maxSize;
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.Show();
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-
-            Assert.Equal(form.MinimumSize, minSize);
-            Assert.Equal(form.MaximumSize, maxSize);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_MinMaxSizeChanged_WithRuntimeSetting(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            var minSize = new Drawing.Size(100, 100);
-            var maxSize = new Drawing.Size(500, 500);
-            using var form = new Form();
-            form.MinimumSize = minSize;
-            form.MaximumSize = maxSize;
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.Show();
-
-            // Explicitly opt-in to resize min and max sizes with Dpi changed event.
-            dynamic testAccessor = typeof(LocalAppContextSwitches).TestAccessor().Dynamic;
-            testAccessor.s_scaleTopLevelFormMinMaxSizeForDpi = 1;
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-
-            Assert.NotEqual(form.MinimumSize, minSize);
-            Assert.NotEqual(form.MaximumSize, maxSize);
-
-            // Reset switch.
-            testAccessor.s_scaleTopLevelFormMinMaxSizeForDpi = -1;
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_NonLinear_DesiredSize(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using var form = new Form();
-            form.AutoScaleMode = AutoScaleMode.Font;
-            form.Show();
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-            Drawing.Size nonLInearSize = form.Size;
-
-            // Rollback to 96 Dpi, and change AutoScaleMode to check with linear size
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, (int)DpiHelper.LogicalDpi);
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-            Assert.NotEqual(form.Size, nonLInearSize);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_FormCacheSize(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using var form = new Form();
-            form.AutoScaleMode = AutoScaleMode.Font;
-            form.Show();
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-
-            dynamic fomrTestAccessor = form.TestAccessor().Dynamic;
-            Assert.NotNull(fomrTestAccessor._dpiFormSizes);
-            Assert.Equal(2, fomrTestAccessor._dpiFormSizes.Count);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void Form_DpiChanged_AutoScaleMode_Dpi_FormDoesNotCacheSize(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using var form = new Form();
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.Show();
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-            Assert.Null(form.TestAccessor().Dynamic._dpiFormSizes);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void Form_SizeNotCached_SystemAwareMode()
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using var form = new Form();
-            form.AutoScaleMode = AutoScaleMode.Font;
-            form.Show();
-
-            Assert.Null(form.TestAccessor().Dynamic._dpiFormSizes);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContext(originalAwarenessContext);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/SplitContainerTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/SplitContainerTests.cs
deleted file mode 100644
index 6cb469d0c71..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/SplitContainerTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.HiDpi;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests.Dpi;
-
-public class SplitContainerTests : ControlTestBase
-{
-    public SplitContainerTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public void SplitContainer_Constructor()
-    {
-        using var sc = new SplitContainer();
-
-        Assert.NotNull(sc);
-        Assert.NotNull(sc.Panel1);
-        Assert.Equal(sc, sc.Panel1.Owner);
-        Assert.NotNull(sc.Panel2);
-        Assert.Equal(sc, sc.Panel2.Owner);
-        Assert.False(sc.SplitterRectangle.IsEmpty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(3.5 * 96)]
-    public void SplitContainer_Properties_HorizontalSplitter_Scaling(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            using var form = new Form();
-            using SplitContainer splitContainer = new()
-            {
-                FixedPanel = FixedPanel.Panel1,
-                Location = new Point(0, 0),
-                Margin = new Padding(0),
-                Name = "splitContainer2",
-                Orientation = Orientation.Horizontal,
-                Size = new Size(812, 619),
-                SplitterDistance = 90,
-                SplitterWidth = 2
-            };
-
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.Controls.Add(splitContainer);
-            form.Show();
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED_BEFOREPARENT, splitContainer, newDpi);
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED, form, newDpi);
-
-            Assert.NotEqual(90, splitContainer.SplitterDistance);
-            Assert.NotEqual(2, splitContainer.SplitterWidth);
-            Assert.Equal(splitContainer.SplitterDistance, splitContainer.Panel1.Height);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/ToolStripItemTests.Dpi.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/ToolStripItemTests.Dpi.cs
deleted file mode 100644
index 0126e0b9f3c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Dpi/ToolStripItemTests.Dpi.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.HiDpi;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests.Dpi;
-
-public class ToolStripItemDpiTests : ControlTestBase
-{
-    public ToolStripItemDpiTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(2 * DpiHelper.LogicalDpi)]
-    [InlineData(3.5 * DpiHelper.LogicalDpi)]
-    public void ToolStripItems_FontScaling(int newDpi)
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // Set thread awareness context to PermonitorV2(PMv2).
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-        typeof(DpiHelper).TestAccessor().Dynamic.Initialize();
-        try
-        {
-            int clientWidth = 800;
-            using Form form = new();
-            form.AutoScaleMode = AutoScaleMode.Dpi;
-            form.ClientSize = new Size(clientWidth, 450);
-            using ToolStrip toolStrip = new();
-            using ToolStripButton toolStripItemOpen = new("Open");
-
-            toolStrip.GripStyle = ToolStripGripStyle.Hidden;
-            toolStrip.Items.Add(toolStripItemOpen);
-            toolStrip.Location = new Point(0, 0);
-            toolStrip.Name = "toolStrip1";
-            toolStrip.Text = "toolStrip1";
-            using Font initialFont = toolStrip.Font = new("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
-
-            form.Show();
-
-            DpiMessageHelper.TriggerDpiMessage(PInvoke.WM_DPICHANGED_BEFOREPARENT, toolStrip, newDpi);
-            var factor = (float)newDpi / form.DeviceDpi;
-
-            Assert.Equal((float)initialFont.Size * factor, toolStrip.Font.Size, precision: 1);
-            form.Close();
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DragDropTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DragDropTests.cs
deleted file mode 100644
index 8394c6af757..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/DragDropTests.cs
+++ /dev/null
@@ -1,1112 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-using Windows.Win32.UI.WindowsAndMessaging;
-using Xunit.Abstractions;
-using static Interop;
-using static UiaClient;
-
-namespace System.Windows.Forms.UITests;
-
-public class DragDropTests : ControlTestBase
-{
-    private const int DesktopNormalizedMax = 65536;
-    public const int DragDropDelayMS = 100;
-    public const string DragAcceptRtf = "DragAccept.rtf";
-    public const string DragDrop = "DragDrop";
-    public const string Explorer = "explorer";
-    public const string Resources = "Resources";
-    private readonly Bitmap _dragImage = new("./Resources/move.bmp");
-
-    public DragDropTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task DragDrop_QueryDefaultCursors_Async()
-    {
-        await RunFormWithoutControlAsync(() => new DragDropForm(TestOutputHelper), async (form) =>
-        {
-            await MoveMouseToControlAsync(form.ListDragSource);
-
-            // Select the item under the caret
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            var targetMousePosition = ToVirtualPoint(form.ListDragTarget.PointToScreen(new Point(20, 20)));
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse
-                    .LeftButtonDown()
-                    .MoveMouseTo(targetMousePosition.X - 40, targetMousePosition.Y)
-                    .MoveMouseTo(targetMousePosition.X, targetMousePosition.Y)
-                    .MoveMouseTo(targetMousePosition.X + 2, targetMousePosition.Y + 2)
-                    .MoveMouseTo(targetMousePosition.X + 4, targetMousePosition.Y + 4)
-                    .LeftButtonUp());
-
-            Assert.Equal(1, form.ListDragTarget.Items.Count);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DragDrop_NonSerializedObject_ReturnsExpected_Async()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/7864, and it verifies that we can successfully drag and drop a
-        // non-serialized object.
-
-        Button? button = null;
-        object? data = null;
-        await RunFormWithoutControlAsync(() => new Form(), async (form) =>
-        {
-            form.AllowDrop = true;
-            form.ClientSize = new Size(100, 100);
-            form.DragEnter += (s, e) =>
-            {
-                if (e.Data?.GetDataPresent(typeof(Button)) ?? false)
-                {
-                    e.Effect = DragDropEffects.Copy;
-                }
-            };
-            form.DragOver += (s, e) =>
-            {
-                if (e.Data?.GetDataPresent(typeof(Button)) ?? false)
-                {
-                    // Get the non-serialized Button.
-                    data = e.Data?.GetData(typeof(Button));
-                    e.Effect = DragDropEffects.Copy;
-                }
-            };
-            form.MouseDown += (s, e) =>
-            {
-                DataObject data = new();
-
-                // Button does not participate in serialization scenarios.
-                // Store a non-serialized Button in the DataObject.
-                button = new()
-                {
-                    Name = "button1",
-                    Text = "Click"
-                };
-                data.SetData(typeof(Button), button);
-                form.DoDragDrop(data, DragDropEffects.Copy);
-            };
-
-            var startRect = form.DisplayRectangle;
-            var startCoordinates = form.PointToScreen(GetCenter(startRect));
-            var endCoordinates = new Point(startCoordinates.X + 5, startCoordinates.Y + 5);
-            var virtualPointStart = ToVirtualPoint(startCoordinates);
-            var virtualPointEnd = ToVirtualPoint(endCoordinates);
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator
-                    => inputSimulator.Mouse
-                        .MoveMouseTo(virtualPointStart.X + 6, virtualPointStart.Y + 6)
-                        .LeftButtonDown()
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .LeftButtonUp());
-        });
-
-        Assert.NotNull(data);
-        Assert.True(data is Button);
-        Assert.Equal(button?.Name, ((Button)data).Name);
-        Assert.Equal(button?.Text, ((Button)data).Text);
-    }
-
-    [WinFormsFact(Skip = "Crashes dotnet.exe, see: https://github.com/dotnet/winforms/issues/8598")]
-    public async Task DragDrop_RTF_FromExplorer_ToRichTextBox_ReturnsExpected_Async()
-    {
-        await RunTestAsync(async dragDropForm =>
-        {
-            string dragAcceptRtfDestPath = string.Empty;
-            string dragDropDirectory = Path.Combine(Directory.GetCurrentDirectory(), DragDrop);
-            IUIAutomation? uiAutomation = null;
-            IUIAutomationElement? uiAutomationElement = null;
-
-            try
-            {
-                string dragAcceptRtfSourcePath = Path.Combine(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);
-
-                if (!Directory.Exists(dragDropDirectory))
-                {
-                    Directory.CreateDirectory(dragDropDirectory);
-                }
-
-                dragAcceptRtfDestPath = Path.Combine(dragDropDirectory, DragAcceptRtf);
-
-                if (!File.Exists(dragAcceptRtfDestPath))
-                {
-                    File.Copy(dragAcceptRtfSourcePath, dragAcceptRtfDestPath);
-                }
-
-                string dragAcceptRtfContent = string.Empty;
-                string dragAcceptRtfTextContent = string.Empty;
-
-                using (RichTextBox richTextBox = new())
-                {
-                    richTextBox.Rtf = File.ReadAllText(dragAcceptRtfDestPath);
-                    dragAcceptRtfContent = richTextBox.Rtf;
-                    dragAcceptRtfTextContent = richTextBox.Text;
-                }
-
-                TestOutputHelper.WriteLine($"dragAcceptRtfPath: {dragAcceptRtfDestPath}");
-
-                // Open the DragDrop directory and set focus on DragAccept.rtf
-                Process.Start("explorer.exe", $"/select,\"{dragAcceptRtfDestPath}\"");
-                WaitForExplorer(DragDrop, new Point(dragDropForm.Location.X + dragDropForm.Width, dragDropForm.Location.Y));
-                Assert.True(IsExplorerOpen(DragDrop));
-
-                // Create a CUIAutomation object and obtain the IUIAutomation interface
-                Assert.True(TryGetUIAutomation(out uiAutomation));
-                Assert.NotNull(uiAutomation);
-
-                // Retrieve the UI element that has focus
-                Assert.Equal((int)HRESULT.S_OK, uiAutomation?.GetFocusedElement(out uiAutomationElement));
-                Assert.NotNull(uiAutomationElement);
-
-                string elementName = GetElementName(uiAutomationElement!);
-                TestOutputHelper.WriteLine($"Focused element name: {elementName}");
-
-                RECT rect = default;
-                uiAutomationElement?.get_CurrentBoundingRectangle(out rect);
-                TestOutputHelper.WriteLine($"Focused element bounding rect: {rect}");
-
-                // Retrieve a point that can be clicked
-                Point clickable = default;
-                bool gotClickable = false;
-                Assert.Equal(HRESULT.S_OK, uiAutomationElement?.GetClickablePoint(out clickable, out gotClickable));
-                Assert.True(gotClickable);
-                TestOutputHelper.WriteLine($"gotClickable: {gotClickable}");
-                TestOutputHelper.WriteLine($"clickable: {clickable}");
-
-                Point startCoordinates = clickable;
-                Rectangle endRect = dragDropForm.RichTextBoxDropTarget.ClientRectangle;
-                Point endCoordinates = dragDropForm.RichTextBoxDropTarget.PointToScreen(GetCenter(endRect));
-
-                Rectangle vscreen = SystemInformation.VirtualScreen;
-                Point virtualPointStart = new()
-                {
-                    X = (startCoordinates.X - vscreen.Left) * DesktopNormalizedMax / vscreen.Width + DesktopNormalizedMax / (vscreen.Width * 2),
-                    Y = (startCoordinates.Y - vscreen.Top) * DesktopNormalizedMax / vscreen.Height + DesktopNormalizedMax / (vscreen.Height * 2)
-                };
-                Point virtualPointEnd = new()
-                {
-                    X = (endCoordinates.X - vscreen.Left) * DesktopNormalizedMax / vscreen.Width + DesktopNormalizedMax / (vscreen.Width * 2),
-                    Y = (endCoordinates.Y - vscreen.Top) * DesktopNormalizedMax / vscreen.Height + DesktopNormalizedMax / (vscreen.Height * 2)
-                };
-
-                TestOutputHelper.WriteLine($"virtualPointStart: {virtualPointStart}");
-                TestOutputHelper.WriteLine($"virtualPointEnd: {virtualPointEnd}");
-
-                Assert.Equal((int)HRESULT.S_OK, uiAutomationElement?.SetFocus());
-
-                await InputSimulator.SendAsync(
-                        dragDropForm,
-                        inputSimulator
-                            => inputSimulator.Mouse
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointStart.X, virtualPointStart.Y)
-                                .LeftButtonDown()
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X, virtualPointEnd.Y)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                                .MoveMouseToPositionOnVirtualDesktop(virtualPointEnd.X, virtualPointEnd.Y)
-                                .LeftButtonUp());
-
-                Assert.NotNull(dragDropForm);
-                Assert.NotNull(dragDropForm.RichTextBoxDropTarget);
-
-                TestOutputHelper.WriteLine($"dragAcceptRtfContent: {dragAcceptRtfContent}");
-                TestOutputHelper.WriteLine($"RichTextBoxDropTarget.Rtf: {dragDropForm.RichTextBoxDropTarget.Rtf}");
-                Assert.False(string.IsNullOrWhiteSpace(dragDropForm.RichTextBoxDropTarget.Rtf),
-                    $"Actual form.RichTextBoxDropTarget.Rtf: {dragDropForm.RichTextBoxDropTarget.Rtf}");
-
-                TestOutputHelper.WriteLine($"dragAcceptRtfTextContent: {dragAcceptRtfTextContent}");
-                TestOutputHelper.WriteLine($"RichTextBoxDropTarget.Text: {dragDropForm.RichTextBoxDropTarget.Text}");
-                Assert.False(string.IsNullOrWhiteSpace(dragDropForm.RichTextBoxDropTarget.Text),
-                    $"Actual form.RichTextBoxDropTarget.Text: {dragDropForm.RichTextBoxDropTarget.Text}");
-
-                Assert.Equal(dragAcceptRtfContent, dragDropForm.RichTextBoxDropTarget?.Rtf);
-                Assert.Equal(dragAcceptRtfTextContent, dragDropForm.RichTextBoxDropTarget?.Text);
-            }
-            finally
-            {
-                if (uiAutomationElement is not null)
-                {
-                    Marshal.ReleaseComObject(uiAutomationElement);
-                }
-
-                if (uiAutomation is not null)
-                {
-                    Marshal.ReleaseComObject(uiAutomation);
-                }
-
-                if (IsExplorerOpen(DragDrop))
-                {
-                    CloseExplorer(DragDrop);
-                }
-
-                if (File.Exists(dragAcceptRtfDestPath))
-                {
-                    File.Delete(dragAcceptRtfDestPath);
-                }
-
-                if (Directory.Exists(dragDropDirectory))
-                {
-                    Directory.Delete(dragDropDirectory, true);
-                }
-            }
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DragDrop_SerializedObject_ReturnsExpected_Async()
-    {
-        // Verifies that we can successfully drag and drop a serialized object.
-
-        ListViewItem? listViewItem = null;
-        object? data = null;
-        await RunFormWithoutControlAsync(() => new Form(), async (form) =>
-        {
-            form.AllowDrop = true;
-            form.ClientSize = new Size(100, 100);
-            form.DragEnter += (s, e) =>
-            {
-                if (e.Data?.GetDataPresent(DataFormats.Serializable) ?? false)
-                {
-                    e.Effect = DragDropEffects.Copy;
-                }
-            };
-            form.DragOver += (s, e) =>
-            {
-                if (e.Data?.GetDataPresent(DataFormats.Serializable) ?? false)
-                {
-                    // Get the serialized ListViewItem.
-                    data = e.Data?.GetData(DataFormats.Serializable);
-                    e.Effect = DragDropEffects.Copy;
-                }
-            };
-            form.MouseDown += (s, e) =>
-            {
-                DataObject data = new();
-
-                // ListViewItem participates in resx serialization scenarios.
-                // Store a serialized ListViewItem in the DataObject.
-                listViewItem = new("listViewItem1")
-                {
-                    Text = "View"
-                };
-                data.SetData(DataFormats.Serializable, listViewItem);
-                form.DoDragDrop(data, DragDropEffects.Copy);
-            };
-
-            var startRect = form.DisplayRectangle;
-            var startCoordinates = form.PointToScreen(GetCenter(startRect));
-            var endCoordinates = new Point(startCoordinates.X + 5, startCoordinates.Y + 5);
-            var virtualPointStart = ToVirtualPoint(startCoordinates);
-            var virtualPointEnd = ToVirtualPoint(endCoordinates);
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator
-                    => inputSimulator.Mouse
-                        .MoveMouseTo(virtualPointStart.X + 6, virtualPointStart.Y + 6)
-                        .LeftButtonDown()
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .LeftButtonUp());
-        });
-
-        Assert.NotNull(data);
-        Assert.True(data is ListViewItem);
-        Assert.Equal(listViewItem?.Name, ((ListViewItem)data).Name);
-        Assert.Equal(listViewItem?.Text, ((ListViewItem)data).Text);
-    }
-
-    [WinFormsFact]
-    public async Task DragEnter_Set_DropImageType_Message_MessageReplacementToken_ReturnsExptected_Async()
-    {
-        await RunFormWithoutControlAsync(() => new DragDropForm(TestOutputHelper), async (form) =>
-        {
-            DropImageType dropImageType = DropImageType.Move;
-            string message = "Move to %1";
-            string messageReplacementToken = "Drop Target";
-
-            form.ListDragSource.GiveFeedback += (s, e) =>
-            {
-                e.DragImage = _dragImage;
-                e.CursorOffset = new Point(0, 48);
-                e.UseDefaultCursors = false;
-            };
-
-            form.ListDragTarget.DragEnter += (s, e) =>
-            {
-                e.DropImageType = dropImageType;
-                e.Message = message;
-                e.MessageReplacementToken = messageReplacementToken;
-                e.Effect = DragDropEffects.Copy;
-            };
-
-            form.ListDragTarget.DragOver += (s, e) =>
-            {
-                Assert.Equal(dropImageType, e.DropImageType);
-                Assert.Equal(message, e.Message);
-                Assert.Equal(messageReplacementToken, e.MessageReplacementToken);
-            };
-
-            form.ListDragTarget.DragDrop += (s, e) =>
-            {
-                Assert.Equal(dropImageType, e.DropImageType);
-                Assert.Equal(message, e.Message);
-                Assert.Equal(messageReplacementToken, e.MessageReplacementToken);
-            };
-
-            var startRect = form.ListDragSource.DisplayRectangle;
-            var startCoordinates = form.ListDragSource.PointToScreen(GetCenter(startRect));
-            var endRect = form.ListDragTarget.DisplayRectangle;
-            var endCoordinates = form.ListDragTarget.PointToScreen(GetCenter(endRect));
-            var virtualPointStart = ToVirtualPoint(startCoordinates);
-            var virtualPointEnd = ToVirtualPoint(endCoordinates);
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator
-                    => inputSimulator.Mouse
-                        .MoveMouseTo(virtualPointStart.X + 6, virtualPointStart.Y + 6)
-                        .LeftButtonDown()
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .LeftButtonUp());
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator
-                    => inputSimulator.Mouse
-                        .MoveMouseTo(virtualPointStart.X + 6, virtualPointStart.Y + 6)
-                        .LeftButtonDown()
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .MoveMouseTo(virtualPointEnd.X + 2, virtualPointEnd.Y + 2)
-                        .MoveMouseTo(virtualPointEnd.X + 4, virtualPointEnd.Y + 4)
-                        .LeftButtonUp());
-
-            Assert.Equal(2, form.ListDragTarget.Items.Count);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PictureBox_SetData_DoDragDrop_RichTextBox_ReturnsExptected_Async()
-    {
-        await RunFormWithoutControlAsync(() => new DragImageDropDescriptionForm(TestOutputHelper), async (form) =>
-        {
-            string dragAcceptRtfPath = Path.Combine(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);
-            using RichTextBox richTextBox = new();
-            richTextBox.Rtf = File.ReadAllText(dragAcceptRtfPath);
-            string dragAcceptRtfContent = richTextBox.Rtf;
-            string dragAcceptRtfTextContent = richTextBox.Text;
-            Point startCoordinates = form.PictureBoxDragSource.PointToScreen(new Point(20, 20));
-            Point virtualPointStart = ToVirtualPoint(startCoordinates);
-            startCoordinates.Offset(155, 0);
-            Point virtualPointEnd = ToVirtualPoint(startCoordinates);
-            await InputSimulator.SendAsync(
-                        form,
-                        inputSimulator => inputSimulator.Mouse.MoveMouseTo(virtualPointStart.X, virtualPointStart.Y)
-                                                                .LeftButtonDown()
-                                                                .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                                                                .LeftButtonUp());
-
-            Assert.NotNull(form);
-            Assert.NotNull(form.RichTextBoxDropTarget);
-            Assert.False(string.IsNullOrWhiteSpace(form.RichTextBoxDropTarget.Rtf));
-            Assert.False(string.IsNullOrWhiteSpace(form.RichTextBoxDropTarget.Text));
-            Assert.Equal(dragAcceptRtfContent, form.RichTextBoxDropTarget?.Rtf);
-            Assert.Equal(dragAcceptRtfTextContent, form.RichTextBoxDropTarget?.Text);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ToolStripItem_SetData_DoDragDrop_RichTextBox_ReturnsExptected_Async()
-    {
-        await RunFormWithoutControlAsync(() => new DragImageDropDescriptionForm(TestOutputHelper), async (form) =>
-        {
-            string dragAcceptRtfPath = Path.Combine(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);
-            using RichTextBox richTextBox = new();
-            richTextBox.Rtf = File.ReadAllText(dragAcceptRtfPath);
-            string dragAcceptRtfContent = richTextBox.Rtf;
-            string dragAcceptRtfTextContent = richTextBox.Text;
-
-            await MoveMouseToControlAsync(form.ToolStrip);
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            Point toolStripItemCoordinates = form.ToolStrip.PointToScreen(new Point(5, 5));
-            toolStripItemCoordinates.Offset(0, 40);
-            Point virtualToolStripItemCoordinates = ToVirtualPoint(toolStripItemCoordinates);
-
-            await InputSimulator.SendAsync(
-                        form,
-                        inputSimulator => inputSimulator.Mouse.MoveMouseTo(virtualToolStripItemCoordinates.X, virtualToolStripItemCoordinates.Y));
-
-            Point virtualPointStart = virtualToolStripItemCoordinates;
-            toolStripItemCoordinates.Offset(50, 50);
-            Point virtualPointEnd = ToVirtualPoint(toolStripItemCoordinates);
-            await InputSimulator.SendAsync(
-                        form,
-                        inputSimulator => inputSimulator.Mouse.MoveMouseTo(virtualPointStart.X, virtualPointStart.Y)
-                                                                .LeftButtonDown()
-                                                                .MoveMouseTo(virtualPointEnd.X, virtualPointEnd.Y)
-                                                                .LeftButtonUp());
-
-            Assert.NotNull(form);
-            Assert.NotNull(form.RichTextBoxDropTarget);
-            Assert.False(string.IsNullOrWhiteSpace(form.RichTextBoxDropTarget.Rtf));
-            Assert.False(string.IsNullOrWhiteSpace(form.RichTextBoxDropTarget.Text));
-            Assert.Equal(dragAcceptRtfContent, form.RichTextBoxDropTarget?.Rtf);
-            Assert.Equal(dragAcceptRtfTextContent, form.RichTextBoxDropTarget?.Text);
-        });
-    }
-
-    private void CloseExplorer(string directory)
-    {
-        foreach (Process process in Process.GetProcesses())
-        {
-            if (process.ProcessName == Explorer && process.MainWindowTitle == directory)
-            {
-                process.CloseMainWindow();
-                process.Close();
-                return;
-            }
-        }
-    }
-
-    private string GetElementName(IUIAutomationElement element)
-    {
-        if (element.get_CurrentName(out BSTR retVal) == 0)
-        {
-            return retVal.AsSpan().ToString();
-        }
-
-        return string.Empty;
-    }
-
-    private bool IsExplorerOpen(string directory)
-    {
-        foreach (Process process in Process.GetProcesses())
-        {
-            if (process.ProcessName == Explorer && process.MainWindowTitle == directory)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private async Task RunTestAsync(Func<DragImageDropDescriptionForm, Task> runTest)
-    {
-        await RunFormWithoutControlAsync(
-            testDriverAsync: runTest,
-            createForm: () =>
-            {
-                return new DragImageDropDescriptionForm(TestOutputHelper)
-                {
-                    Location = new Point(0, 0),
-                    StartPosition = FormStartPosition.Manual
-                };
-            });
-    }
-
-    private bool TryGetUIAutomation([NotNullWhen(true)] out IUIAutomation? uiAutomation)
-    {
-        Guid CLSID_CUIAutomation = new("FF48DBA4-60EF-4201-AA87-54103EEF594E");
-        Guid IID_IUIAutomation = new("30CBE57D-D9D0-452A-AB13-7AC5AC4825EE");
-        HRESULT hr = Ole32.CoCreateInstance(
-            in CLSID_CUIAutomation,
-            IntPtr.Zero,
-            CLSCTX.CLSCTX_INPROC_SERVER,
-            in IID_IUIAutomation,
-            out object obj);
-        if (hr.Succeeded)
-        {
-            uiAutomation = (IUIAutomation)obj;
-            return true;
-        }
-
-        uiAutomation = default;
-        return false;
-    }
-
-    private void WaitForExplorer(string directory, Point startPosition)
-    {
-        int wait = 0, maxWait = 100;
-        while (!IsExplorerOpen(directory) && wait++ < maxWait)
-        {
-            TestOutputHelper.WriteLine($"Waiting for Explorer to open, wait {wait}");
-            Thread.Sleep(DragDropDelayMS);
-        }
-
-        foreach (Process process in Process.GetProcesses())
-        {
-            if (process.ProcessName == Explorer && process.MainWindowTitle == directory)
-            {
-                PInvoke.SetWindowPos(
-                    (HWND)process.MainWindowHandle,
-                    HWND.HWND_TOP,
-                    startPosition.X,
-                    startPosition.Y,
-                    0,
-                    0,
-                    SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
-            }
-        }
-    }
-
-    class DragDropForm : Form
-    {
-        public ListBox ListDragSource;
-        public ListBox ListDragTarget;
-        private CheckBox UseCustomCursorsCheck;
-        private Label DropLocationLabel;
-
-        private int indexOfItemUnderMouseToDrag;
-        private int indexOfItemUnderMouseToDrop;
-
-        private Rectangle dragBoxFromMouseDown;
-        private Point screenOffset;
-
-        private Cursor? MyNoDropCursor;
-        private Cursor? MyNormalCursor;
-
-        private readonly ITestOutputHelper _testOutputHelper;
-
-        public DragDropForm(ITestOutputHelper testOutputHelper)
-        {
-            ListDragSource = new ListBox();
-            ListDragTarget = new ListBox();
-            UseCustomCursorsCheck = new CheckBox();
-            DropLocationLabel = new Label();
-
-            SuspendLayout();
-
-            // ListDragSource
-            ListDragSource.Items.AddRange(new object[]
-            {
-                "one", "two", "three", "four",
-                "five", "six", "seven", "eight",
-                "nine", "ten"
-            });
-            ListDragSource.Location = new Point(10, 17);
-            ListDragSource.Size = new Size(120, 225);
-            ListDragSource.MouseDown += ListDragSource_MouseDown;
-            ListDragSource.QueryContinueDrag += ListDragSource_QueryContinueDrag;
-            ListDragSource.MouseUp += ListDragSource_MouseUp;
-            ListDragSource.MouseMove += ListDragSource_MouseMove;
-            ListDragSource.GiveFeedback += ListDragSource_GiveFeedback;
-
-            // ListDragTarget
-            ListDragTarget.AllowDrop = true;
-            ListDragTarget.Location = new Point(154, 17);
-            ListDragTarget.Size = new Size(120, 225);
-            ListDragTarget.DragOver += ListDragTarget_DragOver;
-            ListDragTarget.DragDrop += ListDragTarget_DragDrop;
-            ListDragTarget.DragEnter += ListDragTarget_DragEnter;
-            ListDragTarget.DragLeave += ListDragTarget_DragLeave;
-
-            // UseCustomCursorsCheck
-            UseCustomCursorsCheck.Location = new Point(10, 243);
-            UseCustomCursorsCheck.Size = new Size(137, 24);
-            UseCustomCursorsCheck.Text = "Use Custom Cursors";
-
-            // DropLocationLabel
-            DropLocationLabel.Location = new Point(154, 245);
-            DropLocationLabel.Size = new Size(137, 24);
-            DropLocationLabel.Text = "None";
-
-            // Form1
-            ClientSize = new Size(292, 270);
-            Controls.AddRange(new Control[]
-            {
-                ListDragSource,
-                ListDragTarget,
-                UseCustomCursorsCheck,
-                DropLocationLabel
-            });
-
-            _testOutputHelper = testOutputHelper;
-        }
-
-        private void ListDragSource_MouseDown(object? sender, MouseEventArgs e)
-        {
-            // Get the index of the item the mouse is below.
-            indexOfItemUnderMouseToDrag = ListDragSource.IndexFromPoint(e.X, e.Y);
-            _testOutputHelper.WriteLine($"Mouse down on drag source at position ({e.X},{e.Y}). Index of element under mouse: {indexOfItemUnderMouseToDrag}");
-
-            if (indexOfItemUnderMouseToDrag != ListBox.NoMatches)
-            {
-                // Remember the point where the mouse down occurred. The DragSize indicates
-                // the size that the mouse can move before a drag event should be started.
-                Size dragSize = SystemInformation.DragSize;
-
-                // Create a rectangle using the DragSize, with the mouse position being
-                // at the center of the rectangle.
-                dragBoxFromMouseDown = new Rectangle(
-                    new Point(e.X - (dragSize.Width / 2),
-                              e.Y - (dragSize.Height / 2)),
-                    dragSize);
-            }
-            else
-            {
-                // Reset the rectangle if the mouse is not over an item in the ListBox.
-                dragBoxFromMouseDown = Rectangle.Empty;
-            }
-        }
-
-        private void ListDragSource_MouseUp(object? sender, MouseEventArgs e)
-        {
-            // Reset the drag rectangle when the mouse button is raised.
-            dragBoxFromMouseDown = Rectangle.Empty;
-            _testOutputHelper.WriteLine($"Mouse up on drag source at position ({e.X},{e.Y}).");
-        }
-
-        private void ListDragSource_MouseMove(object? sender, MouseEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Mouse move on drag source to position ({e.X},{e.Y}) with buttons {e.Button}.");
-            if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
-            {
-                // If the mouse moves outside the rectangle, start the drag.
-                if (dragBoxFromMouseDown != Rectangle.Empty &&
-                    !dragBoxFromMouseDown.Contains(e.X, e.Y))
-                {
-                    // Create custom cursors for the drag-and-drop operation.
-                    try
-                    {
-                        MyNormalCursor = new Cursor("./Resources/3dwarro.cur");
-                        MyNoDropCursor = new Cursor("./Resources/3dwno.cur");
-                    }
-                    catch
-                    {
-                        // An error occurred while attempting to load the cursors, so use
-                        // standard cursors.
-                        UseCustomCursorsCheck.Checked = false;
-                    }
-                    finally
-                    {
-                        // The screenOffset is used to account for any desktop bands
-                        // that may be at the top or left side of the screen when
-                        // determining when to cancel the drag drop operation.
-                        screenOffset = SystemInformation.WorkingArea.Location;
-
-                        // Proceed with the drag-and-drop, passing in the list item.
-                        DragDropEffects dropEffect = ListDragSource.DoDragDrop(
-                            ListDragSource.Items[indexOfItemUnderMouseToDrag],
-                            DragDropEffects.All | DragDropEffects.Link);
-
-                        // If the drag operation was a move then remove the item.
-                        if (dropEffect == DragDropEffects.Move)
-                        {
-                            ListDragSource.Items.RemoveAt(indexOfItemUnderMouseToDrag);
-
-                            // Selects the previous item in the list as long as the list has an item.
-                            if (indexOfItemUnderMouseToDrag > 0)
-                                ListDragSource.SelectedIndex = indexOfItemUnderMouseToDrag - 1;
-
-                            else if (ListDragSource.Items.Count > 0)
-                                // Selects the first item.
-                                ListDragSource.SelectedIndex = 0;
-                        }
-
-                        // Dispose of the cursors since they are no longer needed.
-                        MyNormalCursor?.Dispose();
-
-                        MyNoDropCursor?.Dispose();
-                    }
-                }
-            }
-        }
-
-        private void ListDragSource_GiveFeedback(object? sender, GiveFeedbackEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Give feedback on drag source.");
-
-            // Use custom cursors if the check box is checked.
-            if (UseCustomCursorsCheck.Checked)
-            {
-                // Sets the custom cursor based upon the effect.
-                e.UseDefaultCursors = false;
-                if ((e.Effect & DragDropEffects.Move) == DragDropEffects.Move)
-                    Cursor.Current = MyNormalCursor;
-                else
-                    Cursor.Current = MyNoDropCursor;
-            }
-        }
-
-        private void ListDragTarget_DragOver(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag over on the drag target.");
-
-            // Determine whether string data exists in the drop data. If not, then
-            // the drop effect reflects that the drop cannot occur.
-            if (e.Data is null || !e.Data.GetDataPresent(typeof(string)))
-            {
-                e.Effect = DragDropEffects.None;
-                DropLocationLabel.Text = "None - no string data.";
-                return;
-            }
-
-            // Set the effect based upon the KeyState.
-            if ((e.KeyState & (8 + 32)) == (8 + 32) &&
-                (e.AllowedEffect & DragDropEffects.Link) == DragDropEffects.Link)
-            {
-                // KeyState 8 + 32 = CTRL + ALT
-
-                // Link drag-and-drop effect.
-                e.Effect = DragDropEffects.Link;
-            }
-            else if ((e.KeyState & 32) == 32 &&
-                (e.AllowedEffect & DragDropEffects.Link) == DragDropEffects.Link)
-            {
-                // ALT KeyState for link.
-                e.Effect = DragDropEffects.Link;
-            }
-            else if ((e.KeyState & 4) == 4 &&
-                (e.AllowedEffect & DragDropEffects.Move) == DragDropEffects.Move)
-            {
-                // SHIFT KeyState for move.
-                e.Effect = DragDropEffects.Move;
-            }
-            else if ((e.KeyState & 8) == 8 &&
-                (e.AllowedEffect & DragDropEffects.Copy) == DragDropEffects.Copy)
-            {
-                // CTRL KeyState for copy.
-                e.Effect = DragDropEffects.Copy;
-            }
-            else if ((e.AllowedEffect & DragDropEffects.Move) == DragDropEffects.Move)
-            {
-                // By default, the drop action should be move, if allowed.
-                e.Effect = DragDropEffects.Move;
-            }
-            else
-            {
-                e.Effect = DragDropEffects.None;
-            }
-
-            // Get the index of the item the mouse is below.
-
-            // The mouse locations are relative to the screen, so they must be
-            // converted to client coordinates.
-
-            indexOfItemUnderMouseToDrop =
-                ListDragTarget.IndexFromPoint(ListDragTarget.PointToClient(new Point(e.X, e.Y)));
-
-            // Updates the label text.
-            if (indexOfItemUnderMouseToDrop != ListBox.NoMatches)
-            {
-                DropLocationLabel.Text = $"Drops before item #{(indexOfItemUnderMouseToDrop + 1)}";
-            }
-            else
-            {
-                DropLocationLabel.Text = "Drops at the end.";
-            }
-        }
-
-        private void ListDragTarget_DragDrop(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag drop on drag target.");
-
-            // Ensure that the list item index is contained in the data.
-            if (e.Data is not null && e.Data.GetDataPresent(typeof(string)))
-            {
-                object? item = e.Data.GetData(typeof(string));
-
-                // Perform drag-and-drop, depending upon the effect.
-                if (item is not null && (e.Effect == DragDropEffects.Copy || e.Effect == DragDropEffects.Move))
-                {
-                    // Insert the item.
-                    if (indexOfItemUnderMouseToDrop != ListBox.NoMatches)
-                        ListDragTarget.Items.Insert(indexOfItemUnderMouseToDrop, item);
-                    else
-                        ListDragTarget.Items.Add(item);
-                }
-            }
-
-            // Reset the label text.
-            DropLocationLabel.Text = "None";
-        }
-
-        private void ListDragSource_QueryContinueDrag(object? sender, QueryContinueDragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Query for drag continuation.");
-
-            // Cancel the drag if the mouse moves off the form.
-            if (sender is ListBox lb)
-            {
-                Form form = lb.FindForm()!;
-
-                // Cancel the drag if the mouse moves off the form. The screenOffset
-                // takes into account any desktop bands that may be at the top or left
-                // side of the screen.
-                if (((MousePosition.X - screenOffset.X) < form.DesktopBounds.Left) ||
-                    ((MousePosition.X - screenOffset.X) > form.DesktopBounds.Right) ||
-                    ((MousePosition.Y - screenOffset.Y) < form.DesktopBounds.Top) ||
-                    ((MousePosition.Y - screenOffset.Y) > form.DesktopBounds.Bottom))
-                {
-                    _testOutputHelper.WriteLine($"Cancelling drag.");
-                    e.Action = DragAction.Cancel;
-                }
-            }
-        }
-
-        private void ListDragTarget_DragEnter(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag enter on target.");
-
-            // Reset the label text.
-            DropLocationLabel.Text = "None";
-
-            // Also treat this as a DragOver to start the drag/drop operation
-            ListDragTarget_DragOver(sender, e);
-        }
-
-        private void ListDragTarget_DragLeave(object? sender, EventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag leave on target.");
-
-            // Reset the label text.
-            DropLocationLabel.Text = "None";
-        }
-    }
-
-    class DragImageDropDescriptionForm : Form
-    {
-        private readonly Bitmap _dragImage = new("./Resources/image.png");
-        private readonly Bitmap _dragAcceptBmp = new("./Resources/DragAccept.bmp");
-        private readonly ITestOutputHelper _testOutputHelper;
-
-        private ContextMenuStrip? _contextMenuStrip;
-
-        public PictureBox PictureBoxDragSource;
-        public RichTextBox RichTextBoxDropTarget;
-        public ToolStrip ToolStrip = new();
-
-        public DragImageDropDescriptionForm(ITestOutputHelper testOutputHelper)
-        {
-            _testOutputHelper = testOutputHelper;
-            PictureBoxDragSource = new PictureBox();
-            RichTextBoxDropTarget = new RichTextBox();
-
-            SuspendLayout();
-
-            // PictureBoxDragSource
-            PictureBoxDragSource.AllowDrop = true;
-            PictureBoxDragSource.BorderStyle = BorderStyle.FixedSingle;
-            PictureBoxDragSource.Location = new Point(10, 45);
-            PictureBoxDragSource.Size = new Size(125, 119);
-            PictureBoxDragSource.DragEnter += PictureBoxDragSource_DragEnter;
-            PictureBoxDragSource.DragOver += PictureBoxDragSource_DragOver;
-            PictureBoxDragSource.MouseDown += PictureBoxDragSource_MouseDown;
-
-            // RichTextBoxDropTarget
-            RichTextBoxDropTarget.AllowDrop = true;
-            RichTextBoxDropTarget.EnableAutoDragDrop = true;
-            RichTextBoxDropTarget.Location = new Point(145, 45);
-            RichTextBoxDropTarget.Size = new Size(125, 119);
-            RichTextBoxDropTarget.DragEnter += RichTextBoxDropTarget_DragEnter;
-            RichTextBoxDropTarget.DragDrop += RichTextBoxDropTarget_DragDrop;
-
-            // ToolStrip
-            CreateToolStrip();
-
-            // Form1
-            ClientSize = new Size(285, 175);
-            Controls.AddRange(new Control[]
-            {
-                PictureBoxDragSource,
-                RichTextBoxDropTarget
-            });
-        }
-
-        private void CreateToolStrip()
-        {
-            TableLayoutPanel tableLayoutPanel = new()
-            {
-                ColumnCount = 1,
-                Dock = DockStyle.Top,
-                Height = 35,
-                RowCount = 1
-            };
-
-            tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize));
-
-            _contextMenuStrip = new ContextMenuStrip
-            {
-                AllowDrop = true,
-                AutoSize = true,
-                ImageScalingSize = new Size(25, 25)
-            };
-
-            _contextMenuStrip.Opening += new CancelEventHandler(ContextMenuStrip_Opening);
-
-            ToolStrip = new()
-            {
-                DefaultDropDownDirection = ToolStripDropDownDirection.BelowLeft,
-                Dock = DockStyle.Right,
-                GripStyle = ToolStripGripStyle.Hidden
-            };
-
-            ToolStripDropDownButton toolStripDropDownButton = new()
-            {
-                AutoSize = false,
-                AutoToolTip = false,
-                DropDown = _contextMenuStrip,
-                Height = 35,
-                Name = "toolStripDropDownButton",
-                Text = "Drag Images",
-                ToolTipText = string.Empty,
-                Width = 100
-            };
-
-            ToolStrip.Items.Add(toolStripDropDownButton);
-            tableLayoutPanel.Controls.Add(ToolStrip, 0, 0);
-            Controls.Add(tableLayoutPanel);
-            ContextMenuStrip = _contextMenuStrip;
-        }
-
-        void ContextMenuStrip_Opening(object? sender, CancelEventArgs e)
-        {
-            if (_contextMenuStrip is null)
-            {
-                return;
-            }
-
-            _contextMenuStrip.DefaultDropDownDirection = ToolStripDropDownDirection.BelowLeft;
-            _contextMenuStrip.Items.Clear();
-
-            ToolStripItem dragAcceptItem = new ToolStripMenuItem()
-            {
-                AllowDrop = true,
-                Image = _dragAcceptBmp,
-                ImageScaling = ToolStripItemImageScaling.SizeToFit,
-                Text = "DragAccept",
-                Name = "dragAcceptItem",
-            };
-            dragAcceptItem.DragEnter += DragAcceptItem_DragEnter;
-            dragAcceptItem.MouseDown += DragAcceptItem_MouseDown;
-
-            _contextMenuStrip.Items.Add(dragAcceptItem);
-            e.Cancel = false;
-        }
-
-        private void DragAcceptItem_DragEnter(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag enter on target.");
-
-            e.DropImageType = DropImageType.Link;
-            e.Message = "DragAcceptFiles";
-            e.Effect = DragDropEffects.Link;
-        }
-
-        private void DragAcceptItem_MouseDown(object? sender, MouseEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Mouse down on drag source at position ({e.X},{e.Y}).");
-
-            if (sender is not ToolStripItem dragAcceptItem)
-            {
-                return;
-            }
-
-            string dragAcceptRtf = Path.Combine(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);
-            if (File.Exists(dragAcceptRtf))
-            {
-                string[] dropFiles = new string[] { dragAcceptRtf };
-                DataObject data = new(DataFormats.FileDrop, dropFiles);
-                dragAcceptItem.DoDragDrop(data, DragDropEffects.All, _dragAcceptBmp, new Point(0, 16), false);
-            }
-        }
-
-        private void PictureBoxDragSource_DragOver(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag over on source.");
-
-            e.DropImageType = DropImageType.None;
-            e.Effect = DragDropEffects.None;
-        }
-
-        private void RichTextBoxDropTarget_DragDrop(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag drop on target.");
-
-            if (e.Data is not null
-                && e.Data.GetDataPresent(DataFormats.FileDrop)
-                && e.Data.GetData(DataFormats.FileDrop) is string[] fileNames
-                && fileNames.Length > 0 && fileNames[0].Contains(DragAcceptRtf))
-            {
-                RichTextBoxDropTarget.Clear();
-                RichTextBoxDropTarget.LoadFile(fileNames[0], RichTextBoxStreamType.RichText);
-                e.Effect = DragDropEffects.None;
-            }
-        }
-
-        private void RichTextBoxDropTarget_DragEnter(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag enter on target.");
-
-            if (e.Data is not null
-                && e.Data.GetDataPresent(DataFormats.FileDrop)
-                && e.Data.GetData(DataFormats.FileDrop) is string[] fileNames
-                && fileNames.Length > 0 && fileNames[0].Contains(DragAcceptRtf))
-            {
-                e.DropImageType = DropImageType.Link;
-                e.Message = "%1 (shellapi.h)";
-                e.MessageReplacementToken = "DragAcceptFiles";
-                e.Effect = DragDropEffects.Link;
-            }
-        }
-
-        private void PictureBoxDragSource_DragEnter(object? sender, DragEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Drag enter on source.");
-
-            e.DropImageType = DropImageType.None;
-            e.Effect = DragDropEffects.None;
-        }
-
-        private void PictureBoxDragSource_MouseDown(object? sender, MouseEventArgs e)
-        {
-            _testOutputHelper.WriteLine($"Mouse down on drag source at position ({e.X},{e.Y}).");
-
-            string dragAcceptRtf = Path.Combine(Directory.GetCurrentDirectory(), Resources, DragAcceptRtf);
-            if (File.Exists(dragAcceptRtf))
-            {
-                string[] dropFiles = new string[] { dragAcceptRtf };
-                DataObject data = new(DataFormats.FileDrop, dropFiles);
-                PictureBoxDragSource.DoDragDrop(data, DragDropEffects.All, _dragImage, new Point(0, 16), false);
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FolderBrowserDialogTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FolderBrowserDialogTests.cs
deleted file mode 100644
index 8ec4d68dcd6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FolderBrowserDialogTests.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class FolderBrowserDialogTests : ControlTestBase
-{
-    public FolderBrowserDialogTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    // Regression test for https://github.com/dotnet/winforms/issues/7981
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void FolderBrowserDialog_ShowDialog(bool autoUpgradeEnabled)
-    {
-        using DialogHostForm dialogOwnerForm = new();
-        using FolderBrowserDialog dialog = new()
-        {
-            AutoUpgradeEnabled = autoUpgradeEnabled,
-        };
-
-        Assert.Equal(DialogResult.Cancel, dialog.ShowDialog(dialogOwnerForm));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FormTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FormTests.cs
deleted file mode 100644
index 684d17cb635..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/FormTests.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class FormTests : ControlTestBase
-{
-    // When using the keyboard for snap layout menu, there are various times when
-    // a delay is needed. This value may need to be adjusted if tests fail
-    // in CI/different environment
-    private const int SnapLayoutDelayMS = 500;
-
-    public FormTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(FormWindowState.Normal)]
-    [InlineData(FormWindowState.Maximized)]
-    public async Task Form_SnapsLeftAsync(FormWindowState windowState)
-    {
-        if (!OsVersion.IsWindows11_OrGreater())
-        {
-            return;
-        }
-
-        await RunEmptyFormTestAsync(async form =>
-        {
-            form.Location = new Point(20, 21);
-            form.Size = new Size(300, 310);
-
-            form.WindowState = windowState;
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.ModifiedKeyStroke(VIRTUAL_KEY.VK_LWIN, VIRTUAL_KEY.VK_Z));
-
-            // inputSimulator.Sleep appears wildly inconsistent with snap panel timing. Task.Delay does not
-            await Task.Delay(SnapLayoutDelayMS);
-
-            // Snap left
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RIGHT)
-                                                         .KeyPress(VIRTUAL_KEY.VK_RETURN));
-
-            await Task.Delay(SnapLayoutDelayMS);
-
-            // At this point, Windows displays a panel containing all running applications so the
-            // user can select one to dock next to our form. It also takes the keyboard focus away.
-            // If left in this state, subsequently run tests will fail since keyboard focus is not
-            // given to any newly launched window until this panel is dismissed.
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_ESCAPE));
-
-            await Task.Delay(SnapLayoutDelayMS);
-
-            var screenWorkingArea = Screen.FromControl(form).WorkingArea;
-            int borderSize = (form.Width - form.ClientRectangle.Width) / 2;
-
-            Assert.True(form.Left <= screenWorkingArea.X);
-            Assert.True(form.Left >= screenWorkingArea.X - borderSize);
-
-            Assert.True(form.Top <= screenWorkingArea.Y);
-            Assert.True(form.Top >= screenWorkingArea.Y - borderSize);
-
-            Assert.True(form.Height >= screenWorkingArea.Height);
-            Assert.True(form.Height <= screenWorkingArea.Height + (borderSize * 2));
-
-            Assert.True(form.Width >= screenWorkingArea.Width / 2);
-            Assert.True(form.Width <= (screenWorkingArea.Width / 2) + (borderSize * 2));
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(FormWindowState.Normal)]
-    [InlineData(FormWindowState.Maximized)]
-    public async Task Form_SnapsRightAsync(FormWindowState windowState)
-    {
-        if (!OsVersion.IsWindows11_OrGreater())
-        {
-            return;
-        }
-
-        await RunEmptyFormTestAsync(async form =>
-        {
-            form.Location = new Point(20, 21);
-            form.Size = new Size(300, 310);
-
-            form.WindowState = windowState;
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.ModifiedKeyStroke(VIRTUAL_KEY.VK_LWIN, VIRTUAL_KEY.VK_Z));
-
-            // inputSimulator.Sleep appears wildly inconsistent with snap panel timing. Task.Delay does not
-            await Task.Delay(SnapLayoutDelayMS);
-
-            // Snap right
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RIGHT)
-                                                         .KeyPress(VIRTUAL_KEY.VK_RIGHT)
-                                                         .KeyPress(VIRTUAL_KEY.VK_RETURN));
-
-            await Task.Delay(SnapLayoutDelayMS);
-
-            // At this point, Windows displays a panel containing all running applications so the
-            // user can select one to dock next to our form. It also takes the keyboard focus away.
-            // If left in this state, subsequently run tests will fail since keyboard focus is not
-            // given to any newly launched window until this panel is dismissed.
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_ESCAPE));
-
-            await Task.Delay(SnapLayoutDelayMS);
-
-            var screenWorkingArea = Screen.FromControl(form).WorkingArea;
-            int screenMiddleX = screenWorkingArea.X + (screenWorkingArea.Width / 2);
-            int borderSize = (form.Width - form.ClientRectangle.Width) / 2;
-
-            Assert.True(form.Left <= screenMiddleX);
-            Assert.True(form.Left >= screenMiddleX - borderSize);
-
-            Assert.True(form.Top <= screenWorkingArea.Y);
-            Assert.True(form.Top >= screenWorkingArea.Y - borderSize);
-
-            Assert.True(form.Height >= screenWorkingArea.Height);
-            Assert.True(form.Height <= screenWorkingArea.Height + (borderSize * 2));
-
-            Assert.True(form.Width >= screenWorkingArea.Width / 2);
-            Assert.True(form.Width <= (screenWorkingArea.Width / 2) + (borderSize * 2));
-        });
-    }
-
-    private async Task RunEmptyFormTestAsync(Func<Form, Task> testDriverAsync)
-    {
-        await RunFormWithoutControlAsync(
-            () =>
-            {
-                var form = new Form();
-                form.TopMost = true;
-
-                return form;
-            },
-            testDriverAsync);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalSuppressions.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalSuppressions.cs
deleted file mode 100644
index 3865b67214b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalSuppressions.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// This file is used by Code Analysis to maintain SuppressMessage
-// attributes that are applied to this project.
-// Project-level suppressions either have no target or are given
-// a specific target and scoped to a namespace, type, member, etc.
-
-[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods")]
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalUsings.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalUsings.cs
deleted file mode 100644
index 0bb9068efd5..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/GlobalUsings.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using System.Diagnostics.CodeAnalysis;
-global using Windows.Win32;
-global using Windows.Win32.Foundation;
-global using Windows.Win32.UI.Controls;
-global using Xunit;
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ImageListTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ImageListTests.cs
deleted file mode 100644
index 2799a87e59c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ImageListTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Threading;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class ImageListTests : ControlTestBase
-{
-    // Base64-reencoded streamer using GetObjectData(Stream) from a decoded ClassicImageListStreamer
-    private const string DevMsImageListStreamer =
-        "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";
-
-    public ImageListTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/6635")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/6635")]
-    public void ImageList_FinalizerReleasesNativeHandle_ReturnsExpected()
-    {
-        // Warm up to create any GDI handles that are necessary, e.g. fonts, brushes, etc.
-        using (Form form = CreateForm())
-        {
-            form.Show();
-        }
-
-        uint startGdiHandleCount = GetGdiHandles();
-        TestOutputHelper.WriteLine($"GDI handles before: {startGdiHandleCount}");
-
-        // Now test for real
-        using (Form form = CreateForm())
-        {
-            form.Show();
-        }
-
-        uint endGdiHandleCount = GetGdiHandles();
-        TestOutputHelper.WriteLine($"GDI handles after: {endGdiHandleCount}");
-
-        Assert.Equal(startGdiHandleCount, endGdiHandleCount);
-
-        static uint GetGdiHandles()
-        {
-            GC.Collect();
-            GC.WaitForPendingFinalizers();
-            GC.Collect(0);
-
-            uint result = PInvoke.GetGuiResources((HANDLE)Process.GetCurrentProcess().Handle,
-                GET_GUI_RESOURCES_FLAGS.GR_GDIOBJECTS);
-            if (result == 0)
-            {
-                int lastWin32Error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(lastWin32Error, "Failed to retrieves the count of GDI handles");
-            }
-
-            return result;
-        }
-    }
-
-    private Form CreateForm()
-    {
-        ListView listView1 = new()
-        {
-            Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left,
-            Location = new Point(12, 33),
-            Name = "listView1",
-            Size = new Size(439, 59),
-            TabIndex = 0,
-            UseCompatibleStateImageBehavior = false
-        };
-
-        Form form = new();
-        form.AutoScaleMode = AutoScaleMode.Font;
-        form.Controls.Add(listView1);
-        form.Name = "ListViewTest";
-        form.Text = "ListView Test";
-
-        ImageList imageList1 = new();
-        imageList1.ImageStream = DeserializeStreamer(DevMsImageListStreamer);
-        listView1.SmallImageList = imageList1;
-
-        return form;
-    }
-
-    private static ImageListStreamer DeserializeStreamer(string base64String)
-    {
-        byte[] bytes = Convert.FromBase64String(base64String);
-        using MemoryStream ms = new(bytes);
-        return new ImageListStreamer(ms);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ControlTestBase.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ControlTestBase.cs
deleted file mode 100644
index 915aa53e0a6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ControlTestBase.cs
+++ /dev/null
@@ -1,381 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.UITests.Input;
-using Microsoft.VisualStudio.Threading;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Windows.Win32.UI.WindowsAndMessaging;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-[UseDefaultXunitCulture]
-[UISettings(MaxAttempts = 3)] // Try up to 3 times before failing.
-public abstract class ControlTestBase : IAsyncLifetime, IDisposable
-{
-    private const int SPIF_SENDCHANGE = 0x0002;
-
-    private bool _clientAreaAnimation;
-    private DenyExecutionSynchronizationContext? _denyExecutionSynchronizationContext;
-    private JoinableTaskCollection _joinableTaskCollection = null!;
-    private static string s_previousRunTestName = "This is the first test to run.";
-
-    private Point? _mousePosition;
-
-    static ControlTestBase()
-    {
-        DataCollectionService.InstallFirstChanceExceptionHandler();
-    }
-
-    protected ControlTestBase(ITestOutputHelper testOutputHelper)
-    {
-        TestOutputHelper = testOutputHelper;
-        DataCollectionService.CurrentTest = GetTest();
-        testOutputHelper.WriteLine($" Previous run test: {s_previousRunTestName}");
-        s_previousRunTestName = DataCollectionService.CurrentTest.DisplayName;
-
-        Application.EnableVisualStyles();
-
-        // Disable animations for maximum test performance
-        bool disabled = false;
-        Assert.True(PInvoke.SystemParametersInfo(SYSTEM_PARAMETERS_INFO_ACTION.SPI_GETCLIENTAREAANIMATION, ref _clientAreaAnimation));
-        Assert.True(PInvoke.SystemParametersInfo(SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETCLIENTAREAANIMATION, ref disabled, SPIF_SENDCHANGE));
-
-        ITest GetTest()
-        {
-            var type = testOutputHelper.GetType();
-            var testMember = type.GetField("test", BindingFlags.Instance | BindingFlags.NonPublic)!;
-            return (ITest)testMember.GetValue(testOutputHelper)!;
-        }
-    }
-
-    protected ITestOutputHelper TestOutputHelper { get; }
-
-    protected JoinableTaskContext JoinableTaskContext { get; private set; } = null!;
-
-    protected JoinableTaskFactory JoinableTaskFactory { get; private set; } = null!;
-
-    protected SendInput InputSimulator => new(WaitForIdleAsync);
-
-    public virtual Task InitializeAsync()
-    {
-        // Verify keyboard and mouse state at the start of the test
-        VerifyKeyStates(isStartOfTest: true, TestOutputHelper);
-
-        // Record the mouse position so it can be restored at the end of the test
-        _mousePosition = Cursor.Position;
-
-        if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
-        {
-            JoinableTaskContext = new JoinableTaskContext();
-        }
-        else
-        {
-            _denyExecutionSynchronizationContext = new DenyExecutionSynchronizationContext(SynchronizationContext.Current!);
-            JoinableTaskContext = new JoinableTaskContext(_denyExecutionSynchronizationContext.MainThread, _denyExecutionSynchronizationContext);
-        }
-
-        _joinableTaskCollection = JoinableTaskContext.CreateCollection();
-        JoinableTaskFactory = JoinableTaskContext.CreateFactory(_joinableTaskCollection);
-        return Task.CompletedTask;
-    }
-
-    public virtual async Task DisposeAsync()
-    {
-        await _joinableTaskCollection.JoinTillEmptyAsync();
-
-        // Verify keyboard and mouse state at the end of the test
-        VerifyKeyStates(isStartOfTest: false, TestOutputHelper);
-
-        // Restore the mouse position
-        if (_mousePosition is { } mousePosition)
-        {
-            Cursor.Position = mousePosition;
-        }
-
-        JoinableTaskContext = null!;
-        JoinableTaskFactory = null!;
-        if (_denyExecutionSynchronizationContext is not null)
-        {
-            SynchronizationContext.SetSynchronizationContext(_denyExecutionSynchronizationContext.UnderlyingContext);
-            _denyExecutionSynchronizationContext.ThrowIfSwitchOccurred();
-        }
-    }
-
-    public virtual void Dispose()
-    {
-        Assert.True(PInvoke.SystemParametersInfo(SYSTEM_PARAMETERS_INFO_ACTION.SPI_SETCLIENTAREAANIMATION, ref _clientAreaAnimation));
-        DataCollectionService.CurrentTest = null;
-    }
-
-    private void VerifyKeyStates(bool isStartOfTest, ITestOutputHelper testOutputHelper)
-    {
-        // Verify that no window has currently captured the cursor
-        Assert.Equal(HWND.Null, PInvoke.GetCapture());
-
-        // Verify that no keyboard or mouse keys are in the pressed state at the beginning of the test, since
-        // this could interfere with test behavior. This code uses GetAsyncKeyState since GetKeyboardState was
-        // not working reliably in local testing.
-        foreach (var code in Enum.GetValues<VIRTUAL_KEY>())
-        {
-            if (code is VIRTUAL_KEY.VK_SCROLL or VIRTUAL_KEY.VK_NUMLOCK)
-                continue;
-
-            if (PInvoke.GetAsyncKeyState((int)code) < 0)
-            {
-                // 😕 VK_LEFT and VK_RIGHT was observed to be pressed at the start of a test even though no test
-                // ran before it
-                if (isStartOfTest && code is VIRTUAL_KEY.VK_LEFT or VIRTUAL_KEY.VK_RIGHT)
-                {
-                    testOutputHelper.WriteLine($"Sending WM_KEYUP for '{code}' at the start of the test");
-                    new InputSimulator().Keyboard.KeyUp(code);
-                }
-                else
-                {
-                    Assert.Fail($"The key with virtual key code '{code}' was unexpectedly pressed at the {(isStartOfTest ? "start" : "end")} of the test.");
-                }
-            }
-        }
-    }
-
-    protected async Task WaitForIdleAsync()
-    {
-        TaskCompletionSource<VoidResult> idleCompletionSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
-        Application.Idle += HandleApplicationIdle;
-        Application.LeaveThreadModal += HandleApplicationIdle;
-
-        try
-        {
-            // Queue an event to make sure we don't stall if the application was already idle
-            await JoinableTaskFactory.SwitchToMainThreadAsync();
-            await Task.Yield();
-
-            if (Application.OpenForms.Count > 0)
-            {
-                await idleCompletionSource.Task;
-            }
-        }
-        finally
-        {
-            Application.Idle -= HandleApplicationIdle;
-            Application.LeaveThreadModal -= HandleApplicationIdle;
-        }
-
-        void HandleApplicationIdle(object? sender, EventArgs e)
-        {
-            idleCompletionSource.TrySetResult(default);
-        }
-    }
-
-    protected async Task MoveMouseToControlAsync(Control control)
-    {
-        var rect = control.DisplayRectangle;
-        var centerOfRect = GetCenter(rect);
-        var centerOnScreen = control.PointToScreen(centerOfRect);
-        await MoveMouseAsync(control.FindForm()!, centerOnScreen);
-    }
-
-    protected internal static Point ToVirtualPoint(Point point)
-    {
-        Size primaryMonitor = SystemInformation.PrimaryMonitorSize;
-        return new Point(
-            (int)Math.Ceiling((65535.0 / (primaryMonitor.Width - 1)) * point.X),
-            (int)Math.Ceiling((65535.0 / (primaryMonitor.Height - 1)) * point.Y));
-    }
-
-    protected async Task MoveMouseAsync(Form window, Point point, bool assertCorrectLocation = true)
-    {
-        TestOutputHelper.WriteLine($"Moving mouse to ({point.X}, {point.Y}).");
-        Size primaryMonitor = SystemInformation.PrimaryMonitorSize;
-        var virtualPoint = ToVirtualPoint(point);
-        TestOutputHelper.WriteLine($"Screen resolution of ({primaryMonitor.Width}, {primaryMonitor.Height}) translates mouse to ({virtualPoint.X}, {virtualPoint.Y}).");
-
-        await InputSimulator.SendAsync(window, inputSimulator => inputSimulator.Mouse.MoveMouseTo(virtualPoint.X, virtualPoint.Y));
-
-        // ⚠ The call to GetCursorPos is required for correct behavior.
-        if (!PInvoke.GetCursorPos(out Point actualPoint))
-        {
-#pragma warning disable CS8597 // Thrown value may be null.
-            throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
-#pragma warning restore CS8597 // Thrown value may be null.
-        }
-
-        if (actualPoint.X != point.X || actualPoint.Y != point.Y)
-        {
-            // Wait and try again
-            await Task.Delay(15);
-            if (!PInvoke.GetCursorPos(out Point _))
-            {
-#pragma warning disable CS8597 // Thrown value may be null.
-                throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
-#pragma warning restore CS8597 // Thrown value may be null.
-            }
-        }
-
-        if (assertCorrectLocation)
-        {
-            Assert.Equal(point, actualPoint);
-        }
-    }
-
-    protected async Task RunSingleControlTestAsync<T>(Func<Form, T, Task> testDriverAsync)
-        where T : Control, new()
-    {
-        await RunFormAsync(
-            () =>
-            {
-                var form = new Form();
-                form.TopMost = true;
-
-                var control = new T();
-                form.Controls.Add(control);
-
-                return (form, control);
-            },
-            testDriverAsync);
-    }
-
-    protected async Task RunSingleControlTestAsync<T>(Func<Form, T, Task> testDriverAsync, Func<T> createControl, Func<Form>? createForm = null)
-        where T : Control, new()
-    {
-        await RunFormAsync(
-            () =>
-            {
-                Form form;
-                if (createForm is null)
-                {
-                    form = new();
-                }
-                else
-                {
-                    form = createForm();
-                }
-
-                form.TopMost = true;
-
-                T control = createControl();
-                Assert.NotNull(control);
-
-                form.Controls.Add(control);
-
-                return (form, control);
-            },
-            testDriverAsync);
-    }
-
-    protected async Task RunControlPairTestAsync<T1, T2>(Func<Form, (T1 control1, T2 control2), Task> testDriverAsync)
-        where T1 : Control, new()
-        where T2 : Control, new()
-    {
-        await RunFormAsync(
-            () =>
-            {
-                var form = new Form();
-                form.TopMost = true;
-
-                var control1 = new T1();
-                var control2 = new T2();
-
-                var tableLayout = new TableLayoutPanel();
-                tableLayout.ColumnCount = 2;
-                tableLayout.RowCount = 1;
-                tableLayout.Controls.Add(control1, 0, 0);
-                tableLayout.Controls.Add(control2, 1, 0);
-                form.Controls.Add(tableLayout);
-
-                return (form, (control1, control2));
-            },
-            testDriverAsync);
-    }
-
-    protected async Task RunFormAsync<T>(Func<(Form dialog, T control)> createDialog, Func<Form, T, Task> testDriverAsync)
-    {
-        Form? dialog = null;
-        T? control = default;
-
-        TaskCompletionSource<VoidResult> gate = new TaskCompletionSource<VoidResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-        JoinableTask test = JoinableTaskFactory.RunAsync(async () =>
-        {
-            await gate.Task;
-            await JoinableTaskFactory.SwitchToMainThreadAsync();
-            await WaitForIdleAsync();
-            try
-            {
-                await testDriverAsync(dialog!, control!);
-            }
-            catch (Exception ex) when (DataCollectionService.LogAndPropagate(ex))
-            {
-                throw new InvalidOperationException("Not reachable");
-            }
-            finally
-            {
-                dialog!.Close();
-                dialog.Dispose();
-                dialog = null;
-            }
-        });
-
-        await JoinableTaskFactory.SwitchToMainThreadAsync();
-        (dialog, control) = createDialog();
-
-        Assert.NotNull(dialog);
-        Assert.NotNull(control);
-
-        dialog.Activated += (sender, e) => gate.TrySetResult(default);
-        dialog.ShowDialog();
-
-        await test.JoinAsync();
-    }
-
-    protected async Task RunFormWithoutControlAsync<TForm>(Func<TForm> createForm, Func<TForm, Task> testDriverAsync)
-        where TForm : Form
-    {
-        TForm? dialog = null;
-
-        TaskCompletionSource<VoidResult> gate = new TaskCompletionSource<VoidResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-        JoinableTask test = JoinableTaskFactory.RunAsync(async () =>
-        {
-            await gate.Task;
-            await JoinableTaskFactory.SwitchToMainThreadAsync();
-            await WaitForIdleAsync();
-            try
-            {
-                await testDriverAsync(dialog!);
-            }
-            catch (Exception ex) when (DataCollectionService.LogAndPropagate(ex))
-            {
-                throw new InvalidOperationException("Not reachable");
-            }
-            finally
-            {
-                dialog!.Close();
-                dialog.Dispose();
-                dialog = null;
-            }
-        });
-
-        await JoinableTaskFactory.SwitchToMainThreadAsync();
-        dialog = createForm();
-
-        Assert.NotNull(dialog);
-
-        dialog.Activated += (sender, e) => gate.TrySetResult(default);
-        dialog.ShowDialog();
-
-        await test.JoinAsync();
-    }
-
-    internal struct VoidResult
-    {
-    }
-
-    internal static Point GetCenter(Rectangle cell)
-    {
-        return new Point(GetMiddle(cell.Right, cell.Left), GetMiddle(cell.Top, cell.Bottom));
-
-        static int GetMiddle(int a, int b) => a + ((b - a) / 2);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DataCollectionService.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DataCollectionService.cs
deleted file mode 100644
index db438f6d69f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DataCollectionService.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
-using System.Text;
-using Xunit.Abstractions;
-using Xunit.Sdk;
-
-namespace System.Windows.Forms.UITests;
-
-internal static class DataCollectionService
-{
-    private static readonly ConditionalWeakTable<Exception, StrongBox<bool>> LoggedExceptions = new();
-    private static ImmutableList<CustomLoggerData> _customInProcessLoggers = ImmutableList<CustomLoggerData>.Empty;
-    private static bool _firstChanceExceptionHandlerInstalled;
-
-    [ThreadStatic]
-    private static bool _inHandler;
-
-    internal static ITest? CurrentTest { get; set; }
-
-    static DataCollectionService()
-    {
-        // Register the default custom logger to take screenshots on failure
-        RegisterCustomLogger(
-            ScreenshotService.TakeScreenshot,
-            logId: string.Empty,
-            extension: "png");
-    }
-
-    private static string CurrentTestName
-    {
-        get
-        {
-            if (CurrentTest is null)
-            {
-                return "Unknown";
-            }
-
-            return GetTestName(CurrentTest.TestCase);
-        }
-    }
-
-    /// <summary>
-    /// Register a custom logger to collect data in the event of a test failure.
-    /// </summary>
-    /// <remarks>
-    /// <para>The <paramref name="logId"/> and <paramref name="extension"/> should be chosen to avoid conflicts with
-    /// other loggers. Otherwise, it is possible for logs to be overwritten during data collection. Built-in logs
-    /// include:</para>
-    ///
-    /// <list type="table">
-    ///   <listheader>
-    ///     <description><strong>Log ID</strong></description>
-    ///     <description><strong>Extension</strong></description>
-    ///     <description><strong>Purpose</strong></description>
-    ///   </listheader>
-    ///   <item>
-    ///     <description>None</description>
-    ///     <description><c>log</c></description>
-    ///     <description>Exception details</description>
-    ///   </item>
-    ///   <item>
-    ///     <description>None</description>
-    ///     <description><c>png</c></description>
-    ///     <description>Screenshot</description>
-    ///   </item>
-    /// </list>
-    /// </remarks>
-    /// <param name="callback">The callback to invoke to collect log information. The argument to the callback is the fully-qualified file path where the log data should be written.</param>
-    /// <param name="logId">An optional log identifier to include in the resulting file name.</param>
-    /// <param name="extension">The extension to give the resulting file.</param>
-    public static void RegisterCustomLogger(Action<string> callback, string logId, string extension)
-    {
-        ImmutableInterlocked.Update(
-            ref _customInProcessLoggers,
-            (loggers, newLogger) => loggers.Add(newLogger),
-            new CustomLoggerData(callback, logId, extension));
-    }
-
-    internal static string GetTestName(ITestCase testCase)
-    {
-        var testMethod = testCase.TestMethod.Method;
-        var testClass = testCase.TestMethod.TestClass.Class.Name;
-        var lastDot = testClass.LastIndexOf('.');
-        testClass = testClass.Substring(lastDot + 1);
-        return $"{testClass}.{testMethod.Name}";
-    }
-
-    internal static void InstallFirstChanceExceptionHandler()
-    {
-        if (!_firstChanceExceptionHandlerInstalled)
-        {
-            AppDomain.CurrentDomain.FirstChanceException += OnFirstChanceException;
-            _firstChanceExceptionHandlerInstalled = true;
-        }
-    }
-
-    internal static bool LogAndCatch(Exception ex)
-    {
-        try
-        {
-            TryLog(ex);
-        }
-        catch
-        {
-            // Make sure exceptions do not escape the exception filter
-        }
-
-        return true;
-    }
-
-    internal static bool LogAndPropagate(Exception ex)
-    {
-        try
-        {
-            TryLog(ex);
-        }
-        catch
-        {
-            // Make sure exceptions do not escape the exception filter
-        }
-
-        return false;
-    }
-
-    internal static bool TryLog(Exception ex)
-    {
-        if (ex is null)
-        {
-            return false;
-        }
-
-        var logged = LoggedExceptions.GetOrCreateValue(ex);
-        if (logged.Value)
-        {
-            // Only log the first time an exception is thrown
-            return false;
-        }
-
-        logged.Value = true;
-        CaptureFailureState(CurrentTestName, ex);
-        return true;
-    }
-
-    internal static void CaptureFailureState(string testName, Exception ex)
-    {
-        if (_inHandler)
-        {
-            // Avoid stack overflow which could occur by recursively trying to capture failure states
-            return;
-        }
-
-        try
-        {
-            _inHandler = true;
-
-            var logDir = GetLogDirectory();
-            var timestamp = DateTimeOffset.UtcNow;
-            testName ??= "Unknown";
-            var errorId = ex.GetType().Name;
-
-            Directory.CreateDirectory(logDir);
-
-            var exceptionDetails = new StringBuilder();
-            exceptionDetails.AppendLine(ex.ToString());
-            exceptionDetails.AppendLine("---------------------------------");
-            exceptionDetails.AppendLine("Stack Trace at Log Time:");
-            exceptionDetails.AppendLine(new StackTrace(true).ToString());
-            File.WriteAllText(CreateLogFileName(logDir, timestamp, testName, errorId, logId: string.Empty, "log"), exceptionDetails.ToString());
-            foreach (var (callback, logId, extension) in _customInProcessLoggers)
-            {
-                callback(CreateLogFileName(logDir, timestamp, testName, errorId, logId, extension));
-            }
-        }
-        finally
-        {
-            _inHandler = false;
-        }
-    }
-
-    private static void OnFirstChanceException(object? sender, FirstChanceExceptionEventArgs e)
-    {
-        if (e.Exception is not XunitException)
-        {
-            // Only xunit exceptions are logged in this handler
-            return;
-        }
-
-        TryLog(e.Exception);
-    }
-
-    /// <summary>
-    /// Computes a full log file name.
-    /// </summary>
-    /// <param name="logDirectory">The location where logs are saved.</param>
-    /// <param name="timestamp">The timestamp of the failure.</param>
-    /// <param name="testName">The current test name, or <c>Unknown</c> if the test is not known.</param>
-    /// <param name="errorId">The error ID, e.g. the name of the exception instance.</param>
-    /// <param name="logId">The log ID (e.g. <c>DotNet</c> or <c>Watson</c>). This may be an empty string for one log output of a particular <paramref name="extension"/>.</param>
-    /// <param name="extension">The log file extension, without a dot (e.g. <c>log</c>).</param>
-    /// <returns>The fully qualified log file name.</returns>
-    private static string CreateLogFileName(string logDirectory, DateTimeOffset timestamp, string testName, string errorId, string logId, string extension)
-    {
-        const int MaxPath = 260;
-
-        var path = CombineElements(logDirectory, timestamp, testName, errorId, logId, extension);
-        if (path.Length > MaxPath)
-        {
-            testName = testName.Substring(0, Math.Max(0, testName.Length - (path.Length - MaxPath)));
-            path = CombineElements(logDirectory, timestamp, testName, errorId, logId, extension);
-        }
-
-        return path;
-
-        static string CombineElements(string logDirectory, DateTimeOffset timestamp, string testName, string errorId, string logId, string extension)
-        {
-            if (!string.IsNullOrEmpty(logId))
-            {
-                logId = $".{logId}";
-            }
-
-            var sanitizedTestName = new string(testName.Select(c => char.IsLetterOrDigit(c) ? c : '_').ToArray());
-            var sanitizedErrorId = new string(errorId.Select(c => char.IsLetterOrDigit(c) ? c : '_').ToArray());
-
-            return Path.Combine(Path.GetFullPath(logDirectory), $"{timestamp:HH.mm.ss}-{testName}-{errorId}{logId}.{extension}");
-        }
-    }
-
-    internal static string GetLogDirectory()
-    {
-        return Path.Combine(GetBaseLogDirectory(), "Screenshots");
-    }
-
-    private static string GetBaseLogDirectory()
-    {
-        if (Environment.GetEnvironmentVariable("XUNIT_LOGS") is { Length: > 0 } baseLogDirectory)
-        {
-            return Path.GetFullPath(baseLogDirectory);
-        }
-
-        // Output assembly is located in a directory similar to:
-        //   C:\dev\winforms\artifacts\bin\System.Windows.Forms.UI.IntegrationTests\Debug\net8.0
-        var assemblyDirectory = GetAssemblyDirectory();
-
-        var binPathSeparator = assemblyDirectory.IndexOf(@"\bin\", StringComparison.Ordinal);
-        if (binPathSeparator > 0)
-        {
-            var configuration = Path.GetFileName(Path.GetDirectoryName(assemblyDirectory))!;
-            return Path.Combine(assemblyDirectory[..binPathSeparator], "log", configuration);
-        }
-
-        return Path.Combine(assemblyDirectory, "xUnitResults");
-    }
-
-    private static string GetAssemblyDirectory()
-    {
-        var assemblyPath = typeof(DataCollectionService).Assembly.Location;
-        return Path.GetDirectoryName(assemblyPath)!;
-    }
-
-    internal record struct CustomLoggerData(Action<string> Callback, string LogId, string Extension);
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DenyExecutionSynchronizationContext.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DenyExecutionSynchronizationContext.cs
deleted file mode 100644
index 0d4313de3a3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/DenyExecutionSynchronizationContext.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.ExceptionServices;
-
-namespace System.Windows.Forms.UITests;
-
-internal class DenyExecutionSynchronizationContext : SynchronizationContext
-{
-    private readonly SynchronizationContext _underlyingContext;
-    private readonly Thread _mainThread;
-    private readonly StrongBox<ExceptionDispatchInfo> _failedTransfer;
-
-    public DenyExecutionSynchronizationContext(SynchronizationContext underlyingContext)
-        : this(underlyingContext, mainThread: null, failedTransfer: null)
-    {
-    }
-
-    private DenyExecutionSynchronizationContext(SynchronizationContext underlyingContext, Thread? mainThread, StrongBox<ExceptionDispatchInfo>? failedTransfer)
-    {
-        _underlyingContext = underlyingContext;
-        _mainThread = mainThread ?? new Thread(MainThreadStart);
-        _failedTransfer = failedTransfer ?? new StrongBox<ExceptionDispatchInfo>();
-    }
-
-    internal SynchronizationContext UnderlyingContext => _underlyingContext;
-
-    internal Thread MainThread => _mainThread;
-
-    private static void MainThreadStart() => throw new InvalidOperationException("This thread should never be started.");
-
-    internal void ThrowIfSwitchOccurred()
-    {
-        if (_failedTransfer.Value is null)
-        {
-            return;
-        }
-
-        _failedTransfer.Value.Throw();
-    }
-
-    public override void Post(SendOrPostCallback d, object? state)
-    {
-        try
-        {
-            if (_failedTransfer.Value is null)
-            {
-                ThrowFailedTransferExceptionForCapture();
-            }
-        }
-        catch (InvalidOperationException e)
-        {
-            _failedTransfer.Value = ExceptionDispatchInfo.Capture(e);
-        }
-
-#pragma warning disable VSTHRD001 // Avoid legacy thread switching APIs
-        (_underlyingContext ?? new SynchronizationContext()).Post(d, state);
-#pragma warning restore VSTHRD001 // Avoid legacy thread switching APIs
-    }
-
-    public override void Send(SendOrPostCallback d, object? state)
-    {
-        try
-        {
-            if (_failedTransfer.Value is null)
-            {
-                ThrowFailedTransferExceptionForCapture();
-            }
-        }
-        catch (InvalidOperationException e)
-        {
-            _failedTransfer.Value = ExceptionDispatchInfo.Capture(e);
-        }
-
-#pragma warning disable VSTHRD001 // Avoid legacy thread switching APIs
-        (_underlyingContext ?? new SynchronizationContext()).Send(d, state);
-#pragma warning restore VSTHRD001 // Avoid legacy thread switching APIs
-    }
-
-    public override SynchronizationContext CreateCopy()
-    {
-        return new DenyExecutionSynchronizationContext(_underlyingContext.CreateCopy(), _mainThread, _failedTransfer);
-    }
-
-    private static void ThrowFailedTransferExceptionForCapture()
-    {
-        throw new InvalidOperationException("Tests cannot use SwitchToMainThreadAsync unless they are marked with ApartmentState.STA.");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ScreenshotService.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ScreenshotService.cs
deleted file mode 100644
index ade77ef4051..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/ScreenshotService.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Imaging;
-
-namespace System.Windows.Forms.UITests;
-
-internal static class ScreenshotService
-{
-    private static readonly object Gate = new();
-
-    /// <summary>
-    /// Takes a picture of the screen and saves it to the location specified by
-    /// <paramref name="fullPath"/>. Files are always saved in PNG format, regardless of the
-    /// file extension.
-    /// </summary>
-    public static void TakeScreenshot(string fullPath)
-    {
-        // This gate prevents concurrency for two reasons:
-        //
-        // 1. Only one screenshot is held in memory at a time to prevent running out of memory for large displays
-        // 2. Only one screenshot is written to disk at a time to avoid exceptions if concurrent calls are writing
-        //    to the same file
-        lock (Gate)
-        {
-            using var bitmap = TryCaptureFullScreen();
-            if (bitmap is null)
-            {
-                return;
-            }
-
-            var directory = Path.GetDirectoryName(fullPath)!;
-            Directory.CreateDirectory(directory);
-
-            bitmap.Save(fullPath, ImageFormat.Png);
-        }
-    }
-
-    /// <summary>
-    /// Captures the full screen to a <see cref="Bitmap"/>.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="Bitmap"/> containing the screen capture of the desktop, or <see langword="null"/> if a screen
-    /// capture can't be created.
-    /// </returns>
-    private static Bitmap? TryCaptureFullScreen()
-    {
-        if (Screen.PrimaryScreen is not { } primaryScreen)
-            return null;
-
-        var width = primaryScreen.Bounds.Width;
-        var height = primaryScreen.Bounds.Height;
-
-        if (width <= 0 || height <= 0)
-        {
-            // Don't try to take a screenshot if there is no screen.
-            // This may not be an interactive session.
-            return null;
-        }
-
-        var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
-
-        using (var graphics = Graphics.FromImage(bitmap))
-        {
-            graphics.CopyFromScreen(
-                sourceX: primaryScreen.Bounds.X,
-                sourceY: primaryScreen.Bounds.Y,
-                destinationX: 0,
-                destinationY: 0,
-                blockRegionSize: bitmap.Size,
-                copyPixelOperation: CopyPixelOperation.SourceCopy);
-
-            if (Cursor.Current is { } cursor)
-            {
-                var bounds = new Rectangle(Cursor.Position - (Size)cursor.HotSpot, cursor.Size);
-                cursor.Draw(graphics, bounds);
-            }
-
-            return bitmap;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/SendInput.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/SendInput.cs
deleted file mode 100644
index e9c90def7df..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Infra/SendInput.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.UITests.Input;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Windows.Win32.UI.WindowsAndMessaging;
-
-namespace System.Windows.Forms.UITests;
-
-public class SendInput
-{
-    private readonly Func<Task> _waitForIdleAsync;
-
-    public SendInput(Func<Task> waitForIdleAsync)
-    {
-        _waitForIdleAsync = waitForIdleAsync;
-    }
-
-    internal async Task SendAsync(Form window, params object[] keys)
-    {
-        await SendAsync(window, inputSimulator =>
-        {
-            foreach (var key in keys)
-            {
-                switch (key)
-                {
-                    case string str:
-                        var text = str.Replace("\r\n", "\r").Replace("\n", "\r");
-                        int index = 0;
-                        while (index < text.Length)
-                        {
-                            if (text[index] == '\r')
-                            {
-                                inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RETURN);
-                                index++;
-                            }
-                            else
-                            {
-                                int nextIndex = text.IndexOf('\r', index);
-                                if (nextIndex == -1)
-                                {
-                                    nextIndex = text.Length;
-                                }
-
-                                inputSimulator.Keyboard.TextEntry(text.Substring(index, nextIndex - index));
-                                index = nextIndex;
-                            }
-                        }
-
-                        break;
-
-                    case char c:
-                        inputSimulator.Keyboard.TextEntry(c);
-                        break;
-
-                    case VIRTUAL_KEY virtualKeyCode:
-                        inputSimulator.Keyboard.KeyPress(virtualKeyCode);
-                        break;
-
-                    case null:
-                        throw new ArgumentNullException(nameof(keys));
-
-                    default:
-                        throw new ArgumentException($"Unexpected type encountered: {key.GetType()}", nameof(keys));
-                }
-            }
-        });
-    }
-
-    internal async Task SendAsync(Form window, Action<InputSimulator> actions)
-    {
-        if (actions is null)
-        {
-            throw new ArgumentNullException(nameof(actions));
-        }
-
-        SetForegroundWindow(window);
-        await Task.Run(() => actions(new InputSimulator()));
-
-        await _waitForIdleAsync();
-    }
-
-    private static HWND GetForegroundWindow()
-    {
-        var startTime = DateTime.Now;
-
-        // Attempt to get the foreground window in a loop, as the NativeMethods function can return IntPtr.Zero
-        // in certain circumstances, such as when a window is losing activation.
-        HWND foregroundWindow;
-        do
-        {
-            foregroundWindow = PInvoke.GetForegroundWindow();
-        }
-        while (foregroundWindow == IntPtr.Zero
-            && DateTime.Now - startTime < TimeSpan.FromMilliseconds(500));
-
-        return foregroundWindow;
-    }
-
-    private static void SetForegroundWindow(Form window)
-    {
-        // Make the window a top-most window so it will appear above any existing top-most windows
-        PInvoke.SetWindowPos(window, HWND.HWND_TOPMOST, 0, 0, 0, 0, SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOMOVE);
-
-        // Move the window into the foreground as it may not have been achieved by the 'SetWindowPos' call
-        if (!PInvoke.SetForegroundWindow(window))
-        {
-            string windowTitle = PInvoke.GetWindowText(window);
-            if (PInvoke.GetWindowThreadProcessId(window, out uint processId) == 0 || processId != Environment.ProcessId)
-            {
-                string message = $"ForegroundWindow doesn't belong the test process! The current window HWND: {window}, title:{windowTitle}.";
-                throw new InvalidOperationException(message);
-            }
-        }
-
-        // Ensure the window is 'Active' as it may not have been achieved by 'SetForegroundWindow'
-        PInvoke.SetActiveWindow(window);
-
-        // Give the window the keyboard focus as it may not have been achieved by 'SetActiveWindow'
-        PInvoke.SetFocus(window);
-
-        // Remove the 'Top-Most' qualification from the window
-        PInvoke.SetWindowPos(window, HWND.HWND_NOTOPMOST, 0, 0, 0, 0, SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOMOVE);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputBuilder.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputBuilder.cs
deleted file mode 100644
index d3dfc5ff425..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputBuilder.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-
-namespace System.Windows.Forms.UITests.Input;
-
-internal static class InputBuilder
-{
-    public static INPUT KeyDown(VIRTUAL_KEY keyCode)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_KEYBOARD,
-            Anonymous =
-            {
-                ki = new KEYBDINPUT
-                {
-                    wVk = keyCode,
-                    wScan = (ushort)(PInvoke.MapVirtualKey((uint)keyCode, MAP_VIRTUAL_KEY_TYPE.MAPVK_VK_TO_VSC) & 0xFFU),
-                    dwFlags = IsExtendedKey(keyCode) ? KEYBD_EVENT_FLAGS.KEYEVENTF_EXTENDEDKEY : 0,
-                    time = 0,
-                    dwExtraInfo = 0,
-                },
-            },
-        };
-    }
-
-    public static INPUT KeyUp(VIRTUAL_KEY keyCode)
-    {
-        var input = KeyDown(keyCode);
-        input.Anonymous.ki.dwFlags |= KEYBD_EVENT_FLAGS.KEYEVENTF_KEYUP;
-        return input;
-    }
-
-    public static INPUT CharacterDown(char character)
-    {
-        ushort scanCode = character;
-        var input = new INPUT
-        {
-            type = INPUT_TYPE.INPUT_KEYBOARD,
-            Anonymous =
-            {
-                ki = new KEYBDINPUT
-                {
-                    wVk = 0,
-                    wScan = scanCode,
-                    dwFlags = KEYBD_EVENT_FLAGS.KEYEVENTF_UNICODE,
-                    time = 0,
-                    dwExtraInfo = 0,
-                },
-            },
-        };
-
-        // Handle extended keys:
-        // If the scan code is preceded by a prefix byte that has the value 0xE0 (224),
-        // we need to include the KEYEVENTF_EXTENDEDKEY flag in the Flags property. 
-        if ((scanCode & 0xFF00) == 0xE000)
-        {
-            input.Anonymous.ki.dwFlags |= KEYBD_EVENT_FLAGS.KEYEVENTF_EXTENDEDKEY;
-        }
-
-        return input;
-    }
-
-    public static INPUT CharacterUp(char character)
-    {
-        var input = CharacterDown(character);
-        input.Anonymous.ki.dwFlags |= KEYBD_EVENT_FLAGS.KEYEVENTF_KEYUP;
-        return input;
-    }
-
-    public static INPUT MouseButtonDown(MouseButtons button)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_MOUSE,
-            Anonymous =
-            {
-                mi = new MOUSEINPUT
-                {
-                    dwFlags =
-                        button switch
-                        {
-                            MouseButtons.Left => MOUSE_EVENT_FLAGS.MOUSEEVENTF_LEFTDOWN,
-                            MouseButtons.Middle => MOUSE_EVENT_FLAGS.MOUSEEVENTF_MIDDLEDOWN,
-                            MouseButtons.Right => MOUSE_EVENT_FLAGS.MOUSEEVENTF_RIGHTDOWN,
-                            _ => throw new ArgumentException("Unexpected button", nameof(button)),
-                        },
-                }
-            },
-        };
-    }
-
-    public static INPUT MouseButtonUp(MouseButtons button)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_MOUSE,
-            Anonymous =
-            {
-                mi = new MOUSEINPUT
-                {
-                    dwFlags =
-                        button switch
-                        {
-                            MouseButtons.Left => MOUSE_EVENT_FLAGS.MOUSEEVENTF_LEFTUP,
-                            MouseButtons.Middle => MOUSE_EVENT_FLAGS.MOUSEEVENTF_MIDDLEUP,
-                            MouseButtons.Right => MOUSE_EVENT_FLAGS.MOUSEEVENTF_RIGHTUP,
-                            _ => throw new ArgumentException("Unexpected button", nameof(button)),
-                        },
-                }
-            },
-        };
-    }
-
-    public static INPUT RelativeMouseMovement(int x, int y)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_MOUSE,
-            Anonymous =
-            {
-                mi = new MOUSEINPUT
-                {
-                    dx = x,
-                    dy = y,
-                    dwFlags = MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE_NOCOALESCE,
-                }
-            },
-        };
-    }
-
-    public static INPUT AbsoluteMouseMovement(int x, int y)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_MOUSE,
-            Anonymous =
-            {
-                mi = new MOUSEINPUT
-                {
-                    dx = x,
-                    dy = y,
-                    dwFlags = MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE_NOCOALESCE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_ABSOLUTE,
-                }
-            },
-        };
-    }
-
-    public static INPUT AbsoluteMouseMovementOnVirtualDesktop(int x, int y)
-    {
-        return new INPUT
-        {
-            type = INPUT_TYPE.INPUT_MOUSE,
-            Anonymous =
-            {
-                mi = new MOUSEINPUT
-                {
-                    dx = x,
-                    dy = y,
-                    dwFlags = MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_MOVE_NOCOALESCE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_ABSOLUTE | MOUSE_EVENT_FLAGS.MOUSEEVENTF_VIRTUALDESK,
-                }
-            },
-        };
-    }
-
-    private static bool IsExtendedKey(VIRTUAL_KEY keyCode)
-    {
-        // Pass through to VirtualKeyUtilities. Note that there are differences between InputSimulatorPlus and
-        // VirtualKeyUtilities for this method.
-        //
-        // Keys considered expended by VirtualKeyUtilities but not by InputSimulatorPlus:
-        //   VK_APPS
-        //   VK_RWIN
-        //   VK_LWIN
-        //
-        // Keys considered extended by InputSimulatorPlus but not by VirtualKeyUtilities:
-        //   VK_MENU
-        //   VK_CONTROL
-        //   VK_CANCEL
-        //   VK_SNAPSHOT
-        //   VK_DIVIDE
-        return VirtualKeyUtilities.IsExtendedKey(keyCode);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputSimulator.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputSimulator.cs
deleted file mode 100644
index 48d19952ce2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/InputSimulator.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.UITests.Input;
-
-internal class InputSimulator
-{
-    public InputSimulator()
-    {
-        Keyboard = new KeyboardSimulator(this);
-        Mouse = new MouseSimulator(this);
-    }
-
-    public KeyboardSimulator Keyboard { get; }
-
-    public MouseSimulator Mouse { get; }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/KeyboardSimulator.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/KeyboardSimulator.cs
deleted file mode 100644
index f1db138c6b1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/KeyboardSimulator.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-
-namespace System.Windows.Forms.UITests.Input;
-
-internal class KeyboardSimulator
-{
-    private readonly InputSimulator _inputSimulator;
-
-    public KeyboardSimulator(InputSimulator inputSimulator)
-    {
-        _inputSimulator = inputSimulator;
-    }
-
-    public MouseSimulator Mouse => _inputSimulator.Mouse;
-
-    internal KeyboardSimulator KeyDown(VIRTUAL_KEY key)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.KeyDown(key),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator KeyUp(VIRTUAL_KEY key)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.KeyUp(key),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator KeyPress(VIRTUAL_KEY key)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.KeyDown(key),
-            InputBuilder.KeyUp(key),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator TextEntry(char character)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.CharacterDown(character),
-            InputBuilder.CharacterUp(character),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator TextEntry(string text)
-    {
-        if (text.Length == 0)
-        {
-            return this;
-        }
-
-        Span<INPUT> inputs = stackalloc INPUT[text.Length * 2];
-        for (var i = 0; i < text.Length; i++)
-        {
-            inputs[i * 2] = InputBuilder.CharacterDown(text[i]);
-            inputs[i * 2 + 1] = InputBuilder.CharacterUp(text[i]);
-        }
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator ModifiedKeyStroke(VIRTUAL_KEY modifierKeyCode, VIRTUAL_KEY keyCode)
-    {
-        return ModifiedKeyStroke(new[] { modifierKeyCode }, new[] { keyCode });
-    }
-
-    internal KeyboardSimulator ModifiedKeyStroke(IEnumerable<VIRTUAL_KEY> modifierKeyCodes, IEnumerable<VIRTUAL_KEY> keyCodes)
-    {
-        var modifierArray = modifierKeyCodes.ToArray();
-        var keyArray = keyCodes.ToArray();
-        if (modifierArray.Length == 0 && keyArray.Length == 0)
-        {
-            return this;
-        }
-
-        Span<INPUT> inputs = stackalloc INPUT[modifierArray.Length * 2 + keyArray.Length * 2];
-        for (var i = 0; i < modifierArray.Length; i++)
-        {
-            inputs[i] = InputBuilder.KeyDown(modifierArray[i]);
-            inputs[^(i + 1)] = InputBuilder.KeyUp(modifierArray[i]);
-        }
-
-        for (var i = 0; i < keyArray.Length; i++)
-        {
-            inputs[modifierArray.Length + i] = InputBuilder.KeyDown(keyArray[i]);
-            inputs[modifierArray.Length + i + 1] = InputBuilder.KeyUp(keyArray[i]);
-        }
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal KeyboardSimulator Sleep(TimeSpan time)
-    {
-        Thread.Sleep(time);
-        return this;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/MouseSimulator.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/MouseSimulator.cs
deleted file mode 100644
index fa8cb0395a8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Input/MouseSimulator.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-
-namespace System.Windows.Forms.UITests.Input;
-
-internal class MouseSimulator
-{
-    private readonly InputSimulator _inputSimulator;
-
-    public MouseSimulator(InputSimulator inputSimulator)
-    {
-        _inputSimulator = inputSimulator;
-    }
-
-    public KeyboardSimulator Keyboard => _inputSimulator.Keyboard;
-
-    internal MouseSimulator LeftButtonDown()
-    {
-        return ButtonDown(MouseButtons.Left);
-    }
-
-    internal MouseSimulator LeftButtonUp()
-    {
-        return ButtonUp(MouseButtons.Left);
-    }
-
-    internal MouseSimulator LeftButtonClick()
-    {
-        return ButtonClick(MouseButtons.Left);
-    }
-
-    internal MouseSimulator LeftButtonDoubleClick()
-    {
-        return ButtonDoubleClick(MouseButtons.Left);
-    }
-
-    internal MouseSimulator MiddleButtonDown()
-    {
-        return ButtonDown(MouseButtons.Middle);
-    }
-
-    internal MouseSimulator MiddleButtonUp()
-    {
-        return ButtonUp(MouseButtons.Middle);
-    }
-
-    internal MouseSimulator MiddleButtonClick()
-    {
-        return ButtonClick(MouseButtons.Middle);
-    }
-
-    internal MouseSimulator MiddleButtonDoubleClick()
-    {
-        return ButtonDoubleClick(MouseButtons.Middle);
-    }
-
-    internal MouseSimulator RightButtonDown()
-    {
-        return ButtonDown(MouseButtons.Right);
-    }
-
-    internal MouseSimulator RightButtonUp()
-    {
-        return ButtonUp(MouseButtons.Right);
-    }
-
-    internal MouseSimulator RightButtonClick()
-    {
-        return ButtonClick(MouseButtons.Right);
-    }
-
-    internal MouseSimulator RightButtonDoubleClick()
-    {
-        return ButtonDoubleClick(MouseButtons.Right);
-    }
-
-    private MouseSimulator ButtonDown(MouseButtons button)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.MouseButtonDown(button),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    private MouseSimulator ButtonUp(MouseButtons button)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.MouseButtonUp(button),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    private MouseSimulator ButtonClick(MouseButtons button)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.MouseButtonDown(button),
-            InputBuilder.MouseButtonUp(button),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    private MouseSimulator ButtonDoubleClick(MouseButtons button)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.MouseButtonDown(button),
-            InputBuilder.MouseButtonUp(button),
-            InputBuilder.MouseButtonDown(button),
-            InputBuilder.MouseButtonUp(button),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal MouseSimulator MoveMouseBy(int x, int y, bool bypassOperatingSystemSettings = true)
-    {
-        if (bypassOperatingSystemSettings)
-        {
-            // Redirect to MoveMouseTo, since the implementation of MoveMouseBy is subject to the OS's settings for
-            // mouse speed and acceleration.
-            Assert.True(PInvoke.GetPhysicalCursorPos(out var point));
-            var virtualPoint = ControlTestBase.ToVirtualPoint(point + new Size(x, y));
-            return MoveMouseTo(virtualPoint.X, virtualPoint.Y);
-        }
-
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.RelativeMouseMovement(x, y),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal MouseSimulator MoveMouseTo(double absoluteX, double absoluteY)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.AbsoluteMouseMovement((int)absoluteX, (int)absoluteY),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal MouseSimulator MoveMouseToPositionOnVirtualDesktop(double absoluteX, double absoluteY)
-    {
-        Span<INPUT> inputs = stackalloc INPUT[]
-        {
-            InputBuilder.AbsoluteMouseMovementOnVirtualDesktop((int)absoluteX, (int)absoluteY),
-        };
-
-        PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());
-        return this;
-    }
-
-    internal MouseSimulator Sleep(TimeSpan time)
-    {
-        Thread.Sleep(time);
-        return this;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomation.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomation.cs
deleted file mode 100644
index 2dbf579b844..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomation.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-internal static partial class UiaClient
-{
-    [ComImport]
-    [Guid("30CBE57D-D9D0-452A-AB13-7AC5AC4825EE")]
-    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
-    internal interface IUIAutomation
-    {
-        void CompareElements();
-
-        void CompareRuntimeIds();
-
-        void GetRootElement();
-
-        void ElementFromHandle();
-
-        void ElementFromPoint();
-
-        int GetFocusedElement(out IUIAutomationElement element);
-
-        void GetRootElementBuildCache();
-
-        void ElementFromHandleBuildCache();
-
-        void ElementFromPointBuildCache();
-
-        void GetFocusedElementBuildCache();
-
-        void CreateTreeWalker();
-
-        void get_ControlViewWalker();
-
-        void get_ContentViewWalker();
-
-        void get_RawViewWalker();
-
-        void get_RawViewCondition();
-
-        void get_ControlViewCondition();
-
-        void get_ContentViewCondition();
-
-        void CreateCacheRequest();
-
-        void CreateTrueCondition();
-
-        void CreateFalseCondition();
-
-        void CreatePropertyCondition();
-
-        void CreatePropertyConditionEx();
-
-        void CreateAndCondition();
-
-        void CreateAndConditionFromArray();
-
-        void CreateAndConditionFromNativeArray();
-
-        void CreateOrCondition();
-
-        void CreateOrConditionFromArray();
-
-        void CreateOrConditionFromNativeArray();
-
-        void CreateNotCondition();
-
-        void AddAutomationEventHandler();
-
-        void RemoveAutomationEventHandler();
-
-        void AddPropertyChangedEventHandlerNativeArray();
-
-        void AddPropertyChangedEventHandler();
-
-        void RemovePropertyChangedEventHandler();
-
-        void AddStructureChangedEventHandler();
-
-        void RemoveStructureChangedEventHandler();
-
-        void AddFocusChangedEventHandler();
-
-        void RemoveFocusChangedEventHandler();
-
-        void RemoveAllEventHandlers();
-
-        void IntNativeArrayToSafeArray();
-
-        void IntSafeArrayToNativeArray();
-
-        void RectToVariant();
-
-        void VariantToRect();
-
-        void SafeArrayToRectNativeArray();
-
-        void CreateProxyFactoryEntry();
-
-        void get_ProxyFactoryMapping();
-
-        void GetPropertyProgrammaticName();
-
-        void GetPatternProgrammaticName();
-
-        void PollForPotentialSupportedPatterns();
-
-        void PollForPotentialSupportedProperties();
-
-        void CheckNotSupported();
-
-        void get_ReservedNotSupportedValue();
-
-        void get_ReservedMixedAttributeValue();
-
-        void ElementFromIAccessible();
-
-        void ElementFromIAccessibleBuildCache();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomationElement.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomationElement.cs
deleted file mode 100644
index ea14756fd67..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Interop/UiaClient/Interop.IUIAutomationElement.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-internal static partial class UiaClient
-{
-    [ComImport]
-    [Guid("D22108AA-8AC5-49A5-837B-37BBB3D7591E")]
-    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
-    internal interface IUIAutomationElement
-    {
-        int SetFocus();
-
-        void GetRuntimeId();
-
-        void FindFirst();
-
-        void FindAll();
-
-        void FindFirstBuildCache();
-
-        void FindAllBuildCache();
-
-        void BuildUpdatedCache();
-
-        void GetCurrentPropertyValue();
-
-        void GetCurrentPropertyValueEx();
-
-        void GetCachedPropertyValue();
-
-        void GetCachedPropertyValueEx();
-
-        void GetCurrentPatternAs();
-
-        void GetCachedPatternAs();
-
-        void GetCurrentPattern();
-
-        void GetCachedPattern();
-
-        void GetCachedParent();
-
-        void GetCachedChildren();
-
-        void get_CurrentProcessId();
-
-        void get_CurrentControlType();
-
-        void get_CurrentLocalizedControlType();
-
-        HRESULT get_CurrentName(out BSTR retVal);
-
-        void get_CurrentAcceleratorKey();
-
-        void get_CurrentAccessKey();
-
-        void get_CurrentHasKeyboardFocus();
-
-        void get_CurrentIsKeyboardFocusable();
-
-        void get_CurrentIsEnabled();
-
-        void get_CurrentAutomationId();
-
-        void get_CurrentClassName();
-
-        void get_CurrentHelpText();
-
-        void get_CurrentCulture();
-
-        void get_CurrentIsControlElement();
-
-        void get_CurrentIsContentElement();
-
-        void get_CurrentIsPassword();
-
-        void get_CurrentNativeWindowHandle();
-
-        void get_CurrentItemType();
-
-        void get_CurrentIsOffscreen();
-
-        void get_CurrentOrientation();
-
-        void get_CurrentFrameworkId();
-
-        void get_CurrentIsRequiredForForm();
-
-        void get_CurrentItemStatus();
-
-        HRESULT get_CurrentBoundingRectangle(out RECT retVal);
-
-        void get_CurrentLabeledBy();
-
-        void get_CurrentAriaRole();
-
-        void get_CurrentAriaProperties();
-
-        void get_CurrentIsDataValidForForm();
-
-        void get_CurrentControllerFor();
-
-        void get_CurrentDescribedBy();
-
-        void get_CurrentFlowsTo();
-
-        void get_CurrentProviderDescription();
-
-        void get_CachedProcessId();
-
-        void get_CachedControlType();
-
-        void get_CachedLocalizedControlType();
-
-        void get_CachedName();
-
-        void get_CachedAcceleratorKey();
-
-        void get_CachedAccessKey();
-
-        void get_CachedHasKeyboardFocus();
-
-        void get_CachedIsKeyboardFocusable();
-
-        void get_CachedIsEnabled();
-
-        void get_CachedAutomationId();
-
-        void get_CachedClassName();
-
-        void get_CachedHelpText();
-
-        void get_CachedCulture();
-
-        void get_CachedIsControlElement();
-
-        void get_CachedIsContentElement();
-
-        void get_CachedIsPassword();
-
-        void get_CachedNativeWindowHandle();
-
-        void get_CachedItemType();
-
-        void get_CachedIsOffscreen();
-
-        void get_CachedOrientation();
-
-        void get_CachedFrameworkId();
-
-        void get_CachedIsRequiredForForm();
-
-        void get_CachedItemStatus();
-
-        void get_CachedBoundingRectangle();
-
-        void get_CachedLabeledBy();
-
-        void get_CachedAriaRole();
-
-        void get_CachedAriaProperties();
-
-        void get_CachedIsDataValidForForm();
-
-        void get_CachedControllerFor();
-
-        void get_CachedDescribedBy();
-
-        void get_CachedFlowsTo();
-
-        void get_CachedProviderDescription();
-
-        HRESULT GetClickablePoint(out Point clickable, out bool gotClickable);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ListViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ListViewTests.cs
deleted file mode 100644
index 0102a3fcb03..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ListViewTests.cs
+++ /dev/null
@@ -1,583 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.UITests;
-
-// NOTE: This class contains many tests which don't require user input. Although they arguably belong to the unit
-// tests project, these tests assert behaviours of ListView.View=View.Tile, which doesn't work correctly unless
-// we ran an app.
-
-public class ListViewTests : ControlTestBase
-{
-    public ListViewTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, true, true)]
-    [InlineData(false, false, false)]
-    [InlineData(true, true, false)]
-    public async Task ListView_CheckBox_DoubleClick_WorksExpectedAsync(bool virtualModeEnabled, bool checkBoxesEnabled, bool expected)
-    {
-        await RunTestAsync(async (form, listView) =>
-        {
-            InitializeItems(listView, View.Details, virtualModeEnabled, checkBoxesEnabled);
-
-            Point itemCenter = GetCenter(listView.RectangleToScreen(listView.Items[0].Bounds));
-            await MoveMouseAsync(form, itemCenter);
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonDoubleClick());
-
-            Assert.Equal(listView.Items[0].Checked, expected);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Group_NavigateKeyboard_SucceedsAsync()
-    {
-        await RunTestAsync(async (form, listView) =>
-        {
-            var group = new ListViewGroup($"Group 1", HorizontalAlignment.Left) { CollapsedState = ListViewGroupCollapsedState.Expanded };
-            var item1 = new ListViewItem("g1-1") { Group = group };
-            var item2 = new ListViewItem("g1-2") { Group = group };
-            var item3 = new ListViewItem("g1-3") { Group = group };
-
-            listView.Groups.Add(group);
-            listView.Items.AddRange(new[] { item1, item2, item3 });
-            listView.Focus();
-
-            bool collapsedStateChangedFired = false;
-            listView.GroupCollapsedStateChanged += (sender, e) => collapsedStateChangedFired = true;
-
-            item1.Selected = true;
-
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RIGHT));
-            Assert.False(item1.Selected);
-            Assert.True(item2.Selected);
-            Assert.False(item3.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RIGHT));
-            Assert.False(item1.Selected);
-            Assert.False(item2.Selected);
-            Assert.True(item3.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_RIGHT));
-            Assert.False(item1.Selected);
-            Assert.False(item2.Selected);
-            Assert.True(item3.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_LEFT).KeyPress(VIRTUAL_KEY.VK_LEFT));
-            Assert.True(item1.Selected);
-            Assert.False(item2.Selected);
-            Assert.False(item3.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_LEFT));
-            Assert.True(item1.Selected);
-            Assert.False(item2.Selected);
-            Assert.False(item3.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            // Selects header, which selects all items in group
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_UP));
-            Assert.True(item2.Selected);
-            Assert.True(item2.Selected);
-            Assert.True(item2.Selected);
-            Assert.False(collapsedStateChangedFired);
-
-            // Collapse group
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_LEFT).KeyPress(VIRTUAL_KEY.VK_UP).KeyPress(VIRTUAL_KEY.VK_LEFT));
-            Assert.Equal(ListViewGroupCollapsedState.Collapsed, group.CollapsedState);
-            Assert.True(collapsedStateChangedFired);
-
-            // Expand group
-            collapsedStateChangedFired = false;
-            await InputSimulator.SendAsync(form, inputSimulator => inputSimulator.Keyboard.KeyPress(VIRTUAL_KEY.VK_UP).KeyPress(VIRTUAL_KEY.VK_RIGHT));
-            Assert.True(collapsedStateChangedFired);
-            Assert.Equal(ListViewGroupCollapsedState.Expanded, group.CollapsedState);
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 2, 150, 150, 0, 1, (int)NavigateDirection.FirstChild)]
-    [InlineData(4, 3, 150, 150, 0, 3, (int)NavigateDirection.LastChild)]
-    [InlineData(4, 1, 150, 150, 0, 1, (int)NavigateDirection.LastChild)]
-    [InlineData(2, 5, 150, 150, 0, 1, (int)NavigateDirection.LastChild)]
-    [InlineData(10, 10, 100, 100, 0, 5, (int)NavigateDirection.LastChild)]
-    public async Task ListView_Tile_FragmentNavigate_WorksExpectedAsync(int columnCount, int subItemsCount, int width, int height, int itemIndex, int subItemIndex, int direction)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(width, height));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-            IRawElementProviderFragment? actualAccessibleObject = accessibleObject.FragmentNavigate((NavigateDirection)direction);
-            AccessibleObject? expectedAccessibleObject = listView.Items[itemIndex].SubItems[subItemIndex].AccessibilityObject;
-
-            Assert.Equal(expectedAccessibleObject, actualAccessibleObject);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 0, 150, 150, (int)NavigateDirection.FirstChild)]
-    [InlineData(1, 2, 150, 150, (int)NavigateDirection.FirstChild)]
-    [InlineData(2, 1, 10, 10, (int)NavigateDirection.FirstChild)]
-    [InlineData(4, 0, 150, 150, (int)NavigateDirection.LastChild)]
-    [InlineData(1, 2, 150, 150, (int)NavigateDirection.LastChild)]
-    [InlineData(2, 1, 10, 10, (int)NavigateDirection.LastChild)]
-    public async Task ListView_Tile_FragmentNavigate_ReturnsNullAsync(int columnCount, int subItemsCount, int width, int height, int direction)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(width, height));
-
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Null(accessibleObject.FragmentNavigate((NavigateDirection)direction));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(4, 1)]
-    [InlineData(2, 3)]
-    public async Task ListView_Tile_SubItem_FragmentNavigate_Sibling_ReturnsNullAsync(int columnCount, int subItemsCount)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(100, 100));
-
-            AccessibleObject? accessibleObject = listView.Items[0].SubItems[1].AccessibilityObject;
-            IRawElementProviderFragment? nextAccessibleObject = accessibleObject?.FragmentNavigate(NavigateDirection.NextSibling);
-            IRawElementProviderFragment? previousAccessibleObject = accessibleObject?.FragmentNavigate(NavigateDirection.PreviousSibling);
-
-            Assert.Null(nextAccessibleObject);
-            Assert.Null(previousAccessibleObject);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(4, 3, 150, 150, 3)]
-    [InlineData(4, 0, 150, 150, 0)]
-    [InlineData(4, 1, 150, 150, 1)]
-    [InlineData(2, 5, 150, 150, 1)]
-    [InlineData(1, 2, 150, 150, 0)]
-    [InlineData(2, 1, 10, 10, 0)]
-    [InlineData(10, 10, 100, 100, 5)]
-    public async Task ListView_Tile_GetChildCount_ReturnsExpectedAsync(int columnCount, int subItemsCount, int width, int height, int expected)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(width, height));
-
-            Application.DoEvents();
-
-            Assert.Equal(expected, listView.Items[0].AccessibilityObject.GetChildCount());
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(4, 1)]
-    [InlineData(2, 5)]
-    public async Task ListView_Tile_GetChildAsync(int columnCount, int subItemsCount)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(150, 150));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Null(accessibleObject.GetChild(-1));
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, accessibleObject.GetChild(0));
-            Assert.Null(accessibleObject.GetChild(1));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(4, 0, 150, 150)]
-    [InlineData(1, 2, 150, 150)]
-    [InlineData(2, 1, 10, 10)]
-    public async Task ListView_Tile_GetChild_ReturnsNullAsync(int columnCount, int subItemsCount, int width, int height)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(width, height));
-
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Null(accessibleObject.GetChild(-1));
-            Assert.Null(accessibleObject.GetChild(0));
-            Assert.Null(accessibleObject.GetChild(1));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(4, 1, 150, 150, -1, 1)]
-    [InlineData(2, 1, 10, 10, -1, -1)]
-    public async Task ListView_Tile_GetChildIndex_ForDifferentSize_ReturnsExpectedAsync(int columnCount, int subItemsCount, int width, int height, int expected1, int expected2)
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount, subItemsCount, tileSize: new Size(width, height));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Equal(expected1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(expected2, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_SubItem_FragmentNavigate_NextSibling_ReturnsExpectedAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 4, subItemsCount: 4, tileSize: new Size(100, 100));
-
-            Application.DoEvents();
-            AccessibleObject? accessibleObject1 = listView.Items[0].SubItems[1].AccessibilityObject;
-            AccessibleObject? accessibleObject2 = (AccessibleObject?)accessibleObject1?.FragmentNavigate(NavigateDirection.NextSibling);
-            AccessibleObject? accessibleObject3 = (AccessibleObject?)accessibleObject2?.FragmentNavigate(NavigateDirection.NextSibling);
-            AccessibleObject? accessibleObject4 = (AccessibleObject?)accessibleObject3?.FragmentNavigate(NavigateDirection.NextSibling);
-
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, accessibleObject2);
-            Assert.Equal(listView.Items[0].SubItems[3].AccessibilityObject, accessibleObject3);
-            Assert.Null(accessibleObject4);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_SubItem_HitTest_ReturnExpectedAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 3, subItemsCount: 2, tileSize: new Size(100, 100));
-
-            Application.DoEvents();
-
-            AccessibleObject? expectedAccessibleItem1 = listView.Items[0].SubItems[1].AccessibilityObject;
-            AccessibleObject? expectedAccessibleItem2 = listView.Items[0].SubItems[2].AccessibilityObject;
-            AccessibleObject actualAccessibleItem1 = HitTest(GetSubItemLocation(0, 1));
-            AccessibleObject actualAccessibleItem2 = HitTest(GetSubItemLocation(0, 2));
-
-            Assert.Equal(expectedAccessibleItem1, actualAccessibleItem1);
-            Assert.Equal(expectedAccessibleItem2, actualAccessibleItem2);
-
-            AccessibleObject HitTest(Point point) =>
-                listView.AccessibilityObject.HitTest(point.X, point.Y)!;
-            Point GetSubItemLocation(int itemIndex, int subItemIndex) =>
-                listView.PointToScreen(listView.GetSubItemRect(itemIndex, subItemIndex, ItemBoundsPortion.Label).Location);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_SubItem_FragmentNavigate_Sibling_ReturnsNull_For_SmallSizeAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 5, subItemsCount: 5, tileSize: new Size(50, 40));
-
-            AccessibleObject? accessibleObject = listView.Items[0].SubItems[1].AccessibilityObject;
-            IRawElementProviderFragment? nextAccessibleObject = accessibleObject?.FragmentNavigate(NavigateDirection.NextSibling);
-            IRawElementProviderFragment? previousAccessibleObject = accessibleObject?.FragmentNavigate(NavigateDirection.PreviousSibling);
-
-            Assert.Null(nextAccessibleObject);
-            Assert.Null(previousAccessibleObject);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_SubItem_FragmentNavigate_Child_ReturnsNullAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 5, subItemsCount: 5, tileSize: new Size(50, 40));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = (AccessibleObject)listView.Items[0].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild)!;
-
-            Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChild_ReturnsExpectedAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 4, subItemsCount: 3, tileSize: new Size(150, 150));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Null(accessibleObject.GetChild(-1));
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, accessibleObject.GetChild(0));
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, accessibleObject.GetChild(1));
-            Assert.Equal(listView.Items[0].SubItems[3].AccessibilityObject, accessibleObject.GetChild(2));
-            Assert.Null(accessibleObject.GetChild(3));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChild_ReturnsExpected_For_BigSizeAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 10, subItemsCount: 10, tileSize: new Size(100, 100));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Null(accessibleObject.GetChild(-1));
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, accessibleObject.GetChild(0));
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, accessibleObject.GetChild(1));
-            Assert.Equal(listView.Items[0].SubItems[3].AccessibilityObject, accessibleObject.GetChild(2));
-            Assert.Equal(listView.Items[0].SubItems[4].AccessibilityObject, accessibleObject.GetChild(3));
-            Assert.Equal(listView.Items[0].SubItems[5].AccessibilityObject, accessibleObject.GetChild(4));
-            Assert.Null(accessibleObject.GetChild(5));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChildIndex_ReturnsExpectedAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 4, subItemsCount: 3, tileSize: new Size(150, 150));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(2, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-            Assert.Equal(3, accessibleObject.GetChildIndex(listView.Items[0].SubItems[3].AccessibilityObject));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChildIndex_ReturnsExpected_SubItemsMoreThanColumnsAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 2, subItemsCount: 5, tileSize: new Size(150, 150));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[3].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[4].AccessibilityObject));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChildIndex_ReturnsMinusOne_For_Single_ColumnAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 1, subItemsCount: 2, tileSize: new Size(150, 150));
-
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_GetChildIndex_ReturnsExpected_For_BigSizeAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 10, subItemsCount: 10, tileSize: new Size(100, 100));
-
-            Application.DoEvents();
-            AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(2, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-            Assert.Equal(3, accessibleObject.GetChildIndex(listView.Items[0].SubItems[3].AccessibilityObject));
-            Assert.Equal(4, accessibleObject.GetChildIndex(listView.Items[0].SubItems[4].AccessibilityObject));
-            Assert.Equal(5, accessibleObject.GetChildIndex(listView.Items[0].SubItems[5].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[6].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[7].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[8].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[9].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[10].AccessibilityObject));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Tile_ColumnProperty_ReturnsMinusOneAsync()
-    {
-        await RunTestAsync((form, listView) =>
-        {
-            InitializeTileList(listView, columnCount: 4, subItemsCount: 3, tileSize: new Size(150, 150));
-
-            Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject?.Column, -1);
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject?.Column, -1);
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject?.Column, -1);
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject?.Column, -1);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task ListView_Click_On_Second_Column_Does_Not_Alter_CheckBoxesAsync()
-    {
-        await RunTestAsync(async (form, listView) =>
-        {
-            InitializeItems(listView, View.Details, virtualModeEnabled: false, checkBoxesEnabled: true);
-
-            foreach (ListViewItem item in listView.Items)
-            {
-                Assert.Equal(0, item.StateImageIndex);
-                Assert.False(item.Selected);
-            }
-
-            Point listViewCenter = GetCenter(listView.RectangleToScreen(listView.Items[0].SubItems[1].Bounds));
-            await MoveMouseAsync(form, listViewCenter);
-            await InputSimulator.SendAsync(
-               form,
-               inputSimulator => inputSimulator.Keyboard.KeyDown(VIRTUAL_KEY.VK_SHIFT)
-                                                .Mouse.LeftButtonClick());
-            listViewCenter = GetCenter(listView.RectangleToScreen(listView.Items[2].SubItems[1].Bounds));
-            await MoveMouseAsync(form, listViewCenter);
-            await InputSimulator.SendAsync(
-               form,
-               inputSimulator => inputSimulator.Mouse.LeftButtonClick()
-                                               .Keyboard.KeyUp(VIRTUAL_KEY.VK_SHIFT));
-
-            foreach (ListViewItem item in listView.Items)
-            {
-                Assert.Equal(0, item.StateImageIndex);
-                Assert.True(item.Selected);
-            }
-        });
-    }
-
-    private void InitializeItems(ListView listView, View view, bool virtualModeEnabled, bool checkBoxesEnabled)
-    {
-        var columnHeader1 = new ColumnHeader { Text = "ColumnHeader1", Width = 140 };
-        var columnHeader2 = new ColumnHeader { Text = "ColumnHeader2", Width = 140 };
-        var columnHeader3 = new ColumnHeader { Text = "ColumnHeader3", Width = 140 };
-        listView.Columns.AddRange(new[] { columnHeader1, columnHeader2, columnHeader3 });
-        var listViewItem1 = new ListViewItem(new[] { "row1", "row1Col2", "row1Col3" }, -1) { StateImageIndex = 0 };
-        var listViewItem2 = new ListViewItem(new[] { "row2", "row2Col2", "row2Col3" }, -1) { StateImageIndex = 0 };
-        var listViewItem3 = new ListViewItem(new[] { "row3", "row3Col2", "row3Col3" }, -1) { StateImageIndex = 0 };
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listViewItem1,
-                1 => listViewItem2,
-                2 => listViewItem3,
-                _ => listViewItem1,
-            };
-        };
-
-        listView.CheckBoxes = checkBoxesEnabled;
-        listView.FullRowSelect = true;
-        listView.View = view;
-        listView.VirtualMode = virtualModeEnabled;
-        listView.VirtualListSize = 3;
-        if (!virtualModeEnabled)
-        {
-            listView.Items.AddRange(new[] { listViewItem1, listViewItem2, listViewItem3 });
-        }
-    }
-
-    private void InitializeTileList(ListView listView, int columnCount, int subItemsCount, Size tileSize)
-    {
-        listView.View = View.Tile;
-        listView.TileSize = tileSize;
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            listView.Columns.Add(new ColumnHeader() { Text = $"ColumnHeader{i}" });
-        }
-
-        ListViewItem listViewItem = new ListViewItem("Test");
-        for (int i = 0; i < subItemsCount; i++)
-        {
-            listViewItem.SubItems.Add(new ListViewItem.ListViewSubItem() { Text = $"Test SubItem{i}" });
-        }
-
-        listView.Items.Add(listViewItem);
-    }
-
-    private async Task RunTestAsync(Func<Form, ListView, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                ListView control = new()
-                {
-                    Dock = DockStyle.Fill
-                };
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new Size(500, 400)
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MDITests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MDITests.cs
deleted file mode 100644
index 5de4742c6d8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MDITests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class MDITests : ControlTestBase
-{
-    public MDITests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task MDIForm_ResizeWhenMdiChildrenMinimizedAnchorBottom_DefaultAsync()
-    {
-        await RunTestAsync(form =>
-        {
-            using Form childForm = new()
-            {
-                MdiParent = form,
-                WindowState = FormWindowState.Minimized
-            };
-
-            childForm.Show();
-
-            int childFormMinimizedYPositionFromBottom = form.ClientSize.Height - childForm.Top;
-            form.Height += 100;
-
-            Assert.Equal(childFormMinimizedYPositionFromBottom, form.ClientSize.Height - childForm.Top);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task MDIForm_ResizeWhenMdiChildrenMinimizedAnchorBottom_FalseAsync()
-    {
-        await RunTestAsync(form =>
-        {
-            using Form childForm = new()
-            {
-                MdiParent = form,
-                WindowState = FormWindowState.Minimized
-            };
-            form.MdiChildrenMinimizedAnchorBottom = false;
-
-            childForm.Show();
-
-            int childFormMinimizedTop = childForm.Top;
-            form.Height += 100;
-
-            Assert.Equal(childFormMinimizedTop, childForm.Top);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    private async Task RunTestAsync(Func<Form, Task> runTest)
-    {
-        await RunFormWithoutControlAsync(
-            testDriverAsync: runTest,
-            createForm: () =>
-            {
-                return new()
-                {
-                    IsMdiContainer = true,
-                    ClientSize = new Size(640, 480),
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarAccessibleObjectTests.cs
deleted file mode 100644
index ff7c4efbf66..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Xunit.Abstractions;
-using static System.Windows.Forms.MonthCalendar;
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.UITests;
-
-public class MonthCalendarAccessibleObjectTests : ControlTestBase
-{
-    public MonthCalendarAccessibleObjectTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task MonthCalendar_GetFromPoint_ReturnsCorrectValueAsync()
-    {
-        await RunTestAsync((form, calendar) =>
-        {
-            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)calendar.AccessibilityObject;
-            CalendarAccessibleObject calendarAccessibleObject = new(accessibleObject, 0, "Test name");
-
-            MCHITTESTINFO info = new()
-            {
-                uHit = MCHITTESTINFO_HIT_FLAGS.MCHT_CALENDARDAY,
-                iRow = 0
-            };
-            MonthCalendarChildAccessibleObject cell = calendarAccessibleObject.GetChildFromPoint(info);
-
-            Assert.NotNull(cell);
-
-            return Task.CompletedTask;
-        });
-    }
-
-    private async Task RunTestAsync(Func<Form, MonthCalendar, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                MonthCalendar control = new()
-                {
-                    Location = new Point(0, 0)
-                };
-
-                return control;
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarTests.cs
deleted file mode 100644
index fbfaa3ef6fb..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/MonthCalendarTests.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Windows.Win32.UI.Input.KeyboardAndMouse;
-using Xunit.Abstractions;
-using static System.Windows.Forms.MonthCalendar;
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.UITests;
-
-public class MonthCalendarTests : ControlTestBase
-{
-    private static readonly DateTime CurrentDate = new(2021, 12, 1);
-    private static readonly DateTime MaxDate = new(2021, 12, 3, 18, 0, 0);
-    private static readonly DateTime MinDate = new(2021, 11, 30, 17, 0, 0);
-
-    public MonthCalendarTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task MonthCalendar_SetDate_DoesntCrashApplication_IfUseMouseAsync()
-    {
-        await RunTestAsync(async (form, calendar) =>
-        {
-            await MoveMouseToControlAsync(calendar);
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-        });
-    }
-
-    [WinFormsFact]
-    public async Task MonthCalendar_SetDate_DoesntCrashApplication_IfUseKeyboardAsync()
-    {
-        await RunTestAsync(async (form, calendar) =>
-        {
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard
-                                                .KeyPress(VIRTUAL_KEY.VK_RIGHT)
-                                                .KeyPress(VIRTUAL_KEY.VK_RIGHT));
-        });
-    }
-
-    [WinFormsFact]
-    public async Task MonthCalendar_SetDate_DoesntCrashApplication_ProgrammaticallyAsync()
-    {
-        await RunTestAsync(async (form, calendar) =>
-        {
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Keyboard
-                                                .KeyPress(VIRTUAL_KEY.VK_RIGHT)
-                                                .KeyPress(VIRTUAL_KEY.VK_RIGHT));
-
-            DateTime selectedDate = new DateTime(2020, 4, 10);
-            SYSTEMTIME date = new()
-            {
-                wYear = (ushort)selectedDate.Year,
-                wMonth = (ushort)selectedDate.Month,
-                wDay = (ushort)selectedDate.Day
-            };
-
-            NMSELCHANGE lParam = new()
-            {
-                nmhdr = new NMHDR
-                {
-                    code = unchecked((uint)MCN.SELCHANGE),
-                },
-                stSelStart = date,
-                stSelEnd = date,
-            };
-
-            PInvoke.SendMessage(calendar, MessageId.WM_REFLECT_NOTIFY, 0, ref lParam);
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)] // Min date
-    [InlineData(1)]
-    [InlineData(2)] // Max date
-    public async Task MonthCalendar_Click_Date_InvokeEventsAsync(int delta)
-    {
-        await RunClickTestAsync(async (form, calendar) =>
-        {
-            calendar.SetDate(CurrentDate);
-            DateTime newDate = CurrentDate.Date.AddDays(delta);
-            int callDateSelectedCount = 0;
-            int callDateChangedCount = 0;
-            calendar.DateSelected += (object? sender, DateRangeEventArgs e) => callDateSelectedCount++;
-            calendar.DateChanged += (object? sender, DateRangeEventArgs e) => callDateChangedCount++;
-            await ClickOnDateAsync(form, calendar, newDate);
-
-            Assert.Equal(newDate.Date, calendar.SelectionStart.Date);
-            Assert.NotEqual(0, callDateSelectedCount);
-            Assert.NotEqual(0, callDateChangedCount);
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)] // Min date
-    [InlineData(1)]
-    [InlineData(2)] // Max date
-    public async Task MonthCalendar_DoubleClick_Date_InvokeEventsAsync(int delta)
-    {
-        await RunClickTestAsync(async (form, calendar) =>
-        {
-            calendar.SetDate(CurrentDate);
-            DateTime newDate = CurrentDate.Date.AddDays(delta);
-            int callDateSelectedCount = 0;
-            int callDateChangedCount = 0;
-            calendar.DateSelected += (object? sender, DateRangeEventArgs e) => callDateSelectedCount++;
-            calendar.DateChanged += (object? sender, DateRangeEventArgs e) => callDateChangedCount++;
-            await ClickOnDateTwiceAsync(form, calendar, newDate);
-
-            Assert.Equal(newDate.Date, calendar.SelectionStart.Date);
-            Assert.NotEqual(0, callDateSelectedCount);
-            Assert.NotEqual(0, callDateChangedCount);
-        });
-    }
-
-    [WinFormsTheory]
-    [InlineData(2018, 12, 8, (int)MCGRIDINFO_PART.MCGIP_NEXT, 2019, 1, 1)]
-    [InlineData(2018, 12, 8, (int)MCGRIDINFO_PART.MCGIP_PREV, 2018, 11, 1)]
-    public async Task MonthCalendar_Click_ToMonthAsync(int givenYear, int givenMonth, int givenDay, int action, int expectedYear, int expectedMonth, int expectedDay)
-    {
-        await RunTestAsync(async (form, calendar) =>
-        {
-            DateTime givenDate = new(givenYear, givenMonth, givenDay);
-            DateTime expectedDate = new(expectedYear, expectedMonth, expectedDay);
-
-            calendar.TodayDate = givenDate;
-            calendar.SetDate(givenDate);
-
-            Assert.Equal(new DateTime(givenYear, givenMonth, 1), calendar.GetDisplayRange(visible: true).Start);
-
-            // Find the position of the 'Next' button
-            var rect = GetCalendarGridRect(calendar, (MCGRIDINFO_PART)action);
-
-            // Move the mouse to the center of the 'Next' or 'Prev' buttons
-            var centerOfRect = GetCenter(rect);
-            var centerOnScreen = calendar.PointToScreen(centerOfRect);
-            await MoveMouseAsync(form, centerOnScreen);
-
-            TaskCompletionSource<VoidResult> dateChanged = new TaskCompletionSource<VoidResult>(TaskCreationOptions.RunContinuationsAsynchronously);
-            calendar.DateChanged += (sender, e) => dateChanged.TrySetResult(default);
-
-            await InputSimulator.SendAsync(
-                form,
-                inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-
-            await dateChanged.Task;
-
-            // Verify that the next month is selected
-            Assert.Equal(expectedDate, calendar.GetDisplayRange(visible: true).Start);
-        });
-
-        static unsafe Rectangle GetCalendarGridRect(MonthCalendar control, MCGRIDINFO_PART part)
-        {
-            MCGRIDINFO result = new()
-            {
-                cbSize = (uint)sizeof(MCGRIDINFO),
-                dwPart = part,
-                dwFlags = MCGRIDINFO_FLAGS.MCGIF_RECT,
-            };
-
-            Assert.NotEqual(default, PInvoke.SendMessage(control, PInvoke.MCM_GETCALENDARGRIDINFO, default, ref result));
-            return result.rc;
-        }
-    }
-
-    private Point GetCellPositionByDate(MonthCalendar calendar, DateTime dateTime)
-    {
-        MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)calendar.AccessibilityObject;
-        CalendarCellAccessibleObject cell = accessibleObject.TestAccessor().Dynamic.GetCellByDate(dateTime.Date);
-        return cell.Bounds.Location + (cell.Bounds.Size / 2);
-    }
-
-    private async Task ClickOnDateAsync(Form form, MonthCalendar calendar, DateTime date)
-    {
-        await MoveMouseAsync(form, GetCellPositionByDate(calendar, date));
-        await InputSimulator.SendAsync(
-            form,
-            inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-    }
-
-    private async Task ClickOnDateTwiceAsync(Form form, MonthCalendar calendar, DateTime date)
-    {
-        await MoveMouseAsync(form, GetCellPositionByDate(calendar, date));
-        await InputSimulator.SendAsync(
-            form,
-            inputSimulator => inputSimulator.Mouse
-                                            .LeftButtonClick()
-                                            .Sleep(TimeSpan.FromMilliseconds(500))
-                                            .LeftButtonClick());
-    }
-
-    private async Task RunClickTestAsync(Func<Form, MonthCalendar, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                MonthCalendar control = new()
-                {
-                    Location = new Point(0, 0),
-                    MinDate = MinDate,
-                    MaxDate = MaxDate
-                };
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new(500, 300),
-                };
-            });
-    }
-
-    private async Task RunTestAsync(Func<Form, MonthCalendar, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                MonthCalendar control = new()
-                {
-                    Location = new Point(0, 0),
-                };
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new(500, 300),
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/NumericUpDownTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/NumericUpDownTests.cs
deleted file mode 100644
index 13ef2c17678..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/NumericUpDownTests.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class NumericUpDownTests : ControlTestBase
-{
-    public NumericUpDownTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task NumericUpDownAccessibleObject_Focused_ReturnsCorrectValueAsync()
-    {
-        await RunSingleControlTestAsync<NumericUpDown>(async (form, control) =>
-        {
-            var accessibleObject = control.AccessibilityObject;
-            await MoveMouseToControlAsync(control);
-            form.Activate();
-            control.Focus();
-
-            var focused = accessibleObject.GetFocused();
-            Assert.NotNull(focused);
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/OpenFileDialogTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/OpenFileDialogTests.cs
deleted file mode 100644
index ad6057608e5..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/OpenFileDialogTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class OpenFileDialogTests : ControlTestBase
-{
-    public OpenFileDialogTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    // Regression test for https://github.com/dotnet/winforms/issues/8108
-    [WinFormsFact]
-    public void OpenFileDialogTests_OpenWithNonExistingInitDirectory_Success()
-    {
-        using DialogHostForm dialogOwnerForm = new();
-        using OpenFileDialog dialog = new();
-        dialog.InitialDirectory = Guid.NewGuid().ToString();
-        Assert.Equal(DialogResult.Cancel, dialog.ShowDialog(dialogOwnerForm));
-    }
-
-    [WinFormsFact]
-    public void OpenFileDialogTests_OpenWithExistingInitDirectory_Success()
-    {
-        using DialogHostForm dialogOwnerForm = new();
-        using OpenFileDialog dialog = new();
-        dialog.InitialDirectory = Path.GetTempPath();
-        Assert.Equal(DialogResult.Cancel, dialog.ShowDialog(dialogOwnerForm));
-    }
-
-    // Regression test for https://github.com/dotnet/winforms/issues/8414
-    [WinFormsFact]
-    public void OpenFileDialogTests_ResultWithMultiselect()
-    {
-        using var tempFile = TempFile.Create(0);
-        using AcceptDialogForm dialogOwnerForm = new();
-        using OpenFileDialog dialog = new();
-        dialog.Multiselect= true;
-        dialog.InitialDirectory = Path.GetDirectoryName(tempFile.Path);
-        dialog.FileName = tempFile.Path;
-        Assert.Equal(DialogResult.OK, dialog.ShowDialog(dialogOwnerForm));
-        Assert.Equal(tempFile.Path, dialog.FileName);
-    }
-
-    private class AcceptDialogForm : DialogHostForm
-    {
-        protected override void OnDialogIdle(HWND dialogHandle)
-        {
-            Accept(dialogHandle);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs
deleted file mode 100644
index 53e64615c79..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal.TestUtilities;
-using System.Windows.Forms.UITests;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.PropertyGridInternal.UITests;
-
-public class DropDownButtonAccessibleObjectTests : ControlTestBase
-{
-    public DropDownButtonAccessibleObjectTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task DropDownButtonAccessibleObject_FragmentNavigate_Parent_IsSelectedEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            Assert.Equal(grid.SelectedEntry.AccessibilityObject,
-                grid.GridView.DropDownButton.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownButtonAccessibleObject_FragmentNavigate_PreviousSibling_IsTextBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            Assert.Equal(grid.GridView.EditAccessibleObject,
-                grid.GridView.DropDownButton.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownButtonAccessibleObject_FragmentNavigate_NextSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            Assert.Null(grid.GridView.DropDownButton.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownButtonAccessibleObject_FragmentNavigate_NextSibling_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Font)];
-
-            grid.SelectedEntry.Expanded = true;
-
-            Assert.Equal(grid.SelectedEntry.Children.First().AccessibilityObject,
-                grid.GridView.DialogButton.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs
deleted file mode 100644
index b149267076d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs
+++ /dev/null
@@ -1,275 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal.TestUtilities;
-using System.Windows.Forms.UITests;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.PropertyGridInternal.UITests;
-
-public class PropertyDescriptorGridEntryAccessibleObjectTests : ControlTestBase
-{
-    public PropertyDescriptorGridEntryAccessibleObjectTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_Parent_IsParentEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Equal(entry.AccessibilityObject,
-                entry.Children.First().AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_PreviousSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Null(entry.Children.First().AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_PreviousSibling_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Equal(entry.Children.First().AccessibilityObject,
-                entry.Children[1].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_PreviousSibling_IsTextBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-            grid.SelectedEntry.Expanded = true;
-
-            Assert.Equal(grid.GridView.EditAccessibleObject,
-                grid.SelectedEntry.Children.First().AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_PreviousSibling_IsDialogButtonAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Font)];
-            grid.SelectedEntry.Expanded = true;
-
-            Assert.Equal(grid.GridView.DialogButton.AccessibilityObject,
-                grid.SelectedEntry.Children.First().AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_NextSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Null(entry.Children.Last().AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_NextSibling_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Equal(entry.Children[1].AccessibilityObject,
-                entry.Children.First().AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_FirstChild_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            Assert.Null(grid[nameof(Button.Font)].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_FirstChild_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Equal(entry.Children.First().AccessibilityObject,
-                entry.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_FirstChild_IsNullAfterExpandCollapsedAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-
-            entry.Expanded = true;
-            entry.Expanded = false;
-
-            Assert.Null(entry.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_FirstChild_IsTextBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            Assert.Equal(grid.GridView.EditAccessibleObject,
-                grid.SelectedEntry.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_FirstChild_IsDropDownHolderAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-                Assert.Equal(grid.GridView.DropDownControlHolder.AccessibilityObject,
-                    grid.SelectedEntry.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild)));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            Assert.Null(grid[nameof(Button.Font)].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-            entry.Expanded = true;
-
-            Assert.Equal(entry.Children.Last().AccessibilityObject,
-                entry.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsNullAfterExpandCollapsedAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            GridEntry entry = grid[nameof(Button.Font)];
-
-            entry.Expanded = true;
-            entry.Expanded = false;
-
-            Assert.Null(entry.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsTextBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-
-            Assert.Equal(grid.GridView.EditAccessibleObject,
-                grid.SelectedEntry.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsDropDownButtonAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            Assert.Equal(grid.GridView.DropDownButton.AccessibilityObject,
-                grid.SelectedEntry.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task PropertyDescriptorGridEntryAccessibleObject_FragmentNavigate_LastChild_IsDialogButtonAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Font)];
-
-            Assert.Equal(grid.GridView.DialogButton.AccessibilityObject,
-                grid.SelectedEntry.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs
deleted file mode 100644
index d60a62fe589..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal.TestUtilities;
-using System.Windows.Forms.UITests;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.PropertyGridInternal.UITests;
-
-public class PropertyGridView_DropDownHolder_DropDownHolderAccessibleObjectTests : ControlTestBase
-{
-    public PropertyGridView_DropDownHolder_DropDownHolderAccessibleObjectTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task DropDownHolderAccessibleObject_FragmentNavigate_Parent_IsSelectedEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-                Assert.Equal(grid.SelectedEntry.AccessibilityObject,
-                    grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent)));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownHolderAccessibleObject_FragmentNavigate_PreviousSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-                Assert.Null(grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling)));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownHolderAccessibleObject_FragmentNavigate_NextSibling_IsTextBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-                Assert.Equal(grid.GridView.EditAccessibleObject,
-                    grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling)));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownHolderAccessibleObject_FragmentNavigate_FirstLastChild_IsListBoxAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-            {
-                Assert.Equal(grid.GridView.DropDownListBoxAccessibleObject,
-                    grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-                Assert.Equal(grid.GridView.DropDownListBoxAccessibleObject,
-                    grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-            });
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task DropDownHolderAccessibleObject_FragmentNavigate_FirstLastChild_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Anchor)];
-
-            grid.PopupEditorAndClose(() =>
-            {
-                Assert.Null(grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-                Assert.Null(grid.GridView.DropDownControlHolder.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-            });
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewListBox.GridViewListBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewListBox.GridViewListBoxAccessibleObjectTests.cs
deleted file mode 100644
index a6c93799add..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewListBox.GridViewListBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal.TestUtilities;
-using System.Windows.Forms.UITests;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.PropertyGridInternal.UITests;
-
-public class PropertyGridView_GridViewListBox_GridViewListBoxAccessibleObjectTests : ControlTestBase
-{
-    public PropertyGridView_GridViewListBox_GridViewListBoxAccessibleObjectTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task GridViewListBoxAccessibleObject_FragmentNavigate_Parent_IsDropDownHolderAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-            {
-                Assert.Equal(grid.GridView.DropDownControlHolder.AccessibilityObject,
-                    grid.GridView.DropDownListBoxAccessibleObject.FragmentNavigate(NavigateDirection.Parent));
-            });
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewListBoxAccessibleObject_FragmentNavigate_PreviousSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-            {
-                Assert.Null(grid.GridView.DropDownListBoxAccessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            });
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewListBoxAccessibleObject_FragmentNavigate_NextSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.AccessibleRole)];
-
-            grid.PopupEditorAndClose(() =>
-            {
-                Assert.Null(grid.GridView.DropDownListBoxAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-            });
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs
deleted file mode 100644
index b0167adf8bf..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal.TestUtilities;
-using System.Windows.Forms.UITests;
-using Xunit.Abstractions;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.PropertyGridInternal.UITests;
-
-public class PropertyGridView_GridViewTextBox_GridViewTextBoxAccessibleObjectTests : ControlTestBase
-{
-    public PropertyGridView_GridViewTextBox_GridViewTextBoxAccessibleObjectTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_Parent_IsSelectedEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-
-            Assert.Equal(grid.SelectedEntry.AccessibilityObject,
-                grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.Parent));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_PreviousSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-
-            Assert.Null(grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_PreviousSibling_IsDropDownHolderAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.FlatStyle)];
-
-            grid.PopupEditorAndClose(onClosingAction: () =>
-                Assert.Equal(grid.GridView.DropDownControlHolder.AccessibilityObject,
-                    grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling)));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_NextSibling_IsNullAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-
-            Assert.Null(grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_NextSibling_IsChildEntryAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Size)];
-            grid.SelectedEntry.Expanded = true;
-
-            Assert.Equal(grid.SelectedEntry.Children.First().AccessibilityObject,
-                grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_NextSibling_IsDropDownButtonAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.FlatStyle)];
-
-            Assert.Equal(grid.GridView.DropDownButton.AccessibilityObject,
-                grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-
-    [WinFormsFact]
-    public async Task GridViewTextBoxAccessibleObject_FragmentNavigate_NextSibling_IsDialogButtonAsync()
-    {
-        await RunSingleControlTestAsync<SubPropertyGrid<Button>>((form, grid) =>
-        {
-            grid.SelectedEntry = grid[nameof(Button.Font)];
-
-            Assert.Equal(grid.GridView.DialogButton.AccessibilityObject,
-                grid.GridView.EditAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridViewTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridViewTests.cs
deleted file mode 100644
index 8bf52022169..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/PropertyGridViewTests.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.PropertyGridInternal;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class PropertyGridViewTests : ControlTestBase
-{
-    public PropertyGridViewTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task PropertyGridViewRowsAccessibleObject_Ctor_DefaultAsync()
-    {
-        await RunControlPairTestAsync<DomainUpDown, PropertyGrid>((form, controls) =>
-        {
-            (DomainUpDown domainUpDown, PropertyGrid propertyGrid) = controls;
-            propertyGrid.Size = new Size(223, 244);
-            form.ClientSize = new Size(508, 367);
-            propertyGrid.SelectedObject = domainUpDown;
-            GridEntryCollection entries = propertyGrid.GetCurrentEntries();
-            PropertyGridView propertyGridView = (PropertyGridView)propertyGrid.Controls[2];
-
-            int borderHeight = 2;
-            int heightSum = 0;
-            int entriesBorders = 0;
-
-            foreach (GridEntry entry in entries)
-            {
-                int entryHeight = propertyGridView.AccessibilityGetGridEntryBounds(entry).Height;
-                heightSum += entryHeight;
-                if (entryHeight > 0)
-                {
-                    entriesBorders++;
-                }
-
-                foreach (GridEntry item in entry.GridItems)
-                {
-                    int itemHeight = propertyGridView.AccessibilityGetGridEntryBounds(item).Height;
-                    heightSum += itemHeight;
-                    if (itemHeight > 0)
-                    {
-                        entriesBorders++;
-                    }
-                }
-            }
-
-            Assert.Equal(heightSum, propertyGridView.AccessibilityObject.Bounds.Height - borderHeight - entriesBorders);
-
-            return Task.CompletedTask;
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwarro.cur b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwarro.cur
deleted file mode 100644
index e464770d3b1..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwarro.cur and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwno.cur b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwno.cur
deleted file mode 100644
index 165283c03fd..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/3dwno.cur and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.bmp b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.bmp
deleted file mode 100644
index 4ac8a0cc28d..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.rtf b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.rtf
deleted file mode 100644
index b4aec65e1ca..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/DragAccept.rtf
+++ /dev/null
@@ -1,242 +0,0 @@
-{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff31507\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi31507\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}
-{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\f313\fbidi \fmodern\fcharset0\fprq1{\*\panose 020b0609020000020004}Cascadia Mono;}
-{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fhimajor\f31502\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0302020204030204}Calibri Light;}{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f897\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\f898\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\f900\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f901\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f902\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\f903\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\f904\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f905\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f1237\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}
-{\f1238\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}{\f1240\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f1241\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f1244\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}
-{\f1245\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}{\f1267\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f1268\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f1270\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}
-{\f1271\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\f1272\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\f1273\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\f1274\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
-{\f1275\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\f4027\fbidi \fmodern\fcharset238\fprq1 Cascadia Mono CE;}{\f4028\fbidi \fmodern\fcharset204\fprq1 Cascadia Mono Cyr;}{\f4030\fbidi \fmodern\fcharset161\fprq1 Cascadia Mono Greek;}
-{\f4031\fbidi \fmodern\fcharset162\fprq1 Cascadia Mono Tur;}{\f4034\fbidi \fmodern\fcharset186\fprq1 Cascadia Mono Baltic;}{\f4035\fbidi \fmodern\fcharset163\fprq1 Cascadia Mono (Vietnamese);}
-{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \fswiss\fcharset238\fprq2 Calibri Light CE;}{\fhimajor\f31529\fbidi \fswiss\fcharset204\fprq2 Calibri Light Cyr;}
-{\fhimajor\f31531\fbidi \fswiss\fcharset161\fprq2 Calibri Light Greek;}{\fhimajor\f31532\fbidi \fswiss\fcharset162\fprq2 Calibri Light Tur;}{\fhimajor\f31533\fbidi \fswiss\fcharset177\fprq2 Calibri Light (Hebrew);}
-{\fhimajor\f31534\fbidi \fswiss\fcharset178\fprq2 Calibri Light (Arabic);}{\fhimajor\f31535\fbidi \fswiss\fcharset186\fprq2 Calibri Light Baltic;}{\fhimajor\f31536\fbidi \fswiss\fcharset163\fprq2 Calibri Light (Vietnamese);}
-{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
-{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}
-{\fhiminor\f31573\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\fhiminor\f31574\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
-{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}
-{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;
-\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;\red0\green0\blue0;\red0\green0\blue0;}{\*\defchp \fs22\loch\af31506\hich\af31506\dbch\af31505 }{\*\defpap 
-\ql \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 
-\af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\*
-\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused 
-Normal Table;}}{\*\rsidtbl \rsid13178\rsid4880890}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\operator Brandon Williams}{\creatim\yr2021\mo12\dy31\min39}
-{\revtim\yr2021\mo12\dy31\min40}{\version2}{\edmins1}{\nofpages1}{\nofwords100}{\nofchars570}{\nofcharsws669}{\vern39}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}
-\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect 
-\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\dghorigin1701
-\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\rsidroot13178 \nouicompat \fet0{\*\wgrffmtfilter 2450}\nofeaturethrottle1\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang
-{\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}
-{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9
-\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 
-\fs22\lang1033\langfe1033\loch\af31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af37\afs28 \ltrch\fcs0 \b\f313\fs28\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 
-DragAcceptFiles function (shellapi.h)}{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Registers whether a window accepts dropped files.
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Syntax}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 void DragAcceptFiles(
-\par \hich\af313\dbch\af31505\loch\f313   HWND hWnd,
-\par \hich\af313\dbch\af31505\loch\f313   BOOL fAccept
-\par \hich\af313\dbch\af31505\loch\f313 );
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Parameters}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\ul\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 hWnd}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par \hich\af313\dbch\af31505\loch\f313 Type: HWND
-\par 
-\par \hich\af313\dbch\af31505\loch\f313 The identifier of th\hich\af313\dbch\af31505\loch\f313 e window that is registering whether it will accept dropped files.
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\ul\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 fAccept}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-
-\par \hich\af313\dbch\af31505\loch\f313 Type: BOOL
-\par 
-\par \hich\af313\dbch\af31505\loch\f313 A value that indicates if the window identified by the hWnd parameter accepts dropped files. This value is TRUE to accept dropped files or FALSE to discontinue acceptin\hich\af313\dbch\af31505\loch\f313 g dropped files.
-
-\par }{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Return value}{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 None
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Remarks}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 An application that calls DragAcceptFiles with the fAccept parameter set to TRUE has identified itsel
-\hich\af313\dbch\af31505\loch\f313 f as able to process the WM_DROPFILES message from File Manager.}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a
-9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad
-5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6
-b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0
-0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6
-a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f
-c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512
-0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462
-a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865
-6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b
-4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b
-4757e8d3f729e245eb2b260a0238fd010000ffff0300504b030414000600080000002100b6f4679893070000c9200000160000007468656d652f7468656d652f
-7468656d65312e786d6cec59cd8b1bc915bf07f23f347d97f5d5ad8fc1f2a24fcfda33b6b164873dd648a5eef2547789aad28cc56208de532e81c026e49085bd
-ed21842cecc22eb9e48f31d8249b3f22afaa5bdd5552c99e191c3061463074977eefd5afde7bf5de53d5ddcf5e26d4bbc05c1096f6fcfa9d9aefe174ce16248d
-7afeb3d9a4d2f13d2151ba4094a5b8e76fb0f03fbbf7eb5fdd454732c609f6403e1547a8e7c752ae8eaa5531876124eeb0154ee1bb25e30992f0caa3ea82a34b
-d09bd06aa3566b55134452df4b51026a1f2f97648ebd9952e9dfdb2a1f53784da5500373caa74a35b6243476715e5708b11143cabd0b447b3eccb3609733fc52
-fa1e4542c2173dbfa6fffceabdbb5574940b517940d6909be8bf5c2e17589c37f49c3c3a2b260d823068f50bfd1a40e53e6edc1eb7c6ad429f06a0f91c569a71
-b175b61bc320c71aa0ecd1a17bd41e35eb16ded0dfdce3dc0fd5c7c26b50a63fd8c34f2643b0a285d7a00c1feee1c3417730b2f56b50866fede1dbb5fe28685b
-fa3528a6243ddf43d7c25673b85d6d0159327aec8477c360d26ee4ca4b144443115d6a8a254be5a1584bd00bc6270050408a24493db959e1259a43140f112567
-9c7827248a21f056286502866b8ddaa4d684ffea13e827ed5174849121ad780113b137a4f87862cec94af6fc07a0d537206f7ffef9cdeb1fdfbcfee9cd575fbd
-79fdf77c6eadca923b466964cafdf2dd1ffef3cd6fbd7ffff0ed2f5fff319b7a172f4cfcbbbffdeedd3ffef93ef5b0e2d2146ffff4fdbb1fbf7ffbe7dfffebaf
-5f3bb4f7393a33e1339260e13dc297de5396c0021dfcf119bf9ec42c46c494e8a791402952b338f48f656ca11f6d10450edc00db767cce21d5b880f7d72f2cc2
-d398af2571687c182716f094313a60dc6985876a2ec3ccb3751ab927e76b13f714a10bd7dc43945a5e1eaf579063894be530c616cd2714a5124538c5d253dfb1
-738c1dabfb8210cbaea764ce99604be97d41bc01224e93ccc899154da5d03149c02f1b1741f0b7659bd3e7de8051d7aa47f8c246c2de40d4417e86a965c6fb68
-2d51e252394309350d7e8264ec2239ddf0b9891b0b099e8e3065de78818570c93ce6b05ec3e90f21cdb8dd7e4a37898de4929cbb749e20c64ce4889d0f6394ac
-5cd829496313fbb938871045de13265df05366ef10f50e7e40e941773f27d872f787b3c133c8b026a53240d4376beef0e57dccacf89d6ee8126157aae9f3c44a
-b17d4e9cd131584756689f604cd1255a60ec3dfbdcc160c05696cd4bd20f62c82ac7d815580f901dabea3dc5027a25d5dcece7c91322ac909de2881de073bad9
-493c1b9426881fd2fc08bc6eda7c0ca52e7105c0633a3f37818f08f480102f4ea33c16a0c308ee835a9fc4c82a60ea5db8e375c32dff5d658fc1be7c61d1b8c2
-be04197c6d1948eca6cc7b6d3343d49aa00c9819822ec3956e41c4727f29a28aab165b3be596f6a62ddd00dd91d5f42424fd6007b4d3fb84ffbbde073a8cb77f
-f9c6b10f3e4ebfe3566c25ab6b763a8792c9f14e7f7308b7dbd50c195f904fbfa919a175fa04431dd9cf58b73dcd6d4fe3ffdff73487f6f36d2773a8dfb8ed64
-7ce8306e3b99fc70e5e3743265f3027d8d3af0c80e7af4b14f72f0d46749289dca0dc527421ffc08f83db398c0a092d3279eb838055cc5f0a8ca1c4c60e1228e
-b48cc799fc0d91f134462b381daafb4a492472d591f0564cc0a1911e76ea5678ba4e4ed9223becacd7d5c16656590592e5782d2cc6e1a04a66e856bb3cc02bd4
-6bb6913e68dd1250b2d721614c6693683a48b4b783ca48fa58178ce620a157f65158741d2c3a4afdd6557b2c805ae115f8c1edc1cff49e1f06200242701e07cd
-f942f92973f5d6bbda991fd3d3878c69450034d8db08283ddd555c0f2e4fad2e0bb52b78da2261849b4d425b46377822869fc17974aad1abd0b8aeafbba54b2d
-7aca147a3e08ad9246bbf33e1637f535c8ede6069a9a9982a6de65cf6f35430899395af5fc251c1ac363b282d811ea3717a211dcbccc25cf36fc4d32cb8a0b39
-4222ce0cae934e960d122231f728497abe5a7ee1069aea1ca2b9d51b90103e59725d482b9f1a3970baed64bc5ce2b934dd6e8c284b67af90e1b35ce1fc568bdf
-1cac24d91adc3d8d1797de195df3a708422c6cd795011744c0dd413db3e682c0655891c8caf8db294c79da356fa3740c65e388ae62945714339967709dca0b3a
-faadb081f196af190c6a98242f8467912ab0a651ad6a5a548d8cc3c1aafb6121653923699635d3ca2aaa6abab39835c3b60cecd8f26645de60b53531e434b3c2
-67a97b37e576b7b96ea74f28aa0418bcb09fa3ea5ea12018d4cac92c6a8af17e1a56393b1fb56bc776811fa07695226164fdd656ed8edd8a1ae19c0e066f54f9
-416e376a6168b9ed2bb5a5f5adb979b1cdce5e40f2184197bba6526857c2c92e47d0104d754f92a50dd8222f65be35e0c95b73d2f3bfac85fd60d80887955a27
-1c57826650ab74c27eb3d20fc3667d1cd66ba341e31514161927f530bbb19fc00506dde4f7f67a7cefee3ed9ded1dc99b3a4caf4dd7c5513d777f7f5c6e1bb7b
-8f40d2f9b2d598749bdd41abd26df627956034e854bac3d6a0326a0ddba3c9681876ba9357be77a1c141bf390c5ae34ea5551f0e2b41aba6e877ba9576d068f4
-8376bf330efaaff23606569ea58fdc16605ecdebde7f010000ffff0300504b0304140006000800000021000dd1909fb60000001b010000270000007468656d65
-2f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f78277086f6fd3ba109126dd88d0add40384e4350d36
-3f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89d93b64b060828e6f37ed1567914b284d262452282e
-3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd5001996509affb3fd381a89672f1f165dfe514173d985
-0528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0fbfff0000001c020000130000000000000000000000
-0000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6a7e7c0000000360100000b00000000000000000000
-000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a0000001c0000000000000000000000000019020000
-7468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d0014000600080000002100b6f4679893070000c92000001600000000000000
-000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d00140006000800000021000dd1909fb60000001b01000027000000
-000000000000000000009d0a00007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000980b00000000}
-{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
-617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
-6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
-656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
-{\*\latentstyles\lsdstimax376\lsdlockeddef0\lsdsemihiddendef0\lsdunhideuseddef0\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 5;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 9;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 1;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 2;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 4;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 5;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 7;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 8;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 header;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footer;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index heading;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of figures;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope return;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation reference;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 line number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 page number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote text;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of authorities;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 macro;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 toa heading;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 5;\lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Closing;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Signature;\lsdsemihidden1 \lsdunhideused1 \lsdpriority1 \lsdlocked0 Default Paragraph Font;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Message Header;\lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Salutation;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Date;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Note Heading;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Block Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 FollowedHyperlink;\lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;
-\lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Document Map;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Plain Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 E-mail Signature;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Top of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Bottom of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal (Web);\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Acronym;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Cite;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Code;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Definition;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Keyboard;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Preformatted;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Sample;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Typewriter;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Variable;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Table;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation subject;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 No List;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Contemporary;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Elegant;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Professional;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Subtle 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Subtle 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Balloon Text;\lsdpriority39 \lsdlocked0 Table Grid;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Theme;\lsdsemihidden1 \lsdlocked0 Placeholder Text;
-\lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdpriority60 \lsdlocked0 Light Shading;\lsdpriority61 \lsdlocked0 Light List;\lsdpriority62 \lsdlocked0 Light Grid;\lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdpriority64 \lsdlocked0 Medium Shading 2;
-\lsdpriority65 \lsdlocked0 Medium List 1;\lsdpriority66 \lsdlocked0 Medium List 2;\lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdpriority70 \lsdlocked0 Dark List;
-\lsdpriority71 \lsdlocked0 Colorful Shading;\lsdpriority72 \lsdlocked0 Colorful List;\lsdpriority73 \lsdlocked0 Colorful Grid;\lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdpriority61 \lsdlocked0 Light List Accent 1;
-\lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdsemihidden1 \lsdlocked0 Revision;
-\lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;
-\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdpriority72 \lsdlocked0 Colorful List Accent 1;
-\lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;
-\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;
-\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;
-\lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;
-\lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;
-\lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;\lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdpriority60 \lsdlocked0 Light Shading Accent 4;
-\lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdpriority62 \lsdlocked0 Light Grid Accent 4;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;
-\lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdpriority70 \lsdlocked0 Dark List Accent 4;
-\lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;\lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdpriority61 \lsdlocked0 Light List Accent 5;
-\lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdpriority62 \lsdlocked0 Light Grid Accent 6;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;
-\lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority37 \lsdlocked0 Bibliography;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;\lsdpriority41 \lsdlocked0 Plain Table 1;\lsdpriority42 \lsdlocked0 Plain Table 2;\lsdpriority43 \lsdlocked0 Plain Table 3;\lsdpriority44 \lsdlocked0 Plain Table 4;
-\lsdpriority45 \lsdlocked0 Plain Table 5;\lsdpriority40 \lsdlocked0 Grid Table Light;\lsdpriority46 \lsdlocked0 Grid Table 1 Light;\lsdpriority47 \lsdlocked0 Grid Table 2;\lsdpriority48 \lsdlocked0 Grid Table 3;\lsdpriority49 \lsdlocked0 Grid Table 4;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 1;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 1;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 1;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 1;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 1;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 2;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 2;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 2;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 2;
-\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 3;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 3;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 3;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 3;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 3;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 4;
-\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 4;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 4;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 4;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 4;
-\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 4;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 5;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 5;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 5;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 5;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 5;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 6;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 6;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 6;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 6;
-\lsdpriority46 \lsdlocked0 List Table 1 Light;\lsdpriority47 \lsdlocked0 List Table 2;\lsdpriority48 \lsdlocked0 List Table 3;\lsdpriority49 \lsdlocked0 List Table 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful;\lsdpriority52 \lsdlocked0 List Table 7 Colorful;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 List Table 2 Accent 1;\lsdpriority48 \lsdlocked0 List Table 3 Accent 1;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 1;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 1;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 1;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 List Table 2 Accent 2;\lsdpriority48 \lsdlocked0 List Table 3 Accent 2;\lsdpriority49 \lsdlocked0 List Table 4 Accent 2;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 2;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 3;
-\lsdpriority47 \lsdlocked0 List Table 2 Accent 3;\lsdpriority48 \lsdlocked0 List Table 3 Accent 3;\lsdpriority49 \lsdlocked0 List Table 4 Accent 3;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 3;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 4;\lsdpriority47 \lsdlocked0 List Table 2 Accent 4;
-\lsdpriority48 \lsdlocked0 List Table 3 Accent 4;\lsdpriority49 \lsdlocked0 List Table 4 Accent 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 4;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 4;
-\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 List Table 2 Accent 5;\lsdpriority48 \lsdlocked0 List Table 3 Accent 5;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 5;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 5;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 5;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 List Table 2 Accent 6;\lsdpriority48 \lsdlocked0 List Table 3 Accent 6;\lsdpriority49 \lsdlocked0 List Table 4 Accent 6;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Mention;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hashtag;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Unresolved Mention;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Link;}}{\*\datastore 01050000
-02000000180000004d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000
-d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e500000000000000000000000070e0
-e90722fed701feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
-0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/image.png b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/image.png
deleted file mode 100644
index 2cadf74aaf8..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/image.png and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/move.bmp b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/move.bmp
deleted file mode 100644
index 83fd0c58674..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/Resources/move.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/RichTextBoxTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/RichTextBoxTests.cs
deleted file mode 100644
index e491d29e00a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/RichTextBoxTests.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Xunit.Abstractions;
-using static Interop;
-
-namespace System.Windows.Forms.UITests;
-
-public class RichTextBoxTests : ControlTestBase
-{
-    private const int TomLink = unchecked((int)0x80000020);
-    private const int TomHidden = unchecked((int)0x80000100);
-    public RichTextBoxTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task RichTextBox_Click_On_Friendly_Name_Link_Provides_Hidden_Link_SpanAsync()
-    {
-        await RunTestAsync(async (form, richTextBox) =>
-        {
-            richTextBox.Rtf = @"{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang4105{\fonttbl{\f0\fnil\fcharset0 Calibri;}}
-{\*\generator Riched20 10.0.17134}\viewkind4\uc1 
-{\field{\*\fldinst { HYPERLINK ""http://www.google.com"" }}{\fldrslt {Click link #1}}}
-\pard\sa200\sl276\slmult1\f0\fs22\lang9  for more information.\par
-{\field{\*\fldinst { HYPERLINK ""http://www.google.com"" }}{\fldrslt {Click link #2}}}
-\pard\sa200\sl276\slmult1\f0\fs22\lang9  for more information.\par
-{\field{\*\fldinst { HYPERLINK ""http://www.google.com"" }}{\fldrslt {Click link #3}}}
-\pard\sa200\sl276\slmult1\f0\fs22\lang9  for more information.\par
-}";
-
-            LinkClickedEventArgs? result = null;
-            LinkClickedEventHandler handler = (sender, e) => result = e;
-            richTextBox.LinkClicked += handler;
-            try
-            {
-                Point pt = richTextBox.PointToScreen(richTextBox.GetPositionFromCharIndex(richTextBox.Text.IndexOf("Click link #2")));
-
-                // Adjust point a bit to make sure we are clicking inside the character cell instead of on its edge.
-                pt.X += 2;
-                pt.Y += 2;
-                await MoveMouseAsync(form, pt);
-                await InputSimulator.SendAsync(
-                    form,
-                    inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-            }
-            finally
-            {
-                richTextBox.LinkClicked -= handler;
-            }
-
-            Assert.NotNull(result);
-
-            Assert.True(result!.LinkStart + result.LinkLength <= richTextBox.Text.Length);
-            Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength));
-
-            // This assumes the input span is the hidden text of a "friendly name" URL,
-            // which is what the native control will pass to the LinkClicked event instead
-            // of the actual span of the clicked display text.
-            var displayText = GetTextFromRange(richTextBox, result.LinkStart, result.LinkLength, range =>
-            {
-                // Move the cursor to the end of the hidden area we are currently located in.
-                range.EndOf(TomHidden, 0);
-
-                // Extend the cursor to the end of the display text of the link.
-                range.EndOf(TomLink, 1);
-            });
-
-            Assert.Equal("Click link #2", displayText);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task RichTextBox_Click_On_Custom_Link_Preceeded_By_Hidden_Text_Provides_Displayed_Link_SpanAsync()
-    {
-        await RunTestAsync(async (form, richTextBox) =>
-        {
-            richTextBox.Rtf = @"{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang4105{\fonttbl{\f0\fnil\fcharset0 Calibri;}}
-{\*\generator Riched20 10.0.17134}\viewkind4\uc1\pard\sa200\sl276\slmult1\f0\fs22\lang9
-This is hidden text preceeding a \v #link1#\v0 custom link.\par
-This is hidden text preceeding a \v #link2#\v0 custom link.\par
-This is hidden text preceeding a \v #link3#\v0 custom link.\par
-}";
-
-            MakeLink(richTextBox, "#link1#custom link");
-            MakeLink(richTextBox, "#link2#custom link");
-            MakeLink(richTextBox, "#link3#custom link");
-
-            LinkClickedEventArgs? result = null;
-            LinkClickedEventHandler handler = (sender, e) => result = e;
-            richTextBox.LinkClicked += handler;
-            try
-            {
-                Point pt = richTextBox.PointToScreen(richTextBox.GetPositionFromCharIndex(richTextBox.Text.IndexOf("#link2#custom link")));
-
-                // Adjust point a bit to make sure we are clicking inside the character cell instead of on its edge.
-                pt.X += 2;
-                pt.Y += 2;
-                await MoveMouseAsync(form, pt);
-                await InputSimulator.SendAsync(
-                    form,
-                    inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-            }
-            finally
-            {
-                richTextBox.LinkClicked -= handler;
-            }
-
-            Assert.NotNull(result);
-
-            Assert.True(result!.LinkStart + result.LinkLength <= richTextBox.Text.Length);
-            Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength));
-
-            // This assumes the input span is a custom link preceeded by hidden text.
-            var hiddenText = GetTextFromRange(richTextBox, result.LinkStart, result.LinkLength, range =>
-            {
-                // Move the cursor to the start of the link we are currently located in.
-                range.StartOf(TomLink, 0);
-
-                // Extend the cursor to the start of the hidden area preceeding the link.
-                range.StartOf(TomHidden, 1);
-            });
-
-            Assert.Equal("#link2#", hiddenText);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task RichTextBox_Click_On_Custom_Link_Followed_By_Hidden_Text_Provides_Displayed_Link_SpanAsync()
-    {
-        await RunTestAsync(async (form, richTextBox) =>
-        {
-                    // This needs to be sufficiently different from the previous test so we don't click on the same location twice,
-                    // otherwise the tests may execute fast enough for the second test to register as a double click.
-                    richTextBox.Rtf = @"{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang4105{\fonttbl{\f0\fnil\fcharset0 Calibri;}}
-        {\*\generator Riched20 10.0.17134}\viewkind4\uc1\pard\sa200\sl276\slmult1\f0\fs22\lang9
-        This is a custom link\v #link1#\v0  which is followed by hidden text.\par
-        This is a custom link\v #link2#\v0  which is followed by hidden text.\par
-        This is a custom link\v #link3#\v0  which is followed by hidden text.\par
-        }";
-
-            MakeLink(richTextBox, "custom link#link1#");
-            MakeLink(richTextBox, "custom link#link2#");
-            MakeLink(richTextBox, "custom link#link3#");
-
-            LinkClickedEventArgs? result = null;
-            LinkClickedEventHandler handler = (sender, e) => result = e;
-            richTextBox.LinkClicked += handler;
-            try
-            {
-                Point pt = richTextBox.PointToScreen(richTextBox.GetPositionFromCharIndex(richTextBox.Text.IndexOf("custom link#link2#")));
-
-                // Adjust point a bit to make sure we are clicking inside the character cell instead of on its edge.
-                pt.X += 2;
-                pt.Y += 2;
-                await MoveMouseAsync(form, pt);
-                await InputSimulator.SendAsync(
-                    form,
-                    inputSimulator => inputSimulator.Mouse.LeftButtonClick());
-            }
-            finally
-            {
-                richTextBox.LinkClicked -= handler;
-            }
-
-            Assert.NotNull(result);
-
-            Assert.True(result!.LinkStart + result.LinkLength <= richTextBox.Text.Length);
-            Assert.Equal(result.LinkText, richTextBox.Text.Substring(result.LinkStart, result.LinkLength));
-
-            // This assumes the input span is a custom link followed by hidden text.
-            var hiddenText = GetTextFromRange(richTextBox, result.LinkStart, result.LinkLength, range =>
-            {
-                // Move the cursor to the end of link we are currently located in.
-                range.EndOf(TomLink, 0);
-
-                // Extend the cursor to the end of the hidden area following the link.
-                range.EndOf(TomHidden, 1);
-            });
-
-            Assert.Equal("#link2#", hiddenText);
-        });
-    }
-
-    private unsafe void MakeLink(RichTextBox control, string text)
-    {
-        control.Select(control.Text.IndexOf(text), text.Length);
-
-        var format = new Richedit.CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(Richedit.CHARFORMAT2W),
-            dwMask = Richedit.CFM.LINK,
-            dwEffects = Richedit.CFE.LINK,
-        };
-
-        PInvoke.SendMessage(control, PInvoke.EM_SETCHARFORMAT, (WPARAM)(uint)Richedit.SCF.SELECTION, ref format);
-
-        control.Select(0, 0);
-    }
-
-    private unsafe string? GetTextFromRange(RichTextBox control, int start, int length, Action<Richedit.ITextRange> transform)
-    {
-        IntPtr pOleInterface = IntPtr.Zero;
-        object? oleInterface = null;
-
-        try
-        {
-            if (PInvoke.SendMessage(control, PInvoke.EM_GETOLEINTERFACE, 0, ref pOleInterface) != 0 && pOleInterface != IntPtr.Zero)
-            {
-                // This increments the RCW reference count, further casts do not increment it. It is important
-                // to capture the initial reference to the RCW so we can release it even if casts fail.
-                oleInterface = Marshal.GetObjectForIUnknown(pOleInterface);
-
-                if (oleInterface is Richedit.ITextDocument textDocument)
-                {
-                    // This method returns a COM object, thus increments the RCW reference count and we want to release it later.
-                    var range = textDocument.Range(start, start + length);
-                    if (range is not null)
-                    {
-                        try
-                        {
-                            transform?.Invoke(range);
-                            return range.GetText();
-                        }
-                        finally
-                        {
-                            // release RCW reference count
-                            Marshal.ReleaseComObject(range);
-                        }
-                    }
-                }
-            }
-
-            return null;
-        }
-        finally
-        {
-            // release RCW reference count
-            if (oleInterface is not null)
-            {
-                Marshal.ReleaseComObject(oleInterface);
-            }
-
-            // release COM reference count
-            if (pOleInterface != IntPtr.Zero)
-            {
-                Marshal.Release(pOleInterface);
-            }
-        }
-    }
-
-    private async Task RunTestAsync(Func<Form, RichTextBox, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                RichTextBox control = new()
-                {
-                    Size = new Size(439, 103),
-                    DetectUrls = false,
-                };
-
-                return control;
-            },
-            createForm: () =>
-            {
-                return new()
-                {
-                    Size = new(300, 300),
-                    Location = new Point(100, 100),
-                };
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/System.Windows.Forms.UI.IntegrationTests.csproj b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/System.Windows.Forms.UI.IntegrationTests.csproj
deleted file mode 100644
index 2b954683ac7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/System.Windows.Forms.UI.IntegrationTests.csproj
+++ /dev/null
@@ -1,53 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <IsPackable>false</IsPackable>
-    <Nullable>enable</Nullable>
-    <NoWarn>$(NoWarn);NU1701</NoWarn>
-    <RootNamespace>System.Windows.Forms.UITests</RootNamespace>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.VisualStudio.Threading" Version="$(MicrosoftVisualStudioThreadingVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\Common\tests\TestUtilities\System.Windows.Forms.Common.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\TestUtilities\System.Windows.Forms.TestUtilities.csproj" />
-    <ProjectReference Include="..\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="Resources\3dwarro.cur">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\3dwno.cur">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\Arc.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\DragAccept.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\DragAccept.rtf">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\image.png">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\move.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/TabControlTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/TabControlTests.cs
deleted file mode 100644
index 98b39ef47f9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/TabControlTests.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class TabControlTests : ControlTestBase
-{
-    public TabControlTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-    }
-
-    [WinFormsFact]
-    public async Task TabControl_TabPage_IsHoveredWithMouse_IsTrue_WhenMouseIsOn_FirstTabAsync()
-    {
-        await RunTestAsync(async (form, tabControl) =>
-        {
-            // TODO: find the way to determin the tab's dimensions and use those instead of (10, 10)
-            bool result = await IsHoveredWithMouseAsync(form, tabControl, new(10, 10));
-
-            Assert.True(result);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task TabControl_TabPage_IsHoveredWithMouse_IsTrue_WhenMouseIsOn_SecondTabAsync()
-    {
-        await RunTestAsync(async (form, tabControl) =>
-        {
-            // TODO: find the way to determin the tab's dimensions and use those instead of (60, 10)
-            bool result = await IsHoveredWithMouseAsync(form, tabControl, new(60, 10));
-
-            Assert.True(result);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task TabControl_TabPage_IsHoveredWithMouse_IsFalse_WhenMouseIs_OutsideControlAsync()
-    {
-        await RunTestAsync(async (form, tabControl) =>
-        {
-            // TODO: find the way to determin the tab's dimensions and use those instead of (300, 300)
-            bool result = await IsHoveredWithMouseAsync(form, tabControl, new(300, 300));
-
-            Assert.False(result);
-        });
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/6654")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/6654")]
-    public async Task TabControl_TabPage_IsHoveredWithMouse_IsFalse_WhenMouseIs_OutsideMainScreenAsync()
-    {
-        await RunTestAsync(async (form, tabControl) =>
-        {
-            TestOutputHelper.WriteLine($"Primary screen: {Screen.PrimaryScreen?.WorkingArea}");
-
-            // We can't physically move the mouse outside the desktop area,
-            // so the mouse cursor will be stuck at the bottom right corner of the desktop.
-            bool result = await IsHoveredWithMouseAsync(form, tabControl, new(1000, 1000), assertCorrectLocation: false);
-
-            Assert.False(result);
-        });
-    }
-
-    private async Task<bool> IsHoveredWithMouseAsync(Form form, TabControl tabControl, Point point, bool assertCorrectLocation = true)
-    {
-        await MoveMouseAsync(form, tabControl.PointToScreen(point), assertCorrectLocation);
-
-        bool result = ((IKeyboardToolTip)tabControl).IsHoveredWithMouse();
-        bool resultOfPage1 = ((IKeyboardToolTip)tabControl.TabPages[0]).IsHoveredWithMouse();
-        bool resultOfPage2 = ((IKeyboardToolTip)tabControl.TabPages[1]).IsHoveredWithMouse();
-        return result && resultOfPage1 && resultOfPage2;
-    }
-
-    private async Task RunTestAsync(Func<Form, TabControl, Task> runTest)
-    {
-        await RunSingleControlTestAsync(
-            testDriverAsync: runTest,
-            createControl: () =>
-            {
-                TabControl tabControl = new()
-                {
-                    Location = new Point(0, 0)
-                };
-
-                TabPage tabPage1 = new();
-                TabPage tabPage2 = new();
-                tabControl.TabPages.Add(tabPage1);
-                tabControl.TabPages.Add(tabPage2);
-
-                return tabControl;
-            });
-    }
-
-    [WinFormsFact]
-    public async Task TabControl_ControlsDoNotReorderWhenSelectedIndexChanges()
-    {
-        // Validates the following bug fix: https://github.com/dotnet/winforms/issues/7837
-        await RunSingleControlTestAsync(
-            testDriverAsync: async (form, tabControl) =>
-            {
-                var originalPages = tabControl.TabPages.Cast<TabPage>().ToArray();
-
-                tabControl.SelectedIndex--;
-                await Task.Yield();
-
-                // The changes we made to SelectedIndex will result in a WM_WINDOWPOSCHANGED message which will 
-                // fire TabPage.WmWindowPosChanged, which will call TabControl.UpdateChildControlIndex.
-
-                // This test ensures that the latter method short-circuits and does not call Controls.SetChildIndex
-                // which would inappropriately reorder the Controls collection, resulting in TabPages and Controls
-                // becoming out of sync.
-
-                for (int i = 0; i < originalPages.Length; i++)
-                {
-                    Assert.Equal(tabControl.Controls[i], tabControl.TabPages[i]);
-                }
-
-                // The following test proves that it *matters* that the Controls and TabPages collection remain in sync.
-
-                // Remove the first page by position:
-                tabControl.TabPages.RemoveAt(0);
-
-                // We should be left with pages[1] and pages[2]. This will not be the case if the Controls and TabPages
-                // collections are out of sync.
-                Assert.Equal(originalPages[1], tabControl.TabPages[0]);
-                Assert.Equal(originalPages[2], tabControl.TabPages[1]);
-            },
-            createControl: () =>
-            {
-                SubclassedTabControl tabControl = new()
-                {
-                    Location = new Point(0, 0)
-                };
-
-                TabPage tabPage1 = new() { Text = "Page 1" };
-                TabPage tabPage2 = new() { Text = "Page 2" };
-                TabPage tabPage3 = new() { Text = "Page 3" };
-
-                tabControl.TabPages.Add(tabPage1);
-                tabControl.TabPages.Add(tabPage2);
-                tabControl.TabPages.Add(tabPage3);
-
-                // Start with the Selected Page at the end:
-                tabControl.SelectedIndex = tabControl.TabPages.Count - 1;
-
-                return tabControl;
-            });
-    }
-
-    // Bug https://github.com/dotnet/winforms/issues/7837 occured only when TabControl was subclassed.
-    class SubclassedTabControl : TabControl { }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ToolStripTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ToolStripTests.cs
deleted file mode 100644
index 0313699fb40..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/ToolStripTests.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.UITests;
-
-public class ToolStripTests : ControlTestBase
-{
-    private readonly ImageList _sharedImageList;
-
-    public ToolStripTests(ITestOutputHelper testOutputHelper)
-        : base(testOutputHelper)
-    {
-        _sharedImageList = new ImageList();
-        _sharedImageList.Images.Add("square", Image.FromFile("./Resources/image.png"));
-    }
-
-    // Regression test for https://github.com/dotnet/winforms/issues/6881
-    [WinFormsFact]
-    public void ToolStrip_shared_imagelist_should_not_get_disposed_when_toolstrip_does()
-    {
-        ShowForm(_sharedImageList);
-        ShowForm(_sharedImageList);
-
-        return;
-
-        static void ShowForm(ImageList sharedImageList)
-        {
-            using Form form = new();
-            using ToolStripButton toolStripButton = new()
-            {
-                ImageKey = "square",
-                ToolTipText = "Random Button"
-            };
-            using ToolStrip toolStrip = new()
-            {
-                ImageList = sharedImageList
-            };
-            toolStrip.Items.Add(toolStripButton);
-
-            form.Controls.Add(toolStrip);
-
-            form.Show();
-
-            Assert.NotNull(sharedImageList);
-#if DEBUG
-            Assert.False(sharedImageList.IsDisposed);
-#endif
-            Assert.Single(sharedImageList.Images);
-
-            form.Close();
-
-            Assert.NotNull(sharedImageList);
-#if DEBUG
-            Assert.False(sharedImageList.IsDisposed);
-#endif
-            Assert.Single(sharedImageList.Images);
-        }
-    }
-
-    // Regression test for https://github.com/dotnet/winforms/issues/7884
-    [WinFormsFact]
-    public void ToolStrip_Hiding_ToolStripMenuItem_OnDropDownClosed_ShouldNotThrow()
-    {
-        using Form form = new();
-
-        using ToolStripMenuItem menu1 = new("Menu1");
-        using ToolStripMenuItem menu1Item1 = new("Item1");
-        menu1.DropDownItems.Add(menu1Item1);
-
-        using ToolStripMenuItem hiddenMenu = new("hiddenMenu");
-        using ToolStripMenuItem hiddenMenuItem1 = new("hiddenMenuItem1");
-        hiddenMenu.DropDownItems.Add(hiddenMenuItem1);
-        hiddenMenu.DropDownClosed += (object? sender, EventArgs e) => { hiddenMenu.Visible = false; };
-
-        using MenuStrip menuStrip = new();
-        menuStrip.Items.Add(menu1);
-        menuStrip.Items.Add(hiddenMenu);
-
-        form.Controls.Add(menuStrip);
-        form.MainMenuStrip = menuStrip;
-        form.Show();
-        hiddenMenu.ShowDropDown();
-        menu1.Select();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/runtimeconfig.template.json b/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/UIIntegrationTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/ApplicationEvents.vb b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/ApplicationEvents.vb
deleted file mode 100644
index 994a2c850e5..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/ApplicationEvents.vb
+++ /dev/null
@@ -1,16 +0,0 @@
-Imports Microsoft.VisualBasic.ApplicationServices
-Imports Microsoft.VisualBasic.Devices
-
-Namespace My
-    ' The following events are available for MyApplication:
-    ' Startup: Raised when the application starts, before the startup form is created.
-    ' Shutdown: Raised after all application forms are closed.  This event is not raised if the application terminates abnormally.
-    ' UnhandledException: Raised if the application encounters an unhandled exception.
-    ' StartupNextInstance (!!Not yet implemented!!): Raised when launching a single-instance application and the application is already active. 
-    ' NetworkAvailabilityChanged: Raised when the network connection is connected or disconnected.
-    Partial Friend Class MyApplication
-        Private Sub MyApplication_Startup(sender As Object, e As StartupEventArgs) Handles Me.Startup
-            System.Windows.Forms.Application.SetHighDpiMode(HighDpiMode.SystemAware)
-        End Sub
-    End Class
-End Namespace
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.props b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.props
deleted file mode 100644
index 635deb886fd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.props
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.targets b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.targets
deleted file mode 100644
index 635deb886fd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Directory.Build.targets
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.Designer.vb b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.Designer.vb
deleted file mode 100644
index 08eede81f27..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.Designer.vb
+++ /dev/null
@@ -1,50 +0,0 @@
-<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()>
-Partial Class Form1
-    Inherits System.Windows.Forms.Form
-
-    'Form overrides dispose to clean up the component list.
-    <System.Diagnostics.DebuggerNonUserCode()>
-    Protected Overrides Sub Dispose(ByVal disposing As Boolean)
-        Try
-            If disposing AndAlso components IsNot Nothing Then
-                components.Dispose()
-            End If
-        Finally
-            MyBase.Dispose(disposing)
-        End Try
-    End Sub
-
-    'Required by the Windows Form Designer
-    Private components As System.ComponentModel.IContainer
-
-    'NOTE: The following procedure is required by the Windows Form Designer
-    'It can be modified using the Windows Form Designer.  
-    'Do not modify it using the code editor.
-    <System.Diagnostics.DebuggerStepThrough()>
-    Private Sub InitializeComponent()
-        Me.Button1 = New System.Windows.Forms.Button()
-        Me.SuspendLayout()
-        '
-        'Button1
-        '
-        Me.Button1.Location = New System.Drawing.Point(338, 350)
-        Me.Button1.Name = "Button1"
-        Me.Button1.Size = New System.Drawing.Size(147, 53)
-        Me.Button1.TabIndex = 0
-        Me.Button1.Text = "Button1"
-        Me.Button1.UseVisualStyleBackColor = True
-        '
-        'Form1
-        '
-        Me.AutoScaleDimensions = New System.Drawing.SizeF(10.0!, 25.0!)
-        Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
-        Me.ClientSize = New System.Drawing.Size(800, 450)
-        Me.Controls.Add(Me.Button1)
-        Me.Name = "Form1"
-        Me.Text = "Form1"
-        Me.ResumeLayout(False)
-
-    End Sub
-
-    Friend WithEvents Button1 As Button
-End Class
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.resx b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.vb b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.vb
deleted file mode 100644
index d644dea06cd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/Form1.vb
+++ /dev/null
@@ -1,10 +0,0 @@
-'NOTE:
-'If you copy this project, you need to change the GUID in
-'My Project\AssemblyInfo.VB (see comment there).
-'Show all files in the Solution Explorer to see AssemblyInfo.Vb.
-
-Public Class Form1
-    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
-        MessageBox.Show("Hello VB!", "VB WinForms NET5.0")
-    End Sub
-End Class
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.Designer.vb b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.Designer.vb
deleted file mode 100644
index 46e28810672..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.Designer.vb	
+++ /dev/null
@@ -1,38 +0,0 @@
-'------------------------------------------------------------------------------
-' <auto-generated>
-'     This code was generated by a tool.
-'     Runtime Version:4.0.30319.42000
-'
-'     Changes to this file may cause incorrect behavior and will be lost if
-'     the code is regenerated.
-' </auto-generated>
-'------------------------------------------------------------------------------
-
-Option Strict On
-Option Explicit On
-
-
-Namespace My
-
-    'NOTE: This file is auto-generated; do not modify it directly.  To make changes,
-    ' or if you encounter build errors in this file, go to the Project Designer
-    ' (go to Project Properties or double-click the My Project node in
-    ' Solution Explorer), and make changes on the Application tab.
-    '
-    Partial Friend Class MyApplication
-
-        <Global.System.Diagnostics.DebuggerStepThroughAttribute()>
-        Public Sub New()
-            MyBase.New(Global.Microsoft.VisualBasic.ApplicationServices.AuthenticationMode.Windows)
-            Me.IsSingleInstance = True
-            Me.EnableVisualStyles = True
-            Me.SaveMySettingsOnExit = False
-            Me.ShutDownStyle = Global.Microsoft.VisualBasic.ApplicationServices.ShutdownMode.AfterMainFormCloses
-        End Sub
-        
-        <Global.System.Diagnostics.DebuggerStepThroughAttribute()>  _
-        Protected Overrides Sub OnCreateMainForm()
-            Me.MainForm = Global.VbWinForms.Form1
-        End Sub
-    End Class
-End Namespace
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.myapp b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.myapp
deleted file mode 100644
index 8fdb355107c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/Application.myapp	
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<MyApplicationData xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <MySubMain>true</MySubMain>
-  <MainForm>Form1</MainForm>
-  <SingleInstance>true</SingleInstance>
-  <ShutdownMode>0</ShutdownMode>
-  <EnableVisualStyles>true</EnableVisualStyles>
-  <AuthenticationMode>0</AuthenticationMode>
-  <ApplicationType>0</ApplicationType>
-  <SaveMySettingsOnExit>false</SaveMySettingsOnExit>
-</MyApplicationData>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/AssemblyInfo.vb b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/AssemblyInfo.vb
deleted file mode 100644
index 9f7c1944904..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/My Project/AssemblyInfo.vb	
+++ /dev/null
@@ -1,36 +0,0 @@
-Imports System
-Imports System.Reflection
-Imports System.Runtime.InteropServices
-
-' General Information about an assembly is controlled through the following
-' set of attributes. Change these attribute values to modify the information
-' associated with an assembly.
-
-' Review the values of the assembly attributes
-
-<Assembly: AssemblyTitle("VB WinForms NET5.0")>
-<Assembly: AssemblyDescription("")>
-<Assembly: AssemblyCompany("")>
-<Assembly: AssemblyProduct("VbWinForms")>
-<Assembly: AssemblyCopyright("Copyright ©  2020")>
-<Assembly: AssemblyTrademark("")>
-
-<Assembly: ComVisible(False)>
-
-'The following GUID is for the ID of the typelib if this project is exposed to COM
-' NOTE: PLEASE CHANGE THIS GUID. IT MUST BE UNIQUE FOR EVERY APPLICATION.
-<Assembly: Guid("6a6ec69e-e4b7-4dcb-8a58-3e82006838ce")>
-
-' Version information for an assembly consists of the following four values:
-'
-'      Major Version
-'      Minor Version
-'      Build Number
-'      Revision
-'
-' You can specify all the values or you can default the Build and Revision Numbers
-' by using the '*' as shown below:
-' <Assembly: AssemblyVersion("1.0.*")>
-
-<Assembly: AssemblyVersion("1.0.0.0")>
-<Assembly: AssemblyFileVersion("1.0.0.0")>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/VbWinForms.vbproj b/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/VbWinForms.vbproj
deleted file mode 100644
index 71f10f99043..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/VisualBasicTemplate/VbWinForms.vbproj
+++ /dev/null
@@ -1,38 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net6.0-windows</TargetFramework>
-    <RootNamespace>VbWinForms</RootNamespace>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <UseWindowsForms>true</UseWindowsForms>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <WarningsAsErrors>$(WarningsAsErrors),41999,42016,42017,42018,42019,42020,42021,42022,42032,42036</WarningsAsErrors>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <MyType>WindowsForms</MyType>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Import Include="System.Data" />
-    <Import Include="System.Drawing" />
-    <Import Include="System.Windows.Forms" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Update="My Project\Application.Designer.vb">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Application.myapp</DependentUpon>
-    </Compile>
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="My Project\Application.myapp">
-      <Generator>MyApplicationCodeGenerator</Generator>
-      <LastGenOutput>Application.Designer.vb</LastGenOutput>
-    </None>
-  </ItemGroup>
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.Designer.cs
deleted file mode 100644
index 8d76290fd5e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.Designer.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace WinformsControlsTest;
-
-partial class AnchorLayoutTests
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.button1 = new System.Windows.Forms.Button();
-        this.button2 = new System.Windows.Forms.Button();
-        this.button3 = new System.Windows.Forms.Button();
-        this.button4 = new System.Windows.Forms.Button();
-        this.button5 = new System.Windows.Forms.Button();
-        this.button6 = new System.Windows.Forms.Button();
-        this.button7 = new System.Windows.Forms.Button();
-        this.button8 = new System.Windows.Forms.Button();
-        this.button9 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.Location = new System.Drawing.Point(12, 12);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(112, 34);
-        this.button1.TabIndex = 0;
-        this.button1.Text = "Top-Left";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // button2
-        // 
-        this.button2.Anchor = System.Windows.Forms.AnchorStyles.Top;
-        this.button2.Location = new System.Drawing.Point(338, 12);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(112, 34);
-        this.button2.TabIndex = 1;
-        this.button2.Text = "Top";
-        this.button2.UseVisualStyleBackColor = true;
-        // 
-        // button3
-        // 
-        this.button3.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-        this.button3.Location = new System.Drawing.Point(676, 12);
-        this.button3.Name = "button3";
-        this.button3.Size = new System.Drawing.Size(112, 34);
-        this.button3.TabIndex = 2;
-        this.button3.Text = "Top-Right";
-        this.button3.UseVisualStyleBackColor = true;
-        // 
-        // button4
-        // 
-        this.button4.Anchor = System.Windows.Forms.AnchorStyles.Left;
-        this.button4.Location = new System.Drawing.Point(12, 198);
-        this.button4.Name = "button4";
-        this.button4.Size = new System.Drawing.Size(112, 34);
-        this.button4.TabIndex = 3;
-        this.button4.Text = "Left";
-        this.button4.UseVisualStyleBackColor = true;
-        // 
-        // button5
-        // 
-        this.button5.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.button5.Location = new System.Drawing.Point(12, 404);
-        this.button5.Name = "button5";
-        this.button5.Size = new System.Drawing.Size(112, 34);
-        this.button5.TabIndex = 4;
-        this.button5.Text = "Bottom-Left";
-        this.button5.UseVisualStyleBackColor = true;
-        // 
-        // button6
-        // 
-        this.button6.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-        | System.Windows.Forms.AnchorStyles.Left) 
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.button6.Location = new System.Drawing.Point(338, 198);
-        this.button6.Name = "button6";
-        this.button6.Size = new System.Drawing.Size(112, 34);
-        this.button6.TabIndex = 5;
-        this.button6.Text = "All";
-        this.button6.UseVisualStyleBackColor = true;
-        // 
-        // button7
-        // 
-        this.button7.Anchor = System.Windows.Forms.AnchorStyles.Right;
-        this.button7.Location = new System.Drawing.Point(676, 198);
-        this.button7.Name = "button7";
-        this.button7.Size = new System.Drawing.Size(112, 34);
-        this.button7.TabIndex = 6;
-        this.button7.Text = "Right";
-        this.button7.UseVisualStyleBackColor = true;
-        // 
-        // button8
-        // 
-        this.button8.Anchor = System.Windows.Forms.AnchorStyles.Bottom;
-        this.button8.Location = new System.Drawing.Point(338, 404);
-        this.button8.Name = "button8";
-        this.button8.Size = new System.Drawing.Size(112, 34);
-        this.button8.TabIndex = 7;
-        this.button8.Text = "Bottom";
-        this.button8.UseVisualStyleBackColor = true;
-        // 
-        // button9
-        // 
-        this.button9.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
-        this.button9.Location = new System.Drawing.Point(676, 404);
-        this.button9.Name = "button9";
-        this.button9.Size = new System.Drawing.Size(112, 34);
-        this.button9.TabIndex = 8;
-        this.button9.Text = "Bottom-Right";
-        this.button9.UseVisualStyleBackColor = true;
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(10F, 25F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Controls.Add(this.button9);
-        this.Controls.Add(this.button8);
-        this.Controls.Add(this.button7);
-        this.Controls.Add(this.button6);
-        this.Controls.Add(this.button5);
-        this.Controls.Add(this.button4);
-        this.Controls.Add(this.button3);
-        this.Controls.Add(this.button2);
-        this.Controls.Add(this.button1);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private Button button1;
-    private Button button2;
-    private Button button3;
-    private Button button4;
-    private Button button5;
-    private Button button6;
-    private Button button7;
-    private Button button8;
-    private Button button9;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.cs
deleted file mode 100644
index 63dd39d9761..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class AnchorLayoutTests : Form
-{
-    public AnchorLayoutTests()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/AnchorLayoutTests.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.Designer.cs
deleted file mode 100644
index d9a782460ed..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.Designer.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class Buttons
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        this.toolTip1 = new System.Windows.Forms.ToolTip(this.components);
-        this.SuspendLayout();
-        //
-        // toolTip1
-        //
-        this.toolTip1.IsBalloon = true;
-        //
-        // Buttons
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(419, 271);
-        this.Name = "Buttons";
-        this.Text = "Buttons";
-        this.ResumeLayout(false);
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ToolTip toolTip1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.cs
deleted file mode 100644
index 0fdc064e63c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class Buttons : Form
-{
-    private readonly FlatStyle[] _styles =
-    {
-        FlatStyle.Flat,
-        FlatStyle.Popup,
-        FlatStyle.Standard,
-        FlatStyle.System
-    };
-
-    public Buttons()
-    {
-        InitializeComponent();
-    }
-
-    protected override void OnLoad(EventArgs e)
-    {
-        var table = new TableLayoutPanel
-        {
-            Dock = DockStyle.Fill,
-            ColumnCount = 3,
-            RowCount = 2
-        };
-
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        table.RowStyles.Add(new RowStyle(SizeType.Percent, 70.0f));
-        table.RowStyles.Add(new RowStyle(SizeType.Percent, 30.0f));
-        Controls.Add(table);
-
-        var panel = new FlowLayoutPanel
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-        table.Controls.Add(panel, column: 0, row: 0);
-
-        RadioButton radioButton;
-        foreach (FlatStyle style in _styles)
-        {
-            radioButton = new RadioButton
-            {
-                AutoSize = true,
-                FlatStyle = style,
-                Text = style.ToString(),
-                Checked = true
-            };
-
-            panel.Controls.Add(radioButton);
-        }
-
-        panel = new FlowLayoutPanel
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-        table.Controls.Add(panel, column: 1, row: 0);
-
-        CheckBox checkBox;
-        foreach (FlatStyle style in _styles)
-        {
-            checkBox = new CheckBox
-            {
-                AutoSize = true,
-                FlatStyle = style,
-                Text = style.ToString(),
-                Checked = true
-            };
-
-            panel.Controls.Add(checkBox);
-        }
-
-        panel = new FlowLayoutPanel
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-        table.Controls.Add(panel, column: 2, row: 0);
-
-        Button button;
-        foreach (FlatStyle style in _styles)
-        {
-            button = new Button
-            {
-                AutoSize = true,
-                FlatStyle = style,
-                Text = style.ToString()
-            };
-
-            toolTip1.SetToolTip(button, $"{style}.");
-
-            panel.Controls.Add(button);
-        }
-
-        table.Controls.Add(
-            new Button
-            {
-                AutoSize = true,
-                Image = SystemIcons.GetStockIcon(StockIconId.DesktopPC).ToBitmap()
-            },
-            column: 0,
-            row: 1);
-
-        table.Controls.Add(
-            new Button
-            {
-                AutoSize = true,
-                Image = Icon.ExtractIcon("regedit.exe", 0, 256).ToBitmap()
-            },
-            column: 1,
-            row: 1);
-
-        base.OnLoad(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.resx
deleted file mode 100644
index 2a5e6f3c363..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Buttons.resx
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="toolTip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.Designer.cs
deleted file mode 100644
index 7a4c0526a28..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.Designer.cs
+++ /dev/null
@@ -1,276 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class Calendar
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.monthCalendar1 = new System.Windows.Forms.MonthCalendar();
-        this.minDateDateTimePicker = new System.Windows.Forms.DateTimePicker();
-        this.setMinDateButton = new System.Windows.Forms.Button();
-        this.label1 = new System.Windows.Forms.Label();
-        this.label2 = new System.Windows.Forms.Label();
-        this.setMaxDateButton = new System.Windows.Forms.Button();
-        this.maxDateDateTimePicker = new System.Windows.Forms.DateTimePicker();
-        this.label3 = new System.Windows.Forms.Label();
-        this.daysOfWeekComboBox = new System.Windows.Forms.ComboBox();
-        this.label4 = new System.Windows.Forms.Label();
-        this.resetMinDateButton = new System.Windows.Forms.Button();
-        this.resetMaxDateButton = new System.Windows.Forms.Button();
-        this.showWeekNumbersCheckBox = new System.Windows.Forms.CheckBox();
-        this.showTodayCheckBox = new System.Windows.Forms.CheckBox();
-        this.label5 = new System.Windows.Forms.Label();
-        this.currentDPILabel1 = new CurrentDPILabel();
-        this.SuspendLayout();
-        // 
-        // monthCalendar1
-        // 
-        this.monthCalendar1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-        | System.Windows.Forms.AnchorStyles.Left)
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.monthCalendar1.AnnuallyBoldedDates = new System.DateTime[] {
-    new System.DateTime(2021, 8, 1, 0, 0, 0, 0),
-    new System.DateTime(2021, 8, 2, 0, 0, 0, 0)};
-        this.monthCalendar1.BoldedDates = new System.DateTime[] {
-    new System.DateTime(2021, 7, 3, 0, 0, 0, 0),
-    new System.DateTime(2021, 7, 4, 0, 0, 0, 0)};
-        this.monthCalendar1.Location = new System.Drawing.Point(18, 80);
-        this.monthCalendar1.MonthlyBoldedDates = new System.DateTime[] {
-    new System.DateTime(2021, 9, 5, 0, 0, 0, 0),
-    new System.DateTime(2021, 9, 6, 0, 0, 0, 0)};
-        this.monthCalendar1.Name = "monthCalendar1";
-        this.monthCalendar1.TabIndex = 0;
-        // 
-        // minDateDateTimePicker
-        // 
-        this.minDateDateTimePicker.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.minDateDateTimePicker.Location = new System.Drawing.Point(18, 334);
-        this.minDateDateTimePicker.Name = "minDateDateTimePicker";
-        this.minDateDateTimePicker.Size = new System.Drawing.Size(251, 27);
-        this.minDateDateTimePicker.TabIndex = 1;
-        // 
-        // setMinDateButton
-        // 
-        this.setMinDateButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.setMinDateButton.Location = new System.Drawing.Point(18, 367);
-        this.setMinDateButton.Name = "setMinDateButton";
-        this.setMinDateButton.Size = new System.Drawing.Size(123, 29);
-        this.setMinDateButton.TabIndex = 2;
-        this.setMinDateButton.Text = "Set MinDate";
-        this.setMinDateButton.UseVisualStyleBackColor = true;
-        this.setMinDateButton.Click += new System.EventHandler(this.setMinDateButton_Click);
-        // 
-        // label1
-        // 
-        this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(18, 308);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(94, 20);
-        this.label1.TabIndex = 3;
-        this.label1.Text = "Set MinDate:";
-        // 
-        // label2
-        // 
-        this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(19, 422);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(97, 20);
-        this.label2.TabIndex = 6;
-        this.label2.Text = "Set MaxDate:";
-        // 
-        // setMaxDateButton
-        // 
-        this.setMaxDateButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.setMaxDateButton.Location = new System.Drawing.Point(19, 481);
-        this.setMaxDateButton.Name = "setMaxDateButton";
-        this.setMaxDateButton.Size = new System.Drawing.Size(123, 29);
-        this.setMaxDateButton.TabIndex = 5;
-        this.setMaxDateButton.Text = "Set MaxDate";
-        this.setMaxDateButton.UseVisualStyleBackColor = true;
-        this.setMaxDateButton.Click += new System.EventHandler(this.setMaxDateButton_Click);
-        // 
-        // maxDateDateTimePicker
-        // 
-        this.maxDateDateTimePicker.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.maxDateDateTimePicker.Location = new System.Drawing.Point(19, 448);
-        this.maxDateDateTimePicker.Name = "maxDateDateTimePicker";
-        this.maxDateDateTimePicker.Size = new System.Drawing.Size(250, 27);
-        this.maxDateDateTimePicker.TabIndex = 4;
-        // 
-        // label3
-        // 
-        this.label3.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(301, 336);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(142, 20);
-        this.label3.TabIndex = 7;
-        this.label3.Text = "Set FirstDayOfWeek:";
-        // 
-        // daysOfWeekComboBox
-        // 
-        this.daysOfWeekComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.daysOfWeekComboBox.FormattingEnabled = true;
-        this.daysOfWeekComboBox.Items.AddRange(new object[] {
-        "Monday",
-        "Tuesday",
-        "Wednesday",
-        "Thursday",
-        "Friday",
-        "Saturday",
-        "Sunday",
-        "Default"});
-        this.daysOfWeekComboBox.Location = new System.Drawing.Point(301, 363);
-        this.daysOfWeekComboBox.Name = "daysOfWeekComboBox";
-        this.daysOfWeekComboBox.Size = new System.Drawing.Size(151, 28);
-        this.daysOfWeekComboBox.TabIndex = 8;
-        this.daysOfWeekComboBox.SelectedIndexChanged += new System.EventHandler(this.daysOfWeekComboBox_SelectedIndexChanged);
-        // 
-        // label4
-        // 
-        this.label4.AutoSize = true;
-        this.label4.Location = new System.Drawing.Point(18, 50);
-        this.label4.Name = "label4";
-        this.label4.Size = new System.Drawing.Size(334, 20);
-        this.label4.TabIndex = 9;
-        this.label4.Text = "Change the form size to change the calendar size";
-        // 
-        // resetMinDateButton
-        // 
-        this.resetMinDateButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.resetMinDateButton.Location = new System.Drawing.Point(146, 367);
-        this.resetMinDateButton.Name = "resetMinDateButton";
-        this.resetMinDateButton.Size = new System.Drawing.Size(123, 29);
-        this.resetMinDateButton.TabIndex = 10;
-        this.resetMinDateButton.Text = "Reset";
-        this.resetMinDateButton.UseVisualStyleBackColor = true;
-        this.resetMinDateButton.Click += new System.EventHandler(this.resetMinDateButton_Click);
-        // 
-        // resetMaxDateButton
-        // 
-        this.resetMaxDateButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.resetMaxDateButton.Location = new System.Drawing.Point(146, 481);
-        this.resetMaxDateButton.Name = "resetMaxDateButton";
-        this.resetMaxDateButton.Size = new System.Drawing.Size(123, 29);
-        this.resetMaxDateButton.TabIndex = 11;
-        this.resetMaxDateButton.Text = "Reset";
-        this.resetMaxDateButton.UseVisualStyleBackColor = true;
-        this.resetMaxDateButton.Click += new System.EventHandler(this.resetMaxDateButton_Click);
-        // 
-        // showWeekNumbersCheckBox
-        //
-        this.showWeekNumbersCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.showWeekNumbersCheckBox.AutoSize = true;
-        this.showWeekNumbersCheckBox.Location = new System.Drawing.Point(301, 452);
-        this.showWeekNumbersCheckBox.Name = "showWeekNumbersCheckBox";
-        this.showWeekNumbersCheckBox.Size = new System.Drawing.Size(161, 24);
-        this.showWeekNumbersCheckBox.TabIndex = 12;
-        this.showWeekNumbersCheckBox.Text = "showWeekNumbers";
-        this.showWeekNumbersCheckBox.UseVisualStyleBackColor = true;
-        this.showWeekNumbersCheckBox.CheckedChanged += new System.EventHandler(this.showWeekNumbersCheckBox_CheckedChanged);
-        // 
-        // showTodayCheckBox
-        //
-        this.showTodayCheckBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.showTodayCheckBox.AutoSize = true;
-        this.showTodayCheckBox.Location = new System.Drawing.Point(301, 484);
-        this.showTodayCheckBox.Name = "showTodayCheckBox";
-        this.showTodayCheckBox.Size = new System.Drawing.Size(105, 24);
-        this.showTodayCheckBox.TabIndex = 13;
-        this.showTodayCheckBox.Text = "showToday";
-        this.showTodayCheckBox.UseVisualStyleBackColor = true;
-        this.showTodayCheckBox.CheckedChanged += new System.EventHandler(this.showTodayCheckBox_CheckedChanged);
-        // 
-        // label5
-        // 
-        this.label5.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
-        this.label5.AutoSize = true;
-        this.label5.Location = new System.Drawing.Point(301, 422);
-        this.label5.Name = "label5";
-        this.label5.Size = new System.Drawing.Size(137, 20);
-        this.label5.TabIndex = 14;
-        this.label5.Text = "Additional settings:";
-        //
-        // currentDPILabel1
-        //
-        this.currentDPILabel1.Location = new System.Drawing.Point(18, 18);
-        this.currentDPILabel1.Name = "currentDPILabel1";
-        this.currentDPILabel1.Size = new System.Drawing.Size(227, 23);
-        this.currentDPILabel1.TabIndex = 1;
-        this.currentDPILabel1.Text = "currentDPILabel1";
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(509, 528);
-        this.Controls.Add(this.currentDPILabel1);
-        this.Controls.Add(this.label5);
-        this.Controls.Add(this.showTodayCheckBox);
-        this.Controls.Add(this.showWeekNumbersCheckBox);
-        this.Controls.Add(this.resetMaxDateButton);
-        this.Controls.Add(this.resetMinDateButton);
-        this.Controls.Add(this.label4);
-        this.Controls.Add(this.daysOfWeekComboBox);
-        this.Controls.Add(this.label3);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.setMaxDateButton);
-        this.Controls.Add(this.maxDateDateTimePicker);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.setMinDateButton);
-        this.Controls.Add(this.minDateDateTimePicker);
-        this.Controls.Add(this.monthCalendar1);
-        this.MinimumSize = new System.Drawing.Size(527, 575);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-    }
-
-    #endregion
-
-    private System.Windows.Forms.MonthCalendar monthCalendar1;
-    private System.Windows.Forms.DateTimePicker minDateDateTimePicker;
-    private System.Windows.Forms.Button setMinDateButton;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.Button setMaxDateButton;
-    private System.Windows.Forms.DateTimePicker maxDateDateTimePicker;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.ComboBox daysOfWeekComboBox;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.Button resetMinDateButton;
-    private System.Windows.Forms.Button resetMaxDateButton;
-    private System.Windows.Forms.CheckBox showWeekNumbersCheckBox;
-    private System.Windows.Forms.CheckBox showTodayCheckBox;
-    private System.Windows.Forms.Label label5;
-    private CurrentDPILabel currentDPILabel1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.cs
deleted file mode 100644
index 7a6253ec224..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.DateTimePicker;
-
-namespace WinformsControlsTest;
-
-public partial class Calendar : Form
-{
-    public Calendar()
-    {
-        InitializeComponent();
-        daysOfWeekComboBox.SelectedIndex = (int)monthCalendar1.FirstDayOfWeek;
-        showWeekNumbersCheckBox.Checked = monthCalendar1.ShowWeekNumbers;
-        showTodayCheckBox.Checked = monthCalendar1.ShowToday;
-        monthCalendar1.DateSelected += monthCalendar1_DateSelected;
-    }
-
-    private unsafe void monthCalendar1_DateSelected(object sender, DateRangeEventArgs e)
-    {
-        if (monthCalendar1.BoldedDates.Contains(e.Start))
-        {
-            monthCalendar1.RemoveBoldedDate(e.Start);
-        }
-        else
-        {
-            monthCalendar1.AddBoldedDate(e.Start);
-        }
-
-        monthCalendar1.UpdateBoldedDates();
-    }
-
-    private void setMinDateButton_Click(object sender, EventArgs e)
-    {
-        if (minDateDateTimePicker.Value > monthCalendar1.MaxDate)
-        {
-            MessageBox.Show("MinDate should be less then MaxDate", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-            return;
-        }
-
-        monthCalendar1.MinDate = minDateDateTimePicker.Value;
-    }
-
-    private void setMaxDateButton_Click(object sender, EventArgs e)
-    {
-        if (maxDateDateTimePicker.Value < monthCalendar1.MinDate)
-        {
-            MessageBox.Show("MaxDate should be grater then MinDate", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-            return;
-        }
-
-        monthCalendar1.MaxDate = maxDateDateTimePicker.Value;
-    }
-
-    private void daysOfWeekComboBox_SelectedIndexChanged(object sender, EventArgs e)
-    {
-        monthCalendar1.FirstDayOfWeek = (Day)daysOfWeekComboBox.SelectedIndex;
-    }
-
-    private void resetMinDateButton_Click(object sender, EventArgs e)
-    {
-        monthCalendar1.MinDate = MinimumDateTime;
-    }
-
-    private void resetMaxDateButton_Click(object sender, EventArgs e)
-    {
-        monthCalendar1.MaxDate = MaximumDateTime;
-    }
-
-    private void showWeekNumbersCheckBox_CheckedChanged(object sender, EventArgs e)
-    {
-        monthCalendar1.ShowWeekNumbers = showWeekNumbersCheckBox.Checked;
-    }
-
-    private void showTodayCheckBox_CheckedChanged(object sender, EventArgs e)
-    {
-        monthCalendar1.ShowToday = showTodayCheckBox.Checked;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Calendar.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.Designer.cs
deleted file mode 100644
index 26d458703d8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.Designer.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest.UserControls;
-
-partial class CollectionEditors
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.listView1 = new System.Windows.Forms.ListView();
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.label1 = new System.Windows.Forms.Label();
-        this.domainUpDown1 = new System.Windows.Forms.DomainUpDown();
-        this.SuspendLayout();
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Location = new System.Drawing.Point(4, 64);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(121, 21);
-        this.comboBox1.TabIndex = 2;
-        this.comboBox1.Enter += new System.EventHandler(this.control_Enter);
-        // 
-        // maskedTextBox1
-        // 
-        this.maskedTextBox1.Location = new System.Drawing.Point(4, 91);
-        this.maskedTextBox1.Name = "maskedTextBox1";
-        this.maskedTextBox1.Size = new System.Drawing.Size(121, 20);
-        this.maskedTextBox1.TabIndex = 3;
-        this.maskedTextBox1.Enter += new System.EventHandler(this.control_Enter);
-        // 
-        // textBox1
-        // 
-        this.textBox1.Location = new System.Drawing.Point(4, 12);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(121, 20);
-        this.textBox1.TabIndex = 0;
-        this.textBox1.Enter += new System.EventHandler(this.control_Enter);
-        // 
-        // listView1
-        // 
-        this.listView1.HideSelection = false;
-        this.listView1.Location = new System.Drawing.Point(4, 117);
-        this.listView1.Name = "listView1";
-        this.listView1.Size = new System.Drawing.Size(121, 97);
-        this.listView1.TabIndex = 4;
-        this.listView1.UseCompatibleStateImageBehavior = false;
-        this.listView1.Enter += new System.EventHandler(this.control_Enter);
-        // 
-        // propertyGrid1
-        // 
-        this.propertyGrid1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-        | System.Windows.Forms.AnchorStyles.Left) 
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.propertyGrid1.Location = new System.Drawing.Point(132, 37);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(357, 254);
-        this.propertyGrid1.TabIndex = 6;
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(132, 13);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(35, 13);
-        this.label1.TabIndex = 5;
-        this.label1.Text = "label1";
-        // 
-        // domainUpDown1
-        // 
-        this.domainUpDown1.Location = new System.Drawing.Point(4, 38);
-        this.domainUpDown1.Name = "domainUpDown1";
-        this.domainUpDown1.Size = new System.Drawing.Size(120, 20);
-        this.domainUpDown1.TabIndex = 1;
-        this.domainUpDown1.Text = "domainUpDown1";
-        this.domainUpDown1.Enter += new System.EventHandler(this.control_Enter);
-        // 
-        // CollectionEditors
-        // 
-        this.ClientSize = new System.Drawing.Size(501, 303);
-        this.Controls.Add(this.domainUpDown1);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.propertyGrid1);
-        this.Controls.Add(this.listView1);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.maskedTextBox1);
-        this.Controls.Add(this.comboBox1);
-        this.Name = "CollectionEditors";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-
-    #endregion
-
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.MaskedTextBox maskedTextBox1;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.ListView listView1;
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.DomainUpDown domainUpDown1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.cs
deleted file mode 100644
index 37470cf72bd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.ObjectModel;
-using System.Drawing;
-#if NETCORE
-using System.ComponentModel.Design;
-using System.Drawing.Design;
-using System.Windows.Forms.Design;
-#endif
-
-namespace WinformsControlsTest.UserControls;
-
-internal partial class CollectionEditors : Form
-{
-    private string[] _stringArray = new[] { "Lorem ipsum dolor sit amet", "id quo accusamus definitionem", "graeco salutandi sed te", "mei in solum primis definitionem." };
-    private List<string> _stringList = new() { "Lorem ipsum dolor sit amet", "id quo accusamus definitionem", "graeco salutandi sed te", "mei in solum primis definitionem." };
-    private Collection<string> _stringCollection = new() { "Lorem ipsum dolor sit amet", "id quo accusamus definitionem", "graeco salutandi sed te", "mei in solum primis definitionem." };
-
-    public CollectionEditors()
-    {
-        InitializeComponent();
-
-        var imageList = new ImageList();
-        imageList.Images.Add("SmallA", Image.FromFile("Images\\SmallA.bmp"));
-        imageList.Images.Add(Image.FromFile("Images\\SmallABlue.bmp"));
-        imageList.Images.Add("LargeA", Image.FromFile("Images\\LargeA.bmp"));
-        imageList.Images.Add(Image.FromFile("Images\\LargeABlue.bmp"));
-
-        textBox1.Lines = _stringArray;
-        domainUpDown1.Items.AddRange(_stringCollection);
-        listView1.LargeImageList = imageList;
-        _stringList.ForEach(s => listView1.Items.Add(s));
-        _stringList.ForEach(s => comboBox1.Items.Add(s));
-    }
-
-    private void control_Enter(object sender, System.EventArgs e)
-    {
-        label1.Text = sender.GetType().FullName;
-        propertyGrid1.SelectedObject = sender;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CollectionEditors.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.Designer.cs
deleted file mode 100644
index 96ce774fe3e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.Designer.cs
+++ /dev/null
@@ -1,310 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ComboBoxes
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.comboBox2 = new System.Windows.Forms.ComboBox();
-        this.comboBox3 = new System.Windows.Forms.ComboBox();
-        this.comboBox4 = new System.Windows.Forms.ComboBox();
-        this.comboBox5 = new System.Windows.Forms.ComboBox();
-        this.comboBox6 = new System.Windows.Forms.ComboBox();
-        this.comboBox7 = new System.Windows.Forms.ComboBox();
-        this.comboBox8 = new System.Windows.Forms.ComboBox();
-        this.comboBox9 = new System.Windows.Forms.ComboBox();
-        this.comboBox10 = new System.Windows.Forms.ComboBox();
-        this.comboBox11 = new System.Windows.Forms.ComboBox();
-        this.comboBox12 = new System.Windows.Forms.ComboBox();
-        this.dataBoundComboBox = new System.Windows.Forms.ComboBox();
-        this.currentDPILabel1 = new WinformsControlsTest.CurrentDPILabel();
-        this.label1 = new System.Windows.Forms.Label();
-        this.dataBoundLabel = new System.Windows.Forms.Label();
-        this.SuspendLayout();
-        //
-        // comboBox1
-        //
-        this.comboBox1.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Items.AddRange(new object[] {
-        "dropdown",
-        "system"});
-        this.comboBox1.Location = new System.Drawing.Point(21, 22);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(121, 21);
-        this.comboBox1.TabIndex = 3;
-        this.comboBox1.SelectedIndexChanged += new System.EventHandler(this.ComboBox1_SelectedIndexChanged);
-        // 
-        // comboBox2
-        //
-        this.comboBox2.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-        this.comboBox2.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.comboBox2.FormattingEnabled = true;
-        this.comboBox2.Items.AddRange(new object[] {
-        "dropdownlist",
-        "aa",
-        "bb",
-        "cc",
-        "d",
-        "ee",
-        "ff",
-        "gg",});
-        this.comboBox2.Location = new System.Drawing.Point(148, 22);
-        this.comboBox2.Name = "comboBox2";
-        this.comboBox2.Size = new System.Drawing.Size(121, 21);
-        this.comboBox2.TabIndex = 4;
-        this.comboBox2.DropDownHeight = 80;
-        //
-        // comboBox3
-        //
-        this.comboBox3.FormattingEnabled = true;
-        this.comboBox3.Items.AddRange(new object[] {
-        "dropdown",
-        "standard",
-        "aa",
-        "bb",
-        "cc",
-        "d",
-        "ee",
-        "ff",
-        "gg",});
-        this.comboBox3.Location = new System.Drawing.Point(21, 59);
-        this.comboBox3.Name = "comboBox3";
-        this.comboBox3.Size = new System.Drawing.Size(121, 21);
-        this.comboBox3.TabIndex = 5;
-        this.comboBox3.DropDownHeight = 80;
-        //
-        // comboBox4
-        //
-        this.comboBox4.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-        this.comboBox4.FormattingEnabled = true;
-        this.comboBox4.Items.AddRange(new object[] {
-        "DropDownList",
-        "aaa",
-        "aaa",
-        "aaa"});
-        this.comboBox4.Location = new System.Drawing.Point(148, 59);
-        this.comboBox4.Name = "comboBox4";
-        this.comboBox4.Size = new System.Drawing.Size(121, 21);
-        this.comboBox4.TabIndex = 6;
-        //
-        // comboBox5
-        //
-        this.comboBox5.FlatStyle = System.Windows.Forms.FlatStyle.Popup;
-        this.comboBox5.FormattingEnabled = true;
-        this.comboBox5.Items.AddRange(new object[] {
-        "popup"});
-        this.comboBox5.Location = new System.Drawing.Point(21, 96);
-        this.comboBox5.Name = "comboBox5";
-        this.comboBox5.Size = new System.Drawing.Size(121, 21);
-        this.comboBox5.TabIndex = 7;
-        //
-        // comboBox6
-        //
-        this.comboBox6.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-        this.comboBox6.FlatStyle = System.Windows.Forms.FlatStyle.Popup;
-        this.comboBox6.FormattingEnabled = true;
-        this.comboBox6.Items.AddRange(new object[] {
-        "popup",
-        "dropdownlist"});
-        this.comboBox6.Location = new System.Drawing.Point(148, 96);
-        this.comboBox6.Name = "comboBox6";
-        this.comboBox6.Size = new System.Drawing.Size(121, 21);
-        this.comboBox6.TabIndex = 8;
-        //
-        // comboBox7
-        //
-        this.comboBox7.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-        this.comboBox7.FormattingEnabled = true;
-        this.comboBox7.Items.AddRange(new object[] {
-        "flat",
-        "dropdown"});
-        this.comboBox7.Location = new System.Drawing.Point(21, 136);
-        this.comboBox7.Name = "comboBox7";
-        this.comboBox7.Size = new System.Drawing.Size(121, 21);
-        this.comboBox7.TabIndex = 9;
-        //
-        // comboBox8
-        //
-        this.comboBox8.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-        this.comboBox8.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-        this.comboBox8.FormattingEnabled = true;
-        this.comboBox8.Items.AddRange(new object[] {
-        "flat ",
-        "drop down list"});
-        this.comboBox8.Location = new System.Drawing.Point(148, 136);
-        this.comboBox8.Name = "comboBox8";
-        this.comboBox8.Size = new System.Drawing.Size(121, 21);
-        this.comboBox8.TabIndex = 10;
-        //
-        // comboBox9
-        //
-        this.comboBox9.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox9.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-        this.comboBox9.FormattingEnabled = true;
-        this.comboBox9.Items.AddRange(new object[] {
-        "flat ",
-        "simple"});
-        this.comboBox9.Location = new System.Drawing.Point(696, 22);
-        this.comboBox9.Name = "comboBox9";
-        this.comboBox9.Size = new System.Drawing.Size(121, 150);
-        this.comboBox9.TabIndex = 14;
-        //
-        // comboBox10
-        //
-        this.comboBox10.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox10.FlatStyle = System.Windows.Forms.FlatStyle.Popup;
-        this.comboBox10.FormattingEnabled = true;
-        this.comboBox10.Items.AddRange(new object[] {
-        "popup",
-        "simple"});
-        this.comboBox10.Location = new System.Drawing.Point(560, 22);
-        this.comboBox10.Name = "comboBox10";
-        this.comboBox10.Size = new System.Drawing.Size(121, 150);
-        this.comboBox10.TabIndex = 13;
-        //
-        // comboBox11
-        //
-        this.comboBox11.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox11.FormattingEnabled = true;
-        this.comboBox11.Items.AddRange(new object[] {
-        "simple",
-        "aaa",
-        "aaa",
-        "aaa"});
-        this.comboBox11.Location = new System.Drawing.Point(419, 22);
-        this.comboBox11.Name = "comboBox11";
-        this.comboBox11.Size = new System.Drawing.Size(121, 150);
-        this.comboBox11.TabIndex = 12;
-        //
-        // comboBox12
-        //
-        this.comboBox12.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox12.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.comboBox12.FormattingEnabled = true;
-        this.comboBox12.Items.AddRange(new object[] {
-        "system",
-        "simple",
-        "aa",
-        "bb",
-        "cc",
-        "d",
-        "ee",
-        "ff",
-        "gg",});
-        this.comboBox12.Location = new System.Drawing.Point(275, 22);
-        this.comboBox12.Name = "comboBox12";
-        this.comboBox12.Size = new System.Drawing.Size(121, 150);
-        this.comboBox12.TabIndex = 11;
-        //
-        // dataBoundComboBox
-        //
-        this.dataBoundComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.dataBoundComboBox.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.dataBoundComboBox.Location = new System.Drawing.Point(836, 22);
-        this.dataBoundComboBox.Name = "DataBoundComboBox";
-        this.dataBoundComboBox.Size = new System.Drawing.Size(121, 150);
-        this.dataBoundComboBox.TabIndex = 13;
-        //
-        // currentDPILabel1
-        //
-        this.currentDPILabel1.AutoSize = true;
-        this.currentDPILabel1.Location = new System.Drawing.Point(18, 173);
-        this.currentDPILabel1.Margin = new System.Windows.Forms.Padding(2, 0, 2, 0);
-        this.currentDPILabel1.Name = "currentDPILabel1";
-        this.currentDPILabel1.Size = new System.Drawing.Size(90, 13);
-        this.currentDPILabel1.TabIndex = 15;
-        this.currentDPILabel1.Text = "Current scaling is 100%";
-        //
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(18, 6);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(35, 13);
-        this.label1.TabIndex = 15;
-        this.label1.Text = "label1";
-        //
-        // dataBoundLabel
-        // 
-        this.dataBoundLabel.AutoSize = true;
-        this.dataBoundLabel.Location = new System.Drawing.Point(836, 6);
-        this.dataBoundLabel.Name = "dataBoundLabel";
-        this.dataBoundLabel.Size = new System.Drawing.Size(65, 13);
-        this.dataBoundLabel.TabIndex = 16; 
-        this.dataBoundLabel.Text = "data-bound";
-        // 
-        // ComboBoxes
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(975, 198);
-        this.Controls.Add(this.currentDPILabel1);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.dataBoundLabel);
-        this.Controls.Add(this.dataBoundComboBox);
-        this.Controls.Add(this.comboBox9);
-        this.Controls.Add(this.comboBox10);
-        this.Controls.Add(this.comboBox11);
-        this.Controls.Add(this.comboBox12);
-        this.Controls.Add(this.comboBox8);
-        this.Controls.Add(this.comboBox7);
-        this.Controls.Add(this.comboBox6);
-        this.Controls.Add(this.comboBox5);
-        this.Controls.Add(this.comboBox4);
-        this.Controls.Add(this.comboBox3);
-        this.Controls.Add(this.comboBox2);
-        this.Controls.Add(this.comboBox1);
-        this.Name = "ComboBoxes";
-        this.Text = "ComboBoxes";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.ComboBox comboBox2;
-    private System.Windows.Forms.ComboBox comboBox3;
-    private System.Windows.Forms.ComboBox comboBox4;
-    private System.Windows.Forms.ComboBox comboBox5;
-    private System.Windows.Forms.ComboBox comboBox6;
-    private System.Windows.Forms.ComboBox comboBox7;
-    private System.Windows.Forms.ComboBox comboBox8;
-    private System.Windows.Forms.ComboBox comboBox9;
-    private System.Windows.Forms.ComboBox comboBox10;
-    private System.Windows.Forms.ComboBox comboBox11;
-    private System.Windows.Forms.ComboBox comboBox12;
-    private System.Windows.Forms.ComboBox dataBoundComboBox;
-    private CurrentDPILabel currentDPILabel1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Label dataBoundLabel;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.cs
deleted file mode 100644
index 71682fc12a3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.IntegrationTests.Common;
-
-namespace WinformsControlsTest;
-
-public partial class ComboBoxes : Form
-{
-    public ComboBoxes()
-    {
-        InitializeComponent();
-
-        comboBox1.SelectedIndex = 0;
-
-        dataBoundComboBox.DataSource = TestDataSources.GetPersons();
-        dataBoundComboBox.DisplayMember = TestDataSources.PersonDisplayMember;
-    }
-
-    private void ComboBox1_SelectedIndexChanged(object sender, EventArgs e)
-    {
-        label1.Text = comboBox1.Text;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxes.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.Designer.cs
deleted file mode 100644
index 297e56eef70..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.Designer.cs
+++ /dev/null
@@ -1,403 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ComboBoxesWithScrollBars
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.comboBox2 = new System.Windows.Forms.ComboBox();
-        this.comboBox3 = new System.Windows.Forms.ComboBox();
-        this.changeHeightGroupBox1 = new System.Windows.Forms.GroupBox();
-        this.label1 = new System.Windows.Forms.Label();
-        this.changeDDH_UpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.label2 = new System.Windows.Forms.Label();
-        this.changeCBHeight_UpDown2 = new System.Windows.Forms.NumericUpDown();
-        this.label3 = new System.Windows.Forms.Label();
-        this.changeDDH_UpDown3 = new System.Windows.Forms.NumericUpDown();
-        this.changeMaxDropDownItemsGroupBox2 = new System.Windows.Forms.GroupBox();
-        this.maxDropDownItemsUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.maxDropDownItemsUpDown2 = new System.Windows.Forms.NumericUpDown();
-        this.maxDropDownItemsUpDown3 = new System.Windows.Forms.NumericUpDown();
-        this.changeIntegralHeightGroupBox3 = new System.Windows.Forms.GroupBox();
-        this.integralHeightCheckBox1 = new System.Windows.Forms.CheckBox();
-        this.integralHeightCheckBox2 = new System.Windows.Forms.CheckBox();
-        this.integralHeightCheckBox3 = new System.Windows.Forms.CheckBox();
-        this.changeHeightsStyleGroupBox4 = new System.Windows.Forms.GroupBox();
-        this.useDifferentHeightsCheckBox1 = new System.Windows.Forms.CheckBox();
-        this.useDifferentHeightsCheckBox2 = new System.Windows.Forms.CheckBox();
-        this.useDifferentHeightsCheckBox3 = new System.Windows.Forms.CheckBox();
-        this.toolTip1 = new System.Windows.Forms.ToolTip(this.components);
-        this.changeHeightGroupBox1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.changeDDH_UpDown1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.changeCBHeight_UpDown2)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.changeDDH_UpDown3)).BeginInit();
-        this.changeMaxDropDownItemsGroupBox2.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown2)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown3)).BeginInit();
-        this.changeIntegralHeightGroupBox3.SuspendLayout();
-        this.changeHeightsStyleGroupBox4.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.IntegralHeight = false;
-        this.comboBox1.Location = new System.Drawing.Point(37, 348);
-        this.comboBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(116, 23);
-        this.comboBox1.TabIndex = 0;
-        this.comboBox1.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.comboBox_DrawItem);
-        // 
-        // comboBox2
-        // 
-        this.comboBox2.DropDownStyle = System.Windows.Forms.ComboBoxStyle.Simple;
-        this.comboBox2.FormattingEnabled = true;
-        this.comboBox2.IntegralHeight = false;
-        this.comboBox2.Location = new System.Drawing.Point(206, 348);
-        this.comboBox2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.comboBox2.Name = "comboBox2";
-        this.comboBox2.Size = new System.Drawing.Size(116, 155);
-        this.comboBox2.TabIndex = 1;
-        this.comboBox2.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.comboBox_DrawItem);
-        // 
-        // comboBox3
-        // 
-        this.comboBox3.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
-        this.comboBox3.FormattingEnabled = true;
-        this.comboBox3.IntegralHeight = false;
-        this.comboBox3.Location = new System.Drawing.Point(370, 348);
-        this.comboBox3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.comboBox3.Name = "comboBox3";
-        this.comboBox3.Size = new System.Drawing.Size(116, 23);
-        this.comboBox3.TabIndex = 2;
-        this.comboBox3.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.comboBox_DrawItem);
-        // 
-        // changeHeightGroupBox1
-        // 
-        this.changeHeightGroupBox1.Controls.Add(this.label1);
-        this.changeHeightGroupBox1.Controls.Add(this.changeDDH_UpDown1);
-        this.changeHeightGroupBox1.Controls.Add(this.label2);
-        this.changeHeightGroupBox1.Controls.Add(this.changeCBHeight_UpDown2);
-        this.changeHeightGroupBox1.Controls.Add(this.label3);
-        this.changeHeightGroupBox1.Controls.Add(this.changeDDH_UpDown3);
-        this.changeHeightGroupBox1.Location = new System.Drawing.Point(14, 14);
-        this.changeHeightGroupBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeHeightGroupBox1.Name = "changeHeightGroupBox1";
-        this.changeHeightGroupBox1.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeHeightGroupBox1.Size = new System.Drawing.Size(502, 100);
-        this.changeHeightGroupBox1.TabIndex = 3;
-        this.changeHeightGroupBox1.TabStop = false;
-        this.changeHeightGroupBox1.Text = "Change a height";
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(23, 28);
-        this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(100, 30);
-        this.label1.TabIndex = 0;
-        this.label1.Text = "Change \r\nDropDownHeight";
-        // 
-        // changeDDH_UpDown1
-        // 
-        this.changeDDH_UpDown1.Location = new System.Drawing.Point(23, 61);
-        this.changeDDH_UpDown1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeDDH_UpDown1.Maximum = new decimal(new int[] {
-        1000,
-        0,
-        0,
-        0});
-        this.changeDDH_UpDown1.Name = "changeDDH_UpDown1";
-        this.changeDDH_UpDown1.Size = new System.Drawing.Size(117, 23);
-        this.changeDDH_UpDown1.TabIndex = 0;
-        this.toolTip1.SetToolTip(this.changeDDH_UpDown1, "Sets IntegralHeight to false. MaxDropDownItems won\'t be available after it settin" +
-    "g");
-        // 
-        // label2
-        // 
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(192, 28);
-        this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(106, 30);
-        this.label2.TabIndex = 1;
-        this.label2.Text = "Change \r\nComboBox Height";
-        // 
-        // changeCBHeight_UpDown2
-        // 
-        this.changeCBHeight_UpDown2.Location = new System.Drawing.Point(192, 61);
-        this.changeCBHeight_UpDown2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeCBHeight_UpDown2.Maximum = new decimal(new int[] {
-        1000,
-        0,
-        0,
-        0});
-        this.changeCBHeight_UpDown2.Name = "changeCBHeight_UpDown2";
-        this.changeCBHeight_UpDown2.Size = new System.Drawing.Size(117, 23);
-        this.changeCBHeight_UpDown2.TabIndex = 1;
-        // 
-        // label3
-        // 
-        this.label3.AutoSize = true;
-        this.label3.Location = new System.Drawing.Point(356, 28);
-        this.label3.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.label3.Name = "label3";
-        this.label3.Size = new System.Drawing.Size(100, 30);
-        this.label3.TabIndex = 2;
-        this.label3.Text = "Change \r\nDropDownHeight";
-        // 
-        // changeDDH_UpDown3
-        // 
-        this.changeDDH_UpDown3.Location = new System.Drawing.Point(356, 61);
-        this.changeDDH_UpDown3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeDDH_UpDown3.Maximum = new decimal(new int[] {
-        1000,
-        0,
-        0,
-        0});
-        this.changeDDH_UpDown3.Name = "changeDDH_UpDown3";
-        this.changeDDH_UpDown3.Size = new System.Drawing.Size(117, 23);
-        this.changeDDH_UpDown3.TabIndex = 2;
-        this.toolTip1.SetToolTip(this.changeDDH_UpDown3, "Sets IntegralHeight to false. MaxDropDownItems won\'t be available after it settin" +
-    "g");
-        // 
-        // changeMaxDropDownItemsGroupBox2
-        // 
-        this.changeMaxDropDownItemsGroupBox2.Controls.Add(this.maxDropDownItemsUpDown1);
-        this.changeMaxDropDownItemsGroupBox2.Controls.Add(this.maxDropDownItemsUpDown2);
-        this.changeMaxDropDownItemsGroupBox2.Controls.Add(this.maxDropDownItemsUpDown3);
-        this.changeMaxDropDownItemsGroupBox2.Location = new System.Drawing.Point(14, 121);
-        this.changeMaxDropDownItemsGroupBox2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeMaxDropDownItemsGroupBox2.Name = "changeMaxDropDownItemsGroupBox2";
-        this.changeMaxDropDownItemsGroupBox2.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeMaxDropDownItemsGroupBox2.Size = new System.Drawing.Size(502, 63);
-        this.changeMaxDropDownItemsGroupBox2.TabIndex = 4;
-        this.changeMaxDropDownItemsGroupBox2.TabStop = false;
-        this.changeMaxDropDownItemsGroupBox2.Text = "Change MaxDropDownItems value";
-        // 
-        // maxDropDownItemsUpDown1
-        // 
-        this.maxDropDownItemsUpDown1.Location = new System.Drawing.Point(23, 22);
-        this.maxDropDownItemsUpDown1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.maxDropDownItemsUpDown1.Maximum = new decimal(new int[] {
-        40,
-        0,
-        0,
-        0});
-        this.maxDropDownItemsUpDown1.Name = "maxDropDownItemsUpDown1";
-        this.maxDropDownItemsUpDown1.Size = new System.Drawing.Size(117, 23);
-        this.maxDropDownItemsUpDown1.TabIndex = 0;
-        // 
-        // maxDropDownItemsUpDown2
-        // 
-        this.maxDropDownItemsUpDown2.Location = new System.Drawing.Point(192, 22);
-        this.maxDropDownItemsUpDown2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.maxDropDownItemsUpDown2.Maximum = new decimal(new int[] {
-        40,
-        0,
-        0,
-        0});
-        this.maxDropDownItemsUpDown2.Name = "maxDropDownItemsUpDown2";
-        this.maxDropDownItemsUpDown2.Size = new System.Drawing.Size(117, 23);
-        this.maxDropDownItemsUpDown2.TabIndex = 1;
-        this.toolTip1.SetToolTip(this.maxDropDownItemsUpDown2, "It doesn\'t affect the combobox with the Simple dropdown style");
-        // 
-        // maxDropDownItemsUpDown3
-        // 
-        this.maxDropDownItemsUpDown3.Location = new System.Drawing.Point(356, 22);
-        this.maxDropDownItemsUpDown3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.maxDropDownItemsUpDown3.Maximum = new decimal(new int[] {
-        40,
-        0,
-        0,
-        0});
-        this.maxDropDownItemsUpDown3.Name = "maxDropDownItemsUpDown3";
-        this.maxDropDownItemsUpDown3.Size = new System.Drawing.Size(117, 23);
-        this.maxDropDownItemsUpDown3.TabIndex = 2;
-        // 
-        // changeIntegralHeightGroupBox3
-        // 
-        this.changeIntegralHeightGroupBox3.Controls.Add(this.integralHeightCheckBox1);
-        this.changeIntegralHeightGroupBox3.Controls.Add(this.integralHeightCheckBox2);
-        this.changeIntegralHeightGroupBox3.Controls.Add(this.integralHeightCheckBox3);
-        this.changeIntegralHeightGroupBox3.Location = new System.Drawing.Point(14, 192);
-        this.changeIntegralHeightGroupBox3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeIntegralHeightGroupBox3.Name = "changeIntegralHeightGroupBox3";
-        this.changeIntegralHeightGroupBox3.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeIntegralHeightGroupBox3.Size = new System.Drawing.Size(502, 63);
-        this.changeIntegralHeightGroupBox3.TabIndex = 5;
-        this.changeIntegralHeightGroupBox3.TabStop = false;
-        this.changeIntegralHeightGroupBox3.Text = "Change IntegralHeight value";
-        // 
-        // integralHeightCheckBox1
-        // 
-        this.integralHeightCheckBox1.AutoSize = true;
-        this.integralHeightCheckBox1.Location = new System.Drawing.Point(23, 33);
-        this.integralHeightCheckBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.integralHeightCheckBox1.Name = "integralHeightCheckBox1";
-        this.integralHeightCheckBox1.Size = new System.Drawing.Size(102, 19);
-        this.integralHeightCheckBox1.TabIndex = 0;
-        this.integralHeightCheckBox1.Text = "IntegralHeight";
-        this.integralHeightCheckBox1.UseVisualStyleBackColor = true;
-        // 
-        // integralHeightCheckBox2
-        // 
-        this.integralHeightCheckBox2.AutoSize = true;
-        this.integralHeightCheckBox2.Location = new System.Drawing.Point(192, 33);
-        this.integralHeightCheckBox2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.integralHeightCheckBox2.Name = "integralHeightCheckBox2";
-        this.integralHeightCheckBox2.Size = new System.Drawing.Size(102, 19);
-        this.integralHeightCheckBox2.TabIndex = 1;
-        this.integralHeightCheckBox2.Text = "IntegralHeight";
-        this.integralHeightCheckBox2.UseVisualStyleBackColor = true;
-        // 
-        // integralHeightCheckBox3
-        // 
-        this.integralHeightCheckBox3.AutoSize = true;
-        this.integralHeightCheckBox3.Location = new System.Drawing.Point(356, 33);
-        this.integralHeightCheckBox3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.integralHeightCheckBox3.Name = "integralHeightCheckBox3";
-        this.integralHeightCheckBox3.Size = new System.Drawing.Size(102, 19);
-        this.integralHeightCheckBox3.TabIndex = 2;
-        this.integralHeightCheckBox3.Text = "IntegralHeight";
-        this.integralHeightCheckBox3.UseVisualStyleBackColor = true;
-        // 
-        // changeHeightsStyleGroupBox4
-        // 
-        this.changeHeightsStyleGroupBox4.Controls.Add(this.useDifferentHeightsCheckBox1);
-        this.changeHeightsStyleGroupBox4.Controls.Add(this.useDifferentHeightsCheckBox2);
-        this.changeHeightsStyleGroupBox4.Controls.Add(this.useDifferentHeightsCheckBox3);
-        this.changeHeightsStyleGroupBox4.Location = new System.Drawing.Point(14, 262);
-        this.changeHeightsStyleGroupBox4.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeHeightsStyleGroupBox4.Name = "changeHeightsStyleGroupBox4";
-        this.changeHeightsStyleGroupBox4.Padding = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.changeHeightsStyleGroupBox4.Size = new System.Drawing.Size(502, 63);
-        this.changeHeightsStyleGroupBox4.TabIndex = 6;
-        this.changeHeightsStyleGroupBox4.TabStop = false;
-        this.changeHeightsStyleGroupBox4.Text = "Change items heights style";
-        // 
-        // useDifferentHeightsCheckBox1
-        // 
-        this.useDifferentHeightsCheckBox1.AutoSize = true;
-        this.useDifferentHeightsCheckBox1.Location = new System.Drawing.Point(23, 33);
-        this.useDifferentHeightsCheckBox1.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.useDifferentHeightsCheckBox1.Name = "useDifferentHeightsCheckBox1";
-        this.useDifferentHeightsCheckBox1.Size = new System.Drawing.Size(135, 19);
-        this.useDifferentHeightsCheckBox1.TabIndex = 0;
-        this.useDifferentHeightsCheckBox1.Text = "Use different heights";
-        this.useDifferentHeightsCheckBox1.UseVisualStyleBackColor = true;
-        // 
-        // useDifferentHeightsCheckBox2
-        // 
-        this.useDifferentHeightsCheckBox2.AutoSize = true;
-        this.useDifferentHeightsCheckBox2.Location = new System.Drawing.Point(192, 33);
-        this.useDifferentHeightsCheckBox2.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.useDifferentHeightsCheckBox2.Name = "useDifferentHeightsCheckBox2";
-        this.useDifferentHeightsCheckBox2.Size = new System.Drawing.Size(135, 19);
-        this.useDifferentHeightsCheckBox2.TabIndex = 1;
-        this.useDifferentHeightsCheckBox2.Text = "Use different heights";
-        this.useDifferentHeightsCheckBox2.UseVisualStyleBackColor = true;
-        // 
-        // useDifferentHeightsCheckBox3
-        // 
-        this.useDifferentHeightsCheckBox3.AutoSize = true;
-        this.useDifferentHeightsCheckBox3.Location = new System.Drawing.Point(356, 33);
-        this.useDifferentHeightsCheckBox3.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.useDifferentHeightsCheckBox3.Name = "useDifferentHeightsCheckBox3";
-        this.useDifferentHeightsCheckBox3.Size = new System.Drawing.Size(135, 19);
-        this.useDifferentHeightsCheckBox3.TabIndex = 2;
-        this.useDifferentHeightsCheckBox3.Text = "Use different heights";
-        this.toolTip1.SetToolTip(this.useDifferentHeightsCheckBox3, "Changes DropDownList dropdown style to DropDown in view.\nIt is impossible to retu" +
-    "rn DropDownList style for the combobox");
-        this.useDifferentHeightsCheckBox3.UseVisualStyleBackColor = true;
-        // 
-        // ComboBoxesWithScrollBars
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(531, 517);
-        this.Controls.Add(this.changeHeightGroupBox1);
-        this.Controls.Add(this.changeMaxDropDownItemsGroupBox2);
-        this.Controls.Add(this.changeIntegralHeightGroupBox3);
-        this.Controls.Add(this.changeHeightsStyleGroupBox4);
-        this.Controls.Add(this.comboBox1);
-        this.Controls.Add(this.comboBox2);
-        this.Controls.Add(this.comboBox3);
-        this.Margin = new System.Windows.Forms.Padding(4, 3, 4, 3);
-        this.Name = "ComboBoxesWithScrollBars";
-        this.Text = "ComboBoxes with ScrollBars";
-        this.changeHeightGroupBox1.ResumeLayout(false);
-        this.changeHeightGroupBox1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.changeDDH_UpDown1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.changeCBHeight_UpDown2)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.changeDDH_UpDown3)).EndInit();
-        this.changeMaxDropDownItemsGroupBox2.ResumeLayout(false);
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown2)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.maxDropDownItemsUpDown3)).EndInit();
-        this.changeIntegralHeightGroupBox3.ResumeLayout(false);
-        this.changeIntegralHeightGroupBox3.PerformLayout();
-        this.changeHeightsStyleGroupBox4.ResumeLayout(false);
-        this.changeHeightsStyleGroupBox4.PerformLayout();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.ComboBox comboBox2;
-    private System.Windows.Forms.ComboBox comboBox3;
-    private System.Windows.Forms.GroupBox changeHeightGroupBox1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.NumericUpDown changeDDH_UpDown1;
-    private System.Windows.Forms.NumericUpDown changeCBHeight_UpDown2;
-    private System.Windows.Forms.NumericUpDown changeDDH_UpDown3;
-    private System.Windows.Forms.GroupBox changeMaxDropDownItemsGroupBox2;
-    private System.Windows.Forms.NumericUpDown maxDropDownItemsUpDown1;
-    private System.Windows.Forms.NumericUpDown maxDropDownItemsUpDown2;
-    private System.Windows.Forms.NumericUpDown maxDropDownItemsUpDown3;
-    private System.Windows.Forms.GroupBox changeIntegralHeightGroupBox3;
-    private System.Windows.Forms.CheckBox integralHeightCheckBox2;
-    private System.Windows.Forms.CheckBox integralHeightCheckBox1;
-    private System.Windows.Forms.CheckBox integralHeightCheckBox3;
-    private System.Windows.Forms.GroupBox changeHeightsStyleGroupBox4;
-    private System.Windows.Forms.CheckBox useDifferentHeightsCheckBox3;
-    private System.Windows.Forms.CheckBox useDifferentHeightsCheckBox2;
-    private System.Windows.Forms.CheckBox useDifferentHeightsCheckBox1;
-    private System.Windows.Forms.ToolTip toolTip1;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.cs
deleted file mode 100644
index 4650d7cb4f3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class ComboBoxesWithScrollBars : Form
-{
-    public ComboBoxesWithScrollBars()
-    {
-        InitializeComponent();
-
-        // Init comboboxes
-        for (int i = 0; i <= 40; i++)
-        {
-            comboBox1.Items.Add(i);
-            comboBox2.Items.Add(i);
-            comboBox3.Items.Add(i);
-        }
-    }
-
-    protected override void OnLoad(EventArgs e)
-    {
-        // Set current NumericUpDowns values to heights
-        changeDDH_UpDown1.Value = comboBox1.DropDownHeight;
-        changeCBHeight_UpDown2.Value = comboBox2.Size.Height;
-        changeDDH_UpDown3.Value = comboBox3.DropDownHeight;
-
-        // Set current NumericUpDowns values to MaxDropDownItems values
-        maxDropDownItemsUpDown1.Value = comboBox1.MaxDropDownItems;
-        maxDropDownItemsUpDown2.Value = comboBox2.MaxDropDownItems;
-        maxDropDownItemsUpDown3.Value = comboBox3.MaxDropDownItems;
-
-        // Set current CheckBoxes values to IntegralHeight values
-        integralHeightCheckBox1.Checked = comboBox1.IntegralHeight;
-        integralHeightCheckBox2.Checked = comboBox2.IntegralHeight;
-        integralHeightCheckBox3.Checked = comboBox3.IntegralHeight;
-
-        // Set current CheckBoxes values to DrawMode values
-        useDifferentHeightsCheckBox1.Checked = comboBox1.DrawMode == DrawMode.OwnerDrawVariable;
-        useDifferentHeightsCheckBox2.Checked = comboBox2.DrawMode == DrawMode.OwnerDrawVariable;
-        useDifferentHeightsCheckBox3.Checked = comboBox3.DrawMode == DrawMode.OwnerDrawVariable;
-
-        // Add event handlers
-        // These handlers are not added to the designer and put here to avoid redundant invocations
-        // when the values of the upDowns and checkBoxes are set above.
-        // These handlers should be invoked when a user changes the upDowns and checkBoxes values only.
-        changeDDH_UpDown1.ValueChanged += (s, e) =>
-        {
-            comboBox1.DropDownHeight = (int)changeDDH_UpDown1.Value;
-            integralHeightCheckBox1.Checked = false;
-        };
-        changeCBHeight_UpDown2.ValueChanged += (s, e) => comboBox2.Size = new Size(comboBox2.Size.Width, (int)changeCBHeight_UpDown2.Value);
-        changeDDH_UpDown3.ValueChanged += (s, e) =>
-        {
-            comboBox3.DropDownHeight = (int)changeDDH_UpDown3.Value;
-            integralHeightCheckBox3.Checked = false;
-        };
-        maxDropDownItemsUpDown1.ValueChanged += (s, e) => comboBox1.MaxDropDownItems = (int)maxDropDownItemsUpDown1.Value;
-        maxDropDownItemsUpDown2.ValueChanged += (s, e) => comboBox2.MaxDropDownItems = (int)maxDropDownItemsUpDown2.Value;
-        maxDropDownItemsUpDown3.ValueChanged += (s, e) => comboBox3.MaxDropDownItems = (int)maxDropDownItemsUpDown3.Value;
-        integralHeightCheckBox1.CheckedChanged += (s, e) => comboBox1.IntegralHeight = integralHeightCheckBox1.Checked;
-        integralHeightCheckBox2.CheckedChanged += (s, e) => comboBox2.IntegralHeight = integralHeightCheckBox2.Checked;
-        integralHeightCheckBox3.CheckedChanged += (s, e) => comboBox3.IntegralHeight = integralHeightCheckBox3.Checked;
-        useDifferentHeightsCheckBox1.CheckedChanged += useDifferentHeightsCheckBox1_CheckedChanged;
-        useDifferentHeightsCheckBox2.CheckedChanged += useDifferentHeightsCheckBox2_CheckedChanged;
-        useDifferentHeightsCheckBox3.CheckedChanged += useDifferentHeightsCheckBox3_CheckedChanged;
-
-        base.OnLoad(e);
-    }
-
-    private void useDifferentHeightsCheckBox1_CheckedChanged(object sender, EventArgs e)
-    {
-        bool isChecked = useDifferentHeightsCheckBox1.Checked;
-
-        if (isChecked)
-        {
-            comboBox1.DrawMode = DrawMode.OwnerDrawVariable;
-            comboBox1.MeasureItem += comboBox_MeasureItem;
-        }
-        else
-        {
-            comboBox1.DrawMode = DrawMode.OwnerDrawFixed;
-            comboBox1.MeasureItem -= comboBox_MeasureItem;
-        }
-    }
-
-    private void useDifferentHeightsCheckBox2_CheckedChanged(object sender, EventArgs e)
-    {
-        bool isChecked = useDifferentHeightsCheckBox2.Checked;
-
-        if (isChecked)
-        {
-            comboBox2.DrawMode = DrawMode.OwnerDrawVariable;
-            comboBox2.MeasureItem += comboBox_MeasureItem;
-        }
-        else
-        {
-            comboBox2.DrawMode = DrawMode.OwnerDrawFixed;
-            comboBox2.MeasureItem -= comboBox_MeasureItem;
-        }
-    }
-
-    private void useDifferentHeightsCheckBox3_CheckedChanged(object sender, EventArgs e)
-    {
-        bool isChecked = useDifferentHeightsCheckBox3.Checked;
-
-        if (isChecked)
-        {
-            comboBox3.SuspendLayout();
-            comboBox3.DrawMode = DrawMode.OwnerDrawVariable;
-            comboBox3.MeasureItem += comboBox_MeasureItem;
-            comboBox3.ResumeLayout(false);
-        }
-        else
-        {
-            comboBox3.SuspendLayout();
-            comboBox3.DrawMode = DrawMode.OwnerDrawFixed;
-            comboBox3.MeasureItem -= comboBox_MeasureItem;
-            comboBox3.ResumeLayout(false);
-        }
-    }
-
-    private void comboBox_MeasureItem(object sender, MeasureItemEventArgs e) => e.ItemHeight = 15 + (e.Index % 5) * 5;
-
-    private void comboBox_DrawItem(object sender, DrawItemEventArgs e)
-    {
-        ComboBox control = (ComboBox)sender;
-
-        if (e.Index < 0 || e.Index >= control.Items.Count)
-        {
-            return;
-        }
-
-        e.DrawBackground();
-        using SolidBrush brush = new SolidBrush(e.ForeColor);
-        e.Graphics.DrawString(
-            control.Items[e.Index].ToString(),
-            e.Font,
-            brush,
-            e.Bounds);
-        e.DrawFocusRectangle();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ComboBoxesWithScrollBars.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CurrentDPILabel.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CurrentDPILabel.cs
deleted file mode 100644
index 97dfd816d7f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/CurrentDPILabel.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace WinformsControlsTest;
-
-public class CurrentDPILabel : Label
-{
-    public CurrentDPILabel()
-    {
-        DpiChangedAfterParent += CurrentDPILabel_DpiChangedAfterParent;
-        HandleCreated += CurrentDPILabel_HandleCreated;
-    }
-
-    [DefaultValue(false)]
-    public override bool AutoSize
-    {
-        get => base.AutoSize;
-        set => base.AutoSize = value;
-    }
-
-    private void CurrentDPILabel_HandleCreated(object sender, EventArgs e)
-    {
-        SetText();
-    }
-
-    private void CurrentDPILabel_DpiChangedAfterParent(object sender, EventArgs e)
-    {
-        SetText();
-    }
-
-    private void SetText()
-    {
-        Text = $"Current scaling is {(int)Math.Round((DeviceDpi / 96.0) * 100)}%";
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.bmp
deleted file mode 100644
index 4ac8a0cc28d..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.rtf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.rtf
deleted file mode 100644
index b4aec65e1ca..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/DragAccept.rtf
+++ /dev/null
@@ -1,242 +0,0 @@
-{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff31507\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi31507\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}
-{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\f313\fbidi \fmodern\fcharset0\fprq1{\*\panose 020b0609020000020004}Cascadia Mono;}
-{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fhimajor\f31502\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0302020204030204}Calibri Light;}{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f897\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\f898\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\f900\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f901\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f902\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\f903\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\f904\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f905\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f1237\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}
-{\f1238\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}{\f1240\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f1241\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f1244\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}
-{\f1245\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}{\f1267\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f1268\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f1270\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}
-{\f1271\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\f1272\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\f1273\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\f1274\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
-{\f1275\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\f4027\fbidi \fmodern\fcharset238\fprq1 Cascadia Mono CE;}{\f4028\fbidi \fmodern\fcharset204\fprq1 Cascadia Mono Cyr;}{\f4030\fbidi \fmodern\fcharset161\fprq1 Cascadia Mono Greek;}
-{\f4031\fbidi \fmodern\fcharset162\fprq1 Cascadia Mono Tur;}{\f4034\fbidi \fmodern\fcharset186\fprq1 Cascadia Mono Baltic;}{\f4035\fbidi \fmodern\fcharset163\fprq1 Cascadia Mono (Vietnamese);}
-{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \fswiss\fcharset238\fprq2 Calibri Light CE;}{\fhimajor\f31529\fbidi \fswiss\fcharset204\fprq2 Calibri Light Cyr;}
-{\fhimajor\f31531\fbidi \fswiss\fcharset161\fprq2 Calibri Light Greek;}{\fhimajor\f31532\fbidi \fswiss\fcharset162\fprq2 Calibri Light Tur;}{\fhimajor\f31533\fbidi \fswiss\fcharset177\fprq2 Calibri Light (Hebrew);}
-{\fhimajor\f31534\fbidi \fswiss\fcharset178\fprq2 Calibri Light (Arabic);}{\fhimajor\f31535\fbidi \fswiss\fcharset186\fprq2 Calibri Light Baltic;}{\fhimajor\f31536\fbidi \fswiss\fcharset163\fprq2 Calibri Light (Vietnamese);}
-{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
-{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}
-{\fhiminor\f31573\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\fhiminor\f31574\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
-{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}
-{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;
-\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;\red0\green0\blue0;\red0\green0\blue0;}{\*\defchp \fs22\loch\af31506\hich\af31506\dbch\af31505 }{\*\defpap 
-\ql \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 
-\af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\*
-\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused 
-Normal Table;}}{\*\rsidtbl \rsid13178\rsid4880890}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\operator Brandon Williams}{\creatim\yr2021\mo12\dy31\min39}
-{\revtim\yr2021\mo12\dy31\min40}{\version2}{\edmins1}{\nofpages1}{\nofwords100}{\nofchars570}{\nofcharsws669}{\vern39}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}
-\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect 
-\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\dghorigin1701
-\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\rsidroot13178 \nouicompat \fet0{\*\wgrffmtfilter 2450}\nofeaturethrottle1\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang
-{\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}
-{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9
-\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 
-\fs22\lang1033\langfe1033\loch\af31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af37\afs28 \ltrch\fcs0 \b\f313\fs28\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 
-DragAcceptFiles function (shellapi.h)}{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Registers whether a window accepts dropped files.
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Syntax}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 void DragAcceptFiles(
-\par \hich\af313\dbch\af31505\loch\f313   HWND hWnd,
-\par \hich\af313\dbch\af31505\loch\f313   BOOL fAccept
-\par \hich\af313\dbch\af31505\loch\f313 );
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Parameters}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\ul\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 hWnd}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par \hich\af313\dbch\af31505\loch\f313 Type: HWND
-\par 
-\par \hich\af313\dbch\af31505\loch\f313 The identifier of th\hich\af313\dbch\af31505\loch\f313 e window that is registering whether it will accept dropped files.
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\ul\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 fAccept}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-
-\par \hich\af313\dbch\af31505\loch\f313 Type: BOOL
-\par 
-\par \hich\af313\dbch\af31505\loch\f313 A value that indicates if the window identified by the hWnd parameter accepts dropped files. This value is TRUE to accept dropped files or FALSE to discontinue acceptin\hich\af313\dbch\af31505\loch\f313 g dropped files.
-
-\par }{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Return value}{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 None
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \ab\af37\afs24 \ltrch\fcs0 \b\f313\fs24\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 Remarks}{\rtlch\fcs1 \ab\af37 \ltrch\fcs0 \b\f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37 \ltrch\fcs0 \f313\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 \hich\af313\dbch\af31505\loch\f313 An application that calls DragAcceptFiles with the fAccept parameter set to TRUE has identified itsel
-\hich\af313\dbch\af31505\loch\f313 f as able to process the WM_DROPFILES message from File Manager.}{\rtlch\fcs1 \af37\afs20 \ltrch\fcs0 \f313\fs20\lang9\langfe1033\langnp9\insrsid4880890\charrsid13178 
-\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a
-9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad
-5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6
-b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0
-0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6
-a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f
-c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512
-0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462
-a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865
-6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b
-4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b
-4757e8d3f729e245eb2b260a0238fd010000ffff0300504b030414000600080000002100b6f4679893070000c9200000160000007468656d652f7468656d652f
-7468656d65312e786d6cec59cd8b1bc915bf07f23f347d97f5d5ad8fc1f2a24fcfda33b6b164873dd648a5eef2547789aad28cc56208de532e81c026e49085bd
-ed21842cecc22eb9e48f31d8249b3f22afaa5bdd5552c99e191c3061463074977eefd5afde7bf5de53d5ddcf5e26d4bbc05c1096f6fcfa9d9aefe174ce16248d
-7afeb3d9a4d2f13d2151ba4094a5b8e76fb0f03fbbf7eb5fdd454732c609f6403e1547a8e7c752ae8eaa5531876124eeb0154ee1bb25e30992f0caa3ea82a34b
-d09bd06aa3566b55134452df4b51026a1f2f97648ebd9952e9dfdb2a1f53784da5500373caa74a35b6243476715e5708b11143cabd0b447b3eccb3609733fc52
-fa1e4542c2173dbfa6fffceabdbb5574940b517940d6909be8bf5c2e17589c37f49c3c3a2b260d823068f50bfd1a40e53e6edc1eb7c6ad429f06a0f91c569a71
-b175b61bc320c71aa0ecd1a17bd41e35eb16ded0dfdce3dc0fd5c7c26b50a63fd8c34f2643b0a285d7a00c1feee1c3417730b2f56b50866fede1dbb5fe28685b
-fa3528a6243ddf43d7c25673b85d6d0159327aec8477c360d26ee4ca4b144443115d6a8a254be5a1584bd00bc6270050408a24493db959e1259a43140f112567
-9c7827248a21f056286502866b8ddaa4d684ffea13e827ed5174849121ad780113b137a4f87862cec94af6fc07a0d537206f7ffef9cdeb1fdfbcfee9cd575fbd
-79fdf77c6eadca923b466964cafdf2dd1ffef3cd6fbd7ffff0ed2f5fff319b7a172f4cfcbbbffdeedd3ffef93ef5b0e2d2146ffff4fdbb1fbf7ffbe7dfffebaf
-5f3bb4f7393a33e1339260e13dc297de5396c0021dfcf119bf9ec42c46c494e8a791402952b338f48f656ca11f6d10450edc00db767cce21d5b880f7d72f2cc2
-d398af2571687c182716f094313a60dc6985876a2ec3ccb3751ab927e76b13f714a10bd7dc43945a5e1eaf579063894be530c616cd2714a5124538c5d253dfb1
-738c1dabfb8210cbaea764ce99604be97d41bc01224e93ccc899154da5d03149c02f1b1741f0b7659bd3e7de8051d7aa47f8c246c2de40d4417e86a965c6fb68
-2d51e252394309350d7e8264ec2239ddf0b9891b0b099e8e3065de78818570c93ce6b05ec3e90f21cdb8dd7e4a37898de4929cbb749e20c64ce4889d0f6394ac
-5cd829496313fbb938871045de13265df05366ef10f50e7e40e941773f27d872f787b3c133c8b026a53240d4376beef0e57dccacf89d6ee8126157aae9f3c44a
-b17d4e9cd131584756689f604cd1255a60ec3dfbdcc160c05696cd4bd20f62c82ac7d815580f901dabea3dc5027a25d5dcece7c91322ac909de2881de073bad9
-493c1b9426881fd2fc08bc6eda7c0ca52e7105c0633a3f37818f08f480102f4ea33c16a0c308ee835a9fc4c82a60ea5db8e375c32dff5d658fc1be7c61d1b8c2
-be04197c6d1948eca6cc7b6d3343d49aa00c9819822ec3956e41c4727f29a28aab165b3be596f6a62ddd00dd91d5f42424fd6007b4d3fb84ffbbde073a8cb77f
-f9c6b10f3e4ebfe3566c25ab6b763a8792c9f14e7f7308b7dbd50c195f904fbfa919a175fa04431dd9cf58b73dcd6d4fe3ffdff73487f6f36d2773a8dfb8ed64
-7ce8306e3b99fc70e5e3743265f3027d8d3af0c80e7af4b14f72f0d46749289dca0dc527421ffc08f83db398c0a092d3279eb838055cc5f0a8ca1c4c60e1228e
-b48cc799fc0d91f134462b381daafb4a492472d591f0564cc0a1911e76ea5678ba4e4ed9223becacd7d5c16656590592e5782d2cc6e1a04a66e856bb3cc02bd4
-6bb6913e68dd1250b2d721614c6693683a48b4b783ca48fa58178ce620a157f65158741d2c3a4afdd6557b2c805ae115f8c1edc1cff49e1f06200242701e07cd
-f942f92973f5d6bbda991fd3d3878c69450034d8db08283ddd555c0f2e4fad2e0bb52b78da2261849b4d425b46377822869fc17974aad1abd0b8aeafbba54b2d
-7aca147a3e08ad9246bbf33e1637f535c8ede6069a9a9982a6de65cf6f35430899395af5fc251c1ac363b282d811ea3717a211dcbccc25cf36fc4d32cb8a0b39
-4222ce0cae934e960d122231f728497abe5a7ee1069aea1ca2b9d51b90103e59725d482b9f1a3970baed64bc5ce2b934dd6e8c284b67af90e1b35ce1fc568bdf
-1cac24d91adc3d8d1797de195df3a708422c6cd795011744c0dd413db3e682c0655891c8caf8db294c79da356fa3740c65e388ae62945714339967709dca0b3a
-faadb081f196af190c6a98242f8467912ab0a651ad6a5a548d8cc3c1aafb6121653923699635d3ca2aaa6abab39835c3b60cecd8f26645de60b53531e434b3c2
-67a97b37e576b7b96ea74f28aa0418bcb09fa3ea5ea12018d4cac92c6a8af17e1a56393b1fb56bc776811fa07695226164fdd656ed8edd8a1ae19c0e066f54f9
-416e376a6168b9ed2bb5a5f5adb979b1cdce5e40f2184197bba6526857c2c92e47d0104d754f92a50dd8222f65be35e0c95b73d2f3bfac85fd60d80887955a27
-1c57826650ab74c27eb3d20fc3667d1cd66ba341e31514161927f530bbb19fc00506dde4f7f67a7cefee3ed9ded1dc99b3a4caf4dd7c5513d777f7f5c6e1bb7b
-8f40d2f9b2d598749bdd41abd26df627956034e854bac3d6a0326a0ddba3c9681876ba9357be77a1c141bf390c5ae34ea5551f0e2b41aba6e877ba9576d068f4
-8376bf330efaaff23606569ea58fdc16605ecdebde7f010000ffff0300504b0304140006000800000021000dd1909fb60000001b010000270000007468656d65
-2f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f78277086f6fd3ba109126dd88d0add40384e4350d36
-3f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89d93b64b060828e6f37ed1567914b284d262452282e
-3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd5001996509affb3fd381a89672f1f165dfe514173d985
-0528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0fbfff0000001c020000130000000000000000000000
-0000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6a7e7c0000000360100000b00000000000000000000
-000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a0000001c0000000000000000000000000019020000
-7468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d0014000600080000002100b6f4679893070000c92000001600000000000000
-000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d00140006000800000021000dd1909fb60000001b01000027000000
-000000000000000000009d0a00007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000980b00000000}
-{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
-617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
-6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
-656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
-{\*\latentstyles\lsdstimax376\lsdlockeddef0\lsdsemihiddendef0\lsdunhideuseddef0\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 5;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 9;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 1;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 2;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 4;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 5;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 7;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 8;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 header;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footer;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index heading;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of figures;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope return;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation reference;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 line number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 page number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote text;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of authorities;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 macro;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 toa heading;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 5;\lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Closing;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Signature;\lsdsemihidden1 \lsdunhideused1 \lsdpriority1 \lsdlocked0 Default Paragraph Font;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Message Header;\lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Salutation;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Date;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Note Heading;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Block Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 FollowedHyperlink;\lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;
-\lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Document Map;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Plain Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 E-mail Signature;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Top of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Bottom of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal (Web);\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Acronym;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Cite;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Code;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Definition;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Keyboard;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Preformatted;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Sample;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Typewriter;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Variable;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Table;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation subject;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 No List;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Simple 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Classic 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Colorful 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Columns 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Grid 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table List 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table 3D effects 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Contemporary;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Elegant;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Professional;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Subtle 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Subtle 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 1;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 2;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Web 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Balloon Text;\lsdpriority39 \lsdlocked0 Table Grid;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Table Theme;\lsdsemihidden1 \lsdlocked0 Placeholder Text;
-\lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdpriority60 \lsdlocked0 Light Shading;\lsdpriority61 \lsdlocked0 Light List;\lsdpriority62 \lsdlocked0 Light Grid;\lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdpriority64 \lsdlocked0 Medium Shading 2;
-\lsdpriority65 \lsdlocked0 Medium List 1;\lsdpriority66 \lsdlocked0 Medium List 2;\lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdpriority70 \lsdlocked0 Dark List;
-\lsdpriority71 \lsdlocked0 Colorful Shading;\lsdpriority72 \lsdlocked0 Colorful List;\lsdpriority73 \lsdlocked0 Colorful Grid;\lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdpriority61 \lsdlocked0 Light List Accent 1;
-\lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdsemihidden1 \lsdlocked0 Revision;
-\lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;
-\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdpriority72 \lsdlocked0 Colorful List Accent 1;
-\lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;
-\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;
-\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;
-\lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdpriority62 \lsdlocked0 Light Grid Accent 3;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;
-\lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;
-\lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;\lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdpriority60 \lsdlocked0 Light Shading Accent 4;
-\lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdpriority62 \lsdlocked0 Light Grid Accent 4;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;
-\lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdpriority70 \lsdlocked0 Dark List Accent 4;
-\lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;\lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdpriority61 \lsdlocked0 Light List Accent 5;
-\lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdpriority62 \lsdlocked0 Light Grid Accent 6;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;
-\lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority37 \lsdlocked0 Bibliography;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;\lsdpriority41 \lsdlocked0 Plain Table 1;\lsdpriority42 \lsdlocked0 Plain Table 2;\lsdpriority43 \lsdlocked0 Plain Table 3;\lsdpriority44 \lsdlocked0 Plain Table 4;
-\lsdpriority45 \lsdlocked0 Plain Table 5;\lsdpriority40 \lsdlocked0 Grid Table Light;\lsdpriority46 \lsdlocked0 Grid Table 1 Light;\lsdpriority47 \lsdlocked0 Grid Table 2;\lsdpriority48 \lsdlocked0 Grid Table 3;\lsdpriority49 \lsdlocked0 Grid Table 4;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 1;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 1;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 1;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 1;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 1;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 2;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 2;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 2;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 2;
-\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 3;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 3;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 3;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 3;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 3;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 4;
-\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 4;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 4;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 4;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 4;
-\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 4;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 5;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 5;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 5;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 5;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 5;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 6;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 6;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 6;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 6;
-\lsdpriority46 \lsdlocked0 List Table 1 Light;\lsdpriority47 \lsdlocked0 List Table 2;\lsdpriority48 \lsdlocked0 List Table 3;\lsdpriority49 \lsdlocked0 List Table 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful;\lsdpriority52 \lsdlocked0 List Table 7 Colorful;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 List Table 2 Accent 1;\lsdpriority48 \lsdlocked0 List Table 3 Accent 1;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 1;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 1;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 1;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 List Table 2 Accent 2;\lsdpriority48 \lsdlocked0 List Table 3 Accent 2;\lsdpriority49 \lsdlocked0 List Table 4 Accent 2;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 2;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 3;
-\lsdpriority47 \lsdlocked0 List Table 2 Accent 3;\lsdpriority48 \lsdlocked0 List Table 3 Accent 3;\lsdpriority49 \lsdlocked0 List Table 4 Accent 3;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 3;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 4;\lsdpriority47 \lsdlocked0 List Table 2 Accent 4;
-\lsdpriority48 \lsdlocked0 List Table 3 Accent 4;\lsdpriority49 \lsdlocked0 List Table 4 Accent 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 4;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 4;
-\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 List Table 2 Accent 5;\lsdpriority48 \lsdlocked0 List Table 3 Accent 5;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 5;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 5;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 5;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 List Table 2 Accent 6;\lsdpriority48 \lsdlocked0 List Table 3 Accent 6;\lsdpriority49 \lsdlocked0 List Table 4 Accent 6;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Mention;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hashtag;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Unresolved Mention;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Link;}}{\*\datastore 01050000
-02000000180000004d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000
-d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e500000000000000000000000070e0
-e90722fed701feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
-0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat1.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat1.bmp
deleted file mode 100644
index 806bf5fb8ab..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat1.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat2.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat2.bmp
deleted file mode 100644
index 806bf5fb8ab..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat2.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat3.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat3.bmp
deleted file mode 100644
index 806bf5fb8ab..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat3.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat4.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat4.bmp
deleted file mode 100644
index 806bf5fb8ab..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat4.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat5.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat5.bmp
deleted file mode 100644
index 806bf5fb8ab..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCat5.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii.txt b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii.txt
deleted file mode 100644
index 4c81fe5d2fe..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-.,__,.........,__,.....╭¬¬¬¬¬━━╮
-`•.,¸,.•*¯`•.,¸,.•*|:¬¬¬¬¬¬::::|:^--------^ 
-`•.,¸,.•*¯`•.,¸,.•*|:¬¬¬¬¬¬::::||｡◕‿‿◕｡| 
--........--""-.......--"╰O━━━━O╯╰--O-O--╯
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii_301.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii_301.bmp
deleted file mode 100644
index 5773715c5c8..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/NyanCatAscii_301.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripAsciiCat.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripAsciiCat.bmp
deleted file mode 100644
index dcba3c6ffa7..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripAsciiCat.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripDragAccept.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripDragAccept.bmp
deleted file mode 100644
index 2fa0140c4a4..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripDragAccept.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripNyanCat.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripNyanCat.bmp
deleted file mode 100644
index e7c99d04888..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/DragDrop/ToolStripNyanCat.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/example.rtf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/example.rtf
deleted file mode 100644
index a3c9a1f4f2f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Data/example.rtf
+++ /dev/null
@@ -1,235 +0,0 @@
-{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff0\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi0\deflang3081\deflangfe3081\themelang2057\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}
-{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0302020204030204}Calibri Light;}
-{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
-{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}
-{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f43\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f44\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\f46\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f47\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f48\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f49\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\f50\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f51\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f383\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f384\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}
-{\f386\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f387\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f390\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f391\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}
-{\f413\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f414\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f416\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\f417\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}
-{\f418\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\f419\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\f420\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f421\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}
-{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \fswiss\fcharset238\fprq2 Calibri Light CE;}{\fhimajor\f31529\fbidi \fswiss\fcharset204\fprq2 Calibri Light Cyr;}
-{\fhimajor\f31531\fbidi \fswiss\fcharset161\fprq2 Calibri Light Greek;}{\fhimajor\f31532\fbidi \fswiss\fcharset162\fprq2 Calibri Light Tur;}{\fhimajor\f31533\fbidi \fswiss\fcharset177\fprq2 Calibri Light (Hebrew);}
-{\fhimajor\f31534\fbidi \fswiss\fcharset178\fprq2 Calibri Light (Arabic);}{\fhimajor\f31535\fbidi \fswiss\fcharset186\fprq2 Calibri Light Baltic;}{\fhimajor\f31536\fbidi \fswiss\fcharset163\fprq2 Calibri Light (Vietnamese);}
-{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
-{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
-{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
-{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
-{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
-{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
-{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}
-{\fhiminor\f31573\fbidi \fswiss\fcharset177\fprq2 Calibri (Hebrew);}{\fhiminor\f31574\fbidi \fswiss\fcharset178\fprq2 Calibri (Arabic);}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
-{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
-{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
-{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}
-{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;
-\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;\red0\green0\blue0;\red0\green0\blue0;\chyperlink\ctint255\cshade255\red5\green99\blue193;\red96\green94\blue92;\red225\green223\blue221;}
-{\*\defchp \fs22\loch\af31506\hich\af31506\dbch\af31505 }{\*\defpap \ql \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \fs22\lang2057\langfe2057\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp2057\langfenp2057 \snext0 \sqformat \spriority0 Normal;}{\*
-\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\*
-\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \fs22\lang3081\langfe3081\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp3081\langfenp3081 \snext11 \ssemihidden \sunhideused 
-Normal Table;}{\*\cs15 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \ul\cf19 \sbasedon10 \sunhideused \styrsid6102101 Hyperlink;}{\*\cs16 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \cf20\chshdng0\chcfpat0\chcbpat21 
-\sbasedon10 \ssemihidden \sunhideused \styrsid6102101 Unresolved Mention;}}{\*\listtable{\list\listtemplateid134807583{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext
-\'02\'00.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fbias0 \fi-360\li360\lin360 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'04\'00.\'01.;}{\levelnumbers\'01\'03;}
-\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-432\li792\lin792 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'06\'00.\'01.\'02.;}{\levelnumbers\'01\'03\'05;}\rtlch\fcs1 \af0 \ltrch\fcs0 
-\fi-504\li1224\lin1224 }{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'08\'00.\'01.\'02.\'03.;}{\levelnumbers\'01\'03\'05\'07;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-648\li1728\lin1728 }
-{\listlevel\levelnfc0\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'0a\'00.\'01.\'02.\'03.\'04.;}{\levelnumbers\'01\'03\'05\'07\'09;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-792\li2232\lin2232 }{\listlevel\levelnfc0
-\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'0c\'00.\'01.\'02.\'03.\'04.\'05.;}{\levelnumbers\'01\'03\'05\'07\'09\'0b;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-936\li2736\lin2736 }{\listlevel\levelnfc0\levelnfcn0
-\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'0e\'00.\'01.\'02.\'03.\'04.\'05.\'06.;}{\levelnumbers\'01\'03\'05\'07\'09\'0b\'0d;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-1080\li3240\lin3240 }{\listlevel\levelnfc0\levelnfcn0
-\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'10\'00.\'01.\'02.\'03.\'04.\'05.\'06.\'07.;}{\levelnumbers\'01\'03\'05\'07\'09\'0b\'0d\'0f;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-1224\li3744\lin3744 }{\listlevel\levelnfc0
-\levelnfcn0\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'12\'00.\'01.\'02.\'03.\'04.\'05.\'06.\'07.\'08.;}{\levelnumbers\'01\'03\'05\'07\'09\'0b\'0d\'0f\'11;}\rtlch\fcs1 \af0 \ltrch\fcs0 \fi-1440\li4320\lin4320 }
-{\listname ;}\listid311953490}}{\*\listoverridetable{\listoverride\listid311953490\listoverridecount0\ls1}}{\*\rsidtbl \rsid726525\rsid1857979\rsid3368175\rsid6102101\rsid14046926\rsid14645217\rsid14955985}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0
-\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\operator Igor Velikorossov}{\creatim\yr2019\mo3\dy14\hr11\min8}{\revtim\yr2019\mo8\dy15\hr13\min31}{\version7}{\edmins6}{\nofpages1}{\nofwords32}{\nofchars187}
-{\nofcharsws218}{\vern111}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect 
-\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\dghorigin1701
-\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\rsidroot14955985 \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2
-\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6
-\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang 
-{\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\qc \li0\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid14955985 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 
-\fs22\lang2057\langfe2057\loch\af31506\hich\af31506\dbch\af31505\cgrid\langnp2057\langfenp2057 {\field{\*\fldinst {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid6102101 \hich\af31506\dbch\af31505\loch\f31506  \hich\af31506\dbch\af31505\loch\f31506 HYPERLINK 
-\hich\af31506\dbch\af31505\loch\f31506 "https://github.com/dotnet/winforms/issues/146"\hich\af31506\dbch\af31505\loch\f31506  }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid6102101 {\*\datafield 
-00d0c9ea79f9bace118c8200aa004ba90b0200000003000000e0c9ea79f9bace118c8200aa004ba90b74000000680074007400700073003a002f002f006700690074006800750062002e0063006f006d002f0064006f0074006e00650074002f00770069006e0066006f0072006d0073002f00690073007300750065007300
-2f003100340036000000795881f43b1d7f48af2c825dc485276300000000a5ab0003}}}{\fldrslt {\rtlch\fcs1 \af0 \ltrch\fcs0 \cs15\ul\cf19\insrsid14645217\charrsid6102101 \hich\af31506\dbch\af31505\loch\f31506 Example}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {
-\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506  Document}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid3368175 
-\par }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506 1.\tab}}\pard \ltrpar\ql \fi-360\li360\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin360\itap0\pararsid14955985 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506 Section}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\hich\af31506\dbch\af31505\loch\f31506  }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506 T}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 itle}{\rtlch\fcs1 \af0 \ltrch\fcs0 
-\insrsid6102101 \hich\af31506\dbch\af31505\loch\f31506  }{\field{\*\fldinst {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid6102101 \hich\af31506\dbch\af31505\loch\f31506  \hich\af31506\dbch\af31505\loch\f31506 HYPERLINK \hich\af31506\dbch\af31505\loch\f31506 "
-\hich\af31506\dbch\af31505\loch\f31506 http://\hich\af31506\dbch\af31505\loch\f31506 www.google.com\hich\af31506\dbch\af31505\loch\f31506 "\hich\af31506\dbch\af31505\loch\f31506  }}{\fldrslt {\rtlch\fcs1 \af0 \ltrch\fcs0 
-\cs15\ul\cf19\insrsid6102101\charrsid5517541 \hich\af31506\dbch\af31505\loch\f31506 www.google.com}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid6102101 \hich\af31506\dbch\af31505\loch\f31506  }{\rtlch\fcs1 \af0 
-\ltrch\fcs0 \insrsid14955985 
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506 1.1.\tab}}\pard \ltrpar\ql \fi-432\li792\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\ilvl1\adjustright\rin0\lin792\itap0\pararsid1857979 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506  }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\hich\af31506\dbch\af31505\loch\f31506 Some stu}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 \hich\af31506\dbch\af31505\loch\f31506 f}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid1857979 \hich\af31506\dbch\af31505\loch\f31506 f}{\rtlch\fcs1 \af0 \ltrch\fcs0 
-\insrsid14046926 
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid726525 \hich\af31506\dbch\af31505\loch\f31506 1.1.1.\tab}}\pard \ltrpar\ql \fi-504\li1224\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\ilvl2\adjustright\rin0\lin1224\itap0\pararsid1857979 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid726525 \hich\af31506\dbch\af31505\loch\f31506  }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 
-\hich\af31506\dbch\af31505\loch\f31506 Some stuff\hich\f31506 \rquote \loch\f31506 s }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid726525 \hich\af31506\dbch\af31505\loch\f31506 thing}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid1857979 
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 1.2.\tab}}\pard \ltrpar\ql \fi-432\li792\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\ilvl1\adjustright\rin0\lin792\itap0\pararsid14955985 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506  More stuff
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 2.\tab}}\pard \ltrpar\ql \fi-360\li360\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin360\itap0\pararsid14955985 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 Next }{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 
-\hich\af31506\dbch\af31505\loch\f31506 Section}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0\afs22 \ltrch\fcs0 \f31506\fs22\lang2057\langfe2057\langnp2057\langfenp2057\insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 2.1.\tab}}\pard \ltrpar\ql \fi-432\li792\ri0\sa160\sl259\slmult1
-\widctlpar\wrapdefault\aspalpha\aspnum\faauto\ls1\ilvl1\adjustright\rin0\lin792\itap0\pararsid14955985 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 \hich\af31506\dbch\af31505\loch\f31506 Other s}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14645217 
-\hich\af31506\dbch\af31505\loch\f31506 tuff}{\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\par }\pard \ltrpar\ql \li720\ri0\sa160\sl259\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin720\itap0\pararsid14955985 {\rtlch\fcs1 \af0 \ltrch\fcs0 \insrsid14955985 
-\par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a
-9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad
-5689811a183c61a50f98f4babebc2837878049899a52a57be670674cb23d8e90721f90a4d2fa3802cb35762680fd800ecd7551dc18eb899138e3c943d7e503b6
-b01d583deee5f99824e290b4ba3f364eac4a430883b3c092d4eca8f946c916422ecab927f52ea42b89a1cd59c254f919b0e85e6535d135a8de20f20b8c12c3b0
-0c895fcf6720192de6bf3b9e89ecdbd6596cbcdd8eb28e7c365ecc4ec1ff1460f53fe813d3cc7f5b7f020000ffff0300504b030414000600080000002100a5d6
-a7e7c0000000360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4f
-c7060abb0884a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b6309512
-0f88d94fbc52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462
-a1a82fe353bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f746865
-6d652f7468656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b
-4b0d592c9c070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b
-4757e8d3f729e245eb2b260a0238fd010000ffff0300504b030414000600080000002100b6f4679893070000c9200000160000007468656d652f7468656d652f
-7468656d65312e786d6cec59cd8b1bc915bf07f23f347d97f5d5ad8fc1f2a24fcfda33b6b164873dd648a5eef2547789aad28cc56208de532e81c026e49085bd
-ed21842cecc22eb9e48f31d8249b3f22afaa5bdd5552c99e191c3061463074977eefd5afde7bf5de53d5ddcf5e26d4bbc05c1096f6fcfa9d9aefe174ce16248d
-7afeb3d9a4d2f13d2151ba4094a5b8e76fb0f03fbbf7eb5fdd454732c609f6403e1547a8e7c752ae8eaa5531876124eeb0154ee1bb25e30992f0caa3ea82a34b
-d09bd06aa3566b55134452df4b51026a1f2f97648ebd9952e9dfdb2a1f53784da5500373caa74a35b6243476715e5708b11143cabd0b447b3eccb3609733fc52
-fa1e4542c2173dbfa6fffceabdbb5574940b517940d6909be8bf5c2e17589c37f49c3c3a2b260d823068f50bfd1a40e53e6edc1eb7c6ad429f06a0f91c569a71
-b175b61bc320c71aa0ecd1a17bd41e35eb16ded0dfdce3dc0fd5c7c26b50a63fd8c34f2643b0a285d7a00c1feee1c3417730b2f56b50866fede1dbb5fe28685b
-fa3528a6243ddf43d7c25673b85d6d0159327aec8477c360d26ee4ca4b144443115d6a8a254be5a1584bd00bc6270050408a24493db959e1259a43140f112567
-9c7827248a21f056286502866b8ddaa4d684ffea13e827ed5174849121ad780113b137a4f87862cec94af6fc07a0d537206f7ffef9cdeb1fdfbcfee9cd575fbd
-79fdf77c6eadca923b466964cafdf2dd1ffef3cd6fbd7ffff0ed2f5fff319b7a172f4cfcbbbffdeedd3ffef93ef5b0e2d2146ffff4fdbb1fbf7ffbe7dfffebaf
-5f3bb4f7393a33e1339260e13dc297de5396c0021dfcf119bf9ec42c46c494e8a791402952b338f48f656ca11f6d10450edc00db767cce21d5b880f7d72f2cc2
-d398af2571687c182716f094313a60dc6985876a2ec3ccb3751ab927e76b13f714a10bd7dc43945a5e1eaf579063894be530c616cd2714a5124538c5d253dfb1
-738c1dabfb8210cbaea764ce99604be97d41bc01224e93ccc899154da5d03149c02f1b1741f0b7659bd3e7de8051d7aa47f8c246c2de40d4417e86a965c6fb68
-2d51e252394309350d7e8264ec2239ddf0b9891b0b099e8e3065de78818570c93ce6b05ec3e90f21cdb8dd7e4a37898de4929cbb749e20c64ce4889d0f6394ac
-5cd829496313fbb938871045de13265df05366ef10f50e7e40e941773f27d872f787b3c133c8b026a53240d4376beef0e57dccacf89d6ee8126157aae9f3c44a
-b17d4e9cd131584756689f604cd1255a60ec3dfbdcc160c05696cd4bd20f62c82ac7d815580f901dabea3dc5027a25d5dcece7c91322ac909de2881de073bad9
-493c1b9426881fd2fc08bc6eda7c0ca52e7105c0633a3f37818f08f480102f4ea33c16a0c308ee835a9fc4c82a60ea5db8e375c32dff5d658fc1be7c61d1b8c2
-be04197c6d1948eca6cc7b6d3343d49aa00c9819822ec3956e41c4727f29a28aab165b3be596f6a62ddd00dd91d5f42424fd6007b4d3fb84ffbbde073a8cb77f
-f9c6b10f3e4ebfe3566c25ab6b763a8792c9f14e7f7308b7dbd50c195f904fbfa919a175fa04431dd9cf58b73dcd6d4fe3ffdff73487f6f36d2773a8dfb8ed64
-7ce8306e3b99fc70e5e3743265f3027d8d3af0c80e7af4b14f72f0d46749289dca0dc527421ffc08f83db398c0a092d3279eb838055cc5f0a8ca1c4c60e1228e
-b48cc799fc0d91f134462b381daafb4a492472d591f0564cc0a1911e76ea5678ba4e4ed9223becacd7d5c16656590592e5782d2cc6e1a04a66e856bb3cc02bd4
-6bb6913e68dd1250b2d721614c6693683a48b4b783ca48fa58178ce620a157f65158741d2c3a4afdd6557b2c805ae115f8c1edc1cff49e1f06200242701e07cd
-f942f92973f5d6bbda991fd3d3878c69450034d8db08283ddd555c0f2e4fad2e0bb52b78da2261849b4d425b46377822869fc17974aad1abd0b8aeafbba54b2d
-7aca147a3e08ad9246bbf33e1637f535c8ede6069a9a9982a6de65cf6f35430899395af5fc251c1ac363b282d811ea3717a211dcbccc25cf36fc4d32cb8a0b39
-4222ce0cae934e960d122231f728497abe5a7ee1069aea1ca2b9d51b90103e59725d482b9f1a3970baed64bc5ce2b934dd6e8c284b67af90e1b35ce1fc568bdf
-1cac24d91adc3d8d1797de195df3a708422c6cd795011744c0dd413db3e682c0655891c8caf8db294c79da356fa3740c65e388ae62945714339967709dca0b3a
-faadb081f196af190c6a98242f8467912ab0a651ad6a5a548d8cc3c1aafb6121653923699635d3ca2aaa6abab39835c3b60cecd8f26645de60b53531e434b3c2
-67a97b37e576b7b96ea74f28aa0418bcb09fa3ea5ea12018d4cac92c6a8af17e1a56393b1fb56bc776811fa07695226164fdd656ed8edd8a1ae19c0e066f54f9
-416e376a6168b9ed2bb5a5f5adb979b1cdce5e40f2184197bba6526857c2c92e47d0104d754f92a50dd8222f65be35e0c95b73d2f3bfac85fd60d80887955a27
-1c57826650ab74c27eb3d20fc3667d1cd66ba341e31514161927f530bbb19fc00506dde4f7f67a7cefee3ed9ded1dc99b3a4caf4dd7c5513d777f7f5c6e1bb7b
-8f40d2f9b2d598749bdd41abd26df627956034e854bac3d6a0326a0ddba3c9681876ba9357be77a1c141bf390c5ae34ea5551f0e2b41aba6e877ba9576d068f4
-8376bf330efaaff23606569ea58fdc16605ecdebde7f010000ffff0300504b0304140006000800000021000dd1909fb60000001b010000270000007468656d65
-2f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f78277086f6fd3ba109126dd88d0add40384e4350d36
-3f2451eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89d93b64b060828e6f37ed1567914b284d262452282e
-3198720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd5001996509affb3fd381a89672f1f165dfe514173d985
-0528a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100e9de0fbfff0000001c020000130000000000000000000000
-0000000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6a7e7c0000000360100000b00000000000000000000
-000000300100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a0000001c0000000000000000000000000019020000
-7468656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d0014000600080000002100b6f4679893070000c92000001600000000000000
-000000000000d60200007468656d652f7468656d652f7468656d65312e786d6c504b01022d00140006000800000021000dd1909fb60000001b01000027000000
-000000000000000000009d0a00007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000980b00000000}
-{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
-617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
-6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
-656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
-{\*\latentstyles\lsdstimax376\lsdlockeddef0\lsdsemihiddendef0\lsdunhideuseddef0\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 5;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 7;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 8;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index 9;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 1;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 2;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 4;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 5;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 6;
-\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 7;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 8;\lsdsemihidden1 \lsdunhideused1 \lsdpriority39 \lsdlocked0 toc 9;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 header;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footer;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 index heading;\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of figures;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 envelope return;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 footnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation reference;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 line number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 page number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote reference;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 endnote text;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 table of authorities;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 macro;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 toa heading;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Bullet 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 4;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Number 5;\lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Closing;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Signature;\lsdsemihidden1 \lsdunhideused1 \lsdpriority1 \lsdlocked0 Default Paragraph Font;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 4;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 List Continue 5;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Message Header;\lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Salutation;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Date;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text First Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Note Heading;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Body Text Indent 3;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Block Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 FollowedHyperlink;\lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;
-\lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Document Map;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Plain Text;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 E-mail Signature;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Top of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Bottom of Form;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Normal (Web);\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Acronym;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Address;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Cite;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Code;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Definition;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Keyboard;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Preformatted;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Sample;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Typewriter;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 HTML Variable;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 annotation subject;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 No List;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 1;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 2;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Outline List 3;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Balloon Text;\lsdpriority39 \lsdlocked0 Table Grid;
-\lsdsemihidden1 \lsdlocked0 Placeholder Text;\lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdpriority60 \lsdlocked0 Light Shading;\lsdpriority61 \lsdlocked0 Light List;\lsdpriority62 \lsdlocked0 Light Grid;
-\lsdpriority63 \lsdlocked0 Medium Shading 1;\lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdpriority65 \lsdlocked0 Medium List 1;\lsdpriority66 \lsdlocked0 Medium List 2;\lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdpriority68 \lsdlocked0 Medium Grid 2;
-\lsdpriority69 \lsdlocked0 Medium Grid 3;\lsdpriority70 \lsdlocked0 Dark List;\lsdpriority71 \lsdlocked0 Colorful Shading;\lsdpriority72 \lsdlocked0 Colorful List;\lsdpriority73 \lsdlocked0 Colorful Grid;\lsdpriority60 \lsdlocked0 Light Shading Accent 1;
-\lsdpriority61 \lsdlocked0 Light List Accent 1;\lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;
-\lsdsemihidden1 \lsdlocked0 Revision;\lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;\lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;\lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 1;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdpriority61 \lsdlocked0 Light List Accent 2;\lsdpriority62 \lsdlocked0 Light Grid Accent 2;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdpriority70 \lsdlocked0 Dark List Accent 2;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;\lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdpriority62 \lsdlocked0 Light Grid Accent 3;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdpriority60 \lsdlocked0 Light Shading Accent 4;\lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdpriority62 \lsdlocked0 Light Grid Accent 4;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;\lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 4;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdpriority61 \lsdlocked0 Light List Accent 5;\lsdpriority62 \lsdlocked0 Light Grid Accent 5;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdpriority70 \lsdlocked0 Dark List Accent 5;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;\lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdpriority62 \lsdlocked0 Light Grid Accent 6;
-\lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;\lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;
-\lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;\lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;
-\lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;\lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;
-\lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;\lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdsemihidden1 \lsdunhideused1 \lsdpriority37 \lsdlocked0 Bibliography;
-\lsdsemihidden1 \lsdunhideused1 \lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;\lsdpriority41 \lsdlocked0 Plain Table 1;\lsdpriority42 \lsdlocked0 Plain Table 2;\lsdpriority43 \lsdlocked0 Plain Table 3;\lsdpriority44 \lsdlocked0 Plain Table 4;
-\lsdpriority45 \lsdlocked0 Plain Table 5;\lsdpriority40 \lsdlocked0 Grid Table Light;\lsdpriority46 \lsdlocked0 Grid Table 1 Light;\lsdpriority47 \lsdlocked0 Grid Table 2;\lsdpriority48 \lsdlocked0 Grid Table 3;\lsdpriority49 \lsdlocked0 Grid Table 4;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 1;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 1;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 1;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 1;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 1;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 2;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 2;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 2;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 2;
-\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 3;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 3;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 3;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 3;
-\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 3;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 4;
-\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 4;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 4;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 4;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 4;
-\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 4;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 5;
-\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 5;\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 5;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 5;
-\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 5;\lsdpriority46 \lsdlocked0 Grid Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 Grid Table 2 Accent 6;\lsdpriority48 \lsdlocked0 Grid Table 3 Accent 6;
-\lsdpriority49 \lsdlocked0 Grid Table 4 Accent 6;\lsdpriority50 \lsdlocked0 Grid Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 Grid Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 Grid Table 7 Colorful Accent 6;
-\lsdpriority46 \lsdlocked0 List Table 1 Light;\lsdpriority47 \lsdlocked0 List Table 2;\lsdpriority48 \lsdlocked0 List Table 3;\lsdpriority49 \lsdlocked0 List Table 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful;\lsdpriority52 \lsdlocked0 List Table 7 Colorful;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 1;\lsdpriority47 \lsdlocked0 List Table 2 Accent 1;\lsdpriority48 \lsdlocked0 List Table 3 Accent 1;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 1;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 1;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 1;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 1;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 2;\lsdpriority47 \lsdlocked0 List Table 2 Accent 2;\lsdpriority48 \lsdlocked0 List Table 3 Accent 2;\lsdpriority49 \lsdlocked0 List Table 4 Accent 2;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 2;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 2;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 2;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 3;
-\lsdpriority47 \lsdlocked0 List Table 2 Accent 3;\lsdpriority48 \lsdlocked0 List Table 3 Accent 3;\lsdpriority49 \lsdlocked0 List Table 4 Accent 3;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 3;
-\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 3;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 3;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 4;\lsdpriority47 \lsdlocked0 List Table 2 Accent 4;
-\lsdpriority48 \lsdlocked0 List Table 3 Accent 4;\lsdpriority49 \lsdlocked0 List Table 4 Accent 4;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 4;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 4;
-\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 4;\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 5;\lsdpriority47 \lsdlocked0 List Table 2 Accent 5;\lsdpriority48 \lsdlocked0 List Table 3 Accent 5;
-\lsdpriority49 \lsdlocked0 List Table 4 Accent 5;\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 5;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 5;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 5;
-\lsdpriority46 \lsdlocked0 List Table 1 Light Accent 6;\lsdpriority47 \lsdlocked0 List Table 2 Accent 6;\lsdpriority48 \lsdlocked0 List Table 3 Accent 6;\lsdpriority49 \lsdlocked0 List Table 4 Accent 6;
-\lsdpriority50 \lsdlocked0 List Table 5 Dark Accent 6;\lsdpriority51 \lsdlocked0 List Table 6 Colorful Accent 6;\lsdpriority52 \lsdlocked0 List Table 7 Colorful Accent 6;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Mention;
-\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Hyperlink;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Hashtag;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Unresolved Mention;\lsdsemihidden1 \lsdunhideused1 \lsdlocked0 Smart Link;}}{\*\datastore 01050000
-02000000180000004d73786d6c322e534158584d4c5265616465722e362e3000000000000000000000060000
-d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e5000000000000000000000000b090
-d5a65453d501feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
-00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
-0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.Designer.cs
deleted file mode 100644
index 120593f494b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.Designer.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class DataGridViewInVirtualModeTest
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.dataGridView1 = new System.Windows.Forms.DataGridView();
-        this.personNameColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.ageColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.hasAJobColumn = new System.Windows.Forms.DataGridViewCheckBoxColumn();
-        this.genderColumn = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // dataGridView1
-        // 
-        this.dataGridView1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-        | System.Windows.Forms.AnchorStyles.Left)
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView1.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
-        this.personNameColumn,
-        this.ageColumn,
-        this.hasAJobColumn,
-        this.genderColumn});
-        this.dataGridView1.Location = new System.Drawing.Point(0, 15);
-        this.dataGridView1.Name = "dataGridView1";
-        this.dataGridView1.Size = new System.Drawing.Size(492, 150);
-        this.dataGridView1.TabIndex = 5;
-        this.dataGridView1.VirtualMode = true;
-        // 
-        // personNameColumn
-        // 
-        this.personNameColumn.HeaderText = "Name";
-        this.personNameColumn.Name = "personNameColumn";
-        // 
-        // ageColumn
-        // 
-        this.ageColumn.HeaderText = "Age";
-        this.ageColumn.Name = "ageColumn";
-        // 
-        // hasAJobColumn
-        // 
-        this.hasAJobColumn.HeaderText = "Has a job";
-        this.hasAJobColumn.Name = "hasAJobColumn";
-        // 
-        // genderColumn
-        // 
-        this.genderColumn.HeaderText = "Gender";
-        this.genderColumn.Name = "genderColumn";
-        this.genderColumn.Items.Add("Male");
-        this.genderColumn.Items.Add("Female");
-        // 
-        // DataGridViewInVirtualModeTest
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(492, 180);
-        this.Controls.Add(this.dataGridView1);
-        this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        this.Name = "DataGridViewInVirtualModeTest";
-        this.Text = "DataGridView in Virtual mode";
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.DataGridView dataGridView1;
-    private System.Windows.Forms.DataGridViewTextBoxColumn personNameColumn;
-    private System.Windows.Forms.DataGridViewTextBoxColumn ageColumn;
-    private System.Windows.Forms.DataGridViewCheckBoxColumn hasAJobColumn;
-    private System.Windows.Forms.DataGridViewComboBoxColumn genderColumn;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.cs
deleted file mode 100644
index bfe76987579..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class DataGridViewInVirtualModeTest : Form
-{
-    // Declare fields for testing DGV in the Virtual mode
-    // The example was taken from: https://docs.microsoft.com/dotnet/desktop/winforms/controls/implementing-virtual-mode-wf-datagridview-control
-
-    // Declare a List to serve as the test data source
-    private readonly List<TestCustomer> _customers = new();
-
-    // Declare a TestCustomer object to store data for a row being edited
-    private TestCustomer _customerInEdit;
-
-    // Declare a variable to store the index of a row being edited.
-    // A value of -1 indicates that there is no row currently in edit
-    private int _rowInEdit = -1;
-
-    // Declare a variable to indicate the commit scope.
-    // Set this value to false to use cell-level commit scope
-    private bool _rowScopeCommit = true;
-
-    public DataGridViewInVirtualModeTest()
-    {
-        InitializeComponent();
-    }
-
-    protected override void OnLoad(EventArgs e)
-    {
-        base.OnLoad(e);
-
-        // Connect the virtual-mode events to event handlers
-        dataGridView1.CellValueNeeded += dataGridView1_CellValueNeeded;
-        dataGridView1.CellValuePushed += dataGridView1_CellValuePushed;
-        dataGridView1.NewRowNeeded += dataGridView1_NewRowNeeded;
-        dataGridView1.RowValidated += dataGridView1_RowValidated;
-        dataGridView1.RowDirtyStateNeeded += dataGridView1_RowDirtyStateNeeded;
-        dataGridView1.CancelRowEdit += dataGridView1_CancelRowEdit;
-        dataGridView1.UserDeletingRow += dataGridView1_UserDeletingRow;
-
-        // Add some sample entries to the data store
-        _customers.Add(new TestCustomer("Ann", 23, true, "Female"));
-        _customers.Add(new TestCustomer("John", 45, true, "Male"));
-        _customers.Add(new TestCustomer("Sarah", 67, false, "Female"));
-
-        // Set the row count, including the row for new records
-        dataGridView1.RowCount = _customers.Count + 1; // Add 1 as a new edit row
-    }
-
-    private void dataGridView1_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e)
-    {
-        // If this is the row for new records, no values are needed
-        if (e.RowIndex == dataGridView1.RowCount - 1)
-        {
-            return;
-        }
-
-        // Store a reference to the TestCustomer object for the row being painted
-        TestCustomer customer = e.RowIndex == _rowInEdit ? _customerInEdit : _customers[e.RowIndex];
-
-        // Set the cell value to paint using the TestCustomer object retrieved
-        switch (dataGridView1.Columns[e.ColumnIndex].Name)
-        {
-            case "personNameColumn":
-                e.Value = customer.Name;
-                break;
-            case "ageColumn":
-                e.Value = customer.Age;
-                break;
-            case "hasAJobColumn":
-                e.Value = customer.HasAJob;
-                break;
-            case "genderColumn":
-                e.Value = customer.Gender;
-                break;
-        }
-    }
-
-    private void dataGridView1_CellValuePushed(object sender, DataGridViewCellValueEventArgs e)
-    {
-        // Store a reference to the TestCustomer object for the row being edited
-        if (e.RowIndex < _customers.Count)
-        {
-            // If the user is editing a new row, create a new TestCustomer object
-            TestCustomer customer = _customers[e.RowIndex];
-            _customerInEdit ??= new TestCustomer(customer.Name, customer.Age, customer.HasAJob, customer.Gender);
-            _rowInEdit = e.RowIndex;
-        }
-
-        // Set the appropriate TestCustomer property to the cell value entered
-        object newValue = e.Value;
-
-        switch (dataGridView1.Columns[e.ColumnIndex].Name)
-        {
-            case "personNameColumn":
-                _customerInEdit.Name = newValue.ToString();
-                break;
-            case "ageColumn":
-                if (int.TryParse(newValue.ToString(), out int result))
-                {
-                    _customerInEdit.Age = result;
-                }
-
-                break;
-            case "hasAJobColumn":
-                _customerInEdit.HasAJob = (bool)newValue;
-                break;
-            case "genderColumn":
-                _customerInEdit.Gender = newValue.ToString();
-                break;
-        }
-    }
-
-    private void dataGridView1_NewRowNeeded(object sender, DataGridViewRowEventArgs e)
-    {
-        // Create a new TestCustomer object when the user edits
-        // the row for new records
-        _customerInEdit = new TestCustomer();
-        _rowInEdit = dataGridView1.Rows.Count - 1;
-    }
-
-    private void dataGridView1_RowValidated(object sender, DataGridViewCellEventArgs e)
-    {
-        // Save row changes if any were made and release the edited
-        // TestCustomer object if there is one.
-        if (e.RowIndex >= _customers.Count && e.RowIndex != dataGridView1.Rows.Count - 1)
-        {
-            // Add the new TestCustomer object to the data store
-            _customers.Add(_customerInEdit);
-            _customerInEdit = null;
-            _rowInEdit = -1;
-        }
-        else if (_customerInEdit is not null && e.RowIndex < _customers.Count)
-        {
-            // Save the modified TestCustomer object in the data store
-            _customers[e.RowIndex] = _customerInEdit;
-            _customerInEdit = null;
-            _rowInEdit = -1;
-        }
-        else if (dataGridView1.ContainsFocus)
-        {
-            _customerInEdit = null;
-            _rowInEdit = -1;
-        }
-    }
-
-    private void dataGridView1_RowDirtyStateNeeded(object sender, QuestionEventArgs e)
-    {
-        if (!_rowScopeCommit)
-        {
-            // In cell-level commit scope, indicate whether the value
-            // of the current cell has been modified
-            e.Response = dataGridView1.IsCurrentCellDirty;
-        }
-    }
-
-    private void dataGridView1_CancelRowEdit(object sender, QuestionEventArgs e)
-    {
-        if (_rowInEdit == dataGridView1.Rows.Count - 2 && _rowInEdit == _customers.Count)
-        {
-            // If the user has canceled the edit of a newly created row,
-            // replace the corresponding TestCustomer object with a new, empty one
-            _customerInEdit = new TestCustomer();
-        }
-        else
-        {
-            // If the user has canceled the edit of an existing row,
-            // release the corresponding TestCustomer object
-            _customerInEdit = null;
-            _rowInEdit = -1;
-        }
-    }
-
-    private void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
-    {
-        if (e.Row.Index < _customers.Count)
-        {
-            // If the user has deleted an existing row, remove the
-            // corresponding TestCustomer object from the data store
-            _customers.RemoveAt(e.Row.Index);
-        }
-
-        if (e.Row.Index == _rowInEdit)
-        {
-            // If the user has deleted a newly created row, release
-            // the corresponding TestCustomer object
-            _rowInEdit = -1;
-            _customerInEdit = null;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewInVirtualModeTest.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.Designer.cs
deleted file mode 100644
index 13939dbee55..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.Designer.cs
+++ /dev/null
@@ -1,242 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class DataGridViewTest
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
-        System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle3 = new System.Windows.Forms.DataGridViewCellStyle();
-        this.dataGridView1 = new System.Windows.Forms.DataGridView();
-        this.column1 = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.column2 = new System.Windows.Forms.DataGridViewTextBoxColumn();
-        this.column3 = new System.Windows.Forms.DataGridViewCheckBoxColumn();
-        this.column4 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.column5 = new System.Windows.Forms.DataGridViewComboBoxColumn();
-        this.column6 = new System.Windows.Forms.DataGridViewImageColumn();
-        this.column7 = new System.Windows.Forms.DataGridViewButtonColumn();
-        this.column8 = new System.Windows.Forms.DataGridViewCheckBoxColumn();
-        this.currentDPILabel1 = new WinformsControlsTest.CurrentDPILabel();
-        this.changeFontButton = new System.Windows.Forms.Button();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.label1 = new System.Windows.Forms.Label();
-        this.resetFontButton = new System.Windows.Forms.Button();
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // dataGridView1
-        // 
-        dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
-        dataGridViewCellStyle1.BackColor = System.Drawing.SystemColors.Control;
-        dataGridViewCellStyle1.Font = new System.Drawing.Font("Cascadia Code", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        dataGridViewCellStyle1.ForeColor = System.Drawing.SystemColors.WindowText;
-        dataGridViewCellStyle1.SelectionBackColor = System.Drawing.SystemColors.Highlight;
-        dataGridViewCellStyle1.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
-        dataGridViewCellStyle1.WrapMode = System.Windows.Forms.DataGridViewTriState.True;
-        this.dataGridView1.ColumnHeadersDefaultCellStyle = dataGridViewCellStyle1;
-        this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
-        this.dataGridView1.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
-        this.column1,
-        this.column2,
-        this.column5,
-        this.column3,
-        this.column4,
-        this.column6,
-        this.column7,
-        this.column8, });
-        dataGridViewCellStyle3.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
-        dataGridViewCellStyle3.BackColor = System.Drawing.SystemColors.Info;
-        dataGridViewCellStyle3.Font = new System.Drawing.Font("Consolas", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        dataGridViewCellStyle3.ForeColor = System.Drawing.Color.Maroon;
-        dataGridViewCellStyle3.SelectionBackColor = System.Drawing.SystemColors.Highlight;
-        dataGridViewCellStyle3.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
-        dataGridViewCellStyle3.WrapMode = System.Windows.Forms.DataGridViewTriState.False;
-        this.dataGridView1.DefaultCellStyle = dataGridViewCellStyle3;
-        this.dataGridView1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.dataGridView1.Location = new System.Drawing.Point(0, 0);
-        this.dataGridView1.Name = "dataGridView1";
-        this.dataGridView1.Size = new System.Drawing.Size(750, 150);
-        this.dataGridView1.TabIndex = 0;
-        // 
-        // column1
-        // 
-        this.column1.HeaderText = "Column1";
-        this.column1.Name = "column1";
-        // 
-        // column2
-        // 
-        this.column2.HeaderText = "Column2";
-        this.column2.Name = "column2";
-        // 
-        // column3
-        // 
-        this.column3.HeaderText = "Column3";
-        this.column3.Name = "column3";
-        // 
-        // column4
-        // 
-        this.column4.HeaderText = "Column4";
-        this.column4.Name = "column4";
-        this.column4.Items.AddRange(new[] {"First", "Second"});
-        this.column4.AutoComplete = true;
-        // 
-        // column5
-        // 
-        this.column5.HeaderText = "Hidden Column";
-        this.column5.Name = "column5";
-        this.column5.Visible = false;
-        // 
-        // column6
-        // 
-        this.column6.HeaderText = "Column6";
-        this.column6.Name = "column6";
-        // 
-        // column7
-        // 
-        this.column7.HeaderText = "Column7";
-        this.column7.Name = "column7";
-        this.column7.Text = "Button";
-        this.column7.UseColumnTextForButtonValue = true;
-        // 
-        // column8
-        // 
-        this.column8.HeaderText = "Column8";
-        this.column8.Name = "column8";
-        this.column8.ThreeState = true;
-        // 
-        // currentDPILabel1
-        // 
-        this.currentDPILabel1.AutoSize = true;
-        this.currentDPILabel1.Location = new System.Drawing.Point(12, 174);
-        this.currentDPILabel1.Name = "currentDPILabel1";
-        this.currentDPILabel1.Size = new System.Drawing.Size(116, 13);
-        this.currentDPILabel1.TabIndex = 1;
-        this.currentDPILabel1.Text = "Current scaling is 100%";
-        // 
-        // changeFontButton
-        // 
-        this.changeFontButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
-        this.changeFontButton.AutoSize = true;
-        this.changeFontButton.Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        this.changeFontButton.Location = new System.Drawing.Point(12, 234);
-        this.changeFontButton.Name = "button1";
-        this.changeFontButton.Size = new System.Drawing.Size(154, 29);
-        this.changeFontButton.TabIndex = 1;
-        this.changeFontButton.Text = "Change DGV font";
-        this.changeFontButton.UseVisualStyleBackColor = true;
-        this.changeFontButton.Click += new System.EventHandler(this.changeFontButton_Click);
-        // 
-        // numericUpDown1
-        // 
-        this.numericUpDown1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
-        this.numericUpDown1.Location = new System.Drawing.Point(89, 208);
-        this.numericUpDown1.Maximum = new decimal(new int[] {
-        14,
-        0,
-        0,
-        0});
-        this.numericUpDown1.Minimum = new decimal(new int[] {
-        8,
-        0,
-        0,
-        0});
-        this.numericUpDown1.Name = "numericUpDown1";
-        this.numericUpDown1.Size = new System.Drawing.Size(64, 20);
-        this.numericUpDown1.TabIndex = 2;
-        this.numericUpDown1.TextAlign = System.Windows.Forms.HorizontalAlignment.Right;
-        this.numericUpDown1.Value = new decimal(new int[] {
-        8,
-        0,
-        0,
-        0});
-        this.numericUpDown1.ValueChanged += new System.EventHandler(this.numericUpDown1_ValueChanged);
-        // 
-        // label1
-        // 
-        this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(12, 210);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(51, 13);
-        this.label1.TabIndex = 3;
-        this.label1.Text = "Form font";
-        // 
-        // resetFontButton
-        // 
-        this.resetFontButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)));
-        this.resetFontButton.AutoSize = true;
-        this.resetFontButton.Font = new System.Drawing.Font("Consolas", 12F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        this.resetFontButton.Location = new System.Drawing.Point(192, 234);
-        this.resetFontButton.Name = "button2";
-        this.resetFontButton.Size = new System.Drawing.Size(154, 29);
-        this.resetFontButton.TabIndex = 4;
-        this.resetFontButton.Text = "Reset DGV font";
-        this.resetFontButton.UseVisualStyleBackColor = true;
-        this.resetFontButton.Click += new System.EventHandler(this.resetFontButton_Click);
-        // 
-        // DataGridViewTest
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(750, 272);
-        this.Controls.Add(this.resetFontButton);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.numericUpDown1);
-        this.Controls.Add(this.currentDPILabel1);
-        this.Controls.Add(this.changeFontButton);
-        this.Controls.Add(this.dataGridView1);
-        this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
-        this.Name = "DataGridViewTest";
-        this.Text = "DataGridView";
-        ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.DataGridView dataGridView1;
-    private System.Windows.Forms.DataGridViewTextBoxColumn column1;
-    private System.Windows.Forms.DataGridViewTextBoxColumn column2;
-    private System.Windows.Forms.DataGridViewCheckBoxColumn column3;
-    private System.Windows.Forms.DataGridViewComboBoxColumn column4;
-    private System.Windows.Forms.DataGridViewComboBoxColumn column5;
-    private System.Windows.Forms.DataGridViewImageColumn column6;
-    private System.Windows.Forms.DataGridViewButtonColumn column7;
-    private System.Windows.Forms.DataGridViewCheckBoxColumn column8;
-    private WinformsControlsTest.CurrentDPILabel currentDPILabel1;
-    private System.Windows.Forms.Button changeFontButton;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Button resetFontButton;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.cs
deleted file mode 100644
index f613253f2e6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class DataGridViewTest : Form
-{
-    private static readonly Font[] s_fonts = new[]
-    {
-        new Font("Tahoma", 12F, FontStyle.Regular),
-        new Font("Consolas", 14F, FontStyle.Italic),
-        new Font("Arial", 9F, FontStyle.Bold),
-        new Font("Microsoft Sans Serif", 11F, FontStyle.Regular)
-    };
-    private int _cellFontIndex;
-    private int _columnHeaderFontIndex;
-    private int _rowHeaderFontIndex;
-
-    public DataGridViewTest()
-    {
-        InitializeComponent();
-
-        dataGridView1.Rows.Add(new DataGridViewRow() { Visible = false });
-        dataGridView1.Rows.Add("DefaultCellStyle", dataGridView1.DefaultCellStyle.Font.ToString());
-        dataGridView1.Rows.Add("ColumnHeadersDefaultCellStyle", dataGridView1.ColumnHeadersDefaultCellStyle.Font.ToString());
-        dataGridView1.Rows.Add("RowHeadersDefaultCellStyle", dataGridView1.RowHeadersDefaultCellStyle.Font.ToString());
-        column6.Image = Image.FromFile("Images\\SmallA.bmp");
-
-        int i = 1;
-        foreach (DataGridViewRow row in dataGridView1.Rows)
-        {
-            if (row.Visible)
-            {
-                row.HeaderCell.Value = $"Row {i++}";
-            }
-        }
-    }
-
-    protected override void OnLoad(EventArgs e)
-    {
-        base.OnLoad(e);
-
-        currentDPILabel1.Text = DeviceDpi.ToString();
-    }
-
-    private void DataGridView_DpiChanged(object sender, DpiChangedEventArgs e)
-    {
-        currentDPILabel1.Text = DeviceDpi.ToString();
-    }
-
-    private void changeFontButton_Click(object sender, EventArgs e)
-    {
-        _cellFontIndex++;
-        if (_cellFontIndex >= s_fonts.Length)
-        {
-            _cellFontIndex -= s_fonts.Length;
-        }
-
-        _columnHeaderFontIndex += 2;
-        if (_columnHeaderFontIndex >= s_fonts.Length)
-        {
-            _columnHeaderFontIndex -= s_fonts.Length;
-        }
-
-        _rowHeaderFontIndex += 3;
-        if (_rowHeaderFontIndex >= s_fonts.Length)
-        {
-            _rowHeaderFontIndex -= s_fonts.Length;
-        }
-
-        dataGridView1.DefaultCellStyle.Font = s_fonts[_cellFontIndex];
-        dataGridView1.Rows[0].Cells[1].Value = s_fonts[_cellFontIndex];
-
-        dataGridView1.ColumnHeadersDefaultCellStyle.Font = s_fonts[_columnHeaderFontIndex];
-        dataGridView1.Rows[1].Cells[1].Value = s_fonts[_columnHeaderFontIndex];
-
-        dataGridView1.RowHeadersDefaultCellStyle.Font = s_fonts[_rowHeaderFontIndex];
-        dataGridView1.Rows[2].Cells[1].Value = s_fonts[_rowHeaderFontIndex];
-    }
-
-    private void resetFontButton_Click(object sender, EventArgs e)
-    {
-        dataGridView1.DefaultCellStyle.Font = null;
-        dataGridView1.ColumnHeadersDefaultCellStyle.Font = null;
-        dataGridView1.RowHeadersDefaultCellStyle.Font = null;
-    }
-
-    private void numericUpDown1_ValueChanged(object sender, EventArgs e)
-    {
-        Font = new Font("Tahoma", (float)numericUpDown1.Value, FontStyle.Regular);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.resx
deleted file mode 100644
index 6b21d20960e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DataGridViewTest.resx
+++ /dev/null
@@ -1,79 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="Column1.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column2.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column3.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column1.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column2.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <metadata name="Column3.UserAddedColumn" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.Designer.cs
deleted file mode 100644
index 4e0bb3cf282..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.Designer.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-partial class DateTimePicker
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.dateTimePicker1 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker2 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker3 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker4 = new System.Windows.Forms.DateTimePicker();
-        this.dateTimePicker5 = new System.Windows.Forms.DateTimePicker();
-        this.SuspendLayout();
-        // 
-        // dateTimePicker1
-        // 
-        this.dateTimePicker1.Location = new Point(31, 32);
-        this.dateTimePicker1.Margin = new Padding(4, 3, 4, 3);
-        this.dateTimePicker1.Name = "dateTimePicker1";
-        this.dateTimePicker1.Size = new Size(233, 23);
-        this.dateTimePicker1.TabIndex = 1;
-        this.dateTimePicker1.ShowCheckBox = true;
-        // 
-        // dateTimePicker2
-        // 
-        this.dateTimePicker2.Format = DateTimePickerFormat.Long;
-        this.dateTimePicker2.Location = new Point(31, 78);
-        this.dateTimePicker2.Margin = new Padding(4, 3, 4, 3);
-        this.dateTimePicker2.Name = "dateTimePicker2";
-        this.dateTimePicker2.Size = new Size(233, 23);
-        this.dateTimePicker2.TabIndex = 2;
-        this.dateTimePicker2.ShowCheckBox = true;
-        this.dateTimePicker2.ShowUpDown = true;
-        // 
-        // dateTimePicker3
-        // 
-        this.dateTimePicker3.Format = DateTimePickerFormat.Short;
-        this.dateTimePicker3.Location = new Point(31, 128);
-        this.dateTimePicker3.Margin = new Padding(4, 3, 4, 3);
-        this.dateTimePicker3.Name = "dateTimePicker3";
-        this.dateTimePicker3.Size = new Size(233, 23);
-        this.dateTimePicker3.TabIndex = 3;
-        this.dateTimePicker3.ShowCheckBox = true;
-        // 
-        // dateTimePicker4
-        // 
-        this.dateTimePicker4.Format = DateTimePickerFormat.Time;
-        this.dateTimePicker4.Location = new Point(31, 175);
-        this.dateTimePicker4.Margin = new Padding(4, 3, 4, 3);
-        this.dateTimePicker4.Name = "dateTimePicker4";
-        this.dateTimePicker4.Size = new Size(233, 23);
-        this.dateTimePicker4.TabIndex = 4;
-        this.dateTimePicker4.ShowCheckBox = true;
-        // 
-        // dateTimePicker5
-        // 
-        this.dateTimePicker5.Format = DateTimePickerFormat.Custom;
-        this.dateTimePicker5.Location = new Point(31, 221);
-        this.dateTimePicker5.Margin = new Padding(4, 3, 4, 3);
-        this.dateTimePicker5.Name = "dateTimePicker5";
-        this.dateTimePicker5.Size = new Size(233, 23);
-        this.dateTimePicker5.TabIndex = 5;
-        this.dateTimePicker5.ShowCheckBox = true;
-        // 
-        // DateTimePicker
-        // 
-        this.AutoScaleDimensions = new SizeF(7F, 15F);
-        this.AutoScaleMode = AutoScaleMode.Font;
-        this.ClientSize = new Size(331, 301);
-        this.Controls.Add(dateTimePicker5);
-        this.Controls.Add(dateTimePicker4);
-        this.Controls.Add(dateTimePicker3);
-        this.Controls.Add(dateTimePicker2);
-        this.Controls.Add(dateTimePicker1);
-        this.Margin = new Padding(4, 3, 4, 3);
-        this.Name = "DateTimePicker";
-        this.Text = "DateTimePicker";
-        this.ResumeLayout(false);
-    }
-
-    #endregion
-
-    private System.Windows.Forms.DateTimePicker dateTimePicker1;
-    private System.Windows.Forms.DateTimePicker dateTimePicker2;
-    private System.Windows.Forms.DateTimePicker dateTimePicker3;
-    private System.Windows.Forms.DateTimePicker dateTimePicker4;
-    private System.Windows.Forms.DateTimePicker dateTimePicker5;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.cs
deleted file mode 100644
index a5dac2ee1b9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DateTimePicker.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class DateTimePicker : Form
-{
-    public DateTimePicker()
-    {
-        InitializeComponent();
-        this.dateTimePicker5.CustomFormat = "yyyy-MM-dd HH:mm:ss";
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.Designer.cs
deleted file mode 100644
index a9e5242bad0..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.Designer.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class DesignTimeAligned
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.label1 = new System.Windows.Forms.Label();
-        this.label2 = new System.Windows.Forms.Label();
-        this.button1 = new System.Windows.Forms.Button();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.currentDPILabel1 = new WinformsControlsTest.CurrentDPILabel();
-        this.SuspendLayout();
-        //
-        // label1
-        //
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(72, 18);
-        this.label1.Margin = new System.Windows.Forms.Padding(6, 0, 6, 0);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(36, 25);
-        this.label1.TabIndex = 0;
-        this.label1.Text = "LL";
-        this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
-        //
-        // label2
-        //
-        this.label2.AutoSize = true;
-        this.label2.Location = new System.Drawing.Point(72, 76);
-        this.label2.Margin = new System.Windows.Forms.Padding(6, 0, 6, 0);
-        this.label2.Name = "label2";
-        this.label2.Size = new System.Drawing.Size(36, 25);
-        this.label2.TabIndex = 2;
-        this.label2.Text = "LL";
-        this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
-        //
-        // button1
-        //
-        this.button1.Location = new System.Drawing.Point(122, 66);
-        this.button1.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(60, 46);
-        this.button1.TabIndex = 3;
-        this.button1.Text = "LL";
-        this.button1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
-        this.button1.UseVisualStyleBackColor = true;
-        //
-        // textBox1
-        //
-        this.textBox1.Location = new System.Drawing.Point(122, 12);
-        this.textBox1.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(56, 31);
-        this.textBox1.TabIndex = 4;
-        this.textBox1.Text = "LLL";
-        //
-        // currentDPILabel1
-        //
-        this.currentDPILabel1.AutoSize = true;
-        this.currentDPILabel1.Location = new System.Drawing.Point(25, 159);
-        this.currentDPILabel1.Name = "currentDPILabel1";
-        this.currentDPILabel1.Size = new System.Drawing.Size(178, 25);
-        this.currentDPILabel1.TabIndex = 5;
-        this.currentDPILabel1.Text = "currentDPILabel1";
-        //
-        // DesignTimeAligned
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(192F, 192F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(490, 196);
-        this.Controls.Add(this.currentDPILabel1);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.button1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.label1);
-        this.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.Name = "DesignTimeAligned";
-        this.Text = "DesignTime Aligned";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.TextBox textBox1;
-    private CurrentDPILabel currentDPILabel1;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.cs
deleted file mode 100644
index 4c32a417b62..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class DesignTimeAligned : Form
-{
-    public DesignTimeAligned()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DesignTimeAligned.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ClientGuidConverter.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ClientGuidConverter.cs
deleted file mode 100644
index 4ca709fe6cf..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ClientGuidConverter.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.Globalization;
-
-namespace WinformsControlsTest;
-
-public partial class Dialogs
-{
-    /// <summary>
-    /// Provides a predefined set of GUIDs to chose from in order to configure <see cref="ExposedClientGuidMetadata.ClientGuid"/>.
-    /// </summary>
-    private sealed class ClientGuidConverter : GuidConverter
-    {
-        private StandardValuesCollection? _values;
-
-        public override bool GetStandardValuesSupported(ITypeDescriptorContext? context) => true;
-        public override bool GetStandardValuesExclusive(ITypeDescriptorContext? context) => true;
-
-        public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
-        {
-            // base class is for plain Guid, but ClientGuid is nullable Guid, which we need to implement separately
-            if ((value is null) || (value is string str && str.Length == 0))
-                return null;
-
-            return base.ConvertFrom(context, culture, value);
-        }
-
-        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext? context)
-        {
-            // chose from two GUIDs we pregenerated for testing
-            _values ??= new StandardValuesCollection(new Guid?[]
-            {
-                    null,
-                    new Guid("38EA9AE9-13BE-4992-9482-DAD370894BBD"),
-                    new Guid("46DFEE70-A89E-4D9A-8842-6D46DBC1F195"),
-            });
-
-            return _values;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.Designer.cs
deleted file mode 100644
index 5331c6f2703..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.Designer.cs
+++ /dev/null
@@ -1,174 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class Dialogs
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.resources = new System.ComponentModel.ComponentResourceManager(typeof(Dialogs));
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.btnSaveFileDialog = new System.Windows.Forms.Button();
-        this.btnOpenFileDialog = new System.Windows.Forms.Button();
-        this.btnColorDialog = new System.Windows.Forms.Button();
-        this.btnThreadExceptionDialog = new System.Windows.Forms.Button();
-        this.btnPrintDialog = new System.Windows.Forms.Button();
-        this.btnFolderBrowserDialog = new System.Windows.Forms.Button();
-        this.flowLayoutPanel1 = new System.Windows.Forms.FlowLayoutPanel();
-        this.openFileDialog1 = new System.Windows.Forms.OpenFileDialog();
-        this.printDialog1 = new System.Windows.Forms.PrintDialog();
-        this.saveFileDialog1 = new System.Windows.Forms.SaveFileDialog();
-        this.folderBrowserDialog1 = new System.Windows.Forms.FolderBrowserDialog();
-        this.flowLayoutPanel1.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // propertyGrid1
-        // 
-        this.propertyGrid1.CommandsBorderColor = System.Drawing.SystemColors.Control;
-        this.propertyGrid1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.propertyGrid1.Location = new System.Drawing.Point(171, 0);
-        this.propertyGrid1.Margin = new System.Windows.Forms.Padding(2);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(332, 430);
-        this.propertyGrid1.TabIndex = 0;
-        this.propertyGrid1.SelectedObjectsChanged += new System.EventHandler(this.propertyGrid1_SelectedObjectsChanged);
-        // 
-        // btnOpenFileDialog
-        // 
-        this.btnOpenFileDialog.Location = new System.Drawing.Point(3, 3);
-        this.btnOpenFileDialog.Name = "btnOpenFileDialog";
-        this.btnOpenFileDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnOpenFileDialog.TabIndex = 1;
-        this.btnOpenFileDialog.Text = "Open &file dialog";
-        this.btnOpenFileDialog.UseVisualStyleBackColor = true;
-        this.btnOpenFileDialog.Click += new System.EventHandler(this.btnOpenFileDialog_Click);
-        // 
-        // btnColorDialog
-        // 
-        this.btnColorDialog.Location = new System.Drawing.Point(3, 32);
-        this.btnColorDialog.Name = "btnColorDialog";
-        this.btnColorDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnColorDialog.TabIndex = 2;
-        this.btnColorDialog.Text = "&Color dialog";
-        this.btnColorDialog.UseVisualStyleBackColor = true;
-        this.btnColorDialog.Click += new System.EventHandler(this.btnColorDialog_Click);
-        // 
-        // btnThreadExceptionDialog
-        // 
-        this.btnThreadExceptionDialog.Location = new System.Drawing.Point(3, 32);
-        this.btnThreadExceptionDialog.Name = "btnThreadExceptionDialog";
-        this.btnThreadExceptionDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnThreadExceptionDialog.TabIndex = 2;
-        this.btnThreadExceptionDialog.Text = "&Thread exception dialog";
-        this.btnThreadExceptionDialog.UseVisualStyleBackColor = true;
-        this.btnThreadExceptionDialog.Click += new System.EventHandler(this.btnThreadExceptionDialog_Click);
-        // 
-        // btnPrintDialog
-        // 
-        this.btnPrintDialog.Location = new System.Drawing.Point(3, 32);
-        this.btnPrintDialog.Name = "btnPrintDialog";
-        this.btnPrintDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnPrintDialog.TabIndex = 3;
-        this.btnPrintDialog.Text = "&Print dialog";
-        this.btnPrintDialog.UseVisualStyleBackColor = true;
-        this.btnPrintDialog.Click += new System.EventHandler(this.btnPrintDialog_Click);
-        // 
-        // btnFolderBrowserDialog
-        // 
-        this.btnFolderBrowserDialog.Location = new System.Drawing.Point(3, 61);
-        this.btnFolderBrowserDialog.Name = "btnFolderBrowserDialog";
-        this.btnFolderBrowserDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnFolderBrowserDialog.TabIndex = 4;
-        this.btnFolderBrowserDialog.Text = "Folder &browser dialog";
-        this.btnFolderBrowserDialog.UseVisualStyleBackColor = true;
-        this.btnFolderBrowserDialog.Click += new System.EventHandler(this.btnFolderBrowserDialog_Click);
-        // 
-        // btnSaveFileDialog
-        // 
-        this.btnSaveFileDialog.Location = new System.Drawing.Point(3, 3);
-        this.btnSaveFileDialog.Name = "btnSaveFileDialog";
-        this.btnSaveFileDialog.Size = new System.Drawing.Size(163, 23);
-        this.btnSaveFileDialog.TabIndex = 5;
-        this.btnSaveFileDialog.Text = "&Save file dialog";
-        this.btnSaveFileDialog.UseVisualStyleBackColor = true;
-        this.btnSaveFileDialog.Click += new System.EventHandler(this.btnSaveFileDialog_Click);
-        // 
-        // flowLayoutPanel1
-        // 
-        this.flowLayoutPanel1.Controls.Add(this.btnColorDialog);
-        this.flowLayoutPanel1.Controls.Add(this.btnThreadExceptionDialog);
-        this.flowLayoutPanel1.Controls.Add(this.btnPrintDialog);
-        this.flowLayoutPanel1.Controls.Add(this.btnFolderBrowserDialog);
-        this.flowLayoutPanel1.Controls.Add(this.btnOpenFileDialog);
-        this.flowLayoutPanel1.Controls.Add(this.btnSaveFileDialog);
-        this.flowLayoutPanel1.Dock = System.Windows.Forms.DockStyle.Left;
-        this.flowLayoutPanel1.Location = new System.Drawing.Point(0, 0);
-        this.flowLayoutPanel1.Name = "flowLayoutPanel1";
-        this.flowLayoutPanel1.Size = new System.Drawing.Size(171, 430);
-        this.flowLayoutPanel1.TabIndex = 3;
-        // 
-        // openFileDialog1
-        // 
-        this.openFileDialog1.FileName = "openFileDialog1";
-        // 
-        // folderBrowserDialog1
-        // 
-        this.folderBrowserDialog1.Description = "Open global dotnet folder";
-        this.folderBrowserDialog1.InitialDirectory = "C:\\Program Files\\dotnet";
-        this.folderBrowserDialog1.ShowNewFolderButton = false;
-        this.folderBrowserDialog1.UseDescriptionForTitle = true;
-        // 
-        // Dialogs
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(503, 430);
-        this.Controls.Add(this.propertyGrid1);
-        this.Controls.Add(this.flowLayoutPanel1);
-        this.Name = "Dialogs";
-        this.Text = "Dialogs Test";
-        this.flowLayoutPanel1.ResumeLayout(false);
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-    private System.Windows.Forms.Button btnSaveFileDialog;
-    private System.Windows.Forms.Button btnOpenFileDialog;
-    private System.Windows.Forms.Button btnColorDialog;
-    private System.Windows.Forms.Button btnThreadExceptionDialog;
-    private System.Windows.Forms.Button btnPrintDialog;
-    private System.Windows.Forms.Button btnFolderBrowserDialog;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel1;
-    private System.Windows.Forms.OpenFileDialog openFileDialog1;
-    private System.Windows.Forms.SaveFileDialog saveFileDialog1;
-    private System.Windows.Forms.PrintDialog printDialog1;
-    private System.Windows.Forms.FolderBrowserDialog folderBrowserDialog1;
-    private System.ComponentModel.ComponentResourceManager resources;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ExposedClientGuidMetadata.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ExposedClientGuidMetadata.cs
deleted file mode 100644
index b4d619c5117..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.ExposedClientGuidMetadata.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-
-namespace WinformsControlsTest;
-
-public partial class Dialogs
-{
-    /// <summary>
-    /// Changes the <see cref="ClientGuid"/> metadata to be configurable in the <see cref="PropertyGrid"/> used
-    /// to prepare tests of <see cref="System.Windows.Forms.FileDialog"/> and <see cref="FolderBrowserDialog"/>.
-    /// </summary>
-    private sealed class ExposedClientGuidMetadata
-    {
-        [Browsable(true)]
-        [TypeConverter(typeof(ClientGuidConverter))]
-        public Guid? ClientGuid { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.cs
deleted file mode 100644
index 247f6f78f3a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.ComponentModel.DataAnnotations;
-using System.Drawing;
-using System.Drawing.Design;
-
-namespace WinformsControlsTest;
-
-public partial class Dialogs : Form
-{
-    private readonly ToolStripButton _btnOpen;
-
-    public Dialogs()
-    {
-        InitializeComponent();
-
-        // expose ClientGuid to be configurable in the property grid by overriding the metadata, but only for these specific instance of the dialogs, not in general
-        TypeDescriptor.AddProvider(new AssociatedMetadataTypeTypeDescriptionProvider(openFileDialog1.GetType(), typeof(ExposedClientGuidMetadata)), openFileDialog1);
-        TypeDescriptor.AddProvider(new AssociatedMetadataTypeTypeDescriptionProvider(saveFileDialog1.GetType(), typeof(ExposedClientGuidMetadata)), saveFileDialog1);
-        TypeDescriptor.AddProvider(new AssociatedMetadataTypeTypeDescriptionProvider(folderBrowserDialog1.GetType(), typeof(ExposedClientGuidMetadata)), folderBrowserDialog1);
-
-        _btnOpen = new("&Open dialog")
-        {
-            Image = (Bitmap?)resources.GetObject("OpenDialog"),
-            Enabled = false,
-        };
-
-        _btnOpen.Click += (s, e) =>
-        {
-            if (propertyGrid1.SelectedObject is CommonDialog dialog)
-            {
-                dialog.ShowDialog(this);
-                return;
-            }
-
-            if (propertyGrid1.SelectedObject is Form form)
-            {
-                form.ShowDialog(this);
-                return;
-            }
-        };
-
-        ToolStrip toolbar = GetToolbar();
-        toolbar.Items.Add(new ToolStripSeparator { Visible = true });
-        toolbar.Items.Add(_btnOpen);
-    }
-
-    private void DisposeIfNeeded()
-    {
-        if (propertyGrid1.SelectedObject is IDisposable disposable)
-        {
-            disposable.Dispose();
-        }
-    }
-
-    private ToolStrip GetToolbar()
-    {
-        foreach (Control control in propertyGrid1.Controls)
-        {
-            ToolStrip? toolStrip = control as ToolStrip;
-            if (toolStrip is not null)
-            {
-                return toolStrip;
-            }
-        }
-
-        throw new MissingMemberException("Unable to find the toolstrip in the PropertyGrid.");
-    }
-
-    private void btnColorDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = null;
-
-        Type? typeCustomColorDialog = typeof(ColorEditor).Assembly.GetTypes().SingleOrDefault(t => t.Name == "CustomColorDialog");
-        if (typeCustomColorDialog is null)
-        {
-            throw new Exception("Unable to locate 'CustomColorDialog' type.");
-        }
-
-        using ColorDialog dialog = (ColorDialog)Activator.CreateInstance(typeCustomColorDialog)!;
-        dialog.ShowDialog(this);
-    }
-
-    private void btnOpenFileDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = openFileDialog1;
-    }
-
-    private void btnSaveFileDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = saveFileDialog1;
-    }
-
-    private void btnFolderBrowserDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = folderBrowserDialog1;
-    }
-
-    private void btnPrintDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = printDialog1;
-    }
-
-    private void btnThreadExceptionDialog_Click(object sender, EventArgs e)
-    {
-        DisposeIfNeeded();
-        propertyGrid1.SelectedObject = null;
-
-        using ThreadExceptionDialog dialog = new(new Exception("Really long exception description string, because we want to see if it properly wraps around or is truncated."));
-        dialog.ShowDialog(this);
-    }
-
-    private void propertyGrid1_SelectedObjectsChanged(object sender, EventArgs e)
-    {
-        _btnOpen.Enabled = propertyGrid1.SelectedObject is not null;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.resx
deleted file mode 100644
index 673fcd2cf80..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Dialogs.resx
+++ /dev/null
@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="OpenDialog" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>Resources\OpenDialog.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.Designer.cs
deleted file mode 100644
index bc7be2fdd70..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.Designer.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace WinformsControlsTest;
-
-partial class DockLayoutTests
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.button1 = new System.Windows.Forms.Button();
-        this.button3 = new System.Windows.Forms.Button();
-        this.button2 = new System.Windows.Forms.Button();
-        this.button4 = new System.Windows.Forms.Button();
-        this.button5 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // button1
-        // 
-        this.button1.Dock = System.Windows.Forms.DockStyle.Left;
-        this.button1.Location = new System.Drawing.Point(0, 0);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(112, 450);
-        this.button1.TabIndex = 0;
-        this.button1.Text = "Left";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // button3
-        // 
-        this.button3.Dock = System.Windows.Forms.DockStyle.Right;
-        this.button3.Location = new System.Drawing.Point(688, 0);
-        this.button3.Name = "button3";
-        this.button3.Size = new System.Drawing.Size(112, 450);
-        this.button3.TabIndex = 2;
-        this.button3.Text = "Right";
-        this.button3.UseVisualStyleBackColor = true;
-        // 
-        // button2
-        // 
-        this.button2.Dock = System.Windows.Forms.DockStyle.Top;
-        this.button2.Location = new System.Drawing.Point(112, 0);
-        this.button2.Name = "button2";
-        this.button2.Size = new System.Drawing.Size(576, 89);
-        this.button2.TabIndex = 3;
-        this.button2.Text = "Top";
-        this.button2.UseVisualStyleBackColor = true;
-        // 
-        // button4
-        // 
-        this.button4.Dock = System.Windows.Forms.DockStyle.Bottom;
-        this.button4.Location = new System.Drawing.Point(112, 384);
-        this.button4.Name = "button4";
-        this.button4.Size = new System.Drawing.Size(576, 66);
-        this.button4.TabIndex = 4;
-        this.button4.Text = "Bottom";
-        this.button4.UseVisualStyleBackColor = true;
-        // 
-        // button5
-        // 
-        this.button5.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.button5.Location = new System.Drawing.Point(112, 89);
-        this.button5.Name = "button5";
-        this.button5.Size = new System.Drawing.Size(576, 295);
-        this.button5.TabIndex = 5;
-        this.button5.Text = "Fill";
-        this.button5.UseVisualStyleBackColor = true;
-        // 
-        // DockLayoutTests
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(10F, 25F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Controls.Add(this.button5);
-        this.Controls.Add(this.button4);
-        this.Controls.Add(this.button2);
-        this.Controls.Add(this.button3);
-        this.Controls.Add(this.button1);
-        this.Name = "DockLayoutTests";
-        this.Text = "DockLayoutTests";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private Button button1;
-    private Button button3;
-    private Button button2;
-    private Button button4;
-    private Button button5;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.cs
deleted file mode 100644
index 69692204d1a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class DockLayoutTests : Form
-{
-    public DockLayoutTests()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DockLayoutTests.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.Designer.cs
deleted file mode 100644
index be2c24a55c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.Designer.cs
+++ /dev/null
@@ -1,226 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class DragDrop
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
-        this.textBox = new System.Windows.Forms.TextBox();
-        this.richTextBox = new System.Windows.Forms.RichTextBox();
-        this.pictureBox1 = new System.Windows.Forms.PictureBox();
-        this.pictureBox2 = new System.Windows.Forms.PictureBox();
-        this.pictureBox3 = new System.Windows.Forms.PictureBox();
-        this.pictureBox4 = new System.Windows.Forms.PictureBox();
-        this.pictureBox5 = new System.Windows.Forms.PictureBox();
-        this.tableLayoutPanel2 = new System.Windows.Forms.TableLayoutPanel();
-        this.buttonOpenCats = new System.Windows.Forms.Button();
-        this.buttonClear = new System.Windows.Forms.Button();
-        this.tableLayoutPanel1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).BeginInit();
-        this.tableLayoutPanel2.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // tableLayoutPanel1
-        // 
-        this.tableLayoutPanel1.ColumnCount = 3;
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 115F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 55.55556F));
-        this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 44.44445F));
-        this.tableLayoutPanel1.Controls.Add(this.textBox, 2, 0);
-        this.tableLayoutPanel1.Controls.Add(this.richTextBox, 1, 0);
-        this.tableLayoutPanel1.Controls.Add(this.pictureBox1, 0, 0);
-        this.tableLayoutPanel1.Controls.Add(this.pictureBox2, 0, 1);
-        this.tableLayoutPanel1.Controls.Add(this.pictureBox3, 0, 2);
-        this.tableLayoutPanel1.Controls.Add(this.pictureBox4, 0, 3);
-        this.tableLayoutPanel1.Controls.Add(this.pictureBox5, 0, 4);
-        this.tableLayoutPanel1.Controls.Add(this.tableLayoutPanel2, 2, 5);
-        this.tableLayoutPanel1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.tableLayoutPanel1.Location = new System.Drawing.Point(0, 0);
-        this.tableLayoutPanel1.Name = "tableLayoutPanel1";
-        this.tableLayoutPanel1.RowCount = 6;
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 112F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 112F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 112F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 112F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 112F));
-        this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F));
-        this.tableLayoutPanel1.Size = new System.Drawing.Size(1226, 674);
-        this.tableLayoutPanel1.TabIndex = 0;
-        // 
-        // textBox
-        // 
-        this.textBox.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.textBox.Font = new System.Drawing.Font("Segoe UI", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
-        this.textBox.Location = new System.Drawing.Point(742, 3);
-        this.textBox.Multiline = true;
-        this.textBox.Name = "textBox";
-        this.tableLayoutPanel1.SetRowSpan(this.textBox, 5);
-        this.textBox.Size = new System.Drawing.Size(481, 619);
-        this.textBox.TabIndex = 18;
-        // 
-        // richTextBox
-        // 
-        this.richTextBox.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.richTextBox.Font = new System.Drawing.Font("Segoe UI", 14.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
-        this.richTextBox.Location = new System.Drawing.Point(134, 3);
-        this.richTextBox.Name = "richTextBox";
-        this.tableLayoutPanel1.SetRowSpan(this.richTextBox, 5);
-        this.richTextBox.Size = new System.Drawing.Size(602, 619);
-        this.richTextBox.TabIndex = 22;
-        this.richTextBox.Text = "";
-        // 
-        // pictureBox1
-        // 
-        this.pictureBox1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.pictureBox1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.pictureBox1.InitialImage = null;
-        this.pictureBox1.Location = new System.Drawing.Point(3, 3);
-        this.pictureBox1.Name = "pictureBox1";
-        this.pictureBox1.Size = new System.Drawing.Size(125, 119);
-        this.pictureBox1.TabIndex = 13;
-        this.pictureBox1.TabStop = false;
-        // 
-        // pictureBox2
-        // 
-        this.pictureBox2.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.pictureBox2.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.pictureBox2.InitialImage = null;
-        this.pictureBox2.Location = new System.Drawing.Point(3, 128);
-        this.pictureBox2.Name = "pictureBox2";
-        this.pictureBox2.Size = new System.Drawing.Size(125, 119);
-        this.pictureBox2.TabIndex = 13;
-        this.pictureBox2.TabStop = false;
-        // 
-        // pictureBox3
-        // 
-        this.pictureBox3.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.pictureBox3.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.pictureBox3.InitialImage = null;
-        this.pictureBox3.Location = new System.Drawing.Point(3, 253);
-        this.pictureBox3.Name = "pictureBox3";
-        this.pictureBox3.Size = new System.Drawing.Size(125, 119);
-        this.pictureBox3.TabIndex = 13;
-        this.pictureBox3.TabStop = false;
-        // 
-        // pictureBox4
-        // 
-        this.pictureBox4.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.pictureBox4.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.pictureBox4.InitialImage = null;
-        this.pictureBox4.Location = new System.Drawing.Point(3, 378);
-        this.pictureBox4.Name = "pictureBox4";
-        this.pictureBox4.Size = new System.Drawing.Size(125, 119);
-        this.pictureBox4.TabIndex = 13;
-        this.pictureBox4.TabStop = false;
-        // 
-        // pictureBox5
-        // 
-        this.pictureBox5.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.pictureBox5.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.pictureBox5.InitialImage = null;
-        this.pictureBox5.Location = new System.Drawing.Point(3, 503);
-        this.pictureBox5.Name = "pictureBox5";
-        this.pictureBox5.Size = new System.Drawing.Size(125, 119);
-        this.pictureBox5.TabIndex = 13;
-        this.pictureBox5.TabStop = false;
-        // 
-        // tableLayoutPanel2
-        // 
-        this.tableLayoutPanel2.ColumnCount = 2;
-        this.tableLayoutPanel2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.Controls.Add(this.buttonOpenCats, 0, 0);
-        this.tableLayoutPanel2.Controls.Add(this.buttonClear, 1, 0);
-        this.tableLayoutPanel2.Dock = System.Windows.Forms.DockStyle.Right;
-        this.tableLayoutPanel2.Location = new System.Drawing.Point(1046, 628);
-        this.tableLayoutPanel2.Name = "tableLayoutPanel2";
-        this.tableLayoutPanel2.RowCount = 1;
-        this.tableLayoutPanel2.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
-        this.tableLayoutPanel2.Size = new System.Drawing.Size(177, 43);
-        this.tableLayoutPanel2.TabIndex = 23;
-        // 
-        // buttonOpenCats
-        // 
-        this.buttonOpenCats.Dock = System.Windows.Forms.DockStyle.Right;
-        this.buttonOpenCats.Location = new System.Drawing.Point(3, 3);
-        this.buttonOpenCats.Name = "buttonOpenCats";
-        this.buttonOpenCats.Size = new System.Drawing.Size(82, 37);
-        this.buttonOpenCats.TabIndex = 21;
-        this.buttonOpenCats.Text = "Open Cats";
-        this.buttonOpenCats.UseVisualStyleBackColor = true;
-        // 
-        // buttonClear
-        // 
-        this.buttonClear.Dock = System.Windows.Forms.DockStyle.Right;
-        this.buttonClear.Location = new System.Drawing.Point(92, 3);
-        this.buttonClear.Name = "buttonClear";
-        this.buttonClear.Size = new System.Drawing.Size(82, 37);
-        this.buttonClear.TabIndex = 20;
-        this.buttonClear.Text = "Clear";
-        this.buttonClear.UseVisualStyleBackColor = true;
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(1226, 625);
-        this.Controls.Add(this.tableLayoutPanel1);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        this.tableLayoutPanel1.ResumeLayout(false);
-        this.tableLayoutPanel1.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).EndInit();
-        this.tableLayoutPanel2.ResumeLayout(false);
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
-    private System.Windows.Forms.PictureBox pictureBox1;
-    private System.Windows.Forms.PictureBox pictureBox2;
-    private System.Windows.Forms.PictureBox pictureBox3;
-    private System.Windows.Forms.PictureBox pictureBox4;
-    private System.Windows.Forms.PictureBox pictureBox5;
-    private System.Windows.Forms.RichTextBox richTextBox;
-    private System.Windows.Forms.TextBox textBox;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel2;
-    private System.Windows.Forms.Button buttonClear;
-    private System.Windows.Forms.Button buttonOpenCats;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.cs
deleted file mode 100644
index 5b3b3fd8029..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.cs
+++ /dev/null
@@ -1,573 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class DragDrop : Form
-{
-    private const string DragDropDataDirectory = @"Data\DragDrop";
-    private const string NyanCatAsciiTxt = @"NyanCatAscii.txt";
-    private const string DragAcceptRtf = @"DragAccept.rtf";
-    private readonly string _nyanCatAscii = string.Empty;
-    private readonly Bitmap _dragAcceptBmp = new(@"Data\DragDrop\DragAccept.bmp");
-    private readonly Bitmap _nyanCatAscii301Bmp = new(@"Data\DragDrop\NyanCatAscii_301.bmp");
-    private readonly Bitmap _nyanCatBmp = new(@"Data\DragDrop\NyanCat1.bmp");
-    private readonly Bitmap _toolStripAsciiCatBmp = new(@"Data\DragDrop\ToolStripAsciiCat.bmp");
-    private readonly Bitmap _toolStripDragAcceptBmp = new(@"Data\DragDrop\ToolStripDragAccept.bmp");
-    private readonly Bitmap _toolStripNyanCatBmp = new(@"Data\DragDrop\ToolStripNyanCat.bmp");
-    private readonly List<PictureBox> _pictureBoxList;
-    private ContextMenuStrip? _catContextMenuStrip;
-
-    public DragDrop()
-    {
-        InitializeComponent();
-
-        _nyanCatAscii = ReadAsciiText();
-        _pictureBoxList = new()
-        {
-            pictureBox1,
-            pictureBox2,
-            pictureBox3,
-            pictureBox4,
-            pictureBox5
-        };
-
-        AllowDrop = true;
-        DragEnter += DragDrop_DragEnter;
-
-        pictureBox1.AllowDrop = true;
-        pictureBox1.DragEnter += PictureBox_DragEnter;
-        pictureBox1.DragDrop += PictureBox_DragDrop;
-        pictureBox1.MouseDown += PictureBox_MouseDown;
-        pictureBox1.GiveFeedback += PictureBox_GiveFeedback;
-
-        pictureBox2.AllowDrop = true;
-        pictureBox2.DragEnter += PictureBox_DragEnter;
-        pictureBox2.DragDrop += PictureBox_DragDrop;
-        pictureBox2.MouseDown += PictureBox_MouseDown;
-        pictureBox2.GiveFeedback += PictureBox_GiveFeedback;
-
-        pictureBox3.AllowDrop = true;
-        pictureBox3.DragEnter += PictureBox_DragEnter;
-        pictureBox3.DragDrop += PictureBox_DragDrop;
-        pictureBox3.MouseDown += PictureBox_MouseDown;
-        pictureBox3.GiveFeedback += PictureBox_GiveFeedback;
-
-        pictureBox4.AllowDrop = true;
-        pictureBox4.DragEnter += PictureBox_DragEnter;
-        pictureBox4.DragDrop += PictureBox_DragDrop;
-        pictureBox4.MouseDown += PictureBox_MouseDown;
-        pictureBox4.GiveFeedback += PictureBox_GiveFeedback;
-
-        pictureBox5.AllowDrop = true;
-        pictureBox5.DragEnter += PictureBox_DragEnter;
-        pictureBox5.DragDrop += PictureBox_DragDrop;
-        pictureBox5.MouseDown += PictureBox_MouseDown;
-        pictureBox5.GiveFeedback += PictureBox_GiveFeedback;
-
-        textBox.AllowDrop = true;
-        textBox.DragEnter += TextBox_DragEnter;
-        textBox.DragOver += TextBox_DragOver;
-        textBox.DragDrop += TextBox_DragDrop;
-
-        richTextBox.AllowDrop = true;
-        richTextBox.EnableAutoDragDrop = true;
-        richTextBox.DragEnter += RichTextBox_DragEnter;
-        richTextBox.DragDrop += RichTextBox_DragDrop;
-
-        buttonOpenCats.Click += new EventHandler(ButtonOpenCats_Click);
-        buttonClear.Click += new EventHandler(ButtonClear_Click);
-
-        CreateCatToolStrip();
-    }
-
-    private void ButtonClear_Click(object? sender, EventArgs e)
-    {
-        ClearCats();
-        richTextBox.Clear();
-        textBox.Clear();
-    }
-
-    private void ButtonOpenCats_Click(object? sender, EventArgs e)
-        => OpenCats();
-
-    private void DragDrop_DragEnter(object? sender, DragEventArgs e)
-    {
-        e.DropImageType = DropImageType.Warning;
-        e.Effect = DragDropEffects.None;
-    }
-
-    private void PictureBox_DragEnter(object? sender, DragEventArgs e)
-    {
-        if (sender is not PictureBox pictureBox || e.Data is null)
-        {
-            return;
-        }
-
-        if (e.Data.GetDataPresent(DataFormats.FileDrop)
-            && e.Data.GetData(DataFormats.FileDrop) is string[] files
-            && files.Length > 0 && files.Length <= 5)
-        {
-            if (files.All(file => file.Contains("NyanCat") && file.Contains(".bmp")))
-            {
-                // Set the target drop image to a plus sign (+).
-                e.DropImageType = DropImageType.Copy;
-
-                // Set the target drop text.
-                e.Message = $"{e.DropImageType} %1 from Explorer";
-                e.MessageReplacementToken = $"{(files.Length > 1 ? "Cats" : "Cat")}";
-
-                // Set the target drop effect.
-                e.Effect = DragDropEffects.Copy;
-            }
-            else if (files.Length == 1 && files.Any(file => file.Contains("DragAccept.rtf")))
-            {
-                // Set the target drop image to a red bisected circle.
-                e.DropImageType = DropImageType.None;
-
-                // Set the target drop text.
-                e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1";
-                e.MessageReplacementToken = Path.GetExtension(files[0]);
-
-                // Set the target drop effect.
-                e.Effect = DragDropEffects.None;
-            }
-        }
-        else if (e.Data.GetDataPresent(nameof(_nyanCatBmp)))
-        {
-            // Set the target drop image to a plus sign (+).
-            e.DropImageType = DropImageType.Copy;
-
-            // Set the target drop text.
-            e.Message = $"{e.DropImageType} %1 from WinForms";
-            e.MessageReplacementToken = "Cat";
-
-            // Set the target drop effect.
-            e.Effect = DragDropEffects.Copy;
-        }
-    }
-
-    private void PictureBox_DragDrop(object? sender, DragEventArgs e)
-    {
-        if (sender is PictureBox pictureBox && e.Data is not null)
-        {
-            if (e.Data.GetDataPresent(DataFormats.FileDrop)
-                && e.Data.GetData(DataFormats.FileDrop) is string[] files
-                && files.Length > 0 && files.Length <= 5
-                && files.All(file => file.Contains("NyanCat") && file.Contains(".bmp")))
-            {
-                LoadCats(pictureBox, files);
-            }
-            else if (e.Data.GetDataPresent(nameof(_nyanCatBmp))
-                && e.Data.GetData(nameof(_nyanCatBmp)) is Bitmap nyanCatBmp)
-            {
-                LoadCat(pictureBox, nyanCatBmp);
-            }
-        }
-    }
-
-    private void PictureBox_MouseDown(object? sender, MouseEventArgs e)
-    {
-        if (sender is PictureBox pictureBox)
-        {
-            // Create the ascii cat data object.
-            DataObject data = new(nameof(_nyanCatAscii), _nyanCatAscii);
-
-            // Call DoDragDrop and set the initial drag image.
-            // Set useDefaultDragImage to true to specify a layered drag image window with size 96x96.
-            pictureBox.DoDragDrop(data, DragDropEffects.All, _nyanCatBmp, new Point(0, 96), true);
-        }
-    }
-
-    private void PictureBox_GiveFeedback(object? sender, GiveFeedbackEventArgs e)
-    {
-        if (e.Effect.Equals(DragDropEffects.Copy))
-        {
-            // Specify a new drag image in GiveFeedback.
-            // Note the outer edges of the drag image are blended out if the image width or height exceeds 300 pixels.
-            e.DragImage = _nyanCatAscii301Bmp;
-
-            // Set the cursor to the bottom left-hand corner of the drag image.
-            e.CursorOffset = new Point(0, 111);
-
-            // Set UseDefaultDragImage to false to remove the 96x96 layered drag image window.
-            e.UseDefaultDragImage = false;
-        }
-        else
-        {
-            e.DragImage = _nyanCatBmp;
-            e.CursorOffset = new Point(0, 96);
-            e.UseDefaultDragImage = true;
-        }
-    }
-
-    private void TextBox_DragDrop(object? sender, DragEventArgs e)
-    {
-        if (e.Data is not null
-            && e.Data.GetDataPresent(nameof(_nyanCatAscii), false)
-            && e.Data.GetData(nameof(_nyanCatAscii)) is string asciiCat)
-        {
-            textBox.Text += textBox.Text.Length > 0
-                ? Environment.NewLine + Environment.NewLine + asciiCat
-                : asciiCat;
-        }
-
-        textBox.SelectionStart = textBox.Text.Length;
-        textBox.SelectionLength = 0;
-    }
-
-    private void TextBox_DragEnter(object? sender, DragEventArgs e)
-    {
-        e.Effect = DragDropEffects.None;
-
-        if (e.Data is null)
-        {
-            return;
-        }
-
-        if (e.Data.GetDataPresent(nameof(_nyanCatAscii)))
-        {
-            // Set the target drop image to a plus sign (+).
-            e.DropImageType = DropImageType.Copy;
-
-            // Set the target drop text.
-            e.Message = "Copy cat to %1";
-            e.MessageReplacementToken = "~=[,,_,,]:3";
-
-            // Set the target drop effect.
-            e.Effect = DragDropEffects.Copy;
-        }
-        else if (e.Data.GetDataPresent(nameof(_nyanCatBmp)))
-        {
-            e.DropImageType = DropImageType.None;
-            e.Message = "Nyan %1";
-            e.MessageReplacementToken = "Cat";
-            e.Effect = DragDropEffects.None;
-        }
-        else if (e.Data.GetDataPresent(DataFormats.FileDrop)
-            && e.Data.GetData(DataFormats.FileDrop) is string[] files
-            && files.Length > 0 && files[0].Contains("DragAccept.rtf"))
-        {
-            // Set the target drop image to a red bisected circle.
-            e.DropImageType = DropImageType.None;
-
-            // Set the target drop text.
-            e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1";
-            e.MessageReplacementToken = Path.GetExtension(files[0]);
-
-            // Set the target drop effect.
-            e.Effect = DragDropEffects.None;
-        }
-    }
-
-    private void TextBox_DragOver(object? sender, DragEventArgs e)
-    {
-        if (e.Data is null)
-        {
-            return;
-        }
-
-        if (e.Data.GetDataPresent(nameof(_nyanCatAscii)))
-        {
-            // Set the target drop image to a plus sign (+).
-            e.DropImageType = DropImageType.Copy;
-
-            // Set the target drop text.
-            e.Message = "Copy cat to %1";
-            e.MessageReplacementToken = "~=[,,_,,]:3";
-
-            // Set the target drop effect.
-            e.Effect = DragDropEffects.Copy;
-        }
-        else if (e.Data.GetDataPresent(nameof(_nyanCatBmp)))
-        {
-            e.DropImageType = DropImageType.None;
-            e.Message = "Nyan %1";
-            e.MessageReplacementToken = "Cat";
-            e.Effect = DragDropEffects.None;
-        }
-        else if (e.Data.GetDataPresent(DataFormats.FileDrop)
-            && e.Data.GetData(DataFormats.FileDrop) is string[] files
-            && files.Length > 0 && files[0].Contains("DragAccept.rtf"))
-        {
-            // Set the target drop image to a red bisected circle.
-            e.DropImageType = DropImageType.None;
-
-            // Set the target drop text.
-            e.Message = $"{Path.GetFileNameWithoutExtension(files[0])}%1";
-            e.MessageReplacementToken = Path.GetExtension(files[0]);
-
-            // Set the target drop effect.
-            e.Effect = DragDropEffects.None;
-        }
-    }
-
-    private void RichTextBox_DragEnter(object? sender, DragEventArgs e)
-    {
-        if (e.Data is null)
-        {
-            return;
-        }
-
-        if (e.Data.GetDataPresent(DataFormats.FileDrop)
-            && e.Data.GetDataPresent("FileName")
-            && e.Data.GetData("FileName") is string[] fileNames
-            && fileNames.Length > 0 && fileNames[0].Contains("DragAccept.rtf"))
-        {
-            e.DropImageType = DropImageType.Link;
-            e.Message = "%1 (shellapi.h)";
-            e.MessageReplacementToken = "DragAcceptFiles";
-            e.Effect = DragDropEffects.Link;
-        }
-        else if (e.Data.GetDataPresent(nameof(_nyanCatAscii)))
-        {
-            e.DropImageType = DropImageType.None;
-            e.Message = "Ascii %1";
-            e.MessageReplacementToken = "Cat";
-            e.Effect = DragDropEffects.None;
-        }
-        else if (e.Data.GetDataPresent(nameof(_nyanCatBmp)))
-        {
-            e.DropImageType = DropImageType.None;
-            e.Message = "Nyan %1";
-            e.MessageReplacementToken = "Cat";
-            e.Effect = DragDropEffects.None;
-        }
-    }
-
-    private void RichTextBox_DragDrop(object? sender, DragEventArgs e)
-    {
-        if (e.Data is not null
-            && e.Data.GetDataPresent(DataFormats.FileDrop)
-            && e.Data.GetDataPresent("FileName")
-            && e.Data.GetData("FileName") is string[] fileNames
-            && fileNames.Length > 0 && fileNames[0].Contains("DragAccept.rtf"))
-        {
-            richTextBox.Clear();
-            richTextBox.LoadFile(fileNames[0], RichTextBoxStreamType.RichText);
-            e.Effect = DragDropEffects.None;
-        }
-    }
-
-    private void LoadCat(PictureBox pictureBox, Bitmap image)
-    {
-        pictureBox.Image = image;
-    }
-
-    private void LoadCats(PictureBox pictureBox, string[] bitmapFiles)
-    {
-        if (bitmapFiles.Length == 1)
-        {
-            LoadCat(pictureBox, new Bitmap(bitmapFiles[0]));
-        }
-        else
-        {
-            for (int i = 0; i < bitmapFiles.Length; i++)
-            {
-                if (_pictureBoxList[i] is not null)
-                {
-                    LoadCat(_pictureBoxList[i], new Bitmap(bitmapFiles[0]));
-                }
-            }
-        }
-    }
-
-    private void ClearCats()
-        => _pictureBoxList.ForEach(pb => pb.Image = null);
-
-    private void OpenCats()
-    {
-        string dragDropDataDirectory = Path.Combine(
-            Directory.GetCurrentDirectory(),
-            DragDropDataDirectory);
-
-        if (Directory.Exists(dragDropDataDirectory))
-        {
-            ProcessStartInfo startInfo = new()
-            {
-                Arguments = dragDropDataDirectory,
-                FileName = "explorer.exe"
-            };
-
-            Process.Start(startInfo);
-        }
-    }
-
-    private string ReadAsciiText()
-    {
-        string nyanCatAsciiPath = Path.Combine(
-            Directory.GetCurrentDirectory(),
-            DragDropDataDirectory,
-            NyanCatAsciiTxt);
-
-        try
-        {
-            return File.ReadAllText(nyanCatAsciiPath);
-        }
-        catch
-        {
-            return string.Empty;
-        }
-    }
-
-    private void CreateCatToolStrip()
-    {
-        TableLayoutPanel tableLayoutPanel = new()
-        {
-            ColumnCount = 1,
-            Dock = DockStyle.Top,
-            Height = 35,
-            RowCount = 1
-        };
-
-        tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize));
-
-        _catContextMenuStrip = new ContextMenuStrip
-        {
-            AllowDrop = true,
-            AutoSize = true,
-            ImageScalingSize = new Size(75, 75)
-        };
-
-        _catContextMenuStrip.Opening += new CancelEventHandler(ContextMenuStrip_Opening);
-
-        ToolStrip toolStrip = new()
-        {
-            Dock = DockStyle.Right,
-            GripStyle = ToolStripGripStyle.Hidden
-        };
-
-        ToolStripDropDownButton catToolStripDropDownButton = new()
-        {
-            AutoSize = false,
-            DropDown = _catContextMenuStrip,
-            Image = _toolStripNyanCatBmp,
-            Height = 35,
-            Name = "catToolStripDropDownButton",
-            Text = "Cats",
-            Width = 100
-        };
-
-        toolStrip.Items.Add(catToolStripDropDownButton);
-        tableLayoutPanel.Controls.Add(toolStrip, 0, 0);
-        Controls.Add(tableLayoutPanel);
-        ContextMenuStrip = _catContextMenuStrip;
-    }
-
-    void ContextMenuStrip_Opening(object? sender, CancelEventArgs e)
-    {
-        if (_catContextMenuStrip is null)
-        {
-            return;
-        }
-
-        _catContextMenuStrip.Items.Clear();
-
-        ToolStripItem dragAcceptItem = new ToolStripMenuItem()
-        {
-            AllowDrop = true,
-            ImageScaling = ToolStripItemImageScaling.SizeToFit,
-            Text = "DragAcceptFiles",
-            Name = "DragAcceptItem",
-            Image = _toolStripDragAcceptBmp
-        };
-        dragAcceptItem.DragEnter += DragAcceptItem_DragEnter;
-        dragAcceptItem.MouseDown += DragAcceptItem_MouseDown;
-
-        ToolStripItem nyanCatItem = new ToolStripMenuItem()
-        {
-            AllowDrop = true,
-            ImageScaling = ToolStripItemImageScaling.SizeToFit,
-            Text = "Nyan Cat",
-            Name = "NyanCatItem",
-            Image = _toolStripNyanCatBmp
-        };
-        nyanCatItem.DragEnter += NyanCatItem_DragEnter;
-        nyanCatItem.MouseDown += NyanCatItem_MouseDown;
-
-        ToolStripItem asciiCatItem = new ToolStripMenuItem()
-        {
-            AllowDrop = true,
-            ImageScaling = ToolStripItemImageScaling.SizeToFit,
-            Text = "Ascii Cat",
-            Name = "AsciiCatItem",
-            Image = _toolStripAsciiCatBmp
-        };
-        asciiCatItem.DragEnter += AsciiCatItem_DragEnter;
-        asciiCatItem.MouseDown += AsciiCatItem_MouseDown;
-
-        _catContextMenuStrip.Items.Add(dragAcceptItem);
-        _catContextMenuStrip.Items.Add(nyanCatItem);
-        _catContextMenuStrip.Items.Add(asciiCatItem);
-
-        e.Cancel = false;
-    }
-
-    private void DragAcceptItem_DragEnter(object? sender, DragEventArgs e)
-    {
-        e.DropImageType = DropImageType.Link;
-        e.Message = "DragAcceptFiles";
-        e.Effect = DragDropEffects.Link;
-    }
-
-    private void NyanCatItem_DragEnter(object? sender, DragEventArgs e)
-    {
-        e.DropImageType = DropImageType.Link;
-        e.Message = "NyanCat";
-        e.Effect = DragDropEffects.Link;
-    }
-
-    private void AsciiCatItem_DragEnter(object? sender, DragEventArgs e)
-    {
-        e.DropImageType = DropImageType.Link;
-        e.Message = "AsciiCat";
-        e.Effect = DragDropEffects.Link;
-    }
-
-    private void DragAcceptItem_MouseDown(object? sender, MouseEventArgs e)
-    {
-        if (sender is ToolStripItem toolStripItem)
-        {
-            // Create a DragAccept.rtf FileDrop data object.
-            DataObject data = new(DataFormats.FileDrop,
-                new string[]
-                {
-                    Path.Combine(Directory.GetCurrentDirectory(),
-                        DragDropDataDirectory,
-                        DragAcceptRtf)
-                });
-
-            // Call DoDragDrop and set the initial drag image.
-            toolStripItem.DoDragDrop(data, DragDropEffects.All, _dragAcceptBmp, new Point(0, 96), true);
-        }
-    }
-
-    private void NyanCatItem_MouseDown(object? sender, MouseEventArgs e)
-    {
-        if (sender is ToolStripItem toolStripItem)
-        {
-            // Create a nyan cat bitmap data object.
-            DataObject data = new(nameof(_nyanCatBmp), _nyanCatBmp);
-
-            // Call DoDragDrop and set the initial drag image.
-            toolStripItem.DoDragDrop(data, DragDropEffects.All, _nyanCatBmp, new Point(0, 96), true);
-        }
-    }
-
-    private void AsciiCatItem_MouseDown(object? sender, MouseEventArgs e)
-    {
-        if (sender is ToolStripItem toolStripItem)
-        {
-            // Create a string ascii cat data object.
-            DataObject data = new(nameof(_nyanCatAscii), _nyanCatAscii);
-
-            // Call DoDragDrop and set the initial drag image.
-            toolStripItem.DoDragDrop(data, DragDropEffects.All, _nyanCatAscii301Bmp, new Point(0, 111), false);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.resx
deleted file mode 100644
index f298a7be809..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/DragDrop.resx
+++ /dev/null
@@ -1,60 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.Designer.cs
deleted file mode 100644
index 3dfd76d86e1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.Designer.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ErrorProviderTest
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.errorProvider1 = new System.Windows.Forms.ErrorProvider(this.components);
-        this.submitButton = new System.Windows.Forms.Button();
-        this.label1 = new System.Windows.Forms.Label();
-        ((System.ComponentModel.ISupportInitialize)(this.errorProvider1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // textBox1
-        // 
-        this.textBox1.Location = new System.Drawing.Point(35, 60);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(120, 23);
-        this.textBox1.TabIndex = 0;
-        // 
-        // errorProvider1
-        // 
-        this.errorProvider1.ContainerControl = this;
-        // 
-        // submitButton
-        // 
-        this.submitButton.Location = new System.Drawing.Point(35, 109);
-        this.submitButton.Name = "submitButton";
-        this.submitButton.Size = new System.Drawing.Size(120, 27);
-        this.submitButton.TabIndex = 1;
-        this.submitButton.Text = "Submit";
-        this.submitButton.UseVisualStyleBackColor = true;
-        this.submitButton.Click += new System.EventHandler(this.submitButton_Click);
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(19, 26);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(155, 15);
-        this.label1.TabIndex = 2;
-        this.label1.Text = "Type from 5 to 10 characters";
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(194, 165);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.submitButton);
-        this.Controls.Add(this.textBox1);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        ((System.ComponentModel.ISupportInitialize)(this.errorProvider1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.ErrorProvider errorProvider1;
-    private System.Windows.Forms.Button submitButton;
-    private System.Windows.Forms.Label label1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.cs
deleted file mode 100644
index b5b98ac50cd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class ErrorProviderTest : Form
-{
-    public ErrorProviderTest()
-    {
-        InitializeComponent();
-    }
-
-    private void submitButton_Click(object sender, EventArgs e)
-    {
-        if (textBox1.TextLength < 5 || textBox1.TextLength > 10)
-        {
-            errorProvider1.SetError(textBox1, "The length of the testbox is invalid!");
-        }
-        else
-        {
-            errorProvider1.Clear();
-            MessageBox.Show("All right!", "OK", MessageBoxButtons.OK, MessageBoxIcon.Information);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ErrorProviderTest.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.Designer.cs
deleted file mode 100644
index 824b93b8a67..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.Designer.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-namespace WindowsFormsApp1;
-
-partial class FormBorderStyles
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.btnChangeFormBorderStyle = new System.Windows.Forms.Button();
-        this.lblFormBorderStyle = new System.Windows.Forms.Label();
-        this.SuspendLayout();
-        // 
-        // btnChangeFormBorderStyle
-        // 
-        this.btnChangeFormBorderStyle.Location = new System.Drawing.Point(13, 13);
-        this.btnChangeFormBorderStyle.Name = "btnChangeFormBorderStyle";
-        this.btnChangeFormBorderStyle.Size = new System.Drawing.Size(162, 23);
-        this.btnChangeFormBorderStyle.TabIndex = 0;
-        this.btnChangeFormBorderStyle.Text = "Change FormBorderStyle";
-        this.btnChangeFormBorderStyle.UseVisualStyleBackColor = true;
-        this.btnChangeFormBorderStyle.Click += new System.EventHandler(this.btnChangeFormBorderStyle_Click);
-        // 
-        // lblFormBorderStyle
-        // 
-        this.lblFormBorderStyle.AutoSize = true;
-        this.lblFormBorderStyle.Location = new System.Drawing.Point(13, 43);
-        this.lblFormBorderStyle.Name = "lblFormBorderStyle";
-        this.lblFormBorderStyle.Size = new System.Drawing.Size(0, 13);
-        this.lblFormBorderStyle.TabIndex = 1;
-        // 
-        // FormBorderStyles
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(349, 214);
-        this.Controls.Add(this.lblFormBorderStyle);
-        this.Controls.Add(this.btnChangeFormBorderStyle);
-        this.DoubleBuffered = true;
-        this.Name = "FormBorderStyles";
-        this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Show;
-        this.Text = "FormBorderStyles";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button btnChangeFormBorderStyle;
-    private System.Windows.Forms.Label lblFormBorderStyle;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.cs
deleted file mode 100644
index 1b07c4f2167..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WindowsFormsApp1;
-
-public partial class FormBorderStyles : Form
-{
-    public FormBorderStyles()
-    {
-        InitializeComponent();
-        ShowCurrentBorderStyle();
-    }
-
-    private void ShowCurrentBorderStyle()
-    {
-        lblFormBorderStyle.Text = $"Current border style: {FormBorderStyle}";
-    }
-
-    private void btnChangeFormBorderStyle_Click(object sender, EventArgs e)
-    {
-        var currentBorderStyle = (int)FormBorderStyle;
-        currentBorderStyle++;
-        if (currentBorderStyle > (int)FormBorderStyle.SizableToolWindow)
-        {
-            currentBorderStyle = 0;
-        }
-
-        FormBorderStyle = (FormBorderStyle)currentBorderStyle;
-        ShowCurrentBorderStyle();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormBorderStyles.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormOwnerTestForm.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormOwnerTestForm.cs
deleted file mode 100644
index 3689f234812..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormOwnerTestForm.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-internal class FormOwnerTestForm : Form
-{
-    public FormOwnerTestForm()
-    {
-        this.Shown += (object sender, EventArgs e) => RunFormOwnerMemoryLeakTest();
-    }
-
-    /// <summary>
-    /// This method runs a loop to open and close a parent form.
-    /// The parent form opens a child form.show(IWin32Window) overload.
-    /// The parent form is then closed, which also closes the child.
-    /// The output shows how much memory was used in the process and
-    /// can be used to check if a memory leak is present.
-    /// This is used to test the bug: https://github.com/dotnet/winforms/issues/530
-    /// </summary>
-    private void RunFormOwnerMemoryLeakTest()
-    {
-        long memoryStart = GC.GetTotalMemory(false);
-
-        List<Form> childForms = new();
-        for (int i = 0; i < 500; i++)
-        {
-            MemoryTestParentForm parent = new();
-            parent.Show();
-            childForms.Add(parent.CreateChildFormWithMemory());
-            parent.Close();
-        }
-
-        childForms.ForEach(childForm => childForm.Close());
-        childForms.Clear();
-
-        long memoryBeforeGC = GC.GetTotalMemory(false);
-        GC.Collect();
-        GC.WaitForPendingFinalizers();
-        GC.Collect();
-        long memoryAfterGC = GC.GetTotalMemory(true);
-
-        Controls.Add(new Label()
-        {
-            Text = $"Memory Usage:\nBefore: {memoryStart:N0} bytes\nDuring: {memoryBeforeGC:N0} bytes\nAfter: {memoryAfterGC:N0} bytes",
-            Dock = DockStyle.Fill,
-            TextAlign = ContentAlignment.MiddleCenter
-        });
-    }
-
-    public class MemoryTestParentForm : Form
-    {
-        private byte[] array;
-
-        public Form CreateChildFormWithMemory()
-        {
-            // Create a byte array to consume memory on the parent so the leak is more obvious.
-            this.array = new byte[1024 * 1024];
-            Array.Clear(array, 0, this.array.Length);
-            Form child = new();
-
-            // Show the child and pass the parent as the owner, this is where the leak can happen.
-            child.Show(this);
-            return child;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormShowInTaskbar.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormShowInTaskbar.cs
deleted file mode 100644
index 0f3fc4858fd..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/FormShowInTaskbar.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public class FormShowInTaskbar : Form
-{
-    public FormShowInTaskbar()
-    {
-        Width = 600;
-        Height = 460;
-        StartPosition = FormStartPosition.CenterScreen;
-
-        var btnTest = new Button()
-        {
-            Text = "Click here to open new Form",
-            Location = new Point(10, 10),
-            Height = 60,
-            AutoSize = true,
-        };
-
-        btnTest.Click += BtnTest_Click;
-        Controls.Add(btnTest);
-    }
-
-    private void BtnTest_Click(object sender, EventArgs e)
-    {
-        using var form = new Form()
-        {
-            Width = 680,
-            Height = 400,
-            StartPosition = FormStartPosition.CenterScreen,
-        };
-
-        var btnTest = new Button()
-        {
-            Text = $"Click here to test ShowInTaskbar.{Environment.NewLine}If the test result is failed, this dialog will automatically close, or it will throw an exception.",
-            Location = new Point(10, 10),
-            Height = 60,
-            AutoSize = true,
-        };
-
-        btnTest.Click += (object sender, EventArgs e) =>
-        {
-            IntPtr formHandle = form.Handle;
-            form.ShowInTaskbar = !form.ShowInTaskbar;
-
-            if (form.IsHandleCreated == false)
-                throw new Exception();
-
-            if (formHandle == form.Handle)
-                throw new Exception();
-        };
-
-        form.Controls.Add(btnTest);
-        form.ShowDialog(this);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/GlobalUsings.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/GlobalUsings.cs
deleted file mode 100644
index d696db5c105..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/GlobalUsings.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using System.Windows.Forms;
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeA.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeA.bmp
deleted file mode 100644
index c8398cf1374..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeA.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeABlue.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeABlue.bmp
deleted file mode 100644
index ca674447a6d..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/LargeABlue.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallA.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallA.bmp
deleted file mode 100644
index 814d4302d30..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallA.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallABlue.bmp b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallABlue.bmp
deleted file mode 100644
index b91fb59c7f6..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Images/SmallABlue.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.Designer.cs
deleted file mode 100644
index dabd3a9c6a7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.Designer.cs
+++ /dev/null
@@ -1,252 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ListBoxes
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.label1 = new System.Windows.Forms.Label();
-        this.listBox1 = new System.Windows.Forms.ListBox();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.addButton1 = new System.Windows.Forms.Button();
-        this.deleteButton1 = new System.Windows.Forms.Button();
-        this.label2 = new System.Windows.Forms.Label();
-        this.listBox2 = new System.Windows.Forms.CheckedListBox();
-        this.textBox2 = new System.Windows.Forms.TextBox();
-        this.addButton2 = new System.Windows.Forms.Button();
-        this.deleteButton2 = new System.Windows.Forms.Button();
-        this.label3 = new System.Windows.Forms.Label();
-        this.listBox3 = new System.Windows.Forms.ListBox();
-        this.textBox3 = new System.Windows.Forms.TextBox();
-        this.addButton3 = new System.Windows.Forms.Button();
-        this.deleteButton3 = new System.Windows.Forms.Button();
-        this.label4 = new System.Windows.Forms.Label();
-        this.listBox4 = new System.Windows.Forms.ListBox();
-        this.textBox4 = new System.Windows.Forms.TextBox();
-        this.addButton4 = new System.Windows.Forms.Button();
-        this.deleteButton4 = new System.Windows.Forms.Button();
-        this.SuspendLayout();
-        // 
-        // label1
-        //
-        this.label1.Location = new System.Drawing.Point(20, 10);
-        this.label1.Size = new System.Drawing.Size(200, 20);
-        this.label1.Text = "ListBox with DrawMode.Normal";
-        // 
-        // listBox1
-        // 
-        this.listBox1.Location = new System.Drawing.Point(20, 40);
-        this.listBox1.Name = "listBox1";
-        this.listBox1.Size = new System.Drawing.Size(200, 150);
-        this.listBox1.DrawMode = System.Windows.Forms.DrawMode.Normal;
-        // 
-        // textBox1
-        //
-        this.textBox1.Location = new System.Drawing.Point(240, 40);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.Size = new System.Drawing.Size(100, 30);
-        // 
-        // addButton1
-        // 
-        this.addButton1.AutoSize = true;
-        this.addButton1.Location = new System.Drawing.Point(240, 80);
-        this.addButton1.Text = "Add";
-        this.addButton1.Tag = new object[]{ listBox1, textBox1 };
-        this.addButton1.Click += new System.EventHandler(this.addButton_Click);
-        // 
-        // deleteButton1
-        // 
-        this.deleteButton1.AutoSize = true;
-        this.deleteButton1.Location = new System.Drawing.Point(240, 110);
-        this.deleteButton1.Text = "Delete";
-        this.deleteButton1.Tag = listBox1;
-        this.deleteButton1.Click += new System.EventHandler(this.deleteButton_Click);
-        // 
-        // label2
-        //
-        this.label2.Location = new System.Drawing.Point(20, 200);
-        this.label2.Text = "CheckedListBox";
-        // 
-        // listBox2
-        // 
-        this.listBox2.Location = new System.Drawing.Point(20, 240);
-        this.listBox2.Name = "listBox2";
-        this.listBox2.Size = new System.Drawing.Size(200, 150);
-        // 
-        // textBox2
-        //
-        this.textBox2.Location = new System.Drawing.Point(240, 240);
-        this.textBox2.Name = "textBox2";
-        this.textBox2.Size = new System.Drawing.Size(100, 30);
-        // 
-        // addButton2
-        // 
-        this.addButton2.AutoSize = true;
-        this.addButton2.Location = new System.Drawing.Point(240, 300);
-        this.addButton2.Text = "Add";
-        this.addButton2.Tag = new object[] { listBox2, textBox2 };
-        this.addButton2.Click += new System.EventHandler(this.addButton_Click);
-        // 
-        // deleteButton2
-        // 
-        this.deleteButton2.AutoSize = true;
-        this.deleteButton2.Location = new System.Drawing.Point(240, 330);
-        this.deleteButton2.Text = "Delete";
-        this.deleteButton2.Tag = listBox2;
-        this.deleteButton2.Click += new System.EventHandler(this.deleteButton_Click);
-        // 
-        // label3
-        //
-        this.label3.Location = new System.Drawing.Point(360, 10);
-        this.label3.Size = new System.Drawing.Size(250, 20);
-        this.label3.Text = "ListBox DrawMode.OwnerDrawFixed";
-        // 
-        // listBox3
-        // 
-        this.listBox3.Location = new System.Drawing.Point(360, 40);
-        this.listBox3.Name = "listBox3";
-        this.listBox3.Size = new System.Drawing.Size(200, 150);
-        this.listBox3.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
-        this.listBox3.DrawItem += new System.Windows.Forms.DrawItemEventHandler(ListBox_DrawItem);
-        // 
-        // textBox3
-        //
-        this.textBox3.Location = new System.Drawing.Point(600, 40);
-        this.textBox3.Name = "textBox3";
-        this.textBox3.Size = new System.Drawing.Size(100, 30);
-        // 
-        // addButton3
-        // 
-        this.addButton3.AutoSize = true;
-        this.addButton3.Location = new System.Drawing.Point(600, 80);
-        this.addButton3.Text = "Add";
-        this.addButton3.Tag = new object[] { listBox3, textBox3 };
-        this.addButton3.Click += new System.EventHandler(this.addButton_Click);
-        // 
-        // deleteButton3
-        // 
-        this.deleteButton3.AutoSize = true;
-        this.deleteButton3.Location = new System.Drawing.Point(600, 110);
-        this.deleteButton3.Text = "Delete";
-        this.deleteButton3.Tag = listBox3;
-        this.deleteButton3.Click += new System.EventHandler(this.deleteButton_Click);
-        // 
-        // label4
-        //
-        this.label4.Location = new System.Drawing.Point(360, 200);
-        this.label4.Size = new System.Drawing.Size(250, 20);
-        this.label4.Text = "ListBox DrawMode.OwnerDrawVariable";
-        // 
-        // listBox4
-        // 
-        this.listBox4.Location = new System.Drawing.Point(360, 240);
-        this.listBox4.Name = "listBox4";
-        this.listBox4.Size = new System.Drawing.Size(200, 150);
-        this.listBox4.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawVariable;
-        this.listBox4.DrawItem += new System.Windows.Forms.DrawItemEventHandler(ListBox_DrawItem);
-        this.listBox4.MeasureItem += new System.Windows.Forms.MeasureItemEventHandler(ListBox_MeasureItem);
-        // 
-        // textBox4
-        //
-        this.textBox4.Location = new System.Drawing.Point(600, 240);
-        this.textBox4.Name = "textBox4";
-        this.textBox4.Size = new System.Drawing.Size(100, 30);
-        // 
-        // addButton4
-        // 
-        this.addButton4.AutoSize = true;
-        this.addButton4.Location = new System.Drawing.Point(600, 300);
-        this.addButton4.Text = "Add";
-        this.addButton4.Tag = new object[] { listBox4, textBox4 };
-        this.addButton4.Click += new System.EventHandler(this.addButton_Click);
-        // 
-        // deleteButton4
-        // 
-        this.deleteButton4.AutoSize = true;
-        this.deleteButton4.Location = new System.Drawing.Point(600, 330);
-        this.deleteButton4.Text = "Delete";
-        this.deleteButton4.Tag = listBox4;
-        this.deleteButton4.Click += new System.EventHandler(this.deleteButton_Click);
-        // 
-        // Form
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 500);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.listBox1);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.addButton1);
-        this.Controls.Add(this.deleteButton1);
-        this.Controls.Add(this.label2);
-        this.Controls.Add(this.listBox2);
-        this.Controls.Add(this.textBox2);
-        this.Controls.Add(this.addButton2);
-        this.Controls.Add(this.deleteButton2);
-        this.Controls.Add(this.label3);
-        this.Controls.Add(this.listBox3);
-        this.Controls.Add(this.textBox3);
-        this.Controls.Add(this.addButton3);
-        this.Controls.Add(this.deleteButton3);
-        this.Controls.Add(this.label4);
-        this.Controls.Add(this.listBox4);
-        this.Controls.Add(this.textBox4);
-        this.Controls.Add(this.addButton4);
-        this.Controls.Add(this.deleteButton4);
-        this.Name = "ListBoxes";
-        this.Text = "LIstBoxes";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.ListBox listBox1;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.Button addButton1;
-    private System.Windows.Forms.Button deleteButton1;
-    private System.Windows.Forms.Label label2;
-    private System.Windows.Forms.CheckedListBox listBox2;
-    private System.Windows.Forms.TextBox textBox2;
-    private System.Windows.Forms.Button addButton2;
-    private System.Windows.Forms.Button deleteButton2;
-    private System.Windows.Forms.Label label3;
-    private System.Windows.Forms.ListBox listBox3;
-    private System.Windows.Forms.TextBox textBox3;
-    private System.Windows.Forms.Button addButton3;
-    private System.Windows.Forms.Button deleteButton3;
-    private System.Windows.Forms.Label label4;
-    private System.Windows.Forms.ListBox listBox4;
-    private System.Windows.Forms.TextBox textBox4;
-    private System.Windows.Forms.Button addButton4;
-    private System.Windows.Forms.Button deleteButton4;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.cs
deleted file mode 100644
index ce9c66e04e3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class ListBoxes : Form
-{
-    public ListBoxes()
-    {
-        InitializeComponent();
-    }
-
-    private void addButton_Click(object sender, EventArgs e)
-    {
-        var control = (Control)sender;
-        var listBox = (ListBox)((Object[])control.Tag)[0];
-        var textBox = (TextBox)((Object[])control.Tag)[1];
-        listBox.Items.Add(textBox.Text);
-    }
-
-    private void deleteButton_Click(object sender, EventArgs e)
-    {
-        var control = (Control)sender;
-        var listBox = (ListBox)control.Tag;
-        listBox.Items.Clear();
-    }
-
-    private void ListBox_DrawItem(object sender, DrawItemEventArgs e)
-    {
-        var listBox = (ListBox)sender;
-
-        Brush customBrush;
-
-        if (e.Index % 2 == 0)
-        {
-            customBrush = Brushes.Green;
-        }
-        else
-        {
-            customBrush = Brushes.Red;
-        }
-
-        e.Graphics.DrawString(listBox.Items[e.Index].ToString(),
-            e.Font, customBrush, e.Bounds, StringFormat.GenericDefault);
-
-        e.DrawFocusRectangle();
-    }
-
-    private void ListBox_MeasureItem(object sender, MeasureItemEventArgs e)
-    {
-        if (e.Index % 2 == 0)
-        {
-            e.ItemHeight += 10;
-        }
-        else
-        {
-            e.ItemHeight += 5;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListBoxes.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.Designer.cs
deleted file mode 100644
index 2012bd2e167..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.Designer.cs
+++ /dev/null
@@ -1,159 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ListViewTest
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ListViewTest));
-        this.imageList1 = new System.Windows.Forms.ImageList(this.components);
-        this.listView1 = new System.Windows.Forms.ListView();
-        this.columnHeader1 = (System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader());
-        this.columnHeader2 = (System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader());
-        this.imageList2 = new System.Windows.Forms.ImageList(this.components);
-        this.btnClearListView1 = new System.Windows.Forms.Button();
-        this.btnLoadImagesListView1 = new System.Windows.Forms.Button();
-        this.LargeImageList = new System.Windows.Forms.ImageList(this.components);
-        this.btnReplaceImageListView1 = new System.Windows.Forms.Button();
-        this.openFileDialog1 = new System.Windows.Forms.OpenFileDialog();
-        this.SuspendLayout();
-        // 
-        // imageList1
-        // 
-        this.imageList1.ImageStream = (System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream"));
-        this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
-        this.imageList1.Images.SetKeyName(0, "SmallA.bmp");
-        this.imageList1.Images.SetKeyName(1, "SmallABlue.bmp");
-        // 
-        // columnHeader1
-        // 
-        this.columnHeader1.ImageIndex = 0;
-        // 
-        // columnHeader2
-        // 
-        this.columnHeader2.ImageIndex = 1;
-        // 
-        // listView1
-        //
-        this.listView1.Anchor = System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left;
-        this.listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
-        this.columnHeader1,
-        this.columnHeader2});
-        this.listView1.Groups.AddRange(new System.Windows.Forms.ListViewGroup[] {
-        (System.Windows.Forms.ListViewGroup)(resources.GetObject("listView1.Groups"))});
-        this.listView1.HideSelection = false;
-        this.listView1.Items.AddRange(new System.Windows.Forms.ListViewItem[] {
-        (System.Windows.Forms.ListViewItem)(resources.GetObject("listView1.Items")),
-        (System.Windows.Forms.ListViewItem)(resources.GetObject("listView1.Items1")),
-        (System.Windows.Forms.ListViewItem)(resources.GetObject("listView1.Items2"))});
-        this.listView1.LargeImageList = this.imageList2;
-        resources.ApplyResources(this.listView1, "listView1");
-        this.listView1.Location = new System.Drawing.Point(12, 33);
-        this.listView1.Name = "listView1";
-        this.listView1.Size = new System.Drawing.Size(439, 159);
-        this.listView1.SmallImageList = this.imageList1;
-        this.listView1.TabIndex = 0;
-        this.listView1.UseCompatibleStateImageBehavior = false;
-        // 
-        // imageList2
-        // 
-        this.imageList2.ImageStream = (System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList2.ImageStream"));
-        this.imageList2.TransparentColor = System.Drawing.Color.Transparent;
-        this.imageList2.Images.SetKeyName(0, "LargeA.bmp");
-        this.imageList2.Images.SetKeyName(1, "LargeABlue.bmp");
-        // 
-        // btnClearListView1
-        // 
-        this.btnClearListView1.Location = new System.Drawing.Point(13, 4);
-        this.btnClearListView1.Name = "btnClearListView1";
-        this.btnClearListView1.Size = new System.Drawing.Size(75, 23);
-        this.btnClearListView1.TabIndex = 1;
-        this.btnClearListView1.Text = "Clear";
-        this.btnClearListView1.UseVisualStyleBackColor = true;
-        this.btnClearListView1.Click += new System.EventHandler(this.btnClearListView1_Click);
-        // 
-        // btnLoadImagesListView1
-        // 
-        this.btnLoadImagesListView1.Location = new System.Drawing.Point(95, 4);
-        this.btnLoadImagesListView1.Name = "btnLoadImagesListView1";
-        this.btnLoadImagesListView1.Size = new System.Drawing.Size(75, 23);
-        this.btnLoadImagesListView1.TabIndex = 2;
-        this.btnLoadImagesListView1.Text = "Load images";
-        this.btnLoadImagesListView1.UseVisualStyleBackColor = true;
-        this.btnLoadImagesListView1.Click += new System.EventHandler(this.btnLoadImagesListView1_Click);
-        // 
-        // LargeImageList
-        // 
-        this.LargeImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth24Bit;
-        this.LargeImageList.ImageSize = new System.Drawing.Size(256, 256);
-        this.LargeImageList.TransparentColor = System.Drawing.Color.Transparent;
-        // 
-        // openFileDialog1
-        // 
-        this.openFileDialog1.FileName = "openFileDialog1";
-        this.openFileDialog1.Multiselect = true;
-        this.openFileDialog1.SupportMultiDottedExtensions = true;
-        // 
-        // btnReplaceImageListView1
-        // 
-        this.btnReplaceImageListView1.Location = new System.Drawing.Point(176, 4);
-        this.btnReplaceImageListView1.Name = "btnReplaceImageListView1";
-        this.btnReplaceImageListView1.Size = new System.Drawing.Size(87, 23);
-        this.btnReplaceImageListView1.TabIndex = 3;
-        this.btnReplaceImageListView1.Text = "Replace image";
-        this.btnReplaceImageListView1.UseVisualStyleBackColor = true;
-        this.btnReplaceImageListView1.Click += new System.EventHandler(this.btnReplaceImageListView1_Click);
-        // 
-        // ListViewTest
-        // 
-        resources.ApplyResources(this, "$this");
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.Controls.Add(this.btnReplaceImageListView1);
-        this.Controls.Add(this.btnLoadImagesListView1);
-        this.Controls.Add(this.btnClearListView1);
-        this.Controls.Add(this.listView1);
-        this.Name = "ListViewTest";
-        this.Text = "ListView Test";
-        this.ResumeLayout(false);
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ListView listView1;
-    private System.Windows.Forms.ImageList imageList1;
-    private System.Windows.Forms.ImageList imageList2;
-    private System.Windows.Forms.ImageList LargeImageList;
-    private System.Windows.Forms.ColumnHeader columnHeader1;
-    private System.Windows.Forms.ColumnHeader columnHeader2;
-    private System.Windows.Forms.Button btnClearListView1;
-    private System.Windows.Forms.Button btnLoadImagesListView1;
-    private System.Windows.Forms.Button btnReplaceImageListView1;
-    private System.Windows.Forms.OpenFileDialog openFileDialog1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.cs
deleted file mode 100644
index e032ce58fe7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.cs
+++ /dev/null
@@ -1,266 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class ListViewTest : Form
-{
-    public ListViewTest()
-    {
-        InitializeComponent();
-        CreateMyListView();
-
-        listView1.LabelEdit = true;
-        listView1.View = View.Tile;
-
-        var random = new Random();
-        int i = random.Next(100, 300);
-
-        listView1.TileSize = new Size(200, 50);
-        listView1.Items[0].ImageIndex = 0;
-        listView1.Items[1].ImageIndex = 1;
-        listView1.Items[2].ImageIndex = 2;
-        listView1.Click += (s, e) =>
-        {
-            //listView1.TileSize = new Size(random.Next(100, 300), random.Next(25, 50));
-
-            Point pos = Cursor.Position;
-            pos = PointToClient(pos);
-            var index = listView1.InsertionMark.NearestIndex(pos);
-            Console.WriteLine($"nearest index: {index}");
-        };
-
-        AddCollapsibleGroupToListView();
-        AddGroupTasks();
-    }
-
-    private void CreateMyListView()
-    {
-        // Create a new ListView control.
-        ListView listView2 = new ListView
-        {
-            Bounds = new Rectangle(new Point(0, 0), new Size(400, 200)),
-
-            // Set the view to show details.
-            View = View.Details,
-            // Allow the user to edit item text.
-            LabelEdit = true,
-            // Allow the user to rearrange columns.
-            AllowColumnReorder = true,
-            // Display check boxes.
-            CheckBoxes = true,
-            // Select the item and subitems when selection is made.
-            FullRowSelect = true,
-            // Display grid lines.
-            GridLines = true,
-            // Sort the items in the list in ascending order.
-            Sorting = SortOrder.Ascending,
-
-            VirtualMode = true,
-            VirtualListSize = 3,
-        };
-
-        listView2.SelectedIndexChanged += listView2_SelectedIndexChanged;
-        listView2.Click += listView2_Click;
-
-        // Create three items and three sets of subitems for each item.
-        ListViewItem item1 = new("item1", 0)
-        {
-            // Place a check mark next to the item.
-            Checked = true
-        };
-        item1.SubItems.Add("1");
-        item1.SubItems.Add("2");
-        item1.SubItems.Add("3");
-        ListViewItem item2 = new("item2", 1);
-        item2.SubItems.Add("4");
-        item2.SubItems.Add("5");
-        item2.SubItems.Add("6");
-        ListViewItem item3 = new("item3")
-        {
-            // Place a check mark next to the item.
-            Checked = true
-        };
-        item3.SubItems.Add("7");
-        item3.SubItems.Add("8");
-        item3.SubItems.Add("9");
-
-        // Add the items to the ListView, but because the listview is in Virtual Mode, we have to manage items ourselves
-        // and thus, we can't call the following:
-        //      listView2.Items.AddRange(new ListViewItem[] { item1, item2, item3 });
-        listView2.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => item1,
-                1 => item2,
-                2 => item3,
-                _ => throw new IndexOutOfRangeException(),
-            };
-        };
-
-        // Create columns for the items and subitems.
-        // Width of -2 indicates auto-size.
-        listView2.Columns.Add("column1", "Item Column", -2, HorizontalAlignment.Left, 0);
-        listView2.Columns.Add("Column 2", -2, HorizontalAlignment.Left);
-        listView2.Columns.Add("Column 3", -2, HorizontalAlignment.Left);
-        listView2.Columns.Add("Column 4", -2, HorizontalAlignment.Center);
-        listView2.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
-
-        // Create two ImageList objects.
-        ImageList imageListSmall = new(components);
-        ImageList imageListLarge = new(components);
-
-        // Initialize the ImageList objects with bitmaps.
-        imageListSmall.Images.Add(Bitmap.FromFile("Images\\SmallA.bmp"));
-        imageListSmall.Images.Add(Bitmap.FromFile("Images\\SmallABlue.bmp"));
-        imageListLarge.Images.Add(Bitmap.FromFile("Images\\LargeA.bmp"));
-        imageListLarge.Images.Add(Bitmap.FromFile("Images\\LargeABlue.bmp"));
-
-        // Assign the ImageList objects to the ListView.
-        listView2.LargeImageList = imageListLarge;
-        listView2.SmallImageList = imageListSmall;
-
-        // Add the ListView to the control collection.
-        Controls.Add(listView2);
-        listView2.Dock = DockStyle.Bottom;
-    }
-
-    private void AddCollapsibleGroupToListView()
-    {
-        var lvgroup1 = new ListViewGroup
-        {
-            Header = "CollapsibleGroup1",
-            CollapsedState = ListViewGroupCollapsedState.Expanded
-        };
-
-        listView1.Groups.Add(lvgroup1);
-        listView1.Items.Add(new ListViewItem
-        {
-            Text = "Item4",
-            Group = lvgroup1
-        });
-
-        var lvgroup2 = new ListViewGroup
-        {
-            Header = "CollapsibleGroup2",
-            CollapsedState = ListViewGroupCollapsedState.Collapsed
-        };
-
-        listView1.Groups.Add(lvgroup2);
-        listView1.Items.Add(new ListViewItem
-        {
-            Text = "Item5",
-            Group = lvgroup2
-        });
-
-        listView1.GroupCollapsedStateChanged += listView1_GroupCollapsedStateChanged;
-    }
-
-    private void listView1_GroupCollapsedStateChanged(object sender, ListViewGroupEventArgs e)
-    {
-        MessageBox.Show($"CollapsedState changed at group with index {e.GroupIndex}");
-    }
-
-    private void AddGroupTasks()
-    {
-        listView1.Groups[0].TaskLink = "Task";
-        listView1.Groups[0].Subtitle = "Subtitle";
-        listView1.GroupTaskLinkClick += listView1_GroupTaskLinkClick;
-
-        var lvgroup1 = new ListViewGroup
-        {
-            Header = "TaskGroup",
-            TaskLink = "Task2"
-        };
-
-        listView1.Groups.Add(lvgroup1);
-        listView1.Items.Add(new ListViewItem
-        {
-            Text = "Item6",
-            Group = lvgroup1
-        });
-    }
-
-    private void listView1_GroupTaskLinkClick(object sender, ListViewGroupEventArgs e)
-    {
-        MessageBox.Show(this, $"Task at group index {e.GroupIndex} was clicked", "GroupClick Event");
-    }
-
-    private void listView2_Click(object sender, System.EventArgs e)
-    {
-        Debug.WriteLine(listView1.TileSize);
-        MessageBox.Show(this, "listView2_Click", "event");
-    }
-
-    private void listView2_SelectedIndexChanged(object sender, System.EventArgs e)
-    {
-        // MessageBox.Show(this, "listView2_SelectedIndexChanged", "event");
-
-        var listView2 = sender as ListView;
-        if (listView2 is null)
-        {
-            return;
-        }
-
-        var random = new Random();
-        listView2.Columns[random.Next(0, listView2.Columns.Count)].ImageIndex = random.Next(0, 2);
-    }
-
-    private void btnClearListView1_Click(object sender, EventArgs e)
-    {
-        listView1.Clear();
-        LargeImageList.Images.Clear();
-
-        listView1.LargeImageList = LargeImageList;
-        listView1.View = View.LargeIcon;
-    }
-
-    private void btnLoadImagesListView1_Click(object sender, EventArgs e)
-    {
-        if (openFileDialog1.ShowDialog() != DialogResult.OK)
-        {
-            return;
-        }
-
-        foreach (string file in openFileDialog1.FileNames)
-        {
-            Bitmap bitmap = (Bitmap)Bitmap.FromFile(file);
-            LargeImageList.Images.Add(file, bitmap);
-
-            ListViewItem item = new ListViewItem
-            {
-                Text = Path.GetFileName(file),
-                Name = file,
-                ImageKey = file,
-                Checked = true
-            };
-            listView1.Items.Add(item);
-        }
-    }
-
-    private void btnReplaceImageListView1_Click(object sender, EventArgs e)
-    {
-        if (listView1.SelectedIndices.Count != 1)
-        {
-            return;
-        }
-
-        openFileDialog1.Multiselect = false;
-        DialogResult result = openFileDialog1.ShowDialog();
-        openFileDialog1.Multiselect = true;
-
-        if (result != DialogResult.OK)
-        {
-            return;
-        }
-
-        string file = openFileDialog1.FileName;
-        Bitmap bitmap = (Bitmap)Bitmap.FromFile(file);
-        LargeImageList.Images[listView1.SelectedIndices[0]] = bitmap;
-
-        listView1.Refresh();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.resx
deleted file mode 100644
index 10ce08d8f10..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ListViewTest.resx
+++ /dev/null
@@ -1,334 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="imageList1.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
-      ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAACK
-      CAAAAk1TRnQBSQFMAgEBAgEAARABAAEQAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo
-      AwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA
-      AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5
-      AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA
-      AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm
-      AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM
-      AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA
-      ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz
-      AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ
-      AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM
-      AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA
-      AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA
-      AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ
-      AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/
-      AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA
-      AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
-      ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ
-      Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz
-      AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA
-      AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM
-      AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM
-      ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM
-      Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA
-      AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM
-      AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ
-      AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz
-      AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm
-      AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw
-      AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAIP8gAA3/AfQB8w7/
-      AvQB/yAAAf8DvQj/AfMCRwL/AvIB8wj/AfMBzwGnAf8gAAH/AkcBFwj/ARcBRwEXAv8CpwHPCP8BzwGn
-      Ac8B/yAAAf8B4wJHBL0B/wO9ARcBRwHzAv8BzwGnAc8D3QHyAf8B8gLdAc8BpwH0Af8gAAL/AeMERwHj
-      AZQB4wNHAeMB9AP/AbQEpwHPAQkBzwOnAbQC/yAAAv8B9AHjAkcB4wZHAb0F/wG1AacCzwanAfIC/yAA
-      A/8BvQFHARcElAEXAUcBFgH0Bf8B8gGnAc8EtQHPAacBtQH0Av8gAAP/AfQBFgFHARYC/wG9ARcBRwG9
-      Bv8B9AG1AacBtQL/Ad0BzwGnAd0D/yAABP8BvQJHAbcBvQEXAUcBFgH0B/8B3QGnAc8BCQHdAc8BpwG1
-      AfQD/yAABP8B9AEWAUcBFgGUAUcBFgH0Cf8BtQGnArUBpwG1AfQE/yAABf8BvQRHAZQK/wHdAacCzwGn
-      AQkF/yAABv8BlAJHARYB9Av/AbUCpwG1Bv8gAAf/AZQBFg7/ArUH/yAAIP8gACD/IAABQgFNAT4HAAE+
-      AwABKAMAAUADAAEQAwABAQEAAQEFAAGAFwAD/4EACw==
-    </value>
-  </data>
-  <data name="columnHeader1.Text" xml:space="preserve">
-    <value>ColumnHeader1</value>
-  </data>
-  <data name="columnHeader2.Text" xml:space="preserve">
-    <value>ColumnHeader2</value>
-  </data>
-  <data name="listView1.Groups" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0
-      ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwCQAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1Rh
-      ZwROYW1lCkl0ZW1zQ291bnQFSXRlbTAFSXRlbTEFSXRlbTIFSXRlbTMBBAEBAAQEBAQoU3lzdGVtLldp
-      bmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFsaWdubWVudAIAAAAIIVN5c3RlbS5XaW5kb3dzLkZvcm1zLkxp
-      c3RWaWV3SXRlbQIAAAAhU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdJdGVtAgAAACFTeXN0ZW0u
-      V2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0CAAAAIVN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3
-      SXRlbQIAAAACAAAABgMAAAANTGlzdFZpZXdHcm91cAX8////KFN5c3RlbS5XaW5kb3dzLkZvcm1zLkhv
-      cml6b250YWxBbGlnbm1lbnQBAAAAB3ZhbHVlX18ACAIAAAAAAAAABgUAAAAJZ3JvdXAgdGFnBgYAAAAO
-      bGlzdFZpZXdHcm91cDEEAAAACQcAAAAJCAAAAAkJAAAACQoAAAAMCwAAAFFTeXN0ZW0uRHJhd2luZywg
-      VmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFk
-      NTBhM2EFBwAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0LAAAABFRleHQKSW1hZ2VJ
-      bmRleAhJbWFnZUtleQxTdWJJdGVtQ291bnQIU3ViSXRlbTEJQmFja0NvbG9yB0NoZWNrZWQERm9udAlG
-      b3JlQ29sb3IXVXNlSXRlbVN0eWxlRm9yU3ViSXRlbXMFR3JvdXABAAEABAQABAQABAgIMVN5c3RlbS5X
-      aW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1Ykl0ZW0CAAAAFFN5c3RlbS5EcmF3aW5n
-      LkNvbG9yCwAAAAETU3lzdGVtLkRyYXdpbmcuRm9udAsAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3ILAAAA
-      ASJTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwAgAAAAIAAAAGDAAAAAVJdGVtMf////8G
-      DQAAAApMYXJnZUEuYm1wAgAAAAkOAAAABfH///8UU3lzdGVtLkRyYXdpbmcuQ29sb3IEAAAABG5hbWUF
-      dmFsdWUKa25vd25Db2xvcgVzdGF0ZQEAAAAJBwcLAAAACgAAAAAAAAAAGAABAAAJEAAAAAHv////8f//
-      /woAAAAAAAAAABoAAQABCQEAAAAFCAAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0I
-      AAAABFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVt
-      U3R5bGVGb3JTdWJJdGVtcwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcgsAAAABE1N5
-      c3RlbS5EcmF3aW5nLkZvbnQLAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yCwAAAAEiU3lzdGVtLldpbmRv
-      d3MuRm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABhMAAAAFaXRlbTIBAAAAAez////x////CgAAAAAA
-      AAAAGAABAAEJEAAAAAHq////8f///woAAAAAAAAAABoAAQABCQEAAAABCQAAAAcAAAAGGAAAAAVJdGVt
-      Mf////8GGQAAAApMYXJnZUEuYm1wAgAAAAkaAAAAAeX////x////CgAAAAAAAAAAGAABAAAJHAAAAAHj
-      ////8f///woAAAAAAAAAABoAAQABCQEAAAAFCgAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmll
-      d0l0ZW0IAAAABFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdV
-      c2VJdGVtU3R5bGVGb3JTdWJJdGVtcwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcgsA
-      AAABE1N5c3RlbS5EcmF3aW5nLkZvbnQLAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yCwAAAAEiU3lzdGVt
-      LldpbmRvd3MuRm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABh8AAAAFaXRlbTIBAAAAAeD////x////
-      CgAAAAAAAAAAGAABAAEJIQAAAAHe////8f///woAAAAAAAAAABoAAQABCQEAAAAFDgAAADFTeXN0ZW0u
-      V2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtBAAAAAR0ZXh0BG5hbWUFc3R5
-      bGUIdXNlckRhdGEBAQQCPlN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1
-      Ykl0ZW0rU3ViSXRlbVN0eWxlAgAAAAIAAAAGJAAAAAhzdWJpdGVtMQoJJQAAAAoFEAAAABNTeXN0ZW0u
-      RHJhd2luZy5Gb250BAAAAAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZv
-      bnRTdHlsZQsAAAAbU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0CwAAAAsAAAAGJgAAABRNaWNyb3Nv
-      ZnQgU2FucyBTZXJpZgAAAEEF2f///xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18A
-      CAsAAAAAAAAABdj///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgLAAAA
-      AwAAAAEaAAAADgAAAAYpAAAACHN1Yml0ZW0xCgkqAAAACgEcAAAAEAAAAAYrAAAAFE1pY3Jvc29mdCBT
-      YW5zIFNlcmlmAAAAQQHU////2f///wAAAAAB0////9j///8DAAAAASEAAAAQAAAABi4AAAAUTWljcm9z
-      b2Z0IFNhbnMgU2VyaWYAAABBAdH////Z////AAAAAAHQ////2P///wMAAAAFJQAAAD5TeXN0ZW0uV2lu
-      ZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtK1N1Ykl0ZW1TdHlsZQMAAAAJYmFj
-      a0NvbG9yCWZvcmVDb2xvcgRmb250BAQEFFN5c3RlbS5EcmF3aW5nLkNvbG9yCwAAABRTeXN0ZW0uRHJh
-      d2luZy5Db2xvcgsAAAATU3lzdGVtLkRyYXdpbmcuRm9udAsAAAACAAAAAc/////x////CgAAAAAAAAAA
-      pgABAAHO////8f///woAAAAAAAAAAAAAAAAKASoAAAAlAAAAAc3////x////CgAAAAAAAAAApgABAAHM
-      ////8f///woAAAAAAAAAAAAAAAAKCw==
-    </value>
-  </data>
-  <data name="listView1.Items" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkMAwAAAFFTeXN0
-      ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2Vu
-      PWIwM2Y1ZjdmMTFkNTBhM2EFAQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0LAAAA
-      BFRleHQKSW1hZ2VJbmRleAhJbWFnZUtleQxTdWJJdGVtQ291bnQIU3ViSXRlbTEJQmFja0NvbG9yB0No
-      ZWNrZWQERm9udAlGb3JlQ29sb3IXVXNlSXRlbVN0eWxlRm9yU3ViSXRlbXMFR3JvdXABAAEABAQABAQA
-      BAgIMVN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1Ykl0ZW0CAAAAFFN5
-      c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAETU3lzdGVtLkRyYXdpbmcuRm9udAMAAAAUU3lzdGVtLkRyYXdp
-      bmcuQ29sb3IDAAAAASJTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwAgAAAAIAAAAGBAAA
-      AAVJdGVtMf////8GBQAAAApMYXJnZUEuYm1wAgAAAAkGAAAABfn///8UU3lzdGVtLkRyYXdpbmcuQ29s
-      b3IEAAAABG5hbWUFdmFsdWUKa25vd25Db2xvcgVzdGF0ZQEAAAAJBwcDAAAACgAAAAAAAAAAGAABAAAJ
-      CAAAAAH3////+f///woAAAAAAAAAABoAAQABCQoAAAAFBgAAADFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5M
-      aXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtBAAAAAR0ZXh0BG5hbWUFc3R5bGUIdXNlckRhdGEBAQQC
-      PlN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1Ykl0ZW0rU3ViSXRlbVN0
-      eWxlAgAAAAIAAAAGCwAAAAhzdWJpdGVtMQoJDAAAAAoFCAAAABNTeXN0ZW0uRHJhd2luZy5Gb250BAAA
-      AAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZvbnRTdHlsZQMAAAAbU3lz
-      dGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AwAAAAMAAAAGDQAAABRNaWNyb3NvZnQgU2FucyBTZXJpZgAA
-      AEEF8v///xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18ACAMAAAAAAAAABfH///8b
-      U3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgDAAAAAwAAAAUKAAAAIlN5c3Rl
-      bS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3R3JvdXAJAAAABkhlYWRlcg9IZWFkZXJBbGlnbm1lbnQDVGFn
-      BE5hbWUKSXRlbXNDb3VudAVJdGVtMAVJdGVtMQVJdGVtMgVJdGVtMwEEAQEABAQEBChTeXN0ZW0uV2lu
-      ZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAghU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlz
-      dFZpZXdJdGVtAgAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0CAAAAIVN5c3RlbS5X
-      aW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbQIAAAAhU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdJ
-      dGVtAgAAAAIAAAAGEAAAAA1MaXN0Vmlld0dyb3VwBe////8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9y
-      aXpvbnRhbEFsaWdubWVudAEAAAAHdmFsdWVfXwAIAgAAAAAAAAAGEgAAAAlncm91cCB0YWcGEwAAAA5s
-      aXN0Vmlld0dyb3VwMQQAAAAJFAAAAAkVAAAACQEAAAAJFwAAAAUMAAAAPlN5c3RlbS5XaW5kb3dzLkZv
-      cm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1Ykl0ZW0rU3ViSXRlbVN0eWxlAwAAAAliYWNrQ29sb3IJ
-      Zm9yZUNvbG9yBGZvbnQEBAQUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAFFN5c3RlbS5EcmF3aW5nLkNv
-      bG9yAwAAABNTeXN0ZW0uRHJhd2luZy5Gb250AwAAAAIAAAAB6P////n///8KAAAAAAAAAACmAAEAAef/
-      ///5////CgAAAAAAAAAAAAAAAAoBFAAAAAEAAAAGGgAAAAVJdGVtMf////8GGwAAAApMYXJnZUEuYm1w
-      AgAAAAkcAAAAAeP////5////CgAAAAAAAAAAGAABAAAJHgAAAAHh////+f///woAAAAAAAAAABoAAQAB
-      CQoAAAAFFQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0IAAAABFRleHQKSW1hZ2VJ
-      bmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5bGVGb3JTdWJJdGVt
-      cwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcgMAAAABE1N5c3RlbS5EcmF3aW5nLkZv
-      bnQDAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAEiU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZp
-      ZXdHcm91cAIAAAACAAAABiEAAAAFaXRlbTIBAAAAAd7////5////CgAAAAAAAAAAGAABAAEJHgAAAAHc
-      ////+f///woAAAAAAAAAABoAAQABCQoAAAAFFwAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmll
-      d0l0ZW0IAAAABFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdV
-      c2VJdGVtU3R5bGVGb3JTdWJJdGVtcwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcgMA
-      AAABE1N5c3RlbS5EcmF3aW5nLkZvbnQDAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAEiU3lzdGVt
-      LldpbmRvd3MuRm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABiYAAAAFaXRlbTIBAAAAAdn////5////
-      CgAAAAAAAAAAGAABAAEJKAAAAAHX////+f///woAAAAAAAAAABoAAQABCQoAAAABHAAAAAYAAAAGKwAA
-      AAhzdWJpdGVtMQoJLAAAAAoBHgAAAAgAAAAGLQAAABRNaWNyb3NvZnQgU2FucyBTZXJpZgAAAEEB0v//
-      //L///8AAAAAAdH////x////AwAAAAEoAAAACAAAAAYwAAAAFE1pY3Jvc29mdCBTYW5zIFNlcmlmAAAA
-      QQHP////8v///wAAAAABzv////H///8DAAAAASwAAAAMAAAAAc3////5////CgAAAAAAAAAApgABAAHM
-      ////+f///woAAAAAAAAAAAAAAAAKCw==
-    </value>
-  </data>
-  <data name="listView1.Items1" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkMAwAAAFFTeXN0
-      ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2Vu
-      PWIwM2Y1ZjdmMTFkNTBhM2EFAQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0IAAAA
-      BFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5
-      bGVGb3JTdWJJdGVtcwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcgMAAAABE1N5c3Rl
-      bS5EcmF3aW5nLkZvbnQDAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAEiU3lzdGVtLldpbmRvd3Mu
-      Rm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABgQAAAAFaXRlbTIBAAAABfv///8UU3lzdGVtLkRyYXdp
-      bmcuQ29sb3IEAAAABG5hbWUFdmFsdWUKa25vd25Db2xvcgVzdGF0ZQEAAAAJBwcDAAAACgAAAAAAAAAA
-      GAABAAEJBgAAAAH5////+////woAAAAAAAAAABoAAQABCQgAAAAFBgAAABNTeXN0ZW0uRHJhd2luZy5G
-      b250BAAAAAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZvbnRTdHlsZQMA
-      AAAbU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AwAAAAMAAAAGCQAAABRNaWNyb3NvZnQgU2FucyBT
-      ZXJpZgAAAEEF9v///xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18ACAMAAAAAAAAA
-      BfX///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgDAAAAAwAAAAUIAAAA
-      IlN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3R3JvdXAJAAAABkhlYWRlcg9IZWFkZXJBbGlnbm1l
-      bnQDVGFnBE5hbWUKSXRlbXNDb3VudAVJdGVtMAVJdGVtMQVJdGVtMgVJdGVtMwEEAQEABAQEBChTeXN0
-      ZW0uV2luZG93cy5Gb3Jtcy5Ib3Jpem9udGFsQWxpZ25tZW50AgAAAAghU3lzdGVtLldpbmRvd3MuRm9y
-      bXMuTGlzdFZpZXdJdGVtAgAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0CAAAAIVN5
-      c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbQIAAAAhU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlz
-      dFZpZXdJdGVtAgAAAAIAAAAGDAAAAA1MaXN0Vmlld0dyb3VwBfP///8oU3lzdGVtLldpbmRvd3MuRm9y
-      bXMuSG9yaXpvbnRhbEFsaWdubWVudAEAAAAHdmFsdWVfXwAIAgAAAAAAAAAGDgAAAAlncm91cCB0YWcG
-      DwAAAA5saXN0Vmlld0dyb3VwMQQAAAAJEAAAAAkRAAAACRIAAAAJAQAAAAUQAAAAIVN5c3RlbS5XaW5k
-      b3dzLkZvcm1zLkxpc3RWaWV3SXRlbQsAAAAEVGV4dApJbWFnZUluZGV4CEltYWdlS2V5DFN1Ykl0ZW1D
-      b3VudAhTdWJJdGVtMQlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5bGVG
-      b3JTdWJJdGVtcwVHcm91cAEAAQAEBAAEBAAECAgxU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdJ
-      dGVtK0xpc3RWaWV3U3ViSXRlbQIAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAARNTeXN0ZW0uRHJh
-      d2luZy5Gb250AwAAABRTeXN0ZW0uRHJhd2luZy5Db2xvcgMAAAABIlN5c3RlbS5XaW5kb3dzLkZvcm1z
-      Lkxpc3RWaWV3R3JvdXACAAAAAgAAAAYUAAAABUl0ZW0x/////wYVAAAACkxhcmdlQS5ibXACAAAACRYA
-      AAAB6f////v///8KAAAAAAAAAAAYAAEAAAkYAAAAAef////7////CgAAAAAAAAAAGgABAAEJCAAAAAER
-      AAAAAQAAAAYbAAAABWl0ZW0yAQAAAAHk////+////woAAAAAAAAAABgAAQABCRgAAAAB4v////v///8K
-      AAAAAAAAAAAaAAEAAQkIAAAABRIAAAAhU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdJdGVtCwAA
-      AARUZXh0CkltYWdlSW5kZXgISW1hZ2VLZXkMU3ViSXRlbUNvdW50CFN1Ykl0ZW0xCUJhY2tDb2xvcgdD
-      aGVja2VkBEZvbnQJRm9yZUNvbG9yF1VzZUl0ZW1TdHlsZUZvclN1Ykl0ZW1zBUdyb3VwAQABAAQEAAQE
-      AAQICDFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtAgAAABRT
-      eXN0ZW0uRHJhd2luZy5Db2xvcgMAAAABE1N5c3RlbS5EcmF3aW5nLkZvbnQDAAAAFFN5c3RlbS5EcmF3
-      aW5nLkNvbG9yAwAAAAEiU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABiAA
-      AAAFSXRlbTH/////BiEAAAAKTGFyZ2VBLmJtcAIAAAAJIgAAAAHd////+////woAAAAAAAAAABgAAQAA
-      CSQAAAAB2/////v///8KAAAAAAAAAAAaAAEAAQkIAAAABRYAAAAxU3lzdGVtLldpbmRvd3MuRm9ybXMu
-      TGlzdFZpZXdJdGVtK0xpc3RWaWV3U3ViSXRlbQQAAAAEdGV4dARuYW1lBXN0eWxlCHVzZXJEYXRhAQEE
-      Aj5TeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtK1N1Ykl0ZW1T
-      dHlsZQIAAAACAAAABicAAAAIc3ViaXRlbTEKCSgAAAAKARgAAAAGAAAABikAAAAUTWljcm9zb2Z0IFNh
-      bnMgU2VyaWYAAABBAdb////2////AAAAAAHV////9f///wMAAAABIgAAABYAAAAGLAAAAAhzdWJpdGVt
-      MQoJLQAAAAoBJAAAAAYAAAAGLgAAABRNaWNyb3NvZnQgU2FucyBTZXJpZgAAAEEB0f////b///8AAAAA
-      AdD////1////AwAAAAUoAAAAPlN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmll
-      d1N1Ykl0ZW0rU3ViSXRlbVN0eWxlAwAAAAliYWNrQ29sb3IJZm9yZUNvbG9yBGZvbnQEBAQUU3lzdGVt
-      LkRyYXdpbmcuQ29sb3IDAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAABNTeXN0ZW0uRHJhd2luZy5G
-      b250AwAAAAIAAAABz/////v///8KAAAAAAAAAACmAAEAAc7////7////CgAAAAAAAAAAAAAAAAoBLQAA
-      ACgAAAABzf////v///8KAAAAAAAAAACmAAEAAcz////7////CgAAAAAAAAAAAAAAAAoL
-    </value>
-  </data>
-  <data name="listView1.Items2" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkMAwAAAFFTeXN0
-      ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2Vu
-      PWIwM2Y1ZjdmMTFkNTBhM2EFAQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0HAAAA
-      BFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5
-      bGVGb3JTdWJJdGVtcwEABAAEBAAIFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAETU3lzdGVtLkRyYXdp
-      bmcuRm9udAMAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAAQIAAAAGBAAAAAVpdGVtM/////8F+///
-      /xRTeXN0ZW0uRHJhd2luZy5Db2xvcgQAAAAEbmFtZQV2YWx1ZQprbm93bkNvbG9yBXN0YXRlAQAAAAkH
-      BwMAAAAKAAAAAAAAAAAYAAEAAAkGAAAAAfn////7////CgAAAAAAAAAAGgABAAEFBgAAABNTeXN0ZW0u
-      RHJhd2luZy5Gb250BAAAAAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZv
-      bnRTdHlsZQMAAAAbU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AwAAAAMAAAAGCAAAABRNaWNyb3Nv
-      ZnQgU2FucyBTZXJpZgAAAEEF9////xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18A
-      CAMAAAAAAAAABfb///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgDAAAA
-      AwAAAAs=
-    </value>
-  </data>
-  <data name="imageList2.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-      AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
-      LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
-      ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADK
-      BwAAAk1TRnQBSQFMAgEBAgEAARABAAEQAQABEAEAARABAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo
-      AwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA
-      AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5
-      AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA
-      AWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHMAgABMwH/AgABZgMAAWYBMwIAAmYCAAFm
-      AZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgACmQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHM
-      AWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZAgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEA
-      ATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8BMwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEz
-      AWYCAAEzAWYBMwEAATMCZgEAATMBZgGZAQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZ
-      AWYBAAEzApkBAAEzAZkBzAEAATMBmQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLM
-      AQABMwHMAf8BAAEzAf8BMwEAATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEA
-      AWYBAAFmAQABZgEAAZkBAAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEA
-      AWYBMwHMAQABZgEzAf8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZ
-      AWYBAAFmApkBAAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/
-      AQABZgH/AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEA
-      AZkBAAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
-      ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwBAAKZ
-      Af8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIAAZkB/wEz
-      AQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYBAAHMAQABmQEA
-      AcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEzAf8BAAHMAWYCAAHM
-      AWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwBmQEzAQABzAGZAWYBAAHM
-      ApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEAA8wBAALMAf8BAAHMAf8CAAHM
-      Af8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwBAAEzAQAB/wEAAWYBAAH/AQABmQEA
-      AcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEAAf8BMwH/AQAB/wFmAgAB/wFmATMBAAHM
-      AmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkCAAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZ
-      AcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHMAWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEz
-      AQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8BAAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFm
-      AQABIQEAAaUBAANfAQADdwEAA4YBAAOWAQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHw
-      AfsB/wEAAaQCoAEAA4ADAAH/AgAB/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAIP8gAA//AUcP/wGn
-      IAAI/wFHBf8BRwn/AacF/wGnAf8gAAn/BUcL/wWnAv8gAAn/AkcC/wFHC/8CpwL/AacC/yAACv8BRwH/
-      AUcN/wGnAf8BpwP/IAAK/wNHDf8DpwP/IAAK/wJHDv8CpwT/IAAH/wFHAv8BRwz/AacC/wGnBf8gAAH/
-      AUcF/wFHCf8BpwX/AacI/yAAAv8FRwv/BacJ/yAAAv8CRwL/AUcL/wKnAv8Bpwn/IAAD/wFHAf8BRw3/
-      AacB/wGnCv8gAAP/A0cN/wOnCv8gAAT/AUcP/wGnC/8gACD/IAABQgFNAT4HAAE+AwABKAMAAUADAAEQ
-      AwABAQEAAQEFAAGAFwAD/4EACw==
-    </value>
-  </data>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="listView1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>-4, 0</value>
-  </data>
-  <data name="listView1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>439, 200</value>
-  </data>
-  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
-    <value>800, 408</value>
-  </data>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.Designer.cs
deleted file mode 100644
index abba48a9e64..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.Designer.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MainForm
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.overarchingFlowLayoutPanel = new System.Windows.Forms.FlowLayoutPanel();
-        this.overarchingFlowLayoutPanel.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // overarchingFlowLayoutPanel
-        // 
-        this.overarchingFlowLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.overarchingFlowLayoutPanel.FlowDirection = System.Windows.Forms.FlowDirection.TopDown;
-        this.overarchingFlowLayoutPanel.Location = new System.Drawing.Point(8, 8);
-        this.overarchingFlowLayoutPanel.Name = "flowLayoutPanelUITypeEditors";
-        this.overarchingFlowLayoutPanel.TabIndex = 0;
-        // 
-        // MainForm
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(570, 30);
-        this.Controls.Add(this.overarchingFlowLayoutPanel);
-        this.Name = "MainForm";
-        this.Padding = new System.Windows.Forms.Padding(8);
-        this.Text = "MenuForm";
-        this.overarchingFlowLayoutPanel.ResumeLayout(false);
-        this.ResumeLayout(false);
-    }
-
-    #endregion
-
-    private System.Windows.Forms.FlowLayoutPanel overarchingFlowLayoutPanel;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.cs
deleted file mode 100644
index 26d762a6480..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.cs
+++ /dev/null
@@ -1,291 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.IntegrationTests.Common;
-using Microsoft.Win32;
-using WindowsFormsApp1;
-using WinformsControlsTest.UserControls;
-
-namespace WinformsControlsTest;
-
-[DesignerCategory("code")]
-public partial class MainForm : Form
-{
-    public MainForm()
-    {
-        this.BringToForeground();
-        InitializeComponent();
-
-        // Init buttons
-        IReadOnlyDictionary<MainFormControlsTabOrder, InitInfo> buttonsInitInfo = GetButtonsInitInfo();
-        Array mainFormControlsTabOrderItems = Enum.GetValues(typeof(MainFormControlsTabOrder));
-
-        foreach (MainFormControlsTabOrder item in mainFormControlsTabOrderItems)
-        {
-            InitInfo info = buttonsInitInfo[item];
-            Button button = new Button
-            {
-                AutoSizeMode = AutoSizeMode.GrowAndShrink,
-                Name = info.Name,
-                TabIndex = (int)item,
-                Text = info.Name,
-                UseVisualStyleBackColor = true
-            };
-            button.Click += info.Click;
-
-            overarchingFlowLayoutPanel.Controls.Add(button);
-        }
-
-        Text = RuntimeInformation.FrameworkDescription;
-
-        SystemEvents.UserPreferenceChanged += (s, e) =>
-        {
-            // The default font gets reset for UserPreferenceCategory.Color
-            // though perhaps it should've been done for UserPreferenceCategory.Window
-            if (e.Category == UserPreferenceCategory.Color)
-            {
-                UpdateLayout();
-            }
-        };
-    }
-
-    private IReadOnlyDictionary<MainFormControlsTabOrder, InitInfo> GetButtonsInitInfo() => new Dictionary<MainFormControlsTabOrder, InitInfo>
-    {
-        {
-            MainFormControlsTabOrder.ButtonsButton,
-            new InitInfo("Buttons", (obj, e) => new Buttons().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.CalendarButton,
-            new InitInfo("Calendar", (obj, e) => new Calendar().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.MultipleControlsButton,
-            new InitInfo("MultipleControls", (obj, e) => new MultipleControls().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ComboBoxesButton,
-            new InitInfo("ComboBoxes", (obj, e) => new ComboBoxes().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ComboBoxesWithScrollBarsButton,
-            new InitInfo("ComboBoxes with ScrollBars", (obj, e) => new ComboBoxesWithScrollBars().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.DateTimePickerButton,
-            new InitInfo("DateTimePicker", (obj, e) => new DateTimePicker().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.DialogsButton,
-            new InitInfo("Dialogs", (obj, e) => new Dialogs().ShowDialog(this))
-        },
-        {
-            MainFormControlsTabOrder.DataGridViewButton,
-            new InitInfo("DataGridView", (obj, e) => new DataGridViewTest().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.DataGridViewInVirtualModeButton,
-            new InitInfo("DataGridView in Virtual mode", (obj, e) => new DataGridViewInVirtualModeTest().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.TreeViewButton,
-            new InitInfo("TreeView, ImageList", (obj, e) => new TreeViewTest().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ContentAlignmentButton,
-            new InitInfo("ContentAlignment", (obj, e) => new DesignTimeAligned().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.MenusButton,
-            new InitInfo("Menus", (obj, e) => new MenuStripAndCheckedListBox().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.PanelsButton,
-            new InitInfo("Panels", (obj, e) => new Panels().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.SplitterButton,
-            new InitInfo("Splitter", (obj, e) => new Splitter().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.MdiParentButton,
-            new InitInfo("MDI Parent", (obj, e) => new MdiParent().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.PropertyGridButton,
-            new InitInfo("PropertyGrid", (obj, e) => new PropertyGrid(new UserControlWithObjectCollectionEditor()).Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ListViewButton,
-            new InitInfo("ListView", (obj, e) => new ListViewTest().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.FontNameEditorButton,
-            new InitInfo("FontNameEditor", (obj, e) => new PropertyGrid(new UserControlWithFontNameEditor()).Show(this))
-        },
-        {
-            MainFormControlsTabOrder.CollectionEditorsButton,
-            new InitInfo("CollectionEditors", (obj, e) => new CollectionEditors().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.RichTextBoxesButton,
-            new InitInfo("RichTextBoxes", (obj, e) => new RichTextBoxes().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.PictureBoxesButton,
-            new InitInfo("PictureBoxes", (obj, e) => new PictureBoxes().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.FormBorderStylesButton,
-            new InitInfo("FormBorderStyles", (obj, e) => new FormBorderStyles().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.FormShowInTaskbarButton,
-            new InitInfo("FormShowInTaskbar", (obj, e) => new FormShowInTaskbar().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ToggleIconButton,
-            new InitInfo("ToggleFormIcon", (obj, e) => ShowIcon = !ShowIcon)
-        },
-        {
-            MainFormControlsTabOrder.ErrorProviderButton,
-            new InitInfo("ErrorProvider", (obj, e) => new ErrorProviderTest().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.TaskDialogButton,
-            new InitInfo("Task Dialog", (obj, e) => new TaskDialogSamples().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.MessageBoxButton,
-            new InitInfo("MessageBox", (obj, e) => new MessageBoxes().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ToolStripsButton,
-            new InitInfo("ToolStrips", (obj, e) => new ToolStripTests().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.TrackBarsButton,
-            new InitInfo("TrackBars", (obj, e) => new TrackBars().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ScrollBarsButton,
-            new InitInfo("ScrollBars", (obj, e) => new ScrollBars().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ToolTipsButton,
-            new InitInfo("ToolTips", (obj, e) => new ToolTipTests().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.AnchorLayoutButton,
-            new InitInfo("AnchorLayout", (obj, e) => new AnchorLayoutTests().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.DockLayoutButton,
-            new InitInfo("DockLayout", (obj, e) => new DockLayoutTests().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.DragAndDrop,
-            new InitInfo("Drag and Drop", (obj, e) => new DragDrop().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.TextBoxesButton,
-            new InitInfo("TextBoxes", (obj, e) => new TextBoxes().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.MediaPlayerButton,
-            new InitInfo("MediaPlayer", (obj, e) => new MediaPlayer().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.FormOwnerTestButton,
-            new InitInfo("FormOwnerTest", (obj, e) => new FormOwnerTestForm().Show(this))
-        },
-        {
-            MainFormControlsTabOrder.ListBoxTestButton,
-            new InitInfo("ListBoxes", (obj, e) => new ListBoxes().Show(this))
-        }
-    };
-
-    protected override void OnShown(EventArgs e)
-    {
-        base.OnShown(e);
-
-        UpdateLayout();
-        overarchingFlowLayoutPanel.Controls[(int)MainFormControlsTabOrder.ButtonsButton].Focus();
-    }
-
-    private void UpdateLayout()
-    {
-        MinimumSize = default;
-        Debug.WriteLine($"MessageBoxFont: {SystemFonts.MessageBoxFont}", nameof(MainForm));
-        Debug.WriteLine($"Default font: {Control.DefaultFont}", nameof(MainForm));
-
-        List<Button> buttons = new List<Button>();
-        foreach (Control control in overarchingFlowLayoutPanel.Controls)
-        {
-            if (control is Button button)
-            {
-                buttons.Add(button);
-            }
-            else
-            {
-                Debug.WriteLine($"Why did we get a {control.GetType().Name} instead a {nameof(Button)} on {nameof(MainForm)}?");
-            }
-        }
-
-        // 1. Auto-size all buttons
-        overarchingFlowLayoutPanel.SuspendLayout();
-        foreach (Button button in buttons)
-        {
-            button.AutoSize = true;
-        }
-
-        overarchingFlowLayoutPanel.ResumeLayout(true);
-
-        // 2. Find the biggest button
-        Size biggestButton = default;
-        foreach (Button button in buttons)
-        {
-            if (button.Width > biggestButton.Width)
-            {
-                biggestButton = button.Size;
-            }
-        }
-
-        Debug.WriteLine($"Biggest button size: {biggestButton}", nameof(MainForm));
-
-        // 3. Size all buttons to the biggest button
-        overarchingFlowLayoutPanel.SuspendLayout();
-        foreach (Button button in buttons)
-        {
-            button.AutoSize = false;
-            button.Size = biggestButton;
-        }
-
-        overarchingFlowLayoutPanel.ResumeLayout(true);
-
-        // 4. Calculate the new form size showing all buttons in two vertical columns
-        int padding = overarchingFlowLayoutPanel.Controls[0].Margin.All;
-        ClientSize = new Size(
-            (biggestButton.Width + padding * 2) * 2 + padding * 2 + overarchingFlowLayoutPanel.Location.X * 2,
-            (overarchingFlowLayoutPanel.Controls.Count + 1) / 2 * (biggestButton.Height + padding * 2)
-                + padding * 2 + overarchingFlowLayoutPanel.Location.Y * 2);
-        MinimumSize = Size;
-        Debug.WriteLine($"Minimum form size: {MinimumSize}", nameof(MainForm));
-    }
-
-    private struct InitInfo
-    {
-        public InitInfo(string name, EventHandler handler)
-        {
-            Name = name;
-            Click = handler;
-        }
-
-        public string Name { get; }
-
-        public EventHandler Click { get; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MainForm.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.Designer.cs
deleted file mode 100644
index 560058ea9aa..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.Designer.cs
+++ /dev/null
@@ -1,162 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MdiChild
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.panel1 = new System.Windows.Forms.Panel();
-        this.btnOpenChild = new System.Windows.Forms.Button();
-        this.chkSetParentMenustrip = new System.Windows.Forms.CheckBox();
-        this.chkSetMenustrip = new System.Windows.Forms.CheckBox();
-        this.chkAddParentMenustrip = new System.Windows.Forms.CheckBox();
-        this.chkAddMenustrip = new System.Windows.Forms.CheckBox();
-        this.chkChildAlign = new System.Windows.Forms.CheckBox();
-        this.chkRightToLeft = new System.Windows.Forms.CheckBox();
-        this.panel1.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // panel1
-        //
-        this.panel1.Controls.Add(this.chkRightToLeft);
-        this.panel1.Controls.Add(this.chkChildAlign);
-        this.panel1.Controls.Add(this.chkAddMenustrip);
-        this.panel1.Controls.Add(this.chkAddParentMenustrip);
-        this.panel1.Controls.Add(this.chkSetMenustrip);
-        this.panel1.Controls.Add(this.chkSetParentMenustrip);
-        this.panel1.Controls.Add(this.btnOpenChild);
-        this.panel1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.panel1.Location = new System.Drawing.Point(0, 0);
-        this.panel1.Name = "panel1";
-        this.panel1.Size = new System.Drawing.Size(480, 221);
-        this.panel1.TabIndex = 0;
-        this.panel1.DoubleClick += this.panel1_DoubleClick;
-        // 
-        // chkChildAlign
-        // 
-        this.chkChildAlign.AutoSize = true;
-        this.chkChildAlign.Location = new System.Drawing.Point(43, 121);
-        this.chkChildAlign.Name = "chkChildAlign";
-        this.chkChildAlign.Size = new System.Drawing.Size(162, 17);
-        this.chkChildAlign.TabIndex = 3;
-        this.chkChildAlign.Text = "Top align minimized child";
-        this.chkChildAlign.UseVisualStyleBackColor = true;
-        this.chkChildAlign.CheckedChanged += new System.EventHandler(this.chkChildAlign_CheckedChanged);
-        // 
-        // chkRightToLeft
-        // 
-        this.chkRightToLeft.AutoSize = true;
-        this.chkRightToLeft.Location = new System.Drawing.Point(228, 121);
-        this.chkRightToLeft.Name = "chkRightToLeft";
-        this.chkRightToLeft.Size = new System.Drawing.Size(162, 17);
-        this.chkRightToLeft.TabIndex = 4;
-        this.chkRightToLeft.Text = "Right to left mode";
-        this.chkRightToLeft.UseVisualStyleBackColor = true;
-        this.chkRightToLeft.CheckedChanged += new System.EventHandler(this.chkRightToLeft_CheckedChanged);
-        // 
-        // btnOpenChild
-        // 
-        this.btnOpenChild.AutoSize = true;
-        this.btnOpenChild.Location = new System.Drawing.Point(40, 22);
-        this.btnOpenChild.Name = "btnOpenChild";
-        this.btnOpenChild.Size = new System.Drawing.Size(138, 23);
-        this.btnOpenChild.TabIndex = 0;
-        this.btnOpenChild.Text = "Open new child";
-        this.btnOpenChild.UseVisualStyleBackColor = true;
-        this.btnOpenChild.Click += new System.EventHandler(this.btnOpenChild_Click);
-        // 
-        // chkSetParentMenustrip
-        // 
-        this.chkSetParentMenustrip.AutoSize = true;
-        this.chkSetParentMenustrip.Location = new System.Drawing.Point(43, 73);
-        this.chkSetParentMenustrip.Name = "chkSetParentMenustrip";
-        this.chkSetParentMenustrip.Size = new System.Drawing.Size(123, 17);
-        this.chkSetParentMenustrip.TabIndex = 1;
-        this.chkSetParentMenustrip.Text = "Set parent menustrip";
-        this.chkSetParentMenustrip.UseVisualStyleBackColor = true;
-        this.chkSetParentMenustrip.CheckedChanged += new System.EventHandler(this.chkSetParentMenustrip_CheckedChanged);
-        // 
-        // chkSetMenustrip
-        // 
-        this.chkSetMenustrip.AutoSize = true;
-        this.chkSetMenustrip.Location = new System.Drawing.Point(228, 73);
-        this.chkSetMenustrip.Name = "chkSetMenustrip";
-        this.chkSetMenustrip.Size = new System.Drawing.Size(115, 17);
-        this.chkSetMenustrip.TabIndex = 3;
-        this.chkSetMenustrip.Text = "Set child menustrip";
-        this.chkSetMenustrip.UseVisualStyleBackColor = true;
-        this.chkSetMenustrip.CheckedChanged += new System.EventHandler(this.chkSetMenustrip_CheckedChanged);
-        // 
-        // chkAddParentMenustrip
-        // 
-        this.chkAddParentMenustrip.AutoSize = true;
-        this.chkAddParentMenustrip.Location = new System.Drawing.Point(43, 97);
-        this.chkAddParentMenustrip.Name = "chkAddParentMenustrip";
-        this.chkAddParentMenustrip.Size = new System.Drawing.Size(179, 17);
-        this.chkAddParentMenustrip.TabIndex = 2;
-        this.chkAddParentMenustrip.Text = "Add parent menustrip to Controls";
-        this.chkAddParentMenustrip.UseVisualStyleBackColor = true;
-        this.chkAddParentMenustrip.CheckedChanged += new System.EventHandler(this.chkAddParentMenustrip_CheckedChanged);
-        // 
-        // chkAddMenustrip
-        // 
-        this.chkAddMenustrip.AutoSize = true;
-        this.chkAddMenustrip.Location = new System.Drawing.Point(228, 97);
-        this.chkAddMenustrip.Name = "chkAddMenustrip";
-        this.chkAddMenustrip.Size = new System.Drawing.Size(146, 17);
-        this.chkAddMenustrip.TabIndex = 4;
-        this.chkAddMenustrip.Text = "Add menustrip to Controls";
-        this.chkAddMenustrip.UseVisualStyleBackColor = true;
-        this.chkAddMenustrip.CheckedChanged += new System.EventHandler(this.chkAddMenustrip_CheckedChanged);
-        // 
-        // ChildForm
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(480, 221);
-        this.Controls.Add(this.panel1);
-        this.Name = "ChildForm";
-        this.Text = "ChildForm";
-        this.panel1.ResumeLayout(false);
-        this.panel1.PerformLayout();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Panel panel1;
-    private System.Windows.Forms.Button btnOpenChild;
-    private System.Windows.Forms.CheckBox chkAddMenustrip;
-    private System.Windows.Forms.CheckBox chkAddParentMenustrip;
-    private System.Windows.Forms.CheckBox chkSetMenustrip;
-    private System.Windows.Forms.CheckBox chkSetParentMenustrip;
-    private System.Windows.Forms.CheckBox chkChildAlign;
-    private System.Windows.Forms.CheckBox chkRightToLeft;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.cs
deleted file mode 100644
index b907ab1910a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class MdiChild : Form
-{
-    private readonly MenuStrip _menuStrip;
-
-    public MdiChild()
-    {
-        InitializeComponent();
-
-        _menuStrip = new MenuStrip();
-        _menuStrip.Items.Add(new ToolStripMenuItem { Text = "Child1" });
-        _menuStrip.Items.Add(new ToolStripMenuItem
-        {
-            Alignment = ToolStripItemAlignment.Right,
-            Text = "Child2",
-        });
-    }
-
-    private MdiParent MyParent => (MdiParent)MdiParent;
-
-    private void btnOpenChild_Click(object sender, EventArgs e)
-    {
-        Form frm = new Form();
-        frm.MdiParent = MdiParent;
-        frm.WindowState = FormWindowState.Maximized;
-        frm.Show();
-    }
-
-    private void chkSetMenustrip_CheckedChanged(object sender, EventArgs e)
-    {
-        if (chkSetMenustrip.Checked)
-        {
-            MainMenuStrip = _menuStrip;
-        }
-        else
-        {
-            MainMenuStrip = null;
-        }
-    }
-
-    private void chkSetParentMenustrip_CheckedChanged(object sender, EventArgs e)
-    {
-        if (chkSetParentMenustrip.Checked)
-        {
-            MyParent.MainMenuStrip = MyParent.MainMenu;
-        }
-        else
-        {
-            MyParent.MainMenuStrip = null;
-        }
-    }
-
-    private void chkAddMenustrip_CheckedChanged(object sender, EventArgs e)
-    {
-        if (chkAddMenustrip.Checked)
-        {
-            Controls.Add(_menuStrip);
-        }
-        else
-        {
-            Controls.Remove(_menuStrip);
-        }
-    }
-
-    private void chkAddParentMenustrip_CheckedChanged(object sender, EventArgs e)
-    {
-        if (chkAddParentMenustrip.Checked)
-        {
-            MyParent.Controls.Add(MyParent.MainMenu);
-        }
-        else
-        {
-            MyParent.Controls.Remove(MyParent.MainMenu);
-        }
-    }
-
-    private void panel1_DoubleClick(object sender, System.EventArgs e)
-    {
-        WindowState = FormWindowState.Normal;
-    }
-
-    private void chkChildAlign_CheckedChanged(object sender, EventArgs e)
-    {
-        MyParent.MdiChildrenMinimizedAnchorBottom = !chkChildAlign.Checked;
-    }
-
-    private void chkRightToLeft_CheckedChanged(object sender, EventArgs e)
-    {
-        if (MyParent.MainMenuStrip is not null)
-        {
-            MyParent.MainMenuStrip.RightToLeft = chkRightToLeft.Checked ? RightToLeft.Yes : RightToLeft.No;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiChild.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.Designer.cs
deleted file mode 100644
index 0f4b3359351..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.Designer.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MdiParent
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.SuspendLayout();
-        // 
-        // frmMDI
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(900, 578);
-        this.IsMdiContainer = true;
-        this.Name = "frmMDI";
-        this.Text = "frmMDI";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.cs
deleted file mode 100644
index 541fd697f35..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace WinformsControlsTest;
-
-public partial class MdiParent : Form
-{
-    private readonly MenuStrip _menuStrip;
-
-    public MdiParent()
-    {
-        InitializeComponent();
-
-        Text = RuntimeInformation.FrameworkDescription;
-
-        ToolStripMenuItem menu = new() { Text = "Open new child" };
-        menu.Click += (s, e) =>
-        {
-            var child = new Form();
-            child.MdiParent = this;
-            child.WindowState = FormWindowState.Maximized;
-            child.Show();
-        };
-
-        _menuStrip = new MenuStrip();
-        _menuStrip.Items.Add(menu);
-
-        for (int i = 1; i < 7; i++)
-        {
-            ToolStripMenuItem item = new()
-            {
-                Alignment = i < 4 ? ToolStripItemAlignment.Left : ToolStripItemAlignment.Right,
-                Text = $"Item{i}"
-            };
-            _menuStrip.Items.Add(item);
-        }
-    }
-
-    public MenuStrip MainMenu => _menuStrip;
-
-    protected override void OnLoad(EventArgs e)
-    {
-        base.OnLoad(e);
-
-        MdiChild frm = new MdiChild();
-        frm.MdiParent = this;
-        frm.WindowState = FormWindowState.Maximized;
-        frm.Show();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MdiParent.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.Designer.cs
deleted file mode 100644
index 857250b0635..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.Designer.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MediaPlayer
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-
-        axWindowsMediaPlayer1.Dispose();
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MediaPlayer));
-        this.axWindowsMediaPlayer1 = new AxWMPLib.AxWindowsMediaPlayer();
-        ((System.ComponentModel.ISupportInitialize)(this.axWindowsMediaPlayer1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // axWindowsMediaPlayer1
-        // 
-        this.axWindowsMediaPlayer1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.axWindowsMediaPlayer1.Enabled = true;
-        this.axWindowsMediaPlayer1.Location = new System.Drawing.Point(0, 0);
-        this.axWindowsMediaPlayer1.Name = "axWindowsMediaPlayer1";
-        this.axWindowsMediaPlayer1.OcxState = ((System.Windows.Forms.AxHost.State)(resources.GetObject("axWindowsMediaPlayer1.OcxState")));
-        this.axWindowsMediaPlayer1.Size = new System.Drawing.Size(800, 450);
-        this.axWindowsMediaPlayer1.TabIndex = 0;
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Controls.Add(this.axWindowsMediaPlayer1);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        ((System.ComponentModel.ISupportInitialize)(this.axWindowsMediaPlayer1)).EndInit();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-    private AxWMPLib.AxWindowsMediaPlayer axWindowsMediaPlayer1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.cs
deleted file mode 100644
index 9d9821b3bfc..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class MediaPlayer : Form
-{
-    public MediaPlayer()
-    {
-        InitializeComponent();
-        axWindowsMediaPlayer1.URL = Path.GetFullPath(@".\resources\media.mpg");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MediaPlayer.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.Designer.cs
deleted file mode 100644
index d35c6d0c639..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.Designer.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MenuStripAndCheckedListBox
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.menuStrip1 = new System.Windows.Forms.MenuStrip();
-        this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.newToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.openToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator();
-        this.memoryCardFileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.navigationToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.newToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.settingsEditorToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.exitToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator();
-        this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.viewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.insertToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.checkStateSamplesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.uncheckedToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.uncheckedCheckOnClickToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.checkedToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.checkedCheckOnClickToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.indeterminateToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.indeterminateCheckOnClickToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
-        this.currentDpiLabel = new System.Windows.Forms.Label();
-        this.menuStrip1.SuspendLayout();
-        this.SuspendLayout();
-        //
-        // menuStrip1
-        //
-        this.menuStrip1.BackColor = System.Drawing.Color.IndianRed;
-        this.menuStrip1.ImageScalingSize = new System.Drawing.Size(32, 32);
-        this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.fileToolStripMenuItem,
-        this.editToolStripMenuItem,
-        this.viewToolStripMenuItem,
-        this.insertToolStripMenuItem,
-        this.checkStateSamplesToolStripMenuItem});
-        this.menuStrip1.Location = new System.Drawing.Point(0, 0);
-        this.menuStrip1.Name = "menuStrip1";
-        this.menuStrip1.Padding = new System.Windows.Forms.Padding(12, 4, 0, 4);
-        this.menuStrip1.Size = new System.Drawing.Size(736, 46);
-        this.menuStrip1.TabIndex = 0;
-        this.menuStrip1.Text = "menuStrip1";
-        //
-        // fileToolStripMenuItem
-        //
-        this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.newToolStripMenuItem,
-        this.openToolStripMenuItem1,
-        this.toolStripSeparator1,
-        this.memoryCardFileToolStripMenuItem,
-        this.toolStripSeparator2,
-        this.exitToolStripMenuItem});
-        this.fileToolStripMenuItem.Name = "fileToolStripMenuItem";
-        this.fileToolStripMenuItem.Size = new System.Drawing.Size(108, 38);
-        this.fileToolStripMenuItem.Text = "Project";
-        //
-        // newToolStripMenuItem
-        //
-        this.newToolStripMenuItem.Name = "newToolStripMenuItem";
-        this.newToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.N)));
-        this.newToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.newToolStripMenuItem.Text = "New";
-        //
-        // openToolStripMenuItem1
-        //
-        this.openToolStripMenuItem1.Enabled = false;
-        this.openToolStripMenuItem1.Name = "openToolStripMenuItem1";
-        this.openToolStripMenuItem1.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.O)));
-        this.openToolStripMenuItem1.Size = new System.Drawing.Size(401, 44);
-        this.openToolStripMenuItem1.Text = "Open";
-        //
-        // toolStripSeparator1
-        //
-        this.toolStripSeparator1.Name = "toolStripSeparator1";
-        this.toolStripSeparator1.Size = new System.Drawing.Size(398, 6);
-        //
-        // memoryCardFileToolStripMenuItem
-        //
-        this.memoryCardFileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.navigationToolStripMenuItem,
-        this.saveToolStripMenuItem,
-        this.saveAsToolStripMenuItem,
-        this.exitToolStripMenuItem1});
-        this.memoryCardFileToolStripMenuItem.Name = "memoryCardFileToolStripMenuItem";
-        this.memoryCardFileToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.memoryCardFileToolStripMenuItem.Text = "Memory Card File";
-        this.memoryCardFileToolStripMenuItem.ToolTipText = "Looooooooooooooooooooooooooooooooong ToolTip";
-        //
-        // navigationToolStripMenuItem
-        //
-        this.navigationToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.newToolStripMenuItem1});
-        this.navigationToolStripMenuItem.Name = "navigationToolStripMenuItem";
-        this.navigationToolStripMenuItem.Size = new System.Drawing.Size(265, 44);
-        this.navigationToolStripMenuItem.Text = "Navigation";
-        this.navigationToolStripMenuItem.ToolTipText = "Looooooooooooooooooooooooooooooooong ToolTip 2";
-        //
-        // newToolStripMenuItem1
-        //
-        this.newToolStripMenuItem1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.settingsEditorToolStripMenuItem});
-        this.newToolStripMenuItem1.Name = "newToolStripMenuItem1";
-        this.newToolStripMenuItem1.Size = new System.Drawing.Size(197, 44);
-        this.newToolStripMenuItem1.Text = "New";
-        //
-        // settingsEditorToolStripMenuItem
-        //
-        this.settingsEditorToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.openToolStripMenuItem});
-        this.settingsEditorToolStripMenuItem.Name = "settingsEditorToolStripMenuItem";
-        this.settingsEditorToolStripMenuItem.Size = new System.Drawing.Size(304, 44);
-        this.settingsEditorToolStripMenuItem.Text = "Settings Editor";
-        //
-        // openToolStripMenuItem
-        //
-        this.openToolStripMenuItem.Name = "openToolStripMenuItem";
-        this.openToolStripMenuItem.Size = new System.Drawing.Size(208, 44);
-        this.openToolStripMenuItem.Text = "Open";
-        //
-        // saveToolStripMenuItem
-        //
-        this.saveToolStripMenuItem.Name = "saveToolStripMenuItem";
-        this.saveToolStripMenuItem.Size = new System.Drawing.Size(265, 44);
-        this.saveToolStripMenuItem.Text = "Save";
-        //
-        // saveAsToolStripMenuItem
-        //
-        this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem";
-        this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(265, 44);
-        this.saveAsToolStripMenuItem.Text = "Save As";
-        //
-        // exitToolStripMenuItem1
-        //
-        this.exitToolStripMenuItem1.Name = "exitToolStripMenuItem1";
-        this.exitToolStripMenuItem1.Size = new System.Drawing.Size(265, 44);
-        this.exitToolStripMenuItem1.Text = "Exit";
-        //
-        // toolStripSeparator2
-        //
-        this.toolStripSeparator2.Name = "toolStripSeparator2";
-        this.toolStripSeparator2.Size = new System.Drawing.Size(398, 6);
-        //
-        // exitToolStripMenuItem
-        //
-        this.exitToolStripMenuItem.Name = "exitToolStripMenuItem";
-        this.exitToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.exitToolStripMenuItem.Text = "Exit";
-        //
-        // editToolStripMenuItem
-        //
-        this.editToolStripMenuItem.Name = "editToolStripMenuItem";
-        this.editToolStripMenuItem.Size = new System.Drawing.Size(75, 38);
-        this.editToolStripMenuItem.Text = "Edit";
-        //
-        // viewToolStripMenuItem
-        //
-        this.viewToolStripMenuItem.Name = "viewToolStripMenuItem";
-        this.viewToolStripMenuItem.Size = new System.Drawing.Size(86, 38);
-        this.viewToolStripMenuItem.Text = "View";
-        //
-        // insertToolStripMenuItem
-        //
-        this.insertToolStripMenuItem.Name = "insertToolStripMenuItem";
-        this.insertToolStripMenuItem.Size = new System.Drawing.Size(94, 38);
-        this.insertToolStripMenuItem.Text = "Insert";
-        //
-        // checkStateSamplesToolStripMenuItem
-        //
-        this.checkStateSamplesToolStripMenuItem.Name = "checkStateSamplesToolStripMenuItem";
-        this.checkStateSamplesToolStripMenuItem.Size = new System.Drawing.Size(200, 38);
-        this.checkStateSamplesToolStripMenuItem.Text = "CheckState samples";
-        this.checkStateSamplesToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.uncheckedToolStripMenuItem,
-        this.uncheckedCheckOnClickToolStripMenuItem,
-        this.checkedToolStripMenuItem,
-        this.checkedCheckOnClickToolStripMenuItem,
-        this.indeterminateToolStripMenuItem,
-        this.indeterminateCheckOnClickToolStripMenuItem});
-        // 
-        // uncheckedToolStripMenuItem
-        // 
-        this.uncheckedToolStripMenuItem.Name = "uncheckedToolStripMenuItem";
-        this.uncheckedToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.uncheckedToolStripMenuItem.Text = "Unchecked CheckOnClick(F)";
-        this.uncheckedToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        // 
-        // uncheckedCheckOnClickToolStripMenuItem
-        // 
-        this.uncheckedCheckOnClickToolStripMenuItem.CheckOnClick = true;
-        this.uncheckedCheckOnClickToolStripMenuItem.Name = "uncheckedCheckOnClickToolStripMenuItem";
-        this.uncheckedCheckOnClickToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.uncheckedCheckOnClickToolStripMenuItem.Text = "Unchecked CheckOnClick(T)";
-        this.uncheckedCheckOnClickToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        this.uncheckedCheckOnClickToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.C)));
-        // 
-        // checkedToolStripMenuItem
-        // 
-        this.checkedToolStripMenuItem.Checked = true;
-        this.checkedToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.checkedToolStripMenuItem.Name = "checkedToolStripMenuItem";
-        this.checkedToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.checkedToolStripMenuItem.Text = "Checked CheckOnClick(F)";
-        this.checkedToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        // 
-        // checkedCheckOnClickToolStripMenuItem
-        // 
-        this.checkedCheckOnClickToolStripMenuItem.Checked = true;
-        this.checkedCheckOnClickToolStripMenuItem.CheckOnClick = true;
-        this.checkedCheckOnClickToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.checkedCheckOnClickToolStripMenuItem.Name = "checkedCheckOnClickToolStripMenuItem";
-        this.checkedCheckOnClickToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.checkedCheckOnClickToolStripMenuItem.Text = "Checked CheckOnClick(T)";
-        this.checkedCheckOnClickToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        // 
-        // indeterminateToolStripMenuItem
-        // 
-        this.indeterminateToolStripMenuItem.Checked = true;
-        this.indeterminateToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Indeterminate;
-        this.indeterminateToolStripMenuItem.Name = "indeterminateToolStripMenuItem";
-        this.indeterminateToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.indeterminateToolStripMenuItem.Text = "Indeterminate CheckOnClick(F)";
-        this.indeterminateToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        // 
-        // indeterminateCheckOnClickToolStripMenuItem
-        // 
-        this.indeterminateCheckOnClickToolStripMenuItem.Checked = true;
-        this.indeterminateCheckOnClickToolStripMenuItem.CheckOnClick = true;
-        this.indeterminateCheckOnClickToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Indeterminate;
-        this.indeterminateCheckOnClickToolStripMenuItem.Name = "indeterminateCheckOnClickToolStripMenuItem";
-        this.indeterminateCheckOnClickToolStripMenuItem.Size = new System.Drawing.Size(401, 44);
-        this.indeterminateCheckOnClickToolStripMenuItem.Text = "Indeterminate CheckOnClick(T)";
-        this.indeterminateCheckOnClickToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None;
-        //
-        // currentDpiLabel
-        //
-        this.currentDpiLabel.AutoSize = true;
-        this.currentDpiLabel.Location = new System.Drawing.Point(22, 66);
-        this.currentDpiLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0);
-        this.currentDpiLabel.Name = "currentDpiLabel";
-        this.currentDpiLabel.Size = new System.Drawing.Size(131, 25);
-        this.currentDpiLabel.TabIndex = 4;
-        this.currentDpiLabel.Text = "current DPI: ";
-        //
-        // MenuStripAndCheckedListBox
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(192F, 192F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(736, 342);
-        this.Controls.Add(this.currentDpiLabel);
-        this.Controls.Add(this.menuStrip1);
-        this.MainMenuStrip = this.menuStrip1;
-        this.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.Name = "MenuStripAndCheckedListBox";
-        this.Text = "MenuStrip and CheckedListBox";
-        this.Load += new System.EventHandler(this.MenuStripScaling_Load);
-        this.DpiChanged += new System.Windows.Forms.DpiChangedEventHandler(this.MenuStripAndCheckedListBox_DpiChanged);
-        this.menuStrip1.ResumeLayout(false);
-        this.menuStrip1.PerformLayout();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.MenuStrip menuStrip1;
-    private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem1;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator1;
-    private System.Windows.Forms.ToolStripMenuItem memoryCardFileToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem navigationToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem1;
-    private System.Windows.Forms.ToolStripMenuItem settingsEditorToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem saveToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem saveAsToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem1;
-    private System.Windows.Forms.ToolStripSeparator toolStripSeparator2;
-    private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem viewToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem insertToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem checkStateSamplesToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem uncheckedToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem uncheckedCheckOnClickToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem checkedToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem checkedCheckOnClickToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem indeterminateToolStripMenuItem;
-    private System.Windows.Forms.ToolStripMenuItem indeterminateCheckOnClickToolStripMenuItem;
-    private System.Windows.Forms.Label currentDpiLabel;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.cs
deleted file mode 100644
index 7d051a98195..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class MenuStripAndCheckedListBox : Form
-{
-    public MenuStripAndCheckedListBox()
-    {
-        InitializeComponent();
-    }
-
-    private void MenuStripScaling_Load(object sender, EventArgs e)
-    {
-        currentDpiLabel.Text = $"Current scaling = {(int)Math.Round((DeviceDpi / 96.0) * 100)}%";
-    }
-
-    private void MenuStripAndCheckedListBox_DpiChanged(object sender, DpiChangedEventArgs e)
-    {
-        currentDpiLabel.Text = $"Current scaling = {(int)Math.Round((DeviceDpi / 96.0) * 100)}%";
-
-        menuStrip1.SuspendLayout();
-
-        float factor = (float)e.DeviceDpiNew / e.DeviceDpiOld;
-
-        //foreach (ToolStripMenuItem item in menuStrip1.Items)
-        //{
-        //    item.Size = new Size((int)Math.Round(factor * item.Width), (int)Math.Round(factor * item.Height));
-        //}
-
-        //int width = menuStrip1.Width;
-        //int height = menuStrip1.Height;
-        //menuStrip1.Size = new Size((int)Math.Round(factor * menuStrip1.Width), (int)Math.Round(factor * menuStrip1.Height));
-
-        Font f = menuStrip1.Font;
-        menuStrip1.Font = new Font(f.FontFamily, f.Size * factor, f.Style);
-
-        menuStrip1.ResumeLayout();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.resx
deleted file mode 100644
index 82a05ef4b33..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MenuStripAndCheckedListBox.resx
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="menuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.Designer.cs
deleted file mode 100644
index 62ca6f03ce5..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.Designer.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MessageBoxes
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.resources = new System.ComponentModel.ComponentResourceManager(typeof(Dialogs));
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.SuspendLayout();
-        // 
-        // propertyGrid1
-        // 
-        this.propertyGrid1.CommandsBorderColor = System.Drawing.SystemColors.Control;
-        this.propertyGrid1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.propertyGrid1.Location = new System.Drawing.Point(171, 0);
-        this.propertyGrid1.Margin = new System.Windows.Forms.Padding(2);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(332, 430);
-        this.propertyGrid1.TabIndex = 0;
-        this.propertyGrid1.SelectedObjectsChanged += new System.EventHandler(this.propertyGrid1_SelectedObjectsChanged);
-        // 
-        // Dialogs
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(503, 430);
-        this.Controls.Add(this.propertyGrid1);
-        this.Name = "Dialogs";
-        this.Text = "Dialogs Test";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-    private System.ComponentModel.ComponentResourceManager resources;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.cs
deleted file mode 100644
index c0287e0687a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-namespace WinformsControlsTest;
-
-public partial class MessageBoxes : Form
-{
-    private readonly ToolStripButton _btnOpen;
-    private readonly MessageBoxProxy _messgageBoxProxy = new();
-
-    public MessageBoxes()
-    {
-        InitializeComponent();
-
-        _btnOpen = new("Show MessageBox")
-        {
-            Image = (System.Drawing.Bitmap?)(resources.GetObject("OpenDialog")),
-            Enabled = false
-        };
-
-        _btnOpen.Click += (s, e) =>
-        {
-            MessageBox.Show(this, _messgageBoxProxy.Text, _messgageBoxProxy.Caption,
-                _messgageBoxProxy.Buttons, _messgageBoxProxy.Icon,
-                _messgageBoxProxy.DefaultButton, _messgageBoxProxy.Options,
-                "mspaint.chm", HelpNavigator.KeywordIndex, "ovals");
-        };
-
-        ToolStrip toolbar = GetToolbar();
-        toolbar.Items.Add(new ToolStripSeparator { Visible = true });
-        toolbar.Items.Add(_btnOpen);
-
-        propertyGrid1.SelectedObject = _messgageBoxProxy;
-    }
-
-    private ToolStrip GetToolbar()
-    {
-        foreach (Control control in propertyGrid1.Controls)
-        {
-            ToolStrip? toolStrip = control as ToolStrip;
-            if (toolStrip is not null)
-            {
-                return toolStrip;
-            }
-        }
-
-        throw new MissingMemberException("Unable to find the toolstrip in the PropertyGrid.");
-    }
-
-    private void propertyGrid1_SelectedObjectsChanged(object sender, EventArgs e)
-    {
-        _btnOpen.Enabled = propertyGrid1.SelectedObject is not null;
-    }
-
-    private class MessageBoxProxy
-    {
-        public string Caption { get; set; } = "My Caption";
-        public string Text { get; set; } = "Opps, I did it again...";
-        public MessageBoxButtons Buttons { get; set; }
-        public MessageBoxIcon Icon { get; set; }
-        public MessageBoxDefaultButton DefaultButton { get; set; }
-        public MessageBoxOptions Options { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.resx
deleted file mode 100644
index 673fcd2cf80..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MessageBoxes.resx
+++ /dev/null
@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=42.42.42.42, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="OpenDialog" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>Resources\OpenDialog.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.Designer.cs
deleted file mode 100644
index 15401442b77..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.Designer.cs
+++ /dev/null
@@ -1,354 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class MultipleControls
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.progressBar1 = new System.Windows.Forms.ProgressBar();
-        this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
-        this.button1 = new System.Windows.Forms.Button();
-        this.label1 = new System.Windows.Forms.Label();
-        this.maskedTextBox1 = new System.Windows.Forms.MaskedTextBox();
-        this.richTextBox1 = new System.Windows.Forms.RichTextBox();
-        this.textBox1 = new System.Windows.Forms.TextBox();
-        this.tabControl1 = new System.Windows.Forms.TabControl();
-        this.tabPage1 = new System.Windows.Forms.TabPage();
-        this.comboBox1 = new System.Windows.Forms.ComboBox();
-        this.tabPage2 = new System.Windows.Forms.TabPage();
-        this.checkBox1 = new System.Windows.Forms.CheckBox();
-        this.checkBox2 = new System.Windows.Forms.CheckBox();
-        this.radioButton2 = new System.Windows.Forms.RadioButton();
-        this.radioButton1 = new System.Windows.Forms.RadioButton();
-        this.groupBox1 = new System.Windows.Forms.GroupBox();
-        this.checkedListBox1 = new System.Windows.Forms.CheckedListBox();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.domainUpDown1 = new System.Windows.Forms.DomainUpDown();
-        this.linkLabel1 = new System.Windows.Forms.LinkLabel();
-        this.linkLabel2 = new System.Windows.Forms.LinkLabel();
-        this.checkedListBox2 = new System.Windows.Forms.CheckedListBox();
-        this.tabControl1.SuspendLayout();
-        this.tabPage1.SuspendLayout();
-        this.tabPage2.SuspendLayout();
-        this.groupBox1.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // progressBar1
-        // 
-        this.progressBar1.Location = new System.Drawing.Point(0, 0);
-        this.progressBar1.Name = "progressBar1";
-        this.progressBar1.Size = new System.Drawing.Size(331, 27);
-        this.progressBar1.TabIndex = 0;
-        // 
-        // backgroundWorker1
-        // 
-        this.backgroundWorker1.WorkerReportsProgress = true;
-        this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork);
-        this.backgroundWorker1.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged);
-        // 
-        // button1
-        // 
-        this.button1.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.button1.Location = new System.Drawing.Point(15, 50);
-        this.button1.Name = "button1";
-        this.button1.Size = new System.Drawing.Size(88, 27);
-        this.button1.TabIndex = 1;
-        this.button1.Text = "button1";
-        this.button1.UseVisualStyleBackColor = true;
-        // 
-        // label1
-        // 
-        this.label1.AccessibleDescription = "Test Label AccessibleDescription";
-        this.label1.AccessibleName = "Test Label AccessibleName";
-        this.label1.AccessibleRole = System.Windows.Forms.AccessibleRole.Indicator;
-        this.label1.AutoSize = true;
-        this.label1.FlatStyle = System.Windows.Forms.FlatStyle.System;
-        this.label1.Location = new System.Drawing.Point(15, 84);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(38, 15);
-        this.label1.TabIndex = 2;
-        this.label1.Text = "label1";
-        // 
-        // maskedTextBox1
-        // 
-        this.maskedTextBox1.Location = new System.Drawing.Point(15, 104);
-        this.maskedTextBox1.Name = "maskedTextBox1";
-        this.maskedTextBox1.Size = new System.Drawing.Size(116, 23);
-        this.maskedTextBox1.TabIndex = 5;
-        this.maskedTextBox1.Text = "Masked";
-        // 
-        // richTextBox1
-        // 
-        this.richTextBox1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point);
-        this.richTextBox1.Location = new System.Drawing.Point(15, 135);
-        this.richTextBox1.Name = "richTextBox1";
-        this.richTextBox1.Size = new System.Drawing.Size(116, 110);
-        this.richTextBox1.TabIndex = 6;
-        this.richTextBox1.Text = "LLLL";
-        // 
-        // textBox1
-        // 
-        this.textBox1.Location = new System.Drawing.Point(15, 264);
-        this.textBox1.Name = "textBox1";
-        this.textBox1.PlaceholderText = "Type some text here...";
-        this.textBox1.Size = new System.Drawing.Size(116, 23);
-        this.textBox1.TabIndex = 7;
-        this.textBox1.Text = "LLLLL";
-        // 
-        // tabControl1
-        // 
-        this.tabControl1.Controls.Add(this.tabPage1);
-        this.tabControl1.Controls.Add(this.tabPage2);
-        this.tabControl1.Location = new System.Drawing.Point(141, 50);
-        this.tabControl1.Name = "tabControl1";
-        this.tabControl1.SelectedIndex = 0;
-        this.tabControl1.ShowToolTips = true;
-        this.tabControl1.Size = new System.Drawing.Size(233, 115);
-        this.tabControl1.TabIndex = 8;
-        // 
-        // tabPage1
-        // 
-        this.tabPage1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
-        this.tabPage1.Controls.Add(this.comboBox1);
-        this.tabPage1.Location = new System.Drawing.Point(4, 24);
-        this.tabPage1.Name = "tabPage1";
-        this.tabPage1.Size = new System.Drawing.Size(225, 87);
-        this.tabPage1.TabIndex = 0;
-        this.tabPage1.Text = "tabPage1";
-        this.tabPage1.ToolTipText = "I am tabPage1!";
-        this.tabPage1.UseVisualStyleBackColor = true;
-        // 
-        // comboBox1
-        // 
-        this.comboBox1.FormattingEnabled = true;
-        this.comboBox1.Location = new System.Drawing.Point(22, 30);
-        this.comboBox1.Name = "comboBox1";
-        this.comboBox1.Size = new System.Drawing.Size(140, 23);
-        this.comboBox1.TabIndex = 0;
-        // 
-        // tabPage2
-        // 
-        this.tabPage2.Controls.Add(this.checkBox1);
-        this.tabPage2.Controls.Add(this.checkBox2);
-        this.tabPage2.Location = new System.Drawing.Point(4, 24);
-        this.tabPage2.Name = "tabPage2";
-        this.tabPage2.Size = new System.Drawing.Size(225, 87);
-        this.tabPage2.TabIndex = 1;
-        this.tabPage2.Text = "tabPage2";
-        this.tabPage2.ToolTipText = "I am tabPage2!\r\nI am multiline tooltip!";
-        this.tabPage2.UseVisualStyleBackColor = true;
-        // 
-        // checkBox1
-        // 
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(8, 22);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(83, 19);
-        this.checkBox1.TabIndex = 0;
-        this.checkBox1.Text = "checkBox1";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        // 
-        // checkBox2
-        // 
-        this.checkBox2.AutoSize = true;
-        this.checkBox2.Location = new System.Drawing.Point(8, 50);
-        this.checkBox2.Name = "checkBox2";
-        this.checkBox2.Size = new System.Drawing.Size(153, 19);
-        this.checkBox2.TabIndex = 0;
-        this.checkBox2.Text = "Three state CheckBox";
-        this.checkBox2.ThreeState = true;
-        this.checkBox2.UseVisualStyleBackColor = true;
-        // 
-        // radioButton2
-        // 
-        this.radioButton2.Location = new System.Drawing.Point(19, 55);
-        this.radioButton2.Name = "radioButton2";
-        this.radioButton2.Size = new System.Drawing.Size(99, 20);
-        this.radioButton2.TabIndex = 1;
-        this.radioButton2.TabStop = true;
-        this.radioButton2.Text = "radioButton2";
-        this.radioButton2.UseVisualStyleBackColor = true;
-        // 
-        // radioButton1
-        // 
-        this.radioButton1.Location = new System.Drawing.Point(19, 29);
-        this.radioButton1.Name = "radioButton1";
-        this.radioButton1.Size = new System.Drawing.Size(99, 20);
-        this.radioButton1.TabIndex = 0;
-        this.radioButton1.TabStop = true;
-        this.radioButton1.Text = "radioButton1";
-        this.radioButton1.UseVisualStyleBackColor = true;
-        // 
-        // groupBox1
-        // 
-        this.groupBox1.AccessibleDescription = "Test GroupBox AccessibleDescription";
-        this.groupBox1.AccessibleName = "Test GroupBox AccessibleName";
-        this.groupBox1.AccessibleRole = System.Windows.Forms.AccessibleRole.Table;
-        this.groupBox1.Controls.Add(this.radioButton2);
-        this.groupBox1.Controls.Add(this.radioButton1);
-        this.groupBox1.Location = new System.Drawing.Point(146, 197);
-        this.groupBox1.Name = "groupBox1";
-        this.groupBox1.Size = new System.Drawing.Size(206, 93);
-        this.groupBox1.TabIndex = 9;
-        this.groupBox1.TabStop = false;
-        this.groupBox1.Text = "groupBox1";
-        // 
-        // checkedListBox1
-        // 
-        this.checkedListBox1.BackColor = System.Drawing.SystemColors.Window;
-        this.checkedListBox1.FormattingEnabled = true;
-        this.checkedListBox1.Items.AddRange(new object[] {
-        "Washington",
-        "California",
-        "Florida",
-        "New York"});
-        this.checkedListBox1.Location = new System.Drawing.Point(378, 49);
-        this.checkedListBox1.Name = "checkedListBox1";
-        this.checkedListBox1.Size = new System.Drawing.Size(140, 112);
-        this.checkedListBox1.TabIndex = 10;
-        this.checkedListBox1.SetItemCheckState(0, CheckState.Checked);
-        this.checkedListBox1.SetItemCheckState(1, CheckState.Indeterminate);
-        // 
-        // numericUpDown1
-        // 
-        this.numericUpDown1.Location = new System.Drawing.Point(378, 197);
-        this.numericUpDown1.Name = "numericUpDown1";
-        this.numericUpDown1.Size = new System.Drawing.Size(140, 23);
-        this.numericUpDown1.TabIndex = 11;
-        // 
-        // domainUpDown1
-        // 
-        this.domainUpDown1.Items.Add("First");
-        this.domainUpDown1.Items.Add("Second");
-        this.domainUpDown1.Items.Add("Third");
-        this.domainUpDown1.Items.Add("Fourth");
-        this.domainUpDown1.Location = new System.Drawing.Point(378, 227);
-        this.domainUpDown1.Name = "domainUpDown1";
-        this.domainUpDown1.Size = new System.Drawing.Size(140, 23);
-        this.domainUpDown1.TabIndex = 12;
-        this.domainUpDown1.Text = "domainUpDown1";
-        // 
-        // linkLabel1
-        // 
-        this.linkLabel1.AutoSize = true;
-        this.linkLabel1.Location = new System.Drawing.Point(62, 84);
-        this.linkLabel1.Name = "linkLabel1";
-        this.linkLabel1.Size = new System.Drawing.Size(60, 15);
-        this.linkLabel1.TabIndex = 3;
-        this.linkLabel1.TabStop = true;
-        this.linkLabel1.Text = "linkLabel1";
-        // 
-        // linkLabel2
-        // 
-        this.linkLabel2.AutoSize = true;
-        this.linkLabel2.Location = new System.Drawing.Point(378, 255);
-        this.linkLabel2.Name = "linkLabel2";
-        this.linkLabel2.Size = new System.Drawing.Size(108, 21);
-        this.linkLabel2.TabIndex = 4;
-        this.linkLabel2.TabStop = true;
-        this.linkLabel2.Text = "Home MSN Github";
-        this.linkLabel2.UseCompatibleTextRendering = true;
-        // 
-        // checkedListBox2
-        // 
-        this.checkedListBox2.BackColor = System.Drawing.SystemColors.Window;
-        this.checkedListBox2.FormattingEnabled = true;
-        this.checkedListBox2.Items.AddRange(new object[] {
-        "Beijing",
-        "Moscow",
-        "Ivanovo",
-        "ShangHai",
-        "Vichuga",
-        "Tokyo"});
-        this.checkedListBox2.Location = new System.Drawing.Point(525, 49);
-        this.checkedListBox2.Name = "checkedListBox2";
-        this.checkedListBox2.Size = new System.Drawing.Size(140, 58);
-        this.checkedListBox2.TabIndex = 13;
-        this.checkedListBox2.SetItemCheckState(0, CheckState.Checked);
-        this.checkedListBox2.SetItemCheckState(1, CheckState.Indeterminate);
-        // 
-        // MultipleControls
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(746, 458);
-        this.Controls.Add(this.checkedListBox2);
-        this.Controls.Add(this.domainUpDown1);
-        this.Controls.Add(this.numericUpDown1);
-        this.Controls.Add(this.checkedListBox1);
-        this.Controls.Add(this.groupBox1);
-        this.Controls.Add(this.tabControl1);
-        this.Controls.Add(this.textBox1);
-        this.Controls.Add(this.richTextBox1);
-        this.Controls.Add(this.maskedTextBox1);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.button1);
-        this.Controls.Add(this.progressBar1);
-        this.Controls.Add(this.linkLabel1);
-        this.Controls.Add(this.linkLabel2);
-        this.Name = "MultipleControls";
-        this.Text = "These look ok";
-        this.Load += new System.EventHandler(this.Test3_Load);
-        this.tabControl1.ResumeLayout(false);
-        this.tabPage1.ResumeLayout(false);
-        this.tabPage2.ResumeLayout(false);
-        this.tabPage2.PerformLayout();
-        this.groupBox1.ResumeLayout(false);
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ProgressBar progressBar1;
-    private System.ComponentModel.BackgroundWorker backgroundWorker1;
-    private System.Windows.Forms.Button button1;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.MaskedTextBox maskedTextBox1;
-    private System.Windows.Forms.RichTextBox richTextBox1;
-    private System.Windows.Forms.TextBox textBox1;
-    private System.Windows.Forms.TabControl tabControl1;
-    private System.Windows.Forms.TabPage tabPage1;
-    private System.Windows.Forms.ComboBox comboBox1;
-    private System.Windows.Forms.TabPage tabPage2;
-    private System.Windows.Forms.CheckBox checkBox1;
-    private System.Windows.Forms.CheckBox checkBox2;
-    private System.Windows.Forms.RadioButton radioButton2;
-    private System.Windows.Forms.RadioButton radioButton1;
-    private System.Windows.Forms.GroupBox groupBox1;
-    private System.Windows.Forms.CheckedListBox checkedListBox1;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-    private System.Windows.Forms.DomainUpDown domainUpDown1;
-    private System.Windows.Forms.LinkLabel linkLabel1;
-    private System.Windows.Forms.LinkLabel linkLabel2;
-    private System.Windows.Forms.CheckedListBox checkedListBox2;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.cs
deleted file mode 100644
index c1b6756f150..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class MultipleControls : Form
-{
-    public MultipleControls()
-    {
-        InitializeComponent();
-        CreateMyListView();
-    }
-
-    private void CreateMyListView()
-    {
-        // Create a new ListView control.
-        ListView listView2 = new ListView
-        {
-            Bounds = new Rectangle(new Point(0, 0), new Size(400, 200)),
-
-            // Set the view to show details.
-            View = View.Details,
-            // Allow the user to edit item text.
-            LabelEdit = true,
-            // Allow the user to rearrange columns.
-            AllowColumnReorder = true,
-            // Display check boxes.
-            CheckBoxes = true,
-            // Select the item and subitems when selection is made.
-            FullRowSelect = true,
-            // Display grid lines.
-            GridLines = true,
-            // Sort the items in the list in ascending order.
-            Sorting = SortOrder.Ascending,
-
-            VirtualMode = true,
-            VirtualListSize = 3,
-        };
-
-        // Create three items and three sets of subitems for each item.
-        ListViewItem item1 = new("item1", 0)
-        {
-            // Place a check mark next to the item.
-            Checked = true
-        };
-        item1.SubItems.Add("sub1");
-        item1.SubItems.Add("sub2");
-        item1.SubItems.Add("sub3");
-        ListViewItem item2 = new("item2", 1);
-        item2.SubItems.Add("sub4");
-        item2.SubItems.Add("sub5");
-        item2.SubItems.Add("sub6");
-        ListViewItem item3 = new("item3", 0)
-        {
-            // Place a check mark next to the item.
-            Checked = true
-        };
-        item3.SubItems.Add("sub7");
-        item3.SubItems.Add("sub8");
-        item3.SubItems.Add("sub9");
-
-        // Add the items to the ListView, but because the listview is in Virtual Mode, we have to manage items ourselves
-        // and thus, we can't call the following:
-        //      listView2.Items.AddRange(new ListViewItem[] { item1, item2, item3 });
-        listView2.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => item1,
-                1 => item2,
-                2 => item3,
-                _ => throw new IndexOutOfRangeException(),
-            };
-        };
-
-        // Create columns for the items and subitems.
-        // Width of -2 indicates auto-size.
-        listView2.Columns.Add("column1", "Item Column", -2, HorizontalAlignment.Left, 0);
-        listView2.Columns.Add("Column 2", -2, HorizontalAlignment.Left);
-        listView2.Columns.Add("Column 3", -2, HorizontalAlignment.Left);
-        listView2.Columns.Add("Column 4", -2, HorizontalAlignment.Center);
-        listView2.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
-
-        // Create two ImageList objects.
-        ImageList imageListSmall = new();
-        ImageList imageListLarge = new();
-
-        // Initialize the ImageList objects with bitmaps.
-        imageListSmall.Images.Add(Bitmap.FromFile("Images\\SmallA.bmp"));
-        imageListSmall.Images.Add(Bitmap.FromFile("Images\\SmallABlue.bmp"));
-        imageListLarge.Images.Add(Bitmap.FromFile("Images\\LargeA.bmp"));
-        imageListLarge.Images.Add(Bitmap.FromFile("Images\\LargeABlue.bmp"));
-
-        // Assign the ImageList objects to the ListView.
-        listView2.LargeImageList = imageListLarge;
-        listView2.SmallImageList = imageListSmall;
-
-        // Add the ListView to the control collection.
-        Controls.Add(listView2);
-        listView2.Dock = DockStyle.Bottom;
-    }
-
-    private void Test3_Load(object sender, EventArgs e)
-    {
-        backgroundWorker1.RunWorkerAsync();
-    }
-
-    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
-    {
-        for (int i = 1; i < 100; i++)
-        {
-            Thread.Sleep(100);
-            backgroundWorker1.ReportProgress(i);
-        }
-    }
-
-    private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
-    {
-        progressBar1.Value = e.ProgressPercentage;
-    }
-
-    private void Button1_Click(object sender, System.EventArgs e)
-    {
-        textBox1.Enabled = !textBox1.Enabled;
-    }
-
-    private void MenuStripScaling_Load(object sender, EventArgs e)
-    {
-        checkedListBox1.Items.Add("Pennsylvania", CheckState.Checked);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.resx
deleted file mode 100644
index 566e3bc91db..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/MultipleControls.resx
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="backgroundWorker1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.Designer.cs
deleted file mode 100644
index 4aebfa95b4e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.Designer.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class Panels
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Panels));
-        this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
-        this.tableLayoutPanel2 = new System.Windows.Forms.TableLayoutPanel();
-        this.tableLayoutPanel3 = new System.Windows.Forms.TableLayoutPanel();
-        this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
-        this.numericUpDown2 = new System.Windows.Forms.NumericUpDown();
-        this.currentDPILabel1 = new CurrentDPILabel();
-        this.tableLayoutPanel1.SuspendLayout();
-        this.tableLayoutPanel2.SuspendLayout();
-        this.tableLayoutPanel3.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown2)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // tableLayoutPanel1
-        // 
-        this.tableLayoutPanel1.BackColor = System.Drawing.Color.FromArgb((int)(byte)128, (int)(byte)255, (int)(byte)128);
-        resources.ApplyResources(this.tableLayoutPanel1, "tableLayoutPanel1");
-        this.tableLayoutPanel1.Controls.Add(this.tableLayoutPanel2, 0, 0);
-        this.tableLayoutPanel1.Name = "tableLayoutPanel1";
-        // 
-        // tableLayoutPanel2
-        // 
-        this.tableLayoutPanel2.BackColor = System.Drawing.Color.FromArgb((int)(byte)255, (int)(byte)255, (int)(byte)128);
-        resources.ApplyResources(this.tableLayoutPanel2, "tableLayoutPanel2");
-        this.tableLayoutPanel2.Controls.Add(this.tableLayoutPanel3, 0, 0);
-        this.tableLayoutPanel2.Controls.Add(this.currentDPILabel1, 0, 1);
-        this.tableLayoutPanel2.Name = "tableLayoutPanel2";
-        // 
-        // tableLayoutPanel3
-        // 
-        this.tableLayoutPanel3.BackColor = System.Drawing.Color.FromArgb((int)(byte)128, (int)(byte)255, (int)(byte)255);
-        resources.ApplyResources(this.tableLayoutPanel3, "tableLayoutPanel3");
-        this.tableLayoutPanel3.Controls.Add(this.numericUpDown1, 1, 0);
-        this.tableLayoutPanel3.Controls.Add(this.numericUpDown2, 1, 1);
-        this.tableLayoutPanel3.Name = "tableLayoutPanel3";
-        // 
-        // numericUpDown1
-        // 
-        resources.ApplyResources(this.numericUpDown1, "numericUpDown1");
-        this.numericUpDown1.Name = "numericUpDown1";
-        // 
-        // numericUpDown2
-        // 
-        resources.ApplyResources(this.numericUpDown2, "numericUpDown2");
-        this.numericUpDown2.Name = "numericUpDown2";
-        // 
-        // currentDPILabel1
-        // 
-        resources.ApplyResources(this.currentDPILabel1, "currentDPILabel1");
-        this.currentDPILabel1.BackColor = System.Drawing.Color.FromArgb((int)(byte)255, (int)(byte)128, (int)(byte)255);
-        this.currentDPILabel1.Name = "currentDPILabel1";
-        // 
-        // Panels
-        // 
-        resources.ApplyResources(this, "$this");
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.Controls.Add(this.tableLayoutPanel1);
-        this.Name = "Panels";
-        this.tableLayoutPanel1.ResumeLayout(false);
-        this.tableLayoutPanel2.ResumeLayout(false);
-        this.tableLayoutPanel2.PerformLayout();
-        this.tableLayoutPanel3.ResumeLayout(false);
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown2)).EndInit();
-        this.ResumeLayout(false);
-
-    }
-    #endregion
-
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel2;
-    private System.Windows.Forms.TableLayoutPanel tableLayoutPanel3;
-    private System.Windows.Forms.NumericUpDown numericUpDown1;
-    private System.Windows.Forms.NumericUpDown numericUpDown2;
-    private CurrentDPILabel currentDPILabel1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.cs
deleted file mode 100644
index 558205d3ea8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class Panels : Form
-{
-    public Panels()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.resx
deleted file mode 100644
index a841a0fc349..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Panels.resx
+++ /dev/null
@@ -1,271 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="tableLayoutPanel1.CellBorderStyle" type="System.Windows.Forms.TableLayoutPanelCellBorderStyle, System.Windows.Forms">
-    <value>Single</value>
-  </data>
-  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="tableLayoutPanel1.ColumnCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="tableLayoutPanel2.CellBorderStyle" type="System.Windows.Forms.TableLayoutPanelCellBorderStyle, System.Windows.Forms">
-    <value>Single</value>
-  </data>
-  <data name="tableLayoutPanel2.ColumnCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="tableLayoutPanel3.CellBorderStyle" type="System.Windows.Forms.TableLayoutPanelCellBorderStyle, System.Windows.Forms">
-    <value>InsetDouble</value>
-  </data>
-  <data name="tableLayoutPanel3.ColumnCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="numericUpDown1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>155, 7</value>
-  </data>
-  <data name="numericUpDown1.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="numericUpDown1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>138, 26</value>
-  </data>
-  <data name="numericUpDown1.TabIndex" type="System.Int32, mscorlib">
-    <value>6</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown1.Name" xml:space="preserve">
-    <value>numericUpDown1</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown1.Parent" xml:space="preserve">
-    <value>tableLayoutPanel3</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown1.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <data name="numericUpDown2.Location" type="System.Drawing.Point, System.Drawing">
-    <value>155, 44</value>
-  </data>
-  <data name="numericUpDown2.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="numericUpDown2.Size" type="System.Drawing.Size, System.Drawing">
-    <value>138, 26</value>
-  </data>
-  <data name="numericUpDown2.TabIndex" type="System.Int32, mscorlib">
-    <value>7</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown2.Name" xml:space="preserve">
-    <value>numericUpDown2</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown2.Type" xml:space="preserve">
-    <value>System.Windows.Forms.NumericUpDown, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown2.Parent" xml:space="preserve">
-    <value>tableLayoutPanel3</value>
-  </data>
-  <data name="&gt;&gt;numericUpDown2.ZOrder" xml:space="preserve">
-    <value>1</value>
-  </data>
-  <data name="tableLayoutPanel3.Location" type="System.Drawing.Point, System.Drawing">
-    <value>5, 5</value>
-  </data>
-  <data name="tableLayoutPanel3.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="tableLayoutPanel3.RowCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="tableLayoutPanel3.Size" type="System.Drawing.Size, System.Drawing">
-    <value>300, 150</value>
-  </data>
-  <data name="tableLayoutPanel3.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel3.Name" xml:space="preserve">
-    <value>tableLayoutPanel3</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel3.Type" xml:space="preserve">
-    <value>System.Windows.Forms.TableLayoutPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel3.Parent" xml:space="preserve">
-    <value>tableLayoutPanel2</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel3.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <data name="tableLayoutPanel3.LayoutSettings" type="System.Windows.Forms.TableLayoutSettings, System.Windows.Forms">
-    <value>&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;TableLayoutSettings&gt;&lt;Controls&gt;&lt;Control Name="numericUpDown1" Row="0" RowSpan="1" Column="1" ColumnSpan="1" /&gt;&lt;Control Name="numericUpDown2" Row="1" RowSpan="1" Column="1" ColumnSpan="1" /&gt;&lt;/Controls&gt;&lt;Columns Styles="Percent,50,Percent,50" /&gt;&lt;Rows Styles="AutoSize,0,AutoSize,0" /&gt;&lt;/TableLayoutSettings&gt;</value>
-  </data>
-  <data name="currentDPILabel1.AutoSize" type="System.Boolean, mscorlib">
-    <value>True</value>
-  </data>
-  <data name="currentDPILabel1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>12, 287</value>
-  </data>
-  <data name="currentDPILabel1.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>11, 11, 11, 4</value>
-  </data>
-  <data name="currentDPILabel1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>175, 20</value>
-  </data>
-  <data name="currentDPILabel1.TabIndex" type="System.Int32, mscorlib">
-    <value>1</value>
-  </data>
-  <data name="currentDPILabel1.Text" xml:space="preserve">
-    <value>Current scaling is 150%</value>
-  </data>
-  <data name="&gt;&gt;currentDPILabel1.Name" xml:space="preserve">
-    <value>currentDPILabel1</value>
-  </data>
-  <data name="&gt;&gt;currentDPILabel1.Type" xml:space="preserve">
-    <value>WindowsFormsApp1.CurrentDPILabel, WindowsFormsApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null</value>
-  </data>
-  <data name="&gt;&gt;currentDPILabel1.Parent" xml:space="preserve">
-    <value>tableLayoutPanel2</value>
-  </data>
-  <data name="&gt;&gt;currentDPILabel1.ZOrder" xml:space="preserve">
-    <value>1</value>
-  </data>
-  <data name="tableLayoutPanel2.Location" type="System.Drawing.Point, System.Drawing">
-    <value>5, 5</value>
-  </data>
-  <data name="tableLayoutPanel2.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="tableLayoutPanel2.RowCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="tableLayoutPanel2.Size" type="System.Drawing.Size, System.Drawing">
-    <value>391, 329</value>
-  </data>
-  <data name="tableLayoutPanel2.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel2.Name" xml:space="preserve">
-    <value>tableLayoutPanel2</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel2.Type" xml:space="preserve">
-    <value>System.Windows.Forms.TableLayoutPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel2.Parent" xml:space="preserve">
-    <value>tableLayoutPanel1</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel2.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <data name="tableLayoutPanel2.LayoutSettings" type="System.Windows.Forms.TableLayoutSettings, System.Windows.Forms">
-    <value>&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;TableLayoutSettings&gt;&lt;Controls&gt;&lt;Control Name="tableLayoutPanel3" Row="0" RowSpan="1" Column="0" ColumnSpan="1" /&gt;&lt;Control Name="currentDPILabel1" Row="1" RowSpan="1" Column="0" ColumnSpan="1" /&gt;&lt;/Controls&gt;&lt;Columns Styles="Percent,83.14176,Percent,16.85824" /&gt;&lt;Rows Styles="Percent,84.1629,Percent,15.8371" /&gt;&lt;/TableLayoutSettings&gt;</value>
-  </data>
-  <data name="tableLayoutPanel1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>0, 2</value>
-  </data>
-  <data name="tableLayoutPanel1.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="tableLayoutPanel1.RowCount" type="System.Int32, mscorlib">
-    <value>2</value>
-  </data>
-  <data name="tableLayoutPanel1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>428, 384</value>
-  </data>
-  <data name="tableLayoutPanel1.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel1.Name" xml:space="preserve">
-    <value>tableLayoutPanel1</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.TableLayoutPanel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel1.Parent" xml:space="preserve">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;tableLayoutPanel1.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <data name="tableLayoutPanel1.LayoutSettings" type="System.Windows.Forms.TableLayoutSettings, System.Windows.Forms">
-    <value>&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;TableLayoutSettings&gt;&lt;Controls&gt;&lt;Control Name="tableLayoutPanel2" Row="0" RowSpan="1" Column="0" ColumnSpan="1" /&gt;&lt;/Controls&gt;&lt;Columns Styles="Percent,94.03509,Percent,5.964912" /&gt;&lt;Rows Styles="Percent,88.67188,Percent,11.32813" /&gt;&lt;/TableLayoutSettings&gt;</value>
-  </data>
-  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
-    <value>144, 144</value>
-  </data>
-  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
-    <value>426, 392</value>
-  </data>
-  <data name="$this.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>4, 4, 4, 4</value>
-  </data>
-  <data name="$this.Text" xml:space="preserve">
-    <value>TableLayoutPanels</value>
-  </data>
-  <data name="&gt;&gt;$this.Name" xml:space="preserve">
-    <value>Panels</value>
-  </data>
-  <data name="&gt;&gt;$this.Type" xml:space="preserve">
-    <value>System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.Designer.cs
deleted file mode 100644
index ee1e90da208..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.Designer.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class PictureBoxes
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.pictureBox1 = new System.Windows.Forms.PictureBox();
-        this.btnloadImage = new System.Windows.Forms.Button();
-        this.imageUri = new System.Windows.Forms.TextBox();
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // pictureBox1
-        // 
-        this.pictureBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-        | System.Windows.Forms.AnchorStyles.Left) 
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.pictureBox1.Location = new System.Drawing.Point(11, 39);
-        this.pictureBox1.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
-        this.pictureBox1.Name = "pictureBox1";
-        this.pictureBox1.Size = new System.Drawing.Size(584, 281);
-        this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
-        this.pictureBox1.TabIndex = 0;
-        this.pictureBox1.TabStop = false;
-        this.pictureBox1.LoadCompleted += new System.ComponentModel.AsyncCompletedEventHandler(this.pictureBox1_LoadCompleted);
-        this.pictureBox1.LoadProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.pictureBox1_LoadProgressChanged);
-        // 
-        // btnloadImage
-        // 
-        this.btnloadImage.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-        this.btnloadImage.Location = new System.Drawing.Point(539, 9);
-        this.btnloadImage.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
-        this.btnloadImage.Name = "btnloadImage";
-        this.btnloadImage.Size = new System.Drawing.Size(56, 23);
-        this.btnloadImage.TabIndex = 1;
-        this.btnloadImage.Text = "Load";
-        this.btnloadImage.UseVisualStyleBackColor = true;
-        this.btnloadImage.Click += new System.EventHandler(this.btnloadImage_Click);
-        // 
-        // imageUri
-        // 
-        this.imageUri.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.imageUri.Location = new System.Drawing.Point(13, 11);
-        this.imageUri.MaxLength = 500;
-        this.imageUri.Name = "imageUri";
-        this.imageUri.Size = new System.Drawing.Size(521, 20);
-        this.imageUri.TabIndex = 0;
-        this.imageUri.Text = "https://initiate.alphacoders.com/download/wallpaper/685514/images5/jpg/2283681847" +
-"13846/97229";
-        // 
-        // PictureBoxes
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(606, 331);
-        this.Controls.Add(this.imageUri);
-        this.Controls.Add(this.btnloadImage);
-        this.Controls.Add(this.pictureBox1);
-        this.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
-        this.Name = "PictureBoxes";
-        this.Text = "Form1";
-        ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.PictureBox pictureBox1;
-    private System.Windows.Forms.Button btnloadImage;
-    private System.Windows.Forms.TextBox imageUri;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.cs
deleted file mode 100644
index c7769bde2c7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace WinformsControlsTest;
-
-public partial class PictureBoxes : Form
-{
-    private const string Heading = "PictureBox tests";
-    private bool _isLoading;
-
-    public PictureBoxes()
-    {
-        InitializeComponent();
-        Text = Heading;
-    }
-
-    private void btnloadImage_Click(object sender, EventArgs e)
-    {
-        if (string.IsNullOrWhiteSpace(imageUri.Text))
-        {
-            pictureBox1.Image = null;
-            if (_isLoading)
-            {
-                pictureBox1.CancelAsync();
-            }
-
-            return;
-        }
-
-        try
-        {
-            _isLoading = true;
-            pictureBox1.WaitOnLoad = false;
-            pictureBox1.LoadAsync(imageUri.Text);
-        }
-        catch (Exception ex)
-        {
-            MessageBox.Show(ex.Message);
-        }
-    }
-
-    private void pictureBox1_LoadCompleted(object sender, AsyncCompletedEventArgs e)
-    {
-        _isLoading = false;
-        Text = Heading;
-
-        if (e.Cancelled)
-        {
-            MessageBox.Show("Image loading cancelled");
-        }
-
-        if (e.Error is not null)
-        {
-            MessageBox.Show(e.Error.Message, $"{e.Error.GetType().FullName} occurred");
-        }
-    }
-
-    private void pictureBox1_LoadProgressChanged(object sender, ProgressChangedEventArgs e)
-    {
-        Text = $"{Heading}: loading image progress: {e.ProgressPercentage}%";
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PictureBoxes.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Program.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Program.cs
deleted file mode 100644
index 37d27b7e03a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Program.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using WinformsControlsTest;
-
-// Set STAThread
-Thread.CurrentThread.SetApartmentState(ApartmentState.Unknown);
-Thread.CurrentThread.SetApartmentState(ApartmentState.STA);
-ApplicationConfiguration.Initialize();
-
-Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
-Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
-
-try
-{
-    MainForm form = new()
-    {
-        Icon = SystemIcons.GetStockIcon(StockIconId.Shield, StockIconOptions.SmallIcon)
-    };
-
-    Application.Run(form);
-}
-catch (Exception)
-{
-    Environment.Exit(-1);
-}
-
-Environment.Exit(0);
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Properties/launchSettings.json b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Properties/launchSettings.json
deleted file mode 100644
index 08e953811bc..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Properties/launchSettings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "WinformsControlsTest": {
-      "commandName": "Project",
-      "nativeDebugging": false
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.Designer.cs
deleted file mode 100644
index 792ffe1e95e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.Designer.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class PropertyGrid
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.propertyGrid1 = new System.Windows.Forms.PropertyGrid();
-        this.SuspendLayout();
-        //
-        // propertyGrid1
-        //
-        this.propertyGrid1.CommandsBorderColor = System.Drawing.SystemColors.Control;
-        this.propertyGrid1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.propertyGrid1.Location = new System.Drawing.Point(0, 0);
-        this.propertyGrid1.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
-        this.propertyGrid1.Name = "propertyGrid1";
-        this.propertyGrid1.Size = new System.Drawing.Size(465, 413);
-        this.propertyGrid1.TabIndex = 0;
-        //
-        // PropertyGrid
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(465, 413);
-        this.Controls.Add(this.propertyGrid1);
-        this.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
-        this.Name = "PropertyGrid";
-        this.Text = "Property Grid Test";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.PropertyGrid propertyGrid1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.cs
deleted file mode 100644
index ef3653fd8e0..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class PropertyGrid : Form
-{
-    public PropertyGrid(object selectedObject)
-    {
-        InitializeComponent();
-        propertyGrid1.SelectedObject = selectedObject;
-    }
-
-    // VS designer specific
-    private PropertyGrid()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/PropertyGrid.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/OpenDialog.png b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/OpenDialog.png
deleted file mode 100644
index 2cadf74aaf8..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/OpenDialog.png and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/media.mpg b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/media.mpg
deleted file mode 100644
index 24d661f874e..00000000000
Binary files a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Resources/media.mpg and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.Designer.cs
deleted file mode 100644
index c3968de1d92..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.Designer.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class RichTextBoxes
-{
-    /// <summary>
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    /// Required method for Designer support - do not modify
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.richTextBox1 = new System.Windows.Forms.RichTextBox();
-        this.richTextBox2 = new System.Windows.Forms.RichTextBox();
-        this.SuspendLayout();
-        // 
-        // richTextBox1
-        // 
-        this.richTextBox1.Dock = System.Windows.Forms.DockStyle.Top;
-        this.richTextBox1.Location = new System.Drawing.Point(0, 0);
-        this.richTextBox1.Name = "richTextBox1";
-        this.richTextBox1.Size = new System.Drawing.Size(455, 104);
-        this.richTextBox1.TabIndex = 0;
-        this.richTextBox1.Text = "";
-        this.richTextBox1.LinkClicked += new System.Windows.Forms.LinkClickedEventHandler(this.richTextBox1_LinkClicked);
-        // 
-        // richTextBox2
-        // 
-        this.richTextBox2.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.richTextBox2.Location = new System.Drawing.Point(0, 104);
-        this.richTextBox2.Name = "richTextBox2";
-        this.richTextBox2.Size = new System.Drawing.Size(455, 99);
-        this.richTextBox2.TabIndex = 1;
-        this.richTextBox2.Text = "";
-        this.richTextBox2.LinkClicked += new System.Windows.Forms.LinkClickedEventHandler(this.richTextBox2_LinkClicked);
-        // 
-        // RichTextBoxes
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(455, 203);
-        this.Controls.Add(this.richTextBox2);
-        this.Controls.Add(this.richTextBox1);
-        this.Name = "RichTextBoxes";
-        this.Text = "Form2";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.RichTextBox richTextBox1;
-    private System.Windows.Forms.RichTextBox richTextBox2;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.cs
deleted file mode 100644
index 6c65256a79f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32;
-using Windows.Win32.Foundation;
-
-namespace WinformsControlsTest;
-
-public partial class RichTextBoxes : Form
-{
-    public RichTextBoxes()
-    {
-        InitializeComponent();
-
-        richTextBox1.LoadFile(File.OpenRead(@"Data\example.rtf"), RichTextBoxStreamType.RichText);
-        Load += Form1_Load;
-    }
-
-    private void Form1_Load(object sender, EventArgs e)
-    {
-        richTextBox2.Rtf = @"{\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang4105{\fonttbl{\f0\fnil\fcharset0 Calibri;}}
-{\*\generator Riched20 10.0.17134}\viewkind4\uc1 
-{\field{\*\fldinst { HYPERLINK ""http://www.google.com"" }}{\fldrslt {Click here}}}
-\pard\sa200\sl276\slmult1\f0\fs22\lang9  for more information.\par
-This is a \v #data#\v0 custom link with hidden text before the link.\par
-This is a custom link\v #data#\v0  with hidden text after the link.\par
-}";
-
-        // Allow setting custom links.
-        richTextBox2.DetectUrls = false;
-
-        MakeLink(richTextBox2, "#data#custom link");
-        MakeLink(richTextBox2, "custom link#data#");
-    }
-
-    private unsafe void MakeLink(RichTextBox control, string text)
-    {
-        control.Select(control.Text.IndexOf(text), text.Length);
-
-        var format = new Interop.Richedit.CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(Interop.Richedit.CHARFORMAT2W),
-            dwMask = Interop.Richedit.CFM.LINK,
-            dwEffects = Interop.Richedit.CFE.LINK,
-        };
-
-        PInvoke.SendMessage(
-            control,
-            PInvoke.EM_SETCHARFORMAT,
-            (WPARAM)(uint)Interop.Richedit.SCF.SELECTION,
-            ref format);
-
-        control.Select(0, 0);
-    }
-
-    private string ReportLinkClickedEventArgs(object sender, LinkClickedEventArgs e)
-    {
-        var control = (RichTextBox)sender;
-        var prefix = control.Text.Remove(e.LinkStart);
-        var content = control.Text.Substring(e.LinkStart, e.LinkLength);
-        var suffix = control.Text.Substring(e.LinkStart + e.LinkLength);
-
-        var index = prefix.LastIndexOf('\n');
-        if (index >= 0)
-        {
-            prefix = prefix.Substring(index + 1);
-        }
-
-        index = suffix.IndexOf('\n');
-        if (index >= 0)
-        {
-            suffix = suffix.Remove(index);
-        }
-
-        return
-            $"""
-                LinkText: {e.LinkText}
-                LinkStart: {e.LinkStart}
-                LinkLength: {e.LinkLength}
-
-                Span prefix: {prefix}
-                Span content: {content}
-                Span suffix: {suffix}
-                """;
-    }
-
-    private void richTextBox1_LinkClicked(object sender, LinkClickedEventArgs e)
-    {
-        MessageBox.Show(this, ReportLinkClickedEventArgs(sender, e), "link clicked");
-    }
-
-    private void richTextBox2_LinkClicked(object sender, LinkClickedEventArgs e)
-    {
-        MessageBox.Show(this, ReportLinkClickedEventArgs(sender, e), "link clicked");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/RichTextBoxes.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.Designer.cs
deleted file mode 100644
index b22bc54601b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.Designer.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ScalingBeforeChanges
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.checkBox1 = new WinformsControlsTest.MyCheckBox();
-        this.SuspendLayout();
-        //
-        // checkBox1
-        //
-        this.checkBox1.AutoSize = true;
-        this.checkBox1.Location = new System.Drawing.Point(39, 73);
-        this.checkBox1.Name = "checkBox1";
-        this.checkBox1.Size = new System.Drawing.Size(80, 17);
-        this.checkBox1.TabIndex = 0;
-        this.checkBox1.Text = "checkBox1";
-        this.checkBox1.UseVisualStyleBackColor = true;
-        //
-        // Form1
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.ClientSize = new System.Drawing.Size(284, 261);
-        this.Controls.Add(this.checkBox1);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private MyCheckBox checkBox1;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.cs
deleted file mode 100644
index 2ea33ee98ee..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.cs
+++ /dev/null
@@ -1,136 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32;
-using Windows.Win32.Foundation;
-using Windows.Win32.Graphics.Gdi;
-using Windows.Win32.UI.WindowsAndMessaging;
-
-namespace WinformsControlsTest;
-
-public partial class ScalingBeforeChanges : Form
-{
-    public ScalingBeforeChanges()
-    {
-        InitializeComponent();
-    }
-
-    [DllImport("user32", ExactSpelling = true)]
-    internal static extern bool EnableNonClientDpiScaling(HandleRef hWnd);
-
-    [DllImport("user32", EntryPoint = "#2704")]
-    internal static extern bool EnableChildWindowDpiMessage(HandleRef hWnd, bool fEnable);
-
-    internal const double LogicalDpi = 96.0;
-    internal const int LOGPIXELSX = 88;
-    internal const int LOGPIXELSY = 90;
-
-    internal static void GetDevicePixels(HWND hwnd, out double x, out double y)
-    {
-        x = LogicalDpi;
-        y = LogicalDpi;
-
-        using GetDcScope dc = new(hwnd);
-        if (!dc.IsNull)
-        {
-            x = PInvoke.GetDeviceCaps(dc, GET_DEVICE_CAPS_INDEX.LOGPIXELSX);
-            y = PInvoke.GetDeviceCaps(dc, GET_DEVICE_CAPS_INDEX.LOGPIXELSY);
-        }
-    }
-
-    private double _deviceDpiX, _deviceDpiY;
-
-    protected override void OnHandleCreated(EventArgs e)
-    {
-        base.OnHandleCreated(e);
-        GetDevicePixels((HWND)Handle, out _deviceDpiX, out _deviceDpiY);
-        EnableNonClientDpiScaling(new HandleRef(this, Handle));
-        EnableChildWindowDpiMessage(new HandleRef(this, Handle), true);
-        GC.KeepAlive(this);
-    }
-
-    internal static int LOWORD(IntPtr param)
-    {
-        return (int)(short)(unchecked((int)(long)param) & 0xFFFF);
-    }
-
-    internal static int HIWORD(IntPtr param)
-    {
-        return (int)(short)((unchecked((int)(long)param) >> 16) & 0xFFFF);
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct RECT
-    {
-        public int left;
-        public int top;
-        public int right;
-        public int bottom;
-    }
-
-    protected override void WndProc(ref Message m)
-    {
-        base.WndProc(ref m);
-        switch (m.MsgInternal)
-        {
-            case PInvoke.WM_DPICHANGED:
-                int x = LOWORD(m.WParam);
-                int y = HIWORD(m.WParam);
-                if (x != _deviceDpiX || y != _deviceDpiY)
-                {
-                    RECT suggestedRect = Marshal.PtrToStructure<RECT>(m.LParam);
-
-                    PInvoke.SetWindowPos(
-                        this,
-                        HWND.Null,
-                        suggestedRect.left,
-                        suggestedRect.top,
-                        suggestedRect.right - suggestedRect.left,
-                        suggestedRect.bottom - suggestedRect.top,
-                        SET_WINDOW_POS_FLAGS.SWP_NOZORDER | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE);
-
-                    float factorX = (float)(x / _deviceDpiX);
-                    float factorY = (float)(y / _deviceDpiY);
-                    _deviceDpiY = y;
-                    _deviceDpiX = x;
-
-                    Font = new Font(this.Font.FontFamily, this.Font.Size * factorY, this.Font.Style);
-
-                    checkBox1.Scale(new SizeF(factorX, factorY));
-                }
-
-                m.Result = IntPtr.Zero;
-                break;
-        }
-    }
-}
-
-public class MyCheckBox : CheckBox
-{
-    public MyCheckBox() : base()
-    {
-    }
-
-    protected override void WndProc(ref Message m)
-    {
-        uint dpi;
-        switch (m.MsgInternal)
-        {
-            case PInvoke.WM_DPICHANGED_BEFOREPARENT:
-                dpi = PInvoke.GetDpiForWindow(this);
-                Debug.WriteLine($"WM_DPICHANGED_BEFOREPARENT  {dpi}");
-
-                m.Result = (IntPtr)1;
-                break;
-            case PInvoke.WM_DPICHANGED_AFTERPARENT:
-                dpi = PInvoke.GetDpiForWindow(this);
-                Debug.WriteLine($"WM_DPICHANGED_AFTERPARENT {dpi}");
-                m.Result = (IntPtr)1;
-                break;
-        }
-
-        base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScalingBeforeChanges.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.Designer.cs
deleted file mode 100644
index 56b8a8545c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.Designer.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-
-namespace WinformsControlsTest;
-
-partial class ScrollBars
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.hScrollBar = new System.Windows.Forms.HScrollBar();
-        this.vScrollBar = new System.Windows.Forms.VScrollBar();
-        this.numericMinimum = new System.Windows.Forms.NumericUpDown();
-        this.numericMaximum = new System.Windows.Forms.NumericUpDown();
-        this.chbRightToLeft = new System.Windows.Forms.CheckBox();
-        this.lblMinimum = new System.Windows.Forms.Label();
-        this.lblMaximum = new System.Windows.Forms.Label();
-        this.lblHValue = new System.Windows.Forms.Label();
-        this.lblVValue = new System.Windows.Forms.Label();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMinimum)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMaximum)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // hScrollBar
-        // 
-        this.hScrollBar.Location = new System.Drawing.Point(37, 63);
-        this.hScrollBar.Name = "hScrollBar";
-        this.hScrollBar.Size = new System.Drawing.Size(200, 26);
-        this.hScrollBar.TabIndex = 0;
-        this.hScrollBar.Scroll += new System.Windows.Forms.ScrollEventHandler(this.hScrollBar_Scroll);
-        // 
-        // vScrollBar
-        // 
-        this.vScrollBar.Location = new System.Drawing.Point(275, 63);
-        this.vScrollBar.Name = "vScrollBar";
-        this.vScrollBar.Size = new System.Drawing.Size(26, 200);
-        this.vScrollBar.TabIndex = 1;
-        this.vScrollBar.Scroll += new System.Windows.Forms.ScrollEventHandler(this.vScrollBar_Scroll);
-        // 
-        // numericMinimum
-        // 
-        this.numericMinimum.Location = new System.Drawing.Point(37, 132);
-        this.numericMinimum.Name = "numericMinimum";
-        this.numericMinimum.Size = new System.Drawing.Size(150, 27);
-        this.numericMinimum.TabIndex = 2;
-        this.numericMinimum.ValueChanged += new System.EventHandler(this.numericMinimum_ValueChanged);
-        // 
-        // numericMaximum
-        // 
-        this.numericMaximum.Location = new System.Drawing.Point(37, 194);
-        this.numericMaximum.Name = "numericMaximum";
-        this.numericMaximum.Size = new System.Drawing.Size(150, 27);
-        this.numericMaximum.TabIndex = 3;
-        this.numericMaximum.Value = new decimal(new int[] {
-        100,
-        0,
-        0,
-        0});
-        this.numericMaximum.ValueChanged += new System.EventHandler(this.numericMaximum_ValueChanged);
-        // 
-        // chbRightToLeft
-        // 
-        this.chbRightToLeft.AutoSize = true;
-        this.chbRightToLeft.Location = new System.Drawing.Point(37, 250);
-        this.chbRightToLeft.Name = "chbRightToLeft";
-        this.chbRightToLeft.Size = new System.Drawing.Size(110, 24);
-        this.chbRightToLeft.TabIndex = 4;
-        this.chbRightToLeft.Text = "Right to left";
-        this.chbRightToLeft.UseVisualStyleBackColor = true;
-        this.chbRightToLeft.CheckedChanged += new System.EventHandler(this.chbRightToLeft_CheckedChanged);
-        // 
-        // lblMinimum
-        // 
-        this.lblMinimum.AutoSize = true;
-        this.lblMinimum.Location = new System.Drawing.Point(37, 109);
-        this.lblMinimum.Name = "lblMinimum";
-        this.lblMinimum.Size = new System.Drawing.Size(72, 20);
-        this.lblMinimum.TabIndex = 5;
-        this.lblMinimum.Text = "Minimum";
-        // 
-        // lblMaximum
-        // 
-        this.lblMaximum.AutoSize = true;
-        this.lblMaximum.Location = new System.Drawing.Point(37, 171);
-        this.lblMaximum.Name = "lblMaximum";
-        this.lblMaximum.Size = new System.Drawing.Size(75, 20);
-        this.lblMaximum.TabIndex = 6;
-        this.lblMaximum.Text = "Maximum";
-        // 
-        // lblHValue
-        // 
-        this.lblHValue.AutoSize = true;
-        this.lblHValue.Location = new System.Drawing.Point(37, 33);
-        this.lblHValue.Name = "lblHValue";
-        this.lblHValue.Size = new System.Drawing.Size(50, 20);
-        this.lblHValue.TabIndex = 7;
-        this.lblHValue.Text = "label3";
-        // 
-        // lblVValue
-        // 
-        this.lblVValue.AutoSize = true;
-        this.lblVValue.Location = new System.Drawing.Point(275, 33);
-        this.lblVValue.Name = "lblVValue";
-        this.lblVValue.Size = new System.Drawing.Size(50, 20);
-        this.lblVValue.TabIndex = 8;
-        this.lblVValue.Text = "label4";
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(800, 450);
-        this.Controls.Add(this.lblVValue);
-        this.Controls.Add(this.lblHValue);
-        this.Controls.Add(this.lblMaximum);
-        this.Controls.Add(this.lblMinimum);
-        this.Controls.Add(this.chbRightToLeft);
-        this.Controls.Add(this.numericMaximum);
-        this.Controls.Add(this.numericMinimum);
-        this.Controls.Add(this.vScrollBar);
-        this.Controls.Add(this.hScrollBar);
-        this.Name = "Form1";
-        this.Text = "Form1";
-        ((System.ComponentModel.ISupportInitialize)(this.numericMinimum)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMaximum)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.HScrollBar hScrollBar;
-    private System.Windows.Forms.VScrollBar vScrollBar;
-    private System.Windows.Forms.NumericUpDown numericMinimum;
-    private System.Windows.Forms.NumericUpDown numericMaximum;
-    private System.Windows.Forms.CheckBox chbRightToLeft;
-    private System.Windows.Forms.Label lblMinimum;
-    private System.Windows.Forms.Label lblMaximum;
-    private System.Windows.Forms.Label lblHValue;
-    private System.Windows.Forms.Label lblVValue;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.cs
deleted file mode 100644
index 6cbb5743e43..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class ScrollBars : Form
-{
-    public ScrollBars()
-    {
-        InitializeComponent();
-        SetValueLabels();
-    }
-
-    private void numericMaximum_ValueChanged(object sender, EventArgs e)
-    {
-        hScrollBar.Maximum = Decimal.ToInt32(numericMaximum.Value);
-        vScrollBar.Maximum = Decimal.ToInt32(numericMaximum.Value);
-        numericMinimum.Maximum = numericMaximum.Value;
-        SetValueLabels();
-    }
-
-    private void numericMinimum_ValueChanged(object sender, EventArgs e)
-    {
-        hScrollBar.Minimum = Decimal.ToInt32(numericMinimum.Value);
-        vScrollBar.Minimum = Decimal.ToInt32(numericMinimum.Value);
-        numericMaximum.Minimum = numericMinimum.Value;
-        SetValueLabels();
-    }
-
-    private void hScrollBar_Scroll(object sender, ScrollEventArgs e) => SetValueLabels();
-
-    private void vScrollBar_Scroll(object sender, ScrollEventArgs e) => SetValueLabels();
-
-    private void SetValueLabels()
-    {
-        lblHValue.Text = $"Value: {hScrollBar.Value}";
-        lblVValue.Text = $"Value: {vScrollBar.Value}";
-    }
-
-    private void chbRightToLeft_CheckedChanged(object sender, EventArgs e)
-    {
-        hScrollBar.RightToLeft = chbRightToLeft.Checked ? RightToLeft.Yes : RightToLeft.No;
-        SetValueLabels();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ScrollBars.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.Designer.cs
deleted file mode 100644
index 30d6f7c62c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.Designer.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class Splitter
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.splitContainer1 = new System.Windows.Forms.SplitContainer();
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
-        this.splitContainer1.SuspendLayout();
-        this.SuspendLayout();
-        //
-        // splitContainer1
-        //
-        this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.splitContainer1.Location = new System.Drawing.Point(0, 0);
-        this.splitContainer1.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.splitContainer1.Name = "splitContainer1";
-        //
-        // splitContainer1.Panel1
-        //
-        this.splitContainer1.Panel1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(128)))));
-        //
-        // splitContainer1.Panel2
-        //
-        this.splitContainer1.Panel2.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(128)))), ((int)(((byte)(128)))));
-        this.splitContainer1.Size = new System.Drawing.Size(568, 502);
-        this.splitContainer1.SplitterDistance = 188;
-        this.splitContainer1.SplitterWidth = 8;
-        this.splitContainer1.TabIndex = 0;
-        //
-        // Splitter
-        //
-        this.AutoScaleDimensions = new System.Drawing.SizeF(12F, 25F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(568, 502);
-        this.Controls.Add(this.splitContainer1);
-        this.Margin = new System.Windows.Forms.Padding(6, 6, 6, 6);
-        this.Name = "Splitter";
-        this.Text = "Splitter";
-        ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
-        this.splitContainer1.ResumeLayout(false);
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.SplitContainer splitContainer1;
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.cs
deleted file mode 100644
index 69242878a38..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class Splitter : Form
-{
-    public Splitter()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/Splitter.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.cs
deleted file mode 100644
index ebe646d7922..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.cs
+++ /dev/null
@@ -1,561 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Timer = System.Windows.Forms.Timer;
-
-namespace WinformsControlsTest;
-
-public class TaskDialogSamples : Form
-{
-    public TaskDialogSamples()
-    {
-        this.Text = "Task Dialog Demos";
-
-        AutoSize = true;
-        AutoSizeMode = AutoSizeMode.GrowAndShrink;
-        MinimizeBox = false;
-        MaximizeBox = false;
-
-        var flowLayout = new FlowLayoutPanel
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown,
-            AutoSize = true,
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            Parent = this,
-        };
-
-        void AddButtonForAction(string name, Action action)
-        {
-            var button = new Button
-            {
-                Text = name,
-                AutoSize = true,
-                AutoSizeMode = AutoSizeMode.GrowAndShrink,
-                Anchor = AnchorStyles.Left | AnchorStyles.Right,
-            };
-
-            button.Click += (s, e) => action();
-
-            flowLayout.Controls.Add(button);
-        }
-
-        AddButtonForAction("Confirmation Dialog (3x)", ShowSimpleTaskDialog);
-        AddButtonForAction("Close Document Confirmation", ShowCloseDocumentTaskDialog);
-        AddButtonForAction("Minesweeper Difficulty", ShowMinesweeperDifficultySelectionTaskDialog);
-        AddButtonForAction("Auto-Closing Dialog", ShowAutoClosingTaskDialog);
-        AddButtonForAction("Multi-Page Dialog (modeless)", ShowMultiPageTaskDialog);
-        AddButtonForAction("Elevation Required", ShowElevatedProcessTaskDialog);
-        AddButtonForAction("Events Demo", ShowEventsDemoTaskDialog);
-        AddButtonForAction("Hyperlinks Demo", ShowHyperlinksDemoTaskDialog);
-    }
-
-    private void ShowSimpleTaskDialog()
-    {
-        // Show a message box.
-        DialogResult messageBoxResult = MessageBox.Show(
-            this,
-            text: "Stopping the operation might leave your database in a corrupted state. Are you sure you want to stop?",
-            caption: "Confirmation [Message Box]",
-            buttons: MessageBoxButtons.YesNo,
-            icon: MessageBoxIcon.Warning,
-            defaultButton: MessageBoxDefaultButton.Button2);
-
-        if (messageBoxResult == DialogResult.Yes)
-        {
-            Console.WriteLine("User confirmed to stop the operation.");
-        }
-
-        // Show a task dialog (simple).
-        TaskDialogButton result = TaskDialog.ShowDialog(this, new TaskDialogPage()
-        {
-            Text = "Stopping the operation might leave your database in a corrupted state.",
-            Heading = "Are you sure you want to stop?",
-            Caption = "Confirmation (Task Dialog)",
-            Buttons =
-            {
-                TaskDialogButton.Yes,
-                TaskDialogButton.No
-            },
-            Icon = TaskDialogIcon.Warning,
-            DefaultButton = TaskDialogButton.No
-        });
-
-        if (result == TaskDialogButton.Yes)
-        {
-            Console.WriteLine("User confirmed to stop the operation.");
-        }
-
-        // Show a task dialog (enhanced).
-        var page = new TaskDialogPage()
-        {
-            Heading = "Are you sure you want to stop?",
-            Text = "Stopping the operation might leave your database in a corrupted state.",
-            Caption = "Confirmation (Task Dialog)",
-            Icon = TaskDialogIcon.Warning,
-            AllowCancel = true,
-
-            Verification = new TaskDialogVerificationCheckBox()
-            {
-                Text = "Do not show again"
-            },
-
-            Buttons =
-            {
-                TaskDialogButton.Yes,
-                TaskDialogButton.No
-            },
-
-            DefaultButton = TaskDialogButton.No
-        };
-
-        var resultButton = TaskDialog.ShowDialog(this, page);
-
-        if (resultButton == TaskDialogButton.Yes)
-        {
-            if (page.Verification.Checked)
-                Console.WriteLine("Do not show this confirmation again.");
-
-            Console.WriteLine("User confirmed to stop the operation.");
-        }
-    }
-
-    private void ShowCloseDocumentTaskDialog()
-    {
-        // Create the page which we want to show in the dialog.
-        TaskDialogButton btnCancel = TaskDialogButton.Cancel;
-        TaskDialogButton btnSave = new TaskDialogButton("&Save");
-        TaskDialogButton btnDontSave = new TaskDialogButton("Do&n't save");
-
-        var page = new TaskDialogPage()
-        {
-            Caption = "My Application",
-            Heading = "Do you want to save changes to Untitled?",
-            Buttons =
-            {
-                btnCancel,
-                btnSave,
-                btnDontSave
-            }
-        };
-
-        // Show a modal dialog, then check the result.
-        TaskDialogButton result = TaskDialog.ShowDialog(this, page);
-
-        if (result == btnSave)
-            Console.WriteLine("Saving");
-        else if (result == btnDontSave)
-            Console.WriteLine("Not saving");
-        else
-            Console.WriteLine("Canceling");
-    }
-
-    private void ShowMinesweeperDifficultySelectionTaskDialog()
-    {
-        var page = new TaskDialogPage()
-        {
-            Caption = "Minesweeper",
-            Heading = "What level of difficulty do you want to play?",
-            AllowCancel = true,
-
-            Footnote = new TaskDialogFootnote()
-            {
-                Text = "Note: You can change the difficulty level later " +
-                    "by clicking Options on the Game menu.",
-            },
-
-            Buttons =
-            {
-                new TaskDialogCommandLinkButton("&Beginner", "10 mines, 9 x 9 tile grid")
-                {
-                    Tag = 10
-                },
-                new TaskDialogCommandLinkButton("&Intermediate", "40 mines, 16 x 16 tile grid")
-                {
-                    Tag = 40
-                },
-                new TaskDialogCommandLinkButton("&Advanced", "99 mines, 16 x 30 tile grid")
-                {
-                    Tag = 99
-                }
-            }
-        };
-
-        TaskDialogButton result = TaskDialog.ShowDialog(this, page);
-
-        if (result.Tag is int resultingMines)
-            Console.WriteLine($"Playing with {resultingMines} mines...");
-        else
-            Console.WriteLine("User canceled.");
-    }
-
-    private void ShowAutoClosingTaskDialog()
-    {
-        int remainingTenthSeconds = 50;
-
-        var reconnectButton = new TaskDialogButton("&Reconnect now");
-        var cancelButton = TaskDialogButton.Cancel;
-
-        var page = new TaskDialogPage()
-        {
-            Heading = "Connection lost; reconnecting...",
-            Text = $"Reconnecting in {(remainingTenthSeconds + 9) / 10} seconds...",
-            // Display the form's icon in the task dialog.
-            // Note however that the task dialog will not scale the icon.
-            Icon = new TaskDialogIcon(this.Icon),
-            ProgressBar = new TaskDialogProgressBar()
-            {
-                State = TaskDialogProgressBarState.Paused
-            },
-            Buttons =
-            {
-                reconnectButton,
-                cancelButton
-            }
-        };
-
-        // Create a WinForms timer that raises the Tick event every tenth second.
-        using (var timer = new Timer()
-        {
-            Enabled = true,
-            Interval = 100
-        })
-        {
-            timer.Tick += (s, e) =>
-            {
-                remainingTenthSeconds--;
-                if (remainingTenthSeconds > 0)
-                {
-                    // Update the remaining time and progress bar.
-                    page.Text = $"Reconnecting in {(remainingTenthSeconds + 9) / 10} seconds...";
-                    page.ProgressBar.Value = 100 - remainingTenthSeconds * 2;
-                }
-                else
-                {
-                    // Stop the timer and click the "Reconnect" button - this will
-                    // close the dialog.
-                    timer.Enabled = false;
-                    reconnectButton.PerformClick();
-                }
-            };
-
-            TaskDialogButton result = TaskDialog.ShowDialog(this, page);
-            if (result == reconnectButton)
-                Console.WriteLine("Reconnecting.");
-            else
-                Console.WriteLine("Not reconnecting.");
-        }
-    }
-
-    private void ShowMultiPageTaskDialog()
-    {
-        // Disable the "Yes" button and only enable it when the check box is checked.
-        // Also, don't close the dialog when this button is clicked.
-        var initialButtonYes = TaskDialogButton.Yes;
-        initialButtonYes.Enabled = false;
-        initialButtonYes.AllowCloseDialog = false;
-
-        var initialPage = new TaskDialogPage()
-        {
-            Caption = "My Application",
-            Heading = "Clean up database?",
-            Text = "Do you really want to do a clean-up?\nThis action is irreversible!",
-            Icon = TaskDialogIcon.ShieldWarningYellowBar,
-            AllowCancel = true,
-            // A modeless dialog can be minimizable.
-            AllowMinimize = true,
-
-            Verification = new TaskDialogVerificationCheckBox()
-            {
-                Text = "I know what I'm doing"
-            },
-
-            Buttons =
-            {
-                TaskDialogButton.No,
-                initialButtonYes
-            },
-            DefaultButton = TaskDialogButton.No
-        };
-
-        // For the "In Progress" page, don't allow the dialog to close, by adding
-        // a disabled button (if no button was specified, the task dialog would
-        // get an (enabled) 'OK' button).
-        var inProgressCloseButton = TaskDialogButton.Close;
-        inProgressCloseButton.Enabled = false;
-
-        var inProgressPage = new TaskDialogPage()
-        {
-            Caption = "My Application",
-            Heading = "Operation in progress...",
-            Text = "Please wait while the operation is in progress.",
-            Icon = TaskDialogIcon.Information,
-            AllowMinimize = true,
-
-            ProgressBar = new TaskDialogProgressBar()
-            {
-                State = TaskDialogProgressBarState.Marquee
-            },
-
-            Expander = new TaskDialogExpander()
-            {
-                Text = "Initializing...",
-                Position = TaskDialogExpanderPosition.AfterFootnote
-            },
-
-            Buttons =
-            {
-                inProgressCloseButton
-            }
-        };
-
-        // Add an invisible Cancel button where we will intercept the Click event
-        // to prevent the dialog from closing (when the User clicks the "X" button
-        // in the title bar or presses ESC or Alt+F4).
-        var invisibleCancelButton = TaskDialogButton.Cancel;
-        invisibleCancelButton.Visible = false;
-        invisibleCancelButton.AllowCloseDialog = false;
-        inProgressPage.Buttons.Add(invisibleCancelButton);
-
-        var finishedPage = new TaskDialogPage()
-        {
-            Caption = "My Application",
-            Heading = "Success!",
-            Text = "The operation finished.",
-            Icon = TaskDialogIcon.ShieldSuccessGreenBar,
-            AllowMinimize = true,
-            Buttons =
-            {
-                TaskDialogButton.Close
-            }
-        };
-
-        TaskDialogButton showResultsButton = new TaskDialogCommandLinkButton("Show &Results");
-        finishedPage.Buttons.Add(showResultsButton);
-
-        // Enable the "Yes" button only when the checkbox is checked.
-        TaskDialogVerificationCheckBox checkBox = initialPage.Verification;
-        checkBox.CheckedChanged += (sender, e) =>
-        {
-            initialButtonYes.Enabled = checkBox.Checked;
-        };
-
-        // When the user clicks "Yes", navigate to the second page.
-        initialButtonYes.Click += (sender, e) =>
-        {
-            // Navigate to the "In Progress" page that displays the
-            // current progress of the background work.
-            initialPage.Navigate(inProgressPage);
-
-            // NOTE: When you implement a "In Progress" page that represents
-            // background work that is done e.g. by a separate thread/task,
-            // which eventually calls Control.Invoke()/BeginInvoke() when
-            // its work is finished in order to navigate or update the dialog,
-            // then DO NOT start that work here already (directly after
-            // setting the Page property). Instead, start the work in the
-            // TaskDialogPage.Created event of the new page.
-            //
-            // See comments in the code sample in https://github.com/dotnet/winforms/issues/146
-            // for more information.
-        };
-
-        // Simulate work by starting an async operation from which we are updating the
-        // progress bar and the expander with the current status.
-        inProgressPage.Created += async (s, e) =>
-        {
-            // Run the background operation and iterate over the streamed values to update
-            // the progress. Because we call the async method from the GUI thread,
-            // it will use this thread's synchronization context to run the continuations,
-            // so we don't need to use Control.[Begin]Invoke() to schedule the callbacks.
-            var progressBar = inProgressPage.ProgressBar;
-
-            await foreach (int progressValue in StreamBackgroundOperationProgressAsync())
-            {
-                // When we display the first progress, switch the marquee progress bar
-                // to a regular one.
-                if (progressBar.State == TaskDialogProgressBarState.Marquee)
-                    progressBar.State = TaskDialogProgressBarState.Normal;
-
-                progressBar.Value = progressValue;
-                inProgressPage.Expander.Text = $"Progress: {progressValue} %";
-            }
-
-            // Work is finished, so navigate to the third page.
-            inProgressPage.Navigate(finishedPage);
-        };
-
-        // Show the dialog (modeless).
-        TaskDialogButton result = TaskDialog.ShowDialog(initialPage);
-        if (result == showResultsButton)
-        {
-            Console.WriteLine("Showing Results!");
-        }
-
-        static async IAsyncEnumerable<int> StreamBackgroundOperationProgressAsync()
-        {
-            // Note: The code here will run in the GUI thread - use
-            // "await Task.Run(...)" to schedule CPU-intensive operations in a
-            // worker thread.
-
-            // Wait a bit before reporting the first progress.
-            await Task.Delay(2800);
-
-            for (int i = 0; i <= 100; i += 4)
-            {
-                // Report the progress.
-                yield return i;
-
-                // Wait a bit to simulate work.
-                await Task.Delay(200);
-            }
-        }
-    }
-
-    private void ShowElevatedProcessTaskDialog()
-    {
-        var page = new TaskDialogPage()
-        {
-            Heading = "Settings saved - Service Restart required",
-            Text = "The service needs to be restarted to apply the changes.",
-            Icon = TaskDialogIcon.ShieldSuccessGreenBar,
-            Buttons =
-            {
-                TaskDialogButton.Close
-            }
-        };
-
-        var restartNowButton = new TaskDialogCommandLinkButton("&Restart now");
-        page.Buttons.Add(restartNowButton);
-
-        restartNowButton.ShowShieldIcon = true;
-        restartNowButton.Click += (s, e) =>
-        {
-            restartNowButton.AllowCloseDialog = true;
-            restartNowButton.Enabled = false;
-
-            // Try to start an elevated cmd.exe.
-            var psi = new ProcessStartInfo("cmd.exe", "/k echo Hi, this is an elevated command prompt.")
-            {
-                UseShellExecute = true,
-                Verb = "runas"
-            };
-
-            try
-            {
-                Process.Start(psi)?.Dispose();
-            }
-            catch (Win32Exception ex) when (ex.NativeErrorCode == 1223)
-            {
-                // The user canceled the UAC prompt, so don't close the dialog and
-                // re-enable the restart button.
-                restartNowButton.AllowCloseDialog = false;
-                restartNowButton.Enabled = true;
-                return;
-            }
-        };
-
-        TaskDialog.ShowDialog(this, page);
-    }
-
-    private void ShowEventsDemoTaskDialog()
-    {
-        var page1 = new TaskDialogPage()
-        {
-            Caption = Text,
-            Heading = "Event Demo",
-            Text = "Event Demo...",
-        };
-
-        page1.Created += (s, e) => Console.WriteLine("Page1 Created");
-        page1.Destroyed += (s, e) => Console.WriteLine("Page1 Destroyed");
-        page1.HelpRequest += (s, e) => Console.WriteLine("Page1 HelpRequest");
-
-        page1.Expander = new TaskDialogExpander("Expander")
-        {
-            Position = TaskDialogExpanderPosition.AfterFootnote
-        };
-
-        page1.Expander.ExpandedChanged += (s, e) => Console.WriteLine($"Expander ExpandedChanged: {page1.Expander.Expanded}");
-
-        var buttonOK = TaskDialogButton.OK;
-        var buttonHelp = TaskDialogButton.Help;
-        var buttonCancelClose = new TaskDialogCommandLinkButton("C&ancel Close", allowCloseDialog: false);
-        var buttonShowInnerDialog = new TaskDialogCommandLinkButton("&Show (modeless) Inner Dialog", "(and don't cancel the Close)");
-        var buttonNavigate = new TaskDialogCommandLinkButton("&Navigate", allowCloseDialog: false);
-
-        page1.Buttons.Add(buttonOK);
-        page1.Buttons.Add(buttonHelp);
-        page1.Buttons.Add(buttonCancelClose);
-        page1.Buttons.Add(buttonShowInnerDialog);
-        page1.Buttons.Add(buttonNavigate);
-
-        buttonOK.Click += (s, e) => Console.WriteLine($"Button '{s}' Click");
-        buttonHelp.Click += (s, e) => Console.WriteLine($"Button '{s}' Click");
-
-        buttonCancelClose.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-        };
-
-        buttonShowInnerDialog.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-            TaskDialog.ShowDialog(new TaskDialogPage()
-            {
-                Text = "Inner Dialog"
-            });
-            Console.WriteLine($"(returns) Button '{s}' Click");
-        };
-
-        buttonNavigate.Click += (s, e) =>
-        {
-            Console.WriteLine($"Button '{s}' Click");
-
-            // Navigate to a new page.
-            var page2 = new TaskDialogPage()
-            {
-                Heading = "AfterNavigation.",
-                Buttons =
-                {
-                    TaskDialogButton.Close
-                }
-            };
-            page2.Created += (s, e) => Console.WriteLine("Page2 Created");
-            page2.Destroyed += (s, e) => Console.WriteLine("Page2 Destroyed");
-
-            page1.Navigate(page2);
-        };
-
-        page1.Verification = new TaskDialogVerificationCheckBox("&CheckBox");
-        page1.Verification.CheckedChanged += (s, e) => Console.WriteLine($"CheckBox CheckedChanged: {page1.Verification.Checked}");
-
-        var radioButton1 = page1.RadioButtons.Add("Radi&oButton 1");
-        var radioButton2 = page1.RadioButtons.Add("RadioB&utton 2");
-
-        radioButton1.CheckedChanged += (s, e) => Console.WriteLine($"RadioButton1 CheckedChanged: {radioButton1.Checked}");
-        radioButton2.CheckedChanged += (s, e) => Console.WriteLine($"RadioButton2 CheckedChanged: {radioButton2.Checked}");
-
-        var dialogResult = TaskDialog.ShowDialog(page1);
-        Console.WriteLine($"---> Dialog Result: {dialogResult}");
-    }
-
-    private void ShowHyperlinksDemoTaskDialog()
-    {
-        var page = new TaskDialogPage
-        {
-            Caption = Text,
-            Text = """<a href="Href 1">Link with accelerator &1</a> Text with literal '&&' <a href="Href 2">Link with accelerator &2</a>""",
-            Footnote = new() { Text = """<a href="Href 3">Link with literal '&&'</a> Text with &accelerator""" },
-            Expander = new() { Text = """<a href="Href 4">Link 4</a>""" },
-            EnableLinks = true,
-        };
-
-        page.LinkClicked += (_, e) =>
-        {
-            page.Heading = "Clicked: " + e.LinkHref;
-        };
-
-        TaskDialog.ShowDialog(page);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.resx
deleted file mode 100644
index 1af7de150c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TaskDialogSamples.resx
+++ /dev/null
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TestCustomer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TestCustomer.cs
deleted file mode 100644
index af596964b1e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TestCustomer.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-/// <summary>
-///  It is implementation of a simple customer class
-///  to represent the test data items used by code example in <see cref="DataGridViewInVirtualModeTest"/>
-/// </summary>
-internal class TestCustomer
-{
-    public TestCustomer()
-    {
-        // Leave fields empty
-    }
-
-    public TestCustomer(string name, int age, bool hasAJob, string gender)
-    {
-        Name = name;
-        Age = age;
-        HasAJob = hasAJob;
-        Gender = gender;
-    }
-
-    public string Name { get; set; }
-
-    public int Age { get; set; }
-
-    public bool HasAJob { get; set; }
-
-    public string Gender { get; set; }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.Designer.cs
deleted file mode 100644
index c022aa42d9b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.Designer.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class TextBoxes
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.textBox = new System.Windows.Forms.TextBox();
-        this.RTLTextBox = new System.Windows.Forms.TextBox();
-        this.multilineTextBox = new System.Windows.Forms.TextBox();
-        this.RTLMultilineTextBox = new System.Windows.Forms.TextBox();
-        this.richTextBox = new System.Windows.Forms.RichTextBox();
-        this.RTLRichTextBox = new System.Windows.Forms.RichTextBox();
-        this.SuspendLayout();
-        // 
-        // textBox
-        // 
-        this.textBox.Location = new System.Drawing.Point(20, 20);
-        this.textBox.Name = "textBox";
-        this.textBox.Size = new System.Drawing.Size(120, 30);
-        this.textBox.TabIndex = 0;
-        this.textBox.Text = "Some long long text for a TextBox";
-        // 
-        // RTLTextBox
-        // 
-        this.RTLTextBox.Location = new System.Drawing.Point(160, 20);
-        this.RTLTextBox.Name = "RTLTextBox";
-        this.RTLTextBox.Size = new System.Drawing.Size(120, 30);
-        this.RTLTextBox.TabIndex = 1;
-        this.RTLTextBox.RightToLeft = System.Windows.Forms.RightToLeft.Yes;
-        this.RTLTextBox.Text = "Some long long text for a RTL TextBox";
-        // 
-        // multilineTextBox
-        // 
-        this.multilineTextBox.Location = new System.Drawing.Point(20, 60);
-        this.multilineTextBox.Name = "multilineTextBox";
-        this.multilineTextBox.Size = new System.Drawing.Size(120, 110);
-        this.multilineTextBox.TabIndex = 2;
-        this.multilineTextBox.Multiline = true;
-        this.multilineTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
-        this.multilineTextBox.Text = @"Some long
-long text
-for
-
-a multiline TextBox
-that
-
-contains several
-lines
-with
-
-withspaces,tabs     and
-numbers
-12345";
-        // 
-        // RTLMultilineTextBox
-        // 
-        this.RTLMultilineTextBox.Location = new System.Drawing.Point(160, 60);
-        this.RTLMultilineTextBox.Name = "RTLMultilineTextBox";
-        this.RTLMultilineTextBox.Size = new System.Drawing.Size(120, 110);
-        this.RTLMultilineTextBox.TabIndex = 3;
-        this.RTLMultilineTextBox.Multiline = true;
-        this.RTLMultilineTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
-        this.RTLMultilineTextBox.RightToLeft = System.Windows.Forms.RightToLeft.Yes;
-        this.RTLMultilineTextBox.Text = @"Some long
-long text
-for
-
-a multiline TextBox
-that
-
-contains several
-lines
-with
-
-withspaces,tabs     and
-numbers
-12345";
-        // 
-        // richTextBox
-        // 
-        this.richTextBox.Location = new System.Drawing.Point(20, 190);
-        this.richTextBox.Name = "richTextBox";
-        this.richTextBox.Size = new System.Drawing.Size(120, 110);
-        this.richTextBox.TabIndex = 4;
-        this.richTextBox.Text = @"Some long
-long text
-for
-
-a RichTextBox
-
-that
-contains several
-lines
-with
-
-withspaces and
-numbers
-12345";
-        // 
-        // RTLRichTextBox
-        // 
-        this.RTLRichTextBox.Location = new System.Drawing.Point(160, 190);
-        this.RTLRichTextBox.Name = "RTLRichTextBox";
-        this.RTLRichTextBox.Size = new System.Drawing.Size(120, 110);
-        this.RTLRichTextBox.TabIndex = 5;
-        this.RTLRichTextBox.RightToLeft = System.Windows.Forms.RightToLeft.Yes;
-        this.RTLRichTextBox.Text = @"Some long
-long text
-for
-
-a RichTextBox
-
-that
-contains several
-lines
-with
-
-withspaces and
-numbers
-12345";
-        // 
-        // Form
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(300, 330);
-        this.Controls.Add(this.textBox);
-        this.Controls.Add(this.RTLTextBox);
-        this.Controls.Add(this.multilineTextBox);
-        this.Controls.Add(this.RTLMultilineTextBox);
-        this.Controls.Add(this.richTextBox);
-        this.Controls.Add(this.RTLRichTextBox);
-        this.Name = "TextBoxes";
-        this.Text = "TextBoxes";
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TextBox textBox;
-    private System.Windows.Forms.TextBox RTLTextBox;
-    private System.Windows.Forms.TextBox multilineTextBox;
-    private System.Windows.Forms.TextBox RTLMultilineTextBox;
-    private System.Windows.Forms.RichTextBox richTextBox;
-    private System.Windows.Forms.RichTextBox RTLRichTextBox;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.cs
deleted file mode 100644
index 268ffd97fd7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class TextBoxes : Form
-{
-    public TextBoxes()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TextBoxes.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.Designer.cs
deleted file mode 100644
index c68c53eed49..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.Designer.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class ToolStripTests
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.toolStrip1 = new System.Windows.Forms.ToolStrip();
-        this.statusStrip1 = new System.Windows.Forms.StatusStrip();
-        this.label1 = new System.Windows.Forms.Label();
-        this.toolStripProgressBar1 = new System.Windows.Forms.ToolStripProgressBar();
-        this.toolStripLabel1 = new System.Windows.Forms.ToolStripLabel();
-        this.toolStripTextBox1 = new System.Windows.Forms.ToolStripTextBox();
-        this.toolStripComboBox1 = new System.Windows.Forms.ToolStripComboBox();
-        this.toolStripProgressBar2 = new System.Windows.Forms.ToolStripProgressBar();
-        this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel();
-        this.toolStrip2 = new System.Windows.Forms.ToolStrip();
-        this.toolStrip2_Button1 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_Button2 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_Button3 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_Button4 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_Button5 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_Button6 = new System.Windows.Forms.ToolStripButton();
-        this.toolStrip2_SplitButton1 = new System.Windows.Forms.ToolStripSplitButton();
-        this.toolStrip2_DropDownButton1 = new System.Windows.Forms.ToolStripDropDownButton();
-        this.toolStrip2_DropDownButton1_ChildButton1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStrip2_DropDownButton1_ChildButton2 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStrip2_SplitButton1_ChildButton1 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStrip2_SplitButton1_ChildButton2 = new System.Windows.Forms.ToolStripMenuItem();
-        this.toolStrip2.SuspendLayout();
-        this.toolStrip1.SuspendLayout();
-        this.statusStrip1.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // toolStrip1
-        // 
-        this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripProgressBar1,
-        this.toolStripLabel1,
-        this.toolStripTextBox1,
-        this.toolStripComboBox1 });
-        this.toolStrip1.Location = new System.Drawing.Point(0, 0);
-        this.toolStrip1.Name = "toolStrip1";
-        this.toolStrip1.Size = new System.Drawing.Size(481, 22);
-        this.toolStrip1.TabIndex = 0;
-        this.toolStrip1.Text = "toolStrip1";
-        this.toolStrip1.TabStop = true;
-        // 
-        // toolStrip2
-        // 
-        this.toolStrip2.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStrip2_Button1,
-        this.toolStrip2_Button2,
-        this.toolStrip2_Button3,
-        this.toolStrip2_Button4,
-        this.toolStrip2_Button5,
-        this.toolStrip2_Button6,
-        this.toolStrip2_SplitButton1,
-        this.toolStrip2_DropDownButton1,});
-        this.toolStrip2.Location = new System.Drawing.Point(0, 22);
-        this.toolStrip2.Name = "toolStrip2";
-        this.toolStrip2.Size = new System.Drawing.Size(481, 22);
-        this.toolStrip2.TabIndex = 1;
-        this.toolStrip2.Text = "toolStrip2";
-        this.toolStrip2.TabStop = true;
-        // 
-        // toolStrip2_Button1
-        //
-        this.toolStrip2_Button1.CheckState = System.Windows.Forms.CheckState.Unchecked;
-        this.toolStrip2_Button1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_Button1.Name = "toolStrip2_Button1_Unchecked";
-        this.toolStrip2_Button1.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button1.Text = "toolStrip2_Button1_Unchecked";
-        // 
-        // toolStrip2_Button2
-        //
-        this.toolStrip2_Button2.CheckState = System.Windows.Forms.CheckState.Checked;
-        this.toolStrip2_Button1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text;
-        this.toolStrip2_Button2.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_Button2.Name = "toolStrip2_Button2_Checked";
-        this.toolStrip2_Button2.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button2.Text = "toolStrip2_Button2_Checked";
-        // 
-        // toolStrip2_Button3
-        //
-        this.toolStrip2_Button3.CheckState = System.Windows.Forms.CheckState.Indeterminate;
-        this.toolStrip2_Button3.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_Button3.Name = "toolStrip2_Button3_Indeterminate";
-        this.toolStrip2_Button3.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button3.Text = "toolStrip2_Button3_Indeterminate";
-        // 
-        // toolStrip2_Button4
-        //
-        this.toolStrip2_Button4.CheckOnClick = true;
-        this.toolStrip2_Button4.CheckState = System.Windows.Forms.CheckState.Unchecked;
-        this.toolStrip2_Button4.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_Button4.Name = "toolStrip2_Button4_Checkable";
-        this.toolStrip2_Button4.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button4.Text = "toolStrip2_Button4_Checkable";
-        // 
-        // toolStrip2_Button5
-        //
-        this.toolStrip2_Button5.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_Button5.Name = "toolStrip2_Button5";
-        this.toolStrip2_Button5.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button5.Text = "toolStrip2_Button5";
-        // 
-        // toolStrip2_Button6
-        //
-        this.toolStrip2_Button6.AccessibleRole = AccessibleRole.CheckButton;
-        this.toolStrip2_Button6.Name = "toolStrip2_Button6";
-        this.toolStrip2_Button6.Size = new System.Drawing.Size(114, 22);
-        this.toolStrip2_Button6.Text = "CheckButton role";
-        // 
-        // toolStrip2_SplitButton1_ChildButton1
-        // 
-        this.toolStrip2_SplitButton1_ChildButton1.Name = "toolStrip2_SplitButton1_ChildButton1";
-        this.toolStrip2_SplitButton1_ChildButton1.Size = new System.Drawing.Size(180, 22);
-        this.toolStrip2_SplitButton1_ChildButton1.Text = "toolStrip2_SplitButton1_ChildButton1";
-        // 
-        // toolStrip2_SplitButton1_ChildButton2
-        // 
-        this.toolStrip2_SplitButton1_ChildButton2.Name = "toolStrip2_SplitButton1_ChildButton2";
-        this.toolStrip2_SplitButton1_ChildButton2.Size = new System.Drawing.Size(180, 22);
-        this.toolStrip2_SplitButton1_ChildButton2.Text = "toolStrip2_SplitButton1_ChildButton2";
-        // 
-        // toolStrip2_SplitButton1
-        //
-        this.toolStrip2_SplitButton1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStrip2_SplitButton1_ChildButton1,
-        this.toolStrip2_SplitButton1_ChildButton2});
-        this.toolStrip2_SplitButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text;
-        this.toolStrip2_SplitButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_SplitButton1.Name = "toolStrip2_SplitButton1";
-        this.toolStrip2_SplitButton1.Size = new System.Drawing.Size(133, 22);
-        this.toolStrip2_SplitButton1.Text = "toolStrip2_SplitButton1";
-        // 
-        // toolStrip2_DropDownButton1_ChildButton1
-        // 
-        this.toolStrip2_DropDownButton1_ChildButton1.Name = "toolStrip2_DropDownButton1_ChildButton1";
-        this.toolStrip2_DropDownButton1_ChildButton1.Size = new System.Drawing.Size(180, 22);
-        this.toolStrip2_DropDownButton1_ChildButton1.Text = "toolStrip2_DropDownButton1_ChildButton1";
-        // 
-        // toolStrip2_DropDownButton1_ChildButton2
-        // 
-        this.toolStrip2_DropDownButton1_ChildButton2.Name = "toolStrip2_DropDownButton1_ChildButton2";
-        this.toolStrip2_DropDownButton1_ChildButton2.Size = new System.Drawing.Size(180, 22);
-        this.toolStrip2_DropDownButton1_ChildButton2.Text = "toolStrip2_DropDownButton1_ChildButton2";
-        // 
-        // toolStrip2_DropDownButton1
-        //
-        this.toolStrip2_DropDownButton1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStrip2_DropDownButton1_ChildButton1,
-        this.toolStrip2_DropDownButton1_ChildButton2});
-        this.toolStrip2_DropDownButton1.ImageTransparentColor = System.Drawing.Color.Magenta;
-        this.toolStrip2_DropDownButton1.Name = "toolStrip2_DropDownButton1";
-        this.toolStrip2_DropDownButton1.Size = new System.Drawing.Size(180, 22);
-        this.toolStrip2_DropDownButton1.Text = "toolStrip2_DropDownButton1";
-        // 
-        // statusStrip1
-        // 
-        this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
-        this.toolStripProgressBar2,
-        this.toolStripStatusLabel1});
-        this.statusStrip1.Location = new System.Drawing.Point(0, 101);
-        this.statusStrip1.Name = "statusStrip1";
-        this.statusStrip1.Size = new System.Drawing.Size(481, 22);
-        this.statusStrip1.TabIndex = 1;
-        this.statusStrip1.Text = "statusStrip1";
-        this.statusStrip1.TabStop = true;
-        // 
-        // label1
-        // 
-        this.label1.AutoSize = true;
-        this.label1.Location = new System.Drawing.Point(12, 56);
-        this.label1.Name = "label1";
-        this.label1.Size = new System.Drawing.Size(78, 13);
-        this.label1.TabIndex = 2;
-        this.label1.Text = "Test ToolStrips";
-        // 
-        // toolStripProgressBar1
-        // 
-        this.toolStripProgressBar1.Name = "toolStripProgressBar1";
-        this.toolStripProgressBar1.Size = new System.Drawing.Size(100, 22);
-        this.toolStripProgressBar1.Value = 30;
-        // 
-        // toolStripLabel1
-        // 
-        this.toolStripLabel1.Name = "toolStripLabel1";
-        this.toolStripLabel1.Size = new System.Drawing.Size(86, 22);
-        this.toolStripLabel1.Text = "ToolStripLabel";
-        // 
-        // toolStripTextBox1
-        // 
-        this.toolStripTextBox1.Name = "toolStripTextBox1";
-        this.toolStripTextBox1.Size = new System.Drawing.Size(100, 22);
-        this.toolStripTextBox1.Text = "ToolStripTextBox";
-        // 
-        // toolStripComboBox1
-        //
-        this.toolStripComboBox1.Name = "toolStripComboBox1";
-        this.toolStripComboBox1.Size = new System.Drawing.Size(100, 22);
-        this.toolStripComboBox1.Items.AddRange(new object[] { "1", "2", "3", "4", "5" });
-        // 
-        // toolStripProgressBar2
-        // 
-        this.toolStripProgressBar2.Name = "toolStripProgressBar2";
-        this.toolStripProgressBar2.Size = new System.Drawing.Size(100, 16);
-        this.toolStripProgressBar2.Value = 30;
-        // 
-        // toolStripStatusLabel1
-        // 
-        this.toolStripStatusLabel1.Name = "toolStripStatusLabel1";
-        this.toolStripStatusLabel1.Size = new System.Drawing.Size(118, 17);
-        this.toolStripStatusLabel1.Text = "ToolStripStatusLabel";
-        // 
-        // Form1
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(881, 123);
-        this.Controls.Add(this.label1);
-        this.Controls.Add(this.statusStrip1);
-        this.Controls.Add(this.toolStrip2);
-        this.Controls.Add(this.toolStrip1);
-        this.Name = "ToolStripTests";
-        this.Text = "ToolStripTests";
-        this.toolStrip1.ResumeLayout(false);
-        this.toolStrip1.PerformLayout();
-        this.statusStrip1.ResumeLayout(false);
-        this.statusStrip1.PerformLayout();
-        this.toolStrip2.ResumeLayout(false);
-        this.toolStrip2.PerformLayout();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.ToolStrip toolStrip1;
-    private System.Windows.Forms.ToolStripLabel toolStripLabel1;
-    private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar1;
-    private System.Windows.Forms.StatusStrip statusStrip1;
-    private System.Windows.Forms.ToolStripTextBox toolStripTextBox1;
-    private System.Windows.Forms.ToolStripComboBox toolStripComboBox1;
-    private System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1;
-    private System.Windows.Forms.ToolStripProgressBar toolStripProgressBar2;
-    private System.Windows.Forms.Label label1;
-    private System.Windows.Forms.ToolStrip toolStrip2;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button1;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button2;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button3;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button4;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button5;
-    private System.Windows.Forms.ToolStripButton toolStrip2_Button6;
-    private System.Windows.Forms.ToolStripSplitButton toolStrip2_SplitButton1;
-    private System.Windows.Forms.ToolStripDropDownButton toolStrip2_DropDownButton1;
-    private System.Windows.Forms.ToolStripMenuItem toolStrip2_DropDownButton1_ChildButton1;
-    private System.Windows.Forms.ToolStripMenuItem toolStrip2_DropDownButton1_ChildButton2;
-    private System.Windows.Forms.ToolStripMenuItem toolStrip2_SplitButton1_ChildButton1;
-    private System.Windows.Forms.ToolStripMenuItem toolStrip2_SplitButton1_ChildButton2;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.cs
deleted file mode 100644
index b659096fa74..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace WinformsControlsTest;
-
-public partial class ToolStripTests : Form
-{
-    public ToolStripTests()
-    {
-        InitializeComponent();
-
-        toolStrip1.Items.Add(new ToolStripControlHost(new RadioButton() { Text = "RadioButton" })); // RadioButton supports UIA
-        toolStrip1.Items.Add(new ToolStripControlHost(new HScrollBar() { Value = 30 })); // HScrollBar doesn't support UIA
-        statusStrip1.Items.Add(new ToolStripControlHost(new RadioButton() { Text = "RadioButton" })); // RadioButton supports UIA
-        statusStrip1.Items.Add(new ToolStripControlHost(new HScrollBar() { Value = 30 })); // HScrollBar doesn't support UIA
-
-        toolStrip2_Button4.Image = Image.FromFile("Images\\SmallA.bmp");
-        toolStrip2_Button4.DisplayStyle = ToolStripItemDisplayStyle.ImageAndText;
-        toolStrip2_Button5.Image = Image.FromFile("Images\\SmallABlue.bmp");
-        toolStrip2_Button5.DisplayStyle = ToolStripItemDisplayStyle.Image;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolStripTests.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.Designer.cs
deleted file mode 100644
index fc164f687c9..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.Designer.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-namespace WinformsControlsTest;
-
-partial class ToolTipTests
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        this.delaysNotSetButton = new System.Windows.Forms.Button();
-        this.automaticDelayButton = new System.Windows.Forms.Button();
-        this.autoPopDelayButton = new System.Windows.Forms.Button();
-        this.delaysNotSetToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.flowLayoutPanel1 = new System.Windows.Forms.FlowLayoutPanel();
-        this.defaultAutomaticDelayButton = new System.Windows.Forms.Button();
-        this.defaultAutoPopDelayButton = new System.Windows.Forms.Button();
-        this.initialDelayButton = new System.Windows.Forms.Button();
-        this.automaticDelayToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.autoPopDelayToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.defaultAutoPopDelayToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.defaultAutomaticDelayToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.initialDelayToolTip = new System.Windows.Forms.ToolTip(this.components);
-        this.autoEllipsisButton = new System.Windows.Forms.Button();
-        this.flowLayoutPanel1.SuspendLayout();
-        this.SuspendLayout();
-        // 
-        // delaysNoSetButton
-        // 
-        this.delaysNotSetButton.AutoSize = true;
-        this.delaysNotSetButton.Location = new System.Drawing.Point(8, 411);
-        this.delaysNotSetButton.Name = "delaysNoSetButton";
-        this.delaysNotSetButton.Size = new System.Drawing.Size(876, 183);
-        this.delaysNotSetButton.TabIndex = 2;
-        this.delaysNotSetToolTip.SetToolTip(this.delaysNotSetButton, "Persistent");
-        this.delaysNotSetButton.Text = "Delays &not set";
-        this.delaysNotSetButton.UseVisualStyleBackColor = true;
-        // 
-        // automaticDelayButton
-        // 
-        this.automaticDelayButton.AutoSize = true;
-        this.automaticDelayButton.Location = new System.Drawing.Point(8, 9);
-        this.automaticDelayButton.Name = "automaticDelayButton";
-        this.automaticDelayButton.Size = new System.Drawing.Size(1031, 183);
-        this.automaticDelayButton.TabIndex = 0;
-        this.automaticDelayToolTip.SetToolTip(this.automaticDelayButton, "Not persistent");
-        this.automaticDelayButton.Text = "&AutomaticDelay = 300";
-        this.automaticDelayButton.UseVisualStyleBackColor = true;
-        // 
-        // autoPopDelayButton
-        // 
-        this.autoPopDelayButton.AutoSize = true;
-        this.autoPopDelayButton.Location = new System.Drawing.Point(8, 210);
-        this.autoPopDelayButton.Name = "autoPopDelayButton";
-        this.autoPopDelayButton.Size = new System.Drawing.Size(949, 183);
-        this.autoPopDelayButton.TabIndex = 1;
-        this.autoPopDelayToolTip.SetToolTip(this.autoPopDelayButton, "Not persistent");
-        this.autoPopDelayButton.Text = "Auto&PopDelay = 6000";
-        this.autoPopDelayButton.UseVisualStyleBackColor = true;
-        // 
-        // flowLayoutPanel1
-        // 
-        this.flowLayoutPanel1.Controls.Add(this.automaticDelayButton);
-        this.flowLayoutPanel1.Controls.Add(this.autoPopDelayButton);
-        this.flowLayoutPanel1.Controls.Add(this.delaysNotSetButton);
-        this.flowLayoutPanel1.Controls.Add(this.defaultAutomaticDelayButton);
-        this.flowLayoutPanel1.Controls.Add(this.defaultAutoPopDelayButton);
-        this.flowLayoutPanel1.Controls.Add(this.initialDelayButton);
-        this.flowLayoutPanel1.Controls.Add(this.autoEllipsisButton);
-        this.flowLayoutPanel1.Dock = System.Windows.Forms.DockStyle.Fill;
-        this.flowLayoutPanel1.Location = new System.Drawing.Point(0, 0);
-        this.flowLayoutPanel1.Name = "flowLayoutPanel1";
-        this.flowLayoutPanel1.Size = new System.Drawing.Size(1417, 1577);
-        this.flowLayoutPanel1.TabIndex = 0;
-        // 
-        // defaultAutomaticDelayButton
-        // 
-        this.defaultAutomaticDelayButton.AutoSize = true;
-        this.defaultAutomaticDelayButton.Location = new System.Drawing.Point(8, 612);
-        this.defaultAutomaticDelayButton.Name = "defaultAutomaticDelayButton";
-        this.defaultAutomaticDelayButton.Size = new System.Drawing.Size(915, 183);
-        this.defaultAutomaticDelayButton.TabIndex = 3;
-        this.defaultAutomaticDelayToolTip.SetToolTip(this.defaultAutomaticDelayButton, "Persistent");
-        this.defaultAutomaticDelayButton.Text = "AutomaticDelay = 500";
-        this.defaultAutomaticDelayButton.UseVisualStyleBackColor = true;
-        // 
-        // defaultAutoPopDelayButton
-        // 
-        this.defaultAutoPopDelayButton.AutoSize = true;
-        this.defaultAutoPopDelayButton.Location = new System.Drawing.Point(8, 813);
-        this.defaultAutoPopDelayButton.Name = "defaultAutoPopDelayButton";
-        this.defaultAutoPopDelayButton.Size = new System.Drawing.Size(904, 183);
-        this.defaultAutoPopDelayButton.TabIndex = 4;
-        this.defaultAutoPopDelayToolTip.SetToolTip(this.defaultAutoPopDelayButton, "Persistent");
-        this.defaultAutoPopDelayButton.Text = "AutoPopDelay = 5000";
-        this.defaultAutoPopDelayButton.UseVisualStyleBackColor = true;
-        // 
-        // initialDelayButton
-        // 
-        this.initialDelayButton.AutoSize = true;
-        this.initialDelayButton.Location = new System.Drawing.Point(8, 1014);
-        this.initialDelayButton.Name = "initialDelayButton";
-        this.initialDelayButton.Size = new System.Drawing.Size(876, 183);
-        this.initialDelayButton.TabIndex = 5;
-        this.initialDelayToolTip.SetToolTip(this.initialDelayButton, "Persistent");
-        this.initialDelayButton.Text = "I&nitial delay = 10";
-        this.initialDelayButton.UseVisualStyleBackColor = true;
-        // 
-        // autoEllipsisButton
-        // 
-        this.autoEllipsisButton.AutoEllipsis = true;
-        this.autoEllipsisButton.AutoSize = false;
-        this.autoEllipsisButton.Location = new System.Drawing.Point(8, 1215);
-        this.autoEllipsisButton.Name = "autoEllipsisButton";
-        this.autoEllipsisButton.Size = new System.Drawing.Size(876, 183);
-        this.autoEllipsisButton.TabIndex = 6;
-        this.autoEllipsisButton.Text = "Auto&Ellipsis = true; 1234567890";
-        this.autoEllipsisButton.UseVisualStyleBackColor = true;
-        // 
-        // automaticDelayToolTip
-        // 
-        this.automaticDelayToolTip.AutomaticDelay = 300;
-        // 
-        // autoPopDelayToolTip
-        // 
-        this.autoPopDelayToolTip.AutoPopDelay = 6000;
-        this.autoPopDelayToolTip.InitialDelay = 500;
-        this.autoPopDelayToolTip.ReshowDelay = 100;
-        // 
-        // initialDelayToolTip
-        // 
-        this.initialDelayToolTip.AutoPopDelay = 5000;
-        this.initialDelayToolTip.InitialDelay = 10;
-        this.initialDelayToolTip.ReshowDelay = 100;
-        // 
-        // ToolTipTests
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(17F, 41F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(1417, 1577);
-        this.Controls.Add(this.flowLayoutPanel1);
-        this.Name = "ToolTipTests";
-        this.Text = "ToolTips";
-        this.flowLayoutPanel1.ResumeLayout(false);
-        this.flowLayoutPanel1.PerformLayout();
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.Button delaysNotSetButton;
-    private System.Windows.Forms.Button automaticDelayButton;
-    private System.Windows.Forms.Button autoPopDelayButton;
-    private System.Windows.Forms.Button autoEllipsisButton;
-    private System.Windows.Forms.Button defaultAutomaticDelayButton;
-    private System.Windows.Forms.Button defaultAutoPopDelayButton;
-    private System.Windows.Forms.Button initialDelayButton;
-    private System.Windows.Forms.ToolTip automaticDelayToolTip;
-    private System.Windows.Forms.ToolTip autoPopDelayToolTip;
-    private System.Windows.Forms.ToolTip defaultAutomaticDelayToolTip;
-    private System.Windows.Forms.ToolTip defaultAutoPopDelayToolTip;
-    private System.Windows.Forms.ToolTip delaysNotSetToolTip;
-    private System.Windows.Forms.ToolTip initialDelayToolTip;
-    private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel1;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.cs
deleted file mode 100644
index 98cb775d0c2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class ToolTipTests : Form
-{
-    public ToolTipTests()
-    {
-        InitializeComponent();
-
-        defaultAutomaticDelayToolTip.AutomaticDelay = 500;
-        defaultAutoPopDelayToolTip.AutoPopDelay = 5000;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.resx
deleted file mode 100644
index aa33208fa97..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/ToolTipTests.resx
+++ /dev/null
@@ -1,78 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <metadata name="delaysNotSetToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>350, 17</value>
-  </metadata>
-  <metadata name="automaticDelayToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>714, 17</value>
-  </metadata>
-  <metadata name="autoPopDelayToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>1110, 17</value>
-  </metadata>
-  <metadata name="defaultAutoPopDelayToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>1485, 17</value>
-  </metadata>
-  <metadata name="defaultAutomaticDelayToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 82</value>
-  </metadata>
-  <metadata name="initialDelayToolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.Designer.cs
deleted file mode 100644
index 75a47ab9e53..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.Designer.cs
+++ /dev/null
@@ -1,295 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class TrackBars
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.trackBar1 = new System.Windows.Forms.TrackBar();
-        this.rbHorizontal = new System.Windows.Forms.RadioButton();
-        this.rbVertical = new System.Windows.Forms.RadioButton();
-        this.gbOrientation = new System.Windows.Forms.GroupBox();
-        this.chbRightToLeft = new System.Windows.Forms.CheckBox();
-        this.chbRightToLeftLayout = new System.Windows.Forms.CheckBox();
-        this.tickstyleNone = new System.Windows.Forms.CheckBox();
-        this.numericMinimum = new System.Windows.Forms.NumericUpDown();
-        this.numericMaximum = new System.Windows.Forms.NumericUpDown();
-        this.numericFrequency = new System.Windows.Forms.NumericUpDown();
-        this.lblMinimum = new System.Windows.Forms.Label();
-        this.lblMaximum = new System.Windows.Forms.Label();
-        this.lblTickFrequency = new System.Windows.Forms.Label();
-        this.lblTrackBarSize = new System.Windows.Forms.Label();
-        this.lblTrackBarValue = new System.Windows.Forms.Label();
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).BeginInit();
-        this.gbOrientation.SuspendLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMinimum)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMaximum)).BeginInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericFrequency)).BeginInit();
-        this.SuspendLayout();
-        // 
-        // trackBar1
-        // 
-        this.trackBar1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-        | System.Windows.Forms.AnchorStyles.Right)));
-        this.trackBar1.Location = new System.Drawing.Point(10, 30);
-        this.trackBar1.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.trackBar1.Name = "trackBar1";
-        this.trackBar1.Size = new System.Drawing.Size(457, 45);
-        this.trackBar1.TabIndex = 0;
-        this.trackBar1.Scroll += new System.EventHandler(this.trackBar1_Scroll);
-        this.trackBar1.SizeChanged += new System.EventHandler(this.trackBar1_SizeChanged);
-        // 
-        // rbHorizontal
-        // 
-        this.rbHorizontal.AutoSize = true;
-        this.rbHorizontal.Checked = true;
-        this.rbHorizontal.Location = new System.Drawing.Point(18, 26);
-        this.rbHorizontal.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.rbHorizontal.Name = "rbHorizontal";
-        this.rbHorizontal.Size = new System.Drawing.Size(80, 19);
-        this.rbHorizontal.TabIndex = 1;
-        this.rbHorizontal.TabStop = true;
-        this.rbHorizontal.Text = "Horizontal";
-        this.rbHorizontal.UseVisualStyleBackColor = true;
-        this.rbHorizontal.CheckedChanged += new System.EventHandler(this.rbHorizontal_CheckedChanged);
-        // 
-        // rbVertical
-        // 
-        this.rbVertical.AutoSize = true;
-        this.rbVertical.Location = new System.Drawing.Point(18, 56);
-        this.rbVertical.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.rbVertical.Name = "rbVertical";
-        this.rbVertical.Size = new System.Drawing.Size(63, 19);
-        this.rbVertical.TabIndex = 2;
-        this.rbVertical.Text = "Vertical";
-        this.rbVertical.UseVisualStyleBackColor = true;
-        this.rbVertical.CheckedChanged += new System.EventHandler(this.rbVertical_CheckedChanged);
-        // 
-        // gbOrientation
-        // 
-        this.gbOrientation.Controls.Add(this.rbHorizontal);
-        this.gbOrientation.Controls.Add(this.rbVertical);
-        this.gbOrientation.Location = new System.Drawing.Point(65, 78);
-        this.gbOrientation.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.gbOrientation.Name = "gbOrientation";
-        this.gbOrientation.Padding = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.gbOrientation.Size = new System.Drawing.Size(168, 84);
-        this.gbOrientation.TabIndex = 3;
-        this.gbOrientation.TabStop = false;
-        this.gbOrientation.Text = "Orientation";
-        // 
-        // chbRightToLeft
-        // 
-        this.chbRightToLeft.AutoSize = true;
-        this.chbRightToLeft.Location = new System.Drawing.Point(83, 176);
-        this.chbRightToLeft.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.chbRightToLeft.Name = "chbRightToLeft";
-        this.chbRightToLeft.Size = new System.Drawing.Size(86, 19);
-        this.chbRightToLeft.TabIndex = 4;
-        this.chbRightToLeft.Text = "RightToLeft";
-        this.chbRightToLeft.UseVisualStyleBackColor = true;
-        this.chbRightToLeft.CheckedChanged += new System.EventHandler(this.chbRightToLeft_CheckedChanged);
-        // 
-        // chbRightToLeftLayout
-        // 
-        this.chbRightToLeftLayout.AutoSize = true;
-        this.chbRightToLeftLayout.Location = new System.Drawing.Point(83, 199);
-        this.chbRightToLeftLayout.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.chbRightToLeftLayout.Name = "chbRightToLeftLayout";
-        this.chbRightToLeftLayout.Size = new System.Drawing.Size(122, 19);
-        this.chbRightToLeftLayout.TabIndex = 5;
-        this.chbRightToLeftLayout.Text = "RightToLeftLayout";
-        this.chbRightToLeftLayout.UseVisualStyleBackColor = true;
-        this.chbRightToLeftLayout.CheckedChanged += new System.EventHandler(this.chbRightToLeftLayout_CheckedChanged);
-        // 
-        // tickstyleNone
-        // 
-        this.tickstyleNone.AutoSize = true;
-        this.tickstyleNone.Location = new System.Drawing.Point(83, 222);
-        this.tickstyleNone.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.tickstyleNone.Name = "tickstyleNone";
-        this.tickstyleNone.Size = new System.Drawing.Size(100, 19);
-        this.tickstyleNone.TabIndex = 11;
-        this.tickstyleNone.Text = "TickstyleNone";
-        this.tickstyleNone.UseVisualStyleBackColor = true;
-        this.tickstyleNone.CheckedChanged += new System.EventHandler(this.tickstyleNone_CheckedChanged);
-        // 
-        // numericMinimum
-        // 
-        this.numericMinimum.Location = new System.Drawing.Point(260, 104);
-        this.numericMinimum.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.numericMinimum.Minimum = new decimal(new int[] {
-        -1,
-        -1,
-        -1,
-        -2147483648});
-        this.numericMinimum.Name = "numericMinimum";
-        this.numericMinimum.Size = new System.Drawing.Size(131, 23);
-        this.numericMinimum.TabIndex = 7;
-        this.numericMinimum.Value = new decimal(new int[] {
-        100,
-        0,
-        0,
-        -2147483648});
-        this.numericMinimum.ValueChanged += new System.EventHandler(this.numericMinimum_ValueChanged);
-        // 
-        // numericMaximum
-        // 
-        this.numericMaximum.Location = new System.Drawing.Point(260, 149);
-        this.numericMaximum.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.numericMaximum.Maximum = new decimal(new int[] {
-        -1,
-        -1,
-        -1,
-        0});
-        this.numericMaximum.Name = "numericMaximum";
-        this.numericMaximum.Size = new System.Drawing.Size(131, 23);
-        this.numericMaximum.TabIndex = 8;
-        this.numericMaximum.Value = new decimal(new int[] {
-        100,
-        0,
-        0,
-        0});
-        this.numericMaximum.ValueChanged += new System.EventHandler(this.numericMaximum_ValueChanged);
-        // 
-        // numericFrequency
-        // 
-        this.numericFrequency.Location = new System.Drawing.Point(260, 193);
-        this.numericFrequency.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.numericFrequency.Minimum = new decimal(new int[] {
-        1,
-        0,
-        0,
-        0});
-        this.numericFrequency.Name = "numericFrequency";
-        this.numericFrequency.Size = new System.Drawing.Size(131, 23);
-        this.numericFrequency.TabIndex = 11;
-        this.numericFrequency.Value = new decimal(new int[] {
-        1,
-        0,
-        0,
-        0});
-        this.numericFrequency.ValueChanged += new System.EventHandler(this.numericFrequency_ValueChanged);
-        // 
-        // lblMinimum
-        // 
-        this.lblMinimum.AutoSize = true;
-        this.lblMinimum.Location = new System.Drawing.Point(260, 87);
-        this.lblMinimum.Name = "lblMinimum";
-        this.lblMinimum.Size = new System.Drawing.Size(60, 15);
-        this.lblMinimum.TabIndex = 9;
-        this.lblMinimum.Text = "Minimum";
-        // 
-        // lblMaximum
-        // 
-        this.lblMaximum.AutoSize = true;
-        this.lblMaximum.Location = new System.Drawing.Point(260, 131);
-        this.lblMaximum.Name = "lblMaximum";
-        this.lblMaximum.Size = new System.Drawing.Size(62, 15);
-        this.lblMaximum.TabIndex = 10;
-        this.lblMaximum.Text = "Maximum";
-        // 
-        // lblTickFrequency
-        // 
-        this.lblTickFrequency.AutoSize = true;
-        this.lblTickFrequency.Location = new System.Drawing.Point(260, 176);
-        this.lblTickFrequency.Name = "lblTickFrequency";
-        this.lblTickFrequency.Size = new System.Drawing.Size(86, 15);
-        this.lblTickFrequency.TabIndex = 12;
-        this.lblTickFrequency.Text = "Tick Frequency";
-        // 
-        // lblTrackBarSize
-        // 
-        this.lblTrackBarSize.AutoSize = true;
-        this.lblTrackBarSize.Location = new System.Drawing.Point(166, 9);
-        this.lblTrackBarSize.Name = "lblTrackBarSize";
-        this.lblTrackBarSize.Size = new System.Drawing.Size(39, 15);
-        this.lblTrackBarSize.TabIndex = 13;
-        this.lblTrackBarSize.Text = "Size: 0";
-        // 
-        // lblTrackBarValue
-        // 
-        this.lblTrackBarValue.AutoSize = true;
-        this.lblTrackBarValue.Location = new System.Drawing.Point(12, 9);
-        this.lblTrackBarValue.Name = "lblTrackBarValue";
-        this.lblTrackBarValue.Size = new System.Drawing.Size(47, 15);
-        this.lblTrackBarValue.TabIndex = 14;
-        this.lblTrackBarValue.Text = "Value: 0";
-        // 
-        // TrackBars
-        // 
-        this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-        this.ClientSize = new System.Drawing.Size(479, 308);
-        this.Controls.Add(this.lblTrackBarValue);
-        this.Controls.Add(this.lblTrackBarSize);
-        this.Controls.Add(this.lblTickFrequency);
-        this.Controls.Add(this.lblMaximum);
-        this.Controls.Add(this.lblMinimum);
-        this.Controls.Add(this.numericFrequency);
-        this.Controls.Add(this.numericMaximum);
-        this.Controls.Add(this.numericMinimum);
-        this.Controls.Add(this.chbRightToLeftLayout);
-        this.Controls.Add(this.chbRightToLeft);
-        this.Controls.Add(this.gbOrientation);
-        this.Controls.Add(this.trackBar1);
-        this.Controls.Add(this.tickstyleNone);
-        this.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
-        this.Name = "TrackBars";
-        this.Text = "TrackBars";
-        ((System.ComponentModel.ISupportInitialize)(this.trackBar1)).EndInit();
-        this.gbOrientation.ResumeLayout(false);
-        this.gbOrientation.PerformLayout();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMinimum)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericMaximum)).EndInit();
-        ((System.ComponentModel.ISupportInitialize)(this.numericFrequency)).EndInit();
-        this.ResumeLayout(false);
-        this.PerformLayout();
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TrackBar trackBar1;
-    private System.Windows.Forms.RadioButton rbHorizontal;
-    private System.Windows.Forms.RadioButton rbVertical;
-    private System.Windows.Forms.GroupBox gbOrientation;
-    private System.Windows.Forms.CheckBox chbRightToLeft;
-    private System.Windows.Forms.CheckBox tickstyleNone;
-    private System.Windows.Forms.CheckBox chbRightToLeftLayout;
-    private System.Windows.Forms.NumericUpDown numericMinimum;
-    private System.Windows.Forms.NumericUpDown numericMaximum;
-    private System.Windows.Forms.NumericUpDown numericFrequency;
-    private System.Windows.Forms.Label lblMinimum;
-    private System.Windows.Forms.Label lblMaximum;
-    private System.Windows.Forms.Label lblTickFrequency;
-    private System.Windows.Forms.Label lblTrackBarSize;
-    private System.Windows.Forms.Label lblTrackBarValue;
-}
-
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.cs
deleted file mode 100644
index 04882999370..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class TrackBars : Form
-{
-    public TrackBars()
-    {
-        InitializeComponent();
-
-        trackBar1.Minimum = -100;
-        trackBar1.Maximum = 100;
-        numericMinimum.Value = trackBar1.Minimum;
-        numericMaximum.Value = trackBar1.Maximum;
-        numericFrequency.Value = trackBar1.TickFrequency;
-
-        UpdateSizeLabel();
-        UpdateValueLabel();
-    }
-
-    private void UpdateSizeLabel()
-    {
-        if (trackBar1.Orientation == Orientation.Horizontal)
-        {
-            lblTrackBarSize.Text = $"Trackbar width: {trackBar1.Width}";
-        }
-        else
-        {
-            lblTrackBarSize.Text = $"Trackbar height: {trackBar1.Height}";
-        }
-    }
-
-    private void UpdateValueLabel()
-    {
-        lblTrackBarValue.Text = $"Value {trackBar1.Value}";
-    }
-
-    private void rbHorizontal_CheckedChanged(object sender, EventArgs e)
-    {
-        trackBar1.Orientation = Orientation.Horizontal;
-        trackBar1.Width = ClientRectangle.Width - trackBar1.Left * 2;
-        trackBar1.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
-    }
-
-    private void rbVertical_CheckedChanged(object sender, EventArgs e)
-    {
-        trackBar1.Orientation = Orientation.Vertical;
-        trackBar1.Height = ClientRectangle.Height - trackBar1.Top * 2;
-        trackBar1.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Bottom;
-    }
-
-    private void chbRightToLeft_CheckedChanged(object sender, EventArgs e)
-    {
-        trackBar1.RightToLeft = chbRightToLeft.Checked ? RightToLeft.Yes : RightToLeft.No;
-    }
-
-    private void tickstyleNone_CheckedChanged(object sender, EventArgs e)
-    {
-        if (trackBar1.TickStyle == TickStyle.BottomRight)
-        {
-            trackBar1.TickStyle = TickStyle.None;
-        }
-        else
-        {
-            trackBar1.TickStyle = TickStyle.BottomRight;
-        }
-    }
-
-    private void numericMinimum_ValueChanged(object sender, EventArgs e)
-    {
-        trackBar1.Minimum = (int)Math.Max(numericMinimum.Value, int.MinValue);
-        numericMaximum.Minimum = numericMinimum.Value;        
-        numericFrequency.Maximum = (int)Math.Min(numericMaximum.Value - numericMaximum.Minimum, int.MaxValue);
-        if (numericFrequency.Maximum == 0)
-        {
-            numericFrequency.Minimum = 1;
-        }
-
-        UpdateValueLabel();
-    }
-
-    private void numericMaximum_ValueChanged(object sender, EventArgs e)
-    {
-        trackBar1.Maximum = (int)Math.Min(numericMaximum.Value, int.MaxValue);
-        numericMinimum.Maximum = numericMaximum.Value;
-        numericFrequency.Maximum = (int)Math.Min(numericMaximum.Value - numericMaximum.Minimum, int.MaxValue);
-        if (numericFrequency.Maximum == 0)
-        {
-            numericFrequency.Minimum = 1;
-        }
-
-        UpdateValueLabel();
-    }
-
-    private void numericFrequency_ValueChanged(object sender, EventArgs e)
-    {
-        trackBar1.TickFrequency = (int)numericFrequency.Value;
-    }
-
-    private void trackBar1_Scroll(object sender, EventArgs e)
-    {
-        UpdateValueLabel();
-    }
-
-    private void chbRightToLeftLayout_CheckedChanged(object sender, EventArgs e)
-    {
-        trackBar1.RightToLeftLayout = chbRightToLeftLayout.Checked;
-    }
-
-    private void trackBar1_SizeChanged(object sender, EventArgs e)
-    {
-        UpdateSizeLabel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.resx
deleted file mode 100644
index 667ea1506c8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TrackBars.resx
+++ /dev/null
@@ -1,61 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.Designer.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.Designer.cs
deleted file mode 100644
index 46c396f5de3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.Designer.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-partial class TreeViewTest
-{
-    /// <summary>
-    ///  Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary>
-    ///  Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing)
-    {
-        if (disposing && (components != null))
-        {
-            components.Dispose();
-        }
-        base.Dispose(disposing);
-    }
-
-    #region Windows Form Designer generated code
-
-    /// <summary>
-    ///  Required method for Designer support - do not modify
-    ///  the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent()
-    {
-        this.components = new System.ComponentModel.Container();
-        System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TreeViewTest));
-        this.treeView1 = new System.Windows.Forms.TreeView();
-        this.imageList1 = new System.Windows.Forms.ImageList(this.components);
-        this.SuspendLayout();
-        // 
-        // treeView1
-        // 
-        this.treeView1.CheckBoxes = true;
-        resources.ApplyResources(this.treeView1, "treeView1");
-        this.treeView1.ImageList = this.imageList1;
-        this.treeView1.Name = "treeView1";
-        this.treeView1.Nodes.AddRange(new System.Windows.Forms.TreeNode[] {
-        (System.Windows.Forms.TreeNode)(resources.GetObject("treeView1.Nodes")),
-        (System.Windows.Forms.TreeNode)(resources.GetObject("treeView1.Nodes1")),
-        (System.Windows.Forms.TreeNode)(resources.GetObject("treeView1.Nodes2"))});
-        this.treeView1.ShowNodeToolTips = true;
-        // 
-        // imageList1
-        // 
-        this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth8Bit;
-        this.imageList1.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream")));
-        this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
-        this.imageList1.Images.SetKeyName(0, "SmallA.bmp");
-        this.imageList1.Images.SetKeyName(1, "SmallABlue.bmp");
-        // 
-        // TreeViewTest
-        // 
-        resources.ApplyResources(this, "$this");
-        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
-        this.BackColor = System.Drawing.Color.FromArgb((int)(byte)0, (int)(byte)192, (int)(byte)0);
-        this.Controls.Add(this.treeView1);
-        this.Name = "TreeViewTest";
-        this.ResumeLayout(false);
-
-    }
-
-    #endregion
-
-    private System.Windows.Forms.TreeView treeView1;
-    private System.Windows.Forms.ImageList imageList1;
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.cs
deleted file mode 100644
index 2ed2cfb7fc1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace WinformsControlsTest;
-
-public partial class TreeViewTest : Form
-{
-    public TreeViewTest()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.resx b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.resx
deleted file mode 100644
index 9bbf2b3a84c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/TreeViewTest.resx
+++ /dev/null
@@ -1,252 +0,0 @@
-<root>
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="treeView1.Dock" type="System.Windows.Forms.DockStyle, System.Windows.Forms">
-    <value>Fill</value>
-  </data>
-  <assembly alias="mscorlib" name="mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="treeView1.ImageIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <metadata name="imageList1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
-    <value>17, 17</value>
-  </metadata>
-  <data name="imageList1.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-        AAEAAAD/////AQAAAAAAAAAMAgAAAEZTeXN0ZW0uV2luZG93cy5Gb3JtcywgQ3VsdHVyZT1uZXV0cmFs
-        LCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5BQEAAAAmU3lzdGVtLldpbmRvd3MuRm9ybXMu
-        SW1hZ2VMaXN0U3RyZWFtZXIBAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAiggAAAJNU0Z0AUkBTAIBAQIB
-        AAEwAQABMAEAARABAAEQAQAE/wEJAQAI/wFCAU0BNgEEBgABNgEEAgABKAMAAUADAAEQAwABAQEAAQgG
-        AAEEGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHAAdwBwAEAAfABygGmAQABMwUAATMB
-        AAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANCAQADOQEAAYABfAH/AQACUAH/AQAB
-        kwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ATMDAAFmAwABmQMAAcwCAAEzAwAC
-        MwIAATMBZgIAATMBmQIAATMBzAIAATMB/wIAAWYDAAFmATMCAAJmAgABZgGZAgABZgHMAgABZgH/AgAB
-        mQMAAZkBMwIAAZkBZgIAApkCAAGZAcwCAAGZAf8CAAHMAwABzAEzAgABzAFmAgABzAGZAgACzAIAAcwB
-        /wIAAf8BZgIAAf8BmQIAAf8BzAEAATMB/wIAAf8BAAEzAQABMwEAAWYBAAEzAQABmQEAATMBAAHMAQAB
-        MwEAAf8BAAH/ATMCAAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/AQABMwFmAgABMwFmATMBAAEzAmYB
-        AAEzAWYBmQEAATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEAATMBmQFmAQABMwKZAQABMwGZAcwB
-        AAEzAZkB/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEAATMCzAEAATMBzAH/AQABMwH/ATMB
-        AAEzAf8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEAATMBAAFmAQABZgEAAWYBAAGZAQAB
-        ZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEzAZkBAAFmATMBzAEAAWYBMwH/AQAC
-        ZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEAAWYBmQFmAQABZgKZAQABZgGZAcwB
-        AAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFmAcwB/wEAAWYB/wIAAWYB/wEzAQAB
-        ZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEzAZkBAAGZAQABmQEAAZkBAAHMAQAB
-        mQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIAAZkBZgEzAQABmQEzAWYBAAGZAWYB
-        mQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHMAQACmQH/AQABmQHMAgABmQHMATMB
-        AAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZAf8BMwEAAZkBzAFmAQABmQH/AZkB
-        AAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQABzAEAAZkBAAHMAQABzAEAAZkBMwIAAcwC
-        MwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/AQABzAFmAgABzAFmATMBAAGZAmYBAAHMAWYB
-        mQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkBMwEAAcwBmQFmAQABzAKZAQABzAGZAcwBAAHMAZkB
-        /wEAAswCAALMATMBAALMAWYBAALMAZkBAAPMAQACzAH/AQABzAH/AgABzAH/ATMBAAGZAf8BZgEAAcwB
-        /wGZAQABzAH/AcwBAAHMAv8BAAHMAQABMwEAAf8BAAFmAQAB/wEAAZkBAAHMATMCAAH/AjMBAAH/ATMB
-        ZgEAAf8BMwGZAQAB/wEzAcwBAAH/ATMB/wEAAf8BZgIAAf8BZgEzAQABzAJmAQAB/wFmAZkBAAH/AWYB
-        zAEAAcwBZgH/AQAB/wGZAgAB/wGZATMBAAH/AZkBZgEAAf8CmQEAAf8BmQHMAQAB/wGZAf8BAAH/AcwC
-        AAH/AcwBMwEAAf8BzAFmAQAB/wHMAZkBAAH/AswBAAH/AcwB/wEAAv8BMwEAAcwB/wFmAQAC/wGZAQAC
-        /wHMAQACZgH/AQABZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEAAv8BZgEAASEBAAGlAQADXwEAA3cB
-        AAOGAQADlgEAA8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4AQAB8AH7Af8BAAGkAqABAAOAAwAB
-        /wIAAf8DAAL/AQAB/wMAAf8BAAH/AQAC/wIAA/8BACD/IAAN/wH0AfMO/wL0Af8gAAH/A70I/wHzAkcC
-        /wLyAfMI/wHzAc8BpwH/IAAB/wJHARcI/wEXAUcBFwL/AqcBzwj/Ac8BpwHPAf8gAAH/AeMCRwS9Af8D
-        vQEXAUcB8wL/Ac8BpwHPA90B8gH/AfIC3QHPAacB9AH/IAAC/wHjBEcB4wGUAeMDRwHjAfQD/wG0BKcB
-        zwEJAc8DpwG0Av8gAAL/AfQB4wJHAeMGRwG9Bf8BtQGnAs8GpwHyAv8gAAP/Ab0BRwEXBJQBFwFHARYB
-        9AX/AfIBpwHPBLUBzwGnAbUB9AL/IAAD/wH0ARYBRwEWAv8BvQEXAUcBvQb/AfQBtQGnAbUC/wHdAc8B
-        pwHdA/8gAAT/Ab0CRwG3Ab0BFwFHARYB9Af/Ad0BpwHPAQkB3QHPAacBtQH0A/8gAAT/AfQBFgFHARYB
-        lAFHARYB9An/AbUBpwK1AacBtQH0BP8gAAX/Ab0ERwGUCv8B3QGnAs8BpwEJBf8gAAb/AZQCRwEWAfQL
-        /wG1AqcBtQb/IAAH/wGUARYO/wK1B/8gACD/IAAg/yAAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEB
-        AAEBBQABgBcAA/+BAAs=
-</value>
-  </data>
-  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
-  <data name="treeView1.Location" type="System.Drawing.Point, System.Drawing">
-    <value>7, 7</value>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="treeView1.Margin" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>13, 13, 13, 13</value>
-  </data>
-  <data name="treeView1.Nodes" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-        AAEAAAD/////AQAAAAAAAAAMAgAAAEZTeXN0ZW0uV2luZG93cy5Gb3JtcywgQ3VsdHVyZT1uZXV0cmFs
-        LCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5BQEAAAAdU3lzdGVtLldpbmRvd3MuRm9ybXMu
-        VHJlZU5vZGULAAAABFRleHQLVG9vbFRpcFRleHQETmFtZQlJc0NoZWNrZWQKSW1hZ2VJbmRleAhJbWFn
-        ZUtleRJTZWxlY3RlZEltYWdlSW5kZXgQU2VsZWN0ZWRJbWFnZUtleQpDaGlsZENvdW50CWNoaWxkcmVu
-        MAljaGlsZHJlbjEBAQEAAAEAAQAEBAEICAgdU3lzdGVtLldpbmRvd3MuRm9ybXMuVHJlZU5vZGUCAAAA
-        HVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlAgAAAAIAAAAGAwAAAAVOb2RlMAYEAAAAAAYFAAAA
-        BU5vZGUwAP////8JBAAAAP////8JBAAAAAIAAAAJBwAAAAkIAAAABQcAAAAdU3lzdGVtLldpbmRvd3Mu
-        Rm9ybXMuVHJlZU5vZGUJAAAABFRleHQLVG9vbFRpcFRleHQETmFtZQlJc0NoZWNrZWQKSW1hZ2VJbmRl
-        eAhJbWFnZUtleRJTZWxlY3RlZEltYWdlSW5kZXgQU2VsZWN0ZWRJbWFnZUtleQpDaGlsZENvdW50AQEB
-        AAABAAEAAQgICAIAAAAGCQAAAApDaGlsZE5vZGUxBgoAAAAXQ2hpbGROb2RlMSBUb29sVGlwIHRleHQG
-        CwAAAApDaGlsZE5vZGUxAP////8JBAAAAP////8JBAAAAAAAAAAFCAAAAB1TeXN0ZW0uV2luZG93cy5G
-        b3Jtcy5UcmVlTm9kZQkAAAAEVGV4dAtUb29sVGlwVGV4dAROYW1lCUlzQ2hlY2tlZApJbWFnZUluZGV4
-        CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3RlZEltYWdlS2V5CkNoaWxkQ291bnQBAQEA
-        AAEAAQABCAgIAgAAAAYNAAAACkNoaWxkTm9kZTIJBAAAAAYPAAAACkNoaWxkTm9kZTIA/////wkEAAAA
-        /////wkEAAAAAAAAAAs=
-</value>
-  </data>
-  <data name="treeView1.Nodes1" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-        AAEAAAD/////AQAAAAAAAAAMAgAAAEZTeXN0ZW0uV2luZG93cy5Gb3JtcywgQ3VsdHVyZT1uZXV0cmFs
-        LCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5BQEAAAAdU3lzdGVtLldpbmRvd3MuRm9ybXMu
-        VHJlZU5vZGUMAAAAB1Byb3BCYWcEVGV4dAtUb29sVGlwVGV4dAROYW1lCUlzQ2hlY2tlZApJbWFnZUlu
-        ZGV4CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3RlZEltYWdlS2V5CkNoaWxkQ291bnQJ
-        Y2hpbGRyZW4wCWNoaWxkcmVuMQQBAQEAAAEAAQAEBClTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Pd25lckRy
-        YXdQcm9wZXJ0eUJhZwIAAAABCAgIHVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlAgAAAB1TeXN0
-        ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9kZQIAAAACAAAACQMAAAAGBAAAAAVOb2RlMQYFAAAAAAYGAAAA
-        BU5vZGUxAP////8JBQAAAP////8JBQAAAAIAAAAJCAAAAAkJAAAADAoAAABRU3lzdGVtLkRyYXdpbmcs
-        IFZlcnNpb249NC4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iMDNmNWY3ZjEx
-        ZDUwYTNhBQMAAAApU3lzdGVtLldpbmRvd3MuRm9ybXMuT3duZXJEcmF3UHJvcGVydHlCYWcDAAAACUJh
-        Y2tDb2xvcglGb3JlQ29sb3IERm9udAQEAhRTeXN0ZW0uRHJhd2luZy5Db2xvcgoAAAAUU3lzdGVtLkRy
-        YXdpbmcuQ29sb3IKAAAAAgAAAAX1////FFN5c3RlbS5EcmF3aW5nLkNvbG9yBAAAAARuYW1lBXZhbHVl
-        Cmtub3duQ29sb3IFc3RhdGUBAAAACQcHCgAAAAqA////AAAAAAAAAgAB9P////X///8KAAAAAAAAAAAl
-        AAEACgUIAAAAHVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlCwAAAARUZXh0C1Rvb2xUaXBUZXh0
-        BE5hbWUJSXNDaGVja2VkCkltYWdlSW5kZXgISW1hZ2VLZXkSU2VsZWN0ZWRJbWFnZUluZGV4EFNlbGVj
-        dGVkSW1hZ2VLZXkKQ2hpbGRDb3VudAljaGlsZHJlbjAJY2hpbGRyZW4xAQEBAAABAAEABAQBCAgIHVN5
-        c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlAgAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9k
-        ZQIAAAACAAAABg0AAAAFTm9kZTMJBQAAAAkNAAAAAP////8JBQAAAP////8JBQAAAAIAAAAJEQAAAAkS
-        AAAABQkAAAAdU3lzdGVtLldpbmRvd3MuRm9ybXMuVHJlZU5vZGULAAAABFRleHQLVG9vbFRpcFRleHQE
-        TmFtZQlJc0NoZWNrZWQKSW1hZ2VJbmRleAhJbWFnZUtleRJTZWxlY3RlZEltYWdlSW5kZXgQU2VsZWN0
-        ZWRJbWFnZUtleQpDaGlsZENvdW50CWNoaWxkcmVuMAljaGlsZHJlbjEBAQEAAAEAAQAEBAEICAgdU3lz
-        dGVtLldpbmRvd3MuRm9ybXMuVHJlZU5vZGUCAAAAHVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2Rl
-        AgAAAAIAAAAGEwAAAAVOb2RlNAkFAAAACRMAAAAA/////wkFAAAA/////wkFAAAAAgAAAAkXAAAACRgA
-        AAAFEQAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9kZQkAAAAEVGV4dAtUb29sVGlwVGV4dARO
-        YW1lCUlzQ2hlY2tlZApJbWFnZUluZGV4CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3Rl
-        ZEltYWdlS2V5CkNoaWxkQ291bnQBAQEAAAEAAQABCAgIAgAAAAYZAAAABU5vZGU1CQUAAAAJGQAAAAD/
-        ////CQUAAAD/////CQUAAAAAAAAABRIAAAAdU3lzdGVtLldpbmRvd3MuRm9ybXMuVHJlZU5vZGUJAAAA
-        BFRleHQLVG9vbFRpcFRleHQETmFtZQlJc0NoZWNrZWQKSW1hZ2VJbmRleAhJbWFnZUtleRJTZWxlY3Rl
-        ZEltYWdlSW5kZXgQU2VsZWN0ZWRJbWFnZUtleQpDaGlsZENvdW50AQEBAAABAAEAAQgICAIAAAAGHQAA
-        AAVOb2RlNgkFAAAACR0AAAAA/////wkFAAAA/////wkFAAAAAAAAAAUXAAAAHVN5c3RlbS5XaW5kb3dz
-        LkZvcm1zLlRyZWVOb2RlCQAAAARUZXh0C1Rvb2xUaXBUZXh0BE5hbWUJSXNDaGVja2VkCkltYWdlSW5k
-        ZXgISW1hZ2VLZXkSU2VsZWN0ZWRJbWFnZUluZGV4EFNlbGVjdGVkSW1hZ2VLZXkKQ2hpbGRDb3VudAEB
-        AQAAAQABAAEICAgCAAAABiEAAAAFTm9kZTcJBQAAAAkhAAAAAP////8JBQAAAP////8JBQAAAAAAAAAF
-        GAAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9kZQkAAAAEVGV4dAtUb29sVGlwVGV4dAROYW1l
-        CUlzQ2hlY2tlZApJbWFnZUluZGV4CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3RlZElt
-        YWdlS2V5CkNoaWxkQ291bnQBAQEAAAEAAQABCAgIAgAAAAYlAAAABU5vZGU4CQUAAAAJJQAAAAD/////
-        CQUAAAD/////CQUAAAAAAAAACw==
-</value>
-  </data>
-  <data name="treeView1.Nodes2" mimetype="application/x-microsoft.net.object.binary.base64">
-    <value>
-        AAEAAAD/////AQAAAAAAAAAMAgAAAEZTeXN0ZW0uV2luZG93cy5Gb3JtcywgQ3VsdHVyZT1uZXV0cmFs
-        LCBQdWJsaWNLZXlUb2tlbj1iNzdhNWM1NjE5MzRlMDg5BQEAAAAdU3lzdGVtLldpbmRvd3MuRm9ybXMu
-        VHJlZU5vZGUKAAAAB1Byb3BCYWcEVGV4dAtUb29sVGlwVGV4dAROYW1lCUlzQ2hlY2tlZApJbWFnZUlu
-        ZGV4CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3RlZEltYWdlS2V5CkNoaWxkQ291bnQE
-        AQEBAAABAAEAKVN5c3RlbS5XaW5kb3dzLkZvcm1zLk93bmVyRHJhd1Byb3BlcnR5QmFnAgAAAAEICAgC
-        AAAACQMAAAAGBAAAAAVOb2RlMgYFAAAAE05vZGUyIHRvb2wgdGlwIHRleHQGBgAAAAVOb2RlMgH/////
-        BgcAAAAA/////wkHAAAAAAAAAAwIAAAAUVN5c3RlbS5EcmF3aW5nLCBWZXJzaW9uPTQuMC4wLjAsIEN1
-        bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49YjAzZjVmN2YxMWQ1MGEzYQUDAAAAKVN5c3RlbS5X
-        aW5kb3dzLkZvcm1zLk93bmVyRHJhd1Byb3BlcnR5QmFnAwAAAAlCYWNrQ29sb3IJRm9yZUNvbG9yBEZv
-        bnQEBAQUU3lzdGVtLkRyYXdpbmcuQ29sb3IIAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yCAAAABNTeXN0
-        ZW0uRHJhd2luZy5Gb250CAAAAAIAAAAF9////xRTeXN0ZW0uRHJhd2luZy5Db2xvcgQAAAAEbmFtZQV2
-        YWx1ZQprbm93bkNvbG9yBXN0YXRlAQAAAAkHBwgAAAAKAAAAAAAAAAAAAAAAAfb////3////CgAAAAAA
-        AAAAAAAAAAkLAAAABQsAAAATU3lzdGVtLkRyYXdpbmcuRm9udAQAAAAETmFtZQRTaXplBVN0eWxlBFVu
-        aXQBAAQECxhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUIAAAAG1N5c3RlbS5EcmF3aW5nLkdyYXBoaWNz
-        VW5pdAgAAAAIAAAABgwAAAAQTWljcm9zb2Z0IFRhaSBMZQAAAEEF8////xhTeXN0ZW0uRHJhd2luZy5G
-        b250U3R5bGUBAAAAB3ZhbHVlX18ACAgAAAAAAAAABfL///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NV
-        bml0AQAAAAd2YWx1ZV9fAAgIAAAAAwAAAAs=
-</value>
-  </data>
-  <data name="treeView1.SelectedImageIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="treeView1.Size" type="System.Drawing.Size, System.Drawing">
-    <value>270, 247</value>
-  </data>
-  <data name="treeView1.TabIndex" type="System.Int32, mscorlib">
-    <value>0</value>
-  </data>
-  <data name="&gt;&gt;treeView1.Name" xml:space="preserve">
-    <value>treeView1</value>
-  </data>
-  <data name="&gt;&gt;treeView1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.TreeView, System.Windows.Forms, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;treeView1.Parent" xml:space="preserve">
-    <value>$this</value>
-  </data>
-  <data name="&gt;&gt;treeView1.ZOrder" xml:space="preserve">
-    <value>0</value>
-  </data>
-  <metadata name="$this.Localizable" type="System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
-    <value>True</value>
-  </metadata>
-  <data name="$this.AutoScaleDimensions" type="System.Drawing.SizeF, System.Drawing">
-    <value>96, 96</value>
-  </data>
-  <data name="$this.ClientSize" type="System.Drawing.Size, System.Drawing">
-    <value>284, 261</value>
-  </data>
-  <data name="$this.Padding" type="System.Windows.Forms.Padding, System.Windows.Forms">
-    <value>7, 7, 7, 7</value>
-  </data>
-  <data name="$this.Text" xml:space="preserve">
-    <value>TreeView</value>
-  </data>
-  <data name="&gt;&gt;imageList1.Name" xml:space="preserve">
-    <value>imageList1</value>
-  </data>
-  <data name="&gt;&gt;imageList1.Type" xml:space="preserve">
-    <value>System.Windows.Forms.ImageList, System.Windows.Forms, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-  <data name="&gt;&gt;$this.Name" xml:space="preserve">
-    <value>TreeViewTest</value>
-  </data>
-  <data name="&gt;&gt;$this.Type" xml:space="preserve">
-    <value>System.Windows.Forms.Form, System.Windows.Forms, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithFontNameEditor.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithFontNameEditor.cs
deleted file mode 100644
index 46937d60f10..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithFontNameEditor.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-
-namespace WinformsControlsTest.UserControls;
-
-internal class UserControlWithFontNameEditor : UserControl
-{
-    private const string Category = "!Fonts";
-
-    public UserControlWithFontNameEditor()
-    {
-        AutoScaleMode = AutoScaleMode.Font;
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameBold
-    {
-        get { return "Arial Black"; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameBoldItalic
-    {
-        get { return "Forte"; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameEmpty
-    {
-        get { return ""; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public int FontNameInt
-    {
-        get { return -1345; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameInvalid
-    {
-        get { return "some invalid font family"; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameNull
-    {
-        get { return null; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameItalics
-    {
-        get { return "Lucida Handwriting"; }
-        set { }
-    }
-
-    [Editor(typeof(FontNameEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category(Category)]
-    public string FontNameRegular
-    {
-        get { return "Arial"; }
-        set { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithObjectCollectionEditor.cs b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithObjectCollectionEditor.cs
deleted file mode 100644
index 0778d5e2bea..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/UserControls/UserControlWithObjectCollectionEditor.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing.Design;
-using System.Globalization;
-
-namespace WinformsControlsTest.UserControls;
-
-internal class UserControlWithObjectCollectionEditor : UserControl
-{
-    public UserControlWithObjectCollectionEditor()
-    {
-        AutoScaleMode = AutoScaleMode.Font;
-    }
-
-    [Editor(typeof(CollectionEditor), typeof(UITypeEditor))]
-    [Browsable(true)]
-    [EditorBrowsable(EditorBrowsableState.Always)]
-    [Category("Accessibility")]
-    [TypeConverter(typeof(SomeCollectionTypeConverter))]
-    public IList<int> AAAAAFirstCollection
-    {
-        get { return new List<int>(new int[] { 1, 2, 3 }); }
-        set { }
-    }
-}
-
-internal class SomeCollectionTypeConverter : TypeConverter
-{
-    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-    {
-        if (destinationType is not null && destinationType.IsAssignableFrom(typeof(string)) && value is IList<int> list)
-        {
-            return string.Join(", ", list);
-        }
-
-        return base.ConvertTo(context, culture, value, destinationType);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/WinformsControlsTest.csproj b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/WinformsControlsTest.csproj
deleted file mode 100644
index fff47a2dcc3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/WinformsControlsTest.csproj
+++ /dev/null
@@ -1,143 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <AssemblyName>WinformsControlsTest</AssemblyName>
-    <RootNamespace>WinformsControlsTest</RootNamespace>
-    <ApplicationIcon />
-    <OutputType>WinExe</OutputType>
-    <StartupObject />
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-    <EnableXlfLocalization>false</EnableXlfLocalization>
-    <UpdateXlfOnBuild>false</UpdateXlfOnBuild>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
-    <GenerateResourceWarnOnBinaryFormatterUse>false</GenerateResourceWarnOnBinaryFormatterUse>
-  </PropertyGroup>
-
-  <!--ApplicationConfiguration specific settings.-->
-  <!--https://github.com/dotnet/designs/blob/main/accepted/2021/winforms/streamline-application-bootstrap.md-->
-  <PropertyGroup>
-    <ApplicationDefaultFont>Calibri, 11pt, style=regular</ApplicationDefaultFont>
-    <ApplicationHighDpiMode>SystemAware</ApplicationHighDpiMode>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <NoWarn>$(NoWarn);WFDEV001</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\BuildAssist\BuildAssist.msbuildproj" />
-    <ProjectReference Include="..\..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Design\src\System.Windows.Forms.Design.csproj" />
-    <ProjectReference Include="..\..\..\..\System.Drawing.Common\src\System.Drawing.Common.csproj" />
-    <ProjectReference Include="..\..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Include="Data\DragDrop\DragAccept.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\DragAccept.rtf">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCat1.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCat2.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCat3.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCat4.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCat5.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCatAscii.txt">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\NyanCatAscii_301.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\ToolStripAsciiCat.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\ToolStripDragAccept.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Data\DragDrop\ToolStripNyanCat.bmp">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Images\SmallA.bmp">
-      <LogicalName>WinformsControlsTest.SmallA.bmp</LogicalName>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Images\SmallABlue.bmp">
-      <LogicalName>WinformsControlsTest.SmallABlue.bmp</LogicalName>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Images\LargeA.bmp">
-      <LogicalName>WinformsControlsTest.LargeA.bmp</LogicalName>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Include="Images\LargeABlue.bmp">
-      <LogicalName>WinformsControlsTest.LargeABlue.bmp</LogicalName>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="System.Management" Version="4.5.0-preview1-25914-04" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="Data\example.rtf">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
-
-    <!--
-      Library of Congress, Motion Picture, Broadcasting and Recorded Sound Division.
-      Blechynden, Frederick, Camera, Inc Thomas A. Edison, and Paper Print Collection. Tourists going round
-      Yellowstone Park. produceds by White, James H. Uction United States: Edison Manufacturing Co, 1899. Video.
-      https://www.loc.gov/item/00694320/.
-    -->
-    <None Update="Resources\media.mpg">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-  <!--
-
-      Reference local analyzers for test purposes
-
-    -->
-  <PropertyGroup>
-    <!-- Don't try to resolve analyzers from <repo root>\.dotnet\packs\Microsoft.WindowsDesktop.App.Ref\<version>\ref\net6.0 -->
-    <ResolveWinFormsAnalyzersFromSdkRefPack>false</ResolveWinFormsAnalyzersFromSdkRefPack>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Analyzers\src\System.Windows.Forms.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
-    <ProjectReference Include="..\..\..\..\System.Windows.Forms.Analyzers.CSharp\src\System.Windows.Forms.Analyzers.CSharp.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="AxInterop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\AxInterop.WMPLib.dll</HintPath>
-    </Reference>
-    <Reference Include="Interop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\Interop.WMPLib.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Update="MediaPlayer.cs" />
-  </ItemGroup>
-
-  <Import Project="..\..\..\..\..\pkg\Microsoft.Private.Winforms\sdk\dotnet-wpf\System.Windows.Forms.Analyzers.props" />
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/app.manifest b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/app.manifest
deleted file mode 100644
index f8763de7e1e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/app.manifest
+++ /dev/null
@@ -1,76 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC Manifest Options
-             If you want to change the Windows User Account Control level replace the 
-             requestedExecutionLevel node with one of the following.
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-            Specifying requestedExecutionLevel element will disable file and registry virtualization. 
-            Remove this element if your application requires this virtualization for backwards
-            compatibility.
-        -->
-        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- A list of the Windows versions that this application has been tested on
-           and is designed to work with. Uncomment the appropriate elements
-           and Windows will automatically select the most compatible environment. -->
-
-      <!-- Windows Vista -->
-      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
-
-      <!-- Windows 7 -->
-      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
-
-      <!-- Windows 8 -->
-      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
-
-      <!-- Windows 8.1 -->
-      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
-
-      <!-- Windows 10, Windows 11, Windows Server 2016, Windows Server 2019 and Windows Server 2022 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-
-    </application>
-  </compatibility>
-
-  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
-       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
-       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
-       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. -->
-  <!--
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-    </windowsSettings>
-  </application>
-  -->
-
-  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ComboBoxes.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ComboBoxes.zh-Hant.xlf
deleted file mode 100644
index 68caefcc926..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ComboBoxes.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../ComboBoxes.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hans.xlf
deleted file mode 100644
index 88873438255..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../DataGridViewHeaders.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hant.xlf
deleted file mode 100644
index 1f77e765035..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DataGridViewHeaders.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../DataGridViewHeaders.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hans.xlf
deleted file mode 100644
index c625dac112b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../DateTiemPicker.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hant.xlf
deleted file mode 100644
index 2adca679747..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DateTiemPicker.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../DateTiemPicker.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hans.xlf
deleted file mode 100644
index 6a9bd66b190..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../DesignTimeAligned.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hant.xlf
deleted file mode 100644
index f5f1f98a4af..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/DesignTimeAligned.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../DesignTimeAligned.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hans.xlf
deleted file mode 100644
index a0e182a8181..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../FormBorderStyles.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hant.xlf
deleted file mode 100644
index 63a2f81ba83..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/FormBorderStyles.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../FormBorderStyles.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.cs.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.cs.xlf
deleted file mode 100644
index 3ab455dd05f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.cs.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.de.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.de.xlf
deleted file mode 100644
index f0904a2f4f1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.de.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.es.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.es.xlf
deleted file mode 100644
index cce3eedfcf7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.es.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">encabezadoDeColumna1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">encabezadoDeColumna2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.fr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.fr.xlf
deleted file mode 100644
index 1a2c4111c7b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.fr.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.it.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.it.xlf
deleted file mode 100644
index 274fd181a46..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.it.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ja.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ja.xlf
deleted file mode 100644
index c2ca411c05e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ja.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ko.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ko.xlf
deleted file mode 100644
index 525c620eb8e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ko.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pl.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pl.xlf
deleted file mode 100644
index 61cfd589954..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pl.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pt-BR.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pt-BR.xlf
deleted file mode 100644
index 02c728a78b3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.pt-BR.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ru.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ru.xlf
deleted file mode 100644
index 12cae63a21f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.ru.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.tr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.tr.xlf
deleted file mode 100644
index 247b8e37a23..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.tr.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hans.xlf
deleted file mode 100644
index bfc135535b0..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hans.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hant.xlf
deleted file mode 100644
index 419ca2993fc..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ListViewTest.zh-Hant.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../ListViewTest.resx">
-    <body>
-      <trans-unit id="columnHeader1.Text">
-        <source>ColumnHeader1</source>
-        <target state="translated">ColumnHeader1</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="columnHeader2.Text">
-        <source>ColumnHeader2</source>
-        <target state="translated">ColumnHeader2</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hans.xlf
deleted file mode 100644
index 4118180edde..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MDIParent.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hant.xlf
deleted file mode 100644
index b7ef184539c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MDIParent.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MDIParent.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hans.xlf
deleted file mode 100644
index a96d4365de1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MainForm.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hant.xlf
deleted file mode 100644
index c972632e3e3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MainForm.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MainForm.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hans.xlf
deleted file mode 100644
index 6dbe93a1d7d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MdiChild.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hant.xlf
deleted file mode 100644
index f250fb96376..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MdiChild.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MdiChild.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hans.xlf
deleted file mode 100644
index 478b3defe16..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MenuForm.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hant.xlf
deleted file mode 100644
index 561c56ffdf1..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuForm.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MenuForm.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hans.xlf
deleted file mode 100644
index 607888b4018..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MenuStripAndCheckedListBox.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hant.xlf
deleted file mode 100644
index 48b9ef3d05f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MenuStripAndCheckedListBox.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MenuStripAndCheckedListBox.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hans.xlf
deleted file mode 100644
index 41f2adb56e3..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../MultipleControls.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hant.xlf
deleted file mode 100644
index 4f83e093b10..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/MultipleControls.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../MultipleControls.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.cs.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.cs.xlf
deleted file mode 100644
index 5c20fa27f05..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.cs.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Aktuální měřítko je 150 %.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.de.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.de.xlf
deleted file mode 100644
index d42a333c423..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.de.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Die aktuelle Skalierung beträgt 150 %.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.es.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.es.xlf
deleted file mode 100644
index 1486af0dbf5..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.es.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">Elementos TableLayoutPanel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">El escalado actual es 150 %</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.fr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.fr.xlf
deleted file mode 100644
index e87c0601390..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.fr.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">La mise à l'échelle actuelle est 150 %</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.it.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.it.xlf
deleted file mode 100644
index 7de3a12c97f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.it.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Il ridimensionamento corrente è 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ja.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ja.xlf
deleted file mode 100644
index 8fec2c28e6e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ja.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">現在のスケールは 150% です</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ko.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ko.xlf
deleted file mode 100644
index c3029d64bdc..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ko.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">크기 조정 비율은 현재 150%입니다.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pl.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pl.xlf
deleted file mode 100644
index 60c2b2d616f..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pl.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Bieżące skalowanie to 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pt-BR.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pt-BR.xlf
deleted file mode 100644
index 1c2801b0bd2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.pt-BR.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">A escala atual é 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ru.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ru.xlf
deleted file mode 100644
index dcae0d9e9e4..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.ru.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanel</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Текущее масштабирование: 150 %.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.tr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.tr.xlf
deleted file mode 100644
index 3c4cf073c23..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.tr.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">Geçerli ölçeklendirme 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hans.xlf
deleted file mode 100644
index 4cbb4348d1a..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hans.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">当前缩放比例为 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hant.xlf
deleted file mode 100644
index 53be0ecdf3b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Panels.zh-Hant.xlf
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../Panels.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TableLayoutPanels</source>
-        <target state="translated">TableLayoutPanels</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="currentDPILabel1.Text">
-        <source>Current scaling is 150%</source>
-        <target state="translated">目前的大小為 150%</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hans.xlf
deleted file mode 100644
index 7e1aacc0bd0..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../PictureBoxes.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hant.xlf
deleted file mode 100644
index 2b4e17c5ba7..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PictureBoxes.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../PictureBoxes.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hans.xlf
deleted file mode 100644
index 2d6bc7b890d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../PropertyGrid.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hant.xlf
deleted file mode 100644
index 8b125984e3b..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/PropertyGrid.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../PropertyGrid.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hans.xlf
deleted file mode 100644
index baee804d5c6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../RichTextBoxes.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hant.xlf
deleted file mode 100644
index d28df8c8bd0..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/RichTextBoxes.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../RichTextBoxes.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hans.xlf
deleted file mode 100644
index 3870902cc50..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../ScalingBeforeChanges.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hant.xlf
deleted file mode 100644
index 7dda8847edf..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/ScalingBeforeChanges.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../ScalingBeforeChanges.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hans.xlf
deleted file mode 100644
index 7eb770db3b2..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hans.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANS" original="../Splitter.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hant.xlf
deleted file mode 100644
index bbc030ed858..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/Splitter.zh-Hant.xlf
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-HANT" original="../Splitter.resx">
-    <body />
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.cs.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.cs.xlf
deleted file mode 100644
index 366360c031d..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.cs.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Stromové zobrazení</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.de.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.de.xlf
deleted file mode 100644
index e4d83c519fc..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.de.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Baumansicht</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.es.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.es.xlf
deleted file mode 100644
index 796162760f8..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.es.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">TreeView</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.fr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.fr.xlf
deleted file mode 100644
index 0b2962869f6..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.fr.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Arborescence</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.it.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.it.xlf
deleted file mode 100644
index abbaa97b2ad..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.it.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">TreeView</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ja.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ja.xlf
deleted file mode 100644
index a9b1d52de00..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ja.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">ツリー ビュー</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ko.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ko.xlf
deleted file mode 100644
index 9a79c52649c..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ko.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">트리 뷰</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pl.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pl.xlf
deleted file mode 100644
index 6d58aebf850..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pl.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Widok drzewa</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pt-BR.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pt-BR.xlf
deleted file mode 100644
index 522a18caaeb..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.pt-BR.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Exibição em Árvore</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ru.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ru.xlf
deleted file mode 100644
index 18bf39fff19..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.ru.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">Представление в виде дерева</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.tr.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.tr.xlf
deleted file mode 100644
index 35289937f2e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.tr.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">AğaçGörünümü</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hans.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hans.xlf
deleted file mode 100644
index ecb187b5e11..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hans.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">树视图</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hant.xlf b/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hant.xlf
deleted file mode 100644
index c4b37d8dc9e..00000000000
--- a/src/System.Windows.Forms/tests/IntegrationTests/WinformsControlsTest/xlf/TreeViewTest.zh-Hant.xlf
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../TreeViewTest.resx">
-    <body>
-      <trans-unit id="$this.Text">
-        <source>TreeView</source>
-        <target state="translated">樹狀檢視</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/InteropTests/AccessibleObjectTests.cs b/src/System.Windows.Forms/tests/InteropTests/AccessibleObjectTests.cs
deleted file mode 100644
index 8149ed637f0..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/AccessibleObjectTests.cs
+++ /dev/null
@@ -1,1073 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.InteropTests;
-
-public class AccessibleObjectTests : InteropTestBase
-{
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IAccessibleExConvertReturnedElement_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IAccessibleExConvertReturnedElement(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IAccessibleExGetIAccessiblePair_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IAccessibleExGetIAccessiblePair(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IAccessibleExGetRuntimeId_Invoke_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var o = new AccessibleObject();
-            AssertSuccess(Test_IAccessibleExGetRuntimeId(o, null));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public unsafe void AccessibleObject_IAccessibleExGetObjectForChild_Invoke_ReturnsExpected(int idChild)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IAccessibleExGetObjectForChild(o, idChild));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IServiceProvider_QueryService_Invoke_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IServiceProviderQueryService(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRawElementProviderSimple_GetHostRawElementProvider_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderSimpleHostRawElementProvider(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRawElementProviderSimpleProviderOptions_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderSimpleProviderOptions(o, ProviderOptions.ServerSideProvider | ProviderOptions.UseComThreading));
-    }
-
-    public static TheoryData<int, bool> GetPatternProvider_TestData() => new()
-    {
-        { (int)UIA.InvokePatternId, false },
-        { (int)UIA.SelectionPatternId, false },
-        { (int)UIA.IsInvokePatternAvailablePropertyId, false },
-        { (int)UIA.InvokePatternId - 1, false }
-    };
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPatternProvider_TestData))]
-    public void AccessibleObject_IRawElementProviderSimpleGetPatternProvider_Invoke_ReturnsExpected(int patternId, bool expected)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderSimpleGetPatternProvider(o, (UIA)patternId, (BOOL)expected));
-    }
-
-    public static IEnumerable<object[]> GetPropertyValue_TestData()
-    {
-        yield return new object[] { UIA.InvokePatternId, null };
-        yield return new object[] { UIA.SelectionPatternId, null };
-        yield return new object[] { UIA.IsInvokePatternAvailablePropertyId, false };
-        yield return new object[] { UIA.InvokePatternId - 1, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPropertyValue_TestData))]
-    public void AccessibleObject_IRawElementProviderSimpleGetPropertyValue_Invoke_ReturnsExpected(object patternId, object expected)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderSimpleGetPropertyValue(o, (UIA)patternId, out VARIANT variant));
-        Assert.Equal(expected, variant.ToObject());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderIsReadOnly_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetIsReadOnly(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderLargeChange_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetLargeChange(o, double.NaN));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderMaximum_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetMaximum(o, double.NaN));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderMinimum_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetMinimum(o, double.NaN));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderSmallChange_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetSmallChange(o, double.NaN));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRangeValueProviderValue_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderGetValue(o, double.NaN));
-    }
-
-    [WinFormsTheory]
-    [InlineData(101, double.NaN)]
-    [InlineData(100, double.NaN)]
-    [InlineData(1, double.NaN)]
-    [InlineData(0, double.NaN)]
-    [InlineData(-1, double.NaN)]
-    [InlineData(double.NaN, double.NaN)]
-    public void AccessibleObject_IRangeValueProviderSetValue_Invoke_GetReturnsExpected(double value, double expected)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRangeValueProviderSetValue(o, value, expected));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentBoundingRectangle_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentGetBoundingRectangle(o, new UiaRect()));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentFragmentRoot_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentGetFragmentRoot(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentGetEmbeddedFragmentRoots_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentGetEmbeddedFragmentRoots(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentGetRuntimeId_Invoke_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var o = new AccessibleObject();
-            AssertSuccess(Test_IRawElementProviderFragmentGetRuntimeId(o, null));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)NavigateDirection.Parent - 1)]
-    [InlineData((int)NavigateDirection.Parent)]
-    [InlineData((int)NavigateDirection.NextSibling)]
-    [InlineData((int)NavigateDirection.PreviousSibling)]
-    [InlineData((int)NavigateDirection.FirstChild)]
-    [InlineData((int)NavigateDirection.LastChild)]
-    [InlineData((int)NavigateDirection.LastChild + 1)]
-    public void AccessibleObject_IRawElementProviderFragmentNavigate_Invoke_ReturnsExpected(int direction)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentNavigate(o, (NavigateDirection)direction));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentSetFocus_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentSetFocus(o));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    [InlineData(double.NaN, double.NaN)]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentRootElementProviderFromPoint_Invoke_ReturnsExpected(double x, double y)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentRootElementProviderFromPoint(o, x, y));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IRawElementProviderFragmentRootGetFocus_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderFragmentRootGetFocus(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_IInvokeProviderInvoke_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IInvokeProviderInvoke(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IValueProviderIsReadOnly_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IValueProviderGetIsReadOnly(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IValueProviderValue_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IValueProviderGetValue(o, string.Empty));
-    }
-
-    [WinFormsTheory]
-    [InlineData("101", "")]
-    [InlineData("100", "")]
-    [InlineData("1", "")]
-    [InlineData("0", "")]
-    [InlineData("-1", "")]
-    [InlineData("abc", "")]
-    public void AccessibleObject_IValueProviderSetValue_Invoke_GetReturnsExpected(string value, string expected)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IValueProviderSetValue(o, value, expected));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IValueProviderCollapse_Invoke_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IExpandCollapseProviderCollapse(o, ExpandCollapseState.Collapsed));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IValueProviderCollapse_InvokeAfterExpand_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IExpandCollapseProviderExpand(o, ExpandCollapseState.Collapsed));
-        AssertSuccess(Test_IExpandCollapseProviderCollapse(o, ExpandCollapseState.Collapsed));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IExpandCollapseProviderExpand_Invoke_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IExpandCollapseProviderCollapse(o, ExpandCollapseState.Collapsed));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IExpandCollapseProviderExpand_InvokeAfterCollapse_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IExpandCollapseProviderCollapse(o, ExpandCollapseState.Collapsed));
-        AssertSuccess(Test_IExpandCollapseProviderCollapse(o, ExpandCollapseState.Collapsed));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IExpandCollapseProviderExpandCollapseState_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IExpandCollapseProviderGetExpandCollapseState(o, ExpandCollapseState.Collapsed));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IToggleProviderToggleState_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IToggleProviderGetToggleState(o, ToggleState.Indeterminate));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IToggleProviderToggle_Invoke_Success()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IToggleProviderToggle(o, ToggleState.Indeterminate));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ITableProviderRowOrColumnMajor_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ITableProviderGetRowOrColumnMajor(o, RowOrColumnMajor.RowMajor));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ITableProviderGetColumnHeaders_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ITableProviderGetColumnHeaders(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ITableProviderGetRowHeaders_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ITableProviderGetRowHeaders(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ITableItemProviderGetColumnHeaderItems_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ITableItemProviderGetColumnHeaderItems(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ITableItemProviderGetRowHeaderItems_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ITableItemProviderGetRowHeaderItems(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridProviderColumnCount_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridProviderGetColumnCount(o, -1));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridProviderRowCount_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridProviderGetRowCount(o, -1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(-1, 0)]
-    [InlineData(0, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(0, 1)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_IGridProviderGetItem_Get_ReturnsExpected(int row, int column)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridProviderGetItem(o, row, column));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridItemProviderColumn_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridItemProviderGetColumn(o, -1));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridItemProviderColumnSpan_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridItemProviderGetColumnSpan(o, 1));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridItemProviderContainingGrid_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridItemProviderGetContainingGrid(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridItemProviderRow_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridItemProviderGetRow(o, -1));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IGridItemProviderRowSpan_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IGridItemProviderGetRowSpan(o, 1));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IEnumVARIANTClone_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IEnumVARIANTClone(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IEnumVARIANTNextReset_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IEnumVARIANTNextReset(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IEnumVARIANTSkip_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IEnumVARIANTSkip(o));
-    }
-
-    [WinFormsFact]
-    public unsafe void SystemAccessibleObject_Enumeration()
-    {
-        using ComboBox control = new ComboBox
-        {
-            DropDownStyle = ComboBoxStyle.DropDown
-        };
-        control.CreateControl();
-        ComboBox.ComboBoxAccessibleObject accessibleObject = new ComboBox.ComboBoxAccessibleObject(control);
-
-            var enumVariant = (IEnumVARIANT.Interface)accessibleObject;
-            Assert.Equal(HRESULT.S_OK, enumVariant.Reset());
-
-            VARIANT variantObject;
-            uint retreivedCount;
-            var result = enumVariant.Next(1, &variantObject, &retreivedCount);
-            Assert.Equal(HRESULT.S_OK, result);
-
-        var retreivedItem = variantObject.ToObject();
-
-        Assert.Equal(1, Assert.IsType<int>(retreivedItem));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void AccessibleObject_IOleWindowContextSensitiveHelp_Invoke_ReturnsExpected(bool fEnterMode)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IOleWindowContextSensitiveHelp(o, (BOOL)fEnterMode, HRESULT.S_OK));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void AccessibleObject_IOleWindowContextSensitiveHelp_InvokeWithParent_ReturnsExpected(bool fEnterMode)
-    {
-        var o = new CustomParentAccessibleObject
-        {
-            ParentResult = new AccessibleObject()
-        };
-        AssertSuccess(Test_IOleWindowContextSensitiveHelp(o, (BOOL)fEnterMode, HRESULT.S_OK));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void AccessibleObject_IOleWindowContextSensitiveHelp_InvokeWithControlParent_ReturnsExpected(bool fEnterMode)
-    {
-        using var control = new Control();
-        var o = new CustomParentAccessibleObject
-        {
-            ParentResult = new Control.ControlAccessibleObject(control)
-        };
-        AssertSuccess(Test_IOleWindowContextSensitiveHelp(o, (BOOL)fEnterMode, HRESULT.S_OK));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IOleWindowGetWindow_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IOleWindowGetWindow(o, IntPtr.Zero, HRESULT.E_FAIL));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IOleWindowGetWindow_InvokeWithParent_ReturnsExpected()
-    {
-        var o = new CustomParentAccessibleObject
-        {
-            ParentResult = new AccessibleObject()
-        };
-        AssertSuccess(Test_IOleWindowGetWindow(o, IntPtr.Zero, HRESULT.E_FAIL));
-    }
-
-    // Crashes with Attempted to read or write protected memory. This is often an indication that other memory is corrupt..
-#if false
-    [WinFormsFact]
-    public void AccessibleObject_IOleWindowGetWindow_InvokeWithControlParent_ReturnsExpected()
-    {
-        using var control = new Control();
-        var o = new CustomParentAccessibleObject
-        {
-            ParentResult = new Control.ControlAccessibleObject(control)
-        };
-        AssertSuccess(Test_IOleWindowGetWindow(o, control.Handle, HRESULT.S_OK));
-    }
-#endif
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderChildId_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetChildId(o, 0));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderDefaultAction_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetDefaultAction(o, null));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderDescription_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetDescription(o, null));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderHelp_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetHelp(o, null));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderKeyboardShortcut_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetKeyboardShortcut(o, null));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderName_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetName(o, null));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderRole_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetRole(o, 0));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderState_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetState(o, 0));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderValue_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetValue(o, string.Empty));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderDoDefaultAction_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderDoDefaultAction(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderGetIAccessible_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetIAccessible(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ILegacyIAccessibleProviderGetSelection_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderGetSelection(o, false));
-    }
-
-    [WinFormsTheory]
-    [InlineData("101", "")]
-    [InlineData("100", "")]
-    [InlineData("1", "")]
-    [InlineData("0", "")]
-    [InlineData("-1", "")]
-    [InlineData("abc", "")]
-    public void AccessibleObject_ILegacyIAccessibleProviderSetValue_Invoke_GetReturnsExpected(string value, string expected)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderSetValue(o, value, expected));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(4)]
-    [InlineData(8)]
-    [InlineData(16)]
-    [InlineData(int.MaxValue)]
-    public void AccessibleObject_ILegacyIAccessibleProviderSelect_Invoke_ReturnsExpected(int flagsSelect)
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ILegacyIAccessibleProviderSelect(o, flagsSelect));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionProviderCanSelectMultiple_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionProviderGetCanSelectMultiple(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionProviderIsSelectionRequired_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionProviderGetIsSelectionRequired(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionProviderGetSelection_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionProviderGetSelection(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionProviderIsSelected_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionItemProviderGetIsSelected(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionProviderSelectionContainer_Get_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionItemProviderGetSelectionContainer(o, false));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionItemProviderAddToSelection_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionItemProviderAddToSelection(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionItemProviderRemoveFromSelection_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionItemProviderRemoveFromSelection(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_ISelectionItemProviderSelect_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_ISelectionItemProviderSelect(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IRawElementProviderHwndOverrideGetOverrideProviderForHwnd_Invoke_ReturnsExpected()
-    {
-        var o = new AccessibleObject();
-        AssertSuccess(Test_IRawElementProviderHwndOverrideGetOverrideProviderForHwnd(o));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IScrollItemProviderScrollIntoView_Invoke_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var o = new AccessibleObject();
-            AssertSuccess(Test_IScrollItemProviderScrollIntoView(o));
-        }
-    }
-
-    private class CustomParentAccessibleObject : AccessibleObject
-    {
-        public AccessibleObject ParentResult { get; set; }
-
-        public override AccessibleObject Parent => ParentResult;
-    }
-
-    private class StandardAccessibleObject : AccessibleObject
-    {
-        public new void UseStdAccessibleObjects(IntPtr handle) => base.UseStdAccessibleObjects(handle);
-    }
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IAccessibleExConvertReturnedElement(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IAccessibleExGetIAccessiblePair(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IAccessibleExGetRuntimeId(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int* expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IAccessibleExGetObjectForChild(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int idChild);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IServiceProviderQueryService(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderSimpleHostRawElementProvider(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderSimpleProviderOptions(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ProviderOptions expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderSimpleGetPatternProvider(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        UIA patternId,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderSimpleGetPropertyValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        UIA patternId,
-        out VARIANT expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetIsReadOnly(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetLargeChange(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetSmallChange(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetMaximum(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetMinimum(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderGetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRangeValueProviderSetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double value, double expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentGetBoundingRectangle(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        UiaRect expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentGetFragmentRoot(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentGetEmbeddedFragmentRoots(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentGetRuntimeId(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int* expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderFragmentNavigate(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        NavigateDirection expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentSetFocus(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentRootElementProviderFromPoint(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        double x,
-        double y);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IRawElementProviderFragmentRootGetFocus(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern unsafe string Test_IInvokeProviderInvoke(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IValueProviderGetIsReadOnly(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IValueProviderGetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IValueProviderSetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string value, string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IExpandCollapseProviderGetExpandCollapseState(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ExpandCollapseState expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IExpandCollapseProviderCollapse(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ExpandCollapseState expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IExpandCollapseProviderExpand(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ExpandCollapseState expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IToggleProviderGetToggleState(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ToggleState expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IToggleProviderToggle(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        ToggleState expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ITableProviderGetRowOrColumnMajor(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        RowOrColumnMajor expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ITableProviderGetColumnHeaders(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ITableProviderGetRowHeaders(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ITableItemProviderGetColumnHeaderItems(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ITableItemProviderGetRowHeaderItems(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridProviderGetColumnCount(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridProviderGetRowCount(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridProviderGetItem(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int row,
-        int column);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridItemProviderGetColumn(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridItemProviderGetColumnSpan(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridItemProviderGetContainingGrid(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridItemProviderGetRow(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IGridItemProviderGetRowSpan(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IEnumVARIANTClone(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IEnumVARIANTNextReset(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IEnumVARIANTSkip(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IOleWindowContextSensitiveHelp(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL fEnterMode,
-        HRESULT expectedHr);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IOleWindowGetWindow(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        IntPtr expected,
-        HRESULT expectedHr);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetChildId(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetDefaultAction(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetDescription(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetHelp(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetKeyboardShortcut(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetName(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetRole(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        uint expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetState(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        uint expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderDoDefaultAction(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetIAccessible(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderGetSelection(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderSelect(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        int flagsSelect);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ILegacyIAccessibleProviderSetValue(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        string value, string expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionProviderGetCanSelectMultiple(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionProviderGetIsSelectionRequired(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionProviderGetSelection(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionItemProviderGetIsSelected(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionItemProviderGetSelectionContainer(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
-        BOOL expected);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionItemProviderAddToSelection(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionItemProviderRemoveFromSelection(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_ISelectionItemProviderSelect(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IRawElementProviderHwndOverrideGetOverrideProviderForHwnd(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    [DllImport(NativeTests, ExactSpelling = true, CharSet = CharSet.Unicode)]
-    private static extern string Test_IScrollItemProviderScrollIntoView(
-        [MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/GlobalUsings.cs b/src/System.Windows.Forms/tests/InteropTests/GlobalUsings.cs
deleted file mode 100644
index e935cf9f5f4..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/GlobalUsings.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using Windows.Win32;
-global using Windows.Win32.Foundation;
-global using Xunit;
diff --git a/src/System.Windows.Forms/tests/InteropTests/InteropTestBase.cs b/src/System.Windows.Forms/tests/InteropTests/InteropTestBase.cs
deleted file mode 100644
index c8ba29524db..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/InteropTestBase.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Xunit.Sdk;
-
-namespace System.Windows.Forms.InteropTests;
-
-public abstract class InteropTestBase
-{
-    public const string NativeTests = "NativeTests";
-    public const string Success = "Success";
-
-    protected static void AssertSuccess(string result)
-    {
-        if (result != Success)
-        {
-            throw new XunitException(result);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/AccessibleObjectTests.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/AccessibleObjectTests.cpp
deleted file mode 100644
index 66bf8e22cc6..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/AccessibleObjectTests.cpp
+++ /dev/null
@@ -1,1925 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "testhelpers.h"
-#include <cassert>
-#include <UIAutomation.h>
-#include <atlbase.h>
-using namespace ATL;
-
-#define COR_E_NOTSUPPORTED 0x80131515
-
-TEST const WCHAR* WINAPI Test_IAccessibleExConvertReturnedElement(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IAccessibleEx> pAccessibleEx;
-        CComPtr<IRawElementProviderSimple> pIn;
-
-        hr = pUnknown->QueryInterface(IID_IAccessibleEx, (void**)&pAccessibleEx);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderSimple, (void**)&pIn);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IAccessibleEx> result;
-        hr = pAccessibleEx->ConvertReturnedElement(pIn, &result);
-        assertEqualHr(E_NOTIMPL, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pAccessibleEx->ConvertReturnedElement(NULL, &result);
-        assertEqualHr(E_NOTIMPL, hr);
-
-        hr = pAccessibleEx->ConvertReturnedElement(pIn, NULL);
-        assertEqualHr(E_POINTER, hr);
-        assertNull(result.p);
-
-        hr = pAccessibleEx->ConvertReturnedElement(NULL, NULL);
-        assertEqualHr(E_POINTER, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IAccessibleExGetIAccessiblePair(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IAccessibleEx> pAccessibleEx;
-
-        hr = pUnknown->QueryInterface(IID_IAccessibleEx, (void**)&pAccessibleEx);
-        assertEqualHr(S_OK, hr);
-
-        long idChild = 1;
-        CComPtr<IAccessible> result;
-        hr = pAccessibleEx->GetIAccessiblePair(&result, &idChild);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result.p);
-        assertEqualInt(0, idChild);
-
-        // Negative tests.
-        idChild = 1;
-        hr = pAccessibleEx->GetIAccessiblePair(NULL, &idChild);
-#if false
-        assertEqualHr(E_POINTER, hr);
-#else
-        assertEqualHr(S_OK, hr);
-#endif
-        assertEqualInt(1, idChild);
-
-        result = NULL;
-        hr = pAccessibleEx->GetIAccessiblePair(&result, NULL);
-        assertEqualHr(E_INVALIDARG, hr);
-        assertNull(result.p);
-
-        hr = pAccessibleEx->GetIAccessiblePair(NULL, NULL);
-#if false
-        assertEqualHr(E_POINTER, hr);
-#else
-        assertEqualHr(S_OK, hr);
-#endif
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IAccessibleExGetRuntimeId(IUnknown* pUnknown, int* expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IAccessibleEx> pAccessibleEx;
-
-        hr = pUnknown->QueryInterface(IID_IAccessibleEx, (void**)&pAccessibleEx);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pAccessibleEx->GetRuntimeId(&result);
-        assertEqualHr(COR_E_NOTSUPPORTED, hr);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pAccessibleEx->GetRuntimeId(NULL);
-        assertEqualHr(COR_E_NOTSUPPORTED, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IAccessibleExGetObjectForChild(IUnknown* pUnknown, long idChild)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IAccessibleEx> pAccessibleEx;
-
-        hr = pUnknown->QueryInterface(IID_IAccessibleEx, (void**)&pAccessibleEx);
-        assertEqualHr(S_OK, hr);
-
-        long idChild = 1;
-        CComPtr<IAccessibleEx> result;
-        hr = pAccessibleEx->GetObjectForChild(idChild, &result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pAccessibleEx->GetObjectForChild(idChild, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IServiceProviderQueryService(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IServiceProvider> pServiceProvider;
-
-        hr = pUnknown->QueryInterface(IID_IServiceProvider, (void**)&pServiceProvider);
-        assertEqualHr(S_OK, hr);
-
-        GUID service = { 0 };
-        GUID riid = { 0 };
-        void* pObject = NULL;
-
-        hr = pServiceProvider->QueryService(service, riid, &pObject);
-        assertEqualHr(E_NOINTERFACE, hr);
-
-        service = IID_IAccessibleEx;
-        riid = { 0 };
-        hr = pServiceProvider->QueryService(service, riid, &pObject);
-        assertEqualHr(E_NOINTERFACE, hr);
-
-        service = { 0 };
-        riid = IID_IAccessibleEx;
-        hr = pServiceProvider->QueryService(service, riid, &pObject);
-        assertEqualHr(E_NOINTERFACE, hr);
-
-        service = IID_IAccessibleEx;
-        riid = IID_IAccessibleEx;
-        hr = pServiceProvider->QueryService(service, riid, &pObject);
-        assertEqualHr(E_NOINTERFACE, hr);
-
-        // Negative tests.
-        hr = pServiceProvider->QueryService(service, riid, NULL);
-        assertEqualHr(E_POINTER, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderSimpleHostRawElementProvider(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderSimple> pRawElementProviderSimple;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderSimple, (void**)&pRawElementProviderSimple);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderSimple> result;
-        hr = pRawElementProviderSimple->get_HostRawElementProvider(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualBool(expected, result != NULL);
-
-        // Negative tests.
-        hr = pRawElementProviderSimple->get_HostRawElementProvider(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderSimpleProviderOptions(IUnknown* pUnknown, ProviderOptions expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderSimple> pRawElementProviderSimple;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderSimple, (void**)&pRawElementProviderSimple);
-        assertEqualHr(S_OK, hr);
-
-        ProviderOptions result;
-        hr = pRawElementProviderSimple->get_ProviderOptions(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pRawElementProviderSimple->get_ProviderOptions(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderSimpleGetPatternProvider(IUnknown* pUnknown, PATTERNID patternId, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderSimple> pRawElementProviderSimple;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderSimple, (void**)&pRawElementProviderSimple);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IUnknown> pResult;
-        hr = pRawElementProviderSimple->GetPatternProvider(patternId, &pResult);
-        assertEqualHr(S_OK, hr);
-        if (expected)
-        {
-            assert(pResult == pUnknown);
-        }
-        else
-        {
-            assertNull(pResult.p);
-        }
-
-        // Negative tests.
-        hr = pRawElementProviderSimple->GetPatternProvider(UIA_DockPatternId, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderSimpleGetPropertyValue(IUnknown* pUnknown, PATTERNID patternId, VARIANT* result)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderSimple> pRawElementProviderSimple;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderSimple, (void**)&pRawElementProviderSimple);
-        assertEqualHr(S_OK, hr);
-
-        hr = pRawElementProviderSimple->GetPropertyValue(patternId, result);
-        assertEqualHr(S_OK, hr);
-
-        // Negative tests.
-        hr = pRawElementProviderSimple->GetPropertyValue(UIA_DockPatternId, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentGetBoundingRectangle(IUnknown* pUnknown, UiaRect expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        UiaRect result;
-        hr = pRawElementProviderFragment->get_BoundingRectangle(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected.left, result.left);
-        assertEqualDouble(expected.top, result.top);
-        assertEqualDouble(expected.width, result.width);
-        assertEqualDouble(expected.height, result.height);
-
-        // Negative tests.
-        hr = pRawElementProviderFragment->get_BoundingRectangle(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentGetFragmentRoot(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderFragmentRoot> result;
-        hr = pRawElementProviderFragment->get_FragmentRoot(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pRawElementProviderFragment->get_FragmentRoot(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentGetEmbeddedFragmentRoots(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pRawElementProviderFragment->GetEmbeddedFragmentRoots(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pRawElementProviderFragment->GetEmbeddedFragmentRoots(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentGetRuntimeId(IUnknown* pUnknown, int* expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pRawElementProviderFragment->GetRuntimeId(&result);
-        assertEqualHr(COR_E_NOTSUPPORTED, hr);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pRawElementProviderFragment->GetRuntimeId(NULL);
-        assertEqualHr(COR_E_NOTSUPPORTED, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentNavigate(IUnknown* pUnknown, NavigateDirection direction)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderFragment> result;
-        hr = pRawElementProviderFragment->Navigate(direction, &result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pRawElementProviderFragment->Navigate(NavigateDirection_Parent, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentSetFocus(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragment> pRawElementProviderFragment;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        hr = pRawElementProviderFragment->SetFocus();
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentRootElementProviderFromPoint(IUnknown* pUnknown, double x, double y)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragmentRoot> pRawElementProviderFragment;
-        CComPtr<IRawElementProviderFragmentRoot> pRawElementProviderFragmentRoot;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragment, (void**)&pRawElementProviderFragment);
-        assertEqualHr(S_OK, hr);
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragmentRoot, (void**)&pRawElementProviderFragmentRoot);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderFragment> result;
-        hr = pRawElementProviderFragmentRoot->ElementProviderFromPoint(x, y, &result);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result.p);
-
-        // Negative tests.
-        hr = pRawElementProviderFragmentRoot->ElementProviderFromPoint(0, 0, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderFragmentRootGetFocus(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderFragmentRoot> pRawElementProviderFragmentRoot;
-
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderFragmentRoot, (void**)&pRawElementProviderFragmentRoot);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderFragment> result;
-        hr = pRawElementProviderFragmentRoot->GetFocus(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pRawElementProviderFragmentRoot->GetFocus(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IInvokeProviderInvoke(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IInvokeProvider> pInvokeProvider;
-
-        hr = pUnknown->QueryInterface(IID_IInvokeProvider, (void**)&pInvokeProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pInvokeProvider->Invoke();
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IValueProviderGetIsReadOnly(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pRangeValueProvider->get_IsReadOnly(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_IsReadOnly(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IValueProviderGetValue(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pRangeValueProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_Value(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IValueProviderSetValue(IUnknown* pUnknown, LPCWSTR value, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pRangeValueProvider->SetValue(value);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pRangeValueProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests
-        hr = pRangeValueProvider->SetValue(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetIsReadOnly(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pRangeValueProvider->get_IsReadOnly(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_IsReadOnly(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetLargeChange(IUnknown* pUnknown, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_LargeChange(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_LargeChange(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetMaximum(IUnknown* pUnknown, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_Maximum(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_Maximum(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetMinimum(IUnknown* pUnknown, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_Minimum(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_Minimum(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetSmallChange(IUnknown* pUnknown, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_SmallChange(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_SmallChange(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderGetValue(IUnknown* pUnknown, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        // Negative tests.
-        hr = pRangeValueProvider->get_Value(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRangeValueProviderSetValue(IUnknown* pUnknown, double value, double expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRangeValueProvider> pRangeValueProvider;
-
-        hr = pUnknown->QueryInterface(IID_IRangeValueProvider, (void**)&pRangeValueProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pRangeValueProvider->SetValue(value);
-        assertEqualHr(S_OK, hr);
-
-        double result;
-        hr = pRangeValueProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualDouble(expected, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IExpandCollapseProviderGetExpandCollapseState(IUnknown* pUnknown, ExpandCollapseState expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IExpandCollapseProvider> pExpandCollapseProvider;
-
-        hr = pUnknown->QueryInterface(IID_IExpandCollapseProvider, (void**)&pExpandCollapseProvider);
-        assertEqualHr(S_OK, hr);
-
-        ExpandCollapseState result;
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IExpandCollapseProviderCollapse(IUnknown* pUnknown, ExpandCollapseState expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IExpandCollapseProvider> pExpandCollapseProvider;
-
-        hr = pUnknown->QueryInterface(IID_IExpandCollapseProvider, (void**)&pExpandCollapseProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pExpandCollapseProvider->Collapse();
-        assertEqualHr(S_OK, hr);
-
-        ExpandCollapseState result;
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Call again.
-        hr = pExpandCollapseProvider->Collapse();
-        assertEqualHr(S_OK, hr);
-
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IExpandCollapseProviderExpand(IUnknown* pUnknown, ExpandCollapseState expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IExpandCollapseProvider> pExpandCollapseProvider;
-
-        hr = pUnknown->QueryInterface(IID_IExpandCollapseProvider, (void**)&pExpandCollapseProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pExpandCollapseProvider->Expand();
-        assertEqualHr(S_OK, hr);
-
-        ExpandCollapseState result;
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Call again.
-        hr = pExpandCollapseProvider->Expand();
-        assertEqualHr(S_OK, hr);
-
-        hr = pExpandCollapseProvider->get_ExpandCollapseState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IToggleProviderGetToggleState(IUnknown* pUnknown, ToggleState expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IToggleProvider> pToggleProvider;
-
-        hr = pUnknown->QueryInterface(IID_IToggleProvider, (void**)&pToggleProvider);
-        assertEqualHr(S_OK, hr);
-
-        ToggleState result;
-        hr = pToggleProvider->get_ToggleState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pToggleProvider->get_ToggleState(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IToggleProviderToggle(IUnknown* pUnknown, ToggleState expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IToggleProvider> pToggleProvider;
-
-        hr = pUnknown->QueryInterface(IID_IToggleProvider, (void**)&pToggleProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pToggleProvider->Toggle();
-        assertEqualHr(S_OK, hr);
-
-        ToggleState result;
-        hr = pToggleProvider->get_ToggleState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Call again.
-        hr = pToggleProvider->Toggle();
-        assertEqualHr(S_OK, hr);
-
-        hr = pToggleProvider->get_ToggleState(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ITableProviderGetRowOrColumnMajor(IUnknown* pUnknown, RowOrColumnMajor expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ITableProvider> pTableProvider;
-
-        hr = pUnknown->QueryInterface(IID_ITableProvider, (void**)&pTableProvider);
-        assertEqualHr(S_OK, hr);
-
-        RowOrColumnMajor result;
-        hr = pTableProvider->get_RowOrColumnMajor(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pTableProvider->get_RowOrColumnMajor(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ITableProviderGetColumnHeaders(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ITableProvider> pTableProvider;
-
-        hr = pUnknown->QueryInterface(IID_ITableProvider, (void**)&pTableProvider);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pTableProvider->GetColumnHeaders(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pTableProvider->GetColumnHeaders(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ITableProviderGetRowHeaders(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ITableProvider> pTableProvider;
-
-        hr = pUnknown->QueryInterface(IID_ITableProvider, (void**)&pTableProvider);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pTableProvider->GetRowHeaders(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pTableProvider->GetRowHeaders(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ITableItemProviderGetColumnHeaderItems(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ITableItemProvider> pTableItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ITableItemProvider, (void**)&pTableItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pTableItemProvider->GetColumnHeaderItems(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pTableItemProvider->GetColumnHeaderItems(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ITableItemProviderGetRowHeaderItems(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ITableItemProvider> pTableItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ITableItemProvider, (void**)&pTableItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pTableItemProvider->GetRowHeaderItems(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests.
-        hr = pTableItemProvider->GetRowHeaderItems(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridProviderGetColumnCount(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridProvider> pGridProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridProvider, (void**)&pGridProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridProvider->get_ColumnCount(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridProvider->get_ColumnCount(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridProviderGetRowCount(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridProvider> pGridProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridProvider, (void**)&pGridProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridProvider->get_RowCount(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridProvider->get_RowCount(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridProviderGetItem(IUnknown* pUnknown, int row, int column)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridProvider> pIGridProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridProvider, (void**)&pIGridProvider);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderSimple> result;
-        hr = pIGridProvider->GetItem(row, column, &result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pIGridProvider->GetItem(row, column, NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridItemProviderGetContainingGrid(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridItemProvider> pGridItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridItemProvider, (void**)&pGridItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderSimple> result;
-        hr = pGridItemProvider->get_ContainingGrid(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pGridItemProvider->get_ContainingGrid(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridItemProviderGetColumn(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridItemProvider> pGridItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridItemProvider, (void**)&pGridItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridItemProvider->get_Column(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridItemProvider->get_Column(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridItemProviderGetColumnSpan(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridItemProvider> pGridItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridItemProvider, (void**)&pGridItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridItemProvider->get_ColumnSpan(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridItemProvider->get_ColumnSpan(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridItemProviderGetRow(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridItemProvider> pGridItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridItemProvider, (void**)&pGridItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridItemProvider->get_Row(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridItemProvider->get_Row(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IGridItemProviderGetRowSpan(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IGridItemProvider> pGridItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IGridItemProvider, (void**)&pGridItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pGridItemProvider->get_RowSpan(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pGridItemProvider->get_RowSpan(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IEnumVARIANTClone(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IEnumVARIANT> pEnumVariant;
-
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IEnumVARIANT> result;
-        hr = pEnumVariant->Clone(&result);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result.p);
-        assert(result.p != pEnumVariant.p);
-
-        VARIANT var;
-        ULONG celtFetched = 2;
-        hr = result->Next(1, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Negative tests.
-        hr = pEnumVariant->Clone(NULL);
-        assertEqualHr(E_POINTER, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IEnumVARIANTNextReset(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IEnumVARIANT> pEnumVariant1;
-        CComPtr<IEnumVARIANT> pEnumVariant2;
-        CComPtr<IEnumVARIANT> pEnumVariant3;
-        CComPtr<IEnumVARIANT> pEnumVariant4;
-
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant1);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant2);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant3);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant4);
-        assertEqualHr(S_OK, hr);
-
-        // Fetch nothing.
-        VARIANT var;
-        ULONG celtFetched = 2;
-        hr = pEnumVariant1->Next(0, &var, &celtFetched);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Fetch one.
-        for (int i = 0; i < 2; i++)
-        {
-            hr = pEnumVariant1->Next(1, &var, &celtFetched);
-            assertEqualHr(S_FALSE, hr);
-            assertEqualInt(0, celtFetched);
-
-            // Fetch another.
-            hr = pEnumVariant1->Next(2, &var, &celtFetched);
-            assertEqualHr(S_FALSE, hr);
-            assertEqualInt(0, celtFetched);
-
-            // Fetch another.
-            hr = pEnumVariant1->Next(1, &var, &celtFetched);
-            assertEqualHr(S_FALSE, hr);
-            assertEqualInt(0, celtFetched);
-
-            // Fetch another.
-            hr = pEnumVariant1->Reset();
-            assertEqualHr(S_OK, hr);
-        }
-
-        // Fetch more than one.
-        hr = pEnumVariant2->Next(2, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Fetch without celt.
-        hr = pEnumVariant2->Next(1, &var, NULL);
-#if false
-        assertEqualHr(E_POINTER, hr);
-#else
-        assertEqualHr(S_OK, hr);
-#endif
-
-        // Negative tests.
-        hr = pEnumVariant4->Next(1, NULL, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IEnumVARIANTSkip(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IEnumVARIANT> pEnumVariant1;
-        CComPtr<IEnumVARIANT> pEnumVariant2;
-        CComPtr<IEnumVARIANT> pEnumVariant3;
-        VARIANT var;
-        ULONG celtFetched = 2;
-
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant1);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant2);
-        assertEqualHr(S_OK, hr);
-        hr = pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant3);
-        assertEqualHr(S_OK, hr);
-
-        // Skip nothing.
-        hr = pEnumVariant1->Skip(0);
-        assertEqualHr(S_OK, hr);
-
-        // Fetch.
-        hr = pEnumVariant1->Next(1, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Skip one.
-        hr = pEnumVariant2->Skip(1);
-        assertEqualHr(S_OK, hr);
-
-        hr = pEnumVariant1->Next(1, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Skip again.
-        hr = pEnumVariant1->Skip(1);
-        assertEqualHr(S_OK, hr);
-
-        hr = pEnumVariant1->Next(1, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        // Skip multiple.
-        hr = pEnumVariant2->Skip(2);
-        assertEqualHr(S_OK, hr);
-
-        hr = pEnumVariant2->Next(1, &var, &celtFetched);
-        assertEqualHr(S_FALSE, hr);
-        assertEqualInt(0, celtFetched);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IOleWindowContextSensitiveHelp(IUnknown* pUnknown, BOOL fEnterMode, HRESULT expectedHr)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IOleWindow> pOleWindow;
-
-        hr = pUnknown->QueryInterface(IID_IOleWindow, (void**)&pOleWindow);
-        assertEqualHr(S_OK, hr);
-
-        hr = pOleWindow->ContextSensitiveHelp(fEnterMode);
-        assertEqualHr(expectedHr, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IOleWindowGetWindow(IUnknown* pUnknown, HWND expected, HRESULT expectedHr)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IOleWindow> pOleWindow;
-
-        hr = pUnknown->QueryInterface(IID_IOleWindow, (void**)&pOleWindow);
-        assertEqualHr(S_OK, hr);
-
-        HWND result = (HWND)(long)0xdeadbeef;
-        hr = pOleWindow->GetWindow(&result);
-        assertEqualHr(expectedHr, hr);
-        assert(expected == result);
-
-        // Negative tests.
-        hr = pOleWindow->GetWindow(NULL);
-        assertEqualHr(E_POINTER, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetChildId(IUnknown* pUnknown, int expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        int result;
-        hr = pLegacyIAccessibleProvider->get_ChildId(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_ChildId(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetDefaultAction(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_DefaultAction(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_DefaultAction(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetDescription(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_Description(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_Description(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetHelp(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_Help(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_Help(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetKeyboardShortcut(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_KeyboardShortcut(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_KeyboardShortcut(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetName(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_Name(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_Name(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetRole(IUnknown* pUnknown, DWORD expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        DWORD result;
-        hr = pLegacyIAccessibleProvider->get_Role(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_Role(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetState(IUnknown* pUnknown, DWORD expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        DWORD result;
-        hr = pLegacyIAccessibleProvider->get_State(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_State(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetValue(IUnknown* pUnknown, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests.
-        hr = pLegacyIAccessibleProvider->get_Value(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderDoDefaultAction(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pLegacyIAccessibleProvider->DoDefaultAction();
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetIAccessible(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IAccessible> result;
-        hr = pLegacyIAccessibleProvider->GetIAccessible(&result);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result.p);
-
-        // Negative tests
-        hr = pLegacyIAccessibleProvider->GetIAccessible(NULL);
-        assertEqualHr(E_POINTER, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderGetSelection(IUnknown* pUnknown, BOOL hasAnything)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-#if false
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pLegacyIAccessibleProvider->GetSelection(&result);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result);
-        assertEqualInt(1, result->cbElements);
-        assertEqualInt(hasAnything, static_cast<IRawElementProviderSimple*>(result->pvData) != NULL);
-        SafeArrayDestroy(result);
-#endif
-
-        // Negative tests
-        hr = pLegacyIAccessibleProvider->GetSelection(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderSelect(IUnknown *pUnknown, long flagsSelect)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        // Negative tests
-        hr = pLegacyIAccessibleProvider->Select(flagsSelect);
-        assertEqualHr(S_OK, hr);
-
-#if false
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pLegacyIAccessibleProvider->GetSelection(&result);
-        assertEqualHr(S_OK, hr);
-        assertNotNull(result);
-        assertEqualInt(1, result->cbElements);
-        assertNull(*static_cast<IRawElementProviderSimple*>(result->pvData));
-        SafeArrayDestroy(result);
-#endif
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ILegacyIAccessibleProviderSetValue(IUnknown* pUnknown, LPCWSTR value, LPCWSTR expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ILegacyIAccessibleProvider> pLegacyIAccessibleProvider;
-
-        hr = pUnknown->QueryInterface(IID_ILegacyIAccessibleProvider, (void**)&pLegacyIAccessibleProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pLegacyIAccessibleProvider->SetValue(value);
-        assertEqualHr(S_OK, hr);
-
-        BSTR result;
-        hr = pLegacyIAccessibleProvider->get_Value(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualWString(expected, result);
-        SysFreeString(result);
-
-        // Negative tests
-        hr = pLegacyIAccessibleProvider->SetValue(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionProviderGetSelection(IUnknown* pUnknown, BOOL hasAnything)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionProvider> pSelectionProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionProvider, (void**)&pSelectionProvider);
-        assertEqualHr(S_OK, hr);
-
-        SAFEARRAY *result = (SAFEARRAY*)(long)0xdeadbeef;
-        hr = pSelectionProvider->GetSelection(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result);
-        SafeArrayDestroy(result);
-
-        // Negative tests
-        hr = pSelectionProvider->GetSelection(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionProviderGetCanSelectMultiple(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionProvider> pRangeSelectionProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionProvider, (void**)&pRangeSelectionProvider);
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pRangeSelectionProvider->get_CanSelectMultiple(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pRangeSelectionProvider->get_CanSelectMultiple(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionProviderGetIsSelectionRequired(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionProvider> pRangeSelectionProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionProvider, (void**)&pRangeSelectionProvider);
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pRangeSelectionProvider->get_IsSelectionRequired(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pRangeSelectionProvider->get_IsSelectionRequired(NULL);
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionItemProviderGetIsSelected(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionItemProvider> pSelectionItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionProvider, (void**)&pSelectionItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        // Fails: The active test run was aborted. Reason: Test host process crashed : Fatal error. Internal CLR error.
-#if false
-        BOOL result;
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(expected, result);
-
-        // Negative tests.
-        hr = pSelectionItemProvider->get_IsSelected(NULL);
-        assertEqualHr(S_OK, hr);
-#endif
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionItemProviderGetSelectionContainer(IUnknown* pUnknown, BOOL expected)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionItemProvider> pSelectionItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionProvider, (void**)&pSelectionItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        // Fails: The active test run was aborted. Reason: Test host process crashed : Fatal error. Internal CLR error.
-#if false
-        CComPtr<IRawElementProviderSimple> result;
-        hr = pSelectionItemProvider->get_SelectionContainer(&result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pSelectionItemProvider->get_SelectionContainer(NULL);
-        assertEqualHr(S_OK, hr);
-#endif
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionItemProviderAddToSelection(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionItemProvider> pSelectionItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionItemProvider, (void**)&pSelectionItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->AddToSelection();
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(FALSE, result);
-
-        // Call again.
-        hr = pSelectionItemProvider->AddToSelection();
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(FALSE, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionItemProviderRemoveFromSelection(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionItemProvider> pSelectionItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionItemProvider, (void**)&pSelectionItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->RemoveFromSelection();
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(FALSE, result);
-
-        // Add.
-        hr = pSelectionItemProvider->AddToSelection();
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->RemoveFromSelection();
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(FALSE, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_ISelectionItemProviderSelect(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<ISelectionItemProvider> pSelectionItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_ISelectionItemProvider, (void**)&pSelectionItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pSelectionItemProvider->Select();
-        assertEqualHr(S_OK, hr);
-
-        BOOL result;
-        hr = pSelectionItemProvider->get_IsSelected(&result);
-        assertEqualHr(S_OK, hr);
-        assertEqualInt(FALSE, result);
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IRawElementProviderHwndOverrideGetOverrideProviderForHwnd(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IRawElementProviderHwndOverride> pRawElementProviderHwndOverride;
-
-        // Fails with E_NOINTERFACE.
-        hr = pUnknown->QueryInterface(IID_IRawElementProviderHwndOverride, (void**)&pRawElementProviderHwndOverride);
-#if false
-        assertEqualHr(S_OK, hr);
-
-        CComPtr<IRawElementProviderSimple> result;
-        hr = pRawElementProviderHwndOverride->GetOverrideProviderForHwnd(NULL, &result);
-        assertEqualHr(S_OK, hr);
-        assertNull(result.p);
-
-        // Negative tests.
-        hr = pRawElementProviderHwndOverride->GetOverrideProviderForHwnd(NULL, NULL);
-        assertEqualHr(S_OK, hr);
-#endif
-
-        return S_OK;
-    });
-}
-
-TEST const WCHAR* WINAPI Test_IScrollItemProviderScrollIntoView(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IScrollItemProvider> pScrollItemProvider;
-
-        hr = pUnknown->QueryInterface(IID_IScrollItemProvider, (void**)&pScrollItemProvider);
-        assertEqualHr(S_OK, hr);
-
-        hr = pScrollItemProvider->ScrollIntoView();
-        assertEqualHr(S_OK, hr);
-
-        return S_OK;
-    });
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/App.manifest b/src/System.Windows.Forms/tests/InteropTests/NativeTests/App.manifest
deleted file mode 100644
index 800dce828cf..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/App.manifest
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-    <assemblyIdentity
-        type="win32" 
-        name="System.Windows.Forms.Interop.Tests"
-        version="1.0.0.0" />
-
-    <dependency>
-        <dependentAssembly>
-            <!-- RegFree COM -->
-            <assemblyIdentity
-                type="win32"
-                name="NativeTests.X"
-                version="1.0.0.0"/>
-        </dependentAssembly>
-    </dependency>
-
-</assembly>
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/CMakeLists.txt b/src/System.Windows.Forms/tests/InteropTests/NativeTests/CMakeLists.txt
deleted file mode 100644
index 0b3caf6a27f..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/CMakeLists.txt
+++ /dev/null
@@ -1,51 +0,0 @@
-cmake_minimum_required (VERSION 2.8.12)
-project (NativeTests)
-set(CMAKE_MACOSX_RPATH 1)
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-# Compile IDL file using MIDL
-set(IDL_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/Contract.idl)
-get_filename_component(IDL_NAME ${IDL_SOURCE} NAME_WE)
-
-
-FIND_PROGRAM( MIDL midl.exe )
-set(IDL_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Contract)
-add_custom_command(
-    OUTPUT ${IDL_OUTPUT_DIRECTORY}/${IDL_NAME}_i.c ${IDL_OUTPUT_DIRECTORY}/${IDL_NAME}.h
-    COMMAND ${MIDL} ${MIDL_INCLUDE_DIRECTORIES}
-        /h ${IDL_OUTPUT_DIRECTORY}/${IDL_NAME}.h ${MIDL_DEFINITIONS}
-        /out ${IDL_OUTPUT_DIRECTORY}
-        /tlb $<TARGET_FILE_DIR:${PROJECT_NAME}>/NativeTests.tlb
-        ${IDL_SOURCE}
-    DEPENDS ${IDL_SOURCE}
-    COMMENT "Compiling ${IDL_SOURCE}")
-
-include_directories(${IDL_OUTPUT_DIRECTORY})
-
-# [[! Microsoft.Security.SystemsADM.10086 !]] - SQL required warnings
-add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/W3>) # warning level 3
-add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/WX>) # treat warnings as errors
-add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/we4018>) # 'expression' : signed/unsigned mismatch
-add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/we4055>) # 'conversion' : from data pointer 'type1' to function pointer 'type2'
-
-
-add_library(NativeTests SHARED
-    AccessibleObjectTests.cpp
-    DllGetClassObject.cpp
-    DispatchImpl.cpp
-    RawErrorInfoUsageTest.cpp
-    RichTextBoxTests.cpp
-    StandardErrorInfoUsageTest.cpp
-    WebBrowserSiteBaseInteropTests.cpp
-
-    Exports.def
-    ${IDL_OUTPUT_DIRECTORY}/${IDL_NAME}_i.c
-)
-file(GENERATE OUTPUT $<TARGET_FILE_DIR:${PROJECT_NAME}>/NativeTests.X.manifest INPUT ${CMAKE_CURRENT_SOURCE_DIR}/NativeTests.X.manifest)
-file(GENERATE OUTPUT $<TARGET_FILE_DIR:${PROJECT_NAME}>/App.manifest INPUT ${CMAKE_CURRENT_SOURCE_DIR}/App.manifest)
-
-install(TARGETS NativeTests)
-install(FILES $<TARGET_FILE_DIR:${PROJECT_NAME}>/NativeTests.tlb TYPE BIN)
-install(FILES $<TARGET_FILE_DIR:${PROJECT_NAME}>/NativeTests.X.manifest TYPE BIN)
-install(FILES $<TARGET_FILE_DIR:${PROJECT_NAME}>/App.manifest TYPE BIN)
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/ComHelpers.h b/src/System.Windows.Forms/tests/InteropTests/NativeTests/ComHelpers.h
deleted file mode 100644
index 93ae4a3a09f..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/ComHelpers.h
+++ /dev/null
@@ -1,411 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-#include <Windows.h>
-#include <comdef.h>
-#include <cassert>
-#include <exception>
-#include <type_traits>
-#include <atomic>
-
-// Common macro for working in COM
-#define RETURN_IF_FAILED(exp) { hr = exp; if (FAILED(hr)) { return hr; } }
-
-namespace Internal
-{
-    template<typename I>
-    HRESULT __QueryInterfaceImpl(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject,
-        /* [in] */ I obj)
-    {
-        if (riid == __uuidof(I))
-        {
-            *ppvObject = static_cast<I>(obj);
-        }
-        else
-        {
-            *ppvObject = nullptr;
-            return E_NOINTERFACE;
-        }
-
-        return S_OK;
-    }
-
-    template<typename I1, typename ...IR>
-    HRESULT __QueryInterfaceImpl(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject,
-        /* [in] */ I1 i1,
-        /* [in] */ IR... remain)
-    {
-        if (riid == __uuidof(I1))
-        {
-            *ppvObject = static_cast<I1>(i1);
-            return S_OK;
-        }
-
-        return __QueryInterfaceImpl(riid, ppvObject, remain...);
-    }
-}
-
-// Implementation of IUnknown operations
-class UnknownImpl
-{
-public:
-    UnknownImpl() = default;
-    virtual ~UnknownImpl() = default;
-
-    UnknownImpl(const UnknownImpl&) = delete;
-    UnknownImpl& operator=(const UnknownImpl&) = delete;
-
-    UnknownImpl(UnknownImpl&&) = default;
-    UnknownImpl& operator=(UnknownImpl&&) = default;
-
-    template<typename I1, typename ...IR>
-    HRESULT DoQueryInterface(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void **ppvObject,
-        /* [in] */ I1 i1,
-        /* [in] */ IR... remain)
-    {
-        if (ppvObject == nullptr)
-            return E_POINTER;
-
-        if (riid == __uuidof(IUnknown))
-        {
-            *ppvObject = static_cast<IUnknown *>(i1);
-        }
-        else
-        {
-            HRESULT hr = Internal::__QueryInterfaceImpl(riid, ppvObject, i1, remain...);
-            if (hr != S_OK)
-                return hr;
-        }
-
-        DoAddRef();
-        return S_OK;
-    }
-
-    ULONG DoAddRef()
-    {
-        assert(_refCount > 0);
-        return (++_refCount);
-    }
-
-    ULONG DoRelease()
-    {
-        assert(_refCount > 0);
-        ULONG c = (--_refCount);
-        if (c == 0)
-            delete this;
-        return c;
-    }
-
-protected:
-    ULONG GetRefCount()
-    {
-        return _refCount;
-    }
-
-private:
-    std::atomic<ULONG> _refCount = 1;
-};
-
-// Macro to use for defining ref counting impls
-#define DEFINE_REF_COUNTING() \
-    STDMETHOD_(ULONG, AddRef)(void) { return UnknownImpl::DoAddRef(); } \
-    STDMETHOD_(ULONG, Release)(void) { return UnknownImpl::DoRelease(); }
-
-// Templated class factory
-template<typename T>
-class ClassFactoryBasic : public UnknownImpl, public IClassFactory
-{
-public: // static
-    static HRESULT Create(_In_ REFIID riid, _Outptr_ LPVOID FAR* ppv)
-    {
-        try
-        {
-            auto cf = new ClassFactoryBasic();
-            HRESULT hr = cf->QueryInterface(riid, ppv);
-            cf->Release();
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-public: // IClassFactory
-    STDMETHOD(CreateInstance)(
-        _In_opt_  IUnknown *pUnkOuter,
-        _In_  REFIID riid,
-        _COM_Outptr_  void **ppvObject)
-    {
-        if (pUnkOuter != nullptr)
-            return CLASS_E_NOAGGREGATION;
-
-        try
-        {
-            auto ti = new T();
-            HRESULT hr = ti->QueryInterface(riid, ppvObject);
-            ti->Release();
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-    STDMETHOD(LockServer)(/* [in] */ BOOL fLock)
-    {
-        assert(false && "Not impl");
-        return E_NOTIMPL;
-    }
-
-public: // IUnknown
-    STDMETHOD(QueryInterface)(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
-    {
-        return DoQueryInterface(riid, ppvObject, static_cast<IClassFactory *>(this));
-    }
-
-    DEFINE_REF_COUNTING();
-};
-
-// Templated class factory for aggregation
-template<typename T>
-class ClassFactoryAggregate : public UnknownImpl, public IClassFactory
-{
-public: // static
-    static HRESULT Create(_In_ REFIID riid, _Outptr_ LPVOID FAR* ppv)
-    {
-        try
-        {
-            auto cf = new ClassFactoryAggregate();
-            HRESULT hr = cf->QueryInterface(riid, ppv);
-            cf->Release();
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-public: // IClassFactory
-    STDMETHOD(CreateInstance)(
-        _In_opt_  IUnknown *pUnkOuter,
-        _In_  REFIID riid,
-        _COM_Outptr_  void **ppvObject)
-    {
-        if (pUnkOuter != nullptr && riid != IID_IUnknown)
-            return CLASS_E_NOAGGREGATION;
-
-        try
-        {
-            auto ti = new T(pUnkOuter);
-            HRESULT hr = ti->QueryInterface(riid, ppvObject);
-            ti->Release();
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-    STDMETHOD(LockServer)(/* [in] */ BOOL fLock)
-    {
-        assert(false && "Not impl");
-        return E_NOTIMPL;
-    }
-
-public: // IUnknown
-    STDMETHOD(QueryInterface)(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
-    {
-        return DoQueryInterface(riid, ppvObject, static_cast<IClassFactory *>(this));
-    }
-
-    DEFINE_REF_COUNTING();
-};
-
-// Templated class factory
-// Supplied type must have the following properties to use this template:
-//  1) Have a static method with the following signature:
-//    - HRESULT RequestLicKey(BSTR *key);
-//  2) Have a constructor that takes an optional BSTR value as the key
-template<typename T>
-class ClassFactoryLicense : public UnknownImpl, public IClassFactory2
-{
-public: // static
-    static HRESULT Create(_In_ REFIID riid, _Outptr_ LPVOID FAR* ppv)
-    {
-        try
-        {
-            auto cf = new ClassFactoryLicense();
-            HRESULT hr = cf->QueryInterface(riid, ppv);
-            cf->Release();
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-public: // IClassFactory
-    STDMETHOD(CreateInstance)(
-        _In_opt_  IUnknown *pUnkOuter,
-        _In_  REFIID riid,
-        _COM_Outptr_  void **ppvObject)
-    {
-        return CreateInstanceLic(pUnkOuter, nullptr, riid, nullptr, ppvObject);
-    }
-
-    STDMETHOD(LockServer)(/* [in] */ BOOL fLock)
-    {
-        assert(false && "Not impl");
-        return E_NOTIMPL;
-    }
-
-public: // IClassFactory2
-    STDMETHOD(GetLicInfo)(
-        /* [out][in] */ __RPC__inout LICINFO *pLicInfo)
-    {
-        // The CLR does not call this function and as such,
-        // returns an error. Note that this is explicitly illegal
-        // in a proper implementation of IClassFactory2.
-        return E_UNEXPECTED;
-    }
-
-    STDMETHOD(RequestLicKey)(
-        /* [in] */ DWORD dwReserved,
-        /* [out] */ __RPC__deref_out_opt BSTR *pBstrKey)
-    {
-        if (dwReserved != 0)
-            return E_UNEXPECTED;
-
-        return T::RequestLicKey(pBstrKey);
-    }
-
-    STDMETHOD(CreateInstanceLic)(
-        /* [annotation][in] */ _In_opt_  IUnknown *pUnkOuter,
-        /* [annotation][in] */ _Reserved_  IUnknown *pUnkReserved,
-        /* [annotation][in] */ __RPC__in  REFIID riid,
-        /* [annotation][in] */ __RPC__in  BSTR bstrKey,
-        /* [annotation][iid_is][out] */ __RPC__deref_out_opt  PVOID *ppvObj)
-    {
-        if (pUnkOuter != nullptr)
-            return CLASS_E_NOAGGREGATION;
-
-        if (pUnkReserved != nullptr)
-            return E_UNEXPECTED;
-
-        try
-        {
-            auto ti = new T(bstrKey);
-            HRESULT hr = ti->QueryInterface(riid, ppvObj);
-            ti->Release();
-            return hr;
-        }
-        catch (HRESULT hr)
-        {
-            return hr;
-        }
-        catch (const std::bad_alloc&)
-        {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-public: // IUnknown
-    STDMETHOD(QueryInterface)(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
-    {
-        return DoQueryInterface(riid, ppvObject, static_cast<IClassFactory *>(this), static_cast<IClassFactory2 *>(this));
-    }
-
-    DEFINE_REF_COUNTING();
-};
-
-template<typename T>
-struct ComSmartPtr
-{
-    T* p;
-
-    ComSmartPtr()
-        : p{ nullptr }
-    { }
-
-    ComSmartPtr(_In_ T* t)
-        : p{ t }
-    {
-        if (p != nullptr)
-            (void)p->AddRef();
-    }
-
-    ComSmartPtr(_In_ const ComSmartPtr&) = delete;
-
-    ComSmartPtr(_Inout_ ComSmartPtr&& other)
-        : p{ other.Detach() }
-    { }
-
-    ~ComSmartPtr()
-    {
-        Release();
-    }
-
-    ComSmartPtr& operator=(_In_ const ComSmartPtr&) = delete;
-
-    ComSmartPtr& operator=(_Inout_ ComSmartPtr&& other)
-    {
-        Attach(other.Detach());
-        return (*this);
-    }
-
-    operator T*()
-    {
-        return p;
-    }
-
-    T** operator&()
-    {
-        return &p;
-    }
-
-    T* operator->()
-    {
-        return p;
-    }
-
-    void Attach(_In_opt_ T* t) noexcept
-    {
-        Release();
-        p = t;
-    }
-
-    T* Detach() noexcept
-    {
-        T* tmp = p;
-        p = nullptr;
-        return tmp;
-    }
-
-    void Release() noexcept
-    {
-        if (p != nullptr)
-        {
-            (void)p->Release();
-            p = nullptr;
-        }
-    }
-};
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/Contract.idl b/src/System.Windows.Forms/tests/InteropTests/NativeTests/Contract.idl
deleted file mode 100644
index 168f76d8b13..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/Contract.idl
+++ /dev/null
@@ -1,38 +0,0 @@
-import "oaidl.idl";
-import "ocidl.idl";
-
-[
-    object,
-    uuid(F4611744-02AF-47D4-A10F-9E692368DEFD)
-]
-interface IBasicTest : IDispatch
-{
-    [propget] HRESULT Int_Property([out, retval] int *ret);
-    [propput] HRESULT Int_Property([in] int val);
-};
-
-[
-    uuid(0971AD7E-3D4A-4C44-B0A3-A518AC88DFE1)
-]
-library NativeTests
-{
-    importlib("stdole2.tlb");
-
-    [
-        uuid(0ED8EE0D-22E3-49EA-850C-E69B20D1F296)
-    ]
-    coclass RawErrorInfoUsageTest
-    {
-        [default] interface IBasicTest;
-        interface ISupportErrorInfo;
-    }
-
-    [
-        uuid(EA1FCB3A-277C-4C79-AB85-E2ED3E858201)
-    ]
-    coclass StandardErrorInfoUsageTest
-    {
-        [default] interface IBasicTest;
-        interface ISupportErrorInfo;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.cpp
deleted file mode 100644
index 0e4a167a471..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "DispatchImpl.h"
-
-namespace
-{
-    const wchar_t* s_tlbDefault = L"NativeTests.tlb";
-}
-
-DispatchImpl::DispatchImpl(GUID guid, void *instance, const wchar_t* tlb)
-    : _typeLib{ nullptr }
-    , _typeInfo{ nullptr }
-    , _instance{ instance }
-{
-    const wchar_t* tlbToLoad = tlb == nullptr ? s_tlbDefault : tlb;
-    HRESULT hr = ::LoadTypeLibEx(tlbToLoad, REGKIND::REGKIND_NONE, &_typeLib);
-    if (FAILED(hr))
-        throw hr;
-
-    hr = _typeLib->GetTypeInfoOfGuid(guid, &_typeInfo);
-    if (FAILED(hr))
-        throw hr;
-}
-
-HRESULT DispatchImpl::DoGetTypeInfoCount(UINT* pctinfo)
-{
-    *pctinfo = 1;
-    return S_OK;
-}
-
-HRESULT DispatchImpl::DoGetTypeInfo(UINT iTInfo, ITypeInfo** ppTInfo)
-{
-    if (iTInfo != 0)
-        return DISP_E_BADINDEX;
-
-    assert(_typeInfo != nullptr);
-    return _typeInfo->QueryInterface(__uuidof(*ppTInfo), (void**)ppTInfo);
-}
-
-HRESULT DispatchImpl::DoGetIDsOfNames(LPOLESTR* rgszNames, UINT cNames, DISPID* rgDispId)
-{
-    return _typeInfo->GetIDsOfNames(rgszNames, cNames, rgDispId);
-}
-
-HRESULT DispatchImpl::DoInvoke(DISPID dispIdMember, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
-{
-    return _typeInfo->Invoke(_instance, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.h b/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.h
deleted file mode 100644
index 563e621c284..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DispatchImpl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-#include "ComHelpers.h"
-#include <Windows.h>
-
-// Implementation of IDispatch operations
-class DispatchImpl : public UnknownImpl
-{
-public:
-    DispatchImpl(GUID guid, void *instance, const wchar_t* tlb = nullptr);
-    virtual ~DispatchImpl() = default;
-
-    DispatchImpl(const DispatchImpl&) = delete;
-    DispatchImpl& operator=(const DispatchImpl&) = delete;
-
-    DispatchImpl(DispatchImpl&&) = default;
-    DispatchImpl& operator=(DispatchImpl&&) = default;
-
-protected:
-    HRESULT DoGetTypeInfoCount(UINT* pctinfo);
-    HRESULT DoGetTypeInfo(UINT iTInfo, ITypeInfo** ppTInfo);
-    HRESULT DoGetIDsOfNames(LPOLESTR* rgszNames, UINT cNames, DISPID* rgDispId);
-    HRESULT DoInvoke(DISPID dispIdMember, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr);
-
-private:
-    ComSmartPtr<ITypeLib> _typeLib;
-    ComSmartPtr<ITypeInfo> _typeInfo;
-    void *_instance;
-};
-
-// Macro to use for defining dispatch impls
-#define DEFINE_DISPATCH() \
-    STDMETHOD(GetTypeInfoCount)(UINT *pctinfo) \
-        { return DispatchImpl::DoGetTypeInfoCount(pctinfo); } \
-    STDMETHOD(GetTypeInfo)(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) \
-        { return DispatchImpl::DoGetTypeInfo(iTInfo, ppTInfo); } \
-    STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) \
-        { return DispatchImpl::DoGetIDsOfNames(rgszNames, cNames, rgDispId); } \
-    STDMETHOD(Invoke)(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) \
-        { return DispatchImpl::DoInvoke(dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); }
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DllGetClassObject.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/DllGetClassObject.cpp
deleted file mode 100644
index 6e0a11420e9..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/DllGetClassObject.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "ocidl.h"
-#include <sstream>
-#include "ComHelpers.h"
-#include <Contract.h>
-
-#include "RawErrorInfoUsageTest.h"
-#include "StandardErrorInfoUsageTest.h"
-
-STDAPI DllGetClassObject(_In_ REFCLSID rclsid, _In_ REFIID riid, _Out_ LPVOID FAR* ppv)
-{
-    if (rclsid == __uuidof(RawErrorInfoUsageTest))
-        return ClassFactoryBasic<RawErrorInfoUsageTest>::Create(riid, ppv);
-
-    if (rclsid == __uuidof(StandardErrorInfoUsageTest))
-        return ClassFactoryBasic<StandardErrorInfoUsageTest>::Create(riid, ppv);
-
-    return CLASS_E_CLASSNOTAVAILABLE;
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/Exports.def b/src/System.Windows.Forms/tests/InteropTests/NativeTests/Exports.def
deleted file mode 100644
index 2e9253049fd..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/Exports.def
+++ /dev/null
@@ -1,2 +0,0 @@
-EXPORTS
-    DllGetClassObject   PRIVATE
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.X.manifest b/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.X.manifest
deleted file mode 100644
index 5fdd87552cb..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.X.manifest
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-
-<assemblyIdentity
-    type="win32"
-    name="NativeTests.X"
-    version="1.0.0.0" />
-
-<file name="NativeTests.dll">
-    <!-- RawErrorInfoUsageTest -->
-    <comClass
-        clsid="{0ED8EE0D-22E3-49EA-850C-E69B20D1F296}"
-        threadingModel="Both" />
-    <!-- StandardErrorInfoUsageTest Test -->
-    <comClass
-        clsid="{EA1FCB3A-277C-4C79-AB85-E2ED3E858201}"
-        threadingModel="Both" />
-</file>
-
-</assembly>
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.proj b/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.proj
deleted file mode 100644
index bf0fd4ce020..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/NativeTests.proj
+++ /dev/null
@@ -1,11 +0,0 @@
-<Project Sdk="Microsoft.DotNet.CMake.Sdk">
-  <PropertyGroup>
-    <CMakeCompilerSearchScript>call &quot;$(RepoRoot)eng\init-vs-env.cmd&quot; $(TargetArchitecture)</CMakeCompilerSearchScript>
-    <CMakeLists>CMakeLists.txt</CMakeLists>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <CMakeArguments Include=" --log-level=WARNING" />
-    <CMakeNativeToolArguments Include=" -verbosity:quiet /p:PlatformToolset=%__PlatformToolset% " />
-  </ItemGroup>
-</Project>
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/README.md b/src/System.Windows.Forms/tests/InteropTests/NativeTests/README.md
deleted file mode 100644
index 631085a9090..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-Supplementary native parts for WinForms Interop tests
-==================================================
-
-This project is native DLL which provide unmanaged parts required for testing WinForms components. Most interesting part of the tests would be COM objects which given to controls.
-This project builds as a native DLL, which can be used as a reg-free COM host. That allow running tests without worrying about "polluting" developer/build machines.
-
-Preferably each test case should have their separate COM objects. 
-
-Manifests used in the application:
-
-- `App.manifest` This file used during running test to provide information about this DLL. Developers do not need to modify that file, just run it inside activation context.
-- `NativeTests.X.manifest` This is manifest where all reg-free COM objects registered.
-
-## How to add new COM object
-
-1. Declare COM object in `Contract.idl` file 
-2. Implement COM object in C++.
-3. Add CoClass defined in `Contract.idl` inside `NativeTests.X.manifest`
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.cpp
deleted file mode 100644
index c0e48822396..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "RawErrorInfoUsageTest.h"
-#include <cmath>
-
-HRESULT STDMETHODCALLTYPE RawErrorInfoUsageTest::get_Int_Property(
-    /* [retval][out] */ int *ret)
-{
-    *ret = _int;
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE RawErrorInfoUsageTest::put_Int_Property(
-    /* [in] */ int val)
-{
-    return DISP_E_MEMBERNOTFOUND;
-}
-
-HRESULT STDMETHODCALLTYPE RawErrorInfoUsageTest::InterfaceSupportsErrorInfo(
-    /* [in] */ __RPC__in REFIID riid)
-{
-    // This is hack, in order to not implement IDispatch.
-    // By default implementations wrap any error during invoke into DISP_E_EXCEPTION
-    // and consume IErrorInfo. Some implementation behave differently, so this is emulation
-    // of that behaviour.
-    ComSmartPtr<ICreateErrorInfo> cei;
-    if (SUCCEEDED(::CreateErrorInfo(&cei)))
-    {
-        if (SUCCEEDED(cei->SetGUID(IID_IBasicTest)))
-        {
-            if (SUCCEEDED(cei->SetDescription(L"Error From RawErrorInfoUsageTest")))
-            {
-                ComSmartPtr<IErrorInfo> errorInfo;
-                if (SUCCEEDED(cei->QueryInterface(IID_IErrorInfo, (void**)&errorInfo)))
-                {
-                    ::SetErrorInfo(0, errorInfo);
-                }
-            }
-        }
-    }
-
-    return S_OK;
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.h b/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.h
deleted file mode 100644
index 0cc1aa5924e..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RawErrorInfoUsageTest.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-#include "ComHelpers.h"
-#include <Contract.h>
-#include "DispatchImpl.h"
-#include <vector>
-
-class RawErrorInfoUsageTest : public DispatchImpl, public IBasicTest, public ISupportErrorInfo
-{
-public:
-    RawErrorInfoUsageTest()
-        : DispatchImpl(IID_IBasicTest, static_cast<IBasicTest*>(this))
-    {
-    }
-
-public: // IBasicTest
-    
-    virtual HRESULT STDMETHODCALLTYPE get_Int_Property( 
-        /* [retval][out] */ int *ret);
-    
-    virtual HRESULT STDMETHODCALLTYPE put_Int_Property( 
-        /* [in] */ int val);
-
-public: // ISupportErrorInfo
-    virtual HRESULT STDMETHODCALLTYPE InterfaceSupportsErrorInfo(
-        /* [in] */ __RPC__in REFIID riid);
-
-public: // IDispatch
-    DEFINE_DISPATCH();
-    
-public: // IUnknown
-    STDMETHOD(QueryInterface)(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
-    {
-        return DoQueryInterface(riid, ppvObject,
-            static_cast<IDispatch *>(this),
-            static_cast<IBasicTest *>(this),
-            static_cast<ISupportErrorInfo *>(this));
-    }
-
-    DEFINE_REF_COUNTING();
-
-private:
-    int _int;
-};
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RichTextBoxTests.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/RichTextBoxTests.cpp
deleted file mode 100644
index 91fe1f5cd26..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/RichTextBoxTests.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "testhelpers.h"
-#include <cassert>
-#include <richedit.h>
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_EnLink(ENLINK* value)
-{
-    value->nmhdr.code = 132;
-    value->nmhdr.hwndFrom = (HWND)765;
-    value->nmhdr.idFrom = 432;
-    value->msg = 22;
-    value->wParam = 6578;
-    value->lParam = 54425;
-    value->chrg.cpMin = 109;
-    value->chrg.cpMax = 1577;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_EnProtected(ENPROTECTED* value)
-{
-    value->nmhdr.code = 132;
-    value->nmhdr.hwndFrom = (HWND)765;
-    value->nmhdr.idFrom = 432;
-    value->msg = 22;
-    value->wParam = 6578;
-    value->lParam = 54425;
-    value->chrg.cpMin = 109;
-    value->chrg.cpMax = 1577;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_EnDropFiles(ENDROPFILES* value)
-{
-    value->nmhdr.code = 132;
-    value->nmhdr.hwndFrom = (HWND)765;
-    value->nmhdr.idFrom = 432;
-    value->hDrop = (HANDLE)22;
-    value->cp = 6578;
-    value->fProtected = TRUE;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_CharRange(CHARRANGE* value)
-{
-    value->cpMin = 109;
-    value->cpMax = 1577;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_EditStream(EDITSTREAM* value)
-{
-    value->dwCookie = 109;
-    value->dwError = 1577;
-    value->pfnCallback = (EDITSTREAMCALLBACK)6578;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_FindTextW(FINDTEXTW* value)
-{
-    value->lpstrText = L"Fine Text";
-    value->chrg.cpMin = 109;
-    value->chrg.cpMax = 1577;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_GetTextEx(GETTEXTEX* value)
-{
-    value->cb = 132;
-    value->flags = GT_RAWTEXT;
-    value->codepage = 432;
-    value->lpDefaultChar = (LPCSTR)22;
-    value->lpUsedDefChar = (LPBOOL)6578;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_GetTextLengthEx(GETTEXTLENGTHEX* value)
-{
-    value->flags = GTL_NUMBYTES;
-    value->codepage = 432;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_ParaFormat(PARAFORMAT* value)
-{
-    value->cbSize = 132;
-    value->dwMask = PFM_ALIGNMENT;
-    value->wNumbering = PFN_UCROMAN;
-    value->wReserved = 6578;
-    value->dxStartIndent = 109;
-    value->dxRightIndent = 432;
-    value->dxOffset = 54425;
-    value->wAlignment = PFA_JUSTIFY;
-    value->cTabCount = 6565;
-    value->rgxTabs[0] = 8989;
-    value->rgxTabs[31] = 812;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_ReqResize(REQRESIZE* value)
-{
-    value->nmhdr.code = 132;
-    value->nmhdr.hwndFrom = (HWND)765;
-    value->nmhdr.idFrom = 432;
-    value->rc.left = 6578;
-    value->rc.right = 109;
-    value->rc.top = 54425;
-    value->rc.bottom = 8989;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_SelChange(SELCHANGE* value)
-{
-    value->nmhdr.code = 132;
-    value->nmhdr.hwndFrom = (HWND)765;
-    value->nmhdr.idFrom = 432;
-    value->seltyp = SEL_MULTICHAR;
-    value->chrg.cpMin = 109;
-    value->chrg.cpMax = 1577;
-}
-
-extern "C" __declspec(dllexport) void WINAPI RichTextBox_TextRange(TEXTRANGE* value)
-{
-    value->lpstrText = "Fine Text";
-    value->chrg.cpMin = 109;
-    value->chrg.cpMax = 1577;
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.cpp
deleted file mode 100644
index 9609f93ab7d..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "StandardErrorInfoUsageTest.h"
-#include <cmath>
-
-HRESULT STDMETHODCALLTYPE StandardErrorInfoUsageTest::get_Int_Property(
-    /* [retval][out] */ int *ret)
-{
-    *ret = _int;
-    return S_OK;
-}
-
-HRESULT STDMETHODCALLTYPE StandardErrorInfoUsageTest::put_Int_Property(
-    /* [in] */ int val)
-{
-    ComSmartPtr<ICreateErrorInfo> cei;
-    if (SUCCEEDED(::CreateErrorInfo(&cei)))
-    {
-        if (SUCCEEDED(cei->SetGUID(IID_IBasicTest)))
-        {
-            if (SUCCEEDED(cei->SetDescription(L"Error From StandardErrorInfoUsageTest")))
-            {
-                ComSmartPtr<IErrorInfo> errorInfo;
-                if (SUCCEEDED(cei->QueryInterface(IID_IErrorInfo, (void**)&errorInfo)))
-                {
-                    ::SetErrorInfo(0, errorInfo);
-                }
-            }
-        }
-    }
-
-    return DISP_E_MEMBERNOTFOUND;
-}
-
-HRESULT STDMETHODCALLTYPE StandardErrorInfoUsageTest::InterfaceSupportsErrorInfo(
-    /* [in] */ __RPC__in REFIID riid)
-{
-    return S_OK;
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.h b/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.h
deleted file mode 100644
index 3418d3ee36b..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/StandardErrorInfoUsageTest.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-#include "ComHelpers.h"
-#include <Contract.h>
-#include "DispatchImpl.h"
-#include <vector>
-
-class StandardErrorInfoUsageTest : public DispatchImpl, public IBasicTest, public ISupportErrorInfo
-{
-public:
-    StandardErrorInfoUsageTest()
-        : DispatchImpl(IID_IBasicTest, static_cast<IBasicTest*>(this))
-    {
-    }
-
-public: // IBasicTest
-    
-    virtual HRESULT STDMETHODCALLTYPE get_Int_Property( 
-        /* [retval][out] */ int *ret);
-    
-    virtual HRESULT STDMETHODCALLTYPE put_Int_Property( 
-        /* [in] */ int val);
-
-public: // ISupportErrorInfo
-    virtual HRESULT STDMETHODCALLTYPE InterfaceSupportsErrorInfo(
-        /* [in] */ __RPC__in REFIID riid);
-
-public: // IDispatch
-    DEFINE_DISPATCH();
-    
-public: // IUnknown
-    STDMETHOD(QueryInterface)(
-        /* [in] */ REFIID riid,
-        /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
-    {
-        return DoQueryInterface(riid, ppvObject,
-            static_cast<IDispatch *>(this),
-            static_cast<IBasicTest *>(this),
-            static_cast<ISupportErrorInfo *>(this));
-    }
-
-    DEFINE_REF_COUNTING();
-
-private:
-    int _int;
-};
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/WebBrowserSiteBaseInteropTests.cpp b/src/System.Windows.Forms/tests/InteropTests/NativeTests/WebBrowserSiteBaseInteropTests.cpp
deleted file mode 100644
index 5583a5d3b26..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/WebBrowserSiteBaseInteropTests.cpp
+++ /dev/null
@@ -1,634 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#include "ocidl.h"
-#include "testhelpers.h"
-#include <sstream>
-#include <atlbase.h>
-using namespace ATL;
-
-static HRESULT Test_IOleControlSite_OnControlInfoChanged(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pControlSite->OnControlInfoChanged();
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_LockInPlaceActive(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    // Negative tests.
-    hr = pControlSite->LockInPlaceActive(TRUE);
-    assertEqualHr(E_NOTIMPL, hr);
-
-    hr = pControlSite->LockInPlaceActive(TRUE);
-    assertEqualHr(E_NOTIMPL, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_GetExtendedControl(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    IDispatch* pDisp;
-
-    pDisp = (IDispatch*)(long)0xdeadbeef;
-    hr = pControlSite->GetExtendedControl(&pDisp);
-    assertEqualHr(E_NOTIMPL, hr);
-    assertNull(pDisp);
-
-    // Negative tests.
-    hr = pControlSite->GetExtendedControl(NULL);
-    assertEqualHr(E_POINTER, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_TransformCoords(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    POINTL ptlHimetric;
-    POINTF ptfContainer;
-
-    // HIMETRICTOCONTAINER, SIZE
-    ptlHimetric.x = 1000;
-    ptlHimetric.y = 2000;
-    ptfContainer.x = 0;
-    ptfContainer.y = 0;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_SIZE);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(1000, ptlHimetric.x);
-    assertEqualInt(2000, ptlHimetric.y);
-    assertEqualFloat(38, ptfContainer.x);
-    assertEqualFloat(76, ptfContainer.y);
-
-    ptlHimetric.x = 0;
-    ptlHimetric.y = 0;
-    ptfContainer.x = -1;
-    ptfContainer.y = -2;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_SIZE);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(0, ptlHimetric.x);
-    assertEqualInt(0, ptlHimetric.y);
-    assertEqualFloat(0, ptfContainer.x);
-    assertEqualFloat(0, ptfContainer.y);
-
-    // HIMETRICTOCONTAINER, POSITION
-    ptlHimetric.x = 1000;
-    ptlHimetric.y = 2000;
-    ptfContainer.x = 0;
-    ptfContainer.y = 0;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_POSITION);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(1000, ptlHimetric.x);
-    assertEqualInt(2000, ptlHimetric.y);
-    assertEqualFloat(38, ptfContainer.x);
-    assertEqualFloat(76, ptfContainer.y);
-
-    ptlHimetric.x = 0;
-    ptlHimetric.y = 0;
-    ptfContainer.x = 1;
-    ptfContainer.y = 2;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_POSITION);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(0, ptlHimetric.x);
-    assertEqualInt(0, ptlHimetric.y);
-    assertEqualFloat(0, ptfContainer.x);
-    assertEqualFloat(0, ptfContainer.y);
-
-    // CONTAINERTOHIMETRIC, SIZE
-    ptlHimetric.x = 0;
-    ptlHimetric.y = 0;
-    ptfContainer.x = 38;
-    ptfContainer.y = 76;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_CONTAINERTOHIMETRIC | XFORMCOORDS_SIZE);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(1005, ptlHimetric.x);
-    assertEqualInt(2011, ptlHimetric.y);
-    assertEqualFloat(38, ptfContainer.x);
-    assertEqualFloat(76, ptfContainer.y);
-
-    ptlHimetric.x = 1;
-    ptlHimetric.y = 2;
-    ptfContainer.x = 0;
-    ptfContainer.y = 0;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_CONTAINERTOHIMETRIC | XFORMCOORDS_SIZE);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(0, ptlHimetric.x);
-    assertEqualInt(0, ptlHimetric.y);
-    assertEqualFloat(0, ptfContainer.x);
-    assertEqualFloat(0, ptfContainer.y);
-
-    // CONTAINERTOHIMETRIC, POSITION
-    ptlHimetric.x = 0;
-    ptlHimetric.y = 0;
-    ptfContainer.x = 38;
-    ptfContainer.y = 76;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_CONTAINERTOHIMETRIC | XFORMCOORDS_POSITION);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(1005, ptlHimetric.x);
-    assertEqualInt(2011, ptlHimetric.y);
-    assertEqualFloat(38, ptfContainer.x);
-    assertEqualFloat(76, ptfContainer.y);
-
-    ptlHimetric.x = 1;
-    ptlHimetric.y = 2;
-    ptfContainer.x = 0;
-    ptfContainer.y = 0;
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_CONTAINERTOHIMETRIC | XFORMCOORDS_POSITION);
-    assertEqualHr(S_OK, hr);
-    assertEqualInt(0, ptlHimetric.x);
-    assertEqualInt(0, ptlHimetric.y);
-    assertEqualFloat(0, ptfContainer.x);
-    assertEqualFloat(0, ptfContainer.y);
-
-    // Negative tests.
-    hr = pControlSite->TransformCoords(NULL, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_SIZE);
-    assertEqualHr(E_POINTER, hr);
-
-    hr = pControlSite->TransformCoords(&ptlHimetric, NULL, XFORMCOORDS_HIMETRICTOCONTAINER | XFORMCOORDS_SIZE);
-    assertEqualHr(E_POINTER, hr);
-
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_HIMETRICTOCONTAINER);
-    assertEqualHr(E_INVALIDARG, hr);
-
-    hr = pControlSite->TransformCoords(&ptlHimetric, &ptfContainer, XFORMCOORDS_CONTAINERTOHIMETRIC);
-    assertEqualHr(E_INVALIDARG, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_TranslateAccelerator(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    MSG msg = { 0 };
-
-    hr = pControlSite->TranslateAccelerator(&msg, 0);
-    assertEqualHr(S_FALSE, hr);
-
-    // Negative tests.
-    hr = pControlSite->TranslateAccelerator(NULL, 0);
-    assertEqualHr(E_POINTER, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_OnFocus(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pControlSite->OnFocus(TRUE);
-    assertEqualHr(S_OK, hr);
-
-    hr = pControlSite->OnFocus(TRUE);
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite_ShowPropertyFrame(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    // Negative tests.
-    hr = pControlSite->ShowPropertyFrame();
-    assertEqualHr(E_NOTIMPL, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleControlSite(IOleControlSite* pControlSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = Test_IOleControlSite_OnControlInfoChanged(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_GetExtendedControl(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_LockInPlaceActive(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_TransformCoords(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_TranslateAccelerator(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_OnFocus(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleControlSite_ShowPropertyFrame(pControlSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    return S_OK;
-}
-
-static HRESULT Test_ISimpleFrameSite_PreMessageFilter(ISimpleFrameSite* pSimpleFrameSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pSimpleFrameSite->PreMessageFilter(NULL, 0, NULL, NULL, NULL, NULL);
-    assertEqualHr(S_OK, hr);
-
-    hr = pSimpleFrameSite->PreMessageFilter((HWND)1, 1, (WPARAM)1, (LPARAM)1, (LRESULT*)1, (DWORD*)1);
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_ISimpleFrameSite_PostMessageFilter(ISimpleFrameSite* pSimpleFrameSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pSimpleFrameSite->PostMessageFilter(NULL, 0, NULL, NULL, NULL, 0);
-    assertEqualHr(S_FALSE, hr);
-
-    hr = pSimpleFrameSite->PostMessageFilter((HWND)1, 1, (WPARAM)1, (LPARAM)1, (LRESULT*)1, 1);
-    assertEqualHr(S_FALSE, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_ISimpleFrameSite(ISimpleFrameSite* pSimpleFrameSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = Test_ISimpleFrameSite_PreMessageFilter(pSimpleFrameSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_ISimpleFrameSite_PostMessageFilter(pSimpleFrameSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_SaveObject(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    // Negative tests.
-    hr = pClientSite->SaveObject();
-    assertEqualHr(E_NOTIMPL, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_GetMoniker(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    IMoniker* pmk;
-
-    // Negative tests.
-    pmk = (IMoniker*)(long)0xdeadbeef;
-    hr = pClientSite->GetMoniker(0, 0, &pmk);
-    assertEqualHr(E_NOTIMPL, hr);
-    assertNull(pmk);
-
-    hr = pClientSite->GetMoniker(0, 0, NULL);
-    assertEqualHr(E_POINTER, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_GetContainer(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    IOleContainer* pContainer;
-
-    pContainer = (IOleContainer*)(long)0xdeadbeef;
-    hr = pClientSite->GetContainer(&pContainer);
-    assertEqualHr(S_OK, hr);
-    assertNotNull(pContainer);
-
-#if false
-    // Negative tests.
-    hr = pClientSite->GetContainer(NULL);
-    assertEqualHr(E_POINTER, hr);
-#endif
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_ShowObject(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pClientSite->ShowObject();
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_OnShowWindow(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pClientSite->OnShowWindow(TRUE);
-    assertEqualHr(S_OK, hr);
-
-    hr = pClientSite->OnShowWindow(FALSE);
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite_RequestNewObjectLayout(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    // Negative tests.
-    hr = pClientSite->RequestNewObjectLayout();
-    assertEqualHr(E_NOTIMPL, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleClientSite(IOleClientSite* pClientSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = Test_IOleClientSite_SaveObject(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleClientSite_GetMoniker(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleClientSite_GetContainer(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleClientSite_ShowObject(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleClientSite_OnShowWindow(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleClientSite_RequestNewObjectLayout(pClientSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_GetWindow(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    HWND hwnd;
-
-    hwnd = NULL;
-    hr = pInPlaceSite->GetWindow(&hwnd);
-    assertEqualHr(S_OK, hr);
-    assertNotNull(hwnd);
-
-    // Negative tests.
-    hr = pInPlaceSite->GetWindow(NULL);
-    assertEqualHr(E_POINTER, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_ContextSensitiveHelp(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    // Negative tests.
-    hr = pInPlaceSite->ContextSensitiveHelp(TRUE);
-    assertEqualHr(E_NOTIMPL, hr);
-
-    hr = pInPlaceSite->ContextSensitiveHelp(FALSE);
-    assertEqualHr(E_NOTIMPL, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_CanInPlaceActivate(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pInPlaceSite->CanInPlaceActivate();
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_OnInPlaceActivate(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pInPlaceSite->OnInPlaceActivate();
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_OnUIActivate(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = pInPlaceSite->OnUIActivate();
-    assertEqualHr(S_OK, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite_GetWindowContext(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-    IOleInPlaceFrame* pFrame;
-    IOleInPlaceUIWindow* pDoc;
-    RECT posRect;
-    RECT clipRect;
-    OLEINPLACEFRAMEINFO frameInfo;
-
-    pFrame = NULL;
-    pDoc = NULL;
-    posRect = { 0 };
-    clipRect = { 0 };
-    frameInfo = { 0 };
-    hr = pInPlaceSite->GetWindowContext(&pFrame, &pDoc, &posRect, &clipRect, NULL);
-    assertEqualHr(S_OK, hr);
-    assertNotNull(pFrame);
-    assertNull(pDoc);
-    assertEqualInt(0, posRect.left);
-    assertEqualInt(0, posRect.top);
-    assertEqualInt(250, posRect.right);
-    assertEqualInt(250, posRect.bottom);
-    assertEqualInt(0, clipRect.left);
-    assertEqualInt(0, clipRect.top);
-    assertEqualInt(32000, clipRect.right);
-    assertEqualInt(32000, clipRect.bottom);
-
-    pFrame = NULL;
-    pDoc = NULL;
-    posRect = { 0 };
-    clipRect = { 0 };
-    frameInfo = { 0 };
-    hr = pInPlaceSite->GetWindowContext(&pFrame, &pDoc, &posRect, &clipRect, &frameInfo);
-    assertEqualHr(S_OK, hr);
-    assertNotNull(pFrame);
-    assertNull(pDoc);
-    assertEqualInt(0, posRect.left);
-    assertEqualInt(0, posRect.top);
-    assertEqualInt(250, posRect.right);
-    assertEqualInt(250, posRect.bottom);
-    assertEqualInt(0, clipRect.left);
-    assertEqualInt(0, clipRect.top);
-    assertEqualInt(32000, clipRect.right);
-    assertEqualInt(32000, clipRect.bottom);
-    assertEqualInt(sizeof(OLEINPLACEFRAMEINFO), frameInfo.cb);
-    assertEqualBool(FALSE, frameInfo.fMDIApp);
-    assertEqualInt(0, frameInfo.cAccelEntries);
-    assertNull(frameInfo.haccel);
-    assertNull(frameInfo.hwndFrame);
-
-    // Negative tests.
-#if false
-    hr = pInPlaceSite->GetWindowContext(NULL, &pDoc, &posRect, &clipRect, &frameInfo);
-    assertEqualHr(E_POINTER, hr);
-
-    hr = pInPlaceSite->GetWindowContext(&pFrame, NULL, &posRect, &clipRect, &frameInfo);
-    assertEqualHr(E_POINTER, hr);
-#endif
-
-    hr = pInPlaceSite->GetWindowContext(&pFrame, &pDoc, NULL, &clipRect, &frameInfo);
-    assertEqualHr(E_POINTER, hr);
-
-    hr = pInPlaceSite->GetWindowContext(&pFrame, &pDoc, &posRect, NULL, &frameInfo);
-    assertEqualHr(E_POINTER, hr);
-
-    return S_OK;
-}
-
-static HRESULT Test_IOleInPlaceSite(IOleInPlaceSite* pInPlaceSite, std::wstringstream& output)
-{
-    HRESULT hr;
-
-    hr = Test_IOleInPlaceSite_GetWindow(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleInPlaceSite_ContextSensitiveHelp(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleInPlaceSite_CanInPlaceActivate(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleInPlaceSite_OnInPlaceActivate(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleInPlaceSite_OnUIActivate(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    hr = Test_IOleInPlaceSite_GetWindowContext(pInPlaceSite, output);
-    if (hr != S_OK)
-    {
-        return hr;
-    }
-
-    return S_OK;
-}
-
-TEST const WCHAR* WINAPI Test_WebBrowserSiteBase(IUnknown* pUnknown)
-{
-    return RunTest([&](std::wstringstream& output)
-    {
-        HRESULT hr;
-        CComPtr<IOleControlSite> pControlSite;
-        CComPtr<ISimpleFrameSite> pSimpleFrameSite;
-        CComPtr<IOleClientSite> pClientSite;
-        CComPtr<IOleInPlaceSite> pInPlaceSite;
-
-        hr = pUnknown->QueryInterface(IID_IOleControlSite, (void**)&pControlSite);
-        hr = Test_IOleControlSite(pControlSite, output);
-        if (hr != S_OK)
-        {
-            return hr;
-        }
-
-        hr = pUnknown->QueryInterface(IID_ISimpleFrameSite, (void**)&pSimpleFrameSite);
-        hr = Test_ISimpleFrameSite(pSimpleFrameSite, output);
-        if (hr != S_OK)
-        {
-            return hr;
-        }
-
-        hr = pUnknown->QueryInterface(IID_IOleClientSite, (void**)&pClientSite);
-        hr = Test_IOleClientSite(pClientSite, output);
-        if (hr != S_OK)
-        {
-            return hr;
-        }
-
-        hr = pUnknown->QueryInterface(IID_IOleInPlaceSite, (void**)&pInPlaceSite);
-        hr = Test_IOleInPlaceSite(pInPlaceSite, output);
-        if (hr != S_OK)
-        {
-            return hr;
-        }
-
-        return S_OK;
-    });
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/NativeTests/testhelpers.h b/src/System.Windows.Forms/tests/InteropTests/NativeTests/testhelpers.h
deleted file mode 100644
index 2d6316aee80..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/NativeTests/testhelpers.h
+++ /dev/null
@@ -1,162 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#pragma once
-
-#include <assert.h>
-#include <stdio.h>
-#include <sstream>
-#include <type_traits>
-#include <Windows.h>
-
-#define TEST extern "C" __declspec(dllexport)
-
-template<typename T, typename = std::enable_if_t<std::is_floating_point<T>::value>>
-static inline bool is_essentially_equal_to(const T& a, const T& b)
-{
-    if (std::isnan(a))
-    {
-        return std::isnan(b);
-    }
-    else if (std::isnan(b))
-    {
-        return false;
-    }
-
-    return std::abs(a - b) <= std::numeric_limits<T>::epsilon() * std::fmin(std::abs(a), std::abs(b));
-}
-
-template< typename... Args >
-std::wstring format(const wchar_t* format, Args... args)
-{
-    int length = std::swprintf(nullptr, 0, format, args...);
-    // If this fails, let the program crash.
-    wchar_t* buf = new wchar_t[length + 1];
-    std::swprintf(buf, length + 1, format, args...);
-
-    std::wstring str(buf);
-    delete[] buf;
-    return str;
-}
-
-static void printAssertionFailure(std::wstringstream& output, const char* file, const char* function, int line = __LINE__)
-{
-    output << format(L"Assertion failure: file %hs in %hs, line %d", file, function, line) << std::endl;
-}
-
-#define printLine() printAssertionFailure(output, __FILE__, __FUNCTION__, __LINE__);
-
-#define assertEqualInt(expected, actual) \
-if ((expected) != (actual)) \
-{ \
-    printLine(); \
-    output << format(L"Expected: %d\n", (int)((expected))); \
-    output << format(L"Actual:   %d\n", (int)((actual))); \
-    return E_FAIL; \
-}
-
-#define assertEqualBool(expected, actual) \
-if ((BOOL)(expected) != (BOOL)(actual)) \
-{ \
-    printLine(); \
-    if ((expected)) \
-    { \
-        output << format(L"Expected: TRUE\n"); \
-        output << format(L"Actual: FALSE\n"); \
-    } \
-    else \
-    { \
-        output << format(L"Expected: FALSE\n"); \
-        output << format(L"Actual: TRUE\n"); \
-    } \
-    return E_FAIL; \
-}
-
-#define assertEqualFloat(expected, actual) \
-if (!is_essentially_equal_to((float)((expected)), (float)((actual)))) \
-{ \
-    printLine(); \
-    output << format(L"Expected: %f\n", (float)((expected))); \
-    output << format(L"Actual:   %f\n", (float)((actual))); \
-    return E_FAIL; \
-}
-
-#define assertEqualDouble(expected, actual) \
-if (!is_essentially_equal_to((double)((expected)), (double)((actual)))) \
-{ \
-    printLine(); \
-    output << format(L"Expected: %f\n", (double)((expected))); \
-    output << format(L"Actual:   %f\n", (double)((actual))); \
-    return E_FAIL; \
-}
-
-#define assertEqualHr(expected, actual) \
-if ((int)((expected)) != (int)((actual))) \
-{ \
-    printLine(); \
-    output << format(L"Expected: 0x%08X\n", (int)((expected))); \
-    output << format(L"Actual:   0x%08X\n", (int)((actual))); \
-    return E_FAIL; \
-}
-
-#define assertEqualWString(expected, actual) \
-if (!(expected)) \
-{ \
-    if ((actual)) \
-    { \
-        output << format(L"Expected: NULL\n"); \
-        output << format(L"Actual:   %s\n", (const wchar_t*)((actual))); \
-        return E_FAIL; \
-    } \
-} \
-else if (!(actual)) \
-{ \
-    output << format(L"Expected:   %s\n", (const wchar_t*)((expected))); \
-    output << format(L"Actual: NULL\n"); \
-    return E_FAIL; \
-} \
-else if (wcscmp((const wchar_t*)(expected), (const wchar_t*)(actual)) != 0) \
-{ \
-    printLine(); \
-    output << format(L"Expected: %s\n", (const wchar_t*)((expected))); \
-    output << format(L"Actual:   %s\n", (const wchar_t*)((actual))); \
-    return E_FAIL; \
-}
-
-#define assertNull(actual) \
-if ((actual)) \
-{ \
-    printLine(); \
-    output << format(L"Actual: %p\n", ((actual))); \
-    return E_FAIL; \
-}
-
-#define assertNotNull(actual) \
-if (!(actual) || (void*)((actual)) == (void*)(long)0xdeadbeef) \
-{ \
-    printLine(); \
-    output << format(L"Actual: %p\n", ((actual))); \
-    return E_FAIL; \
-}
-
-template<typename T>
-static const WCHAR* RunTest(T method)
-{
-    std::wstringstream output;
-    HRESULT hr = method(output);
-
-    if (hr == S_OK)
-    {
-        output << L"Success";
-    }
-    return Duplicate(output.str().c_str());
-}
-
-// Need to allocate this as CoTaskMemAlloc to be interpreted by interop marshallers.
-static const WCHAR* Duplicate(const WCHAR* source)
-{
-    size_t length = wcslen(source) + 1;
-    WCHAR* clone = (WCHAR*)CoTaskMemAlloc(length * sizeof(WCHAR));
-    wcscpy_s(clone, length, source);
-    return clone;
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/PropertyGridTests.cs b/src/System.Windows.Forms/tests/InteropTests/PropertyGridTests.cs
deleted file mode 100644
index c00dd73a855..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/PropertyGridTests.cs
+++ /dev/null
@@ -1,147 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-using Windows.Win32.System.ApplicationInstallationAndServicing;
-using Windows.Win32.System.Com;
-using static Interop;
-
-namespace System.Windows.Forms.Interop.Tests;
-
-[Collection("Sequential")]
-public class PropertyGridTests
-{
-    [Fact]
-    public void ISupportErrorInfo_Supported_ButNoIErrorInfoGiven()
-    {
-        ExecuteWithActivationContext(
-            "App.manifest",
-            () =>
-            {
-                using PropertyGrid propertyGrid = new PropertyGrid();
-                var target = CreateComObjectWithStandardIErrorInfoUsage();
-                propertyGrid.SelectedObject = target;
-                var entries = propertyGrid.GetCurrentEntries();
-                var encodingEntry = entries[0].Children.First(_ => _.PropertyName == "Int_Property");
-                try
-                {
-                    encodingEntry.SetPropertyTextValue("333");
-                    Assert.Fail("Invalid set values should produce ExternalException which will be presented to the user.");
-                }
-                catch (ExternalException ex)
-                {
-                    // Most default C++ implementation when Invoke return error code
-                    // implementation consults IErrorInfo object and populates EXCEPINFO structure.
-                    // From EXCEPINFO grid entry reads error code and message.
-                    // IErrorInfo consulted too, but it does not hold error message anymore.
-                    Assert.Equal((int)HRESULT.DISP_E_MEMBERNOTFOUND, ex.HResult);
-                    Assert.Equal("Error From StandardErrorInfoUsageTest", ex.Message);
-                }
-                finally
-                {
-                    propertyGrid.SelectedObject = null;
-                    Marshal.ReleaseComObject(target);
-                }
-            });
-    }
-
-    [Fact]
-    public void ISupportErrorInfo_Supported_WithIErrorInfoGiven()
-    {
-        ExecuteWithActivationContext(
-            "App.manifest",
-            () =>
-            {
-                using PropertyGrid propertyGrid = new PropertyGrid();
-                var target = CreateComObjectWithRawIErrorInfoUsage();
-                propertyGrid.SelectedObject = target;
-                var entries = propertyGrid.GetCurrentEntries();
-                var encodingEntry = entries[0].Children.First(_ => _.PropertyName == "Int_Property");
-                try
-                {
-                    encodingEntry.SetPropertyTextValue("123");
-                    Assert.Fail("Invalid set values should produce ExternalException which will be presenttted to the user.");
-                }
-                catch (ExternalException ex)
-                {
-                    // If C++ implementation of Invoke did not populate EXCEPINFO structure
-                    // from IErrorInfo, then we read that information about error call and display that error message to the user.
-                    Assert.Equal("Error From RawErrorInfoUsageTest", ex.Message);
-                }
-                finally
-                {
-                    propertyGrid.SelectedObject = null;
-                    Marshal.ReleaseComObject(target);
-                }
-            });
-    }
-
-    private unsafe void ExecuteWithActivationContext(string applicationManifest, Action action)
-    {
-        var context = new ACTCTXW();
-        HANDLE handle;
-        fixed (char* p = applicationManifest)
-        {
-            context.cbSize = (uint)sizeof(ACTCTXW);
-            context.lpSource = p;
-
-            handle = PInvoke.CreateActCtx(&context);
-        }
-
-        if (handle == IntPtr.Zero)
-        {
-            throw new Win32Exception();
-        }
-
-        try
-        {
-            nuint cookie;
-            if (!PInvoke.ActivateActCtx(handle, &cookie))
-            {
-                throw new Win32Exception();
-            }
-
-            try
-            {
-                action();
-            }
-            finally
-            {
-                if (!PInvoke.DeactivateActCtx(0, cookie))
-                {
-                    throw new Win32Exception();
-                }
-            }
-        }
-        finally
-        {
-            ReleaseActCtx(handle);
-        }
-    }
-
-    private object CreateComObjectWithRawIErrorInfoUsage()
-    {
-        Guid clsidRawErrorInfoUsageTest = new("0ED8EE0D-22E3-49EA-850C-E69B20D1F296");
-        Ole32.CoCreateInstance(in clsidRawErrorInfoUsageTest,
-            IntPtr.Zero,
-            CLSCTX.CLSCTX_INPROC_SERVER,
-            in IID.GetRef<global::Windows.Win32.System.Com.IUnknown>(),
-            out object result);
-        return result;
-    }
-
-    private object CreateComObjectWithStandardIErrorInfoUsage()
-    {
-        Guid clsidStandardErrorInfoUsageTest = new("EA1FCB3A-277C-4C79-AB85-E2ED3E858201");
-        Ole32.CoCreateInstance(in clsidStandardErrorInfoUsageTest,
-            IntPtr.Zero,
-            CLSCTX.CLSCTX_INPROC_SERVER,
-            in IID.GetRef<global::Windows.Win32.System.Com.IUnknown>(),
-            out object result);
-        return result;
-    }
-
-    [DllImport("kernel32", SetLastError = true)]
-    private static extern void ReleaseActCtx(IntPtr hActCtx);
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/RichTextBoxTests.cs b/src/System.Windows.Forms/tests/InteropTests/RichTextBoxTests.cs
deleted file mode 100644
index 58888fb3f76..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/RichTextBoxTests.cs
+++ /dev/null
@@ -1,199 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.UI.Controls.RichEdit;
-using static Interop.Richedit;
-
-namespace System.Windows.Forms.Interop.Tests;
-
-// Magic numbers in this file are coming from unmanaged part of the test
-// at src/System.Windows.Forms/tests/InteropTests/NativeTests/RichTextBoxTests.cpp
-public class RichTextBoxTests
-{
-    public const string NativeTests = "NativeTests";
-
-    [Fact]
-    public static void RichTextBox_EnLink_Test()
-    {
-        RichTextBox_EnLink(out var value);
-
-        Assert.Equal(132u, value.nmhdr.code);
-        Assert.Equal((HWND)765, value.nmhdr.hwndFrom);
-        Assert.Equal(432u, value.nmhdr.idFrom);
-        Assert.Equal(22, value.msg);
-        Assert.Equal((nuint)6578, value.wParam);
-        Assert.Equal(54425, value.lParam);
-        Assert.Equal(109, value.charrange.cpMin);
-        Assert.Equal(1577, value.charrange.cpMax);
-    }
-
-    [Fact]
-    public static void RichTextBox_EnProtected_Test()
-    {
-        RichTextBox_EnProtected(out var value);
-
-        Assert.Equal(132u, value.nmhdr.code);
-        Assert.Equal((HWND)765, value.nmhdr.hwndFrom);
-        Assert.Equal(432u, value.nmhdr.idFrom);
-        Assert.Equal(22, value.msg);
-        Assert.Equal((nuint)6578, value.wParam);
-        Assert.Equal(54425, value.lParam);
-        Assert.Equal(109, value.chrg.cpMin);
-        Assert.Equal(1577, value.chrg.cpMax);
-    }
-
-    [Fact]
-    public static void RichTextBox_EnDropFiles_Test()
-    {
-        RichTextBox_EnDropFiles(out var value);
-
-        Assert.Equal(132u, value.nmhdr.code);
-        Assert.Equal((HWND)765, value.nmhdr.hwndFrom);
-        Assert.Equal(432u, value.nmhdr.idFrom);
-        Assert.Equal(22, value.hDrop);
-        Assert.Equal(6578, value.cp);
-        Assert.Equal(BOOL.TRUE, value.fProtected);
-    }
-
-    [Fact]
-    public static void RichTextBox_CharRange_Test()
-    {
-        RichTextBox_CharRange(out var value);
-
-        Assert.Equal(109, value.cpMin);
-        Assert.Equal(1577, value.cpMax);
-    }
-
-    [Fact]
-    public static void RichTextBox_EditStream_Test()
-    {
-        RichTextBox_EditStream(out var value);
-
-        Assert.Equal((UIntPtr)109, value.dwCookie);
-        Assert.Equal(1577u, value.dwError);
-        Assert.Equal((IntPtr)6578, value.pfnCallback);
-    }
-
-    [Fact]
-    public static unsafe void RichTextBox_FindTextW_Test()
-    {
-        RichTextBox_FindTextW(out var value);
-
-        Assert.Equal("Fine Text", Marshal.PtrToStringUni((IntPtr)value.lpstrText));
-        Assert.Equal(109, value.chrg.cpMin);
-        Assert.Equal(1577, value.chrg.cpMax);
-    }
-
-    [Fact]
-    public static unsafe void RichTextBox_GetTextEx_Test()
-    {
-        RichTextBox_GetTextEx(out var value);
-
-        Assert.Equal(132u, value.cb);
-        Assert.Equal(GT.RAWTEXT, value.flags);
-        Assert.Equal(432u, value.codepage);
-        Assert.Equal((IntPtr)22, value.lpDefaultChar);
-        Assert.Equal((IntPtr)6578, value.lpUsedDefChar);
-    }
-
-    [Fact]
-    public static unsafe void RichTextBox_GetTextLengthEx_Test()
-    {
-        RichTextBox_GetTextLengthEx(out var value);
-
-        Assert.Equal(GTL.NUMBYTES, value.flags);
-        Assert.Equal(432u, value.codepage);
-    }
-
-    [Fact]
-    public static unsafe void RichTextBox_ParaFormat_Test()
-    {
-        RichTextBox_ParaFormat(out var value);
-
-        Assert.Equal(132u, value.cbSize);
-        Assert.Equal(PFM.ALIGNMENT, value.dwMask);
-        Assert.Equal(PFN.UCROMAN, value.wNumbering);
-        Assert.Equal(6578, value.wReserved);
-        Assert.Equal(109, value.dxStartIndent);
-        Assert.Equal(432, value.dxRightIndent);
-        Assert.Equal(54425, value.dxOffset);
-        Assert.Equal(PFA.JUSTIFY, value.wAlignment);
-        Assert.Equal(6565, value.cTabCount);
-        Assert.Equal(8989, value.rgxTabs[0]);
-        Assert.Equal(812, value.rgxTabs[31]);
-    }
-
-    [Fact]
-    public static void RichTextBox_ReqResize_Test()
-    {
-        RichTextBox_ReqResize(out var value);
-
-        Assert.Equal(132u, value.nmhdr.code);
-        Assert.Equal((HWND)765, value.nmhdr.hwndFrom);
-        Assert.Equal(432u, value.nmhdr.idFrom);
-        Assert.Equal(6578, value.rc.left);
-        Assert.Equal(109, value.rc.right);
-        Assert.Equal(54425, value.rc.top);
-        Assert.Equal(8989, value.rc.bottom);
-    }
-
-    [Fact]
-    public static void RichTextBox_SelChange_Test()
-    {
-        RichTextBox_SelChange(out var value);
-
-        Assert.Equal(132u, value.nmhdr.code);
-        Assert.Equal((HWND)765, value.nmhdr.hwndFrom);
-        Assert.Equal(432u, value.nmhdr.idFrom);
-        Assert.Equal(SEL.MULTICHAR, value.seltyp);
-        Assert.Equal(109, value.chrg.cpMin);
-        Assert.Equal(1577, value.chrg.cpMax);
-    }
-
-    [Fact]
-    public static unsafe void RichTextBox_TextRange_Test()
-    {
-        RichTextBox_TextRange(out var value);
-
-        Assert.Equal("Fine Text", Marshal.PtrToStringAnsi(value.lpstrText));
-        Assert.Equal(109, value.chrg.cpMin);
-        Assert.Equal(1577, value.chrg.cpMax);
-    }
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_EnLink(out ENLINK enlink);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_EnProtected(out ENPROTECTED enprotected);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_EnDropFiles(out ENDROPFILES value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_CharRange(out CHARRANGE value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_EditStream(out EDITSTREAM value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_FindTextW(out FINDTEXTW value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_GetTextEx(out GETTEXTEX value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_GetTextLengthEx(out GETTEXTLENGTHEX value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_ParaFormat(out PARAFORMAT value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_ReqResize(out REQRESIZE value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_SelChange(out SELCHANGE value);
-
-    [DllImport(NativeTests, PreserveSig = true)]
-    private static extern void RichTextBox_TextRange(out TEXTRANGE value);
-}
diff --git a/src/System.Windows.Forms/tests/InteropTests/System.Windows.Forms.Interop.Tests.csproj b/src/System.Windows.Forms/tests/InteropTests/System.Windows.Forms.Interop.Tests.csproj
deleted file mode 100644
index f2790d8b32a..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/System.Windows.Forms.Interop.Tests.csproj
+++ /dev/null
@@ -1,35 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <AssemblyName>System.Windows.Forms.Interop.Tests</AssemblyName>
-    <Platforms>x86;x64</Platforms>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <Import Project="ProjectReference.targets" Sdk="Microsoft.DotNet.CMake.Sdk" />
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\TestUtilities\System.Windows.Forms.TestUtilities.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <NativeProjectReference Include="NativeTests\CMakeLists.txt" CMakeProject="NativeTests\NativeTests.proj" BuildNative="true" />
-  </ItemGroup>
-
-  <Target Name="CopyTlbProjectFiles" BeforeTargets="CopyNativeProjectBinaries">
-    <ItemGroup>
-      <NativeProjectBinaries Include="$(NativeProjectOutputFolder)\*.tlb" />
-      <NativeProjectBinaries Include="$(NativeProjectOutputFolder)\*.manifest" />
-    </ItemGroup>
-  </Target>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/InteropTests/WebBrowserSiteBaseInteropTests.cs b/src/System.Windows.Forms/tests/InteropTests/WebBrowserSiteBaseInteropTests.cs
deleted file mode 100644
index 2a3ec85e719..00000000000
--- a/src/System.Windows.Forms/tests/InteropTests/WebBrowserSiteBaseInteropTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.InteropTests;
-
-public class WebBrowserSiteBaseInteropTests : InteropTestBase
-{
-    [WinFormsFact]
-    public void WebBrowserSiteBase_RunInteropTests()
-    {
-        var browser = new SubWebBrowser();
-        WebBrowserSiteBase site = browser.CreateWebBrowserSiteBase();
-        AssertSuccess(Test_WebBrowserSiteBase(site));
-    }
-
-    [DllImport(NativeTests, CharSet = CharSet.Unicode, ExactSpelling = true)]
-    private static extern string Test_WebBrowserSiteBase([MarshalAs(UnmanagedType.IUnknown)] object pUnk);
-
-    private class SubWebBrowser : WebBrowser
-    {
-        public new WebBrowserSiteBase CreateWebBrowserSiteBase() => base.CreateWebBrowserSiteBase();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/CommonTestHelperEx.cs b/src/System.Windows.Forms/tests/TestUtilities/CommonTestHelperEx.cs
deleted file mode 100644
index deef780e908..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/CommonTestHelperEx.cs
+++ /dev/null
@@ -1,190 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Design;
-using Moq;
-
-namespace System.Windows.Forms.TestUtilities;
-
-public static class CommonTestHelperEx
-{
-    public static TheoryData<Color, Color> GetBackColorTheoryData()
-    {
-        return new TheoryData<Color, Color>
-        {
-            { Color.Red, Color.Red },
-            { Color.Empty, Control.DefaultBackColor }
-        };
-    }
-
-    public static TheoryData<Color, Color> GetForeColorTheoryData()
-    {
-        return new TheoryData<Color, Color>
-        {
-            { Color.Red, Color.Red },
-            { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) },
-            { Color.White, Color.White },
-            { Color.Black, Color.Black },
-            { Color.Empty, Control.DefaultForeColor }
-        };
-    }
-
-    public static TheoryData<Image> GetImageTheoryData()
-    {
-        var data = new TheoryData<Image>
-        {
-            new Bitmap(10, 10),
-            null
-        };
-        return data;
-    }
-
-    public static TheoryData<Font> GetFontTheoryData()
-    {
-        var data = new TheoryData<Font>
-        {
-            SystemFonts.MenuFont,
-            null
-        };
-        return data;
-    }
-
-    public static TheoryData<Type> GetTypeWithNullTheoryData()
-    {
-        var data = new TheoryData<Type>
-        {
-            null,
-            typeof(int)
-        };
-        return data;
-    }
-
-    public static TheoryData<RightToLeft, RightToLeft> GetRightToLeftTheoryData()
-    {
-        var data = new TheoryData<RightToLeft, RightToLeft>
-        {
-            { RightToLeft.Inherit, RightToLeft.No },
-            { RightToLeft.Yes, RightToLeft.Yes },
-            { RightToLeft.No, RightToLeft.No }
-        };
-        return data;
-    }
-
-    public static TheoryData<Padding> GetPaddingTheoryData()
-    {
-        var data = new TheoryData<Padding>
-        {
-            new Padding(),
-            new Padding(1, 2, 3, 4),
-            new Padding(1),
-            new Padding(-1, -2, -3, -4)
-        };
-        return data;
-    }
-
-    public static TheoryData<Padding, Padding> GetPaddingNormalizedTheoryData()
-    {
-        var data = new TheoryData<Padding, Padding>
-        {
-            { new Padding(), new Padding() },
-            { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4) },
-            { new Padding(1), new Padding(1) },
-            { new Padding(-1, -2, -3, -4), Padding.Empty }
-        };
-        return data;
-    }
-
-    public static TheoryData<Cursor> GetCursorTheoryData()
-    {
-        var data = new TheoryData<Cursor>
-        {
-            null,
-            new Cursor((IntPtr)1)
-        };
-        return data;
-    }
-
-    public static TheoryData<PaintEventArgs> GetPaintEventArgsTheoryData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        return new TheoryData<PaintEventArgs>
-        {
-            null,
-            new PaintEventArgs(graphics, Rectangle.Empty)
-        };
-    }
-
-    public static TheoryData<KeyEventArgs> GetKeyEventArgsTheoryData()
-    {
-        return new TheoryData<KeyEventArgs>
-        {
-            new KeyEventArgs(Keys.None),
-            new KeyEventArgs(Keys.Cancel)
-        };
-    }
-
-    public static TheoryData<KeyPressEventArgs> GetKeyPressEventArgsTheoryData()
-    {
-        var data = new TheoryData<KeyPressEventArgs>
-        {
-            null,
-            new KeyPressEventArgs('1')
-        };
-        return data;
-    }
-
-    public static TheoryData<LayoutEventArgs> GetLayoutEventArgsTheoryData()
-    {
-        var data = new TheoryData<LayoutEventArgs>
-        {
-            null,
-            new LayoutEventArgs(null, null),
-            new LayoutEventArgs(new Control(), "affectedProperty")
-        };
-        return data;
-    }
-
-    public static TheoryData<MouseEventArgs> GetMouseEventArgsTheoryData()
-    {
-        return new TheoryData<MouseEventArgs>
-        {
-            null,
-            new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4),
-            new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4)
-        };
-    }
-
-    public static TheoryData<IServiceProvider, object> GetEditValueInvalidProviderTestData()
-    {
-        var nullServiceProviderMock = new Mock<IServiceProvider>(MockBehavior.Strict);
-        nullServiceProviderMock
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(null);
-        var invalidServiceProviderMock = new Mock<IServiceProvider>(MockBehavior.Strict);
-        invalidServiceProviderMock
-            .Setup(p => p.GetService(typeof(IWindowsFormsEditorService)))
-            .Returns(new object());
-        var value = new object();
-        return new TheoryData<IServiceProvider, object>
-        {
-            { null, null },
-            { null, value },
-            { nullServiceProviderMock.Object, null },
-            { nullServiceProviderMock.Object, value },
-            { invalidServiceProviderMock.Object, null },
-            { invalidServiceProviderMock.Object, value }
-        };
-    }
-
-    public static TheoryData<ITypeDescriptorContext> GetITypeDescriptorContextTestData()
-    {
-        return new TheoryData<ITypeDescriptorContext>
-        {
-            null,
-            new Mock<ITypeDescriptorContext>(MockBehavior.Strict).Object
-        };
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/ControlExtensions.cs b/src/System.Windows.Forms/tests/TestUtilities/ControlExtensions.cs
deleted file mode 100644
index c9d709dd62b..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/ControlExtensions.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Metafiles;
-using Windows.Win32;
-using Windows.Win32.Foundation;
-
-namespace System.Windows.Forms;
-
-public static class ControlExtensions
-{
-    /// <summary>
-    ///  Creates a metafile for the specified <see cref="Control"/> by calling <see cref="PInvoke.WM_PRINT"/>.
-    /// </summary>
-    internal static void PrintToMetafile(
-        this Control control,
-        EmfScope emf,
-        int prf = PInvoke.PRF_CHILDREN | PInvoke.PRF_CLIENT)
-    {
-        PInvoke.SendMessage(control, PInvoke.WM_PRINT, (WPARAM)emf.HDC, (LPARAM)(uint)prf);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/DialogHostForm.cs b/src/System.Windows.Forms/tests/TestUtilities/DialogHostForm.cs
deleted file mode 100644
index 4ad427ce228..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/DialogHostForm.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms;
-using Windows.Win32;
-using Windows.Win32.Foundation;
-using Windows.Win32.UI.WindowsAndMessaging;
-
-namespace System;
-
-/// <summary>
-///  Helper class to host dialogs for testing.
-///  This class is typically passed as a parameter to a call to <see cref="CommonDialog.ShowDialog(IWin32Window?)"/>.
-/// </summary>
-internal class DialogHostForm : Form
-{
-    protected override void WndProc(ref Message m)
-    {
-        if (m.MsgInternal == PInvoke.WM_ENTERIDLE && m.WParamInternal == (uint)MSGF.DIALOGBOX)
-        {
-            OnDialogIdle((HWND)m.LParamInternal);
-        }
-
-        base.WndProc(ref m);
-    }
-
-    protected virtual void OnDialogIdle(HWND dialogHandle)
-    {
-        PInvoke.PostMessage(dialogHandle, PInvoke.WM_CLOSE);
-    }
-
-    protected unsafe void Accept(HWND handle)
-    {
-        PInvoke.SendMessage(handle, PInvoke.WM_COMMAND, (WPARAM)(nint)MESSAGEBOX_RESULT.IDOK);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/GlobalUsings.cs b/src/System.Windows.Forms/tests/TestUtilities/GlobalUsings.cs
deleted file mode 100644
index 4fb1a00800f..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/GlobalUsings.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using Xunit;
diff --git a/src/System.Windows.Forms/tests/TestUtilities/KeyboardSimulator.cs b/src/System.Windows.Forms/tests/TestUtilities/KeyboardSimulator.cs
deleted file mode 100644
index 8910a2258d1..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/KeyboardSimulator.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using System.Windows.Forms;
-using Windows.Win32;
-using Windows.Win32.Foundation;
-
-namespace System;
-
-public static class KeyboardSimulator
-{
-    public static void KeyDown(Control control, Keys key)
-    {
-        (nint keyCode, nint lParam) = GetKeyParameters(key);
-        PInvoke.SendMessage(control, PInvoke.WM_KEYDOWN, (WPARAM)keyCode, lParam);
-    }
-
-    public static void KeyPress(Control control, Keys key)
-    {
-        (nint keyCode, nint lParam) = GetKeyParameters(key);
-        PInvoke.SendMessage(control, PInvoke.WM_KEYDOWN, (WPARAM)keyCode, lParam);
-        PInvoke.SendMessage(control, PInvoke.WM_KEYUP, (WPARAM)keyCode, lParam);
-    }
-
-    private static (nint keyCode, nint lParam) GetKeyParameters(Keys key)
-    {
-        var keyCode = (nint)key;
-        var scanCode = (int)key;
-        const int repeatCount = 1;
-        nint lParam = PARAM.FromLowHighUnsigned(repeatCount, scanCode);
-        return (keyCode , lParam);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/MSGF.cs b/src/System.Windows.Forms/tests/TestUtilities/MSGF.cs
deleted file mode 100644
index 9fd6abdf56d..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/MSGF.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-internal enum MSGF : uint
-{
-    DIALOGBOX = 0,
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/Properties/InternalsVisibleTo.cs b/src/System.Windows.Forms/tests/TestUtilities/Properties/InternalsVisibleTo.cs
deleted file mode 100644
index 5e7e0b43dc8..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/Properties/InternalsVisibleTo.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-// Awkward, but necessary to expose Interop based internals to other test libraries
-[assembly: InternalsVisibleTo("System.Windows.Forms.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.UI.IntegrationTests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("System.Windows.Forms.Design.Tests, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("WinformsControlsTest, PublicKey=00000000000000000400000000000000")]
-[assembly: InternalsVisibleTo("MauiListViewTests, PublicKey=00000000000000000400000000000000")]
diff --git a/src/System.Windows.Forms/tests/TestUtilities/PropertyGridInternal/SubPropertyGrid.cs b/src/System.Windows.Forms/tests/TestUtilities/PropertyGridInternal/SubPropertyGrid.cs
deleted file mode 100644
index 6768dccf070..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/PropertyGridInternal/SubPropertyGrid.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.Reflection;
-using System.Runtime.ExceptionServices;
-using System.Runtime.InteropServices;
-using Windows.Win32;
-
-namespace System.Windows.Forms.PropertyGridInternal.TestUtilities;
-
-public class SubPropertyGrid<TSelected> : PropertyGrid where TSelected : new()
-{
-    private static readonly MessageId WM_DELAYEDEXECUTION = PInvoke.RegisterWindowMessage("WinFormsSubPropertyGridDelayedExecution");
-
-    internal PropertyGridView GridView => this.TestAccessor().Dynamic._gridView;
-
-    internal GridEntry SelectedEntry
-    {
-        get => GridView.SelectedGridEntry;
-        set => SelectedGridItem = value;
-    }
-
-    internal GridEntry this[string propertyName]
-    {
-        get
-        {
-            string categoryName = SelectedObject.GetType().GetProperty(propertyName)!
-                .GetCustomAttribute<CategoryAttribute>()!.Category;
-            return GetCurrentEntries().Single(entry => entry.PropertyName == categoryName)
-                .Children.Single(entry => entry.PropertyName == propertyName);
-        }
-    }
-
-    public SubPropertyGrid() => SelectedObject = new TSelected();
-
-    public void PopupEditorAndClose(Action? onClosingAction = null)
-    {
-        Exception? exception = null;
-        bool called = false;
-
-        var callbackHandle = GCHandle.Alloc(() =>
-        {
-            try
-            {
-                onClosingAction?.Invoke();
-            }
-            catch (Exception ex)
-            {
-                exception = ex;
-            }
-
-            GridView.CloseDropDown();
-
-            called = true;
-        });
-
-        try
-        {
-            PInvoke.PostMessage(this, WM_DELAYEDEXECUTION, lParam: GCHandle.ToIntPtr(callbackHandle));
-            GridView.PopupEditor(GridView.TestAccessor().Dynamic._selectedRow);
-        }
-        finally
-        {
-            callbackHandle.Free();
-        }
-
-        Assert.True(called);
-
-        if (exception is not null)
-        {
-            ExceptionDispatchInfo.Capture(exception).Throw();
-        }
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        object selectedObject = SelectedObject;
-
-        base.Dispose(disposing);
-
-        if (disposing && selectedObject is IDisposable disposable)
-        {
-            disposable.Dispose();
-        }
-    }
-
-    protected override void WndProc(ref Message m)
-    {
-        if (m.MsgInternal != WM_DELAYEDEXECUTION)
-        {
-            base.WndProc(ref m);
-            return;
-        }
-
-        ((Action)GCHandle.FromIntPtr(m.LParamInternal).Target!)();
-    }
-
-    protected override void OnGotFocus(EventArgs e)
-    {
-        base.OnGotFocus(e);
-
-        GridView.Focus();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/ResxHelper.cs b/src/System.Windows.Forms/tests/TestUtilities/ResxHelper.cs
deleted file mode 100644
index 660a6bfe84b..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/ResxHelper.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-namespace System.Windows.Forms.TestUtilities;
-
-public static class ResxHelper
-{
-    public static string CreateResx(string data = null) =>
-    $"""
-    <root>
-        <resheader name="resmimetype">
-            <value>text/microsoft-resx</value>
-        </resheader>
-        <resheader name="version">
-            <value>2.0</value>
-        </resheader>
-        <resheader name="reader">
-            <value>System.Resources.ResXResourceReader</value>
-        </resheader>
-        <resheader name="writer">
-            <value>System.Resources.ResXResourceWriter</value>
-        </resheader>
-        {data ?? string.Empty}
-    </root>
-    """;
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/ScrollBarTestHelper.cs b/src/System.Windows.Forms/tests/TestUtilities/ScrollBarTestHelper.cs
deleted file mode 100644
index eaeefce3dd8..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/ScrollBarTestHelper.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.TestUtilities;
-
-public static class ScrollBarTestHelper
-{
-    private const int Maximum = 100;
-    private const int Minumim = 0;
-
-    public static IEnumerable<object[]> HScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            // Depending on orientation and RTL settings, the first button can be shown
-            // or hidden when the trackbar value is at minimum or maximum.
-            int value = rightToLeft == RightToLeft.Yes ? Minumim : Maximum;
-
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ 50 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, value };
-        }
-    }
-
-    public static IEnumerable<object[]> HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            // Depending on orientation and RTL settings, the first button can be shown
-            // or hidden when the trackbar value is at minimum or maximum.
-            int value = rightToLeft == RightToLeft.Yes ? Maximum : Minumim;
-
-            yield return new object[] { rightToLeft, Minumim, Maximum, value };
-        }
-    }
-
-    public static IEnumerable<object[]> HScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            // Depending on orientation and RTL settings, the first button can be shown
-            // or hidden when the trackbar value is at minimum or maximum.
-            int value = rightToLeft == RightToLeft.Yes ? Maximum : Minumim;
-
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ 50 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, value };
-        }
-    }
-
-    public static IEnumerable<object[]> HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            // Depending on orientation and RTL settings, the first button can be shown
-            // or hidden when the trackbar value is at minimum or maximum.
-            int value = rightToLeft == RightToLeft.Yes ? Minumim : Maximum;
-
-            yield return new object[] { rightToLeft, Minumim, Maximum, value };
-        }
-    }
-
-    public static IEnumerable<object[]> ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ 50 };
-        }
-    }
-
-    public static IEnumerable<object[]> ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, /*Minumim*/ 0, /*Maximum*/ 0, /*Value*/ 0 };
-        }
-    }
-
-    public static IEnumerable<object[]> ScrollBarAccessibleObject_TestData()
-    {
-        foreach (bool createControl in new bool[] { true, false })
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                yield return new object[] { createControl, rightToLeft, Minumim, Maximum, /*Value*/ 0 };
-                yield return new object[] { createControl, rightToLeft, Minumim, Maximum, /*Value*/ 50 };
-                yield return new object[] { createControl, rightToLeft, Minumim, Maximum, /*Value*/ 100 };
-                yield return new object[] { createControl, rightToLeft, Minumim, /*Maximum*/ 0, /*Value*/ 0 };
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> ScrollBarAccessibleObject_WithoutCreateControl_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*Value*/ 0 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*Value*/ 50 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*Value*/ 100 };
-            yield return new object[] { rightToLeft, Minumim, /*Maximum*/ 0, /*Value*/ 0 };
-        }
-    }
-
-    public static IEnumerable<object[]> VScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ 50 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ Maximum };
-        }
-    }
-
-    public static IEnumerable<object[]> VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ Minumim };
-        }
-    }
-
-    public static IEnumerable<object[]> VScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ 50 };
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ Minumim };
-        }
-    }
-
-    public static IEnumerable<object[]> VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            yield return new object[] { rightToLeft, Minumim, Maximum, /*value*/ Maximum };
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/System.Windows.Forms.TestUtilities.csproj b/src/System.Windows.Forms/tests/TestUtilities/System.Windows.Forms.TestUtilities.csproj
deleted file mode 100644
index b220d6edaf3..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/System.Windows.Forms.TestUtilities.csproj
+++ /dev/null
@@ -1,23 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <AssemblyName>System.Windows.Forms.TestUtilities</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <RootNamespace>System</RootNamespace>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.RemoteExecutor" Version="$(MicrosoftDotNetRemoteExecutorVersion)" />
-    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\System.Windows.Forms.Primitives\src\System.Windows.Forms.Primitives.csproj" />
-    <ProjectReference Include="..\..\..\System.Windows.Forms.Primitives\tests\TestUtilities\System.Windows.Forms.Primitives.TestUtilities.csproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/TestUtilities/SystemEventsHelper.cs b/src/System.Windows.Forms/tests/TestUtilities/SystemEventsHelper.cs
deleted file mode 100644
index 28064834048..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/SystemEventsHelper.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using Microsoft.Win32;
-using Windows.Win32;
-using Windows.Win32.Foundation;
-using static Windows.Win32.UI.WindowsAndMessaging.SYSTEM_PARAMETERS_INFO_ACTION;
-
-namespace System;
-
-public static class SystemEventsHelper
-{
-    private static HWND GetHWnd()
-    {
-        // Locate the hwnd used by SystemEvents in this domain.
-        FieldInfo windowClassNameField =
-            typeof(SystemEvents).GetField("s_className", BindingFlags.Static | BindingFlags.NonPublic)   // runtime
-            ?? typeof(SystemEvents).GetField("className", BindingFlags.Static | BindingFlags.NonPublic); // desktop
-
-        Assert.NotNull(windowClassNameField);
-        string windowClassName = windowClassNameField.GetValue(null) as string;
-        Assert.NotNull(windowClassName);
-
-        HWND window = PInvoke.FindWindow(windowClassName, null);
-        return window;
-    }
-
-    public static void SendMessageOnUserPreferenceChanged(UserPreferenceCategory category)
-    {
-        HWND window = GetHWnd();
-
-        MessageId msg;
-        WPARAM wParam;
-        if (category == UserPreferenceCategory.Color)
-        {
-            msg = PInvoke.WM_SYSCOLORCHANGE;
-            wParam = 0;
-        }
-        else
-        {
-            msg = PInvoke.WM_SETTINGCHANGE;
-
-            if (category == UserPreferenceCategory.Accessibility)
-            {
-                wParam = (int)SPI_SETHIGHCONTRAST;
-            }
-            else if (category == UserPreferenceCategory.Desktop)
-            {
-                wParam = (int)SPI_SETDESKWALLPAPER;
-            }
-            else if (category == UserPreferenceCategory.Icon)
-            {
-                wParam = (int)SPI_ICONHORIZONTALSPACING;
-            }
-            else if (category == UserPreferenceCategory.Mouse)
-            {
-                wParam = (int)SPI_SETDOUBLECLICKTIME;
-            }
-            else if (category == UserPreferenceCategory.Keyboard)
-            {
-                wParam = (int)SPI_SETKEYBOARDDELAY;
-            }
-            else if (category == UserPreferenceCategory.Menu)
-            {
-                wParam = (int)SPI_SETMENUDROPALIGNMENT;
-            }
-            else if (category == UserPreferenceCategory.Power)
-            {
-                wParam = (int)SPI_SETLOWPOWERACTIVE;
-            }
-            else if (category == UserPreferenceCategory.Screensaver)
-            {
-                wParam = (int)SPI_SETMENUDROPALIGNMENT;
-            }
-            else if (category == UserPreferenceCategory.Window)
-            {
-                wParam = (int)SPI_SETMENUDROPALIGNMENT;
-            }
-            else
-            {
-                throw new NotImplementedException($"Not implemented category {category}.");
-            }
-        }
-
-        // Call with reflect to immediately send the message.
-        PInvoke.SendMessage(window, msg | MessageId.WM_REFLECT, wParam);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/TestUtilities/TrackBarTestHelper.cs b/src/System.Windows.Forms/tests/TestUtilities/TrackBarTestHelper.cs
deleted file mode 100644
index 644820d6689..00000000000
--- a/src/System.Windows.Forms/tests/TestUtilities/TrackBarTestHelper.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.TestUtilities;
-
-/// <summary>
-///  This class contains methods that return a list of parameters for unit tests.
-///  These methods have been moved to a static class since we have several test classes that use the same test parameters.
-///  Thus, we reduce the amount of copy-paste and we can be sure that all tests use the same data sets.
-/// </summary>
-public static class TrackBarTestHelper
-{
-    private const int Maximum = 10;
-    private const int Minumim = 0;
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_ButtonsAreDisplayed_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 5 };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_FirstButtonIsDisplayed_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    bool isMirrored = rightToLeft == RightToLeft.Yes && rightToLeftLayout;
-
-                    // Depending on orientation and RTL settings, the first button can be shown
-                    // or hidden when the trackbar value is at minimum or maximum.
-                    int value = orientation == Orientation.Horizontal && (rightToLeft == RightToLeft.No || isMirrored)
-                        ? Maximum
-                        : Minumim;
-
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 5 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, value };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_FirstButtonIsHidden_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    bool isMirrored = rightToLeft == RightToLeft.Yes && rightToLeftLayout;
-
-                    // Depending on orientation and RTL settings, the first button can be shown
-                    // or hidden when the trackbar value is at minimum or maximum.
-                    int value = orientation == Orientation.Horizontal && (rightToLeft == RightToLeft.No || isMirrored)
-                        ? Minumim
-                        : Maximum;
-
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, value };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_LastButtonIsDisplayed_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    bool isMirrored = rightToLeft == RightToLeft.Yes && rightToLeftLayout;
-
-                    // Depending on orientation and RTL settings, the first button can be shown
-                    // or hidden when the trackbar value is at minimum or maximum.
-                    int value = orientation == Orientation.Horizontal && (rightToLeft == RightToLeft.No || isMirrored)
-                        ? Minumim
-                        : Maximum;
-
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 5 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, value };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, /*maximum*/ 0, /*value*/ 0 };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_LastButtonIsHidden_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    bool isMirrored = rightToLeft == RightToLeft.Yes && rightToLeftLayout;
-
-                    // Depending on orientation and RTL settings, the first button can be shown
-                    // or hidden when the trackbar value is at minimum or maximum.
-                    int value = orientation == Orientation.Horizontal && (rightToLeft == RightToLeft.No || isMirrored)
-                        ? Maximum
-                        : Minumim;
-
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, value };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_MinimumEqualsMaximum_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 0, 0, 0 };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    foreach (bool createControl in new[] { true, false })
-                    {
-                        yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, Minumim, Maximum, /*value*/ 5 };
-                        yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, Minumim, Maximum, /*value*/ 0 };
-                        yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, Minumim, Maximum, /*value*/ 10 };
-                        yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, Minumim, /*maximum*/ 0, /*value*/ 0 };
-                    }
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_WithoutCreateControl_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 5 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 0 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, Maximum, /*value*/ 10 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, Minumim, /*maximum*/ 0, /*value*/ 0 };
-                }
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/BindingNavigatorTests.cs b/src/System.Windows.Forms/tests/UnitTests/BindingNavigatorTests.cs
deleted file mode 100644
index cdcf206bc40..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/BindingNavigatorTests.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Data;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class BindingNavigatorTests
-{
-    [WinFormsFact]
-    public void BindingNavigator_Constructor()
-    {
-        using var bn = new BindingNavigator();
-
-        Assert.NotNull(bn);
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_ConstructorBindingSource()
-    {
-        using var bindingSource = new BindingSource();
-        var data = new List<string>() { "Foo", "Bar" };
-        bindingSource.DataSource = data;
-
-        using var bn = new BindingNavigator(bindingSource);
-
-        Assert.NotNull(bn);
-        Assert.Equal(bindingSource, bn.BindingSource);
-
-        // need more thorough binding source testing
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_ConstructorIContainer()
-    {
-        IContainer nullContainer = null;
-        var mockContainer = new Mock<IContainer>(MockBehavior.Strict);
-        mockContainer.Setup(x => x.Add(It.IsAny<BindingNavigator>())).Verifiable();
-
-        // act & assert
-        ArgumentNullException ex = Assert.Throws<ArgumentNullException>(() => new BindingNavigator(nullContainer));
-        Assert.Equal("container", ex.ParamName);
-
-        using var bn = new BindingNavigator(mockContainer.Object);
-        Assert.NotNull(bn);
-        mockContainer.Verify(x => x.Add(bn));
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_ConstructorBool()
-    {
-        using var bn = new BindingNavigator(true);
-
-        Assert.NotNull(bn);
-
-        Assert.NotNull(bn.PositionItem);
-        Assert.NotNull(bn.CountItem);
-        Assert.Equal("bindingNavigatorPositionItem", bn.PositionItem.Name);
-        Assert.Equal("bindingNavigatorCountItem", bn.CountItem.Name);
-        Assert.Equal(SR.BindingNavigatorCountItemTip, bn.CountItem.ToolTipText);
-        Assert.Equal(SR.BindingNavigatorPositionItemTip, bn.PositionItem.ToolTipText);
-        Assert.False(bn.CountItem.AutoToolTip);
-        Assert.False(bn.PositionItem.AutoToolTip);
-        Assert.Equal(SR.BindingNavigatorPositionAccessibleName, bn.PositionItem.AccessibleName);
-
-        var items = new List<ToolStripItem>()
-        {
-            bn.MoveFirstItem,
-            bn.MovePreviousItem,
-            bn.MoveNextItem,
-            bn.MoveLastItem,
-            bn.AddNewItem,
-            bn.DeleteItem
-        };
-
-        var itemNames = new List<string>()
-        {
-            "bindingNavigatorMoveFirstItem",
-            "bindingNavigatorMovePreviousItem",
-            "bindingNavigatorMoveNextItem",
-            "bindingNavigatorMoveLastItem",
-            "bindingNavigatorAddNewItem",
-            "bindingNavigatorDeleteItem"
-        };
-
-        var itemTexts = new List<string>()
-        {
-            SR.BindingNavigatorMoveFirstItemText,
-            SR.BindingNavigatorMovePreviousItemText,
-            SR.BindingNavigatorMoveNextItemText,
-            SR.BindingNavigatorMoveLastItemText,
-            SR.BindingNavigatorAddNewItemText,
-            SR.BindingNavigatorDeleteItemText
-        };
-
-        for (var i = 0; i < items.Count; i++)
-        {
-            ToolStripItem item = items[i];
-            Assert.NotNull(item);
-            Assert.Equal(itemNames[i], item.Name.Trim());
-            Assert.Equal(itemTexts[i], item.Text.Trim());
-            Assert.NotNull(item.Image);
-            Assert.True(item.RightToLeftAutoMirrorImage);
-            Assert.Equal(ToolStripItemDisplayStyle.Image, item.DisplayStyle);
-        }
-
-        Assert.False(bn.PositionItem.AutoSize);
-        Assert.Equal(50, bn.PositionItem.Width);
-
-        var index = 0;
-        Assert.Equal(11, bn.Items.Count);
-        Assert.Equal(bn.MoveFirstItem, bn.Items[index++]);
-        Assert.Equal(bn.MovePreviousItem, bn.Items[index++]);
-        Assert.NotNull(bn.Items[index]);
-        Assert.IsType<ToolStripSeparator>(bn.Items[index++]);
-        Assert.Equal(bn.PositionItem, bn.Items[index++]);
-        Assert.Equal(bn.CountItem, bn.Items[index++]);
-        Assert.NotNull(bn.Items[index]);
-        Assert.IsType<ToolStripSeparator>(bn.Items[index++]);
-        Assert.Equal(bn.MoveNextItem, bn.Items[index++]);
-        Assert.Equal(bn.MoveLastItem, bn.Items[index++]);
-        Assert.NotNull(bn.Items[index]);
-        Assert.IsType<ToolStripSeparator>(bn.Items[index++]);
-        Assert.Equal(bn.AddNewItem, bn.Items[index++]);
-        Assert.Equal(bn.DeleteItem, bn.Items[index++]);
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_UpdatesItsItems_AfterDataSourceDisposing()
-    {
-        using BindingNavigator control = new BindingNavigator(true);
-        int rowsCount = 5;
-        BindingSource bindingSource = GetTestBindingSource(rowsCount);
-        control.BindingSource = bindingSource;
-
-        Assert.Equal("1", control.PositionItem.Text);
-        Assert.Equal($"of {rowsCount}", control.CountItem.Text);
-
-        bindingSource.Dispose();
-
-        // The BindingNavigator updates its PositionItem and CountItem values
-        // after its BindingSource is disposed
-        Assert.Equal("0", control.PositionItem.Text);
-        Assert.Equal("of 0", control.CountItem.Text);
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_BindingSource_IsNull_AfterDisposing()
-    {
-        using BindingNavigator control = new BindingNavigator();
-        BindingSource bindingSource = GetTestBindingSource(5);
-        control.BindingSource = bindingSource;
-
-        Assert.Equal(bindingSource, control.BindingSource);
-
-        bindingSource.Dispose();
-
-        Assert.Null(control.BindingSource);
-    }
-
-    [WinFormsFact]
-    public void BindingNavigator_BindingSource_IsActual_AfterOldOneIsDisposed()
-    {
-        using BindingNavigator control = new BindingNavigator(true);
-        int rowsCount1 = 3;
-        BindingSource bindingSource1 = GetTestBindingSource(rowsCount1);
-        int rowsCount2 = 5;
-        BindingSource bindingSource2 = GetTestBindingSource(rowsCount2);
-        control.BindingSource = bindingSource1;
-
-        Assert.Equal(bindingSource1, control.BindingSource);
-        Assert.Equal("1", control.PositionItem.Text);
-        Assert.Equal($"of {rowsCount1}", control.CountItem.Text);
-
-        control.BindingSource = bindingSource2;
-
-        Assert.Equal(bindingSource2, control.BindingSource);
-        Assert.Equal("1", control.PositionItem.Text);
-        Assert.Equal($"of {rowsCount2}", control.CountItem.Text);
-
-        bindingSource1.Dispose();
-
-        // bindingSource2 is actual for the BindingNavigator
-        // so it will contain correct PositionItem and CountItem values
-        // even after bindingSource1 is disposed.
-        // This test checks that Disposed events unsubscribed correctly
-        Assert.Equal(bindingSource2, control.BindingSource);
-        Assert.Equal("1", control.PositionItem.Text);
-        Assert.Equal($"of {rowsCount2}", control.CountItem.Text);
-    }
-
-    private BindingSource GetTestBindingSource(int rowsCount)
-    {
-        DataTable dt = new DataTable();
-        dt.Columns.Add("Name");
-        dt.Columns.Add("Age");
-
-        for (int i = 0; i < rowsCount; i++)
-        {
-            DataRow dr = dt.NewRow();
-            dr[0] = $"User{i}";
-            dr[1] = i * 3;
-            dt.Rows.Add(dr);
-        }
-
-        return new() { DataSource = dt };
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxItemAccessibleObjectTests.cs
deleted file mode 100644
index 6613b867c76..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,326 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.CheckedListBox;
-using static Interop;
-
-namespace System.Windows.Forms.Tests.AccessibleObjects;
-
-public class CheckedListBoxItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_Ctor_OwningCheckedListBoxIsNull_RaiseException()
-    {
-        using CheckedListBox checkedListBox = new();
-        var accessibleObject = (CheckedListBoxAccessibleObject)checkedListBox.AccessibilityObject;
-
-        Assert.Throws<ArgumentNullException>(() => { new CheckedListBoxItemAccessibleObject(null, new ItemArray.Entry("A"), accessibleObject); });
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_Ctor_ItemCheckedListBoxIsNull_RaiseException()
-    {
-        using CheckedListBox checkedListBox = new();
-        var accessibleObject = (CheckedListBoxAccessibleObject)checkedListBox.AccessibilityObject;
-
-        Assert.Throws<ArgumentNullException>(() => { new CheckedListBoxItemAccessibleObject(checkedListBox, null, accessibleObject); });
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_Ctor_ParentAccessibleObjectIsNull_RaiseException()
-    {
-        using CheckedListBox checkedListBox = new();
-
-        Assert.Throws<ArgumentNullException>(() => { new CheckedListBoxItemAccessibleObject(checkedListBox, new ItemArray.Entry("A"), null); });
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("A")]
-    [InlineData("")]
-    public void CheckedListBoxItemAccessibleObject_Name_ReturnsExpected(string testName)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add(testName);
-
-        Assert.Equal(testName, checkedListBox.AccessibilityObject.GetChild(0).Name);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_Role_IsCheckButton()
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-
-        Assert.Equal(AccessibleRole.CheckButton, checkedListBox.AccessibilityObject.GetChild(0).Role);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_CurrentIndex_IsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject accessibleObject = checkedListBox.AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChild(0).TestAccessor().Dynamic.CurrentIndex);
-        Assert.Equal(1, accessibleObject.GetChild(1).TestAccessor().Dynamic.CurrentIndex);
-        Assert.Equal(2, accessibleObject.GetChild(2).TestAccessor().Dynamic.CurrentIndex);
-
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TogglePatternId)]
-    [InlineData((int)UiaCore.UIA.InvokePatternId)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    public void CheckedListBoxItemAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-
-        AccessibleObject itemAccessibleObject = checkedListBox.AccessibilityObject.GetChild(0);
-
-        Assert.True(itemAccessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_RuntimeId_NotNull()
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-
-        Assert.NotNull(checkedListBox.AccessibilityObject.GetChild(0).RuntimeId);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void CheckedListBoxItemAccessibleObject_FragmentNavigate_Parent_IsExpected(int itemIndex)
-    {
-        using CheckedListBox checkedListBox = new();
-        AccessibleObject expected = checkedListBox.AccessibilityObject;
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject itemAccessibleObject = checkedListBox.AccessibilityObject.GetChild(itemIndex);
-        UiaCore.IRawElementProviderFragment actual = itemAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(expected, actual);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_FragmentNavigate_NextSibling_IsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject itemAccessibleObject1 = checkedListBox.AccessibilityObject.GetChild(0);
-        AccessibleObject itemAccessibleObject2 = checkedListBox.AccessibilityObject.GetChild(1);
-        AccessibleObject itemAccessibleObject3 = checkedListBox.AccessibilityObject.GetChild(2);
-
-        Assert.Equal(itemAccessibleObject2, itemAccessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(itemAccessibleObject3, itemAccessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(itemAccessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_FragmentNavigate_PreviousSibling_IsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject itemAccessibleObject1 = checkedListBox.AccessibilityObject.GetChild(0);
-        AccessibleObject itemAccessibleObject2 = checkedListBox.AccessibilityObject.GetChild(1);
-        AccessibleObject itemAccessibleObject3 = checkedListBox.AccessibilityObject.GetChild(2);
-
-        Assert.Null(itemAccessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(itemAccessibleObject1, itemAccessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(itemAccessibleObject2, itemAccessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_DefaultAction_IfHandleIsNotCreated_ReturnsEmptyString()
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-
-        Assert.Equal(string.Empty, checkedListBox.AccessibilityObject.GetChild(0).DefaultAction);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CheckedListBoxItemAccessibleObject_DefaultAction_ControlType_IfHandleIsCreated_ReturnsExpected_TestData()
-    {
-        yield return new object[] { true, SR.AccessibleActionUncheck };
-        yield return new object[] { false, SR.AccessibleActionCheck };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckedListBoxItemAccessibleObject_DefaultAction_ControlType_IfHandleIsCreated_ReturnsExpected_TestData))]
-    public void CheckedListBoxItemAccessibleObject_DefaultAction_IfHandleIsCreated_ReturnsExpected(bool isChecked, string expected)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-        checkedListBox.CreateControl();
-
-        Assert.Equal(expected, checkedListBox.AccessibilityObject.GetChild(0).DefaultAction);
-        Assert.True(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckedListBoxItemAccessibleObject_DefaultAction_ControlType_IfHandleIsCreated_ReturnsExpected_TestData))]
-    public void CheckedListBoxItemAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected(bool isChecked, string expected)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-        checkedListBox.CreateControl();
-
-        Assert.Equal(expected, checkedListBox.AccessibilityObject.GetChild(0).GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.True(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBoxItemAccessibleObject_Value_ReturnsExpected(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-
-        Assert.Equal(isChecked.ToString(), checkedListBox.AccessibilityObject.GetChild(0).Value);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBoxItemAccessibleObject_DoDefaultAction_IfHandleIsNotCreated_DoesNothing(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-
-        checkedListBox.AccessibilityObject.GetChild(0).DoDefaultAction();
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBoxItemAccessibleObject_DoDefaultAction_IfHandleIsCreated_WorksExpected(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-        checkedListBox.CreateControl();
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-
-        checkedListBox.AccessibilityObject.GetChild(0).DoDefaultAction();
-
-        Assert.Equal(!isChecked, checkedListBox.GetItemChecked(0));
-        Assert.True(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, (int)UiaCore.ToggleState.On)]
-    [InlineData(false, CheckState.Unchecked, (int)UiaCore.ToggleState.Off)]
-    [InlineData(true, CheckState.Indeterminate, (int)UiaCore.ToggleState.Indeterminate)]
-    public void CheckedListBoxItemAccessibleObject_ToggleState_ReturnsExpected(bool checkValue, CheckState checkState, int toggleState)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemCheckState(0, checkState);
-
-        Assert.Equal((UiaCore.ToggleState)toggleState, checkedListBox.AccessibilityObject.GetChild(0).ToggleState);
-        Assert.Equal(checkValue.ToString(), checkedListBox.AccessibilityObject.GetChild(0).GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBoxItemAccessibleObject_Toggle_IfHandleIsNotCreated_DoesNothing(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-
-        checkedListBox.AccessibilityObject.GetChild(0).Toggle();
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBoxItemAccessibleObject_Toggle_IfHandleIsCreated_WorksExpected(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-        checkedListBox.CreateControl();
-
-        Assert.Equal(isChecked, checkedListBox.GetItemChecked(0));
-
-        checkedListBox.AccessibilityObject.GetChild(0).Toggle();
-
-        Assert.Equal(!isChecked, checkedListBox.GetItemChecked(0));
-        Assert.True(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxItemAccessibleObject_GetPropertyValue_IsInvokePatternAvailablePropertyId_ReturnsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-
-        Assert.True((bool)checkedListBox.AccessibilityObject.GetChild(0).GetPropertyValue(UiaCore.UIA.IsInvokePatternAvailablePropertyId));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckedListBoxItemAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected(bool isChecked)
-    {
-        using CheckedListBox checkedListBox = new();
-        checkedListBox.Items.Add("A");
-        checkedListBox.SetItemChecked(0, isChecked);
-
-        AccessibleObject accessibleObject = checkedListBox.AccessibilityObject.GetChild(0);
-        Assert.Equal(isChecked, bool.Parse(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId).ToString()));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxTests.cs
deleted file mode 100644
index e54eeeda442..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/CheckedListBoxTests.cs
+++ /dev/null
@@ -1,603 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class CheckedListBoxTests
-{
-    [WinFormsFact]
-    public void CheckedListBox_Constructor()
-    {
-        using var box = new CheckedListBox();
-
-        Assert.NotNull(box);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckedListBox_CheckOnClick(bool expected)
-    {
-        using var box = new CheckedListBox
-        {
-            CheckOnClick = expected
-        };
-
-        Assert.Equal(expected, box.CheckOnClick);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_CheckedIndexCollectionNotNull()
-    {
-        using var box = new CheckedListBox();
-
-        CheckedListBox.CheckedIndexCollection collection = box.CheckedIndices;
-
-        Assert.NotNull(collection);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_CheckedItemCollectionNotNull()
-    {
-        using var box = new CheckedListBox();
-
-        CheckedListBox.CheckedItemCollection collection = box.CheckedItems;
-
-        Assert.NotNull(collection);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void CheckedListBox_DisplayMember(string expected)
-    {
-        using var box = new CheckedListBox
-        {
-            DisplayMember = expected
-        };
-
-        Assert.Equal(expected, box.DisplayMember);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_DrawModeReturnsNormalOnly()
-    {
-        using var box = new CheckedListBox();
-
-        DrawMode result = box.DrawMode;
-
-        Assert.Equal(DrawMode.Normal, result);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.None)]
-    [InlineData(SelectionMode.One)]
-    public void CheckedListBox_SelectionModeGetSet(SelectionMode expected)
-    {
-        using var box = new CheckedListBox
-        {
-            SelectionMode = expected
-        };
-
-        Assert.Equal(expected, box.SelectionMode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiSimple)]
-    [InlineData(SelectionMode.MultiExtended)]
-    public void CheckedListBox_SelectionModeGetSetInvalidFromEnum(SelectionMode expected)
-    {
-        using var box = new CheckedListBox();
-
-        ArgumentException ex = Assert.Throws<ArgumentException>(() => box.SelectionMode = expected);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<SelectionMode>]
-    public void CheckedListBox_SelectionMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(SelectionMode value)
-    {
-        using var control = new CheckedListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.SelectionMode = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckedListBox_ThreeDCheckBoxes(bool expected)
-    {
-        using var box = new CheckedListBox
-        {
-            ThreeDCheckBoxes = expected
-        };
-
-        Assert.Equal(expected, box.ThreeDCheckBoxes);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void CheckedListBox_ValueMember(string expected)
-    {
-        using var box = new CheckedListBox
-        {
-            ValueMember = expected
-        };
-
-        Assert.Equal(expected, box.ValueMember);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void CheckedListBox_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new CheckedListBox
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Padding_SetWithHandle_TestData()
-    {
-        yield return new object[] { new Padding(), new Padding(), 0, 0 };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 1 };
-        yield return new object[] { new Padding(1), new Padding(1), 1, 1 };
-        yield return new object[] { new Padding(-1, -2, -3, -4), Padding.Empty, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_SetWithHandle_TestData))]
-    public void CheckedListBox_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new CheckedListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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(expectedInvalidatedCallCount1, 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(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new CheckedListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(-1)]
-    [InlineData(int.MaxValue)]
-    public void CheckedListBox_GetItemCheckStateOutOfRange(int index)
-    {
-        using var box = new CheckedListBox();
-
-        ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => box.GetItemCheckState(index));
-        Assert.Equal("index", ex.ParamName);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_RefreshItems_InvokeEmpty_Success()
-    {
-        using var control = new SubCheckedListBox();
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_RefreshItems_InvokeNotEmpty_Success()
-    {
-        using var control = new SubCheckedListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_RefreshItems_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubCheckedListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_RefreshItems_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubCheckedListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(-1)]
-    [InlineData(int.MaxValue)]
-    public void CheckedListBox_SetItemCheckStateOutOfRange(int index)
-    {
-        using var box = new CheckedListBox();
-
-        ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(() => box.SetItemCheckState(index, CheckState.Checked));
-        Assert.Equal("index", ex.ParamName);
-    }
-
-    [WinFormsTheory]
-    [EnumData<CheckState>]
-    public void CheckedListBox_SetItemCheckState_Invoke_GetReturnsExpected(CheckState value)
-    {
-        using var control = new CheckedListBox();
-        control.Items.Add(new CheckBox(), false);
-
-        control.SetItemCheckState(0, value);
-        Assert.Equal(value, control.GetItemCheckState(0));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetItemCheckState(0, value);
-        Assert.Equal(value, control.GetItemCheckState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<CheckState>]
-    public void CheckedListBox_SetItemCheckState_InvokeInvalidValue_ThrowsInvalidEnumArgumentException(CheckState value)
-    {
-        using var control = new CheckedListBox();
-        control.Items.Add(new CheckBox(), false);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.SetItemCheckState(0, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked)]
-    [InlineData(false, CheckState.Unchecked)]
-    public void CheckedListBox_SetItemChecked(bool send, CheckState expected)
-    {
-        using var box = new CheckedListBox();
-        box.Items.Add(new CheckBox(), false);
-
-        box.SetItemChecked(0, send);
-
-        Assert.Equal(expected, box.GetItemCheckState(0));
-    }
-
-    public static IEnumerable<object[]> OnDrawItem_TestData()
-    {
-        yield return new object[] { null, Rectangle.Empty, 0, DrawItemState.Default, Color.Red, Color.Blue };
-        yield return new object[] { null, new Rectangle(1, 2, 3, 4), 1, DrawItemState.None, Color.Red, Color.Blue };
-        yield return new object[] { null, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Checked, Color.Red, Color.Blue };
-        yield return new object[] { new Font("Arial", 8.25f), new Rectangle(10, 20, 30, 40), 1, DrawItemState.Default, Color.Red, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDrawItem_TestData))]
-    public void CheckedListBox_OnDrawItem_Invoke_Success(Font font, Rectangle rect, int index, DrawItemState state, Color foreColor, Color backColor)
-    {
-        using var control = new SubCheckedListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new DrawItemEventArgs(graphics, font, rect, index, state, foreColor, backColor);
-        control.OnDrawItem(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDrawItem_TestData))]
-    public void CheckedListBox_OnDrawItem_InvokeWithHandle_Success(Font font, Rectangle rect, int index, DrawItemState state, Color foreColor, Color backColor)
-    {
-        using var control = new SubCheckedListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new DrawItemEventArgs(graphics, font, rect, index, state, foreColor, backColor);
-        control.OnDrawItem(e);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_OnDrawItem_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubCheckedListBox();
-        Assert.Throws<NullReferenceException>(() => control.OnDrawItem(null));
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_OnDrawItem_NegativeEIndex_Success()
-    {
-        using var control = new SubCheckedListBox();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new DrawItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), -1, DrawItemState.Default);
-        control.OnDrawItem(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_OnDrawItem_LargeEIndexEmpty_Success()
-    {
-        using var control = new SubCheckedListBox();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new DrawItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Default);
-        control.OnDrawItem(e);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBox_OnDrawItem_LargeEIndexNotEmpty_Success()
-    {
-        using var control = new SubCheckedListBox();
-        control.Items.Add("item1");
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new DrawItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), 2, DrawItemState.Default);
-        control.OnDrawItem(e);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBox_Remove_NotSelectedItems(bool createControl)
-    {
-        using CheckedListBox checkedListBox = new();
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        checkedListBox.Items.AddRange(new object[] { "1", "2", "3" });
-        checkedListBox.SelectedItem = checkedListBox.Items[0];
-
-        Assert.Equal(3, checkedListBox.Items.Count);
-        Assert.Equal(checkedListBox.Items[0], checkedListBox.SelectedItem);
-        Assert.Equal(0, checkedListBox.SelectedIndex);
-        Assert.Equal(1, checkedListBox.SelectedIndices.Count);
-        Assert.Equal(1, checkedListBox.SelectedItems.Count);
-
-        checkedListBox.Items.Remove(checkedListBox.Items[2]);
-
-        Assert.Equal(2, checkedListBox.Items.Count);
-        Assert.Equal(checkedListBox.Items[0], checkedListBox.SelectedItem);
-        Assert.Equal(0, checkedListBox.SelectedIndex);
-        Assert.Equal(1, checkedListBox.SelectedIndices.Count);
-        Assert.Equal(1, checkedListBox.SelectedItems.Count);
-
-        checkedListBox.Items.Remove(checkedListBox.Items[1]);
-
-        Assert.Equal(1, checkedListBox.Items.Count);
-        Assert.Equal(checkedListBox.Items[0], checkedListBox.SelectedItem);
-        Assert.Equal(0, checkedListBox.SelectedIndex);
-        Assert.Equal(1, checkedListBox.SelectedIndices.Count);
-        Assert.Equal(1, checkedListBox.SelectedItems.Count);
-        Assert.Equal(createControl, checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBox_Remove_SelectedItem(bool createControl)
-    {
-        using CheckedListBox checkedListBox = new();
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        checkedListBox.Items.AddRange(new object[] { "1", "2", "3" });
-
-        for (int count = checkedListBox.Items.Count; count > 1; count -= 1)
-        {
-            checkedListBox.SelectedItem = checkedListBox.Items[0];
-
-            Assert.Equal(checkedListBox.Items[0], checkedListBox.SelectedItem);
-            Assert.Equal(0, checkedListBox.SelectedIndex);
-            Assert.Equal(1, checkedListBox.SelectedIndices.Count);
-            Assert.Equal(1, checkedListBox.SelectedItems.Count);
-
-            checkedListBox.Items.Remove(checkedListBox.Items[0]);
-            count -= 1;
-
-            Assert.Equal(count, checkedListBox.Items.Count);
-            Assert.Null(checkedListBox.SelectedItem);
-            Assert.Equal(-1, checkedListBox.SelectedIndex);
-            Assert.Equal(0, checkedListBox.SelectedIndices.Count);
-            Assert.Equal(0, checkedListBox.SelectedItems.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBox_Remove_UncheckedItems(bool createControl)
-    {
-        using CheckedListBox checkedListBox = new();
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        checkedListBox.Items.AddRange(new object[] { "1", "2", "3" });
-
-        checkedListBox.SetItemChecked(0, true);
-
-        for (int count = checkedListBox.Items.Count; count > 1; count -= 1)
-        {
-            Assert.Equal(1, checkedListBox.CheckedIndices.Count);
-            Assert.Equal(1, checkedListBox.CheckedItems.Count);
-
-            checkedListBox.Items.Remove(checkedListBox.Items[2]);
-
-            count -= 1;
-
-            Assert.Equal(count, checkedListBox.Items.Count);
-            Assert.Equal(1, checkedListBox.CheckedIndices.Count);
-            Assert.Equal(1, checkedListBox.CheckedItems.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CheckedListBox_Remove_CheckedItems(bool createControl)
-    {
-        using CheckedListBox checkedListBox = new();
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        checkedListBox.Items.AddRange(new object[] { "1", "2", "3" });
-
-        for (int count = checkedListBox.Items.Count; count > 1; count -= 1)
-        {
-            checkedListBox.SetItemChecked(0, true);
-
-            Assert.Equal(1, checkedListBox.CheckedIndices.Count);
-            Assert.Equal(1, checkedListBox.CheckedItems.Count);
-
-            checkedListBox.Items.Remove(checkedListBox.Items[0]);
-
-            count -= 1;
-
-            Assert.Equal(count, checkedListBox.Items.Count);
-            Assert.Equal(0, checkedListBox.CheckedIndices.Count);
-            Assert.Equal(0, checkedListBox.CheckedItems.Count);
-        }
-    }
-
-    private class SubCheckedListBox : CheckedListBox
-    {
-        public new void RefreshItems() => base.RefreshItems();
-
-        public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ContextMenuStripTests.cs b/src/System.Windows.Forms/tests/UnitTests/ContextMenuStripTests.cs
deleted file mode 100644
index 97120612ac1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ContextMenuStripTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class ContextMenuStripTests
-{
-    [WinFormsFact]
-    public void ContextMenuStrip_Constructor()
-    {
-        using var cms = new ContextMenuStrip();
-
-        Assert.NotNull(cms);
-    }
-
-    [WinFormsFact]
-    public void ContextMenuStrip_ConstructorIContainer()
-    {
-        IContainer nullContainer = null;
-        var mockContainer = new Mock<IContainer>(MockBehavior.Strict);
-        mockContainer.Setup(x => x.Add(It.IsAny<ContextMenuStrip>())).Verifiable();
-
-        // act & assert
-        ArgumentNullException ex = Assert.Throws<ArgumentNullException>(() => new ContextMenuStrip(nullContainer));
-        Assert.Equal("container", ex.ParamName);
-
-        using var cms = new ContextMenuStrip(mockContainer.Object);
-        Assert.NotNull(cms);
-        mockContainer.Verify(x => x.Add(cms));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/DataStreamFromComStreamTests.cs b/src/System.Windows.Forms/tests/UnitTests/DataStreamFromComStreamTests.cs
deleted file mode 100644
index 252772faecc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/DataStreamFromComStreamTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32.System.Com;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataStreamFromComStreamTests
-{
-    [Theory,
-        InlineData(0, 0, 1),
-        InlineData(1, 1, 1)]
-    public unsafe void Write_ThrowsInvalidCount(int bufferSize, int index, int count)
-    {
-        using MemoryStream memoryStream = new();
-        using var stream = ComHelpers.GetComScope<IStream>(new Interop.Ole32.GPStream(memoryStream));
-        using DataStreamFromComStream dataStream = new(stream);
-        Assert.Throws<IOException>(() => dataStream.Write(new byte[bufferSize], index, count));
-    }
-
-    [Theory,
-        InlineData(0, 0, 0),
-        InlineData(0, 0, -1),
-        InlineData(1, 1, 0),
-        InlineData(1, 1, -1)]
-    public unsafe void Write_DoesNotThrowCountZeroOrLess(int bufferSize, int index, int count)
-    {
-        using MemoryStream memoryStream = new();
-        using var stream = ComHelpers.GetComScope<IStream>(new Interop.Ole32.GPStream(memoryStream));
-        using DataStreamFromComStream dataStream = new(stream);
-        dataStream.Write(new byte[bufferSize], index, count);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/DpiHelperTests.cs b/src/System.Windows.Forms/tests/UnitTests/DpiHelperTests.cs
deleted file mode 100644
index 3cc2dcb4eb9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/DpiHelperTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DpiHelperTests
-{
-    [Theory]
-    [IntegerData<int>]
-    public void DpiHelper_LogicalToDeviceUnits(int value)
-    {
-        var expected = Math.Round(value * (DpiHelper.DeviceDpi / DpiHelper.LogicalDpi));
-
-        Assert.Equal(expected, DpiHelper.LogicalToDeviceUnits(value));
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData))]
-    public void DpiHelper_LogicalToDeviceUnitsSize(Size value)
-    {
-        var expected = new Size((int)Math.Round(value.Width * (DpiHelper.DeviceDpi / DpiHelper.LogicalDpi)),
-                                 (int)Math.Round(value.Height * (DpiHelper.DeviceDpi / DpiHelper.LogicalDpi)));
-
-        Assert.Equal(expected, DpiHelper.LogicalToDeviceUnits(value));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ExceptionHandlingTests.cs b/src/System.Windows.Forms/tests/UnitTests/ExceptionHandlingTests.cs
deleted file mode 100644
index 6e86da6e608..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ExceptionHandlingTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ExceptionHandlingTests
-{
-    [WinFormsFact]
-    public void ValidateMessageLoopExceptionsAreThrown()
-    {
-        using ThrowControl control = new();
-        control.CreateControl();
-        Action action = () =>
-        {
-            PInvoke.PostMessage(control, 9876);
-            Application.DoEvents();
-        };
-
-        Assert.Throws<InvalidOperationException>(() => action());
-    }
-
-    public class ThrowControl : Control
-    {
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == 9876)
-            {
-                throw new InvalidOperationException();
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/GlobalUsings.cs b/src/System.Windows.Forms/tests/UnitTests/GlobalUsings.cs
deleted file mode 100644
index c05ff00b2a1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/GlobalUsings.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-global using System.Diagnostics;
-global using System.Windows.Forms;
-global using Windows.Win32;
-global using Windows.Win32.Foundation;
-global using Windows.Win32.Graphics.Gdi;
-global using Windows.Win32.System.Memory;
-global using Windows.Win32.UI.Controls;
-global using Windows.Win32.UI.HiDpi;
-global using Windows.Win32.UI.Shell;
-global using Windows.Win32.UI.WindowsAndMessaging;
-global using Xunit;
diff --git a/src/System.Windows.Forms/tests/UnitTests/KeyboardTooltipStateMachineTests.cs b/src/System.Windows.Forms/tests/UnitTests/KeyboardTooltipStateMachineTests.cs
deleted file mode 100644
index bc81976200e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/KeyboardTooltipStateMachineTests.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class KeyboardTooltipStateMachineTests
-{
-    [WinFormsFact]
-    public void HookToolTip()
-    {
-        using ToolTip toolTip = new();
-        var mock = new Mock<IKeyboardToolTip>(MockBehavior.Strict);
-        IKeyboardToolTip keyboardToolTip = mock.Object;
-
-        // Validate we don't get OnHooked if AllowsToolTip is false
-        mock.Setup(m => m.AllowsToolTip()).Returns(false);
-        mock.Setup(m => m.OnHooked(toolTip));
-        KeyboardToolTipStateMachine.Instance.Hook(keyboardToolTip, toolTip);
-        mock.Verify(m => m.AllowsToolTip());
-
-        mock.Reset();
-
-        // Now validate we get OnHooked if AllowsToolTip is true.
-        mock.Setup(m => m.AllowsToolTip()).Returns(true);
-        mock.Setup(m => m.OnHooked(toolTip));
-        KeyboardToolTipStateMachine.Instance.Hook(keyboardToolTip, toolTip);
-        mock.Verify(m => m.AllowsToolTip());
-        mock.Verify(m => m.OnHooked(toolTip), Times.Once);
-
-        mock.Reset();
-
-        // Validate we don't get OnUnhooked if AllowsToolTip is false.
-        mock.Setup(m => m.AllowsToolTip()).Returns(false);
-        mock.Setup(m => m.OnUnhooked(toolTip));
-        KeyboardToolTipStateMachine.Instance.Unhook(keyboardToolTip, toolTip);
-        mock.Verify(m => m.AllowsToolTip());
-
-        mock.Reset();
-
-        // Finally validate we get OnUnhooked if AllowsToolTip is true.
-        mock.Setup(m => m.AllowsToolTip()).Returns(true);
-        mock.Setup(m => m.OnUnhooked(toolTip));
-        KeyboardToolTipStateMachine.Instance.Unhook(keyboardToolTip, toolTip);
-        mock.Verify(m => m.AllowsToolTip());
-        mock.Verify(m => m.OnUnhooked(toolTip), Times.Once);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.ControlKey)]
-    [InlineData(Keys.Escape)]
-    [InlineData(Keys.ControlKey | Keys.ShiftKey | Keys.F10)]
-    public void KeyboardTooltipStateMachine_DismissalKeyUp_NonPersistent_NotDismissed(Keys keys)
-    {
-        using TestControl control = new();
-        using ToolTip toolTip = new();
-
-        control.CreateControl();
-        _ = toolTip.Handle;
-
-        toolTip.SetToolTip(control, "Non-persistent");
-        toolTip.AutoPopDelay = 888;
-
-        // Simulate that the toolTip is shown.
-        KeyboardToolTipStateMachine instance = KeyboardToolTipStateMachine.Instance;
-        instance.TestAccessor().Dynamic._currentTool = control;
-        instance.TestAccessor().Dynamic._currentState = KeyboardToolTipStateMachine.SmState.Shown;
-
-        control.SimulateKeyUp(keys);
-
-        IKeyboardToolTip currentTool = instance.TestAccessor().Dynamic._currentTool;
-        string currentState = instance.TestAccessor().Dynamic._currentState.ToString();
-
-        Assert.Equal(control, currentTool);
-        Assert.Equal("Shown", currentState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.ControlKey, true)]
-    [InlineData(Keys.Escape, true)]
-    [InlineData(Keys.ControlKey | Keys.ShiftKey | Keys.F10, true)]
-    [InlineData(Keys.ControlKey, false)]
-    [InlineData(Keys.Escape, false)]
-    [InlineData(Keys.ControlKey | Keys.ShiftKey | Keys.F10, false)]
-    public void KeyboardTooltipStateMachine_DismissalKeyUp(Keys keys, bool isPersistent)
-    {
-        using TestControl control = new();
-        using ToolTip toolTip = new();
-
-        control.CreateControl();
-        _ = toolTip.Handle;
-
-        toolTip.SetToolTip(control, "test");
-        toolTip.IsPersistent = isPersistent;
-
-        // Simulate that the toolTip is shown.
-        KeyboardToolTipStateMachine instance = KeyboardToolTipStateMachine.Instance;
-        instance.TestAccessor().Dynamic._currentTool = control;
-        instance.TestAccessor().Dynamic._currentState = KeyboardToolTipStateMachine.SmState.Shown;
-
-        control.SimulateKeyUp(keys);
-
-        IKeyboardToolTip currentTool = instance.TestAccessor().Dynamic._currentTool;
-        string currentState = instance.TestAccessor().Dynamic._currentState.ToString();
-
-        Assert.Equal(isPersistent && OsVersion.IsWindows11_OrGreater() ? "Hidden" : "Shown", currentState);
-    }
-
-    private class TestControl : Control
-    {
-        public void SimulateKeyUp(Keys keys) => base.OnKeyUp(new KeyEventArgs(keys));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/LinkLabelTests.cs b/src/System.Windows.Forms/tests/UnitTests/LinkLabelTests.cs
deleted file mode 100644
index 9840bd0dec9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/LinkLabelTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class LinkLabelTests
-{
-    [WinFormsFact]
-    public void LinkLabel_Constructor()
-    {
-        using var label = new LinkLabel();
-
-        Assert.NotNull(label);
-        Assert.True(label.LinkArea.IsEmpty);
-        Assert.Equal(0, label.LinkArea.Start);
-        Assert.Equal(0, label.LinkArea.Length);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/MaskedTextBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/MaskedTextBoxTests.cs
deleted file mode 100644
index 38c838dcc62..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/MaskedTextBoxTests.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class MaskedTextBoxTests
-{
-    [WinFormsFact]
-    public void MaskedTextBox_Constructor()
-    {
-        using var mtb = new MaskedTextBox();
-
-        Assert.NotNull(mtb);
-    }
-
-    [WinFormsFact]
-    public void MaskedTextBox_ConstructorString()
-    {
-        using var mtb = new MaskedTextBox("Hello World!");
-
-        Assert.NotNull(mtb);
-    }
-
-    [WinFormsFact]
-    public void MaskedTextBox_ConstructorMaskedTextProvider()
-    {
-        using var mtb = new MaskedTextBox(new MaskedTextProvider("Hello World!"));
-
-        Assert.NotNull(mtb);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ModuleInitializer.cs b/src/System.Windows.Forms/tests/UnitTests/ModuleInitializer.cs
deleted file mode 100644
index 52f4acd7bb1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ModuleInitializer.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-
-namespace System.Windows.Forms.Tests;
-
-public class ModuleInitializer
-{
-    [ModuleInitializer]
-    public static void InitializeModule()
-    {
-        // We do not want thread exceptions swallowed during test runs, or worse, popping the exception dialog,
-        // which can hang the test run. Setting this switch will force throwing of exceptions that happen during
-        // handling of a Windows message.
-        AppContext.SetSwitch("System.Windows.Forms.DoNotCatchUnhandledExceptions", isEnabled: true);
-
-        Application.EnableVisualStyles();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/NumericUpDownTests.cs b/src/System.Windows.Forms/tests/UnitTests/NumericUpDownTests.cs
deleted file mode 100644
index a86f0124a2b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/NumericUpDownTests.cs
+++ /dev/null
@@ -1,224 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public class NumericUpDownTests
-{
-    [WinFormsFact]
-    public void NumericUpDown_Constructor()
-    {
-        using var nud = new NumericUpDown();
-
-        Assert.NotNull(nud);
-        Assert.Equal("0", nud.Text);
-    }
-
-    [WinFormsFact]
-    public void NumericUpDown_VisualStyles_off_BasicRendering_ControlEnabled()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var form = new Form();
-        using var upDown = new NumericUpDown();
-
-        form.Controls.Add(upDown);
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Assert.Equal(new Rectangle(0, 0, 120, 23), upDown.Bounds);
-
-        // The rendering here is the "fill" for the background around the child edit control, which
-        // doesn't match up to the main control's bounds.
-        upDown.PrintToMetafile(emf);
-        emf.Validate(
-            state,
-            Validate.Rectangle(
-                new Rectangle(1, 1, 98, 17),
-                State.Pen(2, upDown.BackColor, PEN_STYLE.PS_SOLID)));
-
-        // Printing the main control doesn't get the redraw for the child controls on the first render,
-        // directly hitting the up/down button subcontrol.
-        using var emfButtons = new EmfScope();
-        state = new DeviceContextState(emfButtons);
-        upDown.Controls[0].PrintToMetafile(emfButtons);
-
-        // This is the "fill" line under the up/down arrows
-        emfButtons.Validate(
-            state,
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHDIBITS),
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHDIBITS),
-            Validate.LineTo(
-                (0, 18), (16, 18),
-                State.Pen(1, upDown.BackColor, PEN_STYLE.PS_SOLID)));
-    }
-
-    [WinFormsFact]
-    public void NumericUpDown_VisualStyles_off_BasicRendering_ControlDisabled()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var form = new Form();
-        using var upDown = new NumericUpDown();
-
-        form.Controls.Add(upDown);
-
-        // Check the disabled state
-        upDown.Enabled = false;
-
-        using var emfDisabled = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emfDisabled);
-        upDown.PrintToMetafile(emfDisabled);
-
-        emfDisabled.Validate(
-            state,
-            Validate.Rectangle(
-                new Rectangle(0, 0, 99, 18),
-                State.Pen(1, upDown.BackColor, PEN_STYLE.PS_SOLID)),
-            Validate.Rectangle(
-                new Rectangle(1, 1, 97, 16),
-                State.Pen(1, SystemColors.Control, PEN_STYLE.PS_SOLID)),
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHDIBITS),
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_STRETCHDIBITS),
-            Validate.LineTo(
-                (0, 18), (16, 18),
-                State.Pen(1, upDown.BackColor, PEN_STYLE.PS_SOLID)));
-    }
-
-    [WinFormsFact(Skip = "TODO, refer to https://github.com/dotnet/winforms/issues/4212")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/4212")]
-    public void NumericUpDown_VisualStyles_on_BasicRendering()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var form = new Form();
-        using var upDown = new NumericUpDown();
-
-        form.Controls.Add(upDown);
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Assert.Equal(new Rectangle(0, 0, 120, 23), upDown.Bounds);
-
-        // The rendering here is the "fill" for the background around the child edit control, which
-        // doesn't match up to the main control's bounds.
-        upDown.PrintToMetafile(emf);
-
-        /*
-
-        [ENHMETAHEADER] Bounds: {0, 0, 119, 22 (LTRB)} Device Size: {Width=3840, Height=2160} Header Size: 108
-        [EMRSETBKCOLOR] Color: [R=171, G=173, B=179]
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, 0, 22 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, 0, 0 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 22, 0, 22 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRSETBKCOLOR] Color: [R=171, G=173, B=179]
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, 0, 0 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {119, 0, 119, 0 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, 119, 0 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRSETBKCOLOR] Color: [R=171, G=173, B=179]
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {119, 0, 119, 22 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {119, 0, 119, 0 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {119, 22, 119, 22 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRSETBKCOLOR] Color: [R=171, G=173, B=179]
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 22, 0, 22 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {119, 22, 119, 22 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 22, 119, 22 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMREXTTEXTOUTW] Bounds: {0, 0, -1, -1 (LTRB)} Text: ''
-        [EMRSETBKCOLOR] Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRCREATEPEN] Index: 1 Style: ENDCAP_ROUND Width: {X=1,Y=0} Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRSETROP2] Mode: R2_COPYPEN
-        [EMRSELECTOBJECT] StockObject: NULL_BRUSH
-        [EMRRECTANGLE] RECT: {1, 1, 102, 21 (LTRB)}
-        [EMRSELECTOBJECT] StockObject: WHITE_BRUSH
-        [EMRSELECTOBJECT] StockObject: BLACK_PEN
-        [EMRDELETEOBJECT] Index: 1
-        [EMREOF]
-
-         */
-
-        // Printing the main control doesn't get the redraw for the child controls on the first render,
-        // directly hitting the up/down button subcontrol.
-
-        using var emfButtons = new EmfScope();
-        state = new DeviceContextState(emfButtons);
-        upDown.Controls[0].PrintToMetafile(emfButtons);
-
-        /*
-
-        [ENHMETAHEADER] Bounds: {0, 0, 16, 20 (LTRB)} Device Size: {Width=3840, Height=2160} Header Size: 108
-        [EMRINTERSECTCLIPRECT] RECT: {0, 0, 16, 10 (LTRB)}
-        [EMRBITBLT] Bounds: {0, 0, 15, 9 (LTRB)} Destination: {0, 0, 16, 10 (LTRB)} Rop: SRCCOPY Source DC Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 16, 21 (LTRB)} Rects: 1 Rect index 0: {0, 0, 16, 21 (LTRB)}
-        [EMRINTERSECTCLIPRECT] RECT: {4, 2, 11, 8 (LTRB)}
-        [EMRALPHABLEND]
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 16, 21 (LTRB)} Rects: 1 Rect index 0: {0, 0, 16, 21 (LTRB)}
-        [EMRINTERSECTCLIPRECT] RECT: {0, 10, 16, 20 (LTRB)}
-        [EMRBITBLT] Bounds: {0, 10, 15, 19 (LTRB)} Destination: {0, 10, 16, 20 (LTRB)} Rop: SRCCOPY Source DC Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 16, 21 (LTRB)} Rects: 1 Rect index 0: {0, 0, 16, 21 (LTRB)}
-        [EMRINTERSECTCLIPRECT] RECT: {4, 12, 11, 18 (LTRB)}
-        [EMRALPHABLEND]
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 16, 21 (LTRB)} Rects: 1 Rect index 0: {0, 0, 16, 21 (LTRB)}
-        [EMRSETROP2] Mode: R2_COPYPEN
-        [EMRSETBKMODE] Mode: BKMODE_TRANSPARENT
-        [EMRCREATEPEN] Index: 1 Style: ENDCAP_ROUND Width: {X=1,Y=0} Color: [R=255, G=255, B=255] (COLOR_WINDOW, COLOR_HIGHLIGHTTEXT, COLOR_BTNHIGHLIGHT)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRMOVETOEX] Point: {X=0,Y=20}
-        [EMRLINETO] Point: {X=16,Y=20}
-        [EMRMOVETOEX] Point: {X=0,Y=0}
-        [EMRSELECTOBJECT] StockObject: BLACK_PEN
-        [EMRSETBKMODE] Mode: BKMODE_OPAQUE
-        [EMRDELETEOBJECT] Index: 1
-        [EMREOF]
-
-        */
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/Properties/launchSettings.json b/src/System.Windows.Forms/tests/UnitTests/Properties/launchSettings.json
deleted file mode 100644
index 7360e90ee51..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/Properties/launchSettings.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "profiles": {
-    "System.Windows.Forms.Tests": {
-      "commandName": "Project",
-      "nativeDebugging": true
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/UnitTests/SRCategoryAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/SRCategoryAttributeTests.cs
deleted file mode 100644
index c263cdf6049..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/SRCategoryAttributeTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SRCategoryAttributeTests
-{
-    [Fact]
-    public void VerifyCategoryForValidCategoryAttribute()
-    {
-        SRCategoryAttribute srCategoryAttribute = new SRCategoryAttribute(nameof(SR.CatAccessibility));
-        Assert.True(string.Equals(srCategoryAttribute.Category, SR.CatAccessibility, StringComparison.Ordinal));
-    }
-
-    [Fact]
-    public void InvalidCategoryShouldReturnCategoryNameAsIs()
-    {
-        const string fakeCategory = "fakeCategory";
-        SRCategoryAttribute srCategoryAttribute = new SRCategoryAttribute(fakeCategory);
-        Assert.True(string.Equals(srCategoryAttribute.Category, fakeCategory, StringComparison.Ordinal));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/SRDescriptionAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/SRDescriptionAttributeTests.cs
deleted file mode 100644
index fac81f74a39..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/SRDescriptionAttributeTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SRDescriptionAttributeTests
-{
-    [Fact]
-    public void VerifyDescriptionAttributeValue()
-    {
-        SRDescriptionAttribute srDescriptionAttribute = new SRDescriptionAttribute(nameof(SR.AboutBoxDesc));
-        Assert.True(string.Equals(srDescriptionAttribute.Description, SR.AboutBoxDesc, StringComparison.Ordinal));
-
-        // Getting srDescriptionAttribute.Description again should also return description value
-        Assert.True(string.Equals(srDescriptionAttribute.Description, SR.AboutBoxDesc, StringComparison.Ordinal));
-    }
-
-    [Fact]
-    public void InvalidDescriptionAttributeShouldReturnNull()
-    {
-        SRDescriptionAttribute srDescriptionAttribute = new SRDescriptionAttribute("fake");
-        Assert.Null(srDescriptionAttribute.Description);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/SerializableAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/SerializableAttributeTests.cs
deleted file mode 100644
index e539ee8b30c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/SerializableAttributeTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests.Serialization;
-
-// NB: doesn't require thread affinity
-public class SerializableAttributeTests
-{
-    [Fact]
-    public void EnsureSerializableAttribute()
-    {
-        BinarySerialization.EnsureSerializableAttribute(
-            typeof(ListViewItem).Assembly,
-            new HashSet<string>
-            {
-                // This state is serialized to communicate to the native control
-                { typeof(AxHost.State).FullName },
-                // Following classes are participating in resx serialization scenarios.
-                { typeof(ImageListStreamer).FullName },
-                { typeof(LinkArea).FullName },
-                { typeof(ListViewGroup).FullName },
-                { typeof(ListViewItem).FullName },
-                { typeof(ListViewItem.ListViewSubItem).FullName },
-                { "System.Windows.Forms.ListViewItem+ListViewSubItem+SubItemStyle" },  // Private type.
-                { typeof(OwnerDrawPropertyBag).FullName },
-                { typeof(Padding).FullName },
-                { typeof(TreeNode).FullName },
-                { typeof(TableLayoutSettings).FullName },
-            });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/SerializableTypesTests.cs b/src/System.Windows.Forms/tests/UnitTests/SerializableTypesTests.cs
deleted file mode 100644
index c7ce497296b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/SerializableTypesTests.cs
+++ /dev/null
@@ -1,412 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Text;
-using static System.Windows.Forms.ImageList;
-using static System.Windows.Forms.ListViewItem;
-using static System.Windows.Forms.TableLayoutSettings;
-using static Interop;
-
-namespace System.Windows.Forms.Tests.Serialization;
-
-// NB: doesn't require thread affinity
-public class SerializableTypesTests
-{
-    [Fact]
-    public void AxHostState_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        string payload = "abc";
-        string licenseKey = "licenseKey";
-        string netBlob;
-        AxHost.State state;
-
-        using (var stream = new MemoryStream(256))
-        {
-            var bytes = Encoding.UTF8.GetBytes(payload);
-            using (var writer = new BinaryWriter(stream))
-            {
-                writer.Write(bytes.Length);
-                writer.Write(bytes);
-                stream.Seek(0, SeekOrigin.Begin);
-
-                state = new AxHost.State(stream, 1, true, licenseKey);
-                netBlob = BinarySerialization.ToBase64String(state);
-            }
-        }
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicAxHostState);
-
-        void ValidateResult(string blob)
-        {
-            AxHost.State result = BinarySerialization.EnsureDeserialize<AxHost.State>(blob);
-
-            Assert.Null(result.GetPropBag());
-            Assert.Null(state.GetPropBag());
-
-            Assert.Equal(1, result.Type);
-            Assert.Equal(1, state.Type);
-
-            Assert.True(result.ManualUpdate);
-            Assert.True(state.ManualUpdate);
-
-            Assert.Equal(licenseKey, result.LicenseKey);
-            Assert.Equal(licenseKey, state.LicenseKey);
-
-            var streamOut = result.GetStream() as Ole32.GPStream;
-            Assert.NotNull(streamOut);
-            Stream bufferStream = streamOut.GetDataStream();
-            byte[] buffer = new byte[3];
-            bufferStream.Read(buffer, 0, buffer.Length);
-            Assert.Equal(payload, Encoding.UTF8.GetString(buffer));
-        }
-    }
-
-    [Fact]
-    public void ImageListStreamer_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        string netBlob;
-
-        using (var imageList = new ImageList()
-            {
-                ImageSize = new Size(16, 16),
-                TransparentColor = Color.White
-            })
-        {
-            imageList.Images.Add(new Bitmap(16, 16));
-            netBlob = BinarySerialization.ToBase64String(imageList.ImageStream);
-        }
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicImageListStreamer);
-
-        void ValidateResult(string blob)
-        {
-            using ImageListStreamer result = BinarySerialization.EnsureDeserialize<ImageListStreamer>(blob);
-            using (NativeImageList nativeImageList = result.GetNativeImageList())
-            {
-                Assert.True(PInvoke.ImageList.GetIconSize(new HandleRef<HIMAGELIST>(this, nativeImageList.HIMAGELIST), out int x, out int y));
-                Assert.Equal(16, x);
-                Assert.Equal(16, y);
-                Assert.True(PInvoke.ImageList.GetImageInfo(new HandleRef<HIMAGELIST>(this, nativeImageList.HIMAGELIST), 0, out IMAGEINFO imageInfo));
-                Assert.False(imageInfo.hbmImage.IsNull);
-            }
-        }
-    }
-
-    [Fact]
-    public void LinkArea_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        var linkArea = new LinkArea(5, 7);
-        var netBlob = BinarySerialization.ToBase64String(linkArea);
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicLinkArea);
-
-        void ValidateResult(string blob)
-        {
-            LinkArea result = BinarySerialization.EnsureDeserialize<LinkArea>(blob);
-
-            Assert.Equal(linkArea, result);
-        }
-    }
-
-    [Fact]
-    public void ListViewGroup_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        var listViewGroup = new ListViewGroup("Header", HorizontalAlignment.Center)
-        {
-            Tag = "Tag",
-            Name = "GroupName",
-        };
-
-        listViewGroup.Items.Add(new ListViewItem("Item"));
-
-        var netBlob = BinarySerialization.ToBase64String(listViewGroup);
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicListViewGroup);
-
-        static void ValidateResult(string blob)
-        {
-            ListViewGroup result = BinarySerialization.EnsureDeserialize<ListViewGroup>(blob);
-
-            Assert.Equal("Header", result.Header);
-            Assert.Equal(HorizontalAlignment.Center, result.HeaderAlignment);
-            Assert.Equal("Tag", result.Tag);
-            Assert.Equal("GroupName", result.Name);
-            var item = Assert.Single(result.Items) as ListViewItem;
-            Assert.NotNull(item);
-            Assert.Equal("Item", item.Text);
-        }
-    }
-
-    [Fact]
-    public void ListViewItem_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        string netBlob;
-
-        using (var font = new Font(FontFamily.GenericSansSerif, 9f))
-        {
-            var listViewItem = new ListViewItem("Item1", 0)
-            {
-                ForeColor = Color.White,
-                BackColor = Color.Black,
-                Font = font,
-                Checked = true
-            };
-
-            netBlob = BinarySerialization.ToBase64String(listViewItem);
-        }
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicListViewItem);
-
-        static void ValidateResult(string blob)
-        {
-            ListViewItem result = BinarySerialization.EnsureDeserialize<ListViewItem>(blob);
-
-            Assert.Equal("Item1", result.Text);
-            Assert.Equal(0, result.ImageIndex);
-            Assert.Empty(result.ImageKey);
-            var item = Assert.Single(result.SubItems) as ListViewSubItem;
-            Assert.Equal("Item1", item.Text);
-            Assert.Equal(Color.Black, result.BackColor);
-            Assert.Equal(Color.White, result.ForeColor);
-            Assert.True(result.Checked);
-            Assert.Equal(FontFamily.GenericSansSerif.Name, result.Font.FontFamily.Name);
-            Assert.True(result.UseItemStyleForSubItems);
-            Assert.Null(result.Group);
-
-            Assert.Null(result.Tag);
-            Assert.Null(result.ImageList);
-            Assert.Equal(-1, result.Index);
-            Assert.Equal(0, result.IndentCount);
-        }
-    }
-
-    [Fact]
-    public void ListViewSubItemAndSubItemStyle_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        string netBlob;
-
-        using (var font = new Font(FontFamily.GenericSansSerif, 9f))
-        {
-            var listViewSubItem = new ListViewSubItem(
-                new ListViewItem(),
-                "SubItem1",
-                foreColor: Color.White,
-                backColor: Color.Black,
-                font)
-            {
-                Tag = "UserData"
-            };
-
-            netBlob = BinarySerialization.ToBase64String(listViewSubItem);
-        }
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicListViewSubItem);
-
-        static void ValidateResult(string blob)
-        {
-            ListViewSubItem result = BinarySerialization.EnsureDeserialize<ListViewSubItem>(blob);
-
-            Assert.Equal("SubItem1", result.Text);
-            Assert.True(result.CustomStyle);
-            Assert.True(result.CustomForeColor);
-            Assert.True(result.CustomBackColor);
-            Assert.True(result.CustomFont);
-            Assert.Equal(Color.White, result.ForeColor);
-            Assert.Equal(Color.Black, result.BackColor);
-            Assert.Equal(FontFamily.GenericSansSerif.Name, result.Font.FontFamily.Name);
-            Assert.Null(result.Tag); // UserData is wiped on deserialization
-        }
-    }
-
-    [Fact]
-    public void Padding_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        var padding = new Padding(1, 2, 3, 4);
-        var netBlob = BinarySerialization.ToBase64String(padding);
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicPadding);
-
-        void ValidateResult(string blob)
-        {
-            Padding result = BinarySerialization.EnsureDeserialize<Padding>(blob);
-
-            Assert.Equal(padding, result);
-        }
-    }
-
-    [Fact]
-    public void TableLayoutSettings_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-
-        string netBlob;
-
-        using (var tableLayoutPanel = new TableLayoutPanel
-        {
-            Name = "table",
-            CellBorderStyle = TableLayoutPanelCellBorderStyle.OutsetDouble,
-            ColumnCount = 3,
-            RowCount = 2
-        })
-        {
-            tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50));
-            tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50));
-            tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50));
-            tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Absolute, 20));
-            tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Absolute, 30));
-
-            var button00_10 = new Button() { Name = "button00_10" };
-            tableLayoutPanel.Controls.Add(button00_10, 0, 0);
-            tableLayoutPanel.SetColumnSpan(button00_10, 2);
-            var label20_21 = new Label() { Name = "label20_21" };
-            tableLayoutPanel.Controls.Add(label20_21, 2, 0);
-            tableLayoutPanel.SetRowSpan(label20_21, 2);
-            tableLayoutPanel.Controls.Add(new RadioButton() { Name = "radioButton01" }, 0, 1);
-            tableLayoutPanel.Controls.Add(new CheckBox() { Name = "checkBox11" }, 1, 1);
-
-            netBlob = BinarySerialization.ToBase64String(tableLayoutPanel.LayoutSettings as TableLayoutSettings);
-        }
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicTableLayoutSettings);
-
-        void ValidateResult(string blob)
-        {
-            TableLayoutSettings result = BinarySerialization.EnsureDeserialize<TableLayoutSettings>(blob);
-
-            Assert.NotNull(result);
-            Assert.True(result.IsStub); // This class is not associated with an owner control.
-            Assert.Equal(TableLayoutPanelCellBorderStyle.None, result.CellBorderStyle); // This property is not serialized.
-            Assert.NotNull(result.LayoutEngine);
-            // These values will be accessible when the owner is set.
-            Assert.Throws<NullReferenceException>(() => result.CellBorderWidth);
-            Assert.Throws<NullReferenceException>(() => result.ColumnCount);
-            Assert.Throws<NullReferenceException>(() => result.GrowStyle);
-            Assert.Throws<NullReferenceException>(() => result.RowCount);
-            Assert.Equal(3, result.ColumnStyles.Count);
-            Assert.Equal(2, result.RowStyles.Count);
-            Assert.Equal(SizeType.Percent, result.ColumnStyles[0].SizeType);
-            Assert.Equal(SizeType.Percent, result.ColumnStyles[1].SizeType);
-            Assert.Equal(SizeType.Percent, result.ColumnStyles[2].SizeType);
-            Assert.Equal(SizeType.Absolute, result.RowStyles[0].SizeType);
-            Assert.Equal(20, result.RowStyles[0].Height);
-            Assert.Equal(30, result.RowStyles[1].Height);
-
-            List<ControlInformation> controls = result.GetControlsInformation();
-            ValidateControlInformation("button00_10", 0, 0, 2, 1, controls[0]);
-            ValidateControlInformation("label20_21", 2, 0, 1, 2, controls[1]);
-            ValidateControlInformation("radioButton01", 0, 1, 1, 1, controls[2]);
-            ValidateControlInformation("checkBox11", 1, 1, 1, 1, controls[3]);
-
-            void ValidateControlInformation(string name, int column, int row, int columnSpan, int rowSpan, ControlInformation control)
-            {
-                Assert.Equal(name, control.Name);
-                Assert.Equal(column, control.Column);
-                Assert.Equal(row, control.Row);
-                Assert.Equal(columnSpan, control.ColumnSpan);
-                Assert.Equal(rowSpan, control.RowSpan);
-            }
-        }
-    }
-
-    [Fact]
-    public void TreeNodeAndPropertyBag_RoundTripAndExchangeWithNet()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        var children = new TreeNode[] { new TreeNode("node2"), new TreeNode("node3") };
-        TreeNode treeNodeIn = new TreeNode("node1", 1, 2, children)
-        {
-            ToolTipText = "tool tip text",
-            Name = "node1",
-            SelectedImageKey = "key",
-            Checked = true,
-            BackColor = Color.Yellow, // Colors and Font are serialized into the property bag.
-            ForeColor = Color.Green,
-            NodeFont = new Font(FontFamily.GenericSansSerif, 9f)
-        };
-
-        var netBlob = BinarySerialization.ToBase64String(treeNodeIn);
-
-        // ensure we can deserialise NET serialised data and continue to match the payload
-        ValidateResult(netBlob);
-        // ensure we can deserialise NET Fx serialised data and continue to match the payload
-        ValidateResult(ClassicTreeNode);
-
-        static void ValidateResult(string blob)
-        {
-            TreeNode result = BinarySerialization.EnsureDeserialize<TreeNode>(blob);
-
-            Assert.Equal("node1", result.Text);
-            Assert.Equal(-1, result.ImageIndex); // No image list
-            Assert.Equal("key", result.SelectedImageKey);
-            Assert.Equal(2, result.childNodes.Count);
-            Assert.Equal("node2", result.FirstNode.Text);
-            Assert.Equal("node3", result.LastNode.Text);
-            Assert.Equal("tool tip text", result.ToolTipText);
-            Assert.Equal("node1", result.Name);
-            Assert.True(result.Checked);
-
-            Assert.Equal(Color.Yellow, result.BackColor);
-            Assert.Equal(Color.Green, result.ForeColor);
-            Assert.Equal(FontFamily.GenericSansSerif.Name, result.NodeFont.FontFamily.Name);
-        }
-    }
-
-    private const string ClassicAxHostState =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5BeEhvc3QrU3RhdGUBAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIgAAAAIBAAAAAQAAAAEKAAAAbGljZW5zZUtleQAAAAADAAAAYWJjCw==";
-
-    public const string ClassicImageListStreamer =
-        "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";
-
-    private const string ClassicLinkArea =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaW5rQXJlYQIAAAAFc3RhcnQGbGVuZ3RoAAAICAIAAAAFAAAABwAAAAs=";
-
-    private const string ClassicListViewGroup =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACJTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0dyb3VwBgAAAAZIZWFkZXIPSGVhZGVyQWxpZ25tZW50A1RhZwROYW1lCkl0ZW1zQ291bnQFSXRlbTABBAEBAAQoU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFsaWdubWVudAIAAAAIIVN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbQIAAAACAAAABgMAAAAGSGVhZGVyBfz///8oU3lzdGVtLldpbmRvd3MuRm9ybXMuSG9yaXpvbnRhbEFsaWdubWVudAEAAAAHdmFsdWVfXwAIAgAAAAIAAAAGBQAAAANUYWcGBgAAAAlHcm91cE5hbWUBAAAACQcAAAAMCAAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFBwAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0IAAAABFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5bGVGb3JTdWJJdGVtcwVHcm91cAEABAAEBAAECBRTeXN0ZW0uRHJhd2luZy5Db2xvcggAAAABE1N5c3RlbS5EcmF3aW5nLkZvbnQIAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yCAAAAAEiU3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdHcm91cAIAAAACAAAABgkAAAAESXRlbf////8F9v///xRTeXN0ZW0uRHJhd2luZy5Db2xvcgQAAAAEbmFtZQV2YWx1ZQprbm93bkNvbG9yBXN0YXRlAQAAAAkHBwgAAAAKAAAAAAAAAAAYAAEAAAkLAAAAAfT////2////CgAAAAAAAAAAGgABAAEJAQAAAAULAAAAE1N5c3RlbS5EcmF3aW5nLkZvbnQEAAAABE5hbWUEU2l6ZQVTdHlsZQRVbml0AQAEBAsYU3lzdGVtLkRyYXdpbmcuRm9udFN0eWxlCAAAABtTeXN0ZW0uRHJhd2luZy5HcmFwaGljc1VuaXQIAAAACAAAAAYOAAAAFE1pY3Jvc29mdCBTYW5zIFNlcmlmAAAEQQXx////GFN5c3RlbS5EcmF3aW5nLkZvbnRTdHlsZQEAAAAHdmFsdWVfXwAICAAAAAAAAAAF8P///xtTeXN0ZW0uRHJhd2luZy5HcmFwaGljc1VuaXQBAAAAB3ZhbHVlX18ACAgAAAADAAAACw==";
-
-    private const string ClassicListViewItem =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkMAwAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAACFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0HAAAABFRleHQKSW1hZ2VJbmRleAlCYWNrQ29sb3IHQ2hlY2tlZARGb250CUZvcmVDb2xvchdVc2VJdGVtU3R5bGVGb3JTdWJJdGVtcwEABAAEBAAIFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAAAAETU3lzdGVtLkRyYXdpbmcuRm9udAMAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAAQIAAAAGBAAAAAVJdGVtMQAAAAAF+////xRTeXN0ZW0uRHJhd2luZy5Db2xvcgQAAAAEbmFtZQV2YWx1ZQprbm93bkNvbG9yBXN0YXRlAQAAAAkHBwMAAAAKAAAAAAAAAAAjAAEAAQkGAAAAAfn////7////CgAAAAAAAAAApAABAAEFBgAAABNTeXN0ZW0uRHJhd2luZy5Gb250BAAAAAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZvbnRTdHlsZQMAAAAbU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AwAAAAMAAAAGCAAAABRNaWNyb3NvZnQgU2FucyBTZXJpZgAAEEEF9////xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18ACAMAAAAAAAAABfb///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgDAAAAAwAAAAs=";
-
-    private const string ClassicListViewSubItem =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAADFTeXN0ZW0uV2luZG93cy5Gb3Jtcy5MaXN0Vmlld0l0ZW0rTGlzdFZpZXdTdWJJdGVtBAAAAAR0ZXh0BG5hbWUFc3R5bGUIdXNlckRhdGEBAQQCPlN5c3RlbS5XaW5kb3dzLkZvcm1zLkxpc3RWaWV3SXRlbStMaXN0Vmlld1N1Ykl0ZW0rU3ViSXRlbVN0eWxlAgAAAAIAAAAGAwAAAAhTdWJJdGVtMQoJBAAAAAYFAAAACFVzZXJEYXRhDAYAAABRU3lzdGVtLkRyYXdpbmcsIFZlcnNpb249NC4wLjAuMCwgQ3VsdHVyZT1uZXV0cmFsLCBQdWJsaWNLZXlUb2tlbj1iMDNmNWY3ZjExZDUwYTNhBQQAAAA+U3lzdGVtLldpbmRvd3MuRm9ybXMuTGlzdFZpZXdJdGVtK0xpc3RWaWV3U3ViSXRlbStTdWJJdGVtU3R5bGUDAAAACWJhY2tDb2xvcglmb3JlQ29sb3IEZm9udAQEBBRTeXN0ZW0uRHJhd2luZy5Db2xvcgYAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3IGAAAAE1N5c3RlbS5EcmF3aW5nLkZvbnQGAAAAAgAAAAX5////FFN5c3RlbS5EcmF3aW5nLkNvbG9yBAAAAARuYW1lBXZhbHVlCmtub3duQ29sb3IFc3RhdGUBAAAACQcHBgAAAAoAAAAAAAAAACMAAQAB+P////n///8KAAAAAAAAAACkAAEACQkAAAAFCQAAABNTeXN0ZW0uRHJhd2luZy5Gb250BAAAAAROYW1lBFNpemUFU3R5bGUEVW5pdAEABAQLGFN5c3RlbS5EcmF3aW5nLkZvbnRTdHlsZQYAAAAbU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0BgAAAAYAAAAGCgAAABRNaWNyb3NvZnQgU2FucyBTZXJpZgAAEEEF9f///xhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUBAAAAB3ZhbHVlX18ACAYAAAAAAAAABfT///8bU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0AQAAAAd2YWx1ZV9fAAgGAAAAAwAAAAs=";
-
-    private const string ClassicPadding =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAABxTeXN0ZW0uV2luZG93cy5Gb3Jtcy5QYWRkaW5nBQAAAARfYWxsBF90b3AFX2xlZnQGX3JpZ2h0B19ib3R0b20AAAAAAAEICAgIAgAAAAACAAAAAQAAAAMAAAAEAAAACw==";
-
-    private const string ClassicTableLayoutSettings =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAAChTeXN0ZW0uV2luZG93cy5Gb3Jtcy5UYWJsZUxheW91dFNldHRpbmdzAQAAABBTZXJpYWxpemVkU3RyaW5nAQIAAAAGAwAAAPUDPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTE2Ij8+PFRhYmxlTGF5b3V0U2V0dGluZ3M+PENvbnRyb2xzPjxDb250cm9sIE5hbWU9ImJ1dHRvbjAwXzEwIiBSb3c9IjAiIFJvd1NwYW49IjEiIENvbHVtbj0iMCIgQ29sdW1uU3Bhbj0iMiIgLz48Q29udHJvbCBOYW1lPSJsYWJlbDIwXzIxIiBSb3c9IjAiIFJvd1NwYW49IjIiIENvbHVtbj0iMiIgQ29sdW1uU3Bhbj0iMSIgLz48Q29udHJvbCBOYW1lPSJyYWRpb0J1dHRvbjAxIiBSb3c9IjEiIFJvd1NwYW49IjEiIENvbHVtbj0iMCIgQ29sdW1uU3Bhbj0iMSIgLz48Q29udHJvbCBOYW1lPSJjaGVja0JveDExIiBSb3c9IjEiIFJvd1NwYW49IjEiIENvbHVtbj0iMSIgQ29sdW1uU3Bhbj0iMSIgLz48L0NvbnRyb2xzPjxDb2x1bW5zIFN0eWxlcz0iUGVyY2VudCw1MCxQZXJjZW50LDUwLFBlcmNlbnQsNTAiIC8+PFJvd3MgU3R5bGVzPSJBYnNvbHV0ZSwyMCxBYnNvbHV0ZSwzMCIgLz48L1RhYmxlTGF5b3V0U2V0dGluZ3M+Cw==";
-
-    private const string ClassicTreeNode =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9kZQwAAAAHUHJvcEJhZwRUZXh0C1Rvb2xUaXBUZXh0BE5hbWUJSXNDaGVja2VkCkltYWdlSW5kZXgISW1hZ2VLZXkSU2VsZWN0ZWRJbWFnZUluZGV4EFNlbGVjdGVkSW1hZ2VLZXkKQ2hpbGRDb3VudAljaGlsZHJlbjAJY2hpbGRyZW4xBAEBAQAAAQABAAQEKVN5c3RlbS5XaW5kb3dzLkZvcm1zLk93bmVyRHJhd1Byb3BlcnR5QmFnAgAAAAEICAgdU3lzdGVtLldpbmRvd3MuRm9ybXMuVHJlZU5vZGUCAAAAHVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlAgAAAAIAAAAJAwAAAAYEAAAABW5vZGUxBgUAAAANdG9vbCB0aXAgdGV4dAkEAAAAAQEAAAAGBwAAAAD/////BggAAAADa2V5AgAAAAkJAAAACQoAAAAMCwAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAwAAAClTeXN0ZW0uV2luZG93cy5Gb3Jtcy5Pd25lckRyYXdQcm9wZXJ0eUJhZwMAAAAJQmFja0NvbG9yCUZvcmVDb2xvcgRGb250BAQEFFN5c3RlbS5EcmF3aW5nLkNvbG9yCwAAABRTeXN0ZW0uRHJhd2luZy5Db2xvcgsAAAATU3lzdGVtLkRyYXdpbmcuRm9udAsAAAACAAAABfT///8UU3lzdGVtLkRyYXdpbmcuQ29sb3IEAAAABG5hbWUFdmFsdWUKa25vd25Db2xvcgVzdGF0ZQEAAAAJBwcLAAAACgAAAAAAAAAApgABAAHz////9P///woAAAAAAAAAAE8AAQAJDgAAAAUJAAAAHVN5c3RlbS5XaW5kb3dzLkZvcm1zLlRyZWVOb2RlCQAAAARUZXh0C1Rvb2xUaXBUZXh0BE5hbWUJSXNDaGVja2VkCkltYWdlSW5kZXgISW1hZ2VLZXkSU2VsZWN0ZWRJbWFnZUluZGV4EFNlbGVjdGVkSW1hZ2VLZXkKQ2hpbGRDb3VudAEBAQAAAQABAAEICAgCAAAABg8AAAAFbm9kZTIJBwAAAAkHAAAAAP////8JBwAAAP////8JBwAAAAAAAAAFCgAAAB1TeXN0ZW0uV2luZG93cy5Gb3Jtcy5UcmVlTm9kZQkAAAAEVGV4dAtUb29sVGlwVGV4dAROYW1lCUlzQ2hlY2tlZApJbWFnZUluZGV4CEltYWdlS2V5ElNlbGVjdGVkSW1hZ2VJbmRleBBTZWxlY3RlZEltYWdlS2V5CkNoaWxkQ291bnQBAQEAAAEAAQABCAgIAgAAAAYRAAAABW5vZGUzCQcAAAAJBwAAAAD/////CQcAAAD/////CQcAAAAAAAAABQ4AAAATU3lzdGVtLkRyYXdpbmcuRm9udAQAAAAETmFtZQRTaXplBVN0eWxlBFVuaXQBAAQECxhTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGULAAAAG1N5c3RlbS5EcmF3aW5nLkdyYXBoaWNzVW5pdAsAAAALAAAABhMAAAAUTWljcm9zb2Z0IFNhbnMgU2VyaWYAABBBBez///8YU3lzdGVtLkRyYXdpbmcuRm9udFN0eWxlAQAAAAd2YWx1ZV9fAAgLAAAAAAAAAAXr////G1N5c3RlbS5EcmF3aW5nLkdyYXBoaWNzVW5pdAEAAAAHdmFsdWVfXwAICwAAAAMAAAAL";
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/SpanHelpersTests.cs b/src/System.Windows.Forms/tests/UnitTests/SpanHelpersTests.cs
deleted file mode 100644
index 24e06725d51..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/SpanHelpersTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SpanHelpersTests
-{
-    [Theory,
-        InlineData("", 1, "\0"),
-        InlineData("a", 1, "\0"),
-        InlineData("ab", 1, "\0"),
-        InlineData("a", 2, "a\0"),
-        InlineData("ab", 2, "a\0"),
-        InlineData("abc", 2, "a\0"),
-        InlineData("a", 3, "a\0@")]
-    public unsafe void CopyAndTerminate(string source, int destinationLength, string expected)
-    {
-        Span<char> destination = stackalloc char[destinationLength];
-        destination.Fill('@');
-        SpanHelpers.CopyAndTerminate(source.AsSpan(), destination);
-        Assert.True(destination.SequenceEqual(expected));
-    }
-
-    [Theory,
-        InlineData("", ""),
-        InlineData("\0", ""),
-        InlineData("\0\0", ""),
-        InlineData("\0a", ""),
-        InlineData("\0a\0", ""),
-        InlineData("a", "a"),
-        InlineData("a\0", "a"),
-        InlineData("a\0a", "a"),
-        InlineData("a\0a\0", "a")]
-    public unsafe void SliceAtFirstNull(string source, string expected)
-    {
-        Assert.True(source.AsSpan().SliceAtFirstNull().SequenceEqual(expected));
-        Span<char> copy = stackalloc char[source.Length];
-        source.AsSpan().CopyTo(copy);
-        Assert.True(copy.SliceAtFirstNull().SequenceEqual(expected));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System.Windows.Forms.Tests.csproj b/src/System.Windows.Forms/tests/UnitTests/System.Windows.Forms.Tests.csproj
deleted file mode 100644
index 5374c302b38..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System.Windows.Forms.Tests.csproj
+++ /dev/null
@@ -1,83 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <SourceTargetFramework>$(TargetFramework)</SourceTargetFramework>
-    <TargetFramework>$(TargetFramework)-windows7.0</TargetFramework>
-    <DisableTransitiveFrameworkReferences>true</DisableTransitiveFrameworkReferences>
-    <AssemblyName>System.Windows.Forms.Tests</AssemblyName>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <NoWarn>$(NoWarn),1573,1591,1712,WFDEV001,SYSLIB0050,SYSLIB0051</NoWarn>
-    <NoWarn>$(NoWarn);IDE0090</NoWarn>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Moq" Version="$(MoqPackageVersion)" />
-    <PackageReference Include="xunit.stafact" Version="$(XUnitStaFactPackageVersion)" />
-    <PackageReference Include="coverlet.msbuild" Version="$(CoverletMSBuildPackageVersion)" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\BuildAssist\BuildAssist.msbuildproj" />
-    <ProjectReference Include="..\..\src\System.Windows.Forms.csproj" />
-    <ProjectReference Include="..\..\..\System.Design\src\System.Design.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing\src\System.Drawing.Facade.csproj" />
-    <ProjectReference Include="..\..\..\System.Drawing.Design\src\System.Drawing.Design.Facade.csproj" />
-    <ProjectReference Include="..\IntegrationTests\System.Windows.Forms.IntegrationTests.Common\System.Windows.Forms.IntegrationTests.Common.csproj" />
-    <ProjectReference Include="..\TestUtilities\System.Windows.Forms.TestUtilities.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <!-- workaround for https://github.com/dotnet/sdk/issues/3254 -->
-    <Reference Include="$(BaseOutputPath)..\System.Drawing.Facade\$(Configuration)\$(SourceTargetFramework)\System.Drawing.dll" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="AxInterop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\AxInterop.WMPLib.dll</HintPath>
-    </Reference>
-    <Reference Include="Interop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\Interop.WMPLib.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Content Include="TestResources\Files\*">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <Content Include="bitmaps\*">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-    <None Include="..\AxHosts\AxHosts.resx" Link="Resources\AxHosts.resx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <EmbeddedResource Include="bitmaps\10x16_one_entry_32bit.ico">
-      <LogicalName>System.Windows.Forms.Design.Tests.CustomPropertyTab</LogicalName>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <EmbeddedResource Update="TestResources.resx">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </EmbeddedResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Update="TestResources\VB6\SimpleControl.vb6">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="AxInterop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\AxInterop.WMPLib.dll</HintPath>
-    </Reference>
-    <Reference Include="Interop.WMPLib">
-      <HintPath>$(ArtifactsBinDir)\AxHosts\$(Configuration)\net472\Interop.WMPLib.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
-</Project>
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PaintValueEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PaintValueEventArgsTests.cs
deleted file mode 100644
index af525bec4e1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PaintValueEventArgsTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Drawing.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class PaintValueEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ITypeDescriptorContext_Object_Rectangle_TestData()
-    {
-        yield return new object[] { null, null, Rectangle.Empty };
-        yield return new object[] { new Mock<ITypeDescriptorContext>(MockBehavior.Strict).Object, new object(), new Rectangle(1, 2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ITypeDescriptorContext_Object_Rectangle_TestData))]
-    public void PaintValueEventArgs_Ctor_ITypeDescriptorContext_Object_Graphics_Rectangle(ITypeDescriptorContext context, object value, Rectangle bounds)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new PaintValueEventArgs(context, value, graphics, bounds);
-        Assert.Same(context, e.Context);
-        Assert.Same(value, e.Value);
-        Assert.Same(graphics, e.Graphics);
-        Assert.Equal(bounds, e.Bounds);
-    }
-
-    [WinFormsFact]
-    public void PaintValueEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        AssertExtensions.Throws<ArgumentNullException>("graphics", () => new PaintValueEventArgs(null, new object(), null, Rectangle.Empty));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PropertyValueUIItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PropertyValueUIItemTests.cs
deleted file mode 100644
index e6668569120..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/PropertyValueUIItemTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Drawing.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertyValueUIItemTests
-{
-    public static IEnumerable<object[]> Ctor_Image_PropertyValueUIItemInvokeHandler_String_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10), (PropertyValueUIItemInvokeHandler)Dummy_PropertyValueUIItemInvokeHandler, null };
-        yield return new object[] { new Bitmap(10, 10), (PropertyValueUIItemInvokeHandler)Dummy_PropertyValueUIItemInvokeHandler, string.Empty };
-        yield return new object[] { new Bitmap(10, 10), (PropertyValueUIItemInvokeHandler)Dummy_PropertyValueUIItemInvokeHandler, "tooltip" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Image_PropertyValueUIItemInvokeHandler_String_TestData))]
-    public void PropertyValueUIItem_Ctor_Image_PropertyValueUIItemInvokeHandler_String(Image uiItemImage, PropertyValueUIItemInvokeHandler handler, string tooltip)
-    {
-        var item = new PropertyValueUIItem(uiItemImage, handler, tooltip);
-        Assert.Same(uiItemImage, item.Image);
-        Assert.Same(handler, item.InvokeHandler);
-        Assert.Same(tooltip, item.ToolTip);
-    }
-
-    [Fact]
-    public void PropertyValueUIItem_Ctor_NullUiItemImage_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("uiItemImage", () => new PropertyValueUIItem(null, Dummy_PropertyValueUIItemInvokeHandler, "tooltip"));
-    }
-
-    [Fact]
-    public void PropertyValueUIItem_Ctor_NullHandler_ThrowsArgumentNullException()
-    {
-        using (var uiItemImage = new Bitmap(10, 10))
-        {
-            Assert.Throws<ArgumentNullException>("handler", () => new PropertyValueUIItem(uiItemImage, null, "tooltip"));
-        }
-    }
-
-    private static void Dummy_PropertyValueUIItemInvokeHandler(ITypeDescriptorContext context, PropertyDescriptor propDesc, PropertyValueUIItem invokedItem) { }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/UITypeEditorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/UITypeEditorTests.cs
deleted file mode 100644
index 6900c72a698..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Drawing/Design/UITypeEditorTests.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Drawing.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class UITypeEditorTests
-{
-    [Fact]
-    public void UITypeEditor_Ctor_Default()
-    {
-        var editor = new UITypeEditor();
-        Assert.False(editor.IsDropDownResizable);
-    }
-
-    public static IEnumerable<object[]> EditValue_ITypeDescriptorContext_IServiceProvider_Object_TestData()
-    {
-        yield return new object[] { null, null, null };
-        var mockTypeDescriptorContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        var mockServiceProvider = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        yield return new object[] { mockTypeDescriptorContext.Object, mockServiceProvider.Object, new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_ITypeDescriptorContext_IServiceProvider_Object_TestData))]
-    public void UITypeEditor_EditValue_Invoke_ReturnsValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
-    {
-        var editor = new UITypeEditor();
-        Assert.Same(value, editor.EditValue(context, provider, value));
-    }
-
-    public static IEnumerable<object[]> EditValue_IServiceProvider_Object_TestData()
-    {
-        yield return new object[] { null, null };
-        var mockServiceProvider = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        yield return new object[] { mockServiceProvider.Object, new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditValue_IServiceProvider_Object_TestData))]
-    public void UITypeEditor_EditValue_Invoke_CallsVirtualEditValue(IServiceProvider provider, object value)
-    {
-        var result = new object();
-        var mockEditor = new Mock<UITypeEditor>(MockBehavior.Strict);
-        mockEditor
-            .Setup(e => e.EditValue(null, provider, value))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(result, mockEditor.Object.EditValue(provider, value));
-        mockEditor.Verify(e => e.EditValue(null, provider, value), Times.Once());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void UITypeEditor_GetEditStyle_Invoke_ReturnsNone(ITypeDescriptorContext context)
-    {
-        var editor = new UITypeEditor();
-        Assert.Equal(UITypeEditorEditStyle.None, editor.GetEditStyle(context));
-    }
-
-    [Fact]
-    public void UITypeEditor_GetEditStyle_Invoke_CallsVirtualGetEditStyle()
-    {
-        var mockEditor = new Mock<UITypeEditor>(MockBehavior.Strict);
-        mockEditor
-            .Setup(e => e.GetEditStyle(null))
-            .Returns(UITypeEditorEditStyle.Modal)
-            .Verifiable();
-        Assert.Equal(UITypeEditorEditStyle.Modal, mockEditor.Object.GetEditStyle());
-        mockEditor.Verify(e => e.GetEditStyle(null), Times.Once());
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetITypeDescriptorContextTestData))]
-    public void UITypeEditor_GetPaintValueSupported_Invoke_ReturnsFalse(ITypeDescriptorContext context)
-    {
-        var editor = new UITypeEditor();
-        Assert.False(editor.GetPaintValueSupported(context));
-    }
-
-    [Theory]
-    [BoolData]
-    public void UITypeEditor_GetPaintValueSupported_Invoke_CallsVirtualGetPaintValueSupported(bool result)
-    {
-        var mockEditor = new Mock<UITypeEditor>(MockBehavior.Strict);
-        mockEditor
-            .Setup(e => e.GetPaintValueSupported(null))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockEditor.Object.GetPaintValueSupported());
-        mockEditor.Verify(e => e.GetPaintValueSupported(null), Times.Once());
-    }
-
-    public static IEnumerable<object[]> PaintValue_PaintValueEventArgs_TestData()
-    {
-        var bitmap = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(bitmap);
-        yield return new object[] { null };
-        yield return new object[] { new PaintValueEventArgs(null, null, graphics, Rectangle.Empty) };
-    }
-
-    [Theory]
-    [MemberData(nameof(PaintValue_PaintValueEventArgs_TestData))]
-    public void UITypeEditor_PaintValue_Invoke_Nop(PaintValueEventArgs e)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (var graphics = Graphics.FromImage(image))
-        {
-            var editor = new UITypeEditor();
-            editor.PaintValue(e);
-        }
-    }
-
-    public static IEnumerable<object[]> PaintValue_Object_Graphics_Rectangle_TestData()
-    {
-        var bitmap = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(bitmap);
-        yield return new object[] { null, graphics, Rectangle.Empty };
-        yield return new object[] { new object(), graphics, new Rectangle(1, 2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(PaintValue_Object_Graphics_Rectangle_TestData))]
-    public void UITypeEditor_PaintValue_Invoke_CallsVirtualPaintValue(object value, Graphics canvas, Rectangle rectangle)
-    {
-        var mockEditor = new Mock<UITypeEditor>(MockBehavior.Strict);
-        mockEditor
-            .Setup(e => e.PaintValue(It.IsAny<PaintValueEventArgs>()))
-            .Verifiable();
-        using (var image = new Bitmap(10, 10))
-        using (var graphics = Graphics.FromImage(image))
-        {
-            mockEditor.Object.PaintValue(value, canvas, rectangle);
-        }
-
-        mockEditor.Verify(e => e.PaintValue(It.IsAny<PaintValueEventArgs>()), Times.Once());
-    }
-
-    [Fact]
-    public void UITypeEditor_PaintValue_NullCanvas_ThrowsArgumentNullException()
-    {
-        var editor = new UITypeEditor();
-        Assert.Throws<ArgumentNullException>("graphics", () => editor.PaintValue(new object(), null, Rectangle.Empty));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRef.ConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRef.ConverterTests.cs
deleted file mode 100644
index f20bde2bb8f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRef.ConverterTests.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Text;
-
-namespace System.Resources.Tests;
-
-// NB: doesn't require thread affinity
-public class ResXFileRef_Converter
-{
-    [Theory]
-    [InlineData("\"File Name.txt\";", new[] { "File Name.txt", "" })]
-    [InlineData("\"File Name.txt\";System.String", new[] { "File Name.txt", "System.String" })]
-    [InlineData("\"File Name.txt\";System.String;utf-8", new[] { "File Name.txt", "System.String", "utf-8" })]
-    [InlineData("File.txt;", new[] { "File.txt", "" })]
-    [InlineData("File.txt;System.String", new[] { "File.txt", "System.String" })]
-    [InlineData("File.txt;System.String;utf-8", new[] { "File.txt", "System.String", "utf-8" })]
-    [InlineData("File.txt; System.String", new[] { "File.txt", " System.String" })]
-    [InlineData("File.txt; System.String; utf-8 ", new[] { "File.txt", " System.String", " utf-8" })]
-    [InlineData("File.txt; System.String   ", new[] { "File.txt", " System.String" })]
-    [InlineData("File.txt; System.String ; utf-8    ", new[] { "File.txt", " System.String ", " utf-8" })]
-    public void ParseResxFileRefString_ReturnsCorrectParts(string resxFileRefString, string[] result)
-    {
-        string[] parts = ResXFileRef.Converter.ParseResxFileRefString(resxFileRefString);
-
-        Assert.Equal(result, parts);
-    }
-
-    [Theory]
-    [InlineData("\"File.txt")]
-    [InlineData("File.txt")]
-    public void ParseResxFileRefString_ThrowsArgumentException(string resxFileRefString)
-    {
-        Assert.Throws<ArgumentException>(() => ResXFileRef.Converter.ParseResxFileRefString(resxFileRefString));
-    }
-
-    [Fact]
-    public void ConvertFrom_ReturnNullWhenValueIsNotAString()
-    {
-        var value = new object();
-        var converter = new ResXFileRef.Converter();
-
-        var result = converter.ConvertFrom(null, null, value);
-
-        Assert.Null(result);
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsString()
-    {
-        var resxFileRefString = @"TestResources\Files\text.ansi.txt;System.String";
-        var expected = "Text";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (string)converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.Equal(expected, result);
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsStringUsingEncodingFromRefString()
-    {
-        var resxFileRefString = @"TestResources\Files\text.utf8.txt;System.String;utf-8";
-        var expected = "Привет";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (string)converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.Equal(expected, result);
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsByteArray()
-    {
-        var resxFileRefString = @"TestResources\Files\text.ansi.txt;System.Byte[]";
-        var expected = "Text";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (byte[])converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.Equal(expected, Encoding.Default.GetString(result));
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsMemoryStream()
-    {
-        var resxFileRefString = @"TestResources\Files\text.ansi.txt;System.IO.MemoryStream";
-        var expected = "Text";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (MemoryStream)converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.Equal(expected, Encoding.Default.GetString(result.ToArray()));
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsIcon()
-    {
-        var resxFileRefString = @"TestResources\Files\Error.ico;System.Drawing.Icon, System.Drawing.Common";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (Icon)converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.NotNull(result);
-        Assert.False(result.Size.IsEmpty);
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsIconWhenTypeIsBitmap()
-    {
-        var bitmapIconRefString = @"TestResources\Files\Error.ico;System.Drawing.Bitmap, System.Drawing.Common";
-        var iconRefString = @"TestResources\Files\Error.ico;System.Drawing.Icon, System.Drawing.Common";
-        var converter = new ResXFileRef.Converter();
-
-        var iconResult = (Icon)converter.ConvertFrom(null, null, iconRefString);
-        var bitmapResult = (Bitmap)converter.ConvertFrom(null, null, bitmapIconRefString);
-
-        Assert.Equal(iconResult.Size, bitmapResult.Size);
-    }
-
-    [Fact]
-    public void ConvertFrom_ReadsFileAsBitmap()
-    {
-        var resxFileRefString = @"TestResources\Files\ErrorControl.bmp;System.Drawing.Bitmap, System.Drawing.Common";
-        var converter = new ResXFileRef.Converter();
-
-        var result = (Bitmap)converter.ConvertFrom(null, null, resxFileRefString);
-
-        Assert.NotNull(result);
-        Assert.False(result.Size.IsEmpty);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRefTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRefTests.cs
deleted file mode 100644
index 39afac71b07..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXFileRefTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Text;
-
-namespace System.Resources.Tests;
-
-// NB: doesn't require thread affinity
-public class ResXFileRefTests
-{
-    [Fact]
-    public void ResXFileRef_Constructor()
-    {
-        var fileName = "SomeFile";
-        var typeName = "SomeType";
-
-        var fileRef = new ResXFileRef(fileName, typeName);
-
-        Assert.Equal(fileName, fileRef.FileName);
-        Assert.Equal(typeName, fileRef.TypeName);
-        Assert.Null(fileRef.TextFileEncoding);
-    }
-
-    [Fact]
-    public void ResXFileRef_EncodingConstructor()
-    {
-        var fileName = "SomeFile";
-        var typeName = "SomeType";
-        Encoding encoding = Encoding.Default;
-
-        var fileRef = new ResXFileRef(fileName, typeName, encoding);
-
-        Assert.Equal(fileName, fileRef.FileName);
-        Assert.Equal(typeName, fileRef.TypeName);
-        Assert.Equal(encoding, fileRef.TextFileEncoding);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceReaderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceReaderTests.cs
deleted file mode 100644
index b773e3585de..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceReaderTests.cs
+++ /dev/null
@@ -1,220 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Text;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Resources.Tests;
-
-public class ResXResourceReaderTests
-{
-    [Fact]
-    public void ResXResourceReader_Deserialize_AxHost_FormatterEnabled_Throws()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-
-        string resxPath = Path.GetFullPath(@".\Resources\AxHosts.resx");
-        using MemoryStream resourceStream = new();
-
-        // ResourceWriter Dispose calls Generate method which will throw.
-        Assert.Throws<PlatformNotSupportedException>(() =>
-        {
-            using ResourceWriter resourceWriter = new(resourceStream);
-            using ResXResourceReader resxReader = new(resxPath);
-            var enumerator = resxReader.GetEnumerator();
-
-            Assert.True(enumerator.MoveNext());
-            string key = enumerator.Key.ToString();
-            object value = enumerator.Value;
-            Assert.Equal("axWindowsMediaPlayer1.OcxState", key);
-            Assert.Equal(typeof(AxHost.State), value.GetType());
-            Assert.False(enumerator.MoveNext());
-
-            resourceWriter.AddResource(key, value);
-
-            // ResourceWriter no longer supports BinaryFormatter in core.
-            Assert.Throws<PlatformNotSupportedException>(resourceWriter.Generate);
-        });
-    }
-
-    [Fact]
-    public void ResXResourceReader_Deserialize_AxHost_FormatterDisabled_Throws()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: false);
-
-        string resxPath = Path.GetFullPath(@".\Resources\AxHosts.resx");
-        using MemoryStream resourceStream = new();
-
-        using ResXResourceReader resxReader = new(resxPath);
-        Assert.Throws<ArgumentException>(() => resxReader.GetEnumerator());
-    }
-
-    [Fact]
-    public void ResXResourceReader_Constructor_FileName()
-    {
-        // Create a temp file and write the resx to it.        
-        using TempFile tempFile = TempFile.Create(ResxHelper.CreateResx());
-        using ResXResourceReader resXReader = new(tempFile.Path);
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        Assert.NotNull(enumerator);
-    }
-
-    [Fact]
-    public void ResXResourceReader_Constructor_TextReader()
-    {
-        using TextReader textReader = new StringReader(ResxHelper.CreateResx());
-        using ResXResourceReader resXReader = new(textReader);
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        Assert.NotNull(enumerator);
-    }
-
-    [Fact]
-    public void ResXResourceReader_Constructor_Stream()
-    {
-        byte[] resxBytes = Encoding.UTF8.GetBytes(ResxHelper.CreateResx());
-        using Stream resxStream = new MemoryStream(resxBytes);
-        using ResXResourceReader resXReader = new ResXResourceReader(resxStream);
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        Assert.NotNull(enumerator);
-    }
-
-    [Fact]
-    public void ResXResourceReader_FromFileContents()
-    {
-        using var resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx());
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        Assert.NotNull(enumerator);
-    }
-
-    [Fact]
-    public void ResXResourceReader_GetEnumerator_String()
-    {
-        // Arrange
-        string keyName1 = "TestString";
-        string keyName2 = "TestString2";
-        string testValue1 = "TestValue1";
-        string testValue2 = "TestValue2";
-
-        IDictionary expectedData = new Hashtable { { keyName1, testValue1 }, { keyName2, testValue2 } };
-        string data = $"""
-            <data name="{keyName1}" xml:space="preserve">
-              <value>{testValue1}</value>
-            </data>
-            <data name="{keyName2}" xml:space="preserve">
-              <value>{testValue2}</value>
-            </data>
-            """;
-
-        // Act
-        using var resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx(data));
-        IDictionary actualData = new Hashtable();
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-
-        while (enumerator.MoveNext())
-        {
-            actualData.Add(enumerator.Key, enumerator.Value);
-        }
-
-        // Assert
-        Assert.Equal(expectedData, actualData);
-    }
-
-    [Fact]
-    public void ResXResourceReader_GetEnumerator_Int()
-    {
-        // Arrange
-        string keyName = "TestNumber";
-        int testValue = 42;
-
-        IDictionary expectedData = new Hashtable { { keyName, testValue } };
-        string data = $"""
-            <data name="{keyName}" type="System.Int32">
-              <value>{testValue}</value>
-            </data>
-            """;
-
-        // Act
-        using var resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx(data));
-        IDictionary actualData = new Hashtable();
-        IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        while (enumerator.MoveNext())
-        {
-            actualData.Add(enumerator.Key, enumerator.Value);
-        }
-
-        // Assert
-        Assert.Equal(expectedData, actualData);
-    }
-
-    [Fact]
-    public void GetMetadataEnumerator_ReturnsMetadataNodes()
-    {
-        // Arrange
-        string metadataName = "TestMetadata";
-        string sampleMetadataValue = "Sample metadata";
-
-        IDictionary expectedMetadata = new Hashtable { { metadataName, sampleMetadataValue } };
-        string metadata = $"""
-            <metadata name="{metadataName}" type="System.String">
-              <value>{sampleMetadataValue}</value>
-            </metadata>
-            """;
-
-        // Act
-        using ResXResourceReader resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx(metadata));
-        IDictionary actualMetadata = new Hashtable();
-        IDictionaryEnumerator metadataEnumerator = resXReader.GetMetadataEnumerator();
-        while (metadataEnumerator.MoveNext())
-        {
-            actualMetadata.Add(metadataEnumerator.Key, metadataEnumerator.Value);
-        }
-
-        // Assert
-        Assert.Equal(expectedMetadata, actualMetadata);
-    }
-
-    [Fact]
-    public void ResXResourceReader_GetEnumerator_UnknownType_ThowsException()
-    {
-        // Arrange
-        string unknownType = "System.XYZ";
-        string data = $"""
-            <data name="UnknownType" type="{unknownType}">
-              <value>UnknownValueType</value>
-            </data>
-            """;
-
-        // Act
-        using var resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx(data));
-
-        // Assert
-        ArgumentException exception = Assert.Throws<ArgumentException>(() => { IDictionaryEnumerator enumerator = resXReader.GetEnumerator(); });
-        Assert.Contains($"ResX file Type {unknownType} in the data", exception.Message);
-    }
-
-    [Fact]
-    public void ResXResourceReader_GetEnumerator_InvalidValue_ThowsException()
-    {
-        // Arrange
-        string keyName = "TestKey";
-        string testValue = "FortyTwo";
-
-        IDictionary expectedData = new Hashtable { { keyName, testValue } };
-        string data = $"""
-            <data name="{keyName}" type="System.Int32">
-              <value>{testValue}</value>
-            </data>
-            """;
-
-        // Act
-        using var resXReader = ResXResourceReader.FromFileContents(ResxHelper.CreateResx(data));
-
-        // Assert
-        ArgumentException exception = Assert.Throws<ArgumentException>(() =>
-        {
-            IDictionaryEnumerator enumerator = resXReader.GetEnumerator();
-        });
-        Assert.Contains($"ResX file {testValue} is not a valid value for Int32", exception.Message);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceSetTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceSetTests.cs
deleted file mode 100644
index 7e1755526a4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceSetTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Resources.Tests;
-
-// NB: doesn't require thread affinity
-public class ResXResourceSetTests
-{
-    [Theory]
-    [InlineData("TestResources.resx", "SomeMissingTest1", null)]
-    [InlineData("TestResources.resx", "SomeMetadataTest1", "Some text for MetaData 1 node")]
-    [InlineData("TestResources.resx", "SomeMetadataTest2", "Some text for MetaData 2 node")]
-    [InlineData("TestResources.resx", "SomeDataTest1", "Some text for Data 1 node")]
-    [InlineData("TestResources.resx", "SomeDataTest2", "Some text for Data 2 node")]
-    [InlineData("TestResources.resx", "text.ansi", "Text")]
-    [InlineData("TestResources.resx", "text.utf8", "Привет")]
-    private void ResXResourceSet_TestFile(string resxFileName, string resourceName, string expected)
-    {
-        Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project");
-
-        using (ResXResourceSet resxSet = new ResXResourceSet(resxFileName))
-        {
-            Assert.NotNull(resxSet);
-
-            string strResXValue = resxSet.GetString(resourceName);
-
-            Assert.Equal(expected, strResXValue);
-        }
-    }
-
-    [Theory]
-    [InlineData("TestResources.resx", "SomeMissingTest1", null)]
-    [InlineData("TestResources.resx", "SomeMetadataTest1", "Some text for MetaData 1 node")]
-    [InlineData("TestResources.resx", "SomeMetadataTest2", "Some text for MetaData 2 node")]
-    [InlineData("TestResources.resx", "SomeDataTest1", "Some text for Data 1 node")]
-    [InlineData("TestResources.resx", "SomeDataTest2", "Some text for Data 2 node")]
-    [InlineData("TestResources.resx", "text.ansi", "Text")]
-    [InlineData("TestResources.resx", "text.utf8", "Привет")]
-    private void ResXResourceSet_TestStream(string resxFileName, string resourceName, string expected)
-    {
-        Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project");
-
-        using (FileStream fs = new FileStream(resxFileName, FileMode.Open))
-        {
-            using (ResXResourceSet resxSet = new ResXResourceSet(fs))
-            {
-                Assert.NotNull(resxSet);
-
-                string strResXValue = resxSet.GetString(resourceName);
-
-                Assert.Equal(expected, strResXValue);
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceWriterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceWriterTests.cs
deleted file mode 100644
index 52827bf294b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResXResourceWriterTests.cs
+++ /dev/null
@@ -1,286 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Resources.Tests;
-
-// NB: doesn't require thread affinity
-public class ResXResourceWriterTests
-{
-    private readonly byte[] _testBytes = new byte[] { 1, 2, 3 };
-    private readonly string _testString1 = "TestString1";
-    private readonly string _testString2 = "TestString2";
-    private readonly string _resxFileName = "test.resx";
-    private readonly DateTime _testDateTime = new(2023, 5, 4);
-    private readonly Func<Type, string> _typeNameConverter = type => type?.AssemblyQualifiedName ?? string.Empty;
-
-    [Fact]
-    public void TestRoundTrip()
-    {
-        var key = "Some.Key.Name";
-        var value = "Some.Key.Value";
-
-        using (var stream = new MemoryStream())
-        {
-            using (var writer = new ResXResourceWriter(stream))
-            {
-                writer.AddResource(key, value);
-            }
-
-            var buffer = stream.ToArray();
-            using (var reader = new ResXResourceReader(new MemoryStream(buffer)))
-            {
-                var dictionary = new Dictionary<object, object>();
-                IDictionaryEnumerator dictionaryEnumerator = reader.GetEnumerator();
-                while (dictionaryEnumerator.MoveNext())
-                {
-                    dictionary.Add(dictionaryEnumerator.Key, dictionaryEnumerator.Value);
-                }
-
-                KeyValuePair<object, object> pair = Assert.Single(dictionary);
-                Assert.Equal(key, pair.Key);
-                Assert.Equal(value, pair.Value);
-            }
-        }
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_FileName_CreatesInstance()
-    {
-        // Arrange
-        string fileName = _resxFileName;
-
-        // Act
-        using ResXResourceWriter writer = new(fileName);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_FileNameAndTypeNameConverter_CreatesInstance()
-    {
-        // Arrange
-        string fileName = _resxFileName;
-
-        // Act
-        using ResXResourceWriter writer = new(fileName, _typeNameConverter);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_Stream_CreatesInstance()
-    {
-        // Arrange
-        using MemoryStream stream = new();
-
-        // Act
-        using ResXResourceWriter writer = new(stream);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_StreamAndTypeNameConverter_CreatesInstance()
-    {
-        // Arrange
-        using MemoryStream stream = new();
-
-        // Act
-        using ResXResourceWriter writer = new(stream, _typeNameConverter);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_TextWriter_CreatesInstance()
-    {
-        // Arrange
-        using StringWriter stringWriter = new();
-
-        // Act
-        using ResXResourceWriter writer = new(stringWriter);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_Constructor_TextWriterAndTypeNameConverter_CreatesInstance()
-    {
-        // Arrange
-        using StringWriter stringWriter = new();
-
-        // Act
-        using ResXResourceWriter writer = new(stringWriter, _typeNameConverter);
-
-        // Assert
-        Assert.NotNull(writer);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddMetadata_ByteValue_AddsMetadataToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddMetadata(_testString1, _testBytes);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var metadataEnumerator = reader.GetMetadataEnumerator();
-        Assert.True(metadataEnumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)metadataEnumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testBytes, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddMetadata_StringValue_AddsMetadataToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddMetadata(_testString1, _testString2);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var metadataEnumerator = reader.GetMetadataEnumerator();
-        Assert.True(metadataEnumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)metadataEnumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testString2, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddMetadata_ObjectValue_AddsMetadataToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddMetadata(_testString1, _testDateTime);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var metadataEnumerator = reader.GetMetadataEnumerator();
-        Assert.True(metadataEnumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)metadataEnumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testDateTime, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddResource_ByteValue_AddsResourceToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddResource(_testString1, _testBytes);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var enumerator = reader.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)enumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testBytes, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddResource_StringValue_AddsResourceToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddResource(_testString1, _testString2);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var enumerator = reader.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)enumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testString2, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddResource_ObjectValue_AddsResourceToResourceFile()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddResource(_testString1, _testDateTime);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var enumerator = reader.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)enumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testDateTime, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddResource_ResxDataNodeValue_AddsResourceToResourceFile()
-    {
-        // Arrange
-        ResXDataNode dataNode = new(_testString1, _testDateTime);
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act
-        writer.AddResource(_testString1, dataNode);
-        writer.Generate();
-        writer.Close();
-
-        // Assert
-        using ResXResourceReader reader = new(_resxFileName);
-        var enumerator = reader.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-
-        var currentEntry = (DictionaryEntry)enumerator.Current;
-        Assert.Equal(_testString1, currentEntry.Key);
-        Assert.Equal(_testDateTime, currentEntry.Value);
-    }
-
-    [Fact]
-    public void ResXResourceWriter_AddAlias_WithNullAssemblyName_ThrowNullException()
-    {
-        // Arrange
-        using ResXResourceWriter writer = new(_resxFileName);
-
-        // Act and Assert
-        Assert.Throws<ArgumentNullException>(() =>
-        {
-            writer.AddAlias(aliasName: "MyAlias", assemblyName: null);
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResxDataNodeTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResxDataNodeTests.cs
deleted file mode 100644
index 5ff4809ee70..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Resources/ResxDataNodeTests.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Resources.Tests;
-
-// NB: doesn't require thread affinity
-public class ResxDataNodeTests
-{
-    [Fact]
-    public void ResxDataNode_ResXFileRefConstructor()
-    {
-        var nodeName = "Node";
-        var fileRef = new ResXFileRef(string.Empty, string.Empty);
-        var dataNode = new ResXDataNode(nodeName, fileRef);
-
-        Assert.Equal(nodeName, dataNode.Name);
-        Assert.Same(fileRef, dataNode.FileRef);
-    }
-
-    [Fact]
-    public void ResxDataNode_GetValue_ByteArray_FromDataNodeInfo_Framework()
-    {
-        using Bitmap bitmap = new(10, 10);
-        var converter = TypeDescriptor.GetConverter(bitmap);
-        ResXDataNode temp = new("test", converter.ConvertTo(bitmap, typeof(byte[])));
-        var dataNodeInfo = temp.GetDataNodeInfo();
-        ResXDataNode dataNode = new(dataNodeInfo, basePath: null);
-
-        var bitmapBytes = dataNode.GetValue(typeResolver: null);
-        Bitmap result = Assert.IsType<Bitmap>(converter.ConvertFrom(bitmapBytes!));
-        Assert.Equal(bitmap.Size, result.Size);
-    }
-
-    [Fact]
-    public void ResxDataNode_GetValue_ByteArray_FromDataNodeInfo_Core()
-    {
-        using Bitmap bitmap = new(10, 10);
-        var converter = TypeDescriptor.GetConverter(bitmap);
-        ResXDataNode temp = new("test", converter.ConvertTo(bitmap, typeof(byte[])));
-        var dataNodeInfo = temp.GetDataNodeInfo();
-        dataNodeInfo.TypeName = "System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
-        ResXDataNode dataNode = new(dataNodeInfo, basePath: null);
-
-        var bitmapBytes = dataNode.GetValue(typeResolver: null);
-        var result = Assert.IsType<Bitmap>(converter.ConvertFrom(bitmapBytes!));
-        Assert.Equal(bitmap.Size, result.Size);
-    }
-
-    [Fact]
-    public void ResxDataNode_GetValue_Null_FromDataNodeInfo()
-    {
-        ResXDataNode temp = new("test", value: null);
-        var dataNodeInfo = temp.GetDataNodeInfo();
-        ResXDataNode dataNode = new(dataNodeInfo, basePath: null);
-
-        var valueNull = dataNode.GetValue(typeResolver: null);
-        Assert.Null(valueNull);
-    }
-
-    [Fact]
-    public void ResxDataNode_GetValue_String_FromDataNodeInfo()
-    {
-        ResXDataNode temp = new("testName", "test");
-        var dataNodeInfo = temp.GetDataNodeInfo();
-        ResXDataNode dataNode = new(dataNodeInfo, basePath: null);
-
-        var valueString = dataNode.GetValue(typeResolver: null);
-        Assert.Equal("test", valueString);
-    }
-
-    [Theory]
-    [MemberData(nameof(RoundTrip_BinaryFormatted_TestData))]
-    public void ResxDataNode_RoundTrip_BinaryFormatted(object? value)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: false);
-        ResXDataNode dataNode = new("Test", value);
-        DataNodeInfo nodeInfo = dataNode.GetDataNodeInfo();
-
-        ResXDataNode deserializedDataNode = new(nodeInfo, basePath: null);
-        Assert.Equal(value, deserializedDataNode.GetValue(typeResolver: null));
-    }
-
-    public static TheoryData<object?> RoundTrip_BinaryFormatted_TestData => new()
-    {
-        new RectangleF(10.0f, 20.0f, 30.0f, 40.0f),
-        new PointF(1.0f, 2.0f),
-        new List<string> { "Jack", "Queen", "King" },
-        new List<int> { 4, 3, 2, 1 },
-        new Hashtable(),
-        new Hashtable()
-        {
-            { "This", "That" }
-        },
-        new Hashtable()
-        {
-            { "Meaning", 42 }
-        },
-        new Hashtable()
-        {
-            { 42, 42 }
-        },
-        new Hashtable()
-        {
-            { 42, 42 },
-            { 43, 42 }
-        },
-        new Hashtable()
-        {
-            { "Hastings", new DateTime(1066, 10, 14) }
-        },
-        new Hashtable()
-        {
-            { "Decimal", decimal.MaxValue }
-        },
-        new Hashtable()
-        {
-            { "This", "That" },
-            { "TheOther", "This" },
-            { "That", "This" }
-        },
-        new Hashtable()
-        {
-            { "Yowza", null },
-            { "Youza", "Anakin" },
-            { "Meeza", "Binks" }
-        },
-        new Hashtable()
-        {
-            { decimal.MinValue, decimal.MaxValue },
-            { float.MinValue, float.MaxValue },
-            { DateTime.MinValue, DateTime.MaxValue },
-            { TimeSpan.MinValue, TimeSpan.MaxValue }
-        },
-    };
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleObjectTests.cs
deleted file mode 100644
index 3fdaeb08337..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleObjectTests.cs
+++ /dev/null
@@ -1,2705 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Accessibility;
-using Moq;
-using static Interop;
-using System.Reflection;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class AccessibleObjectTests
-{
-    [WinFormsFact]
-    public void AccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void AccessibleObject_Name_Set_GetReturnsNull(string value)
-    {
-        var accessibleObject = new AccessibleObject
-        {
-            Name = value
-        };
-        Assert.Null(accessibleObject.Name);
-
-        // Set same.
-        accessibleObject.Name = value;
-        Assert.Null(accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void AccessibleObject_Value_Set_GetReturnsEmpty(string value)
-    {
-        var accessibleObject = new AccessibleObject
-        {
-            Value = value
-        };
-        Assert.Empty(accessibleObject.Value);
-
-        // Set same.
-        accessibleObject.Value = value;
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_DoDefaultAction_InvokeDefault_Nop()
-    {
-        var accessibleObject = new AccessibleObject();
-        accessibleObject.DoDefaultAction();
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void AccessibleObject_GetChild_InvokeDefault_ReturnsNull(int index)
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Null(accessibleObject.GetChild(index));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetChildCount_InvokeDefault_ReturnsMinusOne()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetFocused_InvokeDefault_ReturnsNull()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Null(accessibleObject.GetFocused());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetFocused_InvokeDefaultWithNoChildren_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(0);
-        mockAccessibleObject
-            .Setup(a => a.State)
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.GetFocused())
-            .CallBase();
-        Assert.Null(mockAccessibleObject.Object.GetFocused());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetFocused_InvokeDefaultWithNoChildrenFocused_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(0);
-        mockAccessibleObject
-            .Setup(a => a.State)
-            .Returns(AccessibleStates.Focused);
-        mockAccessibleObject
-            .Setup(a => a.GetFocused())
-            .CallBase();
-        Assert.Same(mockAccessibleObject.Object, mockAccessibleObject.Object.GetFocused());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetFocused_InvokeDefaultWithNoFocusedChildren_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(new AccessibleObject());
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(2);
-            mockAccessibleObject
-                .Setup(a => a.State)
-                .CallBase();
-            mockAccessibleObject
-                .Setup(a => a.GetFocused())
-                .CallBase();
-            Assert.Null(mockAccessibleObject.Object.GetFocused());
-        }
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetFocused_InvokeDefaultWithFocusedChildren_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild1
-                .Setup(a => a.State)
-                .Returns(AccessibleStates.Focused);
-            var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild2
-                .Setup(a => a.State)
-                .Returns(AccessibleStates.Focused);
-
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(mockAccessibleObjectChild1.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(2))
-                .Returns(mockAccessibleObjectChild2.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(3);
-            mockAccessibleObject
-                .Setup(a => a.State)
-                .CallBase();
-            mockAccessibleObject
-                .Setup(a => a.GetFocused())
-                .CallBase();
-            Assert.Same(mockAccessibleObjectChild1.Object, mockAccessibleObject.Object.GetFocused());
-        }
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetHelpTopic_InvokeDefault_ReturnsMinusOne()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Equal(-1, accessibleObject.GetHelpTopic(out string fileName));
-        Assert.Null(fileName);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetSelected_InvokeDefault_ReturnsNull()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Null(accessibleObject.GetSelected());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetSelected_InvokeDefaultWithNoChildren_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(0);
-        mockAccessibleObject
-            .Setup(a => a.State)
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.GetSelected())
-            .CallBase();
-        Assert.Null(mockAccessibleObject.Object.GetSelected());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetSelected_InvokeDefaultWithNoChildrenFocused_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(0);
-        mockAccessibleObject
-            .Setup(a => a.State)
-            .Returns(AccessibleStates.Selected);
-        mockAccessibleObject
-            .Setup(a => a.GetSelected())
-            .CallBase();
-        Assert.Same(mockAccessibleObject.Object, mockAccessibleObject.Object.GetSelected());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetSelected_InvokeDefaultWithNoFocusedChildren_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(new AccessibleObject());
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(2);
-            mockAccessibleObject
-                .Setup(a => a.State)
-                .CallBase();
-            mockAccessibleObject
-                .Setup(a => a.GetSelected())
-                .CallBase();
-            Assert.Null(mockAccessibleObject.Object.GetSelected());
-        }
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_GetSelected_InvokeDefaultWithFocusedChildren_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild1
-                .Setup(a => a.State)
-                .Returns(AccessibleStates.Selected);
-            var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild2
-                .Setup(a => a.State)
-                .Returns(AccessibleStates.Selected);
-
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(mockAccessibleObjectChild1.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(2))
-                .Returns(mockAccessibleObjectChild2.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(3);
-            mockAccessibleObject
-                .Setup(a => a.State)
-                .CallBase();
-            mockAccessibleObject
-                .Setup(a => a.GetSelected())
-                .CallBase();
-            Assert.Same(mockAccessibleObjectChild1.Object, mockAccessibleObject.Object.GetSelected());
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_HitTest_InvokeDefault_ReturnsNull(int x, int y)
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Null(accessibleObject.HitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(3, 5)]
-    public void AccessibleObject_HitTest_InvokeDefaultWithNoChildrenBoundsValid_ReturnsExpected(int x, int y)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4));
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.HitTest(x, y))
-            .CallBase();
-        Assert.Same(mockAccessibleObject.Object, mockAccessibleObject.Object.HitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(4, 2)]
-    [InlineData(1, 6)]
-    [InlineData(4, 5)]
-    public void AccessibleObject_HitTest_InvokeDefaultWithNoChildrenBoundsInvalid_ReturnsNull(int x, int y)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4));
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.HitTest(x, y))
-            .CallBase();
-        Assert.Null(mockAccessibleObject.Object.HitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_HitTest_InvokeDefaultWithNoBoundsChildren_ReturnsExpected(int x, int y)
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(new AccessibleObject());
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(2);
-            mockAccessibleObject
-                .Setup(a => a.HitTest(x, y))
-                .CallBase();
-            Assert.Same(mockAccessibleObject.Object, mockAccessibleObject.Object.HitTest(x, y));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(3, 5)]
-    public void AccessibleObject_HitTest_InvokeDefaultWithBoundsChildren_ReturnsExpected(int x, int y)
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild1
-                .Setup(a => a.Bounds)
-                .Returns(new Rectangle(1, 2, 3, 4));
-            var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild2
-                .Setup(a => a.Bounds)
-                .Returns(new Rectangle(1, 2, 3, 4));
-
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(mockAccessibleObjectChild1.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(2))
-                .Returns(mockAccessibleObjectChild2.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(3);
-            mockAccessibleObject
-                .Setup(a => a.HitTest(x, y))
-                .CallBase();
-            Assert.Same(mockAccessibleObjectChild1.Object, mockAccessibleObject.Object.HitTest(x, y));
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleNavigation>]
-    [InvalidEnumData<AccessibleNavigation>]
-    public void AccessibleObject_Navigate_InvokeDefault_ReturnsNull(AccessibleNavigation navdir)
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Null(accessibleObject.Navigate(navdir));
-    }
-
-    public static IEnumerable<object[]> Navigate_Child_TestData()
-    {
-        yield return new object[] { 0, null };
-        yield return new object[] { 0, new AccessibleObject() };
-        yield return new object[] { 1, null };
-        yield return new object[] { 1, new AccessibleObject() };
-        yield return new object[] { 2, null };
-        yield return new object[] { 2, new AccessibleObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Navigate_Child_TestData))]
-    public void AccessibleObject_Navigate_InvokeFirstChild_ReturnsNull(int childCount, AccessibleObject result)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(childCount);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns(result)
-            .Verifiable();
-        mockAccessibleObject
-            .Setup(a => a.Navigate(AccessibleNavigation.FirstChild))
-            .CallBase();
-        Assert.Same(result, mockAccessibleObject.Object.Navigate(AccessibleNavigation.FirstChild));
-        mockAccessibleObject.Verify(a => a.GetChild(0), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Navigate_Child_TestData))]
-    public void AccessibleObject_Navigate_InvokeLastChild_ReturnsNull(int childCount, AccessibleObject result)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(childCount);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(childCount - 1))
-            .Returns(result)
-            .Verifiable();
-        mockAccessibleObject
-            .Setup(a => a.Navigate(AccessibleNavigation.LastChild))
-            .CallBase();
-        Assert.Same(result, mockAccessibleObject.Object.Navigate(AccessibleNavigation.LastChild));
-        mockAccessibleObject.Verify(a => a.GetChild(childCount - 1), Times.Once());
-    }
-
-    public static IEnumerable<object[]> Navigate_WithParent_TestData()
-    {
-        foreach (int childCount in new int[] { 0, 1, 2 })
-        {
-            foreach (int parentChildCount in new int[] { -1, 0, 1 })
-            {
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Previous };
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Up };
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Left };
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Next };
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Down };
-                yield return new object[] { childCount, parentChildCount, AccessibleNavigation.Right };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Navigate_WithParent_TestData))]
-    public void AccessibleObject_Navigate_InvokeWithParent_ReturnsNull(int childCount, int parentChildCount, AccessibleNavigation navdir)
-    {
-        var mockParentAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockParentAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(parentChildCount)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(childCount);
-        mockAccessibleObject
-            .Setup(a => a.Parent)
-            .Returns(mockParentAccessibleObject.Object)
-            .Verifiable();
-        mockAccessibleObject
-            .Setup(a => a.Navigate(navdir))
-            .CallBase();
-        Assert.Null(mockAccessibleObject.Object.Navigate(navdir));
-        mockAccessibleObject.Verify(a => a.Parent, Times.Once());
-        mockParentAccessibleObject.Verify(a => a.GetChildCount(), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleNavigation.Previous)]
-    [InlineData(AccessibleNavigation.Up)]
-    [InlineData(AccessibleNavigation.Left)]
-    [InlineData(AccessibleNavigation.Next)]
-    [InlineData(AccessibleNavigation.Down)]
-    [InlineData(AccessibleNavigation.Right)]
-    public void AccessibleObject_Navigate_InvokeWithChildrenWithoutParent_ReturnsNull(AccessibleNavigation navdir)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(0);
-        mockAccessibleObject
-            .Setup(a => a.Parent)
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.Navigate(navdir))
-            .CallBase();
-
-        Assert.Null(mockAccessibleObject.Object.Navigate(navdir));
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleSelection>]
-    [InvalidEnumData<AccessibleSelection>]
-    public void AccessibleObject_Navigate_InvokeDefault_Nop(AccessibleSelection flags)
-    {
-        var accessibleObject = new AccessibleObject();
-        accessibleObject.Select(flags);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_Navigate_FormChildren()
-    {
-        using Form form = new();
-        using Control first = new();
-        using Control second = new();
-        form.Controls.Add(first);
-        form.Controls.Add(second);
-        form.Show();
-
-        AccessibleObject firstChild = form.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild);
-        Assert.NotNull(firstChild);
-        Assert.Equal((AccessibleObject)first.TestAccessor().Dynamic.NcAccessibilityObject, firstChild);
-
-        AccessibleObject next = firstChild.Navigate(AccessibleNavigation.Next);
-        Assert.NotNull(next);
-
-        AccessibleObject previous = next.Navigate(AccessibleNavigation.Previous);
-        Assert.NotNull(previous);
-        Assert.Same(firstChild, previous);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleNavigation.FirstChild, true, false)]
-    [InlineData(AccessibleNavigation.LastChild, true, false)]
-    [InlineData(AccessibleNavigation.Next, false, false)]
-    [InlineData(AccessibleNavigation.Previous, true, true)]
-    [InlineData(AccessibleNavigation.Right, false, false)]
-    [InlineData(AccessibleNavigation.Up, true, true)]
-    public void AccessibleObject_Navigate_FromForm_OneChild(AccessibleNavigation direction, bool returnsObject, bool isSystemAccessible)
-    {
-        using Form form = new();
-        using Control control = new();
-        form.Controls.Add(control);
-        form.Show();
-
-        AccessibleObject target = form.AccessibilityObject.Navigate(direction);
-
-        Assert.Equal(returnsObject, target is not null);
-        if (target is not null)
-        {
-            Assert.Equal(isSystemAccessible, (bool)target.TestAccessor().Dynamic._isSystemWrapper);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleNavigation.FirstChild, false)]
-    [InlineData(AccessibleNavigation.LastChild, false)]
-    [InlineData(AccessibleNavigation.Next, false)]
-    [InlineData(AccessibleNavigation.Previous, true)]
-    [InlineData(AccessibleNavigation.Right, false)]
-    [InlineData(AccessibleNavigation.Up, true)]
-    public void AccessibleObject_Navigate_FromForm_NoChildren(AccessibleNavigation direction, bool returnsObject)
-    {
-        using Form form = new();
-        form.Show();
-        AccessibleObject target = form.AccessibilityObject.Navigate(direction);
-        Assert.Equal(returnsObject, target is not null);
-        if (target is not null)
-        {
-            Assert.True((bool)target.TestAccessor().Dynamic._isSystemWrapper);
-        }
-    }
-
-    public static IEnumerable<object[]> UseStdAccessibleObjects_IntPtr_InvalidHandle_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseStdAccessibleObjects_IntPtr_InvalidHandle_TestData))]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrInvalidHandle_Success(IntPtr handle)
-    {
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(handle);
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrControlHandle_Success()
-    {
-        using var control = new Control();
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle);
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Client, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrLabelHandle_Success()
-    {
-        using var control = new Label
-        {
-            Text = "Text"
-        };
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle);
-        Assert.Equal(accessibleObject.Bounds, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Equal("Text", accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Graphic, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.ReadOnly, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    public static IEnumerable<object[]> UseStdAccessibleObjects_IntPtr_Int_InvalidHandle_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)1, 0 };
-        yield return new object[] { IntPtr.Zero, unchecked((int)0xFFFFFFFC) };
-        yield return new object[] { (IntPtr)1, unchecked((int)0xFFFFFFFC) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseStdAccessibleObjects_IntPtr_Int_InvalidHandle_TestData))]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntInvalidHandle_Success(IntPtr handle, int objid)
-    {
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(handle, objid);
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntControlHandleInvalidId_Success()
-    {
-        using var control = new Control();
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, 250);
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntControlHandleWindowId_Success()
-    {
-        using var control = new Control();
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, 0);
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Window, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Invisible | AccessibleStates.Offscreen | AccessibleStates.Focusable, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntControlHandleClientId_Success()
-    {
-        using var control = new Control();
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, unchecked((int)0xFFFFFFFC));
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Client, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntLabelHandleInvalidId_Success()
-    {
-        using var control = new Label
-        {
-            Text = "Text"
-        };
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, 250);
-        Assert.Equal(accessibleObject.Bounds, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntLabelHandleClientId_Success()
-    {
-        using var control = new Label
-        {
-            Text = "Text"
-        };
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, unchecked((int)0xFFFFFFFC));
-        Assert.Equal(accessibleObject.Bounds, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Equal("Text", accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Graphic, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.ReadOnly, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_UseStdAccessibleObjects_InvokeIntPtrIntLabelHandleWindowId_Success()
-    {
-        using var control = new Label
-        {
-            Text = "Text"
-        };
-        var accessibleObject = new SubAccessibleObject();
-        accessibleObject.UseStdAccessibleObjects(control.Handle, 0);
-        Assert.Equal(accessibleObject.Bounds, accessibleObject.Bounds);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Equal("Text", accessibleObject.Name);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Window, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Invisible | AccessibleStates.Offscreen | AccessibleStates.Focusable, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, -2)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void AccessibleObject_IAccessiblaccChildCount_InvokeDefault_ReturnsExpected(int childCount, int expectedChildCount)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(childCount)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(expectedChildCount, iAccessible.accChildCount);
-        mockAccessibleObject.Verify(a => a.GetChildCount(), Times.Once());
-    }
-
-    public static IEnumerable<object[]> SelfVarChild_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { 0 };
-        yield return new object[] { unchecked((int)0x80020004) };
-        yield return new object[] { "abc" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelfVarChild_TestData))]
-    public void AccessibleObject_IAccessibleaccDoDefaultAction_InvokeDefaultSelf_Success(object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.DoDefaultAction())
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accDoDefaultAction(varChild);
-        mockAccessibleObject.Verify(a => a.DoDefaultAction(), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 1, 0)]
-    [InlineData(3, 0, 1)]
-    public void AccessibleObject_IAccessibleaccDoDefaultAction_InvokeDefaultChild_Success(object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.DoDefaultAction())
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.DoDefaultAction())
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accDoDefaultAction(varChild);
-        mockAccessibleObjectChild1.Verify(a => a.DoDefaultAction(), Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.DoDefaultAction(), Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleaccDoDefaultAction_InvokeDefaultNoSuchChild_Success(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accDoDefaultAction(varChild);
-    }
-
-    public static IEnumerable<object[]> accFocus_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AccessibleObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(accFocus_TestData))]
-    public void AccessibleObject_IAccessibleget_accFocus_InvokeDefault_ReturnsExpected(AccessibleObject result)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetFocused())
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Same(result, iAccessible.accFocus);
-        mockAccessibleObject.Verify(a => a.GetFocused(), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IAccessiblaccFocus_InvokeDefaultSelf_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetFocused())
-            .Returns(mockAccessibleObject.Object)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(0, iAccessible.accFocus);
-        mockAccessibleObject.Verify(a => a.GetFocused(), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefault_ReturnsNull(int x, int y)
-    {
-        var accessibleObject = new AccessibleObject();
-        IAccessible iAccessible = accessibleObject;
-        Assert.Null(iAccessible.accHitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(3, 5)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefaultWithNoChildrenBoundsValid_ReturnsExpected(int x, int y)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4));
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.HitTest(x, y))
-            .CallBase();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(0, iAccessible.accHitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(4, 2)]
-    [InlineData(1, 6)]
-    [InlineData(4, 5)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefaultWithNoChildrenBoundsInvalid_ReturnsNull(int x, int y)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4));
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .CallBase();
-        mockAccessibleObject
-            .Setup(a => a.HitTest(x, y))
-            .CallBase();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.accHitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefaultWithNoBoundsChildren_ReturnsExpected(int x, int y)
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(new AccessibleObject());
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(2);
-            mockAccessibleObject
-                .Setup(a => a.HitTest(x, y))
-                .CallBase();
-            IAccessible iAccessible = mockAccessibleObject.Object;
-            Assert.Equal(0, iAccessible.accHitTest(x, y));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(3, 5)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefaultWithBoundsChildren_ReturnsExpected(int x, int y)
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild1
-                .Setup(a => a.Bounds)
-                .Returns(new Rectangle(1, 2, 3, 4));
-            var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObjectChild2
-                .Setup(a => a.Bounds)
-                .Returns(new Rectangle(1, 2, 3, 4));
-
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(mockAccessibleObjectChild1.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(2))
-                .Returns(mockAccessibleObjectChild2.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(3);
-            mockAccessibleObject
-                .Setup(a => a.HitTest(x, y))
-                .CallBase();
-            IAccessible iAccessible = mockAccessibleObject.Object;
-            Assert.Same(mockAccessibleObjectChild1.Object, iAccessible.accHitTest(x, y));
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelfVarChild_TestData))]
-    public void AccessibleObject_IAccessibleaccLocation_InvokeDefaultSelf_Success(object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4))
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, varChild);
-        Assert.Equal(1, pxLeft);
-        Assert.Equal(2, pyTop);
-        Assert.Equal(3, pcxWidth);
-        Assert.Equal(4, pcyHeight);
-        mockAccessibleObject.Verify(a => a.Bounds, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 1, 0)]
-    [InlineData(3, 0, 1)]
-    public void AccessibleObject_IAccessibleaccLocation_InvokeDefaultChild_Success(object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4))
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Bounds)
-            .Returns(new Rectangle(1, 2, 3, 4))
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, varChild);
-        Assert.Equal(1, pxLeft);
-        Assert.Equal(2, pyTop);
-        Assert.Equal(3, pcxWidth);
-        Assert.Equal(4, pcyHeight);
-        mockAccessibleObjectChild1.Verify(a => a.Bounds, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Bounds, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleaccLocation_InvokeDefaultNoSuchChild_Success(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, varChild);
-        Assert.Equal(0, pxLeft);
-        Assert.Equal(0, pyTop);
-        Assert.Equal(0, pcxWidth);
-        Assert.Equal(0, pcyHeight);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleNavigation.Right, 0)]
-    [InlineData((int)AccessibleNavigation.Right, unchecked((int)0x80020004))]
-    [InlineData((int)AccessibleNavigation.Right, "abc")]
-    [InlineData((int)AccessibleNavigation.Right, null)]
-    public void AccessibleObject_IAccessibleaccNavigate_InvokeDefaultSelf_Success(int navDir, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Navigate((AccessibleNavigation)navDir))
-            .Returns(mockAccessibleObject.Object)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(0, iAccessible.accNavigate(navDir, varChild));
-        mockAccessibleObject.Verify(a => a.Navigate((AccessibleNavigation)navDir), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleNavigation.Right, 2, 1, 0)]
-    [InlineData((int)AccessibleNavigation.Right, 3, 0, 1)]
-    public void AccessibleObject_IAccessibleaccNavigate_InvokeDefaultChild_Success(int navDir, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Navigate((AccessibleNavigation)navDir))
-            .Returns(mockAccessibleObjectChild1.Object)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Navigate((AccessibleNavigation)navDir))
-            .Returns(mockAccessibleObjectChild2.Object)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.NotEqual(0, iAccessible.accNavigate(navDir, varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Navigate((AccessibleNavigation)navDir), Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Navigate((AccessibleNavigation)navDir), Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleNavigation.Right, 2, 1, 0)]
-    [InlineData((int)AccessibleNavigation.Right, 3, 0, 1)]
-    public void AccessibleObject_IAccessibleaccNavigate_InvokeDefaultChildSelf_Success(int navDir, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Navigate((AccessibleNavigation)navDir))
-            .Returns(mockAccessibleObject.Object)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Navigate((AccessibleNavigation)navDir))
-            .Returns(mockAccessibleObject.Object)
-            .Verifiable();
-
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(0, iAccessible.accNavigate(navDir, varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Navigate((AccessibleNavigation)navDir), Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Navigate((AccessibleNavigation)navDir), Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleNavigation.Right, -1)]
-    [InlineData((int)AccessibleNavigation.Right, 4)]
-    public void AccessibleObject_IAccessibleaccNavigate_InvokeDefaultNoSuchChild_Success(int navDir, object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.accNavigate(navDir, varChild));
-    }
-
-    public static IEnumerable<object[]> accParent_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AccessibleObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(accParent_TestData))]
-    public void AccessibleObject_IAccessiblaccParent_InvokeDefault_ReturnsExpected(AccessibleObject result)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Parent)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Same(result, iAccessible.accParent);
-        mockAccessibleObject.Verify(a => a.Parent, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IAccessiblaccParent_InvokeDefaultSelf_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.Parent)
-                .Returns(mockAccessibleObject.Object)
-                .Verifiable();
-            IAccessible iAccessible = mockAccessibleObject.Object;
-            Assert.Null(iAccessible.accParent);
-            mockAccessibleObject.Verify(a => a.Parent, Times.Once());
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleSelection.AddSelection, 0)]
-    [InlineData((int)AccessibleSelection.AddSelection, unchecked((int)0x80020004))]
-    [InlineData((int)AccessibleSelection.AddSelection, "abc")]
-    [InlineData((int)AccessibleSelection.AddSelection, null)]
-    public void AccessibleObject_IAccessibleaccSelect_InvokeDefaultSelf_Success(int flagsSelect, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Select((AccessibleSelection)flagsSelect))
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accSelect(flagsSelect, varChild);
-        mockAccessibleObject.Verify(a => a.Select((AccessibleSelection)flagsSelect), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleSelection.AddSelection, 2, 1, 0)]
-    [InlineData((int)AccessibleSelection.AddSelection, 3, 0, 1)]
-    public void AccessibleObject_IAccessibleaccSelect_InvokeDefaultChild_Success(int flagsSelect, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Select((AccessibleSelection)flagsSelect))
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Select((AccessibleSelection)flagsSelect))
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accSelect(flagsSelect, varChild);
-        mockAccessibleObjectChild1.Verify(a => a.Select((AccessibleSelection)flagsSelect), Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Select((AccessibleSelection)flagsSelect), Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)AccessibleSelection.AddSelection, -1)]
-    [InlineData((int)AccessibleSelection.AddSelection, 4)]
-    public void AccessibleObject_IAccessibleaccSelect_InvokeDefaultNoSuchChild_Success(int flagsSelect, object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.accSelect(flagsSelect, varChild);
-    }
-
-    public static IEnumerable<object[]> accSelection_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AccessibleObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(accSelection_TestData))]
-    public void AccessibleObject_IAccessibleget_accSelection_InvokeDefault_ReturnsExpected(AccessibleObject result)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetSelected())
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Same(result, iAccessible.accSelection);
-        mockAccessibleObject.Verify(a => a.GetSelected(), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IAccessiblaccSelection_InvokeDefaultSelf_ReturnsExpected()
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetSelected())
-            .Returns(mockAccessibleObject.Object)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(0, iAccessible.accSelection);
-        mockAccessibleObject.Verify(a => a.GetSelected(), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelfVarChild_TestData))]
-    public void AccessibleObject_IAccessibleget_AccChild_InvokeDefaultSelf_ReturnsExpected(object varChild)
-    {
-        var accessibleObject = new AccessibleObject();
-        IAccessible iAccessible = accessibleObject;
-        Assert.Same(iAccessible, iAccessible.get_accChild(varChild));
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IAccessibleget_accChild_InvokeDefaultChild_Success()
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accChild(1));
-        Assert.Same(mockAccessibleObjectChild1.Object, iAccessible.get_accChild(2));
-        Assert.Same(mockAccessibleObjectChild2.Object, iAccessible.get_accChild(3));
-    }
-
-    [WinFormsTheory]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void AccessibleObject_IAccessibleget_accChild_InvokeDefaultChildSelf_ReturnsExpected(object varChild)
-    {
-        using (new NoAssertContext())
-        {
-            var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-            var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-            var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(0))
-                .Returns((AccessibleObject)null);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(1))
-                .Returns(mockAccessibleObject.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChild(2))
-                .Returns(mockAccessibleObject.Object);
-            mockAccessibleObject
-                .Setup(a => a.GetChildCount())
-                .Returns(3);
-
-            IAccessible iAccessible = mockAccessibleObject.Object;
-            Assert.Null(iAccessible.get_accChild(varChild));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accChild_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accChild(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accDefaultAction_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.DefaultAction)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accDefaultAction(varChild));
-        mockAccessibleObject.Verify(a => a.DefaultAction, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accDefaultAction_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.DefaultAction)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.DefaultAction)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accDefaultAction(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.DefaultAction, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.DefaultAction, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accDefaultAction_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accDefaultAction(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accDescription_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Description)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accDescription(varChild));
-        mockAccessibleObject.Verify(a => a.Description, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accDescription_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Description)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Description)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accDescription(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Description, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Description, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accDescription_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accDescription(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accHelp_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Help)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accHelp(varChild));
-        mockAccessibleObject.Verify(a => a.Help, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accHelp_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Help)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Help)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accHelp(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Help, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Help, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accHelp_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accHelp(varChild));
-    }
-
-    private delegate void HelpTopicDelegate(out string pszHelpFile);
-
-    [WinFormsTheory]
-    [InlineData(-1, null, 0)]
-    [InlineData(0, null, unchecked((int)0x80020004))]
-    [InlineData(1, null, "abc")]
-    [InlineData(2, null, null)]
-    [InlineData(-1, "", 0)]
-    [InlineData(0, "", unchecked((int)0x80020004))]
-    [InlineData(1, "", "abc")]
-    [InlineData(2, "", null)]
-    [InlineData(-1, "value", 0)]
-    [InlineData(0, "value", unchecked((int)0x80020004))]
-    [InlineData(1, "value", "abc")]
-    [InlineData(2, "value", null)]
-    public void AccessibleObject_IAccessibleget_accHelpTopic_InvokeDefaultSelf_ReturnsExpected(int result, string stringResult, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        string dummy;
-        HelpTopicDelegate handler = (out string pszHelpFile) =>
-        {
-            pszHelpFile = stringResult;
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetHelpTopic(out dummy))
-            .Callback(handler)
-            .Returns(result);
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accHelpTopic(out string pszHelpFile, varChild));
-        Assert.Equal(stringResult, pszHelpFile);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null, 2)]
-    [InlineData(0, "", 2)]
-    [InlineData(1, "value", 2)]
-    [InlineData(-1, null, 3)]
-    [InlineData(0, "", 3)]
-    [InlineData(1, "value", 3)]
-    public void AccessibleObject_IAccessibleget_accHelpTopic_InvokeDefaultChild_ReturnsExpected(int result, string stringResult, object varChild)
-    {
-        string dummy;
-        HelpTopicDelegate handler = (out string pszHelpFile) =>
-        {
-            pszHelpFile = stringResult;
-        };
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.GetHelpTopic(out dummy))
-            .Callback(handler)
-            .Returns(result);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.GetHelpTopic(out dummy))
-            .Callback(handler)
-            .Returns(result);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accHelpTopic(out string pszHelpFile, varChild));
-        Assert.Equal(stringResult, pszHelpFile);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accHelpTopic_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(-1, iAccessible.get_accHelpTopic(out string pszHelpFile, varChild));
-        Assert.Null(pszHelpFile);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accKeyboardShortcut_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.KeyboardShortcut)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accKeyboardShortcut(varChild));
-        mockAccessibleObject.Verify(a => a.KeyboardShortcut, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accKeyboardShortcut_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObjectChild1
-            .Setup(a => a.KeyboardShortcut)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObjectChild2
-            .Setup(a => a.KeyboardShortcut)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accKeyboardShortcut(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.KeyboardShortcut, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.KeyboardShortcut, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accKeyboardShortcut_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accKeyboardShortcut(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accName_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.Name)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accName(varChild));
-        mockAccessibleObject.Verify(a => a.Name, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accName_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObjectChild1
-            .Setup(a => a.Name)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObjectChild2
-            .Setup(a => a.Name)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accName(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Name, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Name, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accName_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accName(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleRole.None, 0)]
-    [InlineData(AccessibleRole.None, unchecked((int)0x80020004))]
-    [InlineData(AccessibleRole.None, "abc")]
-    [InlineData(AccessibleRole.None, null)]
-    [InlineData(AccessibleRole.Default, 0)]
-    [InlineData(AccessibleRole.Default, unchecked((int)0x80020004))]
-    [InlineData(AccessibleRole.Default, "abc")]
-    [InlineData(AccessibleRole.Default, null)]
-    [InlineData(AccessibleRole.Sound, 0)]
-    [InlineData(AccessibleRole.Sound, unchecked((int)0x80020004))]
-    [InlineData(AccessibleRole.Sound, "abc")]
-    [InlineData(AccessibleRole.Sound, null)]
-    public void AccessibleObject_IAccessibleget_accRole_InvokeDefaultSelf_ReturnsExpected(AccessibleRole result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Role)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal((int)result, iAccessible.get_accRole(varChild));
-        mockAccessibleObject.Verify(a => a.Role, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_IAccessibleget_accRole_InvokeDefaultSelfNotAClientObject_ReturnsExpected()
-    {
-        using Control control = new();
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = control.TestAccessor().Dynamic.NcAccessibilityObject;
-
-        IAccessible iAccessible = accessibleObject;
-        Assert.Equal(AccessibleRole.Window, iAccessible.get_accRole((int)PInvoke.CHILDID_SELF));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleRole.None, 2, 1, 0)]
-    [InlineData(AccessibleRole.Default, 2, 1, 0)]
-    [InlineData(AccessibleRole.Sound, 2, 1, 0)]
-    [InlineData(AccessibleRole.None, 3, 0, 1)]
-    [InlineData(AccessibleRole.Default, 3, 0, 1)]
-    [InlineData(AccessibleRole.Sound, 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accRole_InvokeDefaultChild_ReturnsExpected(AccessibleRole result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Role)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Role)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal((int)result, iAccessible.get_accRole(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Role, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Role, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accRole_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accRole(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleStates.None, 0)]
-    [InlineData(AccessibleStates.None, unchecked((int)0x80020004))]
-    [InlineData(AccessibleStates.None, "abc")]
-    [InlineData(AccessibleStates.None, null)]
-    [InlineData(AccessibleStates.Mixed, 0)]
-    [InlineData(AccessibleStates.Mixed, unchecked((int)0x80020004))]
-    [InlineData(AccessibleStates.Mixed, "abc")]
-    [InlineData(AccessibleStates.Mixed, null)]
-    public void AccessibleObject_IAccessibleget_accState_InvokeDefaultSelf_ReturnsExpected(AccessibleStates result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.State)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal((int)result, iAccessible.get_accState(varChild));
-        mockAccessibleObject.Verify(a => a.State, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleStates.None, 2, 1, 0)]
-    [InlineData(AccessibleStates.Mixed, 2, 1, 0)]
-    [InlineData(AccessibleStates.None, 3, 0, 1)]
-    [InlineData(AccessibleStates.Mixed, 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accState_InvokeDefaultChild_ReturnsExpected(AccessibleStates result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.State)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.State)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal((int)result, iAccessible.get_accState(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.State, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.State, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accState_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accState(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData(null, unchecked((int)0x80020004))]
-    [InlineData(null, "abc")]
-    [InlineData(null, null)]
-    [InlineData("", 0)]
-    [InlineData("", unchecked((int)0x80020004))]
-    [InlineData("", "abc")]
-    [InlineData("", null)]
-    [InlineData("value", 0)]
-    [InlineData("value", unchecked((int)0x80020004))]
-    [InlineData("value", "abc")]
-    [InlineData("value", null)]
-    public void AccessibleObject_IAccessibleget_accValue_InvokeDefaultSelf_ReturnsExpected(string result, object varChild)
-    {
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.Value)
-            .Returns(result)
-            .Verifiable();
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accValue(varChild));
-        mockAccessibleObject.Verify(a => a.Value, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 2, 1, 0)]
-    [InlineData("", 2, 1, 0)]
-    [InlineData("value", 2, 1, 0)]
-    [InlineData(null, 3, 0, 1)]
-    [InlineData("", 3, 0, 1)]
-    [InlineData("value", 3, 0, 1)]
-    public void AccessibleObject_IAccessibleget_accValue_InvokeDefaultChild_ReturnsExpected(string result, object varChild, int child1CallCount, int child2CallCount)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild1
-            .Setup(a => a.Value)
-            .Returns(result)
-            .Verifiable();
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObjectChild2
-            .Setup(a => a.Value)
-            .Returns(result)
-            .Verifiable();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Equal(result, iAccessible.get_accValue(varChild));
-        mockAccessibleObjectChild1.Verify(a => a.Value, Times.Exactly(child1CallCount));
-        mockAccessibleObjectChild2.Verify(a => a.Value, Times.Exactly(child2CallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    public void AccessibleObject_IAccessibleget_accValue_InvokeDefaultNoSuchChild_ReturnsNull(object varChild)
-    {
-        var mockAccessibleObjectChild1 = new Mock<AccessibleObject>(MockBehavior.Strict);
-        var mockAccessibleObjectChild2 = new Mock<AccessibleObject>(MockBehavior.Strict);
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(mockAccessibleObjectChild1.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(mockAccessibleObjectChild2.Object);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        Assert.Null(iAccessible.get_accValue(varChild));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, null)]
-    [InlineData(unchecked((int)0x80020004), null)]
-    [InlineData("abc", null)]
-    [InlineData(null, null)]
-    [InlineData(0, "")]
-    [InlineData(unchecked((int)0x80020004), "")]
-    [InlineData("abc", "")]
-    [InlineData(null, "")]
-    [InlineData(0, "value")]
-    [InlineData(unchecked((int)0x80020004), "value")]
-    [InlineData("abc", "value")]
-    [InlineData(null, "value")]
-    public void AccessibleObject_IAccessibleset_accName_InvokeDefaultSelf_ReturnsExpected(object varChild, string value)
-    {
-        var accessibleObject = new AccessibleObject();
-        IAccessible iAccessible = accessibleObject;
-        iAccessible.set_accName(varChild, value);
-        Assert.Null(iAccessible.get_accName(varChild));
-        Assert.Null(accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, null)]
-    [InlineData(2, "")]
-    [InlineData(2, "value")]
-    [InlineData(3, null)]
-    [InlineData(3, "")]
-    [InlineData(3, "value")]
-    public void AccessibleObject_IAccessibleset_accName_InvokeDefaultChild_ReturnsExpected(object varChild, string value)
-    {
-        var childAccessibleObject1 = new AccessibleObject();
-        var childAccessibleObject2 = new AccessibleObject();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(childAccessibleObject1);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(childAccessibleObject2);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.set_accName(varChild, value);
-        Assert.Null(iAccessible.get_accName(varChild));
-        Assert.Null(childAccessibleObject1.Name);
-        Assert.Null(childAccessibleObject2.Name);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(-1, "")]
-    [InlineData(-1, "value")]
-    [InlineData(4, null)]
-    [InlineData(4, "")]
-    [InlineData(4, "value")]
-    public void AccessibleObject_IAccessibleset_accName_InvokeDefaultNoSuchChild_ReturnsNull(object varChild, string value)
-    {
-        var childAccessibleObject1 = new AccessibleObject();
-        var childAccessibleObject2 = new AccessibleObject();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>
-        {
-            CallBase = true
-        };
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(childAccessibleObject1);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(childAccessibleObject2);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.set_accName(varChild, value);
-        Assert.Null(iAccessible.get_accName(varChild));
-        Assert.Null(childAccessibleObject1.Name);
-        Assert.Null(childAccessibleObject2.Name);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, null)]
-    [InlineData(unchecked((int)0x80020004), null)]
-    [InlineData("abc", null)]
-    [InlineData(null, null)]
-    [InlineData(0, "")]
-    [InlineData(unchecked((int)0x80020004), "")]
-    [InlineData("abc", "")]
-    [InlineData(null, "")]
-    [InlineData(0, "value")]
-    [InlineData(unchecked((int)0x80020004), "value")]
-    [InlineData("abc", "value")]
-    [InlineData(null, "value")]
-    public void AccessibleObject_IAccessibleset_accValue_InvokeDefaultSelf_ReturnsExpected(object varChild, string value)
-    {
-        var accessibleObject = new AccessibleObject();
-        IAccessible iAccessible = accessibleObject;
-        iAccessible.set_accValue(varChild, value);
-        Assert.Empty(iAccessible.get_accValue(varChild));
-        Assert.Empty(accessibleObject.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, null)]
-    [InlineData(2, "")]
-    [InlineData(2, "value")]
-    [InlineData(3, null)]
-    [InlineData(3, "")]
-    [InlineData(3, "value")]
-    public void AccessibleObject_IAccessibleset_accValue_InvokeDefaultChild_ReturnsExpected(object varChild, string value)
-    {
-        var childAccessibleObject1 = new AccessibleObject();
-        var childAccessibleObject2 = new AccessibleObject();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(childAccessibleObject1);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(childAccessibleObject2);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.set_accValue(varChild, value);
-        Assert.Empty(iAccessible.get_accValue(varChild));
-        Assert.Empty(childAccessibleObject1.Value);
-        Assert.Empty(childAccessibleObject2.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(-1, "")]
-    [InlineData(-1, "value")]
-    [InlineData(4, null)]
-    [InlineData(4, "")]
-    [InlineData(4, "value")]
-    public void AccessibleObject_IAccessibleset_accValue_InvokeDefaultNoSuchChild_ReturnsNull(object varChild, string value)
-    {
-        var childAccessibleObject1 = new AccessibleObject();
-        var childAccessibleObject2 = new AccessibleObject();
-
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(0))
-            .Returns((AccessibleObject)null);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(1))
-            .Returns(childAccessibleObject1);
-        mockAccessibleObject
-            .Setup(a => a.GetChild(2))
-            .Returns(childAccessibleObject2);
-        mockAccessibleObject
-            .Setup(a => a.GetChildCount())
-            .Returns(3);
-
-        IAccessible iAccessible = mockAccessibleObject.Object;
-        iAccessible.set_accValue(varChild, value);
-        Assert.Null(iAccessible.get_accValue(varChild));
-        Assert.Empty(childAccessibleObject1.Value);
-        Assert.Empty(childAccessibleObject2.Value);
-    }
-
-    [DllImport("Oleacc.dll")]
-    internal static extern unsafe HRESULT AccessibleObjectFromPoint(
-        Point ptScreen,
-        [MarshalAs(UnmanagedType.Interface)]
-        out object ppacc,
-        out object pvarChild);
-
-    [WinFormsFact(Skip = "This test needs to be run manually as it depends on the form being unobstructed.")]
-    public unsafe void TestAccessibleObjectFromPoint_Button()
-    {
-        using Form form = new Form();
-        using Button button = new Button
-        {
-            Text = "MSAA Button"
-        };
-
-        form.Controls.Add(button);
-        form.Show();
-        var bounds = button.Bounds;
-        Point point = button.Location;
-        point.Offset(bounds.Width / 2, bounds.Height / 2);
-        point = button.PointToScreen(point);
-        var result = AccessibleObjectFromPoint(
-            point,
-            out object ppacc,
-            out object varItem);
-
-        Assert.Equal(HRESULT.S_OK, result);
-        Assert.NotNull(ppacc);
-        Assert.True(varItem is int);
-
-        IAccessible accessible = ppacc as IAccessible;
-        Assert.NotNull(accessible);
-        Assert.Equal("MSAA Button", accessible.accName);
-        Assert.True(((int)accessible.accState & 0x100000) != 0);    // STATE_SYSTEM_FOCUSABLE
-        Assert.Equal(0x2b, accessible.accRole);                     // ROLE_SYSTEM_PUSHBUTTON
-        Assert.Equal("Press", accessible.accDefaultAction);
-    }
-
-    [WinFormsFact(Skip = "This test needs to be run manually as it depends on the form being unobstructed.")]
-    public unsafe void TestAccessibleObjectFromPoint_ComboBox()
-    {
-        using Form form = new Form();
-        using ComboBox comboBox = new ComboBox();
-        comboBox.Items.Add("Item One");
-        comboBox.Items.Add("Item Two");
-
-        form.Controls.Add(comboBox);
-        form.Show();
-        var bounds = comboBox.Bounds;
-        Point point = comboBox.Location;
-        point.Offset(bounds.Width / 2, bounds.Height / 2);
-        point = comboBox.PointToScreen(point);
-        var result = AccessibleObjectFromPoint(
-            point,
-            out object ppacc,
-            out object varItem);
-
-        Assert.Equal(HRESULT.S_OK, result);
-        Assert.NotNull(ppacc);
-        Assert.True(varItem is int);
-
-        IAccessible accessible = ppacc as IAccessible;
-        Assert.NotNull(accessible);
-        Assert.Null(accessible.accName);
-        Assert.True(((int)accessible.accState & 0x100000) != 0);    // STATE_SYSTEM_FOCUSABLE
-        Assert.Equal(0x2a, accessible.accRole);                     // ROLE_SYSTEM_TEXT
-        Assert.Null(accessible.accDefaultAction);
-
-        var parent = accessible.accParent as IAccessible;
-        Assert.Equal(0x09, parent.accRole);                         // ROLE_SYSTEM_WINDOW
-        Assert.Equal(7, parent.accChildCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ControlTypePropertyId)]
-    [InlineData((int)UiaCore.UIA.AutomationIdPropertyId)]
-    public void AccessibleObject_GetPropertyValue_ReturnsNull_IfExpected(int propertyId)
-    {
-        AccessibleObject accessibleObject = new AccessibleObject();
-
-        Assert.Null(accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId));
-    }
-
-    public static IEnumerable<object[]> AccessibleObject_RuntimeId_IsOverriden_TestData()
-    {
-        Assembly assembly = typeof(AccessibleObject).Assembly;
-        foreach (Type type in assembly.GetTypes())
-        {
-            // ComboBox.ChildAccessibleObject is more like an abstract class, so we should check its direct inheritors instead of it
-            if (type.BaseType != typeof(AccessibleObject) && type.BaseType != typeof(ComboBox.ChildAccessibleObject))
-            {
-                continue;
-            }
-
-            if (type == typeof(ComboBox.ChildAccessibleObject))
-            {
-                continue;
-            }
-
-            yield return new object[] { type };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibleObject_RuntimeId_IsOverriden_TestData))]
-    public void AccessibleObject_RuntimeId_IsOverriden(Type type)
-    {
-        PropertyInfo runtimeIdProperty = type.GetProperty(nameof(AccessibleObject.RuntimeId), BindingFlags.NonPublic | BindingFlags.Instance);
-
-        Assert.Equal(type, runtimeIdProperty.DeclaringType);
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_GetIAccessiblePair_Invoke_ReturnsExpected()
-    {
-        const int expectedIdChild = (int)PInvoke.CHILDID_SELF;
-
-        AccessibleObject accessibleObject = new();
-
-        // Use some number different from the expected to ensure that the value is changed
-        int idChild = unchecked((int)0xdeadbeef);
-        Assert.NotEqual(expectedIdChild, idChild);
-
-        HRESULT result = ((UiaCore.IAccessibleEx)accessibleObject).GetIAccessiblePair(out object pAcc, &idChild);
-
-        Assert.Equal(HRESULT.S_OK, result);
-        Assert.Equal(accessibleObject, pAcc);
-        Assert.Equal(expectedIdChild, idChild);
-    }
-
-    [WinFormsFact]
-    public unsafe void AccessibleObject_GetIAccessiblePair_InvokeWithInvalidArgument_ReturnsError()
-    {
-        AccessibleObject accessibleObject = new();
-
-        HRESULT result = ((UiaCore.IAccessibleEx)accessibleObject).GetIAccessiblePair(out object pAcc, null);
-
-        Assert.Equal(HRESULT.E_INVALIDARG, result);
-        Assert.Null(pAcc);
-    }
-
-    [WinFormsFact]
-    public void AccessibleObject_SystemWrapper_RuntimeId_IsValid()
-    {
-        AccessibleObject accessibleObject =
-            (AccessibleObject)Activator.CreateInstance(typeof(AccessibleObject), BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.NotEmpty(accessibleObject.TestAccessor().Dynamic.RuntimeId);
-    }
-
-    private class SubAccessibleObject : AccessibleObject
-    {
-        public new void UseStdAccessibleObjects(IntPtr handle) => base.UseStdAccessibleObjects(handle);
-
-        public new void UseStdAccessibleObjects(IntPtr handle, int objid) => base.UseStdAccessibleObjects(handle, objid);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleRoleControlTypeMapTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleRoleControlTypeMapTests.cs
deleted file mode 100644
index a59f1fd75e4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AccessibleRoleControlTypeMapTests.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class AccessibleRoleControlTypeMapTests
-{
-    public static IEnumerable<object[]> AccessibleRoleControlTypeMap_Contains_AllRoles_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibleRoleControlTypeMap_Contains_AllRoles_TestData))]
-    public void AccessibleRoleControlTypeMap_Contains_AllRoles(AccessibleRole role)
-    {
-        // Check if the map contains the role
-        // If so the map returns an exist UIA_ControlTypeId
-        UIA actual = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.True(actual >= UIA.ButtonControlTypeId && actual <= UIA.AppBarControlTypeId);
-    }
-
-    [WinFormsFact]
-    public void AccessibleRoleControlTypeMap_GetControlType_ThrowsException_IfRoleArgumentIsIncorrect()
-    {
-        AccessibleRole incorrectRole = (AccessibleRole)(-999);
-
-        Assert.Throws<KeyNotFoundException>(() => AccessibleRoleControlTypeMap.GetControlType(incorrectRole));
-    }
-
-    public static IEnumerable<object[]> AccessibleRoleControlTypeMap_GetControlType_ReturnsExpectedValue_TestData()
-    {
-        yield return new object[] { AccessibleRole.Alert, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Animation, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Application, UIA.WindowControlTypeId };
-        yield return new object[] { AccessibleRole.Border, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.ButtonDropDown, UIA.SplitButtonControlTypeId };
-        yield return new object[] { AccessibleRole.ButtonDropDownGrid, UIA.ButtonControlTypeId };
-        yield return new object[] { AccessibleRole.ButtonMenu, UIA.MenuItemControlTypeId };
-        yield return new object[] { AccessibleRole.Caret, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Cell, UIA.DataItemControlTypeId };
-        yield return new object[] { AccessibleRole.Character, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Chart, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.CheckButton, UIA.CheckBoxControlTypeId };
-        yield return new object[] { AccessibleRole.Client, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Clock, UIA.ButtonControlTypeId };
-        yield return new object[] { AccessibleRole.Column, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.ColumnHeader, UIA.HeaderControlTypeId };
-        yield return new object[] { AccessibleRole.ComboBox, UIA.ComboBoxControlTypeId };
-        yield return new object[] { AccessibleRole.Cursor, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Default, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Diagram, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Dial, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Dialog, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Document, UIA.DocumentControlTypeId };
-        yield return new object[] { AccessibleRole.DropList, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Equation, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Graphic, UIA.ImageControlTypeId };
-        yield return new object[] { AccessibleRole.Grip, UIA.ThumbControlTypeId };
-        yield return new object[] { AccessibleRole.Grouping, UIA.GroupControlTypeId };
-        yield return new object[] { AccessibleRole.HelpBalloon, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.HotkeyField, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Indicator, UIA.ThumbControlTypeId };
-        yield return new object[] { AccessibleRole.IpAddress, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Link, UIA.HyperlinkControlTypeId };
-        yield return new object[] { AccessibleRole.List, UIA.ListControlTypeId };
-        yield return new object[] { AccessibleRole.ListItem, UIA.ListItemControlTypeId };
-        yield return new object[] { AccessibleRole.MenuBar, UIA.MenuBarControlTypeId };
-        yield return new object[] { AccessibleRole.MenuItem, UIA.MenuItemControlTypeId };
-        yield return new object[] { AccessibleRole.MenuPopup, UIA.MenuControlTypeId };
-        yield return new object[] { AccessibleRole.None, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Outline, UIA.TreeControlTypeId };
-        yield return new object[] { AccessibleRole.OutlineButton, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.OutlineItem, UIA.TreeItemControlTypeId };
-        yield return new object[] { AccessibleRole.PageTab, UIA.TabItemControlTypeId };
-        yield return new object[] { AccessibleRole.PageTabList, UIA.TabControlTypeId };
-        yield return new object[] { AccessibleRole.Pane, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.ProgressBar, UIA.ProgressBarControlTypeId };
-        yield return new object[] { AccessibleRole.PropertyPage, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.PushButton, UIA.ButtonControlTypeId };
-        yield return new object[] { AccessibleRole.RadioButton, UIA.RadioButtonControlTypeId };
-        yield return new object[] { AccessibleRole.Row, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.RowHeader, UIA.HeaderControlTypeId };
-        yield return new object[] { AccessibleRole.ScrollBar, UIA.ScrollBarControlTypeId };
-        yield return new object[] { AccessibleRole.Separator, UIA.SeparatorControlTypeId };
-        yield return new object[] { AccessibleRole.Slider, UIA.SliderControlTypeId };
-        yield return new object[] { AccessibleRole.Sound, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.SpinButton, UIA.SpinnerControlTypeId };
-        yield return new object[] { AccessibleRole.SplitButton, UIA.SplitButtonControlTypeId };
-        yield return new object[] { AccessibleRole.StaticText, UIA.TextControlTypeId };
-        yield return new object[] { AccessibleRole.StatusBar, UIA.StatusBarControlTypeId };
-        yield return new object[] { AccessibleRole.Table, UIA.TableControlTypeId };
-        yield return new object[] { AccessibleRole.Text, UIA.EditControlTypeId };
-        yield return new object[] { AccessibleRole.TitleBar, UIA.TitleBarControlTypeId };
-        yield return new object[] { AccessibleRole.ToolBar, UIA.ToolBarControlTypeId };
-        yield return new object[] { AccessibleRole.ToolTip, UIA.ToolTipControlTypeId };
-        yield return new object[] { AccessibleRole.WhiteSpace, UIA.PaneControlTypeId };
-        yield return new object[] { AccessibleRole.Window, UIA.WindowControlTypeId };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibleRoleControlTypeMap_GetControlType_ReturnsExpectedValue_TestData))]
-    public void AccessibleRoleControlTypeMap_GetControlType_ReturnsExpectedValue(AccessibleRole role, int expectedType)
-    {
-        // UIA is less accessible than the test
-        // so we have to use "int" type for "expectedType" argument
-        UIA actual = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal((UIA)expectedType, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AmbientPropertiesTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AmbientPropertiesTests.cs
deleted file mode 100644
index 1343f0402e6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AmbientPropertiesTests.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class AmbientPropertiesTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var property = new AmbientProperties();
-        Assert.Equal(Color.Empty, property.BackColor);
-        Assert.Null(property.Cursor);
-        Assert.Null(property.Font);
-        Assert.Equal(Color.Empty, property.ForeColor);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void BackColor_Set_GetReturnsExpected(Color value)
-    {
-        var property = new AmbientProperties
-        {
-            BackColor = value
-        };
-        Assert.Equal(value, property.BackColor);
-
-        // Set same.
-        property.BackColor = value;
-        Assert.Equal(value, property.BackColor);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void Cursor_Set_GetReturnsExpected(Cursor value)
-    {
-        var property = new AmbientProperties
-        {
-            Cursor = value
-        };
-        Assert.Equal(value, property.Cursor);
-
-        // Set same.
-        property.Cursor = value;
-        Assert.Equal(value, property.Cursor);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void Font_Set_GetReturnsExpected(Font value)
-    {
-        var property = new AmbientProperties
-        {
-            Font = value
-        };
-        Assert.Equal(value, property.Font);
-
-        // Set same.
-        property.Font = value;
-        Assert.Equal(value, property.Font);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void ForeColor_Set_GetReturnsExpected(Color value)
-    {
-        var property = new AmbientProperties
-        {
-            ForeColor = value
-        };
-        Assert.Equal(value, property.ForeColor);
-
-        // Set same.
-        property.ForeColor = value;
-        Assert.Equal(value, property.ForeColor);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ComponentManagerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ComponentManagerTests.cs
deleted file mode 100644
index 9dfaa0697c8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ComponentManagerTests.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Moq;
-using Microsoft.Office;
-
-namespace System.Windows.Forms.Tests.Interop_Mso;
-
-public unsafe class IMsoComponentManagerTests
-{
-    private IMsoComponentManager CreateComponentManager()
-        => (IMsoComponentManager)Activator.CreateInstance(
-            typeof(Application).Assembly.GetType("System.Windows.Forms.Application+ComponentManager")!,
-            nonPublic: true)!;
-
-    [Fact]
-    public void FDebugMessage_ReturnsTrue()
-    {
-        var manager = CreateComponentManager();
-        Assert.True(manager.FDebugMessage(0, 0, default, default));
-    }
-
-    [Fact]
-    public void QueryService_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-
-        // Shouldn't try and deref a null
-        Assert.Equal(HRESULT.E_NOINTERFACE, manager.QueryService(null, null, null));
-
-        // Should null out obj pointer
-        void* obj = (void*)0xDEADBEEF;
-        Assert.Equal(HRESULT.E_NOINTERFACE, manager.QueryService(null, null, &obj));
-        Assert.True(obj is null);
-    }
-
-    [Fact]
-    public void FRegisterComponent_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = default;
-        UIntPtr id = default;
-
-        Assert.False(manager.FRegisterComponent(mock.Object, &info, null));
-        Assert.False(manager.FRegisterComponent(mock.Object, null, &id));
-        Assert.Equal(UIntPtr.Zero, id);
-    }
-
-    [Fact]
-    public void FRegisterComponent_RejectsUnsized()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = default;
-        UIntPtr id = default;
-
-        Assert.False(manager.FRegisterComponent(mock.Object, &info, &id));
-        Assert.Equal(UIntPtr.Zero, id);
-    }
-
-    [Fact]
-    public void FRegisterComponent_Cookies()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-        Assert.NotEqual(UIntPtr.Zero, id);
-
-        UIntPtr newId = default;
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &newId));
-        Assert.NotEqual(UIntPtr.Zero, newId);
-
-        Assert.NotEqual(id, newId);
-    }
-
-    [Fact]
-    public void FRevokeComponent()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-
-        Assert.False(manager.FRevokeComponent(UIntPtr.Zero));
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-        Assert.True(manager.FRevokeComponent(id));
-        Assert.False(manager.FRevokeComponent(id));
-    }
-
-    [Fact]
-    public void FUpdateComponentRegistration_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-        Assert.False(manager.FUpdateComponentRegistration(id, null));
-    }
-
-    [Fact]
-    public void FUpdateComponentRegistration()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-
-        Assert.False(manager.FUpdateComponentRegistration(id, &info));
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-        Assert.True(manager.FUpdateComponentRegistration(id, &info));
-    }
-
-    [Fact]
-    public void FOnComponentActivate_InvalidId()
-    {
-        var manager = CreateComponentManager();
-        Assert.False(manager.FOnComponentActivate(default));
-    }
-
-    [Fact]
-    public void FSetTrackingComponent_InvalidId()
-    {
-        var manager = CreateComponentManager();
-        Assert.False(manager.FSetTrackingComponent(default, true));
-        Assert.False(manager.FSetTrackingComponent(default, false));
-    }
-
-    [Fact]
-    public void FSetTrackingComponent()
-    {
-        var manager = CreateComponentManager();
-
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-
-        Assert.True(manager.FSetTrackingComponent(id, true));
-
-        // Returns false if we're already tracking
-        Assert.False(manager.FSetTrackingComponent(id, true));
-
-        Assert.True(manager.FSetTrackingComponent(id, false));
-
-        // If we aren't tracking, untracking should return false
-        Assert.False(manager.FSetTrackingComponent(id, false));
-        Assert.True(manager.FSetTrackingComponent(id, true));
-    }
-
-    [Fact]
-    public void OnComponentEnterState_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-        manager.OnComponentEnterState(default, default, default, default, null, default);
-    }
-
-    [Fact]
-    public void OnComponentEnterState_Notification()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        mock.Setup(m => m.OnEnterState(msocstate.Modal, true));
-
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-
-        // No call on "Others"
-        manager.OnComponentEnterState(default, msocstate.Modal, msoccontext.Others, 0, null, 0);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, true), Times.Never);
-
-        manager.OnComponentEnterState(default, msocstate.Modal, msoccontext.All, 0, null, 0);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, true), Times.Once);
-
-        manager.OnComponentEnterState(default, msocstate.Modal, msoccontext.Mine, 0, null, 0);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, true), Times.Exactly(2));
-    }
-
-    [Fact]
-    public void FOnComponentExitState_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-        Assert.False(manager.FOnComponentExitState(default, default, default, default, null));
-    }
-
-    [Fact]
-    public void FOnComponentExitState_Notification()
-    {
-        var manager = CreateComponentManager();
-        var mock = new Mock<IMsoComponent>(MockBehavior.Strict);
-        mock.Setup(m => m.OnEnterState(msocstate.Modal, false));
-
-        MSOCRINFO info = new MSOCRINFO { cbSize = (uint)sizeof(MSOCRINFO) };
-        UIntPtr id = default;
-        Assert.True(manager.FRegisterComponent(mock.Object, &info, &id));
-
-        // No call on "Others"
-        manager.FOnComponentExitState(default, msocstate.Modal, msoccontext.Others, 0, null);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, false), Times.Never);
-
-        manager.FOnComponentExitState(default, msocstate.Modal, msoccontext.All, 0, null);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, false), Times.Once);
-
-        manager.FOnComponentExitState(default, msocstate.Modal, msoccontext.Mine, 0, null);
-        mock.Verify(m => m.OnEnterState(msocstate.Modal, false), Times.Exactly(2));
-    }
-
-    [Fact]
-    public void FInState()
-    {
-        var manager = CreateComponentManager();
-        Assert.True(manager.FInState(0, null));
-        manager.OnComponentEnterState(default, msocstate.Modal, default, 0, null, 0);
-        Assert.False(manager.FInState(0, null));
-        Assert.True(manager.FInState(msocstate.Modal, null));
-        manager.OnComponentEnterState(default, msocstate.Recording, default, 0, null, 0);
-        Assert.True(manager.FInState(msocstate.Recording, null));
-        manager.FOnComponentExitState(default, msocstate.RedrawOff, default, 0, null);
-        Assert.True(manager.FInState(0, null));
-    }
-
-    [Fact]
-    public void FContinueIdle()
-    {
-        // Making sure we don't crash- there may or may not be messages in the queue
-        var manager = CreateComponentManager();
-        manager.FContinueIdle();
-    }
-
-    [Fact]
-    public void FPushMessageLoop_InvalidComponent()
-    {
-        var manager = CreateComponentManager();
-        Assert.False(manager.FPushMessageLoop(default, default, null));
-    }
-
-    [Fact]
-    public void FCreateSubComponentManager_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-
-        // Shouldn't try and deref a null
-        Assert.False(manager.FCreateSubComponentManager(default, default, null, null));
-
-        // Should null out obj pointer
-        void* obj = (void*)0xDEADBEEF;
-        Assert.False(manager.FCreateSubComponentManager(default, default, null, &obj));
-        Assert.True(obj is null);
-    }
-
-    [Fact]
-    public void FGetParentComponentManager_HandlesNull()
-    {
-        var manager = CreateComponentManager();
-
-        // Shouldn't try and deref a null
-        Assert.False(manager.FGetParentComponentManager(null));
-
-        // Should null out obj pointer
-        void* obj = (void*)0xDEADBEEF;
-        Assert.False(manager.FGetParentComponentManager(&obj));
-        Assert.True(obj is null);
-    }
-
-    [Fact]
-    public void FGetActiveComponent()
-    {
-        var manager = CreateComponentManager();
-        Assert.False(manager.FGetActiveComponent(msogac.Active, null, null, 0));
-
-        var mock1 = new Mock<IMsoComponent>(MockBehavior.Strict);
-        var mock2 = new Mock<IMsoComponent>(MockBehavior.Strict);
-
-        MSOCRINFO info = new MSOCRINFO
-        {
-            cbSize = (uint)sizeof(MSOCRINFO),
-            uIdleTimeInterval = 1
-        };
-
-        UIntPtr firstId = default;
-        Assert.True(manager.FRegisterComponent(mock1.Object, &info, &firstId));
-        info.uIdleTimeInterval = 2;
-        UIntPtr secondId = default;
-        Assert.True(manager.FRegisterComponent(mock2.Object, &info, &secondId));
-
-        Assert.False(manager.FGetActiveComponent(msogac.Active, null, null, 0));
-
-        // Just an active component
-        Assert.True(manager.FOnComponentActivate(firstId));
-        Assert.False(manager.FGetActiveComponent(msogac.Tracking, null, &info, 0));
-        Assert.True(manager.FGetActiveComponent(msogac.Active, null, &info, 0));
-        Assert.Equal(1u, info.uIdleTimeInterval);
-        Assert.True(manager.FGetActiveComponent(msogac.TrackingOrActive, null, &info, 0));
-        Assert.Equal(1u, info.uIdleTimeInterval);
-
-        // Active and tracking
-        Assert.True(manager.FSetTrackingComponent(secondId, true));
-        Assert.True(manager.FGetActiveComponent(msogac.Tracking, null, &info, 0));
-        Assert.Equal(2u, info.uIdleTimeInterval);
-        Assert.True(manager.FGetActiveComponent(msogac.Active, null, &info, 0));
-        Assert.Equal(1u, info.uIdleTimeInterval);
-        Assert.True(manager.FGetActiveComponent(msogac.TrackingOrActive, null, &info, 0));
-        Assert.Equal(2u, info.uIdleTimeInterval);
-
-        // Now check that we can get the object out
-        mock2.Setup(m => m.FQueryTerminate(true)).Returns(true);
-        void* pUnk = default;
-        Assert.True(manager.FGetActiveComponent(msogac.Tracking, &pUnk, &info, 0));
-        Assert.True(pUnk != null);
-        try
-        {
-            var component = (IMsoComponent)Marshal.GetObjectForIUnknown((IntPtr)pUnk);
-            Assert.True(component.FQueryTerminate(true));
-        }
-        finally
-        {
-            Marshal.Release((IntPtr)pUnk);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ParkingWindowTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ParkingWindowTests.cs
deleted file mode 100644
index 419c0cdaee7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Application.ParkingWindowTests.cs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.DotNet.RemoteExecutor;
-using static System.Windows.Forms.Application;
-
-namespace System.Windows.Forms.Tests;
-
-public class ParkingWindowTests
-{
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void ParkingWindow_DoesNotThrowOnGarbageCollecting()
-    {
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            Control.CheckForIllegalCrossThreadCalls = true;
-
-            Form form = InitFormWithControlToGarbageCollect();
-
-            try
-            {
-                // Force garbage collecting to access combobox from another (GC) thread.
-                GC.Collect();
-
-                GC.WaitForPendingFinalizers();
-            }
-            catch (Exception ex)
-            {
-                Assert.True(ex is null, $"Expected no exception, but got: {ex.Message}"); // Actually need to check whether GC.Collect() does not throw exception.
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    private Form InitFormWithControlToGarbageCollect()
-    {
-        Form form = new Form();
-        ComboBox comboBox = new ComboBox();
-        comboBox.DropDownStyle = ComboBoxStyle.DropDown;
-
-        form.Controls.Add(comboBox);
-        form.Show();
-
-        // Park combobox handle in ParkingWindow.
-        comboBox.Parent = null;
-
-        // Recreate combobox handle to set parent to ParkingWindow.
-        comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
-
-        // Lose the reference to combobox to allow Garbage collecting combobox.
-        comboBox = null;
-
-        return form;
-    }
-
-    [WinFormsFact]
-    public void ParkingWindow_Unaware()
-    {
-        // run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // set thread awareness context to PermonitorV2(PMv2).
-        // if process/thread is not in PMv2, calling 'EnterDpiAwarenessScope' is a no-op and that is by design.
-        // In this case, we will be setting thread to PMv2 mode and then scope to UNAWARE
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using (DpiHelper.EnterDpiAwarenessScope(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_UNAWARE))
-            {
-                using Control control = new();
-                ThreadContext ctx = GetContextForHandle(control);
-                Assert.NotNull(ctx);
-                ParkingWindow parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_UNAWARE);
-                Assert.NotNull(parkingWindow);
-
-                DPI_AWARENESS_CONTEXT dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_UNAWARE, dpiContext));
-            }
-        }
-        finally
-        {
-            // reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void ParkingWindow_SystemAware()
-    {
-        // run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // set thread awareness context to PermonitorV2(PMv2).
-        // if process/thread is not in PMv2, calling 'EnterDpiAwarenessScope' is a no-op and that is by design.
-        // In this case, we will be setting thread to PMv2 mode and then scope to UNAWARE
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using (DpiHelper.EnterDpiAwarenessScope(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE))
-            {
-                using Control control = new();
-                ThreadContext ctx = GetContextForHandle(control);
-                Assert.NotNull(ctx);
-                ParkingWindow parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE);
-                Assert.NotNull(parkingWindow);
-
-                DPI_AWARENESS_CONTEXT dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE, dpiContext));
-            }
-        }
-        finally
-        {
-            // reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void ParkingWindow_PermonitorV2()
-    {
-        // run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // set thread awareness context to PermonitorV2(PMv2).
-        // if process/thread is not in PMv2, calling 'EnterDpiAwarenessScope' is a no-op and that is by design.
-        // In this case, we will be setting thread to PMv2 mode and then scope to UNAWARE
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using Control control = new();
-            ThreadContext ctx = GetContextForHandle(control);
-            Assert.NotNull(ctx);
-
-            ParkingWindow parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-            Assert.NotNull(parkingWindow);
-
-            DPI_AWARENESS_CONTEXT dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-            Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, dpiContext));
-        }
-        finally
-        {
-            // reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void ParkingWindow_Multiple()
-    {
-        // run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // set thread awareness context to PermonitorV2(PMv2).
-        // if process/thread is not in PMv2, calling 'EnterDpiAwarenessScope' is a no-op and that is by design.
-        // In this case, we will be setting thread to PMv2 mode and then scope to UNAWARE
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using Control control = new();
-            ThreadContext ctx = GetContextForHandle(control);
-            Assert.NotNull(ctx);
-            ParkingWindow parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-            Assert.NotNull(parkingWindow);
-
-            DPI_AWARENESS_CONTEXT dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-            Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, dpiContext));
-
-            using (DpiHelper.EnterDpiAwarenessScope(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE))
-            {
-                using Control systemControl = new();
-                ctx = GetContextForHandle(systemControl);
-                Assert.NotNull(ctx);
-                parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE);
-                Assert.NotNull(parkingWindow);
-
-                dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE, dpiContext));
-
-                // check PMv2 parking window still available.
-                parkingWindow = ctx.GetParkingWindowForContext(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-                Assert.NotNull(parkingWindow);
-
-                dpiContext = PInvoke.GetWindowDpiAwarenessContext(parkingWindow.HWND);
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, dpiContext));
-            }
-        }
-        finally
-        {
-            // reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationContextTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationContextTests.cs
deleted file mode 100644
index 52ecf583fcb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationContextTests.cs
+++ /dev/null
@@ -1,411 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-using Moq.Protected;
-
-namespace System.Windows.Forms.Tests;
-
-public class ApplicationContextTests
-{
-    [WinFormsFact]
-    public void Ctor_Default()
-    {
-        using var context = new ApplicationContext();
-
-        Assert.Null(context.MainForm);
-        Assert.Null(context.Tag);
-    }
-
-    public static IEnumerable<object[]> Ctor_Form_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Form() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Form_TestData))]
-    public void Ctor_Form(Form mainForm)
-    {
-        using var context = new ApplicationContext(mainForm);
-
-        Assert.Same(mainForm, context.MainForm);
-        Assert.Null(context.Tag);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Form_TestData))]
-    public void MainForm_Set_GetReturnsExpected(Form value)
-    {
-        using var context = new ApplicationContext
-        {
-            MainForm = value
-        };
-        Assert.Equal(value, context.MainForm);
-
-        // Set same
-        context.MainForm = value;
-        Assert.Equal(value, context.MainForm);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Form_TestData))]
-    public void MainForm_SetWithNonNullOldValue_GetReturnsExpected(Form value)
-    {
-        using var context = new ApplicationContext
-        {
-            MainForm = new Form()
-        };
-
-        context.MainForm = value;
-        Assert.Equal(value, context.MainForm);
-
-        // Set same
-        context.MainForm = value;
-        Assert.Equal(value, context.MainForm);
-    }
-
-    [WinFormsFact]
-    public void MainForm_DestroyHandleWithThreadExit_CallsHandler()
-    {
-        using var mainForm = new SubForm();
-        using var context = new ApplicationContext(mainForm);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(context, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        Assert.NotEqual(IntPtr.Zero, mainForm.Handle);
-        Assert.Equal(0, callCount);
-
-        mainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        mainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void MainForm_DestroyOldHandleWithThreadExit_CallsHandler()
-    {
-        using var mainForm = new SubForm();
-        using var newMainForm = new SubForm();
-        using var context = new ApplicationContext(mainForm)
-        {
-            MainForm = newMainForm
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(context, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        Assert.NotEqual(IntPtr.Zero, mainForm.Handle);
-        Assert.Equal(0, callCount);
-
-        Assert.NotEqual(IntPtr.Zero, newMainForm.Handle);
-        Assert.Equal(0, callCount);
-
-        mainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(0, callCount);
-
-        newMainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        mainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-
-        newMainForm.OnHandleDestroyed(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void MainForm_RecreateHandleWithThreadExit_DoesNotCallHandler()
-    {
-        using var mainForm = new SubForm();
-        using var context = new ApplicationContext(mainForm);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(context, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        Assert.NotEqual(IntPtr.Zero, mainForm.Handle);
-        Assert.Equal(0, callCount);
-
-        mainForm.RecreateHandle();
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        mainForm.RecreateHandle();
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Tag_Set_GetReturnsExpected(string value)
-    {
-        using var context = new ApplicationContext
-        {
-            Tag = value
-        };
-        Assert.Equal(value, context.Tag);
-
-        // Set same
-        context.Tag = value;
-        Assert.Equal(value, context.Tag);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeWithForm_Success()
-    {
-        using var mainForm = new Form();
-        using var context = new ApplicationContext(mainForm);
-        context.Dispose();
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-
-        context.Dispose();
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeWithDisposedForm_Success()
-    {
-        using var mainForm = new Form();
-        using var context = new ApplicationContext(mainForm);
-        mainForm.Dispose();
-        Assert.True(mainForm.IsDisposed);
-
-        context.Dispose();
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-
-        context.Dispose();
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeWithoutForm_Success()
-    {
-        using var context = new ApplicationContext();
-        context.Dispose();
-        Assert.Null(context.MainForm);
-
-        context.Dispose();
-        Assert.Null(context.MainForm);
-    }
-
-    [WinFormsFact]
-    public void Dispose_Invoke_CallsDisposeDisposing()
-    {
-        var mockContext = new Mock<ApplicationContext>(MockBehavior.Strict);
-        mockContext
-            .Protected()
-            .Setup("Dispose", true)
-            .Verifiable();
-        mockContext.Object.Dispose();
-        mockContext.Protected().Verify("Dispose", Times.Once(), true);
-
-        // Call again.
-        mockContext.Object.Dispose();
-        mockContext.Protected().Verify("Dispose", Times.Exactly(2), true);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeDisposingWithForm_Success()
-    {
-        using var mainForm = new Form();
-        using var context = new SubApplicationContext(mainForm);
-        context.Dispose(true);
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-
-        context.Dispose(true);
-        Assert.Null(context.MainForm);
-        Assert.True(mainForm.IsDisposed);
-    }
-
-    [WinFormsFact]
-    public void Dispose_InvokeNotDisposingWithForm_Nop()
-    {
-        using var mainForm = new Form();
-        using var context = new SubApplicationContext(mainForm);
-        context.Dispose(false);
-        Assert.Same(mainForm, context.MainForm);
-        Assert.False(mainForm.IsDisposed);
-
-        context.Dispose(false);
-        Assert.Same(mainForm, context.MainForm);
-        Assert.False(mainForm.IsDisposed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Dispose_InvokeDisposingNoForm_Nop(bool disposing)
-    {
-        using var context = new SubApplicationContext();
-        context.Dispose(disposing);
-        Assert.Null(context.MainForm);
-
-        context.Dispose(disposing);
-        Assert.Null(context.MainForm);
-    }
-
-    [WinFormsFact]
-    public void ExitThread_InvokeWithThreadExit_CallsHandler()
-    {
-        using var context = new ApplicationContext();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(context, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        // Call with handler.
-        context.ExitThread();
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        context.ExitThread();
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        context.ThreadExit -= handler;
-        context.ExitThread();
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ExitThread_Invoke_CallsExitThreadCore()
-    {
-        var mockContext = new Mock<ApplicationContext>(MockBehavior.Strict);
-        mockContext
-            .Protected()
-            .Setup("ExitThreadCore")
-            .Verifiable();
-        mockContext
-            .Protected()
-            .Setup("Dispose", false);
-        mockContext.Object.ExitThread();
-        mockContext.Protected().Verify("ExitThreadCore", Times.Once());
-
-        // Call again.
-        mockContext.Object.ExitThread();
-        mockContext.Protected().Verify("ExitThreadCore", Times.Exactly(2));
-    }
-
-    [WinFormsFact]
-    public void ExitThreadCore_InvokeWithThreadExit_CallsHandler()
-    {
-        using var context = new SubApplicationContext();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(context, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        // Call with handler.
-        context.ExitThreadCore();
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        context.ExitThreadCore();
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        context.ThreadExit -= handler;
-        context.ExitThreadCore();
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> OnMainFormClosed_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMainFormClosed_TestData))]
-    public void OnMainFormClosed_InvokeWithThreadExit_CallsHandler(object sender, EventArgs e)
-    {
-        using var context = new SubApplicationContext();
-        int callCount = 0;
-        EventHandler handler = (actualSender, actualE) =>
-        {
-            Assert.Same(context, actualSender);
-            Assert.Same(EventArgs.Empty, actualE);
-            callCount++;
-        };
-        context.ThreadExit += handler;
-
-        // Call with handler.
-        context.OnMainFormClosed(sender, e);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        context.OnMainFormClosed(sender, e);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        context.ThreadExit -= handler;
-        context.OnMainFormClosed(sender, e);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ApplicationContext_Subclasses_SuppressFinalizeCall()
-    {
-        foreach (var type in typeof(ApplicationContext).Assembly.GetTypes().
-            Where(type => type == typeof(ApplicationContext) || type.IsSubclassOf(typeof(ApplicationContext))))
-        {
-            Assert.True(type == typeof(ApplicationContext) || type == Application.s_typeOfModalApplicationContext,
-                $"Type {type} is not one of [{typeof(ApplicationContext)}, {Application.s_typeOfModalApplicationContext}]. " +
-                $"Consider adding it here and to the ApplicationContext(Form? mainForm) constructor. Or add exclusion to this test (if a new class really needs a finalizer).");
-        }
-    }
-
-    private class SubApplicationContext : ApplicationContext
-    {
-        public SubApplicationContext() : base()
-        {
-        }
-
-        public SubApplicationContext(Form mainForm) : base(mainForm)
-        {
-        }
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new void ExitThreadCore() => base.ExitThreadCore();
-
-        public new void OnMainFormClosed(object sender, EventArgs e) => base.OnMainFormClosed(sender, e);
-    }
-
-    private class SubForm : Form
-    {
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void RecreateHandle() => base.RecreateHandle();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationTests.cs
deleted file mode 100644
index 160dd885b76..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ApplicationTests.cs
+++ /dev/null
@@ -1,413 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-using System.Windows.Forms.VisualStyles;
-using Microsoft.DotNet.RemoteExecutor;
-
-namespace System.Windows.Forms.Tests;
-
-public class ApplicationTests
-{
-    [WinFormsFact]
-    public void Application_CurrentCulture_Get_ReturnsExpected()
-    {
-        Assert.Same(Thread.CurrentThread.CurrentCulture, Application.CurrentCulture);
-    }
-
-    public static IEnumerable<object[]> CurrentCulture_Set_TestData()
-    {
-        yield return new object[] { CultureInfo.InvariantCulture, 0x7Fu };
-        yield return new object[] { new CultureInfo("en"), 0x9u };
-        yield return new object[] { new CultureInfo("fr-FR"), 0x40Cu };
-        yield return new object[] { new CultureInfo("en-DK"), 0xC00u };
-        yield return new object[] { new CultureInfo("haw"), 0x00000075u };
-        yield return new object[] { new CultureInfo("en-US"), 0x00000409u };
-        yield return new object[] { new CultureInfo("de-DE_phoneb"), 0x00010407u };
-        yield return new object[] { new CustomLCIDCultureInfo(10), 0x409u };
-        yield return new object[] { new CustomLCIDCultureInfo(0), 0x409u };
-        yield return new object[] { new CustomLCIDCultureInfo(-1), 0x409u };
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void Application_CurrentCulture_Set_GetReturnsExpected()
-    {
-        RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] testData in CurrentCulture_Set_TestData())
-            {
-                CultureInfo value = (CultureInfo)testData[0];
-                uint expectedLcid = (uint)testData[1];
-
-                CultureInfo oldValue = Application.CurrentCulture;
-                try
-                {
-                    Application.CurrentCulture = value;
-                    Assert.Same(value, Application.CurrentCulture);
-                    Assert.Same(value, Thread.CurrentThread.CurrentCulture);
-                    Assert.Same(value, CultureInfo.CurrentCulture);
-                    Assert.Equal(expectedLcid, PInvoke.GetThreadLocale());
-
-                    // Set same.
-                    Application.CurrentCulture = value;
-                    Assert.Same(value, Application.CurrentCulture);
-                    Assert.Same(value, Thread.CurrentThread.CurrentCulture);
-                    Assert.Same(value, CultureInfo.CurrentCulture);
-                    Assert.Equal(expectedLcid, PInvoke.GetThreadLocale());
-                }
-                finally
-                {
-                    Application.CurrentCulture = oldValue;
-                }
-            }
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void Application_CurrentCulture_SetNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("value", () => Application.CurrentCulture = null);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void Application_EnableVisualStyles_InvokeBeforeGettingRenderWithVisualStyles_Success()
-    {
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-            Assert.True(Application.UseVisualStyles);
-            Assert.True(Application.RenderWithVisualStyles);
-        }).Dispose();
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void Application_EnableVisualStyles_InvokeAfterGettingRenderWithVisualStyles_Success()
-    {
-        // This is not a recommended scenario per https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.application.enablevisualstyles
-        // EnableVisualStyles should be executed before any control-related code is.
-        RemoteExecutor.Invoke(() =>
-        {
-            Assert.False(Application.UseVisualStyles);
-            Assert.False(Application.RenderWithVisualStyles);
-
-            Application.EnableVisualStyles();
-            Assert.True(Application.UseVisualStyles, "New Visual Styles will not be applied on Winforms app. This is a high priority bug and must be looked into");
-            Assert.True(Application.RenderWithVisualStyles);
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void Application_OpenForms_Get_ReturnsExpected()
-    {
-        FormCollection forms = Application.OpenForms;
-        Assert.Same(forms, Application.OpenForms);
-    }
-
-    [WinFormsFact]
-    public void Application_VisualStyleState_Get_ReturnsExpected()
-    {
-        VisualStyleState state = Application.VisualStyleState;
-        Assert.True(Enum.IsDefined(typeof(VisualStyleState), state));
-        Assert.Equal(state, Application.VisualStyleState);
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [EnumData<VisualStyleState>]
-    [InvalidEnumData<VisualStyleState>]
-    public void Application_VisualStyleState_Set_ReturnsExpected(VisualStyleState valueParam)
-    {
-        // This needs to be in RemoteExecutor.Invoke because changing Application.VisualStyleState
-        // sends WM_THEMECHANGED to all controls, which can cause a deadlock if another test fails.
-        RemoteExecutor.Invoke((valueString) =>
-        {
-            VisualStyleState value = Enum.Parse<VisualStyleState>(valueString);
-            VisualStyleState state = Application.VisualStyleState;
-            try
-            {
-                Application.VisualStyleState = value;
-                Assert.Equal(value, Application.VisualStyleState);
-            }
-            finally
-            {
-                Application.VisualStyleState = state;
-            }
-        }, valueParam.ToString());
-    }
-
-    [Fact]
-    public void Application_EnableVisualStyles_ManifestResourceExists()
-    {
-        // Check to make sure the manifest we use for single file publishing is present
-        using Stream stream = typeof(Application).Module.Assembly.GetManifestResourceStream(
-            "System.Windows.Forms.XPThemes.manifest");
-        Assert.NotNull(stream);
-    }
-
-    [WinFormsFact]
-    public void Application_DefaultFont_ReturnsNull_IfNoFontSet()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-        Assert.Null(Application.DefaultFont);
-    }
-
-    [WinFormsFact]
-    public void Application_DefaultFont_Returns_DefaultFont_IfNotScaled()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font customFont = (Font)SystemFonts.CaptionFont.Clone();
-        try
-        {
-            applicationTestAccessor.s_defaultFont = customFont;
-
-            AreFontEqual(customFont, Application.DefaultFont);
-        }
-        finally
-        {
-            customFont.Dispose();
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled?.Dispose();
-            applicationTestAccessor.s_defaultFontScaled = null;
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_DefaultFont_Returns_ScaledDefaultFont_IfScaled()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f);
-        Font scaled = new Font(new FontFamily("Arial"), 16f);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-            applicationTestAccessor.s_defaultFontScaled = scaled;
-
-            AreFontEqual(scaled, Application.DefaultFont);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled = null;
-            font.Dispose();
-            scaled.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_ScaleDefaultFont_Disposes_ScaleDefaultFont_IfExists()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f);
-        Font scaled = new Font(new FontFamily("Arial"), 16f);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-            applicationTestAccessor.s_defaultFontScaled = scaled;
-
-            AreFontEqual(scaled, Application.DefaultFont);
-
-            Application.ScaleDefaultFont(DpiHelper.MinTextScaleFactorValue);
-
-            // The font is not scaled at 100% (factor=1.0)
-            Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            font.Dispose();
-            scaled.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_ScaleDefaultFont_Should_Not_Rescale_IfTextScaleFactorLessThan1()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-
-            Application.ScaleDefaultFont(0f);
-
-            // The font is not scaled at 100% (factor=1.0)
-            Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            font.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_ScaleDefaultFont_Should_Rescale_IfTextScaleFactorGreaterThan1()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-
-            Application.ScaleDefaultFont(2.0f);
-
-            Assert.NotNull(applicationTestAccessor.s_defaultFontScaled);
-            Assert.Equal(12f * 2, applicationTestAccessor.s_defaultFontScaled.SizeInPoints);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled.Dispose();
-            applicationTestAccessor.s_defaultFontScaled = null;
-            font.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_ScaleDefaultFont_Should_Cap_Rescale_ToTextScaleFactor225()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-
-            Application.ScaleDefaultFont(4.0f);
-
-            Assert.NotNull(applicationTestAccessor.s_defaultFontScaled);
-            Assert.Equal(12f * DpiHelper.MaxTextScaleFactorValue, applicationTestAccessor.s_defaultFontScaled.SizeInPoints);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled.Dispose();
-            applicationTestAccessor.s_defaultFontScaled = null;
-            font.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_ScaleDefaultFont_Should_Rescale_FontCorrectly()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Font font = new Font(new FontFamily("Arial"), 12f, FontStyle.Italic | FontStyle.Underline, GraphicsUnit.Pixel);
-        Font scaled = new Font(new FontFamily("Arial"), 18f, FontStyle.Italic | FontStyle.Underline, GraphicsUnit.Pixel);
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-
-            Application.ScaleDefaultFont(1.5f);
-
-            Assert.NotNull(applicationTestAccessor.s_defaultFontScaled);
-            AreFontEqual(scaled, applicationTestAccessor.s_defaultFontScaled);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled = null;
-            font.Dispose();
-            scaled.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void Application_SetDefaultFont_SetNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("font", () => Application.SetDefaultFont(null));
-    }
-
-    [WinFormsFact]
-    public void Application_SetDefaultFont_AfterHandleCreated_InvalidOperationException()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-
-        Assert.Throws<InvalidOperationException>(() => Application.SetDefaultFont(SystemFonts.CaptionFont));
-    }
-
-    [WinFormsFact]
-    public void Application_SetDefaultFont_MustCloneSystemFont()
-    {
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-        Assert.Null(applicationTestAccessor.s_defaultFont);
-        Assert.Null(applicationTestAccessor.s_defaultFontScaled);
-
-        Assert.True(SystemFonts.CaptionFont.IsSystemFont);
-
-        // This a unholy, but generally at this stage NativeWindow.AnyHandleCreated=true,
-        // And we won't be able to set the font, unless we flip the bit
-        var nativeWindowTestAccessor = typeof(NativeWindow).TestAccessor().Dynamic;
-        bool currentAnyHandleCreated = nativeWindowTestAccessor.t_anyHandleCreated;
-
-        try
-        {
-            nativeWindowTestAccessor.t_anyHandleCreated = false;
-
-            Application.SetDefaultFont(SystemFonts.CaptionFont);
-
-            Assert.False(applicationTestAccessor.s_defaultFont.IsSystemFont);
-        }
-        finally
-        {
-            // Flip the bit back
-            nativeWindowTestAccessor.t_anyHandleCreated = currentAnyHandleCreated;
-
-            applicationTestAccessor.s_defaultFont.Dispose();
-            applicationTestAccessor.s_defaultFontScaled?.Dispose();
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled = null;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HighDpiMode>]
-    public void Application_SetHighDpiMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(HighDpiMode value)
-    {
-        Assert.Throws<InvalidEnumArgumentException>("highDpiMode", () => Application.SetHighDpiMode(value));
-    }
-
-    private static void AreFontEqual(Font expected, Font actual)
-    {
-        Assert.Equal(expected.Name, actual.Name);
-        Assert.Equal(expected.SizeInPoints, actual.SizeInPoints);
-        Assert.Equal(expected.GdiCharSet, actual.GdiCharSet);
-        Assert.Equal(expected.Style, actual.Style);
-    }
-
-    private class CustomLCIDCultureInfo : CultureInfo
-    {
-        private readonly int _lcid;
-
-        public CustomLCIDCultureInfo(int lcid) : base("en-US")
-        {
-            _lcid = lcid;
-        }
-
-        public override int LCID => _lcid;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AutoCompleteStringCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AutoCompleteStringCollectionTests.cs
deleted file mode 100644
index 31043dcb353..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AutoCompleteStringCollectionTests.cs
+++ /dev/null
@@ -1,343 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class AutoCompleteStringCollectionTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_AddRange_Invoke_Success()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        string[] values = new string[] { "1", "2", "3" };
-        collection.AddRange(values);
-
-        foreach (string s in values)
-        {
-            Assert.True(collection.Contains(s));
-        }
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_AddRange_NullValue_ThrowsArgumentNullException()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange(null));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_Contains_Invoke_ReturnsExpected()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        string s = "value";
-        collection.Add(s);
-
-        Assert.True(collection.Contains(s));
-        Assert.False(collection.Contains("anotherValue"));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_Contains_Empty_ReturnsFalse()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-
-        Assert.False(collection.Contains("value"));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListContains_Invoke_ReturnsExpected()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        string s = "value";
-        collection.Add(s);
-
-        Assert.True(collection.Contains(s));
-        Assert.False(collection.Contains("anotherValue"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListContains_Empty_ReturnsFalse()
-    {
-        IList collection = new AutoCompleteStringCollection();
-
-        Assert.False(collection.Contains("value"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        string s = "value";
-        collection.Add(s);
-
-        Assert.Equal(0, collection.IndexOf(s));
-        Assert.Equal(-1, collection.IndexOf("anotherValue"));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IndexOf_Empty_ReturnsFalse()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-
-        Assert.Equal(-1, collection.IndexOf("value"));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListIndexOf_Invoke_ReturnsExpected()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        string s = "value";
-        collection.Add(s);
-
-        Assert.Equal(0, collection.IndexOf(s));
-        Assert.Equal(-1, collection.IndexOf("anotherValue"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListIndexOf_Empty_ReturnsMinusOne()
-    {
-        IList collection = new AutoCompleteStringCollection();
-
-        Assert.Equal(-1, collection.IndexOf("value"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_Insert_String_Success()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        string s = "value1";
-        collection.Add("value2");
-        collection.Insert(1, s);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(s, collection[1]);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_Insert_AlreadyInOtherCollection_GetReturnsExpected()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        collection.Add("value1");
-
-        AutoCompleteStringCollection otherCollection = new AutoCompleteStringCollection();
-
-        string s = "value2";
-        otherCollection.Add(s);
-
-        // The string appears to belong to two collections.
-        collection.Insert(0, s);
-        Assert.Same(s, collection[0]);
-        Assert.Equal(s, collection[0]);
-        Assert.Equal(s, Assert.Single(otherCollection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void AutoCompleteStringCollection_Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "value"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListInsert_String_Success()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        string s = "value1";
-        collection.Add("value2");
-        collection.Insert(1, s);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(s, collection[1]);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListInsert_NullItem_ThrowsArgumentOutOfRangeException()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, null));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void AutoCompleteStringCollection_IListInsert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        IList collection = new AutoCompleteStringCollection();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "value"));
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_Remove_String_Success()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        collection.Add("value");
-
-        // Remove null.
-        collection.Remove(null);
-        Assert.Same("value", Assert.Single(collection));
-
-        collection.Remove("value");
-        Assert.Empty(collection);
-
-        // Remove again.
-        collection.Remove("value");
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListRemove_String_Success()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        collection.Add("value");
-
-        collection.Remove("value");
-        Assert.Empty(collection);
-
-        // Remove again.
-        collection.Remove("value");
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void AutoCompleteStringCollection_IListRemove_InvalidItem_Nop(object value)
-    {
-        IList collection = new AutoCompleteStringCollection();
-        collection.Add(value);
-
-        collection.Remove(value);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_CopyTo_NonEmpty_Success()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        collection.Add("value");
-
-        var array = new string[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new string[] { "1", "value", "3" }, array);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_CopyTo_Empty_Nop()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        var array = new string[] { "1", "2", "3" };
-        collection.CopyTo(array, 0);
-        Assert.Equal(new string[] { "1", "2", "3" }, array);
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_GetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_GetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        AutoCompleteStringCollection collection = new AutoCompleteStringCollection();
-        collection.Add("2");
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal("2", enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListGetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        IList collection = new AutoCompleteStringCollection();
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void AutoCompleteStringCollection_IListGetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        IList collection = new AutoCompleteStringCollection();
-        collection.Add("2");
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal("2", enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.AxPropertyDescriptorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.AxPropertyDescriptorTests.cs
deleted file mode 100644
index 6a026b3850d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.AxPropertyDescriptorTests.cs
+++ /dev/null
@@ -1,1460 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Design;
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads (instantiated via GUID)
-public class AxHostPropertyDescriptorTests
-{
-    private const string EmptyClsidString = "00000000-0000-0000-0000-000000000000";
-    private const string WebBrowserClsidString = "8856f961-340a-11d0-a96b-00c04fd705a2";
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Attributes_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.NotNull(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Null(property.Attributes[typeof(DispIdAttribute)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Attributes_GetWithDispIdAttribute_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.Null(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Equal(PInvoke.DISPID_TEXT, Assert.IsType<DispIdAttribute>(property.Attributes[typeof(DispIdAttribute)]).Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Attributes_GetWithDispIdAttributeNotBrowsable_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdNotBrowsableProperty)];
-        Assert.Null(property.Attributes[typeof(CustomAttribute)]);
-        Assert.False(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Equal(PInvoke.DISPID_TEXT, Assert.IsType<DispIdAttribute>(property.Attributes[typeof(DispIdAttribute)]).Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Attributes_GetWithDispIdAttributeReadOnly_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdReadOnlyProperty)];
-        Assert.Null(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.True(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Equal(PInvoke.DISPID_TEXT, Assert.IsType<DispIdAttribute>(property.Attributes[typeof(DispIdAttribute)]).Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Attributes_GetWithDispIdAttributeNotBrowsableReadOnly_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdNotBrowsableReadOnlyProperty)];
-        Assert.Null(property.Attributes[typeof(CustomAttribute)]);
-        Assert.False(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.True(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Equal(PInvoke.DISPID_TEXT, Assert.IsType<DispIdAttribute>(property.Attributes[typeof(DispIdAttribute)]).Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Category_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.Equal("Misc", property.Category);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Category_GetWithCategoryAttribute_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CategoryProperty)];
-        Assert.Equal("Category", property.Category);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_ComponentType_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.Equal(typeof(CustomAxHost), property.ComponentType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Converter_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.IsType<StringConverter>(property.Converter);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Converter_GetDispId_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.IsType<StringConverter>(property.Converter);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Converter_GetDispIdWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.IsType<StringConverter>(property.Converter);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again to test caching behaviour.
-        Assert.IsType<StringConverter>(property.Converter);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Converter_GetCustomConverter_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomConverterProperty)];
-        Assert.IsType<CustomTypeConverter>(property.Converter);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Converter_GetDispIdCustomConverter_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdCustomConverterProperty)];
-        Assert.IsType<CustomTypeConverter>(property.Converter);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Description_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.Empty(property.Description);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_Description_GetWithDescriptionAttribute_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DescriptionProperty)];
-        Assert.Equal("Description", property.Description);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_IsReadOnly_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.False(property.IsReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_IsReadOnly_GetWithoutSetter_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.GetOnlyProperty)];
-        Assert.True(property.IsReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_IsBrowsable_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.True(property.IsBrowsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_IsBrowsable_GetBrowsableAttribute_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.NotBrowsableProperty)];
-        Assert.False(property.IsBrowsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_IsReadOnly_GetReadOnlyAttribute_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.ReadOnlyProperty)];
-        Assert.True(property.IsReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_PropertyType_Get_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.Equal(typeof(string), property.PropertyType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_CanResetValue_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomValue"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.True(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_CanResetValue_InvokeReadOnly_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.ReadOnlyProperty)];
-        Assert.False(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-#if false
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomValue"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeWithEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EditorProperty)];
-        Assert.IsType<CustomEditor>(property.GetEditor(typeof(object)));
-        Assert.Null(property.GetEditor(typeof(CustomEditor)));
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeWithUITypeEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.UITypeEditorProperty)];
-        Assert.Null(property.GetEditor(typeof(object));
-        Assert.Null(property.GetEditor(typeof(CustomUITypeEditor)));
-        Assert.IsType<CustomUITypeEditor>(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.False(control.IsHandleCreated);
-    }
-#endif
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispId_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispIdWithEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdEditorProperty)];
-        Assert.IsType<CustomEditor>(property.GetEditor(typeof(object)));
-        Assert.Null(property.GetEditor(typeof(CustomEditor)));
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispIdWithUITypeEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdUITypeEditorProperty)];
-        Assert.Null(property.GetEditor(typeof(object)));
-        Assert.Null(property.GetEditor(typeof(CustomUITypeEditor)));
-        Assert.IsType<CustomUITypeEditor>(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispIdWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispIdWithOcxWithEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdEditorProperty)];
-        Assert.IsType<CustomEditor>(property.GetEditor(typeof(object)));
-        Assert.Null(property.GetEditor(typeof(CustomEditor)));
-        Assert.Null(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_InvokeDispIdWithOcxWithUITypeEditor_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdUITypeEditorProperty)];
-        Assert.Null(property.GetEditor(typeof(object)));
-        Assert.Null(property.GetEditor(typeof(CustomUITypeEditor)));
-        Assert.IsType<CustomUITypeEditor>(property.GetEditor(typeof(UITypeEditor)));
-        Assert.Null(property.GetEditor(typeof(int)));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-#if false
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetEditor_NullEditorBaseType_ThrowsArgumentNullException()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomValue"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdProperty)];
-        Assert.Throws<ArgumentNullException>("editorBaseType", () => property.GetEditor(null));
-    }
-#endif
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-
-        Assert.Null(property.GetValue(control));
-        Assert.NotNull(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Null(property.Attributes[typeof(DispIdAttribute)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_InvokeDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            DataSourceProperty = new DataSource
-            {
-                Value = "CustomProperty"
-            }
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DataSourceProperty)];
-
-        Assert.Null(property.GetValue(control));
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_InvokeDispatchIdWithDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            DispIdDataSourceProperty = new DataSource
-            {
-                Value = "CustomProperty"
-            }
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdDataSourceProperty)];
-
-        Assert.Equal("CustomProperty", Assert.IsType<DataSource>(property.GetValue(control)).Value);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_InvokeWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-
-        Assert.Equal("CustomProperty", property.GetValue(control));
-        Assert.NotNull(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Null(property.Attributes[typeof(DispIdAttribute)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_InvokeDataSourceWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            DataSourceProperty = new DataSource
-            {
-                Value = "CustomProperty"
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DataSourceProperty)];
-
-        Assert.Equal("CustomProperty", Assert.IsType<DataSource>(property.GetValue(control)).Value);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_GetValue_InvokeDispatchIdWithDataSourceWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            DispIdDataSourceProperty = new DataSource
-            {
-                Value = "CustomProperty"
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdDataSourceProperty)];
-
-        Assert.Equal("CustomProperty", Assert.IsType<DataSource>(property.GetValue(control)).Value);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_GetValue_NullComponent_ReturnsExpected(string propertyName)
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Null(property.GetValue(null));
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_GetValue_NullComponentWithOcx_ThrowsArgumentNullException(string propertyName)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Null(property.GetValue(null));
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_GetValueInvalidComponent_ReturnsExpected(string propertyName)
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Null(property.GetValue(new object()));
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_GetValueInvalidComponentWithOcx_ThrowsTargetInvocationException(string propertyName)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Throws<TargetInvocationException>(() => property.GetValue(new object()));
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(property.GetValue(new object()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_ResetValue_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomValue"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        property.ResetValue(control);
-        Assert.Null(control.CustomProperty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_ResetValue_InvokeReadOnly_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.ReadOnlyProperty)];
-        property.ResetValue(control);
-        Assert.Null(control.CustomProperty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-
-        property.SetValue(control, "CustomProperty");
-        Assert.Equal("CustomProperty", control.CustomProperty);
-        Assert.NotNull(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Null(property.Attributes[typeof(DispIdAttribute)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DataSourceProperty)];
-
-        property.SetValue(control, new DataSource
-        {
-            Value = "CustomProperty"
-        });
-        Assert.Null(control.DataSourceProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeDispatchIdWithDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdDataSourceProperty)];
-
-        property.SetValue(control, new DataSource
-        {
-            Value = "CustomProperty"
-        });
-        Assert.Null(control.DataSourceProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-
-        property.SetValue(control, "CustomProperty");
-        Assert.Equal("CustomProperty", control.CustomProperty);
-        Assert.NotNull(property.Attributes[typeof(CustomAttribute)]);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.Equal("Misc", Assert.IsType<CategoryAttribute>(property.Attributes[typeof(CategoryAttribute)]).Category);
-        Assert.Empty(Assert.IsType<DescriptionAttribute>(property.Attributes[typeof(DescriptionAttribute)]).Description);
-        Assert.False(Assert.IsType<ReadOnlyAttribute>(property.Attributes[typeof(ReadOnlyAttribute)]).IsReadOnly);
-        Assert.Null(property.Attributes[typeof(DispIdAttribute)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeWithOcxDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DataSourceProperty)];
-
-        property.SetValue(control, new DataSource
-        {
-            Value = "CustomProperty"
-        });
-        Assert.Equal("CustomProperty", Assert.IsType<DataSource>(control.DataSourceProperty).Value);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeWithOcxDispatchIdWithDataSource_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.DispIdDataSourceProperty)];
-
-        property.SetValue(control, new DataSource
-        {
-            Value = "CustomProperty"
-        });
-        Assert.Null(control.DataSourceProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeEnumWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        property.SetValue(control, ConsoleColor.Blue);
-        Assert.Equal(ConsoleColor.Blue, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValue_InvokeEnumNotEnumTypeWithOcx_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            CustomProperty = "CustomProperty"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        property.SetValue(control, (int)ConsoleColor.Blue);
-        Assert.Equal(ConsoleColor.Blue, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValue_NullComponent_ReturnsExpected(string propertyName)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        property.SetValue(null, "CustomProperty");
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValue_NullComponentWithOcx_ThrowsArgumentNullException(string propertyName)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        property.SetValue(null, "Value");
-        Assert.Null(control.CustomProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValueInvalidComponent_ReturnsExpected(string propertyName)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        property.SetValue(new object(), "Value");
-        Assert.Null(control.CustomProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValueInvalidComponentWithOcx_ThrowsTargetException(string propertyName)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Throws<TargetException>(() => property.SetValue(new object(), "Value"));
-        Assert.Null(control.CustomProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Throws<TargetException>(() => property.SetValue(new object(), "Value"));
-        Assert.Null(control.CustomProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValueInvalidValue_ReturnsExpected(string propertyName)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        property.SetValue(control, new object());
-        Assert.Null(control.CustomProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(nameof(CustomAxHost.CustomProperty))]
-    [InlineData(nameof(CustomAxHost.DispIdProperty))]
-    public void AxPropertyDescriptor_SetValueInvalidValueWithOcx_ThrowsArgumentException(string propertyName)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[propertyName];
-
-        Assert.Throws<ArgumentException>(() => property.SetValue(control, new object()));
-        Assert.Null(control.CustomProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Throws<ArgumentException>(() => property.SetValue(control, new object()));
-        Assert.Null(control.CustomProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueInvalidValueInt_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.IntProperty)];
-
-        property.SetValue(control, new object());
-        Assert.Equal(0, control.IntProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueInvalidValueIntWithOcx_ThrowsArgumentException()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.IntProperty)];
-
-        Assert.Throws<ArgumentException>(() => property.SetValue(control, new object()));
-        Assert.Equal(0, control.IntProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Throws<ArgumentException>(() => property.SetValue(control, new object()));
-        Assert.Equal(0, control.IntProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueInvalidValueEnum_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        property.SetValue(control, new object());
-        Assert.Equal((ConsoleColor)0, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueInvalidValueEnumWithOcx_ThrowsArgumentException()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        Assert.Throws<ArgumentException>("value", () => property.SetValue(control, new object()));
-        Assert.Equal((ConsoleColor)0, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Throws<ArgumentException>("value", () => property.SetValue(control, new object()));
-        Assert.Equal((ConsoleColor)0, control.EnumProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueNullValueInt_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            IntProperty = 1
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.IntProperty)];
-
-        property.SetValue(control, null);
-        Assert.Equal(1, control.IntProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueNullValueIntWithOcx_ThrowsArgumentException()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            IntProperty = 1
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.IntProperty)];
-
-        property.SetValue(control, null);
-        Assert.Equal(0, control.IntProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        property.SetValue(control, null);
-        Assert.Equal(0, control.IntProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueNullValueEnum_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            EnumProperty = ConsoleColor.Blue
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        property.SetValue(control, null);
-        Assert.Equal(ConsoleColor.Blue, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-#if false
-    [WinFormsFact]
-    public void AxPropertyDescriptor_SetValueNullValueEnumWithOcx_ThrowsArgumentException()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString)
-        {
-            EnumProperty = ConsoleColor.Blue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotNull(control.GetOcx());
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.EnumProperty)];
-
-        property.SetValue(control, null);
-        Assert.Equal(ConsoleColor.Blue, control.EnumProperty);
-        Assert.True(Assert.IsType<BrowsableAttribute>(property.Attributes[typeof(BrowsableAttribute)]).Browsable);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        property.SetValue(control, new object());
-        Assert.Equal(ConsoleColor.Blue, control.EnumProperty);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-#endif
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_ShouldSerializeValue_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString)
-        {
-            CustomProperty = "CustomValue"
-        };
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.CustomProperty)];
-        Assert.True(property.ShouldSerializeValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxPropertyDescriptor_ShouldSerializeValue_InvokeReadOnly_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        PropertyDescriptor property = events[nameof(CustomAxHost.ReadOnlyProperty)];
-        Assert.False(property.ShouldSerializeValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class SubComponentEditor : ComponentEditor
-    {
-        public override bool EditComponent(ITypeDescriptorContext context, object component)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.All)]
-    private class CustomAttribute : Attribute
-    {
-    }
-
-    private class CustomTypeConverter : TypeConverter
-    {
-    }
-
-    private class CustomEditor
-    {
-    }
-
-    private class CustomUITypeEditor : UITypeEditor
-    {
-    }
-
-    [Guid("7C0FFAB3-CD84-11D0-949A-00A0C91110ED")]
-    private class DataSource
-    {
-        public string Value { get; set; }
-    }
-
-    [CustomAttribute]
-    private class CustomAxHost : AxHost
-    {
-        public CustomAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        [CustomAttribute]
-        [DefaultValue(null)]
-        public string CustomProperty { get; set; }
-
-        public DataSource DataSourceProperty { get; set; }
-
-        public ConsoleColor EnumProperty { get; set; }
-
-        public int IntProperty { get; set; }
-
-        [TypeConverter(typeof(CustomTypeConverter))]
-        public string CustomConverterProperty { get; set; }
-
-        [TypeConverter(typeof(CustomTypeConverter))]
-        public string DispIdCustomConverterProperty { get; set; }
-
-        [Editor(typeof(CustomEditor), typeof(object))]
-        public string EditorProperty { get; set; }
-
-        [Editor(typeof(CustomUITypeEditor), typeof(UITypeEditor))]
-        public string UITypeEditorProperty { get; set; }
-
-        public string GetOnlyProperty { get; }
-
-        [Category("Category")]
-        public string CategoryProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [Description("Description")]
-        public string DescriptionProperty { get; set; }
-
-        [Browsable(false)]
-        public string NotBrowsableProperty { get; set; }
-
-        [ReadOnly(true)]
-        public string ReadOnlyProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        public string DispIdProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        public DataSource DispIdDataSourceProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [Browsable(false)]
-        public string DispIdNotBrowsableProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [ReadOnly(true)]
-        public string DispIdReadOnlyProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [ReadOnly(true)]
-        [Browsable(false)]
-        public string DispIdNotBrowsableReadOnlyProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [Editor(typeof(CustomEditor), typeof(object))]
-        public string DispIdEditorProperty { get; set; }
-
-        [DispId(PInvoke.DISPID_TEXT)]
-        [Editor(typeof(CustomUITypeEditor), typeof(UITypeEditor))]
-        public string DispIdUITypeEditorProperty { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.ConnectionPointCookieTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.ConnectionPointCookieTests.cs
deleted file mode 100644
index ae160f638de..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.ConnectionPointCookieTests.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads (instantiated via GUID)
-public class AxHostConnectionPointCookieTests
-{
-    private static readonly Guid CLSID_WebBrowser = new("8856f961-340a-11d0-a96b-00c04fd705a2");
-
-    [WinFormsFact]
-    public void ConnectionPointCookie_Ctor_Object_Object_Type()
-    {
-        Type type = Type.GetTypeFromCLSID(CLSID_WebBrowser);
-        object source = Activator.CreateInstance(type);
-        var sink = new CustomPropertyNotifySink();
-        Type eventType = typeof(IPropertyNotifySink.Interface);
-
-        // Just verify that creation succeeded.
-        var cookie = new AxHost.ConnectionPointCookie(source, sink, eventType);
-        cookie.Disconnect();
-    }
-
-    public static IEnumerable<object[]> Ctor_InvalidSource_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_InvalidSource_TestData))]
-    public void ConnectionPointCookie_Ctor_InvalidSource_ThrowsInvalidCastException(object source)
-    {
-        Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, null, null));
-        Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, new object(), typeof(int)));
-    }
-
-    [WinFormsFact]
-    public void ConnectionPointCookie_Ctor_NullEventInterface_ThrowsNullReferenceException()
-    {
-        Type type = Type.GetTypeFromCLSID(CLSID_WebBrowser);
-        object source = Activator.CreateInstance(type);
-        Assert.Throws<NullReferenceException>(() => new AxHost.ConnectionPointCookie(source, null, null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int))]
-    [InlineData(typeof(IComparable))]
-    [InlineData(typeof(IConnectionPoint.Interface))]
-    [InlineData(typeof(IConnectionPointContainer.Interface))]
-    public void ConnectionPointCookie_Ctor_NullSink_ThrowsInvalidCastException(Type eventInterface)
-    {
-        Type type = Type.GetTypeFromCLSID(CLSID_WebBrowser);
-        object source = Activator.CreateInstance(type);
-        Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, null, eventInterface));
-    }
-
-    public static IEnumerable<object[]> Ctor_InvalidSink_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_InvalidSink_TestData))]
-    public void ConnectionPointCookie_Ctor_InvalidSink_ThrowsInvalidCastException(object sink)
-    {
-        Type type = Type.GetTypeFromCLSID(CLSID_WebBrowser);
-        object source = Activator.CreateInstance(type);
-        Type eventInterface = typeof(IPropertyNotifySink.Interface);
-        Assert.Throws<InvalidCastException>(() => new AxHost.ConnectionPointCookie(source, sink, eventInterface));
-    }
-
-    [WinFormsFact]
-    public void ConnectionPointCookie_Disconnect_InvokeMultipleTimes_Success()
-    {
-        Type type = Type.GetTypeFromCLSID(CLSID_WebBrowser);
-        object source = Activator.CreateInstance(type);
-        var sink = new CustomPropertyNotifySink();
-        Type eventType = typeof(IPropertyNotifySink.Interface);
-        var cookie = new AxHost.ConnectionPointCookie(source, sink, eventType);
-        cookie.Disconnect();
-
-        // Call again.
-        cookie.Disconnect();
-    }
-
-    private class CustomPropertyNotifySink : IPropertyNotifySink.Interface
-    {
-        public HRESULT OnChanged(int dispID) => throw new NotImplementedException();
-
-        public HRESULT OnRequestEdit(int dispID) => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.PropertyBagStreamTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.PropertyBagStreamTests.cs
deleted file mode 100644
index 85a27681c17..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.PropertyBagStreamTests.cs
+++ /dev/null
@@ -1,109 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Variant;
-using Windows.Win32.System.Com.StructuredStorage;
-
-namespace System.Windows.Forms.Tests;
-
-public unsafe class AxHost_PropertyBagStreamTests
-{
-    [Fact]
-    public void PropertyBagStream_WriteReadRoundTrip_FormatterEnabled()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        AxHost.PropertyBagStream bag = new();
-        HRESULT hr = bag.Write("Integer", (VARIANT)42);
-        Assert.True(hr.Succeeded);
-        NameClass obj = new() { Name = "Hamlet" };
-        hr = bag.Write("Object", VARIANT.FromObject(obj));
-        Assert.True(hr.Succeeded);
-
-        using MemoryStream stream = new();
-        bag.Save(stream);
-        Assert.NotEqual(0, stream.Length);
-        stream.Position = 0;
-
-        AxHost.PropertyBagStream newBag = new(stream);
-
-        VARIANT integer = new();
-        hr = newBag.Read("Integer", ref integer, null);
-        Assert.True(hr.Succeeded);
-        Assert.Equal(42, (int)integer);
-
-        VARIANT dispatch = new();
-        hr = newBag.Read("Object", ref dispatch, null);
-        Assert.True(hr.Succeeded);
-        Assert.Equal(obj.Name, ((NameClass)dispatch.ToObject()).Name);
-    }
-
-    [Fact]
-    public void PropertyBagStream_WriteReadRoundTrip_FormatterDisabled()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: false);
-        AxHost.PropertyBagStream bag = new();
-        HRESULT hr = bag.Write("Integer", (VARIANT)42);
-        Assert.True(hr.Succeeded);
-        NameClass obj = new() { Name = "Hamlet" };
-        hr = bag.Write("Object", VARIANT.FromObject(obj));
-        Assert.True(hr.Succeeded);
-
-        using MemoryStream stream = new();
-        Assert.Throws<NotSupportedException>(() => bag.Save(stream));
-        Assert.Equal(0, stream.Position);
-    }
-
-    [Theory]
-    [MemberData(nameof(TestData_PrimitiveValues))]
-    public void PropertyBagStream_WriteReadRoundTrip_Primitives_FormatterDisabled(object value)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: false);
-
-        AxHost.PropertyBagStream bag = new();
-        using VARIANT variant = default;
-        Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);
-        string name = value.GetType().FullName!;
-
-        HRESULT hr = bag.Write(value.GetType().FullName!, variant);
-        Assert.True(hr.Succeeded);
-
-        using MemoryStream stream = new();
-        bag.Save(stream);
-        Assert.NotEqual(0, stream.Length);
-        stream.Position = 0;
-
-        IPropertyBag.Interface newBag = new AxHost.PropertyBagStream(stream);
-        using VARIANT result = new();
-        hr = newBag.Read(name, &result, null);
-        Assert.True(hr.Succeeded);
-        Assert.Equal(variant.ToObject(), result.ToObject());
-    }
-
-    public static TheoryData<object> TestData_PrimitiveValues => new()
-    {
-        int.MaxValue,
-        uint.MaxValue,
-        long.MaxValue,
-        ulong.MaxValue,
-        short.MaxValue,
-        ushort.MaxValue,
-        byte.MaxValue,
-        sbyte.MaxValue,
-        true,
-        float.MaxValue,
-        double.MaxValue,
-        char.MaxValue,
-        // TimeSpan has no VARIANT conversion
-        // TimeSpan.MaxValue,
-        DateTime.MaxValue,
-        decimal.MaxValue,
-        "RightRound"
-    };
-
-    [Serializable]
-    private class NameClass
-    {
-        public string Name { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.VisualBasic6Tests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.VisualBasic6Tests.cs
deleted file mode 100644
index 424b2fc6da2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHost.VisualBasic6Tests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.Tests.TestResources;
-
-namespace System.Windows.Forms.Tests;
-
-public class AxHostVisualBasic6Tests
-{
-    [WinFormsFact(Skip = "Causes test run to abort, must be run manually.")]
-    public void AxHost_SimpleControl_Create()
-    {
-        if (RuntimeInformation.ProcessArchitecture != Architecture.X86)
-        {
-            return;
-        }
-
-        using Form form = new();
-        form.Shown += (object sender, EventArgs e) => form.Close();
-        using DynamicAxHost control = new(ComClasses.VisualBasicSimpleControl);
-        ((ISupportInitialize)control).BeginInit();
-        form.Controls.Add(control);
-        ((ISupportInitialize)control).EndInit();
-        form.ShowDialog();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHostTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHostTests.cs
deleted file mode 100644
index 03ddc7be3fd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/AxHostTests.cs
+++ /dev/null
@@ -1,3224 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads (instantiated via GUID)
-public class AxHostTests
-{
-    private const string EmptyClsidString = "00000000-0000-0000-0000-000000000000";
-    private const string WebBrowserClsidString = "8856f961-340a-11d0-a96b-00c04fd705a2";
-
-    [WinFormsTheory]
-    [InlineData(EmptyClsidString)]
-    public void AxHost_Ctor_String(string clsid)
-    {
-        using var control = new SubAxHost(clsid);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(75, 23), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.Null(control.ContainingControl);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(75, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.EditMode);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasAboutBox);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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.Null(control.OcxState);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(new Size(75, 23), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(75, control.Right);
-        Assert.False(control.RightToLeft);
-        Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(75, 23), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(75, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(EmptyClsidString, 0)]
-    public void AxHost_Ctor_String_Int(string clsid, int flags)
-    {
-        using var control = new SubAxHost(clsid, flags);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(75, 23), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.Null(control.ContainingControl);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(75, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.EditMode);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasAboutBox);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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.Null(control.OcxState);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(new Size(75, 23), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(75, control.Right);
-        Assert.False(control.RightToLeft);
-        Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(75, 23), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(75, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_Ctor_NullClsid_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("g", () => new SubAxHost(null));
-        Assert.Throws<ArgumentNullException>("g", () => new SubAxHost(null, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("clsid")]
-    public void AxHost_Ctor_EmptyClsid_ThrowsFormatException(string clsid)
-    {
-        Assert.Throws<FormatException>(() => new SubAxHost(clsid));
-    }
-
-    [WinFormsFact]
-    public void AxHost_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_CreateParams_GetWithSite_ReturnsExpected()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite.Object
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void AxHost_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void AxHost_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void AxHost_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void AxHost_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsFact]
-    public static void AxHost_ContainingControl_GetWithContainerControlGrandparent_ReturnsExpected()
-    {
-        var grandparent = new ContainerControl();
-        var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Parent = parent
-        };
-        Assert.Same(grandparent, control.ContainingControl);
-
-        // Call again to check caching.
-        Assert.Same(control.ContainingControl, control.ContainingControl);
-
-        // Remove from chain.
-        parent.Parent = null;
-        Assert.Same(grandparent, control.ContainingControl);
-    }
-
-    [WinFormsFact]
-    public static void AxHost_ContainingControl_GetWithContainerControlParent_ReturnsExpected()
-    {
-        var parent = new ContainerControl();
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.ContainingControl);
-
-        // Call again to check caching.
-        Assert.Same(parent, control.ContainingControl);
-
-        // Remove from chain.
-        control.Parent = null;
-        Assert.Same(parent, control.ContainingControl);
-    }
-
-    [WinFormsFact]
-    public static void AxHost_ContainingControl_GetWithNonContainerControlParent_ReturnsExpected()
-    {
-        var parent = new Control();
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Parent = parent
-        };
-        Assert.Null(control.ContainingControl);
-
-        // Call again to check caching.
-        Assert.Null(control.ContainingControl);
-
-        // Modify.
-        var grandparent = new ContainerControl();
-        parent.Parent = grandparent;
-        Assert.Same(grandparent, control.ContainingControl);
-
-        // Call again to check caching.
-        Assert.Same(grandparent, control.ContainingControl);
-
-        // Remove from chain.
-        parent.Parent = null;
-        Assert.Same(grandparent, control.ContainingControl);
-    }
-
-    public static IEnumerable<object[]> ContainingControl_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContainerControl() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContainingControl_Set_TestData))]
-    public void AxHost_ContainingControl_Set_GetReturnsExpected(ContainerControl value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            ContainingControl = value
-        };
-        Assert.Same(value, control.ContainingControl);
-
-        // Set same.
-        control.ContainingControl = value;
-        Assert.Same(value, control.ContainingControl);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void AxHost_Cursor_Set_GetReturnsExpected(Cursor value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Cursor = value
-        };
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void AxHost_Cursor_SetWithHandle_GetReturnsExpected(Cursor value)
-    {
-        using var control = new SubAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void AxHost_Cursor_SetWithChildren_GetReturnsExpected(Cursor value)
-    {
-        var child1 = new Control();
-        var child2 = new Control();
-        using var control = new SubAxHost(EmptyClsidString);
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(value ?? Cursors.Default, child1.Cursor);
-        Assert.Same(value ?? Cursors.Default, child2.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(value ?? Cursors.Default, child1.Cursor);
-        Assert.Same(value ?? Cursors.Default, child2.Cursor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void AxHost_Cursor_SetWithChildrenWithCursor_GetReturnsExpected(Cursor value)
-    {
-        var cursor1 = new Cursor((IntPtr)1);
-        var cursor2 = new Cursor((IntPtr)1);
-        var child1 = new Control
-        {
-            Cursor = cursor1
-        };
-        var child2 = new Control
-        {
-            Cursor = cursor2
-        };
-        using var control = new SubAxHost(EmptyClsidString);
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor2, child2.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor2, child2.Cursor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void AxHost_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void AxHost_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void AxHost_ImeMode_Set_GetReturnsExpected(ImeMode value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            ImeMode = value
-        };
-        Assert.Equal(value, control.ImeMode);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(value, control.ImeMode);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void AxHost_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AxHost_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AxHost_Site_SetDesignMode_CreatesOcx(bool otherDesignMode)
-    {
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite1.Object
-        };
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        object ocx = control.GetOcx();
-        Assert.NotNull(ocx);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set another.
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.DesignMode)
-            .Returns(otherDesignMode);
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set null.
-        control.Site = null;
-        Assert.Null(control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(ocx, control.GetOcx());
-    }
-
-    [WinFormsFact]
-    public void AxHost_Site_SetNonDesignModeThenDesignMode_CreatesOcx()
-    {
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite1.Object
-        };
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-
-        // Set another.
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        object ocx = control.GetOcx();
-        Assert.NotNull(ocx);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set null.
-        control.Site = null;
-        Assert.Null(control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(ocx, control.GetOcx());
-    }
-
-    [WinFormsFact]
-    public void AxHost_Site_SetNonDesignModeThenNonDesignMode_DoesNotCreateOcx()
-    {
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite1.Object
-        };
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-
-        // Set another.
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-
-        // Set null.
-        control.Site = null;
-        Assert.Null(control.Site);
-        Assert.False(control.IsHandleCreated);
-        Assert.Null(control.GetOcx());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1, 1)]
-    [InlineData(true, false, 1, 1)]
-    [InlineData(false, true, 0, 1)]
-    [InlineData(false, false, 0, 0)]
-    public void AxHost_Site_SetWithHandle_CreatesOcx(bool designMode1, bool designMode2, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite1
-            .Setup(s => s.DesignMode)
-            .Returns(designMode1);
-        mockSite1
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new SubAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        object ocx = control.GetOcx();
-        Assert.NotNull(ocx);
-
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set another.
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite2
-            .Setup(s => s.DesignMode)
-            .Returns(designMode2);
-        mockSite2
-            .Setup(s => s.Name)
-            .Returns("Name");
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-        Assert.Same(ocx, control.GetOcx());
-
-        // Set null.
-        control.Site = null;
-        Assert.Null(control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-        Assert.Same(ocx, control.GetOcx());
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        yield return new object[] { null, string.Empty };
-        yield return new object[] { string.Empty, string.Empty };
-        yield return new object[] { "text", "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void AxHost_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubAxHost(EmptyClsidString)
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void AxHost_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_BackColorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackColorChanged += handler);
-        control.BackColorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_BackgroundImageChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackgroundImageChanged += handler);
-        control.BackgroundImageChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_BackgroundImageLayoutChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackgroundImageLayoutChanged += handler);
-        control.BackgroundImageLayoutChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_BindingContextChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BindingContextChanged += handler);
-        control.BindingContextChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_ChangeUICues_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        UICuesEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ChangeUICues += handler);
-        control.ChangeUICues -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_Click_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Click += handler);
-        control.Click -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_CursorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.CursorChanged += handler);
-        control.CursorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_DoubleClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DoubleClick += handler);
-        control.DoubleClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_DragDrop_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragDrop += handler);
-        control.DragDrop -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_DragEnter_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragEnter += handler);
-        control.DragEnter -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_DragLeave_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragLeave += handler);
-        control.DragLeave -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_DragOver_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragOver += handler);
-        control.DragOver -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_EnabledChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.EnabledChanged += handler);
-        control.EnabledChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_FontChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.FontChanged += handler);
-        control.FontChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_ForeColorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ForeColorChanged += handler);
-        control.ForeColorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_GiveFeedback_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        GiveFeedbackEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.GiveFeedback += handler);
-        control.GiveFeedback -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_HelpRequested_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        HelpEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.HelpRequested += handler);
-        control.HelpRequested -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_ImeModeChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ImeModeChanged += handler);
-        control.ImeModeChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_KeyDown_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        KeyEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyDown += handler);
-        control.KeyDown -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_KeyPress_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        KeyPressEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyPress += handler);
-        control.KeyPress -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_KeyUp_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        KeyEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyUp += handler);
-        control.KeyUp -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_Layout_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        LayoutEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Layout += handler);
-        control.Layout -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseClick += handler);
-        control.MouseClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseDoubleClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseDoubleClick += handler);
-        control.MouseDoubleClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseDown_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseDown += handler);
-        control.MouseDown -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseEnter_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseEnter += handler);
-        control.MouseEnter -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseHover_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseHover += handler);
-        control.MouseHover -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseLeave_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseLeave += handler);
-        control.MouseLeave -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseMove_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseMove += handler);
-        control.MouseMove -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseUp_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseUp += handler);
-        control.MouseUp -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_MouseWheel_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseWheel += handler);
-        control.MouseWheel -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_Paint_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        PaintEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Paint += handler);
-        control.Paint -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_QueryAccessibilityHelp__AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        QueryAccessibilityHelpEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.QueryAccessibilityHelp += handler);
-        control.QueryAccessibilityHelp -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_QueryContinueDrag__AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        QueryContinueDragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.QueryContinueDrag += handler);
-        control.QueryContinueDrag -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_RightToLeftChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.RightToLeftChanged += handler);
-        control.RightToLeftChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_StyleChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.StyleChanged += handler);
-        control.StyleChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_TextChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.TextChanged += handler);
-        control.TextChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void AxHost_AttachInterfaces_Invoke_Nop()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.AttachInterfaces();
-        control.AttachInterfaces();
-    }
-
-    [WinFormsFact]
-    public void AxHost_BeginInit_Invoke_Nop()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.BeginInit();
-        control.BeginInit();
-        Assert.False(control.Created);
-    }
-
-    public static IEnumerable<object[]> DoVerb_TestData()
-    {
-        yield return new object[] { 1 };
-        yield return new object[] { 0 };
-        yield return new object[] { -1 };
-        yield return new object[] { -2 };
-        yield return new object[] { -3 };
-        yield return new object[] { -4 };
-        yield return new object[] { -5 };
-        yield return new object[] { -6 };
-        yield return new object[] { -7 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DoVerb_TestData))]
-    public void AxHost_DoVerb_InvokeWithHandle_Success(int verb)
-    {
-        using NoAssertContext context = new();
-        using SubAxHost control = new(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.DoVerb(verb);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DoVerb_TestData))]
-    public void AxHost_DoVerb_InvokeWithHandleWithParent_Success(int verb)
-    {
-        using NoAssertContext context = new();
-        using Control parent = new();
-        using SubAxHost control = new(WebBrowserClsidString)
-        {
-            Parent = parent
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(parent.IsHandleCreated);
-        control.DoVerb(verb);
-        Assert.True(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DoVerb_TestData))]
-    public void AxHost_DoVerb_InvokeWithHandleWithParentWithoutHandle_Success(int verb)
-    {
-        using NoAssertContext context = new();
-        using Control parent = new();
-        using SubAxHost control = new(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Parent = parent;
-        Assert.False(parent.IsHandleCreated);
-        control.DoVerb(verb);
-        Assert.True(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DoVerb_TestData))]
-    public void AxHost_DoVerb_InvokeWithoutHandle_ThrowsNullReferenceException(int verb)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        Assert.Throws<NullReferenceException>(() => control.DoVerb(verb));
-    }
-
-    [WinFormsFact]
-    public void AxHost_EndInit_Invoke_Nop()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.EndInit();
-        control.EndInit();
-        Assert.False(control.Created);
-    }
-
-    [WinFormsFact]
-    public void AxHost_EndInit_InvokeWithParent_CreatesControl()
-    {
-        var parent = new Control();
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Parent = parent
-        };
-        control.EndInit();
-        control.EndInit();
-        Assert.True(parent.Created);
-        Assert.True(control.Created);
-    }
-
-    [ComImport]
-    [Guid("D30C1661-CDAF-11d0-8A3E-00C04FC9E26E")]
-    public interface IWebBrowser2
-    {
-    }
-
-    [WinFormsFact]
-    public void AxHost_CreateControl_ValidClsid_Success()
-    {
-        using var control = new SubAxHost(WebBrowserClsidString);
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        object ocx = control.GetOcx();
-        Assert.True(ocx is IWebBrowser2);
-    }
-
-    [WinFormsFact]
-    public void AxHost_CreateControl_InvalidClsid_ThrowsCOMException()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        Assert.Throws<COMException>(() => control.CreateControl());
-    }
-
-    [WinFormsFact]
-    public void AxHost_CreateSink_Invoke_Nop()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.CreateSink();
-        control.CreateSink();
-        Assert.False(control.Created);
-    }
-
-    [WinFormsFact]
-    public void AxHost_DetachSink_Invoke_Nop()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.DetachSink();
-        control.DetachSink();
-        Assert.False(control.Created);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetOcx_NotCreated_ReturnsNull()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        Assert.Null(control.GetOcx());
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetOcx_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        object ocx = control.GetOcx();
-        Assert.NotNull(ocx);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetFontFromIFont_NullFont_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetFontFromIFont(null));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetFontFromIFont_InvalidFont_ThrowsInvalidCastException()
-    {
-        Assert.Throws<InvalidCastException>(() => SubAxHost.GetFontFromIFont(new object()));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontDispFromFont_InvokeSimpleStyle_Roundtrips()
-    {
-        using var font = new Font("Arial", 10);
-        object disp = SubAxHost.GetIFontDispFromFont(font);
-        IFont.Interface iFont = (IFont.Interface)disp;
-        Assert.Equal(font.Name, iFont.Name.ToStringAndFree());
-        Assert.Equal(97500, iFont.Size.int64);
-        Assert.False(iFont.Bold);
-        Assert.False(iFont.Italic);
-        Assert.False(iFont.Underline);
-        Assert.False(iFont.Strikethrough);
-        // Charset is locale specific
-        // Assert.Equal(0, iFont.Charset);
-        Assert.NotEqual(IntPtr.Zero, iFont.hFont);
-
-        Font result = SubAxHost.GetFontFromIFont(iFont);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(1, result.GdiCharSet);
-
-        result = SubAxHost.GetFontFromIFont((IFontDisp.Interface)disp);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(1, result.GdiCharSet);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontDispFromFont_InvokeComplexStyle_Roundtrips()
-    {
-        using var font = new Font("Arial", 10, FontStyle.Bold | FontStyle.Underline | FontStyle.Italic | FontStyle.Strikeout, GraphicsUnit.Point, 10);
-        object disp = SubAxHost.GetIFontDispFromFont(font);
-
-        IFont.Interface iFont = (IFont.Interface)disp;
-        Assert.Equal(font.Name, iFont.Name.ToStringAndFree());
-        Assert.Equal(97500, iFont.Size.int64);
-        Assert.True(iFont.Bold);
-        Assert.True(iFont.Italic);
-        Assert.True(iFont.Underline);
-        Assert.True(iFont.Strikethrough);
-        Assert.Equal(0, iFont.Charset);
-        Assert.NotEqual(IntPtr.Zero, iFont.hFont);
-
-        Font result = SubAxHost.GetFontFromIFont(iFont);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(10, result.GdiCharSet);
-
-        result = SubAxHost.GetFontFromIFont((IFontDisp.Interface)disp);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(10, result.GdiCharSet);
-    }
-
-    [WinFormsTheory]
-    [InlineData(GraphicsUnit.Document)]
-    [InlineData(GraphicsUnit.Inch)]
-    [InlineData(GraphicsUnit.Millimeter)]
-    [InlineData(GraphicsUnit.Pixel)]
-    [InlineData(GraphicsUnit.World)]
-    public void AxHost_GetIFontDispFromFont_InvalidFontUnit_ThrowsArgumentException(GraphicsUnit unit)
-    {
-        using var font = new Font("Arial", 10, unit);
-        Assert.Throws<ArgumentException>("font", () => SubAxHost.GetIFontDispFromFont(font));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontDispFromFont_NullFont_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetIFontDispFromFont(null));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontFromFont_InvokeSimpleStyle_Roundtrips()
-    {
-        using var font = new Font("Arial", 10);
-        IFont.Interface iFont = (IFont.Interface)SubAxHost.GetIFontFromFont(font);
-        Assert.Equal(font.Name, iFont.Name.ToStringAndFree());
-        Assert.Equal(97500, iFont.Size.int64);
-        Assert.False(iFont.Bold);
-        Assert.False(iFont.Italic);
-        Assert.False(iFont.Underline);
-        Assert.False(iFont.Strikethrough);
-        // Charset is locale specific
-        // Assert.Equal(0, iFont.Charset);
-        Assert.NotEqual(IntPtr.Zero, iFont.hFont);
-
-        Font result = SubAxHost.GetFontFromIFont(iFont);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(1, result.GdiCharSet);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontFromFont_InvokeComplexStyle_Roundtrips()
-    {
-        using var font = new Font("Arial", 10, FontStyle.Bold | FontStyle.Underline | FontStyle.Italic | FontStyle.Strikeout, GraphicsUnit.Point, 10);
-        IFont.Interface iFont = (IFont.Interface)SubAxHost.GetIFontFromFont(font);
-        Assert.Equal(font.Name, iFont.Name.ToStringAndFree());
-        Assert.Equal(97500, iFont.Size.int64);
-        Assert.True(iFont.Bold);
-        Assert.True(iFont.Italic);
-        Assert.True(iFont.Underline);
-        Assert.True(iFont.Strikethrough);
-        Assert.Equal(0, iFont.Charset);
-        Assert.NotEqual(IntPtr.Zero, iFont.hFont);
-
-        Font result = SubAxHost.GetFontFromIFont(iFont);
-        Assert.Equal(font.Name, result.Name);
-        Assert.Equal(9.75, result.Size);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(10, result.GdiCharSet);
-    }
-
-    [WinFormsTheory]
-    [InlineData(GraphicsUnit.Document)]
-    [InlineData(GraphicsUnit.Inch)]
-    [InlineData(GraphicsUnit.Millimeter)]
-    [InlineData(GraphicsUnit.Pixel)]
-    [InlineData(GraphicsUnit.World)]
-    public void AxHost_GetIFontFromFont_InvalidFontUnit_ThrowsArgumentException(GraphicsUnit unit)
-    {
-        using var font = new Font("Arial", 10, unit);
-        Assert.Throws<ArgumentException>("font", () => SubAxHost.GetIFontFromFont(font));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIFontFromFont_NullFont_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetIFontFromFont(null));
-    }
-
-    [WinFormsFact]
-    public unsafe void AxHost_GetIPictureFromCursor_Invoke_Roundtrips()
-    {
-        using var original = new Cursor("bitmaps/cursor.cur");
-        IPicture.Interface iPicture = (IPicture.Interface)SubAxHost.GetIPictureFromCursor(original);
-        Assert.NotNull(iPicture);
-
-        OLE_HANDLE handle = iPicture.Handle;
-        PICTYPE type = iPicture.Type;
-        int width = iPicture.Width;
-        int height = iPicture.Height;
-        uint attributes = iPicture.Attributes;
-
-        Assert.NotEqual(0u, handle);
-        Assert.True(iPicture.get_hPal(out _).Failed);
-        Assert.Equal(PICTYPE.PICTYPE_ICON, type);
-        Assert.Equal(847, width);
-        Assert.Equal(847, height);
-        Assert.Throws<COMException>(() => iPicture.CurDC);
-        Assert.Equal(2u, attributes);
-
-        Assert.Throws<InvalidCastException>(() => SubAxHost.GetPictureFromIPicture(iPicture));
-    }
-
-    [WinFormsFact]
-    public unsafe void AxHost_GetIPictureDispFromPicture_InvokeBitmap_Roundtrips()
-    {
-        var original = new Bitmap(10, 11);
-        original.SetPixel(1, 2, Color.FromArgb(unchecked((int)0xFF010203)));
-        object disp = SubAxHost.GetIPictureDispFromPicture(original);
-        using var iPictureDisp = ComHelpers.GetComScope<IDispatch>(disp);
-
-        VARIANT variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_HANDLE);
-        Assert.NotEqual(0u, variant.data.uintVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_HPAL);
-        Assert.Equal(0u, variant.data.uintVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_TYPE);
-        Assert.Equal(1, variant.data.iVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_WIDTH);
-        Assert.Equal(265u, variant.data.uintVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_HEIGHT);
-        Assert.Equal(291u, variant.data.uintVal);
-
-        var result = Assert.IsType<Bitmap>(SubAxHost.GetPictureFromIPictureDisp(disp));
-        Assert.Equal(original.Size, result.Size);
-        Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-        Assert.Equal(Color.FromArgb(unchecked((int)0xFF010203)), original.GetPixel(1, 2));
-    }
-
-    [WinFormsFact]
-    public unsafe void AxHost_GetIPictureDispFromPicture_InvokeEnhancedMetafile_Roundtrips()
-    {
-        var original = new Metafile("bitmaps/milkmateya01.emf");
-        object disp = SubAxHost.GetIPictureDispFromPicture(original);
-
-        using var iPictureDisp = ComHelpers.GetComScope<IDispatch>(disp);
-
-        VARIANT variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_HANDLE);
-        Assert.NotEqual(0u, variant.data.uintVal);
-        Assert.True(iPictureDisp.Value->TryGetProperty(PInvoke.DISPID_PICT_HPAL, &variant).Failed);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_TYPE);
-        Assert.Equal(4, variant.data.iVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_WIDTH);
-        Assert.Equal(19972u, variant.data.uintVal);
-        variant = iPictureDisp.Value->GetProperty(PInvoke.DISPID_PICT_HEIGHT);
-        Assert.Equal(28332u, variant.data.uintVal);
-
-        var result = Assert.IsType<Metafile>(SubAxHost.GetPictureFromIPictureDisp(disp));
-        Assert.Equal(new Size(759, 1073), result.Size);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIPictureDispFromPicture_InvokeMetafile_ThrowsCOMException()
-    {
-        var original = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<COMException>(() => SubAxHost.GetIPictureDispFromPicture(original));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIPictureDispFromPicture_NullImage_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetIPictureDispFromPicture(null));
-    }
-
-    [WinFormsFact]
-    public unsafe void AxHost_GetIPictureFromPicture_InvokeBitmap_Roundtrips()
-    {
-        var original = new Bitmap(10, 11);
-        original.SetPixel(1, 2, Color.FromArgb(unchecked((int)0xFF010203)));
-        IPicture.Interface iPicture = (IPicture.Interface)SubAxHost.GetIPictureFromPicture(original);
-        Assert.NotNull(iPicture);
-
-        OLE_HANDLE handle = iPicture.Handle;
-        iPicture.get_hPal(out OLE_HANDLE hPal).ThrowOnFailure();
-        PICTYPE type = iPicture.Type;
-        int width = iPicture.Width;
-        int height = iPicture.Height;
-        uint attributes = iPicture.Attributes;
-        HDC curDc = iPicture.CurDC;
-
-        Assert.NotEqual(0u, handle);
-        Assert.Equal(0u, hPal);
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, type);
-        Assert.Equal(265, width);
-        Assert.Equal(291, height);
-        Assert.Equal(default, curDc);
-        Assert.Equal(0u, attributes);
-
-        var result = Assert.IsType<Bitmap>(SubAxHost.GetPictureFromIPicture(iPicture));
-        Assert.Equal(original.Size, result.Size);
-        Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-        Assert.Equal(Color.FromArgb(unchecked((int)0xFF010203)), original.GetPixel(1, 2));
-    }
-
-    [WinFormsFact]
-    public unsafe void AxHost_GetIPictureFromPicture_InvokeEnhancedMetafile_Roundtrips()
-    {
-        var original = new Metafile("bitmaps/milkmateya01.emf");
-        IPicture.Interface iPicture = (IPicture.Interface)SubAxHost.GetIPictureFromPicture(original);
-        Assert.NotNull(iPicture);
-
-        OLE_HANDLE handle = iPicture.Handle;
-        PICTYPE type = iPicture.Type;
-        int width = iPicture.Width;
-        int height = iPicture.Height;
-        uint attributes = iPicture.Attributes;
-
-        Assert.NotEqual(0u, handle);
-        Assert.True(iPicture.get_hPal(out _).Failed);
-        Assert.Equal(PICTYPE.PICTYPE_ENHMETAFILE, type);
-        Assert.Equal(19972, width);
-        Assert.Equal(28332, height);
-        Assert.Throws<COMException>(() => iPicture.CurDC);
-        Assert.Equal(3u, attributes);
-
-        var result = Assert.IsType<Metafile>(SubAxHost.GetPictureFromIPicture(iPicture));
-        Assert.Equal(new Size(759, 1073), result.Size);
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIPictureFromPicture_InvokeMetafile_ThrowsCOMException()
-    {
-        var original = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<COMException>(() => SubAxHost.GetIPictureFromPicture(original));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetIPictureFromPicture_NullImage_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetIPictureFromPicture(null));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetPictureFromIPicture_InvokeInvalid_ThrowsInvalidCastException()
-    {
-        Assert.Throws<InvalidCastException>(() => SubAxHost.GetPictureFromIPicture(new object()));
-    }
-
-    [WinFormsFact]
-    public void AxHost_GetPictureFromIPicture_NullPicture_ReturnsNull()
-    {
-        Assert.Null(SubAxHost.GetPictureFromIPicture(null));
-    }
-
-    [WinFormsFact]
-    public void AxHost_InvokeEditMode_Invoke_Success()
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        control.InvokeEditMode();
-        Assert.Null(control.GetOcx());
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.Null(control.GetOcx());
-    }
-
-    public static IEnumerable<object[]> InvokeEditMode_Site_TestData()
-    {
-        yield return new object[] { true, null, 2 };
-        yield return new object[] { true, new object(), 2 };
-
-        yield return new object[] { false, null, 1 };
-        yield return new object[] { false, new object(), 1 };
-        yield return new object[] { false, new Mock<ISelectionService>(MockBehavior.Strict).Object, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvokeEditMode_Site_TestData))]
-    public void AxHost_InvokeEditMode_InvokeWithSite_Success(bool designMode, object selectionService, int expectedCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(selectionService)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite.Object
-        };
-        control.InvokeEditMode();
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-    }
-
-    public static IEnumerable<object[]> InvokeEditMode_SiteWithParent_TestData()
-    {
-        yield return new object[] { true, null, 3 };
-        yield return new object[] { true, new object(), 3 };
-
-        yield return new object[] { false, null, 1 };
-        yield return new object[] { false, new object(), 1 };
-        yield return new object[] { false, new Mock<ISelectionService>(MockBehavior.Strict).Object, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvokeEditMode_SiteWithParent_TestData))]
-    public void AxHost_InvokeEditMode_InvokeWithSiteWithParent_Success(bool designMode, object selectionService, int expectedCallCount)
-    {
-        using Control parent = new();
-        Mock<ISite> mockSite = new(MockBehavior.Strict);
-
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(selectionService)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-
-        using SubAxHost control = new(WebBrowserClsidString)
-        {
-            Parent = parent,
-            Site = mockSite.Object
-        };
-
-        control.InvokeEditMode();
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-
-        // Call again.
-        control.InvokeEditMode();
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AxHost_InvokeEditMode_InvokeWithSiteDesignModeWithComponentSelectedNoSelectionStyleProperty_Success(bool componentSelected)
-    {
-        using var control = new SubAxHost(WebBrowserClsidString);
-        var mockSelectionService = new Mock<ISelectionService>(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetComponentSelected(control))
-            .Returns(componentSelected)
-            .Verifiable();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        control.Site = mockSite.Object;
-        control.InvokeEditMode();
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AxHost_InvokeEditMode_InvokeWithSiteDesignModeWithComponentSelectedInvalidSelectionStyleProperty_Success(bool componentSelected)
-    {
-        using var control = new InvalidSelectionStyleAxHost(WebBrowserClsidString);
-        var mockSelectionService = new Mock<ISelectionService>(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetComponentSelected(control))
-            .Returns(componentSelected)
-            .Verifiable();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        control.Site = mockSite.Object;
-        control.InvokeEditMode();
-        Assert.Null(control.SelectionStyle);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.Null(control.SelectionStyle);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AxHost_InvokeEditMode_InvokeWithSiteDesignModeWithComponentSelectedValidSelectionStyleProperty_Success(bool componentSelected)
-    {
-        using var control = new ValidSelectionStyleAxHost(WebBrowserClsidString);
-        var mockSelectionService = new Mock<ISelectionService>(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetComponentSelected(control))
-            .Returns(componentSelected)
-            .Verifiable();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        control.Site = mockSite.Object;
-
-        control.InvokeEditMode();
-        Assert.Equal(0, control.SelectionStyle);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.Equal(0, control.SelectionStyle);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(2));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Once());
-    }
-
-    public static IEnumerable<object[]> InvokeEditMode_SiteWithHandle_TestData()
-    {
-        yield return new object[] { true, null, 3 };
-        yield return new object[] { true, new object(), 3 };
-
-        yield return new object[] { false, null, 1 };
-        yield return new object[] { false, new object(), 1 };
-        yield return new object[] { false, new Mock<ISelectionService>(MockBehavior.Strict).Object, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvokeEditMode_SiteWithHandle_TestData))]
-    public void AxHost_InvokeEditMode_InvokeWithSiteWithHandle_Success(bool designMode, object selectionService, int expectedCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(selectionService)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.InvokeEditMode();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvokeEditMode_SiteWithParent_TestData))]
-    public void AxHost_InvokeEditMode_InvokeWithSiteWithParentWithHandle_Success(bool designMode, object selectionService, int expectedCallCount)
-    {
-        using var parent = new Control();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(selectionService)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new SubAxHost(WebBrowserClsidString)
-        {
-            Parent = parent,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.InvokeEditMode();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(expectedCallCount));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2)]
-    [InlineData(false, 0)]
-    public void AxHost_InvokeEditMode_InvokeWithSiteDesignModeWithComponentSelectedValidSelectionStylePropertyWithHandle_Success(bool componentSelected, int expectedSelectionStyle)
-    {
-        using var control = new ValidSelectionStyleAxHost(WebBrowserClsidString);
-        var mockSelectionService = new Mock<ISelectionService>(MockBehavior.Strict);
-        mockSelectionService
-            .Setup(s => s.GetComponentSelected(control))
-            .Returns(componentSelected)
-            .Verifiable();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(ISelectionService)))
-            .Returns(mockSelectionService.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        control.Site = mockSite.Object;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.InvokeEditMode();
-        Assert.Equal(expectedSelectionStyle, control.SelectionStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Exactly(2));
-
-        // Call again.
-        control.InvokeEditMode();
-        Assert.Equal(expectedSelectionStyle, control.SelectionStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        mockSite.Verify(s => s.GetService(typeof(ISelectionService)), Times.Exactly(3));
-        mockSelectionService.Verify(s => s.GetComponentSelected(control), Times.Exactly(2));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void AxHost_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void AxHost_OnLeave_Invoke_CallsLeave(KeyEventArgs eventArgs)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void AxHost_OnMouseCaptureChanged_Invoke_CallsMouseCaptureChanged(EventArgs eventArgs)
-    {
-        using var control = new SubAxHost(EmptyClsidString);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseCaptureChanged += handler;
-        control.OnMouseCaptureChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseCaptureChanged -= handler;
-        control.OnMouseCaptureChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetAttributes_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        AttributeCollection attributes = customTypeDescriptor.GetAttributes();
-        Assert.NotNull(attributes[typeof(CustomAttribute)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        attributes = customTypeDescriptor.GetAttributes();
-        Assert.NotNull(attributes[typeof(CustomAttribute)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetAttributes_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        AttributeCollection attributes = customTypeDescriptor.GetAttributes();
-        Assert.NotNull(attributes[typeof(CustomAttribute)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        attributes = customTypeDescriptor.GetAttributes();
-        Assert.NotNull(attributes[typeof(CustomAttribute)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetClassName_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetClassName());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetClassName());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetClassName_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetClassName());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetClassName());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetComponentName_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetComponentName());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetComponentName());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetComponentName_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetComponentName());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetComponentName());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetConverter_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetConverter());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetConverter());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetConverter_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetConverter());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetConverter());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetDefaultEvent_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptor eventDescriptor = customTypeDescriptor.GetDefaultEvent();
-        Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        eventDescriptor = customTypeDescriptor.GetDefaultEvent();
-        Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetDefaultEvent_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptor eventDescriptor = customTypeDescriptor.GetDefaultEvent();
-        Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        eventDescriptor = customTypeDescriptor.GetDefaultEvent();
-        Assert.Equal(nameof(AxHost.Enter), eventDescriptor.Name);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetDefaultProperty_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptor propertyDescriptor = customTypeDescriptor.GetDefaultProperty();
-        Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        propertyDescriptor = customTypeDescriptor.GetDefaultProperty();
-        Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetDefaultProperty_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptor propertyDescriptor = customTypeDescriptor.GetDefaultProperty();
-        Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        propertyDescriptor = customTypeDescriptor.GetDefaultProperty();
-        Assert.Equal(nameof(AxHost.Text), propertyDescriptor.Name);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    [InlineData(typeof(ComponentEditor))]
-    [InlineData(typeof(SubComponentEditor))]
-    public void AxHost_ICustomTypeDescriptorGetEditor_typeInvoke_ReturnsExpected(Type editorBaseType)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetEditor(editorBaseType));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetEditor(editorBaseType));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    [InlineData(typeof(ComponentEditor))]
-    [InlineData(typeof(SubComponentEditor))]
-    public void AxHost_ICustomTypeDescriptorGetEditor_typeInvokeWithHandle_ReturnsExpected(Type editorBaseType)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Null(customTypeDescriptor.GetEditor(editorBaseType));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(customTypeDescriptor.GetEditor(editorBaseType));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents();
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents();
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents();
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents();
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetEvents_AttributeArray_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<Attribute>() };
-        yield return new object[] { new Attribute[] { null } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetEvents_AttributeArray_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArray_ReturnsExpected(Attribute[] attributes)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(attributes);
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(attributes);
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetEvents_AttributeArray_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArrayWithHandle_ReturnsExpected(Attribute[] attributes)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(attributes);
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(attributes);
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArrayCustom_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(new Attribute[] { new CustomAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(new Attribute[] { new CustomAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArrayCustomWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(new Attribute[] { new CustomAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(new Attribute[] { new CustomAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArrayNoSuch_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetEvents_InvokeAttributeArrayNoSuchWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        EventDescriptorCollection events = customTypeDescriptor.GetEvents(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        events = customTypeDescriptor.GetEvents(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(events.Count > 1);
-        Assert.NotNull(events[nameof(CustomAxHost.CustomEvent)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_Invoke_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        Assert.NotNull(events[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        events = customTypeDescriptor.GetProperties();
-        Assert.NotNull(events[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection events = customTypeDescriptor.GetProperties();
-        Assert.NotNull(events[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        events = customTypeDescriptor.GetProperties();
-        Assert.NotNull(events[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetProperties_AttributeArray_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<Attribute>() };
-#if false
-        yield return new object[] { new Attribute[] { null } };
-#endif
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetProperties_AttributeArray_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArray_ReturnsExpected(Attribute[] attributes)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(attributes);
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(attributes);
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetProperties_AttributeArray_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArrayWithHandle_ReturnsExpected(Attribute[] attributes)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(attributes);
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(attributes);
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArrayCustom_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(new Attribute[] { new CustomAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(new Attribute[] { new CustomAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArrayCustomWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(new Attribute[] { new CustomAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(new Attribute[] { new CustomAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArrayNoSuch_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void AxHost_ICustomTypeDescriptorGetProperties_InvokeAttributeArrayNoSuchWithHandle_ReturnsExpected()
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        PropertyDescriptorCollection properties = customTypeDescriptor.GetProperties(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        properties = customTypeDescriptor.GetProperties(new Attribute[] { new NoSuchAttribute() });
-        Assert.True(properties.Count > 1);
-        Assert.NotNull(properties[nameof(CustomAxHost.CustomProperty)]);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetPropertyOwner_TestData()
-    {
-        yield return new object[] { null };
-
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(string))[nameof(string.Length)];
-        yield return new object[] { descriptor };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPropertyOwner_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetPropertyOwner_Invoke_ReturnsExpected(PropertyDescriptor pd)
-    {
-        using var control = new CustomAxHost(EmptyClsidString);
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Same(control, customTypeDescriptor.GetPropertyOwner(pd));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Same(control, customTypeDescriptor.GetPropertyOwner(pd));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPropertyOwner_TestData))]
-    public void AxHost_ICustomTypeDescriptorGetPropertyOwner_InvokeWithHandle_ReturnsExpected(PropertyDescriptor pd)
-    {
-        using var control = new CustomAxHost(WebBrowserClsidString);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ICustomTypeDescriptor customTypeDescriptor = control;
-        Assert.Same(control, customTypeDescriptor.GetPropertyOwner(pd));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Same(control, customTypeDescriptor.GetPropertyOwner(pd));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubComponentEditor : ComponentEditor
-    {
-        public override bool EditComponent(ITypeDescriptorContext context, object component)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    [AttributeUsage(AttributeTargets.All)]
-    private class CustomAttribute : Attribute
-    {
-    }
-
-    [AttributeUsage(AttributeTargets.All)]
-    private class NoSuchAttribute : Attribute
-    {
-    }
-
-    [CustomAttribute]
-    private class CustomAxHost : AxHost
-    {
-        public CustomAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        [CustomAttribute]
-        public event EventHandler CustomEvent;
-
-        [CustomAttribute]
-        public string CustomProperty { get; set; }
-    }
-
-    private class InvalidSelectionStyleAxHost : AxHost
-    {
-        public InvalidSelectionStyleAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        public InvalidSelectionStyleAxHost(string clsid, int flags) : base(clsid, flags)
-        {
-        }
-
-        public string SelectionStyle { get; set; }
-    }
-
-    private class ValidSelectionStyleAxHost : AxHost
-    {
-        public ValidSelectionStyleAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        public ValidSelectionStyleAxHost(string clsid, int flags) : base(clsid, flags)
-        {
-        }
-
-        public int SelectionStyle { get; set; }
-    }
-
-    private class SubAxHost : AxHost
-    {
-        public SubAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        public SubAxHost(string clsid, int flags) : base(clsid, flags)
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new void AttachInterfaces() => base.AttachInterfaces();
-
-        public new void CreateSink() => base.CreateSink();
-
-        public new void DetachSink() => base.DetachSink();
-
-        public static new Font GetFontFromIFont(object font) => AxHost.GetFontFromIFont(font);
-
-        public static new object GetIFontDispFromFont(Font font) => AxHost.GetIFontDispFromFont(font);
-
-        public static new object GetIFontFromFont(Font font) => AxHost.GetIFontFromFont(font);
-
-        public static new object GetIPictureFromCursor(Cursor cursor) => AxHost.GetIPictureFromCursor(cursor);
-
-        public static new object GetIPictureDispFromPicture(Image image) => AxHost.GetIPictureDispFromPicture(image);
-
-        public static new object GetIPictureFromPicture(Image image) => AxHost.GetIPictureFromPicture(image);
-
-        public static new Image GetPictureFromIPicture(object picture) => AxHost.GetPictureFromIPicture(picture);
-
-        public static new Image GetPictureFromIPictureDisp(object picture) => AxHost.GetPictureFromIPictureDisp(picture);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnMouseCaptureChanged(EventArgs e) => base.OnMouseCaptureChanged(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BaseCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BaseCollectionTests.cs
deleted file mode 100644
index bd61e43fc7e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BaseCollectionTests.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class BaseCollectionTests
-{
-    [WinFormsFact]
-    public void BaseCollection_Ctor_Default()
-    {
-        var collection = new SubBaseCollection();
-        Assert.Throws<NullReferenceException>(() => collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Null(collection.List);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void BaseCollection_Count_GetWithList_ReturnsExpected()
-    {
-        var collection = new CustomBaseCollection(new ArrayList { 1, 2, 3 });
-        Assert.Equal(3, collection.Count);
-    }
-
-    [WinFormsFact]
-    public void BaseCollection_CopyTo_InvokeWithList_Success()
-    {
-        var collection = new CustomBaseCollection(new ArrayList { 1, 2, 3 });
-        var array = new object[] { 0, 0, 0, 0, 4 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 0, 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void BaseCollection_CopyTo_InvokeDefault_ThrowsNullReferenceException()
-    {
-        var collection = new BaseCollection();
-        Assert.Throws<NullReferenceException>(() => collection.CopyTo(Array.Empty<object>(), 0));
-    }
-
-    [WinFormsFact]
-    public void BaseCollection_GetEnumerator_InvokeWithList_Success()
-    {
-        var collection = new CustomBaseCollection(new ArrayList { 1, 2, 3 });
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-        Assert.Equal(1, enumerator.Current);
-    }
-
-    [WinFormsFact]
-    public void BaseCollection_GetEnumerator_InvokeDefault_ThrowsNullReferenceException()
-    {
-        var collection = new BaseCollection();
-        Assert.Throws<NullReferenceException>(() => collection.CopyTo(Array.Empty<object>(), 0));
-    }
-
-    private class CustomBaseCollection : BaseCollection
-    {
-        private readonly ArrayList _list;
-
-        public CustomBaseCollection(ArrayList list) => _list = list;
-
-        protected override ArrayList List => _list;
-    }
-
-    private class SubBaseCollection : BaseCollection
-    {
-        public new ArrayList List => base.List;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BinaryFormat/WinFormsBinaryFormattedObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BinaryFormat/WinFormsBinaryFormattedObjectTests.cs
deleted file mode 100644
index 47b29fa2b1e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BinaryFormat/WinFormsBinaryFormattedObjectTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.BinaryFormat.Tests;
-
-public class WinFormsBinaryFormattedObjectTests
-{
-    private static readonly Attribute[] s_visible = new Attribute[] { DesignerSerializationVisibilityAttribute.Visible };
-
-    [Theory]
-    [MemberData(nameof(BinaryFormattedObjects_TestData))]
-    public void BinaryFormattedObjects_SuccessfullyParse(object value)
-    {
-        // Check that we can parse types that would hit the BinaryFormatter for property serialization.
-        using (value as IDisposable)
-        {
-            var format = value.SerializeAndParse();
-        }
-    }
-
-    public static TheoryData<object> BinaryFormattedObjects_TestData => new()
-    {
-        new PointF(),
-        new PointF[] { default },
-        new RectangleF(),
-        new RectangleF[] { default },
-        new DateTime[] { default },
-        new ImageListStreamer(new ImageList()),
-        new ListViewGroup(),
-        new ListViewItem(),
-        new OwnerDrawPropertyBag(),
-        new TreeNode(),
-        new ListViewItem.ListViewSubItem()
-    };
-
-    [WinFormsTheory]
-    [MemberData(nameof(Control_DesignerVisibleProperties_TestData))]
-    public void Control_BinaryFormatted_DesignerVisibleProperties(object value, string[] properties)
-    {
-        // Check WinForms types for properties that can hit the BinaryFormatter
-
-        using (value as IDisposable)
-        {
-            var propertyDescriptors = TypeDescriptor.GetProperties(value, s_visible);
-
-            List<string> binaryFormattedProperties = new();
-            foreach (PropertyDescriptor property in propertyDescriptors)
-            {
-                Type propertyType = property.PropertyType;
-                if (propertyType.IsBinaryFormatted())
-                {
-                    binaryFormattedProperties.Add($"{property.Name}: {propertyType.Name}");
-                }
-            }
-
-            Assert.Equal(properties, binaryFormattedProperties);
-        }
-    }
-
-    public static TheoryData<object, string[]> Control_DesignerVisibleProperties_TestData => new()
-    {
-        { new Control(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new Form(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new Button(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new CheckBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new RadioButton(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new DataGridView(), new string[] { "DataSource: Object", "DataContext: Object", "Tag: Object" } },
-        { new DateTimePicker(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new GroupBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new Label(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new ComboBox(), new string[] { "DataSource: Object", "DataContext: Object", "Tag: Object" } },
-        { new ListBox(), new string[] { "DataSource: Object", "DataContext: Object", "Tag: Object" } },
-        { new ListView(), new string[] { "DataContext: Object", "Tag: Object" } },
-        {
-            new MonthCalendar(), new string[]
-            {
-                "AnnuallyBoldedDates: DateTime[]",
-                "BoldedDates: DateTime[]",
-                "MonthlyBoldedDates: DateTime[]",
-                "DataContext: Object",
-                "Tag: Object"
-            }
-        },
-        { new PictureBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new PrintPreviewControl(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new ProgressBar(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new ScrollableControl(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new HScrollBar(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new VScrollBar(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new Splitter(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new TabControl(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new TextBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new RichTextBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new MaskedTextBox(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new ToolStrip(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new TrackBar(), new string[] { "DataContext: Object", "Tag: Object" } },
-        { new WebBrowser(), new string[] { "DataContext: Object", "Tag: Object" } },
-    };
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingCompleteEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingCompleteEventArgsTests.cs
deleted file mode 100644
index 35d91a02177..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingCompleteEventArgsTests.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingCompleteEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Binding_BindingCompleteState_BindingCompleteContext_TestData()
-    {
-        yield return new object[] { new Binding(null, new object(), "member"), BindingCompleteState.DataError, BindingCompleteContext.DataSourceUpdate };
-        yield return new object[] { null, BindingCompleteState.Success - 1, BindingCompleteContext.ControlUpdate - 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Binding_BindingCompleteState_BindingCompleteContext_TestData))]
-    public void Ctor_Binding_BindingCompleteState_BindingCompleteContext(Binding binding, BindingCompleteState state, BindingCompleteContext context)
-    {
-        var e = new BindingCompleteEventArgs(binding, state, context);
-        Assert.Equal(binding, e.Binding);
-        Assert.Equal(state, e.BindingCompleteState);
-        Assert.Equal(context, e.BindingCompleteContext);
-        Assert.Empty(e.ErrorText);
-        Assert.Null(e.Exception);
-        Assert.False(e.Cancel);
-    }
-
-    public static IEnumerable<object[]> Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_TestData()
-    {
-        yield return new object[] { new Binding(null, new object(), "member"), BindingCompleteState.DataError, BindingCompleteContext.DataSourceUpdate, "errorText" };
-        yield return new object[] { null, BindingCompleteState.Success - 1, BindingCompleteContext.ControlUpdate - 1, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_TestData))]
-    public void Ctor_Binding_BindingCompleteState_BindingCompleteContext_String(Binding binding, BindingCompleteState state, BindingCompleteContext context, string errorText)
-    {
-        var e = new BindingCompleteEventArgs(binding, state, context, errorText);
-        Assert.Equal(binding, e.Binding);
-        Assert.Equal(state, e.BindingCompleteState);
-        Assert.Equal(context, e.BindingCompleteContext);
-        Assert.Equal(errorText ?? "", e.ErrorText);
-        Assert.Null(e.Exception);
-        Assert.True(e.Cancel);
-    }
-
-    public static IEnumerable<object[]> Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception_TestData()
-    {
-        yield return new object[] { new Binding(null, new object(), "member"), BindingCompleteState.DataError, BindingCompleteContext.DataSourceUpdate, "errorText", new Exception() };
-        yield return new object[] { null, BindingCompleteState.Success - 1, BindingCompleteContext.ControlUpdate - 1, null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception_TestData))]
-    public void Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception(Binding binding, BindingCompleteState state, BindingCompleteContext context, string errorText, Exception exception)
-    {
-        var e = new BindingCompleteEventArgs(binding, state, context, errorText, exception);
-        Assert.Equal(binding, e.Binding);
-        Assert.Equal(state, e.BindingCompleteState);
-        Assert.Equal(context, e.BindingCompleteContext);
-        Assert.Equal(errorText ?? "", e.ErrorText);
-        Assert.Equal(exception, e.Exception);
-        Assert.True(e.Cancel);
-    }
-
-    public static IEnumerable<object[]> Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception_Bool_TestData()
-    {
-        yield return new object[] { new Binding(null, new object(), "member"), BindingCompleteState.DataError, BindingCompleteContext.DataSourceUpdate, "errorText", new Exception(), true };
-        yield return new object[] { null, BindingCompleteState.Success - 1, BindingCompleteContext.ControlUpdate - 1, null, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception_Bool_TestData))]
-    public void Ctor_Binding_BindingCompleteState_BindingCompleteContext_String_Exception_Bool(Binding binding, BindingCompleteState state, BindingCompleteContext context, string errorText, Exception exception, bool cancel)
-    {
-        var e = new BindingCompleteEventArgs(binding, state, context, errorText, exception, cancel);
-        Assert.Equal(binding, e.Binding);
-        Assert.Equal(state, e.BindingCompleteState);
-        Assert.Equal(context, e.BindingCompleteContext);
-        Assert.Equal(errorText ?? "", e.ErrorText);
-        Assert.Equal(exception, e.Exception);
-        Assert.Equal(cancel, e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingContextTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingContextTests.cs
deleted file mode 100644
index 926e7335fbb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingContextTests.cs
+++ /dev/null
@@ -1,1057 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Reflection;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingContextTests
-{
-    [Fact]
-    public void BindingContext_Ctor_Default()
-    {
-        var context = new BindingContext();
-        Assert.False(context.IsReadOnly);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_ICollection_GetProperties_ReturnsExpected()
-    {
-        ICollection context = new BindingContext();
-        Assert.False(context.IsSynchronized);
-        Assert.Same(context, context.SyncRoot);
-        Assert.Equal(0, context.Count);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Count_GetWithNullWeakReferenceTarget_ScrubsWeakRefs()
-    {
-        var context = new BindingContext();
-        var dataSource1 = new DataSource { Property = 1 };
-        var dataSource2 = new DataSource { Property = 2 };
-        PropertyManager manager1 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource1, "Property"]);
-        PropertyManager manager2 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource2, "Property"]);
-        var array = new DictionaryEntry[4];
-        ((ICollection)context).CopyTo(array, 0);
-
-        WeakReference reference1 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager1).Value);
-        WeakReference reference2 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager2).Value);
-        Assert.Same(manager1, reference1.Target);
-        Assert.Same(manager2, reference2.Target);
-
-        // Simulate a GC by assigning the weak reference to null.
-        reference1.Target = null;
-        reference2.Target = null;
-
-        // Verify these weak references have been scrubbed.
-        Assert.Equal(2, ((ICollection)context).Count);
-    }
-
-    [Fact]
-    public void BindingContext_Add_NullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.Add(null, source.CurrencyManager));
-    }
-
-    [Fact]
-    public void BindingContext_Add_Invoke_GetReturnsExpected()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        using var source2 = new BindingSource();
-        var dataSource = new DataSource();
-        context.Add(dataSource, source1.CurrencyManager);
-        Assert.Single(context);
-
-        Assert.Same(source1.CurrencyManager, context[dataSource]);
-        Assert.Same(source1.CurrencyManager, context[dataSource, null]);
-        Assert.Same(source1.CurrencyManager, context[dataSource, string.Empty]);
-
-        // Set new value.
-        context.Add(dataSource, source2.CurrencyManager);
-        Assert.Single(context);
-        Assert.Same(source2.CurrencyManager, context[dataSource]);
-        Assert.Same(source2.CurrencyManager, context[dataSource, null]);
-        Assert.Same(source2.CurrencyManager, context[dataSource, string.Empty]);
-    }
-
-    [Fact]
-    public void BindingContext_Add_InvokeMultiple_Success()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        using var source2 = new BindingSource();
-        var dataSource1 = new DataSource();
-        var dataSource2 = new DataSource();
-        context.Add(dataSource1, source1.CurrencyManager);
-        context.Add(dataSource2, source2.CurrencyManager);
-        Assert.Equal(2, ((ICollection)context).Count);
-
-        Assert.Same(source1.CurrencyManager, context[dataSource1]);
-        Assert.Same(source2.CurrencyManager, context[dataSource2]);
-    }
-
-    [Fact]
-    public void BindingContext_Add_NullListManager_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        Assert.Throws<ArgumentNullException>("listManager", () => context.Add(1, null));
-    }
-
-    [Fact]
-    public void BindingContext_AddCore_Invoke_GetReturnsExpected()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        using var source2 = new BindingSource();
-        var dataSource = new DataSource();
-        context.AddCore(dataSource, source1.CurrencyManager);
-        Assert.Single(context);
-
-        Assert.Same(source1.CurrencyManager, context[dataSource]);
-        Assert.Same(source1.CurrencyManager, context[dataSource, null]);
-        Assert.Same(source1.CurrencyManager, context[dataSource, string.Empty]);
-
-        // Set new value.
-        context.AddCore(dataSource, source2.CurrencyManager);
-        Assert.Single(context);
-        Assert.Same(source2.CurrencyManager, context[dataSource]);
-        Assert.Same(source2.CurrencyManager, context[dataSource, null]);
-        Assert.Same(source2.CurrencyManager, context[dataSource, string.Empty]);
-    }
-
-    [Fact]
-    public void BindingContext_AddCore_InvokeMultiple_Success()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        using var source2 = new BindingSource();
-        var dataSource1 = new DataSource();
-        var dataSource2 = new DataSource();
-        context.AddCore(dataSource1, source1.CurrencyManager);
-        context.AddCore(dataSource2, source2.CurrencyManager);
-        Assert.Equal(2, ((ICollection)context).Count);
-
-        Assert.Same(source1.CurrencyManager, context[dataSource1]);
-        Assert.Same(source2.CurrencyManager, context[dataSource2]);
-    }
-
-    [Fact]
-    public void BindingContext_AddCore_NullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.AddCore(null, source.CurrencyManager));
-    }
-
-    [Fact]
-    public void BindingContext_AddCore_NullListManager_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        Assert.Throws<ArgumentNullException>("listManager", () => context.AddCore(1, null));
-    }
-
-    [Fact]
-    public void BindingContext_CopyTo_Invoke_Success()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        var dataSource = new DataSource();
-        context.Add(dataSource, source.CurrencyManager);
-
-        var array = new object[] { 1, 2, 3 };
-        ((ICollection)context).CopyTo(array, 1);
-        Assert.Equal(1, array[0]);
-        Assert.NotNull(Assert.IsType<DictionaryEntry>(array[1]).Key);
-        Assert.Equal(source.CurrencyManager, Assert.IsType<WeakReference>(Assert.IsType<DictionaryEntry>(array[1]).Value).Target);
-        Assert.Equal(3, array[2]);
-    }
-
-    [Fact]
-    public void BindingContext_CopyTo_WithNullWeakReferenceTarget_ScrubsWeakRefs()
-    {
-        var context = new BindingContext();
-        var dataSource1 = new DataSource { Property = 1 };
-        var dataSource2 = new DataSource { Property = 2 };
-        PropertyManager manager1 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource1, "Property"]);
-        PropertyManager manager2 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource2, "Property"]);
-        var array = new DictionaryEntry[4];
-        ((ICollection)context).CopyTo(array, 0);
-
-        WeakReference reference1 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager1).Value);
-        WeakReference reference2 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager2).Value);
-        Assert.Same(manager1, reference1.Target);
-        Assert.Same(manager2, reference2.Target);
-
-        // Simulate a GC by assigning the weak reference to null.
-        reference1.Target = null;
-        reference2.Target = null;
-
-        // Verify these weak references have been scrubbed.
-        var destArray = new object[] { 1, 2, 3, 4 };
-        ((ICollection)context).CopyTo(destArray, 1);
-        Assert.Equal(1, destArray[0]);
-        Assert.IsType<DictionaryEntry>(destArray[1]);
-        Assert.IsType<DictionaryEntry>(destArray[2]);
-        Assert.Equal(4, destArray[3]);
-    }
-
-    [Fact]
-    public void BindingContext_GetEnumerator_WithNullWeakReferenceTarget_ScrubsWeakRefs()
-    {
-        var context = new BindingContext();
-        var dataSource1 = new DataSource { Property = 1 };
-        var dataSource2 = new DataSource { Property = 2 };
-        PropertyManager manager1 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource1, "Property"]);
-        PropertyManager manager2 = Assert.IsAssignableFrom<PropertyManager>(context[dataSource2, "Property"]);
-        var array = new DictionaryEntry[4];
-        ((ICollection)context).CopyTo(array, 0);
-
-        WeakReference reference1 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager1).Value);
-        WeakReference reference2 = Assert.IsType<WeakReference>(array.Single(p => ((WeakReference)p.Value).Target == manager2).Value);
-        Assert.Same(manager1, reference1.Target);
-        Assert.Same(manager2, reference2.Target);
-
-        // Simulate a GC by assigning the weak reference to null.
-        reference1.Target = null;
-        reference2.Target = null;
-
-        // Verify these weak references have been scrubbed.
-        IEnumerator enumerator = ((ICollection)context).GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-        Assert.IsType<DictionaryEntry>(enumerator.Current);
-        Assert.True(enumerator.MoveNext());
-        Assert.IsType<DictionaryEntry>(enumerator.Current);
-        Assert.False(enumerator.MoveNext());
-    }
-
-    [Fact]
-    public void BindingContext_Remove_Invoke_Success()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        var dataSource1 = new DataSource();
-        using var source2 = new BindingSource();
-        var dataSource2 = new DataSource();
-        context.Add(dataSource1, source1.CurrencyManager);
-        context.Add(dataSource2, source2.CurrencyManager);
-
-        context.Remove(dataSource1);
-        Assert.Single(context);
-
-        // Remove again.
-        context.Remove(dataSource1);
-        Assert.Single(context);
-
-        context.Remove(dataSource2);
-        Assert.Empty(context);
-
-        // Remove again.
-        context.Remove(dataSource2);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Remove_NullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.Remove(null));
-    }
-
-    [Fact]
-    public void BindingContext_RemoveCore_Invoke_Success()
-    {
-        var context = new SubBindingContext();
-        using var source1 = new BindingSource();
-        var dataSource1 = new DataSource();
-        using var source2 = new BindingSource();
-        var dataSource2 = new DataSource();
-        context.Add(dataSource1, source1.CurrencyManager);
-        context.Add(dataSource2, source2.CurrencyManager);
-
-        context.RemoveCore(dataSource1);
-        Assert.Single(context);
-
-        // Remove again.
-        context.RemoveCore(dataSource1);
-        Assert.Single(context);
-
-        context.RemoveCore(dataSource2);
-        Assert.Empty(context);
-
-        // Remove again.
-        context.RemoveCore(dataSource2);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_RemoveCore_NullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.RemoveCore(null));
-    }
-
-    [Fact]
-    public void BindingContext_Clear_Empty_Success()
-    {
-        var context = new SubBindingContext();
-        context.Clear();
-        Assert.Empty(context);
-
-        // Clear again.
-        context.Clear();
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Clear_NotEmpty_Success()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        context.Add(new DataSource(), source.CurrencyManager);
-
-        // Clear again.
-        context.Clear();
-        Assert.Empty(context);
-
-        context.Clear();
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_ClearCore_Empty_Success()
-    {
-        var context = new SubBindingContext();
-        context.ClearCore();
-        Assert.Empty(context);
-
-        // Clear again.
-        context.ClearCore();
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_ClearCore_NotEmpty_Success()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        context.Add(new DataSource(), source.CurrencyManager);
-
-        // Clear again.
-        context.ClearCore();
-        Assert.Empty(context);
-
-        context.ClearCore();
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Contains_DataSource_ReturnsExpected()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        var dataSource = new DataSource();
-        context.Add(dataSource, source.CurrencyManager);
-        Assert.True(context.Contains(dataSource));
-        Assert.True(context.Contains(dataSource, null));
-        Assert.True(context.Contains(dataSource, string.Empty));
-        Assert.False(context.Contains(1));
-        Assert.False(context.Contains(1, null));
-        Assert.False(context.Contains(1, string.Empty));
-    }
-
-    [Fact]
-    public void BindingContext_Contains_DataSourceDataMember_ReturnsExpected()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        var dataSource1 = new DataSource();
-        var dataSource2 = new DataSource();
-        context.Add(dataSource1, source.CurrencyManager);
-        Assert.NotNull(context[dataSource2, "Property"]);
-
-        Assert.True(context.Contains(dataSource1, null));
-        Assert.True(context.Contains(dataSource1, string.Empty));
-        Assert.False(context.Contains(dataSource1, "Property"));
-        Assert.True(context.Contains(dataSource2, null));
-        Assert.True(context.Contains(dataSource2, string.Empty));
-        Assert.True(context.Contains(dataSource2, "Property"));
-        Assert.True(context.Contains(dataSource2, "property"));
-        Assert.False(context.Contains(dataSource2, "NoSuchProperty"));
-        Assert.False(context.Contains(1, "Property"));
-    }
-
-    [Fact]
-    public void BindingContext_Contains_NullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new BindingContext();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.Contains(null));
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.Contains(null, null));
-        Assert.Throws<ArgumentNullException>("dataSource", () => context.Contains(null, string.Empty));
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetNoSuchDataSource_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[dataSource]);
-        Assert.Same(dataSource, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Single(context);
-        Assert.Same(manager, context[dataSource]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListDataSource_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<int> { 1, 2, 3 };
-        CurrencyManager manager = Assert.IsType<CurrencyManager>(context[dataSource]);
-        Assert.Same(dataSource, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Single(context);
-        Assert.Same(manager, context[dataSource]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetArrayDataSource_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var dataSource = new int[] { 1, 2, 3 };
-        CurrencyManager manager = Assert.IsType<CurrencyManager>(context[dataSource]);
-        Assert.Same(dataSource, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Single(context);
-        Assert.Same(manager, context[dataSource]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSource_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<int> { 1, 2, 3 };
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns(dataSource);
-
-        CurrencyManager manager = Assert.IsType<CurrencyManager>(context[mockIListSource.Object]);
-        Assert.Same(dataSource, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Single(context);
-        Assert.Same(manager, context[mockIListSource.Object]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSourceReturningNull_ThrowsArgumentNullException()
-    {
-        var context = new BindingContext();
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns((IList)null);
-
-        Assert.Throws<ArgumentNullException>("dataSource", () => context[mockIListSource.Object]);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetWithICurrencyManagerProvider_DoesNotAddToCollection()
-    {
-        var context = new BindingContext();
-        CurrencyManager manager = new BindingSource().CurrencyManager;
-        var mockCurrencyManagerProvider = new Mock<ICurrencyManagerProvider>();
-        mockCurrencyManagerProvider
-            .Setup(p => p.GetRelatedCurrencyManager("dataMember"))
-            .Returns(manager);
-
-        Assert.Same(manager, context[mockCurrencyManagerProvider.Object, "dataMember"]);
-        Assert.Empty(context);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetWithNullICurrencyManagerProvider_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var mockCurrencyManagerProvider = new Mock<ICurrencyManagerProvider>();
-        mockCurrencyManagerProvider
-            .Setup(p => p.GetRelatedCurrencyManager("dataMember"))
-            .Returns((CurrencyManager)null);
-
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[mockCurrencyManagerProvider.Object]);
-        Assert.Single(context);
-        Assert.Same(manager, context[mockCurrencyManagerProvider.Object]);
-    }
-
-    public static IEnumerable<object[]> Item_DataSourceWithDataMember_TestData()
-    {
-        var dataSource = new ParentDataSource
-        {
-            ParentProperty = new DataSource
-            {
-                Property = 1
-            }
-        };
-        yield return new object[] { dataSource, "ParentProperty", dataSource.ParentProperty, 2 };
-        yield return new object[] { dataSource, "ParentProperty.Property", dataSource.ParentProperty.Property, 3 };
-        yield return new object[] { dataSource, "parentproperty", dataSource.ParentProperty, 2 };
-        yield return new object[] { dataSource, "parentproperty.property", dataSource.ParentProperty.Property, 3 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Item_DataSourceWithDataMember_TestData))]
-    public void BindingContext_Item_GetNoSuchDataSourceWithDataMember_AddsToCollection(object dataSource, string dataMember, object expectedCurrent, int expectedCount)
-    {
-        var context = new BindingContext();
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource, dataMember]);
-        Assert.Equal(expectedCurrent, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(expectedCount, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, dataMember]);
-        Assert.Same(manager, context[dataSource, dataMember.ToLower()]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetWithAddedDataSourceWithDataMember_ThrowsArgumentException()
-    {
-        var context = new SubBindingContext();
-        using var source = new BindingSource();
-        var dataSource = new DataSource();
-        context.Add(dataSource, source.CurrencyManager);
-        Assert.Throws<ArgumentException>(() => context[dataSource, "Property"]);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    public void BindingContext_Item_GetNoSuchDataSourceNullOrEmptyMember_AddsToCollection(string dataMember)
-    {
-        var context = new SubBindingContext();
-        var dataSource = new DataSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[dataSource, dataMember]);
-        Assert.Single(context);
-        Assert.Same(manager, context[dataSource]);
-        Assert.Same(manager, context[dataSource, string.Empty]);
-        Assert.Same(manager, context[dataSource]);
-        Assert.Same(manager, context[dataSource, null]);
-    }
-
-    [Theory]
-    [InlineData("NoSuchProperty")]
-    [InlineData(".")]
-    [InlineData("..")]
-    [InlineData("ParentProperty.")]
-    [InlineData("ParentProperty.NoSuchProperty")]
-    public void BindingContext_Item_GetNoSuchDataSourceNoSuchDataMember_ThrowsArgumentException(string dataMember)
-    {
-        var context = new SubBindingContext();
-        var dataSource = new ParentDataSource();
-        Assert.Throws<ArgumentException>(() => context[dataSource, dataMember]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListWithDataMemberReturningIList_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var list = new List<int> { 1, 2, 3 };
-        var dataSource = new IListDataSource
-        {
-            Property = list
-        };
-
-        CurrencyManager manager = Assert.IsAssignableFrom<CurrencyManager>(context[dataSource, "Property"]);
-        Assert.Same(list, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListWithDataMemberReturningNonIList_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var list = new List<int> { 1, 2, 3 };
-        var dataSource = new ObjectDataSource
-        {
-            Property = list
-        };
-
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource, "Property"]);
-        Assert.Same(list, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetArrayWithDataMember_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var list = new int[] { 1, 2, 3 };
-        var dataSource = new IListDataSource
-        {
-            Property = list
-        };
-
-        CurrencyManager manager = Assert.IsAssignableFrom<CurrencyManager>(context[dataSource, "Property"]);
-        Assert.Same(list, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSourceWithDataMemberReturningIList_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var list = new List<int> { 1, 2, 3 };
-        var dataSource = new IListDataSource();
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns(list);
-        Mock<IList> mockIList = mockIListSource.As<IList>();
-        dataSource.Property = mockIList.Object;
-
-        CurrencyManager manager = Assert.IsAssignableFrom<CurrencyManager>(context[dataSource, "Property"]);
-        Assert.Same(list, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSourceWithDataMemberReturningNonIList_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var list = new List<int> { 1, 2, 3 };
-        var dataSource = new IListSourceDataSource();
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns(list);
-        dataSource.Property = mockIListSource.Object;
-
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource, "Property"]);
-        Assert.Same(mockIListSource.Object, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSourceWithDataMemberReturningIListNull_ThrowsArgumentNullException()
-    {
-        var context = new BindingContext();
-        var dataSource = new IListDataSource();
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns((IList)null);
-        Mock<IList> mockIList = mockIListSource.As<IList>();
-        dataSource.Property = mockIList.Object;
-
-        Assert.Throws<ArgumentNullException>("dataSource", () => context[dataSource, "Property"]);
-
-        // Does, however, add the parent.
-        PropertyManager parentManager = Assert.IsType<PropertyManager>(Assert.IsType<WeakReference>(Assert.IsType<DictionaryEntry>(Assert.Single(context)).Value).Target);
-        Assert.Same(dataSource, parentManager.Current);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetIListSourceDataSourceWithDataMemberReturningNonIListNull_AddsToCollection()
-    {
-        var context = new BindingContext();
-        var dataSource = new IListSourceDataSource();
-        var mockIListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockIListSource
-            .Setup(s => s.GetList())
-            .Returns((IList)null);
-        dataSource.Property = mockIListSource.Object;
-
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource, "Property"]);
-        Assert.Same(mockIListSource.Object, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Equal(2, ((ICollection)context).Count);
-        Assert.Same(manager, context[dataSource, "Property"]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetWithNullWeakReferenceTarget_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[dataSource]);
-        WeakReference reference = Assert.IsType<WeakReference>(Assert.IsType<DictionaryEntry>(Assert.Single(context)).Value);
-        Assert.Same(manager, reference.Target);
-
-        // Simulate a GC by assigning the weak reference to null.
-        reference.Target = null;
-
-        // Now get the new manager and verify it.
-        PropertyManager newManager = Assert.IsType<PropertyManager>(context[dataSource]);
-        Assert.NotSame(manager, newManager);
-        Assert.Same(dataSource, newManager.Current);
-        Assert.Equal(1, newManager.Count);
-        Assert.Equal(0, newManager.Position);
-        Assert.Single(context);
-        Assert.Same(newManager, context[dataSource]);
-    }
-
-    [Fact]
-    public void BindingContext_Item_GetNullDataSource_ThrowsArgumentNullException()
-    {
-        var context = new SubBindingContext();
-        Assert.Throws<ArgumentNullException>("dataSource", () => context[null]);
-        Assert.Throws<ArgumentNullException>("dataSource", () => context[null, null]);
-        Assert.Throws<ArgumentNullException>("dataSource", () => context[null, string.Empty]);
-    }
-
-    [Fact]
-    public void BindingContext_CollectionChanged_Add_ThrowsNotImplementedException()
-    {
-        var context = new BindingContext();
-        CollectionChangeEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotImplementedException>(() => context.CollectionChanged += handler);
-    }
-
-    [Fact]
-    public void BindingContext_CollectionChanged_Remove_Nop()
-    {
-        var context = new BindingContext();
-        CollectionChangeEventHandler handler = (sender, e) => { };
-        context.CollectionChanged -= handler;
-    }
-
-    [Fact]
-    public void BindingContext_OnCollectionChanged_Invoke_Nop()
-    {
-        var context = new SubBindingContext();
-        CollectionChangeEventHandler handler = (sender, e) => { };
-        context.OnCollectionChanged(null);
-    }
-
-    [Fact]
-    public void BindingContext_KeyEquals_Invoke_ReturnsExpected()
-    {
-        var context1 = new SubBindingContext();
-        var context2 = new SubBindingContext();
-        var context3 = new SubBindingContext();
-        var context4 = new SubBindingContext();
-        using var source1 = new BindingSource();
-        using var source2 = new BindingSource();
-        var dataSource1 = new DataSource();
-        var dataSource2 = new DataSource();
-
-        context1.Add(dataSource1, source1.CurrencyManager);
-        context2.Add(dataSource1, source1.CurrencyManager);
-        context3.Add(dataSource2, source1.CurrencyManager);
-        context4.Add(dataSource2, source2.CurrencyManager);
-
-        DictionaryEntry entry1 = Assert.IsType<DictionaryEntry>(Assert.Single(context1));
-        DictionaryEntry entry2 = Assert.IsType<DictionaryEntry>(Assert.Single(context2));
-        DictionaryEntry entry3 = Assert.IsType<DictionaryEntry>(Assert.Single(context3));
-        DictionaryEntry entry4 = Assert.IsType<DictionaryEntry>(Assert.Single(context3));
-
-        Assert.True(entry1.Key.Equals(entry1.Key));
-        Assert.True(entry1.Key.Equals(entry2.Key));
-        Assert.False(entry1.Key.Equals(entry3.Key));
-        Assert.False(entry1.Key.Equals(entry4.Key));
-
-        Assert.False(entry1.Key.Equals(new object()));
-        Assert.False(entry1.Key.Equals(null));
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NewBindingWithoutDataMember_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        BindingContext.UpdateBinding(context, binding);
-        Assert.Single(context);
-
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[dataSource]);
-        Assert.Same(binding, Assert.Single(manager.Bindings));
-        Assert.Same(dataSource, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Same(manager, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NewListBindingWithoutDataMember_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<int> { 1, 2, 3 };
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        BindingContext.UpdateBinding(context, binding);
-        Assert.Single(context);
-
-        CurrencyManager manager = Assert.IsType<CurrencyManager>(context[dataSource]);
-        Assert.Same(binding, Assert.Single(manager.Bindings));
-        Assert.Same(dataSource, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Same(manager, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NewBindingWithDataMember_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource { Property = 1 };
-        var binding = new Binding(null, dataSource, "Property.ignored");
-
-        BindingContext.UpdateBinding(context, binding);
-        Assert.Equal(2, ((ICollection)context).Count);
-
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource, "Property"]);
-        Assert.Same(binding, Assert.Single(manager.Bindings));
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Same(manager, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NewListBindingWithDataMember_Success()
-    {
-        var context = new BindingContext();
-        var list = new List<int> { 1, 2, 3 };
-        var dataSource = new IListDataSource { Property = list };
-        var binding = new Binding(null, dataSource, "Property.ignore");
-
-        BindingContext.UpdateBinding(context, binding);
-        Assert.Equal(2, ((ICollection)context).Count);
-
-        CurrencyManager manager = Assert.IsAssignableFrom<CurrencyManager>(context[dataSource, "Property"]);
-        Assert.Same(binding, Assert.Single(manager.Bindings));
-        Assert.Same(list, manager.List);
-        Assert.Equal(1, manager.Current);
-        Assert.Equal(3, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Same(manager, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_UpdateBindingWithoutDataMember_Success()
-    {
-        var context1 = new BindingContext();
-        var context2 = new BindingContext();
-        var dataSource = new DataSource();
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        BindingContext.UpdateBinding(context1, binding);
-        Assert.Single(context1);
-        Assert.Empty(context2);
-
-        // Update.
-        BindingContext.UpdateBinding(context2, binding);
-        Assert.Single(context1);
-        Assert.Single(context2);
-
-        PropertyManager manager1 = Assert.IsType<PropertyManager>(context1[dataSource]);
-        Assert.Empty(manager1.Bindings);
-        Assert.Same(dataSource, manager1.Current);
-        Assert.Equal(1, manager1.Count);
-        Assert.Equal(0, manager1.Position);
-
-        PropertyManager manager2 = Assert.IsType<PropertyManager>(context2[dataSource]);
-        Assert.Same(binding, Assert.Single(manager2.Bindings));
-        Assert.Same(dataSource, manager2.Current);
-        Assert.Equal(1, manager2.Count);
-        Assert.Equal(0, manager2.Position);
-        Assert.Same(manager2, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_UpdateListBindingWithoutDataMember_Success()
-    {
-        var context1 = new BindingContext();
-        var context2 = new BindingContext();
-        var dataSource = new List<int> { 1, 2, 3 };
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        BindingContext.UpdateBinding(context1, binding);
-        Assert.Single(context1);
-        Assert.Empty(context2);
-
-        // Update.
-        BindingContext.UpdateBinding(context2, binding);
-        Assert.Single(context1);
-        Assert.Single(context2);
-
-        CurrencyManager manager1 = Assert.IsType<CurrencyManager>(context1[dataSource]);
-        Assert.Empty(manager1.Bindings);
-        Assert.Same(dataSource, manager1.List);
-        Assert.Equal(1, manager1.Current);
-        Assert.Equal(3, manager1.Count);
-        Assert.Equal(0, manager1.Position);
-
-        CurrencyManager manager2 = Assert.IsType<CurrencyManager>(context2[dataSource]);
-        Assert.Same(binding, Assert.Single(manager2.Bindings));
-        Assert.Same(dataSource, manager2.List);
-        Assert.Equal(1, manager2.Current);
-        Assert.Equal(3, manager2.Count);
-        Assert.Equal(0, manager2.Position);
-        Assert.Same(manager2, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NullBindingContext_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        // Without binding manager.
-        BindingContext.UpdateBinding(null, binding);
-        Assert.Null(binding.BindingManagerBase);
-
-        // With binding manager.
-        BindingContext.UpdateBinding(context, binding);
-        Assert.Single(context);
-        Assert.NotNull(binding.BindingManagerBase);
-
-        BindingContext.UpdateBinding(null, binding);
-        Assert.Single(context);
-
-        PropertyManager manager = Assert.IsAssignableFrom<PropertyManager>(context[dataSource]);
-        Assert.Empty(manager.Bindings);
-        Assert.Equal(dataSource, manager.Current);
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Null(binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void BindingContext_InvokeCircularWithoutComponent_ThrowsArgumentException()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        var binding = new Binding(null, dataSource, "dataMember");
-
-        BindingContext.UpdateBinding(context, binding);
-        BindingManagerBase oldManager = binding.BindingManagerBase;
-        int callCount = 0;
-        oldManager.Bindings.CollectionChanged += (sender, e) =>
-        {
-            if (e.Action == CollectionChangeAction.Remove)
-            {
-                Assert.Null(binding.BindingManagerBase);
-                MethodInfo m = oldManager.Bindings.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
-                m.Invoke(oldManager.Bindings, new object[] { binding });
-                Assert.NotNull(binding.BindingManagerBase);
-                callCount++;
-            }
-        };
-        Assert.Throws<ArgumentException>("dataBinding", () => BindingContext.UpdateBinding(context, binding));
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void BindingContext_InvokeCircularWithComponent_ThrowsArgumentException()
-    {
-        var context = new BindingContext();
-        var dataSource = new DataSource();
-        var binding = new Binding(null, dataSource, "dataMember");
-        var control = new Control();
-        control.DataBindings.Add(binding);
-        Assert.NotNull(binding.BindableComponent);
-
-        BindingContext.UpdateBinding(context, binding);
-        BindingManagerBase oldManager = binding.BindingManagerBase;
-        int callCount = 0;
-        oldManager.Bindings.CollectionChanged += (sender, e) =>
-        {
-            if (e.Action == CollectionChangeAction.Remove)
-            {
-                Assert.Null(binding.BindingManagerBase);
-                MethodInfo m = oldManager.Bindings.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
-                m.Invoke(oldManager.Bindings, new object[] { binding });
-                Assert.NotNull(binding.BindingManagerBase);
-                callCount++;
-            }
-        };
-        Assert.Throws<ArgumentException>("dataBinding", () => BindingContext.UpdateBinding(context, binding));
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void BindingContext_UpdateBinding_NullBinding_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("binding", () => BindingContext.UpdateBinding(new BindingContext(), null));
-    }
-
-    private class ParentDataSource
-    {
-        public DataSource ParentProperty { get; set; }
-    }
-
-    private class DataSource
-    {
-        public int Property { get; set; }
-    }
-
-    private class IListDataSource
-    {
-        public IList Property { get; set; }
-    }
-
-    private class IListSourceDataSource
-    {
-        public IListSource Property { get; set; }
-    }
-
-    private class ObjectDataSource
-    {
-        public object Property { get; set; }
-    }
-
-    private class SubBindingContext : BindingContext
-    {
-        public new void Add(object dataSource, BindingManagerBase listManager) => base.Add(dataSource, listManager);
-
-        public new void AddCore(object dataSource, BindingManagerBase listManager) => base.AddCore(dataSource, listManager);
-
-        public new void Remove(object dataSource) => base.Remove(dataSource);
-
-        public new void RemoveCore(object dataSource) => base.RemoveCore(dataSource);
-
-        public new void Clear() => base.Clear();
-
-        public new void ClearCore() => base.ClearCore();
-
-        public new void OnCollectionChanged(CollectionChangeEventArgs ccevent) => base.OnCollectionChanged(ccevent);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerBaseTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerBaseTests.cs
deleted file mode 100644
index ee25bf65f6b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerBaseTests.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingManagerBaseTests
-{
-    [Fact]
-    public void Bindings_Get_ReturnsExpected()
-    {
-        var manager = new PropertyManager();
-        Assert.Empty(manager.Bindings);
-        Assert.Same(manager.Bindings, manager.Bindings);
-    }
-
-    [Fact]
-    public void Bindings_Add_Success()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(manager, binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void Bindings_AddNull_ThrowsArgumentNullException()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.Add(null));
-    }
-
-    [Fact]
-    public void Bindings_AddAlreadyInSameManager_ThrowsArgumentException()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Throws<ArgumentException>("dataBinding", () => collection.Add(binding));
-    }
-
-    [Fact]
-    public void Bindings_AddAlreadyInDifferentManager_ThrowsArgumentException()
-    {
-        var manager1 = new PropertyManager();
-        var manager2 = new PropertyManager();
-        BindingsCollection collection1 = manager1.Bindings;
-        BindingsCollection collection2 = manager2.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection1.Add(binding);
-        Assert.Throws<ArgumentException>("dataBinding", () => collection2.Add(binding));
-    }
-
-    [Fact]
-    public void Bindings_Clear_Success()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(manager, binding.BindingManagerBase);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(binding.BindingManagerBase);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void Bindings_Remove_Success()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(manager, binding.BindingManagerBase);
-
-        collection.Remove(binding);
-        Assert.Empty(collection);
-        Assert.Null(binding.BindingManagerBase);
-    }
-
-    [Fact]
-    public void Bindings_RemoveNullDataBinding_ThrowsArgumentNullException()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.Remove(null));
-        Assert.Same(binding, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void Bindings_RemoveNoSuchDataBinding_ThrowsArgumentException()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection.Add(binding1);
-
-        Assert.Throws<ArgumentException>("dataBinding", () => collection.Remove(binding2));
-        Assert.Same(binding1, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void Bindings_RemoveDataBindingFromOtherCollection_ThrowsArgumentException()
-    {
-        var manager1 = new PropertyManager();
-        var manager2 = new PropertyManager();
-        BindingsCollection collection1 = manager1.Bindings;
-        BindingsCollection collection2 = manager2.Bindings;
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection1.Add(binding1);
-        collection2.Add(binding2);
-
-        Assert.Throws<ArgumentException>("dataBinding", () => collection2.Remove(binding1));
-        Assert.Same(binding1, Assert.Single(collection1));
-        Assert.Same(binding2, Assert.Single(collection2));
-    }
-
-    [Fact]
-    public void Bindings_RemoveAt_Success()
-    {
-        var manager = new PropertyManager();
-        BindingsCollection collection = manager.Bindings;
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(manager, binding.BindingManagerBase);
-
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(binding.BindingManagerBase);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerDataErrorEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerDataErrorEventArgsTests.cs
deleted file mode 100644
index b16b07779e0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingManagerDataErrorEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingManagerDataErrorEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Exception_TestData()
-    {
-        yield return new object[] { new Exception() };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Exception_TestData))]
-    public void Ctor_Exception(Exception exception)
-    {
-        var e = new BindingManagerDataErrorEventArgs(exception);
-        Assert.Equal(exception, e.Exception);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingMemberInfoTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingMemberInfoTests.cs
deleted file mode 100644
index 4f69e25883e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingMemberInfoTests.cs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingMemberInfoTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var info = new BindingMemberInfo();
-        Assert.Empty(info.BindingPath);
-        Assert.Empty(info.BindingField);
-        Assert.Empty(info.BindingMember);
-    }
-
-    [Theory]
-    [InlineData(null, "", "", "")]
-    [InlineData("", "", "", "")]
-    [InlineData("Some", "", "Some", "Some")]
-    [InlineData("Some.More.Other", "Some.More", "Other", "Some.More.Other")]
-    [InlineData("Some.Other", "Some", "Other", "Some.Other")]
-    [InlineData("Some.", "Some", "", "Some.")]
-    [InlineData(".Other", "", "Other", "Other")]
-    [InlineData(".", "", "", "")]
-    public void Ctor_String(string dataMember, string expectedPath, string expectedField, string expectedMember)
-    {
-        var info = new BindingMemberInfo(dataMember);
-        Assert.Equal(expectedPath, info.BindingPath);
-        Assert.Equal(expectedField, info.BindingField);
-        Assert.Equal(expectedMember, info.BindingMember);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo("Some.Other"), true };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo("some.other"), true };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo("Some2.Other"), false };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo("Some.Other2"), false };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo("Some"), false };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo(), false };
-
-        yield return new object[] { new BindingMemberInfo("Some"), new BindingMemberInfo("Some"), true };
-        yield return new object[] { new BindingMemberInfo("Some"), new BindingMemberInfo("Some2"), false };
-        yield return new object[] { new BindingMemberInfo("Some"), new BindingMemberInfo("Some.Other"), false };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new BindingMemberInfo(), false };
-
-        yield return new object[] { new BindingMemberInfo(), new BindingMemberInfo(), true };
-        yield return new object[] { new BindingMemberInfo(), new BindingMemberInfo(""), true };
-        yield return new object[] { new BindingMemberInfo(), new BindingMemberInfo("Some.Other"), false };
-
-        yield return new object[] { new BindingMemberInfo("Some.Other"), new object(), false };
-        yield return new object[] { new BindingMemberInfo("Some.Other"), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Equals_Invoke_ReturnsExpected(BindingMemberInfo info, object other, bool expected)
-    {
-        if (other is BindingMemberInfo otherInfo)
-        {
-            Assert.Equal(expected, info == otherInfo);
-            Assert.Equal(!expected, info != otherInfo);
-        }
-
-        Assert.Equal(expected, info.Equals(other));
-    }
-
-    public static IEnumerable<object[]> GetHashCode_TestData()
-    {
-        yield return new object[] { new BindingMemberInfo() };
-        yield return new object[] { new BindingMemberInfo("Some") };
-        yield return new object[] { new BindingMemberInfo("Some.Other") };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetHashCode_TestData))]
-    public void GetHashCode_Invoke_ReturnsExpected(BindingMemberInfo info)
-    {
-        Assert.Equal(info.GetHashCode(), info.GetHashCode());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingSourceTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingSourceTests.cs
deleted file mode 100644
index 73a801e89e5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingSourceTests.cs
+++ /dev/null
@@ -1,914 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class BindingSourceTests
-{
-    [WinFormsFact]
-    public void Ctor_Default()
-    {
-        using var source = new SubBindingSource();
-        Assert.True(source.AllowEdit);
-        Assert.True(source.AllowNew);
-        Assert.True(source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Empty(source);
-        Assert.Equal(0, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);
-        Assert.True(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(-1, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Null(source.Current);
-        Assert.Empty(source.DataMember);
-        Assert.Null(source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.True(source.IsBindingSuspended);
-        Assert.False(source.IsFixedSize);
-        Assert.False(source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.False(source.IsSynchronized);
-        Assert.Empty(source.List);
-        Assert.IsType<BindingList<object>>(source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    public static IEnumerable<object[]> Ctor_Object_String_Null_TestData()
-    {
-        yield return new object[] { null, null, typeof(BindingList<object>) };
-        yield return new object[] { null, string.Empty, typeof(BindingList<object>) };
-        yield return new object[] { null, "dataMember", typeof(BindingList<object>) };
-        yield return new object[] { new DataClass { List = null }, nameof(DataClass.List), typeof(BindingList<int>) };
-        yield return new object[] { new DataClass { List = null }, nameof(DataClass.List), typeof(BindingList<int>) };
-
-        yield return new object[] { new ObjectDataClass { List = null }, nameof(ObjectDataClass.List), typeof(BindingList<object>) };
-        yield return new object[] { new ObjectDataClass { List = null }, nameof(ObjectDataClass.List).ToLower(), typeof(BindingList<object>) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Object_String_Null_TestData))]
-    public void Ctor_Object_String_Null(object dataSource, string dataMember, Type expectedType)
-    {
-        using var source = new SubBindingSource(dataSource, dataMember);
-        Assert.True(source.AllowEdit);
-        Assert.True(source.AllowNew);
-        Assert.True(source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Empty(source);
-        Assert.Equal(0, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);
-        Assert.True(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(-1, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Null(source.Current);
-        Assert.Same(dataMember, source.DataMember);
-        Assert.Same(dataSource, source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.True(source.IsBindingSuspended);
-        Assert.False(source.IsFixedSize);
-        Assert.False(source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.False(source.IsSynchronized);
-        Assert.Empty(source.List);
-        Assert.IsType(expectedType, source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    public static IEnumerable<object[]> Ctor_Object_String_Empty_TestData()
-    {
-        foreach (string dataMember in new string[] { null, string.Empty })
-        {
-            var emptyList = new List<int> { };
-            yield return new object[] { emptyList, dataMember, true, false, emptyList };
-
-            var emptyArray = Array.Empty<int>();
-            yield return new object[] { emptyArray, dataMember, false, true, emptyArray };
-
-            var mockEmptyListSource = new Mock<IListSource>(MockBehavior.Strict);
-            mockEmptyListSource
-                .Setup(s => s.GetList())
-                .Returns(emptyList);
-            yield return new object[] { mockEmptyListSource.Object, dataMember, true, false, emptyList };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Object_String_Empty_TestData))]
-    public void Ctor_Object_String_Empty(object dataSource, string dataMember, bool expectedAllowRemove, bool expectedIsFixedSize, IList expected)
-    {
-        using var source = new SubBindingSource(dataSource, dataMember);
-        Assert.True(source.AllowEdit);
-        Assert.False(source.AllowNew);
-        Assert.Equal(expectedAllowRemove, source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Equal(expected, source);
-        Assert.Equal(expected.Count, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);
-        Assert.True(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(-1, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Null(source.Current);
-        Assert.Same(dataMember, source.DataMember);
-        Assert.Same(dataSource, source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.True(source.IsBindingSuspended);
-        Assert.Equal(expectedIsFixedSize, source.IsFixedSize);
-        Assert.False(source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.False(source.IsSynchronized);
-        Assert.Same(expected, source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    public static IEnumerable<object[]> Ctor_Object_String_TestData()
-    {
-        foreach (string dataMember in new string[] { null, string.Empty })
-        {
-            var nonEmptyList = new List<int> { 1, 2, 3 };
-            yield return new object[] { nonEmptyList, dataMember, true, false, true, false, false, false, nonEmptyList };
-
-            var fixedSizeList = new FixedSizeList<int> { 1, 2, 3 };
-            yield return new object[] { fixedSizeList, dataMember, true, false, false, true, false, false, fixedSizeList };
-
-            var readOnlyList = new ReadOnlyList<int> { 1, 2, 3 };
-            yield return new object[] { readOnlyList, dataMember, false, false, false, false, true, false, readOnlyList };
-
-            var synchronizedList = new SynchronizedList<int> { 1, 2, 3 };
-            yield return new object[] { synchronizedList, dataMember, true, false, true, false, false, true, synchronizedList };
-
-            var nonEmptyArray = new int[] { 1, 2, 3 };
-            yield return new object[] { nonEmptyArray, dataMember, true, false, false, true, false, false, nonEmptyArray };
-
-            var mockNonEmptyListSource = new Mock<IListSource>(MockBehavior.Strict);
-            mockNonEmptyListSource
-                .Setup(s => s.GetList())
-                .Returns(nonEmptyList);
-            yield return new object[] { mockNonEmptyListSource.Object, dataMember, true, false, true, false, false, false, nonEmptyList };
-        }
-
-        var list = new List<int> { 1, 2, 3 };
-        var listDataClass = new DataClass { List = list };
-        yield return new object[] { listDataClass, nameof(DataClass.List), true, false, true, false, false, false, list };
-        yield return new object[] { listDataClass, nameof(DataClass.List).ToLower(), true, false, true, false, false, false, list };
-
-        var mockListSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockListSource
-            .Setup(s => s.GetList())
-            .Returns(list);
-        var listSourceDataClass = new ListSourceDataClass { ListSource = mockListSource.Object };
-        yield return new object[] { listSourceDataClass, nameof(ListSourceDataClass.ListSource), true, false, true, false, false, false, list };
-        yield return new object[] { listSourceDataClass, nameof(ListSourceDataClass.ListSource).ToLower(), true, false, true, false, false, false, list };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Object_String_TestData))]
-    public void Ctor_Object_String(object dataSource, string dataMember, bool expectedAllowEdit, bool expectedAllowNew, bool expectedAllowRemove, bool expectedIsFixedSize, bool expectedReadOnly, bool expectedIsSynchronized, IList expected)
-    {
-        using var source = new SubBindingSource(dataSource, dataMember);
-        Assert.Equal(expectedAllowEdit, source.AllowEdit);
-        Assert.Equal(expectedAllowNew, source.AllowNew);
-        Assert.Equal(expectedAllowRemove, source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Equal(expected, source);
-        Assert.Equal(expected.Count, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Equal(expected[0], source.CurrencyManager.Current);
-        Assert.False(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(0, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Equal(expected[0], source.Current);
-        Assert.Same(dataMember, source.DataMember);
-        Assert.Same(dataSource, source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.False(source.IsBindingSuspended);
-        Assert.Equal(expectedIsFixedSize, source.IsFixedSize);
-        Assert.Equal(expectedReadOnly, source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.Equal(expectedIsSynchronized, source.IsSynchronized);
-        Assert.Same(expected, source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    public static IEnumerable<object[]> Ctor_Object_String_BindingList_TestData()
-    {
-        foreach (string dataMember in new string[] { null, string.Empty })
-        {
-            var emptyList = new List<int> { };
-
-            var nonEmptyList = new List<int> { 1, 2, 3 };
-            var emptyEnumerable = new EnumerableWrapper<int>(emptyList);
-            yield return new object[] { emptyEnumerable, dataMember, true, false, true, false, false, false, new List<int>[] { emptyList }, typeof(BindingList<EnumerableWrapper<int>>) };
-
-            var nonEmptyEnumerable = new EnumerableWrapper<int>(nonEmptyList);
-            yield return new object[] { nonEmptyEnumerable, dataMember, true, false, true, false, false, false, nonEmptyList, typeof(BindingList<int>) };
-        }
-
-        var o1 = new object();
-        yield return new object[] { new ObjectDataClass { List = o1 }, nameof(ObjectDataClass.List), true, true, true, false, false, false, new BindingList<object> { o1 }, typeof(BindingList<object>) };
-
-        var o2 = new object();
-        yield return new object[] { new ObjectDataClass { List = o2 }, nameof(ObjectDataClass.List).ToLower(), true, true, true, false, false, false, new BindingList<object> { o2 }, typeof(BindingList<object>) };
-
-        yield return new object[] { new ObjectDataClass { List = 1 }, nameof(ObjectDataClass.List), true, true, true, false, false, false, new BindingList<int> { 1 }, typeof(BindingList<int>) };
-        yield return new object[] { new ObjectDataClass { List = 1 }, nameof(ObjectDataClass.List).ToLower(), true, true, true, false, false, false, new BindingList<int> { 1 }, typeof(BindingList<int>) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Object_String_BindingList_TestData))]
-    public void Ctor_Object_String_BindingList(object dataSource, string dataMember, bool expectedAllowEdit, bool expectedAllowNew, bool expectedAllowRemove, bool expectedIsFixedSize, bool expectedReadOnly, bool expectedIsSynchronized, IList expected, Type expectedType)
-    {
-        using var source = new SubBindingSource(dataSource, dataMember);
-        Assert.Equal(expectedAllowEdit, source.AllowEdit);
-        Assert.Equal(expectedAllowNew, source.AllowNew);
-        Assert.Equal(expectedAllowRemove, source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Equal(expected, source);
-        Assert.Equal(expected.Count, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Equal(expected[0], source.CurrencyManager.Current);
-        Assert.False(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(0, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Equal(expected[0], source.Current);
-        Assert.Same(dataMember, source.DataMember);
-        Assert.Same(dataSource, source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.False(source.IsBindingSuspended);
-        Assert.Equal(expectedIsFixedSize, source.IsFixedSize);
-        Assert.Equal(expectedReadOnly, source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.Equal(expectedIsSynchronized, source.IsSynchronized);
-        Assert.Equal(expected, source.List);
-        Assert.NotSame(expected, source.List);
-        Assert.IsType(expectedType, source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void Ctor_Object_String_IBindingList(string dataMember)
-    {
-        PropertyDescriptor sortProperty = TypeDescriptor.GetProperties(typeof(DataClass))[0];
-        var syncRoot = new object();
-        var mockList = new Mock<IBindingList>(MockBehavior.Strict);
-        mockList
-            .Setup(p => p.Count)
-            .Returns(0);
-        mockList
-            .Setup(p => p.AllowEdit)
-            .Returns(false);
-        mockList
-            .Setup(p => p.AllowNew)
-            .Returns(false);
-        mockList
-            .Setup(p => p.AllowRemove)
-            .Returns(false);
-        mockList
-            .Setup(p => p.GetEnumerator())
-            .Returns(new List<int>().GetEnumerator());
-        mockList
-            .Setup(p => p.IsFixedSize)
-            .Returns(false);
-        mockList
-            .Setup(p => p.IsReadOnly)
-            .Returns(false);
-        mockList
-            .Setup(p => p.IsSynchronized)
-            .Returns(false);
-        mockList
-            .Setup(p => p.IsSorted)
-            .Returns(true);
-        mockList
-            .Setup(p => p.SortDirection)
-            .Returns(ListSortDirection.Descending);
-        mockList
-            .Setup(p => p.SortProperty)
-            .Returns(sortProperty);
-        mockList
-            .Setup(p => p.SupportsChangeNotification)
-            .Returns(false);
-        mockList
-            .Setup(p => p.SupportsSearching)
-            .Returns(true);
-        mockList
-            .Setup(p => p.SupportsSorting)
-            .Returns(true);
-        mockList
-            .Setup(p => p.SyncRoot)
-            .Returns(syncRoot);
-
-        var sortDescriptions = new ListSortDescriptionCollection();
-        var mockListView = mockList.As<IBindingListView>();
-        mockListView
-            .Setup(p => p.SortDescriptions)
-            .Returns(sortDescriptions);
-        mockListView
-            .Setup(p => p.SupportsAdvancedSorting)
-            .Returns(true);
-        mockListView
-            .Setup(p => p.SupportsFiltering)
-            .Returns(true);
-
-        using var source = new SubBindingSource(mockList.Object, dataMember);
-        Assert.False(source.AllowEdit);
-        Assert.False(source.AllowNew);
-        Assert.False(source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Null(source.Container);
-        Assert.Empty(source);
-        Assert.Equal(0, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);
-        Assert.True(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(-1, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Null(source.Current);
-        Assert.Same(dataMember, source.DataMember);
-        Assert.Same(mockList.Object, source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.True(source.IsBindingSuspended);
-        Assert.False(source.IsFixedSize);
-        Assert.False(source.IsReadOnly);
-        Assert.True(source.IsSorted);
-        Assert.False(source.IsSynchronized);
-        Assert.Same(mockList.Object, source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.Null(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Same(sortDescriptions, source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Descending, source.SortDirection);
-        Assert.Same(sortProperty, source.SortProperty);
-        Assert.True(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.True(source.SupportsFiltering);
-        Assert.True(source.SupportsSearching);
-        Assert.True(source.SupportsSorting);
-        Assert.Same(syncRoot, source.SyncRoot);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void Ctor_Object_String_ICurrencyManagerProvider(string dataMember)
-    {
-        var mockCurrencyManagerProvider = new Mock<ICurrencyManagerProvider>(MockBehavior.Strict);
-        mockCurrencyManagerProvider
-            .Setup(p => p.CurrencyManager)
-            .Returns<CurrencyManager>(null)
-            .Verifiable();
-        using var source = new BindingSource(mockCurrencyManagerProvider.Object, dataMember);
-        mockCurrencyManagerProvider.Verify(p => p.CurrencyManager, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(PrivateDefaultConstructor))]
-    [InlineData(typeof(NoDefaultConstructor))]
-    [InlineData(typeof(ThrowingDefaultConstructor))]
-    public void Ctor_InvalidDataSourceType_ThrowsNotSupportedException(Type dataSource)
-    {
-        Assert.Throws<NotSupportedException>(() => new BindingSource(dataSource, "dataMember"));
-    }
-
-    [WinFormsFact]
-    public void Ctor_NoSuchDataMember_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => new BindingSource(new DataClass(), "NoSuchProperty"));
-    }
-
-    [WinFormsFact]
-    public void Ctor_IContainer()
-    {
-        using var container = new Container();
-        using var source = new SubBindingSource(container);
-        Assert.True(source.AllowEdit);
-        Assert.True(source.AllowNew);
-        Assert.True(source.AllowRemove);
-        Assert.True(source.CanRaiseEvents);
-        Assert.Same(container, source.Container);
-        Assert.Empty(source);
-        Assert.Equal(0, source.CurrencyManager.Count);
-        Assert.Empty(source.CurrencyManager.Bindings);
-        Assert.Same(source.CurrencyManager.Bindings, source.CurrencyManager.Bindings);
-        Assert.Throws<IndexOutOfRangeException>(() => source.CurrencyManager.Current);
-        Assert.True(source.CurrencyManager.IsBindingSuspended);
-        Assert.Same(source, source.CurrencyManager.List);
-        Assert.Equal(-1, source.CurrencyManager.Position);
-        Assert.Same(source.CurrencyManager, source.CurrencyManager);
-        Assert.Null(source.Current);
-        Assert.Empty(source.DataMember);
-        Assert.Null(source.DataSource);
-        Assert.False(source.DesignMode);
-        Assert.NotNull(source.Events);
-        Assert.Same(source.Events, source.Events);
-        Assert.Null(source.Filter);
-        Assert.True(source.IsBindingSuspended);
-        Assert.False(source.IsFixedSize);
-        Assert.False(source.IsReadOnly);
-        Assert.False(source.IsSorted);
-        Assert.False(source.IsSynchronized);
-        Assert.Empty(source.List);
-        Assert.IsType<BindingList<object>>(source.List);
-        Assert.True(source.RaiseListChangedEvents);
-        Assert.NotNull(source.Site);
-        Assert.Null(source.Sort);
-        Assert.Null(source.SortDescriptions);
-        Assert.Equal(ListSortDirection.Ascending, source.SortDirection);
-        Assert.Null(source.SortProperty);
-        Assert.False(source.SupportsAdvancedSorting);
-        Assert.True(source.SupportsChangeNotification);
-        Assert.False(source.SupportsFiltering);
-        Assert.False(source.SupportsSearching);
-        Assert.False(source.SupportsSorting);
-        Assert.Same(source.List.SyncRoot, source.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new SubBindingSource(null));
-    }
-
-    [WinFormsFact]
-    public void ISupportInitializeNotification_GetProperties_ReturnsExpected()
-    {
-        using var bindingSource = new BindingSource();
-        ISupportInitializeNotification source = bindingSource;
-        Assert.True(source.IsInitialized);
-    }
-
-    [WinFormsFact]
-    public void BeginInitEndInit_Invoke_Success()
-    {
-        using var bindingSource = new BindingSource();
-        ISupportInitializeNotification source = bindingSource;
-        source.BeginInit();
-        Assert.False(source.IsInitialized);
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-    }
-
-    [WinFormsFact]
-    public void BeginInitEndInit_WithInitializedEvent_CallsEvent()
-    {
-        using var bindingSource = new BindingSource();
-        ISupportInitializeNotification source = bindingSource;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(source, sender);
-            Assert.Equal(EventArgs.Empty, e);
-        };
-        source.Initialized += handler;
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        source.Initialized -= handler;
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void BeginInitEndInit_WithDataSource_CallsEvent()
-    {
-        using var bindingSource = new BindingSource(new DataSource(), nameof(DataSource.Member));
-        ISupportInitializeNotification source = bindingSource;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(source, sender);
-            Assert.Equal(EventArgs.Empty, e);
-        };
-        source.Initialized += handler;
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void BeginInitEndInit_WithISupportInitializeNotificationDataSource_WaitsForDataSourceInitialize()
-    {
-        var dataSource = new ISupportInitializeNotificationDataSource { IsInitializedResult = false };
-        using var bindingSource = new BindingSource(dataSource, nameof(ISupportInitializeNotificationDataSource.Member));
-        ISupportInitializeNotification source = bindingSource;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(source, sender);
-            Assert.Equal(EventArgs.Empty, e);
-        };
-        source.Initialized += handler;
-
-        source.BeginInit();
-        Assert.False(source.IsInitialized);
-        Assert.Equal(0, callCount);
-
-        // Call the source init - should not initialize and should instead wait for
-        // the data source initialization.
-        source.EndInit();
-        Assert.False(source.IsInitialized);
-        Assert.Equal(0, callCount);
-
-        // Then, call the data source init.
-        dataSource.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void BeginInitEndInit_WithISupportInitializeNotificationDataSourceInitialized_DoesNotWaitForDataSourceInitialize()
-    {
-        var dataSource = new ISupportInitializeNotificationDataSource { IsInitializedResult = true };
-        using var bindingSource = new BindingSource(dataSource, nameof(ISupportInitializeNotificationDataSource.Member));
-        ISupportInitializeNotification source = bindingSource;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(source, sender);
-            Assert.Equal(EventArgs.Empty, e);
-        };
-        source.Initialized += handler;
-
-        source.BeginInit();
-        Assert.False(source.IsInitialized);
-        Assert.Equal(0, callCount);
-
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> BeginInitEndInit_SetDataSourceInInit_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataSource() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BeginInitEndInit_SetDataSourceInInit_TestData))]
-    public void BeginInitEndInit_SetDataSourceInInit_Success(object newDataSource)
-    {
-        var dataSource = new ISupportInitializeNotificationDataSource { IsInitializedResult = false };
-        using var bindingSource = new BindingSource(dataSource, nameof(ISupportInitializeNotificationDataSource.Member));
-        ISupportInitializeNotification source = bindingSource;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(source, sender);
-            Assert.Equal(EventArgs.Empty, e);
-        };
-        source.Initialized += handler;
-        dataSource.Initialized += (sender, e) =>
-        {
-            ((BindingSource)source).DataSource = newDataSource;
-        };
-
-        source.BeginInit();
-        Assert.False(source.IsInitialized);
-        Assert.Equal(0, callCount);
-
-        // Call the source init - should not initialize and should instead wait for
-        // the data source initialization.
-        source.EndInit();
-        Assert.False(source.IsInitialized);
-        Assert.Equal(0, callCount);
-
-        // Then, call the data source init.
-        dataSource.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        source.EndInit();
-        Assert.True(source.IsInitialized);
-        Assert.Equal(2, callCount);
-    }
-
-    private class FixedSizeList<T> : VirtualList<T>
-    {
-        public override bool IsFixedSize => true;
-    }
-
-    private class ReadOnlyList<T> : VirtualList<T>
-    {
-        public override bool IsReadOnly => true;
-    }
-
-    private class SynchronizedList<T> : VirtualList<T>
-    {
-        public override bool IsSynchronized => true;
-    }
-
-    private class VirtualList<T> : IList
-    {
-        private readonly List<T> _innerList = new();
-
-        public VirtualList()
-        {
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => _innerList.GetEnumerator();
-
-        public int Count => _innerList.Count;
-
-        public object SyncRoot => ((IList)_innerList).SyncRoot;
-
-        public virtual bool IsSynchronized => ((IList)_innerList).IsSynchronized;
-
-        public virtual bool IsReadOnly => ((IList)_innerList).IsReadOnly;
-
-        public virtual bool IsFixedSize => ((IList)_innerList).IsFixedSize;
-
-        public void Add(T item) => _innerList.Add(item);
-
-        public int Add(object item) => ((IList)_innerList).Add(item);
-
-        public void Clear() => _innerList.Clear();
-
-        public bool Contains(T item) => _innerList.Contains(item);
-
-        public bool Contains(object item) => ((IList)_innerList).Contains(item);
-
-        public void CopyTo(T[] array, int arrayIndex) => _innerList.CopyTo(array, arrayIndex);
-
-        public void CopyTo(Array array, int arrayIndex) => ((IList)_innerList).CopyTo(array, arrayIndex);
-
-        public bool Remove(T item) => _innerList.Remove(item);
-
-        public void Remove(object item) => ((IList)_innerList).Remove(item);
-
-        public T this[int index]
-        {
-            get => _innerList[index];
-            set => _innerList[index] = value;
-        }
-
-        object IList.this[int index]
-        {
-            get => ((IList)_innerList)[index];
-            set => ((IList)_innerList)[index] = value;
-        }
-
-        public int IndexOf(T item) => _innerList.IndexOf(item);
-
-        public int IndexOf(object item) => ((IList)_innerList).IndexOf(item);
-
-        public void Insert(int index, T item) => _innerList.Insert(index, item);
-
-        public void Insert(int index, object item) => ((IList)_innerList).Insert(index, item);
-
-        public void RemoveAt(int index) => _innerList.RemoveAt(index);
-    }
-
-    private class EnumerableWrapper<T> : IEnumerable<T>
-    {
-        private readonly IEnumerable<T> _innerEnumerable;
-
-        public EnumerableWrapper(IEnumerable<T> innerEnumerable)
-        {
-            _innerEnumerable = innerEnumerable;
-        }
-
-        public IEnumerator<T> GetEnumerator() => _innerEnumerable.GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() => _innerEnumerable.GetEnumerator();
-    }
-
-    private class DataClass
-    {
-        public IList<int> List { get; set; }
-    }
-
-    private class EnumerableDataClass
-    {
-        public IEnumerable Enumerable { get; set; }
-    }
-
-    private class ListSourceDataClass
-    {
-        public IListSource ListSource { get; set; }
-    }
-
-    private class ObjectDataClass
-    {
-        public object List { get; set; }
-    }
-
-    private class SubBindingSource : BindingSource
-    {
-        public SubBindingSource() : base()
-        {
-        }
-
-        public SubBindingSource(object dataSource, string dataMember) : base(dataSource, dataMember)
-        {
-        }
-
-        public SubBindingSource(IContainer container) : base(container)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-    }
-
-    private class PrivateDefaultConstructor : List<int>, ITypedList
-    {
-        private PrivateDefaultConstructor() { }
-
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class NoDefaultConstructor : List<int>, ITypedList
-    {
-        public NoDefaultConstructor(int i) { }
-
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class ThrowingDefaultConstructor : List<int>, ITypedList
-    {
-        public ThrowingDefaultConstructor()
-        {
-            throw new DivideByZeroException();
-        }
-
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class DataSource
-    {
-        public int Member { get; set; }
-    }
-
-    private class ISupportInitializeNotificationDataSource : ISupportInitializeNotification
-    {
-        public int Member { get; set; }
-
-        public bool IsInitializedResult { get; set; }
-
-        public bool IsInitialized => IsInitializedResult;
-
-        public event EventHandler Initialized;
-
-        public void BeginInit()
-        {
-        }
-
-        public void EndInit()
-        {
-            Initialized(this, null);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingTests.cs
deleted file mode 100644
index c74e01cd5ac..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingTests.cs
+++ /dev/null
@@ -1,638 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-using System.Security;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingTests
-{
-    public static IEnumerable<object[]> Ctor_String_Object_String_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new object(), string.Empty };
-        yield return new object[] { "propertyName", new object(), "dataMember" };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_TestData))]
-    public void Binding_Ctor_String_Object_String(string propertyName, object dataSource, string dataMember)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(DataSourceUpdateMode.OnValidation, binding.DataSourceUpdateMode);
-        Assert.Null(binding.FormatInfo);
-        Assert.Empty(binding.FormatString);
-        Assert.False(binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Null(binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Object_String_Bool_TestData()
-    {
-        yield return new object[] { null, null, null, true };
-        yield return new object[] { string.Empty, new object(), string.Empty, true };
-        yield return new object[] { "propertyName", new object(), "dataMember", false };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember", false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_Bool_TestData))]
-    public void Binding_Ctor_String_Object_String_Bool(string propertyName, object dataSource, string dataMember, bool formattingEnabled)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember, formattingEnabled);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(DataSourceUpdateMode.OnValidation, binding.DataSourceUpdateMode);
-        Assert.Null(binding.FormatInfo);
-        Assert.Empty(binding.FormatString);
-        Assert.Equal(formattingEnabled, binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Null(binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Object_String_Bool_DataSourceUpdateMode_TestData()
-    {
-        yield return new object[] { null, null, null, true, DataSourceUpdateMode.OnValidation };
-        yield return new object[] { string.Empty, new object(), string.Empty, true, DataSourceUpdateMode.OnValidation - 1 };
-        yield return new object[] { "propertyName", new object(), "dataMember", false, DataSourceUpdateMode.Never };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember", false, DataSourceUpdateMode.Never + 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_Bool_DataSourceUpdateMode_TestData))]
-    public void Binding_Ctor_String_Object_String_Bool_DataSourceUpdateMode(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(dataSourceUpdateMode, binding.DataSourceUpdateMode);
-        Assert.Null(binding.FormatInfo);
-        Assert.Empty(binding.FormatString);
-        Assert.Equal(formattingEnabled, binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Null(binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_TestData()
-    {
-        yield return new object[] { null, null, null, true, DataSourceUpdateMode.OnValidation, null };
-        yield return new object[] { string.Empty, new object(), string.Empty, true, DataSourceUpdateMode.OnValidation - 1, DBNull.Value };
-        yield return new object[] { "propertyName", new object(), "dataMember", false, DataSourceUpdateMode.Never, new object() };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember", false, DataSourceUpdateMode.Never + 1, new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_TestData))]
-    public void Binding_Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, nullValue);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(dataSourceUpdateMode, binding.DataSourceUpdateMode);
-        Assert.Null(binding.FormatInfo);
-        Assert.Empty(binding.FormatString);
-        Assert.Equal(formattingEnabled, binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Same(nullValue, binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String_TestData()
-    {
-        yield return new object[] { null, null, null, true, DataSourceUpdateMode.OnValidation, null, null };
-        yield return new object[] { string.Empty, new object(), string.Empty, true, DataSourceUpdateMode.OnValidation - 1, DBNull.Value, string.Empty };
-        yield return new object[] { "propertyName", new object(), "dataMember", false, DataSourceUpdateMode.Never, new object(), "formatString" };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember", false, DataSourceUpdateMode.Never + 1, new object(), "formatString" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String_TestData))]
-    public void Binding_Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, nullValue, formatString);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(dataSourceUpdateMode, binding.DataSourceUpdateMode);
-        Assert.Null(binding.FormatInfo);
-        Assert.Same(formatString, binding.FormatString);
-        Assert.Equal(formattingEnabled, binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Same(nullValue, binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String_IFormatProvider_TestData()
-    {
-        yield return new object[] { null, null, null, true, DataSourceUpdateMode.OnValidation, null, null, null };
-        yield return new object[] { string.Empty, new object(), string.Empty, true, DataSourceUpdateMode.OnValidation - 1, DBNull.Value, string.Empty, CultureInfo.CurrentCulture };
-        yield return new object[] { "propertyName", new object(), "dataMember", false, DataSourceUpdateMode.Never, new object(), "formatString", CultureInfo.InvariantCulture };
-        yield return new object[] { "propertyName", new object(), "dataMember.subDataMember", false, DataSourceUpdateMode.Never + 1, new object(), "formatString", CultureInfo.CurrentCulture };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String_IFormatProvider_TestData))]
-    public void Binding_Ctor_String_Object_String_Bool_DataSourceUpdateMode_Object_String_IFormatProvider(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString, IFormatProvider formatInfo)
-    {
-        var binding = new Binding(propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, nullValue, formatString, formatInfo);
-        Assert.Null(binding.BindableComponent);
-        Assert.Null(binding.BindingManagerBase);
-        Assert.Equal(new BindingMemberInfo(dataMember), binding.BindingMemberInfo);
-        Assert.Null(binding.Control);
-        Assert.Equal(ControlUpdateMode.OnPropertyChanged, binding.ControlUpdateMode);
-        Assert.Same(dataSource, binding.DataSource);
-        Assert.Same(DBNull.Value, binding.DataSourceNullValue);
-        Assert.Equal(dataSourceUpdateMode, binding.DataSourceUpdateMode);
-        Assert.Equal(formatInfo, binding.FormatInfo);
-        Assert.Same(formatString, binding.FormatString);
-        Assert.Equal(formattingEnabled, binding.FormattingEnabled);
-        Assert.False(binding.IsBinding);
-        Assert.Same(nullValue, binding.NullValue);
-        Assert.Same(propertyName, binding.PropertyName);
-    }
-
-    public static IEnumerable<object[]> DataSourceNullValue_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { DBNull.Value };
-    }
-
-    [Theory]
-    [MemberData(nameof(DataSourceNullValue_Set_TestData))]
-    public void Binding_DataSourceNullValue_Set_GetReturnsExpected(object value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            DataSourceNullValue = value
-        };
-        Assert.Equal(value, binding.DataSourceNullValue);
-
-        // Set same.
-        binding.DataSourceNullValue = value;
-        Assert.Equal(value, binding.DataSourceNullValue);
-    }
-
-    [Theory]
-    [EnumData<ControlUpdateMode>]
-    [InvalidEnumData<ControlUpdateMode>]
-    public void Binding_ControlUpdateMode_Set_GetReturnsExpected(ControlUpdateMode value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            ControlUpdateMode = value
-        };
-        Assert.Equal(value, binding.ControlUpdateMode);
-
-        // Set same.
-        binding.ControlUpdateMode = value;
-        Assert.Equal(value, binding.ControlUpdateMode);
-    }
-
-    [Theory]
-    [EnumData<DataSourceUpdateMode>]
-    [InvalidEnumData<DataSourceUpdateMode>]
-    public void Binding_DataSourceUpdateMode_Set_GetReturnsExpected(DataSourceUpdateMode value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            DataSourceUpdateMode = value
-        };
-        Assert.Equal(value, binding.DataSourceUpdateMode);
-
-        // Set same.
-        binding.DataSourceUpdateMode = value;
-        Assert.Equal(value, binding.DataSourceUpdateMode);
-    }
-
-    public static IEnumerable<object[]> FormatInfo_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { CultureInfo.CurrentCulture };
-    }
-
-    [Theory]
-    [MemberData(nameof(FormatInfo_Set_TestData))]
-    public void Binding_FormatInfo_Set_GetReturnsExpected(IFormatProvider value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            FormatInfo = value
-        };
-        Assert.Same(value, binding.FormatInfo);
-
-        // Set same.
-        binding.FormatInfo = value;
-        Assert.Same(value, binding.FormatInfo);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void Binding_FormatString_Set_GetReturnsExpected(string value, string expected)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            FormatString = value
-        };
-        Assert.Equal(expected, binding.FormatString);
-
-        // Set same.
-        binding.FormatString = value;
-        Assert.Equal(expected, binding.FormatString);
-    }
-
-    [Theory]
-    [BoolData]
-    public void Binding_FormattingEnabled_Set_GetReturnsExpected(bool value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            FormattingEnabled = value
-        };
-        Assert.Equal(value, binding.FormattingEnabled);
-
-        // Set same.
-        binding.FormattingEnabled = value;
-        Assert.Equal(value, binding.FormattingEnabled);
-
-        // Set different.
-        binding.FormattingEnabled = !value;
-        Assert.Equal(!value, binding.FormattingEnabled);
-    }
-
-    public static IEnumerable<object[]> NullValue_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { DBNull.Value };
-    }
-
-    [Theory]
-    [MemberData(nameof(NullValue_Set_TestData))]
-    public void Binding_NullValue_Set_GetReturnsExpected(object value)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            NullValue = value
-        };
-        Assert.Same(value, binding.NullValue);
-
-        // Set same.
-        binding.NullValue = value;
-        Assert.Same(value, binding.NullValue);
-    }
-
-    public static IEnumerable<object[]> BindingCompleteEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new BindingCompleteEventArgs(null, BindingCompleteState.Success, BindingCompleteContext.ControlUpdate) };
-    }
-
-    [Theory]
-    [MemberData(nameof(BindingCompleteEventArgs_TestData))]
-    public void Binding_OnBindingComplete_Invoke_CallsBindingComplete(BindingCompleteEventArgs eventArgs)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember");
-
-        // No handler.
-        binding.OnBindingComplete(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        binding.BindingComplete += handler;
-        binding.OnBindingComplete(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        binding.BindingComplete -= handler;
-        binding.OnBindingComplete(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(BindingCompleteEventArgs_TestData))]
-    public void Binding_OnBindingComplete_InvokeInsideBindingComplete_DoesNotCallBindingComplete(BindingCompleteEventArgs eventArgs)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember");
-
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-
-            binding.OnBindingComplete(e);
-        };
-
-        binding.BindingComplete += handler;
-        binding.OnBindingComplete(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnBindingComplete_CriticalException_TestData()
-    {
-        yield return new object[] { null, new NullReferenceException() };
-        yield return new object[] { new BindingCompleteEventArgs(null, BindingCompleteState.Success, BindingCompleteContext.ControlUpdate), new NullReferenceException() };
-    }
-
-    [Theory]
-    [MemberData(nameof(OnBindingComplete_CriticalException_TestData))]
-    public void Binding_OnBindingComplete_ThrowsCriticalException_Rethrows(BindingCompleteEventArgs eventArgs, Exception exception)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember");
-
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-
-            throw exception;
-        };
-
-        binding.BindingComplete += handler;
-        Assert.Throws(exception.GetType(), () => binding.OnBindingComplete(eventArgs));
-        if (eventArgs is not null)
-        {
-            Assert.False(eventArgs.Cancel);
-        }
-
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnBindingComplete_NonCriticalException_TestData()
-    {
-        yield return new object[] { null, new SecurityException() };
-        yield return new object[] { new BindingCompleteEventArgs(null, BindingCompleteState.Success, BindingCompleteContext.ControlUpdate), new SecurityException() };
-    }
-
-    [Theory]
-    [MemberData(nameof(OnBindingComplete_NonCriticalException_TestData))]
-    public void Binding_OnBindingComplete_ThrowsNonCriticalException_SetsCancelToTrue(BindingCompleteEventArgs eventArgs, Exception exception)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember");
-
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-
-            throw exception;
-        };
-
-        binding.BindingComplete += handler;
-        binding.OnBindingComplete(eventArgs);
-        if (eventArgs is not null)
-        {
-            Assert.True(eventArgs.Cancel);
-        }
-
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ConvertEventArgs_TestData()
-    {
-        yield return new object[] { false, null, null };
-        yield return new object[] { false, new ConvertEventArgs(null, typeof(int)), null };
-        yield return new object[] { false, new ConvertEventArgs("1", null), "1" };
-        yield return new object[] { false, new ConvertEventArgs("1", typeof(string)), "1" };
-        yield return new object[] { false, new ConvertEventArgs("1", typeof(int)), 1 };
-        yield return new object[] { false, new ConvertEventArgs(1.1.ToString(CultureInfo.CurrentCulture), typeof(double)), 1.1 };
-        yield return new object[] { false, new ConvertEventArgs(DBNull.Value, typeof(int)), DBNull.Value };
-
-        var o = new object();
-        yield return new object[] { false, new ConvertEventArgs(o, typeof(object)), o };
-        yield return new object[] { false, new ConvertEventArgs(o, typeof(int)), o };
-
-        yield return new object[] { true, null, null };
-        yield return new object[] { true, new ConvertEventArgs("1", typeof(int)), "1" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertEventArgs_TestData))]
-    public void Binding_OnFormat_Invoke_CallsFormat(bool formattingEnabled, ConvertEventArgs eventArgs, object expectedValue)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember")
-        {
-            FormattingEnabled = formattingEnabled
-        };
-
-        // No handler.
-        object oldValue = eventArgs?.Value;
-        binding.OnFormat(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-
-        // Handler.
-        int callCount = 0;
-        ConvertEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        binding.Format += handler;
-        if (eventArgs is not null)
-        {
-            eventArgs.Value = oldValue;
-        }
-
-        binding.OnFormat(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        binding.Format -= handler;
-        if (eventArgs is not null)
-        {
-            eventArgs.Value = oldValue;
-        }
-
-        binding.OnFormat(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-        Assert.Equal(1, callCount);
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertEventArgs_TestData))]
-    public void Binding_OnParse_Invoke_CallsParse(bool formattingEnabled, ConvertEventArgs eventArgs, object expectedValue)
-    {
-        var binding = new SubBinding("propertyName", new object(), "dataMember")
-        {
-            FormattingEnabled = formattingEnabled
-        };
-
-        // No handler.
-        object oldValue = eventArgs?.Value;
-        binding.OnParse(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-
-        // Handler.
-        int callCount = 0;
-        ConvertEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(binding, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        binding.Parse += handler;
-        if (eventArgs is not null)
-        {
-            eventArgs.Value = oldValue;
-        }
-
-        binding.OnParse(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        binding.Parse -= handler;
-        if (eventArgs is not null)
-        {
-            eventArgs.Value = oldValue;
-        }
-
-        binding.OnParse(eventArgs);
-        Assert.Equal(expectedValue, eventArgs?.Value);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ReadValue_TestData()
-    {
-        foreach (ControlUpdateMode controlUpdateMode in Enum.GetValues(typeof(ControlUpdateMode)))
-        {
-            yield return new object[] { controlUpdateMode, true, 1 };
-            yield return new object[] { controlUpdateMode, false, 0 };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ReadValue_TestData))]
-    public void Binding_ReadValue_Invoke_CallsBindingCompleteIfFormattingEnabled(ControlUpdateMode controlUpdateMode, bool formattingEnabled, int expectedCallCount)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            ControlUpdateMode = controlUpdateMode,
-            FormattingEnabled = formattingEnabled
-        };
-
-        // No handler.
-        binding.ReadValue();
-
-        // Handler.
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(binding, sender);
-            Assert.Same(binding, e.Binding);
-            Assert.Equal(BindingCompleteContext.ControlUpdate, e.BindingCompleteContext);
-            Assert.Equal(BindingCompleteState.Success, e.BindingCompleteState);
-            Assert.False(e.Cancel);
-            Assert.Empty(e.ErrorText);
-            Assert.Null(e.Exception);
-            callCount++;
-        };
-
-        binding.BindingComplete += handler;
-        binding.ReadValue();
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Should not call if the handler is removed.
-        binding.BindingComplete -= handler;
-        binding.ReadValue();
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    public static IEnumerable<object[]> WriteValue_TestData()
-    {
-        foreach (ControlUpdateMode controlUpdateMode in Enum.GetValues(typeof(ControlUpdateMode)))
-        {
-            yield return new object[] { controlUpdateMode, true };
-            yield return new object[] { controlUpdateMode, false };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(WriteValue_TestData))]
-    public void Binding_WriteValue_Invoke_DoesNotCallBindingComplete(ControlUpdateMode controlUpdateMode, bool formattingEnabled)
-    {
-        var binding = new Binding("propertyName", new object(), "dataMember")
-        {
-            ControlUpdateMode = controlUpdateMode,
-            FormattingEnabled = formattingEnabled
-        };
-
-        // No handler.
-        binding.WriteValue();
-
-        // Handler.
-        int callCount = 0;
-        BindingCompleteEventHandler handler = (sender, e) => callCount++;
-
-        binding.BindingComplete += handler;
-        binding.WriteValue();
-        Assert.Equal(0, callCount);
-
-        // Should not call if the handler is removed.
-        binding.BindingComplete -= handler;
-        binding.WriteValue();
-        Assert.Equal(0, callCount);
-    }
-
-    private class SubBinding : Binding
-    {
-        public SubBinding(string propertyName, object dataSource, string dataMember) : base(propertyName, dataSource, dataMember)
-        {
-        }
-
-        public new void OnBindingComplete(BindingCompleteEventArgs e) => base.OnBindingComplete(e);
-
-        public new void OnFormat(ConvertEventArgs cevent) => base.OnFormat(cevent);
-
-        public new void OnParse(ConvertEventArgs cevent) => base.OnParse(cevent);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingsCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingsCollectionTests.cs
deleted file mode 100644
index 678fa2a38d5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/BindingsCollectionTests.cs
+++ /dev/null
@@ -1,560 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class BindingsCollectionTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var collection = new SubBindingsCollection();
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection.List);
-        Assert.False(collection.ShouldSerializeMyAll());
-    }
-
-    [Fact]
-    public void Add_Invoke_Success()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        Assert.Equal(1, collection.Count);
-        Assert.Same(binding, collection[0]);
-        Assert.True(collection.ShouldSerializeMyAll());
-    }
-
-    [Fact]
-    public void Add_InvokeWithCollectionChanging_CallsHandler()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Add, e.Action);
-            Assert.Same(binding, e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Add, e.Action);
-            Assert.Same(binding, e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.Add(binding);
-        Assert.Equal(1, changingCallCount);
-        Assert.Equal(1, changedCallCount);
-        Assert.Equal(1, collection.Count);
-
-        // Add again.
-        collection.Add(binding);
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Equal(2, collection.Count);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.Add(binding);
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Equal(3, collection.Count);
-    }
-
-    [Fact]
-    public void Add_NullDataBinding_ThrowsArgumentNullException()
-    {
-        var collection = new BindingsCollection();
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.Add(null));
-    }
-
-    [Fact]
-    public void AddCore_Invoke_Success()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.AddCore(binding);
-
-        Assert.Equal(1, collection.Count);
-        Assert.Same(binding, collection[0]);
-        Assert.True(collection.ShouldSerializeMyAll());
-    }
-
-    [Fact]
-    public void AddCore_InvokeWithCollectionChanging_DoesNotCallHandler()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Add, e.Action);
-            Assert.Same(binding, e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Add, e.Action);
-            Assert.Same(binding, e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.AddCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Equal(1, collection.Count);
-
-        // Add again.
-        collection.AddCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Equal(2, collection.Count);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.AddCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Equal(3, collection.Count);
-    }
-
-    [Fact]
-    public void AddCore_NullDataBinding_ThrowsArgumentNullException()
-    {
-        var collection = new SubBindingsCollection();
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.AddCore(null));
-    }
-
-    [Fact]
-    public void Clear_Invoke_Success()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.Clear();
-        Assert.Empty(collection);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void Clear_InvokeWithCollectionChanging_CallsHandler()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Refresh, e.Action);
-            Assert.Null(e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Refresh, e.Action);
-            Assert.Null(e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.Clear();
-        Assert.Equal(1, changingCallCount);
-        Assert.Equal(1, changedCallCount);
-        Assert.Empty(collection);
-
-        // Add again.
-        collection.Clear();
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Empty(collection);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-
-        collection.Clear();
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void ClearCore_Invoke_Success()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.ClearCore();
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void ClearCore_InvokeWithCollectionChanging_DoesNotCallHandler()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Refresh, e.Action);
-            Assert.Null(e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Refresh, e.Action);
-            Assert.Null(e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.ClearCore();
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-
-        // Add again.
-        collection.ClearCore();
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-
-        collection.ClearCore();
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void RemoveAt_Invoke_Success()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void Remove_Invoke_Success()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.Remove(binding);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void Remove_InvokeWithCollectionChanging_CallsHandler()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Remove, e.Action);
-            Assert.Same(binding, e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Remove, e.Action);
-            Assert.Same(binding, e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.Remove(binding);
-        Assert.Equal(1, changingCallCount);
-        Assert.Equal(1, changedCallCount);
-        Assert.Empty(collection);
-
-        // Add again.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.Remove(binding);
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Empty(collection);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.Add(binding);
-
-        collection.Remove(binding);
-        Assert.Equal(2, changingCallCount);
-        Assert.Equal(2, changedCallCount);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void Remove_NullDataBinding_Nop()
-    {
-        var collection = new BindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.Remove(null);
-        Assert.Same(binding, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void Remove_NoSuchDataBinding_Nop()
-    {
-        var collection = new BindingsCollection();
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection.Add(binding1);
-
-        collection.Remove(binding2);
-        Assert.Same(binding1, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void Remove_DataBindingFromOtherCollection_Nop()
-    {
-        var collection1 = new BindingsCollection();
-        var collection2 = new BindingsCollection();
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection1.Add(binding1);
-        collection2.Add(binding2);
-
-        collection2.Remove(binding1);
-        Assert.Same(binding1, Assert.Single(collection1));
-        Assert.Same(binding2, Assert.Single(collection2));
-    }
-
-    [Fact]
-    public void RemoveCore_Invoke_Success()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.RemoveCore(binding);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void RemoveCore_InvokeWithCollectionChanging_DoesNotCallHandler()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-
-        int changingCallCount = 0;
-        int changedCallCount = 0;
-        CollectionChangeEventHandler changingHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Remove, e.Action);
-            Assert.Same(binding, e.Element);
-            changingCallCount++;
-            Assert.True(changingCallCount > changedCallCount);
-        };
-        CollectionChangeEventHandler changedHandler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Equal(CollectionChangeAction.Remove, e.Action);
-            Assert.Same(binding, e.Element);
-            changedCallCount++;
-            Assert.Equal(changingCallCount, changedCallCount);
-        };
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.RemoveCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-
-        // Add again.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.Add(binding);
-        collection.CollectionChanging += changingHandler;
-        collection.CollectionChanged += changedHandler;
-
-        collection.RemoveCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-
-        // Remove handler.
-        collection.CollectionChanging -= changingHandler;
-        collection.CollectionChanged -= changedHandler;
-        collection.Add(binding);
-
-        collection.RemoveCore(binding);
-        Assert.Equal(0, changingCallCount);
-        Assert.Equal(0, changedCallCount);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void RemoveCore_NullDataBinding_Nop()
-    {
-        var collection = new SubBindingsCollection();
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        collection.RemoveCore(null);
-        Assert.Same(binding, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void RemoveCore_NoSuchDataBinding_Nop()
-    {
-        var collection = new SubBindingsCollection();
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection.Add(binding1);
-
-        collection.RemoveCore(binding2);
-        Assert.Same(binding1, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void RemoveCore_DataBindingFromOtherCollection_Nop()
-    {
-        var collection1 = new SubBindingsCollection();
-        var collection2 = new SubBindingsCollection();
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection1.Add(binding1);
-        collection2.Add(binding2);
-
-        collection2.RemoveCore(binding1);
-        Assert.Same(binding1, Assert.Single(collection1));
-        Assert.Same(binding2, Assert.Single(collection2));
-    }
-
-    [Fact]
-    public void OnCollectionChanging_Invoke_CallsHandler()
-    {
-        var collection = new SubBindingsCollection();
-        var eventArgs = new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null);
-        int callCount = 0;
-        CollectionChangeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        collection.CollectionChanging += handler;
-        collection.OnCollectionChanging(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        collection.CollectionChanging -= handler;
-        collection.OnCollectionChanging(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [Fact]
-    public void OnCollectionChanged_Invoke_CallsHandler()
-    {
-        var collection = new SubBindingsCollection();
-        var eventArgs = new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null);
-        int callCount = 0;
-        CollectionChangeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(collection, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        collection.CollectionChanged += handler;
-        collection.OnCollectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        collection.CollectionChanged -= handler;
-        collection.OnCollectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    private class SubBindingsCollection : BindingsCollection
-    {
-        public new ArrayList List => base.List;
-
-        public new void AddCore(Binding dataBinding) => base.AddCore(dataBinding);
-
-        public new void ClearCore() => base.ClearCore();
-
-        public new void RemoveCore(Binding dataBinding) => base.RemoveCore(dataBinding);
-
-        public new void OnCollectionChanging(CollectionChangeEventArgs e) => base.OnCollectionChanging(e);
-
-        public new void OnCollectionChanged(CollectionChangeEventArgs e) => base.OnCollectionChanged(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Button.ButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Button.ButtonAccessibleObjectTests.cs
deleted file mode 100644
index bc7f1ed46f8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Button.ButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-using ButtonAccessibleObject = System.Windows.Forms.Button.ButtonAccessibleObject;
-
-namespace System.Windows.Forms.Tests;
-
-public class Button_ButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ButtonAccessibleObject_Ctor_NullControl_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => new ButtonAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ButtonAccessibleObject_Ctor_InitializesOwner()
-    {
-        using var button = new Button();
-        Assert.False(button.IsHandleCreated);
-        var buttonAccessibleObject = new ButtonAccessibleObject(button);
-
-        Assert.Same(button, buttonAccessibleObject.Owner);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.PushButton)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ButtonAccessibleObject_AccessibleRole_Default_ReturnsExpected(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var button = new Button
-        {
-            AccessibleRole = AccessibleRole.Default
-        };
-
-        if (createControl)
-        {
-            button.CreateControl();
-        }
-
-        var buttonAccessibleObject = new ButtonAccessibleObject(button);
-
-        Assert.Equal(accessibleRole, buttonAccessibleObject.Role);
-        Assert.Equal(createControl, button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonAccessibleObject_AccessibleRole_Custom_ReturnsExpected()
-    {
-        using var button = new Button
-        {
-            AccessibleRole = AccessibleRole.Link
-        };
-
-        Assert.False(button.IsHandleCreated);
-        var buttonAccessibleObject = new ButtonAccessibleObject(button);
-
-        Assert.Equal(AccessibleRole.Link, buttonAccessibleObject.Role);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.LegacyIAccessibleNamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.ButtonControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "Button1")]
-    public void ButtonAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var button = new Button
-        {
-            Name = "Button1",
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(button.IsHandleCreated);
-        var buttonAccessibleObject = new ButtonAccessibleObject(button);
-        object value = buttonAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonAccessibleObject_IsPatternSupported_Invoke_ReturnsTrue_ForLegacyIAccessiblePatternId()
-    {
-        using var button = new Button();
-
-        Assert.False(button.IsHandleCreated);
-        var buttonAccessibleObject = new ButtonAccessibleObject(button);
-
-        Assert.True(buttonAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(button.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using Button button = new Button();
-        button.AccessibleRole = role;
-
-        object actual = button.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(button.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBase.ButtonBaseAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBase.ButtonBaseAccessibleObjectTests.cs
deleted file mode 100644
index 4202f1c5c41..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBase.ButtonBaseAccessibleObjectTests.cs
+++ /dev/null
@@ -1,310 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ButtonBase_ButtonBaseAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ButtonBaseAccessibleObject_Ctor_NullControl_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => new ButtonBase.ButtonBaseAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ButtonBaseAccessibleObject_Ctor_InvalidTypeControl_ThrowsArgumentException()
-    {
-        using var textBox = new TextBox();
-        Assert.Throws<ArgumentException>(() => new ButtonBase.ButtonBaseAccessibleObject(textBox));
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, true, AccessibleStates.Focusable | AccessibleStates.Pressed)]
-    [InlineData(FlatStyle.Flat, false, true, AccessibleStates.None)]
-    [InlineData(FlatStyle.Flat, true, false, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Flat, false, false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Popup, true, true, AccessibleStates.Focusable | AccessibleStates.Pressed)]
-    [InlineData(FlatStyle.Popup, false, true, AccessibleStates.None)]
-    [InlineData(FlatStyle.Popup, true, false, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Popup, false, false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Standard, true, true, AccessibleStates.Focusable | AccessibleStates.Pressed)]
-    [InlineData(FlatStyle.Standard, false, true, AccessibleStates.None)]
-    [InlineData(FlatStyle.Standard, true, false, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Standard, false, false, AccessibleStates.None)]
-    [InlineData(FlatStyle.System, true, true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.System, false, true, AccessibleStates.None)]
-    [InlineData(FlatStyle.System, true, false, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.System, false, false, AccessibleStates.None)]
-    public void ButtonBaseAccessibleObject_State_is_correct(FlatStyle flatStyle, bool createControl, bool mouseIsDown, AccessibleStates expectedAccessibleState)
-    {
-        using var button = new SubButtonBase()
-        {
-            FlatStyle = flatStyle
-        };
-
-        if (createControl)
-        {
-            button.CreateControl();
-        }
-
-        Assert.Equal(createControl, button.IsHandleCreated);
-
-        if (mouseIsDown)
-        {
-            button.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        }
-
-        var buttonBaseAccessibleObject = new ButtonBase.ButtonBaseAccessibleObject(button);
-
-        Assert.Equal(expectedAccessibleState, buttonBaseAccessibleObject.State);
-        Assert.Equal(createControl, button.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, AccessibleRole.Client)]
-    [InlineData(true, false, AccessibleRole.HelpBalloon)]
-    [InlineData(false, true, AccessibleRole.None)]
-    [InlineData(false, false, AccessibleRole.HelpBalloon)]
-    public void ButtonBase_CreateAccessibilityInstance_InvokeWithRole_ReturnsExpected(bool createControl, bool defaultRole, AccessibleRole expectedAccessibleRole)
-    {
-        using var control = new SubButtonBase();
-
-        if (!defaultRole)
-        {
-            control.AccessibleRole = AccessibleRole.HelpBalloon;
-        }
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-
-        ButtonBase.ButtonBaseAccessibleObject instance = Assert.IsType<ButtonBase.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedAccessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_CreateAccessibilityInstance_InvokeWithDefaultRole_ReturnsExpected_ForAllFlatStyles_IfControlIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase()
-        {
-            FlatStyle = flatStyle
-        };
-        control.CreateControl();
-        ButtonBase.ButtonBaseAccessibleObject instance = Assert.IsType<ButtonBase.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.Client, instance.Role);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_CreateAccessibilityInstance_InvokeWithDefaultRole_ReturnsNone_ForAllFlatStyles_IfControlIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase()
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.False(control.IsHandleCreated);
-
-        ButtonBase.ButtonBaseAccessibleObject instance = Assert.IsType<ButtonBase.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.None, instance.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ButtonBase_CreateAccessibilityInstance_InvokeDoDefaultAction_CallsOnClick(bool createControl)
-    {
-        using var control = new SubButtonBase();
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        var buttonBaseAccessibleObject = new ButtonBase.ButtonBaseAccessibleObject(control);
-        buttonBaseAccessibleObject.DoDefaultAction();
-
-        Assert.Equal(createControl ? 1 : 0, callCount);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ButtonBase_CreateAccessibilityInstance_InvokeIButtonControlDoDefaultAction_CallsOnClick(bool createControl, int expectedCallCount)
-    {
-        using var control = new SubButtonBase();
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        int performClickCallCount = 0;
-        control.PerformClickAction = () => performClickCallCount++;
-        var buttonBaseAccessibleObject = new ButtonBase.ButtonBaseAccessibleObject(control);
-
-        buttonBaseAccessibleObject.DoDefaultAction();
-
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.Equal(0, performClickCallCount);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ButtonBaseBoxAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using ButtonBase buttonBase = new SubButtonBase();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            buttonBase.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = buttonBase.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.Equal(createControl, buttonBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ButtonBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ButtonBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ButtonBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ButtonBase buttonBase = new SubButtonBase();
-        buttonBase.AccessibleRole = role;
-
-        object actual = buttonBase.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(buttonBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBaseAccessibleObject_GetPropertyValue_AutomationId_ReturnsExpected()
-    {
-        using SubButtonBase ownerControl = new() { Name = "test name" };
-        string expected = ownerControl.Name;
-        object actual = ownerControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.False(ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBaseAccessibleObject_TextChanged_AutomationPropertyChanged_Raised()
-    {
-        const string newText = "New text";
-        using var control = new ButtonWithCustomAccessibleObject(
-            (propertyId, value) => propertyId == UiaCore.UIA.NamePropertyId && ReferenceEquals(value, newText))
-        {
-            Text = "Text"
-        };
-
-        var accessibilityObject = control.AccessibilityObject as ControlAccessibleObjectWithNotificationCounter;
-        Assert.NotNull(accessibilityObject);
-        Assert.True(control.IsAccessibilityObjectCreated);
-        Assert.Equal(0, accessibilityObject.RaiseAutomationNotificationCallCount);
-
-        control.Text = newText;
-
-        Assert.Equal(1, accessibilityObject.RaiseAutomationNotificationCallCount);
-    }
-
-    private class SubButtonBase : ButtonBase
-    {
-        public Action PerformClickAction { get; set; }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public void PerformClick() => PerformClickAction();
-    }
-
-    private class ButtonWithCustomAccessibleObject : ButtonBase
-    {
-        private readonly Func<UiaCore.UIA, object, bool> _checkRaisedEvent;
-
-        public ButtonWithCustomAccessibleObject(Func<UiaCore.UIA, object, bool> checkRaisedEvent)
-        {
-            _checkRaisedEvent = checkRaisedEvent;
-        }
-
-        protected override AccessibleObject CreateAccessibilityInstance() => new ControlAccessibleObjectWithNotificationCounter(this, _checkRaisedEvent);
-    }
-
-    private class ControlAccessibleObjectWithNotificationCounter : Control.ControlAccessibleObject
-    {
-        private readonly Func<UiaCore.UIA, object, bool> _checkRaisedEvent;
-
-        public ControlAccessibleObjectWithNotificationCounter(Control ownerControl, Func<UiaCore.UIA, object, bool> checkRaisedEvent) : base(ownerControl)
-        {
-            _checkRaisedEvent = checkRaisedEvent;
-        }
-        
-        internal int RaiseAutomationNotificationCallCount { get; private set; }
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UiaCore.UIA propertyId, object oldValue, object newValue)
-        {
-            if (_checkRaisedEvent(propertyId, newValue))
-            {
-                RaiseAutomationNotificationCallCount++;
-            }
-
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBaseTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBaseTests.cs
deleted file mode 100644
index ded4165801a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonBaseTests.cs
+++ /dev/null
@@ -1,9380 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Windows.Forms.DataBinding.TestUtilities;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ButtonBaseTests
-{
-    [WinFormsFact]
-    public void ButtonBase_Ctor_Default()
-    {
-        using var control = new SubButtonBase();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoEllipsis);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(75, 23), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(75, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.NotNull(control.FlatAppearance);
-        Assert.Same(control.FlatAppearance, control.FlatAppearance);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Null(control.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.ImageAlign);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsDefault);
-        Assert.False(control.IsMirrored);
-        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("Microsoft\u00AE .NET", control.ProductName);
-        // This causes an assertion which we want to keep internally.
-        using (new NoAssertContext())
-        {
-            Assert.Throws<NullReferenceException>(() => control.PreferredSize);
-        }
-
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(75, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(75, 23), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.TextAlign);
-        Assert.Equal(TextImageRelation.Overlay, control.TextImageRelation);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.True(control.UseMnemonic);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(75, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubButtonBase();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, 0x56010000)]
-    [InlineData(FlatStyle.Flat, false, 0x56010000)]
-    [InlineData(FlatStyle.Popup, true, 0x56010000)]
-    [InlineData(FlatStyle.Popup, false, 0x56010000)]
-    [InlineData(FlatStyle.Standard, true, 0x56010000)]
-    [InlineData(FlatStyle.Standard, false, 0x56010000)]
-    [InlineData(FlatStyle.System, true, 0x56012F01)]
-    [InlineData(FlatStyle.System, false, 0x56012F00)]
-    public void ButtonBase_CreateParams_GetIsDefault_ReturnsExpected(FlatStyle flatStyle, bool isDefault, int expectedStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            IsDefault = isDefault
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CreateParams_GetIsDefault_TestData()
-    {
-        foreach (FlatStyle flatStyle in new FlatStyle[] { FlatStyle.Flat, FlatStyle.Popup, FlatStyle.Standard })
-        {
-            foreach (ContentAlignment textAlign in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                yield return new object[] { flatStyle, RightToLeft.Yes, textAlign, 0x56010000, 0x7000 };
-                yield return new object[] { flatStyle, RightToLeft.No, textAlign, 0x56010000, 0 };
-                yield return new object[] { flatStyle, RightToLeft.Inherit, textAlign, 0x56010000, 0 };
-            }
-        }
-
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomLeft, 0x56012A00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomCenter, 0x56012B00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomRight, 0x56012900, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleLeft, 0x56012E00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleCenter, 0x56012F00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleRight, 0x56012D00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopLeft, 0x56012600, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopCenter, 0x56012700, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopRight, 0x56012500, 0x6000 };
-
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomLeft, 0x56012900, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomCenter, 0x56012B00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomRight, 0x56012A00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleLeft, 0x56012D00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleCenter, 0x56012F00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleRight, 0x56012E00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopLeft, 0x56012500, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopCenter, 0x56012700, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopRight, 0x56012600, 0 };
-
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomLeft, 0x56012900, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomCenter, 0x56012B00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomRight, 0x56012A00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleLeft, 0x56012D00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleCenter, 0x56012F00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleRight, 0x56012E00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopLeft, 0x56012500, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopCenter, 0x56012700, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopRight, 0x56012600, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateParams_GetIsDefault_TestData))]
-    public void ButtonBase_CreateParams_GetTextAlign_ReturnsExpected(FlatStyle flatStyle, RightToLeft rightToLeft, ContentAlignment textAlign, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            RightToLeft = rightToLeft,
-            TextAlign = textAlign
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_AutoEllipsis_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = value
-        };
-        Assert.Equal(value, control.AutoEllipsis);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoEllipsis = value;
-        Assert.Equal(value, control.AutoEllipsis);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoEllipsis = !value;
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ButtonBase_AutoEllipsis_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoEllipsis = value;
-        Assert.Equal(value, control.AutoEllipsis);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoEllipsis = value;
-        Assert.Equal(value, control.AutoEllipsis);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoEllipsis = !value;
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_AutoSize_SetAutoEllipsis_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = true
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_AutoSize_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ButtonBase_AutoSize_SetAutoEllipsisWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(!value, control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.False(control.AutoEllipsis);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ButtonBase_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubButtonBase
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ButtonBase_BackColor_SetWithUseVisualStyleBackColor_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubButtonBase
-        {
-            UseVisualStyleBackColor = true,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ButtonBase_BackColor_SetDesignMode_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Site = mockSite.Object,
-            UseVisualStyleBackColor = false,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ButtonBase_BackColor_SetDesignModeWithUseVisualStyleBackColor_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Site = mockSite.Object,
-            UseVisualStyleBackColor = true,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(value.IsEmpty, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(value.IsEmpty, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ButtonBase_BackColor_SetDesignModeWithInvalidDescriptor_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Site = mockSite.Object,
-            UseVisualStyleBackColor = true
-        };
-        var mockCustomTypeDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-        mockCustomTypeDescriptor
-            .Setup(d => d.GetProperties())
-            .Returns(PropertyDescriptorCollection.Empty);
-        var mockProvider = new Mock<TypeDescriptionProvider>(MockBehavior.Strict);
-        mockProvider
-            .Setup(p => p.GetCache(control))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(control))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetTypeDescriptor(typeof(SubButtonBase), control))
-            .Returns(mockCustomTypeDescriptor.Object);
-        TypeDescriptor.AddProvider(mockProvider.Object, control);
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 2 };
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void ButtonBase_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_BasicCommandBinding()
-    {
-        const string CommandParameter = nameof(CommandParameter);
-
-        using SubButtonBase button = new();
-
-        // TestCommandExecutionAbility is controlling the execution context.
-        CommandViewModel viewModel = new() { TestCommandExecutionAbility = true };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(button, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        button.CommandChanged += handler;
-        button.Command = viewModel.TestCommand;
-        Assert.Equal(1, callCount);
-
-        button.CommandParameterChanged += handler;
-        button.CommandParameter = CommandParameter;
-        Assert.Equal(2, callCount);
-
-        Assert.Same(viewModel.TestCommand, button.Command);
-        Assert.True(button.Enabled);
-
-        // OnClick is invoking the command in the ViewModel.
-        // The CommandParameter should make its way into the viewmodel's CommandExecuteResult property.
-        button.OnClick(EventArgs.Empty);
-        Assert.Same(CommandParameter, viewModel.CommandExecuteResult);
-
-        // We're changing the execution context.
-        // The ViewModel calls RaiseCanExecuteChanged, which the Button should handle.
-        viewModel.TestCommandExecutionAbility = false;
-        Assert.False(button.Enabled);
-
-        // Remove handler.
-        button.CommandChanged -= handler;
-        button.Command = null;
-        Assert.Equal(2, callCount);
-
-        button.CommandParameterChanged -= handler;
-        button.CommandParameter = null;
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Enabled_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true };
-                yield return new object[] { visible, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ButtonBase_Enabled_Set_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            Visible = visible,
-            Image = image,
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ButtonBase_Enabled_SetDesignMode_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object,
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Enabled_SetWithHandle_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true, 0, 2 };
-                yield return new object[] { visible, image, false, 2, 3 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_SetWithHandle_TestData))]
-    public void ButtonBase_Enabled_SetWithHandle_GetReturnsExpected(bool visible, Image image, bool value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubButtonBase
-        {
-            Visible = visible,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_SetWithHandle_TestData))]
-    public void ButtonBase_Enabled_SetDesignModeWithHandle_GetReturnsExpected(bool visible, Image image, bool value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.EnabledChanged += handler;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Enabled = false;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_FlatAppearance_Get_ReturnsExpected()
-    {
-        using var control = new SubButtonBase();
-        FlatButtonAppearance appearance = control.FlatAppearance;
-        Assert.Equal(Color.Empty, appearance.BorderColor);
-        Assert.Equal(1, appearance.BorderSize);
-        Assert.Equal(Color.Empty, appearance.CheckedBackColor);
-        Assert.Equal(Color.Empty, appearance.MouseDownBackColor);
-        Assert.Equal(Color.Empty, appearance.MouseOverBackColor);
-        Assert.Same(appearance, control.FlatAppearance);
-    }
-
-    public static IEnumerable<object[]> FlatStyle_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (FlatStyle value in Enum.GetValues(typeof(FlatStyle)))
-            {
-                yield return new object[] { autoSize, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_Set_TestData))]
-    public void ButtonBase_FlatStyle_Set_GetReturnsExpected(bool autoSize, FlatStyle value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> FlatStyle_SetWithCustomOldValue_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (FlatStyle oldValue in Enum.GetValues(typeof(FlatStyle)))
-            {
-                foreach (FlatStyle value in Enum.GetValues(typeof(FlatStyle)))
-                {
-                    yield return new object[] { autoSize, oldValue, value };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_SetWithCustomOldValue_TestData))]
-    public void ButtonBase_FlatStyle_SetWithCustomOldValue_GetReturnsExpected(bool autoSize, FlatStyle oldValue, FlatStyle value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            FlatStyle = oldValue
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> FlatStyle_SetWithParent_TestData()
-    {
-        yield return new object[] { true, FlatStyle.Flat, 1 };
-        yield return new object[] { true, FlatStyle.Popup, 1 };
-        yield return new object[] { true, FlatStyle.Standard, 0 };
-        yield return new object[] { true, FlatStyle.System, 1 };
-
-        yield return new object[] { false, FlatStyle.Flat, 0 };
-        yield return new object[] { false, FlatStyle.Popup, 0 };
-        yield return new object[] { false, FlatStyle.Standard, 0 };
-        yield return new object[] { false, FlatStyle.System, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_SetWithParent_TestData))]
-    public void ButtonBase_FlatStyle_SetWithParent_GetReturnsExpected(bool autoSize, FlatStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("FlatStyle", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.FlatStyle = value;
-            Assert.Equal(value, control.FlatStyle);
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.FlatStyle = value;
-            Assert.Equal(value, control.FlatStyle);
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> FlatStyle_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, FlatStyle.Flat, 1, 0 };
-            yield return new object[] { autoSize, FlatStyle.Popup, 1, 0 };
-            yield return new object[] { autoSize, FlatStyle.Standard, 0, 0 };
-            yield return new object[] { autoSize, FlatStyle.System, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_SetWithHandle_TestData))]
-    public void ButtonBase_FlatStyle_SetWithHandle_GetReturnsExpected(bool autoSize, FlatStyle value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> FlatStyle_SetWithCustomOldValueWithHandle_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, FlatStyle.Flat, 0, 0 };
-        yield return new object[] { FlatStyle.Flat, FlatStyle.Popup, 1, 0 };
-        yield return new object[] { FlatStyle.Flat, FlatStyle.Standard, 1, 0 };
-        yield return new object[] { FlatStyle.Flat, FlatStyle.System, 1, 1 };
-
-        yield return new object[] { FlatStyle.Popup, FlatStyle.Flat, 1, 0 };
-        yield return new object[] { FlatStyle.Popup, FlatStyle.Popup, 0, 0 };
-        yield return new object[] { FlatStyle.Popup, FlatStyle.Standard, 1, 0 };
-        yield return new object[] { FlatStyle.Popup, FlatStyle.System, 1, 1 };
-
-        yield return new object[] { FlatStyle.Standard, FlatStyle.Flat, 1, 0 };
-        yield return new object[] { FlatStyle.Standard, FlatStyle.Popup, 1, 0 };
-        yield return new object[] { FlatStyle.Standard, FlatStyle.Standard, 0, 0 };
-        yield return new object[] { FlatStyle.Standard, FlatStyle.System, 1, 1 };
-
-        yield return new object[] { FlatStyle.System, FlatStyle.Flat, 1, 1 };
-        yield return new object[] { FlatStyle.System, FlatStyle.Popup, 1, 1 };
-        yield return new object[] { FlatStyle.System, FlatStyle.Standard, 1, 1 };
-        yield return new object[] { FlatStyle.System, FlatStyle.System, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_SetWithCustomOldValueWithHandle_TestData))]
-    public void ButtonBase_FlatStyle_SetWithCustomOldValueWithHandle_GetReturnsExpected(FlatStyle oldValue, FlatStyle value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = oldValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> FlatStyle_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, FlatStyle.Flat, 1, 1, 0 };
-        yield return new object[] { true, FlatStyle.Popup, 1, 1, 0 };
-        yield return new object[] { true, FlatStyle.Standard, 0, 0, 0 };
-        yield return new object[] { true, FlatStyle.System, 1, 1, 1 };
-
-        yield return new object[] { false, FlatStyle.Flat, 0, 1, 0 };
-        yield return new object[] { false, FlatStyle.Popup, 0, 1, 0 };
-        yield return new object[] { false, FlatStyle.Standard, 0, 0, 0 };
-        yield return new object[] { false, FlatStyle.System, 0, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FlatStyle_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_FlatStyle_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, FlatStyle value, int expectedParentLayoutCallCount, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("FlatStyle", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        try
-        {
-            control.FlatStyle = value;
-            Assert.Equal(value, control.FlatStyle);
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(expectedCreatedCallCount, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.FlatStyle = value;
-            Assert.Equal(value, control.FlatStyle);
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserMouse));
-            Assert.Equal(value != FlatStyle.System, control.GetStyle(ControlStyles.UserPaint));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(expectedCreatedCallCount, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<FlatStyle>]
-    public void ButtonBase_FlatStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(FlatStyle value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.FlatStyle = value);
-    }
-
-    public static IEnumerable<object[]> Image_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                foreach (bool visible in new bool[] { true, false })
-                {
-                    yield return new object[] { autoSize, enabled, visible, null };
-                    yield return new object[] { autoSize, enabled, visible, new Bitmap(10, 10) };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ButtonBase_Image_Set_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_SetWithImageIndex_GetReturnsExpected()
-    {
-        using var control = new SubButtonBase
-        {
-            ImageIndex = 1
-        };
-
-        // Set same.
-        control.Image = null;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(1, control.ImageIndex);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        using var value = new Bitmap(10, 10);
-        control.Image = value;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Same(value, control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_SetWithImageKey_GetReturnsExpected()
-    {
-        using var control = new SubButtonBase
-        {
-            ImageKey = "ImageKey"
-        };
-
-        // Set same.
-        control.Image = null;
-        Assert.Equal("ImageKey", control.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, control.ImageIndex);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        using var value = new Bitmap(10, 10);
-        control.Image = value;
-        Assert.Equal(ImageList.Indexer.DefaultKey, control.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, control.ImageIndex);
-        Assert.Same(value, control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_SetWithImageList_GetReturnsExpected()
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-
-        // Set same.
-        control.Image = null;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Same(imageList, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        using var value = new Bitmap(10, 10);
-        control.Image = value;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Null(control.ImageList);
-        Assert.Same(value, control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ButtonBase_Image_SetDesignMode_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible,
-            Site = mockSite.Object
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Image_SetWithParent_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                yield return new object[] { true, enabled, visible, null, 0 };
-                yield return new object[] { true, enabled, visible, new Bitmap(10, 10), 1 };
-                yield return new object[] { false, enabled, visible, null, 0 };
-                yield return new object[] { false, enabled, visible, new Bitmap(10, 10), 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithParent_TestData))]
-    public void ButtonBase_Image_SetWithParent_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Image", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Image = value;
-            Assert.Same(value, control.Image);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Image = value;
-            Assert.Same(value, control.Image);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Image_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                foreach (bool visible in new bool[] { true, false })
-                {
-                    yield return new object[] { autoSize, enabled, visible, null, 0 };
-                    yield return new object[] { autoSize, enabled, visible, new Bitmap(10, 10), 2 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithHandle_TestData))]
-    public void ButtonBase_Image_SetWithHandle_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithHandle_TestData))]
-    public void ButtonBase_Image_SetDesignModeWithHandle_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value, int expectedInvalidatedCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Image = value;
-        Assert.Same(value, control.Image);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Image_SetWithParentWithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                yield return new object[] { true, enabled, visible, null, 0, 0 };
-                yield return new object[] { true, enabled, visible, new Bitmap(10, 10), 1, 2 };
-                yield return new object[] { false, enabled, visible, null, 0, 0 };
-                yield return new object[] { false, enabled, visible, new Bitmap(10, 10), 0, 2 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_Image_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, bool enabled, bool visible, Image value, int expectedParentLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Enabled = enabled,
-            Visible = visible,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Image", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Image = value;
-            Assert.Same(value, control.Image);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.Image = value;
-            Assert.Same(value, control.Image);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.Image)];
-        using var control = new SubButtonBase();
-        Assert.False(property.CanResetValue(control));
-
-        using var image = new Bitmap(10, 10);
-        control.Image = image;
-        Assert.Same(image, control.Image);
-        Assert.True(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-
-        property.ResetValue(control);
-        Assert.Null(control.Image);
-        Assert.False(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_ResetValueWithHandle_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.Image)];
-        using var control = new SubButtonBase();
-        Assert.False(property.CanResetValue(control));
-
-        using var image = new Bitmap(10, 10);
-        control.Image = image;
-        Assert.Same(image, control.Image);
-        Assert.True(property.CanResetValue(control));
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        property.ResetValue(control);
-        Assert.Null(control.Image);
-        Assert.False(property.CanResetValue(control));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Image_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.Image)];
-        using var control = new SubButtonBase();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        using var image = new Bitmap(10, 10);
-        control.Image = image;
-        Assert.Same(image, control.Image);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Null(control.Image);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> ImageAlign_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                yield return new object[] { autoSize, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageAlign_Set_TestData))]
-    public void ButtonBase_ImageAlign_Set_GetReturnsExpected(bool autoSize, ContentAlignment value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageAlign_SetWithParent_TestData()
-    {
-        foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-        {
-            int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-            yield return new object[] { true, value, expectedCallCount };
-            yield return new object[] { false, value, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageAlign_SetWithParent_TestData))]
-    public void ButtonBase_ImageAlign_SetWithParent_GetReturnsExpected(bool autoSize, ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("ImageAlign", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ImageAlign = value;
-            Assert.Equal(value, control.ImageAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.ImageAlign = value;
-            Assert.Equal(value, control.ImageAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> ImageAlign_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-                yield return new object[] { autoSize, value, expectedCallCount };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageAlign_SetWithHandle_TestData))]
-    public void ButtonBase_ImageAlign_SetWithHandle_GetReturnsExpected(bool autoSize, ContentAlignment value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ImageAlign_SetWithParentWithHandle_TestData()
-    {
-        foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-        {
-            int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-            yield return new object[] { true, value, expectedCallCount, expectedCallCount };
-            yield return new object[] { false, value, 0, expectedCallCount };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageAlign_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_ImageAlign_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, ContentAlignment value, int expectedParentLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("ImageAlign", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ImageAlign = value;
-            Assert.Equal(value, control.ImageAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.ImageAlign = value;
-            Assert.Equal(value, control.ImageAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void ButtonBase_ImageAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImageAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ButtonBase_ImageIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubButtonBase
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageIndex_SetWithImage_GetReturnsExpected()
-    {
-        using var image = new Bitmap(10, 10);
-        using var control = new SubButtonBase
-        {
-            Image = image
-        };
-
-        // Set same.
-        control.ImageIndex = -1;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Same(image, control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ImageIndex = 0;
-        Assert.Empty(control.ImageKey);
-        Assert.Equal(0, control.ImageIndex);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ButtonBase_ImageIndex_SetWithImageKey_GetReturnsExpected(int value)
-    {
-        using var control = new SubButtonBase
-        {
-            ImageKey = "ImageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ButtonBase_ImageIndex_SetWithEmptyList_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-
-        control.ImageIndex = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void ButtonBase_ImageIndex_SetWithNotEmptyList_GetReturnsExpected(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-
-        control.ImageIndex = value;
-        Assert.Equal(expected, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(expected, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1, 2)]
-    [InlineData(0, 1, 1)]
-    [InlineData(1, 1, 1)]
-    public void ButtonBase_ImageIndex_SetWithHandle_GetReturnsExpected(int value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    public void ButtonBase_ImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ImageIndex = value);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ButtonBase_ImageKey_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubButtonBase
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageKey_SetWithImage_GetReturnsExpected()
-    {
-        using var image = new Bitmap(10, 10);
-        using var control = new SubButtonBase
-        {
-            Image = image
-        };
-
-        control.ImageKey = ImageList.Indexer.DefaultKey;
-        Assert.Equal(ImageList.Indexer.DefaultKey, control.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, control.ImageIndex);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("ImageKey", "ImageKey")]
-    public void ButtonBase_ImageKey_SetWithImageIndex_GetReturnsExpected(string value, string expectedImageKey)
-    {
-        using var control = new SubButtonBase
-        {
-            ImageIndex = 0,
-            ImageKey = value
-        };
-        Assert.Equal(expectedImageKey, control.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(expectedImageKey, control.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ButtonBase_ImageKey_SetWithEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Image1", "Image1")]
-    [InlineData("image1", "image1")]
-    [InlineData("Image2", "Image2")]
-    [InlineData("NoSuchImage", "NoSuchImage")]
-    public void ButtonBase_ImageKey_SetWithNotEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 1, 2)]
-    [InlineData("", "", 1, 2)]
-    [InlineData("ImageKey", "ImageKey", 1, 1)]
-    public void ButtonBase_ImageKey_SetWithHandle_GetReturnsExpected(string value, string expected, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(expected, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ImageList_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ImageList() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void ButtonBase_ImageList_Set_GetReturnsExpected(ImageList value)
-    {
-        using var control = new SubButtonBase
-        {
-            ImageList = value
-        };
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_SetWithImage_GetReturnsExpected()
-    {
-        using var image = new Bitmap(10, 10);
-        using var control = new SubButtonBase
-        {
-            Image = image
-        };
-
-        // Set same.
-        control.ImageList = null;
-        Assert.Null(control.ImageList);
-        Assert.Same(image, control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Same(imageList, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void ButtonBase_ImageList_SetWithNonNullOldValue_GetReturnsExpected(ImageList value)
-    {
-        using var oldValue = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = oldValue
-        };
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageList_SetWithHandle_TestData()
-    {
-        yield return new object[] { null, 0 };
-        yield return new object[] { new ImageList(), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_SetWithHandle_TestData))]
-    public void ButtonBase_ImageList_SetWithHandle_GetReturnsExpected(ImageList value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ImageList_SetWithNonNullOldValueWithHandle_TestData()
-    {
-        yield return new object[] { null, 1 };
-        yield return new object[] { new ImageList(), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_SetWithNonNullOldValueWithHandle_TestData))]
-    public void ButtonBase_ImageList_SetWithNonNullOldValueWithHandle_GetReturnsExpected(ImageList value, int expectedInvalidatedCallCount)
-    {
-        using var oldValue = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = oldValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.Null(control.Image);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_Set_DoesNotCreateImageHandle()
-    {
-        using var control = new SubButtonBase();
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.False(imageList.HandleCreated);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_Dispose_DetachesFromButtonBase()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList1
-        };
-        Assert.Same(imageList1, control.ImageList);
-
-        imageList1.Dispose();
-        Assert.Null(control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_DisposeWithHandle_DetachesFromButtonBase()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = imageList1;
-        Assert.Same(imageList1, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_RecreateHandle_Nop()
-    {
-        using var imageList1 = new ImageList();
-        int recreateCallCount1 = 0;
-        imageList1.RecreateHandle += (sender, e) => recreateCallCount1++;
-        using var imageList2 = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList1
-        };
-        Assert.Same(imageList1, control.ImageList);
-        Assert.Equal(0, recreateCallCount1);
-        Assert.NotEqual(IntPtr.Zero, imageList1.Handle);
-
-        imageList1.ImageSize = new Size(1, 2);
-        Assert.Equal(1, recreateCallCount1);
-        Assert.Same(imageList1, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.ImageSize = new Size(2, 3);
-        Assert.Equal(2, recreateCallCount1);
-        Assert.Same(imageList2, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImageList_RecreateHandleWithHandle_Success()
-    {
-        using var imageList1 = new ImageList();
-        int recreateCallCount1 = 0;
-        imageList1.RecreateHandle += (sender, e) => recreateCallCount1++;
-        using var imageList2 = new ImageList();
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.NotEqual(IntPtr.Zero, imageList1.Handle);
-
-        control.ImageList = imageList1;
-        Assert.Same(imageList1, control.ImageList);
-        Assert.Equal(0, recreateCallCount1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.ImageSize = new Size(1, 2);
-        Assert.Equal(1, recreateCallCount1);
-        Assert.Same(imageList1, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.ImageSize = new Size(2, 3);
-        Assert.Equal(2, recreateCallCount1);
-        Assert.Same(imageList2, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ButtonBase_ImeMode_Set_GetReturnsExpected(ImeMode value)
-    {
-        using var control = new SubButtonBase
-        {
-            ImeMode = value
-        };
-        Assert.Equal(value, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(value, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void ButtonBase_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    public static IEnumerable<object[]> IsDefault_Set_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, true };
-            yield return new object[] { flatStyle, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsDefault_Set_TestData))]
-    public void ButtonBase_IsDefault_Set_GetReturnsExpected(FlatStyle flatStyle, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            IsDefault = value
-        };
-        Assert.Equal(value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.IsDefault = value;
-        Assert.Equal(value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.IsDefault = !value;
-        Assert.Equal(!value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> IsDefault_SetWithHandle_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.Popup, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.Standard, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.System, true, 1, 1, 2, 2 };
-
-        yield return new object[] { FlatStyle.Flat, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.Popup, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.Standard, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.System, false, 0, 0, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsDefault_SetWithHandle_TestData))]
-    public void ButtonBase_IsDefault_SetWithHandle_GetReturnsExpected(FlatStyle flatStyle, bool value, int expectedInvalidatedCallCount1, int expectedStyleChangeCallCount1, int expectedInvalidatedCallCount2, int expectedStyleChangeCallCount2)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.IsDefault = value;
-        Assert.Equal(value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.IsDefault = value;
-        Assert.Equal(value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.IsDefault = !value;
-        Assert.Equal(!value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount2, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new Control() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ButtonBase_Parent_Set_GetReturnsExpected(bool enabled, bool visible, Image image, Control value)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ButtonBase_Parent_SetDesignMode_GetReturnsExpected(bool enabled, bool visible, Image image, Control value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object,
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ButtonBase_Parent_SetWithNonNullOldParent_GetReturnsExpected(bool enabled, bool visible, Image image, Control value)
-    {
-        using var oldParent = new Control();
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new Control();
-        using var control = new SubButtonBase
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ButtonBase_Parent_SetWithHandle_GetReturnsExpected(bool enabled, bool visible, Image image, Control value)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ButtonBase_Parent_SetDesignModeWithHandle_GetReturnsExpected(bool enabled, bool visible, Image image, Control value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null, string.Empty };
-            yield return new object[] { autoSize, string.Empty, string.Empty };
-            yield return new object[] { autoSize, "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void ButtonBase_Text_Set_GetReturnsExpected(bool autoSize, string value, string expected)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithParent_TestData()
-    {
-        yield return new object[] { true, null, string.Empty, 0 };
-        yield return new object[] { true, string.Empty, string.Empty, 0 };
-        yield return new object[] { true, "text", "text", 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParent_TestData))]
-    public void ButtonBase_Text_SetWithParent_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Text_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null, string.Empty, 0 };
-            yield return new object[] { autoSize, string.Empty, string.Empty, 0 };
-            yield return new object[] { autoSize, "text", "text", 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithHandle_TestData))]
-    public void ButtonBase_Text_SetWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, null, string.Empty, 0 };
-        yield return new object[] { true, string.Empty, string.Empty, 0 };
-        yield return new object[] { true, "text", "text", 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_Text_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> TextAlign_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-            {
-                foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-                {
-                    yield return new object[] { autoSize, flatStyle, value };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_Set_TestData))]
-    public void ButtonBase_TextAlign_Set_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextAlign_SetWithParent_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-                yield return new object[] { true, flatStyle, value, expectedCallCount };
-                yield return new object[] { false, flatStyle, value, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_SetWithParent_TestData))]
-    public void ButtonBase_TextAlign_SetWithParent_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextAlign", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.TextAlign = value;
-            Assert.Equal(value, control.TextAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.TextAlign = value;
-            Assert.Equal(value, control.TextAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> TextAlign_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-                yield return new object[] { autoSize, FlatStyle.Flat, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.Popup, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.Standard, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.System, value, expectedCallCount, expectedCallCount };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_SetWithHandle_TestData))]
-    public void ButtonBase_TextAlign_SetWithHandle_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TextAlign_SetWithParentWithHandle_TestData()
-    {
-        foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-        {
-            int expectedCallCount = value == ContentAlignment.MiddleCenter ? 0 : 1;
-            yield return new object[] { true, FlatStyle.Flat, value, expectedCallCount, expectedCallCount, 0 };
-            yield return new object[] { true, FlatStyle.Popup, value, expectedCallCount, expectedCallCount, 0 };
-            yield return new object[] { true, FlatStyle.Standard, value, expectedCallCount, expectedCallCount, 0 };
-            yield return new object[] { true, FlatStyle.System, value, expectedCallCount, expectedCallCount, expectedCallCount };
-
-            yield return new object[] { false, FlatStyle.Flat, value, 0, expectedCallCount, 0 };
-            yield return new object[] { false, FlatStyle.Popup, value, 0, expectedCallCount, 0 };
-            yield return new object[] { false, FlatStyle.Standard, value, 0, expectedCallCount, 0 };
-            yield return new object[] { false, FlatStyle.System, value, 0, expectedCallCount, expectedCallCount };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_TextAlign_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value, int expectedParentLayoutCallCount, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextAlign", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.TextAlign = value;
-            Assert.Equal(value, control.TextAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.TextAlign = value;
-            Assert.Equal(value, control.TextAlign);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void ButtonBase_TextAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextAlign = value);
-    }
-
-    public static IEnumerable<object[]> TextImageRelation_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (TextImageRelation value in Enum.GetValues(typeof(TextImageRelation)))
-            {
-                yield return new object[] { autoSize, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextImageRelation_Set_TestData))]
-    public void ButtonBase_TextImageRelation_Set_GetReturnsExpected(bool autoSize, TextImageRelation value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextImageRelation = value;
-        Assert.Equal(value, control.TextImageRelation);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextImageRelation = value;
-        Assert.Equal(value, control.TextImageRelation);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextImageRelation_SetWithParent_TestData()
-    {
-        yield return new object[] { true, TextImageRelation.ImageAboveText, 1 };
-        yield return new object[] { true, TextImageRelation.ImageBeforeText, 1 };
-        yield return new object[] { true, TextImageRelation.Overlay, 0 };
-        yield return new object[] { true, TextImageRelation.TextAboveImage, 1 };
-        yield return new object[] { true, TextImageRelation.ImageBeforeText, 1 };
-
-        yield return new object[] { false, TextImageRelation.ImageAboveText, 0 };
-        yield return new object[] { false, TextImageRelation.ImageBeforeText, 0 };
-        yield return new object[] { false, TextImageRelation.Overlay, 0 };
-        yield return new object[] { false, TextImageRelation.TextAboveImage, 0 };
-        yield return new object[] { false, TextImageRelation.ImageBeforeText, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextImageRelation_SetWithParent_TestData))]
-    public void ButtonBase_TextImageRelation_SetWithParent_GetReturnsExpected(bool autoSize, TextImageRelation value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextImageRelation", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.TextImageRelation = value;
-            Assert.Equal(value, control.TextImageRelation);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.TextImageRelation = value;
-            Assert.Equal(value, control.TextImageRelation);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> TextImageRelation_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, TextImageRelation.ImageAboveText, 1 };
-            yield return new object[] { autoSize, TextImageRelation.ImageBeforeText, 1 };
-            yield return new object[] { autoSize, TextImageRelation.Overlay, 0 };
-            yield return new object[] { autoSize, TextImageRelation.TextAboveImage, 1 };
-            yield return new object[] { autoSize, TextImageRelation.ImageBeforeText, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextImageRelation_SetWithHandle_TestData))]
-    public void ButtonBase_TextImageRelation_SetWithHandle_GetReturnsExpected(bool autoSize, TextImageRelation value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextImageRelation = value;
-        Assert.Equal(value, control.TextImageRelation);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextImageRelation = value;
-        Assert.Equal(value, control.TextImageRelation);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TextImageRelation_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, TextImageRelation.ImageAboveText, 1, 1 };
-        yield return new object[] { true, TextImageRelation.ImageBeforeText, 1, 1 };
-        yield return new object[] { true, TextImageRelation.Overlay, 0, 0 };
-        yield return new object[] { true, TextImageRelation.TextAboveImage, 1, 1 };
-        yield return new object[] { true, TextImageRelation.ImageBeforeText, 1, 1 };
-
-        yield return new object[] { false, TextImageRelation.ImageAboveText, 0, 1 };
-        yield return new object[] { false, TextImageRelation.ImageBeforeText, 0, 1 };
-        yield return new object[] { false, TextImageRelation.Overlay, 0, 0 };
-        yield return new object[] { false, TextImageRelation.TextAboveImage, 0, 1 };
-        yield return new object[] { false, TextImageRelation.ImageBeforeText, 0, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextImageRelation_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_TextImageRelation_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, TextImageRelation value, int expectedParentLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextImageRelation", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.TextImageRelation = value;
-            Assert.Equal(value, control.TextImageRelation);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.TextImageRelation = value;
-            Assert.Equal(value, control.TextImageRelation);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextImageRelation>]
-    [InlineData((TextImageRelation)3)]
-    [InlineData((TextImageRelation)5)]
-    [InlineData((TextImageRelation)6)]
-    [InlineData((TextImageRelation)7)]
-    public void ButtonBase_TextImageRelation_SetInvalid_ThrowsInvalidEnumArgumentException(TextImageRelation value)
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextImageRelation = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ButtonBase_UseCompatibleTextRendering_Set_GetReturnsExpected(bool autoSize, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize,
-            UseCompatibleTextRendering = value
-        };
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseCompatibleTextRendering = !value;
-        Assert.Equal(!value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 1)]
-    [InlineData(true, false, 1, 2)]
-    [InlineData(false, true, 0, 0)]
-    [InlineData(false, false, 0, 0)]
-    public void ButtonBase_UseCompatibleTextRendering_SetWithParent_GetReturnsExpected(bool autoSize, bool value, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("UseCompatibleTextRendering", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set different.
-            control.UseCompatibleTextRendering = !value;
-            Assert.Equal(!value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 0)]
-    [InlineData(false, false, 1)]
-    public void ButtonBase_UseCompatibleTextRendering_SetWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseCompatibleTextRendering = !value;
-        Assert.Equal(!value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 0, 1, 1)]
-    [InlineData(true, false, 1, 1, 2, 2)]
-    [InlineData(false, true, 0, 0, 1, 0)]
-    [InlineData(false, false, 1, 0, 2, 0)]
-    public void ButtonBase_UseCompatibleTextRendering_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedInvalidatedCallCount1, int expectedParentLayoutCallCount1, int expectedInvalidatedCallCount2, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("UseCompatibleTextRendering", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            control.UseCompatibleTextRendering = !value;
-            Assert.Equal(!value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> UseMnemonic_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, true };
-            yield return new object[] { autoSize, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseMnemonic_Set_TestData))]
-    public void ButtonBase_UseMnemonic_Set_GetReturnsExpected(bool autoSize, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.UseMnemonic = value;
-        Assert.Equal(value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseMnemonic = value;
-        Assert.Equal(value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseMnemonic = !value;
-        Assert.Equal(!value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UseMnemonic_SetWithParent_TestData()
-    {
-        yield return new object[] { true, true, 0, 1 };
-        yield return new object[] { true, false, 1, 2 };
-        yield return new object[] { false, true, 0, 0 };
-        yield return new object[] { false, false, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseMnemonic_SetWithParent_TestData))]
-    public void ButtonBase_UseMnemonic_SetWithParent_GetReturnsExpected(bool autoSize, bool value, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseMnemonic = value;
-            Assert.Equal(value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.UseMnemonic = value;
-            Assert.Equal(value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.UseMnemonic = !value;
-            Assert.Equal(!value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> UseMnemonic_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, true, 0 };
-            yield return new object[] { autoSize, false, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseMnemonic_SetWithHandle_TestData))]
-    public void ButtonBase_UseMnemonic_SetWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.UseMnemonic = value;
-        Assert.Equal(value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseMnemonic = value;
-        Assert.Equal(value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseMnemonic = !value;
-        Assert.Equal(!value, control.UseMnemonic);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> UseMnemonic_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, true, 0, 1, 0, 1 };
-        yield return new object[] { true, false, 1, 2, 1, 2 };
-        yield return new object[] { false, true, 0, 0, 0, 1 };
-        yield return new object[] { false, false, 0, 0, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UseMnemonic_SetWithParentWithHandle_TestData))]
-    public void ButtonBase_UseMnemonic_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseMnemonic = value;
-            Assert.Equal(value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.UseMnemonic = value;
-            Assert.Equal(value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set different.
-            control.UseMnemonic = !value;
-            Assert.Equal(!value, control.UseMnemonic);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_UseVisualStyleBackColor_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            UseVisualStyleBackColor = value
-        };
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ButtonBase_UseVisualStyleBackColor_SetWithCustomOldValue_GetReturnsExpected(bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            UseVisualStyleBackColor = true
-        };
-
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 1)]
-    public void ButtonBase_UseVisualStyleBackColor_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ButtonBase_UseVisualStyleBackColor_SetWithCustomOldValueWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            UseVisualStyleBackColor = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_UseVisualStyleBackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.UseVisualStyleBackColor)];
-        using var control = new SubButtonBase();
-        Assert.False(property.CanResetValue(control));
-
-        control.UseVisualStyleBackColor = false;
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.True(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-
-        property.ResetValue(control);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(property.CanResetValue(control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_UseVisualStyleBackColor_ResetValueWithHandle_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.UseVisualStyleBackColor)];
-        using var control = new SubButtonBase();
-        Assert.False(property.CanResetValue(control));
-
-        control.UseVisualStyleBackColor = false;
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.True(property.CanResetValue(control));
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        property.ResetValue(control);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(property.CanResetValue(control));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_UseVisualStyleBackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ButtonBase))[nameof(ButtonBase.UseVisualStyleBackColor)];
-        using var control = new SubButtonBase();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.UseVisualStyleBackColor = false;
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> Visible_Set_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true };
-                yield return new object[] { enabled, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void ButtonBase_Visible_Set_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Image = image,
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void ButtonBase_Visible_SetDesignMode_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true };
-                yield return new object[] { enabled, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandle_TestData))]
-    public void ButtonBase_Visible_SetWithHandle_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandle_TestData))]
-    public void ButtonBase_Visible_SetDesignModeWithHandle_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_Invoke_Success()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeWithImageList_Success()
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose image list.
-            imageList.Dispose();
-            Assert.Same(imageList, control.ImageList);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeWithToolTip_Success()
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = true
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeDisposing_Success()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeDisposingWithImageList_Success()
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose image list.
-            imageList.Dispose();
-            Assert.Same(imageList, control.ImageList);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeDisposingWithToolTip_Success()
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = true
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeNotDisposing_Success()
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeNotDisposingWithImageList_Success()
-    {
-        using var imageList = new ImageList();
-        using var control = new SubButtonBase
-        {
-            ImageList = imageList
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Same(imageList, control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose image list.
-            imageList.Dispose();
-            Assert.Null(control.ImageList);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_Dispose_InvokeNotDisposingWithToolTip_Success()
-    {
-        using var control = new SubButtonBase
-        {
-            AutoEllipsis = true
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ImageList);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubButtonBase();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, Size.Empty };
-            yield return new object[] { flatStyle, new Size(-1, -2) };
-            yield return new object[] { flatStyle, new Size(1, 2) };
-            yield return new object[] { flatStyle, new Size(2, 1) };
-            yield return new object[] { flatStyle, new Size(1, 1) };
-            yield return new object[] { flatStyle, new Size(10, 20) };
-            yield return new object[] { flatStyle, new Size(30, 40) };
-            yield return new object[] { flatStyle, new Size(int.MaxValue, int.MaxValue) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ButtonBase_GetPreferredSize_Invoke_ThrowsNullReferenceException(FlatStyle flatStyle, Size proposedSize)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize));
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize));
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ButtonBase_GetPreferredSize_InvokeWithHandle_ThrowsNullReferenceException(FlatStyle flatStyle, Size proposedSize)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize));
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            Assert.Throws<NullReferenceException>(() => control.GetPreferredSize(proposedSize));
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, true)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, true)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ButtonBase_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubButtonBase();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubButtonBase();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> OnEnabledChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ButtonBase_OnEnabledChanged_Invoke_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ButtonBase_OnEnabledChanged_InvokeDesignMode_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnEnabledChanged_WithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null, enabled ? 1 : 2 };
-                    yield return new object[] { enabled, visible, image, new EventArgs(), enabled ? 1 : 2 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_WithHandle_TestData))]
-    public void ButtonBase_OnEnabledChanged_InvokeWithHandle_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_WithHandle_TestData))]
-    public void ButtonBase_OnEnabledChanged_InvokeDesignModeWithHandle_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnGotFocus_InvokeWithHandle_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            bool expectedIsHandleCreated = flatStyle == FlatStyle.System;
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), false, false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), false, false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), true, expectedIsHandleCreated };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_TestData))]
-    public void ButtonBase_OnKeyDown_Invoke_CallsKeyDown(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, bool expectedHandled, bool expectedIsHandleCreated)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_MouseDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), true };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_MouseDown_TestData))]
-    public void ButtonBase_OnKeyDown_InvokeMouseDown_CallsKeyDown(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, bool expectedHandled)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_WithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), false, 0 };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), false, 0 };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), true, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_WithHandle_TestData))]
-    public void ButtonBase_OnKeyDown_InvokeWithHandle_CallsKeyDown(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, bool expectedHandled, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_MouseDownWithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), false };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), true };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_MouseDownWithHandle_TestData))]
-    public void ButtonBase_OnKeyDown_InvokeMouseDownWithHandle_CallsKeyDown(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, bool expectedHandled)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Space, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Space, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Space, 0)]
-    [InlineData(FlatStyle.System, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.System, Keys.Enter, 0)]
-    [InlineData(FlatStyle.System, Keys.Space, 0)]
-    public void ButtonBase_OnKeyDown_GetState_ReturnsExpected(FlatStyle flatStyle, Keys key, int expected)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.OnKeyDown(new KeyEventArgs(key));
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.BM_GETSTATE));
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Space, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Space, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Space, 0)]
-    [InlineData(FlatStyle.System, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.System, Keys.Enter, 0)]
-    [InlineData(FlatStyle.System, Keys.Space, 0)]
-    public void ButtonBase_OnKeyDown_MouseDownGetState_ReturnsExpected(FlatStyle flatStyle, Keys key, int expected)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnKeyDown(new KeyEventArgs(key));
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.BM_GETSTATE));
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_OnKeyDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<NullReferenceException>(() => control.OnKeyDown(null));
-    }
-
-    public static IEnumerable<object[]> OnKeyUp_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.None) };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel) };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter) };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyUp_TestData))]
-    public void ButtonBase_OnKeyUp_Invoke_CallsKeyUp(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(0, clickCallCount);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnKeyUp_MouseDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                bool expectedIsHandleCreated = flatStyle == FlatStyle.System;
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), 0, expectedIsHandleCreated };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), 1, expectedIsHandleCreated };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), 1, expectedIsHandleCreated };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyUp_MouseDown_TestData))]
-    public void ButtonBase_OnKeyUp_InvokeMouseDown_CallsKeyUp(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, int expectedClickCallCount, bool expectedIsHandleCreated)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        int clickCallCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            clickCallCount++;
-        };
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedClickCallCount, clickCallCount);
-        Assert.True(eventArgs.Handled);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedClickCallCount, clickCallCount);
-        Assert.True(eventArgs.Handled);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyUp_TestData))]
-    public void ButtonBase_OnKeyUp_InvokeWithHandle_CallsKeyUp(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnKeyUp_MouseDownWithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                int expectedCallCount = flatStyle == FlatStyle.System ? 0 : 1;
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Cancel), 0, expectedCallCount };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Enter), 1, expectedCallCount };
-                yield return new object[] { flatStyle, enabled, new KeyEventArgs(Keys.Space), 1, expectedCallCount };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyUp_MouseDownWithHandle_TestData))]
-    public void ButtonBase_OnKeyUp_InvokeMouseDownWithHandle_CallsKeyUp(FlatStyle flatStyle, bool enabled, KeyEventArgs eventArgs, int expectedClickCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int clickCallCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            clickCallCount++;
-        };
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedClickCallCount, clickCallCount);
-        Assert.True(eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedClickCallCount, clickCallCount);
-        Assert.True(eventArgs.Handled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Space, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Space, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Space, 0)]
-    [InlineData(FlatStyle.System, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.System, Keys.Enter, 0)]
-    [InlineData(FlatStyle.System, Keys.Space, 0)]
-    public void ButtonBase_OnKeyUp_GetState_ReturnsExpected(FlatStyle flatStyle, Keys key, int expected)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.OnKeyUp(new KeyEventArgs(key));
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.BM_GETSTATE));
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Flat, Keys.Space, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Popup, Keys.Space, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Enter, 0)]
-    [InlineData(FlatStyle.Standard, Keys.Space, 0)]
-    [InlineData(FlatStyle.System, Keys.Cancel, 0)]
-    [InlineData(FlatStyle.System, Keys.Enter, 0)]
-    [InlineData(FlatStyle.System, Keys.Space, 0)]
-    public void ButtonBase_OnKeyUp_MouseDownGetState_ReturnsExpected(FlatStyle flatStyle, Keys key, int expected)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnKeyUp(new KeyEventArgs(key));
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.BM_GETSTATE));
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_OnKeyUp_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubButtonBase();
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.Throws<NullReferenceException>(() => control.OnKeyUp(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnLostFocus_Invoke_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LostFocus += handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ButtonBase_OnLostFocus_InvokeWithHandle_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LostFocus += handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void ButtonBase_OnMouseDown_Invoke_CallsMouseDown(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_WithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_WithHandle_TestData))]
-    public void ButtonBase_OnMouseDown_InvokeWithHandle_CallsMouseDown(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_OnMouseDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));
-    }
-
-    public static IEnumerable<object[]> OnMouseEnter_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                foreach (bool autoEllipsis in new bool[] { true, false })
-                {
-                    foreach (string text in new string[] { null, string.Empty, "text" })
-                    {
-                        yield return new object[] { flatStyle, enabled, autoEllipsis, text, null };
-                        yield return new object[] { flatStyle, enabled, autoEllipsis, text, new EventArgs() };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void ButtonBase_OnMouseEnter_Invoke_CallsMouseEnter(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void ButtonBase_OnMouseEnter_InvokeDesignMode_CallsMouseEnter(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text,
-            Site = mockSite.Object
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void ButtonBase_OnMouseEnter_InvokeWithHandle_CallsMouseEnter(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void ButtonBase_OnMouseEnter_InvokeDesignModeWithHandle_CallsMouseEnter(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseLeave_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                foreach (bool autoEllipsis in new bool[] { true, false })
-                {
-                    foreach (string text in new string[] { null, string.Empty, "text" })
-                    {
-                        yield return new object[] { flatStyle, enabled, autoEllipsis, text, null };
-                        yield return new object[] { flatStyle, enabled, autoEllipsis, text, new EventArgs() };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_TestData))]
-    public void ButtonBase_OnMouseLeave_Invoke_CallsMouseLeave(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoEllipsis, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoEllipsis, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_TestData))]
-    public void ButtonBase_OnMouseLeave_InvokeWithHandle_CallsMouseLeave(FlatStyle flatStyle, bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseMove_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, 0, 0) };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, -1, 0) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_TestData))]
-    public void ButtonBase_OnMouseMove_Invoke_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_TestData))]
-    public void ButtonBase_OnMouseMove_InvokeMousePressed_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_TestData))]
-    public void ButtonBase_OnMouseMove_InvokeMousePressedLeave_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnLostFocus(new EventArgs());
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseMove_WithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, -1, 0), 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_WithHandle_TestData))]
-    public void ButtonBase_OnMouseMove_InvokeWithHandle_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseMove_MousePressedWithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, -1, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, -1, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, int.MaxValue, int.MaxValue, 0), 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_MousePressedWithHandle_TestData))]
-    public void ButtonBase_OnMouseMove_InvokeMousePressedWithHandle_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseMove_MousePressedLeaveWithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), 1 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, 0, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, -1, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, -1, -1, 0), 0 };
-                yield return new object[] { flatStyle, enabled, new MouseEventArgs(MouseButtons.Right, 3, int.MaxValue, int.MaxValue, 0), 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_MousePressedLeaveWithHandle_TestData))]
-    public void ButtonBase_OnMouseMove_InvokeMousePressedLeaveWithHandle_CallsMouseMove(FlatStyle flatStyle, bool enabled, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle,
-            Enabled = enabled
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnLostFocus(new EventArgs());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_OnMouseMove_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubButtonBase();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseMove(null));
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, null };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void ButtonBase_OnMouseUp_Invoke_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void ButtonBase_OnMouseUp_InvokeWithHandle_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnParentChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ButtonBase_OnParentChanged_Invoke_CallsParentChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ButtonBase_OnParentChanged_InvokeDesignMode_CallsParentChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnParentChanged_WithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_WithHandle_TestData))]
-    public void ButtonBase_OnParentChanged_InvokeWithHandle_CallsParentChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_WithHandle_TestData))]
-    public void ButtonBase_OnParentChanged_InvokeDesignModeWithHandle_CallsParentChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnTextChanged_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null };
-            yield return new object[] { autoSize, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_TestData))]
-    public void ButtonBase_OnTextChanged_Invoke_CallsTextChanged(bool autoSize, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnTextChanged_WithParent_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_WithParent_TestData))]
-    public void ButtonBase_OnTextChanged_InvokeWithParent_CallsTextChanged(bool autoSize, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            control.TextChanged += handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Remove handler.
-            control.TextChanged -= handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_TestData))]
-    public void ButtonBase_OnTextChanged_InvokeWithHandle_CallsTextChanged(bool autoSize, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_WithParent_TestData))]
-    public void ButtonBase_OnTextChanged_InvokeWithParentWithHandle_CallsTextChanged(bool autoSize, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            control.TextChanged += handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Remove handler.
-            control.TextChanged -= handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ButtonBase_OnVisibleChanged_Invoke_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ButtonBase_OnVisibleChanged_InvokeDesignMode_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_WithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_WithHandle_TestData))]
-    public void ButtonBase_OnVisibleChanged_InvokeWithHandle_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_WithHandle_TestData))]
-    public void ButtonBase_OnVisibleChanged_InvokeDesignModeWithHandle_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButtonBase
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ResetFlagsandPaint_Invoke_Success()
-    {
-        using var control = new SubButtonBase();
-        control.ResetFlagsandPaint();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResetFlagsandPaint();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ButtonBase_ResetFlagsandPaint_InvokeWithHandle_Success()
-    {
-        using var control = new SubButtonBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ResetFlagsandPaint();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.ResetFlagsandPaint();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CANCELMODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CANCELMODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedLostFocusWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            control.OnLostFocus(new EventArgs());
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CANCELMODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedInButtonUpWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-
-            var buttonM = new Message
-            {
-                Msg = (int)PInvoke.WM_LBUTTONUP
-            };
-            int mouseUpCallCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                int callCount = 0;
-                control.LostFocus += (sender, e) => callCount++;
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_CANCELMODE,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(0, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                // Call again.
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(0, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                mouseUpCallCount++;
-            };
-            control.WndProc(ref buttonM);
-            Assert.Equal(1, mouseUpCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CANCELMODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, 1)]
-    [InlineData(FlatStyle.Popup, 1)]
-    [InlineData(FlatStyle.Standard, 1)]
-    [InlineData(FlatStyle.System, 0)]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedWithHandle_Success(FlatStyle flatStyle, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CANCELMODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedLostFocusWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnLostFocus(new EventArgs());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CANCELMODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCancelModeMousePressedInButtonUpWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var buttonM = new Message
-        {
-            Msg = (int)PInvoke.WM_LBUTTONUP
-        };
-        int mouseUpCallCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CANCELMODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            mouseUpCallCount++;
-        };
-        control.WndProc(ref buttonM);
-        Assert.Equal(1, mouseUpCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            int callCount = 0;
-            control.MouseCaptureChanged += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            int callCount = 0;
-            control.MouseCaptureChanged += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedLostFocusWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            control.OnLostFocus(new EventArgs());
-            int callCount = 0;
-            control.MouseCaptureChanged += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedLostFocusInButtonUpWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-
-            var buttonM = new Message
-            {
-                Msg = (int)PInvoke.WM_LBUTTONUP
-            };
-            int mouseUpCallCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                int callCount = 0;
-                control.MouseCaptureChanged += (sender, e) =>
-                {
-                    Assert.Same(control, sender);
-                    Assert.Same(EventArgs.Empty, e);
-                    callCount++;
-                };
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(1, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                // Call again.
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(2, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                mouseUpCallCount++;
-            };
-            control.WndProc(ref buttonM);
-            Assert.Equal(1, mouseUpCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseCaptureChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CAPTURECHANGED,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, 1)]
-    [InlineData(FlatStyle.Popup, 1)]
-    [InlineData(FlatStyle.Standard, 1)]
-    [InlineData(FlatStyle.System, 0)]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedWithHandle_Success(FlatStyle flatStyle, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseCaptureChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CAPTURECHANGED,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedLostFocusWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnLostFocus(new EventArgs());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseCaptureChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CAPTURECHANGED,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeCaptureChangedMousePressedInButtonUpWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var buttonM = new Message
-        {
-            Msg = (int)PInvoke.WM_LBUTTONUP
-        };
-        int mouseUpCallCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            int callCount = 0;
-            control.MouseCaptureChanged += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            mouseUpCallCount++;
-        };
-        control.WndProc(ref buttonM);
-        Assert.Equal(1, mouseUpCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeClick_Success(FlatStyle flatStyle)
-    {
-        using SubButtonBase control = new()
-        {
-            FlatStyle = flatStyle
-        };
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        Message m = new()
-        {
-            Msg = (int)PInvoke.BM_CLICK,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(250, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeClickButtonButtonBase_Success(FlatStyle flatStyle)
-    {
-        using ButtonControl control = new()
-        {
-            FlatStyle = flatStyle
-        };
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        int performCallCount = 0;
-        control.PerformClickAction = () => performCallCount++;
-
-        Message m = new()
-        {
-            Msg = (int)PInvoke.BM_CLICK,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(250, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, performCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeClickWithHandle_Success(FlatStyle flatStyle)
-    {
-        using SubButtonBase control = new()
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        Message m = new()
-        {
-            Msg = (int)PInvoke.BM_CLICK,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(250, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeClickButtonControlWithHandle_Success(FlatStyle flatStyle)
-    {
-        using ButtonControl control = new()
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        int performCallCount = 0;
-        control.PerformClickAction = () => performCallCount++;
-        Message m = new()
-        {
-            Msg = (int)PInvoke.BM_CLICK,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(250, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, performCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            int callCount = 0;
-            control.LostFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            int callCount = 0;
-            control.LostFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedLostFocusWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-            control.OnLostFocus(new EventArgs());
-            int callCount = 0;
-            control.LostFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedLostFocusInButtonUpWithoutHandle_Success(FlatStyle flatStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-
-            var buttonM = new Message
-            {
-                Msg = (int)PInvoke.WM_LBUTTONUP
-            };
-            int mouseUpCallCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                int callCount = 0;
-                control.LostFocus += (sender, e) =>
-                {
-                    Assert.Same(control, sender);
-                    Assert.Same(EventArgs.Empty, e);
-                    callCount++;
-                };
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_KILLFOCUS,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(1, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                // Call again.
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.Equal(2, callCount);
-                Assert.True(control.IsHandleCreated);
-
-                mouseUpCallCount++;
-            };
-            control.WndProc(ref buttonM);
-            Assert.Equal(1, mouseUpCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_KILLFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, 2)]
-    [InlineData(FlatStyle.Popup, 2)]
-    [InlineData(FlatStyle.Standard, 2)]
-    [InlineData(FlatStyle.System, 1)]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedWithHandle_Success(FlatStyle flatStyle, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_KILLFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedLostFocusWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        control.OnLostFocus(new EventArgs());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_KILLFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeKillFocusMousePressedInButtonUpWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var buttonM = new Message
-        {
-            Msg = (int)PInvoke.WM_LBUTTONUP
-        };
-        int mouseUpCallCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            int callCount = 0;
-            control.LostFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(2, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            mouseUpCallCount++;
-        };
-        control.WndProc(ref buttonM);
-        Assert.Equal(1, mouseUpCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void ButtonBase_WndProc_InvokeMouseHoverWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_MouseUp_TestData()
-    {
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, -1, -2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void ButtonBase_WndProc_InvokeMouseUpWithoutHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            int callCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void ButtonBase_WndProc_InvokeMouseUpWithoutHandleNotSelectable_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            control.SetStyle(ControlStyles.Selectable, false);
-            int callCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONUP)]
-    [InlineData((int)PInvoke.WM_MBUTTONUP)]
-    [InlineData((int)PInvoke.WM_RBUTTONUP)]
-    [InlineData((int)PInvoke.WM_XBUTTONUP)]
-    public void ButtonBase_WndProc_InvokeMouseUpWithoutHandleNotEnabled_CallsMouseUp(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                Enabled = false
-            };
-            int callCount = 0;
-            control.MouseUp += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)250, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void ButtonBase_WndProc_InvokeMouseUpWithHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubButtonBase();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void ButtonBase_WndProc_InvokeMouseUpWithHandleNotSelectable_DoesNotCallMouseUp(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubButtonBase();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        control.SetStyle(ControlStyles.Selectable, false);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONUP)]
-    [InlineData((int)PInvoke.WM_MBUTTONUP)]
-    [InlineData((int)PInvoke.WM_RBUTTONUP)]
-    [InlineData((int)PInvoke.WM_XBUTTONUP)]
-    public void ButtonBase_WndProc_InvokeMouseUpWithHandleNotEnabled_CallsMouseUp(int msg)
-    {
-        using var control = new SubButtonBase
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = msg,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectCommandWithoutHandle_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, IntPtr.Zero, IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(123, 456), IntPtr.Zero, 0 };
-
-        yield return new object[] { FlatStyle.Popup, IntPtr.Zero, IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(123, 456), IntPtr.Zero, 0 };
-
-        yield return new object[] { FlatStyle.Standard, IntPtr.Zero, IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), IntPtr.Zero, 0 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(123, 456), IntPtr.Zero, 0 };
-
-        yield return new object[] { FlatStyle.System, IntPtr.Zero, (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(123, 456), (IntPtr)250, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommandWithoutHandle_TestData))]
-    public void ButtonBase_WndProc_InvokeReflectCommandWithoutHandle_Success(FlatStyle flatStyle, IntPtr wParam, IntPtr expectedResult, int expectedCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButtonBase
-            {
-                FlatStyle = flatStyle
-            };
-            int callCount = 0;
-            control.Click += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-
-            var m = new Message
-            {
-                Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(expectedCallCount, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommandWithoutHandle_TestData))]
-    public void ButtonBase_WndProc_InvokeReflectCommandWithHandle_Success(FlatStyle flatStyle, IntPtr wParam, IntPtr expectedResult, int expectedCallCount)
-    {
-        using var control = new SubButtonBase
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_SetState_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, (IntPtr)250 };
-        yield return new object[] { FlatStyle.Popup, (IntPtr)250 };
-        yield return new object[] { FlatStyle.Standard, (IntPtr)250 };
-        yield return new object[] { FlatStyle.System, IntPtr.Zero };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_SetState_TestData))]
-    public void ButtonBase_WndProc_InvokeSetStateWithoutHandle_Success(FlatStyle flatStyle, IntPtr expectedResult)
-    {
-        using (new NoAssertContext())
-        {
-            using SubButtonBase control = new()
-            {
-                FlatStyle = flatStyle
-            };
-
-            Message m = new()
-            {
-                Msg = (int)PInvoke.BM_SETSTATE,
-                Result = 250
-            };
-
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_SetState_TestData))]
-    public void ButtonBase_WndProc_InvokeSetStateWithHandle_Success(FlatStyle flatStyle, IntPtr expectedResult)
-    {
-        using SubButtonBase control = new()
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Message m = new()
-        {
-            Msg = (int)PInvoke.BM_SETSTATE,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubButton : Button
-    {
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-    }
-
-    private class ButtonControl : ButtonBase, IButtonControl
-    {
-        public DialogResult DialogResult { get; set; }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public void NotifyDefault(bool value) => throw new NotImplementedException();
-
-        public Action PerformClickAction { get; set; }
-
-        public void PerformClick() => PerformClickAction();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class SubButtonBase : ButtonBase
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsDefault
-        {
-            get => base.IsDefault;
-            set => base.IsDefault = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-        
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs kevent) => base.OnKeyDown(kevent);
-
-        public new void OnKeyUp(KeyEventArgs kevent) => base.OnKeyUp(kevent);
-
-        public new void OnLostFocus(EventArgs e) => base.OnLostFocus(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs eventargs) => base.OnMouseEnter(eventargs);
-
-        public new void OnMouseLeave(EventArgs eventargs) => base.OnMouseLeave(eventargs);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnPaint(PaintEventArgs pevent) => base.OnPaint(pevent);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new void ResetFlagsandPaint() => base.ResetFlagsandPaint();
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonRenderingTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonRenderingTests.cs
deleted file mode 100644
index f09f2bf9469..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonRenderingTests.cs
+++ /dev/null
@@ -1,254 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public class ButtonRenderingTests
-{
-    [WinFormsFact]
-    public unsafe void CaptureButton()
-    {
-        using Button button = new Button();
-
-        using var emf = new EmfScope();
-        button.PrintToMetafile(emf);
-
-        var types = new List<ENHANCED_METAFILE_RECORD_TYPE>();
-        var details = new List<string>();
-        emf.Enumerate((ref EmfRecord record) =>
-        {
-            types.Add(record.Type);
-            details.Add(record.ToString());
-            return true;
-        });
-    }
-
-    [WinFormsFact]
-    public unsafe void Button_VisualStyles_off_Default_LineDrawing()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using Button button = new Button();
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = button.Bounds;
-
-        button.PrintToMetafile(emf);
-
-        emf.Validate(
-            state,
-            Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT), 1),
-            Validate.LineTo(
-                (bounds.Right - 1, 0), (0, 0),
-                State.PenColor(SystemColors.ControlLightLight)),
-            Validate.LineTo(
-                (0, 0), (0, bounds.Bottom - 1),
-                State.PenColor(SystemColors.ControlLightLight)),
-            Validate.LineTo(
-                (0, bounds.Bottom - 1), (bounds.Right - 1, bounds.Bottom - 1),
-                State.PenColor(SystemColors.ControlDarkDark)),
-            Validate.LineTo(
-                (bounds.Right - 1, bounds.Bottom - 1), (bounds.Right - 1, -1),
-                State.PenColor(SystemColors.ControlDarkDark)),
-            Validate.LineTo(
-                (bounds.Right - 2, 1), (1, 1),
-                State.PenColor(SystemColors.Control)),
-            Validate.LineTo(
-                (1, 1), (1, bounds.Bottom - 2),
-                State.PenColor(SystemColors.Control)),
-            Validate.LineTo(
-                (1, bounds.Bottom - 2), (bounds.Right - 2, bounds.Bottom - 2),
-                State.PenColor(SystemColors.ControlDark)),
-            Validate.LineTo(
-                (bounds.Right - 2, bounds.Bottom - 2), (bounds.Right - 2, 0),
-                State.PenColor(SystemColors.ControlDark)));
-    }
-
-    [WinFormsFact]
-    public unsafe void Button_VisualStyles_on_Default_LineDrawing()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using Button button = new Button();
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = button.Bounds;
-
-        button.PrintToMetafile(emf);
-
-        /*
-
-        [ENHMETAHEADER] Bounds: {0, 0, 74, 22 (LTRB)} Device Size: {Width=1024, Height=768} Header Size: 108
-        [EMRINTERSECTCLIPRECT] RECT: {0, 0, 75, 23 (LTRB)}
-        [EMRSETVIEWPORTORGEX] Point: {X=0,Y=0}
-        [EMRCREATEBRUSHINDIRECT] Index: 1 Style: SOLID Color: [R=240, G=240, B=240] (COLOR_MENU, COLOR_BTNFACE, COLOR_MENUBAR)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRBITBLT] Bounds: {0, 0, -1, -1 (LTRB)} Destination: {0, 0, 120, 0 (LTRB)} Rop: PATCOPY Source DC Color: [R=0, G=0, B=0] (COLOR_BACKGROUND, COLOR_MENUTEXT, COLOR_WINDOWTEXT, COLOR_CAPTIONTEXT, COLOR_BTNTEXT, COLOR_INACTIVECAPTIONTEXT, COLOR_INFOTEXT)
-        [EMRSELECTOBJECT] StockObject: WHITE_BRUSH
-        [EMRDELETEOBJECT] Index: 1
-        [EMRCREATEBRUSHINDIRECT] Index: 1 Style: SOLID Color: [R=240, G=240, B=240] (COLOR_MENU, COLOR_BTNFACE, COLOR_MENUBAR)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRBITBLT] Bounds: {0, 0, -1, -1 (LTRB)} Destination: {0, 0, 120, 0 (LTRB)} Rop: PATCOPY Source DC Color: [R=0, G=0, B=0] (COLOR_BACKGROUND, COLOR_MENUTEXT, COLOR_WINDOWTEXT, COLOR_CAPTIONTEXT, COLOR_BTNTEXT, COLOR_INACTIVECAPTIONTEXT, COLOR_INFOTEXT)
-        [EMRSELECTOBJECT] StockObject: WHITE_BRUSH
-        [EMRDELETEOBJECT] Index: 1
-        [EMRSETVIEWPORTORGEX] Point: {X=0,Y=0}
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 75, 23 (LTRB)} Rects: 1 Rect index 0: {0, 0, 75, 23 (LTRB)}
-        [EMRINTERSECTCLIPRECT] RECT: {0, 0, 75, 23 (LTRB)}
-        [EMRALPHABLEND]
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 75, 23 (LTRB)} Rects: 1 Rect index 0: {0, 0, 75, 23 (LTRB)}
-        [EMREOF]
-
-        */
-    }
-
-    [WinFormsFact]
-    public unsafe void Button_VisualStyles_off_Default_WithText_LineDrawing()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using Button button = new Button { Text = "Hello" };
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = button.Bounds;
-
-        button.PrintToMetafile(emf);
-
-        emf.Validate(
-            state,
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT),
-            Validate.TextOut("Hello"),
-            Validate.LineTo(
-                (bounds.Right - 1, 0), (0, 0),
-                State.PenColor(SystemColors.ControlLightLight)),
-            Validate.LineTo(
-                (0, 0), (0, bounds.Bottom - 1),
-                State.PenColor(SystemColors.ControlLightLight)),
-            Validate.LineTo(
-                (0, bounds.Bottom - 1), (bounds.Right - 1, bounds.Bottom - 1),
-                State.PenColor(SystemColors.ControlDarkDark)),
-            Validate.LineTo(
-                (bounds.Right - 1, bounds.Bottom - 1), (bounds.Right - 1, -1),
-                State.PenColor(SystemColors.ControlDarkDark)),
-            Validate.LineTo(
-                (bounds.Right - 2, 1), (1, 1),
-                State.PenColor(SystemColors.Control)),
-            Validate.LineTo(
-                (1, 1), (1, bounds.Bottom - 2),
-                State.PenColor(SystemColors.Control)),
-            Validate.LineTo(
-                (1, bounds.Bottom - 2), (bounds.Right - 2, bounds.Bottom - 2),
-                State.PenColor(SystemColors.ControlDark)),
-            Validate.LineTo(
-                (bounds.Right - 2, bounds.Bottom - 2), (bounds.Right - 2, 0),
-                State.PenColor(SystemColors.ControlDark)));
-    }
-
-    [WinFormsFact]
-    public unsafe void Button_VisualStyles_on_Default_WithText_LineDrawing()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using Button button = new Button { Text = "Hello" };
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = button.Bounds;
-
-        button.PrintToMetafile(emf);
-
-        /*
-
-        [ENHMETAHEADER] Bounds: {0, 0, 74, 22 (LTRB)} Device Size: {Width=3840, Height=2160} Header Size: 108
-        [EMRINTERSECTCLIPRECT] RECT: {0, 0, 75, 23 (LTRB)}
-        [EMRSETVIEWPORTORGEX] Point: {X=0,Y=0}
-        [EMRCREATEBRUSHINDIRECT] Index: 1 Style: SOLID Color: [R=240, G=240, B=240] (COLOR_MENU, COLOR_BTNFACE, COLOR_MENUBAR)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRBITBLT] Bounds: {0, 0, -1, -1 (LTRB)} Destination: {0, 0, 120, 0 (LTRB)} Rop: PATCOPY Source DC Color: [R=0, G=0, B=0] (COLOR_BACKGROUND, COLOR_MENUTEXT, COLOR_WINDOWTEXT, COLOR_CAPTIONTEXT, COLOR_BTNTEXT, COLOR_INACTIVECAPTIONTEXT, COLOR_INFOTEXT)
-        [EMRSELECTOBJECT] StockObject: WHITE_BRUSH
-        [EMRDELETEOBJECT] Index: 1
-        [EMRCREATEBRUSHINDIRECT] Index: 1 Style: SOLID Color: [R=240, G=240, B=240] (COLOR_MENU, COLOR_BTNFACE, COLOR_MENUBAR)
-        [EMRSELECTOBJECT] Index: 1
-        [EMRBITBLT] Bounds: {0, 0, -1, -1 (LTRB)} Destination: {0, 0, 120, 0 (LTRB)} Rop: PATCOPY Source DC Color: [R=0, G=0, B=0] (COLOR_BACKGROUND, COLOR_MENUTEXT, COLOR_WINDOWTEXT, COLOR_CAPTIONTEXT, COLOR_BTNTEXT, COLOR_INACTIVECAPTIONTEXT, COLOR_INFOTEXT)
-        [EMRSELECTOBJECT] StockObject: WHITE_BRUSH
-        [EMRDELETEOBJECT] Index: 1
-        [EMRSETVIEWPORTORGEX] Point: {X=0,Y=0}
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 75, 23 (LTRB)} Rects: 1 Rect index 0: {0, 0, 75, 23 (LTRB)}
-        [EMRINTERSECTCLIPRECT] RECT: {0, 0, 75, 23 (LTRB)}
-        [EMRALPHABLEND]
-        [EMREXTSELECTCLIPRGN] Mode: COPY Bounds: {0, 0, 75, 23 (LTRB)} Rects: 1 Rect index 0: {0, 0, 75, 23 (LTRB)}
-        [EMRSAVEDC]
-        [EMRSETICMMODE] Mode: ICM_OFF
-        [EMREXTSELECTCLIPRGN] Mode: Set Default
-        [EMRSETBKMODE] Mode: BKMODE_TRANSPARENT
-        [EMRSETTEXTCOLOR] Color: [R=0, G=0, B=0] (COLOR_BACKGROUND, COLOR_MENUTEXT, COLOR_WINDOWTEXT, COLOR_CAPTIONTEXT, COLOR_BTNTEXT, COLOR_INACTIVECAPTIONTEXT, COLOR_INFOTEXT)
-        [EMRSETTEXTALIGN] Mode: TA_BASELINE
-        [EMREXTCREATEFONTINDIRECTW] Index: 1 FaceName: 'Segoe UI' Height: -12 Weight: FW_NORMAL
-        [EMRSELECTOBJECT] Index: 1
-        [EMREXTTEXTOUTW] Bounds: {24, 4, 51, 18 (LTRB)} Text: 'Hello'
-        [EMRSELECTOBJECT] StockObject: SYSTEM_FONT
-        [EMRRESTOREDC] Index: -1
-        [EMRDELETEOBJECT] Index: 1
-        [EMREOF]
-
-        */
-    }
-
-    [WinFormsFact]
-    public unsafe void CaptureButtonOnForm()
-    {
-        using Form form = new Form();
-        using Button button = new Button();
-        form.Controls.Add(button);
-
-        using var emf = new EmfScope();
-        form.PrintToMetafile(emf);
-
-        var details = emf.RecordsToString();
-    }
-
-    [WinFormsFact]
-    public unsafe void Button_FlatStyle_WithText_Rectangle()
-    {
-        using Button button = new Button
-        {
-            Text = "Flat Style",
-            FlatStyle = FlatStyle.Flat,
-        };
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = button.Bounds;
-
-        button.PrintToMetafile(emf);
-
-        emf.Validate(
-            state,
-            Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_BITBLT),
-            Validate.TextOut("Flat Style"),
-            Validate.Rectangle(
-                new Rectangle(0, 0, button.Width - 1, button.Height - 1),
-                State.PenColor(Color.Black),
-                State.PenStyle(PEN_STYLE.PS_ENDCAP_ROUND),
-                State.BrushStyle(BRUSH_STYLE.BS_NULL),       // Regressed in https://github.com/dotnet/winforms/pull/3667
-                State.Rop2(R2_MODE.R2_COPYPEN)));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonTests.cs
deleted file mode 100644
index dbf46b9c829..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ButtonTests.cs
+++ /dev/null
@@ -1,3791 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static Interop.UiaCore;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ButtonTests
-{
-    [WinFormsFact]
-    public void Button_Ctor_Default()
-    {
-        using var control = new SubButton();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoEllipsis);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(75, 23), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(75, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(DialogResult.None, control.DialogResult);
-        Assert.Equal(new Rectangle(0, 0, 75, 23), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.NotNull(control.FlatAppearance);
-        Assert.Same(control.FlatAppearance, control.FlatAppearance);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Null(control.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.ImageAlign);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsDefault);
-        Assert.False(control.IsMirrored);
-        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("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(75, 23), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(75, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(75, 23), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.TextAlign);
-        Assert.Equal(TextImageRelation.Overlay, control.TextImageRelation);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.True(control.UseMnemonic);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(75, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubButton();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x5601000B, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x5601000B)]
-    [InlineData(false, 0x56010000)]
-    public void Button_CreateParams_GetUserPaint_ReturnsExpected(bool userPaint, int expectedStyle)
-    {
-        using var control = new SubButton();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, 0x5601000B)]
-    [InlineData(FlatStyle.Flat, false, 0x5601000B)]
-    [InlineData(FlatStyle.Popup, true, 0x5601000B)]
-    [InlineData(FlatStyle.Popup, false, 0x5601000B)]
-    [InlineData(FlatStyle.Standard, true, 0x5601000B)]
-    [InlineData(FlatStyle.Standard, false, 0x5601000B)]
-    [InlineData(FlatStyle.System, true, 0x56012F01)]
-    [InlineData(FlatStyle.System, false, 0x56012F00)]
-    public void Button_CreateParams_GetIsDefault_ReturnsExpected(FlatStyle flatStyle, bool isDefault, int expectedStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            IsDefault = isDefault
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CreateParams_GetIsDefault_TestData()
-    {
-        foreach (FlatStyle flatStyle in new FlatStyle[] { FlatStyle.Flat, FlatStyle.Popup, FlatStyle.Standard })
-        {
-            foreach (ContentAlignment textAlign in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                yield return new object[] { flatStyle, RightToLeft.Yes, textAlign, 0x5601000B, 0x7000 };
-                yield return new object[] { flatStyle, RightToLeft.No, textAlign, 0x5601000B, 0 };
-                yield return new object[] { flatStyle, RightToLeft.Inherit, textAlign, 0x5601000B, 0 };
-            }
-        }
-
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomLeft, 0x56012A00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomCenter, 0x56012B00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.BottomRight, 0x56012900, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleLeft, 0x56012E00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleCenter, 0x56012F00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.MiddleRight, 0x56012D00, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopLeft, 0x56012600, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopCenter, 0x56012700, 0x6000 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Yes, ContentAlignment.TopRight, 0x56012500, 0x6000 };
-
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomLeft, 0x56012900, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomCenter, 0x56012B00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.BottomRight, 0x56012A00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleLeft, 0x56012D00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleCenter, 0x56012F00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.MiddleRight, 0x56012E00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopLeft, 0x56012500, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopCenter, 0x56012700, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.No, ContentAlignment.TopRight, 0x56012600, 0 };
-
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomLeft, 0x56012900, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomCenter, 0x56012B00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.BottomRight, 0x56012A00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleLeft, 0x56012D00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleCenter, 0x56012F00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.MiddleRight, 0x56012E00, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopLeft, 0x56012500, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopCenter, 0x56012700, 0 };
-        yield return new object[] { FlatStyle.System, RightToLeft.Inherit, ContentAlignment.TopRight, 0x56012600, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateParams_GetIsDefault_TestData))]
-    public void Button_CreateParams_GetTextAlign_ReturnsExpected(FlatStyle flatStyle, RightToLeft rightToLeft, ContentAlignment textAlign, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            RightToLeft = rightToLeft,
-            TextAlign = textAlign
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(75, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void Button_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubButton();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Button_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Button_AutoSizeMode_SetWithCustomLayoutEngineParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubButton
-        {
-            Parent = parent
-        };
-        parent.SetLayoutEngine(new SubLayoutEngine());
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = base.LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-    }
-
-    private class SubLayoutEngine : LayoutEngine
-    {
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void Button_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Button_AutoSizeMode_SetWithParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Button_AutoSizeMode_SetWithCustomLayoutEngineParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubButton
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    public void Button_AutoSize_SetCachedPreferredSize_DoesNotInvalidate()
-    {
-        using var control = new Button
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = AutoSizeMode.GrowOnly,
-            Text = "text"
-        };
-        Assert.Equal(new Size(75, 24), control.GetPreferredSize(Size.Empty));
-
-        // Set font.
-        Size newSize = TextRenderer.MeasureText(control.Text, control.Font);
-        control.AutoSizeMode = AutoSizeMode.GrowAndShrink;
-        Assert.Equal(new Size(75, 24), control.GetPreferredSize(Size.Empty));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoSizeMode>]
-    public void Button_AutoSizeMode_SetInvalid_ThrowsInvalidEnumArgumentException(AutoSizeMode value)
-    {
-        using var control = new Button();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoSizeMode = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DialogResult>]
-    public void Button_DialogResult_Set_GetReturnsExpected(DialogResult value)
-    {
-        using var control = new Button
-        {
-            DialogResult = value
-        };
-        Assert.Equal(value, control.DialogResult);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DialogResult = value;
-        Assert.Equal(value, control.DialogResult);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DialogResult>]
-    public void Button_DialogResult_SetWithHandle_GetReturnsExpected(DialogResult value)
-    {
-        using var control = new Button();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DialogResult = value;
-        Assert.Equal(value, control.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DialogResult = value;
-        Assert.Equal(value, control.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DialogResult>]
-    public void Button_DialogResult_SetInvalidValue_ThrowsInvalidEnumArgumentException(DialogResult value)
-    {
-        using var control = new Button();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DialogResult = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void Button_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubButton
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    public void Button_Font_SetCachedPreferredSize_Invalidates()
-    {
-        using var font = new Font("Arial", 100f);
-        using var control = new Button
-        {
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            FlatStyle = FlatStyle.System,
-            Text = "text"
-        };
-        Size oldSize = TextRenderer.MeasureText(control.Text, control.Font);
-        Assert.Equal(oldSize + new Size(14, 9), control.GetPreferredSize(Size.Empty));
-
-        // Set font.
-        Size newSize = TextRenderer.MeasureText(control.Text, font);
-        control.Font = font;
-        Assert.Equal(newSize + new Size(14, 9), control.GetPreferredSize(Size.Empty));
-    }
-
-    [WinFormsFact]
-    public void Button_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new Button();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null, string.Empty };
-            yield return new object[] { autoSize, string.Empty, string.Empty };
-            yield return new object[] { autoSize, "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void Button_Text_Set_GetReturnsExpected(bool autoSize, string value, string expected)
-    {
-        using var control = new SubButton
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithParent_TestData()
-    {
-        yield return new object[] { true, null, string.Empty, 0 };
-        yield return new object[] { true, string.Empty, string.Empty, 0 };
-        yield return new object[] { true, "text", "text", 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParent_TestData))]
-    public void Button_Text_SetWithParent_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Text_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null, string.Empty, 0 };
-            yield return new object[] { autoSize, string.Empty, string.Empty, 0 };
-            yield return new object[] { autoSize, "text", "text", 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithHandle_TestData))]
-    public void Button_Text_SetWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButton
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, null, string.Empty, 0 };
-        yield return new object[] { true, string.Empty, string.Empty, 0 };
-        yield return new object[] { true, "text", "text", 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParentWithHandle_TestData))]
-    public void Button_Text_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Button
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(expectedParentLayoutCallCount, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    public void Button_Text_SetCachedPreferredSize_Invalidates()
-    {
-        using var control = new Button
-        {
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            FlatStyle = FlatStyle.System,
-            Text = "text"
-        };
-        Size oldSize = TextRenderer.MeasureText(control.Text, control.Font);
-        Assert.Equal(oldSize + new Size(14, 9), control.GetPreferredSize(Size.Empty));
-
-        // Set font.
-        Size newSize = TextRenderer.MeasureText("NewText", control.Font);
-        control.Text = "NextText";
-        Assert.Equal(newSize + new Size(14, 9), control.GetPreferredSize(Size.Empty));
-    }
-
-    [WinFormsFact]
-    public void Button_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_Invoke_ReturnsExpected_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.False(control.IsHandleCreated);
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleStates.None, instance.State);
-        Assert.Equal(AccessibleRole.None, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_Invoke_ReturnsExpected_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        control.CreateControl();
-        Assert.True(control.IsHandleCreated);
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleStates.Focusable, instance.State);
-        Assert.Equal(AccessibleRole.PushButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, FlatStyle.Flat, AccessibleStates.Pressed | AccessibleStates.Focusable, AccessibleRole.PushButton)]
-    [InlineData(true, FlatStyle.Popup, AccessibleStates.Pressed | AccessibleStates.Focusable, AccessibleRole.PushButton)]
-    [InlineData(true, FlatStyle.Standard, AccessibleStates.Pressed | AccessibleStates.Focusable, AccessibleRole.PushButton)]
-    [InlineData(true, FlatStyle.System, AccessibleStates.Focusable, AccessibleRole.PushButton)]
-    [InlineData(false, FlatStyle.Flat, AccessibleStates.None, AccessibleRole.None)]
-    [InlineData(false, FlatStyle.Popup, AccessibleStates.None, AccessibleRole.None)]
-    [InlineData(false, FlatStyle.Standard, AccessibleStates.None, AccessibleRole.None)]
-    [InlineData(false, FlatStyle.System, AccessibleStates.None, AccessibleRole.None)]
-    public void Button_CreateAccessibilityInstance_InvokeMouseDown_ReturnsExpected(bool createControl, FlatStyle flatStyle, AccessibleStates expectedState, AccessibleRole expectedRole)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedState, instance.State);
-        Assert.Equal(expectedRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-
-        control.CreateControl();
-        Assert.True(control.IsHandleCreated);
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleStates.Focusable, instance.State);
-        Assert.Equal(AccessibleRole.HelpBalloon, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-
-        Assert.False(control.IsHandleCreated);
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleStates.None, instance.State);
-        Assert.Equal(AccessibleRole.HelpBalloon, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_InvokeDoDefaultAction_CallsOnClick_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        control.CreateControl();
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        instance.DoDefaultAction();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_CreateAccessibilityInstance_InvokeDoDefaultAction_CallsOnClick_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        Button.ButtonBaseAccessibleObject instance = Assert.IsAssignableFrom<Button.ButtonBaseAccessibleObject>(control.CreateAccessibilityInstance());
-        instance.DoDefaultAction();
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubButton();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_System_TestData()
-    {
-        yield return new object[] { AutoSizeMode.GrowAndShrink, Size.Empty, new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(14, 9) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(14, 9) };
-
-        yield return new object[] { AutoSizeMode.GrowOnly, Size.Empty, new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 2), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(2, 1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(10, 20), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, 40), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(75, 23) };
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_System_TestData))]
-    public void Button_GetPreferredSize_InvokeSystem_ReturnsExpected(AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = autoSizeMode
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_SystemWithPadding_TestData()
-    {
-        yield return new object[] { AutoSizeMode.GrowAndShrink, Size.Empty, new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(18, 15) };
-
-        yield return new object[] { AutoSizeMode.GrowOnly, Size.Empty, new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 2), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(2, 1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 1), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(10, 20), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, 40), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(75, 23) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(75, 23) };
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_SystemWithPadding_TestData))]
-    public void Button_GetPreferredSize_InvokeSystemWithPadding_ReturnsExpected(AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = autoSizeMode,
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_SystemWithPaddingSmallSize_TestData()
-    {
-        yield return new object[] { AutoSizeMode.GrowAndShrink, Size.Empty, new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(18, 15) };
-
-        yield return new object[] { AutoSizeMode.GrowOnly, Size.Empty, new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 2), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(2, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(1, 1), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(10, 20), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(18, 15) };
-        yield return new object[] { AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(18, 15) };
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_SystemWithPaddingSmallSize_TestData))]
-    public void Button_GetPreferredSize_InvokeSystemWithPaddingSmallSize_ReturnsExpected(AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = autoSizeMode,
-            Size = new Size(14, 9),
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_SystemWithText_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(-2, -1) };
-        yield return new object[] { new Size(-1, -1) };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(2, 1) };
-        yield return new object[] { new Size(1, 1) };
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_SystemWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeSystemGrowOnlyWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = AutoSizeMode.GrowOnly,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 6 + 9), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 6 + 9), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_SystemWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeSystemGrowAndShrinkWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.System,
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(14, 9) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(14, 9) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_Flat_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(8, 8) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(8, 8) };
-
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(6, 6) };
-
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(6, 6) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(6, 6) };
-
-        foreach (FlatStyle flatStyle in new FlatStyle[] { FlatStyle.Flat, FlatStyle.Popup, FlatStyle.Standard })
-        {
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, Size.Empty, new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 2), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(2, 1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(10, 20), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, 40), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(75, 23) };
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_Flat_TestData))]
-    public void Button_GetPreferredSize_InvokeFlat_ReturnsExpected(FlatStyle flatStyle, AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            AutoSizeMode = autoSizeMode
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_FlatWithPadding_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(12, 14) };
-
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Popup, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(10, 12) };
-
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(10, 12) };
-        yield return new object[] { FlatStyle.Standard, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(10, 12) };
-
-        foreach (FlatStyle flatStyle in new FlatStyle[] { FlatStyle.Flat, FlatStyle.Popup, FlatStyle.Standard })
-        {
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, Size.Empty, new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 2), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(2, 1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 1), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(10, 20), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, 40), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(75, 23) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(75, 23) };
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithPadding_TestData))]
-    public void Button_GetPreferredSize_InvokeFlatWithPadding_ReturnsExpected(FlatStyle flatStyle, AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            AutoSizeMode = autoSizeMode,
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_FlatWithPaddingSmallSize_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(12, 14) };
-
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, Size.Empty, new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(1, 2), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(2, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(1, 1), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(10, 20), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(30, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(12, 14) };
-        yield return new object[] { FlatStyle.Flat, AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(12, 14) };
-
-        foreach (FlatStyle flatStyle in new FlatStyle[] { FlatStyle.Popup, FlatStyle.Standard })
-        {
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, Size.Empty, new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(-1, -2), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(-2, -1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(-1, -1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(1, 2), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(2, 1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(1, 1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(10, 20), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(30, 40), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(30, int.MaxValue), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, 40), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowAndShrink, new Size(int.MaxValue, int.MaxValue), new Size(10, 12) };
-
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, Size.Empty, new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -2), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-2, -1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(-1, -1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 2), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(2, 1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(1, 1), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(10, 20), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, 40), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(30, int.MaxValue), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, 40), new Size(10, 12) };
-            yield return new object[] { flatStyle, AutoSizeMode.GrowOnly, new Size(int.MaxValue, int.MaxValue), new Size(10, 12) };
-        }
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithPaddingSmallSize_TestData))]
-    public void Button_GetPreferredSize_InvokeFlatWithPaddingSmallSize_ReturnsExpected(FlatStyle flatStyle, AutoSizeMode autoSizeMode, Size proposedSize, Size expected)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle,
-            AutoSizeMode = autoSizeMode,
-            Size = new Size(6, 6),
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(expected, size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_FlatWithText_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(-2, -1) };
-        yield return new object[] { new Size(-1, -1) };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(2, 1) };
-        yield return new object[] { new Size(1, 1) };
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeFlatGrowOnlyWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Flat,
-            AutoSizeMode = AutoSizeMode.GrowOnly,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 8), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 8), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeFlatGrowAndShrinkWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Flat,
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(11, 15) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(11, 15) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokePopupGrowOnlyWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Popup,
-            AutoSizeMode = AutoSizeMode.GrowOnly,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokePopupGrowAndShrinkWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Popup,
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(9, 13) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(9, 13) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeStandardGrowOnlyWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Standard,
-            AutoSizeMode = AutoSizeMode.GrowOnly,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(75, minSize.Height + 13 + 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3647")]
-    [WinFormsTheory(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/3647")]
-    [MemberData(nameof(GetPreferredSize_FlatWithText_TestData))]
-    public void Button_GetPreferredSize_InvokeStandardGrowAndShrinkWithText_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = FlatStyle.Standard,
-            AutoSizeMode = AutoSizeMode.GrowAndShrink,
-            Padding = new Padding(1, 2, 3, 4),
-            Text = "Text"
-        };
-        Size minSize = TextRenderer.MeasureText(control.Text, control.Font);
-
-        Size size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(9, 13) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        size = control.GetPreferredSize(proposedSize);
-        Assert.Equal(minSize + new Size(9, 13) + new Size(4, 6), size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, true)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, true)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Button_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubButton();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Button_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubButton();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> NotifyDefault_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, true };
-            yield return new object[] { flatStyle, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyDefault_TestData))]
-    public void Button_NotifyDefault_Invoke_GetReturnsExpected(FlatStyle flatStyle, bool value)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        control.NotifyDefault(value);
-        Assert.Equal(value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.NotifyDefault(value);
-        Assert.Equal(value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.NotifyDefault(!value);
-        Assert.Equal(!value, control.IsDefault);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> NotifyDefault_WithHandle_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.Popup, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.Standard, true, 1, 0, 2, 0 };
-        yield return new object[] { FlatStyle.System, true, 1, 1, 2, 2 };
-
-        yield return new object[] { FlatStyle.Flat, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.Popup, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.Standard, false, 0, 0, 1, 0 };
-        yield return new object[] { FlatStyle.System, false, 0, 0, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyDefault_WithHandle_TestData))]
-    public void Button_NotifyDefault_InvokeWithHandle_GetReturnsExpected(FlatStyle flatStyle, bool value, int expectedInvalidatedCallCount1, int expectedStyleChangeCallCount1, int expectedInvalidatedCallCount2, int expectedStyleChangeCallCount2)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.NotifyDefault(value);
-        Assert.Equal(value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.NotifyDefault(value);
-        Assert.Equal(value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.NotifyDefault(!value);
-        Assert.Equal(!value, control.IsDefault);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangeCallCount2, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void Button_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubButton();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnClick_InvokeWithForm_CallsClick(EventArgs eventArgs)
-    {
-        using var form = new Form();
-        using var parent = new Control
-        {
-            Parent = form
-        };
-        using var control = new SubButton
-        {
-            Parent = parent,
-            DialogResult = DialogResult.Yes
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DialogResult.Yes, form.DialogResult);
-
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DialogResult.Yes, form.DialogResult);
-
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnClick_InvokeWithHandle_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnClick_InvokeWithFormWithHandle_CallsClick(EventArgs eventArgs)
-    {
-        using var form = new Form();
-        using var parent = new Control
-        {
-            Parent = form
-        };
-        using var control = new SubButton
-        {
-            Parent = parent,
-            DialogResult = DialogResult.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DialogResult.Yes, form.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DialogResult.Yes, form.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Button_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Button_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void Button_OnMouseDown_Invoke_CallsMouseDown(bool enabled, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_WithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), 0 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), 1 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), 0 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), 1 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), 0 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), 1 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), 0 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), 1 };
-            yield return new object[] { enabled, new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_WithHandle_TestData))]
-    public void Button_OnMouseDown_InvokeWithHandle_CallsMouseDown(bool enabled, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Button_OnMouseDown_NullE_ReturnsExpected()
-    {
-        using var control = new SubButton();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));
-    }
-
-    public static IEnumerable<object[]> OnMouseEnter_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool autoEllipsis in new bool[] { true, false })
-            {
-                foreach (string text in new string[] { null, string.Empty, "text" })
-                {
-                    yield return new object[] { enabled, autoEllipsis, text, null };
-                    yield return new object[] { enabled, autoEllipsis, text, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void Button_OnMouseEnter_Invoke_CallsMouseEnter(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void Button_OnMouseEnter_InvokeDesignMode_CallsMouseEnter(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text,
-            Site = mockSite.Object
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void Button_OnMouseEnter_InvokeWithHandle_CallsMouseEnter(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseEnter_TestData))]
-    public void Button_OnMouseEnter_InvokeDesignModeWithHandle_CallsMouseEnter(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text,
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseLeave_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool autoEllipsis in new bool[] { true, false })
-            {
-                foreach (string text in new string[] { null, string.Empty, "text" })
-                {
-                    yield return new object[] { enabled, autoEllipsis, text, null };
-                    yield return new object[] { enabled, autoEllipsis, text, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_TestData))]
-    public void Button_OnMouseLeave_Invoke_CallsMouseLeave(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoEllipsis, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoEllipsis, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_TestData))]
-    public void Button_OnMouseLeave_InvokeWithHandle_CallsMouseLeave(bool enabled, bool autoEllipsis, string text, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            Enabled = enabled,
-            AutoEllipsis = autoEllipsis,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void Button_OnMouseUp_Invoke_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_MouseDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), true };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), true };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_MouseDown_TestData))]
-    public void Button_OnMouseUp_InvokeMouseDown_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs, bool expectedIsHandleCreated)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void Button_OnMouseUp_InvokeWithHandle_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_WithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            int expectedCallCount = flatStyle != FlatStyle.System ? 1 : 0;
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4), 0 };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), expectedCallCount };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), 0 };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), 0 };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4), 0 };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), expectedCallCount };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), 0 };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_WithHandle_TestData))]
-    public void Button_OnMouseUp_InvokeMouseDownWithHandle_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Button_OnMouseUp_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubButton();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null));
-    }
-
-    public static IEnumerable<object[]> OnTextChanged_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null };
-            yield return new object[] { autoSize, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_TestData))]
-    public void Button_OnTextChanged_Invoke_CallsTextChanged(bool autoSize, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnTextChanged_WithParent_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_WithParent_TestData))]
-    public void Button_OnTextChanged_InvokeWithParent_CallsTextChanged(bool autoSize, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            control.TextChanged += handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Remove handler.
-            control.TextChanged -= handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_TestData))]
-    public void Button_OnTextChanged_InvokeWithHandle_CallsTextChanged(bool autoSize, EventArgs eventArgs)
-    {
-        using var control = new SubButton
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextChanged_WithParent_TestData))]
-    public void Button_OnTextChanged_InvokeWithParentWithHandle_CallsTextChanged(bool autoSize, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubButton
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            control.TextChanged += handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-
-            // Remove handler.
-            control.TextChanged -= handler;
-            control.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Button_PerformClick_Invoke_CallsClick()
-    {
-        using var control = new SubButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_PerformClick_InvokeWithForm_CallsClick()
-    {
-        using var form = new Form();
-        using var parent = new Control
-        {
-            Parent = form
-        };
-        using var control = new SubButton
-        {
-            Parent = parent,
-            DialogResult = DialogResult.Yes
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(0, callCount);
-        Assert.Equal(DialogResult.None, form.DialogResult);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(0, callCount);
-        Assert.Equal(DialogResult.None, form.DialogResult);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_PerformClick_InvokeWithHandle_CallsClick()
-    {
-        using var control = new SubButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Button_PerformClick_InvokeWithFormWithHandle_CallsClick()
-    {
-        using var form = new Form();
-        using var parent = new Control
-        {
-            Parent = form
-        };
-        using var control = new SubButton
-        {
-            Parent = parent,
-            DialogResult = DialogResult.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(0, callCount);
-        Assert.Equal(DialogResult.None, form.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(0, callCount);
-        Assert.Equal(DialogResult.None, form.DialogResult);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a', 0)]
-    [InlineData(true, "", char.MinValue, 0)]
-    [InlineData(true, "&a", 'a', 1)]
-    [InlineData(true, "&a", 'b', 0)]
-    [InlineData(true, "&&a", 'a', 0)]
-    [InlineData(true, "&", 'a', 0)]
-    [InlineData(true, "text", 'a', 0)]
-    [InlineData(false, "", 'a', 0)]
-    [InlineData(false, "", char.MinValue, 0)]
-    [InlineData(false, "&a", 'a', 0)]
-    [InlineData(false, "&a", 'b', 0)]
-    [InlineData(false, "&&a", 'a', 0)]
-    [InlineData(false, "&", 'a', 0)]
-    [InlineData(false, "text", 'a', 0)]
-    public void Button_ProcessMnemonic_Invoke_ReturnsExpected(bool useMnemonic, string text, char charCode, int expectedClickCallCount)
-    {
-        using var control = new SubButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            clickCallCount++;
-        };
-        Assert.Equal(expectedClickCallCount != 0, control.ProcessMnemonic(charCode));
-        Assert.Equal(expectedClickCallCount, clickCallCount);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a')]
-    [InlineData(true, "", char.MinValue)]
-    [InlineData(true, "&a", 'a')]
-    [InlineData(true, "&a", 'b')]
-    [InlineData(true, "&&a", 'a')]
-    [InlineData(true, "&", 'a')]
-    [InlineData(true, "text", 'a')]
-    [InlineData(false, "", 'a')]
-    [InlineData(false, "", char.MinValue)]
-    [InlineData(false, "&a", 'a')]
-    [InlineData(false, "&a", 'b')]
-    [InlineData(false, "&&a", 'a')]
-    [InlineData(false, "&", 'a')]
-    [InlineData(false, "text", 'a')]
-    public void Button_ProcessMnemonic_InvokeCantProcessMnemonic_ReturnsFalse(bool useMnemonic, string text, char charCode)
-    {
-        using var control = new SubButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text,
-            Enabled = false
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        Assert.False(control.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new Button();
-        Assert.Equal("System.Windows.Forms.Button, Text: ", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void Button_RaiseAutomationEvent_Invoke_Success_IfControlIsCreated()
-    {
-        using var button = new TestButton();
-        Assert.False(button.IsHandleCreated);
-        button.CreateControl();
-        var accessibleObject = (SubButtonAccessibleObject)button.AccessibilityObject;
-        Assert.Equal(0, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(0, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-
-        button.PerformClick();
-
-        Assert.Equal(1, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(1, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-        Assert.True(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_RaiseAutomationEvent_IsNotInvoked_IfControlIsNotCreated()
-    {
-        using var button = new TestButton();
-        var accessibleObject = (SubButtonAccessibleObject)button.AccessibilityObject;
-        Assert.Equal(0, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(0, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-
-        button.PerformClick();
-
-        Assert.Equal(0, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(0, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Button_ToString_InvokeShortText_ReturnsExpected()
-    {
-        using var control = new Button
-        {
-            Text = "Text"
-        };
-        Assert.Equal("System.Windows.Forms.Button, Text: Text", control.ToString());
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgndWithoutHandleWithoutWParam_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, true, opaque, IntPtr.Zero };
-            yield return new object[] { true, false, opaque, IntPtr.Zero };
-            yield return new object[] { false, true, opaque, IntPtr.Zero };
-            yield return new object[] { false, false, opaque, IntPtr.Zero };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgndWithoutHandleWithoutWParam_TestData))]
-    public void Button_WndProc_InvokeEraseBkgndWithoutHandleWithoutWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque, IntPtr expectedResult)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButton();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_ERASEBKGND,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, paintCallCount);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgnd_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-            {
-                foreach (bool opaque in new bool[] { true, false })
-                {
-                    yield return new object[] { userPaint, allPaintingInWmPaint, opaque };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgnd_TestData))]
-    public void Button_WndProc_InvokeEraseBkgndWithoutHandleWithWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubButton();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            using var image = new Bitmap(10, 10);
-            using Graphics graphics = Graphics.FromImage(image);
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_ERASEBKGND,
-                    WParam = hdc,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(IntPtr.Zero, m.Result);
-                Assert.False(control.IsHandleCreated);
-                Assert.Equal(0, paintCallCount);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgnd_TestData))]
-    public void Button_WndProc_InvokeEraseBkgndWithHandleWithoutWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque)
-    {
-        using var control = new SubButton();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_ERASEBKGND,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, paintCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgnd_TestData))]
-    public void Button_WndProc_InvokeEraseBkgndWithHandleWithWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque)
-    {
-        using var control = new SubButton();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_ERASEBKGND,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(0, paintCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void Button_WndProc_InvokeMouseHoverWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectCommandWithoutHandle_TestData()
-    {
-        yield return new object[] { FlatStyle.Flat, IntPtr.Zero, (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Flat, PARAM.FromLowHigh(123, 456), (IntPtr)250, 0 };
-
-        yield return new object[] { FlatStyle.Popup, IntPtr.Zero, (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Popup, PARAM.FromLowHigh(123, 456), (IntPtr)250, 0 };
-
-        yield return new object[] { FlatStyle.Standard, IntPtr.Zero, (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.Standard, PARAM.FromLowHigh(123, 456), (IntPtr)250, 0 };
-
-        yield return new object[] { FlatStyle.System, IntPtr.Zero, (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(0, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(123, (int)PInvoke.BN_CLICKED), (IntPtr)250, 1 };
-        yield return new object[] { FlatStyle.System, PARAM.FromLowHigh(123, 456), (IntPtr)250, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommandWithoutHandle_TestData))]
-    public void Button_WndProc_InvokeReflectCommandWithoutHandle_Success(FlatStyle flatStyle, IntPtr wParam, IntPtr expectedResult, int expectedCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using SubButton control = new()
-            {
-                FlatStyle = flatStyle
-            };
-
-            int callCount = 0;
-            control.Click += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-
-            Message m = new()
-            {
-                Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-                WParam = wParam,
-                Result = 250
-            };
-
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(expectedCallCount, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommandWithoutHandle_TestData))]
-    public void Button_WndProc_InvokeReflectCommandWithHandle_Success(FlatStyle flatStyle, IntPtr wParam, IntPtr expectedResult, int expectedCallCount)
-    {
-        using var control = new SubButton
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubButton : Button
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsDefault
-        {
-            get => base.IsDefault;
-            set => base.IsDefault = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs eventargs) => base.OnMouseEnter(eventargs);
-
-        public new void OnMouseLeave(EventArgs eventargs) => base.OnMouseLeave(eventargs);
-
-        public new void OnMouseUp(MouseEventArgs eventargs) => base.OnMouseUp(eventargs);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class TestButton : Button
-    {
-        protected override AccessibleObject CreateAccessibilityInstance()
-        {
-            return new SubButtonAccessibleObject(this);
-        }
-    }
-
-    private class SubButtonAccessibleObject : Button.ButtonAccessibleObject
-    {
-        public SubButtonAccessibleObject(Button owner) : base(owner)
-        {
-            RaiseAutomationEventCallsCount = 0;
-            RaiseAutomationPropertyChangedEventCallsCount = 0;
-        }
-
-        public int RaiseAutomationEventCallsCount { get; private set; }
-
-        public int RaiseAutomationPropertyChangedEventCallsCount { get; private set; }
-
-        internal override bool RaiseAutomationEvent(UIA eventId)
-        {
-            if (Owner.IsHandleCreated)
-            {
-                RaiseAutomationEventCallsCount++;
-            }
-
-            return base.RaiseAutomationEvent(eventId);
-        }
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UIA propertyId, object oldValue, object newValue)
-        {
-            if (Owner.IsHandleCreated)
-            {
-                RaiseAutomationPropertyChangedEventCallsCount++;
-            }
-
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CacheVirtualItemsEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CacheVirtualItemsEventArgsTests.cs
deleted file mode 100644
index 09f56b8b3a5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CacheVirtualItemsEventArgsTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class CacheVirtualItemsEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int startIndex, int endIndex)
-    {
-        var e = new CacheVirtualItemsEventArgs(startIndex, endIndex);
-        Assert.Equal(startIndex, e.StartIndex);
-        Assert.Equal(endIndex, e.EndIndex);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CategoryGridEntryAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CategoryGridEntryAccessibleObjectTests.cs
deleted file mode 100644
index be34209bad5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CategoryGridEntryAccessibleObjectTests.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.PropertyGridInternal;
-using static System.Windows.Forms.PropertyGridInternal.CategoryGridEntry;
-using static System.Windows.Forms.PropertyGridInternal.PropertyGridView;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class CategoryGridEntryAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_Ctor_Default()
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        Assert.Null(((IOwnedObject<GridEntry>)accessibilityObject).Owner);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_Role_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        Assert.Equal(AccessibleRole.ButtonDropDownGrid, accessibilityObject.Role);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_Column_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        Assert.Equal(0, accessibilityObject.Column);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_ControlType_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        UiaCore.UIA expected = UiaCore.UIA.TreeItemControlTypeId;
-
-        Assert.Equal(expected, accessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.GridItemPatternId)]
-    [InlineData((int)UiaCore.UIA.TableItemPatternId)]
-    public void CategoryGridEntryAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        Assert.True(accessibilityObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-
-        AccessibleObject accessibilityObject = gridView.TopLevelGridEntries[0].AccessibilityObject;
-
-        Assert.Equal(gridView.AccessibilityObject, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-
-        AccessibleObject accessibilityObjectCategory1 = gridView.TopLevelGridEntries[0].AccessibilityObject;
-        AccessibleObject accessibilityObjectCategory2 = gridView.TopLevelGridEntries[1].AccessibilityObject;
-        AccessibleObject accessibilityObjectLastCategory = gridView.TopLevelGridEntries[^1].AccessibilityObject;
-
-        Assert.Equal(accessibilityObjectCategory2, accessibilityObjectCategory1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibilityObjectLastCategory.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-
-        AccessibleObject accessibilityObjectCategory1 = gridView.TopLevelGridEntries[0].AccessibilityObject;
-        AccessibleObject accessibilityObjectCategory2 = gridView.TopLevelGridEntries[1].AccessibilityObject;
-
-        Assert.Null(accessibilityObjectCategory1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibilityObjectCategory1, accessibilityObjectCategory2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-        var category = (CategoryGridEntry)gridView.TopLevelGridEntries[0];
-        var gridViewAccessibilityObject = (PropertyGridViewAccessibleObject)gridView.AccessibilityObject;
-
-        AccessibleObject accessibilityObject = category.AccessibilityObject;
-        AccessibleObject accessibilityObjectFirstItem = gridViewAccessibilityObject.GetFirstChildProperty(category);
-
-        Assert.Equal(accessibilityObjectFirstItem, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-        var category = (CategoryGridEntry)gridView.TopLevelGridEntries[0];
-        var gridViewAccessibilityObject = (PropertyGridViewAccessibleObject)gridView.AccessibilityObject;
-
-        AccessibleObject accessibilityObject = category.AccessibilityObject;
-        AccessibleObject accessibilityObjectLastItem = gridViewAccessibilityObject.GetLastChildProperty(category);
-
-        Assert.Equal(accessibilityObjectLastItem, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObject_LocalizedControlType_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        var accessibilityObject = new CategoryGridEntryAccessibleObject(null);
-
-        string expected = SR.CategoryPropertyGridLocalizedControlType;
-
-        Assert.Equal(expected, accessibilityObject.GetPropertyValue(UiaCore.UIA.LocalizedControlTypePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.ButtonDropDownGrid)]
-    [InlineData((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId, true)]
-    [InlineData((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId, true)]
-    public void CategoryGridEntryAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using NoAssertContext context = new();
-        CategoryGridEntryAccessibleObject accessibleObject = new(null);
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void CategoryGridEntryAccessibleObjectWithControl_GetPropertyValue_ReturnsExpected()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        PropertyGridView gridView = control.TestAccessor().Dynamic._gridView;
-        var category = (CategoryGridEntry)gridView.TopLevelGridEntries[0];
-        var gridViewAccessibilityObject = (PropertyGridViewAccessibleObject)gridView.AccessibilityObject;
-        AccessibleObject accessibilityObject = category.AccessibilityObject;
-
-        Assert.Equal("Collapse", accessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.Null(accessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBox.CheckBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBox.CheckBoxAccessibleObjectTests.cs
deleted file mode 100644
index 673c92246cf..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBox.CheckBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-using CheckBoxAccessibleObject = System.Windows.Forms.CheckBox.CheckBoxAccessibleObject;
-
-namespace System.Windows.Forms.Tests;
-
-public class CheckBox_CheckBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Ctor_NullControl_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => new CheckBoxAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Ctor_InvalidTypeControl_ThrowsArgumentException()
-    {
-        using var textBox = new TextBox();
-        Assert.Throws<ArgumentException>(() => new CheckBoxAccessibleObject(textBox));
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Ctor_Default()
-    {
-        using var checkBox = new CheckBox();
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.NotNull(checkBoxAccessibleObject.Owner);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_CustomDoDefaultAction_ReturnsExpected()
-    {
-        using var checkBox = new CheckBox
-        {
-            Name = "CheckBox1",
-            AccessibleDefaultActionDescription = "TestActionDescription"
-        };
-
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal("TestActionDescription", checkBoxAccessibleObject.DefaultAction);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_DefaultRole_ReturnsExpected()
-    {
-        using var checkBox = new CheckBox();
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal(AccessibleRole.CheckButton, checkBoxAccessibleObject.Role);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_CustomRole_ReturnsExpected()
-    {
-        using var checkBox = new CheckBox
-        {
-            AccessibleRole = AccessibleRole.PushButton
-        };
-
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal(AccessibleRole.PushButton, checkBoxAccessibleObject.Role);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleStates.Focusable)]
-    [InlineData(false, AccessibleStates.None)]
-    public void CheckBoxAccessibleObject_State_ReturnsExpected(bool createControl, AccessibleStates accessibleStates)
-    {
-        using var checkBox = new CheckBox();
-
-        if (createControl)
-        {
-            checkBox.CreateControl();
-        }
-
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal(accessibleStates, checkBoxAccessibleObject.State);
-        Assert.Equal(createControl, checkBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, (int)ToggleState.On)]
-    [InlineData(true, CheckState.Unchecked, (int)ToggleState.Off)]
-    [InlineData(true, CheckState.Indeterminate, (int)ToggleState.Indeterminate)]
-    [InlineData(false, CheckState.Checked, (int)ToggleState.On)]
-    [InlineData(false, CheckState.Unchecked, (int)ToggleState.Off)]
-    [InlineData(false, CheckState.Indeterminate, (int)ToggleState.Indeterminate)]
-    public void CheckBoxAccessibleObject_ToggleState_ReturnsExpected(bool createControl, CheckState checkState, int toggleState)
-    {
-        using var checkBox = new CheckBox() { CheckState = checkState };
-
-        if (createControl)
-        {
-            checkBox.CreateControl();
-        }
-
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-        Assert.Equal((ToggleState)toggleState, checkBoxAccessibleObject.ToggleState);
-
-        Assert.Equal(createControl, checkBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CheckBoxAccessibleObject_DoDefaultAction_Success_Data()
-    {
-        yield return new object[] { true, false, CheckState.Checked, (int)ToggleState.Off };
-        yield return new object[] { true, false, CheckState.Indeterminate, (int)ToggleState.Off };
-        yield return new object[] { true, false, CheckState.Unchecked, (int)ToggleState.On };
-
-        yield return new object[] { true, true, CheckState.Checked, (int)ToggleState.Indeterminate };
-        yield return new object[] { true, true, CheckState.Indeterminate, (int)ToggleState.Off };
-        yield return new object[] { true, true, CheckState.Unchecked, (int)ToggleState.On };
-
-        yield return new object[] { false, true, CheckState.Checked, (int)ToggleState.On };
-        yield return new object[] { false, true, CheckState.Indeterminate, (int)ToggleState.Indeterminate };
-        yield return new object[] { false, true, CheckState.Unchecked, (int)ToggleState.Off };
-
-        yield return new object[] { false, false, CheckState.Checked, (int)ToggleState.On };
-        yield return new object[] { false, false, CheckState.Indeterminate, (int)ToggleState.Indeterminate };
-        yield return new object[] { false, false, CheckState.Unchecked, (int)ToggleState.Off };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxAccessibleObject_DoDefaultAction_Success_Data))]
-    public void CheckBoxAccessibleObject_DoDefaultAction_Success(bool createControl, bool threeState, CheckState checkState, int toggleState)
-    {
-        using var checkBox = new CheckBox()
-        {
-            ThreeState = threeState,
-            CheckState = checkState
-        };
-
-        if (createControl)
-        {
-            checkBox.CreateControl();
-        }
-
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-        checkBoxAccessibleObject.DoDefaultAction();
-
-        Assert.Equal((ToggleState)toggleState, checkBoxAccessibleObject.ToggleState);
-        Assert.Equal(createControl, checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Description_ReturnsExpected()
-    {
-        using var checkBox = new CheckBox
-        {
-            AccessibleDescription = "TestDescription"
-        };
-
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal("TestDescription", checkBoxAccessibleObject.Description);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Name_ReturnsExpected()
-    {
-        using var checkBox = new CheckBox
-        {
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.Equal("TestName", checkBoxAccessibleObject.Name);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.LegacyIAccessibleNamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.CheckBoxControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "CheckBox1")]
-    public void CheckBoxAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var checkBox = new CheckBox
-        {
-            Name = "CheckBox1",
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-        object value = checkBoxAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.TogglePatternId)]
-    [InlineData((int)UIA.LegacyIAccessiblePatternId)]
-    public void CheckBoxAccessibleObject_IsPatternSupported_Invoke_ReturnsExpected(int patternId)
-    {
-        using var checkBox = new CheckBox();
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-
-        Assert.True(checkBoxAccessibleObject.IsPatternSupported((UIA)patternId));
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Toggle_Invoke_Success()
-    {
-        using var checkBox = new CheckBox();
-        Assert.False(checkBox.IsHandleCreated);
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-        Assert.False(checkBox.Checked);
-
-        checkBoxAccessibleObject.Toggle();
-        Assert.True(checkBox.Checked);
-
-        // toggle again
-        checkBoxAccessibleObject.Toggle();
-
-        Assert.False(checkBox.Checked);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxAccessibleObject_Toggle_Invoke_ThreeState_Success()
-    {
-        using var checkBox = new CheckBox() { ThreeState = true };
-        var checkBoxAccessibleObject = new CheckBoxAccessibleObject(checkBox);
-        Assert.Equal(CheckState.Unchecked, checkBox.CheckState);
-
-        checkBoxAccessibleObject.Toggle();
-        Assert.Equal(CheckState.Checked, checkBox.CheckState);
-
-        // toggle again
-        checkBoxAccessibleObject.Toggle();
-        Assert.Equal(CheckState.Indeterminate, checkBox.CheckState);
-
-        // toggle again
-        checkBoxAccessibleObject.Toggle();
-        Assert.Equal(CheckState.Unchecked, checkBox.CheckState);
-
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CheckBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void CheckBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using CheckBox checkBox = new CheckBox();
-        checkBox.AccessibleRole = role;
-        UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, checkBox.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId));
-        Assert.Equal(checkBox.AccessibilityObject.DefaultAction, checkBox.AccessibilityObject.GetPropertyValue(UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(checkBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBoxTests.cs
deleted file mode 100644
index 08d715c9936..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckBoxTests.cs
+++ /dev/null
@@ -1,529 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using static Interop.UiaCore;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class CheckBoxTests
-{
-    [WinFormsFact]
-    public void CheckBox_Ctor_Default()
-    {
-        using var control = new SubCheckBox();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(Appearance.Normal, control.Appearance);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.True(control.AutoCheck);
-        Assert.False(control.AutoEllipsis);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(24, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(ContentAlignment.MiddleLeft, control.CheckAlign);
-        Assert.False(control.Checked);
-        Assert.Equal(CheckState.Unchecked, control.CheckState);
-        Assert.Equal(new Size(104, 24), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(104, 24), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.NotNull(control.FlatAppearance);
-        Assert.Same(control.FlatAppearance, control.FlatAppearance);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(24, control.Height);
-        Assert.Null(control.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.ImageAlign);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsDefault);
-        Assert.False(control.IsMirrored);
-        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("Microsoft\u00AE .NET", control.ProductName);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(104, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(104, 24), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ContentAlignment.MiddleLeft, control.TextAlign);
-        Assert.Equal(TextImageRelation.Overlay, control.TextImageRelation);
-        Assert.False(control.ThreeState);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseMnemonic);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(104, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubCheckBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(24, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x5601000B, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<Appearance>]
-    public void CheckBox_Appearance_Set_GetReturnsExpected(Appearance value)
-    {
-        using var control = new CheckBox
-        {
-            Appearance = value
-        };
-        Assert.Equal(value, control.Appearance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Appearance = value;
-        Assert.Equal(value, control.Appearance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<Appearance>]
-    public void CheckBox_Appearance_SetInvalidValue_ThrowsInvalidEnumArgumentException(Appearance value)
-    {
-        using var control = new CheckBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Appearance = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckBox_AutoCheck(bool expected)
-    {
-        using var box = new CheckBox
-        {
-            AutoCheck = expected
-        };
-
-        Assert.Equal(expected, box.AutoCheck);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void CheckBox_CheckAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var control = new CheckBox
-        {
-            CheckAlign = value
-        };
-        Assert.Equal(value, control.CheckAlign);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CheckAlign = value;
-        Assert.Equal(value, control.CheckAlign);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void CheckBox_CheckAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new CheckBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.CheckAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked)]
-    [InlineData(false, CheckState.Unchecked)]
-    public void CheckBox_CheckedGetSet(bool sent, CheckState expected)
-    {
-        using var box = new CheckBox
-        {
-            Checked = sent
-        };
-
-        Assert.Equal(expected, box.CheckState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, true, CheckState.Indeterminate)]
-    [InlineData(true, CheckState.Unchecked, true, CheckState.Checked)]
-    [InlineData(true, CheckState.Indeterminate, false, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Checked, false, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Unchecked, true, CheckState.Checked)]
-    [InlineData(false, CheckState.Indeterminate, false, CheckState.Unchecked)]
-    public void CheckBox_OnClick_AutoCheck_SetCorrectCheckState(bool threeState, CheckState checkState, bool expectedChecked, CheckState expectedCheckState)
-    {
-        using var box = new SubCheckBox
-        {
-            AutoCheck = true,
-            ThreeState = threeState,
-            CheckState = checkState
-        };
-
-        box.OnClick(EventArgs.Empty);
-
-        Assert.Equal(expectedChecked, box.Checked);
-        Assert.Equal(expectedCheckState, box.CheckState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, true)]
-    [InlineData(true, CheckState.Unchecked, false)]
-    [InlineData(true, CheckState.Indeterminate, true)]
-    [InlineData(false, CheckState.Checked, true)]
-    [InlineData(false, CheckState.Unchecked, false)]
-    [InlineData(false, CheckState.Indeterminate, true)]
-    public void CheckBox_OnClick_AutoCheckFalse_DoesNotChangeCheckState(bool threeState, CheckState expectedCheckState, bool expectedChecked)
-    {
-        using var box = new SubCheckBox
-        {
-            AutoCheck = false,
-            ThreeState = threeState,
-            CheckState = expectedCheckState
-        };
-
-        box.OnClick(EventArgs.Empty);
-
-        Assert.Equal(expectedChecked, box.Checked);
-        Assert.Equal(expectedCheckState, box.CheckState);
-    }
-
-    [WinFormsTheory]
-    [EnumData<CheckState>]
-    public void CheckBox_CheckState_Set_GetReturnsExpected(CheckState value)
-    {
-        using var control = new CheckBox
-        {
-            CheckState = value
-        };
-        Assert.Equal(value, control.CheckState);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CheckState = value;
-        Assert.Equal(value, control.CheckState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<CheckState>]
-    public void CheckBox_CheckState_SetInvalidValue_ThrowsInvalidEnumArgumentException(CheckState value)
-    {
-        using var control = new CheckBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.CheckState = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void CheckBox_TextAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var control = new CheckBox
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, control.TextAlign);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void CheckBox_TextAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new CheckBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextAlign = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckBox_ThreeState(bool expected)
-    {
-        using var box = new CheckBox
-        {
-            ThreeState = expected
-        };
-
-        Assert.Equal(expected, box.ThreeState);
-    }
-
-    [WinFormsFact]
-    public void CheckBox_CreateFlatAdapter()
-    {
-        using var box = new CheckBox();
-
-        ButtonInternal.ButtonBaseAdapter buttonBaseAdptr = box.CreateFlatAdapter();
-
-        Assert.NotNull(buttonBaseAdptr);
-    }
-
-    [WinFormsFact]
-    public void CheckBox_CreatePopupAdapter()
-    {
-        using var box = new CheckBox();
-
-        ButtonInternal.ButtonBaseAdapter checkBoxPopupAdptr = box.CreatePopupAdapter();
-
-        Assert.NotNull(checkBoxPopupAdptr);
-    }
-
-    [WinFormsFact]
-    public void CheckBox_CreateStandardAdapter()
-    {
-        using var box = new CheckBox();
-
-        ButtonInternal.ButtonBaseAdapter checkBoxSndAdptr = box.CreateStandardAdapter();
-
-        Assert.NotNull(checkBoxSndAdptr);
-    }
-
-    [WinFormsFact]
-    public void CheckBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubCheckBox();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, true)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, true)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void CheckBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubCheckBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void CheckBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubCheckBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void CheckBox_RaiseAutomationEvent_Invoke_Success()
-    {
-        using var checkBox = new TestCheckBox();
-        Assert.False(checkBox.IsHandleCreated);
-
-        var accessibleObject = (SubCheckBoxAccessibleObject)checkBox.AccessibilityObject;
-        Assert.Equal(0, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(0, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-
-        checkBox.Checked = true;
-
-        Assert.Equal(1, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(1, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-        Assert.False(checkBox.IsHandleCreated);
-    }
-
-    // the zero here may be an issue with cultural variance
-    [WinFormsFact]
-    public void CheckBox_ToStringTest()
-    {
-        using var box = new CheckBox();
-        var expected = "System.Windows.Forms.CheckBox, CheckState: 0";
-
-        var actual = box.ToString();
-
-        Assert.Equal(expected, actual);
-    }
-
-    public class SubCheckBox : CheckBox
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsDefault
-        {
-            get => base.IsDefault;
-            set => base.IsDefault = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-    }
-
-    private class TestCheckBox : CheckBox
-    {
-        protected override AccessibleObject CreateAccessibilityInstance()
-        {
-            return new SubCheckBoxAccessibleObject(this);
-        }
-    }
-
-    private class SubCheckBoxAccessibleObject : CheckBox.CheckBoxAccessibleObject
-    {
-        public SubCheckBoxAccessibleObject(CheckBox owner) : base(owner)
-        {
-            RaiseAutomationEventCallsCount = 0;
-            RaiseAutomationPropertyChangedEventCallsCount = 0;
-        }
-
-        public int RaiseAutomationEventCallsCount { get; private set; }
-
-        public int RaiseAutomationPropertyChangedEventCallsCount { get; private set; }
-
-        internal override bool RaiseAutomationEvent(UIA eventId)
-        {
-            RaiseAutomationEventCallsCount++;
-            return base.RaiseAutomationEvent(eventId);
-        }
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UIA propertyId, object oldValue, object newValue)
-        {
-            RaiseAutomationPropertyChangedEventCallsCount++;
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBox.CheckedIndexCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBox.CheckedIndexCollectionTests.cs
deleted file mode 100644
index 888f1c08ef6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBox.CheckedIndexCollectionTests.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class CheckedListBox_CheckedIndexCollectionTests
-{
-    [WinFormsFact]
-    public void CheckedIndexCollection_Ctor_OwnerIsNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => { new CheckedListBox.CheckedIndexCollection(null); });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBoxAccessibleObjectTests.cs
deleted file mode 100644
index b88ae071d2c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CheckedListBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,163 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class CheckedListBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CheckedListBoxAccessibleObject_CheckBounds()
-    {
-        using CheckedListBox checkedListBox = new CheckedListBox();
-        checkedListBox.Size = new Size(120, 100);
-        checkedListBox.Items.Add("a");
-        checkedListBox.Items.Add("b");
-        checkedListBox.Items.Add("c");
-        checkedListBox.Items.Add("d");
-        checkedListBox.Items.Add("e");
-        checkedListBox.Items.Add("f");
-        checkedListBox.Items.Add("g");
-        checkedListBox.Items.Add("h");
-        checkedListBox.Items.Add("i");
-
-        int listBoxHeight = checkedListBox.AccessibilityObject.Bounds.Height;
-        int sumItemsHeight = 0;
-
-        for (int i = 0; i < checkedListBox.Items.Count; i++)
-        {
-            AccessibleObject item = checkedListBox.AccessibilityObject.GetChild(i);
-            sumItemsHeight += item.Bounds.Height;
-        }
-
-        Assert.Equal(listBoxHeight, sumItemsHeight);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.UIA.ListControlTypeId)]
-    [InlineData(false, (int)UiaCore.UIA.ListControlTypeId)]
-    public void CheckedListBoxAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool createControl, int expectedType)
-    {
-        using CheckedListBox checkedListBox = new CheckedListBox();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        object actual = checkedListBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-        Assert.Equal(createControl, checkedListBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CheckedListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckedListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void CheckedListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using CheckedListBox checkedListBox = new CheckedListBox();
-        checkedListBox.AccessibleRole = role;
-
-        object actual = checkedListBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.List)]
-    [InlineData(false, AccessibleRole.None)]
-    public void CheckedListBoxAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using CheckedListBox checkedListBox = new CheckedListBox();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            checkedListBox.CreateControl();
-        }
-
-        AccessibleRole actual = checkedListBox.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(3)]
-    public void CheckedListBoxAccessibleObject_GetChildCount_ReturnsExpected(int childCount)
-    {
-        using CheckedListBox checkedListBox = new();
-
-        for (int i = 0; i < childCount; i++)
-        {
-            checkedListBox.Items.Add(i);
-        }
-
-        int actual = checkedListBox.AccessibilityObject.GetChildCount();
-
-        Assert.Equal(childCount, actual);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxAccessibleObject_RuntimeId_NotNull()
-    {
-        using CheckedListBox checkedListBox = new();
-
-        Assert.NotNull(checkedListBox.AccessibilityObject.RuntimeId);
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxAccessibleObject_FragmentNavigate_NavigateToFirstChild_IsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-        AccessibleObject accessibleObject = checkedListBox.AccessibilityObject;
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject expected = accessibleObject.GetChild(0);
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CheckedListBoxAccessibleObject_FragmentNavigate_NavigateToLastChild_IsExpected()
-    {
-        using CheckedListBox checkedListBox = new();
-        AccessibleObject accessibleObject = checkedListBox.AccessibilityObject;
-
-        checkedListBox.Items.Add(0);
-        checkedListBox.Items.Add(1);
-        checkedListBox.Items.Add(2);
-
-        AccessibleObject expected = accessibleObject.GetChild(2);
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(checkedListBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ClipboardTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ClipboardTests.cs
deleted file mode 100644
index 539020746e1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ClipboardTests.cs
+++ /dev/null
@@ -1,515 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.Tests;
-
-public class ClipboardTests
-{
-    [WinFormsFact]
-    public void Clipboard_Clear_InvokeMultipleTimes_Success()
-    {
-        Clipboard.Clear();
-        Assert.False(Clipboard.ContainsAudio());
-        Assert.False(Clipboard.ContainsData("format"));
-        Assert.False(Clipboard.ContainsFileDropList());
-        Assert.False(Clipboard.ContainsImage());
-        Assert.False(Clipboard.ContainsText());
-
-        Clipboard.Clear();
-        Assert.False(Clipboard.ContainsAudio());
-        Assert.False(Clipboard.ContainsData("format"));
-        Assert.False(Clipboard.ContainsFileDropList());
-        Assert.False(Clipboard.ContainsImage());
-        Assert.False(Clipboard.ContainsText());
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_Clear_NotSta_ThrowsThreadStateException()
-    {
-        Assert.Throws<ThreadStateException>(() => Clipboard.Clear());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_ContainsAudio_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsAudio();
-        Assert.Equal(result, Clipboard.ContainsAudio());
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Clipboard_ContainsData_InvokeMultipleTimes_Success(string format)
-    {
-        bool result = Clipboard.ContainsData(format);
-        Assert.Equal(result, Clipboard.ContainsData(format));
-        Assert.False(result);
-    }
-
-    [WinFormsFact]
-    public void Clipboard_ContainsFileDropList_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsFileDropList();
-        Assert.Equal(result, Clipboard.ContainsFileDropList());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_ContainsImage_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsImage();
-        Assert.Equal(result, Clipboard.ContainsImage());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_ContainsText_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsText();
-        Assert.Equal(result, Clipboard.ContainsText());
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextDataFormat>]
-    public void Clipboard_ContainsText_InvokeTextDataFormatMultipleTimes_Success(TextDataFormat format)
-    {
-        bool result = Clipboard.ContainsText(format);
-        Assert.Equal(result, Clipboard.ContainsText(format));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextDataFormat>]
-    public void Clipboard_ContainsText_InvalidFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        Assert.Throws<InvalidEnumArgumentException>("format", () => Clipboard.ContainsText(format));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_GetAudioStream_InvokeMultipleTimes_Success()
-    {
-        Stream result = Clipboard.GetAudioStream();
-        Assert.Equal(result, Clipboard.GetAudioStream());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("\t")]
-    public void Clipboard_GetData_NullOrEmptyFormat_Returns_Null(string format)
-    {
-        object result = Clipboard.GetData(format);
-        Assert.Equal(result, Clipboard.GetData(format));
-        Assert.Null(result);
-    }
-
-    [WinFormsFact]
-    public void Clipboard_GetDataObject_InvokeMultipleTimes_Success()
-    {
-        object result = Clipboard.GetDataObject();
-        Assert.NotEqual(result, Clipboard.GetDataObject());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_GetFileDropList_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsFileDropList();
-        Assert.Equal(result, Clipboard.ContainsFileDropList());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_GetImage_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsImage();
-        Assert.Equal(result, Clipboard.ContainsImage());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_GetText_InvokeMultipleTimes_Success()
-    {
-        bool result = Clipboard.ContainsText();
-        Assert.Equal(result, Clipboard.ContainsText());
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextDataFormat>]
-    public void Clipboard_GetText_InvokeTextDataFormatMultipleTimes_Success(TextDataFormat format)
-    {
-        string result = Clipboard.GetText(format);
-        Assert.Equal(result, Clipboard.GetText(format));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextDataFormat>]
-    public void Clipboard_GetText_InvalidFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        Assert.Throws<InvalidEnumArgumentException>("format", () => Clipboard.GetText(format));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_InvokeByteArray_GetReturnsExpected()
-    {
-        byte[] audioBytes = new byte[] { 1, 2, 3 };
-        Clipboard.SetAudio(audioBytes);
-        Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(Clipboard.GetAudioStream()).ToArray());
-        Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(Clipboard.GetData(DataFormats.WaveAudio)).ToArray());
-        Assert.True(Clipboard.ContainsAudio());
-        Assert.True(Clipboard.ContainsData(DataFormats.WaveAudio));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_InvokeEmptyByteArray_GetReturnsExpected()
-    {
-        byte[] audioBytes = Array.Empty<byte>();
-        Clipboard.SetAudio(audioBytes);
-        Assert.Null(Clipboard.GetAudioStream());
-        Assert.Null(Clipboard.GetData(DataFormats.WaveAudio));
-        Assert.True(Clipboard.ContainsAudio());
-        Assert.True(Clipboard.ContainsData(DataFormats.WaveAudio));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_NullAudioBytes_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("audioBytes", () => Clipboard.SetAudio((byte[])null));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_InvokeStream_GetReturnsExpected()
-    {
-        byte[] audioBytes = new byte[] { 1, 2, 3 };
-        using (var audioStream = new MemoryStream(audioBytes))
-        {
-            Clipboard.SetAudio(audioStream);
-            Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(Clipboard.GetAudioStream()).ToArray());
-            Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(Clipboard.GetData(DataFormats.WaveAudio)).ToArray());
-            Assert.True(Clipboard.ContainsAudio());
-            Assert.True(Clipboard.ContainsData(DataFormats.WaveAudio));
-        }
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_InvokeEmptyStream_GetReturnsExpected()
-    {
-        var audioStream = new MemoryStream();
-        Clipboard.SetAudio(audioStream);
-        Assert.Null(Clipboard.GetAudioStream());
-        Assert.Null(Clipboard.GetData(DataFormats.WaveAudio));
-        Assert.True(Clipboard.ContainsAudio());
-        Assert.True(Clipboard.ContainsData(DataFormats.WaveAudio));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetAudio_NullAudioStream_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("audioStream", () => Clipboard.SetAudio((Stream)null));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetAudio_NotSta_ThrowsThreadStateException()
-    {
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetAudio(Array.Empty<byte>()));
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetAudio(new MemoryStream()));
-    }
-
-    [WinFormsTheory]
-    [InlineData("format", null)]
-    [InlineData("format", 1)]
-    public void Clipboard_SetData_Invoke_GetReturnsExpected(string format, object data)
-    {
-        Clipboard.SetData(format, data);
-        Assert.Equal(data, Clipboard.GetData(format));
-        Assert.True(Clipboard.ContainsData(format));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetData_NullFormat_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => Clipboard.SetData(format: null, data: new object()));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData(" ")]
-    [InlineData("\t")]
-    public void Clipboard_SetData_EmptyOrWhitespaceFormat_ThrowsArgumentException(string format)
-    {
-        Assert.Throws<ArgumentException>(() => Clipboard.SetData(format, data: null));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetData_NotSta_ThrowsThreadStateException()
-    {
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetData("format", data: null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData("data")]
-    public void Clipboard_SetDataObject_InvokeObjectNotIComDataObject_GetReturnsExpected(object data)
-    {
-        Clipboard.SetDataObject(data);
-        Assert.Equal(data, Clipboard.GetDataObject().GetData(data.GetType()));
-        Assert.True(Clipboard.ContainsData(data.GetType().FullName));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData("data")]
-    public void Clipboard_SetDataObject_InvokeObjectIComDataObject_GetReturnsExpected(object data)
-    {
-        var dataObject = new DataObject(data);
-        Clipboard.SetDataObject(dataObject);
-        Assert.Equal(data, Clipboard.GetDataObject().GetData(data.GetType()));
-        Assert.True(Clipboard.ContainsData(data.GetType().FullName));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, true)]
-    [InlineData(1, false)]
-    [InlineData("data", true)]
-    [InlineData("data", false)]
-    public void Clipboard_SetDataObject_InvokeObjectBoolNotIComDataObject_GetReturnsExpected(object data, bool copy)
-    {
-        Clipboard.SetDataObject(data, copy);
-        Assert.Equal(data, Clipboard.GetDataObject().GetData(data.GetType()));
-        Assert.True(Clipboard.ContainsData(data.GetType().FullName));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, true, 0, 0)]
-    [InlineData(1, false, 1, 2)]
-    [InlineData("data", true, 0, 0)]
-    [InlineData("data", false, 1, 2)]
-    public void Clipboard_SetDataObject_InvokeObjectBoolIComDataObject_GetReturnsExpected(object data, bool copy, int retryTimes, int retryDelay)
-    {
-        var dataObject = new DataObject(data);
-        Clipboard.SetDataObject(dataObject, copy, retryTimes, retryDelay);
-        Assert.Equal(data, Clipboard.GetDataObject().GetData(data.GetType()));
-        Assert.True(Clipboard.ContainsData(data.GetType().FullName));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, true, 0, 0)]
-    [InlineData(1, false, 1, 2)]
-    [InlineData("data", true, 0, 0)]
-    [InlineData("data", false, 1, 2)]
-    public void Clipboard_SetDataObject_InvokeObjectBoolIntIntNotIComDataObject_GetReturnsExpected(object data, bool copy, int retryTimes, int retryDelay)
-    {
-        Clipboard.SetDataObject(data, copy, retryTimes, retryDelay);
-        Assert.Equal(data, Clipboard.GetDataObject().GetData(data.GetType()));
-        Assert.True(Clipboard.ContainsData(data.GetType().FullName));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetDataObject_NullData_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("data", () => Clipboard.SetDataObject(null));
-        Assert.Throws<ArgumentNullException>("data", () => Clipboard.SetDataObject(null, copy: true));
-        Assert.Throws<ArgumentNullException>("data", () => Clipboard.SetDataObject(null, copy: true, retryTimes: 10, retryDelay: 0));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetDataObject_NegativeRetryTimes_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("retryTimes", () => Clipboard.SetDataObject(new object(), copy: true, retryTimes: -1, retryDelay: 0));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetDataObject_NegativeRetryDelay_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("retryDelay", () => Clipboard.SetDataObject(new object(), copy: true, retryTimes: 10, retryDelay: -1));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetDataObject_NotSta_ThrowsThreadStateException()
-    {
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetDataObject(null));
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetDataObject(null, copy: true));
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetDataObject(null, copy: true, retryTimes: 10, retryDelay: 0));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetFileDropList_Invoke_GetReturnsExpected()
-    {
-        var filePaths = new StringCollection
-        {
-            "filePath",
-            "filePath2"
-        };
-
-        Clipboard.SetFileDropList(filePaths);
-        Assert.Equal(filePaths, Clipboard.GetFileDropList());
-        Assert.True(Clipboard.ContainsFileDropList());
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetFileDropList_NullFilePaths_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("filePaths", () => Clipboard.SetFileDropList(null));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetFileDropList_EmptyFilePaths_ThrowsArgumentException()
-    {
-        var filePaths = new StringCollection();
-        Assert.Throws<ArgumentException>(() => Clipboard.SetFileDropList(filePaths));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("\0")]
-    public void Clipboard_SetFileDropList_InvalidFileInPaths_ThrowsArgumentException(string filePath)
-    {
-        var filePaths = new StringCollection
-        {
-            filePath
-        };
-        Assert.Throws<ArgumentException>(() => Clipboard.SetFileDropList(filePaths));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetFileDropList_NotSta_ThrowsThreadStateException()
-    {
-        var filePaths = new StringCollection
-        {
-            "filePath"
-        };
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetFileDropList(filePaths));
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetImage_InvokeBitmap_GetReturnsExpected()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        {
-            bitmap.SetPixel(1, 2, Color.FromArgb(0x01, 0x02, 0x03, 0x04));
-            Clipboard.SetImage(bitmap);
-            Bitmap result = Assert.IsType<Bitmap>(Clipboard.GetImage());
-            Assert.Equal(bitmap.Size, result.Size);
-            Assert.Equal(Color.FromArgb(0xFF, 0xD2, 0xD2, 0xD2), result.GetPixel(1, 2));
-            Assert.True(Clipboard.ContainsImage());
-        }
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetImage_InvokeMetafile_GetReturnsExpected()
-    {
-        using (var metafile = new Metafile("bitmaps/telescope_01.wmf"))
-        {
-            Clipboard.SetImage(metafile);
-            Assert.Null(Clipboard.GetImage());
-            Assert.True(Clipboard.ContainsImage());
-        }
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetImage_InvokeEnhancedMetafile_GetReturnsExpected()
-    {
-        using (var metafile = new Metafile("bitmaps/milkmateya01.emf"))
-        {
-            Clipboard.SetImage(metafile);
-            Assert.Null(Clipboard.GetImage());
-            Assert.True(Clipboard.ContainsImage());
-        }
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetImage_NullImage_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("image", () => Clipboard.SetImage(null));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetImage_NotSta_ThrowsThreadStateException()
-    {
-        using (var bitmap = new Bitmap(10, 10))
-        using (var metafile = new Metafile("bitmaps/telescope_01.wmf"))
-        using (var enhancedMetafile = new Metafile("bitmaps/milkmateya01.emf"))
-        {
-            Assert.Throws<ThreadStateException>(() => Clipboard.SetImage(bitmap));
-            Assert.Throws<ThreadStateException>(() => Clipboard.SetImage(metafile));
-            Assert.Throws<ThreadStateException>(() => Clipboard.SetImage(enhancedMetafile));
-        }
-    }
-
-    [WinFormsFact]
-    public void Clipboard_SetText_InvokeString_GetReturnsExpected()
-    {
-        Clipboard.SetText("text");
-        Assert.Equal("text", Clipboard.GetText());
-        Assert.True(Clipboard.ContainsText());
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextDataFormat>]
-    public void Clipboard_SetText_InvokeStringTextDataFormat_GetReturnsExpected(TextDataFormat format)
-    {
-        Clipboard.SetText("text", format);
-        Assert.Equal("text", Clipboard.GetText(format));
-        Assert.True(Clipboard.ContainsText(format));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void Clipboard_SetText_NullOrEmptyText_ThrowsArgumentNullException(string text)
-    {
-        Assert.Throws<ArgumentNullException>("text", () => Clipboard.SetText(text));
-        Assert.Throws<ArgumentNullException>("text", () => Clipboard.SetText(text, TextDataFormat.Text));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextDataFormat>]
-    public void Clipboard_SetText_InvalidFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        Assert.Throws<InvalidEnumArgumentException>("format", () => Clipboard.SetText("text", format));
-    }
-
-    [Fact] // x-thread
-    public void Clipboard_SetText_NotSta_ThrowsThreadStateException()
-    {
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetText("text"));
-        Assert.Throws<ThreadStateException>(() => Clipboard.SetText("text", TextDataFormat.Text));
-    }
-
-    [WinFormsFact]
-    public void ClipBoard_SetData_CustomFormat_Color()
-    {
-        using BinaryFormatterScope scope = new(enable: true);
-        string format = nameof(ClipBoard_SetData_CustomFormat_Color);
-        Clipboard.SetData(format, Color.Black);
-        Assert.True(Clipboard.ContainsData(format));
-        Assert.Equal(Color.Black, Clipboard.GetData(format));
-    }
-
-    [WinFormsFact]
-    public void ClipBoard_SetData_CustomFormat_Color_BinaryFormatterDisabled_SerializesException()
-    {
-        using BinaryFormatterScope scope = new(enable: false);
-        string format = nameof(ClipBoard_SetData_CustomFormat_Color);
-
-        // This will fail and NotSupportedException will be put on the Clipboard instead.
-        Clipboard.SetData(format, Color.Black);
-        Assert.True(Clipboard.ContainsData(format));
-
-        NotSupportedException value = (NotSupportedException)Clipboard.GetData(format);
-
-        using MemoryStream stream = new();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011
-        try
-        {
-            formatter.Serialize(stream, new object());
-        }
-        catch (NotSupportedException ex)
-        {
-            Assert.Equal(ex.Message, value.Message);
-            return;
-        }
-
-        Assert.Fail("Formatting should have failed.");
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColorDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColorDialogTests.cs
deleted file mode 100644
index 22bdd426e78..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColorDialogTests.cs
+++ /dev/null
@@ -1,382 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ColorDialogTests
-{
-    [WinFormsFact]
-    public void ColorDialog_Ctor_Default()
-    {
-        using var dialog = new SubColorDialog();
-        Assert.True(dialog.AllowFullOpen);
-        Assert.False(dialog.AnyColor);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.Equal(Enumerable.Repeat(0x00FFFFFF, 16).ToArray(), dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.Equal(dialog.Instance, dialog.Instance);
-        Assert.False(dialog.FullOpen);
-        Assert.Equal(0, dialog.Options);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.SolidColorOnly);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_Ctor_Default_OverridenReset()
-    {
-        using var dialog = new EmptyResetColorDialog();
-        Assert.True(dialog.AllowFullOpen);
-        Assert.False(dialog.AnyColor);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Empty, dialog.Color);
-        Assert.Equal(new int[16], dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.False(dialog.FullOpen);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.Equal(dialog.Instance, dialog.Instance);
-        Assert.Equal(0, dialog.Options);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.SolidColorOnly);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0, 0x4)]
-    [InlineData(false, 0x4, 0)]
-    public void ColorDialog_AllowFullOpen_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubColorDialog
-        {
-            AllowFullOpen = value
-        };
-        Assert.Equal(value, dialog.AllowFullOpen);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AllowFullOpen = value;
-        Assert.Equal(value, dialog.AllowFullOpen);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AllowFullOpen = !value;
-        Assert.Equal(!value, dialog.AllowFullOpen);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x100, 0)]
-    [InlineData(false, 0, 0x100)]
-    public void ColorDialog_AnyColor_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubColorDialog
-        {
-            AnyColor = value
-        };
-        Assert.Equal(value, dialog.AnyColor);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AnyColor = value;
-        Assert.Equal(value, dialog.AnyColor);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AnyColor = !value;
-        Assert.Equal(!value, dialog.AnyColor);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    public static IEnumerable<object[]> Color_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public void ColorDialog_Color_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var dialog = new ColorDialog
-        {
-            Color = value
-        };
-        Assert.Equal(expected, dialog.Color);
-
-        // Set same.
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public void ColorDialog_Color_SetWithCustomOldValue_GetReturnsExpected(Color value, Color expected)
-    {
-        using var dialog = new ColorDialog
-        {
-            Color = Color.Blue
-        };
-
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-
-        // Set same.
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_Color_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColorDialog))[nameof(ColorDialog.Color)];
-        using var dialog = new ColorDialog();
-        Assert.False(property.CanResetValue(dialog));
-
-        dialog.Color = Color.Red;
-        Assert.Equal(Color.Red, dialog.Color);
-        Assert.True(property.CanResetValue(dialog));
-
-        property.ResetValue(dialog);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.False(property.CanResetValue(dialog));
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_Color_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColorDialog))[nameof(ColorDialog.Color)];
-        using var dialog = new ColorDialog();
-        Assert.False(property.ShouldSerializeValue(dialog));
-
-        dialog.Color = Color.Red;
-        Assert.Equal(Color.Red, dialog.Color);
-        Assert.True(property.ShouldSerializeValue(dialog));
-
-        property.ResetValue(dialog);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.False(property.ShouldSerializeValue(dialog));
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_CustomColors_Get_ReturnsClone()
-    {
-        using var dialog = new ColorDialog();
-        int[] value1 = dialog.CustomColors;
-        int[] value2 = dialog.CustomColors;
-        Assert.NotSame(value1, value2);
-        Assert.Equal(value1, value2);
-        value1[0] = 1;
-        Assert.Equal(0x00FFFFFF, value2[0]);
-        Assert.Equal(0x00FFFFFF, dialog.CustomColors[0]);
-    }
-
-    public static IEnumerable<object[]> CustomColors_Set_TestData()
-    {
-        yield return new object[] { null, Enumerable.Repeat(0x00FFFFFF, 16).ToArray() };
-        yield return new object[] { Array.Empty<int>(), Enumerable.Repeat(0x00FFFFFF, 16).ToArray() };
-        yield return new object[] { new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 }.Concat(Enumerable.Repeat(0x00FFFFFF, 13)).ToArray() };
-        yield return new object[] { Enumerable.Repeat(0, 16).ToArray(), Enumerable.Repeat(0, 16).ToArray() };
-        yield return new object[] { Enumerable.Repeat(unchecked((int)0xFFFFFFFF), 16).ToArray(), Enumerable.Repeat(unchecked((int)0xFFFFFFFF), 16).ToArray() };
-        yield return new object[] { Enumerable.Repeat(1, 16).ToArray(), Enumerable.Repeat(1, 16).ToArray() };
-        yield return new object[] { Enumerable.Repeat(1, 20).ToArray(), Enumerable.Repeat(1, 16).ToArray() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CustomColors_Set_TestData))]
-    public void ColorDialog_CustomColors_Set_GetReturnsExpected(int[] value, int[] expected)
-    {
-        using var dialog = new ColorDialog
-        {
-            CustomColors = value
-        };
-        Assert.Equal(expected, dialog.CustomColors);
-        Assert.NotSame(value, dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-
-        // Set same.
-        dialog.CustomColors = value;
-        Assert.Equal(expected, dialog.CustomColors);
-        Assert.NotSame(value, dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CustomColors_Set_TestData))]
-    public void ColorDialog_CustomColors_SetWithCustomOldValue_GetReturnsExpected(int[] value, int[] expected)
-    {
-        using var dialog = new ColorDialog
-        {
-            CustomColors = new int[1]
-        };
-
-        dialog.CustomColors = value;
-        Assert.Equal(expected, dialog.CustomColors);
-        Assert.NotSame(value, dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-
-        // Set same.
-        dialog.CustomColors = value;
-        Assert.Equal(expected, dialog.CustomColors);
-        Assert.NotSame(value, dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_CustomColors_Set_GetReturnsClone()
-    {
-        int[] value = Enumerable.Repeat(1, 16).ToArray();
-        using var dialog = new ColorDialog
-        {
-            CustomColors = value
-        };
-        value[0] = 0;
-        Assert.Equal(Enumerable.Repeat(1, 16), dialog.CustomColors);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x2, 0)]
-    [InlineData(false, 0, 0x2)]
-    public void ColorDialog_FullOpen_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubColorDialog
-        {
-            FullOpen = value
-        };
-        Assert.Equal(value, dialog.FullOpen);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.FullOpen = value;
-        Assert.Equal(value, dialog.FullOpen);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.FullOpen = !value;
-        Assert.Equal(!value, dialog.FullOpen);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x8, 0)]
-    [InlineData(false, 0, 0x8)]
-    public void ColorDialog_ShowHelp_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubColorDialog
-        {
-            ShowHelp = value
-        };
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowHelp = value;
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowHelp = !value;
-        Assert.Equal(!value, dialog.ShowHelp);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x80, 0)]
-    [InlineData(false, 0, 0x80)]
-    public void ColorDialog_SolidColorOnly_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubColorDialog
-        {
-            SolidColorOnly = value
-        };
-        Assert.Equal(value, dialog.SolidColorOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.SolidColorOnly = value;
-        Assert.Equal(value, dialog.SolidColorOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.SolidColorOnly = !value;
-        Assert.Equal(!value, dialog.SolidColorOnly);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_Reset_Invoke_Success()
-    {
-        using var dialog = new SubColorDialog
-        {
-            AllowFullOpen = false,
-            AnyColor = true,
-            Color = Color.Red,
-            CustomColors = new int[] { 1, 2, 3 },
-            FullOpen = true,
-            ShowHelp = true,
-            SolidColorOnly = true,
-            Tag = "Tag",
-        };
-
-        dialog.Reset();
-        Assert.True(dialog.AllowFullOpen);
-        Assert.False(dialog.AnyColor);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.Equal(Enumerable.Repeat(0x00FFFFFF, 16).ToArray(), dialog.CustomColors);
-        Assert.NotSame(dialog.CustomColors, dialog.CustomColors);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.False(dialog.FullOpen);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.Equal(dialog.Instance, dialog.Instance);
-        Assert.Equal(0, dialog.Options);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.SolidColorOnly);
-        Assert.Null(dialog.Site);
-        Assert.Equal("Tag", dialog.Tag);
-    }
-
-    [WinFormsFact]
-    public void ColorDialog_ToString_Invoke_ReturnsExpected()
-    {
-        using var dialog = new SubColorDialog();
-        Assert.Equal("System.Windows.Forms.Tests.ColorDialogTests+SubColorDialog,  Color: Color [Black]", dialog.ToString());
-    }
-
-    private class SubColorDialog : ColorDialog
-    {
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new IntPtr Instance => base.Instance;
-
-        public new int Options => base.Options;
-    }
-
-    private class EmptyResetColorDialog : SubColorDialog
-    {
-        public override void Reset()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnClickEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnClickEventArgsTests.cs
deleted file mode 100644
index b32274ce5db..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnClickEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ColumnClickEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int column)
-    {
-        var e = new ColumnClickEventArgs(column);
-        Assert.Equal(column, e.Column);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeader.ListViewColumnHeaderAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeader.ListViewColumnHeaderAccessibleObjectTests.cs
deleted file mode 100644
index ae4c6ec344a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeader.ListViewColumnHeaderAccessibleObjectTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ColumnHeader;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ColumnHeader_ListViewColumnHeaderAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_Ctor_OwnerColumnHeaderCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ListViewColumnHeaderAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_GetPropertyValue_ControlType_ReturnsExpected()
-    {
-        using ColumnHeader columnHeader = new();
-
-        ListViewColumnHeaderAccessibleObject accessibleObject = new(columnHeader);
-
-        Assert.Equal(UIA.HeaderItemControlTypeId, accessibleObject.GetPropertyValue(UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        string testText = "This is a simple text for testing.";
-        using ColumnHeader columnHeader = new() { Text = testText };
-
-        ListViewColumnHeaderAccessibleObject accessibleObject = new(columnHeader);
-
-        Assert.Equal(testText, accessibleObject.GetPropertyValue(UIA.NamePropertyId));
-        Assert.Equal(testText, accessibleObject.GetPropertyValue(UIA.LegacyIAccessibleNamePropertyId));
-        Assert.Null(accessibleObject.GetPropertyValue(UIA.LegacyIAccessibleDefaultActionPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_IsDisconnected_WhenListViewReleasesUiaProvider()
-    {
-        using ListView listView = new();
-        using ColumnHeader columnHeader = new();
-        listView.Columns.Add(columnHeader);
-        EnforceAccessibleObjectCreation(columnHeader);
-        _ = listView.AccessibilityObject;
-
-        listView.ReleaseUiaProvider(listView.HWND);
-
-        Assert.Null(columnHeader.TestAccessor().Dynamic._accessibilityObject);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_IsDisconnected_WhenListViewIsCleared()
-    {
-        using ListView listView = new();
-        using ColumnHeader columnHeader = new();
-        listView.Columns.Add(columnHeader);
-        EnforceAccessibleObjectCreation(columnHeader);
-
-        listView.Clear();
-
-        Assert.Null(columnHeader.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_IsDisconnected_WhenColumnsAreCleared()
-    {
-        using ListView listView = new();
-        using ColumnHeader columnHeader = new();
-        listView.Columns.Add(columnHeader);
-        EnforceAccessibleObjectCreation(columnHeader);
-
-        listView.Columns.Clear();
-
-        Assert.Null(columnHeader.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewColumnHeaderAccessibleObject_IsDisconnected_WhenColumnIsRemoved()
-    {
-        using ListView listView = new();
-        using ColumnHeader columnHeader = new();
-        listView.Columns.Add(columnHeader);
-        EnforceAccessibleObjectCreation(columnHeader);
-
-        listView.Columns.Remove(columnHeader);
-
-        Assert.Null(columnHeader.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private static void EnforceAccessibleObjectCreation(ColumnHeader columnHeader)
-    {
-        _ = columnHeader.AccessibilityObject;
-        Assert.NotNull(columnHeader.TestAccessor().Dynamic._accessibilityObject);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderCollectionTests.cs
deleted file mode 100644
index ecf98da67ae..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderCollectionTests.cs
+++ /dev/null
@@ -1,1116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class ColumnHeaderCollectionTests
-{
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Ctor_ListView()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new ListView.ColumnHeaderCollection(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IList_GetProperties_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Item_GetValidIndex_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.Same(header, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_Item_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            header
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListItem_GetValidIndex_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.Same(header, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_IListItem_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        IList collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            header
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_IListItem_Set_ThrowsNotSupportedException(int index)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        IList collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            header
-        };
-        Assert.Throws<NotSupportedException>(() => collection[index] = new ColumnHeader());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("longer", -1)]
-    [InlineData("sm", -1)]
-    [InlineData("text", 1)]
-    [InlineData("tsxt", -1)]
-    [InlineData("TEXT", 1)]
-    public void ColumnHeaderCollection_Item_GetString_ReturnsExpected(string key, int expectedIndex)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader
-        {
-            Name = "text"
-        };
-        collection.Add(header1);
-        collection.Add(header2);
-
-        Assert.Equal(expectedIndex != -1 ? collection[expectedIndex] : null, collection[key]);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Add_ColumnHeader_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.Same(header, Assert.Single(collection));
-        Assert.Equal(listView, header.ListView);
-        Assert.Equal(0, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Add_ExistsInSameCollection_ThrowsArgumentException()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.Throws<ArgumentException>("ch", () => collection.Add(header));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Add_ExistsInOtherCollection_ThrowsArgumentException()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var otherListView = new ListView();
-        var otherCollection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        otherCollection.Add(header);
-        Assert.Throws<ArgumentException>("ch", () => collection.Add(header));
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeaderCollection_Add_String_Success(string text, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            text
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_Int_TestData()
-    {
-        yield return new object[] { null, -1, string.Empty };
-        yield return new object[] { string.Empty, 0, string.Empty };
-        yield return new object[] { "text", 1, "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_Int_TestData))]
-    public void ColumnHeaderCollection_Add_String_Int_Success(string text, int width, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { text, width }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_Int_HorizontalAlignment_TestData()
-    {
-        yield return new object[] { null, -1, HorizontalAlignment.Left, string.Empty };
-        yield return new object[] { string.Empty, 0, HorizontalAlignment.Center, string.Empty };
-        yield return new object[] { "text", 1, HorizontalAlignment.Right, "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_Int_HorizontalAlignment_TestData))]
-    public void ColumnHeaderCollection_Add_String_Int_HorizontalAlignment_Success(string text, int width, HorizontalAlignment textAlign, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { text, width, textAlign }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "name", "text", "name", "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_TestData))]
-    public void ColumnHeaderCollection_Add_String_String_Success(string name, string text, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { name, text }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_String_Int_TestData()
-    {
-        yield return new object[] { null, null, -1, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, 0, string.Empty, string.Empty };
-        yield return new object[] { "name", "text", 1, "name", "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_TestData))]
-    public void ColumnHeaderCollection_Add_String_String_Int_Success(string name, string text, int width, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { name, text, width }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_String_Int_HorizontalAlignment_Int_TestData()
-    {
-        yield return new object[] { null, null, -1, HorizontalAlignment.Left, -1, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, 0, HorizontalAlignment.Center, 0, string.Empty, string.Empty };
-        yield return new object[] { "name", "text", 1, HorizontalAlignment.Right, 1, "name", "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_HorizontalAlignment_Int_TestData))]
-    public void ColumnHeaderCollection_Add_String_String_Int_HorizontalAlignment_Int_Success(string name, string text, int width, HorizontalAlignment textAlign, int imageIndex, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { name, text, width, textAlign, imageIndex }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(imageIndex, header.ImageIndex);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    public static IEnumerable<object[]> Add_String_String_Int_HorizontalAlignment_String_TestData()
-    {
-        yield return new object[] { null, null, -1, HorizontalAlignment.Left, null, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, 0, HorizontalAlignment.Center, string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "name", "text", 1, HorizontalAlignment.Right, "imageKey", "name", "text", "imageKey" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_HorizontalAlignment_String_TestData))]
-    public void ColumnHeaderCollection_Add_String_String_Int_HorizontalAlignment_String_Success(string name, string text, int width, HorizontalAlignment textAlign, string imageKey, string expectedName, string expectedText, string expectedImageKey)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            { name, text, width, textAlign, imageKey }
-        };
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(expectedImageKey, header.ImageKey);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Add_NullItem_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentNullException>("ch", () => collection.Add((ColumnHeader)null));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void ColumnHeaderCollection_Add_InvalidTextAlign_ThrowsInvalidEnumArgumentException(HorizontalAlignment textAlign)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => collection.Add("text", 1, textAlign));
-        Assert.Throws<InvalidEnumArgumentException>("value", () => collection.Add("name", "text", 1, textAlign, "imageKey"));
-        Assert.Throws<InvalidEnumArgumentException>("value", () => collection.Add("name", "text", 1, textAlign, 1));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IList_Add_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.Same(header, Assert.Single(collection));
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ColumnHeaderCollection_IListAdd_InvalidValue_ThrowsArgumentException(object value)
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentException>("value", () => collection.Add(value));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_AddRange_ColumnHeaderArray_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header1 = new ColumnHeader("text1");
-        using var header2 = new ColumnHeader("text2");
-        var items = new ColumnHeader[] { header1, header2 };
-        collection.AddRange(items);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Same(header1, collection[0]);
-        Assert.Same(header2, collection[1]);
-
-        Assert.Equal(0, header1.DisplayIndex);
-        Assert.Equal(1, header2.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_AddRange_ColumnHeaderArrayWithDisplayIndex_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header1 = new ColumnHeader("text1")
-        {
-            DisplayIndex = 1
-        };
-        using var header2 = new ColumnHeader("text2")
-        {
-            DisplayIndex = 0
-        };
-        using var header3 = new ColumnHeader("text3")
-        {
-            DisplayIndex = 2
-        };
-        using var header4 = new ColumnHeader("text4")
-        {
-            DisplayIndex = 2
-        };
-        using var header5 = new ColumnHeader("text5")
-        {
-            DisplayIndex = 10
-        };
-        var items = new ColumnHeader[] { header1, header2, header3, header4, header5 };
-        collection.AddRange(items);
-
-        Assert.Equal(5, collection.Count);
-        Assert.Same(header1, collection[0]);
-        Assert.Same(header2, collection[1]);
-        Assert.Same(header3, collection[2]);
-        Assert.Same(header4, collection[3]);
-        Assert.Same(header5, collection[4]);
-
-        Assert.Equal(0, header1.DisplayIndex);
-        Assert.Equal(1, header2.DisplayIndex);
-        Assert.Equal(2, header3.DisplayIndex);
-        Assert.Equal(3, header4.DisplayIndex);
-        Assert.Equal(4, header5.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_AddRange_NullValues_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentNullException>("values", () => collection.AddRange(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_AddRange_NullValueInValues_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentNullException>("values", () => collection.AddRange(new ColumnHeader[] { null }));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Clear_Invoke_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Clear_InvokeWithHandle_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Clear_InvokeTile_Success()
-    {
-        using var listView = new ListView
-        {
-            View = View.Tile
-        };
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Clear_InvokeTileWithHandle_Success()
-    {
-        using var listView = new ListView
-        {
-            View = View.Tile
-        };
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Clear_Empty_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Contains_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        Assert.True(collection.Contains(header));
-        Assert.False(collection.Contains(new ColumnHeader()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Contains_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.False(collection.Contains(new ColumnHeader()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, false)]
-    [InlineData("", false)]
-    [InlineData("longer", false)]
-    [InlineData("sm", false)]
-    [InlineData("text", true)]
-    [InlineData("tsxt", false)]
-    [InlineData("TEXT", true)]
-    public void ColumnHeaderCollection_ContainsKey_Invoke_ReturnsExpected(string key, bool expected)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader
-        {
-            Name = "text"
-        };
-        collection.Add(header1);
-        collection.Add(header2);
-
-        Assert.Equal(expected, collection.ContainsKey(key));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_ContainsKey_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.False(collection.ContainsKey("text"));
-        Assert.False(collection.ContainsKey(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListContains_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        Assert.True(collection.Contains(header));
-        Assert.False(collection.Contains(new ColumnHeader()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListContains_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.False(collection.Contains(new ColumnHeader()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        Assert.Equal(0, collection.IndexOf(header));
-        Assert.Equal(-1, collection.IndexOf(new ColumnHeader()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IndexOf_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.Equal(-1, collection.IndexOf(new ColumnHeader()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("longer", -1)]
-    [InlineData("sm", -1)]
-    [InlineData("text", 1)]
-    [InlineData("tsxt", -1)]
-    [InlineData("TEXT", 1)]
-    public void ColumnHeaderCollection_IndexOfKey_Invoke_ReturnsExpected(string key, int expected)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader
-        {
-            Name = "text"
-        };
-        collection.Add(header1);
-        collection.Add(header2);
-
-        Assert.Equal(expected, collection.IndexOfKey(key));
-
-        // Call again to validate caching behaviour.
-        Assert.Equal(expected, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("noSuchKey"));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IndexOfKey_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.Equal(-1, collection.IndexOfKey("text"));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListIndexOf_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        Assert.Equal(0, collection.IndexOf(header));
-        Assert.Equal(-1, collection.IndexOf(new ColumnHeader()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListIndexOf_Empty_ReturnsMinusOne()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-
-        Assert.Equal(-1, collection.IndexOf(new ColumnHeader()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Insert_ColumnHeader_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(new ColumnHeader());
-        collection.Insert(1, header);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(header, collection[1]);
-        Assert.Same(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeaderCollection_Insert_String_Success(string text, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, text);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_Int_TestData))]
-    public void ColumnHeaderCollection_Insert_String_Int_Success(string text, int width, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, text, width);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_Int_HorizontalAlignment_TestData))]
-    public void ColumnHeaderCollection_Insert_String_Int_HorizontalAlignment_Success(string text, int width, HorizontalAlignment textAlign, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, text, width, textAlign);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_TestData))]
-    public void ColumnHeaderCollection_Insert_String_String_Success(string name, string text, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, name, text);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_TestData))]
-    public void ColumnHeaderCollection_Insert_String_String_Int_Success(string name, string text, int width, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, name, text, width);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_HorizontalAlignment_Int_TestData))]
-    public void ColumnHeaderCollection_Insert_String_String_Int_HorizontalAlignment_Int_Success(string name, string text, int width, HorizontalAlignment textAlign, int imageIndex, string expectedName, string expectedText)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, name, text, width, textAlign, imageIndex);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(imageIndex, header.ImageIndex);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_String_String_Int_HorizontalAlignment_String_TestData))]
-    public void ColumnHeaderCollection_Insert_String_String_Int_HorizontalAlignment_String_Success(string name, string text, int width, HorizontalAlignment textAlign, string imageKey, string expectedName, string expectedText, string expectedImageKey)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, name, text, width, textAlign, imageKey);
-        using ColumnHeader header = Assert.Single(collection.Cast<ColumnHeader>());
-        Assert.Equal(expectedName, header.Name);
-        Assert.Equal(expectedText, header.Text);
-        Assert.Equal(width, header.Width);
-        Assert.Equal(textAlign, header.TextAlign);
-        Assert.Equal(expectedImageKey, header.ImageKey);
-        Assert.Equal(listView, header.ListView);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Insert_NullItem_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            header
-        };
-        Assert.Throws<ArgumentNullException>("ch", () => collection.Insert(1, (ColumnHeader)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, (ColumnHeader)null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListInsert_ColumnHeader_Success()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(new ColumnHeader());
-        collection.Insert(1, header);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(header, collection[1]);
-        Assert.Same(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ColumnHeaderCollection_IListInsert_InvalidItem_Nop(object value)
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        collection.Insert(0, value);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_IListInsert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, new ColumnHeader()));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_Remove_ColumnHeader_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        // Remove null.
-        collection.Remove(null);
-        Assert.Same(header, Assert.Single(collection));
-
-        collection.Remove(header);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(-1, header.DisplayIndex);
-
-        // Remove again.
-        collection.Remove(header);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(-1, header.DisplayIndex);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_IListRemove_ColumnHeader_Success()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        collection.Remove(header);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(-1, header.DisplayIndex);
-
-        // Remove again.
-        collection.Remove(header);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-        Assert.Equal(-1, header.Index);
-        Assert.Equal(-1, header.DisplayIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ColumnHeaderCollection_IListRemove_InvalidItem_Nop(object value)
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        collection.Remove(value);
-        Assert.Same(header, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_RemoveAt_ValidIndex_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-
-        // Remove from start.
-        collection.RemoveAt(0);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-        Assert.Equal(2, collection[2].DisplayIndex);
-
-        // Remove from middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-
-        // Remove from end.
-        collection.RemoveAt(1);
-        Assert.Single(collection);
-        Assert.Equal(0, collection[0].DisplayIndex);
-
-        // Remove only.
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_RemoveAt_HasHandle_Success()
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        // Remove from start.
-        collection.RemoveAt(0);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-        Assert.Equal(2, collection[2].DisplayIndex);
-
-        // Remove from middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-
-        // Remove from end.
-        collection.RemoveAt(1);
-        Assert.Single(collection);
-        Assert.Equal(0, collection[0].DisplayIndex);
-
-        // Remove only.
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_RemoveAt_HasHandleWithTile_Success()
-    {
-        using var listView = new ListView
-        {
-            View = View.Tile
-        };
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-        collection.Add(new ColumnHeader());
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        // Remove from start.
-        collection.RemoveAt(0);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-        Assert.Equal(2, collection[2].DisplayIndex);
-
-        // Remove from middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(0, collection[0].DisplayIndex);
-        Assert.Equal(1, collection[1].DisplayIndex);
-
-        // Remove from end.
-        collection.RemoveAt(1);
-        Assert.Single(collection);
-        Assert.Equal(0, collection[0].DisplayIndex);
-
-        // Remove only.
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(header.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void ColumnHeaderCollection_RemoveAt_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        var collection = new ListView.ColumnHeaderCollection(listView)
-        {
-            header
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeaderCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 1)]
-    [InlineData("longer", 1)]
-    [InlineData("sm", 1)]
-    [InlineData("text", 0)]
-    [InlineData("tsxt", 1)]
-    [InlineData("TEXT", 0)]
-    public void ColumnHeaderCollection_RemoveByKey_Invoke_Success(string key, int expectedCount)
-    {
-        using var listView = new ListView();
-        var collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader
-        {
-            Name = "text"
-        };
-        collection.Add(header);
-
-        collection.RemoveByKey(key);
-        Assert.Equal(expectedCount, collection.Count);
-        if (expectedCount == 0)
-        {
-            Assert.Null(header.ListView);
-        }
-        else
-        {
-            Assert.Same(listView, header.ListView);
-        }
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_CopyTo_NonEmpty_Success()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        using var header = new ColumnHeader();
-        collection.Add(header);
-
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, header, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderCollection_CopyTo_Empty_Nop()
-    {
-        using var listView = new ListView();
-        IList collection = new ListView.ColumnHeaderCollection(listView);
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 0);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderConverterTests.cs
deleted file mode 100644
index 3b61f0872b9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderConverterTests.cs
+++ /dev/null
@@ -1,205 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ColumnHeaderConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(ColumnHeader), false)]
-    public void ColumnHeaderConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    [Theory]
-    [InlineData("value")]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void ColumnHeaderConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(ColumnHeader), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void ColumnHeaderConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    public static IEnumerable<object[]> ConvertTo_InstanceDescriptor_TestData()
-    {
-        yield return new object[]
-        {
-            new ColumnHeader(),
-            Array.Empty<Type>(),
-            Array.Empty<object>()
-        };
-        yield return new object[]
-        {
-            new ColumnHeader("imageKey"),
-            new Type[] { typeof(string) },
-            new object[] { "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ColumnHeader(1),
-            new Type[] { typeof(int) },
-            new object[] { 1 }
-        };
-        yield return new object[]
-        {
-            new PrivateIntConstructor() { ImageIndex = 1 },
-            Array.Empty<Type>(),
-            Array.Empty<object>()
-        };
-        yield return new object[]
-        {
-            new PrivateStringConstructor() { ImageKey = "imageKey" },
-            Array.Empty<Type>(),
-            Array.Empty<object>()
-        };
-        yield return new object[]
-        {
-            new PrivateDefaultConstructor("imageKey"),
-            new Type[] { typeof(string) },
-            new object[] { "imageKey" }
-        };
-        yield return new object[]
-        {
-            new PrivateDefaultConstructor(1),
-            new Type[] { typeof(int) },
-            new object[] { 1 }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertTo_InstanceDescriptor_TestData))]
-    public void ColumnHeaderConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ColumnHeader value, Type[] parameterTypes, object[] arguments)
-    {
-        var converter = new ColumnHeaderConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
-        Assert.Equal(value.GetType().GetConstructor(parameterTypes), descriptor.MemberInfo);
-        Assert.Equal(arguments, descriptor.Arguments);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderConverter_ConvertTo_NoPublicDefaultConstructor_ThrowsArgumentException()
-    {
-        using var value = new PrivateDefaultConstructor(-1);
-        var converter = new ColumnHeaderConverter();
-        Assert.Throws<ArgumentException>(() => converter.ConvertTo(value, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(null, "")]
-    [InlineData(1, "1")]
-    public void ColumnHeaderConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_ConvertTo_ValueNotThrowsNotSupportedException()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(ColumnHeader))]
-    [InlineData(typeof(int))]
-    public void ColumnHeaderConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ColumnHeader(), destinationType));
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.True(converter.GetPropertiesSupported(null));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeaderConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        var converter = new ColumnHeaderConverter();
-        using var item = new ColumnHeader();
-        Assert.Equal(TypeDescriptor.GetProperties(item, null).Count, converter.GetProperties(null, item, null).Count);
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_GetStandardValues_Invoke_ReturnsNull()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.Null(converter.GetStandardValues(null));
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_GetStandardValuesExclusive_Invoke_ReturnsFalse()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.False(converter.GetStandardValuesExclusive(null));
-    }
-
-    [Fact]
-    public void ColumnHeaderConverter_GetStandardValuesSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new ColumnHeaderConverter();
-        Assert.False(converter.GetStandardValuesSupported(null));
-    }
-
-    private class PrivateDefaultConstructor : ColumnHeader
-    {
-        private PrivateDefaultConstructor() : base() { }
-
-        public PrivateDefaultConstructor(string imageKey) : base(imageKey) { }
-
-        public PrivateDefaultConstructor(int imageIndex) : base(imageIndex) { }
-    }
-
-    private class PrivateStringConstructor : ColumnHeader
-    {
-        public PrivateStringConstructor() : base() { }
-
-        private PrivateStringConstructor(string imageKey) : base(imageKey) { }
-
-        public PrivateStringConstructor(int imageIndex) : base(imageIndex) { }
-    }
-
-    private class PrivateIntConstructor : ColumnHeader
-    {
-        public PrivateIntConstructor() : base() { }
-
-        public PrivateIntConstructor(string imageKey) : base(imageKey) { }
-
-        private PrivateIntConstructor(int imageIndex) : base(imageIndex) { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderTests.cs
deleted file mode 100644
index 21d2ca527df..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnHeaderTests.cs
+++ /dev/null
@@ -1,1664 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ColumnHeaderTests
-{
-    [WinFormsFact]
-    public void ColumnHeader_Ctor_Default()
-    {
-        using var header = new SubColumnHeader();
-        Assert.True(header.CanRaiseEvents);
-        Assert.Null(header.Container);
-        Assert.False(header.DesignMode);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.NotNull(header.Events);
-        Assert.Same(header.Events, header.Events);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Equal(string.Empty, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("ColumnHeader", header.Text);
-        Assert.Equal(HorizontalAlignment.Left, header.TextAlign);
-        Assert.Equal(60, header.Width);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_Ctor_Int(int imageIndex)
-    {
-        using var header = new SubColumnHeader(imageIndex);
-        Assert.True(header.CanRaiseEvents);
-        Assert.Null(header.Container);
-        Assert.False(header.DesignMode);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.NotNull(header.Events);
-        Assert.Same(header.Events, header.Events);
-        Assert.Equal(imageIndex, header.ImageIndex);
-        Assert.Equal(string.Empty, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("ColumnHeader", header.Text);
-        Assert.Equal(HorizontalAlignment.Left, header.TextAlign);
-        Assert.Equal(60, header.Width);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Ctor_String(string imageKey, string expectedImageKey)
-    {
-        using var header = new SubColumnHeader(imageKey);
-        Assert.True(header.CanRaiseEvents);
-        Assert.Null(header.Container);
-        Assert.False(header.DesignMode);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.NotNull(header.Events);
-        Assert.Same(header.Events, header.Events);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Equal(expectedImageKey, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("ColumnHeader", header.Text);
-        Assert.Equal(HorizontalAlignment.Left, header.TextAlign);
-        Assert.Equal(60, header.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_DisplayIndex_GetWithListView_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Equal(0, header.DisplayIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_DisplayIndex_SetWithoutListView_GetReturnsExpected(int value)
-    {
-        using var header = new ColumnHeader
-        {
-            DisplayIndex = value
-        };
-        Assert.Equal(value, header.DisplayIndex);
-
-        // Set same.
-        header.DisplayIndex = value;
-        Assert.Equal(value, header.DisplayIndex);
-    }
-
-    public static IEnumerable<object[]> DisplayIndex_Set_TestData()
-    {
-        yield return new object[] { 0, 0, new int[] { 0, 1, 2 } };
-        yield return new object[] { 0, 1, new int[] { 1, 0, 2 } };
-        yield return new object[] { 0, 2, new int[] { 2, 0, 1 } };
-
-        yield return new object[] { 1, 0, new int[] { 1, 0, 2 } };
-        yield return new object[] { 1, 1, new int[] { 0, 1, 2 } };
-        yield return new object[] { 1, 2, new int[] { 0, 2, 1 } };
-
-        yield return new object[] { 2, 0, new int[] { 1, 2, 0 } };
-        yield return new object[] { 2, 1, new int[] { 0, 2, 1 } };
-        yield return new object[] { 2, 2, new int[] { 0, 1, 2 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisplayIndex_Set_TestData))]
-    public void ColumnHeader_DisplayIndex_SetWithListView_GetReturnsExpected(int columnIndex, int value, int[] expectedDisplayIndices)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        using var header3 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-        listView.Columns.Add(header3);
-
-        listView.Columns[columnIndex].DisplayIndex = value;
-        Assert.Equal(expectedDisplayIndices[0], header1.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[1], header2.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[2], header3.DisplayIndex);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Columns[columnIndex].DisplayIndex = value;
-        Assert.Equal(expectedDisplayIndices[0], header1.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[1], header2.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[2], header3.DisplayIndex);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisplayIndex_Set_TestData))]
-    public void ColumnHeader_DisplayIndex_SetWithListViewWithHandle_GetReturnsExpected(int columnIndex, int value, int[] expectedDisplayIndices)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        using var header3 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-        listView.Columns.Add(header3);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.Columns[columnIndex].DisplayIndex = value;
-        Assert.Equal(expectedDisplayIndices[0], header1.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[1], header2.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[2], header3.DisplayIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.Columns[columnIndex].DisplayIndex = value;
-        Assert.Equal(expectedDisplayIndices[0], header1.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[1], header2.DisplayIndex);
-        Assert.Equal(expectedDisplayIndices[2], header3.DisplayIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> DisplayIndex_SetGetColOrderArray_TestData()
-    {
-        yield return new object[] { 0, 0, new int[] { 0, 1, 2 } };
-        yield return new object[] { 0, 1, new int[] { 1, 0, 2 } };
-        yield return new object[] { 0, 2, new int[] { 1, 2, 0 } };
-
-        yield return new object[] { 1, 0, new int[] { 1, 0, 2 } };
-        yield return new object[] { 1, 1, new int[] { 0, 1, 2 } };
-        yield return new object[] { 1, 2, new int[] { 0, 2, 1 } };
-
-        yield return new object[] { 2, 0, new int[] { 2, 0, 1 } };
-        yield return new object[] { 2, 1, new int[] { 0, 2, 1 } };
-        yield return new object[] { 2, 2, new int[] { 0, 1, 2 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisplayIndex_SetGetColOrderArray_TestData))]
-    public void ColumnHeader_DisplayIndex_GetColumnOrderArray_Success(int columnIndex, int value, int[] expectedDisplayIndices)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        using var header3 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-        listView.Columns.Add(header3);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        listView.Columns[columnIndex].DisplayIndex = value;
-        var result = new int[3];
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNORDERARRAY, 3, ref result[0]));
-        Assert.Equal(expectedDisplayIndices, result);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ColumnHeader_DisplayIndex_SetInvalidWithListView_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Throws<ArgumentOutOfRangeException>("DisplayIndex", () => header.DisplayIndex = value);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_DisplayIndex_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.DisplayIndex)];
-        using var item = new ColumnHeader();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.DisplayIndex = -1;
-        Assert.Equal(-1, item.DisplayIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.DisplayIndex = 0;
-        Assert.Equal(0, item.DisplayIndex);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.DisplayIndex);
-        Assert.True(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_DisplayIndex_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.DisplayIndex)];
-        using var item = new ColumnHeader();
-        Assert.False(property.CanResetValue(item));
-
-        item.DisplayIndex = -1;
-        Assert.Equal(-1, item.DisplayIndex);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.DisplayIndex = 0;
-        Assert.Equal(0, item.DisplayIndex);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.DisplayIndex);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_SetWithoutListView_GetReturnsExpected(int value)
-    {
-        using var header = new ColumnHeader
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_SetWithImageKey_GetReturnsExpected(int value)
-    {
-        using var header = new ColumnHeader
-        {
-            ImageKey = "ImageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, header.ImageKey);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, header.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_SetWithListView_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_SetWithListViewWithEmptyList_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageIndex = value;
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void ColumnHeader_ImageIndex_SetWithListViewWithNotEmptyList_GetReturnsExpected(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageIndex = value;
-        Assert.Equal(expected, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(expected, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_SetWithListViewWithHandle_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        header.ImageIndex = value;
-        Assert.Equal(value, header.ImageIndex);
-        Assert.Empty(header.ImageKey);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ColumnHeader_ImageIndex_GetColumnWithoutImageList_Success(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.ImageIndex = value;
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_IMAGE
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, 0, ref column));
-        Assert.Equal(0, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 0)]
-    public void ColumnHeader_ImageIndex_GetColumnWithImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.ImageIndex = value;
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_IMAGE | LVCOLUMNW_MASK.LVCF_FMT,
-            fmt = LVCOLUMNW_FORMAT.LVCFMT_IMAGE
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, 0, ref column));
-        Assert.Equal(expected, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    public void ColumnHeader_ImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var header = new ColumnHeader();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => header.ImageIndex = value);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ImageIndex_SetInvalidSetColumn_ThrowsInvalidOperationException()
-    {
-        using var listView = new InvalidSetColumnListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        listView.MakeInvalid = true;
-        Assert.Throws<InvalidOperationException>(() => header.ImageIndex = 0);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_ImageKey_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        using var header = new ColumnHeader
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("ImageKey", "ImageKey")]
-    public void ColumnHeader_ImageKey_SetWithImageIndex_GetReturnsExpected(string value, string expectedImageKey)
-    {
-        using var header = new ColumnHeader
-        {
-            ImageIndex = 0,
-            ImageKey = value
-        };
-        Assert.Equal(expectedImageKey, header.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, header.ImageIndex);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expectedImageKey, header.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, header.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_ImageKey_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_ImageKey_SetWithListViewWithEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Image1", "Image1")]
-    [InlineData("image1", "image1")]
-    [InlineData("Image2", "Image2")]
-    [InlineData("NoSuchImage", "NoSuchImage")]
-    public void ColumnHeader_ImageKey_SetWithListViewWithNotEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_ImageKey_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        header.ImageKey = value;
-        Assert.Equal(expected, header.ImageKey);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Image1")]
-    [InlineData("image1")]
-    [InlineData("Image2")]
-    [InlineData("NoSuchImage")]
-    public void ColumnHeader_ImageKey_GetColumnWithoutImageList_Success(string value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.ImageKey = value;
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_IMAGE
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, 0, ref column));
-        Assert.Equal(0, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("Image1", 0)]
-    [InlineData("image1", 0)]
-    [InlineData("Image2", 1)]
-    [InlineData("NoSuchImage", 0)]
-    public void ColumnHeader_ImageKey_GetColumnWithImageList_Success(string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.ImageKey = value;
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_IMAGE | LVCOLUMNW_MASK.LVCF_FMT,
-            fmt = LVCOLUMNW_FORMAT.LVCFMT_IMAGE
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, 0, ref column));
-        Assert.Equal(expected, column.iImage);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ImageKey_SetInvalidSetColumn_ThrowsInvalidOperationException()
-    {
-        using var listView = new InvalidSetColumnListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        listView.MakeInvalid = true;
-        Assert.Throws<InvalidOperationException>(() => header.ImageKey = "Key");
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ImageList_GetWithListViewWithoutImageList_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Null(header.ImageList);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ImageList_GetWithListViewWithImageList_ReturnsExpected()
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            SmallImageList = imageList
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Same(listView.SmallImageList, header.ImageList);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Index_GetWithListView_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Equal(0, header.Index);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ListView_GetWithListView_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.Same(listView, header.ListView);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Name_GetWithSite_ReturnsExpected(string name, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(x => x.Name)
-            .Returns(name);
-        mockSite
-            .Setup(x => x.Container)
-            .Returns((IContainer)null);
-        using var header = new ColumnHeader
-        {
-            Site = mockSite.Object
-        };
-        Assert.Equal(expected, header.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Name_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        using var header = new ColumnHeader
-        {
-            Name = value
-        };
-        Assert.Equal(expected, header.Name);
-
-        // Set same.
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Name_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Name_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Name_SetWithSite_GetReturnsExpected(string value, string expected)
-    {
-        using var header = new ColumnHeader
-        {
-            Site = Mock.Of<ISite>(),
-            Name = value
-        };
-        Assert.Equal(expected, header.Name);
-        Assert.Equal(value, header.Site.Name);
-
-        // Set same.
-        header.Name = value;
-        Assert.Equal(expected, header.Name);
-        Assert.Equal(value, header.Site.Name);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Name_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.Name)];
-        using var header = new ColumnHeader();
-        Assert.False(property.CanResetValue(header));
-
-        // Set null.
-        header.Name = null;
-        Assert.Empty(header.Name);
-        Assert.False(property.CanResetValue(header));
-
-        // Set empty.
-        header.Name = string.Empty;
-        Assert.Empty(header.Name);
-        Assert.False(property.CanResetValue(header));
-
-        // Set custom
-        header.Name = "name";
-        Assert.Equal("name", header.Name);
-        Assert.False(property.CanResetValue(header));
-
-        property.ResetValue(header);
-        Assert.Equal("name", header.Name);
-        Assert.False(property.CanResetValue(header));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Name_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.Name)];
-        using var header = new ColumnHeader();
-        Assert.False(property.ShouldSerializeValue(header));
-
-        // Set null.
-        header.Name = null;
-        Assert.Empty(header.Name);
-        Assert.False(property.ShouldSerializeValue(header));
-
-        // Set empty.
-        header.Name = string.Empty;
-        Assert.Empty(header.Name);
-        Assert.False(property.ShouldSerializeValue(header));
-
-        // Set custom
-        header.Name = "name";
-        Assert.Equal("name", header.Name);
-        Assert.True(property.ShouldSerializeValue(header));
-
-        property.ResetValue(header);
-        Assert.Equal("name", header.Name);
-        Assert.True(property.ShouldSerializeValue(header));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name", "name", true)]
-    [InlineData(null, "", false)]
-    public void ColumnHeader_Name_WithSite_ShouldSerializeValue_Success(string name, string resultingName, bool result)
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.Name)];
-
-        // Get name from the Site
-        using ColumnHeader header = new ColumnHeader();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name);
-        mockSite
-            .Setup(s => s.Component)
-            .Returns(header);
-        // Container is accessed when disposing the ColumnHeader component.
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        header.Site = mockSite.Object;
-
-        Assert.Equal(resultingName, header.Name);
-        Assert.Equal(result, property.ShouldSerializeValue(header));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ColumnHeader_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var header = new ColumnHeader
-        {
-            Tag = value
-        };
-        Assert.Equal(value, header.Tag);
-
-        // Set same.
-        header.Tag = value;
-        Assert.Equal(value, header.Tag);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Text_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        using var header = new ColumnHeader
-        {
-            Text = value
-        };
-        Assert.Equal(expected, header.Text);
-
-        // Set same.
-        header.Text = value;
-        Assert.Equal(expected, header.Text);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Text_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.Text = value;
-        Assert.Equal(expected, header.Text);
-
-        // Set same.
-        header.Text = value;
-        Assert.Equal(expected, header.Text);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ColumnHeader_Text_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        header.Text = value;
-        Assert.Equal(expected, header.Text);
-
-        // Set same.
-        header.Text = value;
-        Assert.Equal(expected, header.Text);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public unsafe void ColumnHeader_Text_GetColumn_Success(string value, string expected)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.Text = value;
-        char* buffer = stackalloc char[256];
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_TEXT,
-            pszText = buffer,
-            cchTextMax = 256
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, 0, ref column));
-        Assert.Equal(expected, new string(column.pszText));
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, true, HorizontalAlignment.Left)]
-    [InlineData(RightToLeft.Yes, true, HorizontalAlignment.Left)]
-    [InlineData(RightToLeft.Inherit, true, HorizontalAlignment.Left)]
-    [InlineData(RightToLeft.No, false, HorizontalAlignment.Left)]
-    [InlineData(RightToLeft.Yes, false, HorizontalAlignment.Right)]
-    [InlineData(RightToLeft.Inherit, false, HorizontalAlignment.Left)]
-    public void ColumnHeader_TextAlign_GetWithListView_ReturnsExpected(RightToLeft rightToLeft, bool rightToLeftLayout, HorizontalAlignment expected)
-    {
-        using var listView = new ListView
-        {
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-        Assert.Equal(HorizontalAlignment.Left, header1.TextAlign);
-        Assert.Equal(expected, header2.TextAlign);
-
-        // Get again to test caching.
-        Assert.Equal(HorizontalAlignment.Left, header1.TextAlign);
-        Assert.Equal(expected, header2.TextAlign);
-
-        // Change listView.
-        listView.RightToLeft = RightToLeft.No;
-        listView.RightToLeftLayout = false;
-        Assert.Equal(HorizontalAlignment.Left, header1.TextAlign);
-        Assert.Equal(expected, header2.TextAlign);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Text_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.Text)];
-        using var header = new ColumnHeader();
-        Assert.False(property.CanResetValue(header));
-
-        // Set null.
-        header.Text = null;
-        Assert.Empty(header.Text);
-        Assert.True(property.CanResetValue(header));
-
-        // Set empty.
-        header.Text = string.Empty;
-        Assert.Empty(header.Text);
-        Assert.True(property.CanResetValue(header));
-
-        // Set custom
-        header.Text = "text";
-        Assert.Equal("text", header.Text);
-        Assert.True(property.CanResetValue(header));
-
-        property.ResetValue(header);
-        Assert.Empty(header.Text);
-        Assert.True(property.CanResetValue(header));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Text_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ColumnHeader))[nameof(ColumnHeader.Text)];
-        using var header = new ColumnHeader();
-        Assert.False(property.ShouldSerializeValue(header));
-
-        // Set null.
-        header.Text = null;
-        Assert.Empty(header.Text);
-        Assert.True(property.ShouldSerializeValue(header));
-
-        // Set empty.
-        header.Text = string.Empty;
-        Assert.Empty(header.Text);
-        Assert.True(property.ShouldSerializeValue(header));
-
-        // Set custom
-        header.Text = "text";
-        Assert.Equal("text", header.Text);
-        Assert.True(property.ShouldSerializeValue(header));
-
-        property.ResetValue(header);
-        Assert.Empty(header.Text);
-        Assert.True(property.ShouldSerializeValue(header));
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void ColumnHeader_TextAlign_SetWithoutListView_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var header = new ColumnHeader
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, header.TextAlign);
-
-        // Set same.
-        header.TextAlign = value;
-        Assert.Equal(value, header.TextAlign);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, HorizontalAlignment.Center, HorizontalAlignment.Left)]
-    [InlineData(0, HorizontalAlignment.Left, HorizontalAlignment.Left)]
-    [InlineData(0, HorizontalAlignment.Right, HorizontalAlignment.Left)]
-    [InlineData(1, HorizontalAlignment.Center, HorizontalAlignment.Center)]
-    [InlineData(1, HorizontalAlignment.Left, HorizontalAlignment.Left)]
-    [InlineData(1, HorizontalAlignment.Right, HorizontalAlignment.Right)]
-    public void ColumnHeader_TextAlign_SetWithListView_GetReturnsExpected(int columnIndex, HorizontalAlignment value, HorizontalAlignment expected)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-
-        listView.Columns[columnIndex].TextAlign = value;
-        Assert.Equal(expected, listView.Columns[columnIndex].TextAlign);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Columns[columnIndex].TextAlign = value;
-        Assert.Equal(expected, listView.Columns[columnIndex].TextAlign);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, HorizontalAlignment.Center, HorizontalAlignment.Left)]
-    [InlineData(0, HorizontalAlignment.Left, HorizontalAlignment.Left)]
-    [InlineData(0, HorizontalAlignment.Right, HorizontalAlignment.Left)]
-    [InlineData(1, HorizontalAlignment.Center, HorizontalAlignment.Center)]
-    [InlineData(1, HorizontalAlignment.Left, HorizontalAlignment.Left)]
-    [InlineData(1, HorizontalAlignment.Right, HorizontalAlignment.Right)]
-    public void ColumnHeader_TextAlign_SetWithListViewWithHandle_GetReturnsExpected(int columnIndex, HorizontalAlignment value, HorizontalAlignment expected)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.Columns[columnIndex].TextAlign = value;
-        Assert.Equal(expected, listView.Columns[columnIndex].TextAlign);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.Columns[columnIndex].TextAlign = value;
-        Assert.Equal(expected, listView.Columns[columnIndex].TextAlign);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, HorizontalAlignment.Center, 0x4000)]
-    [InlineData(0, HorizontalAlignment.Left, 0x4000)]
-    [InlineData(0, HorizontalAlignment.Right, 0x4000)]
-    [InlineData(1, HorizontalAlignment.Center, 0x4002)]
-    [InlineData(1, HorizontalAlignment.Left, 0x4000)]
-    [InlineData(1, HorizontalAlignment.Right, 0x4001)]
-    public unsafe void ColumnHeader_TextAlign_GetColumn_Success(int columnIndex, HorizontalAlignment value, int expected)
-    {
-        using var listView = new ListView();
-        using var header1 = new ColumnHeader();
-        using var header2 = new ColumnHeader();
-        listView.Columns.Add(header1);
-        listView.Columns.Add(header2);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        listView.Columns[columnIndex].TextAlign = value;
-        var column = new ComCtl32.LVCOLUMNW
-        {
-            mask = LVCOLUMNW_MASK.LVCF_FMT
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNW, (WPARAM)columnIndex, ref column));
-        Assert.Equal(expected, (int)column.fmt);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void ColumnHeader_TextAlign_SetInvalid_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
-    {
-        using var header = new ColumnHeader();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => header.TextAlign = value);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Width_GetWithListView_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.Equal(60, header.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Width_GetWithListViewWithHandle_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(60, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Width_GetWithListViewWithHandleWithDetails_GetReturnsExpected()
-    {
-        using var listView = new ListView
-        {
-            View = View.Details
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(header.Width, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Width_Set_TestData()
-    {
-        yield return new object[] { -3 };
-        yield return new object[] { -2 };
-        yield return new object[] { -1 };
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 60 };
-        yield return new object[] { 75 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_Set_TestData))]
-    public void ColumnHeader_Width_SetWithoutListView_GetReturnsExpected(int value)
-    {
-        using var header = new ColumnHeader
-        {
-            Width = value
-        };
-        Assert.Equal(value, header.Width);
-
-        // Set same.
-        header.Width = value;
-        Assert.Equal(value, header.Width);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_Set_TestData))]
-    public void ColumnHeader_Width_SetWithListView_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.Width = value;
-        Assert.Equal(value, header.Width);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        header.Width = value;
-        Assert.Equal(value, header.Width);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_Set_TestData))]
-    public void ColumnHeader_Width_SetWithListViewWithHandle_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        header.Width = value;
-        Assert.Equal(value, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        header.Width = value;
-        Assert.Equal(value, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(60)]
-    [InlineData(75)]
-    public void ColumnHeader_Width_GetColumnWidth_ReturnsExpected(int value)
-    {
-        using var listView = new ListView
-        {
-            View = View.Details
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.Width = value;
-        Assert.Equal(value, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNWIDTH));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-3)]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void ColumnHeader_Width_GetColumnWidthCustom_ReturnsExpected(int value)
-    {
-        using var listView = new ListView
-        {
-            View = View.Details
-        };
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        header.Width = value;
-        Assert.True(PInvoke.SendMessage(listView, PInvoke.LVM_GETCOLUMNWIDTH) > 0);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColumnHeaderAutoResizeStyle>]
-    public void ColumnHeader_AutoSize_WithoutListView_Nop(ColumnHeaderAutoResizeStyle headerAutoResize)
-    {
-        using var header = new ColumnHeader();
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-
-        // Call again.
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColumnHeaderAutoResizeStyle>]
-    public void ColumnHeader_AutoSize_WithListView_Success(ColumnHeaderAutoResizeStyle headerAutoResize)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-        Assert.True(listView.IsHandleCreated);
-
-        // Call again.
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColumnHeaderAutoResizeStyle>]
-    public void ColumnHeader_AutoSize_WithListViewWithHandle_Success(ColumnHeaderAutoResizeStyle headerAutoResize)
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        header.AutoResize(headerAutoResize);
-        Assert.Equal(60, header.Width);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ColumnHeaderAutoResizeStyle>]
-    public void ColumnHeader_AutoSize_InvalidHeaderAutoResize_ThrowsInvalidEnumArgumentException(ColumnHeaderAutoResizeStyle headerAutoResize)
-    {
-        using var header = new ColumnHeader();
-        Assert.Throws<InvalidEnumArgumentException>("headerAutoResize", () => header.AutoResize(headerAutoResize));
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Clone_Invoke_ReturnsExpected()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var source = new ColumnHeader
-        {
-            DisplayIndex = 1,
-            ImageKey = "imageKey",
-            ImageIndex = 1,
-            Name = "name",
-            Site = mockSite.Object,
-            Tag = "tag",
-            Text = "text",
-            TextAlign = HorizontalAlignment.Center,
-            Width = 10
-        };
-        using ColumnHeader header = Assert.IsType<ColumnHeader>(source.Clone());
-        Assert.NotSame(header, source);
-        Assert.Null(header.Container);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Equal(string.Empty, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("text", header.Text);
-        Assert.Equal(HorizontalAlignment.Center, header.TextAlign);
-        Assert.Equal(10, header.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Clone_InvokeWithListView_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var source = new ColumnHeader
-        {
-            DisplayIndex = 1,
-            ImageKey = "imageKey",
-            ImageIndex = 1,
-            Name = "name",
-            Site = mockSite.Object,
-            Tag = "tag",
-            Text = "text",
-            TextAlign = HorizontalAlignment.Center,
-            Width = 10
-        };
-        listView.Columns.Add(source);
-
-        using ColumnHeader header = Assert.IsType<ColumnHeader>(source.Clone());
-        Assert.NotSame(header, source);
-        Assert.Null(header.Container);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Equal(string.Empty, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("text", header.Text);
-        Assert.Equal(HorizontalAlignment.Center, header.TextAlign);
-        Assert.Equal(10, header.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Clone_InvokeSubClass_ReturnsExpected()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var source = new SubColumnHeader
-        {
-            DisplayIndex = 1,
-            ImageKey = "imageKey",
-            ImageIndex = 1,
-            Name = "name",
-            Site = mockSite.Object,
-            Tag = "tag",
-            Text = "text",
-            TextAlign = HorizontalAlignment.Center,
-            Width = 10
-        };
-        using SubColumnHeader header = Assert.IsType<SubColumnHeader>(source.Clone());
-        Assert.NotSame(header, source);
-        Assert.True(header.CanRaiseEvents);
-        Assert.Null(header.Container);
-        Assert.False(header.DesignMode);
-        Assert.Equal(-1, header.DisplayIndex);
-        Assert.NotNull(header.Events);
-        Assert.Same(header.Events, header.Events);
-        Assert.Equal(-1, header.ImageIndex);
-        Assert.Equal(string.Empty, header.ImageKey);
-        Assert.Null(header.ImageList);
-        Assert.Equal(-1, header.Index);
-        Assert.Null(header.ListView);
-        Assert.Empty(header.Name);
-        Assert.Null(header.Site);
-        Assert.Null(header.Tag);
-        Assert.Equal("text", header.Text);
-        Assert.Equal(HorizontalAlignment.Center, header.TextAlign);
-        Assert.Equal(10, header.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Dispose_WithoutListView_Success()
-    {
-        using var header = new ColumnHeader();
-        header.Dispose();
-        header.Dispose();
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_Dispose_WithListView_Success()
-    {
-        using var listView = new ListView();
-        using var header = new ColumnHeader();
-        listView.Columns.Add(header);
-        header.Dispose();
-        Assert.Empty(listView.Columns);
-
-        header.Dispose();
-        Assert.Empty(listView.Columns);
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ToString_Invoke_ReturnsExpected()
-    {
-        using var header = new ColumnHeader();
-        Assert.Equal($"ColumnHeader: Text: ColumnHeader", header.ToString());
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ColumnHeader_ToString_InvokeWithText_ReturnsExpected(string value)
-    {
-        using var header = new ColumnHeader
-        {
-            Text = value
-        };
-        Assert.Equal($"ColumnHeader: Text: {header.Text}", header.ToString());
-    }
-
-    private class InvalidSetColumnListView : ListView
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.LVM_SETCOLUMNW)
-            {
-                m.Result = IntPtr.Zero;
-            }
-            else
-            {
-                base.WndProc(ref m);
-            }
-        }
-    }
-
-    [WinFormsFact]
-    public void ColumnHeader_ImageIndexer_SetImageList_Nop()
-    {
-        using (new NoAssertContext())
-        {
-            using var imageList = new ImageList();
-            using var imageList2 = new ImageList();
-            using var listView = new ListView
-            {
-                SmallImageList = imageList
-            };
-            using var header = new ColumnHeader();
-            listView.Columns.Add(header);
-            var indexer = new ColumnHeader.ColumnHeaderImageListIndexer(header);
-            indexer.ImageList = imageList2;
-            Assert.Same(imageList, indexer.ImageList);
-        }
-    }
-
-    private class SubColumnHeader : ColumnHeader
-    {
-        public SubColumnHeader() : base()
-        {
-        }
-
-        public SubColumnHeader(int imageIndex) : base(imageIndex)
-        {
-        }
-
-        public SubColumnHeader(string imageKey) : base(imageKey)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new bool DesignMode => base.DesignMode;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnReorderedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnReorderedEventArgsTests.cs
deleted file mode 100644
index ea0d8213f52..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnReorderedEventArgsTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ColumnReorderedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_Int_ColumnHeader_TestData()
-    {
-        yield return new object[] { -1, -1, null };
-        yield return new object[] { 0, 0, null };
-        yield return new object[] { 1, 2, new ColumnHeader() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_Int_ColumnHeader_TestData))]
-    public void Ctor_Int_Int_ColumnHeader(int oldDisplayIndex, int newDisplayIndex, ColumnHeader header)
-    {
-        var e = new ColumnReorderedEventArgs(oldDisplayIndex, newDisplayIndex, header);
-        Assert.Equal(oldDisplayIndex, e.OldDisplayIndex);
-        Assert.Equal(newDisplayIndex, e.NewDisplayIndex);
-        Assert.Equal(header, e.Header);
-        Assert.False(e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnStyleTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnStyleTests.cs
deleted file mode 100644
index d345cbdb9e2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnStyleTests.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ColumnStyleTests
-{
-    [WinFormsFact]
-    public void ColumnStyle_Ctor_Default()
-    {
-        var style = new ColumnStyle();
-        Assert.Equal(SizeType.AutoSize, style.SizeType);
-        Assert.Equal(0, style.Width);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SizeType>]
-    [InvalidEnumData<SizeType>]
-    public void ColumnStyle_Ctor_SizeType(SizeType sizeType)
-    {
-        var style = new ColumnStyle(sizeType);
-        Assert.Equal(sizeType, style.SizeType);
-        Assert.Equal(0, style.Width);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SizeType.AutoSize, 0)]
-    [InlineData(SizeType.Absolute, 1)]
-    [InlineData(SizeType.Percent, 2)]
-    [InlineData((SizeType)(SizeType.AutoSize - 1), 3)]
-    [InlineData((SizeType)(SizeType.Percent + 1), 4)]
-    public void ColumnStyle_Ctor_SizeType_Float(SizeType sizeType, float width)
-    {
-        var style = new ColumnStyle(sizeType, width);
-        Assert.Equal(sizeType, style.SizeType);
-        Assert.Equal(width, style.Width);
-    }
-
-    [WinFormsFact]
-    public void ColumnStyle_Ctor_NegativeWidth_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new ColumnStyle(SizeType.AutoSize, -1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(float.MaxValue)]
-    public void ColumnStyle_Width_Set_GetReturnsExpected(float value)
-    {
-        var style = new ColumnStyle
-        {
-            Width = value
-        };
-        Assert.Equal(value, style.Width);
-
-        // Set same.
-        style.Width = value;
-        Assert.Equal(value, style.Width);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(float.MaxValue, 1)]
-    public void ColumnStyle_Width_SetWithOwner_GetReturnsExpected(float value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new ColumnStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.Width = value;
-        Assert.Equal(value, style.Width);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        style.Width = value;
-        Assert.Equal(value, style.Width);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(float.MaxValue, 1)]
-    public void ColumnStyle_Width_SetWithOwnerWithHandle_GetReturnsExpected(float value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new ColumnStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.Width = value;
-        Assert.Equal(value, style.Width);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        style.Width = value;
-        Assert.Equal(value, style.Width);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ColumnStyle_Width_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var style = new ColumnStyle();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => style.Width = -1);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangedEventArgsTests.cs
deleted file mode 100644
index 97f42b2f589..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangedEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ColumnWidthChangedEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int columnIndex)
-    {
-        var e = new ColumnWidthChangedEventArgs(columnIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangingEventArgsTests.cs
deleted file mode 100644
index 22737104566..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ColumnWidthChangingEventArgsTests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ColumnWidthChangingEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1, true)]
-    [InlineData(0, 0, false)]
-    [InlineData(1, 2, true)]
-    public void Ctor_Int_Int_Bool(int columnIndex, int newWidth, bool cancel)
-    {
-        var e = new ColumnWidthChangingEventArgs(columnIndex, newWidth, cancel);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(newWidth, e.NewWidth);
-        Assert.Equal(cancel, e.Cancel);
-    }
-
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int columnIndex, int newWidth)
-    {
-        var e = new ColumnWidthChangingEventArgs(columnIndex, newWidth);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(newWidth, e.NewWidth);
-        Assert.False(e.Cancel);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void NewWidth_Set_GetReturnsExpected(int value)
-    {
-        var e = new ColumnWidthChangingEventArgs(2, 3)
-        {
-            NewWidth = value
-        };
-        Assert.Equal(value, e.NewWidth);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ChildAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ChildAccessibleObjectTests.cs
deleted file mode 100644
index 5a045ee97fd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ChildAccessibleObjectTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ChildAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ChildAccessibleObject_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ComboBox.ChildAccessibleObject(null, IntPtr.Zero));
-    }
-
-    [WinFormsFact]
-    public void ChildAccessibleObject_Ctor_Default()
-    {
-        using var control = new ComboBox();
-        control.CreateControl();
-
-        var accessibleObject = new ComboBox.ChildAccessibleObject(control, IntPtr.Zero);
-
-        Assert.NotNull(accessibleObject.TestAccessor().Dynamic._owner);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Some string for test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void ChildAccessibleObject_Name_Default(string testName)
-    {
-        using var control = new ComboBox();
-        control.AccessibilityObject.Name = testName;
-        control.CreateControl();
-
-        var accessibleObject = new ComboBox.ChildAccessibleObject(control, IntPtr.Zero);
-
-        Assert.Equal(testName, accessibleObject.Name);
-        Assert.True(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxAccessibleObjectTests.cs
deleted file mode 100644
index fd249ca4279..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,512 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ComboBox)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ComboBoxAccessibleObject_Ctor_Default(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using ComboBox control = new ComboBox();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        ComboBox.ComboBoxAccessibleObject accessibleObject = new ComboBox.ComboBoxAccessibleObject(control);
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.NotNull(accessibleObject.Owner);
-        Assert.Equal(expectedAccessibleRole, accessibleObject.Role);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    public void ComboBoxAccessibleObject_ExpandCollapse_Set_CollapsedState_IfControlIsCreated(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox control = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-        control.CreateControl();
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-
-        accessibleObject.Expand();
-        Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed);
-        Assert.Equal(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded);
-
-        accessibleObject.Collapse();
-        Assert.Equal(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed);
-        Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded);
-
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    public void ComboBoxAccessibleObject_ExpandCollapse_Set_CollapsedState_IfControlIsNotCreated(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox control = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        Assert.False(control.IsHandleCreated);
-
-        accessibleObject.Expand();
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed);
-        Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded);
-
-        accessibleObject.Collapse();
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed);
-        Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxAccessibleObject_FragmentNavigate_FirstChild_ReturnNull_IfHandleNotCreated(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        AccessibleObject accessibleObject = comboBox.AccessibilityObject;
-        UiaCore.IRawElementProviderFragment firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-
-        Assert.Null(firstChild);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test text")]
-    [InlineData(null)]
-    public void ComboBoxEditAccessibleObject_NameNotNull(string name)
-    {
-        using ComboBox control = new ComboBox();
-        control.AccessibleName = name;
-        control.CreateControl(false);
-        object editAccessibleName = control.ChildEditAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-        Assert.NotNull(editAccessibleName);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxEditAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        const string name = "Test text";
-        using ComboBox comboBox = new();
-
-        Assert.Null(comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Null(comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-
-        comboBox.AccessibleName = name;
-        comboBox.CreateControl(false);
-
-        Assert.Equal(name, comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Equal(name, comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ComboBoxAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    bool childListDisplayed = droppedDown || comboBoxStyle == ComboBoxStyle.Simple;
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown, childListDisplayed };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_TestData))]
-    public void ComboBoxAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown,
-        bool childListDisplayed)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject firstChild = comboBox.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-
-        Assert.NotNull(firstChild);
-        Assert.Equal(childListDisplayed, firstChild == comboBox.ChildListAccessibleObject);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ComboBoxAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_TestData))]
-    public void ComboBoxAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected(ComboBoxStyle comboBoxStyle, bool createControl, bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject lastChild = comboBox.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        AccessibleObject expectedLastChild = comboBoxStyle == ComboBoxStyle.Simple
-            ? comboBox.ChildEditAccessibleObject
-            : GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider;
-
-        Assert.NotNull(lastChild);
-        Assert.Equal(expectedLastChild, lastChild);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxAccessibleObject_FragmentNavigate_LastChild_ReturnNull_IfHandleNotCreated(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        AccessibleObject accessibleObject = comboBox.AccessibilityObject;
-        UiaCore.IRawElementProviderFragment lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.Null(lastChild);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    private ComboBox.ComboBoxAccessibleObject GetComboBoxAccessibleObject(ComboBox comboBox)
-    {
-        return comboBox.AccessibilityObject as ComboBox.ComboBoxAccessibleObject;
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_ControlType_IsComboBox_IfAccessibleRoleIsDefault()
-    {
-        using ComboBox control = new ComboBox();
-        // AccessibleRole is not set = Default
-
-        object actual = control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ComboBoxControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ComboBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ComboBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.AccessibleRole = role;
-
-        object actual = comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxEditAccessibleObject_GetPropertyValue_NativeWindowHandle_ReturnsExpected()
-    {
-        using ComboBox comboBox = new();
-        comboBox.CreateControl(false);
-        object actual = comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NativeWindowHandlePropertyId);
-
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal((nint)comboBox.InternalHandle, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void ComboBoxAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using ComboBox comboBox = new();
-        comboBox.CreateControl(false);
-        ComboBox.ComboBoxAccessibleObject accessibleObject = (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_DefaultAction_IfAccessibleDefaultActionDescriptionIsNotNull_ReturnsAccessibleDefaultActionDescription()
-    {
-        using ComboBox comboBox = new() { AccessibleDefaultActionDescription = "Test" };
-
-        Assert.Equal(comboBox.AccessibleDefaultActionDescription, comboBox.AccessibilityObject.DefaultAction);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_DefaultAction_IfHandleIsNotCreated_ReturnsNull()
-    {
-        using ComboBox comboBox = new();
-
-        Assert.Empty(comboBox.AccessibilityObject.DefaultAction);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_DefaultAction_IfHandleIsCreatedAndDropDownStyleIsSimple_ReturnsNull()
-    {
-        using ComboBox comboBox = new() { DropDownStyle = ComboBoxStyle.Simple };
-        comboBox.CreateControl();
-
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Empty(comboBox.AccessibilityObject.DefaultAction);
-    }
-
-    public static IEnumerable<object[]> ComboBoxAccessibleObject_DefaultAction_IfHandleIsCreated_ReturnsExpected_TestData()
-    {
-        yield return new object[] { ComboBoxStyle.DropDown, false, SR.AccessibleActionExpand };
-        yield return new object[] { ComboBoxStyle.DropDown, true, SR.AccessibleActionCollapse };
-        yield return new object[] { ComboBoxStyle.DropDownList, false, SR.AccessibleActionExpand };
-        yield return new object[] { ComboBoxStyle.DropDownList, true, SR.AccessibleActionCollapse };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxAccessibleObject_DefaultAction_IfHandleIsCreated_ReturnsExpected_TestData))]
-    public void ComboBoxAccessibleObject_DefaultAction_IfHandleIsCreated_ReturnsExpected(ComboBoxStyle style, bool droppedDown, string expectedAction)
-    {
-        using ComboBox comboBox = new() { DropDownStyle = style };
-        comboBox.CreateControl();
-        comboBox.DroppedDown = droppedDown;
-
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal(expectedAction, comboBox.AccessibilityObject.DefaultAction);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxAccessibleObject_DefaultAction_IfHandleIsCreated_ReturnsExpected_TestData))]
-    public void ComboBoxAccessibleObject_GetPropertyValue_IfHandleIsCreated_ReturnsExpected(ComboBoxStyle style, bool droppedDown, string expectedAction)
-    {
-        using ComboBox comboBox = new() { DropDownStyle = style };
-        comboBox.CreateControl();
-        comboBox.DroppedDown = droppedDown;
-
-        Assert.Equal(expectedAction, comboBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_DoDefaultAction_IfHandleIsNotCreated_DoesNotExpand()
-    {
-        using ComboBox comboBox = new();
-
-        Assert.False(comboBox.DroppedDown);
-
-        comboBox.AccessibilityObject.DoDefaultAction();
-
-        Assert.False(comboBox.DroppedDown);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxAccessibleObject_DoDefaultAction_IfHandleIsCreatedAndDropDownStyleIsSimple_DoesNotCollapse()
-    {
-        using ComboBox comboBox = new() { DropDownStyle = ComboBoxStyle.Simple };
-        comboBox.CreateControl();
-
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.True(comboBox.DroppedDown);
-
-        comboBox.AccessibilityObject.DoDefaultAction();
-
-        Assert.True(comboBox.DroppedDown);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, false, true)]
-    [InlineData(ComboBoxStyle.DropDown, true, false)]
-    [InlineData(ComboBoxStyle.DropDownList, false, true)]
-    [InlineData(ComboBoxStyle.DropDownList, true, false)]
-    public void ComboBoxAccessibleObject_DoDefaultAction_IfHandleIsCreated_DoesExpected(ComboBoxStyle style, bool droppedDown, bool expectedDroppedDown)
-    {
-        using ComboBox comboBox = new() { DropDownStyle = style };
-        comboBox.CreateControl();
-        comboBox.DroppedDown = droppedDown;
-
-        Assert.True(comboBox.IsHandleCreated);
-
-        comboBox.AccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(expectedDroppedDown, comboBox.DroppedDown);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_ReleaseUiaProvider_ClearsItemsAccessibleObjects()
-    {
-        using ComboBox comboBox = CreateComboBoxWithItems();
-        comboBox.CreateControl();
-        InitComboBoxItemsAccessibleObjects(comboBox);
-        var accessibleObject = (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-
-        Assert.Equal(comboBox.Items.Count, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBox.ReleaseUiaProvider(comboBox.HWND);
-
-        Assert.Equal(0, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItems_Clear_ClearsItemsAccessibleObjects()
-    {
-        using ComboBox comboBox = CreateComboBoxWithItems();
-        comboBox.CreateControl();
-        InitComboBoxItemsAccessibleObjects(comboBox);
-        var accessibleObject = (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-
-        Assert.Equal(comboBox.Items.Count, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBox.Items.Clear();
-
-        Assert.Equal(0, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItems_Remove_RemovesItemAccessibleObject()
-    {
-        using ComboBox comboBox = CreateComboBoxWithItems();
-        comboBox.CreateControl();
-        InitComboBoxItemsAccessibleObjects(comboBox);
-        var accessibleObject = (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBox.ObjectCollection.Entry item = comboBox.Items.InnerList[0];
-
-        Assert.True(accessibleObject.ItemAccessibleObjects.ContainsKey(item));
-        Assert.Equal(comboBox.Items.Count, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBox.Items.Remove(item);
-
-        Assert.False(accessibleObject.ItemAccessibleObjects.ContainsKey(item));
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItems_Remove_RemovesItemAccessibleObjectCorrectly_IfOneIsNotCreated()
-    {
-        using ComboBox comboBox = CreateComboBoxWithItems();
-        comboBox.CreateControl();
-        InitComboBoxItemsAccessibleObjects(comboBox);
-
-        // Add a new item, but don't create an accessible object for it.
-        comboBox.Items.Insert(0, "h");
-
-        var accessibleObject = (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBox.ObjectCollection.Entry item = comboBox.Items.InnerList[0];
-
-        Assert.False(accessibleObject.ItemAccessibleObjects.ContainsKey(item));
-        // One item's accessible object is not created.
-        Assert.Equal(comboBox.Items.Count - 1, accessibleObject.ItemAccessibleObjects.Count);
-
-        // It shouldn't throw an exception when trying to remove the item's accessible object,
-        // that is not created for the tested item, from the ItemAccessibleObjects collection.
-        comboBox.Items.Remove(item);
-
-        Assert.Equal(comboBox.Items.Count, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    private ComboBox CreateComboBoxWithItems()
-    {
-        ComboBox comboBox = new();
-        comboBox.Items.AddRange(new object[]
-        {
-            "a",
-            "b",
-            "c",
-            "d",
-            "e",
-            "f",
-            "g"
-        });
-
-        return comboBox;
-    }
-
-    private void InitComboBoxItemsAccessibleObjects(ComboBox comboBox)
-    {
-        var listAccessibleObject = (ComboBox.ComboBoxChildListUiaProvider)comboBox.ChildListAccessibleObject;
-        int childCount = listAccessibleObject.GetChildFragmentCount();
-
-        // Force items accessiblity objects creation
-        for (int i = 0; i < childCount; i++)
-        {
-            listAccessibleObject.GetChildFragment(i);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildDropDownButtonUiaProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildDropDownButtonUiaProviderTests.cs
deleted file mode 100644
index bea68581d2a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildDropDownButtonUiaProviderTests.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxChildDropDownButtonUiaProviderTests
-{
-    public static IEnumerable<object[]> DropDownButtonUiaProvider_FragmentNavigate_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            // ComboBox with "ComboBoxStyle.Simple" DropDownStyle has no DropDownButtonUiaProvider
-            if (comboBoxStyle == ComboBoxStyle.Simple)
-            {
-                continue;
-            }
-
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DropDownButtonUiaProvider_FragmentNavigate_TestData))]
-    public void DropDownButtonUiaProvider_FragmentNavigate_NextSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject nextItem = GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider
-            .FragmentNavigate(UiaCore.NavigateDirection.NextSibling) as AccessibleObject;
-
-        Assert.Null(nextItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DropDownButtonUiaProvider_FragmentNavigate_TestData))]
-    public void DropDownButtonUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject previousItem = GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider
-            .FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling) as AccessibleObject;
-
-        AccessibleObject expectedItem = comboBoxStyle == ComboBoxStyle.DropDownList
-            ? comboBox.ChildTextAccessibleObject
-            : comboBox.ChildEditAccessibleObject;
-
-        Assert.Equal(expectedItem, previousItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.Simple)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void DropDownButtonUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected_IfHandleIsNotCreated(
-        ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        AccessibleObject previousItem = GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider
-            .FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling) as AccessibleObject;
-
-        Assert.Null(previousItem);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void DropDownButtonUiaProvider_Name_ReturnsExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        Assert.Equal(SR.ComboboxDropDownButtonOpenName, GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider.Name);
-
-        // Open the dropdown list
-        comboBox.DroppedDown = true;
-
-        Assert.Equal(SR.ComboboxDropDownButtonCloseName, GetComboBoxAccessibleObject(comboBox).DropDownButtonUiaProvider.Name);
-    }
-
-    private ComboBox.ComboBoxAccessibleObject GetComboBoxAccessibleObject(ComboBox comboBox)
-    {
-        return comboBox.AccessibilityObject as ComboBox.ComboBoxAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildEditUiaProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildEditUiaProviderTests.cs
deleted file mode 100644
index cbad915e1fa..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildEditUiaProviderTests.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxChildEditUiaProviderTests
-{
-    public static IEnumerable<object[]> ComboBoxChildEditUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            // A Combobox with ComboBoxStyle.DropDownList style does not support a ComboBoxChildEditUiaProvider
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    bool childListDisplayed = droppedDown || comboBoxStyle == ComboBoxStyle.Simple;
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown, childListDisplayed };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxChildEditUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected_TestData))]
-    public void ComboBoxChildEditUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown,
-        bool childListDisplayed)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject previousItem = comboBox.ChildEditAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling) as AccessibleObject;
-
-        Assert.Equal(!childListDisplayed, previousItem is null);
-        Assert.Equal(childListDisplayed, previousItem == comboBox.ChildListAccessibleObject);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ComboBoxChildAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            // A Combobox with ComboBoxStyle.DropDownList style does not support a ComboBoxChildEditUiaProvider
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxChildAccessibleObject_FragmentNavigate_TestData))]
-    public void ComboBoxChildEditUiaProvider_FragmentNavigate_NextSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject nextItem = comboBox.ChildEditAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.NextSibling) as AccessibleObject;
-
-        AccessibleObject expectedItem = comboBoxStyle != ComboBoxStyle.Simple
-            ? ((ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject).DropDownButtonUiaProvider
-            : null;
-
-        Assert.Equal(expectedItem, nextItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxChildEditUiaProvider_SupportsTextPattern(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.CreateControl();
-        AccessibleObject accessibleObject = comboBox.ChildEditAccessibleObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsTextPatternAvailablePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxChildEditUiaProvider_SupportsTextPattern2(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.CreateControl();
-        AccessibleObject accessibleObject = comboBox.ChildEditAccessibleObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsTextPattern2AvailablePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxChildEditUiaProvider_SupportsValuePattern(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.CreateControl();
-        AccessibleObject accessibleObject = comboBox.ChildEditAccessibleObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsValuePatternAvailablePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ComboBoxChildEditUiaProvider_GetPropertyValue_ReturnsExpected()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.CreateControl();
-        AccessibleObject accessibleObject = comboBox.ChildEditAccessibleObject;
-
-        Assert.Equal(SR.ComboBoxEditDefaultAccessibleName, accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId).ToString());
-        Assert.Equal(SR.ComboBoxEditDefaultAccessibleName, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId).ToString());
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-
-        comboBox.AccessibleName = "Combo AO name";
-
-        Assert.Equal(comboBox.AccessibleName, accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId).ToString());
-        Assert.Equal(comboBox.AccessibleName, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId).ToString());
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildListUiaProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildListUiaProviderTests.cs
deleted file mode 100644
index b76af273946..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildListUiaProviderTests.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxChildListUiaProviderTests
-{
-    public static IEnumerable<object[]> ChildListAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool droppedDown in new[] { true, false })
-                {
-                    yield return new object[] { comboBoxStyle, createControl, droppedDown };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ChildListAccessibleObject_FragmentNavigate_TestData))]
-    public void ChildListAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject previousItem = comboBox.ChildListAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling) as AccessibleObject;
-
-        AccessibleObject expectedItem = comboBoxStyle == ComboBoxStyle.Simple
-            ? comboBox.ChildListAccessibleObject
-            : null;
-
-        Assert.Equal(expectedItem, previousItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ChildListAccessibleObject_FragmentNavigate_TestData))]
-    public void ChildListAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected(
-        ComboBoxStyle comboBoxStyle,
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject nextItem = comboBox.ChildListAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.NextSibling) as AccessibleObject;
-
-        AccessibleObject expectedItem = comboBoxStyle == ComboBoxStyle.DropDownList
-            ? comboBox.ChildTextAccessibleObject
-            : comboBox.ChildEditAccessibleObject;
-
-        Assert.Equal(expectedItem, nextItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ChildListAccessibleObject_BoundingRectangle_ReturnsCorrectWidth_IfComboBoxIsScrollable_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            yield return new object[] { comboBoxStyle };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ChildListAccessibleObject_BoundingRectangle_ReturnsCorrectWidth_IfComboBoxIsScrollable_TestData))]
-    public void ChildListAccessibleObject_BoundingRectangle_ReturnsCorrectWidth_IfComboBoxIsScrollable(ComboBoxStyle comboBoxStyle)
-    {
-        const int expectedWidth = 100;
-
-        using ComboBox comboBox = new()
-        {
-            DropDownStyle = comboBoxStyle,
-            IntegralHeight = false
-        };
-        comboBox.Items.AddRange(Enumerable.Range(0, 11).Cast<object>().ToArray());
-        comboBox.CreateControl();
-
-        if (comboBoxStyle == ComboBoxStyle.Simple)
-        {
-            comboBox.Size = new Size(expectedWidth, 150);
-        }
-        else
-        {
-            comboBox.Size = new Size(expectedWidth, comboBox.Size.Height);
-            comboBox.DropDownHeight = 120;
-            comboBox.DroppedDown = true;
-        }
-
-        UiaCore.IRawElementProviderFragment childListUiaProvider = comboBox.ChildListAccessibleObject;
-        UiaCore.UiaRect actual = childListUiaProvider.BoundingRectangle;
-
-        Assert.Equal(expectedWidth, actual.width);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildNativeWindowTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildNativeWindowTests.cs
deleted file mode 100644
index f9282ec091e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildNativeWindowTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxChildNativeWindowTests
-{
-    [WinFormsFact]
-    public void ComboBoxChildNativeWindow_GetChildAccessibleObject()
-    {
-        using ComboBox comboBox = new() { DropDownStyle = ComboBoxStyle.DropDown };
-        comboBox.CreateControl();
-
-        var childNativeWindow = comboBox.GetListNativeWindow();
-        Type childWindowTypeEnum = typeof(ComboBox).GetNestedType("ChildWindowType", Reflection.BindingFlags.NonPublic);
-
-        foreach (var childWindowType in Enum.GetValues(childWindowTypeEnum))
-        {
-            Assert.True(childNativeWindow.TestAccessor().Dynamic.GetChildAccessibleObject() is ComboBox.ChildAccessibleObject);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildTextUiaProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildTextUiaProviderTests.cs
deleted file mode 100644
index f47a2afe852..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxChildTextUiaProviderTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBoxChildTextUiaProviderTests
-{
-    public static IEnumerable<object[]> ComboBoxChildTextUiaProvider_FragmentNavigate__TestData()
-    {
-        foreach (bool createControl in new[] { true, false })
-        {
-            foreach (bool droppedDown in new[] { true, false })
-            {
-                yield return new object[] { createControl, droppedDown };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxChildTextUiaProvider_FragmentNavigate__TestData))]
-    public void ComboBoxChildTextUiaProvider_FragmentNavigate_PreviousSibling_ReturnsExpected(
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = ComboBoxStyle.DropDownList
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject previousItem = comboBox.ChildTextAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling) as AccessibleObject;
-
-        Assert.Equal(!droppedDown, previousItem is null);
-        Assert.Equal(droppedDown, previousItem == comboBox.ChildListAccessibleObject);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxChildTextUiaProvider_FragmentNavigate__TestData))]
-    public void ComboBoxChildTextUiaProvider_FragmentNavigate_NextSibling_ReturnsExpected(
-        bool createControl,
-        bool droppedDown)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = ComboBoxStyle.DropDownList
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.DroppedDown = droppedDown;
-        AccessibleObject nextItem = comboBox.ChildTextAccessibleObject
-            .FragmentNavigate(UiaCore.NavigateDirection.NextSibling) as AccessibleObject;
-
-        AccessibleObject expectedItem = ((ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject).DropDownButtonUiaProvider;
-
-        Assert.Equal(expectedItem, nextItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxItemAccessibleObjectTests.cs
deleted file mode 100644
index aa6f690e77a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,690 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.IntegrationTests.Common;
-using static System.Windows.Forms.ComboBox;
-using static System.Windows.Forms.ComboBox.ObjectCollection;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxItemAccessibleObjectTests
-{
-    private const AccessibleStates InvisibleItemState = AccessibleStates.Invisible | AccessibleStates.Offscreen | AccessibleStates.Focusable | AccessibleStates.Selectable;
-    private const AccessibleStates VisibleItemState = AccessibleStates.Selected | AccessibleStates.Focusable | AccessibleStates.Selectable;
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_Get_Not_ThrowsException()
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox control = new ComboBox();
-
-            HashNotImplementedObject item1 = new();
-            HashNotImplementedObject item2 = new();
-            HashNotImplementedObject item3 = new();
-
-            control.Items.AddRange(new[] { item1, item2, item3 });
-
-            ComboBox.ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBox.ComboBoxAccessibleObject)control.AccessibilityObject;
-
-            bool exceptionThrown = false;
-
-            try
-            {
-                ComboBox.ComboBoxItemAccessibleObject item1AccessibleObject = comboBoxAccessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(control.Items.InnerList[0]);
-                ComboBox.ComboBoxItemAccessibleObject item2AccessibleObject = comboBoxAccessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(control.Items.InnerList[1]);
-                ComboBox.ComboBoxItemAccessibleObject item3AccessibleObject = comboBoxAccessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(control.Items.InnerList[2]);
-            }
-            catch
-            {
-                exceptionThrown = true;
-            }
-
-            Assert.False(exceptionThrown, "Getting accessible object for ComboBox item has thrown an exception.");
-        }
-    }
-
-    public class HashNotImplementedObject
-    {
-        public override int GetHashCode()
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_DataBoundAccessibleName()
-    {
-        using (new NoAssertContext())
-        {
-            // Regression test for https://github.com/dotnet/winforms/issues/3549
-            using ComboBox control = new ComboBox()
-            {
-                DataSource = TestDataSources.GetPersons(),
-                DisplayMember = TestDataSources.PersonDisplayMember
-            };
-
-            ComboBox.ComboBoxAccessibleObject accessibleObject = Assert.IsType<ComboBox.ComboBoxAccessibleObject>(control.AccessibilityObject);
-
-            foreach (Person person in TestDataSources.GetPersons())
-            {
-                ComboBox.ComboBoxItemAccessibleObject item = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(new Entry(person));
-                AccessibleObject itemAccessibleObject = Assert.IsType<ComboBox.ComboBoxItemAccessibleObject>(item);
-                Assert.Equal(person.Name, itemAccessibleObject.Name);
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxItemAccessibleObject_SeveralSameItems_FragmentNavigate_NextSibling_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.Items.AddRange(new[] { "aaa", "aaa", "aaa" });
-        comboBox.CreateControl();
-
-        ComboBoxItemAccessibleObjectCollection itemAccessibleObjects = ((ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject).ItemAccessibleObjects;
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-            .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        Assert.Equal("aaa", comboBoxItem1.Name);
-        Assert.Equal(comboBoxItem1, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[0]));
-
-        // FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling) should return accessible object for second "aaa" item
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-            .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        Assert.NotEqual(comboBoxItem1, comboBoxItem2);
-        Assert.Equal("aaa", comboBoxItem2.Name);
-        Assert.Equal(comboBoxItem2, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[1]));
-
-        // FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling) should return accessible object for third "aaa" item
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-            .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        Assert.NotEqual(comboBoxItem3, comboBoxItem2);
-        Assert.NotEqual(comboBoxItem3, comboBoxItem1);
-        Assert.Equal("aaa", comboBoxItem3.Name);
-        Assert.Equal(comboBoxItem3, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[2]));
-
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxItemAccessibleObject_SeveralSameItems_FragmentNavigate_PreviousSibling_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.Items.AddRange(new[] { "aaa", "aaa", "aaa" });
-        comboBox.CreateControl();
-
-        ComboBoxItemAccessibleObjectCollection itemAccessibleObjects = ((ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject).ItemAccessibleObjects;
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-            .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild);
-
-        Assert.Equal("aaa", comboBoxItem3.Name);
-        Assert.Equal(comboBoxItem3, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[2]));
-
-        // FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling) should return accessible object for second "aaa" item
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem3
-            .FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.NotEqual(comboBoxItem2, comboBoxItem3);
-        Assert.Equal("aaa", comboBoxItem2.Name);
-        Assert.Equal(comboBoxItem2, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[1]));
-
-        // FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling) should return accessible object for first "aaa" item
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-            .FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling);
-        Assert.NotEqual(comboBoxItem1, comboBoxItem2);
-        Assert.NotEqual(comboBoxItem1, comboBoxItem3);
-        Assert.Equal("aaa", comboBoxItem1.Name);
-        Assert.Equal(comboBoxItem1, itemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBox.Items.InnerList[0]));
-
-        // FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling) should return null for first "aaa" item
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItemPrevious = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-            .FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling);
-        Assert.Null(comboBoxItemPrevious);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxItemAccessibleObject_FragmentNavigate_Parent_ReturnListAccessibleObject(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBox(comboBoxStyle);
-        AccessibleObject childListAccessibleObject = comboBox.ChildListAccessibleObject;
-        AccessibleObject comboBoxItem = (AccessibleObject)childListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-
-        Assert.Equal(childListAccessibleObject, comboBoxItem.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxItemAccessibleObject_FragmentNavigate_Child_ReturnNull(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBox(comboBoxStyle);
-        AccessibleObject childListAccessibleObject = comboBox.ChildListAccessibleObject;
-        AccessibleObject comboBoxItem = (AccessibleObject)childListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-
-        Assert.Null(comboBoxItem.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(comboBoxItem.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_IsPatternSupported_ReturnsTrue_ForScrollItemPattern()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.Items.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
-        comboBox.CreateControl();
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-
-        // Check that all items support ScrollItemPattern
-        foreach (Entry itemEntry in comboBox.Items.InnerList)
-        {
-            ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-
-            Assert.True(itemAccessibleObject.IsPatternSupported(UiaCore.UIA.ScrollItemPatternId));
-        }
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_GetPropertyValue_Pattern_IsAvailable()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.Items.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
-        comboBox.CreateControl();
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-
-        // Check that all items support Pattern
-        foreach (Entry itemEntry in comboBox.Items.InnerList)
-        {
-            ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-
-            Assert.True((bool)itemAccessibleObject.GetPropertyValue(UiaCore.UIA.IsScrollItemPatternAvailablePropertyId));
-            Assert.True((bool)itemAccessibleObject.GetPropertyValue(UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId));
-            Assert.Null(itemAccessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxItemAccessibleObject_ScrollIntoView_DoNothing_IfControlIsNotEnabled_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            yield return new object[] { comboBoxStyle };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxItemAccessibleObject_ScrollIntoView_DoNothing_IfControlIsNotEnabled_TestData))]
-    public void ComboBoxItemAccessibleObject_ScrollIntoView_DoNothing_IfControlIsNotEnabled(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.IntegralHeight = false;
-        comboBox.DropDownStyle = comboBoxStyle;
-        comboBox.Enabled = false;
-        comboBox.Items.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
-        comboBox.CreateControl();
-
-        if (comboBoxStyle == ComboBoxStyle.Simple)
-        {
-            comboBox.Size = new Size(100, 132);
-        }
-        else
-        {
-            comboBox.DropDownHeight = 107;
-            comboBox.DroppedDown = true;
-        }
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-        Entry itemEntry = comboBox.Items.InnerList[10];
-        ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-
-        itemAccessibleObject.ScrollIntoView();
-
-        int actual = (int)PInvoke.SendMessage(comboBox, PInvoke.CB_GETTOPINDEX);
-
-        Assert.Equal(0, actual); // ScrollIntoView didn't scroll to the tested item because the combobox is disabled
-    }
-
-    public static IEnumerable<object[]> ComboBoxItemAccessibleObject_ScrollIntoView_EnsureVisible_TestData()
-    {
-        foreach (bool scrollingDown in new[] { true, false })
-        {
-            foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-            {
-                int itemsCount = 41;
-
-                for (int index = 0; index < itemsCount; index++)
-                {
-                    yield return new object[] { comboBoxStyle, scrollingDown, index, itemsCount };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxItemAccessibleObject_ScrollIntoView_EnsureVisible_TestData))]
-    public void ComboBoxItemAccessibleObject_ScrollIntoView_EnsureVisible(ComboBoxStyle comboBoxStyle, bool scrollingDown, int itemIndex, int itemsCount)
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.IntegralHeight = false;
-        comboBox.DropDownStyle = comboBoxStyle;
-        comboBox.CreateControl();
-
-        for (int i = 0; i < itemsCount; i++)
-        {
-            comboBox.Items.Add(i);
-        }
-
-        if (comboBoxStyle == ComboBoxStyle.Simple)
-        {
-            comboBox.Size = new Size(100, 132);
-        }
-        else
-        {
-            comboBox.DropDownHeight = 107;
-            comboBox.DroppedDown = true;
-        }
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-        Entry itemEntry = comboBox.Items.InnerList[itemIndex];
-        ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-
-        int expected;
-        Rectangle dropDownRect = comboBox.ChildListAccessibleObject.Bounds;
-        int visibleItemsCount = (int)Math.Ceiling((double)dropDownRect.Height / comboBox.ItemHeight);
-
-        // Get an index of the first item that is visible if dropdown is scrolled to the bottom
-        int lastFirstVisible = itemsCount - visibleItemsCount;
-
-        if (scrollingDown)
-        {
-            if (dropDownRect.IntersectsWith(itemAccessibleObject.Bounds))
-            {
-                // ScrollIntoView method shouldn't scroll to the item because it is already visible
-                expected = 0;
-            }
-            else
-            {
-                //  ScrollIntoView method should scroll to the item or
-                //  the first item that is visible if dropdown is scrolled to the bottom
-                expected = itemIndex > lastFirstVisible ? lastFirstVisible : itemIndex;
-            }
-        }
-        else
-        {
-            // Scroll to the bottom and test the method when scrolling up
-            PInvoke.SendMessage(comboBox, PInvoke.CB_SETTOPINDEX, (WPARAM)(itemsCount - 1));
-
-            if (dropDownRect.IntersectsWith(itemAccessibleObject.Bounds))
-            {
-                // ScrollIntoView method shouldn't scroll to the item because it is already visible
-                expected = lastFirstVisible;
-            }
-            else
-            {
-                // ScrollIntoView method should scroll to the item
-                expected = itemIndex;
-            }
-        }
-
-        itemAccessibleObject.ScrollIntoView();
-
-        int actual = (int)PInvoke.SendMessage(comboBox, PInvoke.CB_GETTOPINDEX);
-
-        Assert.Equal(expected, actual);
-    }
-
-    public static IEnumerable<object[]> ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_IfComboBoxIsScrollable_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            // The tested combobox contains 11 items
-            for (int index = 0; index < 11; index++)
-            {
-                int y = index * 15;
-                int initialYPosition = comboBoxStyle == ComboBoxStyle.Simple ? 56 : 55;
-                int x = comboBoxStyle == ComboBoxStyle.Simple ? 10 : 9;
-                Point point = new Point(x, y + initialYPosition);
-
-                yield return new object[] { comboBoxStyle, index, point };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_IfComboBoxIsScrollable_TestData))]
-    public void ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_IfComboBoxIsScrollable(ComboBoxStyle comboBoxStyle, int itemIndex, Point expectedPosition)
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.IntegralHeight = false;
-        comboBox.DropDownStyle = comboBoxStyle;
-        comboBox.Items.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
-        comboBox.CreateControl();
-
-        if (comboBoxStyle == ComboBoxStyle.Simple)
-        {
-            comboBox.Size = new Size(100, 132);
-        }
-        else
-        {
-            comboBox.Size = new Size(100, comboBox.Size.Height);
-            comboBox.DropDownHeight = 105;
-            comboBox.DroppedDown = true;
-        }
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-        Entry itemEntry = comboBox.Items.InnerList[itemIndex];
-        ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-        Rectangle actual = itemAccessibleObject.Bounds;
-        Rectangle dropdownRect = comboBox.ChildListAccessibleObject.Bounds;
-
-        // We get items rectangles from Windows
-        // It returns to us different expected widths values depending on a combobox drop-down style
-        int itemWidth = comboBoxStyle == ComboBoxStyle.Simple ? 79 : 81;
-
-        Assert.Equal(expectedPosition.X, actual.X);
-        Assert.Equal(expectedPosition.Y, actual.Y);
-        Assert.Equal(itemWidth, actual.Width); // All items are the same width
-        Assert.Equal(15, actual.Height); // All items are the same height
-    }
-
-    public static IEnumerable<object[]> ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_ForDifferentHeightItems_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            // The tested combobox contains 11 items
-            for (int index = 0; index < 11; index++)
-            {
-                int height = DifferentHeightComboBox.GetCustomItemHeight(index);
-
-                // We get items rectangles from Windows
-                // It returns to us different expected bounds values depending on a combobox drop-down style
-                int width = comboBoxStyle == ComboBoxStyle.Simple ? 96 : 81;
-                int x = comboBoxStyle == ComboBoxStyle.Simple ? 10 : 9;
-                int y = comboBoxStyle == ComboBoxStyle.Simple ? 57 : 56;
-
-                for (int i = 0; i < index; i++)
-                {
-                    y += DifferentHeightComboBox.GetCustomItemHeight(i); // Calculate the sum of heights of all items before the current
-                }
-
-                yield return new object[] { comboBoxStyle, index, new Rectangle(x, y, width, height) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_ForDifferentHeightItems_TestData))]
-    public void ComboBoxItemAccessibleObject_Bounds_ReturnsCorrect_ForDifferentHeightItems(ComboBoxStyle comboBoxStyle, int itemIndex, Rectangle expectedRect)
-    {
-        using DifferentHeightComboBox comboBox = new DifferentHeightComboBox();
-        comboBox.DropDownStyle = comboBoxStyle;
-        comboBox.Items.AddRange(new[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" });
-        comboBox.CreateControl();
-
-        if (comboBoxStyle == ComboBoxStyle.Simple)
-        {
-            comboBox.Size = new Size(100, 400);
-        }
-        else
-        {
-            comboBox.Size = new Size(100, comboBox.Size.Height);
-            comboBox.DropDownHeight = 400;
-            comboBox.DroppedDown = true;
-        }
-
-        ComboBoxAccessibleObject comboBoxAccessibleObject = (ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-        ComboBoxItemAccessibleObjectCollection itemsCollection = comboBoxAccessibleObject.ItemAccessibleObjects;
-        Entry itemEntry = comboBox.Items.InnerList[itemIndex];
-        ComboBoxItemAccessibleObject itemAccessibleObject = itemsCollection.GetComboBoxItemAccessibleObject(itemEntry);
-        Rectangle actual = itemAccessibleObject.Bounds;
-        Rectangle dropdownRect = comboBox.ChildListAccessibleObject.Bounds;
-
-        Assert.Equal(expectedRect, actual);
-    }
-
-    private class DifferentHeightComboBox : ComboBox
-    {
-        public DifferentHeightComboBox() : base()
-        {
-            DrawMode = DrawMode.OwnerDrawVariable;
-        }
-
-        public static int GetCustomItemHeight(int index) => 15 + (index % 5) * 5;
-
-        protected override void OnMeasureItem(MeasureItemEventArgs e)
-        {
-            e.ItemHeight = GetCustomItemHeight(e.Index);
-            base.OnMeasureItem(e);
-        }
-
-        protected override void OnDrawItem(DrawItemEventArgs e)
-        {
-            if (e.Index < 0 || e.Index >= Items.Count)
-            {
-                return;
-            }
-
-            e.DrawBackground();
-            using var brush = new SolidBrush(e.ForeColor);
-            e.Graphics.DrawString(
-                Items[e.Index].ToString(),
-                e.Font,
-                brush,
-                e.Bounds);
-            e.DrawFocusRectangle();
-            base.OnDrawItem(e);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_MaxDropDownItems_State_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxItems(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        Assert.Equal(InvisibleItemState, comboBoxItem1.State); // comboBoxItem1 above the visible area
-        Assert.Equal(VisibleItemState, comboBoxItem2.State); // comboBoxItem2 in the visible area
-        Assert.Equal(InvisibleItemState, comboBoxItem3.State); // comboBoxItem3 below the visible area
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_DropDownHeight_State_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxHeight(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        Assert.Equal(InvisibleItemState, comboBoxItem1.State); // comboBoxItem1 above the visible area
-        Assert.Equal(VisibleItemState, comboBoxItem2.State); // comboBoxItem2 in the visible area
-        Assert.Equal(InvisibleItemState, comboBoxItem3.State); // comboBoxItem3 below the visible area
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_DropDownCollapsed_State_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBox(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        Assert.Equal(InvisibleItemState, comboBoxItem1.State);
-        Assert.Equal(InvisibleItemState, comboBoxItem2.State);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_State_ReturnExpected()
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxSize(ComboBoxStyle.Simple);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        AccessibleStates itemState = AccessibleStates.Invisible | AccessibleStates.Selected | AccessibleStates.Focusable | AccessibleStates.Selectable;
-
-        Assert.Equal(InvisibleItemState, comboBoxItem1.State); // comboBoxItem1 above the visible area
-        Assert.Equal(itemState, comboBoxItem2.State); // comboBoxItem2 in the visible area
-        Assert.Equal(InvisibleItemState, comboBoxItem3.State); // comboBoxItem3 below the visible area
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_MaxDropDownItems_GetOffScreenProperty_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxItems(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        AssertExtensions.True(comboBoxItem1, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem1 above the visible area
-        AssertExtensions.False(comboBoxItem2, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem2 in the visible area
-        AssertExtensions.True(comboBoxItem3, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem3 below the visible area
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_DropDownHeight_GetOffScreenProperty_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxHeight(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        AssertExtensions.True(comboBoxItem1, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem1 above the visible area
-        AssertExtensions.False(comboBoxItem2, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem2 in the visible area
-        AssertExtensions.True(comboBoxItem3, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem3 below the visible area
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.DropDown)]
-    public void ComboBoxItemAccessibleObject_DropDownCollapsed_GetOffScreenProperty_ReturnExpected(ComboBoxStyle comboBoxStyle)
-    {
-        using ComboBox comboBox = GetComboBox(comboBoxStyle);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        AssertExtensions.True(comboBoxItem1, UiaCore.UIA.IsOffscreenPropertyId);
-        AssertExtensions.True(comboBoxItem2, UiaCore.UIA.IsOffscreenPropertyId);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxItemAccessibleObject_GetOffScreenProperty_ReturnExpected()
-    {
-        using ComboBox comboBox = GetComboBoxWithMaxSize(ComboBoxStyle.Simple);
-
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem1 = (ComboBox.ComboBoxItemAccessibleObject)comboBox
-                .ChildListAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem2 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem1
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-        ComboBox.ComboBoxItemAccessibleObject comboBoxItem3 = (ComboBox.ComboBoxItemAccessibleObject)comboBoxItem2
-                .FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling);
-
-        AssertExtensions.True(comboBoxItem1, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem1 above the visible area
-        AssertExtensions.False(comboBoxItem2, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem2 in the visible area
-        AssertExtensions.True(comboBoxItem3, UiaCore.UIA.IsOffscreenPropertyId); // comboBoxItem3 below the visible area
-    }
-
-    private ComboBox GetComboBox(ComboBoxStyle comboBoxStyle)
-    {
-        ComboBox comboBox = new ComboBox
-        {
-            DropDownStyle = comboBoxStyle
-        };
-
-        comboBox.Items.Add(1);
-        comboBox.Items.Add(2);
-        comboBox.Items.Add(3);
-        comboBox.CreateControl();
-        return comboBox;
-    }
-
-    private ComboBox GetComboBoxWithMaxItems(ComboBoxStyle comboBoxStyle)
-    {
-        ComboBox comboBox = GetComboBox(comboBoxStyle);
-        comboBox.IntegralHeight = false;
-        comboBox.MaxDropDownItems = 1;
-        comboBox.SelectedIndex = 1;
-        comboBox.DroppedDown = true;
-        return comboBox;
-    }
-
-    private ComboBox GetComboBoxWithMaxHeight(ComboBoxStyle comboBoxStyle)
-    {
-        ComboBox comboBox = GetComboBox(comboBoxStyle);
-        comboBox.DropDownHeight = 10;
-        comboBox.SelectedIndex = 1;
-        comboBox.DroppedDown = true;
-        return comboBox;
-    }
-
-    private ComboBox GetComboBoxWithMaxSize(ComboBoxStyle comboBoxStyle)
-    {
-        ComboBox comboBox = GetComboBox(comboBoxStyle);
-        comboBox.Size = new Size(100, 50);
-        comboBox.SelectedIndex = 1;
-        return comboBox;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxUiaTextProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxUiaTextProviderTests.cs
deleted file mode 100644
index 5438af4e76c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBox.ComboBoxUiaTextProviderTests.cs
+++ /dev/null
@@ -1,1156 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxUiaTextProviderTests
-{
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_Ctor_DoesntCreateControlHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsFact]
-    public void ComboBoxUiaTextProvider_Ctor_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ComboBox.ComboBoxUiaTextProvider(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_IsMultiline_IsFalse(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(provider.IsMultiline);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_IsReadOnly_IsFalse(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(provider.IsReadOnly);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_IsScrollable_IsTrue(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.True(provider.IsScrollable);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_IsScrollable_False_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(provider.IsScrollable);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetWindowStyle_ReturnsNoneForNotInitializedControl(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.Equal(WINDOW_STYLE.WS_OVERLAPPED, provider.WindowStyle);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, RightToLeft.Yes, true)]
-    [InlineData(ComboBoxStyle.DropDown, RightToLeft.No, false)]
-    [InlineData(ComboBoxStyle.Simple, RightToLeft.Yes, true)]
-    [InlineData(ComboBoxStyle.Simple, RightToLeft.No, false)]
-    public void ComboBoxUiaTextProvider_IsReadingRTL_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, RightToLeft rightToLeft, bool expectedResult)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, RightToLeft = rightToLeft };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.Equal(expectedResult, provider.IsReadingRTL);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, RightToLeft.Yes)]
-    [InlineData(ComboBoxStyle.DropDown, RightToLeft.No)]
-    [InlineData(ComboBoxStyle.Simple, RightToLeft.Yes)]
-    [InlineData(ComboBoxStyle.Simple, RightToLeft.No)]
-    public void ComboBoxUiaTextProvider_IsReadingRTL_ReturnsFalse_WithoutHandle(ComboBoxStyle dropDownStyle, RightToLeft rightToLeft)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, RightToLeft = rightToLeft };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(provider.IsReadingRTL);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_DocumentRange_IsNotNull_WorksCorrectly(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.CreateControl();
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            Assert.Equal(comboBox.ChildEditAccessibleObject, provider.DocumentRange.GetEnclosingElement());
-            Assert.Equal(provider, provider.DocumentRange.TestAccessor().Dynamic._provider);
-            Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_DocumentRange_IsNull_ThowException(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            Assert.Throws<NullReferenceException>(() => provider.DocumentRange);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_SupportedTextSelection_IsNotNull(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            UiaCore.SupportedTextSelection uiaTextRange = provider.SupportedTextSelection;
-
-            Assert.Equal(UiaCore.SupportedTextSelection.Single, uiaTextRange);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetCaretRange_IsNotNull(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        UiaCore.ITextRangeProvider uiaTextRange = provider.GetCaretRange(out _);
-
-        Assert.NotNull(uiaTextRange);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetCaretRange_IsNull_IfHandleIsNotCreated(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            UiaCore.ITextRangeProvider uiaTextRange = provider.GetCaretRange(out _);
-
-            Assert.Null(uiaTextRange);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_LinesPerPage_ReturnsMinusOne_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.Equal(-1, provider.LinesPerPage);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_LinesPerPage_ReturnsOne_WithHandle(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.Equal(1, provider.LinesPerPage);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 0)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 50)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 100)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, -5)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 0)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 50)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 100)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, -5)]
-    public void ComboBoxUiaTextProvider_GetLineFromCharIndex_ReturnsZero(
-        ComboBoxStyle dropDownStyle,
-        int width,
-        int height,
-        int charIndex)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(width, height) };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing GetLineFromCharIndex method");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        int actualLine = provider.GetLineFromCharIndex(charIndex);
-
-        Assert.Equal(0, actualLine);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 5)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 5)]
-    public void ComboBoxUiaTextProvider_GetLineFromCharIndex_ReturnsMinusOne_WithoutHandle(
-        ComboBoxStyle dropDownStyle,
-        int width,
-        int height,
-        int charIndex)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(width, height) };
-            comboBox.Items.Add("Some test text for testing GetLineFromCharIndex method");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            int actualLine = provider.GetLineFromCharIndex(charIndex);
-
-            Assert.Equal(-1, actualLine);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetLineIndex_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, 50, 20, 0 };
-            yield return new object[] { comboBoxStyle, 50, 20, 3 };
-            yield return new object[] { comboBoxStyle, 50, 50, 3 };
-            yield return new object[] { comboBoxStyle, 100, 50, 3 };
-            yield return new object[] { comboBoxStyle, 50, 50, 100 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetLineIndex_TestData))]
-    public void ComboBoxUiaTextProvider_GetLineIndex_ReturnsCorrectValue(
-        ComboBoxStyle dropDownStyle,
-        int width,
-        int height,
-        int lineIndex)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(width, height) };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing GetLineIndex method");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        int actualIndex = provider.GetLineIndex(lineIndex);
-
-        Assert.Equal(0, actualIndex);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetLineIndex_TestData))]
-    public void ComboBoxUiaTextProvider_GetLineIndex_ReturnsMinusOne_WithoutHandle(
-        ComboBoxStyle dropDownStyle,
-        int width,
-        int height,
-        int lineIndex)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(width, height) };
-            comboBox.Items.Add("Some test text for testing GetLineIndex method");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            int actualIndex = provider.GetLineIndex(lineIndex);
-
-            Assert.Equal(-1, actualIndex);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetLogfont_ReturnsCorrectValue(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.CreateControl();
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            LOGFONTW expected = LOGFONTW.FromFont(comboBox.Font);
-            LOGFONTW actual = provider.Logfont;
-            Assert.False(string.IsNullOrEmpty(actual.FaceName.ToString()));
-            Assert.Equal(expected, actual);
-            Assert.True(comboBox.IsHandleCreated);
-            Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetLogfont_ReturnsEmpty_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            LOGFONTW expected = default;
-
-            LOGFONTW actual = provider.Logfont;
-
-            Assert.True(string.IsNullOrEmpty(actual.FaceName.ToString()));
-            Assert.Equal(expected, actual);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetPositionFromChar_TestData()
-    {
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(50, 20), "Some test text for testing", 0, new Point(1, 0) };
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(50, 20), "Some test text for testing", 15, new Point(79, 0) };
-
-        yield return new object[] { ComboBoxStyle.Simple, new Size(50, 20), "Some test text for testing", 0, new Point(1, 0) };
-        yield return new object[] { ComboBoxStyle.Simple, new Size(50, 20), "Some test text for testing", 15, new Point(79, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetPositionFromChar_TestData))]
-    public void ComboBoxUiaTextProvider_GetPositionFromChar_ReturnsCorrectValue(ComboBoxStyle dropdownStyle, Size size, string text, int charIndex, Point expectedPoint)
-    {
-        using ComboBox comboBox = new ComboBox() { Size = size, DropDownStyle = dropdownStyle };
-        comboBox.CreateControl();
-        comboBox.Items.Add(text);
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Point actualPoint = provider.GetPositionFromChar(charIndex);
-
-        Assert.True(actualPoint.X >= expectedPoint.X - 1 || actualPoint.X <= expectedPoint.X + 1);
-        Assert.True(actualPoint.Y >= expectedPoint.Y - 1 || actualPoint.Y <= expectedPoint.Y + 1);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetPositionFromChar_WithoutHandle_TestData()
-    {
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(50, 20), "Some test text for testing", 0 };
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(50, 20), "Some test text for testing", 15 };
-
-        yield return new object[] { ComboBoxStyle.Simple, new Size(50, 20), "Some test text for testing", 0 };
-        yield return new object[] { ComboBoxStyle.Simple, new Size(50, 20), "Some test text for testing", 15 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetPositionFromChar_WithoutHandle_TestData))]
-    public void ComboBoxUiaTextProvider_GetPositionFromChar_ReturnsEmpty_WithoutHandle(ComboBoxStyle dropDownStyle, Size size, string text, int charIndex)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-            comboBox.Items.Add(text);
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Point actualPoint = provider.GetPositionFromChar(charIndex);
-
-            Assert.Equal(Point.Empty, actualPoint);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "", 0, new Point(0, 0) };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", 100, new Point(0, 0) };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", -1, new Point(0, 0) };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", 12, new Point(71, 0) };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \n text", 10, new Point(56, 0) };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \r\n text", 10, new Point(56, 0) };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \r\n text", 12, new Point(60, 0) };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \t text", 10, new Point(57, 0) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_TestData))]
-    public void ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, Size size, string text, int charIndex, Point expectedPoint)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-        comboBox.CreateControl();
-        comboBox.Items.Add(text);
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Point actualPoint = provider.GetPositionFromCharForUpperRightCorner(charIndex, comboBox.Text);
-
-        Assert.True(actualPoint.X >= expectedPoint.X - 1 || actualPoint.X <= expectedPoint.X + 1);
-        Assert.True(actualPoint.Y >= expectedPoint.Y - 1 || actualPoint.Y <= expectedPoint.Y + 1);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_WithoutHandle_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "", 0 };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", 100 };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", -1 };
-            yield return new object[] { comboBoxStyle, new Size(50, 20), "Some test text", 12 };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \n text", 10 };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \r\n text", 10 };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \r\n text", 12 };
-            yield return new object[] { comboBoxStyle, new Size(100, 60), "Some test \t text", 10 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_WithoutHandle_TestData))]
-    public void ComboBoxUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsMinusOne_WithoutHandle(ComboBoxStyle dropDownStyle, Size size, string text, int charIndex)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-            comboBox.Items.Add(text);
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Point actualPoint = provider.GetPositionFromCharForUpperRightCorner(charIndex, comboBox.Text);
-
-            Assert.Equal(Point.Empty, actualPoint);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetFormattingRectangle_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, new Size(0, 0), new Rectangle(0, 0, 80, 16) };
-            int width = comboBoxStyle == ComboBoxStyle.DropDown ? 27 : 44;
-            yield return new object[] { comboBoxStyle, new Size(50, 50), new Rectangle(0, 0, width, 15) };
-            width = comboBoxStyle == ComboBoxStyle.DropDown ? 227 : 244;
-            yield return new object[] { comboBoxStyle, new Size(250, 100), new Rectangle(0, 0, width, 15) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetFormattingRectangle_TestData))]
-    public void ComboBoxUiaTextProvider_GetFormattingRectangle_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, Size size, Rectangle expectedRectangle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Rectangle providerRectangle = provider.BoundingRectangle;
-
-        Assert.Equal(expectedRectangle, providerRectangle);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetFormattingRectangle_ReturnsEmpty_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(250, 100) };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Rectangle providerRectangle = provider.BoundingRectangle;
-
-            Assert.Equal(Drawing.Rectangle.Empty, providerRectangle);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_Text_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, "" };
-            yield return new object[] { comboBoxStyle, "Text" };
-            yield return new object[] { comboBoxStyle, "Some test text" };
-            yield return new object[] { comboBoxStyle, "Some very very very long test text for testing GetTextLength method" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_Text_TestData))]
-    public void ComboBoxUiaTextProvider_Text_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, string text)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        comboBox.Items.Add(text);
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-        string expected = comboBox.Text;
-
-        string actual = provider.Text.Trim('\0');
-
-        Assert.Equal(expected, actual);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_Text_TestData))]
-    public void ComboBoxUiaTextProvider_Text_ReturnsEmpty_WithoutHandle(ComboBoxStyle dropDownStyle, string text)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.Items.Add(text);
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            string actual = provider.Text.Trim('\0');
-
-            Assert.Equal(string.Empty, actual);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_Text_TestData))]
-    public void ComboBoxUiaTextProvider_TextLength_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, string text)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        comboBox.Items.Add(text);
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.Equal(comboBox.Text.Length, provider.TextLength);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_Text_TestData))]
-    public void ComboBoxUiaTextProvider_TextLength_ReturnsMinusOne_WithoutHandle(ComboBoxStyle dropDownStyle, string text)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.Items.Add(text);
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.Equal(-1, provider.TextLength);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_WindowExStyle_ReturnsCorrectValue(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-        WINDOW_EX_STYLE actual = provider.WindowExStyle;
-        Assert.Equal((WINDOW_EX_STYLE)0, actual);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_WindowExStyle_ReturnsLeft_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            WINDOW_EX_STYLE actual = provider.WindowExStyle;
-
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_LEFT, actual);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_EditStyle_ReturnsCorrectValue(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        WINDOW_STYLE actual = provider.WindowStyle;
-
-        Assert.False(((int)actual & PInvoke.ES_RIGHT) != 0);
-        Assert.True(((int)actual & PInvoke.ES_NOHIDESEL) != 0);
-        Assert.True(((int)actual & PInvoke.ES_AUTOHSCROLL) != 0);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_EditStyle_ReturnsLeft_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            WINDOW_STYLE actual = provider.WindowStyle;
-
-            Assert.Equal(PInvoke.ES_LEFT, (int)actual);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBox_GetVisibleRangePoints_ForSinglelineComboBox_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, new Size(0, 0), 0, 0 };
-            yield return new object[] { comboBoxStyle, new Size(0, 20), 0, 0 };
-            int expectedEnd = comboBoxStyle == ComboBoxStyle.DropDown ? 2 : 4;
-            yield return new object[] { comboBoxStyle, new Size(30, 30), 0, expectedEnd };
-            expectedEnd = comboBoxStyle == ComboBoxStyle.DropDown ? 4 : 8;
-            yield return new object[] { comboBoxStyle, new Size(50, 20), 0, expectedEnd };
-            yield return new object[] { comboBoxStyle, new Size(150, 20), 0, 26 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBox_GetVisibleRangePoints_ForSinglelineComboBox_TestData))]
-    public void ComboBoxUiaTextProvider_GetVisibleRangePoints_ForSinglelineComboBox_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, Size size, int expectedStart, int expectedEnd)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        provider.GetVisibleRangePoints(out int providerVisibleStart, out int providerVisibleEnd);
-
-        Assert.True(providerVisibleStart >= 0);
-        Assert.True(providerVisibleStart < comboBox.Text.Length);
-        Assert.True(providerVisibleEnd >= 0);
-        Assert.True(providerVisibleEnd <= comboBox.Text.Length);
-
-        Assert.Equal(expectedStart, providerVisibleStart);
-        Assert.Equal(expectedEnd, providerVisibleEnd);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    public static IEnumerable<object[]> ComboBox_GetVisibleRangePoints_ForSinglelineComboBox_WithoutHandle_TestData()
-    {
-        foreach (ComboBoxStyle comboBoxStyle in Enum.GetValues(typeof(ComboBoxStyle)))
-        {
-            if (comboBoxStyle == ComboBoxStyle.DropDownList)
-            {
-                continue;
-            }
-
-            yield return new object[] { comboBoxStyle, new Size(0, 0) };
-            yield return new object[] { comboBoxStyle, new Size(0, 20) };
-            yield return new object[] { comboBoxStyle, new Size(30, 30) };
-            yield return new object[] { comboBoxStyle, new Size(50, 20) };
-            yield return new object[] { comboBoxStyle, new Size(150, 20) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBox_GetVisibleRangePoints_ForSinglelineComboBox_WithoutHandle_TestData))]
-    public void ComboBoxUiaTextProvider_GetVisibleRangePoints_ReturnsZeros_WithoutHandle(ComboBoxStyle dropDownStyle, Size size)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-            comboBox.Items.Add("Some test text for testing");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            provider.GetVisibleRangePoints(out int providerVisibleStart, out int providerVisibleEnd);
-
-            Assert.Equal(0, providerVisibleStart);
-            Assert.Equal(0, providerVisibleEnd);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_GetVisibleRanges_TestData()
-    {
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(0, 0) };
-        yield return new object[] { ComboBoxStyle.DropDown, new Size(100, 20) };
-        yield return new object[] { ComboBoxStyle.Simple, new Size(0, 0) };
-        yield return new object[] { ComboBoxStyle.Simple, new Size(100, 20) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetVisibleRanges_TestData))]
-    public void ComboBoxUiaTextProvider_GetVisibleRanges_ReturnsCorrectValue(ComboBoxStyle dropDownStyle, Size size)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.NotNull(provider.GetVisibleRanges());
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_GetVisibleRanges_TestData))]
-    public void ComboBoxUiaTextProvider_GetVisibleRanges_ReturnsNull_WithoutHandle(ComboBoxStyle dropDownStyle, Size size)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = size };
-            comboBox.Items.Add("Some test text for testing");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.Null(provider.GetVisibleRanges());
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_RangeFromChild_DoesntThrowAnException(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            // RangeFromChild doesn't throw an exception
-            UiaCore.ITextRangeProvider range = provider.RangeFromChild(comboBox.AccessibilityObject);
-            // RangeFromChild implementation can be changed so this test can be changed too
-            Assert.Null(range);
-        }
-    }
-
-    public static IEnumerable<object[]> ComboBoxUiaTextProvider_RangeFromPoint_TestData()
-    {
-        yield return new object[] { ComboBoxStyle.DropDown, Point.Empty };
-        yield return new object[] { ComboBoxStyle.DropDown, new Point(10, 10) };
-        yield return new object[] { ComboBoxStyle.Simple, Point.Empty };
-        yield return new object[] { ComboBoxStyle.Simple, new Point(10, 10) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_RangeFromPoint_TestData))]
-    public void ComboBoxUiaTextProvider_RangeFromPoint_DoesntThrowAnException(ComboBoxStyle dropDownStyle, Point point)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        UiaTextRange textRangeProvider = provider.RangeFromPoint(point) as UiaTextRange;
-
-        Assert.NotNull(textRangeProvider);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ComboBoxUiaTextProvider_RangeFromPoint_TestData))]
-    public void ComboBoxUiaTextProvider_RangeFromPoint_ReturnsNull_WithoutHandle(ComboBoxStyle dropDownStyle, Point point)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            UiaTextRange textRangeProvider = provider.RangeFromPoint(point) as UiaTextRange;
-
-            Assert.Null(textRangeProvider);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 2, 5)]
-    [InlineData(ComboBoxStyle.DropDown, 0, 10)]
-    [InlineData(ComboBoxStyle.Simple, 2, 5)]
-    [InlineData(ComboBoxStyle.Simple, 0, 10)]
-    public void ComboBoxUiaTextProvider_SetSelection_GetSelection_ReturnCorrectValue(ComboBoxStyle dropDownStyle, int start, int end)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-        provider.SetSelection(start, end);
-        UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-        UiaTextRange textRange = selection[0] as UiaTextRange;
-
-        Assert.NotNull(selection);
-        Assert.NotNull(textRange);
-        Assert.Equal(start, textRange.Start);
-        Assert.Equal(end, textRange.End);
-        Assert.Equal(start, comboBox.SelectionStart);
-        Assert.Equal(end, comboBox.SelectionStart + comboBox.SelectionLength);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 2, 5)]
-    [InlineData(ComboBoxStyle.DropDown, 0, 10)]
-    [InlineData(ComboBoxStyle.Simple, 2, 5)]
-    [InlineData(ComboBoxStyle.Simple, 0, 10)]
-    public void ComboBoxUiaTextProvider_SetSelection_GetSelection_DontWork_WithoutHandle(ComboBoxStyle dropDownStyle, int start, int end)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.Items.Add("Some test text for testing");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            provider.SetSelection(start, end);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-
-            UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-
-            Assert.Null(selection);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-            Assert.Equal(0, comboBox.SelectionStart);
-            Assert.Equal(0, comboBox.SelectionStart + comboBox.SelectionLength);
-            Assert.True(comboBox.IsHandleCreated);
-            Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, -5, 10)]
-    [InlineData(ComboBoxStyle.DropDown, 5, 100)]
-    [InlineData(ComboBoxStyle.Simple, -5, 10)]
-    [InlineData(ComboBoxStyle.Simple, 5, 100)]
-    public void ComboBoxUiaTextProvider_SetSelection_DoesntSelectText_IfIncorrectArguments(ComboBoxStyle dropDownStyle, int start, int end)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle };
-            comboBox.CreateControl();
-            comboBox.Items.Add("Some test text for testing");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            provider.SetSelection(start, end);
-            UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-            Assert.NotNull(selection);
-
-            UiaTextRange textRange = selection[0] as UiaTextRange;
-
-            Assert.NotNull(textRange);
-            Assert.Equal(0, textRange.Start);
-            Assert.Equal(0, textRange.End);
-            Assert.Equal(0, comboBox.SelectionStart);
-            Assert.Equal(0, comboBox.SelectionStart + comboBox.SelectionLength);
-            Assert.True(comboBox.IsHandleCreated);
-            Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 0)]
-    [InlineData(ComboBoxStyle.DropDown, 2)]
-    [InlineData(ComboBoxStyle.Simple, 0)]
-    [InlineData(ComboBoxStyle.Simple, 2)]
-    public void ComboBoxUiaTextProvider_LineScroll_ReturnsFalse(ComboBoxStyle dropDownStyle, int newLine)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some long long test text for testing GetFirstVisibleLine method");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        Assert.False(provider.LineScroll(0, newLine));
-        Assert.Equal(0, provider.FirstVisibleLine);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 0)]
-    [InlineData(ComboBoxStyle.DropDown, 2)]
-    [InlineData(ComboBoxStyle.Simple, 0)]
-    [InlineData(ComboBoxStyle.Simple, 2)]
-    public void ComboBoxUiaTextProvider_LineScroll_DoesntWork_WithoutHandle(ComboBoxStyle dropDownStyle, int newLine)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-            comboBox.Items.Add("Some long long test text for testing GetFirstVisibleLine method");
-            comboBox.SelectedIndex = 0;
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-            Assert.False(provider.LineScroll(0, newLine));
-            Assert.Equal(-1, provider.FirstVisibleLine);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetLogfont_ReturnSegoe_ByDefault(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-        LOGFONTW logFont = provider.Logfont;
-
-        string actual = logFont.FaceName.ToString();
-
-        Assert.Equal("Segoe UI", actual);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_GetLogfont_ReturnEmpty_WithoutHandle(ComboBoxStyle dropDownStyle)
-    {
-        using (new NoAssertContext())
-        {
-            using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-            ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-            Assert.False(comboBox.IsHandleCreated);
-            Assert.Null(comboBox.TestAccessor().Dynamic._childEdit);
-            Assert.Equal(new LOGFONTW(), provider.Logfont);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_FirstVisibleLine_DefaultValueCorrect(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        int actualValue = (int)PInvoke.SendMessage((IHandle<HWND>)comboBox.TestAccessor().Dynamic._childEdit, PInvoke.EM_GETFIRSTVISIBLELINE);
-
-        Assert.Equal(actualValue, provider.FirstVisibleLine);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void ComboBoxUiaTextProvider_LinesCount_DefaultValueCorrect(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-        comboBox.CreateControl();
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        int actualValue = (int)PInvoke.SendMessage((IHandle<HWND>)comboBox.TestAccessor().Dynamic._childEdit, PInvoke.EM_GETLINECOUNT);
-
-        Assert.Equal(actualValue, provider.LinesCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 0)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 50)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, 200)]
-    [InlineData(ComboBoxStyle.DropDown, 50, 20, -5)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 0)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 50)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, 200)]
-    [InlineData(ComboBoxStyle.Simple, 50, 20, -5)]
-    public void ComboBoxUiaTextProvider_GetLineFromCharIndex_DefaultValueCorrect(
-        ComboBoxStyle dropDownStyle,
-        int width,
-        int height,
-        int charIndex)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(width, height) };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some test text for testing GetLineFromCharIndex method");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        int expectedLine = (int)PInvoke.SendMessage((IHandle<HWND>)comboBox.TestAccessor().Dynamic._childEdit, PInvoke.EM_LINEFROMCHAR, (WPARAM)charIndex);
-        int actualLine = provider.GetLineFromCharIndex(charIndex);
-
-        Assert.Equal(expectedLine, actualLine);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown, 0)]
-    [InlineData(ComboBoxStyle.DropDown, 2)]
-    [InlineData(ComboBoxStyle.Simple, 0)]
-    [InlineData(ComboBoxStyle.Simple, 2)]
-    public void ComboBoxUiaTextProvider_LineScroll_DefaultValueCorrect(ComboBoxStyle dropDownStyle, int newLine)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(50, 100) };
-        comboBox.CreateControl();
-        comboBox.Items.Add("Some long long test text for testing GetFirstVisibleLine method");
-        comboBox.SelectedIndex = 0;
-        ComboBox.ComboBoxUiaTextProvider provider = new ComboBox.ComboBoxUiaTextProvider(comboBox);
-
-        bool expectedValue = PInvoke.SendMessage((IHandle<HWND>)comboBox.TestAccessor().Dynamic._childEdit, PInvoke.EM_LINESCROLL, 0, newLine) != 0;
-
-        Assert.Equal(expectedValue, provider.LineScroll(0, newLine));
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.NotNull(comboBox.TestAccessor().Dynamic._childEdit);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBoxTests.cs
deleted file mode 100644
index 43fd0cf01fb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComboBoxTests.cs
+++ /dev/null
@@ -1,2516 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static System.Windows.Forms.ComboBox;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBoxTests
-{
-    [WinFormsFact]
-    public void ComboBox_Ctor_Default()
-    {
-        using var control = new SubComboBox();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.AllowSelection);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Empty(control.AutoCompleteCustomSource);
-        Assert.Same(control.AutoCompleteCustomSource, control.AutoCompleteCustomSource);
-        Assert.Equal(AutoCompleteMode.None, control.AutoCompleteMode);
-        Assert.Equal(AutoCompleteSource.None, control.AutoCompleteSource);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(control.PreferredHeight, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 121, control.PreferredHeight), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(117, control.PreferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 117, control.PreferredHeight - 4), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Null(control.DataManager);
-        Assert.Null(control.DataSource);
-        Assert.Same(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(121, control.PreferredHeight), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(new Rectangle(0, 0, 117, control.PreferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Equal(DrawMode.Normal, control.DrawMode);
-        Assert.Equal(106, control.DropDownHeight);
-        Assert.Equal(ComboBoxStyle.DropDown, control.DropDownStyle);
-        Assert.Equal(121, control.DropDownWidth);
-        Assert.False(control.DroppedDown);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Null(control.FormatInfo);
-        Assert.Empty(control.FormatString);
-        Assert.False(control.FormattingEnabled);
-        Assert.False(control.HasChildren);
-        Assert.Equal(control.PreferredHeight, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IntegralHeight);
-        Assert.Equal(Control.DefaultFont.Height + 2, control.ItemHeight);
-        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(8, control.MaxDropDownItems);
-        Assert.Equal(0, control.MaxLength);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.True(control.PreferredHeight > 0);
-        Assert.Equal(new Size(121, control.PreferredHeight), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(121, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Null(control.SelectedValue);
-        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(121, control.PreferredHeight), control.Size);
-        Assert.False(control.Sorted);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Empty(control.ValueMember);
-        Assert.True(control.Visible);
-        Assert.Equal(121, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubComboBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ComboBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56210242, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoCompleteMode>]
-    public void ComboBox_AutoCompleteMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(AutoCompleteMode value)
-    {
-        using var control = new ComboBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoCompleteMode = value);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ComboBox_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ComboBox
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void ComboBox_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ComboBox))[nameof(ComboBox.BackColor)];
-        using var control = new ComboBox();
-        Assert.False(property.CanResetValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ComboBox_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ComboBox))[nameof(ComboBox.BackColor)];
-        using var control = new ComboBox();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void ComboBox_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new ComboBox
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ComboBox_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new ComboBox
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ComboBox_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new ComboBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    public static IEnumerable<object[]> DataSource_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new List<int>() };
-        yield return new object[] { Array.Empty<int>() };
-
-        var mockSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockSource
-            .Setup(s => s.GetList())
-            .Returns(new int[] { 1 });
-        yield return new object[] { mockSource.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ComboBox_DataSource_Set_GetReturnsExpected(object value)
-    {
-        using var control = new SubComboBox
-        {
-            DataSource = value
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DataSource_SetWithHandler_CallsDataSourceChanged()
-    {
-        using var control = new ComboBox();
-        int dataSourceCallCount = 0;
-        int displayMemberCallCount = 0;
-        EventHandler dataSourceHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            dataSourceCallCount++;
-        };
-        EventHandler displayMemberHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            displayMemberCallCount++;
-        };
-        control.DataSourceChanged += dataSourceHandler;
-        control.DisplayMemberChanged += displayMemberHandler;
-
-        // Set different.
-        var dataSource1 = new List<int>();
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(0, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set same.
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(0, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set different.
-        var dataSource2 = new List<int>();
-        control.DataSource = dataSource2;
-        Assert.Same(dataSource2, control.DataSource);
-        Assert.Equal(0, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set null.
-        control.DataSource = null;
-        Assert.Null(control.DataSource);
-        Assert.Equal(0, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Remove handler.
-        control.DataSourceChanged -= dataSourceHandler;
-        control.DisplayMemberChanged -= displayMemberHandler;
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(0, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ComboBoxStyle>]
-    public void ComboBox_DropDownStyle_Set_GetReturnsExpected(ComboBoxStyle value)
-    {
-        using var control = new ComboBox
-        {
-            DropDownStyle = value
-        };
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DropDownStyle = value;
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DropDownStyle_Set_TestData()
-    {
-        foreach (AutoCompleteSource source in Enum.GetValues(typeof(AutoCompleteSource)))
-        {
-            foreach (AutoCompleteMode mode in Enum.GetValues(typeof(AutoCompleteMode)))
-            {
-                yield return new object[] { source, mode, ComboBoxStyle.Simple, mode };
-                yield return new object[] { source, mode, ComboBoxStyle.DropDown, mode };
-                yield return new object[] { source, mode, ComboBoxStyle.DropDownList, source != AutoCompleteSource.ListItems ? AutoCompleteMode.None : mode };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DropDownStyle_Set_TestData))]
-    public void ComboBox_DropDownStyle_SetWithSourceAndMode_GetReturnsExpected(AutoCompleteSource source, AutoCompleteMode mode, ComboBoxStyle value, AutoCompleteMode expectedMode)
-    {
-        using var control = new ComboBox
-        {
-            AutoCompleteSource = source,
-            AutoCompleteMode = mode,
-            DropDownStyle = value
-        };
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.Equal(source, control.AutoCompleteSource);
-        Assert.Equal(expectedMode, control.AutoCompleteMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DropDownStyle = value;
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.Equal(source, control.AutoCompleteSource);
-        Assert.Equal(expectedMode, control.AutoCompleteMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoCompleteSource>]
-    public void ComboBox_AutoCompleteSource_Set_GetReturnsExpected(AutoCompleteSource value)
-    {
-        using var control = new ComboBox();
-        control.AutoCompleteSource = value;
-        Assert.Equal(value, control.AutoCompleteSource);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoCompleteSource>]
-    public void ComboBox_AutoCompleteSource_InvalidAutoCompleteSource_ThrowsInvalidEnumArgumentException(AutoCompleteSource source)
-    {
-        using var control = new ComboBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoCompleteSource = source);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DropDownStyle_SetWithPreferredHeight_ResetsPreferredHeight()
-    {
-        using var control = new ComboBox
-        {
-            FormattingEnabled = true
-        };
-        int height1 = control.PreferredHeight;
-
-        control.DropDownStyle = ComboBoxStyle.DropDownList;
-        Assert.Equal(height1, control.PreferredHeight);
-
-        control.DropDownStyle = ComboBoxStyle.Simple;
-        int height2 = control.PreferredHeight;
-        Assert.True(height2 > height1);
-
-        control.DropDownStyle = ComboBoxStyle.DropDownList;
-        Assert.Equal(height1, control.PreferredHeight);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.Simple, 1)]
-    [InlineData(ComboBoxStyle.DropDown, 0)]
-    [InlineData(ComboBoxStyle.DropDownList, 1)]
-    public void ComboBox_DropDownStyle_SetWithHandle_GetReturnsExpected(ComboBoxStyle value, int expectedCreatedCallCount)
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DropDownStyle = value;
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.DropDownStyle = value;
-        Assert.Equal(value, control.DropDownStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DropDownStyle_SetWithHandler_CallsDropDownStyleChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DropDownStyleChanged += handler;
-
-        // Set different.
-        control.DropDownStyle = ComboBoxStyle.DropDownList;
-        Assert.Equal(ComboBoxStyle.DropDownList, control.DropDownStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.DropDownStyle = ComboBoxStyle.DropDownList;
-        Assert.Equal(ComboBoxStyle.DropDownList, control.DropDownStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.DropDownStyle = ComboBoxStyle.Simple;
-        Assert.Equal(ComboBoxStyle.Simple, control.DropDownStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DropDownStyleChanged -= handler;
-        control.DropDownStyle = ComboBoxStyle.DropDownList;
-        Assert.Equal(ComboBoxStyle.DropDownList, control.DropDownStyle);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ComboBoxStyle>]
-    public void ComboBox_DropDownStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(ComboBoxStyle value)
-    {
-        using var control = new ComboBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DropDownStyle = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ComboBox_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubComboBox
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ComboBox_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ComboBox
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void ComboBox_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ComboBox))[nameof(ComboBox.ForeColor)];
-        using var control = new ComboBox();
-        Assert.False(property.CanResetValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ComboBox_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ComboBox))[nameof(ComboBox.ForeColor)];
-        using var control = new ComboBox();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ComboBox_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ComboBox
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ComboBox_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ComboBox_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new ComboBox
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new ComboBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ComboBox_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new ComboBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, "")]
-    [InlineData(0, "System.Windows.Forms.Tests.ComboBoxTests+DataClass")]
-    [InlineData(1, "System.Windows.Forms.Tests.ComboBoxTests+DataClass")]
-    public void ComboBox_SelectedIndex_SetWithoutDisplayMember_GetReturnsExpected(int value, string expectedText)
-    {
-        using var control = new ComboBox();
-        control.Items.Add(new DataClass { Value = "Value1" });
-        control.Items.Add(new DataClass { Value = "Value2" });
-
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value == -1 ? null : control.Items[control.SelectedIndex], control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value == -1 ? null : control.Items[control.SelectedIndex], control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, "")]
-    [InlineData(0, "Value1")]
-    [InlineData(1, "Value2")]
-    public void ComboBox_SelectedIndex_SetWithDisplayMember_GetReturnsExpected(int value, string expectedText)
-    {
-        using var control = new ComboBox
-        {
-            DisplayMember = "Value"
-        };
-        control.Items.Add(new DataClass { Value = "Value1" });
-        control.Items.Add(new DataClass { Value = "Value2" });
-
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value == -1 ? null : control.Items[control.SelectedIndex], control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value == -1 ? null : control.Items[control.SelectedIndex], control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectedText_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectedText_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectionLength_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectionLength_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectionStart_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated); // SelectionStart forces Handle creating
-
-        // Get again.
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectionStart_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new ComboBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubComboBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ComboBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubComboBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ComboBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubComboBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> FindString_TestData()
-    {
-        foreach (int startIndex in new int[] { -2, -1, 0, 1 })
-        {
-            yield return new object[] { new ComboBox(), null, startIndex, -1 };
-            yield return new object[] { new ComboBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ComboBox(), "s", startIndex, -1 };
-
-            using var controlWithNoItems = new ComboBox();
-            Assert.Empty(controlWithNoItems.Items);
-            yield return new object[] { new ComboBox(), null, startIndex, -1 };
-            yield return new object[] { new ComboBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ComboBox(), "s", startIndex, -1 };
-        }
-
-        using var controlWithItems = new ComboBox
-        {
-            DisplayMember = "Value"
-        };
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "ABC" });
-        controlWithItems.Items.Add(new DataClass { Value = "def" });
-        controlWithItems.Items.Add(new DataClass { Value = "" });
-        controlWithItems.Items.Add(new DataClass { Value = null });
-
-        yield return new object[] { controlWithItems, "abc", -1, 0 };
-        yield return new object[] { controlWithItems, "abc", 0, 1 };
-        yield return new object[] { controlWithItems, "abc", 1, 2 };
-        yield return new object[] { controlWithItems, "abc", 2, 0 };
-        yield return new object[] { controlWithItems, "abc", 5, 0 };
-
-        yield return new object[] { controlWithItems, "ABC", -1, 0 };
-        yield return new object[] { controlWithItems, "ABC", 0, 1 };
-        yield return new object[] { controlWithItems, "ABC", 1, 2 };
-        yield return new object[] { controlWithItems, "ABC", 2, 0 };
-        yield return new object[] { controlWithItems, "ABC", 5, 0 };
-
-        yield return new object[] { controlWithItems, "a", -1, 0 };
-        yield return new object[] { controlWithItems, "a", 0, 1 };
-        yield return new object[] { controlWithItems, "a", 1, 2 };
-        yield return new object[] { controlWithItems, "a", 2, 0 };
-        yield return new object[] { controlWithItems, "a", 5, 0 };
-
-        yield return new object[] { controlWithItems, "A", -1, 0 };
-        yield return new object[] { controlWithItems, "A", 0, 1 };
-        yield return new object[] { controlWithItems, "A", 1, 2 };
-        yield return new object[] { controlWithItems, "A", 2, 0 };
-        yield return new object[] { controlWithItems, "A", 5, 0 };
-
-        yield return new object[] { controlWithItems, "abcd", -1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 0, -1 };
-        yield return new object[] { controlWithItems, "abcd", 1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 2, -1 };
-        yield return new object[] { controlWithItems, "abcd", 5, -1 };
-
-        yield return new object[] { controlWithItems, "def", -1, 3 };
-        yield return new object[] { controlWithItems, "def", 0, 3 };
-        yield return new object[] { controlWithItems, "def", 1, 3 };
-        yield return new object[] { controlWithItems, "def", 2, 3 };
-        yield return new object[] { controlWithItems, "def", 5, 3 };
-
-        yield return new object[] { controlWithItems, null, -1, -1 };
-        yield return new object[] { controlWithItems, null, 0, -1 };
-        yield return new object[] { controlWithItems, null, 1, -1 };
-        yield return new object[] { controlWithItems, null, 2, -1 };
-        yield return new object[] { controlWithItems, null, 5, -1 };
-
-        yield return new object[] { controlWithItems, string.Empty, -1, 0 };
-        yield return new object[] { controlWithItems, string.Empty, 0, 1 };
-        yield return new object[] { controlWithItems, string.Empty, 1, 2 };
-        yield return new object[] { controlWithItems, string.Empty, 2, 3 };
-        yield return new object[] { controlWithItems, string.Empty, 5, 0 };
-
-        yield return new object[] { controlWithItems, "NoSuchItem", -1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 0, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 2, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 5, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FindString_TestData))]
-    public void ComboBox_FindString_Invoke_ReturnsExpected(ComboBox control, string s, int startIndex, int expected)
-    {
-        if (startIndex == -1)
-        {
-            Assert.Equal(expected, control.FindString(s));
-        }
-
-        Assert.Equal(expected, control.FindString(s, startIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ComboBox_FindString_InvalidStartIndex_ThrowsArgumentOutOfRangeException(int startIndex)
-    {
-        using var control = new ComboBox();
-        control.Items.Add("item");
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindString("s", startIndex));
-    }
-
-    public static IEnumerable<object[]> FindStringExact_TestData()
-    {
-        foreach (int startIndex in new int[] { -2, -1, 0, 1 })
-        {
-            foreach (bool ignoreCase in new bool[] { true, false })
-            {
-                yield return new object[] { new ComboBox(), null, startIndex, ignoreCase, -1 };
-                yield return new object[] { new ComboBox(), string.Empty, startIndex, ignoreCase, -1 };
-                yield return new object[] { new ComboBox(), "s", startIndex, ignoreCase, -1 };
-
-                using var controlWithNoItems = new ComboBox();
-                Assert.Empty(controlWithNoItems.Items);
-                yield return new object[] { new ComboBox(), null, startIndex, ignoreCase, -1 };
-                yield return new object[] { new ComboBox(), string.Empty, startIndex, ignoreCase, -1 };
-                yield return new object[] { new ComboBox(), "s", startIndex, ignoreCase, -1 };
-            }
-        }
-
-        using var controlWithItems = new ComboBox
-        {
-            DisplayMember = "Value"
-        };
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "ABC" });
-        controlWithItems.Items.Add(new DataClass { Value = "def" });
-        controlWithItems.Items.Add(new DataClass { Value = "" });
-        controlWithItems.Items.Add(new DataClass { Value = null });
-
-        foreach (bool ignoreCase in new bool[] { true, false })
-        {
-            yield return new object[] { controlWithItems, "abc", -1, ignoreCase, 0 };
-            yield return new object[] { controlWithItems, "abc", 0, ignoreCase, 1 };
-            yield return new object[] { controlWithItems, "abc", 1, ignoreCase, ignoreCase ? 2 : 0 };
-            yield return new object[] { controlWithItems, "abc", 2, ignoreCase, 0 };
-            yield return new object[] { controlWithItems, "abc", 5, ignoreCase, 0 };
-        }
-
-        yield return new object[] { controlWithItems, "ABC", -1, false, 2 };
-        yield return new object[] { controlWithItems, "ABC", 0, false, 2 };
-        yield return new object[] { controlWithItems, "ABC", 1, false, 2 };
-        yield return new object[] { controlWithItems, "ABC", 2, false, 2 };
-        yield return new object[] { controlWithItems, "ABC", 5, false, 2 };
-
-        yield return new object[] { controlWithItems, "ABC", -1, true, 0 };
-        yield return new object[] { controlWithItems, "ABC", 0, true, 1 };
-        yield return new object[] { controlWithItems, "ABC", 1, true, 2 };
-        yield return new object[] { controlWithItems, "ABC", 2, true, 0 };
-        yield return new object[] { controlWithItems, "ABC", 5, true, 0 };
-
-        foreach (bool ignoreCase in new bool[] { true, false })
-        {
-            yield return new object[] { controlWithItems, "a", -1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "a", 0, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "a", 1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "a", 2, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "a", 5, ignoreCase, -1 };
-
-            yield return new object[] { controlWithItems, "A", -1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "A", 0, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "A", 1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "A", 2, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "A", 5, ignoreCase, -1 };
-
-            yield return new object[] { controlWithItems, "abcd", -1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "abcd", 0, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "abcd", 1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "abcd", 2, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "abcd", 5, ignoreCase, -1 };
-
-            yield return new object[] { controlWithItems, "def", -1, ignoreCase, 3 };
-            yield return new object[] { controlWithItems, "def", 0, ignoreCase, 3 };
-            yield return new object[] { controlWithItems, "def", 1, ignoreCase, 3 };
-            yield return new object[] { controlWithItems, "def", 2, ignoreCase, 3 };
-            yield return new object[] { controlWithItems, "def", 5, ignoreCase, 3 };
-
-            yield return new object[] { controlWithItems, null, -1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, null, 0, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, null, 1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, null, 2, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, null, 5, ignoreCase, -1 };
-
-            yield return new object[] { controlWithItems, string.Empty, -1, ignoreCase, 4 };
-            yield return new object[] { controlWithItems, string.Empty, 0, ignoreCase, 4 };
-            yield return new object[] { controlWithItems, string.Empty, 1, ignoreCase, 4 };
-            yield return new object[] { controlWithItems, string.Empty, 2, ignoreCase, 4 };
-            yield return new object[] { controlWithItems, string.Empty, 5, ignoreCase, 4 };
-
-            yield return new object[] { controlWithItems, "NoSuchItem", -1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "NoSuchItem", 0, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "NoSuchItem", 1, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "NoSuchItem", 2, ignoreCase, -1 };
-            yield return new object[] { controlWithItems, "NoSuchItem", 5, ignoreCase, -1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FindStringExact_TestData))]
-    public void ComboBox_FindStringExact_Invoke_ReturnsExpected(ComboBox control, string s, int startIndex, bool ignoreCase, int expected)
-    {
-        if (ignoreCase)
-        {
-            if (startIndex == -1)
-            {
-                Assert.Equal(expected, control.FindStringExact(s));
-            }
-
-            Assert.Equal(expected, control.FindStringExact(s, startIndex));
-        }
-
-        Assert.Equal(expected, control.FindStringExact(s, startIndex, ignoreCase));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ComboBox_FindStringExact_InvalidStartIndex_ThrowsArgumentOutOfRangeException(int startIndex)
-    {
-        using var control = new ComboBox();
-        control.Items.Add("item");
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindStringExact("s", startIndex));
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindStringExact("s", startIndex, ignoreCase: true));
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindStringExact("s", startIndex, ignoreCase: false));
-    }
-
-    private void SendCtrlBackspace(SubComboBox tb)
-    {
-        var message = new Message();
-        tb.ProcessCmdKey(ref message, Keys.Control | Keys.Back);
-    }
-
-    [WinFormsFact]
-    public void CtrlBackspaceTextRemainsEmpty()
-    {
-        using SubComboBox control = new SubComboBox();
-        control.ConfigureForCtrlBackspace();
-        SendCtrlBackspace(control);
-        Assert.Equal("", control.Text);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCtrlBackspaceData))]
-    public void CtrlBackspaceTextChanged(string value, string expected, int cursorRelativeToEnd)
-    {
-        using SubComboBox control = new SubComboBox(value);
-        control.ConfigureForCtrlBackspace(cursorRelativeToEnd);
-        SendCtrlBackspace(control);
-        Assert.Equal(expected, control.Text);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCtrlBackspaceRepeatedData))]
-    public void CtrlBackspaceRepeatedTextChanged(string value, string expected, int repeats)
-    {
-        using SubComboBox control = new SubComboBox(value);
-        control.ConfigureForCtrlBackspace();
-        for (int i = 0; i < repeats; i++)
-        {
-            SendCtrlBackspace(control);
-        }
-
-        Assert.Equal(expected, control.Text);
-    }
-
-    [WinFormsFact]
-    public void CtrlBackspaceDeletesSelection()
-    {
-        using SubComboBox control = new SubComboBox("123-5-7-9");
-        control.ConfigureForCtrlBackspace();
-        control.SelectionStart = 2;
-        control.SelectionLength = 5;
-        SendCtrlBackspace(control);
-        Assert.Equal("12-9", control.Text);
-    }
-
-    public static IEnumerable<object[]> WndProc_PaintWithoutWParam_TestData()
-    {
-        foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-        {
-            yield return new object[] { FlatStyle.Flat, false, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Popup, false, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Standard, false, true, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.System, false, true, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.Flat, false, false, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Popup, false, false, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Standard, false, false, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.System, false, false, allPaintingInWmPaint, false, 0 };
-
-            yield return new object[] { FlatStyle.Flat, true, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Popup, true, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Standard, true, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.System, true, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Flat, true, false, allPaintingInWmPaint, true, 1 };
-            yield return new object[] { FlatStyle.Popup, true, false, allPaintingInWmPaint, true, 1 };
-            yield return new object[] { FlatStyle.Standard, true, false, allPaintingInWmPaint, true, 1 };
-            yield return new object[] { FlatStyle.System, true, false, allPaintingInWmPaint, true, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithoutWParam_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithoutWParam_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, bool expectedIsHandleCreated, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubComboBox
-            {
-                FlatStyle = flatStyle
-            };
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PAINT
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithoutWParam_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithoutWParamWithBounds_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, bool expectedIsHandleCreated, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubComboBox
-            {
-                FlatStyle = flatStyle,
-                Bounds = new Rectangle(1, 2, 30, 40)
-            };
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PAINT
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_PaintWithoutWParamWithHandle_TestData()
-    {
-        foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-        {
-            yield return new object[] { FlatStyle.Flat, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Popup, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Standard, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.System, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Flat, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Popup, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Standard, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.System, false, false, allPaintingInWmPaint, 0 };
-
-            yield return new object[] { FlatStyle.Flat, true, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Popup, true, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Standard, true, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.System, true, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Flat, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Popup, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Standard, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.System, true, false, allPaintingInWmPaint, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithoutWParamWithHandle_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithoutWParamWithHandle_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, int expectedPaintCallCount)
-    {
-        using var control = new SubComboBox
-        {
-            FlatStyle = flatStyle
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_PAINT
-        };
-        control.WndProc(ref m);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(expectedPaintCallCount, paintCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithoutWParamWithHandle_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithoutWParamWithBoundsWithHandle_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, int expectedPaintCallCount)
-    {
-        using var control = new SubComboBox
-        {
-            FlatStyle = flatStyle,
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_PAINT
-        };
-        control.WndProc(ref m);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(expectedPaintCallCount, paintCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_PaintWithWParam_TestData()
-    {
-        foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-        {
-            yield return new object[] { FlatStyle.Flat, false, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Popup, false, true, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Standard, false, true, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.System, false, true, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.Flat, false, false, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Popup, false, false, allPaintingInWmPaint, true, 0 };
-            yield return new object[] { FlatStyle.Standard, false, false, allPaintingInWmPaint, false, 0 };
-            yield return new object[] { FlatStyle.System, false, false, allPaintingInWmPaint, false, 0 };
-
-            yield return new object[] { FlatStyle.Flat, true, true, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.Popup, true, true, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.Standard, true, true, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.System, true, true, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.Flat, true, false, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.Popup, true, false, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.Standard, true, false, allPaintingInWmPaint, false, 1 };
-            yield return new object[] { FlatStyle.System, true, false, allPaintingInWmPaint, false, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithWParam_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithWParam_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, bool expectedIsHandleCreated, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var image = new Bitmap(10, 10);
-            using Graphics graphics = Graphics.FromImage(image);
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                using var control = new SubComboBox
-                {
-                    FlatStyle = flatStyle
-                };
-                control.SetStyle(ControlStyles.UserPaint, userPaint);
-                control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-                control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-                int paintCallCount = 0;
-                control.Paint += (sender, e) => paintCallCount++;
-
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_PAINT,
-                    WParam = hdc
-                };
-                control.WndProc(ref m);
-                Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-                Assert.Equal(expectedPaintCallCount, paintCallCount);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithWParam_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithWParamWithBounds_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, bool expectedIsHandleCreated, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var image = new Bitmap(10, 10);
-            using Graphics graphics = Graphics.FromImage(image);
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                using var control = new SubComboBox
-                {
-                    FlatStyle = flatStyle,
-                    Bounds = new Rectangle(1, 2, 30, 40)
-                };
-                control.SetStyle(ControlStyles.UserPaint, userPaint);
-                control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-                control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-                int paintCallCount = 0;
-                control.Paint += (sender, e) => paintCallCount++;
-
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_PAINT,
-                    WParam = hdc
-                };
-                control.WndProc(ref m);
-                Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-                Assert.Equal(expectedPaintCallCount, paintCallCount);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_PaintWithWParamWithHandle_TestData()
-    {
-        foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-        {
-            yield return new object[] { FlatStyle.Flat, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Popup, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Standard, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.System, false, true, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Flat, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Popup, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.Standard, false, false, allPaintingInWmPaint, 0 };
-            yield return new object[] { FlatStyle.System, false, false, allPaintingInWmPaint, 0 };
-
-            yield return new object[] { FlatStyle.Flat, true, true, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Popup, true, true, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Standard, true, true, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.System, true, true, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Flat, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Popup, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.Standard, true, false, allPaintingInWmPaint, 1 };
-            yield return new object[] { FlatStyle.System, true, false, allPaintingInWmPaint, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithWParamWithHandle_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithWParamWithHandle_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            using var control = new SubComboBox
-            {
-                FlatStyle = flatStyle
-            };
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PAINT,
-                WParam = hdc
-            };
-            control.WndProc(ref m);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PaintWithWParamWithHandle_TestData))]
-    public void ComboBox_WndProc_InvokePaintWithWParamWithBoundsWithHandle_Success(FlatStyle flatStyle, bool userPaint, bool doubleBuffered, bool allPaintingInWmPaint, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            using var control = new SubComboBox
-            {
-                FlatStyle = flatStyle,
-                Bounds = new Rectangle(1, 2, 30, 40)
-            };
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PAINT,
-                WParam = hdc
-            };
-            control.WndProc(ref m);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ComboBoxStyle.DropDown)]
-    [InlineData(ComboBoxStyle.DropDownList)]
-    [InlineData(ComboBoxStyle.Simple)]
-    public void Combobox_SetCustomSize_DoesNotCreateHandle(ComboBoxStyle dropDownStyle)
-    {
-        using ComboBox comboBox = new ComboBox() { DropDownStyle = dropDownStyle, Size = new Size(100, 50) };
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_CustomAccessibleObject_DoesntCrashControl_WhenAddingItems()
-    {
-        using AutomationEventCountingComboBox control = new();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_OnKeyUp_DoesNotInvoke_RaiseAutomationEvent_AccessibilityObjectIsNotCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        comboBox.OnKeyUp();
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationCallCount" method is called from "OnTextChanged" method
-        Assert.Equal(0, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_OnKeyUp_Invoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.OnKeyUp();
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationCallCount" method is called from "OnTextChanged" method
-        Assert.Equal(1, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_OnMouseDown_DoesNotInvoke_RaiseAutomationEvent_AccessibilityObjectIsNotCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        comboBox.OnMouseDown(comboBox.PointToClient(comboBoxChildEditUiaProvider.Bounds.Location));
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationCallCount" method is called from "OnTextChanged" method
-        Assert.Equal(0, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_OnMouseDown_Invoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.OnMouseDown(comboBox.PointToClient(comboBoxChildEditUiaProvider.Bounds.Location));
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationCallCount" method is called from "OnTextChanged" method
-        Assert.Equal(1, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void Combox_SelectedItem_HandlesItemRemoval(int selectedIndex)
-    {
-        using ComboBox comboBox = new();
-        for (int i = 0; i < 3; i++)
-        {
-            comboBox.Items.Add(i.ToString());
-        }
-
-        comboBox.SelectedItem = comboBox.Items[selectedIndex];
-        Assert.Equal(selectedIndex, comboBox.SelectedIndex);
-        Assert.Equal(selectedIndex.ToString(), comboBox.SelectedItem);
-        Assert.Equal(selectedIndex.ToString(), comboBox.Text);
-
-        comboBox.Items.RemoveAt(selectedIndex);
-        Assert.Equal(-1, comboBox.SelectedIndex);
-        Assert.Null(comboBox.SelectedItem);
-        Assert.Empty(comboBox.Text);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectedItem_Set_DoesNotInvoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.SelectedItem = comboBox.Items[0];
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal(0, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_SelectedItem_Set_Invoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.SelectedItem = comboBox.Items[0];
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationEvent" method is called from "OnTextChanged" and "OnSelectedIndexChanged" methods
-        Assert.Equal(2, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Text_Set_DoesNotInvoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.Text = "Test";
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal(0, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Text_Set_Invoke_RaiseAutomationEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-        comboBox.CreateControl();
-        AutomationEventCountingComboBoxChildEditUiaProvider comboBoxChildEditUiaProvider = new(comboBox, comboBox.TestAccessor().Dynamic._childEdit.Handle);
-        comboBox.TestAccessor().Dynamic._childEditAccessibleObject = comboBoxChildEditUiaProvider;
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.Text = "Test";
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationEvent" method is called from "OnTextChanged" method
-        Assert.Equal(1, comboBoxChildEditUiaProvider.RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DroppedDown_Set_True_DoesNotInvoke_RaiseAutomationPropertyChangedEvent_AccessibilityObjectIsNotCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.DroppedDown = true;
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal(0, ((AutomationEventCountingComboBoxAccessibleObject)comboBox.AccessibilityObject).RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DroppedDown_Set_False_DoesNotInvoke_RaiseAutomationPropertyChangedEvent_AccessibilityObjectIsNotCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.DroppedDown = true;
-        comboBox.DroppedDown = false;
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-        Assert.Equal(0, ((AutomationEventCountingComboBoxAccessibleObject)comboBox.AccessibilityObject).RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DroppedDownProperty_Set_True_Invoke_RaiseAutomationPropertyChangedEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.DroppedDown = true;
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationPropertyChangedEvent" method is called from "OnDropDown" method
-        Assert.Equal(1, ((AutomationEventCountingComboBoxAccessibleObject)comboBox.AccessibilityObject).RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_DroppedDownProperty_Set_False_Invoke_RaiseAutomationPropertyChangedEvent_AccessibilityObjectIsCreated()
-    {
-        using AutomationEventCountingComboBox comboBox = new();
-
-        Assert.IsType<AutomationEventCountingComboBoxAccessibleObject>(comboBox.AccessibilityObject);
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.DroppedDown = true;
-        comboBox.DroppedDown = false;
-
-        Assert.True(comboBox.IsAccessibilityObjectCreated);
-        Assert.True(comboBox.IsHandleCreated);
-
-        // The "RaiseAutomationPropertyChangedEvent" method is called from "OnDropDown" and "OnDropDownClosed" method
-        Assert.Equal(2, ((AutomationEventCountingComboBoxAccessibleObject)comboBox.AccessibilityObject).RaiseAutomationCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Add_Items_By_Index()
-    {
-        using ComboBox comboBox = new();
-        Random random = new(DateTime.Now.Millisecond);
-        InitializeItems(comboBox, 10);
-
-        // Add 5 items by index
-        for (int i = 0; i < 5; i++)
-        {
-            int count = comboBox.Items.Count;
-            int index = random.Next(0, count - 1);
-            string item = $"new item{i}";
-            comboBox.Items.Insert(index, item);
-
-            Assert.True(item.Equals(comboBox.Items[index]));
-            Assert.Equal(comboBox.Items.Count, ++count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(10, 0, 5)]
-    [InlineData(10, 2, 4)]
-    public void ComboBox_Remove_Items_By_Index(int numberOfItems, int index, int numberOfItemsToRemove)
-    {
-        using ComboBox comboBox = new();
-        InitializeItems(comboBox, numberOfItems);
-
-        int count = comboBox.Items.Count;
-        for (int i = 0; i < numberOfItemsToRemove; i++)
-        {
-            comboBox.Items.RemoveAt(index);
-        }
-
-        Assert.Equal(count - numberOfItemsToRemove, comboBox.Items.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(10, 0, 5)]
-    [InlineData(10, 2, 4)]
-    public void ComboBox_Remove_Items_By_Object(int numberOfItems, int index, int number)
-    {
-        using ComboBox comboBox = new();
-        InitializeItems(comboBox, numberOfItems);
-
-        int count = comboBox.Items.Count;
-        for (int i = 0; i < number; i++)
-        {
-            comboBox.Items.Remove(comboBox.Items[index]);
-        }
-
-        Assert.Equal(count - number, comboBox.Items.Count);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Sorted_Sorts_By_Ascending()
-    {
-        using ComboBox comboBox = new();
-        const int numItems = 200;
-        Random random = new();
-
-        string[] items = new string[numItems];
-
-        // All the items are between a - z
-        for (int j = 0; j < numItems; j++)
-        {
-            string item = (random.Next() % 26 + (char)'a').ToString();
-            items[j] = item;
-            comboBox.Items.Add(item);
-        }
-
-        comboBox.Sorted = true;
-        Array.Sort(items);
-
-        for (int i = 0; i < numItems; i++)
-        {
-            Assert.Equal(items[i], comboBox.Items[i]);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(5)]
-    public void ComboBox_SelectedIndex_DoesNotChange_SelectedItem_AndDoesNotFire_OnSelectedIndexChanged(int index)
-    {
-        using ComboBoxWithSelectCounter comboBox = new();
-        InitializeItems(comboBox, 10);
-
-        comboBox.SelectedIndex = index;
-        comboBox.Sorted = false;
-        int selectedIndex = comboBox.SelectedIndex;
-        comboBox.SelectedIndex = index;
-
-        Assert.Equal(index, comboBox.SelectedIndex);
-        Assert.True(comboBox.Items[comboBox.SelectedIndex].Equals(comboBox.SelectedItem));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(9)]
-    public void ComboBox_SelectedIndexChangesSelectedItemAndFiresOnSelectedIndexChanged(int index)
-    {
-        using ComboBoxWithSelectCounter comboBox = new();
-        InitializeItems(comboBox, 10);
-
-        comboBox.Sorted = false;
-        int eventsCountExpected = 0;
-        comboBox.ResetEventsCount();
-        int selectedIndex = comboBox.SelectedIndex;
-        comboBox.SelectedIndex = index;
-        eventsCountExpected++;
-
-        Assert.Equal(index, comboBox.SelectedIndex);
-        Assert.True(comboBox.Items[comboBox.SelectedIndex].Equals(comboBox.SelectedItem));
-        Assert.Equal(eventsCountExpected, comboBox.EventsCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("item0", 0, 0, false)]
-    [InlineData("item1", 0, 1, false)]
-    [InlineData("item1", 1, 1, false)]
-    [InlineData("item1", 2, 1, false)]
-    [InlineData("item7", 2, 7, false)]
-    [InlineData("item7", 9, 7, false)]
-    [InlineData("item9", 0, 9, false)]
-    [InlineData("item9", 9, 9, false)]
-    [InlineData("Item9", 9, -1, false)]
-    [InlineData("item1984", 9, -1, false)]
-    [InlineData("item0", 0, 0, true)]
-    [InlineData("ITEM1", 0, 1, true)]
-    [InlineData("itEm1", 1, 1, true)]
-    [InlineData("item1", 2, 1, true)]
-    [InlineData("item7", 2, 7, true)]
-    [InlineData("item7", 9, 7, true)]
-    [InlineData("item9", 0, 9, true)]
-    [InlineData("item9", 9, 9, true)]
-    [InlineData("Item9", 9, 9, true)]
-    [InlineData("item1984", 9, -1, true)]
-    public void ComboBox_FindString(string value, int index, int expected, bool isExact)
-    {
-        using ComboBox comboBox = new();
-        InitializeItems(comboBox, 10);
-
-        int actual = comboBox.FindStringExact(value, index, isExact);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void OwnerDrawComboBox_Verify_OnMeasureItem_Receives_Correct_Arguments()
-    {
-        using OwnerDrawComboBox ownerDrawComboBox = new();
-        ownerDrawComboBox.CreateControl();
-        ownerDrawComboBox.Items.AddRange(new object[]
-        {
-            "One",
-            "Two",
-            "Three"
-        });
-        ownerDrawComboBox.Location = new Point(0, 50);
-        Assert.Equal(3, ownerDrawComboBox.MeasureItemEventArgs.Count);
-
-        for (int i = 0; i < 3; i++)
-        {
-            MeasureItemEventArgs e = ownerDrawComboBox.MeasureItemEventArgs[i];
-            Assert.NotNull(e.Graphics);
-            Assert.Equal(e.Index, i);
-            Assert.Equal(18, e.ItemHeight);
-            Assert.Equal(0, e.ItemWidth);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Up, 9, 9)]
-    [InlineData(Keys.Down, 9, 0)]
-    public void ComboBox_Select_Item_By_Key(Keys key, int expectedKeyPressesCount, int selectedIndex)
-    {
-        using ComboBoxWithSelectCounter comboBox = new();
-        comboBox.AddItems(expectedKeyPressesCount+1);
-        comboBox.CreateControl();
-        comboBox.SelectedIndex = selectedIndex;
-        comboBox.ResetEventsCount();
-
-        for (int i = 0; i < expectedKeyPressesCount; i++)
-        {
-            KeyboardSimulator.KeyPress(comboBox, key);
-        }
-
-        Assert.Equal(expectedKeyPressesCount, comboBox.EventsCount);
-    }
-
-    private void InitializeItems(ComboBox comboBox, int numItems)
-    {
-        for (int i = 0; i < numItems; i++)
-        {
-            comboBox.Items.Add($"item{i}");
-        }
-
-        Assert.Equal(numItems, comboBox.Items.Count);
-    }
-
-    private class OwnerDrawComboBox : ComboBox
-    {
-        public OwnerDrawComboBox()
-        {
-            DrawMode = DrawMode.OwnerDrawVariable;
-            FormattingEnabled = true;
-        }
-
-        public List<MeasureItemEventArgs> MeasureItemEventArgs { get; } = new List<MeasureItemEventArgs>();
-
-        protected override void OnMeasureItem(MeasureItemEventArgs e)
-        {
-            MeasureItemEventArgs.Add(e);
-        }
-    }
-
-    private class AutomationEventCountingComboBox : ComboBox
-    {
-        protected override AccessibleObject CreateAccessibilityInstance()
-            => new AutomationEventCountingComboBoxAccessibleObject(this);
-
-        public void OnKeyUp() => base.OnKeyUp(new KeyEventArgs(Keys.Left));
-
-        public void OnMouseDown(Point p) => base.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, p.X, p.Y, 0));
-    }
-
-    private class AutomationEventCountingComboBoxAccessibleObject : Control.ControlAccessibleObject
-    {
-        public AutomationEventCountingComboBoxAccessibleObject(ComboBox owner) : base(owner)
-        { }
-
-        internal int RaiseAutomationCallCount;
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UiaCore.UIA propertyId, object oldValue, object newValue)
-        {
-            RaiseAutomationCallCount++;
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-
-    private class AutomationEventCountingComboBoxChildEditUiaProvider : ComboBoxChildEditUiaProvider
-    {
-        public AutomationEventCountingComboBoxChildEditUiaProvider(ComboBox owner, IntPtr childEditControlhandle) : base(owner, childEditControlhandle)
-        {
-            RaiseAutomationCallCount = 0;
-        }
-
-        internal int RaiseAutomationCallCount;
-
-        internal override bool RaiseAutomationEvent(UiaCore.UIA eventId)
-        {
-            RaiseAutomationCallCount++;
-            return base.RaiseAutomationEvent(eventId);
-        }
-    }
-
-    private class SubComboBox : ComboBox
-    {
-        public SubComboBox()
-        { }
-
-        public SubComboBox(string text)
-        {
-            Text = text;
-        }
-
-        public new bool AllowSelection => base.AllowSelection;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new CurrencyManager DataManager => base.DataManager;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-#pragma warning disable 0618
-        public new void AddItemsCore(object[] value) => base.AddItemsCore(value);
-#pragma warning restore 0618
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public void ConfigureForCtrlBackspace(int cursorRelativeToEnd = 0)
-        {
-            Focus();
-            SelectionStart = this.Text.Length + cursorRelativeToEnd;
-            SelectionLength = 0;
-        }
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
-
-        public new void OnDropDown(EventArgs e) => base.OnDropDown(e);
-
-        public new void OnDropDownStyleChanged(EventArgs e) => base.OnDropDownStyleChanged(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnMeasureItem(MeasureItemEventArgs e) => base.OnMeasureItem(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnParentBackColorChanged(EventArgs e) => base.OnParentBackColorChanged(e);
-
-        public new void OnSelectedIndexChanged(EventArgs e) => base.OnSelectedIndexChanged(e);
-
-        public new void OnSelectedItemChanged(EventArgs e) => base.OnSelectedItemChanged(e);
-
-        public new void OnSelectedValueChanged(EventArgs e) => base.OnSelectedValueChanged(e);
-
-        public new void OnSelectionChangeCommitted(EventArgs e) => base.OnSelectionChangeCommitted(e);
-
-        public new bool ProcessCmdKey(ref Message msg, Keys keyData) => base.ProcessCmdKey(ref msg, keyData);
-
-        public new void ScaleControl(SizeF factor, BoundsSpecified specified) => base.ScaleControl(factor, specified);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class ComboBoxWithSelectCounter : ComboBox
-    {
-        public int EventsCount { get; private set; }
-
-        public void AddItems(int numToAdd)
-        {
-            for (int i = 0; i < numToAdd; i++)
-            {
-                Items.Add($"Item {i}");
-            }
-        }
-
-        protected override void OnSelectedIndexChanged(EventArgs e)
-        {
-            base.OnSelectedIndexChanged(e);
-            EventsCount++;
-        }
-
-        public void ResetEventsCount()
-        {
-            EventsCount = 0;
-        }
-    }
-
-    private class DataClass
-    {
-        public string Value { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Combobox.ObjectCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Combobox.ObjectCollectionTests.cs
deleted file mode 100644
index dd54e5c416b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Combobox.ObjectCollectionTests.cs
+++ /dev/null
@@ -1,1454 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Windows.Forms.IntegrationTests.Common;
-using static System.Windows.Forms.ComboBox;
-using static System.Windows.Forms.ComboBox.ObjectCollection;
-
-namespace System.Windows.Forms.Tests;
-
-public class ComboBox_ComboBoxObjectCollectionTests
-{
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Add_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        // Check Entry values
-        Assert.Equal("a", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Add_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        // Check Entry values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal(person2, comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Add_Invoke_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        int firstIndex = comboBoxObjectCollection.Add("a");
-        int secondIndex = comboBoxObjectCollection.Add("a");
-
-        Assert.Equal(0, firstIndex);
-        Assert.Equal(1, secondIndex);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Add_Invoke_NullItem_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentNullException>("item", () => comboBoxObjectCollection.Add(null));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Add_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Add("a"));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Add_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        comboBoxObjectCollection.Add("b");
-        comboBoxObjectCollection.Add("c");
-        comboBoxObjectCollection.Add("a");
-
-        // Check string values
-        Assert.Equal("a", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal("c", comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Add_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-
-        comboBoxObjectCollection.Add(person3);
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        // Check string values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal(person2, comboBoxObjectCollection[1]);
-        Assert.Equal(person3, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Add_ObjectAndString_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(3, "Name 3");
-
-        comboBoxObjectCollection.Add(person2);
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add("Name 2");
-
-        // Check string values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal("Name 2", comboBoxObjectCollection[1]);
-        Assert.Equal(person2, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Add_Invoke_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        int firstIndex = comboBoxObjectCollection.Add("c");
-        int secondIndex = comboBoxObjectCollection.Add("a");
-        int thirdIndex = comboBoxObjectCollection.Add("b");
-
-        Assert.Equal(0, firstIndex);
-        Assert.Equal(0, secondIndex);
-        Assert.Equal(1, thirdIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_AddRange_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.AddRange(new string[] { "a", "b" });
-
-        // Check string values
-        Assert.Equal("a", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_AddRange_Objects_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.AddRange(new Person[] { person1, person2, person3 });
-
-        // Check string values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal(person2, comboBoxObjectCollection[1]);
-        Assert.Equal(person3, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_AddRange_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        comboBoxObjectCollection.AddRange(new string[] { "c", "a", "b" });
-
-        // Check string values
-        Assert.Equal("a", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal("c", comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_AddRange_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-
-        comboBoxObjectCollection.AddRange(new Person[] { person3, person1, person2 });
-
-        // Check string values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal(person2, comboBoxObjectCollection[1]);
-        Assert.Equal(person3, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_AddRange_ObjectAndString_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(3, "Name 3");
-
-        comboBoxObjectCollection.AddRange(new object[] { "Name 2", person1, person2 });
-
-        // Check string values
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal("Name 2", comboBoxObjectCollection[1]);
-        Assert.Equal(person2, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_AddRange_Invoke_NullItems_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        Assert.Throws<ArgumentNullException>("items", () => comboBoxObjectCollection.AddRange(null));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_AddRange_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.AddRange(new string[] { "a", "b" }));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Clear_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.AddRange(new string[] { "c", "a", "b" });
-
-        Assert.Equal(3, comboBoxObjectCollection.Count);
-        Assert.Equal(3, comboBoxObjectCollection.InnerList.Count);
-
-        comboBoxObjectCollection.Clear();
-
-        Assert.Equal(0, comboBoxObjectCollection.Count);
-        Assert.Equal(0, comboBoxObjectCollection.InnerList.Count);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxObjectCollection_Clear_Invoke_ClearItemAccessibleObjects()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.CreateControl();
-        ObjectCollection comboBoxObjectCollection = comboBox.Items;
-        comboBoxObjectCollection.AddRange(new string[] { "a", "b" });
-        ComboBox.ComboBoxAccessibleObject accessibleObject = GetComboBoxAccessibleObject(comboBox);
-
-        // Adding ComboBoxItemAccessibleObject to the "ItemAccessibleObjects" list
-        ComboBoxItemAccessibleObject firstAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[0]);
-        ComboBoxItemAccessibleObject secondAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[1]);
-
-        Assert.Equal(2, comboBoxObjectCollection.InnerList.Count);
-        Assert.Equal(2, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBoxObjectCollection.Clear();
-
-        Assert.Equal(0, comboBoxObjectCollection.Count);
-        Assert.Equal(0, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Clear_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Clear());
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Contains_Invoke_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.AddRange(new string[] { "a", "b" });
-
-        Assert.True(comboBoxObjectCollection.Contains("a"));
-        Assert.True(comboBoxObjectCollection.Contains("b"));
-        Assert.False(comboBoxObjectCollection.Contains("c"));
-
-        Assert.True(comboBoxObjectCollection.Contains(comboBoxObjectCollection.InnerList[0]));
-        Assert.True(comboBoxObjectCollection.Contains(comboBoxObjectCollection.InnerList[1]));
-        Assert.False(comboBoxObjectCollection.Contains(new Entry("a")));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Contains_Object_Invoke_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-
-        comboBoxObjectCollection.AddRange(new object[] { person1, person2 });
-
-        Assert.True(comboBoxObjectCollection.Contains(person1));
-        Assert.True(comboBoxObjectCollection.Contains(person2));
-        Assert.False(comboBoxObjectCollection.Contains(person3));
-
-        Assert.True(comboBoxObjectCollection.Contains(comboBoxObjectCollection.InnerList[0]));
-        Assert.True(comboBoxObjectCollection.Contains(comboBoxObjectCollection.InnerList[1]));
-        Assert.False(comboBoxObjectCollection.Contains(new Entry(person3)));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_CopyTo_Invoke_NullArray_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentNullException>("destination", () => comboBoxObjectCollection.CopyTo(null, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_CopyTo_Invoke_NegativeIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("arrayIndex", () => comboBoxObjectCollection.CopyTo(new object[1], -1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_CopyTo_Invoke_TooMoreIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("arrayIndex", () => comboBoxObjectCollection.CopyTo(new object[1], 3));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_CopyTo_InvokeEmpty_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        object[] array = new object[] { "1", "2", "3" };
-
-        comboBoxObjectCollection.CopyTo(array, 1);
-
-        Assert.Equal(new object[] { "1", "2", "3" }, array);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_CopyTo_InvokeNotEmpty_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add(1);
-        comboBoxObjectCollection.Add(2);
-        object[] array = new object[] { "1", "2", "3" };
-
-        comboBoxObjectCollection.CopyTo(array, 1);
-
-        Assert.Equal(new object[] { "1", 1, 2 }, array);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.Insert(0, "c");
-
-        Assert.Equal("c", comboBoxObjectCollection[0]);
-        Assert.Equal("a", comboBoxObjectCollection[1]);
-        Assert.Equal("b", comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        comboBoxObjectCollection.Insert(0, person3);
-
-        Assert.Equal(person3, comboBoxObjectCollection[0]);
-        Assert.Equal(person1, comboBoxObjectCollection[1]);
-        Assert.Equal(person2, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Insert_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.Insert(0, "c");
-
-        Assert.Equal("a", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal("c", comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Insert_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        comboBoxObjectCollection.Insert(0, person3);
-
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal(person2, comboBoxObjectCollection[1]);
-        Assert.Equal(person3, comboBoxObjectCollection[2]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Sorted_Insert_ObjectAndString_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DisplayMember = TestDataSources.PersonDisplayMember
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        comboBox.Sorted = true;
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add("Name 2");
-
-        comboBoxObjectCollection.Insert(0, person2);
-        comboBoxObjectCollection.Insert(0, "Name 4");
-
-        Assert.Equal(person1, comboBoxObjectCollection[0]);
-        Assert.Equal("Name 2", comboBoxObjectCollection[1]);
-        Assert.Equal(person2, comboBoxObjectCollection[2]);
-        Assert.Equal("Name 4", comboBoxObjectCollection[3]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Invoke_NullItem_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentNullException>("item", () => comboBoxObjectCollection.Insert(0, null));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Invoke_NegativeIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.Insert(-1, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Invoke_TooMoreIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.Insert(3, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Insert_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Insert(3, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_RemoveAt_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.RemoveAt(0);
-
-        Assert.Equal(1, comboBoxObjectCollection.Count);
-        Assert.Equal("b", comboBoxObjectCollection[0]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxObjectCollection_RemoveAt_Invoke_RemoveItemAccessibleObject()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.CreateControl();
-
-        comboBox.CreateControl();
-        ObjectCollection comboBoxObjectCollection = comboBox.Items;
-        comboBoxObjectCollection.Add("a");
-        ComboBox.ComboBoxAccessibleObject accessibleObject = GetComboBoxAccessibleObject(comboBox);
-
-        // Adding ComboBoxItemAccessibleObject to the "ItemAccessibleObjects" list
-        ComboBoxItemAccessibleObject firstAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[0]);
-        Assert.Equal(1, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBoxObjectCollection.RemoveAt(0);
-
-        Assert.Equal(0, comboBoxObjectCollection.Count);
-        Assert.Equal(0, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_RemoveAt_Invoke_NegativeIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.RemoveAt(-1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_RemoveAt_Invoke_TooMoreIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.RemoveAt(3));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_RemoveAt_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.RemoveAt(0));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Remove_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.Remove("a");
-
-        Assert.Equal(1, comboBoxObjectCollection.Count);
-        Assert.Equal("b", comboBoxObjectCollection[0]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Remove_Invoke_NonExistingItem_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.Remove("c");
-
-        Assert.Equal(2, comboBoxObjectCollection.Count);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Remove_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        // Remove non-existing object
-        comboBoxObjectCollection.Remove(person3);
-
-        Assert.Equal(2, comboBoxObjectCollection.Count);
-
-        // Remove existing object
-        comboBoxObjectCollection.Remove(person1);
-
-        Assert.Equal(1, comboBoxObjectCollection.Count);
-        Assert.Equal(person2, comboBoxObjectCollection[0]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Remove_Entry_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        comboBoxObjectCollection.Remove(comboBoxObjectCollection[0]);
-
-        Assert.Equal(1, comboBoxObjectCollection.Count);
-        Assert.Equal("b", comboBoxObjectCollection[0]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxObjectCollection_Remove_Invoke_RemoveItemAccessibleObject()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.CreateControl();
-
-        comboBox.CreateControl();
-        ObjectCollection comboBoxObjectCollection = comboBox.Items;
-        comboBoxObjectCollection.Add("a");
-        ComboBox.ComboBoxAccessibleObject accessibleObject = GetComboBoxAccessibleObject(comboBox);
-
-        // Adding ComboBoxItemAccessibleObject to the "ItemAccessibleObjects" list
-        ComboBoxItemAccessibleObject firstAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[0]);
-        Assert.Equal(1, accessibleObject.ItemAccessibleObjects.Count);
-
-        comboBoxObjectCollection.Remove("a");
-
-        Assert.Equal(0, comboBoxObjectCollection.Count);
-        Assert.Equal(0, accessibleObject.ItemAccessibleObjects.Count);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_Remove_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBox.DataSource = new string[] { "b" };
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection.Remove("a"));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItemInternal_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-        comboBoxObjectCollection.SetItemInternal(0, "c");
-        comboBoxObjectCollection.SetItemInternal(1, "b");
-
-        Assert.Equal("c", comboBoxObjectCollection[0]);
-        Assert.Equal("b", comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItemInternal_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-        comboBoxObjectCollection.SetItemInternal(0, person3);
-        comboBoxObjectCollection.SetItemInternal(1, "Name 4");
-
-        Assert.Equal(person3, comboBoxObjectCollection[0]);
-        Assert.Equal("Name 4", comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItemInternal_Invoke_NullItem_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-
-        Assert.Throws<ArgumentNullException>("value", () => comboBoxObjectCollection.SetItemInternal(0, null));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItemInternal_Invoke_NegativeIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.SetItemInternal(-1, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItemInternal_Invoke_TooMoreIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection.SetItemInternal(3, 1));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_IndexOf_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection.Add("b");
-
-        Assert.Equal(0, comboBoxObjectCollection.IndexOf("a"));
-        Assert.Equal(1, comboBoxObjectCollection.IndexOf("b"));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf("c"));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf(null));
-
-        Assert.Equal(0, comboBoxObjectCollection.IndexOf(comboBoxObjectCollection[0]));
-        Assert.Equal(1, comboBoxObjectCollection.IndexOf(comboBoxObjectCollection[1]));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf(new Entry("a")));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_IndexOf_Object_ReturnExpected(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-
-        Assert.Equal(0, comboBoxObjectCollection.IndexOf(person1));
-        Assert.Equal(1, comboBoxObjectCollection.IndexOf(person2));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf(person3));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf("Name 1"));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf("Name 2"));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf(null));
-
-        Assert.Equal(0, comboBoxObjectCollection.IndexOf(comboBoxObjectCollection[0]));
-        Assert.Equal(1, comboBoxObjectCollection.IndexOf(comboBoxObjectCollection[1]));
-        Assert.Equal(-1, comboBoxObjectCollection.IndexOf(new Entry(person1)));
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBoxObjectCollection[0] = "b";
-
-        Assert.Equal("b", comboBoxObjectCollection[0]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Object_Invoke_Success(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        var person1 = new Person(1, "Name 1");
-        var person2 = new Person(2, "Name 2");
-        var person3 = new Person(3, "Name 3");
-        comboBoxObjectCollection.Add(person1);
-        comboBoxObjectCollection.Add(person2);
-        comboBoxObjectCollection[0] = person3;
-        comboBoxObjectCollection[1] = "Name 4";
-
-        Assert.Equal(person3, comboBoxObjectCollection[0]);
-        Assert.Equal("Name 4", comboBoxObjectCollection[1]);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBoxObjectCollection_SetItem_DoesNotAffect_ItemsAccessibleObject()
-    {
-        using ComboBox comboBox = new ComboBox();
-        comboBox.CreateControl();
-        ComboBox.ComboBoxAccessibleObject accessibleObject = GetComboBoxAccessibleObject(comboBox);
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        ComboBoxItemAccessibleObject oldAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[0]);
-        comboBoxObjectCollection[0] = "b";
-        ComboBoxItemAccessibleObject newAccessibleObjectItem = accessibleObject.ItemAccessibleObjects.GetComboBoxItemAccessibleObject(comboBoxObjectCollection.InnerList[0]);
-
-        Assert.Equal(oldAccessibleObjectItem, newAccessibleObjectItem);
-        Assert.True(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Invoke_NullItem_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        Assert.Throws<ArgumentNullException>("value", () => comboBoxObjectCollection[0] = null);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Invoke_NegativeIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection[-1] = 1);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Invoke_TooMoreIndex_ThrowsArgumentNullException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => comboBoxObjectCollection[3] = 1);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_SetItem_Invoke_DataSourceExists_ThrowsArgumentException(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        comboBoxObjectCollection.Add("a");
-        comboBox.DataSource = new string[] { "b" };
-
-        Assert.Throws<ArgumentException>(() => comboBoxObjectCollection[0] = 1);
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_GetEnumerator_Invoke_Empty(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection collection = new ObjectCollection(comboBox);
-        IEnumerator enumerator = collection.GetEnumerator();
-
-        ObjectCollection comboBoxObjectCollection = new ObjectCollection(comboBox);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ComboBoxObjectCollection_GetEnumerator_Invoke_NotEmpty(bool createControl)
-    {
-        using ComboBox comboBox = new ComboBox();
-        if (createControl)
-        {
-            comboBox.CreateControl();
-        }
-
-        ObjectCollection collection = new ObjectCollection(comboBox);
-        collection.Add(2);
-        IEnumerator enumerator = collection.GetEnumerator();
-
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(2, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-
-        Assert.Equal(createControl, comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Item_RemoveAt_DoesNotCreateAccessibilityObject()
-    {
-        using ComboBox comboBox = new();
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.Items.Remove(1);
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Item_Insert_DoesNotCreateAccessibilityObject()
-    {
-        using ComboBox comboBox = new();
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.Items.Insert(1, "Item3");
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComboBox_Item_Clear_DoesNotCreateAccessibilityObject()
-    {
-        using ComboBox comboBox = new();
-
-        comboBox.Items.Add("item1");
-        comboBox.Items.Add("item2");
-        comboBox.Items.Clear();
-
-        Assert.False(comboBox.IsAccessibilityObjectCreated);
-        Assert.False(comboBox.IsHandleCreated);
-    }
-
-    private ComboBox.ComboBoxAccessibleObject GetComboBoxAccessibleObject(ComboBox comboBox)
-    {
-        return (ComboBox.ComboBoxAccessibleObject)comboBox.AccessibilityObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CommonDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CommonDialogTests.cs
deleted file mode 100644
index 2c05a19dfcd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CommonDialogTests.cs
+++ /dev/null
@@ -1,295 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Reflection;
-using Microsoft.DotNet.RemoteExecutor;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class CommonDialogTests
-{
-    [WinFormsFact]
-    public void Ctor_Default()
-    {
-        using var dialog = new SubCommonDialog();
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.Null(dialog.Container);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Tag_Set_GetReturnsExpected(object value)
-    {
-        using var dialog = new SubCommonDialog()
-        {
-            Tag = value
-        };
-        Assert.Same(value, dialog.Tag);
-
-        // Set same.
-        dialog.Tag = value;
-        Assert.Same(value, dialog.Tag);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void OnHelpRequest_Invoke_CallsHelpRequest(EventArgs eventArgs)
-    {
-        using var dialog = new SubCommonDialog();
-
-        // No handler.
-        dialog.OnHelpRequest(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(dialog, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        dialog.HelpRequest += handler;
-        dialog.OnHelpRequest(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        dialog.HelpRequest -= handler;
-        dialog.OnHelpRequest(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> HookProc_TestData()
-    {
-        yield return new object[] { PInvoke.WM_INITDIALOG };
-        yield return new object[] { PInvoke.WM_SETFOCUS };
-
-        const int CDM_SETDEFAULTFOCUS = (int)PInvoke.WM_USER + 0x51;
-        yield return new object[] { CDM_SETDEFAULTFOCUS };
-
-        yield return new object[] { 0 };
-        yield return new object[] { -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HookProc_TestData))]
-    public void HookProc_Invoke_ReturnsZero(int msg)
-    {
-        using var dialog = new SubCommonDialog();
-        Assert.Equal(IntPtr.Zero, dialog.HookProc(IntPtr.Zero, msg, IntPtr.Zero, IntPtr.Zero));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_NoOwner_ReturnsExpected(bool runDialogResult, DialogResult expectedDialogResult)
-    {
-        using var dialog = new SubCommonDialog
-        {
-            RunDialogResult = runDialogResult
-        };
-        Assert.Equal(expectedDialogResult, dialog.ShowDialog());
-        Assert.Equal(expectedDialogResult, dialog.ShowDialog(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_NonControlOwner_ReturnsExpected(bool runDialogResult, DialogResult expectedDialogResult)
-    {
-        using var dialog = new SubCommonDialog
-        {
-            RunDialogResult = runDialogResult
-        };
-        var owner = new Mock<IWin32Window>(MockBehavior.Strict);
-        owner
-            .Setup(o => o.Handle)
-            .Returns(IntPtr.Zero);
-        Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner.Object));
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_NonControlOwnerWithVisualStyles_ReturnsExpected(bool runDialogResultParam, DialogResult expectedDialogResultParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((runDialogResultString, expectedDialogResultString) =>
-        {
-            bool runDialogResult = bool.Parse(runDialogResultString);
-            DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString);
-
-            Application.EnableVisualStyles();
-
-            using var dialog = new SubCommonDialog
-            {
-                RunDialogResult = runDialogResult
-            };
-            var owner = new Mock<IWin32Window>(MockBehavior.Strict);
-            owner
-                .Setup(o => o.Handle)
-                .Returns(IntPtr.Zero);
-            Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner.Object));
-        }, runDialogResultParam.ToString(), expectedDialogResultParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_ControlOwner_ReturnsExpected(bool runDialogResult, DialogResult expectedDialogResult)
-    {
-        using var dialog = new SubCommonDialog
-        {
-            RunDialogResult = runDialogResult
-        };
-        using var owner = new Control();
-        Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner));
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_ControlOwnerWithVisualStyles_ReturnsExpected(bool runDialogResultParam, DialogResult expectedDialogResultParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((runDialogResultString, expectedDialogResultString) =>
-        {
-            bool runDialogResult = bool.Parse(runDialogResultString);
-            DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString);
-
-            Application.EnableVisualStyles();
-
-            using var dialog = new SubCommonDialog
-            {
-                RunDialogResult = runDialogResult
-            };
-            using var owner = new Control();
-            Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner));
-        }, runDialogResultParam.ToString(), expectedDialogResultParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_ControlOwnerWithHandle_ReturnsExpected(bool runDialogResult, DialogResult expectedDialogResult)
-    {
-        using var dialog = new SubCommonDialog
-        {
-            RunDialogResult = runDialogResult
-        };
-        using var owner = new Control();
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner));
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(true, DialogResult.OK)]
-    [InlineData(false, DialogResult.Cancel)]
-    public void ShowDialog_ControlOwnerWithHandleWithVisualStyles_ReturnsExpected(bool runDialogResultParam, DialogResult expectedDialogResultParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((runDialogResultString, expectedDialogResultString) =>
-        {
-            bool runDialogResult = bool.Parse(runDialogResultString);
-            DialogResult expectedDialogResult = (DialogResult)Enum.Parse(typeof(DialogResult), expectedDialogResultString);
-
-            Application.EnableVisualStyles();
-
-            using var dialog = new SubCommonDialog
-            {
-                RunDialogResult = runDialogResult
-            };
-            using var owner = new Control();
-            Assert.NotEqual(IntPtr.Zero, owner.Handle);
-            Assert.Equal(expectedDialogResult, dialog.ShowDialog(owner));
-        }, runDialogResultParam.ToString(), expectedDialogResultParam.ToString()).Dispose();
-    }
-
-    [WinFormsFact]
-    public void ShowDialog_NonControlOwnerWithHandle_ThrowsWin32Exception()
-    {
-        using var dialog = new SubCommonDialog();
-        var owner = new Mock<IWin32Window>(MockBehavior.Strict);
-        owner
-            .Setup(o => o.Handle)
-            .Returns((IntPtr)1);
-        Assert.Throws<Win32Exception>(() => dialog.ShowDialog(owner.Object));
-    }
-
-    [WinFormsFact]
-    public void OwnerWndProc_HelpMessage_CallsHelpRequest()
-    {
-        using var dialog = new SubCommonDialog();
-        FieldInfo field = typeof(CommonDialog).GetField("s_helpMessage", BindingFlags.NonPublic | BindingFlags.Static);
-        Assert.NotNull(field);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(dialog, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        dialog.HelpRequest += handler;
-        Assert.Equal(IntPtr.Zero, dialog.OwnerWndProc(IntPtr.Zero, (int)(MessageId)field.GetValue(null), IntPtr.Zero, IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void OwnerWndProc_NonHelpMessage_DoesNotCallHelpRequest()
-    {
-        using var dialog = new SubCommonDialog();
-        FieldInfo field = typeof(CommonDialog).GetField("s_helpMessage", BindingFlags.NonPublic | BindingFlags.Static);
-        Assert.NotNull(field);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(dialog, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        dialog.HelpRequest += handler;
-        Assert.Equal(IntPtr.Zero, dialog.OwnerWndProc(IntPtr.Zero, (int)(MessageId)field.GetValue(null) + 1, IntPtr.Zero, IntPtr.Zero));
-        Assert.Equal(0, callCount);
-    }
-
-    private class SubCommonDialog : CommonDialog
-    {
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-
-        public override void Reset()
-        {
-        }
-
-        public bool RunDialogResult { get; set; }
-
-        protected override bool RunDialog(IntPtr hwndOwner) => RunDialogResult;
-
-        public new void OnHelpRequest(EventArgs e) => base.OnHelpRequest(e);
-
-        public new IntPtr HookProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
-        {
-            return base.HookProc(hWnd, msg, wparam, lparam);
-        }
-
-        public new IntPtr OwnerWndProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
-        {
-            return base.OwnerWndProc(hWnd, msg, wparam, lparam);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2FontConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2FontConverterTests.cs
deleted file mode 100644
index 8bfcd6acf97..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2FontConverterTests.cs
+++ /dev/null
@@ -1,165 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.ComponentModel.Com2Interop;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-
-namespace System.Windows.Forms.Tests.ComponentModel.Com2Interop;
-
-public unsafe class COM2FontConverterTests
-{
-    private static readonly Com2PropertyDescriptor s_stubDescriptor = new(
-        default,
-        "Foo",
-        Array.Empty<Attribute>(),
-        default,
-        default,
-        default,
-        default);
-
-    [Fact]
-    public void COM2FontConverter_ConvertNativeToManaged()
-    {
-        fixed (char* n = "Arial")
-        {
-            FONTDESC fontDesc = new()
-            {
-                cbSizeofstruct = (uint)sizeof(FONTDESC),
-                lpstrName = n,
-                cySize = (CY)12.0f
-            };
-
-            using ComScope<IFont> iFont = new(null);
-            PInvoke.OleCreateFontIndirect(&fontDesc, IID.Get<IFont>(), iFont).ThrowOnFailure();
-
-            Com2FontConverter converter = new();
-            using Font? font = (Font?)converter.ConvertNativeToManaged((VARIANT)(IUnknown*)iFont, s_stubDescriptor);
-            Assert.NotNull(font);
-
-            // Converter might have failed and returned DefaultFont.
-            Assert.NotEqual(font, Control.DefaultFont);
-
-            Assert.Equal("Arial", font.Name);
-            Assert.Equal(12, font.Size);
-
-            bool cancelSet = false;
-            using VARIANT result = converter.ConvertManagedToNative(font, s_stubDescriptor, ref cancelSet);
-            Assert.True(result.IsEmpty);
-            Assert.True(cancelSet);
-        }
-    }
-
-    [Fact]
-    public void COM2FontConverter_ConvertManagedToNative()
-    {
-        fixed (char* n = "Arial")
-        {
-            FONTDESC fontDesc = new()
-            {
-                cbSizeofstruct = (uint)sizeof(FONTDESC),
-                lpstrName = n,
-                cySize = (CY)12.0f
-            };
-
-            using ComScope<IFont> iFont = new(null);
-            PInvoke.OleCreateFontIndirect(&fontDesc, IID.Get<IFont>(), iFont).ThrowOnFailure();
-
-            Com2FontConverter converter = new();
-            using Font? font = (Font?)converter.ConvertNativeToManaged((VARIANT)(IUnknown*)iFont, s_stubDescriptor);
-            Assert.NotNull(font);
-
-            using Font newFont = new(font.Name, 20.0f);
-
-            bool cancelSet = false;
-
-            // Need to addref here as ConvertManagedToNative will release the VARIANT we cast to below.
-            iFont.Value->AddRef();
-
-            using VARIANT result = converter.ConvertManagedToNative(
-                newFont,
-                new CustomGetNativeValueDescriptor((VARIANT)(IUnknown*)iFont.Value),
-                ref cancelSet);
-
-            Assert.True(cancelSet);
-            Assert.True(result.IsEmpty);
-            Assert.Equal("Arial", iFont.Value->Name.ToStringAndFree());
-            Assert.Equal(20.0f, (float)iFont.Value->Size, precision: 0);
-        }
-    }
-
-    private class CustomGetNativeValueDescriptor : Com2PropertyDescriptor
-    {
-        private ICustomTypeDescriptor _descriptor;
-
-        public CustomGetNativeValueDescriptor(VARIANT nativeValue)
-            : base(default, "Foo", Array.Empty<Attribute>(), default, default, default, default)
-        {
-            _descriptor = new CustomDescriptor(nativeValue);
-        }
-
-        public override object TargetObject => _descriptor;
-
-        private class CustomDescriptor : ICustomTypeDescriptor
-        {
-            private readonly object _propertyOwner;
-
-            public CustomDescriptor(VARIANT variant) => _propertyOwner = new DispatchStub(variant);
-
-            public AttributeCollection GetAttributes() => throw new NotImplementedException();
-
-            public string? GetClassName() => throw new NotImplementedException();
-
-            public string? GetComponentName() => throw new NotImplementedException();
-
-            public TypeConverter? GetConverter() => throw new NotImplementedException();
-
-            public EventDescriptor? GetDefaultEvent() => throw new NotImplementedException();
-
-            public PropertyDescriptor? GetDefaultProperty() => throw new NotImplementedException();
-
-            public object? GetEditor(Type editorBaseType) => throw new NotImplementedException();
-
-            public EventDescriptorCollection GetEvents() => throw new NotImplementedException();
-
-            public EventDescriptorCollection GetEvents(Attribute[]? attributes) => throw new NotImplementedException();
-
-            public PropertyDescriptorCollection GetProperties() => throw new NotImplementedException();
-
-            public PropertyDescriptorCollection GetProperties(Attribute[]? attributes) => throw new NotImplementedException();
-
-            public object? GetPropertyOwner(PropertyDescriptor? pd) => _propertyOwner;
-
-            private class DispatchStub : IDispatch.Interface, IManagedWrapper<IDispatch>
-            {
-                private readonly VARIANT _variant;
-                public DispatchStub(VARIANT variant) => _variant = variant;
-
-                HRESULT IDispatch.Interface.GetTypeInfoCount(uint* pctinfo) => throw new NotImplementedException();
-
-                HRESULT IDispatch.Interface.GetTypeInfo(uint iTInfo, uint lcid, ITypeInfo** ppTInfo) => throw new NotImplementedException();
-
-                HRESULT IDispatch.Interface.GetIDsOfNames(Guid* riid, PWSTR* rgszNames, uint cNames, uint lcid, int* rgDispId) => throw new NotImplementedException();
-
-                HRESULT IDispatch.Interface.Invoke(
-                    int dispIdMember,
-                    Guid* riid,
-                    uint lcid,
-                    DISPATCH_FLAGS dwFlags,
-                    DISPPARAMS* pDispParams,
-                    VARIANT* pVarResult,
-                    EXCEPINFO* pExcepInfo,
-                    uint* pArgErr)
-                {
-                    *pVarResult = _variant;
-                    return HRESULT.S_OK;
-                }
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2PictureConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2PictureConverterTests.cs
deleted file mode 100644
index 4e6eb336913..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/COM2PictureConverterTests.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.ComponentModel.Com2Interop;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-
-namespace System.Windows.Forms.Tests.ComponentModel.Com2Interop;
-
-// NB: doesn't require thread affinity
-public unsafe class COM2PictureConverterTests
-{
-    private static Com2PictureConverter Instance { get; } = new Com2PictureConverter(new Com2PropertyDescriptor(
-        default,
-        "Foo",
-        default,
-        default,
-        default,
-        default,
-        default));
-
-    [Fact]
-    public void ConvertNativeToManaged_Null()
-    {
-        Assert.Null(Instance.ConvertNativeToManaged(default, null));
-    }
-
-    private unsafe class TestIPicture : IPictureMock
-    {
-        private nint _handle;
-        private PICTYPE _type;
-
-        public TestIPicture(nint handle, PICTYPE type = PICTYPE.PICTYPE_NONE)
-        {
-            _handle = handle;
-            _type = type;
-        }
-
-        public override OLE_HANDLE Handle => new((uint)(int)_handle);
-
-        public override PICTYPE Type => _type;
-    }
-
-    [Fact]
-    public void ConvertNativeToManaged_NullHandle()
-    {
-        TestIPicture nullIPicture = new(0);
-        using var unknown = ComHelpers.GetComScope<IUnknown>(nullIPicture);
-        Assert.Null(Instance.ConvertNativeToManaged((VARIANT)unknown.Value, null));
-    }
-
-    [Fact]
-    public unsafe void ConvertNativeToManaged_Icon()
-    {
-        Icon errorIcon = SystemIcons.Error;
-        nint handle = errorIcon.Handle;
-        TestIPicture iconIPicture = new(handle, PICTYPE.PICTYPE_ICON);
-        using var unknown = ComHelpers.GetComScope<IUnknown>(iconIPicture);
-
-        using Icon icon = (Icon)Instance.ConvertNativeToManaged((VARIANT)unknown.Value, null);
-
-        Assert.Equal(icon.Height, errorIcon.Height);
-        Assert.Equal(icon.Width, errorIcon.Width);
-        Assert.Equal(typeof(Icon), Instance.ManagedType);
-
-        // We should get the cached object if the handle didn't change
-        Assert.Same(icon, (Icon)Instance.ConvertNativeToManaged((VARIANT)unknown.Value, null));
-    }
-
-    [Fact]
-    public void ConvertNativeToManaged_Bitmap()
-    {
-        Icon errorIcon = SystemIcons.Error;
-        using Bitmap errorBitmap = errorIcon.ToBitmap();
-        nint hBitmap = errorBitmap.GetHbitmap();
-        TestIPicture bitmapIPicture = new(hBitmap, PICTYPE.PICTYPE_BITMAP);
-        try
-        {
-            using var unknown = ComHelpers.GetComScope<IUnknown>(bitmapIPicture);
-            using Bitmap bitmap = (Bitmap)Instance.ConvertNativeToManaged((VARIANT)unknown.Value, property: null);
-
-            Assert.Equal(bitmap.Height, errorIcon.Height);
-            Assert.Equal(bitmap.Width, errorIcon.Width);
-            Assert.Equal(typeof(Bitmap), Instance.ManagedType);
-
-            // We should get the cached object if the handle didn't change
-            Assert.Same(bitmap, (Bitmap)Instance.ConvertNativeToManaged((VARIANT)unknown.Value, property: null));
-        }
-        finally
-        {
-            PInvoke.DeleteObject((HGDIOBJ)hBitmap);
-        }
-    }
-
-    [Fact]
-    public void ConvertNativeToManaged_UnsupportedPICTYPE()
-    {
-        // The converter asserts, but doesn't throw. Suppress asserts so that we can validate it returns null as expected.
-        using (new NoAssertContext())
-        {
-            using var unknown = ComHelpers.GetComScope<IUnknown>(new TestIPicture(1, PICTYPE.PICTYPE_METAFILE));
-            Assert.Null(Instance.ConvertNativeToManaged((VARIANT)unknown.Value, null));
-        }
-    }
-
-    [Fact]
-    public void ConvertManagedToNative_NullObject()
-    {
-        bool cancelSet = true;
-        Assert.True(Instance.ConvertManagedToNative(null, null, ref cancelSet).IsEmpty);
-        Assert.False(cancelSet);
-    }
-
-    [StaFact]
-    public unsafe void ConvertManagedToNative_Icon()
-    {
-        bool cancelSet = true;
-        Icon exclamationIcon = SystemIcons.Exclamation;
-
-        using VARIANT native = Instance.ConvertManagedToNative(exclamationIcon, null, ref cancelSet);
-        using ComScope<IPicture> picture = ComScope<IPicture>.QueryFrom((IUnknown*)native);
-
-        Assert.False(cancelSet);
-        int height = picture.Value->Height;
-        int width = picture.Value->Width;
-        Assert.Equal(PICTYPE.PICTYPE_ICON, picture.Value->Type);
-        Assert.Equal(exclamationIcon.Height, GdiHelper.HimetricToPixelY(height));
-        Assert.Equal(exclamationIcon.Width, GdiHelper.HimetricToPixelX(width));
-
-        // And we should also round trip to the same value
-        Assert.Same(exclamationIcon, Instance.ConvertNativeToManaged((VARIANT)picture.AsUnknown, null));
-    }
-
-    [StaFact]
-    public unsafe void ConvertManagedToNative_Bitmap()
-    {
-        bool cancelSet = true;
-        using Bitmap bitmap = new Bitmap(42, 70);
-
-        using VARIANT native = Instance.ConvertManagedToNative(bitmap, null, ref cancelSet);
-        using ComScope<IPicture> picture = ComScope<IPicture>.QueryFrom((IUnknown*)native);
-
-        Assert.False(cancelSet);
-        int height = picture.Value->Height;
-        int width = picture.Value->Width;
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, picture.Value->Type);
-        Assert.Equal(bitmap.Height, GdiHelper.HimetricToPixelY(height));
-        Assert.Equal(bitmap.Width, GdiHelper.HimetricToPixelX(width));
-
-        // And we should also round trip to the same value
-        Assert.Same(bitmap, Instance.ConvertNativeToManaged((VARIANT)picture.AsUnknown, null));
-    }
-
-    [Fact]
-    public void ConvertManagedToNative_UnknownObjectType()
-    {
-        // The converter asserts, but doesn't throw. Suppress asserts so
-        // that we can validate it returns null as expected.
-        using (new NoAssertContext())
-        {
-            bool cancelSet = true;
-            Assert.True(Instance.ConvertManagedToNative(new object(), null, ref cancelSet).IsEmpty);
-            Assert.False(cancelSet);
-        }
-    }
-
-    private unsafe class IPictureMock : IPicture.Interface, IManagedWrapper<IPicture>
-    {
-        public virtual HRESULT Render(HDC hDC, int x, int y, int cx, int cy, int xSrc, int ySrc, int cxSrc, int cySrc, RECT* pRcWBounds)
-            => HRESULT.S_OK;
-
-        public virtual HRESULT PictureChanged() => HRESULT.S_OK;
-
-        public virtual HRESULT SaveAsFile(IStream* pStream, BOOL fSaveMemCopy, int* pCbSize) => HRESULT.S_OK;
-
-        public virtual OLE_HANDLE Handle => default;
-
-        public virtual HRESULT get_hPal(OLE_HANDLE* phPal) => HRESULT.S_OK;
-
-        public virtual PICTYPE Type => default;
-
-        public virtual int Width => default;
-
-        public virtual int Height => default;
-
-        public virtual HRESULT set_hPal(OLE_HANDLE hPal) => HRESULT.S_OK;
-
-        public HDC CurDC => default;
-
-        public virtual HRESULT SelectPicture(HDC hDCIn, HDC* phDCOut, OLE_HANDLE* phBmpOut) => HRESULT.S_OK;
-
-        public virtual BOOL KeepOriginalFormat { get => default; set { } }
-
-        public virtual uint Attributes => default;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/Com2PropertyDescriptorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/Com2PropertyDescriptorTests.cs
deleted file mode 100644
index 0122d76da8d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/Com2PropertyDescriptorTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-
-namespace System.Windows.Forms.ComponentModel.Com2Interop.Tests;
-
-// NB: doesn't require thread affinity
-public class Com2PropertyDescriptorTests
-{
-    private static MethodInfo s_miVersionInfo;
-    private static Type s_typeCom2PropertyDescriptor;
-
-    static Com2PropertyDescriptorTests()
-    {
-        s_typeCom2PropertyDescriptor = typeof(Com2PropertyDescriptor);
-        s_miVersionInfo = s_typeCom2PropertyDescriptor.GetMethod("TrimNewline", BindingFlags.Static | BindingFlags.NonPublic);
-        Assert.NotNull(s_miVersionInfo);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/ComNativeDescriptorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/ComNativeDescriptorTests.cs
deleted file mode 100644
index 95ee7b983ef..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ComponentModel/Com2Interop/ComNativeDescriptorTests.cs
+++ /dev/null
@@ -1,357 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.Tests.TestResources;
-using Windows.Win32.System.Com;
-using Windows.Win32.System.Ole;
-using Windows.Win32.System.Variant;
-using Windows.Win32.UI.Accessibility;
-using WMPLib;
-using static Interop;
-
-namespace System.Windows.Forms.ComponentModel.Com2Interop.Tests;
-
-public unsafe class ComNativeDescriptorTests
-{
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_FromIPictureDisp_ComInterop()
-    {
-        using Bitmap bitmap = new(10, 20);
-        object iPictureDisp = IPictureDisp.CreateObjectFromImage(bitmap);
-        Assert.NotNull(iPictureDisp);
-
-        ValidateIPictureDispProperties(iPictureDisp, TypeDescriptor.GetProperties(iPictureDisp));
-    }
-
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_FromIPictureDisp_ComWrappers()
-    {
-        using Bitmap bitmap = new(10, 20);
-        using var iPictureDisp = IPictureDisp.CreateFromImage(bitmap);
-        Assert.False(iPictureDisp.IsNull);
-
-        // The runtime needs to be updated to allow ComWrappers through
-        ComNativeDescriptor descriptor = new();
-        object comWrapper = UnknownComWrappers.Instance.GetOrCreateObjectForComInstance(iPictureDisp, CreateObjectFlags.None);
-        ValidateIPictureDispProperties(comWrapper, descriptor.GetProperties(comWrapper));
-    }
-
-    private static void ValidateIPictureDispProperties(object iPictureDisp, PropertyDescriptorCollection properties)
-    {
-        Assert.NotNull(properties);
-        Assert.Equal(5, properties.Count);
-
-        var handleProperty = properties["Handle"];
-        Assert.IsType<Com2PropertyDescriptor>(handleProperty);
-        Assert.True(handleProperty.IsReadOnly);
-        Assert.Equal("Misc", handleProperty.Category);
-        Assert.False(handleProperty.IsLocalizable);
-        Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", handleProperty.ComponentType.FullName);
-
-        // OLE_HANDLE
-        Assert.Equal("System.Int32", handleProperty.PropertyType.FullName);
-
-        Assert.Equal(DesignerSerializationVisibility.Visible, handleProperty.SerializationVisibility);
-        Assert.False(handleProperty.CanResetValue(iPictureDisp));
-        Assert.False(handleProperty.ShouldSerializeValue(iPictureDisp));
-        Assert.NotEqual(0, handleProperty.GetValue(iPictureDisp));
-
-        var converter = (Com2ExtendedTypeConverter)handleProperty.Converter;
-        Assert.IsAssignableFrom<Int32Converter>(converter.InnerConverter);
-
-        var typeProperty = properties["Type"];
-        Assert.NotNull(typeProperty);
-        Assert.True(typeProperty.IsReadOnly);
-        Assert.Equal("Misc", typeProperty.Category);
-        Assert.False(typeProperty.IsLocalizable);
-        Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", typeProperty.ComponentType.FullName);
-
-        Assert.Equal("System.Int16", typeProperty.PropertyType.FullName);
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, (PICTYPE)(short)typeProperty.GetValue(iPictureDisp));
-    }
-
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_FromIPicture()
-    {
-        // While we ask for IPicture, the underlying native class also supports IDispatch, so we get support
-        // in the type descriptor.
-        using Bitmap bitmap = new(10, 20);
-        object iPicture = IPicture.CreateObjectFromImage(bitmap);
-        Assert.NotNull(iPicture);
-
-        var properties = TypeDescriptor.GetProperties(iPicture);
-        Assert.Equal(PICTYPE.PICTYPE_BITMAP, (PICTYPE)(short)properties["Type"].GetValue(iPicture));
-    }
-
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_FromActiveXMediaPlayerControl_ComInterop()
-    {
-        Guid guid = typeof(WindowsMediaPlayerClass).GUID;
-        HRESULT hr = Ole32.CoCreateInstance(
-            in guid,
-            IntPtr.Zero,
-            CLSCTX.CLSCTX_INPROC_SERVER,
-            in IID.GetRef<IUnknown>(),
-            out object mediaPlayer);
-
-        Assert.Equal(HRESULT.S_OK, hr);
-
-        ComNativeDescriptor descriptor = new();
-        ValidateMediaPlayerProperties(mediaPlayer, descriptor.GetProperties(mediaPlayer));
-    }
-
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_FromActiveXMediaPlayerControl_ComWrappers()
-    {
-        Guid guid = typeof(WindowsMediaPlayerClass).GUID;
-        ComScope<IUnknown> unknown = new(null);
-        HRESULT hr = PInvoke.CoCreateInstance(
-            &guid,
-            null,
-            CLSCTX.CLSCTX_INPROC_SERVER,
-            IID.Get<IUnknown>(),
-            (void**)unknown);
-
-        Assert.Equal(HRESULT.S_OK, hr);
-
-        object mediaPlayer = UnknownComWrappers.Instance.GetOrCreateObjectForComInstance(unknown, CreateObjectFlags.None);
-
-        ComNativeDescriptor descriptor = new();
-        ValidateMediaPlayerProperties(mediaPlayer, descriptor.GetProperties(mediaPlayer));
-    }
-
-    private static void ValidateMediaPlayerProperties(object mediaPlayer, PropertyDescriptorCollection properties)
-    {
-        Assert.Equal(25, properties.Count);
-
-        var urlProperty = properties["URL"];
-        Assert.IsType<Com2PropertyDescriptor>(urlProperty);
-        Assert.False(urlProperty.IsReadOnly);
-        Assert.Equal("Misc", urlProperty.Category);
-        Assert.False(urlProperty.IsLocalizable);
-        Assert.Equal("Windows.Win32.System.Com.IDispatch+Interface", urlProperty.ComponentType.FullName);
-
-        Assert.Equal("System.String", urlProperty.PropertyType.FullName);
-
-        Assert.Equal(DesignerSerializationVisibility.Visible, urlProperty.SerializationVisibility);
-        Assert.False(urlProperty.CanResetValue(mediaPlayer));
-        Assert.False(urlProperty.ShouldSerializeValue(mediaPlayer));
-        Assert.Equal(string.Empty, urlProperty.GetValue(mediaPlayer));
-
-        urlProperty.SetValue(mediaPlayer, "Movie.mpg");
-
-        // This will be the fully qualified path name, which is based on the current directory.
-        Assert.EndsWith("Movie.mpg", (string)urlProperty.GetValue(mediaPlayer));
-
-        var converter = (Com2ExtendedTypeConverter)urlProperty.Converter;
-        Assert.IsAssignableFrom<StringConverter>(converter.InnerConverter);
-    }
-
-    [WinFormsFact]
-    public void ComNativeDescriptor_GetProperties_StdAccessible()
-    {
-        using Control control = new();
-        control.CreateControl();
-
-        using ComScope<IAccessible> accessible = new(null);
-        HRESULT hr = PInvoke.CreateStdAccessibleObject(
-            control.HWND,
-            (int)OBJECT_IDENTIFIER.OBJID_CLIENT,
-            IID.Get<IAccessible>(),
-            accessible);
-
-        object comWrapper = UnknownComWrappers.Instance.GetOrCreateObjectForComInstance(accessible, CreateObjectFlags.None);
-
-        ComNativeDescriptor descriptor = new();
-        var properties = descriptor.GetProperties(comWrapper);
-        Assert.Equal(4, properties.Count);
-
-        var accChildCount = properties["accChildCount"];
-        Assert.True(accChildCount.IsReadOnly);
-        Assert.Equal(0, accChildCount.GetValue(comWrapper));
-
-        var accFocus = properties["accFocus"];
-        Assert.True(accFocus.IsReadOnly);
-        // VT_EMPTY - Nothing has focus
-        Assert.Null(accFocus.GetValue(comWrapper));
-    }
-
-    [StaFact]
-    public void ComNativeDescriptor_GetProperties_StandardDispatchAccessible_MultiClassInfo()
-    {
-        // Hitting the IProvideMultipleClassInfo with our stub object created over a system created IAccessible TypeInfo.
-
-        StandardAccessibleObjectWithMultipleClassInfo value = new();
-        using var accessible = ComHelpers.GetComScope<IAccessible>(value);
-
-        object comWrapper = UnknownComWrappers.Instance.GetOrCreateObjectForComInstance(accessible, CreateObjectFlags.None);
-        ComNativeDescriptor descriptor = new();
-        var properties = descriptor.GetProperties(comWrapper);
-
-        Assert.Equal(4, properties.Count);
-
-        var accChildCount = properties["accChildCount"];
-        Assert.True(accChildCount.IsReadOnly);
-        Assert.Equal(42, accChildCount.GetValue(comWrapper));
-
-        var accFocus = properties["accFocus"];
-        Assert.True(accFocus.IsReadOnly);
-        Assert.Equal((int)PInvoke.CHILDID_SELF, accFocus.GetValue(comWrapper));
-    }
-
-    [WinFormsFact(Skip = "Causes test run to abort, must be run manually.")]
-    public void ComNativeDescriptor_GetProperties_FromSimpleVBControl()
-    {
-        if (RuntimeInformation.ProcessArchitecture != Architecture.X86)
-        {
-            return;
-        }
-
-        // Not much to see with this control, but it does exercise a fair amount of code.
-        ComClasses.VisualBasicSimpleControl.CreateInstance(out object vbcontrol).ThrowOnFailure();
-
-        var properties = TypeDescriptor.GetProperties(vbcontrol);
-        Assert.Empty(properties);
-
-        var events = TypeDescriptor.GetEvents(vbcontrol);
-        Assert.Empty(events);
-
-        var attributes = TypeDescriptor.GetAttributes(vbcontrol);
-        Assert.Equal(2, attributes.Count);
-        BrowsableAttribute browsable = (BrowsableAttribute)attributes[0];
-        Assert.True(browsable.Browsable);
-        DesignTimeVisibleAttribute visible = (DesignTimeVisibleAttribute)attributes[1];
-        Assert.False(visible.Visible);
-    }
-
-    /// <summary>
-    ///  A simple stub that implements IDispatch for IAccessible and also implements IProvideMultipleClassInfo that
-    ///  just forwards to the IDispatch ITypeInfo to exercise the IProvideMultipleClassInfo code path.
-    /// </summary>
-    private unsafe class StandardAccessibleObjectWithMultipleClassInfo :
-        StandardDispatch,
-        IProvideMultipleClassInfo.Interface,
-        IAccessible.Interface,
-        IManagedWrapper<IAccessible, IDispatch, IProvideMultipleClassInfo>
-    {
-        // The accessibility TypeLib- lives in oleacc.dll
-        private static readonly Guid s_accessibilityTypeLib = new("1ea4dbf0-3c3b-11cf-810c-00aa00389b71");
-
-        public StandardAccessibleObjectWithMultipleClassInfo()
-            : base(s_accessibilityTypeLib, 1, 1, IAccessible.IID_Guid)
-        {
-        }
-
-        HRESULT IProvideMultipleClassInfo.Interface.GetClassInfo(ITypeInfo** ppTI) => HRESULT.E_NOTIMPL;
-
-        HRESULT IProvideMultipleClassInfo.Interface.GetGUID(uint dwGuidKind, Guid* pGUID) => HRESULT.E_NOTIMPL;
-
-        HRESULT IProvideMultipleClassInfo.Interface.GetMultiTypeInfoCount(uint* pcti)
-        {
-            if (pcti is null)
-            {
-                return HRESULT.E_POINTER;
-            }
-
-            *pcti = 1;
-            return HRESULT.S_OK;
-        }
-
-        HRESULT IProvideMultipleClassInfo.Interface.GetInfoOfIndex(
-            uint iti,
-            MULTICLASSINFO_FLAGS dwFlags,
-            ITypeInfo** pptiCoClass,
-            uint* pdwTIFlags,
-            uint* pcdispidReserved,
-            Guid* piidPrimary,
-            Guid* piidSource)
-        {
-            if (pptiCoClass is null)
-            {
-                return HRESULT.E_POINTER;
-            }
-
-            if (dwFlags != MULTICLASSINFO_FLAGS.MULTICLASSINFO_GETTYPEINFO)
-            {
-                return HRESULT.E_NOTIMPL;
-            }
-
-            return ((IDispatch.Interface)this).GetTypeInfo(iti, 0, pptiCoClass);
-        }
-
-        HRESULT IAccessible.Interface.get_accChildCount(int* pcountChildren)
-        {
-            if (pcountChildren is null)
-            {
-                return HRESULT.E_POINTER;
-            }
-
-            *pcountChildren = 42;
-            return HRESULT.S_OK;
-        }
-
-        HRESULT IAccessible.Interface.get_accFocus(VARIANT* pvarChild)
-        {
-            if (pvarChild is null)
-            {
-                return HRESULT.E_POINTER;
-            }
-
-            *pvarChild = (VARIANT)(int)PInvoke.CHILDID_SELF;
-            return HRESULT.S_OK;
-        }
-
-        HRESULT IProvideClassInfo2.Interface.GetClassInfo(ITypeInfo** ppTI) => HRESULT.E_NOTIMPL;
-        HRESULT IProvideClassInfo2.Interface.GetGUID(uint dwGuidKind, Guid* pGUID) => HRESULT.E_NOTIMPL;
-        HRESULT IProvideClassInfo.Interface.GetClassInfo(ITypeInfo** ppTI) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accParent(IDispatch** ppdispParent) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accChild(VARIANT varChild, IDispatch** ppdispChild) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accName(VARIANT varChild, BSTR* pszName) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accValue(VARIANT varChild, BSTR* pszValue) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accDescription(VARIANT varChild, BSTR* pszDescription) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accRole(VARIANT varChild, VARIANT* pvarRole) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accState(VARIANT varChild, VARIANT* pvarState) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accHelp(VARIANT varChild, BSTR* pszHelp) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild, int* pidTopic) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accKeyboardShortcut(VARIANT varChild, BSTR* pszKeyboardShortcut) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accSelection(VARIANT* pvarChildren) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.get_accDefaultAction(VARIANT varChild, BSTR* pszDefaultAction) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.accSelect(int flagsSelect, VARIANT varChild) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.accLocation(int* pxLeft, int* pyTop, int* pcxWidth, int* pcyHeight, VARIANT varChild) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.accNavigate(int navDir, VARIANT varStart, VARIANT* pvarEndUpAt) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.accHitTest(int xLeft, int yTop, VARIANT* pvarChild) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.accDoDefaultAction(VARIANT varChild) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.put_accName(VARIANT varChild, BSTR szName) => HRESULT.E_NOTIMPL;
-        HRESULT IAccessible.Interface.put_accValue(VARIANT varChild, BSTR szValue) => HRESULT.E_NOTIMPL;
-    }
-
-    private class UnknownComWrappers : ComWrappers
-    {
-        private UnknownComWrappers() { }
-        public static ComWrappers Instance { get; } = new UnknownComWrappers();
-
-        protected override unsafe ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override object CreateObject(nint externalComObject, CreateObjectFlags flags)
-        {
-            return new UnknownClass() { Unknown = externalComObject };
-        }
-
-        protected override void ReleaseObjects(IEnumerable objects)
-        {
-            throw new NotImplementedException();
-        }
-
-        private class UnknownClass
-        {
-            public nint Unknown { get; set; }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContainerControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContainerControlTests.cs
deleted file mode 100644
index 8171019bf5b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContainerControlTests.cs
+++ /dev/null
@@ -1,1505 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Reflection;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ContainerControlTests
-{
-    [WinFormsFact]
-    public void ContainerControl_Ctor_Default()
-    {
-        using var control = new SubContainerControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Null(control.ActiveControl);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        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(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubContainerControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_ActiveContainerControl_Set_GetReturnsExpected()
-    {
-        using var control = new ContainerControl();
-        using var child = new Control();
-        var grandchild = new Control();
-        control.Controls.Add(child);
-        child.Controls.Add(grandchild);
-
-        control.ActiveControl = child;
-        Assert.Same(child, control.ActiveControl);
-
-        // Set same.
-        control.ActiveControl = child;
-        Assert.Same(child, control.ActiveControl);
-
-        // Set grandchild.
-        control.ActiveControl = grandchild;
-        Assert.Same(grandchild, control.ActiveControl);
-
-        // Set null.
-        control.ActiveControl = null;
-        Assert.Null(control.ActiveControl);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_ActiveContainerControl_SetInvalid_ThrowsArgumentException()
-    {
-        using var control = new ContainerControl();
-        Assert.Throws<ArgumentException>("value", () => control.ActiveControl = control);
-        Assert.Throws<ArgumentException>("value", () => control.ActiveControl = new Control());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData), TestIncludeType.NoNegatives)]
-    public void ContainerControl_AutoScaleDimensions_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new ContainerControl
-        {
-            AutoScaleDimensions = value
-        };
-        Assert.Equal(value, control.AutoScaleDimensions);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScaleDimensions = value;
-        Assert.Equal(value, control.AutoScaleDimensions);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData), TestIncludeType.NoNegatives)]
-    public void ContainerControl_AutoScaleDimensions_SetWithChildren_GetReturnsExpected(Size value)
-    {
-        using var child = new Control();
-        using var control = new ContainerControl();
-        control.Controls.Add(child);
-
-        control.AutoScaleDimensions = value;
-        Assert.Equal(value, control.AutoScaleDimensions);
-
-        // Set same.
-        control.AutoScaleDimensions = value;
-        Assert.Equal(value, control.AutoScaleDimensions);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData), TestIncludeType.NoPositives)]
-    public void ContainerControl_AutoScaleDimensions_SetInvalid_ThrowsArgumentOutOfRangeException(Size value)
-    {
-        using var control = new ContainerControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.AutoScaleDimensions = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoScaleMode>]
-    public void ContainerControl_AutoScaleMode_Set_GetReturnsExpected(AutoScaleMode value)
-    {
-        using var control = new ContainerControl
-        {
-            AutoScaleMode = value
-        };
-        Assert.Equal(value, control.AutoScaleMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScaleMode = value;
-        Assert.Equal(value, control.AutoScaleMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AutoScaleMode_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { AutoScaleMode.None, SizeF.Empty };
-        yield return new object[] { AutoScaleMode.Dpi, new SizeF(96, 96) };
-        yield return new object[] { AutoScaleMode.Inherit, SizeF.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScaleMode_SetWithCustomOldValue_TestData))]
-    public void ContainerControl_AutoScaleMode_SetWithCustomOldValue_ResetsAutoScaleDimensions(AutoScaleMode value, SizeF expectedAutoScaleDimensions)
-    {
-        using var control = new ContainerControl
-        {
-            AutoScaleDimensions = new SizeF(1, 2),
-            AutoScaleMode = AutoScaleMode.Font
-        };
-
-        control.AutoScaleMode = value;
-        Assert.Equal(value, control.AutoScaleMode);
-        Assert.Equal(expectedAutoScaleDimensions, control.AutoScaleDimensions);
-        Assert.Equal(expectedAutoScaleDimensions, control.CurrentAutoScaleDimensions);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScaleMode = value;
-        Assert.Equal(value, control.AutoScaleMode);
-        Assert.Equal(expectedAutoScaleDimensions, control.AutoScaleDimensions);
-        Assert.Equal(expectedAutoScaleDimensions, control.CurrentAutoScaleDimensions);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoScaleMode>]
-    public void ContainerControl_AutoScaleMode_SetInvalid_ThrowsInvalidEnumArgumentException(AutoScaleMode value)
-    {
-        using var control = new ContainerControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoScaleMode = value);
-    }
-
-    public static IEnumerable<object[]> AutoValidate_Set_TestData()
-    {
-        yield return new object[] { AutoValidate.Disable, AutoValidate.Disable };
-        yield return new object[] { AutoValidate.EnablePreventFocusChange, AutoValidate.EnablePreventFocusChange };
-        yield return new object[] { AutoValidate.EnableAllowFocusChange, AutoValidate.EnableAllowFocusChange };
-        yield return new object[] { AutoValidate.Inherit, AutoValidate.EnablePreventFocusChange };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoValidate_Set_TestData))]
-    public void UserControl_AutoValidate_Set_GetReturnsExpected(AutoValidate value, AutoValidate expected)
-    {
-        using var control = new ContainerControl
-        {
-            AutoValidate = value
-        };
-        Assert.Equal(expected, control.AutoValidate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoValidate = value;
-        Assert.Equal(expected, control.AutoValidate);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_AutoValidate_SetWithHandler_CallsAutoValidateChanged()
-    {
-        using var control = new ContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoValidateChanged += handler;
-
-        // Set different.
-        control.AutoValidate = AutoValidate.EnablePreventFocusChange;
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoValidate = AutoValidate.EnablePreventFocusChange;
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoValidate = AutoValidate.EnableAllowFocusChange;
-        Assert.Equal(AutoValidate.EnableAllowFocusChange, control.AutoValidate);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoValidateChanged -= handler;
-        control.AutoValidate = AutoValidate.Disable;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoValidate>]
-    public void ContainerControl_AutoValidate_SetInvalidValue_ThrowsInvalidEnumArgumentException(AutoValidate value)
-    {
-        using var control = new ContainerControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoValidate = value);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_BindingContext_Set_GetReturnsExpected()
-    {
-        var value = new BindingContext();
-        using var control = new ContainerControl
-        {
-            BindingContext = value
-        };
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.NotNull(control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_BindingContext_SetWithHandler_CallsBindingContextChanged()
-    {
-        using var control = new ContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var value1 = new BindingContext();
-        control.BindingContext = value1;
-        Assert.Same(value1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = value1;
-        Assert.Same(value1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var value2 = new BindingContext();
-        control.BindingContext = value2;
-        Assert.Equal(value2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        var value3 = new BindingContext();
-        control.BindingContextChanged -= handler;
-        control.BindingContext = value3;
-        Assert.Same(value3, control.BindingContext);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ContainerControl_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubContainerControl
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ContainerControl_Font_SetWithAutoScaleModeFont_GetReturnsExpected(Font value)
-    {
-        using var control = new SubContainerControl
-        {
-            AutoScaleMode = AutoScaleMode.Font
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(new Size(1, 1), control.AutoScaleFactor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(new Size(1, 1), control.AutoScaleFactor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubContainerControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubContainerControl.ScrollStateAutoScrolling, false)]
-    [InlineData(SubContainerControl.ScrollStateFullDrag, false)]
-    [InlineData(SubContainerControl.ScrollStateHScrollVisible, false)]
-    [InlineData(SubContainerControl.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubContainerControl.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ContainerControl_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubContainerControl();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ContainerControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubContainerControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubContainerControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoScaleMode>]
-    public void PerformAutoScale_InvokeWithoutChildren_Success(AutoScaleMode autoScaleMode)
-    {
-        using var control = new SubContainerControl
-        {
-            AutoScaleMode = autoScaleMode
-        };
-        control.PerformAutoScale();
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoScaleMode>]
-    public void PerformAutoScale_InvokeWithChildren_Success(AutoScaleMode autoScaleMode)
-    {
-        using var child = new Control();
-        using var control = new SubContainerControl
-        {
-            AutoScaleMode = autoScaleMode
-        };
-        control.Controls.Add(child);
-        control.PerformAutoScale();
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_CreateContainerControl_Invoke_CallsBindingContextChanged()
-    {
-        using var control = new ContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var value1 = new BindingContext();
-        control.BindingContext = value1;
-        Assert.Same(value1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = value1;
-        Assert.Same(value1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var value2 = new BindingContext();
-        control.BindingContext = value2;
-        Assert.Equal(value2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        var value3 = new BindingContext();
-        control.BindingContextChanged -= handler;
-        control.BindingContext = value3;
-        Assert.Same(value3, control.BindingContext);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_Dispose_Invoke_ResetsActiveControl()
-    {
-        using var control = new ContainerControl();
-        using var child = new Control();
-        control.Controls.Add(child);
-        control.ActiveControl = child;
-
-        control.Dispose();
-        Assert.Null(control.ActiveControl);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ContainerControl_OnAutoValidateChanged_Invoke_CallsAutoValidateChanged(EventArgs eventArgs)
-    {
-        using var control = new SubContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AutoValidateChanged += handler;
-        control.OnAutoValidateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AutoValidateChanged -= handler;
-        control.OnAutoValidateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_OnCreateControl_Invoke_Nop()
-    {
-        using var control = new SubContainerControl();
-        int bindingContextChangedCallCount = 0;
-        control.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            bindingContextChangedCallCount++;
-        };
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(1, bindingContextChangedCallCount);
-
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(2, bindingContextChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ContainerControl_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ContainerControl_OnFontChanged_InvokeWithAutoScaleModeFont_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubContainerControl
-        {
-            AutoScaleMode = AutoScaleMode.Font
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(new Size(1, 1), control.AutoScaleFactor);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(new Size(1, 1), control.AutoScaleFactor);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ContainerControl_OnLayout_Invoke_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubContainerControl();
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ContainerControl_OnParentChanged_Invoke_CallsParentChanged(EventArgs eventArgs)
-    {
-        using var control = new SubContainerControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_UpdateDefaultButton_Invoke_Nop()
-    {
-        using var control = new SubContainerControl();
-        control.UpdateDefaultButton();
-        control.UpdateDefaultButton();
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_ValidateChildren_InvokeWithoutChildren_ReturnsTrue()
-    {
-        using var control = new ContainerControl();
-        Assert.True(control.ValidateChildren());
-    }
-
-    public static IEnumerable<object[]> ValidateChildren_TestData()
-    {
-        yield return new object[] { true, 0 };
-        yield return new object[] { false, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValidateChildren_TestData))]
-    public void ContainerControl_ValidateChildren_InvokeWithChildren_ReturnsExpected(bool cancel, int expectedCallCount)
-    {
-        using var control = new ContainerControl();
-        using var child1 = new Control();
-        using var grandchild1 = new Control();
-        child1.Controls.Add(grandchild1);
-        using var child2 = new ContainerControl();
-        using var grandchild2 = new Control();
-        child2.Controls.Add(grandchild2);
-        using var child3 = new TabControl();
-        using var grandchild3 = new TabPage();
-        child3.Controls.Add(grandchild3);
-        using var child4 = new SubControl();
-        child4.SetStyle(ControlStyles.Selectable, false);
-        using var child5 = new SubControl
-        {
-            Enabled = false
-        };
-        using var child6 = new SubControl
-        {
-            Visible = false
-        };
-        using var child7 = new SubControl
-        {
-            TabStop = false
-        };
-        using var child8 = new SubControl
-        {
-            CausesValidation = false
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-        control.Controls.Add(child5);
-        control.Controls.Add(child6);
-        control.Controls.Add(child7);
-        control.Controls.Add(child8);
-
-        int validatingCallCount = 0;
-        control.Validating += (sender, e) => validatingCallCount++;
-        int validatedCallCount = 0;
-        control.Validated += (sender, e) => validatedCallCount++;
-
-        int child1ValidatingCallCount = 0;
-        child1.Validating += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.False(e.Cancel);
-            child1ValidatingCallCount++;
-            e.Cancel = cancel;
-        };
-        int child1ValidatedCallCount = 0;
-        child1.Validated += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1ValidatedCallCount++;
-        };
-        int grandchild1ValidatingCallCount = 0;
-        grandchild1.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild1, sender);
-            Assert.False(e.Cancel);
-            grandchild1ValidatingCallCount++;
-        };
-        int grandchild1ValidatedCallCount = 0;
-        grandchild1.Validated += (sender, e) => grandchild1ValidatedCallCount++;
-        int child2ValidatingCallCount = 0;
-        child2.Validating += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.False(e.Cancel);
-            child2ValidatingCallCount++;
-        };
-        int child2ValidatedCallCount = 0;
-        child2.Validated += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2ValidatedCallCount++;
-        };
-        int grandchild2ValidatingCallCount = 0;
-        grandchild2.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.False(e.Cancel);
-            grandchild2ValidatingCallCount++;
-        };
-        int grandchild2ValidatedCallCount = 0;
-        grandchild2.Validated += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            grandchild2ValidatedCallCount++;
-        };
-        int child3ValidatingCallCount = 0;
-        child3.Validating += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.False(e.Cancel);
-            child3ValidatingCallCount++;
-        };
-        int child3ValidatedCallCount = 0;
-        child3.Validated += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child3ValidatedCallCount++;
-        };
-        int grandchild3ValidatingCallCount = 0;
-        grandchild3.Validating += (sender, e) => grandchild3ValidatingCallCount++;
-        int grandchild3ValidatedCallCount = 0;
-        grandchild3.Validated += (sender, e) => grandchild3ValidatedCallCount++;
-        int child4ValidatingCallCount = 0;
-        child4.Validating += (sender, e) => child4ValidatingCallCount++;
-        int child4ValidatedCallCount = 0;
-        child4.Validated += (sender, e) => child4ValidatedCallCount++;
-        int child5ValidatingCallCount = 0;
-        child5.Validating += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.False(e.Cancel);
-            child5ValidatingCallCount++;
-        };
-        int child5ValidatedCallCount = 0;
-        child5.Validated += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child5ValidatedCallCount++;
-        };
-        int child6ValidatingCallCount = 0;
-        child6.Validating += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.False(e.Cancel);
-            child6ValidatingCallCount++;
-        };
-        int child6ValidatedCallCount = 0;
-        child6.Validated += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child6ValidatedCallCount++;
-        };
-        int child7ValidatingCallCount = 0;
-        child7.Validating += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.False(e.Cancel);
-            child7ValidatingCallCount++;
-        };
-        int child7ValidatedCallCount = 0;
-        child7.Validated += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child7ValidatedCallCount++;
-        };
-        int child8ValidatingCallCount = 0;
-        child8.Validating += (sender, e) => child8ValidatingCallCount++;
-        int child8ValidatedCallCount = 0;
-        child8.Validated += (sender, e) => child8ValidatedCallCount++;
-
-        Assert.Equal(!cancel, control.ValidateChildren());
-        Assert.Equal(0, validatingCallCount);
-        Assert.Equal(0, validatedCallCount);
-        Assert.Equal(1, child1ValidatingCallCount);
-        Assert.Equal(expectedCallCount, child1ValidatedCallCount);
-        Assert.Equal(0, grandchild1ValidatingCallCount);
-        Assert.Equal(0, grandchild1ValidatedCallCount);
-        Assert.Equal(1, child2ValidatingCallCount);
-        Assert.Equal(1, child2ValidatedCallCount);
-        Assert.Equal(1, grandchild2ValidatingCallCount);
-        Assert.Equal(1, grandchild2ValidatedCallCount);
-        Assert.Equal(1, child3ValidatingCallCount);
-        Assert.Equal(1, child3ValidatedCallCount);
-        Assert.Equal(0, grandchild3ValidatingCallCount);
-        Assert.Equal(0, grandchild3ValidatedCallCount);
-        Assert.Equal(0, child4ValidatingCallCount);
-        Assert.Equal(0, child4ValidatedCallCount);
-        Assert.Equal(1, child5ValidatingCallCount);
-        Assert.Equal(1, child5ValidatedCallCount);
-        Assert.Equal(1, child6ValidatingCallCount);
-        Assert.Equal(1, child6ValidatedCallCount);
-        Assert.Equal(1, child7ValidatingCallCount);
-        Assert.Equal(1, child7ValidatedCallCount);
-        Assert.Equal(0, child8ValidatingCallCount);
-        Assert.Equal(0, child8ValidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ValidationConstraints>]
-    public void ContainerControl_ValidateChildren_InvokeValidationConstraintsWithoutChildren_ReturnsTrue(ValidationConstraints validationConstraints)
-    {
-        using var control = new ContainerControl();
-        Assert.True(control.ValidateChildren(validationConstraints));
-    }
-
-    public static IEnumerable<object[]> ValidateChildren_ValidationConstraints_TestData()
-    {
-        yield return new object[] { ValidationConstraints.ImmediateChildren, true, 0, 0, 0, 1, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.ImmediateChildren, false, 1, 0, 0, 1, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Selectable, true, 0, 1, 0, 0, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.Selectable, false, 1, 1, 0, 0, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Enabled, true, 0, 1, 1, 1, 0, 1, 1 };
-        yield return new object[] { ValidationConstraints.Enabled, false, 1, 1, 1, 1, 0, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Visible, true, 0, 1, 0, 1, 1, 0, 1 };
-        yield return new object[] { ValidationConstraints.Visible, false, 1, 1, 0, 1, 1, 0, 1 };
-
-        yield return new object[] { ValidationConstraints.TabStop, true, 0, 1, 0, 1, 1, 1, 0 };
-        yield return new object[] { ValidationConstraints.TabStop, false, 1, 1, 0, 1, 1, 1, 0 };
-
-        yield return new object[] { ValidationConstraints.None, true, 0, 1, 1, 1, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.None, false, 1, 1, 1, 1, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.ImmediateChildren | ValidationConstraints.Selectable | ValidationConstraints.Enabled | ValidationConstraints.Visible | ValidationConstraints.TabStop, true, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { ValidationConstraints.ImmediateChildren | ValidationConstraints.Selectable | ValidationConstraints.Enabled | ValidationConstraints.Visible | ValidationConstraints.TabStop, false, 1, 0, 0, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValidateChildren_ValidationConstraints_TestData))]
-    public void ContainerControl_ValidateChildren_InvokeValidationConstraintsWithChildren_ReturnsExpected(ValidationConstraints validationConstraints, bool cancel, int expectedChild1CallCount, int expectedGrandchild2CallCount, int expectedGrandchild3CallCount, int expectedChild4CallCount, int expectedChild5CallCount, int expectedChild6CallCount, int expectedChild7CallCount)
-    {
-        using var control = new ContainerControl();
-        using var child1 = new Control();
-        using var grandchild1 = new Control();
-        child1.Controls.Add(grandchild1);
-        using var child2 = new ContainerControl();
-        using var grandchild2 = new Control();
-        child2.Controls.Add(grandchild2);
-        using var child3 = new TabControl();
-        using var grandchild3 = new TabPage();
-        child3.Controls.Add(grandchild3);
-        using var child4 = new SubControl();
-        child4.SetStyle(ControlStyles.Selectable, false);
-        using var child5 = new SubControl
-        {
-            Enabled = false
-        };
-        using var child6 = new SubControl
-        {
-            Visible = false
-        };
-        using var child7 = new SubControl
-        {
-            TabStop = false
-        };
-        using var child8 = new SubControl
-        {
-            CausesValidation = false
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-        control.Controls.Add(child5);
-        control.Controls.Add(child6);
-        control.Controls.Add(child7);
-        control.Controls.Add(child8);
-
-        int validatingCallCount = 0;
-        control.Validating += (sender, e) => validatingCallCount++;
-        int validatedCallCount = 0;
-        control.Validated += (sender, e) => validatedCallCount++;
-
-        int child1ValidatingCallCount = 0;
-        child1.Validating += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.False(e.Cancel);
-            child1ValidatingCallCount++;
-            e.Cancel = cancel;
-        };
-        int child1ValidatedCallCount = 0;
-        child1.Validated += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1ValidatedCallCount++;
-        };
-        int grandchild1ValidatingCallCount = 0;
-        grandchild1.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild1, sender);
-            Assert.False(e.Cancel);
-            grandchild1ValidatingCallCount++;
-        };
-        int grandchild1ValidatedCallCount = 0;
-        grandchild1.Validated += (sender, e) => grandchild1ValidatedCallCount++;
-        int child2ValidatingCallCount = 0;
-        child2.Validating += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.False(e.Cancel);
-            child2ValidatingCallCount++;
-        };
-        int child2ValidatedCallCount = 0;
-        child2.Validated += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2ValidatedCallCount++;
-        };
-        int grandchild2ValidatingCallCount = 0;
-        grandchild2.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.False(e.Cancel);
-            grandchild2ValidatingCallCount++;
-        };
-        int grandchild2ValidatedCallCount = 0;
-        grandchild2.Validated += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            grandchild2ValidatedCallCount++;
-        };
-        int child3ValidatingCallCount = 0;
-        child3.Validating += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.False(e.Cancel);
-            child3ValidatingCallCount++;
-        };
-        int child3ValidatedCallCount = 0;
-        child3.Validated += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child3ValidatedCallCount++;
-        };
-        int grandchild3ValidatingCallCount = 0;
-        grandchild3.Validating += (sender, e) => grandchild3ValidatingCallCount++;
-        int grandchild3ValidatedCallCount = 0;
-        grandchild3.Validated += (sender, e) => grandchild3ValidatedCallCount++;
-        int child4ValidatingCallCount = 0;
-        child4.Validating += (sender, e) => child4ValidatingCallCount++;
-        int child4ValidatedCallCount = 0;
-        child4.Validated += (sender, e) => child4ValidatedCallCount++;
-        int child5ValidatingCallCount = 0;
-        child5.Validating += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.False(e.Cancel);
-            child5ValidatingCallCount++;
-        };
-        int child5ValidatedCallCount = 0;
-        child5.Validated += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child5ValidatedCallCount++;
-        };
-        int child6ValidatingCallCount = 0;
-        child6.Validating += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.False(e.Cancel);
-            child6ValidatingCallCount++;
-        };
-        int child6ValidatedCallCount = 0;
-        child6.Validated += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child6ValidatedCallCount++;
-        };
-        int child7ValidatingCallCount = 0;
-        child7.Validating += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.False(e.Cancel);
-            child7ValidatingCallCount++;
-        };
-        int child7ValidatedCallCount = 0;
-        child7.Validated += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child7ValidatedCallCount++;
-        };
-        int child8ValidatingCallCount = 0;
-        child8.Validating += (sender, e) => child8ValidatingCallCount++;
-        int child8ValidatedCallCount = 0;
-        child8.Validated += (sender, e) => child8ValidatedCallCount++;
-
-        Assert.Equal(!cancel, control.ValidateChildren(validationConstraints));
-        Assert.Equal(0, validatingCallCount);
-        Assert.Equal(0, validatedCallCount);
-        Assert.Equal(1, child1ValidatingCallCount);
-        Assert.Equal(expectedChild1CallCount, child1ValidatedCallCount);
-        Assert.Equal(0, grandchild1ValidatingCallCount);
-        Assert.Equal(0, grandchild1ValidatedCallCount);
-        Assert.Equal(1, child2ValidatingCallCount);
-        Assert.Equal(1, child2ValidatedCallCount);
-        Assert.Equal(expectedGrandchild2CallCount, grandchild2ValidatingCallCount);
-        Assert.Equal(expectedGrandchild2CallCount, grandchild2ValidatedCallCount);
-        Assert.Equal(1, child3ValidatingCallCount);
-        Assert.Equal(1, child3ValidatedCallCount);
-        Assert.Equal(expectedGrandchild3CallCount, grandchild3ValidatingCallCount);
-        Assert.Equal(expectedGrandchild3CallCount, grandchild3ValidatedCallCount);
-        Assert.Equal(expectedChild4CallCount, child4ValidatingCallCount);
-        Assert.Equal(expectedChild4CallCount, child4ValidatedCallCount);
-        Assert.Equal(expectedChild5CallCount, child5ValidatingCallCount);
-        Assert.Equal(expectedChild5CallCount, child5ValidatedCallCount);
-        Assert.Equal(expectedChild6CallCount, child6ValidatingCallCount);
-        Assert.Equal(expectedChild6CallCount, child6ValidatedCallCount);
-        Assert.Equal(expectedChild7CallCount, child7ValidatingCallCount);
-        Assert.Equal(expectedChild7CallCount, child7ValidatedCallCount);
-        Assert.Equal(0, child8ValidatingCallCount);
-        Assert.Equal(0, child8ValidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((ValidationConstraints)(-1))]
-    [InlineData((ValidationConstraints)(0x20))]
-    public void ContainerControl_ValidateChildren_InvalidValidationConstraints_ThrowsInvalidEnumArgumentException(ValidationConstraints validationConstraints)
-    {
-        using var control = new ContainerControl();
-        Assert.Throws<InvalidEnumArgumentException>("validationConstraints", () => control.ValidateChildren(validationConstraints));
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubContainerControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_WndProc_InvokeSetFocusWithHandle_Success()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubContainerControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Null(control.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_WndProc_InvokeSetFocusWithActiveControlWithHandle_Success()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubContainerControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.ActiveControl = child2;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Same(child2, control.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_OnMove_HidesToolTip_IfToolTipIsShown()
-    {
-        using Control control = new();
-        using SubContainerControl container = new();
-        container.Controls.Add(control);
-        container.SetTopLevel();
-        container.CreateControl();
-
-        // Simulate that a keyboard toolTip is shown
-        KeyboardToolTipStateMachine instance = KeyboardToolTipStateMachine.Instance;
-        instance.TestAccessor().Dynamic._currentTool = control;
-        instance.TestAccessor().Dynamic._currentState = (byte)2;
-
-        container.MoveContainer();
-        IKeyboardToolTip currentTool = instance.TestAccessor().Dynamic._currentTool;
-        string currentState = instance.TestAccessor().Dynamic._currentState.ToString();
-
-        Assert.Null(currentTool);
-        Assert.Equal("Hidden", currentState);
-
-        Assert.True(control.IsHandleCreated);
-        Assert.True(container.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_OnResize_HidesToolTip_IfToolTipIsShown()
-    {
-        using Control control = new();
-        using SubContainerControl container = new();
-        container.Controls.Add(control);
-        container.SetTopLevel();
-        container.CreateControl();
-
-        // Simulate that a keyboard toolTip is shown
-        KeyboardToolTipStateMachine instance = KeyboardToolTipStateMachine.Instance;
-        instance.TestAccessor().Dynamic._currentTool = control;
-        instance.TestAccessor().Dynamic._currentState = (byte)2;
-
-        container.ResizeContainer();
-        IKeyboardToolTip currentTool = instance.TestAccessor().Dynamic._currentTool;
-        string currentState = instance.TestAccessor().Dynamic._currentState.ToString();
-
-        Assert.Null(currentTool);
-        Assert.Equal("Hidden", currentState);
-
-        Assert.True(control.IsHandleCreated);
-        Assert.True(container.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_OnResize_DoNothing_IfInstanceIsNotCreated()
-    {
-        using Control control = new();
-        using SubContainerControl container = new();
-        container.Controls.Add(control);
-        container.CreateControl();
-
-        container.ResizeContainer();
-        object instance = typeof(KeyboardToolTipStateMachine).GetField("s_instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
-
-        Assert.Null(instance);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(container.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ContainerControl_OnMove_DoNothing_IfInstanceIsNotCreated()
-    {
-        using Control control = new();
-        using SubContainerControl container = new();
-        container.Controls.Add(control);
-        container.CreateControl();
-
-        container.MoveContainer();
-        object instance = typeof(KeyboardToolTipStateMachine).GetField("s_instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
-
-        Assert.Null(instance);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(container.IsHandleCreated);
-    }
-
-    private class SubControl : Control
-    {
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    public class SubContainerControl : ContainerControl
-    {
-        public new const int ScrollStateAutoScrolling = ContainerControl.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ContainerControl.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ContainerControl.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ContainerControl.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ContainerControl.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public void MoveContainer() => base.OnMove(EventArgs.Empty);
-
-        public void ResizeContainer() => base.OnResize(EventArgs.Empty);
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnAutoValidateChanged(EventArgs e) => base.OnAutoValidateChanged(e);
-
-        public new void OnCreateControl() => base.OnCreateControl();
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public void SetTopLevel() => SetTopLevel(true);
-
-        public new void UpdateDefaultButton() => base.UpdateDefaultButton();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContentsResizedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContentsResizedEventArgsTests.cs
deleted file mode 100644
index 4a69cb93cc7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ContentsResizedEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ContentsResizedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_TestData))]
-    public void Ctor_Rectangle(Rectangle newRectangle)
-    {
-        var e = new ContentsResizedEventArgs(newRectangle);
-        Assert.Equal(newRectangle, e.NewRectangle);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXFontMarshallerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXFontMarshallerTests.cs
deleted file mode 100644
index d04569ad865..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXFontMarshallerTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Tests;
-
-public unsafe class Control_ActiveXFontMarshalerTests
-{
-    private static readonly ICustomMarshaler s_marshaler =
-        (ICustomMarshaler)Activator.CreateInstance(
-            typeof(Control).Assembly.GetType("System.Windows.Forms.Control+ActiveXFontMarshaler")!,
-            nonPublic: true)!;
-
-    [StaFact(Skip = "Flaky test being investigated. see: https://github.com/dotnet/winforms/issues/8608")]
-    public void ActiveXFontMarshaler_RoundTripManagedFont()
-    {
-        using Font font = new("Arial", 11.0f, GraphicsUnit.Point);
-        nint native = s_marshaler.MarshalManagedToNative(font);
-        Assert.NotEqual(0, native);
-        using ComScope<IFont> iFont = new((IFont*)native);
-        using BSTR name = iFont.Value->Name;
-        Assert.Equal(font.Name, name.ToString());
-        Assert.Equal(11.25f, (float)iFont.Value->Size);
-
-        using Font outFont = (Font)s_marshaler.MarshalNativeToManaged(native);
-        Assert.Equal(font.Name, outFont.Name);
-        Assert.Equal(11.25f, outFont.SizeInPoints);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXImplTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXImplTests.cs
deleted file mode 100644
index 381f7b94c6e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ActiveXImplTests.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Collections;
-using System.Drawing;
-using System.Runtime.Serialization;
-using Windows.Win32.System.Com;
-using static Interop.Ole32;
-
-namespace System.Windows.Forms.Tests;
-
-public unsafe class Control_ActiveXImplTests
-{
-    [WinFormsFact]
-    public void ActiveXImpl_SaveLoad_RoundTrip_FormatterDisabled()
-    {
-        using BinaryFormatterScope formatterScope = new(enable: false);
-        using Control control = new();
-        control.BackColor = Color.Bisque;
-        IPersistStreamInit.Interface persistStream = control;
-
-        using MemoryStream memoryStream = new();
-        using var istream = ComHelpers.GetComScope<IStream>(new GPStream(memoryStream));
-        HRESULT hr = persistStream.Save(istream.Value, fClearDirty: BOOL.FALSE);
-        Assert.True(hr.Succeeded);
-        control.BackColor = Color.Honeydew;
-
-        istream.Value->Seek(0, SeekOrigin.Begin);
-        hr = persistStream.Load(istream.Value);
-        Assert.True(hr.Succeeded);
-        Assert.Equal(Color.Bisque, control.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ActiveXImpl_SaveLoad_BinaryFormatterProperty_FormatterEnabled()
-    {
-        using BinaryFormatterScope formatterScope = new(enable: true);
-        using MyControl control = new();
-
-        // We need to have a type that doesn't have a TypeConverter that implements ISerializable to hit the
-        // BinaryFormatter code path.
-        SerializableStruct myValue = new() { Value = "HelloThere" };
-        control.SerializableValue = myValue;
-        IPersistStreamInit.Interface persistStream = control;
-
-        using MemoryStream memoryStream = new();
-        using var istream = ComHelpers.GetComScope<IStream>(new GPStream(memoryStream));
-        HRESULT hr = persistStream.Save(istream.Value, fClearDirty: BOOL.FALSE);
-        Assert.True(hr.Succeeded);
-        control.SerializableValue = default;
-
-        istream.Value->Seek(0, SeekOrigin.Begin);
-        hr = persistStream.Load(istream.Value);
-        Assert.True(hr.Succeeded);
-        Assert.Equal(myValue, control.SerializableValue);
-    }
-
-    [WinFormsFact]
-    public void ActiveXImpl_SaveLoad_BinaryFormatterProperty_FormatterDisabled()
-    {
-        using BinaryFormatterScope formatterScope = new(enable: false);
-        using MyControl control = new();
-
-        // We need to have a type that doesn't have a TypeConverter that implements ISerializable to hit the
-        // BinaryFormatter code path.
-        SerializableStruct myValue = new() { Value = "HelloThere" };
-        control.SerializableValue = myValue;
-        IPersistStreamInit.Interface persistStream = control;
-
-        using MemoryStream memoryStream = new();
-        using var istream = ComHelpers.GetComScope<IStream>(new GPStream(memoryStream));
-        var istreamPointer = istream.Value;
-        Assert.Throws<NotSupportedException>(() => persistStream.Save(istreamPointer, fClearDirty: BOOL.FALSE));
-    }
-
-    [WinFormsFact]
-    public void ActiveXImpl_SaveLoad_BinaryFormatterProperty_FormatterDisabledSupported()
-    {
-        using BinaryFormatterScope formatterScope = new(enable: false);
-        using BinaryFormatterPropertiesControl control = new();
-
-        // We need to have a type that doesn't have a TypeConverter that implements ISerializable to hit the
-        // BinaryFormatter code path.
-        control.Table = new Hashtable() { { "Whas", "sup" } };
-
-        IPersistStreamInit.Interface persistStream = control;
-
-        using MemoryStream memoryStream = new();
-        using var istream = ComHelpers.GetComScope<IStream>(new GPStream(memoryStream));
-        HRESULT hr = persistStream.Save(istream.Value, fClearDirty: BOOL.FALSE);
-        Assert.True(hr.Succeeded);
-        control.Table = default;
-
-        istream.Value->Seek(0, SeekOrigin.Begin);
-        hr = persistStream.Load(istream.Value);
-        Assert.True(hr.Succeeded);
-        Assert.Equal("sup", control.Table!["Whas"]);
-    }
-
-    private class MyControl : Control
-    {
-        public SerializableStruct SerializableValue { get; set; }
-    }
-
-    private class BinaryFormatterPropertiesControl : Control
-    {
-        public Hashtable? Table { get; set; }
-    }
-
-    [Serializable]
-    public struct SerializableStruct : ISerializable
-    {
-        public string? Value { get; set; }
-
-        public void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            info.AddValue(nameof(Value), Value, typeof(string));
-        }
-
-        private SerializableStruct(SerializationInfo serializationInfo, StreamingContext streamingContext)
-        {
-            Value = (string?)serializationInfo.GetValue(nameof(Value), typeof(string));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ControlAccessibleObjectTests.cs
deleted file mode 100644
index 9681fcf2639..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Control.ControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1711 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-using System.Windows.Forms.Automation;
-using Accessibility;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class Control_ControlAccessibleObjectTests
-{
-    // These controls return an empty "AccessKey" property because they have a ControlStyles.UseTextForAccessibility flag
-    // with "false" value, which prohibits the use of text to create the AccessKey.
-    // This behavior is consistent with .NET Framework 4.7.2
-    private static Type[] s_controlsNotUseTextForAccessibility = new Type[]
-    {
-        typeof(CheckedListBox),
-        typeof(ComboBox),
-        typeof(DataGridViewComboBoxEditingControl),
-        typeof(DataGridViewTextBoxEditingControl),
-        typeof(DateTimePicker),
-        typeof(DomainUpDown),
-        typeof(HScrollBar),
-        typeof(ListBox),
-        typeof(ListView),
-        typeof(MaskedTextBox),
-        typeof(NumericUpDown),
-        typeof(ProgressBar),
-        typeof(RichTextBox),
-        typeof(TextBox),
-        typeof(TrackBar),
-        typeof(TreeView),
-        typeof(VScrollBar),
-        typeof(WebBrowser),
-    };
-
-    // These controls have special conditions for setting the Text property.
-    // Please check if the control type isn't contained here in cases where text change is needed
-    // otherwise an error can be thrown.
-    private static Type[] s_controlsIgnoringTextChangesForTests = new Type[]
-    {
-        typeof(DateTimePicker), typeof(WebBrowser)
-    };
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_Ctor_ControlWithoutHandle()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.False(ownerControl.IsHandleCreated);
-
-        Assert.True(accessibleObject.Bounds.X >= 0);
-        Assert.True(accessibleObject.Bounds.Y >= 0);
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Equal(IntPtr.Zero, accessibleObject.HandleInternal);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Same(ownerControl, accessibleObject.Owner);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(string.Empty, accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_Ctor_ControlWithHandle()
-    {
-        using var ownerControl = new Control();
-        Assert.NotEqual(IntPtr.Zero, ownerControl.Handle);
-        int invalidatedCallCount = 0;
-        ownerControl.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ownerControl.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        ownerControl.HandleCreated += (sender, e) => createdCallCount++;
-
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Assert.True(accessibleObject.Bounds.X >= 0);
-        Assert.True(accessibleObject.Bounds.Y >= 0);
-        Assert.Equal(0, accessibleObject.Bounds.Width);
-        Assert.Equal(0, accessibleObject.Bounds.Height);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Description);
-        Assert.Equal(ownerControl.Handle, accessibleObject.Handle);
-        Assert.Null(accessibleObject.Help);
-        Assert.Null(accessibleObject.KeyboardShortcut);
-        Assert.Null(accessibleObject.Name);
-        Assert.Same(ownerControl, accessibleObject.Owner);
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Client, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.Null(accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("ownerControl", () => new Control.ControlAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_created_via_owner_ensure_handle_set_when_owner_created()
-    {
-        using var ownerControl = new Control();
-
-        AccessibleObject accessibleObject = ownerControl.AccessibilityObject;
-        Assert.IsType<Control.ControlAccessibleObject>(accessibleObject);
-
-        Control.ControlAccessibleObject controlAccessibleObject = (Control.ControlAccessibleObject)accessibleObject;
-        Assert.False(ownerControl.IsHandleCreated);
-        Assert.Equal(IntPtr.Zero, controlAccessibleObject.HandleInternal);
-
-        // force the owner control to create its handle
-        ownerControl.CreateControl();
-
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, controlAccessibleObject.Handle);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_created_via_owner_ensure_handle_reset_when_owner_destroyed()
-    {
-        using var ownerControl = new Control();
-        ownerControl.CreateControl();
-
-        AccessibleObject accessibleObject = ownerControl.AccessibilityObject;
-        Assert.IsType<Control.ControlAccessibleObject>(accessibleObject);
-
-        Control.ControlAccessibleObject controlAccessibleObject = (Control.ControlAccessibleObject)accessibleObject;
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, controlAccessibleObject.Handle);
-
-        ownerControl.Dispose();
-
-        Assert.False(ownerControl.IsHandleCreated);
-        Assert.Equal(IntPtr.Zero, controlAccessibleObject.Handle);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_created_detached_owner_ensure_handle_set_when_owner_created()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.False(ownerControl.IsHandleCreated);
-        Assert.Equal(IntPtr.Zero, accessibleObject.HandleInternal);
-
-        // force the owner control to create its handle
-        ownerControl.CreateControl();
-
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, accessibleObject.Handle);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_created_detached_owner_ensure_handle_reset_when_owner_destroyed()
-    {
-        using var ownerControl = new Control();
-        var controlAccessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        ownerControl.CreateControl();
-
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, controlAccessibleObject.Handle);
-
-        ownerControl.Dispose();
-
-        Assert.False(ownerControl.IsHandleCreated);
-
-        // NB: Detached object, so we don't get notifications
-        Assert.NotEqual(IntPtr.Zero, controlAccessibleObject.Handle);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_DefaultAction_GetWithAccessibleDefaultActionDescription_ReturnsExpected(string accessibleDefaultActionDescription)
-    {
-        using var ownerControl = new Control
-        {
-            AccessibleDefaultActionDescription = accessibleDefaultActionDescription
-        };
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(accessibleDefaultActionDescription, accessibleObject.DefaultAction);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected(string accessibleDefaultActionDescription)
-    {
-        using var ownerControl = new Control
-        {
-            AccessibleDefaultActionDescription = accessibleDefaultActionDescription
-        };
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(!string.IsNullOrEmpty(accessibleDefaultActionDescription) ? accessibleDefaultActionDescription :
-            null, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_Description_GetWithAccessibleDescription_ReturnsExpected(string accessibleDescription)
-    {
-        using var ownerControl = new Control
-        {
-            AccessibleDescription = accessibleDescription
-        };
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(accessibleDescription, accessibleObject.Description);
-    }
-
-    public static IEnumerable<object[]> Handle_Set_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)(-1) };
-        yield return new object[] { (IntPtr)1 };
-        yield return new object[] { (IntPtr)250 };
-        yield return new object[] { new Control().Handle };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Handle_Set_TestData))]
-    public void ControlAccessibleObject_Handle_Set_Success(IntPtr value)
-    {
-        using var ownerControl = new Control();
-        ownerControl.CreateControl();
-        Assert.True(ownerControl.IsHandleCreated);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.True(ownerControl.IsHandleCreated);
-
-        // Set empty.
-        accessibleObject.Handle = value;
-        Assert.Equal(value, accessibleObject.Handle);
-
-        // Set same.
-        accessibleObject.Handle = value;
-        Assert.Equal(value, accessibleObject.Handle);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_Help_GetWithQueryAccessibilityHelpEvent_Success(string result)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        int callCount = 0;
-        void handler(object sender, QueryAccessibilityHelpEventArgs e)
-        {
-            Assert.Same(ownerControl, sender);
-            Assert.Null(e.HelpKeyword);
-            Assert.Null(e.HelpNamespace);
-            Assert.Null(e.HelpString);
-
-            e.HelpString = result;
-            callCount++;
-        }
-
-        ownerControl.QueryAccessibilityHelp += handler;
-
-        // Get with handler.
-        Assert.Equal(result, accessibleObject.Help);
-        Assert.Equal(1, callCount);
-
-        // Get again.
-        Assert.Equal(result, accessibleObject.Help);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        ownerControl.QueryAccessibilityHelp -= handler;
-        Assert.Null(accessibleObject.Help);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> KeyboardShortcut_Get_TestData()
-    {
-        yield return new object[] { true, null, null };
-        yield return new object[] { true, string.Empty, null };
-        yield return new object[] { true, "Text", null };
-        yield return new object[] { false, null, null };
-        yield return new object[] { false, string.Empty, null };
-        yield return new object[] { false, "Text", null };
-
-        // With mnemonic.
-        yield return new object[] { true, "&", null };
-        yield return new object[] { true, "&&a", null };
-        yield return new object[] { true, "a&", null };
-        yield return new object[] { true, "a&b", "Alt+b" };
-        yield return new object[] { true, "a&bc", "Alt+b" };
-        yield return new object[] { false, "&", null };
-        yield return new object[] { false, "&&a", null };
-        yield return new object[] { false, "a&", null };
-        yield return new object[] { false, "a&b", null };
-        yield return new object[] { false, "a&bc", null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_Get_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_Get_ReturnsExpected(bool useTextForAccessibility, string text, string expected)
-    {
-        using var ownerControl = new SubControl
-        {
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_Get_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_GetWithNonContainerControlParent_IgnoresParent(bool useTextForAccessibility, string text, string expected)
-    {
-        using var parent = new Control();
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_Get_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_GetWithContainerControlParentWithoutPreviousLabel_IgnoresParent(bool useTextForAccessibility, string text, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    public static IEnumerable<object[]> KeyboardShortcut_GetWithPreviousLabel_TestData()
-    {
-        yield return new object[] { true, null, null, null };
-        yield return new object[] { true, null, string.Empty, null };
-        yield return new object[] { true, null, "LabelText", null };
-        yield return new object[] { true, string.Empty, null, null };
-        yield return new object[] { true, string.Empty, string.Empty, null };
-        yield return new object[] { true, string.Empty, "LabelText", null };
-        yield return new object[] { true, "Text", null, null };
-        yield return new object[] { true, "Text", string.Empty, null };
-        yield return new object[] { true, "Text", "LabelText", null };
-        yield return new object[] { false, null, null, null };
-        yield return new object[] { false, null, string.Empty, null };
-        yield return new object[] { false, null, "LabelText", null };
-        yield return new object[] { false, string.Empty, null, null };
-        yield return new object[] { false, string.Empty, string.Empty, null };
-        yield return new object[] { false, string.Empty, "LabelText", null };
-        yield return new object[] { false, "Text", null, null };
-        yield return new object[] { false, "Text", string.Empty, null };
-        yield return new object[] { false, "Text", "LabelText", null };
-
-        // With mnemonic.
-        yield return new object[] { true, "&", null, null };
-        yield return new object[] { true, "&&a", null, null };
-        yield return new object[] { true, "a&", null, null };
-        yield return new object[] { true, "a&b", null, "Alt+b" };
-        yield return new object[] { true, "a&bc", null, "Alt+b" };
-        yield return new object[] { true, null, "&", null };
-        yield return new object[] { true, null, "&&a", null };
-        yield return new object[] { true, null, "a&", null };
-        yield return new object[] { true, null, "a&b", "Alt+b" };
-        yield return new object[] { true, null, "a&bc", "Alt+b" };
-
-        yield return new object[] { false, "&", null, null };
-        yield return new object[] { false, "&&a", null, null };
-        yield return new object[] { false, "a&", null, null };
-        yield return new object[] { false, "a&b", null, null };
-        yield return new object[] { false, "a&bc", null, null };
-        yield return new object[] { false, null, "&", null };
-        yield return new object[] { false, null, "&&a", null };
-        yield return new object[] { false, null, "a&", null };
-        yield return new object[] { false, null, "a&b", "Alt+b" };
-        yield return new object[] { false, null, "a&bc", "Alt+b" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_GetWithPreviousLabel_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_GetWithContainerControlParentWithPreviousLabel_ReturnsExpected(bool useTextForAccessibility, string text, string labelText, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = labelText
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent,
-            Visible = false
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_GetWithPreviousLabel_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_GetWithPreviousNotTabStopAndPreviousLabel_IgnoresPreviousLabel(bool useTextForAccessibility, string text, string labelText, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = labelText
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent,
-            TabStop = false
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyboardShortcut_Get_TestData))]
-    public void ControlAccessibleObject_KeyboardShortcut_GetWithPreviousTabStopVisibleAndPreviousLabel_IgnoresPreviousLabel(bool useTextForAccessibility, string text, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = "LabelText"
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.KeyboardShortcut);
-    }
-
-    public static IEnumerable<object[]> Name_Get_TestData()
-    {
-        yield return new object[] { true, null, null, null };
-        yield return new object[] { true, null, string.Empty, null };
-        yield return new object[] { true, null, "text", "text" };
-        yield return new object[] { true, string.Empty, null, string.Empty };
-        yield return new object[] { true, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { true, string.Empty, "text", string.Empty };
-        yield return new object[] { true, "name", null, "name" };
-        yield return new object[] { true, "name", string.Empty, "name" };
-        yield return new object[] { true, "name", "text", "name" };
-
-        yield return new object[] { false, null, null, null };
-        yield return new object[] { false, null, string.Empty, null };
-        yield return new object[] { false, null, "text", null };
-        yield return new object[] { false, string.Empty, null, string.Empty };
-        yield return new object[] { false, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { false, string.Empty, "text", string.Empty };
-        yield return new object[] { false, "name", null, "name" };
-        yield return new object[] { false, "name", string.Empty, "name" };
-        yield return new object[] { false, "name", "text", "name" };
-
-        // With mnemonic.
-        yield return new object[] { true, "Name1&Name2", "text", "Name1&Name2" };
-        yield return new object[] { true, null, "&", string.Empty };
-        yield return new object[] { true, null, "&&Name", "&Name" };
-        yield return new object[] { true, null, "Name1&Name2", "Name1Name2" };
-        yield return new object[] { true, null, "Name1&Name2&Name3", "Name1Name2Name3" };
-        yield return new object[] { true, null, "Name1&Name2&", "Name1Name2" };
-        yield return new object[] { false, "Name1&Name2", "text", "Name1&Name2" };
-        yield return new object[] { false, null, "&", null };
-        yield return new object[] { false, null, "&&Name", null };
-        yield return new object[] { false, null, "Name1&Name2", null };
-        yield return new object[] { false, null, "Name1&Name2&Name3", null };
-        yield return new object[] { false, null, "Name1&Name2&", null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_Get_TestData))]
-    public void ControlAccessibleObject_Name_Get_ReturnsExpected(bool useTextForAccessibility, string accessibleName, string text, string expected)
-    {
-        using var ownerControl = new SubControl
-        {
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_Get_TestData))]
-    public void ControlAccessibleObject_Name_GetWithNonContainerControlParent_IgnoresParent(bool useTextForAccessibility, string accessibleName, string text, string expected)
-    {
-        using var parent = new Control();
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_Get_TestData))]
-    public void ControlAccessibleObject_Name_GetWithContainerControlParentEmpty_IgnoresParent(bool useTextForAccessibility, string accessibleName, string text, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    public static IEnumerable<object[]> Name_GetWithPreviousLabel_TestData()
-    {
-        yield return new object[] { true, null, null, null, null };
-        yield return new object[] { true, null, null, string.Empty, null };
-        yield return new object[] { true, null, null, "LabelText", "LabelText" };
-        yield return new object[] { true, null, string.Empty, null, null };
-        yield return new object[] { true, null, string.Empty, string.Empty, null };
-        yield return new object[] { true, null, string.Empty, "LabelText", "LabelText" };
-        yield return new object[] { true, null, "text", null, "text" };
-        yield return new object[] { true, null, "text", string.Empty, "text" };
-        yield return new object[] { true, null, "text", "LabelText", "text" };
-        yield return new object[] { true, string.Empty, null, null, string.Empty };
-        yield return new object[] { true, string.Empty, null, string.Empty, string.Empty };
-        yield return new object[] { true, string.Empty, null, "LabelText", string.Empty };
-        yield return new object[] { true, string.Empty, string.Empty, null, string.Empty };
-        yield return new object[] { true, string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { true, string.Empty, string.Empty, "LabelText", string.Empty };
-        yield return new object[] { true, string.Empty, "text", null, string.Empty };
-        yield return new object[] { true, string.Empty, "text", string.Empty, string.Empty };
-        yield return new object[] { true, string.Empty, "text", "LabelText", string.Empty };
-        yield return new object[] { true, "name", null, null, "name" };
-        yield return new object[] { true, "name", null, string.Empty, "name" };
-        yield return new object[] { true, "name", null, "LabelText", "name" };
-        yield return new object[] { true, "name", string.Empty, null, "name" };
-        yield return new object[] { true, "name", string.Empty, string.Empty, "name" };
-        yield return new object[] { true, "name", string.Empty, "LabelText", "name" };
-        yield return new object[] { true, "name", "text", null, "name" };
-        yield return new object[] { true, "name", "text", string.Empty, "name" };
-        yield return new object[] { true, "name", "text", "LabelText", "name" };
-
-        yield return new object[] { false, null, null, null, null };
-        yield return new object[] { false, null, null, string.Empty, null };
-        yield return new object[] { false, null, null, "LabelText", "LabelText" };
-        yield return new object[] { false, null, string.Empty, null, null };
-        yield return new object[] { false, null, string.Empty, string.Empty, null };
-        yield return new object[] { false, null, string.Empty, "LabelText", "LabelText" };
-        yield return new object[] { false, null, "text", null, null };
-        yield return new object[] { false, null, "text", string.Empty, null };
-        yield return new object[] { false, null, "text", "LabelText", "LabelText" };
-        yield return new object[] { false, string.Empty, null, null, string.Empty };
-        yield return new object[] { false, string.Empty, null, string.Empty, string.Empty };
-        yield return new object[] { false, string.Empty, null, "LabelText", string.Empty };
-        yield return new object[] { false, string.Empty, string.Empty, null, string.Empty };
-        yield return new object[] { false, string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { false, string.Empty, string.Empty, "LabelText", string.Empty };
-        yield return new object[] { false, string.Empty, "text", null, string.Empty };
-        yield return new object[] { false, string.Empty, "text", string.Empty, string.Empty };
-        yield return new object[] { false, string.Empty, "text", "LabelText", string.Empty };
-        yield return new object[] { false, "name", null, null, "name" };
-        yield return new object[] { false, "name", null, string.Empty, "name" };
-        yield return new object[] { false, "name", null, "LabelText", "name" };
-        yield return new object[] { false, "name", string.Empty, null, "name" };
-        yield return new object[] { false, "name", string.Empty, string.Empty, "name" };
-        yield return new object[] { false, "name", string.Empty, "LabelText", "name" };
-        yield return new object[] { false, "name", "text", null, "name" };
-        yield return new object[] { false, "name", "text", string.Empty, "name" };
-        yield return new object[] { false, "name", "text", "LabelText", "name" };
-
-        // With mnemonic.
-        yield return new object[] { true, "Name1&Name2", "text", null, "Name1&Name2" };
-        yield return new object[] { true, null, "&", null, string.Empty };
-        yield return new object[] { true, null, "&&Name", null, "&Name" };
-        yield return new object[] { true, null, "Name1&Name2", null, "Name1Name2" };
-        yield return new object[] { true, null, "Name1&Name2&Name3", null, "Name1Name2Name3" };
-        yield return new object[] { true, null, "Name1&Name2&", null, "Name1Name2" };
-        yield return new object[] { true, null, null, "&", string.Empty };
-        yield return new object[] { true, null, null, "&&Name", "&Name" };
-        yield return new object[] { true, null, null, "Name1&Name2", "Name1Name2" };
-        yield return new object[] { true, null, null, "Name1&Name2&Name3", "Name1Name2Name3" };
-        yield return new object[] { true, null, null, "Name1&Name2&", "Name1Name2" };
-        yield return new object[] { false, "Name1&Name2", "text", null, "Name1&Name2" };
-        yield return new object[] { false, null, "&", null, null };
-        yield return new object[] { false, null, "&&Name", null, null };
-        yield return new object[] { false, null, "Name1&Name2", null, null };
-        yield return new object[] { false, null, "Name1&Name2&Name3", null, null };
-        yield return new object[] { false, null, "Name1&Name2&", null, null };
-        yield return new object[] { false, null, null, "&", string.Empty };
-        yield return new object[] { false, null, null, "&&Name", "&Name" };
-        yield return new object[] { false, null, null, "Name1&Name2", "Name1Name2" };
-        yield return new object[] { false, null, null, "Name1&Name2&Name3", "Name1Name2Name3" };
-        yield return new object[] { false, null, null, "Name1&Name2&", "Name1Name2" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_GetWithPreviousLabel_TestData))]
-    public void ControlAccessibleObject_Name_GetWithContainerControlParentWithPreviousLabel_ReturnsExpected(bool useTextForAccessibility, string accessibleName, string text, string labelText, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = labelText
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent,
-            Visible = false
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_GetWithPreviousLabel_TestData))]
-    public void ControlAccessibleObject_Name_GetWithPreviousNotTabStopAndPreviousLabel_ReturnsExpected(bool useTextForAccessibility, string accessibleName, string text, string labelText, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = labelText
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent,
-            TabStop = false
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Name_Get_TestData))]
-    public void ControlAccessibleObject_Name_GetWithPreviousTabStopVisibleAndPreviousLabel_ReturnsExpected(bool useTextForAccessibility, string accessibleName, string text, string expected)
-    {
-        using var parent = new ContainerControl();
-        using var previousLabel = new Label
-        {
-            Parent = parent,
-            Text = "LabelText"
-        };
-        using var previousControl = new Control
-        {
-            Parent = parent
-        };
-        using var ownerControl = new SubControl
-        {
-            Parent = parent,
-            AccessibleName = accessibleName,
-            Text = text
-        };
-        ownerControl.SetStyle(ControlStyles.UseTextForAccessibility, useTextForAccessibility);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_Name_Set_GetReturnsExpected(string value)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        accessibleObject.Name = value;
-        Assert.Equal(value, accessibleObject.Name);
-        Assert.Empty(ownerControl.Name);
-        Assert.Equal(value, ownerControl.AccessibleName);
-
-        // Set same.
-        accessibleObject.Name = value;
-        Assert.Equal(value, accessibleObject.Name);
-        Assert.Empty(ownerControl.Name);
-        Assert.Equal(value, ownerControl.AccessibleName);
-    }
-
-    public static IEnumerable<object[]> Role_Get_TestData()
-    {
-        yield return new object[] { AccessibleRole.None };
-        yield return new object[] { AccessibleRole.TitleBar };
-        yield return new object[] { AccessibleRole.MenuBar };
-        yield return new object[] { AccessibleRole.ScrollBar };
-        yield return new object[] { AccessibleRole.Grip };
-        yield return new object[] { AccessibleRole.Sound };
-        yield return new object[] { AccessibleRole.Cursor };
-        yield return new object[] { AccessibleRole.Caret };
-        yield return new object[] { AccessibleRole.Alert };
-        yield return new object[] { AccessibleRole.Window };
-        yield return new object[] { AccessibleRole.Client };
-        yield return new object[] { AccessibleRole.MenuPopup };
-        yield return new object[] { AccessibleRole.MenuItem };
-        yield return new object[] { AccessibleRole.ToolTip };
-        yield return new object[] { AccessibleRole.Application };
-        yield return new object[] { AccessibleRole.Document };
-        yield return new object[] { AccessibleRole.Pane };
-        yield return new object[] { AccessibleRole.Chart };
-        yield return new object[] { AccessibleRole.Dialog };
-        yield return new object[] { AccessibleRole.Border };
-        yield return new object[] { AccessibleRole.Grouping };
-        yield return new object[] { AccessibleRole.Separator };
-        yield return new object[] { AccessibleRole.ToolBar };
-        yield return new object[] { AccessibleRole.StatusBar };
-        yield return new object[] { AccessibleRole.Table };
-        yield return new object[] { AccessibleRole.ColumnHeader };
-        yield return new object[] { AccessibleRole.RowHeader };
-        yield return new object[] { AccessibleRole.Column };
-        yield return new object[] { AccessibleRole.Row };
-        yield return new object[] { AccessibleRole.Cell };
-        yield return new object[] { AccessibleRole.Link };
-        yield return new object[] { AccessibleRole.HelpBalloon };
-        yield return new object[] { AccessibleRole.Character };
-        yield return new object[] { AccessibleRole.List };
-        yield return new object[] { AccessibleRole.ListItem };
-        yield return new object[] { AccessibleRole.Outline };
-        yield return new object[] { AccessibleRole.OutlineItem };
-        yield return new object[] { AccessibleRole.PageTab };
-        yield return new object[] { AccessibleRole.PropertyPage };
-        yield return new object[] { AccessibleRole.Indicator };
-        yield return new object[] { AccessibleRole.Graphic };
-        yield return new object[] { AccessibleRole.StaticText };
-        yield return new object[] { AccessibleRole.Text };
-        yield return new object[] { AccessibleRole.PushButton };
-        yield return new object[] { AccessibleRole.CheckButton };
-        yield return new object[] { AccessibleRole.RadioButton };
-        yield return new object[] { AccessibleRole.ComboBox };
-        yield return new object[] { AccessibleRole.DropList };
-        yield return new object[] { AccessibleRole.ProgressBar };
-        yield return new object[] { AccessibleRole.Dial };
-        yield return new object[] { AccessibleRole.HotkeyField };
-        yield return new object[] { AccessibleRole.Slider };
-        yield return new object[] { AccessibleRole.SpinButton };
-        yield return new object[] { AccessibleRole.Diagram };
-        yield return new object[] { AccessibleRole.Animation };
-        yield return new object[] { AccessibleRole.Equation };
-        yield return new object[] { AccessibleRole.ButtonDropDown };
-        yield return new object[] { AccessibleRole.ButtonMenu };
-        yield return new object[] { AccessibleRole.ButtonDropDownGrid };
-        yield return new object[] { AccessibleRole.WhiteSpace };
-        yield return new object[] { AccessibleRole.PageTabList };
-        yield return new object[] { AccessibleRole.Clock };
-        yield return new object[] { AccessibleRole.SplitButton };
-        yield return new object[] { AccessibleRole.IpAddress };
-        yield return new object[] { AccessibleRole.OutlineButton };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Role_Get_TestData))]
-    public void ControlAccessibleObject_Role_GetWithAccessibleRole_ReturnsExpected(AccessibleRole accessibleRole)
-    {
-        using var ownerControl = new Control
-        {
-            AccessibleRole = accessibleRole
-        };
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_Value_Set_GetReturnsNull_IfHandleIsCreated(string value)
-    {
-        using var ownerControl = new Control();
-        ownerControl.CreateControl();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        accessibleObject.Value = value;
-        Assert.Null(accessibleObject.Value);
-
-        // Set same.
-        accessibleObject.Value = value;
-        Assert.Null(accessibleObject.Value);
-        Assert.True(ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlAccessibleObject_Value_Set_GetReturnsNull_IfHandleIsNotCreated(string value)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        accessibleObject.Value = value;
-        Assert.Equal(string.Empty, accessibleObject.Value);
-
-        // Set same.
-        accessibleObject.Value = value;
-        Assert.Equal(string.Empty, accessibleObject.Value);
-        Assert.False(ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_DoDefaultAction_InvokeDefault_Nop()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        accessibleObject.DoDefaultAction();
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetChildCount_InvokeDefault_ReturnsMinusOne()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetChildCount_InvokeWithChildren_ReturnsMinusOne()
-    {
-        using var child = new Control();
-        using var ownerControl = new Control();
-        ownerControl.Controls.Add(child);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ControlAccessibleObject_GetChild_InvokeDefault_ReturnsNull(int index)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Null(accessibleObject.GetChild(index));
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetFocused_InvokeDefault_ReturnsNull()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Null(accessibleObject.GetFocused());
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetHelpTopic_InvokeDefault_ReturnsMinusOne()
-    {
-        var accessibleObject = new AccessibleObject();
-        Assert.Equal(-1, accessibleObject.GetHelpTopic(out string fileName));
-        Assert.Null(fileName);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, 0, true, 0)]
-    [InlineData("", "", 0, true, 0)]
-    [InlineData("HelpNamespace", "invalid", 0, true, 0)]
-    [InlineData("HelpNamespace", "1", 1, true, 0)]
-    [InlineData(null, null, 0, false, -1)]
-    [InlineData("", "", 0, false, -1)]
-    [InlineData("HelpNamespace", "invalid", 0, false, -1)]
-    [InlineData("HelpNamespace", "1", 1, false, -1)]
-    public void ControlAccessibleObject_GetHelpTopic_InvokeWithQueryAccessibilityHelpEvent_ReturnsExpected(
-        string helpNamespace,
-        string helpKeyword,
-        int expectedResult,
-        bool createControl,
-        int expectedResultWithoutHandler)
-    {
-        using var ownerControl = new Control();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        int callCount = 0;
-        void handler(object sender, QueryAccessibilityHelpEventArgs e)
-        {
-            Assert.Same(ownerControl, sender);
-            Assert.Null(e.HelpKeyword);
-            Assert.Null(e.HelpNamespace);
-            Assert.Null(e.HelpString);
-
-            e.HelpNamespace = helpNamespace;
-            e.HelpKeyword = helpKeyword;
-            callCount++;
-        }
-
-        ownerControl.QueryAccessibilityHelp += handler;
-
-        // Get with handler.
-        Assert.Equal(expectedResult, accessibleObject.GetHelpTopic(out string fileName));
-        Assert.Equal(helpNamespace, fileName);
-        Assert.Equal(1, callCount);
-
-        // Get again.
-        Assert.Equal(expectedResult, accessibleObject.GetHelpTopic(out fileName));
-        Assert.Equal(helpNamespace, fileName);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        ownerControl.QueryAccessibilityHelp -= handler;
-        Assert.Equal(expectedResultWithoutHandler, accessibleObject.GetHelpTopic(out fileName));
-        Assert.Null(fileName);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetSelected_InvokeDefault_ReturnsNull()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Null(accessibleObject.GetSelected());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -2)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void AccessibleObject_HitTest_InvokeDefault_ReturnsNull(int x, int y)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Null(accessibleObject.HitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleNavigation>]
-    public void AccessibleObject_Navigate_InvokeDefault_ReturnsNull(AccessibleNavigation navdir)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Null(accessibleObject.Navigate(navdir));
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleEvents.Create)]
-    public void ControlAccessibleObject_NotifyClients_InvokeAccessibleEvents_Success(AccessibleEvents accEvent)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        accessibleObject.NotifyClients(accEvent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleEvents.Create, -1)]
-    [InlineData(AccessibleEvents.Create, 0)]
-    [InlineData(AccessibleEvents.Create, 1)]
-    public void ControlAccessibleObject_NotifyClients_InvokeAccessibleEventsInt_Success(AccessibleEvents accEvent, int childID)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        accessibleObject.NotifyClients(accEvent, childID);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleEvents.Create, -1, -1)]
-    [InlineData(AccessibleEvents.Create, 1, 0)]
-    [InlineData(AccessibleEvents.Create, 2, 1)]
-    public void ControlAccessibleObject_NotifyClients_InvokeAccessibleEventsIntInt_Success(AccessibleEvents accEvent, int objectID, int childID)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        accessibleObject.NotifyClients(accEvent, objectID, childID);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_RaiseLiveRegionChanged_Invoke_Success()
-    {
-        using var ownerControl = new AutomationLiveRegionControl();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        accessibleObject.RaiseLiveRegionChanged();
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_RaiseLiveRegionChanged_InvokeNotIAutomationLiveRegion_ThrowsInvalidOperationException()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.RaiseLiveRegionChanged());
-    }
-
-    [WinFormsTheory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public void ControlAccessibleObject_RaiseAutomationEvent_IsHandleCreatedFlag(bool isHandleCreated)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        Assert.False(ownerControl.IsHandleCreated);
-
-        if (isHandleCreated)
-        {
-            Assert.NotEqual(IntPtr.Zero, ownerControl.Handle);
-        }
-
-        Assert.Equal(isHandleCreated, accessibleObject.RaiseAutomationEvent(UiaCore.UIA.AutomationPropertyChangedEventId));
-        Assert.Equal(isHandleCreated, ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public void ControlAccessibleObject_RaiseAutomationPropertyChangedEvent_IsHandleCreatedFlag(bool isHandleCreated)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-
-        Assert.False(ownerControl.IsHandleCreated);
-
-        if (isHandleCreated)
-        {
-            Assert.NotEqual(IntPtr.Zero, ownerControl.Handle);
-        }
-
-        Assert.Equal(isHandleCreated, accessibleObject.RaiseAutomationPropertyChangedEvent(UiaCore.UIA.NamePropertyId, ownerControl.Name, ownerControl.Name));
-        Assert.Equal(isHandleCreated, ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_ToString_Invoke_Success()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal("ControlAccessibleObject: Owner = System.Windows.Forms.Control", accessibleObject.ToString());
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_IAccessibleaccFocus_InvokeDefault_ReturnsNull()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Null(iAccessible.accFocus);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -1, -2, 0)]
-    [InlineData(true, 0, 0, 0)]
-    [InlineData(true, 1, 2, 0)]
-    [InlineData(false, -1, -2, null)]
-    [InlineData(false, 0, 0, null)]
-    [InlineData(false, 1, 2, null)]
-    public void AccessibleObject_IAccessibleaccHitTest_InvokeDefault_ReturnsExpectedValue(bool createControl, int x, int y, int? expectedValue)
-    {
-        using var ownerControl = new Control();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Equal(expectedValue, iAccessible.accHitTest(x, y));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ControlAccessibleObject_IAccessibleaccParent_InvokeDefault_ReturnsExpectedValue(bool createControl)
-    {
-        using var ownerControl = new Control();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Equal(createControl, iAccessible.accParent is not null);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_IAccessibleaccSelection_InvokeDefault_ReturnsNull()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Null(iAccessible.accSelection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ControlAccessibleObject_IAccessibleget_accChild_InvokeNoSuchChild_ReturnsNull(int childID)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Null(iAccessible.get_accChild(childID));
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_IAccessibleget_accChildCount_InvokeDefault_ReturnsExpected()
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Equal(0, iAccessible.accChildCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ControlAccessibleObject_IAccessibleget_accChildCount_InvokeWithChildren_ReturnsExpected(bool createControl, int expectedCount)
-    {
-        using var child = new Control();
-        using var ownerControl = new Control();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        ownerControl.Controls.Add(child);
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Equal(expectedCount, iAccessible.accChildCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ControlAccessibleObject_IAccessibleget_accRole_InvokeNoSuchChild_ReturnsNull(object varChild)
-    {
-        using var ownerControl = new Control();
-        var accessibleObject = new Control.ControlAccessibleObject(ownerControl);
-        IAccessible iAccessible = accessibleObject;
-        Assert.Null(iAccessible.get_accRole(varChild));
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_DoesntSupport_LegacyIAccessiblePattern()
-    {
-        using var control = new Control();
-        var accessibleObject = control.AccessibilityObject;
-
-        bool expected = control.SupportsUiaProviders;
-        Assert.False(expected);
-
-        bool actual = accessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId);
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_Supports_LegacyIAccessiblePattern_IfOwnerSupportsUia()
-    {
-        using var control = new Label();
-        var accessibleObject = new Control.ControlAccessibleObject(control);
-
-        Assert.True(control.SupportsUiaProviders);
-        bool actual = accessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId);
-        Assert.True(actual);
-    }
-
-    public static IEnumerable<object[]> ControlAccessibleObject_TestData()
-    {
-        return ReflectionHelper.GetPublicNotAbstractClasses<Control>().Select(type => new object[] { type });
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_Custom_Role_ReturnsExpected(Type type)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        control.AccessibleRole = AccessibleRole.Link;
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-
-        var accessibleObjectRole = controlAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_GetPropertyValue_AccessKey_ReturnExpected(Type type)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        if (!s_controlsIgnoringTextChangesForTests.Contains(type))
-        {
-            control.Text = "&Name";
-        }
-
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-        string expectedValue = s_controlsNotUseTextForAccessibility.Contains(type) ? string.Empty : "Alt+n";
-
-        Assert.Equal(expectedValue, controlAccessibleObject.GetPropertyValue(UiaCore.UIA.AccessKeyPropertyId));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue(Type type)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = controlAccessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_Custom_Description_ReturnsExpected(Type type)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        control.AccessibleDescription = "Test Accessible Description";
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-
-        var accessibleObjectDescription = controlAccessibleObject.Description;
-
-        Assert.Equal("Test Accessible Description", accessibleObjectDescription);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected(Type type)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-        control.Name = "Name1";
-        control.AccessibleName = "Test Name";
-
-        Assert.Equal("Test Name", controlAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.Equal("Test Name", controlAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-    }
-
-    public static IEnumerable<object[]> ControlAccessibleObject_DefaultName_TestData()
-    {
-        // These controls have AccessibleName defined.
-        // MonthCalendar has "Month" view by default and returns current date as AccessibleName
-        var typeDefaultValues = new Dictionary<Type, string>
-        {
-            { typeof(DataGridViewTextBoxEditingControl), SR.DataGridView_AccEditingControlAccName },
-            { typeof(DateTimePicker), string.Empty },
-            { typeof(PrintPreviewDialog), SR.PrintPreviewDialog_PrintPreview },
-            { typeof(TextBox), string.Empty },
-            { typeof(MaskedTextBox), string.Empty }
-        };
-
-        foreach (Type type in ReflectionHelper.GetPublicNotAbstractClasses<Control>())
-        {
-            yield return new object[]
-            {
-                type,
-                typeDefaultValues.ContainsKey(type) ? typeDefaultValues[type] : null
-            };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_DefaultName_TestData))]
-    public void ControlAccessibleObject_GetPropertyValue_Default_Name_ReturnsExpected(Type type, string expectedName)
-    {
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        if (!control.SupportsUiaProviders)
-        {
-            return;
-        }
-
-        AccessibleObject controlAccessibleObject = control.AccessibilityObject;
-        Assert.Equal(expectedName, controlAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-    }
-
-    public static IEnumerable<object[]> ControlAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue_TestData))]
-    public void ControlAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue(AccessibleRole role)
-    {
-        using Control control = new Control();
-        control.AccessibleRole = role;
-
-        UiaCore.UIA actual = (UiaCore.UIA)control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        // Check if the method returns an exist UIA_ControlTypeId
-        Assert.True(actual >= UiaCore.UIA.ButtonControlTypeId && actual <= UiaCore.UIA.AppBarControlTypeId);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentRoot_IsNullOrOwnObject(Type type)
-    {
-        using NoAssertContext context = new();
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment actual = control.AccessibilityObject.FragmentRoot;
-
-        Assert.True(actual is null || actual == control.AccessibilityObject);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentRoot_IsToolStrip_IfControlIsUsedAsToolStripItem(Type type)
-    {
-        using NoAssertContext context = new();
-        using ToolStrip toolStrip = new();
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        using ToolStripControlHost host = new(control);
-
-        toolStrip.CreateControl();
-        control.CreateControl();
-
-        if (!CanBeAddedToToolStrip(control))
-        {
-            // A number of controls can't be added to ToolStrip. Double verify it is still the case, and exit.
-            Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host));
-
-            return;
-        }
-
-        toolStrip.Items.Add(host);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment actual = ((UiaCore.IRawElementProviderFragment)control.AccessibilityObject).FragmentRoot;
-
-        Assert.Equal(toolStrip.AccessibilityObject, actual);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentNavigate_Parent_IsNull(Type type)
-    {
-        using NoAssertContext context = new();
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment parent
-            = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.True(parent is null);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentNavigate_Siblings_AreNull(Type type)
-    {
-        using NoAssertContext context = new();
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment nextSibling
-            = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        UiaCore.IRawElementProviderFragment previousSibling
-            = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.True(nextSibling is null);
-        Assert.True(previousSibling is null);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentNavigate_ParentIsToolStrip_IfControlIsUsedAsToolStripItem(Type type)
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStrip toolStrip = new() { Size = new Drawing.Size(1000, 25) };
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        using ToolStripControlHost host = new(control);
-
-        toolStrip.CreateControl();
-        control.CreateControl();
-
-        if (!CanBeAddedToToolStrip(control))
-        {
-            // A number of controls can't be added to ToolStrip. Double verify it is still the case, and exit.
-            Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host));
-
-            return;
-        }
-
-        toolStrip.Items.Add(host);
-        ((ToolStripItem)host).TestAccessor().Dynamic._parent = toolStrip;
-        host.SetPlacement(ToolStripItemPlacement.Main);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment actual = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-        AccessibleObject expected = toolStrip.AccessibilityObject;
-
-        Assert.Equal(expected, actual);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentNavigate_NextSibling_IsNextItem_IfControlIsUsedAsToolStripItem(Type type)
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStrip toolStrip = new() { Size = new Drawing.Size(1000, 25) };
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        using ToolStripControlHost host = new(control);
-        using ToolStripLabel label = new();
-        using ToolStripButton button = new();
-
-        toolStrip.CreateControl();
-        control.CreateControl();
-        toolStrip.Items.Add(label);
-
-        if (!CanBeAddedToToolStrip(control))
-        {
-            // A number of controls can't be added to ToolStrip. Double verify it is still the case, and exit.
-            Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host));
-
-            return;
-        }
-
-        toolStrip.Items.Add(host);
-        toolStrip.Items.Add(button);
-        ((ToolStripItem)host).TestAccessor().Dynamic._parent = toolStrip;
-        host.SetPlacement(ToolStripItemPlacement.Main);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment actual = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject expected = button.AccessibilityObject;
-
-        Assert.Equal(expected, actual);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_FragmentNavigate_PreviousSibling_IsPreviousItem_IfControlIsUsedAsToolStripItem(Type type)
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStrip toolStrip = new() { Size = new Drawing.Size(1000, 25) };
-        using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        using ToolStripControlHost host = new(control);
-        using ToolStripLabel label = new();
-
-        toolStrip.CreateControl();
-        control.CreateControl();
-        toolStrip.Items.Add(label);
-
-        if (!CanBeAddedToToolStrip(control))
-        {
-            // A number of controls can't be added to ToolStrip. Double verify it is still the case, and exit.
-            Assert.Throws<ArgumentException>(() => toolStrip.Items.Add(host));
-
-            return;
-        }
-
-        toolStrip.Items.Add(host);
-        ((ToolStripItem)host).TestAccessor().Dynamic._parent = toolStrip;
-        host.SetPlacement(ToolStripItemPlacement.Main);
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        UiaCore.IRawElementProviderFragment actual = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject expected = label.AccessibilityObject;
-
-        Assert.Equal(expected, actual);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_GetPropertyValue_AutomationId_ReturnsExpected()
-    {
-        using Control ownerControl = new() { Name = "test name" };
-        string expected = ownerControl.Name;
-        object actual = ownerControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.False(ownerControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlAccessibleObject_DoesNotRootControl()
-    {
-        Control.ControlAccessibleObject accessibleObject = CreateAndDisposeControl();
-        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true);
-        Assert.False(accessibleObject.TryGetOwnerAs(out Control _));
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static Control.ControlAccessibleObject CreateAndDisposeControl()
-        {
-            using Control control = new();
-            var accessibleObject = (Control.ControlAccessibleObject)control.AccessibilityObject;
-            Assert.NotNull(accessibleObject);
-            Assert.True(accessibleObject.TryGetOwnerAs(out Control _));
-
-            return accessibleObject;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_TestData))]
-    public void ControlAccessibleObject_DoesNotRootControls_AllPublicControl(Type type)
-    {
-        Control.ControlAccessibleObject accessibleObject = CreateAndDisposeControl(type);
-        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true);
-        Assert.False(accessibleObject.TryGetOwnerAs(out Control _));
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static Control.ControlAccessibleObject CreateAndDisposeControl(Type type)
-        {
-            using Control control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-            var accessibleObject = (Control.ControlAccessibleObject)control.AccessibilityObject;
-            Assert.NotNull(accessibleObject);
-            Assert.True(accessibleObject.TryGetOwnerAs(out Control _));
-
-            return accessibleObject;
-        }
-    }
-
-    public static IEnumerable<object[]> ControlAccessibleObject_Name_KeyboardShortcut_TestData()
-    {
-        // Controls that have UseMnemonic property.
-        yield return new object[] { typeof(Label) };
-        yield return new object[] { typeof(LinkLabel) };
-        yield return new object[] { typeof(Button) };
-        yield return new object[] { typeof(RadioButton) };
-        yield return new object[] { typeof(CheckBox) };
-    }
-
-    // Unit test for https://github.com/dotnet/winforms/issues/9296
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_Name_KeyboardShortcut_TestData))]
-    public void ControlAccessibleObject_Shortcut_Invoke_ReturnsExpected(Type type)
-    {
-        using var control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        control.Text = "&control";
-        control.TabIndex = 1;
-        var accessibleObject = control.AccessibilityObject;
-
-        Assert.Equal("Alt+c", accessibleObject.KeyboardShortcut);
-
-        control.GetType().GetProperty(nameof(Label.UseMnemonic)).SetValue(control, false);
-
-        Assert.Null(accessibleObject.KeyboardShortcut);
-
-        if (control is not Label)
-        {
-            using var form = new Form();
-            using var label = new Label();
-            label.Text = "&label";
-            label.TabIndex = 0;
-
-            form.Controls.Add(label);
-            form.Controls.Add(control);
-            form.Show();
-
-            Assert.Equal("Alt+l", accessibleObject.KeyboardShortcut);
-
-            label.UseMnemonic = false;
-
-            Assert.Null(accessibleObject.KeyboardShortcut);
-
-            control.GetType().GetProperty(nameof(Label.UseMnemonic)).SetValue(control, true);
-
-            Assert.Equal("Alt+c", accessibleObject.KeyboardShortcut);
-
-            control.Text = "control";
-            label.UseMnemonic = true;
-
-            Assert.Equal("Alt+l", accessibleObject.KeyboardShortcut);
-        }
-    }
-
-    // Unit test for https://github.com/dotnet/winforms/issues/9296
-    [WinFormsTheory]
-    [MemberData(nameof(ControlAccessibleObject_Name_KeyboardShortcut_TestData))]
-    public void ControlAccessibleObject_Name_Invoke_ReturnsExpected(Type type)
-    {
-        using var control = ReflectionHelper.InvokePublicConstructor<Control>(type);
-        control.Text = "&control";
-        var accessibleObject = control.AccessibilityObject;
-
-        Assert.Equal("control", accessibleObject.Name);
-
-        control.GetType().GetProperty(nameof(Label.UseMnemonic)).SetValue(control, false);
-
-        Assert.Equal("&control", accessibleObject.Name);
-
-        accessibleObject.Name = "CustomName";
-
-        Assert.Equal("CustomName", accessibleObject.Name);
-
-        control.GetType().GetProperty(nameof(Label.UseMnemonic)).SetValue(control, true);
-
-        Assert.Equal("CustomName", accessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    // ContextMenuStrip, From, ToolStripDropDown, ToolStripDropDownMenu
-    // are Top level controls that can't be added to a ToolStrip.
-    // A TabPage can be added to a TabControl only (see TabPage.AssignParent method).
-    private bool CanBeAddedToToolStrip(Control control)
-        => !(control is ContextMenuStrip
-            || control is Form
-            || control is ToolStripDropDown
-            || control is ToolStripDropDownMenu
-            || control is TabPage);
-
-    private class AutomationLiveRegionControl : Control, IAutomationLiveRegion
-    {
-        public AutomationLiveSetting LiveSetting { get; set; }
-    }
-
-    private class SubControl : Control
-    {
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlBindingsCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlBindingsCollectionTests.cs
deleted file mode 100644
index dc1e202b4e1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlBindingsCollectionTests.cs
+++ /dev/null
@@ -1,422 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class ControlBindingsCollectionTests
-{
-    public static IEnumerable<object[]> Ctor_IBindableComponent_TestData()
-    {
-        var mockBindableComponent = new Mock<IBindableComponent>(MockBehavior.Strict);
-        mockBindableComponent.Setup(c => c.Dispose());
-        yield return new object[] { mockBindableComponent.Object, null };
-
-        var control = new Control();
-        yield return new object[] { control, control };
-        yield return new object[] { null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_IBindableComponent_TestData))]
-    public void Ctor_IBindableComponent(IBindableComponent control, Control expectedControl)
-    {
-        var collection = new ControlBindingsCollection(control);
-        Assert.Same(control, collection.BindableComponent);
-        Assert.Same(expectedControl, collection.Control);
-        Assert.Equal(DataSourceUpdateMode.OnValidation, collection.DefaultDataSourceUpdateMode);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataSourceUpdateMode>]
-    [InvalidEnumData<DataSourceUpdateMode>]
-    public void DefaultDataSourceUpdateMode_Set_GetReturnsExpected(DataSourceUpdateMode value)
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control)
-        {
-            DefaultDataSourceUpdateMode = value
-        };
-        Assert.Equal(value, collection.DefaultDataSourceUpdateMode);
-    }
-
-    public static IEnumerable<object[]> Add_Binding_TestData()
-    {
-        yield return new object[] { new Binding(null, new object(), "dataMember") };
-        yield return new object[] { new Binding("", new object(), "dataMember") };
-        yield return new object[] { new Binding(nameof(Control.Text), new object(), "dataMember") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Binding_TestData))]
-    public void Add_Binding_Success(Binding binding)
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control)
-        {
-            binding
-        };
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-    }
-
-    [WinFormsFact]
-    public void Add_DuplicateBinding_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding1 = new Binding("", 1, "dataMember");
-        var binding2 = new Binding(null, 1, "dataMember");
-        var binding3 = new Binding(nameof(Control.Text), 1, "dataMember");
-        collection.Add(binding1);
-        collection.Add(binding2);
-        collection.Add(binding3);
-
-        var binding4 = new Binding(nameof(Control.Text), 1, "dataMember");
-        collection.Add(binding4);
-        Assert.Equal(4, collection.Count);
-        Assert.Same(binding1, collection[0]);
-        Assert.Same(binding2, collection[1]);
-        Assert.Same(binding3, collection[2]);
-        Assert.Same(binding4, collection[3]);
-    }
-
-    [WinFormsFact]
-    public void Add_FormControl_Success()
-    {
-        using var control = new Form();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(nameof(Control.Text), 1, "dataMember");
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void Add_ControlBindings_Success()
-    {
-        using var control = new SubControl();
-        ControlBindingsCollection collection = control.DataBindings;
-        var binding1 = new Binding(nameof(SubControl.Text), 1, "dataMember");
-        var binding2 = new Binding(nameof(SubControl.AccessibleRole), 1, "dataMember");
-        var binding3 = new Binding(null, 1, "dataMember");
-        var binding4 = new Binding("", 1, "dataMember");
-        var binding5 = new Binding(nameof(SubControl.text), 1, "dataMember");
-
-        collection.Add(binding1);
-        collection.Add(binding2);
-        collection.Add(binding3);
-        collection.Add(binding4);
-        collection.Add(binding5);
-        Assert.Equal(5, collection.Count);
-        Assert.Same(binding1, collection[0]);
-        Assert.Same(binding2, collection[1]);
-        Assert.Same(binding3, collection[2]);
-        Assert.Same(binding4, collection[3]);
-        Assert.Same(binding5, collection[4]);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectString_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember");
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.False(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnValidation, binding.DataSourceUpdateMode);
-        Assert.Null(binding.NullValue);
-        Assert.Empty(binding.FormatString);
-        Assert.Null(binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectStringBool_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember", true);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.True(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnValidation, binding.DataSourceUpdateMode);
-        Assert.Null(binding.NullValue);
-        Assert.Empty(binding.FormatString);
-        Assert.Null(binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectStringBoolDataSourceUpdateMode_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.True(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnPropertyChanged, binding.DataSourceUpdateMode);
-        Assert.Null(binding.NullValue);
-        Assert.Empty(binding.FormatString);
-        Assert.Null(binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectStringBoolDataSourceUpdateModeObject_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null");
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.True(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnPropertyChanged, binding.DataSourceUpdateMode);
-        Assert.Equal("null", binding.NullValue);
-        Assert.Empty(binding.FormatString);
-        Assert.Null(binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectStringBoolDataSourceUpdateModeObjectString_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString");
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.True(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnPropertyChanged, binding.DataSourceUpdateMode);
-        Assert.Equal("null", binding.NullValue);
-        Assert.Equal("formatString", binding.FormatString);
-        Assert.Null(binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_StringObjectStringBoolDataSourceUpdateModeObjectStringIFormatProvider_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Binding binding = collection.Add(nameof(Control.Text), 1, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString", CultureInfo.CurrentCulture);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-        Assert.Equal(nameof(Control.Text), binding.PropertyName);
-        Assert.Equal(1, binding.DataSource);
-        Assert.True(binding.FormattingEnabled);
-        Assert.Equal(DataSourceUpdateMode.OnPropertyChanged, binding.DataSourceUpdateMode);
-        Assert.Equal("null", binding.NullValue);
-        Assert.Equal("formatString", binding.FormatString);
-        Assert.Equal(CultureInfo.CurrentCulture, binding.FormatInfo);
-    }
-
-    [WinFormsFact]
-    public void Add_NullDataSource_ThrowsArgumentNullException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember"));
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember", true));
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged));
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null"));
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString"));
-        Assert.Throws<ArgumentNullException>("dataSource", () => collection.Add("propertyName", null, "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString", CultureInfo.CurrentCulture));
-    }
-
-    [WinFormsFact]
-    public void Add_InvalidBinding_ThrowsArgumentException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add(new Binding("NoSuchProperty", new object(), "dataMember")));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember"));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember", true));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null"));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString"));
-        Assert.Throws<ArgumentException>("PropertyName", () => collection.Add("NoSuchProperty", new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString", CultureInfo.CurrentCulture));
-    }
-
-    [WinFormsFact]
-    public void Add_DuplicateBinding_ThrowsArgumentException()
-    {
-        using var control = new Control();
-        ControlBindingsCollection collection = control.DataBindings;
-        var binding = new Binding(nameof(Control.Text), new object(), "dataMember");
-        collection.Add(binding);
-
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(new Binding(nameof(Control.Text), new object(), "dataMember")));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember"));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember", true));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null"));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString"));
-        Assert.Throws<ArgumentException>("binding", () => collection.Add(nameof(Control.Text), new object(), "dataMember", true, DataSourceUpdateMode.OnPropertyChanged, "null", "formatString", CultureInfo.CurrentCulture));
-    }
-
-    [WinFormsFact]
-    public void Add_NullDataBinding_ThrowsArgumentNullException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void Add_AddAlreadyInSameManager_ThrowsArgumentException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Throws<ArgumentException>("dataBinding", () => collection.Add(binding));
-    }
-
-    [WinFormsFact]
-    public void Add_AlreadyInDifferentManager_ThrowsArgumentException()
-    {
-        using var control1 = new Control();
-        using var control2 = new Control();
-        var collection1 = new ControlBindingsCollection(control1);
-        var collection2 = new ControlBindingsCollection(control2);
-        var binding = new Binding(null, new object(), "member");
-
-        collection1.Add(binding);
-        Assert.Throws<ArgumentException>("dataBinding", () => collection2.Add(binding));
-    }
-
-    [WinFormsFact]
-    public void Clear_Invoke_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(binding.BindableComponent);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void Remove_Invoke_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-
-        collection.Remove(binding);
-        Assert.Empty(collection);
-        Assert.Null(binding.BindableComponent);
-    }
-
-    [WinFormsFact]
-    public void Remove_NullDataBinding_ThrowsArgumentNullException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(null, new object(), "member");
-        collection.Add(binding);
-
-        Assert.Throws<ArgumentNullException>("dataBinding", () => collection.Remove(null));
-        Assert.Same(binding, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void Remove_NoSuchDataBinding_ThrowsArgumentException()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection.Add(binding1);
-
-        Assert.Throws<ArgumentException>("dataBinding", () => collection.Remove(binding2));
-        Assert.Same(binding1, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void Remove_DataBindingFromOtherCollection_ThrowsArgumentException()
-    {
-        using var control1 = new Control();
-        using var control2 = new Control();
-        var collection1 = new ControlBindingsCollection(control1);
-        var collection2 = new ControlBindingsCollection(control2);
-        var binding1 = new Binding(null, new object(), "member");
-        var binding2 = new Binding(null, new object(), "member");
-        collection1.Add(binding1);
-        collection2.Add(binding2);
-
-        Assert.Throws<ArgumentException>("dataBinding", () => collection2.Remove(binding1));
-        Assert.Same(binding1, Assert.Single(collection1));
-        Assert.Same(binding2, Assert.Single(collection2));
-    }
-
-    [WinFormsFact]
-    public void RemoveAt_Invoke_Success()
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(null, new object(), "member");
-
-        collection.Add(binding);
-        Assert.Same(binding, Assert.Single(collection));
-        Assert.Same(control, binding.BindableComponent);
-
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(binding.BindableComponent);
-    }
-
-    [WinFormsTheory]
-    [InlineData("text")]
-    [InlineData("TEXT")]
-    public void Item_PropertyNameExists_ReturnsExpected(string propertyName)
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(nameof(Control.Text), new object(), "member");
-        collection.Add(binding);
-        Assert.Same(binding, collection[propertyName]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchProperty")]
-    public void Item_NoSuchPropertyName_ReturnsNull(string propertyName)
-    {
-        using var control = new Control();
-        var collection = new ControlBindingsCollection(control);
-        var binding = new Binding(nameof(Control.Text), new object(), "member");
-        collection.Add(binding);
-        Assert.Null(collection[propertyName]);
-    }
-
-    private class SubControl : Control
-    {
-        public string text { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlEventArgsTests.cs
deleted file mode 100644
index 0ae02959839..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlEventArgsTests.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ControlEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Control_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Button() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_TestData))]
-    public void Ctor_Control(Control control)
-    {
-        var e = new ControlEventArgs(control);
-        Assert.Equal(control, e.Control);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.Rendering.cs
deleted file mode 100644
index cb21560b571..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.Rendering.cs
+++ /dev/null
@@ -1,370 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Numerics;
-using System.Windows.Forms.Metafiles;
-using static System.Windows.Forms.Metafiles.DataHelpers;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlPaintTests
-{
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_Solid_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, Color.Blue, ButtonBorderStyle.Solid);
-
-        emf.Validate(
-            state,
-            Validate.Rectangle(
-                // We match the legacy GDI+ rendering, where the right and bottom are drawn inside the bounds
-                new Rectangle(10, 10, 9, 9),
-                State.Pen(1, Color.Blue, PEN_STYLE.PS_SOLID)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_Inset_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, Color.Gray, ButtonBorderStyle.Inset);
-
-        // For whatever reason GDI+ renders as polylines scaled 16x with a 1/16th world transform applied.
-        // For test readability we'll transform the points from our coordinates to the logical coordinates.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-        Matrix3x2 times16 = Matrix3x2.CreateScale(16.0f);
-
-        // This is the default pen style GDI+ renders polylines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-            state,
-            // Top
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 19, 10),
-                State.Pen(16, ControlPaint.DarkDark(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)),
-            // Left
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 10, 19),
-                State.Pen(16, ControlPaint.DarkDark(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 19, 19, 19),
-                State.Pen(16, ControlPaint.LightLight(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)),
-            // Right
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 19, 10, 19, 19),
-                State.Pen(16, ControlPaint.LightLight(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)),
-            // Top inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 18, 11),
-                State.Pen(16, ControlPaint.Light(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)),
-            // Left inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 11, 18),
-                State.Pen(16, ControlPaint.Light(Color.Gray), penStyle),
-                State.Transform(oneSixteenth)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_Inset_ControlColor_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, SystemColors.Control, ButtonBorderStyle.Inset);
-
-        // For whatever reason GDI+ renders as polylines scaled 16x with a 1/16th world transform applied.
-        // For test readability we'll transform the points from our coordinates to the logical coordinates.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-        Matrix3x2 times16 = Matrix3x2.CreateScale(16.0f);
-
-        // This is the default pen style GDI+ renders polylines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-            state,
-            // Top
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 19, 10),
-                State.Pen(16, ControlPaint.DarkDark(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-            // Left
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 10, 19),
-                State.Pen(16, ControlPaint.DarkDark(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 19, 19, 19),
-                State.Pen(16, ControlPaint.LightLight(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-            // Right
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 19, 10, 19, 19),
-                State.Pen(16, ControlPaint.LightLight(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-            // Top inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 18, 11),
-                State.Pen(16, ControlPaint.Light(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-            // Left inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 11, 18),
-                State.Pen(16, ControlPaint.Light(SystemColors.Control), penStyle),
-                State.Transform(oneSixteenth)),
-
-            // The bottom/right insets are only drawn if the original color was SystemColors.Control.
-
-            // Bottom inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 18, 18, 18),
-                State.Pen(16, SystemColors.ControlLight, penStyle),
-                State.Transform(oneSixteenth)),
-            // Right inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 18, 11, 18, 18),
-                State.Pen(16, SystemColors.ControlLight, penStyle),
-                State.Transform(oneSixteenth)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_OutSet_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, Color.PeachPuff, ButtonBorderStyle.Outset);
-
-        string dump = emf.RecordsToStringWithState(state);
-
-        // For whatever reason GDI+ renders as polylines scaled 16x with a 1/16th world transform applied.
-        // For test readability we'll transform the points from our coordinates to the logical coordinates.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-        Matrix3x2 times16 = Matrix3x2.CreateScale(16.0f);
-
-        // This is the default pen style GDI+ renders polylines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-            state,
-            // Top
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 19, 10),
-                State.Pen(16, ControlPaint.LightLight(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)),
-            // Left
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 10, 19),
-                State.Pen(16, ControlPaint.LightLight(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 19, 19, 19),
-                State.Pen(16, ControlPaint.DarkDark(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)),
-            // Right
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 19, 10, 19, 19),
-                State.Pen(16, ControlPaint.DarkDark(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)),
-            // Top inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 18, 11),
-                State.Pen(16, Color.PeachPuff, penStyle),
-                State.Transform(oneSixteenth)),
-            // Left inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 11, 18),
-                State.Pen(16, Color.PeachPuff, penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 18, 18, 18),
-                State.Pen(16, ControlPaint.Dark(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)),
-            // Right inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 18, 11, 18, 18),
-                State.Pen(16, ControlPaint.Dark(Color.PeachPuff), penStyle),
-                State.Transform(oneSixteenth)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_OutSet_ControlColor_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, SystemColors.Control, ButtonBorderStyle.Outset);
-
-        string dump = emf.RecordsToStringWithState(state);
-
-        // For whatever reason GDI+ renders as polylines scaled 16x with a 1/16th world transform applied.
-        // For test readability we'll transform the points from our coordinates to the logical coordinates.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-        Matrix3x2 times16 = Matrix3x2.CreateScale(16.0f);
-
-        // This is the default pen style GDI+ renders polylines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-            state,
-            // Top
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 19, 10),
-                State.Pen(16, SystemColors.ControlLightLight, penStyle),
-                State.Transform(oneSixteenth)),
-            // Left
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 10, 10, 19),
-                State.Pen(16, SystemColors.ControlLightLight, penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 10, 19, 19, 19),
-                State.Pen(16, SystemColors.ControlDarkDark, penStyle),
-                State.Transform(oneSixteenth)),
-            // Right
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 19, 10, 19, 19),
-                State.Pen(16, SystemColors.ControlDarkDark, penStyle),
-                State.Transform(oneSixteenth)),
-            // Top inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 18, 11),
-                State.Pen(16, SystemColors.Control, penStyle),
-                State.Transform(oneSixteenth)),
-            // Left inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 11, 11, 18),
-                State.Pen(16, SystemColors.Control, penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 11, 18, 18, 18),
-                State.Pen(16, SystemColors.ControlDark, penStyle),
-                State.Transform(oneSixteenth)),
-            // Right inset
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 18, 11, 18, 18),
-                State.Pen(16, SystemColors.ControlDark, penStyle),
-                State.Transform(oneSixteenth)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_Dotted_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, Color.Green, ButtonBorderStyle.Dotted);
-
-        // For whatever reason GDI+ renders as polygons scaled 16x with a 1/16th world transform applied.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-
-        // This is the default pen style GDI+ renders dotted lines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_BEVEL | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-        state,
-            Validate.PolyPolygon16(
-                new Rectangle(8, 8, 13, 13),
-                polyCount: 18,
-                State.Transform(oneSixteenth),
-                State.Pen(16, Color.Green, penStyle),
-                State.Brush(Color.Green, BRUSH_STYLE.BS_SOLID)));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawBorder_Dashed_Rendering()
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        using Graphics graphics = Graphics.FromHdc((IntPtr)emf.HDC);
-
-        Rectangle bounds = new Rectangle(10, 10, 10, 10);
-        ControlPaint.DrawBorder(graphics, bounds, Color.Pink, ButtonBorderStyle.Dashed);
-
-        // For whatever reason GDI+ renders as polygons scaled 16x with a 1/16th world transform applied.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-
-        // This is the default pen style GDI+ renders dotted lines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_BEVEL | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-        state,
-            Validate.PolyPolygon16(
-                new Rectangle(8, 8, 13, 13),
-                polyCount: 9,
-                State.Transform(oneSixteenth),
-                State.Pen(16, Color.Pink, penStyle),
-                State.Brush(Color.Pink, BRUSH_STYLE.BS_SOLID)));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.cs
deleted file mode 100644
index 6dd60132af5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlPaintTests.cs
+++ /dev/null
@@ -1,2304 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Imaging;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlPaintTests
-{
-    public static IEnumerable<object[]> ControlCreateHBitmap16Bit_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format1bppIndexed), Color.Empty };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), Color.Empty };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), Color.Empty };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format1bppIndexed), Color.Red };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), Color.Red };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), Color.Red };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format1bppIndexed), Color.Transparent };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), Color.Transparent };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), Color.Transparent };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format1bppIndexed), Color.Red };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppRgb), Color.Red };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppArgb), Color.Red };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format1bppIndexed), Color.Red };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppRgb), Color.Red };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppArgb), Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlCreateHBitmap16Bit_TestData))]
-    public void ControlPaint_CreateHBitmap16Bit_Invoke_ReturnsExpected(Bitmap bitmap, Color background)
-    {
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmap16Bit(bitmap, background);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format16bppRgb555, result.PixelFormat);
-            Assert.Empty(result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmap16Bit_InvokeSpecificPixels_Success()
-    {
-        using var bitmap = new Bitmap(3, 1);
-        bitmap.SetPixel(0, 0, Color.FromArgb(255, 50, 100, 150));
-        bitmap.SetPixel(1, 0, Color.FromArgb(1, 50, 100, 150));
-        bitmap.SetPixel(2, 0, Color.FromArgb(0, 50, 100, 150));
-
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmap16Bit(bitmap, Color.Red);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format16bppRgb555, result.PixelFormat);
-            Assert.Empty(result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-            Assert.Equal(Color.FromArgb(255, 49, 99, 148), result.GetPixel(0, 0));
-            Assert.Equal(Color.FromArgb(255, 255, 0, 0), result.GetPixel(1, 0));
-            Assert.Equal(Color.FromArgb(255, 255, 0, 0), result.GetPixel(2, 0));
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmap16Bit_NullBitmap_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => ControlPaint.CreateHBitmap16Bit(null, Color.Red));
-    }
-
-    public static IEnumerable<object[]> CreateHBitmapColorMask_TestData()
-    {
-        foreach (IntPtr monochromeMask in new IntPtr[] { IntPtr.Zero, (IntPtr)1 })
-        {
-            yield return new object[] { new Bitmap(10, 10, PixelFormat.Format1bppIndexed), monochromeMask };
-            yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), monochromeMask };
-            yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), monochromeMask };
-            yield return new object[] { new Bitmap(16, 24, PixelFormat.Format1bppIndexed), monochromeMask };
-            yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppRgb), monochromeMask };
-            yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppArgb), monochromeMask };
-            yield return new object[] { new Bitmap(11, 11, PixelFormat.Format1bppIndexed), monochromeMask };
-            yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppRgb), monochromeMask };
-            yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppArgb), monochromeMask };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateHBitmapColorMask_TestData))]
-    public void ControlPaint_CreateHBitmapColorMask_Invoke_ReturnsExpected(Bitmap bitmap, IntPtr monochromeMask)
-    {
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmapColorMask(bitmap, monochromeMask);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-            Assert.Empty(result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmapColorMask_InvokeSpecificPixelsWithMonochromeMask_Success()
-    {
-        using var mask = new Bitmap(3, 1);
-        mask.SetPixel(0, 0, Color.FromArgb(255, 255, 0, 0));
-        mask.SetPixel(1, 0, Color.FromArgb(255, 0, 255, 0));
-        mask.SetPixel(2, 0, Color.FromArgb(0, 0, 0, 255));
-        HBITMAP monochromeMask = (HBITMAP)mask.GetHbitmap();
-        try
-        {
-            using var bitmap = new Bitmap(3, 1);
-            bitmap.SetPixel(0, 0, Color.FromArgb(255, 50, 100, 150));
-            bitmap.SetPixel(1, 0, Color.FromArgb(1, 50, 100, 150));
-            bitmap.SetPixel(2, 0, Color.FromArgb(0, 50, 100, 150));
-
-            HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmapColorMask(bitmap, (IntPtr)monochromeMask);
-            try
-            {
-                Assert.False(hBitmap.IsNull);
-                Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-                using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-                Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-                Assert.Empty(result.Palette.Entries);
-                Assert.Equal(bitmap.Size, result.Size);
-                Assert.Equal(Color.FromArgb(255, 0, 100, 150), result.GetPixel(0, 0));
-                Assert.Equal(Color.FromArgb(255, 210, 0, 211), result.GetPixel(1, 0));
-                Assert.Equal(Color.FromArgb(255, 0, 0, 0), result.GetPixel(2, 0));
-            }
-            finally
-            {
-                PInvoke.DeleteObject(hBitmap);
-            }
-        }
-        finally
-        {
-            PInvoke.DeleteObject(monochromeMask);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmapColorMask_InvokeSpecificPixelsWithoutMonochromeMask_Success()
-    {
-        using var bitmap = new Bitmap(3, 1);
-        bitmap.SetPixel(0, 0, Color.FromArgb(255, 50, 100, 150));
-        bitmap.SetPixel(1, 0, Color.FromArgb(1, 50, 100, 150));
-        bitmap.SetPixel(2, 0, Color.FromArgb(0, 50, 100, 150));
-
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmapColorMask(bitmap, IntPtr.Zero);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format32bppRgb, result.PixelFormat);
-            Assert.Empty(result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-            Assert.Equal(Color.FromArgb(255, 50, 100, 150), result.GetPixel(0, 0));
-            Assert.Equal(Color.FromArgb(255, 210, 210, 211), result.GetPixel(1, 0));
-            Assert.Equal(Color.FromArgb(255, 211, 211, 211), result.GetPixel(2, 0));
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmapColorMask_NullBitmap_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => ControlPaint.CreateHBitmapColorMask(null, IntPtr.Zero));
-    }
-
-    public static IEnumerable<object[]> CreateHBitmapTransparencyMask_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format1bppIndexed) };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb) };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb) };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format1bppIndexed) };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppRgb) };
-        yield return new object[] { new Bitmap(16, 24, PixelFormat.Format32bppArgb) };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format1bppIndexed) };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppRgb) };
-        yield return new object[] { new Bitmap(11, 11, PixelFormat.Format32bppArgb) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateHBitmapTransparencyMask_TestData))]
-    public void ControlPaint_CreateHBitmapTransparencyMask_Invoke_ReturnsExpected(Bitmap bitmap)
-    {
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmapTransparencyMask(bitmap);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format1bppIndexed, result.PixelFormat);
-            Assert.Equal(new Color[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 255, 255, 255) }, result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmapTransparencyMask_InvokeSpecificPixels_Success()
-    {
-        using var bitmap = new Bitmap(3, 1);
-        bitmap.SetPixel(0, 0, Color.FromArgb(255, 50, 100, 150));
-        bitmap.SetPixel(1, 0, Color.FromArgb(1, 50, 100, 150));
-        bitmap.SetPixel(2, 0, Color.FromArgb(0, 50, 100, 150));
-
-        HBITMAP hBitmap = (HBITMAP)ControlPaint.CreateHBitmapTransparencyMask(bitmap);
-        try
-        {
-            Assert.False(hBitmap.IsNull);
-            Assert.Equal(OBJ_TYPE.OBJ_BITMAP, (OBJ_TYPE)PInvoke.GetObjectType(hBitmap));
-
-            using Bitmap result = Bitmap.FromHbitmap((IntPtr)hBitmap);
-            Assert.Equal(PixelFormat.Format1bppIndexed, result.PixelFormat);
-            Assert.Equal(new Color[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 255, 255, 255) }, result.Palette.Entries);
-            Assert.Equal(bitmap.Size, result.Size);
-            Assert.Equal(Color.FromArgb(255, 0, 0, 0), result.GetPixel(0, 0));
-            Assert.Equal(Color.FromArgb(255, 0, 0, 0), result.GetPixel(1, 0));
-            Assert.Equal(Color.FromArgb(255, 255, 255, 255), result.GetPixel(2, 0));
-        }
-        finally
-        {
-            PInvoke.DeleteObject(hBitmap);
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_CreateHBitmapTransparencyMask_NullBitmap_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("bitmap", () => ControlPaint.CreateHBitmapTransparencyMask(null));
-    }
-
-    public static IEnumerable<object[]> CreateBitmapWithInvertedForeColor_TestData()
-    {
-        yield return new object[] { Color.White, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.Black, Color.FromArgb(255, 255, 255, 255) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateBitmapWithInvertedForeColor_TestData))]
-    public void ControlPaint_CreateBitmapWithInvertedForeColor(Color imageColor, Color expected)
-    {
-        using Bitmap bitmap = new(1, 1);
-        bitmap.SetPixel(0, 0, imageColor);
-
-        using Bitmap invertedBitmap = ControlPaint.CreateBitmapWithInvertedForeColor(bitmap, Color.LightGray);
-        Color newColor = invertedBitmap.GetPixel(0, 0);
-
-        Assert.Equal(expected, newColor);
-    }
-
-    public static IEnumerable<object[]> Dark_Color_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 85, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), Color.FromArgb(255, 0, 85, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 0, 0, 85) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 85, 85, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), Color.FromArgb(255, 85, 0, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), Color.FromArgb(255, 0, 85, 85) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), Color.FromArgb(255, 85, 85, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), Color.FromArgb(255, 0, 28, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), Color.FromArgb(255, 0, 9, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), Color.FromArgb(255, 0, 2, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), Color.FromArgb(255, 41, 14, 67) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), Color.FromArgb(255, 151, 0, 151) };
-        yield return new object[] { SystemColors.ControlDarkDark, Color.FromArgb(255, 35, 35, 35) };
-        yield return new object[] { SystemColors.ControlDark, Color.FromArgb(255, 53, 53, 53) };
-        yield return new object[] { SystemColors.Control, Color.FromArgb(255, 133, 133, 133) };
-        yield return new object[] { SystemColors.ControlLight, Color.FromArgb(255, 75, 75, 75) };
-        yield return new object[] { SystemColors.ControlLightLight, Color.FromArgb(255, 85, 85, 85) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dark_Color_TestData))]
-    public void ControlPaint_Dark_InvokeColor_ReturnsExpected(Color baseColor, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.Dark(baseColor));
-
-        // Call again to test caching.
-        Assert.Equal(expected, ControlPaint.Dark(baseColor));
-    }
-
-    public static IEnumerable<object[]> Dark_Color_Float_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -1.5f, Color.FromArgb(255, 255, 170, 170) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -1.5f, Color.FromArgb(255, 170, 255, 170) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -1.5f, Color.FromArgb(255, 170, 170, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -1.5f, Color.FromArgb(255, 255, 255, 170) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -1.5f, Color.FromArgb(255, 255, 170, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -1.5f, Color.FromArgb(255, 170, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -1.5f, Color.FromArgb(255, 169, 169, 169) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -1.5f, Color.FromArgb(255, 0, 138, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -1.5f, Color.FromArgb(255, 0, 43, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -1.5f, Color.FromArgb(255, 0, 11, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -1.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -1.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -1.5f, Color.FromArgb(255, 201, 162, 236) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -1.5f, Color.FromArgb(255, 255, 243, 0) };
-        yield return new object[] { SystemColors.ControlDarkDark, -1.5f, Color.FromArgb(255, 175, 175, 175) };
-        yield return new object[] { SystemColors.ControlDark, -1.5f, Color.FromArgb(255, 9, 9, 9) };
-        yield return new object[] { SystemColors.Control, -1.5f, Color.FromArgb(255, 242, 242, 242) };
-        yield return new object[] { SystemColors.ControlLight, -1.5f, Color.FromArgb(255, 121, 121, 121) };
-        yield return new object[] { SystemColors.ControlLightLight, -1.5f, Color.FromArgb(255, 169, 169, 169) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -1f, Color.FromArgb(255, 255, 85, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -1f, Color.FromArgb(255, 85, 255, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -1f, Color.FromArgb(255, 85, 85, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -1f, Color.FromArgb(255, 255, 255, 85) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -1f, Color.FromArgb(255, 255, 85, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -1f, Color.FromArgb(255, 85, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -1f, Color.FromArgb(255, 84, 84, 84) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -1f, Color.FromArgb(255, 0, 111, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -1f, Color.FromArgb(255, 0, 34, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -1f, Color.FromArgb(255, 0, 9, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -1f, Color.FromArgb(255, 163, 96, 223) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -1f, Color.FromArgb(255, 255, 93, 0) };
-        yield return new object[] { SystemColors.ControlDarkDark, -1f, Color.FromArgb(255, 140, 140, 140) };
-        yield return new object[] { SystemColors.ControlDark, -1f, Color.FromArgb(255, 212, 212, 212) };
-        yield return new object[] { SystemColors.Control, -1f, Color.FromArgb(255, 215, 215, 215) };
-        yield return new object[] { SystemColors.ControlLight, -1f, Color.FromArgb(255, 45, 45, 45) };
-        yield return new object[] { SystemColors.ControlLightLight, -1f, Color.FromArgb(255, 84, 84, 84) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -0.5f, Color.FromArgb(255, 255, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -0.5f, Color.FromArgb(255, 0, 255, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -0.5f, Color.FromArgb(255, 0, 0, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -0.5f, Color.FromArgb(255, 255, 255, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -0.5f, Color.FromArgb(255, 255, 0, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -0.5f, Color.FromArgb(255, 0, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -0.5f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -0.5f, Color.FromArgb(255, 0, 83, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -0.5f, Color.FromArgb(255, 0, 26, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -0.5f, Color.FromArgb(255, 0, 6, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -0.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -0.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -0.5f, Color.FromArgb(255, 123, 39, 199) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -0.5f, Color.FromArgb(255, 255, 198, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -0.5f, Color.FromArgb(255, 105, 105, 105) };
-        yield return new object[] { SystemColors.ControlDark, -0.5f, Color.FromArgb(255, 159, 159, 159) };
-        yield return new object[] { SystemColors.Control, -0.5f, Color.FromArgb(255, 187, 187, 187) };
-        yield return new object[] { SystemColors.ControlLight, -0.5f, Color.FromArgb(255, 226, 226, 226) };
-        yield return new object[] { SystemColors.ControlLightLight, -0.5f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -0.25f, Color.FromArgb(255, 213, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -0.25f, Color.FromArgb(255, 0, 213, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -0.25f, Color.FromArgb(255, 0, 0, 213) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -0.25f, Color.FromArgb(255, 213, 213, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -0.25f, Color.FromArgb(255, 213, 0, 213) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -0.25f, Color.FromArgb(255, 0, 213, 213) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -0.25f, Color.FromArgb(255, 212, 212, 212) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -0.25f, Color.FromArgb(255, 0, 68, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -0.25f, Color.FromArgb(255, 0, 21, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -0.25f, Color.FromArgb(255, 0, 4, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -0.25f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -0.25f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -0.25f, Color.FromArgb(255, 102, 33, 165) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -0.25f, Color.FromArgb(255, 255, 121, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -0.25f, Color.FromArgb(255, 87, 87, 87) };
-        yield return new object[] { SystemColors.ControlDark, -0.25f, Color.FromArgb(255, 132, 132, 132) };
-        yield return new object[] { SystemColors.Control, -0.25f, Color.FromArgb(255, 173, 173, 173) };
-        yield return new object[] { SystemColors.ControlLight, -0.25f, Color.FromArgb(255, 188, 188, 188) };
-        yield return new object[] { SystemColors.ControlLightLight, -0.25f, Color.FromArgb(255, 212, 212, 212) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0f, Color.FromArgb(255, 170, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0f, Color.FromArgb(255, 0, 170, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0f, Color.FromArgb(255, 0, 0, 170) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0f, Color.FromArgb(255, 170, 170, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0f, Color.FromArgb(255, 170, 0, 170) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0f, Color.FromArgb(255, 0, 170, 170) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0f, Color.FromArgb(255, 170, 170, 170) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0f, Color.FromArgb(255, 0, 55, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0f, Color.FromArgb(255, 0, 17, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0f, Color.FromArgb(255, 0, 4, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0f, Color.FromArgb(255, 83, 27, 133) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0f, Color.FromArgb(255, 255, 47, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0f, Color.FromArgb(255, 70, 70, 70) };
-        yield return new object[] { SystemColors.ControlDark, 0f, Color.FromArgb(255, 106, 106, 106) };
-        yield return new object[] { SystemColors.Control, 0f, SystemColors.ControlDark };
-        yield return new object[] { SystemColors.ControlLight, 0f, Color.FromArgb(255, 150, 150, 150) };
-        yield return new object[] { SystemColors.ControlLightLight, 0f, Color.FromArgb(255, 170, 170, 170) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0.25f, Color.FromArgb(255, 128, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0.25f, Color.FromArgb(255, 0, 128, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0.25f, Color.FromArgb(255, 0, 0, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0.25f, Color.FromArgb(255, 128, 128, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0.25f, Color.FromArgb(255, 128, 0, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0.25f, Color.FromArgb(255, 0, 128, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0.25f, Color.FromArgb(255, 127, 127, 127) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0.25f, Color.FromArgb(255, 0, 43, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0.25f, Color.FromArgb(255, 0, 13, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0.25f, Color.FromArgb(255, 0, 4, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0.25f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0.25f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0.25f, Color.FromArgb(255, 63, 20, 101) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0.25f, Color.FromArgb(255, 227, 0, 227) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0.25f, Color.FromArgb(255, 53, 53, 53) };
-        yield return new object[] { SystemColors.ControlDark, 0.25f, Color.FromArgb(255, 79, 79, 79) };
-        yield return new object[] { SystemColors.Control, 0.25f, Color.FromArgb(255, 147, 147, 147) };
-        yield return new object[] { SystemColors.ControlLight, 0.25f, Color.FromArgb(255, 113, 113, 113) };
-        yield return new object[] { SystemColors.ControlLightLight, 0.25f, Color.FromArgb(255, 127, 127, 127) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0.5f, Color.FromArgb(255, 85, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0.5f, Color.FromArgb(255, 0, 85, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0.5f, Color.FromArgb(255, 0, 0, 85) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0.5f, Color.FromArgb(255, 85, 85, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0.5f, Color.FromArgb(255, 85, 0, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0.5f, Color.FromArgb(255, 0, 85, 85) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0.5f, Color.FromArgb(255, 85, 85, 85) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0.5f, Color.FromArgb(255, 0, 28, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0.5f, Color.FromArgb(255, 0, 9, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0.5f, Color.FromArgb(255, 0, 2, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0.5f, Color.FromArgb(255, 41, 14, 67) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0.5f, Color.FromArgb(255, 151, 0, 151) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0.5f, Color.FromArgb(255, 35, 35, 35) };
-        yield return new object[] { SystemColors.ControlDark, 0.5f, Color.FromArgb(255, 53, 53, 53) };
-        yield return new object[] { SystemColors.Control, 0.5f, Color.FromArgb(255, 133, 133, 133) };
-        yield return new object[] { SystemColors.ControlLight, 0.5f, Color.FromArgb(255, 75, 75, 75) };
-        yield return new object[] { SystemColors.ControlLightLight, 0.5f, Color.FromArgb(255, 85, 85, 85) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlDarkDark, 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlDark, 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.Control, 1f, SystemColors.ControlDarkDark };
-        yield return new object[] { SystemColors.ControlLight, 1f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlLightLight, 1f, Color.FromArgb(255, 0, 0, 0) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 1.5f, Color.FromArgb(255, 173, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 1.5f, Color.FromArgb(255, 0, 173, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 1.5f, Color.FromArgb(255, 0, 0, 173) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 1.5f, Color.FromArgb(255, 174, 173, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 1.5f, Color.FromArgb(255, 173, 0, 174) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 1.5f, Color.FromArgb(255, 0, 174, 173) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 1.5f, Color.FromArgb(255, 171, 171, 171) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 1.5f, Color.FromArgb(255, 0, 230, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 1.5f, Color.FromArgb(255, 0, 250, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 1.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 1.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 1.5f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 1.5f, Color.FromArgb(255, 218, 243, 192) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 1.5f, Color.FromArgb(255, 107, 0, 108) };
-        yield return new object[] { SystemColors.ControlDarkDark, 1.5f, Color.FromArgb(255, 221, 221, 221) };
-        yield return new object[] { SystemColors.ControlDark, 1.5f, Color.FromArgb(255, 203, 203, 203) };
-        yield return new object[] { SystemColors.Control, 1.5f, Color.FromArgb(255, 78, 78, 78) };
-        yield return new object[] { SystemColors.ControlLight, 1.5f, Color.FromArgb(255, 181, 181, 181) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dark_Color_Float_TestData))]
-    private void ControlPaint_Dark_InvokeColorFloat_ReturnsExpected(Color baseColor, float percOfDarkDark, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.Dark(baseColor, percOfDarkDark));
-
-        // Call again to test caching.
-        Assert.Equal(expected, ControlPaint.Dark(baseColor, percOfDarkDark));
-    }
-
-    public static IEnumerable<object[]> DarkDark_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlDarkDark, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlDark, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.Control, SystemColors.ControlDarkDark };
-        yield return new object[] { SystemColors.ControlLight, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { SystemColors.ControlLightLight, Color.FromArgb(255, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DarkDark_TestData))]
-    private void ControlPaint_DarkDark_InvokeColorFloat_ReturnsExpected(Color baseColor, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.DarkDark(baseColor));
-    }
-
-    public static IEnumerable<object[]> DrawBorder_Graphics_Rectangle_Color_ButtonBorderStyle_TestData()
-    {
-        foreach (ButtonBorderStyle style in new ButtonBorderStyle[] { ButtonBorderStyle.Dashed, ButtonBorderStyle.Dotted, ButtonBorderStyle.Inset, ButtonBorderStyle.None, ButtonBorderStyle.Outset, ButtonBorderStyle.Solid, ButtonBorderStyle.None - 1, ButtonBorderStyle.Outset + 1 })
-        {
-            yield return new object[] { Rectangle.Empty, Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, -3, -4), Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.ControlLight, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.Control, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.ControlDark, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Black, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.White, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Transparent, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), Color.Red, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), Color.Red, style };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder_Graphics_Rectangle_Color_ButtonBorderStyle_TestData))]
-    public void ControlPaint_DrawBorder_GraphicsRectangleColorButtonBorderStyle_Success(Rectangle bounds, Color color, ButtonBorderStyle style)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder(graphics, bounds, color, style);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder(graphics, bounds, color, style);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ButtonBorderStyle>]
-    [InlineData(ButtonBorderStyle.None)]
-    public void ControlPaint_DrawBorder_GraphicsRectangleColorButtonBorderStyleInvalidStyle_Nop(ButtonBorderStyle style)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder(graphics, new Rectangle(1, 2, 3, 4), Color.Red, style);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder(graphics, new Rectangle(1, 2, 3, 4), Color.Red, style);
-    }
-
-    public static IEnumerable<object[]> DrawBorder_Graphics_Rectangle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_TestData()
-    {
-        foreach (ButtonBorderStyle style in new ButtonBorderStyle[] { ButtonBorderStyle.Dashed, ButtonBorderStyle.Dotted, ButtonBorderStyle.Inset, ButtonBorderStyle.None, ButtonBorderStyle.Outset, ButtonBorderStyle.Solid, ButtonBorderStyle.None - 1, ButtonBorderStyle.Outset + 1 })
-        {
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { Rectangle.Empty, Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, -3, -4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 0, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 0, style, Color.Blue, 0, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 0, style, Color.Blue, 3, style, Color.Yellow, 0, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 0, style, Color.Blue, 0, style, Color.Yellow, 0, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 2, style, Color.Blue, 0, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 2, style, Color.Blue, 0, style, Color.Yellow, 0, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 0, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 0, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 0, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 0, style, Color.Blue, 0, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 0, style, Color.Blue, 3, style, Color.Yellow, 0, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 0, style, Color.Blue, 0, style, Color.Yellow, 0, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 0, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 0, style, Color.Yellow, 0, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 0, style };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder_Graphics_Rectangle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_Color_Int_ButtonBorderStyle_TestData))]
-    public void ControlPaint_DrawBorder_GraphicsRectangleColorIntButtonBorderStyleColorIntButtonBorderStyleColorIntButtonBorderStyleColorIntButtonBorderStyle_Success(
-        Rectangle bounds,
-        Color leftColor, int leftWidth, ButtonBorderStyle leftStyle,
-        Color topColor, int topWidth, ButtonBorderStyle topStyle,
-        Color rightColor, int rightWidth, ButtonBorderStyle rightStyle,
-        Color bottomColor, int bottomWidth, ButtonBorderStyle bottomStyle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder(graphics, bounds, leftColor, leftWidth, leftStyle, topColor, topWidth, topStyle, rightColor, rightWidth, rightStyle, bottomColor, bottomWidth, bottomStyle);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder(graphics, bounds, leftColor, leftWidth, leftStyle, topColor, topWidth, topStyle, rightColor, rightWidth, rightStyle, bottomColor, bottomWidth, bottomStyle);
-    }
-
-    public static IEnumerable<object[]> DrawBorder_OutOfRange_TestData()
-    {
-        foreach (ButtonBorderStyle style in new ButtonBorderStyle[] { ButtonBorderStyle.Dashed, ButtonBorderStyle.Dotted, ButtonBorderStyle.Inset, ButtonBorderStyle.None, ButtonBorderStyle.Outset, ButtonBorderStyle.Solid, ButtonBorderStyle.None - 1, ButtonBorderStyle.Outset + 1 })
-        {
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, -1, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, -1, style, Color.Blue, -1, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, -1, style, Color.Blue, 3, style, Color.Yellow, -1, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, -1, style, Color.Blue, -1, style, Color.Yellow, -1, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, 2, style, Color.Blue, -1, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, 2, style, Color.Blue, -1, style, Color.Yellow, -1, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, -1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, -1, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, -1, style, Color.Blue, 3, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, -1, style, Color.Blue, -1, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, -1, style, Color.Blue, 3, style, Color.Yellow, -1, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, -1, style, Color.Blue, -1, style, Color.Yellow, -1, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, -1, style, Color.Yellow, 4, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, -1, style, Color.Yellow, -1, style };
-
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Green, 2, style, Color.Blue, 3, style, Color.Yellow, -1, style };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder_OutOfRange_TestData))]
-    public void ControlPaint_DrawBorder_OutOfRange_ThrowsOutOfRangeException(
-        Rectangle bounds,
-        Color leftColor, int leftWidth, ButtonBorderStyle leftStyle,
-        Color topColor, int topWidth, ButtonBorderStyle topStyle,
-        Color rightColor, int rightWidth, ButtonBorderStyle rightStyle,
-        Color bottomColor, int bottomWidth, ButtonBorderStyle bottomStyle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>(() => ControlPaint.DrawBorder(graphics, bounds, leftColor, leftWidth, leftStyle, topColor, topWidth, topStyle, rightColor, rightWidth, rightStyle, bottomColor, bottomWidth, bottomStyle));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonBorderStyle.Dashed)]
-    [InlineData(ButtonBorderStyle.Dotted)]
-    [InlineData(ButtonBorderStyle.Inset)]
-    [InlineData(ButtonBorderStyle.Outset)]
-    [InlineData(ButtonBorderStyle.Solid)]
-    public void ControlPaint_DrawBorder_NullGraphics_ThrowsArgumentNullException(ButtonBorderStyle style)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder(null, new Rectangle(1, 2, 3, 4), Color.Red, style));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ButtonBorderStyle>]
-    [InvalidEnumData<ButtonBorderStyle>]
-    public void ControlPaint_DrawBorder_NullGraphicsComplex_ThrowsArgumentNullException(ButtonBorderStyle style)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder(null, new Rectangle(1, 2, 3, 4), Color.Red, 1, style, Color.Red, 1, style, Color.Red, 1, style, Color.Red, 1, style));
-    }
-
-    public static IEnumerable<object[]> DrawBorder3D_Graphics_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 4, 3) };
-        yield return new object[] { new Rectangle(1, 2, 3, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_Rectangle_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsRectangle_Success(Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle);
-    }
-
-    public static IEnumerable<object[]> DrawBorder3D_Graphics_RectangleBorder3DStyle_TestData()
-    {
-        foreach (Border3DStyle style in Enum.GetValues(typeof(Border3DStyle)))
-        {
-            yield return new object[] { Rectangle.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, -3, -4), style };
-            yield return new object[] { new Rectangle(0, 0, 3, 4), style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), style };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), style };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), style };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_RectangleBorder3DStyle_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsRectangleBorder3DStyle_Success(Rectangle rectangle, Border3DStyle style)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle, style);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle, style);
-    }
-
-    public static IEnumerable<object[]> DrawBorder3D_Graphics_RectangleBorder3DStyleBorder3DSide_TestData()
-    {
-        foreach (Border3DStyle style in Enum.GetValues(typeof(Border3DStyle)))
-        {
-            foreach (Border3DSide side in Enum.GetValues(typeof(Border3DSide)))
-            {
-                yield return new object[] { Rectangle.Empty, style, side };
-                yield return new object[] { new Rectangle(1, 2, -3, -4), style, side };
-                yield return new object[] { new Rectangle(0, 0, 3, 4), style, side };
-                yield return new object[] { new Rectangle(1, 2, 3, 4), style, side };
-                yield return new object[] { new Rectangle(1, 2, 4, 3), style, side };
-                yield return new object[] { new Rectangle(1, 2, 3, 3), style, side };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_RectangleBorder3DStyleBorder3DSide_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsRectangleBorder3DStyleBorder3DSide_Success(Rectangle rectangle, Border3DStyle style, Border3DSide side)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle, style, side);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle, style, side);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_Rectangle_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsIntIntIntInt_Success(Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_RectangleBorder3DStyle_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsIntIntIntIntBorder3DStyleSuccess(Rectangle rectangle, Border3DStyle style)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, style);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, style);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawBorder3D_Graphics_RectangleBorder3DStyleBorder3DSide_TestData))]
-    public void ControlPaint_DrawBorder3D_InvokeGraphicsIntIntIntIntBorder3DStyleBorder3DSide_Success(Rectangle rectangle, Border3DStyle style, Border3DSide side)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, style, side);
-
-        // Call again to test caching.
-        ControlPaint.DrawBorder3D(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, style, side);
-    }
-
-    [WinFormsTheory]
-    [EnumData<Border3DStyle>]
-    [InvalidEnumData<Border3DStyle>]
-    public void ControlPaint_DrawBorder3D_NullGraphics_ThrowsArgumentNullException(Border3DStyle style)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, new Rectangle(1, 2, 3, 4)));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, new Rectangle(1, 2, 3, 4), style));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, new Rectangle(1, 2, 3, 4), style, Border3DSide.All));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, 1, 2, 3, 4));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, 1, 2, 3, 4, style));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawBorder3D(null, 1, 2, 3, 4, style, Border3DSide.All));
-    }
-
-    public static IEnumerable<object[]> DrawButton_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), state };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawButton_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawButton(graphics, rectangle, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawButton(graphics, rectangle, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawButton_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawButton_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawButton(null, new Rectangle(1, 2, 3, 4), state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawButton(null, 1, 2, 3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    [InlineData(0, 0, ButtonState.Normal)]
-    public void ControlPaint_DrawButton_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawButton(graphics, new Rectangle(0, 0, width, height), state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawButton(graphics, 0, 0, width, height, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawButton_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawButton(graphics, new Rectangle(0, 0, -3, 4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawButton(graphics, 0, 0, -3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawButton_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawButton(graphics, new Rectangle(0, 0, 3, -4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawButton(graphics, 0, 0, 3, -4, state));
-    }
-
-    public static IEnumerable<object[]> DrawCaptionButton_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (CaptionButton button in Enum.GetValues(typeof(CaptionButton)))
-        {
-            foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-            {
-                yield return new object[] { new Rectangle(0, 0, 3, 4), button, state };
-                yield return new object[] { new Rectangle(1, 2, 3, 4), button, state };
-                yield return new object[] { new Rectangle(1, 2, 4, 3), button, state };
-                yield return new object[] { new Rectangle(1, 2, 3, 3), button, state };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawCaptionButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawCaptionButton_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, CaptionButton button, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawCaptionButton(graphics, rectangle, button, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawCaptionButton(graphics, rectangle, button, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawCaptionButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawCaptionButton_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, CaptionButton button, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawCaptionButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, button, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawCaptionButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, button, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawCaptionButton_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawCaptionButton(null, new Rectangle(1, 2, 3, 4), CaptionButton.Close, state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawCaptionButton(null, 1, 2, 3, 4, CaptionButton.Close, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    public void ControlPaint_DrawCaptionButton_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawCaptionButton(graphics, new Rectangle(0, 0, width, height), CaptionButton.Close, state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawCaptionButton(graphics, 0, 0, width, height, CaptionButton.Close, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawCaptionButton_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawCaptionButton(graphics, new Rectangle(0, 0, -3, 4), CaptionButton.Close, state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawCaptionButton(graphics, 0, 0, -3, 4, CaptionButton.Close, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawCaptionButton_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawCaptionButton(graphics, new Rectangle(0, 0, 3, -4), CaptionButton.Close, state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawCaptionButton(graphics, 0, 0, 3, -4, CaptionButton.Close, state));
-    }
-
-    public static IEnumerable<object[]> DrawCheckBox_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), state };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawCheckBox_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawCheckBox_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawCheckBox(graphics, rectangle, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawCheckBox(graphics, rectangle, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawCheckBox_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawCheckBox_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawCheckBox(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawCheckBox(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawCheckBox_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawCheckBox(null, new Rectangle(1, 2, 3, 4), state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawCheckBox(null, 1, 2, 3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    [InlineData(0, 0, ButtonState.Normal)]
-    public void ControlPaint_DrawCheckBox_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawCheckBox(graphics, new Rectangle(0, 0, width, height), state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawCheckBox(graphics, 0, 0, width, height, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All, "rectangle")]
-    [InlineData(ButtonState.Normal, "width")]
-    public void ControlPaint_DrawCheckBox_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state, string expectedParamName)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>(expectedParamName, () => ControlPaint.DrawCheckBox(graphics, new Rectangle(0, 0, -3, 4), state));
-        Assert.Throws<ArgumentOutOfRangeException>(expectedParamName, () => ControlPaint.DrawCheckBox(graphics, 0, 0, -3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All, "rectangle")]
-    [InlineData(ButtonState.Normal, "height")]
-    public void ControlPaint_DrawCheckBox_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state, string expectedParamName)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>(expectedParamName, () => ControlPaint.DrawCheckBox(graphics, new Rectangle(0, 0, 3, -4), state));
-        Assert.Throws<ArgumentOutOfRangeException>(expectedParamName, () => ControlPaint.DrawCheckBox(graphics, 0, 0, 3, -4, state));
-    }
-
-    public static IEnumerable<object[]> DrawComboButton_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), state };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawComboButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawComboButton_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawComboButton(graphics, rectangle, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawComboButton(graphics, rectangle, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawComboButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawComboButton_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawComboButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawComboButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawComboButton_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawComboButton(null, new Rectangle(1, 2, 3, 4), state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawComboButton(null, 1, 2, 3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    public void ControlPaint_DrawComboButton_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawComboButton(graphics, new Rectangle(0, 0, width, height), state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawComboButton(graphics, 0, 0, width, height, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawComboButton_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawComboButton(graphics, new Rectangle(0, 0, -3, 4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawComboButton(graphics, 0, 0, -3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawComboButton_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawComboButton(graphics, new Rectangle(0, 0, 3, -4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawComboButton(graphics, 0, 0, 3, -4, state));
-    }
-
-    public static IEnumerable<object[]> DrawContainerGrabHandle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 4, 3) };
-        yield return new object[] { new Rectangle(1, 2, 3, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawContainerGrabHandle_TestData))]
-    public void ControlPaint_DrawContainerGrabHandle_Invoke_Success(Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawContainerGrabHandle(graphics, rectangle);
-
-        // Call again to test caching.
-        ControlPaint.DrawContainerGrabHandle(graphics, rectangle);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawContainerGrabHandle_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawContainerGrabHandle(null, new Rectangle(1, 2, 3, 4)));
-    }
-
-    public static IEnumerable<object[]> DrawFocusRectangle_Graphics_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 4, 3) };
-        yield return new object[] { new Rectangle(1, 2, 3, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawFocusRectangle_Graphics_Rectangle_TestData))]
-    public void ControlPaint_DrawFocusRectangle_InvokeGraphicsRectangle_Success(Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawFocusRectangle(graphics, rectangle);
-
-        // Call again to test caching.
-        ControlPaint.DrawFocusRectangle(graphics, rectangle);
-    }
-
-    public static IEnumerable<object[]> DrawFocusRectangle_Graphics_Rectangle_Color_Color_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Color.Red, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, -3, -4), Color.Red, Color.Blue };
-        yield return new object[] { new Rectangle(0, 0, 3, 4), Color.Red, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Black, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.White, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Empty, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Transparent, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Black };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.White };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Transparent };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 4, 3), Color.Red, Color.Blue };
-        yield return new object[] { new Rectangle(1, 2, 3, 3), Color.Red, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawFocusRectangle_Graphics_Rectangle_Color_Color_TestData))]
-    public void ControlPaint_DrawFocusRectangle_Invoke_Success(Rectangle rectangle, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawFocusRectangle(graphics, rectangle, foreColor, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawFocusRectangle(graphics, rectangle, foreColor, backColor);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawFocusRectangle_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawFocusRectangle(null, new Rectangle(1, 2, 3, 4)));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawFocusRectangle(null, new Rectangle(1, 2, 3, 4), Color.Red, Color.Blue));
-    }
-
-    public static IEnumerable<object[]> DrawGrabHandle_TestData()
-    {
-        foreach (bool primary in new bool[] { true, false })
-        {
-            foreach (bool enabled in new bool[] { true, false })
-            {
-                yield return new object[] { Rectangle.Empty, primary, enabled };
-                yield return new object[] { new Rectangle(1, 2, -3, -4), primary, enabled };
-                yield return new object[] { new Rectangle(0, 0, 3, 4), primary, enabled };
-                yield return new object[] { new Rectangle(1, 2, 3, 4), primary, enabled };
-                yield return new object[] { new Rectangle(1, 2, 4, 3), primary, enabled };
-                yield return new object[] { new Rectangle(1, 2, 3, 3), primary, enabled };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawGrabHandle_TestData))]
-    public void ControlPaint_DrawGrabHandle_Invoke_Success(Rectangle rectangle, bool primary, bool enabled)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawGrabHandle(graphics, rectangle, primary, enabled);
-
-        // Call again to test caching.
-        ControlPaint.DrawGrabHandle(graphics, rectangle, primary, enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ControlPaint_DrawGrabHandle_NullGraphics_ThrowsArgumentNullException(bool primary, bool enabled)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawGrabHandle(null, new Rectangle(1, 2, 3, 4), primary, enabled));
-    }
-
-    public static IEnumerable<object[]> DrawGrid_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, new Size(1, 1), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, -3, -4), new Size(1, 1), Color.Red };
-        yield return new object[] { new Rectangle(0, 0, 3, 4), new Size(1, 1), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.Black };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.White };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.Transparent };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(10, 20), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 4, 3), new Size(10, 20), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 3), new Size(10, 20), Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawGrid_TestData))]
-    public void ControlPaint_DrawGrid_Invoke_Success(Rectangle area, Size pixelsBetweenDots, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawGrid(graphics, area, pixelsBetweenDots, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawGrid(graphics, area, pixelsBetweenDots, backColor);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawGrid_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawGrid(null, new Rectangle(1, 2, 3, 4), new Size(1, 1), Color.Red));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(-1, 1)]
-    [InlineData(1, 0)]
-    [InlineData(1, -1)]
-    public void ControlPaint_DrawGrid_InvalidPixelsBetweenDots_ThrowsArgumentOutOfRangeException(int width, int height)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("pixelsBetweenDots", () => ControlPaint.DrawGrid(graphics, new Rectangle(0, 0, width, height), new Size(width, height), Color.Red));
-    }
-
-    public static IEnumerable<object[]> DrawImageDisabled_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10), -10, -20, Color.Red };
-        yield return new object[] { new Bitmap(10, 10), 0, 0, Color.Red };
-        yield return new object[] { new Bitmap(10, 10), 1, 2, Color.Red };
-        yield return new object[] { new Bitmap(10, 10), 0, 0, Color.Black };
-        yield return new object[] { new Bitmap(10, 10), 0, 0, Color.White };
-        yield return new object[] { new Bitmap(10, 10), 0, 0, Color.Transparent };
-        yield return new object[] { new Bitmap(10, 10), 0, 0, Color.Empty };
-
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), -10, -20, Color.Red };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 0, 0, Color.Red };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 1, 2, Color.Red };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 0, 0, Color.Black };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 0, 0, Color.White };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 0, 0, Color.Transparent };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf"), 0, 0, Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawImageDisabled_TestData))]
-    public void ControlPaint_DrawImageDisabled_Invoke_Success(Image image, int x, int y, Color background)
-    {
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        ControlPaint.DrawImageDisabled(graphics, image, x, y, background);
-
-        // Call again to test caching.
-        ControlPaint.DrawImageDisabled(graphics, image, x, y, background);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawImageDisabled_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawImageDisabled(null, image, 0, 0, Color.Red));
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawImageDisabled_NullImage_ThrowsNullReferenceException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<NullReferenceException>(() => ControlPaint.DrawImageDisabled(graphics, null, 0, 0, Color.Red));
-    }
-
-    public static IEnumerable<object[]> DrawLockedFrame_TestData()
-    {
-        foreach (bool primary in new bool[] { true, false })
-        {
-            yield return new object[] { Rectangle.Empty, primary };
-            yield return new object[] { new Rectangle(1, 2, -3, -4), primary };
-            yield return new object[] { new Rectangle(0, 0, 3, 4), primary };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), primary };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), primary };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), primary };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawLockedFrame_TestData))]
-    public void ControlPaint_DrawLockedFrame_Invoke_Success(Rectangle rectangle, bool primary)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawLockedFrame(graphics, rectangle, primary);
-
-        // Call again to test caching.
-        ControlPaint.DrawLockedFrame(graphics, rectangle, primary);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ControlPaint_DrawLockedFrame_NullGraphics_ThrowsArgumentNullException(bool primary)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawLockedFrame(null, new Rectangle(1, 2, 3, 4), primary));
-    }
-
-    public static IEnumerable<object[]> DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_TestData()
-    {
-        foreach (MenuGlyph glyph in Enum.GetValues(typeof(MenuGlyph)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), glyph };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), glyph };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), glyph };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_TestData))]
-    public void ControlPaint_DrawMenuGlyph_InvokeGraphicsRectangleMenuGlyph_Success(Rectangle rectangle, MenuGlyph glyph)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMenuGlyph(graphics, rectangle, glyph);
-
-        // Call again to test caching.
-        ControlPaint.DrawMenuGlyph(graphics, rectangle, glyph);
-    }
-
-    public static IEnumerable<object[]> DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_Color_Color_TestData()
-    {
-        foreach (MenuGlyph glyph in Enum.GetValues(typeof(MenuGlyph)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), glyph, Color.Red, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Black, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.White, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Empty, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Transparent, Color.Blue };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.Black };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.White };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.Empty };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.Transparent };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), glyph, Color.Red, Color.Red };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), glyph, Color.Red, Color.Red };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), glyph, Color.Red, Color.Red };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_Color_Color_TestData))]
-    public void ControlPaint_DrawMenuGlyph_InvokeGraphicsRectangleMenuGlyphColorColor_Success(Rectangle rectangle, MenuGlyph glyph, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMenuGlyph(graphics, rectangle, glyph, foreColor, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawMenuGlyph(graphics, rectangle, glyph, foreColor, backColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_TestData))]
-    public void ControlPaint_DrawMenuGlyph_InvokeGraphicsIntIntIntIntMenuGlyph_Success(Rectangle rectangle, MenuGlyph glyph)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMenuGlyph(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, glyph);
-
-        // Call again to test caching.
-        ControlPaint.DrawMenuGlyph(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, glyph);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMenuGlyph_Graphics_Rectangle_MenuGlyph_Color_Color_TestData))]
-    public void ControlPaint_DrawMenuGlyph_InvokeGraphicsIntIntIntIntMenuGlyphColorColor_Success(Rectangle rectangle, MenuGlyph glyph, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMenuGlyph(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, glyph, foreColor, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawMenuGlyph(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, glyph, foreColor, backColor);
-    }
-
-    [WinFormsTheory]
-    [InlineData(MenuGlyph.Arrow)]
-    [InlineData(MenuGlyph.Bullet)]
-    [InlineData(MenuGlyph.Checkmark)]
-    public void ControlPaint_DrawMenuGlyph_NullGraphics_ThrowsArgumentNullException(MenuGlyph glyph)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawMenuGlyph(null, new Rectangle(1, 2, 3, 4), glyph));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawMenuGlyph(null, 1, 2, 3, 4, glyph));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, MenuGlyph.Arrow)]
-    [InlineData(0, 4, MenuGlyph.Bullet)]
-    [InlineData(0, 4, MenuGlyph.Checkmark)]
-    [InlineData(3, 0, MenuGlyph.Arrow)]
-    [InlineData(3, 0, MenuGlyph.Bullet)]
-    [InlineData(3, 0, MenuGlyph.Checkmark)]
-    [InlineData(0, 0, MenuGlyph.Arrow)]
-    [InlineData(0, 0, MenuGlyph.Bullet)]
-    [InlineData(0, 0, MenuGlyph.Checkmark)]
-    public void ControlPaint_DrawMenuGlyph_EmptyRectangle_ThrowsArgumentException(int width, int height, MenuGlyph glyph)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawMenuGlyph(graphics, new Rectangle(0, 0, width, height), glyph));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawMenuGlyph(graphics, 0, 0, width, height, glyph));
-    }
-
-    [WinFormsTheory]
-    [InlineData(MenuGlyph.Arrow)]
-    [InlineData(MenuGlyph.Bullet)]
-    [InlineData(MenuGlyph.Checkmark)]
-    public void ControlPaint_DrawMenuGlyph_NegativeWidth_ThrowsArgumentOutOfRangeException(MenuGlyph glyph)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawMenuGlyph(graphics, new Rectangle(0, 0, -3, 4), glyph));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawMenuGlyph(graphics, 0, 0, -3, 4, glyph));
-    }
-
-    [WinFormsTheory]
-    [InlineData(MenuGlyph.Min)]
-    [InlineData(MenuGlyph.Bullet)]
-    [InlineData(MenuGlyph.Checkmark)]
-    public void ControlPaint_DrawMenuGlyph_NegativeHeight_ThrowsArgumentOutOfRangeException(MenuGlyph glyph)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawMenuGlyph(graphics, new Rectangle(0, 0, 3, -4), glyph));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawMenuGlyph(graphics, 0, 0, 3, -4, glyph));
-    }
-
-    public static IEnumerable<object[]> DrawMixedCheckBox_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), state };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMixedCheckBox_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawMixedCheckBox_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMixedCheckBox(graphics, rectangle, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawMixedCheckBox(graphics, rectangle, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMixedCheckBox_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawMixedCheckBox_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawMixedCheckBox(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawMixedCheckBox(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawMixedCheckBox_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawMixedCheckBox(null, new Rectangle(1, 2, 3, 4), state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawMixedCheckBox(null, 1, 2, 3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    public void ControlPaint_DrawMixedCheckBox_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawMixedCheckBox(graphics, new Rectangle(0, 0, width, height), state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawMixedCheckBox(graphics, 0, 0, width, height, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawMixedCheckBox_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawMixedCheckBox(graphics, new Rectangle(0, 0, -3, 4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawMixedCheckBox(graphics, 0, 0, -3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawMixedCheckBox_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawMixedCheckBox(graphics, new Rectangle(0, 0, 3, -4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawMixedCheckBox(graphics, 0, 0, 3, -4, state));
-    }
-
-    public static IEnumerable<object[]> DrawRadioButton_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-        {
-            yield return new object[] { new Rectangle(0, 0, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), state };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), state };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), state };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawRadioButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawRadioButton_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawRadioButton(graphics, rectangle, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawRadioButton(graphics, rectangle, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawRadioButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawRadioButton_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawRadioButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawRadioButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawRadioButton_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawRadioButton(null, new Rectangle(1, 2, 3, 4), state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawRadioButton(null, 1, 2, 3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    public void ControlPaint_DrawRadioButton_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawRadioButton(graphics, new Rectangle(0, 0, width, height), state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawRadioButton(graphics, 0, 0, width, height, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawRadioButton_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawRadioButton(graphics, new Rectangle(0, 0, -3, 4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawRadioButton(graphics, 0, 0, -3, 4, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawRadioButton_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawRadioButton(graphics, new Rectangle(0, 0, 3, -4), state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawRadioButton(graphics, 0, 0, 3, -4, state));
-    }
-
-    public static IEnumerable<object[]> DrawReversibleFrame_TestData()
-    {
-        foreach (FrameStyle style in new FrameStyle[] { FrameStyle.Dashed, FrameStyle.Thick, FrameStyle.Dashed - 1, FrameStyle.Thick + 1 })
-        {
-            yield return new object[] { Rectangle.Empty, Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, -3, -4), Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.ControlLight, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.Control, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), SystemColors.ControlDark, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Black, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.White, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Transparent, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Empty, style };
-            yield return new object[] { new Rectangle(1, 2, 4, 3), Color.Red, style };
-            yield return new object[] { new Rectangle(1, 2, 3, 3), Color.Red, style };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawReversibleFrame_TestData))]
-    public void ControlPaint_DrawReversibleFrame_Invoke_Success(Rectangle rectangle, Color backColor, FrameStyle style)
-    {
-        ControlPaint.DrawReversibleFrame(rectangle, backColor, style);
-
-        // Call again to test caching.
-        ControlPaint.DrawReversibleFrame(rectangle, backColor, style);
-    }
-
-    public static IEnumerable<object[]> DrawReversibleLine_TestData()
-    {
-        yield return new object[] { Point.Empty, Point.Empty, Color.Red };
-        yield return new object[] { new Point(1, 2), new Point(1, 2), Color.Red };
-        yield return new object[] { new Point(2, 3), new Point(1, 2), Color.Red };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.Empty };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.Red };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), SystemColors.ControlLight };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), SystemColors.Control };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), SystemColors.ControlDark };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.Black };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.White };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.Transparent };
-        yield return new object[] { new Point(1, 2), new Point(2, 3), Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawReversibleLine_TestData))]
-    public void ControlPaint_DrawReversibleLine_Invoke_Success(Point start, Point end, Color backColor)
-    {
-        ControlPaint.DrawReversibleLine(start, end, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawReversibleLine(start, end, backColor);
-    }
-
-    public static IEnumerable<object[]> DrawScrollButton_Graphics_Rectangle_ButtonState_TestData()
-    {
-        foreach (ScrollButton button in Enum.GetValues(typeof(ScrollButton)))
-        {
-            foreach (ButtonState state in Enum.GetValues(typeof(ButtonState)))
-            {
-                yield return new object[] { new Rectangle(0, 0, 3, 4), button, state };
-                yield return new object[] { new Rectangle(1, 2, 3, 4), button, state };
-                yield return new object[] { new Rectangle(1, 2, 4, 3), button, state };
-                yield return new object[] { new Rectangle(1, 2, 3, 3), button, state };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawScrollButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawScrollButton_InvokeGraphicsRectangleButtonState_Success(Rectangle rectangle, ScrollButton button, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawScrollButton(graphics, rectangle, button, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawScrollButton(graphics, rectangle, button, state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawScrollButton_Graphics_Rectangle_ButtonState_TestData))]
-    public void ControlPaint_DrawScrollButton_InvokeGraphicsIntIntIntIntButtonState_Success(Rectangle rectangle, ScrollButton button, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawScrollButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, button, state);
-
-        // Call again to test caching.
-        ControlPaint.DrawScrollButton(graphics, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, button, state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawScrollButton_NullGraphics_ThrowsArgumentNullException(ButtonState state)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawScrollButton(null, new Rectangle(1, 2, 3, 4), ScrollButton.Up, state));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawScrollButton(null, 1, 2, 3, 4, ScrollButton.Up, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 4, ButtonState.All)]
-    [InlineData(0, 4, ButtonState.Normal)]
-    [InlineData(3, 0, ButtonState.All)]
-    [InlineData(3, 0, ButtonState.Normal)]
-    [InlineData(0, 0, ButtonState.All)]
-    public void ControlPaint_DrawScrollButton_EmptyRectangle_ThrowsArgumentException(int width, int height, ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawScrollButton(graphics, new Rectangle(0, 0, width, height), ScrollButton.Up, state));
-        Assert.Throws<ArgumentException>(() => ControlPaint.DrawScrollButton(graphics, 0, 0, width, height, ScrollButton.Up, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawScrollButton_NegativeWidth_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawScrollButton(graphics, new Rectangle(0, 0, -3, 4), ScrollButton.Up, state));
-        Assert.Throws<ArgumentOutOfRangeException>("width", () => ControlPaint.DrawScrollButton(graphics, 0, 0, -3, 4, ScrollButton.Up, state));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ButtonState.All)]
-    [InlineData(ButtonState.Normal)]
-    public void ControlPaint_DrawScrollButton_NegativeHeight_ThrowsArgumentOutOfRangeException(ButtonState state)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawScrollButton(graphics, new Rectangle(0, 0, 3, -4), ScrollButton.Up, state));
-        Assert.Throws<ArgumentOutOfRangeException>("height", () => ControlPaint.DrawScrollButton(graphics, 0, 0, 3, -4, ScrollButton.Up, state));
-    }
-
-    public static IEnumerable<object[]> DrawSelectionFrame_TestData()
-    {
-        foreach (bool active in new bool[] { true, false })
-        {
-            yield return new object[] { active, Rectangle.Empty, Rectangle.Empty, Color.Red };
-            yield return new object[] { active, new Rectangle(1, 2, -3, -4), new Rectangle(1, 2, -3, -4), Color.Red };
-            yield return new object[] { active, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), Color.Red };
-            yield return new object[] { active, new Rectangle(1, 2, 3, 4), new Rectangle(0, 1, 4, 5), Color.Red };
-            yield return new object[] { active, new Rectangle(0, 1, 4, 5), new Rectangle(1, 2, 3, 4), Color.Red };
-            yield return new object[] { active, new Rectangle(0, 1, 4, 5), new Rectangle(1, 2, 3, 4), Color.Black };
-            yield return new object[] { active, new Rectangle(0, 1, 4, 5), new Rectangle(1, 2, 3, 4), Color.White };
-            yield return new object[] { active, new Rectangle(0, 1, 4, 5), new Rectangle(1, 2, 3, 4), Color.Transparent };
-            yield return new object[] { active, new Rectangle(0, 1, 4, 5), new Rectangle(1, 2, 3, 4), Color.Empty };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawSelectionFrame_TestData))]
-    public void ControlPaint_DrawSelectionFrame_Invoke_Success(bool active, Rectangle outsideRect, Rectangle insideRect, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawSelectionFrame(graphics, active, outsideRect, insideRect, backColor);
-
-        // Call again to test caching.
-        ControlPaint.DrawSelectionFrame(graphics, active, outsideRect, insideRect, backColor);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ControlPaint_DrawSelectionFrame_NullGraphics_ThrowsArgumentNullException(bool active)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawSelectionFrame(null, active, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), Color.Red));
-    }
-
-    public static IEnumerable<object[]> DrawSizeGrip_Graphics_Color_Rectangle_TestData()
-    {
-        yield return new object[] { Color.Red, Rectangle.Empty };
-        yield return new object[] { Color.Red, new Rectangle(1, 2, -3, -4) };
-        yield return new object[] { Color.Red, new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { Color.Red, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Black, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.White, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Empty, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Transparent, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Red, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Red, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { Color.Red, new Rectangle(1, 2, 4, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawSizeGrip_Graphics_Color_Rectangle_TestData))]
-    public void ControlPaint_DrawSizeGrip_InvokeGraphicsColorRectangle_Success(Color backColor, Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawSizeGrip(graphics, backColor, rectangle);
-
-        // Call again to test caching.
-        ControlPaint.DrawSizeGrip(graphics, backColor, rectangle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawSizeGrip_Graphics_Color_Rectangle_TestData))]
-    public void ControlPaint_DrawSizeGrip_InvokeGraphicsColorIntIntIntInt_Success(Color backColor, Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawSizeGrip(graphics, backColor, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
-
-        // Call again to test caching.
-        ControlPaint.DrawSizeGrip(graphics, backColor, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawSizeGrip_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawSizeGrip(null, Color.Red, new Rectangle(1, 2, 3, 4)));
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawSizeGrip(null, Color.Red, 1, 2, 3, 4));
-    }
-
-    public static IEnumerable<object[]> DrawStringDisabled_Graphics_String_Font_Color_RectangleF_StringFormat_TestData()
-    {
-        foreach (string s in new string[] { null, string.Empty, "string" })
-        {
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new RectangleF(1, 2, 3, 4), null };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, RectangleF.Empty, new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new RectangleF(1, 2, -3, -4), new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new RectangleF(1, 2, 3, 4), new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Black, new RectangleF(1, 2, 3, 4), new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.White, new RectangleF(1, 2, 3, 4), new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Transparent, new RectangleF(1, 2, 3, 4), new StringFormat() };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Empty, new RectangleF(1, 2, 3, 4), new StringFormat() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawStringDisabled_Graphics_String_Font_Color_RectangleF_StringFormat_TestData))]
-    public void ControlPaint_DrawStringDisabled_InvokeGraphicsStringFontColorRectangleFStringFormat_Success(
-        string s, Font font, Color color,
-        RectangleF layoutRectangle, StringFormat format)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawStringDisabled(graphics, s, font, color, layoutRectangle, format);
-
-        // Call again to test caching.
-        ControlPaint.DrawStringDisabled(graphics, s, font, color, layoutRectangle, format);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void ControlPaint_DrawStringDisabled_NullFontWithNullOrEmptyS_Nop(string s)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawStringDisabled(graphics, s, null, Color.Red, new RectangleF(1, 2, 3, 4), null);
-
-        // Call again to test caching.
-        ControlPaint.DrawStringDisabled(graphics, s, null, Color.Red, new RectangleF(1, 2, 3, 4), null);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlPaint_DrawStringDisabled_NullGraphics_ThrowsArgumentNullException(string s)
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawStringDisabled(null, s, SystemFonts.MenuFont, Color.Red, new RectangleF(1, 2, 3, 4), new StringFormat()));
-    }
-
-    public static IEnumerable<object[]> DrawStringDisabled_IDeviceContext_String_Font_Color_RectangleF_TextFormatFlags_TestData()
-    {
-        foreach (string s in new string[] { null, string.Empty, "string" })
-        {
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new Rectangle(1, 2, 3, 4), TextFormatFlags.Default };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, Rectangle.Empty, TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new Rectangle(1, 2, -3, -4), TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Red, new Rectangle(1, 2, 3, 4), TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Black, new Rectangle(1, 2, 3, 4), TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.White, new Rectangle(1, 2, 3, 4), TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Transparent, new Rectangle(1, 2, 3, 4), TextFormatFlags.VerticalCenter };
-            yield return new object[] { s, SystemFonts.MenuFont, Color.Empty, new Rectangle(1, 2, 3, 4), TextFormatFlags.VerticalCenter };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawStringDisabled_IDeviceContext_String_Font_Color_RectangleF_TextFormatFlags_TestData))]
-    public void ControlPaint_DrawStringDisabled_InvokeIDeviceContextStringFontColorRectangleTextFormatFlags_Success(
-       string s, Font font, Color color,
-       Rectangle layoutRectangle, TextFormatFlags format)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawStringDisabled((IDeviceContext)graphics, s, font, color, layoutRectangle, format);
-
-        // Call again to test caching.
-        ControlPaint.DrawStringDisabled((IDeviceContext)graphics, s, font, color, layoutRectangle, format);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ControlPaint_DrawStringDisabled_NullDc_ThrowsArgumentNullException(string s)
-    {
-        Assert.Throws<ArgumentNullException>("dc", () => ControlPaint.DrawStringDisabled(null, s, SystemFonts.MenuFont, Color.Red, new Rectangle(1, 2, 3, 4), TextFormatFlags.Default));
-    }
-
-    public static IEnumerable<object[]> DrawVisualStyleBorder_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 4, 3) };
-        yield return new object[] { new Rectangle(1, 2, 3, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawVisualStyleBorder_TestData))]
-    public void ControlPaint_DrawVisualStyleBorder_Invoke_Success(Rectangle rectangle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        ControlPaint.DrawVisualStyleBorder(graphics, rectangle);
-
-        // Call again to test caching.
-        ControlPaint.DrawVisualStyleBorder(graphics, rectangle);
-    }
-
-    [WinFormsFact]
-    public void ControlPaint_DrawVisualStyleBorder_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => ControlPaint.DrawVisualStyleBorder(null, new Rectangle(1, 2, 3, 4)));
-    }
-
-    public static IEnumerable<object[]> FillReversibleRectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Color.Red };
-        yield return new object[] { new Rectangle(1, 2, -3, -4), Color.Red };
-        yield return new object[] { new Rectangle(0, 0, 3, 4), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Black };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.White };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Color.Transparent };
-        yield return new object[] { new Rectangle(1, 2, 4, 3), Color.Red };
-        yield return new object[] { new Rectangle(1, 2, 3, 3), Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FillReversibleRectangle_TestData))]
-    public void ControlPaint_FillReversibleRectangle_Invoke_Success(Rectangle rectangle, Color backColor)
-    {
-        ControlPaint.FillReversibleRectangle(rectangle, backColor);
-
-        // Call again to test caching.
-        ControlPaint.FillReversibleRectangle(rectangle, backColor);
-    }
-
-    public static IEnumerable<object[]> IsDark_TestData()
-    {
-        yield return new object[] { Color.White, false };
-        yield return new object[] { Color.Black, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsDark_TestData))]
-    public void ControlPaint_IsDark(Color color, bool expected)
-    {
-        bool result = ControlPaint.IsDark(color);
-
-        Assert.Equal(expected, result);
-    }
-
-    public static IEnumerable<object[]> Light_Color_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 255, 64, 64) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), Color.FromArgb(255, 64, 255, 64) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 64, 64, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 255, 255, 64) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), Color.FromArgb(255, 255, 64, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), Color.FromArgb(255, 64, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), Color.FromArgb(255, 0, 191, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), Color.FromArgb(255, 0, 149, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), Color.FromArgb(255, 0, 134, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), Color.FromArgb(255, 0, 130, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 63, 63, 63) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), Color.FromArgb(255, 157, 87, 221) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), Color.FromArgb(255, 255, 213, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, Color.FromArgb(255, 142, 142, 142) };
-        yield return new object[] { SystemColors.ControlDark, Color.FromArgb(255, 183, 183, 183) };
-        yield return new object[] { SystemColors.Control, Color.FromArgb(255, 241, 241, 241) };
-        yield return new object[] { SystemColors.ControlLight, Color.FromArgb(255, 233, 233, 233) };
-        yield return new object[] { SystemColors.ControlLightLight, Color.FromArgb(255, 255, 255, 255) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Light_Color_TestData))]
-    public void ControlPaint_Light_InvokeColor_ReturnsExpected(Color baseColor, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.Light(baseColor));
-
-        // Call again to test caching.
-        Assert.Equal(expected, ControlPaint.Light(baseColor));
-    }
-
-    public static IEnumerable<object[]> Light_Color_Float_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -1.5f, Color.FromArgb(255, 64, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -1.5f, Color.FromArgb(255, 0, 64, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -1.5f, Color.FromArgb(255, 0, 0, 64) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -1.5f, Color.FromArgb(255, 64, 64, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -1.5f, Color.FromArgb(255, 64, 0, 64) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -1.5f, Color.FromArgb(255, 0, 64, 64) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -1.5f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -1.5f, Color.FromArgb(255, 0, 24, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -1.5f, Color.FromArgb(255, 0, 178, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -1.5f, Color.FromArgb(255, 0, 146, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -1.5f, Color.FromArgb(255, 0, 134, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -1.5f, Color.FromArgb(255, 65, 65, 65) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -1.5f, Color.FromArgb(255, 19, 6, 30) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -1.5f, Color.FromArgb(255, 255, 159, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -1.5f, Color.FromArgb(255, 249, 249, 249) };
-        yield return new object[] { SystemColors.ControlDark, -1.5f, Color.FromArgb(255, 89, 89, 89) };
-        yield return new object[] { SystemColors.Control, -1.5f, Color.FromArgb(255, 185, 185, 185) };
-        yield return new object[] { SystemColors.ControlLight, -1.5f, Color.FromArgb(255, 207, 207, 207) };
-        yield return new object[] { SystemColors.ControlLightLight, -1.5f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -1f, Color.FromArgb(255, 128, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -1f, Color.FromArgb(255, 0, 128, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -1f, Color.FromArgb(255, 0, 0, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -1f, Color.FromArgb(255, 128, 128, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -1f, Color.FromArgb(255, 128, 0, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -1f, Color.FromArgb(255, 0, 128, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -1f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -1f, Color.FromArgb(255, 0, 131, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -1f, Color.FromArgb(255, 0, 43, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -1f, Color.FromArgb(255, 0, 16, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -1f, Color.FromArgb(255, 0, 5, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -1f, Color.FromArgb(255, 129, 129, 129) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -1f, Color.FromArgb(255, 54, 17, 87) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -1f, Color.FromArgb(255, 255, 172, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -1f, Color.FromArgb(255, 29, 29, 29) };
-        yield return new object[] { SystemColors.ControlDark, -1f, Color.FromArgb(255, 112, 112, 112) };
-        yield return new object[] { SystemColors.Control, -1f, Color.FromArgb(255, 199, 199, 199) };
-        yield return new object[] { SystemColors.ControlLight, -1f, Color.FromArgb(255, 213, 213, 213) };
-        yield return new object[] { SystemColors.ControlLightLight, -1f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -0.5f, Color.FromArgb(255, 191, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -0.5f, Color.FromArgb(255, 0, 191, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -0.5f, Color.FromArgb(255, 0, 0, 191) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -0.5f, Color.FromArgb(255, 191, 191, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -0.5f, Color.FromArgb(255, 191, 0, 191) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -0.5f, Color.FromArgb(255, 0, 191, 191) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -0.5f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -0.5f, Color.FromArgb(255, 0, 237, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -0.5f, Color.FromArgb(255, 0, 165, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -0.5f, Color.FromArgb(255, 0, 141, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -0.5f, Color.FromArgb(255, 0, 133, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -0.5f, Color.FromArgb(255, 193, 193, 193) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -0.5f, Color.FromArgb(255, 89, 29, 143) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -0.5f, Color.FromArgb(255, 255, 187, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -0.5f, Color.FromArgb(255, 68, 68, 68) };
-        yield return new object[] { SystemColors.ControlDark, -0.5f, Color.FromArgb(255, 137, 137, 137) };
-        yield return new object[] { SystemColors.Control, -0.5f, Color.FromArgb(255, 213, 213, 213) };
-        yield return new object[] { SystemColors.ControlLight, -0.5f, Color.FromArgb(255, 221, 221, 221) };
-        yield return new object[] { SystemColors.ControlLightLight, -0.5f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), -0.25f, Color.FromArgb(255, 223, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), -0.25f, Color.FromArgb(255, 0, 223, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), -0.25f, Color.FromArgb(255, 0, 0, 223) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), -0.25f, Color.FromArgb(255, 223, 223, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), -0.25f, Color.FromArgb(255, 223, 0, 223) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), -0.25f, Color.FromArgb(255, 0, 223, 223) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), -0.25f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), -0.25f, Color.FromArgb(255, 0, 32, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), -0.25f, Color.FromArgb(255, 0, 226, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), -0.25f, Color.FromArgb(255, 0, 205, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), -0.25f, Color.FromArgb(255, 0, 196, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), -0.25f, Color.FromArgb(255, 225, 225, 225) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), -0.25f, Color.FromArgb(255, 106, 34, 172) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), -0.25f, Color.FromArgb(255, 255, 193, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, -0.25f, Color.FromArgb(255, 87, 87, 87) };
-        yield return new object[] { SystemColors.ControlDark, -0.25f, Color.FromArgb(255, 148, 148, 148) };
-        yield return new object[] { SystemColors.Control, -0.25f, Color.FromArgb(255, 220, 220, 220) };
-        yield return new object[] { SystemColors.ControlLight, -0.25f, Color.FromArgb(255, 224, 224, 224) };
-        yield return new object[] { SystemColors.ControlLightLight, -0.25f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0f, Color.FromArgb(255, 255, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0f, Color.FromArgb(255, 0, 255, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0f, Color.FromArgb(255, 0, 0, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0f, Color.FromArgb(255, 255, 255, 0) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0f, Color.FromArgb(255, 255, 0, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0f, Color.FromArgb(255, 0, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0f, Color.FromArgb(255, 0, 85, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0f, Color.FromArgb(255, 0, 28, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0f, Color.FromArgb(255, 0, 9, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0f, Color.FromArgb(255, 0, 2, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0f, Color.FromArgb(255, 0, 0, 0) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0f, Color.FromArgb(255, 124, 40, 200) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0f, Color.FromArgb(255, 255, 200, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0f, Color.FromArgb(255, 105, 105, 105) };
-        yield return new object[] { SystemColors.ControlDark, 0f, Color.FromArgb(255, 160, 160, 160) };
-        yield return new object[] { SystemColors.Control, 0f, SystemColors.ControlLight };
-        yield return new object[] { SystemColors.ControlLight, 0f, Color.FromArgb(255, 227, 227, 227) };
-        yield return new object[] { SystemColors.ControlLightLight, 0f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0.25f, Color.FromArgb(255, 255, 32, 32) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0.25f, Color.FromArgb(255, 32, 255, 32) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0.25f, Color.FromArgb(255, 32, 32, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0.25f, Color.FromArgb(255, 255, 255, 32) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0.25f, Color.FromArgb(255, 255, 32, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0.25f, Color.FromArgb(255, 32, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0.25f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0.25f, Color.FromArgb(255, 0, 138, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0.25f, Color.FromArgb(255, 0, 87, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0.25f, Color.FromArgb(255, 0, 70, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0.25f, Color.FromArgb(255, 0, 66, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0.25f, Color.FromArgb(255, 31, 31, 31) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0.25f, Color.FromArgb(255, 141, 58, 216) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0.25f, Color.FromArgb(255, 255, 206, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0.25f, Color.FromArgb(255, 123, 123, 123) };
-        yield return new object[] { SystemColors.ControlDark, 0.25f, Color.FromArgb(255, 172, 172, 172) };
-        yield return new object[] { SystemColors.Control, 0.25f, Color.FromArgb(255, 234, 234, 234) };
-        yield return new object[] { SystemColors.ControlLight, 0.25f, Color.FromArgb(255, 230, 230, 230) };
-        yield return new object[] { SystemColors.ControlLightLight, 0.25f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 0.5f, Color.FromArgb(255, 255, 64, 64) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 0.5f, Color.FromArgb(255, 64, 255, 64) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 0.5f, Color.FromArgb(255, 64, 64, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 0.5f, Color.FromArgb(255, 255, 255, 64) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 0.5f, Color.FromArgb(255, 255, 64, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 0.5f, Color.FromArgb(255, 64, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 0.5f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 0.5f, Color.FromArgb(255, 0, 191, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 0.5f, Color.FromArgb(255, 0, 149, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 0.5f, Color.FromArgb(255, 0, 134, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 0.5f, Color.FromArgb(255, 0, 130, 0) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 0.5f, Color.FromArgb(255, 63, 63, 63) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 0.5f, Color.FromArgb(255, 157, 87, 221) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 0.5f, Color.FromArgb(255, 255, 213, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 0.5f, Color.FromArgb(255, 142, 142, 142) };
-        yield return new object[] { SystemColors.ControlDark, 0.5f, Color.FromArgb(255, 183, 183, 183) };
-        yield return new object[] { SystemColors.Control, 0.5f, Color.FromArgb(255, 241, 241, 241) };
-        yield return new object[] { SystemColors.ControlLight, 0.5f, Color.FromArgb(255, 233, 233, 233) };
-        yield return new object[] { SystemColors.ControlLightLight, 0.5f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 1f, Color.FromArgb(255, 255, 128, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 1f, Color.FromArgb(255, 128, 255, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 1f, Color.FromArgb(255, 128, 128, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 1f, Color.FromArgb(255, 255, 255, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 1f, Color.FromArgb(255, 255, 128, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 1f, Color.FromArgb(255, 128, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 1f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 1f, Color.FromArgb(255, 43, 255, 43) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 1f, Color.FromArgb(255, 15, 255, 15) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 1f, Color.FromArgb(255, 4, 255, 4) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 1f, Color.FromArgb(255, 2, 255, 2) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 1f, Color.FromArgb(255, 127, 127, 127) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 1f, Color.FromArgb(255, 190, 143, 233) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 1f, Color.FromArgb(255, 255, 227, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 1f, Color.FromArgb(255, 180, 180, 180) };
-        yield return new object[] { SystemColors.ControlDark, 1f, Color.FromArgb(255, 208, 208, 208) };
-        yield return new object[] { SystemColors.Control, 1f, SystemColors.ControlLightLight };
-        yield return new object[] { SystemColors.ControlLight, 1f, Color.FromArgb(255, 241, 241, 241) };
-        yield return new object[] { SystemColors.ControlLightLight, 1f, Color.FromArgb(255, 255, 255, 255) };
-
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), 1.5f, Color.FromArgb(255, 255, 191, 191) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), 1.5f, Color.FromArgb(255, 191, 255, 191) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), 1.5f, Color.FromArgb(255, 191, 191, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), 1.5f, Color.FromArgb(255, 255, 255, 191) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), 1.5f, Color.FromArgb(255, 255, 191, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), 1.5f, Color.FromArgb(255, 191, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), 1.5f, Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), 1.5f, Color.FromArgb(255, 149, 255, 149) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), 1.5f, Color.FromArgb(255, 136, 255, 136) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), 1.5f, Color.FromArgb(255, 130, 255, 130) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), 1.5f, Color.FromArgb(255, 130, 255, 130) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), 1.5f, Color.FromArgb(255, 191, 191, 191) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), 1.5f, Color.FromArgb(255, 223, 200, 244) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), 1.5f, Color.FromArgb(255, 255, 240, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, 1.5f, Color.FromArgb(255, 217, 217, 217) };
-        yield return new object[] { SystemColors.ControlDark, 1.5f, Color.FromArgb(255, 231, 231, 231) };
-        yield return new object[] { SystemColors.Control, 1.5f, Color.FromArgb(255, 13, 13, 13) };
-        yield return new object[] { SystemColors.ControlLight, 1.5f, Color.FromArgb(255, 247, 247, 247) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Light_Color_Float_TestData))]
-    private void ControlPaint_Light_InvokeColorFloat_ReturnsExpected(Color baseColor, float percOfLightLight, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.Light(baseColor, percOfLightLight));
-
-        // Call again to test caching.
-        Assert.Equal(expected, ControlPaint.Light(baseColor, percOfLightLight));
-    }
-
-    public static IEnumerable<object[]> LightLight_TestData()
-    {
-        yield return new object[] { Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 255, 128, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 0), Color.FromArgb(255, 128, 255, 128) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 255), Color.FromArgb(255, 128, 128, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 0), Color.FromArgb(255, 255, 255, 128) };
-        yield return new object[] { Color.FromArgb(255, 255, 0, 255), Color.FromArgb(255, 255, 128, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 255, 255), Color.FromArgb(255, 128, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 255, 255, 255), Color.FromArgb(255, 255, 255, 255) };
-        yield return new object[] { Color.FromArgb(255, 0, 85, 0), Color.FromArgb(255, 43, 255, 43) };
-        yield return new object[] { Color.FromArgb(255, 0, 28, 0), Color.FromArgb(255, 15, 255, 15) };
-        yield return new object[] { Color.FromArgb(255, 0, 9, 0), Color.FromArgb(255, 4, 255, 4) };
-        yield return new object[] { Color.FromArgb(255, 0, 2, 0), Color.FromArgb(255, 2, 255, 2) };
-        yield return new object[] { Color.FromArgb(255, 0, 0, 0), Color.FromArgb(255, 127, 127, 127) };
-        yield return new object[] { Color.FromArgb(255, 125, 40, 200), Color.FromArgb(255, 190, 143, 233) };
-        yield return new object[] { Color.FromArgb(0, 255, 200, 255), Color.FromArgb(255, 255, 227, 255) };
-        yield return new object[] { SystemColors.ControlDarkDark, Color.FromArgb(255, 180, 180, 180) };
-        yield return new object[] { SystemColors.ControlDark, Color.FromArgb(255, 208, 208, 208) };
-        yield return new object[] { SystemColors.Control, SystemColors.ControlLightLight };
-        yield return new object[] { SystemColors.ControlLight, Color.FromArgb(255, 241, 241, 241) };
-        yield return new object[] { SystemColors.ControlLightLight, Color.FromArgb(255, 255, 255, 255) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LightLight_TestData))]
-    public void ControlPaint_LightLight_InvokeColor_ReturnsExpected(Color baseColor, Color expected)
-    {
-        Assert.Equal(expected, ControlPaint.LightLight(baseColor));
-
-        // Call again to test caching.
-        Assert.Equal(expected, ControlPaint.LightLight(baseColor));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.ControlCollection.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.ControlCollection.cs
deleted file mode 100644
index f606dab30b5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.ControlCollection.cs
+++ /dev/null
@@ -1,3538 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads (instantiated via GUID)
-public class ControlControlCollectionTests
-{
-    [WinFormsFact]
-    public void ControlCollection_Ctor_Control()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Empty(collection);
-        Assert.False(collection.IsReadOnly);
-        Assert.Same(owner, collection.Owner);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new Control.ControlCollection(null));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_ControlNewCollection_Success()
-    {
-        using var owner = new Control();
-        using var control1 = new Control();
-        using var control2 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(collection.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int layoutCallCount1 = 0;
-        control1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        control2.Layout += (sender, e) => layoutCallCount2++;
-
-        try
-        {
-            collection.Add(control1);
-            Assert.Same(control1, Assert.Single(collection));
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-
-            // Add another.
-            collection.Add(control2);
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add existing.
-            Assert.Throws<ArgumentException>(() => collection.Add(control2));
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add null.
-            collection.Add(null);
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_ControlExistingCollection_Success()
-    {
-        using var owner = new Control();
-        using var control1 = new Control();
-        using var control2 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        int parentLayoutCallCount = 0;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(collection.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int layoutCallCount1 = 0;
-        control1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        control2.Layout += (sender, e) => layoutCallCount2++;
-
-        try
-        {
-            affectedProperty = "Parent";
-            collection.Add(control1);
-            Assert.Same(control1, Assert.Single(collection));
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(control1, Assert.Single(owner.Controls));
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-
-            // Add another.
-            collection.Add(control2);
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add existing.
-            affectedProperty = "ChildIndex";
-            collection.Add(control1);
-            Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(3, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add null.
-            collection.Add(null);
-            Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_ControlHasParent_Success()
-    {
-        using var owner1 = new Control();
-        using var owner2 = new Control();
-        using var control = new Control();
-        Control.ControlCollection collection1 = owner1.Controls;
-        Control.ControlCollection collection2 = owner2.Controls;
-        int layoutCallCount = 0;
-        string affectedProperty = "Parent";
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner2, sender);
-            Assert.Same(collection2.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        owner2.Layout += parentHandler;
-
-        try
-        {
-            collection1.Add(control);
-            collection2.Add(control);
-            Assert.Same(control, Assert.Single(collection2));
-            Assert.Empty(collection1);
-            Assert.Same(owner2, control.Parent);
-            Assert.Equal(0, control.TabIndex);
-            Assert.Same(control, Assert.Single(owner2.Controls));
-            Assert.Equal(1, layoutCallCount);
-            Assert.False(owner2.IsHandleCreated);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            owner2.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_ControlWithCustomLayoutEngine_Success()
-    {
-        using var owner = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        int layoutCallCount = 0;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(collection.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        using var control = new CustomLayoutEngineControl();
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.InitLayout(control, BoundsSpecified.All))
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-
-        try
-        {
-            affectedProperty = "Parent";
-            collection.Add(control);
-            Assert.Same(control, Assert.Single(collection));
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(0, control.TabIndex);
-            Assert.Same(control, Assert.Single(owner.Controls));
-            Assert.Equal(1, layoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control.IsHandleCreated);
-            mockLayoutEngine.Verify(e => e.InitLayout(control, BoundsSpecified.All), Times.Once());
-
-            // Add existing.
-            affectedProperty = "ChildIndex";
-            collection.Add(control);
-            Assert.Same(control, Assert.Single(collection));
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(0, control.TabIndex);
-            Assert.Same(control, Assert.Single(owner.Controls));
-            Assert.Equal(2, layoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control.IsHandleCreated);
-            mockLayoutEngine.Verify(e => e.InitLayout(control, BoundsSpecified.All), Times.Once());
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_TabIndex_Success()
-    {
-        using var owner = new SubControl();
-        Control.ControlCollection collection = owner.Controls;
-        using var control1 = new SubControl
-        {
-            TabIndex = 1
-        };
-        int tabIndexChangedCallCount1 = 0;
-        control1.TabIndexChanged += (sender, e) => tabIndexChangedCallCount1++;
-
-        collection.Add(control1);
-        Assert.Equal(new Control[] { control1 }, collection.Cast<Control>());
-        Assert.Same(owner, control1.Parent);
-        Assert.Equal(1, control1.TabIndex);
-        Assert.Equal(0, tabIndexChangedCallCount1);
-
-        // Add another.
-        using var control2 = new SubControl();
-        int tabIndexChangedCallCount2 = 0;
-        control2.TabIndexChanged += (sender, e) => tabIndexChangedCallCount2++;
-        collection.Add(control2);
-        Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-        Assert.Same(owner, control1.Parent);
-        Assert.Equal(1, control1.TabIndex);
-        Assert.Equal(0, tabIndexChangedCallCount1);
-        Assert.Same(owner, control2.Parent);
-        Assert.Equal(2, control2.TabIndex);
-        Assert.Equal(0, tabIndexChangedCallCount2);
-
-        // Add another.
-        control1.TabIndex = 10;
-        using var control3 = new SubControl();
-        int tabIndexChangedCallCount3 = 0;
-        control3.TabIndexChanged += (sender, e) => tabIndexChangedCallCount3++;
-        collection.Add(control3);
-        Assert.Equal(new Control[] { control1, control2, control3 }, collection.Cast<Control>());
-        Assert.Same(owner, control1.Parent);
-        Assert.Equal(10, control1.TabIndex);
-        Assert.Equal(1, tabIndexChangedCallCount1);
-        Assert.Same(owner, control2.Parent);
-        Assert.Equal(2, control2.TabIndex);
-        Assert.Equal(0, tabIndexChangedCallCount2);
-        Assert.Same(owner, control3.Parent);
-        Assert.Equal(11, control3.TabIndex);
-        Assert.Equal(0, tabIndexChangedCallCount3);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ControlCollection_Add_InvokeValueWithoutHandleOwnerWithHandle_CreatedValueIfVisible(bool visible)
-    {
-        using var owner = new Control();
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        Control.ControlCollection collection = owner.Controls;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        collection.Add(control);
-        Assert.Same(control, Assert.Single(collection));
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(visible, control.Visible);
-        Assert.Equal(visible, control.IsHandleCreated);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ControlCollection_Add_InvokeValueWithHandleOwnerWithoutHandle_Success(bool visible)
-    {
-        using var owner = new Control();
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        Control.ControlCollection collection = owner.Controls;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Add(control);
-        Assert.Same(control, Assert.Single(collection));
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(visible, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ControlCollection_Add_InvokeValueWithHandleOwnerWithHandleControlNewCollection_Success(bool visible)
-    {
-        using var owner = new Control();
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        var collection = new Control.ControlCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<ArgumentException>(() => collection.Add(control));
-        Assert.Same(control, Assert.Single(collection));
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(visible, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ControlCollection_Add_InvokeValueWithHandleOwnerWithHandleControlExistingCollection_Success(bool visible)
-    {
-        using var owner = new Control();
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        Control.ControlCollection collection = owner.Controls;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Add(control);
-        Assert.Equal(owner.Handle, PInvoke.GetParent(control));
-        Assert.Same(control, Assert.Single(collection));
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(visible, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_InvokeWithHandler_CallsControlAdded()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        int parentChangedCallCount = 0;
-        int callCount = 0;
-        int parentLayoutCallCount = 0;
-        child1.ParentChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            parentChangedCallCount++;
-        };
-        child2.ParentChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            parentChangedCallCount++;
-        };
-        object affectedControl = null;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        void handler(object sender, ControlEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.Control);
-            Assert.Equal(parentChangedCallCount - 1, callCount);
-            Assert.Equal(parentLayoutCallCount - 1, callCount);
-            callCount++;
-        }
-
-        try
-        {
-            // Call with handler.
-            owner.ControlAdded += handler;
-            affectedControl = child1;
-            affectedProperty = "Parent";
-            collection.Add(child1);
-            Assert.Same(owner, child1.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(1, callCount);
-
-            // Call again.
-            affectedProperty = "ChildIndex";
-            collection.Add(child1);
-            Assert.Same(owner, child1.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Equal(1, callCount);
-
-            // Remove handler.
-            owner.ControlAdded -= handler;
-            affectedControl = child2;
-            affectedProperty = "Parent";
-            collection.Add(child2);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(2, parentChangedCallCount);
-            Assert.Equal(3, parentLayoutCallCount);
-            Assert.Equal(1, callCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_InvokeWithNonOverridenProperties_DoesNotCallPropertyHandlers()
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        control.ParentChanged += (sender, e) => parentChangedCallCount++;
-        control.EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        control.VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        control.FontChanged += (sender, e) => fontChangedCallCount++;
-        control.ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        control.BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        control.RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Add(control);
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(0, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(0, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(0, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, bindingContextChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_InvokeWithNonOverridenPropertiesWithHandle_DoesNotCallPropertyHandlers()
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        control.ParentChanged += (sender, e) => parentChangedCallCount++;
-        control.EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        control.VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        control.FontChanged += (sender, e) => fontChangedCallCount++;
-        control.ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        control.BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        control.RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Add(control);
-        Assert.Same(owner, control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(0, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(0, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(0, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(1, bindingContextChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Add_OverridenProperties_TestData()
-    {
-        var parentContext = new BindingContext();
-        var childContext = new BindingContext();
-        yield return new object[] { parentContext, childContext, childContext };
-        yield return new object[] { parentContext, null, parentContext };
-        yield return new object[] { null, childContext, childContext };
-        yield return new object[] { null, null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_OverridenProperties_TestData))]
-    public void ControlCollection_Add_InvokeWithOverridenProperties_CallsPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext)
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-
-        owner.Enabled = false;
-        Assert.True(control.Enabled);
-        owner.Visible = false;
-        Assert.True(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(bindingContext, control.BindingContext);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            Assert.Equal(enabledChangedCallCount, parentChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, parentChangedCallCount);
-            Assert.Equal(fontChangedCallCount, parentChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, parentChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        }
-
-        control.ParentChanged += parentChangedHandler;
-        control.EnabledChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, enabledChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(fontChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, enabledChangedCallCount);
-            enabledChangedCallCount++;
-        };
-        control.VisibleChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(fontChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, visibleChangedCallCount);
-            visibleChangedCallCount++;
-        };
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, fontChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, fontChangedCallCount);
-            fontChangedCallCount++;
-        };
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, foreColorChangedCallCount);
-            foreColorChangedCallCount++;
-        };
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, backColorChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, backColorChangedCallCount);
-            backColorChangedCallCount++;
-        };
-        control.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(backColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, rightToLeftChangedCallCount);
-            rightToLeftChangedCallCount++;
-        };
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        try
-        {
-            collection.Add(control);
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.False(control.Enabled);
-            Assert.Equal(1, enabledChangedCallCount);
-            Assert.False(control.Visible);
-            Assert.Equal(1, visibleChangedCallCount);
-            Assert.Same(font, control.Font);
-            Assert.Equal(1, fontChangedCallCount);
-            Assert.Equal(Color.Red, control.ForeColor);
-            Assert.Equal(1, foreColorChangedCallCount);
-            Assert.Equal(Color.Blue, control.BackColor);
-            Assert.Equal(1, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-            Assert.Equal(1, rightToLeftChangedCallCount);
-            Assert.Same(expectedBindingContext, control.BindingContext);
-            Assert.Equal(0, bindingContextChangedCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Add_OverridenPropertiesWithHandle_TestData()
-    {
-        var parentContext = new BindingContext();
-        var childContext = new BindingContext();
-        yield return new object[] { parentContext, childContext, childContext, 0 };
-        yield return new object[] { parentContext, null, parentContext, 1 };
-        yield return new object[] { null, childContext, childContext, 0 };
-        yield return new object[] { null, null, null, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_OverridenPropertiesWithHandle_TestData))]
-    public void ControlCollection_Add_InvokeWithOverridenPropertiesWithHandle_CallsPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext, int expectedBindingContextChangedCallCount)
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-
-        owner.Enabled = false;
-        Assert.True(control.Enabled);
-        owner.Visible = false;
-        Assert.True(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(bindingContext, control.BindingContext);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            Assert.Equal(enabledChangedCallCount, parentChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, parentChangedCallCount);
-            Assert.Equal(fontChangedCallCount, parentChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        }
-
-        control.ParentChanged += parentChangedHandler;
-        control.EnabledChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, enabledChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(fontChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, enabledChangedCallCount);
-            enabledChangedCallCount++;
-        };
-        control.VisibleChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(fontChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, visibleChangedCallCount);
-            visibleChangedCallCount++;
-        };
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, fontChangedCallCount);
-            fontChangedCallCount++;
-        };
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, foreColorChangedCallCount);
-            foreColorChangedCallCount++;
-        };
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, backColorChangedCallCount);
-            backColorChangedCallCount++;
-        };
-        control.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(backColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            rightToLeftChangedCallCount++;
-        };
-        control.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, bindingContextChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, bindingContextChangedCallCount);
-            Assert.Equal(visibleChangedCallCount - 1, bindingContextChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, bindingContextChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, bindingContextChangedCallCount);
-            Assert.Equal(backColorChangedCallCount - 1, bindingContextChangedCallCount);
-            bindingContextChangedCallCount++;
-        };
-
-        try
-        {
-            collection.Add(control);
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.False(control.Enabled);
-            Assert.Equal(1, enabledChangedCallCount);
-            Assert.False(control.Visible);
-            Assert.Equal(1, visibleChangedCallCount);
-            Assert.Same(font, control.Font);
-            Assert.Equal(1, fontChangedCallCount);
-            Assert.Equal(Color.Red, control.ForeColor);
-            Assert.Equal(1, foreColorChangedCallCount);
-            Assert.Equal(Color.Blue, control.BackColor);
-            Assert.Equal(1, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-            Assert.Equal(1, rightToLeftChangedCallCount);
-            Assert.Same(expectedBindingContext, control.BindingContext);
-            Assert.Equal(expectedBindingContextChangedCallCount, bindingContextChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(1, createdCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_OverridenProperties_TestData))]
-    public void ControlCollection_Add_InvokeWithOverridenPropertiesAxHost_DoesNotCallPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext)
-    {
-        using var owner = new Control();
-        using var control = new SubAxHost("8856f961-340a-11d0-a96b-00c04fd705a2");
-        var collection = new Control.ControlCollection(owner);
-
-        owner.Enabled = false;
-        Assert.True(control.Enabled);
-        owner.Visible = false;
-        Assert.True(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(bindingContext, control.BindingContext);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            parentChangedCallCount++;
-        }
-
-        ((Control)control).ParentChanged += parentChangedHandler;
-        ((Control)control).EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        ((Control)control).VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        ((Control)control).FontChanged += (sender, e) => fontChangedCallCount++;
-        ((Control)control).ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        ((Control)control).BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        ((Control)control).RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        ((Control)control).BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Add(control);
-        try
-        {
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.False(control.Enabled);
-            Assert.Equal(0, enabledChangedCallCount);
-            Assert.False(control.Visible);
-            Assert.Equal(0, visibleChangedCallCount);
-            Assert.Same(font, control.Font);
-            Assert.Equal(0, fontChangedCallCount);
-            Assert.Equal(Color.Red, control.ForeColor);
-            Assert.Equal(0, foreColorChangedCallCount);
-            Assert.Equal(Color.Blue, control.BackColor);
-            Assert.Equal(0, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.Yes, ((Control)control).RightToLeft);
-            Assert.Equal(0, rightToLeftChangedCallCount);
-            Assert.Same(expectedBindingContext, control.BindingContext);
-            Assert.Equal(0, bindingContextChangedCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_OverridenPropertiesWithHandle_TestData))]
-    public void ControlCollection_Add_InvokeWithOverridenPropertiesAxHostWithHandle_CallSPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext, int expectedBindingContextChangedCallCount)
-    {
-        using var owner = new Control();
-        using var control = new SubAxHost("8856f961-340a-11d0-a96b-00c04fd705a2");
-        var collection = new Control.ControlCollection(owner);
-
-        owner.Enabled = false;
-        Assert.True(control.Enabled);
-        owner.Visible = false;
-        Assert.True(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(bindingContext, control.BindingContext);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            parentChangedCallCount++;
-        }
-
-        ((Control)control).ParentChanged += parentChangedHandler;
-        ((Control)control).EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        ((Control)control).VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        ((Control)control).FontChanged += (sender, e) => fontChangedCallCount++;
-        ((Control)control).ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        ((Control)control).BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        ((Control)control).RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        ((Control)control).BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        try
-        {
-            collection.Add(control);
-            Assert.Same(owner, control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.False(control.Enabled);
-            Assert.Equal(1, enabledChangedCallCount);
-            Assert.False(control.Visible);
-            Assert.Equal(1, visibleChangedCallCount);
-            Assert.Same(font, control.Font);
-            Assert.Equal(1, fontChangedCallCount);
-            Assert.Equal(Color.Red, control.ForeColor);
-            Assert.Equal(1, foreColorChangedCallCount);
-            Assert.Equal(Color.Blue, control.BackColor);
-            Assert.Equal(1, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.Yes, ((Control)control).RightToLeft);
-            Assert.Equal(1, rightToLeftChangedCallCount);
-            Assert.Same(expectedBindingContext, control.BindingContext);
-            Assert.Equal(expectedBindingContextChangedCallCount, bindingContextChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(6, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    private class SubAxHost : AxHost
-    {
-        public SubAxHost(string clsid) : base(clsid)
-        {
-        }
-
-        public SubAxHost(string clsid, int flags) : base(clsid, flags)
-        {
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_TopLevelValue_ThrowsArgumentException()
-    {
-        using var owner = new Control();
-        using var control = new SubControl();
-        control.SetTopLevel(true);
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(control));
-    }
-
-    [Fact] // cross-thread access
-    public void ControlCollection_Add_DifferentThreadValueOwner_ThrowsArgumentException()
-    {
-        Control owner = null;
-        var thread = new Thread(() =>
-        {
-            owner = new Control();
-            Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        });
-        thread.Start();
-        thread.Join();
-
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(control));
-    }
-
-    [Fact] // cross-thread access
-    public void ControlCollection_Add_DifferentThreadValueControl_ThrowsArgumentException()
-    {
-        Control control = null;
-        var thread = new Thread(() =>
-        {
-            control = new Control();
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-        });
-        thread.Start();
-        thread.Join();
-
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(control));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_SameAsOwner_ThrowsArgumentException()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(owner));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_OwnerParent_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var owner = new Control
-        {
-            Parent = parent
-        };
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(parent));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_OwnerGrandParent_ThrowsArgumentException()
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var owner = new Control
-        {
-            Parent = parent
-        };
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(grandparent));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_AddRange_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        int parentLayoutCallCount = 0;
-        object affectedControl = null;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int controlAddedCallCount = 0;
-        owner.ControlAdded += (sender, e) => controlAddedCallCount++;
-
-        try
-        {
-            affectedControl = child3;
-            affectedProperty = "Parent";
-            collection.AddRange(new Control[] { child1, child2, null, child3 });
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            affectedControl = child1;
-            affectedProperty = "ChildIndex";
-            collection.AddRange(new Control[] { child1, child2, null, child3 });
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Add empty.
-            collection.AddRange(Array.Empty<Control>());
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_AddRange_NullControls_ThrowsArgumentNullException()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentNullException>("controls", () => collection.AddRange(null));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Clear_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-        int parentLayoutCallCount = 0;
-        owner.Layout += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child3, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        };
-        int controlRemovedCallCount = 0;
-        owner.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(child1.Parent);
-        Assert.Null(child2.Parent);
-        Assert.Null(child3.Parent);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.Equal(3, controlRemovedCallCount);
-        Assert.False(owner.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(child3.IsHandleCreated);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(child1.Parent);
-        Assert.Null(child2.Parent);
-        Assert.Null(child3.Parent);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.Equal(3, controlRemovedCallCount);
-        Assert.False(owner.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(child3.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Clone_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var sourceCollection = new Control.ControlCollection(owner);
-        ICloneable iCloneable = sourceCollection;
-        sourceCollection.Add(child1);
-        sourceCollection.Add(child2);
-        sourceCollection.Add(child3);
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            var collection = Assert.IsType<Control.ControlCollection>(iCloneable.Clone());
-            Assert.NotSame(sourceCollection, collection);
-            Assert.Equal(new Control[] { child1, child2, child3 }, sourceCollection.Cast<Control>());
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.False(collection.IsReadOnly);
-            Assert.Same(owner, collection.Owner);
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Contains_Invoke_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.True(collection.Contains(child1));
-        Assert.True(collection.Contains(child2));
-        Assert.False(collection.Contains(new Control()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, false)]
-    [InlineData("", false)]
-    [InlineData("name1", true)]
-    [InlineData("NAME1", true)]
-    [InlineData("name2", true)]
-    [InlineData("NoSuchName", false)]
-    [InlineData("abcd", false)]
-    [InlineData("abcde", false)]
-    [InlineData("abcdef", false)]
-    public void ControlCollection_ContainsKey_Invoke_ReturnsExpected(string key, bool expected)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(expected, collection.ContainsKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.ContainsKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void ControlCollection_Find_InvokeKeyExists_ReturnsExpected(string key)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        using var grandchild1 = new Control
-        {
-            Name = "name1"
-        };
-        using var grandchild2 = new Control
-        {
-            Name = "name2"
-        };
-        using var grandchild3 = new Control
-        {
-            Name = "name2"
-        };
-        child3.Controls.Add(grandchild1);
-        child3.Controls.Add(grandchild2);
-        child3.Controls.Add(grandchild3);
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        // Search all children.
-        Assert.Equal(new Control[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Call again.
-        Assert.Equal(new Control[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Don't search all children.
-        Assert.Equal(new Control[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-
-        // Call again.
-        Assert.Equal(new Control[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ControlCollection_Find_InvokeNoSuchKey_ReturnsEmpty(string key)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Empty(collection.Find(key, searchAllChildren: true));
-        Assert.Empty(collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void ControlCollection_Find_NullOrEmptyKey_ThrowsArgumentNullException(string key)
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: true));
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetChildIndex_InvokeControl_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Equal(0, collection.GetChildIndex(child1));
-        Assert.Equal(1, collection.GetChildIndex(child2));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetChildIndex_InvokeControlBoolThrowException_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Equal(0, collection.GetChildIndex(child1, throwException: true));
-        Assert.Equal(1, collection.GetChildIndex(child2, throwException: true));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetChildIndex_InvokeControlBoolNoSuchControl_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Equal(0, collection.GetChildIndex(child1, throwException: false));
-        Assert.Equal(1, collection.GetChildIndex(child2, throwException: false));
-        Assert.Equal(-1, collection.GetChildIndex(new Control(), throwException: false));
-        Assert.Equal(-1, collection.GetChildIndex(null, throwException: false));
-    }
-
-    public static IEnumerable<object[]> GetChildIndex_NoSuchControl_TestData()
-    {
-        yield return new object[] { new Control() };
-        yield return new object[] { null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetChildIndex_NoSuchControl_TestData))]
-    public void ControlCollection_GetChildIndex_NoSuchControl_ThrowsArgumentException(Control child)
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Throws<ArgumentException>(() => collection.GetChildIndex(child));
-        Assert.Throws<ArgumentException>(() => collection.GetChildIndex(child));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Null(enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Null(enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Null(enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Null(enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child1, enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child2, enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child3, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Same(child3, enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Same(child3, enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetEnumerator_AddDuringEnumeration_ReturnsExpected()
-    {
-        using var owner = new Control();
-        using var child = new Control();
-        var collection = new Control.ControlCollection(owner);
-        IEnumerator enumerator = collection.GetEnumerator();
-        collection.Add(child);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Null(enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Null(enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Null(enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetEnumerator_InvokeRemoveBeforeEnumeration_ReturnsExpected()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        collection.Remove(child1);
-
-        Assert.Null(enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child2, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-
-        Assert.False(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-
-        // Call again.
-        Assert.False(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_GetEnumerator_InvokeRemoveAtEndOfEnumeration_ReturnsExpected()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.Null(enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child1, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child2, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-
-        collection.Remove(child1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => enumerator.Current);
-
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => enumerator.Current);
-
-        // Call again.
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => enumerator.Current);
-
-        collection.Add(child1);
-        Assert.Same(child1, enumerator.Current);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        using var child1 = new Control();
-        using var child2 = new Control();
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Equal(0, collection.IndexOf(child1));
-        Assert.Equal(1, collection.IndexOf(child2));
-        Assert.Equal(-1, collection.IndexOf(new Control()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    [InlineData("NoSuchName", -1)]
-    [InlineData("abcd", -1)]
-    [InlineData("abcde", -1)]
-    [InlineData("abcdef", -1)]
-    public void ControlCollection_IndexOfKey_Invoke_ReturnsExpected(string key, int expected)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(expected, collection.IndexOfKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    public void ControlCollection_Item_GetStringValidKey_ReturnsExpected(string key, int expectedIndex)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(collection[expectedIndex], collection[key]);
-
-        // Call again.
-        Assert.Equal(collection[expectedIndex], collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ControlCollection_Item_GetStringNoSuchKey_ReturnsNull(string key)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Null(collection[key]);
-
-        // Call again.
-        Assert.Null(collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Item_GetInt_ReturnsExpected()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Same(child1, collection[0]);
-        Assert.Same(child2, collection[1]);
-        Assert.Same(child3, collection[2]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ControlCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ControlCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new Control();
-        using var child = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeChildWithoutHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove null.
-            collection.Remove(null);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeContainerControlParent_Success()
-    {
-        using var owner = new ContainerControl();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        owner.ActiveControl = child1;
-        Assert.Same(child1, owner.ActiveControl);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Null(owner.ActiveControl);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Null(owner.ActiveControl);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove null.
-            collection.Remove(null);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Null(owner.ActiveControl);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeChildWithHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, child1.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-
-        try
-        {
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove null.
-            collection.Remove(null);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeChildWithHandleOwnerWithHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-
-            // Remove null.
-            collection.Remove(null);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeChildFromAnotherParent_Nop()
-    {
-        using var owner1 = new Control();
-        using var owner2 = new Control();
-        using var control1 = new Control();
-        using var control2 = new Control();
-        using var control3 = new Control();
-        var collection1 = new Control.ControlCollection(owner1);
-        var collection2 = new Control.ControlCollection(owner2);
-        collection1.Add(control1);
-        collection2.Add(control2);
-
-        // Remove with parent.
-        collection1.Remove(control2);
-        Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>());
-        Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>());
-        Assert.Same(owner1, control1.Parent);
-        Assert.Same(owner2, control2.Parent);
-
-        // Remove without parent.
-        collection1.Remove(control3);
-        Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>());
-        Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>());
-        Assert.Same(owner1, control1.Parent);
-        Assert.Same(owner2, control2.Parent);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeWithNonOverridenProperties_DoesNotCallPropertyHandlers()
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        control.ParentChanged += (sender, e) => parentChangedCallCount++;
-        control.EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        control.VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        control.FontChanged += (sender, e) => fontChangedCallCount++;
-        control.ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        control.BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        control.RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Remove(control);
-        Assert.Null(control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(0, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(0, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(0, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, bindingContextChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeWithNonOverridenPropertiesWithHandle_DoesNotCallPropertyHandlers()
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        control.ParentChanged += (sender, e) => parentChangedCallCount++;
-        control.EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        control.VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        control.FontChanged += (sender, e) => fontChangedCallCount++;
-        control.ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        control.BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        control.RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Remove(control);
-        Assert.Null(control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(0, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(2, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(0, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(1, bindingContextChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Remove_OverridenProperties_TestData()
-    {
-        var parentContext = new BindingContext();
-        var childContext = new BindingContext();
-        yield return new object[] { parentContext, childContext, childContext };
-        yield return new object[] { parentContext, null, parentContext };
-        yield return new object[] { null, childContext, childContext };
-        yield return new object[] { null, null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_OverridenProperties_TestData))]
-    public void ControlCollection_Remove_InvokeWithOverridenProperties_CallsPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext)
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-
-        owner.Enabled = false;
-        Assert.False(control.Enabled);
-        owner.Visible = false;
-        Assert.False(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Same(font, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Color.Blue, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(expectedBindingContext, control.BindingContext);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        control.ParentChanged += (sender, e) =>
-        {
-            Assert.Equal(enabledChangedCallCount, parentChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, parentChangedCallCount);
-            Assert.Equal(fontChangedCallCount, parentChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, parentChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        };
-        control.EnabledChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, enabledChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(fontChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, enabledChangedCallCount);
-            enabledChangedCallCount++;
-        };
-        control.VisibleChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, visibleChangedCallCount);
-            Assert.Equal(fontChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, visibleChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, visibleChangedCallCount);
-            visibleChangedCallCount++;
-        };
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, fontChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, fontChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, fontChangedCallCount);
-            fontChangedCallCount++;
-        };
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, foreColorChangedCallCount);
-            foreColorChangedCallCount++;
-        };
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, backColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, backColorChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, backColorChangedCallCount);
-            backColorChangedCallCount++;
-        };
-        control.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(visibleChangedCallCount, rightToLeftChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(backColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(bindingContextChangedCallCount, rightToLeftChangedCallCount);
-            rightToLeftChangedCallCount++;
-        };
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Remove(control);
-        Assert.Null(control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(1, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(0, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(1, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(1, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(1, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(1, rightToLeftChangedCallCount);
-        Assert.Same(bindingContext, control.BindingContext);
-        Assert.Equal(0, bindingContextChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Remove_OverridenPropertiesWithHandle_TestData()
-    {
-        var parentContext = new BindingContext();
-        var childContext = new BindingContext();
-        yield return new object[] { parentContext, childContext, childContext, 0 };
-        yield return new object[] { parentContext, null, parentContext, 1 };
-        yield return new object[] { null, childContext, childContext, 0 };
-        yield return new object[] { null, null, null, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_OverridenPropertiesWithHandle_TestData))]
-    public void ControlCollection_Remove_InvokeWithOverridenPropertiesWithHandle_CallsPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext, int expectedBindingContextChangedCallCount)
-    {
-        using var owner = new Control();
-        using var control = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-
-        owner.Enabled = false;
-        Assert.False(control.Enabled);
-        owner.Visible = false;
-        Assert.False(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Same(font, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Color.Blue, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(expectedBindingContext, control.BindingContext);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            Assert.Equal(enabledChangedCallCount, parentChangedCallCount);
-            Assert.Equal(fontChangedCallCount, parentChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, parentChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        }
-
-        control.ParentChanged += parentChangedHandler;
-        control.EnabledChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, enabledChangedCallCount);
-            Assert.Equal(fontChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, enabledChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, enabledChangedCallCount);
-            enabledChangedCallCount++;
-        };
-        control.VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, fontChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, fontChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, fontChangedCallCount);
-            fontChangedCallCount++;
-        };
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, foreColorChangedCallCount);
-            Assert.Equal(backColorChangedCallCount, foreColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, foreColorChangedCallCount);
-            foreColorChangedCallCount++;
-        };
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, backColorChangedCallCount);
-            Assert.Equal(rightToLeftChangedCallCount, backColorChangedCallCount);
-            backColorChangedCallCount++;
-        };
-        control.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Equal(parentChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(enabledChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(fontChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(foreColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            Assert.Equal(backColorChangedCallCount - 1, rightToLeftChangedCallCount);
-            rightToLeftChangedCallCount++;
-        };
-        control.BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        try
-        {
-            collection.Remove(control);
-            Assert.Null(control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.True(control.Enabled);
-            Assert.Equal(1, enabledChangedCallCount);
-            Assert.True(control.Visible);
-            Assert.Equal(2, visibleChangedCallCount);
-            Assert.Equal(Control.DefaultFont, control.Font);
-            Assert.Equal(1, fontChangedCallCount);
-            Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-            Assert.Equal(1, foreColorChangedCallCount);
-            Assert.Equal(Control.DefaultBackColor, control.BackColor);
-            Assert.Equal(1, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.Equal(1, rightToLeftChangedCallCount);
-            Assert.Same(bindingContext, control.BindingContext);
-            Assert.Equal(expectedBindingContextChangedCallCount * 2, bindingContextChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(1, createdCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_OverridenProperties_TestData))]
-    public void ControlCollection_Remove_InvokeWithOverridenPropertiesAxHost_DoesNotCallPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext)
-    {
-        using var owner = new Control();
-        using var control = new SubAxHost("8856f961-340a-11d0-a96b-00c04fd705a2");
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-
-        owner.Enabled = false;
-        Assert.False(control.Enabled);
-        owner.Visible = false;
-        Assert.False(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Same(font, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Color.Blue, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, ((Control)control).RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(expectedBindingContext, control.BindingContext);
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        ((Control)control).ParentChanged += (sender, e) => parentChangedCallCount++;
-        ((Control)control).EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        ((Control)control).VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        ((Control)control).FontChanged += (sender, e) => fontChangedCallCount++;
-        ((Control)control).ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        ((Control)control).BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        ((Control)control).RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        ((Control)control).BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        collection.Remove(control);
-        Assert.Null(control.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.True(control.Enabled);
-        Assert.Equal(0, enabledChangedCallCount);
-        Assert.True(control.Visible);
-        Assert.Equal(0, visibleChangedCallCount);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(0, fontChangedCallCount);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-        Assert.Same(bindingContext, control.BindingContext);
-        Assert.Equal(0, bindingContextChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_OverridenPropertiesWithHandle_TestData))]
-    public void ControlCollection_Remove_InvokeWithOverridenPropertiesAxHostWithHandle_CallSPropertyHandlers(BindingContext parentBindingContext, BindingContext bindingContext, BindingContext expectedBindingContext, int expectedBindingContextChangedCallCount)
-    {
-        using var owner = new Control();
-        using var control = new SubAxHost("8856f961-340a-11d0-a96b-00c04fd705a2");
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(control);
-
-        owner.Enabled = false;
-        Assert.False(control.Enabled);
-        owner.Visible = false;
-        Assert.False(control.Visible);
-        var font = new Font("Arial", 8.25f);
-        owner.Font = font;
-        Assert.Same(font, control.Font);
-        owner.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        owner.BackColor = Color.Blue;
-        Assert.Equal(Color.Blue, control.BackColor);
-        owner.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, ((Control)control).RightToLeft);
-        owner.BindingContext = parentBindingContext;
-        control.BindingContext = bindingContext;
-        Assert.Same(expectedBindingContext, control.BindingContext);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int parentChangedCallCount = 0;
-        int enabledChangedCallCount = 0;
-        int visibleChangedCallCount = 0;
-        int fontChangedCallCount = 0;
-        int foreColorChangedCallCount = 0;
-        int backColorChangedCallCount = 0;
-        int rightToLeftChangedCallCount = 0;
-        int bindingContextChangedCallCount = 0;
-        void parentChangedHandler(object sender, EventArgs e)
-        {
-            parentChangedCallCount++;
-        }
-
-        ((Control)control).ParentChanged += parentChangedHandler;
-        ((Control)control).EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        ((Control)control).VisibleChanged += (sender, e) => visibleChangedCallCount++;
-        ((Control)control).FontChanged += (sender, e) => fontChangedCallCount++;
-        ((Control)control).ForeColorChanged += (sender, e) => foreColorChangedCallCount++;
-        ((Control)control).BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        ((Control)control).RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        ((Control)control).BindingContextChanged += (sender, e) => bindingContextChangedCallCount++;
-
-        try
-        {
-            collection.Remove(control);
-            Assert.Null(control.Parent);
-            Assert.Equal(1, parentChangedCallCount);
-            Assert.True(control.Enabled);
-            Assert.Equal(1, enabledChangedCallCount);
-            Assert.True(control.Visible);
-            Assert.Equal(2, visibleChangedCallCount);
-            Assert.Equal(Control.DefaultFont, control.Font);
-            Assert.Equal(1, fontChangedCallCount);
-            Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-            Assert.Equal(1, foreColorChangedCallCount);
-            Assert.Equal(Control.DefaultBackColor, control.BackColor);
-            Assert.Equal(1, backColorChangedCallCount);
-            Assert.Equal(RightToLeft.No, ((Control)control).RightToLeft);
-            Assert.Equal(1, rightToLeftChangedCallCount);
-            Assert.Same(bindingContext, control.BindingContext);
-            Assert.Equal(expectedBindingContextChangedCallCount, bindingContextChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(7, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(1, createdCallCount);
-        }
-        finally
-        {
-            control.ParentChanged -= parentChangedHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Remove_InvokeWithHandler_CallsControlRemoved()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int parentChangedCallCount = 0;
-        int callCount = 0;
-        int parentLayoutCallCount = 0;
-        child1.ParentChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, parentChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        };
-        child2.ParentChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, parentChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, parentChangedCallCount);
-            parentChangedCallCount++;
-        };
-        object affectedControl = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            Assert.Equal(parentChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(callCount, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        void handler(object sender, ControlEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.Control);
-            Assert.Equal(parentChangedCallCount - 1, callCount);
-            Assert.Equal(parentLayoutCallCount - 1, callCount);
-            callCount++;
-        }
-
-        // Call with handler.
-        owner.ControlRemoved += handler;
-        affectedControl = child1;
-        collection.Remove(child1);
-        Assert.Null(child1.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        collection.Remove(child1);
-        Assert.Null(child1.Parent);
-        Assert.Equal(1, parentChangedCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        owner.ControlRemoved -= handler;
-        affectedControl = child2;
-        collection.Remove(child2);
-        Assert.Null(child2.Parent);
-        Assert.Equal(2, parentChangedCallCount);
-        Assert.Equal(2, parentLayoutCallCount);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_RemoveAt_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        object affectedControl = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            affectedControl = child2;
-            collection.RemoveAt(1);
-            Assert.Equal(new Control[] { child1 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            affectedControl = child1;
-            collection.RemoveAt(0);
-            Assert.Empty(collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ControlCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ControlCollection_RemoveAtInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new Control();
-        using var child = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void ControlCollection_RemoveByKey_InvokeValidKey_ReturnsExpected(string key)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        object affectedControl = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            affectedControl = child2;
-            collection.RemoveByKey(key);
-            Assert.Equal(new Control[] { child1, child3 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Remove again.
-            affectedControl = child3;
-            collection.RemoveByKey(key);
-            Assert.Equal(new Control[] { child1 }, collection.Cast<Control>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ControlCollection_RemoveByKey_InvokeNoSuchKey_ReturnsNull(string key)
-    {
-        using var owner = new Control();
-        using var child1 = new Control
-        {
-            Name = "name1"
-        };
-        using var child2 = new Control
-        {
-            Name = "name2"
-        };
-        using var child3 = new Control
-        {
-            Name = "name2"
-        };
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        collection.RemoveByKey(key);
-        Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-
-        // Call again.
-        collection.RemoveByKey(key);
-        Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_InvokeChildWithoutHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Set middle.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Set same.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Set start.
-            collection.SetChildIndex(child1, 0);
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 1)]
-    [InlineData(3, 2)]
-    [InlineData(4, 2)]
-    public void ControlCollection_SetChildIndex_InvokeLargeIndex_Success(int index, int expectedParentLayoutCallCount)
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Set middle.
-            collection.SetChildIndex(child1, index);
-            Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Set same.
-            collection.SetChildIndex(child1, index);
-            Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_InvokeChildWithHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, child1.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-
-        try
-        {
-            // Set middle.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Set same.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Set start.
-            collection.SetChildIndex(child1, 0);
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_InvokeChildWithHandleOwnerWithHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Set middle.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-
-            // Set same.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-
-            // Set start.
-            collection.SetChildIndex(child1, 0);
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_InvokeChildWithoutHandleOwnerWithHandle_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new SubControl();
-        using var child2 = new Control();
-        using var child3 = new Control();
-        Control.ControlCollection collection = owner.Controls;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Set middle.
-            child1.DestroyHandle();
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.False(child1.IsHandleCreated);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-
-            // Set same.
-            collection.SetChildIndex(child1, 1);
-            Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.False(child1.IsHandleCreated);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-
-            // Set start.
-            collection.SetChildIndex(child1, 0);
-            Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.False(child1.IsHandleCreated);
-            Assert.True(child2.IsHandleCreated);
-            Assert.True(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_NullChild_ThrowsArgumentNullException()
-    {
-        using var owner = new Control();
-        var collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentNullException>("child", () => collection.SetChildIndex(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_SetChildIndex_InvalidIndex_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new Control();
-        using var child = new Control();
-        var collection = new Control.ControlCollection(owner);
-        collection.Add(child);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.SetChildIndex(child, -2));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_IListAdd_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var control1 = new Control();
-        using var control2 = new Control();
-        IList collection = owner.Controls;
-        int parentLayoutCallCount = 0;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(collection.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int layoutCallCount1 = 0;
-        control1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        control2.Layout += (sender, e) => layoutCallCount2++;
-
-        try
-        {
-            affectedProperty = "Parent";
-            Assert.Equal(0, collection.Add(control1));
-            Assert.Same(control1, Assert.Single(collection));
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(control1, Assert.Single(owner.Controls));
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-
-            // Add another.
-            affectedProperty = "Parent";
-            Assert.Equal(1, collection.Add(control2));
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add existing.
-            affectedProperty = "ChildIndex";
-            Assert.Equal(1, collection.Add(control1));
-            Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(3, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_IListAdd_NotControl_ThrowsArgumentException()
-    {
-        using var owner = new Control();
-        IList collection = new Control.ControlCollection(owner);
-        Assert.Throws<ArgumentException>("control", () => collection.Add(new object()));
-        Assert.Throws<ArgumentException>("control", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_IListRemove_Invoke_Success()
-    {
-        using var owner = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        IList collection = new Control.ControlCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(child1);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove null.
-            collection.Remove(null);
-            Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());
-            Assert.Null(child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_IListRemove_NotControl_ThrowsArgumentException()
-    {
-        using var owner = new Control();
-        IList collection = new Control.ControlCollection(owner);
-        collection.Remove(new object());
-        collection.Remove(null);
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = new Control().LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-
-        public new void InitLayout() => base.InitLayout();
-    }
-
-    private class SubControl : Control
-    {
-        public new void DestroyHandle() => base.DestroyHandle();
-
-        public new void SetTopLevel(bool value) => base.SetTopLevel(value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Handlers.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Handlers.cs
deleted file mode 100644
index 6e480346771..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Handlers.cs
+++ /dev/null
@@ -1,5842 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlTests
-{
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnAutoSizeChanged_Invoke_CallsAutoSizeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AutoSizeChanged += handler;
-        control.OnAutoSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.OnAutoSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnBackColorChanged_InvokeInDisposing_DoesNotCallBackColorChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackColorChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnBackColorChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackColorChanged_InvokeWithChildren_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackColorChanged_InvokeWithChildrenWithBackColor_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            BackColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            BackColor = Color.YellowGreen
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageChanged_Invoke_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageChanged_InvokeWithHandle_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_OnBackgroundImageChanged_InvokeInDisposing_DoesNotCallBackgroundImageChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackgroundImageChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnBackgroundImageChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageChanged_InvokeWithChildren_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        child1.BackgroundImageChanged += childHandler1;
-        child2.BackgroundImageChanged += childHandler2;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        child1.BackgroundImageChanged -= childHandler1;
-        child2.BackgroundImageChanged -= childHandler2;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageChanged_InvokeWithChildrenWithBackgroundImage_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            BackgroundImage = new Bitmap(10, 10)
-        };
-        using var child2 = new Control
-        {
-            BackgroundImage = new Bitmap(10, 10)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        child1.BackgroundImageChanged += childHandler1;
-        child2.BackgroundImageChanged += childHandler2;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        child1.BackgroundImageChanged -= childHandler1;
-        child2.BackgroundImageChanged -= childHandler2;
-        control.OnBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageLayoutChanged_Invoke_CallsBackgroundImageLayoutChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageLayoutChanged += handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageLayoutChanged_InvokeWithHandle_CallsBackgroundImageLayoutChangedAndInvalidated(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.BackgroundImageLayoutChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageLayoutChanged_InvokeWithChildren_CallsBackgroundImageLayoutChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BackgroundImageLayoutChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BackgroundImageLayoutChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageLayoutChanged += handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBackgroundImageLayoutChanged_InvokeWithChildrenWithBackgroundImageLayout_CallsBackgroundImageLayoutChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            BackgroundImageLayout = ImageLayout.Center
-        };
-        using var child2 = new Control
-        {
-            BackgroundImageLayout = ImageLayout.Center
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BackgroundImageLayoutChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BackgroundImageLayoutChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageLayoutChanged += handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.OnBackgroundImageLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnBackgroundImageLayoutChanged_InvokeInDisposing_DoesNotCallBackgroundImageLayoutChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackgroundImageLayoutChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnBackgroundImageLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBindingContextChanged_Invoke_CallsBindingContextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBindingContextChanged_InvokeWithChildren_CallsBindingContextChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnBindingContextChanged_InvokeWithChildrenWithBindingContext_CallsBindingContextChanged(EventArgs eventArgs)
-    {
-        var childContext1 = new BindingContext();
-        var childContext2 = new BindingContext();
-        using var child1 = new Control
-        {
-            BindingContext = childContext1
-        };
-        using var child2 = new Control
-        {
-            BindingContext = childContext2
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnCausesValidationChanged_Invoke_CallsCausesValidationChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CausesValidationChanged += handler;
-        control.OnCausesValidationChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.OnCausesValidationChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> UICuesEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new UICuesEventArgs(UICues.None) };
-        yield return new object[] { new UICuesEventArgs(UICues.Changed) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UICuesEventArgs_TestData))]
-    public void Control_OnChangeUICues_Invoke_CallsChangeUICues(UICuesEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        UICuesEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ChangeUICues += handler;
-        control.OnChangeUICues(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ChangeUICues -= handler;
-        control.OnChangeUICues(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnClientSizeChanged_Invoke_CallsClientSizeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int sizeChangedCallCount = 0;
-        EventHandler sizeChangedHandler = (sender, e) => sizeChangedCallCount++;
-        int resizeCallCount = 0;
-        EventHandler resizeHandler = (sender, e) => resizeCallCount++;
-
-        // Call with handler.
-        control.ClientSizeChanged += handler;
-        control.SizeChanged += sizeChangedHandler;
-        control.Resize += resizeHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ClientSizeChanged -= handler;
-        control.SizeChanged += sizeChangedHandler;
-        control.Resize += resizeHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnClientSizeChanged_InvokeWithHandle_CallsClientSizeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int sizeChangedCallCount = 0;
-        EventHandler sizeChangedHandler = (sender, e) => sizeChangedCallCount++;
-        int resizeCallCount = 0;
-        EventHandler resizeHandler = (sender, e) => resizeCallCount++;
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.ClientSizeChanged += handler;
-        control.SizeChanged += sizeChangedHandler;
-        control.Resize += resizeHandler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ClientSizeChanged -= handler;
-        control.SizeChanged -= sizeChangedHandler;
-        control.Resize -= resizeHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnClientSizeChanged_InvokeWithResizeRedraw_CallsClientSizeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, true);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int sizeChangedCallCount = 0;
-        EventHandler sizeChangedHandler = (sender, e) => sizeChangedCallCount++;
-        int resizeCallCount = 0;
-        EventHandler resizeHandler = (sender, e) => resizeCallCount++;
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.ClientSizeChanged += handler;
-        control.SizeChanged += sizeChangedHandler;
-        control.Resize += resizeHandler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ClientSizeChanged -= handler;
-        control.SizeChanged -= sizeChangedHandler;
-        control.Resize -= resizeHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnClientSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnContextMenuStripChanged_Invoke_CallsContextMenuStripChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ContextMenuStripChanged += handler;
-        control.OnContextMenuStripChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ContextMenuStripChanged -= handler;
-        control.OnContextMenuStripChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ControlEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ControlEventArgs(null) };
-        yield return new object[] { new ControlEventArgs(new Control()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlEventArgs_TestData))]
-    public void Control_OnControlAdded_Invoke_CallsControlAdded(ControlEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        ControlEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ControlAdded += handler;
-        control.OnControlAdded(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ControlAdded -= handler;
-        control.OnControlAdded(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlEventArgs_TestData))]
-    public void Control_OnControlRemoved_Invoke_CallsControlRemoved(ControlEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        ControlEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ControlRemoved += handler;
-        control.OnControlRemoved(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ControlRemoved -= handler;
-        control.OnControlRemoved(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnCreateControl_Invoke_Nop()
-    {
-        using var control = new SubControl();
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnCursorChanged_Invoke_CallsCursorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CursorChanged += handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnCursorChanged_InvokeWithChildren_CallsCursorChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.CursorChanged += handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnCursorChanged_InvokeWithChildrenWithCursor_CallsCursorChanged(EventArgs eventArgs)
-    {
-        var childCursor1 = new Cursor((IntPtr)1);
-        var childCursor2 = new Cursor((IntPtr)1);
-        using var child1 = new Control
-        {
-            Cursor = childCursor1
-        };
-        using var child2 = new Control
-        {
-            Cursor = childCursor2
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child1.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.CursorChanged += handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.OnCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnDockChanged_Invoke_CallsDockChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DockChanged += handler;
-        control.OnDockChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.OnDockChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnDpiChangedBeforeParent_Invoke_CallsDpiChangedAfterParent(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DpiChangedAfterParent += handler;
-        control.OnDpiChangedAfterParent(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DpiChangedAfterParent -= handler;
-        control.OnDpiChangedAfterParent(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnDpiChangedBeforeParent_Invoke_CallsDpiChangedBeforeParent(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DpiChangedBeforeParent += handler;
-        control.OnDpiChangedBeforeParent(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DpiChangedBeforeParent -= handler;
-        control.OnDpiChangedBeforeParent(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> DragEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DragEventArgs(null, 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void Control_OnDragDrop_Invoke_CallsDragDrop(DragEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DragDrop += handler;
-        control.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DragDrop -= handler;
-        control.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void Control_OnDragEnter_Invoke_CallsDragEnter(DragEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DragEnter += handler;
-        control.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DragEnter -= handler;
-        control.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnDragLeave_Invoke_CallsDragLeave(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DragLeave += handler;
-        control.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DragLeave -= handler;
-        control.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void Control_OnDragOver_Invoke_CallsDragOver(DragEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DragOver += handler;
-        control.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DragOver -= handler;
-        control.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnabledChanged_Invoke_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnabledChanged_InvokeWithHandle_CallsEnabledChangedCallsInvalidated(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnabledChanged_InvokeWithHandleNoUserPaint_CallsEnabledChangedDoesNotCallInvalidated(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, false);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnabledChanged_InvokeWithChildren_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.EnabledChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount1++;
-        };
-        child2.EnabledChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount2++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnabledChanged_InvokeWithChildrenDisabled_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            Enabled = false
-        };
-        using var child2 = new Control
-        {
-            Enabled = false
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.EnabledChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount1++;
-        };
-        child2.EnabledChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount2++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnFontChanged_InvokeWithFontHeight_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            FontHeight = 10
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_WithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, null };
-            yield return new object[] { userPaint, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithHandle_TestData))]
-    public void Control_OnFontChanged_InvokeWithHandle_CallsFontChangedAndInvalidated(bool userPaint, EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnFontChanged_InvokeWithChildren_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.FontChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.FontChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnFontChanged_InvokeWithChildrenWithFont_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var childFont1 = new Font("Arial", 1);
-        using var childFont2 = new Font("Arial", 2);
-        using var child1 = new Control
-        {
-            Font = childFont1
-        };
-        using var child2 = new Control
-        {
-            Font = childFont2
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.FontChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.FontChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnFontChanged_InvokeInDisposing_DoesNotCallFontChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.FontChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnFontChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnForeColorChanged_InvokeWithHandle_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_OnForeColorChanged_InvokeInDisposing_DoesNotCallForeColorChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.ForeColorChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnForeColorChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnForeColorChanged_InvokeWithChildren_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnForeColorChanged_InvokeWithChildrenWithForeColor_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            ForeColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            ForeColor = Color.YellowGreen
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    public static IEnumerable<object[]> GiveFeedbackEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new GiveFeedbackEventArgs(DragDropEffects.None, true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GiveFeedbackEventArgs_TestData))]
-    public void Control_OnGiveFeedback_Invoke_CallsGiveFeedback(GiveFeedbackEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        GiveFeedbackEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GiveFeedback += handler;
-        control.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.GiveFeedback -= handler;
-        control.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_WithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, null };
-            yield return new object[] { userPaint, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_WithHandle_TestData))]
-    public void Control_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(bool userPaint, EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_Region_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-        {
-            yield return new object[] { testData[0], new Region() };
-            yield return new object[] { testData[0], new Region(new Rectangle(1, 2, 3, 4)) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_Region_TestData))]
-    public void Control_OnHandleCreated_InvokeWithRegion_CallsHandleCreated(EventArgs eventArgs, Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_Text_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-        {
-            yield return new object[] { testData[0], null, string.Empty };
-            yield return new object[] { testData[0], string.Empty, string.Empty };
-            yield return new object[] { testData[0], "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_Text_TestData))]
-    public void Control_OnHandleCreated_InvokeWithText_CallsHandleCreated(EventArgs eventArgs, string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleCreated_InvokeWithHandleAllowDrop_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleDestroyed_Region_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-        {
-            yield return new object[] { testData[0], new Region() };
-            yield return new object[] { testData[0], new Region(new Rectangle(1, 2, 3, 4)) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_Region_TestData))]
-    public void Control_OnHandleDestroyed_InvokeWithRegion_CallsHandleDestroyed(EventArgs eventArgs, Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-    }
-
-    public static IEnumerable<object[]> OnHandleDestroyed_Text_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-        {
-            yield return new object[] { testData[0], null, string.Empty };
-            yield return new object[] { testData[0], string.Empty, string.Empty };
-            yield return new object[] { testData[0], "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_Text_TestData))]
-    public void Control_OnHandleDestroyed_InvokeWithText_CallsHandleDestroyed(EventArgs eventArgs, string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleDestroyed_InvokeAllowDrop_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_Region_TestData))]
-    public void Control_OnHandleDestroyed_InvokeWithHandleWithRegion_CallsHandleDestroyed(EventArgs eventArgs, Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_Text_TestData))]
-    public void Control_OnHandleDestroyed_InvokeWithHandleWithText_CallsHandleDestroyed(EventArgs eventArgs, string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnHandleDestroyed_InvokeWithHandleAllowDrop_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-    }
-
-    public static IEnumerable<object[]> HelpEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new HelpEventArgs(new Point(1, 2)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HelpEventArgs_TestData))]
-    public void Control_OnHelpRequested_Invoke_CallsHelpRequested(HelpEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        HelpEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HelpRequested += handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.HelpRequested -= handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HelpEventArgs_TestData))]
-    public void Control_OnHelpRequested_InvokeWithParent_CallsHelpRequested(HelpEventArgs eventArgs)
-    {
-        var parent = new Control();
-        int parentCallCount = 0;
-        HelpEventHandler parentHandler = (sender, e) => parentCallCount++;
-        parent.HelpRequested += parentHandler;
-
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        HelpEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HelpRequested += handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, parentCallCount);
-
-        // Remove handler.
-        control.HelpRequested -= handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, parentCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnHelpRequested_InvokeWithHandler_SetsHandled()
-    {
-        var eventArgs = new HelpEventArgs(new Point(1, 2));
-        using var control = new SubControl();
-        int callCount = 0;
-        HelpEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HelpRequested += handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(eventArgs.Handled);
-
-        // Remove handler.
-        eventArgs.Handled = false;
-        control.HelpRequested -= handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void Control_OnHelpRequested_InvokeWithParentHandler_SetsHandled()
-    {
-        var parent = new Control();
-        int parentCallCount = 0;
-        HelpEventHandler parentHandler = (sender, e) => parentCallCount++;
-        parent.HelpRequested += parentHandler;
-
-        var eventArgs = new HelpEventArgs(new Point(1, 2));
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-
-        // Call with handler.
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, parentCallCount);
-        Assert.True(eventArgs.Handled);
-
-        // Remove handler.
-        eventArgs.Handled = false;
-        parent.HelpRequested -= parentHandler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, parentCallCount);
-        Assert.False(eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void Control_OnHelpRequested_InvokeWithoutHandler_DoesNotSetHandled()
-    {
-        var eventArgs = new HelpEventArgs(new Point(1, 2));
-        using var control = new SubControl();
-        control.OnHelpRequested(eventArgs);
-        Assert.False(eventArgs.Handled);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnImeModeChanged_Invoke_CallsImeModeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ImeModeChanged += handler;
-        control.OnImeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.OnImeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> InvalidateEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new InvalidateEventArgs(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidateEventArgs_TestData))]
-    public void Control_OnInvalidated_Invoke_CallsInvalidated(InvalidateEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnInvalidated_WithChildren_TestData()
-    {
-        yield return new object[] { true, Color.Empty, null };
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(Rectangle.Empty) };
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)) };
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)) };
-        yield return new object[] { true, Color.Red, null };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(Rectangle.Empty) };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)) };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)) };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), null };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(Rectangle.Empty) };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)) };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)) };
-
-        yield return new object[] { false, Color.Empty, null };
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(Rectangle.Empty) };
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)) };
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)) };
-        yield return new object[] { false, Color.Red, null };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(Rectangle.Empty) };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)) };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnInvalidated_WithChildren_TestData))]
-    public void Control_OnInvalidated_InvokeWithChildren_CallsInvalidated(bool supportsTransparentBackgroundColor, Color backColor, InvalidateEventArgs eventArgs)
-    {
-        using var child1 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var child2 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        child1.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child1.BackColor = backColor;
-        child2.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child2.BackColor = backColor;
-
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InvalidateEventArgs_TestData))]
-    public void Control_OnInvalidated_InvokeWithHandle_CallsInvalidated(InvalidateEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnInvalidated_WithChildrenWithHandle_TestData()
-    {
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(Rectangle.Empty), 0 };
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)), 0 };
-        yield return new object[] { true, Color.Empty, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)), 0 };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(Rectangle.Empty), 0 };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)), 0 };
-        yield return new object[] { true, Color.Red, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)), 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(Rectangle.Empty), 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)), 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)), 1 };
-
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(Rectangle.Empty), 0 };
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)), 0 };
-        yield return new object[] { false, Color.Empty, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)), 0 };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(Rectangle.Empty), 0 };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(new Rectangle(100, 200, 300, 400)), 0 };
-        yield return new object[] { false, Color.Red, new InvalidateEventArgs(new Rectangle(1, 2, 300, 400)), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnInvalidated_WithChildrenWithHandle_TestData))]
-    public void Control_OnInvalidated_InvokeWithChildrenWithHandle_CallsInvalidated(bool supportsTransparentBackgroundColor, Color backColor, InvalidateEventArgs eventArgs, int expectedChildInvalidatedCallCount)
-    {
-        using var child1 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var child2 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        child1.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child1.BackColor = backColor;
-        child2.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child2.BackColor = backColor;
-
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int invalidatedCallCount1 = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount1++;
-        int invalidatedCallCount2 = 0;
-        child2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        child2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        child2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount, invalidatedCallCount1);
-        Assert.Equal(0, styleChangedCallCount1);
-        Assert.Equal(0, createdCallCount1);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount, invalidatedCallCount2);
-        Assert.Equal(0, styleChangedCallCount2);
-        Assert.Equal(0, createdCallCount2);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.OnInvalidated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount * 2, invalidatedCallCount1);
-        Assert.Equal(0, styleChangedCallCount1);
-        Assert.Equal(0, createdCallCount1);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount * 2, invalidatedCallCount2);
-        Assert.Equal(0, styleChangedCallCount2);
-        Assert.Equal(0, createdCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_OnInvalidated_NullEventArgsWithChildren_ThrowsNullReferenceException()
-    {
-        using var child1 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var child2 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        child1.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        child1.BackColor = Color.FromArgb(200, 50, 100, 150);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Throws<NullReferenceException>(() => control.OnInvalidated(null));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void Control_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void Control_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void Control_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void Control_OnLayout_Invoke_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void Control_OnLayout_InvokeWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void Control_OnLayout_InvokeWithParent_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void Control_OnLeave_Invoke_CallsLeave(KeyEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnLocationChanged_Invoke_CallsLocationChangedAndMove(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            locationChangedCallCount++;
-        };
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-
-        // Call with handler.
-        control.LocationChanged += locationChangedHandler;
-        control.Move += moveHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnLocationChanged_InvokeWithHandle_CallsLocationChangedAndMove(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            locationChangedCallCount++;
-        };
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.LocationChanged += locationChangedHandler;
-        control.Move += moveHandler;
-        control.Invalidated += invalidatedHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    public static IEnumerable<object[]> OnLocationChanged_HandleWithTransparentBackColor_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-        {
-            yield return new object[] { true, testData[0], 1 };
-            yield return new object[] { false, testData[0], 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLocationChanged_HandleWithTransparentBackColor_TestData))]
-    public void Control_OnLocationChanged_InvokeWithHandleWithTransparentBackColor_CallsLocationChangedAndMoveAndInvalidated(bool supportsTransparentBackgroundColor, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            locationChangedCallCount++;
-        };
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.LocationChanged += locationChangedHandler;
-        control.Move += moveHandler;
-        control.Invalidated += invalidatedHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnLocationChanged(eventArgs);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnLostFocus_Invoke_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LostFocus += handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMarginChanged_Invoke_CallsMarginChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MarginChanged += handler;
-        control.OnMarginChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MarginChanged -= handler;
-        control.OnMarginChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMouseCaptureChanged_Invoke_CallsMouseCaptureChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseCaptureChanged += handler;
-        control.OnMouseCaptureChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseCaptureChanged -= handler;
-        control.OnMouseCaptureChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMouseEnter_Invoke_CallsMouseEnter(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMouseHover_Invoke_CallsMouseHover(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseHover += handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseHover -= handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMouseLeave_Invoke_CallsMouseLeave(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Control_OnMouseWheel_Invoke_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_OnMouseWheel_InvokeHandledMouseEventArgs_DoesNotSetHandled()
-    {
-        using var control = new SubControl();
-        var eventArgs = new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4);
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.False(eventArgs.Handled);
-            callCount++;
-        };
-        control.MouseWheel += handler;
-
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(eventArgs.Handled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMove_Invoke_CallsMove(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-
-        // Call with handler.
-        control.Move += moveHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-
-        // Remove handler.
-        control.Move -= moveHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnMove_InvokeWithHandle_CallsMove(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.Move += moveHandler;
-        control.Invalidated += invalidatedHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        control.Move -= moveHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLocationChanged_HandleWithTransparentBackColor_TestData))]
-    public void Control_OnMove_InvokeWithHandleWithTransparentBackColor_CallsMoveAndInvalidated(bool supportsTransparentBackgroundColor, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            moveCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.Move += moveHandler;
-        control.Invalidated += invalidatedHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Remove handler.
-        control.Move -= moveHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.OnMove(eventArgs);
-        Assert.Equal(1, moveCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnPaddingChanged_Invoke_CallsPaddingChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.PaddingChanged += handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnPaddingChanged_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaddingChanged_WithHandle_TestData))]
-    public void Control_OnPaddingChanged_InvokeWithHandle_CallsPaddingChanged(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.PaddingChanged += handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void Control_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb), new Bitmap(10, 10, PixelFormat.Format32bppArgb) })
-        {
-            foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-            {
-                yield return new object[] { true, Color.Empty, backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.Red, backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                yield return new object[] { false, Color.Empty, backgroundImage, backgroundImageLayout };
-                yield return new object[] { false, Color.Red, backgroundImage, backgroundImageLayout };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void Control_OnPaintBackground_Invoke_Success(bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    // TODO: unify
-    // Correct the implementation as per ScrollableControlTests.OnPaintBackground_VisualStyles_off_WithParent_TestData
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_off_WithParent_TestData()
-    {
-        var control = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        var tabPage = new TabPage
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        foreach (Control parent in new Control[] { control, tabPage })
-        {
-            foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-            {
-                foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                {
-                    yield return new object[] { parent, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                    yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                    yield return new object[] { parent, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                }
-            }
-
-            yield return new object[] { parent, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-            yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-            yield return new object[] { parent, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-            yield return new object[] { parent, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            yield return new object[] { parent, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-            yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-            yield return new object[] { parent, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            yield return new object[] { parent, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-        }
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_on_WithParent_TestData()
-    {
-        var control = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        var tabPage = new TabPage
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        foreach (Control parent in new Control[] { control, tabPage })
-        {
-            int expected1 = parent == tabPage ? 0 : 1;
-            int expected2 = parent == tabPage ? 0 : 2;
-
-            foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-            {
-                foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                {
-                    yield return new object[] { parent, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected1 };
-                    yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected1 };
-                }
-            }
-
-            yield return new object[] { parent, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-            yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-            yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-
-            yield return new object[] { parent, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-            yield return new object[] { parent, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-            yield return new object[] { parent, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-            yield return new object[] { parent, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-            yield return new object[] { parent, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-            yield return new object[] { parent, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_VisualStyles_on_WithParent_TestData))]
-    public void Control_OnPaintBackground_InvokeWithParent_CallsPaint(Control parent, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 0, 0), e.ClipRectangle);
-            parentCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void Control_OnPaintBackground_InvokeWithHandle_Success(bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_WithParentWithHandle_TestData()
-    {
-        foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-        {
-            foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-            {
-                yield return new object[] { true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                yield return new object[] { true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                yield return new object[] { true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                yield return new object[] { true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                yield return new object[] { false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                yield return new object[] { false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-            }
-        }
-
-        yield return new object[] { true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-        yield return new object[] { true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-        yield return new object[] { true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-        yield return new object[] { true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-        yield return new object[] { false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-        yield return new object[] { false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-        yield return new object[] { true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-        yield return new object[] { true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-        yield return new object[] { true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-        yield return new object[] { true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-        yield return new object[] { false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-        yield return new object[] { false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_WithParentWithHandle_TestData))]
-    public void Control_OnPaintBackground_InvokeWithParentWithHandle_CallsPaint(bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var parent = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 10, 20), e.ClipRectangle);
-            parentCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnPaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var control = new SubControl();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentChanged_Invoke_CallsParentChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBackColorChanged_InvokeWithBackColor_DoesNotCallBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            BackColor = Color.Red
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBackgroundImageChanged_Invoke_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        control.OnParentBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.OnParentBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBackgroundImageChanged_InvokeWithBackgroundImage_CallsBackgroundImageChanged(EventArgs eventArgs)
-    {
-        var image = new Bitmap(10, 10);
-        using var control = new SubControl
-        {
-            BackgroundImage = image
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackgroundImageChanged += handler;
-        control.OnParentBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.OnParentBackgroundImageChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBindingContextChanged_Invoke_CallsBindingContextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnParentBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnParentBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentBindingContextChanged_InvokeWithBindingContext_DoesNotCallBindingContextChanged(EventArgs eventArgs)
-    {
-        var context = new BindingContext();
-        using var control = new SubControl
-        {
-            BindingContext = context
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnParentBindingContextChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnParentBindingContextChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentCursorChanged_Invoke_CallsCursorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CursorChanged += handler;
-        control.OnParentCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.OnParentCursorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentCursorChanged_InvokeWithCursor_DoesNotCallCursorChanged(EventArgs eventArgs)
-    {
-        var cursor = new Cursor((IntPtr)1);
-        using var control = new SubControl
-        {
-            Cursor = cursor
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CursorChanged += handler;
-        control.OnParentCursorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.OnParentCursorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentEnabledChanged_Invoke_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentEnabledChanged_InvokeDisabled_DoesNotCallEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            Enabled = false
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnParentFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnParentFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentFontChanged_InvokeWithFont_DoesNotCallFontChanged(EventArgs eventArgs)
-    {
-        var font = new Font("Arial", 8.25f);
-        using var control = new SubControl
-        {
-            Font = font
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnParentFontChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnParentFontChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentForeColorChanged_InvokeWithForeColor_DoesNotCallForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            ForeColor = Color.Red
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentVisibleChanged_Invoke_CallsVisibleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnParentVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnParentVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnParentVisibleChanged_InvokeDisabled_DoesNotCallVisibleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            Visible = false
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnParentVisibleChanged(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnParentVisibleChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPrint_WithoutHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, opaque, 1, false };
-            yield return new object[] { false, opaque, 0, true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPrint_WithoutHandle_TestData))]
-    public void Control_OnPrint_InvokeWithoutHandle_Success(bool userPaint, bool opaque, int expectedPaintCallCount, bool expectedIsHandleCreated)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-        control.OnPrint(eventArgs);
-        Assert.Equal(expectedPaintCallCount, paintCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_OnPrint_InvokeExceptionThrownInOnPaintWithoutHandle_Success()
-    {
-        using var control = new SubControl();
-        int paintCallCount = 0;
-        control.Paint += (sender, e) =>
-        {
-            paintCallCount++;
-            throw new DivideByZeroException();
-        };
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-        Assert.Throws<DivideByZeroException>(() => control.OnPrint(eventArgs));
-        Assert.Equal(1, paintCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Print again.
-        control.OnPrint(eventArgs);
-        Assert.Equal(1, paintCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnPrint_WithHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, opaque, 1 };
-            yield return new object[] { false, opaque, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPrint_WithHandle_TestData))]
-    public void Control_OnPrint_InvokeWithHandle_Success(bool userPaint, bool opaque, int expectedPaintCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-        control.OnPrint(eventArgs);
-        Assert.Equal(expectedPaintCallCount, paintCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnPrint_InvokeExceptionThrownInOnPaintWithHandle_Success()
-    {
-        using var control = new SubControl();
-        int paintCallCount = 0;
-        control.Paint += (sender, e) =>
-        {
-            paintCallCount++;
-            throw new DivideByZeroException();
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-        Assert.Throws<DivideByZeroException>(() => control.OnPrint(eventArgs));
-        Assert.Equal(1, paintCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Print again.
-        control.OnPrint(eventArgs);
-        Assert.Equal(1, paintCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnPrint_InvokeSetTextInPrint_CachesText()
-    {
-        using var control = new SubControl();
-
-        int printCallCount = 0;
-        control.Paint += (sender, e) =>
-        {
-            string longString = new('a', 65536);
-            control.Text = longString;
-            Assert.Equal(longString, control.Text);
-            printCallCount++;
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Empty(control.Text);
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-        control.OnPrint(eventArgs);
-        Assert.Equal(1, printCallCount);
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_OnPrint_InvokeNullE_ThrowsArgumentNullException()
-    {
-        using var control = new SubControl();
-        Assert.Throws<ArgumentNullException>("e", () => control.OnPrint(null));
-    }
-
-    public static IEnumerable<object[]> QueryContinueDragEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new QueryContinueDragEventArgs(0, true, DragAction.Drop) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(QueryContinueDragEventArgs_TestData))]
-    public void Control_OnQueryContinueDrag_Invoke_CallsQueryContinueDrag(QueryContinueDragEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        QueryContinueDragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.QueryContinueDrag += handler;
-        control.OnQueryContinueDrag(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.QueryContinueDrag -= handler;
-        control.OnQueryContinueDrag(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnRegionChanged_Invoke_CallsRegionChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        // Call with handler.
-        control.RegionChanged += handler;
-        control.OnRegionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        control.RegionChanged -= handler;
-        control.OnRegionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnResize_Invoke_CallsResize(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnResize_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_WithHandle_TestData))]
-    public void Control_OnResize_InvokeWithHandle_CallsResize(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnRightToLeftChanged_Invoke_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnRightToLeftChanged_InvokeWithHandle_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnRightToLeftChanged_InvokeInDisposing_DoesNotCallRightToLeftChanged()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnRightToLeftChanged_InvokeWithChildren_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control
-        {
-            RightToLeft = RightToLeft.Inherit
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnRightToLeftChanged_InvokeWithChildrenWithRightToLeft_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var child2 = new Control
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            child1CallCount++;
-        };
-        child2.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSizeChanged_Invoke_CallsSizeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SizeChanged += handler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SizeChanged -= handler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSizeChanged_Invoke_CallsSizeChangedAndResize(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int resizeCallCount = 0;
-        EventHandler resizeHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            resizeCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.SizeChanged += handler;
-        control.Resize += resizeHandler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SizeChanged -= handler;
-        control.Resize -= resizeHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSizeChanged_InvokeWithResizeRedraw_CallsSizeChangedAndResizeAndInvalidate(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, true);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int resizeCallCount = 0;
-        EventHandler resizeHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            resizeCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.SizeChanged += handler;
-        control.Resize += resizeHandler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SizeChanged -= handler;
-        control.Resize -= resizeHandler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnSizeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnStyleChanged_Invoke_CallsStyleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.StyleChanged += handler;
-        control.OnStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.StyleChanged -= handler;
-        control.OnStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSystemColorsChanged_Invoke_CallsSystemColorsChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SystemColorsChanged += handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SystemColorsChanged -= handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSystemColorsChanged_InvokeWithHandle_CallsSystemColorsChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SystemColorsChanged += handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SystemColorsChanged -= handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnSystemColorsChanged_InvokeWithChildren_CallsSystemColorsChanged(EventArgs eventArgs)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        child1.SystemColorsChanged += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1CallCount++;
-        };
-        child2.SystemColorsChanged += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2CallCount++;
-        };
-
-        // Call with handler.
-        control.SystemColorsChanged += handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-
-        // Remove handler.
-        control.SystemColorsChanged -= handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnTabIndexChanged_Invoke_CallsTabIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TabIndexChanged += handler;
-        control.OnTabIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.OnTabIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnTabStopChanged_Invoke_CallsTabStopChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TabStopChanged += handler;
-        control.OnTabStopChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.OnTabStopChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnTextChanged_Invoke_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_OnValidated_Invoke_CallsValidated(EventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Validated += handler;
-        control.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Validated -= handler;
-        control.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnValidating_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs() };
-        yield return new object[] { new CancelEventArgs(true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnValidating_TestData))]
-    public void Control_OnValidating_Invoke_CallsValidating(CancelEventArgs eventArgs)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        CancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Validating += handler;
-        control.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Validating -= handler;
-        control.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            yield return new object[] { visible, null };
-            yield return new object[] { visible, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void Control_OnVisibleChanged_Invoke_CallsVisibleChanged(bool visible, EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void Control_OnVisibleChanged_InvokeWithParent_CallsVisibleChanged(bool visible, EventArgs eventArgs)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent,
-            Visible = visible
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(visible, control.IsHandleCreated);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(visible, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_WithHandle_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (bool userPaint in new bool[] { true, false })
-            {
-                yield return new object[] { visible, userPaint, null };
-                yield return new object[] { visible, userPaint, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_WithHandle_TestData))]
-    public void Control_OnVisibleChanged_InvokeWithHandle_CallsVisibleChangedCallsInvalidated(bool visible, bool userPaint, EventArgs eventArgs)
-    {
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_WithHandle_TestData))]
-    public void Control_OnVisibleChanged_InvokeWithParentWithHandle_CallsVisibleChanged(bool visible, bool userPaint, EventArgs eventArgs)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent,
-            Visible = visible
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_WithChildren_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_WithChildren_TestData))]
-    public void Control_OnVisibleChanged_InvokeWithChildren_CallsVisibleChanged(bool visible, EventArgs eventArgs, int expectedChildCallCount)
-    {
-        using var grandchild1 = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        child1.Controls.Add(grandchild1);
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int grandchildCallCount1 = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        void grandchildHandler1(object sender, EventArgs e)
-        {
-            Assert.Same(grandchild1, sender);
-            Assert.Same(eventArgs, e);
-            grandchildCallCount1++;
-        }
-
-        grandchild1.VisibleChanged += grandchildHandler1;
-        void childHandler1(object sender, EventArgs e)
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount1++;
-        }
-
-        child1.VisibleChanged += childHandler1;
-        void childHandler2(object sender, EventArgs e)
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount2++;
-        }
-
-        child2.VisibleChanged += childHandler2;
-
-        try
-        {
-            // Call with handler.
-            control.VisibleChanged += handler;
-            control.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedChildCallCount, childCallCount1);
-            Assert.Equal(expectedChildCallCount, childCallCount2);
-            Assert.Equal(expectedChildCallCount, grandchildCallCount1);
-
-            // Remove handler.
-            control.VisibleChanged -= handler;
-            control.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(expectedChildCallCount * 2, childCallCount1);
-            Assert.Equal(expectedChildCallCount * 2, childCallCount2);
-            Assert.Equal(expectedChildCallCount * 2, grandchildCallCount1);
-        }
-        finally
-        {
-            grandchild1.VisibleChanged -= grandchildHandler1;
-            child1.VisibleChanged -= childHandler1;
-            child2.VisibleChanged -= childHandler2;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void Control_OnVisibleChanged_InvokeWithChildrenNotVisible_CallsVisibleChanged(bool visible, EventArgs eventArgs)
-    {
-        using var grandchild1 = new Control();
-        using var child1 = new Control
-        {
-            Visible = false
-        };
-        using var child2 = new Control
-        {
-            Visible = false
-        };
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        child1.Controls.Add(grandchild1);
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int grandchildCallCount1 = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        grandchild1.VisibleChanged += (sender, e) => grandchildCallCount1++;
-        child1.VisibleChanged += (sender, e) => childCallCount1++;
-        child2.VisibleChanged += (sender, e) => childCallCount2++;
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-        Assert.Equal(0, grandchildCallCount1);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-        Assert.Equal(0, grandchildCallCount1);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Internals.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Internals.cs
deleted file mode 100644
index 6b62dc29dce..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Internals.cs
+++ /dev/null
@@ -1,447 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.CompilerServices;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlTests
-{
-    [WinFormsFact]
-    public void Control_GetHandleInternalShouldBeZero()
-    {
-        using var control = new Control();
-
-        IntPtr intptr = control.HandleInternal;
-
-        Assert.Equal(IntPtr.Zero, intptr);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_IsTopMdiWindowClosingGetSet(bool expected)
-    {
-        using var control = new Control
-        {
-            IsTopMdiWindowClosing = expected
-        };
-
-        Assert.Equal(expected, control.IsTopMdiWindowClosing);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BoundsSpecified>]
-    public void Control_RequiredScaling_Set_GetReturnsExpected(BoundsSpecified value)
-    {
-        using var control = new Control
-        {
-            RequiredScaling = value
-        };
-        Assert.Equal(value, control.RequiredScaling);
-
-        // Set same.
-        control.RequiredScaling = value;
-        Assert.Equal(value, control.RequiredScaling);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_RequiredScalingEnabled_Get_ReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            RequiredScalingEnabled = value
-        };
-        Assert.Equal(value, control.RequiredScalingEnabled);
-
-        // Set same.
-        control.RequiredScalingEnabled = value;
-        Assert.Equal(value, control.RequiredScalingEnabled);
-
-        // Set different.
-        control.RequiredScalingEnabled = !value;
-        Assert.Equal(!value, control.RequiredScalingEnabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_TabStopInternal_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            TabStopInternal = value
-        };
-        Assert.Equal(value, control.TabStopInternal);
-
-        // Set same.
-        control.TabStopInternal = value;
-        Assert.Equal(value, control.TabStopInternal);
-
-        // Set different.
-        control.TabStopInternal = value;
-        Assert.Equal(value, control.TabStopInternal);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_TabStopInternal_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.TabStopInternal = value;
-        Assert.Equal(value, control.TabStopInternal);
-
-        // Set same.
-        control.TabStopInternal = value;
-        Assert.Equal(value, control.TabStopInternal);
-
-        // Set different.
-        control.TabStopInternal = value;
-        Assert.Equal(value, control.TabStopInternal);
-    }
-
-    [WinFormsFact]
-    public void Control_TabStopInternal_SetWithHandler_DoesNotCallTabStopChanged()
-    {
-        using var control = new Control
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStopInternal = false;
-        Assert.False(control.TabStopInternal);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.TabStopInternal = false;
-        Assert.False(control.TabStopInternal);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.TabStopInternal = true;
-        Assert.True(control.TabStopInternal);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStopInternal = false;
-        Assert.False(control.TabStopInternal);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(false, true)] // setting is impossible; default is false
-    // SupportsUseCompatibleTextRendering is always false
-    public void Control_UseCompatibleTextRenderingIntGetSet(bool given, bool expected)
-    {
-        using var control = new Control
-        {
-            UseCompatibleTextRenderingInt = given
-        };
-
-        Assert.Equal(expected, control.UseCompatibleTextRenderingInt);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ValidationCancelledGetSet(bool expected)
-    {
-        using var control = new Control
-        {
-            ValidationCancelled = expected
-        };
-
-        Assert.Equal(expected, control.ValidationCancelled);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void Control_ApplyBoundsConstraints(int expected)
-    {
-        using var control = new Control();
-        var expectedBounds = new Rectangle(expected, expected, expected, expected);
-
-        Rectangle actualBounds = control.ApplyBoundsConstraints(expected, expected, expected, expected);
-
-        Assert.Equal(expectedBounds, actualBounds);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void Control_ApplySizeConstraints(int expected)
-    {
-        using var control = new Control();
-        var expectedSize = new Size(expected, expected);
-
-        Size actualSize = control.ApplySizeConstraints(expected, expected);
-
-        Assert.Equal(expectedSize, actualSize);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData))]
-    public void Control_ApplySizeConstraintsSize_Invoke_ReturnsExpected(Size expectedSize)
-    {
-        using var control = new Control();
-        Size actualSize = control.ApplySizeConstraints(expectedSize);
-        Assert.Equal(expectedSize, actualSize);
-    }
-
-    [WinFormsFact]
-    public void Control_AssignParent()
-    {
-        using var control = new Control();
-        var parent = new Control();
-
-        control.AssignParent(parent);
-
-        Assert.Equal(parent, control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Control_ParentChangedFromAssign()
-    {
-        bool wasChanged = false;
-        using var control = new Control();
-        control.ParentChanged += (sender, args) => wasChanged = true;
-        var parent = new Control();
-
-        control.AssignParent(parent);
-
-        Assert.True(wasChanged);
-    }
-
-    [WinFormsFact]
-    public void Control_CanProcessMnemonic()
-    {
-        using var control = new Control();
-
-        // act and assert
-        Assert.True(control.CanProcessMnemonic());
-    }
-
-    [WinFormsFact]
-    public void Control_CanProcessMnemonicNotEnabled()
-    {
-        using var control = new Control
-        {
-            Enabled = false
-        };
-
-        // act and assert
-        Assert.False(control.CanProcessMnemonic());
-    }
-
-    [WinFormsFact]
-    public void Control_CanProcessMnemonicNotVisible()
-    {
-        using var control = new Control
-        {
-            Visible = false
-        };
-
-        // act and assert
-        Assert.False(control.CanProcessMnemonic());
-    }
-
-    [WinFormsFact]
-    public void Control_CanProcessMnemonicParent()
-    {
-        using var control = new Control();
-        var parent = new Control();
-        control.AssignParent(parent);
-
-        // act and assert
-        Assert.True(control.CanProcessMnemonic());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_CreateControlInternal(bool fIgnoreVisible)
-    {
-        using var control = new Control();
-
-        control.CreateControl(fIgnoreVisible);
-
-        Assert.True(control.Created);
-    }
-
-    [WinFormsFact]
-    public void Control_GetChildControlsInTabOrder()
-    {
-        using var control = new Control();
-        var first = new Control
-        {
-            TabIndex = 0
-        };
-        var second = new Control
-        {
-            TabIndex = 1
-        };
-        var third = new Control
-        {
-            TabIndex = 2
-        };
-        var ordered = new Control[]
-        {
-            first,
-            second,
-            third
-        };
-        var unordered = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        control.Controls.AddRange(unordered);
-
-        Control[] tabOrderedChildren = control.GetChildControlsInTabOrder(false);
-
-        Assert.Equal(ordered, tabOrderedChildren);
-    }
-
-    [WinFormsFact]
-    public void Control_GetChildControlsInTabOrderHandlesOnly()
-    {
-        using var control = new Control();
-        var first = new Control
-        {
-            TabIndex = 0
-        };
-        var second = new Control
-        {
-            TabIndex = 1
-        };
-        var third = new Control
-        {
-            TabIndex = 2
-        };
-        var unordered = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        control.Controls.AddRange(unordered);
-
-        Control[] tabOrderedChildrenWithhandlesOnly = control.GetChildControlsInTabOrder(true);
-
-        Assert.Empty(tabOrderedChildrenWithhandlesOnly);
-    }
-
-    [WinFormsFact]
-    public void Control_GetFirstChildControlInTabOrder()
-    {
-        using var control = new Control();
-        var first = new Control
-        {
-            TabIndex = 0
-        };
-        var second = new Control
-        {
-            TabIndex = 1
-        };
-        var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        control.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Equal(first, control.GetFirstChildControlInTabOrder(true));
-    }
-
-    [WinFormsFact]
-    public void Control_GetFirstChildControlInTabOrderReverse()
-    {
-        using var control = new Control();
-        var first = new Control
-        {
-            TabIndex = 0
-        };
-        var second = new Control
-        {
-            TabIndex = 1
-        };
-        var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        control.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Equal(third, control.GetFirstChildControlInTabOrder(false));
-    }
-
-    [WinFormsFact]
-    public void Control_NotifyEnter()
-    {
-        bool wasChanged = false;
-        using var control = new Control();
-        control.Enter += (sender, args) => wasChanged = true;
-
-        control.NotifyEnter();
-
-        Assert.True(wasChanged);
-    }
-
-    [WinFormsFact]
-    public void Control_NotifyLeave()
-    {
-        bool wasChanged = false;
-        using var control = new Control();
-        control.Leave += (sender, args) => wasChanged = true;
-
-        control.NotifyLeave();
-
-        Assert.True(wasChanged);
-    }
-
-    [WinFormsFact]
-    public void Control_ReflectParentDoesNotRootParent()
-    {
-        using Control control = new();
-        CreateAndDispose(control);
-        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true);
-        Assert.Null(control.TestAccessor().Dynamic.ReflectParent);
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void CreateAndDispose(Control control)
-        {
-            // Note that rooting of locals changes between release and debug. Having a separate method here
-            // ensures that we'll always get it collected when doing GC.Collect out in the caller.
-            using Form form = new();
-            form.Controls.Add(control);
-            form.Show();
-            form.Controls.Remove(control);
-            Assert.NotNull(control.TestAccessor().Dynamic.ReflectParent);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Methods.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Methods.cs
deleted file mode 100644
index 581b08e42a8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Methods.cs
+++ /dev/null
@@ -1,14428 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Reflection;
-using System.Windows.Forms.Layout;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlTests
-{
-    public static IEnumerable<object[]> AccessibilityNotifyClients_AccessibleEvents_Int_TestData()
-    {
-        yield return new object[] { AccessibleEvents.DescriptionChange, int.MinValue };
-        yield return new object[] { AccessibleEvents.DescriptionChange, -1 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, 0 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, 1 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, int.MaxValue };
-        yield return new object[] { (AccessibleEvents)0, int.MinValue };
-        yield return new object[] { (AccessibleEvents)0, -1 };
-        yield return new object[] { (AccessibleEvents)0, 0 };
-        yield return new object[] { (AccessibleEvents)0, 1 };
-        yield return new object[] { (AccessibleEvents)0, int.MaxValue };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, int.MinValue };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, -1 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, 0 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, 1 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityNotifyClients_AccessibleEvents_Int_TestData))]
-    public void Control_AccessibilityNotifyClients_InvokeAccessibleEventsIntWithoutHandle_Nop(AccessibleEvents accEvent, int childID)
-    {
-        using var control = new SubControl();
-        control.AccessibilityNotifyClients(accEvent, childID);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.AccessibilityNotifyClients(accEvent, childID);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityNotifyClients_AccessibleEvents_Int_TestData))]
-    public void Control_AccessibilityNotifyClients_InvokeAccessibleEventsIntWithHandle_Success(AccessibleEvents accEvent, int childID)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.AccessibilityNotifyClients(accEvent, childID);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.AccessibilityNotifyClients(accEvent, childID);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AccessibilityNotifyClients_AccessibleEvents_Int_Int_TestData()
-    {
-        yield return new object[] { AccessibleEvents.DescriptionChange, int.MaxValue, int.MinValue };
-        yield return new object[] { AccessibleEvents.DescriptionChange, 1, -1 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, 0, 0 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, -1, 1 };
-        yield return new object[] { AccessibleEvents.DescriptionChange, int.MinValue, int.MaxValue };
-        yield return new object[] { (AccessibleEvents)0, int.MaxValue, int.MinValue };
-        yield return new object[] { (AccessibleEvents)0, 1, -1 };
-        yield return new object[] { (AccessibleEvents)0, 0, 0 };
-        yield return new object[] { (AccessibleEvents)0, -1, 1 };
-        yield return new object[] { (AccessibleEvents)0, int.MinValue, int.MaxValue };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, int.MaxValue, int.MinValue };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, 1, -1 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, 0, 0 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, 1, 1 };
-        yield return new object[] { (AccessibleEvents)int.MaxValue, int.MinValue, int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityNotifyClients_AccessibleEvents_Int_Int_TestData))]
-    public void Control_AccessibilityNotifyClients_InvokeAccessibleEventsIntIntWithoutHandle_Nop(AccessibleEvents accEvent, int objectID, int childID)
-    {
-        using var control = new SubControl();
-        control.AccessibilityNotifyClients(accEvent, objectID, childID);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.AccessibilityNotifyClients(accEvent, objectID, childID);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityNotifyClients_AccessibleEvents_Int_Int_TestData))]
-    public void Control_AccessibilityNotifyClients_InvokeAccessibleEventsIntIntWithHandle_Success(AccessibleEvents accEvent, int objectID, int childID)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.AccessibilityNotifyClients(accEvent, objectID, childID);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.AccessibilityNotifyClients(accEvent, objectID, childID);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_BringToFront_InvokeWithoutHandleWithoutParent_Nop(bool topLevel)
-    {
-        using var control = new SubControl();
-        control.SetTopLevel(topLevel);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.BringToFront();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(topLevel, control.IsHandleCreated);
-
-        // Call again.
-        control.BringToFront();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(topLevel, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_BringToFront_InvokeWithoutHandleWithParent_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child2, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_BringToFront_InvokeWithHandleWithParentWithoutHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child2, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, child1.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_BringToFront_InvokeWithHandleWithParentWithHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child2, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_BringToFront_InvokeWithoutHandleWithParentWithHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new SubControl();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child2, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        child1.DestroyHandle();
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child2.BringToFront();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_BringToFront_InvokeWithHandleWithoutParent_Success(bool enabled, bool topLevel)
-    {
-        using var control = new SubControl
-        {
-            Enabled = enabled
-        };
-        control.SetTopLevel(topLevel);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BringToFront();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.BringToFront();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void Control_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createHandle, AccessibleRole expectedAccessibleRole)
-    {
-        using var control = new SubControl();
-        if (createHandle)
-        {
-            control.CreateHandle();
-        }
-
-        Assert.Equal(createHandle, control.IsHandleCreated);
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedAccessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Equal(createHandle, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_Invoke_Success()
-    {
-        using var control = new SubControl();
-        Assert.True(control.GetStyle(ControlStyles.UserPaint));
-
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        IntPtr handle1 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle1);
-
-        // Call again.
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        IntPtr handle2 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.Equal(handle1, handle2);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeNoUserPaint_Success()
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, false);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    public static IEnumerable<object[]> CreateControl_Region_TestData()
-    {
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateControl_Region_TestData))]
-    public void Control_CreateControl_InvokeWithRegion_Success(Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Same(region, control.Region);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_CreateControl_InvokeWithText_Success(string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeAllowDrop_Success()
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-
-        control.CreateControl();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.AllowDrop);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeWithParent_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.CreateControl();
-        Assert.False(parent.Created);
-        Assert.False(parent.IsHandleCreated);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_CreateControl_InvokeWithHandleWithText_Success(string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-
-        IntPtr handle1 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.Equal(expectedText, control.Text);
-
-        control.DestroyHandle();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedText, control.Text);
-
-        IntPtr handle2 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle2, handle1);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeWithChildren_Success()
-    {
-        using var parent = new SubControl();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        parent.CreateControl();
-        Assert.True(parent.Created);
-        Assert.True(parent.IsHandleCreated);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeNotVisible_Nop()
-    {
-        using var control = new Control
-        {
-            Visible = false
-        };
-        control.CreateControl();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeWithHandler_CallsHandleCreated()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.HandleCreated += handler;
-
-        control.CreateControl();
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeCantCreate_ThrowsWin32Exception()
-    {
-        using var control = new NoCreateControl();
-        Assert.Throws<Win32Exception>(() => control.CreateControl());
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControl_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new SubControl();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.CreateControl());
-    }
-
-    [WinFormsFact]
-    public void Control_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Control.ControlCollection controls = Assert.IsType<Control.ControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.False(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_CreateHandle_Invoke_Success(bool resizeRedraw)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    public static IEnumerable<object[]> CreateHandle_Region_TestData()
-    {
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateHandle_Region_TestData))]
-    public void Control_CreateHandle_InvokeWithRegion_Success(Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Same(region, control.Region);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_CreateHandle_InvokeWithText_Success(string text, string expectedText)
-    {
-        using var control = new SubControl
-        {
-            Text = text
-        };
-
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expectedText, control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeAllowDrop_Success()
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.AllowDrop);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeWithParent_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.CreateHandle();
-        Assert.False(parent.Created);
-        Assert.False(parent.IsHandleCreated);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeWithChildren_Success()
-    {
-        using var parent = new SubControl();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        parent.CreateHandle();
-        Assert.True(parent.Created);
-        Assert.True(parent.IsHandleCreated);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeNotVisible_Nop()
-    {
-        using var control = new SubControl
-        {
-            Visible = false
-        };
-        control.CreateHandle();
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeWithHandler_CallsHandleCreated()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.HandleCreated += handler;
-
-        control.CreateHandle();
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeCantCreate_ThrowsWin32Exception()
-    {
-        using var control = new NoCreateControl();
-        Assert.Throws<Win32Exception>(() => control.CreateHandle());
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new SubControl();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.CreateHandle());
-    }
-
-    [WinFormsFact]
-    public void Control_CreateHandle_InvokeAlreadyCreated_ThrowsInvalidOperationException()
-    {
-        using var control = new SubControl();
-        control.CreateHandle();
-        Assert.Throws<InvalidOperationException>(() => control.CreateHandle());
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        using var child1 = new Control
-        {
-            Parent = control
-        };
-        using var child2 = new Control
-        {
-            Parent = control
-        };
-        using var grandchild1 = new Control
-        {
-            Parent = child1
-        };
-        using var otherParent = new Control();
-        using var otherControl = new Control
-        {
-            Parent = otherParent
-        };
-        using var emptyControl = new Control();
-
-        Assert.True(parent.Contains(control));
-        Assert.True(parent.Contains(child1));
-        Assert.True(parent.Contains(child2));
-        Assert.True(parent.Contains(grandchild1));
-        Assert.False(parent.Contains(parent));
-
-        Assert.True(control.Contains(child1));
-        Assert.True(control.Contains(child2));
-        Assert.True(control.Contains(grandchild1));
-        Assert.False(control.Contains(control));
-        Assert.False(control.Contains(parent));
-
-        Assert.False(control.Contains(emptyControl));
-        Assert.False(control.Contains(otherParent));
-        Assert.False(control.Contains(otherControl));
-        Assert.False(control.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void Control_DestroyHandle_InvokeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        IntPtr handle1 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle1);
-
-        control.DestroyHandle();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        IntPtr handle2 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle2, handle1);
-    }
-
-    [WinFormsFact]
-    public void Control_DestroyHandle_InvokeWithHandleWithParent_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-
-        control.DestroyHandle();
-        Assert.True(parent.IsHandleCreated);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(parent, control.Parent);
-    }
-
-    public static IEnumerable<object[]> DestroyHandle_Region_TestData()
-    {
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateHandle_Region_TestData))]
-    public void Control_DestroyHandle_InvokeWithRegion_Success(Region region)
-    {
-        using var control = new SubControl
-        {
-            Region = region
-        };
-
-        IntPtr handle1 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.Same(region, control.Region);
-
-        control.DestroyHandle();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(region, control.Region);
-
-        IntPtr handle2 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle2, handle1);
-        Assert.Same(region, control.Region);
-    }
-
-    [WinFormsFact]
-    public void Control_DestroyHandle_InvokeWithHandleAllowDrop_Success()
-    {
-        using var control = new SubControl
-        {
-            AllowDrop = true
-        };
-
-        IntPtr handle1 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.True(control.AllowDrop);
-
-        control.DestroyHandle();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.AllowDrop);
-
-        IntPtr handle2 = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle2, handle1);
-        Assert.True(control.AllowDrop);
-    }
-
-    [WinFormsFact]
-    public void Control_DestroyHandle_InvokeWithoutHandle_Nop()
-    {
-        using var control = new SubControl();
-        control.DestroyHandle();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_DestroyHandle_InvokeWithHandler_CallsHandleDestroyed()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.HandleDestroyed += handler;
-
-        control.DestroyHandle();
-        Assert.Equal(0, callCount);
-
-        IntPtr handle = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle);
-
-        control.DestroyHandle();
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        control.DestroyHandle();
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        handle = control.Handle;
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle);
-
-        control.HandleDestroyed -= handler;
-        control.DestroyHandle();
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_Invoke_Success()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeWithParent_Success()
-    {
-        using var parent = new Control();
-        int controlRemovedCallCount = 0;
-        parent.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(1, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(1, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeWithChildren_Success()
-    {
-        using var control = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int child1CallCount = 0;
-        child1.Disposed += (sender, e) => child1CallCount++;
-        int child2CallCount = 0;
-        child2.Disposed += (sender, e) => child2CallCount++;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.True(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.True(child2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, child1CallCount);
-            Assert.Equal(1, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.True(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.True(child2.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, child1CallCount);
-            Assert.Equal(1, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeWithBindings_Success()
-    {
-        using var control = new Control();
-        control.DataBindings.Add(new Binding("Text", new object(), "member"));
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeWithHandle_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int destroyedCallCount = 0;
-        control.HandleDestroyed += (sender, e) => destroyedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(1, destroyedCallCount);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(1, destroyedCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeInDisposing_Nop()
-    {
-        using var control = new SubControl();
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.Dispose();
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposing_Success()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeNotDisposing_Success()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposingWithParent_Success()
-    {
-        using var parent = new SubControl();
-        int controlRemovedCallCount = 0;
-        parent.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(1, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(1, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeNotDisposingWithParent_Success()
-    {
-        using var parent = new SubControl();
-        int controlRemovedCallCount = 0;
-        parent.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Same(parent, control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.False(control.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Same(parent, control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.False(control.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposingWithChildren_Success()
-    {
-        using var control = new SubControl();
-        using var child1 = new SubControl();
-        using var child2 = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int child1CallCount = 0;
-        child1.Disposed += (sender, e) => child1CallCount++;
-        int child2CallCount = 0;
-        child2.Disposed += (sender, e) => child2CallCount++;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.True(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.True(child2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, child1CallCount);
-            Assert.Equal(1, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.True(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.True(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.True(child2.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, child1CallCount);
-            Assert.Equal(1, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeNotDisposingWithChildren_Success()
-    {
-        using var control = new SubControl();
-        using var child1 = new SubControl();
-        using var child2 = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-        int child1CallCount = 0;
-        child1.Disposed += (sender, e) => child1CallCount++;
-        int child2CallCount = 0;
-        child2.Disposed += (sender, e) => child2CallCount++;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, child1.Parent);
-            Assert.Same(control, child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.False(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.False(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.False(child2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, child1CallCount);
-            Assert.Equal(0, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, child1.Parent);
-            Assert.Same(control, child2.Parent);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.Disposing);
-            Assert.False(control.IsDisposed);
-            Assert.False(child1.Disposing);
-            Assert.False(child1.IsDisposed);
-            Assert.False(child2.Disposing);
-            Assert.False(child2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, child1CallCount);
-            Assert.Equal(0, child2CallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposingWithBindings_Success()
-    {
-        using var control = new SubControl();
-        control.DataBindings.Add(new Binding("Text", new object(), "member"));
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeNotDisposingWithBindings_Success()
-    {
-        using var control = new SubControl();
-        var binding = new Binding("Text", new object(), "member");
-        control.DataBindings.Add(binding);
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Same(binding, Assert.Single(control.DataBindings));
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Same(binding, Assert.Single(control.DataBindings));
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposingWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int destroyedCallCount = 0;
-        control.HandleDestroyed += (sender, e) => destroyedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(1, destroyedCallCount);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(1, destroyedCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeNotDisposingWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int destroyedCallCount = 0;
-        control.HandleDestroyed += (sender, e) => destroyedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(0, destroyedCallCount);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(0, destroyedCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Dispose_InvokeDisposingInDisposing_Nop()
-    {
-        using var control = new SubControl();
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.Dispose(true);
-            disposedCallCount++;
-        };
-
-        control.Dispose(true);
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    public static IEnumerable<object[]> DoDragDrop_TestData()
-    {
-        foreach (DragDropEffects allowedEffects in Enum.GetValues(typeof(DragDropEffects)))
-        {
-            yield return new object[] { "text", allowedEffects };
-            yield return new object[] { new DataObject(), allowedEffects };
-            yield return new object[] { new DataObject("data"), allowedEffects };
-            yield return new object[] { new Mock<IDataObject>(MockBehavior.Strict).Object, allowedEffects };
-            yield return new object[] { new Mock<IComDataObject>(MockBehavior.Strict).Object, allowedEffects };
-        }
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void Control_DoDragDrop_Invoke_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var control = new Control();
-        Assert.Equal(DragDropEffects.None, control.DoDragDrop(data, allowedEffects));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void Control_DoDragDrop_InvokeWithHandle_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DragDropEffects.None, control.DoDragDrop(data, allowedEffects));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_DoDragDrop_NullData_ThrowsArgumentNullException()
-    {
-        using var control = new Control();
-        Assert.Throws<ArgumentNullException>("data", () => control.DoDragDrop(null, DragDropEffects.All));
-    }
-
-    public static IEnumerable<object[]> DrawToBitmap_TestData()
-    {
-        yield return new object[] { new Rectangle(0, 0, 1, 1) };
-        yield return new object[] { new Rectangle(0, 0, 10, 10) };
-        yield return new object[] { new Rectangle(2, 3, 10, 15) };
-        yield return new object[] { new Rectangle(2, 3, 15, 10) };
-        yield return new object[] { new Rectangle(0, 0, 100, 150) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawToBitmap_TestData))]
-    public void Control_DrawToBitmap_Invoke_Success(Rectangle targetBounds)
-    {
-        using var control = new SubControl
-        {
-            Width = 20,
-            Height = 20,
-        };
-        using var bitmap = new Bitmap(20, 20);
-        control.DrawToBitmap(bitmap, targetBounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawToBitmap_TestData))]
-    public void Control_DrawToBitmap_InvokeWithHandle_Success(Rectangle rectangle)
-    {
-        using var control = new SubControl
-        {
-            Width = 20,
-            Height = 20,
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var bitmap = new Bitmap(20, 20);
-        control.DrawToBitmap(bitmap, rectangle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_DrawToBitmap_NullBitmap_ThrowsArgumentNullException()
-    {
-        using var control = new SubControl();
-        Assert.Throws<ArgumentNullException>("bitmap", () => control.DrawToBitmap(null, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0, 1, 2)]
-    [InlineData(0, -1, 1, 2)]
-    [InlineData(0, 0, -1, 2)]
-    [InlineData(0, 0, 0, 2)]
-    [InlineData(0, 0, 1, -1)]
-    [InlineData(0, 0, 1, 0)]
-    public void Control_DrawToBitmap_InvalidTargetBounds_ThrowsArgumentException(int x, int y, int width, int height)
-    {
-        using var control = new SubControl
-        {
-            Width = 20,
-            Height = 20
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(x, y, width, height)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void Control_DrawToBitmap_InvokeZeroWidth_ThrowsArgumentException(int width)
-    {
-        using var control = new SubControl
-        {
-            Width = width,
-            Height = 20
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void Control_DrawToBitmap_InvokeZeroHeight_ThrowsArgumentException(int height)
-    {
-        using var control = new SubControl
-        {
-            Width = 20,
-            Height = height
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsFact]
-    public void Control_FindFormWithParent_ReturnsForm()
-    {
-        using var control = new Control();
-        var form = new Form();
-        control.Parent = form;
-        Assert.Equal(form, control.FindForm());
-    }
-
-    [WinFormsFact]
-    public void Control_FindFormWithoutParent_ReturnsNull()
-    {
-        using var control = new Control();
-        Assert.Null(control.FindForm());
-    }
-
-    [WinFormsFact]
-    public void Control_FromChildHandle_InvokeControlHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        IntPtr handle = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Same(control, Control.FromChildHandle(handle));
-
-        // Get when destroyed.
-        control.DestroyHandle();
-        Assert.Null(Control.FromChildHandle(handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromChildHandle_InvokeNativeWindowHandle_ReturnsExpected()
-    {
-        var window = new NativeWindow();
-        window.CreateHandle(new CreateParams());
-        IntPtr handle = window.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Null(Control.FromChildHandle(handle));
-
-        // Get when destroyed.
-        window.DestroyHandle();
-        Assert.Null(Control.FromChildHandle(handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromChildHandle_InvokeChildHandle_ReturnsExpected()
-    {
-        using var parent = new SubControl();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        IntPtr parentHandle = parent.Handle;
-        Assert.NotEqual(IntPtr.Zero, parentHandle);
-        Assert.True(control.IsHandleCreated);
-
-        var window = new NativeWindow();
-        window.CreateHandle(control.CreateParams);
-        Assert.Same(parent, Control.FromChildHandle(window.Handle));
-
-        // Get when destroyed.
-        window.DestroyHandle();
-        Assert.Null(Control.FromChildHandle(window.Handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromChildHandle_InvokeNoSuchControl_ReturnsNull()
-    {
-        Assert.Null(Control.FromChildHandle(IntPtr.Zero));
-        Assert.Null(Control.FromChildHandle((IntPtr)1));
-    }
-
-    [WinFormsFact]
-    public void Control_FromHandle_InvokeControlHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        IntPtr handle = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Same(control, Control.FromHandle(handle));
-
-        // Get when destroyed.
-        control.DestroyHandle();
-        Assert.Null(Control.FromHandle(handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromHandle_InvokeNativeWindowHandle_ReturnsExpected()
-    {
-        var window = new NativeWindow();
-        window.CreateHandle(new CreateParams());
-        IntPtr handle = window.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Null(Control.FromHandle(handle));
-
-        // Get when destroyed.
-        window.DestroyHandle();
-        Assert.Null(Control.FromHandle(handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromHandle_InvokeChildHandle_ReturnsExpected()
-    {
-        using var parent = new SubControl();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        IntPtr parentHandle = parent.Handle;
-        Assert.NotEqual(IntPtr.Zero, parentHandle);
-        Assert.True(control.IsHandleCreated);
-
-        var window = new NativeWindow();
-        window.CreateHandle(control.CreateParams);
-        Assert.Null(Control.FromHandle(window.Handle));
-
-        // Get when destroyed.
-        window.DestroyHandle();
-        Assert.Null(Control.FromHandle(window.Handle));
-    }
-
-    [WinFormsFact]
-    public void Control_FromHandle_InvokeNoSuchControl_ReturnsNull()
-    {
-        Assert.Null(Control.FromHandle(IntPtr.Zero));
-        Assert.Null(Control.FromHandle((IntPtr)1));
-    }
-
-    // TODO: create a focus test that returns true when a handle has been created
-    [WinFormsFact]
-    public void Control_Focus_InvokeWithoutHandle_Nop()
-    {
-        using var control = new Control();
-        Assert.False(control.Focus());
-        Assert.False(control.Focused);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-
-        // Call again to test caching.
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [EnumData<GetChildAtPointSkip>]
-    public void Control_GetChildAtPoint_Invoke_ReturnsExpected(GetChildAtPointSkip skipValue)
-    {
-        using var control = new Control();
-        Assert.Null(control.GetChildAtPoint(new Point(5, 5), skipValue));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(control.GetChildAtPoint(new Point(5, 5), skipValue));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((GetChildAtPointSkip)(-1))]
-    [InlineData((GetChildAtPointSkip)8)]
-    public void Control_GetChildAtPoint_InvokeInvalidSkipValue_ThrowsInvalidEnumArgumentException(GetChildAtPointSkip skipValue)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("skipValue", () => control.GetChildAtPoint(new Point(5, 5), skipValue));
-    }
-
-    [WinFormsFact]
-    public void Control_GetContainerControl_GetWithParent_ReturnsNull()
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Null(control.GetContainerControl());
-        Assert.Null(parent.GetContainerControl());
-        Assert.Null(grandparent.GetContainerControl());
-    }
-
-    [WinFormsFact]
-    public void Control_GetContainerControl_GetWithContainerControlParent_ReturnsExpected()
-    {
-        using var greatGrandparent = new ContainerControl();
-        using var grandparent = new ContainerControl
-        {
-            Parent = greatGrandparent
-        };
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(grandparent, control.GetContainerControl());
-        Assert.Same(grandparent, parent.GetContainerControl());
-        Assert.Same(grandparent, grandparent.GetContainerControl());
-    }
-
-    [WinFormsFact]
-    public void Control_GetContainerControl_GetWithSplitContainerParent_ReturnsExpected()
-    {
-        using var greatGrandparent = new ContainerControl();
-        using var grandparent = new SplitContainer
-        {
-            Parent = greatGrandparent
-        };
-        using var control = new Control
-        {
-            Parent = grandparent.Panel1
-        };
-        Assert.Same(grandparent, control.GetContainerControl());
-        Assert.Same(grandparent, grandparent.Panel1.GetContainerControl());
-        Assert.Same(greatGrandparent, grandparent.GetContainerControl());
-    }
-
-    [WinFormsFact]
-    public void Control_GetContainerControl_GetWithInvalidContainerControlParent_ReturnsExpected()
-    {
-        using var greatGrandparent = new ContainerControl();
-        using var grandparent = new SubContainerControl
-        {
-            Parent = greatGrandparent
-        };
-        grandparent.SetStyle(ControlStyles.ContainerControl, false);
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(greatGrandparent, control.GetContainerControl());
-        Assert.Same(greatGrandparent, parent.GetContainerControl());
-        Assert.Same(greatGrandparent, grandparent.GetContainerControl());
-    }
-
-    [WinFormsFact]
-    public void Control_GetContainerControl_GetWithFakeContainerControlParent_ReturnsExpected()
-    {
-        using var greatGrandparent = new ContainerControl();
-        using var grandparent = new SubControl
-        {
-            Parent = greatGrandparent
-        };
-        grandparent.SetStyle(ControlStyles.ContainerControl, true);
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(greatGrandparent, control.GetContainerControl());
-        Assert.Same(greatGrandparent, parent.GetContainerControl());
-        Assert.Same(greatGrandparent, grandparent.GetContainerControl());
-    }
-
-    private class SubContainerControl : ContainerControl
-    {
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    [WinFormsFact]
-    public void Control_GetNextControl()
-    {
-        using var cont = new Control();
-        using var first = new Control
-        {
-            TabIndex = 0
-        };
-        using var second = new Control
-        {
-            TabIndex = 1
-        };
-        using var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        cont.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Equal(second, cont.GetNextControl(first, true));
-    }
-
-    [WinFormsFact]
-    public void Control_GetNextControlReverse()
-    {
-        using var cont = new Control();
-        using var first = new Control
-        {
-            TabIndex = 0
-        };
-        using var second = new Control
-        {
-            TabIndex = 1
-        };
-        using var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        cont.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Equal(first, cont.GetNextControl(second, false));
-    }
-
-    [WinFormsFact]
-    public void Control_GetNextControlNoNext()
-    {
-        using var cont = new Control();
-        using var first = new Control
-        {
-            TabIndex = 0
-        };
-        using var second = new Control
-        {
-            TabIndex = 1
-        };
-        using var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        cont.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Null(cont.GetNextControl(third, true));
-    }
-
-    [WinFormsFact]
-    public void Control_GetNextControlNoNextReverse()
-    {
-        using var cont = new Control();
-        using var first = new Control
-        {
-            TabIndex = 0
-        };
-        using var second = new Control
-        {
-            TabIndex = 1
-        };
-        using var third = new Control
-        {
-            TabIndex = 2
-        };
-        var tabOrder = new Control[]
-        {
-            second,
-            first,
-            third
-        };
-        cont.Controls.AddRange(tabOrder);
-
-        // act and assert
-        Assert.Null(cont.GetNextControl(first, false));
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void Control_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new Control();
-        Assert.Equal(Size.Empty, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(Size.Empty, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void Control_GetPreferredSize_InvokeWithBounds_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        Assert.Equal(new Size(30, 40), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(30, 40), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, new Size(30, 40), Size.Empty };
-        yield return new object[] { new Size(10, 20), Size.Empty, new Size(30, 40), new Size(10, 20) };
-        yield return new object[] { new Size(30, 40), Size.Empty, new Size(30, 40), new Size(30, 40) };
-        yield return new object[] { new Size(31, 40), Size.Empty, new Size(30, 40), new Size(31, 40) };
-        yield return new object[] { new Size(30, 41), Size.Empty, new Size(30, 40), new Size(30, 41) };
-        yield return new object[] { new Size(40, 50), Size.Empty, new Size(30, 40), new Size(40, 50) };
-        yield return new object[] { Size.Empty, new Size(20, 10), new Size(30, 40), Size.Empty };
-        yield return new object[] { Size.Empty, new Size(30, 40), new Size(30, 40), Size.Empty };
-        yield return new object[] { Size.Empty, new Size(31, 40), new Size(30, 40), Size.Empty };
-        yield return new object[] { Size.Empty, new Size(30, 41), new Size(30, 40), Size.Empty };
-        yield return new object[] { Size.Empty, new Size(40, 50), new Size(30, 40), Size.Empty };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), new Size(30, 40), new Size(10, 20) };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), new Size(int.MaxValue, int.MaxValue), new Size(10, 20) };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), new Size(10, 20) };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), new Size(10, 20) };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), new Size(30, 40), new Size(30, 40) };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), new Size(30, 40), new Size(30, 40) };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), new Size(30, 40), new Size(40, 50) };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), new Size(30, 40), new Size(40, 50) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithConstrainedSize_TestData))]
-    public void Control_GetPreferredSize_InvokeWithConstrainedSize_ReturnsExpected(Size minimumSize, Size maximumSize, Size proposedSize, Size expected)
-    {
-        using var control = new Control
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize,
-        };
-        Assert.Equal(expected, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 0) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 6, 12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 12) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, -6, -12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, -12) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_TestData))]
-    public void Control_GetScaledBounds_Invoke_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubControl();
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_WithStyles_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 4, 4) };
-        yield return new object[] { Rectangle.Empty, new Size(0, 0), BoundsSpecified.X, Rectangle.Empty };
-        yield return new object[] { Rectangle.Empty, new Size(0, 0), BoundsSpecified.Y, Rectangle.Empty };
-        yield return new object[] { Rectangle.Empty, new Size(0, 0), BoundsSpecified.Width, new Rectangle(0, 0, 4, 0) };
-        yield return new object[] { Rectangle.Empty, new Size(0, 0), BoundsSpecified.Height, new Rectangle(0, 0, 0, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 4, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 4, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 2, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 2, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_WithStyles_TestData))]
-    public void Control_GetScaledBounds_InvokeWithStyles_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new BorderedControl();
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_TestData))]
-    public void Control_GetScaledBounds_InvokeWithSite_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_InvalidDesignModeSite_TestData()
-    {
-        foreach (object[] testData in GetScaledBounds_TestData())
-        {
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], null };
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], new object() };
-
-            var mockNullDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-            mockNullDesignerHost
-                .Setup(s => s.RootComponent)
-                .Returns((IComponent)null);
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], mockNullDesignerHost.Object };
-
-            var mockUnknownDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-            mockUnknownDesignerHost
-                .Setup(s => s.RootComponent)
-                .Returns(new Control());
-            yield return new object[] { testData[0], testData[1], testData[2], testData[3], mockUnknownDesignerHost.Object };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_InvalidDesignModeSite_TestData))]
-    public void Control_GetScaledBounds_InvokeWithInvalidDesignModeSite_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected, object designerHost)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(designerHost)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_NoScaleLocation_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(1, 2, 0, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 0) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(1, 2, 6, 12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 12) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(1, 2, -6, -12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, -12) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_NoScaleLocation_TestData))]
-    public void Control_GetScaledBounds_InvokeWithValidDesignModeSite_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubControl
-        {
-            Site = mockSite.Object
-        };
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(control)
-            .Verifiable();
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Exactly(2));
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_NoScaleLocation_TestData))]
-    public void Control_GetScaledBounds_InvokeTopLevel_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubControl();
-        control.SetTopLevel(true);
-
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_FixedWidth_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 0) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 3, 12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 12) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, 3, -12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, -12) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_FixedWidth_TestData))]
-    public void Control_GetScaledBounds_InvokeFixedWidth_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.FixedWidth, true);
-
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_FixedHeight_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_FixedHeight_TestData))]
-    public void Control_GetScaledBounds_InvokeFixedHeight_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.FixedHeight, true);
-
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_FixedWidthAndHeight_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_FixedWidthAndHeight_TestData))]
-    public void Control_GetScaledBounds_InvokeFixedWidthAndHeight_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.FixedWidth, true);
-        control.SetStyle(ControlStyles.FixedHeight, true);
-
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_FixedWidthAndHeight_TestData))]
-    public void Control_GetScaledBounds_InvokeFixedWidthAndHeightWithStyles_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new BorderedControl();
-        control.SetStyle(ControlStyles.FixedWidth, true);
-        control.SetStyle(ControlStyles.FixedHeight, true);
-
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Control_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Control_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.False(control.GetTopLevel());
-
-        // Call again to test caching.
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void Control_Hide_Invoke_SetsInvisible()
-    {
-        using var control = new Control
-        {
-            Visible = true
-        };
-        control.Hide();
-        Assert.False(control.Visible);
-
-        // Hide again.
-        control.Hide();
-        Assert.False(control.Visible);
-    }
-
-    [WinFormsFact]
-    public void Control_Hide_InvokeWithHandler_CallsVisibleChanged()
-    {
-        using var control = new Control
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        control.Hide();
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        control.Hide();
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = true;
-        control.Hide();
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InitLayout_Invoke_Success()
-    {
-        using var control = new SubControl();
-        control.InitLayout();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.InitLayout();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_InitLayout_InvokeMocked_Success()
-    {
-        using var control = new CustomLayoutEngineControl();
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.InitLayout(control, BoundsSpecified.All))
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-
-        control.InitLayout();
-        mockLayoutEngine.Verify(e => e.InitLayout(control, BoundsSpecified.All), Times.Once());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.InitLayout();
-        mockLayoutEngine.Verify(e => e.InitLayout(control, BoundsSpecified.All), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_InitLayout_NullLayoutEngine_ThrowsNullReferenceException()
-    {
-        using var control = new CustomLayoutEngineControl();
-        control.SetLayoutEngine(null);
-        Assert.Throws<NullReferenceException>(() => control.InitLayout());
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = new Control().LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-
-        public new void InitLayout() => base.InitLayout();
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Invalidate_Invoke_Success(bool opaque)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate();
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate();
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Invalidate_InvokeWithHandle_Success(bool opaque)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(control.ClientRectangle, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Invalidate_InvokeWithChildrenWithHandle_Success(bool opaque)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(control.ClientRectangle, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_Invalidate_InvokeBool_Success(bool opaque, bool invalidateChildren)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate(invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate(invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_Invalidate_InvokeBoolWithHandle_Success(bool opaque, bool invalidateChildren)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(control.ClientRectangle, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate(invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate(invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_Invalidate_InvokeBoolWithChildrenWithHandle_Success(bool opaque, bool invalidateChildren)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(control.ClientRectangle, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate(invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate(invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Rectangle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { opaque, Rectangle.Empty };
-            yield return new object[] { opaque, new Rectangle(0, 0, 10, 20) };
-            yield return new object[] { opaque, new Rectangle(1, 2, 3, 4) };
-            yield return new object[] { opaque, new Rectangle(5, 10, 5, 10) };
-            yield return new object[] { opaque, new Rectangle(100, 200, 300, 400) };
-            yield return new object[] { opaque, new Rectangle(-100, -200, -300, -400) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void Control_Invalidate_InvokeRectangle_Success(bool opaque, Rectangle rc)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate(rc);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate(rc);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Rectangle_WithHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { opaque, Rectangle.Empty, new Rectangle(0, 0, 10, 20) };
-            yield return new object[] { opaque, new Rectangle(0, 0, 10, 20), new Rectangle(0, 0, 10, 20) };
-            yield return new object[] { opaque, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
-            yield return new object[] { opaque, new Rectangle(5, 10, 5, 10), new Rectangle(5, 10, 5, 10) };
-            yield return new object[] { opaque, new Rectangle(100, 200, 300, 400), new Rectangle(100, 200, 300, 400) };
-            yield return new object[] { opaque, new Rectangle(-100, -200, -300, -400), new Rectangle(-100, -200, -300, -400) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRectangleWithHandle_Success(bool opaque, Rectangle rc, Rectangle expectedInvalidRect)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate(rc);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate(rc);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRectangleWithChildrenWithHandle_Success(bool opaque, Rectangle rc, Rectangle expectedInvalidRect)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate(rc);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate(rc);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Rectangle_Bool_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            foreach (bool invalidateChildren in new bool[] { true, false })
-            {
-                yield return new object[] { opaque, Rectangle.Empty, invalidateChildren };
-                yield return new object[] { opaque, new Rectangle(0, 0, 10, 20), invalidateChildren };
-                yield return new object[] { opaque, new Rectangle(1, 2, 3, 4), invalidateChildren };
-                yield return new object[] { opaque, new Rectangle(5, 10, 5, 10), invalidateChildren };
-                yield return new object[] { opaque, new Rectangle(100, 200, 300, 400), invalidateChildren };
-                yield return new object[] { opaque, new Rectangle(-100, -200, -300, -400), invalidateChildren };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_Bool_TestData))]
-    public void Control_Invalidate_InvokeRectangleBool_Success(bool opaque, Rectangle rc, bool invalidateChildren)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate(rc, invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate(rc, invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Rectangle_Bool_WithHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            foreach (bool invalidateChildren in new bool[] { true, false })
-            {
-                yield return new object[] { opaque, Rectangle.Empty, invalidateChildren, new Rectangle(0, 0, 10, 20) };
-                yield return new object[] { opaque, new Rectangle(0, 0, 10, 20), invalidateChildren, new Rectangle(0, 0, 10, 20) };
-                yield return new object[] { opaque, new Rectangle(1, 2, 3, 4), invalidateChildren, new Rectangle(1, 2, 3, 4) };
-                yield return new object[] { opaque, new Rectangle(5, 10, 5, 10), invalidateChildren, new Rectangle(5, 10, 5, 10) };
-                yield return new object[] { opaque, new Rectangle(100, 200, 300, 400), invalidateChildren, new Rectangle(100, 200, 300, 400) };
-                yield return new object[] { opaque, new Rectangle(-100, -200, -300, -400), invalidateChildren, new Rectangle(-100, -200, -300, -400) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_Bool_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRectangleBoolWithHandle_Success(bool opaque, Rectangle rc, bool invalidateChildren, Rectangle expectedInvalidRect)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate(rc, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate(rc, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_Bool_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRectangleBoolWithChildrenWithHandle_Success(bool opaque, Rectangle rc, bool invalidateChildren, Rectangle expectedInvalidRect)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate(rc, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate(rc, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Region_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { opaque, null };
-            yield return new object[] { opaque, new Region(new Rectangle(0, 0, 10, 20)) };
-            yield return new object[] { opaque, new Region(new Rectangle(1, 2, 3, 4)) };
-            yield return new object[] { opaque, new Region(new Rectangle(5, 10, 5, 10)) };
-            yield return new object[] { opaque, new Region(new Rectangle(100, 200, 300, 400)) };
-            yield return new object[] { opaque, new Region(new Rectangle(-100, -200, -300, -400)) };
-            yield return new object[] { opaque, new Region() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_TestData))]
-    public void Control_Invalidate_InvokeRegion_Success(bool opaque, Region region)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate(region);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate(region);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Region_WithHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { opaque, null, new Rectangle(0, 0, 10, 20) };
-            yield return new object[] { opaque, new Region(new Rectangle(0, 0, 10, 20)), new Rectangle(0, 0, 10, 20) };
-            yield return new object[] { opaque, new Region(new Rectangle(1, 2, 3, 4)), new Rectangle(1, 2, 3, 4) };
-            yield return new object[] { opaque, new Region(new Rectangle(5, 10, 5, 10)), new Rectangle(5, 10, 5, 10) };
-            yield return new object[] { opaque, new Region(new Rectangle(100, 200, 300, 400)), new Rectangle(100, 200, 300, 400) };
-            yield return new object[] { opaque, new Region(new Rectangle(-100, -200, -300, -400)), new Rectangle(-100, -200, -300, -400) };
-            yield return new object[] { opaque, new Region(), new Rectangle(-4194304, -4194304, 8388608, 8388608) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRegionWithHandle_Success(bool opaque, Region region, Rectangle expectedInvalidRect)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate(region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate(region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRegionWithChildrenWithHandle_Success(bool opaque, Region region, Rectangle expectedInvalidRect)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate(region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate(region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Region_Bool_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            foreach (bool invalidateChildren in new bool[] { true, false })
-            {
-                yield return new object[] { opaque, null, invalidateChildren };
-                yield return new object[] { opaque, new Region(new Rectangle(0, 0, 10, 20)), invalidateChildren };
-                yield return new object[] { opaque, new Region(new Rectangle(1, 2, 3, 4)), invalidateChildren };
-                yield return new object[] { opaque, new Region(new Rectangle(5, 10, 5, 10)), invalidateChildren };
-                yield return new object[] { opaque, new Region(new Rectangle(100, 200, 300, 400)), invalidateChildren };
-                yield return new object[] { opaque, new Region(new Rectangle(-100, -200, -300, -400)), invalidateChildren };
-                yield return new object[] { opaque, new Region(), invalidateChildren };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_Bool_TestData))]
-    public void Control_Invalidate_InvokeRegionBool_Success(bool opaque, Region region, bool invalidateChildren)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        control.Invalidate(region, invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-
-        control.Invalidate(region, invalidateChildren);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Region_Bool_WithHandle_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            foreach (bool invalidateChildren in new bool[] { true, false })
-            {
-                yield return new object[] { opaque, null, invalidateChildren, new Rectangle(0, 0, 10, 20) };
-                yield return new object[] { opaque, new Region(new Rectangle(0, 0, 10, 20)), invalidateChildren, new Rectangle(0, 0, 10, 20) };
-                yield return new object[] { opaque, new Region(new Rectangle(1, 2, 3, 4)), invalidateChildren, new Rectangle(1, 2, 3, 4) };
-                yield return new object[] { opaque, new Region(new Rectangle(5, 10, 5, 10)), invalidateChildren, new Rectangle(5, 10, 5, 10) };
-                yield return new object[] { opaque, new Region(new Rectangle(100, 200, 300, 400)), invalidateChildren, new Rectangle(100, 200, 300, 400) };
-                yield return new object[] { opaque, new Region(new Rectangle(-100, -200, -300, -400)), invalidateChildren, new Rectangle(-100, -200, -300, -400) };
-                yield return new object[] { opaque, new Region(), invalidateChildren, new Rectangle(-4194304, -4194304, 8388608, 8388608) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_Bool_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRegionBoolWithHandle_Success(bool opaque, Region region, bool invalidateChildren, Rectangle expectedInvalidRect)
-    {
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Invalidate(region, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Invalidate(region, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Region_Bool_WithHandle_TestData))]
-    public void Control_Invalidate_InvokeRegionBoolWithChildrenWithHandle_Success(bool opaque, Region region, bool invalidateChildren, Rectangle expectedInvalidRect)
-    {
-        using var child = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        using var control = new SubControl
-        {
-            Size = new Size(10, 20)
-        };
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        control.Controls.Add(child);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedInvalidRect, e.InvalidRect);
-            invalidatedCallCount++;
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int childInvalidatedCallCount = 0;
-        child.Invalidated += (sender, e) => childInvalidatedCallCount++;
-        int childStyleChangedCallCount = 0;
-        child.StyleChanged += (sender, e) => childStyleChangedCallCount++;
-        int childCreatedCallCount = 0;
-        child.HandleCreated += (sender, e) => childCreatedCallCount++;
-
-        control.Invalidate(region, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-
-        // Call again.
-        control.Invalidate(region, invalidateChildren);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child.IsHandleCreated);
-        Assert.Equal(0, childInvalidatedCallCount);
-        Assert.Equal(0, childStyleChangedCallCount);
-        Assert.Equal(0, childCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokeDelegateSameThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action method = () =>
-        {
-            callCount++;
-        };
-        control.Invoke(method);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokeDelegateThrowsExceptionSameThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action method = () =>
-        {
-            callCount++;
-            throw new DivideByZeroException();
-        };
-        Assert.Throws<DivideByZeroException>(() => control.Invoke(method));
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public async Task Control_InvokeDelegateThrowsExceptionDifferentThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action method = () =>
-        {
-            callCount++;
-            throw new DivideByZeroException();
-        };
-        await Task.Run(() =>
-        {
-            Assert.Throws<DivideByZeroException>(() => control.Invoke(method));
-        });
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_Action_calls_correct_method()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        DivideByZeroException exception = Assert.Throws<DivideByZeroException>(() => control.Invoke(() => FaultingMethod()));
-
-        /*
-        Expecting something like the following.
-        The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-            at System.Windows.Forms.Tests.ControlTests.<Control_Invoke_Action_calls_correct_method>g__FaultingMethod|410_1() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3902
-               at System.Windows.Forms.Tests.ControlTests.<>c.<Control_Invoke_Action_calls_correct_method>b__410_2() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3877
-               at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6515
-               at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6487
-               at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6459
-               at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6563
-            --- End of stack trace from previous location ---
-               at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6951
-               at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6413
-               at System.Windows.Forms.Control.Invoke(Action method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6376
-               at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass410_0.<Control_Invoke_Action_calls_correct_method>b__0() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3877
-               at Xunit.Assert.RecordException(Action testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 27
-        */
-        Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-        Assert.Contains(" System.Windows.Forms.Control.Invoke(Action method) ", exception.StackTrace);
-
-        static void FaultingMethod()
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_Delegate_Func_calls_correct_method()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        DivideByZeroException exception = Assert.Throws<DivideByZeroException>(() =>
-        {
-            int result = (int)control.Invoke((Delegate)(new Func<float>(() => FaultingMethod(10))));
-        });
-
-        /*
-        Expecting something like the following.
-        The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-            at System.Windows.Forms.Tests.ControlTests.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>g__FaultingMethod|412_1() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3945
-                at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6400
-                at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6376
-                at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6348
-                at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6448
-            --- End of stack trace from previous location ---
-                at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6829
-                at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6310
-                at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6290
-                at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass412_0.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>b__0() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3915
-                at Xunit.Assert.RecordException(Func`1 testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 50
-        */
-        Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-        Assert.Contains(" System.Windows.Forms.Control.Invoke(Delegate method) ", exception.StackTrace);
-
-        static int FaultingMethod(int a)
-        {
-            return a / 0;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_Delegate_MethodInvoker_calls_correct_method()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        DivideByZeroException exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod));
-
-        /*
-        Expecting something like the following.
-        The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-            at System.Windows.Forms.Tests.ControlTests.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>g__FaultingMethod|412_1() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3945
-                at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6400
-                at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6376
-                at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6348
-                at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6448
-            --- End of stack trace from previous location ---
-                at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6829
-                at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6310
-                at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6290
-                at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass412_0.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>b__0() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3915
-                at Xunit.Assert.RecordException(Func`1 testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 50
-        */
-        Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-        Assert.Contains(" System.Windows.Forms.Control.Invoke(Delegate method) ", exception.StackTrace);
-
-        static void FaultingMethod()
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_Func_calls_correct_method()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        DivideByZeroException exception = Assert.Throws<DivideByZeroException>(() =>
-        {
-            int result = control.Invoke(() => FaultingMethod(10));
-        });
-
-        /*
-        Expecting something like the following.
-        The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-            at System.Windows.Forms.Tests.ControlTests.<Control_Invoke_Func_calls_correct_method>g__FaultingMethod|412_1(Int32 a) in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3976
-               at System.Windows.Forms.Tests.ControlTests.<>c.<Control_Invoke_Func_calls_correct_method>b__412_2() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3950
-            --- End of stack trace from previous location ---
-               at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6951
-               at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6413
-               at System.Windows.Forms.Control.Invoke[T](Func`1 method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6422
-               at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass412_0.<Control_Invoke_Func_calls_correct_method>b__0() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3950
-               at Xunit.Assert.RecordException(Action testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 27
-        */
-        Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-        Assert.Contains(" System.Windows.Forms.Control.Invoke[T](Func`1 method) ", exception.StackTrace);
-
-        static int FaultingMethod(int a)
-        {
-            return a / 0;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_InvokeDelegateObjectSameThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action<int> method = (i) =>
-        {
-            Assert.Equal(1, i);
-            callCount++;
-        };
-        control.Invoke(method, new object[] { 1 });
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokeDelegateObjectThrowsExceptionSameThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action<int> method = (i) =>
-        {
-            Assert.Equal(1, i);
-            callCount++;
-            throw new DivideByZeroException();
-        };
-        Assert.Throws<DivideByZeroException>(() => control.Invoke(method, new object[] { 1 }));
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        var exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod));
-
-        /*
-
-        Expecting something like the following.
-        The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-                at System.Windows.Forms.Tests.ControlTests.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>g__FaultingMethod|412_1() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3945
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6400
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6376
-                       at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6348
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6448
-                    --- End of stack trace from previous location ---
-                       at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6829
-                       at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6310
-                       at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6290
-                       at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass412_0.<Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace>b__0() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3915
-                       at Xunit.Assert.RecordException(Func`1 testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 50
-
-        */
-        Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-        Assert.Contains(nameof(Control_InvokeDelegateObjectThrowsExceptionSameThread_VerifyStackTrace), exception.StackTrace);
-
-        static void FaultingMethod()
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [WinFormsFact]
-    public async Task Control_InvokeDelegateObjectThrowsExceptionDifferentThread_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        Action<int> method = (param) =>
-        {
-            Assert.Equal(1, param);
-            callCount++;
-            throw new DivideByZeroException();
-        };
-        await Task.Run(() =>
-        {
-            Assert.Throws<DivideByZeroException>(() => control.Invoke(method, new object[] { 1 }));
-        });
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public async Task Control_InvokeDelegateObjectThrowsExceptionDifferentThread_VerifyStackTrace()
-    {
-        using var control = new Control();
-        control.CreateControl();
-
-        await Task.Run(() =>
-        {
-            var exception = Assert.Throws<DivideByZeroException>(() => control.Invoke((MethodInvoker)FaultingMethod));
-
-            /*
-
-            Expecting something like the following.
-            The first frame must be the this method, followed by MarshaledInvoke at previous location.
-
-                at System.Windows.Forms.Tests.ControlTests.<Control_InvokeDelegateObjectThrowsExceptionDifferentThread_VerifyStackTrace>g__FaultingMethod|413_1() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3969
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6400
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6367
-                       at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
-                    --- End of stack trace from previous location ---
-                       at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
-                       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
-                       at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6344
-                       at System.Windows.Forms.Control.InvokeMarshaledCallbacks() in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6448
-                    --- End of stack trace from previous location ---
-                       at System.Windows.Forms.Control.MarshaledInvoke(Control caller, Delegate method, Object[] args, Boolean synchronous) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6829
-                       at System.Windows.Forms.Control.Invoke(Delegate method, Object[] args) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6310
-                       at System.Windows.Forms.Control.Invoke(Delegate method) in ...\winforms\src\System.Windows.Forms\src\System\Windows\Forms\Control.cs:line 6290
-                       at System.Windows.Forms.Tests.ControlTests.<>c__DisplayClass413_0.<Control_InvokeDelegateObjectThrowsExceptionDifferentThread_VerifyStackTrace>b__2() in ...\winforms\src\System.Windows.Forms\tests\UnitTests\System\Windows\Forms\ControlTests.Methods.cs:line 3947
-                       at Xunit.Assert.RecordException(Func`1 testCode) in C:\Dev\xunit\xunit\src\xunit.assert\Asserts\Record.cs:line 50
-
-            */
-            Assert.Contains(nameof(FaultingMethod), exception.StackTrace);
-            Assert.Contains(nameof(Control_InvokeDelegateObjectThrowsExceptionDifferentThread_VerifyStackTrace), exception.StackTrace);
-        });
-
-        static void FaultingMethod()
-        {
-            throw new DivideByZeroException();
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_InvokeWithoutHandle_ThrowsInvalidOperationException()
-    {
-        using var control = new Control();
-        Action method = () => { };
-        Assert.Throws<InvalidOperationException>(() => control.Invoke(method));
-        Assert.Throws<InvalidOperationException>(() => control.Invoke(method, Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void Control_Invoke_InvokeInvalidParameters_ThrowsTargetParameterCountException()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Action<int> method = (i) => { };
-        Assert.Throws<TargetParameterCountException>(() => control.Invoke(method));
-        Assert.Throws<TargetParameterCountException>(() => control.Invoke(method, null));
-        Assert.Throws<TargetParameterCountException>(() => control.Invoke(method, Array.Empty<object>()));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_InvokeGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var otherControl = new Control();
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int otherCallCount = 0;
-        EventHandler otherHandler = (sender, e) =>
-        {
-            Assert.Same(otherControl, sender);
-            Assert.Same(eventArgs, e);
-            otherCallCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        otherControl.GotFocus += otherHandler;
-        control.InvokeGotFocus(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-
-        control.InvokeGotFocus(null, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        otherControl.GotFocus -= otherHandler;
-        control.InvokeGotFocus(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Control_InvokeLostFocus_Invoke_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var otherControl = new SubControl();
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int otherCallCount = 0;
-        EventHandler otherHandler = (sender, e) =>
-        {
-            Assert.Same(otherControl, sender);
-            Assert.Same(eventArgs, e);
-            otherCallCount++;
-        };
-
-        // Call with handler.
-        control.LostFocus += handler;
-        otherControl.LostFocus += otherHandler;
-        control.InvokeLostFocus(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-
-        control.InvokeLostFocus(null, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        otherControl.LostFocus -= otherHandler;
-        control.InvokeLostFocus(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void Control_InvokePaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var otherControl = new SubControl();
-        using var control = new SubControl();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) => callCount++;
-        int otherCallCount = 0;
-        PaintEventHandler otherHandler = (sender, e) =>
-        {
-            Assert.Same(otherControl, sender);
-            Assert.Same(eventArgs, e);
-            otherCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        otherControl.Paint += otherHandler;
-        control.InvokePaint(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        otherControl.Paint -= otherHandler;
-        control.InvokePaint(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, otherCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokePaint_NullToInvoke_ThrowsNullReferenceException()
-    {
-        using var control = new SubControl();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-        Assert.Throws<NullReferenceException>(() => control.InvokePaint(null, eventArgs));
-    }
-
-    [WinFormsFact]
-    public void Control_InvokePaintBackground_Invoke_CallsPaint()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var otherControlParent = new Control();
-        using var otherControl = new SubControl
-        {
-            Parent = otherControlParent
-        };
-        otherControl.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        otherControl.BackColor = Color.FromArgb(100, 50, 100, 150);
-        using var control = new SubControl();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) => callCount++;
-        int otherCallCount = 0;
-        PaintEventHandler otherHandler = (sender, e) => otherCallCount++;
-        int otherParentCallCount = 0;
-        PaintEventHandler otherParentHandler = (sender, e) =>
-        {
-            Assert.Same(otherControlParent, sender);
-            Assert.NotSame(eventArgs, e);
-            otherParentCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        otherControl.Paint += otherHandler;
-        otherControlParent.Paint += otherParentHandler;
-        control.InvokePaintBackground(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, otherCallCount);
-        Assert.Equal(1, otherParentCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        otherControl.Paint -= otherHandler;
-        otherControlParent.Paint -= otherParentHandler;
-        control.InvokePaintBackground(otherControl, eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, otherCallCount);
-        Assert.Equal(1, otherParentCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_InvokePaintBackground_NullToInvoke_ThrowsNullReferenceException()
-    {
-        using var control = new SubControl();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-        Assert.Throws<NullReferenceException>(() => control.InvokePaintBackground(null, eventArgs));
-    }
-
-    [WinFormsFact]
-    public void Control_InvokePaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var otherControl = new Control();
-        using var control = new SubControl();
-        Assert.Throws<ArgumentNullException>(() => control.InvokePaintBackground(otherControl, null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    public void Control_IsInputChar_InvokeWithoutHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.Equal(expected, control.IsInputChar((char)keyData));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    public void Control_IsInputChar_InvokeWithHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.IsInputChar((char)keyData));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> IsInputKey_TestData()
-    {
-        yield return new object[] { Keys.Tab, false };
-        yield return new object[] { Keys.Up, false };
-        yield return new object[] { Keys.Down, false };
-        yield return new object[] { Keys.Left, false };
-        yield return new object[] { Keys.Right, false };
-        yield return new object[] { Keys.Return, false };
-        yield return new object[] { Keys.Escape, false };
-        yield return new object[] { Keys.A, false };
-        yield return new object[] { Keys.C, false };
-        yield return new object[] { Keys.Insert, false };
-        yield return new object[] { Keys.Space, false };
-        yield return new object[] { Keys.Home, false };
-        yield return new object[] { Keys.End, false };
-        yield return new object[] { Keys.Back, false };
-        yield return new object[] { Keys.Next, false };
-        yield return new object[] { Keys.Prior, false };
-        yield return new object[] { Keys.Delete, false };
-        yield return new object[] { Keys.D0, false };
-        yield return new object[] { Keys.NumPad0, false };
-        yield return new object[] { Keys.F1, false };
-        yield return new object[] { Keys.F2, false };
-        yield return new object[] { Keys.F3, false };
-        yield return new object[] { Keys.F4, false };
-        yield return new object[] { Keys.F10, false };
-        yield return new object[] { Keys.RButton, false };
-        yield return new object[] { Keys.PageUp, false };
-        yield return new object[] { Keys.PageDown, false };
-        yield return new object[] { Keys.Menu, false };
-        yield return new object[] { Keys.None, false };
-
-        yield return new object[] { Keys.Control | Keys.Tab, false };
-        yield return new object[] { Keys.Control | Keys.Up, false };
-        yield return new object[] { Keys.Control | Keys.Down, false };
-        yield return new object[] { Keys.Control | Keys.Left, false };
-        yield return new object[] { Keys.Control | Keys.Right, false };
-        yield return new object[] { Keys.Control | Keys.Return, false };
-        yield return new object[] { Keys.Control | Keys.Escape, false };
-        yield return new object[] { Keys.Control | Keys.A, false };
-        yield return new object[] { Keys.Control | Keys.C, false };
-        yield return new object[] { Keys.Control | Keys.Insert, false };
-        yield return new object[] { Keys.Control | Keys.Space, false };
-        yield return new object[] { Keys.Control | Keys.Home, false };
-        yield return new object[] { Keys.Control | Keys.End, false };
-        yield return new object[] { Keys.Control | Keys.Back, false };
-        yield return new object[] { Keys.Control | Keys.Next, false };
-        yield return new object[] { Keys.Control | Keys.Prior, false };
-        yield return new object[] { Keys.Control | Keys.Delete, false };
-        yield return new object[] { Keys.Control | Keys.D0, false };
-        yield return new object[] { Keys.Control | Keys.NumPad0, false };
-        yield return new object[] { Keys.Control | Keys.F1, false };
-        yield return new object[] { Keys.Control | Keys.F2, false };
-        yield return new object[] { Keys.Control | Keys.F3, false };
-        yield return new object[] { Keys.Control | Keys.F4, false };
-        yield return new object[] { Keys.Control | Keys.F10, false };
-        yield return new object[] { Keys.Control | Keys.RButton, false };
-        yield return new object[] { Keys.Control | Keys.PageUp, false };
-        yield return new object[] { Keys.Control | Keys.PageDown, false };
-        yield return new object[] { Keys.Control | Keys.Menu, false };
-        yield return new object[] { Keys.Control | Keys.None, false };
-
-        yield return new object[] { Keys.Alt | Keys.Tab, false };
-        yield return new object[] { Keys.Alt | Keys.Up, false };
-        yield return new object[] { Keys.Alt | Keys.Down, false };
-        yield return new object[] { Keys.Alt | Keys.Left, false };
-        yield return new object[] { Keys.Alt | Keys.Right, false };
-        yield return new object[] { Keys.Alt | Keys.Return, false };
-        yield return new object[] { Keys.Alt | Keys.Escape, false };
-        yield return new object[] { Keys.Alt | Keys.A, false };
-        yield return new object[] { Keys.Alt | Keys.C, false };
-        yield return new object[] { Keys.Alt | Keys.Insert, false };
-        yield return new object[] { Keys.Alt | Keys.Space, false };
-        yield return new object[] { Keys.Alt | Keys.Home, false };
-        yield return new object[] { Keys.Alt | Keys.End, false };
-        yield return new object[] { Keys.Alt | Keys.Back, false };
-        yield return new object[] { Keys.Alt | Keys.Next, false };
-        yield return new object[] { Keys.Alt | Keys.Prior, false };
-        yield return new object[] { Keys.Alt | Keys.Delete, false };
-        yield return new object[] { Keys.Alt | Keys.D0, false };
-        yield return new object[] { Keys.Alt | Keys.NumPad0, false };
-        yield return new object[] { Keys.Alt | Keys.F1, false };
-        yield return new object[] { Keys.Alt | Keys.F2, false };
-        yield return new object[] { Keys.Alt | Keys.F3, false };
-        yield return new object[] { Keys.Alt | Keys.F4, false };
-        yield return new object[] { Keys.Alt | Keys.F10, false };
-        yield return new object[] { Keys.Alt | Keys.RButton, false };
-        yield return new object[] { Keys.Alt | Keys.PageUp, false };
-        yield return new object[] { Keys.Alt | Keys.PageDown, false };
-        yield return new object[] { Keys.Alt | Keys.Menu, false };
-        yield return new object[] { Keys.Alt | Keys.None, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    public void Control_IsInputKey_InvokeWithoutHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    public void Control_IsInputKey_InvokeWithHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> IsMnemonic_TestData()
-    {
-        yield return new object[] { '&', null, false };
-        yield return new object[] { '&', "", false };
-        yield return new object[] { '&', "text", false };
-        yield return new object[] { '&', "&", false };
-        yield return new object[] { 'a', null, false };
-        yield return new object[] { 'a', "", false };
-        yield return new object[] { 'a', "text", false };
-        yield return new object[] { 'a', "a", false };
-        yield return new object[] { 'a', "&", false };
-        yield return new object[] { 'a', "&a", true };
-        yield return new object[] { 'A', "&a", true };
-        yield return new object[] { 'a', "&A", true };
-        yield return new object[] { 'A', "&A", true };
-        yield return new object[] { 'a', "&&a", false };
-        yield return new object[] { 'a', "a&a", true };
-        yield return new object[] { 'a', "a&ab", true };
-        yield return new object[] { 'a', "a&b", false };
-        yield return new object[] { 'a', "a&ba", false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsMnemonic_TestData))]
-    public void Control_IsMnemonic_Invoke_ReturnsExpected(char charCode, string text, bool expected)
-    {
-        Assert.Equal(expected, Control.IsMnemonic(charCode, text));
-    }
-
-    public static IEnumerable<object[]> NotifyInvalidated_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyInvalidated_TestData))]
-    public void Control_NotifyInvalidate_Invoke_CallsInvalidated(Rectangle invalidatedArea)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(invalidatedArea, e.InvalidRect);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> NotifyInvalidate_WithChildren_TestData()
-    {
-        yield return new object[] { true, Color.Empty, null };
-        yield return new object[] { true, Color.Empty, Rectangle.Empty };
-        yield return new object[] { true, Color.Empty, new Rectangle(100, 200, 300, 400) };
-        yield return new object[] { true, Color.Empty, new Rectangle(1, 2, 300, 400) };
-        yield return new object[] { true, Color.Red, null };
-        yield return new object[] { true, Color.Red, Rectangle.Empty };
-        yield return new object[] { true, Color.Red, new Rectangle(100, 200, 300, 400) };
-        yield return new object[] { true, Color.Red, new Rectangle(1, 2, 300, 400) };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), null };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), Rectangle.Empty };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new Rectangle(100, 200, 300, 400) };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new Rectangle(1, 2, 300, 400) };
-
-        yield return new object[] { false, Color.Empty, null };
-        yield return new object[] { false, Color.Empty, Rectangle.Empty };
-        yield return new object[] { false, Color.Empty, new Rectangle(100, 200, 300, 400) };
-        yield return new object[] { false, Color.Empty, new Rectangle(1, 2, 300, 400) };
-        yield return new object[] { false, Color.Red, null };
-        yield return new object[] { false, Color.Red, Rectangle.Empty };
-        yield return new object[] { false, Color.Red, new Rectangle(100, 200, 300, 400) };
-        yield return new object[] { false, Color.Red, new Rectangle(1, 2, 300, 400) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyInvalidate_WithChildren_TestData))]
-    public void Control_NotifyInvalidate_InvokeWithChildren_CallsInvalidated(bool supportsTransparentBackgroundColor, Color backColor, Rectangle invalidatedArea)
-    {
-        using var child1 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var child2 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        child1.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child1.BackColor = backColor;
-        child2.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child2.BackColor = backColor;
-
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(invalidatedArea, e.InvalidRect);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyInvalidated_TestData))]
-    public void Control_NotifyInvalidate_InvokeWithHandle_CallsInvalidated(Rectangle invalidatedArea)
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(invalidatedArea, e.InvalidRect);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> NotifyInvalidate_WithChildrenWithHandle_TestData()
-    {
-        yield return new object[] { true, Color.Empty, Rectangle.Empty, 0 };
-        yield return new object[] { true, Color.Empty, new Rectangle(100, 200, 300, 400), 0 };
-        yield return new object[] { true, Color.Empty, new Rectangle(1, 2, 300, 400), 0 };
-        yield return new object[] { true, Color.Red, Rectangle.Empty, 0 };
-        yield return new object[] { true, Color.Red, new Rectangle(100, 200, 300, 400), 0 };
-        yield return new object[] { true, Color.Red, new Rectangle(1, 2, 300, 400), 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), Rectangle.Empty, 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new Rectangle(100, 200, 300, 400), 0 };
-        yield return new object[] { true, Color.FromArgb(200, 50, 100, 150), new Rectangle(1, 2, 300, 400), 1 };
-
-        yield return new object[] { false, Color.Empty, Rectangle.Empty, 0 };
-        yield return new object[] { false, Color.Empty, new Rectangle(100, 200, 300, 400), 0 };
-        yield return new object[] { false, Color.Empty, new Rectangle(1, 2, 300, 400), 0 };
-        yield return new object[] { false, Color.Red, Rectangle.Empty, 0 };
-        yield return new object[] { false, Color.Red, new Rectangle(100, 200, 300, 400), 0 };
-        yield return new object[] { false, Color.Red, new Rectangle(1, 2, 300, 400), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NotifyInvalidate_WithChildrenWithHandle_TestData))]
-    public void Control_NotifyInvalidate_InvokeWithChildrenWithHandle_CallsInvalidated(bool supportsTransparentBackgroundColor, Color backColor, Rectangle invalidatedArea, int expectedChildInvalidatedCallCount)
-    {
-        using var child1 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var child2 = new SubControl
-        {
-            ClientSize = new Size(10, 20)
-        };
-        using var control = new SubControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        child1.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child1.BackColor = backColor;
-        child2.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-        child2.BackColor = backColor;
-
-        int callCount = 0;
-        InvalidateEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(invalidatedArea, e.InvalidRect);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int invalidatedCallCount1 = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount1++;
-        int invalidatedCallCount2 = 0;
-        child2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        child2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        child2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        // Call with handler.
-        control.Invalidated += handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount, invalidatedCallCount1);
-        Assert.Equal(0, styleChangedCallCount1);
-        Assert.Equal(0, createdCallCount1);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount, invalidatedCallCount2);
-        Assert.Equal(0, styleChangedCallCount2);
-        Assert.Equal(0, createdCallCount2);
-
-        // Remove handler.
-        control.Invalidated -= handler;
-        control.NotifyInvalidate(invalidatedArea);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount * 2, invalidatedCallCount1);
-        Assert.Equal(0, styleChangedCallCount1);
-        Assert.Equal(0, createdCallCount1);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(expectedChildInvalidatedCallCount * 2, invalidatedCallCount2);
-        Assert.Equal(0, styleChangedCallCount2);
-        Assert.Equal(0, createdCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_Invoke_Success()
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.PerformLayout();
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout();
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeCustomLayoutEngine_Success()
-    {
-        using var control = new CustomLayoutEngineControl();
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.Layout(control, It.IsAny<LayoutEventArgs>()))
-            .Returns(false)
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.PerformLayout();
-        Assert.Equal(1, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Once());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout();
-        Assert.Equal(2, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeWithParent_Success()
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.PerformLayout();
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout();
-        Assert.Equal(2, layoutCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_PerformLayout_InvokeWithParentCustomLayoutEngine_Success(bool parentNeedsLayout, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new CustomLayoutEngineControl
-        {
-            Parent = parent
-        };
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.Layout(control, It.IsAny<LayoutEventArgs>()))
-            .Returns(parentNeedsLayout)
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("PreferredSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.PerformLayout();
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Once());
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout();
-        Assert.Equal(2, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_PerformLayout_InvokeSuspended_DoesNotCallLayout(bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout();
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        control.PerformLayout();
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_PerformLayout_InvokeSuspendedMultipleTimes_DoesNotCallLayout(bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(new Control(), "OtherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(new Control(), "OtherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout();
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        control.PerformLayout();
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeSetTextInLayout_CachesText()
-    {
-        using var control = new Control();
-
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            string longString = new('a', 65536);
-            control.Text = longString;
-            Assert.Equal(longString, control.Text);
-            layoutCallCount++;
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Empty(control.Text);
-        control.PerformLayout();
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeInDisposing_DoesNotCallLayout()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        control.Layout += (sender, e) => callCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.PerformLayout();
-            Assert.Equal(0, callCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    public static IEnumerable<object[]> PerformLayout_Control_String_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new Control(), string.Empty };
-        yield return new object[] { new Control(), "AffectedProperty" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_TestData))]
-    public void Control_PerformLayout_InvokeControlString_Success(Control affectedControl, string affectedProperty)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_TestData))]
-    public void Control_PerformLayout_InvokeControlStringCustomLayoutEngine_Success(Control affectedControl, string affectedProperty)
-    {
-        using var control = new CustomLayoutEngineControl();
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.Layout(control, It.IsAny<LayoutEventArgs>()))
-            .Returns(false)
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(1, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Once());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(2, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_TestData))]
-    public void Control_PerformLayout_InvokeControlStringWithParent_Success(Control affectedControl, string affectedProperty)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(2, layoutCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PerformLayout_Control_String_WithParent_TestData()
-    {
-        yield return new object[] { true, null, null, 1 };
-        yield return new object[] { true, new Control(), string.Empty, 1 };
-        yield return new object[] { true, new Control(), "AffectedProperty", 1 };
-
-        yield return new object[] { false, null, null, 0 };
-        yield return new object[] { false, new Control(), string.Empty, 0 };
-        yield return new object[] { false, new Control(), "AffectedProperty", 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_WithParent_TestData))]
-    public void Control_PerformLayout_InvokeControlStringWithParentCustomLayoutEngine_Success(bool parentNeedsLayout, Control affectedControl, string affectedProperty, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new CustomLayoutEngineControl
-        {
-            Parent = parent
-        };
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.Layout(control, It.IsAny<LayoutEventArgs>()))
-            .Returns(parentNeedsLayout)
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("PreferredSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Once());
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(2, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-        mockLayoutEngine.Verify(e => e.Layout(control, It.IsAny<LayoutEventArgs>()), Times.Exactly(2));
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> PerformLayout_Control_String_Suspended_TestData()
-    {
-        yield return new object[] { true, null, null, 1 };
-        yield return new object[] { true, new Control(), string.Empty, 1 };
-        yield return new object[] { true, new Control(), "AffectedProperty", 1 };
-
-        yield return new object[] { false, null, null, 0 };
-        yield return new object[] { false, new Control(), string.Empty, 0 };
-        yield return new object[] { false, new Control(), "AffectedProperty", 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_Suspended_TestData))]
-    public void Control_PerformLayout_InvokeControlStringSuspended_DoesNotCallLayout(bool performLayout, Control affectedControl, string affectedProperty, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformLayout_Control_String_Suspended_TestData))]
-    public void Control_PerformLayout_InvokeControlStringSuspendedMultipleTimes_DoesNotCallLayout(bool performLayout, Control affectedControl, string affectedProperty, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(new Control(), "OtherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(new Control(), "OtherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-
-        // Resume again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeControlStringSetTextInLayout_CachesText()
-    {
-        using var control = new Control();
-
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            string longString = new('a', 65536);
-            control.Text = longString;
-            Assert.Equal(longString, control.Text);
-            layoutCallCount++;
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Empty(control.Text);
-        control.PerformLayout(control, "AffectedProperty");
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_InvokeControlStringInDisposing_DoesNotCallLayout()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        control.Layout += (sender, e) => callCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.PerformLayout(new Control(), "AffectedProperty");
-            Assert.Equal(0, callCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_PerformLayout_NullLayoutEngine_ThrowsNullReferenceException()
-    {
-        using var control = new CustomLayoutEngineControl();
-        control.SetLayoutEngine(null);
-        Assert.Throws<NullReferenceException>(() => control.PerformLayout());
-        Assert.Throws<NullReferenceException>(() => control.PerformLayout(new Control(), "AffectedProperty"));
-    }
-
-    public static IEnumerable<object[]> PreProcessMessage_TestData()
-    {
-        yield return new object[] { 0, Keys.None, false };
-        yield return new object[] { 0, Keys.A, false };
-        yield return new object[] { 0, Keys.Tab, false };
-        yield return new object[] { 0, Keys.Menu, false };
-        yield return new object[] { 0, Keys.F10, false };
-
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.Tab, true };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.Menu, true };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.F10, true };
-
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.Tab, true };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.Menu, true };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.F10, true };
-
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.Tab, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.Menu, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.F10, false };
-
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.Tab, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.Menu, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.F10, false };
-
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.None, true };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.A, true };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.Tab, true };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.Menu, true };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.F10, true };
-
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.Tab, false };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.Menu, false };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.F10, false };
-
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.Tab, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.Menu, false };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.F10, false };
-
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.None, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.A, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.Tab, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.Menu, false };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.F10, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreProcessMessage_TestData))]
-    public void Control_PreProcessMessage_Invoke_ReturnsExpected(int windowMsg, Keys keys, bool expectedIsHandleCreated)
-    {
-        using var control = new SubControl();
-        var msg = new Message
-        {
-            Msg = windowMsg,
-            WParam = (IntPtr)keys
-        };
-        Assert.False(control.PreProcessMessage(ref msg));
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreProcessMessage_TestData))]
-    public void Control_PreProcessMessage_InvokeWithParent_ReturnsExpected(int windowMsg, Keys keys, bool expectedIsHandleCreated)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        var msg = new Message
-        {
-            Msg = windowMsg,
-            WParam = (IntPtr)keys
-        };
-        Assert.False(control.PreProcessMessage(ref msg));
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PreProcessMessage_CustomProcessCmdKeyParent_TestData()
-    {
-        yield return new object[] { 0, Keys.None, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, Keys.A, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.None, true, false, false, false, false, true, 1, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.None, false, true, false, false, false, false, 1, 1, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.None, false, false, true, false, false, true, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.None, false, false, false, false, false, false, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.A, true, false, false, false, false, true, 1, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.A, false, true, false, false, false, false, 1, 1, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.A, false, false, true, false, false, true, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYDOWN, Keys.A, false, false, false, false, false, false, 1, 1, 1, 0, 0 };
-
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.None, true, false, false, false, false, true, 1, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.None, false, true, false, false, false, false, 1, 1, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.None, false, false, true, false, false, true, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.None, false, false, false, false, false, false, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.A, true, false, false, false, false, true, 1, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.A, false, true, false, false, false, false, 1, 1, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.A, false, false, true, false, false, true, 1, 1, 1, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, Keys.A, false, false, false, false, false, false, 1, 1, 1, 0, 0 };
-
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.None, false, false, false, true, false, false, 0, 0, 0, 1, 0 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.None, false, false, false, true, true, false, 0, 0, 0, 1, 0 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.None, false, false, false, false, true, true, 0, 0, 0, 1, 1 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.None, false, false, false, false, false, false, 0, 0, 0, 1, 1 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.A, false, false, false, true, false, false, 0, 0, 0, 1, 0 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.A, false, false, false, true, true, false, 0, 0, 0, 1, 0 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.A, false, false, false, false, true, true, 0, 0, 0, 1, 1 };
-        yield return new object[] { (int)PInvoke.WM_CHAR, Keys.A, false, false, false, false, false, false, 0, 0, 0, 1, 1 };
-
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.None, false, false, false, true, false, false, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.None, false, false, false, true, true, true, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.None, false, false, false, false, true, true, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.None, false, false, false, false, false, false, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.A, false, false, false, true, false, false, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.A, false, false, false, true, true, true, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.A, false, false, false, false, true, true, 0, 0, 0, 0, 1 };
-        yield return new object[] { (int)PInvoke.WM_SYSCHAR, Keys.A, false, false, false, false, false, false, 0, 0, 0, 0, 1 };
-
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.None, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_KEYUP, Keys.A, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.None, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-        yield return new object[] { (int)PInvoke.WM_SYSKEYUP, Keys.A, false, false, false, false, false, false, 0, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreProcessMessage_CustomProcessCmdKeyParent_TestData))]
-    public void Control_PreProcessMessage_InvokeWithCustomParent_ReturnsExpected(int windowMsg, Keys keys, bool processCmdKeyResult, bool isInputKeyResult, bool processDialogKeyResult, bool isInputCharResult, bool processDialogCharResult, bool expectedResult, int expectedProcessCmdKeyCallCount, int expectedIsInputKeyCallCount, int expectedProcessDialogKeyCallCount, int expectedIsInputCharCallCount, int expectedProcessDialogCharCallCount)
-    {
-        int processCmdKeyCallCount = 0;
-        bool processCmdKeyAction(Message actualM, Keys actualKeyData)
-        {
-            Assert.Equal((IntPtr)keys, actualM.WParam);
-            Assert.Equal(keys, actualKeyData);
-            processCmdKeyCallCount++;
-            return processCmdKeyResult;
-        }
-
-        int isInputKeyCallCount = 0;
-        bool isInputKeyAction(Keys actualKeyData)
-        {
-            Assert.Equal(keys, actualKeyData);
-            isInputKeyCallCount++;
-            return isInputKeyResult;
-        }
-
-        int processDialogKeyCallCount = 0;
-        bool processDialogKeyAction(Keys actualKeyData)
-        {
-            Assert.Equal(keys, actualKeyData);
-            processDialogKeyCallCount++;
-            return processDialogKeyResult;
-        }
-
-        int isInputCharCallCount = 0;
-        bool isInputCharAction(char actualCharCode)
-        {
-            Assert.Equal((char)keys, actualCharCode);
-            isInputCharCallCount++;
-            return isInputCharResult;
-        }
-
-        int processDialogCharCallCount = 0;
-        bool processDialogCharAction(char actualCharCode)
-        {
-            Assert.Equal((char)keys, actualCharCode);
-            processDialogCharCallCount++;
-            return processDialogCharResult;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = processCmdKeyAction,
-            ProcessDialogKeyAction = processDialogKeyAction,
-            ProcessDialogCharAction = processDialogCharAction
-        };
-        using var control = new CustomIsInputControl
-        {
-            Parent = parent,
-            IsInputKeyAction = isInputKeyAction,
-            IsInputCharAction = isInputCharAction
-        };
-        var msg = new Message
-        {
-            Msg = windowMsg,
-            WParam = (IntPtr)keys
-        };
-        Assert.Equal(expectedResult, control.PreProcessMessage(ref msg));
-        Assert.Equal(expectedProcessCmdKeyCallCount, processCmdKeyCallCount);
-        Assert.Equal(expectedIsInputKeyCallCount, isInputKeyCallCount);
-        Assert.Equal(expectedProcessDialogKeyCallCount, processDialogKeyCallCount);
-        Assert.Equal(expectedIsInputCharCallCount, isInputCharCallCount);
-        Assert.Equal(expectedProcessDialogCharCallCount, processDialogCharCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomIsInputControl : Control
-    {
-        public Func<char, bool> IsInputCharAction { get; set; }
-
-        protected override bool IsInputChar(char charCode) => IsInputCharAction(charCode);
-
-        public Func<Keys, bool> IsInputKeyAction { get; set; }
-
-        protected override bool IsInputKey(Keys keyData) => IsInputKeyAction(keyData);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<char, bool> ProcessDialogCharAction { get; set; }
-
-        protected override bool ProcessDialogChar(char charCode) => ProcessDialogCharAction(charCode);
-
-        public Func<Keys, bool> ProcessDialogKeyAction { get; set; }
-
-        protected override bool ProcessDialogKey(Keys keyData) => ProcessDialogKeyAction(keyData);
-
-        public Func<Message, bool> ProcessKeyPreviewAction { get; set; }
-
-        protected override bool ProcessKeyPreview(ref Message m) => ProcessKeyPreviewAction(m);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void Control_ProcessCmdKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubControl();
-        var m = new Message();
-        Assert.False(control.ProcessCmdKey(ref m, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void Control_ProcessCmdKey_InvokeWithParent_ReturnsFalse(Keys keyData)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        var msg = new Message();
-        Assert.False(control.ProcessCmdKey(ref msg, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    public void Control_ProcessCmdKey_InvokeWithCustomParent_ReturnsExpected(Keys keyData, bool result)
-    {
-        using var control = new SubControl();
-        var msg = new Message
-        {
-            Msg = 1
-        };
-        int callCount = 0;
-        bool action(Message actualMsg, Keys actualKeyData)
-        {
-            Assert.Equal(1, actualMsg.Msg);
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = action
-        };
-        control.Parent = parent;
-
-        Assert.Equal(result, control.ProcessCmdKey(ref msg, keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a')]
-    public void Control_ProcessDialogChar_InvokeWithoutParent_ReturnsFalse(char charCode)
-    {
-        using var control = new SubControl();
-        Assert.False(control.ProcessDialogChar(charCode));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a')]
-    public void Control_ProcessDialogChar_InvokeWithParent_ReturnsFalse(char charCode)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.False(control.ProcessDialogChar(charCode));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a', true)]
-    [InlineData('a', false)]
-    public void Control_ProcessDialogChar_InvokeWithCustomParent_ReturnsExpected(char charCode, bool result)
-    {
-        int callCount = 0;
-        bool action(char actualKeyData)
-        {
-            Assert.Equal(charCode, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessDialogCharAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Equal(result, control.ProcessDialogChar(charCode));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void Control_ProcessDialogKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubControl();
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void Control_ProcessDialogKey_InvokeWithParent_ReturnsFalse(Keys keyData)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    public void Control_ProcessDialogKey_InvokeWithCustomParent_ReturnsExpected(Keys keyData, bool result)
-    {
-        int callCount = 0;
-        bool action(Keys actualKeyData)
-        {
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessDialogKeyAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Equal(result, control.ProcessDialogKey(keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ProcessKeyEventArgs_TestData()
-    {
-        foreach (bool handled in new bool[] { true, false })
-        {
-            yield return new object[] { (int)PInvoke.WM_CHAR, '2', handled, 1, 0, 0, (IntPtr)50 };
-            yield return new object[] { (int)PInvoke.WM_CHAR, '1', handled, 1, 0, 0, (IntPtr)49 };
-            yield return new object[] { (int)PInvoke.WM_SYSCHAR, '2', handled, 1, 0, 0, (IntPtr)50 };
-            yield return new object[] { (int)PInvoke.WM_SYSCHAR, '1', handled, 1, 0, 0, (IntPtr)49 };
-            yield return new object[] { (int)PInvoke.WM_IME_CHAR, '2', handled, 1, 0, 0, (IntPtr)50 };
-            yield return new object[] { (int)PInvoke.WM_IME_CHAR, '1', handled, 1, 0, 0, (IntPtr)49 };
-            yield return new object[] { (int)PInvoke.WM_KEYDOWN, '2', handled, 0, 1, 0, (IntPtr)2 };
-            yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, '2', handled, 0, 1, 0, (IntPtr)2 };
-            yield return new object[] { (int)PInvoke.WM_KEYUP, '2', handled, 0, 0, 1, (IntPtr)2 };
-            yield return new object[] { (int)PInvoke.WM_SYSKEYUP, '2', handled, 0, 0, 1, (IntPtr)2 };
-            yield return new object[] { 0, '2', handled, 0, 0, 1, (IntPtr)2 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyEventArgs_InvokeWithoutParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var control = new SubControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyEventArgs_InvokeWithParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyEventArgs_InvokeWithCustomParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        int callCount = 0;
-        bool action(Message m)
-        {
-            callCount++;
-            return true;
-        }
-
-        using var parent = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_CHAR)]
-    [InlineData((int)PInvoke.WM_SYSCHAR)]
-    public void Control_ProcessKeyEventArgs_InvokeCharAfterImeChar_Success(int msg)
-    {
-        using var control = new SubControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.KeyChar);
-            e.Handled = true;
-            keyPressCallCount++;
-        };
-        var charM = new Message
-        {
-            Msg = msg
-        };
-        var imeM = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_CHAR
-        };
-
-        // Char.
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Ime, Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(4, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(6, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_KEYDOWN)]
-    [InlineData((int)PInvoke.WM_SYSKEYDOWN)]
-    [InlineData((int)PInvoke.WM_KEYUP)]
-    [InlineData((int)PInvoke.WM_SYSKEYUP)]
-    public void Control_ProcessKeyEventArgs_InvokeNonCharAfterImeChar_Success(int msg)
-    {
-        using var control = new SubControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            e.Handled = true;
-            keyPressCallCount++;
-        };
-        int keyCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            e.Handled = true;
-            keyCallCount++;
-        };
-        control.KeyUp += (sender, e) =>
-        {
-            e.Handled = true;
-            keyCallCount++;
-        };
-        var charM = new Message
-        {
-            Msg = msg
-        };
-        var imeM = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_CHAR
-        };
-
-        // Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(0, keyPressCallCount);
-        Assert.Equal(1, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(1, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(2, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Ime, Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(4, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(5, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(6, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomProcessKeyEventArgsControl : Control
-    {
-        public Func<Message, bool> ProcessKeyEventArgsAction { get; set; }
-
-        protected override bool ProcessKeyEventArgs(ref Message m) => ProcessKeyEventArgsAction(m);
-
-        public new bool ProcessKeyMessage(ref Message m) => base.ProcessKeyMessage(ref m);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyMessage_InvokeWithoutParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var control = new SubControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyMessage(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyMessage_InvokeWithParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyMessage(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void Control_ProcessKeyMessage_InvokeWithCustomParent_ReturnsFalse(int msg, char newChar, bool handled, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        int callCount = 0;
-        bool action(Message m)
-        {
-            callCount++;
-            return true;
-        }
-
-        using var parent = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(2, e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)2
-        };
-        Assert.Equal(handled, control.ProcessKeyMessage(ref m));
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ProcessKeyMessage_InvokeWithCustomParentProcessKeyPreview_ReturnsExpected(bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessKeyPreviewAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(result, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ProcessKeyMessage_InvokeWithCustomProcessKeyEventArgs_ReturnsExpected(bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var control = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(result, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, true)]
-    [InlineData(true, false, 0, true)]
-    [InlineData(false, true, 1, true)]
-    [InlineData(false, false, 1, false)]
-    public void Control_ProcessKeyMessage_InvokeWithCustomParentProcessKeyPreviewCustomProcessKeyEventArgs_ReturnsExpected(bool parentResult, bool result, int expectedCallCount, bool expectedResult)
-    {
-        int parentCallCount = 0;
-        bool parentAction(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            parentCallCount++;
-            return parentResult;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessKeyPreviewAction = parentAction
-        };
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var control = new CustomProcessKeyEventArgsControl
-        {
-            Parent = parent,
-            ProcessKeyEventArgsAction = action
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(expectedResult, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, parentCallCount);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_ProcessKeyPreview_InvokeWithoutParent_ReturnsFalse()
-    {
-        using var control = new SubControl();
-        var m = new Message();
-        Assert.False(control.ProcessKeyPreview(ref m));
-    }
-
-    [WinFormsFact]
-    public void Control_ProcessKeyPreview_InvokeWithParent_ReturnsFalse()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        var m = new Message();
-        Assert.False(control.ProcessKeyPreview(ref m));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ProcessKeyPreview_InvokeWithCustomParent_ReturnsExpected(bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessKeyPreviewAction = action
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(result, control.ProcessKeyPreview(ref m));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a')]
-    [InlineData(char.MinValue)]
-    public void Control_ProcessMnemonic_Invoke_ReturnsFalse(char charCode)
-    {
-        using var control = new SubControl();
-        Assert.False(control.ProcessMnemonic(charCode));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_RecreateHandle_InvokeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        IntPtr handle1 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.True(control.IsHandleCreated);
-
-        control.RecreateHandle();
-        IntPtr handle2 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle1, handle2);
-        Assert.True(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        IntPtr handle3 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle3);
-        Assert.NotEqual(handle2, handle3);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_RecreateHandle_InvokeWithoutHandle_Nop()
-    {
-        using var control = new SubControl();
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_Refresh_InvokeWithoutHandle_Nop()
-    {
-        using var control = new Control();
-        control.Refresh();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Refresh();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_Refresh_InvokeWithHandle_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Refresh();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Refresh();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void Control_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubControl();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetBackColor_Invoke_Success()
-    {
-        using var control = new Control();
-
-        // Reset without value.
-        control.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-
-        // Reset with value.
-        control.BackColor = Color.Black;
-        control.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-
-        // Reset again.
-        control.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetBindings_Invoke_Success()
-    {
-        using var control = new SubControl();
-
-        // Reset without value.
-        control.ResetBindings();
-        Assert.Empty(control.DataBindings);
-
-        // Reset with value.
-        control.DataBindings.Add(new Binding("Text", new object(), "member"));
-        control.ResetBindings();
-        Assert.Empty(control.DataBindings);
-
-        // Reset again.
-        control.ResetBindings();
-        Assert.Empty(control.DataBindings);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetCursor_Invoke_Success()
-    {
-        using var control = new SubControl();
-        using var cursor = new Cursor((IntPtr)1);
-
-        // Reset without value.
-        control.ResetCursor();
-        Assert.Equal(control.DefaultCursor, control.Cursor);
-
-        // Reset with value.
-        control.Cursor = cursor;
-        control.ResetCursor();
-        Assert.Equal(control.DefaultCursor, control.Cursor);
-
-        // Reset again.
-        control.ResetCursor();
-        Assert.Equal(control.DefaultCursor, control.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetFont_Invoke_Success()
-    {
-        using var control = new Control();
-        using var font = new Font("Arial", 8.25f);
-
-        // Reset without value.
-        control.ResetFont();
-        Assert.Equal(Control.DefaultFont, control.Font);
-
-        // Reset with value.
-        control.Font = font;
-        control.ResetFont();
-        Assert.Equal(Control.DefaultFont, control.Font);
-
-        // Reset again.
-        control.ResetFont();
-        Assert.Equal(Control.DefaultFont, control.Font);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetForeColor_Invoke_Success()
-    {
-        using var control = new Control();
-
-        // Reset without value.
-        control.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-
-        // Reset with value.
-        control.ForeColor = Color.Black;
-        control.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-
-        // Reset again.
-        control.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetImeMode_Invoke_Success()
-    {
-        using var control = new SubControl();
-
-        // Reset without value.
-        control.ResetImeMode();
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-
-        // Reset with value.
-        control.ImeMode = ImeMode.On;
-        control.ResetImeMode();
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-
-        // Reset again.
-        control.ResetImeMode();
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetMouseEventArgs_InvokeWithoutHandle_Success()
-    {
-        using var control = new SubControl();
-        control.ResetMouseEventArgs();
-        Assert.False(control.IsHandleCreated);
-
-        // Invoke again.
-        control.ResetMouseEventArgs();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetMouseEventArgs_InvokeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ResetMouseEventArgs();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.ResetMouseEventArgs();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetRightToLeft_Invoke_Success()
-    {
-        using var control = new SubControl();
-
-        // Reset without value.
-        control.ResetRightToLeft();
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-
-        // Reset with value.
-        control.RightToLeft = RightToLeft.Yes;
-        control.ResetRightToLeft();
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-
-        // Reset again.
-        control.ResetRightToLeft();
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void Control_ResetText_Invoke_Success()
-    {
-        using var control = new SubControl();
-
-        // Reset without value.
-        control.ResetText();
-        Assert.Empty(control.Text);
-
-        // Reset with value.
-        control.Text = "Text";
-        control.ResetText();
-        Assert.Empty(control.Text);
-
-        // Reset again.
-        control.ResetText();
-        Assert.Empty(control.Text);
-    }
-
-    public static IEnumerable<object[]> ResumeLayout_TestData()
-    {
-        yield return new object[] { null, null, true, 1 };
-        yield return new object[] { new Control(), string.Empty, true, 1 };
-        yield return new object[] { new Control(), "AffectedProperty", true, 1 };
-
-        yield return new object[] { null, null, false, 0 };
-        yield return new object[] { new Control(), string.Empty, false, 0 };
-        yield return new object[] { new Control(), "AffectedProperty", false, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResumeLayout_TestData))]
-    public void Control_ResumeLayout_InvokeSuspendedWithLayoutRequest_Success(Control affectedControl, string affectedProperty, bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Same(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResumeLayout_TestData))]
-    public void Control_ResumeLayout_InvokeSuspendedWithMultipleLayoutRequests_Success(Control affectedControl, string affectedProperty, bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Same(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(new Control(), "AnotherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ResumeLayout_InvokeSuspendedWithoutLayoutRequests_Success(bool performLayout)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResumeLayout_TestData))]
-    public void Control_ResumeLayout_InvokeSuspendedMultipleTimesWithLayoutRequest_Success(Control affectedControl, string affectedProperty, bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Same(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResumeLayout_TestData))]
-    public void Control_ResumeLayout_InvokeSuspendedMultipleTimesWithMultipleLayoutRequests_Success(Control affectedControl, string affectedProperty, bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Same(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        control.PerformLayout(new Control(), "AnotherAffectedProperty");
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ResumeLayout_InvokeSuspendedMultipleTimesWithoutLayoutRequests_Success(bool performLayout)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void Control_ResumeLayout_InvokeSuspendedWithChildren_Nop(bool performLayout, int expectedInitLayoutCallCount)
-    {
-        using var child = new Control();
-        using var control = new CustomLayoutEngineControl();
-        control.Controls.Add(child);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.InitLayout(child, BoundsSpecified.All))
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.InitLayout(child, BoundsSpecified.All), Times.Exactly(expectedInitLayoutCallCount));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.InitLayout(child, BoundsSpecified.All), Times.Exactly(expectedInitLayoutCallCount * 2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ResumeLayout_InvokeNotSuspended_Nop(bool performLayout)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void Control_ResumeLayout_InvokeNotSuspendedWithChildren_Nop(bool performLayout, int expectedInitLayoutCallCount)
-    {
-        using var child = new Control();
-        using var control = new CustomLayoutEngineControl();
-        control.Controls.Add(child);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.InitLayout(child, BoundsSpecified.All))
-            .Verifiable();
-        control.SetLayoutEngine(mockLayoutEngine.Object);
-
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.InitLayout(child, BoundsSpecified.All), Times.Exactly(expectedInitLayoutCallCount));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(0, layoutCallCount);
-        mockLayoutEngine.Verify(e => e.InitLayout(child, BoundsSpecified.All), Times.Exactly(expectedInitLayoutCallCount * 2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResumeLayout_TestData))]
-    public void Control_ResumeLayout_InvokeSuspendedWithLayoutRequestWithHandle_Success(Control affectedControl, string affectedProperty, bool performLayout, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Same(affectedProperty, e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        control.PerformLayout(affectedControl, affectedProperty);
-        Assert.Equal(0, layoutCallCount);
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.ResumeLayout(performLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateContent_TestData))]
-    public void Control_RtlTranslateAlignment_InvokeContentAlignment_ReturnsExpected(RightToLeft rightToLeft, ContentAlignment align, ContentAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateLeftRight_TestData))]
-    public void Control_RtlTranslateAlignment_InvokeLeftRightAlignment_ReturnsExpected(RightToLeft rightToLeft, LeftRightAlignment align, LeftRightAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateHorizontal_TestData))]
-    public void Control_RtlTranslateAlignment_InvokeHorizontalAlignment_ReturnsExpected(RightToLeft rightToLeft, HorizontalAlignment align, HorizontalAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateAlignment(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RtlTranslateContent_TestData()
-    {
-        foreach (ContentAlignment align in Enum.GetValues(typeof(ContentAlignment)))
-        {
-            yield return new object[] { RightToLeft.No, align, align };
-            yield return new object[] { RightToLeft.Inherit, align, align };
-        }
-
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.BottomCenter, ContentAlignment.BottomCenter };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.BottomLeft, ContentAlignment.BottomRight };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.BottomRight, ContentAlignment.BottomLeft };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.MiddleCenter, ContentAlignment.MiddleCenter };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.MiddleLeft, ContentAlignment.MiddleRight };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.MiddleRight, ContentAlignment.MiddleLeft };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.TopCenter, ContentAlignment.TopCenter };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.TopLeft, ContentAlignment.TopRight };
-        yield return new object[] { RightToLeft.Yes, ContentAlignment.TopRight, ContentAlignment.TopLeft };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateContent_TestData))]
-    public void Control_RtlTranslateContent_Invoke_ReturnsExpected(RightToLeft rightToLeft, ContentAlignment align, ContentAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateContent(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateContent(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RtlTranslateLeftRight_TestData()
-    {
-        foreach (LeftRightAlignment align in Enum.GetValues(typeof(LeftRightAlignment)))
-        {
-            yield return new object[] { RightToLeft.No, align, align };
-            yield return new object[] { RightToLeft.Inherit, align, align };
-        }
-
-        yield return new object[] { RightToLeft.Yes, LeftRightAlignment.Left, LeftRightAlignment.Right };
-        yield return new object[] { RightToLeft.Yes, LeftRightAlignment.Right, LeftRightAlignment.Left };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateLeftRight_TestData))]
-    public void Control_RtlTranslateLeftRight_Invoke_ReturnsExpected(RightToLeft rightToLeft, LeftRightAlignment align, LeftRightAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateLeftRight(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateLeftRight(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RtlTranslateHorizontal_TestData()
-    {
-        foreach (HorizontalAlignment align in Enum.GetValues(typeof(HorizontalAlignment)))
-        {
-            yield return new object[] { RightToLeft.No, align, align };
-            yield return new object[] { RightToLeft.Inherit, align, align };
-        }
-
-        yield return new object[] { RightToLeft.Yes, HorizontalAlignment.Center, HorizontalAlignment.Center };
-        yield return new object[] { RightToLeft.Yes, HorizontalAlignment.Left, HorizontalAlignment.Right };
-        yield return new object[] { RightToLeft.Yes, HorizontalAlignment.Right, HorizontalAlignment.Left };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RtlTranslateHorizontal_TestData))]
-    public void Control_RtlTranslateHorizontal_Invoke_ReturnsExpected(RightToLeft rightToLeft, HorizontalAlignment align, HorizontalAlignment expected)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.RtlTranslateHorizontal(align));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.RtlTranslateHorizontal(align));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_SendToBack_InvokeWithoutHandleWithoutParent_Nop(bool topLevel)
-    {
-        using var control = new SubControl();
-        control.SetTopLevel(topLevel);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SendToBack();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(topLevel, control.IsHandleCreated);
-
-        // Call again.
-        control.SendToBack();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(topLevel, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_SendToBack_InvokeWithoutHandleWithParent_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(2, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_SendToBack_InvokeWithHandleWithParentWithoutHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, child1.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(2, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(child2.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_SendToBack_InvokeWithHandleWithParentWithHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        child1.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child1.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child1.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(2, parentLayoutCallCount);
-        Assert.True(child1.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_SendToBack_InvokeWithoutHandleWithParentWithHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new SubControl();
-        using var child2 = new Control();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-        Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>());
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child1, e.AffectedControl);
-            Assert.Equal("ChildIndex", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        child1.DestroyHandle();
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child1.SendToBack();
-        Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(2, parentLayoutCallCount);
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_SendToBack_InvokeWithHandleWithoutParent_Success(bool enabled, bool topLevel)
-    {
-        using var control = new SubControl
-        {
-            Enabled = enabled
-        };
-        control.SetTopLevel(topLevel);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SendToBack();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SendToBack();
-        Assert.Equal(topLevel, control.GetTopLevel());
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetAutoSizeMode_TestData()
-    {
-        yield return new object[] { AutoSizeMode.GrowOnly, AutoSizeMode.GrowOnly };
-        yield return new object[] { AutoSizeMode.GrowAndShrink, AutoSizeMode.GrowAndShrink };
-        yield return new object[] { AutoSizeMode.GrowAndShrink - 1, AutoSizeMode.GrowOnly };
-        yield return new object[] { AutoSizeMode.GrowOnly + 1, AutoSizeMode.GrowOnly };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetAutoSizeMode_TestData))]
-    public void Control_SetAutoSizeMode_Invoke_GetAutoSizeModeReturnsExpected(AutoSizeMode mode, AutoSizeMode expected)
-    {
-        using var control = new SubControl();
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetAutoSizeMode_TestData))]
-    public void Control_SetAutoSizeMode_InvokeWithParent_GetAutoSizeModeReturnsExpected(AutoSizeMode mode, AutoSizeMode expected)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        parent.Layout += (sender, e) => layoutCallCount++;
-
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetAutoSizeMode_TestData))]
-    public void Control_SetAutoSizeMode_InvokeWithHandle_GetAutoSizeModeReturnsExpected(AutoSizeMode mode, AutoSizeMode expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetAutoSizeMode(mode);
-        Assert.Equal(expected, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, 1 };
-        yield return new object[] { 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 1, 2, 1 };
-        yield return new object[] { 1, 2, 30, 40, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntInt_Success(int x, int y, int width, int height, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, 1, 2, 30, 40, 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, 1, 2, 30, 40, 31, 40, 0 };
-        yield return new object[] { new Size(30, 41), Size.Empty, 1, 2, 30, 40, 30, 41, 0 };
-        yield return new object[] { new Size(40, 50), Size.Empty, 1, 2, 30, 40, 40, 50, 0 };
-        yield return new object[] { Size.Empty, new Size(20, 10), 1, 2, 30, 40, 20, 10, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, 20, 30, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, 20, 30, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), 1, 2, 30, 40, 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), 1, 2, 30, 40, 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), 1, 2, 30, 40, 40, 50, 0 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), 1, 2, 30, 40, 40, 50, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithConstrainedSize_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntWithConstrainedSize_Success(Size minimumSize, Size maximumSize, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_WithCustomStyle_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, -7, -8, 1 };
-        yield return new object[] { 1, 0, 0, 0, -4, -4, 1 };
-        yield return new object[] { 0, 2, 0, 0, -4, -4, 1 };
-        yield return new object[] { 1, 2, 0, 0, -4, -4, 1 };
-        yield return new object[] { 0, 0, 1, 0, -3, -4, 1 };
-        yield return new object[] { 0, 0, 0, 2, -4, -2, 1 };
-        yield return new object[] { 0, 0, 1, 2, -3, -2, 1 };
-        yield return new object[] { 1, 2, 30, 40, 26, 36, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithCustomStyle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntWithCustomStyle_Success(int x, int y, int width, int height, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_WithParent_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, 1, 2 };
-        yield return new object[] { 1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 0, 2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 2, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 0, 1, 2 };
-        yield return new object[] { 0, 0, 0, 2, 1, 2 };
-        yield return new object[] { 0, 0, 1, 2, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithParent_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntWithParent_Success(int x, int y, int width, int height, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.SetBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_WithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 1, 0, 1, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 2, 0, 2, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 2, 1, 2, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 30, 40, 1, 1 };
-
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 1, 0, 1, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 2, 0, 2, 1, 0 };
-        yield return new object[] { false, 0, 0, 1, 2, 1, 2, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 30, 40, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_WithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { true, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 2, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 1, 2, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 0, 1, 0, 1, 1, 2, 2 };
-        yield return new object[] { true, 0, 0, 0, 2, 0, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 0, 0, 1, 2, 1, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 1, 2, 30, 40, 30, 40, 1, 1, 2, 2 };
-
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { false, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 0, 2, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 1, 2, 0, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 0, 0, 1, 0, 1, 0, 1, 0, 2, 2 };
-        yield return new object[] { false, 0, 0, 0, 2, 0, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 0, 0, 1, 2, 1, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 1, 2, 30, 40, 30, 40, 1, 0, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithParentWithHandle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.SetBounds(x, y, width, height);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.SetBounds(x, y, width, height);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.All, -1, -2, -3, -4, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.X, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.X, -1, 0, 0, 0, 0 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.X, 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.X, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.X, 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.X, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.X, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.X, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.X, 1, 0, 0, 0, 0 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Y, 0, -2, 0, 0, 0 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Y, 0, 2, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Y, 0, 2, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Y, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Y, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Y, 0, 2, 0, 0, 0 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Location, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Location, -1, -2, 0, 0, 0 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Location, 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Location, 0, 2, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Location, 1, 2, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Location, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Location, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Location, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Location, 1, 2, 0, 0, 0 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Width, 0, 0, -3, 0, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Width, 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Width, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Width, 0, 0, 1, 0, 1 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Width, 0, 0, 30, 0, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Height, 0, 0, 0, -4, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Height, 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Height, 0, 0, 0, 2, 1 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Height, 0, 0, 0, 40, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Size, 0, 0, -3, -4, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Size, 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Size, 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Size, 0, 0, 1, 2, 1 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Size, 0, 0, 30, 40, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.None, 0, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecified_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(expectedX + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(expectedY + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(expectedX + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(expectedY + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 31, 40, 0 };
-        yield return new object[] { new Size(30, 41), Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 41, 0 };
-        yield return new object[] { new Size(40, 50), Size.Empty, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 40, 50, 0 };
-        yield return new object[] { Size.Empty, new Size(20, 10), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 20, 10, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 20, 30, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 20, 30, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 40, 50, 0 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 40, 50, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_WithConstrainedSize_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecifiedWithConstrainedSize_Success(Size minimumSize, Size maximumSize, int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_WithCustomStyle_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.All, -1, -2, -3, -4, -7, -8, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, -4, -4, 1 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, -4, -4, 1 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, -4, -4, 1 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, -3, -4, 1 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, -4, -2, 1 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, -3, -2, 1 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 26, 36, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_WithCustomStyle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecifiedWithCustomStyle_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(expectedX + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(expectedY + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(expectedX + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(expectedY + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_WithParent_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.All, -1, -2, -3, -4, 1, 2 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1, 2 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1, 2 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1, 2 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.X, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.X, -1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.X, 1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.X, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.X, 1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.X, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.X, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.X, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.X, 1, 0, 0, 0, 0, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Y, 0, -2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Y, 0, 2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Y, 0, 2, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Y, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Y, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Y, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Y, 0, 2, 0, 0, 0, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Location, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Location, -1, -2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Location, 1, 0, 0, 0, 0, 1 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Location, 0, 2, 0, 0, 0, 1 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Location, 1, 2, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Location, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Location, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Location, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Location, 1, 2, 0, 0, 0, 1 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Width, 0, 0, -3, 0, 1, 2 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Width, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Width, 0, 0, 1, 0, 1, 2 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Width, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Width, 0, 0, 1, 0, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Width, 0, 0, 30, 0, 1, 2 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Height, 0, 0, 0, -4, 1, 2 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Height, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Height, 0, 0, 0, 2, 1, 2 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Height, 0, 0, 0, 2, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Height, 0, 0, 0, 40, 1, 2 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.Size, 0, 0, -3, -4, 1, 2 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.Size, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.Size, 0, 0, 1, 0, 1, 2 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.Size, 0, 0, 0, 2, 1, 2 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.Size, 0, 0, 1, 2, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.Size, 0, 0, 30, 40, 1, 2 };
-
-        yield return new object[] { 0, 0, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 0, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 0, 2, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 2, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 30, 40, BoundsSpecified.None, 0, 0, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_WithParent_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecifiedWithParent_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBounds(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(expectedX, control.Left);
-            Assert.Equal(expectedX + expectedWidth, control.Right);
-            Assert.Equal(expectedY, control.Top);
-            Assert.Equal(expectedY + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.SetBounds(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(expectedX, control.Left);
-            Assert.Equal(expectedX + expectedWidth, control.Right);
-            Assert.Equal(expectedY, control.Top);
-            Assert.Equal(expectedY + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_WithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, BoundsSpecified.All, -1, -2, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1, 1 };
-
-        yield return new object[] { false, 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, BoundsSpecified.All, -1, -2, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1, 0 };
-        yield return new object[] { false, 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_WithHandle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecifiedWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetBounds(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(expectedX, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(expectedY, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBounds_Int_Int_Int_Int_BoundsSpecified_WithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, BoundsSpecified.All, -1, -2, 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { true, 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1, 1, 2, 2 };
-        yield return new object[] { true, 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1, 1, 2, 2 };
-
-        yield return new object[] { false, 0, 0, 0, 0, BoundsSpecified.All, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, BoundsSpecified.All, -1, -2, 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { false, 1, 0, 0, 0, BoundsSpecified.All, 1, 0, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 0, 2, 0, 0, BoundsSpecified.All, 0, 2, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 1, 2, 0, 0, BoundsSpecified.All, 1, 2, 0, 0, 0, 0, 1, 1 };
-        yield return new object[] { false, 0, 0, 1, 0, BoundsSpecified.All, 0, 0, 1, 0, 1, 0, 2, 2 };
-        yield return new object[] { false, 0, 0, 0, 2, BoundsSpecified.All, 0, 0, 0, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 0, 0, 1, 2, BoundsSpecified.All, 0, 0, 1, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 1, 2, 30, 40, BoundsSpecified.All, 1, 2, 30, 40, 1, 0, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_BoundsSpecified_WithParentWithHandle_TestData))]
-    public void Control_SetBounds_InvokeIntIntIntIntBoundsSpecifiedWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified, int expectedX, int expectedY, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.SetBounds(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(expectedX, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(expectedY, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.SetBounds(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(expectedX, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(expectedY, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(expectedX, expectedY, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 0, 0, specified, 0, 0 };
-            yield return new object[] { -1, -2, -3, -4, specified, 1, 1 };
-            yield return new object[] { 1, 0, 0, 0, specified, 1, 0 };
-            yield return new object[] { 0, 2, 0, 0, specified, 1, 0 };
-            yield return new object[] { 1, 2, 0, 0, specified, 1, 0 };
-            yield return new object[] { 0, 0, 1, 0, specified, 0, 1 };
-            yield return new object[] { 0, 0, 0, 2, specified, 0, 1 };
-            yield return new object[] { 0, 0, 1, 2, specified, 0, 1 };
-            yield return new object[] { 1, 2, 30, 40, specified, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void Control_SetBoundsCore_Invoke_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_WithConstrainedSize_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Size.Empty, Size.Empty, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { new Size(10, 20), Size.Empty, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { new Size(30, 40), Size.Empty, 1, 2, 30, 40, specified, 30, 40, 1, 0 };
-            yield return new object[] { new Size(31, 40), Size.Empty, 1, 2, 30, 40, specified, 31, 40, 1, 0 };
-            yield return new object[] { new Size(30, 41), Size.Empty, 1, 2, 30, 40, specified, 30, 41, 1, 0 };
-            yield return new object[] { new Size(40, 50), Size.Empty, 1, 2, 30, 40, specified, 40, 50, 1, 0 };
-            yield return new object[] { Size.Empty, new Size(20, 10), 1, 2, 30, 40, specified, 20, 10, 1, 1 };
-            yield return new object[] { Size.Empty, new Size(30, 40), 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { Size.Empty, new Size(31, 40), 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { Size.Empty, new Size(30, 41), 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { Size.Empty, new Size(40, 50), 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { new Size(10, 20), new Size(40, 50), 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, specified, 20, 30, 1, 1 };
-            yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, specified, 20, 30, 1, 1 };
-            yield return new object[] { new Size(30, 40), new Size(20, 30), 1, 2, 30, 40, specified, 30, 40, 1, 0 };
-            yield return new object[] { new Size(30, 40), new Size(40, 50), 1, 2, 30, 40, specified, 30, 40, 1, 0 };
-            yield return new object[] { new Size(40, 50), new Size(20, 30), 1, 2, 30, 40, specified, 40, 50, 1, 0 };
-            yield return new object[] { new Size(40, 50), new Size(40, 50), 1, 2, 30, 40, specified, 40, 50, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithConstrainedSize_TestData))]
-    public void Control_SetBoundsCore_InvokeWithConstrainedSize_Success(Size minimumSize, Size maximumSize, int x, int y, int width, int height, BoundsSpecified specified, int expectedWidth, int expectedHeight, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_WithCustomStyle_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 0, 0, specified, 0, 0, 0, 0 };
-            yield return new object[] { -1, -2, -3, -4, specified, -7, -8, 1, 1 };
-            yield return new object[] { 1, 0, 0, 0, specified, -4, -4, 1, 1 };
-            yield return new object[] { 0, 2, 0, 0, specified, -4, -4, 1, 1 };
-            yield return new object[] { 1, 2, 0, 0, specified, -4, -4, 1, 1 };
-            yield return new object[] { 0, 0, 1, 0, specified, -3, -4, 0, 1 };
-            yield return new object[] { 0, 0, 0, 2, specified, -4, -2, 0, 1 };
-            yield return new object[] { 0, 0, 1, 2, specified, -3, -2, 0, 1 };
-            yield return new object[] { 1, 2, 30, 40, specified, 26, 36, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithCustomStyle_TestData))]
-    public void Control_SetBoundsCore_InvokeWithCustomStyle_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedClientWidth, int expectedClientHeight, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void Control_SetBoundsCore_InvokeWithParent_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_WithHandle_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { true, 0, 0, 0, 0, specified, 0, 0, 0, 0, 0 };
-            yield return new object[] { true, -1, -2, -3, -4, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { true, 1, 0, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { true, 0, 2, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { true, 1, 2, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { true, 0, 0, 1, 0, specified, 1, 0, 0, 1, 1 };
-            yield return new object[] { true, 0, 0, 0, 2, specified, 0, 2, 0, 1, 1 };
-            yield return new object[] { true, 0, 0, 1, 2, specified, 1, 2, 0, 1, 1 };
-            yield return new object[] { true, 1, 2, 30, 40, specified, 30, 40, 1, 1, 1 };
-
-            yield return new object[] { false, 0, 0, 0, 0, specified, 0, 0, 0, 0, 0 };
-            yield return new object[] { false, -1, -2, -3, -4, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { false, 1, 0, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { false, 0, 2, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { false, 1, 2, 0, 0, specified, 0, 0, 1, 0, 0 };
-            yield return new object[] { false, 0, 0, 1, 0, specified, 1, 0, 0, 1, 0 };
-            yield return new object[] { false, 0, 0, 0, 2, specified, 0, 2, 0, 1, 0 };
-            yield return new object[] { false, 0, 0, 1, 2, specified, 1, 2, 0, 1, 0 };
-            yield return new object[] { false, 1, 2, 30, 40, specified, 30, 40, 1, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithHandle_TestData))]
-    public void Control_SetBoundsCore_InvokeWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified, int expectedWidth, int expectedHeight, int expectedLocationChangedCallCount, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithHandle_TestData))]
-    public void Control_SetBoundsCore_InvokeWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified, int expectedWidth, int expectedHeight, int expectedLocationChangedCallCount, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_Set_TestData))]
-    public void Control_SetClientSizeCore_Invoke_GetReturnsExpected(Size value, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_SetWithCustomStyle_TestData))]
-    public void Control_SetClientSizeCore_InvokeWithCustomStyle_GetReturnsExpected(Size value, Size expectedSize)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_SetWithHandle_TestData))]
-    public void Control_SetClientSizeCore_InvokeWithHandle_GetReturnsExpected(bool resizeRedraw, Size value, Size expectedSize, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetClientSizeCore(value.Width, value.Height);
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_SetClientSizeCore_InvokeWithHandler_CallsClientSizeChanged()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        int sizeChangedCallCount = 0;
-        EventHandler sizeChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += handler;
-        control.SizeChanged += sizeChangedHandler;
-
-        control.SetClientSizeCore(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(2, callCount);
-        Assert.Equal(1, sizeChangedCallCount);
-
-        // Set same.
-        control.SetClientSizeCore(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(3, callCount);
-        Assert.Equal(1, sizeChangedCallCount);
-
-        // Set different.
-        control.SetClientSizeCore(11, 11);
-        Assert.Equal(new Size(11, 11), control.ClientSize);
-        Assert.Equal(5, callCount);
-        Assert.Equal(2, sizeChangedCallCount);
-
-        // Remove handler.
-        control.ClientSizeChanged -= handler;
-        control.SizeChanged -= sizeChangedHandler;
-        control.SetClientSizeCore(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(5, callCount);
-        Assert.Equal(2, sizeChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> SetStyle_TestData()
-    {
-        yield return new object[] { ControlStyles.UserPaint, true, true };
-        yield return new object[] { ControlStyles.UserPaint, false, false };
-        yield return new object[] { (ControlStyles)0, true, true };
-        yield return new object[] { (ControlStyles)0, false, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetStyle_TestData))]
-    public void Control_SetStyle_Invoke_GetStyleReturnsExpected(ControlStyles flag, bool value, bool expected)
-    {
-        using var control = new SubControl();
-        control.SetStyle(flag, value);
-        Assert.Equal(expected, control.GetStyle(flag));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetStyle(flag, value);
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetStyle_TestData))]
-    public void Control_SetStyle_InvokeWithHandle_GetStyleReturnsExpected(ControlStyles flag, bool value, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetStyle(flag, value);
-        Assert.Equal(expected, control.GetStyle(flag));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetStyle(flag, value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, 1, 1, 1)]
-    [InlineData(true, false, false, 0, 0, 1)]
-    [InlineData(false, true, false, 1, 0, 0)]
-    [InlineData(false, false, false, 0, 0, 0)]
-    public void Control_SetTopLevel_Invoke_GetTopLevelReturnsExpected(bool visible, bool value, bool expectedHandleCreated1, int expectedStyleChangedCallCount1, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetTopLevel(value);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.Equal(expectedHandleCreated1, control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.SetTopLevel(value);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.Equal(expectedHandleCreated1, control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.SetTopLevel(!value);
-        Assert.Equal(!value, control.GetTopLevel());
-        Assert.Equal(visible, control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1 + 1, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1)]
-    [InlineData(false, false, 0)]
-    public void Control_SetTopLevel_InvokeWithHandle_GetTopLevelReturnsExpected(bool visible, bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetTopLevel(value);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetTopLevel(value);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.SetTopLevel(!value);
-        Assert.Equal(!value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_SetTopLevel_InvokeWithParent_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Throws<ArgumentException>("value", () => control.SetTopLevel(true));
-        control.SetTopLevel(false);
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> SizeFromClientSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeFromClientSize_TestData))]
-    public void Control_SizeFromClientSize_Invoke_ReturnsExpected(Size clientSize)
-    {
-        using var control = new SubControl();
-        Assert.Equal(clientSize, control.SizeFromClientSize(clientSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again to test caching behavior.
-        Assert.Equal(clientSize, control.SizeFromClientSize(clientSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeFromClientSize_TestData))]
-    public void Control_SizeFromClientSize_InvokeWithStyles_ReturnsExpected(Size clientSize)
-    {
-        using var control = new BorderedControl();
-        var expected = new Size(clientSize.Width + 4, clientSize.Height + 4);
-        Assert.Equal(expected, control.SizeFromClientSize(clientSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again to test caching behavior.
-        Assert.Equal(expected, control.SizeFromClientSize(clientSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class BorderedControl : Control
-    {
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                CreateParams cp = base.CreateParams;
-                cp.Style |= (int)WINDOW_STYLE.WS_BORDER;
-                cp.ExStyle |= (int)WINDOW_EX_STYLE.WS_EX_STATICEDGE;
-                return cp;
-            }
-        }
-
-        public new Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) => base.GetScaledBounds(bounds, factor, specified);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified); public new void SetClientSizeCore(int width, int height) => base.SetClientSizeCore(width, height);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new Size SizeFromClientSize(Size clientSize) => base.SizeFromClientSize(clientSize);
-
-        public new void UpdateBounds() => base.UpdateBounds();
-
-        public new void UpdateBounds(int x, int y, int width, int height) => base.UpdateBounds(x, y, width, height);
-
-        public new void UpdateBounds(int x, int y, int width, int height, int clientWidth, int clientHeight) => base.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeFromClientSize_TestData))]
-    public void Control_SizeFromClientSize_InvokeWithHandle_ReturnsExpected(Size clientSize)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(clientSize, control.SizeFromClientSize(clientSize));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again to test caching behavior.
-        Assert.Equal(clientSize, control.SizeFromClientSize(clientSize));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Show_Invoke_Success(bool visible)
-    {
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        control.Show();
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Show();
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Show_InvokeWithHandle_Success(bool visible)
-    {
-        using var control = new Control
-        {
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Show();
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Show();
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_SuspendLayout_Invoke_Success()
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_SuspendLayout_InvokeWithHandle_Success()
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SuspendLayout();
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.Equal("System.Windows.Forms.Control", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void Control_Update_InvokeWithoutHandle_Nop()
-    {
-        using var control = new Control();
-        control.Update();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Update();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_Update_InvokeWithHandle_Success()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Update();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Update();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_Invoke_Success()
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        int sizeChangedCallCount = 0;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        int clientSizeChangedCallCount = 0;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeTopLevel_Success()
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        int sizeChangedCallCount = 0;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        int clientSizeChangedCallCount = 0;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        control.SetTopLevel(true);
-        Assert.True(control.IsHandleCreated);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateBounds();
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height >= 0);
-        Assert.Equal(0, control.ClientRectangle.X);
-        Assert.Equal(0, control.ClientRectangle.Y);
-        Assert.True(control.ClientRectangle.Width > 0);
-        Assert.True(control.ClientRectangle.Height >= 0);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height >= 0);
-        Assert.True(control.Size.Width > 0);
-        Assert.True(control.Size.Height > 0);
-        Assert.Equal(0, control.Left);
-        Assert.True(control.Right > 0);
-        Assert.Equal(0, control.Top);
-        Assert.True(control.Bottom >= 0);
-        Assert.True(control.Width > 0);
-        Assert.True(control.Height >= 0);
-        Assert.Equal(0, control.Bounds.X);
-        Assert.Equal(0, control.Bounds.Y);
-        Assert.True(control.Bounds.Width > 0);
-        Assert.True(control.Bounds.Height >= 0);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height >= 0);
-        Assert.Equal(0, control.ClientRectangle.X);
-        Assert.Equal(0, control.ClientRectangle.Y);
-        Assert.True(control.ClientRectangle.Width > 0);
-        Assert.True(control.ClientRectangle.Height >= 0);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height >= 0);
-        Assert.True(control.Size.Width > 0);
-        Assert.True(control.Size.Height >= 0);
-        Assert.Equal(0, control.Left);
-        Assert.True(control.Right > 0);
-        Assert.Equal(0, control.Top);
-        Assert.True(control.Bottom >= 0);
-        Assert.True(control.Width > 0);
-        Assert.True(control.Height >= 0);
-        Assert.Equal(0, control.Bounds.X);
-        Assert.Equal(0, control.Bounds.Y);
-        Assert.True(control.Bounds.Width > 0);
-        Assert.True(control.Bounds.Height >= 0);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeWithBounds_Success()
-    {
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 3, 4)
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeWithParentWithBounds_Success()
-    {
-        using var parent = new SubControl
-        {
-            Bounds = new Rectangle(10, 20, 30, 40)
-        };
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 3, 4),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeWithBoundsWithHandle_Success()
-    {
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 3, 4)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        int sizeChangedCallCount = 0;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        int clientSizeChangedCallCount = 0;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateBounds();
-        Assert.Equal(new Size(3, 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.DisplayRectangle);
-        Assert.Equal(new Size(3, 4), control.Size);
-        Assert.Equal(1, control.Left);
-        Assert.Equal(4, control.Right);
-        Assert.Equal(2, control.Top);
-        Assert.Equal(6, control.Bottom);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(4, control.Height);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(new Size(3, 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.DisplayRectangle);
-        Assert.Equal(new Size(3, 4), control.Size);
-        Assert.Equal(1, control.Left);
-        Assert.Equal(4, control.Right);
-        Assert.Equal(2, control.Top);
-        Assert.Equal(6, control.Bottom);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(4, control.Height);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateBounds_InvokeWithParentWithBoundsWithHandle_Success()
-    {
-        using var parent = new SubControl
-        {
-            Bounds = new Rectangle(10, 20, 30, 40)
-        };
-        using var control = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 3, 4),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        int sizeChangedCallCount = 0;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        int clientSizeChangedCallCount = 0;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.UpdateBounds();
-        Assert.Equal(new Size(3, 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.DisplayRectangle);
-        Assert.Equal(new Size(3, 4), control.Size);
-        Assert.Equal(1, control.Left);
-        Assert.Equal(4, control.Right);
-        Assert.Equal(2, control.Top);
-        Assert.Equal(6, control.Bottom);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(4, control.Height);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        control.UpdateBounds();
-        Assert.Equal(new Size(3, 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 3, 4), control.DisplayRectangle);
-        Assert.Equal(new Size(3, 4), control.Size);
-        Assert.Equal(1, control.Left);
-        Assert.Equal(4, control.Right);
-        Assert.Equal(2, control.Top);
-        Assert.Equal(6, control.Bottom);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(4, control.Height);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, 1 };
-        yield return new object[] { 1, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 1, 2, 1 };
-        yield return new object[] { 1, 2, 30, 40, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntInt_Success(int x, int y, int width, int height, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(30, 41), Size.Empty, 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(40, 50), Size.Empty, 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(20, 10), 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), 1, 2, 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), 1, 2, 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), 1, 2, 30, 40, 1 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), 1, 2, 30, 40, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_WithConstrainedSize_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntWithConstrainedSize_Success(Size minimumSize, Size maximumSize, int x, int y, int width, int height, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_WithCustomStyle_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, -4, -4 };
-        yield return new object[] { -1, -2, -3, -4, -7, -8 };
-        yield return new object[] { 1, 0, 0, 0, -4, -4 };
-        yield return new object[] { 0, 2, 0, 0, -4, -4 };
-        yield return new object[] { 1, 2, 0, 0, -4, -4 };
-        yield return new object[] { 0, 0, 1, 0, -3, -4 };
-        yield return new object[] { 0, 0, 0, 2, -4, -2 };
-        yield return new object[] { 0, 0, 1, 2, -3, -2 };
-        yield return new object[] { 1, 2, 30, 40, 26, 36 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_WithCustomStyle_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntWithCustomStyle_Success(int x, int y, int width, int height, int expectedClientWidth, int expectedClientHeight)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntWithParent_Success(int x, int y, int width, int height, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UpdateBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.UpdateBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_WithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, 1, 1 };
-        yield return new object[] { true, 1, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 2, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 2, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 1, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 2, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 2, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 1, 1 };
-
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, 1, 0 };
-        yield return new object[] { false, 1, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 2, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 1, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 2, 1, 0 };
-        yield return new object[] { false, 0, 0, 1, 2, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.UpdateBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.UpdateBounds(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4, -5, -6, 1 };
-        yield return new object[] { 1, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0, 0, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0, 0, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0, 0, 0, 1 };
-        yield return new object[] { 0, 0, 0, 2, 0, 0, 1 };
-        yield return new object[] { 0, 0, 1, 2, 0, 0, 1 };
-        yield return new object[] { 0, 0, 0, 0, 1, 0, 1 };
-        yield return new object[] { 0, 0, 0, 0, 0, 2, 1 };
-        yield return new object[] { 0, 0, 0, 0, 1, 2, 1 };
-        yield return new object[] { 1, 2, 0, 0, 3, 4, 1 };
-        yield return new object[] { 1, 2, 30, 40, 30, 40, 1 };
-        yield return new object[] { 1, 2, 30, 40, 20, 30, 1 };
-        yield return new object[] { 1, 2, 30, 40, 50, 60, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_Int_Int_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntIntInt_Success(int x, int y, int width, int height, int clientWidth, int clientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-        Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-        Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_Int_Int_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntIntIntWithParent_Success(int x, int y, int width, int height, int clientWidth, int clientHeight, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-            Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-            Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> UpdateBounds_Int_Int_Int_Int_Int_Int_WithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, -1, -2, -3, -4, -5, -6, 1, 1 };
-        yield return new object[] { true, 1, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 1, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 1, 0, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 2, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 1, 2, 0, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 0, 1, 0, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 0, 0, 2, 1, 1 };
-        yield return new object[] { true, 0, 0, 0, 0, 1, 2, 1, 1 };
-        yield return new object[] { true, 1, 2, 0, 0, 30, 40, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 30, 40, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 20, 30, 1, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 50, 60, 1, 1 };
-
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, -5, -6, 1, 0 };
-        yield return new object[] { false, 1, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 1, 0, 0, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 2, 0, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 1, 2, 0, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 0, 1, 0, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 0, 0, 2, 1, 0 };
-        yield return new object[] { false, 0, 0, 0, 0, 1, 2, 1, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, 30, 40, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 30, 40, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 20, 30, 1, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 50, 60, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntIntIntWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int clientWidth, int clientHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-        Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-        Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpdateBounds_Int_Int_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_UpdateBounds_InvokeIntIntIntIntIntIntWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, int clientWidth, int clientHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-            Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-            Assert.Equal(new Size(clientWidth, clientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, clientWidth, clientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateStyles_InvokeWithoutHandle_Success()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.StyleChanged += handler;
-        control.UpdateStyles();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.StyleChanged -= handler;
-        control.UpdateStyles();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateStyles_InvokeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        IntPtr handle = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.StyleChanged += handler;
-        control.UpdateStyles();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(handle, control.Handle);
-
-        // Remove handler.
-        control.StyleChanged -= handler;
-        control.UpdateStyles();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(handle, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithoutParent_Nop()
-    {
-        using var control = new SubControl();
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithoutHandleWithParentWithoutHandle_Nop()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithHandleWithParentWithoutHandle_Nop()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateZOrder();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        control.UpdateZOrder();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithoutHandleWithParentWithHandle_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        control.DestroyHandle();
-
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        control.UpdateZOrder();
-        Assert.False(control.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithHandleWithParentWithHandleOnlyChild_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.UpdateZOrder();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        control.UpdateZOrder();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithHandleWithParentWithHandleMultipleChildren_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new Control();
-        using var child2 = new SubControl();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        child2.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child2.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child2.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        child2.UpdateZOrder();
-        Assert.True(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child2.UpdateZOrder();
-        Assert.True(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_UpdateZOrder_InvokeWithHandleWithParentWithHandleMultipleChildrenWithoutHandle_Success()
-    {
-        using var parent = new Control();
-        using var child1 = new SubControl();
-        using var child2 = new SubControl();
-        parent.Controls.Add(child1);
-        parent.Controls.Add(child2);
-
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        child2.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        child2.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        child2.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        child1.DestroyHandle();
-
-        child2.UpdateZOrder();
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Call again.
-        child2.UpdateZOrder();
-        Assert.False(child1.IsHandleCreated);
-        Assert.True(child2.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeCaptureChangedWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int callCount = 0;
-            control.MouseCaptureChanged += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CAPTURECHANGED,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeCaptureChangedWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseCaptureChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CAPTURECHANGED,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeCancelMode_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CANCELMODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeCancelModeWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        control.LostFocus += (sender, e) => callCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CANCELMODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithoutContextMenuStrip_TestData()
-    {
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2) };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void Control_WndProc_InvokeContextMenuWithoutContextMenuStripWithoutHandle_Success(Size size, IntPtr lParam)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl
-            {
-                Size = size
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1), (IntPtr)250, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0), IntPtr.Zero, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2), IntPtr.Zero, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2), IntPtr.Zero, true };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1), IntPtr.Zero, false };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(p.X, p.Y), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData))]
-    public void Control_WndProc_InvokeContextMenuWithContextMenuStripWithoutHandle_Success(Size size, IntPtr lParam, IntPtr expectedResult, bool expectedHandleCreated)
-    {
-        using (new NoAssertContext())
-        {
-            using var menu = new ContextMenuStrip();
-            using var control = new SubControl
-            {
-                ContextMenuStrip = menu,
-                Size = size
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(menu.Visible);
-            Assert.Equal(expectedResult == (IntPtr)250, menu.SourceControl == control);
-            Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void Control_WndProc_InvokeContextMenuWithoutContextMenuStripWithHandle_Success(Size size, IntPtr lParam)
-    {
-        using var control = new SubControl
-        {
-            Size = size
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1), (IntPtr)250 };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0), IntPtr.Zero };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2), IntPtr.Zero };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250 };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2), IntPtr.Zero };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(p.X, p.Y), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2), IntPtr.Zero };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithHandle_TestData))]
-    public void Control_WndProc_InvokeContextMenuWithContextMenuStripWithHandle_Success(Size size, IntPtr lParam, IntPtr expectedResult)
-    {
-        using var menu = new ContextMenuStrip();
-        using var control = new SubControl
-        {
-            ContextMenuStrip = menu,
-            Size = size
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.False(menu.Visible);
-        Assert.Equal(expectedResult == (IntPtr)250, menu.SourceControl == control);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeDpiChangedAfterParentWithoutHandle_Success()
-    {
-        // Set thread awareness context to PermonitorV2(PMv2).
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using (new NoAssertContext())
-            {
-                using SubControl control = new();
-                int callCount = 0;
-                control.DpiChangedAfterParent += (sender, e) =>
-                {
-                    Assert.Same(control, sender);
-                    Assert.Same(EventArgs.Empty, e);
-                    callCount++;
-                };
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_DPICHANGED_AFTERPARENT,
-                    WParam = PARAM.FromLowHigh(192, 192),
-                    Result = 250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(0, m.Result);
-                Assert.Equal(1, callCount);
-                Assert.False(control.IsHandleCreated);
-            }
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeDpiChangedAfterParentWithHandle_Success()
-    {
-        // Set thread awareness context to PermonitorV2(PMv2).
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using var control = new SubControl();
-            Assert.NotEqual(0, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            int callCount = 0;
-            control.DpiChangedAfterParent += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_DPICHANGED_AFTERPARENT,
-                WParam = PARAM.FromLowHigh(192, 192),
-                Result = 250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(0, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeDpiChangedBeforeParentWithoutHandle_Success()
-    {
-        // Set thread awareness context to PermonitorV2(PMv2).
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using (new NoAssertContext())
-            {
-                using var control = new SubControl();
-                int callCount = 0;
-                control.DpiChangedBeforeParent += (sender, e) =>
-                {
-                    Assert.Same(control, sender);
-                    Assert.Same(EventArgs.Empty, e);
-                    callCount++;
-                };
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_DPICHANGED_BEFOREPARENT,
-                    WParam = PARAM.FromLowHigh(192, 192),
-                    Result = 250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(0, m.Result);
-                Assert.Equal(1, callCount);
-                Assert.False(control.IsHandleCreated);
-            }
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeDpiChangedBeforeParentWithHandle_Success()
-    {
-        // Set thread awareness context to PermonitorV2(PMv2).
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using var control = new SubControl();
-            Assert.NotEqual(0, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            int callCount = 0;
-            control.DpiChangedBeforeParent += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_DPICHANGED_BEFOREPARENT,
-                WParam = PARAM.FromLowHigh(192, 192),
-                Result = 250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(0, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgndWithoutHandleWithoutWParam_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, true, opaque, (IntPtr)1, false };
-            yield return new object[] { true, false, opaque, IntPtr.Zero, false };
-            yield return new object[] { false, true, opaque, IntPtr.Zero, false };
-            yield return new object[] { false, false, opaque, IntPtr.Zero, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgndWithoutHandleWithoutWParam_TestData))]
-    public void Control_WndProc_InvokeEraseBkgndWithoutHandleWithoutWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque, IntPtr expectedResult, bool expectedIsHandleCreated)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_ERASEBKGND,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-            Assert.Equal(0, paintCallCount);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgndWithoutHandleWithWParam_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, true, opaque, (IntPtr)1, false };
-            yield return new object[] { true, false, opaque, (IntPtr)1, true };
-            yield return new object[] { false, true, opaque, IntPtr.Zero, false };
-            yield return new object[] { false, false, opaque, IntPtr.Zero, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgndWithoutHandleWithWParam_TestData))]
-    public void Control_WndProc_InvokeEraseBkgndWithoutHandleWithWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque, IntPtr expectedResult, bool expectedIsHandleCreated)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            using var image = new Bitmap(10, 10);
-            using Graphics graphics = Graphics.FromImage(image);
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_ERASEBKGND,
-                    WParam = hdc,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(expectedResult, m.Result);
-                Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-                Assert.Equal(0, paintCallCount);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgndWithHandleWithoutWParam_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, true, opaque, (IntPtr)1 };
-            yield return new object[] { true, false, opaque, IntPtr.Zero };
-            yield return new object[] { false, true, opaque, IntPtr.Zero };
-            yield return new object[] { false, false, opaque, IntPtr.Zero };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgndWithHandleWithoutWParam_TestData))]
-    public void Control_WndProc_InvokeEraseBkgndWithHandleWithoutWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque, IntPtr expectedResult)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_ERASEBKGND,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, paintCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgndWithHandleWithWParam_TestData()
-    {
-        foreach (bool opaque in new bool[] { true, false })
-        {
-            yield return new object[] { true, true, opaque, (IntPtr)1 };
-            yield return new object[] { true, false, opaque, (IntPtr)1 };
-            yield return new object[] { false, true, opaque, IntPtr.Zero };
-            yield return new object[] { false, false, opaque, IntPtr.Zero };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgndWithHandleWithWParam_TestData))]
-    public void Control_WndProc_InvokeEraseBkgndWithHandleWithWParam_Success(bool userPaint, bool allPaintingInWmPaint, bool opaque, IntPtr expectedResult)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_ERASEBKGND,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(0, paintCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeGetDlgCodeWithoutHandle_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_GETDLGCODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeGetDlgCodeWithHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_GETDLGCODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeImeNotifyCallCountWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int imeModeChangedCallCount = 0;
-            control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_IME_NOTIFY,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, imeModeChangedCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeImeNotifyCallCountWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int imeModeChangedCallCount = 0;
-        control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_NOTIFY,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, imeModeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeKillFocusWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int callCount = 0;
-            control.LostFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeKillFocusWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_KILLFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_PrintClientWithoutHandleWithoutWParam_TestData()
-    {
-        yield return new object[] { true, true, (IntPtr)250, 0 };
-        yield return new object[] { false, true, IntPtr.Zero, 0 };
-        yield return new object[] { false, false, IntPtr.Zero, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PrintClientWithoutHandleWithoutWParam_TestData))]
-    public void Control_WndProc_InvokePrintClientWithoutHandleWithoutWParam_Success(bool userPaint, bool opaque, IntPtr expectedResult, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PRINTCLIENT,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokePrintClientWithoutHandleWithoutWParamUserPaint_DoesNotThrow()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserPaint, true);
-            control.SetStyle(ControlStyles.Opaque, false);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PRINTCLIENT,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)250, m.Result);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, paintCallCount);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_PrintClientWithoutHandleWithWParam_TestData()
-    {
-        yield return new object[] { true, true, (IntPtr)250, 1 };
-        yield return new object[] { true, false, (IntPtr)250, 1 };
-        yield return new object[] { false, true, IntPtr.Zero, 0 };
-        yield return new object[] { false, false, IntPtr.Zero, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PrintClientWithoutHandleWithWParam_TestData))]
-    public void Control_WndProc_InvokePrintClientWithoutHandleWithWParam_Success(bool userPaint, bool opaque, IntPtr expectedResult, int expectedPaintCallCount)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserPaint, userPaint);
-            control.SetStyle(ControlStyles.Opaque, opaque);
-            int paintCallCount = 0;
-            control.Paint += (sender, e) => paintCallCount++;
-
-            using var image = new Bitmap(10, 10);
-            using Graphics graphics = Graphics.FromImage(image);
-            IntPtr hdc = graphics.GetHdc();
-            try
-            {
-                var m = new Message
-                {
-                    Msg = (int)PInvoke.WM_PRINTCLIENT,
-                    WParam = hdc,
-                    Result = (IntPtr)250
-                };
-                control.WndProc(ref m);
-                Assert.Equal(expectedResult, m.Result);
-                Assert.False(control.IsHandleCreated);
-                Assert.Equal(expectedPaintCallCount, paintCallCount);
-            }
-            finally
-            {
-                graphics.ReleaseHdc();
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_PrintClientWithHandleWithoutWParam_TestData()
-    {
-        yield return new object[] { true, true, (IntPtr)250, 0 };
-        yield return new object[] { false, true, IntPtr.Zero, 0 };
-        yield return new object[] { false, false, IntPtr.Zero, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PrintClientWithHandleWithoutWParam_TestData))]
-    public void Control_WndProc_InvokePrintClientWithHandleWithoutWParam_Success(bool userPaint, bool opaque, IntPtr expectedResult, int expectedPaintCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_PRINTCLIENT,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(expectedPaintCallCount, paintCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokePrintClientWithHandleWithoutWParamUserPaint_DoesNotThrow()
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, true);
-        control.SetStyle(ControlStyles.Opaque, false);
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_PRINTCLIENT,
-            Result = (IntPtr)250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, paintCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_PrintClientWithHandleWithWParam_TestData()
-    {
-        yield return new object[] { true, true, (IntPtr)250, 1 };
-        yield return new object[] { true, false, (IntPtr)250, 1 };
-        yield return new object[] { false, true, IntPtr.Zero, 0 };
-        yield return new object[] { false, false, IntPtr.Zero, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_PrintClientWithHandleWithWParam_TestData))]
-    public void Control_WndProc_InvokePrintClientWithHandleWithWParam_Success(bool userPaint, bool opaque, IntPtr expectedResult, int expectedPaintCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PRINTCLIENT,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.Equal(expectedPaintCallCount, paintCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_MouseDown_TestData()
-    {
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, -1, -2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void Control_WndProc_InvokeMouseDownWithoutHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            int callCount = 0;
-            control.MouseDown += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void Control_WndProc_InvokeMouseDownWithoutHandleNotSelectable_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            control.SetStyle(ControlStyles.Selectable, false);
-            int callCount = 0;
-            control.MouseDown += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_LBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_MBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_MBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_RBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_RBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_XBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_XBUTTONDBLCLK)]
-    public void Control_WndProc_InvokeMouseDownWithoutHandleNotEnabled_DoesNotCallMouseDown(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl
-            {
-                Enabled = false
-            };
-            int callCount = 0;
-            control.MouseDown += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void Control_WndProc_InvokeMouseDownWithHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void Control_WndProc_InvokeMouseDownWithHandleNotSelectable_DoesNotCallMouseDown(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        control.SetStyle(ControlStyles.Selectable, false);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_LBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_MBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_MBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_RBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_RBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_XBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_XBUTTONDBLCLK)]
-    public void Control_WndProc_InvokeMouseDownWithHandleNotEnabled_DoesNotCallMouseDown(int msg)
-    {
-        using var control = new SubControl
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = msg,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeMouseHoverWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int callCount = 0;
-            control.MouseHover += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_MOUSEHOVER,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_MouseUp_TestData()
-    {
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONUP, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, -1, -2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void Control_WndProc_InvokeMouseUpWithoutHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            int callCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void Control_WndProc_InvokeMouseUpWithoutHandleNotSelectable_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            control.SetStyle(ControlStyles.Selectable, false);
-            int callCount = 0;
-            control.MouseUp += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONUP)]
-    [InlineData((int)PInvoke.WM_MBUTTONUP)]
-    [InlineData((int)PInvoke.WM_RBUTTONUP)]
-    [InlineData((int)PInvoke.WM_XBUTTONUP)]
-    public void Control_WndProc_InvokeMouseUpWithoutHandleNotEnabled_CallsMouseUp(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl
-            {
-                Enabled = false
-            };
-            int callCount = 0;
-            control.MouseUp += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void Control_WndProc_InvokeMouseUpWithHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseUp_TestData))]
-    public void Control_WndProc_InvokeMouseUpWithHandleNotSelectable_DoesNotCallMouseUp(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        control.SetStyle(ControlStyles.Selectable, false);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONUP)]
-    [InlineData((int)PInvoke.WM_MBUTTONUP)]
-    [InlineData((int)PInvoke.WM_RBUTTONUP)]
-    [InlineData((int)PInvoke.WM_XBUTTONUP)]
-    public void Control_WndProc_InvokeMouseUpWithHandleNotEnabled_CallsMouseUp(int msg)
-    {
-        using var control = new SubControl
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseUp += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = msg,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            int callCount = 0;
-            control.GotFocus += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_SETFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithHandle_Success()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithParentContainerControlWithHandle_Success()
-    {
-        using var parent = new ContainerControl();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Null(parent.ActiveControl);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.Same(control, parent.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_SetFocusWithParentIContainer_TestData()
-    {
-        yield return new object[] { true, true, IntPtr.Zero, 1, 1 };
-        yield return new object[] { true, false, (IntPtr)250, 1, 0 };
-        yield return new object[] { false, true, IntPtr.Zero, 0, 1 };
-        yield return new object[] { false, false, IntPtr.Zero, 0, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_SetFocusWithParentIContainer_TestData))]
-    public void Control_WndProc_InvokeSetFocusWithParentIContainerControlWithHandle_Success(bool containerControl, bool enabled, IntPtr expectedResult, int expectedActivateControlCallCount, int expectedCallCount)
-    {
-        using var parent = new CustomContainerControl();
-        parent.SetStyle(ControlStyles.ContainerControl, containerControl);
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Null(parent.ActiveControl);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int activateControlCallCount = 0;
-        parent.ActivateControlAction = (active) =>
-        {
-            Assert.Same(control, active);
-            activateControlCallCount++;
-            return enabled;
-        };
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.Equal(expectedActivateControlCallCount, activateControlCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class CustomContainerControl : Control, IContainerControl
-    {
-        public CustomContainerControl()
-        {
-            SetStyle(ControlStyles.ContainerControl, true);
-        }
-
-        public Control ActiveControl { get; set; }
-
-        public Func<Control, bool> ActivateControlAction { get; set; }
-
-        public bool ActivateControl(Control active) => ActivateControlAction(active);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithParentContainerControlWithParentContainerControlWithHandle_Success()
-    {
-        using var grandparent = new ContainerControl();
-        using var parent = new ContainerControl
-        {
-            Parent = grandparent
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Null(parent.ActiveControl);
-        Assert.Null(grandparent.ActiveControl);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.Same(control, parent.ActiveControl);
-        Assert.Same(parent, grandparent.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithParentContainerControlWithParentControlWithHandle_Success()
-    {
-        using var grandparent = new Control();
-        using var parent = new ContainerControl
-        {
-            Parent = grandparent
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Null(parent.ActiveControl);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.Same(control, parent.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithParentContainerControlWithParentContainerControlAlreadyActiveWithHandle_Success()
-    {
-        using var grandparent = new ContainerControl();
-        using var parent = new ContainerControl
-        {
-            Parent = grandparent
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        parent.ActiveControl = control;
-        grandparent.ActiveControl = parent;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.Same(control, parent.ActiveControl);
-        Assert.Same(parent, grandparent.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFocusWithParentContainerControlWithParentWithHandle_Success()
-    {
-        using var grandparent = new Control();
-        using var parent = new ContainerControl
-        {
-            Parent = grandparent
-        };
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        Assert.Null(parent.ActiveControl);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.Same(control, parent.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFontWithoutHandle_ReturnsExpected()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubControl();
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_SETFONT,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSetFontWithHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFONT,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class NoCreateControl : Control
-    {
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.WM_NCCREATE)
-            {
-                m.Result = IntPtr.Zero;
-                return;
-            }
-            else
-            {
-                base.WndProc(ref m);
-            }
-        }
-
-        public new void CreateHandle() => base.CreateHandle();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Properties.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Properties.cs
deleted file mode 100644
index 3c442ed2e7b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.Properties.cs
+++ /dev/null
@@ -1,13793 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Windows.Forms.Layout;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlTests
-{
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Control_AccessibilityObject_Get_ReturnsExpected(bool createControl)
-    {
-        using var control = new Control();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Control.ControlAccessibleObject accessibleObject = Assert.IsType<Control.ControlAccessibleObject>(control.AccessibilityObject);
-        Assert.Same(accessibleObject, control.AccessibilityObject);
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.Same(control, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void Control_AccessibilityObject_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Control.ControlAccessibleObject accessibleObject = Assert.IsType<Control.ControlAccessibleObject>(control.AccessibilityObject);
-        Assert.Same(accessibleObject, control.AccessibilityObject);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Same(control, accessibleObject.Owner);
-    }
-
-    public static IEnumerable<object[]> AccessibilityObject_CustomCreateAccessibilityInstance_TestData()
-    {
-        yield return new object[] { null, null };
-
-        var accessibleObject = new AccessibleObject();
-        yield return new object[] { accessibleObject, accessibleObject };
-
-        var controlAccessibleObject = new Control.ControlAccessibleObject(new Control());
-        yield return new object[] { controlAccessibleObject, controlAccessibleObject };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityObject_CustomCreateAccessibilityInstance_TestData))]
-    public void Control_AccessibilityObject_GetCustomCreateAccessibilityInstance_ReturnsExpected(AccessibleObject result, AccessibleObject expected)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new CustomCreateAccessibilityInstanceControl
-            {
-                CreateAccessibilityResult = result
-            };
-            Assert.Same(expected, control.AccessibilityObject);
-            Assert.Same(control.AccessibilityObject, control.AccessibilityObject);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    private class CustomCreateAccessibilityInstanceControl : Control
-    {
-        public AccessibleObject CreateAccessibilityResult { get; set; }
-
-        protected override AccessibleObject CreateAccessibilityInstance() => CreateAccessibilityResult;
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Control_AccessibleDefaultActionDescription_Set_GetReturnsExpected(string value)
-    {
-        using var control = new Control
-        {
-            AccessibleDefaultActionDescription = value
-        };
-        Assert.Equal(value, control.AccessibleDefaultActionDescription);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AccessibleDefaultActionDescription = value;
-        Assert.Equal(value, control.AccessibleDefaultActionDescription);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Control_AccessibleDescription_Set_GetReturnsExpected(string value)
-    {
-        using var control = new Control
-        {
-            AccessibleDescription = value
-        };
-        Assert.Equal(value, control.AccessibleDescription);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AccessibleDescription = value;
-        Assert.Equal(value, control.AccessibleDescription);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Control_AccessibleName_Set_GetReturnsExpected(string value)
-    {
-        using var control = new Control
-        {
-            AccessibleName = value
-        };
-        Assert.Equal(value, control.AccessibleName);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AccessibleName = value;
-        Assert.Equal(value, control.AccessibleName);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleRole>]
-    public void Control_AccessibleRole_Set_GetReturnsExpected(AccessibleRole value)
-    {
-        using var control = new Control
-        {
-            AccessibleRole = value
-        };
-        Assert.Equal(value, control.AccessibleRole);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AccessibleRole = value;
-        Assert.Equal(value, control.AccessibleRole);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AccessibleRole>]
-    public void Control_AccessibleRole_SetInvalidValue_ThrowsInvalidEnumArgumentException(AccessibleRole value)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AccessibleRole = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_AllowDrop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_AllowDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DropTargetMock dropTarget = new();
-        Assert.Equal(ApartmentState.STA, Application.OleRequired());
-        Assert.Equal(HRESULT.S_OK, PInvoke.RegisterDragDrop(control, dropTarget));
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Fact] // non-UI thread
-    public void Control_AllowDrop_SetWithHandleNonSTAThread_ThrowsInvalidOperationException()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<InvalidOperationException>(() => control.AllowDrop = true);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Can set to false.
-        control.AllowDrop = false;
-        Assert.False(control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Anchor_Set_TestData()
-    {
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left };
-        yield return new object[] { AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right };
-
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right };
-
-        yield return new object[] { AnchorStyles.None, AnchorStyles.None };
-        yield return new object[] { (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-        yield return new object[] { (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void Control_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void Control_Anchor_SetWithOldValue_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new Control
-        {
-            Anchor = AnchorStyles.Left
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Anchor_SetWithParent_TestData()
-    {
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 0, 0 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left, 1, 1 };
-        yield return new object[] { AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right, 1, 1 };
-
-        yield return new object[] { AnchorStyles.None, AnchorStyles.None, 1, 1 };
-        yield return new object[] { (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2 };
-        yield return new object[] { (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithParent_TestData))]
-    public void Control_Anchor_SetWithParent_GetReturnsExpected(AnchorStyles value, AnchorStyles expected, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithParent_TestData))]
-    public void Control_Anchor_SetWithGrandparent_GetReturnsExpected(AnchorStyles value, AnchorStyles expected, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        int grandparentLayoutCallCount = 0;
-        void grandparentHandler(object sender, LayoutEventArgs e)
-        {
-            grandparentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        grandparent.Layout += grandparentHandler;
-
-        try
-        {
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-            grandparent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Anchor_SetWithOldValueWithParent_TestData()
-    {
-        foreach (AnchorStyles oldValue in new AnchorStyles[] { AnchorStyles.Left, AnchorStyles.Top, AnchorStyles.Right, AnchorStyles.Left })
-        {
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-            yield return new object[] { oldValue, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, 1, 1 };
-            yield return new object[] { oldValue, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-            yield return new object[] { oldValue, AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, 1, 1 };
-
-            yield return new object[] { oldValue, AnchorStyles.None, AnchorStyles.None, 1, 1 };
-            yield return new object[] { oldValue, (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2 };
-            yield return new object[] { oldValue, (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2 };
-        }
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top, AnchorStyles.Top, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top, AnchorStyles.Top, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top, AnchorStyles.Top, 1, 1 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top, AnchorStyles.Top, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom, AnchorStyles.Bottom, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Left, AnchorStyles.Left, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Left, AnchorStyles.Left, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left, AnchorStyles.Left, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Left, AnchorStyles.Left, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Right, AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Right, AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Right, AnchorStyles.Right, 1, 1 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right, AnchorStyles.Right, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithOldValueWithParent_TestData))]
-    public void Control_Anchor_SetWithOldValueWithParent_GetReturnsExpected(AnchorStyles oldValue, AnchorStyles value, AnchorStyles expected, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Anchor = oldValue,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Anchor_SetWithOldValueWithGrandparent_TestData()
-    {
-        foreach (AnchorStyles oldValue in new AnchorStyles[] { AnchorStyles.Left, AnchorStyles.Top, AnchorStyles.Right, AnchorStyles.Left })
-        {
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, 1, 1, 0, 0 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-            yield return new object[] { oldValue, AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, 1, 1, 0, 0 };
-
-            yield return new object[] { oldValue, AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, 1, 1, 0, 0 };
-            yield return new object[] { oldValue, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-
-            yield return new object[] { oldValue, AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-
-            yield return new object[] { oldValue, (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2, 0, 0 };
-            yield return new object[] { oldValue, (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 2, 0, 0 };
-        }
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 1, 1, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, 1, 1, 0, 0 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.None, AnchorStyles.None, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.None, AnchorStyles.None, 1, 1, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.None, AnchorStyles.None, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.None, AnchorStyles.None, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top, AnchorStyles.Top, 0, 0, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Top, AnchorStyles.Top, 1, 1, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Top, AnchorStyles.Top, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Top, AnchorStyles.Top, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom, AnchorStyles.Bottom, 0, 0, 0, 0 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Bottom, AnchorStyles.Bottom, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Left, AnchorStyles.Left, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Left, AnchorStyles.Left, 1, 1, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left, AnchorStyles.Left, 0, 0, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Left, AnchorStyles.Left, 1, 1, 1, 1 };
-
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Right, AnchorStyles.Right, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Right, AnchorStyles.Right, 1, 1, 1, 1 };
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Right, AnchorStyles.Right, 1, 1, 0, 0 };
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right, AnchorStyles.Right, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithOldValueWithGrandparent_TestData))]
-    public void Control_Anchor_SetWithOldValueWithGrandparent_GetReturnsExpected(AnchorStyles oldValue, AnchorStyles value, AnchorStyles expected, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2, int expectedGrandparentLayoutCallCount1, int expectedGrandparentLayoutCallCount2)
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Anchor = oldValue,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        int grandparentLayoutCallCount = 0;
-        void grandparentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(grandparent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            grandparentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        grandparent.Layout += grandparentHandler;
-
-        try
-        {
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedGrandparentLayoutCallCount1, grandparentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Anchor = value;
-            Assert.Equal(expected, control.Anchor);
-            Assert.Equal(DockStyle.None, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedGrandparentLayoutCallCount2, grandparentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-            grandparent.Layout -= grandparentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Anchor_SetWithDock_TestData()
-    {
-        foreach (DockStyle dock in Enum.GetValues(typeof(DockStyle)))
-        {
-            yield return new object[] { dock, AnchorStyles.Top, AnchorStyles.Top, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, dock };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-            yield return new object[] { dock, AnchorStyles.Bottom, AnchorStyles.Bottom, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-            yield return new object[] { dock, AnchorStyles.Left, AnchorStyles.Left, DockStyle.None };
-            yield return new object[] { dock, AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-            yield return new object[] { dock, AnchorStyles.Right, AnchorStyles.Right, DockStyle.None };
-
-            yield return new object[] { dock, AnchorStyles.None, AnchorStyles.None, DockStyle.None };
-            yield return new object[] { dock, (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-            yield return new object[] { dock, (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithDock_TestData))]
-    public void Control_Anchor_SetWithDock_GetReturnsExpected(DockStyle dock, AnchorStyles value, AnchorStyles expectedAnchor, DockStyle expectedDock)
-    {
-        using var control = new Control
-        {
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Anchor = value;
-        Assert.Equal(expectedAnchor, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expectedAnchor, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Anchor_SetWithDockWithParent_TestData()
-    {
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.Bottom, DockStyle.Fill, DockStyle.Left, DockStyle.Right, DockStyle.Top })
-        {
-            yield return new object[] { dock, AnchorStyles.Top, AnchorStyles.Top, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, dock, 0 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-
-            yield return new object[] { dock, AnchorStyles.Bottom, AnchorStyles.Bottom, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-
-            yield return new object[] { dock, AnchorStyles.Left, AnchorStyles.Left, DockStyle.None, 1 };
-            yield return new object[] { dock, AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-
-            yield return new object[] { dock, AnchorStyles.Right, AnchorStyles.Right, DockStyle.None, 1 };
-
-            yield return new object[] { dock, AnchorStyles.None, AnchorStyles.None, DockStyle.None, 1 };
-            yield return new object[] { dock, (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-            yield return new object[] { dock, (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_SetWithDockWithParent_TestData))]
-    public void Control_Anchor_SetWithDockWithParent_GetReturnsExpected(DockStyle dock, AnchorStyles value, AnchorStyles expectedAnchor, DockStyle expectedDock, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent,
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            if (e.AffectedProperty == "Dock")
-            {
-                Assert.Same(parent, sender);
-                Assert.Same(control, e.AffectedControl);
-                parentLayoutCallCount++;
-            }
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Anchor = value;
-            Assert.Equal(expectedAnchor, control.Anchor);
-            Assert.Equal(expectedDock, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Anchor = value;
-            Assert.Equal(expectedAnchor, control.Anchor);
-            Assert.Equal(expectedDock, control.Dock);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void Control_Anchor_SetWithHandle_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void Control_AutoScrollOffset_Set_GetReturnsExpected(Point value)
-    {
-        using var control = new Control
-        {
-            AutoScrollOffset = value
-        };
-        Assert.Equal(value, control.AutoScrollOffset);
-
-        // Set same.
-        control.AutoScrollOffset = value;
-        Assert.Equal(value, control.AutoScrollOffset);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_AutoSize_SetWithParent_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_AutoSize_SetWithParentWithCustomLayoutEngine_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        var mockLayoutEngine = new Mock<LayoutEngine>(MockBehavior.Strict);
-        mockLayoutEngine
-            .Setup(e => e.Layout(parent, It.IsAny<LayoutEventArgs>()))
-            .Returns(false)
-            .Verifiable();
-        mockLayoutEngine
-            .Setup(e => e.InitLayout(control, BoundsSpecified.None));
-        parent.SetLayoutEngine(mockLayoutEngine.Object);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            mockLayoutEngine.Verify(e => e.Layout(parent, It.IsAny<LayoutEventArgs>()), Times.Exactly(expectedLayoutCallCount));
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            mockLayoutEngine.Verify(e => e.Layout(parent, It.IsAny<LayoutEventArgs>()), Times.Exactly(expectedLayoutCallCount));
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount + 1, parentLayoutCallCount);
-            mockLayoutEngine.Verify(e => e.Layout(parent, It.IsAny<LayoutEventArgs>()), Times.Exactly(expectedLayoutCallCount + 1));
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_AutoSize_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_AutoSize_SetWithParentWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new Control
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void Control_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new Control
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void Control_BackColor_SetWithCustomOldValue_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new Control
-        {
-            BackColor = Color.YellowGreen
-        };
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetTransparent_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.Empty, Control.DefaultBackColor };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetTransparent_TestData))]
-    public void Control_BackColor_SetTransparent_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void Control_BackColor_SetWithChildren_GetReturnsExpected(Color value, Color expected)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, child1.BackColor);
-        Assert.Equal(expected, child2.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, child1.BackColor);
-        Assert.Equal(expected, child2.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void Control_BackColor_SetWithChildrenWithColor_GetReturnsExpected(Color value, Color expected)
-    {
-        using var child1 = new Control
-        {
-            BackColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            BackColor = Color.YellowGreen
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void Control_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_SetWithHandlerInDisposing_DoesNotCallBackColorChanged()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackColorChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.BackColor = Color.Red;
-            Assert.Equal(Color.Red, control.BackColor);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_SetWithChildrenWithHandler_CallsBackColorChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount - 1, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1 - 1, childCallCount2);
-            childCallCount2++;
-        };
-        control.BackColorChanged += handler;
-        child1.BackColorChanged += childHandler1;
-        child2.BackColorChanged += childHandler2;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Red, child1.BackColor);
-        Assert.Equal(Color.Red, child2.BackColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Red, child1.BackColor);
-        Assert.Equal(Color.Red, child2.BackColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(Control.DefaultBackColor, child1.BackColor);
-        Assert.Equal(Control.DefaultBackColor, child2.BackColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        child1.BackColorChanged -= childHandler1;
-        child2.BackColorChanged -= childHandler2;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Red, child1.BackColor);
-        Assert.Equal(Color.Red, child2.BackColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_SetWithChildrenWithBackColorWithHandler_CallsBackColorChanged()
-    {
-        using var child1 = new Control
-        {
-            BackColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            BackColor = Color.YellowGreen
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.BackColorChanged += handler;
-        child1.BackColorChanged += childHandler1;
-        child2.BackColorChanged += childHandler2;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        child1.BackColorChanged -= childHandler1;
-        child2.BackColorChanged -= childHandler2;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Yellow, child1.BackColor);
-        Assert.Equal(Color.YellowGreen, child2.BackColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_SetTransparent_ThrowsArgmentException()
-    {
-        using var control = new Control();
-        Assert.Throws<ArgumentException>(() => control.BackColor = Color.FromArgb(254, 1, 2, 3));
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.BackColor)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.BackColor)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void Control_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new Control
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackgroundImage_SetWithHandle_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10), 1 };
-        yield return new object[] { null, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_SetWithHandle_TestData))]
-    public void Control_BackgroundImage_SetWithHandle_GetReturnsExpected(Image value, int expectedInvalidatedCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void Control_BackgroundImage_SetWithChildren_GetReturnsExpected(Image value)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void Control_BackgroundImage_SetWithChildrenWithBackgroundImage_GetReturnsExpected(Image value)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var child1 = new Control
-        {
-            BackgroundImage = image1
-        };
-        using var child2 = new Control
-        {
-            BackgroundImage = image2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.Same(image1, child1.BackgroundImage);
-        Assert.Same(image2, child2.BackgroundImage);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.Same(image1, child1.BackgroundImage);
-        Assert.Same(image2, child2.BackgroundImage);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImage_SetWithHandlerInDisposing_DoesNotCallBackgroundImageChanged()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackgroundImageChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            var value = new Bitmap(10, 10);
-            control.BackgroundImage = value;
-            Assert.Same(value, control.BackgroundImage);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImage_SetWithChildrenWithHandler_CallsBackgroundImageChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2CallCount++;
-        };
-        control.BackgroundImageChanged += handler;
-        child1.BackgroundImageChanged += childHandler1;
-        child2.BackgroundImageChanged += childHandler2;
-
-        // Set different.
-        var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set different.
-        var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        child1.BackgroundImageChanged -= childHandler1;
-        child2.BackgroundImageChanged -= childHandler2;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Null(child1.BackgroundImage);
-        Assert.Null(child2.BackgroundImage);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImage_SetWithChildrenWithBackgroundImageWithHandler_CallsBackgroundImageChanged()
-    {
-        using var childBackgroundImage1 = new Bitmap(10, 10);
-        using var childBackgroundImage2 = new Bitmap(10, 10);
-        using var child1 = new Control
-        {
-            BackgroundImage = childBackgroundImage1
-        };
-        using var child2 = new Control
-        {
-            BackgroundImage = childBackgroundImage2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2CallCount++;
-        };
-        control.BackgroundImageChanged += handler;
-        child1.BackgroundImageChanged += childHandler1;
-        child2.BackgroundImageChanged += childHandler2;
-
-        // Set different.
-        var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Same(childBackgroundImage1, child1.BackgroundImage);
-        Assert.Same(childBackgroundImage2, child2.BackgroundImage);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Same(childBackgroundImage1, child1.BackgroundImage);
-        Assert.Same(childBackgroundImage2, child2.BackgroundImage);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set different.
-        var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Same(childBackgroundImage1, child1.BackgroundImage);
-        Assert.Same(childBackgroundImage2, child2.BackgroundImage);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Same(childBackgroundImage1, child1.BackgroundImage);
-        Assert.Same(childBackgroundImage2, child2.BackgroundImage);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        child1.BackgroundImageChanged -= childHandler1;
-        child2.BackgroundImageChanged -= childHandler2;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Same(childBackgroundImage1, child1.BackgroundImage);
-        Assert.Same(childBackgroundImage2, child2.BackgroundImage);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void Control_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubControl
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ImageLayout.Center, 1)]
-    [InlineData(ImageLayout.None, 1)]
-    [InlineData(ImageLayout.Stretch, 1)]
-    [InlineData(ImageLayout.Tile, 0)]
-    [InlineData(ImageLayout.Zoom, 1)]
-    public void Control_BackgroundImageLayout_SetWithHandle_GetReturnsExpected(ImageLayout value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> BackgroundImageLayout_SetWithBackgroundImage_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Center, true };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Stretch, true };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Zoom, true };
-
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), ImageLayout.None, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), ImageLayout.Tile, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), ImageLayout.Center, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), ImageLayout.Stretch, false };
-        yield return new object[] { new Bitmap(10, 10, PixelFormat.Format32bppRgb), ImageLayout.Zoom, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImageLayout_SetWithBackgroundImage_TestData))]
-    public void Control_BackgroundImageLayout_SetWithBackgroundImage_GetReturnsExpected(Image backgroundImage, ImageLayout value, bool expectedDoubleBuffered)
-    {
-        using var control = new SubControl
-        {
-            BackgroundImage = backgroundImage,
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.Equal(expectedDoubleBuffered, control.DoubleBuffered);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.Equal(expectedDoubleBuffered, control.DoubleBuffered);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BackgroundImageLayout_SetWithHandlerInDisposing_DoesNotCallBackgroundImageLayoutChanged()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.BackgroundImageLayoutChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.BackgroundImageLayout = ImageLayout.Center;
-            Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void Control_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsFact]
-    public void Control_BindingContext_GetWithParent_ReturnsExpected()
-    {
-        var bindingContext = new BindingContext();
-        using var parent = new Control
-        {
-            BindingContext = bindingContext
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(bindingContext, control.BindingContext);
-    }
-
-    [WinFormsFact]
-    public void Control_BindingContext_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        var bindingContext = new BindingContext();
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            BindingContext = bindingContext
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Null(control.BindingContext);
-    }
-
-    public static IEnumerable<object[]> BindingContext_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new BindingContext() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void Control_BindingContext_Set_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new Control
-        {
-            BindingContext = value
-        };
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void Control_BindingContext_SetWithNonNullBindingContext_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new Control
-        {
-            BindingContext = new BindingContext()
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_BindingContext_SetWithHandler_CallsBindingContextChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_BindingContext_SetWithChildrenWithHandler_CallsBindingContextChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.BindingContextChanged += handler;
-        child1.BindingContextChanged += childHandler1;
-        child2.BindingContextChanged += childHandler2;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(context1, child1.BindingContext);
-        Assert.Same(context1, child2.BindingContext);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(context1, child1.BindingContext);
-        Assert.Same(context1, child2.BindingContext);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Same(context2, child1.BindingContext);
-        Assert.Same(context2, child2.BindingContext);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Null(child1.BindingContext);
-        Assert.Null(child2.BindingContext);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, childCallCount1);
-        Assert.Equal(3, childCallCount2);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        child1.BindingContextChanged -= childHandler1;
-        child2.BindingContextChanged -= childHandler2;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(context1, child1.BindingContext);
-        Assert.Same(context1, child2.BindingContext);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, childCallCount1);
-        Assert.Equal(3, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_BindingContext_SetWithChildrenWithBindingContextWithHandler_CallsBindingContextChanged()
-    {
-        var childContext1 = new BindingContext();
-        var childContext2 = new BindingContext();
-        using var child1 = new Control
-        {
-            BindingContext = childContext1
-        };
-        using var child2 = new Control
-        {
-            BindingContext = childContext2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.BindingContextChanged += handler;
-        child1.BindingContextChanged += childHandler1;
-        child2.BindingContextChanged += childHandler2;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(childContext1, child1.BindingContext);
-        Assert.Same(childContext2, child2.BindingContext);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(childContext1, child1.BindingContext);
-        Assert.Same(childContext2, child2.BindingContext);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Same(childContext1, child1.BindingContext);
-        Assert.Same(childContext2, child2.BindingContext);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Same(childContext1, child1.BindingContext);
-        Assert.Same(childContext2, child2.BindingContext);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        child1.BindingContextChanged -= childHandler1;
-        child2.BindingContextChanged -= childHandler2;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Same(childContext1, child1.BindingContext);
-        Assert.Same(childContext2, child2.BindingContext);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_TestData))]
-    public void Control_Bounds_Set_GetReturnsExpected(int x, int y, int width, int height, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithConstrainedSize_TestData))]
-    public void Control_Bounds_SetWithConstrainedSize_GetReturnsExpected(Size minimumSize, Size maximumSize, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithCustomStyle_TestData))]
-    public void Control_Bounds_SetWithCustomStyle_GetReturnsExpected(int x, int y, int width, int height, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithParent_TestData))]
-    public void Control_Bounds_SetWithParent_GetReturnsExpected(int x, int y, int width, int height, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Bounds = new Rectangle(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Bounds = new Rectangle(x, y, width, height);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithHandle_TestData))]
-    public void Control_Bounds_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_Int_Int_Int_Int_WithParentWithHandle_TestData))]
-    public void Control_Bounds_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Bounds = new Rectangle(x, y, width, height);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Bounds = new Rectangle(x, y, width, height);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + expectedWidth, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void Control_CanFocus_GetWithHandle_ReturnsExpected(bool enabled, bool visible)
-    {
-        using var control = new Control
-        {
-            Enabled = enabled,
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.CanFocus);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void Control_CanSelect_Get_ReturnsExpected(bool enabled, bool visible, bool expected)
-    {
-        using var control = new Control
-        {
-            Enabled = enabled,
-            Visible = visible
-        };
-        Assert.Equal(expected, control.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void Control_CanSelect_GetWithParent_ReturnsExpected(bool enabled, bool visible, bool expected)
-    {
-        using var parent = new Control
-        {
-            Enabled = enabled,
-            Visible = visible
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Equal(expected, control.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void Control_CanSelect_GetWithHandle_ReturnsExpected(bool enabled, bool visible, bool expected)
-    {
-        using var control = new Control
-        {
-            Enabled = enabled,
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void Control_CanSelect_GetWithParentWithHandle_ReturnsExpected(bool enabled, bool visible, bool expected)
-    {
-        using var parent = new Control
-        {
-            Enabled = enabled,
-            Visible = visible
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        Assert.Equal(expected, control.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Capture_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            Capture = value
-        };
-        Assert.Equal(value, control.Capture);
-        Assert.Equal(value, control.IsHandleCreated);
-
-        // Set same.
-        control.Capture = value;
-        Assert.Equal(value, control.Capture);
-        Assert.Equal(value, control.IsHandleCreated);
-
-        // Set different.
-        control.Capture = !value;
-        Assert.Equal(!value, control.Capture);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Capture_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Capture = value;
-        Assert.Equal(value, control.Capture);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Capture = value;
-        Assert.Equal(value, control.Capture);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Capture = !value;
-        Assert.Equal(!value, control.Capture);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_CausesValidation_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_CausesValidation_SetWithHandler_CallsCausesValidationChanged()
-    {
-        using var control = new Control
-        {
-            CausesValidation = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CausesValidationChanged += handler;
-
-        // Set different.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.CausesValidation = true;
-        Assert.True(control.CausesValidation);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> ClientSize_Get_TestData()
-    {
-        yield return new object[] { new Control(), Size.Empty };
-        yield return new object[] { new NonZeroWidthBorderedControl(), Size.Empty };
-        yield return new object[] { new NonZeroHeightBorderedControl(), Size.Empty };
-        yield return new object[] { new NonZeroWidthNonZeroHeightBorderedControl(), new Size(6, 16) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_Get_TestData))]
-    public void Control_ClientSize_Get_ReturnsExpected(Control control, Size expected)
-    {
-        Assert.Equal(expected, control.ClientSize);
-    }
-
-    private class NonZeroWidthBorderedControl : BorderedControl
-    {
-        protected override Size DefaultSize => new(10, 0);
-    }
-
-    private class NonZeroHeightBorderedControl : BorderedControl
-    {
-        protected override Size DefaultSize => new(0, 10);
-    }
-
-    private class NonZeroWidthNonZeroHeightBorderedControl : BorderedControl
-    {
-        protected override Size DefaultSize => new(10, 20);
-    }
-
-    public static IEnumerable<object[]> ClientSize_Set_TestData()
-    {
-        yield return new object[] { new Size(10, 20), 1 };
-        yield return new object[] { new Size(1, 2), 1 };
-        yield return new object[] { new Size(0, 0), 0 };
-        yield return new object[] { new Size(-1, -2), 1 };
-        yield return new object[] { new Size(-1, 2), 1 };
-        yield return new object[] { new Size(1, -2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_Set_TestData))]
-    public void Control_ClientSize_Set_GetReturnsExpected(Size value, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ClientSize_SetWithCustomStyle_TestData()
-    {
-        yield return new object[] { new Size(10, 20), new Size(14, 24) };
-        yield return new object[] { new Size(1, 2), new Size(5, 6) };
-        yield return new object[] { new Size(0, 0), new Size(4, 4) };
-        yield return new object[] { new Size(-1, -2), new Size(3, 2) };
-        yield return new object[] { new Size(-1, 2), new Size(3, 6) };
-        yield return new object[] { new Size(1, -2), new Size(5, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_SetWithCustomStyle_TestData))]
-    public void Control_ClientSize_SetWithCustomStyle_GetReturnsExpected(Size value, Size expectedSize)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ClientSize_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, new Size(1, 2), new Size(1, 2), 1, 1 };
-        yield return new object[] { true, new Size(0, 0), new Size(0, 0), 0, 0 };
-        yield return new object[] { true, new Size(-1, -2), new Size(0, 0), 0, 0 };
-        yield return new object[] { true, new Size(-1, 2), new Size(0, 2), 1, 1 };
-        yield return new object[] { true, new Size(1, -2), new Size(1, 0), 1, 1 };
-
-        yield return new object[] { false, new Size(1, 2), new Size(1, 2), 1, 0 };
-        yield return new object[] { false, new Size(0, 0), new Size(0, 0), 0, 0 };
-        yield return new object[] { false, new Size(-1, -2), new Size(0, 0), 0, 0 };
-        yield return new object[] { false, new Size(-1, 2), new Size(0, 2), 1, 0 };
-        yield return new object[] { false, new Size(1, -2), new Size(1, 0), 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClientSize_SetWithHandle_TestData))]
-    public void Control_ClientSize_SetWithHandle_GetReturnsExpected(bool resizeRedraw, Size value, Size expectedSize, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ClientSize = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, value), control.DisplayRectangle);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedSize.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedSize.Height, control.Bottom);
-        Assert.Equal(expectedSize.Width, control.Width);
-        Assert.Equal(expectedSize.Height, control.Height);
-        Assert.Equal(new Rectangle(Point.Empty, expectedSize), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ClientSize_SetWithHandler_CallsClientSizeChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        int sizeChangedCallCount = 0;
-        EventHandler sizeChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += handler;
-        control.SizeChanged += sizeChangedHandler;
-
-        control.ClientSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(2, callCount);
-        Assert.Equal(1, sizeChangedCallCount);
-
-        // Set same.
-        control.ClientSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(3, callCount);
-        Assert.Equal(1, sizeChangedCallCount);
-
-        // Set different.
-        control.ClientSize = new Size(11, 11);
-        Assert.Equal(new Size(11, 11), control.ClientSize);
-        Assert.Equal(5, callCount);
-        Assert.Equal(2, sizeChangedCallCount);
-
-        // Remove handler.
-        control.ClientSizeChanged -= handler;
-        control.SizeChanged -= sizeChangedHandler;
-        control.ClientSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), control.ClientSize);
-        Assert.Equal(5, callCount);
-        Assert.Equal(2, sizeChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void Control_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new Control
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ContextMenuStrip = value;
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void Control_ContextMenuStrip_SetWithCustomOldValue_GetReturnsExpected(ContextMenuStrip value)
-    {
-        var oldValue = new ContextMenuStrip();
-        using var control = new Control
-        {
-            ContextMenuStrip = oldValue
-        };
-        control.ContextMenuStrip = value;
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ContextMenuStrip = value;
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_ContextMenuStrip_SetDisposeNew_RemovesContextMenuStrip()
-    {
-        using var menu = new ContextMenuStrip();
-        using var control = new Control
-        {
-            ContextMenuStrip = menu
-        };
-        Assert.Same(menu, control.ContextMenuStrip);
-
-        menu.Dispose();
-        Assert.Null(control.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void Control_ContextMenuStrip_SetDisposeOld_RemovesContextMenuStrip()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new Control
-        {
-            ContextMenuStrip = menu1
-        };
-        Assert.Same(menu1, control.ContextMenuStrip);
-
-        control.ContextMenuStrip = menu2;
-        Assert.Same(menu2, control.ContextMenuStrip);
-
-        menu1.Dispose();
-        Assert.Same(menu2, control.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void Control_ContextMenuStrip_SetWithHandler_CallsContextMenuStripChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ContextMenuStripChanged += handler;
-
-        // Set different.
-        using var menu1 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu2;
-        Assert.Same(menu2, control.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.ContextMenuStrip = null;
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.ContextMenuStripChanged -= handler;
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> Controls_CustomCreateControlsInstance_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control.ControlCollection(new Control()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Controls_CustomCreateControlsInstance_TestData))]
-    public void Control_Controls_GetCustomCreateControlsInstance_ReturnsExpected(Control.ControlCollection result)
-    {
-        using var control = new CustomCreateControlsInstanceControl
-        {
-            CreateControlsResult = result
-        };
-        Assert.Same(result, control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomCreateControlsInstanceControl : Control
-    {
-        public Control.ControlCollection CreateControlsResult { get; set; }
-
-        protected override Control.ControlCollection CreateControlsInstance() => CreateControlsResult;
-    }
-
-    [WinFormsFact]
-    public void Control_Controls_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Controls)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        Assert.Empty(control.Controls);
-        Assert.False(property.CanResetValue(control));
-
-        using var child = new Control();
-        control.Controls.Add(child);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Controls_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Controls)];
-        using var control = new Control();
-        Assert.True(property.ShouldSerializeValue(control));
-
-        Assert.Empty(control.Controls);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        using var child = new Control();
-        control.Controls.Add(child);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.True(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_GetUseWaitCursor_ReturnsExpected()
-    {
-        using var cursor = new Cursor((IntPtr)1);
-        using var control = new Control
-        {
-            UseWaitCursor = true
-        };
-        Assert.Same(Cursors.WaitCursor, control.Cursor);
-
-        // Set custom.
-        control.Cursor = cursor;
-        Assert.Same(Cursors.WaitCursor, control.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_GetWithParent_ReturnsExpected()
-    {
-        using var cursor1 = new Cursor((IntPtr)1);
-        using var cursor2 = new Cursor((IntPtr)2);
-        using var parent = new Control
-        {
-            Cursor = cursor1
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(cursor1, control.Cursor);
-
-        // Set custom.
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        using var cursor1 = new Cursor((IntPtr)1);
-        using var cursor2 = new Cursor((IntPtr)2);
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            Cursor = cursor1
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(cursor1, control.Cursor);
-
-        // Set custom.
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_GetWithDefaultCursor_ReturnsExpected()
-    {
-        using var cursor = new Cursor((IntPtr)1);
-        using var control = new CustomDefaultCursorControl();
-        Assert.Same(control.DefaultCursorResult, control.Cursor);
-
-        // Set custom.
-        control.Cursor = cursor;
-        Assert.Same(cursor, control.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_GetWithDefaultCursorWithParent_ReturnsExpected()
-    {
-        using var cursor1 = new Cursor((IntPtr)1);
-        using var cursor2 = new Cursor((IntPtr)2);
-        using var parent = new Control
-        {
-            Cursor = cursor1
-        };
-        using var control = new CustomDefaultCursorControl
-        {
-            Parent = parent
-        };
-        Assert.Same(control.DefaultCursorResult, control.Cursor);
-
-        // Set custom.
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-    }
-
-    private class CustomDefaultCursorControl : Control
-    {
-        public Cursor DefaultCursorResult { get; } = new Cursor((IntPtr)1);
-
-        protected override Cursor DefaultCursor => DefaultCursorResult;
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void Control_Cursor_Set_GetReturnsExpected(Cursor value)
-    {
-        using var control = new Control
-        {
-            Cursor = value
-        };
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void Control_Cursor_SetWithHandle_GetReturnsExpected(Cursor value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void Control_Cursor_SetWithChildren_GetReturnsExpected(Cursor value)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(value ?? Cursors.Default, child1.Cursor);
-        Assert.Same(value ?? Cursors.Default, child2.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(value ?? Cursors.Default, child1.Cursor);
-        Assert.Same(value ?? Cursors.Default, child2.Cursor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void Control_Cursor_SetWithChildrenWithCursor_GetReturnsExpected(Cursor value)
-    {
-        var cursor1 = new Cursor((IntPtr)1);
-        var cursor2 = new Cursor((IntPtr)1);
-        using var child1 = new Control
-        {
-            Cursor = cursor1
-        };
-        using var child2 = new Control
-        {
-            Cursor = cursor2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor2, child2.Cursor);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor2, child2.Cursor);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_SetWithHandler_CallsCursorChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CursorChanged += handler;
-
-        // Set different.
-        using var cursor1 = new Cursor((IntPtr)1);
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var cursor2 = new Cursor((IntPtr)2);
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Cursor = null;
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_SetWithChildrenWithHandler_CallsCursorChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2CallCount++;
-        };
-        control.CursorChanged += handler;
-        child1.CursorChanged += childHandler1;
-        child2.CursorChanged += childHandler2;
-
-        // Set different.
-        using var cursor1 = new Cursor((IntPtr)1);
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor1, child2.Cursor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set same.
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor1, child2.Cursor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, child1CallCount);
-        Assert.Equal(1, child2CallCount);
-
-        // Set different.
-        using var cursor2 = new Cursor((IntPtr)2);
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-        Assert.Same(cursor2, child1.Cursor);
-        Assert.Same(cursor2, child2.Cursor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, child1CallCount);
-        Assert.Equal(2, child2CallCount);
-
-        // Set null.
-        control.Cursor = null;
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, child1.Cursor);
-        Assert.Same(Cursors.Default, child2.Cursor);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        child1.CursorChanged -= childHandler1;
-        child2.CursorChanged -= childHandler2;
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(cursor1, child1.Cursor);
-        Assert.Same(cursor1, child2.Cursor);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, child1CallCount);
-        Assert.Equal(3, child2CallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Cursor_SetWithChildrenWithCursorWithHandler_CallsCursorChanged()
-    {
-        using var childCursor1 = new Cursor((IntPtr)1);
-        using var childCursor2 = new Cursor((IntPtr)2);
-        using var child1 = new Control
-        {
-            Cursor = childCursor1
-        };
-        using var child2 = new Control
-        {
-            Cursor = childCursor2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int child1CallCount = 0;
-        int child2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1CallCount++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2CallCount++;
-        };
-        control.CursorChanged += handler;
-        child1.CursorChanged += childHandler1;
-        child2.CursorChanged += childHandler2;
-
-        // Set different.
-        using var cursor1 = new Cursor((IntPtr)3);
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(childCursor1, child1.Cursor);
-        Assert.Same(childCursor2, child2.Cursor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Set same.
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(childCursor1, child1.Cursor);
-        Assert.Same(childCursor2, child2.Cursor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Set different.
-        using var cursor2 = new Cursor((IntPtr)4);
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-        Assert.Same(childCursor1, child1.Cursor);
-        Assert.Same(childCursor2, child2.Cursor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Set null.
-        control.Cursor = null;
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(childCursor1, child1.Cursor);
-        Assert.Same(childCursor2, child2.Cursor);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        child1.CursorChanged -= childHandler1;
-        child2.CursorChanged -= childHandler2;
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Same(childCursor1, child1.Cursor);
-        Assert.Same(childCursor2, child2.Cursor);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, child1CallCount);
-        Assert.Equal(0, child2CallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void Control_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void Control_Dock_SetWithOldValue_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Control
-        {
-            Dock = DockStyle.Top
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Dock_SetWithParent_TestData()
-    {
-        yield return new object[] { DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Fill, 1 };
-        yield return new object[] { DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.None, 0 };
-        yield return new object[] { DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Top, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_SetWithParent_TestData))]
-    public void Control_Dock_SetWithParent_GetReturnsExpected(DockStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Dock", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Control_Dock_SetWithOldValueWithParent_TestData()
-    {
-        yield return new object[] { DockStyle.Bottom, DockStyle.Bottom, 0 };
-        yield return new object[] { DockStyle.Fill, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.None, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Bottom, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Fill, 1 };
-        yield return new object[] { DockStyle.Fill, DockStyle.Fill, 0 };
-        yield return new object[] { DockStyle.Left, DockStyle.Fill, 1 };
-        yield return new object[] { DockStyle.None, DockStyle.Fill, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Fill, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Fill, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Fill, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Left, 0 };
-        yield return new object[] { DockStyle.None, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Left, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.None, 1 };
-        yield return new object[] { DockStyle.Fill, DockStyle.None, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.None, 1 };
-        yield return new object[] { DockStyle.None, DockStyle.None, 0 };
-        yield return new object[] { DockStyle.Right, DockStyle.None, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.None, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Fill, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.None, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Right, 0 };
-        yield return new object[] { DockStyle.Top, DockStyle.Right, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Fill, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.None, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Top, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Control_Dock_SetWithOldValueWithParent_TestData))]
-    public void Control_Dock_SetWithOldValueWithParent_GetReturnsExpected(DockStyle oldValue, DockStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Dock = oldValue,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Dock", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Dock_SetWithAnchor_TestData()
-    {
-        foreach (AnchorStyles anchor in Enum.GetValues(typeof(AnchorStyles)))
-        {
-            foreach (DockStyle value in Enum.GetValues(typeof(DockStyle)))
-            {
-                yield return new object[] { anchor, value, value == DockStyle.None ? anchor : AnchorStyles.Top | AnchorStyles.Left };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_SetWithAnchor_TestData))]
-    public void Control_Dock_SetWithAnchor_GetReturnsExpected(AnchorStyles anchor, DockStyle value, AnchorStyles expectedAnchor)
-    {
-        using var control = new Control
-        {
-            Anchor = anchor
-        };
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(expectedAnchor, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(expectedAnchor, control.Anchor);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void Control_Dock_SetWithHandle_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new Control
-        {
-            Dock = DockStyle.None
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void Control_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubControl
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false, 1, 2)]
-    [InlineData(true, true, 0, 1)]
-    [InlineData(false, false, 0, 0)]
-    [InlineData(false, true, 0, 0)]
-    public void Control_Enabled_SetWithHandle_GetReturnsExpected(bool userPaint, bool value, int expectedInvalidateCallCount1, int expectedInvalidateCallCount2)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var control = new Control
-        {
-            Enabled = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.EnabledChanged += handler;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Enabled_SetWithChildrenWithHandler_CallsEnabledChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control
-        {
-            Enabled = true
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.EnabledChanged += handler;
-        child1.EnabledChanged += childHandler1;
-        child2.EnabledChanged += childHandler2;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.True(child1.Enabled);
-        Assert.True(child2.Enabled);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        child1.EnabledChanged -= childHandler1;
-        child2.EnabledChanged -= childHandler2;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Enabled_SetWithChildrenDisabledWithHandler_CallsEnabledChanged()
-    {
-        using var child1 = new Control
-        {
-            Enabled = false
-        };
-        using var child2 = new Control
-        {
-            Enabled = false
-        };
-        using var control = new Control
-        {
-            Enabled = true
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.EnabledChanged += handler;
-        child1.EnabledChanged += childHandler1;
-        child2.EnabledChanged += childHandler2;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        child1.EnabledChanged -= childHandler1;
-        child2.EnabledChanged -= childHandler2;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.False(child1.Enabled);
-        Assert.False(child2.Enabled);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Enabled_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Enabled)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.True(control.Enabled);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Enabled_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Enabled)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.True(control.Enabled);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Font_GetWithParent_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new Control
-        {
-            Font = font1
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(font1, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsFact]
-    public void Control_Font_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            Font = font1
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Equal(Control.DefaultFont, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void Control_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubControl
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithFontHeight_TestData()
-    {
-        var font = new Font("Arial", 8.25f);
-        yield return new object[] { null, 10 };
-        yield return new object[] { font, font.Height };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithFontHeight_TestData))]
-    public void Control_Font_SetWithFontHeight_GetReturnsExpected(Font value, int expectedFontHeight)
-    {
-        using var control = new SubControl
-        {
-            FontHeight = 10,
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedFontHeight, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedFontHeight, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetNonNullOldValueWithFontHeight_TestData()
-    {
-        var font = new Font("Arial", 8.25f);
-        yield return new object[] { null, Control.DefaultFont.Height };
-        yield return new object[] { font, font.Height };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetNonNullOldValueWithFontHeight_TestData))]
-    public void Control_Font_SetNonNullOldValueWithFontHeight_GetReturnsExpected(Font value, int expectedFontHeight)
-    {
-        using var control = new SubControl
-        {
-            FontHeight = 10,
-            Font = new Font("Arial", 1)
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedFontHeight, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedFontHeight, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void Control_Font_SetWithNonNullOldValue_GetReturnsExpected(Font value)
-    {
-        using var control = new SubControl
-        {
-            Font = new Font("Arial", 1)
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f), 1 };
-            yield return new object[] { userPaint, null, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void Control_Font_SetWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithNonNullOldValueWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f) };
-            yield return new object[] { userPaint, null };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
-    public void Control_Font_SetWithNonNullOldValueWithHandle_GetReturnsExpected(bool userPaint, Font value)
-    {
-        using var control = new SubControl
-        {
-            Font = new Font("Arial", 1)
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Font_SetWithChildrenWithHandler_CallsFontChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.FontChanged += handler;
-        child1.FontChanged += childHandler1;
-        child2.FontChanged += childHandler2;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, child1.Font);
-        Assert.Same(font1, child2.Font);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, child1.Font);
-        Assert.Same(font1, child2.Font);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(font2, child1.Font);
-        Assert.Same(font2, child2.Font);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(Control.DefaultFont, child1.Font);
-        Assert.Equal(Control.DefaultFont, child2.Font);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, childCallCount1);
-        Assert.Equal(3, childCallCount2);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        child1.FontChanged -= childHandler1;
-        child2.FontChanged -= childHandler2;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, child1.Font);
-        Assert.Same(font1, child2.Font);
-        Assert.Equal(3, callCount);
-        Assert.Equal(3, childCallCount1);
-        Assert.Equal(3, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Font_SetWithChildrenWithFontWithHandler_CallsFontChanged()
-    {
-        using var childFont1 = new Font("Arial", 1);
-        using var childFont2 = new Font("Arial", 1);
-        using var child1 = new Control
-        {
-            Font = childFont1
-        };
-        using var child2 = new Control
-        {
-            Font = childFont2
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.FontChanged += handler;
-        child1.FontChanged += childHandler1;
-        child2.FontChanged += childHandler2;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        child1.FontChanged -= childHandler1;
-        child2.FontChanged -= childHandler2;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Font_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Font)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        using var font = new Font("Arial", 8.25f);
-        control.Font = font;
-        Assert.Same(font, control.Font);
-        Assert.True(property.CanResetValue(control));
-
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.False(property.CanResetValue(control));
-
-        control.Font = font;
-        Assert.Same(font, control.Font);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Font_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Font)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        using var font = new Font("Arial", 8.25f);
-        control.Font = font;
-        Assert.Same(font, control.Font);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Font = font;
-        Assert.Same(font, control.Font);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void Control_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new Control
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void Control_ForeColor_SetWithCustomOldValue_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new Control
-        {
-            ForeColor = Color.YellowGreen
-        };
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void Control_ForeColor_SetWithChildren_GetReturnsExpected(Color value, Color expected)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.Equal(expected, child1.ForeColor);
-        Assert.Equal(expected, child2.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.Equal(expected, child1.ForeColor);
-        Assert.Equal(expected, child2.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void Control_ForeColor_SetWithChildrenWithColor_GetReturnsExpected(Color value, Color expected)
-    {
-        using var child1 = new Control
-        {
-            ForeColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            ForeColor = Color.YellowGreen
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.Empty, Control.DefaultForeColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void Control_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_SetWithHandlerInDisposing_DoesNotCallForeColorChanged()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.ForeColorChanged += (sender, e) => callCount++;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.ForeColor = Color.Red;
-            Assert.Equal(Color.Red, control.ForeColor);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, invalidatedCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_SetWithChildrenWithHandler_CallsForeColorChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount - 1, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1 - 1, childCallCount2);
-            childCallCount2++;
-        };
-        control.ForeColorChanged += handler;
-        child1.ForeColorChanged += childHandler1;
-        child2.ForeColorChanged += childHandler2;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Red, child1.ForeColor);
-        Assert.Equal(Color.Red, child2.ForeColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Red, child1.ForeColor);
-        Assert.Equal(Color.Red, child2.ForeColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(Control.DefaultForeColor, child1.ForeColor);
-        Assert.Equal(Control.DefaultForeColor, child2.ForeColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        child1.ForeColorChanged -= childHandler1;
-        child2.ForeColorChanged -= childHandler2;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Red, child1.ForeColor);
-        Assert.Equal(Color.Red, child2.ForeColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_SetWithChildrenWithForeColorWithHandler_CallsForeColorChanged()
-    {
-        using var child1 = new Control
-        {
-            ForeColor = Color.Yellow
-        };
-        using var child2 = new Control
-        {
-            ForeColor = Color.YellowGreen
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.ForeColorChanged += handler;
-        child1.ForeColorChanged += childHandler1;
-        child2.ForeColorChanged += childHandler2;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        child1.ForeColorChanged -= childHandler1;
-        child2.ForeColorChanged -= childHandler2;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(Color.Yellow, child1.ForeColor);
-        Assert.Equal(Color.YellowGreen, child2.ForeColor);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.ForeColor)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.ForeColor)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_GetHandle()
-    {
-        using var cont = new Control();
-
-        IntPtr intptr = cont.Handle;
-
-        Assert.NotEqual(IntPtr.Zero, intptr);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, 1)]
-    [InlineData(0, 0)]
-    [InlineData(2, 1)]
-    [InlineData(40, 1)]
-    public void Control_Height_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Height = value;
-        Assert.Equal(new Size(0, value), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.DisplayRectangle);
-        Assert.Equal(new Size(0, value), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(value, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Height = value;
-        Assert.Equal(new Size(0, value), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.DisplayRectangle);
-        Assert.Equal(new Size(0, value), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(value, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Height_Set_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 40, 0, 40, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, 40, 10, 40, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, 40, 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, 40, 31, 40, 0 };
-        yield return new object[] { new Size(30, 41), Size.Empty, 40, 30, 41, 0 };
-        yield return new object[] { new Size(40, 50), Size.Empty, 40, 40, 50, 0 };
-        yield return new object[] { Size.Empty, new Size(20, 10), 40, 0, 10, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), 40, 0, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), 40, 0, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), 40, 0, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), 40, 0, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), 40, 10, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 40, 10, 30, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), 40, 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), 40, 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), 40, 40, 50, 0 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), 40, 40, 50, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_Set_WithConstrainedSize_TestData))]
-    public void Control_Height_SetWithConstrainedSize_GetReturnsExpected(Size minimumSize, Size maximumSize, int value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Height = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Height = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, -4, -8, 1)]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(2, -4, -2, 1)]
-    [InlineData(40, -4, 36, 1)]
-    public void Control_Height_SetWithCustomStyle_GetReturnsExpected(int value, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Height = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(0, value), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(value, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Height = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(0, value), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(value, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, 1, 2)]
-    [InlineData(0, 0, 0)]
-    [InlineData(2, 1, 2)]
-    [InlineData(40, 1, 2)]
-    public void Control_Height_SetWithParent_GetReturnsExpected(int value, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Height = value;
-            Assert.Equal(new Size(0, value), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.DisplayRectangle);
-            Assert.Equal(new Size(0, value), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(value, control.Height);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Height = value;
-            Assert.Equal(new Size(0, value), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.DisplayRectangle);
-            Assert.Equal(new Size(0, value), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(value, control.Height);
-            Assert.Equal(new Rectangle(0, 0, 0, value), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Height_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, -4, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 0, 0 };
-        yield return new object[] { true, 2, 2, 1, 1 };
-        yield return new object[] { true, 40, 40, 1, 1 };
-        yield return new object[] { false, -4, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 0, 0 };
-        yield return new object[] { false, 2, 2, 1, 0 };
-        yield return new object[] { false, 40, 40, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_SetWithHandle_TestData))]
-    public void Control_Height_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Height = value;
-        Assert.Equal(new Size(0, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(0, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Height = value;
-        Assert.Equal(new Size(0, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(0, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Height_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, -4, 0, 0, 0, 1, 2 };
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 2, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 40, 40, 1, 1, 2, 2 };
-        yield return new object[] { false, -4, 0, 0, 0, 1, 2 };
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 2, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 40, 40, 1, 0, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_SetWithParentWithHandle_TestData))]
-    public void Control_Height_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Height = value;
-            Assert.Equal(new Size(0, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(0, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Height = value;
-            Assert.Equal(new Size(0, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(0, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, 0, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void Control_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new Control
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void Control_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void Control_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    public static IEnumerable<object[]> ImeModeBase_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.OnHalf };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void Control_ImeModeBase_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new SubControl
-        {
-            ImeModeBase = value
-        };
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void Control_ImeModeBase_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ImeModeBase_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new SubControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeModeBase = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeModeBase);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ImeModeBase = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeModeBase);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ImeModeBase = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeModeBase);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeModeBase = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeModeBase);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void Control_ImeModeBase_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new SubControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeModeBase = value);
-    }
-
-    [WinFormsFact]
-    public async Task Control_InvokeRequired_Get_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.InvokeRequired);
-
-        await Task.Run(() =>
-        {
-            Assert.True(control.InvokeRequired);
-        });
-    }
-
-    [WinFormsFact]
-    public async Task Control_InvokeRequired_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.InvokeRequired);
-
-        await Task.Run(() =>
-        {
-            Assert.True(control.InvokeRequired);
-        });
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_IsAccessible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            IsAccessible = value
-        };
-        Assert.Equal(value, control.IsAccessible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.IsAccessible = value;
-        Assert.Equal(value, control.IsAccessible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.IsAccessible = !value;
-        Assert.Equal(!value, control.IsAccessible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_IsMirrored_Get_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.False(control.IsMirrored);
-
-        // Call again to test caching behavior.
-        Assert.False(control.IsMirrored);
-    }
-
-    [WinFormsFact]
-    public void Control_IsMirrored_GetLayoutRtl_ReturnsExpected()
-    {
-        using var control = new RightToLeftControl();
-        Assert.True(control.IsMirrored);
-
-        // Call again to test caching behavior.
-        Assert.True(control.IsMirrored);
-    }
-
-    [WinFormsFact]
-    public void Control_IsMirrored_GetLayoutRtlWithHandle_ReturnsExpected()
-    {
-        using var control = new RightToLeftControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsMirrored);
-
-        // Call again to test caching behavior.
-        Assert.True(control.IsMirrored);
-    }
-
-    [WinFormsFact]
-    public void Control_IsMirrored_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.IsMirrored);
-
-        // Call again to test caching behavior.
-        Assert.False(control.IsMirrored);
-    }
-
-    private class RightToLeftControl : Control
-    {
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                CreateParams cp = base.CreateParams;
-                cp.ExStyle |= (int)WINDOW_EX_STYLE.WS_EX_LAYOUTRTL;
-                return cp;
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, 1)]
-    [InlineData(1, 1)]
-    public void Control_Left_Set_GetReturnsExpected(int value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubControl();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Left = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(new Point(value, 0), control.Location);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Left = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(new Point(value, 0), control.Location);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, 1)]
-    [InlineData(1, 1)]
-    public void Control_Left_SetWithParent_GetReturnsExpected(int value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Left = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value, control.Left);
-            Assert.Equal(new Point(value, 0), control.Location);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Left = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value, control.Left);
-            Assert.Equal(new Point(value, 0), control.Location);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Left_SetWithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, 0, 0 };
-            yield return new object[] { resizeRedraw, -1, 1 };
-            yield return new object[] { resizeRedraw, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Left_SetWithHandle_TestData))]
-    public void Control_Left_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Left = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(new Point(value, 0), control.Location);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Left = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(new Point(value, 0), control.Location);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Left_SetWithHandle_TestData))]
-    public void Control_Left_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Left = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value, control.Left);
-            Assert.Equal(new Point(value, 0), control.Location);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Left = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value, control.Left);
-            Assert.Equal(new Point(value, 0), control.Location);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value, 0, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_Left_SetWithHandleWithTransparentBackColor_DoesNotCallInvalidate(bool supportsTransparentBackgroundColor, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        // Set different.
-        control.Left = 1;
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set same.
-        control.Left = 1;
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set different.
-        control.Left = 2;
-        Assert.Equal(new Point(2, 0), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Left_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new Control();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Left = 1;
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Left = 1;
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different.
-        control.Left = 2;
-        Assert.Equal(new Point(2, 0), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Left = 1;
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-    }
-
-    public static IEnumerable<object[]> Location_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(-1, -2), 1 };
-        yield return new object[] { new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void Control_Location_Set_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new Control();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void Control_Location_SetWithParent_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Location = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Location = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Location_SetWithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, new Point(0, 0), 0 };
-            yield return new object[] { resizeRedraw, new Point(-1, -2), 1 };
-            yield return new object[] { resizeRedraw, new Point(1, 0), 1 };
-            yield return new object[] { resizeRedraw, new Point(0, 2), 1 };
-            yield return new object[] { resizeRedraw, new Point(1, 2), 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_SetWithHandle_TestData))]
-    public void Control_Location_SetWithHandle_GetReturnsExpected(bool resizeRedraw, Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_SetWithHandle_TestData))]
-    public void Control_Location_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, Point value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        int layoutCallCount = 0;
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Location = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Location = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_Location_SetWithHandleWithTransparentBackColor_DoesNotCallInvalidate(bool supportsTransparentBackgroundColor, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set different.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Location_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Location)];
-        using var control = new Control();
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.True(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Location_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Location)];
-        using var control = new Control();
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Location_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new Control();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different x.
-        control.Location = new Point(2, 2);
-        Assert.Equal(new Point(2, 2), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Set different y.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-    }
-
-    public static IEnumerable<object[]> Margin_Get_TestData()
-    {
-        yield return new object[] { new Control(), new Padding(3) };
-        yield return new object[] { new NonZeroDefaultMarginControl(), new Padding(1, 2, 3, 4) };
-        yield return new object[] { new ZeroDefaultMarginControl(), Padding.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Margin_Get_TestData))]
-    public void Control_Margin_GetWithCustomDefaultMargin_ReturnsExpected(Control control, Padding expected)
-    {
-        Assert.Equal(expected, control.Margin);
-    }
-
-    private class NonZeroDefaultMarginControl : Control
-    {
-        protected override Padding DefaultMargin => new(1, 2, 3, 4);
-    }
-
-    private class ZeroDefaultMarginControl : Control
-    {
-        protected override Padding DefaultMargin => Padding.Empty;
-    }
-
-    public static IEnumerable<object[]> Margin_Set_TestData()
-    {
-        yield return new object[] { new Padding(), new Padding() };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4) };
-        yield return new object[] { new Padding(1), new Padding(1) };
-        yield return new object[] { new Padding(-1, -2, -3, -4), Padding.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Margin_Set_TestData))]
-    public void Control_Margin_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Margin_Set_TestData))]
-    public void Control_Margin_SetWithParent_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Margin_Set_TestData))]
-    public void Control_Margin_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Margin_Set_TestData))]
-    public void Control_Margin_SetWithParentWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Margin = value;
-        Assert.Equal(expected, control.Margin);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(1, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Margin_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Margin)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.Margin = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Margin);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Margin_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Margin)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Margin = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Margin);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> MaximumSize_Get_TestData()
-    {
-        yield return new object[] { new Control(), Size.Empty };
-        yield return new object[] { new NonZeroWidthDefaultMaximumSizeControl(), new Size(10, 0) };
-        yield return new object[] { new NonZeroHeightDefaultMaximumSizeControl(), new Size(0, 20) };
-        yield return new object[] { new NonZeroWidthNonZeroHeightDefaultMaximumSizeControl(), new Size(10, 20) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Get_TestData))]
-    public void Control_MaximumSize_GetWithCustomDefaultMaximumSize_ReturnsExpected(Control control, Size expected)
-    {
-        Assert.Equal(expected, control.MaximumSize);
-    }
-
-    private class NonZeroWidthDefaultMaximumSizeControl : Control
-    {
-        protected override Size DefaultMaximumSize => new(10, 0);
-    }
-
-    private class NonZeroHeightDefaultMaximumSizeControl : Control
-    {
-        protected override Size DefaultMaximumSize => new(0, 20);
-    }
-
-    private class NonZeroWidthNonZeroHeightDefaultMaximumSizeControl : Control
-    {
-        protected override Size DefaultMaximumSize => new(10, 20);
-    }
-
-    public static IEnumerable<object[]> MaximumSize_Set_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(0, 1) };
-        yield return new object[] { new Size(0, 10) };
-        yield return new object[] { new Size(1, 0) };
-        yield return new object[] { new Size(10, 0) };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(3, 4) };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1) };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue) };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void Control_MaximumSize_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void Control_MaximumSize_SetWithCustomOldValue_GetReturnsExpected(Size value)
-    {
-        using var control = new Control
-        {
-            MaximumSize = new Size(1, 2)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MaximumSize_SetWithSize_TestData()
-    {
-        yield return new object[] { new Size(2, 3), Size.Empty, new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(0, 1), new Size(0, 1), 1 };
-        yield return new object[] { new Size(2, 3), new Size(0, 10), new Size(0, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(1, 0), new Size(1, 0), 1 };
-        yield return new object[] { new Size(2, 3), new Size(10, 0), new Size(2, 0), 1 };
-        yield return new object[] { new Size(2, 3), new Size(1, 2), new Size(1, 2), 1 };
-        yield return new object[] { new Size(2, 3), new Size(2, 2), new Size(2, 2), 1 };
-        yield return new object[] { new Size(2, 3), new Size(1, 3), new Size(1, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(2, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(3, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(2, 4), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(3, 4), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(5, 6), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue, ushort.MaxValue), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(int.MaxValue, int.MaxValue), new Size(2, 3), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetWithSize_TestData))]
-    public void Control_MaximumSize_SetWithSize_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void Control_MaximumSize_SetWithMinimumSize_GetReturnsExpected(Size value)
-    {
-        using var control = new Control
-        {
-            MinimumSize = new Size(100, 100)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(new Size(100, 100), control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(new Size(100, 100), control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetWithSize_TestData))]
-    public void Control_MaximumSize_SetWithCustomOldValueWithSize_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            MaximumSize = new Size(4, 5),
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MaximumSize_SetWithParent_TestData()
-    {
-        yield return new object[] { Size.Empty, 0 };
-        yield return new object[] { new Size(0, 1), 1 };
-        yield return new object[] { new Size(0, 10), 1 };
-        yield return new object[] { new Size(1, 0), 1 };
-        yield return new object[] { new Size(10, 0), 1 };
-        yield return new object[] { new Size(-1, -2), 1 };
-        yield return new object[] { new Size(1, 2), 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetWithParent_TestData))]
-    public void Control_MaximumSize_SetWithParent_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MaximumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> MaximumSize_SetCustomOldValueWithParent_TestData()
-    {
-        yield return new object[] { Size.Empty, 0 };
-        yield return new object[] { new Size(0, 1), 1 };
-        yield return new object[] { new Size(0, 10), 1 };
-        yield return new object[] { new Size(1, 0), 1 };
-        yield return new object[] { new Size(10, 0), 1 };
-        yield return new object[] { new Size(-1, -2), 1 };
-        yield return new object[] { new Size(1, 2), 0 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetCustomOldValueWithParent_TestData))]
-    public void Control_MaximumSize_SetWithCustomOldValueWithParent_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            MaximumSize = new Size(1, 2),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MaximumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void Control_MaximumSize_SetWithHandle_GetReturnsExpected(Size value)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void Control_MaximumSize_SetWithCustomOldValueWithHandle_GetReturnsExpected(Size value)
-    {
-        using var control = new Control
-        {
-            MaximumSize = new Size(1, 2)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetWithSize_TestData))]
-    public void Control_MaximumSize_SetWithSizeWithHandle_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetWithParent_TestData))]
-    public void Control_MaximumSize_SetWithParentWithHandle_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MaximumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_SetCustomOldValueWithParent_TestData))]
-    public void Control_MaximumSize_SetWithCustomOldValueWithParentWithHandle_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            MaximumSize = new Size(1, 2),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MaximumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_MaximumSize_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.MaximumSize)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.MaximumSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.MaximumSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.MaximumSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.MaximumSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.MaximumSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.MaximumSize);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_MaximumSize_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.MaximumSize)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.MaximumSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.MaximumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.MaximumSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.MaximumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.MaximumSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.MaximumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> MinimumSize_Get_TestData()
-    {
-        yield return new object[] { new Control(), Size.Empty };
-        yield return new object[] { new NonZeroWidthDefaultMinimumSizeControl(), new Size(10, 0) };
-        yield return new object[] { new NonZeroHeightDefaultMinimumSizeControl(), new Size(0, 20) };
-        yield return new object[] { new NonZeroWidthNonZeroHeightDefaultMinimumSizeControl(), new Size(10, 20) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_Get_TestData))]
-    public void Control_MinimumSize_GetWithCustomDefaultMinimumSize_ReturnsExpected(Control control, Size expected)
-    {
-        Assert.Equal(expected, control.MinimumSize);
-    }
-
-    private class NonZeroWidthDefaultMinimumSizeControl : Control
-    {
-        protected override Size DefaultMinimumSize => new(10, 0);
-    }
-
-    private class NonZeroHeightDefaultMinimumSizeControl : Control
-    {
-        protected override Size DefaultMinimumSize => new(0, 20);
-    }
-
-    private class NonZeroWidthNonZeroHeightDefaultMinimumSizeControl : Control
-    {
-        protected override Size DefaultMinimumSize => new(10, 20);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_Set_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 0 };
-        yield return new object[] { new Size(0, 1), new Size(0, 1), 1 };
-        yield return new object[] { new Size(0, 10), new Size(0, 10), 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 0), 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 0), 1 };
-        yield return new object[] { new Size(-1, -2), Size.Empty, 0 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 1 };
-        yield return new object[] { new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(int.MaxValue, int.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_Set_TestData))]
-    public void Control_MinimumSize_Set_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { Size.Empty, new Size(1, 2), 0 };
-        yield return new object[] { new Size(0, 1), new Size(1, 2), 0 };
-        yield return new object[] { new Size(0, 10), new Size(1, 10), 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 2), 0 };
-        yield return new object[] { new Size(10, 0), new Size(10, 2), 1 };
-        yield return new object[] { new Size(-1, -2), new Size(1, 2), 0 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 0 };
-        yield return new object[] { new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(int.MaxValue, int.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithCustomOldValue_TestData))]
-    public void Control_MinimumSize_SetWithCustomOldValue_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            MinimumSize = new Size(1, 2)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithSize_TestData()
-    {
-        yield return new object[] { new Size(2, 3), Size.Empty, new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(0, 1), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(0, 10), new Size(2, 10), 1 };
-        yield return new object[] { new Size(2, 3), new Size(1, 0), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(10, 0), new Size(10, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(-1, -2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(1, 2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(2, 2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(1, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(2, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(3, 3), new Size(3, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(2, 4), new Size(2, 4), 1 };
-        yield return new object[] { new Size(2, 3), new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(2, 3), new Size(5, 6), new Size(5, 6), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1 };
-        yield return new object[] { new Size(2, 3), new Size(int.MaxValue, int.MaxValue), new Size(int.MaxValue, int.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithSize_TestData))]
-    public void Control_MinimumSize_SetWithSize_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_Set_TestData))]
-    public void Control_MinimumSize_SetWithMaximumSize_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            MaximumSize = new Size(-1, -2)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithSize_TestData))]
-    public void Control_MinimumSize_SetWithCustomOldValueWithSize_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            MinimumSize = new Size(1, 2),
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithParent_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 0, 0 };
-        yield return new object[] { new Size(0, 1), new Size(0, 1), 1, 1 };
-        yield return new object[] { new Size(0, 10), new Size(0, 10), 1, 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 0), 1, 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 0), 1, 1 };
-        yield return new object[] { new Size(-1, -2), Size.Empty, 0, 1 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1, 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(int.MaxValue, int.MaxValue), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithParent_TestData))]
-    public void Control_MinimumSize_SetWithParent_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MinimumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetCustomOldValueWithParent_TestData()
-    {
-        yield return new object[] { Size.Empty, new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(0, 1), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(0, 10), new Size(1, 10), 1, 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 2), 1, 1 };
-        yield return new object[] { new Size(-1, -2), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 0, 0 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 1, 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(int.MaxValue, int.MaxValue), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetCustomOldValueWithParent_TestData))]
-    public void Control_MinimumSize_SetWithCustomOldValueWithParent_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            MinimumSize = new Size(1, 2),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MinimumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithHandle_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 0 };
-        yield return new object[] { new Size(0, 1), new Size(0, 1), 1 };
-        yield return new object[] { new Size(0, 10), new Size(0, 10), 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 0), 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 0), 1 };
-        yield return new object[] { new Size(-1, -2), Size.Empty, 0 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 1 };
-        yield return new object[] { new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithHandle_TestData))]
-    public void Control_MinimumSize_SetWithHandle_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithCustomOldValueWithHandle_TestData()
-    {
-        yield return new object[] { Size.Empty, new Size(1, 2), 0 };
-        yield return new object[] { new Size(0, 1), new Size(1, 2), 0 };
-        yield return new object[] { new Size(0, 10), new Size(1, 10), 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 2), 0 };
-        yield return new object[] { new Size(10, 0), new Size(10, 2), 1 };
-        yield return new object[] { new Size(-1, -2), new Size(1, 2), 0 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 0 };
-        yield return new object[] { new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithCustomOldValueWithHandle_TestData))]
-    public void Control_MinimumSize_SetWithCustomOldValueWithHandle_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            MinimumSize = new Size(1, 2)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithSizeWithHandle_TestData()
-    {
-        yield return new object[] { new Size(2, 3), Size.Empty, new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(0, 1), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(0, 10), new Size(2, 10), 1 };
-        yield return new object[] { new Size(2, 3), new Size(1, 0), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(10, 0), new Size(10, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(-1, -2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(1, 2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(2, 2), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(1, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(2, 3), new Size(2, 3), 0 };
-        yield return new object[] { new Size(2, 3), new Size(3, 3), new Size(3, 3), 1 };
-        yield return new object[] { new Size(2, 3), new Size(2, 4), new Size(2, 4), 1 };
-        yield return new object[] { new Size(2, 3), new Size(3, 4), new Size(3, 4), 1 };
-        yield return new object[] { new Size(2, 3), new Size(5, 6), new Size(5, 6), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(2, 3), new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-        yield return new object[] { new Size(2, 3), new Size(int.MaxValue, int.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithSizeWithHandle_TestData))]
-    public void Control_MinimumSize_SetWithSizeWithHandle_GetReturnsExpected(Size size, Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new Control
-        {
-            Size = size
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 0, 0 };
-        yield return new object[] { new Size(0, 1), new Size(0, 1), 1, 1 };
-        yield return new object[] { new Size(0, 10), new Size(0, 10), 1, 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 0), 1, 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 0), 1, 1 };
-        yield return new object[] { new Size(-1, -2), Size.Empty, 0, 1 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetWithParentWithHandle_TestData))]
-    public void Control_MinimumSize_SetWithParentWithHandle_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MinimumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> MinimumSize_SetCustomOldValueWithParentWithHandle_TestData()
-    {
-        yield return new object[] { Size.Empty, new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(0, 1), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(0, 10), new Size(1, 10), 1, 1 };
-        yield return new object[] { new Size(1, 0), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(10, 0), new Size(10, 2), 1, 1 };
-        yield return new object[] { new Size(-1, -2), new Size(1, 2), 0, 1 };
-        yield return new object[] { new Size(1, 2), new Size(1, 2), 0, 0 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), new Size(ushort.MaxValue, ushort.MaxValue), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_SetCustomOldValueWithParentWithHandle_TestData))]
-    public void Control_MinimumSize_SetWithCustomOldValueWithParentWithHandle_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            MinimumSize = new Size(1, 2),
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("MinimumSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_MinimumSize_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.MinimumSize)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.MinimumSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.MinimumSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.MinimumSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.MinimumSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.MinimumSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.MinimumSize);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_MinimumSize_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.MinimumSize)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.MinimumSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.MinimumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.MinimumSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.MinimumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.MinimumSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.MinimumSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0, 0, 0, 0, MouseButtons.None)]
-    [InlineData(1, 2, 3, 4, 5, MouseButtons.None)]
-    [InlineData(byte.MaxValue, 0, 0, 0, 0, MouseButtons.Left)]
-    [InlineData(0, byte.MaxValue, 0, 0, 0, MouseButtons.Middle)]
-    [InlineData(0, 0, byte.MaxValue, 0, 0, MouseButtons.Right)]
-    [InlineData(0, 0, 0, byte.MaxValue, 0, MouseButtons.XButton1)]
-    [InlineData(0, 0, 0, 0, byte.MaxValue, MouseButtons.XButton2)]
-    [InlineData(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, MouseButtons.Left | MouseButtons.Middle | MouseButtons.Right | MouseButtons.XButton1 | MouseButtons.XButton2)]
-    public unsafe void MouseButtons_Get_ReturnsExpected(byte lState, byte mState, byte rState, byte xState1, byte xState2, MouseButtons expected)
-    {
-        using var control = new SubControl();
-
-        var keyState = new byte[256];
-        fixed (byte* b = keyState)
-        {
-            Assert.True(PInvoke.GetKeyboardState(b));
-            keyState[(int)Keys.LButton] = lState;
-            keyState[(int)Keys.MButton] = mState;
-            keyState[(int)Keys.RButton] = rState;
-            keyState[(int)Keys.XButton1] = xState1;
-            keyState[(int)Keys.XButton2] = xState2;
-            PInvoke.SetKeyboardState(b);
-        }
-
-        Assert.Equal(expected, Control.MouseButtons);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Name_GetWithSite_ReturnsExpected(string siteName, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(siteName);
-        using var control = new Control
-        {
-            Site = mockSite.Object
-        };
-        Assert.Equal(expected, control.Name);
-        mockSite.Verify(s => s.Name, Times.Once());
-
-        // Get again.
-        Assert.Equal(expected, control.Name);
-        mockSite.Verify(s => s.Name, Times.Exactly(2));
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Name_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Control
-        {
-            Name = value
-        };
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Get again.
-        control.Name = value;
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Name_SetWithCustomOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Control
-        {
-            Name = "oldName"
-        };
-
-        control.Name = value;
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Get again.
-        control.Name = value;
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("name", null, "name", 0)]
-    [InlineData("", null, "", 1)]
-    [InlineData("", "", "", 1)]
-    [InlineData("", "siteName", "siteName", 1)]
-    [InlineData(null, null, "", 1)]
-    [InlineData(null, "", "", 1)]
-    [InlineData(null, "siteName", "siteName", 1)]
-    public void Control_Name_SetWithSite_GetReturnsExpected(string value, string siteName, string expected, int expectedSiteCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(siteName);
-        using var control = new Control
-        {
-            Site = mockSite.Object,
-            Name = value
-        };
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedSiteCallCount));
-
-        // Get again.
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-        mockSite.Verify(s => s.Name, Times.Exactly(expectedSiteCallCount * 2));
-    }
-
-    public static IEnumerable<object[]> Padding_Get_TestData()
-    {
-        yield return new object[] { new Control(), Padding.Empty };
-        yield return new object[] { new NonZeroDefaultPaddingControl(), new Padding(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Get_TestData))]
-    public void Control_Padding_GetWithCustomDefaultPadding_ReturnsExpected(Control control, Padding expected)
-    {
-        Assert.Equal(expected, control.Padding);
-    }
-
-    private class NonZeroDefaultPaddingControl : Control
-    {
-        protected override Padding DefaultPadding => new(1, 2, 3, 4);
-    }
-
-    public static IEnumerable<object[]> Padding_Set_TestData()
-    {
-        yield return new object[] { new Padding(), new Padding(), 0, 0 };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 1 };
-        yield return new object[] { new Padding(1), new Padding(1), 1, 1 };
-        yield return new object[] { new Padding(-1, -2, -3, -4), Padding.Empty, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Set_TestData))]
-    public void Control_Padding_Set_GetReturnsExpected(Padding value, Padding expected, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Set_TestData))]
-    public void Control_Padding_SetWithParent_GetReturnsExpected(Padding value, Padding expected, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount1, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount2, parentLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        parent.Layout -= parentHandler;
-    }
-
-    public static IEnumerable<object[]> Padding_SetWithHandle_TestData()
-    {
-        yield return new object[] { false, new Padding(), new Padding(), 0, 0, 0, 0 };
-        yield return new object[] { false, new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 0, 1, 0 };
-        yield return new object[] { false, new Padding(1), new Padding(1), 1, 0, 1, 0 };
-        yield return new object[] { false, new Padding(-1, -2, -3, -4), Padding.Empty, 1, 0, 2, 0 };
-        yield return new object[] { true, new Padding(), new Padding(), 0, 0, 0, 0 };
-        yield return new object[] { true, new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 1, 1, 1 };
-        yield return new object[] { true, new Padding(1), new Padding(1), 1, 1, 1, 1 };
-        yield return new object[] { true, new Padding(-1, -2, -3, -4), Padding.Empty, 1, 1, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_SetWithHandle_TestData))]
-    public void Control_Padding_SetWithHandle_GetReturnsExpected(bool resizeRedraw, Padding value, Padding expected, int expectedLayoutCallCount1, int expectedInvalidatedCallCount1, int expectedLayoutCallCount2, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_SetWithHandle_TestData))]
-    public void Control_Padding_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, Padding value, Padding expected, int expectedLayoutCallCount1, int expectedInvalidatedCallCount1, int expectedLayoutCallCount2, int expectedInvalidatedCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount1, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount2, parentLayoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        parent.Layout -= parentHandler;
-    }
-
-    [WinFormsFact]
-    public void Control_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Padding_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Padding)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.Padding = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Padding_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Padding)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Padding = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-        yield return new object[] { new Form() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Control_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new Control
-        {
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Control_Parent_SetWithNonNullOldParent_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new Control();
-        using var control = new Control
-        {
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Control_Parent_SetWithHandle_GetReturnsExpected(Control value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new Control();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Control_Parent_SetChild_ThrowsArgumentException()
-    {
-        using var child = new Control();
-        using var control = new Control();
-        control.Controls.Add(child);
-
-        Assert.Throws<ArgumentException>(() => control.Parent = child);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Control_Parent_SetTopLevel_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new SubControl();
-        control.SetTopLevel(true);
-
-        Assert.Throws<ArgumentException>(() => control.Parent = parent);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Control_PreferredSize_GetWithChildrenSimple_ReturnsExpected()
-    {
-        using var control = new Control();
-        using var child = new Control
-        {
-            Size = new Size(16, 20)
-        };
-        control.Controls.Add(child);
-        Assert.Equal(new Size(0, 0), control.PreferredSize);
-
-        // Call again.
-        Assert.Equal(new Size(0, 0), control.PreferredSize);
-    }
-
-    [WinFormsFact]
-    public void Control_PreferredSize_GetWithChildrenAdvanced_ReturnsExpected()
-    {
-        using var control = new BorderedControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        using var child = new Control
-        {
-            Size = new Size(16, 20)
-        };
-        control.Controls.Add(child);
-        Assert.Equal(new Size(0, 0), control.PreferredSize);
-
-        // Call again.
-        Assert.Equal(new Size(0, 0), control.PreferredSize);
-    }
-
-    public static IEnumerable<object[]> Region_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void Control_Region_Set_GetReturnsExpected(Region value)
-    {
-        using var control = new Control
-        {
-            Region = value
-        };
-        Assert.Same(value, control.Region);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void Control_Region_SetWithNonNullOldValue_GetReturnsExpected(Region value)
-    {
-        using var oldValue = new Region();
-        using var control = new Control
-        {
-            Region = oldValue
-        };
-        oldValue.MakeEmpty();
-
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.Throws<ArgumentException>(() => oldValue.MakeEmpty());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.Throws<ArgumentException>(() => oldValue.MakeEmpty());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void Control_Region_SetWithHandle_GetReturnsExpected(Region value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void Control_Region_SetWithNonNullOldValueWithHandle_GetReturnsExpected(Region value)
-    {
-        using var oldValue = new Region();
-        using var control = new Control
-        {
-            Region = oldValue
-        };
-        oldValue.MakeEmpty();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.Throws<ArgumentException>(() => oldValue.MakeEmpty());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.Throws<ArgumentException>(() => oldValue.MakeEmpty());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Region_SetWithHandler_CallsRegionChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RegionChanged += handler;
-
-        // Set different.
-        using var region1 = new Region();
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var region2 = new Region();
-        control.Region = region2;
-        Assert.Same(region2, control.Region);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Region = null;
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RegionChanged -= handler;
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ResizeRedraw_Get_ReturnsExpected(bool value)
-    {
-        var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, value);
-        Assert.Equal(value, control.ResizeRedraw);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ResizeRedraw_Set_GetReturnsExpected(bool value)
-    {
-        var control = new SubControl
-        {
-            ResizeRedraw = value
-        };
-        Assert.Equal(value, control.ResizeRedraw);
-        Assert.Equal(value, control.GetStyle(ControlStyles.ResizeRedraw));
-
-        // Set same.
-        control.ResizeRedraw = value;
-        Assert.Equal(value, control.ResizeRedraw);
-        Assert.Equal(value, control.GetStyle(ControlStyles.ResizeRedraw));
-
-        // Set different.
-        control.ResizeRedraw = !value;
-        Assert.Equal(!value, control.ResizeRedraw);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.ResizeRedraw));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void Control_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new Control
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void Control_RightToLeft_SetWithOldValue_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void Control_RightToLeft_SetWithChildren_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expected, child1.RightToLeft);
-        Assert.Equal(expected, child2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expected, child1.RightToLeft);
-        Assert.Equal(expected, child2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void Control_RightToLeft_SetWithChildrenWithRightToLeft_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var child1 = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var child2 = new Control
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, 1)]
-    [InlineData(RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, 0)]
-    public void Control_RightToLeft_SetWithHandle_GetReturnsExpected(RightToLeft value, RightToLeft expected, int expectedCreatedCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.No, RightToLeft.No, 1)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, 1)]
-    public void Control_RightToLeft_SetWithOldValueWithHandle_GetReturnsExpected(RightToLeft value, RightToLeft expected, int expectedCreatedCallCount)
-    {
-        using var control = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_SetWithHandlerInDisposing_DoesNotCallRightToLeftChanged()
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeft = RightToLeft.Yes;
-            Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_SetWithChildrenWithHandler_CallsRightToLeftChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control
-        {
-            RightToLeft = RightToLeft.Inherit
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount - 1, childCallCount1);
-            Assert.Equal(childCallCount1, childCallCount2);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(callCount, childCallCount1);
-            Assert.Equal(childCallCount1 - 1, childCallCount2);
-            childCallCount2++;
-        };
-        control.RightToLeftChanged += handler;
-        child1.RightToLeftChanged += childHandler1;
-        child2.RightToLeftChanged += childHandler2;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child2.RightToLeft);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child2.RightToLeft);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(RightToLeft.No, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        child1.RightToLeftChanged -= childHandler1;
-        child2.RightToLeftChanged -= childHandler2;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child2.RightToLeft);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_SetWithChildrenWithRightToLeftWithHandler_CallsRightToLeftChanged()
-    {
-        using var child1 = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var child2 = new Control
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.RightToLeftChanged += handler;
-        child1.RightToLeftChanged += childHandler1;
-        child2.RightToLeftChanged += childHandler2;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        child1.RightToLeftChanged -= childHandler1;
-        child2.RightToLeftChanged -= childHandler2;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, child1.RightToLeft);
-        Assert.Equal(RightToLeft.No, child2.RightToLeft);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void Control_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.RightToLeft)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.True(property.CanResetValue(control));
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(property.CanResetValue(control));
-
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(property.CanResetValue(control));
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_RightToLeft_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.RightToLeft)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_ShowFocusCues_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, control.ShowFocusCues);
-    }
-
-    public static TheoryData<int, bool> Get_Control_ShowFocusCues_GetWithHandleMessageSent_ReturnsExpected()
-    {
-        return new TheoryData<int, bool>()
-        {
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_HIDEACCEL << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_HIDEFOCUS << 16), true },
-            { (int)PInvoke.UIS_CLEAR | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), true },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_HIDEACCEL << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_HIDEFOCUS << 16), false },
-            { (int)PInvoke.UIS_SET | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), false },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_HIDEACCEL << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_HIDEFOCUS << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), SystemInformation.MenuAccessKeysUnderlined }
-        };
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ControlTests), nameof(ControlTests.Get_Control_ShowFocusCues_GetWithHandleMessageSent_ReturnsExpected))]
-    public void Control_ShowFocusCues_GetWithHandleMessageSent_ReturnsExpected(int wParam, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        PInvoke.SendMessage(control, PInvoke.WM_UPDATEUISTATE, (WPARAM)wParam);
-        Assert.Equal(expected, control.ShowFocusCues);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ShowFocusCues_GetWithSiteWithHandle_ReturnsExpected(bool designMode)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        using var control = new SubControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, control.ShowFocusCues);
-    }
-
-    [WinFormsFact]
-    public void Control_ShowKeyboardCues_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, control.ShowKeyboardCues);
-    }
-
-    public static TheoryData<int, bool> Get_Control_ShowKeyboardCues_GetWithHandleMessageSent_ReturnsExpected()
-    {
-        return new TheoryData<int, bool>()
-        {
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_HIDEACCEL << 16), true },
-            { (int)PInvoke.UIS_CLEAR | ((int)PInvoke.UISF_HIDEFOCUS << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_CLEAR | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), true },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_HIDEACCEL << 16), false },
-            { (int)PInvoke.UIS_SET | ((int)PInvoke.UISF_HIDEFOCUS << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_SET | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), false },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_ACTIVE << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_HIDEACCEL << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)PInvoke.UISF_HIDEFOCUS << 16), SystemInformation.MenuAccessKeysUnderlined },
-            { (int)PInvoke.UIS_INITIALIZE | ((int)(PInvoke.UISF_HIDEACCEL | PInvoke.UISF_HIDEFOCUS) << 16), SystemInformation.MenuAccessKeysUnderlined }
-        };
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ControlTests), nameof(ControlTests.Get_Control_ShowKeyboardCues_GetWithHandleMessageSent_ReturnsExpected))]
-    public void Control_ShowKeyboardCues_GetWithHandleMessageSent_ReturnsExpected(int wParam, bool expected)
-    {
-        using var control = new SubControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        PInvoke.SendMessage(control, PInvoke.WM_UPDATEUISTATE, (WPARAM)wParam);
-        Assert.Equal(expected, control.ShowKeyboardCues);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_ShowKeyboardCues_GetWithSiteWithHandle_ReturnsExpected(bool designMode)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        using var control = new SubControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(designMode | SystemInformation.MenuAccessKeysUnderlined, control.ShowKeyboardCues);
-    }
-
-    public static IEnumerable<object[]> Site_Set_TestData()
-    {
-        yield return new object[] { null };
-
-        var mockNullSite = new Mock<ISite>(MockBehavior.Strict);
-        mockNullSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockNullSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        yield return new object[] { mockNullSite.Object };
-
-        var mockInvalidSite = new Mock<ISite>(MockBehavior.Strict);
-        mockInvalidSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockInvalidSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new object());
-        yield return new object[] { mockInvalidSite.Object };
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        yield return new object[] { mockSite.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void Control_Site_Set_GetReturnsExpected(ISite value)
-    {
-        using var control = new Control
-        {
-            Site = value
-        };
-        Assert.Same(value, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void Control_Site_SetWithHandle_GetReturnsExpected(ISite value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void Control_Site_SetWithNonNullOldValue_GetReturnsExpected(ISite value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        using var control = new Control
-        {
-            Site = mockSite.Object
-        };
-
-        control.Site = value;
-        Assert.Same(value, control.Site);
-
-        // Set same.
-        control.Site = value;
-        Assert.Same(value, control.Site);
-    }
-
-    [WinFormsFact]
-    public void Control_Site_SetWithoutAmbientPropertiesSet_UpdatesProperties()
-    {
-        Font font1 = SystemFonts.CaptionFont;
-        Font font2 = SystemFonts.DialogFont;
-        Cursor cursor1 = Cursors.AppStarting;
-        Cursor cursor2 = Cursors.Arrow;
-        var properties = new AmbientProperties
-        {
-            BackColor = Color.Blue,
-            Cursor = cursor1,
-            Font = font1,
-            ForeColor = Color.Red
-        };
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(properties)
-            .Verifiable();
-
-        var sameProperties = new AmbientProperties
-        {
-            BackColor = Color.Blue,
-            Cursor = cursor1,
-            Font = font1,
-            ForeColor = Color.Red
-        };
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(sameProperties)
-            .Verifiable();
-
-        var differentProperties = new AmbientProperties
-        {
-            BackColor = Color.Red,
-            Cursor = cursor2,
-            Font = font2,
-            ForeColor = Color.Blue
-        };
-        var mockSite3 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite3
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite3
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(differentProperties)
-            .Verifiable();
-
-        var mockSite4 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite4
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite4
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null)
-            .Verifiable();
-
-        using var control = new Control();
-        int backColorChangedCallCount = 0;
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            backColorChangedCallCount++;
-        };
-        int cursorChangedCallCount = 0;
-        control.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            cursorChangedCallCount++;
-        };
-        int foreColorChangedCallCount = 0;
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            foreColorChangedCallCount++;
-        };
-        int fontChangedCallCount = 0;
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            fontChangedCallCount++;
-        };
-
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.Equal(Color.Blue, control.BackColor);
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Same(font1, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Once());
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(1, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(1, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.Equal(Color.Blue, control.BackColor);
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Same(font1, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(1, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(1, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set equal.
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.Equal(Color.Blue, control.BackColor);
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Same(font1, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(1, backColorChangedCallCount);
-        Assert.Equal(1, cursorChangedCallCount);
-        Assert.Equal(1, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set different.
-        control.Site = mockSite3.Object;
-        Assert.Same(mockSite3.Object, control.Site);
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Same(cursor2, control.Cursor);
-        Assert.Equal(Color.Blue, control.ForeColor);
-        Assert.Same(font2, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(2, backColorChangedCallCount);
-        Assert.Equal(1, cursorChangedCallCount);
-        Assert.Equal(2, foreColorChangedCallCount);
-        Assert.Equal(1, fontChangedCallCount);
-
-        // Set null.
-        control.Site = mockSite4.Object;
-        Assert.Same(mockSite4.Object, control.Site);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        Assert.Equal(3, backColorChangedCallCount);
-        Assert.Equal(2, cursorChangedCallCount);
-        Assert.Equal(3, foreColorChangedCallCount);
-        Assert.Equal(2, fontChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Site_SetWithAmbientPropertiesSet_DoesNotUpdate()
-    {
-        Font font1 = SystemFonts.MenuFont;
-        Font font2 = SystemFonts.DialogFont;
-        Cursor cursor1 = Cursors.AppStarting;
-        Cursor cursor2 = Cursors.Arrow;
-        var properties = new AmbientProperties
-        {
-            BackColor = Color.Blue,
-            Cursor = cursor1,
-            Font = font1,
-            ForeColor = Color.Red
-        };
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(properties)
-            .Verifiable();
-
-        var sameProperties = new AmbientProperties
-        {
-            BackColor = Color.Blue,
-            Cursor = cursor1,
-            Font = font1,
-            ForeColor = Color.Red
-        };
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(sameProperties)
-            .Verifiable();
-
-        var differentProperties = new AmbientProperties
-        {
-            BackColor = Color.Red,
-            Cursor = cursor2,
-            Font = font2,
-            ForeColor = Color.Blue
-        };
-        var mockSite3 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite3
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite3
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(differentProperties)
-            .Verifiable();
-
-        var mockSite4 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite4
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite4
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null)
-            .Verifiable();
-
-        using var controlCursor = new Cursor((IntPtr)3);
-        Font controlFont = SystemFonts.StatusFont;
-        using var control = new Control
-        {
-            BackColor = Color.Green,
-            Cursor = controlCursor,
-            ForeColor = Color.Yellow,
-            Font = controlFont
-        };
-        int backColorChangedCallCount = 0;
-        control.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            backColorChangedCallCount++;
-        };
-        int cursorChangedCallCount = 0;
-        control.CursorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            cursorChangedCallCount++;
-        };
-        int foreColorChangedCallCount = 0;
-        control.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            foreColorChangedCallCount++;
-        };
-        int fontChangedCallCount = 0;
-        control.FontChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            fontChangedCallCount++;
-        };
-
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.Equal(Color.Green, control.BackColor);
-        Assert.Same(controlCursor, control.Cursor);
-        Assert.Equal(Color.Yellow, control.ForeColor);
-        Assert.Same(controlFont, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Once());
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.Equal(Color.Green, control.BackColor);
-        Assert.Same(controlCursor, control.Cursor);
-        Assert.Equal(Color.Yellow, control.ForeColor);
-        Assert.Same(controlFont, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set equal.
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.Equal(Color.Green, control.BackColor);
-        Assert.Same(controlCursor, control.Cursor);
-        Assert.Equal(Color.Yellow, control.ForeColor);
-        Assert.Same(controlFont, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-
-        // Set different.
-        control.Site = mockSite3.Object;
-        Assert.Same(mockSite3.Object, control.Site);
-        Assert.Equal(Color.Green, control.BackColor);
-        Assert.Same(controlCursor, control.Cursor);
-        Assert.Equal(Color.Yellow, control.ForeColor);
-        Assert.Same(controlFont, control.Font);
-        mockSite1.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(2));
-        mockSite2.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite3.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Exactly(1));
-        mockSite4.Verify(s => s.GetService(typeof(AmbientProperties)), Times.Never());
-        Assert.Equal(0, backColorChangedCallCount);
-        Assert.Equal(0, cursorChangedCallCount);
-        Assert.Equal(0, foreColorChangedCallCount);
-        Assert.Equal(0, fontChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(-3, -4), 1 };
-        yield return new object[] { new Size(0, 0), 0 };
-        yield return new object[] { new Size(1, 0), 1 };
-        yield return new object[] { new Size(0, 2), 1 };
-        yield return new object[] { new Size(30, 40), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void Control_Size_Set_GetReturnsExpected(Size value, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Size = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Size_Set_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, new Size(30, 40), 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, new Size(30, 40), 31, 40, 0 };
-        yield return new object[] { new Size(30, 41), Size.Empty, new Size(30, 40), 30, 41, 0 };
-        yield return new object[] { new Size(40, 50), Size.Empty, new Size(30, 40), 40, 50, 0 };
-        yield return new object[] { Size.Empty, new Size(20, 10), new Size(30, 40), 20, 10, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), new Size(30, 40), 30, 40, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), 20, 30, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), 20, 30, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), new Size(30, 40), 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), new Size(30, 40), 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), new Size(30, 40), 40, 50, 0 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), new Size(30, 40), 40, 50, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_WithConstrainedSize_TestData))]
-    public void Control_Size_SetWithConstrainedSize_GetReturnsExpected(Size minimumSize, Size maximumSize, Size value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Size_SetWithCustomStyle_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0, 0 };
-        yield return new object[] { new Size(-3, -4), -7, -8, 1 };
-        yield return new object[] { new Size(1, 0), -3, -4, 1 };
-        yield return new object[] { new Size(0, 2), -4, -2, 1 };
-        yield return new object[] { new Size(1, 2), -3, -2, 1 };
-        yield return new object[] { new Size(30, 40), 26, 36, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithCustomStyle_TestData))]
-    public void Control_Size_SetWithCustomStyle_GetReturnsExpected(Size value, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Size = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Size_SetWithParent_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0 };
-        yield return new object[] { new Size(-3, -4), 1, 2 };
-        yield return new object[] { new Size(1, 0), 1, 2 };
-        yield return new object[] { new Size(0, 2), 1, 2 };
-        yield return new object[] { new Size(1, 2), 1, 2 };
-        yield return new object[] { new Size(30, 40), 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParent_TestData))]
-    public void Control_Size_SetWithParent_GetReturnsExpected(Size value, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Size = value;
-            Assert.Equal(value, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-            Assert.Equal(value, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(value.Width, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(value.Height, control.Bottom);
-            Assert.Equal(value.Width, control.Width);
-            Assert.Equal(value.Height, control.Height);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Size = value;
-            Assert.Equal(value, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-            Assert.Equal(value, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(value.Width, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(value.Height, control.Bottom);
-            Assert.Equal(value.Width, control.Width);
-            Assert.Equal(value.Height, control.Height);
-            Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Size_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, new Size(0, 0), 0, 0, 0, 0 };
-        yield return new object[] { true, new Size(-3, -4), 0, 0, 0, 0 };
-        yield return new object[] { true, new Size(1, 0), 1, 0, 1, 1 };
-        yield return new object[] { true, new Size(0, 2), 0, 2, 1, 1 };
-        yield return new object[] { true, new Size(1, 2), 1, 2, 1, 1 };
-        yield return new object[] { true, new Size(30, 40), 30, 40, 1, 1 };
-
-        yield return new object[] { false, new Size(0, 0), 0, 0, 0, 0 };
-        yield return new object[] { false, new Size(-3, -4), 0, 0, 0, 0 };
-        yield return new object[] { false, new Size(1, 0), 1, 0, 1, 0 };
-        yield return new object[] { false, new Size(0, 2), 0, 2, 1, 0 };
-        yield return new object[] { false, new Size(1, 2), 1, 2, 1, 0 };
-        yield return new object[] { false, new Size(30, 40), 30, 40, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithHandle_TestData))]
-    public void Control_Size_SetWithHandle_GetReturnsExpected(bool resizeRedraw, Size value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Size_SetWithParentHandle_TestData()
-    {
-        yield return new object[] { true, new Size(0, 0), 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, new Size(-3, -4), 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { true, new Size(1, 0), 1, 0, 1, 1, 2, 2 };
-        yield return new object[] { true, new Size(0, 2), 0, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, new Size(1, 2), 1, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, new Size(30, 40), 30, 40, 1, 1, 2, 2 };
-
-        yield return new object[] { false, new Size(0, 0), 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, new Size(-3, -4), 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { false, new Size(1, 0), 1, 0, 1, 0, 2, 2 };
-        yield return new object[] { false, new Size(0, 2), 0, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, new Size(1, 2), 1, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, new Size(30, 40), 30, 40, 1, 0, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParentHandle_TestData))]
-    public void Control_Size_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, Size value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Size = value;
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Size = value;
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_Size_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Size)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.Size = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.Size);
-        Assert.True(property.CanResetValue(control));
-
-        control.Size = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.Size);
-        Assert.True(property.CanResetValue(control));
-
-        control.Size = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.Size);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Size_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Size)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.Size);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.Size);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.Size);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void Control_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new Control
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new Control
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new Control();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new Control
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Control
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new Control();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Text_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Text)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        // Set null.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.False(property.CanResetValue(control));
-
-        // Set empty.
-        control.Text = string.Empty;
-        Assert.Empty(control.Text);
-        Assert.False(property.CanResetValue(control));
-
-        // Set custom
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Empty(control.Text);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Text_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Text)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        // Set null.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        // Set empty.
-        control.Text = string.Empty;
-        Assert.Empty(control.Text);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        // Set custom
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Empty(control.Text);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, 1)]
-    [InlineData(1, 1)]
-    public void Control_Top_Set_GetReturnsExpected(int value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubControl();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Top = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(new Point(0, value), control.Location);
-        Assert.Equal(value, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Top = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(new Point(0, value), control.Location);
-        Assert.Equal(value, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, 1)]
-    [InlineData(1, 1)]
-    public void Control_Top_SetWithParent_GetReturnsExpected(int value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Top = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(new Point(0, value), control.Location);
-            Assert.Equal(value, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Top = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(new Point(0, value), control.Location);
-            Assert.Equal(value, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Top_SetWithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, 0, 0 };
-            yield return new object[] { resizeRedraw, -1, 1 };
-            yield return new object[] { resizeRedraw, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Top_SetWithHandle_TestData))]
-    public void Control_Top_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Top = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(new Point(0, value), control.Location);
-        Assert.Equal(value, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Top = value;
-        Assert.Equal(new Size(0, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(0, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(new Point(0, value), control.Location);
-        Assert.Equal(value, control.Top);
-        Assert.Equal(value, control.Bottom);
-        Assert.Equal(0, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Top_SetWithHandle_TestData))]
-    public void Control_Top_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Top = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(new Point(0, value), control.Location);
-            Assert.Equal(value, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Top = value;
-            Assert.Equal(new Size(0, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 0, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(0, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(new Point(0, value), control.Location);
-            Assert.Equal(value, control.Top);
-            Assert.Equal(value, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, value, 0, 0), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Control_Top_SetWithHandleWithTransparentBackColor_DoesNotCallInvalidate(bool supportsTransparentBackgroundColor, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        // Set different.
-        control.Top = 1;
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set same.
-        control.Top = 1;
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set different.
-        control.Top = 2;
-        Assert.Equal(new Point(0, 2), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Top_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new Control();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Top = 1;
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Top = 1;
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different.
-        control.Top = 2;
-        Assert.Equal(new Point(0, 2), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Top = 1;
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_TopLevelControl_GetWithParent_ReturnsNull()
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Null(control.TopLevelControl);
-        Assert.Null(parent.TopLevelControl);
-        Assert.Null(grandparent.TopLevelControl);
-    }
-
-    [WinFormsFact]
-    public void Control_TopLevelControl_GetWithTopLevelParent_ReturnsExpected()
-    {
-        using var grandparent = new SubControl();
-        grandparent.SetTopLevel(true);
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(grandparent, control.TopLevelControl);
-        Assert.Same(grandparent, parent.TopLevelControl);
-        Assert.Same(grandparent, grandparent.TopLevelControl);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_UseWaitCursor_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            UseWaitCursor = value
-        };
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseWaitCursor = value;
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseWaitCursor = !value;
-        Assert.Equal(!value, control.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_UseWaitCursor_SetWithChildren_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        using var child1 = new Control();
-        using var child2 = new Control();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        control.UseWaitCursor = value;
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.Equal(value, child1.UseWaitCursor);
-        Assert.Equal(value, child2.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseWaitCursor = value;
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.Equal(value, child1.UseWaitCursor);
-        Assert.Equal(value, child2.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseWaitCursor = !value;
-        Assert.Equal(!value, control.UseWaitCursor);
-        Assert.Equal(!value, child1.UseWaitCursor);
-        Assert.Equal(!value, child2.UseWaitCursor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_UseWaitCursor_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseWaitCursor = value;
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseWaitCursor = value;
-        Assert.Equal(value, control.UseWaitCursor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseWaitCursor = !value;
-        Assert.Equal(!value, control.UseWaitCursor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void Control_Visible_GetWithParent_ReturnsExpected(bool parentVisible, bool visible, bool expected)
-    {
-        using var parent = new Control
-        {
-            Visible = parentVisible
-        };
-        using var item = new Control
-        {
-            Parent = parent
-        };
-        Assert.Equal(parentVisible, item.Visible);
-
-        // Set custom.
-        item.Visible = visible;
-        Assert.Equal(expected, item.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Visible_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent,
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(!value, control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, true };
-            yield return new object[] { userPaint, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandle_TestData))]
-    public void Control_Visible_SetWithHandle_GetReturnsExpected(bool userPaint, bool value)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Control_Visible_SetWithParentWithHandle_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new Control
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_Visible_SetWithChildrenWithHandler_CallsVisibleChanged()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new Control
-        {
-            Visible = true
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.VisibleChanged += handler;
-        child1.VisibleChanged += childHandler1;
-        child2.VisibleChanged += childHandler2;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.True(child1.Visible);
-        Assert.True(child2.Visible);
-        Assert.Equal(2, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        child1.VisibleChanged -= childHandler1;
-        child2.VisibleChanged -= childHandler2;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(2, callCount);
-        Assert.Equal(1, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Visible_SetWithChildrenDisabledWithHandler_CallsVisibleChanged()
-    {
-        using var child1 = new Control
-        {
-            Visible = false
-        };
-        using var child2 = new Control
-        {
-            Visible = false
-        };
-        using var control = new Control
-        {
-            Visible = true
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        EventHandler childHandler1 = (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount1++;
-        };
-        EventHandler childHandler2 = (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            childCallCount2++;
-        };
-        control.VisibleChanged += handler;
-        child1.VisibleChanged += childHandler1;
-        child2.VisibleChanged += childHandler2;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        child1.VisibleChanged -= childHandler1;
-        child2.VisibleChanged -= childHandler2;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(child1.Visible);
-        Assert.False(child2.Visible);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(0, childCallCount2);
-    }
-
-    [WinFormsFact]
-    public void Control_Visible_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Visible)];
-        using var control = new Control();
-        Assert.False(property.CanResetValue(control));
-
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.True(control.Visible);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void Control_Visible_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.Visible)];
-        using var control = new Control();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.True(control.Visible);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, 1)]
-    [InlineData(0, 0)]
-    [InlineData(2, 1)]
-    [InlineData(40, 1)]
-    public void Control_Width_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Width = value;
-        Assert.Equal(new Size(value, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(value, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(value, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Width = value;
-        Assert.Equal(new Size(value, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(value, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(value, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Width_Set_WithConstrainedSize_TestData()
-    {
-        yield return new object[] { Size.Empty, Size.Empty, 30, 30, 0, 1 };
-        yield return new object[] { new Size(10, 20), Size.Empty, 30, 30, 20, 1 };
-        yield return new object[] { new Size(30, 40), Size.Empty, 30, 30, 40, 0 };
-        yield return new object[] { new Size(31, 40), Size.Empty, 30, 31, 40, 0 };
-        yield return new object[] { new Size(30, 41), Size.Empty, 30, 30, 41, 0 };
-        yield return new object[] { new Size(40, 50), Size.Empty, 30, 40, 50, 0 };
-        yield return new object[] { Size.Empty, new Size(20, 10), 30, 20, 0, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 40), 30, 30, 0, 1 };
-        yield return new object[] { Size.Empty, new Size(31, 40), 30, 30, 0, 1 };
-        yield return new object[] { Size.Empty, new Size(30, 41), 30, 30, 0, 1 };
-        yield return new object[] { Size.Empty, new Size(40, 50), 30, 30, 0, 1 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), 30, 30, 20, 1 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), 30, 20, 20, 1 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), 30, 30, 40, 0 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), 30, 30, 40, 0 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), 30, 40, 50, 0 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), 30, 40, 50, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_Set_WithConstrainedSize_TestData))]
-    public void Control_Width_SetWithConstrainedSize_GetReturnsExpected(Size minimumSize, Size maximumSize, int value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new SubControl
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Width = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Width = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, -8, -4, 1)]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(2, -2, -4, 1)]
-    [InlineData(30, 26, -4, 1)]
-    public void Control_Width_SetWithCustomStyle_GetReturnsExpected(int value, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount)
-    {
-        using var control = new BorderedControl();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Width = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(value, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(value, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Width = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(value, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(value, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4, 1, 2)]
-    [InlineData(0, 0, 0)]
-    [InlineData(2, 1, 2)]
-    [InlineData(40, 1, 2)]
-    public void Control_Width_SetWithParent_GetReturnsExpected(int value, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Width = value;
-            Assert.Equal(new Size(value, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(value, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(value, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(value, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Width = value;
-            Assert.Equal(new Size(value, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(value, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(value, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(value, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, 0, value, 0), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Width_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, -4, 0, 0, 0 };
-        yield return new object[] { true, 0, 0, 0, 0 };
-        yield return new object[] { true, 2, 2, 1, 1 };
-        yield return new object[] { true, 30, 30, 1, 1 };
-        yield return new object[] { false, -4, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 0, 0 };
-        yield return new object[] { false, 2, 2, 1, 0 };
-        yield return new object[] { false, 30, 30, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_SetWithHandle_TestData))]
-    public void Control_Width_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedWidth, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Width = value;
-        Assert.Equal(new Size(expectedWidth, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Width = value;
-        Assert.Equal(new Size(expectedWidth, 0), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, 0), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Width_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { true, -4, 0, 0, 0, 1, 2 };
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { true, 2, 2, 1, 1, 2, 2 };
-        yield return new object[] { true, 40, 40, 1, 1, 2, 2 };
-        yield return new object[] { false, -4, 0, 0, 0, 1, 2 };
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 2, 2, 1, 0, 2, 2 };
-        yield return new object[] { false, 40, 40, 1, 0, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Width_SetWithParentWithHandle_TestData))]
-    public void Control_Width_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, int value, int expectedWidth, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Width = value;
-            Assert.Equal(new Size(expectedWidth, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Width = value;
-            Assert.Equal(new Size(expectedWidth, 0), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, 0), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, 0), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_WindowTargetGetSet()
-    {
-        using var cont = new Control();
-        var mock = new Mock<IWindowTarget>(MockBehavior.Strict);
-
-        cont.WindowTarget = mock.Object;
-
-        Assert.Equal(mock.Object, cont.WindowTarget);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Control_WindowText_Set_GetReturnsExpected(string value)
-    {
-        using var control = new Control
-        {
-            WindowText = value
-        };
-        Assert.Equal(value ?? string.Empty, control.WindowText);
-
-        // Set same.
-        control.WindowText = value;
-        Assert.Equal(value ?? string.Empty, control.WindowText);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Control_WindowText_SetWithHandle_GetReturnsExpected(string value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.WindowText = value;
-        Assert.Equal(value ?? string.Empty, control.WindowText);
-
-        // Set same.
-        control.WindowText = value;
-        Assert.Equal(value ?? string.Empty, control.WindowText);
-    }
-
-    private class SubAxHost : AxHost
-    {
-        public SubAxHost(string clsid) : base(clsid)
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.cs
deleted file mode 100644
index 1bb04299544..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ControlTests.cs
+++ /dev/null
@@ -1,1526 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ControlTests
-{
-    [WinFormsFact]
-    public void Control_Ctor_Default()
-    {
-        using var control = new SubControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Control_Ctor_String(string text, string expectedText)
-    {
-        using var control = new SubControl(text);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { null, -1, -2, -3, -4, string.Empty };
-        yield return new object[] { string.Empty, 0, 0, 0, 0, string.Empty };
-        yield return new object[] { "Text", 1, 2, 3, 4, "Text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Int_Int_Int_Int_TestData))]
-    public void Ctor_String_Int_Int_Int_Int(string text, int left, int top, int width, int height, string expectedText)
-    {
-        using var control = new SubControl(text, left, top, width, height);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(top + height, control.Bottom);
-        Assert.Equal(new Rectangle(left, top, width, height), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(left, control.Left);
-        Assert.Equal(new Point(left, top), 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(new Size(width, height), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(left + width, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(top, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(width, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Ctor_Control_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { new Control(), string.Empty, string.Empty };
-        yield return new object[] { new Control(), "text", "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_String_TestData))]
-    public void Control_Ctor_Control_String(Control parent, string text, string expectedText)
-    {
-        using var control = new SubControl(parent, text);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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.Same(parent, control.Parent);
-        Assert.Equal(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Same(expectedText, control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Ctor_Control_String_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { null, null, -1, -2, -3, -4, string.Empty };
-        yield return new object[] { new Control(), string.Empty, 0, 0, 0, 0, string.Empty };
-        yield return new object[] { new Control(), "text", 1, 2, 3, 4, "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_String_Int_Int_Int_Int_TestData))]
-    public void Control_Ctor_Control_String_Int_Int_Int_Int(Control parent, string text, int left, int top, int width, int height, string expectedText)
-    {
-        using var control = new SubControl(parent, text, left, top, width, height);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(top + height, control.Bottom);
-        Assert.Equal(new Rectangle(left, top, width, height), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(left, control.Left);
-        Assert.Equal(new Point(left, top), 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.Same(parent, control.Parent);
-        Assert.Equal(new Size(width, height), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(left + width, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Same(expectedText, control.Text);
-        Assert.Equal(top, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(width, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_DefaultBackColor_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemColors.Control, Control.DefaultBackColor);
-    }
-
-    [WinFormsFact]
-    public void Control_DefaultForeColor_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemColors.ControlText, Control.DefaultForeColor);
-    }
-
-    [WinFormsFact]
-    public void Control_DefaultFont_Get_ReturnsExpected()
-    {
-        Font font = Control.DefaultFont;
-        Assert.Equal(SystemFonts.MessageBoxFont, Control.DefaultFont);
-        Assert.Same(font, Control.DefaultFont);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x10000)]
-    [InlineData(false, 0)]
-    public void Control_CreateParams_GetContainerControl_ReturnsExpected(bool containerControl, int expectedExStyle)
-    {
-        using var control = new SubControl();
-        control.SetStyle(ControlStyles.ContainerControl, containerControl);
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010000)]
-    [InlineData(false, 0x5E010000)]
-    public void Control_CreateParams_GetEnabled_ReturnsExpected(bool enabled, int expectedStyle)
-    {
-        using var control = new SubControl
-        {
-            Enabled = enabled
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateParams_GetParent_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateParams_GetParentWithHandle_ReturnsExpected()
-    {
-        using var parent = new Control();
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        using var control = new SubControl
-        {
-            Parent = parent
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(parent.Handle, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_CreateParams_GetTopLevel_ReturnsExpected()
-    {
-        using var control = new SubControl();
-        control.SetTopLevel(true);
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.True(createParams.Height > 0);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x12010000, createParams.Style);
-        Assert.True(createParams.Width > 0);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, 0)]
-    [InlineData(RightToLeft.Yes, 0x7000)]
-    [InlineData(RightToLeft.No, 0)]
-    public void Control_CreateParams_GetRightToLeft_ReturnsExpected(RightToLeft rightToLeft, int expectedExStyle)
-    {
-        using var control = new SubControl
-        {
-            RightToLeft = rightToLeft
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010000)]
-    [InlineData(false, 0x56000000)]
-    public void Control_CreateParams_GetTabStop_ReturnsExpected(bool tabStop, int expectedStyle)
-    {
-        using var control = new SubControl
-        {
-            TabStop = tabStop
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010000)]
-    [InlineData(false, 0x46010000)]
-    public void Control_CreateParams_GetVisible_ReturnsExpected(bool visible, int expectedStyle)
-    {
-        using var control = new SubControl
-        {
-            Visible = visible
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_DataContext_AmbientBehaviorTest()
-    {
-        using SubControl control = new();
-        using SubControl childControl = new();
-
-        control.Controls.Add(childControl);
-        string dataContext = "dataContext";
-
-        int callCount = 0;
-        EventHandler controlHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        EventHandler childControlHandler = (sender, e) =>
-        {
-            Assert.Same(childControl, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        control.DataContextChanged += controlHandler;
-        childControl.DataContextChanged += childControlHandler;
-
-        control.DataContext = dataContext;
-        Assert.Equal(dataContext, control.DataContext);
-        Assert.Equal(dataContext, childControl.DataContext);
-
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DataContextChanged -= controlHandler;
-        control.DataContext = null;
-
-        // ChildControl's DataContextChanged should still be called.
-        Assert.Equal(3, callCount);
-        Assert.Null(childControl.DataContext);
-
-        // Testing ambient behavior:
-        // Given: Parent's DataContext = null; ChildControl's DataContext = "dataContext".
-        // We're changing Parent's to "dataContext". ChildControl's DataContextChanged should not be called.
-        childControl.DataContext = dataContext;
-        Assert.Equal(4, callCount);
-        control.DataContext = dataContext;
-        Assert.Equal(4, callCount);
-
-        Assert.Equal(dataContext, control.DataContext);
-        Assert.Equal(dataContext, childControl.DataContext);
-
-        // Remove handler.
-        childControl.DataContextChanged -= childControlHandler;
-        childControl.DataContext = null;
-        Assert.Equal(4, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_GetNextItem_Buttons_CycleForwardExpected(RightToLeft rightToLeft)
-    {
-        using SubControl control = new() { RightToLeft = rightToLeft };
-        using Button button1 = new();
-        using Button button2 = new();
-        using Button button3 = new();
-        control.Controls.AddRange(new Button[] { button1, button2, button3 });
-        Control nextControl1 = control.GetNextControl(button1, forward: true);
-        Control nextControl2 = control.GetNextControl(button2, forward: true);
-        Control nextControl3 = control.GetNextControl(button3, forward: true);
-
-        Assert.Equal(button2, nextControl1);
-        Assert.Equal(button3, nextControl2);
-        Assert.Null(nextControl3);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_GetNextItem_Buttons_CycleBackwardExpected(RightToLeft rightToLeft)
-    {
-        using SubControl control = new() { RightToLeft = rightToLeft };
-        using Button button1 = new();
-        using Button button2 = new();
-        using Button button3 = new();
-        control.Controls.AddRange(new Button[] { button1, button2, button3 });
-        Control previousControl1 = control.GetNextControl(button1, forward: false);
-        Control previousControl2 = control.GetNextControl(button2, forward: false);
-        Control previousControl3 = control.GetNextControl(button3, forward: false);
-
-        Assert.Null(previousControl1);
-        Assert.Equal(button1, previousControl2);
-        Assert.Equal(button2, previousControl3);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_GetNextSelectableControl_Buttons_CycleForwardExpected(RightToLeft rightToLeft)
-    {
-        using SubControl control = new() { RightToLeft = rightToLeft };
-        using Button button1 = new();
-        using Button button2 = new();
-        using Button button3 = new();
-        control.Controls.AddRange(new Button[] { button1, button2, button3 });
-        Control nextControl1 = control.GetNextSelectableControl(button1, forward: true, tabStopOnly: true, nested: true, wrap: true);
-        Control nextControl2 = control.GetNextSelectableControl(button2, forward: true, tabStopOnly: true, nested: true, wrap: true);
-        Control nextControl3 = control.GetNextSelectableControl(button3, forward: true, tabStopOnly: true, nested: true, wrap: true);
-        Control nextControl4 = control.GetNextSelectableControl(button1, forward: true, tabStopOnly: true, nested: true, wrap: true);
-
-        Assert.Equal(button2, nextControl1);
-        Assert.Equal(button3, nextControl2);
-        Assert.Equal(button1, nextControl3);
-        Assert.Equal(button2, nextControl4);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_GetNextSelectableControl_Buttons_CycleBackwardExpected(RightToLeft rightToLeft)
-    {
-        using SubControl control = new() { RightToLeft = rightToLeft };
-        using Button button1 = new();
-        using Button button2 = new();
-        using Button button3 = new();
-        control.Controls.AddRange(new Button[] { button1, button2, button3 });
-        Control previousControl1 = control.GetNextSelectableControl(button1, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl2 = control.GetNextSelectableControl(button3, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl3 = control.GetNextSelectableControl(button2, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl4 = control.GetNextSelectableControl(button1, forward: false, tabStopOnly: true, nested: true, wrap: true);
-
-        Assert.Equal(button3, previousControl1);
-        Assert.Equal(button2, previousControl2);
-        Assert.Equal(button1, previousControl3);
-        Assert.Equal(button3, previousControl4);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_GetNextSelectableControl_MultipleComplexControls_CycleBackwardExpected(RightToLeft rightToLeft)
-    {
-        using SubControl control = new() { RightToLeft = rightToLeft };
-        using TableLayoutPanel table = new() { Dock = DockStyle.Fill, ColumnCount = 3 };
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
-        control.Controls.Add(table);
-        using FlowLayoutPanel panelRadioButtons = new()
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-
-        table.Controls.Add(panelRadioButtons, column: 0, row: 0);
-        using RadioButton radioButton1 = new() { Checked = true };
-        panelRadioButtons.Controls.Add(radioButton1);
-        using RadioButton radioButton2 = new() { Checked = false };
-        panelRadioButtons.Controls.Add(radioButton2);
-        using FlowLayoutPanel panelCheckBoxes = new()
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-
-        table.Controls.Add(panelCheckBoxes, column: 1, row: 0);
-        using CheckBox checkBox1 = new() { Checked = true };
-        panelCheckBoxes.Controls.Add(checkBox1);
-        using CheckBox checkBox2 = new() { Checked = true };
-        panelCheckBoxes.Controls.Add(checkBox2);
-        using FlowLayoutPanel panelButtons = new()
-        {
-            Dock = DockStyle.Fill,
-            FlowDirection = FlowDirection.TopDown
-        };
-
-        table.Controls.Add(panelButtons, column: 2, row: 0);
-        using Button button1 = new();
-        panelButtons.Controls.Add(button1);
-        using Button button2 = new();
-        panelButtons.Controls.Add(button2);
-        Control previousControl1 = control.GetNextSelectableControl(button2, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl2 = control.GetNextSelectableControl(button1, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl3 = control.GetNextSelectableControl(checkBox2, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl4 = control.GetNextSelectableControl(checkBox1, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl5 = control.GetNextSelectableControl(radioButton1, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Control previousControl6 = control.GetNextSelectableControl(button2, forward: false, tabStopOnly: true, nested: true, wrap: true);
-
-        Assert.Equal(button1, previousControl1);
-        Assert.Equal(checkBox2, previousControl2);
-        Assert.Equal(checkBox1, previousControl3);
-        Assert.Equal(radioButton1, previousControl4);
-        Assert.Equal(button2, previousControl5);
-        Assert.Equal(button1, previousControl6);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/6730")]
-    [WinFormsTheory]
-    [SkipOnArchitecture(TestArchitectures.X64,
-        "Flaky tests, see: https://github.com/dotnet/winforms/issues/6730")]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_SelectNextControl_ToolStrips_CycleForwardExpected(RightToLeft rightToLeft)
-    {
-        using Form form = new() { RightToLeft = rightToLeft, };
-        using ToolStrip toolStrip1 = new() { TabStop = true, };
-        using ToolStrip toolStrip2 = new() { TabStop = true, };
-        toolStrip1.CreateControl();
-        toolStrip2.CreateControl();
-        form.CreateControl();
-        using ToolStripButton toolStrip1_Button1 = new();
-        using ToolStripTextBox toolStrip1_TextBox1 = new();
-        using ToolStripComboBox toolStrip1_ComboBox1 = new();
-        using ToolStripSplitButton toolStrip1_SplitButton1 = new();
-        toolStrip1.Items.AddRange(new ToolStripItem[]
-        {
-            toolStrip1_Button1, toolStrip1_TextBox1, toolStrip1_ComboBox1, toolStrip1_SplitButton1
-        });
-
-        using ToolStripComboBox toolStrip2_ComboBox1 = new();
-        using ToolStripSplitButton toolStrip2_SplitButton1 = new();
-        using ToolStripLabel toolStrip2_Label1 = new();
-        using ToolStripSplitButton toolStrip2_DropDownButton1 = new();
-        using ToolStripComboBox toolStrip2_ComboBox2 = new();
-        toolStrip2.Items.AddRange(new ToolStripItem[]
-        {
-            toolStrip2_ComboBox1,
-            toolStrip2_SplitButton1,
-            toolStrip2_Label1,
-            toolStrip2_DropDownButton1,
-            toolStrip2_ComboBox2
-        });
-
-        form.Controls.AddRange(new ToolStrip[] { toolStrip1, toolStrip2 });
-        toolStrip1.ParentInternal.Visible = true;
-        toolStrip2.ParentInternal.Visible = true;
-        toolStrip1_ComboBox1.ParentInternal.Visible = true;
-        toolStrip1_TextBox1.ParentInternal.Visible = true;
-        toolStrip1_ComboBox1.ComboBox.AssignParent(toolStrip1);
-        toolStrip1_TextBox1.Control.AssignParent(toolStrip1);
-
-        var result = form.SelectNextControl(toolStrip1_ComboBox1.ComboBox, forward: true, tabStopOnly: true, nested: true, wrap: true);
-        Assert.True(result);
-        Assert.True(toolStrip2_ComboBox1.Focused);
-        Assert.True(toolStrip2.Items[0].Selected);
-
-        result = form.SelectNextControl(toolStrip1_TextBox1.Control, forward: true, tabStopOnly: true, nested: true, wrap: true);
-        Assert.True(result);
-        Assert.True(toolStrip2_ComboBox1.Focused);
-        Assert.True(toolStrip2.Items[0].Selected);
-
-        Assert.True(form.IsHandleCreated);
-        Assert.True(toolStrip1.IsHandleCreated);
-        Assert.True(toolStrip2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void Control_SelectNextControl_ToolStrips_CycleBackwardExpected(RightToLeft rightToLeft)
-    {
-        using Form form = new() { RightToLeft = rightToLeft };
-        using ToolStrip toolStrip1 = new() { TabStop = true };
-        using ToolStrip toolStrip2 = new() { TabStop = true };
-        toolStrip1.CreateControl();
-        toolStrip2.CreateControl();
-        form.CreateControl();
-        using ToolStripButton toolStrip1_Button1 = new();
-        using ToolStripLabel toolStrip1_Label1 = new();
-        using ToolStripTextBox toolStrip1_TextBox1 = new();
-        using ToolStripSplitButton toolStrip1_SplitButton1 = new();
-        toolStrip1.Items.AddRange(new ToolStripItem[]
-        {
-            toolStrip1_Button1, toolStrip1_Label1, toolStrip1_TextBox1, toolStrip1_SplitButton1
-        });
-
-        using ToolStripComboBox toolStrip2_ComboBox1 = new();
-        using ToolStripSplitButton toolStrip2_SplitButton1 = new();
-        using ToolStripLabel toolStrip2_Label1 = new();
-        using ToolStripSplitButton toolStrip2_DropDownButton1 = new();
-        using ToolStripComboBox toolStrip2_ComboBox2 = new();
-        toolStrip2.Items.AddRange(new ToolStripItem[]
-        {
-            toolStrip2_ComboBox1,
-            toolStrip2_SplitButton1,
-            toolStrip2_Label1,
-            toolStrip2_DropDownButton1,
-            toolStrip2_ComboBox2
-        });
-
-        form.Controls.AddRange(new ToolStrip[] { toolStrip1, toolStrip2 });
-        toolStrip1.ParentInternal.Visible = true;
-        toolStrip2.ParentInternal.Visible = true;
-        toolStrip2_ComboBox1.ParentInternal.Visible = true;
-        toolStrip2_ComboBox2.ParentInternal.Visible = true;
-        toolStrip2_ComboBox1.ComboBox.AssignParent(toolStrip2);
-        toolStrip2_ComboBox2.ComboBox.AssignParent(toolStrip2);
-
-        var result = form.SelectNextControl(toolStrip2_ComboBox2.ComboBox, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Assert.True(result);
-        Assert.True(toolStrip1.Focused);
-        Assert.True(toolStrip1.Items[0].Selected);
-
-        result = form.SelectNextControl(toolStrip2_ComboBox1.ComboBox, forward: false, tabStopOnly: true, nested: true, wrap: true);
-        Assert.True(result);
-        Assert.True(toolStrip1.Focused);
-        Assert.True(toolStrip1.Items[0].Selected);
-
-        Assert.True(form.IsHandleCreated);
-        Assert.True(toolStrip1.IsHandleCreated);
-        Assert.True(toolStrip2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_RecreateHandleCore_invokes_OnParentHandleRecreated_for_children()
-    {
-        using Form form = new();
-        SubCheckedListBox checkedListBox1 = new();
-        SubButton button1 = new();
-        SubListBox listBox1 = new();
-        SubListView listView1 = new();
-
-        checkedListBox1.Items.AddRange(new object[] { "Foo", "Foo", "Foo" });
-        checkedListBox1.Location = new Point(10, 10);
-        checkedListBox1.Size = new Size(103, 64);
-
-        button1.Location = new Point(12, 166);
-        button1.Size = new Size(213, 20);
-
-        listBox1.Items.AddRange(new object[] { "Foo", "Foo", "Foo" });
-        listBox1.Location = new Point(12, 80);
-        listBox1.Size = new Size(101, 69);
-
-        listView1.Items.AddRange(new ListViewItem[] { new("Foo"), new("Foo"), new("Foo") });
-        listView1.Location = new Point(130, 10);
-        listView1.Size = new Size(121, 64);
-        listView1.View = View.List;
-
-        form.Controls.Add(checkedListBox1);
-        form.Controls.Add(button1);
-        form.Controls.Add(listBox1);
-        form.Controls.Add(listView1);
-
-        form.Show();
-
-        // This will recreate the handle.
-        form.ShowInTaskbar = false;
-
-        try
-        {
-            AssertHandler(button1);
-            AssertHandler(listView1);
-            AssertHandler(checkedListBox1);
-            AssertHandler(listBox1);
-        }
-        finally
-        {
-            form.Close();
-        }
-
-        return;
-
-        static void AssertHandler(IParentHandleRecreationHandler handler)
-        {
-            Assert.Equal(1, handler.OnParentHandleRecreatedCalled);
-            Assert.Equal(1, handler.OnParentHandleRecreatingCalled);
-        }
-    }
-
-    [WinFormsFact]
-    public void Control_OnCreateControl_Triggered_Once_Expected()
-    {
-        // regression test for https://github.com/dotnet/winforms/issues/8495 and https://github.com/dotnet/winforms/issues/8489
-        // In both issues CreateControl method was not exiting early when the control was already created
-        // causing various unexpected behavior. This test ensures that a control does not try to go through
-        // CreateControl more than expected.
-        using Form form = new();
-        using OnCreateControlCounter control = new();
-        form.Controls.Add(control);
-        form.Shown += (s, e) => { form.Close(); };
-
-        form.ShowDialog();
-
-        // Calling show on the form will cause the control to be created and trigger OnCreateControl. Once
-        // the control is created, another show message will dispatch, which should cause CreateControl method to
-        // exit early, avoiding another trigger to OnCreateControl.
-        Assert.Equal(1, control.OnCreateControlCount);
-    }
-
-    private class OnCreateControlCounter : Control
-    {
-        public int OnCreateControlCount { get; set; }
-
-        protected override void OnCreateControl()
-        {
-            base.OnCreateControl();
-            OnCreateControlCount++;
-        }
-    }
-
-    private class SubControl : Control
-    {
-        public SubControl() : base()
-        {
-        }
-
-        public SubControl(string text) : base(text)
-        {
-        }
-
-        public SubControl(string text, int left, int top, int width, int height) : base(text, left, top, width, height)
-        {
-        }
-
-        public SubControl(Control parent, string text) : base(parent, text)
-        {
-        }
-
-        public SubControl(Control parent, string text, int left, int top, int width, int height) : base(parent, text, left, top, width, height)
-        {
-        }
-
-        public Control GetNextSelectableControl(Control ctl, bool forward, bool tabStopOnly, bool nested, bool wrap)
-            => this.TestAccessor().Dynamic.GetNextSelectableControl(ctl, forward, tabStopOnly, nested, wrap);
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new void AccessibilityNotifyClients(AccessibleEvents accEvent, int childID) => base.AccessibilityNotifyClients(accEvent, childID);
-
-        public new void AccessibilityNotifyClients(AccessibleEvents accEvent, int objectID, int childID) => base.AccessibilityNotifyClients(accEvent, objectID, childID);
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new void DestroyHandle() => base.DestroyHandle();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) => base.GetScaledBounds(bounds, factor, specified);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void InitLayout() => base.InitLayout();
-
-        public new void InvokeGotFocus(Control toInvoke, EventArgs e) => base.InvokeGotFocus(toInvoke, e);
-
-        public new void InvokeLostFocus(Control toInvoke, EventArgs e) => base.InvokeLostFocus(toInvoke, e);
-
-        public new void InvokePaint(Control c, PaintEventArgs e) => base.InvokePaint(c, e);
-
-        public new void InvokePaintBackground(Control c, PaintEventArgs e) => base.InvokePaintBackground(c, e);
-
-        public new bool IsInputChar(char charCode) => base.IsInputChar(charCode);
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void NotifyInvalidate(Rectangle invalidatedArea) => base.NotifyInvalidate(invalidatedArea);
-
-        public new void OnAutoSizeChanged(EventArgs e) => base.OnAutoSizeChanged(e);
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnBackgroundImageChanged(EventArgs e) => base.OnBackgroundImageChanged(e);
-
-        public new void OnBackgroundImageLayoutChanged(EventArgs e) => base.OnBackgroundImageLayoutChanged(e);
-
-        public new void OnBindingContextChanged(EventArgs e) => base.OnBindingContextChanged(e);
-
-        public new void OnCausesValidationChanged(EventArgs e) => base.OnCausesValidationChanged(e);
-
-        public new void OnChangeUICues(UICuesEventArgs e) => base.OnChangeUICues(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnClientSizeChanged(EventArgs e) => base.OnClientSizeChanged(e);
-
-        public new void OnContextMenuStripChanged(EventArgs e) => base.OnContextMenuStripChanged(e);
-
-        public new void OnControlAdded(ControlEventArgs e) => base.OnControlAdded(e);
-
-        public new void OnControlRemoved(ControlEventArgs e) => base.OnControlRemoved(e);
-
-        public new void OnCreateControl() => base.OnCreateControl();
-
-        public new void OnCursorChanged(EventArgs e) => base.OnCursorChanged(e);
-
-        public new void OnDockChanged(EventArgs e) => base.OnDockChanged(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnDpiChangedAfterParent(EventArgs e) => base.OnDpiChangedAfterParent(e);
-
-        public new void OnDpiChangedBeforeParent(EventArgs e) => base.OnDpiChangedBeforeParent(e);
-
-        public new void OnDragDrop(DragEventArgs e) => base.OnDragDrop(e);
-
-        public new void OnDragEnter(DragEventArgs e) => base.OnDragEnter(e);
-
-        public new void OnDragLeave(EventArgs e) => base.OnDragLeave(e);
-
-        public new void OnDragOver(DragEventArgs e) => base.OnDragOver(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnGiveFeedback(GiveFeedbackEventArgs e) => base.OnGiveFeedback(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnHelpRequested(HelpEventArgs e) => base.OnHelpRequested(e);
-
-        public new void OnImeModeChanged(EventArgs e) => base.OnImeModeChanged(e);
-
-        public new void OnInvalidated(InvalidateEventArgs e) => base.OnInvalidated(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnLocationChanged(EventArgs e) => base.OnLocationChanged(e);
-
-        public new void OnLostFocus(EventArgs e) => base.OnLostFocus(e);
-
-        public new void OnMarginChanged(EventArgs e) => base.OnMarginChanged(e);
-
-        public new void OnMouseCaptureChanged(EventArgs e) => base.OnMouseCaptureChanged(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseHover(EventArgs e) => base.OnMouseHover(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnMouseWheel(MouseEventArgs e) => base.OnMouseWheel(e);
-
-        public new void OnMove(EventArgs e) => base.OnMove(e);
-
-        public new void OnPaddingChanged(EventArgs e) => base.OnPaddingChanged(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnParentBackColorChanged(EventArgs e) => base.OnParentBackColorChanged(e);
-
-        public new void OnParentBackgroundImageChanged(EventArgs e) => base.OnParentBackgroundImageChanged(e);
-
-        public new void OnParentBindingContextChanged(EventArgs e) => base.OnParentBindingContextChanged(e);
-
-        public new void OnParentCursorChanged(EventArgs e) => base.OnParentCursorChanged(e);
-
-        public new void OnParentEnabledChanged(EventArgs e) => base.OnParentEnabledChanged(e);
-
-        public new void OnParentFontChanged(EventArgs e) => base.OnParentFontChanged(e);
-
-        public new void OnParentForeColorChanged(EventArgs e) => base.OnParentForeColorChanged(e);
-
-        public new void OnParentVisibleChanged(EventArgs e) => base.OnParentVisibleChanged(e);
-
-        public new void OnPrint(PaintEventArgs e) => base.OnPrint(e);
-
-        public new void OnQueryContinueDrag(QueryContinueDragEventArgs e) => base.OnQueryContinueDrag(e);
-
-        public new void OnRegionChanged(EventArgs e) => base.OnRegionChanged(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-
-        public new void OnSizeChanged(EventArgs e) => base.OnSizeChanged(e);
-
-        public new void OnStyleChanged(EventArgs e) => base.OnStyleChanged(e);
-
-        public new void OnSystemColorsChanged(EventArgs e) => base.OnSystemColorsChanged(e);
-
-        public new void OnTabIndexChanged(EventArgs e) => base.OnTabIndexChanged(e);
-
-        public new void OnTabStopChanged(EventArgs e) => base.OnTabStopChanged(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new void OnValidated(EventArgs e) => base.OnValidated(e);
-
-        public new void OnValidating(CancelEventArgs e) => base.OnValidating(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new bool ProcessCmdKey(ref Message msg, Keys keyData) => base.ProcessCmdKey(ref msg, keyData);
-
-        public new bool ProcessDialogChar(char charCode) => base.ProcessDialogChar(charCode);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new bool ProcessKeyEventArgs(ref Message m) => base.ProcessKeyEventArgs(ref m);
-
-        public new bool ProcessKeyMessage(ref Message m) => base.ProcessKeyMessage(ref m);
-
-        public new bool ProcessKeyPreview(ref Message m) => base.ProcessKeyPreview(ref m);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void RecreateHandle() => base.RecreateHandle();
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void ResetMouseEventArgs() => base.ResetMouseEventArgs();
-
-        public new HorizontalAlignment RtlTranslateAlignment(HorizontalAlignment align) => base.RtlTranslateAlignment(align);
-
-        public new LeftRightAlignment RtlTranslateAlignment(LeftRightAlignment align) => base.RtlTranslateAlignment(align);
-
-        public new ContentAlignment RtlTranslateAlignment(ContentAlignment align) => base.RtlTranslateAlignment(align);
-
-        public new ContentAlignment RtlTranslateContent(ContentAlignment align) => base.RtlTranslateContent(align);
-
-        public new HorizontalAlignment RtlTranslateHorizontal(HorizontalAlignment align) => base.RtlTranslateHorizontal(align);
-
-        public new LeftRightAlignment RtlTranslateLeftRight(LeftRightAlignment align) => base.RtlTranslateLeftRight(align);
-
-        public new void SetAutoSizeMode(AutoSizeMode mode) => base.SetAutoSizeMode(mode);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetClientSizeCore(int x, int y) => base.SetClientSizeCore(x, y);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void SetTopLevel(bool value) => base.SetTopLevel(value);
-
-        public new Size SizeFromClientSize(Size clientSize) => base.SizeFromClientSize(clientSize);
-
-        public new void UpdateBounds() => base.UpdateBounds();
-
-        public new void UpdateBounds(int x, int y, int width, int height) => base.UpdateBounds(x, y, width, height);
-
-        public new void UpdateBounds(int x, int y, int width, int height, int clientWidth, int clientHeight) => base.UpdateBounds(x, y, width, height, clientWidth, clientHeight);
-
-        public new void UpdateStyles() => base.UpdateStyles();
-
-        public new void UpdateZOrder() => base.UpdateZOrder();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class SubCheckedListBox : CheckedListBox, IParentHandleRecreationHandler
-    {
-        public int OnParentHandleRecreatedCalled { get; private set; }
-        public int OnParentHandleRecreatingCalled { get; private set; }
-
-        internal override void OnParentHandleRecreated()
-        {
-            OnParentHandleRecreatedCalled++;
-            base.OnParentHandleRecreated();
-        }
-
-        internal override void OnParentHandleRecreating()
-        {
-            OnParentHandleRecreatingCalled++;
-            base.OnParentHandleRecreating();
-        }
-    }
-
-    private class SubListBox : ListBox, IParentHandleRecreationHandler
-    {
-        public int OnParentHandleRecreatedCalled { get; private set; }
-        public int OnParentHandleRecreatingCalled { get; private set; }
-
-        internal override void OnParentHandleRecreated()
-        {
-            OnParentHandleRecreatedCalled++;
-            base.OnParentHandleRecreated();
-        }
-
-        internal override void OnParentHandleRecreating()
-        {
-            OnParentHandleRecreatingCalled++;
-            base.OnParentHandleRecreating();
-        }
-    }
-
-    private class SubButton : Button, IParentHandleRecreationHandler
-    {
-        public int OnParentHandleRecreatedCalled { get; private set; }
-        public int OnParentHandleRecreatingCalled { get; private set; }
-
-        internal override void OnParentHandleRecreated()
-        {
-            OnParentHandleRecreatedCalled++;
-            base.OnParentHandleRecreated();
-        }
-
-        internal override void OnParentHandleRecreating()
-        {
-            OnParentHandleRecreatingCalled++;
-            base.OnParentHandleRecreating();
-        }
-    }
-
-    private class SubListView : ListView, IParentHandleRecreationHandler
-    {
-        public int OnParentHandleRecreatedCalled { get; private set; }
-        public int OnParentHandleRecreatingCalled { get; private set; }
-
-        internal override void OnParentHandleRecreated()
-        {
-            OnParentHandleRecreatedCalled++;
-            base.OnParentHandleRecreated();
-        }
-
-        internal override void OnParentHandleRecreating()
-        {
-            OnParentHandleRecreatingCalled++;
-            base.OnParentHandleRecreating();
-        }
-    }
-
-    private interface IParentHandleRecreationHandler
-    {
-        int OnParentHandleRecreatedCalled { get; }
-        int OnParentHandleRecreatingCalled { get; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ConvertEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ConvertEventArgsTests.cs
deleted file mode 100644
index 72e202ce279..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ConvertEventArgsTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ConvertEventArgsTests
-{
-    [Theory]
-    [InlineData("value", typeof(int))]
-    [InlineData(null, null)]
-    public void Ctor_Object_Type(object value, Type desiredType)
-    {
-        var e = new ConvertEventArgs(value, desiredType);
-        Assert.Equal(value, e.Value);
-        Assert.Equal(desiredType, e.DesiredType);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(1)]
-    public void Value_Set_GetReturnsExpected(object value)
-    {
-        var e = new ConvertEventArgs("value", typeof(int))
-        {
-            Value = value
-        };
-        Assert.Equal(value, e.Value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CreateParamsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CreateParamsTests.cs
deleted file mode 100644
index 81c54938500..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CreateParamsTests.cs
+++ /dev/null
@@ -1,150 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class CreateParamsTests
-{
-    [Theory]
-    [StringWithNullData]
-    public void CreateParams_ClassName_Set_GetReturnsExpected(string value)
-    {
-        var createParams = new CreateParams
-        {
-            ClassName = value
-        };
-        Assert.Equal(value, createParams.ClassName);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void CreateParams_Caption_Set_GetReturnsExpected(string value)
-    {
-        var createParams = new CreateParams
-        {
-            Caption = value
-        };
-        Assert.Equal(value, createParams.Caption);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_Style_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            Style = value
-        };
-        Assert.Equal(value, createParams.Style);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_ExStyle_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            ExStyle = value
-        };
-        Assert.Equal(value, createParams.ExStyle);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_ClassStyle_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            ClassStyle = value
-        };
-        Assert.Equal(value, createParams.ClassStyle);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_X_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            X = value
-        };
-        Assert.Equal(value, createParams.X);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_Y_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            Y = value
-        };
-        Assert.Equal(value, createParams.Y);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_Width_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            Width = value
-        };
-        Assert.Equal(value, createParams.Width);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void CreateParams_Height_Set_GetReturnsExpected(int value)
-    {
-        var createParams = new CreateParams
-        {
-            Height = value
-        };
-        Assert.Equal(value, createParams.Height);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetIntPtrTheoryData))]
-    public void CreateParams_Parent_Set_GetReturnsExpected(IntPtr value)
-    {
-        var createParams = new CreateParams
-        {
-            Parent = value
-        };
-        Assert.Equal(value, createParams.Parent);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void CreateParams_Param_Set_GetReturnsExpected(string value)
-    {
-        var createParams = new CreateParams
-        {
-            Param = value
-        };
-        Assert.Equal(value, createParams.Param);
-    }
-
-    [Fact]
-    public void CreateParams_ToString_Invoke_ReturnsExpected()
-    {
-        var createParams = new CreateParams
-        {
-            ClassName = "className",
-            Caption = "caption",
-            Style = 10,
-            ExStyle = 11,
-            X = 12,
-            Y = 13,
-            Width = 14,
-            Height = 15,
-            Parent = (IntPtr)16,
-            Param = "param"
-        };
-        Assert.Equal("CreateParams {'className', 'caption', 0xa, 0xb, {12, 13, 14, 15}}", createParams.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorConverterTests.cs
deleted file mode 100644
index 024743cf783..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorConverterTests.cs
+++ /dev/null
@@ -1,235 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Drawing;
-using System.Reflection;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class CursorConverterTests
-{
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetConvertFromTheoryData))]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(byte[]), true)]
-    [InlineData(typeof(Cursor), false)]
-    public void CursorConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new CursorConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    [Theory]
-    [InlineData("AppStarting")]
-    [InlineData("appstarting")]
-    public void CursorConverter_ConvertFrom_KnownCursor_ReturnsExpected(string value)
-    {
-        var converter = new CursorConverter();
-        Assert.Same(Cursors.AppStarting, converter.ConvertFrom(value));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertFrom_ByteArray_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        byte[] data = File.ReadAllBytes(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        using Cursor cursor = Assert.IsType<Cursor>(converter.ConvertFrom(data));
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Assert.Equal(new Point(5, 8), cursor.HotSpot);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData("NoSuchString")]
-    [InlineData(null)]
-    public void CursorConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertFrom_InvalidByteArray_ThrowsArgumentException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<ArgumentException>("stream", () => converter.ConvertFrom(Array.Empty<byte>()));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(byte[]), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(Cursor), false)]
-    [InlineData(null, false)]
-    public void CursorConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new CursorConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_KnownToString_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        Assert.Equal("AppStarting", converter.ConvertTo(Cursors.AppStarting, typeof(string)));
-        Assert.Equal("AppStarting", converter.ConvertTo(new Cursor(Cursors.AppStarting.Handle), typeof(string)));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_UnknownToString_ThrowsFormatException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<FormatException>(() => converter.ConvertTo(new Cursor((IntPtr)2), typeof(string)));
-    }
-
-    [Theory]
-    [InlineData(null, "")]
-    [InlineData(1, "1")]
-    public void CursorConverter_ConvertTo_ValueNotCursorToString_ReturnsExpected(object value, string expected)
-    {
-        var converter = new CursorConverter();
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_KnownToInstanceDescriptor_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(Cursors.AppStarting, typeof(InstanceDescriptor)));
-        Assert.Empty(descriptor.Arguments);
-        Assert.Equal(typeof(Cursors).GetProperty(nameof(Cursors.AppStarting), BindingFlags.Public | BindingFlags.Static), descriptor.MemberInfo);
-        Assert.True(descriptor.IsComplete);
-
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new Cursor(Cursors.AppStarting.Handle), typeof(InstanceDescriptor)));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_UnknownToInstanceDescriptor_ThrowsNotSupportedException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new Cursor((IntPtr)2), typeof(InstanceDescriptor)));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_NullToInstanceDescriptor_ThrowsNotSupportedException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(null, typeof(InstanceDescriptor)));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_StreamToByteArray_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        byte[] data = File.ReadAllBytes(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        using var stream = new MemoryStream(data);
-        using var sourceCursor = new Cursor(stream);
-        Assert.Equal(data, converter.ConvertTo(sourceCursor, typeof(byte[])));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_FileToByteArray_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        string fileName = Path.Combine("bitmaps", "10x16_one_entry_32bit.ico");
-        byte[] data = File.ReadAllBytes(fileName);
-        using var sourceCursor = new Cursor(fileName);
-        Assert.Equal(data, converter.ConvertTo(sourceCursor, typeof(byte[])));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_KnownToByteArray_ThrowsFormatException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<FormatException>(() => converter.ConvertTo(Cursors.AppStarting, typeof(byte[])));
-        Assert.Throws<InvalidOperationException>(() => converter.ConvertTo(new Cursor(Cursors.AppStarting.Handle), typeof(byte[])));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_UnknownToByteArray_ThrowsFormatException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<InvalidOperationException>(() => converter.ConvertTo(new Cursor((IntPtr)2), typeof(byte[])));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_NullToByteArray_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-        Assert.Empty(Assert.IsType<byte[]>(converter.ConvertTo(null, typeof(byte[]))));
-    }
-
-    [Fact]
-    public void CursorConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Theory]
-    [InlineData(typeof(InstanceDescriptor))]
-    [InlineData(typeof(byte[]))]
-    public void CursorConverter_ConvertTo_ValueNotCursor_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new CursorConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, destinationType));
-    }
-
-    [Fact]
-    public void CursorConverter_GetStandardValues_Invoke_ReturnsExpected()
-    {
-        var converter = new CursorConverter();
-
-        // The static accessors only provide a weak guarantee about their return values, when multiple threads
-        // are involved it is possible that return values differ between calls. We need a dry run and memory barrier
-        // to ensure the fields backing the property are all initialized and visible to the current thread,
-        // failing to do so means that the very first call to a static cursor accessor may return a different
-        // cursor instance than subsequent calls.
-        converter.GetStandardValues();
-        Threading.Thread.MemoryBarrier();
-
-        ICollection<Cursor> values = converter.GetStandardValues().Cast<Cursor>().ToArray();
-        Assert.Equal(28, values.Count);
-        Assert.Contains(Cursors.AppStarting, values);
-        Assert.Contains(Cursors.Arrow, values);
-        Assert.Contains(Cursors.Cross, values);
-        Assert.Contains(Cursors.Default, values);
-        Assert.Contains(Cursors.Hand, values);
-        Assert.Contains(Cursors.Help, values);
-        Assert.Contains(Cursors.HSplit, values);
-        Assert.Contains(Cursors.IBeam, values);
-        Assert.Contains(Cursors.No, values);
-        Assert.Contains(Cursors.NoMove2D, values);
-        Assert.Contains(Cursors.NoMoveHoriz, values);
-        Assert.Contains(Cursors.NoMoveVert, values);
-        Assert.Contains(Cursors.PanEast, values);
-        Assert.Contains(Cursors.PanNE, values);
-        Assert.Contains(Cursors.PanNorth, values);
-        Assert.Contains(Cursors.PanNW, values);
-        Assert.Contains(Cursors.PanSE, values);
-        Assert.Contains(Cursors.PanSouth, values);
-        Assert.Contains(Cursors.PanSW, values);
-        Assert.Contains(Cursors.PanWest, values);
-        Assert.Contains(Cursors.SizeAll, values);
-        Assert.Contains(Cursors.SizeNESW, values);
-        Assert.Contains(Cursors.SizeNS, values);
-        Assert.Contains(Cursors.SizeNWSE, values);
-        Assert.Contains(Cursors.SizeWE, values);
-        Assert.Contains(Cursors.UpArrow, values);
-        Assert.Contains(Cursors.VSplit, values);
-        Assert.Contains(Cursors.WaitCursor, values);
-        Assert.NotSame(values, converter.GetStandardValues());
-    }
-
-    [Fact]
-    public void CursorConverter_GetStandardValuesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new CursorConverter();
-        Assert.True(converter.GetStandardValuesSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorTests.cs
deleted file mode 100644
index f4f89aa4be7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorTests.cs
+++ /dev/null
@@ -1,510 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Design.Tests;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-[Collection(nameof(CursorTestsCollection))]
-public class CursorTests
-{
-    // Some controls have behavior that changes when the mouse is over them. To avoid verification issues, keep these
-    // tests from running when other tests do and move the cursor back to 0,0 when they are done.
-    //
-    // See https://github.com/dotnet/winforms/pull/7031#issuecomment-1101339968 for an example of this.
-
-    [CollectionDefinition(nameof(CursorTestsCollection), DisableParallelization = true)]
-    public class CursorTestsCollection : ICollectionFixture<CursorTestsCollection.CursorTestsFixture>
-    {
-        public class CursorTestsFixture : IDisposable
-        {
-            public CursorTestsFixture() => Cursor.Position = default;
-
-            public void Dispose() => Cursor.Position = default;
-        }
-    }
-
-    [Fact]
-    public void Cursor_Ctor_IntPtr()
-    {
-        Cursor sourceCursor = Cursors.AppStarting;
-        using var cursor = new Cursor(sourceCursor.Handle);
-        Assert.Equal(sourceCursor.Handle, cursor.Handle);
-        Assert.Equal(sourceCursor.HotSpot, cursor.HotSpot);
-        Assert.Equal(sourceCursor.Size, cursor.Size);
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_IntPtr_Invalid()
-    {
-        using var cursor = new Cursor(-1000);
-        Assert.Equal(-1000, cursor.Handle);
-        Assert.Equal(new Point(0, 0), cursor.HotSpot);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_ZeroHandle_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>("handle", () => new Cursor(IntPtr.Zero));
-    }
-
-    public static IEnumerable<object[]> Ctor_ValidFile_TestData()
-    {
-        yield return new object[] { Path.Combine("bitmaps", "cursor.cur"), Point.Empty };
-        yield return new object[] { Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"), new Point(5, 8) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ValidFile_TestData))]
-    public void Cursor_Ctor_Stream(string fileName, Point expectedHotSpot)
-    {
-        using var stream = new MemoryStream(File.ReadAllBytes(fileName));
-        using var cursor = new Cursor(stream);
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Assert.Equal(expectedHotSpot, cursor.HotSpot);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_Stream_NonStartPosition()
-    {
-        using var stream = new MemoryStream(File.ReadAllBytes(Path.Combine("bitmaps", "cursor.cur")));
-        stream.Position = 5;
-        using var cursor = new Cursor(stream);
-        Assert.NotNull(cursor);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_EmptyStream_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>("stream", () => new Cursor(new MemoryStream()));
-    }
-
-    [Fact]
-    public void Cursor_Ctor_NullStream_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("stream", () => new Cursor((Stream)null));
-    }
-
-    public static IEnumerable<object[]> Ctor_InvalidFile_TestData()
-    {
-        yield return new object[] { Path.Combine("bitmaps", "nature24bits.jpg") };
-        yield return new object[] { Path.Combine("bitmaps", "nature24bits.gif") };
-        yield return new object[] { Path.Combine("bitmaps", "1bit.png") };
-        yield return new object[] { Path.Combine("bitmaps", "almogaver24bits.bmp") };
-        yield return new object[] { Path.Combine("bitmaps", "telescope_01.wmf") };
-        yield return new object[] { Path.Combine("bitmaps", "milkmateya01.emf") };
-        yield return new object[] { Path.Combine("bitmaps", "EmptyFile") };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidFile_TestData))]
-    public void Cursor_Ctor_StreamNotIcon_ThrowsArgumentException(string fileName)
-    {
-        using var stream = new MemoryStream(File.ReadAllBytes(fileName));
-        Assert.Throws<ArgumentException>("stream", () => new Cursor(stream));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ValidFile_TestData))]
-    public void Cursor_Ctor_String(string fileName, Point expectedHotSpot)
-    {
-        using var cursor = new Cursor(fileName);
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Assert.Equal(expectedHotSpot, cursor.HotSpot);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_NullFileName_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("path", () => new Cursor((string)null));
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("pa\0th")]
-    public void Cursor_Ctor_InvalidFileName_ThrowsArgumentException(string fileName)
-    {
-        Assert.Throws<ArgumentException>("path", () => new Cursor(fileName));
-    }
-
-    [Fact]
-    public void Cursor_Ctor_NoSuchFileName_ThrowsFileNotFoundException()
-    {
-        Assert.Throws<FileNotFoundException>(() => new Cursor("NoSuchFile"));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidFile_TestData))]
-    public void Cursor_Ctor_FileNotIcon_ThrowsArgumentException(string fileName)
-    {
-        Assert.Throws<ArgumentException>("fileName", () => new Cursor(fileName));
-    }
-
-    [Fact]
-    public void Cursor_Ctor_Type_String()
-    {
-        using var cursor = new Cursor(typeof(PropertyTabTests), "CustomPropertyTab");
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Assert.Equal(new Point(5, 8), cursor.HotSpot);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Ctor_NullType_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("type", () => new Cursor(null, "resource"));
-    }
-
-    [Theory]
-    [InlineData(typeof(PropertyTabTests), "NoSuchType")]
-    [InlineData(typeof(PropertyTabTests), "")]
-    [InlineData(typeof(PropertyTabTests), null)]
-    public void Cursor_Ctor_NoSuchResource_ThrowsArgumentNullException(Type type, string resource)
-    {
-        Assert.Throws<ArgumentNullException>("stream", () => new Cursor(type, resource));
-    }
-
-    [Fact]
-    public void Cursor_Clip_Get_ReturnsExpected()
-    {
-        Rectangle clip = Cursor.Clip;
-
-        // Cursor location can be negative when it's located on a secondary screen to the left of
-        // or above the primary one.
-        Assert.True(clip.Width >= 0);
-        Assert.True(clip.Height >= 0);
-    }
-
-    [Fact]
-    public void Cursor_Clip_Set_GetReturnsExpected()
-    {
-        DPI_AWARENESS_CONTEXT oldDpiAwarenessContext = DPI_AWARENESS_CONTEXT.UNSPECIFIED_DPI_AWARENESS_CONTEXT;
-        Rectangle clip = Cursor.Clip;
-        try
-        {
-            // The clipping area is always defined in physical pixels (disregarding DPI) while
-            // the virtual screen area depends on the DPI awareness of the thread querying for it.
-            // Cannot use DpiAwarenessScope because it rejects to change the DPI awareness.
-            oldDpiAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-            // Set non-empty.
-            Cursor.Clip = new Rectangle(1, 2, 3, 4);
-            Assert.True(Cursor.Clip.X >= 0);
-            Assert.True(Cursor.Clip.Y >= 0);
-            Assert.True(Cursor.Clip.Width >= 0);
-            Assert.True(Cursor.Clip.Height >= 0);
-
-            Rectangle virtualScreen = SystemInformation.VirtualScreen;
-
-            // Set empty.
-            Cursor.Clip = new Rectangle(0, 0, 0, 0);
-            Assert.Equal(virtualScreen, Cursor.Clip);
-
-            // Set outside normal bounds.
-            Cursor.Clip = Rectangle.Inflate(virtualScreen, 10, 10);
-            Assert.Equal(virtualScreen, Cursor.Clip);
-        }
-        finally
-        {
-            if (oldDpiAwarenessContext != DPI_AWARENESS_CONTEXT.UNSPECIFIED_DPI_AWARENESS_CONTEXT)
-                PInvoke.SetThreadDpiAwarenessContextInternal(oldDpiAwarenessContext);
-
-            Cursor.Clip = clip;
-        }
-    }
-
-    [Fact]
-    public void Cursor_Current_Get_ReturnsExpected()
-    {
-        Cursor cursor = Cursor.Current;
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Point hotSpot = cursor.HotSpot;
-        Assert.True(hotSpot.X >= 0 && hotSpot.X <= cursor.Size.Width);
-        Assert.True(hotSpot.Y >= 0 && hotSpot.Y <= cursor.Size.Height);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-        Assert.NotSame(cursor, Cursor.Current);
-    }
-
-    [Fact]
-    public void Cursor_Current_Set_GetReturnsExpected()
-    {
-        Cursor current = Cursor.Current;
-        try
-        {
-            // Set non-null.
-            Cursor value = new Cursor(Cursors.AppStarting.Handle);
-            Cursor.Current = value;
-            Assert.Equal(value.Handle, Cursor.Current.Handle);
-
-            // Set null.
-            Cursor.Current = null;
-            Assert.Null(Cursor.Current);
-        }
-        finally
-        {
-            Cursor.Current = current;
-        }
-    }
-
-    [Fact]
-    public void Cursor_Position_Get_ReturnsExpected()
-    {
-        Point position = Cursor.Position;
-        Rectangle virtualScreen = SystemInformation.VirtualScreen;
-
-        Assert.True(position.X >= virtualScreen.X);
-        Assert.True(position.Y >= virtualScreen.Y);
-        Assert.True(position.X <= virtualScreen.Right);
-        Assert.True(position.Y <= virtualScreen.Bottom);
-    }
-
-    [Fact]
-    public void Cursor_Position_Set_GetReturnsExpected()
-    {
-        Point position = Cursor.Position;
-        try
-        {
-            Cursor.Position = new Point(1, 2);
-            position = Cursor.Position;
-            Assert.True(position.X >= 0);
-            Assert.True(position.Y >= 0);
-
-            Rectangle virtualScreen = SystemInformation.VirtualScreen;
-            Cursor.Position = new Point(virtualScreen.X - 1, virtualScreen.Y - 1);
-            position = Cursor.Position;
-            Assert.True(position.X >= virtualScreen.X);
-            Assert.True(position.Y >= virtualScreen.Y);
-        }
-        finally
-        {
-            Cursor.Position = position;
-        }
-    }
-
-    [Fact]
-    public void Cursor_Show_InvokeMultipleTimes_Success()
-    {
-        Cursor.Show();
-        Cursor.Show();
-    }
-
-    [Fact]
-    public void Cursor_Hide_InvokeMultipleTimes_Success()
-    {
-        Cursor.Hide();
-        Cursor.Hide();
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void Cursor_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var cursor = new Cursor(2)
-        {
-            Tag = value
-        };
-        Assert.Same(value, cursor.Tag);
-
-        // Set same.
-        cursor.Tag = value;
-        Assert.Same(value, cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_CopyHandle_Invoke_Success()
-    {
-        using var sourceCursor = new Cursor(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        IntPtr handle = sourceCursor.CopyHandle();
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.NotEqual(sourceCursor.Handle, handle);
-
-        using var cursor = new Cursor(sourceCursor.Handle);
-        Assert.Equal(sourceCursor.Handle, cursor.Handle);
-        Assert.Equal(sourceCursor.HotSpot, cursor.HotSpot);
-        Assert.Equal(sourceCursor.Size, cursor.Size);
-        Assert.Null(cursor.Tag);
-    }
-
-    [Fact]
-    public void Cursor_Dispose_InvokeOwned_Success()
-    {
-        var cursor = new Cursor(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        cursor.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => cursor.Handle);
-        Assert.Throws<ObjectDisposedException>(() => cursor.HotSpot);
-
-        cursor.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => cursor.Handle);
-        Assert.Throws<ObjectDisposedException>(() => cursor.HotSpot);
-    }
-
-    [Fact]
-    public void Cursor_Dispose_InvokeNotOwned_Success()
-    {
-        var cursor = new Cursor(2);
-        cursor.Dispose();
-
-        // Cursors not owned should not be disposed.
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, Cursors.Default.Size.Width, Cursors.Default.Size.Height) };
-        yield return new object[] { new Rectangle(1, 0, Cursors.Default.Size.Width, Cursors.Default.Size.Height) };
-        yield return new object[] { new Rectangle(0, 2, 3, Cursors.Default.Size.Height) };
-        yield return new object[] { new Rectangle(0, 0, Cursors.Default.Size.Width, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void Cursor_Draw_InvokeValidCursor_Success(Rectangle rectangle)
-    {
-        using var cursor = new Cursor(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        cursor.Draw(graphics, rectangle);
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void Cursor_Draw_InvokeInvalidCursor_Success(Rectangle rectangle)
-    {
-        using var cursor = new Cursor(-1000);
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        cursor.Draw(graphics, rectangle);
-    }
-
-    [Fact]
-    public void Cursor_Draw_NullGraphics_ThrowsArgumentNullException()
-    {
-        Cursor cursor = Cursors.AppStarting;
-        Assert.Throws<ArgumentNullException>("graphics", () => cursor.Draw(null, new Rectangle(Point.Empty, cursor.Size)));
-    }
-
-    [Fact]
-    public void Cursor_Draw_DisposedGraphics_ThrowsArgumentException()
-    {
-        Cursor cursor = Cursors.AppStarting;
-        using var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        graphics.Dispose();
-        Assert.Throws<ArgumentException>(() => cursor.Draw(graphics, new Rectangle(Point.Empty, cursor.Size)));
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void Cursor_DrawStretched_InvokeValidCursor_Success(Rectangle rectangle)
-    {
-        using var cursor = new Cursor(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        cursor.DrawStretched(graphics, rectangle);
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void Cursor_DrawStretched_InvokeInvalidCursor_Success(Rectangle rectangle)
-    {
-        using var cursor = new Cursor(-1000);
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        cursor.DrawStretched(graphics, rectangle);
-    }
-
-    [Fact]
-    public void Cursor_DrawStretched_NullGraphics_ThrowsArgumentNullException()
-    {
-        Cursor cursor = Cursors.AppStarting;
-        Assert.Throws<ArgumentNullException>("graphics", () => cursor.DrawStretched(null, new Rectangle(Point.Empty, cursor.Size)));
-    }
-
-    [Fact]
-    public void Cursor_DrawStretched_DisposedGraphics_ThrowsArgumentException()
-    {
-        Cursor cursor = Cursors.AppStarting;
-        using var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        graphics.Dispose();
-        Assert.Throws<ArgumentException>(() => cursor.DrawStretched(graphics, new Rectangle(Point.Empty, cursor.Size)));
-    }
-
-    public static IEnumerable<object[]> Equals_Object_TestData()
-    {
-        var cursor = new Cursor(Cursors.AppStarting.Handle);
-        yield return new object[] { cursor, cursor, true };
-        yield return new object[] { cursor, new Cursor(Cursors.AppStarting.Handle), true };
-        yield return new object[] { cursor, new Cursor(Cursors.Arrow.Handle), false };
-
-        yield return new object[] { cursor, new object(), false };
-        yield return new object[] { cursor, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Object_TestData))]
-    public void Cursor_Equals_InvokeObject_ReturnsExpected(Cursor cursor, object obj, bool expected)
-    {
-        Assert.Equal(expected, cursor.Equals(obj));
-        if (obj is Cursor)
-        {
-            Assert.Equal(expected, cursor.GetHashCode().Equals(obj.GetHashCode()));
-        }
-    }
-
-    public static IEnumerable<object[]> Equals_Cursor_TestData()
-    {
-        var cursor = new Cursor(2);
-        yield return new object[] { cursor, cursor, true };
-        yield return new object[] { cursor, new Cursor(2), true };
-        yield return new object[] { cursor, new Cursor(1), false };
-
-        yield return new object[] { null, null, true };
-        yield return new object[] { null, cursor, false };
-        yield return new object[] { cursor, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Cursor_TestData))]
-    public void Cursor_Equals_InvokeCursor_ReturnsExpected(Cursor cursor1, Cursor cursor2, bool expected)
-    {
-        Assert.Equal(expected, cursor1 == cursor2);
-        Assert.Equal(!expected, cursor1 != cursor2);
-    }
-
-    [Fact]
-    public void Cursor_ToString_KnownCursor_ReturnsExpected()
-    {
-        Cursor cursor = Cursors.AppStarting;
-        Assert.Equal("[Cursor: AppStarting]", cursor.ToString());
-    }
-
-    [Fact]
-    public void Cursor_ToString_CursorFromFile_ReturnsExpected()
-    {
-        using var cursor = new Cursor(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico"));
-        Assert.Equal("[Cursor: System.Windows.Forms.Cursor]", cursor.ToString());
-    }
-
-    [Fact]
-    public void Cursor_ToString_InvalidCursor_ThrowsFormatException()
-    {
-        using var cursor = new Cursor(2);
-        Assert.Throws<FormatException>(() => cursor.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorsTests.cs
deleted file mode 100644
index 1473e8c0fca..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/CursorsTests.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class CursorsTests
-{
-    public static IEnumerable<object[]> Cursors_TestData()
-    {
-        // Identity function to avoid constant casting
-        static Func<Cursor> I(Func<Cursor> factory) => factory;
-
-        yield return new object[] { I(() => Cursors.AppStarting) };
-        yield return new object[] { I(() => Cursors.Arrow) };
-        yield return new object[] { I(() => Cursors.Cross) };
-        yield return new object[] { I(() => Cursors.Default) };
-        yield return new object[] { I(() => Cursors.Hand) };
-        yield return new object[] { I(() => Cursors.Help) };
-        yield return new object[] { I(() => Cursors.HSplit) };
-        yield return new object[] { I(() => Cursors.IBeam) };
-        yield return new object[] { I(() => Cursors.No) };
-        yield return new object[] { I(() => Cursors.NoMove2D) };
-        yield return new object[] { I(() => Cursors.NoMoveHoriz) };
-        yield return new object[] { I(() => Cursors.NoMoveVert) };
-        yield return new object[] { I(() => Cursors.PanEast) };
-        yield return new object[] { I(() => Cursors.PanNE) };
-        yield return new object[] { I(() => Cursors.PanNorth) };
-        yield return new object[] { I(() => Cursors.PanNW) };
-        yield return new object[] { I(() => Cursors.PanSE) };
-        yield return new object[] { I(() => Cursors.PanSouth) };
-        yield return new object[] { I(() => Cursors.PanSW) };
-        yield return new object[] { I(() => Cursors.PanWest) };
-        yield return new object[] { I(() => Cursors.SizeAll) };
-        yield return new object[] { I(() => Cursors.SizeNESW) };
-        yield return new object[] { I(() => Cursors.SizeNS) };
-        yield return new object[] { I(() => Cursors.SizeNWSE) };
-        yield return new object[] { I(() => Cursors.SizeWE) };
-        yield return new object[] { I(() => Cursors.UpArrow) };
-        yield return new object[] { I(() => Cursors.VSplit) };
-        yield return new object[] { I(() => Cursors.WaitCursor) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Cursors_TestData))]
-    public void Cursors_KnownCursor_Get_ReturnsExpected(Func<Cursor> getCursor)
-    {
-        Cursor cursor = getCursor();
-        Assert.NotEqual(IntPtr.Zero, cursor.Handle);
-        Point hotSpot = cursor.HotSpot;
-        Assert.True(hotSpot.X >= 0 && hotSpot.X <= cursor.Size.Width);
-        Assert.True(hotSpot.Y >= 0 && hotSpot.Y <= cursor.Size.Height);
-        Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
-        Assert.Null(cursor.Tag);
-
-        // Cursor statics aren't thread safe. While rare, this can and does fail.
-        // Assert.Same(cursor, getCursor());
-    }
-
-    [Fact]
-    public void Cursors_Properties_Get_NotNull()
-    {
-        foreach (var property in typeof(Cursors).GetProperties(BindingFlags.Static | BindingFlags.Public))
-        {
-            object[] tempIndex = null;
-            Assert.NotNull((Cursor)property.GetValue(null, tempIndex));
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Cursors_TestData))]
-    public void Cursors_ToString_KnownCursor_ReturnsExpected(Func<Cursor> getCursor)
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/9464
-        Cursor cursor = getCursor();
-        Assert.NotEqual("[Cursor: System.Windows.Forms.Cursor]", cursor.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataFormatsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataFormatsTests.cs
deleted file mode 100644
index a6c40bcdd43..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataFormatsTests.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataFormatsTests
-{
-    public static IEnumerable<object[]> KnownFormats_TestData()
-    {
-        yield return new object[] { DataFormats.Bitmap, "Bitmap" };
-        yield return new object[] { DataFormats.CommaSeparatedValue, "Csv" };
-        yield return new object[] { DataFormats.Dib, "DeviceIndependentBitmap" };
-        yield return new object[] { DataFormats.Dif, "DataInterchangeFormat" };
-        yield return new object[] { DataFormats.EnhancedMetafile, "EnhancedMetafile" };
-        yield return new object[] { DataFormats.FileDrop, "FileDrop" };
-        yield return new object[] { DataFormats.Html, "HTML Format" };
-        yield return new object[] { DataFormats.Locale, "Locale" };
-        yield return new object[] { DataFormats.MetafilePict, "MetaFilePict" };
-        yield return new object[] { DataFormats.OemText, "OEMText" };
-        yield return new object[] { DataFormats.Palette, "Palette" };
-        yield return new object[] { DataFormats.PenData, "PenData" };
-        yield return new object[] { DataFormats.Riff, "RiffAudio" };
-        yield return new object[] { DataFormats.Rtf, "Rich Text Format" };
-        yield return new object[] { DataFormats.Serializable, "WindowsForms10PersistentObject" };
-        yield return new object[] { DataFormats.StringFormat, "System.String" };
-        yield return new object[] { DataFormats.SymbolicLink, "SymbolicLink" };
-        yield return new object[] { DataFormats.Text, "Text" };
-        yield return new object[] { DataFormats.Tiff, "TaggedImageFileFormat" };
-        yield return new object[] { DataFormats.UnicodeText, "UnicodeText" };
-        yield return new object[] { DataFormats.WaveAudio, "WaveAudio" };
-    }
-
-    [Theory]
-    [MemberData(nameof(KnownFormats_TestData))]
-    public void DataFormats_KnownFormat_Get_ReturnsExpected(string value, string expected)
-    {
-        Assert.Equal(expected, value);
-    }
-
-    public static IEnumerable<object[]> GetFormat_KnownString_TestData()
-    {
-        yield return new object[] { DataFormats.Bitmap, "Bitmap", 2 };
-        yield return new object[] { DataFormats.Dib, "DeviceIndependentBitmap", 8 };
-        yield return new object[] { DataFormats.Dif, "DataInterchangeFormat", 5 };
-        yield return new object[] { DataFormats.EnhancedMetafile, "EnhancedMetafile", 14 };
-        yield return new object[] { DataFormats.FileDrop, "FileDrop", 15 };
-        yield return new object[] { DataFormats.Locale, "Locale", 16 };
-        yield return new object[] { DataFormats.MetafilePict, "MetaFilePict", 3 };
-        yield return new object[] { DataFormats.OemText, "OEMText", 7 };
-        yield return new object[] { DataFormats.Palette, "Palette", 9 };
-        yield return new object[] { DataFormats.PenData, "PenData", 10 };
-        yield return new object[] { DataFormats.Riff, "RiffAudio", 11 };
-        yield return new object[] { DataFormats.SymbolicLink, "SymbolicLink", 4 };
-        yield return new object[] { DataFormats.Text, "Text", 1 };
-        yield return new object[] { DataFormats.Tiff, "TaggedImageFileFormat", 6 };
-        yield return new object[] { DataFormats.UnicodeText, "UnicodeText", 13 };
-        yield return new object[] { DataFormats.WaveAudio, "WaveAudio", 12 };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormat_KnownString_TestData))]
-    public void DataFormats_GetFormat_InvokeKnownString_ReturnsExpected(string format, string expectedName, int expectedId)
-    {
-        DataFormats.Format result = DataFormats.GetFormat(format);
-        Assert.Same(result, DataFormats.GetFormat(format.ToLower()));
-        Assert.Equal(expectedName, result.Name);
-        Assert.Equal(expectedId, result.Id);
-
-        // Call again to test caching behavior.
-        Assert.Same(result, DataFormats.GetFormat(format));
-    }
-
-    public static IEnumerable<object[]> GetFormat_UnknownString_TestData()
-    {
-        yield return new object[] { DataFormats.CommaSeparatedValue, "Csv" };
-        yield return new object[] { DataFormats.Html, "HTML Format" };
-        yield return new object[] { DataFormats.Rtf, "Rich Text Format" };
-        yield return new object[] { DataFormats.Serializable, "WindowsForms10PersistentObject" };
-        yield return new object[] { DataFormats.StringFormat, "System.String" };
-        yield return new object[] { "Custom", "Custom" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormat_UnknownString_TestData))]
-    public void DataFormats_GetFormat_InvokeUnknownFormatString_ReturnsExpected(string format, string expectedName)
-    {
-        DataFormats.Format result = DataFormats.GetFormat(format);
-        Assert.Same(result, DataFormats.GetFormat(format));
-        Assert.Same(result, DataFormats.GetFormat(format.ToLower()));
-        Assert.Equal(expectedName, result.Name);
-
-        // Internally the format is registered with RegisterClipboardFormat.
-        // According to the documentation: "Registered clipboard formats are
-        // identified by values in the range 0xC000 through 0xFFFF."
-        Assert.True(result.Id >= 0xC000);
-        Assert.True(result.Id < 0xFFFF);
-
-        // Should register the format.
-        Assert.Same(result, DataFormats.GetFormat(result.Id));
-    }
-
-    public static IEnumerable<object[]> GetFormat_InvalidString_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { string.Empty };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormat_InvalidString_TestData))]
-    public void DataFormats_GetFormat_NullOrEmptyString_ArgumentException(string format)
-    {
-        Assert.Throws<ArgumentException>(() => DataFormats.GetFormat(format));
-    }
-
-    public static IEnumerable<object[]> GetFormat_InvalidFormat_TestData()
-    {
-        yield return new object[] { new string('a', 256) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormat_InvalidFormat_TestData))]
-    public void DataFormats_GetFormat_InvalidFormat_ThrowsWin32Exception(string format)
-    {
-        Assert.Throws<Win32Exception>(() => DataFormats.GetFormat(format));
-    }
-
-    public static IEnumerable<object[]> GetFormat_Int_TestData()
-    {
-        yield return new object[] { 2, "Bitmap" };
-        yield return new object[] { 8, "DeviceIndependentBitmap" };
-        yield return new object[] { 5, "DataInterchangeFormat" };
-        yield return new object[] { 14, "EnhancedMetafile" };
-        yield return new object[] { 15, "FileDrop" };
-        yield return new object[] { 16, "Locale" };
-        yield return new object[] { 3, "MetaFilePict" };
-        yield return new object[] { 7, "OEMText" };
-        yield return new object[] { 9, "Palette" };
-        yield return new object[] { 10, "PenData" };
-        yield return new object[] { 11, "RiffAudio" };
-        yield return new object[] { 4, "SymbolicLink" };
-        yield return new object[] { 1, "Text" };
-        yield return new object[] { 6, "TaggedImageFileFormat" };
-        yield return new object[] { 13, "UnicodeText" };
-        yield return new object[] { 12, "WaveAudio" };
-        yield return new object[] { 12 & 0xFFFFFFFF, "WaveAudio" };
-
-        yield return new object[] { -1, "Format65535" };
-        yield return new object[] { 1234, "Format1234" };
-
-        uint manuallyRegisteredFormatId = PInvoke.RegisterClipboardFormat("ManuallyRegisteredFormat");
-        uint longManuallyRegisteredFormatId = PInvoke.RegisterClipboardFormat(new string('a', 255));
-        yield return new object[] { (int)manuallyRegisteredFormatId, "ManuallyRegisteredFormat" };
-        yield return new object[] { (int)longManuallyRegisteredFormatId, new string('a', 255) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormat_Int_TestData))]
-    public void DataFormats_GetFormat_InvokeId_ReturnsExpected(int id, string expectedName)
-    {
-        DataFormats.Format result = DataFormats.GetFormat(id);
-        Assert.Equal(result, DataFormats.GetFormat(id));
-        Assert.Equal(expectedName, result.Name);
-        Assert.Equal(id & 0xFFFF, result.Id);
-    }
-
-    [Theory]
-    [InlineData(null, -1)]
-    [InlineData("", 0)]
-    [InlineData("name", int.MaxValue)]
-    public void DataFormats_Format_Ctor_String_Int(string name, int id)
-    {
-        var format = new DataFormats.Format(name, id);
-        Assert.Equal(name, format.Name);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridView.DataGridViewEditingPanelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridView.DataGridViewEditingPanelAccessibleObjectTests.cs
deleted file mode 100644
index e316af30f0d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridView.DataGridViewEditingPanelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridView_DataGridViewEditingPanelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewEditingPanelAccessibleObject_FirstAndLastChildren_AreNull()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        AccessibleObject accessibleObject = dataGridView.EditingPanelAccessibleObject;
-
-        // Exception does not appear when trying to get first Child
-        UiaCore.IRawElementProviderFragment firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.Null(firstChild);
-
-        // Exception does not appear when trying to get last Child
-        UiaCore.IRawElementProviderFragment lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        Assert.Null(lastChild);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewEditingPanelAccessibleObject_EditedState_FirstAndLastChildren_AreNotNull()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        DataGridViewCell cell = dataGridView.Rows[0].Cells[0];
-        dataGridView.CurrentCell = cell;
-        dataGridView.BeginEdit(false);
-
-        AccessibleObject accessibleObject = dataGridView.EditingPanelAccessibleObject;
-
-        UiaCore.IRawElementProviderFragment firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.NotNull(firstChild);
-
-        UiaCore.IRawElementProviderFragment lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        Assert.NotNull(lastChild);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewEditingPanelAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        Panel editingPanel = dataGridView.EditingPanel;
-        // AccessibleRole is not set = Default
-
-        object actual = editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-        Assert.False(editingPanel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void DataGridViewEditingPanelAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using DataGridView dataGridView = new DataGridView();
-        Panel editingPanel = dataGridView.EditingPanel;
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            editingPanel.CreateControl();
-        }
-
-        object actual = editingPanel.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, editingPanel.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewEditingPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewEditingPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DataGridViewEditingPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DataGridView dataGridView = new DataGridView();
-        Panel editingPanel = dataGridView.EditingPanel;
-        editingPanel.AccessibleRole = role;
-
-        object actual = editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(editingPanel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewEditingPanelAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        Panel editingPanel = dataGridView.EditingPanel;
-
-        Assert.True((bool)editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.Equal(string.Empty, editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.HelpTextPropertyId));
-        Assert.Equal(SR.DataGridView_AccEditingPanelAccName, editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Equal(SR.DataGridView_AccEditingPanelAccName, editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.Null(editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False((bool)editingPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsPasswordPropertyId));
-        Assert.False(editingPanel.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAccessibleObjectTests.cs
deleted file mode 100644
index 9eae2d239d4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1689 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Reflection;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Ctor_Default()
-    {
-        using DataGridView dataGridView = new();
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(AccessibleRole.Table, accessibleObject.Role);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ItemStatus_ReturnsAsSorted()
-    {
-        using DataGridView dataGridView = new();
-        DataGridViewTextBoxColumn column = new()
-        {
-            SortMode = DataGridViewColumnSortMode.Programmatic,
-            HeaderText = "Some column"
-        };
-
-        dataGridView.Columns.Add(column);
-        dataGridView.Sort(dataGridView.Columns[0], ListSortDirection.Ascending);
-
-        string itemStatus = dataGridView.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ItemStatusPropertyId)?.ToString();
-        string expectedStatus = "Sorted ascending by Some column.";
-
-        Assert.Equal(expectedStatus, itemStatus);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ItemStatus_ReturnsNotSorted_IfSortedColumnInvisible()
-    {
-        using DataGridView dataGridView = new();
-        DataGridViewTextBoxColumn column1 = new()
-        {
-            SortMode = DataGridViewColumnSortMode.Programmatic,
-            HeaderText = "Sortable"
-        };
-
-        DataGridViewTextBoxColumn column2 = new()
-        {
-            SortMode = DataGridViewColumnSortMode.NotSortable,
-            HeaderText = "Not Sortable"
-        };
-
-        dataGridView.Columns.Add(column1);
-        dataGridView.Columns.Add(column2);
-        dataGridView.Sort(column1, ListSortDirection.Ascending);
-        column1.Visible = false;
-
-        string itemStatus = dataGridView.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ItemStatusPropertyId)?.ToString();
-
-        Assert.Equal(SR.NotSortedAccessibleStatus, itemStatus);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_EmptyGrid_GetChildCount_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChildCount()); // dataGridView doesn't have items
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GridWithFirstRowOnly_GetChildCount_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.ColumnHeadersVisible = false;
-
-        Assert.Equal(1, accessibleObject.GetChildCount()); // A first row only
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GridWithColumnHeadersAndFirstRow_GetChildCount_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        Assert.Equal(2, accessibleObject.GetChildCount()); // Column headers and a first Row
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_EmptyGrid_GetChild_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        Assert.Equal(0, accessibleObject.GetChildCount()); // dataGridView doesn't have an item
-
-        Assert.Null(accessibleObject.GetChild(0)); // GetChild method should not throw an exception
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GridWithFirstRowOnly_GetChild_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.ColumnHeadersVisible = false;
-
-        Assert.NotNull(accessibleObject.GetChild(0)); // dataGridView a first empty row.
-        Assert.Null(accessibleObject.GetChild(1)); // GetChild method should not throw an exception
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GridWithColumnHeadersAndFirstRow_GetChild_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        Assert.NotNull(accessibleObject.GetChild(0)); // dataGridView column headers
-        Assert.NotNull(accessibleObject.GetChild(1)); // dataGridView a first empty row
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Bounds_ReturnsCorrectValue_IfHandleIsCreated()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.CreateControl();
-        dataGridView.Size = new Size(500, 300);
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        int actualWidth = accessibleObject.Bounds.Width;
-        int expectedWidth = dataGridView.Size.Width;
-        Assert.Equal(expectedWidth, actualWidth);
-
-        int actualHeight = accessibleObject.Bounds.Height;
-        int expectedHeight = dataGridView.Size.Height;
-        Assert.Equal(expectedHeight, actualHeight);
-
-        Rectangle actualBounds = accessibleObject.Bounds;
-        actualBounds.Location = new Point(0, 0);
-        Rectangle expectedBounds = dataGridView.Bounds;
-
-        Assert.Equal(expectedBounds, actualBounds);
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Bounds_ReturnsCorrectValue_IfHandleIsNotCreated()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Size = new Size(500, 300);
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        int actualWidth = accessibleObject.Bounds.Width;
-        Assert.Equal(0, actualWidth);
-
-        int actualHeight = accessibleObject.Bounds.Height;
-        Assert.Equal(0, actualHeight);
-
-        Rectangle actualBounds = accessibleObject.Bounds;
-        actualBounds.Location = new Point(0, 0);
-        Rectangle expectedBounds = dataGridView.Bounds;
-
-        Assert.Equal(Rectangle.Empty, actualBounds);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ControlType_IsDataGrid_IfAccessibleRoleIsDefault()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = UiaCore.UIA.DataGridControlTypeId;
-
-        Assert.False(dataGridView.IsHandleCreated);
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetFocused_ReturnsCorrectFocusedCell()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        PInvoke.SetFocus(dataGridView);
-
-        DataGridViewCell cell = dataGridView.Rows[0].Cells[0];
-        Assert.NotNull(cell);
-
-        dataGridView.CurrentCell = cell;
-        Assert.True(cell.Selected);
-
-        AccessibleObject focusedCell = dataGridView.AccessibilityObject.GetFocused();
-
-        Assert.NotNull(focusedCell);
-        Assert.Equal(cell.AccessibilityObject, focusedCell);
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsCorrectValue()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add();
-
-        for (int i = 0; i < dataGridView.Rows.Count; i++)
-        {
-            for (int j = 0; j < dataGridView.Rows[i].Cells.Count; j++)
-            {
-                AccessibleObject expected = dataGridView.Rows[i].Cells[j].AccessibilityObject;
-                AccessibleObject actual = (AccessibleObject)dataGridView.AccessibilityObject.GetItem(i, j);
-
-                Assert.Equal(expected, actual);
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleStates.Focusable)]
-    [InlineData(false, AccessibleStates.None)]
-    public void DataGridViewAccessibleObject_State_IsFocusable(bool createControl, AccessibleStates expectedAccessibleStates)
-    {
-        using DataGridView dataGridView = new();
-        if (createControl)
-        {
-            dataGridView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.Equal(createControl, dataGridView.IsHandleCreated);
-        Assert.Equal(expectedAccessibleStates, accessibleObject.State & AccessibleStates.Focusable);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Ctor_NullOwnerParameter_ThrowsArgumentNullException()
-    {
-        using DataGridView dataGridView = new();
-        Type type = dataGridView.AccessibilityObject.GetType();
-
-        ConstructorInfo ctor = type.GetConstructor(new Type[] { typeof(DataGridView) });
-
-        Assert.NotNull(ctor);
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { null }));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FirstAndLastChildren_AreNotNull()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        // ColumnHeaders
-        UiaCore.IRawElementProviderFragment firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.NotNull(firstChild);
-
-        // New row
-        UiaCore.IRawElementProviderFragment lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        Assert.NotNull(lastChild);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsGridPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTablePatternAvailablePropertyId)]
-    public void DataGridViewAccessibleObject_Pattern_IsAvailable_IfDGVIsNotEmpty(int propertyId)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        AccessibleObject accessibilityObject = dataGridView.AccessibilityObject;
-
-        Assert.True((bool)accessibilityObject.GetPropertyValue((UiaCore.UIA)propertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_TablePattern_IsNotAvailable_IfDGVIsEmpty()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibilityObject = dataGridView.AccessibilityObject;
-
-        Assert.False((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsTablePatternAvailablePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_Cell_IsOffscreen_ReturnsCorrectValue(bool createControl)
-    {
-        using DataGridView dataGridView = new();
-
-        if (createControl)
-        {
-            dataGridView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        dataGridView.Size = new Size(200, 100);
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        dataGridView.Rows.Add(); // 1
-        object isOffscreen = dataGridView.Rows[1].Cells[0].AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-        Assert.False((bool)isOffscreen); // Within the visible area
-
-        dataGridView.Rows.Add(); // 2
-        dataGridView.Rows.Add(); // 3
-        dataGridView.Rows.Add(); // 4
-        isOffscreen = dataGridView.Rows[4].Cells[0].AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-
-        Assert.Equal(createControl, (bool)isOffscreen); // Out of the visible area
-        Assert.Equal(createControl, dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TablePatternId)]
-    [InlineData((int)UiaCore.UIA.GridPatternId)]
-    public void DataGridViewAccessibleObject_IsPatternSupported_IfDGVIsNotEmpty(int patternId)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_TablePattern_IsNotSupported_IfDGVIsEmpty()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibilityObject = dataGridView.AccessibilityObject;
-
-        Assert.False(accessibilityObject.IsPatternSupported(UiaCore.UIA.IsTablePatternAvailablePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_TablePattern_IsNotSupported_IfColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns[0].Visible = false;
-        AccessibleObject accessibilityObject = dataGridView.AccessibilityObject;
-
-        Assert.False(accessibilityObject.IsPatternSupported(UiaCore.UIA.IsTablePatternAvailablePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_Cell_IsReadOnly_ReturnsCorrectValue(bool isReadOnly)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        dataGridView.Rows[0].Cells[0].ReadOnly = isReadOnly;
-
-        Assert.Equal(dataGridView.ReadOnly, dataGridView.AccessibilityObject.IsReadOnly);
-
-        foreach (DataGridViewRow row in dataGridView.Rows)
-        {
-            Assert.Equal(row.ReadOnly, row.AccessibilityObject.IsReadOnly);
-
-            foreach (DataGridViewCell cell in row.Cells)
-            {
-                Assert.Equal(cell.ReadOnly, cell.AccessibilityObject.IsReadOnly);
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_Row_IsReadOnly_ReturnsCorrectValue(bool isReadOnly)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        dataGridView.Rows[0].ReadOnly = isReadOnly;
-
-        Assert.Equal(dataGridView.ReadOnly, dataGridView.AccessibilityObject.IsReadOnly);
-
-        foreach (DataGridViewRow row in dataGridView.Rows)
-        {
-            Assert.Equal(row.ReadOnly, row.AccessibilityObject.IsReadOnly);
-
-            foreach (DataGridViewCell cell in row.Cells)
-            {
-                Assert.Equal(cell.ReadOnly, cell.AccessibilityObject.IsReadOnly);
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_Grid_IsReadOnly_ReturnsCorrectValue(bool isReadOnly)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-
-        dataGridView.ReadOnly = isReadOnly;
-
-        Assert.Equal(dataGridView.ReadOnly, dataGridView.AccessibilityObject.IsReadOnly);
-
-        foreach (DataGridViewRow row in dataGridView.Rows)
-        {
-            Assert.Equal(row.ReadOnly, row.AccessibilityObject.IsReadOnly);
-
-            foreach (DataGridViewCell cell in row.Cells)
-            {
-                Assert.Equal(cell.ReadOnly, cell.AccessibilityObject.IsReadOnly);
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Owner_IsNotNull()
-    {
-        using DataGridView dataGridView = new();
-        Control.ControlAccessibleObject accessibleObject = (Control.ControlAccessibleObject)dataGridView.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject.Owner);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Parent_IsNotNull_IfHandleIsCreated()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.CreateControl();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject.Parent);
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Parent_IsNotNull_IfHandleIsNotCreated()
-    {
-        using DataGridView dataGridView = new();
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        Assert.Null(accessibleObject.Parent);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DataGridViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.AccessibleRole = role;
-
-        object actual = dataGridView.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_IsExpected_ForEmptyDGV(bool focused)
-    {
-        using DataGridView dataGridView = new FakeFocusDataGridView(focused);
-
-        bool actual = (bool)dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.Equal(focused, dataGridView.Focused);
-        Assert.Equal(0, dataGridView.RowCount); // DGV is empty
-        Assert.Equal(focused, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_False_ForNotEmptyDGV(bool focused)
-    {
-        using DataGridView dataGridView = new FakeFocusDataGridView(focused);
-        dataGridView.Columns.Add(new DataGridViewButtonColumn());
-
-        bool actual = (bool)dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.Equal(focused, dataGridView.Focused);
-        Assert.Equal(1, dataGridView.RowCount); // One new row for editing, it will be in focus instead of whole DGV
-        Assert.False(actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_AsExpected_DependsOnForm(bool modal)
-    {
-        using Form form = new();
-        using DataGridView dataGridView = new FakeFocusDataGridView(true);
-        dataGridView.Columns.Add(new DataGridViewButtonColumn());
-        dataGridView.Parent = form;
-
-        bool? actualValue = null;
-        form.Load += (_, _) =>
-        {
-            actualValue = (bool)dataGridView.AccessibilityObject
-                .GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-            form.Close();
-        };
-        if (modal)
-        {
-            form.ShowDialog();
-        }
-        else
-        {
-            form.Show();
-        }
-
-        Assert.Equal(modal, actualValue);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_IsExpected_ForGridWithHiddenRow(bool focused)
-    {
-        using DataGridView dataGridView = new FakeFocusDataGridView(focused) { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test");
-        dataGridView.Rows[0].Visible = false;
-
-        bool actual = (bool)dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.Equal(focused, dataGridView.Focused);
-        Assert.Equal(focused, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_IsExpected_ForNonEditableDGV(bool focused)
-    {
-        using DataGridView dataGridView = new FakeFocusDataGridView(focused)
-        {
-            ReadOnly = true,
-            AllowUserToAddRows = false
-        };
-
-        bool actual = (bool)dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.Equal(focused, dataGridView.Focused);
-        Assert.Equal(focused, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    private class FakeFocusDataGridView : DataGridView
-    {
-        private readonly bool _focused;
-
-        public FakeFocusDataGridView(bool focused)
-        {
-            _focused = focused;
-        }
-
-        // Emulate the focus state to avoid creation of a form and the control's Handle
-        public override bool Focused => _focused;
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnOne_IfFirstRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnOne_IfSecondRowAndColumnHeadersInVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnZero_IfRowsAndColumnHeadersInVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(0, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnTwo_IfFirstRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(2, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnTwo_IfSecondRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(2, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChildCount_ReturnOne_IfRowsInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnExpected_IfFirstRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(1));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnExpected_IfSecondRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(1));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnNull_IfRowsAndColumnHeadersInVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(1));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnExpected_IfFirstRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.GetChild(1));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnExpected_IfSecondRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.GetChild(1));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetChild_ReturnExpected_IfRowsInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(-1));
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.GetChild(0));
-        Assert.Null(dataGridView.AccessibilityObject.GetChild(1));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunExpected_IfFirstRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunExpected_IfSecondRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunNull_IfRowsAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Null(dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunExpected_IfFirstRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunExpected_IfSecondRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_FragmentNavigate_Child_RetrunExpected_IfRowsInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunExpected_IfFirstRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunExpected_IfSecondRowAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunNull_IfRowsAndColumnHeadersInvisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-            ColumnHeadersVisible = false
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Null(dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunExpected_IfFirstRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(dataGridView.Rows[1].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunExpected_IfSecondRowInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(dataGridView.Rows[0].AccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_Navigate_Child_RetrunExpected_IfRowsInvisibleAndColumnHeadersVisible()
-    {
-        using DataGridView dataGridView = new()
-        {
-            AllowUserToAddRows = false,
-        };
-
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        AccessibleObject topRowAccessibilityObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(topRowAccessibilityObject, dataGridView.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetColumnHeaders_ReturnExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-
-        var columnHeaders = dataGridView.AccessibilityObject.GetColumnHeaders();
-
-        Assert.NotNull(columnHeaders);
-        Assert.Equal(3, columnHeaders.Length);
-        Assert.Equal(dataGridView.Columns[0].HeaderCell.AccessibilityObject, columnHeaders[0]);
-        Assert.Equal(dataGridView.Columns[1].HeaderCell.AccessibilityObject, columnHeaders[1]);
-        Assert.Equal(dataGridView.Columns[2].HeaderCell.AccessibilityObject, columnHeaders[2]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetColumnHeaders_ReturnExpected_IfFirstColumnInvisible()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[0].Visible = false;
-
-        var columnHeaders = dataGridView.AccessibilityObject.GetColumnHeaders();
-
-        Assert.NotNull(columnHeaders);
-        Assert.Equal(2, columnHeaders.Length);
-        Assert.Equal(dataGridView.Columns[1].HeaderCell.AccessibilityObject, columnHeaders[0]);
-        Assert.Equal(dataGridView.Columns[2].HeaderCell.AccessibilityObject, columnHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetColumnHeaders_ReturnExpected_IfSecondColumnInvisible()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[1].Visible = false;
-
-        var columnHeaders = dataGridView.AccessibilityObject.GetColumnHeaders();
-
-        Assert.NotNull(columnHeaders);
-        Assert.Equal(2, columnHeaders.Length);
-        Assert.Equal(dataGridView.Columns[0].HeaderCell.AccessibilityObject, columnHeaders[0]);
-        Assert.Equal(dataGridView.Columns[2].HeaderCell.AccessibilityObject, columnHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetColumnHeaders_ReturnExpected_IfThirdColumnInvisible()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[2].Visible = false;
-
-        var columnHeaders = dataGridView.AccessibilityObject.GetColumnHeaders();
-
-        Assert.NotNull(columnHeaders);
-        Assert.Equal(2, columnHeaders.Length);
-        Assert.Equal(dataGridView.Columns[0].HeaderCell.AccessibilityObject, columnHeaders[0]);
-        Assert.Equal(dataGridView.Columns[1].HeaderCell.AccessibilityObject, columnHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetColumnHeaders_ReturnEmptyArray_IfColumnsInvisible()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        var columnHeaders = dataGridView.AccessibilityObject.GetColumnHeaders();
-
-        Assert.NotNull(columnHeaders);
-        Assert.Equal(0, columnHeaders.Length);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetRowHeaders_ReturnExpected()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test", "Test");
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        dataGridView.Rows.Add("Test 3");
-
-        var rowHeaders = dataGridView.AccessibilityObject.GetRowHeaders();
-
-        Assert.NotNull(rowHeaders);
-        Assert.Equal(3, rowHeaders.Length);
-        Assert.Equal(dataGridView.Rows[0].HeaderCell.AccessibilityObject, rowHeaders[0]);
-        Assert.Equal(dataGridView.Rows[1].HeaderCell.AccessibilityObject, rowHeaders[1]);
-        Assert.Equal(dataGridView.Rows[2].HeaderCell.AccessibilityObject, rowHeaders[2]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetRowHeaders_ReturnExpected_IfFirstRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test", "Test");
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        dataGridView.Rows.Add("Test 3");
-        dataGridView.Rows[0].Visible = false;
-
-        var rowHeaders = dataGridView.AccessibilityObject.GetRowHeaders();
-
-        Assert.NotNull(rowHeaders);
-        Assert.Equal(2, rowHeaders.Length);
-        Assert.Equal(dataGridView.Rows[1].HeaderCell.AccessibilityObject, rowHeaders[0]);
-        Assert.Equal(dataGridView.Rows[2].HeaderCell.AccessibilityObject, rowHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetRowHeaders_ReturnExpected_IfSecondRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test", "Test");
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        dataGridView.Rows.Add("Test 3");
-        dataGridView.Rows[1].Visible = false;
-
-        var rowHeaders = dataGridView.AccessibilityObject.GetRowHeaders();
-
-        Assert.NotNull(rowHeaders);
-        Assert.Equal(2, rowHeaders.Length);
-        Assert.Equal(dataGridView.Rows[0].HeaderCell.AccessibilityObject, rowHeaders[0]);
-        Assert.Equal(dataGridView.Rows[2].HeaderCell.AccessibilityObject, rowHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetRowHeaders_ReturnExpected_IfThirdRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test", "Test");
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        dataGridView.Rows.Add("Test 3");
-        dataGridView.Rows[2].Visible = false;
-
-        var rowHeaders = dataGridView.AccessibilityObject.GetRowHeaders();
-
-        Assert.NotNull(rowHeaders);
-        Assert.Equal(2, rowHeaders.Length);
-        Assert.Equal(dataGridView.Rows[0].HeaderCell.AccessibilityObject, rowHeaders[0]);
-        Assert.Equal(dataGridView.Rows[1].HeaderCell.AccessibilityObject, rowHeaders[1]);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetRowHeaders_ReturnExpected_IfRowsHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test", "Test");
-        dataGridView.Rows.Add("Test 1");
-        dataGridView.Rows.Add("Test 2");
-        dataGridView.Rows.Add("Test 3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-        dataGridView.Rows[2].Visible = false;
-
-        var rowHeaders = dataGridView.AccessibilityObject.GetRowHeaders();
-
-        Assert.NotNull(rowHeaders);
-        Assert.Equal(0, rowHeaders.Length);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfFirstColumnAndRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Rows[0].Visible = false;
-
-        int rowCount = dataGridView.Rows.Count;
-        int columnCount = dataGridView.Columns.Count;
-
-        for (int i = 0; i < rowCount; i++)
-        {
-            for (int j = 0; j < columnCount; j++)
-            {
-                AccessibleObject expected = (i >= rowCount - 1 || j >= columnCount - 1)
-                    ? null
-                    : dataGridView.Rows[i + 1].Cells[j + 1].AccessibilityObject;
-
-                Assert.Equal(expected, dataGridView.AccessibilityObject.GetItem(i, j));
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfSecondColumnAndRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        int rowCount = dataGridView.Rows.Count;
-        int columnCount = dataGridView.Columns.Count;
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-
-        AccessibleObject expected = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        var actual = accessibleObject.GetItem(0, 0);
-        Assert.Equal(expected, actual);
-
-        expected = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        actual = accessibleObject.GetItem(0, 1);
-        Assert.Equal(expected, actual);
-
-        Assert.Null(accessibleObject.GetItem(0, 2));
-
-        expected = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-        actual = accessibleObject.GetItem(1, 0);
-        Assert.Equal(expected, actual);
-
-        expected = dataGridView.Rows[2].Cells[2].AccessibilityObject;
-        actual = accessibleObject.GetItem(1, 1);
-        Assert.Equal(expected, actual);
-
-        Assert.Null(accessibleObject.GetItem(1, 2));
-        Assert.Null(accessibleObject.GetItem(2, 0));
-        Assert.Null(accessibleObject.GetItem(2, 1));
-        Assert.Null(accessibleObject.GetItem(2, 2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfLastColumnAndRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Rows.Add();
-        dataGridView.Columns[2].Visible = false;
-        dataGridView.Rows[2].Visible = false;
-
-        int rowCount = dataGridView.Rows.Count;
-        int columnCount = dataGridView.Columns.Count;
-
-        for (int i = 0; i < rowCount; i++)
-        {
-            for (int j = 0; j < columnCount; j++)
-            {
-                AccessibleObject expected = (i >= rowCount - 1 || j >= columnCount - 1)
-                    ? null
-                    : dataGridView.Rows[i].Cells[j].AccessibilityObject;
-
-                Assert.Equal(expected, dataGridView.AccessibilityObject.GetItem(i, j));
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        AccessibleObject accessibleObjectCell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObjectCell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObjectCell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObjectCell3, dataGridView.AccessibilityObject.GetItem(0, 0));
-        Assert.Equal(accessibleObjectCell2, dataGridView.AccessibilityObject.GetItem(0, 1));
-        Assert.Equal(accessibleObjectCell1, dataGridView.AccessibilityObject.GetItem(0, 2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        AccessibleObject accessibleObjectCell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObjectCell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObjectCell3, dataGridView.AccessibilityObject.GetItem(0, 0));
-        Assert.Equal(accessibleObjectCell2, dataGridView.AccessibilityObject.GetItem(0, 1));
-        Assert.Null(dataGridView.AccessibilityObject.GetItem(0, 2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        AccessibleObject accessibleObjectCell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObjectCell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObjectCell3, dataGridView.AccessibilityObject.GetItem(0, 0));
-        Assert.Equal(accessibleObjectCell1, dataGridView.AccessibilityObject.GetItem(0, 1));
-        Assert.Null(dataGridView.AccessibilityObject.GetItem(0, 2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_GetItem_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject = dataGridView.AccessibilityObject;
-        AccessibleObject accessibleObjectCell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObjectCell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObjectCell2, dataGridView.AccessibilityObject.GetItem(0, 0));
-        Assert.Equal(accessibleObjectCell1, dataGridView.AccessibilityObject.GetItem(0, 1));
-        Assert.Null(dataGridView.AccessibilityObject.GetItem(0, 2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ColumnCount_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-
-        Assert.Equal(3, dataGridView.AccessibilityObject.ColumnCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ColumnCount_ReturnsExpected_IfOneColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[0].Visible = false;
-
-        Assert.Equal(2, dataGridView.AccessibilityObject.ColumnCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ColumnCount_ReturnsExpected_IfTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.ColumnCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ColumnCount_ReturnsExpected_IfThreeColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Columns.Add("Test 2", "Test 2");
-        dataGridView.Columns.Add("Test 3", "Test 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        Assert.Equal(0, dataGridView.AccessibilityObject.ColumnCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        Assert.Equal(4, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfOneColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(3, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(2, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfThreeColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-        dataGridView.Rows[2].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        Assert.Equal(3, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfOneColumnHidden_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        Assert.Equal(2, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfTwoColumnHidden_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        Assert.Equal(1, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_RowCount_ReturnsExpected_IfThreeColumnHidden_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add("Test 1", "Test 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-        dataGridView.Rows[2].Visible = false;
-
-        Assert.Equal(0, dataGridView.AccessibilityObject.RowCount);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ItemStatusProperty_IsExpected_ForNonSortedDGV()
-    {
-        using DataGridView dataGridView = new();
-        using DataGridViewTextBoxColumn column = new();
-        dataGridView.Columns.Add(column);
-
-        object actual = dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.ItemStatusPropertyId);
-
-        Assert.Equal(1, dataGridView.RowCount);
-        Assert.Equal(1, dataGridView.ColumnCount);
-        Assert.Equal(SR.NotSortedAccessibleStatus, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewAccessibleObject_ItemStatusProperty_IsNull_ForEmptyDGV()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-
-        object actual = dataGridView.AccessibilityObject
-            .GetPropertyValue(UiaCore.UIA.ItemStatusPropertyId);
-
-        Assert.Equal(0, dataGridView.RowCount);
-        Assert.Equal(0, dataGridView.ColumnCount);
-        Assert.Null(actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnModeEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnModeEventArgsTests.cs
deleted file mode 100644
index e17398a818e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnModeEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewAutoSizeColumnModeEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DataGridViewColumn_DataGridViewAutoSizeColumn_TestData()
-    {
-        yield return new object[] { null, (DataGridViewAutoSizeColumnMode)(DataGridViewAutoSizeColumnMode.NotSet - 1) };
-        yield return new object[] { new DataGridViewColumn(), DataGridViewAutoSizeColumnMode.AllCells };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DataGridViewColumn_DataGridViewAutoSizeColumn_TestData))]
-    public void Ctor_DataGridViewColumn_DataGridViewAutoSizeColumn(DataGridViewColumn dataGridViewColumn, DataGridViewAutoSizeColumnMode previousMode)
-    {
-        var e = new DataGridViewAutoSizeColumnModeEventArgs(dataGridViewColumn, previousMode);
-        Assert.Equal(dataGridViewColumn, e.Column);
-        Assert.Equal(previousMode, e.PreviousMode);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnsModeEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnsModeEventArgsTests.cs
deleted file mode 100644
index 9ce4afc38ff..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeColumnsModeEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewAutoSizeColumnsModeEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DataGridViewAutoSizeColumnModeArray_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<DataGridViewAutoSizeColumnMode>() };
-        yield return new object[] { new DataGridViewAutoSizeColumnMode[] { DataGridViewAutoSizeColumnMode.AllCells, (DataGridViewAutoSizeColumnMode)(DataGridViewAutoSizeColumnMode.None - 1) } };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DataGridViewAutoSizeColumnModeArray_TestData))]
-    public void Ctor_DataGridViewAutoSizeColumnModeArray(DataGridViewAutoSizeColumnMode[] previousModes)
-    {
-        var e = new DataGridViewAutoSizeColumnsModeEventArgs(previousModes);
-        Assert.Equal(previousModes, e.PreviousModes);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeModeEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeModeEventArgsTests.cs
deleted file mode 100644
index 123b7347a3e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewAutoSizeModeEventArgsTests.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewAutoSizeModeEventArgsTests
-{
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Ctor_Bool(bool previousModeAutoSized)
-    {
-        var e = new DataGridViewAutoSizeModeEventArgs(previousModeAutoSized);
-        Assert.Equal(previousModeAutoSized, e.PreviousModeAutoSized);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewBindingCompleteEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewBindingCompleteEventArgsTests.cs
deleted file mode 100644
index 4d7a3533dd4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewBindingCompleteEventArgsTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewBindingCompleteEventArgsTests
-{
-    [Theory]
-    [InlineData(ListChangedType.ItemAdded)]
-    [InlineData(ListChangedType.Reset - 1)]
-    public void Ctor_ListChangedType(ListChangedType listChangedType)
-    {
-        var e = new DataGridViewBindingCompleteEventArgs(listChangedType);
-        Assert.Equal(listChangedType, e.ListChangedType);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewButtonCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewButtonCellAccessibleObjectTests.cs
deleted file mode 100644
index 28e812f31fa..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewButtonCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewButtonCellAccessibleObjectTests : DataGridViewButtonCell
-{
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.Equal(SR.DataGridView_AccButtonCellDefaultAction, accessibleObject.DefaultAction);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.Equal(SR.DataGridView_AccButtonCellDefaultAction, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewButtonCellAccessibleObject(null);
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_DoDefaultAction_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(()
-            => new DataGridViewButtonCellAccessibleObject(null).DoDefaultAction());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewButtonCellAccessibleObject_DoDefaultAction_ThrowsException_IfOwnerRowIndexIncorrect()
-    {
-        using DataGridViewCell cell = new DataGridViewButtonCell();
-        AccessibleObject accessibleObject = cell.AccessibilityObject;
-
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.DoDefaultAction());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellAccessibleObjectTests.cs
deleted file mode 100644
index 4400d0e22f0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1451 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Moq;
-using Moq.Protected;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellAccessibleObjectTests : DataGridViewCell
-{
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewCellAccessibleObject();
-
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    public static IEnumerable<object[]> Ctor_DataGridViewCell_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void DataGridViewCellsAccessibleObject_Ctor_Default_IfHandleIsCreated(RightToLeft rightToLeft)
-    {
-        using var dataGridView = new DataGridView
-        {
-            RightToLeft = rightToLeft,
-            ColumnCount = 4,
-            Width = 85
-        };
-
-        dataGridView.CreateControl();
-        dataGridView.Columns[0].Width = 40;
-        dataGridView.Columns[1].Width = 40;
-        dataGridView.Columns[2].Width = 40;
-        dataGridView.Columns[3].Width = 40;
-
-        AccessibleObject rr = dataGridView.AccessibilityObject; //it is necessary to be in time to initialize elements
-
-        var accCellWidthSum = 0;
-        for (int i = 0; i < 4; i++)
-        {
-            accCellWidthSum += dataGridView.Rows[0].Cells[i].AccessibilityObject.BoundingRectangle.Width;
-        }
-
-        var accRowWidth = dataGridView.Rows[0].AccessibilityObject.BoundingRectangle.Width;
-
-        Assert.Equal(accCellWidthSum, accRowWidth - dataGridView.RowHeadersWidth);
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void DataGridViewCellsAccessibleObject_Ctor_Default_IfHandleIsNotCreated(RightToLeft rightToLeft)
-    {
-        using var dataGridView = new DataGridView
-        {
-            RightToLeft = rightToLeft,
-            ColumnCount = 4,
-            Width = 85
-        };
-
-        dataGridView.Columns[0].Width = 40;
-        dataGridView.Columns[1].Width = 40;
-        dataGridView.Columns[2].Width = 40;
-        dataGridView.Columns[3].Width = 40;
-
-        AccessibleObject rr = dataGridView.AccessibilityObject; //it is necessary to be in time to initialize elements
-
-        var accCellWidthSum = 0;
-        for (int i = 0; i < 4; i++)
-        {
-            accCellWidthSum += dataGridView.Rows[0].Cells[i].AccessibilityObject.BoundingRectangle.Width;
-        }
-
-        var accRowWidth = dataGridView.Rows[0].AccessibilityObject.BoundingRectangle.Width;
-
-        Assert.Equal(0, accCellWidthSum);
-        Assert.Equal(0, accRowWidth);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_DataGridViewCell_TestData))]
-    public void DataGridViewCellAccessibleObject_Ctor_DataGridViewCell(DataGridViewCell owner)
-    {
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-
-        Assert.Equal(owner, accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    public static IEnumerable<object[]> Bounds_TestData()
-    {
-        var row = new DataGridViewRow();
-        var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        yield return new object[] { new DataGridViewCellAccessibleObject(cell), Rectangle.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Bounds_TestData))]
-    public void DataGridViewCellAccessibleObject_Bounds_Get_ReturnsExpected(AccessibleObject accessibleObject, Rectangle expected)
-    {
-        Assert.Equal(expected, accessibleObject.Bounds);
-    }
-
-    public static IEnumerable<object[]> NoOwner_TestData()
-    {
-        yield return new object[] { new DataGridViewCellAccessibleObject() };
-        yield return new object[] { new DataGridViewCellAccessibleObject(null) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Bounds_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Bounds);
-    }
-
-    public static IEnumerable<object[]> DefaultAction_TestData()
-    {
-        yield return new object[] { new DataGridViewCellAccessibleObject(new SubDataGridViewCell()), "Edit" };
-
-        var row = new DataGridViewRow();
-        var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        cell.ReadOnly = true;
-        yield return new object[] { new DataGridViewCellAccessibleObject(cell), string.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultAction_TestData))]
-    public void DataGridViewCellAccessibleObject_DefaultAction_Get_ReturnsExpected(AccessibleObject accessibleObject, string expected)
-    {
-        Assert.Equal(expected, accessibleObject.DefaultAction);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultAction_TestData))]
-    public void DataGridViewCellAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected(AccessibleObject accessibleObject, string expected)
-    {
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId) ?? string.Empty);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_DefaultAction_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.DefaultAction);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Help_Get_ReturnsNull()
-    {
-        var accessibleObject = new DataGridViewCellAccessibleObject();
-
-        Assert.Null(accessibleObject.Help);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnStringEmpty_IfOwningRowAndColumnNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(cell);
-        Assert.Equal(string.Empty, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnStringEmpty_IfOwningRowNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        cell.OwningColumn = new DataGridViewTextBoxColumn();
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(cell);
-
-        Assert.Equal(string.Empty, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnStringEmpty_IfOwningColumnNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        cell.OwningRow = new DataGridViewRow();
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(cell);
-        Assert.Equal(string.Empty, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnExpected_IfDataGridViewNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        cell.OwningRow = new DataGridViewRow();
-        cell.OwningColumn = new DataGridViewTextBoxColumn() { HeaderText = "Test", SortMode = DataGridViewColumnSortMode.NotSortable };
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(cell);
-        string expected = string.Format(SR.DataGridView_AccDataGridViewCellName, cell.OwningColumn.HeaderText, -1);
-
-        Assert.Equal(expected, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnExpected()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        DataGridViewTextBoxColumn column = new() { HeaderText = "Test", SortMode = DataGridViewColumnSortMode.NotSortable };
-        dataGridView.Columns.Add(column);
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-        string expected = string.Format(SR.DataGridView_AccDataGridViewCellName, column.HeaderText, 2);
-
-        Assert.Equal(expected, accessibleObject.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnExpected_IfOneRowHidden()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        DataGridViewTextBoxColumn column = new() { HeaderText = "Test", SortMode = DataGridViewColumnSortMode.NotSortable };
-        dataGridView.Columns.Add(column);
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-        string expected = string.Format(SR.DataGridView_AccDataGridViewCellName, column.HeaderText, 1);
-
-        Assert.Equal(expected, accessibleObject.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Name_ReturnExpected_IfTwoRowsHidden()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        DataGridViewTextBoxColumn column = new() { HeaderText = "Test", SortMode = DataGridViewColumnSortMode.NotSortable };
-        dataGridView.Columns.Add(column);
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-        string expected = string.Format(SR.DataGridView_AccDataGridViewCellName, column.HeaderText, 0);
-
-        Assert.Equal(expected, accessibleObject.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Name_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Owner_Set_GetReturnsExpected()
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject
-        {
-            Owner = owner
-        };
-
-        Assert.Same(owner, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Owner_SetAlreadyWithOwner_ThrowsInvalidOperationException()
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Owner = owner);
-    }
-
-    public static IEnumerable<object[]> Parent_TestData()
-    {
-        yield return new object[] { new DataGridViewCellAccessibleObject(new SubDataGridViewCell()), null };
-
-        var row = new DataGridViewRow();
-        var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        yield return new object[] { new DataGridViewCellAccessibleObject(cell), row.AccessibilityObject };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_TestData))]
-    public void DataGridViewCellAccessibleObject_Parent_Get_ReturnsExpected(AccessibleObject accessibleObject, AccessibleObject expected)
-    {
-        Assert.Equal(expected, accessibleObject.Parent);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Parent_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Parent);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_State_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_State_NoDataGridView_ReturnsExpected()
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-
-        Assert.Equal(AccessibleStates.Focusable | AccessibleStates.Selectable, accessibleObject.State);
-    }
-
-    public static IEnumerable<object[]> Value_TestData()
-    {
-        yield return new object[] { new DataGridViewCellAccessibleObject(new SubDataGridViewCell()), "(null)" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_TestData))]
-    public void DataGridViewCellAccessibleObject_Value_Get_ReturnsExpected(AccessibleObject accessibleObject, string expected)
-    {
-        Assert.Equal(expected, accessibleObject.Value);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Value_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Value);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_DoDefaultAction_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.DoDefaultAction());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_GetChild_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChild(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_GetChild_NoDataGridView_ReturnsNull()
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_GetChildCount_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_GetChildCount_NoDataGridView_ReturnsZero()
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_GetFocused_Invoke_ReturnsNull()
-    {
-        var accessibleObject = new DataGridViewCellAccessibleObject();
-
-        Assert.Null(accessibleObject.GetFocused());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_GetSelected_Invoke_ReturnsNull()
-    {
-        var accessibleObject = new DataGridViewCellAccessibleObject();
-
-        Assert.Null(accessibleObject.GetSelected());
-    }
-
-    public static IEnumerable<object[]> Navigate_TestData()
-    {
-        yield return new object[] { new DataGridViewCellAccessibleObject(new SubDataGridViewCell()), AccessibleNavigation.Right, null };
-
-        var row = new DataGridViewRow();
-        var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        yield return new object[] { new DataGridViewCellAccessibleObject(cell), AccessibleNavigation.Right, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Navigate_TestData))]
-    public void DataGridViewCellAccessibleObject_Navigate_Invoke_ReturnsExpected(AccessibleObject accessibleObject, AccessibleNavigation navigationDirection, AccessibleObject expected)
-    {
-        Assert.Equal(expected, accessibleObject.Navigate(navigationDirection));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Navigate_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Navigate(AccessibleNavigation.Right));
-    }
-
-    [WinFormsTheory]
-    [InlineData(AccessibleSelection.None)]
-    [InlineData(AccessibleSelection.RemoveSelection)]
-    public void DataGridViewCellAccessibleObject_Select_NothingToDo_Nop(AccessibleSelection flags)
-    {
-        using var owner = new SubDataGridViewCell();
-        var accessibleObject = new DataGridViewCellAccessibleObject(owner);
-        accessibleObject.Select(flags);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewCellAccessibleObject_Select_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Select(AccessibleSelection.None));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Select_HasSelectionFlagsWithoutValidDataGridView_DoesNothing()
-    {
-        var mockCell = new Mock<DataGridViewCell>(MockBehavior.Strict);
-        mockCell
-            .SetupSet(s => s.State = DataGridViewElementStates.Visible)
-            .Verifiable();
-        mockCell
-            .Protected()
-            .Setup("Dispose", ItExpr.IsAny<bool>());
-
-        var mockObj = mockCell.Object;
-        var accessibleObject = new DataGridViewCellAccessibleObject(mockObj);
-        accessibleObject.Select(AccessibleSelection.None);
-        // NB: asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-
-        using DataGridView dataGridView = new DataGridView();
-        mockCell
-            .Protected()
-            .Setup("OnDataGridViewChanged");
-        mockObj.DataGridView = dataGridView;
-
-        accessibleObject.Select(AccessibleSelection.None);
-        // NB: asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Select_TakeFocus()
-    {
-        using var dataGridView = new SubDataGridView();
-        dataGridView.CreateControl();
-        Assert.True(dataGridView.IsHandleCreated);
-
-        var mockCell = new Mock<DataGridViewCell>(MockBehavior.Strict);
-        mockCell
-            .SetupSet(s => s.State = DataGridViewElementStates.Visible)
-            .Verifiable();
-        mockCell
-            .Protected()
-            .Setup("Dispose", ItExpr.IsAny<bool>());
-        mockCell
-            .Protected()
-            .Setup("OnDataGridViewChanged");
-
-        var mockObj = mockCell.Object;
-        mockObj.DataGridView = dataGridView;
-
-        var accessibleObject = new DataGridViewCellAccessibleObject(mockObj);
-        // verify that we check for a flag, not direct comparison. 128 is an arbitrary large flag.
-        accessibleObject.Select((AccessibleSelection)128 | AccessibleSelection.TakeFocus);
-
-        // NB: some asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-        Assert.True(dataGridView.FocusCalled);
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Select_TakeSelection()
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.CreateControl();
-        Assert.True(dataGridView.IsHandleCreated);
-
-        var mockCell = new Mock<DataGridViewCell>(MockBehavior.Strict);
-        mockCell
-            .SetupSet(s => s.State = DataGridViewElementStates.Visible)
-            .Verifiable();
-        mockCell
-            .SetupSet(s => s.Selected = true)
-            .Verifiable();
-        mockCell
-            .Protected()
-            .Setup("Dispose", ItExpr.IsAny<bool>());
-        mockCell
-            .Protected()
-            .Setup("OnDataGridViewChanged");
-
-        var mockObj = mockCell.Object;
-        mockObj.DataGridView = dataGridView;
-
-        var accessibleObject = new DataGridViewCellAccessibleObject(mockObj);
-        // verify that we check for a flag, not direct comparison. 128 is an arbitrary large flag.
-        accessibleObject.Select((AccessibleSelection)128 | AccessibleSelection.TakeSelection);
-
-        // NB: some asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-
-        // Can't test whether CurrentCell was set unless we add the whole layer of Rows, Columns, etc.
-        // Assert.Equal(mockObj, dataGridView.CurrentCell);
-
-        Assert.True(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Select_AddSelection()
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.CreateControl();
-        Assert.True(dataGridView.IsHandleCreated);
-
-        var mockCell = new Mock<DataGridViewCell>(MockBehavior.Strict);
-        mockCell
-            .SetupSet(s => s.State = DataGridViewElementStates.Visible)
-            .Verifiable();
-        mockCell
-            .SetupSet(s => s.Selected = true)
-            .Verifiable();
-        mockCell
-            .Protected()
-            .Setup("Dispose", ItExpr.IsAny<bool>());
-        mockCell
-            .Protected()
-            .Setup("OnDataGridViewChanged");
-
-        mockCell.Object.DataGridView = dataGridView;
-
-        var accessibleObject = new DataGridViewCellAccessibleObject(mockCell.Object);
-        // verify that we check for a flag, not direct comparison. 128 is an arbitrary large flag.
-        accessibleObject.Select((AccessibleSelection)128 | AccessibleSelection.AddSelection);
-        Assert.True(dataGridView.IsHandleCreated);
-
-        // NB: asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Select_RemoveSelection()
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.CreateControl();
-        Assert.True(dataGridView.IsHandleCreated);
-
-        var mockCell = new Mock<DataGridViewCell>(MockBehavior.Strict);
-        mockCell
-            .SetupSet(s => s.State = DataGridViewElementStates.Visible)
-            .Verifiable();
-        mockCell
-            .SetupSet(s => s.Selected = It.IsAny<bool>())
-            .Verifiable();
-        mockCell
-            .Protected()
-            .Setup("Dispose", ItExpr.IsAny<bool>());
-        mockCell
-            .Protected()
-            .Setup("OnDataGridViewChanged");
-
-        mockCell.Object.DataGridView = dataGridView;
-
-        var accessibleObject = new DataGridViewCellAccessibleObject(mockCell.Object);
-
-        // set selection, RemoveSelection is ignored
-        accessibleObject.Select(AccessibleSelection.AddSelection | AccessibleSelection.RemoveSelection);
-        // set selection, RemoveSelection is ignored
-        accessibleObject.Select(AccessibleSelection.TakeSelection | AccessibleSelection.RemoveSelection);
-        // now remove the selection
-        accessibleObject.Select(AccessibleSelection.RemoveSelection);
-
-        // NB: asserts are implicit - check that nothing was called on the mock that we didn't anticipate
-        mockCell.VerifySet(s => s.Selected = true, Times.Exactly(2));
-        mockCell.VerifySet(s => s.Selected = false, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellsAccessibleObject_IsReadOnly_property()
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-        dataGridView.Rows.Add(new DataGridViewRow());
-
-        dataGridView.Rows[0].Cells[0].ReadOnly = true;
-        dataGridView.Rows[1].ReadOnly = true;
-        dataGridView.Rows[2].ReadOnly = false;
-
-        foreach (DataGridViewRow row in dataGridView.Rows)
-        {
-            foreach (DataGridViewCell cell in row.Cells)
-            {
-                bool value = cell.AccessibilityObject.IsReadOnly;
-
-                Assert.Equal(cell.ReadOnly, value);
-            }
-        }
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_ControlType_IsDefined()
-    {
-        UiaCore.IRawElementProviderSimple provider = new DataGridViewCellAccessibleObject();
-
-        Assert.Equal(UiaCore.UIA.DataItemControlTypeId, provider.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellsAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-
-        DataGridViewCellAccessibleObject accessibleObject = new(dataGridView.Rows[0].Cells[0]);
-
-        //DataGridViewCellAccessibleObject name couldn't be set, it's gathered dynamically in the Name property accessor
-        Assert.Equal(accessibleObject.Name, accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Equal(accessibleObject.Name, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellsAccessibleObject_GetPropertyValue_HelpText_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-
-        DataGridViewCellAccessibleObject accessibleObject = new(dataGridView.Rows[0].Cells[0]);
-
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.HelpTextPropertyId);
-
-        Assert.Equal(accessibleObject.Help ?? string.Empty, actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellsAccessibleObject_GetPropertyValue_IsOffscreen_ReturnsFalse()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-
-        DataGridViewCellAccessibleObject accessibleObject = new(dataGridView.Rows[0].Cells[0]);
-
-        bool actual = (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-
-        Assert.False(actual);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void DataGridViewCellAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-        DataGridViewCellAccessibleObject accessibleObject = new(dataGridView.Rows[0].Cells[0]);
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Row_ReturnExpected_IfOwningRowNotExist()
-    {
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(new SubDataGridViewCell());
-
-        Assert.Equal(-1, accessibleObject.Row);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Row_ReturnExpected_IfDataGridViewNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        cell.OwningRow = new DataGridViewRow();
-
-        Assert.Equal(-1, cell.AccessibilityObject.Row);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Row_ReturnExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Row);
-        Assert.Equal(1, accessibleObject2.Row);
-        Assert.Equal(2, accessibleObject3.Row);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessicbleObject_Row_ReturnExpected_IfFirstRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject1.Row);
-        Assert.Equal(0, accessibleObject2.Row);
-        Assert.Equal(1, accessibleObject3.Row);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessicbleObject_Row_ReturnExpected_IfSecondRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Row);
-        Assert.Equal(-1, accessibleObject2.Row);
-        Assert.Equal(1, accessibleObject3.Row);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessicbleObject_Row_ReturnExpected_IfLastRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].Cells[0].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Row);
-        Assert.Equal(1, accessibleObject2.Row);
-        Assert.Equal(-1, accessibleObject3.Row);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Сolumn_ReturnExpected_IfOwningColumnNotExist()
-    {
-        AccessibleObject accessibleObject = new DataGridViewCellAccessibleObject(new SubDataGridViewCell());
-
-        Assert.Equal(-1, accessibleObject.Column);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfDataGridViewNotExist()
-    {
-        SubDataGridViewCell cell = new SubDataGridViewCell();
-        cell.OwningColumn = new DataGridViewTextBoxColumn();
-
-        Assert.Equal(-1, cell.AccessibilityObject.Column);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Column);
-        Assert.Equal(1, accessibleObject2.Column);
-        Assert.Equal(2, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject1.Column);
-        Assert.Equal(0, accessibleObject2.Column);
-        Assert.Equal(1, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Column);
-        Assert.Equal(-1, accessibleObject2.Column);
-        Assert.Equal(1, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Column);
-        Assert.Equal(1, accessibleObject2.Column);
-        Assert.Equal(-1, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject1.Column);
-        Assert.Equal(1, accessibleObject2.Column);
-        Assert.Equal(0, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject1.Column);
-        Assert.Equal(1, accessibleObject2.Column);
-        Assert.Equal(0, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(1, accessibleObject1.Column);
-        Assert.Equal(-1, accessibleObject2.Column);
-        Assert.Equal(0, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_Column_ReturnExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-        dataGridView.Rows.Add("1");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(1, accessibleObject1.Column);
-        Assert.Equal(0, accessibleObject2.Column);
-        Assert.Equal(-1, accessibleObject3.Column);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_GetPropertyValue_AutomationId_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add(new DataGridViewRow());
-
-        DataGridViewCellAccessibleObject dataGridViewCellAccessibleObject = new(dataGridView.Rows[0].Cells[0]);
-        string expected = string.Concat(dataGridViewCellAccessibleObject.RuntimeId);
-
-        Assert.Equal(expected, dataGridViewCellAccessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected(bool createControl)
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 1, createControl);
-
-        DataGridViewRow row = dataGridView.Rows[0];
-        AccessibleObject accessibleObject = row.Cells[0].AccessibilityObject;
-
-        if (createControl)
-        {
-            Assert.Equal(row.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        }
-        else
-        {
-            Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        }
-
-        Assert.Equal(createControl, dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Parent_ReturnsNull_IfOwningRowIsNull()
-    {
-        using SubDataGridViewCell owner = new();
-        DataGridViewCellAccessibleObject accessibleObject = new(owner);
-
-        Assert.Null(accessibleObject.Owner.OwningRow);
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 2, createControl: false);
-
-        DataGridViewRow row = dataGridView.Rows[0];
-        AccessibleObject cell1 = row.Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = row.Cells[1].AccessibilityObject;
-
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.RowHeadersVisible = false;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(cell2, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(cell1, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(cell1, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 4);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell4 = dataGridView.Rows[0].Cells[3].AccessibilityObject;
-
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell4, cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell3, cell4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 4);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell4 = dataGridView.Rows[0].Cells[3].AccessibilityObject;
-
-        Assert.Equal(cell3, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell4, cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell3, cell4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 4);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[3].Visible = false;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell1, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(cell1, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell1, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowHeader = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell2, rowHeader.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(rowHeader, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(rowHeader.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(cell2, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell3, cell1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell1, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 3);
-        dataGridView.RowHeadersVisible = false;
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject cell3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(cell3, cell2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(cell3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(cell2, cell3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Child_ReturnsNull(bool createControl)
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 2, createControl);
-
-        AccessibleObject cell1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject cell2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = CreateDataGridView(columnCount: 1);
-        dataGridView.RowHeadersVisible = false;
-
-        AccessibleObject cell = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    private DataGridView CreateDataGridView(int columnCount, bool createControl = true)
-    {
-        DataGridView dataGridView = new();
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        }
-
-        if (createControl)
-        {
-            dataGridView.CreateControl();
-        }
-
-        return dataGridView;
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-
-    private class SubDataGridView : DataGridView
-    {
-        public bool FocusCalled { get; private set; }
-
-        public new DataGridViewCell CurrentCell { get; set; }
-
-        private protected override bool FocusInternal()
-        {
-            FocusCalled = true;
-            return false;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellCancelEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellCancelEventArgsTests.cs
deleted file mode 100644
index b310880740d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellCancelEventArgsTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellCancelEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int columnIndex, int rowIndex)
-    {
-        var e = new DataGridViewCellCancelEventArgs(columnIndex, rowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.False(e.Cancel);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellCancelEventArgs(-2, 0));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellCancelEventArgs(0, -2));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellContextMenuStripNeededEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellContextMenuStripNeededEventArgsTests.cs
deleted file mode 100644
index a7bc69ee080..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellContextMenuStripNeededEventArgsTests.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellContextMenuStripNeededEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int columnIndex, int rowIndex)
-    {
-        var e = new DataGridViewCellContextMenuStripNeededEventArgs(columnIndex, rowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Null(e.ContextMenuStrip);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellContextMenuStripNeededEventArgs(-2, 0));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellContextMenuStripNeededEventArgs(0, -2));
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_TestData))]
-    public void ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        var e = new DataGridViewCellContextMenuStripNeededEventArgs(1, 2)
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Equal(value, e.ContextMenuStrip);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellErrorTextNeededEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellErrorTextNeededEventArgsTests.cs
deleted file mode 100644
index fa3fc5b04dc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellErrorTextNeededEventArgsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewCellErrorTextNeededEventArgsTests
-{
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewCellErrorTextNeededEventArgs_ErrorText_Set_GetReturnsExpected(string value)
-    {
-        var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = dataGridView.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            e.ErrorText = value;
-            Assert.Equal(value, e.ErrorText);
-        };
-        dataGridView.CellErrorTextNeeded += handler;
-
-        Assert.Same(value, cell.GetErrorText(0));
-        Assert.Equal(1, callCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellEventArgsTests.cs
deleted file mode 100644
index 5e7fa135be5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellEventArgsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int columnIndex, int rowIndex)
-    {
-        var e = new DataGridViewCellEventArgs(columnIndex, rowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellEventArgs(-2, 0));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellEventArgs(0, -2));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellFormattingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellFormattingEventArgsTests.cs
deleted file mode 100644
index 4b375f9ef02..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellFormattingEventArgsTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellFormattingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_Int_Object_Type_DataGridViewCellStyle_TestData()
-    {
-        yield return new object[] { -1, -1, null, null, null };
-        yield return new object[] { 0, 0, "value", typeof(string), new DataGridViewCellStyle() };
-        yield return new object[] { 1, 2, "value", typeof(string), new DataGridViewCellStyle() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_Int_Object_Type_DataGridViewCellStyle_TestData))]
-    public void Ctor_Int_Int_Object_Type_DataGridViewCellStyle(int columnIndex, int rowIndex, object value, Type desiredType, DataGridViewCellStyle cellStyle)
-    {
-        var e = new DataGridViewCellFormattingEventArgs(columnIndex, rowIndex, value, desiredType, cellStyle);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(value, e.Value);
-        Assert.Equal(desiredType, e.DesiredType);
-        Assert.Equal(cellStyle, e.CellStyle);
-        Assert.False(e.FormattingApplied);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellFormattingEventArgs(-2, 0, "value", typeof(string), null));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellFormattingEventArgs(0, -2, "value", typeof(string), null));
-    }
-
-    public static IEnumerable<object[]> CellStyle_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellStyle() };
-    }
-
-    [Theory]
-    [MemberData(nameof(CellStyle_TestData))]
-    public void CellStyle_Set_GetReturnsExpected(DataGridViewCellStyle value)
-    {
-        var e = new DataGridViewCellFormattingEventArgs(1, 2, "value", typeof(string), new DataGridViewCellStyle())
-        {
-            CellStyle = value
-        };
-        Assert.Equal(value, e.CellStyle);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void FormattingApplied_Set_GetReturnsExpected(bool value)
-    {
-        var e = new DataGridViewCellFormattingEventArgs(1, 2, "value", typeof(string), new DataGridViewCellStyle())
-        {
-            FormattingApplied = value
-        };
-        Assert.Equal(value, e.FormattingApplied);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellMouseEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellMouseEventArgsTests.cs
deleted file mode 100644
index d3bc919a8a8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellMouseEventArgsTests.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellMouseEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_Int_Int_Int_MouseEventArgs_TestData()
-    {
-        yield return new object[] { -1, -1, -1, -1, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-        yield return new object[] { 0, 0, 0, 0, new MouseEventArgs((MouseButtons)1, 0, 0, 0, 0) };
-        yield return new object[] { 1, 2, 3, 4, new MouseEventArgs((MouseButtons)3, -1, -1, -1, -2) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_Int_Int_Int_MouseEventArgs_TestData))]
-    public void Ctor_Int_Int_Int_Int_MouseEventArgs(int columnIndex, int rowIndex, int localX, int localY, MouseEventArgs mouseE)
-    {
-        var e = new DataGridViewCellMouseEventArgs(columnIndex, rowIndex, localX, localY, mouseE);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(mouseE.Button, e.Button);
-        Assert.Equal(mouseE.Clicks, e.Clicks);
-        Assert.Equal(localX, e.X);
-        Assert.Equal(localY, e.Y);
-        Assert.Equal(mouseE.Delta, e.Delta);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellMouseEventArgs(-2, 0, 1, 2, null));
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellMouseEventArgs(-2, 0, 1, 2, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4)));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellMouseEventArgs(0, -2, 1, 2, null));
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellMouseEventArgs(0, -2, 1, 2, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4)));
-    }
-
-    [Fact]
-    public void Ctor_NullE_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("e", () => new DataGridViewCellMouseEventArgs(1, 2, 1, 2, null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellPaintingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellPaintingEventArgsTests.cs
deleted file mode 100644
index 81376cc9763..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellPaintingEventArgsTests.cs
+++ /dev/null
@@ -1,254 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewCellPaintingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_Rectangle_Int_Int_DataGridViewElementStates_Object_Object_String_DataGridViewCellStyle_DataGridViewAdvancedBorderStyle_DataGridViewPaintParts_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -2, -2, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new Rectangle(-1, -2, -3, -4), -1, -1, DataGridViewElementStates.Displayed, "value", "formattedValue", "", new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle(), DataGridViewPaintParts.All };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 0, 1, (DataGridViewElementStates)7, "value", "formattedValue", "errorText", new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle(), DataGridViewPaintParts.All };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Rectangle_Rectangle_Int_Int_DataGridViewElementStates_Object_Object_String_DataGridViewCellStyle_DataGridViewAdvancedBorderStyle_DataGridViewPaintParts_TestData))]
-    public void DataGridViewCellPaintingEventArgs_Ctor_Rectangle_Rectangle_Int_Int_DataGridViewElementStates_Object_Object_String_DataGridViewCellStyle_DataGridViewAdvancedBorderStyle_DataGridViewPaintParts(Rectangle clipBounds, Rectangle cellBounds, int rowIndex, int columnIndex, DataGridViewElementStates cellState, object value, object formattedValue, string errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var dataGridView = new DataGridView();
-
-        var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, clipBounds, cellBounds, rowIndex, columnIndex, cellState, value, formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(clipBounds, e.ClipBounds);
-        Assert.Equal(cellBounds, e.CellBounds);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(cellState, e.State);
-        Assert.Equal(value, e.Value);
-        Assert.Equal(formattedValue, e.FormattedValue);
-        Assert.Equal(errorText, e.ErrorText);
-        Assert.Equal(cellStyle, e.CellStyle);
-        Assert.Equal(advancedBorderStyle, e.AdvancedBorderStyle);
-        Assert.Equal(paintParts, e.PaintParts);
-        Assert.False(e.Handled);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_Ctor_NullDataGridView_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("dataGridView", () => new DataGridViewCellPaintingEventArgs(null, graphics, Rectangle.Empty, Rectangle.Empty, -2, -2, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All));
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var dataGridView = new DataGridView();
-        Assert.Throws<ArgumentNullException>("graphics", () => new DataGridViewCellPaintingEventArgs(dataGridView, null, Rectangle.Empty, Rectangle.Empty, -2, -2, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_Ctor_NullCellStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            Assert.Throws<ArgumentNullException>("cellStyle", () => new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, -2, DataGridViewElementStates.Displayed, null, null, null, null, null, DataGridViewPaintParts.All));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.All + 1))]
-    public void DataGridViewCellPaintingEventArgs_Ctor_InvalidPaintParts_ThrowsArgumentException(DataGridViewPaintParts paintParts)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            Assert.Throws<ArgumentException>("paintParts", () => new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, -2, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, paintParts));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, -1)]
-    public void DataGridViewCellPaintingEventArgs_Paint_ValidRowAndColumnIndex_Success(int rowIndex, int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle(), DataGridViewPaintParts.All);
-            e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None);
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_Paint_NullAdvancedBorderStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<ArgumentNullException>("advancedBorderStyle", () => e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_Paint_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_Paint_InvalidColumnIndex_ThrowsInvalidOperationException(int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.Paint(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, -1)]
-    public void DataGridViewCellPaintingEventArgs_PaintBackground_ValidRowAndColumnIndex_Success(int rowIndex, int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle(), DataGridViewPaintParts.All);
-            e.PaintBackground(new Rectangle(1, 2, 3, 4), true);
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_PaintBackground_NullAdvancedBorderStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<ArgumentNullException>("advancedBorderStyle", () => e.PaintBackground(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_PaintBackground_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.PaintBackground(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_PaintBackground_InvalidColumnIndex_ThrowsInvalidOperationException(int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.PaintBackground(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(-1, -1)]
-    public void DataGridViewCellPaintingEventArgs_PaintContent_ValidRowAndColumnIndex_Success(int rowIndex, int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle(), DataGridViewPaintParts.All);
-            e.PaintContent(new Rectangle(1, 2, 3, 4));
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCellPaintingEventArgs_PaintContent_NullAdvancedBorderStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<ArgumentNullException>("advancedBorderStyle", () => e.PaintContent(new Rectangle(1, 2, 3, 4)));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_PaintContent_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, 0, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.PaintContent(new Rectangle(1, 2, 3, 4)));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCellPaintingEventArgs_PaintContent_InvalidColumnIndex_ThrowsInvalidOperationException(int columnIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewCellPaintingEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, columnIndex, DataGridViewElementStates.Displayed, null, null, null, new DataGridViewCellStyle(), null, DataGridViewPaintParts.All);
-            Assert.Throws<InvalidOperationException>(() => e.PaintContent(new Rectangle(1, 2, 3, 4)));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellParsingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellParsingEventArgsTests.cs
deleted file mode 100644
index eeefb76f59a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellParsingEventArgsTests.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellParsingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_Int_Object_Type_DataGridViewCellStyle_TestData()
-    {
-        yield return new object[] { -2, -2, null, null, null };
-        yield return new object[] { -1, -1, null, null, null };
-        yield return new object[] { 0, 0, "value", typeof(string), new DataGridViewCellStyle() };
-        yield return new object[] { 1, 2, "value", typeof(string), new DataGridViewCellStyle() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_Int_Object_Type_DataGridViewCellStyle_TestData))]
-    public void Ctor_Int_Int_Object_Type_DataGridViewCellStyle(int rowIndex, int columnIndex, object value, Type desiredType, DataGridViewCellStyle inheritedCellStyle)
-    {
-        var e = new DataGridViewCellParsingEventArgs(rowIndex, columnIndex, value, desiredType, inheritedCellStyle);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(value, e.Value);
-        Assert.Equal(desiredType, e.DesiredType);
-        Assert.Equal(inheritedCellStyle, e.InheritedCellStyle);
-        Assert.False(e.ParsingApplied);
-    }
-
-    public static IEnumerable<object[]> InheritedCellStyle_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellStyle() };
-    }
-
-    [Theory]
-    [MemberData(nameof(InheritedCellStyle_TestData))]
-    public void InheritedCellStyle_Set_GetReturnsExpected(DataGridViewCellStyle value)
-    {
-        var e = new DataGridViewCellParsingEventArgs(1, 2, "value", typeof(string), new DataGridViewCellStyle())
-        {
-            InheritedCellStyle = value
-        };
-        Assert.Equal(value, e.InheritedCellStyle);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ParsingApplied_Set_GetReturnsExpected(bool value)
-    {
-        var e = new DataGridViewCellParsingEventArgs(1, 2, "value", typeof(string), new DataGridViewCellStyle())
-        {
-            ParsingApplied = value
-        };
-        Assert.Equal(value, e.ParsingApplied);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStateChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStateChangedEventArgsTests.cs
deleted file mode 100644
index 27f59f517b4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStateChangedEventArgsTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellStateChangedEventArgsTests
-{
-    [Theory]
-    [InlineData(DataGridViewElementStates.Displayed)]
-    [InlineData((DataGridViewElementStates)7)]
-    public void Ctor_DataGridViewCell_DataGridViewElementStates(DataGridViewElementStates stateChanged)
-    {
-        var cell = new SubDataGridViewCell();
-        var e = new DataGridViewCellStateChangedEventArgs(cell, stateChanged);
-        Assert.Equal(cell, e.Cell);
-        Assert.Equal(stateChanged, e.StateChanged);
-    }
-
-    [Fact]
-    public void Ctor_NullDataGridViewCell_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dataGridViewCell", () => new DataGridViewCellStateChangedEventArgs(null, DataGridViewElementStates.None));
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-        public SubDataGridViewCell() : base() { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStyleTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStyleTests.cs
deleted file mode 100644
index 3ec2e47963f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellStyleTests.cs
+++ /dev/null
@@ -1,1159 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellStyleTests
-{
-    [Fact]
-    public void DataGridViewCellStyle_Ctor_Default()
-    {
-        var style = new DataGridViewCellStyle();
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.NotSet, style.Alignment);
-        Assert.Equal(Color.Empty, style.BackColor);
-        Assert.Equal(DBNull.Value, style.DataSourceNullValue);
-        Assert.Null(style.Font);
-        Assert.Equal(Color.Empty, style.ForeColor);
-        Assert.Empty(style.Format);
-        Assert.Equal(CultureInfo.CurrentCulture, style.FormatProvider);
-        Assert.True(style.IsDataSourceNullValueDefault);
-        Assert.True(style.IsFormatProviderDefault);
-        Assert.True(style.IsNullValueDefault);
-        Assert.Equal(string.Empty, style.NullValue);
-        Assert.Equal(Padding.Empty, style.Padding);
-        Assert.Equal(Color.Empty, style.SelectionBackColor);
-        Assert.Equal(Color.Empty, style.SelectionForeColor);
-        Assert.Null(style.Tag);
-        Assert.Equal(DataGridViewTriState.NotSet, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Ctor_NonEmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Red,
-            DataSourceNullValue = "dbNull",
-            Font = SystemFonts.DefaultFont,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = formatProvider,
-            NullValue = "null",
-            Padding = new Padding(1, 2, 3, 4),
-            SelectionBackColor = Color.Green,
-            SelectionForeColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True
-        };
-        var style = new DataGridViewCellStyle(source);
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.BottomCenter, style.Alignment);
-        Assert.Equal(Color.Red, style.BackColor);
-        Assert.Equal("dbNull", style.DataSourceNullValue);
-        Assert.Equal(SystemFonts.DefaultFont, style.Font);
-        Assert.Equal(Color.Blue, style.ForeColor);
-        Assert.Equal("format", style.Format);
-        Assert.Equal(formatProvider, style.FormatProvider);
-        Assert.False(style.IsDataSourceNullValueDefault);
-        Assert.False(style.IsFormatProviderDefault);
-        Assert.False(style.IsNullValueDefault);
-        Assert.Equal("null", style.NullValue);
-        Assert.Equal(new Padding(1, 2, 3, 4), style.Padding);
-        Assert.Equal(Color.Green, style.SelectionBackColor);
-        Assert.Equal(Color.Yellow, style.SelectionForeColor);
-        Assert.Equal("tag", style.Tag);
-        Assert.Equal(DataGridViewTriState.True, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Ctor_EmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle();
-        var style = new DataGridViewCellStyle(source);
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.NotSet, style.Alignment);
-        Assert.Equal(Color.Empty, style.BackColor);
-        Assert.Equal(DBNull.Value, style.DataSourceNullValue);
-        Assert.Null(style.Font);
-        Assert.Equal(Color.Empty, style.ForeColor);
-        Assert.Empty(style.Format);
-        Assert.Equal(CultureInfo.CurrentCulture, style.FormatProvider);
-        Assert.True(style.IsDataSourceNullValueDefault);
-        Assert.True(style.IsFormatProviderDefault);
-        Assert.True(style.IsNullValueDefault);
-        Assert.Equal(string.Empty, style.NullValue);
-        Assert.Equal(Padding.Empty, style.Padding);
-        Assert.Equal(Color.Empty, style.SelectionBackColor);
-        Assert.Equal(Color.Empty, style.SelectionForeColor);
-        Assert.Null(style.Tag);
-        Assert.Equal(DataGridViewTriState.NotSet, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Ctor_NullDataGridViewCellStyle_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dataGridViewCellStyle", () => new DataGridViewCellStyle(null));
-    }
-
-    [Theory]
-    [EnumData<DataGridViewContentAlignment>]
-    public void DataGridViewCellStyle_Alignment_Set_GetReturnsExpected(DataGridViewContentAlignment value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Alignment = value
-        };
-        Assert.Equal(value, style.Alignment);
-
-        // Set same.
-        style.Alignment = value;
-        Assert.Equal(value, style.Alignment);
-    }
-
-    [Theory]
-    [InvalidEnumData<DataGridViewContentAlignment>]
-    public void DataGridViewCellStyle_Alignment_SetInvalid_ThrowsInvalidEnumArgumentException(DataGridViewContentAlignment value)
-    {
-        var style = new DataGridViewCellStyle();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => style.Alignment = value);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void DataGridViewCellStyle_BackColor_Set_GetReturnsExpected(Color value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            BackColor = value
-        };
-        Assert.Equal(value, style.BackColor);
-
-        // Set same.
-        style.BackColor = value;
-        Assert.Equal(value, style.BackColor);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_BackColor_SetEmpty_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            BackColor = Color.Red
-        };
-        style.BackColor = Color.Empty;
-        Assert.Equal(Color.Empty, style.BackColor);
-    }
-
-    public static IEnumerable<object[]> DataSourceNullValue_TestData()
-    {
-        yield return new object[] { DBNull.Value, true };
-        yield return new object[] { null, false };
-        yield return new object[] { string.Empty, false };
-        yield return new object[] { "value", false };
-        yield return new object[] { new AlwaysEqual(), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(DataSourceNullValue_TestData))]
-    public void DataGridViewCellStyle_DataSourceNullValue_Set_GetReturnsExpected(object value, bool expectedIsDataSourceNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = value
-        };
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-
-        // Set same.
-        style.DataSourceNullValue = value;
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-    }
-
-    [Theory]
-    [MemberData(nameof(DataSourceNullValue_TestData))]
-    public void DataGridViewCellStyle_DataSourceNullValue_SetWithNonNullOldValue_GetReturnsExpected(object value, bool expectedIsDataSourceNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = "oldValue"
-        };
-        style.DataSourceNullValue = value;
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-
-        // Set same.
-        style.DataSourceNullValue = value;
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-    }
-
-    [Theory]
-    [MemberData(nameof(DataSourceNullValue_TestData))]
-    public void DataGridViewCellStyle_DataSourceNullValue_SetWithNullOldValue_GetReturnsExpected(object value, bool expectedIsDataSourceNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = null
-        };
-        style.DataSourceNullValue = value;
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-
-        // Set same.
-        style.DataSourceNullValue = value;
-        Assert.Equal(value, style.DataSourceNullValue);
-        Assert.Equal(expectedIsDataSourceNullValueDefault, style.IsDataSourceNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_DataSourceNullValue_SetEqual_GetReturnsExpected()
-    {
-        var value = new AlwaysEqual();
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = value
-        };
-        style.DataSourceNullValue = new AlwaysEqual();
-        Assert.Same(value, style.DataSourceNullValue);
-        Assert.False(style.IsDataSourceNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_DataSourceNullValue_SetDifferent_GetReturnsExpected()
-    {
-        var value = new AlwaysEqual();
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = value
-        };
-        style.DataSourceNullValue = "value";
-        Assert.Equal("value", style.DataSourceNullValue);
-        Assert.False(style.IsDataSourceNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_DataSourceNullValue_SetDBNull_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            DataSourceNullValue = "value"
-        };
-        style.DataSourceNullValue = DBNull.Value;
-        Assert.Equal(DBNull.Value, style.DataSourceNullValue);
-        Assert.True(style.IsDataSourceNullValueDefault);
-    }
-
-    public static IEnumerable<object[]> Font_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { SystemFonts.DefaultFont };
-    }
-
-    [Theory]
-    [MemberData(nameof(Font_TestData))]
-    public void DataGridViewCellStyle_Font_Set_GetReturnsExpected(Font value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Font = value
-        };
-        Assert.Equal(value, style.Font);
-
-        // Set same.
-        style.Font = value;
-        Assert.Equal(value, style.Font);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Font_SetNull_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Font = SystemFonts.DefaultFont
-        };
-        style.Font = null;
-        Assert.Null(style.Font);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void DataGridViewCellStyle_ForeColor_Set_GetReturnsExpected(Color value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            ForeColor = value
-        };
-        Assert.Equal(value, style.ForeColor);
-
-        // Set same.
-        style.ForeColor = value;
-        Assert.Equal(value, style.ForeColor);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ForeColor_SetEmpty_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            ForeColor = Color.Red
-        };
-        style.ForeColor = Color.Empty;
-        Assert.Equal(Color.Empty, style.ForeColor);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void DataGridViewCellStyle_Format_Set_GetReturnsExpected(string value, string expected)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Format = value
-        };
-        Assert.Equal(expected, style.Format);
-
-        // Set same.
-        style.Format = value;
-        Assert.Equal(expected, style.Format);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void DataGridViewCellStyle_Format_SetWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Format = "value"
-        };
-        style.Format = value;
-        Assert.Equal(expected, style.Format);
-    }
-
-    public static IEnumerable<object[]> FormatProvider_TestData()
-    {
-        yield return new object[] { null, CultureInfo.CurrentCulture, true };
-
-        var numberFormatInfo = new NumberFormatInfo();
-        yield return new object[] { numberFormatInfo, numberFormatInfo, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(FormatProvider_TestData))]
-    public void DataGridViewCellStyle_FormatProvider_Set_GetReturnsExpected(IFormatProvider value, IFormatProvider expected, bool expectedIsFormatProviderDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            FormatProvider = value
-        };
-        Assert.Equal(expected, style.FormatProvider);
-        Assert.Equal(expectedIsFormatProviderDefault, style.IsFormatProviderDefault);
-
-        // Set same.
-        style.FormatProvider = value;
-        Assert.Equal(expected, style.FormatProvider);
-        Assert.Equal(expectedIsFormatProviderDefault, style.IsFormatProviderDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_FormatProvider_SetNull_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            FormatProvider = new NumberFormatInfo()
-        };
-        style.FormatProvider = null;
-        Assert.Equal(CultureInfo.CurrentCulture, style.FormatProvider);
-        Assert.True(style.IsFormatProviderDefault);
-    }
-
-    public static IEnumerable<object[]> NullValue_TestData()
-    {
-        yield return new object[] { DBNull.Value, false };
-        yield return new object[] { null, false };
-        yield return new object[] { string.Empty, true };
-        yield return new object[] { "value", false };
-        yield return new object[] { new AlwaysEqual(), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(NullValue_TestData))]
-    public void DataGridViewCellStyle_NullValue_Set_GetReturnsExpected(object value, bool expectedIsNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = value
-        };
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-
-        // Set same.
-        style.NullValue = value;
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-    }
-
-    [Theory]
-    [MemberData(nameof(NullValue_TestData))]
-    public void DataGridViewCellStyle_NullValue_SetWithNonNullOldValue_GetReturnsExpected(object value, bool expectedIsNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = "oldValue"
-        };
-        style.NullValue = value;
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-
-        // Set same.
-        style.NullValue = value;
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-    }
-
-    [Theory]
-    [MemberData(nameof(NullValue_TestData))]
-    public void DataGridViewCellStyle_NullValue_SetWithNullOldValue_GetReturnsExpected(object value, bool expectedIsNullValueDefault)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = null
-        };
-        style.NullValue = value;
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-
-        // Set same.
-        style.NullValue = value;
-        Assert.Equal(value, style.NullValue);
-        Assert.Equal(expectedIsNullValueDefault, style.IsNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_NullValue_SetEqual_GetReturnsExpected()
-    {
-        var value = new AlwaysEqual();
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = value
-        };
-        style.NullValue = new AlwaysEqual();
-        Assert.Same(value, style.NullValue);
-        Assert.False(style.IsNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_NullValue_SetDifferent_GetReturnsExpected()
-    {
-        var value = new AlwaysEqual();
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = value
-        };
-        style.NullValue = "value";
-        Assert.Equal("value", style.NullValue);
-        Assert.False(style.IsNullValueDefault);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_NullValue_SetEmpty_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            NullValue = "value"
-        };
-        style.NullValue = string.Empty;
-        Assert.Equal(string.Empty, style.NullValue);
-        Assert.True(style.IsNullValueDefault);
-    }
-
-    public static IEnumerable<object[]> Padding_TestData()
-    {
-        yield return new object[] { Padding.Empty, Padding.Empty };
-        yield return new object[] { new Padding(-1), Padding.Empty };
-        yield return new object[] { new Padding(-2), Padding.Empty };
-        yield return new object[] { new Padding(2), new Padding(2) };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4) };
-        yield return new object[] { new Padding(-1, 2, 3, 4), new Padding(0, 2, 3, 4) };
-        yield return new object[] { new Padding(1, -2, 3, 4), new Padding(1, 0, 3, 4) };
-        yield return new object[] { new Padding(1, 2, -3, 4), new Padding(1, 2, 0, 4) };
-        yield return new object[] { new Padding(1, 2, 3, -4), new Padding(1, 2, 3, 0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Padding_TestData))]
-    public void DataGridViewCellStyle_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, style.Padding);
-
-        // Set same.
-        style.Padding = value;
-        Assert.Equal(expected, style.Padding);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void DataGridViewCellStyle_SelectionBackColor_Set_GetReturnsExpected(Color value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            SelectionBackColor = value
-        };
-        Assert.Equal(value, style.SelectionBackColor);
-
-        // Set same.
-        style.SelectionBackColor = value;
-        Assert.Equal(value, style.SelectionBackColor);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_SelectionBackColor_SetEmpty_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            SelectionBackColor = Color.Red
-        };
-        style.SelectionBackColor = Color.Empty;
-        Assert.Equal(Color.Empty, style.SelectionBackColor);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void DataGridViewCellStyle_SelectionForeColor_Set_GetReturnsExpected(Color value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            SelectionForeColor = value
-        };
-        Assert.Equal(value, style.SelectionForeColor);
-
-        // Set same.
-        style.SelectionForeColor = value;
-        Assert.Equal(value, style.SelectionForeColor);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_SelectionForeColor_SetEmpty_GetReturnsExpected()
-    {
-        var style = new DataGridViewCellStyle
-        {
-            SelectionForeColor = Color.Red
-        };
-        style.SelectionForeColor = Color.Empty;
-        Assert.Equal(Color.Empty, style.SelectionForeColor);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DataGridViewCellStyle_Tag_Set_GetReturnsExpected(object value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Tag = value
-        };
-        Assert.Same(value, style.Tag);
-
-        // Set same.
-        style.Tag = value;
-        Assert.Same(value, style.Tag);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DataGridViewCellStyle_Tag_SetWithNonNullOldValue_GetReturnsExpected(object value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            Tag = "tag"
-        };
-        style.Tag = value;
-        Assert.Equal(value, style.Tag);
-
-        // Set same.
-        style.Tag = value;
-        Assert.Equal(value, style.Tag);
-    }
-
-    [Theory]
-    [EnumData<DataGridViewTriState>]
-    public void DataGridViewCellStyle_WrapMode_Set_GetReturnsExpected(DataGridViewTriState value)
-    {
-        var style = new DataGridViewCellStyle
-        {
-            WrapMode = value
-        };
-        Assert.Equal(value, style.WrapMode);
-
-        // Set same.
-        style.WrapMode = value;
-        Assert.Equal(value, style.WrapMode);
-    }
-
-    [Theory]
-    [InvalidEnumData<DataGridViewTriState>]
-    public void DataGridViewCellStyle_WrapMode_SetInvalid_ThrowsInvalidEnumArgumentException(DataGridViewTriState value)
-    {
-        var style = new DataGridViewCellStyle();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => style.WrapMode = value);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ApplyStyle_NonEmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Red,
-            DataSourceNullValue = "dbNull",
-            Font = SystemFonts.DefaultFont,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = formatProvider,
-            NullValue = "null",
-            Padding = new Padding(1, 2, 3, 4),
-            SelectionBackColor = Color.Green,
-            SelectionForeColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True
-        };
-        var style = new DataGridViewCellStyle();
-        style.ApplyStyle(source);
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.BottomCenter, style.Alignment);
-        Assert.Equal(Color.Red, style.BackColor);
-        Assert.Equal("dbNull", style.DataSourceNullValue);
-        Assert.Equal(SystemFonts.DefaultFont, style.Font);
-        Assert.Equal(Color.Blue, style.ForeColor);
-        Assert.Equal("format", style.Format);
-        Assert.Equal(formatProvider, style.FormatProvider);
-        Assert.False(style.IsDataSourceNullValueDefault);
-        Assert.False(style.IsFormatProviderDefault);
-        Assert.False(style.IsNullValueDefault);
-        Assert.Equal("null", style.NullValue);
-        Assert.Equal(new Padding(1, 2, 3, 4), style.Padding);
-        Assert.Equal(Color.Green, style.SelectionBackColor);
-        Assert.Equal(Color.Yellow, style.SelectionForeColor);
-        Assert.Equal("tag", style.Tag);
-        Assert.Equal(DataGridViewTriState.True, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ApplyStyle_EmptyDataGridViewCellStyle_Nop()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle();
-        var style = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Red,
-            DataSourceNullValue = "dbNull",
-            Font = SystemFonts.DefaultFont,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = formatProvider,
-            NullValue = "null",
-            Padding = new Padding(1, 2, 3, 4),
-            SelectionBackColor = Color.Green,
-            SelectionForeColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True
-        };
-        style.ApplyStyle(source);
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.BottomCenter, style.Alignment);
-        Assert.Equal(Color.Red, style.BackColor);
-        Assert.Equal("dbNull", style.DataSourceNullValue);
-        Assert.Equal(SystemFonts.DefaultFont, style.Font);
-        Assert.Equal(Color.Blue, style.ForeColor);
-        Assert.Equal("format", style.Format);
-        Assert.Equal(formatProvider, style.FormatProvider);
-        Assert.False(style.IsDataSourceNullValueDefault);
-        Assert.False(style.IsFormatProviderDefault);
-        Assert.False(style.IsNullValueDefault);
-        Assert.Equal("null", style.NullValue);
-        Assert.Equal(new Padding(1, 2, 3, 4), style.Padding);
-        Assert.Equal(Color.Green, style.SelectionBackColor);
-        Assert.Equal(Color.Yellow, style.SelectionForeColor);
-        Assert.Equal("tag", style.Tag);
-        Assert.Equal(DataGridViewTriState.True, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ApplyStyle_NullDataGridViewCellStyle_ThrowsArgumentNullException()
-    {
-        var style = new DataGridViewCellStyle();
-        Assert.Throws<ArgumentNullException>("dataGridViewCellStyle", () => style.ApplyStyle(null));
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Clone_NonEmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Red,
-            DataSourceNullValue = "dbNull",
-            Font = SystemFonts.DefaultFont,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = formatProvider,
-            NullValue = "null",
-            Padding = new Padding(1, 2, 3, 4),
-            SelectionBackColor = Color.Green,
-            SelectionForeColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True
-        };
-        DataGridViewCellStyle style = source.Clone();
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.BottomCenter, style.Alignment);
-        Assert.Equal(Color.Red, style.BackColor);
-        Assert.Equal("dbNull", style.DataSourceNullValue);
-        Assert.Equal(SystemFonts.DefaultFont, style.Font);
-        Assert.Equal(Color.Blue, style.ForeColor);
-        Assert.Equal("format", style.Format);
-        Assert.Equal(formatProvider, style.FormatProvider);
-        Assert.False(style.IsDataSourceNullValueDefault);
-        Assert.False(style.IsFormatProviderDefault);
-        Assert.False(style.IsNullValueDefault);
-        Assert.Equal("null", style.NullValue);
-        Assert.Equal(new Padding(1, 2, 3, 4), style.Padding);
-        Assert.Equal(Color.Green, style.SelectionBackColor);
-        Assert.Equal(Color.Yellow, style.SelectionForeColor);
-        Assert.Equal("tag", style.Tag);
-        Assert.Equal(DataGridViewTriState.True, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_Clone_EmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        var source = new DataGridViewCellStyle();
-        DataGridViewCellStyle style = source.Clone();
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.NotSet, style.Alignment);
-        Assert.Equal(Color.Empty, style.BackColor);
-        Assert.Equal(DBNull.Value, style.DataSourceNullValue);
-        Assert.Null(style.Font);
-        Assert.Equal(Color.Empty, style.ForeColor);
-        Assert.Empty(style.Format);
-        Assert.Equal(CultureInfo.CurrentCulture, style.FormatProvider);
-        Assert.True(style.IsDataSourceNullValueDefault);
-        Assert.True(style.IsFormatProviderDefault);
-        Assert.True(style.IsNullValueDefault);
-        Assert.Equal(string.Empty, style.NullValue);
-        Assert.Equal(Padding.Empty, style.Padding);
-        Assert.Equal(Color.Empty, style.SelectionBackColor);
-        Assert.Equal(Color.Empty, style.SelectionForeColor);
-        Assert.Null(style.Tag);
-        Assert.Equal(DataGridViewTriState.NotSet, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ICloneableClone_NonEmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        ICloneable source = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Red,
-            DataSourceNullValue = "dbNull",
-            Font = SystemFonts.DefaultFont,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = formatProvider,
-            NullValue = "null",
-            Padding = new Padding(1, 2, 3, 4),
-            SelectionBackColor = Color.Green,
-            SelectionForeColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True
-        };
-        DataGridViewCellStyle style = Assert.IsType<DataGridViewCellStyle>(source.Clone());
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.BottomCenter, style.Alignment);
-        Assert.Equal(Color.Red, style.BackColor);
-        Assert.Equal("dbNull", style.DataSourceNullValue);
-        Assert.Equal(SystemFonts.DefaultFont, style.Font);
-        Assert.Equal(Color.Blue, style.ForeColor);
-        Assert.Equal("format", style.Format);
-        Assert.Equal(formatProvider, style.FormatProvider);
-        Assert.False(style.IsDataSourceNullValueDefault);
-        Assert.False(style.IsFormatProviderDefault);
-        Assert.False(style.IsNullValueDefault);
-        Assert.Equal("null", style.NullValue);
-        Assert.Equal(new Padding(1, 2, 3, 4), style.Padding);
-        Assert.Equal(Color.Green, style.SelectionBackColor);
-        Assert.Equal(Color.Yellow, style.SelectionForeColor);
-        Assert.Equal("tag", style.Tag);
-        Assert.Equal(DataGridViewTriState.True, style.WrapMode);
-    }
-
-    [Fact]
-    public void DataGridViewCellStyle_ICloneableClone_EmptyDataGridViewCellStyle_Success()
-    {
-        var formatProvider = new NumberFormatInfo();
-        ICloneable source = new DataGridViewCellStyle();
-        DataGridViewCellStyle style = Assert.IsType<DataGridViewCellStyle>(source.Clone());
-
-        Assert.Equal(DataGridViewCellStyleScopes.None, style.Scope);
-        Assert.Equal(DataGridViewContentAlignment.NotSet, style.Alignment);
-        Assert.Equal(Color.Empty, style.BackColor);
-        Assert.Equal(DBNull.Value, style.DataSourceNullValue);
-        Assert.Null(style.Font);
-        Assert.Equal(Color.Empty, style.ForeColor);
-        Assert.Empty(style.Format);
-        Assert.Equal(CultureInfo.CurrentCulture, style.FormatProvider);
-        Assert.True(style.IsDataSourceNullValueDefault);
-        Assert.True(style.IsFormatProviderDefault);
-        Assert.True(style.IsNullValueDefault);
-        Assert.Equal(string.Empty, style.NullValue);
-        Assert.Equal(Padding.Empty, style.Padding);
-        Assert.Equal(Color.Empty, style.SelectionBackColor);
-        Assert.Equal(Color.Empty, style.SelectionForeColor);
-        Assert.Null(style.Tag);
-        Assert.Equal(DataGridViewTriState.NotSet, style.WrapMode);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        Font font = SystemFonts.DefaultFont;
-        var formatProvider = new NumberFormatInfo();
-
-        yield return new object[] { new DataGridViewCellStyle(), new DataGridViewCellStyle(), true };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomCenter },
-            new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomCenter },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomCenter },
-            new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomRight },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { BackColor = Color.Red },
-            new DataGridViewCellStyle { BackColor = Color.Red },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { BackColor = Color.Red },
-            new DataGridViewCellStyle { BackColor = Color.Blue },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = "dbNull" },
-            new DataGridViewCellStyle { DataSourceNullValue = "dbNull" },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = "dbNull" },
-            new DataGridViewCellStyle { DataSourceNullValue = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = null },
-            new DataGridViewCellStyle { DataSourceNullValue = null },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = null },
-            new DataGridViewCellStyle { DataSourceNullValue = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { ForeColor = Color.Red },
-            new DataGridViewCellStyle { ForeColor = Color.Red },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { ForeColor = Color.Red },
-            new DataGridViewCellStyle { ForeColor = Color.Blue },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Font = font },
-            new DataGridViewCellStyle { Font = font },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Font = font },
-            new DataGridViewCellStyle { Font = SystemFonts.MenuFont },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Format = "format" },
-            new DataGridViewCellStyle { Format = "format" },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Format = "format" },
-            new DataGridViewCellStyle { Format = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { FormatProvider = formatProvider },
-            new DataGridViewCellStyle { FormatProvider = formatProvider },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { FormatProvider = formatProvider },
-            new DataGridViewCellStyle { FormatProvider = CultureInfo.CurrentCulture },
-            false, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = "null" },
-            new DataGridViewCellStyle { NullValue = "null" },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = "null" },
-            new DataGridViewCellStyle { NullValue = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = null },
-            new DataGridViewCellStyle { NullValue = null },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = null },
-            new DataGridViewCellStyle { NullValue = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Padding = new Padding(1, 2, 3, 4) },
-            new DataGridViewCellStyle { Padding = new Padding(1, 2, 3, 4) },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Padding = new Padding(1, 2, 3, 4) },
-            new DataGridViewCellStyle { Padding = new Padding(2, 3, 4, 5) },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionBackColor = Color.Red },
-            new DataGridViewCellStyle { SelectionBackColor = Color.Red },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionBackColor = Color.Red },
-            new DataGridViewCellStyle { SelectionBackColor = Color.Blue },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionForeColor = Color.Red },
-            new DataGridViewCellStyle { SelectionForeColor = Color.Red },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionForeColor = Color.Red },
-            new DataGridViewCellStyle { SelectionForeColor = Color.Blue },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Tag = "tag" },
-            new DataGridViewCellStyle { Tag = "tag" },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Tag = "tag" },
-            new DataGridViewCellStyle { Tag = "other" },
-            false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { WrapMode = DataGridViewTriState.True },
-            new DataGridViewCellStyle { WrapMode = DataGridViewTriState.True },
-            true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { WrapMode = DataGridViewTriState.True },
-            new DataGridViewCellStyle { WrapMode = DataGridViewTriState.False },
-            false
-        };
-
-        yield return new object[] { new DataGridViewCellStyle(), new object(), false };
-        yield return new object[] { new DataGridViewCellStyle(), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void DataGridViewCellStyle_Equals_Invoke_ReturnsExpected(DataGridViewCellStyle style, object other, bool expected, bool? expectedEqualHashCode = null)
-    {
-        if (other is DataGridViewCellStyle)
-        {
-            Assert.Equal(expectedEqualHashCode ?? expected, style.GetHashCode().Equals(other.GetHashCode()));
-        }
-
-        Assert.Equal(expected, style.Equals(other));
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new DataGridViewCellStyle(), "DataGridViewCellStyle { }" };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomCenter },
-            "DataGridViewCellStyle { Alignment=BottomCenter }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { BackColor = Color.Red },
-            "DataGridViewCellStyle { BackColor=Color [Red] }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = "dbNull" },
-            "DataGridViewCellStyle { DataSourceNullValue=dbNull }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { DataSourceNullValue = null },
-            "DataGridViewCellStyle { }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { ForeColor = Color.Red },
-            "DataGridViewCellStyle { ForeColor=Color [Red] }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Font = SystemFonts.DefaultFont },
-            $"DataGridViewCellStyle {{ Font={SystemFonts.DefaultFont} }}"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Format = "format" },
-            "DataGridViewCellStyle { Format=format }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { FormatProvider = new NumberFormatInfo() },
-            "DataGridViewCellStyle { }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = "null" },
-            "DataGridViewCellStyle { NullValue=null }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { NullValue = null },
-            "DataGridViewCellStyle { }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Padding = new Padding(1, 2, 3, 4) },
-            "DataGridViewCellStyle { Padding={Left=1,Top=2,Right=3,Bottom=4} }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionBackColor = Color.Red },
-            "DataGridViewCellStyle { SelectionBackColor=Color [Red] }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { SelectionForeColor = Color.Red },
-            "DataGridViewCellStyle { SelectionForeColor=Color [Red] }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { Tag = "tag" },
-            "DataGridViewCellStyle { Tag=tag }"
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle { WrapMode = DataGridViewTriState.True },
-            "DataGridViewCellStyle { WrapMode=True }"
-        };
-
-        Font font = SystemFonts.DefaultFont;
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                Alignment = DataGridViewContentAlignment.BottomCenter,
-                BackColor = Color.Red,
-                DataSourceNullValue = "dbNull",
-                Font = font,
-                ForeColor = Color.Blue,
-                Format = "format",
-                FormatProvider = new NumberFormatInfo(),
-                NullValue = "null",
-                Padding = new Padding(1, 2, 3, 4),
-                SelectionBackColor = Color.Green,
-                SelectionForeColor = Color.Yellow,
-                Tag = "tag",
-                WrapMode = DataGridViewTriState.True
-            },
-            $"DataGridViewCellStyle {{ BackColor=Color [Red], ForeColor=Color [Blue], SelectionBackColor=Color [Green], SelectionForeColor=Color [Yellow], Font={font}, NullValue=null, DataSourceNullValue=dbNull, Format=format, WrapMode=True, Alignment=BottomCenter, Padding={{Left=1,Top=2,Right=3,Bottom=4}}, Tag=tag }}"
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void DataGridViewCellStyle_ToString_Invoke_ReturnsExpected(DataGridViewCellStyle style, string expected)
-    {
-        Assert.Equal(expected, style.ToString());
-    }
-
-    private class AlwaysEqual
-    {
-        public override bool Equals(object other) => other is AlwaysEqual;
-
-        public override int GetHashCode() => base.GetHashCode();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellTests.cs
deleted file mode 100644
index 41b01f79e4b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellTests.cs
+++ /dev/null
@@ -1,6763 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-using System.Windows.Forms.Automation;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewCellTests
-{
-    [WinFormsFact]
-    public void DataGridViewCell_Ctor_Default()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Null(cell.DataGridView);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.False(cell.Displayed);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Empty(cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Null(cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.False(cell.HasStyle);
-        Assert.Equal(DataGridViewElementStates.ResizableSet, cell.InheritedState);
-        Assert.False(cell.IsInEditMode);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.False(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.False(cell.Selected);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.NotNull(cell.Style);
-        Assert.Same(cell.Style, cell.Style);
-        Assert.Null(cell.Tag);
-        Assert.Empty(cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Null(cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentBounds_Get_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentBounds_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentBounds_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentBounds_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentBounds_GetShared_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.ContentBounds);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_GetWithRow_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_GetWithColumn_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ContextMenuStrip = menu
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Null(cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_GetWithDataGridView_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            ContextMenuStrip = menu
-        };
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContextMenuStrip_GetWithDataGridViewVirtualMode_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContextMenuStrip_GetWithDataGridViewDataSource_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Equal(value, cell.ContextMenuStrip);
-
-        // Set same.
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_SetWithRow_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-
-        // Set same.
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_SetWithColumn_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-
-        // Set same.
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewCell_ContextMenuStrip_SetWithDataGridView_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ContextMenuStrip = value;
-        Assert.Equal(value, cell.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContextMenuStrip_SetWithDataGridView_CallsCellContextMenuStripChanged()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal(0, e.ColumnIndex);
-        };
-        control.CellContextMenuStripChanged += handler;
-
-        // Set non-null.
-        using var menu1 = new ContextMenuStrip();
-        cell.ContextMenuStrip = menu1;
-        Assert.Same(menu1, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        cell.ContextMenuStrip = menu1;
-        Assert.Same(menu1, cell.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        cell.ContextMenuStrip = menu2;
-        Assert.Same(menu2, cell.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        cell.ContextMenuStrip = null;
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.CellContextMenuStripChanged -= handler;
-        cell.ContextMenuStrip = menu1;
-        Assert.Equal(menu1, cell.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContextMenuStrip_Dispose_SetsToNull()
-    {
-        using var cell = new SubDataGridViewCell();
-        using var menu = new ContextMenuStrip();
-        cell.ContextMenuStrip = menu;
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.False(menu.IsDisposed);
-
-        menu.Dispose();
-        Assert.Null(cell.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContextMenuStrip_ResetThenDispose_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        using var menu1 = new ContextMenuStrip();
-        cell.ContextMenuStrip = menu1;
-        Assert.Same(menu1, cell.ContextMenuStrip);
-
-        using var menu2 = new ContextMenuStrip();
-        cell.ContextMenuStrip = menu2;
-
-        menu1.Dispose();
-        Assert.Same(menu2, cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Displayed, false)]
-    [InlineData(DataGridViewElementStates.Displayed | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewCell_Displayed_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Displayed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Displayed_GetWithRow_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.False(cell.Displayed);
-    }
-
-    public static IEnumerable<object[]> Displayed_GetWithDataGridView_TestData()
-    {
-        foreach (bool gridVisible in new bool[] { true, false })
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool columnHeadersVisible in new bool[] { true, false })
-                {
-                    foreach (bool rowVisible in new bool[] { true, false })
-                    {
-                        foreach (bool columnVisible in new bool[] { true, false })
-                        {
-                            yield return new object[] { gridVisible, rowHeadersVisible, columnHeadersVisible, rowVisible, columnVisible };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewCell_Displayed_GetWithDataGridView_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Displayed_GetWithSharedDataGridView_TestData()
-    {
-        foreach (bool gridVisible in new bool[] { true, false })
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool columnHeadersVisible in new bool[] { true, false })
-                {
-                    foreach (bool columnVisible in new bool[] { true, false })
-                    {
-                        yield return new object[] { gridVisible, rowHeadersVisible, columnHeadersVisible, columnVisible };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithSharedDataGridView_TestData))]
-    public void DataGridViewCell_Displayed_GetWithSharedDataGridView_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewCell_Displayed_GetWithDataGridViewWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(gridVisible && rowVisible && columnVisible, cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    // See https://github.com/dotnet/winforms/pull/6957
-    // Note if we fix this issue https://github.com/dotnet/winforms/issues/6930#issuecomment-1090213559 then we will have to edit this test.
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithSharedDataGridView_TestData))]
-    public void DataGridViewCell_Displayed_GetWithSharedDataGridViewWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        // We create default row with State = DataGridViewElementStates.Visible;
-        // After that we have only one such shared row in the collection.
-        // And there 2 rows in the collection overall (+ 1 new_row because of AllowUserToAddRows == true).
-        control.Rows.Add();
-        // Store it. Note that if we put this line after Assert.NotEqual(IntPtr.Zero, control.Handle),
-        // with previews implementation (prior #6957) test will fail.
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        // While calling control.Handle we will create a new handle.
-        // During this process DataGridView call MakeFirstDisplayedCellCurrentCell().
-        // Where if we have cell to display (columnVisible) we will set it as CurrentCell.
-        // Which in turn will lead to unsharing of the raw in any case.
-        // MakeFirstDisplayedCellCurrentCell() -> SetAndSelectCurrentCellAddress() -> SetCurrentCellAddressCore()
-        //   -> OnCurrentCellChanged() -> CurrentCell.get() -> Rows[index]
-        // See https://github.com/dotnet/winforms/issues/6930#issuecomment-1090213559.
-        // Note that the cell is Displayed (Displayed == true) only if the owning row IS NOT shared and Displayed and owning column is Displayed.
-        // So we have these options:
-        // 1. columnVisible == false - our row remain shared and therefore cell will not be Displayed;
-        // 2. gridVisible == false - our row and column are not Displayed, so and the cell too.
-        // 3. (gridVisible && columnVisible) == true - our row became unshared and Displayed.
-        //    But because this is the only one such row in the collection and Count of all rows = 2,
-        //    with previous implementation (prior #6957) we will clone it and LOST.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Test for shared row (if row.Index == -1 this is shared row).
-        Assert.Equal(columnVisible, row.Index != -1);
-        DataGridViewCell cell = row.Cells[0];
-        // 
-        // Here 3 our ways with previous implementation (prior #6957) in relation to the old test implementation (Assert.False(cell.Displayed)):
-        // 1. All correct - we have shared and therefore not Displayed row.
-        // 2. All correct - we have not Displayed row.
-        // 3. control.Rows.SharedRow(0) unshared and Displayed BUT our stored row (LOST) still shared and therefore not Displayed.
-        //    So test will pass of course.
-        // Test must check: Assert.Equal(gridVisible && columnVisible, cell.Displayed);
-        // And with new implementation it will work no mater where you put row = control.Rows.SharedRow(0);
-        Assert.Equal(gridVisible && columnVisible, cell.Displayed); //old test implementation: Assert.False(cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_Get_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Null(cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetWithValue_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Value = "Value"
-        };
-        Assert.Null(cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Null(cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ValueType = typeof(string);
-        Assert.Empty((string)cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetWithDataGridViewWithValue_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.Value = "Value";
-        cell.ValueType = typeof(string);
-        Assert.Equal("Value", (string)cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EditedFormattedValue_GetShared_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.EditedFormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorIconBounds_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Equal(Rectangle.Empty, cell.ErrorIconBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorIconBounds_Get_ThrowInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.ErrorIconBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorIconBounds_GetWithRow_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Throws<InvalidOperationException>(() => cell.ErrorIconBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorIconBounds_GetWithColumn_ThrowsInvalidOperationException()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.ErrorIconBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorIconBounds_GetShared_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.ErrorIconBounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Empty(cell.ErrorText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Empty(cell.ErrorText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Empty(cell.ErrorText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetShared_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Empty(cell.ErrorText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetVirtualMode_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal("errorText2", cell.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetSharedVirtualMode_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) => callCount++;
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetDataGridViewWithDataSource_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal("errorText2", cell.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_GetSharedWithDataSource_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) => callCount++;
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.ErrorText);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ErrorText = value
-        };
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ErrorText = "OldValue"
-        };
-        cell.ErrorText = value;
-
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithRow_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithRowWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            ErrorText = "OldValue"
-        };
-        row.Cells.Add(cell);
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithColumn_GetReturnsExpected(string value, string expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithColumnWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell
-        {
-            ErrorText = "OldValue"
-        };
-        column.HeaderCell = cell;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithDataGridView_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ErrorText = "OldValue";
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_Shared_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ErrorText_SharedWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = "OldValue";
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 0)]
-    [InlineData("", "", 0)]
-    [InlineData("ErrorText", "ErrorText", 1)]
-    public void DataGridViewCell_ErrorText_SetWithDataGridViewWithHandle_GetReturnsExpected(string value, string expected, int expectedInvalidatedCallCount)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 1)]
-    [InlineData("", "", 1)]
-    [InlineData("ErrorText", "ErrorText", 1)]
-    [InlineData("OldValue", "OldValue", 0)]
-    public void DataGridViewCell_ErrorText_SetWithDataGridViewWithNonNullOldValueWithHandle_GetReturnsExpected(string value, string expected, int expectedInvalidCallCount)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ErrorText = "OldValue";
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        cell.ErrorText = value;
-        Assert.Equal(expected, cell.ErrorText);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ErrorText_SetWithDataGridView_CallsCellErrorTextChanged()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.ColumnIndex);
-            Assert.Equal(0, e.RowIndex);
-        };
-        control.CellErrorTextChanged += handler;
-
-        // Set non-null.
-        cell.ErrorText = "errorText";
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        cell.ErrorText = "errorText";
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        cell.ErrorText = null;
-        Assert.Empty(cell.ErrorText);
-        Assert.Equal(2, callCount);
-
-        // Set different.
-        cell.ErrorText = "other";
-        Assert.Equal("other", cell.ErrorText);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.CellErrorTextChanged -= handler;
-        cell.ErrorText = "errorText";
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_Get_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Null(cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetWithValue_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Value = "Value"
-        };
-        Assert.Null(cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Null(cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ValueType = typeof(string);
-        Assert.Empty((string)cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetWithDataGridViewWithValue_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.Value = "Value";
-        cell.ValueType = typeof(string);
-        Assert.Equal("Value", (string)cell.FormattedValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_FormattedValue_GetShared_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.FormattedValue);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Frozen, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewCell_Frozen_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Frozen_GetWithRow_ReturnsExpected(bool rowFrozen)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = rowFrozen
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(rowFrozen, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Frozen_GetWithColumn_ReturnsExpected(bool columnFrozen)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Frozen = columnFrozen
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(columnFrozen, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewCell_Frozen_GetWithDataGridView_ReturnsExpected(bool rowFrozen, bool columnFrozen)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Frozen = rowFrozen;
-        column.Frozen = columnFrozen;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(rowFrozen && columnFrozen, cell.Frozen);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Frozen_GetShared_ReturnsExpected(bool columnFrozen)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Frozen = columnFrozen;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Frozen);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedState_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.InheritedState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.False, DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewElementStates.ResizableSet)]
-    public void DataGridViewCell_InheritedState_GetWithRowCustomState_ReturnsExpected(DataGridViewTriState resizable, DataGridViewElementStates expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = true,
-            ReadOnly = true,
-            Visible = false,
-            Resizable = resizable
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | expected, cell.InheritedState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedState_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.InheritedState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.False, DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewElementStates.ResizableSet)]
-    public void DataGridViewCell_InheritedState_GetWithColumnCustomState_ReturnsExpected(DataGridViewTriState resizable, DataGridViewElementStates expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Frozen = true,
-            ReadOnly = true,
-            Visible = false,
-            Resizable = resizable
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | expected, cell.InheritedState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedState_GetWithDataGrid_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.InheritedState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedState_GetWithDataGridCustomStateRow_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = true;
-        row.Frozen = true;
-        row.Resizable = DataGridViewTriState.True;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.InheritedState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedState_GetSharedRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.InheritedState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedStyle_Get_ThrowInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedStyle_GetWithRow_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Throws<InvalidOperationException>(() => cell.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InheritedStyle_GetWithColumn_ThrowsInvalidOperationException()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_IsInEditMode_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.False(cell.IsInEditMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_IsInEditMode_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.False(cell.IsInEditMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_IsInEditMode_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.False(cell.IsInEditMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_IsInEditMode_GetSharedRow_ThrowsInvalidOperationExceptio()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.IsInEditMode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.ReadOnly, true)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Frozen, true)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Selected, true)]
-    public void DataGridViewCell_ReadOnly_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_ReadOnly_GetWithRow_ReturnsExpected(bool rowReadOnly)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = rowReadOnly
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(rowReadOnly, cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, true, true)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, true)]
-    [InlineData(false, false, false)]
-    [InlineData(true, true, true)]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, true)]
-    [InlineData(true, false, false)]
-    public void DataGridViewCell_ReadOnly_GetWithDataGridView_ReturnsExpected(bool readOnly, bool rowReadOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        column.ReadOnly = columnReadOnly;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(readOnly || rowReadOnly || columnReadOnly, cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewCell_ReadOnly_GetShared_ReturnsExpected(bool readOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.ReadOnly = columnReadOnly;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.ReadOnly);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ReadOnly_SetWithoutOwningRow_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = true);
-        Assert.False(cell.ReadOnly);
-
-        cell.ReadOnly = false;
-        Assert.False(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SubDataGridViewCell_ReadOnly_SetWithRow_GetReturnsExpected(bool value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set same.
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set different.
-        cell.ReadOnly = !value;
-        Assert.True(cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.True((cell.State & DataGridViewElementStates.ReadOnly) != 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void SubDataGridViewCell_ReadOnly_SetWithRowReadOnlySet_GetReturnsExpected(bool rowReadOnly, bool value)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = rowReadOnly
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.Equal(rowReadOnly && value, row.ReadOnly);
-        Assert.Equal(!rowReadOnly && value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set same.
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.Equal(rowReadOnly && value, row.ReadOnly);
-        Assert.Equal(!rowReadOnly && value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set different.
-        cell.ReadOnly = !value;
-        Assert.Equal(!rowReadOnly || !value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(!rowReadOnly || !value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void SubDataGridViewCell_ReadOnly_SetWithRowReadOnlySetWithCells_GetReturnsExpected(bool rowReadOnly, bool value)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = rowReadOnly
-        };
-        using var cell1 = new SubDataGridViewCell();
-        using var cell2 = new SubDataGridViewCell();
-        row.Cells.Add(cell1);
-        row.Cells.Add(cell2);
-
-        cell1.ReadOnly = value;
-        Assert.Equal(value, cell1.ReadOnly);
-        Assert.Equal(rowReadOnly, cell2.ReadOnly);
-        Assert.Equal(rowReadOnly && value, row.ReadOnly);
-        Assert.Equal(!rowReadOnly && value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set same.
-        cell1.ReadOnly = value;
-        Assert.Equal(value, cell1.ReadOnly);
-        Assert.Equal(rowReadOnly, cell2.ReadOnly);
-        Assert.Equal(rowReadOnly && value, row.ReadOnly);
-        Assert.Equal(!rowReadOnly && value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set different.
-        cell1.ReadOnly = !value;
-        Assert.Equal(!rowReadOnly || !value, cell1.ReadOnly);
-        Assert.Equal(rowReadOnly, cell2.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(!rowReadOnly || !value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ReadOnly_SetWithColumn_ThrowsInvalidOperationException()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = true);
-        Assert.True(cell.ReadOnly);
-
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = false);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SubDataGridViewCell_ReadOnly_SetWithDataGridView_GetReturnsExpected(bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        DataGridViewCell cell = row.Cells[0];
-
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ReadOnly = value;
-        Assert.Equal(value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        cell.ReadOnly = !value;
-        Assert.Equal(!value, cell.ReadOnly);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(!value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, true)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, true)]
-    [InlineData(false, false, false)]
-    public void SubDataGridViewCell_ReadOnly_SetWithDataGridViewCellReadOnlySet_GetReturnsExpected(bool readOnly, bool rowReadOnly, bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        DataGridViewCell cell = row.Cells[0];
-
-        cell.ReadOnly = value;
-        Assert.Equal(readOnly || value, cell.ReadOnly);
-        Assert.Equal(readOnly || (rowReadOnly && value), row.ReadOnly);
-        Assert.Equal(!readOnly && !rowReadOnly && value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ReadOnly = value;
-        Assert.Equal(readOnly || value, cell.ReadOnly);
-        Assert.Equal(readOnly || (rowReadOnly && value), row.ReadOnly);
-        Assert.Equal(!readOnly && !rowReadOnly && value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        cell.ReadOnly = !value;
-        Assert.Equal(readOnly || !value, cell.ReadOnly);
-        Assert.Equal(readOnly, row.ReadOnly);
-        Assert.Equal(!readOnly && !value, (cell.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, true)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, true)]
-    [InlineData(false, false, false)]
-    public void SubDataGridViewCell_ReadOnly_SetWithDataGridViewCellReadOnlySetWithCells_GetReturnsExpected(bool readOnly, bool rowReadOnly, bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column1 = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var column2 = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        DataGridViewCell cell1 = row.Cells[0];
-        DataGridViewCell cell2 = row.Cells[1];
-
-        cell1.ReadOnly = value;
-        Assert.Equal(readOnly || value, cell1.ReadOnly);
-        Assert.Equal(readOnly || rowReadOnly, cell2.ReadOnly);
-        Assert.Equal(readOnly || (rowReadOnly && value), row.ReadOnly);
-        Assert.Equal(!readOnly && !rowReadOnly && value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell1.ReadOnly = value;
-        Assert.Equal(readOnly || value, cell1.ReadOnly);
-        Assert.Equal(readOnly || rowReadOnly, cell2.ReadOnly);
-        Assert.Equal(readOnly || (rowReadOnly && value), row.ReadOnly);
-        Assert.Equal(!readOnly && !rowReadOnly && value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        cell1.ReadOnly = !value;
-        Assert.Equal(readOnly || !value, cell1.ReadOnly);
-        Assert.Equal(readOnly || rowReadOnly, cell2.ReadOnly);
-        Assert.Equal(readOnly, row.ReadOnly);
-        Assert.Equal(!readOnly && !value, (cell1.State & DataGridViewElementStates.ReadOnly) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ReadOnly_SetWithDataGridView_CallsCellStateChanged()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(cell, e.Cell);
-            Assert.Equal(DataGridViewElementStates.ReadOnly, e.StateChanged);
-        };
-        control.CellStateChanged += handler;
-
-        // Set true.
-        cell.ReadOnly = true;
-        Assert.True(cell.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        cell.ReadOnly = true;
-        Assert.True(cell.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        cell.ReadOnly = false;
-        Assert.False(cell.ReadOnly);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CellStateChanged -= handler;
-        cell.ReadOnly = true;
-        Assert.True(cell.ReadOnly);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_ReadOnly_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Resizable, false)]
-    [InlineData(DataGridViewElementStates.Resizable | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Resizable | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewCell_Resizable_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.False, false)]
-    [InlineData(DataGridViewTriState.NotSet, false)]
-    public void DataGridViewCell_Resizable_GetWithRow_ReturnsExpected(DataGridViewTriState rowResizable, bool expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Resizable = rowResizable
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.True, DataGridViewTriState.False, true)]
-    [InlineData(DataGridViewTriState.True, DataGridViewTriState.NotSet, true)]
-    [InlineData(DataGridViewTriState.False, DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.False, DataGridViewTriState.False, false)]
-    [InlineData(DataGridViewTriState.False, DataGridViewTriState.NotSet, true)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewTriState.False, true)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewTriState.NotSet, true)]
-    public void DataGridViewCell_Resizable_GetWithDataGridView_ReturnsExpected(DataGridViewTriState rowResizable, DataGridViewTriState columnResizable, bool expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        column.Resizable = columnResizable;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(expected, cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewTriState>]
-    public void DataGridViewCell_Resizable_GetShared_ReturnsExpected(DataGridViewTriState columnResizable)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Resizable = columnResizable;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Selected, true)]
-    [InlineData(DataGridViewElementStates.Selected | DataGridViewElementStates.ReadOnly, true)]
-    [InlineData(DataGridViewElementStates.Selected | DataGridViewElementStates.Frozen, true)]
-    public void DataGridViewCell_Selected_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Selected_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewCell_Selected_GetWithDataGridView_ReturnsExpected(bool rowSelected, bool columnSelected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Selected = rowSelected;
-        column.Selected = columnSelected;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(rowSelected, cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Selected_GetShared_ReturnsExpected(bool columnSelected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Selected = columnSelected;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Selected_Set_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = true);
-        Assert.False(cell.Selected);
-
-        cell.Selected = false;
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Selected_SetWithRow_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = true);
-        Assert.False(cell.Selected);
-
-        cell.Selected = false;
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Selected_SetWithColumn_ThrowsInvalidOperationException(bool value)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Selected_SetWithDataGridView_ReturnsExpected(bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.Selected = value;
-        Assert.Equal(value, cell.Selected);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.Selected) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.Selected = value;
-        Assert.Equal(value, cell.Selected);
-        Assert.Equal(value, (cell.State & DataGridViewElementStates.Selected) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        cell.Selected = !value;
-        Assert.Equal(!value, cell.Selected);
-        Assert.Equal(!value, (cell.State & DataGridViewElementStates.Selected) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Selected_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Selected_SetWithDataGridView_CallsCellStateChanged()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(cell, e.Cell);
-            Assert.Equal(DataGridViewElementStates.Selected, e.StateChanged);
-        };
-        control.CellStateChanged += handler;
-
-        // Set true.
-        cell.Selected = true;
-        Assert.True(cell.Selected);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        cell.Selected = true;
-        Assert.True(cell.Selected);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        cell.Selected = false;
-        Assert.False(cell.Selected);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CellStateChanged -= handler;
-        cell.Selected = true;
-        Assert.True(cell.Selected);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Style_Set_TestData()
-    {
-        yield return new object[] { null, new DataGridViewCellStyle() };
-
-        var style = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomRight };
-        yield return new object[] { style, style };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_Set_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Style = value
-        };
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithNonNullOldValue_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        using var cell = new SubDataGridViewCell
-        {
-            Style = oldValue
-        };
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithRow_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithNonNullOldValueWithRow_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            Style = oldValue
-        };
-        row.Cells.Add(cell);
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithColumn_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithNonNullOldValueWithColumn_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell
-        {
-            Style = oldValue
-        };
-        column.HeaderCell = cell;
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithDataGridView_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Style_Set_TestData))]
-    public void DataGridViewCell_Style_SetWithNonNullOldValueWithDataGridView_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.Style = oldValue;
-
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-
-        // Set same.
-        cell.Style = value;
-        Assert.Equal(expected, cell.Style);
-        Assert.True(cell.HasStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Style_SetWithDataGridView_CallsCellStyleChanged()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        int callCount = 0;
-        DataGridViewCellEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.ColumnIndex);
-            Assert.Equal(0, e.RowIndex);
-            callCount++;
-        };
-        control.CellStyleChanged += handler;
-
-        var style1 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-
-        // Set non-null.
-        cell.Style = style1;
-        Assert.Equal(style1, cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        cell.Style = style1;
-        Assert.Equal(style1, cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var style2 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        cell.Style = style2;
-        Assert.Same(style2, cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        cell.Style = null;
-        Assert.NotNull(cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(3, callCount);
-
-        // Set null again.
-        cell.Style = null;
-        Assert.NotNull(cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(4, callCount);
-
-        // Set non-null.
-        cell.Style = style2;
-        Assert.NotNull(cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(5, callCount);
-
-        // Remove handler.
-        control.CellStyleChanged -= handler;
-        cell.Style = style1;
-        Assert.Equal(style1, cell.Style);
-        Assert.True(cell.HasStyle);
-        Assert.Equal(5, callCount);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewCell_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Tag = value
-        };
-        Assert.Same(value, cell.Tag);
-
-        // Set same.
-        cell.Tag = value;
-        Assert.Same(value, cell.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewCell_Tag_SetWithNonNullOldValue_GetReturnsExpected(object value)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Tag = "tag"
-        };
-        cell.Tag = value;
-        Assert.Same(value, cell.Tag);
-
-        // Set same.
-        cell.Tag = value;
-        Assert.Same(value, cell.Tag);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToolTipText_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Empty(cell.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToolTipText_GetWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Empty(cell.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToolTipText_GetWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Empty(cell.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToolTipText_GetSharedRow_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Empty(cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ToolTipText = value
-        };
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ToolTipText = "ToolTipText"
-        };
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithRow_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithRowWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            ToolTipText = "ToolTipText"
-        };
-        row.Cells.Add(cell);
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithColumn_GetReturnsExpected(string value, string expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithColumnWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell
-        {
-            ToolTipText = "ToolTipText"
-        };
-        column.HeaderCell = cell;
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithDataGridView_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ToolTipText = "ToolTipText";
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetShared_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewCell_ToolTipText_SetSharedWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        cell.ToolTipText = "ToolTipText";
-
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ToolTipText = value;
-        Assert.Equal(expected, cell.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ValueType_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.ValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_GetWithColumn_ReturnsExpected(Type valueType)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ValueType = valueType
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(typeof(object), cell.ValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_GetWithDataGridView_ReturnsExpected(Type valueType)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            ValueType = valueType
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Same(valueType, cell.ValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_Set_GetReturnsExpected(Type value)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ValueType = value
-        };
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_SetWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ValueType = typeof(string)
-        };
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_SetWithRow_GetReturnsExpected(Type value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_SetWithRowWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            ValueType = typeof(string)
-        };
-        row.Cells.Add(cell);
-
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-    }
-
-    public static IEnumerable<object[]> ValueType_SetWithColumn_TestData()
-    {
-        yield return new object[] { null, typeof(object) };
-        yield return new object[] { typeof(object), typeof(object) };
-        yield return new object[] { typeof(int), typeof(int) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetWithColumn_TestData))]
-    public void DataGridViewCell_ValueType_SetWithColumn_GetReturnsExpected(Type value, Type expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetWithColumn_TestData))]
-    public void DataGridViewCell_ValueType_SetWithColumnWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        column.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_SetWithDataGridView_GetReturnsExpected(Type value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewCell_ValueType_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ValueType = typeof(string);
-
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(value, cell.ValueType);
-        Assert.Equal(value, cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Visible, false)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewCell_Visible_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Visible_GetWithRow_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(rowVisible, cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true)]
-    [InlineData(true, true, true, false)]
-    [InlineData(true, true, false, true)]
-    [InlineData(true, true, false, false)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, true, false)]
-    [InlineData(true, false, false, true)]
-    [InlineData(true, false, false, false)]
-    [InlineData(false, true, true, true)]
-    [InlineData(false, true, true, false)]
-    [InlineData(false, true, false, true)]
-    [InlineData(false, true, false, false)]
-    [InlineData(false, false, true, true)]
-    [InlineData(false, false, true, false)]
-    [InlineData(false, false, false, true)]
-    [InlineData(false, false, false, false)]
-    public void DataGridViewCell_Visible_GetWithDataGridView_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        column.Visible = columnVisible;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(rowVisible && columnVisible, cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Visible_GetShared_ReturnsExpected(bool columnVisible)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Visible = columnVisible;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single)]
-    [InlineData(true, true, false, true, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single)]
-    [InlineData(false, true, true, true, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single)]
-    [InlineData(true, true, true, false, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single)]
-    [InlineData(true, false, true, true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single)]
-    public void DataGridViewCell_AdjustCellBorderStyle_AllSingleWithoutDataGridView_ReturnsExpected(bool singleVerticalBorderAdded, bool singleHorizontalBorderAdded, bool isFirstDisplayedColumn, bool isFirstDisplayedRow, DataGridViewAdvancedCellBorderStyle expectedLeft, DataGridViewAdvancedCellBorderStyle expectedRight, DataGridViewAdvancedCellBorderStyle expectedTop, DataGridViewAdvancedCellBorderStyle expectedBottom)
-    {
-        using var cell = new SubDataGridViewCell();
-        var controlAdvancedBorderStyleInput = new DataGridViewAdvancedBorderStyle
-        {
-            All = DataGridViewAdvancedCellBorderStyle.Single
-        };
-        var controlAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        Assert.Same(controlAdvancedBorderStylePlaceholder, cell.AdjustCellBorderStyle(controlAdvancedBorderStyleInput, controlAdvancedBorderStylePlaceholder, singleVerticalBorderAdded, singleHorizontalBorderAdded, isFirstDisplayedColumn, isFirstDisplayedRow));
-        Assert.Equal(expectedLeft, controlAdvancedBorderStylePlaceholder.Left);
-        Assert.Equal(expectedRight, controlAdvancedBorderStylePlaceholder.Right);
-        Assert.Equal(expectedTop, controlAdvancedBorderStylePlaceholder.Top);
-        Assert.Equal(expectedBottom, controlAdvancedBorderStylePlaceholder.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.None)]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.Inset)]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.InsetDouble)]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.Outset)]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.OutsetDouble)]
-    [InlineData(DataGridViewAdvancedCellBorderStyle.OutsetPartial)]
-    public void DataGridViewCell_AdjustCellBorderStyle_InvalidAll_ReturnsExpected(DataGridViewAdvancedCellBorderStyle all)
-    {
-        using var cell = new SubDataGridViewCell();
-        var controlAdvancedBorderStyleInput = new DataGridViewAdvancedBorderStyle
-        {
-            All = all
-        };
-        var controlAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        Assert.Same(controlAdvancedBorderStyleInput, cell.AdjustCellBorderStyle(controlAdvancedBorderStyleInput, controlAdvancedBorderStylePlaceholder, true, true, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_AdjustCellBorderStyle_NullDataGridViewAdvancedBorderStyleInput_ThrowsArgumentNullException()
-    {
-        using var cell = new SubDataGridViewCell();
-        var controlAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        Assert.Throws<ArgumentNullException>("dataGridViewAdvancedBorderStyleInput", () => cell.AdjustCellBorderStyle(null, controlAdvancedBorderStylePlaceholder, true, true, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_AdjustCellBorderStyle_AllNotSetWithoutDataGridView_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        var controlAdvancedBorderStyleInput = new DataGridViewAdvancedBorderStyle
-        {
-            Left = DataGridViewAdvancedCellBorderStyle.Single,
-            Right = DataGridViewAdvancedCellBorderStyle.None
-        };
-        var controlAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        Assert.Same(controlAdvancedBorderStyleInput, cell.AdjustCellBorderStyle(controlAdvancedBorderStyleInput, controlAdvancedBorderStylePlaceholder, true, true, true, true));
-    }
-
-    public static IEnumerable<object[]> AdjustCellBorderStyle_NullDataGridViewAdvancedBorderStylePlaceholder_TestData()
-    {
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.None } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.Inset } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.InsetDouble } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.Outset } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.OutsetDouble } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { All = DataGridViewAdvancedCellBorderStyle.OutsetPartial } };
-        yield return new object[] { new DataGridViewAdvancedBorderStyle { Left = DataGridViewAdvancedCellBorderStyle.Inset, Right = DataGridViewAdvancedCellBorderStyle.Outset } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustCellBorderStyle_NullDataGridViewAdvancedBorderStylePlaceholder_TestData))]
-    public void DataGridViewCell_AdjustCellBorderStyle_NullDataGridViewAdvancedBorderStylePlaceholder_ThrowsArgumentNullException(DataGridViewAdvancedBorderStyle controlAdvancedBorderStyleInput)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("dataGridViewAdvancedBorderStylePlaceholder", () => cell.AdjustCellBorderStyle(controlAdvancedBorderStyleInput, null, true, true, true, true));
-    }
-
-    public static IEnumerable<object[]> BorderWidths_TestData()
-    {
-        yield return new object[] { new DataGridViewAdvancedBorderStyle(), new Rectangle(0, 0, 0, 0) };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle(),
-            new Rectangle(0, 0, 0, 0)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                All = DataGridViewAdvancedCellBorderStyle.OutsetDouble
-            },
-            new Rectangle(2, 2, 2, 2)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                All = DataGridViewAdvancedCellBorderStyle.InsetDouble
-            },
-            new Rectangle(2, 2, 2, 2)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                All = DataGridViewAdvancedCellBorderStyle.Single
-            },
-            new Rectangle(1, 1, 1, 1)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                Left = DataGridViewAdvancedCellBorderStyle.Single
-            },
-            new Rectangle(1, 0, 0, 0)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                Right = DataGridViewAdvancedCellBorderStyle.Single
-            },
-            new Rectangle(0, 0, 1, 0)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                Top = DataGridViewAdvancedCellBorderStyle.Single
-            },
-            new Rectangle(0, 1, 0, 0)
-        };
-        yield return new object[]
-        {
-            new DataGridViewAdvancedBorderStyle
-            {
-                Bottom = DataGridViewAdvancedCellBorderStyle.Single
-            },
-            new Rectangle(0, 0, 0, 1)
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_Invoke_ReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(expected, cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_InvokeWithRow_ReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            DividerHeight = 10
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(new Rectangle(expected.X, expected.Y, expected.Width, expected.Height + 10), cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_InvokeWithColumn_ReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DividerWidth = 10
-        };
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(new Rectangle(expected.X, expected.Y, expected.Width + 10, expected.Height), cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_InvokeWithDataGridView_ReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        column.DividerWidth = 10;
-        row.DividerHeight = 11;
-        SubDataGridViewCell cell = (SubDataGridViewCell)row.Cells[0];
-        Assert.Equal(new Rectangle(expected.X, expected.Y, expected.Width + 10, expected.Height + 11), cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_InvokeWithDataGridViewRightToLeft_ReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        column.DividerWidth = 10;
-        row.DividerHeight = 11;
-        SubDataGridViewCell cell = (SubDataGridViewCell)row.Cells[0];
-        Assert.Equal(new Rectangle(expected.X + 10, expected.Y, expected.Width, expected.Height + 11), cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderWidths_TestData))]
-    public void DataGridViewCell_BorderWidths_InvokeSharedReturnsExpected(DataGridViewAdvancedBorderStyle advancedBorderStyle, Rectangle expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        column.DividerWidth = 10;
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Equal(new Rectangle(expected.X, expected.Y, expected.Width + 10, expected.Height), cell.BorderWidths(advancedBorderStyle));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_BorderWidths_NullAdvancedBorderStyleInput_ThrowsArgumentNullException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("advancedBorderStyle", () => cell.BorderWidths(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.ClickUnsharesRow(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Clone_NonEmpty_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        using var source = new SubDataGridViewCell
-        {
-            ContextMenuStrip = menu,
-            ErrorText = "errorText",
-            Style = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft },
-            Tag = "tag",
-            ToolTipText = "toolTipText",
-            Value = "value",
-            ValueType = typeof(int)
-        };
-
-        SubDataGridViewCell cell = Assert.IsType<SubDataGridViewCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.False(menu.IsDisposed);
-        Assert.NotNull(cell.ContextMenuStrip);
-        Assert.NotSame(source.ContextMenuStrip, cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(int), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.True(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.False(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft }, cell.Style);
-        Assert.NotSame(source.Style, cell.Style);
-        Assert.Equal("tag", cell.Tag);
-        Assert.Equal("toolTipText", cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Equal(typeof(int), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Clone_Empty_Success()
-    {
-        using var source = new SubDataGridViewCell();
-        SubDataGridViewCell cell = Assert.IsType<SubDataGridViewCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Empty(cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Null(cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.False(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.False(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle(), cell.Style);
-        Assert.Null(cell.Tag);
-        Assert.Empty(cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Null(cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.ContentClickUnsharesRow(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ContentDoubleClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.ContentDoubleClickUnsharesRow(null));
-    }
-
-    public class CreateAccessibilityInstanceTests : DataGridViewCell
-    {
-        [WinFormsFact]
-        public void DataGridViewCell_AccessibilityObject_Get_ReturnsExpected()
-        {
-            using var cell = new SubDataGridViewCell();
-            DataGridViewCell.DataGridViewCellAccessibleObject accessibleObject = Assert.IsType<DataGridViewCell.DataGridViewCellAccessibleObject>(cell.AccessibilityObject);
-            Assert.Same(accessibleObject, cell.AccessibilityObject);
-            Assert.Same(cell, accessibleObject.Owner);
-        }
-
-        public static IEnumerable<object[]> AccessibilityObject_CustomCreateAccessibilityInstance_TestData()
-        {
-            yield return new object[] { null };
-            yield return new object[] { new AccessibleObject() };
-            yield return new object[] { new DataGridViewCell.DataGridViewCellAccessibleObject(null) };
-            yield return new object[] { new DataGridViewCell.DataGridViewCellAccessibleObject(new SubDataGridViewCell()) };
-        }
-
-        [WinFormsTheory]
-        [MemberData(nameof(AccessibilityObject_CustomCreateAccessibilityInstance_TestData))]
-        public void DataGridViewCell_AccessibilityObject_GetCustomCreateAccessibilityInstance_ReturnsExpected(AccessibleObject result)
-        {
-            using var control = new CustomCreateAccessibilityInstanceDataGridViewCell
-            {
-                CreateAccessibilityResult = result
-            };
-            Assert.Same(result, control.AccessibilityObject);
-            Assert.Same(control.AccessibilityObject, control.AccessibilityObject);
-        }
-
-        [WinFormsFact]
-        public void DataGridViewCell_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-        {
-            using var cell = new SubDataGridViewCell();
-            DataGridViewCell.DataGridViewCellAccessibleObject instance = Assert.IsAssignableFrom<DataGridViewCell.DataGridViewCellAccessibleObject>(cell.CreateAccessibilityInstance());
-            Assert.NotNull(instance);
-            Assert.Same(cell, instance.Owner);
-            Assert.Equal(AccessibleRole.Cell, instance.Role);
-            Assert.NotSame(cell.CreateAccessibilityInstance(), instance);
-            Assert.NotSame(cell.AccessibilityObject, instance);
-        }
-
-        private class CustomCreateAccessibilityInstanceDataGridViewCell : DataGridViewCell
-        {
-            public AccessibleObject CreateAccessibilityResult { get; set; }
-
-            protected override AccessibleObject CreateAccessibilityInstance() => CreateAccessibilityResult;
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_DetachEditingDataGridViewCell_InvokeNoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.DetachEditingControl());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_DetachEditingDataGridViewCell_InvokeNoEditingControl_ThrowsInvalidOperationException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.DetachEditingControl());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Dispose_InvokeWithoutContextMenuStrip_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.Dispose();
-        Assert.Null(cell.ContextMenuStrip);
-
-        // Call multiple times.
-        cell.Dispose();
-        Assert.Null(cell.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Dispose_InvokeWithContextMenuStrip_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        using var cell = new SubDataGridViewCell
-        {
-            ContextMenuStrip = menu
-        };
-        cell.Dispose();
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.False(menu.IsDisposed);
-
-        // Call multiple times.
-        cell.Dispose();
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.False(menu.IsDisposed);
-
-        // Dispose menu.
-        menu.Dispose();
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.True(menu.IsDisposed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Dispose_InvokeDisposingWithoutContextMenuStrip_Nop(bool disposing)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.Dispose(disposing);
-        Assert.Null(cell.ContextMenuStrip);
-
-        // Call multiple times.
-        cell.Dispose(disposing);
-        Assert.Null(cell.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewCell_Dispose_InvokeDisposingWithContextMenuStrip_Success(bool disposing)
-    {
-        using var menu = new ContextMenuStrip();
-        using var cell = new SubDataGridViewCell
-        {
-            ContextMenuStrip = menu
-        };
-        cell.Dispose(disposing);
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.False(menu.IsDisposed);
-
-        // Call multiple times.
-        cell.Dispose(disposing);
-        Assert.Same(menu, cell.ContextMenuStrip);
-        Assert.False(menu.IsDisposed);
-
-        // Dispose menu.
-        menu.Dispose();
-        Assert.Equal(disposing, cell.ContextMenuStrip == menu);
-        Assert.True(menu.IsDisposed);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_DoubleClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.DoubleClickUnsharesRow(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_EnterUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.EnterUnsharesRow(-1, true));
-    }
-
-    public static IEnumerable<object[]> GetClipboardContent_TestData()
-    {
-        yield return new object[] { -2, true, true, true, true, "format", null };
-        yield return new object[] { -2, true, true, true, true, null, null };
-        yield return new object[] { -1, true, true, true, true, "format", null };
-        yield return new object[] { -1, true, true, true, true, null, null };
-        yield return new object[] { 0, true, true, true, true, "format", null };
-        yield return new object[] { 0, true, true, true, true, null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetClipboardContent_TestData))]
-    public void DataGridViewCell_GetClipboardContent_Invoke_ReturnsExpected(int rowIndex, bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format, object expected)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(expected, cell.GetClipboardContent(rowIndex, firstCell, lastCell, inFirstRow, inLastRow, format));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetClipboardContent_TestData))]
-    public void DataGridViewCell_GetClipboardContent_InvokeWithRow_ReturnsExpected(int rowIndex, bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format, object expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(expected, cell.GetClipboardContent(rowIndex, firstCell, lastCell, inFirstRow, inLastRow, format));
-    }
-
-    public static IEnumerable<object[]> GetClipboardContent_WithColumn_TestData()
-    {
-        yield return new object[] { true, true, true, true, "format", null };
-        yield return new object[] { true, true, true, true, null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetClipboardContent_WithColumn_TestData))]
-    public void DataGridViewCell_GetClipboardContent_InvokeWithColumn_ReturnsExpected(bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format, object expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(expected, cell.GetClipboardContent(-1, firstCell, lastCell, inFirstRow, inLastRow, format));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetClipboardContent_WithColumn_TestData))]
-    public void DataGridViewCell_GetClipboardContent_InvokeWithDataGridView_ReturnsExpected(bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format, object expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Equal(expected, cell.GetClipboardContent(0, firstCell, lastCell, inFirstRow, inLastRow, format));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetClipboardContent_WithColumn_TestData))]
-    public void DataGridViewCell_GetClipboardContent_InvokeShared_ReturnsExpected(bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format, object expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Equal(expected, cell.GetClipboardContent(0, firstCell, lastCell, inFirstRow, inLastRow, format));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetClipboardContent_InvalidRowIndexWithColumn_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetClipboardContent(rowIndex, true, true, true, true, "format"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetClipboardContent_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetClipboardContent(rowIndex, true, true, true, true, "format"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetClipboardContent_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetClipboardContent(rowIndex, true, true, true, true, "format"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetContentBounds_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetContentBounds_InvokeWithRow_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetContentBounds_InvokeWithColumn_ReturnsExpected(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetContentBounds_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetContentBounds_InvokeShared_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetContentBounds_InvokeInvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetContentBounds(rowIndex));
-    }
-
-    public static IEnumerable<object[]> GetContentBounds_TestData()
-    {
-        yield return new object[] { null, -2 };
-        yield return new object[] { null, -1 };
-        yield return new object[] { null, 0 };
-        yield return new object[] { null, 1 };
-        yield return new object[] { new DataGridViewCellStyle(), -2 };
-        yield return new object[] { new DataGridViewCellStyle(), -1 };
-        yield return new object[] { new DataGridViewCellStyle(), 0 };
-        yield return new object[] { new DataGridViewCellStyle(), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetContentBounds_TestData))]
-    public void DataGridViewCell_GetContentBounds_InvokeWithoutGraphics_ReturnsExpected(DataGridViewCellStyle cellStyle, int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(null, cellStyle, rowIndex));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetContentBounds_TestData))]
-    public void DataGridViewCell_GetContentBounds_InvokeWithGraphics_ReturnsExpected(DataGridViewCellStyle cellStyle, int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Equal(Rectangle.Empty, cell.GetContentBounds(graphics, cellStyle, rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(-1, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(0, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(1, DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_Invoke_ReturnsExpected(int rowIndex, DataGridViewDataErrorContexts context)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Null(cell.GetEditedFormattedValue(rowIndex, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(-1, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(0, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(1, DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeWithValue_ReturnsExpected(int rowIndex, DataGridViewDataErrorContexts context)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Value = "Value"
-        };
-        Assert.Null(cell.GetEditedFormattedValue(rowIndex, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(-1, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(0, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(1, DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeWithRow_ReturnsExpected(int rowIndex, DataGridViewDataErrorContexts context)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.GetEditedFormattedValue(rowIndex, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(-1, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(0, DataGridViewDataErrorContexts.Formatting)]
-    [InlineData(1, DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeWithColumn_ReturnsExpected(int rowIndex, DataGridViewDataErrorContexts context)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Null(cell.GetEditedFormattedValue(rowIndex, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeWithDataGridView_ReturnsExpected(DataGridViewDataErrorContexts context)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ValueType = typeof(string);
-        Assert.Empty((string)cell.GetEditedFormattedValue(0, context));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeWithDataGridViewWithValue_ReturnsExpected(DataGridViewDataErrorContexts context)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.Value = "Value";
-        cell.ValueType = typeof(string);
-        Assert.Equal("Value", (string)cell.GetEditedFormattedValue(0, context));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewDataErrorContexts.Formatting)]
-    public void DataGridViewCell_GetEditedFormattedValue_InvokeShared_ReturnsExpected(DataGridViewDataErrorContexts context)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        cell.ValueType = typeof(string);
-        Assert.Empty((string)cell.GetEditedFormattedValue(0, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewRow_GetEditedFormattedValue_InvalidRowIndex_ThrowsArgumentOutRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetEditedFormattedValue(rowIndex, DataGridViewDataErrorContexts.Formatting));
-    }
-
-    public static IEnumerable<object[]> GetErrorIconBounds_TestData()
-    {
-        yield return new object[] { null, -2 };
-        yield return new object[] { null, -1 };
-        yield return new object[] { null, 0 };
-        yield return new object[] { null, 1 };
-        yield return new object[] { new DataGridViewCellStyle(), -2 };
-        yield return new object[] { new DataGridViewCellStyle(), -1 };
-        yield return new object[] { new DataGridViewCellStyle(), 0 };
-        yield return new object[] { new DataGridViewCellStyle(), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetErrorIconBounds_TestData))]
-    public void DataGridViewCell_GetErrorIconBounds_InvokeWithoutGraphics_ReturnsExpected(DataGridViewCellStyle cellStyle, int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(Rectangle.Empty, cell.GetErrorIconBounds(null, cellStyle, rowIndex));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetErrorIconBounds_TestData))]
-    public void DataGridViewCell_GetErrorIconBounds_InvokeWithGraphics_ReturnsExpected(DataGridViewCellStyle cellStyle, int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Equal(Rectangle.Empty, cell.GetErrorIconBounds(graphics, cellStyle, rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -2, "")]
-    [InlineData(null, -1, "")]
-    [InlineData(null, 0, "")]
-    [InlineData("", -2, "")]
-    [InlineData("", -1, "")]
-    [InlineData("", 0, "")]
-    [InlineData("ErrorText", -2, "ErrorText")]
-    [InlineData("ErrorText", -1, "ErrorText")]
-    [InlineData("ErrorText", 0, "ErrorText")]
-    public void DataGridViewCell_GetErrorText_Invoke_ReturnsExpected(string errorText, int rowIndex, string expected)
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            ErrorText = errorText
-        };
-        Assert.Equal(expected, cell.GetErrorText(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -2, "")]
-    [InlineData(null, -1, "")]
-    [InlineData(null, 0, "")]
-    [InlineData("", -2, "")]
-    [InlineData("", -1, "")]
-    [InlineData("", 0, "")]
-    [InlineData("ErrorText", -2, "ErrorText")]
-    [InlineData("ErrorText", -1, "ErrorText")]
-    [InlineData("ErrorText", 0, "ErrorText")]
-    public void DataGridViewCell_GetErrorText_InvokeWithRow_ReturnsExpected(string errorText, int rowIndex, string expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            ErrorText = errorText
-        };
-        row.Cells.Add(cell);
-        Assert.Equal(expected, cell.GetErrorText(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -2, "")]
-    [InlineData(null, -1, "")]
-    [InlineData(null, 0, "")]
-    [InlineData("", -2, "")]
-    [InlineData("", -1, "")]
-    [InlineData("", 0, "")]
-    [InlineData("ErrorText", -2, "ErrorText")]
-    [InlineData("ErrorText", -1, "ErrorText")]
-    [InlineData("ErrorText", 0, "ErrorText")]
-    public void DataGridViewCell_GetErrorText_InvokeWithColumn_ReturnsExpected(string errorText, int rowIndex, string expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell
-        {
-            ErrorText = errorText
-        };
-        column.HeaderCell = cell;
-        Assert.Equal(expected, cell.GetErrorText(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -2, "")]
-    [InlineData(null, -1, "")]
-    [InlineData(null, 0, "")]
-    [InlineData("", -2, "")]
-    [InlineData("", -1, "")]
-    [InlineData("", 0, "")]
-    [InlineData("ErrorText", -2, "ErrorText")]
-    [InlineData("ErrorText", -1, "ErrorText")]
-    [InlineData("ErrorText", 0, "ErrorText")]
-    public void DataGridViewCell_GetErrorText_InvokeWithDataGridView_ReturnsExpected(string errorText, int rowIndex, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.ErrorText = errorText;
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        Assert.Equal(expected, cell.GetErrorText(rowIndex));
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -2, "")]
-    [InlineData(null, -1, "")]
-    [InlineData(null, 0, "")]
-    [InlineData("", -2, "")]
-    [InlineData("", -1, "")]
-    [InlineData("", 0, "")]
-    [InlineData("ErrorText", -2, "ErrorText")]
-    [InlineData("ErrorText", -1, "ErrorText")]
-    [InlineData("ErrorText", 0, "ErrorText")]
-    public void DataGridViewCell_GetErrorText_InvokeShared_ReturnsExpected(string errorText, int rowIndex, string expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = errorText;
-        int callCount = 0;
-        control.CellErrorTextNeeded += (sender, e) => callCount++;
-
-        Assert.Equal(expected, cell.GetErrorText(rowIndex));
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0, "errorText1")]
-    [InlineData(-1, 0, "errorText1")]
-    [InlineData(0, 1, "errorText2")]
-    public void DataGridViewCell_GetErrorText_InvokeVirtualMode_ReturnsExpected(int rowIndex, int expectedCallCount, string expectedErrorText)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(rowIndex, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal(expectedErrorText, cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0, "errorText1")]
-    [InlineData(-1, 0, "errorText1")]
-    [InlineData(0, 1, "errorText2")]
-    public void DataGridViewCell_GetErrorText_InvokeSharedWithVirtualMode_ReturnsExpected(int rowIndex, int expectedCallCount, string expectedErrorText)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(rowIndex, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal(expectedErrorText, cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0, "errorText1")]
-    [InlineData(-1, 0, "errorText1")]
-    [InlineData(0, 1, "errorText2")]
-    public void DataGridViewCell_GetErrorText_InvokeDataGridViewWithDataSource_ReturnsExpected(int rowIndex, int expectedCallCount, string expectedErrorText)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        control.Columns.Add(column);
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(rowIndex, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal(expectedErrorText, cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0, "errorText1")]
-    [InlineData(-1, 0, "errorText1")]
-    [InlineData(0, 1, "errorText2")]
-    public void DataGridViewCell_GetErrorText_InvokeSharedWithDataSource_ReturnsExpected(int rowIndex, int expectedCallCount, string expectedErrorText)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        control.Columns.Add(column);
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        cell.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewCellErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(rowIndex, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.CellErrorTextNeeded += handler;
-
-        Assert.Equal(expectedErrorText, cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.CellErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", cell.GetErrorText(rowIndex));
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetErrorText_InvalidRowIndex_ThrowsArgumentOutRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("e.RowIndex", () => cell.GetErrorText(1));
-    }
-
-    public static IEnumerable<object[]> GetFormattedValue_TestData()
-    {
-        yield return new object[] { "value", -2, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter(), DataGridViewDataErrorContexts.Formatting, null };
-        yield return new object[] { "value", -1, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter(), DataGridViewDataErrorContexts.Formatting, null };
-        yield return new object[] { "value", 0, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter(), DataGridViewDataErrorContexts.Formatting, null };
-        yield return new object[] { null, -2, null, null, null, (DataGridViewDataErrorContexts)(DataGridViewDataErrorContexts.Formatting - 1), null };
-        yield return new object[] { null, -1, null, null, null, (DataGridViewDataErrorContexts)(DataGridViewDataErrorContexts.Formatting - 1), null };
-        yield return new object[] { null, 0, null, null, null, (DataGridViewDataErrorContexts)(DataGridViewDataErrorContexts.Formatting - 1), null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetFormattedValue_TestData))]
-    public void DataGridViewCell_GetFormattedValue_Invoke_ReturnsExpected(object value, int rowIndex, DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context, object expected)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(expected, cell.GetFormattedValue(value, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetFormattedValue_TestData))]
-    public void DataGridViewCell_GetFormattedValue_InvokeWithRow_ReturnsExpected(object value, int rowIndex, DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context, object expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(expected, cell.GetFormattedValue(value, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetFormattedValue_TestData))]
-    public void DataGridViewCell_GetFormattedValue_InvokeWithColumn_ReturnsExpected(object value, int rowIndex, DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context, object expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(expected, cell.GetFormattedValue(value, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Null(cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithMenu_ReturnsExpected(int rowIndex)
-    {
-        using var cellMenu = new ContextMenuStrip();
-        using var cell = new SubDataGridViewCell
-        {
-            ContextMenuStrip = cellMenu
-        };
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    public static IEnumerable<object[]> GetInheritedContextMenuStrip_TestData()
-    {
-        yield return new object[] { -2, null };
-        yield return new object[] { -2, new ContextMenuStrip() };
-        yield return new object[] { -1, null };
-        yield return new object[] { -1, new ContextMenuStrip() };
-        yield return new object[] { 0, null };
-        yield return new object[] { 0, new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedContextMenuStrip_TestData))]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithRow_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedContextMenuStrip_TestData))]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithMenuWithRow_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        using var cellMenu = new ContextMenuStrip();
-        using var cell = new SubDataGridViewCell
-        {
-            ContextMenuStrip = cellMenu
-        };
-        row.Cells.Add(cell);
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_GetWithDataGridView_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithDataGridView_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithMenuWithDataGridView_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        using var cellMenu = new ContextMenuStrip();
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = cellMenu;
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeShared_ReturnsExpected(ContextMenuStrip menu)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithDataGridViewVirtualMode_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvokeWithDataGridViewDataSource_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetInheritedContextMenuStrip_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_Invoke_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(DataGridViewElementStates.ResizableSet, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.False, DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewElementStates.ResizableSet)]
-    public void DataGridViewCell_GetInheritedState_InvokeWithRowCustomState_ReturnsExpected(DataGridViewTriState resizable, DataGridViewElementStates expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = true,
-            ReadOnly = true,
-            Visible = false,
-            Resizable = resizable
-        };
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | expected, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_InvokeWithDataGrid_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_DataGridViewCustomState_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomState_TestData))]
-    public void DataGridViewCell_GetInheritedState_InvokeWithDataGridCustomState_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_InvokeWithDataGridWithHandle_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_DataGridViewCustomStateWithHandle_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Selected };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomStateWithHandle_TestData))]
-    public void DataGridViewCell_GetInheritedState_InvokeWithDataGridCustomStateWithHandle_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_InvokeWithDataGridCustomStateRow_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = true;
-        row.Frozen = true;
-        row.Resizable = DataGridViewTriState.True;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedState_InvokeSharedRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetInheritedState_InvalidRowIndexNoDataGridView_ThrowsArgumentException(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentException>(() => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetInheritedState_InvalidRowIndexWithRow_ThrowsArgumentException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Throws<ArgumentException>(() => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewCell_GetInheritedState_InvalidRowIndexWithColumn_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetInheritedState_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetInheritedState_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedStyle_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.GetInheritedStyle(new DataGridViewCellStyle(), -1, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedStyle_InvokeWithoutDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.GetInheritedStyle(new DataGridViewCellStyle(), -1, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedStyle_InvokeWithRow_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Throws<InvalidOperationException>(() => cell.GetInheritedStyle(new DataGridViewCellStyle(), -1, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetInheritedStyle_InvokeWithColumn_ThrowsInvalidOperationException()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.GetInheritedStyle(new DataGridViewCellStyle(), -1, true));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetInheritedStyle_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedStyle(new DataGridViewCellStyle(), rowIndex, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InitializeEditingControl_Set_Parent()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        dataGridView.CreateControl();
-
-        Assert.True(dataGridView.AccessibilityObject is Control.ControlAccessibleObject);
-
-        using DataGridViewTextBoxColumn column1 = new DataGridViewTextBoxColumn();
-        dataGridView.Columns.Add(column1);
-        dataGridView.Rows.Add();
-        var cell = dataGridView.Rows[0].Cells[0];
-        cell.Selected = true;
-
-        // Attach EditingControl.AccessibilityObject to cell
-        dataGridView.BeginEdit(false);
-        Assert.NotNull(dataGridView.EditingControl.AccessibilityObject.Parent);
-        Assert.Same(cell.AccessibilityObject, dataGridView.EditingControl.AccessibilityObject.Parent);
-
-        // Detach EditingControl.AccessibilityObject
-        dataGridView.EndEdit();
-        Assert.Null(dataGridView.EditingControlAccessibleObject);
-
-        // Reattach EditingControl.AccessibilityObject to cell
-        dataGridView.BeginEdit(false);
-        Assert.NotNull(dataGridView.EditingControl.AccessibilityObject.Parent);
-        Assert.Same(cell.AccessibilityObject, dataGridView.EditingControl.AccessibilityObject.Parent);
-
-        dataGridView.EndEdit();
-    }
-
-    [StaFact]
-    public void DataGridViewCell_GetNeighboringToolsRectangles_ReturnsCorrectRectangles()
-    {
-        DataGridView control = new DataGridView();
-        control.Size = new Size(600, 200);
-        control.CreateControl();
-
-        DataGridViewTextBoxColumn column1 = new DataGridViewTextBoxColumn();
-        DataGridViewTextBoxColumn column2 = new DataGridViewTextBoxColumn();
-        DataGridViewTextBoxColumn column3 = new DataGridViewTextBoxColumn();
-        DataGridViewTextBoxColumn column4 = new DataGridViewTextBoxColumn();
-
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        control.Columns.Add(column3);
-        control.Columns.Add(column4);
-
-        control.Rows.Add();
-        control.Rows.Add();
-        control.Rows.Add();
-        control.Rows.Add();
-
-        control.Rows[0].Cells[1].Value = "Text";
-        control.Rows[1].Cells[2].Value = "Text";
-        control.Rows[1].Cells[3].Value = "Text";
-        control.Rows[2].Cells[0].Value = "Text";
-        control.Rows[2].Cells[1].Value = "Text";
-        control.Rows[2].Cells[3].Value = "Text";
-        control.Rows[3].Cells[1].Value = "Text";
-        control.Rows[3].Cells[2].Value = "Text";
-
-        IList<Rectangle> neighbors00 = ((IKeyboardToolTip)control.Rows[0].Cells[0]).GetNeighboringToolsRectangles();
-        Assert.True(neighbors00.Contains(control.Rows[0].Cells[1].AccessibilityObject.Bounds));
-        Assert.False(neighbors00.Contains(control.Rows[1].Cells[1].AccessibilityObject.Bounds));
-        Assert.False(neighbors00.Contains(control.Rows[1].Cells[0].AccessibilityObject.Bounds));
-
-        IList<Rectangle> neighbors21 = ((IKeyboardToolTip)control.Rows[2].Cells[1]).GetNeighboringToolsRectangles();
-        Assert.True(neighbors21.Contains(control.Rows[1].Cells[2].AccessibilityObject.Bounds));
-        Assert.True(neighbors21.Contains(control.Rows[2].Cells[0].AccessibilityObject.Bounds));
-        Assert.True(neighbors21.Contains(control.Rows[2].Cells[1].AccessibilityObject.Bounds));
-        Assert.True(neighbors21.Contains(control.Rows[3].Cells[1].AccessibilityObject.Bounds));
-        Assert.False(neighbors21.Contains(control.Rows[1].Cells[1].AccessibilityObject.Bounds));
-
-        IList<Rectangle> neighbors33 = ((IKeyboardToolTip)control.Rows[3].Cells[3]).GetNeighboringToolsRectangles();
-        Assert.True(neighbors33.Contains(control.Rows[2].Cells[3].AccessibilityObject.Bounds));
-        Assert.True(neighbors33.Contains(control.Rows[3].Cells[2].AccessibilityObject.Bounds));
-        Assert.False(neighbors33.Contains(control.Rows[2].Cells[2].AccessibilityObject.Bounds));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetPreferredSize_Invoke_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(new Size(-1, -1), cell.GetPreferredSize(null, null, -1, Size.Empty));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetSize_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal(new Size(-1, -1), cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetSize_InvokeWithRow_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(new Size(-1, -1), cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetSize_InvokeWithDataGridView_ReturnsExpected(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Height = 11;
-        SubDataGridViewCell cell = (SubDataGridViewCell)row.Cells[0];
-        Assert.Equal(new Size(10, 11), cell.GetSize(rowIndex));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetSize_InvokeShared_ReturnsExpected(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Equal(new Size(10, Control.DefaultFont.Height + 9), cell.GetSize(rowIndex));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetSize_InvalidRowIndexWithColumn_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetSize_InvalidRowIndexWithDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.GetSize(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetSize_InvalidRowIndexShared_ThrowsInvalidOperationException()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.GetSize(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Null(cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_InvokeWithValue_ReturnsExpected(int rowIndex)
-    {
-        var value = new object();
-        using var cell = new SubDataGridViewCell
-        {
-            Value = value
-        };
-        Assert.Same(value, cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_InvokeWithRow_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_InvokeWithValueWithRow_ReturnsExpected(int rowIndex)
-    {
-        var value = new object();
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell
-        {
-            Value = value
-        };
-        row.Cells.Add(cell);
-        Assert.Same(value, cell.GetValue(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Null(cell.GetValue(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeWithValueWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        var value = new object();
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.Value = value;
-        Assert.Same(value, cell.GetValue(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeShared_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Null(cell.GetValue(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeSharedWithValue_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        var value = new object();
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.Value = value);
-        Assert.Null(cell.GetValue(0));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeWithDataGridViewVirtualMode_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.Value = value1;
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Same(value2, cell.GetValue(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Null(cell.GetValue(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeWithDataGridViewNewRowVirtualMode_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.Value = value1;
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Null(cell.GetValue(0));
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Null(cell.GetValue(0));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_GetValue_InvokeWithDataGridViewNewRowDataSource_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        control.Columns.Add(column);
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.Value = value1;
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Same(value1, cell.GetValue(0));
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Same(value1, cell.GetValue(0));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_GetValue_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_InitializeEditingDataGridViewCell_SetNoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.InitializeEditingControl(-1, null, null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_KeyDownUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.KeyDownUnsharesRow(null, -1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_KeyEntersEditMode_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.KeyEntersEditMode(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_KeyPressUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.KeyPressUnsharesRow(null, -1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_KeyUpUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.KeyUpUnsharesRow(null, -1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_LeaveUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.LeaveUnsharesRow(-1, true));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DataGridViewCell_MeasureTextHeight_NullOrEmptyText_ReturnsExpected(string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        int height = DataGridViewCell.MeasureTextHeight(graphics, text, SystemFonts.DefaultFont, 10, TextFormatFlags.Default);
-        Assert.Equal(0, height);
-
-        height = DataGridViewCell.MeasureTextHeight(graphics, text, SystemFonts.DefaultFont, 10, TextFormatFlags.Default, out bool widthTruncated);
-        Assert.Equal(0, height);
-        Assert.False(widthTruncated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("a", false)]
-    [InlineData("truncate_me", true)]
-    public void DataGridViewCell_MeasureTextHeight_NonEmptyText_ReturnsExpected(string text, bool expectedWidthTruncated)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        int height = DataGridViewCell.MeasureTextHeight(graphics, text, SystemFonts.DefaultFont, 20, TextFormatFlags.Default);
-        Assert.NotEqual(0, height);
-
-        height = DataGridViewCell.MeasureTextHeight(graphics, text, SystemFonts.DefaultFont, 20, TextFormatFlags.Default, out bool widthTruncated);
-        Assert.NotEqual(0, height);
-        Assert.Equal(expectedWidthTruncated, widthTruncated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextHeight_NullGraphics_ThrowsArgumentNullException()
-    {
-        bool widthTruncated = true;
-        Assert.Throws<ArgumentNullException>("graphics", () => DataGridViewCell.MeasureTextHeight(null, "text", SystemFonts.DefaultFont, 10, TextFormatFlags.Default));
-        Assert.Throws<ArgumentNullException>("graphics", () => DataGridViewCell.MeasureTextHeight(null, "text", SystemFonts.DefaultFont, 10, TextFormatFlags.Default, out widthTruncated));
-        Assert.True(widthTruncated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextHeight_NullFont_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        bool widthTruncated = true;
-        Assert.Throws<ArgumentNullException>("font", () => DataGridViewCell.MeasureTextHeight(graphics, "text", null, 10, TextFormatFlags.Default));
-        Assert.Throws<ArgumentNullException>("font", () => DataGridViewCell.MeasureTextHeight(graphics, "text", null, 10, TextFormatFlags.Default, out widthTruncated));
-        Assert.True(widthTruncated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void DataGridViewCell_MeasureTextHeight_InvalidMaxWidth_ThrowsArgumentOutOfRangeException(int maxWidth)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        bool widthTruncated = true;
-        Assert.Throws<ArgumentOutOfRangeException>("maxWidth", () => DataGridViewCell.MeasureTextHeight(graphics, "text", SystemFonts.DefaultFont, maxWidth, TextFormatFlags.Default));
-        Assert.Throws<ArgumentOutOfRangeException>("maxWidth", () => DataGridViewCell.MeasureTextHeight(graphics, "text", SystemFonts.DefaultFont, maxWidth, TextFormatFlags.Default, out widthTruncated));
-        Assert.True(widthTruncated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((TextFormatFlags)(-1))]
-    public void DataGridViewCell_MeasureTextHeight_InvalidFlags_ThrowsInvalidEnumArgumentException(TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        bool widthTruncated = true;
-        Assert.Throws<InvalidEnumArgumentException>("flags", () => DataGridViewCell.MeasureTextHeight(graphics, "text", SystemFonts.DefaultFont, 10, flags));
-        Assert.Throws<InvalidEnumArgumentException>("flags", () => DataGridViewCell.MeasureTextHeight(graphics, "text", SystemFonts.DefaultFont, 10, flags, out widthTruncated));
-        Assert.True(widthTruncated);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DataGridViewCell_MeasureTextPreferredSize_NullOrEmptyText_ReturnsExpected(string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Equal(Size.Empty, DataGridViewCell.MeasureTextPreferredSize(graphics, text, SystemFonts.DefaultFont, 0.2f, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData("a", TextFormatFlags.Default)]
-    [InlineData("truncate_me", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    public void DataGridViewCell_MeasureTextPreferredSize_NonEmptyText_ReturnsExpected(string text, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.NotEqual(Size.Empty, DataGridViewCell.MeasureTextPreferredSize(graphics, text, SystemFonts.DefaultFont, 0.2f, flags));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextPreferredSize_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => DataGridViewCell.MeasureTextPreferredSize(null, "text", SystemFonts.DefaultFont, 0.2f, TextFormatFlags.Default));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextPreferredSize_NullFont_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentNullException>("font", () => DataGridViewCell.MeasureTextPreferredSize(graphics, "text", null, 0.2f, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void DataGridViewCell_MeasureTextPreferredSize_InvalidMaxHeight_ThrowsArgumentOutOfRangeException(float maxRatio)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("maxRatio", () => DataGridViewCell.MeasureTextPreferredSize(graphics, "text", SystemFonts.DefaultFont, maxRatio, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData((TextFormatFlags)(-1))]
-    public void DataGridViewCell_MeasureTextPreferredSize_InvalidFlags_ThrowsInvalidEnumArgumentException(TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<InvalidEnumArgumentException>("flags", () => DataGridViewCell.MeasureTextPreferredSize(graphics, "text", SystemFonts.DefaultFont, 0.2f, flags));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DataGridViewCell_MeasureTextSize_NullOrEmptyText_ReturnsExpected(string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        {
-            Assert.Equal(Size.Empty, DataGridViewCell.MeasureTextSize(graphics, text, SystemFonts.DefaultFont, TextFormatFlags.Default));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData("a", TextFormatFlags.Default)]
-    [InlineData("truncate_me", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    public void DataGridViewCell_MeasureTextSize_NonEmptyText_ReturnsExpected(string text, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.NotEqual(Size.Empty, DataGridViewCell.MeasureTextSize(graphics, text, SystemFonts.DefaultFont, flags));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextSize_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => DataGridViewCell.MeasureTextSize(null, "text", SystemFonts.DefaultFont, TextFormatFlags.Default));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextSize_NullFont_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentNullException>("font", () => DataGridViewCell.MeasureTextSize(graphics, "text", null, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData((TextFormatFlags)(-1))]
-    public void DataGridViewCell_MeasureTextSize_InvalidFlags_ThrowsInvalidEnumArgumentException(TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<InvalidEnumArgumentException>("flags", () => DataGridViewCell.MeasureTextSize(graphics, "text", SystemFonts.DefaultFont, flags));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DataGridViewCell_MeasureTextWidth_NullOrEmptyText_ReturnsExpected(string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Equal(0, DataGridViewCell.MeasureTextWidth(graphics, text, SystemFonts.DefaultFont, 10, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData("a", TextFormatFlags.Default)]
-    [InlineData("truncate_me", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\nnew\rn\nnew", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default)]
-    [InlineData("truncate_me\r\truncate_me_again", TextFormatFlags.Default | TextFormatFlags.SingleLine)]
-    public void DataGridViewCell_MeasureTextWidth_NonEmptyText_ReturnsExpected(string text, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.NotEqual(0, DataGridViewCell.MeasureTextWidth(graphics, text, SystemFonts.DefaultFont, 10, flags));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextWidth_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => DataGridViewCell.MeasureTextWidth(null, "text", SystemFonts.DefaultFont, 10, TextFormatFlags.Default));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MeasureTextWidth_NullFont_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentNullException>("font", () => DataGridViewCell.MeasureTextWidth(graphics, "text", null, 10, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void DataGridViewCell_MeasureTextWidth_InvalidMaxHeight_ThrowsArgumentOutOfRangeException(int maxHeight)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentOutOfRangeException>("maxHeight", () => DataGridViewCell.MeasureTextWidth(graphics, "text", SystemFonts.DefaultFont, maxHeight, TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [InlineData((TextFormatFlags)(-1))]
-    public void DataGridViewCell_MeasureTextWidth_InvalidFlags_ThrowsInvalidEnumArgumentException(TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<InvalidEnumArgumentException>("flags", () => DataGridViewCell.MeasureTextWidth(graphics, "text", SystemFonts.DefaultFont, 10, flags));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MouseClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseClickUnsharesRow(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_MouseDoubleClickUnsharesRow_Invoke_ReturnsFalse()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseDoubleClickUnsharesRow(null));
-    }
-
-    public static IEnumerable<object[]> DataGridViewCellMouseEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_MouseDownUnsharesRow_Invoke_ReturnsFalse(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseDownUnsharesRow(e));
-    }
-
-    public static IEnumerable<object[]> DataGridViewCellMouseEventArgs_WithDataGridView_TestData()
-    {
-        foreach (bool enableHeadersVisualStyles in new bool[] { true, false })
-        {
-            yield return new object[] { enableHeadersVisualStyles, null };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_MouseDownUnsharesRow_InvokeWithDataGridView_ReturnsFalse(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.False(cell.MouseDownUnsharesRow(e));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_MouseEnterUnsharesRow_Invoke_ReturnsFalse(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseEnterUnsharesRow(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewCell_MouseEnterUnsharesRow_InvokeWithDataGridView_ReturnsFalse(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseEnterUnsharesRow(rowIndex));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_MouseLeaveUnsharesRow_Invoke_ReturnsFalse(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseLeaveUnsharesRow(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewCell_MouseLeaveUnsharesRow_InvokeWithDataGridView_ReturnsFalse(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseLeaveUnsharesRow(rowIndex));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_MouseMoveUnsharesRow_Invoke_ReturnsFalse(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseMoveUnsharesRow(e));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_MouseMoveUnsharesRow_InvokeWithDataGridView_ReturnsFalse(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseMoveUnsharesRow(e));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_MouseUpUnsharesRow_Invoke_ReturnsFalse(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.False(cell.MouseUpUnsharesRow(e));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_MouseUpUnsharesRow_InvokeWithDataGridView_ReturnsFalse(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseUpUnsharesRow(e));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnClick_Invoke_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnClick(null);
-    }
-
-    public static IEnumerable<object[]> DataGridViewCellEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellEventArgs(-1, -1) };
-        yield return new object[] { new DataGridViewCellEventArgs(0, -1) };
-        yield return new object[] { new DataGridViewCellEventArgs(-1, 0) };
-        yield return new object[] { new DataGridViewCellEventArgs(0, 0) };
-        yield return new object[] { new DataGridViewCellEventArgs(1, 0) };
-        yield return new object[] { new DataGridViewCellEventArgs(0, 1) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewCell_OnContentClick_Invoke_Nop(DataGridViewCellEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnContentClick(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewCell_OnContentDoubleClick_Invoke_Nop(DataGridViewCellEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnContentDoubleClick(e);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnDataGridViewChanged_InvokeWithoutStyle_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnDataGridViewChanged();
-        Assert.Equal(DataGridViewCellStyleScopes.Cell, cell.Style.Scope);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnDataGridViewChanged_InvokeWithStyle_SetsScopeToNone()
-    {
-        using var cell = new SubDataGridViewCell
-        {
-            Style = new DataGridViewCellStyle()
-        };
-        Assert.Equal(DataGridViewCellStyleScopes.Cell, cell.Style.Scope);
-        cell.OnDataGridViewChanged();
-        Assert.Equal(DataGridViewCellStyleScopes.None, cell.Style.Scope);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewCell_OnDoubleClick_Invoke_Nop(DataGridViewCellEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnDoubleClick(e);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnEnter_Invoke_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnEnter(-1, true);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void DataGridViewCell_OnKeyDown_Invoke_Nop(KeyEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnKeyDown(e, -1);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void DataGridViewCell_OnKeyPress_Invoke_Nop(KeyPressEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnKeyPress(e, -1);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void DataGridViewCell_OnKeyUp_Invoke_Nop(KeyEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnKeyUp(e, -1);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnLeave_Invoke_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnLeave(-1, true);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_OnMouseClick_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseClick(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_OnMouseClick_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseClick(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_OnMouseDoubleClick_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseDoubleClick(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_OnMouseDoubleClick_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseDoubleClick(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_OnMouseDown_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseDown(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_OnMouseDown_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseDown(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_OnMouseEnter_Invoke_Nop(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseEnter(rowIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewCell_OnMouseEnter_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseEnter(rowIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewCell_OnMouseLeave_Invoke_Nop(int rowIndex)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseLeave(rowIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewCell_OnMouseLeave_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseLeave(rowIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_OnMouseMove_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseMove(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_OnMouseMove_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseMove(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_TestData))]
-    public void DataGridViewCell_OnMouseUp_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.OnMouseUp(e);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellMouseEventArgs_WithDataGridView_TestData))]
-    public void DataGridViewCell_OnMouseUp_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        cell.OnMouseUp(e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Paint_Invoke_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        cell.Paint(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, null, null, null, null, null, DataGridViewPaintParts.All);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_Paint_InvokeWithGraphics_Nop()
-    {
-        using var cell = new SubDataGridViewCell();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        cell.Paint(graphics, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, null, null, null, null, null, DataGridViewPaintParts.All);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_PaintBorder_NoDataGridView_Nop()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var cell = new SubDataGridViewCell();
-        cell.PaintBorder(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_PaintBorder_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("graphics", () => cell.PaintBorder(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), new DataGridViewCellStyle(), new DataGridViewAdvancedBorderStyle()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_PaintBorder_NullCellStyle_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("cellStyle", () => cell.PaintBorder(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), null, new DataGridViewAdvancedBorderStyle()));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void DataGridViewCell_PaintErrorIcon_InvokeNullOrEmptyText_Success(string errorText)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var cell = new SubDataGridViewCell();
-        cell.PaintErrorIcon(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 20, 19), errorText);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewCell_PaintErrorIcon_NoDataGridView_Nop(string errorText)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var cell = new SubDataGridViewCell();
-        cell.PaintErrorIcon(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 20, 19), errorText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 100, "errorText")]
-    [InlineData(0, 100, "errorText")]
-    [InlineData(19, 100, "errorText")]
-    [InlineData(100, -1, "errorText")]
-    [InlineData(100, 0, "errorText")]
-    [InlineData(100, 18, "errorText")]
-    [InlineData(3, 4, "errorText")]
-    [InlineData(3, 4, "")]
-    [InlineData(3, 4, null)]
-    public void DataGridViewCell_PaintErrorIcon_NullGraphicsInvalidSize_ThrowsArgumentNullException(int cellValueBoundsWidth, int cellValueBoundsHeight, string errorText)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("graphics", () => cell.PaintErrorIcon(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, cellValueBoundsWidth, cellValueBoundsHeight), errorText));
-    }
-
-    public static IEnumerable<object[]> ParseFormattedValue_TestData()
-    {
-        // Simple assignment.
-        yield return new object[] { typeof(object), typeof(string), "value", new DataGridViewCellStyle(), null, null, "value" };
-        yield return new object[] { typeof(string), typeof(string), "value", new DataGridViewCellStyle(), null, null, "value" };
-        yield return new object[] { typeof(object), typeof(int), 1, new DataGridViewCellStyle(), null, null, 1 };
-        yield return new object[] { typeof(int), typeof(int), 1, new DataGridViewCellStyle(), null, null, 1 };
-
-        // Null.
-        yield return new object[] { typeof(object), typeof(DBNull), DBNull.Value, new DataGridViewCellStyle(), null, null, null };
-        yield return new object[] { typeof(string), typeof(string), "null", new DataGridViewCellStyle { NullValue = "null" }, null, null, null };
-        yield return new object[] { typeof(object), typeof(string), "null", new DataGridViewCellStyle { NullValue = "null" }, null, null, null };
-        yield return new object[] { typeof(object), typeof(string), "s", new DataGridViewCellStyle { NullValue = "null" }, null, null, "s" };
-        yield return new object[] { typeof(object), typeof(string), "longer", new DataGridViewCellStyle { NullValue = "null" }, null, null, "longer" };
-        yield return new object[] { typeof(object), typeof(string), "abcd", new DataGridViewCellStyle { NullValue = "null" }, null, null, "abcd" };
-        yield return new object[] { typeof(object), typeof(string), "null", new DataGridViewCellStyle { NullValue = "null" }, null, null, null };
-        yield return new object[] { typeof(int), typeof(int), 1, new DataGridViewCellStyle { NullValue = 1 }, null, null, DBNull.Value };
-        yield return new object[] { typeof(int), typeof(int), 2, new DataGridViewCellStyle { NullValue = 1 }, null, null, 2 };
-        yield return new object[] { typeof(string), typeof(string), "null", new DataGridViewCellStyle { NullValue = "null", DataSourceNullValue = "dbNull" }, null, null, "dbNull" };
-        yield return new object[] { typeof(int), typeof(int), 1, new DataGridViewCellStyle { NullValue = 1, DataSourceNullValue = "dbNull" }, null, null, "dbNull" };
-
-        // Converter.
-        yield return new object[] { typeof(string), typeof(int), 123, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter(), "123" };
-        yield return new object[] { typeof(string), typeof(int), 123, new DataGridViewCellStyle(), new Int32Converter(), null, "123" };
-        yield return new object[] { typeof(string), typeof(int), 123, new DataGridViewCellStyle(), null, new Int32Converter(), "123" };
-        yield return new object[] { typeof(string), typeof(int?), 123, new DataGridViewCellStyle(), null, null, "123" };
-        yield return new object[] { typeof(int), typeof(string), "123", new DataGridViewCellStyle(), null, null, 123 };
-        yield return new object[] { typeof(int), typeof(string), "123", new DataGridViewCellStyle { FormatProvider = CultureInfo.InvariantCulture }, null, null, 123 };
-        yield return new object[] { typeof(int), typeof(string), "123", new DataGridViewCellStyle { FormatProvider = new NumberFormatInfo() }, null, null, 123 };
-
-        // Converter can't convert.
-        yield return new object[] { typeof(string), typeof(int), 123, new DataGridViewCellStyle(), new Int16Converter(), null, "123" };
-        yield return new object[] { typeof(string), typeof(int), 123, new DataGridViewCellStyle(), null, new Int16Converter(), "123" };
-
-        // Convert.ChangeType.
-        yield return new object[] { typeof(short), typeof(int), 123, new DataGridViewCellStyle(), null, null, (short)123 };
-        yield return new object[] { typeof(short), typeof(int), 123, new DataGridViewCellStyle { FormatProvider = CultureInfo.InvariantCulture }, null, null, (short)123 };
-        yield return new object[] { typeof(short), typeof(int), 123, new DataGridViewCellStyle { FormatProvider = new NumberFormatInfo() }, null, null, (short)123 };
-        yield return new object[] { typeof(short?), typeof(int), 123, new DataGridViewCellStyle(), null, null, (short)123 };
-        yield return new object[] { typeof(short), typeof(int?), 123, new DataGridViewCellStyle(), null, null, (short)123 };
-
-        // Nullable.
-        yield return new object[] { typeof(int?), typeof(int?), 123, new DataGridViewCellStyle(), null, null, 123 };
-        yield return new object[] { typeof(int?), typeof(int), 123, new DataGridViewCellStyle(), null, null, 123 };
-        yield return new object[] { typeof(int), typeof(int?), 123, new DataGridViewCellStyle(), null, null, 123 };
-        yield return new object[] { typeof(string), typeof(int?), 123, new DataGridViewCellStyle(), null, null, "123" };
-
-        // CheckState.
-        yield return new object[] { typeof(bool), typeof(CheckState), CheckState.Indeterminate, new DataGridViewCellStyle(), null, null, DBNull.Value };
-        yield return new object[] { typeof(bool), typeof(CheckState), CheckState.Checked, new DataGridViewCellStyle(), null, null, true };
-        yield return new object[] { typeof(bool), typeof(CheckState), CheckState.Unchecked, new DataGridViewCellStyle(), null, null, false };
-        yield return new object[] { typeof(bool), typeof(CheckState), (CheckState)(CheckState.Unchecked - 1), new DataGridViewCellStyle(), null, null, false };
-        yield return new object[] { typeof(bool), typeof(CheckState), (CheckState)(CheckState.Indeterminate + 1), new DataGridViewCellStyle(), null, null, false };
-        yield return new object[] { typeof(CheckState), typeof(CheckState), CheckState.Checked, new DataGridViewCellStyle(), null, null, CheckState.Checked };
-        yield return new object[] { typeof(int), typeof(CheckState), CheckState.Checked, new DataGridViewCellStyle(), null, null, 1 };
-        yield return new object[] { typeof(int), typeof(CheckState), CheckState.Checked, new DataGridViewCellStyle(), new EnumConverter(typeof(CheckState)), null, 1 };
-        yield return new object[] { typeof(int), typeof(CheckState), CheckState.Checked, new DataGridViewCellStyle(), null, new EnumConverter(typeof(CheckState)), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ParseFormattedValue_TestData))]
-    public void DataGridViewCell_ParseFormattedValue_Invoke_ReturnsExpected(Type valueType, Type formattedValueType, object formattedValue, DataGridViewCellStyle cellStyle, TypeConverter formattedValueTypeConverter, TypeConverter valueTypeConverter, object expected)
-    {
-        using var cell = new CustomFormattedValueType
-        {
-            ValueType = valueType,
-            FormattedValueTypeResult = formattedValueType
-        };
-        Assert.Equal(expected, cell.ParseFormattedValue(formattedValue, cellStyle, formattedValueTypeConverter, valueTypeConverter));
-
-        // Call same.
-        Assert.Equal(expected, cell.ParseFormattedValue(formattedValue, cellStyle, formattedValueTypeConverter, valueTypeConverter));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ParseFormattedValue_NullCellStyle_ThrowsArgumentNullException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<ArgumentNullException>("cellStyle", () => cell.ParseFormattedValue(1, null, new Int32Converter(), new Int32Converter()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ParseFormattedValue_NullValueTypeAndFormattedValueType_ThrowsFormatException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<FormatException>(() => cell.ParseFormattedValue(1, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ParseFormattedValue_NullValueType_ThrowsFormatException()
-    {
-        using var cell = new CustomFormattedValueType { FormattedValueTypeResult = typeof(int) };
-        Assert.Throws<FormatException>(() => cell.ParseFormattedValue(1, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ParseFormattedValue_NullFormattedValueType_ThrowsFormatException()
-    {
-        using var cell = new CustomFormattedValueType { ValueType = typeof(int) };
-        Assert.Throws<FormatException>(() => cell.ParseFormattedValue(1, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter()));
-    }
-
-    public static IEnumerable<object[]> ParseFormattedValue_CantConvert_TestData()
-    {
-        yield return new object[] { typeof(DataGridViewCellTests), typeof(int), 123, new DataGridViewCellStyle(), null, null };
-        yield return new object[] { typeof(DataGridViewCell), typeof(DataGridViewCellTests), new DataGridViewCellTests(), new DataGridViewCellStyle(), null, null };
-        yield return new object[] { typeof(int), typeof(string), "Invalid", new DataGridViewCellStyle(), null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ParseFormattedValue_CantConvert_TestData))]
-    public void DataGridViewCell_ParseFormattedValue_CantConvert_ThrowsFormatException(Type valueType, Type formattedValueType, object formattedValue, DataGridViewCellStyle cellStyle, TypeConverter formattedValueTypeConverter, TypeConverter valueTypeConverter)
-    {
-        using var cell = new CustomFormattedValueType
-        {
-            ValueType = valueType,
-            FormattedValueTypeResult = formattedValueType
-        };
-        Assert.Throws<FormatException>(() => cell.ParseFormattedValue(formattedValue, cellStyle, formattedValueTypeConverter, valueTypeConverter));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    public void DataGridViewCell_ParseFormattedValue_InvalidFormattedValue_ThrowsArgumentException(object formattedValue)
-    {
-        using var cell = new CustomFormattedValueType
-        {
-            ValueType = typeof(int),
-            FormattedValueTypeResult = typeof(string)
-        };
-        Assert.Throws<ArgumentException>("formattedValue", () => cell.ParseFormattedValue(formattedValue, new DataGridViewCellStyle(), new Int32Converter(), new Int32Converter()));
-    }
-
-    private class CustomFormattedValueType : DataGridViewCell
-    {
-        public Type FormattedValueTypeResult { get; set; }
-
-        public override Type FormattedValueType => FormattedValueTypeResult;
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_PositionEditingDataGridViewCell_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.PositionEditingControl(true, true, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), new DataGridViewCellStyle(), true, true, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_PositionEditingPanel_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Throws<InvalidOperationException>(() => cell.PositionEditingPanel(new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), new DataGridViewCellStyle(), true, true, true, true));
-    }
-
-    public static IEnumerable<object[]> SetValue_TestData()
-    {
-        yield return new object[] { -2, null };
-        yield return new object[] { -2, "value" };
-        yield return new object[] { -1, null };
-        yield return new object[] { -1, "value" };
-        yield return new object[] { 0, null };
-        yield return new object[] { 0, "value" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetValue_TestData))]
-    public void DataGridViewCell_SetValue_Invoke_GetReturnsExpected(int rowIndex, object value)
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.True(cell.SetValue(rowIndex, value));
-        Assert.Equal(value, cell.GetValue(rowIndex));
-
-        // Set same.
-        Assert.True(cell.SetValue(rowIndex, value));
-        Assert.Equal(value, cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetValue_TestData))]
-    public void DataGridViewCell_SetValue_InvokeWithRow_GetReturnsExpected(int rowIndex, object value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-
-        Assert.True(cell.SetValue(rowIndex, value));
-        Assert.Equal(value, cell.GetValue(rowIndex));
-
-        // Set same.
-        Assert.True(cell.SetValue(rowIndex, value));
-        Assert.Equal(value, cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("value")]
-    public void DataGridViewCell_SetValue_InvokeWithColumn_GetReturnsExpected(object value)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        Assert.True(cell.SetValue(-1, value));
-        Assert.Equal(value, cell.GetValue(-1));
-
-        // Set same.
-        Assert.True(cell.SetValue(-1, value));
-        Assert.Equal(value, cell.GetValue(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("value")]
-    public void DataGridViewCell_SetValue_InvokeWithDataGridView_GetReturnsExpected(object value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-
-        Assert.True(cell.SetValue(0, value));
-        Assert.Equal(value, cell.GetValue(0));
-
-        // Set same.
-        Assert.True(cell.SetValue(0, value));
-        Assert.Equal(value, cell.GetValue(0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("value")]
-    public void DataGridViewCell_SetValue_InvokeShared_GetReturnsExpected(object value)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-
-        Assert.True(cell.SetValue(0, value));
-        Assert.Equal(value, cell.GetValue(0));
-
-        // Set same.
-        Assert.True(cell.SetValue(0, value));
-        Assert.Equal(value, cell.GetValue(0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewCell_SetValue_InvalidRowIndexWithColumn_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.SetValue(rowIndex, "value"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_SetValue_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.SetValue(rowIndex, "value"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewCell_SetValue_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewCell cell = (SubDataGridViewCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.SetValue(rowIndex, "value"));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToString_Invoke_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewCell();
-        Assert.Equal("DataGridViewCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToString_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal("DataGridViewCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToString_InvokeWithColumn_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal("DataGridViewColumnHeaderCell { ColumnIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_ToString_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal("DataGridViewCell { ColumnIndex=0, RowIndex=0 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCell_OnContentClick_InvokeInternalRaiseAutomationNotification()
-    {
-        using var cellTemplate = new SubDataGridViewCheckBoxCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-
-        using var dataGridView = new DataGridView();
-        dataGridView.Columns.Add(column);
-        SubDataGridViewCheckBoxCell cell = (SubDataGridViewCheckBoxCell)dataGridView.Rows[0].Cells[0];
-        var mockAccessibleObject = new Mock<AccessibleObject>(MockBehavior.Strict);
-        mockAccessibleObject
-            .Setup(a => a.InternalRaiseAutomationNotification(
-                It.IsAny<AutomationNotificationKind>(),
-                It.IsAny<AutomationNotificationProcessing>(),
-                It.IsAny<string>()))
-            .Returns(true)
-            .Verifiable();
-
-        var cellName = "TestCellName";
-
-        mockAccessibleObject
-            .Setup(a => a.Name)
-            .Returns(cellName);
-
-        mockAccessibleObject
-            .Setup(a => a.DoDefaultAction()).CallBase();
-
-        cell.MockAccessibleObject = mockAccessibleObject.Object;
-        cell.Value = false;
-        dataGridView.CurrentCell = cell;
-
-        // Enforce accessible object creation
-        _ = dataGridView.AccessibilityObject;
-
-        // Checkbox is checked
-        dataGridView.BeginEdit(false);
-        cell.MouseClick(new DataGridViewCellMouseEventArgs(0, 0, 10, 10, new MouseEventArgs(MouseButtons.Left, 1, 10, 10, 0)));
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(AutomationNotificationKind.Other,
-            AutomationNotificationProcessing.MostRecent,
-            string.Format(SR.DataGridViewCheckBoxCellCheckedStateDescription, cellName)),
-            Times.Once());
-
-        // Checkbox is unchecked
-        dataGridView.BeginEdit(false);
-        cell.MouseClick(new DataGridViewCellMouseEventArgs(0, 0, 10, 10, new MouseEventArgs(MouseButtons.Left, 1, 10, 10, 0)));
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(AutomationNotificationKind.Other,
-            AutomationNotificationProcessing.MostRecent,
-            string.Format(SR.DataGridViewCheckBoxCellUncheckedStateDescription, cellName)),
-            Times.Once());
-
-        // Checkbox is checked
-        dataGridView.BeginEdit(false);
-        cell.OnKeyClick(new KeyEventArgs(Keys.Space), 0);
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(AutomationNotificationKind.Other,
-            AutomationNotificationProcessing.MostRecent,
-            string.Format(SR.DataGridViewCheckBoxCellCheckedStateDescription, cellName)),
-            Times.Exactly(2));
-
-        // Checkbox is unchecked
-        dataGridView.BeginEdit(false);
-        cell.OnKeyClick(new KeyEventArgs(Keys.Space), 0);
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(AutomationNotificationKind.Other,
-            AutomationNotificationProcessing.MostRecent,
-            string.Format(SR.DataGridViewCheckBoxCellUncheckedStateDescription, cellName)),
-            Times.Exactly(2));
-    }
-
-    private class SubDataGridViewCheckBoxCell : DataGridViewCheckBoxCell
-    {
-        public SubDataGridViewCheckBoxCell()
-        {
-        }
-
-        public AccessibleObject MockAccessibleObject;
-
-        protected override AccessibleObject CreateAccessibilityInstance() => MockAccessibleObject;
-
-        public void MouseClick(DataGridViewCellMouseEventArgs e) => base.OnMouseUpInternal(e);
-
-        public void OnKeyClick(KeyEventArgs e, int rowIndex) => base.OnKeyUp(e, rowIndex);
-    }
-
-    private class SubDataGridViewColumnHeaderCell : DataGridViewColumnHeaderCell
-    {
-        public new Rectangle BorderWidths(DataGridViewAdvancedBorderStyle advancedBorderStyle) => base.BorderWidths(advancedBorderStyle);
-
-        public new object GetClipboardContent(int rowIndex, bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format)
-        {
-            return base.GetClipboardContent(rowIndex, firstCell, lastCell, inFirstRow, inLastRow, format);
-        }
-
-        public new string GetErrorText(int rowIndex) => base.GetErrorText(rowIndex);
-
-        public new object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context)
-        {
-            return base.GetFormattedValue(value, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context);
-        }
-
-        public new Size GetSize(int rowIndex) => base.GetSize(rowIndex);
-
-        public new object GetValue(int rowIndex) => base.GetValue(rowIndex);
-
-        public new bool SetValue(int rowIndex, object value) => base.SetValue(rowIndex, value);
-    }
-
-    private class CustomStateDataGridViewCell : DataGridViewCell
-    {
-        public DataGridViewElementStates StateResult { get; set; }
-
-        public override DataGridViewElementStates State => StateResult;
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-        public new Rectangle BorderWidths(DataGridViewAdvancedBorderStyle advancedBorderStyle) => base.BorderWidths(advancedBorderStyle);
-
-        public new bool ClickUnsharesRow(DataGridViewCellEventArgs e) => base.ClickUnsharesRow(e);
-
-        public new bool ContentClickUnsharesRow(DataGridViewCellEventArgs e) => base.ContentClickUnsharesRow(e);
-
-        public new bool ContentDoubleClickUnsharesRow(DataGridViewCellEventArgs e) => base.ContentDoubleClickUnsharesRow(e);
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new bool DoubleClickUnsharesRow(DataGridViewCellEventArgs e) => base.DoubleClickUnsharesRow(e);
-
-        public new bool EnterUnsharesRow(int rowIndex, bool throughMouseClick) => base.EnterUnsharesRow(rowIndex, throughMouseClick);
-
-        public new object GetClipboardContent(int rowIndex, bool firstCell, bool lastCell, bool inFirstRow, bool inLastRow, string format)
-        {
-            return base.GetClipboardContent(rowIndex, firstCell, lastCell, inFirstRow, inLastRow, format);
-        }
-
-        public new Rectangle GetContentBounds(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex) => base.GetContentBounds(graphics, cellStyle, rowIndex);
-
-        public new Rectangle GetErrorIconBounds(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex) => base.GetErrorIconBounds(graphics, cellStyle, rowIndex);
-
-        public new string GetErrorText(int rowIndex) => base.GetErrorText(rowIndex);
-
-        public new object GetFormattedValue(object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context)
-        {
-            return base.GetFormattedValue(value, rowIndex, ref cellStyle, valueTypeConverter, formattedValueTypeConverter, context);
-        }
-
-        public new Size GetPreferredSize(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex, Size constraintSize) => base.GetPreferredSize(graphics, cellStyle, rowIndex, constraintSize);
-
-        public new Size GetSize(int rowIndex) => base.GetSize(rowIndex);
-
-        public new object GetValue(int rowIndex) => base.GetValue(rowIndex);
-
-        public new bool KeyDownUnsharesRow(KeyEventArgs e, int rowIndex) => base.KeyDownUnsharesRow(e, rowIndex);
-
-        public new bool KeyEntersEditMode(KeyEventArgs e) => base.KeyEntersEditMode(e);
-
-        public new bool KeyPressUnsharesRow(KeyPressEventArgs e, int rowIndex) => base.KeyPressUnsharesRow(e, rowIndex);
-
-        public new bool KeyUpUnsharesRow(KeyEventArgs e, int rowIndex) => base.KeyUpUnsharesRow(e, rowIndex);
-
-        public new bool LeaveUnsharesRow(int rowIndex, bool throughMouseClick) => base.LeaveUnsharesRow(rowIndex, throughMouseClick);
-
-        public new bool MouseClickUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseClickUnsharesRow(e);
-
-        public new bool MouseDoubleClickUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseDoubleClickUnsharesRow(e);
-
-        public new bool MouseDownUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseDownUnsharesRow(e);
-
-        public new bool MouseEnterUnsharesRow(int rowIndex) => base.MouseEnterUnsharesRow(rowIndex);
-
-        public new bool MouseLeaveUnsharesRow(int rowIndex) => base.MouseLeaveUnsharesRow(rowIndex);
-
-        public new bool MouseMoveUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseMoveUnsharesRow(e);
-
-        public new bool MouseUpUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseUpUnsharesRow(e);
-
-        public new void OnClick(DataGridViewCellEventArgs e) => base.OnClick(e);
-
-        public new void OnContentClick(DataGridViewCellEventArgs e) => base.OnContentClick(e);
-
-        public new void OnContentDoubleClick(DataGridViewCellEventArgs e) => base.OnContentDoubleClick(e);
-
-        public new void OnDataGridViewChanged() => base.OnDataGridViewChanged();
-
-        public new void OnDoubleClick(DataGridViewCellEventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnEnter(int rowIndex, bool throughMouseClick) => base.OnEnter(rowIndex, throughMouseClick);
-
-        public new void OnKeyDown(KeyEventArgs e, int rowIndex) => base.OnKeyDown(e, rowIndex);
-
-        public new void OnKeyPress(KeyPressEventArgs e, int rowIndex) => base.OnKeyPress(e, rowIndex);
-
-        public new void OnKeyUp(KeyEventArgs e, int rowIndex) => base.OnKeyUp(e, rowIndex);
-
-        public new void OnLeave(int rowIndex, bool throughMouseClick) => base.OnLeave(rowIndex, throughMouseClick);
-
-        public new void OnMouseClick(DataGridViewCellMouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(DataGridViewCellMouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(DataGridViewCellMouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(int rowIndex) => base.OnMouseEnter(rowIndex);
-
-        public new void OnMouseLeave(int rowIndex) => base.OnMouseLeave(rowIndex);
-
-        public new void OnMouseMove(DataGridViewCellMouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(DataGridViewCellMouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void Paint(Graphics graphics, Rectangle clipBounds, Rectangle cellBounds, int rowIndex, DataGridViewElementStates cellState, object value, object formattedValue, string errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts)
-        {
-            base.Paint(graphics, clipBounds, cellBounds, rowIndex, cellState, value, formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);
-        }
-
-        public new void PaintBorder(Graphics graphics, Rectangle clipBounds, Rectangle bounds, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle)
-        {
-            base.PaintBorder(graphics, clipBounds, bounds, cellStyle, advancedBorderStyle);
-        }
-
-        public new void PaintErrorIcon(Graphics graphics, Rectangle clipBounds, Rectangle cellValueBounds, string errorText) => base.PaintErrorIcon(graphics, clipBounds, cellValueBounds, errorText);
-
-        public new bool SetValue(int rowIndex, object value) => base.SetValue(rowIndex, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellValueEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellValueEventArgsTests.cs
deleted file mode 100644
index be22dbc3332..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCellValueEventArgsTests.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewCellValueEventArgsTests
-{
-    [Theory]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int columnIndex, int rowIndex)
-    {
-        var e = new DataGridViewCellValueEventArgs(columnIndex, rowIndex);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Null(e.Value);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException(int columnIndex)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewCellValueEventArgs(columnIndex, 0));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewCellValueEventArgs(0, rowIndex));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData(1)]
-    public void Value_Set_GetReturnsExpected(object value)
-    {
-        var e = new DataGridViewCellValueEventArgs(1, 2)
-        {
-            Value = value
-        };
-        Assert.Equal(value, e.Value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCheckBoxCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCheckBoxCellAccessibleObjectTests.cs
deleted file mode 100644
index 8b3f9b2c2cd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewCheckBoxCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,301 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewCheckBoxCellAccessibleObjectTests : DataGridViewCheckBoxCell
-{
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    public static IEnumerable<object[]> DataGridViewCheckBoxCellAccessibleObject_ToggleState_TestData()
-    {
-        yield return new object[] { false, (int)UiaCore.ToggleState.Off };
-        yield return new object[] { true, (int)UiaCore.ToggleState.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCheckBoxCellAccessibleObject_ToggleState_TestData))]
-    public void DataGridViewCheckBoxCellAccessibleObject_ToggleState_ReturnsExpected(bool isChecked, int expected)
-    {
-        using DataGridView control = new();
-        control.Columns.Add(new DataGridViewCheckBoxColumn());
-
-        var cell = control.Rows[0].Cells[0];
-        // Create control to check cell if it is needed.
-        control.CreateControl();
-
-        var accessibleObject = (DataGridViewCheckBoxCellAccessibleObject)cell.AccessibilityObject;
-        if (isChecked)
-        {
-            // Make sure that toggle state is off as a default case.
-            Assert.Equal(UiaCore.ToggleState.Off, accessibleObject.ToggleState);
-            // Check it.
-            accessibleObject.DoDefaultAction();
-        }
-
-        Assert.Equal((UiaCore.ToggleState)expected, accessibleObject.ToggleState);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-        Assert.Equal(UiaCore.UIA.CheckBoxControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_IsTogglePatternAvailablePropertyId_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsTogglePatternAvailablePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add(new DataGridViewCheckBoxColumn());
-        var cell = control.Rows[0].Cells[0];
-        control.CreateControl();
-        var accessibleObject = (DataGridViewCheckBoxCellAccessibleObject)cell.AccessibilityObject;
-
-        Assert.False(bool.Parse(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId).ToString()));
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.True(bool.Parse(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId).ToString()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TogglePatternId)]
-    public void DataGridViewCheckBoxCellAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewCheckBoxCellAccessibleObject(null);
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_DefaultAction_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(()
-          => new DataGridViewCheckBoxCellAccessibleObject(null).DefaultAction);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_DefaultAction_ReturnsExpected_IfOwnerIsReadOnly()
-    {
-        using DataGridViewCheckBoxCell cell = new();
-        using DataGridViewRow row = new();
-        row.Cells.Add(cell);
-        cell.ReadOnly = true;
-
-        Assert.True(cell.ReadOnly);
-        Assert.Equal(string.Empty, cell.AccessibilityObject.DefaultAction);
-    }
-
-    public static IEnumerable<object[]> DataGridViewCheckBoxCellAccessibleObject_DefaultAction_TestData()
-    {
-        yield return new object[] { false, SR.DataGridView_AccCheckBoxCellDefaultActionCheck };
-        yield return new object[] { true, SR.DataGridView_AccCheckBoxCellDefaultActionUncheck };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCheckBoxCellAccessibleObject_DefaultAction_TestData))]
-    public void DataGridViewCheckBoxCellAccessibleObject_DefaultAction_ReturnsExpected(bool isChecked, string expected)
-    {
-        using DataGridView control = new();
-        control.Columns.Add(new DataGridViewCheckBoxColumn());
-        control.Rows.Add(new DataGridViewRow());
-        var cell = control.Rows[0].Cells[0];
-        // Create control to check cell if it is needed.
-        control.CreateControl();
-
-        var accessibleObject = (DataGridViewCheckBoxCellAccessibleObject)cell.AccessibilityObject;
-        if (isChecked)
-        {
-            // Make sure that default action is check as a default case.
-            Assert.Equal(SR.DataGridView_AccCheckBoxCellDefaultActionCheck, accessibleObject.DefaultAction);
-            // Check it.
-            accessibleObject.DoDefaultAction();
-        }
-
-        Assert.Equal(expected, accessibleObject.DefaultAction);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCheckBoxCellAccessibleObject_DefaultAction_TestData))]
-    public void DataGridViewCheckBoxCellAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected(bool isChecked, string expected)
-    {
-        using DataGridView control = new();
-        control.Columns.Add(new DataGridViewCheckBoxColumn());
-        control.Rows.Add(new DataGridViewRow());
-        var cell = control.Rows[0].Cells[0];
-        // Create control to check cell if it is needed.
-        control.CreateControl();
-
-        var accessibleObject = (DataGridViewCheckBoxCellAccessibleObject)cell.AccessibilityObject;
-        if (isChecked)
-        {
-            // Make sure that default action is check as a default case.
-            Assert.Equal(SR.DataGridView_AccCheckBoxCellDefaultActionCheck, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-            // Check it.
-            accessibleObject.DoDefaultAction();
-        }
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_ToggleState_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(()
-          => new DataGridViewCheckBoxCellAccessibleObject(null).ToggleState);
-    }
-
-    public static IEnumerable<object[]> DataGridViewCheckBoxCellAccessibleObject_DoDefaultAction_TestData()
-    {
-        yield return new object[] { false, true, (int)UiaCore.ToggleState.Off };
-        yield return new object[] { false, false, (int)UiaCore.ToggleState.Off };
-        yield return new object[] { true, true, (int)UiaCore.ToggleState.Off };
-        yield return new object[] { true, false, (int)UiaCore.ToggleState.On };
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_DoDefaultAction_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(()
-          => new DataGridViewCheckBoxCellAccessibleObject(null).DoDefaultAction());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_DoDefaultAction_ThrowsException_IfRowIndexIsIncorrect()
-    {
-        using DataGridViewCheckBoxCell cell = new();
-
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Throws<InvalidOperationException>(() => cell.AccessibilityObject.DoDefaultAction());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCheckBoxCellAccessibleObject_DoDefaultAction_TestData))]
-    public void DataGridViewCheckBoxCellAccessibleObject_DoDefaultAction_WorksExpected(bool createControl, bool isChecked, int expected)
-    {
-        using DataGridView control = new();
-        control.Columns.Add(new DataGridViewCheckBoxColumn());
-        control.Rows.Add(new DataGridViewRow());
-        var cell = control.Rows[0].Cells[0];
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        var accessibleObject = (DataGridViewCheckBoxCellAccessibleObject)cell.AccessibilityObject;
-        if (isChecked)
-        {
-            // Make sure that toogle state is off as a default case.
-            Assert.Equal(UiaCore.ToggleState.Off, accessibleObject.ToggleState);
-            // Check it.
-            accessibleObject.DoDefaultAction();
-
-            if (createControl)
-            {
-                // Make sure that toogle state has been changed.
-                Assert.Equal(UiaCore.ToggleState.On, accessibleObject.ToggleState);
-            }
-            else
-            {
-                // Make sure that nothing changes.
-                Assert.Equal(UiaCore.ToggleState.Off, accessibleObject.ToggleState);
-            }
-        }
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.Equal((UiaCore.ToggleState)expected, accessibleObject.ToggleState);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    // Unit test for https://github.com/dotnet/winforms/issues/9256
-    [WinFormsFact]
-    public void DataGridViewCheckBoxCellAccessibleObject_ToggleStateIndeterminate_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        using DataGridViewCheckBoxColumn checkBoxColumn = new();
-        checkBoxColumn.ThreeState = true;
-        dataGridView.Columns.Add(checkBoxColumn);
-        using DataGridViewRow row = new();
-        dataGridView.Rows.Add(row);
-        dataGridView.CreateControl();
-
-        DataGridViewCell cell = dataGridView.Rows[0].Cells[0];
-
-        var checkBoxAccessibleObject = cell.AccessibilityObject;
-
-        Assert.Equal(UiaCore.ToggleState.Indeterminate, checkBoxAccessibleObject.ToggleState);
-        checkBoxAccessibleObject.DoDefaultAction();
-        Assert.Equal(UiaCore.ToggleState.Off, checkBoxAccessibleObject.ToggleState);
-        checkBoxAccessibleObject.DoDefaultAction();
-        Assert.Equal(UiaCore.ToggleState.On, checkBoxAccessibleObject.ToggleState);
-        checkBoxAccessibleObject.DoDefaultAction();
-        Assert.Equal(UiaCore.ToggleState.Indeterminate, checkBoxAccessibleObject.ToggleState);
-        checkBoxAccessibleObject.DoDefaultAction();
-        Assert.Equal(UiaCore.ToggleState.Off, checkBoxAccessibleObject.ToggleState);
-        checkBoxAccessibleObject.DoDefaultAction();
-        Assert.Equal(UiaCore.ToggleState.On, checkBoxAccessibleObject.ToggleState);
-
-        dataGridView.Rows.Add(true);
-        Assert.Equal(UiaCore.ToggleState.On, dataGridView.Rows[1].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add(false);
-        Assert.Equal(UiaCore.ToggleState.Off, dataGridView.Rows[2].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add(CheckState.Indeterminate);
-        Assert.Equal(UiaCore.ToggleState.Indeterminate, dataGridView.Rows[3].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add(CheckState.Checked);
-        Assert.Equal(UiaCore.ToggleState.On, dataGridView.Rows[4].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add(CheckState.Unchecked);
-        Assert.Equal(UiaCore.ToggleState.Off, dataGridView.Rows[5].Cells[0].AccessibilityObject.ToggleState);
-
-        checkBoxColumn.TrueValue = "on";
-        checkBoxColumn.FalseValue = "off";
-        checkBoxColumn.IndeterminateValue = "not set";
-
-        dataGridView.Rows.Add("on");
-        Assert.Equal(UiaCore.ToggleState.On, dataGridView.Rows[4].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add("off");
-        Assert.Equal(UiaCore.ToggleState.Off, dataGridView.Rows[5].Cells[0].AccessibilityObject.ToggleState);
-
-        dataGridView.Rows.Add("not set");
-        Assert.Equal(UiaCore.ToggleState.Indeterminate, dataGridView.Rows[3].Cells[0].AccessibilityObject.ToggleState);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnCollectionTests.cs
deleted file mode 100644
index 5485d0ed9b0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnCollectionTests.cs
+++ /dev/null
@@ -1,573 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewColumnCollectionTests
-{
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Ctor_DataGridView()
-    {
-        using var control = new DataGridView();
-        var collection = new SubDataGridViewColumnCollection(control);
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.Same(control, collection.DataGridView);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.True(collection.List is ArrayList);
-        Assert.Empty(collection.List);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        using var control = new DataGridView();
-#if false
-        Assert.Throws<ArgumentNullException>("control", () => new SubDataGridViewColumnCollection(null));
-#endif
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_Invoke_Success()
-    {
-        using var control = new DataGridView();
-        var collection = new DataGridViewColumnCollection(control);
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        using var column2 = new DataGridViewColumn();
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(1, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_InvokeColumns_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell());
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(1, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.CellSelect, DataGridViewColumnSortMode.Automatic)]
-    [InlineData(DataGridViewSelectionMode.CellSelect, DataGridViewColumnSortMode.NotSortable)]
-    [InlineData(DataGridViewSelectionMode.CellSelect, DataGridViewColumnSortMode.Programmatic)]
-    [InlineData(DataGridViewSelectionMode.ColumnHeaderSelect, DataGridViewColumnSortMode.NotSortable)]
-    [InlineData(DataGridViewSelectionMode.ColumnHeaderSelect, DataGridViewColumnSortMode.Programmatic)]
-    [InlineData(DataGridViewSelectionMode.FullColumnSelect, DataGridViewColumnSortMode.NotSortable)]
-    [InlineData(DataGridViewSelectionMode.FullColumnSelect, DataGridViewColumnSortMode.Programmatic)]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect, DataGridViewColumnSortMode.Automatic)]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect, DataGridViewColumnSortMode.NotSortable)]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect, DataGridViewColumnSortMode.Programmatic)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect, DataGridViewColumnSortMode.Automatic)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect, DataGridViewColumnSortMode.NotSortable)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect, DataGridViewColumnSortMode.Programmatic)]
-    public void DataGridViewColumnCollection_Add_CustomColumnSortModeAndSelectionMode_Success(DataGridViewSelectionMode selectionMode, DataGridViewColumnSortMode sortMode)
-    {
-        using var control = new DataGridView
-        {
-            SelectionMode = selectionMode
-        };
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            SortMode = sortMode
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            SortMode = sortMode
-        };
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(1, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Add_CustomAutoSizeMode_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnsMode columnsAutoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnsMode)))
-        {
-            foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-            {
-                bool canBeFrozen = autoSizeMode != DataGridViewAutoSizeColumnMode.Fill && !(columnsAutoSizeMode == DataGridViewAutoSizeColumnsMode.Fill && autoSizeMode == DataGridViewAutoSizeColumnMode.NotSet);
-                if (canBeFrozen)
-                {
-                    yield return new object[] { true, true, true, columnsAutoSizeMode, autoSizeMode };
-                }
-
-                yield return new object[] { true, true, false, columnsAutoSizeMode, autoSizeMode };
-                yield return new object[] { true, false, true, columnsAutoSizeMode, autoSizeMode };
-                yield return new object[] { true, false, false, columnsAutoSizeMode, autoSizeMode };
-                if (autoSizeMode != DataGridViewAutoSizeColumnMode.ColumnHeader && !(columnsAutoSizeMode == DataGridViewAutoSizeColumnsMode.ColumnHeader && autoSizeMode == DataGridViewAutoSizeColumnMode.NotSet))
-                {
-                    if (canBeFrozen)
-                    {
-                        yield return new object[] { false, true, true, columnsAutoSizeMode, autoSizeMode };
-                    }
-
-                    yield return new object[] { false, true, false, columnsAutoSizeMode, autoSizeMode };
-                }
-
-                yield return new object[] { false, false, true, columnsAutoSizeMode, autoSizeMode };
-                yield return new object[] { false, false, false, columnsAutoSizeMode, autoSizeMode };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_CustomAutoSizeMode_TestData))]
-    public void DataGridViewColumnCollection_Add_CustomAutoSizeMode_Success(bool columnHeadersVisible, bool visible, bool frozen, DataGridViewAutoSizeColumnsMode columnsAutoSizeMode, DataGridViewAutoSizeColumnMode autoSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = columnsAutoSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            AutoSizeMode = autoSizeMode,
-            Frozen = frozen,
-            Visible = visible
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            AutoSizeMode = autoSizeMode,
-            Frozen = frozen,
-            Visible = visible
-        };
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(1, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_InvokeFrozen_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true
-        };
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(1, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void DataGridViewColumnCollection_Add_CustomDisplayIndex_Success(int displayIndex)
-    {
-        using var control = new DataGridView();
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            DisplayIndex = displayIndex
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            DisplayIndex = 0
-        };
-        using var column3 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            DisplayIndex = 1
-        };
-
-        // Add one.
-        collection.Add(column1);
-        Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(0, column1.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column2);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(1, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(0, column2.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        collection.Add(column3);
-        Assert.Equal(new DataGridViewColumn[] { column1, column2, column3 }, collection.Cast<DataGridViewColumn>());
-        Assert.Same(control, column1.DataGridView);
-        Assert.Equal(0, column1.Index);
-        Assert.Equal(2, column1.DisplayIndex);
-        Assert.Same(control, column2.DataGridView);
-        Assert.Equal(1, column2.Index);
-        Assert.Equal(0, column2.DisplayIndex);
-        Assert.Same(control, column3.DataGridView);
-        Assert.Equal(2, column3.Index);
-        Assert.Equal(1, column3.DisplayIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_AddWithHeaderCell_Invoke_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewColumnCollection collection = control.Columns;
-        using var headerCell = new DataGridViewColumnHeaderCell();
-        using var column = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            HeaderCell = headerCell
-        };
-
-        // Add one.
-        collection.Add(column);
-        Assert.Same(control, column.DataGridView);
-        Assert.Equal(0, column.Index);
-        Assert.Equal(0, column.DisplayIndex);
-        Assert.Same(control, headerCell.DataGridView);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_NullDataGridViewColumn_ThrowsArgumentNullException()
-    {
-        using var control = new DataGridView();
-        var collection = new DataGridViewColumnCollection(control);
-        Assert.Throws<ArgumentNullException>("dataGridViewColumn", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_NoDimensionChangeAllowed_ThrowsInvalidOperationException()
-    {
-        using var control = new SubDataGridView();
-        var collection = new DataGridViewColumnCollection(control);
-        int callCount = 0;
-        control.RowValidating += (sender, e) =>
-        {
-            var column = new DataGridViewColumn(new SubDataGridViewCell());
-            Assert.Throws<InvalidOperationException>(() => collection.Add(null));
-            Assert.Throws<InvalidOperationException>(() => collection.Add(column));
-            callCount++;
-        };
-        control.OnRowValidating(null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_InDisplayIndexAdjustment_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        var collection = new DataGridViewColumnCollection(control);
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell());
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-
-        int callCount = 0;
-        control.ColumnDisplayIndexChanged += (sender, e) =>
-        {
-            var column = new DataGridViewColumn(new SubDataGridViewCell());
-            Assert.Throws<InvalidOperationException>(() => collection.Add(null));
-            Assert.Throws<InvalidOperationException>(() => collection.Add(column));
-            callCount++;
-        };
-        column1.DisplayIndex = 1;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_ColumnHasDataGridView_ThrowsInvalidOperationException()
-    {
-        using var control1 = new DataGridView();
-        using var control2 = new DataGridView();
-        var collection = new DataGridViewColumnCollection(control1);
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell());
-        control1.Columns.Add(column1);
-        control2.Columns.Add(column2);
-
-        Assert.Throws<InvalidOperationException>(() => collection.Add(column1));
-        Assert.Throws<InvalidOperationException>(() => collection.Add(column2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.FullColumnSelect)]
-    [InlineData(DataGridViewSelectionMode.ColumnHeaderSelect)]
-    public void DataGridViewColumnCollection_Add_ColumnAutomaticSortModeColumnSelectionMode_ThrowsInvalidOperationException(DataGridViewSelectionMode selectionMode)
-    {
-        using var control = new DataGridView
-        {
-            SelectionMode = selectionMode
-        };
-        var collection = new DataGridViewColumnCollection(control);
-        using var column = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            SortMode = DataGridViewColumnSortMode.Automatic
-        };
-        Assert.Throws<InvalidOperationException>(() => collection.Add(column));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.FullColumnSelect)]
-    [InlineData(DataGridViewSelectionMode.ColumnHeaderSelect)]
-    public void DataGridViewColumnCollection_Add_ColumnAutomaticSortModeColumnSelectionModeInInitialization_ThrowsInvalidOperationException(DataGridViewSelectionMode selectionMode)
-    {
-        using var control = new DataGridView
-        {
-            SelectionMode = selectionMode
-        };
-        ISupportInitialize iSupportInitialize = (ISupportInitialize)control;
-        DataGridViewColumnCollection collection = control.Columns;
-        using var column = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            SortMode = DataGridViewColumnSortMode.Automatic
-        };
-        iSupportInitialize.BeginInit();
-        collection.Add(column);
-
-        // End init.
-        Assert.Throws<InvalidOperationException>(() => iSupportInitialize.EndInit());
-        Assert.Equal(DataGridViewSelectionMode.RowHeaderSelect, control.SelectionMode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewAutoSizeColumnsMode.None, DataGridViewAutoSizeColumnMode.ColumnHeader)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.ColumnHeader, DataGridViewAutoSizeColumnMode.NotSet)]
-    public void DataGridViewColumnCollection_Add_VisibleColumnHeadersNotVisibleInvalidAutoSize_ThrowsInvalidOperationException(DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, DataGridViewAutoSizeColumnMode autoSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = autoSizeColumnsMode,
-            ColumnHeadersVisible = false
-        };
-        var collection = new DataGridViewColumnCollection(control);
-        using var column = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            AutoSizeMode = autoSizeMode
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewAutoSizeColumnsMode.None, DataGridViewAutoSizeColumnMode.Fill)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.Fill, DataGridViewAutoSizeColumnMode.NotSet)]
-    public void DataGridViewColumnCollection_Add_VisibleFrozenColumnInvalidAutoSize_ThrowsInvalidOperationException(DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, DataGridViewAutoSizeColumnMode autoSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = autoSizeColumnsMode
-        };
-        var collection = new DataGridViewColumnCollection(control);
-        using var column = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            AutoSizeMode = autoSizeMode,
-            Frozen = true
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_FillWeightsOverflow_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        control.Columns.Add(column1);
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            FillWeight = ushort.MaxValue - 99
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column2));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_FrozenPreviousColumnNotFrozen_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell());
-        control.Columns.Add(column1);
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column2));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_FrozenPreviousColumnNotFrozenDisplayIndex_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            DisplayIndex = 1
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true,
-            DisplayIndex = 0,
-        };
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        using var column3 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true,
-            DisplayIndex = 1
-        };
-        control.Columns.Add(column3);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_NotFrozenPreviousColumnFrozenDisplayIndex_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true,
-            DisplayIndex = 1
-        };
-        using var column2 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            Frozen = true,
-            DisplayIndex = 0
-        };
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        using var column3 = new DataGridViewColumn(new SubDataGridViewCell())
-        {
-            DisplayIndex = 1
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column3));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_ColumnHasNoCellTemplateEmpty_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column = new DataGridViewColumn();
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnCollection_Add_ColumnHasNoCellTemplateNotEmpty_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1
-        };
-        using var column = new DataGridViewColumn();
-        Assert.Throws<InvalidOperationException>(() => control.Columns.Add(column));
-    }
-
-    private class SubDataGridView : DataGridView
-    {
-        public new void OnRowValidating(DataGridViewCellCancelEventArgs e) => base.OnRowValidating(e);
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-
-    private class SubDataGridViewColumnCollection : DataGridViewColumnCollection
-    {
-        public SubDataGridViewColumnCollection(DataGridView control) : base(control)
-        {
-        }
-
-        public new DataGridView DataGridView => base.DataGridView;
-
-        public new ArrayList List => base.List;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnDividerDoubleClickEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnDividerDoubleClickEventArgsTests.cs
deleted file mode 100644
index 23a5426eb1c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnDividerDoubleClickEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewColumnDividerDoubleClickEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_HandledMouseEventArgs_TestData()
-    {
-        yield return new object[] { -1, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, true) };
-        yield return new object[] { 0, new HandledMouseEventArgs((MouseButtons)1, 0, 0, 0, 0, true) };
-        yield return new object[] { 1, new HandledMouseEventArgs((MouseButtons)3, -1, -1, -1, -2, false) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_HandledMouseEventArgs_TestData))]
-    public void DataGridViewColumnDividerDoubleClickEventArgs_Ctor_Int_HandledMouseEventArgs(int columnIndex, HandledMouseEventArgs mouseE)
-    {
-        var e = new DataGridViewColumnDividerDoubleClickEventArgs(columnIndex, mouseE);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(mouseE.Button, e.Button);
-        Assert.Equal(mouseE.Clicks, e.Clicks);
-        Assert.Equal(mouseE.X, e.X);
-        Assert.Equal(mouseE.Y, e.Y);
-        Assert.Equal(mouseE.Delta, e.Delta);
-        Assert.Equal(mouseE.Handled, e.Handled);
-    }
-
-    [Fact]
-    public void DataGridViewColumnDividerDoubleClickEventArgs_Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewColumnDividerDoubleClickEventArgs(-2, null));
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewColumnDividerDoubleClickEventArgs(-2, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, true)));
-    }
-
-    [Fact]
-    public void DataGridViewColumnDividerDoubleClickEventArgs_Ctor_NullE_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("e", () => new DataGridViewColumnDividerDoubleClickEventArgs(1, null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnEventArgsTests.cs
deleted file mode 100644
index 2a23b34ebbf..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewColumnEventArgsTests
-{
-    [Fact]
-    public void Ctor_DataGridViewColumn()
-    {
-        using var dataGridViewColumn = new DataGridViewColumn();
-        var e = new DataGridViewColumnEventArgs(dataGridViewColumn);
-        Assert.Equal(dataGridViewColumn, e.Column);
-    }
-
-    [Fact]
-    public void Ctor_NullDataGridViewColumn_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dataGridViewColumn", () => new DataGridViewColumnEventArgs(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnHeaderCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnHeaderCellAccessibleObjectTests.cs
deleted file mode 100644
index 95b5cf1de3f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnHeaderCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,969 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewColumnHeaderCellAccessibleObjectTests : DataGridViewColumnHeaderCell
-{
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewColumnHeaderCellAccessibleObject(null);
-        Assert.Null(accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Parent_ThrowException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(() => new DataGridViewColumnHeaderCellAccessibleObject(null).Parent);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Parent_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewColumnHeaderCell cell = control.Columns[0].HeaderCell;
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)cell.AccessibilityObject;
-
-        Assert.Equal(control.AccessibilityObject.GetChild(0), accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Role_ReturnsExpected()
-    {
-        DataGridViewColumnHeaderCellAccessibleObject accessibleObject = new(null);
-        Assert.Equal(AccessibleRole.ColumnHeader, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Name_ReturnsExpected()
-    {
-        string testHeaderName = "Test header name";
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", testHeaderName);
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(testHeaderName, accessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Value_ReturnsExpected()
-    {
-        string testHeaderName = "Test header name";
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", testHeaderName);
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(testHeaderName, accessibleObject.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Bounds_IsNotEmptyRectangle_IfHandleIsCreated()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.CreateControl();
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Bounds_IsEmptyRectangle_IfHandleIsNotCreated()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_DefaultAction_ReturnsExpected_IfSortModeIsAutomatic()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewColumn column = control.Columns[0];
-        column.SortMode = DataGridViewColumnSortMode.Automatic;
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)column.HeaderCell.AccessibilityObject;
-
-        Assert.Equal(SR.DataGridView_AccColumnHeaderCellDefaultAction, accessibleObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewColumn column = control.Columns[0];
-        column.SortMode = DataGridViewColumnSortMode.Automatic;
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)column.HeaderCell.AccessibilityObject;
-
-        Assert.Equal(SR.DataGridView_AccColumnHeaderCellDefaultAction, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.InvokePatternId)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    public void DataGridViewColumnHeaderCellAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        var accessibleObject = new DataGridViewColumnHeaderCellAccessibleObject(null);
-
-        Assert.True((bool)accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewColumnHeaderCellAccessibleObject(null);
-
-        Assert.Equal(UiaCore.UIA.HeaderControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_ValueValuepropertyId_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewColumn column = control.Columns[0];
-        column.SortMode = DataGridViewColumnSortMode.Automatic;
-
-        var accessibleObject = (DataGridViewColumnHeaderCellAccessibleObject)column.HeaderCell.AccessibilityObject;
-        Assert.Equal("Header text 1", accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        var accessibleObject = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject topRowAccessibleObject = control.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(topRowAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[1].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[1].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Child_ReturnsNull_IfRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        AccessibleObject accessibleObject = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Child_ReturnsNull()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.LastChild));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        AccessibleObject accessibleObject = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Child_ReturnsNull()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[0].Visible = false;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[1].Visible = false;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject0, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject0.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[0].Visible = false;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[1].Visible = false;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[0].Visible = false;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[1].Visible = false;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject0 = control.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject0.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject0, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject0.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[0].Visible = false;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[1].Visible = false;
-        control.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject accessibleObject1 = control.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumnHeaderCellAccessibleObject_Navigate_Sibling_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView control = new() { RowHeadersVisible = false };
-        control.Columns.Add("Column 1", "Column 1");
-        control.Columns.Add("Column 2", "Column 2");
-        control.Columns.Add("Column 3", "Column 3");
-        control.Columns[0].DisplayIndex = 2;
-        control.Columns[1].DisplayIndex = 1;
-        control.Columns[2].DisplayIndex = 0;
-        control.Columns[2].Visible = false;
-
-        AccessibleObject accessibleObject2 = control.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnStateChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnStateChangedEventArgsTests.cs
deleted file mode 100644
index 23bfd17d3a8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnStateChangedEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewColumnStateChangedEventArgsTests
-{
-    [Fact]
-    public void Ctor_DataGridViewColumn_DataGridViewElementStates()
-    {
-        using var dataGridViewColumn = new DataGridViewColumn();
-        var e = new DataGridViewColumnStateChangedEventArgs(dataGridViewColumn, DataGridViewElementStates.Displayed);
-        Assert.Equal(dataGridViewColumn, e.Column);
-        Assert.Equal(DataGridViewElementStates.Displayed, e.StateChanged);
-    }
-
-    [Fact]
-    public void DataGridViewColumnStateChangedEventArgs_Ctor_NullDataGridViewColumn_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new DataGridViewColumnStateChangedEventArgs(null, DataGridViewElementStates.Displayed));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnTests.cs
deleted file mode 100644
index e2a9f4c153f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewColumnTests.cs
+++ /dev/null
@@ -1,1828 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewColumnTests
-{
-    [WinFormsFact]
-    public void DataGridViewColumn_Ctor_Default()
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Null(column.CellTemplate);
-        Assert.Null(column.CellType);
-        Assert.Null(column.ContextMenuStrip);
-        Assert.Null(column.DataGridView);
-        Assert.Empty(column.DataPropertyName);
-        Assert.NotNull(column.DefaultCellStyle);
-        Assert.Same(column.DefaultCellStyle, column.DefaultCellStyle);
-        Assert.Same(typeof(DataGridViewColumnHeaderCell), column.DefaultHeaderCellType);
-        Assert.Equal(-1, column.DisplayIndex);
-        Assert.False(column.Displayed);
-        Assert.Equal(0, column.DividerWidth);
-        Assert.Equal(100, column.FillWeight);
-        Assert.False(column.Frozen);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.IsType<DataGridViewColumnHeaderCell>(column.HeaderCell);
-        Assert.Same(column.HeaderCell, column.HeaderCell);
-        Assert.IsType<DataGridViewColumnHeaderCell>(column.HeaderCellCore);
-        Assert.Same(column.HeaderCellCore, column.HeaderCellCore);
-        Assert.Empty(column.HeaderText);
-        Assert.Equal(column.Index, column.Index);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.InheritedAutoSizeMode);
-        Assert.Same(column.DefaultCellStyle, column.InheritedStyle);
-        Assert.False(column.IsDataBound);
-        Assert.False(column.IsRow);
-        Assert.Equal(5, column.MinimumWidth);
-        Assert.Empty(column.Name);
-        Assert.False(column.ReadOnly);
-        Assert.Equal(DataGridViewTriState.NotSet, column.Resizable);
-        Assert.False(column.Selected);
-        Assert.Null(column.Site);
-        Assert.Equal(DataGridViewElementStates.Visible, column.State);
-        Assert.Equal(DataGridViewColumnSortMode.NotSortable, column.SortMode);
-        Assert.Null(column.Tag);
-        Assert.Empty(column.ToolTipText);
-        Assert.Null(column.ValueType);
-        Assert.True(column.Visible);
-        Assert.Equal(100, column.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_DataGridViewCell_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_DataGridViewCell_TestData))]
-    public void DataGridViewColumn_Ctor_DataGridViewCell(DataGridViewCell cellTemplate)
-    {
-        using var column = new SubDataGridViewColumn(cellTemplate);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Same(cellTemplate, column.CellTemplate);
-        Assert.Equal(cellTemplate?.GetType(), column.CellType);
-        Assert.Null(column.ContextMenuStrip);
-        Assert.Null(column.DataGridView);
-        Assert.Empty(column.DataPropertyName);
-        Assert.NotNull(column.DefaultCellStyle);
-        Assert.Same(column.DefaultCellStyle, column.DefaultCellStyle);
-        Assert.Same(typeof(DataGridViewColumnHeaderCell), column.DefaultHeaderCellType);
-        Assert.Equal(-1, column.DisplayIndex);
-        Assert.False(column.Displayed);
-        Assert.Equal(0, column.DividerWidth);
-        Assert.Equal(100, column.FillWeight);
-        Assert.False(column.Frozen);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Empty(column.HeaderText);
-        Assert.Equal(-1, column.Index);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.InheritedAutoSizeMode);
-        Assert.Same(column.DefaultCellStyle, column.InheritedStyle);
-        Assert.False(column.IsDataBound);
-        Assert.False(column.IsRow);
-        Assert.Equal(5, column.MinimumWidth);
-        Assert.Empty(column.Name);
-        Assert.False(column.ReadOnly);
-        Assert.Equal(DataGridViewTriState.NotSet, column.Resizable);
-        Assert.False(column.Selected);
-        Assert.Null(column.Site);
-        Assert.Equal(DataGridViewElementStates.Visible, column.State);
-        Assert.Equal(DataGridViewColumnSortMode.NotSortable, column.SortMode);
-        Assert.Null(column.Tag);
-        Assert.Empty(column.ToolTipText);
-        Assert.Null(column.ValueType);
-        Assert.True(column.Visible);
-        Assert.Equal(100, column.Width);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeColumnMode>]
-    public void DataGridViewColumn_AutoSizeMode_Set_GetReturnsExpected(DataGridViewAutoSizeColumnMode value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = value
-        };
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeColumnMode>]
-    public void DataGridViewColumn_AutoSizeMode_SetNotVisible_GetReturnsExpected(DataGridViewAutoSizeColumnMode value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = value,
-            Visible = false
-        };
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-    }
-
-    public static IEnumerable<object[]> AutoSizeMode_SetWithDataGridView_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnsMode dataGridMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnsMode)))
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                if (dataGridMode == DataGridViewAutoSizeColumnsMode.ColumnHeader && !columnHeadersVisible)
-                {
-                    continue;
-                }
-
-                foreach (bool frozen in new bool[] { true, false })
-                {
-                    if (dataGridMode == DataGridViewAutoSizeColumnsMode.Fill && frozen)
-                    {
-                        continue;
-                    }
-
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.AllCells };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.DisplayedCells, DataGridViewAutoSizeColumnMode.DisplayedCells };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader, DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.None, DataGridViewAutoSizeColumnMode.None };
-                }
-
-                yield return new object[] { dataGridMode, columnHeadersVisible, false, DataGridViewAutoSizeColumnMode.Fill, DataGridViewAutoSizeColumnMode.Fill };
-            }
-
-            if (dataGridMode != DataGridViewAutoSizeColumnsMode.Fill)
-            {
-                yield return new object[] { dataGridMode, true, true, DataGridViewAutoSizeColumnMode.ColumnHeader, DataGridViewAutoSizeColumnMode.ColumnHeader };
-            }
-
-            yield return new object[] { dataGridMode, true, false, DataGridViewAutoSizeColumnMode.ColumnHeader, DataGridViewAutoSizeColumnMode.ColumnHeader };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoSizeMode_SetWithDataGridView_TestData))]
-    public void DataGridViewColumn_AutoSizeMode_SetWithDataGridView_GetReturnsExpected(DataGridViewAutoSizeColumnsMode parentMode, bool columnHeadersVisible, bool frozen, DataGridViewAutoSizeColumnMode value, DataGridViewAutoSizeColumnMode expectedInherited)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = parentMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell(),
-            Frozen = frozen
-        };
-        control.Columns.Add(column);
-
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(expectedInherited, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(expectedInherited, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-    }
-
-    public static IEnumerable<object[]> AutoSizeMode_SetWithDataGridViewNotVisible_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnsMode dataGridMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnsMode)))
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool frozen in new bool[] { true, false })
-                {
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.AllCells };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.ColumnHeader, DataGridViewAutoSizeColumnMode.ColumnHeader };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.DisplayedCells, DataGridViewAutoSizeColumnMode.DisplayedCells };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader, DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.Fill, DataGridViewAutoSizeColumnMode.Fill };
-                    yield return new object[] { dataGridMode, columnHeadersVisible, frozen, DataGridViewAutoSizeColumnMode.None, DataGridViewAutoSizeColumnMode.None };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoSizeMode_SetWithDataGridViewNotVisible_TestData))]
-    public void DataGridViewColumn_AutoSizeMode_SetWithDataGridViewNotVisible_GetReturnsExpected(DataGridViewAutoSizeColumnsMode parentMode, bool columnHeadersVisible, bool frozen, DataGridViewAutoSizeColumnMode value, DataGridViewAutoSizeColumnMode expectedInherited)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = parentMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell(),
-            Visible = false,
-            Frozen = frozen
-        };
-        control.Columns.Add(column);
-
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(expectedInherited, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(expectedInherited, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetColumnHeaderWithDataGridViewColumnHeadersNotVisible_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersVisible = false
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.None, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetNotSetWithDataGridViewColumnHeadersNotVisible_GetReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersVisible = false
-        };
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells,
-            CellTemplate = new SubDataGridViewCell()
-        };
-        control.Columns.Add(column);
-
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.None, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetNotSetWithDataGridViewColumnHeadersNotVisible_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.ColumnHeader,
-            ColumnHeadersVisible = false
-        };
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells,
-            CellTemplate = new SubDataGridViewCell()
-        };
-        control.Columns.Add(column);
-
-        Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetFillWithDataGridViewFrozen_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell(),
-            Frozen = true
-        };
-        control.Columns.Add(column);
-
-        Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.None, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetNotSetWithDataGridViewFrozen_GetReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells,
-            CellTemplate = new SubDataGridViewCell(),
-            Frozen = true
-        };
-        control.Columns.Add(column);
-
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.NotSet, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.None, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_AutoSizeMode_SetNotSetWithDataGridViewFrozen_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill
-        };
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells,
-            CellTemplate = new SubDataGridViewCell(),
-            Frozen = true
-        };
-        control.Columns.Add(column);
-
-        Assert.Throws<InvalidOperationException>(() => column.AutoSizeMode = DataGridViewAutoSizeColumnMode.NotSet);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.AutoSizeMode);
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.InheritedAutoSizeMode);
-    }
-
-    public static IEnumerable<object[]> AutoSizeMode_SetWithOldValue_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnMode oldValue in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-        {
-            foreach (DataGridViewAutoSizeColumnMode value in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-            {
-                yield return new object[] { oldValue, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoSizeMode_SetWithOldValue_TestData))]
-    public void DataGridViewColumn_AutoSizeMode_SetWithOldValue_GetReturnsExpected(DataGridViewAutoSizeColumnMode oldValue, DataGridViewAutoSizeColumnMode value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = oldValue
-        };
-
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(100, column.Width);
-    }
-
-    public static IEnumerable<object[]> AutoSizeMode_SetWithWidth_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnMode previous in new DataGridViewAutoSizeColumnMode[] { DataGridViewAutoSizeColumnMode.NotSet, DataGridViewAutoSizeColumnMode.None, DataGridViewAutoSizeColumnMode.Fill })
-        {
-            yield return new object[] { previous, DataGridViewAutoSizeColumnMode.AllCells, 20 };
-            yield return new object[] { previous, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader, 20 };
-            yield return new object[] { previous, DataGridViewAutoSizeColumnMode.None, 20 };
-            yield return new object[] { previous, DataGridViewAutoSizeColumnMode.NotSet, 20 };
-            yield return new object[] { previous, DataGridViewAutoSizeColumnMode.Fill, 20 };
-        }
-
-        yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.AllCells, 10 };
-        yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader, 10 };
-        yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.None, 20 };
-        yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.NotSet, 20 };
-        yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, DataGridViewAutoSizeColumnMode.Fill, 20 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoSizeMode_SetWithWidth_TestData))]
-    public void DataGridViewColumn_AutoSizeMode_SetWithWidth_GetReturnsExpected(DataGridViewAutoSizeColumnMode oldValue, DataGridViewAutoSizeColumnMode value, int expectedWidth)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Width = 10,
-            AutoSizeMode = oldValue
-        };
-        column.Width = 20;
-
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(expectedWidth, column.Width);
-
-        // Set same.
-        column.AutoSizeMode = value;
-        Assert.Equal(value, column.AutoSizeMode);
-        Assert.Equal(value, column.InheritedAutoSizeMode);
-        Assert.Equal(expectedWidth, column.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_AutoSizeMode_SetWithHandler_CallsAutoSizeModeChanged()
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        object expectedPreviousMode = DataGridViewAutoSizeColumnMode.Fill;
-        DataGridViewAutoSizeColumnModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            Assert.Equal(expectedPreviousMode, e.PreviousMode);
-            callCount++;
-        };
-        control.AutoSizeColumnModeChanged += handler;
-
-        // Set different.
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.AutoSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.AutoSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        expectedPreviousMode = DataGridViewAutoSizeColumnMode.AllCells;
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.Fill, column.AutoSizeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeColumnModeChanged -= handler;
-        column.AutoSizeMode = DataGridViewAutoSizeColumnMode.AllCells;
-        Assert.Equal(DataGridViewAutoSizeColumnMode.AllCells, column.AutoSizeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DataGridViewAutoSizeColumnMode>]
-    public void DataGridViewColumn_AutoSizeMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(DataGridViewAutoSizeColumnMode value)
-    {
-        using var column = new DataGridViewColumn();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => column.AutoSizeMode = value);
-    }
-
-    public static IEnumerable<object[]> CellTemplate_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CellTemplate_Set_TestData))]
-    public void DataGridViewColumn_CellTemplate_Set_GetReturnsExpected(DataGridViewCell value)
-    {
-        using var column = new SubDataGridViewColumn
-        {
-            CellTemplate = value
-        };
-        Assert.Same(value, column.CellTemplate);
-        Assert.Same(value?.GetType(), column.CellType);
-
-        // Set same.
-        column.CellTemplate = value;
-        Assert.Same(value, column.CellTemplate);
-        Assert.Same(value?.GetType(), column.CellType);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewColumn_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Same(value, column.ContextMenuStrip);
-
-        // Set same.
-        column.ContextMenuStrip = value;
-        Assert.Same(value, column.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewColumn_ContextMenuStrip_SetWithCustomOldValue_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var oldValue = new ContextMenuStrip();
-        using var column = new DataGridViewColumn
-        {
-            ContextMenuStrip = oldValue
-        };
-
-        column.ContextMenuStrip = value;
-        Assert.Same(value, column.ContextMenuStrip);
-
-        // Set same.
-        column.ContextMenuStrip = value;
-        Assert.Same(value, column.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewColumn_ContextMenuStrip_SetWithDataGridView_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        column.ContextMenuStrip = value;
-        Assert.Same(value, column.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        column.ContextMenuStrip = value;
-        Assert.Same(value, column.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ContextMenuStrip_SetDisposeNew_RemovesContextMenuStrip()
-    {
-        using var menu = new ContextMenuStrip();
-        using var control = new DataGridViewColumn
-        {
-            ContextMenuStrip = menu
-        };
-        Assert.Same(menu, control.ContextMenuStrip);
-
-        menu.Dispose();
-        Assert.Null(control.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ContextMenuStrip_SetDisposeOld_RemovesContextMenuStrip()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridViewColumn
-        {
-            ContextMenuStrip = menu1
-        };
-        Assert.Same(menu1, control.ContextMenuStrip);
-
-        control.ContextMenuStrip = menu2;
-        Assert.Same(menu2, control.ContextMenuStrip);
-
-        menu1.Dispose();
-        Assert.Same(menu2, control.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ContextMenuStrip_SetWithHandler_CallsContextMenuStripChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        DataGridViewColumnEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            callCount++;
-        };
-        control.ColumnContextMenuStripChanged += handler;
-
-        // Set different.
-        using var menu1 = new ContextMenuStrip();
-        column.ContextMenuStrip = menu1;
-        Assert.Same(menu1, column.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.ContextMenuStrip = menu1;
-        Assert.Same(menu1, column.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        column.ContextMenuStrip = menu2;
-        Assert.Same(menu2, column.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        column.ContextMenuStrip = null;
-        Assert.Null(column.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.ColumnContextMenuStripChanged -= handler;
-        column.ContextMenuStrip = menu1;
-        Assert.Same(menu1, column.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewColumn_DataPropertyName_SetWithoutDataGridView_GetReturnsExpected(string value, string expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DataPropertyName = value
-        };
-        Assert.Equal(expected, column.DataPropertyName);
-
-        // Set same.
-        column.DataPropertyName = value;
-        Assert.Equal(expected, column.DataPropertyName);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewColumn_DataPropertyName_SetWithDataGridView_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        column.DataPropertyName = value;
-        Assert.Equal(expected, column.DataPropertyName);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        column.DataPropertyName = value;
-        Assert.Equal(expected, column.DataPropertyName);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_DataPropertyName_SetWithHandler_CallsColumnDataPropertyNameChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        DataGridViewColumnEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(column, e.Column);
-            callCount++;
-        };
-        control.ColumnDataPropertyNameChanged += handler;
-
-        // Set different.
-        column.DataPropertyName = "text";
-        Assert.Equal("text", column.DataPropertyName);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.DataPropertyName = "text";
-        Assert.Equal("text", column.DataPropertyName);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        column.DataPropertyName = null;
-        Assert.Empty(column.DataPropertyName);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnDataPropertyNameChanged -= handler;
-        column.DataPropertyName = "text";
-        Assert.Equal("text", column.DataPropertyName);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> DefaultCellStyle_Set_TestData()
-    {
-        yield return new object[] { null, new DataGridViewCellStyle() };
-
-        var style1 = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.MiddleCenter };
-        var style2 = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft };
-        yield return new object[] { style1, style1 };
-        yield return new object[] { style2, style2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewColumn_DefaultCellStyle_Set_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DefaultCellStyle = value
-        };
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-
-        // Set same.
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewColumn_DefaultCellStyle_SetWithNonNullOldValue_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-        using var column = new DataGridViewColumn
-        {
-            DefaultCellStyle = oldValue
-        };
-
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-
-        // Set same.
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewColumn_DefaultCellStyle_SetWithDataGridView_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        column.DefaultCellStyle = value;
-
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewColumn_DefaultCellStyle_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            DefaultCellStyle = oldValue
-        };
-        control.Columns.Add(column);
-
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        column.DefaultCellStyle = value;
-        Assert.Equal(expected, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_DefaultCellStyle_SetWithDataGridView_CallsColumnDefaultCellStyleChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        DataGridViewColumnEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            callCount++;
-        };
-        control.ColumnDefaultCellStyleChanged += handler;
-
-        var style1 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-
-        // Set non-null.
-        column.DefaultCellStyle = style1;
-        Assert.Equal(style1, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.DefaultCellStyle = style1;
-        Assert.Equal(style1, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var style2 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        column.DefaultCellStyle = style2;
-        Assert.Same(style2, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        column.DefaultCellStyle = null;
-        Assert.NotNull(column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(3, callCount);
-
-        // Set null again.
-        column.DefaultCellStyle = null;
-        Assert.NotNull(column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(4, callCount);
-
-        // Set non-null.
-        column.DefaultCellStyle = style2;
-        Assert.NotNull(column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(5, callCount);
-
-        // Remove handler.
-        control.ColumnDefaultCellStyleChanged -= handler;
-        column.DefaultCellStyle = style1;
-        Assert.Equal(style1, column.DefaultCellStyle);
-        Assert.True(column.HasDefaultCellStyle);
-        Assert.Equal(5, callCount);
-    }
-
-    public static IEnumerable<object[]> DefaultHeaderCellType_Set_TestData()
-    {
-        yield return new object[] { null, typeof(DataGridViewColumnHeaderCell) };
-        yield return new object[] { typeof(DataGridViewRowHeaderCell), typeof(DataGridViewRowHeaderCell) };
-        yield return new object[] { typeof(DataGridViewColumnHeaderCell), typeof(DataGridViewColumnHeaderCell) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultHeaderCellType_Set_TestData))]
-    public void DataGridViewColumn_DefaultHeaderCellType_Set_GetReturnsExpected(Type value, Type expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DefaultHeaderCellType = value
-        };
-        Assert.Equal(expected, column.DefaultHeaderCellType);
-
-        // Set same.
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(expected, column.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(DataGridViewRowHeaderCell))]
-    [InlineData(typeof(DataGridViewColumnHeaderCell))]
-    [InlineData(typeof(DataGridViewHeaderCell))]
-    public void DataGridViewColumn_DefaultHeaderCellType_SetWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var column = new SubDataGridViewColumn
-        {
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell)
-        };
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(value, column.DefaultHeaderCellType);
-
-        // Set same.
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(value, column.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultHeaderCellType_Set_TestData))]
-    public void DataGridViewColumn_DefaultHeaderCellType_SetWithDataGridView_GetReturnsExpected(Type value, Type expected)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(expected, column.DefaultHeaderCellType);
-
-        // Set same.
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(expected, column.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(DataGridViewRowHeaderCell))]
-    [InlineData(typeof(DataGridViewColumnHeaderCell))]
-    [InlineData(typeof(DataGridViewHeaderCell))]
-    public void DataGridViewColumn_DefaultHeaderCellType_SetWithDataGridViewNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        column.DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell);
-
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(value, column.DefaultHeaderCellType);
-
-        // Set same.
-        column.DefaultHeaderCellType = value;
-        Assert.Equal(value, column.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int))]
-    public void DataGridViewColumn_DefaultHeaderCellType_SetInvalidWithNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var column = new DataGridViewRow();
-        Assert.Throws<ArgumentException>("value", () => column.DefaultHeaderCellType = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    public void DataGridViewColumn_DefaultHeaderCellType_SetInvalidWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell)
-        };
-        Assert.Throws<ArgumentException>("value", () => column.DefaultHeaderCellType = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_Displayed_Get_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        Assert.False(column.Displayed);
-    }
-
-    public static IEnumerable<object[]> DividerWidth_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DividerWidth_Set_TestData))]
-    public void DataGridViewColumn_DividerWidth_Set_GetReturnsExpected(int value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            DividerWidth = value
-        };
-        Assert.Equal(value, column.DividerWidth);
-
-        // Set same.
-        column.DividerWidth = value;
-        Assert.Equal(value, column.DividerWidth);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DividerWidth_Set_TestData))]
-    public void DataGridViewColumn_DividerWidth_SetWithDataGridView_GetReturnsExpected(int value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewColumn column = control.Columns[0];
-
-        column.DividerWidth = value;
-        Assert.Equal(value, column.DividerWidth);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        column.DividerWidth = value;
-        Assert.Equal(value, column.DividerWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_DividerWidth_SetWithDataGridView_CallsColumnDividerWidthChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        DataGridViewColumnEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-        };
-        control.ColumnDividerWidthChanged += handler;
-
-        // Set non-zero.
-        column.DividerWidth = 4;
-        Assert.Equal(4, column.DividerWidth);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.DividerWidth = 4;
-        Assert.Equal(4, column.DividerWidth);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        column.DividerWidth = 3;
-        Assert.Equal(3, column.DividerWidth);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnDividerWidthChanged -= handler;
-        column.DividerWidth = 4;
-        Assert.Equal(4, column.DividerWidth);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(65537)]
-    public void DataGridViewColumn_DividerWidth_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var column = new DataGridViewColumn();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => column.DividerWidth = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Frozen, true)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly, true)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.Selected, true)]
-    public void DataGridViewColumn_Frozen_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var row = new CustomStateDataGridViewColumn
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, row.Frozen);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_Frozen_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        Assert.False(control.Columns[0].Frozen);
-    }
-
-    public static IEnumerable<object[]> Frozen_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-            {
-                yield return new object[] { visible, autoSizeMode, true };
-                yield return new object[] { visible, autoSizeMode, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Frozen_Set_TestData))]
-    public void DataGridViewColumn_Frozen_Set_GetReturnsExpected(bool visible, DataGridViewAutoSizeColumnMode autoSizeMode, bool value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Visible = visible,
-            AutoSizeMode = autoSizeMode,
-            Frozen = value
-        };
-        Assert.Equal(value, column.Frozen);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-
-        // Set same.
-        column.Frozen = value;
-        Assert.Equal(value, column.Frozen);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-
-        // Set different.
-        column.Frozen = !value;
-        Assert.Equal(!value, column.Frozen);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-    }
-
-    public static IEnumerable<object[]> Frozen_SetWithDataGridView_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-            {
-                if (autoSizeMode == DataGridViewAutoSizeColumnMode.Fill)
-                {
-                    continue;
-                }
-
-                yield return new object[] { visible, autoSizeMode, true, autoSizeMode, autoSizeMode };
-                yield return new object[] { visible, autoSizeMode, false, autoSizeMode, autoSizeMode };
-            }
-        }
-
-        yield return new object[] { true, DataGridViewAutoSizeColumnMode.Fill, true, DataGridViewAutoSizeColumnsMode.None, DataGridViewAutoSizeColumnsMode.None };
-        yield return new object[] { true, DataGridViewAutoSizeColumnMode.Fill, false, DataGridViewAutoSizeColumnsMode.Fill, DataGridViewAutoSizeColumnsMode.None };
-        yield return new object[] { false, DataGridViewAutoSizeColumnMode.Fill, true, DataGridViewAutoSizeColumnsMode.Fill, DataGridViewAutoSizeColumnsMode.Fill };
-        yield return new object[] { false, DataGridViewAutoSizeColumnMode.Fill, false, DataGridViewAutoSizeColumnsMode.Fill, DataGridViewAutoSizeColumnsMode.Fill };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Frozen_SetWithDataGridView_TestData))]
-    public void DataGridViewColumn_Frozen_SetWithDataGridView_GetReturnsExpected(bool visible, DataGridViewAutoSizeColumnMode autoSizeMode, bool value, DataGridViewAutoSizeColumnMode expectedAutoSizeMode1, DataGridViewAutoSizeColumnMode expectedAutoSizeMode2)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader
-        };
-        using var column = new DataGridViewColumn
-        {
-            Visible = visible,
-            AutoSizeMode = autoSizeMode,
-            CellTemplate = new SubDataGridViewCell()
-        };
-        control.Columns.Add(column);
-
-        column.Frozen = value;
-        Assert.Equal(value, column.Frozen);
-        Assert.Equal(expectedAutoSizeMode1, column.AutoSizeMode);
-
-        // Set same.
-        column.Frozen = value;
-        Assert.Equal(value, column.Frozen);
-        Assert.Equal(expectedAutoSizeMode1, column.AutoSizeMode);
-
-        // Set different.
-        column.Frozen = !value;
-        Assert.Equal(!value, column.Frozen);
-        Assert.Equal(expectedAutoSizeMode2, column.AutoSizeMode);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewColumn_Frozen_SetWithPreviousColumns_SetsToFrozen(bool previousVisible)
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        using var column2 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell(),
-            Visible = previousVisible
-        };
-        using var column3 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        using var column4 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        control.Columns.Add(column3);
-        control.Columns.Add(column4);
-
-        // Freeze middle.
-        column3.Frozen = true;
-        Assert.True(column1.Frozen);
-        Assert.Equal(previousVisible, column2.Frozen);
-        Assert.True(column3.Frozen);
-        Assert.False(column4.Frozen);
-
-        // Freeze again.
-        column3.Frozen = true;
-        Assert.True(column1.Frozen);
-        Assert.Equal(previousVisible, column2.Frozen);
-        Assert.True(column3.Frozen);
-        Assert.False(column4.Frozen);
-
-        // Freeze later.
-        column4.Frozen = true;
-        Assert.True(column1.Frozen);
-        Assert.Equal(previousVisible, column2.Frozen);
-        Assert.True(column3.Frozen);
-        Assert.True(column4.Frozen);
-
-        // Unfreeze middle.
-        column3.Frozen = false;
-        Assert.True(column1.Frozen);
-        Assert.Equal(previousVisible, column2.Frozen);
-        Assert.False(column3.Frozen);
-        Assert.False(column4.Frozen);
-
-        // Unfreeze first.
-        column1.Frozen = false;
-        Assert.False(column1.Frozen);
-        Assert.False(column2.Frozen);
-        Assert.False(column3.Frozen);
-        Assert.False(column4.Frozen);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_Frozen_SetWithDataGridView_CallsColumnStateChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Frozen = true
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        DataGridViewColumnStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            Assert.Equal(DataGridViewElementStates.Frozen, e.StateChanged);
-        };
-        control.ColumnStateChanged += handler;
-
-        // Set different.
-        column.Frozen = false;
-        Assert.False(column.Frozen);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.Frozen = false;
-        Assert.False(column.Frozen);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        column.Frozen = true;
-        Assert.True(column.Frozen);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnStateChanged -= handler;
-        column.Frozen = false;
-        Assert.False(column.Frozen);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_HeaderCell_Get_ReturnsExpected()
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.IsType<DataGridViewColumnHeaderCell>(column.HeaderCell);
-        Assert.Same(column, column.HeaderCell.OwningColumn);
-        Assert.Null(column.HeaderCell.OwningRow);
-        Assert.Same(column.HeaderCell, column.HeaderCell);
-        Assert.Same(column.HeaderCell, column.HeaderCellCore);
-        Assert.Empty(column.HeaderText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_HeaderCellCore_Get_ReturnsExpected()
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.IsType<DataGridViewColumnHeaderCell>(column.HeaderCellCore);
-        Assert.Same(column, column.HeaderCellCore.OwningColumn);
-        Assert.Null(column.HeaderCellCore.OwningRow);
-        Assert.Same(column.HeaderCellCore, column.HeaderCellCore);
-        Assert.Same(column.HeaderCell, column.HeaderCellCore);
-        Assert.Empty(column.HeaderText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewAutoSizeColumnsMode.AllCells, DataGridViewAutoSizeColumnMode.AllCells)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader, DataGridViewAutoSizeColumnMode.AllCellsExceptHeader)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.ColumnHeader, DataGridViewAutoSizeColumnMode.ColumnHeader)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.DisplayedCells, DataGridViewAutoSizeColumnMode.DisplayedCells)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.DisplayedCellsExceptHeader, DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.Fill, DataGridViewAutoSizeColumnMode.Fill)]
-    [InlineData(DataGridViewAutoSizeColumnsMode.None, DataGridViewAutoSizeColumnMode.None)]
-    public void DataGridViewColumn_InheritedAutoSizeMode_GetWithDataGridView_ReturnsExpected(DataGridViewAutoSizeColumnsMode mode, DataGridViewAutoSizeColumnMode expected)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeColumnsMode = mode
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        Assert.Equal(expected, column.InheritedAutoSizeMode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.ReadOnly, true)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Visible, true)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Selected, true)]
-    public void DataGridViewColumn_ReadOnly_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var column = new CustomStateDataGridViewColumn
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, column.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_ReadOnly_GetWithDataGridView_ReturnsExpected(bool dataGridViewReadOnly)
-    {
-        using var control = new DataGridView
-        {
-            ReadOnly = dataGridViewReadOnly
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        Assert.Equal(dataGridViewReadOnly, column.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewColumn_ReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ReadOnly = value
-        };
-        Assert.Equal(value, column.ReadOnly);
-        Assert.Equal(value, (column.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set same.
-        column.ReadOnly = value;
-        Assert.Equal(value, column.ReadOnly);
-        Assert.Equal(value, (column.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set different.
-        column.ReadOnly = !value;
-        Assert.Equal(!value, column.ReadOnly);
-        Assert.Equal(!value, (column.State & DataGridViewElementStates.ReadOnly) != 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewColumn_ReadOnly_SetWithDataGridView_GetReturnsExpected(bool controlReadOnly, bool value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        control.ReadOnly = controlReadOnly;
-
-        column.ReadOnly = value;
-        Assert.Equal(controlReadOnly || value, column.ReadOnly);
-
-        // Set same.
-        column.ReadOnly = value;
-        Assert.Equal(controlReadOnly || value, column.ReadOnly);
-
-        // Set different.
-        column.ReadOnly = !value;
-        Assert.Equal(controlReadOnly || !value, column.ReadOnly);
-
-        control.ReadOnly = false;
-        Assert.Equal(!controlReadOnly && !value, column.ReadOnly);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ReadOnly_SetWithDataGridView_CallsColumnStateChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        DataGridViewColumnStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            Assert.Equal(DataGridViewElementStates.ReadOnly, e.StateChanged);
-        };
-        control.ColumnStateChanged += handler;
-
-        // Set true.
-        column.ReadOnly = true;
-        Assert.True(column.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.ReadOnly = true;
-        Assert.True(column.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        column.ReadOnly = false;
-        Assert.False(column.ReadOnly);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnStateChanged -= handler;
-        column.ReadOnly = true;
-        Assert.True(column.ReadOnly);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Visible, true)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.ReadOnly, true)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.Selected, true)]
-    public void DataGridViewColumn_Visible_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var row = new CustomStateDataGridViewColumn
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, row.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewColumn_Visible_GetWithDataGridView_ReturnsExpected(bool visible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = visible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        Assert.True(control.Columns[0].Visible);
-    }
-
-    public static IEnumerable<object[]> Visible_Set_TestData()
-    {
-        foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-        {
-            foreach (bool frozen in new bool[] { true, false })
-            {
-                yield return new object[] { autoSizeMode, frozen, true };
-                yield return new object[] { autoSizeMode, frozen, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void DataGridViewColumn_Visible_Set_GetReturnsExpected(DataGridViewAutoSizeColumnMode autoSizeMode, bool frozen, bool value)
-    {
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = autoSizeMode,
-            Frozen = frozen,
-            Visible = value
-        };
-        Assert.Equal(value, column.Visible);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-
-        // Set same.
-        column.Visible = value;
-        Assert.Equal(value, column.Visible);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-
-        // Set different.
-        column.Visible = !value;
-        Assert.Equal(!value, column.Visible);
-        Assert.Equal(autoSizeMode, column.AutoSizeMode);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithDataGridView_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                foreach (DataGridViewAutoSizeColumnMode autoSizeMode in Enum.GetValues(typeof(DataGridViewAutoSizeColumnMode)))
-                {
-                    if (!columnHeadersVisible && autoSizeMode == DataGridViewAutoSizeColumnMode.ColumnHeader)
-                    {
-                        continue;
-                    }
-
-                    yield return new object[] { visible, columnHeadersVisible, autoSizeMode, true, autoSizeMode, autoSizeMode };
-                    yield return new object[] { visible, columnHeadersVisible, autoSizeMode, false, autoSizeMode, autoSizeMode };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithDataGridView_TestData))]
-    public void DataGridViewColumn_Visible_SetWithDataGridView_GetReturnsExpected(bool visible, bool columnHeadersVisible, DataGridViewAutoSizeColumnMode autoSizeMode, bool value, DataGridViewAutoSizeColumnMode expectedAutoSizeMode1, DataGridViewAutoSizeColumnMode expectedAutoSizeMode2)
-    {
-        using var control = new DataGridView
-        {
-            Visible = visible,
-            ColumnHeadersVisible = columnHeadersVisible,
-            AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            AutoSizeMode = autoSizeMode,
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-
-        column.Visible = value;
-        Assert.Equal(value, column.Visible);
-        Assert.Equal(expectedAutoSizeMode1, column.AutoSizeMode);
-
-        // Set same.
-        column.Visible = value;
-        Assert.Equal(value, column.Visible);
-        Assert.Equal(expectedAutoSizeMode1, column.AutoSizeMode);
-
-        // Set different.
-        column.Visible = !value;
-        Assert.Equal(!value, column.Visible);
-        Assert.Equal(expectedAutoSizeMode2, column.AutoSizeMode);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewColumn_Visible_SetWithPreviousColumns_SetsToVisible(bool previousVisible)
-    {
-        using var control = new DataGridView();
-        using var column1 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        using var column2 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell(),
-            Visible = previousVisible
-        };
-        using var column3 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        using var column4 = new DataGridViewColumn
-        {
-            CellTemplate = new SubDataGridViewCell()
-        };
-        control.Columns.Add(column1);
-        control.Columns.Add(column2);
-        control.Columns.Add(column3);
-        control.Columns.Add(column4);
-
-        // Freeze middle.
-        column3.Visible = true;
-        Assert.True(column1.Visible);
-        Assert.Equal(previousVisible, column2.Visible);
-        Assert.True(column3.Visible);
-        Assert.True(column4.Visible);
-
-        // Freeze again.
-        column3.Visible = true;
-        Assert.True(column1.Visible);
-        Assert.Equal(previousVisible, column2.Visible);
-        Assert.True(column3.Visible);
-        Assert.True(column4.Visible);
-
-        // Freeze later.
-        column4.Visible = true;
-        Assert.True(column1.Visible);
-        Assert.Equal(previousVisible, column2.Visible);
-        Assert.True(column3.Visible);
-        Assert.True(column4.Visible);
-
-        // Unfreeze middle.
-        column3.Visible = false;
-        Assert.True(column1.Visible);
-        Assert.Equal(previousVisible, column2.Visible);
-        Assert.False(column3.Visible);
-        Assert.True(column4.Visible);
-
-        // Unfreeze first.
-        column1.Visible = false;
-        Assert.False(column1.Visible);
-        Assert.Equal(previousVisible, column2.Visible);
-        Assert.False(column3.Visible);
-        Assert.True(column4.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_Visible_SetWithDataGridView_CallsColumnStateChanged()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = true
-        };
-        control.Columns.Add(column);
-
-        int callCount = 0;
-        DataGridViewColumnStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(column, e.Column);
-            Assert.Equal(DataGridViewElementStates.Visible, e.StateChanged);
-        };
-        control.ColumnStateChanged += handler;
-
-        // Set different.
-        column.Visible = false;
-        Assert.False(column.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        column.Visible = false;
-        Assert.False(column.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        column.Visible = true;
-        Assert.True(column.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnStateChanged -= handler;
-        column.Visible = false;
-        Assert.False(column.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> GetPreferred_WithoutDataGridView_TestData()
-    {
-        foreach (bool fixedHeight in new bool[] { true, false })
-        {
-            yield return new object[] { DataGridViewAutoSizeColumnMode.ColumnHeader, fixedHeight };
-            yield return new object[] { DataGridViewAutoSizeColumnMode.AllCellsExceptHeader, fixedHeight };
-            yield return new object[] { DataGridViewAutoSizeColumnMode.AllCells, fixedHeight };
-            yield return new object[] { DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader, fixedHeight };
-            yield return new object[] { DataGridViewAutoSizeColumnMode.DisplayedCells, fixedHeight };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferred_WithoutDataGridView_TestData))]
-    public void DataGridViewColumn_GetPreferredWidth_InvokeWithoutDataGridView_ReturnsExpected(DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight)
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.Equal(-1, column.GetPreferredWidth(autoSizeColumnMode, fixedHeight));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewAutoSizeColumnMode.NotSet)]
-    [InlineData(DataGridViewAutoSizeColumnMode.None)]
-    [InlineData(DataGridViewAutoSizeColumnMode.Fill)]
-    public void DataGridViewColumn_GetPreferredWidth_NotApplicableAutoSizeColumnMode_ThrowsArgumentException(DataGridViewAutoSizeColumnMode autoSizeColumnMode)
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.Throws<ArgumentException>(() => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: true));
-        Assert.Throws<ArgumentException>(() => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: false));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DataGridViewAutoSizeColumnMode>]
-    public void DataGridViewColumn_GetPreferredWidth_NotApplicableAutoSizeColumnMode_ThrowsInvalidEnumArgumentException(DataGridViewAutoSizeColumnMode autoSizeColumnMode)
-    {
-        using var column = new SubDataGridViewColumn();
-        Assert.Throws<InvalidEnumArgumentException>("autoSizeColumnMode", () => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: true));
-        Assert.Throws<InvalidEnumArgumentException>("autoSizeColumnMode", () => column.GetPreferredWidth(autoSizeColumnMode, fixedHeight: false));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ToString_Invoke_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        Assert.Equal("DataGridViewColumn { Name=, Index=-1 }", column.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewColumn_ToString_InvokeWithName_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn
-        {
-            Name = "name"
-        };
-        Assert.Equal("DataGridViewColumn { Name=name, Index=-1 }", column.ToString());
-    }
-
-    private class CustomStateDataGridViewColumn : DataGridViewColumn
-    {
-        public DataGridViewElementStates StateResult { get; set; }
-
-        public override DataGridViewElementStates State => StateResult;
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-
-    private class SubDataGridViewColumn : DataGridViewColumn
-    {
-        public SubDataGridViewColumn() : base()
-        {
-        }
-
-        public SubDataGridViewColumn(DataGridViewCell cellTemplate) : base(cellTemplate)
-        {
-        }
-
-        public new DataGridViewHeaderCell HeaderCellCore => base.HeaderCellCore;
-
-        public new bool IsRow => base.IsRow;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxCellAccessibleObjectTests.cs
deleted file mode 100644
index 9a187abcfc5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewComboBoxCellAccessibleObjectTests
-{
-    public static IEnumerable<object[]> DataGridViewComboBoxCellAccessibleObject_SupportExpandCollapsePattern_TestData()
-    {
-        foreach (DataGridViewComboBoxDisplayStyle displayStyle in Enum.GetValues(typeof(DataGridViewComboBoxDisplayStyle)))
-        {
-            foreach (bool cellIsEdited in new[] { true, false })
-            {
-                bool expectedValue = displayStyle != DataGridViewComboBoxDisplayStyle.Nothing || cellIsEdited;
-                yield return new object[] { displayStyle, cellIsEdited, expectedValue };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewComboBoxCellAccessibleObject_SupportExpandCollapsePattern_TestData))]
-    public void DataGridViewComboBoxCellAccessibleObject_SupportExpandCollapsePattern_ReturnExpected(DataGridViewComboBoxDisplayStyle displayStyle, bool cellIsEdited, bool expectedValue)
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.Columns.Add(new DataGridViewComboBoxColumn() { DisplayStyle = displayStyle });
-        dataGridView.Rows.Add();
-        dataGridView.CurrentCell = dataGridView.Rows[0].Cells[0];
-
-        if (cellIsEdited)
-        {
-            dataGridView.BeginEdit(false);
-        }
-
-        object actualPropertyValue = dataGridView.Rows[0].Cells[0].AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId);
-
-        Assert.Equal(expectedValue, actualPropertyValue);
-    }
-
-    public static IEnumerable<object[]> DataGridViewComboBoxCellAccessibleObject_ControlType_TestData()
-    {
-        foreach (DataGridViewComboBoxDisplayStyle displayStyle in Enum.GetValues(typeof(DataGridViewComboBoxDisplayStyle)))
-        {
-            foreach (bool cellIsEdited in new[] { true, false })
-            {
-                int expectedControlType = displayStyle != DataGridViewComboBoxDisplayStyle.Nothing || cellIsEdited
-                                    ? (int)UiaCore.UIA.ComboBoxControlTypeId
-                                    : (int)UiaCore.UIA.DataItemControlTypeId;
-
-                yield return new object[] { displayStyle, cellIsEdited, expectedControlType };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewComboBoxCellAccessibleObject_ControlType_TestData))]
-    public void DataGridViewComboBoxCellAccessibleObject_ControlType_ReturnExpected(DataGridViewComboBoxDisplayStyle displayStyle, bool cellIsEdited, int expectedControlType)
-    {
-        using var dataGridView = new DataGridView();
-        dataGridView.Columns.Add(new DataGridViewComboBoxColumn() { DisplayStyle = displayStyle });
-        dataGridView.Rows.Add();
-        dataGridView.CurrentCell = dataGridView.Rows[0].Cells[0];
-
-        if (cellIsEdited)
-        {
-            dataGridView.BeginEdit(false);
-        }
-
-        int actualPropertyValue = (int)dataGridView.Rows[0].Cells[0].AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expectedControlType, actualPropertyValue);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxEditingControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxEditingControlAccessibleObjectTests.cs
deleted file mode 100644
index 86246121234..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewComboBoxEditingControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.DataGridViewComboBoxEditingControl;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewComboBoxEditingControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_Ctor_Default()
-    {
-        using DataGridViewComboBoxEditingControl control = new DataGridViewComboBoxEditingControl();
-
-        DataGridViewComboBoxEditingControlAccessibleObject accessibleObject =
-            new DataGridViewComboBoxEditingControlAccessibleObject(control);
-
-        Assert.Equal(control, accessibleObject.Owner);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ComboBox)]
-    [InlineData(false, AccessibleRole.None)]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using DataGridViewComboBoxEditingControl control = new DataGridViewComboBoxEditingControl();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        object actual = control.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_ControlType_IsComboBox_IfAccessibleRoleIsDefault()
-    {
-        using DataGridViewComboBoxEditingControl control = new DataGridViewComboBoxEditingControl();
-        // AccessibleRole is not set = Default
-
-        object actual = control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ComboBoxControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewComboBoxEditingControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewComboBoxEditingControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DataGridViewComboBoxEditingControlAccessibleObjectTest_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DataGridViewComboBoxEditingControl control = new DataGridViewComboBoxEditingControl();
-        control.AccessibleRole = role;
-
-        object actual = control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.NextSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.PreviousSibling)]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_FragmentNavigate_SiblingsAreNull(int direction)
-    {
-        using DataGridViewComboBoxEditingControl control = new();
-
-        object actual = control.AccessibilityObject.FragmentNavigate((UiaCore.NavigateDirection)direction);
-
-        Assert.Null(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_FragmentNavigate_ChildrenAreExpected()
-    {
-        using DataGridViewComboBoxEditingControl control = new();
-        control.CreateControl();
-
-        object firstChild = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        object lastChild = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.Equal(control.ChildEditAccessibleObject, firstChild);
-        Assert.Equal(((DataGridViewComboBoxEditingControlAccessibleObject)control.AccessibilityObject).DropDownButtonUiaProvider, lastChild);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewComboBoxEditingControlAccessibleObject_FragmentNavigate_ParentIsCell()
-    {
-        using DataGridView control = new();
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        control.Columns.Add(new DataGridViewComboBoxColumn());
-        control.Rows.Add();
-
-        control.CreateControl();
-        control.CurrentCell = control.Rows[0].Cells[0];
-        control.BeginEdit(false);
-
-        object actual = control.EditingControlAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        control.EndEdit();
-
-        Assert.Null(control.EditingControl);
-        Assert.Equal(control.CurrentCell.AccessibilityObject, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewDataErrorEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewDataErrorEventArgsTests.cs
deleted file mode 100644
index 73fbf3a3adc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewDataErrorEventArgsTests.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewDataErrorEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Exception_Int_Int_DataGridViewDataErrorContexts_TestData()
-    {
-        yield return new object[] { null, -1, -1, (DataGridViewDataErrorContexts)3 };
-        yield return new object[] { new Exception(), 0, 0, DataGridViewDataErrorContexts.Formatting };
-        yield return new object[] { new Exception(), 1, 2, DataGridViewDataErrorContexts.Formatting };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Exception_Int_Int_DataGridViewDataErrorContexts_TestData))]
-    public void Ctor_Exception_Int_Int_DataGridViewDataErrorContexts(Exception exception, int columnIndex, int rowIndex, DataGridViewDataErrorContexts context)
-    {
-        var e = new DataGridViewDataErrorEventArgs(exception, columnIndex, rowIndex, context);
-        Assert.Equal(exception, e.Exception);
-        Assert.Equal(columnIndex, e.ColumnIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(context, e.Context);
-        Assert.False(e.Cancel);
-        Assert.False(e.ThrowException);
-    }
-
-    [Fact]
-    public void Ctor_NegativeColumnIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("columnIndex", () => new DataGridViewDataErrorEventArgs(null, -2, 0, DataGridViewDataErrorContexts.Formatting));
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewDataErrorEventArgs(null, 0, -2, DataGridViewDataErrorContexts.Formatting));
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ThrowException_SetFalseWithException_GetReturnsExpected(bool value)
-    {
-        var e = new DataGridViewDataErrorEventArgs(new Exception(), 1, 2, DataGridViewDataErrorContexts.Formatting) { ThrowException = value };
-        Assert.Equal(value, e.ThrowException);
-    }
-
-    [Fact]
-    public void ThrowException_SetFalseWithoutException_GetReturnsExpected()
-    {
-        var e = new DataGridViewDataErrorEventArgs(null, 1, 2, DataGridViewDataErrorContexts.Formatting) { ThrowException = false };
-        Assert.False(e.ThrowException);
-    }
-
-    [Fact]
-    public void ThrowException_SetTrueWithoutException_ThrowsArgumentException()
-    {
-        var e = new DataGridViewDataErrorEventArgs(null, 1, 2, DataGridViewDataErrorContexts.Formatting);
-        Assert.Throws<ArgumentException>(() => e.ThrowException = true);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewEditingControlShowingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewEditingControlShowingEventArgsTests.cs
deleted file mode 100644
index 5ddb1f05401..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewEditingControlShowingEventArgsTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewEditingControlShowingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Control_DataGridViewCellStyle_TestData()
-    {
-        yield return new object[] { null, new DataGridViewCellStyle() };
-        yield return new object[] { new Button(), null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_DataGridViewCellStyle_TestData))]
-    public void DataGridViewEditingControlShowingEventArgs_NullArg_ThrowsArgumentNullException(Control control, DataGridViewCellStyle cellStyle)
-    {
-        Assert.Throws<ArgumentNullException>(() => new DataGridViewEditingControlShowingEventArgs(control, cellStyle));
-    }
-
-    [Fact]
-    public void Ctor_Control_DataGridViewCellStyle()
-    {
-        using var button = new Button();
-        var cellStyle = new DataGridViewCellStyle();
-        var e = new DataGridViewEditingControlShowingEventArgs(button, cellStyle);
-        Assert.Equal(button, e.Control);
-        Assert.Equal(cellStyle, e.CellStyle);
-    }
-
-    [Fact]
-    public void CellStyle_SetNull_ThrowsArgumentNullException()
-    {
-        using var button = new Button();
-        var e = new DataGridViewEditingControlShowingEventArgs(button, new DataGridViewCellStyle());
-        Assert.Throws<ArgumentNullException>("value", () => e.CellStyle = null);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewElementTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewElementTests.cs
deleted file mode 100644
index f35d96e89ad..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewElementTests.cs
+++ /dev/null
@@ -1,411 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewElementTests
-{
-    [WinFormsFact]
-    public void DataGridViewElement_Ctor_Default()
-    {
-        var element = new DataGridViewElement();
-        Assert.Null(element.DataGridView);
-        Assert.Equal(DataGridViewElementStates.Visible, element.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_OnDataGridViewChanged_Invoke_Nop()
-    {
-        var element = new SubDataGridViewElement();
-        element.OnDataGridViewChanged();
-    }
-
-    public static IEnumerable<object[]> DataGridViewCellEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellEventArgs(1, 2) };
-    }
-
-    public static IEnumerable<object[]> DataGridViewElement_Subclasses_SuppressFinalizeCall_TestData()
-    {
-        foreach (var type in typeof(DataGridViewElement).Assembly.GetTypes().Where(type =>
-            type == typeof(DataGridViewBand) || type == typeof(DataGridViewCell) ||
-            type.IsSubclassOf(typeof(DataGridViewBand)) || type.IsSubclassOf(typeof(DataGridViewCell))))
-        {
-            yield return new object[] { type };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewElement_RaiseCellClick_Invoke_Nop(DataGridViewCellEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseCellClick(eventArgs);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellClick_InvokeWithDataGridView_Success()
-    {
-        var eventArgs = new DataGridViewCellEventArgs(0, 0);
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.CellClick += handler;
-        element.RaiseCellClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CellClick -= handler;
-        element.RaiseCellClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellClick_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-        Assert.Throws<NullReferenceException>(() => element.RaiseCellClick(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewElement_RaiseCellContentClick_Invoke_Nop(DataGridViewCellEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseCellContentClick(eventArgs);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellContentClick_InvokeWithDataGridView_Success()
-    {
-        var eventArgs = new DataGridViewCellEventArgs(0, 0);
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.CellContentClick += handler;
-        element.RaiseCellContentClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CellContentClick -= handler;
-        element.RaiseCellContentClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellContentClick_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-        Assert.Throws<NullReferenceException>(() => element.RaiseCellContentClick(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewElement_RaiseCellContentDoubleClick_Invoke_Nop(DataGridViewCellEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseCellContentDoubleClick(eventArgs);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellContentDoubleClick_InvokeWithDataGridView_Success()
-    {
-        var eventArgs = new DataGridViewCellEventArgs(0, 0);
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.CellContentDoubleClick += handler;
-        element.RaiseCellContentDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CellContentDoubleClick -= handler;
-        element.RaiseCellContentDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellContentDoubleClick_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-        Assert.Throws<NullReferenceException>(() => element.RaiseCellContentDoubleClick(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewCellEventArgs_TestData))]
-    public void DataGridViewElement_RaiseCellValueChanged_Invoke_Nop(DataGridViewCellEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseCellValueChanged(eventArgs);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellValueChanged_InvokeWithDataGridView_Success()
-    {
-        var eventArgs = new DataGridViewCellEventArgs(0, 0);
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.CellValueChanged += handler;
-        element.RaiseCellValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CellValueChanged -= handler;
-        element.RaiseCellValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseCellValueChanged_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-        Assert.Throws<NullReferenceException>(() => element.RaiseCellValueChanged(null));
-    }
-
-    public static IEnumerable<object[]> DataGridViewDataErrorEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewDataErrorEventArgs(new Exception(), 1, 2, DataGridViewDataErrorContexts.Formatting) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewDataErrorEventArgs_TestData))]
-    public void DataGridViewElement_RaiseDataError_Invoke_Nop(DataGridViewDataErrorEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseDataError(eventArgs);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseDataError_InvokeWithDataGridView_Success()
-    {
-        var eventArgs = new DataGridViewDataErrorEventArgs(new Exception(), 1, 2, DataGridViewDataErrorContexts.Formatting);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1,
-            Site = mockSite.Object
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.DataError += handler;
-        element.RaiseDataError(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DataError -= handler;
-        element.RaiseDataError(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewElement_RaiseDataError_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-        Assert.Throws<NullReferenceException>(() => element.RaiseDataError(null));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void DataGridViewElement_RaiseMouseWheel_Invoke_Nop(MouseEventArgs eventArgs)
-    {
-        var element = new SubDataGridViewElement();
-        element.RaiseMouseWheel(eventArgs);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void DataGridViewElement_RaiseMouseWheel_InvokeWithDataGridView_Success(MouseEventArgs eventArgs)
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 1,
-            ColumnCount = 1
-        };
-        var element = new SubDataGridViewCell();
-        control.Rows[0].Cells[0] = element;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(sender, control);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        element.RaiseMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        element.RaiseMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewElement_Subclasses_SuppressFinalizeCall_TestData))]
-    public void DataGridViewElement_Subclasses_SuppressFinalizeCall(Type type)
-    {
-        Assert.True(type == typeof(DataGridViewBand) || type == typeof(DataGridViewColumn) ||
-            type == typeof(DataGridViewButtonColumn) || type == typeof(DataGridViewCheckBoxColumn) ||
-            type == typeof(DataGridViewComboBoxColumn) || type == typeof(DataGridViewImageColumn) ||
-            type == typeof(DataGridViewLinkColumn) || type == typeof(DataGridViewTextBoxColumn) ||
-            type == typeof(DataGridViewRow) || type == typeof(DataGridViewCell) || type == typeof(DataGridViewButtonCell) ||
-            type == typeof(DataGridViewCheckBoxCell) || type == typeof(DataGridViewComboBoxCell) ||
-            type == typeof(DataGridViewHeaderCell) || type == typeof(DataGridViewColumnHeaderCell) ||
-            type == typeof(DataGridViewTopLeftHeaderCell) || type == typeof(DataGridViewRowHeaderCell) ||
-            type == typeof(DataGridViewImageCell) || type == typeof(DataGridViewLinkCell) || type == typeof(DataGridViewTextBoxCell),
-            $"Type {type} is not one of known {nameof(DataGridViewElement)} subclauses with empty finalizers. " +
-            $"Consider adding it here and to the {nameof(DataGridViewElement)}() constructor. " +
-            $"Or add exclusion to this test (if a new class really needs a finalizer).");
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-        public new void RaiseCellClick(DataGridViewCellEventArgs e) => base.RaiseCellClick(e);
-
-        public new void RaiseCellContentClick(DataGridViewCellEventArgs e) => base.RaiseCellContentClick(e);
-
-        public new void RaiseCellContentDoubleClick(DataGridViewCellEventArgs e) => base.RaiseCellContentDoubleClick(e);
-
-        public new void RaiseCellValueChanged(DataGridViewCellEventArgs e) => base.RaiseCellValueChanged(e);
-
-        public new void RaiseDataError(DataGridViewDataErrorEventArgs e) => base.RaiseDataError(e);
-
-        public new void RaiseMouseWheel(MouseEventArgs e) => base.RaiseMouseWheel(e);
-    }
-
-    private class SubDataGridViewElement : DataGridViewElement
-    {
-        public new void OnDataGridViewChanged() => base.OnDataGridViewChanged();
-
-        public new void RaiseCellClick(DataGridViewCellEventArgs e) => base.RaiseCellClick(e);
-
-        public new void RaiseCellContentClick(DataGridViewCellEventArgs e) => base.RaiseCellContentClick(e);
-
-        public new void RaiseCellContentDoubleClick(DataGridViewCellEventArgs e) => base.RaiseCellContentDoubleClick(e);
-
-        public new void RaiseCellValueChanged(DataGridViewCellEventArgs e) => base.RaiseCellValueChanged(e);
-
-        public new void RaiseDataError(DataGridViewDataErrorEventArgs e) => base.RaiseDataError(e);
-
-        public new void RaiseMouseWheel(MouseEventArgs e) => base.RaiseMouseWheel(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewHeaderCellTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewHeaderCellTests.cs
deleted file mode 100644
index 4cda75c5105..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewHeaderCellTests.cs
+++ /dev/null
@@ -1,4721 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.VisualStyles;
-using Microsoft.DotNet.RemoteExecutor;
-using System.Windows.Forms.TestUtilities;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewHeaderCellTests
-{
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Ctor_Default()
-    {
-        var cell = new SubDataGridViewHeaderCell();
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Null(cell.DataGridView);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.False(cell.Displayed);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Empty(cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.False(cell.HasStyle);
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet, cell.InheritedState);
-        Assert.False(cell.IsInEditMode);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.True(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.False(cell.Selected);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.NotNull(cell.Style);
-        Assert.Same(cell.Style, cell.Style);
-        Assert.Null(cell.Tag);
-        Assert.Empty(cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Displayed_GetWithRow_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.False(cell.Displayed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Displayed_GetWithRowHeaderCell_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.False(cell.Displayed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Displayed_GetColumnHeaderCellHeaderCell_ReturnsExpected(bool columnVisible)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Visible = columnVisible
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.False(cell.Displayed);
-    }
-
-    public static IEnumerable<object[]> Displayed_GetWithDataGridView_TestData()
-    {
-        foreach (bool gridVisible in new bool[] { true, false })
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool columnHeadersVisible in new bool[] { true, false })
-                {
-                    foreach (bool rowVisible in new bool[] { true, false })
-                    {
-                        foreach (bool columnVisible in new bool[] { true, false })
-                        {
-                            yield return new object[] { gridVisible, rowHeadersVisible, columnHeadersVisible, rowVisible, columnVisible };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetWithDataGridView_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetShared_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetColumnHeaderCellWithDataGridViewHeaderCell_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetRowHeaderCellWithDataGridView_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible, bool rowVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Displayed_GetTopLeftHeaderCell_TestData()
-    {
-        foreach (bool gridVisible in new bool[] { true, false })
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool columnHeadersVisible in new bool[] { true, false })
-                {
-                    yield return new object[] { gridVisible, rowHeadersVisible, columnHeadersVisible };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetTopLeftHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetTopLeftHeaderCell_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible,
-            TopLeftHeaderCell = cell
-        };
-        Assert.False(cell.Displayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Displayed_GetShared_TestData()
-    {
-        foreach (bool gridVisible in new bool[] { true, false })
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool columnHeadersVisible in new bool[] { true, false })
-                {
-                    foreach (bool columnVisible in new bool[] { true, false })
-                    {
-                        yield return new object[] { gridVisible, rowHeadersVisible, columnHeadersVisible, columnVisible };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetShared_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetShared_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        if (gridVisible && rowHeadersVisible)
-        {
-            Assert.Throws<InvalidOperationException>(() => cell.Displayed);
-        }
-        else
-        {
-            Assert.Equal(gridVisible && rowHeadersVisible && columnHeadersVisible && columnVisible, cell.Displayed);
-        }
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetWithDataGridViewWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        Assert.Equal(gridVisible && rowHeadersVisible && rowVisible, cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetShared_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetColumnHeaderCellWithDataGridViewWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(gridVisible && columnHeadersVisible && columnVisible, cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetRowHeaderCellWithDataGridViewWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible, bool rowVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(gridVisible && rowHeadersVisible && rowVisible, cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Displayed_GetTopLeftHeaderCellWithHandle_ReturnsExpected(bool visible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = visible
-        };
-        using var cell = new DataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(visible, cell.Displayed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    // Note if we fix this issue https://github.com/dotnet/winforms/issues/6930#issuecomment-1090213559 then we will have to edit this test.
-    [WinFormsTheory]
-    [MemberData(nameof(Displayed_GetShared_TestData))]
-    public void DataGridViewHeaderCell_Displayed_GetSharedWithHandle_ReturnsExpected(bool gridVisible, bool rowHeadersVisible, bool columnHeadersVisible, bool columnVisible)
-    {
-        using var control = new DataGridView
-        {
-            Visible = gridVisible,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Visible = columnVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // DataGridViewHeaderCell with OwningRow will be visible only if: gridVisible && rowHeadersVisible && OwningRow.Displayed.
-        // And OwningRow.Displayed will be true if columnVisible.
-        // See https://github.com/dotnet/winforms/pull/6957 and
-        // DataGridViewCell_Displayed_GetWithSharedDataGridViewWithHandle_ReturnsExpected test for details.
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        if (gridVisible && rowHeadersVisible && !columnVisible)
-        {
-            Assert.Throws<InvalidOperationException>(() => cell.Displayed);
-        }
-        else
-        {
-            Assert.Equal(gridVisible && rowHeadersVisible && columnVisible, cell.Displayed);
-        }
-
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Frozen, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewHeaderCell_Frozen_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewHeaderCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Frozen_GetWithRow_ReturnsExpected(bool rowFrozen)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = rowFrozen
-        };
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(rowFrozen, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Frozen_GetColumnHeaderCellHeaderCell_ReturnsExpected(bool columnFrozen)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Frozen = columnFrozen
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(columnFrozen, cell.Frozen);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, true)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void DataGridViewHeaderCell_Frozen_GetWithDataGridView_ReturnsExpected(bool rowFrozen, bool columnFrozen, bool expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Frozen = rowFrozen;
-        column.Frozen = columnFrozen;
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        Assert.Equal(expected, cell.Frozen);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewHeaderCell_Frozen_GetTopLeftHeaderCell_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible,
-            TopLeftHeaderCell = cell
-        };
-        Assert.True(cell.Frozen);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Frozen_GetShared_ThrowsInvalidOperationException(bool columnFrozen)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Frozen = columnFrozen;
-        DataGridViewCell cell = Assert.IsType<DataGridViewHeaderCell>(row.Cells[0]);
-        Assert.Throws<InvalidOperationException>(() => cell.Frozen);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None)]
-    [InlineData(DataGridViewElementStates.ReadOnly)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Frozen)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Selected)]
-    public void DataGridViewHeaderCell_ReadOnly_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state)
-    {
-        using var cell = new CustomStateDataGridViewHeaderCell
-        {
-            StateResult = state
-        };
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_GetWithRow_ReturnsExpected(bool rowReadOnly)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = rowReadOnly
-        };
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_GetWithRowHeaderCell_ReturnsExpected(bool rowReadOnly)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = rowReadOnly
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_GetColumnHeaderCellHeaderCell_ReturnsExpected(bool columnReadOnly)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ReadOnly = columnReadOnly
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.True(cell.ReadOnly);
-    }
-
-    public static IEnumerable<object[]> ReadOnly_Get_TestData()
-    {
-        foreach (bool readOnly in new bool[] { true, false })
-        {
-            foreach (bool rowReadOnly in new bool[] { true, false })
-            {
-                foreach (bool columnReadOnly in new bool[] { true, false })
-                {
-                    yield return new object[] { readOnly, rowReadOnly, columnReadOnly };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ReadOnly_Get_TestData))]
-    public void DataGridViewHeaderCell_ReadOnly_GetWithDataGridView_ReturnsExpected(bool readOnly, bool rowReadOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        column.ReadOnly = columnReadOnly;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ReadOnly_Get_TestData))]
-    public void DataGridViewHeaderCell_ReadOnly_GetRowHeaderWithDataGridView_ReturnsExpected(bool readOnly, bool rowReadOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        column.ReadOnly = columnReadOnly;
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ReadOnly_Get_TestData))]
-    public void DataGridViewHeaderCell_ReadOnly_GetColumnHeaderCellWithDataGridView_ReturnsExpected(bool readOnly, bool rowReadOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = rowReadOnly;
-        column.ReadOnly = columnReadOnly;
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_GetTopLeftHeaderCell_ReturnsExpected(bool readOnly)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly,
-            TopLeftHeaderCell = cell
-        };
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewHeaderCell_ReadOnly_GetShared_ReturnsExpected(bool readOnly, bool columnReadOnly)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ReadOnly = readOnly
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.ReadOnly = columnReadOnly;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_Set_ThrowsInvalidOperationException(bool value)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetWithRow_ThrowsInvalidOperationException(bool value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetWithRowHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetColumnHeaderCellHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetRowHeaderCellWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetColumnHeaderCellWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetTopLeftHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.True(cell.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_ReadOnly_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.ReadOnly = value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Resizable, false)]
-    [InlineData(DataGridViewElementStates.Resizable | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Resizable | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewHeaderCell_Resizable_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var cell = new CustomStateDataGridViewHeaderCell
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.False, false)]
-    [InlineData(DataGridViewTriState.NotSet, false)]
-    public void DataGridViewHeaderCell_Resizable_GetWithRow_ReturnsExpected(DataGridViewTriState rowResizable, bool expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Resizable = rowResizable
-        };
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.False, false)]
-    [InlineData(DataGridViewTriState.NotSet, false)]
-    public void DataGridViewHeaderCell_Resizable_GetWithRowHeaderCell_ReturnsExpected(DataGridViewTriState columnResizable, bool expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Resizable = columnResizable
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, true)]
-    [InlineData(DataGridViewTriState.False, false)]
-    [InlineData(DataGridViewTriState.NotSet, false)]
-    public void DataGridViewHeaderCell_Resizable_GetColumnHeaderCellHeaderCell_ReturnsExpected(DataGridViewTriState columnResizable, bool expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Resizable = columnResizable
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(expected, cell.Resizable);
-    }
-
-    public static IEnumerable<object[]> Resizable_GetRowHeaderCellWithDataGridView_TestData()
-    {
-        foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-            {
-                foreach (DataGridViewTriState columnResizable in Enum.GetValues(typeof(DataGridViewTriState)))
-                {
-                    bool expected = rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, DataGridViewTriState.True, columnResizable, true };
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, DataGridViewTriState.False, columnResizable, expected };
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, DataGridViewTriState.NotSet, columnResizable, true };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_GetRowHeaderCellWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Resizable_GetWithDataGridView_ReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewTriState rowResizable, DataGridViewTriState columnResizable, bool expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        column.Resizable = columnResizable;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(expected, cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_GetRowHeaderCellWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Resizable_GetRowHeaderCellWithDataGridView_ReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewTriState rowResizable, DataGridViewTriState columnResizable, bool expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        column.Resizable = columnResizable;
-
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(expected, cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Resizable_GetColumnHeaderCellWithDataGridView_TestData()
-    {
-        foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-            {
-                foreach (DataGridViewTriState rowResizable in Enum.GetValues(typeof(DataGridViewTriState)))
-                {
-                    bool expected = columnHeadersHeightSizeMode == DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, rowResizable, DataGridViewTriState.True, true };
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, rowResizable, DataGridViewTriState.False, expected };
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, rowResizable, DataGridViewTriState.NotSet, true };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_GetColumnHeaderCellWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Resizable_GetColumnHeaderCellWithDataGridView_ReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewTriState rowResizable, DataGridViewTriState columnResizable, bool expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        column.Resizable = columnResizable;
-
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(expected, cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Resizable_GetTopLeftHeaderCell_TestData()
-    {
-        foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-            {
-                foreach (DataGridViewTriState rowResizable in Enum.GetValues(typeof(DataGridViewTriState)))
-                {
-                    bool expected = columnHeadersHeightSizeMode == DataGridViewColumnHeadersHeightSizeMode.EnableResizing || rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-                    yield return new object[] { columnHeadersHeightSizeMode, rowHeadersWidthSizeMode, expected };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_GetTopLeftHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_Resizable_GetTopLeftHeaderCell_ReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-
-        using var cell = new DataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell;
-        Assert.Equal(expected, cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewTriState>]
-    public void DataGridViewHeaderCell_Resizable_GetShared_ThrowsInvalidOperationException(DataGridViewTriState columnResizable)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Resizable = columnResizable;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None)]
-    [InlineData(DataGridViewElementStates.Selected)]
-    [InlineData(DataGridViewElementStates.Selected | DataGridViewElementStates.ReadOnly)]
-    [InlineData(DataGridViewElementStates.Selected | DataGridViewElementStates.Frozen)]
-    public void DataGridViewHeaderCell_Selected_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state)
-    {
-        using var cell = new CustomStateDataGridViewHeaderCell
-        {
-            StateResult = state
-        };
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Selected_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Selected_GetWithRowHeaderCell_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Selected_GetColumnHeaderCellHeaderCell_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewHeaderCell_Selected_GetWithDataGridView_ReturnsExpected(bool rowSelected, bool columnSelected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Selected = rowSelected;
-        column.Selected = columnSelected;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewHeaderCell_Selected_GetRowHeaderCellWithDataGridView_ReturnsExpected(bool rowSelected, bool columnSelected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Selected = rowSelected;
-        column.Selected = columnSelected;
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewHeaderCell_Selected_GetColumnHeaderCellWithDataGridView_ReturnsExpected(bool rowSelected, bool columnSelected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Selected = rowSelected;
-        column.Selected = columnSelected;
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Selected_GetTopLeftHeaderCell_ReturnsExpected()
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_GetShared_ReturnsExpected(bool columnSelected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Selected = columnSelected;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_Set_ThrowsInvalidOperationException(bool value)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetWithRow_ThrowsInvalidOperationException(bool value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetWithRowHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetColumnHeaderCellHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetRowHeaderCellWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetColumnHeaderCellWithDataGridView_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetTopLeftHeaderCell_ThrowsInvalidOperationException(bool value)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Selected_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-
-        Assert.Throws<InvalidOperationException>(() => cell.Selected = value);
-        Assert.False(cell.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ValueType_GetWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(typeof(object), cell.ValueType);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ValueType_GetWithRowHeaderCell_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(typeof(object), cell.ValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewHeaderCell_ValueType_GetColumnHeaderCellHeaderCell_ReturnsExpected(Type valueType)
-    {
-        using var column = new DataGridViewColumn
-        {
-            ValueType = valueType
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(typeof(object), cell.ValueType);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewHeaderCell_ValueType_GetWithDataGridView_ReturnsExpected(Type valueType)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            ValueType = valueType
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewHeaderCell_ValueType_GetRowHeaderCellWithDataGridView_ReturnsExpected(Type valueType)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            ValueType = valueType
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetTypeWithNullTheoryData))]
-    public void DataGridViewHeaderCell_ValueType_GetColumnHeaderCellWithDataGridView_ReturnsExpected(Type valueType)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            ValueType = valueType
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ValueType_GetTopLeftHeaderCell_ReturnsExpected()
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_Set_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cell = new DataGridViewHeaderCell
-        {
-            ValueType = value
-        };
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cell = new DataGridViewHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetWithRow_GetReturnsExpected(Type value, Type expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetWithRowWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        row.Cells.Add(cell);
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    public static IEnumerable<object[]> ValueType_SetColumnHeaderCellHeaderCell_TestData()
-    {
-        yield return new object[] { null, typeof(object) };
-        yield return new object[] { typeof(object), typeof(object) };
-        yield return new object[] { typeof(int), typeof(int) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetColumnHeaderCellHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_ValueType_SetWithRowHeaderCell_GetReturnsExpected(Type value, Type expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetColumnHeaderCellHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_ValueType_SetWithRowHeaderCellWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        row.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetColumnHeaderCellHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_ValueType_SetColumnHeaderCellHeaderCell_GetReturnsExpected(Type value, Type expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValueType_SetColumnHeaderCellHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_ValueType_SetColumnHeaderCellWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        column.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetWithDataGridView_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ValueType = typeof(string);
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetRowHeaderCellWithDataGridView_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetRowHeaderCellWithDataGridViewWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        cell.ValueType = typeof(string);
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetColumnHeaderCellWithDataGridView_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetColumnHeaderCellWithDataGridViewWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        cell.ValueType = typeof(string);
-
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetTopLeftHeaderCell_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cell = new DataGridViewHeaderCell
-        {
-            ValueType = value
-        };
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int), typeof(int))]
-    [InlineData(typeof(object), typeof(object))]
-    [InlineData(null, typeof(object))]
-    public void DataGridViewHeaderCell_ValueType_SetTopLeftHeaderCellWithNonNullOldValue_GetReturnsExpected(Type value, Type expected)
-    {
-        using var cell = new DataGridViewHeaderCell
-        {
-            ValueType = typeof(string)
-        };
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        cell.ValueType = value;
-        Assert.Equal(expected, cell.ValueType);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None)]
-    [InlineData(DataGridViewElementStates.Visible)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.ReadOnly)]
-    [InlineData(DataGridViewElementStates.Visible | DataGridViewElementStates.Selected)]
-    public void DataGridViewHeaderCell_Visible_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state)
-    {
-        using var cell = new CustomStateDataGridViewHeaderCell
-        {
-            StateResult = state
-        };
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Visible_GetWithRow_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(rowVisible, cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Visible_GetRowHeaderCell_ReturnsExpected(bool rowVisible)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = rowVisible
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(rowVisible, row.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Visible_GetColumnHeaderCell_ReturnsExpected(bool columnVisible)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Visible = columnVisible
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(columnVisible, cell.Visible);
-    }
-
-    public static IEnumerable<object[]> Visible_GetWithDataGridView_TestData()
-    {
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                foreach (bool rowVisible in new bool[] { true, false })
-                {
-                    foreach (bool columnVisible in new bool[] { true, false })
-                    {
-                        yield return new object[] { rowHeadersVisible, columnHeadersVisible, rowVisible, columnVisible };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Visible_GetWithDataGridView_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        column.Visible = columnVisible;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(rowVisible && rowHeadersVisible, cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Visible_GetRowHeaderCellWithDataGridView_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        column.Visible = columnVisible;
-
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(rowVisible && rowHeadersVisible, cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_Visible_GetColumnHeaderCellWithDataGridView_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible, bool rowVisible, bool columnVisible)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.Columns.Add(column);
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row = control.Rows[0];
-        row.Visible = rowVisible;
-        column.Visible = columnVisible;
-
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(columnVisible && columnHeadersVisible, cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_GetTopLeftHeaderCell_TestData()
-    {
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                yield return new object[] { rowHeadersVisible, columnHeadersVisible };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_GetTopLeftHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_Visible_GetTopLeftHeaderCell_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible,
-            TopLeftHeaderCell = cell
-        };
-
-        Assert.Equal(rowHeadersVisible && columnHeadersVisible, cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewHeaderCell_Visible_GetShared_ThrowsInvalidOperationException(bool columnVisible)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        column.Visible = columnVisible;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Throws<InvalidOperationException>(() => cell.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Clone_NonEmpty_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        using var source = new DataGridViewHeaderCell
-        {
-            ContextMenuStrip = menu,
-            ErrorText = "errorText",
-            Style = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft },
-            Tag = "tag",
-            ToolTipText = "toolTipText",
-            Value = "value",
-            ValueType = typeof(int)
-        };
-
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewHeaderCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.False(menu.IsDisposed);
-        Assert.NotNull(cell.ContextMenuStrip);
-        Assert.NotSame(source.ContextMenuStrip, cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.True(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.True(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft }, cell.Style);
-        Assert.NotSame(source.Style, cell.Style);
-        Assert.Equal("tag", cell.Tag);
-        Assert.Equal("toolTipText", cell.ToolTipText);
-        Assert.Equal("value", cell.Value);
-        Assert.Equal(typeof(int), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Clone_Empty_Success()
-    {
-        using var source = new DataGridViewHeaderCell();
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewHeaderCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Empty(cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.False(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.True(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle(), cell.Style);
-        Assert.Null(cell.Tag);
-        Assert.Empty(cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Clone_NonEmptySubclass_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        using var source = new SubDataGridViewHeaderCell
-        {
-            ContextMenuStrip = menu,
-            ErrorText = "errorText",
-            Style = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft },
-            Tag = "tag",
-            ToolTipText = "toolTipText",
-            Value = "value",
-            ValueType = typeof(int)
-        };
-
-        SubDataGridViewHeaderCell cell = Assert.IsType<SubDataGridViewHeaderCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.False(menu.IsDisposed);
-        Assert.NotNull(cell.ContextMenuStrip);
-        Assert.NotSame(source.ContextMenuStrip, cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Equal("errorText", cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.True(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.True(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft }, cell.Style);
-        Assert.NotSame(source.Style, cell.Style);
-        Assert.Equal("tag", cell.Tag);
-        Assert.Equal("toolTipText", cell.ToolTipText);
-        Assert.Equal("value", cell.Value);
-        Assert.Equal(typeof(int), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Clone_EmptySubclass_Success()
-    {
-        using var source = new SubDataGridViewHeaderCell();
-        SubDataGridViewHeaderCell cell = Assert.IsType<SubDataGridViewHeaderCell>(source.Clone());
-        Assert.Equal(DataGridViewElementStates.None, cell.State);
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(-1, cell.ColumnIndex);
-        Assert.Null(cell.OwningColumn);
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Null(cell.OwningRow);
-
-        Assert.Null(cell.ContextMenuStrip);
-        Assert.Equal(Rectangle.Empty, cell.ContentBounds);
-        Assert.Null(cell.DefaultNewRowValue);
-        Assert.Null(cell.EditedFormattedValue);
-        Assert.Equal(typeof(DataGridViewTextBoxEditingControl), cell.EditType);
-        Assert.Empty(cell.ErrorText);
-        Assert.Null(cell.FormattedValue);
-        Assert.Equal(typeof(string), cell.FormattedValueType);
-        Assert.False(cell.Frozen);
-        Assert.False(cell.HasStyle);
-        Assert.False(cell.IsInEditMode);
-        Assert.Equal(new Size(-1, -1), cell.PreferredSize);
-        Assert.True(cell.ReadOnly);
-        Assert.False(cell.Resizable);
-        Assert.Equal(new Size(-1, -1), cell.Size);
-        Assert.False(cell.Selected);
-        Assert.Equal(new DataGridViewCellStyle(), cell.Style);
-        Assert.Null(cell.Tag);
-        Assert.Empty(cell.ToolTipText);
-        Assert.Null(cell.Value);
-        Assert.Equal(typeof(object), cell.ValueType);
-        Assert.False(cell.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        Assert.Null(cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithMenu_ReturnsExpected(int rowIndex)
-    {
-        using var cellMenu = new ContextMenuStrip();
-        using var cell = new DataGridViewHeaderCell
-        {
-            ContextMenuStrip = cellMenu
-        };
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    public static IEnumerable<object[]> GetInheritedContextMenuStrip_TestData()
-    {
-        yield return new object[] { -2, null };
-        yield return new object[] { -2, new ContextMenuStrip() };
-        yield return new object[] { -1, null };
-        yield return new object[] { -1, new ContextMenuStrip() };
-        yield return new object[] { 0, null };
-        yield return new object[] { 0, new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedContextMenuStrip_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithRow_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedContextMenuStrip_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithMenuWithRow_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        using var cellMenu = new ContextMenuStrip();
-        using var cell = new DataGridViewHeaderCell
-        {
-            ContextMenuStrip = cellMenu
-        };
-        row.Cells.Add(cell);
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_GetWithDataGridView_TestData()
-    {
-        yield return new object[] { -2, null };
-        yield return new object[] { -2, new ContextMenuStrip() };
-        yield return new object[] { -1, null };
-        yield return new object[] { -1, new ContextMenuStrip() };
-        yield return new object[] { 0, null };
-        yield return new object[] { 0, new ContextMenuStrip() };
-        yield return new object[] { 1, null };
-        yield return new object[] { 1, new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithDataGridView_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(rowIndex));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithMenuWithDataGridView_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        using var cellMenu = new ContextMenuStrip();
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = cellMenu;
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeTopLeftHeaderCell_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        using var cell = new DataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell;
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(rowIndex));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeTopLeftHeaderCellWithMenu_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-
-        using var cellMenu = new ContextMenuStrip();
-        using var cell = new DataGridViewHeaderCell
-        {
-            ContextMenuStrip = cellMenu
-        };
-        control.TopLeftHeaderCell = cell;
-        Assert.Same(cellMenu, cell.GetInheritedContextMenuStrip(rowIndex));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_GetWithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeShared_ReturnsExpected(int rowIndex, ContextMenuStrip menu)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            ContextMenuStrip = menu
-        };
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        int callCount = 0;
-        control.CellContextMenuStripNeeded += (sender, e) => callCount++;
-        Assert.Same(menu, cell.GetInheritedContextMenuStrip(rowIndex));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithDataGridViewVirtualMode_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedContextMenuStrip_InvokeWithDataGridViewDataSource_CallsCellContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        cell.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewCellContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.CellContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.CellContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, cell.GetInheritedContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_Invoke_ReturnsExpected()
-    {
-        using var cell = new DataGridViewHeaderCell();
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.False, DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewElementStates.ResizableSet)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRowCustomState_ReturnsExpected(DataGridViewTriState resizable, DataGridViewElementStates expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = true,
-            ReadOnly = true,
-            Visible = false,
-            Resizable = resizable
-        };
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | expected, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCell_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewTriState.True, DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.False, DataGridViewElementStates.ResizableSet)]
-    [InlineData(DataGridViewTriState.NotSet, DataGridViewElementStates.ResizableSet)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCellCustomState_ReturnsExpected(DataGridViewTriState resizable, DataGridViewElementStates expected)
-    {
-        using var column = new DataGridViewColumn
-        {
-            Frozen = true,
-            ReadOnly = true,
-            Visible = false,
-            Resizable = resizable
-        };
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | expected, cell.GetInheritedState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithDataGrid_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_DataGridViewCustomState_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomState_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithDataGridCustomState_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRowHeaderCell_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomState_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRowHeaderCellCustomState_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCellHeaderCell_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible, cell.GetInheritedState(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_ColumnHeaderCellCustomState_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_ColumnHeaderCellCustomState_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCellHeaderCellCustomState_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_TopLeftHeaderCell_TestData()
-    {
-        foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-        {
-            foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-            {
-                DataGridViewElementStates expected = rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.EnableResizing || columnHeadersHeightSizeMode == DataGridViewColumnHeadersHeightSizeMode.EnableResizing ? DataGridViewElementStates.Resizable : (DataGridViewElementStates)0;
-                yield return new object[] { rowHeadersWidthSizeMode, true, columnHeadersHeightSizeMode, true, DataGridViewElementStates.Visible | expected };
-                yield return new object[] { rowHeadersWidthSizeMode, true, columnHeadersHeightSizeMode, false, expected };
-                yield return new object[] { rowHeadersWidthSizeMode, false, columnHeadersHeightSizeMode, false, expected };
-                yield return new object[] { rowHeadersWidthSizeMode, false, columnHeadersHeightSizeMode, false, expected };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_TopLeftHeaderCell_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeTopLeftHeaderCell_ReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, bool columnHeadersVisible, DataGridViewElementStates expected)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.TopLeftHeaderCell = cell;
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithDataGridWithHandle_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_DataGridViewCustomStateWithHandle_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomStateWithHandle_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithDataGridCustomStateWithHandle_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewCell cell = row.Cells[0];
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRowHeaderCellWithHandle_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_DataGridViewCustomStateWithHandle_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeWithRowHeaderCellCustomStateWithHandle_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCellHeaderCellWithHandle_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Resizable | DataGridViewElementStates.ResizableSet | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed, cell.GetInheritedState(-1));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetInheritedState_ColumnHeaderCellCustomStateWithHandle_TestData()
-    {
-        // Frozen.
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, true, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, true, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | DataGridViewElementStates.Frozen };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-
-        // Visible.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, false, DataGridViewTriState.True, false, false, DataGridViewElementStates.Resizable };
-
-        // Resizable.
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.True, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.False, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.True, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.False, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-        yield return new object[] { DataGridViewTriState.NotSet, false, true, DataGridViewTriState.NotSet, false, true, DataGridViewElementStates.Resizable | DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_ColumnHeaderCellCustomStateWithHandle_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeColumnHeaderCellHeaderCellCustomStateWithHandle_ReturnsExpected(DataGridViewTriState rowResizable, bool rowFrozen, bool rowVisible, DataGridViewTriState columnResizable, bool columnFrozen, bool columnVisible, DataGridViewElementStates expected)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = rowResizable;
-        row.Frozen = rowFrozen;
-        row.Visible = rowVisible;
-        column.Resizable = columnResizable;
-        column.Frozen = columnFrozen;
-        column.Visible = columnVisible;
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(-1));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-#if false
-    public static IEnumerable<object[]> GetInheritedState_TopLeftHeaderCellWithHandle_TestData()
-    {
-        foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-        {
-            foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-            {
-                DataGridViewElementStates expected = rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.EnableResizing || columnHeadersHeightSizeMode == DataGridViewColumnHeadersHeightSizeMode.EnableResizing ? DataGridViewElementStates.Resizable : (DataGridViewElementStates)0;
-                yield return new object[] { rowHeadersWidthSizeMode, true, columnHeadersHeightSizeMode, true, DataGridViewElementStates.Visible | DataGridViewElementStates.Displayed | expected };
-                yield return new object[] { rowHeadersWidthSizeMode, true, columnHeadersHeightSizeMode, false, expected };
-                yield return new object[] { rowHeadersWidthSizeMode, false, columnHeadersHeightSizeMode, false, expected };
-                yield return new object[] { rowHeadersWidthSizeMode, false, columnHeadersHeightSizeMode, false, expected };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetInheritedState_TopLeftHeaderCellWithHandle_TestData))]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeTopLeftHeaderCellWithHandle_ReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode, bool columnHeadersVisible, DataGridViewElementStates expected)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersHeightSizeMode = columnHeadersHeightSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.TopLeftHeaderCell = cell;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly | DataGridViewElementStates.ResizableSet | expected, cell.GetInheritedState(-1));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-#endif
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetInheritedState_InvokeSharedRow_ThrowsArgumentException()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexWithRow_ThrowsArgumentException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexRowHeaderCell_ThrowsArgumentException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexColumnHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexWithDataGridView_ThrowsArgumentException(int rowIndex)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexRowHeaderCellWithDataGridView_ThrowsArgumentException(int rowIndex)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexColumnHeaderCellWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexTopLeftHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cell = new DataGridViewHeaderCell();
-        using var control = new DataGridView();
-        control.TopLeftHeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetInheritedState_InvalidRowIndexShared_ThrowsArgumentException(int rowIndex)
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentException>("rowIndex", () => cell.GetInheritedState(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_Invoke_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(new Size(-1, -1), cell.GetSize(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal(new Size(-1, -1), cell.GetSize(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeRowHeaderCell_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(new Size(-1, -1), cell.GetSize(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeColumnHeaderCell_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(new Size(-1, -1), cell.GetSize(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersWidth = 20,
-            ColumnHeadersHeight = 25
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Height = 11;
-
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)row.Cells[0];
-        Assert.Equal(new Size(10, 25), cell.GetSize(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeRowHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersWidth = 20,
-            ColumnHeadersHeight = 25
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Height = 11;
-
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Equal(new Size(20, 11), cell.GetSize(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeColumnHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersWidth = 20,
-            ColumnHeadersHeight = 25
-        };
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        row.Height = 11;
-
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal(new Size(10, 25), cell.GetSize(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeTopLeftHeaderCell_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersWidth = 20,
-            ColumnHeadersHeight = 25,
-            TopLeftHeaderCell = cell
-        };
-        Assert.Equal(new Size(20, 25), cell.GetSize(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetSize_InvokeShared_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView
-        {
-            RowHeadersWidth = 20,
-            ColumnHeadersHeight = 25
-        };
-        control.Columns.Add(column);
-
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Equal(new Size(10, 25), cell.GetSize(-1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndexWithRow_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndexRowHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndexColumnHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetSize_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetSize(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_Invoke_ReturnsExpected()
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValue_ReturnsExpected()
-    {
-        var value = new object();
-        using var cell = new SubDataGridViewHeaderCell
-        {
-            Value = value
-        };
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueWithRow_ReturnsExpected()
-    {
-        var value = new object();
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell
-        {
-            Value = value
-        };
-        row.Cells.Add(cell);
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvokeRowHeaderCell_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Null(cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueRowHeaderCell_ReturnsExpected(int rowIndex)
-    {
-        var value = new object();
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewRowHeaderCell
-        {
-            Value = value
-        };
-        row.HeaderCell = cell;
-        Assert.Same(value, cell.GetValue(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeColumnHeaderCell_ReturnsExpected()
-    {
-        using var row = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Empty((string)cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueColumnHeaderCell_ReturnsExpected()
-    {
-        var value = new object();
-        using var row = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell
-        {
-            Value = value
-        };
-        row.HeaderCell = cell;
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        var value = new object();
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.Value = value);
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeRowHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueRowHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewRow row = control.Rows[0];
-        using var cell = new SubDataGridViewRowHeaderCell();
-        row.HeaderCell = cell;
-        var value = new object();
-        cell.Value = value;
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeColumnHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Empty((string)cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueColumnHeaderCellWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate,
-            Width = 10
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        var value = new object();
-        cell.Value = value;
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeTopLeftHeaderCell_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var cell = new SubDataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell;
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithValueTopLeftHeaderCell_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var cell = new SubDataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell;
-        var value = new object();
-        cell.Value = value;
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeShared_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Null(cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeSharedWithValue_ReturnsExpected()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows.SharedRow(0).Cells[0];
-        var value = new object();
-        cell.Value = value;
-        Assert.Same(value, cell.GetValue(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithDataGridViewVirtualMode_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        control.Rows.Add();
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.Value = value1);
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithDataGridViewNewRowVirtualMode_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            VirtualMode = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.Value = value1);
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_GetValue_InvokeWithDataGridViewNewRowDataSource_CallsCellValueNeeded()
-    {
-        var value1 = new object();
-        var value2 = new object();
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        control.Columns.Add(column);
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.Value = value1);
-
-        int callCount = 0;
-        DataGridViewCellValueEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Null(e.Value);
-            e.Value = value2;
-        };
-        control.CellValueNeeded += handler;
-
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-
-        // Remove the handler.
-        control.CellValueNeeded -= handler;
-        Assert.Null(cell.GetValue(-1));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvokeInvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvokeInvalidRowIndexWithRow_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvokeInvalidColumnIndexColumnHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvalidRowIndexWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvalidRowIndexColumnHeaderCellWithDataGridView_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        using var cell = new SubDataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvalidRowIndexTopLeftHeaderCell_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            TopLeftHeaderCell = cell
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_GetValue_InvalidRowIndexShared_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows.SharedRow(0).Cells[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.GetValue(rowIndex));
-    }
-
-    public static IEnumerable<object[]> MouseDownUnsharesRow_TestData()
-    {
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        //yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseDownUnsharesRow_TestData))]
-    public void DataGridViewHeaderCell_MouseDownUnsharesRow_Invoke_ReturnsFalse(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.False(cell.MouseDownUnsharesRow(e));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    public static IEnumerable<object[]> MouseDownUnsharesRow_WithDataGridView_TestData()
-    {
-        foreach (bool enableHeadersVisualStyles in new bool[] { true, false })
-        {
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), false };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), false };
-        }
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_MouseDownUnsharesRow_InvokeWithDataGridView_ReturnsExpected()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] testData in MouseDownUnsharesRow_WithDataGridView_TestData())
-            {
-                bool enableHeadersVisualStyles = (bool)testData[0];
-                DataGridViewCellMouseEventArgs e = (DataGridViewCellMouseEventArgs)testData[1];
-                bool expected = (bool)testData[2];
-
-                Application.EnableVisualStyles();
-
-                using var cellTemplate = new SubDataGridViewHeaderCell();
-                using var column = new DataGridViewColumn
-                {
-                    CellTemplate = cellTemplate
-                };
-                using var control = new DataGridView
-                {
-                    EnableHeadersVisualStyles = enableHeadersVisualStyles
-                };
-                control.Columns.Add(column);
-                SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-                Assert.Equal(expected, cell.MouseDownUnsharesRow(e));
-                Assert.Equal(ButtonState.Normal, cell.ButtonState);
-                Assert.False(control.IsHandleCreated);
-            }
-        }).Dispose();
-    }
-
-    public static IEnumerable<object[]> MouseDownUnsharesRow_ButtonLeftNullDataGridView_TestData()
-    {
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseDownUnsharesRow_ButtonLeftNullDataGridView_TestData))]
-    public void DataGridViewHeaderCell_MouseDownUnsharesRow_ButtonLeftNullDataGridView_ThrowsNullReferenceException(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<NullReferenceException>(() => cell.MouseDownUnsharesRow(e));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_MouseDownUnsharesRow_NullE_ThrowsNullReferenceException()
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<NullReferenceException>(() => cell.MouseDownUnsharesRow(null));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_MouseEnterUnsharesRow_InvokeWithoutDataGridView_ThrowsNullReferenceException(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<NullReferenceException>(() => cell.MouseEnterUnsharesRow(rowIndex));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewHeaderCell_MouseEnterUnsharesRow_InvokeWithDataGridView_ReturnsExpected(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseEnterUnsharesRow(rowIndex));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_MouseLeaveUnsharesRow_InvokeWithoutDataGridView_ReturnsFalse(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.False(cell.MouseLeaveUnsharesRow(rowIndex));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -2)]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewHeaderCell_MouseLeaveUnsharesRow_InvokeWithDataGridView_ReturnsExpected(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.False(cell.MouseLeaveUnsharesRow(rowIndex));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MouseLeaveUnsharesRow_WithDataGridViewMouseDown_TestData()
-    {
-        ButtonState expected = VisualStyleRenderer.IsSupported ? ButtonState.Pushed : ButtonState.Normal;
-        yield return new object[] { true, -2, expected };
-        yield return new object[] { true, -1, expected };
-        yield return new object[] { true, 0, expected };
-        yield return new object[] { true, 1, expected };
-        yield return new object[] { false, -2, ButtonState.Normal };
-        yield return new object[] { false, -1, ButtonState.Normal };
-        yield return new object[] { false, 0, ButtonState.Normal };
-        yield return new object[] { false, 1, ButtonState.Normal };
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [MemberData(nameof(MouseLeaveUnsharesRow_WithDataGridViewMouseDown_TestData))]
-    public void DataGridViewHeaderCell_MouseLeaveUnsharesRow_InvokeWithDataGridViewMouseDown_ReturnsExpected(bool enableHeadersVisualStylesParam, int rowIndexParam, ButtonState expectedButtonStateParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((enableHeadersVisualStylesString, rowIndexString, expectedButtonStateString) =>
-        {
-            bool enableHeadersVisualStyles = bool.Parse(enableHeadersVisualStylesString);
-            int rowIndex = int.Parse(rowIndexString);
-            ButtonState expectedButtonState = (ButtonState)Enum.Parse(typeof(ButtonState), expectedButtonStateString);
-
-            Application.EnableVisualStyles();
-
-            using var cellTemplate = new SubDataGridViewHeaderCell();
-            using var column = new DataGridViewColumn
-            {
-                CellTemplate = cellTemplate
-            };
-            using var control = new DataGridView
-            {
-                EnableHeadersVisualStyles = enableHeadersVisualStyles
-            };
-            control.Columns.Add(column);
-            SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-            cell.OnMouseDown(new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)));
-            Assert.Equal(enableHeadersVisualStyles && VisualStyleRenderer.IsSupported, cell.MouseLeaveUnsharesRow(rowIndex));
-            Assert.Equal(expectedButtonState, cell.ButtonState);
-            Assert.False(control.IsHandleCreated);
-        }, enableHeadersVisualStylesParam.ToString(), rowIndexParam.ToString(), expectedButtonStateParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseDownUnsharesRow_TestData))]
-    public void DataGridViewHeaderCell_MouseUpUnsharesRow_Invoke_ReturnsFalse(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.False(cell.MouseUpUnsharesRow(e));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_MouseUpUnsharesRow_InvokeWithDataGridView_ReturnsExpected()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] testData in MouseDownUnsharesRow_WithDataGridView_TestData())
-            {
-                bool enableHeadersVisualStyles = (bool)testData[0];
-                DataGridViewCellMouseEventArgs e = (DataGridViewCellMouseEventArgs)testData[1];
-                bool expected = (bool)testData[2];
-
-                Application.EnableVisualStyles();
-
-                using var cellTemplate = new SubDataGridViewHeaderCell();
-                using var column = new DataGridViewColumn
-                {
-                    CellTemplate = cellTemplate
-                };
-                using var control = new DataGridView
-                {
-                    EnableHeadersVisualStyles = enableHeadersVisualStyles
-                };
-                control.Columns.Add(column);
-                SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-                Assert.Equal(expected, cell.MouseUpUnsharesRow(e));
-                Assert.Equal(ButtonState.Normal, cell.ButtonState);
-                Assert.False(control.IsHandleCreated);
-            }
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_MouseUpUnsharesRow_NullE_ThrowsNullReferenceException()
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<NullReferenceException>(() => cell.MouseUpUnsharesRow(null));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseDownUnsharesRow_ButtonLeftNullDataGridView_TestData))]
-    public void DataGridViewHeaderCell_MouseUpUnsharesRow_ButtonLeftNullDataGridView_ThrowsNullReferenceException(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        Assert.Throws<NullReferenceException>(() => cell.MouseUpUnsharesRow(e));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-        yield return new object[] { new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void DataGridViewHeaderCell_OnMouseDown_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        cell.OnMouseDown(e);
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_WithDataGridView_TestData()
-    {
-        foreach (bool enableHeadersVisualStyles in new bool[] { true, false })
-        {
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles ? ButtonState.Pushed : ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles ? ButtonState.Pushed : ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles ? ButtonState.Pushed : ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles ? ButtonState.Pushed : ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), VisualStyleRenderer.IsSupported && enableHeadersVisualStyles ? ButtonState.Pushed : ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), ButtonState.Normal };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), ButtonState.Normal };
-        }
-
-        yield return new object[] { false, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), ButtonState.Normal };
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_OnMouseDown_InvokeWithDataGridView_Nop()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] testData in OnMouseDown_WithDataGridView_TestData())
-            {
-                bool enableHeadersVisualStyles = (bool)testData[0];
-                DataGridViewCellMouseEventArgs e = (DataGridViewCellMouseEventArgs)testData[1];
-                ButtonState expectedButtonState = (ButtonState)testData[2];
-
-                Application.EnableVisualStyles();
-
-                using var cellTemplate = new SubDataGridViewHeaderCell();
-                using var column = new DataGridViewColumn
-                {
-                    CellTemplate = cellTemplate
-                };
-                using var control = new DataGridView
-                {
-                    EnableHeadersVisualStyles = enableHeadersVisualStyles
-                };
-                control.Columns.Add(column);
-                SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-                cell.OnMouseDown(e);
-                Assert.Equal(expectedButtonState, cell.ButtonState);
-                Assert.False(control.IsHandleCreated);
-            }
-        }).Dispose();
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_OnMouseDown_InvalidRowIndexVisualStyles_ThrowsArgumentOutOfRangeException()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-
-            using var cellTemplate = new SubDataGridViewHeaderCell();
-            using var column = new DataGridViewColumn
-            {
-                CellTemplate = cellTemplate
-            };
-            using var control = new DataGridView
-            {
-                EnableHeadersVisualStyles = true
-            };
-            control.Columns.Add(column);
-            SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-            var e = new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0));
-            Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.OnMouseDown(e));
-            Assert.Equal(VisualStyleRenderer.IsSupported ? ButtonState.Pushed : ButtonState.Normal, cell.ButtonState);
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_OnMouseDown_NullEWithDataGridView_ThrowsNullReferenceException()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<NullReferenceException>(() => cell.OnMouseDown(null));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_OnMouseEnter_Invoke_Nop(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        cell.OnMouseEnter(rowIndex);
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    // [InlineData(true, -2)] If a datagridview is rendered with visual styles, mouse entering a header cell will lead to a ArgumentOutOfRangeException
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    // [InlineData(true, 1)] If a datagridview is rendered with visual styles, mouse entering a header cell will lead to a ArgumentOutOfRangeException
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewHeaderCell_OnMouseEnter_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        cell.OnMouseEnter(rowIndex);
-
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_OnMouseEnter_VisualStyles_on_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseEnter(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_OnMouseLeave_Invoke_Nop(int rowIndex)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        cell.OnMouseLeave(rowIndex);
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsTheory]
-    //[InlineData(true, -2)] If a datagridview is rendered with visual styles, mouse leaving a header cell will lead to a ArgumentOutOfRangeException
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    //[InlineData(true, 1)] If a datagridview is rendered with visual styles, mouse leaving a header cell will lead to a ArgumentOutOfRangeException
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewHeaderCell_OnMouseLeave_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, int rowIndex)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        cell.OnMouseLeave(rowIndex);
-
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_OnMouseLeave_VisualStyles_on_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseLeave(rowIndex));
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(true, -1)]
-    [InlineData(true, 0)]
-    [InlineData(false, -2)]
-    [InlineData(false, -1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void DataGridViewHeaderCell_OnMouseLeave_InvokeWithDataGridViewMouseDown_Nop(bool enableHeadersVisualStylesParam, int rowIndexParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((enableHeadersVisualStylesString, rowIndexString) =>
-        {
-            bool enableHeadersVisualStyles = bool.Parse(enableHeadersVisualStylesString);
-            int rowIndex = int.Parse(rowIndexString);
-
-            Application.EnableVisualStyles();
-
-            using var cellTemplate = new SubDataGridViewHeaderCell();
-            using var column = new DataGridViewColumn
-            {
-                CellTemplate = cellTemplate
-            };
-            using var control = new DataGridView
-            {
-                EnableHeadersVisualStyles = enableHeadersVisualStyles
-            };
-            control.Columns.Add(column);
-            SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-            cell.OnMouseDown(new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)));
-            cell.OnMouseLeave(rowIndex);
-            Assert.Equal(ButtonState.Normal, cell.ButtonState);
-            Assert.False(control.IsHandleCreated);
-        }, enableHeadersVisualStylesParam.ToString(), rowIndexParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewHeaderCell_OnMouseLeave_InvalidRowIndexVisualStyles_ThrowsArgumentOutOfRangeException(int rowIndexParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((rowIndexString) =>
-        {
-            int rowIndex = int.Parse(rowIndexString);
-
-            Application.EnableVisualStyles();
-
-            using var cellTemplate = new SubDataGridViewHeaderCell();
-            using var column = new DataGridViewColumn
-            {
-                CellTemplate = cellTemplate
-            };
-            using var control = new DataGridView
-            {
-                EnableHeadersVisualStyles = true
-            };
-            control.Columns.Add(column);
-            SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-            cell.OnMouseDown(new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)));
-            Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.OnMouseLeave(rowIndex));
-            Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        }, rowIndexParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void DataGridViewHeaderCell_OnMouseUp_Invoke_Nop(DataGridViewCellMouseEventArgs e)
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        cell.OnMouseUp(e);
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_WithDataGridView_TestData()
-    {
-        foreach (bool enableHeadersVisualStyles in new bool[] { true, false })
-        {
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)) };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)) };
-        }
-
-        // If a datagridview is rendered with visual styles, a left click on a header cell will lead to a ArgumentOutOfRangeException
-        yield return new object[] { false, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_WithDataGridView_TestData))]
-    public void DataGridViewHeaderCell_OnMouseUp_InvokeWithDataGridView_Nop(bool enableHeadersVisualStyles, DataGridViewCellMouseEventArgs e)
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = enableHeadersVisualStyles
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        cell.OnMouseUp(e);
-
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_OnMouseUp_VisualStyles_on_ThrowsArgumentOutOfRangeException()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView
-        {
-            EnableHeadersVisualStyles = true
-        };
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-
-        var e = new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0));
-        Assert.Throws<ArgumentOutOfRangeException>(() => cell.OnMouseUp(e));
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_WithDataGridViewMouseDown_TestData()
-    {
-        foreach (bool enableHeadersVisualStyles in new bool[] { true, false })
-        {
-            ButtonState expectedButtonState1 = enableHeadersVisualStyles && VisualStyleRenderer.IsSupported ? ButtonState.Pushed : ButtonState.Normal;
-            ButtonState expectedButtonState2 = enableHeadersVisualStyles && VisualStyleRenderer.IsSupported ? ButtonState.Normal : expectedButtonState1;
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), expectedButtonState2 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), expectedButtonState2 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, -1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), expectedButtonState2 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(-1, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), expectedButtonState2 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 0, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(1, 0, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), expectedButtonState2 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0)), expectedButtonState1 };
-            yield return new object[] { enableHeadersVisualStyles, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Middle, 0, 0, 0, 0)), expectedButtonState1 };
-        }
-
-        yield return new object[] { false, new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)), ButtonState.Normal };
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_OnMouseUp_InvokeWithDataGridViewMouseDown_ReturnsExpected()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] testData in OnMouseUp_WithDataGridViewMouseDown_TestData())
-            {
-                bool enableHeadersVisualStyles = (bool)testData[0];
-                DataGridViewCellMouseEventArgs e = (DataGridViewCellMouseEventArgs)testData[1];
-                ButtonState expectedButtonState = (ButtonState)testData[2];
-
-                Application.EnableVisualStyles();
-
-                using var cellTemplate = new SubDataGridViewHeaderCell();
-                using var column = new DataGridViewColumn
-                {
-                    CellTemplate = cellTemplate
-                };
-                using var control = new DataGridView
-                {
-                    EnableHeadersVisualStyles = enableHeadersVisualStyles
-                };
-                control.Columns.Add(column);
-                SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-                cell.OnMouseDown(new DataGridViewCellMouseEventArgs(-1, -1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0)));
-                cell.OnMouseUp(e);
-                Assert.Equal(expectedButtonState, cell.ButtonState);
-                Assert.False(control.IsHandleCreated);
-            }
-        }).Dispose();
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public void DataGridViewHeaderCell_OnMouseUp_InvalidRowIndexVisualStyles_ThrowsArgumentOutOfRangeException()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-
-            using var cellTemplate = new SubDataGridViewHeaderCell();
-            using var column = new DataGridViewColumn
-            {
-                CellTemplate = cellTemplate
-            };
-            using var control = new DataGridView
-            {
-                EnableHeadersVisualStyles = true
-            };
-            control.Columns.Add(column);
-            SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-            var e = new DataGridViewCellMouseEventArgs(0, 1, 0, 0, new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0));
-            Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => cell.OnMouseUp(e));
-            Assert.Equal(ButtonState.Normal, cell.ButtonState);
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_OnMouseUp_NullEWithDataGridView_ThrowsNullReferenceException()
-    {
-        using var cellTemplate = new SubDataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        SubDataGridViewHeaderCell cell = (SubDataGridViewHeaderCell)control.Rows[0].Cells[0];
-        Assert.Throws<NullReferenceException>(() => cell.OnMouseUp(null));
-        Assert.Equal(ButtonState.Normal, cell.ButtonState);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_Paint_NullCellStyle_ThrowsArgumentNullException()
-    {
-        using var cell = new SubDataGridViewHeaderCell();
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Throws<ArgumentNullException>("cellStyle", () => cell.Paint(graphics, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, null, null, null, null, null, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ToString_Invoke_ReturnsExpected()
-    {
-        using var cell = new DataGridViewHeaderCell();
-        Assert.Equal("DataGridViewHeaderCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ToString_InvokeWithRow_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new DataGridViewHeaderCell();
-        row.Cells.Add(cell);
-        Assert.Equal("DataGridViewHeaderCell { ColumnIndex=-1, RowIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ToString_InvokeColumnHeaderCell_ReturnsExpected()
-    {
-        using var column = new DataGridViewColumn();
-        using var cell = new DataGridViewColumnHeaderCell();
-        column.HeaderCell = cell;
-        Assert.Equal("DataGridViewColumnHeaderCell { ColumnIndex=-1 }", cell.ToString());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewHeaderCell_ToString_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var cellTemplate = new DataGridViewHeaderCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        using var control = new DataGridView();
-        control.Columns.Add(column);
-        DataGridViewCell cell = control.Rows[0].Cells[0];
-        Assert.Equal("DataGridViewHeaderCell { ColumnIndex=0, RowIndex=0 }", cell.ToString());
-    }
-
-    private class SubDataGridViewRowHeaderCell : DataGridViewRowHeaderCell
-    {
-        public new Size GetSize(int rowIndex) => base.GetSize(rowIndex);
-
-        public new object GetValue(int rowIndex) => base.GetValue(rowIndex);
-    }
-
-    private class SubDataGridViewColumnHeaderCell : DataGridViewColumnHeaderCell
-    {
-        public new Size GetSize(int rowIndex) => base.GetSize(rowIndex);
-
-        public new object GetValue(int rowIndex) => base.GetValue(rowIndex);
-    }
-
-    private class CustomStateDataGridViewHeaderCell : DataGridViewHeaderCell
-    {
-        public DataGridViewElementStates StateResult { get; set; }
-
-        public override DataGridViewElementStates State => StateResult;
-    }
-
-    public class SubDataGridViewHeaderCell : DataGridViewHeaderCell
-    {
-        public new ButtonState ButtonState => base.ButtonState;
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new Size GetSize(int rowIndex) => base.GetSize(rowIndex);
-
-        public new object GetValue(int rowIndex) => base.GetValue(rowIndex);
-
-        public new bool MouseDownUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseDownUnsharesRow(e);
-
-        public new bool MouseEnterUnsharesRow(int rowIndex) => base.MouseEnterUnsharesRow(rowIndex);
-
-        public new bool MouseLeaveUnsharesRow(int rowIndex) => base.MouseLeaveUnsharesRow(rowIndex);
-
-        public new bool MouseUpUnsharesRow(DataGridViewCellMouseEventArgs e) => base.MouseUpUnsharesRow(e);
-
-        public new void OnMouseDown(DataGridViewCellMouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(int rowIndex) => base.OnMouseEnter(rowIndex);
-
-        public new void OnMouseLeave(int rowIndex) => base.OnMouseLeave(rowIndex);
-
-        public new void OnMouseUp(DataGridViewCellMouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void Paint(Graphics graphics,
-                              Rectangle clipBounds,
-                              Rectangle cellBounds,
-                              int rowIndex,
-                              DataGridViewElementStates dataGridViewElementState,
-                              object value,
-                              object formattedValue,
-                              string errorText,
-                              DataGridViewCellStyle cellStyle,
-                              DataGridViewAdvancedBorderStyle advancedBorderStyle,
-                              DataGridViewPaintParts paintParts)
-        {
-            base.Paint(graphics, clipBounds, cellBounds, rowIndex, dataGridViewElementState, value, formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewImageCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewImageCellAccessibleObjectTests.cs
deleted file mode 100644
index ec8ca9ab595..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewImageCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewImageCellAccessibleObjectTests : DataGridViewImageCell
-{
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.Equal(string.Empty, accessibleObject.DefaultAction);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_GetChildCount_Default()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        UiaCore.UIA expected = UiaCore.UIA.ImageControlTypeId;
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_IsInvokePatternAvailable_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsInvokePatternAvailablePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(((int)UiaCore.UIA.InvokePatternId))]
-    public void DataGridViewImageCellAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_Description_IsNull_IfOwnerIsNotImageCell()
-    {
-        var accessibleObject = new DataGridViewImageCellAccessibleObject(null);
-
-        Assert.Null(accessibleObject.Description);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_Description_ReturnsExpected()
-    {
-        string testDescription = "This is a test description string";
-        using DataGridViewImageCell cell = new();
-
-        cell.Description = testDescription;
-
-        Assert.Equal(testDescription, cell.AccessibilityObject.Description);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewImageCellAccessibleObject_DoDefaultAction_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(() =>
-        new DataGridViewImageCellAccessibleObject(null).DoDefaultAction());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewLinkCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewLinkCellAccessibleObjectTests.cs
deleted file mode 100644
index 7803399bd71..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewLinkCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewLinkCellAccessibleObjectTests : DataGridViewLinkCell
-{
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewLinkCellAccessibleObject(null);
-
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Cell, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewLinkCellAccessibleObject(null);
-
-        Assert.Equal(SR.DataGridView_AccLinkCellDefaultAction, accessibleObject.DefaultAction);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewLinkCellAccessibleObject(null);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewLinkCellAccessibleObject(null);
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewLinkCellAccessibleObject(null);
-
-        UiaCore.UIA expected = UiaCore.UIA.HyperlinkControlTypeId;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_DoDefaultAction_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(() =>
-        new DataGridViewLinkCellAccessibleObject(null).DoDefaultAction());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewLinkCellAccessibleObject_DoDefaultAction_ThrowsException_IfRowIndexIsIncorrect()
-    {
-        using DataGridViewLinkCell cell = new();
-
-        Assert.Equal(-1, cell.RowIndex);
-        Assert.Throws<InvalidOperationException>(() => cell.AccessibilityObject.DoDefaultAction());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowAccessibleObjectTests.cs
deleted file mode 100644
index 7528c223886..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowAccessibleObjectTests.cs
+++ /dev/null
@@ -1,2385 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowAccessibleObjectTests : DataGridViewRow
-{
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewRowAccessibleObject();
-
-        Assert.Null(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Row, accessibleObject.Role);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Help);
-    }
-
-    public static IEnumerable<object[]> Ctor_DataGridViewRow_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DataGridViewRow_TestData))]
-    public void DataGridViewRowAccessibleObject_Ctor_DataGridViewRow(DataGridViewRow owner)
-    {
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-
-        Assert.Equal(owner, accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.Row, accessibleObject.Role);
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Null(accessibleObject.Help);
-    }
-
-    public static IEnumerable<object[]> Bounds_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), Rectangle.Empty };
-    }
-
-    [Theory]
-    [MemberData(nameof(Bounds_TestData))]
-    public void DataGridViewRowAccessibleObject_Bounds_Get_ReturnsExpected(AccessibleObject accessibleObject, Rectangle expected)
-    {
-        Assert.Equal(expected, accessibleObject.Bounds);
-    }
-
-    public static IEnumerable<object[]> NoOwner_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject() };
-        yield return new object[] { new DataGridViewRowAccessibleObject(null) };
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Bounds_GetNoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Bounds);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Name_Get_ReturnsExpected_IfDataGridViewNotExist()
-    {
-        AccessibleObject accessibilityObject = new DataGridViewRowAccessibleObject(new DataGridViewRow());
-
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, -1), accessibilityObject.Name);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Name_Get_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 0), accessibleObject1.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 1), accessibleObject2.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 2), accessibleObject3.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Name_Get_ReturnsExpected_IfFirstRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, -1), accessibleObject1.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 0), accessibleObject2.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 1), accessibleObject3.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Name_Get_ReturnsExpected_IfSecondRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 0), accessibleObject1.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, -1), accessibleObject2.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 1), accessibleObject3.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Name_Get_ReturnsExpected_IfLastRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 0), accessibleObject1.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, 1), accessibleObject2.Name);
-        Assert.Equal(string.Format(SR.DataGridView_AccRowName, -1), accessibleObject3.Name);
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Name_GetNoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Name);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Owner_Set_GetReturnsExpected()
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject
-        {
-            Owner = owner
-        };
-        Assert.Same(owner, accessibleObject.Owner);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_Owner_SetAlreadyWithOwner_ThrowsInvalidOperationException()
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Owner = owner);
-    }
-
-    public static IEnumerable<object[]> Parent_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Parent_TestData))]
-    public void DataGridViewRowAccessibleObject_Parent_Get_ReturnsExpected(AccessibleObject accessibleObject, AccessibleObject expected)
-    {
-        Assert.Same(expected, accessibleObject.Parent);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Parent_GetNoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Parent);
-    }
-
-    public static IEnumerable<object[]> State_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), AccessibleStates.Selected | AccessibleStates.Selectable };
-    }
-
-    [Theory]
-    [MemberData(nameof(State_TestData))]
-    public void DataGridViewRowAccessibleObject_State_Get_ReturnsExpected(AccessibleObject accessibleObject, AccessibleStates expected)
-    {
-        Assert.Equal(expected, accessibleObject.State);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_State_GetNoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.State);
-    }
-
-    public static IEnumerable<object[]> Value_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), string.Empty };
-    }
-
-    [Theory]
-    [MemberData(nameof(Value_TestData))]
-    public void DataGridViewRowAccessibleObject_Value_Get_ReturnsExpected(AccessibleObject accessibleObject, string expected)
-    {
-        Assert.Equal(expected, accessibleObject.Value);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Value_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Value);
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_DoDefaultAction_Invoke_Nop()
-    {
-        var accessibleObject = new DataGridViewRowAccessibleObject();
-        accessibleObject.DoDefaultAction();
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_GetChild_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChild(0));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewRowAccessibleObject_GetChild_NoDataGridView_ReturnsNull(int index)
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-
-        Assert.Null(accessibleObject.GetChild(index));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void DataGridViewRowAccessibleObject_GetChild_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var accessibleObject = new DataGridViewRowAccessibleObject();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => accessibleObject.GetChild(index));
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_GetChildCount_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChildCount());
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_NoDataGridView_ReturnsZero()
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_GetFocused_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetFocused());
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_GetFocused_NoDataGridView_ReturnsNull()
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-        Assert.Null(accessibleObject.GetFocused());
-    }
-
-    [Fact]
-    public void DataGridViewRowAccessibleObject_GetSelected_Invoke_ReturnsSameInstance()
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-        Assert.Same(accessibleObject.GetSelected(), accessibleObject.GetSelected());
-
-        AccessibleObject selectedAccessibleObject = accessibleObject.GetSelected();
-
-        Assert.Equal("Selected Row Cells", selectedAccessibleObject.Name);
-        Assert.Equal(owner.AccessibilityObject, selectedAccessibleObject.Parent);
-        Assert.Equal(AccessibleRole.Grouping, selectedAccessibleObject.Role);
-        Assert.Equal(AccessibleStates.Selected | AccessibleStates.Selectable, selectedAccessibleObject.State);
-        Assert.Equal("Selected Row Cells", selectedAccessibleObject.Value);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_GetSelected_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetSelected());
-    }
-
-    public static IEnumerable<object[]> Navigate_TestData()
-    {
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), (AccessibleNavigation)(AccessibleNavigation.Up - 1), null };
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), (AccessibleNavigation)(AccessibleNavigation.LastChild + 1), null };
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), AccessibleNavigation.Left, null };
-        yield return new object[] { new DataGridViewRowAccessibleObject(new DataGridViewRow()), AccessibleNavigation.Right, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Navigate_TestData))]
-    public void DataGridViewRowAccessibleObject_Navigate_Invoke_ReturnsExpected(AccessibleObject accessibleObject, AccessibleNavigation navigationDirection, AccessibleObject expected)
-    {
-        Assert.Equal(expected, accessibleObject.Navigate(navigationDirection));
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Navigate_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Navigate(AccessibleNavigation.Right));
-    }
-
-    [Theory]
-    [InlineData(AccessibleNavigation.Down)]
-    [InlineData(AccessibleNavigation.FirstChild)]
-    [InlineData(AccessibleNavigation.LastChild)]
-    [InlineData(AccessibleNavigation.Next)]
-    [InlineData(AccessibleNavigation.Previous)]
-    [InlineData(AccessibleNavigation.Up)]
-    public void DataGridViewRowAccessibleObject_Navigate_NoDataGridView_ThrowsNullReferenceException(AccessibleNavigation navigationDirection)
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-
-        Assert.Null(accessibleObject.Navigate(navigationDirection));
-    }
-
-    [Theory]
-    [InlineData(AccessibleSelection.None)]
-    [InlineData(AccessibleSelection.TakeSelection)]
-    [InlineData(AccessibleSelection.AddSelection)]
-    [InlineData(AccessibleSelection.AddSelection | AccessibleSelection.RemoveSelection)]
-    [InlineData(AccessibleSelection.TakeSelection | AccessibleSelection.RemoveSelection)]
-    [InlineData(AccessibleSelection.RemoveSelection)]
-    [InlineData(AccessibleSelection.TakeFocus)]
-    public void DataGridViewRowAccessibleObject_Select_NoDataGridView_Nop(AccessibleSelection flags)
-    {
-        using var owner = new DataGridViewRow();
-        var accessibleObject = new DataGridViewRowAccessibleObject(owner);
-
-        accessibleObject.Select(flags);
-    }
-
-    [Theory]
-    [MemberData(nameof(NoOwner_TestData))]
-    public void DataGridViewRowAccessibleObject_Select_NoOwner_ThrowsInvalidOperationException(AccessibleObject accessibleObject)
-    {
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.Select(AccessibleSelection.None));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentRoot_ReturnsNull_WithoutDataGridView()
-    {
-        using DataGridViewRow dataGridViewRow = new();
-
-        Assert.Null(dataGridViewRow.AccessibilityObject.FragmentRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_IsEnabled_ReturnsFalse_WithoutDataGridView()
-    {
-        using DataGridViewRow dataGridViewRow = new();
-        bool actualValue = (bool)dataGridViewRow.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId);
-
-        Assert.False(actualValue);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfFirstRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfSecondRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfLastRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfFirstRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfSecondRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfLastRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfFirstRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfSecondRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfLastRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject4, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfFirstRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfSecondRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfLastRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfFirstRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfSecondRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfLastRowHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfFirstRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfSecondRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfLastRowAndSpecialRowHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false, AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfFirstRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfSecondRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject3.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject3, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfLastRowAndColumnHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { ColumnHeadersVisible = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject4 = dataGridView.Rows[3].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject4, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject4.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject4.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfFirstRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject2.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject2, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfSecondRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject3, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject3.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject3.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Sibling_ReturnExpected_IfLastRowAndUserRowHidden()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        dataGridView.Rows.Add("1");
-        dataGridView.Rows.Add("2");
-        dataGridView.Rows.Add("3");
-        dataGridView.Rows[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.Next));
-        Assert.Equal(accessibleObject2, accessibleObject1.Navigate(AccessibleNavigation.Next));
-        Assert.Null(accessibleObject2.Navigate(AccessibleNavigation.Next));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.Navigate(AccessibleNavigation.Previous));
-        Assert.Equal(topRowAccessibleObject, accessibleObject1.Navigate(AccessibleNavigation.Previous));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.Previous));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_ReturnsExpected_IfColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfRowHeadersAndColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Null(rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Null(rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsNull_IfRowHeadersAndColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Null(rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfRowHeadersAndAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Null(rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_Navigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, rowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Null(rowAccessibleObject.GetChild(0));
-        Assert.Null(rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(3));
-        Assert.Null(rowAccessibleObject.GetChild(4));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Null(rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfThirdColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(1));
-        Assert.Null(rowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(3));
-        Assert.Null(rowAccessibleObject.GetChild(4));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Rows[0].Cells[2].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.Rows[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Rows[0].Cells[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Rows[0].Cells[0].AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, rowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, rowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, rowAccessibleObject.GetChild(2));
-        Assert.Null(rowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsFour()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(4, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsThree_IfOneColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(3, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsTwo_IfTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(2, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsOne_IfAllColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(1, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsThreeIfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(3, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsTwo_IfRowHeadersAndOneColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(2, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsOne_IfRowHeadersAndTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(1, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetChildCount_ReturnsZero_IfRowHeadersAndAllColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject rowAccessibleObject = dataGridView.Rows[0].AccessibilityObject;
-
-        Assert.Equal(0, rowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.AutoGenerateColumns = false;
-        DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn();
-        column.DataPropertyName = "col1";
-        dataGridView.Columns.Add(column);
-        dataGridView.Rows.Add(new DataGridViewRow());
-        dataGridView.Rows[0].Cells[0].Value = "test1";
-
-        Assert.Equal("test1", dataGridView.Rows[0].AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowCancelEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowCancelEventArgsTests.cs
deleted file mode 100644
index c89f90b0136..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowCancelEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowCancelEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DataGridViewRow_TestData()
-    {
-        yield return new object[] { null };
-
-        var dataGridViewRow = new DataGridViewRow();
-        yield return new object[] { dataGridViewRow };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DataGridViewRow_TestData))]
-    public void Ctor_DataGridViewRow(DataGridViewRow dataGridViewRow)
-    {
-        var e = new DataGridViewRowCancelEventArgs(dataGridViewRow);
-        Assert.Equal(dataGridViewRow, e.Row);
-        Assert.False(e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowContextMenuStripNeededEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowContextMenuStripNeededEventArgsTests.cs
deleted file mode 100644
index 437dc8cd3aa..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowContextMenuStripNeededEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowContextMenuStripNeededEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int rowIndex)
-    {
-        var e = new DataGridViewRowContextMenuStripNeededEventArgs(rowIndex);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Null(e.ContextMenuStrip);
-    }
-
-    [Fact]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewRowContextMenuStripNeededEventArgs(-2));
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_TestData))]
-    public void ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        var e = new DataGridViewRowContextMenuStripNeededEventArgs(1)
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Equal(value, e.ContextMenuStrip);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowConverterTests.cs
deleted file mode 100644
index 30d60e4456d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowConverterTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowConverterTests
-{
-    [Fact]
-    public void CanConvertTo_returns_expected()
-    {
-        using DataGridViewRow row = new DataGridViewRow();
-        TypeConverter converter = TypeDescriptor.GetConverter(row);
-
-        Assert.True(converter.CanConvertTo(typeof(InstanceDescriptor)));
-    }
-
-    [Fact]
-    public void ConvertTo_returns_InstanceDescriptor()
-    {
-        using DataGridViewRow row = new DataGridViewRow();
-
-        TypeConverter converter = TypeDescriptor.GetConverter(row);
-        var descriptor = converter.ConvertTo(row, typeof(InstanceDescriptor));
-
-        Assert.NotNull(descriptor);
-        Assert.IsType<InstanceDescriptor>(descriptor);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowDividerDoubleClickEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowDividerDoubleClickEventArgsTests.cs
deleted file mode 100644
index 0b099a3a149..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowDividerDoubleClickEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowDividerDoubleClickEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Int_HandledMouseEventArgs_TestData()
-    {
-        yield return new object[] { -1, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, true) };
-        yield return new object[] { 0, new HandledMouseEventArgs((MouseButtons)1, 0, 0, 0, 0, true) };
-        yield return new object[] { 1, new HandledMouseEventArgs((MouseButtons)3, -1, -1, -1, -2, false) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Int_HandledMouseEventArgs_TestData))]
-    public void DataGridViewRowDividerDoubleClickEventArgs_Ctor_Int_HandledMouseEventArgs(int rowIndex, HandledMouseEventArgs mouseE)
-    {
-        var e = new DataGridViewRowDividerDoubleClickEventArgs(rowIndex, mouseE);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(mouseE.Button, e.Button);
-        Assert.Equal(mouseE.Clicks, e.Clicks);
-        Assert.Equal(mouseE.X, e.X);
-        Assert.Equal(mouseE.Y, e.Y);
-        Assert.Equal(mouseE.Delta, e.Delta);
-        Assert.Equal(mouseE.Handled, e.Handled);
-    }
-
-    [Fact]
-    public void DataGridViewRowDividerDoubleClickEventArgs_Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentNullException>("e", () => new DataGridViewRowDividerDoubleClickEventArgs(-2, null));
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewRowDividerDoubleClickEventArgs(-2, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, true)));
-    }
-
-    [Fact]
-    public void DataGridViewRowDividerDoubleClickEventArgs_Ctor_NullE_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("e", () => new DataGridViewRowDividerDoubleClickEventArgs(1, null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowErrorTextNeededEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowErrorTextNeededEventArgsTests.cs
deleted file mode 100644
index b6a5844ec86..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowErrorTextNeededEventArgsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowErrorTextNeededEventArgsTests
-{
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRowErrorTextNeededEventArgs_ErrorText_Set_GetReturnsExpected(string value)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = dataGridView.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            e.ErrorText = value;
-            Assert.Equal(value, e.ErrorText);
-        };
-        dataGridView.RowErrorTextNeeded += handler;
-
-        Assert.Same(value, row.GetErrorText(0));
-        Assert.Equal(1, callCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowEventArgsTests.cs
deleted file mode 100644
index b4702482384..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowEventArgsTests
-{
-    [Fact]
-    public void Ctor_DataGridViewRow()
-    {
-        using var dataGridViewRow = new DataGridViewRow();
-        var e = new DataGridViewRowEventArgs(dataGridViewRow);
-        Assert.Equal(dataGridViewRow, e.Row);
-    }
-
-    [Fact]
-    public void Ctor_NullDataGridViewRow_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dataGridViewRow", () => new DataGridViewRowEventArgs(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeaderCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeaderCellAccessibleObjectTests.cs
deleted file mode 100644
index 1e544b88ae7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeaderCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,276 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowHeaderCellAccessibleObjectTests : DataGridViewRowHeaderCell
-{
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Ctor_Default()
-    {
-        DataGridViewRowHeaderCellAccessibleObject accessibleObject = new(null);
-        Assert.Null(accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Parent_ThrowException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(() => new DataGridViewRowHeaderCellAccessibleObject(null).Parent);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Parent_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewRowHeaderCell cell = control.Rows[0].HeaderCell;
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)cell.AccessibilityObject;
-
-        Assert.Equal(cell.OwningRow.AccessibilityObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Value_ReturnsExpected()
-    {
-        DataGridViewRowHeaderCellAccessibleObject accessibleObject = new(null);
-        Assert.Equal(string.Empty, accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Role_ReturnsExpected()
-    {
-        DataGridViewRowHeaderCellAccessibleObject accessibleObject = new(null);
-        Assert.Equal(AccessibleRole.RowHeader, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Name_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewRow row = control.Rows[0];
-
-        Assert.Equal(row.AccessibilityObject.Name, row.HeaderCell.AccessibilityObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewRowHeaderCellAccessibleObject_DefaultAction_TestData()
-    {
-        yield return new object[] { DataGridViewSelectionMode.FullRowSelect, SR.DataGridView_RowHeaderCellAccDefaultAction };
-        yield return new object[] { DataGridViewSelectionMode.RowHeaderSelect, SR.DataGridView_RowHeaderCellAccDefaultAction };
-        yield return new object[] { DataGridViewSelectionMode.CellSelect, string.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewRowHeaderCellAccessibleObject_DefaultAction_TestData))]
-    public void DataGridViewRowHeaderCellAccessibleObject_DefaultAction_ReturnsExpected(DataGridViewSelectionMode mode, string expected)
-    {
-        using DataGridView control = new();
-        control.SelectionMode = mode;
-        control.Columns.Add("Column 1", "Header text 1");
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)control.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect, true)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect, true)]
-    [InlineData(DataGridViewSelectionMode.CellSelect, false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_DoDefaultAction_WorksExpected(DataGridViewSelectionMode mode, bool expected)
-    {
-        using DataGridView control = new();
-        control.SelectionMode = mode;
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewRowHeaderCell cell = control.Rows[0].HeaderCell;
-        control.CreateControl();
-
-        Assert.False(cell.OwningRow.Selected);
-
-        cell.AccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(expected, cell.OwningRow.Selected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect)]
-    [InlineData(DataGridViewSelectionMode.CellSelect)]
-    public void DataGridViewRowHeaderCellAccessibleObject_DoDefaultAction_DoesNothing_IfHandleIsNotCreated(DataGridViewSelectionMode mode)
-    {
-        using DataGridView control = new();
-        control.SelectionMode = mode;
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewRowHeaderCell cell = control.Rows[0].HeaderCell;
-
-        Assert.False(cell.OwningRow.Selected);
-
-        cell.AccessibilityObject.DoDefaultAction();
-
-        Assert.False(cell.OwningRow.Selected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_Bounds_IsNotEmptyRectangle()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)control.Rows[0].HeaderCell.AccessibilityObject;
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 1, createControl);
-        DataGridViewRow row = control.Rows[0];
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-        AccessibleObject expected = row.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_Parent_ReturnsNull_IfOwningRowIsNull()
-    {
-        DataGridViewRowHeaderCellAccessibleObject accessibleObject = new(new());
-
-        Assert.Null(accessibleObject.Owner.OwningRow);
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 1, createControl);
-        DataGridViewRow row = control.Rows[0];
-
-        AccessibleObject accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-        AccessibleObject expected = row.Cells[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfFirstColumnHidden(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].Visible = false;
-        DataGridViewRow row = control.Rows[0];
-
-        AccessibleObject accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-        AccessibleObject expected = row.Cells[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfCustomOrder(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].DisplayIndex = 1;
-        control.Columns[1].DisplayIndex = 0;
-        DataGridViewRow row = control.Rows[0];
-
-        AccessibleObject accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-        AccessibleObject expected = row.Cells[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfCustomOrderAndFirstDisplayedColumnHidden(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].DisplayIndex = 1;
-        control.Columns[1].DisplayIndex = 0;
-        control.Columns[1].Visible = false;
-        DataGridViewRow row = control.Rows[0];
-
-        AccessibleObject accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-        AccessibleObject expected = row.Cells[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 1, createControl);
-        DataGridViewRow row = control.Rows[0];
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewRowHeaderCellAccessibleObject_FragmentNavigate_Child_ReturnsNull(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 1, createControl);
-        DataGridViewRow row = control.Rows[0];
-
-        var accessibleObject = (DataGridViewRowHeaderCellAccessibleObject)row.HeaderCell.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    private DataGridView CreateDataGridView(int columnCount, bool createControl)
-    {
-        DataGridView dataGridView = new();
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        }
-
-        if (createControl)
-        {
-            dataGridView.CreateControl();
-        }
-
-        return dataGridView;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeightInfoNeededEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeightInfoNeededEventArgsTests.cs
deleted file mode 100644
index e4c73ef7146..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowHeightInfoNeededEventArgsTests.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowHeightInfoNeededEventArgsTests
-{
-    [WinFormsTheory]
-    [InlineData(-1, 3)]
-    [InlineData(3, 3)]
-    [InlineData(6, 6)]
-    [InlineData(65536, 65536)]
-    public void DataGridViewRowHeightInfoNeededEventArgs_Height_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = dataGridView.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            e.Height = value;
-            Assert.Equal(expected, e.Height);
-        };
-        dataGridView.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(expected, row.Height);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(65537)]
-    public void Height_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = dataGridView.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Throws<ArgumentOutOfRangeException>("value", () => e.Height = value);
-        };
-        dataGridView.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 10)]
-    [InlineData(3, 10)]
-    [InlineData(10, 10)]
-    [InlineData(11, 11)]
-    [InlineData(65536, 65536)]
-    [InlineData(65537, 65537)]
-    public void MinimumHeight_Set_GetReturnsExpected(int value, int expectedHeight)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = dataGridView.Rows[0];
-        row.Height = 10;
-
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            e.MinimumHeight = value;
-            Assert.Equal(value, e.MinimumHeight);
-            Assert.Equal(expectedHeight, e.Height);
-        };
-        dataGridView.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(value, row.MinimumHeight);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void MinimumHeight_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = dataGridView.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Throws<ArgumentOutOfRangeException>("value", () => e.MinimumHeight = value);
-        };
-        dataGridView.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(1, callCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPostPaintEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPostPaintEventArgsTests.cs
deleted file mode 100644
index 20b56c74b10..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPostPaintEventArgsTests.cs
+++ /dev/null
@@ -1,243 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowPostPaintEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new Rectangle(-1, -2, -3, -4), -1, DataGridViewElementStates.Displayed, "", new DataGridViewCellStyle(), true, false };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 0, (DataGridViewElementStates)7, "errorText", new DataGridViewCellStyle(), true, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool_TestData))]
-    public void Ctor_DataGridView_Graphics_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, string errorText, DataGridViewCellStyle inheritedRowStyle, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var dataGridView = new DataGridView();
-
-        var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, clipBounds, rowBounds, rowIndex, rowState, errorText, inheritedRowStyle, isFirstDisplayedRow, isLastVisibleRow);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(clipBounds, e.ClipBounds);
-        Assert.Equal(rowBounds, e.RowBounds);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(rowState, e.State);
-        Assert.Equal(errorText, e.ErrorText);
-        Assert.Equal(inheritedRowStyle, e.InheritedRowStyle);
-        Assert.Equal(isFirstDisplayedRow, e.IsFirstDisplayedRow);
-        Assert.Equal(isLastVisibleRow, e.IsLastVisibleRow);
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullDataGridView_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("dataGridView", () => new DataGridViewRowPostPaintEventArgs(null, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false));
-        }
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var dataGridView = new DataGridView();
-        Assert.Throws<ArgumentNullException>("graphics", () => new DataGridViewRowPostPaintEventArgs(dataGridView, null, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false));
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullInheritedRowStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            Assert.Throws<ArgumentNullException>("inheritedRowStyle", () => new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, null, false, false));
-        }
-    }
-
-    public static IEnumerable<object[]> ClipBounds_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClipBounds_TestData))]
-    public void ClipBounds_Set_GetReturnsExpected(Rectangle value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false)
-            {
-                ClipBounds = value
-            };
-            Assert.Equal(value, e.ClipBounds);
-        }
-    }
-
-    [WinFormsFact]
-    public void DrawFocus_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.DrawFocus(new Rectangle(1, 2, 3, 4), true);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DrawFocus_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.DrawFocus(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCells_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCells_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCellsBackground_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCellsBackground_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCellsContent_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCellsContent(new Rectangle(1, 2, 3, 4));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCellsContent_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCellsContent(new Rectangle(1, 2, 3, 4)));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintHeader_ValidRowIndexDataGridViewPaintParts_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintHeader(DataGridViewPaintParts.None);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void PaintHeader_ValidRowIndexBool_Success(bool paintSelectionBackground)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintHeader(paintSelectionBackground);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintHeader_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPostPaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintHeader(DataGridViewPaintParts.None));
-            Assert.Throws<InvalidOperationException>(() => e.PaintHeader(true));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPrePaintEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPrePaintEventArgsTests.cs
deleted file mode 100644
index c1b8e9df09e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowPrePaintEventArgsTests.cs
+++ /dev/null
@@ -1,274 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowPrePaintEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DataGridView_Graphics_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { new DataGridView(), graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false };
-        yield return new object[] { new DataGridView(), graphics, new Rectangle(-1, -2, -3, -4), new Rectangle(-1, -2, -3, -4), -1, DataGridViewElementStates.Displayed, "", new DataGridViewCellStyle(), true, false };
-        yield return new object[] { new DataGridView(), graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 0, (DataGridViewElementStates)7, "errorText", new DataGridViewCellStyle(), true, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_DataGridView_Graphics_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool_TestData))]
-    public void Ctor_DataGridView_Graphics_Rectangle_Rectangle_Int_DataGridViewElementStates_String_DataGridViewCellStyle_Bool_Bool(DataGridView dataGridView, Graphics graphics, Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, string errorText, DataGridViewCellStyle inheritedRowStyle, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, clipBounds, rowBounds, rowIndex, rowState, errorText, inheritedRowStyle, isFirstDisplayedRow, isLastVisibleRow);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(clipBounds, e.ClipBounds);
-        Assert.Equal(rowBounds, e.RowBounds);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(rowState, e.State);
-        Assert.Equal(errorText, e.ErrorText);
-        Assert.Equal(inheritedRowStyle, e.InheritedRowStyle);
-        Assert.Equal(isFirstDisplayedRow, e.IsFirstDisplayedRow);
-        Assert.Equal(isLastVisibleRow, e.IsLastVisibleRow);
-        Assert.False(e.Handled);
-        Assert.Equal(DataGridViewPaintParts.All, e.PaintParts);
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullDataGridView_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("dataGridView", () => new DataGridViewRowPrePaintEventArgs(null, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false));
-        }
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var dataGridView = new DataGridView();
-        Assert.Throws<ArgumentNullException>("graphics", () => new DataGridViewRowPrePaintEventArgs(dataGridView, null, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false));
-    }
-
-    [WinFormsFact]
-    public void Ctor_NullInheritedRowStyle_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            Assert.Throws<ArgumentNullException>("inheritedRowStyle", () => new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, null, false, false));
-        }
-    }
-
-    public static IEnumerable<object[]> ClipBounds_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ClipBounds_TestData))]
-    public void ClipBounds_Set_GetReturnsExpected(Rectangle value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false)
-            {
-                ClipBounds = value
-            };
-            Assert.Equal(value, e.ClipBounds);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewPaintParts.None)]
-    [InlineData(DataGridViewPaintParts.All)]
-    public void PaintParts_Set_GetReturnsExpected(DataGridViewPaintParts value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false)
-            {
-                PaintParts = value
-            };
-            Assert.Equal(value, e.PaintParts);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.All + 1))]
-    public void PaintParts_SetInvalidValue_ThrowsArgumentException(DataGridViewPaintParts value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, -2, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<ArgumentException>("value", () => e.PaintParts = value);
-        }
-    }
-
-    [WinFormsFact]
-    public void DrawFocus_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.DrawFocus(new Rectangle(1, 2, 3, 4), true);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void DrawFocus_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.DrawFocus(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCells_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCells_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCells(new Rectangle(1, 2, 3, 4), DataGridViewPaintParts.None));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCellsBackground_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCellsBackground_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCellsBackground(new Rectangle(1, 2, 3, 4), true));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintCellsContent_ValidRowIndex_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintCellsContent(new Rectangle(1, 2, 3, 4));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintCellsContent_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintCellsContent(new Rectangle(1, 2, 3, 4)));
-        }
-    }
-
-    [WinFormsFact]
-    public void PaintHeader_ValidRowIndexDataGridViewPaintParts_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintHeader(DataGridViewPaintParts.None);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void PaintHeader_ValidRowIndexBool_Success(bool paintSelectionBackground)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            e.PaintHeader(paintSelectionBackground);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void PaintHeader_InvalidRowIndex_ThrowsInvalidOperationException(int rowIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var dataGridView = new DataGridView();
-            dataGridView.Columns.Add("name", "text");
-            var e = new DataGridViewRowPrePaintEventArgs(dataGridView, graphics, Rectangle.Empty, Rectangle.Empty, rowIndex, DataGridViewElementStates.Displayed, null, new DataGridViewCellStyle(), false, false);
-            Assert.Throws<InvalidOperationException>(() => e.PaintHeader(DataGridViewPaintParts.None));
-            Assert.Throws<InvalidOperationException>(() => e.PaintHeader(true));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowStateChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowStateChangedEventArgsTests.cs
deleted file mode 100644
index bdc4f8b3151..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowStateChangedEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowStateChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DataGridViewRow_DataGridViewElementStates_TestData()
-    {
-        yield return new object[] { new DataGridViewRow(), (DataGridViewElementStates)7 };
-        yield return new object[] { new DataGridViewRow(), DataGridViewElementStates.Displayed };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DataGridViewRow_DataGridViewElementStates_TestData))]
-    public void Ctor_DataGridViewRow_DataGridViewElementStates(DataGridViewRow dataGridViewRow, DataGridViewElementStates stateChanged)
-    {
-        var e = new DataGridViewRowStateChangedEventArgs(dataGridViewRow, stateChanged);
-        Assert.Equal(dataGridViewRow, e.Row);
-        Assert.Equal(stateChanged, e.StateChanged);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowTests.cs
deleted file mode 100644
index 2961938f538..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowTests.cs
+++ /dev/null
@@ -1,5824 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowTests
-{
-    [WinFormsFact]
-    public void DataGridViewRow_Ctor_Default()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Same(row.Cells, row.Cells);
-        Assert.Empty(row.Cells);
-        Assert.Null(row.ContextMenuStrip);
-        Assert.Null(row.DataBoundItem);
-        Assert.Null(row.DataGridView);
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.Same(row.DefaultCellStyle, row.DefaultCellStyle);
-        Assert.Same(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-        Assert.False(row.Displayed);
-        Assert.Equal(0, row.DividerHeight);
-        Assert.Empty(row.ErrorText);
-        Assert.False(row.Frozen);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCell);
-        Assert.Same(row.HeaderCell, row.HeaderCell);
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCellCore);
-        Assert.Same(row.HeaderCellCore, row.HeaderCellCore);
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-        Assert.Equal(-1, row.Index);
-        Assert.Throws<InvalidOperationException>(() => row.InheritedStyle);
-        Assert.True(row.IsRow);
-        Assert.False(row.IsNewRow);
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(DataGridViewTriState.NotSet, row.Resizable);
-        Assert.False(row.Selected);
-        Assert.Equal(DataGridViewElementStates.Visible, row.State);
-        Assert.Null(row.Tag);
-        Assert.True(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        int callCount = 0;
-        control.RowContextMenuStripNeeded += (sender, e) => callCount++;
-        DataGridViewRow row = control.Rows[0];
-        Assert.Null(row.ContextMenuStrip);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_GetWithDataGridViewVirtualMode_CallsRowContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewRowContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.RowContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_GetWithDataGridViewDataSource_CallsRowContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        row.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewRowContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.RowContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.ContextMenuStrip);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewRow_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Same(value, row.ContextMenuStrip);
-
-        // Set same.
-        row.ContextMenuStrip = value;
-        Assert.Same(value, row.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewRow_ContextMenuStrip_SetWithCustomOldValue_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var oldValue = new ContextMenuStrip();
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = oldValue
-        };
-
-        row.ContextMenuStrip = value;
-        Assert.Same(value, row.ContextMenuStrip);
-
-        // Set same.
-        row.ContextMenuStrip = value;
-        Assert.Same(value, row.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewRow_ContextMenuStrip_SetWithDataGridView_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.ContextMenuStrip = value;
-        Assert.Same(value, row.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.ContextMenuStrip = value;
-        Assert.Same(value, row.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void DataGridViewRow_ContextMenuStrip_SetShared_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        row.ContextMenuStrip = value;
-        Assert.Throws<InvalidOperationException>(() => row.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.ContextMenuStrip = value;
-        Assert.Throws<InvalidOperationException>(() => row.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_SetDisposeNew_RemovesContextMenuStrip()
-    {
-        using var menu = new ContextMenuStrip();
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu
-        };
-        Assert.Same(menu, row.ContextMenuStrip);
-
-        menu.Dispose();
-        Assert.Null(row.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_SetDisposeOld_RemovesContextMenuStrip()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = menu1
-        };
-        Assert.Same(menu1, row.ContextMenuStrip);
-
-        row.ContextMenuStrip = menu2;
-        Assert.Same(menu2, row.ContextMenuStrip);
-
-        menu1.Dispose();
-        Assert.Same(menu2, row.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ContextMenuStrip_SetWithHandler_CallsContextMenuStripChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-            callCount++;
-        };
-        control.RowContextMenuStripChanged += handler;
-
-        // Set different.
-        using var menu1 = new ContextMenuStrip();
-        row.ContextMenuStrip = menu1;
-        Assert.Same(menu1, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.ContextMenuStrip = menu1;
-        Assert.Same(menu1, row.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        row.ContextMenuStrip = menu2;
-        Assert.Same(menu2, row.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        row.ContextMenuStrip = null;
-        Assert.Null(row.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RowContextMenuStripChanged -= handler;
-        row.ContextMenuStrip = menu1;
-        Assert.Same(menu1, row.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DataBoundItem_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Null(row.DataBoundItem);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DataBoundItem_GetWithDataGridViewWithDataSource_ReturnsExpected()
-    {
-        var boundObject = new { Name = "Name" };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { boundObject }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        Assert.Same(boundObject, row.DataBoundItem);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DataBoundItem_GetShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Null(row.DataBoundItem);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DataBoundItem_GetSharedWithDataSource_ReturnsExpected()
-    {
-        var boundObject = new { Name = "Name" };
-        using var control = new DataGridView
-        {
-            DataSource = new[] { boundObject }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Null(row.DataBoundItem);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultCellStyle_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.Same(row.DefaultCellStyle, row.DefaultCellStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultCellStyle_GetShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.Same(row.DefaultCellStyle, row.DefaultCellStyle);
-    }
-
-    public static IEnumerable<object[]> DefaultCellStyle_Set_TestData()
-    {
-        yield return new object[] { null, new DataGridViewCellStyle() };
-
-        var style1 = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.MiddleCenter };
-        var style2 = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomLeft };
-        yield return new object[] { style1, style1 };
-        yield return new object[] { style2, style2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewRow_DefaultCellStyle_Set_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            DefaultCellStyle = value
-        };
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-
-        // Set same.
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewRow_DefaultCellStyle_SetWithNonNullOldValue_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-        using var row = new DataGridViewRow
-        {
-            DefaultCellStyle = oldValue
-        };
-
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-
-        // Set same.
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewRow_DefaultCellStyle_SetWithDataGridView_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.DefaultCellStyle = value;
-
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_Set_TestData))]
-    public void DataGridViewRow_DefaultCellStyle_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(DataGridViewCellStyle value, DataGridViewCellStyle expected)
-    {
-        var oldValue = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.DefaultCellStyle = oldValue;
-
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.DefaultCellStyle = value;
-        Assert.Equal(expected, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultCellStyle_SetWithDataGridView_CallsRowDefaultCellStyleChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-            callCount++;
-        };
-        control.RowDefaultCellStyleChanged += handler;
-
-        var style1 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.MiddleCenter
-        };
-
-        // Set non-null.
-        row.DefaultCellStyle = style1;
-        Assert.Equal(style1, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.DefaultCellStyle = style1;
-        Assert.Equal(style1, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var style2 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter
-        };
-        row.DefaultCellStyle = style2;
-        Assert.Same(style2, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        row.DefaultCellStyle = null;
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(3, callCount);
-
-        // Set null again.
-        row.DefaultCellStyle = null;
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(4, callCount);
-
-        // Set non-null.
-        row.DefaultCellStyle = style2;
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(5, callCount);
-
-        // Remove handler.
-        control.RowDefaultCellStyleChanged -= handler;
-        row.DefaultCellStyle = style1;
-        Assert.Equal(style1, row.DefaultCellStyle);
-        Assert.True(row.HasDefaultCellStyle);
-        Assert.Equal(5, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultCellStyle_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.DefaultCellStyle = new DataGridViewCellStyle());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultHeaderCellType_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DefaultHeaderCellType_GetShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-    }
-
-    public static IEnumerable<object[]> DefaultHeaderCellType_Set_TestData()
-    {
-        yield return new object[] { null, typeof(DataGridViewRowHeaderCell) };
-        yield return new object[] { typeof(DataGridViewRowHeaderCell), typeof(DataGridViewRowHeaderCell) };
-        yield return new object[] { typeof(DataGridViewColumnHeaderCell), typeof(DataGridViewColumnHeaderCell) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultHeaderCellType_Set_TestData))]
-    public void DataGridViewRow_DefaultHeaderCellType_Set_GetReturnsExpected(Type value, Type expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            DefaultHeaderCellType = value
-        };
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(DataGridViewRowHeaderCell))]
-    [InlineData(typeof(DataGridViewColumnHeaderCell))]
-    [InlineData(typeof(DataGridViewHeaderCell))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var row = new SubDataGridViewRow
-        {
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell)
-        };
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultHeaderCellType_Set_TestData))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetWithDataGridView_GetReturnsExpected(Type value, Type expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(DataGridViewRowHeaderCell))]
-    [InlineData(typeof(DataGridViewColumnHeaderCell))]
-    [InlineData(typeof(DataGridViewHeaderCell))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetWithDataGridViewNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell);
-
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultHeaderCellType_Set_TestData))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetShared_GetReturnsExpected(Type value, Type expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(expected, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(DataGridViewRowHeaderCell))]
-    [InlineData(typeof(DataGridViewColumnHeaderCell))]
-    [InlineData(typeof(DataGridViewHeaderCell))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetSharedNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        row.DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell);
-
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-
-        // Set same.
-        row.DefaultHeaderCellType = value;
-        Assert.Equal(value, row.DefaultHeaderCellType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetInvalidWithNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentException>("value", () => row.DefaultHeaderCellType = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(typeof(int))]
-    public void DataGridViewRow_DefaultHeaderCellType_SetInvalidWithNonNullOldValue_GetReturnsExpected(Type value)
-    {
-        using var row = new DataGridViewRow
-        {
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell)
-        };
-        Assert.Throws<ArgumentException>("value", () => row.DefaultHeaderCellType = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Displayed_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.False(row.Displayed);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Displayed_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Displayed);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DividerHeight_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(0, row.DividerHeight);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DividerHeight_GetShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Equal(0, row.DividerHeight);
-    }
-
-    public static IEnumerable<object[]> DividerHeight_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DividerHeight_Set_TestData))]
-    public void DataGridViewRow_DividerHeight_Set_GetReturnsExpected(int value)
-    {
-        using var row = new DataGridViewRow
-        {
-            DividerHeight = value
-        };
-        Assert.Equal(value, row.DividerHeight);
-
-        // Set same.
-        row.DividerHeight = value;
-        Assert.Equal(value, row.DividerHeight);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DividerHeight_Set_TestData))]
-    public void DataGridViewRow_DividerHeight_SetWithDataGridView_GetReturnsExpected(int value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.DividerHeight = value;
-        Assert.Equal(value, row.DividerHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.DividerHeight = value;
-        Assert.Equal(value, row.DividerHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DividerHeight_SetWithDataGridView_CallsRowDividerHeightChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowDividerHeightChanged += handler;
-
-        // Set non-zero.
-        row.DividerHeight = 4;
-        Assert.Equal(4, row.DividerHeight);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.DividerHeight = 4;
-        Assert.Equal(4, row.DividerHeight);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.DividerHeight = 3;
-        Assert.Equal(3, row.DividerHeight);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowDividerHeightChanged -= handler;
-        row.DividerHeight = 4;
-        Assert.Equal(4, row.DividerHeight);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(65537)]
-    public void DataGridViewRow_DividerHeight_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => row.DividerHeight = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DividerHeight_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.DividerHeight = -1);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Empty(row.ErrorText);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_GetNeedsErrorTextVirtualMode_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewRowErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.RowErrorTextNeeded += handler;
-        Assert.Same("errorText2", row.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowErrorTextNeeded -= handler;
-        Assert.Same("errorText1", row.ErrorText);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_GetNeedsErrorTextDataSource_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-
-        DataGridViewRow row = control.Rows[0];
-        row.ErrorText = "errorText1";
-
-        int callCount = 0;
-        DataGridViewRowErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal("errorText1", e.ErrorText);
-            e.ErrorText = "errorText2";
-        };
-        control.RowErrorTextNeeded += handler;
-        Assert.Equal("errorText2", row.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowErrorTextNeeded -= handler;
-        Assert.Equal("errorText1", row.ErrorText);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewRow_ErrorText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            ErrorText = value
-        };
-        Assert.Equal(expected, row.ErrorText);
-
-        // Set same.
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewRow_ErrorText_SetWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            ErrorText = "OldValue"
-        };
-        row.ErrorText = value;
-
-        Assert.Equal(expected, row.ErrorText);
-
-        // Set same.
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewRow_ErrorText_SetWithDataGridView_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void DataGridViewRow_ErrorText_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ErrorText = "OldValue";
-
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.ErrorText = value;
-        Assert.Equal(expected, row.ErrorText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_SetWithDataGridView_CallsRowErrorTextChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowErrorTextChanged += handler;
-
-        // Set non-null.
-        row.ErrorText = "errorText";
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.ErrorText = "errorText";
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        row.ErrorText = null;
-        Assert.Empty(row.ErrorText);
-        Assert.Equal(2, callCount);
-
-        // Set different.
-        row.ErrorText = "other";
-        Assert.Equal("other", row.ErrorText);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RowErrorTextChanged -= handler;
-        row.ErrorText = "errorText";
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ErrorText_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.ErrorText = "value");
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.Frozen, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.Frozen | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewRow_Frozen_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var row = new CustomStateDataGridViewRow
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, row.Frozen);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Frozen_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var row = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(row);
-        control.Rows.Add();
-        Assert.False(control.Rows[0].Frozen);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Frozen_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var row = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(row);
-        control.Rows.Add();
-        Assert.Throws<InvalidOperationException>(() => control.Rows.SharedRow(0).Frozen);
-    }
-
-    public static IEnumerable<object[]> Frozen_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            yield return new object[] { visible, true };
-            yield return new object[] { visible, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Frozen_Set_TestData))]
-    public void DataGridViewRow_Frozen_Set_GetReturnsExpected(bool visible, bool value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Visible = visible,
-            Frozen = value
-        };
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-
-        // Set same.
-        row.Frozen = value;
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-
-        // Set different.
-        row.Frozen = !value;
-        Assert.Equal(!value, row.Frozen);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.Frozen) != 0);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_Frozen_SetWithDataGridView_GetReturnsExpected(bool value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-
-        row.Frozen = value;
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Frozen = value;
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        row.Frozen = !value;
-        Assert.Equal(!value, row.Frozen);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void DataGridViewRow_Frozen_SetWithDataGridViewWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        control.Rows.Add();
-        DataGridViewRow row = control.Rows[0];
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        row.Frozen = value;
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        row.Frozen = value;
-        Assert.Equal(value, row.Frozen);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        row.Frozen = !value;
-        Assert.Equal(!value, row.Frozen);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.Frozen) != 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_Frozen_SetWithPreviousRows_SetsToFrozen(bool previousVisible)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        control.Rows.Add();
-        control.Rows.Add();
-        control.Rows.Add();
-        control.Rows.Add();
-        DataGridViewRow row1 = control.Rows[0];
-        DataGridViewRow row2 = control.Rows[1];
-        row2.Visible = previousVisible;
-        DataGridViewRow row3 = control.Rows[2];
-        DataGridViewRow row4 = control.Rows[3];
-
-        // Freeze middle.
-        row3.Frozen = true;
-        Assert.True(row1.Frozen);
-        Assert.Equal(previousVisible, row2.Frozen);
-        Assert.True(row3.Frozen);
-        Assert.False(row4.Frozen);
-
-        // Freeze again.
-        row3.Frozen = true;
-        Assert.True(row1.Frozen);
-        Assert.Equal(previousVisible, row2.Frozen);
-        Assert.True(row3.Frozen);
-        Assert.False(row4.Frozen);
-
-        // Freeze later.
-        row4.Frozen = true;
-        Assert.True(row1.Frozen);
-        Assert.Equal(previousVisible, row2.Frozen);
-        Assert.True(row3.Frozen);
-        Assert.True(row4.Frozen);
-
-        // Unfreeze middle.
-        row3.Frozen = false;
-        Assert.True(row1.Frozen);
-        Assert.Equal(previousVisible, row2.Frozen);
-        Assert.False(row3.Frozen);
-        Assert.False(row4.Frozen);
-
-        // Unfreeze first.
-        row1.Frozen = false;
-        Assert.False(row1.Frozen);
-        Assert.False(row2.Frozen);
-        Assert.False(row3.Frozen);
-        Assert.False(row4.Frozen);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Frozen_SetWithDataGridView_CallsRowStateChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowStateChanged += handler;
-
-        // Set true.
-        row.Frozen = true;
-        Assert.True(row.Frozen);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.Frozen = true;
-        Assert.True(row.Frozen);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.Frozen = false;
-        Assert.False(row.Frozen);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowStateChanged -= handler;
-        row.Frozen = true;
-        Assert.True(row.Frozen);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_Frozen_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var row = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(row);
-        control.Rows.Add();
-        Assert.Throws<InvalidOperationException>(() => control.Rows.SharedRow(0).Frozen = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCell_Get_ReturnsExpected()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCell);
-        Assert.Same(row, row.HeaderCell.OwningRow);
-        Assert.Null(row.HeaderCell.OwningColumn);
-        Assert.Same(row.HeaderCell, row.HeaderCell);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCell_GetWithDataGridView_ReturnsExpected()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1,
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCell);
-        Assert.Same(row, row.HeaderCell.OwningRow);
-        Assert.Null(row.HeaderCell.OwningColumn);
-        Assert.Same(row.HeaderCell, row.HeaderCell);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCell_GetShared_ReturnsExpected()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1,
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows.SharedRow(0);
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCell);
-        Assert.Same(row, row.HeaderCell.OwningRow);
-        Assert.Null(row.HeaderCell.OwningColumn);
-        Assert.Same(row.HeaderCell, row.HeaderCell);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCellCore_Get_ReturnsExpected()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCellCore);
-        Assert.Same(row, row.HeaderCellCore.OwningRow);
-        Assert.Null(row.HeaderCellCore.OwningColumn);
-        Assert.Same(row.HeaderCellCore, row.HeaderCellCore);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCellCore_GetWithDataGridView_ReturnsExpected()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1,
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCellCore);
-        Assert.Same(row, row.HeaderCellCore.OwningRow);
-        Assert.Null(row.HeaderCellCore.OwningColumn);
-        Assert.Same(row.HeaderCellCore, row.HeaderCellCore);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCellCore_GetShared_ReturnsExpected()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1,
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows.SharedRow(0);
-        Assert.IsType<DataGridViewRowHeaderCell>(row.HeaderCellCore);
-        Assert.Same(row, row.HeaderCellCore.OwningRow);
-        Assert.Null(row.HeaderCellCore.OwningColumn);
-        Assert.Same(row.HeaderCellCore, row.HeaderCellCore);
-        Assert.Same(row.HeaderCell, row.HeaderCellCore);
-    }
-
-    public static IEnumerable<object[]> HeaderCell_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewRowHeaderCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_Set_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var row = new DataGridViewRow
-        {
-            HeaderCell = value
-        };
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_SetNonNullOldValue_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var oldValue = new DataGridViewRowHeaderCell();
-        using var row = new DataGridViewRow
-        {
-            HeaderCell = oldValue
-        };
-        row.HeaderCell = value;
-
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCell_SetAlreadyHasBand_GetReturnsExpected()
-    {
-        using var value = new DataGridViewRowHeaderCell();
-        using var otherRow = new DataGridViewRow
-        {
-            HeaderCell = value
-        };
-        using var row = new DataGridViewRow
-        {
-            HeaderCell = value
-        };
-        Assert.Same(value, row.HeaderCell);
-        Assert.NotSame(value, otherRow.HeaderCell);
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        Assert.Same(value, row.HeaderCell);
-        Assert.NotSame(value, otherRow.HeaderCell);
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_SetWithDataGridView_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_SetWithDataGridViewNonNullOldValue_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        using var oldValue = new DataGridViewRowHeaderCell();
-        row.HeaderCell = oldValue;
-
-        row.HeaderCell = value;
-
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_SetShared_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCell_Set_TestData))]
-    public void DataGridViewRow_HeaderCell_SetSharedNonNullOldValue_GetReturnsExpected(DataGridViewRowHeaderCell value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        using var oldValue = new DataGridViewRowHeaderCell();
-        row.HeaderCell = oldValue;
-
-        row.HeaderCell = value;
-
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-
-        // Set same.
-        row.HeaderCell = value;
-        if (value is not null)
-        {
-            Assert.Same(value, row.HeaderCell);
-        }
-        else
-        {
-            Assert.NotNull(row.HeaderCell);
-        }
-
-        Assert.Equal(row, row.HeaderCell.OwningRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_HeaderCell_SetWithDataGridView_CallsRowHeaderCellChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowHeaderCellChanged += handler;
-
-        // Set non-null.
-        using var cell1 = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell1;
-        Assert.Same(cell1, row.HeaderCell);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.HeaderCell = cell1;
-        Assert.Same(cell1, row.HeaderCell);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var cell2 = new DataGridViewRowHeaderCell();
-        row.HeaderCell = cell2;
-        Assert.Same(cell2, row.HeaderCell);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        row.HeaderCell = null;
-        Assert.NotNull(row.HeaderCell);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RowHeaderCellChanged -= handler;
-        row.HeaderCell = cell1;
-        Assert.Equal(cell1, row.HeaderCell);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> HeaderCellCore_SetInvalid_TestData()
-    {
-        yield return new object[] { new DataGridViewColumnHeaderCell() };
-        yield return new object[] { new DataGridViewHeaderCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HeaderCellCore_SetInvalid_TestData))]
-    public void DataGridViewRow_HeaderCellCore_SetInvalid_ThrowsArgumentException(DataGridViewHeaderCell value)
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Throws<ArgumentException>("value", () => row.HeaderCellCore = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeRowsMode>]
-    public void DataGridViewRow_Height_GetWithDataGridView_ReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        int callCount = 0;
-        control.RowHeightInfoNeeded += (sender, e) => callCount++;
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeRowsMode>]
-    public void DataGridViewRow_Height_GetShared_ReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        int callCount = 0;
-        control.RowHeightInfoNeeded += (sender, e) => callCount++;
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> Height_NeedsHeightInfo_TestData()
-    {
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 6, 2, 6, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 6, 9, 9, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 0, 2, 3, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, -1, 2, 3, 1 };
-
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllHeaders, 2, 1, Control.DefaultFont.Height + 9, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders, 2, 1, Control.DefaultFont.Height + 9, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllCells, 2, 1, Control.DefaultFont.Height + 9, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedHeaders, 2, 1, Control.DefaultFont.Height + 9, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders, 2, 1, Control.DefaultFont.Height + 9, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedCells, 2, 1, Control.DefaultFont.Height + 9, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_NeedsHeightInfo_TestData))]
-    public void DataGridViewRow_Height_GetWithDataGridViewVirtualMode_CallsHeightInfoNeeded(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int heightResult, int minimumHeightResult, int expectedHeight, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal(Control.DefaultFont.Height + 9, e.Height);
-            Assert.Equal(3, e.MinimumHeight);
-            e.Height = heightResult;
-            e.MinimumHeight = minimumHeightResult;
-        };
-        control.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(expectedHeight, row.Height);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.RowHeightInfoNeeded -= handler;
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_NeedsHeightInfo_TestData))]
-    public void DataGridViewRow_Height_GetWithDataGridViewDataSource_CallsHeightInfoNeeded(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int heightResult, int minimumHeightResult, int expectedHeight, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeRowsMode = autoSizeRowsMode,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal(Control.DefaultFont.Height + 9, e.Height);
-            Assert.Equal(3, e.MinimumHeight);
-            e.Height = heightResult;
-            e.MinimumHeight = minimumHeightResult;
-        };
-        control.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(expectedHeight, row.Height);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.RowHeightInfoNeeded -= handler;
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    public static IEnumerable<object[]> Height_Set_TestData()
-    {
-        yield return new object[] { -1, 3 };
-        yield return new object[] { 0, 3 };
-        yield return new object[] { 1, 3 };
-        yield return new object[] { 3, 3 };
-        yield return new object[] { 4, 4 };
-        yield return new object[] { 65536, 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_Set_TestData))]
-    public void DataGridViewRow_Height_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var row = new DataGridViewRow
-        {
-            Height = value
-        };
-        Assert.Equal(expected, row.Height);
-
-        // Set same.
-        row.Height = value;
-        Assert.Equal(expected, row.Height);
-    }
-
-    public static IEnumerable<object[]> Height_SetWithDataGridView_TestData()
-    {
-        foreach (DataGridViewAutoSizeRowsMode autoSizeRowsMode in Enum.GetValues(typeof(DataGridViewAutoSizeRowsMode)))
-        {
-            if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
-            {
-                continue;
-            }
-
-            yield return new object[] { autoSizeRowsMode, -1, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 0, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 1, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 3, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 4, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 65536, Control.DefaultFont.Height + 9 };
-        }
-
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, -1, 3 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 0, 3 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 1, 3 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 3, 3 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 4, 4 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 65536, 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Height_SetWithDataGridView_TestData))]
-    public void DataGridViewRow_Height_SetWithDataGridView_GetReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int value, int expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.Height = value;
-        Assert.Equal(expected, row.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Height = value;
-        Assert.Equal(expected, row.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Height_SetWithDataGridView_CallsRowHeightChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowHeightChanged += handler;
-
-        // Set non-zero.
-        row.Height = 4;
-        Assert.Equal(4, row.Height);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.Height = 4;
-        Assert.Equal(4, row.Height);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.Height = 3;
-        Assert.Equal(3, row.Height);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowHeightChanged -= handler;
-        row.Height = 4;
-        Assert.Equal(4, row.Height);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(65537)]
-    public void DataGridViewRow_Height_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => row.Height = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Height_IsEqualDefaultHeight_IfDefaultFontIsChanged()
-    {
-        var oldApplicationDefaultFont = Application.DefaultFont;
-        using var font = new Font("Times New Roman", 12);
-        using var row = new TestDataGridViewRow();
-        var applicationTestAccessor = typeof(Application).TestAccessor().Dynamic;
-
-        try
-        {
-            applicationTestAccessor.s_defaultFont = font;
-            Assert.NotEqual(oldApplicationDefaultFont, Application.DefaultFont);
-
-            var rowDefaultHeight = row.GetDefaultHeight();
-            Assert.Equal(Control.DefaultFont.Height + 9, rowDefaultHeight);
-            Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        }
-        finally
-        {
-            applicationTestAccessor.s_defaultFont = null;
-            applicationTestAccessor.s_defaultFontScaled = null;
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Height_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Height = -1);
-    }
-
-    public static IEnumerable<object[]> InheritedStyle_GetWithDataGridView_TestData()
-    {
-        Font font1 = SystemFonts.DefaultFont;
-        Font font2 = SystemFonts.MenuFont;
-        var provider1 = new NumberFormatInfo();
-        var provider2 = new NumberFormatInfo();
-
-        var complete1 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomCenter,
-            BackColor = Color.Green,
-            DataSourceNullValue = "dbNull",
-            Font = font1,
-            ForeColor = Color.Blue,
-            Format = "format",
-            FormatProvider = provider1,
-            Padding = new Padding(1, 2, 3, 4),
-            NullValue = "null",
-            SelectionForeColor = Color.Red,
-            SelectionBackColor = Color.Yellow,
-            Tag = "tag",
-            WrapMode = DataGridViewTriState.True,
-        };
-        var complete2 = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomRight,
-            BackColor = Color.Blue,
-            DataSourceNullValue = "dbNull2",
-            Font = font2,
-            ForeColor = Color.Green,
-            Format = "forma2t",
-            FormatProvider = provider2,
-            Padding = new Padding(2, 3, 4, 5),
-            NullValue = "null2",
-            SelectionForeColor = Color.Yellow,
-            SelectionBackColor = Color.Red,
-            Tag = "tag2",
-            WrapMode = DataGridViewTriState.False,
-        };
-        yield return new object[]
-        {
-            1, complete1, null, null, null,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, new DataGridViewCellStyle(), complete1, null, null,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, null, null, complete1, null,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, null, new DataGridViewCellStyle(), complete1, null,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, null, null, null, complete1,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, null, null, new DataGridViewCellStyle(), complete1,
-            complete1
-        };
-        yield return new object[]
-        {
-            2, null, null, null, complete1,
-            complete1
-        };
-        yield return new object[]
-        {
-            2, null, null, new DataGridViewCellStyle(), complete1,
-            complete1
-        };
-        yield return new object[]
-        {
-            1, null, complete1, complete2, null,
-            complete2
-        };
-        yield return new object[]
-        {
-            2, null, complete1, complete2, null,
-            complete1
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InheritedStyle_GetWithDataGridView_TestData))]
-    public void DataGridViewRow_InheritedStyle_Get_ReturnsExpected(int index, DataGridViewCellStyle rowDefaultCellStyle, DataGridViewCellStyle rowsDefaultCellStyle, DataGridViewCellStyle alternatingRowsDefaultCellStyle, DataGridViewCellStyle gridDefaultCellStyle, DataGridViewCellStyle expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 2
-        };
-
-        if (rowsDefaultCellStyle is not null)
-        {
-            control.RowsDefaultCellStyle = rowsDefaultCellStyle;
-        }
-
-        if (alternatingRowsDefaultCellStyle is not null)
-        {
-            control.AlternatingRowsDefaultCellStyle = alternatingRowsDefaultCellStyle;
-        }
-
-        if (gridDefaultCellStyle is not null)
-        {
-            control.DefaultCellStyle = gridDefaultCellStyle;
-        }
-
-        control.Rows.Add(new SubDataGridViewRow());
-        control.Rows.Add(new SubDataGridViewRow());
-
-        DataGridViewRow row = control.Rows[index];
-        if (rowDefaultCellStyle is not null)
-        {
-            row.DefaultCellStyle = rowDefaultCellStyle;
-        }
-
-        Assert.Equal(expected, row.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_InheritedStyle_GetWithoutDataGridView_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_InheritedStyle_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.InheritedStyle);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_IsNewRow_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.False(row.IsNewRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_IsNewRow_GetWithDataGridViewNewRow_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.True(row.IsNewRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_IsNewRow_GetSharedNotNewRow_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.False(row.IsNewRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_IsNewRow_GetSharedNewRow_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.False(row.IsNewRow);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeRowsMode>]
-    public void DataGridViewRow_MinimumHeight_GetWithDataGridView_ReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        int callCount = 0;
-        control.RowHeightInfoNeeded += (sender, e) => callCount++;
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewAutoSizeRowsMode>]
-    public void DataGridViewRow_MinimumHeight_GetShared_ReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        int callCount = 0;
-        control.RowHeightInfoNeeded += (sender, e) => callCount++;
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> MinimumHeight_NeedsHeightInfo_TestData()
-    {
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 6, 2, 2, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 6, 9, 9, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 0, 2, 2, 1 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, -1, 2, 2, 1 };
-
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllHeaders, 2, 1, 3, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders, 2, 1, 3, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.AllCells, 2, 1, 3, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedHeaders, 2, 1, 3, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders, 2, 1, 3, 0 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.DisplayedCells, 2, 1, 3, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumHeight_NeedsHeightInfo_TestData))]
-    public void DataGridViewRow_MinimumHeight_GetWithDataGridViewVirtualMode_CallsHeightInfoNeeded(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int heightResult, int minimumHeightResult, int expectedMinimumHeight, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal(Control.DefaultFont.Height + 9, e.Height);
-            Assert.Equal(3, e.MinimumHeight);
-            e.Height = heightResult;
-            e.MinimumHeight = minimumHeightResult;
-        };
-        control.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.RowHeightInfoNeeded -= handler;
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumHeight_NeedsHeightInfo_TestData))]
-    public void DataGridViewRow_MinimumHeight_GetWithDataGridViewDataSource_CallsHeightInfoNeeded(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int heightResult, int minimumHeightResult, int expectedMinimumHeight, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            AutoSizeRowsMode = autoSizeRowsMode,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        int callCount = 0;
-        DataGridViewRowHeightInfoNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Equal(Control.DefaultFont.Height + 9, e.Height);
-            Assert.Equal(3, e.MinimumHeight);
-            e.Height = heightResult;
-            e.MinimumHeight = minimumHeightResult;
-        };
-        control.RowHeightInfoNeeded += handler;
-
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove the handler.
-        control.RowHeightInfoNeeded -= handler;
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    public static IEnumerable<object[]> MinimumHeight_Set_TestData()
-    {
-        yield return new object[] { 2, 2, Control.DefaultFont.Height + 9 };
-        yield return new object[] { 3, 3, Control.DefaultFont.Height + 9 };
-        yield return new object[] { 4, 4, Control.DefaultFont.Height + 9 };
-        yield return new object[] { 65536, 65536, 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumHeight_Set_TestData))]
-    public void DataGridViewRow_MinimumHeight_Set_GetReturnsExpected(int value, int expectedMinimumHeight, int expectedHeight)
-    {
-        using var row = new DataGridViewRow
-        {
-            MinimumHeight = value
-        };
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedHeight, row.Height);
-
-        // Set same.
-        row.MinimumHeight = value;
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedHeight, row.Height);
-    }
-
-    public static IEnumerable<object[]> MinimumHeight_SetWithDataGridView_TestData()
-    {
-        foreach (DataGridViewAutoSizeRowsMode autoSizeRowsMode in Enum.GetValues(typeof(DataGridViewAutoSizeRowsMode)))
-        {
-            if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
-            {
-                continue;
-            }
-
-            yield return new object[] { autoSizeRowsMode, 2, 2, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 3, 3, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 4, 4, Control.DefaultFont.Height + 9 };
-            yield return new object[] { autoSizeRowsMode, 65536, 65536, Control.DefaultFont.Height + 9 };
-        }
-
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 2, 2, Control.DefaultFont.Height + 9 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 3, 3, Control.DefaultFont.Height + 9 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 4, 4, Control.DefaultFont.Height + 9 };
-        yield return new object[] { DataGridViewAutoSizeRowsMode.None, 65536, 65536, 65536 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumHeight_SetWithDataGridView_TestData))]
-    public void DataGridViewRow_MinimumHeight_SetWithDataGridView_GetReturnsExpected(DataGridViewAutoSizeRowsMode autoSizeRowsMode, int value, int expectedMinimumHeight, int expectedHeight)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AutoSizeRowsMode = autoSizeRowsMode
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.MinimumHeight = value;
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedHeight, row.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.MinimumHeight = value;
-        Assert.Equal(expectedMinimumHeight, row.MinimumHeight);
-        Assert.Equal(expectedHeight, row.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_MinimumHeight_SetWithDataGridView_CallsRowMinimumHeightChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowMinimumHeightChanged += handler;
-
-        // Set non-zero.
-        row.MinimumHeight = 4;
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.MinimumHeight = 4;
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.MinimumHeight = 3;
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowMinimumHeightChanged -= handler;
-        row.MinimumHeight = 4;
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(65537)]
-    public void DataGridViewRow_MinimumHeight_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => row.MinimumHeight = value);
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_MinimumHeight_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.MinimumHeight = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewElementStates.None, false)]
-    [InlineData(DataGridViewElementStates.ReadOnly, false)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Visible, false)]
-    [InlineData(DataGridViewElementStates.ReadOnly | DataGridViewElementStates.Selected, false)]
-    public void DataGridViewRow_ReadOnly_GetWithCustomState_ReturnsExpected(DataGridViewElementStates state, bool expected)
-    {
-        using var row = new CustomStateDataGridViewRow
-        {
-            StateResult = state
-        };
-        Assert.Equal(expected, row.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_ReadOnly_GetWithDataGridView_ReturnsExpected(bool dataGridViewReadOnly)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            ReadOnly = dataGridViewReadOnly
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(dataGridViewReadOnly, row.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_ReadOnly_GetShared_ThrowsInvalidOperationException(bool dataGridViewReadOnly)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            ReadOnly = dataGridViewReadOnly
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.ReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_ReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var row = new DataGridViewRow
-        {
-            ReadOnly = value
-        };
-        Assert.Equal(value, row.ReadOnly);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set same.
-        row.ReadOnly = value;
-        Assert.Equal(value, row.ReadOnly);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.ReadOnly) != 0);
-
-        // Set different.
-        row.ReadOnly = !value;
-        Assert.Equal(!value, row.ReadOnly);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.ReadOnly) != 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridViewRow_ReadOnly_SetWithDataGridView_GetReturnsExpected(bool dataGridViewReadOnly, bool value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            ReadOnly = dataGridViewReadOnly
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.ReadOnly = value;
-        Assert.Equal(dataGridViewReadOnly || value, row.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.ReadOnly = value;
-        Assert.Equal(dataGridViewReadOnly || value, row.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        row.ReadOnly = !value;
-        Assert.Equal(dataGridViewReadOnly || !value, row.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ReadOnly_SetWithDataGridViewReadOnly_Nop()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            ReadOnly = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-
-        // Unset read only.
-        control.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ReadOnly_SetWithCells_Success()
-    {
-        using var row = new DataGridViewRow();
-        using var cell1 = new SubDataGridViewCell();
-        using var cell2 = new SubDataGridViewCell();
-        row.Cells.Add(cell1);
-        row.Cells.Add(cell2);
-        cell2.ReadOnly = true;
-
-        // Set same.
-        row.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-        Assert.False(cell1.ReadOnly);
-        Assert.True(cell2.ReadOnly);
-
-        // Set true.
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-        Assert.True(cell1.ReadOnly);
-        Assert.True(cell2.ReadOnly);
-
-        // Set false.
-        row.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-        Assert.False(cell1.ReadOnly);
-        Assert.False(cell2.ReadOnly);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ReadOnly_SetWithCellsWithDataGridView_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 2,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.Cells[1].ReadOnly = true;
-
-        // Set same.
-        row.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-        Assert.False(row.Cells[0].ReadOnly);
-        Assert.False(row.Cells[1].ReadOnly);
-
-        // Set true.
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-        Assert.True(row.Cells[0].ReadOnly);
-        Assert.True(row.Cells[1].ReadOnly);
-
-        // Set false.
-        row.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-        Assert.False(row.Cells[0].ReadOnly);
-        Assert.False(row.Cells[1].ReadOnly);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ReadOnly_SetWithDataGridView_CallsRowStateChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowStateChanged += handler;
-
-        // Set true.
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.ReadOnly = false;
-        Assert.False(row.ReadOnly);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowStateChanged -= handler;
-        row.ReadOnly = true;
-        Assert.True(row.ReadOnly);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_ReadOnly_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.ReadOnly = true);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, DataGridViewTriState.True)]
-    [InlineData(false, DataGridViewTriState.False)]
-    public void DataGridViewRow_Resizable_GetWithDataGridView_ReturnsExpected(bool allowUserToResizeRows, DataGridViewTriState expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AllowUserToResizeRows = allowUserToResizeRows
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(expected, row.Resizable);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_Resizable_GetShared_ReturnsExpected(bool allowUserToResizeRows)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AllowUserToResizeRows = allowUserToResizeRows
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Resizable);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Resizable_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Resizable);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewTriState>]
-    public void DataGridViewRow_Resizable_Set_GetReturnsExpected(DataGridViewTriState value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Resizable = value
-        };
-        Assert.Equal(value, row.Resizable);
-
-        // Set same.
-        row.Resizable = value;
-        Assert.Equal(value, row.Resizable);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewTriState>]
-    public void DataGridViewRow_Resizable_SetWithCustomOldValue_GetReturnsExpected(DataGridViewTriState value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Resizable = DataGridViewTriState.True
-        };
-
-        row.Resizable = value;
-        Assert.Equal(value, row.Resizable);
-
-        // Set same.
-        row.Resizable = value;
-        Assert.Equal(value, row.Resizable);
-    }
-
-    public static IEnumerable<object[]> Resizable_SetWithDataGridView_TestData()
-    {
-        yield return new object[] { true, DataGridViewTriState.NotSet, DataGridViewTriState.True };
-        yield return new object[] { false, DataGridViewTriState.NotSet, DataGridViewTriState.False };
-        yield return new object[] { true, DataGridViewTriState.True, DataGridViewTriState.True };
-        yield return new object[] { false, DataGridViewTriState.True, DataGridViewTriState.True };
-        yield return new object[] { true, DataGridViewTriState.False, DataGridViewTriState.False };
-        yield return new object[] { false, DataGridViewTriState.False, DataGridViewTriState.False };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_SetWithDataGridView_TestData))]
-    public void DataGridViewRow_Resizable_SetWithDataGridView_GetReturnsExpected(bool allowUserToResizeRows, DataGridViewTriState value, DataGridViewTriState expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AllowUserToResizeRows = allowUserToResizeRows
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.Resizable = value;
-        Assert.Equal(expected, row.Resizable);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Resizable = value;
-        Assert.Equal(expected, row.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Resizable_SetWithDataGridView_CallsRowStateChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowStateChanged += handler;
-
-        // Set false.
-        row.Resizable = DataGridViewTriState.False;
-        Assert.Equal(DataGridViewTriState.False, row.Resizable);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.Resizable = DataGridViewTriState.False;
-        Assert.Equal(DataGridViewTriState.False, row.Resizable);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.Resizable = DataGridViewTriState.True;
-        Assert.Equal(DataGridViewTriState.True, row.Resizable);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowStateChanged -= handler;
-        row.Resizable = DataGridViewTriState.False;
-        Assert.Equal(DataGridViewTriState.False, row.Resizable);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Resizable_SetWithDataGridView_TestData))]
-    public void DataGridViewRow_Resizable_SetWithDataGridViewWithCustomOldValue_GetReturnsExpected(bool allowUserToResizeRows, DataGridViewTriState value, DataGridViewTriState expected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            AllowUserToResizeRows = allowUserToResizeRows
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.Resizable = DataGridViewTriState.True;
-
-        row.Resizable = value;
-        Assert.Equal(expected, row.Resizable);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Resizable = value;
-        Assert.Equal(expected, row.Resizable);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DataGridViewTriState>]
-    public void DataGridViewRow_Resizable_SetInvalid_ThrowsInvalidEnumArgumentException(DataGridViewTriState value)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => row.Resizable = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Selected_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.False(row.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Selected_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Selected_SetWithoutDataGridView_ThrowsInvalidOperationException()
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.Selected = true);
-        Assert.False(row.Selected);
-
-        row.Selected = false;
-        Assert.False(row.Selected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewSelectionMode.CellSelect, false)]
-    [InlineData(DataGridViewSelectionMode.FullRowSelect, true)]
-    [InlineData(DataGridViewSelectionMode.FullColumnSelect, false)]
-    [InlineData(DataGridViewSelectionMode.RowHeaderSelect, true)]
-    [InlineData(DataGridViewSelectionMode.ColumnHeaderSelect, false)]
-    public void DataGridViewRow_Selected_SetWithDataGridView_GetReturnsExpected(DataGridViewSelectionMode selectionMode, bool selected)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = selectionMode;
-        DataGridViewRow row = control.Rows[0];
-
-        // Set true.
-        row.Selected = true;
-        Assert.Equal(selected, (control.SelectedRows).Contains(row));
-        Assert.Equal(selected, row.Selected);
-
-        // Set same.
-        row.Selected = true;
-        Assert.Equal(selected, (control.SelectedRows).Contains(row));
-        Assert.Equal(selected, row.Selected);
-
-        // Set different.
-        row.Selected = false;
-        Assert.False((control.SelectedRows).Contains(row));
-        Assert.False(row.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Selected_SetMultipleNotMultiSelect_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            MultiSelect = false
-        };
-        control.Rows.Add(new DataGridViewRow());
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row1 = control.Rows[0];
-        DataGridViewRow row2 = control.Rows[1];
-
-        row1.Selected = true;
-        Assert.Same(row1, Assert.Single(control.SelectedRows));
-        Assert.True(row1.Selected);
-        Assert.False(row2.Selected);
-
-        row2.Selected = true;
-        Assert.Same(row2, Assert.Single(control.SelectedRows));
-        Assert.False(row1.Selected);
-        Assert.True(row2.Selected);
-
-        row1.Selected = false;
-        Assert.Empty(control.SelectedRows);
-        Assert.False(row1.Selected);
-        Assert.False(row2.Selected);
-
-        row2.Selected = false;
-        Assert.Empty(control.SelectedRows);
-        Assert.False(row1.Selected);
-        Assert.False(row2.Selected);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Selected_SetMultipleMultiSelect_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            MultiSelect = true
-        };
-        control.Rows.Add(new DataGridViewRow());
-        control.Rows.Add(new DataGridViewRow());
-        DataGridViewRow row1 = control.Rows[0];
-        DataGridViewRow row2 = control.Rows[1];
-
-        row1.Selected = true;
-        Assert.Same(row1, Assert.Single(control.SelectedRows));
-        Assert.True(row1.Selected);
-        Assert.False(row2.Selected);
-
-        row2.Selected = true;
-        Assert.Equal(new DataGridViewRow[] { row2, row1 }, control.SelectedRows.Cast<DataGridViewRow>());
-        Assert.True(row1.Selected);
-        Assert.True(row2.Selected);
-
-        row1.Selected = false;
-        Assert.Same(row2, Assert.Single(control.SelectedRows));
-        Assert.False(row1.Selected);
-        Assert.True(row2.Selected);
-
-        row2.Selected = false;
-        Assert.Empty(control.SelectedRows);
-        Assert.False(row1.Selected);
-        Assert.False(row2.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewRow_Selected_SetShared_ThrowsInvalidOperationException(bool value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Selected = value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_State_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(DataGridViewElementStates.Visible, row.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_State_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Tag_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Null(row.Tag);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Tag_GetShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Null(row.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_Set_GetReturnsExpected(string value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Tag = value
-        };
-        Assert.Equal(value, row.Tag);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_SetWithNonNullOldValue_GetReturnsExpected(string value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Tag = "OldValue"
-        };
-
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_SetWithDataGridView_GetReturnsExpected(string value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_SetWithDataGridViewWithNonNullOldValue_GetReturnsExpected(string value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.Tag = "OldValue";
-
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_SetShared_GetReturnsExpected(string value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void DataGridViewRow_Tag_SetSharedWithNonNullOldValue_GetReturnsExpected(string value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        row.Tag = "OldValue";
-
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Tag = value;
-        Assert.Equal(value, row.Tag);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Visible_GetWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.True(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Visible_GetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Visible);
-    }
-
-    public static IEnumerable<object[]> Visible_Set_TestData()
-    {
-        foreach (bool frozen in new bool[] { true, false })
-        {
-            yield return new object[] { frozen, true };
-            yield return new object[] { frozen, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void DataGridViewRow_Visible_Set_GetReturnsExpected(bool frozen, bool value)
-    {
-        using var row = new DataGridViewRow
-        {
-            Frozen = frozen,
-            Visible = value
-        };
-        Assert.Equal(value, row.Visible);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Visible) != 0);
-
-        // Set same.
-        row.Visible = value;
-        Assert.Equal(value, row.Visible);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Visible) != 0);
-
-        // Set different.
-        row.Visible = !value;
-        Assert.Equal(!value, row.Visible);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.Visible) != 0);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void DataGridViewRow_Visible_SetWithDataGridView_GetReturnsExpected(bool frozen, bool value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.Frozen = frozen;
-        row.Visible = value;
-        Assert.Equal(value, row.Visible);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Visible) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        row.Visible = value;
-        Assert.Equal(value, row.Visible);
-        Assert.Equal(value, (row.State & DataGridViewElementStates.Visible) != 0);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        row.Visible = !value;
-        Assert.Equal(!value, row.Visible);
-        Assert.Equal(!value, (row.State & DataGridViewElementStates.Visible) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Visible_SetWithDataGridView_CallsRowStateChanged()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        int callCount = 0;
-        DataGridViewRowStateChangedEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(row, e.Row);
-        };
-        control.RowStateChanged += handler;
-
-        // Set false.
-        row.Visible = false;
-        Assert.False(row.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        row.Visible = false;
-        Assert.False(row.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        row.Visible = true;
-        Assert.True(row.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowStateChanged -= handler;
-        row.Visible = true;
-        Assert.True(row.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Visible_SetNewRowIndexDifferent_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        Assert.Throws<InvalidOperationException>(() => row.Visible = false);
-        Assert.True(row.Visible);
-
-        row.Visible = true;
-        Assert.True(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Visible_SetShared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.Visible = true);
-        Assert.Throws<InvalidOperationException>(() => row.Visible = false);
-    }
-
-    public static IEnumerable<object[]> AdjustRowHeaderBorderStyle_WithDataGridView_TestData()
-    {
-        // Inset.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-        }
-
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Inset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-
-        // InsetDouble.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                true, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-            };
-            yield return new object[]
-            {
-                false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-            };
-        }
-
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-
-        // Outset.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-        }
-
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Outset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-
-        // OutsetDouble.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                true, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-            };
-            yield return new object[]
-            {
-                false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-            };
-        }
-
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-
-        // OutsetPartial.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            foreach (bool isLastVisibleRow in new bool[] { true, false })
-            {
-                yield return new object[]
-                {
-                    true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, isFirstDisplayedRow, isLastVisibleRow,
-                    true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-                };
-                yield return new object[]
-                {
-                    true, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, isFirstDisplayedRow, isLastVisibleRow,
-                    true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-                };
-            }
-        }
-
-        foreach (bool isLastVisibleRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, isLastVisibleRow,
-                true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                true, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, isLastVisibleRow,
-                true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.None
-            };
-        }
-
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, false,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, false,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, false,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-        yield return new object[]
-        {
-            false, true, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, false,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, false,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.Yes, DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, false,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-
-        // Single.
-        foreach (bool isFirstDisplayedRow in new bool[] { true, false })
-        {
-            yield return new object[]
-            {
-                true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-            };
-            yield return new object[]
-            {
-                false, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, isFirstDisplayedRow, true,
-                true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single
-            };
-        }
-
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single
-        };
-        yield return new object[]
-        {
-            false, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.Single, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single
-        };
-
-        // None.
-        yield return new object[]
-        {
-            true, true, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.None, true, true, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            true, false, RightToLeft.No, DataGridViewAdvancedCellBorderStyle.None, true, true, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustRowHeaderBorderStyle_WithDataGridView_TestData))]
-    public void DataGridViewRow_AdjustRowHeaderBorderStyle_InvokeWithDataGridView_ReturnsExpected(bool enableHeadersVisualStyles, bool rowHeadersVisible, RightToLeft rightToLeft, DataGridViewAdvancedCellBorderStyle all, bool singleVerticalBorderAdded, bool singleHorizontalBorderAdded, bool isFirstDisplayedColumn, bool isFirstDisplayedRow, bool returnsAdvanced, DataGridViewAdvancedCellBorderStyle expectedLeft, DataGridViewAdvancedCellBorderStyle expectedRight, DataGridViewAdvancedCellBorderStyle expectedTop, DataGridViewAdvancedCellBorderStyle expectedBottom)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            EnableHeadersVisualStyles = enableHeadersVisualStyles,
-            ColumnHeadersVisible = rowHeadersVisible,
-            RightToLeft = rightToLeft
-        };
-        DataGridViewRow row = control.Rows[0];
-
-        if (!Application.RenderWithVisualStyles && row.DataGridView.EnableHeadersVisualStyles)
-        {
-            // Not supported.
-            return;
-        }
-
-        var dataGridViewAdvancedBorderStyleInput = new DataGridViewAdvancedBorderStyle
-        {
-            All = all
-        };
-        var dataGridViewAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        DataGridViewAdvancedBorderStyle result = row.AdjustRowHeaderBorderStyle(dataGridViewAdvancedBorderStyleInput, dataGridViewAdvancedBorderStylePlaceholder, singleVerticalBorderAdded, singleHorizontalBorderAdded, isFirstDisplayedColumn, isFirstDisplayedRow);
-        Assert.Same(returnsAdvanced ? dataGridViewAdvancedBorderStylePlaceholder : dataGridViewAdvancedBorderStyleInput, result);
-
-        Assert.Equal(expectedLeft, result.Left);
-        Assert.Equal(expectedRight, result.Right);
-        Assert.Equal(expectedTop, result.Top);
-        Assert.Equal(expectedBottom, result.Bottom);
-    }
-
-    public static IEnumerable<object[]> AdjustRowHeaderBorderStyle_WithoutDataGridView_TestData()
-    {
-        // Inset.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Inset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Inset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Inset, true, false, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-
-        // InsetDouble.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.InsetDouble, true, false, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-
-        // Outset.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Outset, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Outset, true, true, false, true,
-            false, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Outset, true, false, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-
-        // OutsetDouble.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, false, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-
-        // OutsetPartial.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, false, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, false, false, false,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetPartial, DataGridViewAdvancedCellBorderStyle.OutsetPartial
-        };
-
-        // Single.
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Single, true, true, false, true,
-            true, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.Single
-        };
-
-        // None.
-
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.None, true, true, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None, DataGridViewAdvancedCellBorderStyle.None
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Single, true, true, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.Single, true, false, true, true,
-            false, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single, DataGridViewAdvancedCellBorderStyle.Single
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.InsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.InsetDouble, true, false, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset, DataGridViewAdvancedCellBorderStyle.InsetDouble, DataGridViewAdvancedCellBorderStyle.Inset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetDouble, true, false, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, true, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-        yield return new object[]
-        {
-            DataGridViewAdvancedCellBorderStyle.OutsetPartial, true, false, true, true,
-            true, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset, DataGridViewAdvancedCellBorderStyle.OutsetDouble, DataGridViewAdvancedCellBorderStyle.Outset
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustRowHeaderBorderStyle_WithoutDataGridView_TestData))]
-    public void DataGridViewRow_AdjustRowHeaderBorderStyle_InvokeWithoutDataGridView_ReturnsExpected(DataGridViewAdvancedCellBorderStyle all, bool singleVerticalBorderAdded, bool singleHorizontalBorderAdded, bool isFirstDisplayedColumn, bool isFirstDisplayedRow, bool returnsAdvanced, DataGridViewAdvancedCellBorderStyle expectedLeft, DataGridViewAdvancedCellBorderStyle expectedRight, DataGridViewAdvancedCellBorderStyle expectedTop, DataGridViewAdvancedCellBorderStyle expectedBottom)
-    {
-        using var row = new DataGridViewRow();
-
-        var dataGridViewAdvancedBorderStyleInput = new DataGridViewAdvancedBorderStyle
-        {
-            All = all
-        };
-        var dataGridViewAdvancedBorderStylePlaceholder = new DataGridViewAdvancedBorderStyle();
-        DataGridViewAdvancedBorderStyle result = row.AdjustRowHeaderBorderStyle(dataGridViewAdvancedBorderStyleInput, dataGridViewAdvancedBorderStylePlaceholder, singleVerticalBorderAdded, singleHorizontalBorderAdded, isFirstDisplayedColumn, isFirstDisplayedRow);
-        Assert.Same(returnsAdvanced ? dataGridViewAdvancedBorderStylePlaceholder : dataGridViewAdvancedBorderStyleInput, result);
-
-        Assert.Equal(expectedLeft, result.Left);
-        Assert.Equal(expectedRight, result.Right);
-        Assert.Equal(expectedTop, result.Top);
-        Assert.Equal(expectedBottom, result.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Clone_Empty_Success()
-    {
-        using var source = new DataGridViewRow();
-        using DataGridViewRow row = Assert.IsType<DataGridViewRow>(source.Clone());
-        Assert.Null(row.ContextMenuStrip);
-        Assert.Null(row.DataGridView);
-        Assert.NotNull(row.DefaultCellStyle);
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-        Assert.Equal(0, row.DividerHeight);
-        Assert.Empty(row.ErrorText);
-        Assert.False(row.Frozen);
-        Assert.NotNull(row.HeaderCell);
-        Assert.Equal(Control.DefaultFont.Height + 9, row.Height);
-        Assert.Equal(3, row.MinimumHeight);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(DataGridViewTriState.NotSet, row.Resizable);
-        Assert.False(row.Selected);
-        Assert.True(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Clone_NoDataGridView_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        var style = new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.BottomRight };
-        using var cell = new DataGridViewRowHeaderCell();
-        using var source = new DataGridViewRow
-        {
-            ContextMenuStrip = menu,
-            DefaultCellStyle = style,
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell),
-            DividerHeight = 10,
-            ErrorText = "errorText",
-            Frozen = true,
-            HeaderCell = cell,
-            Height = 5,
-            MinimumHeight = 4,
-            Resizable = DataGridViewTriState.True,
-            Visible = false
-        };
-        using DataGridViewRow row = Assert.IsType<DataGridViewRow>(source.Clone());
-        Assert.NotNull(row.ContextMenuStrip);
-        Assert.NotSame(menu, row.ContextMenuStrip);
-        Assert.Null(row.DataGridView);
-        Assert.Equal(style, row.DefaultCellStyle);
-        Assert.NotSame(style, row.DefaultCellStyle);
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-        Assert.Equal(10, row.DividerHeight);
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.True(row.Frozen);
-        Assert.NotNull(row.HeaderCell);
-        Assert.NotSame(cell, row.HeaderCell);
-        Assert.Equal(5, row.Height);
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(DataGridViewTriState.True, row.Resizable);
-        Assert.False(row.Selected);
-        Assert.False(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Clone_Subclass_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        var style = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomRight
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        using var source = new SubDataGridViewRow
-        {
-            ContextMenuStrip = menu,
-            DefaultCellStyle = style,
-            DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell),
-            DividerHeight = 10,
-            ErrorText = "errorText",
-            Frozen = true,
-            HeaderCell = cell,
-            Height = 5,
-            MinimumHeight = 4,
-            Resizable = DataGridViewTriState.True,
-            Visible = false
-        };
-        using SubDataGridViewRow row = Assert.IsType<SubDataGridViewRow>(source.Clone());
-        Assert.NotNull(row.ContextMenuStrip);
-        Assert.NotSame(menu, row.ContextMenuStrip);
-        Assert.Null(row.DataGridView);
-        Assert.Equal(style, row.DefaultCellStyle);
-        Assert.NotSame(style, row.DefaultCellStyle);
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-        Assert.Equal(10, row.DividerHeight);
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.True(row.Frozen);
-        Assert.NotNull(row.HeaderCell);
-        Assert.NotSame(cell, row.HeaderCell);
-        Assert.Equal(5, row.Height);
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.False(row.ReadOnly);
-        Assert.Equal(DataGridViewTriState.True, row.Resizable);
-        Assert.False(row.Selected);
-        Assert.False(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Clone_WithDataGridView_Success()
-    {
-        using var menu = new ContextMenuStrip();
-        var style = new DataGridViewCellStyle
-        {
-            Alignment = DataGridViewContentAlignment.BottomRight
-        };
-        using var cell = new DataGridViewRowHeaderCell();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow source = control.Rows[0];
-        source.ContextMenuStrip = menu;
-        source.DefaultCellStyle = style;
-        source.DefaultHeaderCellType = typeof(DataGridViewRowHeaderCell);
-        source.DividerHeight = 10;
-        source.ErrorText = "errorText";
-        source.Frozen = true;
-        source.HeaderCell = cell;
-        source.Height = 5;
-        source.MinimumHeight = 4;
-        source.ReadOnly = true;
-        source.Resizable = DataGridViewTriState.True;
-        source.Selected = true;
-        source.Visible = false;
-
-        using DataGridViewRow row = Assert.IsType<DataGridViewRow>(source.Clone());
-        Assert.NotNull(row.ContextMenuStrip);
-        Assert.NotSame(menu, row.ContextMenuStrip);
-        Assert.Null(row.DataGridView);
-        Assert.Equal(style, row.DefaultCellStyle);
-        Assert.NotSame(style, row.DefaultCellStyle);
-        Assert.Equal(typeof(DataGridViewRowHeaderCell), row.DefaultHeaderCellType);
-        Assert.Equal(10, row.DividerHeight);
-        Assert.Equal("errorText", row.ErrorText);
-        Assert.True(row.Frozen);
-        Assert.NotNull(row.HeaderCell);
-        Assert.NotSame(cell, row.HeaderCell);
-        Assert.Equal(5, row.Height);
-        Assert.Equal(4, row.MinimumHeight);
-        Assert.True(row.ReadOnly);
-        Assert.Equal(DataGridViewTriState.True, row.Resizable);
-        Assert.False(row.Selected);
-        Assert.False(row.Visible);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_InvokeNoColumns_Success()
-    {
-        using var control = new DataGridView();
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        row.CreateCells(control);
-        Assert.Empty(row.Cells);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_InvokeWithColumns_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        row.CreateCells(control);
-        Assert.Null(Assert.Single(row.Cells.Cast<DataGridViewCell>()).Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(new object[] { new object[0] })]
-    [InlineData(new object[] { new object[] { 1, 2, 3 } })]
-    public void DataGridViewRow_CreateCells_InvokeNoColumnsWithValues_Success(object[] values)
-    {
-        using var control = new DataGridView();
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        row.CreateCells(control, values);
-        Assert.Empty(row.Cells);
-    }
-
-    [WinFormsTheory]
-    [InlineData(new object[] { new object[0], null })]
-    [InlineData(new object[] { new object[] { 1 }, 1 })]
-    [InlineData(new object[] { new object[] { 1, 2, 3 }, 1 })]
-    public void DataGridViewRow_CreateCells_InvokeWithValues_Success(object[] values, object expectedValue)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        row.CreateCells(control, values);
-        Assert.Equal(expectedValue, Assert.Single(row.Cells.Cast<DataGridViewCell>()).Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_NullDataGridView_ThrowsArgumentNullException()
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentNullException>("dataGridView", () => row.CreateCells(null));
-        Assert.Throws<ArgumentNullException>("dataGridView", () => row.CreateCells(null, Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_HasDataGridView_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        using var newControl = new DataGridView();
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<InvalidOperationException>(() => row.CreateCells(newControl));
-        Assert.Throws<InvalidOperationException>(() => row.CreateCells(newControl, Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_ColumnHasNoCellTemplate_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView();
-        control.Columns.Add("Name", "Text");
-        control.Columns[0].CellTemplate = null;
-        using var row = new DataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.CreateCells(control));
-        Assert.Throws<InvalidOperationException>(() => row.CreateCells(control, Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCells_NullValues_ThrowsArgumentNullException()
-    {
-        using var row = new DataGridViewRow();
-        using var control = new DataGridView();
-        Assert.Throws<ArgumentNullException>("values", () => row.CreateCells(control, null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_CreateCellsInstance_Invoke_ReturnsEmpty()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Empty(row.CreateCellsInstance());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Dispose_WithoutContextMenuStrip_Nop()
-    {
-        using var row = new DataGridViewRow();
-        row.Dispose();
-        Assert.Null(row.ContextMenuStrip);
-
-        // Call multiple times.
-        row.Dispose();
-        Assert.Null(row.ContextMenuStrip);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Dispose_WithContextMenuStrip_Success()
-    {
-        using var row = new DataGridViewRow
-        {
-            ContextMenuStrip = new ContextMenuStrip()
-        };
-        row.Dispose();
-        Assert.NotNull(row.ContextMenuStrip);
-
-        // Call multiple times.
-        row.Dispose();
-        Assert.NotNull(row.ContextMenuStrip);
-    }
-
-    public static IEnumerable<object[]> DrawFocus_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, new DataGridViewCellStyle(), false };
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, 0, DataGridViewElementStates.None, new DataGridViewCellStyle(), false };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), 1, DataGridViewElementStates.Selected, new DataGridViewCellStyle { BackColor = Color.Blue, SelectionBackColor = Color.Red }, true };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), 1, DataGridViewElementStates.Selected, new DataGridViewCellStyle { BackColor = Color.Blue, SelectionBackColor = Color.Red }, true };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), 1, DataGridViewElementStates.None, new DataGridViewCellStyle { BackColor = Color.Blue, SelectionBackColor = Color.Red }, true };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), 1, DataGridViewElementStates.None, new DataGridViewCellStyle { BackColor = Color.Blue, SelectionBackColor = Color.Red }, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawFocus_TestData))]
-    public void DataGridViewRow_DrawFocus_Invoke_Success(Rectangle clipBounds, Rectangle bounds, int rowIndex, DataGridViewElementStates rowState, DataGridViewCellStyle cellStyle, bool cellsPaintSelectionBackground)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        row.DrawFocus(graphics, clipBounds, bounds, rowIndex, rowState, cellStyle, cellsPaintSelectionBackground);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DrawFocus_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var row = new SubDataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.DrawFocus(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), -1, DataGridViewElementStates.None, new DataGridViewCellStyle(), true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DrawFocus_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.DrawFocus(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), -1, DataGridViewElementStates.None, new DataGridViewCellStyle(), true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_DrawFocus_NullCellStyle_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("cellStyle", () => row.DrawFocus(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), -1, DataGridViewElementStates.None, null, true));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewRow_GetContextMenuStrip_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Null(row.GetContextMenuStrip(rowIndex));
-
-        // Set context menu.
-        using var menu = new ContextMenuStrip();
-        row.ContextMenuStrip = menu;
-        Assert.Same(menu, row.GetContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetContextMenuStrip_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        int callCount = 0;
-        control.RowContextMenuStripNeeded += (sender, e) => callCount++;
-        DataGridViewRow row1 = control.Rows[0];
-        using var menu1 = new ContextMenuStrip();
-        row1.ContextMenuStrip = menu1;
-        DataGridViewRow row2 = control.Rows[1];
-        using var menu2 = new ContextMenuStrip();
-        row2.ContextMenuStrip = menu2;
-        Assert.Same(menu1, row1.GetContextMenuStrip(0));
-        Assert.Same(menu1, row1.GetContextMenuStrip(0));
-        Assert.Same(menu2, row2.GetContextMenuStrip(1));
-        Assert.Same(menu2, row2.GetContextMenuStrip(1));
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetContextMenuStrip_InvokeWithDataGridViewVirtualMode_CallsRowContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewRowContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.RowContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, row.GetContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, row.GetContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetContextMenuStrip_InvokeWithDataGridViewDataSource_CallsRowContextMenuStripNeeded()
-    {
-        using var menu1 = new ContextMenuStrip();
-        using var menu2 = new ContextMenuStrip();
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        row.ContextMenuStrip = menu1;
-
-        int callCount = 0;
-        DataGridViewRowContextMenuStripNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same(menu1, e.ContextMenuStrip);
-            e.ContextMenuStrip = menu2;
-        };
-        control.RowContextMenuStripNeeded += handler;
-
-        Assert.Same(menu2, row.GetContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowContextMenuStripNeeded -= handler;
-        Assert.Same(menu1, row.GetContextMenuStrip(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewRow_GetContextMenuStrip_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.GetContextMenuStrip(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetContextMenuStrip_SharedRow_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<InvalidOperationException>(() => row.GetContextMenuStrip(-1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataGridViewRow_GetErrorText_Invoke_ReturnsExpected(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Empty(row.GetErrorText(rowIndex));
-
-        // Set context menu.
-        row.ErrorText = "ErrorText";
-        Assert.Equal("ErrorText", row.GetErrorText(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetErrorText_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row1 = control.Rows[0];
-        row1.ErrorText = "ErrorText1";
-        DataGridViewRow row2 = control.Rows[1];
-        row2.ErrorText = "ErrorText2";
-        Assert.Same("ErrorText1", row1.GetErrorText(0));
-        Assert.Same("ErrorText1", row1.GetErrorText(0));
-        Assert.Same("ErrorText2", row2.GetErrorText(1));
-        Assert.Same("ErrorText2", row2.GetErrorText(1));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetErrorText_InvokeWithDataGridViewVirtualMode_CallsRowErrorTextNeeded()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ErrorText = "ErrorText1";
-
-        int callCount = 0;
-        DataGridViewRowErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same("ErrorText1", e.ErrorText);
-            e.ErrorText = "ErrorText2";
-        };
-        control.RowErrorTextNeeded += handler;
-        Assert.Same("ErrorText2", row.GetErrorText(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowErrorTextNeeded -= handler;
-        Assert.Same("ErrorText1", row.GetErrorText(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetErrorText_InvokeWithDataGridViewDataSource_CallsRowErrorTextNeeded()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            DataSource = new[] { new { Name = "Name" } }
-        };
-        using var form = new Form();
-        form.Controls.Add(control);
-        Assert.NotNull(control.BindingContext);
-        DataGridViewRow row = control.Rows[0];
-        row.ErrorText = "ErrorText1";
-
-        int callCount = 0;
-        DataGridViewRowErrorTextNeededEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.RowIndex);
-            Assert.Same("ErrorText1", e.ErrorText);
-            e.ErrorText = "ErrorText2";
-        };
-        control.RowErrorTextNeeded += handler;
-        Assert.Equal("ErrorText2", row.GetErrorText(0));
-        Assert.Equal(1, callCount);
-
-        // Remove the handler.
-        control.RowErrorTextNeeded -= handler;
-        Assert.Equal("ErrorText1", row.GetErrorText(0));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewRow_GetErrorText_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.GetErrorText(rowIndex));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetErrorText_SharedRow_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<InvalidOperationException>(() => row.GetErrorText(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetState_Invoke_ReturnsExpected()
-    {
-        using var row = new DataGridViewRow();
-        Assert.Equal(DataGridViewElementStates.Visible, row.GetState(-1));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetState_InvokeWithDataGridView_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows[0];
-        row.ReadOnly = true;
-        Assert.Equal(DataGridViewElementStates.Visible | DataGridViewElementStates.ReadOnly, row.GetState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_GetState_InvokeShared_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Equal(DataGridViewElementStates.Visible, row.GetState(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewRow_GetState_NoDataGridViewInvalidRowIndex_ThrowsArgumentException(int rowIndex)
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentException>("rowIndex", () => row.GetState(rowIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void DataGridViewRow_GetState_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.GetState(rowIndex));
-    }
-
-    public static IEnumerable<object[]> Paint_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true };
-        yield return new object[] { new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), 0, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, true, false };
-        yield return new object[] { new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), 0, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, false, true };
-        yield return new object[] { new Rectangle(1000, 2000, 100, 100), new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, true, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_Invoke_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeHeadersInvisible_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeFrozen_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        control.Columns[0].Frozen = true;
-        control.Columns[0].Visible = true;
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeSingleVerticalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeSingleHorizontalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeFirstDisplayedScrollingColumnIndex_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeFirstDisplayedScrollingColumnIndexRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Paint_TestData))]
-    public void DataGridViewRow_Paint_InvokeSingleHorizontalBorderAddedDisplayedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_Invoke_CallsRowPrePaint()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-
-        int callCount = 0;
-        DataGridViewRowPrePaintEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 3, 4), e.ClipBounds);
-            Assert.Equal(new Rectangle(2, 3, 4, 5), e.RowBounds);
-            Assert.Equal(1, e.RowIndex);
-            Assert.Equal(DataGridViewElementStates.Frozen, e.State);
-            Assert.Empty(e.ErrorText);
-            Assert.True(e.IsFirstDisplayedRow);
-            Assert.False(e.IsLastVisibleRow);
-            Assert.Equal(DataGridViewPaintParts.All, e.PaintParts);
-            Assert.False(e.Handled);
-
-            if (callCount > 1)
-            {
-                e.Handled = true;
-            }
-        };
-        control.RowPrePaint += handler;
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(1, callCount);
-
-        // Call again, handled.
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowPrePaint -= handler;
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_InvokeNullGraphics_DoesNotCallRowPrePaint()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-
-        int callCount = 0;
-        DataGridViewRowPrePaintEventHandler handler = (sender, e) => callCount++;
-        control.RowPrePaint += handler;
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-
-        // Call again, handled.
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.RowPrePaint -= handler;
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_InvokeWithGraphics_CallsRowPostPaint()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-
-        int callCount = 0;
-        DataGridViewRowPostPaintEventHandler handler = (sender, e) =>
-        {
-            callCount++;
-            Assert.Same(control, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 3, 4), e.ClipBounds);
-            Assert.Equal(new Rectangle(2, 3, 4, 5), e.RowBounds);
-            Assert.Equal(1, e.RowIndex);
-            Assert.Equal(DataGridViewElementStates.Frozen, e.State);
-            Assert.Empty(e.ErrorText);
-            Assert.True(e.IsFirstDisplayedRow);
-            Assert.False(e.IsLastVisibleRow);
-        };
-        control.RowPostPaint += handler;
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowPostPaint -= handler;
-        row.Paint(graphics, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_InvokeNullGraphics_DoesNotCallRowPostPaint()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-
-        int callCount = 0;
-        DataGridViewRowPostPaintEventHandler handler = (sender, e) => callCount++;
-        control.RowPostPaint += handler;
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-
-        // Call with nothing to do.
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, Rectangle.Empty, new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.RowPostPaint -= handler;
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, Rectangle.Empty, new Rectangle(2, 3, 4, 5), 1, DataGridViewElementStates.Frozen, true, false));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_NullGraphicsEmptyRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, Rectangle.Empty, Rectangle.Empty, 1, DataGridViewElementStates.None, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_NullGraphicsNonEmptyRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, Rectangle.Empty, new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.None, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_NullGraphicsNonEmptyClipRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.Paint(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.None, true, true));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_Paint_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.Paint(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewRow_Paint_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => row.Paint(graphics, new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), rowIndex, DataGridViewElementStates.None, true, true));
-    }
-
-    public static IEnumerable<object[]> PaintCells_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All };
-        yield return new object[] { new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), 0, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, true, false, DataGridViewPaintParts.All };
-        yield return new object[] { new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), 0, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, false, true, DataGridViewPaintParts.None };
-        yield return new object[] { new Rectangle(1000, 2000, 100, 100), new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.Displayed | DataGridViewElementStates.Displayed, true, false, DataGridViewPaintParts.All };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_Invoke_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeHeadersInvisible_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeFrozen_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        control.Columns[0].Frozen = true;
-        control.Columns[0].Visible = true;
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeSingleVerticalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeSingleHorizontalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeFirstDisplayedScrollingColumnIndex_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeFirstDisplayedScrollingColumnIndexRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintCells_InvokeSingleHorizontalBorderAddedDisplayedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintCells_NullGraphicsEmptyRectangle_Nop()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintCells(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintCells_NullGraphicsNonEmptyRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintCells(null, Rectangle.Empty, new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintCells_NullGraphicsNoVisibleColumns_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintCells(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 100, 100), -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintCells_NullGraphicsNonEmptyClipRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintCells(null, new Rectangle(1, 2, 1000, 10000), new Rectangle(1, 2, 1000, 1000), 1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintCells_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.PaintCells(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewRow_PaintCells_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        control.Columns[0].Frozen = true;
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.PaintCells(graphics, new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), rowIndex, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsTheory]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.None - 1))]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.All + 1))]
-    public void DataGridViewRow_PaintCells_InvalidPaintParts_ThrowsArgumentException(DataGridViewPaintParts paintParts)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentException>(() => row.PaintCells(graphics, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, paintParts));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_Invoke_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeHeadersInvisible_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeFrozen_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        control.Columns[0].Frozen = true;
-        control.Columns[0].Visible = true;
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeSingleVerticalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeSingleHorizontalBorderAddedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeFirstDisplayedScrollingColumnIndex_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeFirstDisplayedScrollingColumnIndexRightToLeft_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            FirstDisplayedScrollingColumnIndex = 0,
-            RightToLeft = RightToLeft.Yes
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PaintCells_TestData))]
-    public void DataGridViewRow_PaintHeader_InvokeSingleHorizontalBorderAddedDisplayedDataGridView_Success(Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-    {
-        if (rowIndex == -1)
-        {
-            return;
-        }
-
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            ColumnHeadersVisible = false,
-            FirstDisplayedScrollingColumnIndex = 0
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        row.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_NullGraphicsEmptyRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintHeader(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_NullGraphicsNonEmptyRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintHeader(null, Rectangle.Empty, new Rectangle(1, 2, 100, 100), -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_NullGraphicsNonEmptyClipRectangle_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintHeader(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 100, 100), 1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_NullGraphicsRowHeadersNotVisible_ThrowsArgumentNullException()
-    {
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2,
-            RowHeadersVisible = false
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[1];
-        Assert.Throws<ArgumentNullException>("graphics", () => row.PaintHeader(null, new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_NoDataGridView_ThrowsInvalidOperationException()
-    {
-        using var row = new SubDataGridViewRow();
-        Assert.Throws<InvalidOperationException>(() => row.PaintHeader(null, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(2)]
-    public void DataGridViewRow_PaintHeader_InvalidRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => row.PaintHeader(graphics, new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), rowIndex, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_PaintHeader_SharedRowIndex_ThrowsInvalidOperationException()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<InvalidOperationException>(() => row.PaintHeader(graphics, new Rectangle(1, 2, 100, 100), new Rectangle(1, 2, 100, 100), -1, DataGridViewElementStates.None, true, true, DataGridViewPaintParts.All));
-    }
-
-    [WinFormsTheory]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.None - 1))]
-    [InlineData((DataGridViewPaintParts)(DataGridViewPaintParts.All + 1))]
-    public void DataGridViewRow_PaintHeader_InvalidPaintParts_ThrowsInvalidEnumArgumentException(DataGridViewPaintParts paintParts)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var rowTemplate = new SubDataGridViewRow();
-        using var control = new DataGridView
-        {
-            RowTemplate = rowTemplate,
-            ColumnCount = 1,
-            RowCount = 2
-        };
-        SubDataGridViewRow row = (SubDataGridViewRow)control.Rows[0];
-        Assert.Throws<InvalidEnumArgumentException>("paintParts", () => row.PaintHeader(graphics, Rectangle.Empty, Rectangle.Empty, -1, DataGridViewElementStates.None, true, true, paintParts));
-    }
-
-    [WinFormsTheory]
-    [InlineData(new object[0], true, null)]
-    [InlineData(new object[] { 1 }, true, 1)]
-    [InlineData(new object[] { 1, 2 }, false, 1)]
-    public void DataGridViewRow_SetValues_HasCellsWithoutDataGridView_Success(object[] values, bool expectedResult, object expectedValue)
-    {
-        using var row = new DataGridViewRow();
-        using var cell = new SubDataGridViewCell();
-        row.Cells.Add(cell);
-        Assert.Equal(expectedResult, row.SetValues(values));
-        Assert.Equal(expectedValue, Assert.Single(row.Cells.Cast<DataGridViewCell>()).Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(new object[0], true, null)]
-    [InlineData(new object[] { 1 }, true, 1)]
-    [InlineData(new object[] { 1, 2 }, false, 1)]
-    public void DataGridViewRow_SetValues_HasCellsWithDataGridView_Success(object[] values, bool expectedResult, object expectedValue)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Equal(expectedResult, row.SetValues(values));
-        Assert.Equal(expectedValue, Assert.Single(row.Cells.Cast<DataGridViewCell>()).Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_SetValues_CantSet_ReturnsFalse()
-    {
-        using var row = new DataGridViewRow();
-        row.Cells.Add(new CantSetDataGridViewCell());
-        Assert.False(row.SetValues(new object[] { 1 }));
-        Assert.Null(Assert.Single(row.Cells.Cast<DataGridViewCell>()).Value);
-    }
-
-    private class CantSetDataGridViewCell : DataGridViewCell
-    {
-        protected override bool SetValue(int rowIndex, object value) => false;
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_SetValues_NullValue_ThrowsArgumentNullException()
-    {
-        using var row = new DataGridViewRow();
-        Assert.Throws<ArgumentNullException>("values", () => row.SetValues(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_SetValues_VirtualDataGridView_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1,
-            VirtualMode = true
-        };
-        DataGridViewRow row = control.Rows[0];
-        Assert.Throws<InvalidOperationException>(() => row.SetValues(Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRow_SetValues_Shared_ThrowsInvalidOperationException()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 1
-        };
-        DataGridViewRow row = control.Rows.SharedRow(0);
-        Assert.Throws<InvalidOperationException>(() => row.SetValues(Array.Empty<object>()));
-    }
-
-    private class CustomStateDataGridViewRow : DataGridViewRow
-    {
-        public DataGridViewElementStates StateResult { get; set; }
-
-        public override DataGridViewElementStates State => StateResult;
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-
-    public class SubDataGridViewRow : DataGridViewRow
-    {
-        public new DataGridViewCellCollection CreateCellsInstance() => base.CreateCellsInstance();
-
-#pragma warning disable xUnit1013
-
-        public new void DrawFocus(Graphics graphics, Rectangle clipBounds, Rectangle bounds, int rowIndex, DataGridViewElementStates rowState, DataGridViewCellStyle cellStyle, bool cellsPaintSelectionBackground)
-        {
-            base.DrawFocus(graphics, clipBounds, bounds, rowIndex, rowState, cellStyle, cellsPaintSelectionBackground);
-        }
-
-        public new void Paint(Graphics graphics, Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow)
-        {
-            base.Paint(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow);
-        }
-
-        public new void PaintCells(Graphics graphics, Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-        {
-            base.PaintCells(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-        }
-
-        public new void PaintHeader(Graphics graphics, Rectangle clipBounds, Rectangle rowBounds, int rowIndex, DataGridViewElementStates rowState, bool isFirstDisplayedRow, bool isLastVisibleRow, DataGridViewPaintParts paintParts)
-        {
-            base.PaintHeader(graphics, clipBounds, rowBounds, rowIndex, rowState, isFirstDisplayedRow, isLastVisibleRow, paintParts);
-        }
-
-#pragma warning restore xUnit1013
-
-        public new bool IsRow => base.IsRow;
-
-        public new DataGridViewHeaderCell HeaderCellCore
-        {
-            get => base.HeaderCellCore;
-            set => base.HeaderCellCore = value;
-        }
-
-        [WinFormsFact]
-        public void DataGridViewRow_AccessibilityObject_Get_ReturnsSameInstance()
-        {
-            Assert.Same(AccessibilityObject, AccessibilityObject);
-            DataGridViewRowAccessibleObject accessibilityObject = Assert.IsType<DataGridViewRowAccessibleObject>(AccessibilityObject);
-            Assert.Equal(this, accessibilityObject.Owner);
-        }
-
-        [WinFormsFact]
-        public void DataGridViewRow_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-        {
-            DataGridViewRowAccessibleObject accessibilityObject = Assert.IsType<DataGridViewRowAccessibleObject>(CreateAccessibilityInstance());
-            Assert.Equal(this, accessibilityObject.Owner);
-        }
-    }
-}
-
-internal class TestDataGridViewRow : DataGridViewRow
-{
-    internal int GetDefaultHeight()
-    {
-        return this.TestAccessor().Dynamic.DefaultHeight;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAccessibleObjectTests.cs
deleted file mode 100644
index 7f0ad14fb27..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAccessibleObjectTests.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewRowsAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewRowsAccessibleObject_Ctor_Default_IfHandleIsCreated()
-    {
-        using DataGridView dataGridView = new DataGridView
-        {
-            RowCount = 5,
-            Height = 87
-        };
-
-        dataGridView.CreateControl();
-        dataGridView.Rows[0].Height = 20;
-        dataGridView.Rows[1].Height = 20;
-        dataGridView.Rows[2].Height = 20;
-        dataGridView.Rows[3].Height = 20;
-        dataGridView.Rows[4].Height = 20;
-
-        AccessibleObject accObject = dataGridView.AccessibilityObject; //it is necessary to be in time to initialize elements
-
-        int accRowHeightSum = 0;
-        for (int i = 0; i < 5; i++)
-        {
-            accRowHeightSum += dataGridView.Rows[i].AccessibilityObject.BoundingRectangle.Height;
-        }
-
-        int accDataGridViewHeight = dataGridView.AccessibilityObject.BoundingRectangle.Height;
-        int borders = 2 * dataGridView.BorderWidth; //top border and bottom border
-
-        Assert.Equal(accRowHeightSum, accDataGridViewHeight - borders - dataGridView.ColumnHeadersHeight);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewRowsAccessibleObject_Ctor_Default_IfHandleIsNotCreated()
-    {
-        using DataGridView dataGridView = new DataGridView
-        {
-            RowCount = 5,
-            Height = 87
-        };
-
-        dataGridView.Rows[0].Height = 20;
-        dataGridView.Rows[1].Height = 20;
-        dataGridView.Rows[2].Height = 20;
-        dataGridView.Rows[3].Height = 20;
-        dataGridView.Rows[4].Height = 20;
-
-        AccessibleObject accObject = dataGridView.AccessibilityObject; //it is necessary to be in time to initialize elements
-
-        int accRowHeightSum = 0;
-        for (int i = 0; i < 5; i++)
-        {
-            accRowHeightSum += dataGridView.Rows[i].AccessibilityObject.BoundingRectangle.Height;
-        }
-
-        int accDataGridViewHeight = dataGridView.AccessibilityObject.BoundingRectangle.Height;
-
-        Assert.Equal(0, accDataGridViewHeight);
-        Assert.Equal(0, accRowHeightSum);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAddedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAddedEventArgsTests.cs
deleted file mode 100644
index 0aa7b5ad79c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsAddedEventArgsTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowsAddedEventArgsTests
-{
-    [Theory]
-    [InlineData(-2, -2)]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int rowIndex, int rowCount)
-    {
-        var e = new DataGridViewRowsAddedEventArgs(rowIndex, rowCount);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(rowCount, e.RowCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsRemovedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsRemovedEventArgsTests.cs
deleted file mode 100644
index cc6bcdaf00f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewRowsRemovedEventArgsTests.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataGridViewRowsRemovedEventArgsTests
-{
-    [Theory]
-    [InlineData(0, 1)]
-    [InlineData(1, 2)]
-    public void Ctor_Int_Int(int rowIndex, int rowCount)
-    {
-        var e = new DataGridViewRowsRemovedEventArgs(rowIndex, rowCount);
-        Assert.Equal(rowIndex, e.RowIndex);
-        Assert.Equal(rowCount, e.RowCount);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void Ctor_NegativeRowIndex_ThrowsArgumentOutOfRangeException(int rowIndex)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowIndex", () => new DataGridViewRowsRemovedEventArgs(rowIndex, 1));
-    }
-
-    [Theory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void Ctor_NegativeRowCount_ThrowsArgumentOutOfRangeException(int rowCount)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("rowCount", () => new DataGridViewRowsRemovedEventArgs(1, rowCount));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellCollectionTests.cs
deleted file mode 100644
index 7b108427ae9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellCollectionTests.cs
+++ /dev/null
@@ -1,523 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewSelectedCellCollectionTests
-{
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_Properties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_Properties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_Item_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Equal(control.Rows[2].Cells[0], collection[0]);
-        Assert.Equal(control.Rows[0].Cells[0], collection[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedCellCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedCellCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_Clear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Throws<NotSupportedException>(() => collection.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_Contains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.True(collection.Contains(control.Rows[0].Cells[0]));
-        Assert.False(collection.Contains(control.Rows[1].Cells[0]));
-        Assert.True(collection.Contains(control.Rows[2].Cells[0]));
-        Assert.False(collection.Contains(new SubDataGridViewCell()));
-        Assert.False(collection.Contains(null));
-    }
-
-    public static IEnumerable<object[]> Contains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Contains_TestData))]
-    public void DataGridViewSelectedCellCollection_Contains_InvokeEmpty_ReturnsFalse(DataGridViewCell dataGridViewCell)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.False(collection.Contains(dataGridViewCell));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_CopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Rows[2].Cells[0], control.Rows[0].Cells[0] }, array);
-    }
-
-    public static IEnumerable<object[]> Insert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new SubDataGridViewCell() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Insert_TestData))]
-    public void DataGridViewSelectedCellCollection_Insert_Invoke_ThrowsNotSupportedException(int index, DataGridViewCell dataGridViewCell)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridViewCell));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListProperties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Equal(0, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListProperties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Equal(2, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListItem_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Equal(control.Rows[2].Cells[0], iList[0]);
-        Assert.Equal(control.Rows[0].Cells[0], iList[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedCellCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedCellCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    public static IEnumerable<object[]> IListItem_SetTestData()
-    {
-        yield return new object[] { 0, null };
-        yield return new object[] { -1, new object() };
-        yield return new object[] { 1, new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListItem_SetTestData))]
-    public void DataGridViewSelectedCellCollection_IListItem_Set_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList[index] = value);
-    }
-
-    public static IEnumerable<object[]> IListAdd_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListAdd_TestData))]
-    public void DataGridViewSelectedCellCollection_IListAdd_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Add(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListClear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListCopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListCopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Rows[2].Cells[0], control.Rows[0].Cells[0] }, array);
-    }
-
-    public static IEnumerable<object[]> IListContains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListContains_TestData))]
-    public void DataGridViewSelectedCellCollection_IListContains_InvokeEmpty_ReturnsFalse(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.False(iList.Contains(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListContains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.True(iList.Contains(control.Rows[0].Cells[0]));
-        Assert.False(iList.Contains(control.Rows[1].Cells[0]));
-        Assert.True(iList.Contains(control.Rows[2].Cells[0]));
-        Assert.False(iList.Contains(new SubDataGridViewCell()));
-        Assert.False(iList.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListGetEnumerator_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListGetEnumerator_InvokeNotEmpty_Success()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Rows[2].Cells[0], enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Rows[0].Cells[0], enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    public static IEnumerable<object[]> IListIndexOf_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListIndexOf_TestData))]
-    public void DataGridViewSelectedCellCollection_IListIndexOf_InvokeEmpty_ReturnsMinusOne(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Equal(-1, iList.IndexOf(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellCollection_IListIndexOf_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            RowCount = 3,
-            ColumnCount = 1,
-            SelectionMode = DataGridViewSelectionMode.CellSelect
-        };
-        control.Rows[0].Cells[0].Selected = true;
-        control.Rows[1].Cells[0].Selected = false;
-        control.Rows[2].Cells[0].Selected = true;
-
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Equal(1, iList.IndexOf(control.Rows[0].Cells[0]));
-        Assert.Equal(-1, iList.IndexOf(control.Rows[1].Cells[0]));
-        Assert.Equal(0, iList.IndexOf(control.Rows[2].Cells[0]));
-        Assert.Equal(-1, iList.IndexOf(new SubDataGridViewCell()));
-        Assert.Equal(-1, iList.IndexOf(null));
-    }
-
-    public static IEnumerable<object[]> IListInsert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new object() };
-            yield return new object[] { index, new SubDataGridViewCell() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListInsert_TestData))]
-    public void DataGridViewSelectedCellCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Insert(index, value));
-    }
-
-    public static IEnumerable<object[]> IListRemove_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new SubDataGridViewCell() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_TestData))]
-    public void DataGridViewSelectedCellCollection_IListRemove_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Remove(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedCellCollection_IListRemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedCellCollection collection = control.SelectedCells;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellsAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellsAccessibleObjectTests.cs
deleted file mode 100644
index ba989fa16f7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedCellsAccessibleObjectTests.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewSelectedCellsAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Ctor_Default()
-    {
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._parentAccessibleObject);
-        Assert.Equal(AccessibleRole.Grouping, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Name_ReturnsExpected()
-    {
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(SR.DataGridView_AccSelectedCellsName, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Value_ReturnsExpected()
-    {
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(SR.DataGridView_AccSelectedCellsName, accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_State_ReturnsExpected()
-    {
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(AccessibleStates.Selected | AccessibleStates.Selectable, accessibleObject.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Parent_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetSelected_ReturnsExpected()
-    {
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(accessibleObject, accessibleObject.GetSelected());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetFocused_ReturnsExpected_IfCurrentCellIsSelected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Rows.Add("Row1");
-        DataGridViewCell currentCell = control.Rows[0].Cells[0];
-        control.CurrentCell = currentCell;
-        currentCell.Selected = true;
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.NotNull(currentCell);
-        Assert.Equal(currentCell.AccessibilityObject, accessibleObject.GetFocused());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetFocused_ReturnsNull_IfCurrentCellIsNotSelected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewCell currentCell = control.Rows[0].Cells[0];
-        control.CurrentCell = currentCell;
-        currentCell.Selected = false;
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.NotNull(currentCell);
-        Assert.Null(accessibleObject.GetFocused());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        int selecetedCellsCount = 2;
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Columns.Add("Column 3", "Header text 3");
-        control.Rows.Add("Row1");
-
-        for (int i = 0; i < selecetedCellsCount; i++)
-        {
-            control.Rows[0].Cells[i].Selected = true;
-        }
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Equal(selecetedCellsCount, accessibleObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-
-        DataGridViewCell selecetedCell1 = control.Rows[0].Cells[0];
-        selecetedCell1.Selected = true;
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Navigate_ReturnsExpected_NoChilds()
-    {
-        using DataGridView control = new();
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_Navigate_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-
-        DataGridViewCell selecetedCell1 = control.Rows[0].Cells[0];
-        selecetedCell1.Selected = true;
-
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Equal(1, accessibleObject.GetChildCount());
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedCellsAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-        DataGridViewCell selecetedCell1 = control.Rows[0].Cells[0];
-        selecetedCell1.Selected = true;
-        Type type = typeof(DataGridView)
-            .GetNestedType("DataGridViewSelectedCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control.AccessibilityObject });
-
-        Assert.Equal("Selected Cells", accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedColumnCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedColumnCollectionTests.cs
deleted file mode 100644
index 39d74dcf828..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedColumnCollectionTests.cs
+++ /dev/null
@@ -1,567 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewSelectedColumnCollectionTests
-{
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_Properties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_Properties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_Item_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Equal(control.Columns[2], collection[0]);
-        Assert.Equal(control.Columns[0], collection[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedColumnCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedColumnCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_Clear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Throws<NotSupportedException>(() => collection.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_Contains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.True(collection.Contains(control.Columns[0]));
-        Assert.False(collection.Contains(control.Columns[1]));
-        Assert.True(collection.Contains(control.Columns[2]));
-        Assert.False(collection.Contains(new DataGridViewColumn()));
-        Assert.False(collection.Contains(null));
-    }
-
-    public static IEnumerable<object[]> Contains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Contains_TestData))]
-    public void DataGridViewSelectedColumnCollection_Contains_InvokeEmpty_ReturnsFalse(DataGridViewColumn dataGridViewColumn)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.False(collection.Contains(dataGridViewColumn));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_CopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Columns[2], control.Columns[0] }, array);
-    }
-
-    public static IEnumerable<object[]> Insert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new DataGridViewColumn() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Insert_TestData))]
-    public void DataGridViewSelectedColumnCollection_Insert_Invoke_ThrowsNotSupportedException(int index, DataGridViewColumn dataGridViewColumn)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridViewColumn));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListProperties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Equal(0, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListProperties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Equal(2, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListItem_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Equal(control.Columns[2], iList[0]);
-        Assert.Equal(control.Columns[0], iList[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedColumnCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedColumnCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    public static IEnumerable<object[]> IListItem_SetTestData()
-    {
-        yield return new object[] { 0, null };
-        yield return new object[] { -1, new object() };
-        yield return new object[] { 1, new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListItem_SetTestData))]
-    public void DataGridViewSelectedColumnCollection_IListItem_Set_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList[index] = value);
-    }
-
-    public static IEnumerable<object[]> IListAdd_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListAdd_TestData))]
-    public void DataGridViewSelectedColumnCollection_IListAdd_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Add(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListClear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListCopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListCopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Columns[2], control.Columns[0] }, array);
-    }
-
-    public static IEnumerable<object[]> IListContains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListContains_TestData))]
-    public void DataGridViewSelectedColumnCollection_IListContains_InvokeEmpty_ReturnsFalse(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.False(iList.Contains(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListContains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.True(iList.Contains(control.Columns[0]));
-        Assert.False(iList.Contains(control.Columns[1]));
-        Assert.True(iList.Contains(control.Columns[2]));
-        Assert.False(iList.Contains(new DataGridViewColumn()));
-        Assert.False(iList.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListGetEnumerator_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListGetEnumerator_InvokeNotEmpty_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Columns[2], enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Columns[0], enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    public static IEnumerable<object[]> IListIndexOf_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListIndexOf_TestData))]
-    public void DataGridViewSelectedColumnCollection_IListIndexOf_InvokeEmpty_ReturnsMinusOne(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Equal(-1, iList.IndexOf(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedColumnCollection_IListIndexOf_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 3,
-            RowCount = 1
-        };
-        control.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.Columns[2].SortMode = DataGridViewColumnSortMode.NotSortable;
-        control.SelectionMode = DataGridViewSelectionMode.ColumnHeaderSelect;
-
-        control.Columns[0].Selected = true;
-        control.Columns[1].Selected = false;
-        control.Columns[2].Selected = true;
-
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Equal(1, iList.IndexOf(control.Columns[0]));
-        Assert.Equal(-1, iList.IndexOf(control.Columns[1]));
-        Assert.Equal(0, iList.IndexOf(control.Columns[2]));
-        Assert.Equal(-1, iList.IndexOf(new DataGridViewColumn()));
-        Assert.Equal(-1, iList.IndexOf(null));
-    }
-
-    public static IEnumerable<object[]> IListInsert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new object() };
-            yield return new object[] { index, new DataGridViewColumn() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListInsert_TestData))]
-    public void DataGridViewSelectedColumnCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Insert(index, value));
-    }
-
-    public static IEnumerable<object[]> IListRemove_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewColumn() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_TestData))]
-    public void DataGridViewSelectedColumnCollection_IListRemove_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Remove(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedColumnCollection_IListRemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedColumnCollection collection = control.SelectedColumns;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCellsAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCellsAccessibleObjectTests.cs
deleted file mode 100644
index ddd456f3ce1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCellsAccessibleObjectTests.cs
+++ /dev/null
@@ -1,217 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewSelectedRowCellsAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Ctor_Default()
-    {
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._owningDataGridViewRow);
-        Assert.Equal(AccessibleRole.Grouping, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Name_ReturnsExpected()
-    {
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.Equal(SR.DataGridView_AccSelectedRowCellsName, accessibleObject.Name);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Value_ReturnsExpected()
-    {
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.Equal(SR.DataGridView_AccSelectedRowCellsName, accessibleObject.Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_State_ReturnsExpected()
-    {
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.Equal(AccessibleStates.Selected | AccessibleStates.Selectable, accessibleObject.State);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Parent_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Rows.Add("Row1");
-        DataGridViewRow row = control.Rows[0];
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { row }, null);
-
-        Assert.Equal(row.AccessibilityObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetSelected_ReturnsExpected()
-    {
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { null }, null);
-
-        Assert.Equal(accessibleObject, accessibleObject.GetSelected());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetFocused_ReturnsExpected_IfCurrentCellIsSelected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Rows.Add("Row1");
-        DataGridViewCell currentCell = control.Rows[0].Cells[0];
-        control.CurrentCell = currentCell;
-        currentCell.Selected = true;
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { control.Rows[0] }, null);
-
-        Assert.NotNull(currentCell);
-        Assert.Equal(currentCell.AccessibilityObject, accessibleObject.GetFocused());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetFocused_ReturnsNull_IfCurrentCellIsNotSelected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        DataGridViewCell currentCell = control.Rows[0].Cells[0];
-        control.CurrentCell = currentCell;
-        currentCell.Selected = false;
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { control.Rows[0] }, null);
-
-        Assert.NotNull(currentCell);
-        Assert.Null(accessibleObject.GetFocused());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        int selecetedCellsCount = 2;
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Columns.Add("Column 3", "Header text 3");
-        control.Rows.Add("Row1");
-        DataGridViewRow row = control.Rows[0];
-
-        for (int i = 0; i < selecetedCellsCount; i++)
-        {
-            row.Cells[i].Selected = true;
-        }
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { row }, null);
-
-        Assert.Equal(selecetedCellsCount, accessibleObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-        DataGridViewRow row = control.Rows[0];
-
-        DataGridViewCell selecetedCell1 = row.Cells[0];
-        selecetedCell1.Selected = true;
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { row }, null);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Navigate_ReturnsExpected_NoChilds()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { control.Rows[0] }, null);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(accessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_Navigate_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-        DataGridViewRow row = control.Rows[0];
-
-        DataGridViewCell selecetedCell1 = row.Cells[0];
-        selecetedCell1.Selected = true;
-
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { row }, null);
-
-        Assert.Equal(1, accessibleObject.GetChildCount());
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(selecetedCell1.AccessibilityObject, accessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCellsAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        control.Columns.Add("Column 1", "Header text 1");
-        control.Columns.Add("Column 2", "Header text 2");
-        control.Rows.Add("Row1");
-        DataGridViewRow row = control.Rows[0];
-        DataGridViewCell selecetedCell1 = row.Cells[0];
-        selecetedCell1.Selected = true;
-        Type type = typeof(DataGridViewRow)
-            .GetNestedType("DataGridViewSelectedRowCellsAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { row }, null);
-
-        Assert.Equal("Selected Row Cells", accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCollectionTests.cs
deleted file mode 100644
index 1a19b71b930..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewSelectedRowCollectionTests.cs
+++ /dev/null
@@ -1,507 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewSelectedRowCollectionTests
-{
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_Properties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_Properties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_Item_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Equal(control.Rows[2], collection[0]);
-        Assert.Equal(control.Rows[0], collection[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedRowCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedRowCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_Clear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Throws<NotSupportedException>(() => collection.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_Contains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.True(collection.Contains(control.Rows[0]));
-        Assert.False(collection.Contains(control.Rows[1]));
-        Assert.True(collection.Contains(control.Rows[2]));
-        Assert.False(collection.Contains(new DataGridViewRow()));
-        Assert.False(collection.Contains(null));
-    }
-
-    public static IEnumerable<object[]> Contains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Contains_TestData))]
-    public void DataGridViewSelectedRowCollection_Contains_InvokeEmpty_ReturnsFalse(DataGridViewRow dataGridViewRow)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.False(collection.Contains(dataGridViewRow));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_CopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Rows[2], control.Rows[0] }, array);
-    }
-
-    public static IEnumerable<object[]> Insert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new DataGridViewRow() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Insert_TestData))]
-    public void DataGridViewSelectedRowCollection_Insert_Invoke_ThrowsNotSupportedException(int index, DataGridViewRow dataGridRow)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, dataGridRow));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListProperties_GetEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Equal(0, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListProperties_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Equal(2, iList.Count);
-        Assert.True(iList.IsFixedSize);
-        Assert.True(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListItem_GetNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Equal(control.Rows[2], iList[0]);
-        Assert.Equal(control.Rows[0], iList[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedRowCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void DataGridViewSelectedRowCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    public static IEnumerable<object[]> IListItem_SetTestData()
-    {
-        yield return new object[] { 0, null };
-        yield return new object[] { -1, new object() };
-        yield return new object[] { 1, new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListItem_SetTestData))]
-    public void DataGridViewSelectedRowCollection_IListItem_Set_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList[index] = value);
-    }
-
-    public static IEnumerable<object[]> IListAdd_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListAdd_TestData))]
-    public void DataGridViewSelectedRowCollection_IListAdd_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Add(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListClear_Invoke_ThrowsNotSupportedException()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Clear());
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListCopyTo_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListCopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        var array = new object[] { 1, 2, 3 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, control.Rows[2], control.Rows[0] }, array);
-    }
-
-    public static IEnumerable<object[]> IListContains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListContains_TestData))]
-    public void DataGridViewSelectedRowCollection_IListContains_InvokeEmpty_ReturnsFalse(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.False(iList.Contains(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListContains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.True(iList.Contains(control.Rows[0]));
-        Assert.False(iList.Contains(control.Rows[1]));
-        Assert.True(iList.Contains(control.Rows[2]));
-        Assert.False(iList.Contains(new DataGridViewRow()));
-        Assert.False(iList.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListGetEnumerator_InvokeEmpty_Success()
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListGetEnumerator_InvokeNotEmpty_Success()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        IEnumerator enumerator = iList.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Rows[2], enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(control.Rows[0], enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-        }
-    }
-
-    public static IEnumerable<object[]> IListIndexOf_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListIndexOf_TestData))]
-    public void DataGridViewSelectedRowCollection_IListIndexOf_InvokeEmpty_ReturnsMinusOne(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Equal(-1, iList.IndexOf(value));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewSelectedRowCollection_IListIndexOf_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new DataGridView
-        {
-            ColumnCount = 1,
-            RowCount = 3
-        };
-        control.Rows[0].Selected = true;
-        control.Rows[1].Selected = false;
-        control.Rows[2].Selected = true;
-
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Equal(1, iList.IndexOf(control.Rows[0]));
-        Assert.Equal(-1, iList.IndexOf(control.Rows[1]));
-        Assert.Equal(0, iList.IndexOf(control.Rows[2]));
-        Assert.Equal(-1, iList.IndexOf(new DataGridViewRow()));
-        Assert.Equal(-1, iList.IndexOf(null));
-    }
-
-    public static IEnumerable<object[]> IListInsert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new object() };
-            yield return new object[] { index, new DataGridViewRow() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListInsert_TestData))]
-    public void DataGridViewSelectedRowCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Insert(index, value));
-    }
-
-    public static IEnumerable<object[]> IListRemove_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataGridViewRow() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_TestData))]
-    public void DataGridViewSelectedRowCollection_IListRemove_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.Remove(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewSelectedRowCollection_IListRemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        using var control = new DataGridView();
-        DataGridViewSelectedRowCollection collection = control.SelectedRows;
-        IList iList = collection;
-        Assert.Throws<NotSupportedException>(() => iList.RemoveAt(index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.Rendering.cs
deleted file mode 100644
index 7254dd96082..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.Rendering.cs
+++ /dev/null
@@ -1,206 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Numerics;
-using System.Windows.Forms.Metafiles;
-using static System.Windows.Forms.Metafiles.DataHelpers;
-
-namespace System.Windows.Forms.Tests;
-
-partial class DataGridViewTests
-{
-    [WinFormsFact]
-    public void DataGridView_GridColor_Rendering()
-    {
-        using Form form = new Form();
-
-        // Only want to render one cell to validate
-        using var dataGrid = new DataGridView
-        {
-            GridColor = Color.Blue,
-            ColumnCount = 1,
-            RowCount = 1,
-            ColumnHeadersVisible = false,
-            RowHeadersVisible = false
-        };
-
-        form.Controls.Add(dataGrid);
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        dataGrid.PrintToMetafile(emf);
-
-        Assert.Equal(new Rectangle(0, 0, 240, 150), dataGrid.Bounds);
-        Assert.Equal(new Size(100, 25), dataGrid[0, 0].Size);
-
-        Rectangle bounds = dataGrid.Bounds;
-
-        // For whatever reason GDI+ renders as polylines scaled 16x with a 1/16th world transform applied.
-        // For test readability we'll transform the points from our coordinates to the logical coordinates.
-        Matrix3x2 oneSixteenth = Matrix3x2.CreateScale(0.0625f);
-        Matrix3x2 times16 = Matrix3x2.CreateScale(16.0f);
-
-        // This is the default pen style GDI+ renders with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        // Don't really care about the bounds, just the actual shapes/lines
-        emf.Validate(
-            state,
-            // The datagrid background
-            Validate.Polygon16(
-                bounds: null,
-                PointArray(times16, 1, 1, 1, 149, 239, 149, 239, 1, 1, 1),
-                State.Pen(1, Color.Empty, PEN_STYLE.PS_NULL),
-                State.Brush(SystemColors.ButtonShadow, BRUSH_STYLE.BS_SOLID),
-                State.Transform(oneSixteenth)),
-            // Left cell border
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 1, 1, 1, 26),
-                State.Pen(16, Color.Blue, penStyle),
-                State.Transform(oneSixteenth)),
-            // Right cell border
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 101, 1, 101, 26),
-                State.Pen(16, Color.Blue, penStyle),
-                State.Transform(oneSixteenth)),
-            // Top cell border
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 1, 1, 101, 1),
-                State.Pen(16, Color.Blue, penStyle),
-                State.Transform(oneSixteenth)),
-            // Bottom cell border
-            Validate.Polyline16(
-                bounds: null,
-                PointArray(times16, 1, 26, 101, 26),
-                State.Pen(16, Color.Blue, penStyle),
-                State.Transform(oneSixteenth)),
-            // Cell background
-            Validate.Polygon16(
-                bounds: null,
-                PointArray(times16, 2, 2, 2, 26, 101, 26, 101, 2, 2, 2),
-                State.Pen(1, Color.Empty, PEN_STYLE.PS_NULL),
-                State.Brush(SystemColors.ButtonHighlight, BRUSH_STYLE.BS_SOLID),
-                State.Transform(oneSixteenth)),
-            // Datagrid border
-            Validate.Polygon16(
-                bounds: null,
-                PointArray(times16, 0, 0, 239, 0, 239, 149, 0, 149),
-                State.Pen(16, SystemColors.Desktop, penStyle),
-                State.Brush(Color.Empty, BRUSH_STYLE.BS_NULL),
-                State.Transform(oneSixteenth)));
-    }
-
-    [WinFormsFact]
-    public void DataGridView_DefaultCellStyles_Rendering()
-    {
-        #region DataGridView setup
-
-        using Font formFont1 = new Font("Times New Roman", 12F, FontStyle.Regular);
-        using Form form = new Form
-        {
-            Font = formFont1,
-            Size = new Size(700, 200)
-        };
-
-        using Font customCellStyleFont = new Font("Tahoma", 8.25F, FontStyle.Regular);
-        using Font customColumnHeaderFont = new Font("Consolas", 14F, FontStyle.Italic);
-        using Font customRowHeaderFont = new Font("Arial", 9F, FontStyle.Bold);
-
-        var defaultCellStyle = new DataGridViewCellStyle
-        {
-            Font = customCellStyleFont,
-
-            // We must supply a completely initialised instance, else we'd be receiving a copy
-            // refer to DefaultCellStyle implementation
-
-            Alignment = DataGridViewContentAlignment.MiddleLeft,
-            BackColor = SystemColors.Info,
-            ForeColor = Color.Maroon,
-            SelectionBackColor = SystemColors.Highlight,
-            SelectionForeColor = SystemColors.HighlightText,
-            WrapMode = DataGridViewTriState.False
-        };
-
-        using DataGridView dataGridView = new DataGridView
-        {
-            DefaultCellStyle = defaultCellStyle,
-            ColumnHeadersDefaultCellStyle = new DataGridViewCellStyle { Font = customColumnHeaderFont },
-            RowHeadersDefaultCellStyle = new DataGridViewCellStyle { Font = customRowHeaderFont },
-
-            Dock = DockStyle.Fill,
-            ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize,
-        };
-
-        var column1 = new DataGridViewTextBoxColumn { HeaderText = "Style" };
-        var column2 = new DataGridViewTextBoxColumn { HeaderText = "Font" };
-        dataGridView.Columns.AddRange(new[] { column1, column2, });
-        dataGridView.Rows.Add(nameof(DataGridView.DefaultCellStyle), customCellStyleFont.ToString());
-        dataGridView.Rows.Add(nameof(DataGridView.ColumnHeadersDefaultCellStyle), customColumnHeaderFont.ToString());
-        dataGridView.Rows.Add(nameof(DataGridView.RowHeadersDefaultCellStyle), customRowHeaderFont.ToString());
-        for (int i = 0; i < dataGridView.Rows.Count; i++)
-        {
-            dataGridView.Rows[i].HeaderCell.Value = $"Row {i + 1}";
-        }
-
-        dataGridView.RowHeadersWidth = 100;
-
-        Assert.Same(customCellStyleFont, dataGridView.DefaultCellStyle.Font);
-        Assert.Same(customColumnHeaderFont, dataGridView.ColumnHeadersDefaultCellStyle.Font);
-        Assert.Same(customRowHeaderFont, dataGridView.RowHeadersDefaultCellStyle.Font);
-
-        // Add the datagridview to the form, this will trigger Font change via OnFontChanged
-        form.Controls.Add(dataGridView);
-
-        #endregion
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Assert.NotEqual(IntPtr.Zero, dataGridView.Handle);
-        dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
-
-        dataGridView.PrintToMetafile(emf);
-
-        // We only care about font styles, nothing else
-        emf.Validate(
-            state,
-
-            // Column headers
-            Validate.SkipTo(
-                Validate.TextOut(column1.HeaderText, stateValidators: State.FontFace(customColumnHeaderFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(column2.HeaderText, stateValidators: State.FontFace(customColumnHeaderFont.Name))),
-
-           // Row1
-           Validate.SkipTo(
-                Validate.TextOut("Row 1", stateValidators: State.FontFace(customRowHeaderFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(nameof(DataGridView.DefaultCellStyle), stateValidators: State.FontFace(customCellStyleFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(customCellStyleFont.ToString(), stateValidators: State.FontFace(customCellStyleFont.Name))),
-
-           // Row2
-           Validate.SkipTo(
-                Validate.TextOut("Row 2", stateValidators: State.FontFace(customRowHeaderFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(nameof(DataGridView.ColumnHeadersDefaultCellStyle), stateValidators: State.FontFace(customCellStyleFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(customColumnHeaderFont.ToString(), stateValidators: State.FontFace(customCellStyleFont.Name))),
-
-           // Row3
-           Validate.SkipTo(
-                Validate.TextOut("Row 3", stateValidators: State.FontFace(customRowHeaderFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(nameof(DataGridView.RowHeadersDefaultCellStyle), stateValidators: State.FontFace(customCellStyleFont.Name))),
-            Validate.SkipTo(
-                Validate.TextOut(customRowHeaderFont.ToString(), stateValidators: State.FontFace(customCellStyleFont.Name))),
-
-            Validate.SkipAll());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.cs
deleted file mode 100644
index d537188a22c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTests.cs
+++ /dev/null
@@ -1,2898 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class DataGridViewTests
-{
-    public DataGridViewTests()
-    {
-        // Some controls have behavior that changes when the mouse is over them. Make sure we start with the cursor
-        // at a known position.
-        //
-        // See https://github.com/dotnet/winforms/pull/7031#issuecomment-1101339968 for an example of this.
-        Cursor.Position = default;
-    }
-
-    [WinFormsFact]
-    public void DataGridView_Ctor_Default()
-    {
-        using var control = new DataGridView();
-        Assert.Equal(23, control.ColumnHeadersHeight);
-        Assert.Equal(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(41, control.RowHeadersWidth);
-        Assert.Equal(DataGridViewRowHeadersWidthSizeMode.EnableResizing, control.RowHeadersWidthSizeMode);
-        Assert.NotNull(control.RowTemplate);
-        Assert.Same(control.RowTemplate, control.RowTemplate);
-    }
-
-    private const int DefaultColumnHeadersHeight = 23;
-
-    public static IEnumerable<object[]> ColumnHeadersHeight_Set_TestData()
-    {
-        foreach (bool columnHeadersVisible in new bool[] { true, false })
-        {
-            foreach (bool autoSize in new bool[] { true, false })
-            {
-                yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, autoSize, 4, DefaultColumnHeadersHeight };
-                yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, autoSize, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-                yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, autoSize, 32768, DefaultColumnHeadersHeight };
-
-                foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in new DataGridViewColumnHeadersHeightSizeMode[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DataGridViewColumnHeadersHeightSizeMode.DisableResizing })
-                {
-                    yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, autoSize, 4, 4 };
-                    yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, autoSize, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-                    yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, autoSize, 32768, 32768 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeight_Set_TestData))]
-    public void DataGridView_ColumnHeadersHeight_Set_GetReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, bool autoSize, int value, int expectedValue)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ColumnHeadersHeight = value;
-        Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ColumnHeadersHeight = value;
-        Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ColumnHeadersHeight_SetWithParent_TestData()
-    {
-        foreach (bool columnHeadersVisible in new bool[] { true, false })
-        {
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, true, 4, DefaultColumnHeadersHeight, 0, 0 };
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, true, 32768, DefaultColumnHeadersHeight, 0, 0 };
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, false, 4, DefaultColumnHeadersHeight, 0, 0 };
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-            yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, columnHeadersVisible, false, 32768, DefaultColumnHeadersHeight, 0, 0 };
-
-            foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in new DataGridViewColumnHeadersHeightSizeMode[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DataGridViewColumnHeadersHeightSizeMode.DisableResizing })
-            {
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 4, 4, 0, 1 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 32768, 32768, columnHeadersVisible ? 1 : 0, 1 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 4, 4, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 32768, 32768, 0, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeight_SetWithParent_TestData))]
-    public void DataGridView_ColumnHeadersHeight_SetWithParent_GetReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, bool autoSize, int value, int expectedValue, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible,
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("ColumnHeadersHeight", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ColumnHeadersHeight = value;
-            Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.ColumnHeadersHeight = value;
-            Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> ColumnHeadersHeight_SetWithHandle_TestData()
-    {
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, 4, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, DefaultColumnHeadersHeight, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, 32768, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, 4, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, DefaultColumnHeadersHeight, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, 32768, 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, 4, DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, 32768, DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, 4, DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, 32768, DefaultColumnHeadersHeight };
-
-        foreach (bool columnHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in new DataGridViewColumnHeadersHeightSizeMode[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DataGridViewColumnHeadersHeightSizeMode.DisableResizing })
-            {
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 4, 4 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 4, 4 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 32768, 32768 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 32768, 32768 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeight_SetWithHandle_TestData))]
-    public void DataGridView_ColumnHeadersHeight_SetWithHandle_GetReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, bool autoSize, int value, int expectedValue)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ColumnHeadersHeight = value;
-        Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ColumnHeadersHeight = value;
-        Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ColumnHeadersHeight_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, 4, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, DefaultColumnHeadersHeight, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, true, 32768, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, 4, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, DefaultColumnHeadersHeight, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, true, false, 32768, 18, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, 4, DefaultColumnHeadersHeight, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, true, 32768, DefaultColumnHeadersHeight, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, 4, DefaultColumnHeadersHeight, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, false, false, 32768, DefaultColumnHeadersHeight, 0, 0 };
-
-        foreach (bool columnHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in new DataGridViewColumnHeadersHeightSizeMode[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DataGridViewColumnHeadersHeightSizeMode.DisableResizing })
-            {
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 4, 4, 0, 1 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, true, 32768, 32768, columnHeadersVisible ? 1 : 0, 1 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 4, 4, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, DefaultColumnHeadersHeight, DefaultColumnHeadersHeight, 0, 0 };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, false, 32768, 32768, 0, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeight_SetWithParentWithHandle_TestData))]
-    public void DataGridView_ColumnHeadersHeight_SetWithParentWithHandle_GetReturnsExpected(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, bool autoSize, int value, int expectedValue, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var parent = new Control();
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible,
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("ColumnHeadersHeight", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ColumnHeadersHeight = value;
-            Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);;
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.ColumnHeadersHeight = value;
-            Assert.Equal(expectedValue, control.ColumnHeadersHeight);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, 1)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing, 1)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize, 0)]
-    public void DataGridView_ColumnHeadersHeight_SetWithHandler_CallsColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ColumnHeadersHeightChanged += handler;
-
-        // Set different.
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Set same.
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Set different.
-        control.ColumnHeadersHeight = 18;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(expectedCallCount * 2, callCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightChanged -= handler;
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(expectedCallCount * 2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewColumnHeadersHeightSizeMode>]
-    public void DataGridView_ColumnHeadersHeight_SetWithHandlerDisposed_DoesNotCallColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        control.Dispose();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        control.ColumnHeadersHeightChanged += handler;
-
-        // Set different.
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ColumnHeadersHeight = 18;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightChanged -= handler;
-        control.ColumnHeadersHeight = 20;
-        Assert.True(control.ColumnHeadersHeight > 0);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, 1)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing, 1)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize, 0)]
-    public void DataGridView_ColumnHeadersHeight_SetWithHandlerInDisposing_CallsColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-            control.ColumnHeadersHeightChanged += handler;
-
-            // Set different.
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Set same.
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Set different.
-            control.ColumnHeadersHeight = 18;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(expectedCallCount * 2, callCount);
-
-            // Remove handler.
-            control.ColumnHeadersHeightChanged -= handler;
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(expectedCallCount * 2, callCount);
-
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewColumnHeadersHeightSizeMode>]
-    public void DataGridView_ColumnHeadersHeight_SetWithHandlerInColumnDisposing_DoesNotCallColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-            control.ColumnHeadersHeightChanged += handler;
-
-            // Set different.
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(0, callCount);
-
-            // Set same.
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(0, callCount);
-
-            // Set different.
-            control.ColumnHeadersHeight = 18;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(0, callCount);
-
-            // Remove handler.
-            control.ColumnHeadersHeightChanged -= handler;
-            control.ColumnHeadersHeight = 20;
-            Assert.True(control.ColumnHeadersHeight > 0);
-            Assert.Equal(0, callCount);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(3)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(32769)]
-    public void DataGridView_ColumnHeadersHeight_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new DataGridView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ColumnHeadersHeight = value);
-    }
-
-    public static IEnumerable<object[]> ColumnHeadersHeightSizeMode_Set_TestData()
-    {
-        foreach (bool columnHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewColumnHeadersHeightSizeMode value in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-            {
-                yield return new object[] { columnHeadersVisible, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeightSizeMode_Set_TestData))]
-    public void DataGridView_ColumnHeadersHeightSizeMode_Set_GetReturnsExpected(bool columnHeadersVisible, DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        using var control = new DataGridView
-        {
-            ColumnHeadersVisible = columnHeadersVisible,
-            ColumnHeadersHeightSizeMode = value
-        };
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ColumnHeadersHeightSizeMode_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, DataGridViewColumnHeadersHeightSizeMode.AutoSize, 18};
-        yield return new object[] { true, DataGridViewColumnHeadersHeightSizeMode.DisableResizing, DefaultColumnHeadersHeight };
-        yield return new object[] { true, DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DefaultColumnHeadersHeight };
-        yield return new object[] { false, DataGridViewColumnHeadersHeightSizeMode.AutoSize, DefaultColumnHeadersHeight };
-        yield return new object[] { false, DataGridViewColumnHeadersHeightSizeMode.DisableResizing, DefaultColumnHeadersHeight };
-        yield return new object[] { false, DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DefaultColumnHeadersHeight };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ColumnHeadersHeightSizeMode_SetWithHandle_TestData))]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetWithHandle_GetReturnsExpected(bool columnHeadersVisible, DataGridViewColumnHeadersHeightSizeMode value, int expectedColumnHeadersHeight)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(expectedColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(expectedColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing, DataGridViewColumnHeadersHeightSizeMode.AutoSize)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, DataGridViewColumnHeadersHeightSizeMode.AutoSize)]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetNonResizeThenResize_RestoresOldValue(DataGridViewColumnHeadersHeightSizeMode originalColumnHeadersHeightSizeMode, DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            ColumnHeadersHeightSizeMode = originalColumnHeadersHeightSizeMode,
-            ColumnHeadersHeight = 30
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int columnHeadersWidthChangedCallCount = 0;
-        control.ColumnHeadersHeightChanged += (sender, e) => columnHeadersWidthChangedCallCount++;
-
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(18, control.ColumnHeadersHeight);
-        Assert.Equal(1, columnHeadersWidthChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Restore.
-        control.ColumnHeadersHeightSizeMode = originalColumnHeadersHeightSizeMode;
-        Assert.Equal(originalColumnHeadersHeightSizeMode, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(30, control.ColumnHeadersHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing, false)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize, true)]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetWithHandler_CallsColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode value, bool expectedPreviousModeAutoSized)
-    {
-        using var control = new DataGridView();
-        int callCount = 0;
-        object expected = false;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expected, e.PreviousModeAutoSized);
-            callCount++;
-        };
-        control.ColumnHeadersHeightSizeModeChanged += handler;
-
-        // Set different.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        expected = expectedPreviousModeAutoSized;
-        control.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
-        Assert.Equal(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightSizeModeChanged -= handler;
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize)]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetWithHandlerDisposed_DoesNotCallColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        using var control = new DataGridView();
-        control.Dispose();
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-        control.ColumnHeadersHeightSizeModeChanged += handler;
-
-        // Set different.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
-        Assert.Equal(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightSizeModeChanged -= handler;
-        control.ColumnHeadersHeightSizeMode = value;
-        Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize)]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetWithHandlerInDisposing_DoesNotCallColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-            control.ColumnHeadersHeightSizeModeChanged += handler;
-
-            // Set different.
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(1, callCount);
-
-            // Set same.
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(1, callCount);
-
-            // Set different.
-            control.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
-            Assert.Equal(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(2, callCount);
-
-            // Remove handler.
-            control.ColumnHeadersHeightSizeModeChanged -= handler;
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(2, callCount);
-
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.AutoSize)]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetWithHandlerInColumnDisposing_DoesNotCallColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-            control.ColumnHeadersHeightSizeModeChanged += handler;
-
-            // Set different.
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Set same.
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Set different.
-            control.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
-            Assert.Equal(DataGridViewColumnHeadersHeightSizeMode.EnableResizing, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Remove handler.
-            control.ColumnHeadersHeightSizeModeChanged -= handler;
-            control.ColumnHeadersHeightSizeMode = value;
-            Assert.Equal(value, control.ColumnHeadersHeightSizeMode);
-            Assert.Equal(0, callCount);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DataGridViewColumnHeadersHeightSizeMode>]
-    public void DataGridView_ColumnHeadersHeightSizeMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(DataGridViewColumnHeadersHeightSizeMode value)
-    {
-        using var control = new DataGridView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ColumnHeadersHeightSizeMode = value);
-    }
-
-    public static IEnumerable<object[]> DefaultCellStyle_TestData()
-    {
-        // If any of the following properties are not initialised or set to the following values
-        // accessing DefaultCellStyle property will return a copy of cell styles, instead of the existing object
-
-        yield return new object[] { new DataGridViewCellStyle() };
-        yield return new object[] { new DataGridViewCellStyle { BackColor = Color.Empty } };
-        yield return new object[] { new DataGridViewCellStyle { ForeColor = Color.Empty } };
-        yield return new object[] { new DataGridViewCellStyle { SelectionBackColor = Color.Empty } };
-        yield return new object[] { new DataGridViewCellStyle { SelectionForeColor = Color.Empty } };
-        yield return new object[] { new DataGridViewCellStyle { Font = null } };
-        yield return new object[] { new DataGridViewCellStyle { Alignment = DataGridViewContentAlignment.NotSet } };
-        yield return new object[] { new DataGridViewCellStyle { WrapMode = DataGridViewTriState.NotSet } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCellStyle_TestData))]
-    public void DataGridView_DefaultCellStyle_returns_copy_if_not_all_fields_initialised(DataGridViewCellStyle cellStyle)
-    {
-        using DataGridView dataGridView = new DataGridView
-        {
-            DefaultCellStyle = cellStyle,
-        };
-
-        Assert.NotSame(cellStyle, dataGridView.DefaultCellStyle);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-        yield return new object[] { new DataGridView() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void DataGridView_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new DataGridView
-        {
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void DataGridView_Parent_SetWithNonNullOldParent_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new Control();
-        using var control = new DataGridView
-        {
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new Control();
-        using var control = new DataGridView
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void DataGridView_Parent_SetWithHandle_GetReturnsExpected(Control value)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new DataGridView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new DataGridView();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    private const int DefaultRowHeadersWidth = 41;
-
-    public static IEnumerable<object[]> RowHeadersWidth_Set_TestData()
-    {
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (bool autoSize in new bool[] { true, false })
-            {
-                foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader })
-                {
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, 4, DefaultRowHeadersWidth };
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, 32768, DefaultRowHeadersWidth };
-                }
-
-                foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.DisableResizing })
-                {
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, 4, 4 };
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-                    yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, autoSize, 32768, 32768 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidth_Set_TestData))]
-    public void DataGridView_RowHeadersWidth_Set_GetReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, bool autoSize, int value, int expectedValue)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.RowHeadersWidth = value;
-        Assert.Equal(expectedValue, control.RowHeadersWidth);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RowHeadersWidth = value;
-        Assert.Equal(expectedValue, control.RowHeadersWidth);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RowHeadersWidth_SetWithParent_TestData()
-    {
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader })
-            {
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 4, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 32768, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 4, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 32768, DefaultRowHeadersWidth, 0, 0 };
-            }
-
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.DisableResizing })
-            {
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 4, 4, 0, 1 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 32768, 32768, rowHeadersVisible ? 1 : 0, 1 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 4, 4, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 32768, 32768, 0, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidth_SetWithParent_TestData))]
-    public void DataGridView_RowHeadersWidth_SetWithParent_GetReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, bool autoSize, int value, int expectedValue, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RowHeadersWidth", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.RowHeadersWidth = value;
-            Assert.Equal(expectedValue, control.RowHeadersWidth);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.RowHeadersWidth = value;
-            Assert.Equal(expectedValue, control.RowHeadersWidth);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> RowHeadersWidth_SetWithHandle_TestData()
-    {
-        foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader })
-        {
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, 4, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, DefaultRowHeadersWidth, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, 32768, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, 4, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, DefaultRowHeadersWidth, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, 32768, 21 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, 4, DefaultRowHeadersWidth };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, 32768, DefaultRowHeadersWidth };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, 4, DefaultRowHeadersWidth };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, 32768, DefaultRowHeadersWidth };
-        }
-
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.DisableResizing })
-            {
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 4, 4 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 4, 4 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 32768, 32768 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 32768, 32768 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidth_SetWithHandle_TestData))]
-    public void DataGridView_RowHeadersWidth_SetWithHandle_GetReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, bool autoSize, int value, int expectedValue)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.RowHeadersWidth = value;
-        Assert.Equal(expectedValue, control.RowHeadersWidth);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.RowHeadersWidth = value;
-        Assert.Equal(expectedValue, control.RowHeadersWidth);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> RowHeadersWidth_SetWithParentWithHandle_TestData()
-    {
-        foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader })
-        {
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, 4, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, DefaultRowHeadersWidth, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, true, 32768, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, 4, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, DefaultRowHeadersWidth, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, true, false, 32768, 21, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, 4, DefaultRowHeadersWidth, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, true, 32768, DefaultRowHeadersWidth, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, 4, DefaultRowHeadersWidth, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-            yield return new object[] { rowHeadersWidthSizeMode, false, false, 32768, DefaultRowHeadersWidth, 0, 0 };
-        }
-
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in new DataGridViewRowHeadersWidthSizeMode[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.DisableResizing })
-            {
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 4, 4, 0, 1 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, true, 32768, 32768, rowHeadersVisible ? 1 : 0, 1 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 4, 4, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, DefaultRowHeadersWidth, DefaultRowHeadersWidth, 0, 0 };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, false, 32768, 32768, 0, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidth_SetWithParentWithHandle_TestData))]
-    public void DataGridView_RowHeadersWidth_SetWithParentWithHandle_GetReturnsExpected(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, bool autoSize, int value, int expectedValue, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var parent = new Control();
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible,
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RowHeadersWidth", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.RowHeadersWidth = value;
-            Assert.Equal(expectedValue, control.RowHeadersWidth);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.RowHeadersWidth = value;
-            Assert.Equal(expectedValue, control.RowHeadersWidth);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing, 1)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, 1)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, 0)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, 0)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, 0)]
-    public void DataGridView_RowHeadersWidth_SetWithHandler_CallsRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RowHeadersWidthChanged += handler;
-
-        // Set different.
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Set same.
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Set different.
-        control.RowHeadersWidth = 21;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(expectedCallCount * 2, callCount);
-
-        // Remove handler.
-        control.RowHeadersWidthChanged -= handler;
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(expectedCallCount * 2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewRowHeadersWidthSizeMode>]
-    public void DataGridView_RowHeadersWidth_SetWithHandlerDisposed_DoesNotCallRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        control.Dispose();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        control.RowHeadersWidthChanged += handler;
-
-        // Set different.
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.RowHeadersWidth = 21;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.RowHeadersWidthChanged -= handler;
-        control.RowHeadersWidth = 20;
-        Assert.True(control.RowHeadersWidth > 0);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing, 1)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, 1)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, 0)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, 0)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, 0)]
-    public void DataGridView_RowHeadersWidth_SetWithHandlerInDisposing_CallsRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, int expectedCallCount)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-            control.RowHeadersWidthChanged += handler;
-
-            // Set different.
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Set same.
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Set different.
-            control.RowHeadersWidth = 21;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(expectedCallCount * 2, callCount);
-
-            // Remove handler.
-            control.RowHeadersWidthChanged -= handler;
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(expectedCallCount * 2, callCount);
-
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewRowHeadersWidthSizeMode>]
-    public void DataGridView_RowHeadersWidth_SetWithHandlerInColumnDisposing_DoesNotCallRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-            control.RowHeadersWidthChanged += handler;
-
-            // Set different.
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(0, callCount);
-
-            // Set same.
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(0, callCount);
-
-            // Set different.
-            control.RowHeadersWidth = 21;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(0, callCount);
-
-            // Remove handler.
-            control.RowHeadersWidthChanged -= handler;
-            control.RowHeadersWidth = 20;
-            Assert.True(control.RowHeadersWidth > 0);
-            Assert.Equal(0, callCount);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(3)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(32769)]
-    public void DataGridView_RowHeadersWidth_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new DataGridView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.RowHeadersWidth = value);
-    }
-
-    public static IEnumerable<object[]> RowHeadersWidthSizeMode_Set_TestData()
-    {
-        foreach (bool rowHeadersVisible in new bool[] { true, false })
-        {
-            foreach (DataGridViewRowHeadersWidthSizeMode value in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-            {
-                yield return new object[] { rowHeadersVisible, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidthSizeMode_Set_TestData))]
-    public void DataGridView_RowHeadersWidthSizeMode_Set_GetReturnsExpected(bool rowHeadersVisible, DataGridViewRowHeadersWidthSizeMode value)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            RowHeadersWidthSizeMode = value
-        };
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RowHeadersWidthSizeMode_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, 21 };
-        yield return new object[] { true, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, 21 };
-        yield return new object[] { true, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, 21 };
-        yield return new object[] { true, DataGridViewRowHeadersWidthSizeMode.DisableResizing, DefaultRowHeadersWidth };
-        yield return new object[] { true, DataGridViewRowHeadersWidthSizeMode.EnableResizing, DefaultRowHeadersWidth };
-        yield return new object[] { false, DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, DefaultRowHeadersWidth };
-        yield return new object[] { false, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, DefaultRowHeadersWidth };
-        yield return new object[] { false, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, DefaultRowHeadersWidth };
-        yield return new object[] { false, DataGridViewRowHeadersWidthSizeMode.DisableResizing, DefaultRowHeadersWidth };
-        yield return new object[] { false, DataGridViewRowHeadersWidthSizeMode.EnableResizing, DefaultRowHeadersWidth };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RowHeadersWidthSizeMode_SetWithHandle_TestData))]
-    public void DataGridView_RowHeadersWidthSizeMode_SetWithHandle_GetReturnsExpected(bool rowHeadersVisible, DataGridViewRowHeadersWidthSizeMode value, int expectedRowHeadersWidth)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(expectedRowHeadersWidth, control.RowHeadersWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(expectedRowHeadersWidth, control.RowHeadersWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing, DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader)]
-    public void DataGridView_RowHeadersWidthSizeMode_SetNonResizeThenResize_RestoresOldValue(DataGridViewRowHeadersWidthSizeMode originalRowHeadersWidthSizeMode, DataGridViewRowHeadersWidthSizeMode value)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            RowHeadersWidthSizeMode = originalRowHeadersWidthSizeMode,
-            RowHeadersWidth = 30
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int rowHeadersWidthChangedCallCount = 0;
-        control.RowHeadersWidthChanged += (sender, e) => rowHeadersWidthChangedCallCount++;
-
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(21, control.RowHeadersWidth);
-        Assert.Equal(1, rowHeadersWidthChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Restore.
-        control.RowHeadersWidthSizeMode = originalRowHeadersWidthSizeMode;
-        Assert.Equal(originalRowHeadersWidthSizeMode, control.RowHeadersWidthSizeMode);
-        Assert.Equal(30, control.RowHeadersWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing, false)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, true)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, true)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, true)]
-    public void DataGridView_RowHeadersWidthSizeMode_SetWithHandler_CallsRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode value, object expectedPreviousModeAutoSized)
-    {
-        using var control = new DataGridView();
-        int callCount = 0;
-        object expected = false;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expected, e.PreviousModeAutoSized);
-            callCount++;
-        };
-        control.RowHeadersWidthSizeModeChanged += handler;
-
-        // Set different.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        expected = expectedPreviousModeAutoSized;
-        control.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-        Assert.Equal(DataGridViewRowHeadersWidthSizeMode.EnableResizing, control.RowHeadersWidthSizeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RowHeadersWidthSizeModeChanged -= handler;
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader)]
-    public void DataGridView_RowHeadersWidthSizeMode_SetWithHandlerDisposed_DoesNotCallRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode value)
-    {
-        using var control = new DataGridView();
-        control.Dispose();
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-        control.RowHeadersWidthSizeModeChanged += handler;
-
-        // Set different.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-        Assert.Equal(DataGridViewRowHeadersWidthSizeMode.EnableResizing, control.RowHeadersWidthSizeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.RowHeadersWidthSizeModeChanged -= handler;
-        control.RowHeadersWidthSizeMode = value;
-        Assert.Equal(value, control.RowHeadersWidthSizeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader)]
-    public void DataGridView_RowHeadersWidthSizeMode_SetWithHandlerInDisposing_DoesNotCallRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-            control.RowHeadersWidthSizeModeChanged += handler;
-
-            // Set different.
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(1, callCount);
-
-            // Set same.
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(1, callCount);
-
-            // Set different.
-            control.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-            Assert.Equal(DataGridViewRowHeadersWidthSizeMode.EnableResizing, control.RowHeadersWidthSizeMode);
-            Assert.Equal(2, callCount);
-
-            // Remove handler.
-            control.RowHeadersWidthSizeModeChanged -= handler;
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(2, callCount);
-
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader)]
-    public void DataGridView_RowHeadersWidthSizeMode_SetWithHandlerInColumnDisposing_DoesNotCallRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode value)
-    {
-        using var control = new DataGridView();
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-            control.RowHeadersWidthSizeModeChanged += handler;
-
-            // Set different.
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Set same.
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Set different.
-            control.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
-            Assert.Equal(DataGridViewRowHeadersWidthSizeMode.EnableResizing, control.RowHeadersWidthSizeMode);
-            Assert.Equal(0, callCount);
-
-            // Remove handler.
-            control.RowHeadersWidthSizeModeChanged -= handler;
-            control.RowHeadersWidthSizeMode = value;
-            Assert.Equal(value, control.RowHeadersWidthSizeMode);
-            Assert.Equal(0, callCount);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DataGridViewRowHeadersWidthSizeMode>]
-    public void DataGridView_RowHeadersWidthSizeMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(DataGridViewRowHeadersWidthSizeMode value)
-    {
-        using var control = new DataGridView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RowHeadersWidthSizeMode = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridView_TopLeftHeaderCell_Set_GetReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        using var cell1 = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible,
-            TopLeftHeaderCell = cell1
-        };
-        Assert.Same(cell1, control.TopLeftHeaderCell);
-        Assert.Same(control, cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TopLeftHeaderCell = cell1;
-        Assert.Same(cell1, control.TopLeftHeaderCell);
-        Assert.Same(control, cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        using var cell2 = new DataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell2;
-        Assert.Same(cell2, control.TopLeftHeaderCell);
-        Assert.Null(cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.Same(control, cell2.DataGridView);
-        Assert.Null(cell2.OwningColumn);
-        Assert.Null(cell2.OwningRow);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.TopLeftHeaderCell = null;
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewTopLeftHeaderCell>(control.TopLeftHeaderCell);
-        Assert.Same(control, cell.DataGridView);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Same(control.TopLeftHeaderCell, control.TopLeftHeaderCell);
-        Assert.Null(cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.Null(cell2.DataGridView);
-        Assert.Null(cell2.OwningColumn);
-        Assert.Null(cell2.OwningRow);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridView_TopLeftHeaderCell_SetWithHandle_GetReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var cell1 = new DataGridViewHeaderCell();
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TopLeftHeaderCell = cell1;
-        Assert.Same(cell1, control.TopLeftHeaderCell);
-        Assert.Same(control, cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TopLeftHeaderCell = cell1;
-        Assert.Same(cell1, control.TopLeftHeaderCell);
-        Assert.Same(control, cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        using var cell2 = new DataGridViewHeaderCell();
-        control.TopLeftHeaderCell = cell2;
-        Assert.Same(cell2, control.TopLeftHeaderCell);
-        Assert.Null(cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.Same(control, cell2.DataGridView);
-        Assert.Null(cell2.OwningColumn);
-        Assert.Null(cell2.OwningRow);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set null.
-        control.TopLeftHeaderCell = null;
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewTopLeftHeaderCell>(control.TopLeftHeaderCell);
-        Assert.Same(control, cell.DataGridView);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Same(control.TopLeftHeaderCell, control.TopLeftHeaderCell);
-        Assert.Null(cell1.DataGridView);
-        Assert.Null(cell1.OwningColumn);
-        Assert.Null(cell1.OwningRow);
-        Assert.Null(cell2.DataGridView);
-        Assert.Null(cell2.OwningColumn);
-        Assert.Null(cell2.OwningRow);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridView_TopLeftHeaderCell_Get_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewTopLeftHeaderCell>(control.TopLeftHeaderCell);
-        Assert.Same(control, cell.DataGridView);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Same(control.TopLeftHeaderCell, control.TopLeftHeaderCell);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DataGridView_TopLeftHeaderCell_GetWithHandle_ReturnsExpected(bool rowHeadersVisible, bool columnHeadersVisible)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new DataGridView
-        {
-            RowHeadersVisible = rowHeadersVisible,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DataGridViewHeaderCell cell = Assert.IsType<DataGridViewTopLeftHeaderCell>(control.TopLeftHeaderCell);
-        Assert.Same(control, cell.DataGridView);
-        Assert.Null(cell.OwningColumn);
-        Assert.Null(cell.OwningRow);
-        Assert.Same(control.TopLeftHeaderCell, control.TopLeftHeaderCell);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnColumnHeadersHeightChanged_TestData()
-    {
-        foreach (DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewColumnHeadersHeightSizeMode)))
-        {
-            foreach (bool columnHeadersVisible in new bool[] { true, false })
-            {
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, null };
-                yield return new object[] { columnHeadersWidthSizeMode, columnHeadersVisible, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightChanged_Invoke_CallsColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ColumnHeadersHeightChanged += handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ColumnHeadersHeightChanged -= handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightChanged_InvokeWithHandle_CallsColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, EventArgs eventArgs)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ColumnHeadersHeightChanged += handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightChanged -= handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightChanged_InvokeDisposed_DoesNotCallColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        control.Dispose();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.ColumnHeadersHeightChanged += handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ColumnHeadersHeightChanged -= handler;
-        control.OnColumnHeadersHeightChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightChanged_InvokeInDisposing_CallsColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.ColumnHeadersHeightChanged += handler;
-            control.OnColumnHeadersHeightChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.ColumnHeadersHeightChanged -= handler;
-            control.OnColumnHeadersHeightChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightChanged_InvokeInColumnDisposing_DoesNotCallColumnHeadersHeightChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, bool columnHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode,
-            ColumnHeadersVisible = columnHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.ColumnHeadersHeightChanged += handler;
-            control.OnColumnHeadersHeightChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.ColumnHeadersHeightChanged -= handler;
-            control.OnColumnHeadersHeightChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    public static IEnumerable<object[]> OnColumnHeadersHeightSizeModeChanged_TestData()
-    {
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, new DataGridViewAutoSizeModeEventArgs(true) };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.DisableResizing, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, new DataGridViewAutoSizeModeEventArgs(false) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightSizeModeChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_Invoke_CallsColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ColumnHeadersHeightSizeModeChanged += handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ColumnHeadersHeightSizeModeChanged -= handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnColumnHeadersHeightSizeModeChanged_WithHandle_TestData()
-    {
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, new DataGridViewAutoSizeModeEventArgs(true), 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.AutoSize, new DataGridViewAutoSizeModeEventArgs(false), 18 };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.DisableResizing, new DataGridViewAutoSizeModeEventArgs(false), DefaultColumnHeadersHeight };
-        yield return new object[] { DataGridViewColumnHeadersHeightSizeMode.EnableResizing, new DataGridViewAutoSizeModeEventArgs(false), DefaultColumnHeadersHeight };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightSizeModeChanged_WithHandle_TestData))]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_InvokeWithHandle_CallsColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs, int expectedColumnHeadersHeight)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ColumnHeadersHeightSizeModeChanged += handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.ColumnHeadersHeightSizeModeChanged -= handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.EnableResizing)]
-    [InlineData(DataGridViewColumnHeadersHeightSizeMode.DisableResizing)]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_InvalidEnableDisableResizingPreviousAutoModeSize_ThrowsArgumentOutOfRangeException(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        var eventArgs = new DataGridViewAutoSizeModeEventArgs(true);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.OnColumnHeadersHeightSizeModeChanged(eventArgs));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightSizeModeChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_InvokeDisposed_DoesNotCallColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        control.Dispose();
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.ColumnHeadersHeightSizeModeChanged += handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ColumnHeadersHeightSizeModeChanged -= handler;
-        control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightSizeModeChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_InvokeInDisposing_CallsColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.ColumnHeadersHeightSizeModeChanged += handler;
-            control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.ColumnHeadersHeightSizeModeChanged -= handler;
-            control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnColumnHeadersHeightSizeModeChanged_TestData))]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_InvokeInColumnDisposing_DoesNotCallColumnHeadersHeightSizeModeChanged(DataGridViewColumnHeadersHeightSizeMode columnHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            ColumnHeadersHeightSizeMode = columnHeadersWidthSizeMode
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.ColumnHeadersHeightSizeModeChanged += handler;
-            control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.ColumnHeadersHeightSizeModeChanged -= handler;
-            control.OnColumnHeadersHeightSizeModeChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.Equal(DefaultColumnHeadersHeight, control.ColumnHeadersHeight);
-            Assert.False(control.IsHandleCreated);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_OnColumnHeadersHeightSizeModeChanged_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubDataGridView();
-        Assert.Throws<NullReferenceException>(() => control.OnColumnHeadersHeightSizeModeChanged(null));
-    }
-
-    [WinFormsFact]
-    [Trait("Issue", "https://github.com/dotnet/winforms/issues/3033")]
-    public void DataGridView_OnFontChanged_does_not_change_user_fonts()
-    {
-        using Font formFont1 = new Font("Times New Roman", 12F, FontStyle.Regular);
-        using Form form = new Form
-        {
-            Font = formFont1
-        };
-
-        using Font customFont1 = new Font("Tahoma", 8.25F, FontStyle.Regular);
-        using Font customFont2 = new Font("Consolas", 14F, FontStyle.Italic);
-        using Font customFont3 = new Font("Arial", 9F, FontStyle.Bold);
-
-        var defaultCellStyle = new DataGridViewCellStyle
-        {
-            Font = customFont1,
-
-            // We must supply a completely initialised instance, else we'd be receiving a copy
-            // refer to DefaultCellStyle implementation
-
-            Alignment = DataGridViewContentAlignment.MiddleLeft,
-            BackColor = SystemColors.Info,
-            ForeColor = Color.Maroon,
-            SelectionBackColor = SystemColors.Highlight,
-            SelectionForeColor = SystemColors.HighlightText,
-            WrapMode = DataGridViewTriState.False
-        };
-
-        using DataGridView dataGridView = new DataGridView
-        {
-            DefaultCellStyle = defaultCellStyle,
-            ColumnHeadersDefaultCellStyle = new DataGridViewCellStyle { Font = customFont2 },
-            RowHeadersDefaultCellStyle = new DataGridViewCellStyle { Font = customFont3 }
-        };
-        dataGridView.Columns.AddRange(new[] { new DataGridViewTextBoxColumn(), new DataGridViewTextBoxColumn() });
-        dataGridView.Rows.Add("DefaultCellStyle", customFont1.ToString());
-        dataGridView.Rows.Add("ColumnHeadersDefaultCellStyle", customFont2.ToString());
-        dataGridView.Rows.Add("RowHeadersDefaultCellStyle", customFont3.ToString());
-
-        Assert.Same(customFont1, dataGridView.DefaultCellStyle.Font);
-        Assert.Same(customFont2, dataGridView.ColumnHeadersDefaultCellStyle.Font);
-        Assert.Same(customFont3, dataGridView.RowHeadersDefaultCellStyle.Font);
-
-        // Add the datagridview to the form, this will trigger Font change via OnFontChanged
-        form.Controls.Add(dataGridView);
-
-        // Ensure custom fonts are preserved
-        Assert.Same(customFont1, dataGridView.DefaultCellStyle.Font);
-        Assert.Same(customFont2, dataGridView.ColumnHeadersDefaultCellStyle.Font);
-        Assert.Same(customFont3, dataGridView.RowHeadersDefaultCellStyle.Font);
-
-        // Force another global font change
-        using Font formFont2 = new Font("Arial Black", 10F, FontStyle.Italic);
-        form.Font = formFont2;
-
-        // Ensure custom fonts are preserved
-        Assert.Same(customFont1, dataGridView.DefaultCellStyle.Font);
-        Assert.Same(customFont2, dataGridView.ColumnHeadersDefaultCellStyle.Font);
-        Assert.Same(customFont3, dataGridView.RowHeadersDefaultCellStyle.Font);
-
-        // Ensure a user is still able to change datagridview fonts
-        dataGridView.DefaultCellStyle.Font = customFont2;
-        dataGridView.ColumnHeadersDefaultCellStyle.Font = customFont3;
-        dataGridView.RowHeadersDefaultCellStyle.Font = customFont1;
-
-        Assert.Same(customFont2, dataGridView.DefaultCellStyle.Font);
-        Assert.Same(customFont3, dataGridView.ColumnHeadersDefaultCellStyle.Font);
-        Assert.Same(customFont1, dataGridView.RowHeadersDefaultCellStyle.Font);
-    }
-
-    public static IEnumerable<object[]> OnRowHeadersWidthChanged_TestData()
-    {
-        foreach (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode in Enum.GetValues(typeof(DataGridViewRowHeadersWidthSizeMode)))
-        {
-            foreach (bool rowHeadersVisible in new bool[] { true, false })
-            {
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, null };
-                yield return new object[] { rowHeadersWidthSizeMode, rowHeadersVisible, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthChanged_Invoke_CallsRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RowHeadersWidthChanged += handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RowHeadersWidthChanged -= handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthChanged_InvokeWithHandle_CallsRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, EventArgs eventArgs)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RowHeadersWidthChanged += handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.RowHeadersWidthChanged -= handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthChanged_InvokeDisposed_DoesNotCallRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible
-        };
-        control.Dispose();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.RowHeadersWidthChanged += handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RowHeadersWidthChanged -= handler;
-        control.OnRowHeadersWidthChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthChanged_InvokeInDisposing_CallsRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.RowHeadersWidthChanged += handler;
-            control.OnRowHeadersWidthChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.RowHeadersWidthChanged -= handler;
-            control.OnRowHeadersWidthChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthChanged_InvokeInColumnDisposing_DoesNotCallRowHeadersWidthChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool rowHeadersVisible, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode,
-            RowHeadersVisible = rowHeadersVisible
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.RowHeadersWidthChanged += handler;
-            control.OnRowHeadersWidthChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.RowHeadersWidthChanged -= handler;
-            control.OnRowHeadersWidthChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    public static IEnumerable<object[]> OnRowHeadersWidthSizeModeChanged_TestData()
-    {
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, new DataGridViewAutoSizeModeEventArgs(true) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, new DataGridViewAutoSizeModeEventArgs(true) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, new DataGridViewAutoSizeModeEventArgs(true) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.DisableResizing, new DataGridViewAutoSizeModeEventArgs(false) };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, new DataGridViewAutoSizeModeEventArgs(false) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthSizeModeChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_Invoke_CallsRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RowHeadersWidthSizeModeChanged += handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RowHeadersWidthSizeModeChanged -= handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRowHeadersWidthSizeModeChanged_WithHandle_TestData()
-    {
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, new DataGridViewAutoSizeModeEventArgs(true), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders, new DataGridViewAutoSizeModeEventArgs(false), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, new DataGridViewAutoSizeModeEventArgs(true), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders, new DataGridViewAutoSizeModeEventArgs(false), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, new DataGridViewAutoSizeModeEventArgs(true), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader, new DataGridViewAutoSizeModeEventArgs(false), 21 };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.DisableResizing, new DataGridViewAutoSizeModeEventArgs(false), DefaultRowHeadersWidth };
-        yield return new object[] { DataGridViewRowHeadersWidthSizeMode.EnableResizing, new DataGridViewAutoSizeModeEventArgs(false), DefaultRowHeadersWidth };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthSizeModeChanged_WithHandle_TestData))]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_InvokeWithHandle_CallsRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs, int expectedRowHeadersWidth)
-    {
-        // Invalidation checks are omitted due to https://github.com/dotnet/winforms/issues/7799
-
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RowHeadersWidthSizeModeChanged += handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedRowHeadersWidth, control.RowHeadersWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.RowHeadersWidthSizeModeChanged -= handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedRowHeadersWidth, control.RowHeadersWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.EnableResizing)]
-    [InlineData(DataGridViewRowHeadersWidthSizeMode.DisableResizing)]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_InvalidEnableDisableResizingPreviousAutoModeSize_ThrowsArgumentOutOfRangeException(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        var eventArgs = new DataGridViewAutoSizeModeEventArgs(true);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.OnRowHeadersWidthSizeModeChanged(eventArgs));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthSizeModeChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_InvokeDisposed_DoesNotCallRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        control.Dispose();
-        int callCount = 0;
-        DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.RowHeadersWidthSizeModeChanged += handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RowHeadersWidthSizeModeChanged -= handler;
-        control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthSizeModeChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_InvokeInDisposing_CallsRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        int disposingCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.RowHeadersWidthSizeModeChanged += handler;
-            control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.RowHeadersWidthSizeModeChanged -= handler;
-            control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-            disposingCallCount++;
-        };
-        control.Disposed += handler;
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposingCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRowHeadersWidthSizeModeChanged_TestData))]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_InvokeInColumnDisposing_DoesNotCallRowHeadersWidthSizeModeChanged(DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, DataGridViewAutoSizeModeEventArgs eventArgs)
-    {
-        using var control = new SubDataGridView
-        {
-            RowHeadersWidthSizeMode = rowHeadersWidthSizeMode
-        };
-        using var cellTemplate = new SubDataGridViewCell();
-        using var column = new DataGridViewColumn
-        {
-            CellTemplate = cellTemplate
-        };
-        control.Columns.Add(column);
-        int disposingCallCount = 0;
-        column.Disposed += (sender, e) =>
-        {
-            int callCount = 0;
-            DataGridViewAutoSizeModeEventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.RowHeadersWidthSizeModeChanged += handler;
-            control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-            Assert.False(control.IsHandleCreated);
-
-            // Remove handler.
-            control.RowHeadersWidthSizeModeChanged -= handler;
-            control.OnRowHeadersWidthSizeModeChanged(eventArgs);
-            Assert.Equal(0, callCount);
-            Assert.Equal(DefaultRowHeadersWidth, control.RowHeadersWidth);
-            Assert.False(control.IsHandleCreated);
-
-            disposingCallCount++;
-        };
-        control.Dispose();
-        Assert.Equal(1, disposingCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_OnRowHeadersWidthSizeModeChanged_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubDataGridView();
-        Assert.Throws<NullReferenceException>(() => control.OnRowHeadersWidthSizeModeChanged(null));
-    }
-
-    [WinFormsFact]
-    public void DataGridView_UpdatesItsItems_AfterDataSourceDisposing()
-    {
-        using DataGridView control = new DataGridView();
-        int rowsCount = 5;
-        BindingSource bindingSource = GetTestBindingSource(rowsCount);
-        BindingContext context = new BindingContext();
-        context.Add(bindingSource, bindingSource.CurrencyManager);
-        control.BindingContext = context;
-        control.DataSource = bindingSource;
-
-        // The TestBindingSource table contains 2 columns
-        Assert.Equal(2, control.Columns.Count);
-        // The TestBindingSource table contains some rows + 1 new DGV row (because AllowUserToAddRows is true)
-        Assert.Equal(rowsCount + 1, control.Rows.Count);
-
-        bindingSource.Dispose();
-
-        // The DataGridView updates its Rows and Columns collections after its DataSource is disposed
-        Assert.Empty(control.Columns);
-        Assert.Empty(control.Rows);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_DataSource_IsNull_AfterDisposing()
-    {
-        using DataGridView control = new DataGridView();
-        BindingSource bindingSource = GetTestBindingSource(5);
-        control.DataSource = bindingSource;
-
-        Assert.Equal(bindingSource, control.DataSource);
-
-        bindingSource.Dispose();
-
-        Assert.Null(control.DataSource);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_DataSource_IsActual_AfterOldOneIsDisposed()
-    {
-        using DataGridView control = new DataGridView();
-        int rowsCount1 = 3;
-        BindingSource bindingSource1 = GetTestBindingSource(rowsCount1);
-        int rowsCount2 = 5;
-        BindingSource bindingSource2 = GetTestBindingSource(rowsCount2);
-        BindingContext context = new BindingContext();
-        context.Add(bindingSource1, bindingSource1.CurrencyManager);
-        control.BindingContext = context;
-        control.DataSource = bindingSource1;
-
-        Assert.Equal(bindingSource1, control.DataSource);
-        Assert.Equal(2, control.Columns.Count);
-        Assert.Equal(rowsCount1 + 1, control.Rows.Count); // + 1 is the new DGV row
-
-        control.DataSource = bindingSource2;
-
-        Assert.Equal(bindingSource2, control.DataSource);
-        Assert.Equal(2, control.Columns.Count);
-        Assert.Equal(rowsCount2 + 1, control.Rows.Count); // + 1 is the new DGV row
-
-        bindingSource1.Dispose();
-
-        // bindingSource2 is actual for the DataGridView so it will contain correct Rows and Columns counts
-        // even after bindingSource1 is disposed. This test checks that Disposed events unsubscribed correctly
-        Assert.Equal(bindingSource2, control.DataSource);
-        Assert.Equal(2, control.Columns.Count);
-        Assert.Equal(rowsCount2 + 1, control.Rows.Count); // + 1 is the new DGV row
-    }
-
-    private BindingSource GetTestBindingSource(int rowsCount)
-    {
-        DataTable dt = new DataTable();
-        dt.Columns.Add("Name");
-        dt.Columns.Add("Age");
-
-        for (int i = 0; i < rowsCount; i++)
-        {
-            DataRow dr = dt.NewRow();
-            dr[0] = $"User{i}";
-            dr[1] = i * 3;
-            dt.Rows.Add(dr);
-        }
-
-        return new() { DataSource = dt };
-    }
-
-    private class SubDataGridViewCell : DataGridViewCell
-    {
-    }
-
-    private class SubDataGridView : DataGridView
-    {
-        public new void OnColumnHeadersHeightChanged(EventArgs e) => base.OnColumnHeadersHeightChanged(e);
-
-        public new void OnColumnHeadersHeightSizeModeChanged(DataGridViewAutoSizeModeEventArgs e) => base.OnColumnHeadersHeightSizeModeChanged(e);
-
-        public new void OnRowHeadersWidthChanged(EventArgs e) => base.OnRowHeadersWidthChanged(e);
-
-        public new void OnRowHeadersWidthSizeModeChanged(DataGridViewAutoSizeModeEventArgs e) => base.OnRowHeadersWidthSizeModeChanged(e);
-    }
-
-    [WinFormsFact]
-    public void DataGridView_GridColor()
-    {
-        using var dataGrid = new DataGridView();
-
-        int changedCount = 0;
-        dataGrid.GridColorChanged += (object sender, EventArgs e) =>
-        {
-            changedCount++;
-        };
-
-        dataGrid.GridColor = Color.Red;
-
-        Assert.Equal(1, changedCount);
-        Assert.Equal(Color.Red, dataGrid.GridColor);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxCell.DataGridViewTextBoxCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxCell.DataGridViewTextBoxCellAccessibleObjectTests.cs
deleted file mode 100644
index 5d1725c79cf..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxCell.DataGridViewTextBoxCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewTextBoxCell_DataGridViewTextBoxCellAccessibleObject
-{
-    [WinFormsFact]
-    public void DataGridViewTextBoxCellAccessibleObject_ControlType_IsDataItem()
-    {
-        using var cell = new DataGridViewTextBoxCell();
-        AccessibleObject accessibleObject = cell.AccessibilityObject;
-
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.DataItemControlTypeId, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControl.DataGridViewTextBoxEditingControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControl.DataGridViewTextBoxEditingControlAccessibleObjectTests.cs
deleted file mode 100644
index 756bc591ff2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControl.DataGridViewTextBoxEditingControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,156 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.DataGridViewTextBoxEditingControl;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewTextBoxEditingControl_DataGridViewTextBoxEditingControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_Ctor_Default()
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        DataGridViewTextBoxEditingControlAccessibleObject accessibleObject = new DataGridViewTextBoxEditingControlAccessibleObject(textCellControl);
-        Assert.Equal(textCellControl, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_Ctor_ThrowsException_IfOwnerIsNull()
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        Assert.Throws<ArgumentNullException>(() => new DataGridViewTextBoxEditingControlAccessibleObject(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_IsReadOnly_IsExpected(bool readOnly)
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        textCellControl.ReadOnly = readOnly;
-        AccessibleObject accessibleObject = textCellControl.AccessibilityObject;
-        Assert.Equal(readOnly, accessibleObject.IsReadOnly);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsValuePatternAvailablePropertyId)]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_GetPropertyValue_PatternsSuported(int propertyID)
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        AccessibleObject accessibleObject = textCellControl.AccessibilityObject;
-        Assert.True((bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyID));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    [InlineData((int)UiaCore.UIA.TextPatternId)]
-    [InlineData((int)UiaCore.UIA.TextPattern2Id)]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_IsPatternSupported_PatternsSuported(int patternId)
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        AccessibleObject accessibleObject = textCellControl.AccessibilityObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_ControlType_IsEdit_IfAccessibleRoleIsDefault()
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        // AccessibleRole is not set = Default
-
-        object actual = textCellControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.EditControlTypeId, actual);
-        Assert.False(textCellControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text)]
-    [InlineData(false, AccessibleRole.None)]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            textCellControl.CreateControl();
-        }
-
-        object actual = textCellControl.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, textCellControl.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewTextBoxEditingControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewTextBoxEditingControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DataGridViewTextBoxEditingControl textCellControl = new DataGridViewTextBoxEditingControl();
-        textCellControl.AccessibleRole = role;
-
-        object actual = textCellControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(textCellControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.NextSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.PreviousSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_FragmentNavigate_SiblingsAndChildrenAreNull(int direction)
-    {
-        using DataGridViewTextBoxEditingControl control = new();
-
-        object actual = control.AccessibilityObject.FragmentNavigate((UiaCore.NavigateDirection)direction);
-
-        Assert.Null(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControlAccessibleObject_FragmentNavigate_ParentIsCell()
-    {
-        using DataGridView control = new();
-
-        Assert.True(control.AccessibilityObject is Control.ControlAccessibleObject);
-
-        control.Columns.Add(new DataGridViewTextBoxColumn());
-        control.Rows.Add();
-
-        control.CreateControl();
-        control.CurrentCell = control.Rows[0].Cells[0];
-        control.BeginEdit(false);
-
-        object actual = control.EditingControlAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        control.EndEdit();
-
-        Assert.Null(control.EditingControl);
-        Assert.Equal(control.CurrentCell.AccessibilityObject, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControlTests.cs
deleted file mode 100644
index f4406d39064..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTextBoxEditingControlTests.cs
+++ /dev/null
@@ -1,2183 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewTextBoxEditingControlTests
-{
-    private static int s_preferredHeight = Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3;
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Ctor_Default()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.False(control.AcceptsReturn);
-        Assert.False(control.AcceptsTab);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Empty(control.AutoCompleteCustomSource);
-        Assert.Same(control.AutoCompleteCustomSource, control.AutoCompleteCustomSource);
-        Assert.Equal(AutoCompleteMode.None, control.AutoCompleteMode);
-        Assert.Equal(AutoCompleteSource.None, control.AutoCompleteSource);
-        Assert.True(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(control.PreferredHeight, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, control.PreferredHeight), control.Bounds);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(CharacterCasing.Normal, control.CharacterCasing);
-        Assert.Equal(new Size(96, control.PreferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 96, control.PreferredHeight - 4), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Same(Cursors.IBeam, control.Cursor);
-        Assert.Same(Cursors.IBeam, 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(100, control.PreferredHeight), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 96, control.PreferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Null(control.EditingControlDataGridView);
-        Assert.Empty(Assert.IsType<string>(control.EditingControlFormattedValue));
-        Assert.Equal(0, control.EditingControlRowIndex);
-        Assert.False(control.EditingControlValueChanged);
-        Assert.Same(Cursors.Default, control.EditingPanelCursor);
-        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.False(control.HasChildren);
-        Assert.Equal(control.PreferredHeight, control.Height);
-        Assert.True(control.HideSelection);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Empty(control.Lines);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(32767, control.MaxLength);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(control.Modified);
-        Assert.False(control.Multiline);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(4, control.PreferredSize.Width);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.True(control.PreferredHeight > 0);
-        Assert.False(control.ReadOnly);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.RepositionEditingControlOnValueChange);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(ScrollBars.None, control.ScrollBars);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.ShortcutsEnabled);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, control.PreferredHeight), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(HorizontalAlignment.Left, control.TextAlign);
-        Assert.Equal(0, control.TextLength);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseSystemPasswordChar);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(100, control.Width);
-        Assert.True(control.WordWrap);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x560000C0, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> EditingControlDataGridView_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DataGridView() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EditingControlDataGridView_Set_TestData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlDataGridView_Set_GetReturnsExpected(DataGridView value)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = value
-        };
-        Assert.Same(value, control.EditingControlDataGridView);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlDataGridView = value;
-        Assert.Same(value, control.EditingControlDataGridView);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    [InlineData("CustomValue")]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlFormattedValue_GetCustomGetEditingControlFormattedValue_ReturnsExpected(object result)
-    {
-        int callCount = 0;
-        object action(DataGridViewDataErrorContexts context)
-        {
-            Assert.Equal(DataGridViewDataErrorContexts.Formatting, context);
-            callCount++;
-            return result;
-        }
-
-        using var control = new CustomGetEditingControlFormattedValueDataGridViewTextBoxEditingControl
-        {
-            GetEditingControlFormattedValueAction = action
-        };
-        Assert.Equal(result, control.EditingControlFormattedValue);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlFormattedValue_Set_GetReturnsExpected(string value, string expected, bool expectedValueChanged)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlFormattedValue = value
-        };
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlFormattedValue = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlFormattedValue_SetWithDataGridView_GetReturnsExpected(string value, string expected, bool expectedValueChanged)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView,
-            EditingControlFormattedValue = value
-        };
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedValueChanged, dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlFormattedValue = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedValueChanged, dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlFormattedValue_SetWithDataGridViewNoColumns_GetReturnsExpected()
-    {
-        using var dataGridView = new DataGridView();
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        Assert.Throws<InvalidOperationException>(() => control.EditingControlFormattedValue = "text");
-        Assert.Equal("text", control.EditingControlFormattedValue);
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, control.TextLength);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlFormattedValue = "text";
-        Assert.Equal("text", control.EditingControlFormattedValue);
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, control.TextLength);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlFormattedValue_SetNonStringValue_ThrowsInvalidCastException()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.Throws<InvalidCastException>(() => control.EditingControlFormattedValue = new object());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlRowIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlRowIndex = value
-        };
-        Assert.Equal(value, control.EditingControlRowIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlRowIndex = value;
-        Assert.Equal(value, control.EditingControlRowIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlValueChanged_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlValueChanged = value
-        };
-        Assert.Equal(value, control.EditingControlValueChanged);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EditingControlValueChanged = value;
-        Assert.Equal(value, control.EditingControlValueChanged);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.EditingControlValueChanged = !value;
-        Assert.Equal(!value, control.EditingControlValueChanged);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_Set_GetReturnsExpected(string value, string expected, bool expectedValueChanged)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_SetWithDataGridView_GetReturnsExpected(string value, string expected, bool expectedValueChanged)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView,
-            Text = value
-        };
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedValueChanged, dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedValueChanged, dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_SetWithDataGridViewNoColumns_GetReturnsExpected()
-    {
-        using var dataGridView = new DataGridView();
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Text = "text");
-        Assert.Equal("text", control.EditingControlFormattedValue);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, control.TextLength);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.EditingControlFormattedValue);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, control.TextLength);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_SetWithHandle_GetReturnsExpected(string value, string expected, bool expectedValueChanged)
-    {
-        using var control = new DataGridViewTextBoxEditingControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.EditingControlFormattedValue);
-        Assert.Equal(expectedValueChanged, control.EditingControlValueChanged);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_Text_SetWithHandlerWithHandle_CallsTextChanged()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_TestData()
-    {
-        yield return new object[] { new DataGridViewCellStyle(), null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false };
-
-        using var font = new Font("Arial", 8.25f);
-        var customStyle = new DataGridViewCellStyle
-        {
-            Font = font,
-            BackColor = Color.Gray,
-            ForeColor = Color.Green
-        };
-        yield return new object[] { customStyle, font, Color.Gray, Color.Green, false, HorizontalAlignment.Left, false };
-
-        var transparentStyle = new DataGridViewCellStyle
-        {
-            Font = font,
-            BackColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78),
-            ForeColor = Color.FromArgb(0x23, 0x45, 0x67, 0x80)
-        };
-        yield return new object[] { transparentStyle, font, Color.FromArgb(0xFF, 0x34, 0x56, 0x78), Color.FromArgb(0x23, 0x45, 0x67, 0x80), false, HorizontalAlignment.Left, false };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, true
-        };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, true
-        };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, false
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_TestData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_Invoke_Success(DataGridViewCellStyle dataGridViewCellStyle, Font expectedFont, Color expectedBackColor, Color expectedForeColor, bool expectedWordWrap, HorizontalAlignment expectedTextAlign, bool expectedRepositionOnValueChange)
-    {
-        using var oldFont = new Font("Arial", 8.25f);
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            Font = oldFont,
-            BackColor = Color.Red,
-            ForeColor = Color.Blue,
-            WordWrap = false
-        };
-        control.ApplyCellStyleToEditingControl(dataGridViewCellStyle);
-        Assert.Equal(expectedFont ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedBackColor, control.BackColor);
-        Assert.Equal(expectedForeColor, control.ForeColor);
-        Assert.Equal(expectedWordWrap, control.WordWrap);
-        Assert.Equal(expectedTextAlign, control.TextAlign);
-        Assert.Equal(expectedRepositionOnValueChange, control.RepositionEditingControlOnValueChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_WithDataGridView_TestData()
-    {
-        yield return new object[] { new DataGridViewCellStyle(), null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false };
-
-        using var font = new Font("Arial", 8.25f);
-        var customStyle = new DataGridViewCellStyle
-        {
-            Font = font,
-            BackColor = Color.Gray,
-            ForeColor = Color.Green
-        };
-        yield return new object[] { customStyle, font, Color.Gray, SystemColors.Control, Color.Green, false, HorizontalAlignment.Left, false };
-
-        var transparentStyle = new DataGridViewCellStyle
-        {
-            Font = font,
-            BackColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78),
-            ForeColor = Color.FromArgb(0x23, 0x45, 0x67, 0x80)
-        };
-        yield return new object[] { transparentStyle, font, Color.FromArgb(0xFF, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78), Color.FromArgb(0x23, 0x45, 0x67, 0x80), false, HorizontalAlignment.Left, false };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.BottomRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.BottomRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, true
-        };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, true
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.MiddleRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.MiddleRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, true
-        };
-
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopCenter
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Center, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopLeft
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Left, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.False,
-                Alignment = DataGridViewContentAlignment.TopRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, false, HorizontalAlignment.Right, false
-        };
-        yield return new object[]
-        {
-            new DataGridViewCellStyle
-            {
-                WrapMode = DataGridViewTriState.True,
-                Alignment = DataGridViewContentAlignment.TopRight
-            },
-            null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), Color.FromArgb(0xFF, 0x00, 0x00, 0x00), SystemColors.WindowText, true, HorizontalAlignment.Right, false
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_WithDataGridView_TestData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_InvokeWithDataGridView_Success(DataGridViewCellStyle dataGridViewCellStyle, Font expectedFont, Color expectedBackColor, Color expectedEditingPanelBackColor, Color expectedForeColor, bool expectedWordWrap, HorizontalAlignment expectedTextAlign, bool expectedRepositionOnValueChange)
-    {
-        using var dataGridView = new DataGridView();
-        using var oldFont = new Font("Arial", 8.25f);
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView,
-            Font = oldFont,
-            BackColor = Color.Red,
-            ForeColor = Color.Blue,
-            WordWrap = false
-        };
-        control.ApplyCellStyleToEditingControl(dataGridViewCellStyle);
-        Assert.Equal(expectedFont ?? Control.DefaultFont, control.Font);
-        Assert.Equal(expectedBackColor, control.BackColor);
-        Assert.Equal(expectedEditingPanelBackColor, dataGridView.EditingPanel.BackColor);
-        Assert.Equal(expectedForeColor, control.ForeColor);
-        Assert.Equal(expectedWordWrap, control.WordWrap);
-        Assert.Equal(expectedTextAlign, control.TextAlign);
-        Assert.Equal(expectedRepositionOnValueChange, control.RepositionEditingControlOnValueChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_ApplyCellStyleToEditingDataGridViewTextBoxEditingControl_NullDataGridViewCellStyle_ThrowsArgumentNullException()
-    {
-        using var control = new DataGridViewTextBoxEditingControl();
-        Assert.Throws<ArgumentNullException>("dataGridViewCellStyle", () => control.ApplyCellStyleToEditingControl(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text)]
-    [InlineData(false, AccessibleRole.None)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedAccessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.Text, instance);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            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);
-    }
-
-    public static IEnumerable<object[]> EditingControlWantsInputKey_TestData()
-    {
-        foreach (bool valueChanged in new bool[] { true, false })
-        {
-            foreach (bool multiline in new bool[] { true, false })
-            {
-                foreach (bool acceptsReturn in new bool[] { true, false })
-                {
-                    foreach (bool dataGridViewWantsInputKey in new bool[] { true, false })
-                    {
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Right, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Right, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Left, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Left, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Down, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Down, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Up, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Up, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Home, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Home, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.End, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.End, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Prior, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || valueChanged };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Prior, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || valueChanged };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Next, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || valueChanged };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Next, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || valueChanged };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Delete, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Delete, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Enter, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Enter, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Enter | Keys.Shift | Keys.Control, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Enter | Keys.Shift | Keys.Control, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.Enter | Keys.Shift, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || (multiline && acceptsReturn) };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.Enter | Keys.Shift, dataGridViewWantsInputKey, !dataGridViewWantsInputKey || (multiline && acceptsReturn) };
-                        yield return new object[] { RightToLeft.Yes, valueChanged, multiline, acceptsReturn, Keys.A, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                        yield return new object[] { RightToLeft.No, valueChanged, multiline, acceptsReturn, Keys.A, dataGridViewWantsInputKey, !dataGridViewWantsInputKey };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EditingControlWantsInputKey_TestData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_EditingControlWantsInputKey_InvokeEmpty_ReturnsExpected(RightToLeft rightToLeft, bool valueChanged, bool multiline, bool acceptsReturn, Keys keyData, bool dataGridViewWantsInputKey, bool expected)
-    {
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            RightToLeft = rightToLeft,
-            EditingControlValueChanged = valueChanged,
-            Multiline = multiline,
-            AcceptsReturn = acceptsReturn
-        };
-        Assert.Equal(expected, control.EditingControlWantsInputKey(keyData, dataGridViewWantsInputKey));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.EditingControlWantsInputKey(keyData, dataGridViewWantsInputKey));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewDataErrorContexts>]
-    [InvalidEnumData<DataGridViewDataErrorContexts>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_GetEditingControlFormattedValue_Invoke_ReturnsExpected(DataGridViewDataErrorContexts context)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.Empty(Assert.IsType<string>(control.GetEditingControlFormattedValue(context)));
-    }
-
-    [WinFormsTheory]
-    [EnumData<DataGridViewDataErrorContexts>]
-    [InvalidEnumData<DataGridViewDataErrorContexts>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_GetEditingControlFormattedValue_InvokeWithText_ReturnsExpected(DataGridViewDataErrorContexts context)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Text = "text"
-        };
-        Assert.Equal("text", Assert.IsType<string>(control.GetEditingControlFormattedValue(context)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnGotFocus_InvokeWithHandle_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingControl_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingControl_OnHandleCreated_InvokeWithDataGridView_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var dataGridView = new DataGridView();
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_WithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, null };
-            yield return new object[] { userPaint, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_WithHandle_TestData))]
-    public void DataGridViewTextBoxEditingControl_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(bool userPaint, EventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnMouseWheel_Invoke_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnMouseWheel_InvokeWithDataGridView_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var dataGridView = new DataGridView();
-        int dataGridViewCallCount = 0;
-        dataGridView.MouseWheel += (sender, e) =>
-        {
-            Assert.Same(dataGridView, sender);
-            Assert.Same(eventArgs, e);
-            dataGridViewCallCount++;
-        };
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, dataGridViewCallCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, dataGridViewCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnTextChanged_Invoke_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnTextChanged_InvokeWithDataGridView_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var dataGridView = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void DataGridViewTextBoxEditingDataGridViewTextBoxEditingControl_OnTextChanged_InvokeWithDataGridViewNoColumns_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var dataGridView = new DataGridView();
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        Assert.Throws<InvalidOperationException>(() => control.OnTextChanged(eventArgs));
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.EditingControlValueChanged);
-        Assert.True(dataGridView.IsCurrentCellDirty);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControl_PrepareEditingControlForEdit_InvokeSelectAll_Success()
-    {
-        var dataGridView = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView,
-            Text = "text"
-        };
-        control.PrepareEditingControlForEdit(selectAll: true);
-        Assert.Equal("text", control.SelectedText);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PrepareEditingControlForEdit(selectAll: true);
-        Assert.Equal("text", control.SelectedText);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Deselect.
-        control.PrepareEditingControlForEdit(selectAll: false);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(4, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTextBoxEditingControl_PrepareEditingControlForEdit_InvokeNotSelectAll_Success()
-    {
-        var dataGridView = new DataGridView
-        {
-            ColumnCount = 1
-        };
-        using var control = new DataGridViewTextBoxEditingControl
-        {
-            EditingControlDataGridView = dataGridView,
-            Text = "text"
-        };
-        control.PrepareEditingControlForEdit(selectAll: false);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(4, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.PrepareEditingControlForEdit(selectAll: false);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(4, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Select all.
-        control.PrepareEditingControlForEdit(selectAll: true);
-        Assert.Equal("text", control.SelectedText);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ProcessKeyEventArgs_TestData()
-    {
-        foreach (bool handled in new bool[] { true, false })
-        {
-            foreach (IntPtr wParam in new IntPtr[] { (IntPtr)Keys.Enter, (IntPtr)Keys.LineFeed, (IntPtr)Keys.A, (IntPtr)2 })
-            {
-                if (wParam != (IntPtr)Keys.Enter)
-                {
-                    yield return new object[] { (int)PInvoke.WM_CHAR, wParam, '2', handled, handled, 1, 0, 0, (IntPtr)50 };
-                    yield return new object[] { (int)PInvoke.WM_CHAR, wParam, '1', handled, handled, 1, 0, 0, (IntPtr)49 };
-                }
-
-                yield return new object[] { (int)PInvoke.WM_SYSCHAR, wParam, '2', handled, handled, 1, 0, 0, (IntPtr)50 };
-                yield return new object[] { (int)PInvoke.WM_SYSCHAR, wParam, '1', handled, handled, 1, 0, 0, (IntPtr)49 };
-                yield return new object[] { (int)PInvoke.WM_IME_CHAR, wParam, '2', handled, handled, 1, 0, 0, (IntPtr)50 };
-                yield return new object[] { (int)PInvoke.WM_IME_CHAR, wParam, '1', handled, handled, 1, 0, 0, (IntPtr)49 };
-                yield return new object[] { (int)PInvoke.WM_KEYDOWN, wParam, '2', handled, handled, 0, 1, 0, wParam };
-                yield return new object[] { (int)PInvoke.WM_SYSKEYDOWN, wParam, '2', handled, handled, 0, 1, 0, wParam };
-                yield return new object[] { (int)PInvoke.WM_KEYUP, wParam, '2', handled, handled, 0, 0, 1, wParam };
-                yield return new object[] { (int)PInvoke.WM_SYSKEYUP, wParam, '2', handled, handled, 0, 0, 1, wParam };
-                yield return new object[] { 0, wParam, '2', handled, handled, 0, 0, 1, wParam };
-            }
-
-            yield return new object[] { (int)PInvoke.WM_CHAR, (IntPtr)Keys.Enter, '2', handled, true, 0, 0, 0, (IntPtr)Keys.Enter };
-            yield return new object[] { (int)PInvoke.WM_CHAR, (IntPtr)Keys.Enter, '1', handled, true, 0, 0, 0, (IntPtr)Keys.Enter };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyEventArgs_InvokeWithoutParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyEventArgs_InvokeWithParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var parent = new Control();
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyEventArgs_InvokeWithCustomParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        int callCount = 0;
-        bool action(Message m)
-        {
-            callCount++;
-            return true;
-        }
-
-        using var parent = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyEventArgs(ref m));
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_CHAR)]
-    [InlineData((int)PInvoke.WM_SYSCHAR)]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyEventArgs_InvokeCharAfterImeChar_Success(int msg)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(0, e.KeyChar);
-            e.Handled = true;
-            keyPressCallCount++;
-        };
-        var charM = new Message
-        {
-            Msg = msg
-        };
-        var imeM = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_CHAR
-        };
-
-        // Char.
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Ime, Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(4, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(5, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(6, keyPressCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_KEYDOWN)]
-    [InlineData((int)PInvoke.WM_SYSKEYDOWN)]
-    [InlineData((int)PInvoke.WM_KEYUP)]
-    [InlineData((int)PInvoke.WM_SYSKEYUP)]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyEventArgs_InvokeNonCharAfterImeChar_Success(int msg)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            e.Handled = true;
-            keyPressCallCount++;
-        };
-        int keyCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            e.Handled = true;
-            keyCallCount++;
-        };
-        control.KeyUp += (sender, e) =>
-        {
-            e.Handled = true;
-            keyCallCount++;
-        };
-        var charM = new Message
-        {
-            Msg = msg
-        };
-        var imeM = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_CHAR
-        };
-
-        // Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(0, keyPressCallCount);
-        Assert.Equal(1, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(1, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(2, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(1, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Ime, Ime, Non-Char.
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(2, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref imeM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(3, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(4, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(5, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(control.ProcessKeyEventArgs(ref charM));
-        Assert.Equal(3, keyPressCallCount);
-        Assert.Equal(6, keyCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomProcessKeyEventArgsControl : Control
-    {
-        public Func<Message, bool> ProcessKeyEventArgsAction { get; set; }
-
-        protected override bool ProcessKeyEventArgs(ref Message m) => ProcessKeyEventArgsAction(m);
-
-        public new bool ProcessKeyMessage(ref Message m) => base.ProcessKeyMessage(ref m);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithoutParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var control = new SubDataGridViewTextBoxEditingControl();
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyMessage(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        using var parent = new Control();
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyMessage(ref m));
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessKeyEventArgs_TestData))]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithCustomParent_ReturnsFalse(int msg, IntPtr wParam, char newChar, bool handled, bool expected, int expectedKeyPressCallCount, int expectedKeyDownCallCount, int expectedKeyUpCallCount, IntPtr expectedWParam)
-    {
-        int callCount = 0;
-        bool action(Message m)
-        {
-            callCount++;
-            return true;
-        }
-
-        using var parent = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Parent = parent
-        };
-        int keyPressCallCount = 0;
-        control.KeyPress += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal((char)wParam, e.KeyChar);
-            e.KeyChar = newChar;
-            e.Handled = handled;
-            keyPressCallCount++;
-        };
-        int keyDownCallCount = 0;
-        control.KeyDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyDownCallCount++;
-        };
-        int keyUpCallCount = 0;
-        control.KeyUp += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(PARAM.ToInt(wParam), e.KeyValue);
-            e.Handled = handled;
-            keyUpCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam
-        };
-        Assert.Equal(expected, control.ProcessKeyMessage(ref m));
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedKeyPressCallCount, keyPressCallCount);
-        Assert.Equal(expectedKeyDownCallCount, keyDownCallCount);
-        Assert.Equal(expectedKeyUpCallCount, keyUpCallCount);
-        Assert.Equal(expectedWParam, m.WParam);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithCustomParentProcessKeyPreview_ReturnsExpected(bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessKeyPreviewAction = action
-        };
-        using var control = new SubDataGridViewTextBoxEditingControl
-        {
-            Parent = parent
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(result, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithCustomProcessKeyEventArgs_ReturnsExpected(bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var control = new CustomProcessKeyEventArgsControl
-        {
-            ProcessKeyEventArgsAction = action
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(result, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, true)]
-    [InlineData(true, false, 0, true)]
-    [InlineData(false, true, 1, true)]
-    [InlineData(false, false, 1, false)]
-    public void DataGridViewTextBoxEditingControl_ProcessKeyMessage_InvokeWithCustomParentProcessKeyPreviewCustomProcessKeyEventArgs_ReturnsExpected(bool parentResult, bool result, int expectedCallCount, bool expectedResult)
-    {
-        int parentCallCount = 0;
-        bool parentAction(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            parentCallCount++;
-            return parentResult;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessKeyPreviewAction = parentAction
-        };
-        int callCount = 0;
-        bool action(Message actualM)
-        {
-            Assert.Equal(1, actualM.Msg);
-            callCount++;
-            return result;
-        }
-
-        using var control = new CustomProcessKeyEventArgsControl
-        {
-            Parent = parent,
-            ProcessKeyEventArgsAction = action
-        };
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.Equal(expectedResult, control.ProcessKeyMessage(ref m));
-        Assert.Equal(1, parentCallCount);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<char, bool> ProcessDialogCharAction { get; set; }
-
-        protected override bool ProcessDialogChar(char charCode) => ProcessDialogCharAction(charCode);
-
-        public Func<Keys, bool> ProcessDialogKeyAction { get; set; }
-
-        protected override bool ProcessDialogKey(Keys keyData) => ProcessDialogKeyAction(keyData);
-
-        public Func<Message, bool> ProcessKeyPreviewAction { get; set; }
-
-        protected override bool ProcessKeyPreview(ref Message m) => ProcessKeyPreviewAction(m);
-    }
-
-    private class CustomGetEditingControlFormattedValueDataGridViewTextBoxEditingControl : DataGridViewTextBoxEditingControl
-    {
-        public Func<DataGridViewDataErrorContexts, object> GetEditingControlFormattedValueAction { get; set; }
-
-        public override object GetEditingControlFormattedValue(DataGridViewDataErrorContexts context)
-        {
-            return GetEditingControlFormattedValueAction(context);
-        }
-    }
-
-    private class SubDataGridViewTextBoxEditingControl : DataGridViewTextBoxEditingControl
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsHandleCreated => base.IsHandleCreated;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new void CreateControl() => base.CreateControl();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnMouseWheel(MouseEventArgs e) => base.OnMouseWheel(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new bool ProcessKeyEventArgs(ref Message m) => base.ProcessKeyEventArgs(ref m);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopLeftHeaderCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopLeftHeaderCellAccessibleObjectTests.cs
deleted file mode 100644
index 8699e8fe912..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopLeftHeaderCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,296 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewTopLeftHeaderCellAccessibleObjectTests : DataGridViewTopLeftHeaderCell
-{
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new DataGridViewTopLeftHeaderCellAccessibleObject(null);
-
-        Assert.Null(accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Bounds_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<InvalidOperationException>(() =>
-            new DataGridViewTopLeftHeaderCellAccessibleObject(null).Bounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Bounds_ReturnsEmptyRectangle_IfDataGridViewIsNull()
-    {
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        Assert.Null(cell.DataGridView);
-        Assert.Equal(Rectangle.Empty, cell.AccessibilityObject.Bounds);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Bounds_ReturnsEmptyRectangle_IfDataGridViewIsNotCreated()
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-
-        Assert.Equal(Rectangle.Empty, cell.AccessibilityObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Bounds_ReturnsExpected()
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        control.CreateControl();
-
-        Assert.NotEqual(Rectangle.Empty, cell.AccessibilityObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewTopLeftHeaderCellAccessibleObject_DefaultAction_TestData()
-    {
-        yield return new object[] { true, SR.DataGridView_AccTopLeftColumnHeaderCellDefaultAction };
-        yield return new object[] { false, string.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewTopLeftHeaderCellAccessibleObject_DefaultAction_TestData))]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_DefaultAction_ReturnsExpected(bool isMultiSelect, string expected)
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        control.MultiSelect = isMultiSelect;
-
-        Assert.Equal(expected, cell.AccessibilityObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Value_ReturnsExpected()
-    {
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        Assert.Equal(string.Empty, cell.AccessibilityObject.Value);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new DataGridViewTopLeftHeaderCellAccessibleObject(null);
-
-        UiaCore.UIA expected = UiaCore.UIA.HeaderControlTypeId;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_IsEnabled_ReturnsExpected(bool isEnabled)
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        control.Enabled = isEnabled;
-
-        Assert.Equal(isEnabled, cell.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DataGridViewTopLeftHeaderCellAccessibleObject_Name_TestData()
-    {
-        yield return new object[] { RightToLeft.No, SR.DataGridView_AccTopLeftColumnHeaderCellName };
-        yield return new object[] { RightToLeft.Yes, SR.DataGridView_AccTopLeftColumnHeaderCellNameRTL };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataGridViewTopLeftHeaderCellAccessibleObject_Name_TestData))]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Name_ReturnsExpected(RightToLeft value, string expected)
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        control.RightToLeft = value;
-
-        Assert.Equal(expected, cell.AccessibilityObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_Name_ReturnsEmptyString_IfOwnerValueIsNotEmptySring()
-    {
-        using DataGridView control = new();
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        cell.Value = "It is not empty string";
-        control.TopLeftHeaderCell = cell;
-
-        Assert.Equal(string.Empty, cell.AccessibilityObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 0, createControl);
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        AccessibleObject expected = control.AccessibilityObject.GetChild(0);
-
-        Assert.Equal(expected, cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 0, createControl);
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-
-        Assert.Null(cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 0, createControl);
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-        AccessibleObject expected = control.AccessibilityObject.GetChild(0)?.GetChild(1);
-
-        Assert.Equal(expected, cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsNull_IfDataGridViewHasNoVisibleCollumns(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 0, createControl);
-        using DataGridViewTopLeftHeaderCell cell = new();
-
-        control.TopLeftHeaderCell = cell;
-
-        Assert.Null(cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfFirstColumnHidden(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].Visible = false;
-
-        using DataGridViewTopLeftHeaderCell cell = new();
-        control.TopLeftHeaderCell = cell;
-
-        AccessibleObject expected = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(expected, cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfCustomOrder(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].DisplayIndex = 1;
-        control.Columns[1].DisplayIndex = 0;
-
-        using DataGridViewTopLeftHeaderCell cell = new();
-        control.TopLeftHeaderCell = cell;
-
-        AccessibleObject expected = control.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(expected, cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfCustomOrderAndFirstDisplayedColumnHidden(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 2, createControl);
-        control.Columns[0].DisplayIndex = 1;
-        control.Columns[1].DisplayIndex = 0;
-        control.Columns[1].Visible = false;
-
-        using DataGridViewTopLeftHeaderCell cell = new();
-        control.TopLeftHeaderCell = cell;
-
-        AccessibleObject expected = control.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(expected, cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DataGridViewTopLeftHeaderCellAccessibleObject_FragmentNavigate_Child_ReturnsNull(bool createControl)
-    {
-        using DataGridView control = CreateDataGridView(columnCount: 0, createControl);
-
-        using DataGridViewTopLeftHeaderCell cell = new();
-        control.TopLeftHeaderCell = cell;
-
-        Assert.Null(cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    private DataGridView CreateDataGridView(int columnCount, bool createControl = true)
-    {
-        DataGridView dataGridView = new();
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            dataGridView.Columns.Add(new DataGridViewTextBoxColumn());
-        }
-
-        if (createControl)
-        {
-            dataGridView.CreateControl();
-        }
-
-        return dataGridView;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopRowAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopRowAccessibleObjectTests.cs
deleted file mode 100644
index 05814458086..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataGridViewTopRowAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1247 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataGridViewTopRowAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_ReturnsExpected_AllowUserToAddRowsEnabled()
-    {
-        using DataGridView dataGridView = new();
-        DataGridViewTextBoxColumn dataGridViewColumn = new() { Name = "Col 1", HeaderText = "Col 1" };
-
-        dataGridView.Columns.Add(dataGridViewColumn);
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject expectedNextSibling = dataGridView.Rows[0].AccessibilityObject;
-        AccessibleObject expectedFirstChild = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject expectedLastChild = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(dataGridView.AccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(expectedNextSibling, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(expectedFirstChild, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(expectedLastChild, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_ReturnsExpected_AllowUserToAddRowsDisabled()
-    {
-        using DataGridView dataGridView = new() { AllowUserToAddRows = false };
-        DataGridViewTextBoxColumn dataGridViewColumn = new() { Name = "Col 1", HeaderText = "Col 1" };
-
-        dataGridView.Columns.Add(dataGridViewColumn);
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject expectedFirstChild = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject expectedLastChild = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(dataGridView.AccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(expectedFirstChild, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(expectedLastChild, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_ReturnsExpected_WithoutColumns()
-    {
-        using DataGridView dataGridView = new();
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-
-        Assert.Equal(dataGridView.AccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfRowHeadersAndAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfRowHeadersAndAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Null(topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndFirstColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndSecondColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndLastColumnAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_Navigate_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(accessibleObject, topRowAccessibleObject.Navigate(AccessibleNavigation.LastChild));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndColumnsHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Null(topRowAccessibleObject.GetChild(0));
-        Assert.Null(topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(3));
-        Assert.Null(topRowAccessibleObject.GetChild(4));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfAllColumnsHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Null(topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfThirdColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndRowHeadersAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(1));
-        Assert.Null(topRowAccessibleObject.GetChild(2));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrder()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(3));
-        Assert.Null(topRowAccessibleObject.GetChild(4));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndFirstColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndSecondColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject1 = dataGridView.Columns[2].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject1, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChild_ReturnsExpected_IfCustomOrderAndLastColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].DisplayIndex = 2;
-        dataGridView.Columns[1].DisplayIndex = 1;
-        dataGridView.Columns[2].DisplayIndex = 0;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-        AccessibleObject topLeftAccessibilityObject = dataGridView.TopLeftHeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject2 = dataGridView.Columns[1].HeaderCell.AccessibilityObject;
-        AccessibleObject accessibleObject3 = dataGridView.Columns[0].HeaderCell.AccessibilityObject;
-
-        Assert.Equal(topLeftAccessibilityObject, topRowAccessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject2, topRowAccessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject3, topRowAccessibleObject.GetChild(2));
-        Assert.Null(topRowAccessibleObject.GetChild(3));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsFour()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(4, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsThree_IfOneColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(3, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsTwo_IfTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(2, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsOne_IfAllColumnHidden()
-    {
-        using DataGridView dataGridView = new();
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(1, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsThreeIfRowHeadersHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(3, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsTwo_IfRowHeadersAndOneColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(2, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsOne_IfRowHeadersAndTwoColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(1, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetChildCount_ReturnsZero_IfRowHeadersAndAllColumnHidden()
-    {
-        using DataGridView dataGridView = new() { RowHeadersVisible = false };
-        dataGridView.Columns.Add("Column 1", "Column 1");
-        dataGridView.Columns.Add("Column 2", "Column 2");
-        dataGridView.Columns.Add("Column 3", "Column 3");
-        dataGridView.Columns[0].Visible = false;
-        dataGridView.Columns[1].Visible = false;
-        dataGridView.Columns[2].Visible = false;
-
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.Equal(0, topRowAccessibleObject.GetChildCount());
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DataGridViewTopRowAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using DataGridView dataGridView = new DataGridView();
-        AccessibleObject topRowAccessibleObject = dataGridView.AccessibilityObject.TestAccessor().Dynamic.TopRowAccessibilityObject;
-
-        Assert.True((bool)topRowAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.Equal(string.Empty, topRowAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.HelpTextPropertyId));
-        Assert.Equal(SR.DataGridView_AccTopRow, topRowAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.NamePropertyId));
-        Assert.Equal(SR.DataGridView_AccTopRow, topRowAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.Equal("Top Row", topRowAccessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(dataGridView.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObjectTests.cs
deleted file mode 100644
index 7a86f136f27..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObjectTests.cs
+++ /dev/null
@@ -1,2429 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Specialized;
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.ComTypes;
-using System.Runtime.Serialization;
-using Windows.Win32.System.Ole;
-using Moq;
-using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
-using Point = System.Drawing.Point;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DataObjectTests
-{
-    private static readonly string[] s_clipboardFormats =
-    {
-        DataFormats.CommaSeparatedValue,
-        DataFormats.Dib,
-        DataFormats.Dif,
-        DataFormats.PenData,
-        DataFormats.Riff,
-        DataFormats.Tiff,
-        DataFormats.WaveAudio,
-        DataFormats.SymbolicLink,
-        DataFormats.StringFormat,
-        DataFormats.Bitmap,
-        DataFormats.EnhancedMetafile,
-        DataFormats.FileDrop,
-        DataFormats.Html,
-        DataFormats.MetafilePict,
-        DataFormats.OemText,
-        DataFormats.Palette,
-        DataFormats.Rtf,
-        DataFormats.Text,
-        DataFormats.UnicodeText,
-        DataFormats.Serializable,
-        "something custom",
-    };
-
-    private static readonly string[] s_mappedFormats =
-    {
-        typeof(Bitmap).FullName,
-        "FileName",
-        "FileNameW"
-    };
-
-    [Fact]
-    public void DataObject_ContainsAudio_InvokeDefault_ReturnsFalse()
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.ContainsAudio());
-    }
-
-    [Theory]
-    [BoolData]
-    public void DataObject_ContainsAudio_InvokeMocked_CallsGetDataPresent(bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.ContainsAudio())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(DataFormats.WaveAudio, false))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.ContainsAudio());
-        mockDataObject.Verify(o => o.GetDataPresent(DataFormats.WaveAudio, false), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_ContainsFileDropList_InvokeDefault_ReturnsFalse()
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.ContainsFileDropList());
-    }
-
-    [Theory]
-    [BoolData]
-    public void DataObject_ContainsFileDropList_InvokeMocked_CallsGetDataPresent(bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.ContainsFileDropList())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(DataFormats.FileDrop, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.ContainsFileDropList());
-        mockDataObject.Verify(o => o.GetDataPresent(DataFormats.FileDrop, true), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_ContainsImage_InvokeDefault_ReturnsFalse()
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.ContainsImage());
-    }
-
-    [Theory]
-    [BoolData]
-    public void DataObject_ContainsImage_InvokeMocked_CallsGetDataPresent(bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.ContainsImage())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(DataFormats.Bitmap, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.ContainsImage());
-        mockDataObject.Verify(o => o.GetDataPresent(DataFormats.Bitmap, true), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_ContainsText_InvokeDefault_ReturnsFalse()
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.ContainsText());
-    }
-
-    [Theory]
-    [BoolData]
-    public void DataObject_ContainsText_InvokeMocked_CallsGetDataPresent(bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.ContainsText())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.ContainsText(TextDataFormat.UnicodeText))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.ContainsText());
-        mockDataObject.Verify(o => o.ContainsText(TextDataFormat.UnicodeText), Times.Once());
-    }
-
-    [Theory]
-    [EnumData<TextDataFormat>]
-    public void DataObject_ContainsText_InvokeTextDataFormat_ReturnsFalse(TextDataFormat format)
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.ContainsText(format));
-    }
-
-    public static IEnumerable<object[]> ContainsText_TextDataFormat_TestData()
-    {
-        foreach (bool result in new bool[] { true, false })
-        {
-            yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, result };
-            yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, result };
-            yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, result };
-            yield return new object[] { TextDataFormat.Html, DataFormats.Html, result };
-            yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, result };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(ContainsText_TextDataFormat_TestData))]
-    public void DataObject_ContainsText_InvokeTextDataFormatMocked_CallsGetDataPresent(TextDataFormat format, string expectedFormat, bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.ContainsText(format))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(expectedFormat, false))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.ContainsText(format));
-        mockDataObject.Verify(o => o.GetDataPresent(expectedFormat, false), Times.Once());
-    }
-
-    [Theory]
-    [InvalidEnumData<TextDataFormat>]
-    public void DataObject_ContainsText_InvokeInvalidTextDataFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<InvalidEnumArgumentException>("format", () => dataObject.ContainsText(format));
-    }
-
-    [Fact]
-    public void DataObject_GetAudioStream_InvokeDefault_ReturnsNull()
-    {
-        var dataObject = new DataObject();
-        Assert.Null(dataObject.GetAudioStream());
-    }
-
-    public static IEnumerable<object[]> GetAudioStream_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), null };
-
-        var stream = new MemoryStream();
-        yield return new object[] { stream, stream };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAudioStream_TestData))]
-    public void DataObject_GetAudioStream_InvokeWithData_ReturnsExpected(object result, Stream expected)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.WaveAudio, result);
-        Assert.Same(expected, dataObject.GetAudioStream());
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAudioStream_TestData))]
-    public void DataObject_GetAudioStream_InvokeMocked_ReturnsExpected(object result, Stream expected)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetAudioStream())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetData(DataFormats.WaveAudio, false))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(expected, mockDataObject.Object.GetAudioStream());
-        mockDataObject.Verify(o => o.GetData(DataFormats.WaveAudio, false), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetData_String_TestData()
-    {
-        foreach (string format in s_clipboardFormats)
-        {
-            yield return new object[] { format };
-        }
-
-        foreach (string format in s_mappedFormats)
-        {
-            yield return new object[] { format };
-        }
-
-        yield return new object[] { "  " };
-        yield return new object[] { string.Empty };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_String_TestData))]
-    public void DataObject_GetData_InvokeStringDefault_ReturnsNull(string format)
-    {
-        var dataObject = new DataObject();
-        Assert.Null(dataObject.GetData(format));
-    }
-
-    public static IEnumerable<object[]> GetData_InvokeStringMocked_TestData()
-    {
-        foreach (object result in new object[] { new object(), null })
-        {
-            yield return new object[] { "format", result };
-            yield return new object[] { "  ", result };
-            yield return new object[] { string.Empty, result };
-            yield return new object[] { null, result };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_InvokeStringMocked_TestData))]
-    public void DataObject_GetData_InvokeStringMocked_CallsGetData(string format, object result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetData(format))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetData(format, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(result, mockDataObject.Object.GetData(format));
-        mockDataObject.Verify(o => o.GetData(format, true), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetData_StringIDataObject_TestData()
-    {
-        foreach (object result in new object[] { new object(), null })
-        {
-            yield return new object[] { "format", result };
-            yield return new object[] { "  ", result };
-            yield return new object[] { string.Empty, result };
-            yield return new object[] { null, result };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_StringIDataObject_TestData))]
-    public void DataObject_GetData_InvokeStringIDataObject_ReturnsExpected(string format, object result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetData(format, true))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Same(result, dataObject.GetData(format));
-        mockDataObject.Verify(o => o.GetData(format, true), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetData_StringBool_TestData()
-    {
-        foreach (bool autoConvert in new bool[] { true, false })
-        {
-            foreach (string format in s_clipboardFormats)
-            {
-                yield return new object[] { format, autoConvert };
-            }
-
-            foreach (string format in s_mappedFormats)
-            {
-                yield return new object[] { format, autoConvert };
-            }
-
-            yield return new object[] { "  ", autoConvert };
-            yield return new object[] { string.Empty, autoConvert };
-            yield return new object[] { null, autoConvert };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_StringBool_TestData))]
-    public void DataObject_GetData_InvokeStringBoolDefault_ReturnsNull(string format, bool autoConvert)
-    {
-        var dataObject = new DataObject();
-        Assert.Null(dataObject.GetData(format, autoConvert));
-    }
-
-    public static IEnumerable<object[]> GetData_StringBoolIDataObject_TestData()
-    {
-        foreach (bool autoConvert in new bool[] { true, false })
-        {
-            foreach (object result in new object[] { new object(), null })
-            {
-                yield return new object[] { "format", autoConvert, result };
-                yield return new object[] { "  ", autoConvert, result };
-                yield return new object[] { string.Empty, autoConvert, result };
-                yield return new object[] { null, autoConvert, result };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_StringBoolIDataObject_TestData))]
-    public void DataObject_GetData_InvokeStringBoolIDataObject_ReturnsExpected(string format, bool autoConvert, object result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetData(format, autoConvert))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Same(result, dataObject.GetData(format, autoConvert));
-        mockDataObject.Verify(o => o.GetData(format, autoConvert), Times.Once());
-    }
-
-    [Theory]
-    [InlineData(typeof(int))]
-    [InlineData(null)]
-    public void DataObject_GetData_InvokeTypeDefault_ReturnsNull(Type format)
-    {
-        var dataObject = new DataObject();
-        Assert.Null(dataObject.GetData(format));
-    }
-
-    public static IEnumerable<object[]> GetData_InvokeTypeMocked_TestData()
-    {
-        foreach (object result in new object[] { new object(), null })
-        {
-            yield return new object[] { typeof(int), result, 1, result };
-            yield return new object[] { null, result, 0, null };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetData_InvokeTypeMocked_TestData))]
-    public void DataObject_GetData_InvokeTypeMocked_CallsGetData(Type format, object result, int expectedCallCount, object expectedResult)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetData(It.IsAny<Type>()))
-            .CallBase();
-        string formatName = format?.FullName ?? "(null)";
-        mockDataObject
-            .Setup(o => o.GetData(formatName))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(expectedResult, mockDataObject.Object.GetData(format));
-        mockDataObject.Verify(o => o.GetData(formatName), Times.Exactly(expectedCallCount));
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_String_TestData()
-    {
-        foreach (string format in s_clipboardFormats)
-        {
-            yield return new object[] { format };
-        }
-
-        foreach (string format in s_mappedFormats)
-        {
-            yield return new object[] { format };
-        }
-
-        yield return new object[] { "  " };
-        yield return new object[] { string.Empty };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_String_TestData))]
-    public void DataObject_GetDataPresent_InvokeStringDefault_ReturnsFalse(string format)
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.GetDataPresent(format));
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_StringMocked_TestData()
-    {
-        foreach (bool result in new bool[] { true, false })
-        {
-            yield return new object[] { "format", result };
-            yield return new object[] { "  ", result };
-            yield return new object[] { string.Empty, result };
-            yield return new object[] { null, result };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_StringMocked_TestData))]
-    public void DataObject_GetDataPresent_InvokeStringMocked_CallsGetDataPresent(string format, bool result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetDataPresent(format))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(format, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(result, mockDataObject.Object.GetDataPresent(format));
-        mockDataObject.Verify(o => o.GetDataPresent(format, true), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_StringIDataObject_TestData()
-    {
-        foreach (bool result in new bool[] { true, false })
-        {
-            yield return new object[] { "format", result };
-            yield return new object[] { "  ", result };
-            yield return new object[] { string.Empty, result };
-            yield return new object[] { null, result };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_StringIDataObject_TestData))]
-    public void DataObject_GetDataPresent_InvokeStringIDataObject_ReturnsExpected(string format, bool result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetDataPresent(format, true))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Equal(result, dataObject.GetDataPresent(format));
-        mockDataObject.Verify(o => o.GetDataPresent(format, true), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_StringBool_TestData()
-    {
-        foreach (bool autoConvert in new bool[] { true, false })
-        {
-            foreach (string format in s_clipboardFormats)
-            {
-                yield return new object[] { format, autoConvert };
-            }
-
-            foreach (string format in s_mappedFormats)
-            {
-                yield return new object[] { format, autoConvert };
-            }
-
-            yield return new object[] { "  ", autoConvert };
-            yield return new object[] { string.Empty, autoConvert };
-            yield return new object[] { null, autoConvert };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_StringBool_TestData))]
-    public void DataObject_GetDataPresent_InvokeStringBoolDefault_ReturnsFalse(string format, bool autoConvert)
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.GetDataPresent(format, autoConvert));
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_StringBoolIDataObject_TestData()
-    {
-        foreach (bool autoConvert in new bool[] { true, false })
-        {
-            foreach (bool result in new bool[] { true, false })
-            {
-                yield return new object[] { "format", autoConvert, result };
-                yield return new object[] { "  ", autoConvert, result };
-                yield return new object[] { string.Empty, autoConvert, result };
-                yield return new object[] { null, autoConvert, result };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_StringBoolIDataObject_TestData))]
-    public void DataObject_GetDataPresent_InvokeStringBoolIDataObject_ReturnsExpected(string format, bool autoConvert, bool result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetDataPresent(format, autoConvert))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Equal(result, dataObject.GetDataPresent(format, autoConvert));
-        mockDataObject.Verify(o => o.GetDataPresent(format, autoConvert), Times.Once());
-    }
-
-    [Theory]
-    [InlineData(typeof(int))]
-    [InlineData(null)]
-    public void DataObject_GetDataPresentPresent_InvokeTypeDefault_ReturnsFalse(Type format)
-    {
-        var dataObject = new DataObject();
-        Assert.False(dataObject.GetDataPresent(format));
-    }
-
-    public static IEnumerable<object[]> GetDataPresent_InvokeTypeMocked_TestData()
-    {
-        foreach (bool result in new bool[] { true, false })
-        {
-            yield return new object[] { typeof(int), result, 1, result, typeof(int).FullName };
-            yield return new object[] { null, result, 0, false, "(null)" };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetDataPresent_InvokeTypeMocked_TestData))]
-    public void DataObject_GetDataPresent_InvokeTypeMocked_CallsGetDataPresent(Type format, bool result, int expectedCallCount, bool expectedResult, string expectedFormatName)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetDataPresent(It.IsAny<Type>()))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetDataPresent(expectedFormatName))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(expectedResult, mockDataObject.Object.GetDataPresent(format));
-        mockDataObject.Verify(o => o.GetDataPresent(expectedFormatName), Times.Exactly(expectedCallCount));
-    }
-
-    [Fact]
-    public void DataObject_GetFileDropList_InvokeDefault_ReturnsEmpty()
-    {
-        var dataObject = new DataObject();
-        Assert.Empty(dataObject.GetFileDropList());
-    }
-
-    public static IEnumerable<object[]> GetFileDropList_TestData()
-    {
-        yield return new object[] { null, Array.Empty<string>() };
-        yield return new object[] { new object(), Array.Empty<string>() };
-
-        var list = new string[] { "a", "  ", string.Empty, null };
-        yield return new object[] { list, list };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFileDropList_TestData))]
-    public void DataObject_GetFileDropList_InvokeWithData_ReturnsExpected(object result, string[] expected)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.FileDrop, result);
-        Assert.Equal(expected, dataObject.GetFileDropList().Cast<string>());
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFileDropList_TestData))]
-    public void DataObject_GetFileDropList_InvokeMocked_ReturnsExpected(object result, string[] expected)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFileDropList())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetData(DataFormats.FileDrop, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Equal(expected, mockDataObject.Object.GetFileDropList().Cast<string>());
-        mockDataObject.Verify(o => o.GetData(DataFormats.FileDrop, true), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_GetFormats_InvokeDefault_ReturnsEmpty()
-    {
-        var dataObject = new DataObject();
-        Assert.Empty(dataObject.GetFormats());
-    }
-
-    [WinFormsFact]
-    public void DataObject_GetFormats_InvokeWithValues_ReturnsExpected()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData("format1", "data1");
-        Assert.Equal(new string[] { "format1" }, dataObject.GetFormats());
-
-        dataObject.SetText("data2");
-        Assert.Equal(new string[] { "format1", "UnicodeText" }, dataObject.GetFormats());
-
-        using var bitmap1 = new Bitmap(10, 10);
-        dataObject.SetData("format2", bitmap1);
-        Assert.Equal(new string[] { "format1", "format2", "UnicodeText" }, dataObject.GetFormats().OrderBy(s => s));
-
-        using var bitmap2 = new Bitmap(10, 10);
-        dataObject.SetData(bitmap2);
-        Assert.Equal(new string[] { "Bitmap", "format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject" }, dataObject.GetFormats().OrderBy(s => s));
-    }
-
-    public static IEnumerable<object[]> GetFormats_Mocked_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<string>() };
-        yield return new object[] { new string[] { "a", "  ", string.Empty, null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormats_Mocked_TestData))]
-    public void DataObject_GetFormats_InvokeMocked_ReturnsExpected(string[] result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(result, mockDataObject.Object.GetFormats());
-        mockDataObject.Verify(o => o.GetFormats(true), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetFormats_IDataObject_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<string>() };
-        yield return new object[] { new string[] { "a", string.Empty, null } };
-        yield return new object[] { new string[] { "a", "  ", string.Empty, null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormats_IDataObject_TestData))]
-    public void DataObject_GetFormats_InvokeIDataObject_ReturnsExpected(string[] result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Same(result, dataObject.GetFormats());
-        mockDataObject.Verify(o => o.GetFormats(true), Times.Once());
-    }
-
-    [Theory]
-    [BoolData]
-    public void DataObject_GetFormats_InvokeBoolDefault_ReturnsEmpty(bool autoConvert)
-    {
-        var dataObject = new DataObject();
-        Assert.Empty(dataObject.GetFormats(autoConvert));
-    }
-
-    [WinFormsFact]
-    public void DataObject_GetFormats_InvokeBoolWithValues_ReturnsExpected()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData("format1", "data1");
-        Assert.Equal(new string[] { "format1" }, dataObject.GetFormats(autoConvert: true));
-        Assert.Equal(new string[] { "format1" }, dataObject.GetFormats(autoConvert: false));
-
-        dataObject.SetText("data2");
-        Assert.Equal(new string[] { "format1", "UnicodeText" }, dataObject.GetFormats(autoConvert: true));
-        Assert.Equal(new string[] { "format1", "UnicodeText" }, dataObject.GetFormats(autoConvert: false));
-
-        using var bitmap1 = new Bitmap(10, 10);
-        dataObject.SetData("format2", bitmap1);
-        Assert.Equal(new string[] { "format1", "format2", "UnicodeText" }, dataObject.GetFormats(autoConvert: true).OrderBy(s => s));
-        Assert.Equal(new string[] { "format1", "format2", "UnicodeText" }, dataObject.GetFormats(autoConvert: false).OrderBy(s => s));
-
-        using var bitmap2 = new Bitmap(10, 10);
-        dataObject.SetData(bitmap2);
-        Assert.Equal(new string[] { "Bitmap", "format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject" }, dataObject.GetFormats(autoConvert: true).OrderBy(s => s));
-        Assert.Equal(new string[] { "format1", "format2", "System.Drawing.Bitmap", "UnicodeText", "WindowsForms10PersistentObject" }, dataObject.GetFormats(autoConvert: false).OrderBy(s => s));
-    }
-
-    public static IEnumerable<object[]> GetFormats_BoolIDataObject_TestData()
-    {
-        foreach (bool autoConvert in new bool[] { true, false })
-        {
-            yield return new object[] { autoConvert, null };
-            yield return new object[] { autoConvert, Array.Empty<string>() };
-            yield return new object[] { autoConvert, new string[] { "a", "  ", string.Empty, null } };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(GetFormats_BoolIDataObject_TestData))]
-    public void DataObject_GetFormats_InvokeBoolIDataObject_ReturnsExpected(bool autoConvert, string[] result)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(autoConvert))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        Assert.Same(result, dataObject.GetFormats(autoConvert));
-        mockDataObject.Verify(o => o.GetFormats(autoConvert), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_GetImage_InvokeDefault_ReturnsNull()
-    {
-        var dataObject = new DataObject();
-        Assert.Null(dataObject.GetImage());
-    }
-
-    public static IEnumerable<object[]> GetImage_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), null };
-
-        var image = new Bitmap(10, 10);
-        yield return new object[] { image, image };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetImage_TestData))]
-    public void DataObject_GetImage_InvokeWithData_ReturnsExpected(object result, Image expected)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.Bitmap, result);
-        Assert.Same(expected, dataObject.GetImage());
-    }
-
-    [Theory]
-    [MemberData(nameof(GetImage_TestData))]
-    public void DataObject_GetImage_InvokeMocked_ReturnsExpected(object result, Image expected)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetImage())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetData(DataFormats.Bitmap, true))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(expected, mockDataObject.Object.GetImage());
-        mockDataObject.Verify(o => o.GetData(DataFormats.Bitmap, true), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_GetText_InvokeDefault_ReturnsEmpty()
-    {
-        var dataObject = new DataObject();
-        Assert.Empty(dataObject.GetText());
-    }
-
-    public static IEnumerable<object[]> GetText_TestData()
-    {
-        yield return new object[] { null, string.Empty };
-        yield return new object[] { string.Empty, string.Empty };
-        yield return new object[] { "  ", "  " };
-        yield return new object[] { "a", "a" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetText_TestData))]
-    public void DataObject_GetText_InvokeWithData_ReturnsExpected(object result, string expected)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.UnicodeText, result);
-        Assert.Equal(expected, dataObject.GetText());
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void DataObject_GetText_InvokeMocked_ReturnsExpected(string result)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetText())
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetText(TextDataFormat.UnicodeText))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(result, mockDataObject.Object.GetText());
-        mockDataObject.Verify(o => o.GetText(TextDataFormat.UnicodeText), Times.Once());
-    }
-
-    [Theory]
-    [EnumData<TextDataFormat>]
-    public void DataObject_GetText_InvokeTextDataFormatDefault_ReturnsEmpty(TextDataFormat format)
-    {
-        var dataObject = new DataObject();
-        Assert.Empty(dataObject.GetText(format));
-    }
-
-    public static IEnumerable<object[]> GetText_TextDataFormat_TestData()
-    {
-        yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, null, string.Empty };
-        yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, new object(), string.Empty };
-        yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, string.Empty, string.Empty };
-        yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, "  ", "  " };
-        yield return new object[] { TextDataFormat.Text, DataFormats.UnicodeText, "a", "a" };
-
-        yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, null, string.Empty };
-        yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, new object(), string.Empty };
-        yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, string.Empty, string.Empty };
-        yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, "  ", "  " };
-        yield return new object[] { TextDataFormat.UnicodeText, DataFormats.UnicodeText, "a", "a" };
-
-        yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, null, string.Empty };
-        yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, new object(), string.Empty };
-        yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, string.Empty, string.Empty };
-        yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, "  ", "  " };
-        yield return new object[] { TextDataFormat.Rtf, DataFormats.Rtf, "a", "a" };
-
-        yield return new object[] { TextDataFormat.Html, DataFormats.Html, null, string.Empty };
-        yield return new object[] { TextDataFormat.Html, DataFormats.Html, new object(), string.Empty };
-        yield return new object[] { TextDataFormat.Html, DataFormats.Html, string.Empty, string.Empty };
-        yield return new object[] { TextDataFormat.Html, DataFormats.Html, "  ", "  " };
-        yield return new object[] { TextDataFormat.Html, DataFormats.Html, "a", "a" };
-
-        yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, null, string.Empty };
-        yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, new object(), string.Empty };
-        yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, string.Empty, string.Empty };
-        yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, "  ", "  " };
-        yield return new object[] { TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue, "a", "a" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetText_TextDataFormat_TestData))]
-    public void DataObject_GetText_InvokeTextDataFormatWithData_ReturnsExpected(TextDataFormat format, string expectedFormat, object result, string expected)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(expectedFormat, result);
-        Assert.Same(expected, dataObject.GetText(format));
-    }
-
-    [Theory]
-    [MemberData(nameof(GetText_TextDataFormat_TestData))]
-    public void DataObject_GetText_InvokeTextDataFormatMocked_ReturnsExpected(TextDataFormat format, string expectedFormat, object result, string expected)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetText(format))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.GetData(expectedFormat, false))
-            .Returns(result)
-            .Verifiable();
-        Assert.Same(expected, mockDataObject.Object.GetText(format));
-        mockDataObject.Verify(o => o.GetData(expectedFormat, false), Times.Once());
-    }
-
-    [Theory]
-    [InvalidEnumData<TextDataFormat>]
-    public void DataObject_GetText_InvokeInvalidFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<InvalidEnumArgumentException>("format", () => dataObject.GetText(format));
-    }
-
-    public static IEnumerable<object[]> SetAudio_ByteArray_TestData()
-    {
-        yield return new object[] { Array.Empty<byte>() };
-        yield return new object[] { new byte[] { 1, 2, 3 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_ByteArray_TestData))]
-    public void DataObject_SetAudio_InvokeByteArray_GetReturnsExpected(byte[] audioBytes)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetAudio(audioBytes);
-        Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(dataObject.GetAudioStream()).ToArray());
-        Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(dataObject.GetData(DataFormats.WaveAudio, autoConvert: true)).ToArray());
-        Assert.Equal(audioBytes, Assert.IsType<MemoryStream>(dataObject.GetData(DataFormats.WaveAudio, autoConvert: false)).ToArray());
-        Assert.True(dataObject.ContainsAudio());
-        Assert.True(dataObject.GetDataPresent(DataFormats.WaveAudio, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.WaveAudio, autoConvert: false));
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_ByteArray_TestData))]
-    public void DataObject_SetAudio_InvokeByteArrayMocked_CallsSetAudio(byte[] audioBytes)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetAudio(audioBytes))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetAudio(It.IsAny<MemoryStream>()))
-            .Verifiable();
-        mockDataObject.Object.SetAudio(audioBytes);
-        mockDataObject.Verify(o => o.SetAudio(It.IsAny<MemoryStream>()), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_ByteArray_TestData))]
-    public void DataObject_SetAudio_InvokeByteArrayIDataObject_CallsSetData(byte[] audioBytes)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.WaveAudio, false, It.IsAny<MemoryStream>()))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetAudio(audioBytes);
-        mockDataObject.Verify(o => o.SetData(DataFormats.WaveAudio, false, It.IsAny<MemoryStream>()), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetAudio_NullAudioBytes_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("audioBytes", () => dataObject.SetAudio((byte[])null));
-    }
-
-    public static IEnumerable<object[]> SetAudio_Stream_TestData()
-    {
-        yield return new object[] { new MemoryStream(Array.Empty<byte>()) };
-        yield return new object[] { new MemoryStream(new byte[] { 1, 2, 3 }) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_Stream_TestData))]
-    public void DataObject_SetAudio_InvokeStream_GetReturnsExpected(Stream audioStream)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetAudio(audioStream);
-        Assert.Same(audioStream, dataObject.GetAudioStream());
-        Assert.Same(audioStream, dataObject.GetData(DataFormats.WaveAudio, autoConvert: true));
-        Assert.Same(audioStream, dataObject.GetData(DataFormats.WaveAudio, autoConvert: false));
-        Assert.True(dataObject.ContainsAudio());
-        Assert.True(dataObject.GetDataPresent(DataFormats.WaveAudio, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.WaveAudio, autoConvert: false));
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_Stream_TestData))]
-    public void DataObject_SetAudio_InvokeStreamMocked_CallsSetAudio(Stream audioStream)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetAudio(audioStream))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.WaveAudio, false, audioStream))
-            .Verifiable();
-        mockDataObject.Object.SetAudio(audioStream);
-        mockDataObject.Verify(o => o.SetData(DataFormats.WaveAudio, false, audioStream), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetAudio_Stream_TestData))]
-    public void DataObject_SetAudio_InvokeStreamIDataObject_CallsSetData(Stream audioStream)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.WaveAudio, false, audioStream))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetAudio(audioStream);
-        mockDataObject.Verify(o => o.SetData(DataFormats.WaveAudio, false, audioStream), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetAudio_NullAudioStream_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("audioStream", () => dataObject.SetAudio((Stream)null));
-    }
-
-    public static IEnumerable<object[]> SetData_Object_TestData()
-    {
-        yield return new object[] { new object(), typeof(object).FullName };
-        yield return new object[] { new Bitmap(10, 10), typeof(Bitmap).FullName };
-        yield return new object[] { new Mock<ISerializable>(MockBehavior.Strict).Object, DataFormats.Serializable };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_Object_TestData))]
-    public void SetData_Object_GetDataReturnsExpected(object data, string expectedFormat)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(data);
-        Assert.Same(data, dataObject.GetData(expectedFormat, autoConvert: false));
-        Assert.Same(data, dataObject.GetData(expectedFormat, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(expectedFormat, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(expectedFormat, autoConvert: false));
-    }
-
-    [Fact]
-    public void DataObject_SetData_MultipleNonSerializable_GetDataReturnsExpected()
-    {
-        var data1 = new object();
-        var data2 = new object();
-
-        var dataObject = new DataObject();
-        dataObject.SetData(data1);
-        dataObject.SetData(data2);
-        Assert.Same(data2, dataObject.GetData(data1.GetType().FullName, autoConvert: false));
-        Assert.Same(data2, dataObject.GetData(data1.GetType().FullName, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(data1.GetType().FullName, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(data1.GetType().FullName, autoConvert: false));
-    }
-
-    [Fact]
-    public void DataObject_SetData_MultipleSerializable_GetDataReturnsExpected()
-    {
-        var data1 = new Mock<ISerializable>(MockBehavior.Strict).Object;
-        var data2 = new Mock<ISerializable>(MockBehavior.Strict).Object;
-
-        var dataObject = new DataObject();
-        dataObject.SetData(data1);
-        dataObject.SetData(data2);
-        Assert.Same(data1, dataObject.GetData(DataFormats.Serializable, autoConvert: false));
-        Assert.Same(data1, dataObject.GetData(DataFormats.Serializable, autoConvert: true));
-        Assert.Same(data2, dataObject.GetData(data2.GetType().FullName, autoConvert: false));
-        Assert.Same(data2, dataObject.GetData(data2.GetType().FullName, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.Serializable, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.Serializable, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent(data2.GetType().FullName, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(data2.GetType().FullName, autoConvert: false));
-    }
-
-    public static IEnumerable<object[]> SetData_ObjectIDataObject_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_ObjectIDataObject_TestData))]
-    public void DataObject_SetData_InvokeObjectIDataObject_CallsSetData(object data)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(data))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetData(data);
-        mockDataObject.Verify(o => o.SetData(data), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetData_NullData_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("data", () => dataObject.SetData(null));
-    }
-
-    public static IEnumerable<object[]> SetData_StringObject_TestData()
-    {
-        foreach (string format in s_clipboardFormats)
-        {
-            yield return new object[] { format, null, format == DataFormats.FileDrop, format == DataFormats.Bitmap };
-            yield return new object[] { format, "input", format == DataFormats.FileDrop, format == DataFormats.Bitmap };
-        }
-
-        yield return new object[] { typeof(Bitmap).FullName, null, false, true };
-        yield return new object[] { typeof(Bitmap).FullName, "input", false, true };
-
-        yield return new object[] { "FileName", null, true, false };
-        yield return new object[] { "FileName", "input", true, false };
-
-        yield return new object[] { "FileNameW", null, true, false };
-        yield return new object[] { "FileNameW", "input", true, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_StringObject_TestData))]
-    private void DataObject_SetData_InvokeStringObject_GetReturnsExpected(string format, object input, bool expectedContainsFileDropList, bool expectedContainsImage)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(format, input);
-        Assert.True(dataObject.GetDataPresent(format));
-        Assert.True(dataObject.GetDataPresent(format, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent(format, autoConvert: true));
-        Assert.Same(input, dataObject.GetData(format));
-        Assert.Same(input, dataObject.GetData(format, autoConvert: false));
-        Assert.Same(input, dataObject.GetData(format, autoConvert: true));
-        Assert.Equal(format == DataFormats.WaveAudio, dataObject.ContainsAudio());
-        Assert.Equal(expectedContainsFileDropList, dataObject.ContainsFileDropList());
-        Assert.Equal(expectedContainsImage, dataObject.ContainsImage());
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText());
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText(TextDataFormat.Text));
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText(TextDataFormat.UnicodeText));
-        Assert.Equal(format == DataFormats.Rtf, dataObject.ContainsText(TextDataFormat.Rtf));
-        Assert.Equal(format == DataFormats.Html, dataObject.ContainsText(TextDataFormat.Html));
-        Assert.Equal(format == DataFormats.CommaSeparatedValue, dataObject.ContainsText(TextDataFormat.CommaSeparatedValue));
-    }
-
-    [Fact]
-    public void DataObject_SetData_InvokeStringObjectDibBitmapAutoConvert_GetDataReturnsExpected()
-    {
-        var image = new Bitmap(10, 10);
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.Dib, true, image);
-        Assert.Same(image, dataObject.GetImage());
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: true));
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: false));
-        Assert.Same(image, dataObject.GetData(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.Null(dataObject.GetData(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: false));
-
-        Assert.True(dataObject.ContainsImage());
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: false));
-    }
-
-    public static IEnumerable<object[]> SetData_StringObjectIDataObject_TestData()
-    {
-        foreach (string format in new string[] { "format", "  ", string.Empty, null })
-        {
-            yield return new object[] { format, null };
-            yield return new object[] { format, new object() };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_StringObjectIDataObject_TestData))]
-    public void DataObject_SetData_InvokeStringObjectIDataObject_CallsSetData(string format, object data)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(format, data))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetData(format, data);
-        mockDataObject.Verify(o => o.SetData(format, data), Times.Once());
-    }
-
-    public static IEnumerable<object[]> SetData_StringBoolObject_TestData()
-    {
-        foreach (string format in s_clipboardFormats)
-        {
-            foreach (bool autoConvert in new bool[] { true, false })
-            {
-                yield return new object[] { format, autoConvert, null, format == DataFormats.FileDrop, format == DataFormats.Bitmap };
-                yield return new object[] { format, autoConvert, "input", format == DataFormats.FileDrop, format == DataFormats.Bitmap };
-            }
-        }
-
-        yield return new object[] { typeof(Bitmap).FullName, false, null, false, false };
-        yield return new object[] { typeof(Bitmap).FullName, false, "input", false, false };
-        yield return new object[] { typeof(Bitmap).FullName, true, null, false, true };
-        yield return new object[] { typeof(Bitmap).FullName, true, "input", false, true };
-
-        yield return new object[] { "FileName", false, null, false, false };
-        yield return new object[] { "FileName", false, "input", false, false };
-        yield return new object[] { "FileName", true, null, true, false };
-        yield return new object[] { "FileName", true, "input", true, false };
-
-        yield return new object[] { "FileNameW", false, null, false, false };
-        yield return new object[] { "FileNameW", false, "input", false, false };
-        yield return new object[] { "FileNameW", true, null, true, false };
-        yield return new object[] { "FileNameW", true, "input", true, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_StringBoolObject_TestData))]
-    private void DataObject_SetData_InvokeStringBoolObject_GetReturnsExpected(string format, bool autoConvert, object input, bool expectedContainsFileDropList, bool expectedContainsImage)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetData(format, autoConvert, input);
-        Assert.Same(input, dataObject.GetData(format, autoConvert: false));
-        Assert.Same(input, dataObject.GetData(format, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(format, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(format, autoConvert: false));
-        Assert.Equal(format == DataFormats.WaveAudio, dataObject.ContainsAudio());
-        Assert.Equal(expectedContainsFileDropList, dataObject.ContainsFileDropList());
-        Assert.Equal(expectedContainsImage, dataObject.ContainsImage());
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText());
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText(TextDataFormat.Text));
-        Assert.Equal(format == DataFormats.UnicodeText, dataObject.ContainsText(TextDataFormat.UnicodeText));
-        Assert.Equal(format == DataFormats.Rtf, dataObject.ContainsText(TextDataFormat.Rtf));
-        Assert.Equal(format == DataFormats.Html, dataObject.ContainsText(TextDataFormat.Html));
-        Assert.Equal(format == DataFormats.CommaSeparatedValue, dataObject.ContainsText(TextDataFormat.CommaSeparatedValue));
-    }
-
-    [Fact]
-    public void DataObject_SetData_InvokeStringBoolObjectDibBitmapAutoConvert_GetDataReturnsExpected()
-    {
-        var image = new Bitmap(10, 10);
-        var dataObject = new DataObject();
-        dataObject.SetData(DataFormats.Dib, true, image);
-        Assert.Same(image, dataObject.GetImage());
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: true));
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: false));
-        Assert.Same(image, dataObject.GetData(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.Null(dataObject.GetData(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: false));
-
-        Assert.True(dataObject.ContainsImage());
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: false));
-    }
-
-    public static IEnumerable<object[]> SetData_StringBoolObjectIDataObject_TestData()
-    {
-        foreach (string format in new string[] { "format", "  ", string.Empty, null })
-        {
-            foreach (bool autoConvert in new bool[] { true, false })
-            {
-                yield return new object[] { format, autoConvert, null };
-                yield return new object[] { format, autoConvert, new object() };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_StringBoolObjectIDataObject_TestData))]
-    public void DataObject_SetData_InvokeStringBoolObjectIDataObject_CallsSetData(string format, bool autoConvert, object data)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(format, autoConvert, data))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetData(format, autoConvert, data);
-        mockDataObject.Verify(o => o.SetData(format, autoConvert, data), Times.Once());
-    }
-
-    public static IEnumerable<object[]> SetData_TypeObjectIDataObject_TestData()
-    {
-        foreach (Type format in new Type[] { typeof(int), null })
-        {
-            yield return new object[] { format, null };
-            yield return new object[] { format, new object() };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SetData_TypeObjectIDataObject_TestData))]
-    public void DataObject_SetData_InvokeTypeObjectIDataObject_CallsSetData(Type format, object data)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(format, data))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetData(format, data);
-        mockDataObject.Verify(o => o.SetData(format, data), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetData_NullFormat_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("format", () => dataObject.SetData((string)null, new object()));
-        Assert.Throws<ArgumentNullException>("format", () => dataObject.SetData(null, true, new object()));
-        Assert.Throws<ArgumentNullException>("format", () => dataObject.SetData(null, false, new object()));
-        Assert.Throws<ArgumentNullException>("format", () => dataObject.SetData((Type)null, new object()));
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("  ")]
-    public void DataObject_SetData_WhitespaceOrEmptyFormat_ThrowsArgumentException(string format)
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentException>("format", () => dataObject.SetData(format, new object()));
-        Assert.Throws<ArgumentException>("format", () => dataObject.SetData(format, true, new object()));
-        Assert.Throws<ArgumentException>("format", () => dataObject.SetData(format, false, new object()));
-    }
-
-    [Fact]
-    public void DataObject_SetData_DibBitmapNoAutoConvert_ThrowsNotSupportedException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<NotSupportedException>(() => dataObject.SetData(DataFormats.Dib, false, new Bitmap(10, 10)));
-    }
-
-    public static IEnumerable<object[]> SetFileDropList_TestData()
-    {
-        yield return new object[] { new StringCollection() };
-        yield return new object[] { new StringCollection { "file", "  ", string.Empty, null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetFileDropList_TestData))]
-    public void DataObject_SetFileDropList_Invoke_GetReturnsExpected(StringCollection filePaths)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetFileDropList(filePaths);
-        Assert.Equal(filePaths, dataObject.GetFileDropList());
-        Assert.Equal(filePaths.Cast<string>(), dataObject.GetData(DataFormats.FileDrop, autoConvert: true));
-        Assert.Equal(filePaths.Cast<string>(), dataObject.GetData(DataFormats.FileDrop, autoConvert: false));
-        Assert.Equal(filePaths.Cast<string>(), dataObject.GetData("FileName", autoConvert: true));
-        Assert.Null(dataObject.GetData("FileName", autoConvert: false));
-        Assert.Equal(filePaths.Cast<string>(), dataObject.GetData("FileNameW", autoConvert: true));
-        Assert.Null(dataObject.GetData("FileNameW", autoConvert: false));
-
-        Assert.True(dataObject.ContainsFileDropList());
-        Assert.True(dataObject.GetDataPresent(DataFormats.FileDrop, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.FileDrop, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent("FileName", autoConvert: true));
-        Assert.False(dataObject.GetDataPresent("FileName", autoConvert: false));
-        Assert.True(dataObject.GetDataPresent("FileNameW", autoConvert: true));
-        Assert.False(dataObject.GetDataPresent("FileNameW", autoConvert: false));
-    }
-
-    [Theory]
-    [MemberData(nameof(SetFileDropList_TestData))]
-    public void DataObject_SetFileDropList_InvokeMocked_CallsSetFileDropList(StringCollection filePaths)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetFileDropList(filePaths))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.FileDrop, true, It.IsAny<string[]>()))
-            .Verifiable();
-        mockDataObject.Object.SetFileDropList(filePaths);
-        mockDataObject.Verify(o => o.SetData(DataFormats.FileDrop, true, It.IsAny<string[]>()), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetFileDropList_TestData))]
-    public void DataObject_SetFileDropList_InvokeIDataObject_CallsSetData(StringCollection filePaths)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.FileDrop, true, It.IsAny<string[]>()))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetFileDropList(filePaths);
-        mockDataObject.Verify(o => o.SetData(DataFormats.FileDrop, true, It.IsAny<string[]>()), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetFileDropList_NullFilePaths_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("filePaths", () => dataObject.SetFileDropList(null));
-    }
-
-    public static IEnumerable<object[]> SetImage_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10) };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetImage_TestData))]
-    public void DataObject_SetImage_Invoke_GetReturnsExpected(Image image)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetImage(image);
-        Assert.Same(image, dataObject.GetImage());
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: true));
-        Assert.Same(image, dataObject.GetData(DataFormats.Bitmap, autoConvert: false));
-        Assert.Same(image, dataObject.GetData(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.Null(dataObject.GetData(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Dib, autoConvert: false));
-
-        Assert.True(dataObject.ContainsImage());
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.Bitmap, autoConvert: false));
-        Assert.True(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(typeof(Bitmap).FullName, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Dib, autoConvert: false));
-    }
-
-    [Theory]
-    [MemberData(nameof(SetImage_TestData))]
-    public void DataObject_SetImage_InvokeMocked_CallsSetImage(Image image)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetImage(image))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.Bitmap, true, image))
-            .Verifiable();
-        mockDataObject.Object.SetImage(image);
-        mockDataObject.Verify(o => o.SetData(DataFormats.Bitmap, true, image), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetImage_TestData))]
-    public void DataObject_SetImage_InvokeIDataObject_CallsSetData(Image image)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.Bitmap, true, image))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetImage(image);
-        mockDataObject.Verify(o => o.SetData(DataFormats.Bitmap, true, image), Times.Once());
-    }
-
-    [Fact]
-    public void DataObject_SetImage_NullImage_ThrowsArgumentNullException()
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("image", () => dataObject.SetImage(null));
-    }
-
-    public static IEnumerable<object[]> SetText_String_TestData()
-    {
-        yield return new object[] { "  " };
-        yield return new object[] { "textData" };
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_String_TestData))]
-    public void DataObject_SetText_InvokeString_GetReturnsExpected(string textData)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText(textData);
-        Assert.Same(textData, dataObject.GetText());
-        Assert.Same(textData, dataObject.GetData(DataFormats.UnicodeText, autoConvert: true));
-        Assert.Same(textData, dataObject.GetData(DataFormats.UnicodeText, autoConvert: false));
-        Assert.Same(textData, dataObject.GetData(DataFormats.Text, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Text, autoConvert: false));
-        Assert.Same(textData, dataObject.GetData(DataFormats.StringFormat, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.StringFormat, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.Rtf, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Rtf, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.Html, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Html, autoConvert: false));
-        Assert.Null(dataObject.GetData(DataFormats.CommaSeparatedValue, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.CommaSeparatedValue, autoConvert: false));
-
-        Assert.True(dataObject.ContainsText());
-        Assert.True(dataObject.GetDataPresent(DataFormats.UnicodeText, autoConvert: true));
-        Assert.True(dataObject.GetDataPresent(DataFormats.UnicodeText, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Text, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Text, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.StringFormat, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.StringFormat, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Rtf, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Rtf, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Html, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Html, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.CommaSeparatedValue, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.CommaSeparatedValue, autoConvert: false));
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_String_TestData))]
-    public void DataObject_SetText_InvokeStringMocked_CallsSetText(string textData)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetText(textData))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetText(textData, TextDataFormat.UnicodeText))
-            .Verifiable();
-        mockDataObject.Object.SetText(textData);
-        mockDataObject.Verify(o => o.SetText(textData, TextDataFormat.UnicodeText), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_String_TestData))]
-    public void DataObject_SetText_InvokeStringIDataObject_CallsSetData(string textData)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(DataFormats.UnicodeText, false, textData))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetText(textData);
-        mockDataObject.Verify(o => o.SetData(DataFormats.UnicodeText, false, textData), Times.Once());
-    }
-
-    public static IEnumerable<object[]> SetText_StringTextDataFormat_TestData()
-    {
-        foreach (string textData in new string[] { "textData", "  " })
-        {
-            yield return new object[] { textData, TextDataFormat.Text, textData, null, null, null };
-            yield return new object[] { textData, TextDataFormat.UnicodeText, textData, null, null, null };
-            yield return new object[] { textData, TextDataFormat.Rtf, null, textData, null, null };
-            yield return new object[] { textData, TextDataFormat.Html, null, null, textData, null };
-            yield return new object[] { textData, TextDataFormat.CommaSeparatedValue, null, null, null, textData };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_StringTextDataFormat_TestData))]
-    public void DataObject_SetText_InvokeStringTextDataFormat_GetReturnsExpected(string textData, TextDataFormat format, string expectedUnicodeText, string expectedRtfText, string expectedHtmlText, string expectedCsvText)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText(textData, format);
-        Assert.Equal(textData, dataObject.GetText(format));
-        Assert.Equal(expectedUnicodeText, dataObject.GetData(DataFormats.UnicodeText, autoConvert: true));
-        Assert.Equal(expectedUnicodeText, dataObject.GetData(DataFormats.UnicodeText, autoConvert: false));
-        Assert.Equal(expectedUnicodeText, dataObject.GetData(DataFormats.Text, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.Text, autoConvert: false));
-        Assert.Equal(expectedUnicodeText, dataObject.GetData(DataFormats.StringFormat, autoConvert: true));
-        Assert.Null(dataObject.GetData(DataFormats.StringFormat, autoConvert: false));
-        Assert.Equal(expectedRtfText, dataObject.GetData(DataFormats.Rtf, autoConvert: true));
-        Assert.Equal(expectedRtfText, dataObject.GetData(DataFormats.Rtf, autoConvert: false));
-        Assert.Equal(expectedHtmlText, dataObject.GetData(DataFormats.Html, autoConvert: true));
-        Assert.Equal(expectedHtmlText, dataObject.GetData(DataFormats.Html, autoConvert: false));
-        Assert.Equal(expectedCsvText, dataObject.GetData(DataFormats.CommaSeparatedValue, autoConvert: true));
-        Assert.Equal(expectedCsvText, dataObject.GetData(DataFormats.CommaSeparatedValue, autoConvert: false));
-
-        Assert.True(dataObject.ContainsText(format));
-        Assert.Equal(expectedUnicodeText is not null, dataObject.GetDataPresent(DataFormats.UnicodeText, autoConvert: true));
-        Assert.Equal(expectedUnicodeText is not null, dataObject.GetDataPresent(DataFormats.UnicodeText, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Text, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.Text, autoConvert: false));
-        Assert.False(dataObject.GetDataPresent(DataFormats.StringFormat, autoConvert: true));
-        Assert.False(dataObject.GetDataPresent(DataFormats.StringFormat, autoConvert: false));
-        Assert.Equal(expectedRtfText is not null, dataObject.GetDataPresent(DataFormats.Rtf, autoConvert: true));
-        Assert.Equal(expectedRtfText is not null, dataObject.GetDataPresent(DataFormats.Rtf, autoConvert: false));
-        Assert.Equal(expectedHtmlText is not null, dataObject.GetDataPresent(DataFormats.Html, autoConvert: true));
-        Assert.Equal(expectedHtmlText is not null, dataObject.GetDataPresent(DataFormats.Html, autoConvert: false));
-        Assert.Equal(expectedCsvText is not null, dataObject.GetDataPresent(DataFormats.CommaSeparatedValue, autoConvert: true));
-        Assert.Equal(expectedCsvText is not null, dataObject.GetDataPresent(DataFormats.CommaSeparatedValue, autoConvert: false));
-    }
-
-    public static IEnumerable<object[]> SetText_StringTextDataFormatMocked_TestData()
-    {
-        foreach (string textData in new string[] { "textData", "  " })
-        {
-            yield return new object[] { textData, TextDataFormat.Text, DataFormats.UnicodeText };
-            yield return new object[] { textData, TextDataFormat.UnicodeText, DataFormats.UnicodeText };
-            yield return new object[] { textData, TextDataFormat.Rtf, DataFormats.Rtf };
-            yield return new object[] { textData, TextDataFormat.Html, DataFormats.Html };
-            yield return new object[] { textData, TextDataFormat.CommaSeparatedValue, DataFormats.CommaSeparatedValue };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_StringTextDataFormatMocked_TestData))]
-    public void DataObject_SetText_InvokeStringTextDataFormatMocked_CallsSetText(string textData, TextDataFormat format, string expectedFormat)
-    {
-        var mockDataObject = new Mock<DataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetText(textData, format))
-            .CallBase();
-        mockDataObject
-            .Setup(o => o.SetData(expectedFormat, false, textData))
-            .Verifiable();
-        mockDataObject.Object.SetText(textData, format);
-        mockDataObject.Verify(o => o.SetData(expectedFormat, false, textData), Times.Once());
-    }
-
-    [Theory]
-    [MemberData(nameof(SetText_StringTextDataFormatMocked_TestData))]
-    public void DataObject_SetText_InvokeStringTextDataFormatIDataObject_CallsSetData(string textData, TextDataFormat format, string expectedFormat)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.SetData(expectedFormat, false, textData))
-            .Verifiable();
-        var dataObject = new DataObject((object)mockDataObject.Object);
-        dataObject.SetText(textData, format);
-        mockDataObject.Verify(o => o.SetData(expectedFormat, false, textData), Times.Once());
-    }
-
-    [Theory]
-    [NullAndEmptyStringData]
-    public void DataObject_SetText_NullOrEmptyTextData_ThrowsArgumentNullException(string textData)
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<ArgumentNullException>("textData", () => dataObject.SetText(textData));
-        Assert.Throws<ArgumentNullException>("textData", () => dataObject.SetText(textData, TextDataFormat.Text));
-    }
-
-    [Theory]
-    [InvalidEnumData<TextDataFormat>]
-    public void DataObject_SetText_InvalidFormat_ThrowsInvalidEnumArgumentException(TextDataFormat format)
-    {
-        var dataObject = new DataObject();
-        Assert.Throws<InvalidEnumArgumentException>("format", () => dataObject.SetText("text", format));
-    }
-
-    [WinFormsFact]
-    public void DataObject_GetData_EnhancedMetafile_DoesNotTerminateProcess()
-    {
-        var data = new DataObject(new DataObjectIgnoringStorageMediumForEnhancedMetafile());
-
-        // Office ignores the storage medium in GetData(EnhancedMetafile) and always returns a handle,
-        // even when asked for a stream. This used to crash the process when DataObject interpreted the
-        // handle as a pointer to a COM IStream without checking the storage medium it retrieved.
-
-        Assert.Null(data.GetData(DataFormats.EnhancedMetafile));
-    }
-
-    private sealed class DataObjectIgnoringStorageMediumForEnhancedMetafile : System.Runtime.InteropServices.ComTypes.IDataObject
-    {
-        public void GetData(ref FORMATETC format, out STGMEDIUM medium)
-        {
-            Marshal.ThrowExceptionForHR(QueryGetData(ref format));
-
-            using var metafile = new Drawing.Imaging.Metafile("bitmaps/milkmateya01.emf");
-
-            medium = default;
-            medium.tymed = TYMED.TYMED_ENHMF;
-            medium.unionmember = metafile.GetHenhmetafile();
-        }
-
-        public int QueryGetData(ref FORMATETC format)
-        {
-            // do not check the requested storage medium, we always return a metafile handle, thats what Office does
-
-            if (format.cfFormat != (short)CLIPBOARD_FORMAT.CF_ENHMETAFILE || format.dwAspect != DVASPECT.DVASPECT_CONTENT || format.lindex != -1)
-                return (int)HRESULT.DV_E_FORMATETC;
-
-            return 0;
-        }
-
-        public IEnumFORMATETC EnumFormatEtc(DATADIR direction) => throw new NotImplementedException();
-        public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) => throw new NotImplementedException();
-        public int GetCanonicalFormatEtc(ref FORMATETC formatIn, out FORMATETC formatOut) => throw new NotImplementedException();
-        public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release) => throw new NotImplementedException();
-        public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection) => throw new NotImplementedException();
-        public void DUnadvise(int connection) => throw new NotImplementedException();
-        public int EnumDAdvise(out IEnumSTATDATA enumAdvise) => throw new NotImplementedException();
-    }
-
-    public static IEnumerable<object[]> DAdvise_TestData()
-    {
-        yield return new object[] { ADVF.ADVF_DATAONSTOP, null };
-
-        var mockAdviseSink = new Mock<IAdviseSink>(MockBehavior.Strict);
-        yield return new object[] { ADVF.ADVF_DATAONSTOP, mockAdviseSink.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DAdvise_TestData))]
-    public void DataObject_DAdvise_InvokeDefault_Success(ADVF advf, IAdviseSink adviseSink)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        var formatetc = new FORMATETC();
-        Assert.Equal(HRESULT.E_NOTIMPL, (HRESULT)comDataObject.DAdvise(ref formatetc, advf, adviseSink, out int connection));
-        Assert.Equal(0, connection);
-    }
-
-    private delegate void DAdviseCallback(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection);
-
-    [WinFormsTheory]
-    [MemberData(nameof(DAdvise_TestData))]
-    public void DataObject_DAdvise_InvokeCustomComDataObject_Success(ADVF advf, IAdviseSink adviseSink)
-    {
-        var mockComDataObject = new Mock<IComDataObject>(MockBehavior.Strict);
-        mockComDataObject
-            .Setup(o => o.DAdvise(ref It.Ref<FORMATETC>.IsAny, advf, adviseSink, out It.Ref<int>.IsAny))
-            .Callback((DAdviseCallback)((ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection) =>
-            {
-                pFormatetc.cfFormat = 3;
-                connection = 2;
-            }))
-            .Returns(1);
-        var dataObject = new DataObject(mockComDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        var formatetc = new FORMATETC();
-        Assert.Equal(1, comDataObject.DAdvise(ref formatetc, advf, adviseSink, out int connection));
-        Assert.Equal(2, connection);
-        Assert.Equal(3, formatetc.cfFormat);
-        mockComDataObject.Verify(o => o.DAdvise(ref It.Ref<FORMATETC>.IsAny, advf, adviseSink, out It.Ref<int>.IsAny), Times.Once());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataObject_DUnadvise_InvokeDefault_Success(int connection)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        Assert.Throws<NotImplementedException>(() => comDataObject.DUnadvise(connection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void DataObject_DUnadvise_InvokeCustomComDataObject_Success(int connection)
-    {
-        var mockComDataObject = new Mock<IComDataObject>(MockBehavior.Strict);
-        mockComDataObject
-            .Setup(o => o.DUnadvise(connection))
-            .Verifiable();
-        var dataObject = new DataObject(mockComDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        comDataObject.DUnadvise(connection);
-        mockComDataObject.Verify(o => o.DUnadvise(connection), Times.Once());
-    }
-
-    [WinFormsFact]
-    public void DataObject_EnumDAdvise_InvokeDefault_Success()
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        Assert.Equal(HRESULT.OLE_E_ADVISENOTSUPPORTED, (HRESULT)comDataObject.EnumDAdvise(out IEnumSTATDATA enumAdvise));
-        Assert.Null(enumAdvise);
-    }
-
-    private delegate void EnumDAdviseCallback(out IEnumSTATDATA enumAdvise);
-
-    public static IEnumerable<object[]> EnumDAdvise_CustomComDataObject_TestData()
-    {
-        yield return new object[] { null };
-
-        var mockEnumStatData = new Mock<IEnumSTATDATA>(MockBehavior.Strict);
-        yield return new object[] { mockEnumStatData.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumDAdvise_CustomComDataObject_TestData))]
-    public void DataObject_EnumDAdvise_InvokeCustomComDataObject_Success(IEnumSTATDATA result)
-    {
-        var mockComDataObject = new Mock<IComDataObject>(MockBehavior.Strict);
-        mockComDataObject
-            .Setup(o => o.EnumDAdvise(out It.Ref<IEnumSTATDATA>.IsAny))
-            .Callback((EnumDAdviseCallback)((out IEnumSTATDATA enumAdvise) =>
-            {
-                enumAdvise = result;
-            }))
-            .Returns(1);
-        var dataObject = new DataObject(mockComDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        Assert.Equal(1, comDataObject.EnumDAdvise(out IEnumSTATDATA enumStatData));
-        Assert.Same(result, enumStatData);
-        mockComDataObject.Verify(o => o.EnumDAdvise(out It.Ref<IEnumSTATDATA>.IsAny), Times.Once());
-    }
-
-    public static IEnumerable<object[]> EnumFormatEtc_Default_TestData()
-    {
-        yield return new object[] { -1 };
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_Default_TestData))]
-    public void DataObject_EnumFormatEtc_InvokeDefault_Success(int celt)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC enumerator = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, result, fetched));
-            Assert.Equal(0, result[0].cfFormat);
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, null, null));
-
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    public static IEnumerable<object[]> EnumFormatEtc_TestData()
-    {
-        yield return new object[] { DataFormats.Bitmap, TYMED.TYMED_GDI };
-        yield return new object[] { DataFormats.CommaSeparatedValue, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Dib, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Dif, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.EnhancedMetafile, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.FileDrop, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { "FileName", TYMED.TYMED_HGLOBAL };
-        yield return new object[] { "FileNameW", TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Html, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Locale, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.MetafilePict, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.OemText, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Palette, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.PenData, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Riff, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Rtf, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Serializable, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.StringFormat, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.SymbolicLink, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Text, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.Tiff, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.UnicodeText, TYMED.TYMED_HGLOBAL };
-        yield return new object[] { DataFormats.WaveAudio, TYMED.TYMED_HGLOBAL };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_TestData))]
-    public void DataObject_EnumFormatEtc_InvokeWithValues_Success(string format1, TYMED expectedTymed)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns(new string[] { format1, "Format2" });
-        var dataObject = new DataObject(mockDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC enumerator = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[2];
-        var fetched = new int[2];
-
-        for (int i = 0; i < 1; i++)
-        {
-            // Fetch nothing.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(0, result, fetched));
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(0, null, null));
-
-            // Fetch negative.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(-1, result, fetched));
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(-1, null, null));
-
-            // Null.
-            Assert.Throws<NullReferenceException>(() => enumerator.Next(1, null, fetched));
-
-            // Fetch first.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(i + 1, result, fetched));
-            Assert.Equal(unchecked((short)(ushort)(DataFormats.GetFormat(format1).Id)), result[0].cfFormat);
-            Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-            Assert.Equal(-1, result[0].lindex);
-            Assert.Equal(IntPtr.Zero, result[0].ptd);
-            Assert.Equal(expectedTymed, result[0].tymed);
-            Assert.Equal(0, result[1].cfFormat);
-            Assert.Equal(1, fetched[0]);
-
-            // Fetch second.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(i + 1, result, fetched));
-            Assert.NotEqual(0, result[0].cfFormat);
-            Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-            Assert.Equal(-1, result[0].lindex);
-            Assert.Equal(IntPtr.Zero, result[0].ptd);
-            Assert.Equal(TYMED.TYMED_HGLOBAL, result[0].tymed);
-            Assert.Equal(0, result[1].cfFormat);
-            Assert.Equal(1, fetched[0]);
-
-            // Fetch another.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(1, null, null));
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(1, null, null));
-
-            // Reset.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_Default_TestData))]
-    public void DataObject_EnumFormatEtc_InvokeNullFormats_Success(int celt)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns((string[])null);
-        var dataObject = new DataObject(mockDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC enumerator = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, result, fetched));
-            Assert.Equal(0, result[0].cfFormat);
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, null, null));
-
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DataObject_EnumFormatEtc_SkipDefault_Success(int celt)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC enumerator = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-        Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Skip(celt));
-        Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(1, result, fetched));
-
-        // Negative.
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Skip(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => enumerator.Next(1, result, fetched));
-    }
-
-    [WinFormsFact]
-    public void DataObject_EnumFormatEtc_SkipCustom_Success()
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns(new string[] { "Format1", DataFormats.Bitmap, "Format2" });
-        var dataObject = new DataObject(mockDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC enumerator = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Skip(1));
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(1, result, fetched));
-        Assert.Equal(2, result[0].cfFormat);
-        Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-        Assert.Equal(-1, result[0].lindex);
-        Assert.Equal(IntPtr.Zero, result[0].ptd);
-        Assert.Equal(TYMED.TYMED_GDI, result[0].tymed);
-        Assert.Equal(1, fetched[0]);
-
-        // Skip negative.
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Skip(-2));
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(1, result, fetched));
-        Assert.Equal(unchecked((short)(ushort)(DataFormats.GetFormat("Format1").Id)), result[0].cfFormat);
-        Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-        Assert.Equal(-1, result[0].lindex);
-        Assert.Equal(IntPtr.Zero, result[0].ptd);
-        Assert.Equal(TYMED.TYMED_HGLOBAL, result[0].tymed);
-        Assert.Equal(1, fetched[0]);
-
-        // Skip end.
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Skip(1));
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(1, result, fetched));
-        Assert.Equal(unchecked((short)(ushort)(DataFormats.GetFormat("Format2").Id)), result[0].cfFormat);
-        Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-        Assert.Equal(-1, result[0].lindex);
-        Assert.Equal(IntPtr.Zero, result[0].ptd);
-        Assert.Equal(TYMED.TYMED_HGLOBAL, result[0].tymed);
-        Assert.Equal(1, fetched[0]);
-
-        Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Skip(0));
-        Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Skip(1));
-
-        // Negative.
-        Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Skip(-4));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => enumerator.Next(1, result, fetched));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_Default_TestData))]
-    public void DataObject_EnumFormatEtc_CloneDefault_Success(int celt)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC source = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        source.Clone(out IEnumFORMATETC enumerator);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, result, fetched));
-            Assert.Equal(0, result[0].cfFormat);
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, null, null));
-
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_TestData))]
-    public void DataObject_EnumFormatEtc_CloneWithValues_Success(string format1, TYMED expectedTymed)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns(new string[] { format1, "Format2" });
-        var dataObject = new DataObject(mockDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC source = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        source.Clone(out IEnumFORMATETC enumerator);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[2];
-        var fetched = new int[2];
-
-        for (int i = 0; i < 1; i++)
-        {
-            // Fetch nothing.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(0, result, fetched));
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(0, null, null));
-
-            // Fetch negative.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(-1, result, fetched));
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(-1, null, null));
-
-            // Null.
-            Assert.Throws<NullReferenceException>(() => enumerator.Next(1, null, fetched));
-
-            // Fetch first.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(i + 1, result, fetched));
-            Assert.Equal(unchecked((short)(ushort)(DataFormats.GetFormat(format1).Id)), result[0].cfFormat);
-            Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-            Assert.Equal(-1, result[0].lindex);
-            Assert.Equal(IntPtr.Zero, result[0].ptd);
-            Assert.Equal(expectedTymed, result[0].tymed);
-            Assert.Equal(0, result[1].cfFormat);
-            Assert.Equal(1, fetched[0]);
-
-            // Fetch second.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Next(i + 1, result, fetched));
-            Assert.NotEqual(0, result[0].cfFormat);
-            Assert.Equal(DVASPECT.DVASPECT_CONTENT, result[0].dwAspect);
-            Assert.Equal(-1, result[0].lindex);
-            Assert.Equal(IntPtr.Zero, result[0].ptd);
-            Assert.Equal(TYMED.TYMED_HGLOBAL, result[0].tymed);
-            Assert.Equal(0, result[1].cfFormat);
-            Assert.Equal(1, fetched[0]);
-
-            // Fetch another.
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(1, null, null));
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(1, null, null));
-
-            // Reset.
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_Default_TestData))]
-    public void DataObject_EnumFormatEtc_CloneNullFormats_Success(int celt)
-    {
-        var mockDataObject = new Mock<IDataObject>(MockBehavior.Strict);
-        mockDataObject
-            .Setup(o => o.GetFormats(true))
-            .Returns((string[])null);
-        var dataObject = new DataObject(mockDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        IEnumFORMATETC source = comDataObject.EnumFormatEtc(DATADIR.DATADIR_GET);
-        source.Clone(out IEnumFORMATETC enumerator);
-        Assert.NotNull(enumerator);
-
-        var result = new FORMATETC[1];
-        var fetched = new int[1];
-
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, result, fetched));
-            Assert.Equal(0, result[0].cfFormat);
-            Assert.Equal(0, fetched[0]);
-
-            Assert.Equal(HRESULT.S_FALSE, (HRESULT)enumerator.Next(celt, null, null));
-
-            Assert.Equal(HRESULT.S_OK, (HRESULT)enumerator.Reset());
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DATADIR.DATADIR_SET)]
-    [InlineData(DATADIR.DATADIR_GET - 1)]
-    [InlineData(DATADIR.DATADIR_SET + 1)]
-    public void DataObject_EnumFormatEtc_InvokeNotGet_ThrowsExternalException(DATADIR dwDirection)
-    {
-        var dataObject = new DataObject();
-        IComDataObject comDataObject = dataObject;
-        Assert.Throws<ExternalException>(() => comDataObject.EnumFormatEtc(dwDirection));
-    }
-
-    public static IEnumerable<object[]> EnumFormatEtc_CustomComDataObject_TestData()
-    {
-        yield return new object[] { DATADIR.DATADIR_GET, null };
-        yield return new object[] { DATADIR.DATADIR_SET, null };
-        yield return new object[] { DATADIR.DATADIR_GET - 1, null };
-        yield return new object[] { DATADIR.DATADIR_SET + 1, null };
-
-        var mockEnumFormatEtc = new Mock<IEnumFORMATETC>(MockBehavior.Strict);
-        yield return new object[] { DATADIR.DATADIR_GET, mockEnumFormatEtc.Object };
-        yield return new object[] { DATADIR.DATADIR_SET, mockEnumFormatEtc.Object };
-        yield return new object[] { DATADIR.DATADIR_GET - 1, mockEnumFormatEtc.Object };
-        yield return new object[] { DATADIR.DATADIR_SET + 1, mockEnumFormatEtc.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(EnumFormatEtc_CustomComDataObject_TestData))]
-    public void DataObject_EnumFormatEtc_InvokeCustomComDataObject_Success(DATADIR dwDirection, IEnumFORMATETC result)
-    {
-        var mockComDataObject = new Mock<IComDataObject>(MockBehavior.Strict);
-        mockComDataObject
-            .Setup(o => o.EnumFormatEtc(dwDirection))
-            .Returns(result)
-            .Verifiable();
-        var dataObject = new DataObject(mockComDataObject.Object);
-        IComDataObject comDataObject = dataObject;
-        Assert.Same(result, comDataObject.EnumFormatEtc(dwDirection));
-        mockComDataObject.Verify(o => o.EnumFormatEtc(dwDirection), Times.Once());
-    }
-
-    public static IEnumerable<object[]> GetDataHere_Text_TestData()
-    {
-        yield return new object[] { TextDataFormat.Rtf, (short)DataFormats.GetFormat(DataFormats.Rtf).Id };
-        yield return new object[] { TextDataFormat.Html, (short)DataFormats.GetFormat(DataFormats.Html).Id };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDataHere_Text_TestData))]
-    public unsafe void IComDataObjectGetDataHere_Text_Success(TextDataFormat textDataFormat, short cfFormat)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText("text", textDataFormat);
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = cfFormat
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        HGLOBAL handle = PInvoke.GlobalAlloc(
-            GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT,
-            1);
-
-        try
-        {
-            stgMedium.unionmember = handle;
-            iComDataObject.GetDataHere(ref formatetc, ref stgMedium);
-
-            sbyte* pChar = *(sbyte**)stgMedium.unionmember;
-            Assert.Equal("text", new string(pChar));
-        }
-        finally
-        {
-            PInvoke.GlobalFree(handle);
-        }
-    }
-
-    public static IEnumerable<object[]> GetDataHere_UnicodeText_TestData()
-    {
-        yield return new object[] { TextDataFormat.Text, (short)CLIPBOARD_FORMAT.CF_UNICODETEXT };
-        yield return new object[] { TextDataFormat.UnicodeText, (short)CLIPBOARD_FORMAT.CF_UNICODETEXT };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDataHere_UnicodeText_TestData))]
-    public unsafe void IComDataObjectGetDataHere_UnicodeText_Success(TextDataFormat textDataFormat, short cfFormat)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText("text", textDataFormat);
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = cfFormat
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        HGLOBAL handle = PInvoke.GlobalAlloc(
-            GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT,
-            1);
-
-        try
-        {
-            stgMedium.unionmember = handle;
-            iComDataObject.GetDataHere(ref formatetc, ref stgMedium);
-
-            char* pChar = *(char**)stgMedium.unionmember;
-            Assert.Equal("text", new string(pChar));
-        }
-        finally
-        {
-            PInvoke.GlobalFree(handle);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDataHere_Text_TestData))]
-    public unsafe void IComDataObjectGetDataHere_TextNoData_ThrowsArgumentException(TextDataFormat textDataFormat, short cfFormat)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText("text", textDataFormat);
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = cfFormat
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        Assert.Throws<ArgumentException>(() => iComDataObject.GetDataHere(ref formatetc, ref stgMedium));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDataHere_UnicodeText_TestData))]
-    public unsafe void IComDataObjectGetDataHere_UnicodeTextNoData_ThrowsArgumentException(TextDataFormat textDataFormat, short cfFormat)
-    {
-        var dataObject = new DataObject();
-        dataObject.SetText("text", textDataFormat);
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = cfFormat
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        Assert.Throws<ArgumentException>(() => iComDataObject.GetDataHere(ref formatetc, ref stgMedium));
-    }
-
-    [WinFormsFact]
-    public unsafe void IComDataObjectGetDataHere_FileNames_Success()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetFileDropList(new StringCollection { "Path1", "Path2" });
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = (short)CLIPBOARD_FORMAT.CF_HDROP
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        HGLOBAL handle = PInvoke.GlobalAlloc(
-            GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT,
-            1);
-
-        try
-        {
-            stgMedium.unionmember = handle;
-            iComDataObject.GetDataHere(ref formatetc, ref stgMedium);
-
-            DROPFILES* pDropFiles = *(DROPFILES**)stgMedium.unionmember;
-            Assert.Equal(20u, pDropFiles->pFiles);
-            Assert.Equal(Point.Empty, pDropFiles->pt);
-            Assert.False(pDropFiles->fNC);
-            Assert.True(pDropFiles->fWide);
-            char* text = (char*)IntPtr.Add((IntPtr)pDropFiles, (int)pDropFiles->pFiles);
-            Assert.Equal("Path1\0Path2\0\0", new string(text, 0, "Path1".Length + 1 + "Path2".Length + 1 + 1));
-        }
-        finally
-        {
-            PInvoke.GlobalFree(handle);
-        }
-    }
-
-    [WinFormsFact]
-    public unsafe void IComDataObjectGetDataHere_EmptyFileNames_Success()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetFileDropList(new StringCollection());
-        IComDataObject iComDataObject = dataObject;
-
-        FORMATETC formatetc = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = (short)CLIPBOARD_FORMAT.CF_HDROP
-        };
-
-        STGMEDIUM stgMedium = new()
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        HGLOBAL handle = PInvoke.GlobalAlloc(
-           GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT,
-           (uint)sizeof(DROPFILES));
-
-        try
-        {
-            stgMedium.unionmember = handle;
-            iComDataObject.GetDataHere(ref formatetc, ref stgMedium);
-
-            DROPFILES* pDropFiles = *(DROPFILES**)stgMedium.unionmember;
-            Assert.Equal(0u, pDropFiles->pFiles);
-            Assert.Equal(Point.Empty, pDropFiles->pt);
-            Assert.False(pDropFiles->fNC);
-            Assert.False(pDropFiles->fWide);
-        }
-        finally
-        {
-            PInvoke.GlobalFree(handle);
-        }
-    }
-
-    [WinFormsFact]
-    public unsafe void IComDataObjectGetDataHere_FileNamesNoData_ThrowsArgumentException()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetFileDropList(new StringCollection { "Path1", "Path2" });
-        IComDataObject iComDataObject = dataObject;
-
-        var formatetc = new FORMATETC
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = (short)CLIPBOARD_FORMAT.CF_HDROP
-        };
-        var stgMedium = new STGMEDIUM
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-        Assert.Throws<ArgumentException>(() => iComDataObject.GetDataHere(ref formatetc, ref stgMedium));
-    }
-
-    [WinFormsFact]
-    public unsafe void IComDataObjectGetDataHere_EmptyFileNamesNoData_Success()
-    {
-        var dataObject = new DataObject();
-        dataObject.SetFileDropList(new StringCollection());
-        IComDataObject iComDataObject = dataObject;
-
-        var formatetc = new FORMATETC
-        {
-            tymed = TYMED.TYMED_HGLOBAL,
-            cfFormat = (short)CLIPBOARD_FORMAT.CF_HDROP
-        };
-        var stgMedium = new STGMEDIUM
-        {
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-        iComDataObject.GetDataHere(ref formatetc, ref stgMedium);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TYMED.TYMED_FILE, TYMED.TYMED_FILE)]
-    [InlineData(TYMED.TYMED_ISTORAGE, TYMED.TYMED_ISTORAGE)]
-    [InlineData(TYMED.TYMED_MFPICT, TYMED.TYMED_MFPICT)]
-    [InlineData(TYMED.TYMED_ENHMF, TYMED.TYMED_ENHMF)]
-    [InlineData(TYMED.TYMED_NULL, TYMED.TYMED_NULL)]
-    public void IComDataObjectGetDataHere_InvalidTymed_ThrowsCOMException(TYMED formatetcTymed, TYMED stgMediumTymed)
-    {
-        var dataObject = new DataObject();
-        IComDataObject iComDataObject = dataObject;
-
-        var formatetc = new FORMATETC
-        {
-            tymed = formatetcTymed
-        };
-        var stgMedium = new STGMEDIUM
-        {
-            tymed = stgMediumTymed
-        };
-        COMException ex = Assert.Throws<COMException>(() => iComDataObject.GetDataHere(ref formatetc, ref stgMedium));
-        Assert.Equal(HRESULT.DV_E_TYMED, (HRESULT)ex.HResult);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TYMED.TYMED_HGLOBAL, TYMED.TYMED_HGLOBAL, (short)CLIPBOARD_FORMAT.CF_UNICODETEXT)]
-    [InlineData(TYMED.TYMED_HGLOBAL, TYMED.TYMED_HGLOBAL, (short)CLIPBOARD_FORMAT.CF_HDROP)]
-    [InlineData(TYMED.TYMED_ISTREAM, TYMED.TYMED_ISTREAM, (short)CLIPBOARD_FORMAT.CF_UNICODETEXT)]
-    [InlineData(TYMED.TYMED_ISTREAM, TYMED.TYMED_ISTREAM, (short)CLIPBOARD_FORMAT.CF_HDROP)]
-    [InlineData(TYMED.TYMED_GDI, TYMED.TYMED_GDI, (short)CLIPBOARD_FORMAT.CF_UNICODETEXT)]
-    [InlineData(TYMED.TYMED_GDI, TYMED.TYMED_GDI, (short)CLIPBOARD_FORMAT.CF_HDROP)]
-    public void IComDataObjectGetDataHere_NoDataPresentNoData_ThrowsCOMException(TYMED formatetcTymed, TYMED stgMediumTymed, short cfFormat)
-    {
-        var dataObject = new DataObject();
-        IComDataObject iComDataObject = dataObject;
-
-        var formatetc = new FORMATETC
-        {
-            tymed = formatetcTymed,
-            cfFormat = cfFormat
-        };
-        var stgMedium = new STGMEDIUM
-        {
-            tymed = stgMediumTymed
-        };
-        COMException ex = Assert.Throws<COMException>(() => iComDataObject.GetDataHere(ref formatetc, ref stgMedium));
-        Assert.Equal(HRESULT.DV_E_FORMATETC, (HRESULT)ex.HResult);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObject_BitmapBinderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObject_BitmapBinderTests.cs
deleted file mode 100644
index 84a656e281c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DataObject_BitmapBinderTests.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-
-namespace System.Windows.Forms.Tests;
-
-public class DataObject_BitmapBinderTests
-{
-    private static readonly SerializationBinder s_serializationBinder
-        = (SerializationBinder)Activator.CreateInstance(typeof(DataObject).Assembly.GetType("System.Windows.Forms.DataObject+BitmapBinder"));
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowedSerializationTypes))]
-    public void BitmapBinder_BindToName_AllowedSerializationTypes(object value)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: true);
-        using (value as IDisposable)
-        {
-            using MemoryStream stream = new();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            BinaryFormatter formatter = new()
-            {
-                Binder = s_serializationBinder
-            };
-#pragma warning restore
-
-            formatter.Serialize(stream, value);
-            Assert.True(stream.Length > 0);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowedSerializationTypes))]
-    public void BitmapBinder_BindToType_AllowedSerializationTypes(object value)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: true);
-        using (value as IDisposable)
-        {
-            using MemoryStream stream = new();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            BinaryFormatter formatter = new();
-#pragma warning restore
-            formatter.Serialize(stream, value);
-            Assert.True(stream.Length > 0);
-            stream.Position = 0;
-
-            formatter = new()
-            {
-                Binder = s_serializationBinder
-            };
-
-            // cs/dangerous-binary-deserialization
-            object deserialized = formatter.Deserialize(stream); // CodeQL [SM03722] : Safe use because input stream is controlled contains strings and Bitmap which is instantiated by a binder. 
-            Assert.NotNull(deserialized);
-
-            if (value is not Bitmap)
-            {
-                Assert.Equal(value, deserialized);
-            }
-        }
-    }
-
-    public static TheoryData<object> AllowedSerializationTypes => new()
-    {
-        "Information At your Fingertips",
-        new string[] { "Hello" },
-        new Bitmap(5, 5)
-    };
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisallowedSerializationTypes))]
-    public void BitmapBinder_BindToName_DisallowedSerializationTypes(object value)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: true);
-        using MemoryStream stream = new();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new()
-        {
-            Binder = s_serializationBinder
-        };
-#pragma warning restore SYSLIB0011
-
-        Assert.Throws<SerializationException>(() => formatter.Serialize(stream, value));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisallowedSerializationTypes))]
-    public void BitmapBinder_BindToType_DisallowedSerializationTypes(object value)
-    {
-        using BinaryFormatterScope formatterScope = new(enable: true);
-        using MemoryStream stream = new();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        BinaryFormatter formatter = new();
-#pragma warning restore SYSLIB0011
-        formatter.Serialize(stream, value);
-        Assert.True(stream.Length > 0);
-        stream.Position = 0;
-
-        formatter = new()
-        {
-            Binder = s_serializationBinder
-        };
-
-        Assert.Throws<SerializationException>(() => formatter.Deserialize(stream));
-    }
-
-    public static TheoryData<object> DisallowedSerializationTypes => new()
-    {
-        new List<string>() { "Hello" },
-        new Hashtable() { { "Silver", "Hammer" } }
-    };
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateRangeEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateRangeEventArgsTests.cs
deleted file mode 100644
index cf6d12ca71e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateRangeEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DateRangeEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_DateTime_DateTime_TestData()
-    {
-        yield return new object[] { DateTime.MinValue, DateTime.MinValue };
-        yield return new object[] { new DateTime(10), new DateTime(0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_DateTime_DateTime_TestData))]
-    public void Ctor_DateTime_DateTime(DateTime start, DateTime end)
-    {
-        var e = new DateRangeEventArgs(start, end);
-        Assert.Equal(start, e.Start);
-        Assert.Equal(end, e.End);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePicker.DateTimePickerAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePicker.DateTimePickerAccessibleObjectTests.cs
deleted file mode 100644
index f3f9bc4b390..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePicker.DateTimePickerAccessibleObjectTests.cs
+++ /dev/null
@@ -1,375 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.DateTimePicker;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DateTimePicker_DateTimePickerAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Ctor_Default()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        DateTimePickerAccessibleObject accessibleObject = new DateTimePickerAccessibleObject(dateTimePicker);
-
-        Assert.Equal(dateTimePicker, accessibleObject.Owner);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_ControlType_IsComboBox_IfAccessibleRoleIsDefault()
-    {
-        using DateTimePicker dateTimePicker = new();
-        // AccessibleRole is not set = Default
-
-        object actual = dateTimePicker.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ComboBoxControlTypeId, actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Role_IsComboBox_ByDefault()
-    {
-        using DateTimePicker dateTimePicker = new();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = dateTimePicker.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.ComboBox, actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_LocalizedControlType_ReturnsExpected_IfAccessibleRoleIsDefault()
-    {
-        using DateTimePicker dateTimePicker = new();
-        // AccessibleRole is not set = Default
-
-        object actual = dateTimePicker.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LocalizedControlTypePropertyId);
-        string expected = SR.DateTimePickerLocalizedControlType;
-
-        Assert.Equal(expected, actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DateTimePickerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DateTimePickerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DateTimePickerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DateTimePicker dateTimePicker = new();
-        dateTimePicker.AccessibleRole = role;
-
-        object actual = dateTimePicker.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DateTimePickerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DateTimePickerAccessibleObject_GetPropertyValue_LocalizedControlType_IsNull_ForCustomRole(AccessibleRole role)
-    {
-        using DateTimePicker dateTimePicker = new();
-        dateTimePicker.AccessibleRole = role;
-
-        object actual = dateTimePicker.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LocalizedControlTypePropertyId);
-
-        Assert.Null(actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 1);
-        dateTimePicker.Value = dt;
-        AccessibleObject accessibleObject = dateTimePicker.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId));
-        Assert.False(dateTimePicker.IsHandleCreated);
-
-        dateTimePicker.CreateControl();
-
-        Assert.Equal(dt.ToLongDateString(), accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.ExpandCollapseState.Expanded)]
-    [InlineData((int)UiaCore.ExpandCollapseState.Collapsed)]
-    public void DateTimePickerAccessibleObject_ExpandCollapseState_ReturnsExpected(int expandCollapseState)
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        var expected = (UiaCore.ExpandCollapseState)expandCollapseState;
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-        dateTimePicker.TestAccessor().Dynamic._expandCollapseState = expected;
-
-        UiaCore.ExpandCollapseState actual = accessibleObject.ExpandCollapseState;
-
-        Assert.Equal(expected, actual);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Expand_IfHandleIsNotCreated_NothingChanges()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        // ExpandCollapseState is Collapsed before some actions
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Expand();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Collapse_IfHandleIsNotCreated_NothingChanges()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        // ExpandCollapseState is Collapsed before some actions
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        dateTimePicker.TestAccessor().Dynamic._expandCollapseState = UiaCore.ExpandCollapseState.Expanded;
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Collapse();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Expand_IfControlAlreadyIsExpanded_NothingChanges()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        dateTimePicker.CreateControl();
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        // ExpandCollapseState is Collapsed before some actions
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        dateTimePicker.TestAccessor().Dynamic._expandCollapseState = UiaCore.ExpandCollapseState.Expanded;
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Expand();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Collapse_IfControlAlreadyIsCollapsed_NothingChanges()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        dateTimePicker.CreateControl();
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        // ExpandCollapseState is Collapsed before some actions
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Collapse();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Expand_IfHandleIsCreated_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        dateTimePicker.CreateControl();
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        // ExpandCollapseState is Collapsed before some actions
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Expand();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Collapse_IfHandleIsCreated_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        dateTimePicker.CreateControl();
-        var accessibleObject = (DateTimePickerAccessibleObject)dateTimePicker.AccessibilityObject;
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        // If don't call Expand() on this control and just change state value instead
-        // then call Collapse() does't work correctly due to the control is not expanded factually
-        accessibleObject.Expand();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-
-        accessibleObject.Collapse();
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ExpandCollapsePatternId)]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    public void DateTimePickerAccessibleObject_IsPatternSupported_ReturnsExpected_IfDoNotShowCheckbox(int patternId)
-    {
-        using DateTimePicker dateTimePicker = new() { ShowCheckBox = false };
-
-        AccessibleObject accessibleObject = dateTimePicker.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TogglePatternId)]
-    [InlineData((int)UiaCore.UIA.ExpandCollapsePatternId)]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    public void DateTimePickerAccessibleObject_IsPatternSupported_ReturnsExpected_IfShowCheckbox(int patternId)
-    {
-        using DateTimePicker dateTimePicker = new() { ShowCheckBox = true };
-
-        AccessibleObject accessibleObject = dateTimePicker.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Name_ReturnsEmptyString_IfControlAccessibleNameIsNotNull()
-    {
-        using DateTimePicker dateTimePicker = new();
-
-        Assert.Equal(string.Empty, dateTimePicker.AccessibilityObject.Name);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_Name_ReturnsExpected_IfControlAccessibleNameIsNotNull()
-    {
-        string testAccessibleName = "TestDateTimePicker";
-        using DateTimePicker dateTimePicker = new() { AccessibleName = testAccessibleName };
-
-        Assert.Equal(testAccessibleName, dateTimePicker.AccessibilityObject.Name);
-        Assert.False(dateTimePicker.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DateTimePickerAccessibleObject_DefaultAction_ReturnsExpected_TestData()
-    {
-        // Expanded dtp control has "Collapse" as a default action, else "Expand".
-        yield return new object[] { true, SR.AccessibleActionCollapse };
-        yield return new object[] { false, SR.AccessibleActionExpand };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DateTimePickerAccessibleObject_DefaultAction_ReturnsExpected_TestData))]
-    public void DateTimePickerAccessibleObject_DefaultAction_ReturnsExpected(bool isExpanded, string expected)
-    {
-        using DateTimePicker dateTimePicker = new();
-        dateTimePicker.CreateControl();
-
-        AccessibleObject accessibleObject = dateTimePicker.AccessibilityObject;
-
-        if (isExpanded)
-        {
-            accessibleObject.Expand();
-        }
-
-        Assert.Equal(expected, accessibleObject.DefaultAction);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.ExpandCollapseState.Collapsed)]
-    [InlineData(false, (int)UiaCore.ExpandCollapseState.Expanded)]
-    public void DateTimePickerAccessibleObject_DoDefaultAction_IfHandleIsCreated_ReturnsExpected(bool isExpanded, int expected)
-    {
-        using DateTimePicker dateTimePicker = new();
-        dateTimePicker.CreateControl();
-
-        AccessibleObject accessibleObject = dateTimePicker.AccessibilityObject;
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-
-        if (isExpanded)
-        {
-            accessibleObject.Expand();
-
-            Assert.Equal(UiaCore.ExpandCollapseState.Expanded, accessibleObject.ExpandCollapseState);
-        }
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.Equal((UiaCore.ExpandCollapseState)expected, accessibleObject.ExpandCollapseState);
-        Assert.True(dateTimePicker.IsHandleCreated);
-    }
-
-    // Unit Test for https://github.com/dotnet/winforms/issues/9281.
-    [WinFormsFact]
-    public void DateTimePickerAccessibleObject_KeyboardShortcut_ReturnsExpected()
-    {
-        using Form form = new Form();
-        using DateTimePicker dateTimePicker1 = new();
-        using Label label1 = new ();
-        using DateTimePicker dateTimePicker2 = new();
-
-        dateTimePicker1.CustomFormat = "'Date&Time' hh:mm dd/MM";
-        dateTimePicker1.Format = DateTimePickerFormat.Custom;
-        dateTimePicker1.TabIndex = 0;
-
-        label1.Text = "&Date";
-        label1.TabIndex = 1;
-
-        dateTimePicker2.TabIndex = 2;
-
-        form.Controls.Add(dateTimePicker2);
-        form.Controls.Add(label1);
-        form.Controls.Add(dateTimePicker1);
-
-        string keyboardShortcut = dateTimePicker1.AccessibilityObject.KeyboardShortcut;
-
-        Assert.Null(keyboardShortcut);
-
-        keyboardShortcut = dateTimePicker2.AccessibilityObject.KeyboardShortcut;
-
-        Assert.Equal("Alt+d", keyboardShortcut);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePickerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePickerTests.cs
deleted file mode 100644
index bbe290a5fae..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DateTimePickerTests.cs
+++ /dev/null
@@ -1,370 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class DateTimePickerTests
-{
-    [WinFormsFact]
-    public void DateTimePicker_Ctor_Default()
-    {
-        using var control = new SubDateTimePicker();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(control.PreferredHeight, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, control.PreferredHeight), control.Bounds);
-        Assert.Equal(Control.DefaultForeColor, control.CalendarForeColor);
-        Assert.Equal(Control.DefaultFont, control.CalendarFont);
-        Assert.Equal(SystemColors.Window, control.CalendarMonthBackground);
-        Assert.Equal(SystemColors.ActiveCaption, control.CalendarTitleBackColor);
-        Assert.Equal(SystemColors.ActiveCaptionText, control.CalendarTitleForeColor);
-        Assert.Equal(SystemColors.GrayText, control.CalendarTrailingForeColor);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.True(control.Checked);
-        Assert.Equal(new Size(196, control.PreferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 196, control.PreferredHeight - 4), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Null(control.CustomFormat);
-        Assert.Same(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(200, control.PreferredHeight), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 196, control.PreferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Equal(LeftRightAlignment.Left, control.DropDownAlign);
-        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.Equal(DateTimePickerFormat.Long, control.Format);
-        Assert.False(control.HasChildren);
-        Assert.Equal(control.PreferredHeight, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(new DateTime(9998, 12, 31), control.MaxDate);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(new DateTime(1753, 1, 1), control.MinDate);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(200, control.PreferredHeight), control.PreferredSize);
-        Assert.Equal(Control.DefaultFont.Height + 7, control.PreferredHeight);
-        Assert.Equal(control.PreferredHeight, control.PreferredHeight);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.False(control.ShowCheckBox);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.False(control.ShowUpDown);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, control.PreferredHeight), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Equal(string.Empty, control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Value > DateTime.MinValue);
-        Assert.True(control.Visible);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubDateTimePicker();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysDateTimePick32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010004, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDateTimePicker();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [EnumData<DateTimePickerFormat>]
-    public void DateTimePicker_Format_Set_GetReturnsExpected(DateTimePickerFormat value)
-    {
-        using var control = new SubDateTimePicker();
-
-        control.Format = value;
-        Assert.Equal(value, control.Format);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DateTimePickerFormat>]
-    public void DateTimePicker_Format_SetInvalid_ThrowsInvalidEnumArgumentException(DateTimePickerFormat value)
-    {
-        using var control = new DateTimePicker();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Format = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void DateTimePicker_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubDateTimePicker();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDateTimePicker();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_SysTimeToDateTime_DoesnThrowException_If_SYSTEMTIME_IsIncorrect()
-    {
-        // We expect to hit Debug.Fail in this test and unless we clear listeners we will crash to xUnit runner:
-        // "The active test run was aborted. Reason: Test host process crashed : Process terminated. Assertion failed."
-        using (new NoAssertContext())
-        {
-            // An empty SYSTEMTIME has year, month and day as 0, but DateTime can't have these parameters.
-            // So an empty SYSTEMTIME is incorrect in this case.
-            SYSTEMTIME systemTime = new SYSTEMTIME();
-            DateTime dateTime = (DateTime)systemTime;
-            Assert.Equal(DateTime.MinValue, dateTime);
-        }
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_Null_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        dateTimePicker.CreateControl();
-
-        Assert.Null(dateTimePicker.CustomFormat);
-        Assert.Equal(dt.ToLongDateString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_Null_Format_Short_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        dateTimePicker.Format = DateTimePickerFormat.Short;
-        dateTimePicker.CreateControl();
-
-        Assert.Null(dateTimePicker.CustomFormat);
-        Assert.Equal(dt.ToShortDateString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_Null_Format_Time_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        dateTimePicker.Format = DateTimePickerFormat.Time;
-        dateTimePicker.CreateControl();
-
-        Assert.Null(dateTimePicker.CustomFormat);
-        Assert.Equal(dt.ToLongTimeString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_LongDatePattern_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        Globalization.DateTimeFormatInfo dateTimeFormat = Globalization.CultureInfo.CurrentCulture.DateTimeFormat;
-        dateTimePicker.Format = DateTimePickerFormat.Custom;
-        dateTimePicker.CustomFormat = dateTimeFormat.LongDatePattern;
-        dateTimePicker.CreateControl();
-
-        Assert.Equal(dt.ToLongDateString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_ShortDatePattern_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        Globalization.DateTimeFormatInfo dateTimeFormat = Globalization.CultureInfo.CurrentCulture.DateTimeFormat;
-        dateTimePicker.Format = DateTimePickerFormat.Custom;
-        dateTimePicker.CustomFormat = dateTimeFormat.ShortDatePattern;
-        dateTimePicker.CreateControl();
-
-        Assert.Equal(dt.ToShortDateString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_LongTimePattern_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        Globalization.DateTimeFormatInfo dateTimeFormat = Globalization.CultureInfo.CurrentCulture.DateTimeFormat;
-        dateTimePicker.Format = DateTimePickerFormat.Custom;
-        dateTimePicker.CustomFormat = dateTimeFormat.LongTimePattern;
-        dateTimePicker.CreateControl();
-
-        Assert.Equal(dt.ToLongTimeString(), dateTimePicker.Text);
-    }
-
-    [WinFormsFact]
-    public void DateTimePicker_CustomFormat_ShortTimePattern_Text_ReturnsExpected()
-    {
-        using DateTimePicker dateTimePicker = new();
-        DateTime dt = new(2000, 1, 2, 3, 4, 5);
-        dateTimePicker.Value = dt;
-        Globalization.DateTimeFormatInfo dateTimeFormat = Globalization.CultureInfo.CurrentCulture.DateTimeFormat;
-        dateTimePicker.Format = DateTimePickerFormat.Custom;
-        dateTimePicker.CustomFormat = dateTimeFormat.ShortTimePattern;
-        dateTimePicker.CreateControl();
-
-        Assert.Equal(dt.ToShortTimeString(), dateTimePicker.Text);
-    }
-
-    public class SubDateTimePicker : DateTimePicker
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorFormTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorFormTests.cs
deleted file mode 100644
index f43b7372b8d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorFormTests.cs
+++ /dev/null
@@ -1,464 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ComponentEditorFormTests
-{
-    [WinFormsFact]
-    public void ComponentEditorComponentEditorForm_Ctor_Default()
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.NotNull(control.AcceptButton);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.Null(control.ActiveControl);
-        Assert.Null(control.ActiveMdiChild);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowTransparency);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-#pragma warning disable 0618
-        Assert.True(control.AutoScale);
-#pragma warning restore 0618
-        Assert.True(control.AutoScaleBaseSize.Width > 0);
-        Assert.True(control.AutoScaleBaseSize.Height > 0);
-        Assert.Equal(SizeF.Empty, control.AutoScaleDimensions);
-        Assert.Equal(new SizeF(1, 1), control.AutoScaleFactor);
-        Assert.Equal(AutoScaleMode.Inherit, control.AutoScaleMode);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(control.Height, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, control.Width, control.Height), control.Bounds);
-        Assert.NotNull(control.CancelButton);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, control.ClientSize.Width, control.ClientSize.Height), control.ClientRectangle);
-        Assert.Equal(new Size(control.ClientSize.Width, control.ClientSize.Height), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.True(control.ControlBox);
-        Assert.NotEmpty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Equal(SizeF.Empty, control.CurrentAutoScaleDimensions);
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(Cursors.Default, control.Cursor);
-        Assert.Equal(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.NoControl, 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(300, 300), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(-SystemInformation.WorkingArea.X, -SystemInformation.WorkingArea.Y, control.Width, control.Height), control.DesktopBounds);
-        Assert.Equal(new Point(-SystemInformation.WorkingArea.X, -SystemInformation.WorkingArea.Y), control.DesktopLocation);
-        Assert.Equal(DialogResult.None, control.DialogResult);
-        Assert.Equal(new Rectangle(0, 0, control.ClientSize.Width, control.ClientSize.Height), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(FormBorderStyle.FixedDialog, control.FormBorderStyle);
-        Assert.True(control.HasChildren);
-        Assert.True(control.Height > 0);
-        Assert.False(control.HelpButton);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.NotNull(control.Icon);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMdiChild);
-        Assert.False(control.IsMdiContainer);
-        Assert.False(control.IsMirrored);
-        Assert.False(control.IsRestrictedWindow);
-        Assert.False(control.KeyPreview);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Null(control.MainMenuStrip);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Empty(control.MdiChildren);
-        Assert.Null(control.MdiParent);
-        Assert.Equal(Rectangle.Empty, control.MaximizedBounds);
-        Assert.False(control.MaximizeBox);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.False(control.MinimizeBox);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(control.Modal);
-        Assert.Equal(1, control.Opacity);
-        Assert.Empty(control.OwnedForms);
-        Assert.Null(control.Owner);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(new Rectangle(-1, -1, control.Width, control.Height), control.RestoreBounds);
-        Assert.Equal(control.Width, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowIcon);
-        Assert.False(control.ShowInTaskbar);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.False(control.ShowWithoutActivation);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(control.Width, control.Height), control.Size);
-        Assert.Equal(SizeGripStyle.Auto, control.SizeGripStyle);
-        Assert.Equal(FormStartPosition.CenterParent, control.StartPosition);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Equal("Properties", control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.True(control.TopLevel);
-        Assert.Same(control, control.TopLevelControl);
-        Assert.False(control.TopMost);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.False(control.UseWaitCursor);
-        Assert.False(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.True(control.Width > 0);
-        Assert.Equal(FormWindowState.Normal, control.WindowState);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorComponentEditorForm_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        CreateParams createParams = control.CreateParams;
-        Assert.Equal("Properties", createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10001, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x2C80000, createParams.Style);
-        Assert.Equal(control.Width, createParams.Width);
-        Assert.Equal(int.MinValue, createParams.X);
-        Assert.Equal(int.MinValue, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorComponentEditorForm_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubComponentEditorForm.ScrollStateAutoScrolling, false)]
-    [InlineData(SubComponentEditorForm.ScrollStateFullDrag, false)]
-    [InlineData(SubComponentEditorForm.ScrollStateHScrollVisible, false)]
-    [InlineData(SubComponentEditorForm.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubComponentEditorForm.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ComponentEditorComponentEditorForm_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ComponentEditorComponentEditorForm_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorComponentEditorForm_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.True(control.GetTopLevel());
-    }
-
-    /*
-            [WinFormsTheory]
-            [NewAndDefaultData<EventArgs>]
-            public void ComponentEditorForm_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-            {
-                using var component = new Component();
-                using var control = new SubComponentEditorForm(component, new Type[0]);
-                int callCount = 0;
-                EventHandler handler = (sender, e) =>
-                {
-                    Assert.Same(control, sender);
-                    Assert.Same(eventArgs, e);
-                    callCount++;
-                };
-
-                // Call with handler.
-                control.HandleCreated += handler;
-                control.OnHandleCreated(eventArgs);
-                Assert.Equal(1, callCount);
-                Assert.False(control.IsHandleCreated);
-
-                // Remove handler.
-                control.HandleCreated -= handler;
-                control.OnHandleCreated(eventArgs);
-                Assert.Equal(1, callCount);
-                Assert.False(control.IsHandleCreated);
-            }
-    */
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ComponentEditorForm_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ComponentEditorForm_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ComponentEditorForm_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var component = new Component();
-        using var control = new SubComponentEditorForm(component, Array.Empty<Type>());
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public class SubComponentEditorForm : ComponentEditorForm
-    {
-        public SubComponentEditorForm(object component, Type[] pageTypes) : base(component, pageTypes)
-        {
-        }
-
-        public new const int ScrollStateAutoScrolling = ComponentEditorForm.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ComponentEditorForm.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ComponentEditorForm.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ComponentEditorForm.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ComponentEditorForm.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new Rectangle MaximizedBounds => base.MaximizedBounds;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool ShowWithoutActivation => base.ShowWithoutActivation;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorPageTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorPageTests.cs
deleted file mode 100644
index 71770556fc4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ComponentEditorPageTests.cs
+++ /dev/null
@@ -1,1015 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Design.Tests;
-
-public class ComponentEditorPageTests
-{
-    [WinFormsFact]
-    public void ComponentEditorPagePanel_Ctor_Default()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.False(control.CommitOnDeactivate);
-        Assert.Null(control.Component);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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.True(control.FirstActivate);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.NotNull(control.Icon);
-        Assert.Same(control.Icon, control.Icon);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        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.PageSite);
-        Assert.Null(control.Parent);
-        Assert.Equal(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Null(control.Site);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Empty(control.Title);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.False(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubComponentEditorPage();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x46000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubComponentEditorPage();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new SubComponentEditorPage
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_CommitOnDeactivate_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            CommitOnDeactivate = value
-        };
-        Assert.Equal(value, control.CommitOnDeactivate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommitOnDeactivate = value;
-        Assert.Equal(value, control.CommitOnDeactivate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CommitOnDeactivate = value;
-        Assert.Equal(value, control.CommitOnDeactivate);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Component_Set_TestData()
-    {
-        yield return new object[] { null };
-        var mockComponent = new Mock<IComponent>(MockBehavior.Strict);
-        mockComponent
-            .Setup(c => c.Dispose());
-        yield return new object[] { mockComponent.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Component_Set_TestData))]
-    public void ComponentEditorPage_Component_Set_GetReturnsExpected(IComponent value)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Component = value
-        };
-        Assert.Same(value, control.Component);
-        Assert.Same(value, control.GetSelectedComponent());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Component = value;
-        Assert.Same(value, control.Component);
-        Assert.Same(value, control.GetSelectedComponent());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_FirstActivate_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            FirstActivate = value
-        };
-        Assert.Equal(value, control.FirstActivate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FirstActivate = value;
-        Assert.Equal(value, control.FirstActivate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.FirstActivate = value;
-        Assert.Equal(value, control.FirstActivate);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_Icon_Set_GetReturnsExpected()
-    {
-        using (var value = Icon.FromHandle(new Bitmap(10, 10).GetHicon()))
-        {
-            using var control = new SubComponentEditorPage
-            {
-                Icon = value
-            };
-            Assert.Same(value, control.Icon);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Icon = value;
-            Assert.Same(value, control.Icon);
-            Assert.False(control.IsHandleCreated);
-
-            // Set null.
-            control.Icon = null;
-            Assert.NotSame(value, control.Icon);
-            Assert.NotNull(control.Icon);
-            Assert.Same(control.Icon, control.Icon);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, true)]
-    [InlineData(0, false)]
-    [InlineData(1, true)]
-    public void ComponentEditorPage_Loading_Set_GetReturnsExpected(int value, bool expectedIsLoading)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Loading = value
-        };
-        Assert.Equal(value, control.Loading);
-        Assert.Equal(expectedIsLoading, control.IsLoading());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Loading = value;
-        Assert.Equal(value, control.Loading);
-        Assert.Equal(expectedIsLoading, control.IsLoading());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_LoadRequired_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            LoadRequired = value
-        };
-        Assert.Equal(value, control.LoadRequired);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LoadRequired = value;
-        Assert.Equal(value, control.LoadRequired);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.LoadRequired = value;
-        Assert.Equal(value, control.LoadRequired);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PageSite_Set_TestData()
-    {
-        yield return new object[] { null };
-        var mockComponentEditorPageSite = new Mock<IComponentEditorPageSite>(MockBehavior.Strict);
-        yield return new object[] { mockComponentEditorPageSite.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PageSite_Set_TestData))]
-    public void ComponentEditorPage_PageSite_Set_GetReturnsExpected(IComponentEditorPageSite value)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            PageSite = value
-        };
-        Assert.Same(value, control.PageSite);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.PageSite = value;
-        Assert.Same(value, control.PageSite);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ComponentEditorPage_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected, control.Title);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected, control.Title);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ComponentEditorPage_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected, control.Title);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected, control.Title);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubComponentEditorPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal("text", control.Title);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal("text", control.Title);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Empty(control.Title);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal("text", control.Title);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ComponentEditorPage_Activate_Invoke_SetsVisible(bool loadRequired, int expectedLoadComponentCallCount)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            LoadRequired = loadRequired
-        };
-        control.Activate();
-        Assert.Equal(expectedLoadComponentCallCount, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Activate();
-        Assert.Equal(expectedLoadComponentCallCount, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_ApplyChanges_Invoke_CallsSaveComponent(bool loadRequired)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            LoadRequired = loadRequired
-        };
-        control.ApplyChanges();
-        Assert.Equal(1, control.SaveComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(loadRequired, control.LoadRequired);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ApplyChanges();
-        Assert.Equal(2, control.SaveComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(loadRequired, control.LoadRequired);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ComponentEditorPage_Deactivate_InvokeActivated_SetsInvisible(bool loadRequired, int expectedLoadComponentCallCount)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            LoadRequired = loadRequired
-        };
-        control.Activate();
-        Assert.Equal(expectedLoadComponentCallCount, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        control.Deactivate();
-        Assert.Equal(expectedLoadComponentCallCount, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Deactivate();
-        Assert.Equal(expectedLoadComponentCallCount, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ComponentEditorPage_Deactivate_InvokeNotActivated_SetsInvisible(bool loadRequired)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            LoadRequired = loadRequired
-        };
-        control.Deactivate();
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(loadRequired, control.LoadRequired);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Deactivate();
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(loadRequired, control.LoadRequired);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_EnterLoadingMode_Invoke_IncrementsLoading()
-    {
-        using var control = new SubComponentEditorPage();
-        control.EnterLoadingMode();
-        Assert.Equal(1, control.Loading);
-
-        // Call again.
-        control.EnterLoadingMode();
-        Assert.Equal(2, control.Loading);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_EnterLoadingMode_ExitLoadingMode_Resets()
-    {
-        using var control = new SubComponentEditorPage();
-        control.EnterLoadingMode();
-        Assert.Equal(1, control.Loading);
-
-        control.ExitLoadingMode();
-        Assert.Equal(0, control.Loading);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_ExitLoadingMode_Invoke_DoesNotDecrementLoading()
-    {
-        using var control = new SubComponentEditorPage();
-        control.ExitLoadingMode();
-        Assert.Equal(0, control.Loading);
-
-        // Call again.
-        control.ExitLoadingMode();
-        Assert.Equal(0, control.Loading);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_ExitLoadingMode_EnterLoadingMode_IncrementsLoading()
-    {
-        using var control = new SubComponentEditorPage();
-        control.ExitLoadingMode();
-        Assert.Equal(0, control.Loading);
-
-        control.EnterLoadingMode();
-        Assert.Equal(1, control.Loading);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_IsFirstActivate_Invoke_ReturnsTrue()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.True(control.IsFirstActivate());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_IsLoading_Invoke_ReturnsFalse()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.False(control.IsLoading());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_IsPageMessage_Invoke_ReturnsExpected()
-    {
-        using var control = new SubComponentEditorPage();
-        var message = new Message();
-        Assert.True(control.IsPageMessage(ref message));
-        Assert.Equal(1, control.PreProcessMessageCallCount);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_GetControl_InvokeDefault_ReturnsSame()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Same(control, control.GetControl());
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_GetSelectedComponent_InvokeDefault_ReturnsNull()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Null(control.GetSelectedComponent());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubComponentEditorPage.ScrollStateAutoScrolling, false)]
-    [InlineData(SubComponentEditorPage.ScrollStateFullDrag, false)]
-    [InlineData(SubComponentEditorPage.ScrollStateHScrollVisible, false)]
-    [InlineData(SubComponentEditorPage.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubComponentEditorPage.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ComponentEditorPage_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ComponentEditorPage_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void ComponentEditorPage_OnApplyComplete_Invoke_SetsLoadRequired(bool visible, bool expectedLoadRequired)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Visible = visible
-        };
-        Assert.Equal(visible, control.Visible);
-        control.OnApplyComplete();
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(expectedLoadRequired, control.LoadRequired);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void ComponentEditorPage_ReloadComponent_Invoke_SetsLoadRequired(bool visible, bool expectedLoadRequired)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Visible = visible
-        };
-        Assert.Equal(visible, control.Visible);
-        control.ReloadComponent();
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.Equal(expectedLoadRequired, control.LoadRequired);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Component_Set_TestData))]
-    public void ComponentEditorPage_SetComponent_Invoke_SetsComponent(IComponent component)
-    {
-        using var control = new SubComponentEditorPage();
-        control.SetComponent(component);
-        Assert.Same(component, control.Component);
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.True(control.LoadRequired);
-
-        // Set same.
-        control.SetComponent(component);
-        Assert.Same(component, control.Component);
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.True(control.LoadRequired);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 1)]
-    [InlineData(1, 0)]
-    public void ComponentEditorPage_SetDirty_InvokeWithPageSites_CallsSetDirty(int loading, int expectedSetDirtyCallCount)
-    {
-        var mockComponentEditorPageSite = new Mock<IComponentEditorPageSite>(MockBehavior.Strict);
-        mockComponentEditorPageSite
-            .Setup(s => s.SetDirty())
-            .Verifiable();
-        using var control = new SubComponentEditorPage
-        {
-            PageSite = mockComponentEditorPageSite.Object,
-            Loading = loading
-        };
-        control.SetDirty();
-        mockComponentEditorPageSite.Verify(s => s.SetDirty(), Times.Exactly(expectedSetDirtyCallCount));
-
-        // Call again.
-        control.SetDirty();
-        mockComponentEditorPageSite.Verify(s => s.SetDirty(), Times.Exactly(expectedSetDirtyCallCount * 2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ComponentEditorPage_SetDirty_InvokeWithoutPageSite_Nop(int loading)
-    {
-        using var control = new SubComponentEditorPage
-        {
-            Loading = loading
-        };
-        control.SetDirty();
-        control.SetDirty();
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_SetSite_Invoke_SetsPageSite()
-    {
-        using var result = new Control();
-        var controlSite = new Mock<IComponentEditorPageSite>(MockBehavior.Strict);
-        controlSite
-            .Setup(s => s.GetControl())
-            .Returns(result)
-            .Verifiable();
-        var noControlSite = new Mock<IComponentEditorPageSite>(MockBehavior.Strict);
-        noControlSite
-            .Setup(s => s.GetControl())
-            .Returns<Control>(null)
-            .Verifiable();
-        using var control = new SubComponentEditorPage();
-        control.SetSite(controlSite.Object);
-        Assert.Same(controlSite.Object, control.PageSite);
-        Assert.Same(control, Assert.Single(result.Controls));
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-
-        // Set same.
-        control.SetSite(controlSite.Object);
-        Assert.Same(controlSite.Object, control.PageSite);
-        Assert.Same(control, Assert.Single(result.Controls));
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-
-        // Set different.
-        control.SetSite(noControlSite.Object);
-        Assert.Same(noControlSite.Object, control.PageSite);
-        Assert.Same(control, Assert.Single(result.Controls));
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-
-        // Set null.
-        control.SetSite(null);
-        Assert.Null(control.PageSite);
-        Assert.Same(control, Assert.Single(result.Controls));
-        Assert.Equal(0, control.LoadComponentCallCount);
-        Assert.Equal(0, control.Loading);
-        Assert.False(control.LoadRequired);
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_ShowHelp_Invoke_Nop()
-    {
-        using var control = new SubComponentEditorPage();
-        control.ShowHelp();
-
-        // Call again.
-        control.ShowHelp();
-    }
-
-    [WinFormsFact]
-    public void ComponentEditorPage_SupportsHelp_Invoke_ReturnsFalse()
-    {
-        using var control = new SubComponentEditorPage();
-        Assert.False(control.SupportsHelp());
-
-        // Call again.
-        Assert.False(control.SupportsHelp());
-    }
-
-    private class SubComponentEditorPage : ComponentEditorPage
-    {
-        public new const int ScrollStateAutoScrolling = ComponentEditorPage.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ComponentEditorPage.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ComponentEditorPage.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ComponentEditorPage.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ComponentEditorPage.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new IComponent Component
-        {
-            get => base.Component;
-            set => base.Component = value;
-        }
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new bool FirstActivate
-        {
-            get => base.FirstActivate;
-            set => base.FirstActivate = value;
-        }
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new int Loading
-        {
-            get => base.Loading;
-            set => base.Loading = value;
-        }
-
-        public new bool LoadRequired
-        {
-            get => base.LoadRequired;
-            set => base.LoadRequired = value;
-        }
-
-        public new IComponentEditorPageSite PageSite
-        {
-            get => base.PageSite;
-            set => base.PageSite = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new void EnterLoadingMode() => base.EnterLoadingMode();
-
-        public new void ExitLoadingMode() => base.ExitLoadingMode();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new Control GetControl() => base.GetControl();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new IComponent GetSelectedComponent() => base.GetSelectedComponent();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsFirstActivate() => base.IsFirstActivate();
-
-        public new bool IsLoading() => base.IsLoading();
-
-        public int LoadComponentCallCount { get; set; }
-
-        protected override void LoadComponent() => LoadComponentCallCount++;
-
-        public int PreProcessMessageCallCount { get; set; }
-
-        public override bool PreProcessMessage(ref Message msg)
-        {
-            PreProcessMessageCallCount++;
-            return true;
-        }
-
-        public new void ReloadComponent() => base.ReloadComponent();
-
-        public int SaveComponentCallCount { get; set; }
-
-        protected override void SaveComponent() => SaveComponentCallCount++;
-
-        public new void SetDirty() => base.SetDirty();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/DesignerAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/DesignerAttributeTests.cs
deleted file mode 100644
index b96cf01fd05..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/DesignerAttributeTests.cs
+++ /dev/null
@@ -1,193 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Reflection;
-using Xunit.Abstractions;
-
-namespace System.Windows.Forms.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class DesignerAttributeTests
-{
-    private const string AssemblyRef_SystemWinforms = $"System.Windows.Forms, Version={FXAssembly.Version}, Culture=neutral, PublicKeyToken={AssemblyRef.MicrosoftPublicKey}";
-    private const string AssemblyRef_SystemWinformsDesign = $"System.Windows.Forms.Design, Version={FXAssembly.Version}, Culture=neutral, PublicKeyToken={AssemblyRef.MicrosoftPublicKey}";
-    private readonly ITestOutputHelper _output;
-
-    private static readonly ImmutableHashSet<string> SkipList = ImmutableHashSet.Create(new string[]
-    {
-        // https://github.com/dotnet/winforms/issues/2412
-        "System.Windows.Forms.Design.ControlBindingsConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-
-        // https://github.com/dotnet/winforms/issues/2411
-        "System.Windows.Forms.Design.AxDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.AxHostDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.BindingNavigatorDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.BindingSourceDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataGridViewColumnDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataGridViewComboBoxColumnDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataGridViewDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.FlowLayoutPanelDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.FolderBrowserDialogDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.NotifyIconDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.PropertyGridDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.SaveFileDialogDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.StatusBarDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.ToolStripContainerDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.ToolStripContentPanelDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.ToolStripPanelDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.TrackBarDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.WebBrowserDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-
-        // https://github.com/dotnet/winforms/issues/1115
-        "System.Windows.Forms.Design.DataGridViewColumnCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataGridViewColumnDataPropertyNameEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataGridViewComponentEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.DataMemberListEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.StyleCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.ToolStripCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.ToolStripImageIndexEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-        "System.Windows.Forms.Design.TreeNodeCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
-    });
-
-    public DesignerAttributeTests(ITestOutputHelper output)
-    {
-        _output = output;
-    }
-
-    public static IEnumerable<object[]> GetAttributeOfType_TestData(string assembly, Type attributeType)
-    {
-        foreach (var type in Assembly.Load(assembly).GetTypes())
-            foreach (var attribute in type.GetCustomAttributes(attributeType, false))
-                yield return new[] { type, attribute };
-    }
-
-    public static IEnumerable<object[]> GetAttributeOfTypeAndProperty_TestData(string assembly, Type attributeType)
-    {
-        foreach (var type in Assembly.Load(assembly).GetTypes())
-        {
-            foreach (var attribute in type.GetCustomAttributes(attributeType, false))
-                yield return new[] { type.FullName, attribute };
-
-            foreach (var property in type.GetProperties())
-                foreach (var attribute in property.GetCustomAttributes(attributeType, false))
-                    yield return new[] { $"{type.FullName}, property {property.Name}", attribute };
-        }
-    }
-
-    public static IEnumerable<object[]> GetAttributeWithType_TestData(string assembly, Type attributeType)
-    {
-        foreach (var type in Assembly.Load(assembly).GetTypes())
-            foreach (var attribute in type.GetCustomAttributes(attributeType, false))
-                yield return new[] { type, attribute };
-    }
-
-    public static IEnumerable<object[]> GetAttributeWithProperty_TestData(string assembly, Type attributeType)
-    {
-        foreach (var type in Assembly.Load(assembly).GetTypes())
-            foreach (var property in type.GetProperties())
-                foreach (var attribute in property.GetCustomAttributes(attributeType, false))
-                    yield return new[] { property, attribute };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeOfType_TestData), AssemblyRef_SystemWinforms, typeof(DesignerAttribute))]
-    public void DesignerAttributes_DesignerAttribute_TypeExists(Type annotatedType, DesignerAttribute attribute)
-    {
-        var type = Type.GetType(attribute.DesignerTypeName, false);
-        _output.WriteLine($"{annotatedType.FullName}: {attribute.DesignerTypeName} --> {type?.FullName}");
-
-        if (SkipList.Contains(attribute.DesignerTypeName))
-        {
-            Assert.Null(type);
-            return;
-        }
-
-        Assert.NotNull(type);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeOfType_TestData), AssemblyRef.SystemDrawing, typeof(DesignerSerializerAttribute))]
-    [MemberData(nameof(GetAttributeOfType_TestData), AssemblyRef_SystemWinforms, typeof(DesignerSerializerAttribute))]
-    [MemberData(nameof(GetAttributeOfType_TestData), AssemblyRef_SystemWinformsDesign, typeof(DesignerSerializerAttribute))]
-    public void DesignerAttributes_DesignerSerializerAttribute_TypeExists(Type annotatedType, DesignerSerializerAttribute attribute)
-    {
-        var type = Type.GetType(attribute.SerializerTypeName, false);
-        _output.WriteLine($"{annotatedType.FullName}: {attribute.SerializerTypeName} --> {type?.FullName}");
-
-        if (SkipList.Contains(attribute.SerializerTypeName))
-        {
-            Assert.Null(type);
-            return;
-        }
-
-        Assert.NotNull(type);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeWithType_TestData), AssemblyRef_SystemWinforms, typeof(DefaultPropertyAttribute))]
-    public void DesignerAttributes_DefaultPropertyAttribute_PropertyExists(Type type, DefaultPropertyAttribute attribute)
-    {
-        var propertyInfo = type.GetProperty(attribute.Name);
-        _output.WriteLine($"{type.FullName}: {attribute.Name} --> {propertyInfo?.Name}");
-
-        Assert.NotNull(propertyInfo);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeWithType_TestData), AssemblyRef_SystemWinforms, typeof(DefaultBindingPropertyAttribute))]
-    public void DesignerAttributes_DefaultBindingPropertyAttribute_PropertyExists(Type type, DefaultBindingPropertyAttribute attribute)
-    {
-        var propertyInfo = type.GetProperty(attribute.Name);
-        _output.WriteLine($"{type.FullName}: {attribute.Name} --> {propertyInfo?.Name}");
-
-        Assert.NotNull(propertyInfo);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeWithType_TestData), AssemblyRef_SystemWinforms, typeof(DefaultEventAttribute))]
-    public void DesignerAttributes_DefaultEventAttribute_EventExists(Type type, DefaultEventAttribute attribute)
-    {
-        var eventInfo = type.GetEvent(attribute.Name);
-        _output.WriteLine($"{type.FullName}: {attribute.Name} --> {eventInfo?.Name}");
-
-        Assert.NotNull(eventInfo);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeOfTypeAndProperty_TestData), AssemblyRef.SystemDrawing, typeof(TypeConverterAttribute))]
-    [MemberData(nameof(GetAttributeOfTypeAndProperty_TestData), AssemblyRef_SystemWinforms, typeof(TypeConverterAttribute))]
-    public void DesignerAttributes_TypeConverterAttribute_TypeExists(string subject, TypeConverterAttribute attribute)
-    {
-        var type = Type.GetType(attribute.ConverterTypeName, false);
-        _output.WriteLine($"{subject}: {attribute.ConverterTypeName} --> {type?.Name}");
-
-        if (SkipList.Contains(attribute.ConverterTypeName))
-        {
-            Assert.Null(type);
-            return;
-        }
-
-        Assert.NotNull(type);
-    }
-
-    [Theory]
-    [MemberData(nameof(GetAttributeOfTypeAndProperty_TestData), AssemblyRef.SystemDrawing, typeof(EditorAttribute))]
-    [MemberData(nameof(GetAttributeOfTypeAndProperty_TestData), AssemblyRef_SystemWinforms, typeof(EditorAttribute))]
-    public void DesignerAttributes_EditorAttribute_TypeExists(string subject, EditorAttribute attribute)
-    {
-        var type = Type.GetType(attribute.EditorTypeName, false);
-        _output.WriteLine($"{subject}: {attribute.EditorTypeName} --> {type?.Name}");
-
-        if (SkipList.Contains(attribute.EditorTypeName))
-        {
-            Assert.Null(type);
-            return;
-        }
-
-        Assert.NotNull(type);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/EventsTabTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/EventsTabTests.cs
deleted file mode 100644
index 24ba7ba92a3..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/EventsTabTests.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using Moq;
-
-namespace System.Windows.Forms.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class EventsTabTests
-{
-    [Fact]
-    public void EventsTab_Ctor_IServiceProvider()
-    {
-        var mockServiceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
-        var tab = new EventsTab(mockServiceProvider.Object);
-        Assert.NotNull(tab.Bitmap);
-        Assert.Null(tab.Components);
-        Assert.Equal("Events", tab.HelpKeyword);
-        Assert.Equal("Events", tab.TabName);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void EventsTab_CanExtend_Invoke_ReturnsTrue(object extendee)
-    {
-        var mockServiceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
-        var tab = new EventsTab(mockServiceProvider.Object);
-        Assert.True(tab.CanExtend(extendee));
-    }
-
-    public static IEnumerable<object[]> GetDefaultProperty_TestData()
-    {
-        var nullMockServiceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
-        nullMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(null);
-
-        var invalidMockServiceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
-        invalidMockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(new object());
-
-        foreach (IServiceProvider provider in new object[] { null, nullMockServiceProvider.Object, invalidMockServiceProvider.Object })
-        {
-            yield return new object[] { null, provider, null };
-            yield return new object[] { new object(), provider, null };
-            yield return new object[] { new ClassWithDefaultEvent(), provider, null };
-
-            var nullMockSite = new Mock<ISite>();
-            nullMockSite
-                .Setup(s => s.GetService(typeof(IEventBindingService)))
-                .Returns(null);
-            yield return new object[] { new ClassWithDefaultEvent { Site = nullMockSite.Object }, provider, null };
-
-            var invalidMockSite = new Mock<ISite>();
-            invalidMockSite
-                .Setup(s => s.GetService(typeof(IEventBindingService)))
-                .Returns(new object());
-            yield return new object[] { new ClassWithDefaultEvent { Site = invalidMockSite.Object }, provider, null };
-
-            PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(ClassWithDefaultEvent))[0];
-            var mockEventBindingService = new Mock<IEventBindingService>();
-            mockEventBindingService
-                .Setup(e => e.GetEventProperty(TypeDescriptor.GetDefaultEvent(typeof(ClassWithDefaultEvent))))
-                .Returns(descriptor);
-            var mockSite = new Mock<ISite>();
-            mockSite
-                .Setup(s => s.GetService(typeof(IEventBindingService)))
-                .Returns(mockEventBindingService.Object);
-            yield return new object[] { new Component { Site = mockSite.Object }, provider, null };
-            yield return new object[] { new ClassWithDefaultEvent { Site = mockSite.Object }, provider, descriptor };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDefaultProperty_TestData))]
-    public void EventsTab_GetDefaultProperty_Invoke_ReturnsExpected(object obj, IServiceProvider serviceProvider, object expected)
-    {
-        var tab = new EventsTab(serviceProvider);
-        Assert.Same(expected, tab.GetDefaultProperty(obj));
-
-        // Call again to test caching behavior.
-        Assert.Same(expected, tab.GetDefaultProperty(obj));
-    }
-
-    public static IEnumerable<object[]> GetDefaultProperty_IDesignerEventService_TestData()
-    {
-        var nullMockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        nullMockDesignerHost
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(null);
-        var invalidMockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        invalidMockDesignerHost
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(new object());
-
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(typeof(ClassWithDefaultEvent))[0];
-        var mockEventBindingService = new Mock<IEventBindingService>();
-        mockEventBindingService
-            .Setup(e => e.GetEventProperty(TypeDescriptor.GetDefaultEvent(typeof(ClassWithDefaultEvent))))
-            .Returns(descriptor);
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(s => s.GetService(typeof(IEventBindingService)))
-            .Returns(mockEventBindingService.Object);
-
-        foreach (ActiveDesignerEventArgs e in new object[]
-            {
-                new ActiveDesignerEventArgs(null, nullMockDesignerHost.Object),
-                new ActiveDesignerEventArgs(null, invalidMockDesignerHost.Object),
-                new ActiveDesignerEventArgs(null, mockDesignerHost.Object)
-            })
-        {
-            yield return new object[] { null, e, null };
-            yield return new object[] { new object(), e, null };
-            yield return new object[] { new Component(), e, null };
-            yield return new object[] { new ClassWithDefaultEvent(), e, e?.NewDesigner == mockDesignerHost.Object ? descriptor : null };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetDefaultProperty_IDesignerEventService_TestData))]
-    public void EventsTab_GetDefaultProperty_IDesignerEventService_Success(object obj, ActiveDesignerEventArgs e, object expected)
-    {
-        using var service = new CustomDesignerEventService();
-        var mockServiceProvider = new Mock<IServiceProvider>(MockBehavior.Strict);
-        mockServiceProvider
-            .Setup(p => p.GetService(typeof(IDesignerEventService)))
-            .Returns(service);
-        var tab = new EventsTab(mockServiceProvider.Object);
-        Assert.Null(tab.GetDefaultProperty(obj));
-
-        service.OnActiveDesignerChanged(e);
-        Assert.Equal(expected, tab.GetDefaultProperty(obj));
-    }
-
-    private class CustomDesignerEventService : Component, IDesignerEventService
-    {
-        public IDesignerHost ActiveDesigner { get; set; }
-        public DesignerCollection Designers { get; }
-
-        public event ActiveDesignerEventHandler ActiveDesignerChanged
-        {
-            add => Events.AddHandler(nameof(ActiveDesignerChanged), value);
-            remove => Events.RemoveHandler(nameof(ActiveDesignerChanged), value);
-        }
-
-        public event DesignerEventHandler DesignerCreated
-        {
-            add => Events.AddHandler(nameof(DesignerCreated), value);
-            remove => Events.RemoveHandler(nameof(DesignerCreated), value);
-        }
-
-        public event DesignerEventHandler DesignerDisposed
-        {
-            add => Events.AddHandler(nameof(DesignerDisposed), value);
-            remove => Events.RemoveHandler(nameof(DesignerDisposed), value);
-        }
-
-        public event EventHandler SelectionChanged
-        {
-            add => Events.AddHandler(nameof(SelectionChanged), value);
-            remove => Events.RemoveHandler(nameof(SelectionChanged), value);
-        }
-
-        public void OnActiveDesignerChanged(ActiveDesignerEventArgs e)
-        {
-            ActiveDesignerEventHandler handler = (ActiveDesignerEventHandler)Events[nameof(ActiveDesignerChanged)];
-            handler?.Invoke(this, e);
-        }
-    }
-
-    [DefaultEvent(nameof(ClassWithDefaultEvent.Event))]
-    private class ClassWithDefaultEvent : Component
-    {
-        public int Value { get; set; }
-
-        public event EventHandler Event
-        {
-            add { }
-            remove { }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/PropertyTabTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/PropertyTabTests.cs
deleted file mode 100644
index aa5364dcef5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/PropertyTabTests.cs
+++ /dev/null
@@ -1,214 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertyTabTests
-{
-    [Fact]
-    public void PropertyTab_Ctor_Default()
-    {
-        var tab = new SubPropertyTab();
-        Assert.Null(tab.Bitmap);
-        Assert.Null(tab.Components);
-        Assert.Equal("TabName", tab.HelpKeyword);
-    }
-
-    [Fact]
-    public void PropertyTab_Bitmap_GetValidMultipleTimes_ReturnsExpected()
-    {
-        var tab = new CustomPropertyTab();
-        Bitmap bitmap = tab.Bitmap;
-        Assert.Equal(new Size(11, 22), tab.Bitmap.Size);
-        Assert.Same(bitmap, tab.Bitmap);
-    }
-
-    [Fact]
-    public void PropertyTab_Bitmap_GetInvalidMultipleTimes_ReturnsNull()
-    {
-        var tab = new SubPropertyTab();
-        Assert.Null(tab.Bitmap);
-        Assert.Null(tab.Bitmap);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void PropertyTab_CanExtend_Invoke_ReturnsTrue(object extendee)
-    {
-        var tab = new SubPropertyTab();
-        Assert.True(tab.CanExtend(extendee));
-    }
-
-    [Fact]
-    public void PropertyTab_Dispose_WithBitmap_Success()
-    {
-        var tab = new CustomPropertyTab();
-        Bitmap bitmap = tab.Bitmap;
-
-        tab.Dispose();
-        Assert.Null(tab.Bitmap);
-        Assert.Throws<ArgumentException>(() => bitmap.Size);
-
-        // Dispose again.
-        tab.Dispose();
-        Assert.Null(tab.Bitmap);
-        Assert.Throws<ArgumentException>(() => bitmap.Size);
-    }
-
-    [Fact]
-    public void PropertyTab_Dispose_NoBitmap_Success()
-    {
-        var tab = new SubPropertyTab();
-        tab.Dispose();
-        Assert.Null(tab.Bitmap);
-
-        // Dispose again.
-        tab.Dispose();
-        Assert.Null(tab.Bitmap);
-    }
-
-    [Theory]
-    [BoolData]
-    public void PropertyTab_Dispose_NoBitmapDisposing_Success(bool disposing)
-    {
-        var tab = new SubPropertyTab();
-        tab.Dispose(disposing);
-        Assert.Null(tab.Bitmap);
-
-        // Dispose again.
-        tab.Dispose(disposing);
-        Assert.Null(tab.Bitmap);
-    }
-
-    [Theory]
-    [BoolData]
-    public void PropertyTab_Dispose_WithBitmapDisposing_Success(bool disposing)
-    {
-        var tab = new CustomPropertyTab();
-        Bitmap bitmap = tab.Bitmap;
-
-        tab.Dispose(disposing);
-        if (disposing)
-        {
-            Assert.Null(tab.Bitmap);
-            Assert.Throws<ArgumentException>(() => bitmap.Size);
-        }
-        else
-        {
-            Assert.Same(bitmap, tab.Bitmap);
-        }
-
-        // Dispose again.
-        tab.Dispose(disposing);
-        if (disposing)
-        {
-            Assert.Null(tab.Bitmap);
-            Assert.Throws<ArgumentException>(() => bitmap.Size);
-        }
-        else
-        {
-            Assert.Same(bitmap, tab.Bitmap);
-        }
-    }
-
-    [Fact]
-    public void PropertyTab_GetDefaultProperty_InvokeWithoutDefaultProperty_ReturnsExpected()
-    {
-        var tab = new SubPropertyTab();
-        Assert.Null(tab.GetDefaultProperty(new ClassWithoutDefaultProperty()));
-    }
-
-    [Fact]
-    public void PropertyTab_GetDefaultProperty_InvokeWithDefaultProperty_ReturnsExpected()
-    {
-        var tab = new SubPropertyTab();
-        Assert.Equal("Value", tab.GetDefaultProperty(new ClassWithDefaultProperty()).Name);
-    }
-
-    [Fact]
-    public void PropertyTab_GetDefaultProperty_InvokeNullComponent_ReturnsExpected()
-    {
-        var tab = new SubPropertyTab();
-        Assert.Null(tab.GetDefaultProperty(null));
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void PropertyTab_GetProperties_Invoke_ReturnsExpected(object component)
-    {
-        var tab = new SubPropertyTab();
-        PropertyDescriptorCollection result = TypeDescriptor.GetProperties(typeof(ClassWithDefaultProperty));
-        int callCount = 0;
-        tab.GetPropertiesAction = (componentResult, attributesResult) =>
-        {
-            Assert.Same(component, componentResult);
-            Assert.Null(attributesResult);
-            callCount++;
-
-            return result;
-        };
-        Assert.Same(result, tab.GetProperties(component));
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> GetProperties_Attributes_TestData()
-    {
-        yield return new object[] { null, null, null };
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        yield return new object[] { mockContext.Object, new object(), Array.Empty<Attribute>() };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetProperties_Attributes_TestData))]
-    public void PropertyTab_GetProperties_InvokeWithAttributes_ReturnsExpected(ITypeDescriptorContext context, object component, Attribute[] attributes)
-    {
-        var tab = new SubPropertyTab();
-        PropertyDescriptorCollection result = TypeDescriptor.GetProperties(typeof(ClassWithDefaultProperty));
-        int callCount = 0;
-        tab.GetPropertiesAction = (componentResult, attributesResult) =>
-        {
-            Assert.Same(component, componentResult);
-            Assert.Same(attributes, attributesResult);
-            callCount++;
-
-            return result;
-        };
-        Assert.Same(result, tab.GetProperties(context, component, attributes));
-        Assert.Equal(1, callCount);
-    }
-
-    private class SubPropertyTab : PropertyTab
-    {
-        public override string TabName => "TabName";
-
-        public Func<object, Attribute[], PropertyDescriptorCollection> GetPropertiesAction { get; set; }
-
-        public override PropertyDescriptorCollection GetProperties(object component, Attribute[] attributes)
-        {
-            return GetPropertiesAction(component, attributes);
-        }
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-    }
-
-    private class CustomPropertyTab : SubPropertyTab
-    {
-    }
-
-    private class ClassWithoutDefaultProperty
-    {
-        public int Value { get; set; }
-    }
-
-    [DefaultProperty(nameof(ClassWithDefaultProperty.Value))]
-    private class ClassWithDefaultProperty
-    {
-        public int Value { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ToolStripItemDesignerAvailabilityAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ToolStripItemDesignerAvailabilityAttributeTests.cs
deleted file mode 100644
index fbd9df6a7f8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/ToolStripItemDesignerAvailabilityAttributeTests.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class ToolStripItemDesignerAvailabilityAttributeTests
-{
-    [Fact]
-    public void ToolStripItemDesignerAvailabilityAttribute_Ctor_Default()
-    {
-        var attribute = new ToolStripItemDesignerAvailabilityAttribute();
-        Assert.Equal(ToolStripItemDesignerAvailability.None, attribute.ItemAdditionVisibility);
-        Assert.True(attribute.IsDefaultAttribute());
-    }
-
-    [Theory]
-    [EnumData<ToolStripItemDesignerAvailability>]
-    [InvalidEnumData<ToolStripItemDesignerAvailability>]
-    public void ToolStripItemDesignerAvailabilityAttribute_Ctor_ToolStripItemDesignerAvailability(ToolStripItemDesignerAvailability visibility)
-    {
-        var attribute = new ToolStripItemDesignerAvailabilityAttribute(visibility);
-        Assert.Equal(visibility, attribute.ItemAdditionVisibility);
-    }
-
-    [Fact]
-    public void ToolStripItemDesignerAvailabilityAttribute_Default_Get_ReturnsExpected()
-    {
-        ToolStripItemDesignerAvailabilityAttribute attribute = ToolStripItemDesignerAvailabilityAttribute.Default;
-        Assert.Same(attribute, ToolStripItemDesignerAvailabilityAttribute.Default);
-        Assert.Equal(ToolStripItemDesignerAvailability.None, attribute.ItemAdditionVisibility);
-        Assert.True(attribute.IsDefaultAttribute());
-    }
-
-    public static IEnumerable<object[]> IsDefaultAttribute_TestData()
-    {
-        yield return new object[] { new ToolStripItemDesignerAvailabilityAttribute(), true };
-        yield return new object[] { new ToolStripItemDesignerAvailabilityAttribute(ToolStripItemDesignerAvailability.All), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsDefaultAttribute_TestData))]
-    public void ToolStripItemDesignerAvailabilityAttribute_IsDefaultAttribute_Invoke_ReturnsExpected(ToolStripItemDesignerAvailabilityAttribute attribute, bool expected)
-    {
-        Assert.Equal(expected, attribute.IsDefaultAttribute());
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        var attribute = new ToolStripItemDesignerAvailabilityAttribute(ToolStripItemDesignerAvailability.All);
-        yield return new object[] { attribute, attribute, true };
-        yield return new object[] { attribute, new ToolStripItemDesignerAvailabilityAttribute(ToolStripItemDesignerAvailability.All), true };
-        yield return new object[] { attribute, new ToolStripItemDesignerAvailabilityAttribute(ToolStripItemDesignerAvailability.None), false };
-
-        yield return new object[] { attribute, new object(), false };
-        yield return new object[] { attribute, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void ToolStripItemDesignerAvailabilityAttribute_Equals_Invoke_ReturnsExpected(ToolStripItemDesignerAvailabilityAttribute attribute, object obj, bool expected)
-    {
-        if (obj is ToolStripItemDesignerAvailability other)
-        {
-            Assert.Equal(expected, attribute.GetHashCode().Equals(other.GetHashCode()));
-        }
-
-        Assert.Equal(expected, attribute.Equals(obj));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsComponentEditorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsComponentEditorTests.cs
deleted file mode 100644
index 254eabb9fc8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Design/WindowsFormsComponentEditorTests.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Design.Tests;
-
-// NB: doesn't require thread affinity
-public class WindowsFormsComponentEditorTests
-{
-    public static IEnumerable<object[]> EditComponent_ObjectIWin32Window_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { Array.Empty<Type>(), null, null };
-
-        var mockWindow = new Mock<IWin32Window>(MockBehavior.Strict);
-        yield return new object[] { null, new object(), mockWindow.Object };
-        yield return new object[] { Array.Empty<Type>(), new object(), mockWindow.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditComponent_ObjectIWin32Window_TestData))]
-    public void WindowsFormsComponentEditor_EditComponent_InvokeObjectIWin32Window_ReturnsFalse(Type[] pages, object component, IWin32Window owner)
-    {
-        var editor = new CustomWindowsFormsComponentEditor
-        {
-            GetComponentEditorPagesResult = pages
-        };
-        Assert.False(editor.EditComponent(component, owner));
-    }
-
-    public static IEnumerable<object[]> EditComponent_ITypeDescriptorContextObject_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { Array.Empty<Type>(), null, null };
-
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        yield return new object[] { null, mockContext.Object, new object() };
-        yield return new object[] { Array.Empty<Type>(), mockContext.Object, new object() };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditComponent_ITypeDescriptorContextObject_TestData))]
-    public void WindowsFormsComponentEditor_EditComponent_InvokeITypeDescriptorContextObject_ReturnsFalse(Type[] pages, ITypeDescriptorContext context, object component)
-    {
-        var editor = new CustomWindowsFormsComponentEditor
-        {
-            GetComponentEditorPagesResult = pages
-        };
-        Assert.False(editor.EditComponent(context, component));
-    }
-
-    public static IEnumerable<object[]> EditComponent_ITypeDescriptorContextObjectIWin32Window_TestData()
-    {
-        yield return new object[] { null, null, null, null };
-        yield return new object[] { Array.Empty<Type>(), null, null, null };
-
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        var mockWindow = new Mock<IWin32Window>(MockBehavior.Strict);
-        yield return new object[] { null, mockContext.Object, new object(), mockWindow.Object };
-        yield return new object[] { Array.Empty<Type>(), mockContext.Object, new object(), mockWindow.Object };
-    }
-
-    [Theory]
-    [MemberData(nameof(EditComponent_ITypeDescriptorContextObjectIWin32Window_TestData))]
-    public void WindowsFormsComponentEditor_EditComponent_InvokeITypeDescriptorContextObjectIWin32Window_ReturnsFalse(Type[] pages, ITypeDescriptorContext context, object component, IWin32Window owner)
-    {
-        var editor = new CustomWindowsFormsComponentEditor
-        {
-            GetComponentEditorPagesResult = pages
-        };
-        Assert.False(editor.EditComponent(context, component, owner));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("component")]
-    public void EditComponent_NonComponentWithPages_ThrowsArgumentException(object component)
-    {
-        var editor = new CustomWindowsFormsComponentEditor
-        {
-            GetComponentEditorPagesResult = new Type[] { typeof(int) }
-        };
-        Assert.Throws<ArgumentException>("component", () => editor.EditComponent(component, null));
-        Assert.Throws<ArgumentException>("component", () => editor.EditComponent(null, component));
-        Assert.Throws<ArgumentException>("component", () => editor.EditComponent(null, component, null));
-    }
-
-    [Fact]
-    public void WindowsFormsComponentEditor_GetComponentEditorPages_Invoke_ReturnsNull()
-    {
-        var editor = new SubWindowsFormsComponentEditor();
-        Assert.Null(editor.GetComponentEditorPages());
-    }
-
-    [Fact]
-    public void WindowsFormsComponentEditor_GetInitialComponentEditorPageIndex_Invoke_ReturnsZero()
-    {
-        var editor = new SubWindowsFormsComponentEditor();
-        Assert.Equal(0, editor.GetInitialComponentEditorPageIndex());
-    }
-
-    private class SubWindowsFormsComponentEditor : WindowsFormsComponentEditor
-    {
-        public new Type[] GetComponentEditorPages() => base.GetComponentEditorPages();
-
-        public new int GetInitialComponentEditorPageIndex() => base.GetInitialComponentEditorPageIndex();
-    }
-
-    private class CustomWindowsFormsComponentEditor : WindowsFormsComponentEditor
-    {
-        public Type[] GetComponentEditorPagesResult { get; set; }
-
-        protected override Type[] GetComponentEditorPages() => GetComponentEditorPagesResult;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DirectionButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DirectionButtonAccessibleObjectTests.cs
deleted file mode 100644
index 358f13c6c18..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DirectionButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class DirectionButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DirectionButtonAccessibleObject_Invoke_DoesNothing_IfControlIsNotCreated_InDomainUpDown(int childId)
-    {
-        using DomainUpDown domainUpDown = new();
-        domainUpDown.Items.AddRange(new string[] { "First", "Second", "Third" });
-        domainUpDown.SelectedIndex = 1; // Select the second item
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-        directionButton.Invoke();
-
-        // The selected index is not changed
-        Assert.Equal(1, domainUpDown.SelectedIndex);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void DirectionButtonAccessibleObject_Invoke_ChangesValue_InDomainUpDown(int childId, int expectedIndex)
-    {
-        using DomainUpDown domainUpDown = new();
-        domainUpDown.Items.AddRange(new string[] { "First", "Second", "Third" });
-        domainUpDown.SelectedIndex = 1; // Select the second item
-        domainUpDown.CreateControl();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-        directionButton.Invoke();
-
-        // The selected index is not changed
-        Assert.Equal(expectedIndex, domainUpDown.SelectedIndex);
-        Assert.True(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DirectionButtonAccessibleObject_Invoke_DoesNothing_IfControlIsNotCreated_InNumericUpDown(int childId)
-    {
-        using NumericUpDown numericUpDown = new();
-        int testValue = 10;
-        numericUpDown.Value = testValue;
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-        directionButton.Invoke();
-
-        // The value is not changed
-        Assert.Equal(testValue, numericUpDown.Value);
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 10, 11)]
-    [InlineData(1, 10, 9)]
-    public void DirectionButtonAccessibleObject_Invoke_ChangesValue_InNumericUpDown(int childId, int testValue, int expected)
-    {
-        using NumericUpDown numericUpDown = new();
-        numericUpDown.Value = testValue;
-        numericUpDown.CreateControl();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-        directionButton.Invoke();
-
-        Assert.Equal(expected, numericUpDown.Value);
-        Assert.True(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, null)]
-    public void DirectionButtonAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_InDomainUpDown(int childId, int? expectedChildId)
-    {
-        using DomainUpDown domainUpDown = new();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-
-        if (expectedChildId is null)
-        {
-            Assert.Null(directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        }
-        else
-        {
-            AccessibleObject expected = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(expectedChildId.Value);
-            Assert.Equal(expected, directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        }
-
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, null)]
-    public void DirectionButtonAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_InNumericUpDown(int childId, int? expectedChildId)
-    {
-        using NumericUpDown numericUpDown = new();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-
-        if (expectedChildId is null)
-        {
-            Assert.Null(directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        }
-        else
-        {
-            AccessibleObject expected = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(expectedChildId.Value);
-            Assert.Equal(expected, directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        }
-
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, null)]
-    [InlineData(1, 0)]
-    public void DirectionButtonAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_InDomainUpDown(int childId, int? expectedChildId)
-    {
-        using DomainUpDown domainUpDown = new();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-
-        if (expectedChildId is null)
-        {
-            Assert.Null(directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        }
-        else
-        {
-            AccessibleObject expected = domainUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(expectedChildId.Value);
-            Assert.Equal(expected, directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        }
-
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, null)]
-    [InlineData(1, 0)]
-    public void DirectionButtonAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_InNumericUpDown(int childId, int? expectedChildId)
-    {
-        using NumericUpDown numericUpDown = new();
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject directionButton = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(childId);
-
-        if (expectedChildId is null)
-        {
-            Assert.Null(directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        }
-        else
-        {
-            AccessibleObject expected = numericUpDown.UpDownButtonsInternal.AccessibilityObject.GetChild(expectedChildId.Value);
-            Assert.Equal(expected, directionButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        }
-
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesConverterTests.cs
deleted file mode 100644
index 37e3f47ae21..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesConverterTests.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DockPaddingEdgesConverterTests
-{
-    [Fact]
-    public void DockPaddingEdgesConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        var converter = new ScrollableControl.DockPaddingEdgesConverter();
-        PropertyDescriptorCollection properties = converter.GetProperties(null);
-        Assert.Equal(5, properties.Count);
-        Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.All), properties[0].Name);
-        Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Left), properties[1].Name);
-        Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Top), properties[2].Name);
-        Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Right), properties[3].Name);
-        Assert.Equal(nameof(ScrollableControl.DockPaddingEdges.Bottom), properties[4].Name);
-    }
-
-    [Fact]
-    public void DockPaddingEdgesConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new ScrollableControl.DockPaddingEdgesConverter();
-        Assert.True(converter.GetPropertiesSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesTests.cs
deleted file mode 100644
index ed95b711ef1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockPaddingEdgesTests.cs
+++ /dev/null
@@ -1,490 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class DockPaddingEdgesTests
-{
-    [WinFormsTheory]
-    [InlineData(-2, -2, -2, -2, 0, 0, 0, 0, 0)]
-    [InlineData(-1, -1, -1, -1, 0, 0, 0, 0, 0)]
-    [InlineData(0, -1, -1, -1, 0, 0, 0, 0, 0)]
-    [InlineData(-1, 0, -1, -1, 0, 0, 0, 0, 0)]
-    [InlineData(-1, -1, 0, -1, 0, 0, 0, 0, 0)]
-    [InlineData(-1, -1, -1, 0, 0, 0, 0, 0, 0)]
-    [InlineData(0, 0, 0, 0, 0, 0, 0, 0, 0)]
-    [InlineData(1, 1, 1, 1, 1, 1, 1, 1, 1)]
-    [InlineData(1, 2, 3, 4, 0, 1, 2, 3, 4)]
-    public void DockPaddingEdges_Properties_Get_ReturnsExpected(int left, int top, int right, int bottom, int expectedAll, int expectedLeft, int expectedTop, int expectedRight, int expectedBottom)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(left, top, right, bottom)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        Assert.Equal(expectedAll, padding.All);
-        Assert.Equal(expectedLeft, padding.Left);
-        Assert.Equal(expectedTop, padding.Top);
-        Assert.Equal(expectedRight, padding.Right);
-        Assert.Equal(expectedBottom, padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0, -1)]
-    [InlineData(-1, 0, -1)]
-    [InlineData(0, 0, 0)]
-    [InlineData(1, 1, 1)]
-    public void DockPaddingEdges_All_SetWithOwner_GetReturnsExpected(int value, int expectedValue, int expectedPaddingAll)
-    {
-        using var owner = new ScrollableControl();
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        padding.All = value;
-        Assert.Equal(expectedValue, padding.All);
-        Assert.Equal(expectedValue, padding.Left);
-        Assert.Equal(expectedValue, padding.Top);
-        Assert.Equal(expectedValue, padding.Right);
-        Assert.Equal(expectedValue, padding.Bottom);
-        Assert.Equal(expectedPaddingAll, owner.Padding.All);
-        Assert.Equal(expectedValue, owner.Padding.Left);
-        Assert.Equal(expectedValue, owner.Padding.Top);
-        Assert.Equal(expectedValue, owner.Padding.Right);
-        Assert.Equal(expectedValue, owner.Padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void DockPaddingEdges_All_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        padding.All = value;
-        Assert.Equal(value, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void DockPaddingEdges_Left_SetWithOwner_GetReturnsExpected(int value, int expectedLeft)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        padding.Left = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(expectedLeft, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-        Assert.Equal(-1, owner.Padding.All);
-        Assert.Equal(expectedLeft, owner.Padding.Left);
-        Assert.Equal(2, owner.Padding.Top);
-        Assert.Equal(3, owner.Padding.Right);
-        Assert.Equal(4, owner.Padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void DockPaddingEdges_Left_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        padding.Left = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void DockPaddingEdges_Top_SetWithOwner_GetReturnsExpected(int value, int expectedTop)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        padding.Top = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(expectedTop, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-        Assert.Equal(-1, owner.Padding.All);
-        Assert.Equal(1, owner.Padding.Left);
-        Assert.Equal(expectedTop, owner.Padding.Top);
-        Assert.Equal(3, owner.Padding.Right);
-        Assert.Equal(4, owner.Padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void DockPaddingEdges_Top_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        padding.Top = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void DockPaddingEdges_Right_SetWithOwner_GetReturnsExpected(int value, int expectedRight)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        padding.Right = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(expectedRight, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-        Assert.Equal(-1, owner.Padding.All);
-        Assert.Equal(1, owner.Padding.Left);
-        Assert.Equal(2, owner.Padding.Top);
-        Assert.Equal(expectedRight, owner.Padding.Right);
-        Assert.Equal(4, owner.Padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void DockPaddingEdges_Right_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        padding.Right = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void DockPaddingEdges_Bottom_SetWithOwner_GetReturnsExpected(int value, int expectedBottom)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        padding.Bottom = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(expectedBottom, padding.Bottom);
-        Assert.Equal(-1, owner.Padding.All);
-        Assert.Equal(1, owner.Padding.Left);
-        Assert.Equal(2, owner.Padding.Top);
-        Assert.Equal(3, owner.Padding.Right);
-        Assert.Equal(expectedBottom, owner.Padding.Bottom);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void DockPaddingEdges_Bottom_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        padding.Bottom = value;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        ScrollableControl.DockPaddingEdges CreatePadding(int left, int top, int right, int bottom)
-        {
-            var owner = new ScrollableControl
-            {
-                Padding = new Padding(left, top, right, bottom)
-            };
-            return owner.DockPadding;
-        }
-
-        ScrollableControl.DockPaddingEdges CreateClonedPadding(int left, int top, int right, int bottom)
-        {
-            ICloneable cloneable = CreatePadding(left, top, right, bottom);
-            return Assert.IsType<ScrollableControl.DockPaddingEdges>(cloneable.Clone());
-        }
-
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreatePadding(1, 2, 3, 4), true };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 3, 4), true };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreatePadding(1, 1, 3, 4), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreateClonedPadding(1, 1, 3, 4), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreatePadding(1, 2, 2, 4), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 2, 4), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreatePadding(1, 2, 3, 5), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 3, 5), false };
-
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreatePadding(1, 2, 3, 4), true };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 3, 4), true };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreatePadding(1, 1, 3, 4), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreateClonedPadding(1, 1, 3, 4), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreatePadding(1, 2, 2, 4), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 2, 4), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreatePadding(1, 2, 3, 5), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), CreateClonedPadding(1, 2, 3, 5), false };
-
-        yield return new object[] { CreatePadding(1, 2, 3, 4), new object(), false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), new object(), false };
-        yield return new object[] { CreatePadding(1, 2, 3, 4), null, false };
-        yield return new object[] { CreateClonedPadding(1, 2, 3, 4), null, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Equals_TestData))]
-    public void DockPaddingEdges_Equals_Invoke_ReturnsExpected(ScrollableControl.DockPaddingEdges padding, object other, bool expected)
-    {
-        if (other is ScrollableControl.DockPaddingEdges)
-        {
-            Assert.Equal(expected, padding.GetHashCode().Equals(other.GetHashCode()));
-        }
-
-        Assert.Equal(expected, padding.Equals(other));
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_GetHashCode_InvokeWithOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        Assert.NotEqual(0, padding.GetHashCode());
-        Assert.Equal(padding.GetHashCode(), padding.GetHashCode());
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_GetHashCode_InvokeWithoutOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        Assert.NotEqual(0, padding.GetHashCode());
-        Assert.Equal(padding.GetHashCode(), padding.GetHashCode());
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_Clone_InvokeWithOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_Clone_InvokeWithoutOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original1 = owner.DockPadding;
-        ICloneable original2 = (ICloneable)original1.Clone();
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original2.Clone();
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_ToString_InvokeWithOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString());
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_ToString_InvokeWithoutOwner_ReturnsExpected()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ICloneable original = owner.DockPadding;
-        ScrollableControl.DockPaddingEdges padding = (ScrollableControl.DockPaddingEdges)original.Clone();
-        Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString());
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_AllPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(ScrollableControl.DockPaddingEdges.All)];
-        Assert.True(property.CanResetValue(padding));
-        Assert.True(property.ShouldSerializeValue(padding));
-        property.ResetValue(padding);
-
-        Assert.Equal(0, padding.All);
-        Assert.Equal(0, padding.Left);
-        Assert.Equal(0, padding.Top);
-        Assert.Equal(0, padding.Right);
-        Assert.Equal(0, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_LeftPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(ScrollableControl.DockPaddingEdges.Left)];
-        Assert.True(property.CanResetValue(padding));
-        Assert.True(property.ShouldSerializeValue(padding));
-        property.ResetValue(padding);
-
-        Assert.Equal(0, padding.All);
-        Assert.Equal(0, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_TopPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(ScrollableControl.DockPaddingEdges.Top)];
-        Assert.True(property.CanResetValue(padding));
-        Assert.True(property.ShouldSerializeValue(padding));
-        property.ResetValue(padding);
-
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(0, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_RightPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(ScrollableControl.DockPaddingEdges.Right)];
-        Assert.True(property.CanResetValue(padding));
-        Assert.True(property.ShouldSerializeValue(padding));
-        property.ResetValue(padding);
-
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(0, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_BottomPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        using var owner = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        ScrollableControl.DockPaddingEdges padding = owner.DockPadding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(ScrollableControl.DockPaddingEdges.Bottom)];
-        Assert.True(property.CanResetValue(padding));
-        Assert.True(property.ShouldSerializeValue(padding));
-        property.ResetValue(padding);
-
-        Assert.Equal(0, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(0, padding.Bottom);
-    }
-
-    [WinFormsFact]
-    public void DockPaddingEdges_GetTypeConverter_ReturnsDockPaddingEdgesConverter()
-    {
-        Assert.IsType<ScrollableControl.DockPaddingEdgesConverter>(TypeDescriptor.GetConverter(typeof(ScrollableControl.DockPaddingEdges)));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockingAttributeTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockingAttributeTests.cs
deleted file mode 100644
index a87b59a0eba..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DockingAttributeTests.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DockingAttributeTests
-{
-    [Fact]
-    public void DockingAttribute_Ctor_Default()
-    {
-        var attribute = new DockingAttribute();
-        Assert.Equal(DockingBehavior.Never, attribute.DockingBehavior);
-        Assert.True(attribute.IsDefaultAttribute());
-    }
-
-    [Theory]
-    [EnumData<DockingBehavior>]
-    [InvalidEnumData<DockingBehavior>]
-    public void DockingAttribute_Ctor_DockingBehavior(DockingBehavior dockingBehavior)
-    {
-        var attribute = new DockingAttribute(dockingBehavior);
-        Assert.Equal(dockingBehavior, attribute.DockingBehavior);
-        Assert.Equal(dockingBehavior == DockingBehavior.Never, attribute.IsDefaultAttribute());
-    }
-
-    [Fact]
-    public void DockingAttribute_Default_Get_ReturnsExpected()
-    {
-        DockingAttribute attribute = DockingAttribute.Default;
-        Assert.Same(attribute, DockingAttribute.Default);
-        Assert.Equal(DockingBehavior.Never, attribute.DockingBehavior);
-        Assert.True(attribute.IsDefaultAttribute());
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        var attribute = new DockingAttribute(DockingBehavior.Ask);
-        yield return new object[] { attribute, attribute, true };
-        yield return new object[] { attribute, new DockingAttribute(DockingBehavior.Ask), true };
-        yield return new object[] { attribute, new DockingAttribute(DockingBehavior.Never), false };
-
-        yield return new object[] { attribute, new object(), false };
-        yield return new object[] { attribute, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void DockingAttribute_Equals_Invoke_ReturnsExpected(DockingAttribute attribute, object other, bool expected)
-    {
-        Assert.Equal(expected, attribute.Equals(other));
-        if (other is DockingAttribute)
-        {
-            Assert.Equal(expected, attribute.GetHashCode().Equals(other.GetHashCode()));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownAccessibleObjectTests.cs
deleted file mode 100644
index dbc4a99ad15..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownAccessibleObjectTests.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class DomainUpDownAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DomainUpDownAccessibleObject_Ctor_Default()
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        AccessibleObject accessibleObject = domainUpDown.AccessibilityObject;
-        Assert.NotNull(accessibleObject);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDownAccessibleObject_ControlType_IsSpinner_IfAccessibleRoleIsDefault()
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        // AccessibleRole is not set = Default
-
-        object actual = domainUpDown.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.SpinnerControlTypeId, actual);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDownAccessibleObject_Role_IsSpinButton_ByDefault()
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = domainUpDown.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.SpinButton, actual);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDownAccessibleObject_GetPropertyValue_IsKeyboardFocusable_ReturnsTrue()
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        AccessibleObject accessibleObject = domainUpDown.AccessibilityObject;
-
-        bool isKeyboardFocusable = (bool)accessibleObject.GetPropertyValue(Interop.UiaCore.UIA.IsKeyboardFocusablePropertyId);
-        Assert.True(isKeyboardFocusable);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDownAccessibleObject_GetPropertyValue_IsKeyboardFocusable_WhenDisabled_ReturnsFalse()
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        AccessibleObject accessibleObject = domainUpDown.AccessibilityObject;
-
-        domainUpDown.Enabled = false;
-
-        bool isKeyboardFocusable = (bool)accessibleObject.GetPropertyValue(Interop.UiaCore.UIA.IsKeyboardFocusablePropertyId);
-        Assert.False(isKeyboardFocusable);
-    }
-
-    public static IEnumerable<object[]> DomainUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DomainUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void DomainUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        domainUpDown.AccessibleRole = role;
-
-        object actual = domainUpDown.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.SpinButton)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleStatePropertyId, AccessibleStates.None)]
-    [InlineData((int)UiaCore.UIA.ValueValuePropertyId, null)]
-    public void DomainUpDownAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using DomainUpDown domainUpDown = new DomainUpDown();
-        AccessibleObject accessibleObject = domainUpDown.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-}
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
deleted file mode 100644
index 42170420bd6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownTests.cs
+++ /dev/null
@@ -1,1510 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class DomainUpDownTests
-{
-    [WinFormsFact]
-    public void DomainUpDown_Ctor_Default()
-    {
-        using var control = new SubDomainUpDown();
-        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);
-        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);
-        }
-        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);
-        }
-
-        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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubDomainUpDown();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-
-        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);
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
-        }
-        else
-        {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE | WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
-        }
-
-        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);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void DomainUpDown_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new DomainUpDown
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void DomainUpDown_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new DomainUpDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new DomainUpDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_SelectedIndex_SetEmpty_Nop()
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, "Item1", "Item1", true)]
-    [InlineData(1, "Item2", "Item2", true)]
-    [InlineData(-1, null, "", false)]
-    public void DomainUpDown_SelectedIndex_SetNotEmpty_GetReturnsExpected(int value, object expected, string expectedText, bool expectedUserEdit)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, "Item1", "Item1", true)]
-    [InlineData(1, "Item2", "Item2", true)]
-    [InlineData(-1, null, "", false)]
-    public void DomainUpDown_SelectedIndex_SetUserEdit_GetReturnsExpected(int value, object expected, string expectedText, bool expectedUserEdit)
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_SelectedIndex_SetWithHandler_CallsSelectedItemChanged()
-    {
-        using var control = new DomainUpDown();
-        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);
-            textChangedCallCount++;
-        };
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(textChangedCallCount - 1, callCount);
-            callCount++;
-        };
-        control.TextChanged += textChangedHandler;
-        control.SelectedItemChanged += handler;
-
-        // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-
-        // Set none.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= textChangedHandler;
-        control.SelectedItemChanged -= handler;
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void DomainUpDown_SelectedIndex_SetInvalidValueEmpty_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new DomainUpDown();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void DomainUpDown_SelectedIndex_SetInvalidValueNotEmpty_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new DomainUpDown();
-        control.Items.Add("Item");
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("NoSuchItem")]
-    public void DomainUpDown_SelectedItem_SetEmpty_Nop(object value)
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Item1", 0, "Item1", "Item1", true)]
-    [InlineData("Item2", 1, "Item2", "Item2", true)]
-    [InlineData("NoSuchItem", -1, null, "", false)]
-    [InlineData(null, -1, null, "", false)]
-    public void DomainUpDown_SelectedItem_SetNotEmpty_GetReturnsExpected(object value, int expectedSelectedIndex, object expected, string expectedText, bool expectedUserEdit)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // 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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Item1", 0, "Item1", "Item1", true)]
-    [InlineData("Item2", 1, "Item2", "Item2", true)]
-    [InlineData("NoSuchItem", -1, null, "", false)]
-    [InlineData(null, -1, null, "", false)]
-    public void DomainUpDown_SelectedItem_SetUserEdit_GetReturnsExpected(object value, int expectedSelectedIndex, object expected, string expectedText, bool expectedUserEdit)
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-
-        // 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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_SelectedItem_SetWithHandler_CallsSelectedItemChanged()
-    {
-        using var control = new DomainUpDown();
-        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);
-            textChangedCallCount++;
-        };
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(textChangedCallCount - 1, callCount);
-            callCount++;
-        };
-        control.TextChanged += textChangedHandler;
-        control.SelectedItemChanged += handler;
-
-        // Set different.
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.SelectedItem = "Item2";
-        Assert.Equal("Item2", control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-
-        // Set none.
-        control.SelectedItem = null;
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= textChangedHandler;
-        control.SelectedItemChanged -= handler;
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Sorted_Set_TestData()
-    {
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            yield return new object[] { userEdit, true };
-            yield return new object[] { userEdit, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_Set_TestData))]
-    public void DomainUpDown_Sorted_Set_GetReturnsExpected(bool userEdit, bool value)
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-
-        // 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);
-
-        // 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);
-    }
-
-    public static IEnumerable<object[]> Sorted_WithItems_TestData()
-    {
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            yield return new object[] { userEdit, true, new string[] { "a", "a", "B", "c", "d" } };
-            yield return new object[] { userEdit, false, new string[] { "c", "B", "a", "a", "d" } };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_WithItems_TestData))]
-    public void DomainUpDown_Sorted_SetWithItems_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // 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);
-
-        // 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);
-    }
-
-    public static IEnumerable<object[]> Sorted_WithItemsWithSelection_TestData()
-    {
-        yield return new object[] { true, true, new string[] { "a", "a", "B", "c", "d" }, -1 };
-        yield return new object[] { false, true, new string[] { "a", "a", "B", "c", "d" }, 1 };
-        yield return new object[] { true, false, new string[] { "c", "B", "a", "a", "d" }, -1 };
-        yield return new object[] { false, false, new string[] { "c", "B", "a", "a", "d" }, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_WithItemsWithSelection_TestData))]
-    public void DomainUpDown_Sorted_SetWithItemsWithSelection_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems, int expectedSelectedIndex)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_Set_TestData))]
-    public void DomainUpDown_Sorted_SetWithHandle_GetReturnsExpected(bool userEdit, bool value)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_WithItems_TestData))]
-    public void DomainUpDown_Sorted_SetWithItemsWithHandle_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_WithItemsWithSelection_TestData))]
-    public void DomainUpDown_Sorted_SetWithItemsWithSelectionWithHandle_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems, int expectedSelectedIndex)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DomainUpDown_Wrap_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new DomainUpDown
-        {
-            Wrap = value
-        };
-        Assert.Equal(value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Wrap = value;
-        Assert.Equal(value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Wrap = !value;
-        Assert.Equal(!value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DomainUpDown_Wrap_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new DomainUpDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        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);
-
-        // 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);
-
-        // 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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDomainUpDown();
-        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);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubDomainUpDown
-        {
-            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);
-    }
-
-    public static IEnumerable<object[]> DownButton_TestData()
-    {
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            foreach (bool wrap in new bool[] { true, false })
-            {
-                yield return new object[] { userEdit, wrap };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DownButton_TestData))]
-    public void DomainUpDown_DownButton_InvokeWithoutItems_Nop(bool userEdit, bool wrap)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-
-        // Call again.
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DownButton_TestData))]
-    public void DomainUpDown_DownButton_InvokeEmpty_Nop(bool userEdit, bool wrap)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        Assert.Empty(control.Items);
-
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-
-        // Call again.
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-    }
-
-    public static IEnumerable<object[]> DownButton_WithItems_TestData()
-    {
-        yield return new object[] { true, true, 0 };
-        yield return new object[] { true, false, 2 };
-        yield return new object[] { false, true, 0 };
-        yield return new object[] { false, false, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DownButton_WithItems_TestData))]
-    public void DomainUpDown_DownButton_InvokeWithItems_Nop(bool userEdit, bool wrap, int expectedWrapSelectedIndex)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        control.Items.Add("a");
-        control.Items.Add("b");
-        control.Items.Add("c");
-
-        control.DownButton();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.DownButton();
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.DownButton();
-        Assert.Equal(2, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.DownButton();
-        Assert.Equal(expectedWrapSelectedIndex, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDomainUpDown();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubDomainUpDown.ScrollStateAutoScrolling, false)]
-    [InlineData(SubDomainUpDown.ScrollStateFullDrag, false)]
-    [InlineData(SubDomainUpDown.ScrollStateHScrollVisible, false)]
-    [InlineData(SubDomainUpDown.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubDomainUpDown.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void DomainUpDown_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubDomainUpDown();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void DomainUpDown_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubDomainUpDown();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubDomainUpDown();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [InlineData("cow", 0, 3)]
-    [InlineData("cow", 4, 3)]
-    [InlineData("foo", 0, 0)]
-    [InlineData("foo", 3, 4)]
-    [InlineData("foo", 4, 4)]
-    [InlineData("foo", 5, 0)]
-    [InlineData("foo", 100, 0)]
-    [InlineData("foo", -1, 4)]
-    [InlineData("foo", -100, 4)]
-    [InlineData("foo2", 0, 1)]
-    [InlineData("foo5", 0, -1)]
-    [InlineData("foo5", 4, -1)]
-    [InlineData("", 0, -1)]
-    public void DomainUpDown_MatchIndex(string text, int start, int expected)
-    {
-        using var control = new DomainUpDown();
-        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));
-    }
-
-    [WinFormsFact]
-    public void DomainUpDown_MatchIndex_NullText_ThrowsNullReferenceException()
-    {
-        using var control = new DomainUpDown();
-        control.Items.Add("item1");
-        Assert.Throws<NullReferenceException>(() => control.MatchIndex(null, false, 0));
-    }
-
-    public static IEnumerable<object[]> OnChanged_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnChanged_TestData))]
-    public void DomainUpDown_OnChanged_Invoke_CallsSelectedItemChanged(object source, EventArgs eventArgs)
-    {
-        using var control = new SubDomainUpDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedItemChanged += handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SelectedItemChanged -= handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnChanged_TestData))]
-    public void DomainUpDown_OnSelectedItemChanged_Invoke_CallsSelectedItemChanged(object source, EventArgs eventArgs)
-    {
-        using var control = new SubDomainUpDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedItemChanged += handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SelectedItemChanged -= handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> UpButton_TestData()
-    {
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            foreach (bool wrap in new bool[] { true, false })
-            {
-                yield return new object[] { userEdit, wrap };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpButton_TestData))]
-    public void DomainUpDown_UpButton_InvokeWithoutItems_Nop(bool userEdit, bool wrap)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-
-        // Call again.
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpButton_TestData))]
-    public void DomainUpDown_UpButton_InvokeEmpty_Nop(bool userEdit, bool wrap)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        Assert.Empty(control.Items);
-
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-
-        // Call again.
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-    }
-
-    public static IEnumerable<object[]> UpButton_WithItems_TestData()
-    {
-        yield return new object[] { true, true, 2, 1 };
-        yield return new object[] { true, false, 0, 0 };
-        yield return new object[] { false, true, 2, 1 };
-        yield return new object[] { false, false, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpButton_WithItems_TestData))]
-    public void DomainUpDown_UpButton_InvokeWithItems_Nop(bool userEdit, bool wrap, int expectedWrapSelectedIndex1, int expectedWrapSelectedIndex2)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        control.Items.Add("a");
-        control.Items.Add("b");
-        control.Items.Add("c");
-        control.SelectedIndex = 2;
-
-        control.UpButton();
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.UpButton();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.UpButton();
-        Assert.Equal(expectedWrapSelectedIndex1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-
-        // Call again.
-        control.UpButton();
-        Assert.Equal(expectedWrapSelectedIndex2, control.SelectedIndex);
-        Assert.False(control.UserEdit);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DomainUpDown_UpdateEditText_InvokeEmpty_Success(bool userEdit, bool changingText)
-    {
-        using var control = new SubDomainUpDown
-        {
-            UserEdit = userEdit,
-            ChangingText = changingText
-        };
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DomainUpDown_UpdateEditText_InvokeNotEmpty_Success(bool userEdit, bool changingText)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // Call again.
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void DomainUpDown_UpdateEditText_InvokeNotEmptyWithSelection_Success(bool userEdit, bool changingText)
-    {
-        using var control = new SubDomainUpDown();
-        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);
-
-        // Call again.
-        control.UpdateEditText();
-        Assert.Equal("Item1", control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public class SubDomainUpDown : DomainUpDown
-    {
-        public new const int ScrollStateAutoScrolling = DomainUpDown.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = DomainUpDown.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = DomainUpDown.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = DomainUpDown.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = DomainUpDown.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool ChangingText
-        {
-            get => base.ChangingText;
-            set => base.ChangingText = value;
-        }
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool UserEdit
-        {
-            get => base.UserEdit;
-            set => base.UserEdit = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnChanged(object source, EventArgs e) => base.OnChanged(source, e);
-
-        public new void OnTextBoxKeyPress(object source, KeyPressEventArgs e) => base.OnTextBoxKeyPress(source, e);
-
-        public new void OnSelectedItemChanged(object source, EventArgs e) => base.OnSelectedItemChanged(source, e);
-
-        public new void UpdateEditText() => base.UpdateEditText();
-
-        public new void ValidateEditText() => base.ValidateEditText();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropFormatTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropFormatTests.cs
deleted file mode 100644
index 128064aec31..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropFormatTests.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.ComTypes;
-using Windows.Win32.System.Ole;
-using static Interop;
-using IStream = Windows.Win32.System.Com.IStream;
-
-namespace System.Windows.Forms.Tests;
-
-public class DragDropFormatTests
-{
-    public static IEnumerable<object[]> DragDropFormat_TestData()
-    {
-        FORMATETC formatEtc = new()
-        {
-            cfFormat = (short)PInvoke.RegisterClipboardFormat("InShellDragLoop"),
-            dwAspect = DVASPECT.DVASPECT_CONTENT,
-            lindex = -1,
-            ptd = IntPtr.Zero,
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        STGMEDIUM medium = new()
-        {
-            pUnkForRelease = null,
-            tymed = TYMED.TYMED_HGLOBAL,
-            unionmember = PInvoke.GlobalAlloc(
-                GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT,
-                BOOL.Size)
-        };
-
-        SaveInDragLoopToHandle((HGLOBAL)medium.unionmember, inDragLoop: true);
-        yield return new object[] { formatEtc, medium };
-
-        MemoryStream memoryStream = new();
-        IStream.Interface iStream = new Ole32.GPStream(memoryStream);
-        formatEtc = new()
-        {
-            cfFormat = (short)PInvoke.RegisterClipboardFormat("DragContext"),
-            dwAspect = DVASPECT.DVASPECT_CONTENT,
-            lindex = -1,
-            ptd = IntPtr.Zero,
-            tymed = TYMED.TYMED_ISTREAM
-        };
-
-        medium = new()
-        {
-            pUnkForRelease = null,
-            tymed = TYMED.TYMED_ISTREAM,
-            unionmember = Marshal.GetIUnknownForObject(iStream)
-        };
-
-        yield return new object[] { formatEtc, medium };
-    }
-
-    [Theory]
-    [MemberData(nameof(DragDropFormat_TestData))]
-    public void DragDropFormat_Set_Dispose_ReturnsExpected(FORMATETC formatEtc, STGMEDIUM medium)
-    {
-        DragDropFormat dragDropFormat = default;
-
-        try
-        {
-            dragDropFormat = new DragDropFormat(formatEtc.cfFormat, medium, copyData: false);
-            dragDropFormat.Dispose();
-            int handleSize = (int)PInvoke.GlobalSize((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal(0, handleSize);
-            Assert.Null(dragDropFormat.Medium.pUnkForRelease);
-            Assert.Equal(TYMED.TYMED_NULL, dragDropFormat.Medium.tymed);
-            Assert.Equal(IntPtr.Zero, dragDropFormat.Medium.unionmember);
-        }
-        finally
-        {
-            dragDropFormat?.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DragDropFormat_TestData))]
-    public void DragDropFormat_Set_GetData_ReturnsExpected(FORMATETC formatEtc, STGMEDIUM medium)
-    {
-        DragDropFormat dragDropFormat = default;
-
-        try
-        {
-            dragDropFormat = new DragDropFormat(formatEtc.cfFormat, medium, copyData: false);
-            STGMEDIUM data = dragDropFormat.GetData();
-            Assert.Equal(medium.pUnkForRelease, data.pUnkForRelease);
-            Assert.Equal(medium.tymed, data.tymed);
-
-            switch (data.tymed)
-            {
-                case TYMED.TYMED_HGLOBAL:
-                case TYMED.TYMED_FILE:
-                case TYMED.TYMED_ENHMF:
-                case TYMED.TYMED_GDI:
-                case TYMED.TYMED_MFPICT:
-
-                    Assert.NotEqual(medium.unionmember, data.unionmember);
-                    break;
-
-                case TYMED.TYMED_ISTORAGE:
-                case TYMED.TYMED_ISTREAM:
-                case TYMED.TYMED_NULL:
-                default:
-
-                    Assert.Equal(medium.unionmember, data.unionmember);
-                    break;
-            }
-        }
-        finally
-        {
-            dragDropFormat?.Dispose();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DragDropFormat_TestData))]
-    public void DragDropFormat_Set_RefreshData_ReturnsExpected(FORMATETC formatEtc, STGMEDIUM medium)
-    {
-        DragDropFormat dragDropFormat = default;
-
-        try
-        {
-            dragDropFormat = new DragDropFormat(formatEtc.cfFormat, medium, copyData: false);
-            STGMEDIUM dataRefresh = new()
-            {
-                pUnkForRelease = dragDropFormat.Medium.pUnkForRelease,
-                tymed = dragDropFormat.Medium.tymed,
-                unionmember = dragDropFormat.Medium.tymed switch
-                {
-                    TYMED.TYMED_HGLOBAL or TYMED.TYMED_FILE or TYMED.TYMED_ENHMF or TYMED.TYMED_GDI or TYMED.TYMED_MFPICT
-                    => PInvoke.OleDuplicateData(
-                        (HANDLE)dragDropFormat.Medium.unionmember,
-                        (CLIPBOARD_FORMAT)formatEtc.cfFormat,
-                        GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE | GLOBAL_ALLOC_FLAGS.GMEM_ZEROINIT),
-                    _ => dragDropFormat.Medium.unionmember,
-                }
-            };
-
-            dragDropFormat.RefreshData(formatEtc.cfFormat, dataRefresh, copyData: false);
-            STGMEDIUM data = dragDropFormat.GetData();
-
-            switch (dragDropFormat.Medium.tymed)
-            {
-                case TYMED.TYMED_HGLOBAL:
-                case TYMED.TYMED_FILE:
-                case TYMED.TYMED_ENHMF:
-                case TYMED.TYMED_GDI:
-                case TYMED.TYMED_MFPICT:
-
-                    Assert.NotEqual(dragDropFormat.Medium.unionmember, data.unionmember);
-                    break;
-
-                case TYMED.TYMED_ISTORAGE:
-                case TYMED.TYMED_ISTREAM:
-                case TYMED.TYMED_NULL:
-                default:
-
-                    Assert.Equal(dragDropFormat.Medium.unionmember, data.unionmember);
-                    break;
-            }
-        }
-        finally
-        {
-            dragDropFormat?.Dispose();
-        }
-    }
-
-    private static unsafe void SaveInDragLoopToHandle(HGLOBAL handle, bool inDragLoop)
-    {
-        try
-        {
-            void* basePtr = PInvoke.GlobalLock(handle);
-            *(BOOL*)basePtr = (BOOL)inDragLoop;
-        }
-        finally
-        {
-            PInvoke.GlobalUnlock(handle);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropHelperTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropHelperTests.cs
deleted file mode 100644
index db45f138509..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragDropHelperTests.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Numerics;
-using System.Runtime.InteropServices.ComTypes;
-using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
-
-namespace System.Windows.Forms.Tests;
-
-public class DragDropHelperTests
-{
-    public static IEnumerable<object[]> DragImage_DataObject_Bitmap_Point_bool_TestData()
-    {
-        yield return new object[] { new DataObject(), new Bitmap(1, 1), new Point(1, 1), false };
-        yield return new object[] { new DataObject(), null, new Point(1, 1), false };
-        yield return new object[] { new DataObject(), new Bitmap(1, 1), new Point(1, 1), true };
-    }
-
-    public static IEnumerable<object[]> DragImage_DataObject_GiveFeedbackEventArgs_TestData()
-    {
-        yield return new object[] { new DataObject(), new GiveFeedbackEventArgs(DragDropEffects.All, false, new Bitmap(1, 1), new Point(0, 0), false) };
-        yield return new object[] { new DataObject(), new GiveFeedbackEventArgs(DragDropEffects.All, false, null, new Point(0, 0), false) };
-        yield return new object[] { new DataObject(), new GiveFeedbackEventArgs(DragDropEffects.All, false, new Bitmap(1, 1), new Point(0, 0), true) };
-    }
-
-    public static IEnumerable<object[]> DropDescription_DragEventArgs_TestData()
-    {
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Invalid, string.Empty, string.Empty) };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.None, string.Empty, string.Empty) };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Copy, "Copy to %1", "Documents") };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Move, "Move to %1", "Documents") };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Link, "Create link in %1", "Documents") };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Label, "Update metadata in %1", "Document") };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.Warning, "A problem has been encountered", string.Empty) };
-        yield return new object[] { new DragEventArgs(new DataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Copy, DropImageType.NoImage, "Copy to %1", "Documents") };
-    }
-
-    public static IEnumerable<object[]> DropDescription_DataObject_DropImageType_string_string_TestData()
-    {
-        yield return new object[] { new DataObject(), DropImageType.Invalid, string.Empty, string.Empty };
-        yield return new object[] { new DataObject(), DropImageType.None, string.Empty, string.Empty };
-        yield return new object[] { new DataObject(), DropImageType.Copy, "Copy to %1", "Documents" };
-        yield return new object[] { new DataObject(), DropImageType.Move, "Move to %1", "Documents" };
-        yield return new object[] { new DataObject(), DropImageType.Link, "Create link in %1", "Documents" };
-        yield return new object[] { new DataObject(), DropImageType.Label, "Update metadata in %1", "Document" };
-        yield return new object[] { new DataObject(), DropImageType.Warning, "A problem has been encountered", string.Empty };
-        yield return new object[] { new DataObject(), DropImageType.NoImage, "Copy to %1", "Documents" };
-    }
-
-    public static IEnumerable<object[]> DropDescription_LengthExceedsMaxPath_TestData()
-    {
-        yield return new object[] { new DataObject(), DropImageType.Copy, new string('*', PInvoke.MAX_PATH), string.Empty };
-        yield return new object[] { new DataObject(), DropImageType.Copy, string.Empty, new string('*', PInvoke.MAX_PATH) };
-    }
-
-    public static IEnumerable<object[]> InDragLoop_TestData()
-    {
-        yield return new object[] { new DataObject(), true };
-        yield return new object[] { new DataObject(), false };
-    }
-
-    [Fact]
-    public void IsInDragLoop_NullComDataObject_ThrowsArgumentNullException()
-    {
-        IComDataObject dataObject = null;
-        Assert.Throws<ArgumentNullException>(nameof(dataObject), () => DragDropHelper.IsInDragLoop(dataObject));
-    }
-
-    [Fact]
-    public void IsInDragLoop_NullDataObject_ThrowsArgumentNullException()
-    {
-        IDataObject dataObject = null;
-        Assert.Throws<ArgumentNullException>(nameof(dataObject), () => DragDropHelper.IsInDragLoop(dataObject));
-    }
-
-    [Theory]
-    [InlineData(DragDropHelper.CF_DRAGIMAGEBITS, false)]
-    [InlineData(DragDropHelper.CF_DROPDESCRIPTION, false)]
-    [InlineData(DragDropHelper.CF_INSHELLDRAGLOOP, true)]
-    [InlineData(DragDropHelper.CF_ISSHOWINGTEXT, false)]
-    [InlineData(DragDropHelper.CF_USINGDEFAULTDRAGIMAGE, false)]
-    public void IsInDragLoopFormat_ReturnsExpected(string format, bool expectedIsInDragLoopFormat)
-    {
-        FORMATETC formatEtc = new()
-        {
-            cfFormat = (short)PInvoke.RegisterClipboardFormat(format),
-            dwAspect = DVASPECT.DVASPECT_CONTENT,
-            lindex = -1,
-            ptd = IntPtr.Zero,
-            tymed = TYMED.TYMED_HGLOBAL
-        };
-
-        Assert.Equal(expectedIsInDragLoopFormat, DragDropHelper.IsInDragLoopFormat(formatEtc));
-    }
-
-    [WinFormsTheory(Skip ="Causing issues with other tests on x86 from the command line")]
-    [MemberData(nameof(DragImage_DataObject_Bitmap_Point_bool_TestData))]
-    public unsafe void SetDragImage_DataObject_Bitmap_Point_bool_ReturnsExptected(DataObject dataObject, Bitmap dragImage, Point cursorOffset, bool useDefaultDragImage)
-    {
-        try
-        {
-            DragDropHelper.SetDragImage(dataObject, dragImage, cursorOffset, useDefaultDragImage);
-            DragDropFormat dragDropFormat = (DragDropFormat)dataObject.GetData(DragDropHelper.CF_DRAGIMAGEBITS);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            SHDRAGIMAGE* pDragImage = (SHDRAGIMAGE*)basePtr;
-            bool isDragImageNull = BitOperations.LeadingZeroCount((uint)(nint)pDragImage->hbmpDragImage).Equals(32);
-            Size dragImageSize = pDragImage->sizeDragImage;
-            Point offset = pDragImage->ptOffset;
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal(dragImage is null, isDragImageNull);
-            Assert.Equal(dragImage is null ? new Size(0, 0) : dragImage.Size, dragImageSize);
-            Assert.Equal(cursorOffset, offset);
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-
-    [WinFormsTheory(Skip = "Causing issues with other tests on x86 from the command line")]
-    [MemberData(nameof(DragImage_DataObject_GiveFeedbackEventArgs_TestData))]
-    public unsafe void SetDragImage_DataObject_GiveFeedbackEventArgs_ReturnsExptected(DataObject dataObject, GiveFeedbackEventArgs e)
-    {
-        try
-        {
-            DragDropHelper.SetDragImage(dataObject, e);
-            DragDropFormat dragDropFormat = (DragDropFormat)dataObject.GetData(DragDropHelper.CF_DRAGIMAGEBITS);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            SHDRAGIMAGE* pDragImage = (SHDRAGIMAGE*)basePtr;
-            bool isDragImageNull = BitOperations.LeadingZeroCount((uint)(nint)pDragImage->hbmpDragImage).Equals(32);
-            Size dragImageSize = pDragImage->sizeDragImage;
-            Point offset = pDragImage->ptOffset;
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal(e.DragImage is null, isDragImageNull);
-            Assert.Equal(e.DragImage is null ? new Size(0, 0) : e.DragImage.Size, dragImageSize);
-            Assert.Equal(e.CursorOffset, offset);
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-
-    [Fact(Skip = "Causing issues with other tests on x86 from the command line")]
-    public void SetDragImage_NonSTAThread_ThrowsInvalidOperationException()
-    {
-        Control.CheckForIllegalCrossThreadCalls = true;
-        Assert.Throws<InvalidOperationException>(() => DragDropHelper.SetDragImage(new DataObject(), new Bitmap(1, 1), new Point(0, 0), false));
-    }
-
-    [Fact]
-    public void SetDragImage_NullDataObject_ThrowsArgumentNullException()
-    {
-        DataObject dataObject = null;
-        Assert.Throws<ArgumentNullException>(nameof(dataObject),
-            () => DragDropHelper.SetDragImage(dataObject, new Bitmap(1, 1), new Point(0, 0), false));
-    }
-
-    [Fact]
-    public void SetDragImage_NullGiveFeedbackEventArgs_ThrowsArgumentNullException()
-    {
-        GiveFeedbackEventArgs e = null;
-        Assert.Throws<ArgumentNullException>(nameof(e), () => DragDropHelper.SetDragImage(new DataObject(), e));
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_DataObject_DropImageType_string_string_TestData))]
-    public unsafe void SetDropDescription_ClearDropDescription_ReturnsExpected(DataObject dataObject, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        try
-        {
-            DragDropHelper.SetDropDescription(dataObject, dropImageType, message, messageReplacementToken);
-            DragDropHelper.ClearDropDescription(dataObject);
-            DragDropFormat dragDropFormat = (DragDropFormat)dataObject.GetData(DragDropHelper.CF_DROPDESCRIPTION);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            DROPDESCRIPTION* pDropDescription = (DROPDESCRIPTION*)basePtr;
-            DROPIMAGETYPE type = pDropDescription->type;
-            string szMessage = pDropDescription->szMessage.ToString();
-            string szInsert = pDropDescription->szInsert.ToString();
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal(DROPIMAGETYPE.DROPIMAGE_INVALID, type);
-            Assert.Equal(string.Empty, szMessage);
-            Assert.Equal(string.Empty, szInsert);
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-
-    [Theory]
-    [InlineData(DropImageType.Invalid - 1)]
-    [InlineData(DropImageType.NoImage + 1)]
-    public void SetDropDescription_InvalidDropImageType_ThrowsArgumentNullException(DropImageType dropImageType)
-    {
-        Assert.Throws<InvalidEnumArgumentException>(nameof(dropImageType),
-            () => DragDropHelper.SetDropDescription(new DataObject(), dropImageType, string.Empty, string.Empty));
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_DataObject_DropImageType_string_string_TestData))]
-    public void SetDropDescription_IsInDragLoop_ReturnsExpected(DataObject dataObject, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        try
-        {
-            DragDropHelper.SetDropDescription(dataObject, dropImageType, message, messageReplacementToken);
-            Assert.True(DragDropHelper.IsInDragLoop(dataObject as IComDataObject));
-            Assert.True(DragDropHelper.IsInDragLoop(dataObject as IDataObject));
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_LengthExceedsMaxPath_TestData))]
-    public void SetDropDescription_LengthExceedsMaxPath_ThrowsArgumentOutOfRangeException(DataObject dataObject, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>(() => DragDropHelper.SetDropDescription(dataObject, dropImageType, message, messageReplacementToken));
-    }
-
-    [Fact]
-    public void SetDropDescription_NullDataObject_ThrowsArgumentNullException()
-    {
-        DataObject dataObject = null;
-        Assert.Throws<ArgumentNullException>(nameof(dataObject),
-            () => DragDropHelper.SetDropDescription(dataObject, DropImageType.Invalid, string.Empty, string.Empty));
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_DataObject_DropImageType_string_string_TestData))]
-    public void SetDropDescription_ReleaseDragDropFormats_ReturnsExptected(DataObject dataObject, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        DragDropHelper.SetDropDescription(dataObject, dropImageType, message, messageReplacementToken);
-        DragDropHelper.ReleaseDragDropFormats(dataObject);
-
-        foreach (string format in dataObject.GetFormats())
-        {
-            if (dataObject.GetData(format) is DragDropFormat dragDropFormat)
-            {
-                Assert.Equal(0, (int)PInvoke.GlobalSize((HGLOBAL)dragDropFormat.Medium.unionmember));
-                Assert.Null(dragDropFormat.Medium.pUnkForRelease);
-                Assert.Equal(TYMED.TYMED_NULL, dragDropFormat.Medium.tymed);
-                Assert.Equal(IntPtr.Zero, dragDropFormat.Medium.unionmember);
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_DragEventArgs_TestData))]
-    public unsafe void SetDropDescription_DragEventArgs_ReturnsExptected(DragEventArgs e)
-    {
-        try
-        {
-            DragDropHelper.SetDropDescription(e);
-            DragDropFormat dragDropFormat = (DragDropFormat)e.Data.GetData(DragDropHelper.CF_DROPDESCRIPTION);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            DROPDESCRIPTION* pDropDescription = (DROPDESCRIPTION*)basePtr;
-            DROPIMAGETYPE type = pDropDescription->type;
-            string szMessage = pDropDescription->szMessage.ToString();
-            string szInsert = pDropDescription->szInsert.ToString();
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal((DROPIMAGETYPE)e.DropImageType, type);
-            Assert.Equal(e.Message, szMessage);
-            Assert.Equal(e.MessageReplacementToken, szInsert);
-        }
-        finally
-        {
-            if (e.Data is IComDataObject dataObject)
-            {
-                DragDropHelper.ReleaseDragDropFormats(dataObject);
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DropDescription_DataObject_DropImageType_string_string_TestData))]
-    public unsafe void SetDropDescription_DataObject_DropImageType_string_string_ReturnsExptected(DataObject dataObject, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        try
-        {
-            DragDropHelper.SetDropDescription(dataObject, dropImageType, message, messageReplacementToken);
-            DragDropFormat dragDropFormat = (DragDropFormat)dataObject.GetData(DragDropHelper.CF_DROPDESCRIPTION);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            DROPDESCRIPTION* pDropDescription = (DROPDESCRIPTION*)basePtr;
-            DROPIMAGETYPE type = pDropDescription->type;
-            string szMessage = pDropDescription->szMessage.ToString();
-            string szInsert = pDropDescription->szInsert.ToString();
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal((DROPIMAGETYPE)dropImageType, type);
-            Assert.Equal(message, szMessage);
-            Assert.Equal(messageReplacementToken, szInsert);
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-
-    [Fact]
-    public unsafe void SetInDragLoop_NullDataObject_ThrowsArgumentNullException()
-    {
-        DataObject dataObject = null;
-        Assert.Throws<ArgumentNullException>(nameof(dataObject), () => DragDropHelper.SetInDragLoop(dataObject, true));
-    }
-
-    [Theory]
-    [MemberData(nameof(InDragLoop_TestData))]
-    public unsafe void SetInDragLoop_ReturnsExptected(DataObject dataObject, bool inDragLoop)
-    {
-        try
-        {
-            DragDropHelper.SetInDragLoop(dataObject, inDragLoop);
-            DragDropFormat dragDropFormat = (DragDropFormat)dataObject.GetData(DragDropHelper.CF_INSHELLDRAGLOOP);
-            void* basePtr = PInvoke.GlobalLock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            bool inShellDragLoop = (basePtr is not null) && (*(BOOL*)basePtr == true);
-            PInvoke.GlobalUnlock((HGLOBAL)dragDropFormat.Medium.unionmember);
-            Assert.Equal(inDragLoop, inShellDragLoop);
-        }
-        finally
-        {
-            DragDropHelper.ReleaseDragDropFormats(dataObject);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragEventArgsTests.cs
deleted file mode 100644
index b82cd1315e2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DragEventArgsTests.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DragEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects_TestData()
-    {
-        yield return new object[] { null, -1, -2, -3, (DragDropEffects)(DragDropEffects.None - 1), (DragDropEffects)(DragDropEffects.None - 1) };
-        yield return new object[] { new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move };
-    }
-
-    public static IEnumerable<object[]> Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects_DropImageType_string_string_TestData()
-    {
-        yield return new object[] { null, -1, -2, -3, (DragDropEffects)(DragDropEffects.None - 1), (DragDropEffects)(DragDropEffects.None - 1), (DropImageType.Invalid - 1), null, null };
-        yield return new object[] { new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move, DropImageType.Copy, "Move to %1", "Documents" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects_TestData))]
-    public void Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects(IDataObject data, int keyState, int x, int y, DragDropEffects allowedEffect, DragDropEffects effect)
-    {
-        var e = new DragEventArgs(data, keyState, x, y, allowedEffect, effect);
-        Assert.Equal(data, e.Data);
-        Assert.Equal(keyState, e.KeyState);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(allowedEffect, e.AllowedEffect);
-        Assert.Equal(effect, e.Effect);
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects_DropImageType_string_string_TestData))]
-    public void Ctor_IDataObject_Int_Int_Int_DragDropEffects_DragDropEffects_DropImageType_string_string(IDataObject data, int keyState, int x,
-        int y, DragDropEffects allowedEffect, DragDropEffects effect, DropImageType dropImageType, string message, string messageReplacementToken)
-    {
-        var e = new DragEventArgs(data, keyState, x, y, allowedEffect, effect, dropImageType, message, messageReplacementToken);
-        Assert.Equal(data, e.Data);
-        Assert.Equal(keyState, e.KeyState);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(allowedEffect, e.AllowedEffect);
-        Assert.Equal(effect, e.Effect);
-        Assert.Equal(dropImageType, e.DropImageType);
-        Assert.Equal(message, e.Message);
-        Assert.Equal(messageReplacementToken, e.MessageReplacementToken);
-    }
-
-    [Theory]
-    [InlineData(DragDropEffects.Copy)]
-    [InlineData((DragDropEffects)(DragDropEffects.None - 1))]
-    public void Effect_Set_GetReturnsExpected(DragDropEffects value)
-    {
-        var e = new DragEventArgs(new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move)
-        {
-            Effect = value
-        };
-        Assert.Equal(value, e.Effect);
-    }
-
-    [Theory]
-    [InlineData(DropImageType.Copy)]
-    [InlineData(DropImageType.Invalid - 1)]
-    public void DropImageType_Set_GetReturnsExpected(DropImageType value)
-    {
-        var e = new DragEventArgs(new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move, DropImageType.Copy, "Copy to %1", "Documents")
-        {
-            DropImageType = value
-        };
-        Assert.Equal(value, e.DropImageType);
-    }
-
-    [Theory]
-    [InlineData("Copy to %1")]
-    [InlineData(null)]
-    public void Message_Set_GetReturnsExpected(string value)
-    {
-        var e = new DragEventArgs(new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move, DropImageType.Copy, "Move to %1", "Documents")
-        {
-            Message = value
-        };
-        Assert.Equal(value, e.Message);
-    }
-
-    [Theory]
-    [InlineData("Documents")]
-    [InlineData(null)]
-    public void MessageReplacementToken_Set_GetReturnsExpected(string value)
-    {
-        var e = new DragEventArgs(new CustomDataObject(), 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move, DropImageType.Copy, "Move to %1", "Desktop")
-        {
-            MessageReplacementToken = value
-        };
-        Assert.Equal(value, e.MessageReplacementToken);
-    }
-
-    private class CustomDataObject : IDataObject
-    {
-        public object GetData(string format, bool autoConvert) => throw new NotImplementedException();
-
-        public object GetData(string format) => throw new NotImplementedException();
-
-        public object GetData(Type format) => throw new NotImplementedException();
-
-        public void SetData(string format, bool autoConvert, object data) => throw new NotImplementedException();
-
-        public void SetData(string format, object data) => throw new NotImplementedException();
-
-        public void SetData(Type format, object data) => throw new NotImplementedException();
-
-        public void SetData(object data) => throw new NotImplementedException();
-
-        public bool GetDataPresent(string format, bool autoConvert) => throw new NotImplementedException();
-
-        public bool GetDataPresent(string format) => throw new NotImplementedException();
-
-        public bool GetDataPresent(Type format) => throw new NotImplementedException();
-
-        public string[] GetFormats(bool autoConvert) => throw new NotImplementedException();
-
-        public string[] GetFormats() => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawItemEventArgsTests.cs
deleted file mode 100644
index 3d791638717..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawItemEventArgsTests.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DrawItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_Font_Rectangle_Int_DrawItemState_TestData()
-    {
-        yield return new object[] { null, Rectangle.Empty, -2, (DrawItemState)(DrawItemState.None - 1), SystemColors.HighlightText, SystemColors.Highlight };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), -1, DrawItemState.None, SystemColors.WindowText, SystemColors.Window };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(-1, 2, -3, -4), 0, DrawItemState.Selected, SystemColors.HighlightText, SystemColors.Highlight };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus, SystemColors.WindowText, SystemColors.Window };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus | DrawItemState.NoFocusRect, SystemColors.WindowText, SystemColors.Window };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_Font_Rectangle_Int_DrawItemState_TestData))]
-    public void DrawItemEventArgs_Ctor_Graphics_Font_Rectangle_Int_DrawItemState(Font font, Rectangle rect, int index, DrawItemState state, Color expectedForeColor, Color expectedBackColor)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawItemEventArgs(graphics, font, rect, index, state);
-            Assert.Equal(graphics, e.Graphics);
-            Assert.Equal(font, e.Font);
-            Assert.Equal(rect, e.Bounds);
-            Assert.Equal(index, e.Index);
-            Assert.Equal(state, e.State);
-            Assert.Equal(expectedForeColor, e.ForeColor);
-            Assert.Equal(expectedBackColor, e.BackColor);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_Font_Rectangle_Int_DrawItemState_Color_Color_TestData()
-    {
-        yield return new object[] { null, Rectangle.Empty, -2, (DrawItemState)(DrawItemState.None - 1), Color.Empty, Color.Empty };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), -1, DrawItemState.None, Color.Red, Color.Blue };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(-1, 2, -3, -4), 0, DrawItemState.Selected, Color.Red, Color.Blue };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus, Color.Red, Color.Blue };
-        yield return new object[] { SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 1, DrawItemState.Focus | DrawItemState.NoFocusRect, Color.Red, Color.Blue };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_Font_Rectangle_Int_DrawItemState_Color_Color_TestData))]
-    public void DrawItemEventArgs_Ctor_Graphics_Font_Rectangle_Int_DrawItemState_Color_Color(Font font, Rectangle rect, int index, DrawItemState state, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new DrawItemEventArgs(graphics, font, rect, index, state, foreColor, backColor);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(font, e.Font);
-        Assert.Equal(rect, e.Bounds);
-        Assert.Equal(index, e.Index);
-        Assert.Equal(state, e.State);
-        Assert.Equal((state & DrawItemState.Selected) == DrawItemState.Selected ? SystemColors.HighlightText : foreColor, e.ForeColor);
-        Assert.Equal((state & DrawItemState.Selected) == DrawItemState.Selected ? SystemColors.Highlight : backColor, e.BackColor);
-    }
-
-    [Fact]
-    public void DrawItemEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new DrawItemEventArgs(null, SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 0, DrawItemState.None));
-        Assert.Throws<ArgumentNullException>("graphics", () => new DrawItemEventArgs(null, SystemFonts.DefaultFont, new Rectangle(1, 2, 3, 4), 0, DrawItemState.None, Color.Red, Color.Blue));
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.None };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.Selected };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.Focus };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.Focus | DrawItemState.Selected };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.Focus | DrawItemState.NoFocusRect };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), DrawItemState.Focus | DrawItemState.NoFocusRect | DrawItemState.Selected };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.None };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.Selected };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.Focus };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.Focus | DrawItemState.Selected };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.Focus | DrawItemState.NoFocusRect };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), DrawItemState.Focus | DrawItemState.NoFocusRect | DrawItemState.Selected };
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawItemEventArgs_DrawBackground_Invoke_Success(Rectangle bounds, DrawItemState state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawItemEventArgs(graphics, SystemFonts.DefaultFont, bounds, -1, state);
-            e.DrawBackground();
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawItemEventArgs_DrawFocusRectangle_Invoke_Success(Rectangle bounds, DrawItemState state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawItemEventArgs(graphics, SystemFonts.DefaultFont, bounds, -1, state);
-            e.DrawFocusRectangle();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewColumnHeaderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewColumnHeaderEventArgsTests.cs
deleted file mode 100644
index b7e64db8b31..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewColumnHeaderEventArgsTests.cs
+++ /dev/null
@@ -1,131 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DrawListViewColumnHeaderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_Rectangle_Int_ColumnHeader_ListViewItemStates_Color_Color_Font_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, -2, null, (DrawItemState)(ListViewItemStates.Checked - 1), Color.Empty, Color.Empty, null };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), -1, new ColumnHeader(), ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new Rectangle(-1, 2, -3, -4), 0, new ColumnHeader(), ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1, new ColumnHeader(), ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_Rectangle_Int_ColumnHeader_ListViewItemStates_Color_Color_Font_TestData))]
-    public void DrawListViewColumnHeaderEventArgs_Ctor_Graphics_Rectangle_Int_ColumnHeader_ListViewItemStates_Color_Color_Font(Rectangle bounds, int columnIndex, ColumnHeader header, ListViewItemStates state, Color foreColor, Color backColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, bounds, columnIndex, header, state, foreColor, backColor, font);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Equal(bounds, e.Bounds);
-            Assert.Equal(columnIndex, e.ColumnIndex);
-            Assert.Same(header, e.Header);
-            Assert.Equal(state, e.State);
-            Assert.Equal(foreColor, e.ForeColor);
-            Assert.Equal(backColor, e.BackColor);
-            Assert.Equal(font, e.Font);
-            Assert.False(e.DrawDefault);
-        }
-    }
-
-    [Fact]
-    public void DrawListViewColumnHeaderEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new DrawListViewColumnHeaderEventArgs(null, new Rectangle(1, 2, 3, 4), 0, new ColumnHeader(), ListViewItemStates.Default, Color.Red, Color.Blue, SystemFonts.DefaultFont));
-    }
-
-    [Theory]
-    [BoolData]
-    public void DrawListViewColumnHeaderEventArgs_DrawDefault_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, new Rectangle(1, 2, 3, 4), -1, new ColumnHeader(), ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont)
-            {
-                DrawDefault = value
-            };
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set same.
-            e.DrawDefault = value;
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set different.
-            e.DrawDefault = !value;
-            Assert.Equal(!value, e.DrawDefault);
-        }
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ColumnHeader(), ListViewItemStates.Default, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ColumnHeader(), ListViewItemStates.Default, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ColumnHeader(), ListViewItemStates.Default, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-    }
-
-    [Theory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewColumnHeaderEventArgs_DrawBackground_Invoke_Success(Rectangle bounds, ColumnHeader header, ListViewItemStates state, Color foreColor, Color backColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, bounds, -1, header, state, foreColor, backColor, font);
-            e.DrawBackground();
-        }
-    }
-
-    [Theory]
-    [InlineData(HorizontalAlignment.Left)]
-    [InlineData(HorizontalAlignment.Center)]
-    [InlineData(HorizontalAlignment.Right)]
-    public void DrawListViewColumnHeaderEventArgs_DrawText_Invoke_Success(HorizontalAlignment textAlign)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var header = new ColumnHeader { TextAlign = textAlign };
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, new Rectangle(1, 2, 3, 4), -1, header, ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont);
-            e.DrawText();
-        }
-    }
-
-    [Fact]
-    public void DrawListViewColumnHeaderEventArgs_DrawText_InvokeTextFormatFlags_Success()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, new Rectangle(1, 2, 3, 4), -1, new ColumnHeader(), ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont);
-            e.DrawText(TextFormatFlags.Bottom);
-        }
-    }
-
-    public static IEnumerable<object[]> NullHeader_TestData()
-    {
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), 0, ListViewItemStates.Default, Color.Empty, Color.Empty, null };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), -1, ListViewItemStates.Checked, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-    }
-
-    [Theory]
-    [MemberData(nameof(NullHeader_TestData))]
-    public void DrawListViewColumnHeaderEventArgs_DrawText_NullHeader_Success(Rectangle bounds, int columnIndex, ListViewItemStates state, Color foreColor, Color backColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewColumnHeaderEventArgs(graphics, bounds, columnIndex, null, state, foreColor, backColor, font);
-            e.DrawText();
-            e.DrawText(TextFormatFlags.Left);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewItemEventArgsTests.cs
deleted file mode 100644
index caa524fe1a7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewItemEventArgsTests.cs
+++ /dev/null
@@ -1,161 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DrawListViewItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, -2, (ListViewItemStates)(ListViewItemStates.Checked - 1) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), -1, ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, 2, -3, -4), 0, ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1, ListViewItemStates.Checked };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates_TestData))]
-    public void DrawListViewItemEventArgs_Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates(Rectangle bounds, int itemIndex, ListViewItemStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var item = new ListViewItem();
-            var e = new DrawListViewItemEventArgs(graphics, item, bounds, itemIndex, state);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Equal(bounds, e.Bounds);
-            Assert.Equal(itemIndex, e.ItemIndex);
-            Assert.Equal(state, e.State);
-            Assert.False(e.DrawDefault);
-        }
-    }
-
-    [Fact]
-    public void DrawListViewItemEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new DrawListViewItemEventArgs(null, new ListViewItem(), new Rectangle(1, 2, 3, 4), 0, ListViewItemStates.Default));
-    }
-
-    [Fact]
-    public void DrawListViewItemEventArgs_Ctor_NullItem_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("item", () => new DrawListViewItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), 0, ListViewItemStates.Default));
-        }
-    }
-
-    [Theory]
-    [BoolData]
-    public void DrawListViewItemEventArgs_DrawDefault_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewItemEventArgs(graphics, new ListViewItem(), new Rectangle(1, 2, 3, 4), -1, ListViewItemStates.Checked)
-            {
-                DrawDefault = value
-            };
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set same.
-            e.DrawDefault = value;
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set different.
-            e.DrawDefault = !value;
-            Assert.Equal(!value, e.DrawDefault);
-        }
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { new ListViewItem(), new Rectangle(1, 2, 3, 4), ListViewItemStates.Default };
-        yield return new object[] { new ListViewItem(), new Rectangle(1, 2, 3, 4), ListViewItemStates.Focused };
-        yield return new object[] { new ListViewItem(), new Rectangle(1, 2, 3, 4), ListViewItemStates.Checked };
-        yield return new object[] { new ListViewItem(), Rectangle.Empty, ListViewItemStates.Default };
-        yield return new object[] { new ListViewItem(), Rectangle.Empty, ListViewItemStates.Focused };
-        yield return new object[] { new ListViewItem(), Rectangle.Empty, ListViewItemStates.Checked };
-        yield return new object[] { new ListViewItem(), new Rectangle(-1, -2, -3, -4), ListViewItemStates.Default };
-        yield return new object[] { new ListViewItem(), new Rectangle(-1, -2, -3, -4), ListViewItemStates.Focused };
-        yield return new object[] { new ListViewItem(), new Rectangle(-1, -2, -3, -4), ListViewItemStates.Checked };
-
-        foreach (View view in new View[] { View.Details, View.List })
-        {
-            var listView = new ListView { View = view };
-            var listViewItem = new ListViewItem();
-            listView.Items.Add(listViewItem);
-            yield return new object[] { listViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Default };
-            yield return new object[] { listViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Focused };
-            yield return new object[] { listViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Checked };
-
-            var subItemsItem = new ListViewItem();
-            subItemsItem.SubItems.Add(new ListViewItem.ListViewSubItem());
-            listView.Items.Add(subItemsItem);
-            yield return new object[] { subItemsItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Default };
-            yield return new object[] { subItemsItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Focused };
-            yield return new object[] { subItemsItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Checked };
-
-            var fullRowSelectListView = new ListView { View = view, FullRowSelect = true };
-            var fullRowSelectListViewItem = new ListViewItem();
-            fullRowSelectListViewItem.SubItems.Add(new ListViewItem.ListViewSubItem());
-            fullRowSelectListView.Items.Add(fullRowSelectListViewItem);
-            yield return new object[] { fullRowSelectListViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Default };
-            yield return new object[] { fullRowSelectListViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Focused };
-            yield return new object[] { fullRowSelectListViewItem, new Rectangle(1, 2, 3, 4), ListViewItemStates.Checked };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewItemEventArgs_DrawBackground_Invoke_Success(ListViewItem item, Rectangle bounds, ListViewItemStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewItemEventArgs(graphics, item, bounds, -1, state);
-            e.DrawBackground();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewItemEventArgs_DrawFocusRectangle_HasGraphicsFocused_Success(ListViewItem item, Rectangle bounds, ListViewItemStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewItemEventArgs(graphics, item, bounds, -1, state);
-            e.DrawFocusRectangle();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewItemEventArgs_DrawText_Invoke_Success(ListViewItem item, Rectangle bounds, ListViewItemStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewItemEventArgs(graphics, item, bounds, -1, state);
-            e.DrawText();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewItemEventArgs_DrawText_InvokeTextFormatFlags(ListViewItem item, Rectangle bounds, ListViewItemStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewItemEventArgs(graphics, item, bounds, -1, state);
-            e.DrawText(TextFormatFlags.Bottom);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewSubItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewSubItemEventArgsTests.cs
deleted file mode 100644
index f7834499ff1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawListViewSubItemEventArgsTests.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class DrawListViewSubItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, null, new ListViewItem.ListViewSubItem(), -2, -2, null, (ListViewItemStates)(ListViewItemStates.Checked - 1) };
-        yield return new object[] { Rectangle.Empty, new ListViewItem(), new ListViewItem.ListViewSubItem(), -2, -2, null, (ListViewItemStates)(ListViewItemStates.Checked - 1) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, -1, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), new ListViewItem.ListViewSubItem(), -1, -1, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, 2, -3, -4), new ListViewItem(), new ListViewItem.ListViewSubItem(), 0, 0, new ColumnHeader(), ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), new ListViewItem.ListViewSubItem(), 1, 2, new ColumnHeader(), ListViewItemStates.Checked };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates_TestData))]
-    public void DrawListViewSubItemEventArgs_Ctor_Graphics_ListViewItem_Rectangle_Int_ListViewItemStates(Rectangle bounds, ListViewItem item, ListViewItem.ListViewSubItem subItem, int itemIndex, int columnIndex, ColumnHeader header, ListViewItemStates itemState)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewSubItemEventArgs(graphics, bounds, item, subItem, itemIndex, columnIndex, header, itemState);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Equal(bounds, e.Bounds);
-            Assert.Same(item, e.Item);
-            Assert.Same(subItem, e.SubItem);
-            Assert.Equal(itemIndex, e.ItemIndex);
-            Assert.Equal(columnIndex, e.ColumnIndex);
-            Assert.Same(header, e.Header);
-            Assert.Equal(itemState, e.ItemState);
-            Assert.False(e.DrawDefault);
-        }
-    }
-
-    [WinFormsFact]
-    public void DrawListViewSubItemEventArgs_Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new DrawListViewSubItemEventArgs(null, new Rectangle(1, 2, 3, 4), new ListViewItem(), new ListViewItem.ListViewSubItem(), -1, 0, new ColumnHeader(), ListViewItemStates.Default));
-    }
-
-    [WinFormsFact]
-    public void DrawListViewSubItemEventArgs_Ctor_NullItemIndexNegativeOne_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("item", () => new DrawListViewSubItemEventArgs(graphics, new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), -1, 0, new ColumnHeader(), ListViewItemStates.Default));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    public void DrawListViewSubItemEventArgs_Ctor_NullSubItemIndexNotNegativeOne_ThrowsArgumentNullException(int itemIndex)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("subItem", () => new DrawListViewSubItemEventArgs(graphics, new Rectangle(1, 2, 3, 4), new ListViewItem(), null, itemIndex, 0, new ColumnHeader(), ListViewItemStates.Default));
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DrawListViewSubItemEventArgs_DrawDefault_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewSubItemEventArgs(graphics, new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, -1, new ColumnHeader(), ListViewItemStates.Checked)
-            {
-                DrawDefault = value
-            };
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set same.
-            e.DrawDefault = value;
-            Assert.Equal(value, e.DrawDefault);
-
-            // Set different.
-            e.DrawDefault = !value;
-            Assert.Equal(!value, e.DrawDefault);
-        }
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, null, ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, null, ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, null, ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, null, ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, null, ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, null, ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new ListViewItem(), null, -1, new ColumnHeader(), ListViewItemStates.Focused };
-
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, null, ListViewItemStates.Focused };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Default };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Checked };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), null, new ListViewItem.ListViewSubItem(), 0, new ColumnHeader(), ListViewItemStates.Focused };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewSubItemEventArgs_DrawBackground_HasGraphics_Success(Rectangle bounds, ListViewItem item, ListViewItem.ListViewSubItem subItem, int itemIndex, ColumnHeader header, ListViewItemStates itemState)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewSubItemEventArgs(graphics, bounds, item, subItem, itemIndex, 0, header, itemState);
-            e.DrawBackground();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawListViewSubItemEventArgs_DrawFocusRectangle_HasGraphics_Success(Rectangle bounds, ListViewItem item, ListViewItem.ListViewSubItem subItem, int itemIndex, ColumnHeader header, ListViewItemStates itemState)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawListViewSubItemEventArgs(graphics, bounds, item, subItem, itemIndex, 0, header, itemState);
-            e.DrawFocusRectangle(new Rectangle(1, 2, 3, 4));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawToolTipEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawToolTipEventArgsTests.cs
deleted file mode 100644
index f5cb6f1ea31..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawToolTipEventArgsTests.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class DrawToolTipEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_IWin32Window_Control_Rectangle_String_Color_Color_Font_TestData()
-    {
-        yield return new object[] { null, null, Rectangle.Empty, null, Color.Empty, Color.Empty, null };
-        yield return new object[] { new Mock<IWin32Window>(MockBehavior.Strict).Object, new Button(), new Rectangle(1, 2, 3, 4), "", Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new Mock<IWin32Window>(MockBehavior.Strict).Object, new Button(), new Rectangle(-1, -2, -3, -4), "toolTipText", Color.Red, Color.Blue, SystemFonts.DefaultFont };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_IWin32Window_Control_Rectangle_String_Color_Color_Font_TestData))]
-    public void Ctor_Graphics_IWin32Window_Control_Rectangle_String_Color_Color_Font(IWin32Window associatedWindow, Control associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawToolTipEventArgs(graphics, associatedWindow, associatedControl, bounds, toolTipText, backColor, foreColor, font);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(associatedWindow, e.AssociatedWindow);
-            Assert.Same(associatedControl, e.AssociatedControl);
-            Assert.Equal(bounds, e.Bounds);
-            Assert.Equal(toolTipText, e.ToolTipText);
-            Assert.Same(font, e.Font);
-        }
-    }
-
-    public static IEnumerable<object[]> Draw_TestData()
-    {
-        yield return new object[] { null, null, new Rectangle(-1, -2, -3, -4), null, Color.Empty, Color.Empty, null };
-        yield return new object[] { null, null, new Rectangle(-1, -2, -3, -4), string.Empty, Color.Empty, Color.Empty, null };
-        yield return new object[] { null, null, new Rectangle(-1, -2, -3, -4), "tooltipText", Color.Empty, Color.Empty, null };
-        yield return new object[] { new SubWin32Window(), new Button(), new Rectangle(1, 2, 3, 4), null, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new SubWin32Window(), new Button(), new Rectangle(1, 2, 3, 4), string.Empty, Color.Red, Color.Blue, SystemFonts.DefaultFont };
-        yield return new object[] { new SubWin32Window(), new Button(), new Rectangle(1, 2, 3, 4), "tooltipText", Color.Red, Color.Blue, SystemFonts.DefaultFont };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawBackground_Invoke_Success(IWin32Window associatedWindow, Control associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawToolTipEventArgs(graphics, associatedWindow, associatedControl, bounds, toolTipText, backColor, foreColor, font);
-            e.DrawBackground();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawText_Invoke_Success(IWin32Window associatedWindow, Control associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawToolTipEventArgs(graphics, associatedWindow, associatedControl, bounds, toolTipText, backColor, foreColor, font);
-            e.DrawText();
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawText_InvokeTextFormatFlags_Success(IWin32Window associatedWindow, Control associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawToolTipEventArgs(graphics, associatedWindow, associatedControl, bounds, toolTipText, backColor, foreColor, font);
-            e.DrawText(TextFormatFlags.Bottom);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_TestData))]
-    public void DrawBorder_Invoke_Success(IWin32Window associatedWindow, Control associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawToolTipEventArgs(graphics, associatedWindow, associatedControl, bounds, toolTipText, backColor, foreColor, font);
-            e.DrawBorder();
-        }
-    }
-
-    private class SubWin32Window : IWin32Window
-    {
-        public IntPtr Handle { get; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawTreeNodeEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawTreeNodeEventArgsTests.cs
deleted file mode 100644
index 5a6ffd8ad55..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DrawTreeNodeEventArgsTests.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class DrawTreeNodeEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_TreeNode_Rectangle_TreeNodeStates_TestData()
-    {
-        yield return new object[] { null, Rectangle.Empty, (TreeNodeStates)(TreeNodeStates.Checked - 1) };
-        yield return new object[] { new TreeNode(), new Rectangle(1, 2, 3, 4), TreeNodeStates.Checked };
-        yield return new object[] { new TreeNode(), new Rectangle(-1, -2, -3, -4), TreeNodeStates.Checked };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_TreeNode_Rectangle_TreeNodeStates_TestData))]
-    public void Ctor_Graphics_TreeNode_Rectangle_TreeNodeStates(TreeNode node, Rectangle bounds, TreeNodeStates state)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawTreeNodeEventArgs(graphics, node, bounds, state);
-            Assert.Equal(graphics, e.Graphics);
-            Assert.Equal(node, e.Node);
-            Assert.Equal(bounds, e.Bounds);
-            Assert.Equal(state, e.State);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void DrawDefault_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new DrawTreeNodeEventArgs(graphics, new TreeNode(), new Rectangle(1, 2, 3, 4), TreeNodeStates.Checked)
-            {
-                DrawDefault = value
-            };
-            Assert.Equal(value, e.DrawDefault);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DynamicAxHost.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DynamicAxHost.cs
deleted file mode 100644
index 4e0d2eae0da..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DynamicAxHost.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using Windows.Win32.System.Com;
-
-namespace System.Windows.Forms.Tests;
-
-/// <summary>
-///  Custom <see cref="AxHost"/> that directly uses a <see cref="ComClassFactory"/>.
-/// </summary>
-public unsafe class DynamicAxHost : AxHost
-{
-    private readonly ComClassFactory _factory;
-
-    internal DynamicAxHost(ComClassFactory factory) : base(factory.ClassId.ToString("D"), 0)
-    {
-        _factory = factory;
-    }
-
-    protected override object CreateInstanceCore(Guid clsid)
-    {
-        Debug.Assert(clsid == _factory.ClassId);
-        _factory.CreateInstance(out object unknown).ThrowOnFailure();
-        return unknown;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/EmbeddedResourceTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/EmbeddedResourceTests.cs
deleted file mode 100644
index c2cf4a8674f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/EmbeddedResourceTests.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-
-namespace System.Windows.Forms.Tests;
-
-public class EmbeddedResourceTests
-{
-    // Get System.Windows.Forms assembly to verify that it contains all the resources that the code uses.
-    private readonly Assembly assembly = Assembly.GetAssembly(typeof(AccessibleObject));
-
-    private static string s_expectedIconNames = """
-            System.Windows.Forms.ActiveDocumentHost
-            System.Windows.Forms.alignment
-            System.Windows.Forms.alignToGrid
-            System.Windows.Forms.Animation
-            System.Windows.Forms.Arrow
-            System.Windows.Forms.BindingNavigator
-            System.Windows.Forms.BindingNavigator.AddNew
-            System.Windows.Forms.BindingNavigator.Delete
-            System.Windows.Forms.BindingNavigator.MoveFirst
-            System.Windows.Forms.BindingNavigator.MoveLast
-            System.Windows.Forms.BindingNavigator.MoveNext
-            System.Windows.Forms.BindingNavigator.MovePrevious
-            System.Windows.Forms.BindingSource
-            System.Windows.Forms.blank
-            System.Windows.Forms.bringToFront
-            System.Windows.Forms.Button
-            System.Windows.Forms.CheckBox
-            System.Windows.Forms.Checked
-            System.Windows.Forms.CheckedListBox
-            System.Windows.Forms.ColorDialog
-            System.Windows.Forms.ComboBox
-            System.Windows.Forms.ComponentModel.OrderImages
-            System.Windows.Forms.ContextMenu
-            System.Windows.Forms.ContextMenuStrip
-            System.Windows.Forms.copy
-            System.Windows.Forms.cut
-            System.Windows.Forms.DataConnector
-            System.Windows.Forms.DataGrid
-            System.Windows.Forms.DataGridCaption.backarrow
-            System.Windows.Forms.DataGridCaption.backarrow_bidi
-            System.Windows.Forms.DataGridCaption.Details
-            System.Windows.Forms.DataGridCaption.down
-            System.Windows.Forms.DataGridCaption.right
-            System.Windows.Forms.DataGridCaption.up
-            System.Windows.Forms.DataGridParentRows.LeftArrow
-            System.Windows.Forms.DataGridParentRows.RightArrow
-            System.Windows.Forms.DataGridRow.error
-            System.Windows.Forms.DataGridRow.left
-            System.Windows.Forms.DataGridRow.pencil
-            System.Windows.Forms.DataGridRow.right
-            System.Windows.Forms.DataGridRow.star
-            System.Windows.Forms.DataGridView
-            System.Windows.Forms.DataGridViewButtonColumn
-            System.Windows.Forms.DataGridViewCheckBoxColumn
-            System.Windows.Forms.DataGridViewComboBoxColumn
-            System.Windows.Forms.DataGridViewImageColumn
-            System.Windows.Forms.DataGridViewLinkColumn
-            System.Windows.Forms.DataGridViewRow.error
-            System.Windows.Forms.DataGridViewRow.left
-            System.Windows.Forms.DataGridViewRow.leftstar
-            System.Windows.Forms.DataGridViewRow.pencil_ltr
-            System.Windows.Forms.DataGridViewRow.pencil_rtl
-            System.Windows.Forms.DataGridViewRow.right
-            System.Windows.Forms.DataGridViewRow.rightstar
-            System.Windows.Forms.DataGridViewRow.star
-            System.Windows.Forms.DataGridViewTextBoxColumn
-            System.Windows.Forms.DataNavigator
-            System.Windows.Forms.DataNavigator.AddNew
-            System.Windows.Forms.DataNavigator.Delete
-            System.Windows.Forms.DataNavigator.MoveFirst
-            System.Windows.Forms.DataNavigator.MoveLast
-            System.Windows.Forms.DataNavigator.MoveNext
-            System.Windows.Forms.DataNavigator.MovePrevious
-            System.Windows.Forms.DateTimePicker
-            System.Windows.Forms.DefaultControl
-            System.Windows.Forms.delete
-            System.Windows.Forms.Design.ComponentEditorPage
-            System.Windows.Forms.Design.EventsTab
-            System.Windows.Forms.displaystyle
-            System.Windows.Forms.DomainUpDown
-            System.Windows.Forms.dotdotdot
-            System.Windows.Forms.down
-            System.Windows.Forms.Edit
-            System.Windows.Forms.editdropdownlist
-            System.Windows.Forms.Error
-            System.Windows.Forms.ErrorControl
-            System.Windows.Forms.ErrorProvider
-            System.Windows.Forms.FlowLayoutPanel
-            System.Windows.Forms.FolderBrowserDialog
-            System.Windows.Forms.FontDialog
-            System.Windows.Forms.Form
-            System.Windows.Forms.Grid
-            System.Windows.Forms.GroupBox
-            System.Windows.Forms.help
-            System.Windows.Forms.HelpProvider
-            System.Windows.Forms.HScrollBar
-            System.Windows.Forms.HTMLControl
-            System.Windows.Forms.IconInError
-            System.Windows.Forms.image
-            System.Windows.Forms.ImageInError
-            System.Windows.Forms.ImageList
-            System.Windows.Forms.IndeterminateChecked
-            System.Windows.Forms.Label
-            System.Windows.Forms.LinkLabel
-            System.Windows.Forms.ListBox
-            System.Windows.Forms.ListView
-            System.Windows.Forms.lockControls
-            System.Windows.Forms.MainMenu
-            System.Windows.Forms.MaskedTextBox
-            System.Windows.Forms.MenuStrip
-            System.Windows.Forms.MonthCalendar
-            System.Windows.Forms.MultiplexPanel
-            System.Windows.Forms.new
-            System.Windows.Forms.NotifyIcon
-            System.Windows.Forms.NumericUpDown
-            System.Windows.Forms.open
-            System.Windows.Forms.OpenFileDialog
-            System.Windows.Forms.overflowButton
-            System.Windows.Forms.PageSetupDialog
-            System.Windows.Forms.Panel
-            System.Windows.Forms.paste
-            System.Windows.Forms.PBAlpha
-            System.Windows.Forms.PBCategory
-            System.Windows.Forms.PBEvent
-            System.Windows.Forms.PBPPage
-            System.Windows.Forms.PBProp
-            System.Windows.Forms.PictureBox
-            System.Windows.Forms.PictureBox.Loading
-            System.Windows.Forms.print
-            System.Windows.Forms.PrintDialog
-            System.Windows.Forms.printPreview
-            System.Windows.Forms.PrintPreviewControl
-            System.Windows.Forms.PrintPreviewDialog
-            System.Windows.Forms.PrintPreviewStrip
-            System.Windows.Forms.ProgressBar
-            System.Windows.Forms.properties
-            System.Windows.Forms.PropertyGrid
-            System.Windows.Forms.PropertyGridInternal.PropertiesTab
-            System.Windows.Forms.RadioButton
-            System.Windows.Forms.Rebar
-            System.Windows.Forms.RichEdit
-            System.Windows.Forms.RichTextBox
-            System.Windows.Forms.save
-            System.Windows.Forms.SaveFileDialog
-            System.Windows.Forms.ScrollButtonDown
-            System.Windows.Forms.ScrollButtonUp
-            System.Windows.Forms.sendToBack
-            System.Windows.Forms.Server.Arrow
-            System.Windows.Forms.SplitContainer
-            System.Windows.Forms.Splitter
-            System.Windows.Forms.SplitterPanel
-            System.Windows.Forms.StatusStrip
-            System.Windows.Forms.StatusStripPanel
-            System.Windows.Forms.TabControl
-            System.Windows.Forms.TableLayoutPanel
-            System.Windows.Forms.TabPage
-            System.Windows.Forms.TabStrip
-            System.Windows.Forms.TextBox
-            System.Windows.Forms.Timer
-            System.Windows.Forms.ToolBar
-            System.Windows.Forms.ToolBarGrip
-            System.Windows.Forms.ToolStrip
-            System.Windows.Forms.ToolStripButton
-            System.Windows.Forms.ToolStripComboBox
-            System.Windows.Forms.ToolStripContainer
-            System.Windows.Forms.ToolStripContainer_BottomToolStripPanel
-            System.Windows.Forms.ToolStripContainer_LeftToolStripPanel
-            System.Windows.Forms.ToolStripContainer_RightToolStripPanel
-            System.Windows.Forms.ToolStripContainer_TopToolStripPanel
-            System.Windows.Forms.ToolStripContentPanel
-            System.Windows.Forms.ToolStripDropDown
-            System.Windows.Forms.ToolStripDropDownButton
-            System.Windows.Forms.ToolStripDropDownMenu
-            System.Windows.Forms.ToolStripLabel
-            System.Windows.Forms.ToolStripMenuItem
-            System.Windows.Forms.ToolStripPanel_standalone
-            System.Windows.Forms.ToolStripProgressBar
-            System.Windows.Forms.ToolStripSeparator
-            System.Windows.Forms.ToolStripSplitButton
-            System.Windows.Forms.ToolStripStatusLabel
-            System.Windows.Forms.ToolStripTextBox
-            System.Windows.Forms.ToolTip
-            System.Windows.Forms.TrackBar
-            System.Windows.Forms.TrayIcon
-            System.Windows.Forms.TreeView
-            System.Windows.Forms.up
-            System.Windows.Forms.UserControl
-            System.Windows.Forms.viewcode
-            System.Windows.Forms.VScrollBar
-            System.Windows.Forms.WebBrowser
-            System.Windows.Forms.wfc
-            """;
-
-    public static TheoryData ExpectedIconNames()
-        => s_expectedIconNames.Split(Environment.NewLine).ToTheoryData();
-
-    [Theory]
-    [MemberData(nameof(ExpectedIconNames))]
-    public void EmbeddedResource_ResourcesExist_Icon(string resourceName)
-    {
-        using Stream stream = assembly.GetManifestResourceStream(resourceName);
-        Assert.NotNull(stream);
-
-        using Icon icon = new(stream);
-        Assert.NotNull(icon);
-    }
-
-    private static string s_expectedCursorNames = """
-            System.Windows.Forms.east.cur
-            System.Windows.Forms.hsplit.cur
-            System.Windows.Forms.ne.cur
-            System.Windows.Forms.nomove2d.cur
-            System.Windows.Forms.nomoveh.cur
-            System.Windows.Forms.nomovev.cur
-            System.Windows.Forms.north.cur
-            System.Windows.Forms.nw.cur
-            System.Windows.Forms.se.cur
-            System.Windows.Forms.south.cur
-            System.Windows.Forms.sw.cur
-            System.Windows.Forms.vsplit.cur
-            System.Windows.Forms.west.cur
-            """;
-
-    public static TheoryData ExpectedCursorNames()
-         => (TheoryData)s_expectedCursorNames.Split(Environment.NewLine).ToTheoryData();
-
-    [Theory]
-    [MemberData(nameof(ExpectedCursorNames))]
-    public void EmbeddedResource_ResourcesExist_Cursor(string resourceName)
-    {
-        using Stream stream = assembly.GetManifestResourceStream(resourceName);
-        Assert.NotNull(stream);
-
-        using Cursor cursor = new(stream);
-        Assert.NotNull(cursor);
-    }
-
-    private const string expectedResourceNames = """
-            ILLink.Substitutions.xml
-            System.SR.resources
-            System.Windows.Forms.MdiWindowDialog.resources
-            System.Windows.Forms.PrintPreviewDialog.resources
-            System.Windows.Forms.XPThemes.manifest
-            """;
-
-    [Fact]
-    public void EmbeddedResource_VerifyList()
-    {
-        string[] actual = assembly.GetManifestResourceNames();
-        Array.Sort(actual, StringComparer.Ordinal);
-
-        string allNames = $"{s_expectedIconNames}{Environment.NewLine}{s_expectedCursorNames}{Environment.NewLine}{expectedResourceNames}";
-        string[] expected = allNames.Split(Environment.NewLine);
-        Array.Sort(expected, StringComparer.Ordinal);
-
-        AssertExtensions.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ControlItem.ControlItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ControlItem.ControlItemAccessibleObjectTests.cs
deleted file mode 100644
index 561772a4bff..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ControlItem.ControlItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,287 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using static System.Windows.Forms.ErrorProvider;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ErrorProvider_ControlItem_ControlItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_Ctor_Default()
-    {
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._controlItem);
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._window);
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._control);
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._provider);
-        Assert.Equal(AccessibleRole.Alert, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_Bounds_ReturnsEmptyRectangle_IfControlIsNotCreated()
-    {
-        using Control control = new();
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, control, null });
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_Bounds_ReturnsNoEmptyRectangle_IfParentControlIsCreated()
-    {
-        using Control parentControl = new();
-        using Control control = new();
-        parentControl.Controls.Add(control);
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-        ControlItem item = new(provider, control, (IntPtr)100);
-        window.Add(item);
-        parentControl.CreateControl();
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { item, window, control, provider });
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_Parent_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, window, control, provider });
-
-        Assert.Equal(window.AccessibilityObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_FragmentRoot_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, window, control, provider });
-
-        Assert.Equal(window.AccessibilityObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_IsReadOnly_ReturnsExpected()
-    {
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.True(accessibleObject.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_State_ReturnsExpected()
-    {
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.Equal(AccessibleStates.HasPopup | AccessibleStates.ReadOnly, accessibleObject.State);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData(null)]
-
-    public void ControlItemAccessibleObjectTests_Name_ReturnsExpected_IfNameIsNullOrEmptyString(string testName)
-    {
-        string testError = "This is test string";
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-        ControlItem item = new(provider, control, (IntPtr)100) { Error = testError };
-        window.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-        accessibleObject.Name = testName;
-
-        Assert.Equal(testError, accessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    public void ControlItemAccessibleObjectTests_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_IsIAccessibleExSupported_ReturnsExpected_IfItemIsNotNull()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-        ControlItem item = new(provider, control, (IntPtr)100);
-        window.Add(item);
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { item, window, control, provider });
-
-        Assert.NotNull(accessibleObject.TestAccessor().Dynamic._controlItem);
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_ControlType_ReturnsExpected()
-    {
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.Equal(UiaCore.UIA.ImageControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_GetPropertyValue_ReturnsExpected()
-    {
-        Type type = typeof(ControlItem)
-           .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, null, null, null });
-
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.Equal(AccessibleStates.ReadOnly | AccessibleStates.HasPopup, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleStatePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_GetChildId_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-        ControlItem item3 = new(provider, control, (IntPtr)300);
-
-        window.ControlItems.AddRange(new[] { item1, item2, item3 });
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject1 = (AccessibleObject)Activator.CreateInstance(type, new object[] { item1, window, control, provider });
-        var accessibleObject2 = (AccessibleObject)Activator.CreateInstance(type, new object[] { item2, window, control, provider });
-        var accessibleObject3 = (AccessibleObject)Activator.CreateInstance(type, new object[] { item3, window, control, provider });
-
-        // Make sure that returns index in window.Items collection + 1
-
-        Assert.Equal(1, accessibleObject1.GetChildId());
-        Assert.Equal(2, accessibleObject2.GetChildId());
-        Assert.Equal(3, accessibleObject3.GetChildId());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        Type type = typeof(ControlItem)
-            .GetNestedType("ControlItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null, window, control, provider });
-
-        Assert.Equal(window.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_FragmentNavigate_NextSibling_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-        ControlItem item3 = new(provider, control, (IntPtr)300);
-
-        window.ControlItems.AddRange(new[] { item1, item2, item3 });
-
-        AccessibleObject accessibleObject1 = item1.AccessibilityObject;
-        AccessibleObject accessibleObject2 = item2.AccessibilityObject;
-        AccessibleObject accessibleObject3 = item3.AccessibilityObject;
-
-        // Window is null while controlItem isn't added to window.
-        Assert.Null(accessibleObject1.TestAccessor().Dynamic._window);
-        Assert.Null(accessibleObject2.TestAccessor().Dynamic._window);
-        Assert.Null(accessibleObject3.TestAccessor().Dynamic._window);
-
-        // So add the reference manually.
-        accessibleObject1.TestAccessor().Dynamic._window = window;
-        accessibleObject2.TestAccessor().Dynamic._window = window;
-        accessibleObject3.TestAccessor().Dynamic._window = window;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ControlItemAccessibleObjectTests_FragmentNavigate_PreviousSibling_ReturnsExpected()
-    {
-        using Control control = new();
-        using ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-        ControlItem item3 = new(provider, control, (IntPtr)300);
-
-        window.ControlItems.AddRange(new[] { item1, item2, item3 });
-
-        AccessibleObject accessibleObject1 = item1.AccessibilityObject;
-        AccessibleObject accessibleObject2 = item2.AccessibilityObject;
-        AccessibleObject accessibleObject3 = item3.AccessibilityObject;
-
-        // Window is null while controlItem isn't added to window.
-        Assert.Null(accessibleObject1.TestAccessor().Dynamic._window);
-        Assert.Null(accessibleObject2.TestAccessor().Dynamic._window);
-        Assert.Null(accessibleObject3.TestAccessor().Dynamic._window);
-
-        // So add the reference manually.
-        accessibleObject1.TestAccessor().Dynamic._window = window;
-        accessibleObject2.TestAccessor().Dynamic._window = window;
-        accessibleObject3.TestAccessor().Dynamic._window = window;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ErrorWindow.ErrorWindowAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ErrorWindow.ErrorWindowAccessibleObjectTests.cs
deleted file mode 100644
index d419adcc1a7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProvider.ErrorWindow.ErrorWindowAccessibleObjectTests.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using static System.Windows.Forms.ErrorProvider;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ErrorProvider_ErrorWindow_ErrorWindowAccessibleObject
-{
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_Ctor_Default()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Null(accessibleObject.TestAccessor().Dynamic._owner);
-        Assert.Equal(AccessibleRole.Grouping, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_IsReadOnly_ReturnsExpected()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.True(accessibleObject.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_State_ReturnsExpected()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(AccessibleStates.ReadOnly, accessibleObject.State);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    public void ErrorWindowAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_ControlType_ReturnsExpected()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(UiaCore.UIA.GroupControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.Equal(AccessibleStates.ReadOnly, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleStatePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        Type type = typeof(ErrorWindow)
-            .GetNestedType("ErrorWindowAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { null });
-
-        Assert.Equal(accessibleObject, accessibleObject.FragmentRoot);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        int testCount = 2;
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-        for (int i = 0; i < testCount; i++)
-        {
-            window.ControlItems.Add(new(provider, control, (IntPtr)i));
-        }
-
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-
-        Assert.Equal(testCount, accessibleObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-
-        window.ControlItems.AddRange(new[] { item1, item2 });
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(item1.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(item2.AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData(null)]
-    public void ErrorWindowAccessibleObject_Name_ReturnsExpected_IfNullOrStringEmptyString(string testName)
-    {
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-        window.ControlItems.AddRange(new[] { item1, item2 });
-
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-        accessibleObject.Name = testName;
-
-        Assert.Equal(SR.ErrorProviderDefaultAccessibleName, accessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_FragmentNavigate_ReturnsExpected()
-    {
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        ControlItem item1 = new(provider, control, (IntPtr)100);
-        ControlItem item2 = new(provider, control, (IntPtr)200);
-        ControlItem item3 = new(provider, control, (IntPtr)300);
-
-        window.ControlItems.AddRange(new[] { item1, item2, item3 });
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-
-        Assert.Equal(item1.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(item3.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ErrorWindowAccessibleObject_FragmentNavigate_ReturnsExpected_NoItems()
-    {
-        using Control control = new();
-        ErrorProvider provider = new();
-        ErrorWindow window = new(provider, control);
-
-        AccessibleObject accessibleObject = window.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderAccessibleObjectTests.cs
deleted file mode 100644
index 54c5c65b39e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderAccessibleObjectTests.cs
+++ /dev/null
@@ -1,165 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ErrorProviderAccessibleObjectTests : IDisposable
-{
-    private readonly Form _form;
-    private readonly Control _control1;
-    private readonly Control _control2;
-    private readonly ErrorProvider _errorProvider;
-    private readonly ErrorProvider.ErrorWindow _errorWindow;
-    private readonly ErrorProvider.ControlItem _controlItem1;
-    private readonly ErrorProvider.ControlItem _controlItem2;
-    private readonly string _errorText1;
-    private readonly string _errorText2;
-
-    public ErrorProviderAccessibleObjectTests()
-    {
-        _form = new Form();
-        _form.CreateControl();
-        _form.Visible = true;
-
-        _control1 = new Control();
-        _control1.CreateControl();
-        _control1.Visible = true;
-
-        _control2 = new Control();
-        _control2.CreateControl();
-        _control2.Visible = true;
-
-        _form.Controls.Add(_control1);
-        _form.Controls.Add(_control2);
-
-        _errorText1 = "Test text 1";
-        _errorText2 = "Test text 2";
-
-        _errorProvider = new ErrorProvider();
-        _errorProvider.SetError(_control1, _errorText1);
-        _errorProvider.SetError(_control2, _errorText2);
-
-        _errorWindow = _errorProvider.EnsureErrorWindow(_form);
-        _controlItem1 = _errorWindow.ControlItems.Count > 0 ? _errorWindow.ControlItems[0] : null;
-        _controlItem2 = _errorWindow.ControlItems.Count > 0 ? _errorWindow.ControlItems[1] : null;
-    }
-
-    public void Dispose()
-    {
-        _errorProvider?.Dispose();
-        _control2?.Dispose();
-        _control1?.Dispose();
-        _form?.Dispose();
-    }
-
-    [WinFormsFact]
-    public void ErrorProviderAccessibleObject_Ctor_Default()
-    {
-        Assert.NotNull(_errorWindow);
-        AccessibleObject windowAccessibleObject = _errorWindow.AccessibilityObject;
-        Assert.NotNull(windowAccessibleObject);
-
-        Assert.NotNull(_controlItem1);
-        AccessibleObject controlItemAccessibleObject1 = _controlItem1.AccessibilityObject;
-        Assert.NotNull(controlItemAccessibleObject1);
-
-        Assert.NotNull(_controlItem2);
-        AccessibleObject controlItemAccessibleObject2 = _controlItem2.AccessibilityObject;
-        Assert.NotNull(controlItemAccessibleObject2);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_ControlItemAccessibleObject_CorrectControlType()
-    {
-        AccessibleObject controlItemAccessibleObject = _controlItem1.AccessibilityObject;
-        object actual = controlItemAccessibleObject?.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        object expected = UiaCore.UIA.ImageControlTypeId;
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_ErrorWindowAccessibleObject_CorrectControlType()
-    {
-        AccessibleObject errorWindowAccessibleObject = _errorWindow.AccessibilityObject;
-        object actual = errorWindowAccessibleObject?.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        object expected = UiaCore.UIA.GroupControlTypeId;
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_CorrectErrorValue()
-    {
-        // Check string for _control1
-        string actual = _errorProvider.GetError(_control1);
-        string expected = _errorText1;
-        Assert.Equal(expected, actual);
-
-        actual = _controlItem1.Error;
-        Assert.Equal(expected, actual);
-
-        // Check string for _control2
-        actual = _errorProvider.GetError(_control2);
-        expected = _errorText2;
-        Assert.Equal(expected, actual);
-
-        actual = _controlItem2.Error;
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_CorrectAccessibilityTree()
-    {
-        AccessibleObject errorWindowAccessibilityObject = _errorWindow.AccessibilityObject;
-        AccessibleObject controlItem1_AccessibilityObject = _controlItem1.AccessibilityObject;
-        AccessibleObject controlItem2_AccessibilityObject = _controlItem2.AccessibilityObject;
-
-        int childCount = errorWindowAccessibilityObject.GetChildCount();
-        int expectedCount = 2;
-        Assert.Equal(expectedCount, childCount);
-
-        AccessibleObject actualAccessibilityObject = errorWindowAccessibilityObject.GetChild(0);
-        Assert.Equal(controlItem1_AccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = errorWindowAccessibilityObject.GetChild(1);
-        Assert.Equal(controlItem2_AccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = controlItem1_AccessibilityObject.Parent;
-        Assert.Equal(errorWindowAccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = controlItem2_AccessibilityObject.Parent;
-        Assert.Equal(errorWindowAccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = (AccessibleObject)controlItem1_AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        Assert.Equal(controlItem2_AccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = (AccessibleObject)controlItem1_AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        Assert.Null(actualAccessibilityObject);
-
-        actualAccessibilityObject = (AccessibleObject)controlItem2_AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        Assert.Equal(controlItem1_AccessibilityObject, actualAccessibilityObject);
-
-        actualAccessibilityObject = (AccessibleObject)controlItem2_AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        Assert.Null(actualAccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_NameDoesntEqualControlTypeOrChildName()
-    {
-        // Mas requires us to have no same AccessibleName and LocalizedControlType or child AccessibleName.
-        // So we need to check if these properties are not equal.
-        // In this specific case, we can't have some positive Assert.
-        // ToLower method used to be case insensitive.
-
-        string errorWindowControlType = "group";
-        string actualWindowAccessibleName = _errorWindow.AccessibilityObject.Name.ToLower();
-        Assert.NotEqual(errorWindowControlType, actualWindowAccessibleName);
-
-        string controlItemControlType = "image";
-        string actualItemAccessibleName = _controlItem1.AccessibilityObject.Name.ToLower();
-        Assert.NotEqual(controlItemControlType, actualItemAccessibleName);
-
-        Assert.NotEqual(actualWindowAccessibleName, actualItemAccessibleName);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderTests.cs
deleted file mode 100644
index 7f189dfc4d7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ErrorProviderTests.cs
+++ /dev/null
@@ -1,1336 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class ErrorProviderTests
-{
-    [WinFormsFact]
-    public void ErrorProvider_Ctor_Default()
-    {
-        using var provider = new SubErrorProvider();
-        Assert.Equal(250, provider.BlinkRate);
-        Assert.Equal(ErrorBlinkStyle.BlinkIfDifferentError, provider.BlinkStyle);
-        Assert.True(provider.CanRaiseEvents);
-        Assert.Null(provider.Container);
-        Assert.Null(provider.ContainerControl);
-        Assert.Null(provider.DataMember);
-        Assert.Null(provider.DataSource);
-        Assert.False(provider.DesignMode);
-        Assert.NotNull(provider.Events);
-        Assert.Same(provider.Events, provider.Events);
-        Assert.NotNull(provider.Icon);
-        Assert.Same(provider.Icon, provider.Icon);
-        Assert.Null(provider.Site);
-        Assert.Null(provider.Tag);
-        Assert.Equal(provider.Icon.Width, PInvoke.GetSystemMetrics(SYSTEM_METRICS_INDEX.SM_CXSMICON));
-        Assert.Equal(provider.Icon.Height, PInvoke.GetSystemMetrics(SYSTEM_METRICS_INDEX.SM_CYSMICON));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Ctor_ContainerControl()
-    {
-        using var parentControl = new ContainerControl();
-        using var provider = new SubErrorProvider(parentControl);
-        Assert.Equal(250, provider.BlinkRate);
-        Assert.Equal(ErrorBlinkStyle.BlinkIfDifferentError, provider.BlinkStyle);
-        Assert.True(provider.CanRaiseEvents);
-        Assert.Null(provider.Container);
-        Assert.Same(parentControl, provider.ContainerControl);
-        Assert.Null(provider.DataMember);
-        Assert.Null(provider.DataSource);
-        Assert.False(provider.DesignMode);
-        Assert.NotNull(provider.Events);
-        Assert.Same(provider.Events, provider.Events);
-        Assert.NotNull(provider.Icon);
-        Assert.Same(provider.Icon, provider.Icon);
-        Assert.Null(provider.Site);
-        Assert.Null(provider.Tag);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Ctor_NullParentControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("parentControl", () => new ErrorProvider((ContainerControl)null));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Ctor_IContainer()
-    {
-        using var container = new Container();
-        using var provider = new SubErrorProvider(container);
-        Assert.Equal(250, provider.BlinkRate);
-        Assert.Equal(ErrorBlinkStyle.BlinkIfDifferentError, provider.BlinkStyle);
-        Assert.True(provider.CanRaiseEvents);
-        Assert.Same(container, provider.Container);
-        Assert.Null(provider.ContainerControl);
-        Assert.Null(provider.DataMember);
-        Assert.Null(provider.DataSource);
-        Assert.False(provider.DesignMode);
-        Assert.NotNull(provider.Events);
-        Assert.Same(provider.Events, provider.Events);
-        Assert.NotNull(provider.Icon);
-        Assert.Same(provider.Icon, provider.Icon);
-        Assert.NotNull(provider.Site);
-        Assert.Null(provider.Tag);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Ctor_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new ErrorProvider((IContainer)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, ErrorBlinkStyle.NeverBlink)]
-    [InlineData(1, ErrorBlinkStyle.BlinkIfDifferentError)]
-    [InlineData(250, ErrorBlinkStyle.BlinkIfDifferentError)]
-    public void ErrorProvider_BlinkRate_Set_GetReturnsExpected(int value, ErrorBlinkStyle expectedBlinkStyle)
-    {
-        using var provider = new ErrorProvider
-        {
-            BlinkRate = value
-        };
-        Assert.Equal(value, provider.BlinkRate);
-        Assert.Equal(expectedBlinkStyle, provider.BlinkStyle);
-
-        // Set same.
-        provider.BlinkRate = value;
-        Assert.Equal(value, provider.BlinkRate);
-        Assert.Equal(expectedBlinkStyle, provider.BlinkStyle);
-
-        // Set blink style.
-        provider.BlinkStyle = ErrorBlinkStyle.BlinkIfDifferentError;
-        Assert.Equal(value, provider.BlinkRate);
-        Assert.Equal(expectedBlinkStyle, provider.BlinkStyle);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_BlinkRate_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => provider.BlinkRate = -1);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ErrorBlinkStyle>]
-    public void ErrorProvider_BlinkStyle_Set_GetReturnsExpected(ErrorBlinkStyle value)
-    {
-        using var provider = new ErrorProvider
-        {
-            BlinkStyle = value
-        };
-        Assert.Equal(value, provider.BlinkStyle);
-        Assert.Equal(250, provider.BlinkRate);
-
-        // Set same.
-        provider.BlinkStyle = value;
-        Assert.Equal(value, provider.BlinkStyle);
-        Assert.Equal(250, provider.BlinkRate);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ErrorBlinkStyle>]
-    public void ErrorProvider_BlinkStyle_SetAlreadyBlink_GetReturnsExpected(ErrorBlinkStyle value)
-    {
-        using var provider = new ErrorProvider
-        {
-            BlinkStyle = ErrorBlinkStyle.AlwaysBlink
-        };
-
-        provider.BlinkStyle = value;
-        Assert.Equal(value, provider.BlinkStyle);
-        Assert.Equal(250, provider.BlinkRate);
-
-        // Set same.
-        provider.BlinkStyle = value;
-        Assert.Equal(value, provider.BlinkStyle);
-        Assert.Equal(250, provider.BlinkRate);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ErrorBlinkStyle>]
-    public void ErrorProvider_BlinkStyle_SetWithZeroBlinkRate_GetReturnsExpected(ErrorBlinkStyle value)
-    {
-        using var provider = new ErrorProvider
-        {
-            BlinkRate = 0,
-            BlinkStyle = value
-        };
-        Assert.Equal(ErrorBlinkStyle.NeverBlink, provider.BlinkStyle);
-        Assert.Equal(0, provider.BlinkRate);
-
-        // Set same.
-        provider.BlinkStyle = value;
-        Assert.Equal(ErrorBlinkStyle.NeverBlink, provider.BlinkStyle);
-        Assert.Equal(0, provider.BlinkRate);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ErrorBlinkStyle>]
-    public void ErrorProvider_BlinkStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(ErrorBlinkStyle value)
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => provider.BlinkStyle = value);
-    }
-
-    public static IEnumerable<object[]> ContainerControl_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContainerControl() };
-        yield return new object[] { new SubContainerControl() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContainerControl_TestData))]
-    public void ErrorProvider_ContainerControl_Set_GetReturnsExpected(ContainerControl value)
-    {
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = value
-        };
-        Assert.Same(value, provider.ContainerControl);
-
-        // Set same.
-        provider.ContainerControl = value;
-        Assert.Same(value, provider.ContainerControl);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContainerControl_TestData))]
-    public void ErrorProvider_ContainerControl_SetWithNonNullOldValue_GetReturnsExpected(ContainerControl value)
-    {
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = new ContainerControl()
-        };
-
-        provider.ContainerControl = value;
-        Assert.Same(value, provider.ContainerControl);
-
-        // Set same.
-        provider.ContainerControl = value;
-        Assert.Same(value, provider.ContainerControl);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ErrorProvider_DataMember_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var provider = new ErrorProvider
-        {
-            DataMember = value
-        };
-        Assert.Equal(expected, provider.DataMember);
-
-        // Set same.
-        provider.DataMember = value;
-        Assert.Equal(expected, provider.DataMember);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ErrorProvider_DataMember_SetWithNonNullOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var provider = new ErrorProvider
-        {
-            DataMember = "OldMember"
-        };
-
-        provider.DataMember = value;
-        Assert.Equal(expected, provider.DataMember);
-
-        // Set same.
-        provider.DataMember = value;
-        Assert.Equal(expected, provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> DataMember_SetWithContainerControl_TestData()
-    {
-        foreach (string value in new string[] { null, string.Empty, "dataMember" })
-        {
-            yield return new object[] { null, value, value ?? string.Empty };
-            yield return new object[] { new ContainerControl(), value, value ?? string.Empty };
-            yield return new object[] { new SubContainerControl(), value, value ?? string.Empty };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataMember_SetWithContainerControl_TestData))]
-    public void ErrorProvider_DataMember_SetWithContainerControl_GetReturnsExpected(ContainerControl containerControl, string value, string expected)
-    {
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataMember = value
-        };
-        Assert.Equal(expected, provider.DataMember);
-
-        // Set same.
-        provider.DataMember = value;
-        Assert.Equal(expected, provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> DataMember_SetWithValidDataMemberWithContainerControl_TestData()
-    {
-        foreach (string dataMember in new string[] { nameof(DataClass.Value), nameof(DataClass.ListValue) })
-        {
-            yield return new object[] { null, dataMember };
-            yield return new object[] { new ContainerControl(), dataMember };
-            yield return new object[] { new SubContainerControl(), dataMember };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataMember_SetWithValidDataMemberWithContainerControl_TestData))]
-    public void ErrorProvider_DataMember_SetWithValidDataSourceWithContainerControl_ReturnsExpected(ContainerControl containerControl, string dataMember)
-    {
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataSource = value,
-            DataMember = dataMember
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Same(dataMember, provider.DataMember);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataMember_ShouldSerializeValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.DataMember)];
-        Assert.False(property.ShouldSerializeValue(provider));
-
-        provider.DataMember = "dataMember";
-        Assert.True(property.ShouldSerializeValue(provider));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataMember_CanResetValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.DataMember)];
-        Assert.False(property.CanResetValue(provider));
-
-        provider.DataMember = "dataMember";
-        Assert.True(property.CanResetValue(provider));
-
-        property.ResetValue(provider);
-        Assert.True(property.CanResetValue(provider));
-        Assert.Empty(provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> NoBindingContextContainerControl_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubContainerControl() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoBindingContextContainerControl_TestData))]
-    public void ErrorProvider_DataMember_SetWithInvalidDataSourceWithContainerControl_ReturnsExpected(ContainerControl containerControl)
-    {
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataSource = value,
-            DataMember = "NoSuchValue"
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Equal("NoSuchValue", provider.DataMember);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataMember_SetWithInvalidDataSourceWithContainerControl_ResetsDataMember()
-    {
-        using var containerControl = new ContainerControl();
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataSource = value
-        };
-        Assert.Throws<ArgumentException>(() => provider.DataMember = "NoSuchValue");
-        Assert.Same(value, provider.DataSource);
-        Assert.Equal("NoSuchValue", provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> DataSource_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new DataClass() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ErrorProvider_DataSource_SetWithNullDataMember_GetReturnsExpected(object value)
-    {
-        using var provider = new ErrorProvider
-        {
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Null(provider.DataMember);
-
-        // Set same.
-        provider.DataSource = value;
-        Assert.Same(value, provider.DataSource);
-        Assert.Null(provider.DataMember);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ErrorProvider_DataSource_SetWithEmptyDataMember_GetReturnsExpected(object value)
-    {
-        using var provider = new ErrorProvider
-        {
-            DataMember = string.Empty,
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Empty(provider.DataMember);
-
-        // Set same.
-        provider.DataSource = value;
-        Assert.Same(value, provider.DataSource);
-        Assert.Empty(provider.DataMember);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ErrorProvider_DataSource_SetWithNonNullOldValue_GetReturnsExpected(object value)
-    {
-        using var provider = new ErrorProvider
-        {
-            DataSource = new object()
-        };
-
-        provider.DataSource = value;
-        Assert.Same(value, provider.DataSource);
-
-        // Set same.
-        provider.DataSource = value;
-        Assert.Same(value, provider.DataSource);
-    }
-
-    public static IEnumerable<object[]> DataSource_SetWithContainerControl_TestData()
-    {
-        foreach (object value in new object[] { null, new object(), new DataClass() })
-        {
-            yield return new object[] { null, value };
-            yield return new object[] { new ContainerControl(), value };
-            yield return new object[] { new SubContainerControl(), value };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_SetWithContainerControl_TestData))]
-    public void ErrorProvider_DataSource_SetWithContainerControl_GetReturnsExpected(ContainerControl containerControl, object value)
-    {
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-
-        // Set same.
-        provider.DataSource = value;
-        Assert.Same(value, provider.DataSource);
-    }
-
-    public static IEnumerable<object[]> DataSource_SetWithValidDataMemberWithContainerControl_TestData()
-    {
-        foreach (string dataMember in new string[] { nameof(DataClass.Value), nameof(DataClass.ListValue) })
-        {
-            yield return new object[] { null, dataMember };
-            yield return new object[] { new ContainerControl(), dataMember };
-            yield return new object[] { new SubContainerControl(), dataMember };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_SetWithValidDataMemberWithContainerControl_TestData))]
-    public void ErrorProvider_DataSource_SetWithValidDataMemberWithContainerControl_ReturnsExpected(ContainerControl containerControl, string dataMember)
-    {
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataMember = dataMember,
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Same(dataMember, provider.DataMember);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NoBindingContextContainerControl_TestData))]
-    public void ErrorProvider_DataSource_SetWithInvalidDataMemberWithContainerControl_ReturnsExpected(ContainerControl containerControl)
-    {
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataMember = "NoSuchValue",
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Equal("NoSuchValue", provider.DataMember);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataSource_SetWithInvalidDataMemberWithContainerControl_ResetsDataMember()
-    {
-        using var containerControl = new ContainerControl();
-        var value = new DataClass();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl,
-            DataMember = "NoSuchValue",
-            DataSource = value
-        };
-        Assert.Same(value, provider.DataSource);
-        Assert.Empty(provider.DataMember);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataSource_ShouldSerializeValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.DataSource)];
-        Assert.False(property.ShouldSerializeValue(provider));
-
-        provider.DataSource = new object();
-        Assert.True(property.ShouldSerializeValue(provider));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_DataSource_CanResetValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.DataSource)];
-        Assert.False(property.CanResetValue(provider));
-
-        provider.DataSource = new object();
-        Assert.True(property.CanResetValue(provider));
-
-        property.ResetValue(provider);
-        Assert.False(property.CanResetValue(provider));
-        Assert.Null(provider.DataSource);
-    }
-
-    public static IEnumerable<object[]> Icon_Set_TestData()
-    {
-        // TODO: we're leaking a handle here, see TaskDialogIcon.BitmapToIcon for correct implementation
-        yield return new object[] { Icon.FromHandle(new Bitmap(10, 10).GetHicon()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_Set_TestData))]
-    public void ErrorProvider_Icon_Set_GetReturnsExpected(Icon value)
-    {
-        using var provider = new ErrorProvider
-        {
-            Icon = value
-        };
-        Assert.Same(value, provider.Icon);
-
-        // Set same.
-        provider.Icon = value;
-        Assert.Same(value, provider.Icon);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Icon_ShouldSerializeValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.Icon)];
-        Assert.False(property.ShouldSerializeValue(provider));
-
-        // TODO: we're leaking a handle here, see TaskDialogIcon.BitmapToIcon for correct implementation
-        provider.Icon = Icon.FromHandle(new Bitmap(10, 10).GetHicon());
-        Assert.True(property.ShouldSerializeValue(provider));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Icon_CanResetValue_ReturnsExpected()
-    {
-        using var provider = new ErrorProvider();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ErrorProvider))[nameof(ErrorProvider.Icon)];
-        Assert.False(property.CanResetValue(provider));
-
-        // TODO: we're leaking a handle here, see TaskDialogIcon.BitmapToIcon for correct implementation
-        provider.Icon = Icon.FromHandle(new Bitmap(10, 10).GetHicon());
-        Assert.True(property.CanResetValue(provider));
-
-        property.ResetValue(provider);
-        Assert.False(property.CanResetValue(provider));
-        Assert.Null(provider.DataSource);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Icon_Null_ThrowsArgumentNullException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("value", () => provider.Icon = null);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ErrorProvider_RightToLeft_Set_GetReturnsExpected(bool value)
-    {
-        using var provider = new ErrorProvider
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(value, provider.RightToLeft);
-
-        // Set same.
-        provider.RightToLeft = value;
-        Assert.Equal(value, provider.RightToLeft);
-
-        // Set different.
-        provider.RightToLeft = !value;
-        Assert.Equal(!value, provider.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var provider = new ErrorProvider
-        {
-            RightToLeft = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(provider, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        provider.RightToLeftChanged += handler;
-
-        // Set different.
-        provider.RightToLeft = false;
-        Assert.False(provider.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        provider.RightToLeft = false;
-        Assert.False(provider.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        provider.RightToLeft = true;
-        Assert.True(provider.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        provider.RightToLeftChanged -= handler;
-        provider.RightToLeft = false;
-        Assert.False(provider.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Site_Set_TestData()
-    {
-        yield return new object[] { null };
-
-        var mockNullHostSite = new Mock<ISite>(MockBehavior.Strict);
-        mockNullHostSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        yield return new object[] { mockNullHostSite.Object };
-
-        var mockInvalidHostSite = new Mock<ISite>(MockBehavior.Strict);
-        mockInvalidHostSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(new object());
-        yield return new object[] { mockInvalidHostSite.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void ErrorProvider_Site_Set_GetReturnsExpected(ISite value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        using var provider = new ErrorProvider
-        {
-            Site = value
-        };
-        Assert.Same(value, provider.Site);
-
-        // Set same.
-        provider.Site = value;
-        Assert.Same(value, provider.Site);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        provider.Site = null;
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void ErrorProvider_Site_SetWithNonNullOldValue_GetReturnsExpected(ISite value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(null);
-        using var provider = new ErrorProvider
-        {
-            Site = mockSite.Object
-        };
-
-        provider.Site = value;
-        Assert.Same(value, provider.Site);
-
-        // Set same.
-        provider.Site = value;
-        Assert.Same(value, provider.Site);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        provider.Site = null;
-    }
-
-    public static IEnumerable<object[]> Site_SetWithIDesignerHost_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new Component(), null };
-
-        var containerControl = new ContainerControl();
-        yield return new object[] { containerControl, containerControl };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_SetWithIDesignerHost_TestData))]
-    public void ErrorProvider_Site_SetWithIDesignerHost_SetsContainerControl(IComponent rootComponent, ContainerControl expected)
-    {
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.RootComponent)
-            .Returns(rootComponent);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object)
-            .Verifiable();
-        using var provider = new ErrorProvider
-        {
-            Site = mockSite.Object
-        };
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-        Assert.Same(mockSite.Object, provider.Site);
-        Assert.Same(expected, provider.ContainerControl);
-        mockSite.Verify(s => s.GetService(typeof(IDesignerHost)), Times.Once());
-        mockDesignerHost.Verify(h => h.RootComponent, Times.Once());
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        provider.Site = null;
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ErrorProvider_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var provider = new ErrorProvider
-        {
-            Tag = value
-        };
-        Assert.Same(value, provider.Tag);
-
-        // Set same.
-        provider.Tag = value;
-        Assert.Same(value, provider.Tag);
-    }
-
-    public static IEnumerable<object[]> BindToDataAndErrors_TestData()
-    {
-        foreach (ContainerControl containerControl in new ContainerControl[] { null, new SubContainerControl() })
-        {
-            foreach (string dataMember in new string[] { null, string.Empty, "dataMember" })
-            {
-                yield return new object[] { containerControl, null, dataMember };
-                yield return new object[] { containerControl, new object(), dataMember };
-                yield return new object[] { containerControl, new DataClass(), dataMember };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindToDataAndErrors_TestData))]
-    public void BindToDataAndErrors_Invoke_SetsDataSourceAndDataMember(ContainerControl containerControl, object newDataSource, string newDataMember)
-    {
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl
-        };
-        provider.BindToDataAndErrors(newDataSource, newDataMember);
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Same(newDataMember, provider.DataMember);
-
-        // Call again.
-        provider.BindToDataAndErrors(newDataSource, newDataMember);
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Same(newDataMember, provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> BindToDataAndErrors_WithBindingContext_TestData()
-    {
-        foreach (string dataMember in new string[] { null, string.Empty })
-        {
-            yield return new object[] { null, dataMember };
-            yield return new object[] { new object(), dataMember };
-            yield return new object[] { new DataClass(), dataMember };
-        }
-
-        yield return new object[] { null, nameof(DataClass.Value) };
-        yield return new object[] { null, nameof(DataClass.ListValue) };
-        yield return new object[] { new DataClass(), nameof(DataClass.Value) };
-        yield return new object[] { new DataClass(), nameof(DataClass.ListValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindToDataAndErrors_WithBindingContext_TestData))]
-    public void BindToDataAndErrors_InvokeValidDataMemberWithBindingContext_SetsDataSourceAndDataMember(object newDataSource, string newDataMember)
-    {
-        using var containerControl = new ContainerControl();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl
-        };
-        provider.BindToDataAndErrors(newDataSource, newDataMember);
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Same(newDataMember, provider.DataMember);
-
-        // Call again.
-        provider.BindToDataAndErrors(newDataSource, newDataMember);
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Same(newDataMember, provider.DataMember);
-    }
-
-    [WinFormsFact]
-    public void BindToDataAndErrors_InvokeInvalidDataMemberWithBindingContext_ThrowsArgumentException()
-    {
-        using var containerControl = new ContainerControl();
-        using var provider = new ErrorProvider
-        {
-            ContainerControl = containerControl
-        };
-        var newDataSource = new DataClass();
-        Assert.Throws<ArgumentException>(() => provider.BindToDataAndErrors(newDataSource, "NoSuchValue"));
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Equal("NoSuchValue", provider.DataMember);
-
-        // Call again.
-        provider.BindToDataAndErrors(newDataSource, "NoSuchValue");
-        Assert.Same(newDataSource, provider.DataSource);
-        Assert.Equal("NoSuchValue", provider.DataMember);
-    }
-
-    public static IEnumerable<object[]> CanExtend_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { new object(), false };
-        yield return new object[] { new Component(), false };
-        yield return new object[] { new Form(), false };
-        yield return new object[] { new Control(), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanExtend_TestData))]
-    public void ErrorProvider_CanExtend_Invoke_ReturnsExpected(object extendee, bool expected)
-    {
-        using var provider = new ErrorProvider();
-        Assert.Equal(expected, provider.CanExtend(extendee));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Clear_InvokeMultipleTimesWithItems_Success()
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        provider.SetError(control, "error");
-        Assert.Equal("error", provider.GetError(control));
-
-        provider.Clear();
-        Assert.Empty(provider.GetError(control));
-
-        provider.Clear();
-        Assert.Empty(provider.GetError(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Clear_InvokeMultipleTimesWithoutItems_Nop()
-    {
-        using var provider = new ErrorProvider();
-        provider.Clear();
-        provider.Clear();
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Dispose_InvokeWithItems_Clears()
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        provider.SetError(control, "error");
-        Assert.Equal("error", provider.GetError(control));
-
-        provider.Dispose();
-        Assert.NotNull(provider.Icon);
-        Assert.Empty(provider.GetError(control));
-
-        provider.Dispose();
-        Assert.NotNull(provider.Icon);
-        Assert.Empty(provider.GetError(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Dispose_InvokeMultipleTimesWithoutItems_Nop()
-    {
-        using var provider = new ErrorProvider();
-        provider.Dispose();
-        Assert.NotNull(provider.Icon);
-
-        provider.Dispose();
-        Assert.NotNull(provider.Icon);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "")]
-    [InlineData(false, "error")]
-    public void ErrorProvider_Dispose_InvokeBoolWithItems_ClearsIfDisposing(bool disposing, string expectedError)
-    {
-        using var provider = new SubErrorProvider();
-        using var control = new Control();
-        provider.SetError(control, "error");
-        Assert.Equal("error", provider.GetError(control));
-
-        provider.Dispose(disposing);
-        Assert.NotNull(provider.Icon);
-        Assert.Equal(expectedError, provider.GetError(control));
-
-        provider.Dispose(disposing);
-        Assert.NotNull(provider.Icon);
-        Assert.Equal(expectedError, provider.GetError(control));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ErrorProvider_Dispose_InvokeBoolMultipleTimesDefault_Nop(bool disposing)
-    {
-        using var provider = new SubErrorProvider();
-        provider.Dispose(disposing);
-        Assert.NotNull(provider.Icon);
-
-        provider.Dispose(disposing);
-        Assert.NotNull(provider.Icon);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetError_InvokeWithoutError_ReturnsEmpty()
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        Assert.Empty(provider.GetError(control));
-
-        // Call again.
-        Assert.Empty(provider.GetError(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetError_NullControl_ThrowsArgumentNullException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.GetError(null));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetIconAlignment_InvokeWithoutError_ReturnsMiddleRight()
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        Assert.Equal(ErrorIconAlignment.MiddleRight, provider.GetIconAlignment(control));
-
-        // Call again.
-        Assert.Equal(ErrorIconAlignment.MiddleRight, provider.GetIconAlignment(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetIconAlignment_NullControl_ThrowsArgumentNullException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.GetIconAlignment(null));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetIconPadding_InvokeWithoutError_ReturnsZero()
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        Assert.Equal(0, provider.GetIconPadding(control));
-
-        // Call again.
-        Assert.Equal(0, provider.GetIconPadding(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_GetIconPadding_NullControl_ThrowsArgumentNullException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.GetIconPadding(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ErrorProvider_OnRightToLeftChanged_Invoke_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var provider = new SubErrorProvider();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(provider, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        provider.RightToLeftChanged += handler;
-        provider.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        provider.RightToLeftChanged -= handler;
-        provider.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> SetError_TestData()
-    {
-        foreach (ErrorBlinkStyle blinkStyle in Enum.GetValues(typeof(ErrorBlinkStyle)))
-        {
-            yield return new object[] { blinkStyle, null, string.Empty };
-            yield return new object[] { blinkStyle, string.Empty, string.Empty };
-            yield return new object[] { blinkStyle, "value", "value" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetError_TestData))]
-    public void ErrorProvider_SetError_Invoke_GetErrorReturnsExpected(ErrorBlinkStyle blinkStyle, string value, string expected)
-    {
-        using var provider = new ErrorProvider
-        {
-            BlinkStyle = blinkStyle
-        };
-        using var control = new Control();
-
-        provider.SetError(control, value);
-        Assert.Equal(expected, provider.GetError(control));
-
-        // Call again.
-        provider.SetError(control, value);
-        Assert.Equal(expected, provider.GetError(control));
-
-        // Set empty.
-        provider.SetError(control, string.Empty);
-        Assert.Empty(provider.GetError(control));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ErrorProvider_SetError_NullControl_ThrowsArgumentNullException(string value)
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.SetError(null, value));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ErrorIconAlignment>]
-    public void ErrorProvider_SetIconAlignment_Invoke_GetIconAlignmentReturnsExpected(ErrorIconAlignment value)
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-
-        provider.SetIconAlignment(control, value);
-        Assert.Equal(value, provider.GetIconAlignment(control));
-
-        // Call again.
-        provider.SetIconAlignment(control, value);
-        Assert.Equal(value, provider.GetIconAlignment(control));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ErrorIconAlignment>]
-    [InvalidEnumData<ErrorIconAlignment>]
-    public void ErrorProvider_SetIconAlignment_NullControl_ThrowsArgumentNullException(ErrorIconAlignment value)
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.SetIconAlignment(null, value));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ErrorIconAlignment>]
-    public void ErrorProvider_SetIconAlignment_InvalidValue_ThrowsInvalidEnumArgumentException(ErrorIconAlignment value)
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => provider.SetIconAlignment(control, value));
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ErrorProvider_SetIconPadding_Invoke_GetIconPaddingReturnsExpected(int value)
-    {
-        using var provider = new ErrorProvider();
-        using var control = new Control();
-
-        provider.SetIconPadding(control, value);
-        Assert.Equal(value, provider.GetIconPadding(control));
-
-        // Call again.
-        provider.SetIconPadding(control, value);
-        Assert.Equal(value, provider.GetIconPadding(control));
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_SetIconPadding_NullControl_ThrowsArgumentNullException()
-    {
-        using var provider = new ErrorProvider();
-        Assert.Throws<ArgumentNullException>("control", () => provider.SetIconPadding(null, 0));
-    }
-
-    public static IEnumerable<object[]> CallEvents_TestData()
-    {
-        foreach (ErrorBlinkStyle blinkStyle in Enum.GetValues(typeof(ErrorBlinkStyle)))
-        {
-            foreach (string error in new string[] { null, string.Empty, "error" })
-            {
-                yield return new object[] { blinkStyle, new SubControl(), error, error ?? string.Empty };
-                yield return new object[] { blinkStyle, new SubControl { Visible = false }, error, error ?? string.Empty };
-                yield return new object[] { blinkStyle, new SubControl { Parent = new Control() }, error, error ?? string.Empty };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CallEvents_TestData))]
-    public void ErrorProvider_Items_CallEvents_Success(ErrorBlinkStyle blinkStyle, SubControl control, string error, string expected)
-    {
-        bool originalVisible = control.Visible;
-        using var originalParent = new Control();
-        using var newParent = new Control();
-
-        using (var provider = new ErrorProvider
-        {
-            BlinkStyle = blinkStyle
-        })
-        {
-            provider.SetError(control, error);
-            Assert.Equal(expected, provider.GetError(control));
-
-            // Call event properties - without handle.
-            control.Location = new Point(1, 2);
-            Assert.Equal(new Point(1, 2), control.Location);
-
-            control.Size = new Size(2, 3);
-            Assert.Equal(new Size(2, 3), control.Size);
-
-            control.Visible = !originalVisible;
-            Assert.Equal(!originalVisible, control.Visible);
-
-            control.Visible = originalVisible;
-            Assert.Equal(originalVisible, control.Visible);
-
-            control.Parent = newParent;
-            Assert.Same(newParent, control.Parent);
-
-            control.Parent = null;
-            Assert.Null(control.Parent);
-
-            control.Parent = originalParent;
-            Assert.Same(originalParent, control.Parent);
-
-            // Call event methods - without handle.
-            control.OnHandleCreated(EventArgs.Empty);
-            control.OnHandleDestroyed(EventArgs.Empty);
-            control.OnLocationChanged(EventArgs.Empty);
-            control.OnSizeChanged(EventArgs.Empty);
-            control.OnVisibleChanged(EventArgs.Empty);
-            control.OnParentChanged(EventArgs.Empty);
-
-            // Call event properties - with handle.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-            control.Location = new Point(2, 3);
-            Assert.Equal(new Point(2, 3), control.Location);
-
-            control.Size = new Size(4, 5);
-            Assert.Equal(new Size(4, 5), control.Size);
-
-            control.Visible = !originalVisible;
-            Assert.Equal(!originalVisible, control.Visible);
-
-            control.Visible = originalVisible;
-            Assert.Equal(originalVisible, control.Visible);
-
-            control.Parent = newParent;
-            Assert.Same(newParent, control.Parent);
-
-            control.Parent = null;
-            Assert.Null(control.Parent);
-
-            control.Parent = originalParent;
-            Assert.Same(originalParent, control.Parent);
-
-            // Call event methods - with handle.
-            control.OnHandleCreated(EventArgs.Empty);
-            control.OnHandleDestroyed(EventArgs.Empty);
-            control.OnLocationChanged(EventArgs.Empty);
-            control.OnSizeChanged(EventArgs.Empty);
-            control.OnVisibleChanged(EventArgs.Empty);
-            control.OnParentChanged(EventArgs.Empty);
-
-            control.Dispose();
-        }
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_HasErrors_NoControl_Set()
-    {
-        using var provider = new ErrorProvider();
-
-        Assert.False(provider.HasErrors);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_HasErrors_SomeControlsSet()
-    {
-        using var provider = new ErrorProvider();
-        using var control1 = new Control();
-
-        provider.SetError(control1, "error");
-
-        Assert.True(provider.HasErrors);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_HasErrors_ControlErrorReset()
-    {
-        using var provider = new ErrorProvider();
-        using var control1 = new Control();
-
-        provider.SetError(control1, String.Empty);
-        Assert.True(provider.HasErrors);
-
-        provider.Clear();
-        Assert.False(provider.HasErrors);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_CustomDataSource_DoesNotThrowInvalidCastException()
-    {
-        using Form form = new();
-        CustomDataSource customDataSource = new();
-        form.DataBindings.Add("Text", customDataSource, "Error");
-        using ErrorProvider errorProvider = new(form);
-
-        var exception = Record.Exception(() => errorProvider.DataSource = customDataSource);
-
-        Assert.Null(exception);
-    }
-
-    [WinFormsFact]
-    public void ErrorProvider_Icon_NotDisposed_Unexpectedly()
-    {
-        // Unit test for https://github.com/dotnet/winforms/issues/8513.
-        using var provider = new ErrorProvider();
-        var icon = provider.Icon;
-
-        Assert.NotNull(icon);
-
-        nint handle = icon.Handle;
-        using Icon newIcon = new("bitmaps/10x16_one_entry_32bit.ico");
-        provider.Icon = newIcon;
-
-        Assert.NotNull(provider.Icon);
-
-        // Make sure the old icon that is not owned by us, is not disposed
-        Assert.Equal(handle, icon.Handle);
-    }
-
-    private class CustomDataSource : IDataErrorInfo
-    {
-        public string this[string columnName] => string.Empty;
-
-        public string Error => string.Empty;
-    }
-
-    private class SubErrorProvider : ErrorProvider
-    {
-        public SubErrorProvider() : base()
-        {
-        }
-
-        public SubErrorProvider(ContainerControl parentControl) : base(parentControl)
-        {
-        }
-
-        public SubErrorProvider(IContainer container) : base(container)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-    }
-
-    private class DataClass
-    {
-        public int Value { get; set; }
-
-        public List<int> ListValue { get; set; }
-    }
-
-    private class SubContainerControl : ContainerControl
-    {
-        public override BindingContext BindingContext => null;
-    }
-
-    public class SubControl : Control
-    {
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnLocationChanged(EventArgs e) => base.OnLocationChanged(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnSizeChanged(EventArgs e) => base.OnSizeChanged(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FeatureSupportTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FeatureSupportTests.cs
deleted file mode 100644
index 105ec43a5c3..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FeatureSupportTests.cs
+++ /dev/null
@@ -1,201 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class FeatureSupportTests
-{
-    public static IEnumerable<object[]> IsPresent_DefaultMinimumVersion_TestData()
-    {
-        yield return new object[] { null, new object(), false };
-        yield return new object[] { new Version(0, 0, 0, 0), new object(), true };
-        yield return new object[] { new Version(1, 2, 3, 4), new object(), true };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsPresent_DefaultMinimumVersion_TestData))]
-    public void FeatureSupport_IsPresent_InvokeDefaultMinimVersion_ReturnsExpected(Version versionPresent, object feature, bool expected)
-    {
-        var featureSupport = new Mock<FeatureSupport>(MockBehavior.Strict);
-        featureSupport
-            .Setup(s => s.IsPresent(feature))
-            .CallBase();
-        featureSupport
-            .Setup(s => s.IsPresent(feature, new Version(0, 0, 0, 0)))
-            .CallBase();
-        featureSupport
-            .Setup(s => s.GetVersionPresent(feature))
-            .Returns(versionPresent);
-        Assert.Equal(expected, featureSupport.Object.IsPresent(feature));
-    }
-
-    public static IEnumerable<object[]> IsPresent_CustomMinimumVersion_TestData()
-    {
-        yield return new object[] { null, new object(), new Version(1, 2, 3, 4), false };
-        yield return new object[] { null, new object(), null, false };
-        yield return new object[] { new Version(0, 0, 0, 0), new object(), new Version(0, 0, 0, 0), true };
-        yield return new object[] { new Version(0, 0, 0, 0), new object(), new Version(1, 2, 3, 4), false };
-        yield return new object[] { new Version(0, 0, 0, 0), new object(), null, true };
-        yield return new object[] { new Version(1, 2, 3, 4), new object(), new Version(1, 2, 3, 4), true };
-        yield return new object[] { new Version(1, 2, 3, 4), new object(), new Version(1, 2, 3, 4), true };
-        yield return new object[] { new Version(1, 2, 3, 4), new object(), new Version(2, 3, 4, 5), false };
-        yield return new object[] { new Version(1, 2, 3, 4), new object(), null, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsPresent_CustomMinimumVersion_TestData))]
-    public void FeatureSupport_IsPresent_InvokeCustomMinimumVersion_ReturnsExpected(Version versionPresent, object feature, Version minimumVersion, bool expected)
-    {
-        var featureSupport = new Mock<FeatureSupport>(MockBehavior.Strict);
-        featureSupport
-            .Setup(s => s.IsPresent(feature, minimumVersion))
-            .CallBase();
-        featureSupport
-            .Setup(s => s.GetVersionPresent(feature))
-            .Returns(versionPresent);
-        Assert.Equal(expected, featureSupport.Object.IsPresent(feature, minimumVersion));
-    }
-
-    public static IEnumerable<object[]> GetVersionPresent_TestData()
-    {
-        foreach (string invalidType in new string[] { null, string.Empty, "NoSuchType" })
-        {
-            yield return new object[] { invalidType, null, null };
-            yield return new object[] { invalidType, string.Empty, null };
-            yield return new object[] { invalidType, "NoSuchField", null };
-        }
-
-        yield return new object[] { typeof(NonIFeatureSupportClass).AssemblyQualifiedName, nameof(NonIFeatureSupportClass.s_field), null };
-
-        yield return new object[] { typeof(IFeatureSupportClass).FullName, nameof(IFeatureSupportClass.s_field), null };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "NoSuchField", null };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "_privateField", null };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "s_privateField", null };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_field), new Version(1, 2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetVersionPresent_TestData))]
-    public void FeatureSupport_GetVersionPresent_Invoke_ReturnsExpected(string featureClassName, string featureConstName, Version expected)
-    {
-        Assert.Equal(expected, FeatureSupport.GetVersionPresent(featureClassName, featureConstName));
-    }
-
-    [Theory]
-    [InlineData(typeof(IFeatureSupportClass), nameof(IFeatureSupportClass._field))]
-    [InlineData(typeof(NonIFeatureSupportClass), nameof(NonIFeatureSupportClass._field))]
-    public void FeatureSupport_GetVersionPresent_NonStaticField_ThrowsTargetException(Type featureClassType, string featureConstName)
-    {
-        Assert.Throws<TargetException>(() => FeatureSupport.GetVersionPresent(featureClassType.AssemblyQualifiedName, featureConstName));
-    }
-
-    public static IEnumerable<object[]> IsPresent_DefaultMinimumVersionClassName_TestData()
-    {
-        foreach (string invalidType in new string[] { null, string.Empty, "NoSuchType" })
-        {
-            yield return new object[] { invalidType, null, false };
-            yield return new object[] { invalidType, string.Empty, false };
-            yield return new object[] { invalidType, "NoSuchField", false };
-        }
-
-        yield return new object[] { typeof(NonIFeatureSupportClass).AssemblyQualifiedName, nameof(NonIFeatureSupportClass.s_field), false };
-
-        yield return new object[] { typeof(IFeatureSupportClass).FullName, nameof(IFeatureSupportClass.s_field), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "NoSuchField", false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "_privateField", false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "s_privateField", false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_zeroVersionField), true };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_nonZeroVersionField), true };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsPresent_DefaultMinimumVersionClassName_TestData))]
-    public void FeatureSupport_IsPresent_InvokeDefaultMinimumVersionClassName_ReturnsExpected(string featureClassName, string featureConstName, bool expected)
-    {
-        Assert.Equal(expected, FeatureSupport.IsPresent(featureClassName, featureConstName));
-    }
-
-    public static IEnumerable<object[]> IsPresent_CustomMinimumVersionClassName_TestData()
-    {
-        foreach (string invalidType in new string[] { null, string.Empty, "NoSuchType" })
-        {
-            yield return new object[] { invalidType, null, new Version(1, 2, 3, 4), false };
-            yield return new object[] { invalidType, string.Empty, new Version(1, 2, 3, 4), false };
-            yield return new object[] { invalidType, "NoSuchField", new Version(1, 2, 3, 4), false };
-        }
-
-        yield return new object[] { typeof(NonIFeatureSupportClass).AssemblyQualifiedName, nameof(NonIFeatureSupportClass.s_field), new Version(1, 2, 3, 4), false };
-
-        yield return new object[] { typeof(IFeatureSupportClass).FullName, nameof(IFeatureSupportClass.s_field), new Version(1, 2, 3, 4), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "NoSuchField", new Version(1, 2, 3, 4), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "_privateField", new Version(1, 2, 3, 4), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, "s_privateField", new Version(1, 2, 3, 4), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_zeroVersionField), new Version(0, 0, 0, 0), true };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_zeroVersionField), new Version(1, 2, 3, 4), false };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_nonZeroVersionField), new Version(0, 0, 0, 0), true };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_nonZeroVersionField), new Version(1, 2, 3, 4), true };
-        yield return new object[] { typeof(IFeatureSupportClass).AssemblyQualifiedName, nameof(IFeatureSupportClass.s_nonZeroVersionField), new Version(2, 3, 4, 5), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsPresent_CustomMinimumVersionClassName_TestData))]
-    public void FeatureSupport_IsPresent_InvokeCustomMinimumVersionClassName_ReturnsExpected(string featureClassName, string featureConstName, Version minimumVersion, bool expected)
-    {
-        Assert.Equal(expected, FeatureSupport.IsPresent(featureClassName, featureConstName, minimumVersion));
-    }
-
-    [Theory]
-    [InlineData(typeof(IFeatureSupportClass), nameof(IFeatureSupportClass._field))]
-    [InlineData(typeof(NonIFeatureSupportClass), nameof(NonIFeatureSupportClass._field))]
-    public void FeatureSupport_IsPresent_NonStaticField_ThrowsTargetException(Type featureClassType, string featureConstName)
-    {
-        Assert.Throws<TargetException>(() => FeatureSupport.IsPresent(featureClassType.AssemblyQualifiedName, featureConstName));
-        Assert.Throws<TargetException>(() => FeatureSupport.IsPresent(featureClassType.AssemblyQualifiedName, featureConstName, new Version(1, 2, 3, 4)));
-    }
-
-    private class IFeatureSupportClass : IFeatureSupport
-    {
-        public bool IsPresent(object feature) => throw new NotImplementedException();
-
-        public bool IsPresent(object feature, Version minimumVersion)
-        {
-            if (feature == s_zeroVersionField)
-            {
-                return new Version(0, 0, 0, 0) >= minimumVersion;
-            }
-            else if (feature == s_nonZeroVersionField)
-            {
-                return new Version(1, 2, 3, 4) >= minimumVersion;
-            }
-
-            throw new InvalidOperationException();
-        }
-
-        public Version GetVersionPresent(object feature)
-        {
-            Assert.Equal(s_field, feature);
-            return new Version(1, 2, 3, 4);
-        }
-
-        public object _field = new();
-        public static object s_field = new();
-
-        public static object s_zeroVersionField = new();
-        public static object s_nonZeroVersionField = new();
-
-#pragma warning disable CA1823 // Unused field
-        private readonly object _privateField = new();
-        private static readonly object s_privateField = new();
-#pragma warning restore CA1823 // Unused field
-    }
-
-    private class NonIFeatureSupportClass
-    {
-        public object _field = new();
-        public static object s_field = new();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FileDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FileDialogTests.cs
deleted file mode 100644
index 45125f7118f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FileDialogTests.cs
+++ /dev/null
@@ -1,827 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Windows.Win32.UI.Controls.Dialogs;
-
-namespace System.Windows.Forms.Tests;
-
-public class FileDialogTests
-{
-    [WinFormsFact]
-    public void FileDialog_Ctor_Default()
-    {
-        using var dialog = new SubFileDialog();
-        Assert.True(dialog.AddExtension);
-        Assert.True(dialog.AddToRecent);
-        Assert.True(dialog.AutoUpgradeEnabled);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.False(dialog.CheckFileExists);
-        Assert.True(dialog.CheckPathExists);
-        Assert.Null(dialog.Container);
-        Assert.Empty(dialog.CustomPlaces);
-        Assert.Same(dialog.CustomPlaces, dialog.CustomPlaces);
-        Assert.False(dialog.DesignMode);
-        Assert.Empty(dialog.DefaultExt);
-        Assert.True(dialog.DereferenceLinks);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.Empty(dialog.FileName);
-        Assert.Empty(dialog.FileNames);
-        Assert.Same(dialog.FileNames, dialog.FileNames);
-        Assert.Equal(1, dialog.FilterIndex);
-        Assert.Empty(dialog.InitialDirectory);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.False(dialog.OkRequiresInteraction);
-        Assert.Equal(2052, dialog.Options);
-        Assert.False(dialog.RestoreDirectory);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.ShowHiddenFiles);
-        Assert.False(dialog.SupportMultiDottedExtensions);
-        Assert.True(dialog.ShowPinnedPlaces);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-        Assert.Empty(dialog.Title);
-        Assert.True(dialog.ValidateNames);
-        Assert.Null(dialog.ClientGuid);
-    }
-
-    [WinFormsFact]
-    public void FileDialog_Ctor_Default_OverridenReset()
-    {
-        using var dialog = new EmptyResetFileDialog();
-        Assert.False(dialog.AddExtension);
-        Assert.True(dialog.AddToRecent);
-        Assert.True(dialog.AutoUpgradeEnabled);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.False(dialog.CheckFileExists);
-        Assert.False(dialog.CheckPathExists);
-        Assert.Null(dialog.Container);
-        Assert.Empty(dialog.CustomPlaces);
-        Assert.Same(dialog.CustomPlaces, dialog.CustomPlaces);
-        Assert.False(dialog.DesignMode);
-        Assert.Empty(dialog.DefaultExt);
-        Assert.True(dialog.DereferenceLinks);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.Empty(dialog.FileName);
-        Assert.Empty(dialog.FileNames);
-        Assert.Same(dialog.FileNames, dialog.FileNames);
-        Assert.Equal(0, dialog.FilterIndex);
-        Assert.Empty(dialog.InitialDirectory);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.False(dialog.OkRequiresInteraction);
-        Assert.Equal(0, dialog.Options);
-        Assert.False(dialog.RestoreDirectory);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.ShowHiddenFiles);
-        Assert.True(dialog.ShowPinnedPlaces);
-        Assert.False(dialog.SupportMultiDottedExtensions);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-        Assert.Empty(dialog.Title);
-        Assert.True(dialog.ValidateNames);
-        Assert.Null(dialog.ClientGuid);
-    }
-
-    [WinFormsFact]
-    public void FileDialog_EventFileOk_Get_ReturnsExpected()
-    {
-        Assert.NotNull(SubFileDialog.EventFileOk);
-        Assert.Same(SubFileDialog.EventFileOk, SubFileDialog.EventFileOk);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FileDialog_AddExtension_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            AddExtension = value
-        };
-        Assert.Equal(value, dialog.AddExtension);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.AddExtension = value;
-        Assert.Equal(value, dialog.AddExtension);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set different.
-        dialog.AddExtension = !value;
-        Assert.Equal(!value, dialog.AddExtension);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2052, 33556484)]
-    [InlineData(false, 33556484, 2052)]
-    public void FileDialog_AddToRecent_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            AddToRecent = value
-        };
-        Assert.Equal(value, dialog.AddToRecent);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AddToRecent = value;
-        Assert.Equal(value, dialog.AddToRecent);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AddToRecent = !value;
-        Assert.Equal(!value, dialog.AddToRecent);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FileDialog_AutoUpgradeEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            AutoUpgradeEnabled = value
-        };
-        Assert.Equal(value, dialog.AutoUpgradeEnabled);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.AutoUpgradeEnabled = value;
-        Assert.Equal(value, dialog.AutoUpgradeEnabled);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set different.
-        dialog.AutoUpgradeEnabled = !value;
-        Assert.Equal(!value, dialog.AutoUpgradeEnabled);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FileDialog_CheckFileExists_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            CheckFileExists = value
-        };
-        Assert.Equal(value, dialog.CheckFileExists);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.CheckFileExists = value;
-        Assert.Equal(value, dialog.CheckFileExists);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set different.
-        dialog.CheckFileExists = !value;
-        Assert.Equal(!value, dialog.CheckFileExists);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2052, 4)]
-    [InlineData(false, 4, 2052)]
-    public void FileDialog_CheckPathExists_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            CheckPathExists = value
-        };
-        Assert.Equal(value, dialog.CheckPathExists);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.CheckPathExists = value;
-        Assert.Equal(value, dialog.CheckPathExists);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.CheckPathExists = !value;
-        Assert.Equal(!value, dialog.CheckPathExists);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData("00000000-0000-0000-0000-000000000000")]
-    [InlineData("1d5a0215-fa19-4e3b-8ab9-06da88c28ae7")]
-    public void FileDialog_ClientGuid_Set_GetReturnsExpected(Guid value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ClientGuid = value
-        };
-        Assert.Equal(value, dialog.ClientGuid);
-
-        // Set same.
-        dialog.ClientGuid = value;
-        Assert.Equal(value, dialog.ClientGuid);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData(".", "")]
-    [InlineData(".ext", "ext")]
-    [InlineData("..ext", ".ext")]
-    [InlineData("ext", "ext")]
-    public void FileDialog_DefaultExt_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var dialog = new SubFileDialog
-        {
-            DefaultExt = value
-        };
-        Assert.Equal(expected, dialog.DefaultExt);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.DefaultExt = value;
-        Assert.Equal(expected, dialog.DefaultExt);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2052, 1050628)]
-    [InlineData(false, 1050628, 2052)]
-    public void FileDialog_DereferenceLinks_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            DereferenceLinks = value
-        };
-        Assert.Equal(value, dialog.DereferenceLinks);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.DereferenceLinks = value;
-        Assert.Equal(value, dialog.DereferenceLinks);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.DereferenceLinks = !value;
-        Assert.Equal(!value, dialog.DereferenceLinks);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, new string[0])]
-    [InlineData("", new string[] { "" })]
-    [InlineData("fileName", new string[] { "fileName" })]
-    public void FileDialog_FileName_Set_GetReturnsExpected(string value, string[] expectedFileNames)
-    {
-        using var dialog = new SubFileDialog
-        {
-            FileName = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.FileName);
-        Assert.Equal(expectedFileNames, dialog.FileNames);
-        if (expectedFileNames.Length > 0)
-        {
-            Assert.Equal(dialog.FileNames, dialog.FileNames);
-            Assert.NotSame(dialog.FileNames, dialog.FileNames);
-        }
-        else
-        {
-            Assert.Same(dialog.FileNames, dialog.FileNames);
-        }
-
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.FileName = value;
-        Assert.Equal(value ?? string.Empty, dialog.FileName);
-        if (expectedFileNames.Length > 0)
-        {
-            Assert.Equal(dialog.FileNames, dialog.FileNames);
-            Assert.NotSame(dialog.FileNames, dialog.FileNames);
-        }
-        else
-        {
-            Assert.Same(dialog.FileNames, dialog.FileNames);
-        }
-
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("filter|filter")]
-    [InlineData("filter|filter|filter|filter")]
-    public void FileDialog_Filter_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            Filter = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.Filter);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.Filter = value;
-        Assert.Equal(value ?? string.Empty, dialog.Filter);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData("filter")]
-    [InlineData("filter|filter|filter")]
-    public void FileDialog_Filter_SetInvalid_ThrowsArgumentException(string value)
-    {
-        using var dialog = new SubFileDialog();
-        Assert.Throws<ArgumentException>("value", () => dialog.Filter = value);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void FileDialog_FilterIndex_Set_GetReturnsExpected(int value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            FilterIndex = value
-        };
-        Assert.Equal(value, dialog.FilterIndex);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.FilterIndex = value;
-        Assert.Equal(value, dialog.FilterIndex);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void FileDialog_InitialDirectory_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            InitialDirectory = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.InitialDirectory);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.InitialDirectory = value;
-        Assert.Equal(value ?? string.Empty, dialog.InitialDirectory);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2099204, 2052)]
-    [InlineData(false, 2052, 2099204)]
-    public void FileDialog_OkRequiresInteraction_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            OkRequiresInteraction = value
-        };
-        Assert.Equal(value, dialog.OkRequiresInteraction);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.OkRequiresInteraction = value;
-        Assert.Equal(value, dialog.OkRequiresInteraction);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.OkRequiresInteraction = !value;
-        Assert.Equal(!value, dialog.OkRequiresInteraction);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2060, 2052)]
-    [InlineData(false, 2052, 2060)]
-    public void FileDialog_RestoreDirectory_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            RestoreDirectory = value
-        };
-        Assert.Equal(value, dialog.RestoreDirectory);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.RestoreDirectory = value;
-        Assert.Equal(value, dialog.RestoreDirectory);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.RestoreDirectory = !value;
-        Assert.Equal(!value, dialog.RestoreDirectory);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2068, 2052)]
-    [InlineData(false, 2052, 2068)]
-    public void FileDialog_ShowHelp_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ShowHelp = value
-        };
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowHelp = value;
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowHelp = !value;
-        Assert.Equal(!value, dialog.ShowHelp);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 268437508, 2052)]
-    [InlineData(false, 2052, 268437508)]
-    public void FileDialog_ShowHiddenFiles_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ShowHiddenFiles = value
-        };
-        Assert.Equal(value, dialog.ShowHiddenFiles);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowHiddenFiles = value;
-        Assert.Equal(value, dialog.ShowHiddenFiles);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowHiddenFiles = !value;
-        Assert.Equal(!value, dialog.ShowHiddenFiles);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2052, 264196)]
-    [InlineData(false, 264196, 2052)]
-    public void FileDialog_ShowPinnedPlaces_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ShowPinnedPlaces = value
-        };
-        Assert.Equal(value, dialog.ShowPinnedPlaces);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowPinnedPlaces = value;
-        Assert.Equal(value, dialog.ShowPinnedPlaces);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowPinnedPlaces = !value;
-        Assert.Equal(!value, dialog.ShowPinnedPlaces);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FileDialog_SupportMultiDottedExtensions_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            SupportMultiDottedExtensions = value
-        };
-        Assert.Equal(value, dialog.SupportMultiDottedExtensions);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.SupportMultiDottedExtensions = value;
-        Assert.Equal(value, dialog.SupportMultiDottedExtensions);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set different.
-        dialog.SupportMultiDottedExtensions = !value;
-        Assert.Equal(!value, dialog.SupportMultiDottedExtensions);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void FileDialog_Title_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new SubFileDialog
-        {
-            Title = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.Title);
-        Assert.Equal(2052, dialog.Options);
-
-        // Set same.
-        dialog.Title = value;
-        Assert.Equal(value ?? string.Empty, dialog.Title);
-        Assert.Equal(2052, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2052, 2308)]
-    [InlineData(false, 2308, 2052)]
-    public void FileDialog_ValidateNames_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ValidateNames = value
-        };
-        Assert.Equal(value, dialog.ValidateNames);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ValidateNames = value;
-        Assert.Equal(value, dialog.ValidateNames);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ValidateNames = !value;
-        Assert.Equal(!value, dialog.ValidateNames);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    public static IEnumerable<object[]> CancelEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CancelEventArgs_TestData))]
-    public void FileDialog_OnFileOk_Invoke_Success(CancelEventArgs eventArgs)
-    {
-        using var dialog = new SubFileDialog();
-
-        // No handler.
-        dialog.OnFileOk(eventArgs);
-
-        // Handler.
-        int callCount = 0;
-        CancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(dialog, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        dialog.FileOk += handler;
-        dialog.OnFileOk(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        dialog.FileOk -= handler;
-        dialog.OnFileOk(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void FileDialog_Reset_Invoke_Success()
-    {
-        using var dialog = new SubFileDialog
-        {
-            AddExtension = false,
-            AddToRecent = false,
-            AutoUpgradeEnabled = false,
-            CheckFileExists = true,
-            CheckPathExists = false,
-            ClientGuid = new Guid("ad6e2857-4659-4791-aa59-efffa61d4594"),
-            DefaultExt = "DefaultExt",
-            DereferenceLinks = false,
-            FileName = "FileName",
-            FilterIndex = 2,
-            InitialDirectory = "InitialDirectory",
-            OkRequiresInteraction = true,
-            RestoreDirectory = true,
-            ShowHelp = true,
-            ShowHiddenFiles = true,
-            ShowPinnedPlaces = false,
-            SupportMultiDottedExtensions = true,
-            Tag = "Tag",
-            Title = "Title",
-            ValidateNames = false
-        };
-        dialog.CustomPlaces.Add("path");
-
-        dialog.Reset();
-        Assert.True(dialog.AddExtension);
-        Assert.True(dialog.AddToRecent);
-        Assert.False(dialog.AutoUpgradeEnabled);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.False(dialog.CheckFileExists);
-        Assert.True(dialog.CheckPathExists);
-        Assert.Null(dialog.Container);
-        Assert.Empty(dialog.CustomPlaces);
-        Assert.Same(dialog.CustomPlaces, dialog.CustomPlaces);
-        Assert.False(dialog.DesignMode);
-        Assert.Empty(dialog.DefaultExt);
-        Assert.True(dialog.DereferenceLinks);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.Empty(dialog.FileName);
-        Assert.Empty(dialog.FileNames);
-        Assert.Same(dialog.FileNames, dialog.FileNames);
-        Assert.Equal(1, dialog.FilterIndex);
-        Assert.Empty(dialog.InitialDirectory);
-        Assert.NotEqual(IntPtr.Zero, dialog.Instance);
-        Assert.False(dialog.OkRequiresInteraction);
-        Assert.Equal(2052, dialog.Options);
-        Assert.False(dialog.RestoreDirectory);
-        Assert.False(dialog.ShowHelp);
-        Assert.False(dialog.ShowHiddenFiles);
-        Assert.True(dialog.ShowPinnedPlaces);
-        Assert.False(dialog.SupportMultiDottedExtensions);
-        Assert.Null(dialog.Site);
-        Assert.Equal("Tag", dialog.Tag);
-        Assert.Empty(dialog.Title);
-        Assert.True(dialog.ValidateNames);
-        Assert.Null(dialog.ClientGuid);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public unsafe void FileDialog_RunDialog_NonVista_Success(bool result)
-    {
-        using var dialog = new SubFileDialog
-        {
-            AutoUpgradeEnabled = false
-        };
-        dialog.RunFileDialogAction = o =>
-        {
-            Assert.Equal(sizeof(OPENFILENAME), (int)o.lStructSize);
-            Assert.Equal((HWND)1, o.hwndOwner);
-            Assert.Equal(dialog.Instance, o.hInstance);
-            ReadOnlySpan<char> filter = new(o.lpstrFilter.Value, o.lpstrFilter.StringListLength);
-            Assert.True(filter.SequenceEqual(" \0*.*"));
-            Assert.True(o.lpstrCustomFilter.IsNull);
-            Assert.Equal(0u, o.nMaxCustFilter);
-            Assert.Equal(1u, o.nFilterIndex);
-            Assert.False(o.lpstrFile.IsNull);
-            Assert.Equal(8192u, o.nMaxFile);
-            Assert.True(o.lpstrFileTitle.IsNull);
-            Assert.Equal(0u, o.nMaxFileTitle);
-            Assert.True(o.lpstrInitialDir.IsNull);
-            Assert.True(o.lpstrTitle.IsNull);
-            Assert.Equal((OPEN_FILENAME_FLAGS)8914980, o.Flags);
-            Assert.Equal(0, o.nFileOffset);
-            Assert.Equal(0, o.nFileExtension);
-            Assert.True(o.lpstrDefExt.IsNull);
-            Assert.Equal((LPARAM)0, o.lCustData);
-            Assert.False(o.lpfnHook is null);
-            Assert.True(o.lpTemplateName.IsNull);
-            Assert.True(o.pvReserved is null);
-            Assert.Equal(0u, o.dwReserved);
-            Assert.Equal((OPEN_FILENAME_FLAGS_EX)0, o.FlagsEx);
-            return result;
-        };
-        Assert.Equal(result, dialog.RunDialog(1));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public unsafe void FileDialog_RunDialog_NonVistaAdvanced_Success(bool result)
-    {
-        using var dialog = new SubFileDialog
-        {
-            AddExtension = result,
-            AddToRecent = false,
-            AutoUpgradeEnabled = false,
-            CheckFileExists = true,
-            CheckPathExists = false,
-            DefaultExt = "DefaultExt",
-            DereferenceLinks = false,
-            FileName = "FileName",
-            FilterIndex = 2,
-            InitialDirectory = "InitialDirectory",
-            OkRequiresInteraction = true,
-            RestoreDirectory = true,
-            ShowHelp = true,
-            ShowHiddenFiles = true,
-            ShowPinnedPlaces = false,
-            SupportMultiDottedExtensions = true,
-            Tag = "Tag",
-            Title = "Title",
-            ValidateNames = false
-        };
-
-        dialog.RunFileDialogAction = o =>
-        {
-            Assert.Equal(sizeof(OPENFILENAME), (int)o.lStructSize);
-            Assert.Equal((IntPtr)1, o.hwndOwner);
-            Assert.Equal(dialog.Instance, o.hInstance);
-            Assert.True(o.lpstrFilter.IsNull);
-            Assert.True(o.lpstrCustomFilter.IsNull);
-            Assert.Equal(0u, o.nMaxCustFilter);
-            Assert.Equal(2u, o.nFilterIndex);
-            Assert.False(o.lpstrFile.IsNull);
-            Assert.Equal(8192u, o.nMaxFile);
-            Assert.True(o.lpstrFileTitle.IsNull);
-            Assert.Equal(0u, o.nMaxFileTitle);
-            Assert.Equal("InitialDirectory", o.lpstrInitialDir.ToString());
-            Assert.Equal("Title", o.lpstrTitle.ToString());
-            Assert.Equal((OPEN_FILENAME_FLAGS)314310972, o.Flags);
-            Assert.Equal(0u, o.nFileOffset);
-            Assert.Equal(0u, o.nFileExtension);
-            Assert.Equal(result ? "DefaultExt" : null, o.lpstrDefExt.ToString());
-            Assert.Equal((LPARAM)0, o.lCustData);
-            Assert.False(o.lpfnHook is null);
-            Assert.True(o.lpTemplateName.IsNull);
-            Assert.True(o.pvReserved is null);
-            Assert.Equal(0u, o.dwReserved);
-            Assert.Equal((OPEN_FILENAME_FLAGS_EX)0, o.FlagsEx);
-            return result;
-        };
-        Assert.Equal(result, dialog.RunDialog((IntPtr)1));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public unsafe void FileDialog_RunDialog_ShowHelp_Success(bool result)
-    {
-        using var dialog = new SubFileDialog
-        {
-            ShowHelp = true
-        };
-        dialog.RunFileDialogAction = o =>
-        {
-            Assert.Equal(sizeof(OPENFILENAME), (int)o.lStructSize);
-            Assert.Equal((HWND)1, o.hwndOwner);
-            Assert.Equal(dialog.Instance, o.hInstance);
-            ReadOnlySpan<char> filter = new(o.lpstrFilter.Value, o.lpstrFilter.StringListLength);
-            Assert.True(filter.SequenceEqual(" \0*.*"));
-            Assert.True(o.lpstrCustomFilter.IsNull);
-            Assert.Equal(0u, o.nMaxCustFilter);
-            Assert.Equal(1u, o.nFilterIndex);
-            Assert.False(o.lpstrFile.IsNull);
-            Assert.Equal(8192u, o.nMaxFile);
-            Assert.True(o.lpstrFileTitle.IsNull);
-            Assert.Equal(0u, o.nMaxFileTitle);
-            Assert.True(o.lpstrInitialDir.IsNull);
-            Assert.True(o.lpstrTitle.IsNull);
-            Assert.Equal((OPEN_FILENAME_FLAGS)8914996, o.Flags);
-            Assert.Equal(0u, o.nFileOffset);
-            Assert.Equal(0u, o.nFileExtension);
-            Assert.True(o.lpstrDefExt.IsNull);
-            Assert.Equal((LPARAM)0, o.lCustData);
-            Assert.False(o.lpfnHook is null);
-            Assert.True(o.lpTemplateName.IsNull);
-            Assert.True(o.pvReserved is null);
-            Assert.Equal(0u, o.dwReserved);
-            Assert.Equal((OPEN_FILENAME_FLAGS_EX)0, o.FlagsEx);
-            return result;
-        };
-        Assert.Equal(result, dialog.RunDialog(1));
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { new SubFileDialog(), "System.Windows.Forms.Tests.FileDialogTests+SubFileDialog: Title: , FileName: " };
-        yield return new object[] { new SubFileDialog { Title = "Title", FileName = "FileName" }, "System.Windows.Forms.Tests.FileDialogTests+SubFileDialog: Title: Title, FileName: FileName" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToString_TestData))]
-    public void FileDialog_ToString_Invoke_ReturnsExpected(FileDialog dialog, string expected)
-    {
-        Assert.Equal(expected, dialog.ToString());
-    }
-
-    private unsafe class SubFileDialog : FileDialog
-    {
-        public static new readonly object EventFileOk = FileDialog.EventFileOk;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new IntPtr Instance => base.Instance;
-
-        public new int Options => base.Options;
-
-        public Func<OPENFILENAME, bool> RunFileDialogAction { get; set; }
-
-        private protected override bool RunFileDialog(OPENFILENAME* ofn)
-        {
-            return RunFileDialogAction(*ofn);
-        }
-
-        private protected override ComScope<IFileDialog> CreateVistaDialog() => default;
-
-        private protected override string[] ProcessVistaFiles(IFileDialog* dialog) => null;
-
-        public new void OnFileOk(CancelEventArgs e) => base.OnFileOk(e);
-
-        public new bool RunDialog(IntPtr hWndOwner) => base.RunDialog(hWndOwner);
-    }
-
-    private class EmptyResetFileDialog : SubFileDialog
-    {
-        public override void Reset()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanel.FlowLayoutPanelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanel.FlowLayoutPanelAccessibleObjectTests.cs
deleted file mode 100644
index eb8e5b2f59a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanel.FlowLayoutPanelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class FlowLayoutPanelAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void FlowLayoutPanelAccessibilityObject_Ctor_Default()
-    {
-        using FlowLayoutPanel flowLayoutPanel = new FlowLayoutPanel();
-        flowLayoutPanel.CreateControl();
-
-        Assert.NotNull(flowLayoutPanel.AccessibilityObject);
-        Assert.True(flowLayoutPanel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanelAccessibilityObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using FlowLayoutPanel flowLayoutPanel = new FlowLayoutPanel();
-        flowLayoutPanel.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = flowLayoutPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.True(flowLayoutPanel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanelAccessibilityObject_Role_IsClient_ByDefault()
-    {
-        using FlowLayoutPanel flowLayoutPanel = new FlowLayoutPanel();
-        flowLayoutPanel.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = flowLayoutPanel.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Client, actual);
-        Assert.True(flowLayoutPanel.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanelTests.cs
deleted file mode 100644
index fe41f328b0a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutPanelTests.cs
+++ /dev/null
@@ -1,504 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class FlowLayoutPanelTests
-{
-    [WinFormsFact]
-    public void FlowLayoutPanel_Ctor_Default()
-    {
-        using var control = new SubFlowLayoutPanel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.False(control.Created);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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.Equal(FlowDirection.LeftToRight, control.FlowDirection);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.True(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-        Assert.True(control.WrapContents);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubFlowLayoutPanel();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlowDirection.BottomUp, 1)]
-    [InlineData(FlowDirection.LeftToRight, 1)]
-    [InlineData(FlowDirection.RightToLeft, 1)]
-    [InlineData(FlowDirection.TopDown, 1)]
-    public void FlowLayoutPanel_FlowDirection_Set_GetReturnsExpected(FlowDirection value, int expectedLayoutCallCount)
-    {
-        using var control = new FlowLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("FlowDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.FlowDirection = value;
-        Assert.Equal(value, control.FlowDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.FlowDirection = value;
-        Assert.Equal(value, control.FlowDirection);
-        Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<FlowDirection>]
-    public void FlowLayoutPanel_FlowDirection_SetInvalidValue_ThrowsInvalidEnumArgumentException(FlowDirection value)
-    {
-        using var control = new FlowLayoutPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.FlowDirection = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 1)]
-    public void FlowLayoutPanel_WrapContents_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new FlowLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("WrapContents", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.WrapContents = value;
-        Assert.Equal(value, control.WrapContents);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.WrapContents = value;
-        Assert.Equal(value, control.WrapContents);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        control.WrapContents = !value;
-        Assert.Equal(!value, control.WrapContents);
-        Assert.Equal(expectedLayoutCallCount + 1 + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_CanExtend_InvokeWithParent_ReturnsTrue()
-    {
-        using var control = new FlowLayoutPanel();
-        using var extendee = new Control
-        {
-            Parent = control
-        };
-        IExtenderProvider extenderProvider = control;
-        Assert.True(extenderProvider.CanExtend(extendee));
-    }
-
-    public static IEnumerable<object[]> CanExtend_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-        yield return new object[] { new Control { Parent = new Control() } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanExtend_TestData))]
-    public void FlowLayoutPanel_CanExtend_InvokeNoParent_ReturnsFalse(object extendee)
-    {
-        using var control = new FlowLayoutPanel();
-        IExtenderProvider extenderProvider = control;
-        Assert.False(extenderProvider.CanExtend(extendee));
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubFlowLayoutPanel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_GetFlowBreak_InvokeValidControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new FlowLayoutPanel();
-        Assert.False(control.GetFlowBreak(child));
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_GetFlowBreak_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new FlowLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetFlowBreak(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubFlowLayoutPanel.ScrollStateAutoScrolling, false)]
-    [InlineData(SubFlowLayoutPanel.ScrollStateFullDrag, false)]
-    [InlineData(SubFlowLayoutPanel.ScrollStateHScrollVisible, false)]
-    [InlineData(SubFlowLayoutPanel.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubFlowLayoutPanel.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void FlowLayoutPanel_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubFlowLayoutPanel();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void FlowLayoutPanel_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubFlowLayoutPanel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutPanel_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubFlowLayoutPanel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FlowLayoutPanel_SetFlowBreak_Invoke_GetFlowBreakReturnsExpected(bool value)
-    {
-        using var child = new Control();
-        using var control = new FlowLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetFlowBreak(child, value);
-        Assert.Equal(value, control.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetFlowBreak(child, value);
-        Assert.Equal(value, control.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set different.
-        control.SetFlowBreak(child, !value);
-        Assert.Equal(!value, control.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void FlowLayoutPanel_SetFlowBreak_InvokeControlWithParent_GetFlowBreakReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new FlowLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("FlowBreak", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetFlowBreak(child, value);
-            Assert.Equal(value, control.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetFlowBreak(child, value);
-            Assert.Equal(value, control.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.SetFlowBreak(child, !value);
-            Assert.Equal(!value, control.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FlowLayoutPanel_SetFlowBreak_NullControl_ThrowsArgumentNullException(bool value)
-    {
-        using var control = new FlowLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetFlowBreak(null, value));
-    }
-
-    private class SubFlowLayoutPanel : FlowLayoutPanel
-    {
-        public new const int ScrollStateAutoScrolling = FlowLayoutPanel.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = FlowLayoutPanel.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = FlowLayoutPanel.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = FlowLayoutPanel.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = FlowLayoutPanel.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutSettingsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutSettingsTests.cs
deleted file mode 100644
index 9ac42af4c1d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FlowLayoutSettingsTests.cs
+++ /dev/null
@@ -1,251 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class FlowLayoutSettingsTests
-{
-    [WinFormsTheory]
-    [InlineData(FlowDirection.BottomUp, 1)]
-    [InlineData(FlowDirection.LeftToRight, 1)]
-    [InlineData(FlowDirection.RightToLeft, 1)]
-    [InlineData(FlowDirection.TopDown, 1)]
-    public void FlowLayoutSettings_FlowDirection_Set_GetReturnsExpected(FlowDirection value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("FlowDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-
-        settings.FlowDirection = value;
-        Assert.Equal(value, settings.FlowDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        settings.FlowDirection = value;
-        Assert.Equal(value, settings.FlowDirection);
-        Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<FlowDirection>]
-    public void FlowLayoutSettings_FlowDirection_SetInvalidValue_ThrowsInvalidEnumArgumentException(FlowDirection value)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => settings.FlowDirection = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 1)]
-    public void FlowLayoutSettings_WrapContents_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("WrapContents", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        settings.WrapContents = value;
-        Assert.Equal(value, settings.WrapContents);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        settings.WrapContents = value;
-        Assert.Equal(value, settings.WrapContents);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        settings.WrapContents = !value;
-        Assert.Equal(!value, settings.WrapContents);
-        Assert.Equal(expectedLayoutCallCount + 1 + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutSettings_GetFlowBreak_InvokeValidControl_ReturnsExpected()
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.False(settings.GetFlowBreak(new Control()));
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutSettings_GetFlowBreak_NullChild_ThrowsArgumentNullException()
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Throws<ArgumentNullException>("child", () => settings.GetFlowBreak(null));
-    }
-
-    [WinFormsFact]
-    public void FlowLayoutSettings_GetFlowBreak_InvalidChild_ThrowsNotSupportedException()
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Throws<NotSupportedException>(() => settings.GetFlowBreak(new object()));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FlowLayoutSettings_SetFlowBreak_Invoke_GetFlowBreakReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        using var child = new Control();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetFlowBreak(child, value);
-        Assert.Equal(value, settings.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetFlowBreak(child, value);
-        Assert.Equal(value, settings.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set different.
-        settings.SetFlowBreak(child, !value);
-        Assert.Equal(!value, settings.GetFlowBreak(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void FlowLayoutSettings_SetFlowBreak_InvokeControlWithParent_GetFlowBreakReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("FlowBreak", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetFlowBreak(child, value);
-            Assert.Equal(value, settings.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-
-            // Set same.
-            settings.SetFlowBreak(child, value);
-            Assert.Equal(value, settings.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-
-            // Set different.
-            settings.SetFlowBreak(child, !value);
-            Assert.Equal(!value, settings.GetFlowBreak(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FlowLayoutSettings_SetFlowBreak_NullChild_ThrowsArgumentNullException(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Throws<ArgumentNullException>("child", () => settings.SetFlowBreak(null, value));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FlowLayoutSettings_SetFlowBreak_InvalidChild_ThrowsNotSupportedException(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Flow
-        };
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Throws<NotSupportedException>(() => settings.SetFlowBreak(new object(), value));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FolderBrowserDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FolderBrowserDialogTests.cs
deleted file mode 100644
index 719e291f1a7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FolderBrowserDialogTests.cs
+++ /dev/null
@@ -1,285 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class FolderBrowserDialogTests
-{
-    [WinFormsFact]
-    public void FolderBrowserDialog_Ctor_Default()
-    {
-        using var dialog = new FolderBrowserDialog();
-        Assert.True(dialog.AddToRecent);
-        Assert.True(dialog.AutoUpgradeEnabled);
-        Assert.Null(dialog.Container);
-        Assert.Empty(dialog.Description);
-        Assert.Equal(Environment.SpecialFolder.Desktop, dialog.RootFolder);
-        Assert.Empty(dialog.InitialDirectory);
-        Assert.False(dialog.OkRequiresInteraction);
-        Assert.Empty(dialog.SelectedPath);
-        Assert.False(dialog.ShowHiddenFiles);
-        Assert.True(dialog.ShowPinnedPlaces);
-        Assert.True(dialog.ShowNewFolderButton);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-        Assert.False(dialog.UseDescriptionForTitle);
-        Assert.Null(dialog.ClientGuid);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_AddToRecent_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            AddToRecent = value
-        };
-        Assert.Equal(value, dialog.AddToRecent);
-
-        // Set same.
-        dialog.AddToRecent = value;
-        Assert.Equal(value, dialog.AddToRecent);
-
-        // Set different.
-        dialog.AddToRecent = !value;
-        Assert.Equal(!value, dialog.AddToRecent);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_AutoUpgradeEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            AutoUpgradeEnabled = value
-        };
-        Assert.Equal(value, dialog.AutoUpgradeEnabled);
-
-        // Set same.
-        dialog.AutoUpgradeEnabled = value;
-        Assert.Equal(value, dialog.AutoUpgradeEnabled);
-
-        // Set different.
-        dialog.AutoUpgradeEnabled = !value;
-        Assert.Equal(!value, dialog.AutoUpgradeEnabled);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void FolderBrowserDialog_Description_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            Description = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.Description);
-
-        // Set same.
-        dialog.Description = value;
-        Assert.Equal(value ?? string.Empty, dialog.Description);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_OkRequiresInteraction_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            OkRequiresInteraction = value
-        };
-        Assert.Equal(value, dialog.OkRequiresInteraction);
-
-        // Set same.
-        dialog.OkRequiresInteraction = value;
-        Assert.Equal(value, dialog.OkRequiresInteraction);
-
-        // Set different.
-        dialog.OkRequiresInteraction = !value;
-        Assert.Equal(!value, dialog.OkRequiresInteraction);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Environment.SpecialFolder.Desktop)]
-    [InlineData(Environment.SpecialFolder.StartMenu)]
-    public void FolderBrowserDialog_RootFolder_Set_GetReturnsExpected(Environment.SpecialFolder value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            RootFolder = value
-        };
-        Assert.Equal(value, dialog.RootFolder);
-
-        // Set same.
-        dialog.RootFolder = value;
-        Assert.Equal(value, dialog.RootFolder);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void FolderBrowserDialog_InitialDirectory_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            InitialDirectory = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.InitialDirectory);
-
-        // Set same.
-        dialog.InitialDirectory = value;
-        Assert.Equal(value ?? string.Empty, dialog.InitialDirectory);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void FolderBrowserDialog_SelectedPath_Set_GetReturnsExpected(string value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            SelectedPath = value
-        };
-        Assert.Equal(value ?? string.Empty, dialog.SelectedPath);
-
-        // Set same.
-        dialog.SelectedPath = value;
-        Assert.Equal(value ?? string.Empty, dialog.SelectedPath);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_ShowHiddenFiles_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            ShowHiddenFiles = value
-        };
-        Assert.Equal(value, dialog.ShowHiddenFiles);
-
-        // Set same.
-        dialog.ShowHiddenFiles = value;
-        Assert.Equal(value, dialog.ShowHiddenFiles);
-
-        // Set different.
-        dialog.ShowHiddenFiles = !value;
-        Assert.Equal(!value, dialog.ShowHiddenFiles);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FileDialog_ShowPinnedPlaces_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            ShowPinnedPlaces = value
-        };
-        Assert.Equal(value, dialog.ShowPinnedPlaces);
-
-        // Set same.
-        dialog.ShowPinnedPlaces = value;
-        Assert.Equal(value, dialog.ShowPinnedPlaces);
-
-        // Set different.
-        dialog.ShowPinnedPlaces = !value;
-        Assert.Equal(!value, dialog.ShowPinnedPlaces);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_ShowNewFolderButton_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            ShowNewFolderButton = value
-        };
-        Assert.Equal(value, dialog.ShowNewFolderButton);
-
-        // Set same.
-        dialog.ShowNewFolderButton = value;
-        Assert.Equal(value, dialog.ShowNewFolderButton);
-
-        // Set different.
-        dialog.ShowNewFolderButton = !value;
-        Assert.Equal(!value, dialog.ShowNewFolderButton);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FolderBrowserDialog_UseDescriptionForTitle_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            UseDescriptionForTitle = value
-        };
-        Assert.Equal(value, dialog.UseDescriptionForTitle);
-
-        // Set same.
-        dialog.UseDescriptionForTitle = value;
-        Assert.Equal(value, dialog.UseDescriptionForTitle);
-
-        // Set different.
-        dialog.UseDescriptionForTitle = !value;
-        Assert.Equal(!value, dialog.UseDescriptionForTitle);
-    }
-
-    [WinFormsFact]
-    public void FolderBrowserDialog_Reset_Invoke_Success()
-    {
-        using var dialog = new FolderBrowserDialog
-        {
-            AddToRecent = false,
-            AutoUpgradeEnabled = false,
-            Description = "A description",
-            RootFolder = Environment.SpecialFolder.CommonAdminTools,
-            InitialDirectory = @"C:\",
-            OkRequiresInteraction = true,
-            SelectedPath = @"C:\",
-            ShowHiddenFiles = true,
-            ShowPinnedPlaces = false,
-            ShowNewFolderButton = false,
-            UseDescriptionForTitle = true,
-            ClientGuid = new Guid("ad6e2857-4659-4791-aa59-efffa61d4594"),
-        };
-
-        dialog.Reset();
-
-        Assert.True(dialog.AddToRecent);
-        Assert.False(dialog.AutoUpgradeEnabled);
-        Assert.Null(dialog.Container);
-        Assert.Empty(dialog.Description);
-        Assert.Equal(Environment.SpecialFolder.Desktop, dialog.RootFolder);
-        Assert.Empty(dialog.InitialDirectory);
-        Assert.False(dialog.OkRequiresInteraction);
-        Assert.Empty(dialog.SelectedPath);
-        Assert.False(dialog.ShowHiddenFiles);
-        Assert.True(dialog.ShowPinnedPlaces);
-        Assert.True(dialog.ShowNewFolderButton);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-        Assert.True(dialog.UseDescriptionForTitle);
-        Assert.Null(dialog.ClientGuid);
-    }
-
-    [WinFormsFact]
-    public void FolderBrowserDialog_HelpRequest_AddRemove_Success()
-    {
-        using var dialog = new FolderBrowserDialog();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        dialog.HelpRequest += handler;
-        dialog.HelpRequest -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("00000000-0000-0000-0000-000000000000")]
-    [InlineData("1d5a0215-fa19-4e3b-8ab9-06da88c28ae7")]
-    public void FolderBrowserDialog_ClientGuid_Set_GetReturnsExpected(Guid value)
-    {
-        using var dialog = new FolderBrowserDialog { ClientGuid = value };
-        Assert.Equal(value, dialog.ClientGuid);
-
-        // Set same.
-        dialog.ClientGuid = value;
-        Assert.Equal(value, dialog.ClientGuid);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontCacheTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontCacheTests.cs
deleted file mode 100644
index ffe5ef85493..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontCacheTests.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class FontCacheTests
-{
-    [Fact(Skip = "Run manually, takes a few minutes and is very resource intensive.")]
-    public void StressTest()
-    {
-        Font[] fonts = new Font[10];
-        for (int i = 0; i < 10; i++)
-        {
-            fonts[i] = new Font("Arial", i + 6);
-        }
-
-        FontCache cache = new FontCache(softLimit: 4, hardLimit: 8);
-        Random random = new Random();
-        try
-        {
-            for (int i = 0; i < 10_000; i++)
-            {
-                Thread.Sleep(random.Next(5));
-                Task.Run(() =>
-                {
-                    using var hfont = cache.GetEntry(
-                        fonts[random.Next(10)],
-                        (FONT_QUALITY)random.Next(7));
-
-                    Assert.False(hfont.Object.IsNull);
-                    Thread.Sleep(random.Next(10));
-                });
-            }
-        }
-        finally
-        {
-            cache.Dispose();
-            for (int i = 0; i < 10; i++)
-            {
-                fonts[i]?.Dispose();
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontDialogTests.cs
deleted file mode 100644
index 64958457854..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FontDialogTests.cs
+++ /dev/null
@@ -1,775 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class FontDialogTests
-{
-    [WinFormsFact]
-    public void FontDialog_Ctor_Default()
-    {
-        using var dialog = new SubFontDialog();
-        Assert.True(dialog.AllowScriptChange);
-        Assert.True(dialog.AllowSimulations);
-        Assert.True(dialog.AllowVectorFonts);
-        Assert.True(dialog.AllowVerticalFonts);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.False(dialog.FixedPitchOnly);
-        Assert.Equal(Control.DefaultFont, dialog.Font);
-        Assert.False(dialog.FontMustExist);
-        Assert.Equal(0, dialog.MaxSize);
-        Assert.Equal(0, dialog.MinSize);
-        Assert.Equal(0x40101, dialog.Options);
-        Assert.False(dialog.ScriptsOnly);
-        Assert.False(dialog.ShowApply);
-        Assert.False(dialog.ShowColor);
-        Assert.True(dialog.ShowEffects);
-        Assert.False(dialog.ShowHelp);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Ctor_Default_OverridenReset()
-    {
-        using var dialog = new EmptyResetFontDialog();
-        Assert.True(dialog.AllowScriptChange);
-        Assert.True(dialog.AllowSimulations);
-        Assert.True(dialog.AllowVectorFonts);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.True(dialog.AllowVerticalFonts);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Empty, dialog.Color);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.False(dialog.FixedPitchOnly);
-        Assert.Equal(Control.DefaultFont, dialog.Font);
-        Assert.False(dialog.FontMustExist);
-        Assert.Equal(0, dialog.MaxSize);
-        Assert.Equal(0, dialog.MinSize);
-        Assert.Equal(0, dialog.Options);
-        Assert.False(dialog.ScriptsOnly);
-        Assert.False(dialog.ShowApply);
-        Assert.False(dialog.ShowColor);
-        Assert.False(dialog.ShowEffects);
-        Assert.False(dialog.ShowHelp);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40101, 0x440101)]
-    [InlineData(false, 0x440101, 0x40101)]
-    public void FontDialog_AllowScriptChange_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            AllowScriptChange = value
-        };
-        Assert.Equal(value, dialog.AllowScriptChange);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AllowScriptChange = value;
-        Assert.Equal(value, dialog.AllowScriptChange);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AllowScriptChange = !value;
-        Assert.Equal(!value, dialog.AllowScriptChange);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40101, 0x41101)]
-    [InlineData(false, 0x41101, 0x40101)]
-    public void FontDialog_AllowSimulations_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            AllowSimulations = value
-        };
-        Assert.Equal(value, dialog.AllowSimulations);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AllowSimulations = value;
-        Assert.Equal(value, dialog.AllowSimulations);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AllowSimulations = !value;
-        Assert.Equal(!value, dialog.AllowSimulations);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40101, 0x40901)]
-    [InlineData(false, 0x40901, 0x40101)]
-    public void FontDialog_AllowVectorFonts_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            AllowVectorFonts = value
-        };
-        Assert.Equal(value, dialog.AllowVectorFonts);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AllowVectorFonts = value;
-        Assert.Equal(value, dialog.AllowVectorFonts);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AllowVectorFonts = !value;
-        Assert.Equal(!value, dialog.AllowVectorFonts);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40101, 0x1040101)]
-    [InlineData(false, 0x1040101, 0x40101)]
-    public void FontDialog_AllowVerticalFonts_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            AllowVerticalFonts = value
-        };
-        Assert.Equal(value, dialog.AllowVerticalFonts);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.AllowVerticalFonts = value;
-        Assert.Equal(value, dialog.AllowVerticalFonts);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.AllowVerticalFonts = !value;
-        Assert.Equal(!value, dialog.AllowVerticalFonts);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    public static IEnumerable<object[]> Color_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Black };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.FromArgb(1, 2, 3, 4), Color.FromArgb(1, 2, 3, 4) };
-        yield return new object[] { SystemColors.ControlText, SystemColors.ControlText };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public void FontDialog_Color_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var dialog = new FontDialog
-        {
-            Color = value
-        };
-        Assert.Equal(expected, dialog.Color);
-
-        // Set same.
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public void FontDialog_Color_SetWithCustomOldValue_GetReturnsExpected(Color value, Color expected)
-    {
-        using var dialog = new FontDialog
-        {
-            Color = Color.Yellow
-        };
-
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-
-        // Set same.
-        dialog.Color = value;
-        Assert.Equal(expected, dialog.Color);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x44101, 0x40101)]
-    [InlineData(false, 0x40101, 0x44101)]
-    public void FontDialog_FixedPitchOnly_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            FixedPitchOnly = value
-        };
-        Assert.Equal(value, dialog.FixedPitchOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.FixedPitchOnly = value;
-        Assert.Equal(value, dialog.FixedPitchOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.FixedPitchOnly = !value;
-        Assert.Equal(!value, dialog.FixedPitchOnly);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_GetWithSmallMinSize_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new FontDialog
-        {
-            MinSize = 1,
-            Font = font
-        };
-        Assert.Same(font, dialog.Font);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_GetWithLargeMinSize_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new FontDialog
-        {
-            MinSize = 100,
-            Font = font
-        };
-        Font result = dialog.Font;
-        Assert.NotSame(result, dialog.Font);
-        Assert.NotSame(font, dialog.Font);
-        Assert.Equal(font.FontFamily, result.FontFamily);
-        Assert.Equal(100, result.SizeInPoints);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(GraphicsUnit.Point, result.Unit);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_GetWithSmallMaxSize_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new FontDialog
-        {
-            MaxSize = 1,
-            Font = font
-        };
-        Font result = dialog.Font;
-        Assert.NotSame(result, dialog.Font);
-        Assert.NotSame(font, dialog.Font);
-        Assert.Equal(font.FontFamily, result.FontFamily);
-        Assert.Equal(1, result.SizeInPoints);
-        Assert.Equal(font.Style, result.Style);
-        Assert.Equal(GraphicsUnit.Point, result.Unit);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_GetWithLargeMaxSize_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new FontDialog
-        {
-            MaxSize = 100,
-            Font = font
-        };
-        Assert.Same(font, dialog.Font);
-    }
-
-    public static IEnumerable<object[]> Font_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { SystemFonts.MenuFont };
-
-        var font = new Font("Arial", 8.25f);
-        yield return new object[] { font };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void FontDialog_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var dialog = new FontDialog
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, dialog.Font);
-
-        // Set same.
-        dialog.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, dialog.Font);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void FontDialog_Font_SetWithCustomOldValue_GetReturnsExpected(Font value)
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new FontDialog
-        {
-            Font = font
-        };
-
-        dialog.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, dialog.Font);
-
-        // Set same.
-        dialog.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, dialog.Font);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(FontDialog))[nameof(FontDialog.Font)];
-        using var dialog = new FontDialog();
-        Assert.False(property.CanResetValue(dialog));
-
-        using var font = new Font("Arial", 8.25f);
-        dialog.Font = font;
-        Assert.Same(font, dialog.Font);
-        Assert.True(property.CanResetValue(dialog));
-
-        property.ResetValue(dialog);
-        Assert.Equal(Control.DefaultFont, dialog.Font);
-        Assert.False(property.CanResetValue(dialog));
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Font_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(FontDialog))[nameof(FontDialog.Font)];
-        using var dialog = new FontDialog();
-        Assert.False(property.ShouldSerializeValue(dialog));
-
-        using var font = new Font("Arial", 8.25f);
-        dialog.Font = font;
-        Assert.Same(font, dialog.Font);
-        Assert.True(property.ShouldSerializeValue(dialog));
-
-        property.ResetValue(dialog);
-        Assert.Equal(Control.DefaultFont, dialog.Font);
-        Assert.False(property.ShouldSerializeValue(dialog));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x50101, 0x40101)]
-    [InlineData(false, 0x40101, 0x50101)]
-    public void FontDialog_FontMustExist_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            FontMustExist = value
-        };
-        Assert.Equal(value, dialog.FontMustExist);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.FontMustExist = value;
-        Assert.Equal(value, dialog.FontMustExist);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.FontMustExist = !value;
-        Assert.Equal(!value, dialog.FontMustExist);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(int.MaxValue, int.MaxValue)]
-    public void FontDialog_MinSize_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var dialog = new FontDialog
-        {
-            MinSize = value
-        };
-        Assert.Equal(expected, dialog.MinSize);
-        Assert.Equal(0, dialog.MaxSize);
-
-        // Set same.
-        dialog.MinSize = value;
-        Assert.Equal(expected, dialog.MinSize);
-        Assert.Equal(0, dialog.MaxSize);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0, 10)]
-    [InlineData(0, 0, 10)]
-    [InlineData(1, 1, 10)]
-    [InlineData(10, 10, 10)]
-    [InlineData(int.MaxValue, int.MaxValue, int.MaxValue)]
-    public void FontDialog_MinSize_SetWithMaxSize_GetReturnsExpected(int value, int expected, int expectedMaxSize)
-    {
-        using var dialog = new FontDialog
-        {
-            MaxSize = 10,
-            MinSize = value
-        };
-        Assert.Equal(expected, dialog.MinSize);
-        Assert.Equal(expectedMaxSize, dialog.MaxSize);
-
-        // Set same.
-        dialog.MinSize = value;
-        Assert.Equal(expected, dialog.MinSize);
-        Assert.Equal(expectedMaxSize, dialog.MaxSize);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(int.MaxValue, int.MaxValue)]
-    public void FontDialog_MaxSize_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var dialog = new FontDialog
-        {
-            MaxSize = value
-        };
-        Assert.Equal(0, dialog.MinSize);
-        Assert.Equal(expected, dialog.MaxSize);
-
-        // Set same.
-        dialog.MaxSize = value;
-        Assert.Equal(0, dialog.MinSize);
-        Assert.Equal(expected, dialog.MaxSize);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0, 10)]
-    [InlineData(0, 0, 10)]
-    [InlineData(1, 1, 1)]
-    [InlineData(10, 10, 10)]
-    [InlineData(int.MaxValue, int.MaxValue, 10)]
-    public void FontDialog_MaxSize_SetWithMinSize_GetReturnsExpected(int value, int expected, int expectedMinSize)
-    {
-        using var dialog = new FontDialog
-        {
-            MinSize = 10,
-            MaxSize = value
-        };
-        Assert.Equal(expectedMinSize, dialog.MinSize);
-        Assert.Equal(expected, dialog.MaxSize);
-
-        // Set same.
-        dialog.MaxSize = value;
-        Assert.Equal(expectedMinSize, dialog.MinSize);
-        Assert.Equal(expected, dialog.MaxSize);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40501, 0x40101)]
-    [InlineData(false, 0x40101, 0x40501)]
-    public void FontDialog_ScriptsOnly_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ScriptsOnly = value
-        };
-        Assert.Equal(value, dialog.ScriptsOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ScriptsOnly = value;
-        Assert.Equal(value, dialog.ScriptsOnly);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ScriptsOnly = !value;
-        Assert.Equal(!value, dialog.ScriptsOnly);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40301, 0x40101)]
-    [InlineData(false, 0x40101, 0x40301)]
-    public void FontDialog_ShowApply_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ShowApply = value
-        };
-        Assert.Equal(value, dialog.ShowApply);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowApply = value;
-        Assert.Equal(value, dialog.ShowApply);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowApply = !value;
-        Assert.Equal(!value, dialog.ShowApply);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FontDialog_ShowColor_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new FontDialog
-        {
-            ShowColor = value
-        };
-        Assert.Equal(value, dialog.ShowColor);
-
-        // Set same.
-        dialog.ShowColor = value;
-        Assert.Equal(value, dialog.ShowColor);
-
-        // Set different.
-        dialog.ShowColor = !value;
-        Assert.Equal(!value, dialog.ShowColor);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40101, 0x40001)]
-    [InlineData(false, 0x40001, 0x40101)]
-    public void FontDialog_ShowEffects_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ShowEffects = value
-        };
-        Assert.Equal(value, dialog.ShowEffects);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowEffects = value;
-        Assert.Equal(value, dialog.ShowEffects);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowEffects = !value;
-        Assert.Equal(!value, dialog.ShowEffects);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x40105, 0x40101)]
-    [InlineData(false, 0x40101, 0x40105)]
-    public void FontDialog_ShowHelp_Set_GetReturnsExpected(bool value, int expectedOptions, int expectedOptionsAfter)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ShowHelp = value
-        };
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set same.
-        dialog.ShowHelp = value;
-        Assert.Equal(value, dialog.ShowHelp);
-        Assert.Equal(expectedOptions, dialog.Options);
-
-        // Set different.
-        dialog.ShowHelp = !value;
-        Assert.Equal(!value, dialog.ShowHelp);
-        Assert.Equal(expectedOptionsAfter, dialog.Options);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_Reset_Invoke_Success()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var dialog = new SubFontDialog
-        {
-            AllowScriptChange = false,
-            AllowSimulations = false,
-            AllowVectorFonts = false,
-            AllowVerticalFonts = false,
-            FixedPitchOnly = true,
-            Font = font,
-            FontMustExist = true,
-            MaxSize = 10,
-            MinSize = 5,
-            ScriptsOnly = true,
-            ShowApply = true,
-            ShowColor = true,
-            ShowEffects = false,
-            ShowHelp = true,
-            Tag = "Tag",
-        };
-
-        dialog.Reset();
-        Assert.True(dialog.AllowScriptChange);
-        Assert.True(dialog.AllowSimulations);
-        Assert.True(dialog.AllowVectorFonts);
-        Assert.True(dialog.AllowVerticalFonts);
-        Assert.True(dialog.CanRaiseEvents);
-        Assert.Equal(Color.Black, dialog.Color);
-        Assert.Null(dialog.Container);
-        Assert.False(dialog.DesignMode);
-        Assert.NotNull(dialog.Events);
-        Assert.Same(dialog.Events, dialog.Events);
-        Assert.False(dialog.FixedPitchOnly);
-        Assert.Equal(Control.DefaultFont, dialog.Font);
-        Assert.False(dialog.FontMustExist);
-        Assert.Equal(0, dialog.MaxSize);
-        Assert.Equal(0, dialog.MinSize);
-        Assert.Equal(0x40101, dialog.Options);
-        Assert.False(dialog.ScriptsOnly);
-        Assert.False(dialog.ShowApply);
-        Assert.False(dialog.ShowColor);
-        Assert.True(dialog.ShowEffects);
-        Assert.False(dialog.ShowHelp);
-        Assert.Null(dialog.Site);
-        Assert.Equal("Tag", dialog.Tag);
-    }
-
-    public static IEnumerable<object[]> HookProc_TestData()
-    {
-        foreach (bool showColor in new bool[] { true, false })
-        {
-            yield return new object[] { showColor, (int)PInvoke.WM_INITDIALOG, IntPtr.Zero };
-            yield return new object[] { showColor, (int)PInvoke.WM_SETFOCUS, IntPtr.Zero };
-            yield return new object[] { showColor, (int)PInvoke.WM_COMMAND, IntPtr.Zero };
-
-            const uint CDM_SETDEFAULTFOCUS = (int)PInvoke.WM_USER + 0x51;
-            yield return new object[] { showColor, (int)CDM_SETDEFAULTFOCUS, IntPtr.Zero };
-
-            yield return new object[] { showColor, 0, IntPtr.Zero };
-            yield return new object[] { showColor, -1, IntPtr.Zero };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HookProc_TestData))]
-    public void FontDialog_HookProc_Invoke_ReturnsZero(bool showColor, int msg, IntPtr wparam)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ShowColor = showColor
-        };
-        int applyCallCount = 0;
-        dialog.Apply += (sender, e) => applyCallCount++;
-        Assert.Equal(IntPtr.Zero, dialog.HookProc(IntPtr.Zero, msg, wparam, IntPtr.Zero));
-        Assert.Equal(0, applyCallCount);
-    }
-
-    public static IEnumerable<object[]> HookProc_WithHWnd_TestData()
-    {
-        foreach (bool showColor in new bool[] { true, false })
-        {
-            yield return new object[] { showColor, (int)PInvoke.WM_INITDIALOG, IntPtr.Zero, 0 };
-            yield return new object[] { showColor, (int)PInvoke.WM_SETFOCUS, IntPtr.Zero, 0 };
-            yield return new object[] { showColor, (int)PInvoke.WM_COMMAND, IntPtr.Zero, 0 };
-            yield return new object[] { showColor, (int)PInvoke.WM_COMMAND, (IntPtr)0x402, 1 };
-
-            const uint CDM_SETDEFAULTFOCUS = (int)PInvoke.WM_USER + 0x51;
-            yield return new object[] { showColor, (int)CDM_SETDEFAULTFOCUS, IntPtr.Zero, 0 };
-
-            yield return new object[] { showColor, 0, IntPtr.Zero, 0 };
-            yield return new object[] { showColor, -1, IntPtr.Zero, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HookProc_WithHWnd_TestData))]
-    public void FontDialog_HookProc_InvokeWithHWnd_ReturnsZero(bool showColor, int msg, IntPtr wparam, int expectedApplyCallCount)
-    {
-        using var control = new CustomClass();
-        using var dialog = new SubFontDialog
-        {
-            ShowColor = showColor
-        };
-        int applyCallCount = 0;
-        dialog.Apply += (sender, e) => applyCallCount++;
-        Assert.Equal(IntPtr.Zero, dialog.HookProc(control.Handle, msg, wparam, IntPtr.Zero));
-        Assert.Equal(expectedApplyCallCount, applyCallCount);
-    }
-
-    private class CustomClass : Control
-    {
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.WM_CHOOSEFONT_GETLOGFONT)
-            {
-                using Font font = new("Arial", 8.25f);
-                LOGFONTW* pLogfont = (LOGFONTW*)m.LParam;
-                object lf = new LOGFONTW();
-                font.ToLogFont(lf);
-                *pLogfont = (LOGFONTW)lf;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FontDialog_HookProc_Invoke_InvalidCommandHWnd(bool showColor)
-    {
-        using var dialog = new SubFontDialog
-        {
-            ShowColor = showColor
-        };
-        int applyCallCount = 0;
-        dialog.Apply += (sender, e) => applyCallCount++;
-        Assert.Throws<ArgumentException>(() => dialog.HookProc(IntPtr.Zero, (int)PInvoke.WM_COMMAND, (IntPtr)0x402, IntPtr.Zero));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void FontDialog_OnApply_Invoke_CallsApply(EventArgs eventArgs)
-    {
-        using var dialog = new SubFontDialog();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(dialog, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        dialog.Apply += handler;
-        dialog.OnApply(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        dialog.Apply -= handler;
-        dialog.OnApply(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void FontDialog_ToString_Invoke_ReturnsExpected()
-    {
-        using var dialog = new SubFontDialog();
-        Assert.Equal($"System.Windows.Forms.Tests.FontDialogTests+SubFontDialog,  Font: {Control.DefaultFont}", dialog.ToString());
-    }
-
-    private class SubFontDialog : FontDialog
-    {
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int Options => base.Options;
-
-        public new IntPtr HookProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam) => base.HookProc(hWnd, msg, wparam, lparam);
-
-        public new bool RunDialog(IntPtr hWndOwner) => base.RunDialog(hWndOwner);
-
-        public new void OnApply(EventArgs e) => base.OnApply(e);
-    }
-
-    private class EmptyResetFontDialog : SubFontDialog
-    {
-        public override void Reset()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Form.FormAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Form.FormAccessibleObjectTests.cs
deleted file mode 100644
index b9b841f9d9b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Form.FormAccessibleObjectTests.cs
+++ /dev/null
@@ -1,230 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.Form;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class Form_FormAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void FormAccessibleObject_Ctor_Default()
-    {
-        using Form form = new Form();
-        FormAccessibleObject accessibleObject = new FormAccessibleObject(form);
-
-        Assert.Equal(form, accessibleObject.Owner);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FormAccessibleObject_ControlType_IsWindow_IfAccessibleRoleIsDefault()
-    {
-        using Form form = new Form();
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = form.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(AccessibleRole.Client, accessibleObject.Role);
-        Assert.Equal(UiaCore.UIA.WindowControlTypeId, actual);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FormAccessibleObject_ControlType_IsDialog_True()
-    {
-        using Form form = new();
-
-        bool? actualValue = null;
-        form.Load += (_, _) =>
-        {
-            AccessibleObject accessibleObject = form.AccessibilityObject;
-            actualValue = (bool?)accessibleObject.GetPropertyValue(UiaCore.UIA.IsDialogPropertyId);
-            form.Close();
-        };
-        form.ShowDialog();
-
-        Assert.True(actualValue);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FormAccessibleObject_ControlType_IsDialog_False()
-    {
-        using Form form = new();
-
-        bool? actualValue = null;
-        form.Load += (_, _) =>
-        {
-            AccessibleObject accessibleObject = form.AccessibilityObject;
-            actualValue = (bool?)accessibleObject.GetPropertyValue(UiaCore.UIA.IsDialogPropertyId);
-            form.Close();
-        };
-        form.Show();
-
-        Assert.False(actualValue);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> FormAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default || role == AccessibleRole.Client)
-            {
-                continue; // The test checks custom roles. "Client" is the default role and it has special handling.
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FormAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void FormAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using Form form = new Form();
-        form.AccessibleRole = role;
-
-        object actual = form.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void FormAccessibleObject_Role_IsClient_ByDefault()
-    {
-        using Form form = new Form();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = form.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Client, actual);
-        Assert.False(form.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("null")] // The form is empty
-    [InlineData("invisible")]  // The form has invisible control (looks empty)
-    [InlineData("disabled")] // The form has disabled control
-    public void FormAccessibleObject_RaiseFocusEvent_WhenFormGetsFocus_WithoutActiveControl(string controlCase)
-    {
-        using Form form = new FocusEventsCounterForm();
-        using Control control = controlCase switch
-        {
-            "null" => null,
-            "invisible" => new Button() { Visible = false },
-            "disabled" => new Button() { Enabled = false },
-            _ => null
-        };
-        form.Controls.Add(control);
-        form.CreateControl(true);
-        var accessibleObject = (FocusEventsCounterFormAccessibleObject)form.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(0, accessibleObject.RaiseAutomationFocusEventCallsCount);
-        Assert.True(form.IsHandleCreated);
-
-        form.Visible = true;
-        form.Focus();
-
-        Assert.Null(form.ActiveControl);
-        Assert.Equal(1, accessibleObject.RaiseAutomationFocusEventCallsCount);
-    }
-
-    [WinFormsFact]
-    public void FormAccessibleObject_RaiseFocusEvent_WhenFormGetsFocus_WithActiveControl()
-    {
-        using Form form = new FocusEventsCounterForm();
-        using Button control = new();
-        form.Controls.Add(control);
-        form.CreateControl(true);
-        var accessibleObject = (FocusEventsCounterFormAccessibleObject)form.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(0, accessibleObject.RaiseAutomationFocusEventCallsCount);
-        Assert.True(form.IsHandleCreated);
-
-        form.Visible = true;
-        control.Visible = true;
-        form.Focus();
-
-        Assert.NotNull(form.ActiveControl);
-
-        // The child control gets the focus changed event instead of the form.
-        // Native control does it itself, so a screen reader should focus on the inner control.
-        Assert.Equal(0, accessibleObject.RaiseAutomationFocusEventCallsCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void FormAccessibleObject_BoundingRectangle_ReturnsExpected_ForRootForm(bool createControl)
-    {
-        using Form form = new();
-
-        if (createControl)
-        {
-            form.CreateControl(true);
-        }
-
-        Rectangle actual = form.AccessibilityObject.BoundingRectangle;
-        Rectangle expected = createControl ? form.Bounds : Rectangle.Empty;
-
-        Assert.Equal(expected, actual);
-        Assert.Equal(createControl, form.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void FormAccessibleObject_BoundingRectangle_ReturnsExpected_ForEmbeddedForm(bool createControl)
-    {
-        using Form form = new();
-        using Form embeddedForm = new() { TopLevel = false };
-        form.Controls.Add(embeddedForm);
-
-        if (createControl)
-        {
-            form.CreateControl(true);
-        }
-
-        Rectangle actual = form.AccessibilityObject.BoundingRectangle;
-
-        Assert.Equal(createControl, actual.Location != Point.Empty);
-        Assert.Equal(createControl, form.IsHandleCreated);
-    }
-
-    private class FocusEventsCounterForm : Form
-    {
-        protected override AccessibleObject CreateAccessibilityInstance()
-            => new FocusEventsCounterFormAccessibleObject(this);
-    }
-
-    private class FocusEventsCounterFormAccessibleObject : FormAccessibleObject
-    {
-        public FocusEventsCounterFormAccessibleObject(Form owner) : base(owner)
-        {
-            RaiseAutomationFocusEventCallsCount = 0;
-        }
-
-        public int RaiseAutomationFocusEventCallsCount { get; private set; }
-
-        internal override bool RaiseAutomationEvent(UiaCore.UIA eventId)
-        {
-            if (eventId == UiaCore.UIA.AutomationFocusChangedEventId)
-            {
-                RaiseAutomationFocusEventCallsCount++;
-            }
-
-            return base.RaiseAutomationEvent(eventId);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosedEventArgsTests.cs
deleted file mode 100644
index c2b2cfce6f4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosedEventArgsTests.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class FormClosedEventArgsTests
-{
-    [Theory]
-    [InlineData(CloseReason.None)]
-    [InlineData((CloseReason)(CloseReason.None - 1))]
-    public void Ctor_CloseReason(CloseReason closeReason)
-    {
-        var e = new FormClosedEventArgs(closeReason);
-        Assert.Equal(closeReason, e.CloseReason);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosingEventArgsTests.cs
deleted file mode 100644
index 4e7b04c2ff5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormClosingEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class FormClosingEventArgsTests
-{
-    [Theory]
-    [InlineData(CloseReason.None, true)]
-    [InlineData((CloseReason)(CloseReason.None - 1), false)]
-    public void Ctor_CloseReason_Bool(CloseReason closeReason, bool cancel)
-    {
-        var e = new FormClosingEventArgs(closeReason, cancel);
-        Assert.Equal(closeReason, e.CloseReason);
-        Assert.Equal(cancel, e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormTests.cs
deleted file mode 100644
index 943d43a4040..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/FormTests.cs
+++ /dev/null
@@ -1,2774 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class FormTests
-{
-    [WinFormsFact]
-    public void Form_Ctor_Default()
-    {
-        using var control = new SubForm();
-        Assert.Null(control.AcceptButton);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.Null(control.ActiveControl);
-        Assert.Null(control.ActiveMdiChild);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowTransparency);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-#pragma warning disable 0618
-        Assert.True(control.AutoScale);
-#pragma warning restore 0618
-        Assert.True(control.AutoScaleBaseSize.Width > 0);
-        Assert.True(control.AutoScaleBaseSize.Height > 0);
-        Assert.Equal(SizeF.Empty, control.AutoScaleDimensions);
-        Assert.Equal(new SizeF(1, 1), control.AutoScaleFactor);
-        Assert.Equal(AutoScaleMode.Inherit, control.AutoScaleMode);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(300, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 300, 300), control.Bounds);
-        Assert.Null(control.CancelButton);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, control.ClientSize.Width, control.ClientSize.Height), control.ClientRectangle);
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height > 0);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.True(control.ControlBox);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Equal(SizeF.Empty, control.CurrentAutoScaleDimensions);
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(Cursors.Default, control.Cursor);
-        Assert.Equal(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.NoControl, 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(300, 300), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(-SystemInformation.WorkingArea.X, -SystemInformation.WorkingArea.Y, 300, 300), control.DesktopBounds);
-        Assert.Equal(new Point(-SystemInformation.WorkingArea.X, -SystemInformation.WorkingArea.Y), control.DesktopLocation);
-        Assert.Equal(DialogResult.None, control.DialogResult);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height > 0);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(FormBorderStyle.Sizable, control.FormBorderStyle);
-        Assert.False(control.HasChildren);
-        Assert.Equal(300, control.Height);
-        Assert.False(control.HelpButton);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.NotNull(control.Icon);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMdiChild);
-        Assert.False(control.IsMdiContainer);
-        Assert.False(control.IsMirrored);
-        Assert.False(control.IsRestrictedWindow);
-        Assert.False(control.KeyPreview);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Null(control.MainMenuStrip);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Empty(control.MdiChildren);
-        Assert.Null(control.MdiParent);
-        Assert.Equal(Rectangle.Empty, control.MaximizedBounds);
-        Assert.True(control.MaximizeBox);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.True(control.MinimizeBox);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(control.Modal);
-        Assert.Equal(1, control.Opacity);
-        Assert.Empty(control.OwnedForms);
-        Assert.Null(control.Owner);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(new Rectangle(0, 0, 300, 300), control.RestoreBounds);
-        Assert.Equal(300, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowIcon);
-        Assert.True(control.ShowInTaskbar);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.False(control.ShowWithoutActivation);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(300, 300), control.Size);
-        Assert.Equal(SizeGripStyle.Auto, control.SizeGripStyle);
-        Assert.Equal(FormStartPosition.WindowsDefaultLocation, control.StartPosition);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.True(control.TopLevel);
-        Assert.Same(control, control.TopLevelControl);
-        Assert.False(control.TopMost);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.False(control.UseWaitCursor);
-        Assert.False(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(300, control.Width);
-        Assert.Equal(FormWindowState.Normal, control.WindowState);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Form_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubForm();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x50000, createParams.ExStyle);
-        Assert.Equal(300, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x2CF0000, createParams.Style);
-        Assert.Equal(300, createParams.Width);
-        Assert.Equal(int.MinValue, createParams.X);
-        Assert.Equal(int.MinValue, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public static void Form_Ctor_show_icon_by_default()
-    {
-        using var form = new Form();
-        Assert.True(form.Handle != IntPtr.Zero);
-
-        HICON hSmallIcon = (HICON)PInvoke.SendMessage(form, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_SMALL);
-        Assert.False(hSmallIcon.IsNull);
-
-        HICON hLargeIcon = (HICON)PInvoke.SendMessage(form, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_BIG);
-        Assert.False(hLargeIcon.IsNull);
-
-        // normal form doesn't have WS_EX.DLGMODALFRAME set, and show icon
-        WINDOW_EX_STYLE extendedStyle = (WINDOW_EX_STYLE)PInvoke.GetWindowLong(form, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE);
-        Assert.False(extendedStyle.HasFlag(WINDOW_EX_STYLE.WS_EX_DLGMODALFRAME));
-    }
-
-    [WinFormsFact]
-    public void Form_AcceptButtonGetSet()
-    {
-        using var form = new Form();
-        var mock = new Mock<IButtonControl>(MockBehavior.Strict);
-        mock.Setup(x => x.NotifyDefault(It.IsAny<bool>()));
-
-        form.AcceptButton = mock.Object;
-
-        Assert.Equal(mock.Object, form.AcceptButton);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_Active_Set_GetReturnsExpected(bool value)
-    {
-        using var form = new Form
-        {
-            Active = value
-        };
-        Assert.Equal(value, form.Active);
-
-        // Set same.
-        form.Active = value;
-        Assert.Equal(value, form.Active);
-    }
-
-    // non deterministic, commenting out for now
-    /*[Fact]
-    public void Form_ActiveFormNotSetActive()
-    {
-        using var form = new Form();
-
-        form.Visible = true;
-        form.Active = false;
-
-        Assert.NotNull(Form.ActiveForm);
-        Assert.Equal(form, Form.ActiveForm);
-        Assert.False(Form.ActiveForm.Active);
-    }*/
-
-    [WinFormsFact]
-    public void Form_ActiveMdiChildInternalGetSet()
-    {
-        using var form = new Form();
-        using var child = new Form();
-
-        form.ActiveMdiChildInternal = child;
-
-        Assert.NotNull(form.ActiveMdiChildInternal);
-        Assert.Equal(child, form.ActiveMdiChildInternal);
-    }
-
-    [WinFormsFact]
-    public void Form_ActiveMdiChildGetSet()
-    {
-        using var form = new Form();
-        using var child = new Form
-        {
-            Visible = true,
-            Enabled = true
-        };
-
-        form.ActiveMdiChildInternal = child;
-
-        Assert.NotNull(form.ActiveMdiChild);
-        Assert.Equal(child, form.ActiveMdiChild);
-    }
-
-    [WinFormsFact]
-    public void Form_ActiveMdiChildGetSetChildNotVisible()
-    {
-        using var form = new Form();
-        using var child = new Form
-        {
-            Visible = false,
-            Enabled = true
-        };
-
-        form.ActiveMdiChildInternal = child;
-
-        Assert.Null(form.ActiveMdiChild);
-    }
-
-    [WinFormsFact]
-    public void Form_ActiveMdiChildGetSetChildNotEnabled()
-    {
-        using var form = new Form();
-        using var child = new Form
-        {
-            Visible = true,
-            Enabled = false
-        };
-
-        form.ActiveMdiChildInternal = child;
-
-        Assert.Null(form.ActiveMdiChild);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_AllowTransparency_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AllowTransparency_SetWithOpacityAndTransparencyKey_TestData()
-    {
-        yield return new object[] { true, Color.Red, 0.5 };
-        yield return new object[] { false, Color.Empty, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowTransparency_SetWithOpacityAndTransparencyKey_TestData))]
-    public void Form_AllowTransparency_SetWithOpacityAndTransparencyKey_GetReturnsExpected(bool value, Color expectedTransparencyKey, float expectedOpacity)
-    {
-        using var control = new Form
-        {
-            Opacity = 0.5,
-            TransparencyKey = Color.Red,
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedTransparencyKey, control.TransparencyKey);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedTransparencyKey, control.TransparencyKey);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_AllowTransparency_SetNotTopLevel_GetReturnsExpected(bool value)
-    {
-        using var control = new Form
-        {
-            TopLevel = false,
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Form_AllowTransparency_SetWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AllowTransparency_SetWithOpacityAndTransparencyKeyWithHandle_TestData()
-    {
-        yield return new object[] { true, Color.Red, 0.5, 0 };
-        yield return new object[] { false, Color.Empty, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowTransparency_SetWithOpacityAndTransparencyKeyWithHandle_TestData))]
-    public void Form_AllowTransparency_SetWithOpacityAndTransparencyKeyWithHandle_GetReturnsExpected(bool value, Color expectedTransparencyKey, float expectedOpacity, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form
-        {
-            Opacity = 0.5,
-            TransparencyKey = Color.Red
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedTransparencyKey, control.TransparencyKey);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedTransparencyKey, control.TransparencyKey);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void Form_AllowTransparency_SetNotTopLevelWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form
-        {
-            TopLevel = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-#pragma warning disable 0618
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_AutoScale_Set_GetReturnsExpected(bool value)
-    {
-        using var form = new Form
-        {
-            AutoScale = value
-        };
-        Assert.Equal(value, form.AutoScale);
-
-        // Set same.
-        form.AutoScale = value;
-        Assert.Equal(value, form.AutoScale);
-    }
-
-#pragma warning restore 0618
-
-    [WinFormsTheory]
-    [EnumData<AutoScaleMode>]
-    public void Form_AutoScaleMode_Set_GetReturnsExpected(AutoScaleMode value)
-    {
-        using var form = new Form
-        {
-            AutoScaleMode = value
-        };
-        Assert.Equal(value, form.AutoScaleMode);
-
-        // Set same.
-        form.AutoScaleMode = value;
-        Assert.Equal(value, form.AutoScaleMode);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_AutoScroll_Set_GetReturnsExpected(bool value)
-    {
-        using var form = new Form
-        {
-            AutoScroll = value
-        };
-        Assert.Equal(value, form.AutoScroll);
-
-        // Set same.
-        form.AutoScroll = value;
-        Assert.Equal(value, form.AutoScroll);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_AutoSizeSet_GetReturnsExpected(bool value)
-    {
-        using var form = new Form
-        {
-            AutoSize = value
-        };
-        Assert.Equal(value, form.AutoSize);
-
-        // Set same.
-        form.AutoSize = value;
-        Assert.Equal(value, form.AutoSize);
-    }
-
-    public static IEnumerable<object[]> Opacity_Set_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, 1.1, 1.0, allowTransparency, allowTransparency };
-            yield return new object[] { allowTransparency, 1.0, 1.0, allowTransparency, allowTransparency };
-            yield return new object[] { allowTransparency, 0.5, 0.5, true, false };
-            yield return new object[] { allowTransparency, 0, 0, true, false };
-            yield return new object[] { allowTransparency, -0.1, 0, true, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_Set_TestData))]
-    public void Form_Opacity_Set_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency, bool expectedHandleCreated)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = allowTransparency,
-            Opacity = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetWithTransparencyKey_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, 1.1, 1.0 };
-            yield return new object[] { allowTransparency, 1.0, 1.0 };
-            yield return new object[] { allowTransparency, 0.5, 0.5 };
-            yield return new object[] { allowTransparency, 0, 0 };
-            yield return new object[] { allowTransparency, -0.1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetWithTransparencyKey_TestData))]
-    public void Form_Opacity_SetWithTransparencyKey_GetReturnsExpected(bool allowTransparency, double value, double expected)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = allowTransparency,
-            TransparencyKey = Color.Red,
-            Opacity = value
-        };
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Red, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Red, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_Set_TestData))]
-    public void Form_Opacity_SetTopLevel_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency, bool expectedHandleCreated)
-    {
-        using var control = new Form
-        {
-            TopLevel = false,
-            AllowTransparency = allowTransparency,
-            Opacity = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetNotTransparentWithHandle_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, 1.1, 1.0 };
-            yield return new object[] { allowTransparency, 1.0, 1.0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetNotTransparentWithHandle_TestData))]
-    public void Form_Opacity_SetNotTransparentWithHandle_GetReturnsExpected(bool allowTransparency, double value, double expected)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = allowTransparency;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0.5, 0.5, 0)]
-    [InlineData(0, 0, 0)]
-    [InlineData(-0.1, 0, 0)]
-    public void Form_Opacity_SetTransparentWithHandleSetAllowTransparencyBefore_GetReturnsExpected(float value, float expected, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetTransparentWithHandle_TestData()
-    {
-        yield return new object[] { true, 0.5, 0.5, 0 };
-        yield return new object[] { true, 0, 0, 0 };
-        yield return new object[] { true, -0.1, -0, 0 };
-
-        yield return new object[] { false, 0.5, 0.5, 1 };
-        yield return new object[] { false, 0, 0, 1 };
-        yield return new object[] { false, -0.1, -0, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetTransparentWithHandle_TestData))]
-    public void Form_Opacity_SetTransparentWithHandleSetAllowTransparencyAfter_GetReturnsExpected(bool allowTransparency, float value, float expected, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = allowTransparency;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetWithTransparencyKeyWithHandle_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, 1.1, 1.0 };
-            yield return new object[] { allowTransparency, 1.0, 1.0 };
-            yield return new object[] { allowTransparency, 0.5, 0.5 };
-            yield return new object[] { allowTransparency, 0, 0 };
-            yield return new object[] { allowTransparency, -0.1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetWithTransparencyKeyWithHandle_TestData))]
-    public void Form_Opacity_SetWithTransparencyKeyWithHandle_GetReturnsExpected(bool allowTransparency, double value, double expected)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = allowTransparency;
-        control.TransparencyKey = Color.Red;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Red, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Red, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetTopLevelWithHandle_TestData()
-    {
-        yield return new object[] { true, 1.1, 1.0, true, 0 };
-        yield return new object[] { true, 1.0, 1.0, true, 0 };
-        yield return new object[] { true, 0.5, 0.5, true, 0 };
-        yield return new object[] { true, 0, 0, true, 0 };
-        yield return new object[] { true, -0.1, 0, true, 0 };
-
-        yield return new object[] { false, 1.1, 1.0, false, 0 };
-        yield return new object[] { false, 1.0, 1.0, false, 0 };
-        yield return new object[] { false, 0.5, 0.5, true, 1 };
-        yield return new object[] { false, 0, 0, true, 1 };
-        yield return new object[] { false, -0.1, 0, true, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetTopLevelWithHandle_TestData))]
-    public void Form_Opacity_SetTopLevelWithHandle_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form
-        {
-            TopLevel = false,
-            AllowTransparency = allowTransparency
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-        yield return new object[] { new Form() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Form_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new Form
-        {
-            TopLevel = false,
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Form_Parent_SetWithNonNullOldParent_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new Control();
-        using var control = new Form
-        {
-            TopLevel = false,
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Form_Restore_RestoresPosition_User()
-    {
-        if (!OsVersion.IsWindows11_OrGreater())
-        {
-            return;
-        }
-
-        using var form = new Form();
-        form.Show();
-
-        form.Location = new Point(10, 11);
-        form.Size = new Size(200, 210);
-
-        PInvoke.SendMessage(form, PInvoke.WM_SYSCOMMAND, (WPARAM)PInvoke.SC_MAXIMIZE);
-
-        form.Location = new Point(20, 21);
-        form.Size = new Size(300, 310);
-
-        Assert.Equal(FormWindowState.Maximized, form.WindowState);
-        Assert.NotEqual(new Point(20, 21), form.Location);
-        Assert.NotEqual(new Size(300, 310), form.Size);
-
-        PInvoke.SendMessage(form, PInvoke.WM_SYSCOMMAND, (WPARAM)PInvoke.SC_RESTORE);
-
-        Assert.Equal(new Point(20, 21), form.Location);
-        Assert.Equal(new Size(300, 310), form.Size);
-    }
-
-    [WinFormsFact]
-    public void Form_Restore_RestoresPosition_WindowState()
-    {
-        if (!OsVersion.IsWindows11_OrGreater())
-        {
-            return;
-        }
-
-        using var form = new Form();
-        form.Show();
-
-        form.Location = new Point(10, 11);
-        form.Size = new Size(200, 210);
-
-        form.WindowState = FormWindowState.Maximized;
-
-        form.Location = new Point(20, 21);
-        form.Size = new Size(300, 310);
-
-        Assert.Equal(FormWindowState.Maximized, form.WindowState);
-        Assert.NotEqual(new Point(20, 21), form.Location);
-        Assert.NotEqual(new Size(300, 310), form.Size);
-
-        form.WindowState = FormWindowState.Normal;
-
-        Assert.Equal(new Point(20, 21), form.Location);
-        Assert.Equal(new Size(300, 310), form.Size);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, true)]
-    [InlineData(true, false)]
-    public static void ShowIcon_renders_icon_correctly(bool showIcon, bool expectedIconNull)
-    {
-        using var form = new Form();
-        Assert.True(form.Handle != 0);
-
-        form.ShowIcon = showIcon;
-
-        HICON hSmallIcon = (HICON)PInvoke.SendMessage(form, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_SMALL);
-        HICON hLargeIcon = (HICON)PInvoke.SendMessage(form, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_BIG);
-        Assert.Equal(expectedIconNull, hSmallIcon.IsNull);
-        Assert.Equal(expectedIconNull, hLargeIcon.IsNull);
-    }
-
-    [WinFormsFact]
-    public static void ShowIcon_false_should_render_no_icon()
-    {
-        using var form = new Form();
-        Assert.True(form.Handle != IntPtr.Zero);
-
-        WINDOW_EX_STYLE extendedStyle = unchecked((WINDOW_EX_STYLE)(long)PInvoke.GetWindowLong(form, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE));
-        Assert.False(extendedStyle.HasFlag(WINDOW_EX_STYLE.WS_EX_DLGMODALFRAME));
-
-        form.ShowIcon = false;
-
-        // hiding icon sets WS_EX.DLGMODALFRAME
-        extendedStyle = unchecked((WINDOW_EX_STYLE)(long)PInvoke.GetWindowLong(form, WINDOW_LONG_PTR_INDEX.GWL_EXSTYLE));
-        Assert.True(extendedStyle.HasFlag(WINDOW_EX_STYLE.WS_EX_DLGMODALFRAME));
-    }
-
-    public static IEnumerable<object[]> Parent_SetMdiChild_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_SetMdiChild_TestData))]
-    public void Form_Parent_SetMdiChild_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new Form
-        {
-            IsMdiContainer = true
-        };
-        using var control = new Form
-        {
-            MdiParent = oldParent,
-            Parent = value
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new Control();
-        using var control = new Form
-        {
-            TopLevel = false,
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void Form_Parent_SetWithHandle_GetReturnsExpected(Control value)
-    {
-        using var control = new Form
-        {
-            TopLevel = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Null(control.MdiParent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new Form
-        {
-            TopLevel = false
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new Form
-        {
-            TopLevel = false
-        };
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_SetTopLevel_ThrowsArgumentException()
-    {
-        using var control = new Form();
-        using var parent = new Control();
-        Assert.Throws<ArgumentException>(() => control.Parent = parent);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_SetFormWithMdiParent_ThrowsArgumentException()
-    {
-        using var oldParent = new Form
-        {
-            IsMdiContainer = true
-        };
-        using var control = new Form
-        {
-            MdiParent = oldParent
-        };
-        using var parent = new Form();
-        Assert.Throws<ArgumentException>("value", () => control.Parent = parent);
-        Assert.NotNull(control.Parent);
-        Assert.Same(oldParent, control.MdiParent);
-    }
-
-    [WinFormsFact]
-    public void Form_Parent_ShowIconInMaximized()
-    {
-        using var parent = new Form();
-        using var menuStrip = new MenuStrip();
-        parent.Controls.Add(menuStrip);
-        parent.IsMdiContainer = true;
-        parent.MainMenuStrip = menuStrip;
-        parent.Show();
-        Assert.True(parent.Handle != IntPtr.Zero);
-        using var control = new Form();
-        control.MdiParent = parent;
-        control.Icon = Form.DefaultIcon;
-        Assert.True(control.Handle != IntPtr.Zero);
-        control.Show();
-
-        control.ShowIcon = false;
-        HICON hSmallIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_SMALL);
-        Assert.True(hSmallIcon.IsNull);
-        HICON hLargeIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_BIG);
-        Assert.True(hLargeIcon.IsNull);
-
-        control.WindowState = FormWindowState.Maximized;
-        control.ShowIcon = false;
-        hSmallIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_SMALL);
-        Assert.True(hSmallIcon.IsNull);
-        hLargeIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_BIG);
-        Assert.True(hLargeIcon.IsNull);
-        Assert.True(!menuStrip.Items[0].Visible);
-
-        control.ShowIcon = true;
-        hSmallIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_SMALL);
-        Assert.False(hSmallIcon.IsNull);
-        hLargeIcon = (HICON)PInvoke.SendMessage(control, PInvoke.WM_GETICON, (WPARAM)PInvoke.ICON_BIG);
-        Assert.False(hLargeIcon.IsNull);
-        Assert.True(menuStrip.Items[0].Visible);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_Set_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, Color.Empty, allowTransparency };
-            yield return new object[] { allowTransparency, Color.Red, true };
-            yield return new object[] { allowTransparency, Color.Transparent, true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_Set_TestData))]
-    public void Form_TransparencyKey_Set_GetReturnsExpected(bool allowTransparency, Color value, bool expectedAllowTransparency)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = allowTransparency,
-            TransparencyKey = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetWithCustomOldValue_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, Color.Empty };
-            yield return new object[] { allowTransparency, Color.Red };
-            yield return new object[] { allowTransparency, Color.Transparent };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithCustomOldValue_TestData))]
-    public void Form_TransparencyKey_SetWithCustomOldValue_GetReturnsExpected(bool allowTransparency, Color value)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = allowTransparency,
-            TransparencyKey = Color.Yellow
-        };
-
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetWithOpacity_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, Color.Empty };
-            yield return new object[] { allowTransparency, Color.Red };
-            yield return new object[] { allowTransparency, Color.Transparent };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithOpacity_TestData))]
-    public void Form_TransparencyKey_SetWithOpacity_GetReturnsExpected(bool allowTransparency, Color value)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = allowTransparency,
-            Opacity = 0.5,
-            TransparencyKey = value
-        };
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetMdiContainer_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, Color.Empty };
-            yield return new object[] { allowTransparency, Color.Red };
-            yield return new object[] { allowTransparency, Color.Transparent };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetMdiContainer_TestData))]
-    public void Form_TransparencyKey_SetMdiContainer_Nop(bool allowTransparency, Color value)
-    {
-        using var control = new Form
-        {
-            IsMdiContainer = true,
-            AllowTransparency = allowTransparency,
-            TransparencyKey = value
-        };
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_Set_TestData))]
-    public void Form_TransparencyKey_SetNotTopLevel_GetReturnsExpected(bool allowTransparency, Color value, bool expectedAllowTransparency)
-    {
-        using var control = new Form
-        {
-            TopLevel = true,
-            AllowTransparency = allowTransparency,
-            TransparencyKey = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Form_TransparencyKey_SetNotTransparentWithHandleSetNotAllowTransparency_GetReturnsExpected()
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = Color.Empty;
-        Assert.False(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = Color.Empty;
-        Assert.False(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetWithHandleSetNotAllowTransparency_TestData()
-    {
-        yield return new object[] { Color.Red, true, 2 };
-        yield return new object[] { Color.Transparent, true, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithHandleSetNotAllowTransparency_TestData))]
-    public void Form_TransparencyKey_SetTransparentWithHandleSetNotAllowTransparency_GetReturnsExpected(Color value, bool expectedAllowTransparency, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_TransparencyKey_SetNotTransparentWithHandleSetAllowTransparencyBefore_GetReturnsExpected()
-    {
-        using var control = new Form
-        {
-            AllowTransparency = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetWithHandleSetAllowTransparency_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.Transparent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithHandleSetAllowTransparency_TestData))]
-    public void Form_TransparencyKey_SetTransparentWithHandleSetAllowTransparencyBefore_GetReturnsExpected(Color value)
-    {
-        using var control = new Form
-        {
-            AllowTransparency = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_TransparencyKey_SetNotTransparentWithHandleSetAllowTransparencyAfter_GetReturnsExpected()
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = true;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithHandleSetAllowTransparency_TestData))]
-    public void Form_TransparencyKey_SetTransparentWithHandleSetAllowTransparencyAfter_GetReturnsExpected(Color value)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = true;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_TransparencyKey_SetNotTransparentWithHandleSetOpacityBefore_GetReturnsExpected()
-    {
-        using var control = new Form
-        {
-            Opacity = 0.5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithHandleSetAllowTransparency_TestData))]
-    public void Form_TransparencyKey_SetTransparentWithHandleSetOpacityBefore_GetReturnsExpected(Color value)
-    {
-        using var control = new Form
-        {
-            Opacity = 0.5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_TransparencyKey_SetNotTransparentWithHandleSetOpacityAfter_GetReturnsExpected()
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Opacity = 0.5;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = Color.Empty;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(Color.Empty, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetWithHandleSetAllowTransparency_TestData))]
-    public void Form_TransparencyKey_SetTransparentWithHandleSetOpacityAfter_GetReturnsExpected(Color value)
-    {
-        using var control = new Form();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Opacity = 0.5;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(0.5, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TransparencyKey_SetNotTopLevelWithHandle_TestData()
-    {
-        yield return new object[] { true, Color.Empty, true, 1 };
-        yield return new object[] { true, Color.Red, true, 0 };
-        yield return new object[] { true, Color.Transparent, true, 0 };
-
-        yield return new object[] { false, Color.Empty, false, 0 };
-        yield return new object[] { false, Color.Red, true, 2 };
-        yield return new object[] { false, Color.Transparent, true, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparencyKey_SetNotTopLevelWithHandle_TestData))]
-    public void Form_TransparencyKey_SetNotTopLevelWithHandle_GetReturnsExpected(bool allowTransparency, Color value, bool expectedAllowTransparency, int expectedStyleChangedCallCount)
-    {
-        using var control = new Form
-        {
-            TopLevel = false,
-            AllowTransparency = allowTransparency
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TransparencyKey = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.Equal(value, control.TransparencyKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_ShowInTaskbar_SetFalse_GetReturnsExpected()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/6421
-
-        using var form = new Form
-        {
-            ShowInTaskbar = true,
-        };
-
-        DialogResult expectedDialogResult = DialogResult.OK;
-
-        form.Load += (object sender, EventArgs e) =>
-        {
-            IntPtr formHandle = form.Handle;
-            form.ShowInTaskbar = false;
-
-            Assert.True(form.IsHandleCreated);
-            Assert.NotEqual(formHandle, form.Handle);
-        };
-
-        form.Shown += (object sender, EventArgs e) =>
-        {
-            form.DialogResult = expectedDialogResult;
-        };
-
-        Assert.Equal(expectedDialogResult, form.ShowDialog());
-        Assert.Equal(expectedDialogResult, form.DialogResult);
-    }
-
-    public static IEnumerable<object[]> Visible_Set_TestData()
-    {
-        foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult)))
-        {
-            yield return new object[] { dialogResult, true };
-            yield return new object[] { dialogResult, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void Form_Visible_Set_GetReturnsExpected(DialogResult dialogResult, bool value)
-    {
-        using var control = new Form
-        {
-            DialogResult = dialogResult,
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(value, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(value, control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetMdiChild_TestData()
-    {
-        foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult)))
-        {
-            yield return new object[] { dialogResult, true, true, true };
-            yield return new object[] { dialogResult, true, false, false };
-            yield return new object[] { dialogResult, false, true, false };
-            yield return new object[] { dialogResult, false, false, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetMdiChild_TestData))]
-    public void Form_Visible_SetMdiChild_GetReturnsExpected(DialogResult dialogResult, bool parentVisible, bool value, bool expected)
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true,
-            Visible = parentVisible
-        };
-        using var control = new Form
-        {
-            MdiParent = parent,
-            DialogResult = dialogResult,
-            Visible = value
-        };
-        Assert.Equal(expected, control.Visible);
-        Assert.Equal(expected, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(expected, control.Visible);
-        Assert.Equal(expected, control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!expected && parentVisible, control.Visible);
-        Assert.Equal(!expected && parentVisible, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.Equal(!expected && parentVisible, control.Visible);
-        Assert.Equal(!expected && parentVisible, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void Form_Visible_SetWithHandle_GetReturnsExpected(DialogResult dialogResult, bool value)
-    {
-        using var control = new Form
-        {
-            DialogResult = dialogResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DialogResult>]
-    public void Form_Visible_SetTrueMdiChildVisibleWithHandle_GetReturnsExpected(DialogResult dialogResult)
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true,
-            Visible = true
-        };
-        using var control = new Form
-        {
-            MdiParent = parent,
-            DialogResult = dialogResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = true;
-        Assert.Equal(dialogResult == DialogResult.OK || dialogResult == DialogResult.None, control.Visible);
-        Assert.Equal(dialogResult == DialogResult.OK || dialogResult == DialogResult.None, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = true;
-        Assert.Equal(dialogResult != DialogResult.OK, control.Visible);
-        Assert.Equal(dialogResult != DialogResult.OK, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DialogResult>]
-    public void Form_Visible_SetFalseMdiChildVisibleWithHandle_GetReturnsExpected(DialogResult dialogResult)
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true,
-            Visible = true
-        };
-        using var control = new Form
-        {
-            MdiParent = parent,
-            DialogResult = dialogResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        control.Visible = true;
-        Assert.Equal(dialogResult == DialogResult.None, control.Visible);
-        Assert.Equal(dialogResult == DialogResult.None, control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_Set_TestData))]
-    public void Form_Visible_SetMdiChildNotVisibleWithHandle_GetReturnsExpected(DialogResult dialogResult, bool value)
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true
-        };
-        using var control = new Form
-        {
-            MdiParent = parent,
-            DialogResult = dialogResult,
-            Visible = value
-        };
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithHandler_TestData()
-    {
-        foreach (DialogResult dialogResult in Enum.GetValues(typeof(DialogResult)))
-        {
-            yield return new object[] { dialogResult, true, 1 };
-            yield return new object[] { dialogResult, false, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandler_TestData))]
-    public void Form_Visible_SetTrueWithHandler_CallsVisibleChanged(DialogResult dialogResult, bool value, int expectedLoadCallCount)
-    {
-        using var control = new Form
-        {
-            DialogResult = dialogResult
-        };
-        int loadCallCount = 0;
-        control.Load += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount, callCount);
-        Assert.Equal(expectedLoadCallCount, loadCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount, callCount);
-        Assert.Equal(expectedLoadCallCount, loadCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_Visible_SetWithHandlerMdiChildVisible_CallsVisibleChanged()
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true,
-            Visible = true
-        };
-        using var control = new Form
-        {
-            MdiParent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(3, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(3, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(4, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(4, callCount);
-    }
-
-    [WinFormsFact]
-    public void Form_Visible_SetWithHandlerMdiChildNotVisible_CallsVisibleChanged()
-    {
-        using var parent = new Form
-        {
-            IsMdiContainer = true
-        };
-        using var control = new Form
-        {
-            MdiParent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = true;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = true;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.False(control.Visible);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandler_TestData))]
-    public void Form_Visible_SetTrueWithHandlerWithHandle_CallsVisibleChanged(DialogResult dialogResult, bool value, int expectedLoadCallCount)
-    {
-        using var control = new Form
-        {
-            DialogResult = dialogResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int loadCallCount = 0;
-        control.Load += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount, callCount);
-        Assert.Equal(expectedLoadCallCount, loadCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount, callCount);
-        Assert.Equal(expectedLoadCallCount, loadCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-
-        // Set same.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(expectedLoadCallCount + 1, callCount);
-        Assert.Equal(1, loadCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Form_Visible_SetWithHandlerWithHandle_CallsVisibleChanged(bool initialVisible)
-    {
-        using var control = new Form
-        {
-            Visible = initialVisible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = !initialVisible;
-        Assert.Equal(!initialVisible, control.Visible);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = !initialVisible;
-        Assert.Equal(!initialVisible, control.Visible);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = initialVisible;
-        Assert.Equal(initialVisible, control.Visible);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = !initialVisible;
-        Assert.Equal(!initialVisible, control.Visible);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Form_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubForm();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubForm.ScrollStateAutoScrolling, false)]
-    [InlineData(SubForm.ScrollStateFullDrag, false)]
-    [InlineData(SubForm.ScrollStateHScrollVisible, false)]
-    [InlineData(SubForm.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubForm.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void Form_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubForm();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Form_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubForm();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Form_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubForm();
-        Assert.True(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Form_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubForm();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Form_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubForm();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Form_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubForm();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Form_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubForm();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> FormShow_TestData()
-    {
-        // Test with control passed as owner.
-        yield return new Action<Form, Control>[]
-        {
-            (Form form, Control control) => form.Show(owner: control)
-        };
-        yield return new Action<Form, Control>[]
-        {
-            (Form form, Control control) => form.ShowDialog(owner: control)
-        };
-
-        // Test with parent form passed as owner.
-        yield return new Action<Form, Control>[]
-        {
-            (Form form, Control control) => form.Show(owner: control.FindForm())
-        };
-        yield return new Action<Form, Control>[]
-        {
-            (Form form, Control control) => form.ShowDialog(owner: control.FindForm())
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FormShow_TestData))]
-    public void Form_Show_SetsOwnerToTopLevelForm_WhenShownWithOwner(Action<Form, Control> showAction)
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/8280
-
-        using Form parent = new();
-        using Control control = new();
-        parent.Controls.Add(control);
-        parent.Show();
-
-        using Form child = new();
-        Form owner = null;
-        child.Load += (object sender, EventArgs e) =>
-        {
-            owner = ((Form)sender).Owner;
-            child.Close();
-        };
-
-        showAction(child, control);
-
-        Assert.Same(parent, owner);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Form_ParentThenSetShowInTaskbarToFalse()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/8803
-        using ParentedForm form = new();
-        form.Show();
-    }
-
-    [WinFormsFact]
-    public void Form_MdiContainer_WithChild_DoubleDispose()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/8990
-        using Form parent = new() { IsMdiContainer = true };
-        using Form mdiChild = new() { MdiParent = parent };
-        parent.Show();
-        mdiChild.Show();
-        parent.Dispose();
-        parent.Dispose();
-    }
-
-    [WinFormsFact]
-    public void Form_DoesNot_PreventShutDown()
-    {
-        using SubForm form = new();
-        var message = Message.Create(HWND.Null, PInvoke.WM_QUERYENDSESSION, wparam: default, lparam: default);
-        form.WndProc(ref message);
-        Assert.True((BOOL)message.ResultInternal);
-    }
-
-    public partial class ParentedForm : Form
-    {
-        private ParentingForm _parentForm;
-
-        protected override void OnHandleCreated(EventArgs e)
-        {
-            base.OnHandleCreated(e);
-            _parentForm = new ParentingForm(this);
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            base.Dispose(disposing);
-
-            if (disposing)
-            {
-                _parentForm?.Dispose();
-            }
-        }
-
-        public class ParentingForm : Form
-        {
-            public ParentingForm(Form targetForm)
-            {
-                targetForm.Owner = this;
-                RecreateHandle();
-            }
-        }
-    }
-
-    public class SubForm : Form
-    {
-        public new const int ScrollStateAutoScrolling = Form.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = Form.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = Form.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = Form.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = Form.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new Rectangle MaximizedBounds => base.MaximizedBounds;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool ShowWithoutActivation => base.ShowWithoutActivation;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GiveFeedbackEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GiveFeedbackEventArgsTests.cs
deleted file mode 100644
index 5884324cac1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GiveFeedbackEventArgsTests.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class GiveFeedbackEventArgsTests
-{
-    [Theory]
-    [InlineData(DragDropEffects.None, true)]
-    [InlineData((DragDropEffects)(DragDropEffects.None - 1), false)]
-    public void Ctor_DragDropEffects_Bool(DragDropEffects effect, bool useDefaultCursors)
-    {
-        var e = new GiveFeedbackEventArgs(effect, useDefaultCursors);
-        Assert.Equal(effect, e.Effect);
-        Assert.Equal(useDefaultCursors, e.UseDefaultCursors);
-    }
-
-    [Theory]
-    [MemberData(nameof(CursorOffset_TestData))]
-    public void CursorOffset_Set_GetReturnsExpected(Point value)
-    {
-        var e = new GiveFeedbackEventArgs(DragDropEffects.None, false, new Bitmap(1, 1), new Point(0, 0), false)
-        {
-            CursorOffset = value
-        };
-        Assert.Equal(value, e.CursorOffset);
-    }
-
-    public static IEnumerable<object[]> CursorOffset_TestData()
-    {
-        yield return new object[] { new Point(1, 1) };
-        yield return new object[] { new Point(-1, -1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DragImage_TestData))]
-    public void DragImage_Set_GetReturnsExpected(Bitmap value)
-    {
-        var e = new GiveFeedbackEventArgs(DragDropEffects.None, false, new Bitmap(2, 2), new Point(0, 0), false)
-        {
-            DragImage = value
-        };
-        Assert.Equal(value, e.DragImage);
-    }
-
-    public static IEnumerable<object[]> DragImage_TestData()
-    {
-        yield return new object[] { new Bitmap(1, 1) };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void UseDefaultCursors_Set_GetReturnsExpected(bool value)
-    {
-        var e = new GiveFeedbackEventArgs(DragDropEffects.None, false)
-        {
-            UseDefaultCursors = value
-        };
-        Assert.Equal(value, e.UseDefaultCursors);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void UseDefaultDragImage_Set_GetReturnsExpected(bool value)
-    {
-        var e = new GiveFeedbackEventArgs(DragDropEffects.None, false, new Bitmap(1, 1), new Point(0, 0), false)
-        {
-            UseDefaultDragImage = value
-        };
-        Assert.Equal(value, e.UseDefaultDragImage);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemCollectionTests.cs
deleted file mode 100644
index f2acd9fff56..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemCollectionTests.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class GridItemCollectionTests
-{
-    [Fact]
-    public void GridItemCollection_Empty_Get_ReturnsExpected()
-    {
-        GridItemCollection collection = GridItemCollection.Empty;
-        Assert.Same(collection, GridItemCollection.Empty);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void GridItemCollection_ICollection_GetProperties_ReturnsExpected()
-    {
-        ICollection collection = GridItemCollection.Empty;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void GridItemCollection_CopyTo_Empty_Nop(int index)
-    {
-        ICollection collection = GridItemCollection.Empty;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, index);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [Fact]
-    public void GridItemCollection_GetEnumerator_Empty_ReturnsExpected()
-    {
-        GridItemCollection collection = GridItemCollection.Empty;
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.False(enumerator.MoveNext());
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void GridItemCollection_Item_GetEmpty_ReturnsNull(string label)
-    {
-        GridItemCollection collection = GridItemCollection.Empty;
-        Assert.Null(collection[label]);
-    }
-
-    private class SubGridItem : GridItem
-    {
-        public override GridItemCollection GridItems => GridItemCollection.Empty;
-
-        public override GridItemType GridItemType => GridItemType.Property;
-
-        public override string Label => "label";
-
-        public override GridItem Parent => null;
-
-        public override PropertyDescriptor PropertyDescriptor => null;
-
-        public override object Value => "value";
-
-        public override bool Select() => true;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemTests.cs
deleted file mode 100644
index 1200dfde47e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GridItemTests.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class GridItemTests
-{
-    [Fact]
-    public void GridItem_Expandable_Get_ReturnsFalse()
-    {
-        var item = new SubGridItem();
-        Assert.False(item.Expandable);
-    }
-
-    [Fact]
-    public void GridItem_Expanded_Get_ReturnsFalse()
-    {
-        var item = new SubGridItem();
-        Assert.False(item.Expanded);
-    }
-
-    [Theory]
-    [BoolData]
-    public void GridItem_Expanded_Set_ThrowsNotSupportedException(bool value)
-    {
-        var item = new SubGridItem();
-        Assert.Throws<NotSupportedException>(() => item.Expanded = value);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void GridItem_Tag_Set_GetReturnsExpected(object value)
-    {
-        var item = new SubGridItem
-        {
-            Tag = value
-        };
-        Assert.Same(value, item.Tag);
-
-        // Set same.
-        item.Tag = value;
-        Assert.Same(value, item.Tag);
-    }
-
-    private class SubGridItem : GridItem
-    {
-        public override GridItemCollection GridItems => GridItemCollection.Empty;
-
-        public override GridItemType GridItemType => GridItemType.Property;
-
-        public override string Label => "label";
-
-        public override GridItem Parent => null;
-
-        public override PropertyDescriptor PropertyDescriptor => null;
-
-        public override object Value => "value";
-
-        public override bool Select() => true;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxAccessibleObjectTests.cs
deleted file mode 100644
index cac86533382..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,131 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class GroupBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        string testAccName = "Test group name";
-        using var groupBox = new GroupBox();
-        AccessibleObject groupBoxAccessibleObject = groupBox.AccessibilityObject;
-
-        Assert.Null(groupBoxAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.NamePropertyId));
-        Assert.Null(groupBoxAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-
-        groupBox.Text = "Some test groupBox text";
-        groupBox.Name = "Group1";
-        groupBox.AccessibleName = testAccName;
-
-        Assert.Equal(testAccName, groupBoxAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.NamePropertyId));
-        Assert.Equal(testAccName, groupBoxAccessibleObject.GetPropertyValue(Interop.UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-        Assert.False(groupBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var groupBox = new GroupBox();
-        groupBox.Name = "Group1";
-        groupBox.Text = "Some test groupBox text";
-        var groupBoxAccessibleObject = new GroupBox.GroupBoxAccessibleObject(groupBox);
-
-        Assert.False(groupBox.IsHandleCreated);
-
-        bool supportsLegacyIAccessiblePatternId = groupBoxAccessibleObject.IsPatternSupported(Interop.UiaCore.UIA.LegacyIAccessiblePatternId);
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_LegacyIAccessible_Role_ReturnsExpected()
-    {
-        using var groupBox = new GroupBox();
-        groupBox.Name = "Group1";
-        groupBox.Text = "Some test groupBox text";
-        groupBox.AccessibleRole = AccessibleRole.Link;
-        var groupBoxAccessibleObject = new GroupBox.GroupBoxAccessibleObject(groupBox);
-
-        Assert.False(groupBox.IsHandleCreated);
-        Assert.Equal(AccessibleRole.Link, groupBoxAccessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_Role_IsGrouping_ByDefault()
-    {
-        using GroupBox groupBox = new GroupBox();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = groupBox.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Grouping, actual);
-        Assert.False(groupBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_LegacyIAccessible_Description_ReturnsExpected()
-    {
-        string testAccDescription = "Test description";
-        using var groupBox = new GroupBox();
-        groupBox.Name = "Group1";
-        groupBox.Text = "Some test groupBox text";
-        groupBox.AccessibleDescription = testAccDescription;
-        var groupBoxAccessibleObject = new GroupBox.GroupBoxAccessibleObject(groupBox);
-
-        Assert.False(groupBox.IsHandleCreated);
-        Assert.Equal(testAccDescription, groupBoxAccessibleObject.Description);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_ControlType_IsGroup_IfAccessibleRoleIsDefault()
-    {
-        using GroupBox groupBox = new GroupBox();
-        // AccessibleRole is not set = Default
-        object actual = groupBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        Assert.Equal(UiaCore.UIA.GroupControlTypeId, actual);
-        Assert.False(groupBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GroupBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GroupBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void GroupBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using GroupBox groupBox = new GroupBox();
-        groupBox.AccessibleRole = role;
-
-        object actual = groupBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(groupBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GroupBoxAccessibleObject_GetPropertyValue_AutomationId_ReturnsExpected()
-    {
-        using GroupBox ownerControl = new() { Name = "test name" };
-        string expected = ownerControl.Name;
-        object actual = ownerControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.False(ownerControl.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxTests.cs
deleted file mode 100644
index 2d65d60b489..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupBoxTests.cs
+++ /dev/null
@@ -1,2375 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class GroupBoxTests
-{
-    [WinFormsFact]
-    public void GroupBox_Ctor_Default()
-    {
-        using var control = new SubGroupBox();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(new Padding(3), control.DefaultPadding);
-        Assert.Equal(new Size(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(new Padding(3), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(6, 6 + Control.DefaultFont.Height), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubGroupBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, null, 0x56000000)]
-    [InlineData(FlatStyle.Popup, null, 0x56000000)]
-    [InlineData(FlatStyle.Standard, null, 0x56000000)]
-    [InlineData(FlatStyle.System, "Button", 0x56000007)]
-    public void GroupBox_CreateParams_GetFlatStyle_ReturnsExpected(FlatStyle flatStyle, string expectedClassName, int expectedStyle)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = flatStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal(expectedClassName, createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new GroupBox
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = !value;
-        Assert.Equal(!value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void GroupBox_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new GroupBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new GroupBox
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void GroupBox_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubGroupBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void GroupBox_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubGroupBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void GroupBox_AutoSizeMode_SetWithCustomLayoutEngineParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubGroupBox
-        {
-            Parent = parent
-        };
-        parent.SetLayoutEngine(new SubLayoutEngine());
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = base.LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-    }
-
-    private class SubLayoutEngine : LayoutEngine
-    {
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void GroupBox_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubGroupBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void GroupBox_AutoSizeMode_SetWithParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubGroupBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void GroupBox_AutoSizeMode_SetWithCustomLayoutEngineParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubGroupBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoSizeMode>]
-    public void GroupBox_AutoSizeMode_SetInvalid_ThrowsInvalidEnumArgumentException(AutoSizeMode value)
-    {
-        using var control = new GroupBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoSizeMode = value);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_DisplayRectangle_Get_ReturnsExpected()
-    {
-        using var control = new GroupBox();
-        Rectangle result = control.DisplayRectangle;
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.Equal(result, control.DisplayRectangle);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_DisplayRectangle_GetWithCustomFontSetAfterCallingDisplayRectangle_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var control = new GroupBox();
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-
-        control.Font = font;
-        Rectangle result = control.DisplayRectangle;
-        Assert.Equal(new Rectangle(3, font.Height + 3, 194, 94 - font.Height), control.DisplayRectangle);
-        Assert.Equal(result, control.DisplayRectangle);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_DisplayRectangle_GetWithCustomFontSetBeforeCallingDisplayRectangle_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var control = new GroupBox
-        {
-            Font = font
-        };
-        Rectangle result = control.DisplayRectangle;
-        Assert.Equal(new Rectangle(3, font.Height + 3, 194, 94 - font.Height), control.DisplayRectangle);
-        Assert.Equal(result, control.DisplayRectangle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, true, true)]
-    [InlineData(FlatStyle.Popup, true, true, true)]
-    [InlineData(FlatStyle.Standard, false, true, false)]
-    [InlineData(FlatStyle.System, true, false, false)]
-    public void GroupBox_FlatStyle_Set_GetReturnsExpected(FlatStyle value, bool containerControl, bool ownerDraw, bool userMouse)
-    {
-        using var control = new SubGroupBox();
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, FlatStyle.Flat, false, true, true)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Popup, true, true, true)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Standard, true, true, true)]
-    [InlineData(FlatStyle.Flat, FlatStyle.System, true, false, false)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Flat, true, true, true)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Popup, false, true, true)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Standard, true, true, true)]
-    [InlineData(FlatStyle.Popup, FlatStyle.System, true, false, false)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Flat, true, true, true)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Popup, true, true, true)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Standard, false, true, false)]
-    [InlineData(FlatStyle.Standard, FlatStyle.System, true, false, false)]
-    [InlineData(FlatStyle.System, FlatStyle.Flat, true, true, true)]
-    [InlineData(FlatStyle.System, FlatStyle.Popup, true, true, true)]
-    [InlineData(FlatStyle.System, FlatStyle.Standard, true, true, true)]
-    [InlineData(FlatStyle.System, FlatStyle.System, false, false, false)]
-    public void GroupBox_FlatStyle_SetWithCustomOldValue_GetReturnsExpected(FlatStyle oldValue, FlatStyle value, bool containerControl, bool ownerDraw, bool userMouse)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = oldValue
-        };
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.Equal(value, control.FlatStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, false, true, false, 0, 0)]
-    [InlineData(FlatStyle.System, true, false, false, 0, 1)]
-    public void GroupBox_FlatStyle_VisualStyles_off_SetWithHandle_GetReturnsExpected(FlatStyle value, bool containerControl, bool ownerDraw, bool userMouse, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        if (Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, false, true, false, 0, 0)]
-    [InlineData(FlatStyle.System, true, false, false, 1, 1)]
-    public void GroupBox_FlatStyle_VisualStyles_on_SetWithHandle_GetReturnsExpected(
-        FlatStyle value,
-        bool containerControl,
-        bool ownerDraw,
-        bool userMouse,
-        int expectedInvalidatedCallCount,
-        int expectedCreatedCallCount)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, FlatStyle.Flat, false, true, true, 0, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Standard, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Popup, false, true, true, 0, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Standard, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Standard, false, true, false, 0, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Flat, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Popup, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Standard, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.System, false, false, false, 0, 0)]
-    public void GroupBox_FlatStyle_VisualStyles_off_SetWithCustomOldValueWithHandle_GetReturnsExpected(FlatStyle oldValue, FlatStyle value, bool containerControl, bool ownerDraw, bool userMouse, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        if (Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox
-        {
-            FlatStyle = oldValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, FlatStyle.Flat, false, true, true, 0, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.Standard, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Flat, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Popup, false, true, true, 0, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.Standard, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Popup, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Flat, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Popup, true, true, true, 1, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.Standard, false, true, false, 0, 0)]
-    [InlineData(FlatStyle.Standard, FlatStyle.System, true, false, false, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Flat, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Popup, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.Standard, true, true, true, 0, 1)]
-    [InlineData(FlatStyle.System, FlatStyle.System, false, false, false, 0, 0)]
-    public void GroupBox_FlatStyle_VisualStyles_on_SetWithCustomOldValue_GetReturnsExpected(FlatStyle oldValue, FlatStyle value, bool containerControl, bool ownerDraw, bool userMouse, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox
-        {
-            FlatStyle = oldValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SetStyle(ControlStyles.ContainerControl, false);
-
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.True(invalidatedCallCount >= expectedInvalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.FlatStyle = value;
-        Assert.Equal(value, control.FlatStyle);
-        Assert.Equal(containerControl, control.GetStyle(ControlStyles.ContainerControl));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.SupportsTransparentBackColor));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.UserPaint));
-        Assert.Equal(ownerDraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(userMouse, control.GetStyle(ControlStyles.UserMouse));
-        Assert.True(control.IsHandleCreated);
-        Assert.True(invalidatedCallCount >= expectedInvalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_PreferredSize_GetWithChildrenSimple_ReturnsExpected()
-    {
-        using var control = new GroupBox();
-        using var child = new Control
-        {
-            Size = new Size(16, 20)
-        };
-        control.Controls.Add(child);
-        Assert.Equal(new Size(22, 25), control.PreferredSize);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_PreferredSize_GetWithBorder_ReturnsExpected()
-    {
-        using var control = new BorderedGroupBox
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(new Size(8, 9), control.PreferredSize);
-    }
-
-    private class BorderedGroupBox : GroupBox
-    {
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                CreateParams cp = base.CreateParams;
-                cp.Style |= (int)WINDOW_STYLE.WS_BORDER;
-                cp.ExStyle |= (int)WINDOW_EX_STYLE.WS_EX_STATICEDGE;
-                return cp;
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void GroupBox_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new GroupBox
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void GroupBox_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new GroupBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new GroupBox
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void GroupBox_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new GroupBox
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void GroupBox_Text_SetInvisible_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new GroupBox
-        {
-            Visible = false,
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void GroupBox_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new GroupBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void GroupBox_Text_SetInvisibleWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new GroupBox
-        {
-            Visible = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new GroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void GroupBox_UseCompatibleTextRendering_Set_GetReturnsExpected(bool autoSize, bool value)
-    {
-        using var control = new GroupBox
-        {
-            AutoSize = autoSize,
-            UseCompatibleTextRendering = value
-        };
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseCompatibleTextRendering = !value;
-        Assert.Equal(!value, control.UseCompatibleTextRendering);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 1)]
-    [InlineData(true, false, 1, 2)]
-    [InlineData(false, true, 0, 0)]
-    [InlineData(false, false, 0, 0)]
-    public void GroupBox_UseCompatibleTextRendering_SetWithParent_GetReturnsExpected(bool autoSize, bool value, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new GroupBox
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("UseCompatibleTextRendering", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set different.
-            control.UseCompatibleTextRendering = !value;
-            Assert.Equal(!value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 0)]
-    [InlineData(false, false, 1)]
-    public void GroupBox_UseCompatibleTextRendering_SetWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new GroupBox
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseCompatibleTextRendering = value;
-        Assert.Equal(value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseCompatibleTextRendering = !value;
-        Assert.Equal(!value, control.UseCompatibleTextRendering);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 0, 1)]
-    [InlineData(true, false, 1, 1, 2)]
-    [InlineData(false, true, 0, 0, 0)]
-    [InlineData(false, false, 1, 0, 0)]
-    public void GroupBox_UseCompatibleTextRendering_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, bool value, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        using var parent = new Control();
-        using var control = new GroupBox
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("UseCompatibleTextRendering", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.UseCompatibleTextRendering = value;
-            Assert.Equal(value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            control.UseCompatibleTextRendering = !value;
-            Assert.Equal(!value, control.UseCompatibleTextRendering);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void GroupBox_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubGroupBox();
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.Grouping, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubGroupBox
-        {
-            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);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubGroupBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void GroupBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubGroupBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void GroupBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubGroupBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void GroupBox_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void GroupBox_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void GroupBox_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_WithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, null };
-            yield return new object[] { userPaint, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithHandle_TestData))]
-    public void GroupBox_OnFontChanged_InvokeWithHandle_CallsFontChangedAndInvalidated(bool userPaint, EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.Equal(new Rectangle(3, Control.DefaultFont.Height + 3, 194, 94 - Control.DefaultFont.Height), control.DisplayRectangle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void GroupBox_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void GroupBox_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void GroupBox_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void GroupBox_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void GroupBox_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void GroupBox_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void GroupBox_OnMouseEnter_Invoke_CallsMouseEnter(EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void GroupBox_OnMouseLeave_Invoke_CallsMouseLeave(EventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void GroupBox_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void GroupBox_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubGroupBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool useCompatibleTextRendering in new bool[] { true, false })
-            {
-                foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-                {
-                    foreach (Color foreColor in new Color[] { Color.Red, Color.Empty })
-                    {
-                        foreach (string text in new string[] { null, string.Empty, "text" })
-                        {
-                            yield return new object[] { new Size(100, 200), enabled, useCompatibleTextRendering, rightToLeft, foreColor, text };
-                            yield return new object[] { new Size(10, 10), enabled, useCompatibleTextRendering, rightToLeft, foreColor, text };
-                            yield return new object[] { new Size(9, 10), enabled, useCompatibleTextRendering, rightToLeft, foreColor, text };
-                            yield return new object[] { new Size(10, 9), enabled, useCompatibleTextRendering, rightToLeft, foreColor, text };
-                            yield return new object[] { new Size(9, 9), enabled, useCompatibleTextRendering, rightToLeft, foreColor, text };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void GroupBox_OnPaint_Invoke_CallsPaint(Size size, bool enabled, bool useCompatibleTextRendering, RightToLeft rightToLeft, Color foreColor, string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubGroupBox
-        {
-            Size = size,
-            Enabled = enabled,
-            UseCompatibleTextRendering = useCompatibleTextRendering,
-            RightToLeft = rightToLeft,
-            ForeColor = foreColor,
-            Text = text
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void GroupBox_OnPaint_InvokeWithHandle_CallsPaint(Size size, bool enabled, bool useCompatibleTextRendering, RightToLeft rightToLeft, Color foreColor, string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubGroupBox
-        {
-            Size = size,
-            Enabled = enabled,
-            UseCompatibleTextRendering = useCompatibleTextRendering,
-            RightToLeft = rightToLeft,
-            ForeColor = foreColor,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void GroupBox_OnPaint_VisualStyles_on_NullE_ThrowsArgumentNullException()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaint(null));
-    }
-
-    [WinFormsFact]
-    public void GroupBox_OnPaint_VisualStyles_off_NullE_ThrowsNullReferenceException()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubGroupBox();
-        Assert.Throws<NullReferenceException>(() => control.OnPaint(null));
-    }
-
-    public static IEnumerable<object[]> ProcessMnemonic_TestData()
-    {
-        yield return new object[] { null, 'a', false };
-        yield return new object[] { string.Empty, 'a', false };
-        yield return new object[] { "a", 'a', false };
-        yield return new object[] { "&a", 'a', true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_TestData))]
-    public void GroupBox_ProcessMnemonic_Invoke_ReturnsExpected(string text, char charCode, bool expected)
-    {
-        using var control = new SubGroupBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.ProcessMnemonic(charCode));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_TestData))]
-    public void GroupBox_ProcessMnemonic_InvokeWithParent_ReturnsExpected(string text, char charCode, bool expected)
-    {
-        using var parent = new Control();
-        using var control = new SubGroupBox
-        {
-            Parent = parent,
-            Text = text
-        };
-        Assert.Equal(expected, control.ProcessMnemonic(charCode));
-    }
-
-    public static IEnumerable<object[]> ProcessMnemonic_CantProcess_TestData()
-    {
-        yield return new object[] { null, 'a' };
-        yield return new object[] { string.Empty, 'a' };
-        yield return new object[] { "a", 'a' };
-        yield return new object[] { "&a", 'a' };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_CantProcess_TestData))]
-    public void GroupBox_ProcessMnemonic_InvokeNotVisible_ReturnsFalse(string text, char charCode)
-    {
-        using var control = new SubGroupBox
-        {
-            Text = text,
-            Visible = false
-        };
-        Assert.False(control.ProcessMnemonic(charCode));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_CantProcess_TestData))]
-    public void GroupBox_ProcessMnemonic_InvokeNotEnabled_ReturnsFalse(string text, char charCode)
-    {
-        using var control = new SubGroupBox
-        {
-            Text = text,
-            Enabled = false
-        };
-        Assert.False(control.ProcessMnemonic(charCode));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_CantProcess_TestData))]
-    public void GroupBox_ProcessMnemonic_InvokeParentNotVisible_ReturnsFalse(string text, char charCode)
-    {
-        using var parent = new Control
-        {
-            Visible = false
-        };
-        using var control = new SubGroupBox
-        {
-            Parent = parent,
-            Text = text
-        };
-        Assert.False(control.ProcessMnemonic(charCode));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessMnemonic_CantProcess_TestData))]
-    public void GroupBox_ProcessMnemonic_InvokeParentNotEnabled_ReturnsFalse(string text, char charCode)
-    {
-        using var parent = new Control
-        {
-            Enabled = false
-        };
-        using var control = new SubGroupBox
-        {
-            Parent = parent,
-            Text = text
-        };
-        Assert.False(control.ProcessMnemonic(charCode));
-    }
-
-    [WinFormsFact]
-    public void GroupBox_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new GroupBox();
-        Assert.Equal("System.Windows.Forms.GroupBox, Text: ", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void GroupBox_ToString_InvokeWithText_ReturnsExpected()
-    {
-        using var control = new GroupBox
-        {
-            Text = "CustomText"
-        };
-        Assert.Equal("System.Windows.Forms.GroupBox, Text: CustomText", control.ToString());
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgnd_TestData()
-    {
-        yield return new object[] { PInvoke.WM_ERASEBKGND };
-        yield return new object[] { PInvoke.WM_PRINTCLIENT };
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_ERASEBKGND)]
-    [InlineData((int)PInvoke.WM_PRINTCLIENT)]
-    public void GroupBox_WndProc_InvokeEraseBkgndNotOwnerDrawWithoutHandle_Success(int msg)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = FlatStyle.System
-        };
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)1, m.Result);
-            Assert.True(control.IsHandleCreated);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_ERASEBKGND)]
-    [InlineData((int)PInvoke.WM_PRINTCLIENT)]
-    public void GroupBox_WndProc_InvokeEraseBkgndNotOwnerDrawWithHandle_Success(int msg)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = FlatStyle.System
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)1, m.Result);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_ERASEBKGND)]
-    [InlineData((int)PInvoke.WM_PRINTCLIENT)]
-    public void GroupBox_WndProc_InvokeEraseBkgndNotOwnerDrawZeroWParam_DoesNotThrow(int msg)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = FlatStyle.System
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat)]
-    [InlineData(FlatStyle.Popup)]
-    [InlineData(FlatStyle.Standard)]
-    public void GroupBox_WndProc_InvokeEraseBkgndOwnerDrawWithHandleWithWParam_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_ERASEBKGND,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)1, m.Result);
-            Assert.Equal(0, paintCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat)]
-    [InlineData(FlatStyle.Popup)]
-    [InlineData(FlatStyle.Standard)]
-    public void GroupBox_WndProc_InvokePrintClientOwnerDrawWithHandleWithWParam_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        IntPtr hdc = graphics.GetHdc();
-        try
-        {
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_PRINTCLIENT,
-                WParam = hdc,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)250, m.Result);
-            Assert.Equal(1, paintCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            graphics.ReleaseHdc();
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void GroupBox_WndProc_InvokeMouseHoverWithHandle_Success(FlatStyle flatStyle)
-    {
-        using var control = new SubGroupBox
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public class SubGroupBox : GroupBox
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new Size SizeFromClientSize(Size clientSize) => base.SizeFromClientSize(clientSize);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupLinkClickEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupLinkClickEventArgsTests.cs
deleted file mode 100644
index e804e289037..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/GroupLinkClickEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class GroupLinkClickEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int groupIndex)
-    {
-        var e = new ListViewGroupEventArgs(groupIndex);
-        Assert.Equal(groupIndex, e.GroupIndex);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.HScrollBarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.HScrollBarAccessibleObjectTests.cs
deleted file mode 100644
index 194eebb8ecf..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.HScrollBarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,288 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static System.Windows.Forms.ScrollBar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_HScrollBarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void HScrollBarAccessibleObject_ctor_ThrowsException_HScrollBarAccessibleObjectIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ScrollBarAccessibleObject(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ScrollBar)]
-    [InlineData(false, AccessibleRole.None)]
-    public void HScrollBarAccessibleObject_Ctor_Default(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var scrollBar = new HScrollBar();
-
-        if (createControl)
-        {
-            scrollBar.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Test")]
-    public void HScrollBarAccessibleObject_Description_Get_ReturnsExpected(string accessibleDescription)
-    {
-        using HScrollBar scrollBar = new();
-        scrollBar.AccessibleDescription = accessibleDescription;
-        ScrollBarAccessibleObject accessibleObject =
-            Assert.IsType<ScrollBarAccessibleObject>(scrollBar.AccessibilityObject);
-
-        Assert.Equal(accessibleDescription, accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Test")]
-    public void HScrollBarAccessibleObject_Name_Get_ReturnsExpected(string accessibleName)
-    {
-        using HScrollBar scrollBar = new();
-        scrollBar.AccessibleName = accessibleName;
-        ScrollBarAccessibleObject accessibleObject =
-            Assert.IsType<ScrollBarAccessibleObject>(scrollBar.AccessibilityObject);
-
-        Assert.Equal(accessibleName, accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarAccessibleObject_ControlType_IsScrollBar_AccessibleRoleIsDefault()
-    {
-        using HScrollBar scrollBar = new();
-        // AccessibleRole is not set = Default
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ScrollBarControlTypeId, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void HScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using HScrollBar scrollBar = new();
-        scrollBar.AccessibleRole = role;
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarAccessibleObject_FragmentNavigate_Child_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        var accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void HScrollBarAccessibleObject_GetChildCount_ReturnsFive_AllButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(5, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarAccessibleObject_GetChildCount_ReturnsFour_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarAccessibleObject_GetChildCount_ReturnsFour_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarAccessibleObject_GetChildCount_ReturnsThree_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(3, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarAccessibleObject_GetChildCount_ReturnsMunisOne_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void HScrollBarAccessibleObject_GetChild_ReturnExpected_AllButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.FirstPageButtonAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastPageButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarAccessibleObject_GetChild_ReturnExpected_FirstButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.LastPageButtonAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarAccessibleObject_GetChild_ReturnExpected_LastButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.FirstPageButtonAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarAccessibleObject_GetChild_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarAccessibleObject_GetChild_ReturnExpected_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void HScrollBarAccessibilityObject_GetPropertyValue_IsEnabledProperty_ReturnsExpected(bool enabled)
-    {
-        using HScrollBar scrollBar = new()
-        {
-            Enabled = enabled
-        };
-
-        Assert.Equal(enabled, scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new HScrollBar
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50)
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs
deleted file mode 100644
index 27f8404f998..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,359 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_ScrollBarFirstLineButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Description_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Name_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarFirstLineButtonAccessibleObject_Invoke_IncreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.Yes, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(51, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarFirstLineButtonAccessibleObject_Invoke_DecreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.No, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(49, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 99, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void HScrollBarFirstLineButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarLinePageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            SmallChange = 1,
-            LargeChange = 2,
-            Size = new Size(500, 50)
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarFirstLineButtonAccessibleObject GetFirstLineButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.FirstLineButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs
deleted file mode 100644
index fc8a3064552..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,397 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_ScrollBarFirstPageButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_State_ReturnNone_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsExpected_ButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        AccessibleObject thumb = scrollBarAccessibleObject.ThumbAccessibleObject;
-        AccessibleObject lineButton = scrollBarAccessibleObject.FirstLineButtonAccessibleObject;
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(thumb, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(lineButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsExpected_ButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_IncreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.Yes, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(54, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_DecreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.No, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(46, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 99, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void HScrollBarFirstPageButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            LargeChange = 2,
-            SmallChange = 1
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarFirstPageButtonAccessibleObject GetFirstPageButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.FirstPageButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs
deleted file mode 100644
index e360a02f51c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,369 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_ScrollBarLastLineButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Role_ReturnPushButton_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleRole.PushButton, accessibleObject.Role);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Role_ReturnNone_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_LastPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarLastLineButtonAccessibleObject_Invoke_DecreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.Yes, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(49, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarLastLineButtonAccessibleObject_Invoke_IncreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.No, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(51, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 99, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void HScrollBarLastLineButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarLinePageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastLineButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(500, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarLastLineButtonAccessibleObject GetLastLineButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.LastLineButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs
deleted file mode 100644
index 92324c02e12..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,384 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_ScrollBarLastPageButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_State_ReturnNone_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnExpected_LastPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnExpected_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_DecreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.Yes, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(46, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_IncreaseValue()
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, RightToLeft.No, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(54, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 99, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void HScrollBarLastPageButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarLastPageButtonAccessibleObject GetLastPageButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.LastPageButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarThumbAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarThumbAccessibleObjectTests.cs
deleted file mode 100644
index f1b7c2b401c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBar.ScrollBarThumbAccessibleObjectTests.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBar_ScrollBarThumbAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_DefaultAction_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(string.Empty, accessibleObject.DefaultAction);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Role_ReturnIndicator_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleRole.Indicator, accessibleObject.Role);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_Role_ReturnNone_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False(accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void HScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_BothPageButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void HScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.HScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void HScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void HScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void HScrollBarThumbAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void HScrollBarThumbAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using HScrollBar scrollBar = GetHScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private HScrollBar GetHScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        HScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarThumbAccessibleObject GetThumb(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.ThumbAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBarTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBarTests.cs
deleted file mode 100644
index e40c060a186..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollBarTests.cs
+++ /dev/null
@@ -1,304 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollBarTests
-{
-    [WinFormsFact]
-    public void HScrollBar_Ctor_Default()
-    {
-        using var control = new SubHScrollBar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bounds.X);
-        Assert.Equal(0, control.Bounds.Y);
-        Assert.True(control.Bounds.Width > 0);
-        Assert.True(control.Bounds.Height > 0);
-        Assert.True(control.Bottom > 0);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(0, control.ClientRectangle.X);
-        Assert.Equal(0, control.ClientRectangle.Y);
-        Assert.True(control.ClientRectangle.Width > 0);
-        Assert.True(control.ClientRectangle.Height > 0);
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height > 0);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, control.DefaultImeMode);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.True(control.DefaultSize.Width > 0);
-        Assert.True(control.DefaultSize.Height > 0);
-        Assert.False(control.DesignMode);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height > 0);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.True(control.Height > 0);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(10, control.LargeChange);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.True(control.Right > 0);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ScaleScrollBarForDpiChange);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.True(control.Size.Width > 0);
-        Assert.True(control.Size.Height > 0);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.Visible);
-        Assert.True(control.Width > 0);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubHScrollBar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ScrollBar", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.True(createParams.Height > 0);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.True(createParams.Width > 0);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void HScrollBar_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new HScrollBar
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HScrollBar_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new HScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void HScrollBar_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new HScrollBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsFact]
-    public void HScrollBar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubHScrollBar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void HScrollBar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubHScrollBar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void HScrollBar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubHScrollBar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    private class SubHScrollBar : HScrollBar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollPropertiesTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollPropertiesTests.cs
deleted file mode 100644
index 30cdf3c9e5a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HScrollPropertiesTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class HScrollPropertiesTests
-{
-    public static IEnumerable<object[]> Ctor_ScrollableControl_TestData()
-    {
-        yield return new object[] { new ScrollableControl() };
-        yield return new object[] { null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ScrollableControl_TestData))]
-    public void HScrollProperties_Ctor_Control(ScrollableControl container)
-    {
-        var properties = new SubHScrollProperties(container);
-        Assert.Equal(container, properties.ParentControlEntry);
-        Assert.True(properties.Enabled);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.False(properties.Visible);
-    }
-
-    private class SubHScrollProperties : HScrollProperties
-    {
-        public SubHScrollProperties(ScrollableControl container) : base(container)
-        {
-        }
-
-        public ScrollableControl ParentControlEntry => ParentControl;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HandledMouseEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HandledMouseEventArgsTests.cs
deleted file mode 100644
index b9b59994c0c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HandledMouseEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class HandledMouseEventArgsTests
-{
-    [Theory]
-    [InlineData(MouseButtons.Left, 1, 2, 3, 4)]
-    [InlineData((MouseButtons)1, 0, 0, 0, 0)]
-    [InlineData((MouseButtons)3, -1, -1, -1, -2)]
-    public void Ctor_MouseButtons_Int_Int_Int_Int(MouseButtons button, int clicks, int x, int y, int delta)
-    {
-        var e = new HandledMouseEventArgs(button, clicks, x, y, delta);
-        Assert.Equal(button, e.Button);
-        Assert.Equal(clicks, e.Clicks);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(delta, e.Delta);
-        Assert.Equal(new Point(x, y), e.Location);
-        Assert.False(e.Handled);
-    }
-
-    [Theory]
-    [InlineData(MouseButtons.Left, 1, 2, 3, 4, true)]
-    [InlineData((MouseButtons)1, 0, 0, 0, 0, true)]
-    [InlineData((MouseButtons)3, -1, -1, -1, -2, false)]
-    public void Ctor_MouseButtons_Int_Int_Int_Int_Bool(MouseButtons button, int clicks, int x, int y, int delta, bool handled)
-    {
-        var e = new HandledMouseEventArgs(button, clicks, x, y, delta, handled);
-        Assert.Equal(button, e.Button);
-        Assert.Equal(clicks, e.Clicks);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(delta, e.Delta);
-        Assert.Equal(new Point(x, y), e.Location);
-        Assert.Equal(handled, e.Handled);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpEventArgsTests.cs
deleted file mode 100644
index 3e27d23884b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpEventArgsTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class HelpEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Point_TestData()
-    {
-        yield return new object[] { Point.Empty };
-        yield return new object[] { new Point(1, 2) };
-        yield return new object[] { new Point(-1, -2) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Point_TestData))]
-    public void Ctor_Point(Point mousePos)
-    {
-        var e = new HelpEventArgs(mousePos);
-        Assert.Equal(mousePos, e.MousePos);
-        Assert.False(e.Handled);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Handled_Set_GetReturnsExpected(bool value)
-    {
-        var e = new HelpEventArgs(new Point(1, 2))
-        {
-            Handled = value
-        };
-        Assert.Equal(value, e.Handled);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpProviderTests.cs
deleted file mode 100644
index 21e8c08aba1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HelpProviderTests.cs
+++ /dev/null
@@ -1,575 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class HelpProviderTests
-{
-    [WinFormsFact]
-    public void HelpProvider_Ctor_Default()
-    {
-        using var provider = new SubHelpProvider();
-        Assert.True(provider.CanRaiseEvents);
-        Assert.Null(provider.Container);
-        Assert.False(provider.DesignMode);
-        Assert.NotNull(provider.Events);
-        Assert.Same(provider.Events, provider.Events);
-        Assert.Null(provider.HelpNamespace);
-        Assert.Null(provider.Site);
-        Assert.Null(provider.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_HelpNamespace_Set_GetReturnsExpected(string value)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = value
-        };
-        Assert.Equal(value, provider.HelpNamespace);
-
-        // Set same.
-        provider.HelpNamespace = value;
-        Assert.Equal(value, provider.HelpNamespace);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_HelpNamespace_SetWithBoundControls_GetReturnsExpected(string value)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = value
-        };
-        Assert.Equal(value, provider.HelpNamespace);
-
-        using var control = new Control();
-        provider.SetShowHelp(control, true);
-        Assert.Equal(0, control.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal(value, fileName);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_Tag_Set_GetReturnsExpected(string value)
-    {
-        using var provider = new HelpProvider
-        {
-            Tag = value
-        };
-        Assert.Same(value, provider.Tag);
-
-        // Set same.
-        provider.Tag = value;
-        Assert.Same(value, provider.Tag);
-    }
-
-    public static IEnumerable<object[]> CanExtend_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { new object(), false };
-        yield return new object[] { new Control(), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanExtend_TestData))]
-    public void HelpProvider_CanExtend_Invoke_ReturnsExpected(object target, bool expected)
-    {
-        using var provider = new HelpProvider();
-        Assert.Equal(expected, provider.CanExtend(target));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpKeyword_NoSuchControl_ReturnsNull()
-    {
-        using var provider = new HelpProvider();
-        Assert.Null(provider.GetHelpKeyword(new Control()));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpKeyword_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.GetHelpKeyword(null));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpNavigator_NoSuchControl_ReturnsAssociateIndex()
-    {
-        using var provider = new HelpProvider();
-        Assert.Equal(HelpNavigator.AssociateIndex, provider.GetHelpNavigator(new Control()));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpNavigator_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.GetHelpNavigator(null));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpString_NoSuchControl_ReturnsNull()
-    {
-        using var provider = new HelpProvider();
-        Assert.Null(provider.GetHelpString(new Control()));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetHelpString_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.GetHelpString(null));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetShowHelp_NoSuchControl_ReturnsFalse()
-    {
-        using var provider = new HelpProvider();
-        Assert.False(provider.GetShowHelp(new Control()));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_GetShowHelp_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.GetShowHelp(null));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HelpProvider_ResetShowHelp_WithShowHelp_Success(bool showHelp)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, showHelp);
-        provider.ResetShowHelp(control);
-        Assert.False(provider.GetShowHelp(control));
-        Assert.False(provider.ShouldSerializeShowHelp(control));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_ResetShowHelp_NoSuchControl_Success()
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.ResetShowHelp(control);
-        Assert.False(provider.GetShowHelp(control));
-        Assert.False(provider.ShouldSerializeShowHelp(control));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_ResetShowHelp_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.ResetShowHelp(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0, null, true)]
-    [InlineData("", 0, null, true)]
-    [InlineData("helpKeyword", 0, "HelpNamespace", true)]
-    [InlineData("1", 1, "HelpNamespace", true)]
-    [InlineData(null, -1, null, false)]
-    [InlineData("", -1, null, false)]
-    [InlineData("helpKeyword", 0, "HelpNamespace", false)]
-    [InlineData("1", 1, "HelpNamespace", false)]
-    public void HelpProvider_SetHelpKeyword_GetHelpKeyword_ReturnsExpected(string keyword, int expectedHelpTopic, string expectedFileName, bool createControl)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = "HelpNamespace"
-        };
-
-        using var control = new Control();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.Equal(!string.IsNullOrEmpty(keyword), provider.GetShowHelp(control));
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.Equal(expectedFileName, fileName);
-
-        // Set same.
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.Equal(!string.IsNullOrEmpty(keyword), provider.GetShowHelp(control));
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out fileName));
-        Assert.Equal(expectedFileName, fileName);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("helpKeyword", 0)]
-    [InlineData("1", 1)]
-    public void HelpProvider_SetHelpKeyword_WithShowHelpTrue_ReturnsExpected(string keyword, int expectedHelpTopic)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = "HelpNamespace"
-        };
-        using var control = new Control();
-        provider.SetShowHelp(control, true);
-
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.True(provider.GetShowHelp(control));
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal("HelpNamespace", fileName);
-
-        // Set same.
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.True(provider.GetShowHelp(control));
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out fileName));
-        Assert.Equal("HelpNamespace", fileName);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0, null, true)]
-    [InlineData("", 0, null, true)]
-    [InlineData("helpKeyword", 0, "HelpNamespace", true)]
-    [InlineData("1", 1, "HelpNamespace", true)]
-    [InlineData(null, -1, null, false)]
-    [InlineData("", -1, null, false)]
-    [InlineData("helpKeyword", 0, "HelpNamespace", false)]
-    [InlineData("1", 1, "HelpNamespace", false)]
-    public void HelpProvider_SetHelpKeyword_WithShowHelpFalse_ReturnsExpected(string keyword, int expectedHelpTopic, string expectedFileName, bool createControl)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = "HelpNamespace"
-        };
-        using var control = new Control();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        provider.SetShowHelp(control, false);
-
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.Equal(!string.IsNullOrEmpty(keyword), provider.GetShowHelp(control));
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.Equal(expectedFileName, fileName);
-
-        // Set same.
-        provider.SetHelpKeyword(control, keyword);
-        Assert.Same(keyword, provider.GetHelpKeyword(control));
-        Assert.Equal(!string.IsNullOrEmpty(keyword), provider.GetShowHelp(control));
-        Assert.Equal(expectedFileName, fileName);
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_SetHelpKeyword_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.SetHelpKeyword(null, "keyword"));
-    }
-
-    [WinFormsTheory]
-    [EnumData<HelpNavigator>]
-    public void HelpProvider_SetHelpNavigator_GetHelpNavigator_ReturnsExpected(HelpNavigator navigator)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-
-        // Set same.
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-    }
-
-    [WinFormsTheory]
-    [EnumData<HelpNavigator>]
-    public void HelpProvider_SetHelpNavigator_WithShowHelpTrue_ReturnsExpected(HelpNavigator navigator)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, true);
-
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-
-        // Set same.
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-    }
-
-    [WinFormsTheory]
-    [EnumData<HelpNavigator>]
-    public void HelpProvider_SetHelpNavigator_WithShowHelpFalse_ReturnsExpected(HelpNavigator navigator)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, false);
-
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-
-        // Set same.
-        provider.SetHelpNavigator(control, navigator);
-        Assert.Equal(navigator, provider.GetHelpNavigator(control));
-        Assert.True(provider.GetShowHelp(control));
-    }
-
-    [WinFormsTheory]
-    [EnumData<HelpNavigator>]
-    [InvalidEnumData<HelpNavigator>]
-    public void HelpProvider_SetHelpNavigator_NullCtl_ThrowsArgumentNullException(HelpNavigator navigator)
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.SetHelpNavigator(null, navigator));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HelpNavigator>]
-    public void HelpProvider_SetHelpNavigator_InvalidNavigator_ThrowsInvalidEnumArgumentException(HelpNavigator navigator)
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<InvalidEnumArgumentException>("navigator", () => provider.SetHelpNavigator(new Control(), navigator));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_SetHelpString_GetHelpString_ReturnsExpected(string helpString)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.Equal(!string.IsNullOrEmpty(helpString), provider.GetShowHelp(control));
-        Assert.Equal(string.IsNullOrEmpty(helpString) ? null : helpString, control.AccessibilityObject.Help);
-
-        // Set same.
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.Equal(!string.IsNullOrEmpty(helpString), provider.GetShowHelp(control));
-        Assert.Equal(string.IsNullOrEmpty(helpString) ? null : helpString, control.AccessibilityObject.Help);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_SetHelpString_WithShowHelpTrue_ReturnsExpected(string helpString)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, true);
-
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.True(provider.GetShowHelp(control));
-        Assert.Equal(helpString, control.AccessibilityObject.Help);
-
-        // Set same.
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.True(provider.GetShowHelp(control));
-        Assert.Equal(helpString, control.AccessibilityObject.Help);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void HelpProvider_SetHelpString_WithShowHelpFalse_ReturnsExpected(string helpString)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, false);
-
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.Equal(!string.IsNullOrEmpty(helpString), provider.GetShowHelp(control));
-        Assert.Equal(string.IsNullOrEmpty(helpString) ? null : helpString, control.AccessibilityObject.Help);
-
-        // Set same.
-        provider.SetHelpString(control, helpString);
-        Assert.Same(helpString, provider.GetHelpString(control));
-        Assert.Equal(!string.IsNullOrEmpty(helpString), provider.GetShowHelp(control));
-        Assert.Equal(string.IsNullOrEmpty(helpString) ? null : helpString, control.AccessibilityObject.Help);
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_SetHelpString_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.SetHelpString(null, "keyword"));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HelpProvider_SetShowHelp_GetShowHelp_ReturnsExpected(bool value)
-    {
-        using var provider = new HelpProvider();
-        using var control = new Control();
-        provider.SetShowHelp(control, value);
-
-        Assert.Equal(value, provider.GetShowHelp(control));
-        Assert.True(provider.ShouldSerializeShowHelp(control));
-
-        // Set same.
-        provider.SetShowHelp(control, value);
-        Assert.Equal(value, provider.GetShowHelp(control));
-        Assert.True(provider.ShouldSerializeShowHelp(control));
-
-        // Set opposite.
-        provider.SetShowHelp(control, !value);
-        Assert.Equal(!value, provider.GetShowHelp(control));
-        Assert.True(provider.ShouldSerializeShowHelp(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, -1)]
-    public void HelpProvider_SetShowHelp_SetFalseThenTrue_UnbindsAndBindsControl(bool createControl, int expectedHelpTopic)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = "HelpNamespace"
-        };
-        using var control = new Control();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        provider.SetShowHelp(control, true);
-        provider.SetHelpKeyword(control, "1");
-        provider.SetHelpString(control, "HelpString");
-
-        Assert.Equal(1, control.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.Equal("HelpNamespace", fileName);
-        Assert.Equal("HelpString", control.AccessibilityObject.Help);
-
-        // Set false.
-        provider.SetShowHelp(control, false);
-        Assert.Equal(expectedHelpTopic, control.AccessibilityObject.GetHelpTopic(out fileName));
-        Assert.Null(fileName);
-        Assert.Null(control.AccessibilityObject.Help);
-
-        // Set true.
-        provider.SetShowHelp(control, true);
-        Assert.Equal(1, control.AccessibilityObject.GetHelpTopic(out fileName));
-        Assert.Equal("HelpNamespace", fileName);
-        Assert.Equal("HelpString", control.AccessibilityObject.Help);
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_SetShowHelp_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.SetShowHelp(null, true));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_ShouldSerializeShowHelp_NoSuchControl_ReturnsFalse()
-    {
-        using var provider = new HelpProvider();
-        Assert.False(provider.ShouldSerializeShowHelp(new Control()));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_ShouldSerializeShowHelp_NullCtl_ThrowsArgumentNullException()
-    {
-        using var provider = new HelpProvider();
-        Assert.Throws<ArgumentNullException>("ctl", () => provider.ShouldSerializeShowHelp(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "System.Windows.Forms.HelpProvider, HelpNamespace: ")]
-    [InlineData("", "System.Windows.Forms.HelpProvider, HelpNamespace: ")]
-    [InlineData("helpNamespace", "System.Windows.Forms.HelpProvider, HelpNamespace: helpNamespace")]
-    public void HelpProvider_ToString_Invoke_ReturnsExpected(string helpNamespace, string expected)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = helpNamespace
-        };
-        Assert.Equal(expected, provider.ToString());
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_BoundControl_ValidEventArgs_Nop()
-    {
-        using var provider = new HelpProvider();
-        using var control = new SubControl();
-        provider.SetShowHelp(control, true);
-
-        control.OnHelpRequested(new HelpEventArgs(new Point(1, 2)));
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_BoundControl_NoInformation_Nop()
-    {
-        using var provider = new HelpProvider();
-        using var control = new SubControl();
-        provider.SetShowHelp(control, true);
-
-        var e = new HelpEventArgs(new Point(1, 2));
-        control.OnHelpRequested(e);
-        Assert.True(e.Handled);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("InvalidUri")]
-    [InlineData("file://")]
-    [InlineData("file://C:/NoSuchFile")]
-    public void HelpProvider_BoundControl_InvalidNamespace_ThrowsArgumentException(string helpNamespace)
-    {
-        using var provider = new HelpProvider
-        {
-            HelpNamespace = helpNamespace
-        };
-        using var control = new SubControl();
-        provider.SetShowHelp(control, true);
-
-        var e = new HelpEventArgs(new Point(1, 2));
-        Assert.Throws<ArgumentException>("url", () => control.OnHelpRequested(e));
-        Assert.False(e.Handled);
-    }
-
-    [WinFormsFact]
-    public void HelpProvider_BoundControl_NullEventEventArgs_Nop()
-    {
-        using var provider = new HelpProvider();
-        using var control = new SubControl();
-        provider.SetShowHelp(control, true);
-
-        control.OnHelpRequested(null);
-    }
-
-    private class SubHelpProvider : HelpProvider
-    {
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-        public new bool DesignMode => base.DesignMode;
-        public new EventHandlerList Events => base.Events;
-    }
-
-    private class SubControl : Control
-    {
-        public new void OnHelpRequested(HelpEventArgs e) => base.OnHelpRequested(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlDocumentTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlDocumentTests.cs
deleted file mode 100644
index 4a49b671bea..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlDocumentTests.cs
+++ /dev/null
@@ -1,2164 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Text;
-using static Interop.Mshtml;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads
-public class HtmlDocumentTests
-{
-    [WinFormsFact]
-    public async Task HtmlDocument_ActiveLinkColor_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(Color.FromArgb(0xFF, 0x00, 0x00, 0xFF), document.ActiveLinkColor);
-    }
-
-    public static IEnumerable<object[]> ActiveLinkColor_GetCustomValueOnBody_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x11, 0x30, 0x60) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x30, 0x41, 0x89) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ActiveLinkColor_GetCustomValueOnBody_TestData))]
-    public async Task HtmlDocument_ActiveLinkColor_GetCustomValueOnBody_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body alink={value}></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.ActiveLinkColor);
-    }
-
-    public static IEnumerable<object[]> ActiveLinkColor_GetCustomValueSet_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ActiveLinkColor_GetCustomValueSet_TestData))]
-    public async Task HtmlDocument_ActiveLinkColor_GetCustomValueSet_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetAlinkColor(value);
-        Assert.Equal(expected, document.ActiveLinkColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public async Task HtmlDocument_ActiveLinkColor_Set_GetReturnsExpected(Color value, Color expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.ActiveLinkColor = value;
-        Assert.Equal(expected, document.ActiveLinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetAlinkColor());
-
-        // Set same.
-        document.ActiveLinkColor = value;
-        Assert.Equal(expected, document.ActiveLinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetAlinkColor());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_All_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.All;
-        Assert.NotSame(collection, document.All);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal("HTML", collection[0].TagName);
-        Assert.Equal("HEAD", collection[1].TagName);
-        Assert.Equal("TITLE", collection[2].TagName);
-        Assert.Equal("BODY", collection[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_All_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.All;
-        Assert.NotSame(collection, document.All);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal("HTML", collection[0].TagName);
-        Assert.Equal("HEAD", collection[1].TagName);
-        Assert.Equal("TITLE", collection[2].TagName);
-        Assert.Equal("BODY", collection[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_ActiveElement_GetNotActiveWithBody_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.ActiveElement;
-        Assert.NotSame(element, document.ActiveElement);
-        Assert.Equal("InnerText", element.InnerText);
-        Assert.Equal("BODY", element.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_ActiveElement_GetNotActiveWithoutBody_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.ActiveElement;
-        Assert.NotSame(element, document.ActiveElement);
-        Assert.Null(element.InnerText);
-        Assert.Equal("BODY", document.ActiveElement.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_ActiveElement_GetNoActiveElement_ReturnsNull()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><h1>Title</h1><p id=\"target\">InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement target = document.GetElementById("target");
-
-        HtmlElement active = document.ActiveElement;
-        IHTMLElement2 iHtmlElement2 = (IHTMLElement2)active.DomElement;
-        iHtmlElement2.Blur();
-
-        HtmlElement element = document.ActiveElement;
-        Assert.Null(document.ActiveElement);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_BackColor_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), document.BackColor);
-    }
-
-    public static IEnumerable<object[]> BackColor_GetCustomValueOnBody_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x11, 0x30, 0x60) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x30, 0x41, 0x89) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_GetCustomValueOnBody_TestData))]
-    public async Task HtmlDocument_BackColor_GetCustomValueOnBody_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body bgcolor={value}></body></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.BackColor);
-    }
-
-    public static IEnumerable<object[]> BackColor_GetCustomValueSet_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_GetCustomValueSet_TestData))]
-    public async Task HtmlDocument_BackColor_GetCustomValueSet_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetBgColor(value);
-        Assert.Equal(expected, document.BackColor);
-    }
-
-    public static IEnumerable<object[]> Color_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.FromArgb(0xFF, 0x00, 0x00, 0x00), "#000000" };
-        yield return new object[] { Color.Red, Color.FromArgb(0xFF, 0xFF, 0x00, 0x00), "#ff0000" };
-        yield return new object[] { Color.White, Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), "#ffffff" };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78), "#345678" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public async Task HtmlDocument_BackColor_Set_GetReturnsExpected(Color value, Color expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.BackColor = value;
-        Assert.Equal(expected, document.BackColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetBgColor());
-
-        // Set same.
-        document.BackColor = value;
-        Assert.Equal(expected, document.BackColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetBgColor());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Body_GetWithBody_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.NotSame(element, document.Body);
-        Assert.Equal("InnerText", element.InnerText);
-        Assert.Equal("BODY", element.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Body_GetWithoutBody_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.NotSame(element, document.Body);
-        Assert.Null(element.InnerText);
-        Assert.Equal("BODY", element.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Body_GetNoBody_ReturnsNull()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        IHTMLDOMNode iHtmlDomNode = (IHTMLDOMNode)element.Parent.DomElement;
-        iHtmlDomNode.RemoveChild((IHTMLDOMNode)element.DomElement);
-
-        Assert.Null(document.Body);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Cookie_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(document.Cookie, document.Cookie);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("cookie", "cookie")]
-    public async Task HtmlDocument_Cookie_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        // Cleanup!
-        // WebBrowser is notorious for not cleaning after itself - clean all cookies before we set new ones
-        document.ExecCommand("ClearAuthenticationCache", false, null);
-
-        document.Cookie = value;
-        Assert.Equal(expected, document.Cookie);
-        Assert.Equal(expected, iHTMLDocument2.GetCookie());
-
-        // Set same.
-        document.Cookie = value;
-        Assert.Equal(expected, document.Cookie);
-        Assert.Equal(expected, iHTMLDocument2.GetCookie());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DefaultEncoding_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.NotEmpty(document.DefaultEncoding);
-        Assert.DoesNotContain('\0', document.DefaultEncoding);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DefaultEncoding_GetWithCustomValueOnMeta_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><meta charset=\"UTF-8\" /></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.NotEmpty(document.DefaultEncoding);
-        Assert.DoesNotContain('\0', document.DefaultEncoding);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DefaultEncoding_GetCustomValueSet_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetDefaultCharset("UTF-8");
-        Assert.NotEmpty(document.DefaultEncoding);
-        Assert.DoesNotContain('\0', document.DefaultEncoding);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Domain_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Empty(document.Domain);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public async Task HtmlDocument_Domain_Set_ThrowsCOMException(string value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        Assert.Throws<COMException>(() => document.Domain = value);
-        Assert.Empty(document.Domain);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DomDocument_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        object domDocument = document.DomDocument;
-        Assert.Same(domDocument, document.DomDocument);
-        Assert.True(domDocument.GetType().IsCOMObject);
-        Assert.False(domDocument is IHTMLDOMNode);
-        Assert.True(domDocument is IHTMLDocument);
-        Assert.True(domDocument is IHTMLDocument2);
-        Assert.True(domDocument is IHTMLDocument3);
-        Assert.True(domDocument is IHTMLDocument4);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Encoding_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.NotEmpty(document.Encoding);
-        Assert.DoesNotContain('\0', document.Encoding);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Encoding_GetWithCustomValueOnMeta_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><meta charset=\"UTF-8\" /></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal("utf-8", document.Encoding);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Encoding_GetCustomValueSet_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetCharset("UTF-8");
-        Assert.Equal("utf-8", document.Encoding);
-    }
-
-    [WinFormsTheory]
-    [InlineData("utf-8", "utf-8")]
-    [InlineData("UTF-8", "utf-8")]
-    public async Task HtmlDocument_Encoding_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.Encoding = value;
-        Assert.Equal(expected, document.Encoding);
-        Assert.Equal(expected, iHTMLDocument2.GetCharset());
-
-        // Set same.
-        document.Encoding = value;
-        Assert.Equal(expected, document.Encoding);
-        Assert.Equal(expected, iHTMLDocument2.GetCharset());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("reasonable")]
-    public async Task HtmlDocument_Charset_SetInvalid_ThrowsArgumentException(string value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Throws<ArgumentException>(() => document.Encoding = value);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Focused_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.False(document.Focused);
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/4906")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/4906")]
-    public async Task HtmlDocument_Focused_GetFocused_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-        iHTMLDocument4.Focus();
-        Assert.False(document.Focused);
-
-        // Have to do it again.
-        iHTMLDocument4.Focus();
-        Assert.True(document.Focused);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_ForeColor_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(Color.FromArgb(0xFF, 0x00, 0x00, 0x00), document.ForeColor);
-    }
-
-    public static IEnumerable<object[]> ForeColor_GetCustomValueOnBody_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x11, 0x30, 0x60) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x30, 0x41, 0x89) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_GetCustomValueOnBody_TestData))]
-    public async Task HtmlDocument_ForeColor_GetCustomValueOnBody_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body text={value}></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.ForeColor);
-    }
-
-    public static IEnumerable<object[]> ForeColor_GetCustomValueSet_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_GetCustomValueSet_TestData))]
-    public async Task HtmlDocument_ForeColor_GetCustomValueSet_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetFgColor(value);
-        Assert.Equal(expected, document.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public async Task HtmlDocument_ForeColor_Set_GetReturnsExpected(Color value, Color expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.ForeColor = value;
-        Assert.Equal(expected, document.ForeColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetFgColor());
-
-        // Set same.
-        document.ForeColor = value;
-        Assert.Equal(expected, document.ForeColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetFgColor());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Forms_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"img1\" /><img id=\"img2\" /><a id=\"link1\">Href</a><a id=\"link2\">Href</a><form id=\"form1\"></form><form id=\"form2\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Forms;
-        Assert.NotSame(collection, document.Forms);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("FORM", collection[0].TagName);
-        Assert.Equal("form1", collection[0].GetAttribute("id"));
-        Assert.Equal("FORM", collection[1].TagName);
-        Assert.Equal("form2", collection[1].GetAttribute("id"));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Forms_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Forms;
-        Assert.NotSame(collection, document.Forms);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Images_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"img1\" /><img id=\"img2\" /><a id=\"link1\">Href</a><a id=\"link2\">Href</a><form id=\"form1\"></form><form id=\"form2\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Images;
-        Assert.NotSame(collection, document.Images);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("IMG", collection[0].TagName);
-        Assert.Equal("img1", collection[0].GetAttribute("id"));
-        Assert.Equal("IMG", collection[1].TagName);
-        Assert.Equal("img2", collection[1].GetAttribute("id"));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Images_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Images;
-        Assert.NotSame(collection, document.Images);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_LinkColor_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(Color.FromArgb(0xFF, 0x00, 0x00, 0xFF), document.LinkColor);
-    }
-
-    public static IEnumerable<object[]> LinkColor_GetCustomValueOnBody_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x11, 0x30, 0x60) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x30, 0x41, 0x89) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LinkColor_GetCustomValueOnBody_TestData))]
-    public async Task HtmlDocument_LinkColor_GetCustomValueOnBody_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body link={value}></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.LinkColor);
-    }
-
-    public static IEnumerable<object[]> LinkColor_GetCustomValueSet_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x00, 0x00, 0xFF) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LinkColor_GetCustomValueSet_TestData))]
-    public async Task HtmlDocument_LinkColor_GetCustomValueSet_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetLinkColor(value);
-        Assert.Equal(expected, document.LinkColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public async Task HtmlDocument_LinkColor_Set_GetReturnsExpected(Color value, Color expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.LinkColor = value;
-        Assert.Equal(expected, document.LinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetLinkColor());
-
-        // Set same.
-        document.LinkColor = value;
-        Assert.Equal(expected, document.LinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetLinkColor());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Links_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"img1\" /><img id=\"img2\" /><a href=\"#1\" id=\"link1\">Href</a><a href=\"#1\" id=\"link2\">Href</a><form id=\"form1\"></form><form id=\"form2\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Links;
-        Assert.NotSame(collection, document.Links);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("A", collection[0].TagName);
-        Assert.Equal("link1", collection[0].GetAttribute("id"));
-        Assert.Equal("A", collection[1].TagName);
-        Assert.Equal("link2", collection[1].GetAttribute("id"));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Links_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElementCollection collection = document.Links;
-        Assert.NotSame(collection, document.Links);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_RightToLeft_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.False(document.RightToLeft);
-    }
-
-    public static IEnumerable<object[]> RightToLeft_CustomValueOnHtml_TestData()
-    {
-        yield return new object[] { "rtl", true };
-        yield return new object[] { "RTL", true };
-        yield return new object[] { "ltr", false };
-        yield return new object[] { "abc", false };
-        yield return new object[] { "", false };
-        yield return new object[] { "123", false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_CustomValueOnHtml_TestData))]
-    public async Task HtmlDocument_RightToLeft_GetCustomValueOnHtml_ReturnsExpected(string rtl, bool expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html dir={rtl}></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.RightToLeft);
-    }
-
-    public static IEnumerable<object[]> RightToLeft_CustomValueSet_TestData()
-    {
-        yield return new object[] { "rtl", true };
-        yield return new object[] { "RTL", true };
-        yield return new object[] { "ltr", false };
-        yield return new object[] { "", false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_CustomValueSet_TestData))]
-    public async Task HtmlDocument_RightToLeft_GetCustomValueSet_ReturnsExpected(string rtl, bool expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html></html>";
-        HtmlDocument document = await GetDocument(control, html);
-
-        IHTMLDocument3 iHTMLDocument3 = (IHTMLDocument3)document.DomDocument;
-        iHTMLDocument3.SetDir(rtl);
-        Assert.Equal(expected, document.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "rtl", "ltr")]
-    [InlineData(false, "ltr", "rtl")]
-    public async Task HtmlDocument_RightToLeft_Set_GetReturnsExpected(bool value, string expectedNative1, string expectedNative2)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument3 iHTMLDocument3 = (IHTMLDocument3)document.DomDocument;
-
-        document.RightToLeft = value;
-        Assert.Equal(value, document.RightToLeft);
-        Assert.Equal(expectedNative1, iHTMLDocument3.GetDir());
-
-        // Set same.
-        document.RightToLeft = value;
-        Assert.Equal(value, document.RightToLeft);
-        Assert.Equal(expectedNative1, iHTMLDocument3.GetDir());
-
-        // Set different.
-        document.RightToLeft = !value;
-        Assert.Equal(!value, document.RightToLeft);
-        Assert.Equal(expectedNative2, iHTMLDocument3.GetDir());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Title_GetWithTitle_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal("Title", document.Title);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Title_GetNoTitle_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Empty(document.Title);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public async Task HtmlDocument_Title_GetCustomValueSet_ReturnsExpected(string title, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetTitle(title);
-        Assert.Equal(expected, document.Title);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public async Task HtmlDocument_Title_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.Title = value;
-        Assert.Equal(expected, document.Title);
-        Assert.Equal(expected, iHTMLDocument2.GetTitle());
-
-        // Set same.
-        document.Title = value;
-        Assert.Equal(expected, document.Title);
-        Assert.Equal(expected, iHTMLDocument2.GetTitle());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Url_GetDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        HtmlDocument document = control.Document;
-        Assert.Equal(new Uri(file.Path), document.Url);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_VisitedLinkColor_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Equal(Color.FromArgb(0xFF, 0x80, 0x00, 0x80), document.VisitedLinkColor);
-    }
-
-    public static IEnumerable<object[]> VisitedLinkColor_GetCustomValueOnBody_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x80, 0x00, 0x80) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x80, 0x00, 0x80) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x11, 0x30, 0x60) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x30, 0x41, 0x89) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(VisitedLinkColor_GetCustomValueOnBody_TestData))]
-    public async Task HtmlDocument_VisitedLinkColor_GetCustomValueOnBody_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body vlink={value}></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        Assert.Equal(expected, document.VisitedLinkColor);
-    }
-
-    public static IEnumerable<object[]> VisitedLinkColor_GetCustomValueSet_TestData()
-    {
-        yield return new object[] { null, Color.FromArgb(0xFF, 0x80, 0x00, 0x80) };
-        yield return new object[] { "", Color.FromArgb(0xFF, 0x80, 0x00, 0x80) };
-        yield return new object[] { "NoSuchName", Color.FromArgb(0xFF, 0x00, 0xC0, 0x0E) };
-        yield return new object[] { "Invalid", Color.FromArgb(0xFF, 0x00, 0xA0, 0xD0) };
-        yield return new object[] { "Red", Color.FromArgb(0xFF, 0xFF, 0x00, 0x00) };
-        yield return new object[] { (int)0x123456, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { (int)0x12345678, Color.FromArgb(0xFF, 0x80, 0x00, 0x80) };
-        yield return new object[] { "#", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-        yield return new object[] { "#1", Color.FromArgb(0xFF, 0x1, 0x00, 0x00) };
-        yield return new object[] { "#123456", Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { "#12345678", Color.FromArgb(0xFF, 0x12, 0x45, 0x78) };
-        yield return new object[] { "abc#123456", Color.FromArgb(0xFF, 0xAB, 0x12, 0x56) };
-        yield return new object[] { "#G", Color.FromArgb(0xFF, 0x00, 0x00, 0x00) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(VisitedLinkColor_GetCustomValueSet_TestData))]
-    public async Task HtmlDocument_VisitedLinkColor_GetCustomValueSet_ReturnsExpected(object value, Color expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>Title</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-        iHTMLDocument2.SetVlinkColor(value);
-        Assert.Equal(expected, document.VisitedLinkColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Color_Set_TestData))]
-    public async Task HtmlDocument_VisitedLinkColor_Set_GetReturnsExpected(Color value, Color expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument2 iHTMLDocument2 = (IHTMLDocument2)document.DomDocument;
-
-        document.VisitedLinkColor = value;
-        Assert.Equal(expected, document.VisitedLinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetVlinkColor());
-
-        // Set same.
-        document.VisitedLinkColor = value;
-        Assert.Equal(expected, document.VisitedLinkColor);
-        Assert.Equal(expectedNative, iHTMLDocument2.GetVlinkColor());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Window_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlWindow window = document.Window;
-        Assert.NotSame(window, document.Window);
-        Assert.NotSame(document, window.Document);
-        Assert.Equal("InnerText", window.Document.Body.InnerText);
-    }
-
-    [WinFormsTheory]
-    [InlineData("eventName")]
-    [InlineData("onclick")]
-    public async Task HtmlDocument_AttachEventHandler_AttachDetach_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        document.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        // Attach again.
-        document.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("onclick")]
-    [InlineData("oncontextmenu")]
-    [InlineData("onfocusin")]
-    [InlineData("onfocusout")]
-    [InlineData("onmousemove")]
-    [InlineData("onmousedown")]
-    [InlineData("onmouseout")]
-    [InlineData("onmouseover")]
-    [InlineData("onmouseup")]
-    [InlineData("onstop")]
-    [InlineData("onhelp")]
-    [InlineData("ondblclick")]
-    [InlineData("onkeydown")]
-    [InlineData("onkeyup")]
-    [InlineData("onkeypress")]
-    [InlineData("onreadystatechange")]
-    [InlineData("onbeforeupdate")]
-    [InlineData("onafterupdate")]
-    [InlineData("onrowexit")]
-    [InlineData("onrowenter")]
-    [InlineData("ondragstart")]
-    [InlineData("onselectstart")]
-    [InlineData("onerrorupdate")]
-    [InlineData("onrowsdelete")]
-    [InlineData("onrowsinserted")]
-    [InlineData("oncellchange")]
-    [InlineData("onpropertychange")]
-    [InlineData("ondatasetchanged")]
-    [InlineData("ondataavailable")]
-    [InlineData("ondatasetcomplete")]
-    [InlineData("onbeforeeditfocus")]
-    [InlineData("onselectionchange")]
-    [InlineData("oncontrolselect")]
-    [InlineData("onmousewheel")]
-    [InlineData("onactivate")]
-    [InlineData("ondeactivate")]
-    [InlineData("onbeforeactivate")]
-    [InlineData("onbeforedeactivate")]
-    public async Task HtmlDocument_AttachEventHandler_InvokeClick_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.NotSame(document, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        document.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        iHTMLDocument4.FireEvent(eventName, null);
-        Assert.Equal(1, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_AttachEventHandler_EmptyEventName_ThrowsCOMException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        COMException ex = Assert.Throws<COMException>(() => document.AttachEventHandler(string.Empty, handler));
-        Assert.Equal(HRESULT.DISP_E_UNKNOWNNAME, (HRESULT)ex.HResult);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_AttachEventHandler_NullEventName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        document.AttachEventHandler(null, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", "")]
-    [InlineData("TagName", "TagName")]
-    [InlineData("h1", "H1")]
-    public async Task HtmlDocument_CreateElement_Invoke_ReturnsExpected(string tagName, string expectedTagName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body>InnerText</body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.CreateElement(tagName);
-        Assert.Equal(expectedTagName, element.TagName);
-        Assert.NotSame(document, element.Document);
-        Assert.Null(element.Document.Body);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_CreateElement_NullElementTag_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Throws<ArgumentException>(() => document.CreateElement(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("eventName")]
-    [InlineData("onclick")]
-    public async Task HtmlDocument_DetachEventHandler_AttachDetach_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        // Detach again.
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DetachEventHandler_EmptyEventName_ThrowsCOMException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        document.DetachEventHandler(string.Empty, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_DetachEventHandler_NullEventName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        document.DetachEventHandler(null, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Equals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlDocument newDocument = document.OpenNew(false);
-
-        Assert.True(document.Equals(document));
-        Assert.False(document.Equals(newDocument));
-        Assert.Throws<InvalidCastException>(() => document.Equals(new object()));
-        Assert.False(document.Equals(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("copy", true, null)]
-    [InlineData("copy", true, "abc")]
-    [InlineData("copy", false, null)]
-    [InlineData("copy", false, "def")]
-    public async Task HtmlDocument_ExecCommand_Invoke_Success(string command, bool showUI, object value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        document.ExecCommand(command, showUI, value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, true, null)]
-    [InlineData("NoSuchCommand", true, null)]
-    [InlineData(null, false, null)]
-    [InlineData("NoSuchCommand", false, null)]
-    public async Task HtmlDocument_ExecCommand_InvalidCommand_ThrowsCOMException(string command, bool showUI, object value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Throws<COMException>(() => document.ExecCommand(command, showUI, value));
-    }
-
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/4906")]
-    [WinFormsFact(Skip = "Flaky tests, see: https://github.com/dotnet/winforms/issues/4906")]
-    public async Task HtmlDocument_Focus_Invoke_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        document.Focus();
-        Assert.True(document.Focused);
-
-        // Call again.
-        document.Focus();
-        Assert.True(document.Focused);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetElementById_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p id=\"para1\">InnerText1</p><p id=\"para2\">InnerText2</p><p>InnerText3</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        Assert.Equal("InnerText1", document.GetElementById("para1").InnerText);
-        Assert.Equal("InnerText1", document.GetElementById("PARA1").InnerText);
-        Assert.Null(document.GetElementById("NoSuchId"));
-        Assert.Null(document.GetElementById(string.Empty));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetElementById_NullId_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Throws<ArgumentException>(() => document.GetElementById(null));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetElementFromPoint_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p id=\"para1\">InnerText1</p><p id=\"para2\">InnerText2</p><p>InnerText3</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        Assert.Equal("BODY", document.GetElementFromPoint(Point.Empty).TagName);
-        Assert.Equal("BODY", document.GetElementFromPoint(new Point(int.MinValue, int.MinValue)).TagName);
-        Assert.Equal("BODY", document.GetElementFromPoint(new Point(int.MaxValue, int.MaxValue)).TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetElementsByTagName_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"img1\" /><img id=\"img2\" /><a id=\"link1\">Href</a><a id=\"link2\">Href</a><form id=\"form1\"></form><form id=\"form2\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        HtmlElementCollection collection = document.GetElementsByTagName("form");
-        Assert.NotSame(collection, document.GetElementsByTagName("form"));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("FORM", collection[0].TagName);
-        Assert.Equal("form1", collection[0].GetAttribute("id"));
-        Assert.Equal("FORM", collection[1].TagName);
-        Assert.Equal("form2", collection[1].GetAttribute("id"));
-
-        Assert.Empty(document.GetElementsByTagName("NoSuchTagName"));
-        Assert.Equal("HTML", ((HtmlElement)Assert.Single(document.GetElementsByTagName("html"))).TagName);
-        Assert.Empty(document.GetElementsByTagName(""));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetElementsByTagName_NullTagName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        Assert.Throws<ArgumentException>(() => document.GetElementsByTagName(null));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_GetHashCode_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlDocument newDocument = document.OpenNew(false);
-
-        Assert.NotEqual(0, document.GetHashCode());
-        Assert.Equal(document.GetHashCode(), document.GetHashCode());
-        Assert.NotEqual(document.GetHashCode(), newDocument.GetHashCode());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_InvokeScript_ScriptExists_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = @"
-<html>
-    <head>
-        <script>
-            function divide(p1, p2)
-            {
-                if (!p1)
-                {
-                    return ""NoParameter1"";
-                }
-                if (!p2)
-                {
-                    return ""NoParameter2"";
-                }
-
-                return p1 / p2;
-            }
-        </script>
-    </head>
-</html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        Assert.Equal("NoParameter1", document.InvokeScript("divide"));
-        Assert.Equal("NoParameter1", document.InvokeScript("divide", null));
-        Assert.Equal("NoParameter1", document.InvokeScript("divide", Array.Empty<object>()));
-        Assert.Equal("NoParameter2", document.InvokeScript("divide", new object[] { 2 }));
-        Assert.Equal(6, document.InvokeScript("divide", new object[] { 12, 2 }));
-        Assert.Equal(6, document.InvokeScript("divide", new object[] { 12, 2 }));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_InvokeScript_NoSuchScript_ReturnsNull()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        Assert.Null(document.InvokeScript("NoSuchScript"));
-        Assert.Null(document.InvokeScript("NoSuchScript", null));
-        Assert.Null(document.InvokeScript("NoSuchScript", Array.Empty<object>()));
-        Assert.Null(document.InvokeScript("NoSuchScript", new object[] { 1 }));
-    }
-
-    public static IEnumerable<object[]> Write_TestData()
-    {
-        yield return new object[] { null, "undefined" };
-        yield return new object[] { "", null };
-        yield return new object[] { "InnerText", "InnerText" };
-        yield return new object[] { "<p>Hi</p>", "<P>Hi</P>" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Write_TestData))]
-    public async Task HtmlDocument_Write_InvokeEmpty_Success(string text, string expectedInnerHtml)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        document.Write(text);
-        Assert.Equal(expectedInnerHtml, document.Body?.InnerHtml);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Write_TestData))]
-    public async Task HtmlDocument_Write_InvokeNotEmpty_Success(string text, string expectedInnerHtml)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><h1>OldH1</h1></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-
-        document.Write(text);
-        Assert.Equal(expectedInnerHtml, document.Body?.InnerHtml);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public async Task HtmlDocument_OpenNew_Invoke_Success(bool replaceInHistory)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><h1>InnerText</h1></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlDocument newDocument = document.OpenNew(replaceInHistory);
-        Assert.Empty(newDocument.All);
-        Assert.Null(newDocument.Body);
-        Assert.Equal("about:blank", newDocument.Url.OriginalString);
-    }
-
-#pragma warning disable CS1718, CSIsNull001, CSIsNull002 // Disable "Comparison made to same variable" warning.
-    [WinFormsFact]
-    public async Task HtmlDocument_OperatorEquals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlDocument newDocument = document.OpenNew(false);
-
-        Assert.True(document == document);
-        Assert.False(document == newDocument);
-        Assert.False(document == (HtmlDocument)null);
-        Assert.False(document == (HtmlDocument)null);
-        Assert.True((HtmlDocument)null == (HtmlDocument)null);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_OperatorNotEquals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlDocument newDocument = document.OpenNew(false);
-
-        Assert.False(document != document);
-        Assert.True(document != newDocument);
-        Assert.True(document != (HtmlDocument)null);
-        Assert.True(document != (HtmlDocument)null);
-        Assert.False((HtmlDocument)null != (HtmlDocument)null);
-    }
-#pragma warning restore CS1718, CSIsNull001, CSIsNull002
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Click_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.Click += handler;
-        iHTMLDocument4.FireEvent("onclick", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.Click -= handler;
-        iHTMLDocument4.FireEvent("onclick", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_ContextMenuShowing_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.ContextMenuShowing += handler;
-        iHTMLDocument4.FireEvent("oncontextmenu", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.ContextMenuShowing -= handler;
-        iHTMLDocument4.FireEvent("oncontextmenu", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Focusing_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.Focusing += handler;
-        iHTMLDocument4.FireEvent("onfocusin", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.Focusing -= handler;
-        iHTMLDocument4.FireEvent("onfocusin", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_LosingFocus_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.LosingFocus += handler;
-        iHTMLDocument4.FireEvent("onfocusout", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.LosingFocus -= handler;
-        iHTMLDocument4.FireEvent("onfocusout", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_MouseDown_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.MouseDown += handler;
-        iHTMLDocument4.FireEvent("onmousedown", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.MouseDown -= handler;
-        iHTMLDocument4.FireEvent("onmousedown", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_MouseLeave_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.MouseLeave += handler;
-        iHTMLDocument4.FireEvent("onmouseout", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.MouseLeave -= handler;
-        iHTMLDocument4.FireEvent("onmouseout", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_MouseMove_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.MouseMove += handler;
-        iHTMLDocument4.FireEvent("onmousemove", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.MouseMove -= handler;
-        iHTMLDocument4.FireEvent("onmousemove", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_MouseOver_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.MouseOver += handler;
-        iHTMLDocument4.FireEvent("onmouseover", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.MouseOver -= handler;
-        iHTMLDocument4.FireEvent("onmouseover", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_MouseUp_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.MouseUp += handler;
-        iHTMLDocument4.FireEvent("onmouseup", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.MouseUp -= handler;
-        iHTMLDocument4.FireEvent("onmouseup", null);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlDocument_Stop_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><p>InnerText</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        IHTMLDocument4 iHTMLDocument4 = (IHTMLDocument4)document.DomDocument;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(document, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        document.Stop += handler;
-        iHTMLDocument4.FireEvent("onstop", null);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        document.Stop -= handler;
-        iHTMLDocument4.FireEvent("onstop", null);
-        Assert.Equal(1, callCount);
-    }
-
-    private static async Task<HtmlDocument> GetDocument(WebBrowser control, string html)
-    {
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        using var file = CreateTempFile(html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        return control.Document;
-    }
-
-    private static TempFile CreateTempFile(string html)
-    {
-        byte[] data = Encoding.UTF8.GetBytes(html);
-        return TempFile.Create(data);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlElementTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlElementTests.cs
deleted file mode 100644
index eff8ffb7d89..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/HtmlElementTests.cs
+++ /dev/null
@@ -1,2992 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Text;
-using static Interop.Mshtml;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads
-public class HtmlElementTests
-{
-    [WinFormsFact]
-    public async Task HtmlElement_All_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElementCollection collection = element.All;
-        Assert.NotSame(collection, element.All);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal("H1", collection[0].TagName);
-        Assert.Equal("STRONG", collection[1].TagName);
-        Assert.Equal("H2", collection[2].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_All_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElementCollection collection = element.All;
-        Assert.NotSame(collection, element.All);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Document_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlDocument result = element.Document;
-        Assert.NotSame(result, element.Document);
-        Assert.NotSame(document, result);
-        Assert.Equal(document.Body.InnerHtml, result.Body.InnerHtml);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_CanHaveChildren_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.True(element.CanHaveChildren);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_CanHaveChildren_GetCantHave_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"id\" /></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.False(element.CanHaveChildren);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_ClientRectangle_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Rectangle result = element.ClientRectangle;
-        Assert.Equal(Rectangle.Empty, result);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Children_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElementCollection collection = element.Children;
-        Assert.NotSame(collection, element.Children);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("H1", collection[0].TagName);
-        Assert.Equal("H2", collection[1].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Children_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElementCollection collection = element.Children;
-        Assert.NotSame(collection, element.Children);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DomElement_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        object domElement = element.DomElement;
-        Assert.Same(domElement, element.DomElement);
-        Assert.True(domElement.GetType().IsCOMObject);
-        Assert.True(domElement is IHTMLDOMNode);
-        Assert.True(domElement is IHTMLElement);
-        Assert.True(domElement is IHTMLElement2);
-        Assert.True(domElement is IHTMLElement3);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Enabled_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.True(element.Enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData("true", false)]
-    [InlineData("false", false)]
-    [InlineData("Nothing", false)]
-    public async Task HtmlElement_Enabled_GetCustomValueOnAttribute_ReturnsExpected(string value, bool expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body><div disabled={value} id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal(expected, element.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public async Task HtmlElement_Enabled_GetCustomValueSet_ReturnsExpected(bool disabled)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-        iHTMLElement3.SetDisabled(disabled);
-        Assert.Equal(!disabled, element.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public async Task HtmlElement_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body><div disabled={value} id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        element.Enabled = value;
-        Assert.Equal(value, element.Enabled);
-        Assert.Equal(!value, iHTMLElement3.GetDisabled());
-
-        // Set same.
-        element.Enabled = value;
-        Assert.Equal(value, element.Enabled);
-        Assert.Equal(!value, iHTMLElement3.GetDisabled());
-
-        // Set different.
-        element.Enabled = !value;
-        Assert.Equal(!value, element.Enabled);
-        Assert.Equal(value, iHTMLElement3.GetDisabled());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_FirstChild_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Null(element.FirstChild);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_FirstChild_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2><h3>Header3</h3></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlElement result = element.FirstChild;
-        Assert.NotSame(result, element.FirstChild);
-        Assert.Equal("H1", result.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Id_GetWithoutId_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.Null(element.Id);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Id_GetOnAttribute_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal("id", element.Id);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("id", "id")]
-    public async Task HtmlElement_Id_GetCustomValueSet_ReturnsExpected(string id, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetId(id);
-        Assert.Equal(expected, element.Id);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("id", "id")]
-    public async Task HtmlElement_Id_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.Id = value;
-        Assert.Equal(expected, element.Id);
-        Assert.Equal(expected, iHTMLElement.GetId());
-
-        // Set same.
-        element.Id = value;
-        Assert.Equal(expected, element.Id);
-        Assert.Equal(expected, iHTMLElement.GetId());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerHtml_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Null(element.InnerHtml);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerHtml_GetOnAttribute_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal("<P>InnerText</P>", element.InnerHtml);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("InnerText", "InnerText")]
-    [InlineData("<p>InnerText</p>", "<P>InnerText</P>")]
-    public async Task HtmlElement_InnerHtml_GetCustomValueSet_ReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetInnerHTML(value);
-        Assert.Equal(expected, element.InnerHtml);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("InnerText", "InnerText")]
-    [InlineData("<p>InnerText</p>", "<P>InnerText</P>")]
-    public async Task HtmlElement_InnerHtml_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.InnerHtml = value;
-        Assert.Equal(expected, element.InnerHtml);
-        Assert.Equal(expected, iHTMLElement.GetInnerHTML());
-
-        // Set same.
-        element.InnerHtml = value;
-        Assert.Equal(expected, element.InnerHtml);
-        Assert.Equal(expected, iHTMLElement.GetInnerHTML());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerHtml_SetCantHaveChildren_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"id\" /></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<NotSupportedException>(() => element.InnerHtml = "InnerText");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerHtml_SetDocumentElement_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body.Parent;
-        Assert.Throws<NotSupportedException>(() => element.InnerHtml = "InnerHtml");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerText_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Null(element.InnerText);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerText_GetWithInnerText_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p> <h1>MoreText</h1></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal($"InnerText{Environment.NewLine}MoreText", element.InnerText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("InnerText", "InnerText")]
-    [InlineData("<p>InnerText</p>", "InnerText")]
-    public async Task HtmlElement_InnerText_GetCustomValueSet_ReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetInnerHTML(value);
-        Assert.Equal(expected, element.InnerText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("InnerText", "InnerText")]
-    [InlineData("<p>InnerText</p>", "<p>InnerText</p>")]
-    public async Task HtmlElement_InnerText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.InnerText = value;
-        Assert.Equal(expected, element.InnerText);
-        Assert.Equal(expected, iHTMLElement.GetInnerText());
-
-        // Set same.
-        element.InnerText = value;
-        Assert.Equal(expected, element.InnerText);
-        Assert.Equal(expected, iHTMLElement.GetInnerText());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerText_SetCantHaveChildren_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><img id=\"id\" /></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<NotSupportedException>(() => element.InnerText = "InnerText");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InnerText_SetDocumentElement_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body.Parent;
-        Assert.Throws<NotSupportedException>(() => element.InnerText = "InnerText");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Name_GetWithoutName_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.Empty(element.Name);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Name_GetOnAttribute_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\" name=\"name\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal("name", element.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public async Task HtmlElement_Name_GetCustomValueSet_ReturnsExpected(string id, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetAttribute("name", id, 0);
-        Assert.Equal(expected, element.Name);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", null)]
-    [InlineData("", "", null)]
-    [InlineData("value", "value", "value")]
-    public async Task HtmlElement_Name_Set_GetReturnsExpected(string value, string expected, string expectedNative)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.Name = value;
-        Assert.Equal(expected, element.Name);
-        Assert.Equal(expectedNative, iHTMLElement.GetAttribute("name", 0));
-
-        // Set same.
-        element.Name = value;
-        Assert.Equal(expected, element.Name);
-        Assert.Equal(expectedNative, iHTMLElement.GetAttribute("name", 0));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_NextSibling_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Null(element.NextSibling);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_NextSibling_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div><h1 id=\"id\">Header1 <strong>Strong</strong></h1><h2>Header2</h2><h3>Header3</h3></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlElement result = element.NextSibling;
-        Assert.NotSame(result, element.NextSibling);
-        Assert.Equal("H2", result.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OffsetParent_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement result = element.OffsetParent;
-        Assert.NotSame(result, element.OffsetParent);
-        Assert.Equal("BODY", result.TagName);
-        Assert.Null(result.OffsetParent);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OffsetParent_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2><h3>Header3</h3></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlElement result = element.OffsetParent;
-        Assert.NotSame(result, element.OffsetParent);
-        Assert.Equal("BODY", result.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OffsetRectangle_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Rectangle result = element.OffsetRectangle;
-        Assert.NotEqual(Rectangle.Empty, result);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterHtml_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal($"{Environment.NewLine}<DIV id=id></DIV>", element.OuterHtml);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterHtml_GetOnAttribute_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>OuterText</p></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal($"{Environment.NewLine}<DIV id=id><P>OuterText</P></DIV>", element.OuterHtml);
-    }
-
-    public static IEnumerable<object[]> OuterHtml_CustomValueSet_TestData()
-    {
-        yield return new object[] { null, $"{Environment.NewLine}<DIV id=id></DIV>" };
-        yield return new object[] { "", $"{Environment.NewLine}<DIV id=id></DIV>" };
-        yield return new object[] { "OuterText", $"{Environment.NewLine}<DIV id=id>OuterText</DIV>" };
-        yield return new object[] { "<p>OuterText</p>", $"{Environment.NewLine}<DIV id=id><P>OuterText</P></DIV>" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OuterHtml_CustomValueSet_TestData))]
-    public async Task HtmlElement_OuterHtml_GetCustomValueSet_ReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetInnerHTML(value);
-        Assert.Equal(expected, element.OuterHtml);
-    }
-
-    public static IEnumerable<object[]> OuterHtml_Set_TestData()
-    {
-        yield return new object[] { null, $"{Environment.NewLine}<DIV id=id></DIV>" };
-        yield return new object[] { "", $"{Environment.NewLine}<DIV id=id></DIV>" };
-        yield return new object[] { "OuterText", $"{Environment.NewLine}<DIV id=id></DIV>" };
-        yield return new object[] { "<p>OuterText</p>", $"{Environment.NewLine}<DIV id=id></DIV>" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OuterHtml_Set_TestData))]
-    public async Task HtmlElement_OuterHtml_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.OuterHtml = value;
-        Assert.Equal(expected, element.OuterHtml);
-        Assert.Equal(expected, iHTMLElement.GetOuterHTML());
-
-        // Set same.
-        element.OuterHtml = value;
-        Assert.Equal(expected, element.OuterHtml);
-        Assert.Equal(expected, iHTMLElement.GetOuterHTML());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterHtml_SetDocumentElement_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body.Parent;
-        Assert.Throws<NotSupportedException>(() => element.OuterHtml = "OuterHtml");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterText_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Null(element.OuterText);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterText_GetWithOuterText_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>OuterText</p> <h1>MoreText</h1></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal($"OuterText{Environment.NewLine}MoreText", element.OuterText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("OuterText", "OuterText")]
-    [InlineData("<p>OuterText</p>", "OuterText")]
-    public async Task HtmlElement_OuterText_GetCustomValueSet_ReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetInnerHTML(value);
-        Assert.Equal(expected, element.OuterText);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("OuterText", null)]
-    [InlineData("<p>OuterText</p>", null)]
-    public async Task HtmlElement_OuterText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.OuterText = value;
-        Assert.Equal(expected, element.OuterText);
-        Assert.Equal(expected, iHTMLElement.GetOuterText());
-
-        // Set same.
-        element.OuterText = value;
-        Assert.Equal(expected, element.OuterText);
-        Assert.Equal(expected, iHTMLElement.GetOuterText());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OuterText_SetDocumentElement_ThrowsNotSupportedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body.Parent;
-        Assert.Throws<NotSupportedException>(() => element.OuterText = "OuterText");
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Parent_GetEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement result = element.Parent;
-        Assert.NotSame(result, element.Parent);
-        Assert.Equal("BODY", result.TagName);
-
-        HtmlElement resultParent = result.Parent;
-        Assert.Equal("HTML", resultParent.TagName);
-        Assert.Null(resultParent.Parent);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Parent_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2><h3>Header3</h3></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlElement result = element.Parent;
-        Assert.NotSame(result, element.Parent);
-        Assert.Equal("BODY", result.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_ScrollLeft_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal(0, element.ScrollLeft);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_ScrollLeft_GetCustomValueSet_ReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-        iHTMLElement2.SetScrollLeft(value);
-        Assert.Equal(0, element.ScrollLeft);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_ScrollLeft_Set_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-
-        element.ScrollLeft = value;
-        Assert.Equal(0, element.ScrollLeft);
-        Assert.Equal(0, iHTMLElement2.GetScrollLeft());
-
-        // Set same.
-        element.ScrollLeft = value;
-        Assert.Equal(0, element.ScrollLeft);
-        Assert.Equal(0, iHTMLElement2.GetScrollLeft());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_ScrollRectangle_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Rectangle result = element.ScrollRectangle;
-        Assert.NotEqual(Rectangle.Empty, result);
-        Assert.Equal(element.ScrollLeft, result.X);
-        Assert.Equal(element.ScrollTop, result.Y);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_ScrollTop_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal(0, element.ScrollTop);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_ScrollTop_GetCustomValueSet_ReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-        iHTMLElement2.SetScrollTop(value);
-        Assert.Equal(0, element.ScrollTop);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_ScrollTop_Set_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-
-        element.ScrollTop = value;
-        Assert.Equal(0, element.ScrollTop);
-        Assert.Equal(0, iHTMLElement2.GetScrollTop());
-
-        // Set same.
-        element.ScrollTop = value;
-        Assert.Equal(0, element.ScrollTop);
-        Assert.Equal(0, iHTMLElement2.GetScrollTop());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Style_GetWithoutStyle_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.Null(element.Style);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", null)]
-    [InlineData("style", null)]
-    [InlineData("name:value", "name: value")]
-    [InlineData("name1:value1;name2:value2", "name1: value1; name2: value2")]
-    public async Task HtmlElement_Style_GetOnAttribute_ReturnsExpected(string style, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        string html = $"<html><body><div id=\"id\" style=\"{style}\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal(expected, element.Style);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", null)]
-    [InlineData("style", null)]
-    [InlineData("name:value", "name: value")]
-    [InlineData("name1:value1;name2:value2", "name1: value1; name2: value2")]
-    public async Task HtmlElement_Style_GetCustomValueSet_ReturnsExpected(string style, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.GetStyle().SetCssText(style);
-        Assert.Equal(expected, element.Style);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null)]
-    [InlineData("", null)]
-    [InlineData("value", null)]
-    [InlineData("name:value", "name: value")]
-    [InlineData("name1:value1;name2:value2", "name1: value1; name2: value2")]
-    public async Task HtmlElement_Style_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-
-        element.Style = value;
-        Assert.Equal(expected, element.Style);
-        Assert.Equal(expected, iHTMLElement.GetStyle().GetCssText());
-
-        // Set same.
-        element.Style = value;
-        Assert.Equal(expected, element.Style);
-        Assert.Equal(expected, iHTMLElement.GetStyle().GetCssText());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_TabIndex_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal(0, element.TabIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_TabIndex_GetCustomValueSet_ReturnsExpected(short value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-        iHTMLElement2.SetTabIndex(value);
-        Assert.Equal(value, element.TabIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public async Task HtmlElement_TabIndex_Set_GetReturnsExpected(short value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement2 iHTMLElement2 = (IHTMLElement2)element.DomElement;
-
-        element.TabIndex = value;
-        Assert.Equal(value, element.TabIndex);
-        Assert.Equal(value, iHTMLElement2.GetTabIndex());
-
-        // Set same.
-        element.TabIndex = value;
-        Assert.Equal(value, element.TabIndex);
-        Assert.Equal(value, iHTMLElement2.GetTabIndex());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_TagName_Get_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal("DIV", element.TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_AppendChild_InvokeEmpty_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.AppendChild(newElement1);
-        Assert.Single(element.All);
-        Assert.Equal("H1", element.All[0].TagName);
-
-        element.AppendChild(newElement2);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-
-        element.AppendChild(newElement3);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-        Assert.Equal("H3", element.All[2].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_AppendChild_InvokeNotEmptyEmpty_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p><strong>StrongText</strong></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.AppendChild(newElement1);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-
-        element.AppendChild(newElement2);
-        Assert.Equal(4, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Equal("H2", element.All[3].TagName);
-
-        element.AppendChild(newElement3);
-        Assert.Equal(5, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Equal("H2", element.All[3].TagName);
-        Assert.Equal("H3", element.All[4].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_AppendChild_NullNewElement_ThrowsNullReferenceException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<NullReferenceException>(() => element.AppendChild(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("eventName")]
-    [InlineData("onclick")]
-    public async Task HtmlElement_AttachEventHandler_AttachDetach_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        element.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        // Attach again.
-        element.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("onclick", true)]
-    [InlineData("ondblclick", true)]
-    [InlineData("onkeypress", true)]
-    [InlineData("onkeydown", true)]
-    [InlineData("onkeyup", true)]
-    [InlineData("onmouseover", false)]
-    [InlineData("onmousemove", true)]
-    [InlineData("onmousedown", true)]
-    [InlineData("onmouseup", true)]
-    [InlineData("onmouseenter", true)]
-    [InlineData("onmouseleave", true)]
-    [InlineData("onerrorupdate", true)]
-    [InlineData("onfocus", true)]
-    [InlineData("ondrag", true)]
-    [InlineData("ondragend", true)]
-    [InlineData("ondragleave", true)]
-    [InlineData("ondragover", true)]
-    [InlineData("onfocusin", true)]
-    [InlineData("onfocusout", true)]
-    [InlineData("onblur", true)]
-    [InlineData("onresizestart", true)]
-    [InlineData("onhelp", true)]
-    [InlineData("onselectstart", true)]
-    [InlineData("ondragstart", true)]
-    [InlineData("onbeforeupdate", true)]
-    [InlineData("onrowexit", true)]
-    [InlineData("ondragenter", true)]
-    [InlineData("ondrop", true)]
-    [InlineData("onbeforecut", true)]
-    [InlineData("oncut", true)]
-    [InlineData("onbeforecopy", true)]
-    [InlineData("oncopy", true)]
-    [InlineData("onbeforepaste", true)]
-    [InlineData("onpaste", true)]
-    [InlineData("oncontextmenu", true)]
-    [InlineData("onbeforedeactivate", true)]
-    [InlineData("onbeforeactivate", true)]
-    [InlineData("oncontrolselect", true)]
-    [InlineData("onmovestart", true)]
-    [InlineData("onmousewheel", true)]
-    public async Task HtmlElement_AttachEventHandler_InvokeNormalElement_Success(string eventName, bool expectedResult)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.NotSame(document, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        element.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        Assert.Equal(expectedResult, iHTMLElement3.FireEvent(eventName, IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("onsubmit")]
-    [InlineData("onreset")]
-    public async Task HtmlElement_AttachEventHandler_InvokeForm_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><form id=\"id\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.NotSame(document, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        element.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        Assert.True(iHTMLElement3.FireEvent(eventName, IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("onchange")]
-    public async Task HtmlElement_AttachEventHandler_InvokeSelect_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><select id=\"id\"></select></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.NotSame(document, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        element.AttachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        Assert.True(iHTMLElement3.FireEvent(eventName, IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        document.DetachEventHandler(eventName, handler);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_AttachEventHandler_EmptyEventName_ThrowsCOMException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        COMException ex = Assert.Throws<COMException>(() => element.AttachEventHandler(string.Empty, handler));
-        Assert.Equal(HRESULT.DISP_E_UNKNOWNNAME, (HRESULT)ex.HResult);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_AttachEventHandler_NullEventName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        element.AttachEventHandler(null, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("eventName")]
-    [InlineData("onclick")]
-    public async Task HtmlElement_DetachEventHandler_AttachDetach_Success(string eventName)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-
-        element.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        element.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        element.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-
-        // Detach again.
-        element.DetachEventHandler(eventName, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DetachEventHandler_EmptyEventName_ThrowsCOMException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        element.DetachEventHandler(string.Empty, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DetachEventHandler_NullEventName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        element.DetachEventHandler(null, handler);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Equals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element1 = document.GetElementById("id1");
-        HtmlElement element2 = document.GetElementById("id1");
-        HtmlElement element3 = document.GetElementById("id2");
-
-        Assert.True(element1.Equals(element1));
-        Assert.True(element1.Equals(element2));
-        Assert.False(element1.Equals(element3));
-        Assert.False(element1.Equals(new object()));
-        Assert.False(element1.Equals(null));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Focus_Invoke_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        element.Focus();
-
-        // Call again.
-        element.Focus();
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetAttribute_InvokeEmpty_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        Assert.Empty(element.GetAttribute("NoSuchAttribute"));
-        Assert.Empty(element.GetAttribute(""));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetAttribute_InvokeCustomAttributeSet_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.Body;
-        IHTMLElement iHTMLElement = (IHTMLElement)element.DomElement;
-        iHTMLElement.SetAttribute("id", "id", 1);
-        iHTMLElement.SetAttribute("customAttribute", "value", 1);
-
-        Assert.Equal("id", element.GetAttribute("id"));
-        Assert.Equal("value", element.GetAttribute("customAttribute"));
-        Assert.Equal("value", element.GetAttribute("CUSTOMATTRIBUTE"));
-        Assert.Empty(element.GetAttribute("noValue"));
-        Assert.Empty(element.GetAttribute("NoSuchAttribute"));
-        Assert.Empty(element.GetAttribute(""));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetAttribute_InvokeWithAttributes_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\" customAttribute=\"value\" noValue=\"\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Equal("id", element.GetAttribute("id"));
-        Assert.Equal("value", element.GetAttribute("customAttribute"));
-        Assert.Equal("value", element.GetAttribute("CUSTOMATTRIBUTE"));
-        Assert.Empty(element.GetAttribute("noValue"));
-        Assert.Empty(element.GetAttribute("NoSuchAttribute"));
-        Assert.Empty(element.GetAttribute(""));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetAttribute_NullAttributeName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<ArgumentException>(() => element.GetAttribute(null));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetElementsByTagName_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><img id=\"img1\" /><img id=\"img2\" /><a id=\"link1\">Href</a><a id=\"link2\">Href</a><form id=\"form1\"></form><form id=\"form2\"></form></div><form id=\"form3\"></form></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        HtmlElementCollection collection = element.GetElementsByTagName("form");
-        Assert.NotSame(collection, element.GetElementsByTagName("form"));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("FORM", collection[0].TagName);
-        Assert.Equal("form1", collection[0].GetAttribute("id"));
-        Assert.Equal("FORM", collection[1].TagName);
-        Assert.Equal("form2", collection[1].GetAttribute("id"));
-
-        Assert.Empty(element.GetElementsByTagName("NoSuchTagName"));
-        Assert.Empty(element.GetElementsByTagName(""));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetElementsByTagName_NullTagName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<ArgumentException>(() => element.GetElementsByTagName(null));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GetHashCode_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element1 = document.GetElementById("id1");
-        HtmlElement element2 = document.GetElementById("id1");
-        HtmlElement element3 = document.GetElementById("id2");
-
-        Assert.NotEqual(0, element1.GetHashCode());
-        Assert.Equal(element1.GetHashCode(), element1.GetHashCode());
-        Assert.Equal(element1.GetHashCode(), element2.GetHashCode());
-        Assert.NotEqual(element1.GetHashCode(), element3.GetHashCode());
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeEmptyBeforeBegin_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement1);
-        Assert.Empty(element.All);
-        Assert.Equal(2, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("DIV", element.Parent.Children[1].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement2);
-        Assert.Empty(element.All);
-        Assert.Equal(3, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("DIV", element.Parent.Children[2].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement3);
-        Assert.Empty(element.All);
-        Assert.Equal(4, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("H3", element.Parent.Children[2].TagName);
-        Assert.Equal("DIV", element.Parent.Children[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeNotEmptyBeforeBegin_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p><strong>StrongText</strong></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement1);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(2, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("DIV", element.Parent.Children[1].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement2);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(3, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("DIV", element.Parent.Children[2].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeBegin, newElement3);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(4, element.Parent.Children.Count);
-        Assert.Equal("H1", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("H3", element.Parent.Children[2].TagName);
-        Assert.Equal("DIV", element.Parent.Children[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeEmptyBeforeEnd_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement1);
-        Assert.Single(element.All);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement2);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement3);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-        Assert.Equal("H3", element.All[2].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeNotEmptyBeforeEnd_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p><strong>StrongText</strong></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement1);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement2);
-        Assert.Equal(4, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Equal("H2", element.All[3].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, newElement3);
-        Assert.Equal(5, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Equal("H2", element.All[3].TagName);
-        Assert.Equal("H3", element.All[4].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeEmptyAfterBegin_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement1);
-        Assert.Single(element.All);
-        Assert.Equal("H1", element.All[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement2);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("H2", element.All[0].TagName);
-        Assert.Equal("H1", element.All[1].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement3);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("H3", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeNotEmptyAfterBegin_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p><strong>StrongText</strong></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement1);
-        Assert.Equal(3, element.All.Count);
-        Assert.Equal("H1", element.All[0].TagName);
-        Assert.Equal("P", element.All[1].TagName);
-        Assert.Equal("STRONG", element.All[2].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement2);
-        Assert.Equal(4, element.All.Count);
-        Assert.Equal("H2", element.All[0].TagName);
-        Assert.Equal("H1", element.All[1].TagName);
-        Assert.Equal("P", element.All[2].TagName);
-        Assert.Equal("STRONG", element.All[3].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterBegin, newElement3);
-        Assert.Equal(5, element.All.Count);
-        Assert.Equal("H3", element.All[0].TagName);
-        Assert.Equal("H2", element.All[1].TagName);
-        Assert.Equal("H1", element.All[2].TagName);
-        Assert.Equal("P", element.All[3].TagName);
-        Assert.Equal("STRONG", element.All[4].TagName);
-        Assert.Single(element.Parent.Children);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeEmptyAfterEnd_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement1);
-        Assert.Equal(2, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H1", element.Parent.Children[1].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement2);
-        Assert.Equal(3, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("H1", element.Parent.Children[2].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement3);
-        Assert.Equal(4, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H3", element.Parent.Children[1].TagName);
-        Assert.Equal("H2", element.Parent.Children[2].TagName);
-        Assert.Equal("H1", element.Parent.Children[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_InvokeNotEmptyAfterEnd_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><p>InnerText</p><strong>StrongText</strong></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement1 = document.CreateElement("h1");
-        HtmlElement newElement2 = document.CreateElement("h2");
-        HtmlElement newElement3 = document.CreateElement("h3");
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement1);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(2, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H1", element.Parent.Children[1].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement2);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(3, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H2", element.Parent.Children[1].TagName);
-        Assert.Equal("H1", element.Parent.Children[2].TagName);
-
-        element.InsertAdjacentElement(HtmlElementInsertionOrientation.AfterEnd, newElement3);
-        Assert.Equal(2, element.All.Count);
-        Assert.Equal("P", element.All[0].TagName);
-        Assert.Equal("STRONG", element.All[1].TagName);
-        Assert.Equal(4, element.Parent.Children.Count);
-        Assert.Equal("DIV", element.Parent.Children[0].TagName);
-        Assert.Equal("H3", element.Parent.Children[1].TagName);
-        Assert.Equal("H2", element.Parent.Children[2].TagName);
-        Assert.Equal("H1", element.Parent.Children[3].TagName);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InsertAdjacentElement_NullNewElement_ThrowsNullReferenceException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"><h1>Header1 <strong>Strong</strong></h1><h2>Header2</h2></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<NullReferenceException>(() => element.InsertAdjacentElement(HtmlElementInsertionOrientation.BeforeEnd, null));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HtmlElementInsertionOrientation>]
-    public async Task HtmlElement_InsertAdjacentElement_InvalidOrient_ThrowsArgumentException(HtmlElementInsertionOrientation orient)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        HtmlElement newElement = document.CreateElement("H1");
-        Assert.Throws<ArgumentException>(() => element.InsertAdjacentElement(orient, newElement));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InvokeMember_MemberExists_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><body><p id=\"target\" attribute=\"value\">Paragraph</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("target");
-        Assert.NotNull(element);
-
-        Assert.Equal("value", element.InvokeMember("getAttribute", "attribute"));
-        Assert.Equal("value", element.InvokeMember("getAttribute", "attribute", 1));
-        Assert.Equal(Convert.DBNull, element.InvokeMember("getAttribute", "ATTRIBUTE", 1));
-        Assert.Equal(Convert.DBNull, element.InvokeMember("getAttribute", "NoSuchAttribute"));
-        Assert.Null(element.InvokeMember("getAttribute", new TimeSpan()));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_InvokeMember_NoSuchMember_ReturnsNull()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><body><p id=\"target\" attribute=\"value\">Paragraph</p></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("target");
-        Assert.NotNull(element);
-
-        Assert.Null(element.InvokeMember("NoSuchMember"));
-        Assert.Null(element.InvokeMember("NoSuchMember", null));
-        Assert.Null(element.InvokeMember("NoSuchMember", Array.Empty<object>()));
-        Assert.Null(element.InvokeMember("NoSuchMember", new object[] { 1 }));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_RemoveFocus_Invoke_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        element.RemoveFocus();
-
-        // Call again.
-        element.RemoveFocus();
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_RemoveFocus_InvokeFocused_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        element.Focus();
-
-        element.RemoveFocus();
-
-        // Call again.
-        element.RemoveFocus();
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public async Task HtmlElement_ScrollIntoView_Invoke_Success(bool alignWithTop)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        element.ScrollIntoView(alignWithTop);
-
-        // Call again.
-        element.ScrollIntoView(alignWithTop);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public async Task HtmlElement_SetAttribute_Invoke_GetAttributeReturnsExpected(string value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-
-        element.SetAttribute("customAttribute", value);
-        Assert.Equal(value, element.GetAttribute("customAttribute"));
-
-        // Set same.
-        element.SetAttribute("customAttribute", value);
-        Assert.Equal(value, element.GetAttribute("customAttribute"));
-
-        // Override.
-        element.SetAttribute("customAttribute", "newValue");
-        Assert.Equal("newValue", element.GetAttribute("customAttribute"));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_SetAttribute_NullAttributeName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        Assert.Throws<ArgumentException>(() => element.SetAttribute(null, "value"));
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_SetAttribute_EmptyAttributeName_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        COMException ex = Assert.Throws<COMException>(() => element.SetAttribute(string.Empty, "value"));
-        Assert.Equal(HRESULT.DISP_E_UNKNOWNNAME, (HRESULT)ex.HResult);
-    }
-
-#pragma warning disable CS1718, CSIsNull001, CSIsNull002 // Disable "Comparison made to same variable" warning.
-    [WinFormsFact]
-    public async Task HtmlElement_OperatorEquals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element1 = document.GetElementById("id1");
-        HtmlElement element2 = document.GetElementById("id1");
-        HtmlElement element3 = document.GetElementById("id2");
-
-        Assert.True(element1 == element1);
-        Assert.True(element1 == element2);
-        Assert.False(element1 == element3);
-        Assert.False(element1 == (HtmlElement)null);
-        Assert.False(element1 == (HtmlElement)null);
-        Assert.True((HtmlElement)null == (HtmlElement)null);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_OperatorNotEquals_Invoke_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id1\"></div><div id=\"id2\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element1 = document.GetElementById("id1");
-        HtmlElement element2 = document.GetElementById("id1");
-        HtmlElement element3 = document.GetElementById("id2");
-
-        Assert.False(element1 != element1);
-        Assert.False(element1 != element2);
-        Assert.True(element1 != element3);
-        Assert.True(element1 != (HtmlElement)null);
-        Assert.True(element1 != (HtmlElement)null);
-        Assert.False((HtmlElement)null != (HtmlElement)null);
-    }
-#pragma warning restore CS1718, CSIsNull001, CSIsNull002
-
-    [WinFormsFact]
-    public async Task HtmlElement_Click_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.Click += handler;
-        Assert.True(iHTMLElement3.FireEvent("onclick", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.Click -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onclick", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DoubleClick_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.DoubleClick += handler;
-        Assert.True(iHTMLElement3.FireEvent("ondblclick", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.DoubleClick -= handler;
-        Assert.True(iHTMLElement3.FireEvent("ondblclick", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Drag_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.Drag += handler;
-        Assert.True(iHTMLElement3.FireEvent("ondrag", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.Drag -= handler;
-        Assert.True(iHTMLElement3.FireEvent("ondrag", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DragEnd_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.DragEnd += handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragend", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.DragEnd -= handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragend", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DragLeave_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.DragLeave += handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragleave", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.DragLeave -= handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragleave", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_DragOver_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.DragOver += handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragover", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.DragOver -= handler;
-        Assert.True(iHTMLElement3.FireEvent("ondragover", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_GotFocus_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.GotFocus += handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocus", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.GotFocus -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocus", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_Focusing_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.Focusing += handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocusin", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.Focusing -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocusin", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_LosingFocus_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.LosingFocus += handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocusout", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.LosingFocus -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onfocusout", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_LostFocus_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.LostFocus += handler;
-        Assert.True(iHTMLElement3.FireEvent("onblur", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.LostFocus -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onblur", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_KeyDown_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.KeyDown += handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeydown", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.KeyDown -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeydown", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_KeyPress_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.KeyPress += handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeypress", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.KeyPress -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeypress", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_KeyUp_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.KeyUp += handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeyup", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.KeyUp -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onkeyup", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseDown_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseDown += handler;
-        Assert.True(iHTMLElement3.FireEvent("onmousedown", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseDown -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onmousedown", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseEnter_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseEnter += handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseenter", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseEnter -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseenter", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseLeave_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseLeave += handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseleave", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseLeave -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseleave", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseMove_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseMove += handler;
-        Assert.True(iHTMLElement3.FireEvent("onmousemove", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseMove -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onmousemove", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseOver_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseOver += handler;
-        Assert.False(iHTMLElement3.FireEvent("onmouseover", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseOver -= handler;
-        Assert.False(iHTMLElement3.FireEvent("onmouseover", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public async Task HtmlElement_MouseUp_InvokeEvent_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        const string Html = "<html><body><div id=\"id\"></div></body></html>";
-        HtmlDocument document = await GetDocument(control, Html);
-        HtmlElement element = document.GetElementById("id");
-        IHTMLElement3 iHTMLElement3 = (IHTMLElement3)element.DomElement;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(element, sender);
-            Assert.IsType<HtmlElementEventArgs>(e);
-            callCount++;
-        }
-
-        element.MouseUp += handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseup", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        element.MouseUp -= handler;
-        Assert.True(iHTMLElement3.FireEvent("onmouseup", IntPtr.Zero));
-        Assert.Equal(1, callCount);
-    }
-
-    private static async Task<HtmlDocument> GetDocument(WebBrowser control, string html)
-    {
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        using var file = CreateTempFile(html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        return control.Document;
-    }
-
-    private static TempFile CreateTempFile(string html)
-    {
-        byte[] data = Encoding.UTF8.GetBytes(html);
-        return TempFile.Create(data);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.ImageCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.ImageCollectionTests.cs
deleted file mode 100644
index 9b6c3a847f9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.ImageCollectionTests.cs
+++ /dev/null
@@ -1,1838 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-using System.Drawing.Imaging;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // ImageList doesn't appear to behave well under stress in multi-threaded env
-public class ImageCollectionTests
-{
-    [WinFormsFact]
-    public void ImageCollection_Count_GetEmptyWithHandle_ReturnsExpected()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Equal(0, collection.Count);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Empty_GetEmptyWithHandle_ReturnsExpected()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        ImageList.ImageCollection collection = list.Images;
-        Assert.True(collection.Empty);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_IsReadOnly_IsReadOnly_ReturnsExpected()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.False(collection.IsReadOnly);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageCollection_Item_GetInt_InvokeWithoutHandle_ReturnsExpected(ColorDepth depth)
-    {
-        using var list = new ImageList
-        {
-            ColorDepth = depth
-        };
-        using var image1bppIndexed = new Bitmap(1, 2, PixelFormat.Format24bppRgb);
-        using var image24bppRGb = new Bitmap(3, 4, PixelFormat.Format24bppRgb);
-        using var image32bppRGb = new Bitmap(5, 6, PixelFormat.Format32bppRgb);
-        using var image32bppArgbNotTransparent = new Bitmap(7, 8, PixelFormat.Format32bppArgb);
-        using var image32bppArgbTransparent = new Bitmap(9, 10, PixelFormat.Format32bppArgb);
-        image32bppArgbTransparent.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-        list.Images.Add(image1bppIndexed);
-        list.Images.Add(image24bppRGb);
-        list.Images.Add(image32bppRGb);
-        list.Images.Add(image32bppArgbNotTransparent);
-        list.Images.Add(image32bppArgbTransparent);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.False(list.HandleCreated);
-
-        Bitmap bitmap1 = Assert.IsType<Bitmap>(collection[0]);
-        Assert.Equal(new Size(16, 16), bitmap1.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap1.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap2 = Assert.IsType<Bitmap>(collection[1]);
-        Assert.Equal(new Size(16, 16), bitmap2.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap2.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap3 = Assert.IsType<Bitmap>(collection[2]);
-        Assert.Equal(new Size(16, 16), bitmap3.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap3.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap4 = Assert.IsType<Bitmap>(collection[3]);
-        Assert.Equal(new Size(16, 16), bitmap4.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap4.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap5 = Assert.IsType<Bitmap>(collection[4]);
-        Assert.Equal(new Size(16, 16), bitmap5.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap5.PixelFormat);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageCollection_Item_GetInt_InvokeWithHandle_ReturnsExpected(ColorDepth depth)
-    {
-        using var list = new ImageList
-        {
-            ColorDepth = depth
-        };
-        using var image1bppIndexed = new Bitmap(1, 2, PixelFormat.Format24bppRgb);
-        using var image24bppRGb = new Bitmap(3, 4, PixelFormat.Format24bppRgb);
-        using var image32bppRGb = new Bitmap(5, 6, PixelFormat.Format32bppRgb);
-        using var image32bppArgbNotTransparent = new Bitmap(7, 8, PixelFormat.Format32bppArgb);
-        using var image32bppArgbTransparent = new Bitmap(9, 10, PixelFormat.Format32bppArgb);
-        image32bppArgbTransparent.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-        list.Images.Add(image1bppIndexed);
-        list.Images.Add(image24bppRGb);
-        list.Images.Add(image32bppRGb);
-        list.Images.Add(image32bppArgbNotTransparent);
-        list.Images.Add(image32bppArgbTransparent);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        Bitmap bitmap1 = Assert.IsType<Bitmap>(collection[0]);
-        Assert.Equal(new Size(16, 16), bitmap1.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap1.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap2 = Assert.IsType<Bitmap>(collection[1]);
-        Assert.Equal(new Size(16, 16), bitmap2.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap2.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap3 = Assert.IsType<Bitmap>(collection[2]);
-        Assert.Equal(new Size(16, 16), bitmap3.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap3.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap4 = Assert.IsType<Bitmap>(collection[3]);
-        Assert.Equal(new Size(16, 16), bitmap4.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap4.PixelFormat);
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap5 = Assert.IsType<Bitmap>(collection[4]);
-        Assert.Equal(new Size(16, 16), bitmap5.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap5.PixelFormat);
-        Assert.True(list.HandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageCollection_VisualStyles_off_Item_Get32bppColorDepth_TestData()
-    {
-        var pixelFormats = new[]
-        {
-            PixelFormat.Format1bppIndexed,
-            PixelFormat.Format24bppRgb,
-            PixelFormat.Format32bppRgb,
-            PixelFormat.Format32bppArgb,
-            PixelFormat.Format32bppPArgb,
-        };
-
-        // SetPixel is not supported for images with indexed pixel formats.
-
-        foreach (PixelFormat pixelFormat in pixelFormats)
-        {
-            yield return new object[] { pixelFormat, Color.Empty, Color.Empty };
-            yield return new object[] { PixelFormat.Format24bppRgb, Color.Red, Color.FromArgb(200, 50, 75, 100) };
-        }
-    }
-
-    public static IEnumerable<object[]> ImageCollection_VisualStyles_on_Item_Get32bppColorDepth_TestData()
-    {
-        // SetPixel is not supported for images with indexed pixel formats.
-        yield return new object[] { PixelFormat.Format1bppIndexed, Color.Empty, Color.Empty, Color.FromArgb(255, 0, 0, 0) };
-
-        // The actual colours are visually close to the originals, but no colour fidelity
-        if (ArchitectureDetection.Is64bit)
-        {
-            yield return new object[] { PixelFormat.Format24bppRgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(255, 50, 75, 100) };
-            yield return new object[] { PixelFormat.Format32bppRgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(255, 50, 75, 100) };
-            yield return new object[] { PixelFormat.Format32bppArgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(200, 67, 81, 96) };
-            yield return new object[] { PixelFormat.Format32bppPArgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(200, 67, 81, 96) };
-        }
-        else
-        {
-            yield return new object[] { PixelFormat.Format24bppRgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(255, 49, 74, 99) };
-            yield return new object[] { PixelFormat.Format32bppRgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(255, 49, 74, 99) };
-            yield return new object[] { PixelFormat.Format32bppArgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(200, 66, 81, 95) };
-            yield return new object[] { PixelFormat.Format32bppPArgb, Color.Red, Color.FromArgb(200, 50, 75, 100), Color.FromArgb(200, 66, 81, 95) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageCollection_VisualStyles_on_Item_Get32bppColorDepth_TestData))]
-    public void ImageCollection_Item_Get32bppColorDepth_Success(PixelFormat pixelFormat, Color pixel00Color, Color givenPixel10Color, Color expectedPixel10Color)
-    {
-        using var imageFiller1 = new Bitmap(16, 16, pixelFormat);
-        using var imageFiller2 = new Bitmap(16, 16, pixelFormat);
-
-        using var image = new Bitmap(16, 16, pixelFormat);
-        if (pixel00Color != Color.Empty)
-            image.SetPixel(0, 0, pixel00Color);
-        if (givenPixel10Color != Color.Empty)
-            image.SetPixel(1, 0, givenPixel10Color);
-
-        using var list = new ImageList
-        {
-            ColorDepth = ColorDepth.Depth32Bit
-        };
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(imageFiller1);
-        collection.Add(image);
-        collection.Add(imageFiller2);
-
-        // By getting a bitmap from the ImageListcollection ImageList will clone the original bitmap.
-        // Assert that the new bitmap contains all the same properties.
-
-        Bitmap resultImage = Assert.IsType<Bitmap>(collection[1]);
-
-        Assert.Equal(image.Size, resultImage.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, resultImage.PixelFormat);
-        Assert.Equal(image.GetPixel(0, 0), resultImage.GetPixel(0, 0));
-        Assert.Equal(expectedPixel10Color, resultImage.GetPixel(1, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageCollection_Item_GetIntInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageCollection_Item_GetIntInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    public static IEnumerable<object[]> Item_Set_TestData()
-    {
-        foreach (Color transparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-        {
-            yield return new object[] { transparentColor, new Bitmap(10, 10) };
-            yield return new object[] { transparentColor, new Bitmap(16, 16) };
-            yield return new object[] { transparentColor, new Bitmap(32, 32) };
-            yield return new object[] { transparentColor, new Bitmap(256, 256) };
-
-            var bitmap = new Bitmap(16, 16);
-            bitmap.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-            yield return new object[] { transparentColor, bitmap };
-
-            yield return new object[] { transparentColor, new Bitmap("bitmaps/10x16_one_entry_32bit.ico") };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Item_Set_TestData))]
-    public void ImageCollection_Item_Set_GetReturnsExpected(Color transparentColor, Image value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-
-        collection[0] = value;
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap = Assert.IsType<Bitmap>(collection[0]);
-        Assert.NotSame(value, bitmap);
-        Assert.Equal(new Size(16, 16), bitmap.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Item_Set_TestData))]
-    public void ImageCollection_Item_SetWithHandle_GetReturnsExpected(Color transparentColor, Image value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        list.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-        ImageList.ImageCollection collection = list.Images;
-
-        collection[0] = value;
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap = Assert.IsType<Bitmap>(collection[0]);
-        Assert.Equal(new Size(16, 16), bitmap.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageCollection_Item_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageCollection_Item_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = null);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Item_SetNullValue_ThrowsArgumentNullException()
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Item_SetNonBitmapValue_ThrowsArgumentException()
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-
-        using var value = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<ArgumentException>(() => collection[0] = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    public void ImageCollection_Item_GetStringValidKey_ReturnsExpected(string key, int expectedIndex)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("name1", image1);
-        collection.Add("name2", image2);
-
-        Bitmap result1 = Assert.IsType<Bitmap>(collection[key]);
-        Assert.Equal(new Size(16, 16), result1.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, result1.PixelFormat);
-        Assert.Equal(((Bitmap)collection[expectedIndex]).GetPixel(0, 0), result1.GetPixel(0, 0));
-
-        // Call again.
-        Bitmap result2 = Assert.IsType<Bitmap>(collection[key]);
-        Assert.NotSame(result1, result2);
-        Assert.Equal(new Size(16, 16), result1.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, result1.PixelFormat);
-        Assert.Equal(result1.GetPixel(0, 0), result2.GetPixel(0, 0));
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ImageCollection_Item_GetStringNoSuchKey_ReturnsNull(string key)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        using var image2 = new Bitmap(3, 4);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("name1", image1);
-        collection.Add("name2", image2);
-
-        Assert.Null(collection[key]);
-
-        // Call again.
-        Assert.Null(collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ImageCollection_Item_GetStringEmpty_ReturnsNull(string key)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        Assert.Null(collection[key]);
-
-        // Call again.
-        Assert.Null(collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Keys_GetEmpty_ReturnsExpected()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Empty(collection.Keys);
-        Assert.NotSame(collection.Keys, collection.Keys);
-    }
-
-    public static IEnumerable<object[]> Add_Image_TestData()
-    {
-        foreach (Color transparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-        {
-            yield return new object[] { transparentColor, new Bitmap(10, 10) };
-            yield return new object[] { transparentColor, new Bitmap(16, 16) };
-            yield return new object[] { transparentColor, new Bitmap(32, 32) };
-            yield return new object[] { transparentColor, new Bitmap(256, 256) };
-
-            var bitmap = new Bitmap(16, 16);
-            bitmap.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-            yield return new object[] { transparentColor, bitmap };
-
-            //yield return new object[] { transparentColor, new Bitmap("bitmaps/10x16_one_entry_32bit.ico") };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_Add_InvokeStringImage_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Add("Key1", value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal("Key1", Assert.Single(collection.Keys));
-        Assert.False(list.HandleCreated);
-
-        // Add again.
-        collection.Add("Key2", value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add same.
-        collection.Add("Key1", value);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add null.
-        collection.Add(null, value);
-        Assert.Equal(4, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add empty.
-        collection.Add(string.Empty, value);
-        Assert.Equal(5, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_Add_InvokeStringImageWithHandle_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Add("Key1", value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal("Key1", Assert.Single(collection.Keys));
-        Assert.True(list.HandleCreated);
-
-        // Add again.
-        collection.Add("Key2", value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add same.
-        collection.Add("Key1", value);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add null.
-        collection.Add(null, value);
-        Assert.Equal(4, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add empty.
-        collection.Add(string.Empty, value);
-        Assert.Equal(5, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_Add_InvokeImage_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Add(value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.False(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_Add_InvokeImageWithHandle_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Add(value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.True(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    public static IEnumerable<object[]> Add_Image_Color_TestData()
-    {
-        foreach (Color listTransparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-        {
-            foreach (Color transparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-            {
-                yield return new object[] { listTransparentColor, new Bitmap(10, 10), transparentColor };
-                yield return new object[] { listTransparentColor, new Bitmap(16, 16), transparentColor };
-                yield return new object[] { listTransparentColor, new Bitmap(32, 32), transparentColor };
-                yield return new object[] { listTransparentColor, new Bitmap(256, 256), transparentColor };
-
-                var bitmap = new Bitmap(16, 16);
-                bitmap.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-                yield return new object[] { listTransparentColor, bitmap, transparentColor };
-
-                //yield return new object[] { listTransparentColor, new Bitmap("bitmaps/10x16_one_entry_32bit.ico"), transparentColor };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_Color_TestData))]
-    public void ImageCollection_Add_InvokeImageColor_Success(Color listTransparentColor, Image value, Color transparentColor)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = listTransparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Add(value, transparentColor);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.False(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value, transparentColor);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_Color_TestData))]
-    public void ImageCollection_Add_InvokeImageColorWithHandle_Success(Color listTransparentColor, Image value, Color transparentColor)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = listTransparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Add(value, transparentColor);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.True(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value, transparentColor);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    public static IEnumerable<object[]> Add_Icon_TestData()
-    {
-        foreach (Color transparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-        {
-            yield return new object[] { transparentColor, new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Icon_TestData))]
-    public void ImageCollection_Add_InvokeStringIcon_Success(Color transparentColor, Icon value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Add("Key1", value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal("Key1", Assert.Single(collection.Keys));
-        Assert.False(list.HandleCreated);
-
-        // Add again.
-        collection.Add("Key2", value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add same.
-        collection.Add("Key1", value);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add null.
-        collection.Add(null, value);
-        Assert.Equal(4, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add empty.
-        collection.Add(string.Empty, value);
-        Assert.Equal(5, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Icon_TestData))]
-    public void ImageCollection_Add_InvokeStringIconWithHandle_Success(Color transparentColor, Icon value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Add("Key1", value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal("Key1", Assert.Single(collection.Keys));
-        Assert.True(list.HandleCreated);
-
-        // Add again.
-        collection.Add("Key2", value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add same.
-        collection.Add("Key1", value);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add null.
-        collection.Add(null, value);
-        Assert.Equal(4, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add empty.
-        collection.Add(string.Empty, value);
-        Assert.Equal(5, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Icon_TestData))]
-    public void ImageCollection_Add_InvokeIcon_Success(Color transparentColor, Icon value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Add(value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.False(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Icon_TestData))]
-    public void ImageCollection_Add_InvokeIconWithHandle_Success(Color transparentColor, Icon value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Add(value);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(string.Empty, Assert.Single(collection.Keys));
-        Assert.True(list.HandleCreated);
-
-        // Add again.
-        collection.Add(value);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Add_NullImage_ThrowsArgumentNullException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentNullException>("value", () => collection.Add((Image)null));
-        Assert.Throws<ArgumentNullException>("value", () => collection.Add((Image)null, Color.Transparent));
-        Assert.Throws<InvalidOperationException>(() => collection.Add("Key", (Image)null));
-        Assert.Throws<ArgumentNullException>("value", () => collection.Add((Icon)null));
-        Assert.Throws<InvalidOperationException>(() => collection.Add("Key", (Icon)null));
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Add_NonBitmapImage_ThrowsArgumentException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        using var value = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<ArgumentException>(() => collection.Add(value));
-        Assert.Throws<ArgumentException>(() => collection.Add(value, Color.Transparent));
-        Assert.Throws<ArgumentException>(() => collection.Add("Key", value));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_AddRange_Invoke_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.AddRange(new Image[] { value, value });
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<Image>());
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_Image_TestData))]
-    public void ImageCollection_AddRange_InvokeWithHandle_Success(Color transparentColor, Image value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.AddRange(new Image[] { value, value });
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<Image>());
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_AddRange_NullImages_ThrowsArgumentNullException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentNullException>("images", () => collection.AddRange(null));
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_AddRange_NullImageInImages_ThrowsArgumentNullException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange(new Image[] { null }));
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_AddRange_NonBitmapImage_ThrowsArgumentException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        using var value = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<ArgumentException>(() => collection.AddRange(new Image[] { value }));
-    }
-
-    public static IEnumerable<object[]> AddStrip_TestData()
-    {
-        foreach (Color transparentColor in new Color[] { Color.Transparent, Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.Empty, Color.Black })
-        {
-            yield return new object[] { transparentColor, new Bitmap(16, 16), 1 };
-            yield return new object[] { transparentColor, new Bitmap(32, 16), 2 };
-            yield return new object[] { transparentColor, new Bitmap(256, 16), 16 };
-
-            var bitmap = new Bitmap(16, 16);
-            bitmap.SetPixel(0, 0, Color.FromArgb(0x12, 0x34, 0x56, 0x78));
-            yield return new object[] { transparentColor, bitmap, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AddStrip_TestData))]
-    public void ImageCollection_AddStrip_Invoke_Success(Color transparentColor, Image value, int expectedCount)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.AddStrip(value);
-        Assert.Equal(expectedCount, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AddStrip_TestData))]
-    public void ImageCollection_AddStrip_InvokeWithHandle_Success(Color transparentColor, Image value, int expectedCount)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.AddStrip(value);
-        Assert.Equal(expectedCount, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_AddStrip_NullValue_ThrowsArgumentNullException()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddStrip(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(15)]
-    [InlineData(17)]
-    public void ImageCollection_AddStrip_InvalidWidth_ThrowsArgumentException(int width)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        using var image = new Bitmap(width, 16);
-        Assert.Throws<ArgumentException>("value", () => collection.AddStrip(image));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(15)]
-    [InlineData(17)]
-    public void ImageCollection_AddStrip_InvalidHeight_ThrowsArgumentException(int width)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        using var image = new Bitmap(16, width);
-        Assert.Throws<ArgumentException>("value", () => collection.AddStrip(image));
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Clear_InvokeEmpty_Nop()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.False(list.HandleCreated);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Clear_InvokeNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.False(list.HandleCreated);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Clear_InvokeEmptyWithHandle_Nop()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.True(list.HandleCreated);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_Clear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.True(list.HandleCreated);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-        Assert.True(list.HandleCreated);
-    }
-
-    public static IEnumerable<object[]> Contains_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Contains_TestData))]
-    public void ImageCollection_Contains_ThrowsNotSupportedException(Image image)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.Contains(image));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, false)]
-    [InlineData("", false)]
-    [InlineData("name1", true)]
-    [InlineData("NAME1", true)]
-    [InlineData("name2", true)]
-    [InlineData("NoSuchName", false)]
-    [InlineData("abcd", false)]
-    [InlineData("abcde", false)]
-    [InlineData("abcdef", false)]
-    public void ImageCollection_ContainsKey_InvokeNotEmpty_ReturnsExpected(string key, bool expected)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        using var image2 = new Bitmap(3, 4);
-        using var image3 = new Bitmap(5, 6);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("name1", image1);
-        collection.Add("name2", image2);
-        collection.Add("name3", image3);
-
-        Assert.Equal(expected, collection.ContainsKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.ContainsKey(key));
-        Assert.False(collection.ContainsKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ImageCollection_ContainsKey_InvokeEmpty_ReturnsExpected(string key)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        Assert.False(collection.ContainsKey(key));
-
-        // Call again.
-        Assert.False(collection.ContainsKey(key));
-        Assert.False(collection.ContainsKey("NoSuchKey"));
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_GetEnumerator_InvokeWithoutHandleEmpty_Success()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.False(list.HandleCreated);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_GetEnumerator_InvokeWithHandleEmpty_Success()
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.True(list.HandleCreated);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_GetEnumerator_InvokeWithoutHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image1);
-        collection.Add(image2);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.True(list.HandleCreated);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Bitmap result1 = Assert.IsType<Bitmap>(enumerator.Current);
-            Assert.Equal(new Size(16, 16), result1.Size);
-            Assert.Equal(PixelFormat.Format32bppArgb, result1.PixelFormat);
-            Assert.Equal(((Bitmap)collection[0]).GetPixel(0, 0), result1.GetPixel(0, 0));
-
-            Assert.True(enumerator.MoveNext());
-            Bitmap result2 = Assert.IsType<Bitmap>(enumerator.Current);
-            Assert.Equal(new Size(16, 16), result2.Size);
-            Assert.Equal(PixelFormat.Format32bppArgb, result2.PixelFormat);
-            Assert.Equal(((Bitmap)collection[1]).GetPixel(0, 0), result2.GetPixel(0, 0));
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_GetEnumerator_InvokeWithHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image1);
-        collection.Add(image2);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.True(list.HandleCreated);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Bitmap result1 = Assert.IsType<Bitmap>(enumerator.Current);
-            Assert.Equal(new Size(16, 16), result1.Size);
-            Assert.Equal(PixelFormat.Format32bppArgb, result1.PixelFormat);
-            Assert.Equal(((Bitmap)collection[0]).GetPixel(0, 0), result1.GetPixel(0, 0));
-
-            Assert.True(enumerator.MoveNext());
-            Bitmap result2 = Assert.IsType<Bitmap>(enumerator.Current);
-            Assert.Equal(new Size(16, 16), result2.Size);
-            Assert.Equal(PixelFormat.Format32bppArgb, result2.PixelFormat);
-            Assert.Equal(((Bitmap)collection[1]).GetPixel(0, 0), result2.GetPixel(0, 0));
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    [InlineData("NoSuchName", -1)]
-    [InlineData("abcd", -1)]
-    [InlineData("abcde", -1)]
-    [InlineData("abcdef", -1)]
-    public void ImageCollection_IndexOfKey_InvokeNotEmpty_ReturnsExpected(string key, int expected)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        using var image2 = new Bitmap(3, 4);
-        using var image3 = new Bitmap(5, 6);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("name1", image1);
-        collection.Add("name2", image2);
-        collection.Add("name3", image3);
-
-        Assert.Equal(expected, collection.IndexOfKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ImageCollection_IndexOfKey_InvokeEmpty_ReturnsExpected(string key)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-
-        Assert.Equal(-1, collection.IndexOfKey(key));
-
-        // Call again.
-        Assert.Equal(-1, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    public static IEnumerable<object[]> IndexOf_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IndexOf_TestData))]
-    public void ImageCollection_IndexOf_ThrowsNotSupportedException(Image image)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.IndexOf(image));
-    }
-
-    public static IEnumerable<object[]> Remove_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Remove_TestData))]
-    public void ImageCollection_Remove_Invoke_ThrowsNotSupportedException(Image image)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.Remove(image));
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_RemoveAt_InvokeWithoutHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        using var image3 = new Bitmap(3, 4);
-        image3.SetPixel(0, 0, Color.Yellow);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image1);
-        collection.Add(image2);
-        collection.Add(image3);
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-
-        // Remove last.
-        collection.RemoveAt(0);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_RemoveAt_InvokeWithHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        using var image3 = new Bitmap(3, 4);
-        image3.SetPixel(0, 0, Color.Yellow);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add(image1);
-        collection.Add(image2);
-        collection.Add(image3);
-        Color color1 = ((Bitmap)collection[0]).GetPixel(0, 0);
-        Color color2 = ((Bitmap)collection[1]).GetPixel(0, 0);
-        Color color3 = ((Bitmap)collection[2]).GetPixel(0, 0);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color1, ((Bitmap)collection[0]).GetPixel(0, 0));
-        Assert.Equal(color3, ((Bitmap)collection[1]).GetPixel(0, 0));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color3, ((Bitmap)collection[0]).GetPixel(0, 0));
-
-        // Remove last.
-        collection.RemoveAt(0);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageCollection_RemoveAt_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_RemoveByKey_InvokeWithoutHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        using var image3 = new Bitmap(3, 4);
-        image3.SetPixel(0, 0, Color.Yellow);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("image1", image1);
-        collection.Add("image2", image2);
-        collection.Add("image3", image3);
-
-        // Remove middle.
-        collection.RemoveByKey("image2");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-
-        // Call again.
-        collection.RemoveByKey("image2");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-
-        // Remove first.
-        collection.RemoveByKey("image1");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-
-        // Remove last.
-        collection.RemoveByKey("IMAGE3");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-    }
-
-    [WinFormsFact]
-    public void ImageListCollection_RemoveByKey_InvokeWithHandleNotEmpty_Success()
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        using var image3 = new Bitmap(3, 4);
-        image3.SetPixel(0, 0, Color.Yellow);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("image1", image1);
-        collection.Add("image2", image2);
-        collection.Add("image3", image3);
-        Color color1 = ((Bitmap)collection[0]).GetPixel(0, 0);
-        Color color2 = ((Bitmap)collection[1]).GetPixel(0, 0);
-        Color color3 = ((Bitmap)collection[2]).GetPixel(0, 0);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Remove middle.
-        collection.RemoveByKey("image2");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color1, ((Bitmap)collection[0]).GetPixel(0, 0));
-        Assert.Equal(color3, ((Bitmap)collection[1]).GetPixel(0, 0));
-
-        // Call again.
-        collection.RemoveByKey("image2");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(2, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color1, ((Bitmap)collection[0]).GetPixel(0, 0));
-        Assert.Equal(color3, ((Bitmap)collection[1]).GetPixel(0, 0));
-
-        // Remove first.
-        collection.RemoveByKey("image1");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(1, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color3, ((Bitmap)collection[0]).GetPixel(0, 0));
-
-        // Remove last.
-        collection.RemoveByKey("IMAGE3");
-        Assert.True(list.HandleCreated);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.Empty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchImage")]
-    public void ImageListCollection_RemoveByKey_InvokeNoSuchKey_Nop(string key)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        image1.SetPixel(0, 0, Color.Red);
-        using var image2 = new Bitmap(3, 4);
-        image2.SetPixel(0, 0, Color.Blue);
-        using var image3 = new Bitmap(3, 4);
-        image3.SetPixel(0, 0, Color.Yellow);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("image1", image1);
-        collection.Add("image2", image2);
-        collection.Add("image3", image3);
-        Color color1 = ((Bitmap)collection[0]).GetPixel(0, 0);
-        Color color2 = ((Bitmap)collection[1]).GetPixel(0, 0);
-        Color color3 = ((Bitmap)collection[2]).GetPixel(0, 0);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.RemoveByKey(key);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(3, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color1, ((Bitmap)collection[0]).GetPixel(0, 0));
-        Assert.Equal(color2, ((Bitmap)collection[1]).GetPixel(0, 0));
-        Assert.Equal(color3, ((Bitmap)collection[2]).GetPixel(0, 0));
-
-        // Call again.
-        collection.RemoveByKey(key);
-        Assert.True(list.HandleCreated);
-        Assert.Equal(3, collection.Count);
-        Assert.False(collection.Empty);
-        Assert.Equal(color1, ((Bitmap)collection[0]).GetPixel(0, 0));
-        Assert.Equal(color2, ((Bitmap)collection[1]).GetPixel(0, 0));
-        Assert.Equal(color3, ((Bitmap)collection[2]).GetPixel(0, 0));
-    }
-
-    public static IEnumerable<object[]> SetKeyName_TestData()
-    {
-        yield return new object[] { 0, null, new string[] { string.Empty, string.Empty } };
-        yield return new object[] { 0, string.Empty, new string[] { string.Empty, string.Empty } };
-        yield return new object[] { 0, "name", new string[] { "name", string.Empty } };
-
-        yield return new object[] { 1, null, new string[] { "KeyName", string.Empty } };
-        yield return new object[] { 1, string.Empty, new string[] { "KeyName", string.Empty } };
-        yield return new object[] { 1, "name", new string[] { "KeyName", "name" } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetKeyName_TestData))]
-    public void ImageCollection_SetKeyName_InvokeWithoutHandle_Success(int index, string name, string[] expectedKeys)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        using var image2 = new Bitmap(3, 4);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("KeyName", image1);
-        collection.Add(image2);
-
-        collection.SetKeyName(index, name);
-        Assert.Equal(expectedKeys, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-
-        // Set again.
-        collection.SetKeyName(index, name);
-        Assert.Equal(expectedKeys, collection.Keys.Cast<string>());
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetKeyName_TestData))]
-    public void ImageCollection_SetKeyNameWithHandle_InvokeWithoutHandle_Success(int index, string name, string[] expectedKeys)
-    {
-        using var list = new ImageList();
-        using var image1 = new Bitmap(1, 2);
-        using var image2 = new Bitmap(3, 4);
-        ImageList.ImageCollection collection = list.Images;
-        collection.Add("KeyName", image1);
-        collection.Add(image2);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        collection.SetKeyName(index, name);
-        Assert.Equal(expectedKeys, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-
-        // Set again.
-        collection.SetKeyName(index, name);
-        Assert.Equal(expectedKeys, collection.Keys.Cast<string>());
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageCollection_SetKeyName_InvalidIndexEmpty_ThrowsIndexOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<IndexOutOfRangeException>(() => collection.SetKeyName(index, "name"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageCollection_SetKeyName_InvalidIndexNotEmpty_ThrowsIndexOutOfRangeException(int index)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        ImageList.ImageCollection collection = list.Images;
-        Assert.Throws<IndexOutOfRangeException>(() => collection.SetKeyName(index, "name"));
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_IListIsFixedSize_GetReturnsExpected()
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.False(collection.IsFixedSize);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_ICollectionIsSynchronized_GetReturnsExpected()
-    {
-        using var list = new ImageList();
-        ICollection collection = list.Images;
-        Assert.False(collection.IsSynchronized);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_ICollectionSyncRoot_GetReturnsExpected()
-    {
-        using var list = new ImageList();
-        ICollection collection = list.Images;
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Item_Set_TestData))]
-    public void ImageCollection_IListItem_Set_GetReturnsExpected(Color transparentColor, Image value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        list.Images.Add(image);
-        IList collection = list.Images;
-
-        collection[0] = value;
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap = Assert.IsType<Bitmap>(collection[0]);
-        Assert.NotSame(value, bitmap);
-        Assert.Equal(new Size(16, 16), bitmap.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Item_Set_TestData))]
-    public void ImageCollection_IListItem_SetWithHandle_GetReturnsExpected(Color transparentColor, Image value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList
-        {
-            TransparentColor = transparentColor
-        };
-        list.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-        IList collection = list.Images;
-
-        collection[0] = value;
-        Assert.True(list.HandleCreated);
-
-        Bitmap bitmap = Assert.IsType<Bitmap>(collection[0]);
-        Assert.Equal(new Size(16, 16), bitmap.Size);
-        Assert.Equal(PixelFormat.Format32bppArgb, bitmap.PixelFormat);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageCollection_IListItem_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-
-        using var value = new Bitmap(1, 2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageCollection_IListItem_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        IList collection = list.Images;
-
-        using var value = new Bitmap(1, 2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = image);
-    }
-
-    public static IEnumerable<object[]> IListItem_SetNonImageValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListItem_SetNonImageValue_TestData))]
-    public void ImageCollection_IListItem_SetNullValue_ThrowsArgumentException(object value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        IList collection = list.Images;
-
-        Assert.Throws<ArgumentException>("value", () => collection[0] = value);
-    }
-
-    [WinFormsFact]
-    public void ImageCollection_IListItem_SetNonBitmapValue_ThrowsArgumentException()
-    {
-        using var image = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(image);
-        IList collection = list.Images;
-
-        using var value = new Metafile("bitmaps/telescope_01.wmf");
-        Assert.Throws<ArgumentException>(() => collection[0] = value);
-    }
-
-    public static IEnumerable<object[]> IListContains_Image_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListContains_Image_TestData))]
-    public void ImageCollection_IListContains_InvokeImage_ThrowsNotSupportedException(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.Contains(value));
-    }
-
-    public static IEnumerable<object[]> IListContains_NotImage_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListContains_NotImage_TestData))]
-    public void ImageCollection_IListContains_InvokeNotImage_ReturnsFalse(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.False(collection.Contains(value));
-    }
-
-    public static IEnumerable<object[]> IListIndexOf_Image_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListIndexOf_Image_TestData))]
-    public void ImageCollection_IListIndexOf_InvokeImage_ThrowsNotSupportedException(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.IndexOf(value));
-    }
-
-    public static IEnumerable<object[]> IListIndexOf_NotImage_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListIndexOf_NotImage_TestData))]
-    public void ImageCollection_IListIndexOf_InvokeNotImage_ReturnsExpected(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.Equal(-1, collection.IndexOf(value));
-    }
-
-    public static IEnumerable<object[]> IListInsert_TestData()
-    {
-        foreach (int index in new int[] { -1, 0, 1 })
-        {
-            yield return new object[] { index, null };
-            yield return new object[] { index, new object() };
-            yield return new object[] { index, new Bitmap(10, 10) };
-            yield return new object[] { index, new Metafile("bitmaps/telescope_01.wmf") };
-            yield return new object[] { index, new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListInsert_TestData))]
-    public void ImageCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, value));
-    }
-
-    public static IEnumerable<object[]> IListRemove_Image_TestData()
-    {
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { new Metafile("bitmaps/telescope_01.wmf") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_Image_TestData))]
-    public void ImageCollection_IListRemove_InvokeImage_ThrowsNotSupportedException(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        Assert.Throws<NotSupportedException>(() => collection.Remove(value));
-    }
-
-    public static IEnumerable<object[]> IListRemove_NotImage_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_NotImage_TestData))]
-    public void ImageCollection_IListRemove_InvokeNotImage_Nop(object value)
-    {
-        using var list = new ImageList();
-        IList collection = list.Images;
-        collection.Remove(value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.NativeImageListTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.NativeImageListTests.cs
deleted file mode 100644
index 57b4b265b85..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageList.NativeImageListTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ImageList;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_NativeImageListTests
-{
-    [WinFormsFact]
-    public void NativeImageList_Dispose_releases_native_handle()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using ImageListStreamer result = BinarySerialization.EnsureDeserialize<ImageListStreamer>(ClassicImageListStreamer);
-
-        NativeImageList nativeImageList = result.GetNativeImageList();
-        Assert.NotEqual(HIMAGELIST.Null, nativeImageList.HIMAGELIST);
-
-        nativeImageList.Dispose();
-        Assert.Equal(HIMAGELIST.Null, nativeImageList.HIMAGELIST);
-    }
-
-    private const string ClassicImageListStreamer =
-        "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";
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListStreamerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListStreamerTests.cs
deleted file mode 100644
index c8c2e0a1fdd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListStreamerTests.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ImageList;
-
-namespace System.Windows.Forms.Tests;
-
-public class ImageListStreamerTests
-{
-    [WinFormsFact]
-    public void ImageListStreamer_BinaryFormatter_Stream_BinaryFormatter_round_trip_equality()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-
-        // Create an ImageListStreamer via BinaryFormatter
-        using ImageListStreamer streamerFromBf = BinarySerialization.EnsureDeserialize<ImageListStreamer>(ClassicBfImageListStreamer);
-        using NativeImageList nativeImageListBf = streamerFromBf.GetNativeImageList();
-        Assert.NotEqual(HIMAGELIST.Null, nativeImageListBf.HIMAGELIST);
-
-        // Read as a memory stream
-        using MemoryStream ms = new();
-        streamerFromBf.GetObjectData(ms);
-        string msBase64 = Convert.ToBase64String(ms.ToArray());
-
-        // Create a new ImageListStreamer from the stream
-        ms.Position = 0;
-        using ImageListStreamer streamerFromMs = new(ms);
-        using NativeImageList nativeImageListMs = streamerFromMs.GetNativeImageList();
-        Assert.NotEqual(HIMAGELIST.Null, nativeImageListMs.HIMAGELIST);
-
-        // Compare the two
-        using ImageList imageListBf = new();
-        imageListBf.ImageStream = streamerFromBf;
-        using ImageList imageListMs = new();
-        imageListMs.ImageStream = streamerFromMs;
-
-        Assert.Equal(imageListBf.ColorDepth, imageListMs.ColorDepth);
-        Assert.Equal(imageListBf.Images.Count, imageListMs.Images.Count);
-        Assert.Equal(imageListBf.ImageSize, imageListMs.ImageSize);
-    }
-
-    [WinFormsFact]
-    public void ImageListStreamer_Stream_BinaryFormatter_compatible()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-
-        // Create a new ImageListStreamer from the stream
-        byte[] bytes = Convert.FromBase64String(DevMsImageListStreamer);
-        using MemoryStream ms = new(bytes);
-        using ImageListStreamer streamerFromMs = new(ms);
-        using NativeImageList nativeImageListMs = streamerFromMs.GetNativeImageList();
-        Assert.NotEqual(HIMAGELIST.Null, nativeImageListMs.HIMAGELIST);
-
-        // Create an ImageListStreamer via BinaryFormatter
-        using ImageListStreamer streamerFromBf = BinarySerialization.EnsureDeserialize<ImageListStreamer>(ClassicBfImageListStreamer);
-        using NativeImageList nativeImageListBf = streamerFromBf.GetNativeImageList();
-        Assert.NotEqual(HIMAGELIST.Null, nativeImageListBf.HIMAGELIST);
-
-        // Compare the two
-        using ImageList imageListBf = new();
-        imageListBf.ImageStream = streamerFromBf;
-        using ImageList imageListMs = new();
-        imageListMs.ImageStream = streamerFromMs;
-
-        Assert.Equal(imageListBf.ColorDepth, imageListMs.ColorDepth);
-        Assert.Equal(imageListBf.Images.Count, imageListMs.Images.Count);
-        Assert.Equal(imageListBf.ImageSize, imageListMs.ImageSize);
-    }
-
-    private const string ClassicBfImageListStreamer =
-        "AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAAqBwAAAk1TRnQBSQFMAwEBAAEIAQABCAEAARABAAEQAQAE/wEJAQAI/wFCAU0BNgEEBgABNgEEAgABKAMAAUADAAEQAwABAQEAAQgGAAEEGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHAAdwBwAEAAfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANCAQADOQEAAYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ATMDAAFmAwABmQMAAcwCAAEzAwACMwIAATMBZgIAATMBmQIAATMBzAIAATMB/wIAAWYDAAFmATMCAAJmAgABZgGZAgABZgHMAgABZgH/AgABmQMAAZkBMwIAAZkBZgIAApkCAAGZAcwCAAGZAf8CAAHMAwABzAEzAgABzAFmAgABzAGZAgACzAIAAcwB/wIAAf8BZgIAAf8BmQIAAf8BzAEAATMB/wIAAf8BAAEzAQABMwEAAWYBAAEzAQABmQEAATMBAAHMAQABMwEAAf8BAAH/ATMCAAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/AQABMwFmAgABMwFmATMBAAEzAmYBAAEzAWYBmQEAATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEAATMBmQFmAQABMwKZAQABMwGZAcwBAAEzAZkB/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEAATMCzAEAATMBzAH/AQABMwH/ATMBAAEzAf8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEAATMBAAFmAQABZgEAAWYBAAGZAQABZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEzAZkBAAFmATMBzAEAAWYBMwH/AQACZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEAAWYBmQFmAQABZgKZAQABZgGZAcwBAAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFmAcwB/wEAAWYB/wIAAWYB/wEzAQABZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEzAZkBAAGZAQABmQEAAZkBAAHMAQABmQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIAAZkBZgEzAQABmQEzAWYBAAGZAWYBmQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHMAQACmQH/AQABmQHMAgABmQHMATMBAAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZAf8BMwEAAZkBzAFmAQABmQH/AZkBAAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQABzAEAAZkBAAHMAQABzAEAAZkBMwIAAcwCMwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/AQABzAFmAgABzAFmATMBAAGZAmYBAAHMAWYBmQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkBMwEAAcwBmQFmAQABzAKZAQABzAGZAcwBAAHMAZkB/wEAAswCAALMATMBAALMAWYBAALMAZkBAAPMAQACzAH/AQABzAH/AgABzAH/ATMBAAGZAf8BZgEAAcwB/wGZAQABzAH/AcwBAAHMAv8BAAHMAQABMwEAAf8BAAFmAQAB/wEAAZkBAAHMATMCAAH/AjMBAAH/ATMBZgEAAf8BMwGZAQAB/wEzAcwBAAH/ATMB/wEAAf8BZgIAAf8BZgEzAQABzAJmAQAB/wFmAZkBAAH/AWYBzAEAAcwBZgH/AQAB/wGZAgAB/wGZATMBAAH/AZkBZgEAAf8CmQEAAf8BmQHMAQAB/wGZAf8BAAH/AcwCAAH/AcwBMwEAAf8BzAFmAQAB/wHMAZkBAAH/AswBAAH/AcwB/wEAAv8BMwEAAcwB/wFmAQAC/wGZAQAC/wHMAQACZgH/AQABZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEAAv8BZgEAASEBAAGlAQADXwEAA3cBAAOGAQADlgEAA8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4AQAB8AH7Af8BAAGkAqABAAOAAwAB/wIAAf8DAAL/AQAB/wMAAf8BAAH/AQAC/wIAA///AP8A/wD/AAUAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/8BAAL/BgAC/wYAAv8GAAL/BgAC/wYAAv8GAAL/BgAC/wYAAv8GAAL/BgAC/wYAAv8GAAL/BgAC/wYAAv8GAAL/BgAL";
-
-    // Base64-reencoded streamer using GetObjectData(Stream) from a decoded ClassicBfImageListStreamer
-    private const string DevMsImageListStreamer =
-        "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";
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListTests.cs
deleted file mode 100644
index 5ef5569fe94..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ImageListTests.cs
+++ /dev/null
@@ -1,1058 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // ImageList doesn't appear to behave well under stress in multi-threaded env
-public class ImageListTests
-{
-    [WinFormsFact]
-    public void ImageList_Ctor_Default()
-    {
-        using var list = new ImageList();
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Null(list.Container);
-        Assert.Empty(list.Images);
-        Assert.Same(list.Images, list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.Null(list.ImageStream);
-        Assert.Null(list.Site);
-        Assert.Null(list.Tag);
-        Assert.Equal(Color.Transparent, list.TransparentColor);
-
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Ctor_IContainer()
-    {
-        var container = new Container();
-        using var list = new ImageList(container);
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Same(container, list.Container);
-        Assert.Empty(list.Images);
-        Assert.Same(list.Images, list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.Null(list.ImageStream);
-        Assert.NotNull(list.Site);
-        Assert.Null(list.Tag);
-        Assert.Equal(Color.Transparent, list.TransparentColor);
-
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Ctor_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new ImageList(null));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ColorDepth_SetWithoutHandle_GetReturnsExpected(ColorDepth value)
-    {
-        using var list = new ImageList
-        {
-            ColorDepth = value
-        };
-        Assert.Equal(value, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-
-        // Set same.
-        list.ColorDepth = value;
-        Assert.Equal(value, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ColorDepth_SetWithoutHandleWithHandler_DoesNotCallRecreateHandle()
-    {
-        using var list = new ImageList();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        list.RecreateHandle += handler;
-
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        list.ColorDepth = ColorDepth.Depth16Bit;
-        Assert.Equal(ColorDepth.Depth16Bit, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.False(list.HandleCreated);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ColorDepth_SetWithHandle_GetReturnsExpected(ColorDepth value)
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.ColorDepth = value;
-        Assert.Equal(value, list.ColorDepth);
-        Assert.True(list.HandleCreated);
-
-        // Set same.
-        list.ColorDepth = value;
-        Assert.Equal(value, list.ColorDepth);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ColorDepth_SetWithHandleWithHandler_CallsRecreateHandle()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(list, sender);
-            //Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        list.RecreateHandle += handler;
-
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.Equal(1, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set same.
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.Equal(1, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set different.
-        list.ColorDepth = ColorDepth.Depth16Bit;
-        Assert.Equal(ColorDepth.Depth16Bit, list.ColorDepth);
-        Assert.Equal(2, callCount);
-        Assert.True(list.HandleCreated);
-        IntPtr handle3 = list.Handle;
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.ColorDepth = ColorDepth.Depth24Bit;
-        Assert.Equal(ColorDepth.Depth24Bit, list.ColorDepth);
-        Assert.Equal(2, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ColorDepth_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.ColorDepth)];
-        using var list = new ImageList();
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.True(property.CanResetValue(list));
-
-        list.ColorDepth = ColorDepth.Depth8Bit;
-        Assert.Equal(ColorDepth.Depth8Bit, list.ColorDepth);
-        Assert.True(property.CanResetValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.True(property.CanResetValue(list));
-    }
-
-    [WinFormsFact]
-    public void ImageList_ColorDepth_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.ColorDepth)];
-        using var list = new ImageList();
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        list.ColorDepth = ColorDepth.Depth8Bit;
-        Assert.Equal(ColorDepth.Depth8Bit, list.ColorDepth);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        // With images.
-        list.Images.Add(new Bitmap(10, 10));
-        Assert.False(property.ShouldSerializeValue(list));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_Handle_Get_CreatesHandle(ColorDepth colorDepth)
-    {
-        using var list = new ImageList
-        {
-            ColorDepth = colorDepth
-        };
-        IntPtr handle = list.Handle;
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Equal(handle, list.Handle);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ColorDepth>]
-    public void ImageList_ColorDepth_SetInvalid_ThrowsInvalidEnumArgumentException(ColorDepth value)
-    {
-        using var list = new ImageList();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => list.ColorDepth = value);
-    }
-
-    public static IEnumerable<object[]> ImageSize_TestData()
-    {
-        yield return new object[] { new Size(16, 16) };
-        yield return new object[] { new Size(17, 16) };
-        yield return new object[] { new Size(16, 17) };
-        yield return new object[] { new Size(24, 25) };
-        yield return new object[] { new Size(256, 26) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageSize_TestData))]
-    public void ImageList_ImageSize_SetWithoutHandle_GetReturnsExpected(Size value)
-    {
-        using var list = new ImageList
-        {
-            ImageSize = value
-        };
-        Assert.Equal(value, list.ImageSize);
-        Assert.False(list.HandleCreated);
-
-        // Set same.
-        list.ImageSize = value;
-        Assert.Equal(value, list.ImageSize);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageSize_SetWithoutHandleWithHandler_DoesNotCallRecreateHandle()
-    {
-        using var list = new ImageList();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        list.RecreateHandle += handler;
-
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Set same.
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Set different.
-        list.ImageSize = new Size(11, 11);
-        Assert.Equal(new Size(11, 11), list.ImageSize);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageSize_TestData))]
-    public void ImageList_ImageSize_SetWithHandle_GetReturnsExpected(Size value)
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.ImageSize = value;
-        Assert.Equal(value, list.ImageSize);
-        Assert.True(list.HandleCreated);
-
-        // Set same.
-        list.ImageSize = value;
-        Assert.Equal(value, list.ImageSize);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageSize_SetWithHandleWithHandler_CallsRecreateHandle()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(list, sender);
-            //Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        list.RecreateHandle += handler;
-
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(1, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set same.
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(1, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set different width.
-        list.ImageSize = new Size(11, 10);
-        Assert.Equal(new Size(11, 10), list.ImageSize);
-        Assert.Equal(2, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set different height.
-        list.ImageSize = new Size(11, 11);
-        Assert.Equal(new Size(11, 11), list.ImageSize);
-        Assert.Equal(3, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set different width and height.
-        list.ImageSize = new Size(12, 12);
-        Assert.Equal(new Size(12, 12), list.ImageSize);
-        Assert.Equal(4, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.ImageSize = new Size(10, 10);
-        Assert.Equal(new Size(10, 10), list.ImageSize);
-        Assert.Equal(4, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageSize_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.ImageSize)];
-        using var list = new ImageList();
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(property.CanResetValue(list));
-
-        list.ImageSize = new Size(32, 32);
-        Assert.Equal(new Size(32, 32), list.ImageSize);
-        Assert.True(property.CanResetValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(property.CanResetValue(list));
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageSize_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.ImageSize)];
-        using var list = new ImageList();
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        list.ImageSize = new Size(32, 32);
-        Assert.Equal(new Size(32, 32), list.ImageSize);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        // With images.
-        list.Images.Add(new Bitmap(10, 10));
-        Assert.False(property.ShouldSerializeValue(list));
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageSize_SetEmpty__ThrowsArgumentException()
-    {
-        using var list = new ImageList();
-        Assert.Throws<ArgumentException>("value", () => list.ImageSize = Size.Empty);
-    }
-
-    public static IEnumerable<object[]> ImageSize_SetInvalidDimension_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { -1 };
-        yield return new object[] { 257 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageSize_SetInvalidDimension_TestData))]
-    public void ImageList_ImageSize_SetInvalidWidth_ThrowsArgumentOutOfRangeException(int width)
-    {
-        using var list = new ImageList();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => list.ImageSize = new Size(width, 1));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageSize_SetInvalidDimension_TestData))]
-    public void ImageList_ImageSize_SetInvalidHeight_ThrowsArgumentOutOfRangeException(int height)
-    {
-        using var list = new ImageList();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => list.ImageSize = new Size(1, height));
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageStream_GetWithImages_ReturnsExpected()
-    {
-        using var list = new ImageList();
-        list.Images.Add(new Bitmap(10, 10));
-        Assert.NotNull(list.ImageStream);
-        Assert.NotSame(list.ImageStream, list.ImageStream);
-        Assert.False(list.HandleCreated);
-    }
-
-    private static T RoundtripSerialize<T>(T source)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var stream = new MemoryStream();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        var formatter = new BinaryFormatter();
-        formatter.Serialize(stream, source);
-        stream.Position = 0;
-        return (T)formatter.Deserialize(stream);
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetStreamerSerialized_UpdatesImages(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        using var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        using ImageListStreamer stream = RoundtripSerialize(sourceList.ImageStream);
-        Assert.True(sourceList.HandleCreated);
-
-        using var list = new ImageList();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        list.RecreateHandle += handler;
-
-        list.ImageStream = stream;
-        Assert.Equal(colorDepth, list.ColorDepth);
-        Assert.Equal(new Size(32, 32), ((Image)Assert.Single(list.Images)).Size);
-        Assert.Equal(new Size(32, 32), list.ImageSize);
-        Assert.Equal(0, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.True(sourceList.HandleCreated);
-
-        // Set same.
-        list.ImageStream = stream;
-        Assert.Equal(colorDepth, list.ColorDepth);
-        Assert.Equal(new Size(32, 32), ((Image)Assert.Single(list.Images)).Size);
-        Assert.Equal(new Size(32, 32), list.ImageSize);
-        Assert.Equal(1, callCount);
-        Assert.True(list.HandleCreated);
-        Assert.True(sourceList.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetStreamerSerializedDisposed_Nop(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        ImageListStreamer stream = RoundtripSerialize(sourceList.ImageStream);
-        Assert.True(sourceList.HandleCreated);
-        stream.Dispose();
-        Assert.True(sourceList.HandleCreated);
-
-        using var list = new ImageList
-        {
-            ImageStream = stream
-        };
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Empty(list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.False(list.HandleCreated);
-        Assert.True(sourceList.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetStreamerHasHandleNotSerialized_UpdatesImages(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, sourceList.Handle);
-        ImageListStreamer stream = sourceList.ImageStream;
-
-        using var list = new ImageList
-        {
-            ImageStream = stream
-        };
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Empty(list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.False(list.HandleCreated);
-        Assert.True(sourceList.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetWithHandleStreamerHasHandleNotSerialized_Nop(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, sourceList.Handle);
-        ImageListStreamer stream = sourceList.ImageStream;
-
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.ImageStream = stream;
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Empty(list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(list.HandleCreated);
-        Assert.True(sourceList.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetStreamerHasNoHandleNotSerialized_Nop(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        ImageListStreamer stream = sourceList.ImageStream;
-
-        using var list = new ImageList
-        {
-            ImageStream = stream
-        };
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Empty(list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.False(list.HandleCreated);
-        Assert.False(sourceList.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColorDepth>]
-    public void ImageList_ImageStream_SetWithHandleStreamerHasNoHandleNotSerialized_Nop(ColorDepth colorDepth)
-    {
-        using var sourceList = new ImageList
-        {
-            ColorDepth = colorDepth,
-            ImageSize = new Size(32, 32)
-        };
-        var image = new Bitmap(10, 10);
-        sourceList.Images.Add(image);
-        ImageListStreamer stream = sourceList.ImageStream;
-
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.ImageStream = stream;
-        Assert.Equal(ColorDepth.Depth32Bit, list.ColorDepth);
-        Assert.Empty(list.Images);
-        Assert.Equal(new Size(16, 16), list.ImageSize);
-        Assert.True(list.HandleCreated);
-        Assert.False(sourceList.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageStream_SetNull_ClearsImages()
-    {
-        using var list = new ImageList();
-
-        // Set null without images.
-        list.ImageStream = null;
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-
-        // Set null with images.
-        list.Images.Add(new Bitmap(10, 10));
-        list.ImageStream = null;
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_ImageStream_SetNullWithHandle_ClearsImages()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        // Set null without images.
-        list.ImageStream = null;
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-
-        // Set null with images.
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-        list.Images.Add(new Bitmap(10, 10));
-        list.ImageStream = null;
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ImageList_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var list = new ImageList
-        {
-            Tag = value
-        };
-        Assert.Equal(value, list.Tag);
-
-        // Set same.
-        list.Tag = value;
-        Assert.Equal(value, list.Tag);
-    }
-
-    public static IEnumerable<object[]> TransparentColor_Set_TestData()
-    {
-        foreach (object[] testData in CommonTestHelper.GetColorWithEmptyTheoryData())
-        {
-            yield return testData;
-        }
-
-        yield return new object[] { Color.LightGray };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparentColor_Set_TestData))]
-    public void ImageList_TransparentColor_SetWithoutHandle_GetReturnsExpected(Color value)
-    {
-        using var list = new ImageList
-        {
-            TransparentColor = value
-        };
-        Assert.Equal(value, list.TransparentColor);
-        Assert.False(list.HandleCreated);
-
-        // Set same.
-        list.TransparentColor = value;
-        Assert.Equal(value, list.TransparentColor);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_TransparentColor_SetWithoutHandleWithHandler_DoesNotCallRecreateHandle()
-    {
-        using var list = new ImageList();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        list.RecreateHandle += handler;
-
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Set same.
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Set different.
-        list.TransparentColor = Color.Blue;
-        Assert.Equal(Color.Blue, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TransparentColor_Set_TestData))]
-    public void ImageList_TransparentColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.TransparentColor = value;
-        Assert.Equal(value, list.TransparentColor);
-        Assert.True(list.HandleCreated);
-
-        // Set same.
-        list.TransparentColor = value;
-        Assert.Equal(value, list.TransparentColor);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_TransparentColor_SetWithHandleWithHandler_DoesNotCallRecreateHandle()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-        list.RecreateHandle += handler;
-
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.True(list.HandleCreated);
-
-        // Set same.
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.True(list.HandleCreated);
-
-        // Set different.
-        list.TransparentColor = Color.Blue;
-        Assert.Equal(Color.Blue, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.True(list.HandleCreated);
-
-        // Remove handler.
-        list.RecreateHandle -= handler;
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.Equal(0, callCount);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_TransparentColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.TransparentColor)];
-        using var list = new ImageList();
-        Assert.Equal(Color.Transparent, list.TransparentColor);
-        Assert.True(property.CanResetValue(list));
-
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.True(property.CanResetValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(Color.LightGray, list.TransparentColor);
-        Assert.False(property.CanResetValue(list));
-    }
-
-    [WinFormsFact]
-    public void ImageList_TransparentColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ImageList))[nameof(ImageList.TransparentColor)];
-        using var list = new ImageList();
-        Assert.Equal(Color.Transparent, list.TransparentColor);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        list.TransparentColor = Color.Red;
-        Assert.Equal(Color.Red, list.TransparentColor);
-        Assert.True(property.ShouldSerializeValue(list));
-
-        property.ResetValue(list);
-        Assert.Equal(Color.LightGray, list.TransparentColor);
-        Assert.False(property.ShouldSerializeValue(list));
-
-        // With images.
-        list.Images.Add(new Bitmap(10, 10));
-        Assert.False(property.ShouldSerializeValue(list));
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_InvokeEmptyWithoutHandle_Nop()
-    {
-        using var list = new ImageList();
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_InvokeWithIconsWithoutHandle_Success()
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var bitmap = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(icon);
-        list.Images.Add(bitmap);
-
-        list.Dispose();
-        Assert.False(list.HandleCreated);
-        Assert.Throws<ObjectDisposedException>(() => list.Images.GetEnumerator());
-        Assert.Equal(0, list.Images.Count);
-        Assert.True(list.HandleCreated);
-
-        // Call again.
-        list.Dispose();
-        Assert.False(list.HandleCreated);
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_InvokeWithoutIconsWithoutHandle_Success()
-    {
-        using var bitmap1 = new Bitmap(10, 10);
-        using var bitmap2 = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(bitmap1);
-        list.Images.Add(bitmap2);
-
-        list.Dispose();
-        Assert.Equal(2, list.Images.Count);
-        Assert.False(list.HandleCreated);
-
-        // Call again.
-        list.Dispose();
-        Assert.Equal(2, list.Images.Count);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_InvokeEmptyWithHandle_Nop()
-    {
-        using var list = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_InvokeNotEmptyWithHandle_Success()
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var bitmap = new Bitmap(10, 10);
-        using var list = new ImageList();
-        list.Images.Add(icon);
-        list.Images.Add(bitmap);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-
-        // Call again.
-        list.Dispose();
-        Assert.Empty(list.Images);
-        Assert.False(list.HandleCreated);
-    }
-
-#if DEBUG
-    [WinFormsFact]
-    public void ImageList_Dispose_SetsIsDisposed()
-    {
-        using var list = new ImageList();
-        Assert.False(list.IsDisposed);
-
-        list.Dispose();
-        Assert.True(list.IsDisposed);
-    }
-#endif
-
-    public static IEnumerable<object[]> Draw_Point_TestData()
-    {
-        yield return new object[] { Point.Empty };
-        yield return new object[] { new Point(1, 2) };
-        yield return new object[] { new Point(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_Point_TestData))]
-    public void ImageList_Draw_InvokeGraphicsPointIntWithoutHandle_Success(Point pt)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, pt, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_Point_TestData))]
-    public void ImageList_Draw_InvokeGraphicsPointIntWithHandle_Success(Point pt)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, pt, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_Point_TestData))]
-    public void ImageList_Draw_InvokeGraphicsIntIntIntWithoutHandle_Success(Point pt)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, pt, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_Point_TestData))]
-    public void ImageList_Draw_InvokeGraphicsIntIntIntWithHandle_Success(Point pt)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, pt.X, pt.Y, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    public static IEnumerable<object[]> Draw_WithSize_TestData()
-    {
-        yield return new object[] { 0, 0, 10, 10 };
-        yield return new object[] { 1, 2, 3, 4 };
-        yield return new object[] { -1, -2, 3, 4 };
-        yield return new object[] { -1, -2, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_WithSize_TestData))]
-    public void ImageList_Draw_InvokeGraphicsIntIntIntIntIntWithoutHandle_Success(int x, int y, int width, int height)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, x, y, width, height, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Draw_WithSize_TestData))]
-    public void ImageList_Draw_InvokeGraphicsIntIntIntIntIntWithHandle_Success(int x, int y, int width, int height)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-        Assert.NotEqual(IntPtr.Zero, list.Handle);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        list.Draw(graphics, x, y, width, height, 0);
-        Assert.True(list.HandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Draw_NullG_ThrowsNullReferenceException()
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-        Assert.Throws<NullReferenceException>(() => list.Draw(null, Point.Empty, 0));
-        Assert.Throws<NullReferenceException>(() => list.Draw(null, 0, 0, 0));
-        Assert.Throws<NullReferenceException>(() => list.Draw(null, 0, 0, 10, 10, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageList_Draw_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, Point.Empty, index));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, 0, 0, index));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, 0, 0, 10, 10, index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ImageList_Draw_InvalidIndexNonEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var list = new ImageList();
-        using var image = new Bitmap(10, 10);
-        list.Images.Add(image);
-
-        using var sourceImage = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(sourceImage);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, Point.Empty, index));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, 0, 0, index));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => list.Draw(graphics, 0, 0, 10, 10, index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangedEventArgsTests.cs
deleted file mode 100644
index 76cd99f1614..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangedEventArgsTests.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class InputLanguageChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_CultureInfo_Byte_TestData()
-    {
-        yield return new object[] { new CultureInfo("en-US"), 0 };
-        yield return new object[] { new CultureInfo("en-US"), 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_CultureInfo_Byte_TestData))]
-    public void Ctor_CultureInfo_Byte(CultureInfo culture, byte charSet)
-    {
-        var e = new InputLanguageChangedEventArgs(culture, charSet);
-        Assert.Equal(InputLanguage.FromCulture(culture), e.InputLanguage);
-        Assert.Equal(culture, e.Culture);
-        Assert.Equal(charSet, e.CharSet);
-    }
-
-    [Fact]
-    public void Ctor_NullCultureInfo_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("culture", () => new InputLanguageChangedEventArgs((CultureInfo)null, 0));
-    }
-
-    public static IEnumerable<object[]> Ctor_NoSuchCultureInfo_TestData()
-    {
-        yield return new object[] { CultureInfo.InvariantCulture };
-        yield return new object[] { new CultureInfo("en") };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_NoSuchCultureInfo_TestData))]
-    public void Ctor_NoSuchCultureInfo_ThrowsArgumentException(CultureInfo culture)
-    {
-        Assert.Throws<ArgumentException>("culture", () => new InputLanguageChangedEventArgs(culture, 0));
-    }
-
-    public static IEnumerable<object[]> Ctor_InputLanguage_Byte_TestData()
-    {
-        yield return new object[] { InputLanguage.FromCulture(CultureInfo.InvariantCulture), 0 };
-        yield return new object[] { InputLanguage.FromCulture(new CultureInfo("en")), 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InputLanguage_Byte_TestData))]
-    public void Ctor_InputLanguage_Byte(InputLanguage inputLanguage, byte charSet)
-    {
-        if (inputLanguage is null)
-        {
-            // Couldn't get the language.
-            return;
-        }
-
-        var e = new InputLanguageChangedEventArgs(inputLanguage, charSet);
-        Assert.Equal(inputLanguage, e.InputLanguage);
-        Assert.Equal(inputLanguage.Culture, e.Culture);
-        Assert.Equal(charSet, e.CharSet);
-    }
-
-    [Fact]
-    public void Ctor_NullInputLanguage_ThrowsNullReferenceException()
-    {
-        Assert.Throws<ArgumentNullException>("inputLanguage", () => new InputLanguageChangedEventArgs((InputLanguage)null, 0));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangingEventArgsTests.cs
deleted file mode 100644
index 352dc517f1e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageChangingEventArgsTests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class InputLanguageChangingEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_CultureInfo_Bool_TestData()
-    {
-        yield return new object[] { new CultureInfo("en-US"), true };
-        yield return new object[] { new CultureInfo("en-US"), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_CultureInfo_Bool_TestData))]
-    public void Ctor_CultureInfo_Bool(CultureInfo culture, bool sysCharSet)
-    {
-        var e = new InputLanguageChangingEventArgs(culture, sysCharSet);
-        Assert.Equal(InputLanguage.FromCulture(culture), e.InputLanguage);
-        Assert.Equal(culture, e.Culture);
-        Assert.Equal(sysCharSet, e.SysCharSet);
-        Assert.False(e.Cancel);
-    }
-
-    [Fact]
-    public void Ctor_NullCultureInfo_ThrowsNullReferenceException()
-    {
-        Assert.Throws<ArgumentNullException>("culture", () => new InputLanguageChangingEventArgs((CultureInfo)null, true));
-    }
-
-    public static IEnumerable<object[]> Ctor_NoSuchCultureInfo_TestData()
-    {
-        yield return new object[] { CultureInfo.InvariantCulture };
-        yield return new object[] { new CultureInfo("en") };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_NoSuchCultureInfo_TestData))]
-    public void Ctor_NoSuchCultureInfo_ThrowsArgumentException(CultureInfo culture)
-    {
-        Assert.Throws<ArgumentException>("culture", () => new InputLanguageChangingEventArgs(culture, true));
-    }
-
-    public static IEnumerable<object[]> Ctor_InputLanguage_Bool_TestData()
-    {
-        yield return new object[] { InputLanguage.FromCulture(CultureInfo.InvariantCulture), true };
-        yield return new object[] { InputLanguage.FromCulture(new CultureInfo("en")), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InputLanguage_Bool_TestData))]
-    public void Ctor_InputLanguage_Bool(InputLanguage inputLanguage, bool sysCharSet)
-    {
-        if (inputLanguage is null)
-        {
-            // Couldn't get the language.
-            return;
-        }
-
-        var e = new InputLanguageChangingEventArgs(inputLanguage, sysCharSet);
-        Assert.Equal(inputLanguage, e.InputLanguage);
-        Assert.Equal(inputLanguage.Culture, e.Culture);
-        Assert.Equal(sysCharSet, e.SysCharSet);
-    }
-
-    [Fact]
-    public void Ctor_NullInputLanguage_ThrowsNullReferenceException()
-    {
-        Assert.Throws<ArgumentNullException>("inputLanguage", () => new InputLanguageChangingEventArgs((InputLanguage)null, true));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageTests.cs
deleted file mode 100644
index e08f8c521a3..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InputLanguageTests.cs
+++ /dev/null
@@ -1,241 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Globalization;
-using System.Reflection;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-[UseDefaultXunitCulture(SetUnmanagedUiThreadCulture = true)]
-public class InputLanguageTests
-{
-    [Fact]
-    public void InputLanguage_InstalledInputLanguages_Get_ReturnsExpected()
-    {
-        InputLanguageCollection collection = InputLanguage.InstalledInputLanguages;
-        Assert.NotSame(collection, InputLanguage.InstalledInputLanguages);
-        Assert.NotEmpty(collection);
-        Assert.All(collection.Cast<InputLanguage>(), VerifyInputLanguage);
-    }
-
-    [Fact]
-    public void InputLanguage_DefaultInputLanguage_Get_ReturnsExpected()
-    {
-        InputLanguage language = InputLanguage.DefaultInputLanguage;
-        Assert.NotSame(language, InputLanguage.DefaultInputLanguage);
-        VerifyInputLanguage(language);
-    }
-
-    [Fact]
-    public void InputLanguage_CurrentInputLanguage_Get_ReturnsExpected()
-    {
-        InputLanguage language = InputLanguage.CurrentInputLanguage;
-        Assert.NotSame(language, InputLanguage.CurrentInputLanguage);
-        VerifyInputLanguage(language);
-    }
-
-    [Fact]
-    public void InputLanguage_CurrentInputLanguage_Set_GetReturnsExpected()
-    {
-        InputLanguage language = InputLanguage.CurrentInputLanguage;
-        try
-        {
-            // Set null.
-            InputLanguage.CurrentInputLanguage = null;
-            Assert.Equal(InputLanguage.DefaultInputLanguage, InputLanguage.CurrentInputLanguage);
-
-            // Set other.
-            InputLanguage.CurrentInputLanguage = language;
-            Assert.Equal(language, InputLanguage.CurrentInputLanguage);
-
-            // Set same.
-            InputLanguage.CurrentInputLanguage = language;
-            Assert.Equal(language, InputLanguage.CurrentInputLanguage);
-        }
-        catch
-        {
-            InputLanguage.CurrentInputLanguage = language;
-        }
-    }
-
-    [Fact]
-    public void InputLanguage_CurrentInputLanguage_SetInvalidValue_ThrowsArgumentException()
-    {
-        InputLanguage language = Assert.IsType<InputLanguage>(Activator.CreateInstance(typeof(InputLanguage), BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { (IntPtr)250 }, null));
-        Assert.Throws<ArgumentException>("value", () => InputLanguage.CurrentInputLanguage = language);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { InputLanguage.DefaultInputLanguage, InputLanguage.DefaultInputLanguage, true };
-        yield return new object[] { InputLanguage.DefaultInputLanguage, new object(), false };
-        yield return new object[] { InputLanguage.DefaultInputLanguage, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void InputLanguage_Equals_Invoke_ReturnsExpected(InputLanguage language, object value, bool expected)
-    {
-        Assert.Equal(expected, language.Equals(value));
-    }
-
-    [Fact]
-    public void InputLanguage_FromCulture_Roundtrip_Success()
-    {
-        InputLanguage language = InputLanguage.CurrentInputLanguage;
-        InputLanguage result = InputLanguage.FromCulture(language.Culture);
-        Assert.NotSame(language, result);
-        Assert.Equal(language, result);
-        VerifyInputLanguage(result);
-    }
-
-    [Fact]
-    public void InputLanguage_FromCulture_NoSuchCulture_ReturnsNull()
-    {
-        var invariantCulture = CultureInfo.InvariantCulture;
-        Assert.Null(InputLanguage.FromCulture(invariantCulture));
-    }
-
-    [Fact]
-    public void InputLanguage_FromCulture_NullCulture_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("culture", () => InputLanguage.FromCulture(null));
-    }
-
-    [Fact]
-    public void InputLanguage_GetHashCode_Invoke_RemainsSameAcrossCalls()
-    {
-        InputLanguage language = InputLanguage.CurrentInputLanguage;
-        Assert.Equal(language.GetHashCode(), language.GetHashCode());
-    }
-
-    public static IEnumerable<object[]> InputLanguageLayoutId_TestData()
-    {
-        yield return new object[] { 0x0409, 0x0000, "en-US", "00000409", "US" };
-        yield return new object[] { 0x0409, 0x0409, "en-US", "00000409", "US" };
-        yield return new object[] { 0x0409, 0x040c, "en-US", "0000040C", "French" };
-        yield return new object[] { 0x0409, 0xf020, "en-US", "00011009", "Canadian Multilingual Standard" };
-        yield return new object[] { 0x0c0c, 0x1009, "fr-CA", "00001009", "Canadian French" };
-        yield return new object[] { 0x0c0c, 0xf020, "fr-CA", "00011009", "Canadian Multilingual Standard" };
-    }
-
-    [Theory]
-    [MemberData(nameof(InputLanguageLayoutId_TestData))]
-    public void InputLanguage_InputLanguageLayoutId_Expected(int langId, int device, string languageTag, string layoutId, string layoutName)
-    {
-        InputLanguage language = new(PARAM.FromLowHigh(langId, device));
-        VerifyInputLanguage(language, languageTag, layoutId, layoutName);
-    }
-
-    public static IEnumerable<object[]> SupplementalInputLanguages_TestData()
-    {
-        yield return new object[] { "got-Goth", "000C0C00", "Gothic" };
-        yield return new object[] { "jv-Java", "00110C00", "Javanese" };
-        // See https://github.com/dotnet/winforms/issues/10150
-        // yield return new object[] { "nqo", "00090C00", "N’Ko" };
-        yield return new object[] { "zgh-Tfng", "0000105F", "Tifinagh (Basic)" };
-    }
-
-    [Theory]
-    [MemberData(nameof(SupplementalInputLanguages_TestData))]
-    public void InputLanguage_FromCulture_SupplementalInputLanguages_Expected(string languageTag, string layoutId, string layoutName)
-    {
-        // This condition should be removed once https://github.com/dotnet/winforms/issues/10150 is resolved.
-        if (languageTag == "nqo" && !OsVersion.IsWindows11_22H2OrGreater())
-        {
-            return;
-        }
-
-        // Also installs default keyboard layout for this language
-        // https://learn.microsoft.com/windows-hardware/manufacture/desktop/default-input-locales-for-windows-language-packs
-        InstallUserLanguage(languageTag);
-
-        try
-        {
-            CultureInfo culture = new(languageTag);
-            InputLanguage language = InputLanguage.FromCulture(culture);
-            VerifyInputLanguage(language, languageTag, layoutId, layoutName);
-        }
-        finally
-        {
-            UninstallUserLanguage(languageTag);
-        }
-    }
-
-    [Theory]
-    [InlineData(0x0000, 0x0409)]
-    [InlineData(0xffff, 0x0409)]
-    public void InputLanguage_Culture_ThrowsArgumentException(int langId, int device)
-    {
-        InputLanguage language = new(PARAM.FromLowHigh(langId, device));
-        Assert.ThrowsAny<ArgumentException>(() => language.Culture);
-    }
-
-    [Theory]
-    [InlineData(0x0409, 0xf000)]
-    [InlineData(0x0409, 0xffff)]
-    public void InputLanguage_LayoutName_UnknownExpected(int langId, int device)
-    {
-        InputLanguage language = new(PARAM.FromLowHigh(langId, device));
-        Assert.Equal(SR.UnknownInputLanguageLayout, language.LayoutName);
-    }
-
-    private static void VerifyInputLanguage(InputLanguage language, string languageTag, string layoutId, string layoutName)
-    {
-        Assert.NotNull(language);
-        Assert.NotEqual(IntPtr.Zero, language.Handle);
-        Assert.Equal(languageTag, language.Culture.Name);
-        Assert.Equal(layoutId, language.LayoutId);
-        Assert.Equal(layoutName, language.LayoutName);
-    }
-
-    private static void VerifyInputLanguage(InputLanguage language)
-    {
-        Assert.NotEqual(IntPtr.Zero, language.Handle);
-        Assert.NotNull(language.Culture);
-        Assert.NotNull(language.LayoutName);
-        Assert.NotEmpty(language.LayoutName);
-        Assert.NotEqual(SR.UnknownInputLanguageLayout, language.LayoutName);
-        Assert.DoesNotContain('\0', language.LayoutName);
-    }
-
-    private static void RunPowerShellScript(string path)
-    {
-        using Process process = new();
-
-        process.StartInfo.FileName = "powershell.exe";
-        process.StartInfo.Arguments = $"-NoProfile -ExecutionPolicy ByPass -File \"{path}\"";
-
-        process.Start();
-        process.WaitForExit();
-    }
-
-    private static void InstallUserLanguage(string languageTag)
-    {
-        string file = Path.Combine(Path.GetTempPath(), $"install-language-{languageTag}.ps1");
-        string script = $$"""
-            $list = Get-WinUserLanguageList
-            $list.Add("{{languageTag}}")
-            Set-WinUserLanguageList $list -force
-            """;
-
-        using TempFile tempFile = new(file, script);
-        RunPowerShellScript(tempFile.Path);
-    }
-
-    private static void UninstallUserLanguage(string languageTag)
-    {
-        string file = Path.Combine(Path.GetTempPath(), $"uninstall-language-{languageTag}.ps1");
-        string script = $$"""
-            $list = Get-WinUserLanguageList
-            $item = $list | Where-Object {$_.LanguageTag -like "{{languageTag}}"}
-            $list.Remove($item)
-            Set-WinUserLanguageList $list -force
-            """;
-
-        using TempFile tempFile = new(file, script);
-        RunPowerShellScript(tempFile.Path);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InvalidateEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InvalidateEventArgsTests.cs
deleted file mode 100644
index dee3167be15..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/InvalidateEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class InvalidateEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_TestData))]
-    public void Ctor_Rectangle(Rectangle invalidRect)
-    {
-        var e = new InvalidateEventArgs(invalidRect);
-        Assert.Equal(invalidRect, e.InvalidRect);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemCheckedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemCheckedEventArgsTests.cs
deleted file mode 100644
index 7c99f1b7ed5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemCheckedEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ItemCheckedEventArgsTests
-{
-    [WinFormsFact]
-    public void ItemCheckedEventArgs_Ctor_NullListViewItem_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ItemCheckedEventArgs(null));
-    }
-
-    [WinFormsFact]
-    public void Ctor_ListViewItem()
-    {
-        ListViewItem listViewItem = new();
-        var e = new ItemCheckedEventArgs(listViewItem);
-        Assert.Equal(listViewItem, e.Item);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemDragEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemDragEventArgsTests.cs
deleted file mode 100644
index 9d4255c7af2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ItemDragEventArgsTests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ItemDragEventArgsTests
-{
-    [Theory]
-    [InlineData(MouseButtons.Left)]
-    [InlineData((MouseButtons)(MouseButtons.None - 1))]
-    public void Ctor_MouseButtons(MouseButtons button)
-    {
-        var e = new ItemDragEventArgs(button);
-        Assert.Equal(button, e.Button);
-        Assert.Null(e.Item);
-    }
-
-    [Theory]
-    [InlineData(MouseButtons.Left, 1)]
-    [InlineData((MouseButtons)(MouseButtons.None - 1), null)]
-    public void Ctor_MouseButtons_Object(MouseButtons button, object item)
-    {
-        var e = new ItemDragEventArgs(button, item);
-        Assert.Equal(button, e.Button);
-        Assert.Equal(item, e.Item);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyEventArgsTests.cs
deleted file mode 100644
index 4f03a113b30..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyEventArgsTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class KeyEventArgsTests
-{
-    [Theory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Control | Keys.A)]
-    [InlineData(Keys.Alt | Keys.A)]
-    [InlineData(Keys.Shift | Keys.A)]
-    [InlineData(Keys.Control)]
-    [InlineData(Keys.Alt)]
-    [InlineData(Keys.Shift)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.A)]
-    [InlineData((Keys)(-1))]
-    [InlineData((Keys)(0x5D))]
-    [InlineData((Keys)(0xFF))]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | (Keys)(0x5D))]
-    public void Ctor_Keys(Keys keyData)
-    {
-        var e = new KeyEventArgs(keyData);
-        Assert.Equal(keyData, e.KeyData);
-        Assert.Equal((keyData & Keys.Control) == Keys.Control, e.Control);
-        Assert.Equal((keyData & Keys.Alt) == Keys.Alt, e.Alt);
-        Assert.Equal((keyData & Keys.Shift) == Keys.Shift, e.Shift);
-        Assert.Equal((keyData & Keys.Modifiers), e.Modifiers);
-        Assert.Equal((int)(keyData & Keys.KeyCode), e.KeyValue);
-        Assert.False(e.Handled);
-        Assert.False(e.SuppressKeyPress);
-
-        if (Enum.IsDefined(typeof(Keys), e.KeyValue))
-        {
-            Assert.Equal((Keys)e.KeyValue, e.KeyCode);
-        }
-        else
-        {
-            Assert.Equal(Keys.None, e.KeyCode);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Handled_Set_GetReturnsExpected(bool value)
-    {
-        var e = new KeyEventArgs(Keys.A)
-        {
-            SuppressKeyPress = !value,
-            Handled = value
-        };
-        Assert.Equal(value, e.Handled);
-        Assert.Equal(!value, e.SuppressKeyPress);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void SuppressKeyPress_Set_GetReturnsExpected(bool value)
-    {
-        var e = new KeyEventArgs(Keys.A)
-        {
-            Handled = !value,
-            SuppressKeyPress = value
-        };
-        Assert.Equal(value, e.SuppressKeyPress);
-        Assert.Equal(value, e.Handled);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyPressEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyPressEventArgsTests.cs
deleted file mode 100644
index b8fc4b03c44..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeyPressEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class KeyPressEventArgsTests
-{
-    [Theory]
-    [InlineData('\0')]
-    [InlineData('a')]
-    public void Ctor_Char(char keyChar)
-    {
-        var e = new KeyPressEventArgs(keyChar);
-        Assert.Equal(keyChar, e.KeyChar);
-        Assert.False(e.Handled);
-    }
-
-    [Theory]
-    [InlineData('\0')]
-    [InlineData('a')]
-    public void KeyChar_Set_GetReturnsExpected(char value)
-    {
-        var e = new KeyPressEventArgs('b')
-        {
-            KeyChar = value
-        };
-        Assert.Equal(value, e.KeyChar);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Handled_Set_GetReturnsExpected(bool value)
-    {
-        var e = new KeyPressEventArgs('a')
-        {
-            Handled = value
-        };
-        Assert.Equal(value, e.Handled);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeysConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeysConverterTests.cs
deleted file mode 100644
index dcbc5a8444d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/KeysConverterTests.cs
+++ /dev/null
@@ -1,169 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Globalization;
-
-namespace System.Windows.Forms.Tests;
-
-public class KeysConverterTests
-{
-    [Theory]
-    [InlineData("Ctrl+Alt+Shift+A", Keys.Control | Keys.Alt | Keys.Shift | Keys.A)]
-    [InlineData("Ctrl+Alt+Shift+F1", Keys.Control | Keys.Alt | Keys.Shift | Keys.F1)]
-    [InlineData("Ctrl+Alt+D", Keys.Control | Keys.Alt | Keys.D)]
-    [InlineData("Ctrl + N", Keys.Control | Keys.N)]
-    [InlineData("G", Keys.G)]
-    [InlineData("None", Keys.None)]
-    public void ConvertFrom_ShouldConvertKeys(string input, Keys keys)
-    {
-        KeysConverter converter = new();
-        var result = (Keys)converter.ConvertFrom(input);
-        Assert.Equal(keys, result);
-    }
-
-    [Theory]
-    [InlineData("fr-FR", "(aucun)", Keys.None)]
-    [InlineData("nb-NO", "None", Keys.None)]
-    [InlineData("de-DE", "Ende", Keys.End)]
-    public void ConvertFrom_ShouldConvertKeys_Localization(string cultureName, string localizedKeyName, Keys expectedKey)
-    {
-        CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
-        KeysConverter converter = new();
-
-        // The 'localizedKeyName' is converted into the corresponding key value according to the specified culture.
-        var resultFromSpecificCulture = (Keys?)converter.ConvertFrom(context: null, culture, localizedKeyName);
-        Assert.Equal(expectedKey, resultFromSpecificCulture);
-
-        // Record original UI culture.
-        CultureInfo originalUICulture = Thread.CurrentThread.CurrentUICulture;
-
-        try
-        {
-            Thread.CurrentThread.CurrentUICulture = culture;
-
-            // When the culture is empty, the 'localizedKeyName' is converted to the corresponding key value based on CurrentUICulture.
-            var resultFromUICulture = (Keys?)converter.ConvertFrom(context: null, culture: null, localizedKeyName);
-            Assert.Equal(expectedKey, resultFromUICulture);
-        }
-        finally
-        {
-            Thread.CurrentThread.CurrentUICulture = originalUICulture;
-        }
-    }
-
-    [Theory]
-    [InlineData(Keys.None, "(none)")]
-    [InlineData(Keys.S, "S")]
-    [InlineData(Keys.Control | Keys.C, "Ctrl+C")]
-    [InlineData(Keys.Control | Keys.Add, "Ctrl+Add")]
-    [InlineData(Keys.Control | Keys.Alt | Keys.D, "Ctrl+Alt+D")]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.A, "Ctrl+Alt+Shift+A")]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.F1, "Ctrl+Alt+Shift+F1")]
-    [InlineData(Keys.F2 | Keys.Shift | Keys.Alt | Keys.Control, "Ctrl+Alt+Shift+F2")]
-    public void ConvertToString_ShouldConvertKeys(Keys keys, string expectedResult)
-    {
-        KeysConverter converter = new();
-        var result = converter.ConvertToString(null, CultureInfo.InvariantCulture, keys);
-        Assert.Equal(expectedResult, result);
-    }
-
-    [Theory]
-    [InlineData("fr-FR", Keys.None, "(aucun)")]
-    [InlineData("de-DE", Keys.End, "Ende")]
-    public void ConvertToString_ShouldConvertKeys_Localization(string cultureName, Keys key, string expectedLocalizedKeyName)
-    {
-        CultureInfo culture = CultureInfo.GetCultureInfo(cultureName);
-
-        KeysConverter converter = new();
-        string result = converter.ConvertToString(null, culture, key);
-
-        Assert.Equal(expectedLocalizedKeyName, result);
-    }
-
-    public static IEnumerable<object[]> ConvertToEnumArray_ShouldConvertKeys_TestData()
-    {
-        yield return new object[] { "fr-FR", Keys.None, new Enum[] { Keys.None } };
-        yield return new object[] { "de-DE", Keys.S, new Enum[] { Keys.S } };
-        yield return new object[] { "zh-CN", Keys.Control | Keys.C, new Enum[] { Keys.Control, Keys.C } };
-        yield return new object[] { "it-IT", Keys.Control | Keys.Add, new Enum[] { Keys.Control, Keys.Add } };
-        yield return new object[] { "ko-KR", Keys.Control | Keys.Alt | Keys.D, new Enum[] { Keys.Control, Keys.Alt, Keys.D } };
-        yield return new object[] { "ru-RU", Keys.Control | Keys.Alt | Keys.Shift | Keys.A, new Enum[] { Keys.Control, Keys.Alt, Keys.Shift, Keys.A } };
-        yield return new object[] { "zh-TW", Keys.Control | Keys.Alt | Keys.Shift | Keys.F1, new Enum[] { Keys.Control, Keys.Alt, Keys.Shift, Keys.F1 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertToEnumArray_ShouldConvertKeys_TestData))]
-    public void ConvertToEnumArray_ShouldConvertKeys(string cultureName, Keys keys, Enum[] expectedResult)
-    {
-        KeysConverter converter = new();
-        var result = converter.ConvertTo(keys, typeof(Enum[]));
-        Assert.Equal(expectedResult, result);
-
-        CultureInfo originalUICulture = Thread.CurrentThread.CurrentUICulture;
-        try
-        {
-            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(cultureName);
-
-            object resultWithoutCulture = converter.ConvertTo(context: null, culture: null, keys, typeof(Enum[]));
-            object resultWithUICulture = converter.ConvertTo(context: null, culture: Thread.CurrentThread.CurrentUICulture, keys, typeof(Enum[]));
-
-            Assert.Equal(expectedResult, resultWithoutCulture);
-            Assert.Equal(resultWithUICulture, resultWithoutCulture);
-        }
-        finally
-        {
-            Thread.CurrentThread.CurrentUICulture = originalUICulture;
-        }
-    }
-
-    [Theory]
-    [InlineData(null, null)]
-    [InlineData("de-DE", null)]
-    [InlineData(null, "de-DE")]
-    [InlineData("fr-FR", "en-US")]
-    [InlineData("en-US", "fr-FR")]
-    [InlineData("zh-CN", "it-IT")]
-    [InlineData("it-IT", "zh-CN")]
-    [InlineData("ko-KR", "ru-RU")]
-    [InlineData("ru-RU", "ko-KR")]
-    [InlineData("zh-TW", "cs-CZ")]
-    [InlineData("cs-CZ", "zh-TW")]
-    [InlineData("ja-JP", "en-US")]
-    public void GetStandardValues(string cultureName, string uiCultureName)
-    {
-        // Record original culture
-        CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
-        CultureInfo originalUICulture = Thread.CurrentThread.CurrentUICulture;
-
-        // Update CurrentCulture
-        Thread.CurrentThread.CurrentCulture = cultureName is not null ? CultureInfo.GetCultureInfo(cultureName) : originalCulture;
-        Thread.CurrentThread.CurrentUICulture = uiCultureName is not null ? CultureInfo.GetCultureInfo(uiCultureName) : originalUICulture;
-
-        Keys[] expectedValues =
-        [
-            Keys.None, Keys.D0, Keys.D1, Keys.D2, Keys.D3, Keys.D4, Keys.D5, Keys.D6, Keys.D7, Keys.D8, Keys.D9, Keys.Alt, Keys.Back, Keys.Control,
-            Keys.Delete, Keys.End, Keys.Enter, Keys.F1, Keys.F10, Keys.F11, Keys.F12, Keys.F2, Keys.F3, Keys.F4, Keys.F5, Keys.F6, Keys.F7, Keys.F8,
-            Keys.F9, Keys.Home, Keys.Insert, Keys.Next, Keys.PageUp, Keys.Shift
-        ];
-
-        try
-        {
-            var standardValuesCollection = new KeysConverter().GetStandardValues();
-            object[] actualValues = new ArrayList(standardValuesCollection).ToArray();
-
-            Assert.Equal(expectedValues.Length, standardValuesCollection.Count);
-
-            foreach (object key in expectedValues)
-            {
-                Assert.Contains(key, actualValues);
-            }
-        }
-        finally
-        {
-            // Restore original Culture
-            Thread.CurrentThread.CurrentCulture = originalCulture;
-            Thread.CurrentThread.CurrentUICulture = originalUICulture;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelAccessibleObjectTests.cs
deleted file mode 100644
index 1b550cd0c29..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,177 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using LabelAccessibleObject = System.Windows.Forms.Label.LabelAccessibleObject;
-
-namespace System.Windows.Forms.Tests;
-
-public class LabelAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.NamePropertyId, "Address")]
-    [InlineData((int)UiaCore.UIA.AutomationIdPropertyId, "Label1")]
-    public void LabelAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using Label label = new()
-        {
-            Text = "Some test label text",
-            Name = "Label1",
-            AccessibleName = "Address"
-        };
-
-        LabelAccessibleObject accessibilityObject = (LabelAccessibleObject)label.AccessibilityObject;
-
-        object value = accessibilityObject.GetPropertyValue((UiaCore.UIA)propertyID);
-        Assert.Equal(expected, value);
-        Assert.False(label.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var label = new Label();
-        label.Name = "Label1";
-        label.Text = "Some test label text";
-        var labelAccessibleObject = new LabelAccessibleObject(label);
-
-        Assert.False(label.IsHandleCreated);
-
-        bool supportsLegacyIAccessiblePatternId = labelAccessibleObject.IsPatternSupported(Interop.UiaCore.UIA.LegacyIAccessiblePatternId);
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_LegacyIAccessible_Role_ReturnsExpected()
-    {
-        using var label = new Label();
-        label.Name = "Label1";
-        label.Text = "Some test label text";
-        label.AccessibleRole = AccessibleRole.Link;
-        var labelAccessibleObject = new LabelAccessibleObject(label);
-
-        Assert.False(label.IsHandleCreated);
-        Assert.Equal(AccessibleRole.Link, labelAccessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_Role_IsStaticText_ByDefault()
-    {
-        using Label label = new Label();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = label.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.StaticText, actual);
-        Assert.False(label.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_LegacyIAccessible_Description_ReturnsExpected()
-    {
-        string testAccDescription = "Test description";
-        using var label = new Label();
-        label.Name = "Label1";
-        label.Text = "Some test label text";
-        label.AccessibleDescription = testAccDescription;
-        var labelAccessibleObject = new LabelAccessibleObject(label);
-
-        Assert.False(label.IsHandleCreated);
-        Assert.Equal(testAccDescription, labelAccessibleObject.Description);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_ControlType_IsText_IfAccessibleRoleIsDefault()
-    {
-        using Label label = new Label();
-        // AccessibleRole is not set = Default
-
-        object actual = label.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TextControlTypeId, actual);
-        Assert.False(label.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> LabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void LabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using Label label = new Label();
-        label.AccessibleRole = role;
-
-        object actual = label.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(label.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LabelAccessibleObject_TextChanged_AutomationPropertyChanged_Raised()
-    {
-        const string newText = "New text";
-        using var control = new LabelWithCustomAccessibleObject(
-            (propertyId, value) => propertyId == UiaCore.UIA.NamePropertyId && ReferenceEquals(value, newText))
-        {
-            Text = "Text"
-        };
-
-        var accessibilityObject = control.AccessibilityObject as ControlAccessibleObjectWithNotificationCounter;
-        Assert.NotNull(accessibilityObject);
-        Assert.True(control.IsAccessibilityObjectCreated);
-        Assert.Equal(0, accessibilityObject.RaiseAutomationNotificationCallCount);
-
-        control.Text = newText;
-
-        Assert.Equal(1, accessibilityObject.RaiseAutomationNotificationCallCount);
-    }
-
-    private class LabelWithCustomAccessibleObject : Label
-    {
-        private readonly Func<UiaCore.UIA, object, bool> _checkRaisedEvent;
-
-        public LabelWithCustomAccessibleObject(Func<UiaCore.UIA, object, bool> checkRaisedEvent)
-        {
-            _checkRaisedEvent = checkRaisedEvent;
-        }
-
-        protected override AccessibleObject CreateAccessibilityInstance() => new ControlAccessibleObjectWithNotificationCounter(this, _checkRaisedEvent);
-    }
-
-    private class ControlAccessibleObjectWithNotificationCounter : Control.ControlAccessibleObject
-    {
-        private readonly Func<UiaCore.UIA, object, bool> _checkRaisedEvent;
-
-        public ControlAccessibleObjectWithNotificationCounter(Control ownerControl, Func<UiaCore.UIA, object, bool> checkRaisedEvent) : base(ownerControl)
-        {
-            _checkRaisedEvent = checkRaisedEvent;
-        }
-
-        internal int RaiseAutomationNotificationCallCount { get; private set; }
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UiaCore.UIA propertyId, object oldValue, object newValue)
-        {
-            if (_checkRaisedEvent(propertyId, newValue))
-            {
-                RaiseAutomationNotificationCallCount++;
-            }
-
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelEditEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelEditEventArgsTests.cs
deleted file mode 100644
index ab42514192d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelEditEventArgsTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LabelEditEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int item)
-    {
-        var e = new LabelEditEventArgs(item);
-        Assert.Equal(item, e.Item);
-        Assert.Null(e.Label);
-        Assert.False(e.CancelEdit);
-    }
-
-    [Theory]
-    [InlineData(-1, null)]
-    [InlineData(0, "")]
-    [InlineData(1, "label")]
-    public void Ctor_Int_String(int item, string label)
-    {
-        var e = new LabelEditEventArgs(item, label);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(label, e.Label);
-        Assert.False(e.CancelEdit);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CancelEdit_Set_GetReturnsExpected(bool value)
-    {
-        var e = new LabelEditEventArgs(1)
-        {
-            CancelEdit = value
-        };
-        Assert.Equal(value, e.CancelEdit);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelTests.cs
deleted file mode 100644
index 5dc609d687a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LabelTests.cs
+++ /dev/null
@@ -1,370 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class LabelTests
-{
-    [WinFormsFact]
-    public void Label_Ctor_Default()
-    {
-        using var control = new SubLabel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoEllipsis);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 23), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(100, 23), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 100, 23), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, control.DefaultImeMode);
-        Assert.Equal(new Padding(3, 0, 3, 0), control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.Equal(new Size(100, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 100, 23), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Null(control.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.ImageAlign);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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, 0, 3, 0), 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("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(0, control.PreferredSize.Width);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.True(control.PreferredHeight > 0);
-        Assert.Equal(0, control.PreferredWidth);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.RenderTransparent);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 23), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ContentAlignment.TopLeft, control.TextAlign);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.True(control.UseMnemonic);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(100, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Label_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubLabel();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Static", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x5600000D, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Label_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubLabel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Label_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubLabel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Label_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubLabel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void Label_ImageIndex_setting_minus_one_resets_ImageKey()
-    {
-        int index = -1;
-
-        using var control = new SubLabel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(index, control.ImageIndex);
-        Assert.Equal(string.Empty, control.ImageKey);
-
-        control.ImageKey = "key";
-        control.ImageIndex = index;
-
-        Assert.Equal(index, control.ImageIndex);
-        Assert.Equal(string.Empty, control.ImageKey);
-    }
-
-    [WinFormsFact]
-    public void Label_ImageKey_setting_empty_resets_ImageIndex()
-    {
-        string key = string.Empty;
-
-        using var control = new SubLabel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(key, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-
-        control.ImageIndex = 2;
-        control.ImageKey = key;
-
-        Assert.Equal(key, control.ImageKey);
-        Assert.Equal(-1, control.ImageIndex);
-    }
-
-    [WinFormsFact]
-    public void Label_SupportsUiaProviders_returns_true()
-    {
-        using var label = new Label();
-        Assert.True(label.SupportsUiaProviders);
-    }
-
-    [WinFormsFact]
-    public void Label_Invokes_SetToolTip_IfExternalToolTipIsSet()
-    {
-        using Label label = new Label();
-        using ToolTip toolTip = new ToolTip();
-        label.CreateControl();
-
-        dynamic labelDynamic = label.TestAccessor().Dynamic;
-        bool actual = labelDynamic._controlToolTip;
-
-        Assert.False(actual);
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        toolTip.SetToolTip(label, "Some test text"); // Invokes Label's SetToolTip inside
-        actual = labelDynamic._controlToolTip;
-
-        Assert.True(actual);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void Label_ImageAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new Label();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImageAlign = value);
-    }
-
-    public static IEnumerable<object[]> ImageAlign_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                yield return new object[] { autoSize, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageAlign_Set_TestData))]
-    public void Label_ImageAlign_Set_GetReturnsExpected(bool autoSize, ContentAlignment value)
-    {
-        using var control = new Label
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageAlign = value;
-        Assert.Equal(value, control.ImageAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, true)]
-    [InlineData(true, false)]
-    public void Label_AutoSize_BehavesExpected(bool autoSize, bool expected)
-    {
-        using Form form = new Form();
-        using Label label = new()
-        {
-            AutoSize = autoSize,
-            Size = new(10, 10),
-            Text = "Hello",
-        };
-        Size oldSize = label.Size;
-        form.Controls.Add(label);
-        form.Show();
-        label.Text = "Say Hello";
-        Size newSize = label.Size;
-        Assert.Equal(expected, newSize == oldSize);
-    }
-
-    public class SubLabel : Label
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-#pragma warning disable 0618
-        public new bool RenderTransparent
-        {
-            get => base.RenderTransparent;
-            set => base.RenderTransparent = value;
-        }
-#pragma warning restore 0618
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/FlowLayoutTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/FlowLayoutTests.cs
deleted file mode 100644
index 9581ddc685a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/FlowLayoutTests.cs
+++ /dev/null
@@ -1,291 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Layout.Tests;
-
-public partial class FlowLayoutTests
-{
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_ValidChild_Nop()
-    {
-        using var control = new FlowLayoutPanel();
-        LayoutEngine engine = control.LayoutEngine;
-        engine.InitLayout(control, BoundsSpecified.All);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_InvalidChild_ThrowsNotSupportedException()
-    {
-        using var control = new FlowLayoutPanel();
-        LayoutEngine engine = control.LayoutEngine;
-        Assert.Throws<NotSupportedException>(() => engine.InitLayout("child", BoundsSpecified.All));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_NullChild_ThrowsArgumentNullException()
-    {
-        using var control = new FlowLayoutPanel();
-        LayoutEngine engine = control.LayoutEngine;
-        Assert.Throws<ArgumentNullException>("child", () => engine.InitLayout(null, BoundsSpecified.All));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_ValidContainerLeftToRight_Success()
-    {
-        using var control = new FlowLayoutPanel();
-        control.SuspendLayout();
-        using var child1 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        using var child2 = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = new Size(10, 20)
-        };
-        using var largeChild = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(100, 200)
-        };
-        using var emptyChild = new Control
-        {
-            Size = Size.Empty
-        };
-        using var emptyChildWithMargin = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = Size.Empty
-        };
-        using var child3 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(50, 100)
-        };
-        using var child4 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(largeChild);
-        control.Controls.Add(emptyChild);
-        control.Controls.Add(emptyChildWithMargin);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-
-        LayoutEngine engine = control.LayoutEngine;
-        engine.Layout(control, null);
-        Assert.Equal(new Rectangle(0, 0, 10, 20), child1.Bounds);
-        Assert.Equal(new Rectangle(11, 2, 10, 20), child2.Bounds);
-        Assert.Equal(new Rectangle(24, 0, 100, 200), largeChild.Bounds);
-        Assert.Equal(new Rectangle(127, 3, 0, 0), emptyChild.Bounds);
-        Assert.Equal(new Rectangle(131, 2, 0, 0), emptyChildWithMargin.Bounds);
-        Assert.Equal(new Rectangle(134, 0, 50, 100), child3.Bounds);
-        Assert.Equal(new Rectangle(184, 0, 10, 20), child4.Bounds);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_ValidContainerRightToLeft_Success()
-    {
-        using var control = new FlowLayoutPanel
-        {
-            FlowDirection = FlowDirection.RightToLeft
-        };
-        control.SuspendLayout();
-        using var child1 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        using var child2 = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = new Size(10, 20)
-        };
-        using var largeChild = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(100, 200)
-        };
-        using var emptyChild = new Control
-        {
-            Size = Size.Empty
-        };
-        using var emptyChildWithMargin = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = Size.Empty
-        };
-        using var child3 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(50, 100)
-        };
-        using var child4 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(largeChild);
-        control.Controls.Add(emptyChild);
-        control.Controls.Add(emptyChildWithMargin);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-
-        LayoutEngine engine = control.LayoutEngine;
-        engine.Layout(control, null);
-        Assert.Equal(new Rectangle(190, 0, 10, 20), child1.Bounds);
-        Assert.Equal(new Rectangle(177, 2, 10, 20), child2.Bounds);
-        Assert.Equal(new Rectangle(76, 0, 100, 200), largeChild.Bounds);
-        Assert.Equal(new Rectangle(73, 3, 0, 0), emptyChild.Bounds);
-        Assert.Equal(new Rectangle(67, 2, 0, 0), emptyChildWithMargin.Bounds);
-        Assert.Equal(new Rectangle(16, 0, 50, 100), child3.Bounds);
-        Assert.Equal(new Rectangle(6, 0, 10, 20), child4.Bounds);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_ValidContainerTopDown_Success()
-    {
-        using var control = new FlowLayoutPanel
-        {
-            FlowDirection = FlowDirection.TopDown
-        };
-        control.SuspendLayout();
-        using var child1 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        using var child2 = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = new Size(10, 20)
-        };
-        using var largeChild = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(100, 200)
-        };
-        using var emptyChild = new Control
-        {
-            Size = Size.Empty
-        };
-        using var emptyChildWithMargin = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = Size.Empty
-        };
-        using var child3 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(50, 100)
-        };
-        using var child4 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(largeChild);
-        control.Controls.Add(emptyChild);
-        control.Controls.Add(emptyChildWithMargin);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-
-        LayoutEngine engine = control.LayoutEngine;
-        engine.Layout(control, null);
-        Assert.Equal(new Rectangle(0, 0, 10, 20), child1.Bounds);
-        Assert.Equal(new Rectangle(1, 22, 10, 20), child2.Bounds);
-        Assert.Equal(new Rectangle(14, 0, 100, 200), largeChild.Bounds);
-        Assert.Equal(new Rectangle(117, 3, 0, 0), emptyChild.Bounds);
-        Assert.Equal(new Rectangle(115, 8, 0, 0), emptyChildWithMargin.Bounds);
-        Assert.Equal(new Rectangle(120, 0, 50, 100), child3.Bounds);
-        Assert.Equal(new Rectangle(170, 0, 10, 20), child4.Bounds);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_ValidContainerBottomUp_Success()
-    {
-        using var control = new FlowLayoutPanel
-        {
-            FlowDirection = FlowDirection.BottomUp
-        };
-        control.SuspendLayout();
-        using var child1 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        using var child2 = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = new Size(10, 20)
-        };
-        using var largeChild = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(100, 200)
-        };
-        using var emptyChild = new Control
-        {
-            Size = Size.Empty
-        };
-        using var emptyChildWithMargin = new Control
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Size = Size.Empty
-        };
-        using var child3 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(50, 100)
-        };
-        using var child4 = new Control
-        {
-            Margin = Padding.Empty,
-            Size = new Size(10, 20)
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(largeChild);
-        control.Controls.Add(emptyChild);
-        control.Controls.Add(emptyChildWithMargin);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-
-        LayoutEngine engine = control.LayoutEngine;
-        engine.Layout(control, null);
-        Assert.Equal(new Rectangle(0, 80, 10, 20), child1.Bounds);
-        Assert.Equal(new Rectangle(1, 56, 10, 20), child2.Bounds);
-        Assert.Equal(new Rectangle(14, -100, 100, 200), largeChild.Bounds);
-        Assert.Equal(new Rectangle(117, 97, 0, 0), emptyChild.Bounds);
-        Assert.Equal(new Rectangle(115, 90, 0, 0), emptyChildWithMargin.Bounds);
-        Assert.Equal(new Rectangle(120, 0, 50, 100), child3.Bounds);
-        Assert.Equal(new Rectangle(170, 80, 10, 20), child4.Bounds);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_InvalidContainer_Nop()
-    {
-        using var control = new FlowLayoutPanel();
-        LayoutEngine engine = control.LayoutEngine;
-        Assert.Throws<NotSupportedException>(() => engine.Layout("container", new LayoutEventArgs(control, "affectedProperty")));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_NullContainer_ThrowsArgumentNullException()
-    {
-        using var control = new FlowLayoutPanel();
-        LayoutEngine engine = control.LayoutEngine;
-        Assert.Throws<ArgumentNullException>("container", () => engine.Layout(null, new LayoutEventArgs(control, "affectedProperty")));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/LayoutEngineTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/LayoutEngineTests.cs
deleted file mode 100644
index e48e842b066..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/LayoutEngineTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Layout.Tests;
-
-public class LayoutEngineTests
-{
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_ValidChild_Nop()
-    {
-        var engine = new SubLayoutEngine();
-        engine.InitLayout(new ScrollableControl(), BoundsSpecified.All);
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_InvalidChild_ThrowsNotSupportedException()
-    {
-        var engine = new SubLayoutEngine();
-        Assert.Throws<NotSupportedException>(() => engine.InitLayout("child", BoundsSpecified.All));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_InitLayout_NullChild_ThrowsArgumentNullException()
-    {
-        var engine = new SubLayoutEngine();
-        Assert.Throws<ArgumentNullException>("child", () => engine.InitLayout(null, BoundsSpecified.All));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_ValidContainer_ReturnsFalse()
-    {
-        var engine = new SubLayoutEngine();
-        Assert.False(engine.Layout(new ScrollableControl(), new LayoutEventArgs(new Component(), "affectedProperty")));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_InvalidContainer_Nop()
-    {
-        var engine = new SubLayoutEngine();
-        Assert.Throws<NotSupportedException>(() => engine.Layout("container", new LayoutEventArgs(new Component(), "affectedProperty")));
-    }
-
-    [WinFormsFact]
-    public void LayoutEngine_Layout_NullContainer_ThrowsArgumentNullException()
-    {
-        var engine = new SubLayoutEngine();
-        Assert.Throws<ArgumentNullException>("container", () => engine.Layout(null, new LayoutEventArgs(new Component(), "affectedProperty")));
-    }
-
-    private class SubLayoutEngine : LayoutEngine
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTests.cs
deleted file mode 100644
index e5326078888..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTests.cs
+++ /dev/null
@@ -1,1917 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Globalization;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using Moq;
-
-namespace System.Windows.Forms.Layout.Tests;
-
-public class TableLayoutSettingsTests
-{
-    [WinFormsFact]
-    public void TableLayoutSettings_Properties_GetWithOwner_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Equal(0, settings.ColumnCount);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Same(settings.ColumnStyles, settings.ColumnStyles);
-        Assert.Equal(TableLayoutPanelGrowStyle.AddRows, settings.GrowStyle);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-        Assert.Equal(0, settings.RowCount);
-        Assert.Empty(settings.RowStyles);
-        Assert.Same(settings.RowStyles, settings.RowStyles);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_Properties_GetWithoutOwner_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<NullReferenceException>(() => settings.GrowStyle);
-        Assert.Throws<NullReferenceException>(() => settings.ColumnCount);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Same(settings.ColumnStyles, settings.ColumnStyles);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-        Assert.Throws<NullReferenceException>(() => settings.RowCount);
-        Assert.Empty(settings.RowStyles);
-        Assert.Same(settings.RowStyles, settings.RowStyles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    public void TableLayoutSettings_ColumnCount_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Columns", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        settings.ColumnCount = value;
-        Assert.Equal(value, settings.ColumnCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        settings.ColumnCount = value;
-        Assert.Equal(value, settings.ColumnCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ColumnCount_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.ColumnCount = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize, 1)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows, 0)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns, 1)]
-    public void TableLayoutSettings_GrowStyle_Set_GetReturnsExpected(TableLayoutPanelGrowStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GrowStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        settings.GrowStyle = value;
-        Assert.Equal(value, settings.GrowStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        settings.GrowStyle = value;
-        Assert.Equal(value, settings.GrowStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TableLayoutPanelGrowStyle>]
-    public void TableLayoutSettings_GrowStyle_SetInvalid_ThrowsArgumentOutOfRangeException(TableLayoutPanelGrowStyle value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<InvalidEnumArgumentException>("value", () => settings.GrowStyle = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    public void TableLayoutSettings_RowCount_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Rows", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        settings.RowCount = value;
-        Assert.Equal(value, settings.RowCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        settings.RowCount = value;
-        Assert.Equal(value, settings.RowCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_RowCount_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.RowCount = -1);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_NoSuchControlStub_ReturnsExpected()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetCellPosition(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_NullControlStub_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetCellPosition(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.GetCellPosition("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), settings.GetCellPosition("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition { Column = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidColumnStub_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition { Column = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition { Row = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetCellPosition_InvalidRowStub_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition { Row = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_NoSuchControl_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        using var child = new Control();
-        Assert.Equal(-1, settings.GetColumn(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_NoSuchControlStub_ReturnsExpected()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(-1, settings.GetColumn(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetColumn(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_NullControlStub_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetColumn(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.GetColumn("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumn_InvalidControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(-1, settings.GetColumn("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Equal(1, settings.GetColumnSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_NoSuchControlStub_ReturnsExpected()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(1, settings.GetColumnSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_NullControl_ThrowsArgumentNullException()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetColumnSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_NullControlStub_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetColumnSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.GetColumnSpan("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetColumnSpan_InvalidControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(1, settings.GetColumnSpan("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_NoSuchControl_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        using var child = new Control();
-        Assert.Equal(-1, settings.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_NoSuchControlStub_ReturnsExpected()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(-1, settings.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetRow(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_NullControlStub_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetRow(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.GetRow("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRow_InvalidControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(-1, settings.GetRow("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Equal(1, settings.GetRowSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_NoSuchControlStub_ReturnsExpected()
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(1, settings.GetRowSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetRowSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_NullControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetRowSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.GetRowSpan("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_GetRowSpan_InvalidControlStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Equal(1, settings.GetRowSpan("control"));
-    }
-
-    public static IEnumerable<object[]> SetCellPosition_TestData()
-    {
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, -1) };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, -1) };
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, 0) };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, 0) };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_TestData))]
-    public void TableLayoutPanel_SetCellPosition_Invoke_GetReturnsExpected(TableLayoutPanelCellPosition value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetCellPosition(child, value);
-        Assert.Equal(value, settings.GetCellPosition(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetCellPosition(child, value);
-        Assert.Equal(value, settings.GetCellPosition(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetCellPosition_ControlWithParent_TestData()
-    {
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, -1), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, -1), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, 0), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, 0), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_ControlWithParent_TestData))]
-    public void TableLayoutPanel_SetCellPosition_InvokeControlWithParent_GetReturnsExpected(TableLayoutPanelCellPosition value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetCellPosition(child, value);
-            Assert.Equal(value, settings.GetCellPosition(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetCellPosition(child, value);
-            Assert.Equal(value, settings.GetCellPosition(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_TestData))]
-    public void TableLayoutPanel_SetCellPosition_InvokeStub_GetReturnsExpected(TableLayoutPanelCellPosition value)
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetCellPosition(child, value);
-        Assert.Equal(value, settings.GetCellPosition(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetCellPosition(child, value);
-        Assert.Equal(value, settings.GetCellPosition(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_TestData))]
-    public void TableLayoutPanel_SetCellPosition_InvokeStubWithParent_GetReturnsExpected(TableLayoutPanelCellPosition value)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetCellPosition(child, value);
-            Assert.Equal(value, settings.GetCellPosition(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetCellPosition(child, value);
-            Assert.Equal(value, settings.GetCellPosition(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        using var child = new Control();
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition(1, 1));
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 1), settings.GetCellPosition(child));
-
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition(2, 2));
-        Assert.Equal(new TableLayoutPanelCellPosition(2, 2), settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_InvokeMultipleTimesStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var child = new Control();
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition(1, 1));
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 1), settings.GetCellPosition(child));
-
-        settings.SetCellPosition(child, new TableLayoutPanelCellPosition(2, 2));
-        Assert.Equal(new TableLayoutPanelCellPosition(2, 2), settings.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetCellPosition(null, new TableLayoutPanelCellPosition()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_NullControlStub_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetCellPosition(null, new TableLayoutPanelCellPosition()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.SetCellPosition("control", new TableLayoutPanelCellPosition()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetCellPosition_InvalidControlStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetCellPosition("control", new TableLayoutPanelCellPosition());
-        Assert.Equal(new TableLayoutPanelCellPosition(), settings.GetCellPosition("control"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumn_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetColumn(child, value);
-        Assert.Equal(value, settings.GetColumn(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetColumn(child, value);
-        Assert.Equal(value, settings.GetColumn(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetColumn_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetColumn(child, value);
-            Assert.Equal(value, settings.GetColumn(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetColumn(child, value);
-            Assert.Equal(value, settings.GetColumn(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumn_InvokeStub_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetColumn(child, value);
-        Assert.Equal(value, settings.GetColumn(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetColumn(child, value);
-        Assert.Equal(value, settings.GetColumn(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumn_InvokeStubWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetColumn(child, value);
-            Assert.Equal(value, settings.GetColumn(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetColumn(child, value);
-            Assert.Equal(value, settings.GetColumn(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        using var child = new Control();
-        settings.SetColumn(child, 1);
-        Assert.Equal(1, settings.GetColumn(child));
-
-        settings.SetColumn(child, 2);
-        Assert.Equal(2, settings.GetColumn(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvokeMultipleTimesStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var child = new Control();
-        settings.SetColumn(child, 1);
-        Assert.Equal(1, settings.GetColumn(child));
-
-        settings.SetColumn(child, 2);
-        Assert.Equal(2, settings.GetColumn(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutSettings_SetColumn_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetColumn(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutSettings_SetColumn_NullControlStub_ThrowsArgumentNullException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetColumn(null, value));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.SetColumn("control", 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvalidControlStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetColumn("control", 1);
-        Assert.Equal(1, settings.GetColumn("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => settings.SetColumn("control", -2));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumn_InvalidColumnStub_ThrowsArgumentOutOfRangeException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => settings.SetColumn("control", -2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumnSpan_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetColumnSpan(child, value);
-        Assert.Equal(value, settings.GetColumnSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetColumnSpan(child, value);
-        Assert.Equal(value, settings.GetColumnSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void TableLayoutPanel_SetColumnSpan_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("ColumnSpan", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetColumnSpan(child, value);
-            Assert.Equal(value, settings.GetColumnSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetColumnSpan(child, value);
-            Assert.Equal(value, settings.GetColumnSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumnSpan_InvokeStub_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetColumnSpan(child, value);
-        Assert.Equal(value, settings.GetColumnSpan(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetColumnSpan(child, value);
-        Assert.Equal(value, settings.GetColumnSpan(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumnSpan_InvokeStubWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetColumnSpan(child, value);
-            Assert.Equal(value, settings.GetColumnSpan(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetColumnSpan(child, value);
-            Assert.Equal(value, settings.GetColumnSpan(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumnSpan_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        using var child = new Control();
-        settings.SetColumnSpan(child, 1);
-        Assert.Equal(1, settings.GetColumnSpan(child));
-
-        settings.SetColumnSpan(child, 2);
-        Assert.Equal(2, settings.GetColumnSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumnSpan_InvokeMultipleTimesStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var child = new Control();
-        settings.SetColumnSpan(child, 1);
-        Assert.Equal(1, settings.GetColumnSpan(child));
-
-        settings.SetColumnSpan(child, 2);
-        Assert.Equal(2, settings.GetColumnSpan(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutSettings_SetColumnSpan_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetColumnSpan(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutSettings_SetColumnSpan_NullControlStub_ThrowsArgumentNullException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetColumnSpan(null, value));
-        Assert.Throws<ArgumentNullException>("control", () => settings.GetColumnSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumnSpan_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.SetColumnSpan("control", 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetColumnSpan_InvalidControlStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetColumnSpan("control", 1);
-        Assert.Equal(1, settings.GetColumnSpan("control"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutSettings_SetColumnSpan_InvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.SetColumnSpan("control", value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutSettings_SetColumnSpan_InvalidValueStub_ThrowsArgumentOutOfRangeException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.SetColumnSpan("control", value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRow_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetRow(child, value);
-        Assert.Equal(value, settings.GetRow(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetRow(child, value);
-        Assert.Equal(value, settings.GetRow(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetRow_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetRow(child, value);
-            Assert.Equal(value, settings.GetRow(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetRow(child, value);
-            Assert.Equal(value, settings.GetRow(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRow_InvokeStub_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetRow(child, value);
-        Assert.Equal(value, settings.GetRow(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetRow(child, value);
-        Assert.Equal(value, settings.GetRow(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRow_InvokeStubWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetRow(child, value);
-            Assert.Equal(value, settings.GetRow(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetRow(child, value);
-            Assert.Equal(value, settings.GetRow(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        using var child = new Control();
-        settings.SetRow(child, 1);
-        Assert.Equal(1, settings.GetRow(child));
-
-        settings.SetRow(child, 2);
-        Assert.Equal(2, settings.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvokeMultipleTimesStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var child = new Control();
-        settings.SetRow(child, 1);
-        Assert.Equal(1, settings.GetRow(child));
-
-        settings.SetRow(child, 2);
-        Assert.Equal(2, settings.GetRow(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutSettings_SetRow_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetRow(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutSettings_SetRow_NullControlStub_ThrowsArgumentNullException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetRow(null, value));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.SetRow("control", 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvalidControlStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetRow("control", 1);
-        Assert.Equal(1, settings.GetRow("control"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => settings.SetRow("control", -2));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRow_InvalidRowStub_ThrowsArgumentOutOfRangeException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => settings.SetRow("control", -2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRowSpan_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetRowSpan(child, value);
-        Assert.Equal(value, settings.GetRowSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetRowSpan(child, value);
-        Assert.Equal(value, settings.GetRowSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void TableLayoutPanel_SetRowSpan_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("RowSpan", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetRowSpan(child, value);
-            Assert.Equal(value, settings.GetRowSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetRowSpan(child, value);
-            Assert.Equal(value, settings.GetRowSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRowSpan_InvokeStub_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        settings.SetRowSpan(child, value);
-        Assert.Equal(value, settings.GetRowSpan(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        settings.SetRowSpan(child, value);
-        Assert.Equal(value, settings.GetRowSpan(child));
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRowSpan_InvokeStubWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            settings.SetRowSpan(child, value);
-            Assert.Equal(value, settings.GetRowSpan(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            settings.SetRowSpan(child, value);
-            Assert.Equal(value, settings.GetRowSpan(child));
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRowSpan_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        using var child = new Control();
-        settings.SetRowSpan(child, 1);
-        Assert.Equal(1, settings.GetRowSpan(child));
-
-        settings.SetRowSpan(child, 2);
-        Assert.Equal(2, settings.GetRowSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRowSpan_InvokeMultipleTimesStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var child = new Control();
-        settings.SetRowSpan(child, 1);
-        Assert.Equal(1, settings.GetRowSpan(child));
-
-        settings.SetRowSpan(child, 2);
-        Assert.Equal(2, settings.GetRowSpan(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutSettings_SetRowSpan_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetRowSpan(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutSettings_SetRowSpan_NullControlStub_ThrowsArgumentNullException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetRowSpan(null, value));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRowSpan_InvalidControl_ThrowsNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<NotSupportedException>(() => settings.SetRowSpan("control", 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_SetRowSpan_InvalidControlStub_GetReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetRowSpan("control", 1);
-        Assert.Equal(1, settings.GetRowSpan("control"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutSettings_SetRowSpan_InvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.SetRowSpan("control", value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutSettings_SetRowSpan_InvalidValueStub_ThrowsArgumentOutOfRangeException(int value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => settings.SetRowSpan("control", value));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeSimple_Success()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeSimpleStub_Success()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeAdvanced_Success()
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-
-        // Setup controls.
-        using var controlWithName = new Control
-        {
-            Name = "name"
-        };
-        using var controlWithDefaultName = new Control();
-        settings.SetColumnSpan(controlWithName, 1);
-        settings.SetRowSpan(controlWithName, 2);
-        settings.SetColumn(controlWithName, 3);
-        settings.SetRow(controlWithName, 4);
-
-        // Setup styles.
-        var columnStyle = new ColumnStyle(SizeType.Percent, 1);
-        var rowStyle = new RowStyle(SizeType.Percent, 2);
-        settings.ColumnStyles.Add(columnStyle);
-        settings.RowStyles.Add(rowStyle);
-
-        // Serialize.
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString"));
-
-        // Set parent.
-        info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        control.Controls.Add(controlWithName);
-        control.Controls.Add(controlWithDefaultName);
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /><Control Name="""" Row=""-1"" RowSpan=""1"" Column=""-1"" ColumnSpan=""1"" /></Controls><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeAdvancedStub_Success()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        // Setup controls.
-        settings.SetColumnSpan("name", 1);
-        settings.SetRowSpan("name", 2);
-        settings.SetColumn("name", 3);
-        settings.SetRow("name", 4);
-        settings.SetRow("", 1);
-        settings.SetColumn("", 1);
-
-        // Setup styles.
-        var columnStyle = new ColumnStyle(SizeType.Percent, 1);
-        var rowStyle = new RowStyle(SizeType.Percent, 2);
-        settings.ColumnStyles.Add(columnStyle);
-        settings.RowStyles.Add(rowStyle);
-
-        // Serialize.
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /><Control Name="""" Row=""1"" RowSpan=""1"" Column=""1"" ColumnSpan=""1"" /></Controls><Columns Styles=""Percent,1"" /><Rows Styles=""Percent,2"" /></TableLayoutSettings>", info.GetString("SerializedString"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeToolStrip_Success()
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = ToolStripLayoutStyle.Table
-        };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(control.LayoutSettings);
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString"));
-
-        // Add children.
-        using var itemWithDefaultName = new SubToolStripItem();
-        using var itemWithoutName = new ToolStripItemWithoutName();
-        using var itemWithNonStringName = new ToolStripItemWithNonStringName();
-        using var itemWithName = new SubToolStripItem
-        {
-            Name = "Name"
-        };
-        control.Items.Add(itemWithDefaultName);
-        control.Items.Add(itemWithoutName);
-        control.Items.Add(itemWithNonStringName);
-        control.Items.Add(itemWithName);
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", info.GetString("SerializedString"));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(NullStringConverter))]
-    [InlineData(typeof(EmptyStringConverter))]
-    public void TableLayoutSettings_ISerializableGetObjectData_InvokeInvalidStringConverter_Success(Type type)
-    {
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        TypeDescriptor.AddAttributes(settings, new Attribute[] { new TypeConverterAttribute(type) });
-
-        ISerializable iSerializable = settings;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Throws<SerializationException>(() => info.GetString("SerializedString"));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettings_Serialize_Deserialize_Success()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        var columnStyle = new ColumnStyle(SizeType.Percent, 1);
-        var rowStyle = new RowStyle(SizeType.Percent, 2);
-
-        using var controlWithName = new Control { Name = "name" };
-        settings.SetColumnSpan(controlWithName, 1);
-        settings.SetRowSpan(controlWithName, 2);
-        settings.SetColumn(controlWithName, 3);
-        settings.SetRow(controlWithName, 4);
-        settings.ColumnStyles.Add(columnStyle);
-        settings.RowStyles.Add(rowStyle);
-
-        using (var stream = new MemoryStream())
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            var formatter = new BinaryFormatter();
-            formatter.Serialize(stream, settings);
-            stream.Seek(0, SeekOrigin.Begin);
-
-            TableLayoutSettings result = Assert.IsType<TableLayoutSettings>(formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-            Assert.Equal(columnStyle.SizeType, ((ColumnStyle)Assert.Single(result.ColumnStyles)).SizeType);
-            Assert.Equal(columnStyle.Width, ((ColumnStyle)Assert.Single(result.ColumnStyles)).Width);
-            Assert.Equal(rowStyle.SizeType, ((RowStyle)Assert.Single(result.RowStyles)).SizeType);
-            Assert.Equal(rowStyle.Height, ((RowStyle)Assert.Single(result.RowStyles)).Height);
-
-            Assert.Equal(1, result.GetColumnSpan(controlWithName));
-            Assert.Equal(1, result.GetRowSpan(controlWithName));
-            Assert.Equal(-1, result.GetColumn(controlWithName));
-            Assert.Equal(-1, result.GetRow(controlWithName));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(NullStringConverter))]
-    [InlineData(typeof(EmptyStringConverter))]
-    public void TableLayoutSettings_Serialize_InvalidStringConverter_DeserializeThrowsSerializationException(Type type)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        TypeDescriptor.AddAttributes(settings, new Attribute[] { new TypeConverterAttribute(type) });
-        using (var stream = new MemoryStream())
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            var formatter = new BinaryFormatter();
-            formatter.Serialize(stream, settings);
-            stream.Seek(0, SeekOrigin.Begin);
-
-            Assert.Throws<SerializationException>(() => formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(NullTableLayoutSettingsConverter))]
-    [InlineData(typeof(NonTableLayoutSettingsConverter))]
-    public void TableLayoutSettings_Deserialize_InvalidConverterResult_Success(Type type)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var control = new TableLayoutPanel();
-        TableLayoutSettings settings = control.LayoutSettings;
-        TypeDescriptor.AddAttributes(settings, new Attribute[] { new TypeConverterAttribute(type) });
-        using (var stream = new MemoryStream())
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            var formatter = new BinaryFormatter();
-            formatter.Serialize(stream, settings);
-
-            stream.Seek(0, SeekOrigin.Begin);
-
-            TableLayoutSettings result = Assert.IsType<TableLayoutSettings>(formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-            Assert.NotNull(result.LayoutEngine);
-            Assert.Same(result.LayoutEngine, result.LayoutEngine);
-            Assert.Throws<NullReferenceException>(() => result.ColumnCount);
-            Assert.Throws<NullReferenceException>(() => result.RowCount);
-            Assert.Empty(result.ColumnStyles);
-            Assert.Empty(result.RowStyles);
-            Assert.Throws<NullReferenceException>(() => result.GrowStyle);
-        }
-    }
-
-    private class NullStringConverter : TypeConverter
-    {
-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-        {
-            return null;
-        }
-    }
-
-    private class EmptyStringConverter : TypeConverter
-    {
-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-        {
-            return "";
-        }
-    }
-
-    private class NullTableLayoutSettingsConverter : TableLayoutSettingsTypeConverter
-    {
-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
-        {
-            return null;
-        }
-    }
-
-    private class NonTableLayoutSettingsConverter : TableLayoutSettingsTypeConverter
-    {
-        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
-        {
-            return "";
-        }
-    }
-
-    private class CustomTypeDescriptionProvider : TypeDescriptionProvider
-    {
-        public CustomTypeDescriptionProvider()
-        {
-        }
-
-        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
-        {
-            var mockDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-            mockDescriptor
-                .Setup(c => c.GetProperties())
-                .Returns(new PropertyDescriptorCollection(Array.Empty<PropertyDescriptor>()));
-            return mockDescriptor.Object;
-        }
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-    }
-
-    [TypeDescriptionProvider(typeof(CustomTypeDescriptionProvider))]
-    private class ToolStripItemWithoutName : ToolStripItem
-    {
-    }
-
-    private class ToolStripItemWithNonStringName : ToolStripItem
-    {
-        public new int Name { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTypeConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTypeConverterTests.cs
deleted file mode 100644
index 93935514139..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Layout/TableLayoutSettingsTypeConverterTests.cs
+++ /dev/null
@@ -1,323 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Xml;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Layout.Tests;
-
-// NB: doesn't require thread affinity
-public class TableLayoutSettingsTypeConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(TableLayoutSettings), false)]
-    [InlineData(typeof(string), true)]
-    public void TableLayoutSettingsTypeConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_HasStylesAndControls_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(
-@"<?xml version=""1.0"" encoding=""utf-16""?>
-<TableLayoutSettings>
-    <Controls>
-        <Control Name=""simple"" />
-        <Control Name=""name"" Row=""1"" RowSpan=""2"" Column=""3"" ColumnSpan=""4"" />
-        <Control Name=""invalidRow"" Row=""abc"" />
-        <Control Name=""invalidRowSpan"" RowSpan=""abc"" />
-        <Control Name=""invalidColumn"" Column=""abc"" />
-        <Control Name=""invalidColumnSpan"" ColumnSpan=""abc"" />
-    </Controls>
-    <Columns Styles=""AutoSize,1,Absolute,2.2"" />
-    <Columns Styles=""AutoSize,1.1#2Percent!1"" />
-    <Columns Styles=""Percent," + '\u0664' + @""" />
-    <Rows Styles=""AutoSize,1,Absolute,2"" />
-</TableLayoutSettings>"));
-        Assert.Equal(5, settings.ColumnStyles.Count);
-        Assert.Equal(SizeType.AutoSize, settings.ColumnStyles[0].SizeType);
-        Assert.Equal(1, settings.ColumnStyles[0].Width);
-        Assert.Equal(SizeType.Absolute, settings.ColumnStyles[1].SizeType);
-        Assert.Equal(2.2f, settings.ColumnStyles[1].Width);
-        Assert.Equal(SizeType.AutoSize, settings.ColumnStyles[2].SizeType);
-        Assert.Equal(1.12f, settings.ColumnStyles[2].Width);
-        Assert.Equal(SizeType.Percent, settings.ColumnStyles[3].SizeType);
-        Assert.Equal(1, settings.ColumnStyles[3].Width);
-        Assert.Equal(SizeType.Percent, settings.ColumnStyles[4].SizeType);
-        Assert.Equal(0, settings.ColumnStyles[4].Width);
-
-        Assert.Equal(2, settings.RowStyles.Count);
-        Assert.Equal(SizeType.AutoSize, settings.RowStyles[0].SizeType);
-        Assert.Equal(1, settings.RowStyles[0].Height);
-        Assert.Equal(SizeType.Absolute, settings.RowStyles[1].SizeType);
-        Assert.Equal(2, settings.RowStyles[1].Height);
-
-        Assert.Equal(-1, settings.GetRow("simple"));
-        Assert.Equal(1, settings.GetRowSpan("simple"));
-        Assert.Equal(-1, settings.GetColumn("simple"));
-        Assert.Equal(1, settings.GetColumnSpan("simple"));
-
-        Assert.Equal(1, settings.GetRow("name"));
-        Assert.Equal(2, settings.GetRowSpan("name"));
-        Assert.Equal(3, settings.GetColumn("name"));
-        Assert.Equal(4, settings.GetColumnSpan("name"));
-
-        Assert.Equal(-1, settings.GetRow("invalidRow"));
-        Assert.Equal(1, settings.GetRowSpan("invalidRow"));
-        Assert.Equal(-1, settings.GetColumn("invalidRow"));
-        Assert.Equal(1, settings.GetColumnSpan("invalidRow"));
-
-        Assert.Equal(-1, settings.GetRow("invalidRowSpan"));
-        Assert.Equal(1, settings.GetRowSpan("invalidRowSpan"));
-        Assert.Equal(-1, settings.GetColumn("invalidRowSpan"));
-        Assert.Equal(1, settings.GetColumnSpan("invalidRowSpan"));
-
-        Assert.Equal(-1, settings.GetRow("invalidColumn"));
-        Assert.Equal(1, settings.GetRowSpan("invalidColumn"));
-        Assert.Equal(-1, settings.GetColumn("invalidColumn"));
-        Assert.Equal(1, settings.GetColumnSpan("invalidColumn"));
-
-        Assert.Equal(-1, settings.GetRow("invalidColumnSpan"));
-        Assert.Equal(1, settings.GetRowSpan("invalidColumnSpan"));
-        Assert.Equal(-1, settings.GetColumn("invalidColumnSpan"));
-        Assert.Equal(1, settings.GetColumnSpan("invalidColumnSpan"));
-    }
-
-    [Theory]
-    [InlineData(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />")]
-    [InlineData(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings></TableLayoutSettings>")]
-    [InlineData(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns /><Rows /></TableLayoutSettings>")]
-    [InlineData(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control /><Control Name="""" /></Controls><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>")]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_Empty_ReturnsExpected(string value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(value));
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Empty(settings.RowStyles);
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("notXmlValue")]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_InvalidStringXmlValue_ThrowsInvalidXmlException(string value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<XmlException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("Invalid,1")]
-    [InlineData("1,1")]
-    [InlineData(",1")]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_InvalidStyleSize_ThrowsArgumentException(string style)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<ArgumentException>(() => converter.ConvertFrom($@"<?xml version=""1.0"" encoding=""utf-16""?><Root><Columns Styles=""{style}"" /></Root>"));
-    }
-
-    [Theory]
-    [InlineData("AutoSize")]
-    [InlineData("AutoSize,")]
-    [InlineData("AutoSize,Invalid")]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_InvalidStyleWidth_ThrowsIndexOutOfRangeException(string style)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<IndexOutOfRangeException>(() => converter.ConvertFrom($@"<?xml version=""1.0"" encoding=""utf-16""?><Root><Columns Styles=""{style}"" /></Root>"));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void TableLayoutSettingsTypeConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(TableLayoutSettings), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void TableLayoutSettingsTypeConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_NoStylesOrControls_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        var converter = new TableLayoutSettingsTypeConverter();
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_HasStylesAndControls_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        toolStrip.Items.Add(new ToolStripLabel("text"));
-
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        settings.ColumnStyles.Add(new ColumnStyle(SizeType.AutoSize, 1));
-        settings.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 2));
-        settings.RowStyles.Add(new RowStyle(SizeType.AutoSize, 1));
-        settings.RowStyles.Add(new RowStyle(SizeType.Absolute, 2));
-
-        using var control = new ScrollableControl();
-        settings.SetColumnSpan(control, 1);
-        settings.SetRowSpan(control, 2);
-        settings.SetColumn(control, 3);
-        settings.SetRow(control, 4);
-
-        var converter = new TableLayoutSettingsTypeConverter();
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles=""AutoSize,1,Absolute,2"" /><Rows Styles=""AutoSize,1,Absolute,2"" /></TableLayoutSettings>", result);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_HasControlChildren_ReturnsExpected()
-    {
-        using var panel = new TableLayoutPanel();
-        using var control = new ScrollableControl();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(panel.LayoutSettings);
-
-        panel.Controls.Add(control);
-        settings.SetColumnSpan(control, 1);
-        settings.SetRowSpan(control, 2);
-        settings.SetColumn(control, 3);
-        settings.SetRow(control, 4);
-
-        var converter = new TableLayoutSettingsTypeConverter();
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name="""" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /></Controls><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_StubWithoutChildren_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_StubWithChildren_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.SetColumnSpan("name", 1);
-        settings.SetRowSpan("name", 2);
-        settings.SetColumn("name", 3);
-        settings.SetRow("name", 4);
-
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls><Control Name=""name"" Row=""4"" RowSpan=""2"" Column=""3"" ColumnSpan=""1"" /></Controls><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_HasControlChildWithoutNameProperty_ThrowsInvalidOperationException()
-    {
-        using var control = new TableLayoutPanel();
-        var settings = Assert.IsType<TableLayoutSettings>(control.LayoutSettings);
-
-        using var child = new ControlWithNullName();
-        control.Controls.Add(child);
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<InvalidOperationException>(() => converter.ConvertTo(settings, typeof(string)));
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_HasControlChildWithoutNameStub_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        Assert.Throws<ArgumentNullException>("control", () => settings.SetColumnSpan(null, 1));
-        string result = Assert.IsType<string>(converter.ConvertTo(settings, typeof(string)));
-        Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-16""?><TableLayoutSettings><Controls /><Columns Styles="""" /><Rows Styles="""" /></TableLayoutSettings>", result);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_RowStyleInColumnStyles_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        Assert.Throws<InvalidCastException>(() => settings.ColumnStyles.Add(new RowStyle()));
-
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<InvalidCastException>(() => converter.ConvertTo(settings, typeof(string)));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_ColumnStyleInRowStyles_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        settings.RowStyles.Add(new ColumnStyle());
-
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<InvalidCastException>(() => converter.ConvertTo(settings, typeof(string)));
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_ValueNotTableLayoutSettings_ReturnsExpected()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Equal("1", converter.ConvertTo(1, typeof(string)));
-    }
-
-    [Fact]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Theory]
-    [InlineData(typeof(InstanceDescriptor))]
-    [InlineData(typeof(TableLayoutSettings))]
-    [InlineData(typeof(int))]
-    public void TableLayoutSettingsTypeConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(toolStrip.LayoutSettings, destinationType));
-    }
-
-    [TypeDescriptionProvider(typeof(CustomTypeDescriptionProvider))]
-    private class ControlWithNullName : Control
-    {
-    }
-
-    private class CustomTypeDescriptionProvider : TypeDescriptionProvider
-    {
-        public CustomTypeDescriptionProvider()
-        {
-        }
-
-        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
-        {
-            var mockDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-            mockDescriptor
-                .Setup(c => c.GetProperties())
-                .Returns(new PropertyDescriptorCollection(Array.Empty<PropertyDescriptor>()));
-            return mockDescriptor.Object;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutEventArgsTests.cs
deleted file mode 100644
index 6a761e28124..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutEventArgsTests.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Runtime.CompilerServices;
-
-namespace System.Windows.Forms.Tests;
-
-public class LayoutEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_IComponent_String_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new Control(), "" };
-        yield return new object[] { new SubComponent(), "affectedProperty" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_IComponent_String_TestData))]
-    public void Ctor_IComponent_String(IComponent affectedComponent, string affectedProperty)
-    {
-        var e = new LayoutEventArgs(affectedComponent, affectedProperty);
-        Assert.Equal(affectedComponent, e.AffectedComponent);
-        Assert.Equal(affectedComponent as Control, e.AffectedControl);
-        Assert.Equal(affectedProperty, e.AffectedProperty);
-    }
-
-    public static IEnumerable<object[]> Ctor_Control_String_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new Control(), "" };
-        yield return new object[] { new Control(), "affectedProperty" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_String_TestData))]
-    public void Ctor_Control_String(Control affectedControl, string affectedProperty)
-    {
-        var e = new LayoutEventArgs(affectedControl, affectedProperty);
-        Assert.Equal(affectedControl, e.AffectedComponent);
-        Assert.Equal(affectedControl, e.AffectedControl);
-        Assert.Equal(affectedProperty, e.AffectedProperty);
-    }
-
-    [WinFormsFact]
-    public void LayoutEventArgs_DoesNotRootControl()
-    {
-        LayoutEventArgs layoutEventArgs = CreateAndDisposeControl();
-        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true);
-        Assert.Null(layoutEventArgs.AffectedComponent);
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static LayoutEventArgs CreateAndDisposeControl()
-        {
-            // Setup TableLayoutPanel and Panel
-            using TableLayoutPanel tableLayoutPanel = new()
-            {
-                ColumnCount = 2,
-                RowCount = 2,
-                AutoScroll = true,
-            };
-
-            tableLayoutPanel.Controls.Add(new Panel()
-            {
-                Name = "Panel",
-                Dock = DockStyle.Fill
-            }, 0, 0); // Add the panel to the first cell
-
-            // Force layout update
-            tableLayoutPanel.PerformLayout();
-
-            // Suspend layout
-            tableLayoutPanel.SuspendLayout();
-            using (Panel panel = (Panel)tableLayoutPanel.Controls.Find("Panel", false).First())
-            {
-                tableLayoutPanel.Controls.Remove(panel);
-                panel.Dispose();
-            }
-
-            // Check the cachedLayoutEventArgs
-            ITestAccessor tableLayoutPanelTestAccessor = tableLayoutPanel.TestAccessor();
-            LayoutEventArgs layoutEventArgs = (LayoutEventArgs)tableLayoutPanelTestAccessor.Dynamic._cachedLayoutEventArgs;
-
-            tableLayoutPanel.ResumeLayout();
-            return layoutEventArgs;
-        }
-    }
-
-    private class SubComponent : IComponent
-    {
-        public ISite Site { get; set; }
-
-#pragma warning disable 0067
-        public event EventHandler Disposed;
-#pragma warning restore 0067
-
-        public void Dispose() { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutSettingsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutSettingsTests.cs
deleted file mode 100644
index b32b81bf3b0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LayoutSettingsTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LayoutSettingsTests
-{
-    [Fact]
-    public void LayoutSettings_Ctor_Default()
-    {
-        var settings = new SubLayoutSettings();
-        Assert.Null(settings.LayoutEngine);
-    }
-
-    private class SubLayoutSettings : LayoutSettings
-    {
-        public SubLayoutSettings() : base() { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaConverterTests.cs
deleted file mode 100644
index 11b62b2555a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaConverterTests.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Globalization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkAreaConverterTests
-{
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetConvertFromTheoryData))]
-    [InlineData(typeof(LinkArea), false)]
-    [InlineData(typeof(string), true)]
-    public void LinkAreaConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_TestData()
-    {
-        yield return new object[] { "1,2", new LinkArea(1, 2) };
-        yield return new object[] { "  1 , 1", new LinkArea(1, 1) };
-        yield return new object[] { "   ", null };
-        yield return new object[] { string.Empty, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_TestData))]
-    public void LinkAreaConverter_ConvertFrom_String_ReturnsExpected(string value, object expected)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Equal(expected, converter.ConvertFrom(value));
-        Assert.Equal(expected, converter.ConvertFrom(null, null, value));
-        Assert.Equal(expected, converter.ConvertFrom(null, CultureInfo.InvariantCulture, value));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void LinkAreaConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("1")]
-    [InlineData("1,2,3")]
-    public void LinkAreaConverter_ConvertFrom_InvalidString_ThrowsArgumentException(string value)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<ArgumentException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(LinkArea), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void LinkAreaConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Fact]
-    public void LinkAreaConverter_ConvertTo_String_ReturnsExpected()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Equal("1, 2", converter.ConvertTo(new LinkArea(1, 2), typeof(string)));
-        Assert.Equal("1, 2", converter.ConvertTo(null, null, new LinkArea(1, 2), typeof(string)));
-        Assert.Equal("1, 2", converter.ConvertTo(null, CultureInfo.InvariantCulture, new LinkArea(1, 2), typeof(string)));
-    }
-
-    [Fact]
-    public void LinkAreaConverter_ConvertTo_InstanceDescriptor_ReturnsExpected()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new LinkArea(1, 2), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(LinkArea).GetConstructor(new Type[] { typeof(int), typeof(int) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1, 2 }, descriptor.Arguments);
-    }
-
-    [Fact]
-    public void LinkAreaConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void LinkAreaConverter_ConvertTo_ValueNotLinkArea_ThrowsNotSupportedException()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(LinkArea))]
-    [InlineData(typeof(int))]
-    public void LinkAreaConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new LinkArea(), destinationType));
-    }
-
-    [Fact]
-    public void LinkAreaConverter_CreateInstance_ValidPropertyValues_ReturnsExpected()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        LinkArea area = Assert.IsType<LinkArea>(converter.CreateInstance(
-            null, new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), 1 },
-                { nameof(LinkArea.Length), 2 }
-            }));
-        Assert.Equal(new LinkArea(1, 2), area);
-    }
-
-    [Fact]
-    public void LinkAreaConverter_CreateInstance_NullPropertyValues_ThrowsArgumentNullException()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<ArgumentNullException>("propertyValues", () => converter.CreateInstance(null, null));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_InvalidPropertyValueType_TestData()
-    {
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), new object() },
-                { nameof(LinkArea.Length), 2 },
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), null },
-                { nameof(LinkArea.Length), 2 },
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Length), 2 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), 1 },
-                { nameof(LinkArea.Length), new object() }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), 1 },
-                { nameof(LinkArea.Length), null }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(LinkArea.Start), 1 }
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_InvalidPropertyValueType_TestData))]
-    public void LinkAreaConverter_CreateInstance_InvalidPropertyValueType_ThrowsArgumentException(IDictionary propertyValues)
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.Throws<ArgumentException>("propertyValues", () => converter.CreateInstance(null, propertyValues));
-    }
-
-    [Fact]
-    public void LinkAreaConverter_GetCreateInstanceSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.True(converter.GetCreateInstanceSupported());
-    }
-
-    [Fact]
-    public void LinkAreaConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        PropertyDescriptorCollection properties = converter.GetProperties(null);
-        Assert.Equal(2, properties.Count);
-        Assert.Equal(nameof(LinkArea.Start), properties[0].Name);
-        Assert.Equal(nameof(LinkArea.Length), properties[1].Name);
-    }
-
-    [Fact]
-    public void LinkAreaConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new LinkArea.LinkAreaConverter();
-        Assert.True(converter.GetPropertiesSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaTests.cs
deleted file mode 100644
index 94638a90e99..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkAreaTests.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkAreaTests
-{
-    [Fact]
-    public void LinkArea_Ctor_Default()
-    {
-        var area = new LinkArea();
-        Assert.Equal(0, area.Start);
-        Assert.Equal(0, area.Length);
-        Assert.True(area.IsEmpty);
-    }
-
-    [Theory]
-    [InlineData(-1, -2, false)]
-    [InlineData(0, 0, true)]
-    [InlineData(1, 2, false)]
-    [InlineData(1, 0, false)]
-    [InlineData(0, 1, false)]
-    public void LinkArea_Ctor_Int_Int(int start, int length, bool expectedIsEmpty)
-    {
-        var area = new LinkArea(start, length);
-        Assert.Equal(start, area.Start);
-        Assert.Equal(length, area.Length);
-        Assert.Equal(expectedIsEmpty, area.IsEmpty);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void LinkArea_Start_Set_GetReturnsExpected(int value)
-    {
-        var area = new LinkArea
-        {
-            Start = value
-        };
-        Assert.Equal(value, area.Start);
-
-        // Set same.
-        area.Start = value;
-        Assert.Equal(value, area.Start);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void LinkArea_Length_Set_GetReturnsExpected(int value)
-    {
-        var area = new LinkArea
-        {
-            Length = value
-        };
-        Assert.Equal(value, area.Length);
-
-        // Set same.
-        area.Length = value;
-        Assert.Equal(value, area.Length);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new LinkArea(1, 2), new LinkArea(1, 2), true };
-        yield return new object[] { new LinkArea(1, 2), new LinkArea(2, 2), false };
-        yield return new object[] { new LinkArea(1, 2), new LinkArea(1, 3), false };
-
-        yield return new object[] { new LinkArea(1, 2), new object(), false };
-        yield return new object[] { new LinkArea(1, 2), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void LinkArea_Equals_Invoke_ReturnsExpected(LinkArea area, object other, bool expected)
-    {
-        if (other is LinkArea otherArea)
-        {
-            Assert.Equal(expected, area == otherArea);
-            Assert.Equal(!expected, area != otherArea);
-            Assert.Equal(expected, area.GetHashCode().Equals(otherArea.GetHashCode()));
-        }
-
-        Assert.Equal(expected, area.Equals(other));
-    }
-
-    [Fact]
-    public void LinkArea_ToString_Invoke_ReturnsExpected()
-    {
-        var area = new LinkArea(1, 2);
-        Assert.Equal("{Start=1, Length=2}", area.ToString());
-    }
-
-    [Fact]
-    public void LinkArea_TypeConverter_Get_ReturnsLinkAreaConverter()
-    {
-        var area = new LinkArea(1, 2);
-        Assert.IsType<LinkArea.LinkAreaConverter>(TypeDescriptor.GetConverter(area));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkClickedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkClickedEventArgsTests.cs
deleted file mode 100644
index 13423230131..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkClickedEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkClickedEventArgsTests
-{
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("linkText")]
-    public void Ctor_String(string linkText)
-    {
-        var e = new LinkClickedEventArgs(linkText);
-        Assert.Equal(linkText, e.LinkText);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkConverterTests.cs
deleted file mode 100644
index 3e5348a389f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkConverterTests.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Globalization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkConverterTests
-{
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetConvertFromTheoryData))]
-    [InlineData(typeof(LinkLabel.Link), false)]
-    [InlineData(typeof(string), true)]
-    public void LinkConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new LinkConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_TestData()
-    {
-        yield return new object[] { "1,2", new LinkLabel.Link(1, 2) };
-        yield return new object[] { "  1 , 1", new LinkLabel.Link(1, 1) };
-        yield return new object[] { "   ", null };
-        yield return new object[] { string.Empty, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_TestData))]
-    public void LinkConverter_ConvertFrom_String_ReturnsExpected(string value, object expected)
-    {
-        var converter = new LinkConverter();
-        AssertEqualLink(expected, converter.ConvertFrom(value));
-        AssertEqualLink(expected, converter.ConvertFrom(null, null, value));
-        AssertEqualLink(expected, converter.ConvertFrom(null, CultureInfo.InvariantCulture, value));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void LinkConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new LinkConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("1")]
-    [InlineData("1,2,3")]
-    public void LinkConverter_ConvertFrom_InvalidString_ThrowsArgumentException(string value)
-    {
-        var converter = new LinkConverter();
-        Assert.Throws<ArgumentException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(LinkLabel.Link), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void LinkConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new LinkConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Fact]
-    public void LinkConverter_ConvertTo_String_ReturnsExpected()
-    {
-        var converter = new LinkConverter();
-        Assert.Equal("1, 2", converter.ConvertTo(new LinkLabel.Link(1, 2), typeof(string)));
-        Assert.Equal("1, 2", converter.ConvertTo(null, null, new LinkLabel.Link(1, 2), typeof(string)));
-        Assert.Equal("1, 2", converter.ConvertTo(null, CultureInfo.InvariantCulture, new LinkLabel.Link(1, 2), typeof(string)));
-    }
-
-    [Fact]
-    public void LinkConverter_ConvertTo_InstanceDescriptor_ReturnsExpected()
-    {
-        var converter = new LinkConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new LinkLabel.Link(1, 2), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(LinkLabel.Link).GetConstructor(new Type[] { typeof(int), typeof(int) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1, 2 }, descriptor.Arguments);
-        Assert.True(descriptor.IsComplete);
-    }
-
-    [Fact]
-    public void LinkConverter_ConvertTo_InstanceDescriptorWithLinkData_ReturnsExpected()
-    {
-        var converter = new LinkConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new LinkLabel.Link(1, 2, "linkData"), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(LinkLabel.Link).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(object) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1, 2, "linkData" }, descriptor.Arguments);
-        Assert.True(descriptor.IsComplete);
-    }
-
-    [Fact]
-    public void LinkConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new LinkConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void LinkConverter_ConvertTo_ValueNotLink_ThrowsNotSupportedException()
-    {
-        var converter = new LinkConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(LinkLabel.Link))]
-    [InlineData(typeof(int))]
-    public void LinkConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new LinkConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new LinkLabel.Link(), destinationType));
-    }
-
-    [Fact]
-    public void LinkConverter_GetCreateInstanceSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new LinkConverter();
-        Assert.False(converter.GetCreateInstanceSupported());
-    }
-
-    [Fact]
-    public void LinkConverter_GetPropertiesSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new LinkConverter();
-        Assert.False(converter.GetPropertiesSupported());
-    }
-
-    private static void AssertEqualLink(object expected, object actual)
-    {
-        if (expected is LinkLabel.Link expectedLink && actual is LinkLabel.Link actualLink)
-        {
-            Assert.Equal(expectedLink.Description, actualLink.Description);
-            Assert.Equal(expectedLink.Enabled, actualLink.Enabled);
-            Assert.Equal(expectedLink.Length, actualLink.Length);
-            Assert.Equal(expectedLink.LinkData, actualLink.LinkData);
-            Assert.Equal(expectedLink.Name, actualLink.Name);
-            Assert.Equal(expectedLink.Start, actualLink.Start);
-            Assert.Equal(expectedLink.Tag, actualLink.Tag);
-            Assert.Equal(expectedLink.Visited, actualLink.Visited);
-        }
-        else
-        {
-            Assert.Equal(expected, actual);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.Link.LinkAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.Link.LinkAccessibleObjectTests.cs
deleted file mode 100644
index 2755504f677..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.Link.LinkAccessibleObjectTests.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.LinkLabel;
-using static System.Windows.Forms.LinkLabel.Link;
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class LinkLabel_Link_LinkAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void LinkAccessibleObject_Ctor_OwnerLinkCannotBeNull()
-    {
-        using LinkLabel linkLabel = new();
-
-        Assert.Throws<ArgumentNullException>(() => new LinkAccessibleObject(link: null, linkLabel));
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_Ctor_OwnerLinkLabelCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new LinkAccessibleObject(new Link(), owner: null));
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_CurrentIndex_IsExpected()
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        for (int index = 0; index < 4; index++)
-        {
-            LinkAccessibleObject linkAccessibleObject = linkLabel.Links[index].AccessibleObject;
-            int actual = linkAccessibleObject.TestAccessor().Dynamic.CurrentIndex;
-
-            Assert.Equal(index, actual);
-        }
-
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("TestDescription")]
-    [InlineData(null)]
-    public void LinkAccessibleObject_Description_IsExpected(string description)
-    {
-        using LinkLabel linkLabel = new();
-
-        Link link = linkLabel.Links[0];
-        link.Description = description;
-
-        Assert.Equal(description, link.AccessibleObject.Description);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_FragmentNavigate_NextSibling_IsExpected()
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        AccessibleObject linkLabelAccessibleObject1 = linkLabel.Links[0].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject2 = linkLabel.Links[1].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject3 = linkLabel.Links[2].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject4 = linkLabel.Links[3].AccessibleObject;
-
-        Assert.Equal(linkLabelAccessibleObject2, linkLabelAccessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(linkLabelAccessibleObject3, linkLabelAccessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(linkLabelAccessibleObject4, linkLabelAccessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(linkLabelAccessibleObject4.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_FragmentNavigate_PreviousSibling_IsExpected()
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        AccessibleObject linkLabelAccessibleObject1 = linkLabel.Links[0].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject2 = linkLabel.Links[1].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject3 = linkLabel.Links[2].AccessibleObject;
-        AccessibleObject linkLabelAccessibleObject4 = linkLabel.Links[3].AccessibleObject;
-
-        Assert.Null(linkLabelAccessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(linkLabelAccessibleObject1, linkLabelAccessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(linkLabelAccessibleObject2, linkLabelAccessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(linkLabelAccessibleObject3, linkLabelAccessibleObject4.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void LinkAccessibleObject_FragmentNavigate_Parent_IsExpected(int linkIndex)
-    {
-        using LinkLabel linkLabel = new();
-
-        AccessibleObject expected = linkLabel.AccessibilityObject;
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        LinkAccessibleObject linkAccessibleObject = linkLabel.Links[linkIndex].AccessibleObject;
-        UiaCore.IRawElementProviderFragment actual = linkAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(expected, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_Parent_IsExpected_IfNoOneLinkWasAdded()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject linkAccessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        AccessibleObject expected = linkLabel.AccessibilityObject;
-        AccessibleObject actual = linkAccessibleObject.Parent;
-
-        Assert.Equal(linkLabel.AccessibilityObject, linkAccessibleObject.Parent);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_Role_IsLink()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        AccessibleRole actual = accessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(((int)UiaCore.UIA.IsInvokePatternAvailablePropertyId))]
-    public void LinkAccessibleObject_GetPropertyValue_IsPatternSupported(int propertyId)
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        bool actual = (bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId);
-
-        Assert.True(actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_GetPropertyValue_RuntimeIdNotNull()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.NotNull(actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        object actual = accessibleObject.GetPropertyValue(UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(accessibleObject.RuntimeId, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_GetPropertyValue_Name_IsExpected_ForOneLink()
-    {
-        using LinkLabel linkLabel = new();
-        string testName = "TestNameLink";
-        linkLabel.Text = testName;
-
-        LinkAccessibleObject linkAccessibleObject = linkLabel.Links[0].AccessibleObject;
-        object actual = linkAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal(testName, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_Name_IsExpected_ForSeveralLinks()
-    {
-        using LinkLabel linkLabel = new();
-        string[] names = { "Home", "About", "Help", "Details" };
-        linkLabel.Text = string.Join(' ', names);
-        int start = 0;
-
-        foreach (string name in names)
-        {
-            linkLabel.Links.Add(new(start, name.Length));
-            start += name.Length + 1;
-        }
-
-        for (int index = 0; index < linkLabel.Links.Count; index++)
-        {
-            string actual = linkLabel.Links[index].AccessibleObject.Name;
-
-            Assert.Equal(names[index], actual);
-        }
-
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_GetPropertyValue_HelpText_ReturnsExpected()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        object actual = accessibleObject.GetPropertyValue(UIA.HelpTextPropertyId);
-
-        Assert.Equal(accessibleObject.Help ?? string.Empty, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkAccessibleObject_GetPropertyValue_IsOffscreen_ReturnsFalse()
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        var actual = (bool)accessibleObject.GetPropertyValue(UIA.IsOffscreenPropertyId);
-
-        Assert.False(actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsValuePatternAvailablePropertyId))]
-    public void LinkAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using LinkLabel linkLabel = new();
-        LinkAccessibleObject accessibleObject = linkLabel.Links[0].AccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UIA)propertyId) ?? false);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkComparerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkComparerTests.cs
deleted file mode 100644
index d3ec95d5b0f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkComparerTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class LinkLabel_LinkComparerTests
-{
-    public static IEnumerable<object[]> LinkCompare_Return_IsExpected_TestData()
-    {
-        yield return new object[] { null, null, 0 };
-        yield return new object[] { null, new LinkLabel.Link(0, 1), -1 };
-        yield return new object[] { new LinkLabel.Link(0, 1), null, 1 };
-        yield return new object[] { new LinkLabel.Link(0, 1), new LinkLabel.Link(0, 1), 0 };
-        yield return new object[] { new LinkLabel.Link(1, 5), new LinkLabel.Link(2, 5), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LinkCompare_Return_IsExpected_TestData))]
-    public void LinkCompare_Return_IsExpected(object link1, object link2, int expectedValue)
-    {
-        using var linkLabel = new LinkLabel();
-        var comparer = linkLabel.TestAccessor().Dynamic.s_linkComparer;
-        var compareMethod = comparer.GetType().GetMethod("Compare");
-        Assert.Equal(expectedValue, compareMethod.Invoke(comparer, new object[] { link1, link2 }));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkLabelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkLabelAccessibleObjectTests.cs
deleted file mode 100644
index ee7242efe84..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabel.LinkLabelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.LinkLabel;
-using static System.Windows.Forms.LinkLabel.Link;
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class LinkLabel_LinkLabelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void LinkLabelAccessibleObject_Ctor_Default()
-    {
-        using LinkLabel linkLabel = new();
-        LinkLabelAccessibleObject accessibleObject = new(linkLabel);
-
-        Assert.Equal(linkLabel, accessibleObject.Owner);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkLabelAccessibleObject_ControlType_IsText_IfAccessibleRoleIsDefault()
-    {
-        using LinkLabel linkLabel = new();
-        // AccessibleRole is not set = Default
-
-        object actual = linkLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TextControlTypeId, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> LinkLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LinkLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void LinkLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using LinkLabel linkLabel = new();
-        linkLabel.AccessibleRole = role;
-
-        object actual = linkLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkLabelAccessibleObject_Role_IsStaticText_ByDefault()
-    {
-        using LinkLabel linkLabel = new();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = linkLabel.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.StaticText, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(4)]
-    [InlineData(10)]
-    public void LinkLabelAccessibleObject_GetChildCount_IsExpected(int linkCount)
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int i = 0; i < linkCount; i++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        int actual = linkLabel.AccessibilityObject.GetChildCount();
-
-        Assert.Equal(linkCount, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(15)]
-    [InlineData(27)]
-    [InlineData(38)]
-    [InlineData(49)]
-    public void LinkLabelAccessibleObject_GetChild_IsExpectedValue(int childIndex)
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int index = 0; index < 50; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        LinkAccessibleObject expected = linkLabel.Links[childIndex].AccessibleObject;
-        var actual = (LinkAccessibleObject)linkLabel.AccessibilityObject.GetChild(childIndex);
-
-        Assert.Equal(expected, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1000)]
-    public void LinkLabelAccessibleObject_GetChild_IsNull(int childIndex)
-    {
-        using LinkLabel linkLabel = new();
-
-        for (int index = 0; index < 50; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        Assert.Null(linkLabel.AccessibilityObject.GetChild(childIndex));
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void LinkLabelAccessibleObject_GetPropertyValue_Enabled_IsExpected(bool isEnabled)
-    {
-        using LinkLabel linkLabel = new();
-
-        linkLabel.Enabled = isEnabled;
-        bool actual = (bool)linkLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId);
-
-        Assert.Equal(isEnabled, actual);
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkLabelAccessibleObject_FragmentNavigate_IsExpected_NavigateToFirstChild()
-    {
-        using LinkLabel linkLabel = new();
-        AccessibleObject accessibleObject = linkLabel.AccessibilityObject;
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        Assert.Equal(linkLabel.Links[0].AccessibleObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkLabelAccessibleObject_FragmentNavigate_IsExpected_NavigateToLastChild()
-    {
-        using LinkLabel linkLabel = new();
-        AccessibleObject accessibleObject = linkLabel.AccessibilityObject;
-
-        for (int index = 0; index < 4; index++)
-        {
-            linkLabel.Links.Add(new());
-        }
-
-        Assert.Equal(linkLabel.Links[^1].AccessibleObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.False(linkLabel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void LinkLabel_Releases_UiaProvider()
-    {
-        using LinkLabel linkLabel = new();
-        AccessibleObject accessibleObject = linkLabel.AccessibilityObject;
-
-        Assert.True(linkLabel.IsAccessibilityObjectCreated);
-
-        linkLabel.ReleaseUiaProvider(linkLabel.HWND);
-
-        Assert.False(linkLabel.IsAccessibilityObjectCreated);
-        Assert.True(linkLabel.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabelLinkClickedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabelLinkClickedEventArgsTests.cs
deleted file mode 100644
index 355fa34602e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkLabelLinkClickedEventArgsTests.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkLabelLinkClickedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_LinkLabelLink_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new LinkLabel.Link() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_LinkLabelLink_TestData))]
-    public void Ctor_LinkLabelLink(LinkLabel.Link link)
-    {
-        var e = new LinkLabelLinkClickedEventArgs(link);
-        Assert.Equal(link, e.Link);
-        Assert.Equal(MouseButtons.Left, e.Button);
-    }
-
-    public static IEnumerable<object[]> Ctor_LinkLabelLink_MouseButtons_TestData()
-    {
-        yield return new object[] { null, (MouseButtons)1 };
-        yield return new object[] { new LinkLabel.Link(), MouseButtons.Left };
-        yield return new object[] { new LinkLabel.Link(), MouseButtons.None };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_LinkLabelLink_MouseButtons_TestData))]
-    public void Ctor_LinkLabelLink_MouseButtons(LinkLabel.Link link, MouseButtons button)
-    {
-        var e = new LinkLabelLinkClickedEventArgs(link, button);
-        Assert.Equal(link, e.Link);
-        Assert.Equal(button, e.Button);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkTests.cs
deleted file mode 100644
index 17b9d0f5fa4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/LinkTests.cs
+++ /dev/null
@@ -1,191 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class LinkTests
-{
-    [Fact]
-    public void Link_Ctor_Default()
-    {
-        var link = new LinkLabel.Link();
-        Assert.Null(link.Description);
-        Assert.True(link.Enabled);
-        Assert.Equal(0, link.Length);
-        Assert.Null(link.LinkData);
-        Assert.Empty(link.Name);
-        Assert.Equal(0, link.Start);
-        Assert.Null(link.Tag);
-        Assert.False(link.Visited);
-    }
-
-    [Theory]
-    [InlineData(-2, -3, -3)]
-    [InlineData(-2, -1, 0)]
-    [InlineData(-1, 0, 0)]
-    [InlineData(0, 0, 0)]
-    [InlineData(1, 2, 2)]
-    public void Link_Ctor_Int_Int(int start, int length, int expectedLength)
-    {
-        var link = new LinkLabel.Link(start, length);
-        Assert.Null(link.Description);
-        Assert.True(link.Enabled);
-        Assert.Equal(expectedLength, link.Length);
-        Assert.Null(link.LinkData);
-        Assert.Empty(link.Name);
-        Assert.Equal(start, link.Start);
-        Assert.Null(link.Tag);
-        Assert.False(link.Visited);
-    }
-
-    [Theory]
-    [InlineData(-2, -3, null, -3)]
-    [InlineData(-2, -1, "", 0)]
-    [InlineData(-1, 0, "linkData", 0)]
-    [InlineData(0, 0, "linkData", 0)]
-    [InlineData(1, 2, "linkData", 2)]
-    public void Link_Ctor_Int_Int_Object(int start, int length, object linkData, int expectedLength)
-    {
-        var link = new LinkLabel.Link(start, length, linkData);
-        Assert.Null(link.Description);
-        Assert.True(link.Enabled);
-        Assert.Equal(expectedLength, link.Length);
-        Assert.Same(linkData, link.LinkData);
-        Assert.Empty(link.Name);
-        Assert.Equal(start, link.Start);
-        Assert.Null(link.Tag);
-        Assert.False(link.Visited);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void Link_Description_SetWithoutOwner_GetReturnsExpected(string value)
-    {
-        var link = new LinkLabel.Link
-        {
-            Description = value
-        };
-        Assert.Same(value, link.Description);
-
-        // Set same.
-        link.Description = value;
-        Assert.Same(value, link.Description);
-    }
-
-    [Theory]
-    [BoolData]
-    public void Link_Enabled_SetWithoutOwner_GetReturnsExpected(bool value)
-    {
-        var link = new LinkLabel.Link
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, link.Enabled);
-
-        // Set same.
-        link.Enabled = value;
-        Assert.Equal(value, link.Enabled);
-
-        // Set opposite.
-        link.Enabled = !value;
-        Assert.Equal(!value, link.Enabled);
-    }
-
-    [Theory]
-    [InlineData(-2, -2)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void Link_Length_SetWithoutOwner_GetReturnsExpected(int value, int expected)
-    {
-        var link = new LinkLabel.Link
-        {
-            Length = value
-        };
-        Assert.Equal(expected, link.Length);
-
-        // Set same.
-        link.Length = value;
-        Assert.Equal(expected, link.Length);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void Link_LinkData_SetWithoutOwner_GetReturnsExpected(string value)
-    {
-        var link = new LinkLabel.Link
-        {
-            LinkData = value
-        };
-        Assert.Same(value, link.LinkData);
-
-        // Set same.
-        link.LinkData = value;
-        Assert.Same(value, link.LinkData);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void Link_Name_SetWithoutOwner_GetReturnsExpected(string value, string expected)
-    {
-        var link = new LinkLabel.Link
-        {
-            Name = value
-        };
-        Assert.Equal(expected, link.Name);
-
-        // Set same.
-        link.LinkData = value;
-        Assert.Equal(expected, link.Name);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Link_Start_SetWithoutOwner_GetReturnsExpected(int value)
-    {
-        var link = new LinkLabel.Link
-        {
-            Start = value
-        };
-        Assert.Equal(value, link.Start);
-
-        // Set same.
-        link.Start = value;
-        Assert.Equal(value, link.Start);
-    }
-
-    [Theory]
-    [StringWithNullData]
-    public void Link_Tag_SetWithoutOwner_GetReturnsExpected(string value)
-    {
-        var link = new LinkLabel.Link
-        {
-            Tag = value
-        };
-        Assert.Same(value, link.Tag);
-
-        // Set same.
-        link.Tag = value;
-        Assert.Same(value, link.Tag);
-    }
-
-    [Theory]
-    [BoolData]
-    public void Link_Visited_SetWithoutOwner_GetReturnsExpected(bool value)
-    {
-        var link = new LinkLabel.Link
-        {
-            Visited = value
-        };
-        Assert.Equal(value, link.Visited);
-
-        // Set same.
-        link.Visited = value;
-        Assert.Equal(value, link.Visited);
-
-        // Set opposite.
-        link.Visited = !value;
-        Assert.Equal(!value, link.Visited);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBindingHelperTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBindingHelperTests.cs
deleted file mode 100644
index 5c00b82643e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBindingHelperTests.cs
+++ /dev/null
@@ -1,950 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Globalization;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListBindingHelperTests
-{
-    public static IEnumerable<object[]> GetList_Object_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { 1, 1 };
-        yield return new object[] { typeof(int), typeof(int) };
-        yield return new object[] { new int[] { 1 }, new int[] { 1 } };
-        yield return new object[] { typeof(int[]), typeof(int[]) };
-
-        var mockSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockSource
-            .Setup(s => s.GetList())
-            .Returns(new int[] { 1 });
-        yield return new object[] { mockSource.Object, new int[] { 1 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetList_Object_TestData))]
-    public void ListBindingHelper_GetList_InvokeObject_ReturnsExpected(object list, object expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetList(list));
-    }
-
-    public static IEnumerable<object[]> GetList_Object_String_TestData()
-    {
-        yield return new object[] { null, "dataMember", null };
-
-        yield return new object[] { new DataClass { Property = 1 }, "Property", 1 };
-        yield return new object[] { new DataClass { Property = 1 }, "property", 1 };
-        yield return new object[] { typeof(DataClass), "NoSuchProperty", typeof(DataClass) };
-        yield return new object[] { typeof(DataClass), "Property", typeof(DataClass) };
-
-        yield return new object[] { new ListDataClass(), "ListProperty", null };
-        yield return new object[] { new ListDataClass { ListProperty = new List<DataClass>() }, "ListProperty", new List<DataClass>() };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new DataClass { Property = 1 } }), "Property", 1 };
-
-        var nullCurrencyManagerProvider = new Mock<ICurrencyManagerProvider>(MockBehavior.Strict);
-        nullCurrencyManagerProvider
-            .Setup(c => c.CurrencyManager)
-            .Returns((CurrencyManager)null);
-        yield return new object[] { nullCurrencyManagerProvider.Object, "CurrencyManager", null };
-
-        var emptySource = new BindingSource();
-        var invalidCurrencyManagerProvider = new Mock<ICurrencyManagerProvider>(MockBehavior.Strict);
-        invalidCurrencyManagerProvider
-            .Setup(c => c.CurrencyManager)
-            .Returns(emptySource.CurrencyManager);
-        yield return new object[] { invalidCurrencyManagerProvider.Object, "CurrencyManager", null };
-
-        var validSource = new BindingSource(new List<CustomCurrencyManagerProvider> { new CustomCurrencyManagerProvider { Property = 1 } }, null);
-        yield return new object[] { new CustomCurrencyManagerProvider { CurrencyManagerResult = validSource.CurrencyManager }, "Property", 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetList_Object_String_TestData))]
-    public void ListBindingHelper_GetList_InvokeObjectString_ReturnsExpected(object dataSource, string dataMember, object expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetList(dataSource, dataMember));
-    }
-
-    public static IEnumerable<object[]> GetList_NoSuchDataMember_TestData()
-    {
-        yield return new object[] { new DataClass(), "NoSuchProperty" };
-        yield return new object[] { new IEnumerableWrapper(Array.Empty<object>()), "NoSuchProperty" };
-        yield return new object[] { new IEnumerableWrapper(Array.Empty<object>()), "Property" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetList_NoSuchDataMember_TestData))]
-    public void ListBindingHelper_GetList_NoSuchDataMember_ThrowsArgumentException(object dataSource, string dataMember)
-    {
-        Assert.Throws<ArgumentException>(() => ListBindingHelper.GetList(dataSource, dataMember));
-    }
-
-    public static IEnumerable<object[]> GetList_DataMember_TestData()
-    {
-        yield return new object[] { null, null, null };
-        yield return new object[] { null, string.Empty, null };
-        yield return new object[] { null, "reasonable", null };
-        yield return new object[] { 1, null, 1 };
-        yield return new object[] { 1, string.Empty, 1 };
-        yield return new object[] { typeof(int), null, typeof(int) };
-        yield return new object[] { typeof(int), string.Empty, typeof(int) };
-        yield return new object[] { typeof(int), "reasonable", typeof(int) };
-
-        var mockSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockSource
-            .Setup(s => s.GetList())
-            .Returns(new int[] { 1 });
-        yield return new object[] { mockSource.Object, null, new int[] { 1 } };
-        yield return new object[] { mockSource.Object, string.Empty, new int[] { 1 } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetList_DataMember_TestData))]
-    public void ListBindingHelper_GetList_InvokeDataMember_ReturnsExpected(object dataSource, string dataMember, object expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetList(dataSource, dataMember));
-    }
-
-    public static IEnumerable<object[]> GetListItemType_Object_TestData()
-    {
-        yield return new object[] { null, null };
-
-        yield return new object[] { 1, typeof(int) };
-        yield return new object[] { typeof(int), typeof(int) };
-
-        yield return new object[] { new int[] { 1 }, typeof(int) };
-        yield return new object[] { typeof(int[]), typeof(int) };
-
-        yield return new object[] { new List<int> { 1 }, typeof(int) };
-        yield return new object[] { typeof(List<int>), typeof(int) };
-
-        yield return new object[] { typeof(IList<int>), typeof(int) };
-        yield return new object[] { typeof(IList), typeof(IList) };
-        yield return new object[] { typeof(ICollection<int>), typeof(ICollection<int>) };
-        yield return new object[] { typeof(IEnumerable), typeof(IEnumerable) };
-
-        yield return new object[] { new Dictionary<int, string> { { 1, "string" } }, typeof(KeyValuePair<int, string>) };
-        yield return new object[] { typeof(Dictionary<int, string>), typeof(Dictionary<int, string>) };
-
-        yield return new object[] { new ClassWithItem(), typeof(ClassWithItem) };
-        yield return new object[] { typeof(ClassWithItem), typeof(ClassWithItem) };
-
-        var genericMockSource = new Mock<IListSource>(MockBehavior.Strict);
-        genericMockSource.Setup(s => s.GetList()).Returns(new GenericIListSourceClassWithItem());
-        yield return new object[] { genericMockSource.Object, typeof(int) };
-
-        var nonGenericMockSource = new Mock<IListSource>(MockBehavior.Strict);
-        nonGenericMockSource.Setup(s => s.GetList()).Returns(new GenericIListSourceClassWithItem());
-        yield return new object[] { nonGenericMockSource.Object, typeof(int) };
-
-        yield return new object[] { new ITypedListClassWithItem(), typeof(string) };
-        yield return new object[] { new ITypedListClassWithCustomNamedItem(), typeof(string) };
-        yield return new object[] { new OnlyGenericIListClassWithItem(), typeof(string) };
-
-        yield return new object[] { new ClassWithIListSource(), typeof(int) };
-        yield return new object[] { typeof(ClassWithIListSource), typeof(int) };
-
-        yield return new object[] { new NullIListSource(), null };
-        yield return new object[] { typeof(NullIListSource), null };
-
-        // Type that wraps an enumerable but ONLY implements non-generic IEnumerable.
-        yield return new object[] { new IEnumerableWrapper(null), typeof(object) };
-        yield return new object[] { new IEnumerableWrapper(Array.Empty<object>()), typeof(object) };
-        yield return new object[] { new IEnumerableWrapper(new int[] { 1 }), typeof(int) };
-        yield return new object[] { new IEnumerableWrapper(new object[] { 1 }), typeof(int) };
-        yield return new object[] { new IEnumerableWrapper(new object[] { 1, string.Empty }), typeof(int) };
-        yield return new object[] { new IEnumerableWrapper(new object[] { null }), typeof(object) };
-        yield return new object[] { new NotSupportedIEnumerable(), typeof(object) };
-
-        // Type that only implements IList.
-        yield return new object[] { new ArrayList(), typeof(object) };
-        yield return new object[] { new ArrayList { 1 }, typeof(int) };
-        yield return new object[] { new ArrayList { 1, string.Empty }, typeof(int) };
-        yield return new object[] { new ArrayList { null }, typeof(object) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemType_Object_TestData))]
-    public void ListBindingHelper_GetListItemType_InvokeObject_ReturnsExpected(object list, Type expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetListItemType(list));
-        Assert.Equal(list is null ? typeof(object) : expected, ListBindingHelper.GetListItemType(list, null));
-        Assert.Equal(list is null ? typeof(object) : expected, ListBindingHelper.GetListItemType(list, string.Empty));
-    }
-
-    public static IEnumerable<object[]> GetListItemType_Object_String_TestData()
-    {
-        yield return new object[] { null, "dataMember", typeof(object) };
-        yield return new object[] { new NullIListSource(), "dataMember", typeof(object) };
-        yield return new object[] { new DataClass(), "noSuchMember", typeof(object) };
-        yield return new object[] { new DataClass { Property = 1 }, "Property", typeof(int) };
-        yield return new object[] { new DataClass { Property = 1 }, "property", typeof(int) };
-        yield return new object[] { new ICustomTypeDescriptorPropertyClass(), "Property", typeof(ICustomTypeDescriptor) };
-
-        var nullMockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        nullMockTypedList.Setup(t => t.GetItemProperties(null)).Returns((PropertyDescriptorCollection)null);
-        yield return new object[] { nullMockTypedList.Object, "dataMember", typeof(object) };
-
-        var instance = new ICustomTypeDescriptorPropertyDescriptorClass();
-        var customTypeDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-        customTypeDescriptor
-            .Setup(t => t.GetProperties())
-            .Returns(new PropertyDescriptorCollection(new PropertyDescriptor[] { new CustomPropertyDescriptor("Property", null) }));
-        var customPropertyDescriptorProvider = new Mock<TypeDescriptionProvider>(MockBehavior.Strict);
-        customPropertyDescriptorProvider
-            .Setup(p => p.GetTypeDescriptor(instance.GetType(), instance))
-            .Returns(customTypeDescriptor.Object);
-        customPropertyDescriptorProvider
-            .Setup(p => p.GetCache(instance))
-            .Returns((IDictionary)null);
-        customPropertyDescriptorProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(instance))
-            .Returns(customTypeDescriptor.Object);
-        TypeDescriptor.AddProvider(customPropertyDescriptorProvider.Object, instance);
-        yield return new object[] { instance, "Property", typeof(object) };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemType_Object_String_TestData))]
-    public void ListBindingHelper_GetListItemType_InvokeObjectString_ReturnsExpected(object list, string dataMember, Type expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetListItemType(list, dataMember));
-    }
-
-    [Theory]
-    [InlineData(typeof(PrivateDefaultConstructor))]
-    [InlineData(typeof(NoDefaultConstructor))]
-    [InlineData(typeof(ThrowingDefaultConstructor))]
-    public void ListBindingHelper_GetListItemType_InvalidIListSourceType_ThrowsNotSupportedException(Type list)
-    {
-        Assert.Throws<NotSupportedException>(() => ListBindingHelper.GetListItemType(list));
-        Assert.Throws<NotSupportedException>(() => ListBindingHelper.GetListItemType(list, null));
-        Assert.Throws<NotSupportedException>(() => ListBindingHelper.GetListItemType(list, string.Empty));
-        Assert.Throws<NotSupportedException>(() => ListBindingHelper.GetListItemType(list, "dataMember"));
-    }
-
-    public static IEnumerable<object[]> GetListItemProperties_Object_TestData()
-    {
-        // Simple objects.
-        yield return new object[] { null, Array.Empty<string>() };
-        yield return new object[] { 1, Array.Empty<string>() };
-        yield return new object[] { typeof(int), Array.Empty<string>() };
-
-        yield return new object[] { string.Empty, new string[] { "Length" } };
-        yield return new object[] { typeof(string), new string[] { "Length" } };
-
-        yield return new object[] { new DataClass(), new string[] { "Property" } };
-        yield return new object[] { typeof(DataClass), new string[] { "Property" } };
-
-        // Lists.
-        yield return new object[] { new List<DataClass>(), new string[] { "Property" } };
-        yield return new object[] { typeof(IList<DataClass>), new string[] { "Property" } };
-
-        yield return new object[] { new List<ICustomTypeDescriptor>(), Array.Empty<string>() };
-        yield return new object[] { typeof(IList<ICustomTypeDescriptor>), Array.Empty<string>() };
-
-        // Array.
-        yield return new object[] { Array.Empty<DataClass>(), new string[] { "Property" } };
-        yield return new object[] { typeof(DataClass[]), new string[] { "Property" } };
-        yield return new object[] { Array.Empty<object>(), Array.Empty<string>() };
-        yield return new object[] { new object[] { new DataClass() }, Array.Empty<string>() };
-
-        // Only implements IEnumerable.
-        yield return new object[] { new IEnumerableWrapper(Array.Empty<object>()), Array.Empty<string>() };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new DataClass() }), new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { 1 }), new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { null }), Array.Empty<string>() };
-
-        // Only implements IList.
-        yield return new object[] { new ArrayList(), Array.Empty<string>() };
-        yield return new object[] { new ArrayList { new DataClass() }, new string[] { "Property" } };
-        yield return new object[] { new ArrayList { 1 }, Array.Empty<string>() };
-        yield return new object[] { new ArrayList { null }, Array.Empty<string>() };
-
-        // ITypedList.
-        var mockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        mockTypedList.Setup(t => t.GetItemProperties(null)).Returns(TypeDescriptor.GetProperties(typeof(DataClass)));
-        yield return new object[] { mockTypedList.Object, new string[] { "Property" } };
-
-        var nullMockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        nullMockTypedList.Setup(t => t.GetItemProperties(null)).Returns((PropertyDescriptorCollection)null);
-        yield return new object[] { nullMockTypedList.Object, null };
-
-        yield return new object[] { new EnumerableITypedListImplementor(), new string[] { "Property" } };
-        yield return new object[] { typeof(EnumerableITypedListImplementor), new string[] { "OtherProperty" } };
-
-        yield return new object[] { new NonEnumerableITypedListImplementor(), new string[] { "Property" } };
-        yield return new object[] { typeof(NonEnumerableITypedListImplementor), new string[] { "OtherProperty" } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemProperties_Object_TestData))]
-    public void ListBindingHelper_GetListItemProperties_InvokeObject_ReturnsExpected(object list, string[] expected)
-    {
-        IEnumerable<PropertyDescriptor> properties = ListBindingHelper.GetListItemProperties(list)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Null list accessors.
-        properties = ListBindingHelper.GetListItemProperties(list, null)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Empty list accessors.
-        properties = ListBindingHelper.GetListItemProperties(list, Array.Empty<PropertyDescriptor>())?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Null data member.
-        properties = ListBindingHelper.GetListItemProperties(list, null, Array.Empty<PropertyDescriptor>())?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Empty data member.
-        properties = ListBindingHelper.GetListItemProperties(list, string.Empty, Array.Empty<PropertyDescriptor>())?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-    }
-
-    public static IEnumerable<object[]> GetListItemProperties_Object_PropertyDescriptorArray_TestData()
-    {
-        yield return new object[] { null, TypeDescriptor.GetProperties(typeof(DataClass)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-
-        yield return new object[] { new DataClass(), TypeDescriptor.GetProperties(typeof(DataClass)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { typeof(DataClass), TypeDescriptor.GetProperties(typeof(DataClass)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-
-        yield return new object[] { new ListDataClass(), TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ListDataClass() { ListProperty = new List<DataClass> { new DataClass() } }, TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { typeof(ListDataClass), TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-
-        yield return new object[] { new MultiListDataClass(), TypeDescriptor.GetProperties(typeof(MultiListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "ListProperty" } };
-        yield return new object[] { new MultiListDataClass { ParentListProperty = new List<ListDataClass> { new ListDataClass { ListProperty = new List<DataClass> { new DataClass() } } } }, TypeDescriptor.GetProperties(typeof(MultiListDataClass)).Cast<PropertyDescriptor>().Take(0).ToArray(), new string[] { "ParentListProperty" } };
-
-        var inner = new PropertyDescriptor[] { TypeDescriptor.GetProperties(typeof(MultiListDataClass))[0], TypeDescriptor.GetProperties(typeof(ListDataClass))[0], TypeDescriptor.GetProperties(typeof(DataClass))[0] };
-        yield return new object[] { new MultiListDataClass { ParentListProperty = new List<ListDataClass> { new ListDataClass { ListProperty = new List<DataClass> { new DataClass() } } } }, inner.Take(2).ToArray(), new string[] { "Property" } };
-        yield return new object[] { typeof(MultiListDataClass), TypeDescriptor.GetProperties(typeof(MultiListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "ListProperty" } };
-
-        yield return new object[] { typeof(DataClass), TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new DataClass(), new PropertyDescriptor[] { null }, Array.Empty<string>() };
-        yield return new object[] { typeof(DataClass), new PropertyDescriptor[] { null }, Array.Empty<string>() };
-
-        // Only implements IEnumerable.
-        PropertyDescriptor[] descriptors = TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray();
-        yield return new object[] { new IEnumerableWrapper(Array.Empty<object>()), descriptors, new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new ListDataClass() }), descriptors, new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new MultiListDataClass() }), inner.Take(2).ToArray(), new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { null }), descriptors, new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new ListDataClass[] { null }), descriptors, new string[] { "Property" } };
-
-        // Only implements IList.
-        yield return new object[] { new ArrayList(), descriptors, new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new ListDataClass() }, descriptors, new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass() }, inner.Take(0).ToArray(), new string[] { "ParentListProperty" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass() }, inner.Take(2).ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass { ParentListProperty = new List<ListDataClass>() } }, inner.Take(0).ToArray(), new string[] { "ParentListProperty" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass { ParentListProperty = new List<ListDataClass>() } }, inner.Take(2).ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass { ParentListProperty = new List<ListDataClass> { new ListDataClass { ListProperty = new List<DataClass> { new DataClass() } } } } }, inner.Take(0).ToArray(), new string[] { "ParentListProperty" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass { ParentListProperty = new List<ListDataClass> { new ListDataClass { ListProperty = new List<DataClass> { new DataClass() } } } } }, inner.Take(2).ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new MultiListDataClass { ParentListProperty = new List<ListDataClass> { new ListDataClass { ListProperty = new List<DataClass> { new DataClass() } } } } }, inner.Take(3).ToArray(), Array.Empty<string>() };
-        yield return new object[] { new ArrayList { null }, descriptors, new string[] { "Property" } };
-
-        // ITypedList.
-        var mockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        mockTypedList.Setup(t => t.GetItemProperties(descriptors)).Returns(TypeDescriptor.GetProperties(typeof(DataClass)));
-        yield return new object[] { mockTypedList.Object, descriptors, new string[] { "Property" } };
-
-        var nullMockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        nullMockTypedList.Setup(t => t.GetItemProperties(descriptors)).Returns((PropertyDescriptorCollection)null);
-        yield return new object[] { nullMockTypedList.Object, descriptors, null };
-
-        yield return new object[] { new EnumerableITypedListImplementor(), descriptors, new string[] { "Property" } };
-        yield return new object[] { typeof(EnumerableITypedListImplementor), descriptors, new string[] { "Property" } };
-        yield return new object[] { new EnumerableITypedListImplementor[] { new EnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(EnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new List<EnumerableITypedListImplementor> { new EnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(EnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new ArrayList { new EnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(EnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new EnumerableITypedListImplementor() }), TypeDescriptor.GetProperties(typeof(EnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { typeof(EnumerableITypedListImplementor[]), descriptors, new string[] { "Property" } };
-
-        yield return new object[] { new NonEnumerableITypedListImplementor(), descriptors, new string[] { "Property" } };
-        yield return new object[] { typeof(NonEnumerableITypedListImplementor), descriptors, new string[] { "Property" } };
-        yield return new object[] { new NonEnumerableITypedListImplementor[] { new NonEnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(NonEnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new List<NonEnumerableITypedListImplementor> { new NonEnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(NonEnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new ArrayList { new NonEnumerableITypedListImplementor() }, TypeDescriptor.GetProperties(typeof(NonEnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new NonEnumerableITypedListImplementor() }), TypeDescriptor.GetProperties(typeof(NonEnumerableITypedListImplementor)).Cast<PropertyDescriptor>().ToArray(), Array.Empty<string>() };
-        yield return new object[] { typeof(NonEnumerableITypedListImplementor[]), descriptors, new string[] { "Property" } };
-
-        var typedListDataClass = new ITypedListDataClass { ListProperty = new List<EnumerableITypedListImplementor>() { new EnumerableITypedListImplementor() } };
-        yield return new object[] { new ITypedListDataClass(), TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { typedListDataClass, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { typeof(ITypedListDataClass), TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ITypedListDataClass[] { new ITypedListDataClass() }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ITypedListDataClass[] { typedListDataClass }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new List<ITypedListDataClass> { new ITypedListDataClass() }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new List<ITypedListDataClass> { typedListDataClass }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ArrayList { new ITypedListDataClass() }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ArrayList { typedListDataClass }, TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new ITypedListDataClass() }), TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { typedListDataClass }), TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { typeof(ITypedListDataClass[]), TypeDescriptor.GetProperties(typeof(ITypedListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-
-        var typedListParent = new ITypedListParent { ListProperty = new EnumerableITypedListImplementor() };
-        yield return new object[] { new ITypedListParent(), TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { typedListParent, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ITypedListParent[] { new ITypedListParent() }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ITypedListParent[] { typedListParent }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new List<ITypedListParent> { new ITypedListParent() }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new List<ITypedListParent> { typedListParent }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new ArrayList { new ITypedListParent() }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new ArrayList { typedListParent }, TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { new ITypedListParent() }), TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "OtherProperty" } };
-        yield return new object[] { new IEnumerableWrapper(new object[] { typedListParent }), TypeDescriptor.GetProperties(typeof(ITypedListParent)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemProperties_Object_PropertyDescriptorArray_TestData))]
-    public void ListBindingHelper_GetListItemProperties_InvokeObjectPropertyDescriptorArray_ReturnsExpected(object list, PropertyDescriptor[] listAccessors, string[] expected)
-    {
-        IEnumerable<PropertyDescriptor> properties = ListBindingHelper.GetListItemProperties(list, listAccessors)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Null data member.
-        properties = ListBindingHelper.GetListItemProperties(list, null, listAccessors)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-
-        // Empty data member.
-        properties = ListBindingHelper.GetListItemProperties(list, string.Empty, listAccessors)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-    }
-
-    public static IEnumerable<object[]> GetListItemProperties_Object_String_PropertyDescriptorArray_TestData()
-    {
-        yield return new object[] { new ListDataClass(), "ListProperty", null, new string[] { "Property" } };
-        yield return new object[] { new ListDataClass(), "listproperty", Array.Empty<PropertyDescriptor>(), new string[] { "Property" } };
-        yield return new object[] { new MultiListDataClass(), "ParentListProperty", TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-        yield return new object[] { typeof(ListDataClass), "ListProperty", null, new string[] { "Property" } };
-        yield return new object[] { typeof(ListDataClass), "listproperty", Array.Empty<PropertyDescriptor>(), new string[] { "Property" } };
-        yield return new object[] { typeof(MultiListDataClass), "ParentListProperty", TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray(), new string[] { "Property" } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemProperties_Object_String_PropertyDescriptorArray_TestData))]
-    public void ListBindingHelper_GetListItemProperties_InvokeObjectStringPropertyDescriptorArray_ReturnsExpected(object list, string dataMember, PropertyDescriptor[] listAccessors, string[] expected)
-    {
-        IEnumerable<PropertyDescriptor> properties = ListBindingHelper.GetListItemProperties(list, dataMember, listAccessors)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-    }
-
-    public static IEnumerable<object[]> GetListItemProperties_NoSuchDataMember_TestData()
-    {
-        yield return new object[] { null, "name" };
-        yield return new object[] { typeof(DataClass), "NoSuchProperty" };
-        yield return new object[] { new DataClass(), "NoSuchProperty" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListItemProperties_NoSuchDataMember_TestData))]
-    public void ListBindingHelper_GetListItemProperties_NoSuchDataMember_ThrowsArgumentException(object list, string dataMember)
-    {
-        Assert.Throws<ArgumentException>(() => ListBindingHelper.GetListItemProperties(list, dataMember, null));
-    }
-
-    [Fact]
-    public void ListBindingHelper_GetListItemProperties_InvalidListAccessors_ThrowsTargetException()
-    {
-        Assert.Throws<TargetInvocationException>(() => ListBindingHelper.GetListItemProperties(new DataClass(), TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray()));
-        Assert.Throws<TargetInvocationException>(() => ListBindingHelper.GetListItemProperties(new DataClass(), null, TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray()));
-        Assert.Throws<TargetInvocationException>(() => ListBindingHelper.GetListItemProperties(new DataClass(), string.Empty, TypeDescriptor.GetProperties(typeof(ListDataClass)).Cast<PropertyDescriptor>().ToArray()));
-    }
-
-    public static IEnumerable<object[]> GetListName_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-
-        var mockTypedList = new Mock<ITypedList>(MockBehavior.Strict);
-        mockTypedList.Setup(t => t.GetListName(null)).Returns("Name");
-        yield return new object[] { mockTypedList.Object, null, "Name" };
-
-        yield return new object[] { 1, null, "Int32" };
-        yield return new object[] { typeof(int), null, "Int32" };
-        yield return new object[] { 1, Array.Empty<PropertyDescriptor>(), "Int32" };
-        yield return new object[] { typeof(int), Array.Empty<PropertyDescriptor>(), "Int32" };
-        yield return new object[] { 1, new PropertyDescriptor[] { null }, "Int32" };
-        yield return new object[] { typeof(int), new PropertyDescriptor[] { null }, "Int32" };
-
-        yield return new object[] { Array.Empty<int>(), null, "Int32" };
-        yield return new object[] { typeof(int[]), null, "Int32" };
-        yield return new object[] { Array.Empty<object>(), null, "Object" };
-        yield return new object[] { typeof(object[]), null, "Object" };
-
-        yield return new object[] { new List<int>(), null, "Int32" };
-        yield return new object[] { typeof(List<int>), null, "Int32" };
-        yield return new object[] { new List<object>(), null, "List`1" };
-        yield return new object[] { typeof(List<object>), null, "List`1" };
-
-        yield return new object[] { typeof(Array), null, "Array" };
-        yield return new object[] { typeof(IList), null, "IList" };
-        yield return new object[] { typeof(IList<int>), null, "IList`1" };
-        yield return new object[] { typeof(IEnumerable), null, "IEnumerable" };
-        yield return new object[] { typeof(IEnumerable), new PropertyDescriptor[] { TypeDescriptor.GetProperties(typeof(DataClass))[0] }, "Int32" };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetListName_TestData))]
-    public void ListBindingHelper_GetListName_Invoke_ReturnsExpected(object list, PropertyDescriptor[] listAccessors, string expected)
-    {
-        Assert.Equal(expected, ListBindingHelper.GetListName(list, listAccessors));
-    }
-
-    private class ClassWithItem
-    {
-        public string this[int i]
-        {
-            get => null;
-        }
-    }
-
-    private class CustomCurrencyManagerProvider : ICurrencyManagerProvider
-    {
-        public CurrencyManager CurrencyManagerResult { get; set; }
-
-        public CurrencyManager CurrencyManager => CurrencyManagerResult;
-
-        public CurrencyManager GetRelatedCurrencyManager(string dataMember)
-        {
-            throw new NotImplementedException();
-        }
-
-        public int Property { get; set; }
-    }
-
-    private class GenericIListSourceClassWithItem : List<int>, IListSource
-    {
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => throw new NotImplementedException();
-    }
-
-    private class NonGenericIListSourceClassWithItem : ArrayList, IListSource
-    {
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotSupportedException();
-        }
-
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => throw new NotImplementedException();
-    }
-
-    private class ITypedListClassWithItem : ClassWithItem, ITypedList
-    {
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotSupportedException();
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotSupportedException();
-        }
-    }
-
-    private class ITypedListClassWithCustomNamedItem : ITypedList
-    {
-        [IndexerName("CustomName")]
-        public string this[int i]
-        {
-            get => null;
-        }
-
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotSupportedException();
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotSupportedException();
-        }
-    }
-
-    private class OnlyGenericIListClassWithItem : ClassWithItem, IList<int>
-    {
-        int IList<int>.this[int index] { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-
-        public int Count => throw new NotImplementedException();
-
-        public bool IsReadOnly => throw new NotImplementedException();
-
-        public void Add(int item) => throw new NotImplementedException();
-
-        public void Clear() => throw new NotImplementedException();
-
-        public bool Contains(int item) => throw new NotImplementedException();
-
-        public void CopyTo(int[] array, int arrayIndex) => throw new NotImplementedException();
-
-        public IEnumerator<int> GetEnumerator() => throw new NotImplementedException();
-
-        public int IndexOf(int item) => throw new NotImplementedException();
-
-        public void Insert(int index, int item) => throw new NotImplementedException();
-
-        public bool Remove(int item) => throw new NotImplementedException();
-
-        public void RemoveAt(int index) => throw new NotImplementedException();
-
-        IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException();
-    }
-
-    private class PrivateDefaultConstructor : IListSource
-    {
-        private PrivateDefaultConstructor() { }
-
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => new int[] { 1 };
-    }
-
-    private class NoDefaultConstructor : IListSource
-    {
-        public NoDefaultConstructor(int i) { }
-
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => new int[] { 1 };
-    }
-
-    private class ThrowingDefaultConstructor : IListSource
-    {
-        public ThrowingDefaultConstructor()
-        {
-            throw new DivideByZeroException();
-        }
-
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => new int[] { 1 };
-    }
-
-    private class ClassWithIListSource : IListSource
-    {
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => new int[] { 1 };
-    }
-
-    private class NullIListSource : IListSource
-    {
-        public bool ContainsListCollection => throw new NotImplementedException();
-
-        public IList GetList() => null;
-    }
-
-    // Type that wraps an enumerable but ONLY implements non-generic IEnumerable.
-    private class IEnumerableWrapper : IEnumerable
-    {
-        public IEnumerableWrapper(IList list)
-        {
-            List = list;
-        }
-
-        private IList List { get; }
-
-        public IEnumerator GetEnumerator() => List?.GetEnumerator();
-
-        public int Property { get; set; }
-    }
-
-    private class NotSupportedIEnumerable : IEnumerable
-    {
-        public IEnumerator GetEnumerator() => throw new NotSupportedException();
-    }
-
-    private class DataClass
-    {
-        public int Property { get; set; }
-    }
-
-    private class ListDataClass
-    {
-        public List<DataClass> ListProperty { get; set; }
-    }
-
-    private class MultiListDataClass
-    {
-        public List<ListDataClass> ParentListProperty { get; set; }
-    }
-
-    private class ITypedListDataClass
-    {
-        public List<EnumerableITypedListImplementor> ListProperty { get; set; }
-    }
-
-    private class ITypedListParent
-    {
-        public EnumerableITypedListImplementor ListProperty { get; set; }
-    }
-
-    private class NonEnumerableITypedListImplementor : ITypedList
-    {
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            return TypeDescriptor.GetProperties(typeof(DataClass));
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-
-        public int OtherProperty { get; set; }
-    }
-
-    private class EnumerableITypedListImplementor : ITypedList, IEnumerable
-    {
-        public IEnumerator GetEnumerator()
-        {
-            return null;
-        }
-
-        public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
-        {
-            return TypeDescriptor.GetProperties(typeof(DataClass));
-        }
-
-        public string GetListName(PropertyDescriptor[] listAccessors)
-        {
-            throw new NotImplementedException();
-        }
-
-        public int OtherProperty { get; set; }
-    }
-
-    private class ICustomTypeDescriptorPropertyClass
-    {
-        public ICustomTypeDescriptor Property { get; set; }
-    }
-
-    private class ICustomTypeDescriptorPropertyDescriptorClass
-    {
-        public int Property { get; set; }
-    }
-
-    private class CustomPropertyDescriptor : PropertyDescriptor
-    {
-        public CustomPropertyDescriptor(string name, Attribute[] attrs) : base(name, attrs)
-        {
-        }
-
-        public override Type PropertyType => new CustomTypeDescriptorType();
-
-        public override Type ComponentType => throw new NotImplementedException();
-
-        public override bool IsReadOnly => throw new NotImplementedException();
-
-        public override bool CanResetValue(object component) => throw new NotImplementedException();
-
-        public override object GetValue(object component) => throw new NotImplementedException();
-
-        public override void ResetValue(object component) => throw new NotImplementedException();
-
-        public override void SetValue(object component, object value)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool ShouldSerializeValue(object component)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    public class CustomTypeDescriptorType : Type, ICustomTypeDescriptor
-    {
-        public override Guid GUID => throw new NotImplementedException();
-
-        public override Module Module => throw new NotImplementedException();
-
-        public override Assembly Assembly => throw new NotImplementedException();
-
-        public override string FullName => throw new NotImplementedException();
-
-        public override string Namespace => throw new NotImplementedException();
-
-        public override string AssemblyQualifiedName => throw new NotImplementedException();
-
-        public override Type BaseType => throw new NotImplementedException();
-
-        public override Type UnderlyingSystemType => throw new NotImplementedException();
-
-        public override string Name => throw new NotImplementedException();
-
-        public AttributeCollection GetAttributes()
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetClassName()
-        {
-            throw new NotImplementedException();
-        }
-
-        public string GetComponentName()
-        {
-            throw new NotImplementedException();
-        }
-
-        public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public TypeConverter GetConverter()
-        {
-            throw new NotImplementedException();
-        }
-
-        public override object[] GetCustomAttributes(bool inherit)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
-        {
-            throw new NotImplementedException();
-        }
-
-        public EventDescriptor GetDefaultEvent()
-        {
-            throw new NotImplementedException();
-        }
-
-        public PropertyDescriptor GetDefaultProperty()
-        {
-            throw new NotImplementedException();
-        }
-
-        public object GetEditor(Type editorBaseType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Type GetElementType() => throw new NotImplementedException();
-
-        public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override EventInfo[] GetEvents(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public EventDescriptorCollection GetEvents(Attribute[] attributes)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override FieldInfo GetField(string name, BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override FieldInfo[] GetFields(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Type GetInterface(string name, bool ignoreCase)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Type[] GetInterfaces() => throw new NotImplementedException();
-
-        public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Type GetNestedType(string name, BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override Type[] GetNestedTypes(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
-        {
-            throw new NotImplementedException();
-        }
-
-        public PropertyDescriptorCollection GetProperties(Attribute[] attributes)
-        {
-            throw new NotImplementedException();
-        }
-
-        public object GetPropertyOwner(PropertyDescriptor pd)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override bool IsDefined(Type attributeType, bool inherit) => throw new NotImplementedException();
-
-        protected override TypeAttributes GetAttributeFlagsImpl() => throw new NotImplementedException();
-
-        protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override bool HasElementTypeImpl() => throw new NotImplementedException();
-
-        protected override bool IsArrayImpl() => throw new NotImplementedException();
-
-        protected override bool IsByRefImpl() => throw new NotImplementedException();
-
-        protected override bool IsCOMObjectImpl() => throw new NotImplementedException();
-
-        protected override bool IsPointerImpl() => throw new NotImplementedException();
-
-        protected override bool IsPrimitiveImpl() => throw new NotImplementedException();
-
-        EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
-        {
-            throw new NotImplementedException();
-        }
-
-        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.IntegerCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.IntegerCollectionTests.cs
deleted file mode 100644
index 0c099e04a88..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.IntegerCollectionTests.cs
+++ /dev/null
@@ -1,2743 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxIntegerCollectionTests
-{
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Ctor_ListBox()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Equal(0, collection.Count);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.IntegerCollection(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_ICollection_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ICollection collection = new ListBox.IntegerCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IList_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Item_Get_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        Assert.Equal(1, collection[0]);
-        Assert.Equal(2, collection[1]);
-        Assert.Equal(3, collection[2]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Item_Set_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Item_SetCustomTabOffsets_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Item_SetWithHandle_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Item_SetCustomTabOffsetsWithHandle_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_Item_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_Item_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Add_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Add_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1)]
-    [InlineData(true, false, 0)]
-    [InlineData(false, true, 1)]
-    [InlineData(false, false, 0)]
-    public void ListBoxIntegerCollection_Add_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1)]
-    [InlineData(true, false, 0)]
-    [InlineData(false, true, 1)]
-    [InlineData(false, false, 0)]
-    public void ListBoxIntegerCollection_Add_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntArray_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntArrayCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 2)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 2)]
-    [InlineData(false, false, 1)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntArrayWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 2)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 2)]
-    [InlineData(false, false, 1)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntArrayCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntegerCollection_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.IntegerCollection(otherOwner);
-        otherCollection.AddRange(new int[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntegerCollectionCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.IntegerCollection(otherOwner);
-        otherCollection.AddRange(new int[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 2)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 2)]
-    [InlineData(false, false, 1)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntegerCollectionWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.IntegerCollection(otherOwner);
-        otherCollection.AddRange(new int[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 2)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 2)]
-    [InlineData(false, false, 1)]
-    public void ListBoxIntegerCollection_AddRange_InvokeIntegerCollectionCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.IntegerCollection(otherOwner);
-        otherCollection.AddRange(new int[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<int>());
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_AddRange_NullItems_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((int[])null));
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((ListBox.IntegerCollection)null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Contains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.False(collection.Contains(0));
-        Assert.False(collection.Contains(1));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Contains_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.False(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.True(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeCustomTabOffsetsEmpty_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeCustomTabOffsetNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeCustomTabOffsetsEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_Clear_InvokeCustomTabOffsetNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", "2", "3" }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_CopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        collection.Add(2);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", 1, 2 }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_CopyTo_NullArrayEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_CopyTo_NullArrayNotEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(-1, collection.IndexOf(1));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IndexOf_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.Equal(0, collection.IndexOf(0));
-        Assert.Equal(1, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Remove_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Remove_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Remove_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_Remove_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_RemoveAt_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_RemoveAt_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_RemoveAt_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_RemoveAt_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        ListBox.IntegerCollection collection = owner.CustomTabOffsets;
-        collection.AddRange(new int[] { 2, 1, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_RemoveAt_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListItem_Get_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        Assert.Equal(1, collection[0]);
-        Assert.Equal(2, collection[1]);
-        Assert.Equal(3, collection[2]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListItem_Set_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListItem_SetCustomTabOffsets_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListItem_SetWithHandle_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListItem_SetCustomTabOffsetsWithHandle_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last.
-        collection[2] = 4;
-        Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_IListItem_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_IListItem_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(0, null)]
-    [InlineData(1, null)]
-    [InlineData(-1, "1")]
-    [InlineData(0, "1")]
-    [InlineData(1, "1")]
-    public void ListBoxIntegerCollection_IListItem_SetValueNotInt_ThrowsArgumentException(int index, object item)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection[index] = item);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListAdd_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListAdd_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = owner.CustomTabOffsets;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1)]
-    [InlineData(true, false, 0)]
-    [InlineData(false, true, 1)]
-    [InlineData(false, false, 0)]
-    public void ListBoxIntegerCollection_IListAdd_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 1)]
-    [InlineData(true, false, 0)]
-    [InlineData(false, true, 1)]
-    [InlineData(false, false, 0)]
-    public void ListBoxIntegerCollection_IListAdd_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        Assert.Equal(2, collection.Add(3));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("1")]
-    public void ListBoxIntegerCollection_IListAdd_ValueNotInt_ThrowsArgumentException(object item)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(item));
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListContains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.False(collection.Contains(0));
-        Assert.False(collection.Contains(1));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListContains_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.False(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.True(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeCustomTabOffsetsEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeCustomTabOffsetNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeCustomTabOffsetsEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListClear_InvokeCustomTabOffsetNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.CustomTabOffsets;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.CustomTabOffsets.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListGetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListGetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(2, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListIndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(-1, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxIntegerCollection_IListIndexOf_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.Equal(0, collection.IndexOf(0));
-        Assert.Equal(1, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemove_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemove_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemove_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemove_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove no such.
-        collection.Remove(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("1")]
-    public void ListBoxIntegerCollection_IListRemove_ValueNotInt_ThrowsArgumentException(object item)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Remove(item));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemoveAt_Invoke_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemoveAt_InvokeCustomTabOffsets_Success(bool sorted, bool useCustomTabOffsets)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffsets
-        };
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemoveAt_InvokeWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListBoxIntegerCollection_IListRemoveAt_InvokeCustomTabOffsetsWithHandle_Success(bool sorted, bool useCustomTabOffset)
-    {
-        using var owner = new ListBox
-        {
-            Sorted = sorted,
-            UseCustomTabOffsets = useCustomTabOffset
-        };
-        IList collection = owner.CustomTabOffsets;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.CustomTabOffsets);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxIntegerCollection_IListRemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxIntegerCollection_IListRemoveAt_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.IntegerCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ListBoxItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ListBoxItemAccessibleObjectTests.cs
deleted file mode 100644
index 0bd5248b583..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ListBoxItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,153 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Automation;
-using System.Windows.Forms.IntegrationTests.Common;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBox_ListBoxItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_DataBoundAccessibleName()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/3706
-
-        using var form = new Form
-        {
-            BindingContext = new BindingContext()
-        };
-
-        using var control = new ListBox
-        {
-            Parent = form,
-            DisplayMember = TestDataSources.PersonDisplayMember,
-            DataSource = TestDataSources.GetPersons()
-        };
-
-        ListBox.ListBoxAccessibleObject accessibleObject =
-            Assert.IsType<ListBox.ListBoxAccessibleObject>(control.AccessibilityObject);
-
-        Collections.Generic.List<Person> persons = TestDataSources.GetPersons();
-        Assert.Equal(persons.Count, accessibleObject.GetChildCount());
-
-        for (int i = 0; i < persons.Count; i++)
-        {
-            Person person = persons[i];
-            AccessibleObject itemAccessibleObject = accessibleObject.GetChild(i);
-
-            Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-            Assert.Equal(person.Name, itemAccessibleObject.Name);
-        }
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        AccessibleObject itemAccessibleObject = accessibleObject.GetChild(0);
-
-        Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-
-        object actual = itemAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal(itemAccessibleObject.Name, actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        AccessibleObject itemAccessibleObject = accessibleObject.GetChild(0);
-
-        Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-
-        object actual = itemAccessibleObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(itemAccessibleObject.RuntimeId, actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_BoundingRectangle_ReturnsExpected()
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        AccessibleObject itemAccessibleObject = accessibleObject.GetChild(0);
-
-        Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-
-        object actual = itemAccessibleObject.GetPropertyValue(UiaCore.UIA.BoundingRectanglePropertyId);
-
-        Assert.Equal(UiaTextProvider.BoundingRectangleAsArray(itemAccessibleObject.BoundingRectangle), actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_HelpText_ReturnsExpected()
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        AccessibleObject itemAccessibleObject = accessibleObject.GetChild(0);
-
-        Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-
-        object actual = itemAccessibleObject.GetPropertyValue(UiaCore.UIA.HelpTextPropertyId);
-
-        Assert.Equal(itemAccessibleObject.Help ?? string.Empty, actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_IsOffscreen_ReturnsFalse()
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        AccessibleObject itemAccessibleObject = accessibleObject.GetChild(0);
-
-        Assert.IsType<ListBox.ListBoxItemAccessibleObject>(itemAccessibleObject);
-
-        bool actual = (bool)itemAccessibleObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-
-        Assert.False(actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using ListBox listBox = new();
-        listBox.Items.Add(item: "testItem");
-        ListBox.ListBoxAccessibleObject listBoxAccessibleObject = new(listBox);
-        ListBox.ListBoxItemAccessibleObject accessibleObject = (ListBox.ListBoxItemAccessibleObject)listBoxAccessibleObject.GetChild(0);
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(listBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ObjectCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ObjectCollectionTests.cs
deleted file mode 100644
index 765503a7f70..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.ObjectCollectionTests.cs
+++ /dev/null
@@ -1,12158 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxObjectCollectionTests
-{
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_ListBox()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_ListBox_ObjectArray()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner, new object[] { 3, 2, 1 });
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.False(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_ListBox_ObjectCollection()
-    {
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner, new object[] { 3, 2, 1 });
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner, otherCollection);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.False(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.ObjectCollection(null));
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.ObjectCollection(null, new ListBox.ObjectCollection(owner)));
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.ObjectCollection(null, Array.Empty<object>()));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-
-        var emptyCollection = new ListBox.ObjectCollection(owner);
-        Assert.Empty(emptyCollection);
-        Assert.Equal(0, emptyCollection.Count);
-        Assert.Empty(emptyCollection);
-        Assert.Empty(owner.Items);
-        Assert.False(emptyCollection.IsReadOnly);
-        Assert.Throws<ArgumentException>(() => new ListBox.ObjectCollection(owner, Array.Empty<object>()));
-        Assert.Throws<ArgumentException>(() => new ListBox.ObjectCollection(owner, otherCollection));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Ctor_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        Assert.Throws<ArgumentNullException>("value", () => new ListBox.ObjectCollection(owner, (object[])null));
-        Assert.Throws<ArgumentNullException>("value", () => new ListBox.ObjectCollection(owner, (ListBox.ObjectCollection)null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_ICollection_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ICollection collection = new ListBox.ObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IList_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_Get_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-
-        Assert.Equal(2, collection[0]);
-        Assert.Equal(1, collection[1]);
-        Assert.Equal(1, collection[2]);
-        Assert.Equal(3, collection[3]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_GetSorted_ReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-
-        Assert.Equal(1, collection[0]);
-        Assert.Equal(1, collection[1]);
-        Assert.Equal(2, collection[2]);
-        Assert.Equal(3, collection[3]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_Item_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_Item_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetNotSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 3 });
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 3 });
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetItems_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.AddRange(new object[] { 2, 1, 3 });
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetItemsSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.AddRange(new object[] { 2, 1, 3 });
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-#if false
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Item_SetNotSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char *textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Item_SetSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char *textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-#endif
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Item_SetItemsWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.AddRange(new object[] { 2, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Item_SetItemsSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.AddRange(new object[] { 2, 1, 3 });
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetWithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetWithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Item_SetWithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Item_SetWithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetWithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Item_SetWithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Item_SetWithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Item_SetWithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_Item_SetNullValueEmpty_ThrowsArgumentNullException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection[index] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_Item_SetNullValueNotEmpty_ThrowsArgumentNullException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentNullException>("value", () => collection[index] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_Item_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_Item_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Add_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Add_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_WithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_WithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Add_WithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Add_WithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_CreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Add_ItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_NullItem_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("item", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Add_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void ListBoxObjectCollection_Add_ErrorAdding_ThrowsOutOfMemoryException(int result)
-    {
-        // Note that this is not an actual out of memory, we're artificially setting up an error case
-        // that we surface as `OutOfMemoryException` (see ListBox.NativeAdd(Object item))
-
-        using var owner = new CustomAddStringListBox
-        {
-            AddStringResult = (IntPtr)result
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        Assert.Throws<OutOfMemoryException>(() => collection.Add(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArraySorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArrayNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArrayItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArraySortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArrayItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 0, 5 });
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 0, 5 });
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 0, 2, 4 });
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        collection.AddRange(new object[] { 0, 2, 4 });
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new object[] { 0, 5 });
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new object[] { 0, 5 });
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new object[] { 0, 2, 4 });
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayWithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.AddRange(new object[] { 0, 2, 5 });
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        collection.AddRange(Array.Empty<object>());
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArrayCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectArrayItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.AddRange(new object[] { 2, 1, 1, 3 });
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 5 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 5 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 2, 4 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 2, 4 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 5 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 5 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 2, 4 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_AddRange_ObjectCollectionWithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 0, 2, 5 });
-        collection.AddRange(otherCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        using var emptyOwner = new ListBox();
-        var emptyCollection = new ListBox.ObjectCollection(emptyOwner);
-        collection.AddRange(emptyCollection);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_AddRange_ObjectCollectionItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.AddRange(new object[] { 2, 1, 1, 3 });
-        collection.AddRange(otherCollection);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_SameObjectCollectionEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.AddRange(collection);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_SameObjectCollectionNotEmptyOneValue_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<InvalidOperationException>(() => collection.AddRange(collection));
-        Assert.Equal(new object[] { 1, 1 }, collection.Cast<object>());
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_SameObjectCollectionNotEmptyMultipleValues_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        collection.Add(2);
-        Assert.Throws<InvalidOperationException>(() => collection.AddRange(collection));
-        Assert.Equal(new object[] { 1, 2, 1 }, collection.Cast<object>());
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_NullItems_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((object[])null));
-        Assert.Throws<ArgumentNullException>("value", () => collection.AddRange((ListBox.ObjectCollection)null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_ObjectArrayContainsNullItem_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("item", () => collection.AddRange(new object[] { null }));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_AddRange_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        Assert.Throws<ArgumentException>(() => collection.AddRange(Array.Empty<object>()));
-        Assert.Throws<ArgumentException>(() => collection.AddRange(otherCollection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void ListBoxObjectCollection_AddRange_ErrorAdding_ThrowsOutOfMemoryException(int result)
-    {
-        // Note that this is not an actual out of memory, we're artificially setting up an error case
-        // that we surface as `OutOfMemoryException` (see ListBox.NativeAdd(Object item))
-
-        using var owner = new CustomAddStringListBox
-        {
-            AddStringResult = (IntPtr)result
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        using var otherOwner = new ListBox();
-        var otherCollection = new ListBox.ObjectCollection(otherOwner);
-        otherCollection.Add(1);
-
-        Assert.Throws<OutOfMemoryException>(() => collection.AddRange(new object[] { 1 }));
-        Assert.Throws<OutOfMemoryException>(() => collection.AddRange(otherCollection));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeItemsEmpty_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeItemsNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeItemsEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Clear_InvokeItemsNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Contains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.False(collection.Contains(0));
-        Assert.False(collection.Contains(1));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Contains_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.False(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.True(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Contains_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", "2", "3" }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_CopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        collection.Add(2);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", 1, 2 }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_CopyTo_NullArrayEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_CopyTo_NullArrayNotEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_GetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_GetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(2, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(-1, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IndexOf_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.Equal(1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IndexOf_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(1, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Insert_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(3, 4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Insert_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_WithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_WithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Insert_WithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(3, 4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Insert_WithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_CreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Insert(0, 2);
-        collection.Insert(1, 1);
-        collection.Insert(2, 1);
-        collection.Insert(3, 3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Insert_ItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Insert(0, 2);
-        collection.Insert(1, 1);
-        collection.Insert(2, 1);
-        collection.Insert(3, 3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_Insert_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void ListBoxObjectCollection_Insert_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, 1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_NullItem_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("item", () => collection.Insert(0, null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Insert_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Insert(0, 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void ListBoxObjectCollection_Insert_ErrorAdding_ThrowsOutOfMemoryException(int result)
-    {
-        // Note that this is not an actual out of memory, we're artificially setting up an error case
-        // that we surface as `OutOfMemoryException` (see ListBox.NativeAdd(Object item))
-
-        using var owner = new CustomInsertStringListBox
-        {
-            InsertStringResult = (IntPtr)result
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        Assert.Throws<OutOfMemoryException>(() => collection.Insert(0, 1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Remove_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Remove_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Remove_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_Remove_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Remove_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Remove_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_WithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_WithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Remove_WithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_Remove_WithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_OwnerHasDataSourceEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Remove(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_Remove_OwnerHasDataSourceNotEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = new object[] { 1 }
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Remove(1));
-        Assert.Throws<ArgumentException>(() => collection.Remove(2));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_RemoveAt_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_RemoveAt_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_RemoveAt_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_RemoveAt_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_RemoveAt_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_RemoveAt_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_WithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_WithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_RemoveAt_WithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_RemoveAt_WithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        ListBox.ObjectCollection collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_RemoveAt_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_OwnerHasDataSourceEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.RemoveAt(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_RemoveAt_OwnerHasDataSourceNotEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = new object[] { 1 }
-        };
-        var collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.RemoveAt(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_Get_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        Assert.Equal(2, collection[0]);
-        Assert.Equal(1, collection[1]);
-        Assert.Equal(1, collection[2]);
-        Assert.Equal(3, collection[3]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_GetSorted_ReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-
-        Assert.Equal(1, collection[0]);
-        Assert.Equal(1, collection[1]);
-        Assert.Equal(2, collection[2]);
-        Assert.Equal(3, collection[3]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetNotSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetItems_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetItemsSorted_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-#if false
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListItem_SetNotSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char *textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListItem_SetSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char *textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-#endif
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListItem_SetItemsWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 2;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListItem_SetItemsSortedWithHandle_GetReturnsExpected()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Set first.
-        collection[0] = 4;
-        Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set middle.
-        collection[1] = 1;
-        Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Set last.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-
-        // Set same.
-        collection[2] = 5;
-        Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("4", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("5", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetWithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetWithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListItem_SetWithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListItem_SetWithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetWithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListItem_SetWithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set selected.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListItem_SetWithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListItem_SetWithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Set before.
-        collection[0] = -1;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set after.
-        collection[3] = 5;
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set first selection same.
-        collection[1] = 2;
-        Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set last selection same.
-        collection[2] = 4;
-        Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(4, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListItem_SetNullValueEmpty_ThrowsArgumentNullException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection[index] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListItem_SetNullValueNotEmpty_ThrowsArgumentNullException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentNullException>("value", () => collection[index] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_IListItem_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListItem_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = 2);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(1, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(2, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Add one.
-        Assert.Equal(0, collection.Add(2));
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add same.
-        Assert.Equal(0, collection.Add(1));
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Add another.
-        Assert.Equal(3, collection.Add(3));
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListAdd_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListAdd_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_WithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_WithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListAdd_WithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListAdd_WithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add before.
-        collection.Add(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add middle.
-        collection.Add(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add after.
-        collection.Add(5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_CreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListAdd_ItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_NullItem_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("item", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListAdd_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void ListBoxObjectCollection_IListAdd_ErrorAdding_ThrowsOutOfMemoryException(int result)
-    {
-        // Note that this is not an actual out of memory, we're artificially setting up an error case
-        // that we surface as `OutOfMemoryException` (see ListBox.NativeAdd(Object item))
-
-        using var owner = new CustomAddStringListBox
-        {
-            AddStringResult = (IntPtr)result
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        Assert.Throws<OutOfMemoryException>(() => collection.Add(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeItemsEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeItemsNotEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeItemsEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListClear_InvokeItemsNotEmptyWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(1);
-
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-
-        // Call again.
-        collection.Clear();
-        Assert.Equal(0, collection.Count);
-        Assert.Equal(0, owner.Items.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListContains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.False(collection.Contains(0));
-        Assert.False(collection.Contains(1));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListContains_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.False(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.True(collection.Contains(0));
-        Assert.True(collection.Contains(1));
-        Assert.False(collection.Contains(2));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListContains_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListCopyTo_InvokeEmpty_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", "2", "3" }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListCopyTo_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        collection.Add(2);
-        var array = new object[] { "1", "2", "3" };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { "1", 1, 2 }, array);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListCopyTo_NullArrayEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListCopyTo_NullArrayNotEmpty_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentNullException>("destination", () => collection.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListGetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListGetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Equal(2, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Move again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Reset.
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListIndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(-1, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListIndexOf_InvokeWithValues_ReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-
-        // Add one.
-        collection.Add(1);
-        Assert.Equal(-1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-
-        // Add another.
-        collection.Add(0);
-        Assert.Equal(1, collection.IndexOf(0));
-        Assert.Equal(0, collection.IndexOf(1));
-        Assert.Equal(-1, collection.IndexOf(2));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListIndexOf_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(1, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Insert first.
-        collection.Insert(0, 1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new object[] { 1 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(0, 2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert same.
-        collection.Insert(0, 2);
-        Assert.Equal(3, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Insert end.
-        collection.Insert(3, 3);
-        Assert.Equal(4, collection.Count);
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>());
-        Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>());
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListInsert_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(3, 4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListInsert_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_WithOneSelectedItemNotSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_WithOneSelectedItemSortedWithHandle_Succes()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListInsert_WithMultipleSelectedItemsNotSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(3, 4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListInsert_WithMultipleSelectedItemsSortedWithHandle_Succes(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Insert before.
-        collection.Insert(3, 0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert middle.
-        collection.Insert(2, 2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Insert after.
-        collection.Insert(4, 5);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_CreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Insert(0, 2);
-        collection.Insert(1, 1);
-        collection.Insert(2, 1);
-        collection.Insert(3, 3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListInsert_ItemsCreateHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Insert(0, 2);
-        collection.Insert(1, 1);
-        collection.Insert(2, 1);
-        collection.Insert(3, 3);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.Equal(4, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 2, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 3, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListInsert_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void ListBoxObjectCollection_IListInsert_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, 1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_NullItem_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentNullException>("item", () => collection.Insert(0, null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListInsert_OwnerHasDataSource_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Insert(0, 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(-2)]
-    public void ListBoxObjectCollection_IListInsert_ErrorAdding_ThrowsOutOfMemoryException(int result)
-    {
-        // Note that this is not an actual out of memory, we're artificially setting up an error case
-        // that we surface as `OutOfMemoryException` (see ListBox.NativeAdd(Object item))
-
-        using var owner = new CustomInsertStringListBox
-        {
-            InsertStringResult = (IntPtr)result
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        Assert.Throws<OutOfMemoryException>(() => collection.Insert(0, 1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemove_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemove_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(2);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemove_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemove_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove again.
-        collection.Remove(2);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.Remove(3);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.Remove(1);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemove_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemove_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_WithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_WithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.Remove(1);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemove_WithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemove_WithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.Remove(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.Remove(4);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.Remove(1);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.Remove(3);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_OwnerHasDataSourceEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Remove(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemove_OwnerHasDataSourceNotEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = new object[] { 1 }
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Remove(1));
-        Assert.Throws<ArgumentException>(() => collection.Remove(2));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_NotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_ItemsNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_Sorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_ItemsSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemoveAt_NotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemoveAt_ItemsNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 2 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("2", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemoveAt_SortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListBoxObjectCollection_IListRemoveAt_ItemsSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        collection.Add(2);
-        collection.Add(1);
-        collection.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-        char* textBuffer = stackalloc char[256];
-
-        // Remove middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 1, (nint)textBuffer);
-        Assert.Equal("3", new string(textBuffer));
-
-        // Remove last.
-        collection.RemoveAt(1);
-        Assert.Equal(1, collection.Count);
-        Assert.Equal(new int[] { 1 }, collection.Cast<int>());
-        Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>());
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-        PInvoke.SendMessage(owner, PInvoke.LB_GETTEXT, 0, (nint)textBuffer);
-        Assert.Equal("1", new string(textBuffer));
-
-        // Remove first.
-        collection.RemoveAt(0);
-        Assert.Equal(0, collection.Count);
-        Assert.Empty(collection);
-        Assert.Empty(owner.Items);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.LB_GETCOUNT));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_WithOneSelectedItemNotSorted_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_WithOneSelectedItemSorted_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemoveAt_WithMultipleSelectedItemsNotSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemoveAt_WithMultipleSelectedItemsSorted_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_WithOneSelectedItemNotSortedWithHandle_Success()
-    {
-        using var owner = new ListBox();
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_WithOneSelectedItemSortedWithHandle_Success()
-    {
-        using var owner = new ListBox
-        {
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        };
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove selected.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemoveAt_WithMultipleSelectedItemsNotSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        collection.Add(5);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBoxObjectCollection_IListRemoveAt_WithMultipleSelectedItemsSortedWithHandle_Success(SelectionMode selectionMode)
-    {
-        using var owner = new ListBox
-        {
-            SelectionMode = selectionMode,
-            Sorted = true
-        };
-        IList collection = owner.Items;
-        collection.Add(0);
-        collection.Add(1);
-        collection.Add(3);
-        collection.Add(4);
-        owner.SelectedItems.Add(1);
-        owner.SelectedItems.Add(3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedIndexChangedCallCount = 0;
-        owner.SelectedIndexChanged += (sender, e) => selectedIndexChangedCallCount++;
-
-        // Remove before.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove after.
-        collection.RemoveAt(2);
-        Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove first selection.
-        collection.RemoveAt(0);
-        Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>());
-        Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());
-        Assert.Equal(0, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove last selection.
-        collection.RemoveAt(0);
-        Assert.Empty(owner.SelectedItems);
-        Assert.Empty(owner.SelectedIndices);
-        Assert.Equal(-1, owner.SelectedIndex);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxObjectCollection_IListRemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBoxObjectCollection_IListRemoveAt_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.ObjectCollection(owner);
-        collection.Add(1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_OwnerHasDataSourceEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = Array.Empty<object>()
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.RemoveAt(1));
-    }
-
-    [WinFormsFact]
-    public void ListBoxObjectCollection_IListRemoveAt_OwnerHasDataSourceNotEmpty_ThrowsArgumentException()
-    {
-        using var owner = new ListBox
-        {
-            DataSource = new object[] { 1 }
-        };
-        IList collection = new ListBox.ObjectCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.RemoveAt(1));
-    }
-
-    private class CustomAddStringListBox : ListBox
-    {
-        public IntPtr AddStringResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LB_ADDSTRING)
-            {
-                m.Result = AddStringResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class CustomInsertStringListBox : ListBox
-    {
-        public IntPtr InsertStringResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LB_INSERTSTRING)
-            {
-                m.Result = InsertStringResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedIndexCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedIndexCollectionTests.cs
deleted file mode 100644
index c0d61a9b2d0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedIndexCollectionTests.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxSelectedIndexCollectionTests
-{
-    [WinFormsFact]
-    public void ListBoxSelectedIndexCollection_Ctor_ListBox()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedIndexCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.SelectedIndexCollection(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedIndexCollection_ICollection_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ICollection collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedIndexCollection_IList_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsFixedSize);
-        Assert.True(collection.IsReadOnly);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(0, null)]
-    [InlineData(1, null)]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(-1, "1")]
-    [InlineData(0, "1")]
-    [InlineData(1, "1")]
-    public void ListBoxSelectedIndexCollection_IListItem_Set_ThrowsNotSupportedException(int index, object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection[index] = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    [InlineData("1")]
-    public void ListBoxSelectedIndexCollection_IListAdd_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Add(value));
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedIndexCollection_IListClear_Invoke_ThrowsNotSupportedException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Clear());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(0, null)]
-    [InlineData(1, null)]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(-1, "1")]
-    [InlineData(0, "1")]
-    [InlineData(1, "1")]
-    public void ListBoxSelectedIndexCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    [InlineData("1")]
-    public void ListBoxSelectedIndexCollection_IListRemove_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Remove(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxSelectedIndexCollection_IListRemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedIndexCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.RemoveAt(index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedObjectCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedObjectCollectionTests.cs
deleted file mode 100644
index ad2926c5e95..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBox.SelectedObjectCollectionTests.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxSelectedObjectCollectionTests
-{
-    [WinFormsFact]
-    public void ListBoxSelectedObjectCollection_Ctor_ListBox()
-    {
-        using var owner = new ListBox();
-        var collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsReadOnly);
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedObjectCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        using var owner = new ListBox();
-        Assert.Throws<ArgumentNullException>("owner", () => new ListBox.SelectedObjectCollection(null));
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedObjectCollection_ICollection_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        ICollection collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedObjectCollection_IList_Properties_GetReturnsExpected()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Equal(0, collection.Count);
-        Assert.True(collection.IsFixedSize);
-        Assert.True(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(0, null)]
-    [InlineData(1, null)]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(-1, "1")]
-    [InlineData(0, "1")]
-    [InlineData(1, "1")]
-    public void ListBoxSelectedObjectCollection_IListItem_Set_ThrowsNotSupportedException(int index, object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection[index] = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    [InlineData("1")]
-    public void ListBoxSelectedObjectCollection_IListAdd_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Add(value));
-    }
-
-    [WinFormsFact]
-    public void ListBoxSelectedObjectCollection_IListClear_Invoke_ThrowsNotSupportedException()
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Clear());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, null)]
-    [InlineData(0, null)]
-    [InlineData(1, null)]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(-1, "1")]
-    [InlineData(0, "1")]
-    [InlineData(1, "1")]
-    public void ListBoxSelectedObjectCollection_IListInsert_Invoke_ThrowsNotSupportedException(int index, object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    [InlineData("1")]
-    public void ListBoxSelectedObjectCollection_IListRemove_Invoke_ThrowsNotSupportedException(object value)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.Remove(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBoxSelectedObjectCollection_IListRemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        using var owner = new ListBox();
-        IList collection = new ListBox.SelectedObjectCollection(owner);
-        Assert.Throws<NotSupportedException>(() => collection.RemoveAt(index));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxAccessibleObjectTests.cs
deleted file mode 100644
index fcb8cdff9dc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,188 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ListBox;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListBoxAccessibleObjectTests_Ctor_Default()
-    {
-        using ListBox listBox = CreateListBoxWithItems();
-
-        var childCount = listBox.AccessibilityObject.GetChildCount();
-
-        for (int i = 0; i < childCount; i++)
-        {
-            var child = listBox.AccessibilityObject.GetChild(i);
-            Assert.True(child.IsPatternSupported(UiaCore.UIA.ScrollItemPatternId));
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBoxAccessibleObject_ControlType_IsList_IfAccessibleRoleIsDefault()
-    {
-        using ListBox listBox = new ListBox();
-        // AccessibleRole is not set = Default
-
-        object actual = listBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ListControlTypeId, actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.List)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ListBoxAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using ListBox listBox = new ListBox();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            listBox.CreateControl();
-        }
-
-        AccessibleRole actual = listBox.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, listBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ListBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ListBox listBox = new ListBox();
-        listBox.AccessibleRole = role;
-
-        object actual = listBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_ValueValuePropertyId_ReturnsExpected()
-    {
-        using ListBox listBox = new ListBox();
-        AccessibleObject accessibleObject = listBox.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.False(listBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ReleaseUiaProvider_ClearsItemsAccessibleObjects()
-    {
-        using ListBox listBox = CreateListBoxWithItems();
-        ListBoxAccessibleObject accessibleObject = InitListBoxItemsAccessibleObjects(listBox);
-
-        listBox.ReleaseUiaProvider(listBox.HWND);
-
-        Assert.Equal(0, accessibleObject.TestAccessor().Dynamic._itemAccessibleObjects.Count);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItems_Clear_ClearsItemsAccessibleObjects()
-    {
-        using ListBox listBox = CreateListBoxWithItems();
-        ListBoxAccessibleObject accessibleObject = InitListBoxItemsAccessibleObjects(listBox);
-
-        listBox.Items.Clear();
-
-        Assert.Equal(0, accessibleObject.TestAccessor().Dynamic._itemAccessibleObjects.Count);
-    }
-
-    [WinFormsFact]
-    public void ListBoxItems_Remove_RemovesItemAccessibleObject()
-    {
-        using ListBox listBox = CreateListBoxWithItems();
-        ListBoxAccessibleObject accessibleObject = InitListBoxItemsAccessibleObjects(listBox);
-        ItemArray.Entry item = listBox.Items.InnerArray.Entries[0];
-        Assert.True(accessibleObject.TestAccessor().Dynamic._itemAccessibleObjects.ContainsKey(item));
-
-        listBox.Items.Remove(item);
-
-        Assert.False(accessibleObject.TestAccessor().Dynamic._itemAccessibleObjects.ContainsKey(item));
-    }
-
-    [WinFormsFact]
-    public void ListBoxItemAccessibleObject_GetPropertyValue_HasKeyboardFocusPropertyId_ReturnsExpected()
-    {
-        using Form form = new();
-        using ListBox listBox = new();
-
-        form.Controls.Add(listBox);
-
-        ListBox.ListBoxAccessibleObject accessibleObject = new(listBox);
-        form.Show();
-
-        Assert.True(listBox.Focused);
-
-        bool actual = (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-        Assert.True(actual);
-
-        listBox.Items.Add(item: "testItem");
-        actual = (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(actual);
-
-        listBox.Items.Clear();
-        actual = (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.True(actual);
-    }
-
-    private ListBox CreateListBoxWithItems()
-    {
-        ListBox listBox = new();
-        listBox.Items.AddRange(new object[]
-        {
-            "a",
-            "b",
-            "c",
-            "d",
-            "e",
-            "f",
-            "g"
-        });
-
-        return listBox;
-    }
-
-    private ListBoxAccessibleObject InitListBoxItemsAccessibleObjects(ListBox listBox)
-    {
-        ListBoxAccessibleObject accessibilityObject = (ListBoxAccessibleObject)listBox.AccessibilityObject;
-        int childCount = accessibilityObject.GetChildCount();
-        // Force items accessiblity objects creation
-        for (int i = 0; i < childCount; i++)
-        {
-            accessibilityObject.GetChild(i);
-        }
-
-        Assert.Equal(childCount, accessibilityObject.TestAccessor().Dynamic._itemAccessibleObjects.Count);
-
-        return accessibilityObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxTests.cs
deleted file mode 100644
index 3eed23286c5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListBoxTests.cs
+++ /dev/null
@@ -1,6389 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListBoxTests
-{
-    [WinFormsFact]
-    public void ListBox_Ctor_Default()
-    {
-        using var control = new SubListBox();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.AllowSelection);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(96, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 120, 96), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(116, 92), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 116, 92), control.ClientRectangle);
-        Assert.Equal(0, control.ColumnWidth);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Empty(control.CustomTabOffsets);
-        Assert.Same(control.CustomTabOffsets, control.CustomTabOffsets);
-        Assert.Null(control.DataManager);
-        Assert.Null(control.DataSource);
-        Assert.Same(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, 96), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(new Rectangle(0, 0, 116, 92), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Equal(DrawMode.Normal, control.DrawMode);
-        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.Null(control.FormatInfo);
-        Assert.Empty(control.FormatString);
-        Assert.False(control.FormattingEnabled);
-        Assert.False(control.HasChildren);
-        Assert.Equal(96, control.Height);
-        Assert.Equal(0, control.HorizontalExtent);
-        Assert.False(control.HorizontalScrollbar);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IntegralHeight);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(Control.DefaultFont.Height, control.ItemHeight);
-        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.False(control.MultiColumn);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3, control.PreferredHeight);
-        Assert.Equal(new Size(120, 96), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(120, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.ScrollAlwaysVisible);
-        Assert.Null(control.SelectedValue);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Same(control.SelectedIndices, control.SelectedIndices);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedItems);
-        Assert.Same(control.SelectedItems, control.SelectedItems);
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(120, 96), control.Size);
-        Assert.False(control.Sorted);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(0, control.TopIndex);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseCustomTabOffsets);
-        Assert.True(control.UseTabStops);
-        Assert.False(control.UseWaitCursor);
-        Assert.Empty(control.ValueMember);
-        Assert.True(control.Visible);
-        Assert.Equal(120, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubListBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x562100C1, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x562110C1)]
-    [InlineData(false, 0x562100C1)]
-    public void ListBox_CreateParams_GetScrollAlwaysVisible_ReturnsExpected(bool scrollAlwaysVisible, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            ScrollAlwaysVisible = scrollAlwaysVisible
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x562100C1)]
-    [InlineData(false, 0x562101C1)]
-    public void ListBox_CreateParams_GetIntegralHeight_ReturnsExpected(bool integralHeight, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            IntegralHeight = integralHeight
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x562100C1)]
-    [InlineData(false, 0x56210041)]
-    public void ListBox_CreateParams_GetUseTabStops_ReturnsExpected(bool useTabStops, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            UseTabStops = useTabStops
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x562100C1, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x562100C1, 0x200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56A100C1, 0)]
-    public void ListBox_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubListBox
-        {
-            BorderStyle = borderStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x563102C1)]
-    [InlineData(true, false, 0x563102C1)]
-    [InlineData(false, true, 0x563100C1)]
-    [InlineData(false, false, 0x562100C1)]
-    public void ListBox_CreateParams_GetMultiColumn_ReturnsExpected(bool multiColumn, bool horizontalScrollBar, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            MultiColumn = multiColumn,
-            HorizontalScrollbar = horizontalScrollBar
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended, 0x562108C1)]
-    [InlineData(SelectionMode.MultiSimple, 0x562100C9)]
-    [InlineData(SelectionMode.None, 0x562140C1)]
-    [InlineData(SelectionMode.One, 0x562100C1)]
-    public void ListBox_CreateParams_GetSelectionMode_ReturnsExpected(SelectionMode selectionMode, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            SelectionMode = selectionMode
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DrawMode.Normal, 0x562100C1)]
-    [InlineData(DrawMode.OwnerDrawFixed, 0x562100D1)]
-    [InlineData(DrawMode.OwnerDrawVariable, 0x562100E1)]
-    public void ListBox_CreateParams_GetDrawMode_ReturnsExpected(DrawMode drawMode, int expectedStyle)
-    {
-        using var control = new SubListBox
-        {
-            DrawMode = drawMode
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ListBox", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListBox_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ListBox
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void ListBox_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.BackColor)];
-        using var control = new ListBox();
-        Assert.False(property.CanResetValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ListBox_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.BackColor)];
-        using var control = new ListBox();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void ListBox_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new ListBox
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ListBox_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new ListBox
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ListBox_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void ListBox_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new ListBox()
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 0)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 1)]
-    public void ListBox_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void ListBox_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(60)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_ColumnWidth_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox
-        {
-            ColumnWidth = value
-        };
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.False(control.IsHandleCreated);
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(60)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_ColumnWidth_SetWithCustomOldValue_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox
-        {
-            ColumnWidth = 10
-        };
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.False(control.IsHandleCreated);
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(60)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_ColumnWidth_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 0)]
-    [InlineData(60, 0)]
-    [InlineData(int.MaxValue, 0)]
-    public void ListBox_ColumnWidth_SetWithCustomOldValueWithHandle_GetReturnsExpected(int value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            ColumnWidth = 10
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        control.ColumnWidth = value;
-        Assert.Equal(value, control.ColumnWidth);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ColumnWidth_GetItemRect_ReturnsExpected()
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = true
-        };
-        control.Items.Add("Value");
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ColumnWidth = 123;
-
-        RECT rc = default;
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETITEMRECT, 0, ref rc));
-        Assert.Equal(123, ((Rectangle)rc).Width);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ColumnWidth_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ColumnWidth = -1);
-    }
-
-    public static IEnumerable<object[]> DataSource_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new List<int>() };
-        yield return new object[] { Array.Empty<int>() };
-
-        var mockSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockSource
-            .Setup(s => s.GetList())
-            .Returns(new int[] { 1 });
-        yield return new object[] { mockSource.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListBox_DataSource_Set_GetReturnsExpected(object value)
-    {
-        using var control = new SubListBox
-        {
-            DataSource = value
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_DataSource_SetWithHandler_CallsDataSourceChanged()
-    {
-        using var control = new ListBox();
-        int dataSourceCallCount = 0;
-        int displayMemberCallCount = 0;
-        EventHandler dataSourceHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            dataSourceCallCount++;
-        };
-        EventHandler displayMemberHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            displayMemberCallCount++;
-        };
-        control.DataSourceChanged += dataSourceHandler;
-        control.DisplayMemberChanged += displayMemberHandler;
-
-        // Set different.
-        var dataSource1 = new List<int>();
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(1, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set same.
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(1, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set different.
-        var dataSource2 = new List<int>();
-        control.DataSource = dataSource2;
-        Assert.Same(dataSource2, control.DataSource);
-        Assert.Equal(2, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set null.
-        control.DataSource = null;
-        Assert.Null(control.DataSource);
-        Assert.Equal(3, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Remove handler.
-        control.DataSourceChanged -= dataSourceHandler;
-        control.DisplayMemberChanged -= displayMemberHandler;
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(3, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-    }
-
-    public static IEnumerable<object[]> DrawMode_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, true, DrawMode.Normal };
-            yield return new object[] { autoSize, false, DrawMode.Normal };
-
-            yield return new object[] { autoSize, true, DrawMode.OwnerDrawFixed };
-            yield return new object[] { autoSize, false, DrawMode.OwnerDrawFixed };
-
-            yield return new object[] { autoSize, false, DrawMode.OwnerDrawVariable };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMode_Set_TestData))]
-    public void ListBox_DrawMode_Set_GetReturnsExpected(bool autoSize, bool multiColumn, DrawMode value)
-    {
-        using var control = new ListBox
-        {
-            AutoSize = autoSize,
-            MultiColumn = multiColumn
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DrawMode_SetWithParent_TestData()
-    {
-        yield return new object[] { true, true, DrawMode.Normal, 0 };
-        yield return new object[] { true, false, DrawMode.Normal, 0 };
-        yield return new object[] { false, true, DrawMode.Normal, 0 };
-        yield return new object[] { false, false, DrawMode.Normal, 0 };
-
-        yield return new object[] { true, true, DrawMode.OwnerDrawFixed, 0 };
-        yield return new object[] { true, false, DrawMode.OwnerDrawFixed, 0 };
-        yield return new object[] { false, true, DrawMode.OwnerDrawFixed, 0 };
-        yield return new object[] { false, false, DrawMode.OwnerDrawFixed, 0 };
-
-        yield return new object[] { true, false, DrawMode.OwnerDrawVariable, 1 };
-        yield return new object[] { false, false, DrawMode.OwnerDrawVariable, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMode_SetWithParent_TestData))]
-    public void ListBox_DrawMode_SetWithParent_GetReturnsExpected(bool autoSize, bool multiColumn, DrawMode value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new ListBox
-        {
-            AutoSize = autoSize,
-            MultiColumn = multiColumn,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("DrawMode", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.DrawMode = value;
-            Assert.Equal(value, control.DrawMode);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.DrawMode = value;
-            Assert.Equal(value, control.DrawMode);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> DrawMode_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, true, DrawMode.Normal, 0 };
-            yield return new object[] { autoSize, false, DrawMode.Normal, 0 };
-
-            yield return new object[] { autoSize, true, DrawMode.OwnerDrawFixed, 1 };
-            yield return new object[] { autoSize, false, DrawMode.OwnerDrawFixed, 1 };
-
-            yield return new object[] { autoSize, false, DrawMode.OwnerDrawVariable, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawMode_SetWithHandle_TestData))]
-    public void ListBox_DrawMode_SetWithHandle_GetReturnsExpected(bool autoSize, bool multiColumn, DrawMode value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            AutoSize = autoSize,
-            MultiColumn = multiColumn
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.Equal(expectedCreatedCallCount * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.Equal(expectedCreatedCallCount * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DrawMode>]
-    public void ListBox_DrawMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(DrawMode value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DrawMode = value);
-    }
-
-    [WinFormsFact]
-    public void ListBox_DrawMode_SetMultiColumnOwnerDrawVariable_ThrowsArgumentException()
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = true
-        };
-        Assert.Throws<ArgumentException>("value", () => control.DrawMode = DrawMode.OwnerDrawVariable);
-    }
-
-    public static IEnumerable<object[]> Font_Set_TestData()
-    {
-        foreach (bool integralHeight in new bool[] { true, false })
-        {
-            yield return new object[] { integralHeight, null };
-            yield return new object[] { integralHeight, new Font("Arial", 8.25f) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ListBox_Font_Set_GetReturnsExpected(bool integralHeight, Font value)
-    {
-        using var control = new SubListBox
-        {
-            IntegralHeight = integralHeight,
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(96, control.Height);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(96, control.Height);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ListBox_Font_SetWithItems_GetReturnsExpected(bool integralHeight, Font value)
-    {
-        using var control = new SubListBox
-        {
-            IntegralHeight = integralHeight
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(96, control.Height);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(96, control.Height);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, null, 0, 0 };
-        yield return new object[] { false, null, 0, 1 };
-        yield return new object[] { true, new Font("Arial", 8.25f), 1, 1 };
-        yield return new object[] { false, new Font("Arial", 8.25f), 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void ListBox_Font_SetWithHandle_GetReturnsExpected(bool integralHeight, Font value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubListBox
-        {
-            IntegralHeight = integralHeight
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.Height > 0);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.Height > 0);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Font_SetHandleWithItems_TestData()
-    {
-        yield return new object[] { true, null, 0, 0 };
-        yield return new object[] { false, null, 1, 2 };
-        yield return new object[] { true, new Font("Arial", 8.25f), 1, 1 };
-        yield return new object[] { false, new Font("Arial", 8.25f), 2, 3 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetHandleWithItems_TestData))]
-    public void ListBox_Font_SetWithItemsWithHandle_GetReturnsExpected(bool integralHeight, Font value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var control = new SubListBox
-        {
-            IntegralHeight = integralHeight
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.Height > 0);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.Height > 0);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListBox_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ListBox
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void ListBox_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.ForeColor)];
-        using var control = new ListBox();
-        Assert.False(property.CanResetValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ListBox_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.ForeColor)];
-        using var control = new ListBox();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> HorizontalExtent_Set_TestData()
-    {
-        foreach (bool multiColumn in new bool[] { true, false })
-        {
-            foreach (bool horizontalScrollbar in new bool[] { true, false })
-            {
-                yield return new object[] { multiColumn, horizontalScrollbar, -1 };
-                yield return new object[] { multiColumn, horizontalScrollbar, 0 };
-                yield return new object[] { multiColumn, horizontalScrollbar, 120 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalExtent_Set_TestData))]
-    public void ListBox_HorizontalExtent_Set_GetReturnsExpected(bool multiColumn, bool horizontalScrollBar, int value)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn,
-            HorizontalScrollbar = horizontalScrollBar,
-            HorizontalExtent = value
-        };
-        Assert.Equal(value, control.HorizontalExtent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HorizontalExtent = value;
-        Assert.Equal(value, control.HorizontalExtent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HorizontalExtent_SetWithHandle_TestData()
-    {
-        foreach (bool multiColumn in new bool[] { true, false })
-        {
-            foreach (bool horizontalScrollbar in new bool[] { true, false })
-            {
-                yield return new object[] { multiColumn, horizontalScrollbar, -1, 0 };
-                yield return new object[] { multiColumn, horizontalScrollbar, 0, 0 };
-                yield return new object[] { multiColumn, horizontalScrollbar, 120, !multiColumn && horizontalScrollbar ? 1 : 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalExtent_SetWithHandle_TestData))]
-    public void ListBox_HorizontalExtent_SetWithHandle_GetReturnsExpected(bool multiColumn, bool horizontalScrollBar, int value, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn,
-            HorizontalScrollbar = horizontalScrollBar
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HorizontalExtent = value;
-        Assert.Equal(value, control.HorizontalExtent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HorizontalExtent = value;
-        Assert.Equal(value, control.HorizontalExtent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0)]
-    [InlineData(true, false, 0)]
-    [InlineData(false, true, 10)]
-    [InlineData(false, false, 0)]
-    public void ListBox_HorizontalExtent_GetHorizontalExtent_Success(bool multiColumn, bool horizontalScrollBar, int expected)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn,
-            HorizontalScrollbar = horizontalScrollBar
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, control.HorizontalExtent);
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETHORIZONTALEXTENT));
-
-        control.HorizontalExtent = 10;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.LB_GETHORIZONTALEXTENT));
-    }
-
-    public static IEnumerable<object[]> HorizontalScrollbar_Set_TestData()
-    {
-        foreach (bool multiColumn in new bool[] { true, false })
-        {
-            yield return new object[] { multiColumn, true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalScrollbar_Set_TestData))]
-    public void ListBox_HorizontalScrollbar_Set_GetReturnsExpected(bool multiColumn, bool value)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn,
-            HorizontalScrollbar = value
-        };
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HorizontalScrollbar = !value;
-        Assert.Equal(!value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalScrollbar_Set_TestData))]
-    public void ListBox_HorizontalScrollbar_SetWithItems_GetReturnsExpected(bool multiColumn, bool value)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HorizontalScrollbar = !value;
-        Assert.Equal(!value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HorizontalScrollbar_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, true, 0, 0, 1, 0 };
-        yield return new object[] { true, false, 0, 0, 1, 0 };
-        yield return new object[] { false, true, 2, 1, 3, 2 };
-        yield return new object[] { false, false, 0, 0, 3, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalScrollbar_SetWithHandle_TestData))]
-    public void ListBox_HorizontalScrollbar_SetWithHandle_GetReturnsExpected(bool multiColumn, bool value, int expectedInvalidatedCallCount1, int expectedCreatedCallCount1, int expectedInvalidatedCallCount2, int expectedCreatedCallCount2)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.HorizontalScrollbar = !value;
-        Assert.Equal(!value, control.HorizontalScrollbar);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> HorizontalScrollbar_SetWithItemsWithHandle_TestData()
-    {
-        yield return new object[] { true, true, 1, 0, 2, 0 };
-        yield return new object[] { true, false, 0, 0, 1, 0 };
-        yield return new object[] { false, true, 3, 1, 4, 2 };
-        yield return new object[] { false, false, 0, 0, 3, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HorizontalScrollbar_SetWithItemsWithHandle_TestData))]
-    public void ListBox_HorizontalScrollbar_SetWithItemsWithHandle_GetReturnsExpected(bool multiColumn, bool value, int expectedInvalidatedCallCount1, int expectedCreatedCallCount1, int expectedInvalidatedCallCount2, int expectedCreatedCallCount2)
-    {
-        using var control = new ListBox
-        {
-            MultiColumn = multiColumn
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.HorizontalScrollbar = value;
-        Assert.Equal(value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.HorizontalScrollbar = !value;
-        Assert.Equal(!value, control.HorizontalScrollbar);
-        Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_IntegralHeight_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox
-        {
-            IntegralHeight = value
-        };
-        Assert.Equal(value, control.IntegralHeight);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.IntegralHeight = value;
-        Assert.Equal(value, control.IntegralHeight);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.IntegralHeight = !value;
-        Assert.Equal(!value, control.IntegralHeight);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ListBox_IntegralHeight_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.IntegralHeight = value;
-        Assert.Equal(value, control.IntegralHeight);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.IntegralHeight = value;
-        Assert.Equal(value, control.IntegralHeight);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.IntegralHeight = !value;
-        Assert.Equal(!value, control.IntegralHeight);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ItemHeight_Set_TestData()
-    {
-        foreach (Enum drawMode in Enum.GetValues(typeof(DrawMode)))
-        {
-            foreach (bool integralHeight in new bool[] { true, false })
-            {
-                yield return new object[] { drawMode, integralHeight, 1 };
-                yield return new object[] { drawMode, integralHeight, 13 };
-                yield return new object[] { drawMode, integralHeight, 255 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemHeight_Set_TestData))]
-    public void ListBox_ItemHeight_Set_GetReturnsExpected(DrawMode drawMode, bool integralHeight, int value)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            IntegralHeight = integralHeight,
-            ItemHeight = value
-        };
-        Assert.Equal(value, control.ItemHeight);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ItemHeight = value;
-        Assert.Equal(value, control.ItemHeight);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ItemHeight_SetWithHandle_TestData()
-    {
-        foreach (bool integralHeight in new bool[] { true, false })
-        {
-            yield return new object[] { DrawMode.Normal, integralHeight, 1, 0 };
-            yield return new object[] { DrawMode.Normal, integralHeight, Control.DefaultFont.Height, 0 };
-            yield return new object[] { DrawMode.Normal, integralHeight, 255, 0 };
-            yield return new object[] { DrawMode.OwnerDrawFixed, integralHeight, 1, 1 };
-            yield return new object[] { DrawMode.OwnerDrawFixed, integralHeight, Control.DefaultFont.Height, 0 };
-            yield return new object[] { DrawMode.OwnerDrawFixed, integralHeight, 255, 1 };
-            yield return new object[] { DrawMode.OwnerDrawVariable, integralHeight, 1, 0 };
-            yield return new object[] { DrawMode.OwnerDrawVariable, integralHeight, Control.DefaultFont.Height, 0 };
-            yield return new object[] { DrawMode.OwnerDrawVariable, integralHeight, 255, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemHeight_SetWithHandle_TestData))]
-    public void ListBox_ItemHeight_SetWithHandle_GetReturnsExpected(DrawMode drawMode, bool integralHeight, int value, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            IntegralHeight = integralHeight
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ItemHeight = value;
-        Assert.True(control.ItemHeight > 0);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ItemHeight = value;
-        Assert.True(control.ItemHeight > 0);
-        Assert.True(control.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DrawMode.Normal, false)]
-    [InlineData(DrawMode.OwnerDrawFixed, true)]
-    [InlineData(DrawMode.OwnerDrawVariable, false)]
-    public void ListBox_ItemHeight_Set_GetItemHeight_ReturnsExpected(DrawMode drawMode, bool expected)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            ItemHeight = 25
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.LB_GETITEMHEIGHT) == 25);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(256)]
-    public void ListBox_ItemHeight_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ItemHeight = value);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ItemHeight_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.ItemHeight)];
-        using var control = new ListBox();
-        Assert.False(property.CanResetValue(control));
-
-        control.ItemHeight = 15;
-        Assert.Equal(15, control.ItemHeight);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultFont.Height, control.ItemHeight);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ListBox_ItemHeight_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ListBox))[nameof(ListBox.ItemHeight)];
-        using var control = new ListBox();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ItemHeight = 15;
-        Assert.Equal(15, control.ItemHeight);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultFont.Height, control.ItemHeight);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> Items_CustomCreateItemCollection_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListBox.ObjectCollection(new ListBox()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Items_CustomCreateItemCollection_TestData))]
-    public void ListBox_Items_GetCustomCreateItemCollection_ReturnsExpected(ListBox.ObjectCollection result)
-    {
-        using var control = new CustomCreateItemCollectionListBox
-        {
-            CreateListBoxResult = result
-        };
-        Assert.Same(result, control.Items);
-        Assert.Same(control.Items, control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomCreateItemCollectionListBox : ListBox
-    {
-        public ListBox.ObjectCollection CreateListBoxResult { get; set; }
-
-        protected override ListBox.ObjectCollection CreateItemCollection() => CreateListBoxResult;
-    }
-
-    public static IEnumerable<object[]> MultiColumn_Set_TestData()
-    {
-        yield return new object[] { DrawMode.Normal, true };
-        yield return new object[] { DrawMode.Normal, false };
-        yield return new object[] { DrawMode.OwnerDrawFixed, true };
-        yield return new object[] { DrawMode.OwnerDrawFixed, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MultiColumn_Set_TestData))]
-    public void ListBox_MultiColumn_Set_GetReturnsExpected(DrawMode drawMode, bool value)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            MultiColumn = value
-        };
-        Assert.Equal(value, control.MultiColumn);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MultiColumn = value;
-        Assert.Equal(value, control.MultiColumn);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.MultiColumn = !value;
-        Assert.Equal(!value, control.MultiColumn);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MultiColumn_SetWithHandle_TestData()
-    {
-        yield return new object[] { DrawMode.Normal, true, 1 };
-        yield return new object[] { DrawMode.Normal, false, 0 };
-        yield return new object[] { DrawMode.OwnerDrawFixed, true, 1 };
-        yield return new object[] { DrawMode.OwnerDrawFixed, false, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MultiColumn_SetWithHandle_TestData))]
-    public void ListBox_MultiColumn_SetWithHandle_GetReturnsExpected(DrawMode drawMode, bool value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MultiColumn = value;
-        Assert.Equal(value, control.MultiColumn);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.MultiColumn = value;
-        Assert.Equal(value, control.MultiColumn);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.MultiColumn = !value;
-        Assert.Equal(!value, control.MultiColumn);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_MultiColumn_SetOwnerDrawVariable_ThrowsArgumentException()
-    {
-        using var control = new ListBox
-        {
-            DrawMode = DrawMode.OwnerDrawVariable
-        };
-        control.MultiColumn = false;
-        Assert.False(control.MultiColumn);
-
-        Assert.Throws<ArgumentException>("value", () => control.MultiColumn = true);
-        Assert.False(control.MultiColumn);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ListBox_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ListBox
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ListBox_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void ListBox_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> PreferredHeight_GetEmpty_TestData()
-    {
-        int extra = SystemInformation.BorderSize.Height * 4 + 3;
-        yield return new object[] { DrawMode.Normal, BorderStyle.Fixed3D, Control.DefaultFont.Height + extra };
-        yield return new object[] { DrawMode.Normal, BorderStyle.FixedSingle, Control.DefaultFont.Height + extra };
-        yield return new object[] { DrawMode.Normal, BorderStyle.None, Control.DefaultFont.Height };
-
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.Fixed3D, Control.DefaultFont.Height + extra };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.FixedSingle, Control.DefaultFont.Height + extra };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.None, Control.DefaultFont.Height };
-
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.Fixed3D, extra };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.FixedSingle, extra };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.None, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreferredHeight_GetEmpty_TestData))]
-    public void ListBox_PreferredHeight_GetEmpty_ReturnsExpected(DrawMode drawMode, BorderStyle borderStyle, int expected)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            BorderStyle = borderStyle
-        };
-        Assert.Equal(expected, control.PreferredHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PreferredHeight_GetNotEmpty_TestData()
-    {
-        int extra = SystemInformation.BorderSize.Height * 4 + 3;
-        yield return new object[] { DrawMode.Normal, BorderStyle.Fixed3D, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.Normal, BorderStyle.FixedSingle, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.Normal, BorderStyle.None, (Control.DefaultFont.Height * 2) };
-
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.Fixed3D, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.FixedSingle, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.None, (Control.DefaultFont.Height * 2) };
-
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.Fixed3D, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.FixedSingle, (Control.DefaultFont.Height * 2) + extra };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.None, (Control.DefaultFont.Height * 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreferredHeight_GetNotEmpty_TestData))]
-    public void ListBox_PreferredHeight_GetNotEmpty_ReturnsExpected(DrawMode drawMode, BorderStyle borderStyle, int expected)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            BorderStyle = borderStyle
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        Assert.Equal(expected, control.PreferredHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PreferredHeight_GetWithHandle_TestData()
-    {
-        yield return new object[] { DrawMode.Normal, BorderStyle.Fixed3D };
-        yield return new object[] { DrawMode.Normal, BorderStyle.FixedSingle };
-        yield return new object[] { DrawMode.Normal, BorderStyle.None };
-
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.Fixed3D };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.FixedSingle };
-        yield return new object[] { DrawMode.OwnerDrawFixed, BorderStyle.None };
-
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.Fixed3D };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.FixedSingle };
-        yield return new object[] { DrawMode.OwnerDrawVariable, BorderStyle.None };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreferredHeight_GetWithHandle_TestData))]
-    public void ListBox_PreferredHeight_GetEmptyWithHandle_ReturnsExpected(DrawMode drawMode, BorderStyle borderStyle)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            BorderStyle = borderStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.PreferredHeight >= 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreferredHeight_GetWithHandle_TestData))]
-    public void ListBox_PreferredHeight_GetNotEmptyWithHandle_ReturnsExpected(DrawMode drawMode, BorderStyle borderStyle)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode,
-            BorderStyle = borderStyle
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.PreferredHeight > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ListBox_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new ListBox
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ListBox_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_ScrollAlwaysVisible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox
-        {
-            ScrollAlwaysVisible = value
-        };
-        Assert.Equal(value, control.ScrollAlwaysVisible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ScrollAlwaysVisible = value;
-        Assert.Equal(value, control.ScrollAlwaysVisible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ScrollAlwaysVisible = !value;
-        Assert.Equal(!value, control.ScrollAlwaysVisible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListBox_ScrollAlwaysVisible_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ScrollAlwaysVisible = value;
-        Assert.Equal(value, control.ScrollAlwaysVisible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.ScrollAlwaysVisible = value;
-        Assert.Equal(value, control.ScrollAlwaysVisible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.ScrollAlwaysVisible = !value;
-        Assert.Equal(!value, control.ScrollAlwaysVisible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SelectionMode>]
-    public void ListBox_SelectedIndex_GetEmptyWithHandle_ReturnsMinusOne(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(-1, control.SelectedIndex);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SelectionMode>]
-    public void ListBox_SelectedIndex_GetNotEmptyWithHandle_ReturnsMinusOne(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("Item");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(-1, control.SelectedIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    [InlineData(SelectionMode.One)]
-    public void ListBox_SelectedIndex_SetEmpty_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode,
-            SelectedIndex = -1
-        };
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedIndex_SetSelectionModeOne_GetReturnsExpected()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select end.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedIndex_SetSelectionModeMultiple_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select end.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void ListBox_SelectedIndex_SetWithDataManager_SetsDataManagerPosition(bool formattingEnabled, int position)
-    {
-        var bindingContext = new BindingContext();
-        var dataSource = new List<string> { "item1", "item2", "item3" };
-        using var control = new SubListBox
-        {
-            BindingContext = bindingContext,
-            DataSource = dataSource,
-            FormattingEnabled = formattingEnabled
-        };
-        control.DataManager.Position = position;
-
-        // Select end.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.Equal(1, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.Equal(1, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.Equal(0, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.Equal(0, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedIndex_SetSelectionModeOneWithHandle_GetReturnsExpected()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Select end.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedIndex_SetSelectionModeMultipleWithHandle_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Select end.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedIndex_GetCurSelOne_Success()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select last.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectedIndex = 1;
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedIndex_GetCurSelMultiple_Success(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select last.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectedIndex = 1;
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Span<int> buffer = stackalloc int[5];
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 1, 0, 0, 0, 0 }, buffer.ToArray());
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Assert.Equal(2, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 0, 1, 0, 0, 0 }, buffer.ToArray());
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 0, 1, 0, 0, 0 }, buffer.ToArray());
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.One)]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedIndex_SetWithHandler_CallsSelectedIndexChanged(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.SelectedIndexChanged += handler;
-
-        // Select last.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, callCount);
-
-        // Select same.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, callCount);
-
-        // Select first.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-
-        // Clear selection.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListBox_SelectedIndex_SetInvalidValueEmpty_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public void ListBox_SelectedIndex_SetInvalidValueNotEmpty_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item");
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedIndex_SetNoSelection_ThrowsArgumentException()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.None
-        };
-        Assert.Throws<ArgumentException>("value", () => control.SelectedIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SelectionMode>]
-    public void ListBox_SelectedItem_GetEmptyWithHandle_ReturnsNull(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Null(control.SelectedItem);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SelectionMode>]
-    public void ListBox_SelectedItem_GetNotEmptyWithHandle_ReturnsNull(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("Item");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Null(control.SelectedItem);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended, null)]
-    [InlineData(SelectionMode.MultiSimple, null)]
-    [InlineData(SelectionMode.One, null)]
-    [InlineData(SelectionMode.MultiExtended, "item")]
-    [InlineData(SelectionMode.MultiSimple, "item")]
-    [InlineData(SelectionMode.One, "item")]
-    public void ListBox_SelectedItem_SetEmpty_GetReturnsExpected(SelectionMode selectionMode, string value)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode,
-            SelectedItem = value
-        };
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedItem = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedItem_SetSelectionModeOne_GetReturnsExpected()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select end.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedItem_SetSelectionModeMultiple_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select end.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    [InlineData(false, 1)]
-    public void ListBox_SelectedItem_SetWithDataManager_SetsDataManagerPosition(bool formattingEnabled, int position)
-    {
-        var bindingContext = new BindingContext();
-        var dataSource = new List<string> { "item1", "item2", "item3" };
-        using var control = new SubListBox
-        {
-            BindingContext = bindingContext,
-            DataSource = dataSource,
-            FormattingEnabled = formattingEnabled
-        };
-        control.DataManager.Position = position;
-
-        // Select end.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.Equal(1, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.Equal(1, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.Equal(1, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.Equal(0, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.Equal(0, control.DataManager.Position);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedItem_SetSelectionModeOneWithHandle_GetReturnsExpected()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Select end.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item1", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedItem_SetSelectionModeMultipleWithHandle_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Select end.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedItem_GetCurSelOne_Success()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.One
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select last.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectedItem = "item2";
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedItem_GetCurSelMultiple_Success(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        // Select last.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectedItem = "item2";
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Span<int> buffer = stackalloc int[5];
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 1, 0, 0, 0, 0 }, buffer.ToArray());
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        buffer = stackalloc int[5];
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 1, 0, 0, 0, 0 }, buffer.ToArray());
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Assert.Equal(2, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 0, 1, 0, 0, 0 }, buffer.ToArray());
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETCURSEL));
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETSELITEMS, (WPARAM)buffer.Length, ref buffer[0]));
-        Assert.Equal(new int[] { 0, 1, 0, 0, 0 }, buffer.ToArray());
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.One)]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectedItem_SetWithHandler_CallsSelectedIndexChanged(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.SelectedIndexChanged += handler;
-
-        // Select last.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, callCount);
-
-        // Select same.
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, callCount);
-
-        // Select invalid.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, callCount);
-
-        // Select first.
-        control.SelectedItem = "item1";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-
-        // Clear selection.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.SelectedItem = "item2";
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("NoSuchItem")]
-    public void ListBox_SelectedItem_SetNoSelectionEmpty_Nop(object value)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.None
-        };
-        control.SelectedItem = value;
-        Assert.Null(control.SelectedItem);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedItem_SetNoSelectionNotEmpty_ThrowsArgumentException()
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = SelectionMode.None
-        };
-        control.Items.Add("item");
-        AssertExtensions.Throws<ArgumentException>("value", () => control.SelectedItem = "item");
-        Assert.Null(control.SelectedItem);
-
-        control.SelectedItem = "NoSuchItem";
-        Assert.Null(control.SelectedItem);
-
-        AssertExtensions.Throws<ArgumentException>("value", () => control.SelectedItem = null);
-        Assert.Null(control.SelectedItem);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectedItems_GetDirtyCustom_ReturnsExpected()
-    {
-        using var control = new CustomListBox
-        {
-            SelectionMode = SelectionMode.MultiSimple
-        };
-        control.Items.Add("Item0");
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        control.Items.Add("Item3");
-        control.Items.Add("Item4");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set MakeCustom after the Handle is created to allow for default behaviour.
-        control.MakeCustom = true;
-
-        // Verify equal lengths.
-        control.GetSelCountResult = (IntPtr)1;
-        control.GetSelResult = new int[] { 2 };
-        Dirty();
-        Assert.Equal(new int[] { 2 }, control.SelectedIndices.Cast<int>());
-
-        // Verify truncated
-        control.GetSelCountResult = (IntPtr)2;
-        control.GetSelResult = new int[] { 2 };
-        Dirty();
-        Assert.Equal(new int[] { 0, 2 }, control.SelectedIndices.Cast<int>());
-
-        void Dirty()
-        {
-            // Simulate a selection change notification.
-            PInvoke.SendMessage(control, MessageId.WM_REFLECT | PInvoke.WM_COMMAND, WPARAM.MAKEWPARAM(0, (int)PInvoke.LBN_SELCHANGE));
-        }
-    }
-
-    private class CustomListBox : ListBox
-    {
-        public bool MakeCustom { get; set; }
-
-        public IntPtr GetSelCountResult { get; set; }
-        public int[] GetSelResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.LB_GETSELCOUNT)
-            {
-                m.Result = GetSelCountResult;
-                return;
-            }
-            else if (MakeCustom && m.Msg == (int)PInvoke.LB_GETSELITEMS)
-            {
-                Assert.Equal(GetSelCountResult, m.WParam);
-                Marshal.Copy(GetSelResult, 0, m.LParam, GetSelResult.Length);
-                m.Result = (IntPtr)GetSelResult.Length;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<SelectionMode>]
-    public void ListBox_SelectionMode_SetEmpty_GetReturnsExpected(SelectionMode value)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = value
-        };
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SelectionMode_SetWithCustomOldValue_TestData()
-    {
-        foreach (SelectionMode selectionMode in Enum.GetValues(typeof(SelectionMode)))
-        {
-            foreach (SelectionMode value in Enum.GetValues(typeof(SelectionMode)))
-            {
-                yield return new object[] { selectionMode, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionMode_SetWithCustomOldValue_TestData))]
-    public void ListBox_SelectionMode_SetEmptyWithCustomOldValue_GetReturnsExpected(SelectionMode selectionMode, SelectionMode value)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiSimple)]
-    [InlineData(SelectionMode.MultiExtended)]
-    public void ListBox_SelectionMode_SetWithItemsOneSelectedToMulti_GetReturnsExpected(SelectionMode value)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 1;
-
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Set back to one.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectionMode_SetWithItemsOneSelectedToNone_GetReturnsExpected()
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 1;
-
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-
-        // Set back to one.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectionMode_SetWithItemsMultiSelectedToOne_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 0;
-        control.SelectedIndex = 1;
-
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set back to multi.
-        control.SelectionMode = selectionMode;
-        Assert.Equal(selectionMode, control.SelectionMode);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectionMode_SetWithItemsMultiSelectedToNone_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 0;
-        control.SelectedIndex = 1;
-
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set back to multi.
-        control.SelectionMode = selectionMode;
-        Assert.Equal(selectionMode, control.SelectionMode);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("item1", control.SelectedItem);
-        Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>());
-        Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.None, 1)]
-    [InlineData(SelectionMode.MultiExtended, 1)]
-    [InlineData(SelectionMode.MultiSimple, 1)]
-    [InlineData(SelectionMode.One, 0)]
-    public void ListBox_SelectionMode_SetEmptyWithHandle_GetReturnsExpected(SelectionMode value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionMode_SetWithCustomOldValueWithHandle_TestData()
-    {
-        yield return new object[] { SelectionMode.None, SelectionMode.None, 0 };
-        yield return new object[] { SelectionMode.None, SelectionMode.MultiExtended, 1 };
-        yield return new object[] { SelectionMode.None, SelectionMode.MultiSimple, 1 };
-        yield return new object[] { SelectionMode.None, SelectionMode.One, 1 };
-
-        yield return new object[] { SelectionMode.MultiExtended, SelectionMode.None, 1 };
-        yield return new object[] { SelectionMode.MultiExtended, SelectionMode.MultiExtended, 0 };
-        yield return new object[] { SelectionMode.MultiExtended, SelectionMode.MultiSimple, 1 };
-        yield return new object[] { SelectionMode.MultiExtended, SelectionMode.One, 1 };
-
-        yield return new object[] { SelectionMode.MultiSimple, SelectionMode.None, 1 };
-        yield return new object[] { SelectionMode.MultiSimple, SelectionMode.MultiExtended, 1 };
-        yield return new object[] { SelectionMode.MultiSimple, SelectionMode.MultiSimple, 0 };
-        yield return new object[] { SelectionMode.MultiSimple, SelectionMode.One, 1 };
-
-        yield return new object[] { SelectionMode.One, SelectionMode.None, 1 };
-        yield return new object[] { SelectionMode.One, SelectionMode.MultiExtended, 1 };
-        yield return new object[] { SelectionMode.One, SelectionMode.MultiSimple, 1 };
-        yield return new object[] { SelectionMode.One, SelectionMode.One, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionMode_SetWithCustomOldValueWithHandle_TestData))]
-    public void ListBox_SelectionMode_SetEmptyWithCustomOldValueWithHandle_GetReturnsExpected(SelectionMode selectionMode, SelectionMode value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiSimple)]
-    [InlineData(SelectionMode.MultiExtended)]
-    public void ListBox_SelectionMode_SetWithItemsOneSelectedToMultiWithHandle_GetReturnsExpected(SelectionMode value)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 1;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = value;
-        Assert.Equal(value, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set back to one.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SelectionMode_SetWithItemsOneSelectedToNoneWithHandle_GetReturnsExpected()
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 1;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set back to one.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectionMode_SetWithItemsMultiSelectedToOneWithHandle_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 0;
-        control.SelectedIndex = 1;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.One;
-        Assert.Equal(SelectionMode.One, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set back to multi.
-        control.SelectionMode = selectionMode;
-        Assert.Equal(selectionMode, control.SelectionMode);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal("item2", control.SelectedItem);
-        Assert.Equal(1, Assert.Single(control.SelectedIndices));
-        Assert.Equal("item2", Assert.Single(control.SelectedItems));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiExtended)]
-    [InlineData(SelectionMode.MultiSimple)]
-    public void ListBox_SelectionMode_SetWithItemsMultiSelectedToNoneWithHandle_GetReturnsExpected(SelectionMode selectionMode)
-    {
-        using var control = new ListBox
-        {
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 0;
-        control.SelectedIndex = 1;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set same.
-        control.SelectionMode = SelectionMode.None;
-        Assert.Equal(SelectionMode.None, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set back to multi.
-        control.SelectionMode = selectionMode;
-        Assert.Equal(selectionMode, control.SelectionMode);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<SelectionMode>]
-    public void ListBox_SelectionMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(SelectionMode value)
-    {
-        using var control = new ListBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.SelectionMode = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_Sorted_SetWithoutItems_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox
-        {
-            Sorted = value
-        };
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_Sorted_SetWithEmptyItems_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox();
-        Assert.Empty(control.Items);
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Sorted_SetWithItems_TestData()
-    {
-        yield return new object[] { true, new string[] { "item1", "item2" } };
-        yield return new object[] { false, new string[] { "item2", "item1" } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_SetWithItems_TestData))]
-    public void ListBox_Sorted_SetWithItems_GetReturnsExpected(bool value, string[] expected)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expected, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expected, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_Sorted_SetWithoutItemsWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.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.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_Sorted_SetWithEmptyItemsWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.Empty(control.Items);
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Sorted_SetWithItems_TestData))]
-    public void ListBox_Sorted_SetWithItemsWithHandle_GetReturnsExpected(bool value, string[] expected)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expected, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expected, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListBox_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ListBox
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithItems_TestData()
-    {
-        foreach (bool formattingEnabled in new bool[] { true, false })
-        {
-            yield return new object[] { formattingEnabled, SelectionMode.None, null, string.Empty, -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, string.Empty, string.Empty, -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "NoSuchItem", "NoSuchItem", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "item1", "item1", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "ITEM1", "ITEM1", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "item2", "item2", -1 };
-
-            foreach (SelectionMode selectionMode in new SelectionMode[] { SelectionMode.MultiExtended, SelectionMode.MultiSimple, SelectionMode.One })
-            {
-                yield return new object[] { formattingEnabled, selectionMode, null, string.Empty, -1 };
-                yield return new object[] { formattingEnabled, selectionMode, string.Empty, string.Empty, -1 };
-                yield return new object[] { formattingEnabled, selectionMode, "NoSuchItem", "NoSuchItem", -1 };
-                yield return new object[] { formattingEnabled, selectionMode, "item1", "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, "ITEM1", "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, "item2", "item2", 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithItems_TestData))]
-    public void ListBox_Text_SetWithItems_GetReturnsExpected(bool formattingEnabled, SelectionMode selectionMode, string value, string expected, int expectedSelectedIndex)
-    {
-        using var control = new ListBox
-        {
-            FormattingEnabled = formattingEnabled,
-            SelectionMode = selectionMode
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithItemsWithSelection_TestData()
-    {
-        foreach (bool formattingEnabled in new bool[] { true, false })
-        {
-            yield return new object[] { formattingEnabled, SelectionMode.None, null, string.Empty, -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, string.Empty, string.Empty, -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "NoSuchItem", "NoSuchItem", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "item1", "item1", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "ITEM1", "ITEM1", -1 };
-            yield return new object[] { formattingEnabled, SelectionMode.None, "item2", "item2", -1 };
-
-            foreach (SelectionMode selectionMode in new SelectionMode[] { SelectionMode.MultiExtended, SelectionMode.MultiSimple, SelectionMode.One })
-            {
-                yield return new object[] { formattingEnabled, selectionMode, null, "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, string.Empty, "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, "NoSuchItem", "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, "item1", "item1", 0 };
-                yield return new object[] { formattingEnabled, selectionMode, "ITEM1", "item1", 0 };
-            }
-
-            yield return new object[] { formattingEnabled, SelectionMode.MultiExtended, "item2", "item1", 0 };
-            yield return new object[] { formattingEnabled, SelectionMode.MultiSimple, "item2", "item1", 0 };
-            yield return new object[] { formattingEnabled, SelectionMode.One, "item2", "item2", 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithItemsWithSelection_TestData))]
-    public void ListBox_Text_SetWithItemsWithSelection_GetReturnsExpected(bool formattingEnabled, SelectionMode selectionMode, string value, string expected, int expectedSelectedIndex)
-    {
-        using var control = new ListBox
-        {
-            FormattingEnabled = formattingEnabled
-        };
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-        control.SelectedIndex = 0;
-        control.SelectionMode = selectionMode;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListBox_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new ListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_TopIndex_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(0, control.TopIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_TopIndex_SetEmpty_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox
-        {
-            TopIndex = value
-        };
-        Assert.Equal(value, control.TopIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TopIndex = value;
-        Assert.Equal(value, control.TopIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_TopIndex_SetNotEmpty_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        control.TopIndex = value;
-        Assert.Equal(value, control.TopIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TopIndex = value;
-        Assert.Equal(value, control.TopIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_TopIndex_SetWithHandleEmpty_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TopIndex = value;
-        Assert.Equal(0, control.TopIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TopIndex = value;
-        Assert.Equal(0, control.TopIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    [InlineData(int.MaxValue)]
-    public void ListBox_TopIndex_SetWithHandleNotEmpty_GetReturnsExpected(int value)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TopIndex = value;
-        Assert.Equal(0, control.TopIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TopIndex = value;
-        Assert.Equal(0, control.TopIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_TopIndex_GetTopIndex_ReturnsExpected()
-    {
-        using var control = new ListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        control.Items.Add("item1");
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.TopIndex = 1;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LB_GETTOPINDEX));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_UseCustomTabOffsets_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox
-        {
-            UseCustomTabOffsets = value
-        };
-        Assert.Equal(value, control.UseCustomTabOffsets);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseCustomTabOffsets = value;
-        Assert.Equal(value, control.UseCustomTabOffsets);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseCustomTabOffsets = !value;
-        Assert.Equal(!value, control.UseCustomTabOffsets);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListBox_UseCustomTabOffsets_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseCustomTabOffsets = value;
-        Assert.Equal(value, control.UseCustomTabOffsets);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.UseCustomTabOffsets = value;
-        Assert.Equal(value, control.UseCustomTabOffsets);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.UseCustomTabOffsets = !value;
-        Assert.Equal(!value, control.UseCustomTabOffsets);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListBox_UseTabStops_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ListBox
-        {
-            UseTabStops = value
-        };
-        Assert.Equal(value, control.UseTabStops);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseTabStops = value;
-        Assert.Equal(value, control.UseTabStops);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseTabStops = !value;
-        Assert.Equal(!value, control.UseTabStops);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ListBox_UseTabStops_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseTabStops = value;
-        Assert.Equal(value, control.UseTabStops);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.UseTabStops = value;
-        Assert.Equal(value, control.UseTabStops);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.UseTabStops = !value;
-        Assert.Equal(!value, control.UseTabStops);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_AddItemsCore_Invoke_Success()
-    {
-        using var control = new SubListBox();
-
-        // Add multiple.
-        control.AddItemsCore(new object[] { "item1", "item2" });
-        Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Add another.
-        control.AddItemsCore(new object[] { "item3" });
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Add empty.
-        control.AddItemsCore(Array.Empty<object>());
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Add null.
-        control.AddItemsCore(null);
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_AddItemsCore_InvokeWithHandle_Success()
-    {
-        using var control = new SubListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Add multiple.
-        control.AddItemsCore(new object[] { "item1", "item2" });
-        Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add another.
-        control.AddItemsCore(new object[] { "item3" });
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add empty.
-        control.AddItemsCore(Array.Empty<object>());
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add null.
-        control.AddItemsCore(null);
-        Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BeginUpdate_InvokeWithoutHandle_Nop()
-    {
-        using var control = new ListBox();
-        control.BeginUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.BeginUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // End once.
-        control.EndUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // End twice.
-        control.EndUpdate();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_BeginUpdate_InvokeWithHandle_Nop()
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BeginUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.BeginUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // End once.
-        control.EndUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // End twice.
-        control.EndUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_EndUpdate_InvokeWithoutHandle_Success()
-    {
-        using var control = new ListBox();
-
-        // End without beginning.
-        control.EndUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // Begin.
-        control.BeginUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // End.
-        control.EndUpdate();
-        Assert.False(control.IsHandleCreated);
-
-        // End again.
-        control.EndUpdate();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_EndUpdate_InvokeWithHandle_Success()
-    {
-        using var control = new ListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // End without beginning.
-        control.EndUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Begin.
-        control.BeginUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // End.
-        control.EndUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // End again.
-        control.EndUpdate();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.List)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ListBox_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var control = new SubListBox();
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(accessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListBox();
-        ListBox.ObjectCollection items = Assert.IsType<ListBox.ObjectCollection>(control.CreateItemCollection());
-        Assert.Empty(items);
-        Assert.False(items.IsReadOnly);
-        Assert.NotSame(items, control.CreateItemCollection());
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            yield return new object[] { borderStyle, Size.Empty };
-            yield return new object[] { borderStyle, new Size(-1, -2) };
-            yield return new object[] { borderStyle, new Size(10, 20) };
-            yield return new object[] { borderStyle, new Size(30, 40) };
-            yield return new object[] { borderStyle, new Size(int.MaxValue, int.MaxValue) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ListBox_GetPreferredSize_Invoke_ReturnsExpected(BorderStyle borderStyle, Size proposedSize)
-    {
-        using var control = new ListBox
-        {
-            BorderStyle = borderStyle
-        };
-        Assert.Equal(new Size(120, 96), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(120, 96), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ListBox_GetPreferredSize_InvokeWithPadding_ReturnsExpected(BorderStyle borderStyle, Size proposedSize)
-    {
-        using var control = new ListBox
-        {
-            BorderStyle = borderStyle,
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(new Size(120, 96), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(120, 96), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ListBox_GetPreferredSize_InvokeWithHandle_ReturnsExpected(BorderStyle borderStyle, Size proposedSize)
-    {
-        using var control = new ListBox
-        {
-            BorderStyle = borderStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Size result = control.GetPreferredSize(proposedSize);
-        Assert.True(result.Width > 0 && result.Width < 120);
-        Assert.Equal(control.PreferredHeight, result.Height);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(result, control.GetPreferredSize(proposedSize));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ListBox_GetPreferredSize_InvokeWithHandleWithPadding_ReturnsExpected(BorderStyle borderStyle, Size proposedSize)
-    {
-        using var control = new ListBox
-        {
-            BorderStyle = borderStyle,
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Size result = control.GetPreferredSize(proposedSize);
-        Assert.True(result.Width > 0 && result.Width < 120);
-        Assert.Equal(control.PreferredHeight + 6, result.Height);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(result, control.GetPreferredSize(proposedSize));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ListBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubListBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> FindString_TestData()
-    {
-        foreach (int startIndex in new int[] { -2, -1, 0, 1 })
-        {
-            yield return new object[] { new ListBox(), null, startIndex, -1 };
-            yield return new object[] { new ListBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ListBox(), "s", startIndex, -1 };
-
-            using var controlWithNoItems = new ListBox();
-            Assert.Empty(controlWithNoItems.Items);
-            yield return new object[] { new ListBox(), null, startIndex, -1 };
-            yield return new object[] { new ListBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ListBox(), "s", startIndex, -1 };
-        }
-
-        using var controlWithItems = new ListBox
-        {
-            DisplayMember = "Value"
-        };
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "ABC" });
-        controlWithItems.Items.Add(new DataClass { Value = "def" });
-        controlWithItems.Items.Add(new DataClass { Value = "" });
-        controlWithItems.Items.Add(new DataClass { Value = null });
-
-        yield return new object[] { controlWithItems, "abc", -1, 0 };
-        yield return new object[] { controlWithItems, "abc", 0, 1 };
-        yield return new object[] { controlWithItems, "abc", 1, 2 };
-        yield return new object[] { controlWithItems, "abc", 2, 0 };
-        yield return new object[] { controlWithItems, "abc", 5, 0 };
-
-        yield return new object[] { controlWithItems, "ABC", -1, 0 };
-        yield return new object[] { controlWithItems, "ABC", 0, 1 };
-        yield return new object[] { controlWithItems, "ABC", 1, 2 };
-        yield return new object[] { controlWithItems, "ABC", 2, 0 };
-        yield return new object[] { controlWithItems, "ABC", 5, 0 };
-
-        yield return new object[] { controlWithItems, "a", -1, 0 };
-        yield return new object[] { controlWithItems, "a", 0, 1 };
-        yield return new object[] { controlWithItems, "a", 1, 2 };
-        yield return new object[] { controlWithItems, "a", 2, 0 };
-        yield return new object[] { controlWithItems, "a", 5, 0 };
-
-        yield return new object[] { controlWithItems, "A", -1, 0 };
-        yield return new object[] { controlWithItems, "A", 0, 1 };
-        yield return new object[] { controlWithItems, "A", 1, 2 };
-        yield return new object[] { controlWithItems, "A", 2, 0 };
-        yield return new object[] { controlWithItems, "A", 5, 0 };
-
-        yield return new object[] { controlWithItems, "abcd", -1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 0, -1 };
-        yield return new object[] { controlWithItems, "abcd", 1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 2, -1 };
-        yield return new object[] { controlWithItems, "abcd", 5, -1 };
-
-        yield return new object[] { controlWithItems, "def", -1, 3 };
-        yield return new object[] { controlWithItems, "def", 0, 3 };
-        yield return new object[] { controlWithItems, "def", 1, 3 };
-        yield return new object[] { controlWithItems, "def", 2, 3 };
-        yield return new object[] { controlWithItems, "def", 5, 3 };
-
-        yield return new object[] { controlWithItems, null, -1, -1 };
-        yield return new object[] { controlWithItems, null, 0, -1 };
-        yield return new object[] { controlWithItems, null, 1, -1 };
-        yield return new object[] { controlWithItems, null, 2, -1 };
-        yield return new object[] { controlWithItems, null, 5, -1 };
-
-        yield return new object[] { controlWithItems, string.Empty, -1, 0 };
-        yield return new object[] { controlWithItems, string.Empty, 0, 1 };
-        yield return new object[] { controlWithItems, string.Empty, 1, 2 };
-        yield return new object[] { controlWithItems, string.Empty, 2, 3 };
-        yield return new object[] { controlWithItems, string.Empty, 5, 0 };
-
-        yield return new object[] { controlWithItems, "NoSuchItem", -1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 0, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 2, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 5, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FindString_TestData))]
-    public void ListBox_FindString_Invoke_ReturnsExpected(ListBox control, string s, int startIndex, int expected)
-    {
-        if (startIndex == -1)
-        {
-            Assert.Equal(expected, control.FindString(s));
-        }
-
-        Assert.Equal(expected, control.FindString(s, startIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBox_FindString_InvalidStartIndex_ThrowsArgumentOutOfRangeException(int startIndex)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item");
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindString("s", startIndex));
-    }
-
-    public static IEnumerable<object[]> FindStringExact_TestData()
-    {
-        foreach (int startIndex in new int[] { -2, -1, 0, 1 })
-        {
-            yield return new object[] { new ListBox(), null, startIndex, -1 };
-            yield return new object[] { new ListBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ListBox(), "s", startIndex, -1 };
-
-            using var controlWithNoItems = new ListBox();
-            Assert.Empty(controlWithNoItems.Items);
-            yield return new object[] { new ListBox(), null, startIndex, -1 };
-            yield return new object[] { new ListBox(), string.Empty, startIndex, -1 };
-            yield return new object[] { new ListBox(), "s", startIndex, -1 };
-        }
-
-        using var controlWithItems = new ListBox
-        {
-            DisplayMember = "Value"
-        };
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "abc" });
-        controlWithItems.Items.Add(new DataClass { Value = "ABC" });
-        controlWithItems.Items.Add(new DataClass { Value = "def" });
-        controlWithItems.Items.Add(new DataClass { Value = "" });
-        controlWithItems.Items.Add(new DataClass { Value = null });
-
-        yield return new object[] { controlWithItems, "abc", -1, 0 };
-        yield return new object[] { controlWithItems, "abc", 0, 1 };
-        yield return new object[] { controlWithItems, "abc", 1, 2 };
-        yield return new object[] { controlWithItems, "abc", 2, 0 };
-        yield return new object[] { controlWithItems, "abc", 5, 0 };
-
-        yield return new object[] { controlWithItems, "ABC", -1, 0 };
-        yield return new object[] { controlWithItems, "ABC", 0, 1 };
-        yield return new object[] { controlWithItems, "ABC", 1, 2 };
-        yield return new object[] { controlWithItems, "ABC", 2, 0 };
-        yield return new object[] { controlWithItems, "ABC", 5, 0 };
-
-        yield return new object[] { controlWithItems, "a", -1, -1 };
-        yield return new object[] { controlWithItems, "a", 0, -1 };
-        yield return new object[] { controlWithItems, "a", 1, -1 };
-        yield return new object[] { controlWithItems, "a", 2, -1 };
-        yield return new object[] { controlWithItems, "a", 5, -1 };
-
-        yield return new object[] { controlWithItems, "A", -1, -1 };
-        yield return new object[] { controlWithItems, "A", 0, -1 };
-        yield return new object[] { controlWithItems, "A", 1, -1 };
-        yield return new object[] { controlWithItems, "A", 2, -1 };
-        yield return new object[] { controlWithItems, "A", 5, -1 };
-
-        yield return new object[] { controlWithItems, "abcd", -1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 0, -1 };
-        yield return new object[] { controlWithItems, "abcd", 1, -1 };
-        yield return new object[] { controlWithItems, "abcd", 2, -1 };
-        yield return new object[] { controlWithItems, "abcd", 5, -1 };
-
-        yield return new object[] { controlWithItems, "def", -1, 3 };
-        yield return new object[] { controlWithItems, "def", 0, 3 };
-        yield return new object[] { controlWithItems, "def", 1, 3 };
-        yield return new object[] { controlWithItems, "def", 2, 3 };
-        yield return new object[] { controlWithItems, "def", 5, 3 };
-
-        yield return new object[] { controlWithItems, null, -1, -1 };
-        yield return new object[] { controlWithItems, null, 0, -1 };
-        yield return new object[] { controlWithItems, null, 1, -1 };
-        yield return new object[] { controlWithItems, null, 2, -1 };
-        yield return new object[] { controlWithItems, null, 5, -1 };
-
-        yield return new object[] { controlWithItems, string.Empty, -1, 4 };
-        yield return new object[] { controlWithItems, string.Empty, 0, 4 };
-        yield return new object[] { controlWithItems, string.Empty, 1, 4 };
-        yield return new object[] { controlWithItems, string.Empty, 2, 4 };
-        yield return new object[] { controlWithItems, string.Empty, 5, 4 };
-
-        yield return new object[] { controlWithItems, "NoSuchItem", -1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 0, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 1, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 2, -1 };
-        yield return new object[] { controlWithItems, "NoSuchItem", 5, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FindStringExact_TestData))]
-    public void ListBox_FindStringExact_Invoke_ReturnsExpected(ListBox control, string s, int startIndex, int expected)
-    {
-        if (startIndex == -1)
-        {
-            Assert.Equal(expected, control.FindStringExact(s));
-        }
-
-        Assert.Equal(expected, control.FindStringExact(s, startIndex));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBox_FindStringExact_InvalidStartIndex_ThrowsArgumentOutOfRangeException(int startIndex)
-    {
-        using var control = new ListBox();
-        control.Items.Add("item");
-        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => control.FindStringExact("s", startIndex));
-    }
-
-    [WinFormsTheory]
-    [EnumData<DrawMode>]
-    public void ListBox_GetItemHeight_InvokeEmptyWithoutHandle_ReturnsExpected(DrawMode drawMode)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode
-        };
-        Assert.Equal(Control.DefaultFont.Height, control.GetItemHeight(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetItemHeight_NotEmpty_TestData()
-    {
-        foreach (DrawMode drawMode in Enum.GetValues(typeof(DrawMode)))
-        {
-            yield return new object[] { drawMode, 0 };
-            yield return new object[] { drawMode, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemHeight_NotEmpty_TestData))]
-    public void ListBox_GetItemHeight_InvokeNotEmptyWithoutHandle_ReturnsExpected(DrawMode drawMode, int index)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        Assert.Equal(Control.DefaultFont.Height, control.GetItemHeight(index));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DrawMode.Normal)]
-    [InlineData(DrawMode.OwnerDrawFixed)]
-    [InlineData(DrawMode.OwnerDrawVariable)]
-    public void ListBox_GetItemHeight_InvokeEmptyWithHandle_ReturnsExpected(DrawMode drawMode)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.GetItemHeight(0) > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemHeight_NotEmpty_TestData))]
-    public void ListBox_GetItemHeight_InvokeNotEmptyWithHandle_ReturnsExpected(DrawMode drawMode, int index)
-    {
-        using var control = new ListBox
-        {
-            DrawMode = drawMode
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.GetItemHeight(index) > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetItemHeight_CustomGetItemHeight_TestData()
-    {
-        yield return new object[] { DrawMode.Normal, 0, 0, 0, 0 };
-        yield return new object[] { DrawMode.Normal, 1, 0, -2, -2 };
-        yield return new object[] { DrawMode.Normal, 0, 0, 10, 10 };
-        yield return new object[] { DrawMode.OwnerDrawFixed, 0, 0, 0, 0 };
-        yield return new object[] { DrawMode.OwnerDrawFixed, 1, 0, -2, -2 };
-        yield return new object[] { DrawMode.OwnerDrawFixed, 0, 0, 10, 10 };
-        yield return new object[] { DrawMode.OwnerDrawVariable, 0, 0, 0, 0 };
-        yield return new object[] { DrawMode.OwnerDrawVariable, 1, 1, -2, -2 };
-        yield return new object[] { DrawMode.OwnerDrawVariable, 0, 0, 10, 10 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemHeight_CustomGetItemHeight_TestData))]
-    public void ListBox_GetItemHeight_InvokeCustomGetItemHeight_ReturnsExpected(DrawMode drawMode, int index, int expectedIndex, int getItemRectResult, int expected)
-    {
-        using var control = new CustomGetItemHeightListBox
-        {
-            DrawMode = drawMode,
-            ExpectedIndex = expectedIndex,
-            GetItemHeightResult = (IntPtr)getItemRectResult
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.GetItemHeight(index));
-    }
-
-    private class CustomGetItemHeightListBox : ListBox
-    {
-        public bool MakeCustom { get; set; }
-        public int ExpectedIndex { get; set; }
-        public IntPtr GetItemHeightResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.LB_GETITEMHEIGHT)
-            {
-                Assert.Equal(ExpectedIndex, (int)m.WParam);
-                m.Result = GetItemHeightResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemHeight_InvokeInvalidGetItemHeight_ThrowsWin32Exception()
-    {
-        using var control = new InvalidGetItemHeightListBox();
-        control.Items.Add("Item");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Throws<Win32Exception>(() => control.GetItemHeight(0));
-    }
-
-    private class InvalidGetItemHeightListBox : ListBox
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.LB_GETITEMHEIGHT)
-            {
-                m.Result = -1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListBox_GetItemHeight_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemHeight(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListBox_GetItemHeight_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item");
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemHeight(index));
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvokeWithoutHandle_ReturnsExpectedAndCreatedHandle()
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item1");
-        control.Items.Add("Item1");
-
-        Rectangle rect1 = control.GetItemRectangle(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetItemRectangle(0));
-        Assert.True(control.IsHandleCreated);
-
-        Rectangle rect2 = control.GetItemRectangle(1);
-        Assert.Equal(rect2.X, rect1.X);
-        Assert.True(rect2.Y >= rect1.Y + rect1.Height);
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item1");
-        control.Items.Add("Item1");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Rectangle rect1 = control.GetItemRectangle(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetItemRectangle(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Rectangle rect2 = control.GetItemRectangle(1);
-        Assert.Equal(rect2.X, rect1.X);
-        Assert.True(rect2.Y >= rect1.Y + rect1.Height);
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetItemRectangle_CustomGetItemRect_TestData()
-    {
-        yield return new object[] { new RECT(), Rectangle.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Rectangle(1, 2, 2, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemRectangle_CustomGetItemRect_TestData))]
-    public void ListBox_GetItemRectangle_InvokeCustomGetItemRect_ReturnsExpected(object getItemRectResult, Rectangle expected)
-    {
-        using var control = new CustomGetItemRectListBox
-        {
-            GetItemRectResult = (RECT)getItemRectResult
-        };
-        control.Items.Add("Item");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, control.GetItemRectangle(0));
-    }
-
-    private class CustomGetItemRectListBox : ListBox
-    {
-        public RECT GetItemRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LB_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetItemRectResult;
-                m.Result = 1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvokeInvalidGetItemRect_ReturnsExpected()
-    {
-        using var control = new InvalidGetItemRectListBox();
-        control.Items.Add("Item");
-        Assert.NotEqual(0, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Equal(Rectangle.Empty, control.GetItemRectangle(0));
-    }
-
-    private class InvalidGetItemRectListBox : ListBox
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.LB_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = new RECT(1, 2, 3, 4);
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(1));
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item");
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(2));
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvalidIndexWithHandleEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListBox();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(1));
-    }
-
-    [WinFormsFact]
-    public void ListBox_GetItemRectangle_InvalidIndexWithHandleNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListBox();
-        control.Items.Add("Item");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRectangle(2));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnDrawItem_TestData()
-    {
-        yield return new object[] { null };
-
-        var bitmap = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(bitmap);
-        yield return new object[] { new DrawItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), 0, DrawItemState.Checked) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDrawItem_TestData))]
-    public void ListBox_OnDrawItem_Invoke_CallsDrawItem(DrawItemEventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        void handler(object sender, DrawItemEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.DrawItem += handler;
-        control.OnDrawItem(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DrawItem -= handler;
-        control.OnDrawItem(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(96, control.Height);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(96, control.Height);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnGotFocus_InvokeWithHandle_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GotFocus += handler;
-        control.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.GotFocus -= handler;
-        control.OnGotFocus(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMeasureItem_TestData()
-    {
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        yield return new object[] { null };
-        yield return new object[] { new MeasureItemEventArgs(graphics, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMeasureItem_TestData))]
-    public void ListBox_OnMeasureItem_Invoke_CallsMeasureItem(MeasureItemEventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        void handler(object sender, MeasureItemEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MeasureItem += handler;
-        control.OnMeasureItem(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MeasureItem -= handler;
-        control.OnMeasureItem(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ListBox_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ListBox_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnSelectedIndexChanged_Invoke_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int selectedValueChangedCallCount = 0;
-        control.SelectedValueChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            selectedValueChangedCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.True(callCount < selectedValueChangedCallCount);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, selectedValueChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, selectedValueChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnSelectedIndexChanged_InvokeWithHandle_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int selectedValueChangedCallCount = 0;
-        control.SelectedValueChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            selectedValueChangedCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.True(callCount < selectedValueChangedCallCount);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, selectedValueChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, selectedValueChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnSelectedIndexChanged_WithDataManager_TestData()
-    {
-        foreach (bool formattingEnabled in new bool[] { true, false })
-        {
-            foreach (int position in new int[] { 0, 1 })
-            {
-                yield return new object[] { formattingEnabled, position, null };
-                yield return new object[] { formattingEnabled, position, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnSelectedIndexChanged_WithDataManager_TestData))]
-    public void ListBox_OnSelectedIndexChanged_InvokeWithDataManager_CallsSelectedIndexChanged(bool formattingEnabled, int position, EventArgs eventArgs)
-    {
-        var bindingContext = new BindingContext();
-        var dataSource = new List<string> { "item1", "item2", "item3" };
-        using var control = new SubListBox
-        {
-            BindingContext = bindingContext,
-            DataSource = dataSource,
-            FormattingEnabled = formattingEnabled
-        };
-        control.DataManager.Position = position;
-        int selectedValueChangedCallCount = 0;
-        control.SelectedValueChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            selectedValueChangedCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.True(callCount < selectedValueChangedCallCount);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, selectedValueChangedCallCount);
-        Assert.Equal(position, control.DataManager.Position);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, selectedValueChangedCallCount);
-        Assert.Equal(position, control.DataManager.Position);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListBox_OnSelectedValueChanged_Invoke_CallsSelectedValueChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedValueChanged += handler;
-        control.OnSelectedValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SelectedValueChanged -= handler;
-        control.OnSelectedValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_RefreshItems_InvokeEmpty_Success()
-    {
-        using var control = new SubListBox();
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_RefreshItems_InvokeNotEmpty_Success()
-    {
-        using var control = new SubListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListBox_RefreshItems_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Empty(control.Items);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_RefreshItems_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.RefreshItems();
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ResetBackColor_Invoke_Success()
-    {
-        using var control = new ListBox();
-
-        // Reset without value.
-        control.ResetBackColor();
-        Assert.Equal(SystemColors.Window, control.BackColor);
-
-        // Reset with value.
-        control.BackColor = Color.Black;
-        control.ResetBackColor();
-        Assert.Equal(SystemColors.Window, control.BackColor);
-
-        // Reset again.
-        control.ResetBackColor();
-        Assert.Equal(SystemColors.Window, control.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ListBox_ResetForeColor_Invoke_Success()
-    {
-        using var control = new ListBox();
-
-        // Reset without value.
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-
-        // Reset with value.
-        control.ForeColor = Color.Black;
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-
-        // Reset again.
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-    }
-
-    public static IEnumerable<object[]> SetItemsCore_TestData()
-    {
-        yield return new object[] { new object[] { "item1", "item2", "item3" } };
-        yield return new object[] { Array.Empty<object>() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetItemsCore_TestData))]
-    public void ListBox_SetItemsCore_Invoke_Success(object[] value)
-    {
-        using var control = new SubListBox();
-        control.SetItemsCore(value);
-        Assert.Equal(value, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetItemsCore(value);
-        Assert.Equal(value, control.Items.Cast<object>());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetItemsCore_TestData))]
-    public void ListBox_SetItemsCore_InvokeWithHandle_Success(object[] value)
-    {
-        using var control = new SubListBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetItemsCore(value);
-        Assert.Equal(value, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetItemsCore(value);
-        Assert.Equal(value, control.Items.Cast<object>());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SetItemsCore_NullValueEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new SubListBox();
-        Assert.Throws<ArgumentNullException>("value", () => control.SetItemsCore(null));
-        Assert.Empty(control.Items);
-    }
-
-    [WinFormsFact]
-    public void ListBox_SetItemsCore_NullValueNotEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new SubListBox();
-        control.Items.Add("item1");
-        control.Items.Add("item2");
-        Assert.Throws<ArgumentNullException>("value", () => control.SetItemsCore(null));
-        Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());
-    }
-
-    [WinFormsFact]
-    public void ListBox_ToString_InvokeWithoutItems_ReturnsExpected()
-    {
-        using var control = new ListBox();
-        Assert.Equal("System.Windows.Forms.ListBox", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void ListBox_ToString_InvokeWithEmptyItems_ReturnsExpected()
-    {
-        using var control = new ListBox();
-        Assert.Empty(control.Items);
-        Assert.Equal("System.Windows.Forms.ListBox, Items.Count: 0", control.ToString());
-    }
-
-    public static IEnumerable<object[]> ToString_WithItems_TestData()
-    {
-        yield return new object[] { string.Empty, "System.Windows.Forms.ListBox, Items.Count: 2, Items[0]: " };
-        yield return new object[] { "abc", "System.Windows.Forms.ListBox, Items.Count: 2, Items[0]: abc" };
-        yield return new object[] { new string('a', 41), "System.Windows.Forms.ListBox, Items.Count: 2, Items[0]: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToString_WithItems_TestData))]
-    public void ListBox_ToString_InvokeWithItems_ReturnsExpected(string item1, string expected)
-    {
-        using var control = new ListBox();
-        control.Items.Add(item1);
-        control.Items.Add("item2");
-        Assert.Equal(expected, control.ToString());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListBox_Remove_NotSelectedItems_IfOneItemSelected(bool createControl)
-    {
-        using ListBox listBox = new();
-
-        if (createControl)
-        {
-            listBox.CreateControl();
-        }
-
-        listBox.Items.AddRange(new object[] { "1", "2", "3" });
-        listBox.SelectedItem = listBox.Items[0];
-
-        Assert.Equal(3, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(1, listBox.SelectedIndices.Count);
-        Assert.Equal(1, listBox.SelectedItems.Count);
-
-        listBox.Items.Remove(listBox.Items[2]);
-
-        Assert.Equal(2, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(1, listBox.SelectedIndices.Count);
-        Assert.Equal(1, listBox.SelectedItems.Count);
-
-        listBox.Items.Remove(listBox.Items[1]);
-
-        Assert.Equal(1, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(1, listBox.SelectedIndices.Count);
-        Assert.Equal(1, listBox.SelectedItems.Count);
-        Assert.Equal(createControl, listBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiSimple, true)]
-    [InlineData(SelectionMode.MultiSimple, false)]
-    [InlineData(SelectionMode.MultiExtended, true)]
-    [InlineData(SelectionMode.MultiExtended, false)]
-    public void ListBox_Remove_NotSelectedItems_IfSeveralItemsSelected(SelectionMode mode, bool createControl)
-    {
-        using ListBox listBox = new() { SelectionMode = mode };
-
-        if (createControl)
-        {
-            listBox.CreateControl();
-        }
-
-        listBox.Items.AddRange(new object[] { "1", "2", "3", "4" });
-        listBox.SelectedItems.Add(listBox.Items[0]);
-        listBox.SelectedItems.Add(listBox.Items[1]);
-
-        Assert.Equal(4, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(2, listBox.SelectedIndices.Count);
-        Assert.Equal(2, listBox.SelectedItems.Count);
-
-        listBox.Items.Remove(listBox.Items[3]);
-
-        Assert.Equal(3, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(2, listBox.SelectedIndices.Count);
-        Assert.Equal(2, listBox.SelectedItems.Count);
-
-        listBox.Items.Remove(listBox.Items[2]);
-
-        Assert.Equal(2, listBox.Items.Count);
-        Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-        Assert.Equal(0, listBox.SelectedIndex);
-        Assert.Equal(2, listBox.SelectedIndices.Count);
-        Assert.Equal(2, listBox.SelectedItems.Count);
-        Assert.Equal(createControl, listBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListBox_Remove_SelectedItem(bool createControl)
-    {
-        using ListBox listBox = new();
-
-        if (createControl)
-        {
-            listBox.CreateControl();
-        }
-
-        listBox.Items.AddRange(new object[] { "1", "2", "3" });
-
-        for (int count = listBox.Items.Count; count > 1; count -= 1)
-        {
-            listBox.SelectedItem = listBox.Items[0];
-
-            Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-            Assert.Equal(0, listBox.SelectedIndex);
-            Assert.Equal(1, listBox.SelectedIndices.Count);
-            Assert.Equal(1, listBox.SelectedItems.Count);
-
-            listBox.Items.Remove(listBox.Items[0]);
-            count -= 1;
-
-            Assert.Equal(count, listBox.Items.Count);
-            Assert.Null(listBox.SelectedItem);
-            Assert.Equal(-1, listBox.SelectedIndex);
-            Assert.Equal(0, listBox.SelectedIndices.Count);
-            Assert.Equal(0, listBox.SelectedItems.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(SelectionMode.MultiSimple, true)]
-    [InlineData(SelectionMode.MultiSimple, false)]
-    [InlineData(SelectionMode.MultiExtended, true)]
-    [InlineData(SelectionMode.MultiExtended, false)]
-    public void ListBox_Remove_SelectedItems(SelectionMode mode, bool createControl)
-    {
-        using ListBox listBox = new() { SelectionMode = mode };
-
-        if (createControl)
-        {
-            listBox.CreateControl();
-        }
-
-        listBox.Items.AddRange(new object[] { "1", "2", "3" });
-
-        for (int count = listBox.Items.Count; count > 1; count -= 1)
-        {
-            listBox.SelectedItems.Add(listBox.Items[0]);
-
-            Assert.Equal(listBox.Items[0], listBox.SelectedItem);
-            Assert.Equal(0, listBox.SelectedIndex);
-            Assert.Equal(1, listBox.SelectedIndices.Count);
-            Assert.Equal(1, listBox.SelectedItems.Count);
-
-            listBox.Items.Remove(listBox.Items[0]);
-
-            count -= 1;
-
-            Assert.Equal(count, listBox.Items.Count);
-            Assert.Null(listBox.SelectedItem);
-            Assert.Equal(-1, listBox.SelectedIndex);
-            Assert.Equal(0, listBox.SelectedIndices.Count);
-            Assert.Equal(0, listBox.SelectedItems.Count);
-        }
-    }
-
-    private class SubListBox : ListBox
-    {
-        public new bool AllowSelection => base.AllowSelection;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new CurrencyManager DataManager => base.DataManager;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-#pragma warning disable 0618
-        public new void AddItemsCore(object[] value) => base.AddItemsCore(value);
-#pragma warning restore 0618
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ObjectCollection CreateItemCollection() => base.CreateItemCollection();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnChangeUICues(UICuesEventArgs e) => base.OnChangeUICues(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDataSourceChanged(EventArgs e) => base.OnDataSourceChanged(e);
-
-        public new void OnDisplayMemberChanged(EventArgs e) => base.OnDisplayMemberChanged(e);
-
-        public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMeasureItem(MeasureItemEventArgs e) => base.OnMeasureItem(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void OnSelectedIndexChanged(EventArgs e) => base.OnSelectedIndexChanged(e);
-
-        public new void OnSelectedValueChanged(EventArgs e) => base.OnSelectedValueChanged(e);
-
-        public new void RefreshItem(int index) => base.RefreshItem(index);
-
-        public new void RefreshItems() => base.RefreshItems();
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void ScaleControl(SizeF factor, BoundsSpecified specified) => base.ScaleControl(factor, specified);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetItemCore(int index, object value) => base.SetItemCore(index, value);
-
-        public new void SetItemsCore(IList value) => base.SetItemsCore(value);
-
-        public new void Sort() => base.Sort();
-
-        public new void WmReflectCommand(ref Message m) => base.WmReflectCommand(ref m);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class DataClass
-    {
-        public string Value { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlConvertEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlConvertEventArgsTests.cs
deleted file mode 100644
index 558ea95543d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlConvertEventArgsTests.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListControlConvertEventArgsTests
-{
-    [Theory]
-    [InlineData("value", typeof(int), 1)]
-    [InlineData(null, null, null)]
-    public void Ctor_Object_Type(object value, Type desiredType, object listItem)
-    {
-        var e = new ListControlConvertEventArgs(value, desiredType, listItem);
-        Assert.Equal(value, e.Value);
-        Assert.Equal(desiredType, e.DesiredType);
-        Assert.Equal(listItem, e.ListItem);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlTests.cs
deleted file mode 100644
index 6243cfaf101..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListControlTests.cs
+++ /dev/null
@@ -1,3079 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListControlTests
-{
-    [WinFormsFact]
-    public void ListControl_Ctor_Default()
-    {
-        using var control = new SubListControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.AllowSelectionEntry);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Null(control.DataManager);
-        Assert.Null(control.DataSource);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Null(control.FormatInfo);
-        Assert.Empty(control.FormatString);
-        Assert.False(control.FormattingEnabled);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(Size.Empty, control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Null(control.SelectedValue);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Empty(control.ValueMember);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubListControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BindingContext_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new BindingContext() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void ListControl_BindingContext_Set_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new SubListControl
-        {
-            BindingContext = value
-        };
-        Assert.Same(value, control.BindingContext);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void ListControl_BindingContext_SetWithNonNullBindingContext_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new SubListControl
-        {
-            BindingContext = new BindingContext()
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_BindingContext_SetWithDataSource_GetReturnsExpected()
-    {
-        var value = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            DataSource = dataSource
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_BindingContext_SetWithDataSourceAndDisplayMember_GetReturnsExpected()
-    {
-        var value = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            DataSource = dataSource,
-            DisplayMember = "Value"
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_BindingContext_SetWithDataSourceWithBindingContext_GetReturnsExpected()
-    {
-        var originalValue = new BindingContext();
-        var value = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = originalValue,
-            DataSource = dataSource
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_BindingContext_SetWithDataSourceAndDisplayMemberWithBindingContext_GetReturnsExpected()
-    {
-        var originalValue = new BindingContext();
-        var value = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = originalValue,
-            DataSource = dataSource,
-            DisplayMember = "Value"
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(value[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_BindingContext_SetWithHandler_CallsBindingContextChanged()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_ChangePosition_UpdatesSelectionIndex()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.DataManager.Position = 1;
-        Assert.Equal(1, control.SelectedIndex);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_ChangePositionDoesNotAllowSelection_DoesNotUpdateSelectionIndex()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new AllowSelectionFalseListControl
-        {
-            SelectedIndex = -2,
-            BindingContext = context,
-            DataSource = dataSource,
-        };
-
-        control.DataManager.Position = 1;
-        Assert.Equal(-2, control.SelectedIndex);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_SuspendResumeBinding_CallsSetItemsCore()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new SubListControl
-        {
-            SelectedIndex = -1,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        int callCount = 0;
-        control.SetItemsCoreHandler += (items) =>
-        {
-            Assert.Same(dataSource, items);
-            callCount++;
-        };
-
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(0, control.DataManager.Position);
-
-        // Suspending should call.
-        control.DataManager.SuspendBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Suspending again should be a nop.
-        control.DataManager.SuspendBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Resuming should call.
-        control.DataManager.ResumeBinding();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-
-        // Resuming again should be a nop.
-        control.DataManager.ResumeBinding();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-
-        // Should not call if the DataSource is changed.
-        control.DataSource = new List<DataClass>();
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_SuspendResumeBindingAfterDataManagerChanged_DoesNotCallSetItemsCore()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new SubListControl
-        {
-            SelectedIndex = -1,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        int callCount = 0;
-        control.SetItemsCoreHandler += (items) =>
-        {
-            Assert.Same(dataSource, items);
-            callCount++;
-        };
-
-        CurrencyManager dataManger = control.DataManager;
-        dataManger.SuspendBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the DataSource is changed.
-        control.DataSource = new List<DataClass>();
-        Assert.NotSame(dataManger, control.DataManager);
-        dataManger.ResumeBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_SuspendResumeBindingDoesNotAllowSelection_CallsSetItemsCore()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new AllowSelectionFalseListControl
-        {
-            SelectedIndex = -1,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        int callCount = 0;
-        control.SetItemsCoreHandler += (items) =>
-        {
-            Assert.Same(dataSource, items);
-            callCount++;
-        };
-
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(0, control.DataManager.Position);
-
-        // Suspending should call.
-        control.DataManager.SuspendBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Suspending again should be a nop.
-        control.DataManager.SuspendBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Resuming should call.
-        control.DataManager.ResumeBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-
-        // Resuming again should be a nop.
-        control.DataManager.ResumeBinding();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_CancelCurrentEdit_CallsSetItemCore()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new SubListControl
-        {
-            SelectedIndex = -1,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        int callCount = 0;
-        control.SetItemCoreHandler += (index, value) =>
-        {
-            Assert.Equal(0, index);
-            Assert.Same(dataSource[0], value);
-            callCount++;
-        };
-
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(0, control.DataManager.Position);
-
-        control.DataManager.CancelCurrentEdit();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataManager_CancelCurrentEditAfterDataManagerChanged_DoesNotCallSetItemCore()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass(), new DataClass() };
-        using var control = new SubListControl
-        {
-            SelectedIndex = -1,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        int callCount = 0;
-        control.SetItemCoreHandler += (index, value) =>
-        {
-            Assert.Equal(0, index);
-            Assert.Same(dataSource[0], value);
-            callCount++;
-        };
-
-        CurrencyManager dataManger = control.DataManager;
-        dataManger.CancelCurrentEdit();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-
-        // Should not call if the DataSource is changed.
-        control.DataSource = new List<DataClass>();
-        Assert.NotSame(dataManger, control.DataManager);
-        dataManger.CancelCurrentEdit();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> DataSource_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new List<int>() };
-        yield return new object[] { Array.Empty<int>() };
-
-        var mockSource = new Mock<IListSource>(MockBehavior.Strict);
-        mockSource
-            .Setup(s => s.GetList())
-            .Returns(new int[] { 1 });
-        yield return new object[] { mockSource.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_Set_GetReturnsExpected(object value)
-    {
-        using var control = new SubListControl
-        {
-            DataSource = value
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithDataSourceNoDisplayMember_GetReturnsExpected(object value)
-    {
-        using var control = new SubListControl
-        {
-            DataSource = new List<int>()
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithDisplayMember_GetReturnsExpected(object value)
-    {
-        using var control = new SubListControl
-        {
-            DisplayMember = "Capacity"
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Capacity", control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Capacity", control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithDataSourceNoSuchDisplayMemberAnymore_GetReturnsExpected(object value)
-    {
-        var originalValue = new List<int>();
-        using var control = new SubListControl
-        {
-            DataSource = originalValue,
-            DisplayMember = "Capacity"
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal(value is null ? string.Empty : "Capacity", control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal(value is null ? string.Empty : "Capacity", control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetComponent_DisposeValue_Removes()
-    {
-        var value = new ComponentList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.Dispose();
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetComponent_DisposeValueDifferentSender_Removes()
-    {
-        var value = new ComponentList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnDisposed(new object(), EventArgs.Empty);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetComponent_DisposeValueNullSender_Removes()
-    {
-        var value = new ComponentList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnDisposed(null, null);
-        Assert.Null(control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetOverridenComponent_DisposeValue_DoesNotRemove()
-    {
-        var originalValue = new ComponentList();
-        var value = new List<int>();
-        using var control = new SubListControl
-        {
-            DataSource = originalValue,
-            DisplayMember = "Count"
-        };
-        Assert.Same(originalValue, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        control.DataSource = value;
-        originalValue.Dispose();
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetSupportInitializeNotification_InitializeValueNotInitializedSetsInitialized_Success()
-    {
-        var value = new SupportInitializeNotificationList();
-        value.Initialized += (sender, e) =>
-        {
-            value.IsInitialized = true;
-        };
-
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnInitialized(value, EventArgs.Empty);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetSupportInitializeNotification_InitializeValueNotInitialized_Success()
-    {
-        var value = new SupportInitializeNotificationList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnInitialized(value, EventArgs.Empty);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetSupportInitializeNotification_InitializeValueInitialized_Success()
-    {
-        var value = new SupportInitializeNotificationList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnInitialized(value, EventArgs.Empty);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetSupportInitializeNotification_InitializeValueDifferentSender_Success()
-    {
-        var value = new SupportInitializeNotificationList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnInitialized(new object(), EventArgs.Empty);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetSupportInitializeNotification_InitializeValueNullSender_Succes()
-    {
-        var value = new SupportInitializeNotificationList();
-        using var control = new SubListControl
-        {
-            DataSource = value,
-            DisplayMember = "Count"
-        };
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        value.OnInitialized(null, null);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListControl_DataSource_SetOverridenSupportInitializeNotification_InitializeValue_Success(bool isInitialized)
-    {
-        var originalValue = new SupportInitializeNotificationList();
-        var value = new List<int>();
-        using var control = new SubListControl
-        {
-            DataSource = originalValue,
-            DisplayMember = "Count"
-        };
-        Assert.Same(originalValue, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-
-        originalValue.IsInitialized = isInitialized;
-        control.DataSource = value;
-        originalValue.OnInitialized(originalValue, EventArgs.Empty);
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Count", control.DisplayMember);
-        Assert.Null(control.DataManager);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithBindingContext_GetReturnsExpected(object value)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            BindingContext = context
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithBindingContextWithDataSource_GetReturnsExpected(object value)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = new List<int>()
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetWithBindingContextWithDisplayMemberCanCreate_GetReturnsExpected()
-    {
-        var context = new BindingContext();
-        var value = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DisplayMember = "Value"
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(context[value], control.DataManager);
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Same(context[value], control.DataManager);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DataSource_Set_TestData))]
-    public void ListControl_DataSource_SetWithBindingContextWithDisplayMemberCantCreate_GetReturnsExpected(object value)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DisplayMember = "NoSuchDisplayMember"
-        };
-
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal(value is null ? "NoSuchDisplayMember" : string.Empty, control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-
-        // Set same.
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Equal(value is null ? "NoSuchDisplayMember" : string.Empty, control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[value], control.DataManager);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetWithHandler_CallsDataSourceChanged()
-    {
-        using var control = new SubListControl();
-        int dataSourceCallCount = 0;
-        int displayMemberCallCount = 0;
-        EventHandler dataSourceHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            dataSourceCallCount++;
-        };
-        EventHandler displayMemberHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            displayMemberCallCount++;
-        };
-        control.DataSourceChanged += dataSourceHandler;
-        control.DisplayMemberChanged += displayMemberHandler;
-
-        // Set different.
-        var dataSource1 = new List<int>();
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(1, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set same.
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(1, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set different.
-        var dataSource2 = new List<int>();
-        control.DataSource = dataSource2;
-        Assert.Same(dataSource2, control.DataSource);
-        Assert.Equal(2, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Set null.
-        control.DataSource = null;
-        Assert.Null(control.DataSource);
-        Assert.Equal(3, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-
-        // Remove handler.
-        control.DataSourceChanged -= dataSourceHandler;
-        control.DisplayMemberChanged -= displayMemberHandler;
-        control.DataSource = dataSource1;
-        Assert.Same(dataSource1, control.DataSource);
-        Assert.Equal(3, dataSourceCallCount);
-        Assert.Equal(0, displayMemberCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetInsideDataSourceChanged_Nop()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            control.DataSource = Array.Empty<int>();
-            callCount++;
-        };
-        control.DataSourceChanged += handler;
-
-        var value = new List<int>();
-        control.DataSource = value;
-        Assert.Same(value, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DataSource_SetInvalid_ThrowsArgumentException()
-    {
-        using var control = new SubListControl();
-        Assert.Throws<ArgumentException>("value", () => control.DataSource = new object());
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_DisplayMember_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            DisplayMember = value
-        };
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_DataMember_SetWithDisplayMember_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            DisplayMember = "DataMember"
-        };
-
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ListControl_DisplayMember_SetWithDataSource_GetReturnsExpected(string value)
-    {
-        var dataSource = new List<int>();
-        using var control = new SubListControl
-        {
-            DataSource = dataSource
-        };
-
-        control.DisplayMember = value;
-        Assert.Equal(value, control.DisplayMember);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Equal(value, control.DisplayMember);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_DisplayMember_SetWithBindingContext_GetReturnsExpected(string value, string expected)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            BindingContext = context
-        };
-
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Null(control.DataSource);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ListControl_DisplayMember_SetWithBindingContextWithDataSource_GetReturnsExpected(string value)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<int>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.DisplayMember = value;
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Empty(control.DisplayMember);
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Value", "Value")]
-    [InlineData("value", "value")]
-    public void ListControl_DisplayMember_SetWithBindingContextWithDataSourceCanCreate_GetReturnsExpected(string value, string expected)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(dataSource, control.DataSource);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(dataSource, control.DataSource);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    [InlineData("ListValue")]
-    public void ListControl_DisplayMember_SetWithBindingContextWithDataSourceCantCreate_GetReturnsExpected(string value)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.DisplayMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[dataSource], control.DataManager);
-        }
-
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisplayMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Empty(control.DisplayMember);
-        if (value is null)
-        {
-            Assert.Null(control.DataManager);
-        }
-        else
-        {
-            Assert.Same(context[dataSource], control.DataManager);
-        }
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DisplayMember_SetWithHandler_CallsDisplayMemberChanged()
-    {
-        using var control = new SubListControl();
-        int displayMemberCallCount = 0;
-        int dataSourceCallCount = 0;
-        EventHandler displayMemberHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            displayMemberCallCount++;
-        };
-        EventHandler dataSourceHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            dataSourceCallCount++;
-        };
-        control.DisplayMemberChanged += displayMemberHandler;
-        control.DataSourceChanged += dataSourceHandler;
-
-        // Set different.
-        control.DisplayMember = "Value1";
-        Assert.Equal("Value1", control.DisplayMember);
-        Assert.Equal(1, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-
-        // Set same.
-        control.DisplayMember = "Value1";
-        Assert.Equal("Value1", control.DisplayMember);
-        Assert.Equal(1, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-
-        // Set different.
-        control.DisplayMember = "Value2";
-        Assert.Equal("Value2", control.DisplayMember);
-        Assert.Equal(2, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-
-        // Set null.
-        control.DisplayMember = null;
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(3, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-
-        // Set empty.
-        control.DisplayMember = string.Empty;
-        Assert.Empty(control.DisplayMember);
-        Assert.Equal(3, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-
-        // Remove handler.
-        control.DisplayMemberChanged -= displayMemberHandler;
-        control.DataSourceChanged -= dataSourceHandler;
-        control.DisplayMember = "Value1";
-        Assert.Equal("Value1", control.DisplayMember);
-        Assert.Equal(3, displayMemberCallCount);
-        Assert.Equal(0, dataSourceCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_DisplayMember_SetInsideDisplayMemberChanged_Nop()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            control.DisplayMember = "Value2";
-            callCount++;
-        };
-        control.DisplayMemberChanged += handler;
-
-        control.DisplayMember = "Value1";
-        Assert.Equal("Value1", control.DisplayMember);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_Format_AddRemove_CallsRefreshItems()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        control.RefreshItemsHandler = () => callCount++;
-        ListControlConvertEventHandler handler = (sender, e) => { };
-
-        // Add.
-        control.Format += handler;
-        Assert.Equal(1, callCount);
-
-        // Remove.
-        control.Format -= handler;
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> FormatInfo_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { CultureInfo.CurrentCulture };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FormatInfo_Set_TestData))]
-    public void ListControl_FormatInfo_Set_GetReturnsExpected(IFormatProvider value)
-    {
-        using var control = new SubListControl
-        {
-            FormatInfo = value
-        };
-        Assert.Same(value, control.FormatInfo);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormatInfo = value;
-        Assert.Same(value, control.FormatInfo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FormatInfo_Set_TestData))]
-    public void ListControl_FormatInfo_SetWithCustomOldValue_GetReturnsExpected(IFormatProvider value)
-    {
-        using var control = new SubListControl
-        {
-            FormatInfo = CultureInfo.InvariantCulture
-        };
-
-        control.FormatInfo = value;
-        Assert.Same(value, control.FormatInfo);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormatInfo = value;
-        Assert.Same(value, control.FormatInfo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormatInfo_Set_CallsRefreshItems()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        control.RefreshItemsHandler = () => callCount++;
-
-        // Set different.
-        control.FormatInfo = CultureInfo.CurrentCulture;
-        Assert.Equal(CultureInfo.CurrentCulture, control.FormatInfo);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormatInfo = CultureInfo.CurrentCulture;
-        Assert.Equal(CultureInfo.CurrentCulture, control.FormatInfo);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormatInfo = CultureInfo.InvariantCulture;
-        Assert.Equal(CultureInfo.InvariantCulture, control.FormatInfo);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.FormatInfo = null;
-        Assert.Null(control.FormatInfo);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormatInfo_SetWithHandler_CallsOnFormatInfoChanged()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FormatInfoChanged += handler;
-
-        // Set different.
-        control.FormatInfo = CultureInfo.CurrentCulture;
-        Assert.Equal(CultureInfo.CurrentCulture, control.FormatInfo);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormatInfo = CultureInfo.CurrentCulture;
-        Assert.Equal(CultureInfo.CurrentCulture, control.FormatInfo);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormatInfo = CultureInfo.InvariantCulture;
-        Assert.Equal(CultureInfo.InvariantCulture, control.FormatInfo);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.FormatInfo = null;
-        Assert.Null(control.FormatInfo);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FormatInfoChanged -= handler;
-        control.FormatInfo = CultureInfo.CurrentCulture;
-        Assert.Equal(CultureInfo.CurrentCulture, control.FormatInfo);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_FormatString_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            FormatString = value
-        };
-        Assert.Equal(expected, control.FormatString);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormatString = value;
-        Assert.Equal(expected, control.FormatString);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_FormatString_SetWithCustomOldValue_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            FormatString = "FormatString"
-        };
-
-        control.FormatString = value;
-        Assert.Equal(expected, control.FormatString);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormatString = value;
-        Assert.Equal(expected, control.FormatString);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormatString_Set_CallsRefreshItems()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        control.RefreshItemsHandler = () => callCount++;
-
-        // Set different.
-        control.FormatString = "Value1";
-        Assert.Equal("Value1", control.FormatString);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormatString = "Value1";
-        Assert.Equal("Value1", control.FormatString);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormatString = "Value2";
-        Assert.Equal("Value2", control.FormatString);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.FormatString = null;
-        Assert.Empty(control.FormatString);
-        Assert.Equal(3, callCount);
-
-        // Set empty.
-        control.FormatString = string.Empty;
-        Assert.Empty(control.FormatString);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormatString_SetWithHandler_CallsOnFormatStringChanged()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FormatStringChanged += handler;
-
-        // Set different.
-        control.FormatString = "Value1";
-        Assert.Equal("Value1", control.FormatString);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormatString = "Value1";
-        Assert.Equal("Value1", control.FormatString);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormatString = "Value2";
-        Assert.Equal("Value2", control.FormatString);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.FormatString = null;
-        Assert.Empty(control.FormatString);
-        Assert.Equal(3, callCount);
-
-        // Set empty.
-        control.FormatString = string.Empty;
-        Assert.Empty(control.FormatString);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FormatStringChanged -= handler;
-        control.FormatString = "Value1";
-        Assert.Equal("Value1", control.FormatString);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListControl_FormattingEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubListControl
-        {
-            FormattingEnabled = value
-        };
-        Assert.Equal(value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormattingEnabled = value;
-        Assert.Equal(value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.FormattingEnabled = !value;
-        Assert.Equal(!value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListControl_FormattingEnabled_SetWithFormattingEnabled_GetReturnsExpected(bool value)
-    {
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true
-        };
-
-        control.FormattingEnabled = value;
-        Assert.Equal(value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FormattingEnabled = value;
-        Assert.Equal(value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.FormattingEnabled = !value;
-        Assert.Equal(!value, control.FormattingEnabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormattingEnabled_Set_CallsRefreshItems()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        control.RefreshItemsHandler = () => callCount++;
-
-        // Set different.
-        control.FormattingEnabled = true;
-        Assert.True(control.FormattingEnabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormattingEnabled = true;
-        Assert.True(control.FormattingEnabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormattingEnabled = false;
-        Assert.False(control.FormattingEnabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_FormattingEnabled_SetWithHandler_CallsOnFormattingEnabledChanged()
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FormattingEnabledChanged += handler;
-
-        // Set different.
-        control.FormattingEnabled = true;
-        Assert.True(control.FormattingEnabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.FormattingEnabled = true;
-        Assert.True(control.FormattingEnabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.FormattingEnabled = false;
-        Assert.False(control.FormattingEnabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.FormattingEnabledChanged -= handler;
-        control.FormattingEnabled = true;
-        Assert.True(control.FormattingEnabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_ValueMember_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            ValueMember = value
-        };
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ValueMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_ValueMember_SetWithDisplayMember_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubListControl
-        {
-            DisplayMember = "DisplayMember"
-        };
-
-        control.ValueMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal("DisplayMember", control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ValueMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal("DisplayMember", control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListControl_ValueMember_SetWithBindingContext_GetReturnsExpected(string value, string expected)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            BindingContext = context
-        };
-
-        control.ValueMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ValueMember = value;
-        Assert.Null(control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Null(control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Value", "Value")]
-    [InlineData("value", "value")]
-    public void ListControl_ValueMember_SetWithBindingContextWithDataSourceCanCreate_GetReturnsExpected(string value, string expected)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.ValueMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ValueMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal(expected, control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_ValueMember_SetWithBindingContextWithDataSourceCantCreate_ThrowsArgumentException()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        Assert.Throws<ArgumentException>("newDisplayMember", (() => control.ValueMember = "NoSuchValue"));
-        Assert.Equal("NoSuchValue", control.DisplayMember);
-        Assert.Empty(control.ValueMember);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Value", "Value")]
-    [InlineData("value", "value")]
-    public void ListControl_ValueMember_SetWithBindingContextWithDataSourceWithDisplayMemberCanCreate_GetReturnsExpected(string value, string expected)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource,
-            DisplayMember = "OtherValue"
-        };
-
-        control.ValueMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("OtherValue", control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ValueMember = value;
-        Assert.Same(dataSource, control.DataSource);
-        Assert.Equal("OtherValue", control.DisplayMember);
-        Assert.Equal(expected, control.ValueMember);
-        Assert.Same(context[dataSource], control.DataManager);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_ValueMember_SetWithBindingContextWithDataSourceWithDisplayMemberCantCreate_ThrowsArgumentException()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            BindingContext = context,
-            DataSource = dataSource,
-            DisplayMember = "Value"
-        };
-
-        Assert.Throws<ArgumentException>("value", (() => control.ValueMember = "NoSuchValue"));
-        Assert.Equal("Value", control.DisplayMember);
-        Assert.Empty(control.ValueMember);
-    }
-
-    [WinFormsFact]
-    public void ListControl_ValueMember_SetWithHandler_CallsValueMemberChanged()
-    {
-        using var control = new SubListControl();
-        int valueMemberCallCount = 0;
-        int selectedValueCallCount = 0;
-        EventHandler valueMemberHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            valueMemberCallCount++;
-        };
-        EventHandler selectedValueHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(valueMemberCallCount > selectedValueCallCount);
-            selectedValueCallCount++;
-        };
-        control.ValueMemberChanged += valueMemberHandler;
-        control.SelectedValueChanged += selectedValueHandler;
-
-        // Set different.
-        control.ValueMember = "Value1";
-        Assert.Equal("Value1", control.ValueMember);
-        Assert.Equal(1, valueMemberCallCount);
-        Assert.Equal(1, selectedValueCallCount);
-
-        // Set same.
-        control.ValueMember = "Value1";
-        Assert.Equal("Value1", control.ValueMember);
-        Assert.Equal(1, valueMemberCallCount);
-        Assert.Equal(1, selectedValueCallCount);
-
-        // Set different.
-        control.ValueMember = "Value2";
-        Assert.Equal("Value2", control.ValueMember);
-        Assert.Equal(2, valueMemberCallCount);
-        Assert.Equal(2, selectedValueCallCount);
-
-        // Set null.
-        control.ValueMember = null;
-        Assert.Empty(control.ValueMember);
-        Assert.Equal(3, valueMemberCallCount);
-        Assert.Equal(3, selectedValueCallCount);
-
-        // Set empty.
-        control.ValueMember = string.Empty;
-        Assert.Empty(control.ValueMember);
-        Assert.Equal(3, valueMemberCallCount);
-        Assert.Equal(3, selectedValueCallCount);
-
-        // Remove handler.
-        control.ValueMemberChanged -= valueMemberHandler;
-        control.SelectedValueChanged -= selectedValueHandler;
-        control.ValueMember = "Value1";
-        Assert.Equal("Value1", control.ValueMember);
-        Assert.Equal(3, valueMemberCallCount);
-        Assert.Equal(3, selectedValueCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Value")]
-    [InlineData("value")]
-    public void ListControl_SelectedValue_SetWithMatchingValue_Success(string valueMember)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass { Value = "StringValue" } };
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            ValueMember = valueMember,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.SelectedValue = "StringValue";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("StringValue", control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedValue = "StringValue";
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal("StringValue", control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SelectedValue_NoMatchingValue_TestData()
-    {
-        yield return new object[] { new List<DataClass>(), "selected" };
-        yield return new object[] { new List<DataClass> { new DataClass { Value = "NoSuchValue" } }, string.Empty };
-        yield return new object[] { new List<DataClass> { new DataClass { Value = "NoSuchValue" } }, "selected" };
-        yield return new object[] { new List<DataClass> { new DataClass { Value = "NoSuchValue" } }, "nosuchvalue" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedValue_NoMatchingValue_TestData))]
-    public void ListControl_SelectedValue_SetWithNoMatchingValue_Success(object dataSource, string value)
-    {
-        var context = new BindingContext();
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            ValueMember = "Value",
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.SelectedValue = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedValue = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListControl_SelectedValue_SetWithChangedDataManager_Success()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            ValueMember = "ValueMember",
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        control.SelectedValue = "selected";
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedValue = "selected";
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    public void ListControl_SelectedValue_SetWithoutDataManager_GetReturnsNull(object value)
-    {
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            SelectedValue = value
-        };
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-
-        // Not set even when given a DataManager.
-        control.BindingContext = new BindingContext();
-        control.DataSource = new List<int>();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Throws<IndexOutOfRangeException>(() => control.SelectedValue);
-    }
-
-    [WinFormsFact]
-    public void ListControl_SelectedValue_SetWithHandler_DoesNotCallSelectedValueChanged()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass> { new DataClass { Value = "StringValue" } };
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            ValueMember = "Value",
-            BindingContext = context,
-            DataSource = dataSource
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.SelectedValueChanged += handler;
-
-        // Set different.
-        control.SelectedValue = "StringValue";
-        Assert.Equal("StringValue", control.SelectedValue);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.SelectedValue = "StringValue";
-        Assert.Equal("StringValue", control.SelectedValue);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.SelectedValueChanged -= handler;
-        control.SelectedValue = "StringValue";
-        Assert.Equal("StringValue", control.SelectedValue);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_SelectedValue_SetNull_ThrowsArgumentNullException()
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            BindingContext = context,
-            DataSource = dataSource,
-            ValueMember = "Value"
-        };
-        Assert.Throws<ArgumentNullException>("key", () => control.SelectedValue = null);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedValue);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData(1)]
-    public void ListControl_SelectedValue_SetWithoutValueMember_ThrowsInvalidOperationException(object value)
-    {
-        var context = new BindingContext();
-        var dataSource = new List<DataClass>();
-        using var control = new SubListControl
-        {
-            SelectedIndex = 0,
-            BindingContext = context,
-            DataSource = dataSource
-        };
-        Assert.Throws<InvalidOperationException>(() => control.SelectedValue = value);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Throws<IndexOutOfRangeException>(() => control.SelectedValue);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Alt, false)]
-    [InlineData(Keys.Alt | Keys.PageUp, false)]
-    [InlineData(Keys.PageUp, true)]
-    [InlineData(Keys.PageDown, true)]
-    [InlineData(Keys.Home, true)]
-    [InlineData(Keys.End, true)]
-    [InlineData(Keys.A, false)]
-    public void IsInputKey_Invoke_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubListControl();
-        Assert.Equal(expected, control.IsInputKey(keyData));
-    }
-
-    public static IEnumerable<object[]> FilterItemOnProperty_TestData()
-    {
-        yield return new object[]
-        {
-            new SubListControl(),
-            null,
-            null
-        };
-
-        var item = new object();
-        yield return new object[]
-        {
-            new SubListControl(),
-            item,
-            item
-        };
-
-        yield return new object[]
-        {
-            new SubListControl { DisplayMember = "Length" },
-            "abc",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl { DisplayMember = "length" },
-            "abc",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl { DisplayMember = "Path.Length" },
-            "abc",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl { DisplayMember = "NoSuchProperty" },
-            "abc",
-            "abc"
-        };
-
-        var dataClass = new DataClass { Value = 10 };
-        var list = new List<DataClass> { dataClass };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                DataSource = list
-            },
-            list,
-            list
-        };
-
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            list,
-            list
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list,
-                DisplayMember = "Value"
-            },
-            list,
-            list
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list,
-                DisplayMember = "Value"
-            },
-            dataClass,
-            10
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list,
-                DisplayMember = "value"
-            },
-            dataClass,
-            10
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list,
-                DisplayMember = "NoSuchProperty"
-            },
-            dataClass,
-            dataClass
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FilterItemOnProperty_TestData))]
-    public void ListControl_FilterItemOnProperty_Invoke_ReturnsExpected(SubListControl control, object item, object expected)
-    {
-        Assert.Equal(expected, control.FilterItemOnProperty(item));
-    }
-
-    public static IEnumerable<object[]> FilterItemOnProperty_String_TestData()
-    {
-        yield return new object[]
-        {
-            new SubListControl(),
-            null,
-            "Field",
-            null
-        };
-
-        var item = new object();
-        yield return new object[]
-        {
-            new SubListControl(),
-            item,
-            null,
-            item
-        };
-        yield return new object[]
-        {
-            new SubListControl(),
-            item,
-            string.Empty,
-            item
-        };
-
-        yield return new object[]
-        {
-            new SubListControl(),
-            "abc",
-            "Length",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl(),
-            "abc",
-            "length",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl(),
-            "abc",
-            "NoSuchProperty",
-            "abc"
-        };
-
-        var dataClass = new DataClass { Value = 10 };
-        var list = new List<DataClass> { dataClass };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            list,
-            "NoSuchField",
-            list
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            list,
-            "Value",
-            list
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            dataClass,
-            "Value",
-            10
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            dataClass,
-            "value",
-            10
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                BindingContext = new BindingContext(),
-                DataSource = list
-            },
-            dataClass,
-            "NoSuchProperty",
-            dataClass
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FilterItemOnProperty_String_TestData))]
-    public void ListControl_FilterItemOnProperty_InvokeString_ReturnsExpected(SubListControl control, object item, string field, object expected)
-    {
-        Assert.Equal(expected, control.FilterItemOnProperty(item, field));
-    }
-
-    public static IEnumerable<object[]> GetItemText_TestData()
-    {
-        yield return new object[]
-        {
-            new SubListControl(), null, string.Empty
-        };
-        yield return new object[]
-        {
-            new SubListControl(),
-            "abc",
-            "abc"
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                DisplayMember = "Length"
-            },
-            "abc",
-            3
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                DisplayMember = "Value"
-            },
-            new DataClass { Value = 1 },
-            "1"
-        };
-        yield return new object[]
-        {
-            new SubListControl
-            {
-                DisplayMember = "Value"
-            },
-            new DataClass { Value = null },
-            string.Empty
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemText_TestData))]
-    public void ListControl_GetItemText_Invoke_ReturnsExpected(ListControl control, object item, string expected)
-    {
-        Assert.Equal(expected, control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Equal(expected, control.GetItemText(item));
-    }
-
-    public static IEnumerable<object[]> GetItemText_HasHandler_TestData()
-    {
-        var item = new DataClass { Value = 3 };
-        yield return new object[] { item, null, "3" };
-        yield return new object[] { item, new object(), "3" };
-        yield return new object[] { item, item, "3" };
-        yield return new object[] { item, "custom", "custom" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemText_HasHandler_TestData))]
-    public void ListControl_GetItemText_HasHandler_CallsFormat(object item, object value, object expected)
-    {
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true,
-            DisplayMember = "Value"
-        };
-
-        // Handler.
-        int callCount = 0;
-        ListControlConvertEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(3, e.Value);
-            Assert.Equal(typeof(string), e.DesiredType);
-            Assert.Same(item, e.ListItem);
-
-            e.Value = value;
-            callCount++;
-        };
-
-        control.Format += handler;
-        Assert.Equal(expected, control.GetItemText(item));
-        Assert.Equal(1, callCount);
-
-        // Should not call if the handler is removed.
-        control.Format -= handler;
-        Assert.Equal("3", control.GetItemText(item));
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> GetItemText_HasHandlerFormattingDisabled_TestData()
-    {
-        var item = new DataClass { Value = 3 };
-        yield return new object[] { item, null };
-        yield return new object[] { item, new object() };
-        yield return new object[] { item, item };
-        yield return new object[] { item, "custom" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemText_HasHandlerFormattingDisabled_TestData))]
-    public void ListControl_GetItemText_HasHandlerFormattingDisabled_DoesNotCallFormat(object item, object value)
-    {
-        using var control = new SubListControl
-        {
-            FormattingEnabled = false,
-            DisplayMember = "Value"
-        };
-
-        // Handler.
-        int callCount = 0;
-        ListControlConvertEventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(3, e.Value);
-            Assert.Equal(typeof(string), e.DesiredType);
-            Assert.Same(item, e.ListItem);
-
-            e.Value = value;
-            callCount++;
-        };
-
-        control.Format += handler;
-        Assert.Equal("3", control.GetItemText(item));
-        Assert.Equal(0, callCount);
-
-        // Should not call if the handler is removed.
-        control.Format -= handler;
-        Assert.Equal("3", control.GetItemText(item));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetItemText_CustomConverter_ReturnsExpected()
-    {
-        var item = new CustomTypeConverterDataClass { Value = 10 };
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true,
-            BindingContext = new BindingContext(),
-            DataSource = new List<CustomTypeConverterDataClass> { item },
-            DisplayMember = "Value"
-        };
-        Assert.Equal("custom", control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Equal("custom", control.GetItemText(item));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetItemText_CustomConverterFormattingDisabled_ReturnsExpected()
-    {
-        var item = new CustomTypeConverterDataClass { Value = 10 };
-        using var control = new SubListControl
-        {
-            FormattingEnabled = false,
-            BindingContext = new BindingContext(),
-            DataSource = new List<CustomTypeConverterDataClass> { item },
-            DisplayMember = "Value"
-        };
-        Assert.Equal("10", control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Equal("10", control.GetItemText(item));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetItemText_CustomConverterNoContext_ReturnsExpected()
-    {
-        var item = new CustomTypeConverterDataClass { Value = 10 };
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true,
-            DataSource = new List<CustomTypeConverterDataClass> { item },
-            DisplayMember = "Value"
-        };
-        Assert.Equal("10", control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Equal("10", control.GetItemText(item));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetItemText_NonCriticalThrowingExceptionType_ReturnsExpected()
-    {
-        var item = new NonCriticalThrowingTypeConverterDataClass();
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true,
-            BindingContext = new BindingContext(),
-            DataSource = new List<NonCriticalThrowingTypeConverterDataClass> { item },
-            DisplayMember = "Value"
-        };
-        Assert.Equal("NonCriticalThrowingTypeConverterDataClassToString", control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Equal("NonCriticalThrowingTypeConverterDataClassToString", control.GetItemText(item));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetItemText_CriticalThrowingExceptionType_RethrowsException()
-    {
-        var item = new CriticalThrowingTypeConverterDataClass();
-        using var control = new SubListControl
-        {
-            FormattingEnabled = true,
-            BindingContext = new BindingContext(),
-            DataSource = new List<CriticalThrowingTypeConverterDataClass> { item },
-            DisplayMember = "Value"
-        };
-        Assert.Throws<StackOverflowException>(() => control.GetItemText(item));
-
-        // Test caching behaviour.
-        Assert.Throws<StackOverflowException>(() => control.GetItemText(item));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ListControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubListControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ListControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnBindingContextChanged_Invoke_CallsBindingContextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BindingContextChanged += handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.OnBindingContextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnDataSourceChanged_Invoke_CallsDataSourceChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DataSourceChanged += handler;
-        control.OnDataSourceChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DataSourceChanged -= handler;
-        control.OnDataSourceChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnDisplayMemberChanged_Invoke_CallsDisplayMemberChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DisplayMemberChanged += handler;
-        control.OnDisplayMemberChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DisplayMemberChanged -= handler;
-        control.OnDisplayMemberChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnFormat_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListControlConvertEventArgs(null, null, null) };
-        yield return new object[] { new ListControlConvertEventArgs(new object(), typeof(int), new object()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFormat_TestData))]
-    public void ListControl_OnFormat_Invoke_CallsFormat(ListControlConvertEventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        ListControlConvertEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Format += handler;
-        control.OnFormat(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Format -= handler;
-        control.OnFormat(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnFormatInfoChanged_Invoke_CallsFormatInfoChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FormatInfoChanged += handler;
-        control.OnFormatInfoChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FormatInfoChanged -= handler;
-        control.OnFormatInfoChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnFormatStringChanged_Invoke_CallsFormatStringChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FormatStringChanged += handler;
-        control.OnFormatStringChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FormatStringChanged -= handler;
-        control.OnFormatStringChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnFormattingEnabledChanged_Invoke_CallsFormattingEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FormattingEnabledChanged += handler;
-        control.OnFormattingEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FormattingEnabledChanged -= handler;
-        control.OnFormattingEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnSelectedIndexChanged_Invoke_CallsSelectedValueChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedValueChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SelectedValueChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnSelectedValueChanged_Invoke_CallsSelectedValueChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectedValueChanged += handler;
-        control.OnSelectedValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SelectedValueChanged -= handler;
-        control.OnSelectedValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ListControl_OnValueMemberChanged_Invoke_CallsValueMemberChanged(EventArgs eventArgs)
-    {
-        using var control = new SubListControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ValueMemberChanged += handler;
-        control.OnValueMemberChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ValueMemberChanged -= handler;
-        control.OnValueMemberChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ListControl_RefreshItems_Invoke_Nop()
-    {
-        using var control = new SubListControl();
-        control.RefreshItemsEntry();
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, null)]
-    [InlineData(-1, 1)]
-    public void ListControl_SetItemCore_Invoke_Nop(int index, object value)
-    {
-        using var control = new SubListControl();
-        control.SetItemCoreEntry(index, value);
-    }
-
-    private class DataClass
-    {
-        public object Value { get; set; }
-        public object OtherValue { get; set; }
-        public IList ListValue { get; set; }
-
-        public override string ToString() => "DataClassToString";
-    }
-
-    private class ComponentList : List<int>, IComponent
-    {
-        public ISite Site { get; set; }
-
-        public event EventHandler Disposed;
-
-        public void Dispose() => OnDisposed(this, EventArgs.Empty);
-
-        public void OnDisposed(object sender, EventArgs e)
-        {
-            Disposed?.Invoke(sender, e);
-        }
-    }
-
-    private class SupportInitializeNotificationList : List<int>, ISupportInitializeNotification
-    {
-        public bool IsInitialized { get; set; }
-
-        public event EventHandler Initialized;
-
-        public void BeginInit()
-        {
-        }
-
-        public void EndInit()
-        {
-        }
-
-        public void OnInitialized(object sender, EventArgs e)
-        {
-            Initialized?.Invoke(sender, e);
-        }
-    }
-
-    public class SubListControl : ListControl
-    {
-        public override int SelectedIndex { get; set; }
-
-        public bool AllowSelectionEntry => base.AllowSelection;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new CurrencyManager DataManager => base.DataManager;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new object FilterItemOnProperty(object item) => base.FilterItemOnProperty(item);
-
-        public new object FilterItemOnProperty(object item, string field) => base.FilterItemOnProperty(item, field);
-
-        public new void OnBindingContextChanged(EventArgs e) => base.OnBindingContextChanged(e);
-
-        public new void OnDataSourceChanged(EventArgs e) => base.OnDataSourceChanged(e);
-
-        public new void OnDisplayMemberChanged(EventArgs e) => base.OnDisplayMemberChanged(e);
-
-        public new void OnFormat(ListControlConvertEventArgs e) => base.OnFormat(e);
-
-        public new void OnFormatInfoChanged(EventArgs e) => base.OnFormatInfoChanged(e);
-
-        public new void OnFormatStringChanged(EventArgs e) => base.OnFormatStringChanged(e);
-
-        public new void OnFormattingEnabledChanged(EventArgs e) => base.OnFormattingEnabledChanged(e);
-
-        public new void OnSelectedIndexChanged(EventArgs e) => base.OnSelectedIndexChanged(e);
-
-        public new void OnSelectedValueChanged(EventArgs e) => base.OnSelectedValueChanged(e);
-
-        public new void OnValueMemberChanged(EventArgs e) => base.OnValueMemberChanged(e);
-
-        public Action RefreshItemsHandler { get; set; }
-
-        public void RefreshItemsEntry() => RefreshItems();
-
-        protected override void RefreshItem(int index)
-        {
-        }
-
-        protected override void RefreshItems()
-        {
-            RefreshItemsHandler?.Invoke();
-            base.RefreshItems();
-        }
-
-        public Action<int, object> SetItemCoreHandler { get; set; }
-
-        public void SetItemCoreEntry(int index, object value) => base.SetItemCore(index, value);
-
-        protected override void SetItemCore(int index, object value)
-        {
-            SetItemCoreHandler?.Invoke(index, value);
-        }
-
-        public Action<IList> SetItemsCoreHandler { get; set; }
-
-        protected override void SetItemsCore(IList items)
-        {
-            SetItemsCoreHandler?.Invoke(items);
-        }
-    }
-
-    public class AllowSelectionFalseListControl : SubListControl
-    {
-        protected override bool AllowSelection => false;
-    }
-
-    public class CustomTypeConverterDataClass
-    {
-        [TypeConverter(typeof(CustomTypeConverter))]
-        public int Value { get; set; }
-
-        public override string ToString() => "CustomTypeConverterDataClassToString";
-    }
-
-    private class CustomTypeConverter : TypeConverter
-    {
-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-        {
-            Assert.Equal(10, value);
-            Assert.Equal(typeof(string), destinationType);
-            return "custom";
-        }
-    }
-
-    public class NonCriticalThrowingTypeConverterDataClass
-    {
-        [TypeConverter(typeof(NonCriticalThrowingTypeConverter))]
-        public int Value { get; set; }
-
-        public override string ToString() => "NonCriticalThrowingTypeConverterDataClassToString";
-    }
-
-    private class NonCriticalThrowingTypeConverter : TypeConverter
-    {
-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-        {
-            throw new InvalidOperationException();
-        }
-    }
-
-    public class CriticalThrowingTypeConverterDataClass
-    {
-        [TypeConverter(typeof(CriticalThrowingTypeConverter))]
-        public int Value { get; set; }
-    }
-
-    private class CriticalThrowingTypeConverter : TypeConverter
-    {
-        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
-        {
-            throw new StackOverflowException();
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListVIew.ListViewAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListVIew.ListViewAccessibleObjectTests.cs
deleted file mode 100644
index 52ab87cba39..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListVIew.ListViewAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1761 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.ListViewGroup;
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_ListViewAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewAccessibleObject_Ctor_Default()
-    {
-        using ListView listView = new ListView();
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.NotNull(accessibleObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_EmptyList_GetChildCount_ReturnsCorrectValue()
-    {
-        using ListView listView = new ListView();
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(-1, accessibleObject.GetChildCount()); // listView doesn't have items
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.List)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ListViewAccessibleObject_DefaultRole_ReturnsCorrectValue(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using ListView listView = new ListView();
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(expectedAccessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_GetMultiViewProviderCurrentView_ReturnsCorrectValue()
-    {
-        using ListView listView = new ListView();
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal((int)listView.View, accessibleObject.GetMultiViewProviderCurrentView());
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_GetMultiViewProviderSupportedViews_ReturnsExpected()
-    {
-        using ListView listView = new ListView();
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(new int[] { (int)View.Details }, accessibleObject.GetMultiViewProviderSupportedViews());
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_GetMultiViewProviderViewName_ReturnsCorrectValue()
-    {
-        using ListView listView = new ListView();
-        listView.View = View.Details;
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(((int)(listView.View)).ToString(), accessibleObject.GetMultiViewProviderViewName((int)View.Details));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_ListWithTwoGroups_FragmentNavigateWorkCorrectly_IfHandleIsCreated_VisualStylesEnabled()
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new ListView();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem());
-        ListViewItem item = new ListViewItem();
-        ListViewItem item2 = new ListViewItem();
-        ListViewGroup group = new ListViewGroup();
-        item2.Group = group;
-        item.Group = group;
-        listView.Groups.Add(group);
-        listView.Items.Add(item);
-        listView.Items.Add(item2);
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        AccessibleObject firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-        AccessibleObject lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        Assert.IsType<ListViewGroupAccessibleObject>(firstChild);
-        Assert.IsType<ListViewGroupAccessibleObject>(lastChild);
-        Assert.NotEqual(firstChild, lastChild);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_ListWithTwoGroups_FragmentNavigateWorkCorrectly_IfHandleIsCreated_VisualStylesDisabled()
-    {
-        if (Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new ListView();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem());
-        ListViewItem item = new ListViewItem();
-        ListViewItem item2 = new ListViewItem();
-        ListViewGroup group = new ListViewGroup();
-        item2.Group = group;
-        item.Group = group;
-        listView.Groups.Add(group);
-        listView.Items.Add(item);
-        listView.Items.Add(item2);
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        AccessibleObject firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-        AccessibleObject lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        Assert.IsAssignableFrom<ListViewItemBaseAccessibleObject>(firstChild);
-        Assert.IsAssignableFrom<ListViewItemBaseAccessibleObject>(lastChild);
-        Assert.NotEqual(firstChild, lastChild);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_ListWithTwoGroups_FragmentNavigateWorkCorrectly_IfHandleIsNotCreated()
-    {
-        using ListView listView = new ListView();
-        listView.Items.Add(new ListViewItem());
-        ListViewItem item = new ListViewItem();
-        ListViewItem item2 = new ListViewItem();
-        ListViewGroup group = new ListViewGroup();
-        item2.Group = group;
-        item.Group = group;
-        listView.Groups.Add(group);
-        listView.Items.Add(item);
-        listView.Items.Add(item2);
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        AccessibleObject firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-        AccessibleObject lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        Assert.Null(firstChild);
-        Assert.Null(lastChild);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_ListWithTwoItems_FragmentNavigateWorkCorrectly_IfHandleIsCreated()
-    {
-        using ListView listView = new ListView();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem());
-        listView.Items.Add(new ListViewItem());
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        AccessibleObject firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-        AccessibleObject lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        Assert.IsAssignableFrom<ListViewItemBaseAccessibleObject>(firstChild);
-        Assert.IsAssignableFrom<ListViewItemBaseAccessibleObject>(lastChild);
-        Assert.NotEqual(firstChild, lastChild);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_ListWithTwoItems_FragmentNavigateWorkCorrectly_IfHandleIsNotCreated()
-    {
-        using ListView listView = new ListView();
-        listView.Items.Add(new ListViewItem());
-        listView.Items.Add(new ListViewItem());
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        AccessibleObject firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild) as AccessibleObject;
-        AccessibleObject lastChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild) as AccessibleObject;
-        Assert.Null(firstChild);
-        Assert.Null(lastChild);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_EmptyList_GetChild_ReturnsCorrectValue()
-    {
-        using ListView listView = new ListView();
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(-1, accessibleObject.GetChildCount()); // listView doesn't have items
-        Assert.Null(accessibleObject.GetChild(0)); // GetChild method should not throw an exception
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_GetPropertyValue_returns_correct_values()
-    {
-        using var list = new ListView();
-        list.Name = "List";
-        list.AccessibleName = "ListView";
-        AccessibleObject listAccessibleObject = list.AccessibilityObject;
-
-        object accessibleName = listAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-        Assert.Equal("ListView", accessibleName);
-
-        object automationId = listAccessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-        Assert.Equal("List", automationId);
-
-        object accessibleControlType = listAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        Assert.Equal(UiaCore.UIA.ListControlTypeId, accessibleControlType); // If AccessibleRole is Default
-
-        object controlType = listAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = UiaCore.UIA.ListControlTypeId;
-        Assert.Equal(expected, controlType);
-
-        Assert.True((bool)listAccessibleObject.GetPropertyValue(UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId));
-        Assert.False(list.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_OwnerHasDefaultGroup_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in Virtual mode
-                if (view == View.Tile && virtualMode)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        foreach (bool createDefaultGroup in new[] { true, false })
-                        {
-                            yield return new object[] { view, virtualMode, showGroups, createHandle, createDefaultGroup };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_OwnerHasDefaultGroup_ReturnsExpected(View view, bool virtualMode, bool showGroups, bool createHandle, bool createDefaultGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 2,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-
-        if (!virtualMode)
-        {
-            ListViewGroup listViewGroup = new("Test Group");
-            listView.Groups.Add(listViewGroup);
-            listViewItem1.Group = listViewGroup;
-            listViewItem2.Group = createDefaultGroup ? null : listViewGroup;
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        bool expected = listView.GroupsDisplayed && createDefaultGroup;
-        bool actual = ((ListView.ListViewAccessibleObject)listView.AccessibilityObject).OwnerHasDefaultGroup;
-
-        Assert.Equal(expected, actual);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_OwnerHasDefaultGroup_WithoutItems_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in Virtual mode
-                if (view == View.Tile && virtualMode)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        yield return new object[] { view, virtualMode, showGroups, createHandle };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_WithoutItems_TestData))]
-    public void ListViewAccessibleObject_OwnerHasDefaultGroup_ReturnsExpected_WithoutItems(View view, bool virtualMode, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 0,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        if (!virtualMode)
-        {
-            ListViewGroup listViewGroup = new("Test Group");
-            listView.Groups.Add(listViewGroup);
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    _ => throw new NotImplementedException()
-                };
-            };
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        bool actual = ((ListView.ListViewAccessibleObject)listView.AccessibilityObject).OwnerHasDefaultGroup;
-
-        Assert.False(actual);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildCount_ReturnsExpected(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group"));
-            listViewItem2.Group = listView.Groups[0];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        int expected = createHandle
-            ? listView.GroupsDisplayed ? 2 : 3
-            : -1;
-
-        Assert.Equal(expected, listView.AccessibilityObject.GetChildCount());
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildCount_ReturnsExpected_WithoutItems(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 0,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group"));
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    _ => throw new NotImplementedException()
-                };
-            };
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Equal(createHandle ? 0 : -1, listView.AccessibilityObject.GetChildCount());
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_GetChild_DefaultGroup_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in Virtual mode
-                if (view == View.Tile && virtualMode)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createDefaultGroup in new[] { true, false })
-                    {
-                        yield return new object[] { view, virtualMode, showGroups, createDefaultGroup };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_DefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsExpected_IfHandleCreated(View view, bool virtualMode, bool showGroups, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group"));
-            listViewItem2.Group = listView.Groups[0];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-
-        if (listView.GroupsDisplayed)
-        {
-            Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject.GetChild(0));
-            Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject.GetChild(1));
-            Assert.Null(accessibleObject.GetChild(2));
-        }
-        else
-        {
-            Assert.Equal(listViewItem1.AccessibilityObject, accessibleObject.GetChild(0));
-            Assert.Equal(listViewItem2.AccessibilityObject, accessibleObject.GetChild(1));
-            Assert.Equal(listViewItem3.AccessibilityObject, accessibleObject.GetChild(2));
-            Assert.Null(accessibleObject.GetChild(3));
-        }
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_DefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsExpected_IfHandleNotCreated(View view, bool virtualMode, bool showGroups, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group"));
-            listViewItem2.Group = listView.Groups[0];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        Assert.Null(listView.AccessibilityObject.GetChild(-1));
-        Assert.Null(listView.AccessibilityObject.GetChild(0));
-        Assert.Null(listView.AccessibilityObject.GetChild(1));
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildIndex_ReturnsExpected_WithDefaultGroup(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group 1"));
-            listView.Groups.Add(new ListViewGroup("Test Group 2"));
-            listViewItem2.Group = listView.Groups[0];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        if (listView.GroupsDisplayed)
-        {
-            Assert.Equal(0, accessibleObject.GetChildIndex(listView.DefaultGroup.AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Groups[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Groups[1].AccessibilityObject));
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[2].AccessibilityObject));
-        }
-        else
-        {
-            Assert.Equal(0, accessibleObject.GetChildIndex(listView.Items[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[1].AccessibilityObject));
-            Assert.Equal(2, accessibleObject.GetChildIndex(listView.Items[2].AccessibilityObject));
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.DefaultGroup.AccessibilityObject));
-        }
-
-        Assert.Equal(-1, accessibleObject.GetChildIndex(new AccessibleObject()));
-
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildIndex_ReturnsExpected_WithoutDefaultGroup(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group 1"));
-            listView.Groups.Add(new ListViewGroup("Test Group 2"));
-            listViewItem1.Group = listView.Groups[0];
-            listViewItem2.Group = listView.Groups[0];
-            listViewItem3.Group = listView.Groups[1];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        if (listView.GroupsDisplayed)
-        {
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.DefaultGroup.AccessibilityObject));
-            Assert.Equal(0, accessibleObject.GetChildIndex(listView.Groups[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Groups[1].AccessibilityObject));
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[2].AccessibilityObject));
-        }
-        else
-        {
-            Assert.Equal(0, accessibleObject.GetChildIndex(listView.Items[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[1].AccessibilityObject));
-            Assert.Equal(2, accessibleObject.GetChildIndex(listView.Items[2].AccessibilityObject));
-
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.DefaultGroup.AccessibilityObject));
-        }
-
-        Assert.Equal(-1, accessibleObject.GetChildIndex(new AccessibleObject()));
-
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildIndex_ReturnsExpected_WithoutVisibleItems(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 0,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group 1"));
-            listView.Groups[0].Items.Add(new ListViewItem());
-            listView.Groups.Add(new ListViewGroup("Test Group 2"));
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    _ => throw new NotImplementedException()
-                };
-            };
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        if (listView.GroupsDisplayed)
-        {
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.DefaultGroup.AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Groups[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Groups[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Groups[0].Items[0].AccessibilityObject));
-        }
-
-        Assert.Equal(-1, accessibleObject.GetChildIndex(new AccessibleObject()));
-
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_OwnerHasDefaultGroup_TestData))]
-    public void ListViewAccessibleObject_GetChildIndex_ReturnsMinusOne_IfChildIsNull(View view, bool virtualMode, bool showGroups, bool createHandle, bool createGroup)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 3,
-            VirtualMode = virtualMode
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new("Test item 1");
-        ListViewItem listViewItem2 = new("Test item 2");
-        ListViewItem listViewItem3 = new("Test item 3");
-
-        if (!virtualMode && createGroup)
-        {
-            listView.Groups.Add(new ListViewGroup("Test Group 1"));
-            listView.Groups.Add(new ListViewGroup("Test Group 2"));
-            listViewItem2.Group = listView.Groups[0];
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    2 => listViewItem3,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Equal(-1, listView.AccessibilityObject.GetChildIndex(null));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_GetSelectionInvoke_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                yield return new object[] { view, showGroups };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_ReturnsExpected(View view, bool showGroups)
-    {
-        using var listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups
-        };
-
-        listView.CreateControl();
-
-        ListViewGroup listGroup1 = new ListViewGroup("Group1");
-        ListViewGroup listGroup2 = new ListViewGroup("Group2");
-        ListViewGroup listGroup3 = new ListViewGroup("Group2");
-        ListViewItem listItem1 = new ListViewItem(listGroup1);
-        ListViewItem listItem2 = new ListViewItem();
-        ListViewItem listItem3 = new ListViewItem(listGroup2);
-        ListViewItem listItem4 = new ListViewItem(listGroup2);
-        listView.Groups.Add(listGroup1);
-        listView.Groups.Add(listGroup2);
-        listView.Items.Add(listItem1);
-        listView.Items.Add(listItem2);
-        listView.Items.Add(listItem3);
-        listView.Items.Add(listItem4);
-
-        listView.Items[0].Selected = true;
-        listView.Items[1].Selected = true;
-        listView.Items[3].Selected = true;
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(listItem1.AccessibilityObject, listSelection[0]);
-        Assert.Equal(listItem2.AccessibilityObject, listSelection[1]);
-        Assert.Equal(listItem4.AccessibilityObject, listSelection[2]);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_WithoutSelectedItems_ReturnsExpected(View view, bool showGroups)
-    {
-        using var listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups
-        };
-
-        listView.CreateControl();
-        ListViewItem listItem1 = new ListViewItem();
-        listView.Items.Add(listItem1);
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(0, listSelection.Length);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_ReturnsExpected_IfHandleNotCreated(View view, bool showGroups)
-    {
-        using var listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups
-        };
-
-        ListViewItem listItem1 = new ListViewItem();
-        listView.Items.Add(listItem1);
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(0, listSelection.Length);
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in Virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                yield return new object[] { view, showGroups };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_ReturnsExpected(View view, bool showGroups)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups,
-            VirtualListSize = 4
-        };
-
-        ListViewItem listItem1 = new ListViewItem(new string[] { "Item 1", "Item A" }, -1);
-        ListViewItem listItem2 = new ListViewItem("Group item 2");
-        ListViewItem listItem3 = new ListViewItem("Item 3");
-        ListViewItem listItem4 = new ListViewItem(new string[] { "Item 4", "Item B" }, -1);
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                1 => listItem2,
-                2 => listItem3,
-                3 => listItem4,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listView.CreateControl();
-        listItem1.SetItemIndex(listView, 0);
-        listItem2.SetItemIndex(listView, 1);
-        listItem3.SetItemIndex(listView, 2);
-        listItem4.SetItemIndex(listView, 3);
-
-        listView.Items[0].Selected = true;
-        listView.Items[1].Selected = true;
-        listView.Items[3].Selected = true;
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(listItem1.AccessibilityObject, listSelection[0]);
-        Assert.Equal(listItem2.AccessibilityObject, listSelection[1]);
-        Assert.Equal(listItem4.AccessibilityObject, listSelection[2]);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_WithoutSelectedItems_VirtualModeReturnsExpected(View view, bool showGroups)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups,
-            VirtualListSize = 1
-        };
-
-        ListViewItem listItem1 = new ListViewItem();
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listView.CreateControl();
-        listItem1.SetItemIndex(listView, 0);
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(0, listSelection.Length);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_TestData))]
-    public void ListViewAccessibleObject_GetSelectionInvoke_VirtualMode_ReturnsExpected_IfHandleNotCreated(View view, bool showGroups)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups,
-            VirtualListSize = 1
-        };
-
-        ListViewItem listItem1 = new ListViewItem();
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listItem1.SetItemIndex(listView, 0);
-
-        var listSelection = listView.AccessibilityObject.GetSelection();
-        Assert.Equal(0, listSelection.Length);
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ListViewAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ListView listView = new ListView();
-        listView.AccessibleRole = role;
-
-        object actual = listView.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_HitTest_DoesNotReturnNull_IfHandleIsCreated(View view)
-    {
-        using ListView listView = new ListView();
-        listView.View = view;
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader("Column 1") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 2") { Width = 70 });
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1" }));
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1" }));
-
-        Assert.NotNull(HitTest(listView, GetItemLocation(0)));
-        Assert.NotNull(HitTest(listView, GetItemLocation(1)));
-        Assert.True(listView.IsHandleCreated);
-
-        Point GetItemLocation(int itemIndex) =>
-        listView.PointToScreen(listView.GetItemRect(0, ItemBoundsPortion.Label).Location);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_HitTest_ReturnsNull_IfHandleIsNotCreated(View view)
-    {
-        using ListView listView = new ListView();
-        listView.View = view;
-        listView.Columns.Add(new ColumnHeader("Column 1") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 2") { Width = 70 });
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1" }));
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1" }));
-
-        Point point = new Point(15, 55);
-
-        Assert.Null(listView.AccessibilityObject.HitTest(point.X, point.Y));
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_HitTest_ReturnsSubItem_DetailsView()
-    {
-        using ListView listView = new ListView();
-        listView.View = View.Details;
-        listView.Size = new Size(200, 200);
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader("Column 1") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 2") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 3") { Width = 70 });
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12" }));
-        listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22" }));
-
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, HitTest(listView, GetSubItemLocation(0, 0)));
-        Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, HitTest(listView, GetSubItemLocation(0, 1)));
-        Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, HitTest(listView, GetSubItemLocation(0, 2)));
-        Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, HitTest(listView, GetSubItemLocation(1, 0)));
-        Assert.Equal(listView.Items[1].SubItems[1].AccessibilityObject, HitTest(listView, GetSubItemLocation(1, 1)));
-        Assert.Equal(listView.Items[1].SubItems[2].AccessibilityObject, HitTest(listView, GetSubItemLocation(1, 2)));
-
-        Point GetSubItemLocation(int itemIndex, int subItemIndex) =>
-            listView.PointToScreen(listView.GetSubItemRect(itemIndex, subItemIndex, ItemBoundsPortion.Label).Location);
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_HitTest_ReturnsFakeSubItem_DetailsView()
-    {
-        using ListView listView = new ListView();
-        listView.View = View.Details;
-        listView.Size = new Size(200, 200);
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader("Column 1") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 2") { Width = 70 });
-        listView.Columns.Add(new ColumnHeader("Column 3") { Width = 70 });
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1" }));
-        listView.Items.Add(new ListViewItem(new string[] { "Item 2" }));
-
-        Assert.Same(GetDetailsSubItemOrFake(0, 1), HitTest(listView, GetDetailsSubItemOrFake(0, 1).Bounds.Location));
-        Assert.Same(GetDetailsSubItemOrFake(0, 2), HitTest(listView, GetDetailsSubItemOrFake(0, 2).Bounds.Location));
-        Assert.Same(GetDetailsSubItemOrFake(1, 1), HitTest(listView, GetDetailsSubItemOrFake(1, 1).Bounds.Location));
-        Assert.Same(GetDetailsSubItemOrFake(1, 2), HitTest(listView, GetDetailsSubItemOrFake(1, 2).Bounds.Location));
-
-        AccessibleObject GetDetailsSubItemOrFake(int itemIndex, int subItemIndex) =>
-            ((ListViewItemDetailsAccessibleObject)listView.Items[itemIndex].AccessibilityObject).GetDetailsSubItemOrFake(subItemIndex);
-    }
-
-    public static IEnumerable<object[]> ListViewAccessibleObject_GetChild_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in Virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, virtualMode };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChildCount_ReturnsExpected_IfHandleIsNotCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: false, virtualMode, showGroups);
-
-        Assert.Equal(-1, listView.AccessibilityObject.GetChildCount());
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChildCount_ReturnsExpected_IfHandleIsCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: true, virtualMode, showGroups);
-
-        // If the display of groups is allowed, we will return the number of groups (2 - custom group and default group),
-        // otherwise the number of elements (4)
-        int expectedCount = view != View.List && listView.GroupsEnabled ? 2 : 4;
-        Assert.Equal(expectedCount, listView.AccessibilityObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsNull_IfHandleIsNotCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: false, virtualMode, showGroups);
-
-        Assert.Null(listView.AccessibilityObject.GetChild(0));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsNull_IfIndexIsNegative(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: true, virtualMode, showGroups);
-
-        Assert.Null(listView.AccessibilityObject.GetChild(-1));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsNull_IfIndexIsWrong(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: true, virtualMode, showGroups);
-
-        Assert.Null(listView.AccessibilityObject.GetChild(10));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_GetChild_ReturnsExpected_DetailsView(View view,  bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: true, virtualMode, showGroups);
-        List<AccessibleObject> expectedValues = new List<AccessibleObject>();
-
-        if (listView.GroupsEnabled && view != View.List)
-        {
-            expectedValues.Add(listView.DefaultGroup.AccessibilityObject);
-            expectedValues.Add(listView.Groups[0].AccessibilityObject);
-            expectedValues.Add(null);
-        }
-        else
-        {
-            expectedValues.Add(listView.Items[0].AccessibilityObject);
-            expectedValues.Add(listView.Items[1].AccessibilityObject);
-            expectedValues.Add(listView.Items[2].AccessibilityObject);
-        }
-
-        Assert.Equal(expectedValues[0], listView.AccessibilityObject.GetChild(0));
-        Assert.Equal(expectedValues[1], listView.AccessibilityObject.GetChild(1));
-        Assert.Equal(expectedValues[2], listView.AccessibilityObject.GetChild(2));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleIsNotCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: false, virtualMode, showGroups);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleIsCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: false, virtualMode, showGroups);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewAccessibleObject_GetChild_TestData))]
-    public void ListViewAccessibleObject_FragmentNavigate_Child_ReturnsExpected(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetListViewWithData(view, createControl: true, virtualMode, showGroups);
-
-        AccessibleObject expectedFirstChild = listView.GroupsEnabled && view != View.List
-            ? listView.DefaultGroup.AccessibilityObject
-            : listView.Items[0].AccessibilityObject;
-
-        AccessibleObject expectedLastChild = listView.GroupsEnabled && view != View.List
-            ? listView.Groups[0].AccessibilityObject
-            : listView.Items[3].AccessibilityObject;
-
-        Assert.Equal(expectedFirstChild, listView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(expectedLastChild, listView.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    private AccessibleObject HitTest(ListView listView, Point point) =>
-        listView.AccessibilityObject.HitTest(point.X, point.Y);
-
-    private ListView GetListViewWithData(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 4
-        };
-
-        listView.VirtualMode = virtualMode;
-
-        ListViewGroup listViewGroup = new("Test");
-        ListViewItem listItem1 = new(new string[] { "Test Item 1", "Item A" }, -1, listViewGroup);
-        ListViewItem listItem2 = new("Group item 2", listViewGroup);
-        ListViewItem listItem3 = new("Item 3");
-        ListViewItem listItem4 = new(new string[] { "Test Item 4", "Item B", "Item C", "Item D" }, -1);
-
-        if (!virtualMode)
-        {
-            listView.Groups.Add(listViewGroup);
-        }
-
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 1" });
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 2" });
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 3" });
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem1,
-                    1 => listItem2,
-                    2 => listItem3,
-                    3 => listItem4,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem1.SetItemIndex(listView, 0);
-            listItem2.SetItemIndex(listView, 1);
-            listItem3.SetItemIndex(listView, 2);
-            listItem4.SetItemIndex(listView, 3);
-        }
-        else
-        {
-            listView.Items.Add(listItem1);
-            listView.Items.Add(listItem2);
-            listView.Items.Add(listItem3);
-            listView.Items.Add(listItem4);
-        }
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        return listView;
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_FragmentNavigate_ReturnExpected_InvisibleGroups(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        ListViewGroup listViewGroupWithItems1 = listView.Groups[1];
-        ListViewGroup listViewGroupWithItems2 = listView.Groups[2];
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listViewGroupWithItems1.AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Equal(listViewGroupWithItems2.AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_FragmentNavigate_ReturnExpected_InvisibleGroups_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listView.Groups[1].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Equal(listView.Groups[2].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listView.Groups[0].Items.Add(listViewItem1);
-        listView.Groups[3].Items.Add(listViewItem2);
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Equal(listView.Groups[3].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_FragmentNavigate_ReturnExpected_InvisibleGroups_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listView.Groups[1].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Equal(listView.Groups[2].AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        listView.Groups[1].Items.RemoveAt(0);
-        listView.Groups[2].Items.RemoveAt(0);
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject,
-            accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChildCount_ReturnExpected_InvisibleGroups(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChildCount_ReturnExpected_InvisibleGroups_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listView.Groups[0].Items.Add(listViewItem1);
-        listView.Groups[3].Items.Add(listViewItem2);
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChildCount_ReturnExpected_InvisibleGroups_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-
-        listView.Groups[1].Items.RemoveAt(0);
-        listView.Groups[2].Items.RemoveAt(0);
-
-        Assert.Equal(1, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChildCount_ReturnExpected_GroupWithInvalidAccessibleObject(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        Assert.Equal(2, accessibleObject.GetChildCount());
-
-        listView.Groups[1].TestAccessor().Dynamic._accessibilityObject = new AccessibleObject();
-
-        Assert.Equal(1, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChild_ReturnExpected_InvisibleGroups(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        ListViewGroup listViewGroupWithItems1 = listView.Groups[1];
-        ListViewGroup listViewGroupWithItems2 = listView.Groups[2];
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listViewGroupWithItems1.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listViewGroupWithItems2.AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChild_ReturnExpected_InvisibleGroups_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listView.Groups[1].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listView.Groups[2].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listView.Groups[0].Items.Add(listViewItem1);
-        listView.Groups[3].Items.Add(listViewItem2);
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listView.Groups[1].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Equal(listView.Groups[2].AccessibilityObject, accessibleObject.GetChild(2));
-        Assert.Equal(listView.Groups[3].AccessibilityObject, accessibleObject.GetChild(3));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewAccessibleObject_GetChild_ReturnExpected_InvisibleGroups_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Equal(listView.Groups[1].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listView.Groups[2].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-
-        listView.Groups[1].Items.RemoveAt(0);
-        listView.Groups[2].Items.RemoveAt(0);
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    private ListView GetListViewItemWithEmptyGroups(View view)
-    {
-        ListView listView = new ListView() { View = view };
-        listView.CreateControl();
-        ListViewGroup listViewGroupWithoutItems = new("Group without items");
-        ListViewGroup listViewGroupWithItems1 = new("Group with item 1");
-        ListViewGroup listViewGroupWithItems2 = new("Group with item 2");
-        ListViewGroup listViewGroupWithInvisibleItems = new("Group with invisible item");
-        listView.Groups.Add(listViewGroupWithoutItems);
-        listView.Groups.Add(listViewGroupWithItems1);
-        listView.Groups.Add(listViewGroupWithItems2);
-        listView.Groups.Add(listViewGroupWithInvisibleItems);
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        ListViewItem listViewItem3 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listViewGroupWithItems1.Items.Add(listViewItem1);
-        listViewGroupWithItems2.Items.Add(listViewItem2);
-        listViewGroupWithInvisibleItems.Items.Add(listViewItem3);
-
-        return listView;
-    }
-
-    [WinFormsFact]
-    public void ListViewAccessibleObject_BoundingRectangle_ReturnsCorrectWidth_IfListViewIsScrollable()
-    {
-        const int expectedWidth = 100;
-
-        using ListView listView = new()
-        {
-            Size = new Size(expectedWidth, 150)
-        };
-        listView.Items.AddRange(Enumerable.Range(0, 11).Select(i => new ListViewItem()).ToArray());
-        listView.CreateControl();
-
-        UiaCore.IRawElementProviderFragment uiaProvider = listView.AccessibilityObject;
-        UiaCore.UiaRect actual = uiaProvider.BoundingRectangle;
-
-        Assert.Equal(expectedWidth, actual.width);
-    }
-}
-
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedIndexCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedIndexCollectionTests.cs
deleted file mode 100644
index 889949e7856..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedIndexCollectionTests.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_CheckedIndexCollectionTests
-{
-    [WinFormsFact]
-    public void CheckedIndexCollection_Ctor_OwnerIsNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => { new ListView.CheckedIndexCollection(null); });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedListViewItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedListViewItemCollectionTests.cs
deleted file mode 100644
index 51ea5b87b51..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.CheckedListViewItemCollectionTests.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_CheckedListViewItemCollectionTests
-{
-    [WinFormsFact]
-    public void CheckedListViewItemCollection_Ctor_OwnerIsNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => { new ListView.CheckedListViewItemCollection(null); });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.ListViewItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.ListViewItemCollectionTests.cs
deleted file mode 100644
index 4481fa04773..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.ListViewItemCollectionTests.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_ListViewItemCollectionTests
-{
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void ListViewItemCollection_Find_InvokeKeyExists_ReturnsExpected(string key)
-    {
-        using ListView listView = new ListView();
-
-        var child1 = new ListViewItem
-        {
-            Name = "name1"
-        };
-        var child2 = new ListViewItem
-        {
-            Name = "name2"
-        };
-        var child3 = new ListViewItem
-        {
-            Name = "name2"
-        };
-
-        var grandchild1 = new ListViewItem.ListViewSubItem
-        {
-            Name = "name1"
-        };
-        var grandchild2 = new ListViewItem.ListViewSubItem
-        {
-            Name = "name2"
-        };
-        var grandchild3 = new ListViewItem.ListViewSubItem
-        {
-            Name = "name2"
-        };
-
-        ListView.ListViewItemCollection collection = listView.Items;
-        child3.SubItems.Add(grandchild1);
-        child3.SubItems.Add(grandchild2);
-        child3.SubItems.Add(grandchild3);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        // Search all subitems.
-        Assert.Equal(new ListViewItem[] { child2, child3 }, collection.Find(key, searchAllSubItems: true));
-
-        // Call again.
-        Assert.Equal(new ListViewItem[] { child2, child3 }, collection.Find(key, searchAllSubItems: true));
-
-        // Don't search all subitems.
-        Assert.Equal(new ListViewItem[] { child2, child3 }, collection.Find(key, searchAllSubItems: false));
-
-        // Call again.
-        Assert.Equal(new ListViewItem[] { child2, child3 }, collection.Find(key, searchAllSubItems: false));
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ListViewItemCollection_Find_InvokeNoSuchKey_ReturnsEmpty(string key)
-    {
-        using ListView listView = new ListView();
-
-        var child1 = new ListViewItem()
-        {
-            Name = "name1"
-        };
-        var child2 = new ListViewItem()
-        {
-            Name = "name2"
-        };
-        var child3 = new ListViewItem()
-        {
-            Name = "name2"
-        };
-        var collection = listView.Items;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Empty(collection.Find(key, searchAllSubItems: true));
-        Assert.Empty(collection.Find(key, searchAllSubItems: false));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void ListViewItemCollection_Find_NullOrEmptyKey_ThrowsArgumentNullException(string key)
-    {
-        using ListView listView = new ListView();
-        var collection = listView.Items;
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllSubItems: true));
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllSubItems: false));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.SelectedListViewItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.SelectedListViewItemCollectionTests.cs
deleted file mode 100644
index 98b46f32733..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListView.SelectedListViewItemCollectionTests.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ListView_SelectedListViewItemCollectionTests
-{
-    [WinFormsFact]
-    public void SelectedListViewItemCollection_Ctor_OwnerIsNull_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => { new ListView.SelectedListViewItemCollection(null); });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroup.ListViewGroupAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroup.ListViewGroupAccessibleObjectTests.cs
deleted file mode 100644
index f15f7641025..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroup.ListViewGroupAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1467 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using Microsoft.DotNet.RemoteExecutor;
-using static System.Windows.Forms.ListView;
-using static System.Windows.Forms.ListViewGroup;
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewGroup_ListViewGroupAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_Ctor_ThrowsArgumentNullException()
-    {
-        using ListView list = new ListView();
-        ListViewGroup listGroup = new ListViewGroup("Group1");
-        listGroup.Items.Add(new ListViewItem());
-        list.Groups.Add(listGroup);
-
-        Type type = listGroup.AccessibilityObject.GetType();
-        ConstructorInfo ctor = type.GetConstructor(new Type[] { typeof(ListViewGroup), typeof(bool) });
-        Assert.NotNull(ctor);
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { null, false }));
-
-        // group without parent ListView
-        ListViewGroup listGroupWithoutList = new ListViewGroup("Group2");
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { listGroupWithoutList, false }));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_Ctor_Default()
-    {
-        using ListView list = new ListView();
-        ListViewGroup listGroup = new ListViewGroup("Group1");
-        listGroup.Items.Add(new ListViewItem());
-        list.Groups.Add(listGroup);
-
-        AccessibleObject accessibleObject = listGroup.AccessibilityObject;
-        Assert.False(list.IsHandleCreated);
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(AccessibleRole.Grouping, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_GetPropertyValue_ReturnsExpected_WithoutDefaultGroup()
-    {
-        using ListView list = new ListView();
-        ListViewGroup listGroup = new ListViewGroup("Group1");
-        listGroup.Items.Add(new ListViewItem());
-        list.Groups.Add(listGroup);
-
-        AccessibleObject accessibleObject = listGroup.AccessibilityObject;
-        Assert.False(list.IsHandleCreated);
-
-        object accessibleName = accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-        Assert.Equal("Group1", accessibleName);
-
-        object automationId = accessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-        Assert.Equal("ListViewGroup-0", automationId);
-
-        object controlType = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = UiaCore.UIA.GroupControlTypeId;
-        Assert.Equal(expected, controlType);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.Equal(AccessibleRole.Grouping, accessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleRolePropertyId));
-        Assert.False(list.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_GetPropertyValue_ReturnsExpected_WithDefaultGroup()
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView list = new ListView();
-        ListViewGroup listGroup = new ListViewGroup("Group1");
-        listGroup.Items.Add(new ListViewItem());
-        list.Items.Add(new ListViewItem());
-        list.Groups.Add(listGroup);
-
-        AccessibleObject defaultGroupAccessibleObject = list.DefaultGroup.AccessibilityObject;
-        AccessibleObject groupAccessibleObject = listGroup.AccessibilityObject;
-
-        Assert.Equal(list.DefaultGroup.Header, defaultGroupAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Equal("Group1", groupAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Equal("Group1", groupAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleNamePropertyId));
-
-        Assert.Equal("ListViewGroup-0", defaultGroupAccessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId));
-        Assert.Equal("ListViewGroup-1", groupAccessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId));
-
-        Assert.Equal(UiaCore.UIA.GroupControlTypeId, groupAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.Equal(UiaCore.UIA.GroupControlTypeId, defaultGroupAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-
-        Assert.True((bool)defaultGroupAccessibleObject.GetPropertyValue(UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.True((bool)groupAccessibleObject.GetPropertyValue(UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.Equal(AccessibleRole.Grouping, defaultGroupAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleRolePropertyId));
-        Assert.Equal(AccessibleRole.Grouping, groupAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleRolePropertyId));
-        Assert.Null(groupAccessibleObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.Equal("WinForm", groupAccessibleObject.GetPropertyValue(UiaCore.UIA.FrameworkIdPropertyId));
-        Assert.False(list.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_GetPropertyValue_ReturnsExpected_WithSubtitle()
-    {
-        using ListView list = new ListView();
-        const string name = "Group1";
-        const string subtitle = "Subtitle";
-        ListViewGroup listGroup = new ListViewGroup(name) { Subtitle = subtitle };
-        listGroup.Items.Add(new ListViewItem());
-        list.Groups.Add(listGroup);
-
-        AccessibleObject accessibleObject = listGroup.AccessibilityObject;
-        Assert.False(list.IsHandleCreated);
-
-        object accessibleName = accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-        Assert.Equal($"{name}. {subtitle}", accessibleName);
-
-        Assert.False(list.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_ReturnsExpected_WithDefaultGroup(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem());
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        if (listView.IsHandleCreated && listView.GroupsDisplayed)
-        {
-            Assert.Equal(listView.AccessibilityObject, listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Equal(groups[0].AccessibilityObject, listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(items[2].AccessibilityObject, listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Equal(items[2].AccessibilityObject, listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Equal(listView.AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Equal(groups[1].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(listView.DefaultGroup.AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(items[0].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Equal(items[1].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Equal(listView.AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(groups[0].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(items[3].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Equal(items[5].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        }
-        else
-        {
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Null(listView.Groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(listView.Groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.Groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(listView.Groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(listView.Groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Null(listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_ReturnsExpected_WithoutDefaultGroup(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        if (listView.IsHandleCreated && listView.GroupsDisplayed)
-        {
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Equal(listView.AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Equal(groups[1].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(items[0].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Equal(items[2].AccessibilityObject, groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Equal(listView.AccessibilityObject, listView.Groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(groups[0].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(items[3].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Equal(items[5].AccessibilityObject, groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        }
-        else
-        {
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(listView.DefaultGroup.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(groups[0].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-            Assert.Null(groups[1].AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        }
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_Bounds_ReturnsCorrectValue()
-    {
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            Control.CheckForIllegalCrossThreadCalls = true;
-            using Form form = new Form();
-
-            using ListView list = new ListView();
-            ListViewGroup listGroup = new ListViewGroup("Group1");
-            ListViewItem listItem1 = new ListViewItem("Item1");
-            ListViewItem listItem2 = new ListViewItem("Item2");
-            list.Groups.Add(listGroup);
-            listItem1.Group = listGroup;
-            listItem2.Group = listGroup;
-            list.Items.Add(listItem1);
-            list.Items.Add(listItem2);
-            list.CreateControl();
-            form.Controls.Add(list);
-            form.Show();
-
-            AccessibleObject accessibleObject = list.AccessibilityObject;
-            AccessibleObject group1AccObj = listGroup.AccessibilityObject;
-            Assert.True(list.IsHandleCreated);
-
-            RECT groupRect = new RECT();
-            PInvoke.SendMessage(list, PInvoke.LVM_GETGROUPRECT, (WPARAM)listGroup.ID, ref groupRect);
-
-            int actualWidth = group1AccObj.Bounds.Width;
-            int expectedWidth = groupRect.Width;
-            Assert.Equal(expectedWidth, actualWidth);
-
-            int actualHeight = group1AccObj.Bounds.Height;
-            int expectedHeight = groupRect.Height;
-            Assert.Equal(expectedHeight, actualHeight);
-
-            Rectangle actualBounds = group1AccObj.Bounds;
-            actualBounds.Location = new Point(0, 0);
-            Rectangle expectedBounds = groupRect;
-            Assert.Equal(expectedBounds, actualBounds);
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_Bounds_ReturnsCorrectValue_PostHandle()
-    {
-        using Form form = new();
-        using ListView listView = new();
-
-        form.Controls.Add(listView);
-        form.Show();
-
-        Assert.True(listView.IsHandleCreated);
-
-        ListViewGroup group = new();
-        listView.Groups.Add(group);
-        listView.Items.Add(new ListViewItem("a", group));
-
-        RECT groupRect = new RECT();
-        PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPRECT, (WPARAM)group.ID, ref groupRect);
-
-        AccessibleObject groupAccObj = group.AccessibilityObject;
-
-        int actualWidth = groupAccObj.Bounds.Width;
-        int expectedWidth = groupRect.Width;
-        Assert.Equal(expectedWidth, actualWidth);
-
-        int actualHeight = groupAccObj.Bounds.Height;
-        int expectedHeight = groupRect.Height;
-        Assert.Equal(expectedHeight, actualHeight);
-
-        Rectangle actualBounds = groupAccObj.Bounds;
-        actualBounds.Location = new Point(0, 0);
-        Rectangle expectedBounds = groupRect;
-        Assert.Equal(expectedBounds, actualBounds);
-    }
-
-    public static IEnumerable<object[]> ListViewGroupAccessibleObject_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, createHandle };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_GetChildIndex_ReturnsExpected(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem());
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        ListViewItem itemWithoutListView1 = new(groups[1]);
-        ListViewItem itemWithoutListView2 = new(groups[1]);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        if (listView.IsHandleCreated && listView.GroupsDisplayed)
-        {
-            Assert.Equal(0, groups[0].AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(1, groups[0].AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(0, groups[1].AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(1, groups[1].AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(2, groups[1].AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(0, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-        }
-        else
-        {
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[0].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[1].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[2].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[3].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[4].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(items[5].AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(itemWithoutListView1.AccessibilityObject));
-            Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(itemWithoutListView2.AccessibilityObject));
-        }
-
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_GetChildIndex_ReturnsMinusOne_IfChildIsNull(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem());
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        Assert.Equal(-1, groups[0].AccessibilityObject.GetChildIndex(null));
-        Assert.Equal(-1, groups[1].AccessibilityObject.GetChildIndex(null));
-        Assert.Equal(-1, listView.DefaultGroup.AccessibilityObject.GetChildIndex(null));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_GetChildCount_Invoke_ReturnsExpected(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem());
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        ListViewGroupAccessibleObject group1AccObj = (ListViewGroupAccessibleObject)groups[0].AccessibilityObject;
-        ListViewGroupAccessibleObject group2AccObj = (ListViewGroupAccessibleObject)groups[1].AccessibilityObject;
-        ListViewGroupAccessibleObject defaultGroupAccObj = (ListViewGroupAccessibleObject)listView.DefaultGroup.AccessibilityObject;
-        bool supportsGetChild = listView.IsHandleCreated && listView.GroupsDisplayed;
-
-        Assert.Equal(supportsGetChild ? 2 : -1, group1AccObj.GetChildCount());
-        Assert.Equal(supportsGetChild ? 3 : -1, group2AccObj.GetChildCount());
-        Assert.Equal(supportsGetChild ? 1 : -1, defaultGroupAccObj.GetChildCount());
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewGroupAccessibleObject_VirtualMode_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, createHandle };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> ListViewGroupAccessibleObject_GetChild_Invoke_TestData()
-    {
-        foreach (bool virtualMode in new[] { true, false })
-        {
-            foreach (View view in Enum.GetValues(typeof(View)))
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        yield return new object[] { view, showGroups, createHandle, virtualMode };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_GetChild_Invoke_ReturnsExpected(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewGroupCollection groups = listView.Groups;
-        ListViewItemCollection items = listView.Items;
-
-        groups.Add(new ListViewGroup("Group1"));
-        groups.Add(new ListViewGroup("Group2"));
-        groups.Add(new ListViewGroup("Group3"));
-        items.Add(new ListViewItem(groups[0]));
-        items.Add(new ListViewItem());
-        items.Add(new ListViewItem(groups[1]));
-        items.Add(new ListViewItem(groups[1]));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        ListViewGroupAccessibleObject group1AccObj = (ListViewGroupAccessibleObject)groups[0].AccessibilityObject;
-        ListViewGroupAccessibleObject group2AccObj = (ListViewGroupAccessibleObject)groups[1].AccessibilityObject;
-        ListViewGroupAccessibleObject group3AccObj = (ListViewGroupAccessibleObject)groups[2].AccessibilityObject;
-        ListViewGroupAccessibleObject defaultGroupAccObj = (ListViewGroupAccessibleObject)listView.DefaultGroup.AccessibilityObject;
-        bool supportsGetChild = listView.IsHandleCreated && listView.GroupsDisplayed;
-
-        Assert.Null(group1AccObj.GetChild(-1));
-        Assert.Null(group1AccObj.GetChild(1));
-
-        Assert.Equal(supportsGetChild ? items[0].AccessibilityObject : null, group1AccObj.GetChild(0));
-
-        Assert.Null(group2AccObj.GetChild(-1));
-        Assert.Null(group2AccObj.GetChild(2));
-        Assert.Equal(supportsGetChild ? items[2].AccessibilityObject : null, group2AccObj.GetChild(0));
-        Assert.Equal(supportsGetChild ? items[3].AccessibilityObject : null, group2AccObj.GetChild(1));
-
-        Assert.Null(group3AccObj.GetChild(-1));
-        Assert.Null(group3AccObj.GetChild(0));
-
-        Assert.Null(defaultGroupAccObj.GetChild(-1));
-        Assert.Null(defaultGroupAccObj.GetChild(1));
-        Assert.Equal(supportsGetChild ? items[1].AccessibilityObject : null, defaultGroupAccObj.GetChild(0));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewGroup_GroupAddedWithItem_AccessibleObject_TestData()
-    {
-        foreach (bool virtualMode in new[] { true, false })
-        {
-            foreach (View view in Enum.GetValues(typeof(View)))
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        yield return new object[] { view, showGroups, createHandle, virtualMode };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroup_GroupAddedWithItem_AccessibleObject_TestData))]
-    public void ListViewGroup_GroupAddedWithItem_AccessibleObject_DoesntThrowException(View view, bool showGroups, bool createHandle, bool virtualMode)
-    {
-        using var listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 1,
-            VirtualMode = virtualMode
-        };
-
-        var listViewGroup = new ListViewGroup("Test Group");
-        var listViewItem = new ListViewItem("Test item", listViewGroup);
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem.SetItemIndex(listView, 0);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem);
-        }
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        Assert.Null(listViewGroup.ListView);
-        Assert.NotNull(listViewGroup.AccessibilityObject);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_ExpandCollapseState_ReturnExpected(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups,
-        };
-
-        var lvgroup1 = new ListViewGroup
-        {
-            Header = "CollapsibleGroup1",
-            CollapsedState = ListViewGroupCollapsedState.Expanded
-        };
-
-        listView.Groups.Add(lvgroup1);
-        listView.Items.Add(new ListViewItem("Item1", lvgroup1));
-
-        var lvgroup2 = new ListViewGroup
-        {
-            Header = "CollapsibleGroup2",
-            CollapsedState = ListViewGroupCollapsedState.Collapsed
-        };
-
-        listView.Groups.Add(lvgroup2);
-        listView.Items.Add(new ListViewItem("Item2", lvgroup2));
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        Assert.Equal(ExpandCollapseState.Expanded, lvgroup1.AccessibilityObject.ExpandCollapseState);
-        Assert.Equal(ExpandCollapseState.Collapsed, lvgroup2.AccessibilityObject.ExpandCollapseState);
-        Assert.Equal(ExpandCollapseState.Expanded, listView.DefaultGroup.AccessibilityObject.ExpandCollapseState);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_ExpandCollapseStateFromKeyboard_ReturnsExpected()
-    {
-        using ListView listView = new() { ShowGroups = true };
-
-        ListViewGroup listViewGroup = new()
-        {
-            Header = "CollapsibleGroup",
-            CollapsedState = ListViewGroupCollapsedState.Expanded
-        };
-
-        listView.Groups.Add(listViewGroup);
-        listView.Items.Add(new ListViewItem("Group Item 1", listViewGroup));
-        listView.Items.Add(new ListViewItem("Group Item 2", listViewGroup));
-        listView.CreateControl();
-        listViewGroup.Items[0].Selected = true;
-        listViewGroup.Items[0].Focused = true;
-        AccessibleObject accessibleObject = listView.SelectedItems[0].AccessibilityObject;
-        ListViewGroupAccessibleObject groupAccObj = (ListViewGroupAccessibleObject)accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        groupAccObj.SetFocus();
-
-        Assert.True(listView.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        KeyboardSimulator.KeyPress(listView, Keys.Up);
-        KeyboardSimulator.KeyPress(listView, Keys.Left);
-
-        Assert.Equal(ListViewGroupCollapsedState.Collapsed, listViewGroup.GetNativeCollapsedState());
-        Assert.Equal(ExpandCollapseState.Collapsed, listViewGroup.AccessibilityObject.ExpandCollapseState);
-
-        KeyboardSimulator.KeyPress(listView, Keys.Left);
-
-        // The second left key pressing should not change Collapsed state
-        Assert.Equal(ListViewGroupCollapsedState.Collapsed, listViewGroup.GetNativeCollapsedState());
-        Assert.Equal(ExpandCollapseState.Collapsed, listViewGroup.AccessibilityObject.ExpandCollapseState);
-
-        KeyboardSimulator.KeyPress(listView, Keys.Right);
-
-        Assert.Equal(ListViewGroupCollapsedState.Expanded, listViewGroup.GetNativeCollapsedState());
-        Assert.Equal(ExpandCollapseState.Expanded, listViewGroup.AccessibilityObject.ExpandCollapseState);
-
-        KeyboardSimulator.KeyPress(listView, Keys.Right);
-
-        // The second right key pressing should not change Expanded state
-        Assert.Equal(ListViewGroupCollapsedState.Expanded, listViewGroup.GetNativeCollapsedState());
-        Assert.Equal(ExpandCollapseState.Expanded, listViewGroup.AccessibilityObject.ExpandCollapseState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ListViewGroupCollapsedState.Collapsed)]
-    [InlineData(ListViewGroupCollapsedState.Expanded)]
-    public void ListViewGroupAccessibleObject_GroupCollapsedStateChanged_IsExpected_ForMultipleSelection(ListViewGroupCollapsedState firstGroupSate)
-    {
-        using ListView listView = new() { ShowGroups = true };
-
-        // This test checks the case of collapsing of the second group.
-        // The first group state might affect behaviour, so check both states.
-        ListViewGroup group1 = new("Group 1") { CollapsedState = firstGroupSate };
-        ListViewGroup group2 = new("Group 2") { CollapsedState = ListViewGroupCollapsedState.Expanded };
-        ListViewGroup group3 = new("Group 3") { CollapsedState = ListViewGroupCollapsedState.Expanded };
-        listView.Groups.AddRange(new[] { group1, group2, group3 });
-        ListViewItem item1 = new("Item 1", group1);
-        ListViewItem item2 = new("Item 2", group2);
-        ListViewItem item3 = new("Item 2", group3);
-        listView.Items.AddRange(new[] { item1, item2, item3 });
-        listView.CreateControl();
-        item1.Focused = true;
-
-        // Keep indices of groups, that GroupCollapsedStateChanged event was raised for.
-        // It will help to understand if the event was raised for a correct group and was raised at all.
-        List<int> eventGroupIndices = new();
-        listView.GroupCollapsedStateChanged += (_, e) => eventGroupIndices.Add(e.GroupIndex);
-
-        // Navigate to the second group
-        KeyboardSimulator.KeyPress(listView, Keys.Down);
-
-        if (firstGroupSate == ListViewGroupCollapsedState.Collapsed)
-        {
-            // This action is necessary to navigate to the second group correctly in this specific case.
-            KeyboardSimulator.KeyPress(listView, Keys.Up);
-        }
-
-        // Simulate multiple selection of several groups to test a specific case,
-        // described in https://github.com/dotnet/winforms/issues/6708
-        item1.Selected = true;
-        item2.Selected = true;
-        item3.Selected = true;
-
-        // Simulate the second group collapse action via keyboard.
-        KeyboardSimulator.KeyPress(listView, Keys.Left);
-
-        Assert.Equal(firstGroupSate, group1.GetNativeCollapsedState());
-        Assert.Equal(firstGroupSate, group1.CollapsedState);
-        Assert.Equal(ListViewGroupCollapsedState.Collapsed, group2.GetNativeCollapsedState());
-        Assert.Equal(ListViewGroupCollapsedState.Collapsed, group2.CollapsedState);
-        Assert.Equal(ListViewGroupCollapsedState.Expanded, group3.GetNativeCollapsedState());
-        Assert.Equal(ListViewGroupCollapsedState.Expanded, group3.CollapsedState);
-
-        // GroupCollapsedStateChanged event should be raised
-        // for the second group only in this specific case.
-        Assert.Equal(1, eventGroupIndices.Count);
-        Assert.Equal(1, eventGroupIndices[0]); 
-
-        // Make sure that we really cheched multiple selection case and the items
-        // are still selected after keyboard navigation simulations.
-        Assert.Equal(3, listView.SelectedItems.Count);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_InvisibleGroups(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        AccessibleObject listViewGroupWithItems1 = listView.Groups[1].AccessibilityObject;
-        AccessibleObject listViewGroupWithItems2 = listView.Groups[2].AccessibilityObject;
-
-        Assert.Null(listViewGroupWithItems1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(listViewGroupWithItems2, listViewGroupWithItems1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(listViewGroupWithItems1, listViewGroupWithItems2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(listViewGroupWithItems2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_ReturnsExpected_Sibling_InvisibleGroups_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-
-        Assert.Null(GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listView.Groups[0].Items.Add(listViewItem1);
-        listView.Groups[3].Items.Add(listViewItem2);
-
-        Assert.Null(GetAccessibleObject(0).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(0).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(0), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(3), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(3).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(3).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-
-        AccessibleObject GetAccessibleObject(int index) => listView.Groups[index].AccessibilityObject;
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_InvisibleGroups_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithEmptyGroups(view);
-        AccessibleObject accessibleObject = listView.AccessibilityObject;
-        AccessibleObject listViewGroupWithItems1 = listView.Groups[1].AccessibilityObject;
-        AccessibleObject listViewGroupWithItems2 = listView.Groups[2].AccessibilityObject;
-
-        Assert.Null(listViewGroupWithItems1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(listViewGroupWithItems2, listViewGroupWithItems1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(listViewGroupWithItems1, listViewGroupWithItems2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(listViewGroupWithItems2.FragmentNavigate(NavigateDirection.NextSibling));
-
-        listView.Groups[2].Items.RemoveAt(0);
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, listViewGroupWithItems1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(listViewGroupWithItems1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_Child_ReturnsExpected_InvisibleItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Groups[0].Items[2].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_Child_ReturnsExpected_InvisibleItems_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Groups[0].Items[2].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        listView.Items.Add(listView.Groups[0].Items[0]);
-        listView.Items.Add(listView.Groups[0].Items[3]);
-
-        Assert.Equal(listView.Groups[0].Items[0].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Groups[0].Items[3].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_FragmentNavigate_Child_ReturnsExpected_InvisibleItems_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Groups[0].Items[2].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        listView.Items.RemoveAt(1);
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChildCount_ReturnsExpected_InvisibleItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChildCount_ReturnsExpected_InvisibleItems_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-
-        listView.Items.Add(listView.Groups[0].Items[0]);
-        listView.Items.Add(listView.Groups[0].Items[3]);
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChildCount_ReturnsExpected_InvisibleItems_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(2, accessibleObject.GetChildCount());
-
-        listView.Items.RemoveAt(1);
-
-        Assert.Equal(1, accessibleObject.GetChildCount());
-
-        listView.Items.RemoveAt(0);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChild_ReturnsExpected_InvisibleItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listView.Groups[0].Items[2].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChild_ReturnsExpected_InvisibleItems_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        listView.Items.Add(listView.Groups[0].Items[0]);
-        listView.Items.Add(listView.Groups[0].Items[3]);
-
-        Assert.Equal(listView.Groups[0].Items[0].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Equal(listView.Groups[0].Items[2].AccessibilityObject, accessibleObject.GetChild(2));
-        Assert.Equal(listView.Groups[0].Items[3].AccessibilityObject, accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_GetChild_ReturnsExpected_InvisibleItems_AfterRemovingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-        AccessibleObject accessibleObject = listView.Groups[0].AccessibilityObject;
-
-        listView.Items.RemoveAt(1);
-
-        Assert.Equal(listView.Groups[0].Items[1].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_FragmentRoot_Returns_ListViewAccessibleObject(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-        };
-
-        ListViewGroup listViewGroup = new();
-        listView.Groups.Add(listViewGroup);
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Equal(listView.AccessibilityObject, listViewGroup.AccessibilityObject.FragmentRoot);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_Bounds_ReturnsExpected(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = GetListViewWithGroups(view, showGroups, createHandle, virtualMode: false);
-        ListView.ListViewAccessibleObject accessibleObject = listView.AccessibilityObject as ListView.ListViewAccessibleObject;
-        bool showBounds = listView.IsHandleCreated && listView.GroupsDisplayed;
-
-        Assert.Equal(showBounds, !listView.DefaultGroup.AccessibilityObject.Bounds.IsEmpty);
-        Assert.Equal(showBounds, !listView.Groups[0].AccessibilityObject.Bounds.IsEmpty);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_Bounds_LocatedInsideListViewBounds(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewWithGroups(view, showGroups: true, createHandle: true, virtualMode: false);
-        ListView.ListViewAccessibleObject accessibleObject = listView.AccessibilityObject as ListView.ListViewAccessibleObject;
-        Rectangle listViewBounds = listView.AccessibilityObject.Bounds;
-
-        Assert.True(listViewBounds.Contains(listView.DefaultGroup.AccessibilityObject.Bounds));
-        Assert.True(listViewBounds.Contains(listView.Groups[0].AccessibilityObject.Bounds));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewGroupAccessibleObject_Bounds_ReturnEmptyRectangle_ForEmptyGroup(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new ListView() { View = view, ShowGroups = true };
-        listView.Columns.Add(new ColumnHeader());
-        listView.CreateControl();
-        listView.Groups.Add(new ListViewGroup());
-        listView.Items.Add(new ListViewItem());
-
-        Assert.False(listView.DefaultGroup.AccessibilityObject.Bounds.IsEmpty);
-        Assert.True(listView.Groups[0].AccessibilityObject.Bounds.IsEmpty);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    private ListView GetListViewItemWithEmptyGroups(View view)
-    {
-        ListView listView = new ListView() { View = view };
-        listView.CreateControl();
-        ListViewGroup listViewGroupWithoutItems = new("Group without items");
-        ListViewGroup listViewGroupWithItems1 = new("Group with item 1");
-        ListViewGroup listViewGroupWithItems2 = new("Group with item 2");
-        ListViewGroup listViewGroupWithInvisibleItems = new("Group with invisible item");
-        listView.Groups.Add(listViewGroupWithoutItems);
-        listView.Groups.Add(listViewGroupWithItems1);
-        listView.Groups.Add(listViewGroupWithItems2);
-        listView.Groups.Add(listViewGroupWithInvisibleItems);
-        ListViewItem listViewItem1 = new();
-        ListViewItem listViewItem2 = new();
-        ListViewItem listViewItem3 = new();
-        listView.Items.Add(listViewItem1);
-        listView.Items.Add(listViewItem2);
-        listViewGroupWithItems1.Items.Add(listViewItem1);
-        listViewGroupWithItems2.Items.Add(listViewItem2);
-        listViewGroupWithInvisibleItems.Items.Add(listViewItem3);
-
-        return listView;
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_TestData))]
-    public void ListViewGroupAccessibleObject_SetFocus_WorksCorrectly(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            Size = new Size(200, 200)
-        };
-
-        ListViewGroup listGroup1 = new ListViewGroup("Group1");
-        ListViewGroup listGroup2 = new ListViewGroup("Group2");
-        ListViewItem listItem1 = new ListViewItem(listGroup1);
-        ListViewItem listItem2 = new ListViewItem(listGroup1);
-        ListViewItem listItem3 = new ListViewItem();
-        listView.Groups.Add(listGroup1);
-        listView.Groups.Add(listGroup2);
-
-        listView.Items.Add(listItem1);
-        listView.Items.Add(listItem2);
-        listView.Items.Add(listItem3);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        bool setFocusSupported = listView.IsHandleCreated && listView.GroupsDisplayed;
-
-        listGroup2.AccessibilityObject.SetFocus();
-
-        Assert.Null(listView.FocusedGroup);
-
-        listView.DefaultGroup.AccessibilityObject.SetFocus();
-
-        Assert.Equal(setFocusSupported ? listView.DefaultGroup : null, listView.FocusedGroup);
-
-        listGroup1.AccessibilityObject.SetFocus();
-
-        Assert.Equal(setFocusSupported ? listGroup1 : null, listView.FocusedGroup);
-
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewGroupAccessibleObject_IsPatternSupported_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    foreach (ListViewGroupCollapsedState listViewGroupCollapsedState in Enum.GetValues(typeof(ListViewGroupCollapsedState)))
-                    {
-                        yield return new object[] { view, showGroups, createHandle, listViewGroupCollapsedState };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewGroupAccessibleObject_IsPatternSupported_TestData))]
-    public void ListViewGroupAccessibleObject_IsPatternSupported_ReturnFalse_ForCollapsedStateDefault(View view, bool showGroups, bool createHandle, ListViewGroupCollapsedState listViewGroupCollapsedState)
-    {
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-        };
-
-        ListViewGroup listGroup = new("Test")
-        {
-            CollapsedState = listViewGroupCollapsedState,
-        };
-
-        listView.Groups.Add(listGroup);
-        ListViewItem item = new("Test");
-        item.Group = listGroup;
-        listView.Items.Add(item);
-        ListViewGroupAccessibleObject accessibleObject = new(listGroup, false);
-
-        if (createHandle)
-        {
-            listView.CreateControl();
-        }
-
-        bool expectedPatternSupported = listViewGroupCollapsedState != ListViewGroupCollapsedState.Default;
-
-        Assert.Equal(expectedPatternSupported, accessibleObject.IsPatternSupported(UiaCore.UIA.ExpandCollapsePatternId));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_IsDisconnected_WhenListViewReleasesUiaProvider()
-    {
-        using ListView listView = new();
-        ListViewGroup group = new();
-        listView.Groups.Add(group);
-        EnforceAccessibleObjectCreation(group);
-        EnforceAccessibleObjectCreation(listView.DefaultGroup);
-
-        listView.ReleaseUiaProvider(listView.HWND);
-
-        Assert.Null(group.TestAccessor().Dynamic._accessibilityObject);
-        Assert.Null(listView.DefaultGroup.TestAccessor().Dynamic._accessibilityObject);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_IsDisconnected_WhenGroupsAreCleared()
-    {
-        using ListView listView = new();
-        ListViewGroup group = new();
-        listView.Groups.Add(group);
-        EnforceAccessibleObjectCreation(group);
-
-        listView.Groups.Clear();
-
-        Assert.Null(group.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupAccessibleObject_IsDisconnected_WhenGroupIsRemoved()
-    {
-        using ListView listView = new();
-        ListViewGroup group = new();
-        listView.Groups.Add(group);
-        EnforceAccessibleObjectCreation(group);
-
-        listView.Groups.Remove(group);
-
-        Assert.Null(group.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private static void EnforceAccessibleObjectCreation(ListViewGroup group)
-    {
-        _ = group.AccessibilityObject;
-        Assert.NotNull(group.TestAccessor().Dynamic._accessibilityObject);
-    }
-
-    private ListView GetListViewItemWithInvisibleItems(View view)
-    {
-        ListView listView = new ListView() { View = view };
-        listView.CreateControl();
-        ListViewGroup listViewGroup = new("Test group");
-        ListViewItem listViewInvisibleItem1 = new ListViewItem("Invisible item 1");
-        ListViewItem listViewVisibleItem1 = new ListViewItem("Visible item 1");
-        ListViewItem listViewInvisibleItem2 = new ListViewItem("Invisible item 1");
-        ListViewItem listViewVisibleItem2 = new ListViewItem("Visible item 1");
-
-        listView.Groups.Add(listViewGroup);
-        listView.Items.AddRange(new ListViewItem[] { listViewVisibleItem1, listViewVisibleItem2 });
-        listViewGroup.Items.AddRange(new ListViewItem[]
-        {
-            listViewInvisibleItem1, listViewVisibleItem1,
-            listViewVisibleItem2, listViewInvisibleItem2
-        });
-
-        return listView;
-    }
-
-    private ListView GetListViewWithGroups(View view, bool showGroups, bool createHandle, bool virtualMode)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualListSize = 2,
-            VirtualMode = virtualMode,
-            Size = new Size(200, 200)
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        ListViewItem listViewItem1 = new ListViewItem("Test item 1");
-        if (!virtualMode)
-        {
-            var listViewGroup = new ListViewGroup("Test Group");
-            listView.Groups.Add(listViewGroup);
-            listViewItem1.Group = listViewGroup;
-        }
-
-        var listViewItem2 = new ListViewItem("Test item 2");
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-        }
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        return listView;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupCollectionTests.cs
deleted file mode 100644
index 6a3ddab3ab5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupCollectionTests.cs
+++ /dev/null
@@ -1,1134 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewGroupCollectionTests
-{
-    [WinFormsFact]
-    public void ListViewGroupCollection_IList_GetProperties_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_GetValidIndex_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        var group = new ListViewGroup();
-        collection.Add(group);
-        Assert.Same(group, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_Item_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetValidIndex_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        var group = new ListViewGroup();
-        collection[0] = group;
-        Assert.Same(group, collection[0]);
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetListViewGroupWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        var group = new ListViewGroup();
-        collection[0] = group;
-        Assert.Same(group, collection[0]);
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetListViewGroupWithItems_Success()
-    {
-        using var listView = new ListView();
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem());
-        group.Items.Add(item);
-        listView.Items.Add(item);
-
-        collection[0] = group;
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetListViewGroupWithItemsWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem());
-        group.Items.Add(item);
-        listView.Items.Add(item);
-
-        collection[0] = group;
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_Item_SetAlreadyInCollection_Nop(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        collection.Add(group1);
-        collection.Add(group2);
-
-        collection[index] = group2;
-        Assert.Same(group1, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetAlreadyInOtherCollection_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        using var otherListView = new ListView();
-        ListViewGroupCollection otherCollection = otherListView.Groups;
-
-        var group = new ListViewGroup();
-        otherCollection.Add(group);
-
-        collection[0] = group;
-        Assert.Same(group, collection[0]);
-        Assert.Same(listView, group.ListView);
-        Assert.Equal(group, Assert.Single(collection));
-        Assert.Equal(group, Assert.Single(otherCollection));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetHasItemsFromOtherListView_ThrowsArgumentException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var oldGroup = new ListViewGroup();
-        collection.Add(oldGroup);
-        using var otherListView = new ListView();
-
-        var item = new ListViewItem();
-        var group = new ListViewGroup();
-        group.Items.Add(item);
-        otherListView.Items.Add(item);
-
-        Assert.Throws<ArgumentException>(() => collection[0] = group);
-        Assert.Same(oldGroup, Assert.Single(collection.Cast<ListViewGroup>()));
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetNull_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_Item_SetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new ListViewGroup());
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListItem_GetValidIndex_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-
-        var group = new ListViewGroup();
-        collection.Add(group);
-        Assert.Same(group, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_IListItem_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListItem_SetValidIndex_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        var group = new ListViewGroup();
-        collection[0] = group;
-        Assert.Same(group, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListItem_SetAlreadyInCollection_Nop()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        collection.Add(group1);
-        collection.Add(group2);
-
-        collection[0] = group2;
-        Assert.Same(group1, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_IListItem_SetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new ListViewGroup());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewGroupCollection_IListItem_SetInvalidValue_Nop(object value)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        collection[0] = value;
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("text", 1)]
-    public void ListViewGroupCollection_Item_GetStringExists_ReturnsExpected(string key, int expectedIndex)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup
-        {
-            Name = "text"
-        };
-        collection.Add(group1);
-        collection.Add(group2);
-
-        Assert.Equal(collection[expectedIndex], collection[key]);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("longer")]
-    [InlineData("sm")]
-    [InlineData("tsxt")]
-    [InlineData("TEXT")]
-    public void ListViewGroupCollection_Item_GetNoSuchString_ReturnsNull(string key)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup
-        {
-            Name = "text"
-        };
-        collection.Add(group1);
-        collection.Add(group2);
-
-        Assert.Null(collection[key]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_GetStringEmptyCollection_ReturnsNull()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Null(collection["text"]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("text", 1)]
-    public void ListViewGroupCollection_Item_SetStringExists_GetReturnsExpected(string key, int expectedIndex)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup
-        {
-            Name = "text"
-        };
-        collection.Add(group1);
-        collection.Add(group2);
-
-        var group3 = new ListViewGroup();
-        collection[key] = group3;
-        Assert.Same(group3, collection[expectedIndex]);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("longer")]
-    [InlineData("sm")]
-    [InlineData("tsxt")]
-    [InlineData("TEXT")]
-    public void ListViewGroupCollection_Item_SetNoSuchString_Nop(string key)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup
-        {
-            Name = "text"
-        };
-        collection.Add(group1);
-        collection.Add(group2);
-
-        var group3 = new ListViewGroup();
-        collection[key] = group3;
-        Assert.Same(group1, collection[0]);
-        Assert.Same(group2, collection[1]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetStringEmptyCollection_Nop()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection["text"] = new ListViewGroup();
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Item_SetStringNullValue_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Throws<ArgumentNullException>("value", () => collection["key"] = null);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        Assert.Equal(0, collection.Add(group1));
-        Assert.Same(group1, Assert.Single(collection));
-        Assert.Same(listView, group1.ListView);
-
-        // Add another.
-        var group2 = new ListViewGroup();
-        Assert.Equal(1, collection.Add(group2));
-        Assert.Equal(new ListViewGroup[] { group1, group2 }, collection.Cast<ListViewGroup>());
-        Assert.Same(listView, group2.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_ListViewGroupWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        Assert.Equal(0, collection.Add(group1));
-        Assert.Same(group1, Assert.Single(collection));
-        Assert.Same(listView, group1.ListView);
-
-        // Add another.
-        var group2 = new ListViewGroup();
-        Assert.Equal(1, collection.Add(group2));
-        Assert.Equal(new ListViewGroup[] { group1, group2 }, collection.Cast<ListViewGroup>());
-        Assert.Same(listView, group2.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_ListViewGroupWithItems_Success()
-    {
-        using var listView = new ListView();
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem());
-        group.Items.Add(item);
-        listView.Items.Add(item);
-
-        Assert.Equal(0, collection.Add(group));
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_ListViewGroupWithItemsWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        group1.Items.Add(new ListViewItem());
-        group1.Items.Add(item);
-        listView.Items.Add(item);
-
-        Assert.Equal(0, collection.Add(group1));
-        Assert.Same(group1, Assert.Single(collection));
-        Assert.Same(listView, group1.ListView);
-
-        var group2 = new ListViewGroup();
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_AlreadyInCollection_Nop()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        Assert.Equal(0, collection.Add(group1));
-        Assert.Equal(1, collection.Add(group2));
-
-        Assert.Equal(-1, collection.Add(group1));
-        Assert.Equal(2, collection.Count);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_AlreadyInOtherCollection_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        using var otherListView = new ListView();
-        ListViewGroupCollection otherCollection = otherListView.Groups;
-
-        var group = new ListViewGroup();
-        otherCollection.Add(group);
-
-        // The group appears to belong to two list views.
-        collection.Add(group);
-        Assert.Same(group, collection[0]);
-        Assert.Same(listView, group.ListView);
-        Assert.Equal(group, Assert.Single(collection));
-        Assert.Equal(group, Assert.Single(otherCollection));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_NullGroup_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Throws<ArgumentNullException>("group", () => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Add_HasItemsFromOtherListView_ThrowsArgumentException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        using var otherListView = new ListView();
-
-        var item = new ListViewItem();
-        var group = new ListViewGroup();
-        group.Items.Add(item);
-        otherListView.Items.Add(item);
-
-        Assert.Throws<ArgumentException>(() => collection.Add(group));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, "")]
-    [InlineData("", "", "")]
-    [InlineData("key", "headerText", "headerText")]
-    public void ListViewGroupCollection_Add_StringString_Success(string key, string headerText, string expectedHeaderText)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(key, headerText);
-
-        ListViewGroup group = Assert.Single(collection.Cast<ListViewGroup>());
-        Assert.Equal(key, group.Name);
-        Assert.Equal(expectedHeaderText, group.Header);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListAdd_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewGroupCollection_IListAdd_NotListViewGroup_ThrowsArgumentException(object value)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        Assert.Throws<ArgumentException>("value", () => collection.Add(value));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_AddRange_ListViewGroupArray_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        var items = new ListViewGroup[] { group1, group2 };
-        collection.AddRange(items);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Same(group1, collection[0]);
-        Assert.Same(group2, collection[1]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_AddRange_ListViewGroupCollection_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        using var otherListView = new ListView();
-        ListViewGroupCollection otherCollection = listView.Groups;
-
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        otherCollection.Add(group1);
-        otherCollection.Add(group2);
-
-        collection.AddRange(otherCollection);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Same(group1, collection[0]);
-        Assert.Same(group2, collection[1]);
-        Assert.Equal(2, otherCollection.Count);
-        Assert.Same(group1, otherCollection[0]);
-        Assert.Same(group2, otherCollection[1]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_AddRange_NullGroups_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Throws<ArgumentNullException>("groups", () => collection.AddRange((ListViewGroup[])null));
-        Assert.Throws<ArgumentNullException>("groups", () => collection.AddRange((ListViewGroupCollection)null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_AddRange_NullValueInGroups_ThrowsArgumentNullException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        Assert.Throws<ArgumentNullException>("group", () => collection.AddRange(new ListViewGroup[] { group, null }));
-        Assert.Same(group, Assert.Single(collection.Cast<ListViewGroup>()));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Clear_Invoke_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Clear_InvokeListViewHasHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Clear_Empty_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Contains_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        Assert.True(collection.Contains(group));
-        Assert.False(collection.Contains(new ListViewGroup()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Contains_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        Assert.False(collection.Contains(new ListViewGroup()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListContains_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        Assert.True(collection.Contains(group));
-        Assert.False(collection.Contains(new ListViewGroup()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListContains_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-
-        Assert.False(collection.Contains(new ListViewGroup()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        Assert.Equal(0, collection.IndexOf(group));
-        Assert.Equal(-1, collection.IndexOf(new ListViewGroup()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IndexOf_Empty_ReturnsFalse()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        Assert.Equal(-1, collection.IndexOf(new ListViewGroup()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListIndexOf_Invoke_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        Assert.Equal(0, collection.IndexOf(group));
-        Assert.Equal(-1, collection.IndexOf(new ListViewGroup()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListIndexOf_Empty_ReturnsMinusOne()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-
-        Assert.Equal(-1, collection.IndexOf(new ListViewGroup()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(new ListViewGroup());
-        collection.Insert(1, group);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(group, collection[1]);
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_ListViewGroupWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(new ListViewGroup());
-        collection.Insert(1, group);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(group, collection[1]);
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_ListViewGroupWithItems_Success()
-    {
-        using var listView = new ListView();
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem());
-        group.Items.Add(item);
-        listView.Items.Add(item);
-
-        collection.Insert(0, group);
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_ListViewGroupWithItemsWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        var item = new ListViewItem();
-
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem());
-        group.Items.Add(item);
-        listView.Items.Add(item);
-
-        collection.Insert(0, group);
-        Assert.Same(group, Assert.Single(collection));
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_AlreadyInOtherCollection_GetReturnsExpected()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-
-        using var otherListView = new ListView();
-        ListViewGroupCollection otherCollection = otherListView.Groups;
-
-        var group = new ListViewGroup();
-        otherCollection.Add(group);
-
-        // The group appears to belong to two list views.
-        collection.Insert(0, group);
-        Assert.Same(group, collection[0]);
-        Assert.Same(listView, group.ListView);
-        Assert.Equal(group, collection[0]);
-        Assert.Equal(group, Assert.Single(otherCollection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_Insert_SetAlreadyInCollection_Nop(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-
-        var group1 = new ListViewGroup();
-        var group2 = new ListViewGroup();
-        collection.Add(group1);
-        collection.Add(group2);
-
-        collection.Insert(index, group2);
-        Assert.Same(group1, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Insert_HasItemsFromOtherListView_ThrowsArgumentException()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        using var otherListView = new ListView();
-
-        var item = new ListViewItem();
-        var group = new ListViewGroup();
-        group.Items.Add(item);
-        otherListView.Items.Add(item);
-
-        Assert.Throws<ArgumentException>(() => collection.Insert(0, group));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ListViewGroupCollection_Insert_NullGroup_ThrowsArgumentNullException(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        collection.Add(new ListViewGroup());
-        Assert.Throws<ArgumentNullException>("group", () => collection.Insert(index, null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, new ListViewGroup()));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListInsert_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(new ListViewGroup());
-        collection.Insert(1, group);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(group, collection[1]);
-        Assert.Same(listView, group.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewGroupCollection_IListInsert_InvalidItem_Nop(object value)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        collection.Insert(-1, value);
-        collection.Insert(0, value);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_IListInsert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, new ListViewGroup()));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Remove_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        // Remove null.
-        collection.Remove(null);
-        Assert.Same(group, Assert.Single(collection));
-
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-
-        // Remove again.
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_Remove_ListViewGroupWithHandle_Success()
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        // Remove null.
-        collection.Remove(null);
-        Assert.Same(group, Assert.Single(collection));
-
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-
-        // Remove again.
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_IListRemove_ListViewGroup_Success()
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-
-        // Remove again.
-        collection.Remove(group);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewGroupCollection_IListRemove_InvalidItem_Nop(object value)
-    {
-        using var listView = new ListView();
-        IList collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        collection.Remove(value);
-        Assert.Same(group, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_RemoveAt_ValidIndex_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-        collection.Add(new ListViewGroup());
-        collection.Add(new ListViewGroup());
-        collection.Add(new ListViewGroup());
-
-        // Remove from start.
-        collection.RemoveAt(0);
-        Assert.Equal(3, collection.Count);
-
-        // Remove from middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-
-        // Remove from end.
-        collection.RemoveAt(1);
-        Assert.Single(collection);
-
-        // Remove only.
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(group.ListView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewGroupCollection_RemoveAt_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_CopyTo_NonEmpty_Success()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var group = new ListViewGroup();
-        collection.Add(group);
-
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, group, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroupCollection_CopyTo_Empty_Nop()
-    {
-        using var listView = new ListView();
-        ListViewGroupCollection collection = listView.Groups;
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 0);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewGroupCollection_Add_Group_DoesNotWork_IfVirtualMode(bool createControl)
-    {
-        using var listView = new ListView() { VirtualMode = true };
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Throws<InvalidOperationException>(() => listView.Groups.Add(new ListViewGroup()));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewGroupCollection_Add_Key_HeaderText_DoesNotWork_IfVirtualMode(bool createControl)
-    {
-        using var listView = new ListView() { VirtualMode = true };
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Throws<InvalidOperationException>(() => listView.Groups.Add(key: "key", headerText: "text"));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewGroupCollection_AddRange_GroupsArray_DoesNotWork_IfVirtualMode(bool createControl)
-    {
-        using var listView = new ListView() { VirtualMode = true };
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Throws<InvalidOperationException>(() => listView.Groups.AddRange(new ListViewGroup[] { new(), new() }));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewGroupCollection_AddRange_ListViewGroupCollection_DoesNotWork_IfVirtualMode(bool createControl)
-    {
-        using var listView = new ListView() { VirtualMode = true };
-        using var listViewSource = new ListView();
-        ListViewGroupCollection sourceGroup = new(listViewSource);
-        sourceGroup.AddRange(new ListViewGroup[] { new(), new() });
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Throws<InvalidOperationException>(() => listView.Groups.AddRange(sourceGroup));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewGroupCollection_Insert_DoesNotWork_IfVirtualMode(bool createControl)
-    {
-        using var listView = new ListView() { VirtualMode = true };
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        Assert.Throws<InvalidOperationException>(() => listView.Groups.Insert(0, new ListViewGroup()));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupConverterTests.cs
deleted file mode 100644
index 005a3b80d12..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupConverterTests.cs
+++ /dev/null
@@ -1,307 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewGroupConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(ListViewGroup), false)]
-    [InlineData(typeof(string), false)]
-    public void ListViewGroupConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> CanConvertFrom_Context_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { new object(), false };
-        yield return new object[] { new ListViewItem(), true };
-
-        var listView = new ListView();
-        var item1 = new ListViewItem();
-        listView.Items.Add(item1);
-        yield return new object[] { item1, true };
-
-        var listViewWithGroups = new ListView();
-        var group = new ListViewGroup("name", "header");
-        listViewWithGroups.Groups.Add(group);
-        var item2 = new ListViewItem();
-        listViewWithGroups.Items.Add(item2);
-        yield return new object[] { item2, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanConvertFrom_Context_TestData))]
-    public void ListViewGroupConverter_CanConvertFrom_Context_ReturnsExpected(object instance, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(instance);
-        Assert.Equal(expected, converter.CanConvertFrom(mockContext.Object, typeof(string)));
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("(none)")]
-    public void ListViewGroupConverter_ConvertFrom_EmptyValue_ReturnsNull(string value)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Null(converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("header")]
-    [InlineData("  header  ")]
-    public void ListViewGroupConverter_ConvertFrom_ValidContext_ReturnsExpected(string value)
-    {
-        var listView = new ListView();
-        var group = new ListViewGroup("name", "header");
-        listView.Groups.Add(group);
-        var item = new ListViewItem();
-        listView.Items.Add(item);
-
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(item);
-        Assert.Same(group, converter.ConvertFrom(mockContext.Object, null, value));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_InvalidContext_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new ListViewItem() };
-
-        var listView = new ListView();
-        var item1 = new ListViewItem();
-        listView.Items.Add(item1);
-        yield return new object[] { item1 };
-
-        var listViewWithGroups = new ListView();
-        listViewWithGroups.Groups.Add(new ListViewGroup("name", "header"));
-        var item2 = new ListViewItem();
-        listViewWithGroups.Items.Add(item2);
-        yield return new object[] { item2 };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_InvalidContext_TestData))]
-    public void ListViewGroupConverter_ConvertFrom_InvalidContext_ThrowsNotSupportedException(object instance)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(instance);
-
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(mockContext.Object, null, "value"));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(mockContext.Object, null, "HEADER"));
-    }
-
-    [Theory]
-    [InlineData("(NONE)")]
-    [InlineData("value")]
-    [InlineData(1)]
-    public void ListViewGroupConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(ListViewGroup), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void ListViewGroupConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    public static IEnumerable<object[]> CanConvertTo_Context_TestData()
-    {
-        yield return new object[] { null, true };
-        yield return new object[] { new object(), true };
-        yield return new object[] { new ListViewItem(), true };
-
-        var listView = new ListView();
-        var item1 = new ListViewItem();
-        listView.Items.Add(item1);
-        yield return new object[] { item1, true };
-
-        var listViewWithGroups = new ListView();
-        var group = new ListViewGroup("name", "header");
-        listViewWithGroups.Groups.Add(group);
-        var item2 = new ListViewItem();
-        listViewWithGroups.Items.Add(item2);
-        yield return new object[] { item2, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(CanConvertTo_Context_TestData))]
-    public void ListViewGroupConverter_CanConvertTo_Context_ReturnsExpected(object instance, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(instance);
-        Assert.Equal(expected, converter.CanConvertTo(mockContext.Object, typeof(string)));
-    }
-
-    public static IEnumerable<object[]> ConvertTo_InstanceDescriptor_TestData()
-    {
-        yield return new object[]
-        {
-            new ListViewGroup(),
-            new Type[] { typeof(string), typeof(HorizontalAlignment) },
-            new object[] { "ListViewGroup", HorizontalAlignment.Left }
-        };
-        yield return new object[]
-        {
-            new ListViewGroup("key", "headerText"),
-            new Type[] { typeof(string), typeof(HorizontalAlignment) },
-            new object[] { "headerText", HorizontalAlignment.Left }
-        };
-        yield return new object[]
-        {
-            new ListViewGroup("header"),
-            new Type[] { typeof(string), typeof(HorizontalAlignment) },
-            new object[] { "header", HorizontalAlignment.Left }
-        };
-        yield return new object[]
-        {
-            new ListViewGroup("header", HorizontalAlignment.Center),
-            new Type[] { typeof(string), typeof(HorizontalAlignment) },
-            new object[] { "header", HorizontalAlignment.Center }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertTo_InstanceDescriptor_TestData))]
-    public void ListViewGroupConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ListViewGroup value, Type[] parameterTypes, object[] arguments)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(ListViewGroup).GetConstructor(parameterTypes), descriptor.MemberInfo);
-        Assert.Equal(arguments, descriptor.Arguments);
-    }
-
-    [Theory]
-    [InlineData(null, "(none)")]
-    [InlineData(1, "1")]
-    public void ListViewGroupConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_ConvertTo_ValueNotThrowsNotSupportedException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(ListViewGroup))]
-    [InlineData(typeof(int))]
-    public void ListViewGroupConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewGroup(), destinationType));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_GetPropertiesSupported_Invoke_ReturnsFalse()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.False(converter.GetPropertiesSupported(null));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_GetProperties_Invoke_ReturnsNull()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var item = new ListViewGroup();
-        Assert.Null(converter.GetProperties(null, item, null));
-    }
-
-    public static IEnumerable<object[]> GetStandardValues_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), null };
-        yield return new object[] { new ListViewItem(), null };
-
-        var listView = new ListView();
-        var item1 = new ListViewItem();
-        listView.Items.Add(item1);
-        yield return new object[] { item1, new object[] { null } };
-
-        var listViewWithGroups = new ListView();
-        var group = new ListViewGroup("name", "header");
-        listViewWithGroups.Groups.Add(group);
-        var item2 = new ListViewItem();
-        listViewWithGroups.Items.Add(item2);
-        yield return new object[] { item2, new object[] { group, null } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetStandardValues_TestData))]
-    public void ListViewGroupConverter_GetStandardValues_HasContext_ReturnsExpected(object instance, object[] expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(instance);
-        Assert.Equal(expected, converter.GetStandardValues(mockContext.Object)?.Cast<object>());
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_GetStandardValues_NullContext_ReturnsNull()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.Null(converter.GetStandardValues(null));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_GetStandardValuesExclusive_Invoke_ReturnsTrue()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.True(converter.GetStandardValuesExclusive(null));
-    }
-
-    [Fact]
-    public void ListViewGroupConverter_GetStandardValuesSupported_Invoke_ReturnsTrue()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewGroup));
-        Assert.True(converter.GetStandardValuesSupported(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupEventArgsTests.cs
deleted file mode 100644
index e32d51e7109..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewGroupEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int groupIndex)
-    {
-        var args = new ListViewGroupEventArgs(groupIndex);
-        Assert.Equal(groupIndex, args.GroupIndex);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupTests.cs
deleted file mode 100644
index f9b93ce482c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewGroupTests.cs
+++ /dev/null
@@ -1,1453 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
-using Microsoft.DotNet.RemoteExecutor;
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewGroupTests
-{
-    [WinFormsFact]
-    public void ListViewGroup_Ctor_Default()
-    {
-        var group = new ListViewGroup();
-        Assert.Empty(group.Footer);
-        Assert.Equal(HorizontalAlignment.Left, group.FooterAlignment);
-        Assert.Equal("ListViewGroup", group.Header);
-        Assert.Equal(HorizontalAlignment.Left, group.HeaderAlignment);
-        Assert.Empty(group.Subtitle);
-        Assert.Empty(group.Items);
-        Assert.Same(group.Items, group.Items);
-        Assert.Null(group.ListView);
-        Assert.Null(group.Name);
-        Assert.Null(group.Tag);
-        Assert.Equal(ListViewGroupCollapsedState.Default, group.CollapsedState);
-        Assert.Empty(group.TaskLink);
-        Assert.Empty(group.TitleImageKey);
-        Assert.Equal(-1, group.TitleImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewGroup_Ctor_String(string header, string expectedHeader)
-    {
-        var group = new ListViewGroup(header);
-        Assert.Empty(group.Footer);
-        Assert.Equal(HorizontalAlignment.Left, group.FooterAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.Equal(HorizontalAlignment.Left, group.HeaderAlignment);
-        Assert.Empty(group.Subtitle);
-        Assert.Empty(group.Items);
-        Assert.Same(group.Items, group.Items);
-        Assert.Null(group.ListView);
-        Assert.Null(group.Name);
-        Assert.Null(group.Tag);
-        Assert.Equal(ListViewGroupCollapsedState.Default, group.CollapsedState);
-        Assert.Empty(group.TaskLink);
-        Assert.Empty(group.TitleImageKey);
-        Assert.Equal(-1, group.TitleImageIndex);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_HorizontalAlignment_TestData()
-    {
-        yield return new object[] { null, HorizontalAlignment.Left, string.Empty };
-        yield return new object[] { string.Empty, HorizontalAlignment.Right, string.Empty };
-        yield return new object[] { "reasonable", HorizontalAlignment.Center, "reasonable" };
-        yield return new object[] { "reasonable", (HorizontalAlignment)(HorizontalAlignment.Left - 1), "reasonable" };
-        yield return new object[] { "reasonable", (HorizontalAlignment)(HorizontalAlignment.Center + 1), "reasonable" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_HorizontalAlignment_TestData))]
-    public void ListViewGroup_Ctor_String_HorizontalAlignment(string header, HorizontalAlignment headerAlignment, string expectedHeader)
-    {
-        var group = new ListViewGroup(header, headerAlignment);
-        Assert.Empty(group.Footer);
-        Assert.Equal(HorizontalAlignment.Left, group.FooterAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.Equal(headerAlignment, group.HeaderAlignment);
-        Assert.Empty(group.Subtitle);
-        Assert.Empty(group.Items);
-        Assert.Equal(group.Items, group.Items);
-        Assert.Null(group.ListView);
-        Assert.Null(group.Name);
-        Assert.Null(group.Tag);
-        Assert.Equal(ListViewGroupCollapsedState.Default, group.CollapsedState);
-        Assert.Empty(group.TaskLink);
-        Assert.Empty(group.TitleImageKey);
-        Assert.Equal(-1, group.TitleImageIndex);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "key", "header", "header" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_String_TestData))]
-    public void ListViewGroup_Ctor_String_String(string key, string header, string expectedHeader)
-    {
-        var group = new ListViewGroup(key, header);
-        Assert.Empty(group.Footer);
-        Assert.Equal(HorizontalAlignment.Left, group.FooterAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.Equal(HorizontalAlignment.Left, group.HeaderAlignment);
-        Assert.Empty(group.Subtitle);
-        Assert.Empty(group.Items);
-        Assert.Same(group.Items, group.Items);
-        Assert.Null(group.ListView);
-        Assert.Equal(key, group.Name);
-        Assert.Null(group.Tag);
-        Assert.Equal(ListViewGroupCollapsedState.Default, group.CollapsedState);
-        Assert.Empty(group.TaskLink);
-        Assert.Empty(group.TitleImageKey);
-        Assert.Equal(-1, group.TitleImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ListViewGroupCollapsedState.Default)]
-    [InlineData(ListViewGroupCollapsedState.Collapsed)]
-    [InlineData(ListViewGroupCollapsedState.Expanded)]
-    public void ListViewGroup_GetNativeCollapsedState_Succeeds(ListViewGroupCollapsedState collapsedState)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup() { CollapsedState = collapsedState };
-        listView.Groups.Add(group);
-
-        Assert.Equal(collapsedState, group.GetNativeCollapsedState());
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_GetNativeCollapsedState_NoListView_Throws()
-    {
-        var group = new ListViewGroup();
-        Assert.Throws<InvalidOperationException>(() => group.GetNativeCollapsedState());
-    }
-
-    [WinFormsTheory]
-    [PositiveIntegerData<int>]
-    [InlineData(-1)]
-    public void ListViewGroup_TitleImageIndex_SetWithoutListView_GetReturnsExpected(int value)
-    {
-        var group = new ListViewGroup
-        {
-            TitleImageIndex = value
-        };
-
-        Assert.Equal(value, group.TitleImageIndex);
-
-        // Set same.
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-    }
-
-    [WinFormsTheory]
-    [PositiveIntegerData<int>]
-    [InlineData(-1)]
-    public void ListViewGroup_TitleImageIndex_SetWithListView_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [PositiveIntegerData<int>]
-    [InlineData(-1)]
-    public void ListViewGroup_TitleImageIndex_SetWithListViewWithHandle_GetReturnsExpected(int value)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    // Need to verify test once RE fixed.
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_TitleImageIndex_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            var data = new (int, int)[] { (-1, -1), (0, 0), (1, 1), (2, -1) };
-            foreach ((int Index, int Expected) value in data)
-            {
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-
-                using var groupImageList = new ImageList();
-                groupImageList.Images.Add(new Bitmap(10, 10));
-                groupImageList.Images.Add(new Bitmap(20, 20));
-                listView.GroupImageList = groupImageList;
-                Assert.Equal((nint)groupImageList.Handle,
-                    PInvoke.SendMessage(listView, PInvoke.LVM_SETIMAGELIST, (WPARAM)(uint)PInvoke.LVSIL_GROUPHEADER, groupImageList.Handle));
-
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.TitleImageIndex = value.Index;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.TITLEIMAGE | LVGF.GROUPID,
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(value.Expected, lvgroup.iTitleImage);
-                Assert.True(lvgroup.iGroupId >= 0);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_TitleImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException()
-    {
-        var random = new Random();
-        int value = random.Next(2, int.MaxValue) * -1;
-        var group = new ListViewGroup();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => group.TitleImageIndex = value);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewGroup_TitleImageIndex_SetTitleImageKey_GetReturnsExpected(string key, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            TitleImageIndex = 0
-        };
-
-        Assert.Equal(0, group.TitleImageIndex);
-
-        // verify TitleImageIndex resets to default once TitleImageKey is set
-        group.TitleImageKey = key;
-        Assert.Equal(expected, group.TitleImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, group.TitleImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_TitleImageKey_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            TitleImageKey = value
-        };
-
-        Assert.Equal(expected, group.TitleImageKey);
-
-        // Set same.
-        group.TitleImageKey = value;
-        Assert.Equal(expected, group.TitleImageKey);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_TitleImageKey_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.TitleImageKey = value;
-        Assert.Equal(expected, group.TitleImageKey);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.TitleImageKey = value;
-        Assert.Equal(expected, group.TitleImageKey);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("header", "header")]
-    [InlineData("te\0xt", "te\0xt")]
-    [InlineData("ListViewGroup", "ListViewGroup")]
-    public void ListViewGroup_TitleImageKey_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.TitleImageKey = value;
-        Assert.Equal(expected, group.TitleImageKey);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.TitleImageKey = value;
-        Assert.Equal(expected, group.TitleImageKey);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    // Need to verify test once RE fixed.
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_TitleImageKey_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            var data = new (string, int)[] { (null, -1), (string.Empty, -1), ("text", 0), ("te\0t", 0) };
-            foreach ((string Key, int ExpectedIndex) value in data)
-            {
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-
-                using var groupImageList = new ImageList();
-                groupImageList.Images.Add(value.Key, new Bitmap(10, 10));
-                listView.GroupImageList = groupImageList;
-                Assert.Equal((nint)groupImageList.Handle,
-                    PInvoke.SendMessage(listView, PInvoke.LVM_SETIMAGELIST, (WPARAM)(uint)PInvoke.LVSIL_GROUPHEADER, groupImageList.Handle));
-
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.TitleImageKey = value.Key;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.TITLEIMAGE | LVGF.GROUPID
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(value.ExpectedIndex, lvgroup.iTitleImage);
-                Assert.True(lvgroup.iGroupId >= 0);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [PositiveIntegerData<int>]
-    [InlineData(-1)]
-    public void ListViewGroup_TitleImageKey_SetTitleImageIndex_GetReturnsExpected(int value)
-    {
-        var group = new ListViewGroup
-        {
-            TitleImageKey = "key"
-        };
-
-        Assert.Equal("key", group.TitleImageKey);
-
-        // verify TitleImageKey resets to default once TitleImageIndex is set
-        group.TitleImageIndex = value;
-        Assert.Equal(value, group.TitleImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, group.TitleImageKey);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Subtitle_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            Subtitle = value
-        };
-
-        Assert.Equal(expected, group.Subtitle);
-
-        // Set same.
-        group.Subtitle = value;
-        Assert.Equal(expected, group.Subtitle);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Subtitle_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.Subtitle = value;
-        Assert.Equal(expected, group.Subtitle);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.Subtitle = value;
-        Assert.Equal(expected, group.Subtitle);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("header", "header")]
-    [InlineData("te\0xt", "te\0xt")]
-    [InlineData("ListViewGroup", "ListViewGroup")]
-    public void ListViewGroup_Subtitle_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.Subtitle = value;
-        Assert.Equal(expected, group.Subtitle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.Subtitle = value;
-        Assert.Equal(expected, group.Subtitle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Property_TypeString_GetGroupInfo_TestData()
-    {
-        yield return new object[] { null, string.Empty };
-        yield return new object[] { string.Empty, string.Empty };
-        yield return new object[] { "text", "text" };
-        yield return new object[] { "te\0t", "te" };
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_Subtitle_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            // This needs to be initialized out of the loop.
-            char* buffer = stackalloc char[256];
-
-            foreach (object[] data in Property_TypeString_GetGroupInfo_TestData())
-            {
-                string value = (string)data[0];
-                string expected = (string)data[1];
-
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.Subtitle = value;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.SUBTITLE | LVGF.GROUPID,
-                    pszSubtitle = buffer,
-                    cchSubtitle = 256
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(expected, new string(lvgroup.pszSubtitle));
-                Assert.True(lvgroup.iGroupId >= 0);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Footer_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            Footer = value
-        };
-
-        Assert.Equal(expected, group.Footer);
-
-        // Set same.
-        group.Footer = value;
-        Assert.Equal(expected, group.Footer);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Footer_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.Footer = value;
-        Assert.Equal(expected, group.Footer);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.Footer = value;
-        Assert.Equal(expected, group.Footer);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("header", "header")]
-    [InlineData("te\0xt", "te\0xt")]
-    [InlineData("ListViewGroup", "ListViewGroup")]
-    public void ListViewGroup_Footer_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.Footer = value;
-        Assert.Equal(expected, group.Footer);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.Footer = value;
-        Assert.Equal(expected, group.Footer);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_Footer_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] data in Property_TypeString_GetGroupInfo_TestData())
-            {
-                string value = (string)data[0];
-                string expected = (string)data[1];
-
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.Footer = value;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                char* buffer = stackalloc char[256];
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.FOOTER | LVGF.GROUPID | LVGF.ALIGN,
-                    pszFooter = buffer,
-                    cchFooter = 256
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(expected, new string(lvgroup.pszFooter));
-                Assert.True(lvgroup.iGroupId >= 0);
-                Assert.Equal(LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT | LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT, lvgroup.uAlign);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    public static IEnumerable<object[]> Alignment_Set_TestData()
-    {
-        foreach (HorizontalAlignment value in Enum.GetValues(typeof(HorizontalAlignment)))
-        {
-            yield return new object[] { null, value, string.Empty };
-            yield return new object[] { string.Empty, value, string.Empty };
-            yield return new object[] { "text", value, "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_FooterAlignment_SetWithoutListView_GetReturnsExpected(string footer, HorizontalAlignment value, string expectedFooter)
-    {
-        var group = new ListViewGroup
-        {
-            Footer = footer,
-            FooterAlignment = value
-        };
-
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-
-        // Set same.
-        group.FooterAlignment = value;
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_FooterAlignment_SetWithListView_GetReturnsExpected(string footer, HorizontalAlignment value, string expectedFooter)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            Footer = footer
-        };
-
-        listView.Groups.Add(group);
-
-        group.FooterAlignment = value;
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.FooterAlignment = value;
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_FooterAlignment_SetWithListViewWithHandle_GetReturnsExpected(string footer, HorizontalAlignment value, string expectedFooter)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            Footer = footer
-        };
-
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.FooterAlignment = value;
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.FooterAlignment = value;
-        Assert.Equal(value, group.FooterAlignment);
-        Assert.Equal(expectedFooter, group.Footer);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> FooterAlignment_GetGroupInfo_TestData()
-    {
-        yield return new object[] { string.Empty, HorizontalAlignment.Left, 0x00000008 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-        yield return new object[] { string.Empty, HorizontalAlignment.Center, 0x00000010 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-        yield return new object[] { string.Empty, HorizontalAlignment.Right, 0x00000020 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-
-        yield return new object[] { "footer", HorizontalAlignment.Left, 0x00000008 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-        yield return new object[] { "footer", HorizontalAlignment.Center, 0x00000010 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-        yield return new object[] { "footer", HorizontalAlignment.Right, 0x00000020 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT };
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [MemberData(nameof(FooterAlignment_GetGroupInfo_TestData))]
-    public unsafe void ListView_FooterAlignment_GetGroupInfo_Success(string footerParam, HorizontalAlignment valueParam, int expectedAlignParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((footer, valueString, expectedAlignString) =>
-        {
-            HorizontalAlignment value = (HorizontalAlignment)Enum.Parse(typeof(HorizontalAlignment), valueString);
-            int expectedAlign = int.Parse(expectedAlignString);
-
-            Application.EnableVisualStyles();
-            using var listView = new ListView();
-            var group1 = new ListViewGroup
-            {
-                Footer = footer
-            };
-
-            listView.Groups.Add(group1);
-
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-            group1.FooterAlignment = value;
-
-            Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-            char* buffer = stackalloc char[256];
-            var lvgroup = new LVGROUPW
-            {
-                cbSize = (uint)sizeof(LVGROUPW),
-                mask = LVGF.FOOTER | LVGF.GROUPID | LVGF.ALIGN,
-                pszFooter = buffer,
-                cchFooter = 256
-            };
-
-            Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-            Assert.Equal(footer, new string(lvgroup.pszFooter));
-            Assert.True(lvgroup.iGroupId >= 0);
-            Assert.Equal(expectedAlign, (int)lvgroup.uAlign);
-        }, footerParam, valueParam.ToString(), expectedAlignParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void ListViewGroup_FooterAlignment_SetInvalid_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
-    {
-        var group = new ListViewGroup();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => group.FooterAlignment = value);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Header_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            Header = value
-        };
-
-        Assert.Equal(expected, group.Header);
-
-        // Set same.
-        group.Header = value;
-        Assert.Equal(expected, group.Header);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Header_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.Header = value;
-        Assert.Equal(expected, group.Header);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.Header = value;
-        Assert.Equal(expected, group.Header);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("header", "header")]
-    [InlineData("te\0xt", "te\0xt")]
-    [InlineData("ListViewGroup", "ListViewGroup")]
-    public void ListViewGroup_Header_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.Header = value;
-        Assert.Equal(expected, group.Header);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.Header = value;
-        Assert.Equal(expected, group.Header);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_Header_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] data in Property_TypeString_GetGroupInfo_TestData())
-            {
-                string value = (string)data[0];
-                string expected = (string)data[1];
-
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.Header = value;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                char* buffer = stackalloc char[256];
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.HEADER | LVGF.GROUPID | LVGF.ALIGN,
-                    pszHeader = buffer,
-                    cchHeader = 256
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(expected, new string(lvgroup.pszHeader));
-                Assert.True(lvgroup.iGroupId >= 0);
-                Assert.Equal(LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_HEADER_LEFT | LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT, lvgroup.uAlign);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_HeaderAlignment_SetWithoutListView_GetReturnsExpected(string header, HorizontalAlignment value, string expectedHeader)
-    {
-        var group = new ListViewGroup
-        {
-            Header = header,
-            HeaderAlignment = value
-        };
-
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-
-        // Set same.
-        group.HeaderAlignment = value;
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_HeaderAlignment_SetWithListView_GetReturnsExpected(string header, HorizontalAlignment value, string expectedHeader)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            Header = header
-        };
-
-        listView.Groups.Add(group);
-
-        group.HeaderAlignment = value;
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.HeaderAlignment = value;
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void ListViewGroup_HeaderAlignment_SetWithListViewWithHandle_GetReturnsExpected(string header, HorizontalAlignment value, string expectedHeader)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            Header = header
-        };
-
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.HeaderAlignment = value;
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.HeaderAlignment = value;
-        Assert.Equal(value, group.HeaderAlignment);
-        Assert.Equal(expectedHeader, group.Header);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> HeaderAlignment_GetGroupInfo_TestData()
-    {
-        yield return new object[] { string.Empty, HorizontalAlignment.Left, 0x00000001 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-        yield return new object[] { string.Empty, HorizontalAlignment.Center, 0x00000002 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-        yield return new object[] { string.Empty, HorizontalAlignment.Right, 0x00000004 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-
-        yield return new object[] { "header", HorizontalAlignment.Left, 0x00000001 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-        yield return new object[] { "header", HorizontalAlignment.Center, 0x00000002 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-        yield return new object[] { "header", HorizontalAlignment.Right, 0x00000004 | (int)LIST_VIEW_GROUP_ALIGN_FLAGS.LVGA_FOOTER_LEFT };
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [MemberData(nameof(HeaderAlignment_GetGroupInfo_TestData))]
-    public unsafe void ListView_HeaderAlignment_GetGroupInfo_Success(string headerParam, HorizontalAlignment valueParam, int expectedAlignParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((header, valueString, expectedAlignString) =>
-        {
-            HorizontalAlignment value = (HorizontalAlignment)Enum.Parse(typeof(HorizontalAlignment), valueString);
-            int expectedAlign = int.Parse(expectedAlignString);
-
-            Application.EnableVisualStyles();
-            using var listView = new ListView();
-            var group1 = new ListViewGroup
-            {
-                Header = header
-            };
-
-            listView.Groups.Add(group1);
-
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-            group1.HeaderAlignment = value;
-
-            Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-            char* buffer = stackalloc char[256];
-            var lvgroup = new LVGROUPW
-            {
-                cbSize = (uint)sizeof(LVGROUPW),
-                mask = LVGF.HEADER | LVGF.GROUPID | LVGF.ALIGN,
-                pszHeader = buffer,
-                cchHeader = 256
-            };
-
-            Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-            Assert.Equal(header, new string(lvgroup.pszHeader));
-            Assert.True(lvgroup.iGroupId >= 0);
-            Assert.Equal(expectedAlign, (int)lvgroup.uAlign);
-        }, headerParam, valueParam.ToString(), expectedAlignParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void ListViewGroup_HeaderAlignment_SetInvalid_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
-    {
-        var group = new ListViewGroup();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => group.HeaderAlignment = value);
-    }
-
-    public static IEnumerable<object[]> CollapsedState_TestData()
-    {
-        yield return new object[] { ListViewGroupCollapsedState.Default, ListViewGroupCollapsedState.Default };
-        yield return new object[] { ListViewGroupCollapsedState.Expanded, ListViewGroupCollapsedState.Expanded };
-        yield return new object[] { ListViewGroupCollapsedState.Collapsed, ListViewGroupCollapsedState.Collapsed };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CollapsedState_TestData))]
-    public void ListViewGroup_Collapse_SetWithoutListView_GetReturnsExpected(ListViewGroupCollapsedState value, ListViewGroupCollapsedState expected)
-    {
-        var group = new ListViewGroup()
-        {
-            CollapsedState = value
-        };
-
-        Assert.Equal(expected, group.CollapsedState);
-
-        // Set same.
-        group.CollapsedState = value;
-        Assert.Equal(expected, group.CollapsedState);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CollapsedState_TestData))]
-    public void ListViewGroup_Collapse_SetWithListView_GetReturnsExpected(ListViewGroupCollapsedState value, ListViewGroupCollapsedState expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            CollapsedState = value
-        };
-
-        listView.Groups.Add(group);
-
-        Assert.Equal(expected, group.CollapsedState);
-        Assert.Equal(group.CollapsedState, listView.Groups[0].CollapsedState);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.CollapsedState = value;
-        Assert.Equal(expected, group.CollapsedState);
-        Assert.Equal(group.CollapsedState, listView.Groups[0].CollapsedState);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CollapsedState_TestData))]
-    public void ListViewGroup_Collapse_SetWithListViewWithHandle_GetReturnsExpected(ListViewGroupCollapsedState value, ListViewGroupCollapsedState expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup
-        {
-            CollapsedState = value
-        };
-
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, group.CollapsedState);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.CollapsedState = value;
-        Assert.Equal(expected, group.CollapsedState);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_Collapse_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            foreach (object[] data in CollapsedState_TestData())
-            {
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.CollapsedState = (ListViewGroupCollapsedState)data[0];
-                ListViewGroupCollapsedState expectedCollapsedState = (ListViewGroupCollapsedState)data[1];
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.STATE | LVGF.GROUPID,
-                    stateMask = LIST_VIEW_GROUP_STATE_FLAGS.LVGS_COLLAPSIBLE | LIST_VIEW_GROUP_STATE_FLAGS.LVGS_COLLAPSED
-                };
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.True(lvgroup.iGroupId >= 0);
-                Assert.Equal(expectedCollapsedState, group.CollapsedState);
-                if (expectedCollapsedState == ListViewGroupCollapsedState.Default)
-                {
-                    Assert.Equal(LIST_VIEW_GROUP_STATE_FLAGS.LVGS_NORMAL, lvgroup.state);
-                }
-                else if (expectedCollapsedState == ListViewGroupCollapsedState.Expanded)
-                {
-                    Assert.Equal(LIST_VIEW_GROUP_STATE_FLAGS.LVGS_COLLAPSIBLE, lvgroup.state);
-                }
-                else
-                {
-                    Assert.Equal(LIST_VIEW_GROUP_STATE_FLAGS.LVGS_COLLAPSIBLE | LIST_VIEW_GROUP_STATE_FLAGS.LVGS_COLLAPSED, lvgroup.state);
-                }
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ListViewGroupCollapsedState>]
-    public void ListViewGroup_CollapsedState_SetInvalid_ThrowsInvalidEnumArgumentException(ListViewGroupCollapsedState value)
-    {
-        var group = new ListViewGroup();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => group.CollapsedState = value);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ListViewGroup_Name_Set_GetReturnsExpected(string value)
-    {
-        var group = new ListViewGroup
-        {
-            Name = value
-        };
-
-        Assert.Same(value, group.Name);
-
-        // Set same.
-        group.Name = value;
-        Assert.Same(value, group.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Task_SetWithoutListView_GetReturnsExpected(string value, string expected)
-    {
-        var group = new ListViewGroup
-        {
-            TaskLink = value
-        };
-
-        Assert.Equal(expected, group.TaskLink);
-
-        // Set same.
-        group.TaskLink = value;
-        Assert.Equal(expected, group.TaskLink);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("te\0xt", "te\0xt")]
-    public void ListViewGroup_Task_SetWithListView_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-
-        group.TaskLink = value;
-        Assert.Equal(expected, group.TaskLink);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        group.TaskLink = value;
-        Assert.Equal(expected, group.TaskLink);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("header", "header")]
-    [InlineData("te\0xt", "te\0xt")]
-    [InlineData("ListViewGroup", "ListViewGroup")]
-    public void ListViewGroup_Task_SetWithListViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var listView = new ListView();
-        var group = new ListViewGroup();
-        listView.Groups.Add(group);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        group.TaskLink = value;
-        Assert.Equal(expected, group.TaskLink);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        group.TaskLink = value;
-        Assert.Equal(expected, group.TaskLink);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewGroup_Task_GetGroupInfo_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            // This needs to be outside the loop.
-            char* buffer = stackalloc char[256];
-
-            foreach (object[] data in Property_TypeString_GetGroupInfo_TestData())
-            {
-                string value = (string)data[0];
-                string expected = (string)data[1];
-
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView();
-                var group = new ListViewGroup();
-                listView.Groups.Add(group);
-
-                Assert.NotEqual(IntPtr.Zero, listView.Handle);
-                group.TaskLink = value;
-
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-                var lvgroup = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.TASK | LVGF.GROUPID,
-                    pszTask = buffer,
-                    cchTask = 256
-                };
-
-                Assert.Equal(1, PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup));
-                Assert.Equal(expected, new string(lvgroup.pszTask));
-                Assert.True(lvgroup.iGroupId >= 0);
-            }
-        });
-
-        // Verify the remote process succeeded.
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ListViewGroup_Tag_Set_GetReturnsExpected(string value)
-    {
-        var group = new ListViewGroup
-        {
-            Tag = value
-        };
-
-        Assert.Same(value, group.Tag);
-
-        // Set same.
-        group.Tag = value;
-        Assert.Same(value, group.Tag);
-    }
-
-    public static IEnumerable<object[]> Serialize_Deserialize_TestData()
-    {
-        yield return new object[] { new ListViewGroup() };
-        yield return new object[] { new ListViewGroup("header", HorizontalAlignment.Center) { Name = "name", Tag = "tag" } };
-
-        var groupWithEmptyItems = new ListViewGroup();
-        Assert.Empty(groupWithEmptyItems.Items);
-        yield return new object[] { groupWithEmptyItems };
-
-        var groupWithItems = new ListViewGroup();
-        groupWithItems.Items.Add(new ListViewItem("text"));
-        yield return new object[] { groupWithItems };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Serialize_Deserialize_TestData))]
-    public void ListViewGroup_Serialize_Deserialize_Success(ListViewGroup group)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var stream = new MemoryStream();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        var formatter = new BinaryFormatter();
-        formatter.Serialize(stream, group);
-        stream.Seek(0, SeekOrigin.Begin);
-
-        ListViewGroup result = Assert.IsType<ListViewGroup>(formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        Assert.Equal(group.Header, result.Header);
-        Assert.Equal(group.HeaderAlignment, result.HeaderAlignment);
-        Assert.Equal(group.Items.Cast<ListViewItem>().Select(i => i.Text), result.Items.Cast<ListViewItem>().Select(i => i.Text));
-        Assert.Equal(group.Name, result.Name);
-        Assert.Equal(group.Tag, result.Tag);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewGroup_ToString_Invoke_ReturnsExpected(string header, string expected)
-    {
-        var group = new ListViewGroup(header);
-        Assert.Equal(expected, group.ToString());
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_ISerializableGetObjectData_InvokeSimple_Success()
-    {
-        var group = new ListViewGroup();
-        ISerializable iSerializable = group;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal("ListViewGroup", info.GetString("Header"));
-        Assert.Equal(HorizontalAlignment.Left, info.GetValue("HeaderAlignment", typeof(HorizontalAlignment)));
-        Assert.Throws<SerializationException>(() => info.GetString("Name"));
-        Assert.Null(info.GetValue("Tag", typeof(object)));
-        Assert.Throws<SerializationException>(() => info.GetInt32("ItemsCount"));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_ISerializableGetObjectData_InvokeWithEmptyItems_Success()
-    {
-        var group = new ListViewGroup();
-        Assert.Empty(group.Items);
-
-        ISerializable iSerializable = group;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal("ListViewGroup", info.GetString("Header"));
-        Assert.Equal(HorizontalAlignment.Left, info.GetValue("HeaderAlignment", typeof(HorizontalAlignment)));
-        Assert.Throws<SerializationException>(() => info.GetString("Name"));
-        Assert.Null(info.GetValue("Tag", typeof(object)));
-        Assert.Throws<SerializationException>(() => info.GetInt32("ItemsCount"));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_ISerializableGetObjectData_InvokeWithItems_Success()
-    {
-        var group = new ListViewGroup();
-        group.Items.Add(new ListViewItem("text"));
-
-        ISerializable iSerializable = group;
-        var info = new SerializationInfo(typeof(ListViewGroup), new FormatterConverter());
-        var context = new StreamingContext();
-
-        iSerializable.GetObjectData(info, context);
-        Assert.Equal("ListViewGroup", info.GetString("Header"));
-        Assert.Equal(HorizontalAlignment.Left, info.GetValue("HeaderAlignment", typeof(HorizontalAlignment)));
-        Assert.Throws<SerializationException>(() => info.GetString("Name"));
-        Assert.Null(info.GetValue("Tag", typeof(object)));
-        Assert.Equal(1, info.GetInt32("ItemsCount"));
-        Assert.Equal("text", ((ListViewItem)info.GetValue("Item0", typeof(ListViewItem))).Text);
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_ISerializableGetObjectData_NullInfo_ThrowsArgumentNullException()
-    {
-        var group = new ListViewGroup();
-        ISerializable iSerializable = group;
-        var context = new StreamingContext();
-        Assert.Throws<ArgumentNullException>("info", () => iSerializable.GetObjectData(null, context));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_InvokeAdd_DoesNotAddTreeViewItemToList()
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem = new ListViewItem();
-        ListViewItem listViewItemGroup = new ListViewItem();
-        ListViewGroup listViewGroup = new ListViewGroup();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        listView.Groups.Add(listViewGroup);
-        listView.Items.Add(listViewItem);
-        listViewGroup.Items.Add(listViewItemGroup);
-
-        Assert.True(accessor.IsToolTracked(listViewItem));
-        Assert.False(accessor.IsToolTracked(listViewItemGroup));
-    }
-
-    [WinFormsFact]
-    public void ListViewGroup_InvokeRemove_DoesNotRemoveTreeViewItemFromList()
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem = new ListViewItem();
-        ListViewGroup listViewGroup = new ListViewGroup();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        listView.Groups.Add(listViewGroup);
-        listView.Items.Add(listViewItem);
-        listViewGroup.Items.Add(listViewItem);
-
-        Assert.True(accessor.IsToolTracked(listViewItem));
-
-        listViewGroup.Items.Remove(listViewItem);
-        Assert.True(accessor.IsToolTracked(listViewItem));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewHitTestInfoTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewHitTestInfoTests.cs
deleted file mode 100644
index 53e9ebd1aa9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewHitTestInfoTests.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewHitTestInfoTests
-{
-    public static IEnumerable<object[]> Ctor_ListViewItem_ListViewSubItem_ListViewHitTestLocations_TestData()
-    {
-        yield return new object[] { null, null, ListViewHitTestLocations.None };
-        yield return new object[] { new ListViewItem(), new ListViewItem.ListViewSubItem(), (ListViewHitTestLocations)(ListViewHitTestLocations.None - 1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewItem_ListViewSubItem_ListViewHitTestLocations_TestData))]
-    public void ListViewHitTestInfo_Ctor_ListViewItem_ListViewSubItem_ListViewHitTestLocations(ListViewItem hitItem, ListViewItem.ListViewSubItem hitSubItem, ListViewHitTestLocations hitTestLocations)
-    {
-        var info = new ListViewHitTestInfo(hitItem, hitSubItem, hitTestLocations);
-        Assert.Equal(hitItem, info.Item);
-        Assert.Equal(hitSubItem, info.SubItem);
-        Assert.Equal(hitTestLocations, info.Location);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewInsertionMarkTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewInsertionMarkTests.cs
deleted file mode 100644
index 3c3564ab89f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewInsertionMarkTests.cs
+++ /dev/null
@@ -1,627 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Microsoft.DotNet.RemoteExecutor;
-using static Interop;
-using Point = System.Drawing.Point;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewInsertionMarkTests
-{
-    [WinFormsFact]
-    public void ListViewInsertionMark_AppearsAfterItem_Get_ReturnsExpected()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.False(insertionMark.AppearsAfterItem);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListViewInsertionMark_AppearsAfterItem_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-
-        insertionMark.AppearsAfterItem = value;
-        Assert.Equal(value, insertionMark.AppearsAfterItem);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        insertionMark.AppearsAfterItem = value;
-        Assert.Equal(value, insertionMark.AppearsAfterItem);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        insertionMark.AppearsAfterItem = !value;
-        Assert.Equal(!value, insertionMark.AppearsAfterItem);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListViewInsertionMark_AppearsAfterItem_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        insertionMark.AppearsAfterItem = value;
-        Assert.Equal(value, insertionMark.AppearsAfterItem);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        insertionMark.AppearsAfterItem = value;
-        Assert.Equal(value, insertionMark.AppearsAfterItem);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        insertionMark.AppearsAfterItem = !value;
-        Assert.Equal(!value, insertionMark.AppearsAfterItem);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewInsertionMark_AppearsAfterItem_GetInsertMark_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewInsertionMark insertionMark = control.InsertionMark;
-
-            // Set same.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.AppearsAfterItem = false;
-            var insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set true.
-            control.InsertionMark.AppearsAfterItem = true;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000001, (uint)insertMark.dwFlags);
-            Assert.Equal(0, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set false.
-            control.InsertionMark.AppearsAfterItem = false;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(0, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-        }).Dispose();
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewInsertionMark_AppearsAfterItem_GetInsertMarkWithColor_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewInsertionMark insertionMark = control.InsertionMark;
-            control.InsertionMark.Color = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-
-            // Set same.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.AppearsAfterItem = false;
-            var insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set true.
-            control.InsertionMark.AppearsAfterItem = true;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000001, (uint)insertMark.dwFlags);
-            Assert.Equal(0, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set false.
-            control.InsertionMark.AppearsAfterItem = false;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(0, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Bounds_GetWithoutHandle_ReturnsEqual()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.Equal(Rectangle.Empty, insertionMark.Bounds);
-        Assert.Equal(insertionMark.Bounds, insertionMark.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Bounds_GetWithHandle_ReturnsEqual()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(Rectangle.Empty, insertionMark.Bounds);
-        Assert.Equal(insertionMark.Bounds, insertionMark.Bounds);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Bounds_GetCustomInsertMarkRect_TestData()
-    {
-        yield return new object[] { new RECT(), Rectangle.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Rectangle(1, 2, 2, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Bounds_GetCustomInsertMarkRect_TestData))]
-    public void ListViewInsertionMark_Bounds_GetCustomGetInsertMarkRect_ReturnsExpected(object getInsertMarkRectResult, Rectangle expected)
-    {
-        using var control = new CustomGetInsertMarkRectListView
-        {
-            GetInsertMarkRectResult = (RECT)getInsertMarkRectResult
-        };
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, insertionMark.Bounds);
-    }
-
-    private class CustomGetInsertMarkRectListView : ListView
-    {
-        public RECT GetInsertMarkRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LVM_GETINSERTMARKRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetInsertMarkRectResult;
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Bounds_GetInvalidGetInsertMarkRect_ReturnsExpected()
-    {
-        using var control = new InvalidGetInsertMarkRectListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Equal(new Rectangle(1, 2, 2, 2), insertionMark.Bounds);
-    }
-
-    private class InvalidGetInsertMarkRectListView : ListView
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.LVM_GETINSERTMARKRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = new RECT(1, 2, 3, 4);
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Color_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(Color.Empty, insertionMark.Color);
-        Assert.Equal(insertionMark.Color, insertionMark.Color);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Color_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.NotEqual(Color.Empty, insertionMark.Color);
-        Assert.Equal(insertionMark.Color, insertionMark.Color);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void ListViewInsertionMark_Color_SetWithoutHandle_ReturnsExpected(Color value)
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-
-        insertionMark.Color = value;
-        Assert.Equal(value, insertionMark.Color);
-        Assert.False(control.IsHandleCreated);
-
-        // Set again.
-        insertionMark.Color = value;
-        Assert.Equal(value, insertionMark.Color);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void ListViewInsertionMark_Color_SetWithHandle_ReturnsExpected(Color value)
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        insertionMark.Color = value;
-        Assert.Equal(value, insertionMark.Color);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set again.
-        insertionMark.Color = value;
-        Assert.Equal(value, insertionMark.Color);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListViewInsertionMark_Color_GetInsertMarkColor_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewInsertionMark insertionMark = control.InsertionMark;
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-            // Set same.
-            control.InsertionMark.Color = Color.Empty;
-            var insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set different.
-            control.InsertionMark.Color = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-        }).Dispose();
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_Index_Get_ReturnsExpected()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.Equal(0, insertionMark.Index);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ListViewInsertionMark_Index_SetWithoutHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-
-        insertionMark.Index = value;
-        Assert.Equal(value, insertionMark.Index);
-        Assert.False(control.IsHandleCreated);
-
-        // Set again.
-        insertionMark.Index = value;
-        Assert.Equal(value, insertionMark.Index);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ListViewInsertionMark_Index_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        insertionMark.Index = value;
-        Assert.Equal(value, insertionMark.Index);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set again.
-        insertionMark.Index = value;
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(value, insertionMark.Index);
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public unsafe void ListViewInsertionMark_Index_GetInsertMark_Success(int indexParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((indexString) =>
-        {
-            int index = int.Parse(indexString);
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewInsertionMark insertionMark = control.InsertionMark;
-
-            // Set same.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.Index = 0;
-            var insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set negative one.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.Index = -1;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set different.
-            control.InsertionMark.Index = index;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(index, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-        }, indexParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(-2)]
-    [InlineData(1)]
-    public unsafe void ListViewInsertionMark_Index_GetInsertMarkWithColor_Success(int indexParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((indexString) =>
-        {
-            int index = int.Parse(indexString);
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewInsertionMark insertionMark = control.InsertionMark;
-            insertionMark.Color = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-
-            // Set same.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.Index = 0;
-            var insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set negative one.
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            control.InsertionMark.Index = -1;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(-1, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-
-            // Set different.
-            control.InsertionMark.Index = index;
-            insertMark = new ComCtl32.LVINSERTMARK
-            {
-                cbSize = (uint)sizeof(ComCtl32.LVINSERTMARK)
-            };
-            Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARK, 0, ref insertMark));
-            Assert.Equal(0x80000000, (uint)insertMark.dwFlags);
-            Assert.Equal(index, insertMark.iItem);
-            Assert.Equal(0u, insertMark.dwReserved);
-            Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETINSERTMARKCOLOR));
-        }, indexParam.ToString()).Dispose();
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_NearestIndex_NoSuchPointWithoutHandle_ReturnsInvalid()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.True(insertionMark.NearestIndex(new Point(-10, -11)) >= -1);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewInsertionMark_NearestIndex_NoSuchPointWithHandle_ReturnsInvalid()
-    {
-        using var control = new ListView();
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(insertionMark.NearestIndex(new Point(-10, -11)) >= -1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ListViewInsertionMark_NearestIndex_InvokeCustomInsertMarkHitTest_ReturnsExpected(int result)
-    {
-        using var control = new CustomInsertMarkHitTestListView
-        {
-            InsertMarkHitTestResult = result
-        };
-        ListViewInsertionMark insertionMark = control.InsertionMark;
-
-        Assert.Equal(result, insertionMark.NearestIndex(new Point(1, 2)));
-    }
-
-    private class CustomInsertMarkHitTestListView : ListView
-    {
-        public int InsertMarkHitTestResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LVM_INSERTMARKHITTEST)
-            {
-                Point* pPt = (Point*)m.WParam;
-                Assert.Equal(1, pPt->X);
-                Assert.Equal(2, pPt->Y);
-                ComCtl32.LVINSERTMARK* pInsertMark = (ComCtl32.LVINSERTMARK*)m.LParam;
-                pInsertMark->iItem = InsertMarkHitTestResult;
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.IKeyboardToolTipTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.IKeyboardToolTipTests.cs
deleted file mode 100644
index af1f578d8ed..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.IKeyboardToolTipTests.cs
+++ /dev/null
@@ -1,825 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.ListViewItem;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_IKeyboardToolTipTests
-{
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, false, true)]
-    public void ListViewItemKeyboardToolTip_InvokeAllowsToolTip_ReturnsExpected(bool insideListView, bool virtualMode, bool showItemToolTips)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode, showItemToolTips);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.True(((IKeyboardToolTip)listViewItem).AllowsToolTip());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true)]
-    [InlineData(true, true, false, false)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, false, false)]
-    [InlineData(false, false, true, false)]
-    public void ListViewItemKeyboardToolTip_InvokeAllowsChildrenToShowToolTips_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool showItemToolTips,
-        bool expectedResult)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode, showItemToolTips);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)listViewItem).AllowsChildrenToShowToolTips());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true)]
-    [InlineData(true, true, false, false)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, false, false)]
-    [InlineData(false, false, true, false)]
-    public void ListViewItemKeyboardToolTip_InvokeCanShowToolTipsNow_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool showItemToolTips,
-        bool expectedResult)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode, showItemToolTips);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)listViewItem).CanShowToolTipsNow());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, "Test tooltip")]
-    [InlineData(true, true, false, "Test tooltip")]
-    [InlineData(true, false, true, "Test tooltip")]
-    [InlineData(true, false, false, "Test tooltip")]
-    [InlineData(false, false, false, "Test tooltip")]
-    public void ListViewItemKeyboardToolTip_InvokeGetCaptionForTool_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool showItemToolTips,
-        string toolTipText)
-    {
-        using var toolTip = new ToolTip();
-        ListViewItem listViewItem = new ListViewItem() { ToolTipText = toolTipText };
-        using var listView = GetListView(virtualMode, showItemToolTips);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(toolTipText, ((IKeyboardToolTip)listViewItem).GetCaptionForTool(toolTip));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, true)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool rectangleIsEmpty)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(rectangleIsEmpty, ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().IsEmpty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ListViewGroupCollapsedState.Default, false)]
-    [InlineData(ListViewGroupCollapsedState.Expanded, false)]
-    [InlineData(ListViewGroupCollapsedState.Collapsed, true)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_InsideGroup_ReturnsExpected(
-        ListViewGroupCollapsedState collapsedState,
-        bool rectangleIsEmpty)
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem = new ListViewItem();
-        ListViewGroup listViewGroup = new ListViewGroup();
-        listView.Groups.Add(listViewGroup);
-        listView.Items.Add(listViewItem);
-        listViewGroup.Items.Add(listViewItem);
-        listViewGroup.CollapsedState = collapsedState;
-
-        Assert.Equal(rectangleIsEmpty, ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().IsEmpty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, View.List, 50, 50)]
-    [InlineData(false, View.List, 50, 50)]
-    [InlineData(true, View.Details, 46, 48)]
-    [InlineData(false, View.Details, 46, 48)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_LongText_ReturnsExpected(
-        bool virtualMode,
-        View view,
-        int expectedWidthVisualStyleEnabled,
-        int expectedWidthVisualStyleDisabled)
-    {
-        using var listView = GetListView(virtualMode, view: view);
-        listView.Columns.Add(new ColumnHeader() { Width = 50 });
-        ListViewItem listViewItem = AssignItemToListView(listView, new ListViewItem(new string('t', 500)));
-        int expectedWidth = Application.UseVisualStyles
-            ? expectedWidthVisualStyleEnabled
-            : expectedWidthVisualStyleDisabled;
-
-        Assert.Equal(expectedWidth, ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().Width);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, View.List)]
-    [InlineData(false, View.List)]
-    [InlineData(true, View.Details)]
-    [InlineData(false, View.Details)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_ShortText_ReturnsExpected(
-        bool virtualMode,
-        View view)
-    {
-        int columnWidth = 50;
-        using var listView = GetListView(virtualMode, view: view);
-        listView.Columns.Add(new ColumnHeader() { Width = columnWidth });
-        ListViewItem listViewItem = AssignItemToListView(listView, new ListViewItem(new string('t', 1)));
-
-        int actualWidth = ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().Width;
-
-        Assert.True(columnWidth > ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().Width);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_ViewTile_LongListViewItemText_ReturnsExpected()
-    {
-        ListViewItem listViewItem = new ListViewItem(new string('t', 20));
-
-        listViewItem.SubItems.Add(new ListViewSubItem(listViewItem, new string('t', 10)));
-        using var listView = GetListView(virtualMode: false, view: View.Tile);
-        AssignItemToListView(listView, listViewItem);
-
-        int expectedWidth = Application.UseVisualStyles
-            ? TextRenderer.MeasureText(listViewItem.Text, listViewItem.Font).Width
-            : listView.GetItemRect(0, ItemBoundsPortion.Label).Width;
-
-        Assert.Equal(expectedWidth, ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().Width);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNativeScreenRectangle_ViewTile_LongListViewSubItemText_ReturnsExpected()
-    {
-        ListViewItem listViewItem = new ListViewItem(new string('t', 10));
-        ListViewSubItem listViewSubItem = new ListViewSubItem(listViewItem, new string('t', 20));
-        listViewItem.SubItems.Add(listViewSubItem);
-        using var listView = GetListView(virtualMode: false, view: View.Tile);
-        AssignItemToListView(listView, listViewItem);
-
-        int expectedWidth = Application.UseVisualStyles
-            ? TextRenderer.MeasureText(listViewSubItem.Text, listViewSubItem.Font).Width
-            : listView.GetItemRect(0, ItemBoundsPortion.Label).Width;
-
-        Assert.Equal(expectedWidth, ((IKeyboardToolTip)listViewItem).GetNativeScreenRectangle().Width);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_WithoutList_ReturnsEmptyList()
-    {
-        ListViewItem listViewItem = new ListViewItem();
-
-        Assert.Equal(0, ((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles().Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewList_ReturnsEmptyList(bool virtualMode)
-    {
-        using var listView = GetListView(virtualMode, view: View.List);
-        ListViewItem listViewItem = AssignItemToListView(listView, new ListViewItem());
-
-        Assert.Equal(0, ((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles().Count);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewTile_ReturnsEmptyList()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.Tile);
-        ListViewItem listViewItem = AssignItemToListView(listView, new ListViewItem());
-
-        Assert.Equal(0, ((IKeyboardToolTip)listViewItem).GetNeighboringToolsRectangles().Count);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 0
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_FirstItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[0]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 1
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_SecondItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[1]).GetNeighboringToolsRectangles();
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[0]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[2]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 2
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_ThirdItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[2]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 3
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_FourthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[3]).GetNeighboringToolsRectangles();
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[0]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[6]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 4
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_FifthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[4]).GetNeighboringToolsRectangles();
-        Assert.Equal(4, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 5
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_SixthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[5]).GetNeighboringToolsRectangles();
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[2]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[8]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 6
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_SeventhItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[6]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 7
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_EighthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[7]).GetNeighboringToolsRectangles();
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[6]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[8]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 8
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewLargeIcon_NinthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.LargeIcon, size: new Size(150, 150));
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[8]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 0
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_FirstItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[0]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 1
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_SecondItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[1]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[0]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[2]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 2
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_ThirdItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[2]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 3
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_FourthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[3]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[0]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[6]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 4
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_FifthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[4]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(4, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[1]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 5
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_SixthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[5]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[2]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[8]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 6
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_SeventhItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[6]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[3]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 7
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_EighthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[7]).GetNeighboringToolsRectangles();
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[6]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[8]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[4]), neighboringToolsRectangles);
-    }
-
-    // The ListView is configured to display items as follows:
-    // 0 1 2
-    // 3 4 5
-    // 6 7 8
-    // This test checks item 8
-    [WinFormsFact]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewSmallIcon_NinthItem_ReturnsExpected()
-    {
-        using var listView = GetListView(virtualMode: false, view: View.SmallIcon, size: new Size(220, 150));
-        listView.Columns.Add(new ColumnHeader());
-        AddListViewItems(listView, 9);
-        listView.CreateControl();
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[8]).GetNeighboringToolsRectangles();
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[5]), neighboringToolsRectangles);
-        Assert.Contains(GetNativeScreenRectangle(listView.Items[7]), neighboringToolsRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewDetails_FirstItem_ReturnsExpected(bool virtualMode)
-    {
-        using var listView = GetListView(virtualMode: virtualMode, view: View.Details, virtualListSize: 3);
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader());
-        AssignListItemsToListView(listView, 3);
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[0]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(listView.Items[0].AccessibilityObject.Bounds, neighboringToolsRectangles);
-        Assert.Contains(listView.Items[1].AccessibilityObject.Bounds, neighboringToolsRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewDetails_SecondItem_ReturnsExpected(bool virtualMode)
-    {
-        using var listView = GetListView(virtualMode: virtualMode, view: View.Details, virtualListSize: 3);
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader());
-        AssignListItemsToListView(listView, 3);
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[1]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(3, neighboringToolsRectangles.Count);
-        Assert.Contains(listView.Items[0].AccessibilityObject.Bounds, neighboringToolsRectangles);
-        Assert.Contains(listView.Items[1].AccessibilityObject.Bounds, neighboringToolsRectangles);
-        Assert.Contains(listView.Items[2].AccessibilityObject.Bounds, neighboringToolsRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ViewDetails_ThirdItem_ReturnsExpected(bool virtualMode)
-    {
-        using var listView = GetListView(virtualMode: virtualMode, view: View.Details, virtualListSize: 3);
-        listView.CreateControl();
-        listView.Columns.Add(new ColumnHeader());
-        AssignListItemsToListView(listView, 3);
-
-        IList<Rectangle> neighboringToolsRectangles = ((IKeyboardToolTip)listView.Items[2]).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringToolsRectangles.Count);
-        Assert.Contains(listView.Items[1].AccessibilityObject.Bounds, neighboringToolsRectangles);
-        Assert.Contains(listView.Items[2].AccessibilityObject.Bounds, neighboringToolsRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void ListViewItemKeyboardToolTip_InvokeGetOwnerWindow_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode);
-        IWin32Window expectedOwner = null;
-
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-            expectedOwner = listView;
-        }
-
-        Assert.Equal(expectedOwner, ((IKeyboardToolTip)listViewItem).GetOwnerWindow());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, RightToLeft.Yes, true)]
-    [InlineData(true, true, RightToLeft.No, false)]
-    [InlineData(true, true, RightToLeft.Inherit, false)]
-    [InlineData(true, false, RightToLeft.Yes, true)]
-    [InlineData(true, false, RightToLeft.No, false)]
-    [InlineData(true, false, RightToLeft.Inherit, false)]
-    [InlineData(false, true, RightToLeft.Yes, false)]
-    public void ListViewItemKeyboardToolTip_InvokeHasRtlModeEnabled_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        RightToLeft rightToLeft,
-        bool expected)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode, rightToLeft: rightToLeft);
-
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(expected, ((IKeyboardToolTip)listViewItem).HasRtlModeEnabled());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true)]
-    [InlineData(true, true, false, false)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, false, false)]
-    [InlineData(false, false, true, false)]
-    public void ListViewItemKeyboardToolTip_InvokeIsHoveredWithMouse_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool isHovered,
-        bool expected)
-    {
-        Point initialPosition = Cursor.Position;
-        try
-        {
-            ListViewItem listViewItem = new ListViewItem();
-            using var listView = GetListView(virtualMode);
-
-            if (insideListView)
-            {
-                listViewItem = AssignItemToListView(listView, listViewItem);
-            }
-
-            listView.CreateControl();
-
-            Point position = listView.AccessibilityObject.Bounds.Location;
-            if (!isHovered)
-            {
-                position.X--;
-                position.Y--;
-            }
-
-            Cursor.Position = position;
-            Assert.Equal(expected, ((IKeyboardToolTip)listViewItem).IsHoveredWithMouse());
-        }
-        finally
-        {
-            Cursor.Position = initialPosition;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true, true)]
-    [InlineData(true, true, false, false)]
-    [InlineData(true, false, true, true)]
-    [InlineData(true, false, false, false)]
-    [InlineData(false, false, true, false)]
-    public void ListViewItemKeyboardToolTip_InvokeShowsOwnToolTip_ReturnsExpected(
-        bool insideListView,
-        bool virtualMode,
-        bool showItemToolTips,
-        bool expectedResult)
-    {
-        ListViewItem listViewItem = new ListViewItem();
-        using var listView = GetListView(virtualMode, showItemToolTips);
-        if (insideListView)
-        {
-            listViewItem = AssignItemToListView(listView, listViewItem);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)listViewItem).ShowsOwnToolTip());
-    }
-
-    private ListViewItem AssignItemToListView(ListView listView, ListViewItem listViewItem)
-    {
-        if (listView.VirtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem,
-                    _ => new ListViewItem(),
-                };
-            };
-        }
-        else
-        {
-            listView.Items.Add(listViewItem);
-        }
-
-        return listView.Items[0];
-    }
-
-    private void AddListViewItems(ListView listView, int count)
-    {
-        for (int i = 0; i < count; i++)
-        {
-            listView.Items.Add(i.ToString());
-        }
-    }
-
-    private void AssignListItemsToListView(ListView listView, int count)
-    {
-        List<ListViewItem> listViewItems = new List<ListViewItem>();
-
-        for (int i = 0; i < count; i++)
-        {
-            ListViewItem listViewItem = new ListViewItem(i.ToString());
-            listViewItem.SubItems.Add(i.ToString());
-            listViewItems.Add(listViewItem);
-        }
-
-        if (listView.VirtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    _ => listViewItems[e.ItemIndex],
-                };
-            };
-        }
-        else
-        {
-            listView.Items.AddRange(listViewItems.ToArray());
-        }
-    }
-
-    private ListView GetListView(
-        bool virtualMode,
-        bool showItemToolTips = false,
-        RightToLeft rightToLeft = RightToLeft.No,
-        View view = View.LargeIcon,
-        Size? size = null,
-        int virtualListSize = 1)
-    {
-        return new ListView()
-        {
-            VirtualListSize = virtualListSize,
-            VirtualMode = virtualMode,
-            ShowItemToolTips = showItemToolTips,
-            RightToLeft = rightToLeft,
-            Size = size ?? new Size(50, 50),
-            View = view
-        };
-    }
-
-    private Rectangle GetNativeScreenRectangle(ListViewItem listView)
-    {
-        return ((IKeyboardToolTip)listView).GetNativeScreenRectangle();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemAccessibleObjectTests.cs
deleted file mode 100644
index cbf7f4092f9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1978 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_Ctor_ThrowsArgumentNullException()
-    {
-        using ListView list = new ListView();
-        ListViewItem listItem = new ListViewItem();
-        list.Items.Add(listItem);
-
-        Type type = listItem.AccessibilityObject.GetType();
-        ConstructorInfo ctor = type.GetConstructor(new Type[] { typeof(ListViewItem) });
-
-        Assert.NotNull(ctor);
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { null }));
-
-        // item without parent ListView
-        ListViewItem itemWithoutList = new ListViewItem();
-
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { itemWithoutList }));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_Ctor_Default()
-    {
-        using ListView list = new ListView();
-        ListViewItem listItem = new ListViewItem();
-        list.Items.Add(listItem);
-
-        AccessibleObject accessibleObject = listItem.AccessibilityObject;
-
-        Assert.False(list.IsHandleCreated);
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(AccessibleRole.ListItem, accessibleObject.Role);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_InGroup_Ctor_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, createHandle };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_InGroup_Ctor_TestData))]
-    public void ListViewItemAccessibleObject_InGroup_Ctor(View view, bool showGroups, bool createHandle)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            ShowGroups = showGroups
-        };
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        ListViewGroup listviewGroup = new ListViewGroup();
-        ListViewItem listViewItem1 = new ListViewItem();
-        ListViewItem listViewItem2 = new ListViewItem(listviewGroup);
-        listviewGroup.Items.Add(listViewItem1);
-        listView.Groups.Add(listviewGroup);
-        listView.Items.Add(listViewItem2);
-
-        AccessibleObject accessibleObject1 = listViewItem1.AccessibilityObject;
-        AccessibleObject accessibleObject2 = listViewItem2.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject1);
-        Assert.NotNull(accessibleObject2);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using var list = new ListView();
-        ListViewItem listItem = new ListViewItem("ListItem");
-        list.Items.Add(listItem);
-        AccessibleObject listItemAccessibleObject = listItem.AccessibilityObject;
-
-        object accessibleName = listItemAccessibleObject.GetPropertyValue(UIA.NamePropertyId);
-
-        Assert.Equal("ListItem", accessibleName);
-
-        object automationId = listItemAccessibleObject.GetPropertyValue(UIA.AutomationIdPropertyId);
-
-        Assert.Equal("ListViewItem-0", automationId);
-
-        object controlType = listItemAccessibleObject.GetPropertyValue(UIA.ControlTypePropertyId);
-        UIA expected = UIA.ListItemControlTypeId;
-
-        Assert.Equal(expected, controlType);
-        Assert.True((bool)listItemAccessibleObject.GetPropertyValue(UIA.IsSelectionItemPatternAvailablePropertyId));
-        Assert.True((bool)listItemAccessibleObject.GetPropertyValue(UIA.IsScrollItemPatternAvailablePropertyId));
-        Assert.True((bool)listItemAccessibleObject.GetPropertyValue(UIA.IsInvokePatternAvailablePropertyId));
-        Assert.False(list.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_FragmentNavigate_Parent_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool virtualMode in new[] { true, false })
-                {
-                    // View.Tile is not supported by ListView in virtual mode
-                    if (view == View.Tile && virtualMode)
-                    {
-                        continue;
-                    }
-
-                    foreach (bool showGroups in new[] { true, false })
-                    {
-                        yield return new object[] { view, createControl, virtualMode, showGroups };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Parent_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Parent_ReturnExpected(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, createControl, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Equal(GetExpectedParent(0), accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(GetExpectedParent(1), accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(GetExpectedParent(2), accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(GetExpectedParent(3), accessibleObject4.FragmentNavigate(NavigateDirection.Parent));
-
-        AccessibleObject GetExpectedParent(int index)
-        {
-            return Application.UseVisualStyles
-                && showGroups
-                && !virtualMode
-                && listView.View != View.List
-                ? listView.Items[index].Group is not null
-                    ? listView.Groups[0].AccessibilityObject
-                    : listView.DefaultGroup.AccessibilityObject
-                : listView.AccessibilityObject;
-        }
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_FragmentNavigate_Sibling_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (view == View.Tile && virtualMode)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    yield return new object[] { view, virtualMode, showGroups };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Sibling_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_NextSibling_ReturnExpected_IfHandleIsCreated(View view, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, true, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        if (Application.UseVisualStyles && showGroups && !virtualMode && listView.View != View.List)
-        {
-            Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.NextSibling));
-        }
-        else
-        {
-            Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Equal(accessibleObject4, accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-            Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.NextSibling));
-        }
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Sibling_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_NextSibling_ReturnExpected_IfHandleIsNotCreated(View view, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, false, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Sibling_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnExpected_IfHandleIsCreated(View view, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, true, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        if (Application.UseVisualStyles && showGroups && !virtualMode && listView.View != View.List)
-        {
-            Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(NavigateDirection.PreviousSibling));
-        }
-        else
-        {
-            Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-            Assert.Equal(accessibleObject3, accessibleObject4.FragmentNavigate(NavigateDirection.PreviousSibling));
-        }
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Sibling_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnExpected_IfHandleIsNotCreated(View view, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, false, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_FragmentNavigate_Child_TestData()
-    {
-        foreach (View view in new View[] { View.List, View.LargeIcon, View.SmallIcon })
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool virtualMode in new[] { true, false })
-                {
-                    foreach (bool showGroups in new[] { true, false })
-                    {
-                        yield return new object[] { view, createControl, virtualMode, showGroups };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Child_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_FirstChild_ReturnExpected(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, createControl, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_FirstChild_ReturnExpected_Tile_View(bool createControl, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(View.Tile, createControl, virtualMode: false, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_FirstChild_ReturnExpected_Details_View_IfHandleCreated(bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(View.Details, createControl: true, virtualMode: virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Items[2].SubItems[0].AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Items[3].SubItems[0].AccessibilityObject, accessibleObject4.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_FragmentNavigate_Details_TestData()
-    {
-        foreach (bool createControl in new[] { true, false })
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    yield return new object[] { createControl, virtualMode, showGroups };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_FirstChildReturnExpected_Details_View_IfHandleNotCreated(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 3);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-
-        Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Child_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnExpected(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(view, createControl, virtualMode, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnExpected_Tile_View(bool createControl, bool showGroups)
-    {
-        using ListView listView = GetListViewWithData(View.Tile, createControl, virtualMode: false, showGroups);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-        AccessibleObject accessibleObject4 = listView.Items[3].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Null(accessibleObject4.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnExpected_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 3);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-
-        Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(listView.Items[1].SubItems[2].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_DoesNotReturnNull_WithoutSubItems_Detail_Views(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 0);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        IRawElementProviderFragment lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        IRawElementProviderFragment lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.NotNull(lastChild1);
-        Assert.NotNull(lastChild2);
-        Assert.NotEqual(listView.Items[0].SubItems[0].AccessibilityObject, lastChild1);
-        Assert.NotEqual(listView.Items[1].SubItems[0].AccessibilityObject, lastChild2);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_SingleColumn_Detail_Views(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 1, subItemCount: 5);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        IRawElementProviderFragment lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        IRawElementProviderFragment lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, lastChild1);
-        Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, lastChild2);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_AfterAddingSubItem_Detail_Views(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 2, subItemCount: 0);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        IRawElementProviderFragment lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        IRawElementProviderFragment lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.NotNull(lastChild1);
-        Assert.NotNull(lastChild2);
-        Assert.Equal(1, listView.Items[0].SubItems.Count);
-        Assert.Equal(1, listView.Items[1].SubItems.Count);
-
-        listView.Items[0].SubItems.Add(new ListViewSubItem() { Text = $"SubItem 0" });
-        listView.Items[1].SubItems.Add(new ListViewSubItem() { Text = $"SubItem 0" });
-
-        lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, lastChild1);
-        Assert.Equal(listView.Items[1].SubItems[1].AccessibilityObject, lastChild2);
-        Assert.Equal(2, listView.Items[0].SubItems.Count);
-        Assert.Equal(2, listView.Items[1].SubItems.Count);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_AfterRemovingSubItem_Detail_Views(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 2, subItemCount: 1);
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        IRawElementProviderFragment lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        IRawElementProviderFragment lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, lastChild1);
-        Assert.Equal(listView.Items[1].SubItems[1].AccessibilityObject, lastChild2);
-        Assert.Equal(2, listView.Items[0].SubItems.Count);
-        Assert.Equal(2, listView.Items[1].SubItems.Count);
-
-        listView.Items[0].SubItems.RemoveAt(1);
-        listView.Items[1].SubItems.RemoveAt(1);
-
-        lastChild1 = accessibleObject1.FragmentNavigate(NavigateDirection.LastChild);
-        lastChild2 = accessibleObject2.FragmentNavigate(NavigateDirection.LastChild);
-
-        Assert.NotNull(lastChild1);
-        Assert.NotNull(lastChild2);
-        Assert.Equal(1, listView.Items[0].SubItems.Count);
-        Assert.Equal(1, listView.Items[1].SubItems.Count);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_View_ShowGroups_VirtualMode_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                yield return new object[] { view, showGroups };
-                yield return new object[] { view, showGroups };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_View_ShowGroups_VirtualMode_TestData))]
-    public void ListViewItemAccessibleObject_FragmentNavigate_ListWithItems_VirtualMode_VirtualListSize1_ReturnsExpected(View view, bool showGroups)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups
-        };
-
-        listView.VirtualListSize = 1;
-
-        ListViewItem listItem1 = new ListViewItem(new string[]
-        {
-            "Test A",
-            "Alpha"
-        }, -1);
-
-        ListViewItem listItem2 = new ListViewItem(new string[]
-        {
-            "Test B",
-            "Beta"
-        }, -1);
-
-        ListViewItem listItem3 = new ListViewItem(new string[]
-        {
-            "Test C",
-            "Gamma"
-        }, -1);
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                1 => listItem2,
-                2 => listItem3,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listItem1.SetItemIndex(listView, 0);
-        listItem2.SetItemIndex(listView, 1);
-        listItem3.SetItemIndex(listView, 2);
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject1 = listItem1.AccessibilityObject;
-        AccessibleObject accessibleObject2 = listItem2.AccessibilityObject;
-        AccessibleObject accessibleObject3 = listItem3.AccessibilityObject;
-
-        // First list view item
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-
-        // Second list view item
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-
-        // Third list view item
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-
-        // Parent
-        Assert.Equal(accessibleObject1.FragmentNavigate(NavigateDirection.Parent), listView.AccessibilityObject);
-        Assert.Equal(accessibleObject2.FragmentNavigate(NavigateDirection.Parent), listView.AccessibilityObject);
-        Assert.Equal(accessibleObject3.FragmentNavigate(NavigateDirection.Parent), listView.AccessibilityObject);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_State_TestData()
-    {
-        AccessibleStates defaultStates = AccessibleStates.Selectable | AccessibleStates.Focusable | AccessibleStates.MultiSelectable;
-        AccessibleStates selectedStates = defaultStates | AccessibleStates.Selected | AccessibleStates.Focused;
-
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool selected in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    AccessibleStates expectedState = selected ? selectedStates : defaultStates;
-                    yield return new object[] { view, selected, expectedState, createHandle };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_State_TestData))]
-    public void ListViewItemAccessibleObject_State_ReturnExpected(View view, bool selected, AccessibleStates expectedAccessibleStates, bool createHandle)
-    {
-        using ListView listView = new ListView
-        {
-            View = view
-        };
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        ListViewItem listItem1 = new ListViewItem(new string[] { "Test A", "Alpha" }, -1);
-        listView.Items.Add(listItem1);
-        listView.Items[0].Selected = selected;
-        AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-        Assert.Equal(expectedAccessibleStates, accessibleObject.State);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_State_VirtualMode_TestData()
-    {
-        AccessibleStates defaultStates = AccessibleStates.Selectable | AccessibleStates.Focusable | AccessibleStates.MultiSelectable;
-        AccessibleStates selectedStates = defaultStates | AccessibleStates.Selected | AccessibleStates.Focused;
-
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool selected in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    AccessibleStates expectedState = selected ? selectedStates : defaultStates;
-                    yield return new object[] { view, selected, expectedState, createHandle };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_State_VirtualMode_TestData))]
-    public void ListViewItemAccessibleObject_State_Virtual_ModeReturnExpected(View view, bool selected, AccessibleStates expectedAccessibleStates, bool createHandle)
-    {
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            VirtualListSize = 1
-        };
-
-        ListViewItem listItem1 = new ListViewItem(new string[] { "Test A", "Alpha" }, -1);
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listItem1.SetItemIndex(listView, 0);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        if (selected)
-        {
-            listView.Items[0].Selected = true;
-        }
-
-        AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-        Assert.Equal(expectedAccessibleStates, accessibleObject.State);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_Bounds_TestData()
-    {
-        foreach (bool virtualMode in new[] { true, false })
-        {
-            foreach (View view in Enum.GetValues(typeof(View)))
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, virtualMode };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_Bounds_TestData))]
-    public void ListViewItemAccessibleObject_Bounds_ReturnExpected_IfHandleIsCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetBoundsListView(view, showGroups, virtualMode);
-        listView.CreateControl();
-
-        Assert.NotEqual(Rectangle.Empty, listView.Items[0].AccessibilityObject.Bounds);
-        if (listView.GroupsDisplayed)
-        {
-            Assert.Equal(Rectangle.Empty, listView.Items[1].AccessibilityObject.Bounds);
-        }
-        else
-        {
-            Assert.NotEqual(Rectangle.Empty, listView.Items[1].AccessibilityObject.Bounds);
-        }
-
-        Assert.NotEqual(Rectangle.Empty, listView.Items[2].AccessibilityObject.Bounds);
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_Bounds_TestData))]
-    public void ListViewItemAccessibleObject_Bounds_ReturnExpected_IfHandleIsNotCreated(View view, bool showGroups, bool virtualMode)
-    {
-        using ListView listView = GetBoundsListView(view, showGroups, virtualMode);
-
-        Assert.Equal(Rectangle.Empty, listView.Items[0].AccessibilityObject.Bounds);
-        Assert.Equal(Rectangle.Empty, listView.Items[1].AccessibilityObject.Bounds);
-        Assert.Equal(Rectangle.Empty, listView.Items[2].AccessibilityObject.Bounds);
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private void AddItemToListView(ListView listView, ListViewItem listViewItem, bool virtualMode)
-    {
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem.SetItemIndex(listView, 0);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem);
-        }
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_IsTogglePatternSupported_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile does not support enabled CheckBoxes
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    foreach (bool virtualMode in new[] { true, false })
-                    {
-                        foreach (bool checkboxes in new[] { true, false })
-                        {
-                            yield return new object[] { view, showGroups, createHandle, virtualMode, checkboxes };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_IsTogglePatternSupported_TestData))]
-    public void ListViewItemAccessibleObject_IsTogglePatternSupported_ReturnExpected(View view, bool showGroups, bool createHandle, bool virtualMode, bool checkboxesEnabled)
-    {
-        using ListView listView = new ListView()
-        {
-            View = view,
-            VirtualMode = virtualMode,
-            VirtualListSize = 1,
-            CheckBoxes = checkboxesEnabled,
-            ShowGroups = showGroups
-        };
-
-        ListViewItem listViewItem = new ListViewItem("Item");
-        AddItemToListView(listView, listViewItem, virtualMode);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        Assert.Equal(checkboxesEnabled, listViewItem.AccessibilityObject.IsPatternSupported(UIA.TogglePatternId));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_ToggleState_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile does not support enabled CheckBoxes
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool createHandle in new[] { true, false })
-                {
-                    foreach (bool virtualMode in new[] { true, false })
-                    {
-                        yield return new object[] { view, showGroups, createHandle, virtualMode };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_ToggleState_TestData))]
-    public void ListViewItemAccessibleObject_ToggleState_ReturnExpected(View view, bool showGroups, bool createHandle, bool virtualMode)
-    {
-        using ListView listView = new ListView()
-        {
-            View = view,
-            VirtualMode = virtualMode,
-            VirtualListSize = 1,
-            CheckBoxes = true,
-            ShowGroups = showGroups
-        };
-
-        ListViewItem listViewItem = new ListViewItem("Item");
-        AddItemToListView(listView, listViewItem, virtualMode);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        AccessibleObject listViewItemAccessibleObject = listViewItem.AccessibilityObject;
-
-        Assert.Equal(ToggleState.Off, listViewItemAccessibleObject.ToggleState);
-
-        listViewItem.Checked = true;
-
-        Assert.Equal(ToggleState.On, listViewItemAccessibleObject.ToggleState);
-
-        listViewItem.Checked = false;
-
-        Assert.Equal(ToggleState.Off, listViewItemAccessibleObject.ToggleState);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_ToggleState_TestData))]
-    public void ListViewItemAccessibleObject_Toggle_Invoke(View view, bool showGroups, bool createHandle, bool virtualMode)
-    {
-        using ListView listView = new ListView()
-        {
-            View = view,
-            VirtualMode = virtualMode,
-            VirtualListSize = 1,
-            CheckBoxes = true,
-            ShowGroups = showGroups
-        };
-
-        ListViewItem listViewItem = new ListViewItem("Item");
-        AddItemToListView(listView, listViewItem, virtualMode);
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        AccessibleObject listViewItemAccessibleObject = listViewItem.AccessibilityObject;
-
-        Assert.Equal(ToggleState.Off, listViewItemAccessibleObject.ToggleState);
-        Assert.False(listViewItem.Checked);
-
-        listViewItemAccessibleObject.Toggle();
-
-        Assert.Equal(ToggleState.On, listViewItemAccessibleObject.ToggleState);
-        Assert.True(listViewItem.Checked);
-
-        // toggle again
-        listViewItemAccessibleObject.Toggle();
-
-        Assert.Equal(ToggleState.Off, listViewItemAccessibleObject.ToggleState);
-        Assert.False(listViewItem.Checked);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_InvisibleItems(View view)
-    {
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-
-        Assert.Null(GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-
-        AccessibleObject GetAccessibleObject(int index) => listView.Groups[0].Items[index].AccessibilityObject;
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_InvisibleItems_AfterAddingItems(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-
-        Assert.Null(GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-
-        listView.Items.Add(listView.Groups[0].Items[0]);
-        listView.Items.Add(listView.Groups[0].Items[3]);
-
-        Assert.Null(GetAccessibleObject(0).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(0).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(0), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(3), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(3).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(3).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-
-        AccessibleObject GetAccessibleObject(int index) => listView.Groups[0].Items[index].AccessibilityObject;
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_InvisibleItems_AfterRemovingItems(View view)
-    {
-        using ListView listView = GetListViewItemWithInvisibleItems(view);
-
-        Assert.Null(GetAccessibleObject(1).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(GetAccessibleObject(2), GetAccessibleObject(1).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(GetAccessibleObject(1), GetAccessibleObject(2).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(2).FragmentNavigate(NavigateDirection.NextSibling));
-
-        listView.Items.RemoveAt(1);
-
-        Assert.Null(GetAccessibleObject(0).FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(GetAccessibleObject(0).FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.True(listView.IsHandleCreated);
-
-        AccessibleObject GetAccessibleObject(int index) => listView.Groups[0].Items[index].AccessibilityObject;
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Parent_TestData))]
-    public void ListViewItemAccessibleObject_GetChildCount_ReturnsExpected(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(view, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 1);
-
-        // We return 3 for "Details" view because the number of children is equal to the number of columns
-        // We return 0 for the "Tile" view because it is limited in the unit tests(all cases are covered in the MauiListViewTests)
-        // We return -1 for the "List", "LargeIcon", "SmallIcon" view because they don't support subitems.
-        int expectedCount = listView.IsHandleCreated && listView.SupportsListViewSubItems
-            ? view == View.Details ? 3 : 0
-            : -1;
-
-        Assert.Equal(expectedCount, listView.Items[0].AccessibilityObject.GetChildCount());
-        Assert.Equal(expectedCount, listView.Items[1].AccessibilityObject.GetChildCount());
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Parent_TestData))]
-    public void ListViewItemAccessibleObject_GetChild_ReturnsExpected(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(view, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 1);
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.GetChild(-1));
-        Assert.Null(accessibleObject2.GetChild(-1));
-        if (view == View.Details)
-        {
-            Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, accessibleObject1.GetChild(0));
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, accessibleObject1.GetChild(1));
-            Assert.Equal(
-                ((ListViewItem.ListViewItemDetailsAccessibleObject)accessibleObject1).GetDetailsSubItemOrFake(2),
-                accessibleObject1.GetChild(2));
-
-            Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, accessibleObject2.GetChild(0));
-            Assert.Equal(listView.Items[1].SubItems[1].AccessibilityObject, accessibleObject2.GetChild(1));
-            Assert.Equal(
-                ((ListViewItem.ListViewItemDetailsAccessibleObject)accessibleObject2).GetDetailsSubItemOrFake(2),
-                accessibleObject2.GetChild(2));
-        }
-        else
-        {
-            Assert.Null(accessibleObject1.GetChild(0));
-            Assert.Null(accessibleObject1.GetChild(1));
-            Assert.Null(accessibleObject1.GetChild(2));
-
-            Assert.Null(accessibleObject2.GetChild(0));
-            Assert.Null(accessibleObject2.GetChild(1));
-            Assert.Null(accessibleObject2.GetChild(2));
-        }
-
-        Assert.Null(accessibleObject1.GetChild(3));
-        Assert.Null(accessibleObject2.GetChild(3));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_FragmentNavigate_Parent_TestData))]
-    public void ListViewItemAccessibleObject_GetChild_ReturnsExpected_ForManySubItems(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(view, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 10);
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.GetChild(-1));
-        Assert.Null(accessibleObject2.GetChild(-1));
-        if (view == View.Details)
-        {
-            Assert.Equal(listView.Items[0].SubItems[0].AccessibilityObject, accessibleObject1.GetChild(0));
-            Assert.Equal(listView.Items[0].SubItems[1].AccessibilityObject, accessibleObject1.GetChild(1));
-            Assert.Equal(listView.Items[0].SubItems[2].AccessibilityObject, accessibleObject1.GetChild(2));
-
-            Assert.Equal(listView.Items[1].SubItems[0].AccessibilityObject, accessibleObject2.GetChild(0));
-            Assert.Equal(listView.Items[1].SubItems[1].AccessibilityObject, accessibleObject2.GetChild(1));
-            Assert.Equal(listView.Items[1].SubItems[2].AccessibilityObject, accessibleObject2.GetChild(2));
-        }
-        else
-        {
-            Assert.Null(accessibleObject1.GetChild(0));
-            Assert.Null(accessibleObject1.GetChild(1));
-            Assert.Null(accessibleObject1.GetChild(2));
-
-            Assert.Null(accessibleObject2.GetChild(0));
-            Assert.Null(accessibleObject2.GetChild(1));
-            Assert.Null(accessibleObject2.GetChild(2));
-        }
-
-        Assert.Null(accessibleObject1.GetChild(3));
-        Assert.Null(accessibleObject2.GetChild(3));
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    private ListView GetListViewWithSubItemData(
-        View view,
-        bool createControl,
-        bool virtualMode,
-        bool showGroups,
-        int columnCount,
-        int subItemCount)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            VirtualListSize = 2
-        };
-
-        ListViewItem listItem1 = new("Item 1");
-        ListViewItem listItem2 = new("Item 2");
-
-        if (!virtualMode)
-        {
-            ListViewGroup listViewGroup = new("Test");
-            listItem2.Group = listViewGroup;
-            listView.Groups.Add(listViewGroup);
-        }
-
-        for (int i = 0; i < subItemCount; i++)
-        {
-            listItem1.SubItems.Add(new ListViewSubItem() { Text = $"SubItem {i}" });
-            listItem2.SubItems.Add(new ListViewSubItem() { Text = $"SubItem {i}" });
-        }
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            listView.Columns.Add(new ColumnHeader($"Column {i}"));
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem1,
-                    1 => listItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem1.SetItemIndex(listView, 0);
-            listItem2.SetItemIndex(listView, 0);
-        }
-        else
-        {
-            listView.Items.AddRange(new ListViewItem[] { listItem1, listItem2 });
-        }
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        return listView;
-    }
-
-    private ListView GetListViewWithData(View view, bool createControl, bool virtualMode, bool showGroups, bool groupsEnabled = true, bool itemsInGroup = true, ListViewGroupCollapsedState state = ListViewGroupCollapsedState.Default)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            VirtualListSize = 4
-        };
-
-        ListViewItem listItem1 = new(new string[] { "Test Item 1", "Item A" }, -1);
-        ListViewItem listItem2 = new("Group item 2");
-        ListViewItem listItem3 = new("Item 3");
-        ListViewItem listItem4 = new(new string[] { "Test Item 4", "Item B", "Item C", "Item D" }, -1);
-
-        if (!virtualMode && groupsEnabled)
-        {
-            ListViewGroup listViewGroup = new("Test") { CollapsedState = state };
-            listView.Groups.Add(listViewGroup);
-            if (itemsInGroup)
-            {
-                listItem1.Group = listViewGroup;
-                listItem2.Group = listViewGroup;
-            }
-        }
-
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 1" });
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 2" });
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 3" });
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem1,
-                    1 => listItem2,
-                    2 => listItem3,
-                    3 => listItem4,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem1.SetItemIndex(listView, 0);
-            listItem2.SetItemIndex(listView, 1);
-            listItem3.SetItemIndex(listView, 2);
-            listItem4.SetItemIndex(listView, 3);
-        }
-        else
-        {
-            listView.Items.Add(listItem1);
-            listView.Items.Add(listItem2);
-            listView.Items.Add(listItem3);
-            listView.Items.Add(listItem4);
-        }
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        return listView;
-    }
-
-    private ListView GetListViewItemWithInvisibleItems(View view)
-    {
-        ListView listView = new ListView() { View = view };
-        listView.CreateControl();
-        ListViewGroup listViewGroup = new("Test group");
-        ListViewItem listViewInvisibleItem1 = new ListViewItem("Invisible item 1");
-        ListViewItem listViewVisibleItem1 = new ListViewItem("Visible item 1");
-        ListViewItem listViewInvisibleItem2 = new ListViewItem("Invisible item 1");
-        ListViewItem listViewVisibleItem2 = new ListViewItem("Visible item 1");
-
-        listView.Groups.Add(listViewGroup);
-        listView.Items.AddRange(new ListViewItem[] { listViewVisibleItem1, listViewVisibleItem2 });
-        listViewGroup.Items.AddRange(new ListViewItem[]
-        {
-            listViewInvisibleItem1, listViewVisibleItem1,
-            listViewVisibleItem2, listViewInvisibleItem2
-        });
-
-        return listView;
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_Parent_ReturnsExpected_AfterAddingGroup(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = true
-        };
-
-        listView.Items.Add(new ListViewItem("Item 1"));
-        listView.Items.Add(new ListViewItem("Item 2"));
-        listView.Items.Add(new ListViewItem("Item 3"));
-        listView.Columns.Add(new ColumnHeader());
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        listView.Groups.Add(new ListViewGroup());
-        listView.Items[1].Group = listView.Groups[0];
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_Parent_ReturnsExpected_AfterRemovingGroup(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = true
-        };
-
-        listView.Groups.Add(new ListViewGroup());
-
-        listView.Items.Add(new ListViewItem("Item 1"));
-        listView.Items.Add(new ListViewItem("Item 2", group: listView.Groups[0]));
-        listView.Items.Add(new ListViewItem("Item 3"));
-        listView.Columns.Add(new ColumnHeader());
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        listView.Groups.RemoveAt(0);
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_Parent_ReturnsExpected_AfterUpdatingGroup(View view)
-    {
-        if (!Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using ListView listView = new()
-        {
-            View = view,
-            ShowGroups = true
-        };
-
-        listView.Groups.Add(new ListViewGroup());
-
-        listView.Items.Add(new ListViewItem("Item 1"));
-        listView.Items.Add(new ListViewItem("Item 2", group: listView.Groups[0]));
-        listView.Items.Add(new ListViewItem("Item 3"));
-        listView.Columns.Add(new ColumnHeader());
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        listView.Groups[0].Items.Insert(0, listView.Items[0]);
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.Groups[0].AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.DefaultGroup.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_FragmentNavigate_Sibling_Parent_ReturnsExpected_ListView()
-    {
-        using ListView listView = new()
-        {
-            View = View.List,
-            ShowGroups = true
-        };
-
-        listView.Items.Add(new ListViewItem("Item 1"));
-        listView.Items.Add(new ListViewItem("Item 2"));
-        listView.Items.Add(new ListViewItem("Item 3"));
-        listView.Columns.Add(new ColumnHeader());
-
-        listView.CreateControl();
-
-        AccessibleObject accessibleObject1 = listView.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = listView.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = listView.Items[2].AccessibilityObject;
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        // Since "List" mode does not support ListViewGroups, adding a ListViewGroup should not affect the operation of availability objects
-        listView.Groups.Add(new ListViewGroup());
-        listView.Items[1].Group = listView.Groups[0];
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        // Since "List" mode does not support ListViewGroups, updating a ListViewGroup should not affect the operation of availability objects
-        listView.Groups[0].Items.Insert(0, listView.Items[0]);
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        // Since "List" mode does not support ListViewGroups, removing a ListViewGroup should not affect the operation of availability objects
-        listView.Groups.RemoveAt(0);
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.Equal(listView.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsExpected(View view)
-    {
-        using ListView listView = new() { View = view };
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1", "SubItem 2" }));
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-
-        if (view == View.Details)
-        {
-            Assert.Equal(0, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-        }
-        else
-        {
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[1].AccessibilityObject));
-            Assert.Equal(-1, accessibleObject.GetChildIndex(listView.Items[0].SubItems[2].AccessibilityObject));
-        }
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsMinusOne_IfChildIsNull(View view)
-    {
-        using ListView listView = new() { View = view };
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 1", "SubItem 2" }));
-
-        Assert.Equal(-1, listView.Items[0].AccessibilityObject.GetChildIndex(null));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsMinusOne_IfSubItemNotExists(View view)
-    {
-        using ListView listView = new() { View = view };
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12" }));
-        listView.Items.Add(new ListViewItem(new string[] { "Item 2", "SubItem 21", "SubItem 22" }));
-
-        Assert.Equal(-1, listView.Items[0].AccessibilityObject.GetChildIndex(listView.Items[1].SubItems[1].AccessibilityObject));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsExpected_ForFakeSubItem()
-    {
-        using ListView listView = new() { View = View.Details };
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1" }));
-        ListViewItemDetailsAccessibleObject accessibleObject = (ListViewItemDetailsAccessibleObject)listView.Items[0].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-        Assert.Equal(1, accessibleObject.GetChildIndex(accessibleObject.GetDetailsSubItemOrFake(1)));
-        Assert.Equal(2, accessibleObject.GetChildIndex(accessibleObject.GetDetailsSubItemOrFake(2)));
-        Assert.Equal(3, accessibleObject.GetChildIndex(accessibleObject.GetDetailsSubItemOrFake(3)));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsExpected_Image(bool hasImage, int expectedFirstSubItemIndex)
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-        using ListView listView = new()
-        {
-            View = View.Details,
-            SmallImageList = imageCollection
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-        var listViewItem = new ListViewItem("Item 1", imageIndex: hasImage ? 0 : -1);
-        listView.Items.Add(listViewItem);
-        var accessibleObject = (ListViewItemDetailsAccessibleObject)listView.Items[0].AccessibilityObject;
-        
-        Assert.Equal(expectedFirstSubItemIndex, accessibleObject.GetChildIndex(listView.Items[0].SubItems[0].AccessibilityObject));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_GetChildIndex_ReturnsMinusOne_ForInvalidChild(View view)
-    {
-        using ListView listView = new() { View = view };
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Columns.Add(new ColumnHeader());
-        listView.Items.Add(new ListViewItem(new string[] { "Item 1", "SubItem 11", "SubItem 12" }));
-
-        Assert.Equal(-1, listView.Items[0].AccessibilityObject.GetChildIndex(listView.AccessibilityObject));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewItemAccessibleObject_ReturnExpectedType(View view)
-    {
-        using ListView listView = new() { View = view };
-        listView.Items.Add(new ListViewItem("Test"));
-
-        switch (view)
-        {
-            case View.Details:
-                Assert.IsType<ListViewItemDetailsAccessibleObject>(listView.Items[0].AccessibilityObject);
-                break;
-            case View.LargeIcon:
-                Assert.IsType<ListViewItemLargeIconAccessibleObject>(listView.Items[0].AccessibilityObject);
-                break;
-            case View.List:
-                Assert.IsType<ListViewItemListAccessibleObject>(listView.Items[0].AccessibilityObject);
-                break;
-            case View.SmallIcon:
-                Assert.IsType<ListViewItemSmallIconAccessibleObject>(listView.Items[0].AccessibilityObject);
-                break;
-            case View.Tile:
-                Assert.IsType<ListViewItemTileAccessibleObject>(listView.Items[0].AccessibilityObject);
-                break;
-        }
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_ReturnExpectedType_TestData()
-    {
-        foreach (View oldView in Enum.GetValues(typeof(View)))
-        {
-            foreach (View newView in Enum.GetValues(typeof(View)))
-            {
-                if (oldView != newView)
-                {
-                    yield return new object[] { oldView, newView };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_ReturnExpectedType_TestData))]
-    public void ListViewItemAccessibleObject_ReturnExpectedType_AfterChangingView(View oldView, View newView)
-    {
-        using ListView listView = new() { View = oldView };
-        listView.Items.Add(new ListViewItem("Test"));
-        CheckAccessibleObject();
-
-        listView.View = newView;
-
-        CheckAccessibleObject();
-
-        void CheckAccessibleObject()
-        {
-            switch (listView.View)
-            {
-                case View.Details:
-                    Assert.IsType<ListViewItemDetailsAccessibleObject>(listView.Items[0].AccessibilityObject);
-                    break;
-                case View.LargeIcon:
-                    Assert.IsType<ListViewItemLargeIconAccessibleObject>(listView.Items[0].AccessibilityObject);
-                    break;
-                case View.List:
-                    Assert.IsType<ListViewItemListAccessibleObject>(listView.Items[0].AccessibilityObject);
-                    break;
-                case View.SmallIcon:
-                    Assert.IsType<ListViewItemSmallIconAccessibleObject>(listView.Items[0].AccessibilityObject);
-                    break;
-                case View.Tile:
-                    Assert.IsType<ListViewItemTileAccessibleObject>(listView.Items[0].AccessibilityObject);
-                    break;
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details, View.LargeIcon)]
-    [InlineData(View.Details, View.List)]
-    [InlineData(View.Details, View.SmallIcon)]
-    [InlineData(View.Details, View.Tile)]
-    [InlineData(View.LargeIcon, View.Details)]
-    [InlineData(View.LargeIcon, View.List)]
-    [InlineData(View.LargeIcon, View.SmallIcon)]
-    [InlineData(View.LargeIcon, View.Tile)]
-    [InlineData(View.List, View.Details)]
-    [InlineData(View.List, View.LargeIcon)]
-    [InlineData(View.List, View.SmallIcon)]
-    [InlineData(View.List, View.Tile)]
-    [InlineData(View.SmallIcon, View.Details)]
-    [InlineData(View.SmallIcon, View.LargeIcon)]
-    [InlineData(View.SmallIcon, View.List)]
-    [InlineData(View.SmallIcon, View.Tile)]
-    [InlineData(View.Tile, View.Details)]
-    [InlineData(View.Tile, View.LargeIcon)]
-    [InlineData(View.Tile, View.List)]
-    [InlineData(View.Tile, View.SmallIcon)]
-    public void ListViewItemAccessibleObject_GetChild_ReturnException_AfterChangingView(View oldView, View newView)
-    {
-        using ListView listView = new() { View = oldView };
-        listView.Items.Add(new ListViewItem(new string[] { "1", "2" }));
-        AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(0));
-
-        listView.View = newView;
-
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChild(0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details, View.LargeIcon)]
-    [InlineData(View.Details, View.List)]
-    [InlineData(View.Details, View.SmallIcon)]
-    [InlineData(View.Details, View.Tile)]
-    [InlineData(View.LargeIcon, View.Details)]
-    [InlineData(View.LargeIcon, View.List)]
-    [InlineData(View.LargeIcon, View.SmallIcon)]
-    [InlineData(View.LargeIcon, View.Tile)]
-    [InlineData(View.List, View.Details)]
-    [InlineData(View.List, View.LargeIcon)]
-    [InlineData(View.List, View.SmallIcon)]
-    [InlineData(View.List, View.Tile)]
-    [InlineData(View.SmallIcon, View.Details)]
-    [InlineData(View.SmallIcon, View.LargeIcon)]
-    [InlineData(View.SmallIcon, View.List)]
-    [InlineData(View.SmallIcon, View.Tile)]
-    [InlineData(View.Tile, View.Details)]
-    [InlineData(View.Tile, View.LargeIcon)]
-    [InlineData(View.Tile, View.List)]
-    [InlineData(View.Tile, View.SmallIcon)]
-    public void ListViewItemAccessibleObject_GetChildCount_ReturnException_AfterChangingView(View oldView, View newView)
-    {
-        using ListView listView = new() { View = oldView };
-        listView.Items.Add(new ListViewItem(new string[] { "1" }));
-        AccessibleObject accessibleObject = listView.Items[0].AccessibilityObject;
-        Assert.NotEqual(2, accessibleObject.GetChildCount());
-
-        listView.View = newView;
-
-        Assert.Throws<InvalidOperationException>(() => accessibleObject.GetChildCount());
-    }
-
-    public static IEnumerable<object[]> ListViewItemAccessibleObject_GetPropertyValue_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool virtualMode in new[] { true, false })
-                {
-                    // View.Tile is not supported by ListView in virtual mode
-                    if (virtualMode && view == View.Tile)
-                    {
-                        continue;
-                    }
-
-                    foreach (bool showGroups in new[] { true, false })
-                    {
-                        foreach (bool groupsEnabled in new[] { true, false })
-                        {
-                            foreach (bool itemsInGroup in new[] { true, false })
-                            {
-                                foreach (ListViewGroupCollapsedState state in Enum.GetValues(typeof(ListViewGroupCollapsedState)))
-                                {
-                                    yield return new object[] { view, createControl, virtualMode, showGroups, groupsEnabled, itemsInGroup, state };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewItemAccessibleObject_GetPropertyValue_TestData))]
-    public void ListViewItemAccessibleObject_GetPropertyValue_ReturnsFalseWhenCollapsedOrOffScreen(View view, bool createControl, bool virtualMode, bool showGroups, bool groupsEnabled, bool itemsInGroup, ListViewGroupCollapsedState state)
-    {
-        using ListView listView = GetListViewWithData(view, createControl, virtualMode, showGroups, groupsEnabled, itemsInGroup, state);
-        ListViewItemBaseAccessibleObject accessibleObject = (ListViewItemBaseAccessibleObject)listView.Items[0].AccessibilityObject;
-
-        bool expected = listView.GroupsDisplayed && listView.Items[0].Group?.CollapsedState == ListViewGroupCollapsedState.Collapsed;
-        bool actual = (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_IsDisconnected_WhenListViewReleasesUiaProvider()
-    {
-        using ListView listView = new();
-        ListViewItem item = new("ListItem");
-        listView.Items.Add(item);
-        EnforceAccessibleObjectCreation(item);
-
-        listView.ReleaseUiaProvider(listView.HWND);
-
-        Assert.Null(item.TestAccessor().Dynamic._accessibilityObject);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_IsDisconnected_WhenListViewIsCleared()
-    {
-        using ListView listView = new();
-        ListViewItem item = new("ListItem");
-        listView.Items.Add(item);
-        EnforceAccessibleObjectCreation(item);
-
-        listView.Clear();
-
-        Assert.Null(item.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_IsDisconnected_WhenItemsAreCleared()
-    {
-        using ListView listView = new();
-        ListViewItem item = new("ListItem");
-        listView.Items.Add(item);
-        EnforceAccessibleObjectCreation(item);
-
-        listView.Items.Clear();
-
-        Assert.Null(item.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_IsDisconnected_WhenItemIsRemoved()
-    {
-        using ListView listView = new();
-        ListViewItem item = new("ListItem");
-        listView.Items.Add(item);
-        EnforceAccessibleObjectCreation(item);
-
-        listView.Items.Remove(item);
-
-        Assert.Null(item.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemAccessibleObject_IsDisconnected_WhenItemIsReplaced()
-    {
-        using ListView listView = new();
-        ListViewItem item = new("ListItem");
-        listView.Items.Add(item);
-        EnforceAccessibleObjectCreation(item);
-
-        listView.Items[0] = new ListViewItem();
-
-        Assert.Null(item.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private static void EnforceAccessibleObjectCreation(ListViewItem listViewItem)
-    {
-        _ = listViewItem.AccessibilityObject;
-        Assert.NotNull(listViewItem.TestAccessor().Dynamic._accessibilityObject);
-    }
-
-    private ListView GetBoundsListView(View view, bool showGroups, bool virtualMode)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            VirtualListSize = 3
-        };
-
-        ListViewItem listViewItem1 = new("Item1");
-        ListViewItem listViewItem2 = new("Item2");
-        ListViewItem listViewItem3 = new("Item3");
-
-        if (!virtualMode)
-        {
-            ListViewGroup lvgroup1 = new()
-            {
-                Header = "CollapsibleGroup1",
-                CollapsedState = ListViewGroupCollapsedState.Expanded
-            };
-
-            ListViewGroup lvgroup2 = new()
-            {
-                Header = "CollapsibleGroup2",
-                CollapsedState = ListViewGroupCollapsedState.Collapsed
-            };
-
-            listView.Groups.Add(lvgroup1);
-            listView.Groups.Add(lvgroup2);
-
-            listViewItem1.Group = lvgroup1;
-            listViewItem2.Group = lvgroup2;
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listViewItem1,
-                    1 => listViewItem1,
-                    2 => listViewItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listViewItem1.SetItemIndex(listView, 0);
-            listViewItem2.SetItemIndex(listView, 1);
-            listViewItem3.SetItemIndex(listView, 2);
-        }
-        else
-        {
-            listView.Items.Add(listViewItem1);
-            listView.Items.Add(listViewItem2);
-            listView.Items.Add(listViewItem3);
-        }
-
-        listView.Columns.Add(new ColumnHeader());
-        return listView;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemBaseAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemBaseAccessibleObjectTests.cs
deleted file mode 100644
index 7f1aa610dac..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemBaseAccessibleObjectTests.cs
+++ /dev/null
@@ -1,409 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemBaseAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_Ctor_OwnerListViewItemCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new SubListViewItemBaseAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_Role_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.Equal(AccessibleRole.ListItem, item.AccessibilityObject.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.Equal(SR.AccessibleActionDoubleClick, item.AccessibilityObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_CurrentIndex_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        var accessibleObject = (ListViewItemBaseAccessibleObject)item.AccessibilityObject;
-
-        Assert.Equal(item.Index, accessibleObject.CurrentIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.Equal(control.AccessibilityObject, item.AccessibilityObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListViewItemBaseAccessibleObject_IsItemSelected_ReturnsExpected(bool isSelected)
-    {
-        using ListView control = new();
-        ListViewItem item = new() { Selected = isSelected };
-        control.Items.Add(item);
-
-        Assert.Equal(isSelected, item.AccessibilityObject.IsItemSelected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_DoDefaultAction_DoesNothing_IfControlIsNotCreated()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.False((accessibleObject.State & AccessibleStates.Selected) != 0);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.False((accessibleObject.State & AccessibleStates.Selected) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_AddToSelection_WorksExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.False(accessibleObject.IsItemSelected);
-
-        accessibleObject.AddToSelection();
-
-        Assert.True(accessibleObject.IsItemSelected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_DoDefaultAction_IfControlIsNotCreated()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.False((accessibleObject.State & AccessibleStates.Selected) != 0);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.False((accessibleObject.State & AccessibleStates.Selected) != 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_DoDefaultAction_WorksExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.False((accessibleObject.State & AccessibleStates.Selected) != 0);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.True((accessibleObject.State & AccessibleStates.Selected) != 0);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-        var actual = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(control.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_FragmentNavigate_ToSibling_ReturnsNull()
-    {
-        using ListView control = new();
-        control.Items.AddRange(new ListViewItem[] { new(), new(), new() });
-
-        AccessibleObject accessibleObject1 = control.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Items[1].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.Tile)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.LargeIcon)]
-    public void ListViewItemBaseAccessibleObject_GetChild_ReturnsNull_IfViewIsNotDetailsOrTile(View view)
-    {
-        using ListView control = new() { View = view };
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Null(item.AccessibilityObject.GetChild(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.Tile)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.LargeIcon)]
-    public void ListViewItemBaseAccessibleObject_GetChildCount_ReturnsNull_IfViewIsNotDetailsOrTile(View view)
-    {
-        using ListView control = new() { View = view };
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(-1, item.AccessibilityObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_GetSubItemBounds_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        var accessibleObject = (ListViewItemBaseAccessibleObject)item.AccessibilityObject;
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.GetSubItemBounds(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_GetPropertyValue_ControlType_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        var actual = item.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ListItemControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_GetPropertyValue_FrameworkProperty_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        var actual = item.AccessibilityObject.GetPropertyValue(UiaCore.UIA.FrameworkIdPropertyId);
-
-        Assert.Equal("WinForm", actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.Equal(SR.AccessibleActionDoubleClick, item.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.Null(item.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.True((bool)item.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsInvokePatternAvailablePropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemBaseAccessibleObject_IsCheckable_IfListViewHasCheckBoxes(bool itemIsChecked)
-    {
-        using ListView listView = new();
-        listView.CheckBoxes = true;
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        item.Checked = itemIsChecked;
-
-        AccessibleObject itemAccessibleObject = item.AccessibilityObject;
-        itemAccessibleObject.DoDefaultAction();
-
-        Assert.Equal(!itemIsChecked, item.Checked);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_IfCheckableListViewItem_HasCheckButtonRole()
-    {
-        using ListView listView = new();
-        listView.CheckBoxes = true;
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        AccessibleObject itemAccessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(AccessibleRole.CheckButton, itemAccessibleObject.Role);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemBaseAccessibleObject_IfCheckableListViewItem_HasExpectedDefaultAction(bool itemIsChecked)
-    {
-        using ListView listView = new();
-        listView.CheckBoxes = true;
-        ListViewItem item = new();
-        item.Checked = itemIsChecked;
-        listView.Items.Add(item);
-
-        AccessibleObject itemAccessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(itemIsChecked ? SR.AccessibleActionUncheck : SR.AccessibleActionCheck, itemAccessibleObject.DefaultAction);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ScrollItemPatternId)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    [InlineData((int)UiaCore.UIA.SelectionItemPatternId)]
-    [InlineData((int)UiaCore.UIA.InvokePatternId)]
-    [InlineData((int)UiaCore.UIA.TogglePatternId)]
-    public void ListViewItemBaseAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        using ListView control = new() { CheckBoxes = true };
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.True(item.AccessibilityObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_ItemSelectionContainer_ReturnsExpected()
-    {
-        using ListView control = new();
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        Assert.Equal(control.AccessibilityObject, item.AccessibilityObject.ItemSelectionContainer);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.ToggleState.On)]
-    [InlineData(false, (int)UiaCore.ToggleState.Off)]
-    public void ListViewItemBaseAccessibleObject_ToggleState_ReturnsExpected(bool isChecked, int expected)
-    {
-        using ListView control = new();
-        ListViewItem item = new() { Checked = isChecked };
-        control.Items.Add(item);
-
-        Assert.Equal((UiaCore.ToggleState)expected, item.AccessibilityObject.ToggleState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, (int)UiaCore.ToggleState.Off, (int)UiaCore.ToggleState.On)]
-    [InlineData(true, (int)UiaCore.ToggleState.On, (int)UiaCore.ToggleState.Off)]
-    public void ListViewItemBaseAccessibleObject_Toggle_WorksExpected(bool isChecked, int before, int expected)
-    {
-        using ListView control = new();
-        ListViewItem item = new() { Checked = isChecked };
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Equal((UiaCore.ToggleState)before, accessibleObject.ToggleState);
-
-        accessibleObject.Toggle();
-
-        Assert.Equal((UiaCore.ToggleState)expected, accessibleObject.ToggleState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemBaseAccessibleObject_GetPropertyValue_AutomationId_ReturnsExpected()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        var accessibleObject = (ListViewItemBaseAccessibleObject)item.AccessibilityObject;
-
-        var expected = $"{nameof(ListViewItem)}-{accessibleObject.CurrentIndex}";
-        Assert.Equal(expected, accessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId));
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private class SubListViewItemBaseAccessibleObject : ListViewItemBaseAccessibleObject
-    {
-        protected override View View => View.List;
-
-        public SubListViewItemBaseAccessibleObject(ListViewItem owningItem) : base(owningItem)
-        {
-        }
-    }
-
-    // More tests for this class has been created already in ListViewItem_ListViewItemAccessibleObjectTests
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemDetailsAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemDetailsAccessibleObjectTests.cs
deleted file mode 100644
index 25e71e2766a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemDetailsAccessibleObjectTests.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemDetailsAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_Ctor_OwnerListViewItemCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ListViewItemDetailsAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Columns.Add(new ColumnHeader());
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-        AccessibleObject expected = item.SubItems[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.Columns.AddRange(new ColumnHeader[] { new(), new(), new() });
-        item.SubItems.AddRange(new ListViewSubItem[] { new(), new(), new(), new(), new() });
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-        AccessibleObject expected = item.SubItems[control.Columns.Count - 1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_GetChild_ReturnsNull_IfIndexInvalid()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Columns.AddRange(new ColumnHeader[] { new(), new(), new() });
-        int outRangeIndex = control.Columns.Count + 1;
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(outRangeIndex));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.Columns.AddRange(new ColumnHeader[] { new(), new(), new() });
-        item.SubItems.AddRange(new ListViewSubItem[] { new(), new(), new(), new() });
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(item.SubItems[0].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(item.SubItems[1].AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Equal(item.SubItems[2].AccessibilityObject, accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_GetChildCount_ReturnsExpected_IfControlIsNotCreated()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.Columns.AddRange(new ColumnHeader[] { new(), new(), new() });
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = item.AccessibilityObject;
-
-        Assert.Equal(control.Columns.Count, accessibleObject.GetChildCount());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemDetailsAccessibleObject_SubItemAccessibleObjects_AreDisconnected_WhenItemIsReleased()
-    {
-        using ListView control = new() { View = View.Details };
-        ListViewItem item = new();
-        control.Items.Add(item);
-        control.Columns.AddRange(new ColumnHeader[] { new(), new(), new() });
-
-        // Enforce subitems' accessible objects creation.
-        Assert.NotNull(item.AccessibilityObject.GetChild(0));
-        Assert.NotNull(item.AccessibilityObject.GetChild(1));
-        Assert.NotNull(item.AccessibilityObject.GetChild(2));
-        Assert.NotEmpty(item.AccessibilityObject.TestAccessor().Dynamic._listViewSubItemAccessibleObjects);
-
-        item.ReleaseUiaProvider();
-
-        Assert.Empty(item.AccessibilityObject.TestAccessor().Dynamic._listViewSubItemAccessibleObjects);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewItemDetailsAccessibleObject_HasImage_ReturnsExpected(bool addImages)
-    {
-        using ListView listView = new()
-        {
-            View = View.Details
-        };
-
-        listView.Columns.Add(new ColumnHeader());
-
-        using ImageList imageList = new();
-        imageList.Images.Add(Form.DefaultIcon);
-
-        if (addImages)
-        {
-            listView.SmallImageList = imageList;
-        }
-
-        ListViewItem listViewItem = new ListViewItem("1", 0);
-        listView.Items.Add(listViewItem);
-
-        var accessibleObject = (ListViewItemDetailsAccessibleObject)listView.Items[0].AccessibilityObject;
-        Assert.Equal(addImages, accessibleObject.HasImage);
-        Assert.False(listView.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemImageAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemImageAccessibleObjectTests.cs
deleted file mode 100644
index 576b2a9332c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemImageAccessibleObjectTests.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static System.Windows.Forms.ListViewItem;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemImageAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemImageAccessibleObject_GetChild_ReturnCorrectValue()
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-
-        ListViewItem listViewItem = new("Test", 0);
-        using ListView list = new()
-        {
-            View = View.Details,
-            SmallImageList = imageCollection
-        };
-        using ColumnHeader column = new();
-        list.Columns.Add(column);
-        list.Items.Add(listViewItem);
-
-        list.CreateControl();
-
-        AccessibleObject imageAccessibleObject = listViewItem.AccessibilityObject.GetChild(0);
-
-        Assert.NotNull(imageAccessibleObject);
-        Assert.IsType<ListViewItemImageAccessibleObject>(imageAccessibleObject);
-        Assert.True(list.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemImageAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-
-        ListViewItem listViewItem = new("Test", 0);
-
-        using ListView list = new()
-        {
-            View = View.Details,
-            SmallImageList = imageCollection
-        };
-        using ColumnHeader column = new();
-        list.Columns.Add(column);
-        list.Items.Add(listViewItem);
-
-        list.CreateControl();
-
-        AccessibleObject imageAccessibleObject = listViewItem.AccessibilityObject.GetChild(0);
-
-        Assert.Equal(UiaCore.UIA.ImageControlTypeId, (UiaCore.UIA)imageAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.False((bool)imageAccessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId));
-        Assert.False((bool)imageAccessibleObject.GetPropertyValue(UiaCore.UIA.IsKeyboardFocusablePropertyId));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemListAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemListAccessibleObjectTests.cs
deleted file mode 100644
index d68b56d174a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemListAccessibleObjectTests.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemListAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_Ctor_OwnerListViewItemCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ListViewItemListAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_Ctor_OwnerListViewCannotBeNull()
-    {
-        Assert.Throws<InvalidOperationException>(() => new ListViewItemListAccessibleObject(new ListViewItem()));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_Bounds_IsEmptyRectangle_IfOwningControlNotCreated()
-    {
-        using ListView control = new();
-        control.View = View.List;
-        control.Items.Add(new ListViewItem());
-
-        Assert.Equal(Rectangle.Empty, control.Items[0].AccessibilityObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_FragmentNavigate_Parent()
-    {
-        using ListView control = new();
-        control.View = View.List;
-        control.Items.Add(new ListViewItem());
-        AccessibleObject accessibleObject1 = control.Items[0].AccessibilityObject;
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_FragmentNavigate_PreviousSibling()
-    {
-        using ListView control = new();
-        control.View = View.List;
-        control.Items.AddRange(new ListViewItem[] { new(), new(), new() });
-        control.CreateControl();
-
-        AccessibleObject accessibleObject1 = control.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Items[2].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewItemListAccessibleObject_FragmentNavigate_NextSibling()
-    {
-        using ListView control = new();
-        control.View = View.List;
-        control.Items.AddRange(new ListViewItem[] { new(), new(), new() });
-        control.CreateControl();
-
-        AccessibleObject accessibleObject1 = control.Items[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Items[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Items[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.True(control.IsHandleCreated);
-    }
-
-    // More tests for this class has been created already in ListViewItem_ListViewItemAccessibleObjectTests
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemTileAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemTileAccessibleObjectTests.cs
deleted file mode 100644
index f7b1c5cdc76..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemTileAccessibleObjectTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ListViewItem;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemTileAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewItemTileAccessibleObject_Ctor_OwnerListViewItemCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ListViewItemTileAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewItemTileAccessibleObject_Ctor_OwnerListViewCannotBeNull()
-    {
-        Assert.Throws<InvalidOperationException>(() => new ListViewItemTileAccessibleObject(new ListViewItem()));
-    }
-
-    // More tests for this class has been created already in ListViewItem_ListViewItemAccessibleObjectTests
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemWithImageAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemWithImageAccessibleObjectTests.cs
deleted file mode 100644
index a2171b01fd9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewItemWithImageAccessibleObjectTests.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewItemWithImageAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_FragmentNavigate_Children_ReturnsNull_WithoutImage(View view)
-    {
-        using ListView control = new();
-        control.View = view;
-        control.Items.AddRange(new ListViewItem[] { new() });
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-
-        Assert.Null(listViewItemAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(listViewItemAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_FragmentNavigate_Children_IsExpected_WithImage(View view)
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-
-        ListViewItem listViewItem = new("Test", 0);
-        using ListView control = new()
-        {
-            View = view,
-            SmallImageList = imageCollection,
-            LargeImageList = imageCollection
-        };
-        control.Items.Add(listViewItem);
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-        var firstChild = listViewItemAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        var lastChild = listViewItemAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.IsType<ListViewItemImageAccessibleObject>(firstChild);
-        Assert.IsType<ListViewItemImageAccessibleObject>(lastChild);
-        Assert.Same(firstChild, lastChild);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_GetChild_ReturnsNull_WithoutImage(View view)
-    {
-        using ListView control = new();
-        control.View = view;
-        control.Items.AddRange(new ListViewItem[] { new() });
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-
-        Assert.Null(listViewItemAccessibleObject.GetChild(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_GetChild_IsExpected_WithImage(View view)
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-
-        ListViewItem listViewItem = new("Test", 0);
-        using ListView control = new()
-        {
-            View = view,
-            SmallImageList = imageCollection,
-            LargeImageList = imageCollection
-        };
-        control.Items.Add(listViewItem);
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-
-        Assert.IsType<ListViewItemImageAccessibleObject>(listViewItemAccessibleObject.GetChild(0));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_GetChildCount_WithoutImage(View view)
-    {
-        using ListView control = new();
-        control.View = view;
-        control.Items.AddRange(new ListViewItem[] { new() });
-        control.CreateControl();
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-
-        Assert.Equal(AccessibleObject.InvalidIndex, listViewItemAccessibleObject.GetChildCount());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetViewTheoryData))]
-    public void ListViewItemListAccessibleObject_GetChildCount_WithImage(View view)
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-
-        ListViewItem listViewItem = new("Test", 0);
-        using ListView control = new()
-        {
-            View = view,
-            SmallImageList = imageCollection,
-            LargeImageList = imageCollection
-        };
-        control.Items.Add(listViewItem);
-        control.CreateControl();
-
-        AccessibleObject listViewItemAccessibleObject = control.Items[0].AccessibilityObject;
-
-        Assert.Equal(1, listViewItemAccessibleObject.GetChildCount());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static TheoryData<View> GetViewTheoryData()
-    {
-        return new TheoryData<View>
-        {
-            View.LargeIcon,
-            View.SmallIcon
-        };
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObjectTests.cs
deleted file mode 100644
index aa3b9a3c11a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using static System.Windows.Forms.ListViewItem.ListViewSubItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewItem_ListViewSubItem_ListViewSubItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetChild_ReturnCorrectValue()
-    {
-        using ListView list = new();
-        ListViewItem listViewItem1 = new(new string[]
-        {
-        "Test 1",
-        "Item 1",
-        "Something 1"
-        }, -1);
-
-        ColumnHeader columnHeader1 = new();
-        ColumnHeader columnHeader2 = new();
-        ColumnHeader columnHeader3 = new();
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2,
-        columnHeader3
-        });
-        list.HideSelection = false;
-        list.Items.Add(listViewItem1);
-        list.View = View.Details;
-
-        list.CreateControl();
-
-        AccessibleObject accessibleObject = listViewItem1.AccessibilityObject.GetChild(0);
-        Assert.NotNull(accessibleObject);
-        Assert.IsType<ListViewSubItemAccessibleObject>(accessibleObject);
-        Assert.True(list.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 0)]
-    [InlineData(true, 1)]
-    [InlineData(false, 1)]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_returns_correct_values(bool labelEdit, int childId)
-    {
-        using ListView list = new();
-        ListViewItem listViewItem1 = new(new string[]
-        {
-        "Test 1",
-        "Test 2",
-        "Something 1"
-        }, -1);
-
-        ColumnHeader columnHeader1 = new();
-        ColumnHeader columnHeader2 = new();
-        ColumnHeader columnHeader3 = new();
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2,
-        columnHeader3
-        });
-        list.HideSelection = false;
-        list.Items.Add(listViewItem1);
-        list.View = View.Details;
-        list.LabelEdit = labelEdit;
-
-        list.CreateControl();
-
-        AccessibleObject accessibleObject = listViewItem1.AccessibilityObject.GetChild(childId);
-
-        object accessibleName = accessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-        Assert.Equal($"Test {childId + 1}", accessibleName);
-
-        object automationId = accessibleObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId);
-        Assert.Equal($"ListViewSubItem-{childId}", automationId);
-
-        object frameworkId = accessibleObject.GetPropertyValue(UiaCore.UIA.FrameworkIdPropertyId);
-        Assert.Equal("WinForm", frameworkId);
-
-        object controlType = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TextControlTypeId, controlType);
-        Assert.True(list.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_GridTablePattern_ReturnsExpected(View view)
-    {
-        using ListView list = new() { View = view };
-        list.Items.Add(new ListViewItem(new string[] { "Test 1", "Test 2" }));
-
-        AccessibleObject accessibleObject = list.Items[0].SubItems[1].AccessibilityObject;
-
-        Assert.Equal(view == View.Details, (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsGridItemPatternAvailablePropertyId));
-        Assert.Equal(view == View.Details, (bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsTableItemPatternAvailablePropertyId));
-    }
-
-    public static IEnumerable<object[]> ListViewSubItemAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (View view in new[] { View.List, View.LargeIcon, View.SmallIcon, View.Tile })
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                foreach (bool virtualMode in new[] { true, false })
-                {
-                    // View.Tile is not supported by ListView in virtual mode
-                    if (view == View.Tile && virtualMode)
-                    {
-                        continue;
-                    }
-
-                    foreach (bool showGroups in new[] { true, false })
-                    {
-                        yield return new object[] { view, createControl, virtualMode, showGroups };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_ReturnsNull_List_Icon_Tile_View(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(view, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_TestData))]
-    public void ListViewSubItemAccessibleObject_Bounds_ReturnsEmptyRectangle_List_Icon_Tile_View(View view, bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(view, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.Equal(Rectangle.Empty, subItemAccObj1.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObj2.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObj3.Bounds);
-
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup1.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup2.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup3.Bounds);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewSubItemAccessibleObject_Bounds_ReturnsNotEmptyRectangle_Details_View_IfHandleIsCreated(bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl: true, virtualMode, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.NotEqual(Rectangle.Empty, subItemAccObj1.Bounds);
-        Assert.NotEqual(Rectangle.Empty, subItemAccObj2.Bounds);
-        Assert.NotEqual(Rectangle.Empty, subItemAccObj3.Bounds);
-
-        Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup1.Bounds);
-        Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup2.Bounds);
-        Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup3.Bounds);
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewSubItemAccessibleObject_Bounds_ReturnsNotEmptyRectangle_Details_View_IfHandleIsNotCreated(bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl: false, virtualMode, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.Equal(Rectangle.Empty, subItemAccObj1.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObj2.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObj3.Bounds);
-
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup1.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup2.Bounds);
-        Assert.Equal(Rectangle.Empty, subItemAccObjInGroup3.Bounds);
-
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData()
-    {
-        foreach (bool createControl in new[] { true, false })
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    yield return new object[] { createControl, virtualMode, showGroups };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_Child_ReturnsNull_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_Child_ReturnsNull_Tile_View(bool createControl, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Tile, createControl, virtualMode: false, showGroups, columnCount: 3, subItemCount: 2);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj1 = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObj2 = listViewItem.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObj3 = listViewItem.SubItems[2].AccessibilityObject;
-
-        AccessibleObject subItemAccObjInGroup1 = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup2 = listViewItemInGroup.SubItems[1].AccessibilityObject;
-        AccessibleObject subItemAccObjInGroup3 = listViewItemInGroup.SubItems[2].AccessibilityObject;
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-
-        Assert.Null(subItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Null(subItemAccObjInGroup3.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_Details_View_TwoColumn(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 2, subItemCount: 5);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-
-        AccessibleObject nextSubItemAccObj1 = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject nextSubItemAccObj2 = (AccessibleObject)nextSubItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        AccessibleObject nextSubItemAccInGroup1 = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject nextSubItemAccInGroup2 = (AccessibleObject)nextSubItemAccInGroup1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, nextSubItemAccObj1);
-        Assert.Null(nextSubItemAccObj2);
-
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, nextSubItemAccInGroup1);
-        Assert.Null(nextSubItemAccInGroup2);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_Details_View_SingleSubItem(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 5, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-
-        AccessibleObject nextSubItemAccObj1 = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject nextSubItemAccObj2 = (AccessibleObject)nextSubItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        AccessibleObject nextSubItemAccInGroup1 = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject nextSubItemAccInGroup2 = (AccessibleObject)nextSubItemAccInGroup1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        Assert.NotNull(nextSubItemAccObj1);
-        Assert.NotNull(nextSubItemAccObj2);
-
-        Assert.NotNull(nextSubItemAccInGroup1);
-        Assert.NotNull(nextSubItemAccInGroup2);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsNull_Details_View_SingleSubItem(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 5, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-        AccessibleObject previousSubItemAccObj = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.Null(previousSubItemAccObj);
-        Assert.Null(previousSubItemAccInGroup);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 4, subItemCount: 3);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[3].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[3].AccessibilityObject;
-
-        AccessibleObject previousSubItemAccObj3 = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj2 = (AccessibleObject)previousSubItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj1 = (AccessibleObject)previousSubItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj0 = (AccessibleObject)previousSubItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        AccessibleObject previousSubItemAccInGroup3 = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup2 = (AccessibleObject)previousSubItemAccInGroup3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup1 = (AccessibleObject)previousSubItemAccInGroup2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup0 = (AccessibleObject)previousSubItemAccInGroup1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.Same(listViewItem.SubItems[2].AccessibilityObject, previousSubItemAccObj3);
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, previousSubItemAccObj2);
-        Assert.Same(listViewItem.SubItems[0].AccessibilityObject, previousSubItemAccObj1);
-        Assert.Null(previousSubItemAccInGroup0);
-
-        Assert.Same(listViewItemInGroup.SubItems[2].AccessibilityObject, previousSubItemAccInGroup3);
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, previousSubItemAccInGroup2);
-        Assert.Same(listViewItemInGroup.SubItems[0].AccessibilityObject, previousSubItemAccInGroup1);
-        Assert.Null(previousSubItemAccInGroup0);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_AfterAddingItem_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 2, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-
-        Assert.NotNull(subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.NotNull(subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        listViewItem.SubItems.Add("SubItem");
-        listViewItemInGroup.SubItems.Add("SubItem");
-
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_AfterAddingItem_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = (AccessibleObject)listViewItem.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        AccessibleObject subItemAccInGroup = (AccessibleObject)listViewItemInGroup.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.NotNull(subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.NotNull(subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        listViewItem.SubItems.Add("SubItem");
-        listViewItemInGroup.SubItems.Add("SubItem");
-
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_AfterRemovingItem_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 2, subItemCount: 1);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listViewItem.SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        listViewItem.SubItems.RemoveAt(1);
-        listViewItemInGroup.SubItems.RemoveAt(1);
-
-        Assert.NotNull(subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.NotNull(subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_AfterRemovingItem_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 3, subItemCount: 1);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = (AccessibleObject)listViewItem.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        AccessibleObject subItemAccInGroup = (AccessibleObject)listViewItemInGroup.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.Same(listViewItem.SubItems[1].AccessibilityObject, subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Same(listViewItemInGroup.SubItems[1].AccessibilityObject, subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        listViewItem.SubItems.Add("SubItem");
-        listViewItemInGroup.SubItems.Add("SubItem");
-
-        Assert.NotNull(subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.NotNull(subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_WithoutSubItems_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 5, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = (AccessibleObject)listViewItem.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        AccessibleObject subItemAccInGroup = (AccessibleObject)listViewItemInGroup.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        AccessibleObject previousSubItemAccObj4 = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj3 = (AccessibleObject)previousSubItemAccObj4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj2 = (AccessibleObject)previousSubItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj1 = (AccessibleObject)previousSubItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccObj0 = (AccessibleObject)previousSubItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        AccessibleObject previousSubItemAccInGroup4 = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup3 = (AccessibleObject)previousSubItemAccInGroup4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup2 = (AccessibleObject)previousSubItemAccInGroup3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup1 = (AccessibleObject)previousSubItemAccInGroup2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        AccessibleObject previousSubItemAccInGroup0 = (AccessibleObject)previousSubItemAccInGroup1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.NotNull(previousSubItemAccObj4);
-        Assert.NotNull(previousSubItemAccObj3);
-        Assert.NotNull(previousSubItemAccObj2);
-        Assert.Same(listView.Items[0].SubItems[0].AccessibilityObject, previousSubItemAccObj1);
-        Assert.Null(previousSubItemAccObj0);
-
-        Assert.NotNull(previousSubItemAccInGroup4);
-        Assert.NotNull(previousSubItemAccInGroup3);
-        Assert.NotNull(previousSubItemAccInGroup2);
-        Assert.Same(listViewItemInGroup.SubItems[0].AccessibilityObject, previousSubItemAccInGroup1);
-        Assert.Null(previousSubItemAccInGroup0);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListViewSubItemAccessibleObject_FragmentNavigate_Details_TestData))]
-    public void ListViewSubItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_WithoutSubItems_Details_View(bool createControl, bool virtualMode, bool showGroups)
-    {
-        using ListView listView = GetListViewWithSubItemData(View.Details, createControl, virtualMode, showGroups, columnCount: 5, subItemCount: 0);
-        ListViewItem listViewItem = listView.Items[0];
-        ListViewItem listViewItemInGroup = listView.Items[1];
-
-        AccessibleObject subItemAccObj = listView.Items[0].SubItems[0].AccessibilityObject;
-        AccessibleObject subItemAccInGroup = listViewItemInGroup.SubItems[0].AccessibilityObject;
-
-        AccessibleObject previousSubItemAccObj1 = (AccessibleObject)subItemAccObj.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccObj2 = (AccessibleObject)previousSubItemAccObj1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccObj3 = (AccessibleObject)previousSubItemAccObj2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccObj4 = (AccessibleObject)previousSubItemAccObj3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccObj5 = (AccessibleObject)previousSubItemAccObj4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        AccessibleObject previousSubItemAccInGroup1 = (AccessibleObject)subItemAccInGroup.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccInGroup2 = (AccessibleObject)previousSubItemAccInGroup1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccInGroup3 = (AccessibleObject)previousSubItemAccInGroup2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccInGroup4 = (AccessibleObject)previousSubItemAccInGroup3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        AccessibleObject previousSubItemAccInGroup5 = (AccessibleObject)previousSubItemAccInGroup4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        Assert.NotNull(previousSubItemAccObj1);
-        Assert.NotNull(previousSubItemAccObj2);
-        Assert.NotNull(previousSubItemAccObj3);
-        Assert.NotNull(previousSubItemAccObj4);
-        Assert.Null(previousSubItemAccObj5);
-
-        Assert.NotNull(previousSubItemAccInGroup1);
-        Assert.NotNull(previousSubItemAccInGroup2);
-        Assert.NotNull(previousSubItemAccInGroup3);
-        Assert.NotNull(previousSubItemAccInGroup4);
-        Assert.Null(previousSubItemAccInGroup5);
-
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_Bounds_ReturnCorrectValue()
-    {
-        using ListView list = new();
-        ListViewItem listViewItem1 = new(new string[]
-        {
-        "Test 1",
-        "Item 1",
-        "Something 1"
-        }, -1);
-
-        ColumnHeader columnHeader1 = new();
-        ColumnHeader columnHeader2 = new();
-        ColumnHeader columnHeader3 = new();
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2,
-        columnHeader3
-        });
-        list.HideSelection = false;
-        list.Items.Add(listViewItem1);
-        list.View = View.Details;
-
-        list.CreateControl();
-
-        ListViewItem.ListViewSubItem subItem = listViewItem1.SubItems[0];
-        AccessibleObject accessibleObject = listViewItem1.AccessibilityObject.GetChild(0);
-
-        int actualWidth = accessibleObject.Bounds.Width;
-        int expectedWidth = listViewItem1.SubItems[1].Bounds.X - subItem.Bounds.X;
-        Assert.Equal(expectedWidth, actualWidth);
-
-        int actualHeight = accessibleObject.Bounds.Height;
-        int expectedHeight = subItem.Bounds.Height;
-        Assert.Equal(expectedHeight, actualHeight);
-
-        Rectangle actualBounds = accessibleObject.Bounds;
-        actualBounds.Location = new Point(0, 0);
-        Rectangle expectedBounds = new(subItem.Bounds.X, subItem.Bounds.Y, expectedWidth, expectedHeight);
-        expectedBounds.Location = new Point(0, 0);
-        Assert.Equal(expectedBounds, actualBounds);
-        Assert.True(list.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListViewSubItemAccessibleObject_ColumnProperty_ReturnCorrectValue(bool createControl)
-    {
-        using ListView list = new() { View = View.Details };
-        ListViewItem listViewItem1 = new(new string[]
-        {
-            "Test 1",
-            "Item 1",
-            "Something 1",
-            "Something 2"
-        });
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-            new ColumnHeader(),
-            new ColumnHeader(),
-            new ColumnHeader()
-        });
-
-        list.Items.Add(listViewItem1);
-
-        if (createControl)
-        {
-            list.CreateControl();
-        }
-
-        Assert.Equal(0, listViewItem1.SubItems[0].AccessibilityObject.Column);
-        Assert.Equal(1, listViewItem1.SubItems[1].AccessibilityObject.Column);
-        Assert.Equal(2, listViewItem1.SubItems[2].AccessibilityObject.Column);
-        Assert.Equal(-1, listViewItem1.SubItems[3].AccessibilityObject.Column);
-        Assert.Equal(createControl, list.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.LargeIcon, true)]
-    [InlineData(View.LargeIcon, false)]
-    [InlineData(View.List, true)]
-    [InlineData(View.List, false)]
-    [InlineData(View.SmallIcon, true)]
-    [InlineData(View.SmallIcon, false)]
-    [InlineData(View.Tile, true)]
-    [InlineData(View.Tile, false)]
-    public void ListViewSubItemAccessibleObject_ColumnProperty_ReturnMinusOne_ForNotTableView(View view, bool createControl)
-    {
-        using ListView list = new() { View = view };
-        ListViewItem listViewItem1 = new(new string[]
-        {
-            "Test 1",
-            "Item 1",
-            "Something 1",
-            "Something 2",
-        });
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-            new ColumnHeader(),
-            new ColumnHeader(),
-            new ColumnHeader()
-        });
-
-        list.Items.Add(listViewItem1);
-
-        if (createControl)
-        {
-            list.CreateControl();
-        }
-
-        Assert.Equal(-1, listViewItem1.SubItems[0].AccessibilityObject.Column);
-        Assert.Equal(-1, listViewItem1.SubItems[1].AccessibilityObject.Column);
-        Assert.Equal(-1, listViewItem1.SubItems[2].AccessibilityObject.Column);
-        Assert.Equal(-1, listViewItem1.SubItems[3].AccessibilityObject.Column);
-        Assert.Equal(createControl, list.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_RowProperty_ReturnCorrectValue()
-    {
-        using ListView list = new();
-        ListViewItem listViewItem1 = new(new string[]
-        {
-        "Test 1",
-        "Item 1",
-        "Something 1"
-        }, -1);
-
-        ColumnHeader columnHeader1 = new();
-        ColumnHeader columnHeader2 = new();
-        ColumnHeader columnHeader3 = new();
-
-        list.Columns.AddRange(new ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2,
-        columnHeader3
-        });
-        list.HideSelection = false;
-        list.Items.Add(listViewItem1);
-        list.View = View.Details;
-
-        list.CreateControl();
-
-        AccessibleObject subItemAccObj1 = listViewItem1.AccessibilityObject.GetChild(0);
-        AccessibleObject subItemAccObj2 = listViewItem1.AccessibilityObject.GetChild(1);
-        AccessibleObject subItemAccObj3 = listViewItem1.AccessibilityObject.GetChild(2);
-        Assert.True(list.IsHandleCreated);
-
-        Assert.Equal(0, subItemAccObj1.Row);
-        Assert.Equal(0, subItemAccObj2.Row);
-        Assert.Equal(0, subItemAccObj3.Row);
-    }
-
-    private ListView GetListViewWithSubItemData(
-        View view,
-        bool createControl,
-        bool virtualMode,
-        bool showGroups,
-        int columnCount,
-        int subItemCount)
-    {
-        ListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            VirtualListSize = 2
-        };
-
-        ListViewItem listItem1 = new("Item 1");
-        ListViewItem listItem2 = new("Item 2");
-
-        if (!virtualMode)
-        {
-            ListViewGroup listViewGroup = new("Test");
-            listView.Groups.Add(listViewGroup);
-            listItem2.Group = listViewGroup;
-        }
-
-        for (int i = 0; i < subItemCount; i++)
-        {
-            listItem1.SubItems.Add($"SubItem {i}");
-            listItem2.SubItems.Add($"SubItem {i}");
-        }
-
-        for (int i = 0; i < columnCount; i++)
-        {
-            listView.Columns.Add(new ColumnHeader($"Column {i}"));
-        }
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem1,
-                    1 => listItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem1.SetItemIndex(listView, 0);
-            listItem2.SetItemIndex(listView, 0);
-        }
-        else
-        {
-            listView.Items.AddRange(new ListViewItem[] { listItem1, listItem2 });
-        }
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        return listView;
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_ProcessId_ReturnCorrectValue()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new("Test item");
-        listViewItem._listView = listView;
-        ListViewItem.ListViewSubItem subItem = new(listViewItem, "Test subItem");
-
-        object actual = subItem.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ProcessIdPropertyId);
-
-        Assert.Equal(Environment.ProcessId, actual);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_Bounds_Equals_ListViewItem_IfFullRowSelectIsTrue()
-    {
-        using ListView listView = new()
-        {
-            View = View.Details,
-            FullRowSelect = true
-        };
-
-        listView.CreateControl();
-        listView.Columns.AddRange(new ColumnHeader[] { new() { Width = 120, Text = "Column 1" }, new() { Width = 120, Text = "Column 2" } });
-        listView.Items.Add(new ListViewItem("Test item 11"));
-        listView.Items[0].SubItems.Add("Test item 12");
-
-        var itemAccessibleObject = listView.Items[0].AccessibilityObject;
-        var subItemAccessibleObject = listView.Items[0].SubItems[0].AccessibilityObject;
-
-        Assert.Equal(itemAccessibleObject.Bounds, subItemAccessibleObject.Bounds);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_Bounds_NotEquals_ListViewItem_IfFullRowSelectIsFalse()
-    {
-        using ListView listView = new()
-        {
-            View = View.Details,
-            FullRowSelect = false
-        };
-
-        listView.CreateControl();
-
-        listView.Columns.AddRange(new ColumnHeader[] { new() { Width = 120, Text = "Column 1" }, new() { Width = 120, Text = "Column 2" } });
-        listView.Items.Add(new ListViewItem("Test item 11"));
-        listView.Items[0].SubItems.Add("Test item 12");
-
-        var itemAccessibleObject = listView.Items[0].AccessibilityObject;
-        var subItemAccessibleObject = listView.Items[0].SubItems[0].AccessibilityObject;
-
-        Assert.NotEqual(itemAccessibleObject.Bounds, subItemAccessibleObject.Bounds);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new("Test item");
-        listView.Items.Add(listViewItem);
-        ListViewItem.ListViewSubItem listViewSubItem = new(listViewItem, "Test subItem");
-        object actual = listViewSubItem.AccessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(listViewSubItem.AccessibilityObject.RuntimeId, actual);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_BoundingRectangle_ReturnsExpected()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new("Test item");
-        listView.Items.Add(listViewItem);
-        ListViewItem.ListViewSubItem listViewSubItem = new(listViewItem, "Test subItem");
-        ListViewSubItemAccessibleObject listViewSubItemAccessibleObject = new(listViewSubItem, listViewItem);
-        object actual = listViewSubItemAccessibleObject.GetPropertyValue(UiaCore.UIA.BoundingRectanglePropertyId);
-
-        Assert.Equal(UiaTextProvider.BoundingRectangleAsArray(listViewSubItem.AccessibilityObject.BoundingRectangle), actual);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_IsOffscreen_ReturnsFalse()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new("Test item");
-        listView.Items.Add(listViewItem);
-        ListViewItem.ListViewSubItem listViewSubItem = new(listViewItem, "Test subItem");
-        ListViewSubItemAccessibleObject listViewSubItemAccessibleObject = new(listViewSubItem, listViewItem);
-        var actual = (bool)listViewSubItemAccessibleObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId);
-
-        Assert.False(actual);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void ListViewSubItemAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using ListView listView = new() { View = View.Details };
-        ListViewItem listViewItem = new("Test item");
-        listView.Items.Add(listViewItem);
-        ListViewItem.ListViewSubItem listViewSubItem = new(listViewItem, "Test subItem");
-        ListViewSubItemAccessibleObject accessibleObject = new(listViewSubItem, listViewItem);
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetColumnHeaderItems_IsExpected()
-    {
-        using ListView control = GetListViewWithSubItemData(
-            View.Details,
-            createControl: false,
-            virtualMode: false,
-            showGroups: false,
-            columnCount: 3,
-            subItemCount: 2);
-
-        ListViewSubItemAccessibleObject_GetColumnHeaderItems_IsExpected_Internal(control);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_GetColumnHeaderItems_IsExpected_WithImage()
-    {
-        using ImageList imageCollection = new();
-        imageCollection.Images.Add(Form.DefaultIcon);
-        using ListView control = GetListViewWithSubItemData(
-            View.Details,
-            createControl: false,
-            virtualMode: false,
-            showGroups: false,
-            columnCount: 3,
-            subItemCount: 2);
-        control.SmallImageList = imageCollection;
-        control.Items[0].ImageIndex = 0;
-
-        ListViewSubItemAccessibleObject_GetColumnHeaderItems_IsExpected_Internal(control);
-    }
-
-    private void ListViewSubItemAccessibleObject_GetColumnHeaderItems_IsExpected_Internal(ListView control)
-    {
-        ListView.ColumnHeaderCollection columns = control.Columns;
-        for (int i = 0; i < columns.Count; i++)
-        {
-            var subItemAccessibleObject = (ListViewSubItemAccessibleObject)control.Items[0].SubItems[i].AccessibilityObject;
-            AccessibleObject columnHeaderAccessibleObject = columns[i].AccessibilityObject;
-            UiaCore.IRawElementProviderSimple[] columnHeaderItems = subItemAccessibleObject.GetColumnHeaderItems();
-
-            Assert.Equal(1, columnHeaderItems.Length);
-            Assert.Same(columnHeaderAccessibleObject, columnHeaderItems[0]);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListViewSubItemAccessibleObject_GetColumnHeaderItems_ReturnsNull_NoColumsViews(View view)
-    {
-        using ListView control = GetListViewWithSubItemData(
-            view,
-            createControl: false,
-            virtualMode: false,
-            showGroups: false,
-            columnCount: 3,
-            subItemCount: 2);
-
-        var subItemAccessibleObject = (ListViewSubItemAccessibleObject)control.Items[0].SubItems[1].AccessibilityObject;
-
-        Assert.Null(subItemAccessibleObject.GetColumnHeaderItems());
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_State_ReturnsFocusable()
-    {
-        using ListView listview = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listview.Items.Add(listViewItem);
-
-        Assert.Equal(AccessibleStates.Focusable, listViewSubItem.AccessibilityObject.State);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenListViewReleasesUiaProvider()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.ReleaseUiaProvider(listView.HWND);
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenListViewIsCleared()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.Clear();
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenOwningItemIsRemoved()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.Items.RemoveAt(0);
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenSubItemIsRemoved()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.Items[0].SubItems.Remove(listViewSubItem);
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenSubItemsAreCleared()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.Items[0].SubItems.Clear();
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenSubItemIsReplaced()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        listView.Items[0] = new ListViewItem();
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemAccessibleObject_IsDisconnected_WhenOwningItemIsReplaced()
-    {
-        using ListView listView = new();
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem listViewSubItem = new();
-        listViewItem.SubItems.Add(listViewSubItem);
-        listView.Items.Add(listViewItem);
-        EnforceAccessibleObjectCreation(listViewItem);
-
-        int subItemIndex = listView.Items[0].SubItems.IndexOf(listViewSubItem);
-        listView.Items[0].SubItems[subItemIndex] = new ListViewItem.ListViewSubItem();
-
-        Assert.Null(listViewSubItem.TestAccessor().Dynamic._accessibilityObject);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    private static void EnforceAccessibleObjectCreation(ListViewItem item)
-    {
-        _ = item.AccessibilityObject;
-        Assert.NotNull(item.TestAccessor().Dynamic._accessibilityObject);
-        foreach (ListViewItem.ListViewSubItem subItem in item.SubItems)
-        {
-            _ = subItem.AccessibilityObject;
-            Assert.NotNull(subItem.TestAccessor().Dynamic._accessibilityObject);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemConverterTests.cs
deleted file mode 100644
index 44a7ba0d3ff..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemConverterTests.cs
+++ /dev/null
@@ -1,331 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewItemConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(ListViewItem), false)]
-    [InlineData(typeof(string), false)]
-    public void ListViewItemConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    [Theory]
-    [InlineData("value")]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void ListViewItemConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(ListViewItem), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void ListViewItemConverter_ConverterCanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    public static IEnumerable<object[]> ConvertTo_InstanceDescriptor_TestData()
-    {
-        var group = new ListViewGroup();
-        var subItem1 = new ListViewItem.ListViewSubItem(null, "text1");
-        var subItem2 = new ListViewItem.ListViewSubItem(null, "text2");
-        var subItem3 = new ListViewItem.ListViewSubItem(null, "text3")
-        {
-            ForeColor = Color.Blue
-        };
-        var subItem4 = new ListViewItem.ListViewSubItem(null, "text4")
-        {
-            BackColor = Color.Blue
-        };
-        var subItem5 = new ListViewItem.ListViewSubItem(null, "text5")
-        {
-            Font = SystemFonts.MenuFont
-        };
-
-        // Simple.
-        yield return new object[]
-        {
-            new ListViewItem(),
-            new Type[] { typeof(string) },
-            new object[] { string.Empty }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(group),
-            new Type[] { typeof(string) },
-            new object[] { string.Empty }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text"),
-            new Type[] { typeof(string) },
-            new object[] { "text" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text", group),
-            new Type[] { typeof(string) },
-            new object[] { "text" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text", "imageKey"),
-            new Type[] { typeof(string), typeof(string) },
-            new object[] { "text", "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text", 1),
-            new Type[] { typeof(string), typeof(int) },
-            new object[] { "text", 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text", "imageKey", group),
-            new Type[] { typeof(string), typeof(string) },
-            new object[] { "text", "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem("text", 1, group),
-            new Type[] { typeof(string), typeof(int) },
-            new object[] { "text", 1 }
-        };
-
-        // Item.
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1 }, "imageKey"),
-            new Type[] { typeof(string), typeof(string) },
-            new object[] { "text1", "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1 }, 1),
-            new Type[] { typeof(string), typeof(int) },
-            new object[] { "text1", 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1 }, "imageKey", group),
-            new Type[] { typeof(string), typeof(string) },
-            new object[] { "text1", "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1 }, 1, group),
-            new Type[] { typeof(string), typeof(int) },
-            new object[] { "text1", 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2 }, "imageKey"),
-            new Type[] { typeof(string[]), typeof(string) },
-            new object[] { new string[] { "text1", "text2" }, "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2 }, 1),
-            new Type[] { typeof(string[]), typeof(int) },
-            new object[] { new string[] { "text1", "text2" }, 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2 }, "imageKey", group),
-            new Type[] { typeof(string[]), typeof(string) },
-            new object[] { new string[] { "text1", "text2" }, "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2 }, 1, group),
-            new Type[] { typeof(string[]), typeof(int) },
-            new object[] { new string[] { "text1", "text2" }, 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, "imageKey"),
-            new Type[] { typeof(ListViewItem.ListViewSubItem[]), typeof(string) },
-            new object[] { new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, 1),
-            new Type[] { typeof(ListViewItem.ListViewSubItem[]), typeof(int) },
-            new object[] { new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, "imageKey", group),
-            new Type[] { typeof(ListViewItem.ListViewSubItem[]), typeof(string) },
-            new object[] { new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, "imageKey" }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, 1, group),
-            new Type[] { typeof(ListViewItem.ListViewSubItem[]), typeof(int) },
-            new object[] { new ListViewItem.ListViewSubItem[] { subItem1, subItem2, subItem3, subItem4, subItem5 }, 1 }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem3 }, 1),
-            new Type[] { typeof(string[]), typeof(int), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text3" }, 1, Color.Blue, Color.Empty, null }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem4 }, 1),
-            new Type[] { typeof(string[]), typeof(int), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text4" }, 1, Color.Empty, Color.Blue, null }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem5 }, 1),
-            new Type[] { typeof(string[]), typeof(int), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text5" }, 1, Color.Empty, Color.Empty, SystemFonts.MenuFont }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem3 }, "imageKey"),
-            new Type[] { typeof(string[]), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text3" }, "imageKey", Color.Blue, Color.Empty, null }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem4 }, "imageKey"),
-            new Type[] { typeof(string[]), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text4" }, "imageKey", Color.Empty, Color.Blue, null }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new ListViewItem.ListViewSubItem[] { subItem5 }, "imageKey"),
-            new Type[] { typeof(string[]), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text5" }, "imageKey", Color.Empty, Color.Empty, SystemFonts.MenuFont }
-        };
-
-        // Custom style - text.
-        yield return new object[]
-        {
-            new ListViewItem(new string[] { "text" }, "imageKey", Color.Red, Color.Blue, SystemFonts.MenuFont),
-            new Type[] { typeof(string[]), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text" }, "imageKey", Color.Red, Color.Blue, SystemFonts.MenuFont }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new string[] { "text" }, 1, Color.Red, Color.Blue, SystemFonts.MenuFont),
-            new Type[] { typeof(string[]), typeof(int), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text" }, 1, Color.Red, Color.Blue, SystemFonts.MenuFont }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new string[] { "text" }, "imageKey", Color.Red, Color.Blue, SystemFonts.MenuFont, group),
-            new Type[] { typeof(string[]), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text" }, "imageKey", Color.Red, Color.Blue, SystemFonts.MenuFont }
-        };
-        yield return new object[]
-        {
-            new ListViewItem(new string[] { "text" }, 1, Color.Red, Color.Blue, SystemFonts.MenuFont, group),
-            new Type[] { typeof(string[]), typeof(int), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { new string[] { "text" }, 1, Color.Red, Color.Blue, SystemFonts.MenuFont }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertTo_InstanceDescriptor_TestData))]
-    public void ListViewItemConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ListViewItem value, Type[] parameterTypes, object[] arguments)
-    {
-        var converter = new ListViewItemConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(ListViewItem).GetConstructor(parameterTypes), descriptor.MemberInfo);
-        Assert.Equal(arguments, descriptor.Arguments);
-    }
-
-    [Theory]
-    [InlineData(null, "")]
-    [InlineData(1, "1")]
-    public void ListViewItemConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_ConvertTo_ValueNotThrowsNotSupportedException()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(ListViewItem))]
-    [InlineData(typeof(int))]
-    public void ListViewItemConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewItem(), destinationType));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.True(converter.GetPropertiesSupported(null));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        var converter = new ListViewItemConverter();
-        var item = new ListViewItem();
-        Assert.Equal(TypeDescriptor.GetProperties(item, null).Count, converter.GetProperties(null, item, null).Count);
-    }
-
-    [Fact]
-    public void ListViewItemConverter_GetStandardValues_Invoke_ReturnsNull()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.Null(converter.GetStandardValues(null));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_GetStandardValuesExclusive_Invoke_ReturnsFalse()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.False(converter.GetStandardValuesExclusive(null));
-    }
-
-    [Fact]
-    public void ListViewItemConverter_GetStandardValuesSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new ListViewItemConverter();
-        Assert.False(converter.GetStandardValuesSupported(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemMouseHoverEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemMouseHoverEventArgsTests.cs
deleted file mode 100644
index 76765d1bb5f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemMouseHoverEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewItemMouseHoverEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ListViewItem_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListViewItem() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewItem_TestData))]
-    public void Ctor_ListViewItem(ListViewItem item)
-    {
-        var e = new ListViewItemMouseHoverEventArgs(item);
-        Assert.Equal(item, e.Item);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemSelectionChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemSelectionChangedEventArgsTests.cs
deleted file mode 100644
index 8fbf1ee0f41..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemSelectionChangedEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewItemSelectionChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ListViewItem_Int_Bool_TestData()
-    {
-        yield return new object[] { null, -2, false };
-        yield return new object[] { new ListViewItem(), -1, true };
-        yield return new object[] { new ListViewItem(), 0, true };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewItem_Int_Bool_TestData))]
-    public void Ctor_ListViewItem_Int_Bool(ListViewItem item, int itemIndex, bool isSelected)
-    {
-        var e = new ListViewItemSelectionChangedEventArgs(item, itemIndex, isSelected);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(itemIndex, e.ItemIndex);
-        Assert.Equal(isSelected, e.IsSelected);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemStateImageIndexConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemStateImageIndexConverterTests.cs
deleted file mode 100644
index 858d6c877e0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemStateImageIndexConverterTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.ComponentModel.TypeConverter;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewItemStateImageIndexConverterTests
-{
-    [Fact]
-    public void ListViewItemStateImageIndexConverter_IncludeNoneAsStandardValue_ReturnsFalse()
-    {
-        Assert.False(new ListViewItemStateImageIndexConverter().TestAccessor().Dynamic.IncludeNoneAsStandardValue);
-    }
-
-    [Fact]
-    public void ListViewItemStateImageIndexConverter_GetStandardValues_Null_Context_ReturnsExpected()
-    {
-        var converter = new ListViewItemStateImageIndexConverter();
-
-        StandardValuesCollection result = converter.GetStandardValues(context: null);
-
-        Assert.Equal(0, result.Count);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemTests.cs
deleted file mode 100644
index a6b0ae2b6e0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewItemTests.cs
+++ /dev/null
@@ -1,1116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewItemTests
-{
-    [Fact]
-    public void ListViewItem_Ctor_Default()
-    {
-        var item = new ListViewItem();
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Empty(subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_String_Color_Color_Font_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, null, Color.Empty, Color.Empty, null, null, string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { Array.Empty<string>(), null, Color.Empty, Color.Empty, null, null, string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { null }, string.Empty, Color.Empty, Color.Empty, null, new ListViewGroup(), string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { "text" }, "imageKey", Color.Blue, Color.Red, SystemFonts.MenuFont, new ListViewGroup(), "imageKey", Color.Blue, Color.Red, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_String_Color_Color_Font_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_StringArray_String_Color_Color_Font_ListViewGroup(string[] subItems, string imageKey, Color foreColor, Color backColor, Font font, ListViewGroup group, string expectedImageKey, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey, foreColor, backColor, font, group);
-        Assert.Equal(expectedBackColor, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(font ?? Control.DefaultFont, item.Font);
-        Assert.Equal(expectedForeColor, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_Int_Color_Color_Font_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, -1, Color.Empty, Color.Empty, null, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { Array.Empty<string>(), 0, Color.Empty, Color.Empty, null, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { null }, 1, Color.Empty, Color.Empty, null, new ListViewGroup(), SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { "text" }, 2, Color.Blue, Color.Red, SystemFonts.MenuFont, new ListViewGroup(), Color.Blue, Color.Red, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_Int_Color_Color_Font_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_StringArray_Int_Color_Color_Font_ListViewGroup(string[] subItems, int imageIndex, Color foreColor, Color backColor, Font font, ListViewGroup group, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex, foreColor, backColor, font, group);
-        Assert.Equal(expectedBackColor, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(font ?? Control.DefaultFont, item.Font);
-        Assert.Equal(expectedForeColor, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_String_Color_Color_Font_TestData()
-    {
-        yield return new object[] { null, null, Color.Empty, Color.Empty, null, string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { Array.Empty<string>(), null, Color.Empty, Color.Empty, null, string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { null }, string.Empty, Color.Empty, Color.Empty, null, string.Empty, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { "text" }, "imageKey", Color.Blue, Color.Red, SystemFonts.MenuFont, "imageKey", Color.Blue, Color.Red, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_String_Color_Color_Font_TestData))]
-    public void ListViewItem_Ctor_StringArray_String_Color_Color_Font(string[] subItems, string imageKey, Color foreColor, Color backColor, Font font, string expectedImageKey, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey, foreColor, backColor, font);
-        Assert.Equal(expectedBackColor, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(font ?? Control.DefaultFont, item.Font);
-        Assert.Equal(expectedForeColor, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_Int_Color_Color_Font_TestData()
-    {
-        yield return new object[] { null, -1, Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { Array.Empty<string>(), 0, Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { null }, 1, Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new string[] { "text" }, 2, Color.Blue, Color.Red, SystemFonts.MenuFont, Color.Blue, Color.Red, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_Int_Color_Color_Font_TestData))]
-    public void ListViewItem_Ctor_StringArray_Int_Color_Color_Font(string[] subItems, int imageIndex, Color foreColor, Color backColor, Font font, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex, foreColor, backColor, font);
-        Assert.Equal(expectedBackColor, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(font ?? Control.DefaultFont, item.Font);
-        Assert.Equal(expectedForeColor, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewSubItemArray_String_ListViewGroup_TestData()
-    {
-        yield return new object[] { Array.Empty<ListViewItem.ListViewSubItem>(), null, null, string.Empty, string.Empty };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, string.Empty, null, string.Empty, "text" };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, "imageKey", new ListViewGroup(), "imageKey", "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewSubItemArray_String_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_ListViewSubItemArray_String_ListViewGroup(ListViewItem.ListViewSubItem[] subItems, string imageKey, ListViewGroup group, string expectedImageKey, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewSubItemArray_Int_ListViewGroup_TestData()
-    {
-        yield return new object[] { Array.Empty<ListViewItem.ListViewSubItem>(), 0, null, string.Empty };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, 1, null, "text" };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, -1, new ListViewGroup(), "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewSubItemArray_Int_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_ListViewSubItemArray_Int_ListViewGroup(ListViewItem.ListViewSubItem[] subItems, int imageIndex, ListViewGroup group, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_String_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, null, null, string.Empty, string.Empty };
-        yield return new object[] { Array.Empty<string>(), null, null, string.Empty, string.Empty };
-        yield return new object[] { new string[] { null }, string.Empty, new ListViewGroup(), string.Empty, string.Empty };
-        yield return new object[] { new string[] { "text" }, "imageKey", new ListViewGroup(), "imageKey", "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_String_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_StringArray_String_ListViewGroup(string[] subItems, string imageKey, ListViewGroup group, string expectedImageKey, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_Int_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, -1, null, string.Empty };
-        yield return new object[] { Array.Empty<string>(), 0, null, string.Empty };
-        yield return new object[] { new string[] { null }, 1, new ListViewGroup(), string.Empty };
-        yield return new object[] { new string[] { "text" }, 2, new ListViewGroup(), "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_Int_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_StringArray_Int_ListViewGroup(string[] subItems, int imageIndex, ListViewGroup group, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_String_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, null, null, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, new ListViewGroup(), string.Empty, string.Empty };
-        yield return new object[] { "text", "imageKey", new ListViewGroup(), "text", "imageKey" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_String_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_String_String_ListViewGroup(string text, string imageKey, ListViewGroup group, string expectedText, string expectedImageKey)
-    {
-        var item = new ListViewItem(text, imageKey, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Same(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Int_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, -1, null, string.Empty };
-        yield return new object[] { string.Empty, 0, new ListViewGroup(), string.Empty };
-        yield return new object[] { "text", 1, new ListViewGroup(), "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Int_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_String_Int_ListViewGroup(string text, int imageIndex, ListViewGroup group, string expectedText)
-    {
-        var item = new ListViewItem(text, imageIndex, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Same(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewSubItemArray_String_TestData()
-    {
-        yield return new object[] { Array.Empty<ListViewItem.ListViewSubItem>(), null, string.Empty, string.Empty };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, string.Empty, string.Empty, "text" };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, "imageKey", "imageKey", "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewSubItemArray_String_TestData))]
-    public void ListViewItem_Ctor_ListViewSubItemArray_String(ListViewItem.ListViewSubItem[] subItems, string imageKey, string expectedImageKey, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Same(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewSubItemArray_Int_TestData()
-    {
-        yield return new object[] { Array.Empty<ListViewItem.ListViewSubItem>(), 0, string.Empty };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, 1, "text" };
-        yield return new object[] { new ListViewItem.ListViewSubItem[] { new ListViewItem.ListViewSubItem(null, "text") }, -1, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewSubItemArray_Int_TestData))]
-    public void ListViewItem_Ctor_ListViewSubItemArray_Int(ListViewItem.ListViewSubItem[] subItems, int imageIndex, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { Array.Empty<string>(), null, string.Empty };
-        yield return new object[] { new string[] { null }, new ListViewGroup(), string.Empty };
-        yield return new object[] { new string[] { "text" }, new ListViewGroup(), "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_StringArray_ListViewGroup(string[] subItems, ListViewGroup group, string expectedText)
-    {
-        var item = new ListViewItem(subItems, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty, string.Empty };
-        yield return new object[] { Array.Empty<string>(), null, string.Empty, string.Empty };
-        yield return new object[] { new string[] { null }, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { new string[] { "text" }, "imageKey", "imageKey", "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_String_TestData))]
-    public void ListViewItem_Ctor_StringArray_String(string[] subItems, string imageKey, string expectedImageKey, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageKey);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Equal(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_Int_TestData()
-    {
-        yield return new object[] { null, -1, string.Empty };
-        yield return new object[] { Array.Empty<string>(), 0, string.Empty };
-        yield return new object[] { new string[] { null }, 1, string.Empty };
-        yield return new object[] { new string[] { "text" }, 2, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_Int_TestData))]
-    public void ListViewItem_Ctor_StringArray_Int(string[] subItems, int imageIndex, string expectedText)
-    {
-        var item = new ListViewItem(subItems, imageIndex);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_ListViewGroup_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { string.Empty, null, string.Empty };
-        yield return new object[] { "text", new ListViewGroup(), "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_String_ListViewGroup(string text, ListViewGroup group, string expectedText)
-    {
-        var item = new ListViewItem(text, group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Same(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Same(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty, string.Empty };
-        yield return new object[] { string.Empty, string.Empty, string.Empty, string.Empty };
-        yield return new object[] { "text", "imageKey", "text", "imageKey" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_String_TestData))]
-    public void ListViewItem_Ctor_String_String(string text, string imageKey, string expectedText, string expectedImageKey)
-    {
-        var item = new ListViewItem(text, imageKey);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Equal(expectedImageKey, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Equal(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Int_TestData()
-    {
-        yield return new object[] { null, -1, string.Empty };
-        yield return new object[] { string.Empty, 0, string.Empty };
-        yield return new object[] { "text", 1, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_String_Int_TestData))]
-    public void ListViewItem_Ctor_String_Int(string text, int imageIndex, string expectedText)
-    {
-        var item = new ListViewItem(text, imageIndex);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(imageIndex, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Equal(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewGroup_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListViewGroup() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ListViewGroup_TestData))]
-    public void ListViewItem_Ctor_ListViewGroup(ListViewGroup group)
-    {
-        var item = new ListViewItem(group);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Equal(group, item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Equal(string.Empty, item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Empty(subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    public static IEnumerable<object[]> Ctor_StringArray_TestData()
-    {
-        yield return new object[] { null, string.Empty };
-        yield return new object[] { Array.Empty<string>(), string.Empty };
-        yield return new object[] { new string[] { null }, string.Empty };
-        yield return new object[] { new string[] { "text" }, "text" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_StringArray_TestData))]
-    public void ListViewItem_Ctor_StringArray(string[] subItems, string expectedText)
-    {
-        var item = new ListViewItem(subItems);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        AssertEqualListViewSubItem(subItems, item.SubItems.Cast<ListViewItem.ListViewSubItem>().ToArray());
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ListViewItem_Ctor_String(string text, string expectedText)
-    {
-        var item = new ListViewItem(text);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-        Assert.Equal(Rectangle.Empty, item.Bounds);
-        Assert.False(item.Checked);
-        Assert.False(item.Focused);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-        Assert.Null(item.Group);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.ImageList);
-        Assert.Equal(0, item.IndentCount);
-        Assert.Equal(-1, item.Index);
-        Assert.Null(item.ListView);
-        Assert.Empty(item.Name);
-        Assert.Equal(new Point(-1, -1), item.Position);
-        Assert.False(item.Selected);
-        Assert.Equal(-1, item.StateImageIndex);
-        ListViewItem.ListViewSubItem subItem = Assert.Single(item.SubItems.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Equal(expectedText, subItem.Text);
-        Assert.Same(item.SubItems, item.SubItems);
-        Assert.Null(item.Tag);
-        Assert.Equal(expectedText, item.Text);
-        Assert.Empty(item.ToolTipText);
-        Assert.True(item.UseItemStyleForSubItems);
-    }
-
-    [Fact]
-    public void ListViewItem_Ctor_NullSubItems_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem((ListViewItem.ListViewSubItem[])null, "imageKey"));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem((ListViewItem.ListViewSubItem[])null, 1));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem((ListViewItem.ListViewSubItem[])null, "imageKey", new ListViewGroup()));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem((ListViewItem.ListViewSubItem[])null, 0, new ListViewGroup()));
-    }
-
-    [Fact]
-    public void ListViewItem_Ctor_NullValueInSubItems_ThrowsArgumentNullException()
-    {
-        var subItems = new ListViewItem.ListViewSubItem[] { null };
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem(subItems, "imageKey"));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem(subItems, 1));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem(subItems, "imageKey", new ListViewGroup()));
-        Assert.Throws<ArgumentNullException>("subItems", () => new ListViewItem(subItems, 1, new ListViewGroup()));
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListViewItem_BackColor_GetWithOwner_ReturnsExpected(Color value, Color expected)
-    {
-        using ListView listView = new()
-        {
-            BackColor = value
-        };
-
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        Assert.Equal(expected, item.BackColor);
-
-        // Remove item.
-        listView.Items.Remove(item);
-        Assert.Equal(SystemColors.Window, item.BackColor);
-    }
-
-    [Theory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListViewItem_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        var item = new ListViewItem
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, item.BackColor);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListViewItem_BackColor_SetWithOwner_GetReturnsExpected(Color value, Color expected)
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListViewItem_ForeColor_GetWithOwner_ReturnsExpected(Color value, Color expected)
-    {
-        using ListView listView = new()
-        {
-            ForeColor = value
-        };
-
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        Assert.Equal(expected, item.ForeColor);
-
-        // Remove item.
-        listView.Items.Remove(item);
-        Assert.Equal(SystemColors.WindowText, item.ForeColor);
-    }
-
-    [Theory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListViewItem_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        ListViewItem item = new()
-        {
-            ForeColor = value
-        };
-
-        Assert.Equal(expected, item.ForeColor);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListViewItem_ForeColor_SetWithOwner_GetReturnsExpected(Color value, Color expected)
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewItem_Font_GetWithOwner_ReturnsExpected(Font value)
-    {
-        using ListView listView = new()
-        {
-            Font = value
-        };
-
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        Assert.Equal(value ?? Control.DefaultFont, item.Font);
-
-        // Remove item.
-        listView.Items.Remove(item);
-        Assert.Equal(Control.DefaultFont, item.Font);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewItem_Font_Set_GetReturnsExpected(Font value)
-    {
-        var item = new ListViewItem
-        {
-            Font = value
-        };
-
-        Assert.Equal(value ?? Control.DefaultFont, item.Font);
-
-        // Set same.
-        item.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, item.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewItem_Font_SetWithOwner_GetReturnsExpected(Font value)
-    {
-        using ListView listView = new()
-        {
-            Font = SystemFonts.CaptionFont
-        };
-
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        item.Font = value;
-        Assert.Equal(value ?? SystemFonts.CaptionFont, item.Font);
-
-        // Set same.
-        item.Font = value;
-        Assert.Equal(value ?? SystemFonts.CaptionFont, item.Font);
-    }
-
-    [WinFormsFact]
-    public void ListViewItem_EnsureVisible_HasListViewWithoutHandle_Nop()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        item.EnsureVisible();
-    }
-
-    [Fact]
-    public void ListViewItem_EnsureVisible_NoListView_Nop()
-    {
-        var item = new ListViewItem();
-        item.EnsureVisible();
-    }
-
-    [WinFormsFact]
-    public void ListViewItem_Remove_HasListView_Success()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-        item.Remove();
-        Assert.Empty(listView.Items);
-        Assert.Null(item.ListView);
-    }
-
-    [Fact]
-    public void ListViewItem_Remove_NoListView_Nop()
-    {
-        var item = new ListViewItem();
-        item.Remove();
-    }
-
-    private static void AssertEqualListViewSubItem(string[] expected, ListViewItem.ListViewSubItem[] actual)
-    {
-        AssertEqualListViewSubItem(expected?.Select(t => new ListViewItem.ListViewSubItem(null, t)).ToArray(), actual);
-    }
-
-    private static void AssertEqualListViewSubItem(ListViewItem.ListViewSubItem[] expected, ListViewItem.ListViewSubItem[] actual)
-    {
-        if (expected is null || expected.Length == 0)
-        {
-            ListViewItem.ListViewSubItem subItem = Assert.Single(actual.Cast<ListViewItem.ListViewSubItem>());
-            Assert.Empty(subItem.Text);
-            return;
-        }
-
-        Assert.Equal(expected.Length, actual.Length);
-        for (int i = 0; i < expected.Length; i++)
-        {
-            Assert.Equal(expected[i].Name, actual[i].Name);
-            Assert.Equal(expected[i].Text, actual[i].Text);
-            Assert.Equal(expected[i].Tag, actual[i].Tag);
-        }
-    }
-
-    [Fact]
-    public void ListViewItem_AccessibilityObject_ThrowsInvalidOperationException_IfListViewNotExists()
-    {
-        ListViewItem item = new();
-
-        Assert.Throws<InvalidOperationException>(() => item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ListViewItem_AccessibilityObject_ReturnsExpected_IfListViewExists()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        Assert.NotNull(item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ListViewItem_AccessibilityObject_ThrowsInvalidOperationException_IfRemoved()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        Assert.NotNull(item.AccessibilityObject);
-
-        listView.Items.RemoveAt(0);
-
-        Assert.Throws<InvalidOperationException>(() => item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ListViewItem_AccessibilityObject_ThrowsInvalidOperationException_IfCleared()
-    {
-        using ListView listView = new();
-        ListViewItem item = new();
-        listView.Items.Add(item);
-
-        Assert.NotNull(item.AccessibilityObject);
-
-        listView.Items.Clear();
-
-        Assert.Throws<InvalidOperationException>(() => item.AccessibilityObject);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewLabelEditAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewLabelEditAccessibleObjectTests.cs
deleted file mode 100644
index adb2beca89f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewLabelEditAccessibleObjectTests.cs
+++ /dev/null
@@ -1,187 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewLabelEditAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.Equal(accessibilityObject.RuntimeId, accessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId));
-        PInvoke.GetWindowRect(labelEdit, out RECT r);
-        Assert.Equal(UiaTextProvider.BoundingRectangleAsArray((Rectangle)r), accessibilityObject.GetPropertyValue(UiaCore.UIA.BoundingRectanglePropertyId));
-        Assert.Equal(Environment.ProcessId, accessibilityObject.GetPropertyValue(UiaCore.UIA.ProcessIdPropertyId));
-        Assert.Equal(UiaCore.UIA.EditControlTypeId, accessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.Equal(accessibilityObject.Name, accessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-        Assert.Empty((string)accessibilityObject.GetPropertyValue(UiaCore.UIA.AccessKeyPropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsKeyboardFocusablePropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(listView.Enabled, (bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal("1", accessibilityObject.GetPropertyValue(UiaCore.UIA.AutomationIdPropertyId));
-        Assert.Empty((string)accessibilityObject.GetPropertyValue(UiaCore.UIA.HelpTextPropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsContentElementPropertyId));
-        Assert.False((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsPasswordPropertyId));
-        Assert.Equal(labelEdit.Handle, accessibilityObject.GetPropertyValue(UiaCore.UIA.NativeWindowHandlePropertyId));
-        Assert.False((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsTextPatternAvailablePropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsTextPattern2AvailablePropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsValuePatternAvailablePropertyId));
-        Assert.True((bool)accessibilityObject.GetPropertyValue(UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.True(listView.IsHandleCreated);
-        Assert.True(labelEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_FragmentNavigate_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.Equal(listView.AccessibilityObject, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(listView.Items[0].AccessibilityObject, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_IsPatternSupported_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.True(accessibilityObject.IsPatternSupported(UiaCore.UIA.TextPatternId));
-        Assert.True(accessibilityObject.IsPatternSupported(UiaCore.UIA.TextPattern2Id));
-        Assert.True(accessibilityObject.IsPatternSupported(UiaCore.UIA.ValuePatternId));
-        Assert.True(accessibilityObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId));
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_RuntimeId_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.Equal(new int[] { AccessibleObject.RuntimeIDFirstItem, PARAM.ToInt(labelEdit.Handle) }, accessibilityObject.RuntimeId);
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.Equal(listView.AccessibilityObject, accessibilityObject.FragmentRoot);
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_HostRawElementProvider_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.NotNull(accessibilityObject.HostRawElementProvider);
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_Name_ReturnsExpected()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-        ListViewLabelEditAccessibleObject accessibilityObject = (ListViewLabelEditAccessibleObject)labelEdit.AccessibilityObject;
-
-        Assert.Equal(listView.Items[0].Text, accessibilityObject.Name);
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditAccessibleObject_Ctor_NullOwningListView_ThrowsArgumentNullException()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-
-        Assert.Throws<ArgumentNullException>(() => new ListViewLabelEditAccessibleObject(null, labelEdit));
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditNativeWindow_Ctor_NullOwningListView_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ListViewLabelEditNativeWindow(null));
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditUiaTextProvider_Ctor_NullOwningListView_ThrowsArgumentNullException()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-
-        Assert.Throws<ArgumentNullException>(() => new ListViewLabelEditUiaTextProvider(null, labelEdit, labelEdit.AccessibilityObject));
-    }
-
-    [WinFormsFact]
-    public void ListViewLabelEditUiaTextProvider_Ctor_NullChildEditAccessibilityObject_ThrowsArgumentNullException()
-    {
-        using ListView listView = CreateListViewAndStartEditing();
-        ListViewLabelEditNativeWindow labelEdit = listView.TestAccessor().Dynamic._labelEdit;
-
-        Assert.Throws<ArgumentNullException>(() => new ListViewLabelEditUiaTextProvider(listView, labelEdit, null));
-    }
-
-    private ListView CreateListViewAndStartEditing()
-    {
-        SubListView listView = new()
-        {
-            Size = new Size(300, 200),
-            View = View.Details,
-            LabelEdit = true
-        };
-
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 1", Width = 100 });
-
-        ListViewItem item = new("Test");
-        listView.Items.Add(item);
-
-        listView.CreateControl();
-
-        PInvoke.SetFocus(listView);
-
-        PInvoke.SendMessage(listView, PInvoke.LVM_EDITLABELW, wParam: 0);
-
-        return listView;
-    }
-
-    private class SubListView : ListView
-    {
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                // End the label edit because ListView cannot be correctly disposed with an active label edit when AccessibilityObject is created for the ListView
-                PInvoke.SendMessage(this, PInvoke.LVM_CANCELEDITLABEL);
-            }
-
-            base.Dispose(disposing);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemCollectionTests.cs
deleted file mode 100644
index 8d2b8805e6a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemCollectionTests.cs
+++ /dev/null
@@ -1,1128 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewSubItemCollectionTests
-{
-    [Fact]
-    public void ListViewSubItemCollection_Ctor_ListViewItem()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new ListViewItem.ListViewSubItemCollection(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IList_GetProperties_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.True(collection.IsSynchronized);
-        Assert.Same(collection, collection.SyncRoot);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Item_GetValidIndex_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-        Assert.Same(subItem, collection[0]);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_Item_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Item_SetValidIndex_GetReturnsExpected()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection[0] = subItem;
-        Assert.Same(subItem, collection[0]);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_Item_SetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new ListViewItem.ListViewSubItem());
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Item_SetNull_ThrowsArgumentNullException()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListItem_GetValidIndex_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-        Assert.Same(subItem, collection[0]);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_IListItem_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListItem_SetValidIndex_GetReturnsExpected()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection[0] = subItem;
-        Assert.Same(subItem, collection[0]);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_IListItem_SetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewSubItemCollection_IList_SetInvalidValue_ThrowsArgumentException(object value)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentException>("value", () => collection[0] = value);
-    }
-
-    [Theory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("longer", -1)]
-    [InlineData("sm", -1)]
-    [InlineData("text", 1)]
-    [InlineData("tsxt", -1)]
-    [InlineData("TEXT", 1)]
-    public void ListViewSubItemCollection_Item_GetString_ReturnsExpected(string key, int expectedIndex)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem();
-        var subItem2 = new ListViewItem.ListViewSubItem
-        {
-            Name = "text"
-        };
-        collection.Add(subItem1);
-        collection.Add(subItem2);
-
-        Assert.Equal(expectedIndex != -1 ? collection[expectedIndex] : null, collection[key]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Add_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-        Assert.Same(subItem, Assert.Single(collection));
-        Assert.Equal(item, subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Add_ManyItems_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        for (int i = 0; i < 4096; i++)
-        {
-            var subItem = new ListViewItem.ListViewSubItem();
-            collection.Add(subItem);
-            Assert.Same(subItem, collection[i]);
-        }
-
-        Assert.Throws<InvalidOperationException>(() => collection.Add(new ListViewItem.ListViewSubItem()));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Add_ListViewSubItemExists_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-        collection.Add(subItem);
-        Assert.Equal(2, collection.Count);
-        Assert.Equal(subItem, collection[0]);
-        Assert.Equal(subItem, collection[1]);
-        Assert.Equal(item, subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Add_ListViewSubItemExistsInOtherCollection_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        var otherItem = new ListViewItem();
-        var otherCollection = new ListViewItem.ListViewSubItemCollection(item);
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        otherCollection.Add(subItem);
-
-        collection.Add(subItem);
-        Assert.Same(subItem, collection[0]);
-        Assert.Same(subItem, otherCollection[0]);
-        Assert.Equal(item, subItem._owner);
-    }
-
-    [Theory]
-    [NormalizedStringData]
-    public void ListViewSubItemCollection_Add_String_Success(string text, string expectedText)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            text
-        };
-        ListViewItem.ListViewSubItem subItem = Assert.Single(collection.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Equal(expectedText, subItem.Text);
-        Assert.Equal(item, subItem._owner);
-    }
-
-    public static IEnumerable<object[]> Add_String_Color_Color_Font_TestData()
-    {
-        yield return new object[] { null, Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { string.Empty, Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, string.Empty };
-        yield return new object[] { "reasonable", Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, "reasonable" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Add_String_Color_Color_Font_TestData))]
-    public void ListViewSubItemCollection_Add_String_Color_Color_Font_Success(string text, Color foreColor, Color backColor, Font font, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            { text, foreColor, backColor, font }
-        };
-        ListViewItem.ListViewSubItem subItem = Assert.Single(collection.Cast<ListViewItem.ListViewSubItem>());
-        Assert.Same(expectedText, subItem.Text);
-        Assert.Equal(expectedForeColor, subItem.ForeColor);
-        Assert.Equal(expectedBackColor, subItem.BackColor);
-        Assert.Equal(font ?? Control.DefaultFont, subItem.Font);
-        Assert.Equal(item, subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Add_NullItem_ThrowsArgumentNullException()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentNullException>("item", () => collection.Add((ListViewItem.ListViewSubItem)null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListAdd_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-        Assert.Same(subItem, Assert.Single(collection));
-        Assert.Equal(item, subItem._owner);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewSubItemCollection_IListAdd_NotListViewSubItem_ThrowsArgumentException(object value)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentException>("item", () => collection.Add(value));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_AddRange_ListViewSubItemArray_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem(null, "text1");
-        var subItem2 = new ListViewItem.ListViewSubItem(null, "text2");
-        var items = new ListViewItem.ListViewSubItem[] { subItem1, null, subItem2 };
-        collection.AddRange(items);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Same(subItem1, collection[0]);
-        Assert.Same(subItem2, collection[1]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_AddRange_LargeListViewSubItemArrayWithItems_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem(null, "text1");
-        var subItem2 = new ListViewItem.ListViewSubItem(null, "text2");
-        var subItem3 = new ListViewItem.ListViewSubItem(null, "text3");
-        var subItem4 = new ListViewItem.ListViewSubItem(null, "text4");
-        var items = new ListViewItem.ListViewSubItem[] { subItem1, null, subItem2, subItem3, subItem4 };
-        collection.AddRange(items);
-
-        Assert.Equal(4, collection.Count);
-        Assert.Same(subItem1, collection[0]);
-        Assert.Same(subItem2, collection[1]);
-        Assert.Same(subItem3, collection[2]);
-        Assert.Same(subItem4, collection[3]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_AddRange_LargeListViewSubItemArrayWithoutItems_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem(null, "text1");
-        var subItem2 = new ListViewItem.ListViewSubItem(null, "text2");
-        var subItem3 = new ListViewItem.ListViewSubItem(null, "text3");
-        var subItem4 = new ListViewItem.ListViewSubItem(null, "text4");
-        var subItem5 = new ListViewItem.ListViewSubItem(null, "text5");
-        var subItem6 = new ListViewItem.ListViewSubItem(null, "text6");
-        var subItem7 = new ListViewItem.ListViewSubItem(null, "text7");
-        var subItem8 = new ListViewItem.ListViewSubItem(null, "text8");
-        var subItem9 = new ListViewItem.ListViewSubItem(null, "text8");
-        var items = new ListViewItem.ListViewSubItem[] { subItem2, null, subItem3, subItem4, subItem5, subItem6, subItem7, subItem8, subItem9 };
-        collection.Add(subItem1);
-        collection.AddRange(items);
-
-        Assert.Equal(9, collection.Count);
-        Assert.Same(subItem1, collection[0]);
-        Assert.Same(subItem2, collection[1]);
-        Assert.Same(subItem3, collection[2]);
-        Assert.Same(subItem4, collection[3]);
-        Assert.Same(subItem5, collection[4]);
-        Assert.Same(subItem6, collection[5]);
-        Assert.Same(subItem7, collection[6]);
-        Assert.Same(subItem8, collection[7]);
-        Assert.Same(subItem9, collection[8]);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_AddRange_StringArray_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var items = new string[] { "text1", null, "text2" };
-        collection.AddRange(items);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("text1", collection[0].Text);
-        Assert.Equal("text2", collection[1].Text);
-    }
-
-    public static IEnumerable<object[]> AddRange_StringArrayWithStyles_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue };
-        yield return new object[] { Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue };
-    }
-
-    [Theory]
-    [MemberData(nameof(AddRange_StringArrayWithStyles_TestData))]
-    public void ListViewSubItemCollection_AddRange_StringArrayWithStyles_Success(Color foreColor, Color backColor, Font font, Color expectedForeColor, Color expectedBackColor)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var items = new string[] { "text1", null, "text2" };
-        collection.AddRange(items, foreColor, backColor, font);
-
-        Assert.Equal(2, collection.Count);
-        Assert.Equal("text1", collection[0].Text);
-        Assert.Equal(expectedForeColor, collection[0].ForeColor);
-        Assert.Equal(expectedBackColor, collection[0].BackColor);
-        Assert.Equal(font ?? Control.DefaultFont, collection[0].Font);
-        Assert.Equal("text2", collection[1].Text);
-        Assert.Equal(expectedForeColor, collection[1].ForeColor);
-        Assert.Equal(expectedBackColor, collection[1].BackColor);
-        Assert.Equal(font ?? Control.DefaultFont, collection[1].Font);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_AddRange_NullList_ThrowsArgumentNullException()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((ListViewItem.ListViewSubItem[])null));
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((string[])null));
-        Assert.Throws<ArgumentNullException>("items", () => collection.AddRange((string[])null, Color.Red, Color.Blue, SystemFonts.MenuFont));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Clear_Invoke_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-
-        // Clear again.
-        collection.Clear();
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Clear_Empty_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        collection.Clear();
-        Assert.Empty(collection);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Contains_Invoke_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        Assert.True(collection.Contains(subItem));
-        Assert.False(collection.Contains(new ListViewItem.ListViewSubItem()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Contains_Empty_ReturnsFalse()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.False(collection.Contains(new ListViewItem.ListViewSubItem()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Theory]
-    [InlineData(null, false)]
-    [InlineData("", false)]
-    [InlineData("longer", false)]
-    [InlineData("sm", false)]
-    [InlineData("text", true)]
-    [InlineData("tsxt", false)]
-    [InlineData("TEXT", true)]
-    public void ListViewSubItemCollection_ContainsKey_Invoke_ReturnsExpected(string key, bool expected)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem();
-        var subItem2 = new ListViewItem.ListViewSubItem
-        {
-            Name = "text"
-        };
-        collection.Add(subItem1);
-        collection.Add(subItem2);
-
-        Assert.Equal(expected, collection.ContainsKey(key));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_ContainsKey_Empty_ReturnsFalse()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.False(collection.ContainsKey("text"));
-        Assert.False(collection.ContainsKey(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListContains_Invoke_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        Assert.True(collection.Contains(subItem));
-        Assert.False(collection.Contains(new ListViewItem.ListViewSubItem()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListContains_Empty_ReturnsFalse()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.False(collection.Contains(new ListViewItem.ListViewSubItem()));
-        Assert.False(collection.Contains(new object()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        Assert.Equal(0, collection.IndexOf(subItem));
-        Assert.Equal(-1, collection.IndexOf(new ListViewItem.ListViewSubItem()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IndexOf_Empty_ReturnsFalse()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.Equal(-1, collection.IndexOf(new ListViewItem.ListViewSubItem()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Theory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("longer", -1)]
-    [InlineData("sm", -1)]
-    [InlineData("text", 1)]
-    [InlineData("tsxt", -1)]
-    [InlineData("TEXT", 1)]
-    public void ListViewSubItemCollection_IndexOfKey_Invoke_ReturnsExpected(string key, int expected)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem();
-        var subItem2 = new ListViewItem.ListViewSubItem
-        {
-            Name = "text"
-        };
-        collection.Add(subItem1);
-        collection.Add(subItem2);
-
-        Assert.Equal(expected, collection.IndexOfKey(key));
-
-        // Call again to validate caching behaviour.
-        Assert.Equal(expected, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("noSuchKey"));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IndexOfKey_Empty_ReturnsFalse()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.Equal(-1, collection.IndexOfKey("text"));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListIndexOf_Invoke_ReturnsExpected()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        Assert.Equal(0, collection.IndexOf(subItem));
-        Assert.Equal(-1, collection.IndexOf(new ListViewItem.ListViewSubItem()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListIndexOf_Empty_ReturnsMinusOne()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-
-        Assert.Equal(-1, collection.IndexOf(new ListViewItem.ListViewSubItem()));
-        Assert.Equal(-1, collection.IndexOf(new object()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Insert_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(new ListViewItem.ListViewSubItem());
-        collection.Insert(1, subItem);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(subItem, collection[1]);
-        Assert.Same(item, subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Insert_ManyItems_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        for (int i = 0; i < 4096; i++)
-        {
-            var subItem = new ListViewItem.ListViewSubItem();
-            collection.Insert(0, subItem);
-            Assert.Same(subItem, collection[0]);
-        }
-
-        Assert.Throws<InvalidOperationException>(() => collection.Add(new ListViewItem.ListViewSubItem()));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Insert_NullItem_ThrowsArgumentNullException()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentNullException>("item", () => collection.Insert(1, null));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_Insert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, null));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListInsert_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(new ListViewItem.ListViewSubItem());
-        collection.Insert(1, subItem);
-        Assert.Equal(2, collection.Count);
-        Assert.Same(subItem, collection[1]);
-        Assert.Same(item, subItem._owner);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewSubItemCollection_IListInsert_InvalidItem_ThrowsArgumentException(object value)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentException>("item", () => collection.Insert(0, value));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_IListInsert_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, new ListViewItem.ListViewSubItem()));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_Remove_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        // Remove null.
-        collection.Remove(null);
-        Assert.Same(subItem, Assert.Single(collection));
-
-        collection.Remove(subItem);
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-
-        // Remove again.
-        collection.Remove(subItem);
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_IListRemove_ListViewSubItem_Success()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        collection.Remove(subItem);
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-
-        // Remove again.
-        collection.Remove(subItem);
-        Assert.Empty(collection);
-        Assert.Null(subItem._owner);
-    }
-
-    [Theory]
-    [InlineData(null)]
-    [InlineData("text")]
-    public void ListViewSubItemCollection_IListRemove_InvalidItem_Nop(object value)
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        collection.Remove(value);
-        Assert.Same(subItem, Assert.Single(collection));
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_RemoveAt_ValidIndex_Success()
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem1 = new ListViewItem.ListViewSubItem();
-        var subItem2 = new ListViewItem.ListViewSubItem();
-        var subItem3 = new ListViewItem.ListViewSubItem();
-        var subItem4 = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem1);
-        collection.Add(subItem2);
-        collection.Add(subItem3);
-        collection.Add(subItem4);
-
-        // Remove from start.
-        collection.RemoveAt(0);
-        Assert.Equal(3, collection.Count);
-        Assert.Null(subItem1._owner);
-        Assert.Same(item, subItem2._owner);
-        Assert.Same(item, subItem3._owner);
-        Assert.Same(item, subItem4._owner);
-
-        // Remove from middle.
-        collection.RemoveAt(1);
-        Assert.Equal(2, collection.Count);
-        Assert.Null(subItem1._owner);
-        Assert.Same(item, subItem2._owner);
-        Assert.Null(subItem3._owner);
-        Assert.Same(item, subItem4._owner);
-
-        // Remove from end.
-        collection.RemoveAt(1);
-        Assert.Single(collection);
-        Assert.Null(subItem1._owner);
-        Assert.Same(item, subItem2._owner);
-        Assert.Null(subItem3._owner);
-        Assert.Null(subItem4._owner);
-
-        // Remove only.
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-        Assert.Null(subItem1._owner);
-        Assert.Null(subItem2._owner);
-        Assert.Null(subItem3._owner);
-        Assert.Null(subItem4._owner);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void ListViewSubItemCollection_RemoveAt_InvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item)
-        {
-            new ListViewItem.ListViewSubItem()
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void ListViewSubItemCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [Theory]
-    [InlineData(null, 1)]
-    [InlineData("", 1)]
-    [InlineData("longer", 1)]
-    [InlineData("sm", 1)]
-    [InlineData("text", 0)]
-    [InlineData("tsxt", 1)]
-    [InlineData("TEXT", 0)]
-    public void ListViewSubItemCollection_RemoveByKey_Invoke_Success(string key, int expectedCount)
-    {
-        var item = new ListViewItem();
-        var collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            Name = "text"
-        };
-        collection.Add(subItem);
-
-        collection.RemoveByKey(key);
-        Assert.Equal(expectedCount, collection.Count);
-        if (expectedCount == 1)
-        {
-            Assert.Same(item, subItem._owner);
-        }
-        else
-        {
-            Assert.Null(subItem._owner);
-        }
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_CopyTo_NonEmpty_Success()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        collection.Add(subItem);
-
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, subItem, 3 }, array);
-    }
-
-    [Fact]
-    public void ListViewSubItemCollection_CopyTo_Empty_Nop()
-    {
-        var item = new ListViewItem();
-        IList collection = new ListViewItem.ListViewSubItemCollection(item);
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 0);
-        Assert.Equal(new object[] { 1, 2, 3 }, array);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_Add_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem = new();
-
-        Assert.Null(subItem._owner);
-
-        listViewItem.SubItems.Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_Add_String_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-
-        listViewItem.SubItems.Add("Test");
-
-        Assert.Same(listViewItem, listViewItem.SubItems[1]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_Add_String_Color_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-
-        listViewItem.SubItems.Add("Test", Color.White, Color.Black, SystemFonts.MenuFont);
-
-        Assert.Same(listViewItem, listViewItem.SubItems[1]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_AddRange_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem1 = new();
-        ListViewItem.ListViewSubItem subItem2 = new();
-
-        Assert.Null(subItem1._owner);
-        Assert.Null(subItem2._owner);
-
-        listViewItem.SubItems.AddRange(new ListViewItem.ListViewSubItem[] { subItem1, subItem2 });
-
-        Assert.Same(listViewItem, subItem1._owner);
-        Assert.Same(listViewItem, subItem2._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_AddRange_String_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-
-        listViewItem.SubItems.AddRange(new string[] { "Test 1", "Test 2" });
-
-        Assert.Same(listViewItem, listViewItem.SubItems[1]._owner);
-        Assert.Same(listViewItem, listViewItem.SubItems[2]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_AddRange_String_Color_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-
-        listViewItem.SubItems.AddRange(new string[] { "Test 1", "Test 2" }, Color.White, Color.Black, SystemFonts.MenuFont);
-
-        Assert.Same(listViewItem, listViewItem.SubItems[1]._owner);
-        Assert.Same(listViewItem, listViewItem.SubItems[2]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_Clear_RemoveOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem1 = new();
-        ListViewItem.ListViewSubItem subItem2 = new();
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-
-        listViewItem.SubItems.Add(subItem1);
-        listViewItem.SubItems.Add(subItem2);
-
-        Assert.Same(listViewItem, oldSubItem._owner);
-        Assert.Same(listViewItem, subItem1._owner);
-        Assert.Same(listViewItem, subItem1._owner);
-
-        listViewItem.SubItems.Clear();
-
-        Assert.Same(listViewItem, listViewItem.SubItems[0]._owner);
-        Assert.Null(oldSubItem._owner);
-        Assert.Null(subItem1._owner);
-        Assert.Null(subItem1._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_IList_Add_SetOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem = new();
-
-        Assert.Null(subItem._owner);
-
-        ((IList)listViewItem.SubItems).Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_IList_Insert_AddOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem1 = new();
-        ListViewItem.ListViewSubItem subItem2 = new();
-        ListViewItem.ListViewSubItem oldSubItem1 = listViewItem.SubItems[0];
-        ListViewItem.ListViewSubItem oldSubItem2 = new();
-        listViewItem.SubItems.Add(oldSubItem2);
-
-        Assert.Null(subItem1._owner);
-        Assert.Null(subItem2._owner);
-        Assert.Same(listViewItem, oldSubItem1._owner);
-        Assert.Same(listViewItem, oldSubItem2._owner);
-
-        ((IList)listViewItem.SubItems).Insert(0, subItem1);
-        ((IList)listViewItem.SubItems).Insert(1, subItem2);
-
-        Assert.Equal(4, listViewItem.SubItems.Count);
-
-        Assert.Same(subItem1, listViewItem.SubItems[0]);
-        Assert.Same(subItem2, listViewItem.SubItems[1]);
-        Assert.Same(oldSubItem1, listViewItem.SubItems[2]);
-        Assert.Same(oldSubItem2, listViewItem.SubItems[3]);
-
-        Assert.Same(listViewItem, oldSubItem1._owner);
-        Assert.Same(listViewItem, oldSubItem2._owner);
-        Assert.Same(listViewItem, subItem1._owner);
-        Assert.Same(listViewItem, subItem2._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_IList_Remove_RemoveOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-        ListViewItem.ListViewSubItem subItem = new();
-        listViewItem.SubItems.Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-        Assert.Same(listViewItem, oldSubItem._owner);
-
-        listViewItem.SubItems.Remove(subItem);
-        listViewItem.SubItems.Remove(oldSubItem);
-
-        Assert.Same(listViewItem, listViewItem.SubItems[0]._owner);
-        Assert.Null(subItem._owner);
-        Assert.Null(oldSubItem._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_IList_Set_UpdateOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem = new();
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-
-        Assert.Same(listViewItem, oldSubItem._owner);
-        Assert.Null(subItem._owner);
-
-        ((IList)listViewItem.SubItems)[0] = subItem;
-
-        Assert.Null(oldSubItem._owner);
-        Assert.Same(listViewItem, subItem._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_Insert_UpdateOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem subItem1 = new();
-        ListViewItem.ListViewSubItem subItem2 = new();
-        ListViewItem.ListViewSubItem defaultSubItem = listViewItem.SubItems[0];
-
-        Assert.Null(subItem1._owner);
-        Assert.Null(subItem2._owner);
-        Assert.Same(listViewItem, defaultSubItem._owner);
-
-        listViewItem.SubItems.Insert(0, subItem1);
-        listViewItem.SubItems.Insert(1, subItem2);
-
-        Assert.Equal(3, listViewItem.SubItems.Count);
-
-        Assert.Same(listViewItem, defaultSubItem._owner);
-        Assert.Same(listViewItem, subItem1._owner);
-        Assert.Same(listViewItem, subItem2._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_Remove_RemoveOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-        ListViewItem.ListViewSubItem subItem = new();
-        listViewItem.SubItems.Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-        Assert.Same(listViewItem, oldSubItem._owner);
-
-        listViewItem.SubItems.Remove(subItem);
-        listViewItem.SubItems.Remove(oldSubItem);
-
-        Assert.Null(subItem._owner);
-        Assert.Null(oldSubItem._owner);
-        Assert.Same(listViewItem, listViewItem.SubItems[0]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_RemoveAt_RemoveOwner()
-    {
-        ListViewItem listViewItem = new();
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-        ListViewItem.ListViewSubItem subItem = new();
-        listViewItem.SubItems.Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-        Assert.Same(listViewItem, oldSubItem._owner);
-
-        listViewItem.SubItems.RemoveAt(1);
-        listViewItem.SubItems.RemoveAt(0);
-
-        Assert.Null(subItem._owner);
-        Assert.Null(oldSubItem._owner);
-        Assert.Same(listViewItem, listViewItem.SubItems[0]._owner);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItemCollection_RemoveByKey_RemoveOwner()
-    {
-        ListViewItem listViewItem = new("Test 1");
-        ListViewItem.ListViewSubItem oldSubItem = listViewItem.SubItems[0];
-        oldSubItem.Name = "Test 1";
-        ListViewItem.ListViewSubItem subItem = new(listViewItem, "Test 2") { Name = "Test 2"  };
-        listViewItem.SubItems.Add(subItem);
-
-        Assert.Same(listViewItem, subItem._owner);
-        Assert.Same(listViewItem, oldSubItem._owner);
-
-        listViewItem.SubItems.RemoveByKey("Test 2");
-        listViewItem.SubItems.RemoveByKey("Test 1");
-
-        Assert.Null(subItem._owner);
-        Assert.Null(oldSubItem._owner);
-        Assert.Same(listViewItem, listViewItem.SubItems[0]._owner);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemConverterTests.cs
deleted file mode 100644
index 06f3db24544..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemConverterTests.cs
+++ /dev/null
@@ -1,144 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewSubItemConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(ListViewItem.ListViewSubItem), false)]
-    [InlineData(typeof(string), false)]
-    public void ListViewSubItemConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    [Theory]
-    [InlineData("value")]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void ListViewSubItemConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(ListViewItem.ListViewSubItem), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void ListViewSubItemConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    public static IEnumerable<object[]> ConvertTo_InstanceDescriptor_TestData()
-    {
-        var item = new ListViewItem();
-        yield return new object[]
-        {
-            new ListViewItem.ListViewSubItem(item, "text"),
-            new Type[] { typeof(ListViewItem), typeof(string) },
-            new object[] { null, "text" }
-        };
-
-        yield return new object[]
-        {
-            new ListViewItem.ListViewSubItem(null, "text", Color.Red, Color.Blue, SystemFonts.MenuFont),
-            new Type[] { typeof(ListViewItem), typeof(string), typeof(Color), typeof(Color), typeof(Font) },
-            new object[] { null, "text", Color.Red, Color.Blue, SystemFonts.MenuFont }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertTo_InstanceDescriptor_TestData))]
-    public void ListViewSubItemConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ListViewItem.ListViewSubItem value, Type[] parameterTypes, object[] arguments)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(ListViewItem.ListViewSubItem).GetConstructor(parameterTypes), descriptor.MemberInfo);
-        Assert.Equal(arguments, descriptor.Arguments);
-    }
-
-    [Theory]
-    [InlineData(null, "")]
-    [InlineData(1, "1")]
-    public void ListViewSubItemConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_ConvertTo_ValueNotThrowsNotSupportedException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(ListViewItem.ListViewSubItem))]
-    [InlineData(typeof(int))]
-    public void ListViewSubItemConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new ListViewItem.ListViewSubItem(), destinationType));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.True(converter.GetPropertiesSupported(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        var item = new ListViewItem.ListViewSubItem();
-        Assert.Equal(TypeDescriptor.GetProperties(item, null).Count, converter.GetProperties(null, item, null).Count);
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_GetStandardValues_Invoke_ReturnsNull()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.Null(converter.GetStandardValues(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_GetStandardValuesExclusive_Invoke_ReturnsFalse()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.False(converter.GetStandardValuesExclusive(null));
-    }
-
-    [Fact]
-    public void ListViewSubItemConverter_GetStandardValuesSupported_Invoke_ReturnsFalse()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(ListViewItem.ListViewSubItem));
-        Assert.False(converter.GetStandardValuesSupported(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemTests.cs
deleted file mode 100644
index 7e0a8d29d22..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewSubItemTests.cs
+++ /dev/null
@@ -1,604 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewSubItemTests
-{
-    [Fact]
-    public void ListViewSubItem_Ctor_Default()
-    {
-        var subItem = new ListViewItem.ListViewSubItem();
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Rectangle.Empty, subItem.Bounds);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-        Assert.Empty(subItem.Name);
-        Assert.Null(subItem.Tag);
-        Assert.Empty(subItem.Text);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewItem_String_TestData()
-    {
-        yield return new object[] { null, null, string.Empty };
-        yield return new object[] { new ListViewItem(), string.Empty, string.Empty };
-        yield return new object[] { new ListViewItem(), "reasonable", "reasonable" };
-        yield return new object[] { new ListViewItem() { BackColor = Color.Yellow, ForeColor = Color.Yellow, Font = SystemFonts.StatusFont }, "reasonable", "reasonable" };
-
-        var listView = new ListView();
-        var item = new ListViewItem();
-        Assert.Null(item.ListView);
-        yield return new object[] { item, "reasonable", "reasonable" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ListViewItem_String_TestData))]
-    public void ListViewSubItem_Ctor_ListViewItem_String(ListViewItem owner, string text, string expectedText)
-    {
-        var subItem = new ListViewItem.ListViewSubItem(owner, text);
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Rectangle.Empty, subItem.Bounds);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-        Assert.Empty(subItem.Name);
-        Assert.Null(subItem.Tag);
-        Assert.Equal(expectedText, subItem.Text);
-    }
-
-    public static IEnumerable<object[]> Ctor_ListViewItem_String_Color_Color_Font_TestData()
-    {
-        yield return new object[] { null, null, Color.Empty, Color.Empty, null, SystemColors.WindowText, SystemColors.Window, string.Empty };
-        yield return new object[] { new ListViewItem(), string.Empty, Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, string.Empty };
-        yield return new object[] { new ListViewItem(), "reasonable", Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, "reasonable" };
-        yield return new object[] { new ListViewItem() { BackColor = Color.Yellow, ForeColor = Color.Yellow, Font = SystemFonts.StatusFont }, string.Empty, Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, string.Empty };
-
-        var item = new ListViewItem();
-        Assert.Null(item.ListView);
-        yield return new object[] { item, "reasonable", Color.Red, Color.Blue, SystemFonts.MenuFont, Color.Red, Color.Blue, "reasonable" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ListViewItem_String_Color_Color_Font_TestData))]
-    public void ListViewSubItem_Ctor_ListViewItem_String_Color_Color_Font(ListViewItem owner, string text, Color foreColor, Color backColor, Font font, Color expectedForeColor, Color expectedBackColor, string expectedText)
-    {
-        var subItem = new ListViewItem.ListViewSubItem(owner, text, foreColor, backColor, font);
-        Assert.Equal(expectedBackColor, subItem.BackColor);
-        Assert.Equal(Rectangle.Empty, subItem.Bounds);
-        Assert.Equal(font ?? Control.DefaultFont, subItem.Font);
-        Assert.Equal(expectedForeColor, subItem.ForeColor);
-        Assert.Empty(subItem.Name);
-        Assert.Null(subItem.Tag);
-        Assert.Equal(expectedText, subItem.Text);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_BackColor_GetWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            BackColor = Color.Red
-        };
-        var item = new ListViewItem();
-        listView.Items.Add(item);
-
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(Color.Red, subItem.BackColor);
-
-        // Remove from the list view.
-        listView.Items.Remove(item);
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-    }
-
-    [Fact]
-    public void ListViewSubItem_BackColor_GetWithListViewItem_ReturnsEqual()
-    {
-        var item = new ListViewItem
-        {
-            BackColor = Color.Red
-        };
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_BackColor_GetWithListViewItemWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            BackColor = Color.Red
-        };
-        var item = new ListViewItem
-        {
-            BackColor = Color.Blue
-        };
-        listView.Items.Add(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-        Assert.Equal(Color.Red, subItem.BackColor);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Empty, SystemColors.Window };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListViewSubItem_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, subItem.BackColor);
-
-        // Set same.
-        subItem.BackColor = value;
-        Assert.Equal(expected, subItem.BackColor);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithListView_TestData()
-    {
-        yield return new object[] { Color.Green, Color.Green };
-        yield return new object[] { Color.Empty, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithListView_TestData))]
-    public void ListViewSubItem_BackColor_SetWithListViewItemWithListView_GetReturnsExpected(Color value, Color expected)
-    {
-        using var listView = new ListView
-        {
-            BackColor = Color.Red
-        };
-        var item = new ListViewItem
-        {
-            BackColor = Color.Blue
-        };
-        listView.Items.Add(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.BackColor = value;
-        Assert.Equal(expected, subItem.BackColor);
-
-        // Set same.
-        subItem.BackColor = value;
-        Assert.Equal(expected, subItem.BackColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListViewSubItem_BackColor_SetWithListViewItem_GetReturnsExpected(Color value, Color expected)
-    {
-        var item = new ListViewItem
-        {
-            BackColor = Color.Blue
-        };
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.BackColor = value;
-        Assert.Equal(expected, subItem.BackColor);
-
-        // Set same.
-        subItem.BackColor = value;
-        Assert.Equal(expected, subItem.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_Bounds_GetWithListViewHandle_ReturnsEqual()
-    {
-        using var listView = new ListView();
-        var item = new ListViewItem();
-        listView.Items.Add(item);
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(subItem.Bounds, subItem.Bounds);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_Font_GetWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            Font = SystemFonts.MenuFont
-        };
-        var item = new ListViewItem();
-        listView.Items.Add(item);
-
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(SystemFonts.MenuFont, subItem.Font);
-
-        // Remove from the list view.
-        listView.Items.Remove(item);
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-    }
-
-    [Fact]
-    public void ListViewSubItem_Font_GetWithListViewItem_ReturnsEqual()
-    {
-        var item = new ListViewItem
-        {
-            Font = SystemFonts.DialogFont
-        };
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_Font_GetWithListViewItemWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            Font = SystemFonts.CaptionFont
-        };
-        var item = new ListViewItem
-        {
-            Font = SystemFonts.DialogFont
-        };
-        listView.Items.Add(item);
-
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-        Assert.Equal(SystemFonts.CaptionFont, subItem.Font);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewSubItem_Font_Set_GetReturnsExpected(Font value)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            Font = value
-        };
-        Assert.Same(value ?? Control.DefaultFont, subItem.Font);
-
-        // Set same.
-        subItem.Font = value;
-        Assert.Same(value ?? Control.DefaultFont, subItem.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewSubItem_Font_SetWithListViewItemWithListView_GetReturnsExpected(Font value)
-    {
-        using var listView = new ListView
-        {
-            Font = SystemFonts.CaptionFont
-        };
-        var item = new ListViewItem
-        {
-            Font = SystemFonts.DialogFont
-        };
-        listView.Items.Add(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.Font = value;
-        Assert.Equal(value ?? SystemFonts.CaptionFont, subItem.Font);
-
-        // Set same.
-        subItem.Font = value;
-        Assert.Equal(value ?? SystemFonts.CaptionFont, subItem.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ListViewSubItem_Font_SetWithListViewItem_GetReturnsExpected(Font value)
-    {
-        var item = new ListViewItem
-        {
-            Font = SystemFonts.DialogFont
-        };
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, subItem.Font);
-
-        // Set same.
-        subItem.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, subItem.Font);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_ForeColor_GetWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            ForeColor = Color.Red
-        };
-        var item = new ListViewItem();
-        listView.Items.Add(item);
-
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(Color.Red, subItem.ForeColor);
-
-        // Remove from the list view.
-        listView.Items.Remove(item);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-    }
-
-    [Fact]
-    public void ListViewSubItem_ForeColor_GetWithListViewItem_ReturnsEqual()
-    {
-        var item = new ListViewItem
-        {
-            ForeColor = Color.Red
-        };
-        var subItem = new ListViewItem.ListViewSubItem(item, "text");
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ListViewSubItem_ForeColor_GetWithListViewItemWithListView_ReturnsEqual()
-    {
-        using var listView = new ListView
-        {
-            ForeColor = Color.Red
-        };
-        var item = new ListViewItem
-        {
-            ForeColor = Color.Blue
-        };
-        listView.Items.Add(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-        Assert.Equal(Color.Red, subItem.ForeColor);
-
-        // Remove from the list view item.
-        item.SubItems.Remove(subItem);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListViewSubItem_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, subItem.ForeColor);
-
-        // Set same.
-        subItem.ForeColor = value;
-        Assert.Equal(expected, subItem.ForeColor);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithListView_TestData()
-    {
-        yield return new object[] { Color.Green, Color.Green };
-        yield return new object[] { Color.Empty, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithListView_TestData))]
-    public void ListViewSubItem_ForeColor_SetWithListViewItemWithListView_GetReturnsExpected(Color value, Color expected)
-    {
-        using var listView = new ListView
-        {
-            ForeColor = Color.Red
-        };
-        var item = new ListViewItem
-        {
-            ForeColor = Color.Blue
-        };
-        listView.Items.Add(item);
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.ForeColor = value;
-        Assert.Equal(expected, subItem.ForeColor);
-
-        // Set same.
-        subItem.ForeColor = value;
-        Assert.Equal(expected, subItem.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListViewSubItem_ForeColor_SetWithListViewItem_GetReturnsExpected(Color value, Color expected)
-    {
-        var item = new ListViewItem
-        {
-            ForeColor = Color.Blue
-        };
-        var subItem = new ListViewItem.ListViewSubItem();
-        item.SubItems.Add(subItem);
-
-        subItem.ForeColor = value;
-        Assert.Equal(expected, subItem.ForeColor);
-
-        // Set same.
-        subItem.ForeColor = value;
-        Assert.Equal(expected, subItem.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewSubItem_Name_SetWithOwner_GetReturnsExpected(string value, string expected)
-    {
-        var item = new ListViewItem();
-        var subItem = new ListViewItem.ListViewSubItem(item, "text")
-        {
-            Name = value
-        };
-        Assert.Equal(expected, subItem.Name);
-
-        // Set same.
-        subItem.Name = value;
-        Assert.Equal(expected, subItem.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewSubItem_Name_SetWithoutOwner_GetReturnsExpected(string value, string expected)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            Name = value
-        };
-        Assert.Equal(expected, subItem.Name);
-
-        // Set same.
-        subItem.Name = value;
-        Assert.Equal(expected, subItem.Name);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ListViewSubItem_Tag_Set_GetReturnsExpected(string value)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            Tag = value
-        };
-        Assert.Same(value, subItem.Tag);
-
-        // Set same.
-        subItem.Tag = value;
-        Assert.Same(value, subItem.Tag);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewSubItem_Text_SetWithOwner_GetReturnsExpected(string value, string expected)
-    {
-        var item = new ListViewItem();
-        var subItem = new ListViewItem.ListViewSubItem(item, "text")
-        {
-            Text = value
-        };
-        Assert.Equal(expected, subItem.Text);
-
-        // Set same.
-        subItem.Text = value;
-        Assert.Equal(expected, subItem.Text);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ListViewSubItem_Text_SetWithoutOwner_GetReturnsExpected(string value, string expected)
-    {
-        var subItem = new ListViewItem.ListViewSubItem
-        {
-            Text = value
-        };
-        Assert.Equal(expected, subItem.Text);
-
-        // Set same.
-        subItem.Text = value;
-        Assert.Equal(expected, subItem.Text);
-    }
-
-    public static IEnumerable<object[]> ResetStyle_Owner_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListViewItem() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResetStyle_Owner_TestData))]
-    public void ListViewSubItem_ResetStyle_NoStyle_Nop(ListViewItem owner)
-    {
-        var subItem = new ListViewItem.ListViewSubItem(owner, "text");
-        subItem.ResetStyle();
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-
-        subItem.ResetStyle();
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ResetStyle_Owner_TestData))]
-    public void ListViewSubItem_ResetStyle_HasStyleWithOwner_Success(ListViewItem owner)
-    {
-        var subItem = new ListViewItem.ListViewSubItem(owner, "text", Color.Red, Color.Blue, SystemFonts.MenuFont);
-
-        subItem.ResetStyle();
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-
-        subItem.ResetStyle();
-        Assert.Equal(SystemColors.Window, subItem.BackColor);
-        Assert.Equal(Control.DefaultFont, subItem.Font);
-        Assert.Equal(SystemColors.WindowText, subItem.ForeColor);
-    }
-
-    public static IEnumerable<object[]> Serialize_Deserialize_TestData()
-    {
-        yield return new object[] { new ListViewItem.ListViewSubItem() };
-        yield return new object[] { new ListViewItem.ListViewSubItem(null, "header", Color.Red, Color.Blue, SystemFonts.MenuFont) { Name = "name", Tag = "tag" } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Serialize_Deserialize_TestData))]
-    public void ListViewSubItem_Serialize_Deserialize_Success(ListViewItem.ListViewSubItem subItem)
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var stream = new MemoryStream();
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-        var formatter = new BinaryFormatter();
-        new BinaryFormatter().Serialize(stream, subItem);
-        stream.Seek(0, SeekOrigin.Begin);
-
-        ListViewItem.ListViewSubItem result = Assert.IsType<ListViewItem.ListViewSubItem>(formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-        Assert.Equal(subItem.BackColor, result.BackColor);
-        Assert.Equal(subItem.Font, result.Font);
-        Assert.Equal(subItem.ForeColor, result.ForeColor);
-        Assert.Empty(result.Name);
-        Assert.Null(result.Tag);
-        Assert.Equal(subItem.Text, result.Text);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ListViewSubItem_ToString_Invoke_ReturnsExpected(string text)
-    {
-        var subItem = new ListViewItem.ListViewSubItem(null, text);
-        Assert.Equal($"ListViewSubItem: {{{text}}}", subItem.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewTests.cs
deleted file mode 100644
index 972a28ecbb5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewTests.cs
+++ /dev/null
@@ -1,5910 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using Microsoft.DotNet.RemoteExecutor;
-using static System.Windows.Forms.ListViewItem;
-using static Interop;
-using static Interop.ComCtl32;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ListViewTests
-{
-    [WinFormsFact]
-    public void ListView_Ctor_Default()
-    {
-        using var control = new SubListView();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.Equal(ItemActivation.Standard, control.Activation);
-        Assert.Equal(ListViewAlignment.Top, control.Alignment);
-        Assert.False(control.AllowColumnReorder);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.True(control.AutoArrange);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.False(control.BackgroundImageTiled);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(97, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 121, 97), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.False(control.CheckBoxes);
-        Assert.Empty(control.CheckedIndices);
-        Assert.Same(control.CheckedIndices, control.CheckedIndices);
-        Assert.Empty(control.CheckedItems);
-        Assert.Same(control.CheckedItems, control.CheckedItems);
-        Assert.Equal(new Size(117, 93), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 117, 93), control.ClientRectangle);
-        Assert.Empty(control.Columns);
-        Assert.Same(control.Columns, control.Columns);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Equal(Cursors.Default, control.Cursor);
-        Assert.Same(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(121, 97), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 117, 93), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.False(control.Focused);
-        Assert.Null(control.FocusedItem);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(control.FullRowSelect);
-        Assert.False(control.GridLines);
-        Assert.Empty(control.Groups);
-        Assert.Same(control.Groups, control.Groups);
-        Assert.Null(control.GroupImageList);
-        Assert.False(control.HasChildren);
-        Assert.Equal(ColumnHeaderStyle.Clickable, control.HeaderStyle);
-        Assert.Equal(97, control.Height);
-        Assert.False(control.HideSelection);
-        Assert.False(control.HotTracking);
-        Assert.False(control.HoverSelection);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.NotNull(control.InsertionMark);
-        Assert.Same(control.InsertionMark, control.InsertionMark);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Empty(control.Items);
-        Assert.Same(control.Items, control.Items);
-        Assert.False(control.LabelEdit);
-        Assert.True(control.LabelWrap);
-        Assert.Null(control.LargeImageList);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Null(control.ListViewItemSorter);
-        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.True(control.MultiSelect);
-        Assert.False(control.OwnerDraw);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(new Size(121, 97), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(121, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.Scrollable);
-        Assert.Empty(control.SelectedIndices);
-        Assert.Same(control.SelectedIndices, control.SelectedIndices);
-        Assert.Empty(control.SelectedItems);
-        Assert.Same(control.SelectedItems, control.SelectedItems);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowGroups);
-        Assert.False(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.SmallImageList);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(121, 97), control.Size);
-        Assert.Equal(SortOrder.None, control.Sorting);
-        Assert.Null(control.StateImageList);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(Size.Empty, control.TileSize);
-        Assert.Equal(0, control.Top);
-        Assert.Throws<InvalidOperationException>(() => control.TopItem);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleStateImageBehavior);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(View.LargeIcon, control.View);
-        Assert.Equal(0, control.VirtualListSize);
-        Assert.False(control.VirtualMode);
-        Assert.True(control.Visible);
-        Assert.Equal(121, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListView_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubListView();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysListView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010148, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ItemActivation>]
-    public void ListView_Activation_Set_GetReturnsExpected(ItemActivation value)
-    {
-        using var listView = new ListView
-        {
-            Activation = value
-        };
-        Assert.Equal(value, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Activation = value;
-        Assert.Equal(value, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ItemActivation.Standard, 0)]
-    [InlineData(ItemActivation.OneClick, 1)]
-    [InlineData(ItemActivation.TwoClick, 1)]
-    public void ListView_Activation_SetWithHandle_GetReturnsExpected(ItemActivation value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.Activation = value;
-        Assert.Equal(value, listView.Activation);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.Activation = value;
-        Assert.Equal(value, listView.Activation);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_Activation_SetHotTrackingOneClick_Nop()
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true,
-            Activation = ItemActivation.OneClick
-        };
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Activation = ItemActivation.OneClick;
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ItemActivation>]
-    public void ListView_Activation_SetInvalidValue_ThrowsInvalidEnumArgumentException(ItemActivation value)
-    {
-        using var listView = new ListView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => listView.Activation = value);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ItemActivation>]
-    public void ListView_Activation_SetHotTrackingInvalidValue_ThrowsInvalidEnumArgumentException(ItemActivation value)
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true
-        };
-        Assert.Throws<InvalidEnumArgumentException>("value", () => listView.Activation = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ItemActivation.Standard)]
-    [InlineData(ItemActivation.TwoClick)]
-    public void ListView_Activation_SetHotTrackingNotOneClick_ThrowsArgumentException(ItemActivation value)
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true
-        };
-        Assert.Throws<ArgumentException>("value", () => listView.Activation = value);
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ListViewAlignment>]
-    public void ListView_Alignment_Set_GetReturnsExpected(ListViewAlignment value)
-    {
-        using var listView = new ListView
-        {
-            Alignment = value
-        };
-        Assert.Equal(value, listView.Alignment);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Alignment = value;
-        Assert.Equal(value, listView.Alignment);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ListViewAlignment.Default, 2, 1)]
-    [InlineData(ListViewAlignment.Top, 0, 0)]
-    [InlineData(ListViewAlignment.Left, 2, 1)]
-    [InlineData(ListViewAlignment.SnapToGrid, 2, 1)]
-    public void ListView_Alignment_SetWithHandle_GetReturnsExpected(ListViewAlignment value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.Alignment = value;
-        Assert.Equal(value, listView.Alignment);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.Alignment = value;
-        Assert.Equal(value, listView.Alignment);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ListViewAlignment>]
-    public void ListView_Alignment_SetInvalidValue_ThrowsInvalidEnumArgumentException(ListViewAlignment value)
-    {
-        using var listView = new ListView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => listView.Alignment = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_AllowColumnReorder_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            AllowColumnReorder = value
-        };
-        Assert.Equal(value, listView.AllowColumnReorder);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.AllowColumnReorder = value;
-        Assert.Equal(value, listView.AllowColumnReorder);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.AllowColumnReorder = !value;
-        Assert.Equal(!value, listView.AllowColumnReorder);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_AllowColumnReorder_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.AllowColumnReorder = value;
-        Assert.Equal(value, listView.AllowColumnReorder);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.AllowColumnReorder = value;
-        Assert.Equal(value, listView.AllowColumnReorder);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.AllowColumnReorder = !value;
-        Assert.Equal(!value, listView.AllowColumnReorder);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_AutoArrange_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = value
-        };
-        Assert.Equal(value, listView.AutoArrange);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.AutoArrange = value;
-        Assert.Equal(value, listView.AutoArrange);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.AutoArrange = !value;
-        Assert.Equal(!value, listView.AutoArrange);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ListView_AutoArrange_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.AutoArrange = value;
-        Assert.Equal(value, listView.AutoArrange);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.AutoArrange = value;
-        Assert.Equal(value, listView.AutoArrange);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.AutoArrange = !value;
-        Assert.Equal(!value, listView.AutoArrange);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ListView_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ListView
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void ListView_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_BackColor_GetBkColor_Success()
-    {
-        using var control = new ListView();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.BackColor = Color.FromArgb(0xFF, 0x12, 0x34, 0x56);
-        Assert.Equal(0x563412, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETBKCOLOR));
-    }
-
-    [WinFormsFact]
-    public void ListView_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new ListView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ListView_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubListView
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListView_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new ListView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ListView_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new ListView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_BackgroundImageTiled_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            BackgroundImageTiled = value
-        };
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.BackgroundImageTiled = !value;
-        Assert.Equal(!value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_BackgroundImageTiled_SetWithBackgroundImage_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            BackgroundImage = new Bitmap(10, 10),
-            BackgroundImageTiled = value
-        };
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.BackgroundImageTiled = !value;
-        Assert.Equal(!value, listView.BackgroundImageTiled);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_BackgroundImageTiled_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.BackgroundImageTiled = !value;
-        Assert.Equal(!value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_BackgroundImageTiled_SetWithBackgroundImageWithHandle_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            BackgroundImage = new Bitmap(10, 10)
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.BackgroundImageTiled = value;
-        Assert.Equal(value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.BackgroundImageTiled = !value;
-        Assert.Equal(!value, listView.BackgroundImageTiled);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void ListView_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var listView = new ListView
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, listView.BorderStyle);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.BorderStyle = value;
-        Assert.Equal(value, listView.BorderStyle);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 0)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 1)]
-    public void ListView_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.BorderStyle = value;
-        Assert.Equal(value, listView.BorderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.BorderStyle = value;
-        Assert.Equal(value, listView.BorderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void ListView_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var listView = new ListView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => listView.BorderStyle = value);
-    }
-
-    public static IEnumerable<object[]> CheckBoxes_Set_TestData()
-    {
-        foreach (bool useCompatibleStateImageBehavior in new bool[] { true, false })
-        {
-            foreach (ListViewAlignment alignment in Enum.GetValues(typeof(ListViewAlignment)))
-            {
-                foreach (Func<ImageList> imageListFactory in new Func<ImageList>[] { () => new ImageList(), () => null })
-                {
-                    foreach (bool value in new bool[] { true, false })
-                    {
-                        yield return new object[] { useCompatibleStateImageBehavior, View.Details, alignment, imageListFactory(), value };
-                        yield return new object[] { useCompatibleStateImageBehavior, View.LargeIcon, alignment, imageListFactory(), value };
-                        yield return new object[] { useCompatibleStateImageBehavior, View.List, alignment, imageListFactory(), value };
-                        yield return new object[] { useCompatibleStateImageBehavior, View.SmallIcon, alignment, imageListFactory(), value };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxes_Set_TestData))]
-    public void ListView_CheckBoxes_Set_GetReturnsExpected(bool useCompatibleStateImageBehavior, View view, ListViewAlignment alignment, ImageList stateImageList, bool value)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            View = view,
-            Alignment = alignment,
-            StateImageList = stateImageList,
-            CheckBoxes = value
-        };
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxes_Set_TestData))]
-    public void ListView_CheckBoxes_SetAutoArrange_GetReturnsExpected(bool useCompatibleStateImageBehavior, View view, ListViewAlignment alignment, ImageList stateImageList, bool value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = true,
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            View = view,
-            Alignment = alignment,
-            StateImageList = stateImageList,
-            CheckBoxes = value
-        };
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_CheckBoxes_SetWithCheckedItems_Success(bool value)
-    {
-        var item1 = new ListViewItem
-        {
-            Checked = true
-        };
-        var item2 = new ListViewItem();
-        using var listView = new ListView();
-        listView.Items.Add(item1);
-        listView.Items.Add(item2);
-        Assert.Equal(new ListViewItem[] { item1, item2 }, listView.Items.Cast<ListViewItem>());
-
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CheckBoxes_SetWithHandle_TestData()
-    {
-        foreach (ListViewAlignment alignment in Enum.GetValues(typeof(ListViewAlignment)))
-        {
-            foreach (Func<ImageList> imageListFactory in new Func<ImageList>[] { () => new ImageList(), () => null })
-            {
-                yield return new object[] { true, View.Details, alignment, imageListFactory(), true, 1, 0, 2, 0 };
-                yield return new object[] { true, View.LargeIcon, alignment, imageListFactory(), true, 1, 0, 2, 0 };
-                yield return new object[] { true, View.List, alignment, imageListFactory(), true, 1, 0, 2, 0 };
-                yield return new object[] { true, View.SmallIcon, alignment, imageListFactory(), true, 1, 0, 2, 0 };
-                yield return new object[] { true, View.Details, alignment, imageListFactory(), false, 0, 0, 1, 0 };
-                yield return new object[] { true, View.LargeIcon, alignment, imageListFactory(), false, 0, 0, 1, 0 };
-                yield return new object[] { true, View.List, alignment, imageListFactory(), false, 0, 0, 1, 0 };
-                yield return new object[] { true, View.SmallIcon, alignment, imageListFactory(), false, 0, 0, 1, 0 };
-            }
-
-            if (alignment != ListViewAlignment.Left)
-            {
-                yield return new object[] { false, View.Details, alignment, null, true, 1, 0, 2, 0 };
-                yield return new object[] { false, View.LargeIcon, alignment, null, true, 2, 1, 3, 1 };
-                yield return new object[] { false, View.List, alignment, null, true, 1, 1, 2, 1 };
-                yield return new object[] { false, View.SmallIcon, alignment, null, true, 2, 1, 3, 1 };
-                yield return new object[] { false, View.Details, alignment, null, false, 0, 0, 1, 0 };
-                yield return new object[] { false, View.LargeIcon, alignment, null, false, 0, 0, 2, 1 };
-                yield return new object[] { false, View.List, alignment, null, false, 0, 0, 1, 1 };
-                yield return new object[] { false, View.SmallIcon, alignment, null, false, 0, 0, 2, 1 };
-
-                yield return new object[] { false, View.Details, alignment, new ImageList(), true, 1, 0, 2, 1 };
-                yield return new object[] { false, View.LargeIcon, alignment, new ImageList(), true, 2, 1, 4, 2 };
-                yield return new object[] { false, View.List, alignment, new ImageList(), true, 1, 1, 2, 2 };
-                yield return new object[] { false, View.SmallIcon, alignment, new ImageList(), true, 2, 1, 4, 2 };
-                yield return new object[] { false, View.Details, alignment, new ImageList(), false, 0, 0, 1, 0 };
-                yield return new object[] { false, View.LargeIcon, alignment, new ImageList(), false, 0, 0, 2, 1 };
-                yield return new object[] { false, View.List, alignment, new ImageList(), false, 0, 0, 1, 1 };
-                yield return new object[] { false, View.SmallIcon, alignment, new ImageList(), false, 0, 0, 2, 1 };
-            }
-        }
-
-        foreach (Func<ImageList> imageListFactory in new Func<ImageList>[] { () => new ImageList(), () => null })
-        {
-            yield return new object[] { false, View.Details, ListViewAlignment.Left, imageListFactory(), true, 1, 0, 2, 1 };
-            yield return new object[] { false, View.LargeIcon, ListViewAlignment.Left, imageListFactory(), true, 2, 1, 4, 2 };
-            yield return new object[] { false, View.List, ListViewAlignment.Left, imageListFactory(), true, 1, 1, 2, 2 };
-            yield return new object[] { false, View.SmallIcon, ListViewAlignment.Left, imageListFactory(), true, 2, 1, 4, 2 };
-            yield return new object[] { false, View.Details, ListViewAlignment.Left, imageListFactory(), false, 0, 0, 1, 0 };
-            yield return new object[] { false, View.LargeIcon, ListViewAlignment.Left, imageListFactory(), false, 0, 0, 2, 1 };
-            yield return new object[] { false, View.List, ListViewAlignment.Left, imageListFactory(), false, 0, 0, 1, 1 };
-            yield return new object[] { false, View.SmallIcon, ListViewAlignment.Left, imageListFactory(), false, 0, 0, 2, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxes_SetWithHandle_TestData))]
-    public void ListView_CheckBoxes_SetWithHandle_GetReturnsExpected(bool useCompatibleStateImageBehavior, View view, ListViewAlignment alignment, ImageList stateImageList, bool value, int expectedInvalidatedCallCount1, int expectedCreatedCallCount1, int expectedInvalidatedCallCount2, int expectedCreatedCallCount2)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            View = view,
-            Alignment = alignment,
-            StateImageList = stateImageList
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CheckBoxes_SetWithHandle_TestData))]
-    public void ListView_CheckBoxes_SetAutoArrangeWithHandle_GetReturnsExpected(bool useCompatibleStateImageBehavior, View view, ListViewAlignment alignment, ImageList stateImageList, bool value, int expectedInvalidatedCallCount1, int expectedCreatedCallCount1, int expectedInvalidatedCallCount2, int expectedCreatedCallCount2)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = true,
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            View = view,
-            Alignment = alignment,
-            StateImageList = stateImageList
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_CheckBoxes_SetWithCheckedItemsWithHandle_Success(bool value)
-    {
-        var item1 = new ListViewItem
-        {
-            Checked = true
-        };
-        var item2 = new ListViewItem();
-        using var listView = new ListView();
-        listView.Items.Add(item1);
-        listView.Items.Add(item2);
-        Assert.Equal(new ListViewItem[] { item1, item2 }, listView.Items.Cast<ListViewItem>());
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.True(listView.IsHandleCreated);
-
-        // Set same.
-        listView.CheckBoxes = value;
-        Assert.Equal(value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.True(listView.IsHandleCreated);
-
-        // Set different.
-        listView.CheckBoxes = !value;
-        Assert.Equal(!value, listView.CheckBoxes);
-        Assert.True(item1.Checked);
-        Assert.False(item2.Checked);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_CheckBoxes_SetTile_ThrowsNotSupportedException(bool useCompatibleStateImageBehavior)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            View = View.Tile
-        };
-        Assert.Throws<NotSupportedException>(() => listView.CheckBoxes = true);
-        Assert.False(listView.CheckBoxes);
-
-        listView.CheckBoxes = false;
-        Assert.False(listView.CheckBoxes);
-    }
-
-    [WinFormsFact]
-    public void ListView_DisposeWithReferencedImageListDoesNotLeak()
-    {
-        // must be separate function because GC of local variables is not precise
-        static WeakReference CreateAndDisposeListViewWithImageListReference(ImageList imageList)
-        {
-            // short lived test code, whatever you need to trigger the leak
-            using var listView = new ListView();
-            listView.LargeImageList = imageList;
-
-            // return a weak reference to whatever you want to track GC of
-            // creating a long weak reference to make sure finalizer does not resurrect the ListView
-            return new WeakReference(listView, true);
-        }
-
-        // simulate a long-living ImageList by keeping it alive for the test
-        using var imageList = new ImageList();
-
-        // simulate a short-living ListView by disposing it (returning a WeakReference to track finalization)
-        var listViewRef = CreateAndDisposeListViewWithImageListReference(imageList);
-
-        GC.Collect(); // mark for finalization (also would clear normal weak references)
-        GC.WaitForPendingFinalizers(); // wait until finalizer is executed
-        GC.Collect(); // wait for long weak reference to be cleared
-
-        // at this point the WeakReference is cleared if -and only if- the finalizer was called and did not resurrect the object
-        // (if the test ever fails you can set a breakpoint here, debug the test, and make heap snapshot in VS;
-        // then search for the ListView in the heap snapshot UI and look who is referencing it, usually you
-        // can derive from types referencing the ListView who is to blame)
-        Assert.False(listViewRef.IsAlive);
-    }
-
-#if DEBUG
-    [WinFormsFact]
-    public void ListView_Dispose_shared_ImageList_doesnt_assert()
-    {
-        using ListView listView = new();
-        ImageList imageList = new();
-        listView.LargeImageList = imageList;
-        listView.SmallImageList = imageList;
-
-        // Initiate DetachImageList sequence
-        imageList.Dispose();
-
-        // Unless we track whether an imagelist was disposed, we would hit Debug.Fail assertion
-        // and never reach this line
-        Assert.True(true);
-    }
-#endif
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubListView();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubListView
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> FocusedItem_Set_TestData()
-    {
-        yield return new object[] { new ListViewItem(), false };
-        yield return new object[] { null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FocusedItem_Set_TestData))]
-    public void ListView_FocusedItem_Set_GetReturnsExpected(ListViewItem value, bool? expectedFocused)
-    {
-        using var control = new SubListView
-        {
-            FocusedItem = value
-        };
-        Assert.Null(control.FocusedItem);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedFocused, value?.Focused);
-
-        // Set same.
-        control.FocusedItem = value;
-        Assert.Null(control.FocusedItem);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedFocused, value?.Focused);
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_SetChild_GetReturnsExpected()
-    {
-        var value = new ListViewItem();
-        using var control = new SubListView();
-        control.Items.Add(value);
-
-        control.FocusedItem = value;
-        Assert.Null(control.FocusedItem);
-        Assert.False(control.Focused);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.FocusedItem = value;
-        Assert.Null(control.FocusedItem);
-        Assert.False(control.Focused);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.FocusedItem = null;
-        Assert.Null(control.FocusedItem);
-        Assert.False(control.Focused);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(FocusedItem_Set_TestData))]
-    public void ListView_FocusedItem_SetWithHandle_GetReturnsExpected(ListViewItem value, bool? expectedFocused)
-    {
-        using var control = new SubListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.FocusedItem = value;
-        Assert.Null(control.FocusedItem);
-        Assert.Equal(expectedFocused, value?.Focused);
-
-        // Set same.
-        control.FocusedItem = value;
-        Assert.Null(control.FocusedItem);
-        Assert.Equal(expectedFocused, value?.Focused);
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_SetChildWithHandle_GetReturnsExpected()
-    {
-        var value = new ListViewItem();
-        using var control = new SubListView();
-        control.Items.Add(value);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.FocusedItem = value;
-        Assert.Same(value, control.FocusedItem);
-        Assert.True(value.Focused);
-
-        // Set same.
-        control.FocusedItem = value;
-        Assert.Same(value, control.FocusedItem);
-        Assert.True(value.Focused);
-
-        // Set null.
-        control.FocusedItem = null;
-        Assert.Same(value, control.FocusedItem);
-        Assert.True(value.Focused);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ListView_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ListView
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void ListView_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_ForeColor_GetTxtColor_Success()
-    {
-        using var control = new ListView();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETTEXTCOLOR));
-    }
-
-    [WinFormsFact]
-    public void ListView_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ListView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_FullRowSelect_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            FullRowSelect = value
-        };
-        Assert.Equal(value, listView.FullRowSelect);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.FullRowSelect = value;
-        Assert.Equal(value, listView.FullRowSelect);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.FullRowSelect = !value;
-        Assert.Equal(!value, listView.FullRowSelect);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_FullRowSelect_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.FullRowSelect = value;
-        Assert.Equal(value, listView.FullRowSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.FullRowSelect = value;
-        Assert.Equal(value, listView.FullRowSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.FullRowSelect = !value;
-        Assert.Equal(!value, listView.FullRowSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_GridLines_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            GridLines = value
-        };
-        Assert.Equal(value, listView.GridLines);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.GridLines = value;
-        Assert.Equal(value, listView.GridLines);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.GridLines = !value;
-        Assert.Equal(!value, listView.GridLines);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_GridLines_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.GridLines = value;
-        Assert.Equal(value, listView.GridLines);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.GridLines = value;
-        Assert.Equal(value, listView.GridLines);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.GridLines = !value;
-        Assert.Equal(!value, listView.GridLines);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GroupImageList_Set_GetReturnsExpected()
-    {
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            foreach (bool virtualMode in new bool[] { true, false })
-            {
-                foreach (View view in new View[] { View.Details, View.LargeIcon, View.List, View.SmallIcon })
-                {
-                    yield return new object[] { autoArrange, virtualMode, view, null };
-                    yield return new object[] { autoArrange, virtualMode, view, new ImageList() };
-                    yield return new object[] { autoArrange, virtualMode, view, CreateImageListNonEmpty() };
-                }
-            }
-
-            yield return new object[] { autoArrange, false, View.Tile, null };
-            yield return new object[] { autoArrange, false, View.Tile, new ImageList() };
-            yield return new object[] { autoArrange, false, View.Tile, CreateImageListNonEmpty() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GroupImageList_Set_GetReturnsExpected))]
-    public void ListView_GroupImageList_Set_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            GroupImageList = value
-        };
-
-        Assert.Same(value, listView.GroupImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GroupImageList_Set_GetReturnsExpected))]
-    public void ListView_GroupImageList_SetWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            GroupImageList = imageList
-        };
-
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GroupImageList_SetWithHandle_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null };
-        yield return new object[] { true, false, View.Details, new ImageList() };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.LargeIcon, null };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList() };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.List, null };
-        yield return new object[] { true, false, View.List, new ImageList() };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.SmallIcon, null };
-        yield return new object[] { true, false, View.SmallIcon, new ImageList() };
-        yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.Tile, null };
-        yield return new object[] { true, false, View.Tile, new ImageList() };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty() };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList() };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList() };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.List, null };
-            yield return new object[] { autoArrange, true, View.List, new ImageList() };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.SmallIcon, null };
-            yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList() };
-            yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty() };
-        }
-
-        yield return new object[] { false, false, View.Details, null };
-        yield return new object[] { false, false, View.Details, new ImageList() };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.LargeIcon, null };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList() };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.List, null };
-        yield return new object[] { false, false, View.List, new ImageList() };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.SmallIcon, null };
-        yield return new object[] { false, false, View.SmallIcon, new ImageList() };
-        yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.Tile, null };
-        yield return new object[] { false, false, View.Tile, new ImageList() };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GroupImageList_SetWithHandle_GetReturnsExpected))]
-    public void ListView_GroupImageList_SetWithHandle_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view
-        };
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GroupImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null };
-        yield return new object[] { true, false, View.Details, new ImageList() };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.LargeIcon, null };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList() };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.List, null };
-        yield return new object[] { true, false, View.List, new ImageList() };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.SmallIcon, null };
-        yield return new object[] { true, false, View.SmallIcon, new ImageList() };
-        yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty() };
-        yield return new object[] { true, false, View.Tile, null };
-        yield return new object[] { true, false, View.Tile, new ImageList() };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty() };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList() };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList() };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.List, null };
-            yield return new object[] { autoArrange, true, View.List, new ImageList() };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty() };
-            yield return new object[] { autoArrange, true, View.SmallIcon, null };
-            yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList() };
-            yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty() };
-        }
-
-        yield return new object[] { false, false, View.Details, null };
-        yield return new object[] { false, false, View.Details, new ImageList() };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.LargeIcon, null };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList() };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.List, null };
-        yield return new object[] { false, false, View.List, new ImageList() };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.SmallIcon, null };
-        yield return new object[] { false, false, View.SmallIcon, new ImageList() };
-        yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty() };
-        yield return new object[] { false, false, View.Tile, null };
-        yield return new object[] { false, false, View.Tile, new ImageList() };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GroupImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected))]
-    public void ListView_GroupImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-        };
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.GroupImageList = value;
-        Assert.Same(value, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_GroupImageList_Dispose_DetachesFromListView(bool autoArrange)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            GroupImageList = imageList1
-        };
-
-        Assert.Same(imageList1, listView.GroupImageList);
-
-        imageList1.Dispose();
-        Assert.Null(listView.GroupImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        listView.GroupImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.GroupImageList);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_GroupImageList_DisposeWithHandle_DetachesFromListView(bool autoArrange, int expectedInvalidatedCallCount)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange
-        };
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.GroupImageList = imageList1;
-        Assert.Same(imageList1, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        listView.GroupImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.GroupImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_Handle_GetWithBackColor_Success()
-    {
-        using var control = new ListView
-        {
-            BackColor = Color.FromArgb(0xFF, 0x12, 0x34, 0x56)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x563412, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETBKCOLOR));
-    }
-
-    [WinFormsFact]
-    public void ListView_Handle_GetWithForeColor_Success()
-    {
-        using var control = new ListView
-        {
-            ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.LVM_GETTEXTCOLOR));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_Handle_GetWithoutGroups_Success(bool showGroups)
-    {
-        using var listView = new ListView
-        {
-            ShowGroups = showGroups
-        };
-        Assert.Equal(0, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-    }
-
-    public static IEnumerable<object[]> Handle_GetWithGroups_TestData()
-    {
-        foreach (bool showGroups in new bool[] { true, false })
-        {
-            yield return new object[] { showGroups, null, HorizontalAlignment.Left, null, HorizontalAlignment.Right, string.Empty, string.Empty, 0x00000021 };
-            yield return new object[] { showGroups, null, HorizontalAlignment.Center, null, HorizontalAlignment.Center, string.Empty, string.Empty, 0x00000012 };
-            yield return new object[] { showGroups, null, HorizontalAlignment.Right, null, HorizontalAlignment.Left, string.Empty, string.Empty, 0x0000000C };
-
-            yield return new object[] { showGroups, string.Empty, HorizontalAlignment.Left, string.Empty, HorizontalAlignment.Right, string.Empty, string.Empty, 0x00000021 };
-            yield return new object[] { showGroups, string.Empty, HorizontalAlignment.Center, string.Empty, HorizontalAlignment.Center, string.Empty, string.Empty, 0x00000012 };
-            yield return new object[] { showGroups, string.Empty, HorizontalAlignment.Right, string.Empty, HorizontalAlignment.Left, string.Empty, string.Empty, 0x0000000C };
-
-            yield return new object[] { showGroups, "header", HorizontalAlignment.Left, "footer", HorizontalAlignment.Right, "header", "footer", 0x00000021 };
-            yield return new object[] { showGroups, "header", HorizontalAlignment.Center, "footer", HorizontalAlignment.Center, "header", "footer", 0x00000012 };
-            yield return new object[] { showGroups, "header", HorizontalAlignment.Right, "footer", HorizontalAlignment.Left, "header", "footer", 0x0000000C };
-
-            yield return new object[] { showGroups, "he\0der", HorizontalAlignment.Left, "fo\0oter", HorizontalAlignment.Right, "he", "fo", 0x00000021 };
-            yield return new object[] { showGroups, "he\0der", HorizontalAlignment.Center, "fo\0oter", HorizontalAlignment.Center, "he", "fo", 0x00000012 };
-            yield return new object[] { showGroups, "he\0der", HorizontalAlignment.Right, "fo\0oter", HorizontalAlignment.Left, "he", "fo", 0x0000000C };
-        }
-    }
-
-    [WinFormsFact(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    public unsafe void ListView_Handle_GetWithGroups_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            char* headerBuffer = stackalloc char[256];
-            char* footerBuffer = stackalloc char[256];
-
-            foreach (object[] data in Handle_GetWithGroups_TestData())
-            {
-                bool showGroups = (bool)data[0];
-                string header = (string)data[1];
-                HorizontalAlignment headerAlignment = (HorizontalAlignment)data[2];
-                string footer = (string)data[3];
-                HorizontalAlignment footerAlignment = (HorizontalAlignment)data[4];
-                string expectedHeaderText = (string)data[5];
-                string expectedFooterText = (string)data[6];
-                int expectedAlign = (int)data[7];
-
-                Application.EnableVisualStyles();
-
-                using var listView = new ListView
-                {
-                    ShowGroups = showGroups
-                };
-                var group1 = new ListViewGroup();
-                var group2 = new ListViewGroup
-                {
-                    Header = header,
-                    HeaderAlignment = headerAlignment,
-                    Footer = footer,
-                    FooterAlignment = footerAlignment
-                };
-                listView.Groups.Add(group1);
-                listView.Groups.Add(group2);
-
-                Assert.Equal(2, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPCOUNT));
-
-                var lvgroup1 = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.HEADER | LVGF.FOOTER | LVGF.GROUPID | LVGF.ALIGN,
-                    pszHeader = headerBuffer,
-                    cchHeader = 256,
-                    pszFooter = footerBuffer,
-                    cchFooter = 256,
-                };
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 0, ref lvgroup1));
-                Assert.Equal("ListViewGroup", new string(lvgroup1.pszHeader));
-                Assert.Empty(new string(lvgroup1.pszFooter));
-                Assert.True(lvgroup1.iGroupId >= 0);
-                Assert.Equal(0x00000009, (int)lvgroup1.uAlign);
-
-                var lvgroup2 = new LVGROUPW
-                {
-                    cbSize = (uint)sizeof(LVGROUPW),
-                    mask = LVGF.HEADER | LVGF.FOOTER | LVGF.GROUPID | LVGF.ALIGN,
-                    pszHeader = headerBuffer,
-                    cchHeader = 256,
-                    pszFooter = footerBuffer,
-                    cchFooter = 256,
-                };
-                Assert.Equal(1, (int)PInvoke.SendMessage(listView, PInvoke.LVM_GETGROUPINFOBYINDEX, 1, ref lvgroup2));
-                Assert.Equal(expectedHeaderText, new string(lvgroup2.pszHeader));
-                Assert.Equal(expectedFooterText, new string(lvgroup2.pszFooter));
-                Assert.True(lvgroup2.iGroupId > 0);
-                Assert.Equal(expectedAlign, (int)lvgroup2.uAlign);
-                Assert.True(lvgroup2.iGroupId > lvgroup1.iGroupId);
-            }
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsFact]
-    public void ListView_Handle_GetTextBackColor_Success()
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        nint expected = unchecked((nint)0xFFFFFFFF);
-        Assert.Equal(expected, (nint)PInvoke.SendMessage(control, PInvoke.LVM_GETTEXTBKCOLOR));
-    }
-
-    [WinFormsFact]
-    public void ListView_Handle_GetVersion_ReturnsExpected()
-    {
-        using var control = new ListView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int version = Application.UseVisualStyles ? 6 : 5;
-        Assert.Equal(version, (int)PInvoke.SendMessage(control, PInvoke.CCM_GETVERSION));
-    }
-
-    public static IEnumerable<object[]> Handle_CustomGetVersion_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, 1 };
-        yield return new object[] { (IntPtr)4, 1 };
-        yield return new object[] { (IntPtr)5, 0 };
-        yield return new object[] { (IntPtr)6, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Handle_CustomGetVersion_TestData))]
-    public void ListView_Handle_CustomGetVersion_Success(IntPtr getVersionResult, int expectedSetVersionCallCount)
-    {
-        using var control = new CustomGetVersionListView
-        {
-            GetVersionResult = getVersionResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expectedSetVersionCallCount, control.SetVersionCallCount);
-    }
-
-    private class CustomGetVersionListView : ListView
-    {
-        public IntPtr GetVersionResult { get; set; }
-        public int SetVersionCallCount { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.CCM_GETVERSION)
-            {
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = GetVersionResult;
-                return;
-            }
-            else if (m.Msg == (int)PInvoke.CCM_SETVERSION)
-            {
-                Assert.Equal((IntPtr)5, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                SetVersionCallCount++;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ColumnHeaderStyle>]
-    public void ListView_HeaderStyle_Set_GetReturnsExpected(ColumnHeaderStyle value)
-    {
-        using var listView = new ListView
-        {
-            HeaderStyle = value
-        };
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HeaderStyle = value;
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ColumnHeaderStyle.Clickable, 0, 0, 0)]
-    [InlineData(ColumnHeaderStyle.Nonclickable, 2, 0, 1)]
-    [InlineData(ColumnHeaderStyle.None, 1, 1, 0)]
-    public void ListView_HeaderStyle_SetClickableWithHandle_GetReturnsExpected(ColumnHeaderStyle value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.HeaderStyle = value;
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.HeaderStyle = value;
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ColumnHeaderStyle.Clickable, 2, 0, 1)]
-    [InlineData(ColumnHeaderStyle.Nonclickable, 0, 0, 0)]
-    [InlineData(ColumnHeaderStyle.None, 1, 1, 0)]
-    public void ListView_HeaderStyle_SetNonClickableWithHandle_GetReturnsExpected(ColumnHeaderStyle value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView
-        {
-            HeaderStyle = ColumnHeaderStyle.Nonclickable
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.HeaderStyle = value;
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.HeaderStyle = value;
-        Assert.Equal(value, listView.HeaderStyle);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ColumnHeaderStyle>]
-    public void ListView_HeaderStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(ColumnHeaderStyle value)
-    {
-        using var listView = new ListView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => listView.HeaderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_HideSelection_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            HideSelection = value
-        };
-        Assert.Equal(value, listView.HideSelection);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HideSelection = value;
-        Assert.Equal(value, listView.HideSelection);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.HideSelection = !value;
-        Assert.Equal(!value, listView.HideSelection);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_HideSelection_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.HideSelection = value;
-        Assert.Equal(value, listView.HideSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.HideSelection = value;
-        Assert.Equal(value, listView.HideSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.HideSelection = !value;
-        Assert.Equal(!value, listView.HideSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_HotTracking_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            HotTracking = value
-        };
-        Assert.Equal(value, listView.HotTracking);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HotTracking = value;
-        Assert.Equal(value, listView.HotTracking);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.HotTracking = !value;
-        Assert.Equal(!value, listView.HotTracking);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 3, 4)]
-    [InlineData(false, 0, 3)]
-    public void ListView_HotTracking_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.HotTracking = value;
-        Assert.Equal(value, listView.HotTracking);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.HotTracking = value;
-        Assert.Equal(value, listView.HotTracking);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.HotTracking = !value;
-        Assert.Equal(!value, listView.HotTracking);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_HotTracking_Set_SetsHoverSelectionAndActivationIfTrue()
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true
-        };
-        Assert.True(listView.HotTracking);
-        Assert.True(listView.HoverSelection);
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HotTracking = true;
-        Assert.True(listView.HotTracking);
-        Assert.True(listView.HoverSelection);
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.HotTracking = false;
-        Assert.False(listView.HotTracking);
-        Assert.True(listView.HoverSelection);
-        Assert.Equal(ItemActivation.OneClick, listView.Activation);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_HoverSelection_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            HoverSelection = value
-        };
-        Assert.Equal(value, listView.HoverSelection);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HoverSelection = value;
-        Assert.Equal(value, listView.HoverSelection);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.HoverSelection = !value;
-        Assert.Equal(!value, listView.HoverSelection);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_HoverSelection_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.HoverSelection = value;
-        Assert.Equal(value, listView.HoverSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.HoverSelection = value;
-        Assert.Equal(value, listView.HoverSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.HoverSelection = !value;
-        Assert.Equal(!value, listView.HoverSelection);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_HoverSelection_SetHotTrackingTrue_Nop()
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true,
-            HoverSelection = true
-        };
-        Assert.True(listView.HoverSelection);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.HoverSelection = true;
-        Assert.True(listView.HoverSelection);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListView_HoverSelection_SetHotTrackingFalse_ThrowsArgumentException()
-    {
-        using var listView = new ListView
-        {
-            HotTracking = true
-        };
-        Assert.Throws<ArgumentException>("value", () => listView.HoverSelection = false);
-        Assert.True(listView.HoverSelection);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_LabelEdit_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            LabelEdit = value
-        };
-        Assert.Equal(value, listView.LabelEdit);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.LabelEdit = value;
-        Assert.Equal(value, listView.LabelEdit);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.LabelEdit = !value;
-        Assert.Equal(!value, listView.LabelEdit);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_LabelEdit_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.LabelEdit = value;
-        Assert.Equal(value, listView.LabelEdit);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.LabelEdit = value;
-        Assert.Equal(value, listView.LabelEdit);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.LabelEdit = !value;
-        Assert.Equal(!value, listView.LabelEdit);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_LabelWrap_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            LabelWrap = value
-        };
-        Assert.Equal(value, listView.LabelWrap);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.LabelWrap = value;
-        Assert.Equal(value, listView.LabelWrap);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.LabelWrap = !value;
-        Assert.Equal(!value, listView.LabelWrap);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ListView_LabelWrap_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.LabelWrap = value;
-        Assert.Equal(value, listView.LabelWrap);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.LabelWrap = value;
-        Assert.Equal(value, listView.LabelWrap);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.LabelWrap = !value;
-        Assert.Equal(!value, listView.LabelWrap);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> LargeImageList_Set_GetReturnsExpected()
-    {
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            foreach (bool virtualMode in new bool[] { true, false })
-            {
-                foreach (View view in new View[] { View.Details, View.LargeIcon, View.List, View.SmallIcon })
-                {
-                    yield return new object[] { autoArrange, virtualMode, view, null };
-                    yield return new object[] { autoArrange, virtualMode, view, new ImageList() };
-                    yield return new object[] { autoArrange, virtualMode, view, CreateImageListNonEmpty() };
-                }
-            }
-
-            yield return new object[] { autoArrange, false, View.Tile, null };
-            yield return new object[] { autoArrange, false, View.Tile, new ImageList() };
-            yield return new object[] { autoArrange, false, View.Tile, CreateImageListNonEmpty() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeImageList_Set_GetReturnsExpected))]
-    public void ListView_LargeImageList_Set_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            LargeImageList = value
-        };
-        Assert.Same(value, listView.LargeImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeImageList_Set_GetReturnsExpected))]
-    public void ListView_LargeImageList_SetWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            LargeImageList = imageList
-        };
-
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> LargeImageList_SetWithHandle_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null, 0 };
-        yield return new object[] { true, false, View.Details, new ImageList(), 0 };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { true, false, View.LargeIcon, null, 0 };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList(), 1 };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty(), 1 };
-        yield return new object[] { true, false, View.List, null, 0 };
-        yield return new object[] { true, false, View.List, new ImageList(), 0 };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { true, false, View.SmallIcon, null, 0 };
-        yield return new object[] { true, false, View.SmallIcon, new ImageList(), 1 };
-        yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 1 };
-        yield return new object[] { true, false, View.Tile, null, 0 };
-        yield return new object[] { true, false, View.Tile, new ImageList(), 0 };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty(), 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null, 0 };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.List, null, 0 };
-            yield return new object[] { autoArrange, true, View.List, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, null, 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0 };
-        }
-
-        yield return new object[] { false, false, View.Details, null, 0 };
-        yield return new object[] { false, false, View.Details, new ImageList(), 0 };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.LargeIcon, null, 0 };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList(), 0 };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.List, null, 0 };
-        yield return new object[] { false, false, View.List, new ImageList(), 0 };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.SmallIcon, null, 0 };
-        yield return new object[] { false, false, View.SmallIcon, new ImageList(), 0 };
-        yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.Tile, null, 0 };
-        yield return new object[] { false, false, View.Tile, new ImageList(), 0 };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeImageList_SetWithHandle_GetReturnsExpected))]
-    public void ListView_LargeImageList_SetWithHandle_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> LargeImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null, 0 };
-        yield return new object[] { true, false, View.Details, new ImageList(), 0 };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { true, false, View.LargeIcon, null, 1 };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList(), 1 };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty(), 1 };
-        yield return new object[] { true, false, View.List, null, 0 };
-        yield return new object[] { true, false, View.List, new ImageList(), 0 };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { true, false, View.SmallIcon, null, 1 };
-        yield return new object[] { true, false, View.SmallIcon, new ImageList(), 1 };
-        yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 1 };
-        yield return new object[] { true, false, View.Tile, null, 0 };
-        yield return new object[] { true, false, View.Tile, new ImageList(), 0 };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty(), 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null, 0 };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.List, null, 0 };
-            yield return new object[] { autoArrange, true, View.List, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty(), 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, null, 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 0 };
-            yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0 };
-        }
-
-        yield return new object[] { false, false, View.Details, null, 0 };
-        yield return new object[] { false, false, View.Details, new ImageList(), 0 };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.LargeIcon, null, 0 };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList(), 0 };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.List, null, 0 };
-        yield return new object[] { false, false, View.List, new ImageList(), 0 };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.SmallIcon, null, 0 };
-        yield return new object[] { false, false, View.SmallIcon, new ImageList(), 0 };
-        yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 0 };
-        yield return new object[] { false, false, View.Tile, null, 0 };
-        yield return new object[] { false, false, View.Tile, new ImageList(), 0 };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected))]
-    public void ListView_LargeImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            LargeImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.LargeImageList = value;
-        Assert.Same(value, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_LargeImageList_Dispose_DetachesFromListView(bool autoArrange)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            LargeImageList = imageList1
-        };
-        Assert.Same(imageList1, listView.LargeImageList);
-
-        imageList1.Dispose();
-        Assert.Null(listView.LargeImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        listView.LargeImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.LargeImageList);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_LargeImageList_DisposeWithHandle_DetachesFromListView(bool autoArrange, int expectedInvalidatedCallCount)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.LargeImageList = imageList1;
-        Assert.Same(imageList1, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        listView.LargeImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.LargeImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_MultiSelect_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            MultiSelect = value
-        };
-        Assert.Equal(value, listView.MultiSelect);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.MultiSelect = value;
-        Assert.Equal(value, listView.MultiSelect);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.MultiSelect = !value;
-        Assert.Equal(!value, listView.MultiSelect);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ListView_MultiSelect_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.MultiSelect = value;
-        Assert.Equal(value, listView.MultiSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.MultiSelect = value;
-        Assert.Equal(value, listView.MultiSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.MultiSelect = !value;
-        Assert.Equal(!value, listView.MultiSelect);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_OwnerDraw_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            OwnerDraw = value
-        };
-        Assert.Equal(value, listView.OwnerDraw);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.OwnerDraw = value;
-        Assert.Equal(value, listView.OwnerDraw);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.OwnerDraw = !value;
-        Assert.Equal(!value, listView.OwnerDraw);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_OwnerDraw_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.OwnerDraw = value;
-        Assert.Equal(value, listView.OwnerDraw);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.OwnerDraw = value;
-        Assert.Equal(value, listView.OwnerDraw);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.OwnerDraw = !value;
-        Assert.Equal(!value, listView.OwnerDraw);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_Scrollable_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            Scrollable = value
-        };
-        Assert.Equal(value, listView.Scrollable);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.Scrollable = value;
-        Assert.Equal(value, listView.Scrollable);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.Scrollable = !value;
-        Assert.Equal(!value, listView.Scrollable);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0, 0)]
-    [InlineData(false, 2, 1)]
-    public void ListView_Scrollable_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.Scrollable = value;
-        Assert.Equal(value, listView.Scrollable);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.Scrollable = value;
-        Assert.Equal(value, listView.Scrollable);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        listView.Scrollable = !value;
-        Assert.Equal(!value, listView.Scrollable);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_ShowGroups_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            ShowGroups = value
-        };
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.ShowGroups = !value;
-        Assert.Equal(!value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_ShowGroups_VirtualMode_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            ShowGroups = value,
-            VirtualMode = true,
-        };
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.ShowGroups = !value;
-        Assert.Equal(!value, listView.ShowGroups);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_ShowGroups_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.ShowGroups = !value;
-        Assert.Equal(!value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_ShowGroups_VirtualMode_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            VirtualMode = true,
-        };
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.ShowGroups = value;
-        Assert.Equal(value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        listView.ShowGroups = !value;
-        Assert.Equal(!value, listView.ShowGroups);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_ShowItemToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            ShowItemToolTips = value
-        };
-        Assert.Equal(value, listView.ShowItemToolTips);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.ShowItemToolTips = value;
-        Assert.Equal(value, listView.ShowItemToolTips);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.ShowItemToolTips = !value;
-        Assert.Equal(!value, listView.ShowItemToolTips);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 1)]
-    [InlineData(false, 0, 0)]
-    public void ListView_ShowItemToolTips_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.ShowItemToolTips = value;
-        Assert.Equal(value, listView.ShowItemToolTips);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.ShowItemToolTips = value;
-        Assert.Equal(value, listView.ShowItemToolTips);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        listView.ShowItemToolTips = !value;
-        Assert.Equal(!value, listView.ShowItemToolTips);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SmallImageList_Set_GetReturnsExpected()
-    {
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            foreach (bool virtualMode in new bool[] { true, false })
-            {
-                foreach (View view in new View[] { View.Details, View.LargeIcon, View.List, View.SmallIcon })
-                {
-                    yield return new object[] { autoArrange, virtualMode, view, null };
-                    yield return new object[] { autoArrange, virtualMode, view, new ImageList() };
-                    yield return new object[] { autoArrange, virtualMode, view, CreateImageListNonEmpty() };
-                }
-            }
-
-            yield return new object[] { autoArrange, false, View.Tile, null };
-            yield return new object[] { autoArrange, false, View.Tile, new ImageList() };
-            yield return new object[] { autoArrange, false, View.Tile, CreateImageListNonEmpty() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallImageList_Set_GetReturnsExpected))]
-    public void ListView_SmallImageList_Set_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            SmallImageList = value
-        };
-        Assert.Same(value, listView.SmallImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallImageList_Set_GetReturnsExpected))]
-    public void ListView_SmallImageList_SetWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            SmallImageList = imageList
-        };
-
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SmallImageList_SetWithHandle_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null, 0, 0 };
-        yield return new object[] { true, false, View.Details, new ImageList(), 1, 0 };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { true, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList(), 1, 0 };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { true, false, View.List, null, 0, 0 };
-        yield return new object[] { true, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null, 0, 0 };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList(), 1, 0 };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty(), 1, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, null, 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { false, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, false, View.Details, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { true, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, false, View.SmallIcon, new ImageList(), 2, 0 };
-            yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 2, 0 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { autoArrange, true, View.SmallIcon, null, 0, 0 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-            }
-
-            yield return new object[] { false, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-        else
-        {
-            yield return new object[] { true, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, false, View.SmallIcon, new ImageList(), 4, 2 };
-            yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 4, 2 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { autoArrange, true, View.SmallIcon, null, 0, 0 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 2, 2 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 2, 2 };
-            }
-
-            yield return new object[] { false, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, false, View.SmallIcon, new ImageList(), 2, 2 };
-            yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 2, 2 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallImageList_SetWithHandle_GetReturnsExpected))]
-    public void ListView_SmallImageList_SetWithHandle_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount)
-    {
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SmallImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected()
-    {
-        yield return new object[] { true, false, View.Details, null, 1, 0 };
-        yield return new object[] { true, false, View.Details, new ImageList(), 1, 0 };
-        yield return new object[] { true, false, View.Details, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { true, false, View.LargeIcon, null, 1, 0 };
-        yield return new object[] { true, false, View.LargeIcon, new ImageList(), 1, 0 };
-        yield return new object[] { true, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { true, false, View.List, null, 0, 0 };
-        yield return new object[] { true, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { autoArrange, true, View.Details, null, 1, 0 };
-            yield return new object[] { autoArrange, true, View.Details, new ImageList(), 1, 0 };
-            yield return new object[] { autoArrange, true, View.Details, CreateImageListNonEmpty(), 1, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, null, 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { false, false, View.Details, null, 1, 0 };
-        yield return new object[] { false, false, View.Details, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, View.Details, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, false, View.LargeIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { true, false, View.SmallIcon, null, 2, 0 };
-            yield return new object[] { true, false, View.SmallIcon, new ImageList(), 2, 0 };
-            yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 2, 0 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { autoArrange, true, View.SmallIcon, null, 0, 0 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-            }
-
-            yield return new object[] { false, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-        else
-        {
-            yield return new object[] { true, false, View.SmallIcon, null, 4, 2 };
-            yield return new object[] { true, false, View.SmallIcon, new ImageList(), 4, 2 };
-            yield return new object[] { true, false, View.SmallIcon, CreateImageListNonEmpty(), 4, 2 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { autoArrange, true, View.SmallIcon, null, 2, 2 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, new ImageList(), 2, 2 };
-                yield return new object[] { autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 2, 2 };
-            }
-
-            yield return new object[] { false, false, View.SmallIcon, null, 2, 2 };
-            yield return new object[] { false, false, View.SmallIcon, new ImageList(), 2, 2 };
-            yield return new object[] { false, false, View.SmallIcon, CreateImageListNonEmpty(), 2, 2 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected))]
-    public void ListView_SmallImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected(bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            SmallImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.SmallImageList = value;
-        Assert.Same(value, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_SmallImageList_Dispose_DetachesFromListView(bool autoArrange)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange,
-            SmallImageList = imageList1
-        };
-        Assert.Same(imageList1, listView.SmallImageList);
-
-        imageList1.Dispose();
-        Assert.Null(listView.SmallImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        listView.SmallImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.SmallImageList);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ListView_SmallImageList_DisposeWithHandle_DetachesFromListView(bool autoArrange, int expectedInvalidatedCallCount)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            AutoArrange = autoArrange
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.SmallImageList = imageList1;
-        Assert.Same(imageList1, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        listView.SmallImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.SmallImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> StateImageList_Set_GetReturnsExpected()
-    {
-        foreach (bool useCompatibleStateImageBehavior in new bool[] { true, false })
-        {
-            foreach (bool checkBoxes in new bool[] { true, false })
-            {
-                foreach (bool autoArrange in new bool[] { true, false })
-                {
-                    foreach (bool virtualMode in new bool[] { true, false })
-                    {
-                        foreach (View view in new View[] { View.Details, View.LargeIcon, View.List, View.SmallIcon })
-                        {
-                            yield return new object[] { useCompatibleStateImageBehavior, checkBoxes, autoArrange, virtualMode, view, null };
-                            yield return new object[] { useCompatibleStateImageBehavior, checkBoxes, autoArrange, virtualMode, view, new ImageList() };
-                            yield return new object[] { useCompatibleStateImageBehavior, checkBoxes, autoArrange, virtualMode, view, CreateImageListNonEmpty() };
-                        }
-                    }
-                }
-            }
-
-            yield return new object[] { useCompatibleStateImageBehavior, false, true, false, View.Tile, null };
-            yield return new object[] { useCompatibleStateImageBehavior, false, true, false, View.Tile, new ImageList() };
-            yield return new object[] { useCompatibleStateImageBehavior, false, true, false, View.Tile, CreateImageListNonEmpty() };
-
-            yield return new object[] { useCompatibleStateImageBehavior, false, false, false, View.Tile, null };
-            yield return new object[] { useCompatibleStateImageBehavior, false, false, false, View.Tile, new ImageList() };
-            yield return new object[] { useCompatibleStateImageBehavior, false, false, false, View.Tile, CreateImageListNonEmpty() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageList_Set_GetReturnsExpected))]
-    public void ListView_StateImageList_Set_GetReturnsExpected(bool useCompatibleStateImageBehavior, bool checkBoxes, bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            CheckBoxes = checkBoxes,
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            StateImageList = value
-        };
-        Assert.Same(value, listView.StateImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageList_Set_GetReturnsExpected))]
-    public void ListView_StateImageList_SetWithNonNullOldValue_GetReturnsExpected(bool useCompatibleStateImageBehavior, bool checkBoxes, bool autoArrange, bool virtualMode, View view, ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            CheckBoxes = checkBoxes,
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-            StateImageList = imageList
-        };
-
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StateImageList_SetWithHandle_GetReturnsExpected()
-    {
-        // UseCompatibleStateImageBehavior true
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { true, checkBoxes, true, false, View.Details, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-            }
-
-            yield return new object[] { true, checkBoxes, false, false, View.Details, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { true, false, true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        yield return new object[] { true, false, false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        // UseCompatibleStateImageBehavior false, CheckBoxes true
-        yield return new object[] { false, true, true, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, true, true, false, View.Details, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.Details, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, new ImageList(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, CreateImageListNonEmpty(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.List, null, 0, 0 };
-        yield return new object[] { false, true, true, false, View.List, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.List, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, null, 0, 0 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, new ImageList(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, CreateImageListNonEmpty(), 3, 1 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { false, true, autoArrange, true, View.Details, null, 0, 0 };
-            yield return new object[] { false, true, autoArrange, true, View.Details, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.Details, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.List, null, 0, 0 };
-            yield return new object[] { false, true, autoArrange, true, View.List, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.List, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 1, 1 };
-        }
-
-        yield return new object[] { false, true, false, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, true, false, false, View.Details, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.Details, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.List, null, 0, 0 };
-        yield return new object[] { false, true, false, false, View.List, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.List, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, null, 0, 0 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, CreateImageListNonEmpty(), 1, 1 };
-
-        // UseCompatibleStateImageBehavior false, CheckBoxes false
-        yield return new object[] { false, false, true, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.Details, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { false, false, autoArrange, true, View.Details, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { false, false, false, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.Details, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageList_SetWithHandle_GetReturnsExpected))]
-    public void ListView_StateImageList_SetWithHandle_GetReturnsExpected(bool useCompatibleStateImageBehavior, bool checkBoxes, bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            CheckBoxes = checkBoxes,
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> StateImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected()
-    {
-        // UseCompatibleStateImageBehavior true
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { true, checkBoxes, true, false, View.Details, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, true, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-
-            foreach (bool autoArrange in new bool[] { true, false })
-            {
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.Details, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, null, 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-                yield return new object[] { true, checkBoxes, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-            }
-
-            yield return new object[] { true, checkBoxes, false, false, View.Details, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { true, checkBoxes, false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { true, false, true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        yield return new object[] { true, false, false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { true, false, false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { true, false, false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        // UseCompatibleStateImageBehavior false, CheckBoxes true
-        yield return new object[] { false, true, true, false, View.Details, null, 1, 1 };
-        yield return new object[] { false, true, true, false, View.Details, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.Details, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, null, 3, 1 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, new ImageList(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.LargeIcon, CreateImageListNonEmpty(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.List, null, 1, 1 };
-        yield return new object[] { false, true, true, false, View.List, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.List, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, null, 3, 1 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, new ImageList(), 3, 1 };
-        yield return new object[] { false, true, true, false, View.SmallIcon, CreateImageListNonEmpty(), 3, 1 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { false, true, autoArrange, true, View.Details, null, 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.Details, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.Details, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, null, 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.List, null, 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.List, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.List, CreateImageListNonEmpty(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, null, 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, new ImageList(), 1, 1 };
-            yield return new object[] { false, true, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 1, 1 };
-        }
-
-        yield return new object[] { false, true, false, false, View.Details, null, 1, 1 };
-        yield return new object[] { false, true, false, false, View.Details, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.Details, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, null, 1, 1 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.List, null, 1, 1 };
-        yield return new object[] { false, true, false, false, View.List, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.List, CreateImageListNonEmpty(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, null, 1, 1 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, new ImageList(), 1, 1 };
-        yield return new object[] { false, true, false, false, View.SmallIcon, CreateImageListNonEmpty(), 1, 1 };
-
-        // UseCompatibleStateImageBehavior false, CheckBoxes false
-        yield return new object[] { false, false, true, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.Details, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, null, 1, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.LargeIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, null, 1, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, new ImageList(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.SmallIcon, CreateImageListNonEmpty(), 1, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, true, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-
-        foreach (bool autoArrange in new bool[] { true, false })
-        {
-            yield return new object[] { false, false, autoArrange, true, View.Details, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.Details, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.Details, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.List, CreateImageListNonEmpty(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, null, 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, new ImageList(), 0, 0 };
-            yield return new object[] { false, false, autoArrange, true, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        }
-
-        yield return new object[] { false, false, false, false, View.Details, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.Details, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Details, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.LargeIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.List, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.SmallIcon, CreateImageListNonEmpty(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, null, 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, new ImageList(), 0, 0 };
-        yield return new object[] { false, false, false, false, View.Tile, CreateImageListNonEmpty(), 0, 0 };
-    }
-
-    [WinFormsTheory(Skip = "Leads to random AccessViolationException. See: https://github.com/dotnet/winforms/issues/3358")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3358")]
-    [MemberData(nameof(StateImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected))]
-    public void ListView_StateImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected(bool useCompatibleStateImageBehavior, bool checkBoxes, bool autoArrange, bool virtualMode, View view, ImageList value, int expectedInvalidatedCallCount, int expectedCreatedCallCount)
-    {
-        using var imageList = new ImageList();
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            CheckBoxes = checkBoxes,
-            AutoArrange = autoArrange,
-            VirtualMode = virtualMode,
-            View = view,
-        };
-
-        listView.StateImageList = imageList;
-
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        listView.StateImageList = value;
-        Assert.Same(value, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(false, true)]
-    [InlineData(true, false)]
-    [InlineData(false, false)]
-    public void ListView_StateImageList_Dispose_DetachesFromListView(bool useCompatibleStateImageBehavior, bool autoArrange)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            AutoArrange = autoArrange,
-            StateImageList = imageList1
-        };
-        Assert.Same(imageList1, listView.StateImageList);
-
-        imageList1.Dispose();
-        Assert.Null(listView.StateImageList);
-        Assert.False(listView.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        listView.StateImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.StateImageList);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 1, 1)]
-    [InlineData(false, true, 1, 2, 3)]
-    [InlineData(true, false, 0, 0, 0)]
-    [InlineData(false, false, 0, 0, 0)]
-    public void ListView_StateImageList_DisposeWithHandle_DetachesFromListView(bool useCompatibleStateImageBehavior, bool autoArrange, int expectedInvalidatedCallCount1, int expectedInvalidatedCallCount2, int expectedInvalidatedCallCount3)
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior,
-            AutoArrange = autoArrange
-        };
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.StateImageList = imageList1;
-        Assert.Same(imageList1, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        listView.StateImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, listView.StateImageList);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_UseCompatibleStateImageBehavior_Set_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView
-        {
-            UseCompatibleStateImageBehavior = value
-        };
-        Assert.Equal(value, listView.UseCompatibleStateImageBehavior);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set same.
-        listView.UseCompatibleStateImageBehavior = value;
-        Assert.Equal(value, listView.UseCompatibleStateImageBehavior);
-        Assert.False(listView.IsHandleCreated);
-
-        // Set different.
-        listView.UseCompatibleStateImageBehavior = !value;
-        Assert.Equal(!value, listView.UseCompatibleStateImageBehavior);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ListView_UseCompatibleStateImageBehavior_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var listView = new ListView();
-        Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        int invalidatedCallCount = 0;
-        listView.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        listView.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        listView.HandleCreated += (sender, e) => createdCallCount++;
-
-        listView.UseCompatibleStateImageBehavior = value;
-        Assert.Equal(value, listView.UseCompatibleStateImageBehavior);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        listView.UseCompatibleStateImageBehavior = value;
-        Assert.Equal(value, listView.UseCompatibleStateImageBehavior);
-        Assert.True(listView.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ListView_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListView();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvokeWithoutHandle_ReturnsExpectedAndCreatedHandle()
-    {
-        using var control = new ListView();
-        var item1 = new ListViewItem();
-        var item2 = new ListViewItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        Rectangle rect1 = control.GetItemRect(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetItemRect(0));
-        Assert.True(control.IsHandleCreated);
-
-        Rectangle rect2 = control.GetItemRect(1);
-        Assert.True((rect2.X >= rect1.Right && rect2.Y == rect1.Y) || (rect2.X == rect1.X && rect2.Y >= rect1.Bottom));
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new ListView();
-        var item1 = new ListViewItem();
-        var item2 = new ListViewItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Rectangle rect1 = control.GetItemRect(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetItemRect(0));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        Rectangle rect2 = control.GetItemRect(1);
-        Assert.True((rect2.X >= rect1.Right && rect2.Y == rect1.Y) || (rect2.X == rect1.X && rect2.Y >= rect1.Bottom));
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetItemRect_InvokeCustomGetItemRect_TestData()
-    {
-        yield return new object[] { new RECT(), Rectangle.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Rectangle(1, 2, 2, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetItemRect_InvokeCustomGetItemRect_TestData))]
-    public void ListView_GetItemRect_InvokeCustomGetItemRect_ReturnsExpected(object getItemRectResult, Rectangle expected)
-    {
-        using var control = new CustomGetItemRectListView
-        {
-            GetItemRectResult = (RECT)getItemRectResult
-        };
-        var item = new ListViewItem();
-        control.Items.Add(item);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, control.GetItemRect(0));
-    }
-
-    private class CustomGetItemRectListView : ListView
-    {
-        public RECT GetItemRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.LVM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetItemRectResult;
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvokeInvalidGetItemRect_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new InvalidGetItemRectListView();
-        var item = new ListViewItem();
-        control.Items.Add(item);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(0));
-    }
-
-    private class InvalidGetItemRectListView : ListView
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.LVM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = new RECT(1, 2, 3, 4);
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListView();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(1));
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListView();
-        var item1 = new ListViewItem();
-        control.Items.Add(item1);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(2));
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvalidIndexWithHandleEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListView();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(1));
-    }
-
-    [WinFormsFact]
-    public void ListView_GetItemRect_InvalidIndexWithHandleNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ListView();
-        var item1 = new ListViewItem();
-        control.Items.Add(item1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetItemRect(2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ListView_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubListView();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ListView_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubListView();
-        Assert.False(control.GetTopLevel());
-    }
-
-    private static ImageList CreateImageListNonEmpty()
-    {
-        var nonEmptyImageList = new ImageList();
-        nonEmptyImageList.Images.Add(new Bitmap(10, 10));
-        return nonEmptyImageList;
-    }
-
-    public static IEnumerable<object[]> ListView_InvokeOnSelectedIndexChanged_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool focused in new[] { true, false })
-                {
-                    foreach (bool selected in new[] { true, false })
-                    {
-                        // Updating Focused property of ListViewItem always calls RaiseAutomationEvent.
-                        // If ListViewItem is focused and selected then RaiseAutomationEvent is also called.
-                        int expectedCallCount = focused && selected ? 2 : 1;
-                        yield return new object[] { view, showGroups, focused, selected, expectedCallCount };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_InvokeOnSelectedIndexChanged_TestData))]
-    public void ListView_OnSelectedIndexChanged_Invoke(View view, bool showGroups, bool focused, bool selected, int expectedCallCount)
-    {
-        using var listView = new SubListView
-        {
-            View = view,
-            VirtualMode = false,
-            ShowGroups = showGroups
-        };
-
-        listView.CreateControl();
-
-        SubListViewItem testItem = new SubListViewItem("Test 1");
-
-        listView.Items.Add(testItem);
-
-        SubListViewItemAccessibleObject customAccessibleObject = new SubListViewItemAccessibleObject(testItem);
-        testItem.CustomAccessibleObject = customAccessibleObject;
-
-        // Enforce accessible object creation
-        _ = listView.AccessibilityObject;
-
-        listView.Items[0].Focused = focused;
-        listView.Items[0].Selected = selected;
-
-        Assert.Equal(expectedCallCount, customAccessibleObject?.RaiseAutomationEventCalls);
-    }
-
-    public static IEnumerable<object[]> ListView_InvokeOnSelectedIndexChanged_VirtualMode_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool focused in new[] { true, false })
-                {
-                    foreach (bool selected in new[] { true, false })
-                    {
-                        // Updating Focused property of ListViewItem always calls RaiseAutomationEvent.
-                        // If ListViewItem is focused and selected then RaiseAutomationEvent is also called.
-                        int expectedCallCount = focused && selected ? 2 : 1;
-                        yield return new object[] { view, showGroups, focused, selected, expectedCallCount };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_InvokeOnSelectedIndexChanged_VirtualMode_TestData))]
-    public void ListView_OnSelectedIndexChanged_VirtualMode_Invoke(View view, bool showGroups, bool focused, bool selected, int expectedCallCount)
-    {
-        SubListViewItem listItem1 = new SubListViewItem("Test 1");
-
-        using ListView listView = new ListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups,
-            VirtualListSize = 1
-        };
-
-        listView.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => listItem1,
-                _ => throw new NotImplementedException()
-            };
-        };
-
-        listView.CreateControl();
-        listItem1.SetItemIndex(listView, 0);
-
-        Assert.NotNull(listView.AccessibilityObject);
-
-        SubListViewItemAccessibleObject customAccessibleObject = new SubListViewItemAccessibleObject(listItem1);
-        listItem1.CustomAccessibleObject = customAccessibleObject;
-
-        listView.Items[0].Focused = focused;
-        listView.Items[0].Selected = selected;
-
-        Assert.Equal(expectedCallCount, customAccessibleObject?.RaiseAutomationEventCalls);
-    }
-
-    public static IEnumerable<object[]> ListView_Checkboxes_VirtualMode_Disabling_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // View.Tile is not supported by ListView in virtual mode
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                foreach (bool useCompatibleStateImageBehavior in new[] { true, false })
-                {
-                    yield return new object[] { view, showGroups, useCompatibleStateImageBehavior };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_Checkboxes_VirtualMode_Disabling_TestData))]
-    public void ListView_Checkboxes_VirtualMode_Disabling_Succeeds(View view, bool showGroups, bool useCompatibleStateImageBehavior)
-    {
-        using var listView = new SubListView
-        {
-            View = view,
-            VirtualMode = true,
-            ShowGroups = showGroups,
-            UseCompatibleStateImageBehavior = useCompatibleStateImageBehavior
-        };
-
-        listView.CheckBoxes = true;
-        listView.CheckBoxes = false; // This would throw an InvalidOperationException prior to fix of #4042
-    }
-
-    [WinFormsFact]
-    public void ListView_WmReflectNotify_LVN_KEYDOWN_WithoutGroups_and_CheckBoxes_DoesntHaveSelectedItems()
-    {
-        using var control = new ListView();
-        control.Items.Add(new ListViewItem());
-        control.Items.Add(new ListViewItem());
-        control.CreateControl();
-        PInvoke.SendMessage(control, PInvoke.WM_KEYDOWN);
-        Assert.Equal(0, control.SelectedItems.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, true)]
-    [InlineData(false, true, true)]
-    [InlineData(false, false, true)]
-    [InlineData(true, true, false)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public unsafe void ListView_WmReflectNotify_LVN_KEYDOWN_SpaceKey_HasCheckBoxes_WithoutGroups_CheckedExpected(bool focusItem, bool checkItem, bool selectItems)
-    {
-        using var control = new ListView();
-        control.CheckBoxes = true;
-        ListViewItem item1 = new ListViewItem();
-        item1.Text = "First";
-        ListViewItem item2 = new ListViewItem();
-        item2.Text = "Second";
-
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        control.CreateControl();
-        control.VirtualMode = false;
-
-        item1.Focused = focusItem;
-        item1.Checked = checkItem;
-        item1.Selected = selectItems;
-        item2.Selected = selectItems;
-
-        KeyboardSimulator.KeyDown(control, Keys.Space);
-
-        Assert.Equal(selectItems ? 2 : 0, control.SelectedItems.Count);
-        Assert.Equal(!checkItem && selectItems && focusItem, item2.Checked);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Down)]
-    [InlineData(Keys.Up)]
-    public unsafe void ListView_WmReflectNotify_LVN_KEYDOWN_WithGroups_WithoutSelection_DoesntFocusGroup(Keys key)
-    {
-        using var control = new ListView();
-        ListViewItem item1 = new ListViewItem();
-        item1.Text = "First";
-        ListViewItem item2 = new ListViewItem();
-        item2.Text = "Second";
-
-        ListViewGroup group = new ListViewGroup("Test group");
-        group.Items.Add(item1);
-        group.Items.Add(item2);
-
-        control.VirtualMode = false;
-        control.Groups.Add(group);
-        control.CreateControl();
-
-        KeyboardSimulator.KeyDown(control, key);
-
-        Assert.Empty(control.SelectedIndices);
-        Assert.Null(control.FocusedItem);
-        Assert.Null(control.FocusedGroup);
-    }
-
-    [WinFormsTheory(Skip = "Crash with unexpected invokerHandle ExitCode")]
-    [InlineData("Keys.Down", "2")]
-    [InlineData("Keys.Up", "1")]
-    public unsafe void ListView_WmReflectNotify_LVN_KEYDOWN_WithGroups_and_SelectedItems_FocusedGroupIsExpected(string keyString, string expectedGroupIndexString)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke((key_s, expectedGroupIndex_s) =>
-        {
-            Application.EnableVisualStyles();
-
-            using var control = new ListView();
-            ListViewGroup group1 = new ListViewGroup("Test group1");
-            ListViewGroup group2 = new ListViewGroup("Test group2");
-            ListViewGroup group3 = new ListViewGroup("Test group3");
-            ListViewItem item1 = new ListViewItem(group1);
-            item1.Text = "First";
-            ListViewItem item2 = new ListViewItem(group2);
-            item2.Text = "Second";
-            ListViewItem item3 = new ListViewItem(group3);
-            item3.Text = "Third";
-            control.Items.Add(item1);
-            control.Items.Add(item2);
-            control.Items.Add(item3);
-            control.Groups.Add(group1);
-            control.Groups.Add(group2);
-            control.Groups.Add(group3);
-            control.VirtualMode = false;
-            control.CreateControl();
-
-            item2.Selected = true;
-
-            var key = key_s == "Keys.Down" ? Keys.Down : Keys.Up;
-            KeyboardSimulator.KeyDown(control, key);
-
-            Assert.False(control.GroupsEnabled);
-            Assert.True(control.Items.Count > 0);
-            int expectedGroupIndex = int.Parse(expectedGroupIndex_s);
-            Assert.Equal(control.Groups[expectedGroupIndex], control.FocusedGroup);
-        }, keyString, expectedGroupIndexString);
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Down)]
-    [InlineData(Keys.Up)]
-    public unsafe void ListView_VirtualMode_WmReflectNotify_LVN_KEYDOWN_WithGroups_DoesNotFocusGroups(Keys key)
-    {
-        using ListView control = new ListView
-        {
-            ShowGroups = true,
-            CheckBoxes = false,
-            VirtualListSize = 2 // we can't add items, just indicate how many we have
-        };
-
-        ListViewGroup group = new ListViewGroup("Test group");
-        control.Groups.Add(group);
-        control.VirtualMode = true;
-        control.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => new ListViewItem(group) { Selected = true },
-                _ => new ListViewItem(group),
-            };
-        };
-
-        control.CreateControl();
-
-        KeyboardSimulator.KeyDown(control, key);
-
-        Assert.Null(control.FocusedGroup);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public unsafe void ListView_VirtualMode_WmReflectNotify_LVN_KEYDOWN_EnabledCheckBoxes_WithoutGroups_DoesNotCheckItems(bool checkedItem)
-    {
-        using ListView control = new ListView
-        {
-            ShowGroups = true,
-            CheckBoxes = true,
-            VirtualMode = true,
-            VirtualListSize = 2 // we can't add items, just indicate how many we have
-        };
-
-        ListViewItem item1 = new ListViewItem();
-        ListViewItem item2 = new ListViewItem();
-
-        control.RetrieveVirtualItem += (s, e) =>
-        {
-            e.Item = e.ItemIndex switch
-            {
-                0 => item1,
-                _ => item2,
-            };
-        };
-
-        control.CreateControl();
-        item1.Checked = checkedItem;
-        item2.Checked = false;
-        control.FocusedItem = item1;
-
-        KeyboardSimulator.KeyDown(control, Keys.Space);
-
-        Assert.False(item2.Checked);
-    }
-
-    [WinFormsFact]
-    public void ListView_KeyUp_Event_Triggers()
-    {
-        using ListView control = new();
-        int callCount = 0;
-        control.KeyUp += (_, _) => callCount++;
-
-        KeyboardSimulator.KeyPress(control, Keys.Enter);
-
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ListView_SelectedIndexies_Contains_Invoke_TestData()
-    {
-        foreach (bool virtualMode in new[] { true, false })
-        {
-            foreach (View view in Enum.GetValues(typeof(View)))
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        yield return new object[] { view, showGroups, createHandle, virtualMode };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_SelectedIndexies_Contains_Invoke_TestData))]
-    public void ListView_SelectedIndexies_Contains_Invoke_ReturnExpected(View view, bool showGroups, bool createHandle, bool virtualMode)
-    {
-        using ListView listView = new ListView
-        {
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            View = view,
-            VirtualListSize = 1
-        };
-
-        var listItem = new ListViewItem();
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem,
-                    _ => throw new NotImplementedException()
-                };
-            };
-        }
-        else
-        {
-            listView.Items.Add(listItem);
-        }
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        listView.Items[0].Selected = true;
-
-        Assert.False(listView.SelectedIndices.Contains(-1));
-        Assert.False(listView.SelectedIndices.Contains(1));
-        Assert.True(listView.SelectedIndices.Contains(0));
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListView_OnGotFocus_Invoke_TestData()
-    {
-        foreach (bool virtualMode in new[] { true, false })
-        {
-            foreach (View view in Enum.GetValues(typeof(View)))
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (virtualMode && view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool createHandle in new[] { true, false })
-                    {
-                        foreach (bool focused in new[] { true, false })
-                        {
-                            int expectedCount = createHandle
-                                ? focused
-                                    ? 2 // "RaiseAutomationEvent" method is called when test updates "Focused" property and calls "OnGotFocus" method
-                                    : 1 // "RaiseAutomationEvent" method is called when test updates "Focused" property
-                                : 0; // "RaiseAutomationEvent method" is not called if handle is not created
-
-                            yield return new object[] { view, virtualMode, showGroups, createHandle, focused, expectedCount };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_OnGotFocus_Invoke_TestData))]
-    public void ListView_OnGotFocus_Invoke(View view, bool virtualMode, bool showGroups, bool createHandle, bool focused, int expectedCount)
-    {
-        using var listView = new SubListView
-        {
-            View = view,
-            VirtualMode = virtualMode,
-            ShowGroups = showGroups,
-            VirtualListSize = 1
-        };
-
-        SubListViewItem listItem = new SubListViewItem("Test 1");
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem.SetItemIndex(listView, 0);
-        }
-        else
-        {
-            listView.Items.Add(listItem);
-        }
-
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, listView.Handle);
-        }
-
-        Assert.NotNull(listView.AccessibilityObject);
-
-        SubListViewItemAccessibleObject customAccessibleObject = new SubListViewItemAccessibleObject(listItem);
-        listItem.CustomAccessibleObject = customAccessibleObject;
-        listView.Items[0].Focused = focused;
-        listView.OnGotFocus(new EventArgs());
-
-        Assert.Equal(expectedCount, customAccessibleObject.RaiseAutomationEventCalls);
-        Assert.Equal(createHandle, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public unsafe void ListView_InvokeGetToolInfoWrapper_ReturnsExpected(bool showItemToolTips, bool useKeyboardToolTip)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ToolTip toolTip = useKeyboardToolTip ? listView.KeyboardToolTip : new ToolTip();
-        ComCtl32.ToolInfoWrapper<Control> wrapper = listView.GetToolInfoWrapper(TOOLTIP_FLAGS.TTF_ABSOLUTE, "Test caption", toolTip);
-
-        Assert.Equal("Test caption", wrapper.Text);
-        //Assert.Equal method does not work because char* cannot be used as an argument to it
-        Assert.Equal(string.Empty, new string(wrapper.Info.lpszText));
-    }
-
-    [WinFormsFact]
-    public unsafe void ListView_ShowNodesEnabled_ExternalToolTip_InvokeGetToolInfoWrapper_ReturnsExpected()
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = true;
-        ToolTip toolTip = new ToolTip();
-        ComCtl32.ToolInfoWrapper<Control> wrapper = listView.GetToolInfoWrapper(TOOLTIP_FLAGS.TTF_ABSOLUTE, "Test caption", toolTip);
-        char* expected = (char*)(-1);
-
-        Assert.Null(wrapper.Text);
-        //Assert.Equal method does not work because char* cannot be used as an argument to it
-        Assert.True(wrapper.Info.lpszText == expected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListView_InvokeAdd_AddListViewItemToTrackList(bool showItemToolTips)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ListViewItem listViewItem = new ListViewItem();
-        listView.Items.Add(listViewItem);
-
-        Assert.True((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListView_InvokeAddRange_AddlistViewItemsToTrackList(bool showItemToolTips)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ListViewItem listViewItem1 = new ListViewItem();
-        ListViewItem listViewItem2 = new ListViewItem();
-        ListViewItem listViewItem3 = new ListViewItem();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-
-        listView.Items.AddRange(new ListViewItem[] { listViewItem1, listViewItem2, listViewItem3 });
-
-        Assert.True(accessor.IsToolTracked(listViewItem1));
-        Assert.True(accessor.IsToolTracked(listViewItem2));
-        Assert.True(accessor.IsToolTracked(listViewItem3));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListView_InvokeInsert_AddlistViewItemToTrackList(bool showItemToolTips)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ListViewItem listViewItem = new ListViewItem();
-        listView.Items.Insert(0, listViewItem);
-
-        Assert.True((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListView_InvokeRemove_RemoveListViewItemFromTrackList(bool showItemToolTips)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ListViewItem listViewItem = new ListViewItem();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        listView.Items.Add(listViewItem);
-
-        Assert.True(accessor.IsToolTracked(listViewItem));
-
-        listView.Items.Remove(listViewItem);
-        Assert.False(accessor.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ListView_InvokeDispose_RemoveListViewItemFromTrackList(bool showItemToolTips)
-    {
-        using var listView = new ListView();
-        listView.ShowItemToolTips = showItemToolTips;
-        ListViewItem listViewItem = new ListViewItem();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        listView.Items.Add(listViewItem);
-
-        Assert.True(accessor.Dynamic.IsToolTracked(listViewItem));
-
-        listView.Dispose();
-        Assert.False(accessor.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsFact]
-    public void ListView_NormalMode_InvokeNotifyAboutGotFocus_DoesNotAddListViewItemToTrackList()
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem = new ListViewItem();
-        listView.TestAccessor().Dynamic.NotifyAboutGotFocus(listViewItem);
-        Assert.False((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsFact]
-    public void ListView_VirtualMode_InvokeNotifyAboutGotFocus_AddListViewItemToTrackList()
-    {
-        using var listView = new ListView() { VirtualMode = true };
-        ListViewItem listViewItem = new ListViewItem();
-        listView.TestAccessor().Dynamic.NotifyAboutGotFocus(listViewItem);
-        Assert.True((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsFact]
-    public void ListView_NormalMode_InvokeNotifyAboutLostFocus_DoesNotRemoveListViewItemFromTrackList()
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem = new ListViewItem();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        listView.Items.Add(listViewItem);
-
-        Assert.True(accessor.IsToolTracked(listViewItem));
-
-        listView.TestAccessor().Dynamic.NotifyAboutLostFocus(listViewItem);
-        Assert.True(accessor.IsToolTracked(listViewItem));
-    }
-
-    [WinFormsFact]
-    public void ListView_VirtualMode_InvokeNotifyAboutLostFocus_RemoveListViewItemFromTrackList()
-    {
-        using var listView = new ListView() { VirtualMode = true };
-        ListViewItem listViewItem = new ListViewItem();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-
-        listView.TestAccessor().Dynamic.NotifyAboutGotFocus(listViewItem);
-        Assert.True(accessor.IsToolTracked(listViewItem));
-
-        listView.TestAccessor().Dynamic.NotifyAboutLostFocus(listViewItem);
-        Assert.False(accessor.IsToolTracked(listViewItem));
-    }
-
-    public static IEnumerable<object[]> ListView_FindNearestItem_Invoke_TestData()
-    {
-        yield return new object[] { 0, null, null, 1, 3 };
-        yield return new object[] { 1, 0, null, 2, 4 };
-        yield return new object[] { 2, 1, null, null, 5 };
-        yield return new object[] { 3, null, 0, 4, 6 };
-        yield return new object[] { 4, 3, 1, 5, 7 };
-        yield return new object[] { 5, 4, 2, null, 8 };
-        yield return new object[] { 6, null, 3, 7, null };
-        yield return new object[] { 7, 6, 4, 8, null };
-        yield return new object[] { 8, 7, 5, null, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_FindNearestItem_Invoke_TestData))]
-    public void ListView_FindNearestItem(int item, int? leftitem, int? upitem, int? rightitem, int? downitem)
-    {
-        using var listView = new ListView();
-        ListViewItem listViewItem1 = new ListViewItem("1");
-        ListViewItem listViewItem2 = new ListViewItem("2");
-        ListViewItem listViewItem3 = new ListViewItem("3");
-        ListViewItem listViewItem4 = new ListViewItem("4");
-        ListViewItem listViewItem5 = new ListViewItem("5");
-        ListViewItem listViewItem6 = new ListViewItem("6");
-        ListViewItem listViewItem7 = new ListViewItem("7");
-        ListViewItem listViewItem8 = new ListViewItem("8");
-        ListViewItem listViewItem9 = new ListViewItem("9");
-
-        using ColumnHeader columnHeader1 = new System.Windows.Forms.ColumnHeader();
-        using ColumnHeader columnHeader2 = new System.Windows.Forms.ColumnHeader();
-
-        listView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2
-        });
-        listView.HideSelection = false;
-        var listItems = new System.Windows.Forms.ListViewItem[]
-        {
-        listViewItem1,
-        listViewItem2,
-        listViewItem3,
-        listViewItem4,
-        listViewItem5,
-        listViewItem6,
-        listViewItem7,
-        listViewItem8,
-        listViewItem9
-        };
-        listView.Items.AddRange(listItems);
-        listView.View = System.Windows.Forms.View.SmallIcon;
-        listView.Size = new System.Drawing.Size(200, 200);
-
-        var listViewItemToTest = listItems[item];
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Left, leftitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Up, upitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Right, rightitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Down, downitem);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_FindNearestItem_Invoke_TestData))]
-    public void ListView_FindNearestItem_With_Images(int item, int? leftitem, int? upitem, int? rightitem, int? downitem)
-    {
-        using var imagecollection = new ImageList();
-        imagecollection.Images.Add(Form.DefaultIcon);
-        imagecollection.Images.Add(Form.DefaultIcon);
-
-        imagecollection.TransparentColor = System.Drawing.Color.Transparent;
-        imagecollection.Images.SetKeyName(0, "SmallA.bmp");
-        imagecollection.Images.SetKeyName(1, "SmallABlue.bmp");
-
-        using var listView = new ListView();
-        listView.SmallImageList = imagecollection;
-        ListViewItem listViewItem1 = new ListViewItem("Item1");
-        ListViewItem listViewItem2 = new ListViewItem("item2") { ImageKey = "SmallABlue.bmp" };
-        ListViewItem listViewItem3 = new ListViewItem("item3");
-        ListViewItem listViewItem4 = new ListViewItem("Items 4") { ImageKey = "SmallA.bmp" };
-        ListViewItem listViewItem5 = new ListViewItem("Items 5");
-        ListViewItem listViewItem6 = new ListViewItem("Items 6") { ImageKey = "SmallABlue.bmp" };
-        ListViewItem listViewItem7 = new ListViewItem("Items 7") { ImageKey = "SmallA.bmp" };
-        ListViewItem listViewItem8 = new ListViewItem("Items 8");
-        ListViewItem listViewItem9 = new ListViewItem("Items 9");
-
-        using ColumnHeader columnHeader1 = new System.Windows.Forms.ColumnHeader();
-        using ColumnHeader columnHeader2 = new System.Windows.Forms.ColumnHeader();
-
-        listView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[]
-        {
-        columnHeader1,
-        columnHeader2
-        });
-        listView.HideSelection = false;
-        var listItems = new System.Windows.Forms.ListViewItem[]
-        {
-        listViewItem1,
-        listViewItem2,
-        listViewItem3,
-        listViewItem4,
-        listViewItem5,
-        listViewItem6,
-        listViewItem7,
-        listViewItem8,
-        listViewItem9
-        };
-        listView.Items.AddRange(listItems);
-        listView.View = System.Windows.Forms.View.SmallIcon;
-        listView.Size = new System.Drawing.Size(200, 200);
-
-        var listViewItemToTest = listItems[item];
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Left, leftitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Up, upitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Right, rightitem);
-        ListView_FindNearestItem_Check_Result(listItems, listViewItemToTest, SearchDirectionHint.Down, downitem);
-    }
-
-    private void ListView_FindNearestItem_Check_Result(ListViewItem[] listItems, ListViewItem item, SearchDirectionHint direction, int? resultItem)
-    {
-        if (!resultItem.HasValue)
-        {
-            Assert.Null(item.FindNearestItem(direction));
-        }
-        else
-        {
-            Assert.Equal(listItems[resultItem.Value], item.FindNearestItem(direction));
-        }
-    }
-
-    [WinFormsFact]
-    public void ListView_Invokes_SetToolTip_IfExternalToolTipIsSet()
-    {
-        using ListView listView = new ListView();
-        using ToolTip toolTip = new ToolTip();
-        listView.CreateControl();
-
-        dynamic listViewDynamic = listView.TestAccessor().Dynamic;
-        string actual = listViewDynamic._toolTipCaption;
-
-        Assert.Empty(actual);
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        string text = "Some test text";
-        toolTip.SetToolTip(listView, text); // Invokes ListView's SetToolTip inside
-        actual = listViewDynamic._toolTipCaption;
-
-        Assert.Equal(text, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListView_AnnounceColumnHeader_DoesNotWork_WithoutHandle(View view)
-    {
-        using ListView listView = new ListView()
-        {
-            Size = new Size(300, 200),
-            View = view
-        };
-
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 1", Width = 100 });
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 2", Width = 100 });
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 3", Width = 100 });
-        listView.Items.Add(new ListViewItem("Test"));
-        SubListViewAccessibleObject accessibleObject = new(listView);
-
-        int accessibilityProperty = listView.TestAccessor().Dynamic.s_accessibilityProperty;
-        listView.Properties.SetObject(accessibilityProperty, accessibleObject);
-        listView.AnnounceColumnHeader(new Point(15, 40));
-        Assert.Equal(0, accessibleObject.RaiseAutomationNotificationCallCount);
-        Assert.False(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListView_AnnounceColumnHeader_DoesNotWork_WithoutHeader(View view)
-    {
-        using ListView listView = new ListView()
-        {
-            Size = new Size(300, 200),
-            View = view
-        };
-
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test"));
-        SubListViewAccessibleObject accessibleObject = new(listView);
-
-        int accessibilityProperty = listView.TestAccessor().Dynamic.s_accessibilityProperty;
-        listView.Properties.SetObject(accessibilityProperty, accessibleObject);
-        listView.AnnounceColumnHeader(new Point(15, 40));
-        Assert.Equal(0, accessibleObject.RaiseAutomationNotificationCallCount);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(View.Details)]
-    [InlineData(View.LargeIcon)]
-    [InlineData(View.List)]
-    [InlineData(View.SmallIcon)]
-    [InlineData(View.Tile)]
-    public void ListView_AnnounceColumnHeader_DoesNotWork_InvalidPoint(View view)
-    {
-        using ListView listView = new ListView()
-        {
-            Size = new Size(300, 200),
-            View = view
-        };
-
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test"));
-        SubListViewAccessibleObject accessibleObject = new(listView);
-
-        int accessibilityProperty = listView.TestAccessor().Dynamic.s_accessibilityProperty;
-        listView.Properties.SetObject(accessibilityProperty, accessibleObject);
-        listView.AnnounceColumnHeader(new Point(10, 20));
-        Assert.Equal(0, accessibleObject.RaiseAutomationNotificationCallCount);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(15, 40, "Column 1")]
-    [InlineData(150, 40, "Column 2")]
-    [InlineData(250, 40, "Column 3")]
-    public void ListView_AnnounceColumnHeader_WorksCorrectly(int x, int y, string expectedColumnName)
-    {
-        using ListView listView = new ListView()
-        {
-            Size = new Size(300, 200),
-            View = View.Details
-        };
-
-        listView.CreateControl();
-
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 1", Width = 100 });
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 2", Width = 100 });
-        listView.Columns.Add(new ColumnHeader() { Text = "Column 3", Width = 100 });
-        listView.Items.Add(new ListViewItem("Test"));
-        SubListViewAccessibleObject accessibleObject = new(listView);
-
-        int accessibilityProperty = listView.TestAccessor().Dynamic.s_accessibilityProperty;
-        listView.Properties.SetObject(accessibilityProperty, accessibleObject);
-        listView.AnnounceColumnHeader(new Point(x, y));
-
-        Assert.Equal(1, accessibleObject.RaiseAutomationNotificationCallCount);
-        Assert.Equal(expectedColumnName, accessibleObject.AnnouncedColumn);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    private class SubListViewAccessibleObject : ListView.ListViewAccessibleObject
-    {
-        internal string AnnouncedColumn { get; private set; }
-
-        internal int RaiseAutomationNotificationCallCount { get; private set; }
-
-        internal SubListViewAccessibleObject(ListView listView) : base(listView)
-        {
-        }
-
-        internal override bool InternalRaiseAutomationNotification(AutomationNotificationKind notificationKind, AutomationNotificationProcessing notificationProcessing, string notificationText)
-        {
-            AnnouncedColumn = notificationText;
-            RaiseAutomationNotificationCallCount++;
-            return true;
-        }
-    }
-
-    public static IEnumerable<object[]> ListView_OnSelectedIndexChanged_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool withinGroup in new[] { true, false })
-                    {
-                        yield return new object[] { view, virtualMode, showGroups, withinGroup };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_OnSelectedIndexChanged_TestData))]
-    public void ListView_OnSelectedIndexChanged_DoesNotInvoke_RaiseAutomationEvent_SecondTime(View view, bool virtualMode, bool showGroups, bool withinGroup)
-    {
-        using SubListView listView = GetSubListViewWithData(view, virtualMode, showGroups, withinGroup, createControl: true);
-        ListViewItem listViewItem = listView.Items[0];
-
-        Assert.NotNull(listView.AccessibilityObject);
-        Assert.NotNull(listViewItem.AccessibilityObject);
-
-        SubListViewItemAccessibleObject accessibleObject = new SubListViewItemAccessibleObject(listViewItem);
-        listViewItem.TestAccessor().Dynamic._accessibilityObject = accessibleObject;
-        listView.CreateControl();
-        listViewItem.Focused = true;
-        listViewItem.Selected = true;
-
-        Assert.Equal(2, accessibleObject.RaiseAutomationEventCalls);
-
-        listView.CallSelectedIndexChanged();
-
-        Assert.Equal(2, accessibleObject.RaiseAutomationEventCalls);
-    }
-
-    public static IEnumerable<object[]> ListView_OnGroupCollapsedStateChanged_InvokeRaiseAutomationEvent_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool virtualMode in new[] { true, false })
-            {
-                // View.Tile is not supported by ListView in virtual mode
-                if (view == View.Tile)
-                {
-                    continue;
-                }
-
-                foreach (bool showGroups in new[] { true, false })
-                {
-                    foreach (bool withinGroup in new[] { true, false })
-                    {
-                        foreach (bool createControl in new[] { true, false })
-                        {
-                            foreach (int groupId in new[] { -1, 0, 1 })
-                            {
-                                yield return new object[] { view, virtualMode, showGroups, withinGroup, createControl, groupId };
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_OnGroupCollapsedStateChanged_InvokeRaiseAutomationEvent_TestData))]
-    public void ListView_OnGroupCollapsedStateChanged_InvokeRaiseAutomationEvent_AsExpected(
-        View view,
-        bool virtualMode,
-        bool showGroups,
-        bool withinGroup,
-        bool createControl,
-        int groupId)
-    {
-        using SubListView listView = GetSubListViewWithData(view, virtualMode, showGroups, withinGroup, createControl);
-        SubListViewAccessibleObject accessibleObject = new(listView);
-        int accessibilityProperty = listView.TestAccessor().Dynamic.s_accessibilityProperty;
-        listView.Properties.SetObject(accessibilityProperty, accessibleObject);
-
-        listView.OnGroupCollapsedStateChanged(new ListViewGroupEventArgs(groupId));
-
-        int expectedCount = listView.GroupsEnabled && groupId == 0 ? 1 : 0;
-
-        Assert.Equal(expectedCount, accessibleObject.RaiseAutomationNotificationCallCount);
-        Assert.Equal(createControl, listView.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]  // Click on the item results in item editing.
-    [InlineData(1, false)]  // Click on sub-items does not result in editing.
-    [InlineData(2, false)]
-    public void ListView_OnMouseClick_EditLabel_AsExpected(int subItemIndex, bool isEditControlCreated)
-    {
-        using ListView listView = new()
-        {
-            Size = new Size(300, 200),
-            View = View.Details,
-            LabelEdit = true,
-            FullRowSelect = true
-        };
-
-        listView.Columns.AddRange(
-            new ColumnHeader[]
-            {
-                new() { Text = "Column 1", Width = 100 },
-                new() { Text = "Column 2", Width = 100 },
-                new() { Text = "Column 3", Width = 100 }
-            });
-
-        ListViewItem item = new("Test");
-        item.SubItems.Add("Sub1");
-        item.SubItems.Add("Sub2");
-        listView.Items.Add(item);
-
-        listView.CreateControl();
-
-        PInvoke.SetFocus(listView);
-        listView.Items[0].Selected = true;
-
-        // Add a pixel both to x and y as the left-upper corner is not a part of subitem
-        Point subItemLocation = listView.Items[0].SubItems[subItemIndex].Bounds.Location + new Size(1, 1);
-        // The mouse down handler will wait for mouse up event, so we need to put it on the message queue
-        // before invoking mouse down.
-        PInvoke.PostMessage(listView, PInvoke.WM_LBUTTONUP, 0, PARAM.FromPoint(subItemLocation));
-        PInvoke.SendMessage(listView, PInvoke.WM_LBUTTONDOWN, 1, PARAM.FromPoint(subItemLocation));
-
-        // Start editing immediately (if it was queued).
-        PInvoke.SendMessage(listView, PInvoke.WM_TIMER, (WPARAM)(nint)listView.TestAccessor().Dynamic.LVLABELEDITTIMER);
-
-        nint editControlHandle = PInvoke.SendMessage(listView, PInvoke.LVM_GETEDITCONTROL);
-
-        // End the edit because this more closely resembles real live usage. Additionally
-        // when edit box is open, the native ListView will move focus to items being removed.
-        PInvoke.SendMessage(listView, PInvoke.LVM_CANCELEDITLABEL);
-
-        if (isEditControlCreated)
-        {
-            Assert.NotEqual(0, editControlHandle);
-        }
-        else
-        {
-            Assert.Equal(0, editControlHandle);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Right)]
-    [InlineData(Keys.Left)]
-    public void ListView_LeftRightArrow_DoesNotThrowException(Keys key)
-    {
-        using ListView listView = new() { ShowGroups = true };
-        listView.Items.Add(new ListViewItem("Group Item 0"));
-        listView.CreateControl();
-        listView.Items[0].Selected = true;
-        listView.Items[0].Focused = true;
-
-        // https://docs.microsoft.com/windows/win32/inputdev/wm-keyup
-        // The MSDN page tells us what bits of lParam to use for each of the parameters.
-        // All we need to do is some bit shifting to assemble lParam
-        // lParam = repeatCount | (scanCode << 16)
-        nint keyCode = (nint)key;
-        nint lParam = 0x00000001 | keyCode << 16;
-        PInvoke.SendMessage(listView, PInvoke.WM_KEYUP, (WPARAM)keyCode, (LPARAM)lParam);
-
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ListView_View_ShowGroup_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            foreach (bool showGroups in new[] { true, false })
-            {
-                yield return new object[] { view, showGroups };
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> ListView_View_ShowGroup_Checked_TestData()
-    {
-        foreach (View view in Enum.GetValues(typeof(View)))
-        {
-            // CheckBoxes are not supported in Tile view.
-            if (view == View.Tile)
-            {
-                continue;
-            }
-
-            foreach (bool showGroups in new[] { true, false })
-            {
-                yield return new object[] { view, showGroups };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_TestData))]
-    public void ListView_Remove_NotSelectedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups };
-        listView.CreateControl();
-        listView.Items.AddRange(new ListViewItem[] { new("test 1"), new("test 2"), new("test 3") });
-
-        listView.Items[0].Selected = true;
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-
-        listView.Items.Remove(listView.Items[1]);
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(2, listView.Items.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-        Assert.True(listView.Items[0].Selected);
-
-        listView.Items.Remove(listView.Items[1]);
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(1, listView.Items.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-        Assert.True(listView.Items[0].Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_TestData))]
-    public void ListView_Remove_SelectedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups };
-        listView.CreateControl();
-        listView.Items.AddRange(new ListViewItem[] { new("test 1"), new("test 2"), new("test 3") });
-
-        for (int count = listView.Items.Count; count > 1; count -= 1)
-        {
-            ListViewItem item = listView.Items[0];
-            item.Selected = true;
-
-            Assert.True(item.Selected);
-            Assert.Equal(count, listView.Items.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(1, listView.SelectedItems.Count);
-            Assert.Equal(1, listView.SelectedIndices.Count);
-
-            listView.Items.Remove(item);
-            count -= 1;
-
-            Assert.True(item.Selected);
-            Assert.Equal(count, listView.Items.Count);
-            Assert.Null(item.ListView);
-            Assert.Equal(0, listView.SelectedItems.Count);
-            Assert.Equal(0, listView.SelectedIndices.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_Checked_TestData))]
-    public void ListView_Remove_NotCheckedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups, CheckBoxes = true };
-        listView.CreateControl();
-        listView.Items.AddRange(new ListViewItem[] { new("test 1"), new("test 2"), new("test 3") });
-
-        listView.Items[0].Checked = true;
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-
-        listView.Items.Remove(listView.Items[1]);
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(2, listView.Items.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-
-        listView.Items.Remove(listView.Items[1]);
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(1, listView.Items.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_Checked_TestData))]
-    public void ListView_Remove_CheckedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups, CheckBoxes = true };
-        listView.CreateControl();
-        listView.Items.AddRange(new ListViewItem[] { new("test 1"), new("test 2"), new("test 3") });
-
-        for (int count = listView.Items.Count; count > 1; count -= 1)
-        {
-            ListViewItem item = listView.Items[0];
-            item.Checked = true;
-
-            Assert.True(item.Checked);
-            Assert.Equal(count, listView.Items.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(1, listView.CheckedItems.Count);
-            Assert.Equal(1, listView.CheckedIndices.Count);
-
-            listView.Items.Remove(item);
-            count -= 1;
-
-            Assert.True(item.Checked);
-            Assert.Equal(count, listView.Items.Count);
-            Assert.Null(item.ListView);
-            Assert.Equal(0, listView.CheckedItems.Count);
-            Assert.Equal(0, listView.CheckedIndices.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_TestData))]
-    public void ListView_Remove_Group_WithNotSelectedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups };
-        listView.CreateControl();
-
-        var groups = new ListViewGroup[] { new("Group 1"), new("Group 2"), new("Group 3") };
-        listView.Groups.AddRange(groups);
-        listView.Items.AddRange(new ListViewItem[] { new("test 1", groups[0]), new("test 2", groups[1]), new("test 3", groups[2]) });
-
-        listView.Items[0].Selected = true;
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(3, listView.Groups.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-
-        listView.Groups.Remove(listView.Groups[2]);
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(2, listView.Groups.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-        Assert.True(listView.Items[0].Selected);
-
-        listView.Groups.Remove(listView.Groups[1]);
-
-        Assert.True(listView.Items[0].Selected);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(1, listView.Groups.Count);
-        Assert.Equal(1, listView.SelectedItems.Count);
-        Assert.Equal(1, listView.SelectedIndices.Count);
-        Assert.True(listView.Items[0].Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_TestData))]
-    public void ListView_Remove_Group_WithSelectedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups };
-        listView.CreateControl();
-
-        var groups = new ListViewGroup[] { new("Group 1"), new("Group 2"), new("Group 3") };
-        listView.Groups.AddRange(groups);
-        listView.Items.AddRange(new ListViewItem[] { new("test 1", groups[0]), new("test 2", groups[1]), new("test 3", groups[2]) });
-
-        int count = 3;
-        for (int i = 0; i < 2; i++)
-        {
-            ListViewItem item = listView.Items[i];
-            item.Selected = true;
-            int selectedCount = i + 1;
-
-            Assert.True(item.Selected);
-            Assert.Equal(3, listView.Items.Count);
-            Assert.Equal(count, listView.Groups.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(selectedCount, listView.SelectedItems.Count);
-            Assert.Equal(selectedCount, listView.SelectedIndices.Count);
-
-            listView.Groups.Remove(listView.Groups[0]);
-            count -= 1;
-
-            Assert.True(item.Selected);
-            Assert.Equal(3, listView.Items.Count);
-            Assert.Equal(count, listView.Groups.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(selectedCount, listView.SelectedItems.Count);
-            Assert.Equal(selectedCount, listView.SelectedIndices.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_Checked_TestData))]
-    public void ListView_Remove_Group_WithNotCheckedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups, CheckBoxes = true };
-        listView.CreateControl();
-
-        var groups = new ListViewGroup[] { new("Group 1"), new("Group 2"), new("Group 3") };
-        listView.Groups.AddRange(groups);
-        listView.Items.AddRange(new ListViewItem[] { new("test 1", groups[0]), new("test 2", groups[1]), new("test 3", groups[2]) });
-
-        listView.Items[0].Checked = true;
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-
-        listView.Groups.Remove(listView.Groups[2]);
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(2, listView.Groups.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-
-        listView.Groups.Remove(listView.Groups[1]);
-
-        Assert.True(listView.Items[0].Checked);
-        Assert.Equal(3, listView.Items.Count);
-        Assert.Equal(1, listView.Groups.Count);
-        Assert.Equal(1, listView.CheckedItems.Count);
-        Assert.Equal(1, listView.CheckedIndices.Count);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ListView_View_ShowGroup_Checked_TestData))]
-    public void ListView_Remove_Group_WithCheckedItems(View view, bool showGroups)
-    {
-        using ListView listView = new ListView() { View = view, ShowGroups = showGroups, CheckBoxes = true };
-        listView.CreateControl();
-
-        var groups = new ListViewGroup[] { new("Group 1"), new("Group 2"), new("Group 3") };
-        listView.Groups.AddRange(groups);
-        listView.Items.AddRange(new ListViewItem[] { new("test 1", groups[0]), new("test 2", groups[1]), new("test 3", groups[2]) });
-
-        int count = 3;
-        for (int i = 0; i < 2; i++)
-        {
-            ListViewItem item = listView.Items[i];
-            item.Checked = true;
-            int selectedCount = i + 1;
-
-            Assert.True(item.Checked);
-            Assert.Equal(3, listView.Items.Count);
-            Assert.Equal(count, listView.Groups.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(selectedCount, listView.CheckedItems.Count);
-            Assert.Equal(selectedCount, listView.CheckedIndices.Count);
-
-            listView.Groups.Remove(listView.Groups[0]);
-            count -= 1;
-
-            Assert.True(item.Checked);
-            Assert.Equal(3, listView.Items.Count);
-            Assert.Equal(count, listView.Groups.Count);
-            Assert.Equal(listView, item.ListView);
-            Assert.Equal(selectedCount, listView.CheckedItems.Count);
-            Assert.Equal(selectedCount, listView.CheckedIndices.Count);
-        }
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_Reset_Remove()
-    {
-        using ListView listView = new();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test 1"));
-        listView.Items.Add(new ListViewItem("Test 2"));
-        listView.Items[0].Focused = true;
-
-        Assert.NotNull(listView.FocusedItem);
-
-        listView.Items.Remove(listView.Items[0]);
-
-        Assert.Null(listView.FocusedItem);
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_Reset_RemoveAt()
-    {
-        using ListView listView = new();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test 1"));
-        listView.Items.Add(new ListViewItem("Test 2"));
-        listView.Items[0].Focused = true;
-
-        Assert.NotNull(listView.FocusedItem);
-
-        listView.Items.RemoveAt(0);
-
-        Assert.Null(listView.FocusedItem);
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_Reset_RemoveByKey()
-    {
-        using ListView listView = new();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test 1") { Name = "Test 1" });
-        listView.Items.Add(new ListViewItem("Test 2"));
-        listView.Items[0].Focused = true;
-
-        Assert.NotNull(listView.FocusedItem);
-
-        listView.Items.RemoveByKey("Test 1");
-
-        Assert.Null(listView.FocusedItem);
-    }
-
-    [WinFormsFact]
-    public void ListView_FocusedItem_Reset_Clear()
-    {
-        using ListView listView = new();
-        listView.CreateControl();
-        listView.Items.Add(new ListViewItem("Test 1"));
-        listView.Items.Add(new ListViewItem("Test 2"));
-        listView.Items[0].Focused = true;
-
-        Assert.NotNull(listView.FocusedItem);
-
-        listView.Items.Clear();
-
-        Assert.Null(listView.FocusedItem);
-    }
-
-    [WinFormsFact]
-    public void ListView_ReleaseUiaProvider_DoesNotForceDefaultGroupCreation()
-    {
-        using ListView listView = new();
-        _ = listView.AccessibilityObject;
-
-        listView.ReleaseUiaProvider(listView.HWND);
-
-        Assert.Null(listView.TestAccessor().Dynamic._defaultGroup);
-        Assert.True(listView.IsHandleCreated);
-    }
-
-    private class SubListViewItem : ListViewItem
-    {
-        public AccessibleObject CustomAccessibleObject { get; set; }
-
-        public SubListViewItem(string text) : base(text)
-        {
-        }
-
-        internal override AccessibleObject AccessibilityObject => CustomAccessibleObject;
-    }
-
-    private class SubListViewItemAccessibleObject : ListViewItemBaseAccessibleObject
-    {
-        protected override View View => View.List;
-
-        public int RaiseAutomationEventCalls;
-
-        public SubListViewItemAccessibleObject(ListViewItem owningItem) : base(owningItem)
-        {
-        }
-
-        internal override bool RaiseAutomationEvent(UiaCore.UIA eventId)
-        {
-            RaiseAutomationEventCalls++;
-            return base.RaiseAutomationEvent(eventId);
-        }
-    }
-
-    private class SubListView : ListView
-    {
-        internal void CallSelectedIndexChanged() => base.OnSelectedIndexChanged(new EventArgs());
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnGroupCollapsedStateChanged(ListViewGroupEventArgs e) => base.OnGroupCollapsedStateChanged(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    private SubListView GetSubListViewWithData(View view, bool virtualMode, bool showGroups, bool withinGroup, bool createControl)
-    {
-        SubListView listView = new()
-        {
-            View = view,
-            ShowGroups = showGroups,
-            VirtualMode = virtualMode,
-            VirtualListSize = 2
-        };
-
-        ListViewItem listItem1 = new("Test Item 1");
-        ListViewItem listItem2 = new("Test Item 2");
-
-        if (!virtualMode && withinGroup)
-        {
-            ListViewGroup listViewGroup = new("Test");
-            listView.Groups.Add(listViewGroup);
-            listItem2.Group = listViewGroup;
-        }
-
-        listView.Columns.Add(new ColumnHeader() { Name = "Column 1" });
-
-        if (virtualMode)
-        {
-            listView.RetrieveVirtualItem += (s, e) =>
-            {
-                e.Item = e.ItemIndex switch
-                {
-                    0 => listItem1,
-                    1 => listItem2,
-                    _ => throw new NotImplementedException()
-                };
-            };
-
-            listItem1.SetItemIndex(listView, 0);
-            listItem2.SetItemIndex(listView, 1);
-        }
-        else
-        {
-            listView.Items.Add(listItem1);
-            listView.Items.Add(listItem2);
-        }
-
-        if (createControl)
-        {
-            listView.CreateControl();
-        }
-
-        return listView;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewVirtualItemsSelectionRangeChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewVirtualItemsSelectionRangeChangedEventArgsTests.cs
deleted file mode 100644
index b109771d8e0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ListViewVirtualItemsSelectionRangeChangedEventArgsTests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ListViewVirtualItemsSelectionRangeChangedEventArgsTests
-{
-    [Theory]
-    [InlineData(-2, -2, true)]
-    [InlineData(-1, -1, false)]
-    [InlineData(0, 0, true)]
-    [InlineData(1, 2, true)]
-    [InlineData(1, 1, false)]
-    public void Ctor_Int_Int_Bool(int startIndex, int endIndex, bool isSelected)
-    {
-        var e = new ListViewVirtualItemsSelectionRangeChangedEventArgs(startIndex, endIndex, isSelected);
-        Assert.Equal(startIndex, e.StartIndex);
-        Assert.Equal(endIndex, e.EndIndex);
-        Assert.Equal(isSelected, e.IsSelected);
-    }
-
-    [Fact]
-    public void Ctor_StartIndexGreaterThanEndIndex_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentException>(() => new ListViewVirtualItemsSelectionRangeChangedEventArgs(1, 0, false));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskInputRejectedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskInputRejectedEventArgsTests.cs
deleted file mode 100644
index 7737deea8f0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskInputRejectedEventArgsTests.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class MaskInputRejectedEventArgsTests
-{
-    [Theory]
-    [InlineData(-2, MaskedTextResultHint.Unknown)]
-    [InlineData(-1, MaskedTextResultHint.Success)]
-    [InlineData(0, MaskedTextResultHint.PromptCharNotAllowed)]
-    [InlineData(1, (MaskedTextResultHint)(MaskedTextResultHint.SignedDigitExpected - 1))]
-    [InlineData(1, MaskedTextResultHint.Unknown)]
-    public void Ctor_Int_Int_Bool(int position, MaskedTextResultHint rejectionHint)
-    {
-        var e = new MaskInputRejectedEventArgs(position, rejectionHint);
-        Assert.Equal(position, e.Position);
-        Assert.Equal(rejectionHint, e.RejectionHint);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskedTextBox.MaskedTextBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskedTextBox.MaskedTextBoxAccessibleObjectTests.cs
deleted file mode 100644
index 71daab45d24..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MaskedTextBox.MaskedTextBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,163 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MaskedTextBoxAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void MaskedTextBoxAccessibilityObject_Ctor_Default()
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.CreateControl();
-
-        Assert.NotNull(maskedTextBox.AccessibilityObject);
-        Assert.True(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MaskedTextBoxAccessibilityObject_ControlType_IsEdit_IfAccessibleRoleIsDefault()
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.EditControlTypeId, actual);
-        Assert.True(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MaskedTextBoxAccessibilityObject_Role_IsText_ByDefault()
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = maskedTextBox.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Text, actual);
-        Assert.True(maskedTextBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MaskedTextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaskedTextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void MaskedTextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.AccessibleRole = role;
-
-        object actual = maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("Test", "Test")]
-    public void MaskedTextBoxAccessibleObject_Name_IsExpected_WithoutMask(string accessibleName, string expectedAccessibleName)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.Text = "000000";
-        maskedTextBox.AccessibleName = accessibleName;
-
-        var actual = (string)maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal(expectedAccessibleName, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("Test", "Test")]
-    public void MaskedTextBoxAccessibleObject_Name_IsExpected_WithMask(string accessibleName, string expectedAccessibleName)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.Text = "000000";
-        maskedTextBox.Mask = "00/00/0000";
-        maskedTextBox.AccessibleName = accessibleName;
-
-        var actual = (string)maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal(expectedAccessibleName, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MaskedTextBoxAccessibleObject_GetPropertyValue_Value_IsExpected_WithMask(bool useMask)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.Text = "000000";
-        maskedTextBox.Mask = useMask ? "00/00/0000" : null;
-
-        var actual = (string)maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId);
-
-        Assert.Equal(maskedTextBox.WindowText, actual);
-        Assert.Equal(useMask, maskedTextBox.Mask?.Length == actual.Length);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MaskedTextBoxAccessibleObject_GetPropertyValue_Value_AccessDenied_WithUseSystemPasswordChar()
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.UseSystemPasswordChar = true;
-        maskedTextBox.Text = "some text";
-
-        object actual = maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId);
-
-        Assert.Equal(SR.AccessDenied, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MaskedTextBoxAccessibleObject_IsPassword_IsExpected_WithUseSystemPasswordChar(bool useSystemPasswordChar)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.UseSystemPasswordChar = useSystemPasswordChar;
-
-        object actual = maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsPasswordPropertyId);
-
-        Assert.Equal(useSystemPasswordChar, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('\0')]
-    [InlineData('*')]
-    public void MaskedTextBoxAccessibleObject_IsPassword_IsExpected_WithPasswordChar(char passwordChar)
-    {
-        using MaskedTextBox maskedTextBox = new MaskedTextBox();
-        maskedTextBox.PasswordChar = passwordChar;
-
-        object actual = maskedTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsPasswordPropertyId);
-        bool expected = passwordChar != '\0';
-
-        Assert.Equal(expected, actual);
-        Assert.False(maskedTextBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiClientTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiClientTests.cs
deleted file mode 100644
index 18b01daf530..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiClientTests.cs
+++ /dev/null
@@ -1,1223 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class MdiClientTests
-{
-    [WinFormsFact]
-    public void MdiClient_Ctor_Default()
-    {
-        using var control = new MdiClient();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.AppWorkspace, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Same(control, Assert.IsType<MdiClient.ControlCollection>(control.Controls).Owner);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.Fill, control.Dock);
-        Assert.True(control.Enabled);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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.Empty(control.MdiChildren);
-        Assert.Same(control.MdiChildren, control.MdiChildren);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void MdiClient_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new MdiClient
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MdiClient_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new MdiClient();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void MdiClient_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(MdiClient.BackColor)];
-        using var control = new MdiClient();
-        Assert.False(property.CanResetValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void MdiClient_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(MdiClient.BackColor)];
-        using var control = new MdiClient();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void MdiClient_BackgroundImage_GetWithParent_GetReturnsExpected(Image parentBackgroundImage)
-    {
-        using var image = new Bitmap(10, 10);
-        using var parent = new Control
-        {
-            BackgroundImage = parentBackgroundImage
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent
-        };
-        Assert.Same(parentBackgroundImage, control.BackgroundImage);
-
-        // Set custom.
-        control.BackgroundImage = image;
-        Assert.Same(image, control.BackgroundImage);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void MdiClient_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new MdiClient
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MdiClient_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new MdiClient();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void MdiClient_BackgroundImageLayout_GetWithParent_GetReturnsExpected(ImageLayout parentBackgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using var parent = new Control
-        {
-            BackgroundImageLayout = parentBackgroundImageLayout
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent
-        };
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-
-        // Set custom.
-        control.BackgroundImage = image;
-        Assert.Equal(parentBackgroundImageLayout, control.BackgroundImageLayout);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void MdiClient_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new MdiClient
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MdiClient_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new MdiClient();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RightToLeft>]
-    public void MdiClient_Handle_Get_Success(RightToLeft rightToLeft)
-    {
-        using var control = new MdiClient
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.Enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true)]
-    [InlineData(RightToLeft.No, true)]
-    [InlineData(RightToLeft.Yes, true)]
-    public void MdiClient_Handle_GetDesignMode_Success(RightToLeft rightToleft, bool designMode)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        using var control = new MdiClient
-        {
-            Site = mockSite.Object,
-            RightToLeft = rightToleft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.Enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Inherit)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Yes)]
-    [InlineData(RightToLeft.No, RightToLeft.Inherit)]
-    [InlineData(RightToLeft.No, RightToLeft.No)]
-    [InlineData(RightToLeft.No, RightToLeft.Yes)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Inherit)]
-    [InlineData(RightToLeft.Yes, RightToLeft.No)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes)]
-    public void MdiClient_Handle_GetWithParent_Success(RightToLeft parentRightToLeft, RightToLeft rightToLeft)
-    {
-        using var parent = new Control
-        {
-            RightToLeft = parentRightToLeft
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent,
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.Enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Inherit, true)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Inherit, false)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, true)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, false)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Yes, true)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Yes, false)]
-    [InlineData(RightToLeft.No, RightToLeft.Inherit, true)]
-    [InlineData(RightToLeft.No, RightToLeft.Inherit, false)]
-    [InlineData(RightToLeft.No, RightToLeft.No, true)]
-    [InlineData(RightToLeft.No, RightToLeft.No, false)]
-    [InlineData(RightToLeft.No, RightToLeft.Yes, true)]
-    [InlineData(RightToLeft.No, RightToLeft.Yes, false)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Inherit, true)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Inherit, false)]
-    [InlineData(RightToLeft.Yes, RightToLeft.No, true)]
-    [InlineData(RightToLeft.Yes, RightToLeft.No, false)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, true)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, false)]
-    public void MdiClient_Handle_GetParentDesignMode_SetsDisabled(RightToLeft parentRightToLeft, RightToLeft rightToLeft, bool designMode)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        using var parent = new Control
-        {
-            Site = mockSite.Object,
-            RightToLeft = parentRightToLeft
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent,
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(!designMode, control.Enabled);
-    }
-
-    [WinFormsFact]
-    public void MdiClient_Location_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(MdiClient.Location)];
-        using var control = new MdiClient();
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.True(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void MdiClient_Location_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(MdiClient.Location)];
-        using var control = new MdiClient();
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(-3, -4), -7, -8, 1 };
-        yield return new object[] { new Size(0, 0), 0, 0, 0 };
-        yield return new object[] { new Size(1, 0), -3, -4, 1 };
-        yield return new object[] { new Size(0, 2), -4, -2, 1 };
-        yield return new object[] { new Size(30, 40), 26, 36, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void MdiClient_Size_Set_GetReturnsExpected(Size value, int expectedWidth, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new MdiClient();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Size_SetWithHandle_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { new Size(-3, -4), 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { new Size(1, 0), 1, 0, 1, 0, 1, 0 };
-        yield return new object[] { new Size(0, 2), 0, 2, 0, 2, 1, 0 };
-        yield return new object[] { new Size(1, 2), 1, 2, 1, 2, 1, 0 };
-        yield return new object[] { new Size(30, 40), 30, 40, 26, 36, 1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithHandle_TestData))]
-    public void MdiClient_Size_SetWithHandle_GetReturnsExpected(Size value, int expectedWidth, int expectedHeight, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new MdiClient();
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Size = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(expectedWidth, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Size_SetWithParentHandle_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0, 0 };
-        yield return new object[] { new Size(-3, -4), 0, 0, 1 };
-        yield return new object[] { new Size(1, 0), 2, 0, 2 };
-        yield return new object[] { new Size(0, 2), 2, 0, 2 };
-        yield return new object[] { new Size(1, 2), 2, 0, 2 };
-        yield return new object[] { new Size(30, 40), 2, 0, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParentHandle_TestData))]
-    public void MdiClient_Size_SetWithParentWithHandle_GetReturnsExpected(Size value, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new MdiClient
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Size = value;
-            Assert.Equal(Size.Empty, control.ClientSize);
-            Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-            Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-            Assert.Equal(Size.Empty, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(Rectangle.Empty, control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Size = value;
-            Assert.Equal(Size.Empty, control.ClientSize);
-            Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-            Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-            Assert.Equal(Size.Empty, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(Rectangle.Empty, control.Bounds);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParentHandle_TestData))]
-    public void MdiClient_Size_SetWithNonDesignModeParentWithHandle_GetReturnsExpected(Size value, int expectedLayoutCallCount, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        using var parent = new Control
-        {
-            Site = mockSite.Object
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Size = value;
-            Assert.Equal(Size.Empty, control.ClientSize);
-            Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-            Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-            Assert.Equal(Size.Empty, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(Rectangle.Empty, control.Bounds);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Size = value;
-            Assert.Equal(Size.Empty, control.ClientSize);
-            Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-            Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-            Assert.Equal(Size.Empty, control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(0, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(0, control.Bottom);
-            Assert.Equal(0, control.Width);
-            Assert.Equal(0, control.Height);
-            Assert.Equal(Rectangle.Empty, control.Bounds);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount * 2, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Size_SetWithDesignModeParentHandle_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { new Size(-3, -4), 0, 0, 0, 0, 0, 0, 0, 1, 2 };
-        yield return new object[] { new Size(1, 0), 0, 0, 0, 0, 2, 4, 0, 2, 4 };
-        yield return new object[] { new Size(0, 2), 0, 0, 0, 0, 2, 4, 0, 2, 4 };
-        yield return new object[] { new Size(1, 2), 0, 0, 0, 0, 2, 4, 0, 2, 4 };
-        yield return new object[] { new Size(30, 40), 0, 0, 0, 0, 2, 4, 0, 2, 4 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithDesignModeParentHandle_TestData))]
-    public void MdiClient_Size_SetWithDesignModeParentWithHandle_GetReturnsExpected(Size value, int expectedWidth, int expectedHeight, int expectedClientWidth, int expectedClientHeight, int expectedLayoutCallCount1, int expectedLayoutCallCount2, int expectedInvalidatedCallCount, int expectedParentLayoutCallCount1, int expectedParentLayoutCallCount2)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        using var parent = new Control
-        {
-            Site = mockSite.Object
-        };
-        using var control = new MdiClient
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.Size = value;
-            Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount1, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount1, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount1, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount1, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Size = value;
-            Assert.Equal(new Size(expectedClientWidth, expectedClientHeight), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expectedClientWidth, expectedClientHeight), control.DisplayRectangle);
-            Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-            Assert.Equal(0, control.Left);
-            Assert.Equal(expectedWidth, control.Right);
-            Assert.Equal(0, control.Top);
-            Assert.Equal(expectedHeight, control.Bottom);
-            Assert.Equal(expectedWidth, control.Width);
-            Assert.Equal(expectedHeight, control.Height);
-            Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.Bounds);
-            Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount2, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutCallCount2, resizeCallCount);
-            Assert.Equal(expectedLayoutCallCount2, sizeChangedCallCount);
-            Assert.Equal(expectedLayoutCallCount2, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void MdiClient_Size_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(Control.Size)];
-        using var control = new MdiClient();
-        Assert.False(property.CanResetValue(control));
-
-        control.Size = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.Size);
-        Assert.False(property.CanResetValue(control));
-
-        control.Size = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.Size);
-        Assert.False(property.CanResetValue(control));
-
-        control.Size = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.Size);
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void MdiClient_Size_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MdiClient))[nameof(Control.Size)];
-        using var control = new MdiClient();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.Size);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.Size);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Size = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.Size);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [EnumData<MdiLayout>]
-    [InvalidEnumData<MdiLayout>]
-    public void MdiClient_LayoutMdi_InvokeWithoutHandle_Nop(MdiLayout value)
-    {
-        using var control = new MdiClient();
-        control.LayoutMdi(value);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<MdiLayout>]
-    [InvalidEnumData<MdiLayout>]
-    public void MdiClient_LayoutMdi_InvokeWithHandle_Success(MdiLayout value)
-    {
-        using var control = new MdiClient();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LayoutMdi(value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiControlStripTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiControlStripTests.cs
deleted file mode 100644
index 22766723aa0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MdiControlStripTests.cs
+++ /dev/null
@@ -1,454 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class MdiControlStripTests
-{
-    [WinFormsFact]
-    public void MdiControlStrip_Ctor_Default()
-    {
-        using Form form = new();
-        using var mdiControlStrip = new SubMdiControlStrip(form);
-        Assert.Null(mdiControlStrip.AccessibleDefaultActionDescription);
-        Assert.Null(mdiControlStrip.AccessibleDescription);
-        Assert.Null(mdiControlStrip.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, mdiControlStrip.AccessibleRole);
-        Assert.False(mdiControlStrip.AllowDrop);
-        Assert.False(mdiControlStrip.AllowItemReorder);
-        Assert.True(mdiControlStrip.AllowMerge);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, mdiControlStrip.Anchor);
-        Assert.False(mdiControlStrip.AutoScroll);
-        Assert.Equal(Size.Empty, mdiControlStrip.AutoScrollMargin);
-        Assert.Equal(Size.Empty, mdiControlStrip.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, mdiControlStrip.AutoScrollPosition);
-        Assert.True(mdiControlStrip.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, mdiControlStrip.BackColor);
-        Assert.Null(mdiControlStrip.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, mdiControlStrip.BackgroundImageLayout);
-        Assert.Null(mdiControlStrip.BindingContext);
-        Assert.Equal(24, mdiControlStrip.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 24), mdiControlStrip.Bounds);
-        Assert.True(mdiControlStrip.CanEnableIme);
-        Assert.False(mdiControlStrip.CanFocus);
-        Assert.False(mdiControlStrip.CanOverflow);
-        Assert.True(mdiControlStrip.CanRaiseEvents);
-        Assert.False(mdiControlStrip.CanSelect);
-        Assert.False(mdiControlStrip.Capture);
-        Assert.False(mdiControlStrip.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 24), mdiControlStrip.ClientRectangle);
-        Assert.Equal(new Size(200, 24), mdiControlStrip.ClientSize);
-        Assert.Null(mdiControlStrip.Container);
-        Assert.False(mdiControlStrip.ContainsFocus);
-        Assert.Null(mdiControlStrip.ContextMenuStrip);
-        Assert.Empty(mdiControlStrip.Controls);
-        Assert.Same(mdiControlStrip.Controls, mdiControlStrip.Controls);
-        Assert.False(mdiControlStrip.Created);
-        Assert.Same(Cursors.Default, mdiControlStrip.Cursor);
-        Assert.Same(Cursors.Default, mdiControlStrip.DefaultCursor);
-        Assert.Equal(DockStyle.Top, mdiControlStrip.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.BelowRight, mdiControlStrip.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, mdiControlStrip.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 0, 2), mdiControlStrip.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, mdiControlStrip.DefaultMargin);
-        Assert.Equal(Size.Empty, mdiControlStrip.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, mdiControlStrip.DefaultMinimumSize);
-        Assert.Equal(new Padding(6, 2, 0, 2), mdiControlStrip.DefaultPadding);
-        Assert.Equal(new Size(200, 24), mdiControlStrip.DefaultSize);
-        Assert.False(mdiControlStrip.DefaultShowItemToolTips);
-        Assert.False(mdiControlStrip.DesignMode);
-        Assert.Equal(2, mdiControlStrip.DisplayedItems.Count);
-        Assert.Same(mdiControlStrip.DisplayedItems, mdiControlStrip.DisplayedItems);
-        Assert.Equal(new Rectangle(6, 2, 194, 20), mdiControlStrip.DisplayRectangle);
-        Assert.Equal(DockStyle.Top, mdiControlStrip.Dock);
-        Assert.NotNull(mdiControlStrip.DockPadding);
-        Assert.Same(mdiControlStrip.DockPadding, mdiControlStrip.DockPadding);
-        Assert.Equal(2, mdiControlStrip.DockPadding.Top);
-        Assert.Equal(2, mdiControlStrip.DockPadding.Bottom);
-        Assert.Equal(6, mdiControlStrip.DockPadding.Left);
-        Assert.Equal(0, mdiControlStrip.DockPadding.Right);
-        Assert.True(mdiControlStrip.DoubleBuffered);
-        Assert.True(mdiControlStrip.Enabled);
-        Assert.NotNull(mdiControlStrip.Events);
-        Assert.Same(mdiControlStrip.Events, mdiControlStrip.Events);
-        Assert.False(mdiControlStrip.Focused);
-        Assert.Equal(Control.DefaultFont, mdiControlStrip.Font);
-        Assert.Equal(mdiControlStrip.Font.Height, mdiControlStrip.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, mdiControlStrip.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Hidden, mdiControlStrip.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Vertical, mdiControlStrip.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 0, 2), mdiControlStrip.GripMargin);
-        Assert.Equal(Rectangle.Empty, mdiControlStrip.GripRectangle);
-        Assert.False(mdiControlStrip.HasChildren);
-        Assert.Equal(24, mdiControlStrip.Height);
-        Assert.NotNull(mdiControlStrip.HorizontalScroll);
-        Assert.Same(mdiControlStrip.HorizontalScroll, mdiControlStrip.HorizontalScroll);
-        Assert.False(mdiControlStrip.HScroll);
-        Assert.Null(mdiControlStrip.ImageList);
-        Assert.Equal(new Size(16, 16), mdiControlStrip.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, mdiControlStrip.ImeMode);
-        Assert.Equal(ImeMode.NoControl, mdiControlStrip.ImeModeBase);
-        Assert.False(mdiControlStrip.IsAccessible);
-        Assert.False(mdiControlStrip.IsCurrentlyDragging);
-        Assert.False(mdiControlStrip.IsDropDown);
-        Assert.False(mdiControlStrip.IsMirrored);
-        Assert.Equal(4, mdiControlStrip.Items.Count);
-        Assert.Same(mdiControlStrip.Items, mdiControlStrip.Items);
-        Assert.NotNull(mdiControlStrip.LayoutEngine);
-        Assert.Same(mdiControlStrip.LayoutEngine, mdiControlStrip.LayoutEngine);
-        Assert.Null(mdiControlStrip.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.HorizontalStackWithOverflow, mdiControlStrip.LayoutStyle);
-        Assert.Equal(0, mdiControlStrip.Left);
-        Assert.Equal(Point.Empty, mdiControlStrip.Location);
-        Assert.Equal(Padding.Empty, mdiControlStrip.Margin);
-        Assert.Equal(Size.Empty, mdiControlStrip.MaximumSize);
-        Assert.Equal(new Size(194, 20), mdiControlStrip.MaxItemSize);
-        Assert.Null(mdiControlStrip.MdiWindowListItem);
-        Assert.Equal(Size.Empty, mdiControlStrip.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, mdiControlStrip.Orientation);
-        Assert.NotNull(mdiControlStrip.OverflowButton);
-        Assert.Same(mdiControlStrip.OverflowButton, mdiControlStrip.OverflowButton);
-        Assert.Same(mdiControlStrip, mdiControlStrip.OverflowButton.GetCurrentParent());
-        Assert.Equal(new Padding(6, 2, 0, 2), mdiControlStrip.Padding);
-        Assert.Null(mdiControlStrip.Parent);
-        Assert.True(mdiControlStrip.PreferredSize.Width > 0);
-        Assert.True(mdiControlStrip.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", mdiControlStrip.ProductName);
-        Assert.False(mdiControlStrip.RecreatingHandle);
-        Assert.Null(mdiControlStrip.Region);
-        Assert.NotNull(mdiControlStrip.Renderer);
-        Assert.Same(mdiControlStrip.Renderer, mdiControlStrip.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(mdiControlStrip.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, mdiControlStrip.RenderMode);
-        Assert.False(mdiControlStrip.ResizeRedraw);
-        Assert.Equal(200, mdiControlStrip.Right);
-        Assert.Equal(RightToLeft.No, mdiControlStrip.RightToLeft);
-        Assert.True(mdiControlStrip.ShowFocusCues);
-        Assert.False(mdiControlStrip.ShowItemToolTips);
-        Assert.True(mdiControlStrip.ShowKeyboardCues);
-        Assert.Null(mdiControlStrip.Site);
-        Assert.Equal(new Size(200, 24), mdiControlStrip.Size);
-        Assert.True(mdiControlStrip.Stretch);
-        Assert.Equal(0, mdiControlStrip.TabIndex);
-        Assert.False(mdiControlStrip.TabStop);
-        Assert.Empty(mdiControlStrip.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, mdiControlStrip.TextDirection);
-        Assert.Equal(0, mdiControlStrip.Top);
-        Assert.Null(mdiControlStrip.TopLevelControl);
-        Assert.False(mdiControlStrip.UseWaitCursor);
-        Assert.NotNull(mdiControlStrip.VerticalScroll);
-        Assert.Same(mdiControlStrip.VerticalScroll, mdiControlStrip.VerticalScroll);
-        Assert.True(mdiControlStrip.Visible);
-        Assert.False(mdiControlStrip.VScroll);
-        Assert.Equal(200, mdiControlStrip.Width);
-
-        Assert.False(mdiControlStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MdiControlStrip_Ctor_VerifyMenuItemsInRightOrder()
-    {
-        using Form form = new();
-        using var mdiControlStrip = new SubMdiControlStrip(form);
-
-        Assert.Equal(4, mdiControlStrip.Items.Count);
-
-        ToolStripMenuItem system = mdiControlStrip.TestAccessor().Dynamic._system;
-        ToolStripMenuItem close = mdiControlStrip.TestAccessor().Dynamic._close;
-        ToolStripMenuItem minimize = mdiControlStrip.TestAccessor().Dynamic._minimize;
-        ToolStripMenuItem restore = mdiControlStrip.TestAccessor().Dynamic._restore;
-        Assert.Equal(minimize, mdiControlStrip.Items[0]);
-        Assert.Equal(restore, mdiControlStrip.Items[1]);
-        Assert.Equal(close, mdiControlStrip.Items[2]);
-        Assert.Equal(system, mdiControlStrip.Items[3]);
-    }
-
-    [WinFormsFact]
-    public void MdiControlStrip_Ctor_VerifyMenuItemsHaveImages()
-    {
-        using Form form = new();
-        using var mdiControlStrip = new SubMdiControlStrip(form);
-
-        ToolStripMenuItem[] items = new ToolStripMenuItem[]
-        {
-            mdiControlStrip.TestAccessor().Dynamic._system,
-            mdiControlStrip.TestAccessor().Dynamic._close,
-            mdiControlStrip.TestAccessor().Dynamic._minimize,
-            mdiControlStrip.TestAccessor().Dynamic._restore
-        };
-
-        foreach (ToolStripMenuItem item in items)
-        {
-            Assert.NotNull(item.Image);
-        }
-    }
-
-    [UseDefaultXunitCulture(SetUnmanagedUiThreadCulture = true)]
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void MdiControlStrip_MaximizedChildWindow_NextSibling_ReturnsControlBoxButtonsAsExpected(RightToLeft rightToLeft)
-    {
-        using ToolStripMenuItem toolStripMenuItem1 = new() { Text = "&Test1" };
-        using ToolStripMenuItem toolStripMenuItem2 = new() { Text = "&Test2" };
-        using MenuStrip menuStrip = new() { RightToLeft = rightToLeft };
-        menuStrip.Items.AddRange(new ToolStripItem[] { toolStripMenuItem1, toolStripMenuItem2 });
-        using Form mdiParent = new()
-        {
-            IsMdiContainer = true,
-            MainMenuStrip = menuStrip
-        };
-
-        mdiParent.Controls.Add(menuStrip);
-        using Form mdiChild = new()
-        {
-            MdiParent = mdiParent,
-            WindowState = FormWindowState.Maximized
-        };
-
-        mdiParent.Show();
-        mdiChild.Show();
-        AccessibleObject accessibleObject = mdiParent.MainMenuStrip.AccessibilityObject;
-        ToolStripItem.ToolStripItemAccessibleObject systemItem = (ToolStripItem.ToolStripItemAccessibleObject)accessibleObject.TestAccessor().Dynamic.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        ToolStripItem.ToolStripItemAccessibleObject test1Item = (ToolStripItem.ToolStripItemAccessibleObject)systemItem.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        ToolStripItem.ToolStripItemAccessibleObject test2Item = (ToolStripItem.ToolStripItemAccessibleObject)test1Item.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        ToolStripItem.ToolStripItemAccessibleObject minimizeItem = (ToolStripItem.ToolStripItemAccessibleObject)test2Item.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        ToolStripItem.ToolStripItemAccessibleObject restoreItem = (ToolStripItem.ToolStripItemAccessibleObject)minimizeItem.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        ToolStripItem.ToolStripItemAccessibleObject closeItem = (ToolStripItem.ToolStripItemAccessibleObject)restoreItem.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        ToolStripItem.ToolStripItemAccessibleObject nullItem = (ToolStripItem.ToolStripItemAccessibleObject)closeItem.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        Assert.Equal("System", systemItem.Name);
-        Assert.Equal("Test1", test1Item.Name);
-        Assert.Equal("Test2", test2Item.Name);
-        Assert.Equal("Minimize", minimizeItem.Name);
-        Assert.Equal("Restore", restoreItem.Name);
-        Assert.Equal("Close", closeItem.Name);
-        Assert.Null(nullItem);
-        Assert.True(mdiChild.IsHandleCreated);
-        Assert.True(mdiParent.IsHandleCreated);
-        Assert.True(menuStrip.IsHandleCreated);
-    }
-
-    [UseDefaultXunitCulture(SetUnmanagedUiThreadCulture = true)]
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void MdiControlStrip_MaximizedChildWindow_PreviousSibling_ReturnsControlBoxButtonsAsExpected(RightToLeft rightToLeft)
-    {
-        using ToolStripMenuItem toolStripMenuItem1 = new() { Text = "&Test1" };
-        using ToolStripMenuItem toolStripMenuItem2 = new() { Text = "&Test2" };
-        using MenuStrip menuStrip = new() { RightToLeft = rightToLeft };
-        menuStrip.Items.AddRange(new ToolStripItem[] { toolStripMenuItem1, toolStripMenuItem2 });
-        using Form mdiParent = new()
-        {
-            IsMdiContainer = true,
-            MainMenuStrip = menuStrip
-        };
-
-        mdiParent.Controls.Add(menuStrip);
-        using Form mdiChild = new()
-        {
-            MdiParent = mdiParent,
-            WindowState = FormWindowState.Maximized
-        };
-
-        mdiParent.Show();
-        mdiChild.Show();
-        AccessibleObject accessibleObject = mdiParent.MainMenuStrip.AccessibilityObject;
-        ToolStripItem.ToolStripItemAccessibleObject closeItem = (ToolStripItem.ToolStripItemAccessibleObject)accessibleObject.TestAccessor().Dynamic.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-        ToolStripItem.ToolStripItemAccessibleObject restoreItem = (ToolStripItem.ToolStripItemAccessibleObject)closeItem.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        ToolStripItem.ToolStripItemAccessibleObject minimizeItem = (ToolStripItem.ToolStripItemAccessibleObject)restoreItem.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        ToolStripItem.ToolStripItemAccessibleObject test2Item = (ToolStripItem.ToolStripItemAccessibleObject)minimizeItem.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        ToolStripItem.ToolStripItemAccessibleObject test1Item = (ToolStripItem.ToolStripItemAccessibleObject)test2Item.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        ToolStripItem.ToolStripItemAccessibleObject systemItem = (ToolStripItem.ToolStripItemAccessibleObject)test1Item.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-        ToolStripItem.ToolStripItemAccessibleObject nullItem = (ToolStripItem.ToolStripItemAccessibleObject)systemItem.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.Equal("Close", closeItem.Name);
-        Assert.Equal("Restore", restoreItem.Name);
-        Assert.Equal("Minimize", minimizeItem.Name);
-        Assert.Equal("Test2", test2Item.Name);
-        Assert.Equal("Test1", test1Item.Name);
-        Assert.Equal("System", systemItem.Name);
-        Assert.Null(nullItem);
-        Assert.True(mdiChild.IsHandleCreated);
-        Assert.True(mdiParent.IsHandleCreated);
-        Assert.True(menuStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public void MdiControlStrip_MaximizedChildWindow_ControlbBoxButtons_AreNotCloned(RightToLeft rightToLeft)
-    {
-        using ToolStripMenuItem toolStripMenuItem1 = new() { Text = "&Test1" };
-        using ToolStripMenuItem toolStripMenuItem2 = new() { Text = "&Test2" };
-        using MenuStrip menuStrip = new() { RightToLeft = rightToLeft };
-        menuStrip.Items.AddRange(new ToolStripItem[] { toolStripMenuItem1, toolStripMenuItem2 });
-        using Form mdiParent = new() { IsMdiContainer = true };
-        using Form mdiChild = new()
-        {
-            MdiParent = mdiParent,
-            WindowState = FormWindowState.Maximized
-        };
-
-        mdiParent.Show();
-        mdiChild.Show();
-        mdiParent.MainMenuStrip = menuStrip;
-        mdiParent.MainMenuStrip = null;
-        mdiParent.MainMenuStrip = menuStrip;
-        mdiParent.MainMenuStrip = null;
-        IntPtr menuHandle = PInvoke.GetMenu((HWND)mdiParent.Handle);
-        int menuItemCount = PInvoke.GetMenuItemCount((HMENU)menuHandle);
-        // Four buttons: System, Minimize, Maximize, Close
-        Assert.True(menuItemCount == 4);
-    }
-
-    [WinFormsFact]
-    public void MdiControlStrip_MaximizedChildWindow_RecreatesOnSizeChanged()
-    {
-        using var mdiParent = new Form() { IsMdiContainer = true, Text = "Parent" };
-        using var mdiChild = new Form() { MdiParent = mdiParent, Text = "Child" };
-        using var menuStrip = new MenuStrip();
-
-        mdiParent.Controls.Add(menuStrip);
-        mdiParent.MainMenuStrip = menuStrip;
-
-        mdiParent.Show();
-        mdiChild.Show();
-        mdiChild.WindowState = FormWindowState.Maximized;
-
-        MdiControlStrip originalMdiControlStrip = mdiParent.TestAccessor().Dynamic.MdiControlStrip;
-
-        // Force size change with large icon
-        HICON hicon = (HICON)new Bitmap(256, 256).GetHicon();
-        Icon largeIcon = (Icon)Icon.FromHandle(hicon).Clone();
-        PInvoke.DestroyIcon(hicon);
-        mdiChild.Icon = largeIcon;
-
-        MdiControlStrip currentMdiControlStrip = mdiParent.TestAccessor().Dynamic.MdiControlStrip;
-        Assert.NotEqual(originalMdiControlStrip, currentMdiControlStrip);
-    }
-
-    private class SubMdiControlStrip : MdiControlStrip
-    {
-        public new const int ScrollStateAutoScrolling = MenuStrip.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = MenuStrip.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = MenuStrip.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = MenuStrip.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = MenuStrip.ScrollStateFullDrag;
-
-        public SubMdiControlStrip(IWin32Window target) : base(target)
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new DockStyle DefaultDock => base.DefaultDock;
-
-        public new Padding DefaultGripMargin => base.DefaultGripMargin;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DefaultShowItemToolTips => base.DefaultShowItemToolTips;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new Size MaxItemSize => base.MaxItemSize;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ToolStripItem CreateDefaultItem(string text, Image image, EventHandler onClick) => base.CreateDefaultItem(text, image, onClick);
-
-        public new LayoutSettings CreateLayoutSettings(ToolStripLayoutStyle layoutStyle) => base.CreateLayoutSettings(layoutStyle);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnMenuActivate(EventArgs e) => base.OnMenuActivate(e);
-
-        public new void OnMenuDeactivate(EventArgs e) => base.OnMenuDeactivate(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MeasureItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MeasureItemEventArgsTests.cs
deleted file mode 100644
index 36966b451b7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MeasureItemEventArgsTests.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class MeasureItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Graphics_Int_Int_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, -1, -1 };
-        yield return new object[] { graphics, 0, 0 };
-        yield return new object[] { graphics, 1, 2 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_Int_Int_TestData))]
-    public void Ctor_Graphics_Int_Int(Graphics graphics, int index, int itemHeight)
-    {
-        var e = new MeasureItemEventArgs(graphics, index, itemHeight);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(index, e.Index);
-        Assert.Equal(itemHeight, e.ItemHeight);
-        Assert.Equal(0, e.ItemWidth);
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_Int_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, -1 };
-        yield return new object[] { graphics, 0 };
-        yield return new object[] { graphics, 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Graphics_Int_TestData))]
-    public void Ctor_Graphics_Int(Graphics graphics, int index)
-    {
-        var e = new MeasureItemEventArgs(graphics, index);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(index, e.Index);
-        Assert.Equal(0, e.ItemHeight);
-        Assert.Equal(0, e.ItemWidth);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ItemHeight_Set_GetReturnsExpected(int value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new MeasureItemEventArgs(graphics, 1)
-            {
-                ItemHeight = value
-            };
-            Assert.Equal(value, e.ItemHeight);
-        }
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ItemWidth_Set_GetReturnsExpected(int value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new MeasureItemEventArgs(graphics, 1)
-            {
-                ItemWidth = value
-            };
-            Assert.Equal(value, e.ItemWidth);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStrip.MenuStripAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStrip.MenuStripAccessibleObjectTests.cs
deleted file mode 100644
index 52213e1d1a8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStrip.MenuStripAccessibleObjectTests.cs
+++ /dev/null
@@ -1,959 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-using static Interop.UiaCore;
-using static System.Windows.Forms.Tests.ToolStripAccessibleObjectTests;
-
-namespace System.Windows.Forms.Tests;
-
-public class MenuStrip_MenuStripAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected()
-    {
-        using var menuStrip = new MenuStrip()
-        {
-            Name = "Name1",
-            AccessibleName = "Test Name"
-        };
-
-        AccessibleObject menuStripAccessibleObject = menuStrip.AccessibilityObject;
-        var accessibleName = menuStripAccessibleObject.GetPropertyValue(UIA.NamePropertyId);
-
-        Assert.Equal("Test Name", accessibleName);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_GetPropertyValue_IsControlElement_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = new();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsControlElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_GetPropertyValue_IsContentElement_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = new();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.IsContentElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var menuStrip = new MenuStrip();
-        AccessibleObject menuStripAccessibleObject = menuStrip.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = menuStripAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_LegacyIAccessible_Custom_Role_ReturnsExpected()
-    {
-        using var menuStrip = new MenuStrip()
-        {
-            AccessibleRole = AccessibleRole.Link
-        };
-
-        AccessibleObject menuStripAccessibleObject = menuStrip.AccessibilityObject;
-        var accessibleObjectRole = menuStripAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_LegacyIAccessible_Custom_Description_ReturnsExpected()
-    {
-        using var menuStrip = new MenuStrip()
-        {
-            AccessibleDescription = "Test Description"
-        };
-
-        AccessibleObject menuStripAccessibleObject = menuStrip.AccessibilityObject;
-        var accessibleObjectDescription = menuStripAccessibleObject.Description;
-
-        Assert.Equal("Test Description", accessibleObjectDescription);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_ControlType_IsMenuBar_IfAccessibleRoleIsDefault()
-    {
-        using MenuStrip menuStrip = new MenuStrip();
-        // AccessibleRole is not set = Default
-
-        object actual = menuStrip.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-
-        Assert.Equal(UIA.MenuBarControlTypeId, actual);
-        Assert.False(menuStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_Role_IsMenuBar_ByDefault()
-    {
-        using MenuStrip menuStrip = new MenuStrip();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = menuStrip.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuBar, actual);
-        Assert.False(menuStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void MenuStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using MenuStrip menuStrip = new MenuStrip();
-        menuStrip.AccessibleRole = role;
-
-        object actual = menuStrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(menuStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData()
-    {
-        Array directions = Enum.GetValues<NavigateDirection>();
-
-        foreach (NavigateDirection direction in directions)
-        {
-            yield return new object[] { direction };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated(int navigateDirection)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(itemCount: 1, createControl: false);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate((NavigateDirection)navigateDirection));
-        Assert.False(menuStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = CreateMenuStrip();
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void MenuStripAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = CreateMenuStrip();
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData()
-    {
-        foreach (object[] data in MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisibleAndToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfOverflow(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: true, itemCount: 1);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndStackLayout(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData()
-    {
-        Size overflowSize = new(10, 10);
-
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, overflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock: null, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        menuStrip.Items.Insert(0, CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        menuStrip.Items.Add(CreateSkippedItem());
-        menuStrip.Items.Add(CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items.Insert(0, CreateSkippedItem());
-
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items.Insert(0, CreateSkippedItem());
-
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (object[] data in MenuStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in MenuStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmptyAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfLastItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        menuStrip.Items.Add(CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        menuStrip.Items.Add(CreateSkippedItem());
-        menuStrip.Items.Add(CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkippedAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        menuStrip.Items.Add(CreateSkippedItem());
-        menuStrip.Items.Add(CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items.Insert(0, CreateSkippedItem());
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.Items.Add(CreateSkippedItem());
-        menuStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items.Insert(0, CreateSkippedItem());
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.Items.Add(CreateSkippedItem());
-        menuStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        menuStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfOverflow_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow: true, itemCount: 3);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(60, 30);
-        Size horizontalOverflowGripSize = new(70, 30);
-        Size verticalOverflowSize = new(30, 30);
-        Size verticalOverflowGripSize = new(30, 40);
-        Size bothOverflowSize = new(25, 25);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData()
-    {
-        Size horizontalOverflowSize = new(60, 30);
-        Size horizontalOverflowGripSize = new(70, 30);
-        Size verticalOverflowSize = new(30, 55);
-        Size verticalOverflowGripSize = new(30, 65);
-        Size bothOverflowSize = new(28, 28);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow: false, itemCount: 2);
-
-        menuStrip.Items.Insert(1, CreateSkippedItem());
-
-        menuStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(60, 30);
-        Size horizontalOverflowGripSize = new(70, 30);
-        Size verticalOverflowSize = new(30, 70);
-        Size verticalOverflowGripSize = new(30, 60);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData()
-    {
-        Size overflowSize = new(30, 40);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, overflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, overflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MenuStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData))]
-    public void MenuStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using MenuStrip menuStrip = CreateMenuStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        menuStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = menuStrip.AccessibilityObject;
-        AccessibleObject expected = menuStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    private MenuStrip CreateMenuStrip(
-       ToolStripGripStyle? gripStyle = null,
-       ToolStripLayoutStyle? layoutStyle = null,
-       DockStyle? dock = null,
-       Size? size = null,
-       bool? canOverflow = null,
-       int itemCount = 0,
-       bool createControl = true
-    )
-    {
-        MenuStrip menuStrip = new();
-
-        if (layoutStyle is not null)
-        {
-            menuStrip.LayoutStyle = layoutStyle.Value;
-        }
-
-        if (gripStyle is not null)
-        {
-            menuStrip.GripStyle = gripStyle.Value;
-        }
-
-        if (dock is not null)
-        {
-            menuStrip.Dock = dock.Value;
-        }
-
-        if (size is not null)
-        {
-            menuStrip.AutoSize = false;
-            menuStrip.Size = size.Value;
-        }
-
-        if (canOverflow is not null)
-        {
-            menuStrip.CanOverflow = canOverflow.Value;
-        }
-
-        for (int i = 0; i < itemCount; i++)
-        {
-            menuStrip.Items.Add(CreateMenuItem());
-        }
-
-        menuStrip.PerformLayout();
-
-        if (createControl)
-        {
-            menuStrip.CreateControl();
-        }
-
-        return menuStrip;
-
-        ToolStripItem CreateMenuItem()
-        {
-            return new ToolStripMenuItem()
-            {
-                AutoSize = false,
-                Size = new Size(50, 25),
-                Overflow = ToolStripItemOverflow.AsNeeded
-            };
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStripTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStripTests.cs
deleted file mode 100644
index 95030be8abb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MenuStripTests.cs
+++ /dev/null
@@ -1,944 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class MenuStripTests
-{
-    [WinFormsFact]
-    public void MenuStrip_Ctor_Default()
-    {
-        using var control = new SubMenuStrip();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.AllowMerge);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(24, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 24), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanOverflow);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.False(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 24), control.ClientRectangle);
-        Assert.Equal(new Size(200, 24), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(DockStyle.Top, control.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.BelowRight, control.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 0, 2), control.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(new Padding(6, 2, 0, 2), control.DefaultPadding);
-        Assert.Equal(new Size(200, 24), control.DefaultSize);
-        Assert.False(control.DefaultShowItemToolTips);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayedItems);
-        Assert.Same(control.DisplayedItems, control.DisplayedItems);
-        Assert.Equal(new Rectangle(6, 2, 194, 20), control.DisplayRectangle);
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.NotNull(control.DockPadding);
-        Assert.Same(control.DockPadding, control.DockPadding);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(2, control.DockPadding.Bottom);
-        Assert.Equal(6, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Hidden, control.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Vertical, control.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 0, 2), control.GripMargin);
-        Assert.Equal(Rectangle.Empty, control.GripRectangle);
-        Assert.False(control.HasChildren);
-        Assert.Equal(24, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Null(control.ImageList);
-        Assert.Equal(new Size(16, 16), control.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsDropDown);
-        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.Null(control.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.HorizontalStackWithOverflow, control.LayoutStyle);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(new Size(194, 20), control.MaxItemSize);
-        Assert.Null(control.MdiWindowListItem);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.NotNull(control.OverflowButton);
-        Assert.Same(control.OverflowButton, control.OverflowButton);
-        Assert.Same(control, control.OverflowButton.GetCurrentParent());
-        Assert.Equal(new Padding(6, 2, 0, 2), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.False(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 24), control.Size);
-        Assert.True(control.Stretch);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, control.TextDirection);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.True(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MenuStrip_CanOverflow_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new MenuStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void MenuStrip_CanOverflow_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new MenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_DefaultPadding_GetVisibleGrip_ReturnsExpected()
-    {
-        using var control = new SubMenuStrip
-        {
-            GripStyle = ToolStripGripStyle.Visible
-        };
-        Assert.Equal(new Padding(3, 2, 0, 2), control.DefaultPadding);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 0)]
-    [InlineData(ToolStripGripStyle.Visible, 1)]
-    public void MenuStrip_GripStyle_Set_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new MenuStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 0)]
-    [InlineData(ToolStripGripStyle.Visible, 1)]
-    public void MenuStrip_GripStyle_SetWithHandle_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new MenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> MdiWindowListItem_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripMenuItem() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MdiWindowListItem_Set_TestData))]
-    public void MenuStrip_MdiWindowListItem_Set_GetReturnsExpected(ToolStripMenuItem value)
-    {
-        using var control = new MenuStrip
-        {
-            MdiWindowListItem = value
-        };
-        Assert.Same(value, control.MdiWindowListItem);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MdiWindowListItem = value;
-        Assert.Same(value, control.MdiWindowListItem);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MenuStrip_ShowItemToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new MenuStrip
-        {
-            ShowItemToolTips = value
-        };
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowItemToolTips = !value;
-        Assert.Equal(!value, control.ShowItemToolTips);
-        Assert.Equal(!value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MenuStrip_Stretch_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            Stretch = value
-        };
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MenuStrip_Stretch_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new MenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMenuStrip();
-        ToolStrip.ToolStripAccessibleObject instance = Assert.IsAssignableFrom<ToolStrip.ToolStripAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.MenuBar, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubMenuStrip
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        ToolStrip.ToolStripAccessibleObject instance = Assert.IsAssignableFrom<ToolStrip.ToolStripAccessibleObject>(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);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Button_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Button_TestData))]
-    public void MenuStrip_CreateDefaultItem_InvokeButton_Success(string text, Image image, EventHandler onClick)
-    {
-        using var control = new SubMenuStrip();
-        ToolStripMenuItem item = Assert.IsType<ToolStripMenuItem>(control.CreateDefaultItem(text, image, onClick));
-        Assert.Equal(text, item.Text);
-        Assert.Same(image, item.Image);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Separator_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null };
-        yield return new object[] { new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Separator_TestData))]
-    public void MenuStrip_CreateDefaultItem_InvokeSeparator_Success(Image image, EventHandler onClick)
-    {
-        using var control = new SubMenuStrip();
-        ToolStripSeparator separator = Assert.IsType<ToolStripSeparator>(control.CreateDefaultItem("-", image, onClick));
-        Assert.Empty(separator.Text);
-        Assert.Null(separator.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 1)]
-    [InlineData("text", 1)]
-    [InlineData("-", 0)]
-    public void MenuStrip_CreateDefaultItem_PerformClick_Success(string text, int expectedCallCount)
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var control = new SubMenuStrip();
-        ToolStripItem item = Assert.IsAssignableFrom<ToolStripItem>(control.CreateDefaultItem(text, null, onClick));
-        item.PerformClick();
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMenuStrip();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubMenuStrip.ScrollStateAutoScrolling, false)]
-    [InlineData(SubMenuStrip.ScrollStateFullDrag, false)]
-    [InlineData(SubMenuStrip.ScrollStateHScrollVisible, false)]
-    [InlineData(SubMenuStrip.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubMenuStrip.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void MenuStrip_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubMenuStrip();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void MenuStrip_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubMenuStrip();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMenuStrip();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MenuStrip_OnMenuActivate_Invoke_CallsMenuActivate(EventArgs eventArgs)
-    {
-        using var control = new SubMenuStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MenuActivate += handler;
-        control.OnMenuActivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MenuActivate -= handler;
-        control.OnMenuActivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MenuStrip_OnMenuActivate_InvokeWithHandle_CallsMenuActivate(EventArgs eventArgs)
-    {
-        using var control = new SubMenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MenuActivate += handler;
-        control.OnMenuActivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MenuActivate -= handler;
-        control.OnMenuActivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MenuStrip_OnMenuDeactivate_Invoke_CallsMenuDeactivate(EventArgs eventArgs)
-    {
-        using var control = new SubMenuStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MenuDeactivate += handler;
-        control.OnMenuDeactivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MenuDeactivate -= handler;
-        control.OnMenuDeactivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MenuStrip_OnMenuDeactivate_InvokeWithHandle_CallsMenuDeactivate(EventArgs eventArgs)
-    {
-        using var control = new SubMenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MenuDeactivate += handler;
-        control.OnMenuDeactivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MenuDeactivate -= handler;
-        control.OnMenuDeactivate(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void MenuStirp_ProcessCmdKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubMenuStrip();
-        var m = new Message();
-        Assert.False(control.ProcessCmdKey(ref m, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Space)]
-    [InlineData(Keys.Control)]
-    [InlineData(Keys.Tab)]
-    [InlineData(Keys.Control & Keys.Tab)]
-    public void MenuStirp_ProcessCmdKey_InvokeWithParent_ReturnsFalse(Keys keyData)
-    {
-        using var parent = new Control();
-        using var control = new SubMenuStrip
-        {
-            Parent = parent
-        };
-        var msg = new Message();
-        Assert.False(control.ProcessCmdKey(ref msg, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    [InlineData(Keys.Space, true)]
-    [InlineData(Keys.Space, false)]
-    [InlineData(Keys.Control, true)]
-    [InlineData(Keys.Control, false)]
-    [InlineData(Keys.Tab, true)]
-    [InlineData(Keys.Tab, false)]
-    [InlineData(Keys.Control & Keys.Tab, true)]
-    [InlineData(Keys.Control & Keys.Tab, false)]
-    public void MenuStirp_ProcessCmdKey_InvokeWithCustomParent_ReturnsExpected(Keys keyData, bool result)
-    {
-        using var control = new SubMenuStrip();
-        var msg = new Message
-        {
-            Msg = 1
-        };
-        int callCount = 0;
-        bool action(Message actualMsg, Keys actualKeyData)
-        {
-            Assert.Equal(1, actualMsg.Msg);
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = action
-        };
-        control.Parent = parent;
-
-        Assert.Equal(result, control.ProcessCmdKey(ref msg, keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_WndProc_InvokeMouseActivate_Success()
-    {
-        using var control = new SubMenuStrip();
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEACTIVATE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_WndProc_InvokeMouseActivateWithHandle_Success()
-    {
-        using var control = new SubMenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEACTIVATE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MenuStrip_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubMenuStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<char, bool> ProcessDialogCharAction { get; set; }
-
-        protected override bool ProcessDialogChar(char charCode) => ProcessDialogCharAction(charCode);
-    }
-
-    private class SubMenuStrip : MenuStrip
-    {
-        public new const int ScrollStateAutoScrolling = MenuStrip.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = MenuStrip.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = MenuStrip.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = MenuStrip.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = MenuStrip.ScrollStateFullDrag;
-
-        public SubMenuStrip() : base()
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new DockStyle DefaultDock => base.DefaultDock;
-
-        public new Padding DefaultGripMargin => base.DefaultGripMargin;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DefaultShowItemToolTips => base.DefaultShowItemToolTips;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new Size MaxItemSize => base.MaxItemSize;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ToolStripItem CreateDefaultItem(string text, Image image, EventHandler onClick) => base.CreateDefaultItem(text, image, onClick);
-
-        public new LayoutSettings CreateLayoutSettings(ToolStripLayoutStyle layoutStyle) => base.CreateLayoutSettings(layoutStyle);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnMenuActivate(EventArgs e) => base.OnMenuActivate(e);
-
-        public new void OnMenuDeactivate(EventArgs e) => base.OnMenuDeactivate(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageBoxTests.cs
deleted file mode 100644
index d2f05f3db94..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageBoxTests.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Reflection;
-
-namespace System.Windows.Forms.Tests;
-
-public class MessageBoxTests
-{
-    [WinFormsTheory]
-    [InvalidEnumData<MessageBoxButtons>]
-    public void MessageBox_MessageBoxButtons_ThrowsInvalidEnumArgumentException(MessageBoxButtons value)
-    {
-        Assert.Throws<InvalidEnumArgumentException>(
-            "buttons",
-            () => GetMessageBoxStyle(
-                null,
-                value,
-                MessageBoxIcon.None,
-                MessageBoxDefaultButton.Button1,
-                MessageBoxOptions.DefaultDesktopOnly,
-                false));
-    }
-
-    public static IEnumerable<object[]> MessageBoxButtons_Set_TestData()
-    {
-        foreach (MessageBoxButtons value in Enum.GetValues(typeof(MessageBoxButtons)))
-        {
-            yield return new object[] { value };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MessageBoxButtons_Set_TestData))]
-    public void MessageBox_MessageBoxButtons_Valid(MessageBoxButtons value)
-    {
-        MESSAGEBOX_STYLE style = GetMessageBoxStyle(
-            null,
-            value,
-            MessageBoxIcon.None,
-            MessageBoxDefaultButton.Button1,
-            MessageBoxOptions.DefaultDesktopOnly,
-            false);
-
-        Assert.Equal(
-            style,
-            (MESSAGEBOX_STYLE)value
-                | (MESSAGEBOX_STYLE)MessageBoxIcon.None
-                | (MESSAGEBOX_STYLE)MessageBoxDefaultButton.Button1
-                | (MESSAGEBOX_STYLE)MessageBoxOptions.DefaultDesktopOnly);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<MessageBoxIcon>]
-    public void MessageBox_MessageBoxIcon_ThrowsInvalidEnumArgumentException(MessageBoxIcon value)
-    {
-        Assert.Throws<InvalidEnumArgumentException>(
-            "icon",
-            () => GetMessageBoxStyle(
-                null,
-                MessageBoxButtons.OK,
-                value,
-                MessageBoxDefaultButton.Button1,
-                MessageBoxOptions.DefaultDesktopOnly,
-                false));
-    }
-
-    public static IEnumerable<object[]> MessageBoxIcon_Set_TestData()
-    {
-        foreach (MessageBoxIcon value in Enum.GetValues(typeof(MessageBoxIcon)))
-        {
-            yield return new object[] { value };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MessageBoxIcon_Set_TestData))]
-    public void MessageBox_MessageBoxIcon_Valid(MessageBoxIcon value)
-    {
-        MESSAGEBOX_STYLE style = GetMessageBoxStyle(
-            null,
-            MessageBoxButtons.OK,
-            value,
-            MessageBoxDefaultButton.Button1,
-            MessageBoxOptions.DefaultDesktopOnly,
-            false);
-        Assert.Equal(
-            style,
-            (MESSAGEBOX_STYLE)MessageBoxButtons.OK
-                | (MESSAGEBOX_STYLE)value
-                | (MESSAGEBOX_STYLE)MessageBoxDefaultButton.Button1
-                | (MESSAGEBOX_STYLE)MessageBoxOptions.DefaultDesktopOnly);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<MessageBoxDefaultButton>]
-    public void MessageBox_MessageBoxDefaultButton_ThrowsInvalidEnumArgumentException(MessageBoxDefaultButton value)
-    {
-        Assert.Throws<InvalidEnumArgumentException>(
-            "defaultButton",
-            () => GetMessageBoxStyle(
-                null,
-                MessageBoxButtons.OK,
-                MessageBoxIcon.None,
-                value,
-                MessageBoxOptions.DefaultDesktopOnly,
-                false));
-    }
-
-    public static IEnumerable<object[]> MessageBoxDefaultButton_Set_TestData()
-    {
-        foreach (MessageBoxDefaultButton value in Enum.GetValues(typeof(MessageBoxDefaultButton)))
-        {
-            yield return new object[] { value };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MessageBoxDefaultButton_Set_TestData))]
-    public void MessageBox_MessageBoxDefaultButton_Valid(MessageBoxDefaultButton value)
-    {
-        MESSAGEBOX_STYLE style = GetMessageBoxStyle(
-            null,
-            MessageBoxButtons.OK,
-            MessageBoxIcon.None,
-            value,
-            MessageBoxOptions.DefaultDesktopOnly,
-            false);
-        Assert.Equal(
-            style,
-            (MESSAGEBOX_STYLE)MessageBoxButtons.OK
-                | (MESSAGEBOX_STYLE)MessageBoxIcon.None
-                | (MESSAGEBOX_STYLE)value
-                | (MESSAGEBOX_STYLE)MessageBoxOptions.DefaultDesktopOnly);
-    }
-
-    private static MESSAGEBOX_STYLE GetMessageBoxStyle(
-        IWin32Window owner,
-        MessageBoxButtons buttons,
-        MessageBoxIcon icon,
-        MessageBoxDefaultButton defaultButton,
-        MessageBoxOptions options,
-        bool showHelp)
-    {
-        try
-        {
-            return typeof(MessageBox).TestAccessor().Dynamic.GetMessageBoxStyle(owner, buttons, icon, defaultButton, options, showHelp);
-        }
-        catch (TargetInvocationException ex)
-        {
-            throw ex.InnerException;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageTests.cs
deleted file mode 100644
index fdb8d90eb35..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MessageTests.cs
+++ /dev/null
@@ -1,508 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class MessageTests
-{
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetIntPtrTheoryData))]
-    public void Message_HWnd_Set_GetReturnsExpected(IntPtr value)
-    {
-        var message = new Message
-        {
-            HWnd = value
-        };
-        Assert.Equal(value, message.HWnd);
-
-        // Set same.
-        message.HWnd = value;
-        Assert.Equal(value, message.HWnd);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Message_Msg_Set_GetReturnsExpected(int value)
-    {
-        var message = new Message
-        {
-            Msg = value
-        };
-        Assert.Equal(value, message.Msg);
-
-        // Set same.
-        message.Msg = value;
-        Assert.Equal(value, message.Msg);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetIntPtrTheoryData))]
-    public void Message_WParam_Set_GetReturnsExpected(IntPtr value)
-    {
-        var message = new Message
-        {
-            WParam = value
-        };
-        Assert.Equal(value, message.WParam);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetIntPtrTheoryData))]
-    public void Message_LParam_Set_GetReturnsExpected(IntPtr value)
-    {
-        var message = new Message
-        {
-            LParam = value
-        };
-        Assert.Equal(value, message.LParam);
-
-        // Set same.
-        message.LParam = value;
-        Assert.Equal(value, message.LParam);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetIntPtrTheoryData))]
-    public void Message_Result_Set_GetReturnsExpected(IntPtr value)
-    {
-        var message = new Message
-        {
-            Result = value
-        };
-        Assert.Equal(value, message.Result);
-
-        // Set same.
-        message.Result = value;
-        Assert.Equal(value, message.Result);
-    }
-
-    public static IEnumerable<object[]> Create_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1), -1, (IntPtr)(-1), (IntPtr)(-1) };
-        yield return new object[] { IntPtr.Zero, 1, IntPtr.Zero, IntPtr.Zero };
-        yield return new object[] { (IntPtr)1, 1, (IntPtr)1, (IntPtr)1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Create_TestData))]
-    public void Message_Create_Invoke_ReturnsExpected(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
-    {
-        Message message = Message.Create(hWnd, msg, wparam, lparam);
-        Assert.Equal(hWnd, message.HWnd);
-        Assert.Equal(msg, message.Msg);
-        Assert.Equal(wparam, message.WParam);
-        Assert.Equal(lparam, message.LParam);
-        Assert.Equal(IntPtr.Zero, message.Result);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        static Message Create(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam, IntPtr result)
-        {
-            Message message = Message.Create(hWnd, msg, wparam, lparam);
-            message.Result = result;
-            return message;
-        }
-
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            true
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)2, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            false
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)1, 3, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            false
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)1, 2, (IntPtr)4, (IntPtr)4, (IntPtr)5),
-            false
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)5, (IntPtr)5),
-            false
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)6),
-            false
-        };
-
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            new object(),
-            false
-        };
-        yield return new object[]
-        {
-            Create((IntPtr)1, 2, (IntPtr)3, (IntPtr)4, (IntPtr)5),
-            null,
-            false
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Message_Equals_Invoke_ReturnsExpected(Message message, object other, bool expected)
-    {
-        if (other is Message otherMessage)
-        {
-            Assert.Equal(expected, message == otherMessage);
-            Assert.Equal(!expected, message != otherMessage);
-        }
-
-        Assert.Equal(expected, message.Equals(other));
-    }
-
-    [Fact]
-    public void Message_GetHashCode_Invoke_ReturnsExpected()
-    {
-        Message message = Message.Create((IntPtr)1, 1, (IntPtr)1, (IntPtr)1);
-        Assert.NotEqual(0, message.GetHashCode());
-        Assert.Equal(message.GetHashCode(), message.GetHashCode());
-    }
-
-    [Fact]
-    public void Message_GetLParam_Invoke_ReturnsExpected()
-    {
-        IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf<TestStruct>());
-        try
-        {
-            var original = new TestStruct
-            {
-                _field1 = 1,
-                _field2 = 2
-            };
-            Marshal.StructureToPtr(original, ptr, fDeleteOld: false);
-
-            var message = new Message
-            {
-                LParam = ptr
-            };
-            TestStruct lparam = Assert.IsType<TestStruct>(message.GetLParam(typeof(TestStruct)));
-            Assert.Equal(1, lparam._field1);
-            Assert.Equal(2, lparam._field2);
-        }
-        finally
-        {
-            Marshal.FreeHGlobal(ptr);
-        }
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct TestStruct
-    {
-        public int _field1;
-        public int _field2;
-    }
-
-    public static IEnumerable<object[]> ToString_TestData()
-    {
-        yield return new object[] { 0x1FFF, null };
-        yield return new object[] { 0x2000, " (WM_REFLECT + WM_NULL)" };
-        yield return new object[] { -1 | 0x2000, " (WM_REFLECT + ???)" };
-
-        yield return new object[] { PInvoke.WM_NULL, " (WM_NULL)" };
-        yield return new object[] { PInvoke.WM_CREATE, " (WM_CREATE)" };
-        yield return new object[] { PInvoke.WM_DESTROY, " (WM_DESTROY)" };
-        yield return new object[] { PInvoke.WM_MOVE, " (WM_MOVE)" };
-        yield return new object[] { PInvoke.WM_SIZE, " (WM_SIZE)" };
-        yield return new object[] { PInvoke.WM_ACTIVATE, " (WM_ACTIVATE)" };
-        yield return new object[] { PInvoke.WM_SETFOCUS, " (WM_SETFOCUS)" };
-        yield return new object[] { PInvoke.WM_KILLFOCUS, " (WM_KILLFOCUS)" };
-        yield return new object[] { PInvoke.WM_ENABLE, " (WM_ENABLE)" };
-        yield return new object[] { PInvoke.WM_SETREDRAW, " (WM_SETREDRAW)" };
-        yield return new object[] { PInvoke.WM_SETTEXT, " (WM_SETTEXT)" };
-        yield return new object[] { PInvoke.WM_GETTEXT, " (WM_GETTEXT)" };
-        yield return new object[] { PInvoke.WM_GETTEXTLENGTH, " (WM_GETTEXTLENGTH)" };
-        yield return new object[] { PInvoke.WM_PAINT, " (WM_PAINT)" };
-        yield return new object[] { PInvoke.WM_CLOSE, " (WM_CLOSE)" };
-        yield return new object[] { PInvoke.WM_QUERYENDSESSION, " (WM_QUERYENDSESSION)" };
-        yield return new object[] { PInvoke.WM_QUIT, " (WM_QUIT)" };
-        yield return new object[] { PInvoke.WM_QUERYOPEN, " (WM_QUERYOPEN)" };
-        yield return new object[] { PInvoke.WM_ERASEBKGND, " (WM_ERASEBKGND)" };
-        yield return new object[] { PInvoke.WM_SYSCOLORCHANGE, " (WM_SYSCOLORCHANGE)" };
-        yield return new object[] { PInvoke.WM_ENDSESSION, " (WM_ENDSESSION)" };
-        yield return new object[] { PInvoke.WM_SHOWWINDOW, " (WM_SHOWWINDOW)" };
-        yield return new object[] { PInvoke.WM_WININICHANGE, " (WM_WININICHANGE)" };
-        yield return new object[] { PInvoke.WM_DEVMODECHANGE, " (WM_DEVMODECHANGE)" };
-        yield return new object[] { PInvoke.WM_ACTIVATEAPP, " (WM_ACTIVATEAPP)" };
-        yield return new object[] { PInvoke.WM_FONTCHANGE, " (WM_FONTCHANGE)" };
-        yield return new object[] { PInvoke.WM_TIMECHANGE, " (WM_TIMECHANGE)" };
-        yield return new object[] { PInvoke.WM_CANCELMODE, " (WM_CANCELMODE)" };
-        yield return new object[] { PInvoke.WM_SETCURSOR, " (WM_SETCURSOR)" };
-        yield return new object[] { PInvoke.WM_MOUSEACTIVATE, " (WM_MOUSEACTIVATE)" };
-        yield return new object[] { PInvoke.WM_CHILDACTIVATE, " (WM_CHILDACTIVATE)" };
-        yield return new object[] { PInvoke.WM_QUEUESYNC, " (WM_QUEUESYNC)" };
-        yield return new object[] { PInvoke.WM_GETMINMAXINFO, " (WM_GETMINMAXINFO)" };
-        yield return new object[] { PInvoke.WM_PAINTICON, " (WM_PAINTICON)" };
-        yield return new object[] { PInvoke.WM_ICONERASEBKGND, " (WM_ICONERASEBKGND)" };
-        yield return new object[] { PInvoke.WM_NEXTDLGCTL, " (WM_NEXTDLGCTL)" };
-        yield return new object[] { PInvoke.WM_SPOOLERSTATUS, " (WM_SPOOLERSTATUS)" };
-        yield return new object[] { PInvoke.WM_DRAWITEM, " (WM_DRAWITEM)" };
-        yield return new object[] { PInvoke.WM_MEASUREITEM, " (WM_MEASUREITEM)" };
-        yield return new object[] { PInvoke.WM_DELETEITEM, " (WM_DELETEITEM)" };
-        yield return new object[] { PInvoke.WM_VKEYTOITEM, " (WM_VKEYTOITEM)" };
-        yield return new object[] { PInvoke.WM_CHARTOITEM, " (WM_CHARTOITEM)" };
-        yield return new object[] { PInvoke.WM_SETFONT, " (WM_SETFONT)" };
-        yield return new object[] { PInvoke.WM_GETFONT, " (WM_GETFONT)" };
-        yield return new object[] { PInvoke.WM_SETHOTKEY, " (WM_SETHOTKEY)" };
-        yield return new object[] { PInvoke.WM_GETHOTKEY, " (WM_GETHOTKEY)" };
-        yield return new object[] { PInvoke.WM_QUERYDRAGICON, " (WM_QUERYDRAGICON)" };
-        yield return new object[] { PInvoke.WM_COMPAREITEM, " (WM_COMPAREITEM)" };
-        yield return new object[] { PInvoke.WM_GETOBJECT, " (WM_GETOBJECT)" };
-        yield return new object[] { PInvoke.WM_COMPACTING, " (WM_COMPACTING)" };
-        yield return new object[] { PInvoke.WM_COMMNOTIFY, " (WM_COMMNOTIFY)" };
-        yield return new object[] { PInvoke.WM_WINDOWPOSCHANGING, " (WM_WINDOWPOSCHANGING)" };
-        yield return new object[] { PInvoke.WM_WINDOWPOSCHANGED, " (WM_WINDOWPOSCHANGED)" };
-        yield return new object[] { PInvoke.WM_POWER, " (WM_POWER)" };
-        yield return new object[] { PInvoke.WM_COPYDATA, " (WM_COPYDATA)" };
-        yield return new object[] { PInvoke.WM_CANCELJOURNAL, " (WM_CANCELJOURNAL)" };
-        yield return new object[] { PInvoke.WM_NOTIFY, " (WM_NOTIFY)" };
-        yield return new object[] { PInvoke.WM_INPUTLANGCHANGEREQUEST, " (WM_INPUTLANGCHANGEREQUEST)" };
-        yield return new object[] { PInvoke.WM_INPUTLANGCHANGE, " (WM_INPUTLANGCHANGE)" };
-        yield return new object[] { PInvoke.WM_TCARD, " (WM_TCARD)" };
-        yield return new object[] { PInvoke.WM_HELP, " (WM_HELP)" };
-        yield return new object[] { PInvoke.WM_USERCHANGED, " (WM_USERCHANGED)" };
-        yield return new object[] { PInvoke.WM_NOTIFYFORMAT, " (WM_NOTIFYFORMAT)" };
-        yield return new object[] { PInvoke.WM_CONTEXTMENU, " (WM_CONTEXTMENU)" };
-        yield return new object[] { PInvoke.WM_STYLECHANGING, " (WM_STYLECHANGING)" };
-        yield return new object[] { PInvoke.WM_STYLECHANGED, " (WM_STYLECHANGED)" };
-        yield return new object[] { PInvoke.WM_DISPLAYCHANGE, " (WM_DISPLAYCHANGE)" };
-        yield return new object[] { PInvoke.WM_GETICON, " (WM_GETICON)" };
-        yield return new object[] { PInvoke.WM_SETICON, " (WM_SETICON)" };
-        yield return new object[] { PInvoke.WM_NCCREATE, " (WM_NCCREATE)" };
-        yield return new object[] { PInvoke.WM_NCDESTROY, " (WM_NCDESTROY)" };
-        yield return new object[] { PInvoke.WM_NCCALCSIZE, " (WM_NCCALCSIZE)" };
-        yield return new object[] { PInvoke.WM_NCHITTEST, " (WM_NCHITTEST)" };
-        yield return new object[] { PInvoke.WM_NCPAINT, " (WM_NCPAINT)" };
-        yield return new object[] { PInvoke.WM_NCACTIVATE, " (WM_NCACTIVATE)" };
-        yield return new object[] { PInvoke.WM_GETDLGCODE, " (WM_GETDLGCODE)" };
-        yield return new object[] { PInvoke.WM_NCMOUSEMOVE, " (WM_NCMOUSEMOVE)" };
-        yield return new object[] { PInvoke.WM_NCLBUTTONDOWN, " (WM_NCLBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_NCLBUTTONUP, " (WM_NCLBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_NCLBUTTONDBLCLK, " (WM_NCLBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_NCRBUTTONDOWN, " (WM_NCRBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_NCRBUTTONUP, " (WM_NCRBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_NCRBUTTONDBLCLK, " (WM_NCRBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_NCMBUTTONDOWN, " (WM_NCMBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_NCMBUTTONUP, " (WM_NCMBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_NCMBUTTONDBLCLK, " (WM_NCMBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_KEYDOWN, " (WM_KEYDOWN)" };
-        yield return new object[] { PInvoke.WM_KEYUP, " (WM_KEYUP)" };
-        yield return new object[] { PInvoke.WM_CHAR, " (WM_CHAR)" };
-        yield return new object[] { PInvoke.WM_DEADCHAR, " (WM_DEADCHAR)" };
-        yield return new object[] { PInvoke.WM_SYSKEYDOWN, " (WM_SYSKEYDOWN)" };
-        yield return new object[] { PInvoke.WM_SYSKEYUP, " (WM_SYSKEYUP)" };
-        yield return new object[] { PInvoke.WM_SYSCHAR, " (WM_SYSCHAR)" };
-        yield return new object[] { PInvoke.WM_SYSDEADCHAR, " (WM_SYSDEADCHAR)" };
-        yield return new object[] { PInvoke.WM_KEYLAST, " (WM_KEYLAST)" };
-        yield return new object[] { PInvoke.WM_IME_STARTCOMPOSITION, " (WM_IME_STARTCOMPOSITION)" };
-        yield return new object[] { PInvoke.WM_IME_ENDCOMPOSITION, " (WM_IME_ENDCOMPOSITION)" };
-        yield return new object[] { PInvoke.WM_IME_COMPOSITION, " (WM_IME_COMPOSITION)" };
-        yield return new object[] { PInvoke.WM_INITDIALOG, " (WM_INITDIALOG)" };
-        yield return new object[] { PInvoke.WM_COMMAND, " (WM_COMMAND)" };
-        yield return new object[] { PInvoke.WM_SYSCOMMAND, " (WM_SYSCOMMAND)" };
-        yield return new object[] { PInvoke.WM_TIMER, " (WM_TIMER)" };
-        yield return new object[] { PInvoke.WM_HSCROLL, " (WM_HSCROLL)" };
-        yield return new object[] { PInvoke.WM_VSCROLL, " (WM_VSCROLL)" };
-        yield return new object[] { PInvoke.WM_INITMENU, " (WM_INITMENU)" };
-        yield return new object[] { PInvoke.WM_INITMENUPOPUP, " (WM_INITMENUPOPUP)" };
-        yield return new object[] { PInvoke.WM_MENUSELECT, " (WM_MENUSELECT)" };
-        yield return new object[] { PInvoke.WM_MENUCHAR, " (WM_MENUCHAR)" };
-        yield return new object[] { PInvoke.WM_ENTERIDLE, " (WM_ENTERIDLE)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORMSGBOX, " (WM_CTLCOLORMSGBOX)" };
-        yield return new object[] { PInvoke.WM_CTLCOLOREDIT, " (WM_CTLCOLOREDIT)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORLISTBOX, " (WM_CTLCOLORLISTBOX)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORBTN, " (WM_CTLCOLORBTN)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORDLG, " (WM_CTLCOLORDLG)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORSCROLLBAR, " (WM_CTLCOLORSCROLLBAR)" };
-        yield return new object[] { PInvoke.WM_CTLCOLORSTATIC, " (WM_CTLCOLORSTATIC)" };
-        yield return new object[] { PInvoke.WM_MOUSEMOVE, " (WM_MOUSEMOVE)" };
-        yield return new object[] { PInvoke.WM_LBUTTONDOWN, " (WM_LBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_LBUTTONUP, " (WM_LBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_LBUTTONDBLCLK, " (WM_LBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_RBUTTONDOWN, " (WM_RBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_RBUTTONUP, " (WM_RBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_RBUTTONDBLCLK, " (WM_RBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_MBUTTONDOWN, " (WM_MBUTTONDOWN)" };
-        yield return new object[] { PInvoke.WM_MBUTTONUP, " (WM_MBUTTONUP)" };
-        yield return new object[] { PInvoke.WM_MBUTTONDBLCLK, " (WM_MBUTTONDBLCLK)" };
-        yield return new object[] { PInvoke.WM_MOUSEWHEEL, " (WM_MOUSEWHEEL)" };
-        yield return new object[] { PInvoke.WM_PARENTNOTIFY, " (WM_PARENTNOTIFY)", " (WM_DESTROY)" };
-        yield return new object[] { PInvoke.WM_ENTERMENULOOP, " (WM_ENTERMENULOOP)" };
-        yield return new object[] { PInvoke.WM_EXITMENULOOP, " (WM_EXITMENULOOP)" };
-        yield return new object[] { PInvoke.WM_NEXTMENU, " (WM_NEXTMENU)" };
-        yield return new object[] { PInvoke.WM_SIZING, " (WM_SIZING)" };
-        yield return new object[] { PInvoke.WM_CAPTURECHANGED, " (WM_CAPTURECHANGED)" };
-        yield return new object[] { PInvoke.WM_MOVING, " (WM_MOVING)" };
-        yield return new object[] { PInvoke.WM_POWERBROADCAST, " (WM_POWERBROADCAST)" };
-        yield return new object[] { PInvoke.WM_DEVICECHANGE, " (WM_DEVICECHANGE)" };
-        yield return new object[] { PInvoke.WM_IME_SETCONTEXT, " (WM_IME_SETCONTEXT)" };
-        yield return new object[] { PInvoke.WM_IME_NOTIFY, " (WM_IME_NOTIFY)" };
-        yield return new object[] { PInvoke.WM_IME_CONTROL, " (WM_IME_CONTROL)" };
-        yield return new object[] { PInvoke.WM_IME_COMPOSITIONFULL, " (WM_IME_COMPOSITIONFULL)" };
-        yield return new object[] { PInvoke.WM_IME_SELECT, " (WM_IME_SELECT)" };
-        yield return new object[] { PInvoke.WM_IME_CHAR, " (WM_IME_CHAR)" };
-        yield return new object[] { PInvoke.WM_IME_KEYDOWN, " (WM_IME_KEYDOWN)" };
-        yield return new object[] { PInvoke.WM_IME_KEYUP, " (WM_IME_KEYUP)" };
-        yield return new object[] { PInvoke.WM_MDICREATE, " (WM_MDICREATE)" };
-        yield return new object[] { PInvoke.WM_MDIDESTROY, " (WM_MDIDESTROY)" };
-        yield return new object[] { PInvoke.WM_MDIACTIVATE, " (WM_MDIACTIVATE)" };
-        yield return new object[] { PInvoke.WM_MDIRESTORE, " (WM_MDIRESTORE)" };
-        yield return new object[] { PInvoke.WM_MDINEXT, " (WM_MDINEXT)" };
-        yield return new object[] { PInvoke.WM_MDIMAXIMIZE, " (WM_MDIMAXIMIZE)" };
-        yield return new object[] { PInvoke.WM_MDITILE, " (WM_MDITILE)" };
-        yield return new object[] { PInvoke.WM_MDICASCADE, " (WM_MDICASCADE)" };
-        yield return new object[] { PInvoke.WM_MDIICONARRANGE, " (WM_MDIICONARRANGE)" };
-        yield return new object[] { PInvoke.WM_MDIGETACTIVE, " (WM_MDIGETACTIVE)" };
-        yield return new object[] { PInvoke.WM_MDISETMENU, " (WM_MDISETMENU)" };
-        yield return new object[] { PInvoke.WM_ENTERSIZEMOVE, " (WM_ENTERSIZEMOVE)" };
-        yield return new object[] { PInvoke.WM_EXITSIZEMOVE, " (WM_EXITSIZEMOVE)" };
-        yield return new object[] { PInvoke.WM_DROPFILES, " (WM_DROPFILES)" };
-        yield return new object[] { PInvoke.WM_MDIREFRESHMENU, " (WM_MDIREFRESHMENU)" };
-        yield return new object[] { PInvoke.WM_MOUSEHOVER, " (WM_MOUSEHOVER)" };
-        yield return new object[] { PInvoke.WM_MOUSELEAVE, " (WM_MOUSELEAVE)" };
-        yield return new object[] { PInvoke.WM_CUT, " (WM_CUT)" };
-        yield return new object[] { PInvoke.WM_COPY, " (WM_COPY)" };
-        yield return new object[] { PInvoke.WM_PASTE, " (WM_PASTE)" };
-        yield return new object[] { PInvoke.WM_CLEAR, " (WM_CLEAR)" };
-        yield return new object[] { PInvoke.WM_UNDO, " (WM_UNDO)" };
-        yield return new object[] { PInvoke.WM_RENDERFORMAT, " (WM_RENDERFORMAT)" };
-        yield return new object[] { PInvoke.WM_RENDERALLFORMATS, " (WM_RENDERALLFORMATS)" };
-        yield return new object[] { PInvoke.WM_DESTROYCLIPBOARD, " (WM_DESTROYCLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_DRAWCLIPBOARD, " (WM_DRAWCLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_PAINTCLIPBOARD, " (WM_PAINTCLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_VSCROLLCLIPBOARD, " (WM_VSCROLLCLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_SIZECLIPBOARD, " (WM_SIZECLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_ASKCBFORMATNAME, " (WM_ASKCBFORMATNAME)" };
-        yield return new object[] { PInvoke.WM_CHANGECBCHAIN, " (WM_CHANGECBCHAIN)" };
-        yield return new object[] { PInvoke.WM_HSCROLLCLIPBOARD, " (WM_HSCROLLCLIPBOARD)" };
-        yield return new object[] { PInvoke.WM_QUERYNEWPALETTE, " (WM_QUERYNEWPALETTE)" };
-        yield return new object[] { PInvoke.WM_PALETTEISCHANGING, " (WM_PALETTEISCHANGING)" };
-        yield return new object[] { PInvoke.WM_PALETTECHANGED, " (WM_PALETTECHANGED)" };
-        yield return new object[] { PInvoke.WM_HOTKEY, " (WM_HOTKEY)" };
-        yield return new object[] { PInvoke.WM_PRINT, " (WM_PRINT)" };
-        yield return new object[] { PInvoke.WM_PRINTCLIENT, " (WM_PRINTCLIENT)" };
-        yield return new object[] { PInvoke.WM_HANDHELDFIRST, " (WM_HANDHELDFIRST)" };
-        yield return new object[] { PInvoke.WM_HANDHELDLAST, " (WM_HANDHELDLAST)" };
-        yield return new object[] { PInvoke.WM_AFXFIRST, " (WM_AFXFIRST)" };
-        yield return new object[] { PInvoke.WM_AFXLAST, " (WM_AFXLAST)" };
-        yield return new object[] { PInvoke.WM_PENWINFIRST, " (WM_PENWINFIRST)" };
-        yield return new object[] { PInvoke.WM_PENWINLAST, " (WM_PENWINLAST)" };
-        yield return new object[] { PInvoke.WM_APP, " (WM_APP)" };
-        yield return new object[] { PInvoke.WM_USER, " (WM_USER)" };
-        yield return new object[] { PInvoke.WM_CTLCOLOR, " (WM_CTLCOLOR)" };
-
-        // RichEdit messages
-        yield return new object[] { PInvoke.EM_GETLIMITTEXT, " (EM_GETLIMITTEXT)" };
-        yield return new object[] { PInvoke.EM_POSFROMCHAR, " (EM_POSFROMCHAR)" };
-        yield return new object[] { PInvoke.EM_CHARFROMPOS, " (EM_CHARFROMPOS)" };
-        yield return new object[] { PInvoke.EM_SCROLLCARET, " (EM_SCROLLCARET)" };
-        yield return new object[] { PInvoke.EM_CANPASTE, " (EM_CANPASTE)" };
-        yield return new object[] { PInvoke.EM_DISPLAYBAND, " (EM_DISPLAYBAND)" };
-        yield return new object[] { PInvoke.EM_EXGETSEL, " (EM_EXGETSEL)" };
-        yield return new object[] { PInvoke.EM_EXLIMITTEXT, " (EM_EXLIMITTEXT)" };
-        yield return new object[] { PInvoke.EM_EXLINEFROMCHAR, " (EM_EXLINEFROMCHAR)" };
-        yield return new object[] { PInvoke.EM_EXSETSEL, " (EM_EXSETSEL)" };
-        yield return new object[] { PInvoke.EM_FINDTEXT, " (EM_FINDTEXT)" };
-        yield return new object[] { PInvoke.EM_FORMATRANGE, " (EM_FORMATRANGE)" };
-        yield return new object[] { PInvoke.EM_GETCHARFORMAT, " (EM_GETCHARFORMAT)" };
-        yield return new object[] { PInvoke.EM_GETEVENTMASK, " (EM_GETEVENTMASK)" };
-        yield return new object[] { PInvoke.EM_GETOLEINTERFACE, " (EM_GETOLEINTERFACE)" };
-        yield return new object[] { PInvoke.EM_GETPARAFORMAT, " (EM_GETPARAFORMAT)" };
-        yield return new object[] { PInvoke.EM_GETSELTEXT, " (EM_GETSELTEXT)" };
-        yield return new object[] { PInvoke.EM_HIDESELECTION, " (EM_HIDESELECTION)" };
-        yield return new object[] { PInvoke.EM_PASTESPECIAL, " (EM_PASTESPECIAL)" };
-        yield return new object[] { PInvoke.EM_REQUESTRESIZE, " (EM_REQUESTRESIZE)" };
-        yield return new object[] { PInvoke.EM_SELECTIONTYPE, " (EM_SELECTIONTYPE)" };
-        yield return new object[] { PInvoke.EM_SETBKGNDCOLOR, " (EM_SETBKGNDCOLOR)" };
-        yield return new object[] { PInvoke.EM_SETCHARFORMAT, " (EM_SETCHARFORMAT)" };
-        yield return new object[] { PInvoke.EM_SETEVENTMASK, " (EM_SETEVENTMASK)" };
-        yield return new object[] { PInvoke.EM_SETOLECALLBACK, " (EM_SETOLECALLBACK)" };
-        yield return new object[] { PInvoke.EM_SETPARAFORMAT, " (EM_SETPARAFORMAT)" };
-        yield return new object[] { PInvoke.EM_SETTARGETDEVICE, " (EM_SETTARGETDEVICE)" };
-        yield return new object[] { PInvoke.EM_STREAMIN, " (EM_STREAMIN)" };
-        yield return new object[] { PInvoke.EM_STREAMOUT, " (EM_STREAMOUT)" };
-        yield return new object[] { PInvoke.EM_GETTEXTRANGE, " (EM_GETTEXTRANGE)" };
-        yield return new object[] { PInvoke.EM_FINDWORDBREAK, " (EM_FINDWORDBREAK)" };
-        yield return new object[] { PInvoke.EM_SETOPTIONS, " (EM_SETOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETOPTIONS, " (EM_GETOPTIONS)" };
-        yield return new object[] { PInvoke.EM_FINDTEXTEX, " (EM_FINDTEXTEX)" };
-        yield return new object[] { PInvoke.EM_GETWORDBREAKPROCEX, " (EM_GETWORDBREAKPROCEX)" };
-        yield return new object[] { PInvoke.EM_SETWORDBREAKPROCEX, " (EM_SETWORDBREAKPROCEX)" };
-
-        // Richedit v2.0 messages
-        yield return new object[] { PInvoke.EM_SETUNDOLIMIT, " (EM_SETUNDOLIMIT)" };
-        yield return new object[] { PInvoke.EM_REDO, " (EM_REDO)" };
-        yield return new object[] { PInvoke.EM_CANREDO, " (EM_CANREDO)" };
-        yield return new object[] { PInvoke.EM_GETUNDONAME, " (EM_GETUNDONAME)" };
-        yield return new object[] { PInvoke.EM_GETREDONAME, " (EM_GETREDONAME)" };
-        yield return new object[] { PInvoke.EM_STOPGROUPTYPING, " (EM_STOPGROUPTYPING)" };
-        yield return new object[] { PInvoke.EM_SETTEXTMODE, " (EM_SETTEXTMODE)" };
-        yield return new object[] { PInvoke.EM_GETTEXTMODE, " (EM_GETTEXTMODE)" };
-        yield return new object[] { PInvoke.EM_AUTOURLDETECT, " (EM_AUTOURLDETECT)" };
-        yield return new object[] { PInvoke.EM_GETAUTOURLDETECT, " (EM_GETAUTOURLDETECT)" };
-        yield return new object[] { PInvoke.EM_SETPALETTE, " (EM_SETPALETTE)" };
-        yield return new object[] { PInvoke.EM_GETTEXTEX, " (EM_GETTEXTEX)" };
-        yield return new object[] { PInvoke.EM_GETTEXTLENGTHEX, " (EM_GETTEXTLENGTHEX)" };
-
-        // Asia specific messages
-        yield return new object[] { PInvoke.EM_SETPUNCTUATION, " (EM_SETPUNCTUATION)" };
-        yield return new object[] { PInvoke.EM_GETPUNCTUATION, " (EM_GETPUNCTUATION)" };
-        yield return new object[] { PInvoke.EM_SETWORDWRAPMODE, " (EM_SETWORDWRAPMODE)" };
-        yield return new object[] { PInvoke.EM_GETWORDWRAPMODE, " (EM_GETWORDWRAPMODE)" };
-        yield return new object[] { PInvoke.EM_SETIMECOLOR, " (EM_SETIMECOLOR)" };
-        yield return new object[] { PInvoke.EM_GETIMECOLOR, " (EM_GETIMECOLOR)" };
-        yield return new object[] { PInvoke.EM_SETIMEOPTIONS, " (EM_SETIMEOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETIMEOPTIONS, " (EM_GETIMEOPTIONS)" };
-        yield return new object[] { PInvoke.EM_CONVPOSITION, " (EM_CONVPOSITION)" };
-        yield return new object[] { PInvoke.EM_SETLANGOPTIONS, " (EM_SETLANGOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETLANGOPTIONS, " (EM_GETLANGOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETIMECOMPMODE, " (EM_GETIMECOMPMODE)" };
-        yield return new object[] { PInvoke.EM_FINDTEXTW, " (EM_FINDTEXTW)" };
-        yield return new object[] { PInvoke.EM_FINDTEXTEXW, " (EM_FINDTEXTEXW)" };
-
-        // Rich Edit 3.0 Asia msgs
-        yield return new object[] { PInvoke.EM_RECONVERSION, " (EM_RECONVERSION)" };
-        yield return new object[] { PInvoke.EM_SETIMEMODEBIAS, " (EM_SETIMEMODEBIAS)" };
-        yield return new object[] { PInvoke.EM_GETIMEMODEBIAS, " (EM_GETIMEMODEBIAS)" };
-
-        // BiDi Specific messages
-        yield return new object[] { PInvoke.EM_SETBIDIOPTIONS, " (EM_SETBIDIOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETBIDIOPTIONS, " (EM_GETBIDIOPTIONS)" };
-        yield return new object[] { PInvoke.EM_SETTYPOGRAPHYOPTIONS, " (EM_SETTYPOGRAPHYOPTIONS)" };
-        yield return new object[] { PInvoke.EM_GETTYPOGRAPHYOPTIONS, " (EM_GETTYPOGRAPHYOPTIONS)" };
-
-        // Extended Edit style specific messages
-        yield return new object[] { PInvoke.EM_SETEDITSTYLE, " (EM_SETEDITSTYLE)" };
-        yield return new object[] { PInvoke.EM_GETEDITSTYLE, " (EM_GETEDITSTYLE)" };
-    }
-
-    [Theory]
-    [MemberData(nameof(ToString_TestData))]
-    public void Message_ToString_Invoke_ReturnsExpected(int msg, string expected, string additionalMsg = null)
-    {
-        Message message = Message.Create((IntPtr)1, msg, (IntPtr)2, (IntPtr)3);
-        message.Result = (IntPtr)4;
-        Assert.Equal($"msg=0x{msg:x}{expected} hwnd=0x1 wparam=0x2 lparam=0x3{additionalMsg} result=0x4", message.ToString());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MixedDpiHostingTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MixedDpiHostingTests.cs
deleted file mode 100644
index 6d467290391..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MixedDpiHostingTests.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class MixedDpiHostingTests
-{
-    [WinFormsFact]
-    public void MixedHosting_Default()
-    {
-        // Run tests only on Windows 10 versions that support thread dpi awareness.
-        if (!PlatformDetection.IsWindows10Version1803OrGreater)
-        {
-            return;
-        }
-
-        // Set thread awareness context to PermonitorV2(PMv2). If process/thread is not in PMv2, calling 'EnterDpiAwarenessScope' is a no-op and that is by design.
-        // In this case, we will be setting thread to PMv2 mode and then scope to UNAWARE
-        DPI_AWARENESS_CONTEXT originalAwarenessContext = PInvoke.SetThreadDpiAwarenessContextInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
-
-        try
-        {
-            using Form form = new Form();
-            using (DpiHelper.EnterDpiAwarenessScope(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE))
-            {
-                using Control control = new();
-                form.Controls.Add(control);
-                form.Load += (_, _) =>
-                {
-                    form.Close();
-                };
-
-                form.ShowDialog();
-
-                DPI_AWARENESS_CONTEXT controlDpiContext = PInvoke.GetWindowDpiAwarenessContext(control.HWND);
-                DPI_AWARENESS_CONTEXT formDpiContext = PInvoke.GetWindowDpiAwarenessContext(form.HWND);
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_SYSTEM_AWARE, controlDpiContext));
-                Assert.True(PInvoke.AreDpiAwarenessContextsEqualInternal(DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2, formDpiContext));
-            }
-        }
-        finally
-        {
-            // Reset back to original awareness context.
-            PInvoke.SetThreadDpiAwarenessContextInternal(originalAwarenessContext);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/CommandViewModel.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/CommandViewModel.cs
deleted file mode 100644
index c78d7bac679..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/CommandViewModel.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-#nullable enable
-
-namespace System.Windows.Forms.DataBinding.TestUtilities;
-
-public class CommandViewModel : ViewModelBase
-{
-    private bool _testCommandExecutionAbility;
-
-    public CommandViewModel()
-    {
-        _testCommand = new RelayCommand(TestCommandExecute, TestCommandCanExecute);
-    }
-
-    private RelayCommand? _testCommand;
-
-    public RelayCommand? TestCommand
-    {
-        get => _testCommand;
-        set => SetProperty(ref _testCommand, value);
-    }
-
-    public bool TestCommandExecutionAbility
-    {
-        get => _testCommandExecutionAbility;
-        
-        set
-        {
-            if (SetProperty(ref _testCommandExecutionAbility, value))
-            {
-                TestCommand?.RaiseCanExecuteChanged();
-            }
-        }
-    }
-
-    public object? CommandExecuteResult { get; private set; }
-
-    private void TestCommandExecute(object? parameter)
-    {
-        CommandExecuteResult = parameter;
-    }
-
-    private bool TestCommandCanExecute(object? parameter)
-    {
-        return TestCommandExecutionAbility;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/RelayCommand.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/RelayCommand.cs
deleted file mode 100644
index 7589b706917..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/RelayCommand.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-#nullable enable
-
-namespace System.Windows.Forms.DataBinding.TestUtilities;
-
-/// <summary>
-///  Basic implementation of a command in a ViewModel/UI-Controller which can be bound to a property of type
-///  <see cref="System.Windows.Input.ICommand"/>.
-/// </summary>
-public class RelayCommand : System.Windows.Input.ICommand
-{
-    public event EventHandler? CanExecuteChanged;
-
-    private readonly Action<object?> _execute;
-    private readonly Func<object?, bool>? _canExecute;
-
-    /// <summary>
-    ///  Creates an instance of this class and passes the command's execution delegate.
-    /// </summary>
-    /// <param name="execute">Action delegate which gets invoked with the <see cref="Execute(object?)"/> method.</param>
-    public RelayCommand(Action<object?> execute) : this(execute, null)
-    {
-    }
-
-    /// <summary>
-    ///  Creates an instance of this class and passes the command's execution delegate and the command's
-    ///  predicate for determining whether the command can be executed.
-    /// </summary>
-    /// <param name="execute">Action delegate which gets invoked with the <see cref="Execute(object?)"/> method.</param>
-    /// <param name="canExecute">Predicate for determining with <see cref="CanExecute(object?)"/>
-    /// whether the command can be executed.</param>
-    /// <exception cref="ArgumentNullException"></exception>
-    public RelayCommand(Action<object?> execute, Func<object?, bool>? canExecute)
-    {
-        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
-        _canExecute = canExecute;
-    }
-
-    /// <summary>
-    ///  Called to indicate that the execution context of the command has changed.
-    /// </summary>
-    public void RaiseCanExecuteChanged()
-        => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
-
-    /// <summary>
-    ///  Determines whether the command can be executed.
-    /// </summary>
-    public bool CanExecute(object? parameter)
-        => _canExecute is null || _canExecute(parameter);
-
-    /// <summary>
-    ///  Executes the command.
-    /// </summary>
-    public void Execute(object? parameter)
-        => _execute(parameter);
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/ViewModelBase.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/ViewModelBase.cs
deleted file mode 100644
index 8bbb4f64eee..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Mocks/DataBinding/ViewModelBase.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-using System.ComponentModel;
-using System.Runtime.CompilerServices;
-
-#nullable enable
-
-namespace System.Windows.Forms.DataBinding.TestUtilities;
-
-/// <summary>
-/// Provides the basic implementation of <see cref="INotifyPropertyChanged"/>
-/// to simplify the creation of UI ViewModels/Controllers.
-/// </summary>
-public abstract class ViewModelBase : INotifyPropertyChanged
-{
-    /// <summary>
-    /// Creates an instance of the BindableBase class.
-    /// </summary>
-    public ViewModelBase() : base()
-    {
-    }
-
-    /// <summary>
-    /// Event for property change notification.
-    /// </summary>
-    public event PropertyChangedEventHandler? PropertyChanged;
-
-    /// <summary>
-    /// Assigns a new value to a property and raises <see cref="PropertyChanged"/> if the value has actually changed.
-    /// </summary>
-    /// <typeparam name="T">Type of the property.</typeparam>
-    /// <param name="storage">Reference to the property backing field.</param>
-    /// <param name="value">New value for the property.</param>
-    /// <param name="propertyName">Name of the property used to notify listeners. This value
-    /// is optional and can be provided automatically when invoked with support of
-    /// <see cref="CallerMemberNameAttribute"/>.</param>
-    protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string? propertyName = null)
-    {
-        if (object.Equals(storage, value))
-        {
-            return false;
-        }
-
-        storage = value;
-        OnPropertyChanged(propertyName);
-        return true;
-    }
-
-    /// <summary>
-    /// Raises the <see cref="PropertyChanged"/> event.
-    /// </summary>
-    /// <param name="propertyName">Name of the property used to notify listeners. This value
-    /// is optional and can be provided automatically when invoked from compilers that support
-    /// <see cref="CallerMemberNameAttribute"/>.</param>
-    protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
-        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarAccessibleObjectTests.cs
deleted file mode 100644
index 809ffdabc45..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,436 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        int calendarIndex = 0;
-        string name = "Test name";
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, calendarIndex, name);
-
-        Assert.Equal(controlAccessibleObject, calendar.Parent);
-        Assert.Equal(calendarIndex, calendar.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(name, calendar.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_Bounds_ReturnsExpectedSize()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Rectangle bounds = calendar.Bounds;
-
-        Assert.Equal(217, bounds.Width);
-        Assert.Equal(135, bounds.Height);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_CalendarBodyAccessibleObject_IsNotNull()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-
-        Assert.NotNull(calendar.CalendarBodyAccessibleObject);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_CalendarHeaderAccessibleObject_IsNotNull()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-
-        Assert.NotNull(calendar.CalendarHeaderAccessibleObject);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(10, 10, 0, 0)]
-    [InlineData(250, 200, 0, 0)]
-    [InlineData(500, 200, 0, 0)]
-    [InlineData(500, 200, 1, 1)]
-    [InlineData(700, 200, 0, 0)]
-    [InlineData(700, 200, 1, 1)]
-    [InlineData(700, 200, 2, 2)]
-    [InlineData(250, 300, 0, 0)]
-    [InlineData(250, 300, 1, 0)]
-    [InlineData(250, 450, 0, 0)]
-    [InlineData(250, 450, 1, 0)]
-    [InlineData(250, 450, 2, 0)]
-    [InlineData(500, 300, 0, 0)]
-    [InlineData(500, 300, 1, 1)]
-    [InlineData(500, 300, 2, 0)]
-    [InlineData(500, 300, 3, 1)]
-    [InlineData(500, 450, 0, 0)]
-    [InlineData(500, 450, 1, 1)]
-    [InlineData(500, 450, 2, 0)]
-    [InlineData(500, 450, 3, 1)]
-    [InlineData(500, 450, 4, 0)]
-    [InlineData(500, 450, 5, 1)]
-    [InlineData(700, 450, 0, 0)]
-    [InlineData(700, 450, 1, 1)]
-    [InlineData(700, 450, 2, 2)]
-    [InlineData(700, 450, 3, 0)]
-    [InlineData(700, 450, 4, 1)]
-    [InlineData(700, 450, 5, 2)]
-    public void CalendarAccessibleObject_Column_ReturnsExpected(int width, int height, int calendarIndex, int expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.Size = new Size(width, height);
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, calendarIndex, "Test name");
-
-        Assert.Equal(expected, calendar.Column);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_ContainingGrid_IsControlAccessibleObject()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Equal(controlAccessibleObject, calendar.ContainingGrid);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CalendarAccessibleObject_DateRange_IsExpected_ForSpecificCalendar_InMonthView_TestData()
-    {
-        yield return new object[] { 0, new SelectionRange(new DateTime(2020, 12, 27), new DateTime(2021, 1, 31)) };
-        yield return new object[] { 1, new SelectionRange(new DateTime(2021, 2, 1), new DateTime(2021, 2, 28)) };
-        yield return new object[] { 2, new SelectionRange(new DateTime(2021, 3, 1), new DateTime(2021, 3, 31)) };
-        yield return new object[] { 3, new SelectionRange(new DateTime(2021, 4, 1), new DateTime(2021, 4, 30)) };
-        yield return new object[] { 4, new SelectionRange(new DateTime(2021, 5, 1), new DateTime(2021, 5, 31)) };
-        yield return new object[] { 5, new SelectionRange(new DateTime(2021, 6, 1), new DateTime(2021, 7, 10)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CalendarAccessibleObject_DateRange_IsExpected_ForSpecificCalendar_InMonthView_TestData))]
-    public void CalendarAccessibleObject_DateRange_IsExpected_ForSpecificCalendar_InMonthView(int calendarIndex, SelectionRange expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.FirstDayOfWeek = Day.Sunday;
-        control.Size = new Size(450, 450);
-        control.SelectionStart = new DateTime(2021, 1, 1);
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        LinkedListNode<CalendarAccessibleObject> calendarNode = controlAccessibleObject.CalendarsAccessibleObjects.First;
-
-        for (int i = 1; i <= calendarIndex; i++)
-        {
-            calendarNode = calendarNode.Next;
-        }
-
-        Assert.NotNull(calendarNode);
-
-        CalendarAccessibleObject calendar = calendarNode.Value;
-
-        Assert.Equal(expected.Start, calendar.DateRange.Start);
-        Assert.Equal(expected.End, calendar.DateRange.End);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarAccessibleObject_GetChildId_ReturnsExpected(int calendarIndex)
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, calendarIndex, "Test name");
-
-        Assert.Equal(calendarIndex + 3, calendar.GetChildId());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_GetColumnHeaderItems_ReturnsNull()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Null(calendar.GetColumnHeaderItems());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CalendarAccessibleObject_IsKeyboardFocusable_IsTrueIfEnabled(bool enabled)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.Enabled = enabled;
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Equal(enabled, calendar.GetPropertyValue(UiaCore.UIA.IsKeyboardFocusablePropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_GetRowHeaderItems_ReturnsNull()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Null(calendar.GetRowHeaderItems());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_GridItemPattern_IsSupported()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.True(calendar.IsPatternSupported(UiaCore.UIA.GridItemPatternId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_TableItemPattern_IsSupported()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.True(calendar.IsPatternSupported(UiaCore.UIA.TableItemPatternId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_Name_HasInitValue()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        string initName = "Test name";
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, initName);
-
-        Assert.Equal(initName, calendar.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_Parent_IsControlAccessibleObject()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Equal(controlAccessibleObject, calendar.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_Role_IsClient()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Equal(AccessibleRole.Client, calendar.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(2, 1)]
-    [InlineData(3, 1)]
-    [InlineData(4, 2)]
-    [InlineData(5, 2)]
-    public void CalendarAccessibleObject_Row_IsExpected(int calendarIndex, int expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.Size = new Size(450, 450);
-
-        control.CreateControl();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        LinkedListNode<CalendarAccessibleObject> calendarNode = controlAccessibleObject.CalendarsAccessibleObjects.First;
-
-        for (int i = 1; i <= calendarIndex; i++)
-        {
-            calendarNode = calendarNode.Next;
-        }
-
-        Assert.NotNull(calendarNode);
-
-        CalendarAccessibleObject calendar = calendarNode.Value;
-
-        Assert.Equal(expected, calendar.Row);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_State_IsNone_IfControlIsNotEnabled()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.Enabled = false;
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-
-        Assert.Equal(AccessibleStates.None, calendar.State);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-
-        Assert.Equal(controlAccessibleObject, calendar.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfSingleMonthView()
-    {
-        using MonthCalendar control = new();
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects?.First?.Value;
-
-        Assert.NotNull(calendar);
-        Assert.Equal(controlAccessibleObject.TodayLinkAccessibleObject, calendar.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected_IfMultiMonthView()
-    {
-        using MonthCalendar control = new()
-        {
-            CalendarDimensions = new Size { Width = 2, Height = 2 }
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        LinkedList<CalendarAccessibleObject> calendars = controlAccessibleObject.CalendarsAccessibleObjects;
-        CalendarAccessibleObject calendar1 = calendars?.First?.Value;
-        CalendarAccessibleObject calendar2 = calendars?.First?.Next?.Value;
-        CalendarAccessibleObject calendar3 = calendars?.First?.Next?.Next?.Value;
-        CalendarAccessibleObject calendar4 = calendars?.First?.Next?.Next?.Next?.Value;
-
-        Assert.NotNull(calendar1);
-        Assert.NotNull(calendar2);
-        Assert.NotNull(calendar3);
-        Assert.NotNull(calendar4);
-
-        Assert.Equal(calendar2, calendar1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(calendar3, calendar2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(calendar4, calendar3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(controlAccessibleObject.TodayLinkAccessibleObject, calendar4.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_IfSingleMonthView()
-    {
-        using MonthCalendar control = new();
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects?.First?.Value;
-
-        Assert.NotNull(calendar);
-        Assert.Equal(controlAccessibleObject.NextButtonAccessibleObject, calendar.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected_IfMultiMonthView()
-    {
-        using MonthCalendar control = new()
-        {
-            CalendarDimensions = new Size { Width = 2, Height = 2 }
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        LinkedList<CalendarAccessibleObject> calendars = controlAccessibleObject.CalendarsAccessibleObjects;
-        CalendarAccessibleObject calendar1 = calendars?.First?.Value;
-        CalendarAccessibleObject calendar2 = calendars?.First?.Next?.Value;
-        CalendarAccessibleObject calendar3 = calendars?.First?.Next?.Next?.Value;
-        CalendarAccessibleObject calendar4 = calendars?.First?.Next?.Next?.Next?.Value;
-
-        Assert.NotNull(calendar1);
-        Assert.NotNull(calendar2);
-        Assert.NotNull(calendar3);
-        Assert.NotNull(calendar4);
-
-        Assert.Equal(controlAccessibleObject.NextButtonAccessibleObject, calendar1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(calendar1, calendar2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(calendar2, calendar3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(calendar3, calendar4.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-
-        Assert.Equal(calendar.CalendarHeaderAccessibleObject, calendar.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-
-        Assert.Equal(calendar.CalendarBodyAccessibleObject, calendar.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarBodyAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarBodyAccessibleObjectTests.cs
deleted file mode 100644
index 82cdc55da2c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarBodyAccessibleObjectTests.cs
+++ /dev/null
@@ -1,246 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarBodyAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject accessibleObject = new(calendarAccessibleObject, controlAccessibleObject, 0);
-
-        Assert.Equal(calendarAccessibleObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_Bounds_HasExpectedSize()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(217, accessibleObject.Bounds.Width);
-        Assert.Equal(106, accessibleObject.Bounds.Height);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, 7)]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, 4)]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, 4)]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, 4)]
-    public void CalendarBodyAccessibleObject_ColumnCount_ReturnsExpected(int view, int expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        PInvoke.SendMessage(control, PInvoke.MCM_SETCURRENTVIEW, 0, view);
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(expected, accessibleObject.ColumnCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(2, accessibleObject.GetChildId());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR)]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE)]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY)]
-    public void CalendarBodyAccessibleObject_GetColumnHeaders_IsNull_IfViewIsNotMonth(int view)
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        PInvoke.SendMessage(control, PInvoke.MCM_SETCURRENTVIEW, 0, view);
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Null(accessibleObject.GetColumnHeaders());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_GetColumnHeaders_HasSevenCells()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(7, accessibleObject.GetColumnHeaders().Length); // Contains days of week
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_ControlType_IsTable()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(UiaCore.UIA.TableControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.GridPatternId)]
-    [InlineData((int)UiaCore.UIA.TablePatternId)]
-    public void CalendarBodyAccessibleObject_Supports_GridAndTablePatterns(int pattern)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)pattern));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, 0, "January 2021")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, 1, "February 2021")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, 2, "March 2021")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, 3, "April 2021")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, 0, "2021")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, 1, "2022")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, 2, "2023")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, 3, "2024")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, 0, "2020-2029")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, 1, "2030-2039")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, 2, "2040-2049")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, 3, "2050-2059")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, 0, "2000-2099")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, 1, "2100-2199")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, 2, "2200-2299")]
-    [InlineData((int)MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, 3, "2300-2399")]
-    public void CalendarBodyAccessibleObject_Name_IsExpected(int view, int calendarIndex, string expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-        control.FirstDayOfWeek = Day.Sunday;
-        control.Size = new Size(450, 450);
-        control.SelectionStart = new DateTime(2021, 1, 1);
-
-        control.CreateControl();
-        PInvoke.SendMessage(control, PInvoke.MCM_SETCURRENTVIEW, 0, (nint)view);
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        LinkedListNode<CalendarAccessibleObject> calendarNode = controlAccessibleObject.CalendarsAccessibleObjects.First;
-
-        for (int i = 1; i <= calendarIndex; i++)
-        {
-            calendarNode = calendarNode.Next;
-        }
-
-        Assert.NotNull(calendarNode);
-
-        CalendarBodyAccessibleObject calendarBody = calendarNode.Value.CalendarBodyAccessibleObject;
-
-        Assert.Equal(expected, calendarBody.Name);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_Parent_IsCalendarAccessibleObject()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject accessibleObject = new(calendarAccessibleObject, controlAccessibleObject, 0);
-
-        Assert.Equal(calendarAccessibleObject, accessibleObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_Role_IsTable()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(AccessibleRole.Table, accessibleObject.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_State_IsDefault()
-    {
-        using MonthCalendar control = new MonthCalendar();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control);
-
-        Assert.Equal(AccessibleStates.Default, accessibleObject.State);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject calendarBody = new(calendar, controlAccessibleObject, 0);
-
-        Assert.Equal(calendar, calendarBody.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_FragmentNavigate_NextSibling_ReturnsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control, 0);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject calendarBody = new(calendar, controlAccessibleObject, 0);
-
-        AccessibleObject expected = calendar.CalendarHeaderAccessibleObject;
-
-        Assert.Equal(expected, calendarBody.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarBodyAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarBodyAccessibleObject accessibleObject = CreateCalendarBodyAccessibleObject(control, 0);
-
-        AccessibleObject firstRow = accessibleObject.RowsAccessibleObjects?.First();
-        AccessibleObject lastRow = accessibleObject.RowsAccessibleObjects?.Last();
-
-        Assert.Equal(firstRow, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(lastRow, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private CalendarBodyAccessibleObject CreateCalendarBodyAccessibleObject(MonthCalendar control, int calendarIndex = 0)
-    {
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-
-        return bodyAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarButtonAccessibleObjectTests.cs
deleted file mode 100644
index 7bd994c3662..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, buttonAccessibleObject.Parent);
-        Assert.Equal(controlAccessibleObject, buttonAccessibleObject.TestAccessor().Dynamic._monthCalendarAccessibleObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        Assert.Equal(SR.AccessibleActionClick, buttonAccessibleObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        Assert.Equal(SR.AccessibleActionClick, buttonAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_ControlType_IsButton()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        UiaCore.UIA actual = (UiaCore.UIA)buttonAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_Supports_InvokePattern()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        bool actual = buttonAccessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId);
-
-        Assert.True(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_Parent_IsCalendarAccessibleObject()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        AccessibleObject actual = buttonAccessibleObject.Parent;
-
-        Assert.Equal(controlAccessibleObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarButtonAccessibleObject_Role_IsPushButton()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarButtonAccessibleObject buttonAccessibleObject = new SubCalendarButtonAccessibleObject(controlAccessibleObject);
-
-        AccessibleRole actual = buttonAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.PushButton, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class SubCalendarButtonAccessibleObject : CalendarButtonAccessibleObject
-    {
-        public SubCalendarButtonAccessibleObject(MonthCalendarAccessibleObject calendarAccessibleObject)
-            : base(calendarAccessibleObject)
-        { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarCellAccessibleObjectTests.cs
deleted file mode 100644
index 43682ec370f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,252 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-[UseDefaultXunitCulture]
-public class MonthCalendar_CalendarCellAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control);
-
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._rowIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._columnIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CalendarCellAccessibleObject_Bounds_ReturnsExpected_TestData()
-    {
-        yield return new object[] { 0, 0, new Rectangle(13, 81, 31, 15) };
-        yield return new object[] { 0, 1, new Rectangle(44, 81, 31, 15) };
-        yield return new object[] { 0, 2, new Rectangle(75, 81, 31, 15) };
-        yield return new object[] { 1, 0, new Rectangle(13, 96, 31, 15) };
-        yield return new object[] { 1, 1, new Rectangle(44, 96, 31, 15) };
-        yield return new object[] { 1, 2, new Rectangle(75, 96, 31, 15) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CalendarCellAccessibleObject_Bounds_ReturnsExpected_TestData))]
-    public void CalendarCellAccessibleObject_Bounds_ReturnsExpected(int rowIndex, int columnIndex, Rectangle expected)
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, 0, rowIndex, columnIndex);
-
-        control.CreateControl();
-        Rectangle actual = cellAccessibleObject.Bounds;
-
-        Assert.Equal(expected, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarCellAccessibleObject_CalendarIndex_ReturnsExpected(int calendarIndex)
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, calendarIndex);
-
-        Assert.Equal(calendarIndex, cellAccessibleObject.CalendarIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarCellAccessibleObject_Column_ReturnsExpected(int columnIndex)
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, 0, 0, columnIndex);
-
-        Assert.Equal(columnIndex, cellAccessibleObject.Column);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_ContainingGrid_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, 0, 0);
-        CalendarCellAccessibleObject cellAccessibleObject = new(rowAccessibleObject, bodyAccessibleObject, controlAccessibleObject, 0, 0, 0);
-
-        Assert.Equal(bodyAccessibleObject, cellAccessibleObject.ContainingGrid);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarCellAccessibleObject_GetChildId_ReturnsExpected(int columnIndex)
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, 0, 0, columnIndex);
-
-        int actual = cellAccessibleObject.GetChildId();
-
-        Assert.Equal(columnIndex + 1, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private CalendarCellAccessibleObject CreateCalendarCellAccessibleObject(MonthCalendar control, int calendarIndex = 0, int rowIndex = 0, int columnIndex = 0)
-    {
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex);
-        CalendarCellAccessibleObject cellAccessibleObject = new(rowAccessibleObject, bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex, columnIndex);
-
-        return cellAccessibleObject;
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_Name_IsEmptyString_IfControlIsNotCreated()
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, 0, 0, 0);
-
-        Assert.Empty(cellAccessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CalendarCellAccessibleObject_Name_ReturnsExpected_TestData()
-    {
-        yield return new object[] { MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, "Wednesday, June 16, 2021" };
-        yield return new object[] { MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_YEAR, "November 2021" };
-        yield return new object[] { MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_DECADE, "2029" };
-        yield return new object[] { MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_CENTURY, "2090 - 2099" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CalendarCellAccessibleObject_Name_ReturnsExpected_TestData))]
-    public void CalendarCellAccessibleObject_Name_ReturnsExpected(int view, string expected)
-    {
-        using MonthCalendar control = new();
-        control.FirstDayOfWeek = Day.Monday;
-        control.SelectionStart = new DateTime(2021, 6, 16); // Set a date to have a stable test case
-
-        control.CreateControl();
-        PInvoke.SendMessage(control, PInvoke.MCM_SETCURRENTVIEW, 0, view);
-
-        CalendarCellAccessibleObject cellAccessibleObject = CreateCalendarCellAccessibleObject(control, 0, 2, 2);
-
-        Assert.Equal(expected, cellAccessibleObject.Name);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarBodyAccessibleObject body = new(calendar, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject row = new(body, controlAccessibleObject, 0, 2);
-        CalendarCellAccessibleObject cell = new(row, body, controlAccessibleObject, 0, 0, 0);
-
-        Assert.Equal(row, cell.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new()
-        {
-            SelectionStart = new DateTime(2022, 10, 1) // Set a date to have a stable test case
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject secondWeek = body.RowsAccessibleObjects?.First?.Next?.Next?.Value;
-        Assert.NotNull(secondWeek);
-
-        CalendarCellAccessibleObject sunday = secondWeek.CellsAccessibleObjects?.First?.Value;
-        CalendarCellAccessibleObject monday = secondWeek.CellsAccessibleObjects?.First?.Next?.Value;
-        CalendarCellAccessibleObject tuesday = secondWeek.CellsAccessibleObjects?.First?.Next?.Next?.Value;
-        CalendarCellAccessibleObject friday = secondWeek.CellsAccessibleObjects?.Last?.Previous?.Value;
-        CalendarCellAccessibleObject saturday = secondWeek.CellsAccessibleObjects?.Last?.Value;
-
-        Assert.NotNull(sunday);
-        Assert.NotNull(monday);
-        Assert.NotNull(tuesday);
-        Assert.NotNull(friday);
-        Assert.NotNull(saturday);
-
-        Assert.Null(sunday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(monday, sunday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(sunday, monday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(tuesday, monday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(friday, saturday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(saturday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfWeekNumbersVisible()
-    {
-        using MonthCalendar control = new()
-        {
-            ShowWeekNumbers = true,
-            SelectionStart = new DateTime(2022, 10, 1) // Set a date to have a stable test case
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject secondWeek = body.RowsAccessibleObjects?.First?.Next?.Next?.Value;
-        Assert.NotNull(secondWeek);
-
-        CalendarWeekNumberCellAccessibleObject weekNumber = secondWeek.WeekNumberCellAccessibleObject;
-        CalendarCellAccessibleObject sunday = secondWeek.CellsAccessibleObjects?.First?.Value;
-        CalendarCellAccessibleObject monday = secondWeek.CellsAccessibleObjects?.First?.Next?.Value;
-
-        Assert.NotNull(weekNumber);
-        Assert.NotNull(sunday);
-        Assert.NotNull(monday);
-
-        Assert.Equal(weekNumber, sunday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(monday, sunday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarCellAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarCellAccessibleObject cell = CreateCalendarCellAccessibleObject(control, 0, 0, 0);
-
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarDayOfWeekCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarDayOfWeekCellAccessibleObjectTests.cs
deleted file mode 100644
index b52dca2c930..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarDayOfWeekCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,212 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarDayOfWeekCellAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._rowIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._columnIndex);
-        Assert.Equal("Test name", cellAccessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_DateRange_IsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        Assert.Null(cellAccessibleObject.DateRange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_DefaultAction_IsEmpty()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        Assert.Empty(cellAccessibleObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_Description_IsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        Assert.Null(cellAccessibleObject.Description);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_ControlType_IsHeader()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        UiaCore.UIA actual = (UiaCore.UIA)cellAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.HeaderControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_HasKeyboardFocus_IsFalse()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        bool actual = (bool)cellAccessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_Role_IsColumnHeader()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        AccessibleRole actual = cellAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.ColumnHeader, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_State_IsNone()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = CreateCalendarDayOfWeekCellCellAccessibleObject(control);
-
-        AccessibleStates actual = cellAccessibleObject.State;
-
-        Assert.Equal(AccessibleStates.None, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarBodyAccessibleObject body = new(calendar, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject row = new(body, controlAccessibleObject, 0, 0);
-        CalendarDayOfWeekCellAccessibleObject cell = new(row, body, controlAccessibleObject, 0, 0, 0, "");
-
-        Assert.Equal(row, cell.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new()
-        {
-            SelectionStart = new DateTime(2022, 10, 1) // Set a date to have a stable test case
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject daysOfWeekRow = body.RowsAccessibleObjects?.First?.Value;
-        Assert.NotNull(daysOfWeekRow);
-
-        LinkedList<CalendarCellAccessibleObject> days = daysOfWeekRow.CellsAccessibleObjects;
-        CalendarDayOfWeekCellAccessibleObject sunday = days?.First?.Value as CalendarDayOfWeekCellAccessibleObject;
-        CalendarDayOfWeekCellAccessibleObject monday = days?.First?.Next?.Value as CalendarDayOfWeekCellAccessibleObject;
-        CalendarDayOfWeekCellAccessibleObject tuesday = days?.First?.Next?.Next?.Value as CalendarDayOfWeekCellAccessibleObject;
-        CalendarDayOfWeekCellAccessibleObject friday = days?.Last?.Previous?.Value as CalendarDayOfWeekCellAccessibleObject;
-        CalendarDayOfWeekCellAccessibleObject saturday = days?.Last?.Value as CalendarDayOfWeekCellAccessibleObject;
-
-        Assert.NotNull(sunday);
-        Assert.NotNull(monday);
-        Assert.NotNull(tuesday);
-        Assert.NotNull(friday);
-        Assert.NotNull(saturday);
-
-        Assert.Null(sunday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(monday, sunday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(sunday, monday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(tuesday, monday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(friday, saturday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(saturday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfWeekNumbersVisible()
-    {
-        using MonthCalendar control = new()
-        {
-            ShowWeekNumbers = true,
-            SelectionStart = new DateTime(2022, 10, 1) // Set a date to have a stable test case
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject daysOfWeekRow = body.RowsAccessibleObjects?.First?.Value;
-        Assert.NotNull(daysOfWeekRow);
-
-        LinkedList<CalendarCellAccessibleObject> days = daysOfWeekRow.CellsAccessibleObjects;
-        CalendarDayOfWeekCellAccessibleObject sunday = days?.First?.Value as CalendarDayOfWeekCellAccessibleObject;
-        CalendarDayOfWeekCellAccessibleObject monday = days?.First?.Next?.Value as CalendarDayOfWeekCellAccessibleObject;
-
-        Assert.NotNull(sunday);
-        Assert.NotNull(monday);
-
-        Assert.Null(sunday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(monday, sunday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarDayOfWeekCellAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarDayOfWeekCellAccessibleObject cell = CreateCalendarDayOfWeekCellCellAccessibleObject(control, 0, 0, 0);
-
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private CalendarDayOfWeekCellAccessibleObject CreateCalendarDayOfWeekCellCellAccessibleObject(MonthCalendar control, int calendarIndex = 0, int rowIndex = 0, int columnIndex = 0)
-    {
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex);
-        CalendarDayOfWeekCellAccessibleObject cellAccessibleObject = new(rowAccessibleObject, bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex, columnIndex, "Test name");
-
-        return cellAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarHeaderAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarHeaderAccessibleObjectTests.cs
deleted file mode 100644
index 7d6b6f0832a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarHeaderAccessibleObjectTests.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarHeaderAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        CalendarHeaderAccessibleObject headerAccessibleObject = CreateCalendarHeaderAccessibleObject(control);
-
-        Assert.Equal(0, headerAccessibleObject.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(4, headerAccessibleObject.RuntimeId.Length);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarHeaderAccessibleObject headerAccessibleObject = CreateCalendarHeaderAccessibleObject(control);
-
-        int actual = headerAccessibleObject.GetChildId();
-
-        Assert.Equal(1, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_Name_IsEmpty_IfControlIsNotCreated()
-    {
-        using MonthCalendar control = new();
-        CalendarHeaderAccessibleObject headerAccessibleObject = CreateCalendarHeaderAccessibleObject(control);
-
-        string actual = headerAccessibleObject.Name;
-
-        Assert.Empty(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_Name_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-
-        control.CreateControl();
-        control.SetSelectionRange(new DateTime(2020, 8, 19), new DateTime(2020, 8, 19));
-        CalendarHeaderAccessibleObject headerAccessibleObject = CreateCalendarHeaderAccessibleObject(control);
-        string actual = headerAccessibleObject.Name;
-
-        Assert.Equal("August 2020", actual);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
-        CalendarHeaderAccessibleObject headerAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, 0);
-
-        AccessibleObject actual = headerAccessibleObject.Parent;
-
-        Assert.Equal(calendarAccessibleObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarHeaderAccessibleObject header = new(calendar, controlAccessibleObject, 0);
-
-        Assert.Equal(calendar, header.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarHeaderAccessibleObject header = new(calendar, controlAccessibleObject, 0);
-
-        Assert.Equal(calendar.CalendarBodyAccessibleObject, header.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(header.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarHeaderAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarHeaderAccessibleObject header = CreateCalendarHeaderAccessibleObject(control, 0);
-
-        Assert.Null(header.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(header.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private CalendarHeaderAccessibleObject CreateCalendarHeaderAccessibleObject(MonthCalendar control, int calendarIndex = 0)
-    {
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarHeaderAccessibleObject headerAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-
-        return headerAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarNextButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarNextButtonAccessibleObjectTests.cs
deleted file mode 100644
index 3ca8914c19c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarNextButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarNextButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarNextButtonAccessibleObject nextButtonAccessibleObject = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, nextButtonAccessibleObject.TestAccessor().Dynamic._monthCalendarAccessibleObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_Description_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarNextButtonAccessibleObject nextButtonAccessibleObject = new(controlAccessibleObject);
-
-        string actual = nextButtonAccessibleObject.Description;
-
-        Assert.Equal(SR.CalendarNextButtonAccessibleObjectDescription, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarNextButtonAccessibleObject nextButtonAccessibleObject = new(controlAccessibleObject);
-
-        int actual = nextButtonAccessibleObject.GetChildId();
-
-        Assert.Equal(2, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_Name_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarNextButtonAccessibleObject nextButtonAccessibleObject = new(controlAccessibleObject);
-
-        string actual = nextButtonAccessibleObject.Name;
-
-        Assert.Equal(SR.MonthCalendarNextButtonAccessibleName, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarNextButtonAccessibleObject nextButton = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, nextButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarNextButtonAccessibleObject nextButton = new(controlAccessibleObject);
-
-        AccessibleObject previousButton = controlAccessibleObject.PreviousButtonAccessibleObject;
-        AccessibleObject firstCalendar = controlAccessibleObject.CalendarsAccessibleObjects?.First?.Value;
-
-        Assert.Equal(previousButton, nextButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(firstCalendar, nextButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarNextButtonAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarNextButtonAccessibleObject nextButton = new(controlAccessibleObject);
-
-        Assert.Null(nextButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(nextButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarPreviousButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarPreviousButtonAccessibleObjectTests.cs
deleted file mode 100644
index ed3b648a602..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarPreviousButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarPreviousButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarPreviousButtonAccessibleObject previousButtonAccessibleObject = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, previousButtonAccessibleObject.TestAccessor().Dynamic._monthCalendarAccessibleObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_Description_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarPreviousButtonAccessibleObject previousButtonAccessibleObject = new(controlAccessibleObject);
-
-        string actual = previousButtonAccessibleObject.Description;
-
-        Assert.Equal(SR.CalendarPreviousButtonAccessibleObjectDescription, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarPreviousButtonAccessibleObject previousButtonAccessibleObject = new(controlAccessibleObject);
-
-        int actual = previousButtonAccessibleObject.GetChildId();
-
-        Assert.Equal(1, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_Name_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarPreviousButtonAccessibleObject previousButtonAccessibleObject = new(controlAccessibleObject);
-
-        string actual = previousButtonAccessibleObject.Name;
-
-        Assert.Equal(SR.MonthCalendarPreviousButtonAccessibleName, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarPreviousButtonAccessibleObject prevButton = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, prevButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarPreviousButtonAccessibleObject prevButton = new(controlAccessibleObject);
-
-        AccessibleObject nextButton = controlAccessibleObject.NextButtonAccessibleObject;
-
-        Assert.Null(prevButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(nextButton, prevButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarPreviousButtonAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarPreviousButtonAccessibleObject prevButton = new(controlAccessibleObject);
-
-        Assert.Null(prevButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(prevButton.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarRowAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarRowAccessibleObjectTests.cs
deleted file mode 100644
index 36d66ff09a5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarRowAccessibleObjectTests.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarRowAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control);
-
-        Assert.Equal(0, rowAccessibleObject.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(0, rowAccessibleObject.TestAccessor().Dynamic._rowIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarRowAccessibleObject_GetChildId_ReturnExpected(int rowIndex)
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control, 0, rowIndex);
-
-        int actual = rowAccessibleObject.GetChildId();
-
-        Assert.Equal(rowIndex + 1, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_ControlType_IsPane()
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control);
-
-        UiaCore.UIA actual = (UiaCore.UIA)rowAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_Name_IsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control);
-
-        string actual = rowAccessibleObject.Name;
-
-        Assert.Null(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, 0, 0);
-
-        AccessibleObject actual = rowAccessibleObject.Parent;
-
-        Assert.Equal(bodyAccessibleObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_Role_IsRow()
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control);
-
-        AccessibleRole actual = rowAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Row, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void CalendarRowAccessibleObject_Row_ReturnsExpected(int rowIndex)
-    {
-        using MonthCalendar control = new();
-        CalendarRowAccessibleObject rowAccessibleObject = CreateCalendarRowAccessibleObject(control, 0, rowIndex);
-
-        int actual = rowAccessibleObject.Row;
-
-        Assert.Equal(rowIndex, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarBodyAccessibleObject body = new(calendar, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject row = new(body, controlAccessibleObject, 0, 2);
-
-        Assert.Equal(body, row.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject daysOfWeekRow = body.RowsAccessibleObjects?.First?.Value;
-        Assert.NotNull(daysOfWeekRow);
-
-        CalendarRowAccessibleObject firstWeek = body.RowsAccessibleObjects?.First?.Next?.Value;
-        Assert.NotNull(firstWeek);
-
-        CalendarRowAccessibleObject secondWeek = body.RowsAccessibleObjects?.First?.Next?.Next?.Value;
-        Assert.NotNull(secondWeek);
-
-        CalendarRowAccessibleObject thirdWeek = body.RowsAccessibleObjects?.First?.Next?.Next?.Next?.Value;
-        Assert.NotNull(thirdWeek);
-
-        Assert.Null(daysOfWeekRow.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(daysOfWeekRow, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(firstWeek, secondWeek.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(firstWeek, daysOfWeekRow.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(secondWeek, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(thirdWeek, secondWeek.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject firstWeek = body.RowsAccessibleObjects?.First?.Next?.Value;
-        Assert.NotNull(firstWeek);
-
-        CalendarCellAccessibleObject sunday = firstWeek.CellsAccessibleObjects?.First?.Value;
-        CalendarCellAccessibleObject saturday = firstWeek.CellsAccessibleObjects?.Last?.Value;
-
-        Assert.Equal(sunday, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(saturday, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void CalendarRowAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfWeekNumbersVisible()
-    {
-        using MonthCalendar control = new() { ShowWeekNumbers = true };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject firstWeek = body.RowsAccessibleObjects?.First?.Next?.Value;
-        Assert.NotNull(firstWeek);
-
-        CalendarWeekNumberCellAccessibleObject weekNumber = firstWeek.WeekNumberCellAccessibleObject;
-        CalendarCellAccessibleObject saturday = firstWeek.CellsAccessibleObjects?.Last?.Value;
-
-        Assert.Equal(weekNumber, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(saturday, firstWeek.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    private CalendarRowAccessibleObject CreateCalendarRowAccessibleObject(MonthCalendar control, int calendarIndex = 0, int rowIndex = 0)
-    {
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex);
-
-        return rowAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarTodayLinkAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarTodayLinkAccessibleObjectTests.cs
deleted file mode 100644
index eeb9c1c48ab..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarTodayLinkAccessibleObjectTests.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarTodayLinkAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarTodayLinkAccessibleObject todayLinkAccessibleObject = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, todayLinkAccessibleObject.TestAccessor().Dynamic._monthCalendarAccessibleObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_Description_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarTodayLinkAccessibleObject todayLinkAccessibleObject = new(controlAccessibleObject);
-
-        string actual = todayLinkAccessibleObject.Description;
-
-        Assert.Equal(SR.CalendarTodayLinkAccessibleObjectDescription, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarTodayLinkAccessibleObject todayLinkAccessibleObject = new(controlAccessibleObject);
-
-        int expected = 3 + controlAccessibleObject.CalendarsAccessibleObjects.Count;
-        int actual = todayLinkAccessibleObject.GetChildId();
-
-        Assert.Equal(expected, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_GetChildId_ReturnsExpected_IfCalendarsAccessibleObjectsIsNull()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarTodayLinkAccessibleObject todayLinkAccessibleObject = new(controlAccessibleObject);
-
-        int actual = todayLinkAccessibleObject.GetChildId();
-
-        Assert.Null(controlAccessibleObject.CalendarsAccessibleObjects);
-        Assert.Equal(-1, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_Name_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarTodayLinkAccessibleObject todayLinkAccessibleObject = new(controlAccessibleObject);
-
-        string expected = string.Format(SR.MonthCalendarTodayButtonAccessibleName,
-            DateTime.Today.ToShortDateString());
-        string actual = todayLinkAccessibleObject.Name;
-
-        Assert.Equal(expected, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarTodayLinkAccessibleObject todayLink = new(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, todayLink.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarTodayLinkAccessibleObject todayLink = new(controlAccessibleObject);
-
-        AccessibleObject lastCalendar = controlAccessibleObject.CalendarsAccessibleObjects?.Last?.Value;
-
-        Assert.Equal(lastCalendar, todayLink.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(todayLink.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarTodayLinkAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        MonthCalendarAccessibleObject controlAccessibleObject = new(control);
-        CalendarTodayLinkAccessibleObject todayLink = new(controlAccessibleObject);
-
-        Assert.Null(todayLink.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(todayLink.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarWeekNumberCellAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarWeekNumberCellAccessibleObjectTests.cs
deleted file mode 100644
index 061dd545662..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.CalendarWeekNumberCellAccessibleObjectTests.cs
+++ /dev/null
@@ -1,209 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_CalendarWeekNumberCellAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._calendarIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._rowIndex);
-        Assert.Equal(0, cellAccessibleObject.TestAccessor().Dynamic._columnIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_DateRange_IsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        Assert.Null(cellAccessibleObject.DateRange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_DefaultAction_IsEmpty()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        Assert.Empty(cellAccessibleObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_Description_IsNull()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        Assert.Null(cellAccessibleObject.Description);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_GetChildId_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        int actual = cellAccessibleObject.GetChildId();
-
-        Assert.Equal(0, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_ControlType_IsHeader()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        UiaCore.UIA actual = (UiaCore.UIA)cellAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.HeaderControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_HasKeyboardFocus_IsFalse()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        bool actual = (bool)cellAccessibleObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_Role_IsRowHeader()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        AccessibleRole actual = cellAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.RowHeader, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_State_IsNone()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = CreateCalendarWeekNumberCellAccessibleObject(control);
-
-        AccessibleStates actual = cellAccessibleObject.State;
-
-        Assert.Equal(AccessibleStates.None, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendar = new(controlAccessibleObject, 0, "");
-        CalendarBodyAccessibleObject body = new(calendar, controlAccessibleObject, 0);
-        CalendarRowAccessibleObject row = new(body, controlAccessibleObject, 0, 0);
-        CalendarWeekNumberCellAccessibleObject cell = new(row, body, controlAccessibleObject, 0, 0, 0, "");
-
-        Assert.Equal(row, cell.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using MonthCalendar control = new()
-        {
-            ShowWeekNumbers = true
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject secondRow = body.RowsAccessibleObjects?.First?.Next?.Next.Value;
-        Assert.NotNull(secondRow);
-
-        CalendarWeekNumberCellAccessibleObject weekNumber = secondRow.WeekNumberCellAccessibleObject;
-        CalendarCellAccessibleObject sunday = secondRow.CellsAccessibleObjects?.First?.Value as CalendarCellAccessibleObject;
-
-        Assert.NotNull(weekNumber);
-        Assert.NotNull(sunday);
-
-        Assert.Null(weekNumber.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(sunday, weekNumber.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_IfWeekNumbersVisible()
-    {
-        using MonthCalendar control = new()
-        {
-            ShowWeekNumbers = true,
-            SelectionStart = new DateTime(2022, 10, 1) // Set a date to have a stable test case
-        };
-        control.CreateControl();
-
-        var controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-
-        CalendarAccessibleObject calendar = controlAccessibleObject.CalendarsAccessibleObjects.First?.Value;
-        Assert.NotNull(calendar);
-
-        CalendarBodyAccessibleObject body = calendar.CalendarBodyAccessibleObject;
-        Assert.NotNull(body);
-
-        CalendarRowAccessibleObject daysOfWeekRow = body.RowsAccessibleObjects?.First?.Value;
-        Assert.NotNull(daysOfWeekRow);
-
-        CalendarCellAccessibleObject sunday = daysOfWeekRow.CellsAccessibleObjects?.First?.Value;
-        CalendarCellAccessibleObject monday = daysOfWeekRow.CellsAccessibleObjects?.First?.Next?.Value;
-
-        Assert.NotNull(sunday);
-        Assert.NotNull(monday);
-
-        Assert.Null(sunday.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(monday, sunday.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void CalendarWeekNumberCellAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using MonthCalendar control = new();
-        CalendarWeekNumberCellAccessibleObject cell = CreateCalendarWeekNumberCellAccessibleObject(control, 0, 0, 0);
-
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(cell.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private CalendarWeekNumberCellAccessibleObject CreateCalendarWeekNumberCellAccessibleObject(MonthCalendar control, int calendarIndex = 0, int rowIndex = 0, int columnIndex = 0)
-    {
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        CalendarAccessibleObject calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
-        CalendarBodyAccessibleObject bodyAccessibleObject = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
-        CalendarRowAccessibleObject rowAccessibleObject = new(bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex);
-        CalendarWeekNumberCellAccessibleObject cellAccessibleObject = new(rowAccessibleObject, bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex, columnIndex, "12");
-
-        return cellAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarAccessibleObjectTests.cs
deleted file mode 100644
index e099fe6d00a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_MonthCalendarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_ctor_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new MonthCalendarAccessibleObject(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test name", (int)UiaCore.UIA.CalendarControlTypeId)]
-    [InlineData(null, (int)UiaCore.UIA.CalendarControlTypeId)]
-    public void MonthCalendarAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(string name, int expected)
-    {
-        // UIA is less accessible than the test
-        // so we have to use "int" type here for "expected" argument
-        using MonthCalendar monthCalendar = new MonthCalendar()
-        {
-            AccessibleName = name
-        };
-        // AccessibleRole is not set = Default
-
-        object actual = monthCalendar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal((UiaCore.UIA)expected, actual);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_Role_IsExpected_ByDefault()
-    {
-        using MonthCalendar monthCalendar = new MonthCalendar();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = monthCalendar.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Table, actual);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MonthCalendarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void MonthCalendarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using MonthCalendar monthCalendar = new MonthCalendar();
-        monthCalendar.AccessibleRole = role;
-
-        object actual = monthCalendar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using MonthCalendar monthCalendar = new MonthCalendar();
-        DateTime dt = new DateTime(2000, 1, 1);
-        monthCalendar.SetDate(dt);
-
-        Assert.Equal(dt.ToLongDateString(), monthCalendar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-        Assert.Equal(AccessibleStates.None, monthCalendar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleStatePropertyId));
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MonthCalendarAccessibleObject_ShowToday_IsExpected(bool showToday)
-    {
-        using MonthCalendar monthCalendar = new();
-        monthCalendar.ShowToday = showToday;
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.Equal(showToday, accessibleObject.ShowToday);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_TodayDate_IsToday()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.Equal(DateTime.Today, accessibleObject.TodayDate);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_ColumnCount_IsMinusOne_IfHandleIsNotCreated()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.False(monthCalendar.IsHandleCreated);
-        Assert.Equal(-1, accessibleObject.ColumnCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_RowCount_IsZero_IfHandleIsNotCreated()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.False(monthCalendar.IsHandleCreated);
-        Assert.Equal(0, accessibleObject.RowCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_CalendarsAccessibleObjects_IsNull_IfHandleIsNotCreated()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.False(monthCalendar.IsHandleCreated);
-        Assert.Null(accessibleObject.CalendarsAccessibleObjects);
-    }
-
-    public static IEnumerable<object[]> MonthCalendarAccessibleObject_Date_ReturnsExpected_TestData()
-    {
-        yield return new object[] { new DateTime(2000, 1, 1) };
-        yield return new object[] { DateTime.Today };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendarAccessibleObject_Date_ReturnsExpected_TestData))]
-    public void MonthCalendarAccessibleObject_MinDate_IsExpected(DateTime minDate)
-    {
-        using MonthCalendar monthCalendar = new();
-        monthCalendar.MinDate = minDate;
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.Equal(DateTimePicker.EffectiveMinDate(minDate), accessibleObject.MinDate);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendarAccessibleObject_Date_ReturnsExpected_TestData))]
-    public void MonthCalendarAccessibleObject_MaxDate_IsExpected(DateTime maxDate)
-    {
-        using MonthCalendar monthCalendar = new();
-        monthCalendar.MaxDate = maxDate;
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.Equal(DateTimePicker.EffectiveMaxDate(maxDate), accessibleObject.MaxDate);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MonthCalendarAccessibleObject_CastDayToDayOfWeek_ReturnsExpected_TestData()
-    {
-        yield return new object[] { Day.Monday, DayOfWeek.Monday };
-        yield return new object[] { Day.Tuesday, DayOfWeek.Tuesday };
-        yield return new object[] { Day.Wednesday, DayOfWeek.Wednesday };
-        yield return new object[] { Day.Thursday, DayOfWeek.Thursday };
-        yield return new object[] { Day.Friday, DayOfWeek.Friday };
-        yield return new object[] { Day.Saturday, DayOfWeek.Saturday };
-        yield return new object[] { Day.Sunday, DayOfWeek.Sunday };
-        yield return new object[] { Day.Default, DayOfWeek.Sunday };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendarAccessibleObject_CastDayToDayOfWeek_ReturnsExpected_TestData))]
-    public void MonthCalendarAccessibleObject_CastDayToDayOfWeek_IsExpected(Day day, DayOfWeek expected)
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        DayOfWeek actual = accessibleObject.TestAccessor().Dynamic.CastDayToDayOfWeek(day);
-
-        Assert.Equal(expected, actual);
-        Assert.False(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MonthCalendarAccessibleObject_GetDisplayRange_IsNull_IfHandleIsNotCreated(bool visible)
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        Assert.False(monthCalendar.IsHandleCreated);
-        Assert.Null(accessibleObject.GetDisplayRange(visible));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void MonthCalendarAccessibleObject_GetDisplayRange_IsExpected(bool visible)
-    {
-        using MonthCalendar monthCalendar = new();
-        monthCalendar.CreateControl();
-        var accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
-
-        SelectionRange expected = monthCalendar.GetDisplayRange(visible);
-        SelectionRange actual = accessibleObject.GetDisplayRange(visible);
-
-        Assert.NotNull(actual);
-        Assert.Equal(expected.Start, actual.Start);
-        Assert.Equal(expected.End, actual.End);
-        Assert.True(monthCalendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_FragmentNavigate_Parent_Returns_Expected()
-    {
-        using MonthCalendar monthCalendar = new();
-        MonthCalendarAccessibleObject accessibleObject = new(monthCalendar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_FragmentNavigate_Sibling_Returns_Expected()
-    {
-        using MonthCalendar monthCalendar = new();
-        MonthCalendarAccessibleObject accessibleObject = new(monthCalendar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_FragmentNavigate_FirstChild_Returns_Expected()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = new MonthCalendarAccessibleObject(monthCalendar);
-
-        AccessibleObject previousButton = accessibleObject.PreviousButtonAccessibleObject;
-
-        Assert.Equal(previousButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_FragmentNavigate_LastChild_Returns_Expected()
-    {
-        using MonthCalendar monthCalendar = new();
-        var accessibleObject = new MonthCalendarAccessibleObject(monthCalendar);
-
-        AccessibleObject todayLink = accessibleObject.TodayLinkAccessibleObject;
-
-        Assert.Equal(todayLink, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarAccessibleObject_FragmentNavigate_LastChild_Returns_Expected_IfTodayLinkHidden()
-    {
-        using MonthCalendar monthCalendar = new() { ShowToday = false };
-        var accessibleObject = new MonthCalendarAccessibleObject(monthCalendar);
-
-        AccessibleObject lastCalendar = accessibleObject.CalendarsAccessibleObjects?.Last?.Value;
-
-        Assert.Equal(lastCalendar, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarChildAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarChildAccessibleObjectTests.cs
deleted file mode 100644
index 367fc9acb65..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendar.MonthCalendarChildAccessibleObjectTests.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.MonthCalendar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class MonthCalendar_MonthCalendarChildAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_ctor_ThrowsException_IfMonthCalendarAccessibleObjectIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new SubObject(null));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_ctor_default()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.HasKeyboardFocusPropertyId, false)]
-    [InlineData((int)UiaCore.UIA.IsEnabledPropertyId, true)]
-    [InlineData((int)UiaCore.UIA.IsKeyboardFocusablePropertyId, false)]
-    [InlineData((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId, true)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.None)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleStatePropertyId, AccessibleStates.None)]
-    [InlineData((int)UiaCore.UIA.NamePropertyId, null)]
-    public void MonthCalendarChildAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_LegacyIAccessiblePattern_IsSupported()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_FragmentRoot_IsControlAccessibleObject()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.Equal(controlAccessibleObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    [InlineData((int)UiaCore.NavigateDirection.NextSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.PreviousSibling)]
-    public void MonthCalendarChildAccessibleObject_FragmentNavigate_DoesntHaveChildrenAndSiblings(int direction)
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate((UiaCore.NavigateDirection)direction));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_FragmentNavigate_Parent_IsNull()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendarChildAccessibleObject_RuntimeId_HasThreeExpectedItems()
-    {
-        using MonthCalendar control = new MonthCalendar();
-
-        control.CreateControl();
-        MonthCalendarAccessibleObject controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
-        MonthCalendarChildAccessibleObject accessibleObject = new SubObject(controlAccessibleObject);
-
-        Assert.Equal(3, accessibleObject.RuntimeId.Length);
-        Assert.Equal(AccessibleObject.RuntimeIDFirstItem, accessibleObject.RuntimeId[0]);
-        Assert.Equal(PARAM.ToInt(control.Handle), accessibleObject.RuntimeId[1]);
-        Assert.Equal(accessibleObject.GetChildId(), accessibleObject.RuntimeId[2]);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    private class SubObject : MonthCalendarChildAccessibleObject
-    {
-        public SubObject(MonthCalendarAccessibleObject calendarAccessibleObject)
-            : base(calendarAccessibleObject)
-        { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendarTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendarTests.cs
deleted file mode 100644
index 148fea79507..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MonthCalendarTests.cs
+++ /dev/null
@@ -1,4340 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Globalization;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-[UseDefaultXunitCulture]
-public class MonthCalendarTests
-{
-    [WinFormsFact]
-    public void MonthCalendar_Ctor_Default()
-    {
-        using var control = new SubMonthCalendar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Empty(control.AnnuallyBoldedDates);
-        Assert.Same(control.AnnuallyBoldedDates, control.AnnuallyBoldedDates);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Empty(control.BoldedDates);
-        Assert.Same(control.BoldedDates, control.BoldedDates);
-        Assert.True(control.Bottom > 0);
-        Assert.Equal(0, control.Bounds.X);
-        Assert.Equal(0, control.Bounds.Y);
-        Assert.True(control.Bounds.Width > 0);
-        Assert.True(control.Bounds.Height > 0);
-        Assert.Equal(new Size(1, 1), control.CalendarDimensions);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height > 0);
-        Assert.Equal(0, control.ClientRectangle.X);
-        Assert.Equal(0, control.ClientRectangle.Y);
-        Assert.True(control.ClientRectangle.Width > 0);
-        Assert.True(control.ClientRectangle.Height > 0);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, control.DefaultImeMode);
-        Assert.Equal(new Padding(9), control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.True(control.DefaultSize.Width > 0);
-        Assert.True(control.DefaultSize.Height > 0);
-        Assert.False(control.DesignMode);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height > 0);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.Equal(Day.Default, control.FirstDayOfWeek);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.True(control.Height > 0);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(9), control.Margin);
-        Assert.Equal(new DateTime(9998, 12, 31), control.MaxDate);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(7, control.MaxSelectionCount);
-        Assert.Equal(new DateTime(1753, 1, 1), control.MinDate);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Empty(control.MonthlyBoldedDates);
-        Assert.Same(control.MonthlyBoldedDates, control.MonthlyBoldedDates);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.True(control.Right > 0);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(0, control.ScrollChange);
-        Assert.Equal(DateTime.Now.Date, control.SelectionEnd);
-        Assert.Equal(DateTime.Now.Date, control.SelectionRange.Start);
-        Assert.Equal(DateTime.Now.Date, control.SelectionRange.End);
-        Assert.NotSame(control.SelectionRange, control.SelectionRange);
-        Assert.Equal(DateTime.Now.Date, control.SelectionStart);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.True(control.ShowToday);
-        Assert.True(control.ShowTodayCircle);
-        Assert.False(control.ShowWeekNumbers);
-        Assert.Equal(new Size(176, 153), control.SingleMonthSize);
-        Assert.Null(control.Site);
-        Assert.True(control.Size.Width > 0);
-        Assert.True(control.Size.Height > 0);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(SystemColors.ActiveCaption, control.TitleBackColor);
-        Assert.Equal(SystemColors.ActiveCaptionText, control.TitleForeColor);
-        Assert.Equal(DateTime.Now.Date, control.TodayDate);
-        Assert.False(control.TodayDateSet);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.Equal(SystemColors.GrayText, control.TrailingForeColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.True(control.Width > 0);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubMonthCalendar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysMonthCal32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010003, createParams.Style);
-        Assert.Equal(control.Width, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AnnuallyBoldedDates_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<DateTime>() };
-        yield return new object[] { Array.Empty<DateTime>(), Array.Empty<DateTime>() };
-
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) }, new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) } };
-        yield return new object[] { new DateTime[] { DateTime.MinValue, DateTime.MaxValue }, new DateTime[] { DateTime.MinValue, DateTime.MaxValue } };
-
-        var everyMonth = new DateTime[]
-        {
-            new DateTime(2019, 01, 1),
-            new DateTime(2019, 02, 2),
-            new DateTime(2019, 03, 3),
-            new DateTime(2019, 04, 4),
-            new DateTime(2019, 05, 5),
-            new DateTime(2019, 06, 6),
-            new DateTime(2019, 07, 7),
-            new DateTime(2019, 08, 8),
-            new DateTime(2019, 09, 9),
-            new DateTime(2019, 10, 10),
-            new DateTime(2019, 11, 11),
-            new DateTime(2019, 12, 12),
-        };
-        yield return new object[] { everyMonth, everyMonth };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AnnuallyBoldedDates_Set_TestData))]
-    public void MonthCalendar_AnnuallyBoldedDates_Set_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar
-        {
-            AnnuallyBoldedDates = value
-        };
-        Assert.Equal(expected, calendar.AnnuallyBoldedDates);
-        Assert.NotSame(value, calendar.AnnuallyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.AnnuallyBoldedDates = value;
-        Assert.Equal(expected, calendar.AnnuallyBoldedDates);
-        Assert.NotSame(value, calendar.AnnuallyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AnnuallyBoldedDates_Set_TestData))]
-    public void MonthCalendar_AnnuallyBoldedDates_SetWithHandle_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.AnnuallyBoldedDates = value;
-        Assert.Equal(expected, calendar.AnnuallyBoldedDates);
-        Assert.NotSame(value, calendar.AnnuallyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.AnnuallyBoldedDates = value;
-        Assert.Equal(expected, calendar.AnnuallyBoldedDates);
-        Assert.NotSame(value, calendar.AnnuallyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.AnnuallyBoldedDates, calendar.AnnuallyBoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void MonthCalendar_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new MonthCalendar
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void MonthCalendar_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void MonthCalendar_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new MonthCalendar
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void MonthCalendar_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubMonthCalendar
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void MonthCalendar_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new MonthCalendar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    public static IEnumerable<object[]> BoldedDates_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<DateTime>() };
-        yield return new object[] { Array.Empty<DateTime>(), Array.Empty<DateTime>() };
-
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) }, new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) } };
-        yield return new object[] { new DateTime[] { DateTime.MinValue, DateTime.MaxValue }, new DateTime[] { DateTime.MinValue, DateTime.MaxValue } };
-
-        var everyMonth = new DateTime[]
-        {
-            new DateTime(2019, 01, 1),
-            new DateTime(2019, 02, 2),
-            new DateTime(2019, 03, 3),
-            new DateTime(2019, 04, 4),
-            new DateTime(2019, 05, 5),
-            new DateTime(2019, 06, 6),
-            new DateTime(2019, 07, 7),
-            new DateTime(2019, 08, 8),
-            new DateTime(2019, 09, 9),
-            new DateTime(2019, 10, 10),
-            new DateTime(2019, 11, 11),
-            new DateTime(2019, 12, 12),
-        };
-        yield return new object[] { everyMonth, everyMonth };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BoldedDates_Set_TestData))]
-    public void MonthCalendar_BoldedDates_Set_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar
-        {
-            BoldedDates = value
-        };
-        Assert.Equal(expected, calendar.BoldedDates);
-        Assert.NotSame(value, calendar.BoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.BoldedDates, calendar.BoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.BoldedDates, calendar.BoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.BoldedDates = value;
-        Assert.Equal(expected, calendar.BoldedDates);
-        Assert.NotSame(value, calendar.BoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.BoldedDates, calendar.BoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.BoldedDates, calendar.BoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BoldedDates_Set_TestData))]
-    public void MonthCalendar_BoldedDates_SetWithHandle_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.BoldedDates = value;
-        Assert.Equal(expected, calendar.BoldedDates);
-        Assert.NotSame(value, calendar.BoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.BoldedDates, calendar.BoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.BoldedDates, calendar.BoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.BoldedDates = value;
-        Assert.Equal(expected, calendar.BoldedDates);
-        Assert.NotSame(value, calendar.BoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.BoldedDates, calendar.BoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.BoldedDates, calendar.BoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CalendarDimensions_Set_TestData()
-    {
-        yield return new object[] { new Size(1, 1), new Size(1, 1) };
-        yield return new object[] { new Size(1, 2), new Size(1, 2) };
-        yield return new object[] { new Size(2, 1), new Size(2, 1) };
-        yield return new object[] { new Size(2, 3), new Size(2, 3) };
-        yield return new object[] { new Size(3, 4), new Size(3, 4) };
-        yield return new object[] { new Size(3, 5), new Size(3, 4) };
-        yield return new object[] { new Size(3, 10), new Size(3, 4) };
-        yield return new object[] { new Size(5, 3), new Size(4, 3) };
-        yield return new object[] { new Size(10, 3), new Size(4, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CalendarDimensions_Set_TestData))]
-    public void MonthCalendar_CalendarDimensions_Set_GetReturnsExpected(Size value, Size expected)
-    {
-        using var calendar = new MonthCalendar
-        {
-            CalendarDimensions = value
-        };
-        Assert.Equal(expected, calendar.CalendarDimensions);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.CalendarDimensions = value;
-        Assert.Equal(expected, calendar.CalendarDimensions);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 12)]
-    [InlineData(12, 1)]
-    public void MonthCalendar_CalendarDimensions_SetAreaOfTwelve_GetReturnsExpected(int width, int height)
-    {
-        var value = new Size(width, height);
-        using var calendar = new MonthCalendar
-        {
-            CalendarDimensions = value
-        };
-        Assert.True(calendar.CalendarDimensions.Width > 0 && calendar.CalendarDimensions.Width <= 12);
-        Assert.True(calendar.CalendarDimensions.Height > 0 && calendar.CalendarDimensions.Height <= 12);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        var previousCalendarDimensions = calendar.CalendarDimensions;
-        calendar.CalendarDimensions = value;
-        Assert.True(calendar.CalendarDimensions.Width > 0 && calendar.CalendarDimensions.Width <= 12);
-        Assert.True(calendar.CalendarDimensions.Height > 0 && calendar.CalendarDimensions.Height <= 12);
-        Assert.Equal(previousCalendarDimensions, calendar.CalendarDimensions);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CalendarDimensions_Set_TestData))]
-    public void MonthCalendar_CalendarDimensions_SetWithHandle_GetReturnsExpected(Size value, Size expected)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.CalendarDimensions = value;
-        Assert.Equal(expected, calendar.CalendarDimensions);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.CalendarDimensions = value;
-        Assert.Equal(expected, calendar.CalendarDimensions);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 12)]
-    [InlineData(12, 1)]
-    public void MonthCalendar_CalendarDimensions_SetWithHandleAreaOfTwelve_GetReturnsExpected(int width, int height)
-    {
-        var value = new Size(width, height);
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.CalendarDimensions = value;
-        Assert.True(calendar.CalendarDimensions.Width > 0 && calendar.CalendarDimensions.Width <= 12);
-        Assert.True(calendar.CalendarDimensions.Height > 0 && calendar.CalendarDimensions.Height <= 12);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        var previousCalendarDimensions = calendar.CalendarDimensions;
-        calendar.CalendarDimensions = value;
-        Assert.True(calendar.CalendarDimensions.Width > 0 && calendar.CalendarDimensions.Width <= 12);
-        Assert.True(calendar.CalendarDimensions.Height > 0 && calendar.CalendarDimensions.Height <= 12);
-        Assert.Equal(previousCalendarDimensions, calendar.CalendarDimensions);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void MonthCalendar_CalendarDimensions_SetNegativeX_ThrowsArgumentOutOfRangeException(int x)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("x", () => calendar.CalendarDimensions = new Size(x, 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void MonthCalendar_CalendarDimensions_SetNegativeY_ThrowsArgumentOutOfRangeException(int y)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("y", () => calendar.CalendarDimensions = new Size(1, y));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MonthCalendar_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubMonthCalendar
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MonthCalendar_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<Day>]
-    public void MonthCalendar_FirstDayOfWeek_Set_GetReturnsExpected(Day value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            FirstDayOfWeek = value
-        };
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<Day>]
-    public void MonthCalendar_FirstDayOfWeek_SetWithCustomOldValue_GetReturnsExpected(Day value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            FirstDayOfWeek = Day.Monday
-        };
-
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<Day>]
-    public void MonthCalendar_FirstDayOfWeek_SetWithHandle_GetReturnsExpected(Day value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Day.Default, 1)]
-    [InlineData(Day.Monday, 0)]
-    [InlineData(Day.Tuesday, 0)]
-    [InlineData(Day.Wednesday, 0)]
-    [InlineData(Day.Thursday, 0)]
-    [InlineData(Day.Friday, 0)]
-    [InlineData(Day.Saturday, 0)]
-    [InlineData(Day.Sunday, 0)]
-    public void MonthCalendar_FirstDayOfWeek_SetWithHandleWithCustomOldValue_GetReturnsExpected(Day value, int expectedCreatedCallCount)
-    {
-        using var calendar = new MonthCalendar
-        {
-            FirstDayOfWeek = Day.Monday
-        };
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        calendar.FirstDayOfWeek = value;
-        Assert.Equal(value, calendar.FirstDayOfWeek);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<Day>]
-    public void MonthCalendar_FirstDayOfWeek_SetInvalidValue_ThrowsInvalidEnumArgumentException(Day value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<InvalidEnumArgumentException>("FirstDayOfWeek", () => calendar.FirstDayOfWeek = value);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void MonthCalendar_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new MonthCalendar
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void MonthCalendar_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithSelectionRange_Success()
-    {
-        var lower = new DateTime(2019, 1, 30, 3, 4, 5, 6);
-        var upper = new DateTime(2019, 2, 3, 4, 5, 6, 7);
-        using var control = new SubMonthCalendar
-        {
-            SelectionRange = new SelectionRange(lower, upper)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Span<SYSTEMTIME> range = stackalloc SYSTEMTIME[2];
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETSELRANGE, 0, ref range[0]));
-        Assert.Equal(2019, range[0].wYear);
-        Assert.Equal(1, range[0].wMonth);
-        Assert.Equal(30, range[0].wDay);
-        Assert.Equal(3, range[0].wDayOfWeek);
-        Assert.True(range[0].wHour >= 0);
-        Assert.True(range[0].wMinute >= 0);
-        Assert.True(range[0].wSecond >= 0);
-        Assert.True(range[0].wMilliseconds >= 0);
-        Assert.Equal(2019, range[1].wYear);
-        Assert.Equal(2, range[1].wMonth);
-        Assert.Equal(3, range[1].wDay);
-        Assert.Equal(0, range[1].wDayOfWeek);
-        Assert.True(range[1].wHour >= 0);
-        Assert.True(range[1].wMinute >= 0);
-        Assert.True(range[1].wSecond >= 0);
-        Assert.True(range[1].wMilliseconds >= 0);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithMaxSelectionCount_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            MaxSelectionCount = 10
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(10, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETMAXSELCOUNT));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithTodayDate_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            TodayDate = new DateTime(2019, 1, 30, 3, 4, 5, 6)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        SYSTEMTIME date = default;
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETTODAY, 0, ref date));
-        Assert.Equal(2019, date.wYear);
-        Assert.Equal(1, date.wMonth);
-        Assert.Equal(30, date.wDay);
-        Assert.Equal(3, date.wDayOfWeek);
-        Assert.Equal(0, date.wHour);
-        Assert.Equal(0, date.wMinute);
-        Assert.Equal(0, date.wSecond);
-        Assert.Equal(0, date.wMilliseconds);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithForeColor_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETCOLOR, (WPARAM)(int)PInvoke.MCSC_TEXT));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithBackColor_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            BackColor = Color.FromArgb(0xFF, 0x12, 0x34, 0x56)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x563412, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETCOLOR, (WPARAM)(int)PInvoke.MCSC_MONTHBK));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithTitleBackColor_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            TitleBackColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETCOLOR, (WPARAM)(int)PInvoke.MCSC_TITLEBK));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithTitleForeColor_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            TitleForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETCOLOR, (WPARAM)(int)PInvoke.MCSC_TITLETEXT));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithTrailingForeColor_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            TrailingForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x785634, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETCOLOR, (WPARAM)(int)PInvoke.MCSC_TRAILINGTEXT));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithDefaultFirstDayOfWeek_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            FirstDayOfWeek = Day.Default
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int expected = (int)CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek + 6;
-        while (expected > 6)
-        {
-            expected -= 7;
-        }
-
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETFIRSTDAYOFWEEK));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithFirstDayOfWeek_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            FirstDayOfWeek = Day.Tuesday
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0x10001, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETFIRSTDAYOFWEEK));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithRange_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            MinDate = new DateTime(2019, 1, 2, 3, 4, 5, 6),
-            MaxDate = new DateTime(2020, 2, 3, 4, 5, 6, 7)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Span<SYSTEMTIME> range = stackalloc SYSTEMTIME[2];
-        Assert.Equal(3, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETRANGE, 0, ref range[0]));
-        Assert.Equal(2019, range[0].wYear);
-        Assert.Equal(1, range[0].wMonth);
-        Assert.Equal(2, range[0].wDay);
-        Assert.Equal(3, range[0].wDayOfWeek);
-        Assert.Equal(3, range[0].wHour);
-        Assert.Equal(4, range[0].wMinute);
-        Assert.Equal(5, range[0].wSecond);
-        Assert.Equal(6, range[0].wMilliseconds);
-        Assert.Equal(2020, range[1].wYear);
-        Assert.Equal(2, range[1].wMonth);
-        Assert.Equal(3, range[1].wDay);
-        Assert.Equal(1, range[1].wDayOfWeek);
-        Assert.Equal(4, range[1].wHour);
-        Assert.Equal(5, range[1].wMinute);
-        Assert.Equal(6, range[1].wSecond);
-        Assert.Equal(7, range[1].wMilliseconds);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Handle_GetWithScrollChange_Success()
-    {
-        using var control = new SubMonthCalendar
-        {
-            ScrollChange = 10
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(10, (int)PInvoke.SendMessage(control, PInvoke.MCM_GETMONTHDELTA));
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void MonthCalendar_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new MonthCalendar
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void MonthCalendar_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void MonthCalendar_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new MonthCalendar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    public static IEnumerable<object[]> MaxDate_Set_TestData()
-    {
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 1), new DateTime(1753, 1, 1) };
-        yield return new object[] { new DateTime(2019, 1, 29), new DateTime(2019, 1, 29), new DateTime(2019, 1, 29) };
-        yield return new object[] { new DateTime(9998, 12, 31), new DateTime(9998, 12, 31), DateTime.Now.Date };
-        yield return new object[] { new DateTime(9999, 1, 1), new DateTime(9998, 12, 31), DateTime.Now.Date };
-        yield return new object[] { DateTime.MaxValue, new DateTime(9998, 12, 31), DateTime.Now.Date };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaxDate_Set_TestData))]
-    public void MonthCalendar_MaxDate_Set_GetReturnsExpected(DateTime value, DateTime expected, DateTime expectedSelection)
-    {
-        using var calendar = new MonthCalendar
-        {
-            MaxDate = value
-        };
-        Assert.Equal(expected, calendar.MaxDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.MaxDate = value;
-        Assert.Equal(expected, calendar.MaxDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaxDate_Set_TestData))]
-    public void MonthCalendar_MaxDate_SetWithHandle_GetReturnsExpected(DateTime value, DateTime expected, DateTime expectedSelection)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.MaxDate = value;
-        Assert.Equal(expected, calendar.MaxDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.MaxDate = value;
-        Assert.Equal(expected, calendar.MaxDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_MaxDate_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.MaxDate = calendar.MinDate.AddTicks(-1));
-    }
-
-    public static IEnumerable<object[]> MaxSelectionCount_Set_TestData()
-    {
-        yield return new object[] { 1 };
-        yield return new object[] { 2 };
-        yield return new object[] { 7 };
-        yield return new object[] { 8 };
-        yield return new object[] { int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaxSelectionCount_Set_TestData))]
-    public void MonthCalendar_MaxSelectionCount_Set_GetReturnsExpected(int value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            MaxSelectionCount = value
-        };
-        Assert.Equal(value, calendar.MaxSelectionCount);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.MaxSelectionCount = value;
-        Assert.Equal(value, calendar.MaxSelectionCount);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaxSelectionCount_Set_TestData))]
-    public void MonthCalendar_MaxSelectionCount_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.MaxSelectionCount = value;
-        Assert.Equal(value, calendar.MaxSelectionCount);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.MaxSelectionCount = value;
-        Assert.Equal(value, calendar.MaxSelectionCount);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void MonthCalendar_MaxSelectionCount_SetLessThanOne_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.MaxSelectionCount = value);
-    }
-
-    public static IEnumerable<object[]> MinDate_Set_TestData()
-    {
-        yield return new object[] { DateTime.MinValue, new DateTime(1753, 1, 1), DateTime.Now.Date };
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 1), DateTime.Now.Date };
-        yield return new object[] { new DateTime(2019, 1, 29), new DateTime(2019, 1, 29), DateTime.Now.Date };
-        yield return new object[] { new DateTime(9998, 12, 31), new DateTime(9998, 12, 31), new DateTime(9998, 12, 31) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinDate_Set_TestData))]
-    public void MonthCalendar_MinDate_Set_GetReturnsExpected(DateTime value, DateTime expected, DateTime expectedSelection)
-    {
-        using var calendar = new MonthCalendar
-        {
-            MinDate = value
-        };
-        Assert.Equal(expected, calendar.MinDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.MinDate = value;
-        Assert.Equal(expected, calendar.MinDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinDate_Set_TestData))]
-    public void MonthCalendar_MinDate_SetWithHandle_GetReturnsExpected(DateTime value, DateTime expected, DateTime expectedSelection)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.MinDate = value;
-        Assert.Equal(expected, calendar.MinDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.MinDate = value;
-        Assert.Equal(expected, calendar.MinDate);
-        Assert.Equal(expectedSelection, calendar.SelectionStart);
-        Assert.Equal(expectedSelection, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_MinDate_SetLessThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.MinDate = calendar.MaxDate.AddTicks(1));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_MinDate_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.MinDate = calendar.MinDate.AddTicks(-1));
-    }
-
-    public static IEnumerable<object[]> MonthlyBoldedDates_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<DateTime>() };
-        yield return new object[] { Array.Empty<DateTime>(), Array.Empty<DateTime>() };
-
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) }, new DateTime[] { new DateTime(2017, 01, 1), new DateTime(2018, 01, 20) } };
-        yield return new object[] { new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) }, new DateTime[] { new DateTime(2019, 01, 1), new DateTime(2019, 01, 1), new DateTime(2018, 01, 1) } };
-        yield return new object[] { new DateTime[] { DateTime.MinValue, DateTime.MaxValue }, new DateTime[] { DateTime.MinValue, DateTime.MaxValue } };
-
-        var everyMonth = new DateTime[]
-        {
-            new DateTime(2019, 01, 1),
-            new DateTime(2019, 02, 2),
-            new DateTime(2019, 03, 3),
-            new DateTime(2019, 04, 4),
-            new DateTime(2019, 05, 5),
-            new DateTime(2019, 06, 6),
-            new DateTime(2019, 07, 7),
-            new DateTime(2019, 08, 8),
-            new DateTime(2019, 09, 9),
-            new DateTime(2019, 10, 10),
-            new DateTime(2019, 11, 11),
-            new DateTime(2019, 12, 12),
-        };
-        yield return new object[] { everyMonth, everyMonth };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthlyBoldedDates_Set_TestData))]
-    public void MonthCalendar_MonthlyBoldedDates_Set_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar
-        {
-            MonthlyBoldedDates = value
-        };
-        Assert.Equal(expected, calendar.MonthlyBoldedDates);
-        Assert.NotSame(value, calendar.MonthlyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.MonthlyBoldedDates = value;
-        Assert.Equal(expected, calendar.MonthlyBoldedDates);
-        Assert.NotSame(value, calendar.MonthlyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthlyBoldedDates_Set_TestData))]
-    public void MonthCalendar_MonthlyBoldedDates_SetWithHandle_GetReturnsExpected(DateTime[] value, DateTime[] expected)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.MonthlyBoldedDates = value;
-        Assert.Equal(expected, calendar.MonthlyBoldedDates);
-        Assert.NotSame(value, calendar.MonthlyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.MonthlyBoldedDates = value;
-        Assert.Equal(expected, calendar.MonthlyBoldedDates);
-        Assert.NotSame(value, calendar.MonthlyBoldedDates);
-        if (value?.Length > 0)
-        {
-            Assert.NotSame(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-        else
-        {
-            Assert.Same(calendar.MonthlyBoldedDates, calendar.MonthlyBoldedDates);
-        }
-
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void MonthCalendar_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new MonthCalendar
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void MonthCalendar_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1)]
-    [InlineData(RightToLeft.Yes, false, 0)]
-    [InlineData(RightToLeft.No, true, 1)]
-    [InlineData(RightToLeft.No, false, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1)]
-    [InlineData(RightToLeft.Inherit, false, 0)]
-    public void MonthCalendar_RightToLeftLayout_Set_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new MonthCalendar
-        {
-            RightToLeft = rightToLeft
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1, 1, 2)]
-    [InlineData(RightToLeft.Yes, false, 0, 0, 1)]
-    [InlineData(RightToLeft.No, true, 1, 0, 0)]
-    [InlineData(RightToLeft.No, false, 0, 0, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1, 0, 0)]
-    [InlineData(RightToLeft.Inherit, false, 0, 0, 0)]
-    public void MonthCalendar_RightToLeftLayout_SetWithHandle_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new MonthCalendar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_RightToLeftLayout_SetWithHandler_CallsRightToLeftLayoutChanged()
-    {
-        using var control = new MonthCalendar
-        {
-            RightToLeftLayout = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftLayoutChanged += handler;
-
-        // Set different.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeftLayout = true;
-        Assert.True(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_RightToLeftLayout_SetWithHandlerInDisposing_DoesNotRightToLeftLayoutChanged()
-    {
-        using var control = new MonthCalendar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeftLayout = true;
-            Assert.True(control.RightToLeftLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    public static IEnumerable<object[]> ScrollChange_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 2 };
-        yield return new object[] { 20000 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollChange_Set_TestData))]
-    public void MonthCalendar_ScrollChange_Set_GetReturnsExpected(int value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            ScrollChange = value
-        };
-        Assert.Equal(value, calendar.ScrollChange);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.ScrollChange = value;
-        Assert.Equal(value, calendar.ScrollChange);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollChange_Set_TestData))]
-    public void MonthCalendar_ScrollChange_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.ScrollChange = value;
-        Assert.Equal(value, calendar.ScrollChange);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.ScrollChange = value;
-        Assert.Equal(value, calendar.ScrollChange);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(200001)]
-    public void MonthCalendar_ScrollChange_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.ScrollChange = value);
-    }
-
-    public static IEnumerable<object[]> SelectionStart_Set_TestData()
-    {
-        yield return new object[] { DateTime.MinValue, new DateTime(1, 1, 7) };
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 7) };
-        yield return new object[] { new DateTime(1753, 1, 1).AddHours(1), new DateTime(1753, 1, 7).AddHours(1) };
-        yield return new object[] { new DateTime(2019, 1, 29), new DateTime(2019, 2, 4) };
-        yield return new object[] { DateTime.Now.Date.AddDays(-1), DateTime.Now.Date };
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date };
-        yield return new object[] { new DateTime(9998, 12, 31), new DateTime(9998, 12, 31) };
-        yield return new object[] { DateTime.MaxValue, DateTime.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionStart_Set_TestData))]
-    public void MonthCalendar_SelectionStart_Set_GetReturnsExpected(DateTime value, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar
-        {
-            SelectionStart = value
-        };
-        Assert.Equal(value, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.SelectionStart = value;
-        Assert.Equal(value, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionStart_Set_TestData))]
-    public void MonthCalendar_SelectionStart_SetWithHandle_GetReturnsExpected(DateTime value, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.SelectionStart = value;
-        Assert.Equal(value, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.SelectionStart = value;
-        Assert.Equal(value, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionStart_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SelectionStart = calendar.MinDate.AddTicks(-1);
-        Assert.Equal(calendar.MinDate.AddTicks(-1), calendar.SelectionStart);
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionStart = calendar.MinDate.AddTicks(-1));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionStart_SetGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SelectionStart = calendar.MaxDate.AddTicks(1);
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionStart);
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionStart = calendar.MaxDate.AddTicks(1));
-    }
-
-    public static IEnumerable<object[]> SelectionEnd_Set_TestData()
-    {
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 1) };
-        yield return new object[] { new DateTime(1753, 1, 1).AddHours(1), new DateTime(1753, 1, 1).AddHours(1) };
-        yield return new object[] { new DateTime(2019, 1, 29), new DateTime(2019, 1, 29) };
-        yield return new object[] { DateTime.Now.Date.AddDays(1), DateTime.Now.Date };
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date };
-        yield return new object[] { new DateTime(9998, 12, 31), new DateTime(9998, 12, 25) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionEnd_Set_TestData))]
-    public void MonthCalendar_SelectionEnd_Set_GetReturnsExpected(DateTime value, DateTime expectedSelectionStart)
-    {
-        using var calendar = new MonthCalendar
-        {
-            SelectionEnd = value
-        };
-        Assert.Equal(value, calendar.SelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.SelectionEnd = value;
-        Assert.Equal(value, calendar.SelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionEnd_Set_TestData))]
-    public void MonthCalendar_SelectionEnd_SetWithHandle_GetReturnsExpected(DateTime value, DateTime expectedSelectionStart)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.SelectionEnd = value;
-        Assert.Equal(value, calendar.SelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.SelectionEnd = value;
-        Assert.Equal(value, calendar.SelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionEnd_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionEnd = calendar.MinDate.AddTicks(-1));
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionEnd = calendar.MinDate.AddTicks(-1));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionEnd_SetGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionEnd = calendar.MaxDate.AddTicks(1));
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.SelectionEnd = calendar.MaxDate.AddTicks(1));
-    }
-
-    public static IEnumerable<object[]> SelectionRange_Set_TestData()
-    {
-        yield return new object[] { new SelectionRange(DateTime.MinValue, DateTime.MinValue), DateTime.MinValue, DateTime.MinValue };
-        yield return new object[] { new SelectionRange(new DateTime(1753, 1, 1).AddTicks(-1), new DateTime(1753, 1, 1).AddTicks(-1)), new DateTime(1752, 12, 31), new DateTime(1752, 12, 31) };
-        yield return new object[] { new SelectionRange(new DateTime(1753, 1, 1), new DateTime(1753, 1, 1)), new DateTime(1753, 1, 1), new DateTime(1753, 1, 1) };
-        yield return new object[] { new SelectionRange(new DateTime(1753, 1, 1), new DateTime(1753, 1, 2)), new DateTime(1753, 1, 1), new DateTime(1753, 1, 2) };
-
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 1), new DateTime(2019, 9, 1)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 1) };
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 1), new DateTime(2019, 9, 2)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 2) };
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 1).AddHours(1), new DateTime(2019, 9, 2).AddHours(1)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 2) };
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 2), new DateTime(2019, 9, 1)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 2) };
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 1), new DateTime(2019, 9, 7)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 7) };
-        yield return new object[] { new SelectionRange(new DateTime(2019, 9, 1), new DateTime(2019, 9, 8)), new DateTime(2019, 9, 1), new DateTime(2019, 9, 7) };
-
-        yield return new object[] { new SelectionRange(DateTime.Now.Date, DateTime.Now.Date), DateTime.Now.Date, DateTime.Now.Date };
-        yield return new object[] { new SelectionRange(DateTime.Now.Date, DateTime.Now.Date.AddDays(1)), DateTime.Now.Date, DateTime.Now.Date.AddDays(1) };
-        yield return new object[] { new SelectionRange(DateTime.Now.Date.AddHours(1), DateTime.Now.Date.AddHours(1)), DateTime.Now.Date, DateTime.Now.Date };
-        yield return new object[] { new SelectionRange(DateTime.Now.Date.AddDays(1), DateTime.Now.Date), DateTime.Now.Date, DateTime.Now.Date.AddDays(1) };
-        yield return new object[] { new SelectionRange(DateTime.Now.Date, DateTime.Now.Date.AddDays(6)), DateTime.Now.Date, DateTime.Now.Date.AddDays(6) };
-        yield return new object[] { new SelectionRange(DateTime.Now.Date, DateTime.Now.Date.AddDays(7)), DateTime.Now.Date.AddDays(1), DateTime.Now.Date.AddDays(7) };
-
-        yield return new object[] { new SelectionRange(new DateTime(9998, 12, 30), new DateTime(9998, 12, 31)), new DateTime(9998, 12, 30), new DateTime(9998, 12, 31) };
-        yield return new object[] { new SelectionRange(new DateTime(9998, 12, 31), new DateTime(9998, 12, 31)), new DateTime(9998, 12, 31), new DateTime(9998, 12, 31) };
-        yield return new object[] { new SelectionRange(new DateTime(9998, 12, 31).AddTicks(1), new DateTime(9998, 12, 31).AddTicks(1)), new DateTime(9998, 12, 31), new DateTime(9998, 12, 31) };
-        yield return new object[] { new SelectionRange(DateTime.MaxValue, DateTime.MaxValue), DateTime.MaxValue.Date, DateTime.MaxValue.Date };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionRange_Set_TestData))]
-    public void MonthCalendar_SelectionRange_Set_GetReturnsExpected(SelectionRange value, DateTime expectedSelectionStart, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar
-        {
-            SelectionRange = value
-        };
-        Assert.Equal(expectedSelectionStart, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.NotSame(value, calendar.SelectionRange);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Set same.
-        calendar.SelectionRange = new SelectionRange(expectedSelectionStart, expectedSelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.NotSame(value, calendar.SelectionRange);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionRange_Set_TestData))]
-    public void MonthCalendar_SelectionRange_SetWithHandle_GetReturnsExpected(SelectionRange value, DateTime expectedSelectionStart, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.SelectionRange = value;
-        Assert.Equal(expectedSelectionStart, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.NotSame(value, calendar.SelectionRange);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        calendar.SelectionRange = new SelectionRange(expectedSelectionStart, expectedSelectionEnd);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.NotSame(value, calendar.SelectionRange);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionRange_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SelectionRange = new SelectionRange(calendar.MinDate.AddTicks(-1), calendar.MinDate);
-        Assert.Equal(calendar.MinDate.AddTicks(-1).Date, calendar.SelectionStart);
-        Assert.Equal(calendar.MinDate, calendar.SelectionEnd);
-
-        calendar.SelectionRange = new SelectionRange(calendar.MinDate, calendar.MinDate.AddTicks(-1));
-        Assert.Equal(calendar.MinDate.AddTicks(-1).Date, calendar.SelectionStart);
-        Assert.Equal(calendar.MinDate, calendar.SelectionEnd);
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date1", () => calendar.SelectionRange = new SelectionRange(calendar.MinDate.AddTicks(-1), calendar.MinDate));
-        Assert.Throws<ArgumentOutOfRangeException>("date1", () => calendar.SelectionRange = new SelectionRange(calendar.MinDate, calendar.MinDate.AddTicks(-1)));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SelectionRange_SetGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SelectionRange = new SelectionRange(calendar.MaxDate.AddTicks(1), calendar.MaxDate);
-        Assert.Equal(calendar.MaxDate, calendar.SelectionStart);
-        Assert.Equal(calendar.MaxDate.AddTicks(1).Date, calendar.SelectionEnd);
-
-        calendar.SelectionRange = new SelectionRange(calendar.MaxDate, calendar.MaxDate.AddTicks(1));
-        Assert.Equal(calendar.MaxDate, calendar.SelectionStart);
-        Assert.Equal(calendar.MaxDate.AddTicks(1).Date, calendar.SelectionEnd);
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date2", () => calendar.SelectionRange = new SelectionRange(calendar.MaxDate.AddDays(1), calendar.MaxDate));
-        Assert.Throws<ArgumentOutOfRangeException>("date2", () => calendar.SelectionRange = new SelectionRange(calendar.MaxDate, calendar.MaxDate.AddDays(1)));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MonthCalendar_ShowToday_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubMonthCalendar
-        {
-            ShowToday = value
-        };
-        Assert.Equal(value, control.ShowToday);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowToday = value;
-        Assert.Equal(value, control.ShowToday);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowToday = !value;
-        Assert.Equal(!value, control.ShowToday);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void MonthCalendar_ShowToday_SetWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ShowToday = value;
-        Assert.Equal(value, control.ShowToday);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ShowToday = value;
-        Assert.Equal(value, control.ShowToday);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ShowToday = !value;
-        Assert.Equal(!value, control.ShowToday);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMonthCalendar();
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.Table, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MonthCalendar_ShowTodayCircle_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubMonthCalendar
-        {
-            ShowTodayCircle = value
-        };
-        Assert.Equal(value, control.ShowTodayCircle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowTodayCircle = value;
-        Assert.Equal(value, control.ShowTodayCircle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowTodayCircle = !value;
-        Assert.Equal(!value, control.ShowTodayCircle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void MonthCalendar_ShowTodayCircle_SetWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ShowTodayCircle = value;
-        Assert.Equal(value, control.ShowTodayCircle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ShowTodayCircle = value;
-        Assert.Equal(value, control.ShowTodayCircle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ShowTodayCircle = !value;
-        Assert.Equal(!value, control.ShowTodayCircle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void MonthCalendar_ShowWeekNumbers_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubMonthCalendar
-        {
-            ShowWeekNumbers = value
-        };
-        Assert.Equal(value, control.ShowWeekNumbers);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowWeekNumbers = value;
-        Assert.Equal(value, control.ShowWeekNumbers);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowWeekNumbers = !value;
-        Assert.Equal(!value, control.ShowWeekNumbers);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void MonthCalendar_ShowWeekNumbers_SetWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ShowWeekNumbers = value;
-        Assert.Equal(value, control.ShowWeekNumbers);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ShowWeekNumbers = value;
-        Assert.Equal(value, control.ShowWeekNumbers);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ShowWeekNumbers = !value;
-        Assert.Equal(!value, control.ShowWeekNumbers);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SingleMonthSize_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Size size = control.SingleMonthSize;
-        Assert.True(size.Width >= 169);
-        Assert.True(size.Height >= 153);
-        Assert.Equal(size, control.SingleMonthSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SingleMonthSize_GetCustomGetMinReqRect_TestData()
-    {
-        yield return new object[] { new RECT(0, 0, 0, 0), Size.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Size(3, 4) };
-        yield return new object[] { new RECT(1, 2, 1, 6), new Size(1, 6) };
-        yield return new object[] { new RECT(1, 2, 6, 1), new Size(6, 1) };
-        yield return new object[] { new RECT(1, 2, 6, 6), new Size(6, 6) };
-        yield return new object[] { new RECT(1, 2, 30, 40), new Size(30, 40) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SingleMonthSize_GetCustomGetMinReqRect_TestData))]
-    public void MonthCalendar_SingleMonthSize_GetCustomGetMinReqRect_ReturnsExpected(object getMinReqRectResult, Size expected)
-    {
-        using var control = new CustomGetMinReqRectMonthCalendar
-        {
-            GetMinReqRectResult = (RECT)getMinReqRectResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, control.SingleMonthSize);
-    }
-
-    private class CustomGetMinReqRectMonthCalendar : MonthCalendar
-    {
-        public RECT GetMinReqRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.MCM_GETMINREQRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetMinReqRectResult;
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SingleMonthSize_GetInvalidGetMinReqRect_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidGetMinReqRectMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Throws<InvalidOperationException>(() => control.SingleMonthSize);
-    }
-
-    private class InvalidGetMinReqRectMonthCalendar : MonthCalendar
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.MCM_GETMINREQRECT)
-            {
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(0, 0) };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(-1, 2) };
-        yield return new object[] { new Size(1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void MonthCalendar_Size_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new MonthCalendar();
-        Size size = control.ClientSize;
-
-        control.Size = value;
-        Assert.Equal(size, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.DisplayRectangle);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.Bounds);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Size = value;
-        Assert.Equal(size, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.DisplayRectangle);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void MonthCalendar_Size_SetWithHandle_GetReturnsExpected(Size value)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Size size = control.Size;
-
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Size = value;
-        Assert.Equal(size, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.DisplayRectangle);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.Bounds);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Size = value;
-        Assert.Equal(size, control.ClientSize);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.ClientRectangle);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.DisplayRectangle);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(new Rectangle(Point.Empty, size), control.Bounds);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Size_SetWithHandler_CallsSizeChanged()
-    {
-        using var control = new MonthCalendar();
-        Size size = control.Size;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        int clientSizeChangedCallCount = 0;
-        EventHandler clientSizeChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            clientSizeChangedCallCount++;
-        };
-        control.SizeChanged += handler;
-        control.ClientSizeChanged += clientSizeChangedHandler;
-
-        control.Size = new Size(10, 10);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-
-        // Set same.
-        control.Size = new Size(10, 10);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-
-        // Set different.
-        control.Size = new Size(11, 11);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-
-        // Remove handler.
-        control.SizeChanged -= handler;
-        control.ClientSizeChanged -= clientSizeChangedHandler;
-        control.Size = new Size(10, 10);
-        Assert.Equal(size, control.Size);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void MonthCalendar_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new MonthCalendar
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void MonthCalendar_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new MonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> TitleBackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TitleBackColor_Set_TestData))]
-    public void MonthCalendar_TitleBackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            TitleBackColor = value
-        };
-        Assert.Equal(value, calendar.TitleBackColor);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.TitleBackColor = value;
-        Assert.Equal(value, calendar.TitleBackColor);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TitleBackColor_Set_TestData))]
-    public void MonthCalendar_TitleBackColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.TitleBackColor = value;
-        Assert.Equal(value, calendar.TitleBackColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.TitleBackColor = value;
-        Assert.Equal(value, calendar.TitleBackColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TitleBackColor_SetEmpty_ThrowsArgumentException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentException>("value", () => calendar.TitleBackColor = Color.Empty);
-    }
-
-    public static IEnumerable<object[]> TitleForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TitleForeColor_Set_TestData))]
-    public void MonthCalendar_TitleForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            TitleForeColor = value
-        };
-        Assert.Equal(value, calendar.TitleForeColor);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.TitleForeColor = value;
-        Assert.Equal(value, calendar.TitleForeColor);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TitleForeColor_Set_TestData))]
-    public void MonthCalendar_TitleForeColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.TitleForeColor = value;
-        Assert.Equal(value, calendar.TitleForeColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.TitleForeColor = value;
-        Assert.Equal(value, calendar.TitleForeColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TitleForeColor_SetEmpty_ThrowsArgumentException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentException>("value", () => calendar.TitleForeColor = Color.Empty);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TodayDate_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(DateTime.Now.Date, control.TodayDate);
-        Assert.False(control.TodayDateSet);
-    }
-
-    public static IEnumerable<object[]> TodayDate_Set_TestData()
-    {
-        yield return new object[] { DateTime.MinValue };
-        yield return new object[] { new DateTime(1753, 1, 1).AddTicks(-1) };
-        yield return new object[] { new DateTime(1753, 1, 1) };
-        yield return new object[] { new DateTime(2019, 9, 1) };
-        yield return new object[] { new DateTime(2019, 9, 1).AddHours(1) };
-        yield return new object[] { DateTime.Now.Date };
-        yield return new object[] { DateTime.Now.Date.AddHours(1) };
-        yield return new object[] { new DateTime(9998, 12, 31) };
-        yield return new object[] { new DateTime(9998, 12, 31).AddTicks(1) };
-        yield return new object[] { DateTime.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TodayDate_Set_TestData))]
-    public void MonthCalendar_TodayDate_Set_GetReturnsExpected(DateTime value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            TodayDate = value
-        };
-        Assert.Equal(value.Date, calendar.TodayDate);
-        Assert.True(calendar.TodayDateSet);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.TodayDate = value;
-        Assert.Equal(value.Date, calendar.TodayDate);
-        Assert.True(calendar.TodayDateSet);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TodayDate_Set_TestData))]
-    public void MonthCalendar_TodayDate_SetWithHandle_GetReturnsExpected(DateTime value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.TodayDate = value;
-        Assert.Equal(value.Date, calendar.TodayDate);
-        Assert.True(calendar.TodayDateSet);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.TodayDate = value;
-        Assert.Equal(value.Date, calendar.TodayDate);
-        Assert.True(calendar.TodayDateSet);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TodayDate_SetLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.TodayDate = calendar.MinDate.AddTicks(-1);
-        Assert.Equal(calendar.MinDate.AddTicks(-1).Date, calendar.TodayDate);
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.TodayDate = calendar.MinDate.AddTicks(-1));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TodayDate_SetGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.TodayDate = calendar.MaxDate.AddTicks(1);
-        Assert.Equal(calendar.MaxDate.AddTicks(1).Date, calendar.TodayDate);
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => calendar.TodayDate = calendar.MaxDate.AddDays(1));
-    }
-
-    public static IEnumerable<object[]> TrailingForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrailingForeColor_Set_TestData))]
-    public void MonthCalendar_TrailingForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar
-        {
-            TrailingForeColor = value
-        };
-        Assert.Equal(value, calendar.TrailingForeColor);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.TrailingForeColor = value;
-        Assert.Equal(value, calendar.TrailingForeColor);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrailingForeColor_Set_TestData))]
-    public void MonthCalendar_TrailingForeColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.TrailingForeColor = value;
-        Assert.Equal(value, calendar.TrailingForeColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.TrailingForeColor = value;
-        Assert.Equal(value, calendar.TrailingForeColor);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_TrailingForeColor_SetEmpty_ThrowsArgumentException()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.Throws<ArgumentException>("value", () => calendar.TrailingForeColor = Color.Empty);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddAnnuallyBoldedDate_Invoke_AddsToAnnuallyBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different day.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different month.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different year.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Duplicate.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MinValue.
-        calendar.AddAnnuallyBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MaxValue.
-        calendar.AddAnnuallyBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.AnnuallyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddAnnuallyBoldedDate_InvokeWithHandle_AddsToAnnuallyBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different day.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different month.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different year.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Duplicate.
-        calendar.AddAnnuallyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5) }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MinValue.
-        calendar.AddAnnuallyBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MaxValue.
-        calendar.AddAnnuallyBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.AnnuallyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddBoldedDate_Invoke_AddsToBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.AddBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different day.
-        calendar.AddBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different month.
-        calendar.AddBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different year.
-        calendar.AddBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Duplicate.
-        calendar.AddBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MinValue.
-        calendar.AddBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MaxValue.
-        calendar.AddBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.BoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddBoldedDate_InvokeWithHandle_AddsToBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.AddBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different day.
-        calendar.AddBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different month.
-        calendar.AddBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different year.
-        calendar.AddBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Duplicate.
-        calendar.AddBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MinValue.
-        calendar.AddBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MaxValue.
-        calendar.AddBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.BoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddMonthlyBoldedDate_Invoke_AddsToMonthlyBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different day.
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different month.
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Different year.
-        calendar.AddMonthlyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Duplicate.
-        calendar.AddMonthlyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MinValue.
-        calendar.AddMonthlyBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-
-        // MaxValue.
-        calendar.AddMonthlyBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.MonthlyBoldedDates);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_AddMonthlyBoldedDate_InvokeWithHandle_AddsToMonthlyBoldedDates()
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 10, 3));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3) }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different day.
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 10, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5) }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different month.
-        calendar.AddMonthlyBoldedDate(new DateTime(2019, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Different year.
-        calendar.AddMonthlyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Duplicate.
-        calendar.AddMonthlyBoldedDate(new DateTime(2018, 09, 5));
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5) }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MinValue.
-        calendar.AddMonthlyBoldedDate(DateTime.MinValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // MaxValue.
-        calendar.AddMonthlyBoldedDate(DateTime.MaxValue);
-        Assert.Equal(new DateTime[] { new DateTime(2019, 10, 3), new DateTime(2019, 10, 5), new DateTime(2019, 09, 5), new DateTime(2018, 09, 5), new DateTime(2018, 09, 5), DateTime.MinValue, DateTime.MaxValue }, calendar.MonthlyBoldedDates);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_CreateHandle_Invoke_Success()
-    {
-        using var control = new SubMonthCalendar();
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMonthCalendar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void MonthCalendar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubMonthCalendar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> DateRangeEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DateRangeEventArgs(DateTime.Now, DateTime.Now) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DateRangeEventArgs_TestData))]
-    public void MonthCalendar_Calendar_OnDateChanged_Invoke_CallsDateChanged(DateRangeEventArgs eventArgs)
-    {
-        using var calendar = new SubMonthCalendar();
-        int callCount = 0;
-        DateRangeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(calendar, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        calendar.DateChanged += handler;
-        calendar.OnDateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        calendar.DateChanged -= handler;
-        calendar.OnDateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DateRangeEventArgs_TestData))]
-    public void MonthCalendar_Calendar_OnDateSelected_Invoke_CallsDateSelected(DateRangeEventArgs eventArgs)
-    {
-        using var calendar = new SubMonthCalendar();
-        int callCount = 0;
-        DateRangeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(calendar, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        calendar.DateSelected += handler;
-        calendar.OnDateSelected(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        calendar.DateSelected -= handler;
-        calendar.OnDateSelected(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthControl_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnForeColorChanged_InvokeWithHandle_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthCalendar_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void MonthCalendar_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void MonthCalendar_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void MonthCalendar_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null };
-        yield return new object[] { RightToLeft.Yes, new EventArgs() };
-        yield return new object[] { RightToLeft.No, null };
-        yield return new object[] { RightToLeft.No, new EventArgs() };
-        yield return new object[] { RightToLeft.Inherit, null };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_TestData))]
-    public void MonthCalendar_OnRightToLeftLayoutChanged_Invoke_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs)
-    {
-        using var control = new SubMonthCalendar
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_WithHandle_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null, 1 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.Inherit, null, 0 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_WithHandle_TestData))]
-    public void MonthCalendar_OnRightToLeftLayoutChanged_InvokeWithHandle_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCreatedCallCount)
-    {
-        using var control = new SubMonthCalendar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount * 2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_OnRightToLeftLayoutChanged_InvokeInDisposing_DoesNotCallRightToLeftLayoutChanged()
-    {
-        using var control = new SubMonthCalendar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_RecreateHandle_InvokeWithHandle_Success()
-    {
-        using var control = new SubMonthCalendar();
-        IntPtr handle1 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.True(control.IsHandleCreated);
-
-        control.RecreateHandle();
-        IntPtr handle2 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle1, handle2);
-        Assert.True(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        IntPtr handle3 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle3);
-        Assert.NotEqual(handle2, handle3);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_RecreateHandle_InvokeWithoutHandle_Nop()
-    {
-        using var control = new SubMonthCalendar();
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void MonthControl_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubMonthCalendar();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetDate_TestData()
-    {
-        yield return new object[] { DateTime.MinValue };
-        yield return new object[] { new DateTime(1753, 1, 1).AddTicks(-1) };
-        yield return new object[] { new DateTime(1753, 1, 1) };
-        yield return new object[] { new DateTime(2019, 9, 1) };
-        yield return new object[] { new DateTime(2019, 9, 1).AddHours(1) };
-        yield return new object[] { DateTime.Now.Date };
-        yield return new object[] { DateTime.Now.Date.AddHours(1) };
-        yield return new object[] { new DateTime(9998, 12, 31) };
-        yield return new object[] { new DateTime(9998, 12, 31).AddTicks(1) };
-        yield return new object[] { DateTime.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDate_TestData))]
-    public void MonthCalendar_SetDate_Invoke_GetReturnsExpected(DateTime date)
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetDate(date);
-        Assert.Equal(date.Date, calendar.SelectionRange.Start);
-        Assert.Equal(date.Date, calendar.SelectionRange.End);
-        Assert.Equal(date, calendar.SelectionStart);
-        Assert.Equal(date, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.SetDate(date);
-        Assert.Equal(date.Date, calendar.SelectionRange.Start);
-        Assert.Equal(date.Date, calendar.SelectionRange.End);
-        Assert.Equal(date, calendar.SelectionStart);
-        Assert.Equal(date, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDate_TestData))]
-    public void MonthCalendar_SetDate_InvokeWithHandle_GetReturnsExpected(DateTime date)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.SetDate(date);
-        Assert.Equal(date.Date, calendar.SelectionRange.Start);
-        Assert.Equal(date.Date, calendar.SelectionRange.End);
-        Assert.Equal(date, calendar.SelectionStart);
-        Assert.Equal(date, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.SetDate(date);
-        Assert.Equal(date.Date, calendar.SelectionRange.Start);
-        Assert.Equal(date.Date, calendar.SelectionRange.End);
-        Assert.Equal(date, calendar.SelectionStart);
-        Assert.Equal(date, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SetDate_DateLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetDate(calendar.MinDate.AddTicks(-1));
-        Assert.Equal(calendar.MinDate.AddTicks(-1), calendar.SelectionStart);
-        Assert.Equal(calendar.MinDate.AddTicks(-1), calendar.SelectionEnd);
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date", () => calendar.SetDate(calendar.MinDate.AddTicks(-1)));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SetDate_DateGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetDate(calendar.MaxDate.AddTicks(1));
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionStart);
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionEnd);
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date", () => calendar.SetDate(calendar.MaxDate.AddDays(1)));
-    }
-
-    public static IEnumerable<object[]> SetSelectionRange_TestData()
-    {
-        yield return new object[] { DateTime.MinValue, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue };
-        yield return new object[] { new DateTime(1753, 1, 1).AddTicks(-1), new DateTime(1753, 1, 1).AddTicks(-1), new DateTime(1753, 1, 1).AddTicks(-1), new DateTime(1753, 1, 1).AddTicks(-1) };
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 1), new DateTime(1753, 1, 1), new DateTime(1753, 1, 1) };
-        yield return new object[] { new DateTime(1753, 1, 1), new DateTime(1753, 1, 2), new DateTime(1753, 1, 1), new DateTime(1753, 1, 2) };
-
-        yield return new object[] { new DateTime(2019, 9, 1), new DateTime(2019, 9, 1), new DateTime(2019, 9, 1), new DateTime(2019, 9, 1) };
-        yield return new object[] { new DateTime(2019, 9, 1), new DateTime(2019, 9, 2), new DateTime(2019, 9, 1), new DateTime(2019, 9, 2) };
-        yield return new object[] { new DateTime(2019, 9, 1).AddHours(1), new DateTime(2019, 9, 2).AddHours(1), new DateTime(2019, 9, 1).AddHours(1), new DateTime(2019, 9, 2).AddHours(1) };
-        yield return new object[] { new DateTime(2019, 9, 2), new DateTime(2019, 9, 1), new DateTime(2019, 9, 2), new DateTime(2019, 9, 2) };
-        yield return new object[] { new DateTime(2019, 9, 1), new DateTime(2019, 9, 7), new DateTime(2019, 9, 1), new DateTime(2019, 9, 7) };
-        yield return new object[] { new DateTime(2019, 9, 1), new DateTime(2019, 9, 8), new DateTime(2019, 9, 1), new DateTime(2019, 9, 7) };
-
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date, DateTime.Now.Date, DateTime.Now.Date };
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date.AddDays(1), DateTime.Now.Date, DateTime.Now.Date.AddDays(1) };
-        yield return new object[] { DateTime.Now.Date.AddHours(1), DateTime.Now.Date.AddHours(1), DateTime.Now.Date.AddHours(1), DateTime.Now.Date.AddHours(1) };
-        yield return new object[] { DateTime.Now.Date.AddDays(1), DateTime.Now.Date, DateTime.Now.Date.AddDays(1), DateTime.Now.Date.AddDays(1) };
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date.AddDays(6), DateTime.Now.Date, DateTime.Now.Date.AddDays(6) };
-        yield return new object[] { DateTime.Now.Date, DateTime.Now.Date.AddDays(7), DateTime.Now.Date.AddDays(1), DateTime.Now.Date.AddDays(7) };
-
-        yield return new object[] { new DateTime(9998, 12, 30), new DateTime(9998, 12, 31), new DateTime(9998, 12, 30), new DateTime(9998, 12, 31) };
-        yield return new object[] { new DateTime(9998, 12, 31), new DateTime(9998, 12, 31), new DateTime(9998, 12, 31), new DateTime(9998, 12, 31) };
-        yield return new object[] { new DateTime(9998, 12, 31).AddTicks(1), new DateTime(9998, 12, 31).AddTicks(1), new DateTime(9998, 12, 31).AddTicks(1), new DateTime(9998, 12, 31).AddTicks(1) };
-        yield return new object[] { DateTime.MaxValue, DateTime.MaxValue, DateTime.MaxValue, DateTime.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetSelectionRange_TestData))]
-    public void MonthCalendar_SetSelectionRange_Invoke_GetReturnsExpected(DateTime date1, DateTime date2, DateTime expectedSelectionStart, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetSelectionRange(date1, date2);
-        Assert.Equal(expectedSelectionStart.Date, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd.Date, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-
-        // Call again.
-        calendar.SetSelectionRange(expectedSelectionStart, expectedSelectionEnd);
-        Assert.Equal(expectedSelectionStart.Date, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd.Date, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.False(calendar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetSelectionRange_TestData))]
-    public void MonthCalendar_SetSelectionRange_InvokeWithHandle_GetReturnsExpected(DateTime date1, DateTime date2, DateTime expectedSelectionStart, DateTime expectedSelectionEnd)
-    {
-        using var calendar = new MonthCalendar();
-        Assert.NotEqual(IntPtr.Zero, calendar.Handle);
-        int invalidatedCallCount = 0;
-        calendar.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        calendar.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        calendar.HandleCreated += (sender, e) => createdCallCount++;
-
-        calendar.SetSelectionRange(date1, date2);
-        Assert.Equal(expectedSelectionStart.Date, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd.Date, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        calendar.SetSelectionRange(expectedSelectionStart, expectedSelectionEnd);
-        Assert.Equal(expectedSelectionStart.Date, calendar.SelectionRange.Start);
-        Assert.Equal(expectedSelectionEnd.Date, calendar.SelectionRange.End);
-        Assert.Equal(expectedSelectionStart, calendar.SelectionStart);
-        Assert.Equal(expectedSelectionEnd, calendar.SelectionEnd);
-        Assert.True(calendar.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SetSelectionRange_DateLessThanMinDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetSelectionRange(calendar.MinDate.AddTicks(-1), calendar.MinDate);
-        Assert.Equal(calendar.MinDate.AddTicks(-1), calendar.SelectionStart);
-        Assert.Equal(calendar.MinDate, calendar.SelectionEnd);
-
-        calendar.SetSelectionRange(calendar.MinDate, calendar.MinDate.AddTicks(-1));
-        Assert.Equal(calendar.MinDate, calendar.SelectionStart);
-        Assert.Equal(calendar.MinDate, calendar.SelectionEnd);
-
-        calendar.MinDate = new DateTime(2019, 10, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date1", () => calendar.SetSelectionRange(calendar.MinDate.AddTicks(-1), calendar.MinDate));
-        Assert.Throws<ArgumentOutOfRangeException>("date2", () => calendar.SetSelectionRange(calendar.MinDate, calendar.MinDate.AddTicks(-1)));
-    }
-
-    [WinFormsFact]
-    public void MonthCalendar_SetSelectionRange_DateGreaterThanMaxDate_ThrowsArgumentOutOfRangeException()
-    {
-        using var calendar = new MonthCalendar();
-        calendar.SetSelectionRange(calendar.MaxDate.AddTicks(1), calendar.MaxDate);
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionStart);
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionEnd);
-
-        calendar.SetSelectionRange(calendar.MaxDate, calendar.MaxDate.AddTicks(1));
-        Assert.Equal(calendar.MaxDate, calendar.SelectionStart);
-        Assert.Equal(calendar.MaxDate.AddTicks(1), calendar.SelectionEnd);
-
-        calendar.MaxDate = new DateTime(2019, 9, 3);
-        Assert.Throws<ArgumentOutOfRangeException>("date1", () => calendar.SetSelectionRange(calendar.MaxDate.AddDays(1), calendar.MaxDate));
-        Assert.Throws<ArgumentOutOfRangeException>("date2", () => calendar.SetSelectionRange(calendar.MaxDate, calendar.MaxDate.AddDays(1)));
-    }
-
-    public static IEnumerable<object[]> MonthCalendar_FillMonthDayStates_ReturnsExpected_TestData()
-    {
-        // This test set of dates is designed for a specifict test case:
-        // when a calendar has 12 fully visible months + 2 not fully visible.
-        // This test calendar has (08/29/2021 - 09/10/2022) dates range.
-
-        yield return new object[] { new DateTime(2021, 8, 31) }; // Make this date of the not fully visible previous month bold
-
-        // Make visible dates of 2021 year (Sep - Dec) bold
-        for (int i = 9; i <= 12; i++)
-        {
-            yield return new object[] { new DateTime(2021, i, i) };
-        }
-
-        // Make visible dates of 2022 year (Jan - Aug) bold
-        for (int i = 1; i <= 8; i++)
-        {
-            yield return new object[] { new DateTime(2022, i, i) };
-        }
-
-        yield return new object[] { new DateTime(2022, 9, 1) }; // Make this date of the not fully visible last month bold
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendar_FillMonthDayStates_ReturnsExpected_TestData))]
-    public unsafe void MonthCalendar_FillMonthDayStates_ReturnsExpected(DateTime currentDate)
-    {
-        const int MonthsInYear = 12;
-        // Create a calendar with (600x600) size, that contains 3 columns and 4 row of months (12 months total).
-        // Set the first day of week to have a stable test case in different environments.
-        using MonthCalendar calendar = new() { Size = new Size(600, 600), FirstDayOfWeek = Day.Sunday };
-
-        calendar.CreateControl();
-        // Set a visible range (08/29/2021 - 09/10/2022) to have a stable test case
-        calendar.SetSelectionRange(new DateTime(2021, 9, 1), new DateTime(2022, 8, 31));
-        MONTH_CALDENDAR_MESSAGES_VIEW view = calendar.TestAccessor().Dynamic._mcCurView;
-        SelectionRange displayRange = calendar.GetDisplayRange(visible: false);
-
-        Assert.Equal(MONTH_CALDENDAR_MESSAGES_VIEW.MCMV_MONTH, view);
-        Assert.Equal(new DateTime(2021, 8, 29), displayRange.Start);
-        Assert.Equal(new DateTime(2022, 9, 10), displayRange.End);
-
-        int monthsCount = calendar.TestAccessor().Dynamic.GetMonthsCountOfRange(displayRange);
-        int currentMonthIndex = (currentDate.Year - displayRange.Start.Year) * MonthsInYear + currentDate.Month - displayRange.Start.Month;
-        calendar.AddBoldedDate(currentDate);
-        Span<uint> boldedDates = stackalloc uint[monthsCount];
-
-        calendar.FillMonthDayStates(boldedDates, displayRange);
-
-        uint expectedState = 1U << (currentDate.Day - 1);
-        uint actualState = boldedDates[currentMonthIndex] & expectedState;
-
-        Assert.Equal(expectedState, actualState);
-    }
-
-    public static IEnumerable<object[]> MonthCalendar_GetIndexInMonths_ReturnsExpected_TestData()
-    {
-        int expectedIndex = 0;
-
-        // This test set of dates is designed to check dates in different years.
-        // The start date is 08/01/2021.
-
-        // Check dates of 2021 year (Aug - Dec)
-        for (int i = 8; i <= 12; i++)
-        {
-            yield return new object[] { new DateTime(2021, i, i), expectedIndex++ };
-        }
-
-        // Check dates of 2022 year (Jan - Sep) bold
-        for (int i = 1; i <= 9; i++)
-        {
-            yield return new object[] { new DateTime(2022, i, i), expectedIndex++ };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MonthCalendar_GetIndexInMonths_ReturnsExpected_TestData))]
-    public unsafe void MonthCalendar_GetIndexInMonths_ReturnsExpected(DateTime currentDate, int expectedIndex)
-    {
-        DateTime startDate = new(2021, 8, 1);
-        using MonthCalendar calendar = new();
-        int actualIndex = calendar.TestAccessor().Dynamic.GetIndexInMonths(startDate, currentDate);
-
-        Assert.Equal(expectedIndex, actualIndex);
-    }
-
-    private class SubMonthCalendar : MonthCalendar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDateChanged(DateRangeEventArgs e) => base.OnDateChanged(e);
-
-        public new void OnDateSelected(DateRangeEventArgs e) => base.OnDateSelected(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnRightToLeftLayoutChanged(EventArgs e) => base.OnRightToLeftLayoutChanged(e);
-
-        public new void RecreateHandle() => base.RecreateHandle();
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MouseEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MouseEventArgsTests.cs
deleted file mode 100644
index 4b65acf3b3e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/MouseEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class MouseEventArgsTests
-{
-    [Theory]
-    [InlineData(MouseButtons.Left, 1, 2, 3, 4)]
-    [InlineData((MouseButtons)1, 0, 0, 0, 0)]
-    [InlineData((MouseButtons)3, -1, -1, -1, -2)]
-    public void Ctor_MouseButtons_Int_Int_Int_Int(MouseButtons button, int clicks, int x, int y, int delta)
-    {
-        var e = new MouseEventArgs(button, clicks, x, y, delta);
-        Assert.Equal(button, e.Button);
-        Assert.Equal(clicks, e.Clicks);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(delta, e.Delta);
-        Assert.Equal(new Point(x, y), e.Location);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NativeWindowTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NativeWindowTests.cs
deleted file mode 100644
index dc358e8a972..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NativeWindowTests.cs
+++ /dev/null
@@ -1,554 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public class NativeWindowTests
-{
-    [WinFormsFact]
-    public void NativeWindow_Ctor_Default()
-    {
-        var window = new NativeWindow();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_ControlHandle_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_TwoNativeWindows_Success()
-    {
-        using Form control = new Form();
-        var window1 = new NativeWindow();
-
-        // ControlNativeWindow (via Form) will be registered with the Handle (by calling .Handle) already.
-        // Invoking AssignHandle on it will set ControlNativeWindow to Previous and assign window1
-        // in the dictionary of window handles (s_windowHandles).
-        window1.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window1.Handle);
-
-        // This will further chain window2, putting window1, then ControlNativeWindow as previous
-        // (Previous) entries in the chain.
-        NativeWindow window2 = new NativeWindow();
-        window2.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window1.Handle);
-        Assert.Equal(control.Handle, window2.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_ControlHandleAfterRelease_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window.Handle);
-
-        window.ReleaseHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-
-        window.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_ZeroHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            var window = new NativeWindow();
-            window.AssignHandle(IntPtr.Zero);
-            Assert.Equal(IntPtr.Zero, window.Handle);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_InvalidHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            var window = new NativeWindow();
-            window.AssignHandle((IntPtr)250);
-            Assert.Equal((IntPtr)250, window.Handle);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_AssignHandle_AlreadyHasHandle_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        Assert.Equal(control.Handle, window.Handle);
-        Assert.Throws<InvalidOperationException>(() => window.AssignHandle((IntPtr)250));
-        Assert.Equal(control.Handle, window.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("SysTabControl32", 0)]
-    [InlineData("SysTabControl32", 100)]
-    public void NativeWindow_CreateHandle_Invoke_Success(string className, int classStyle)
-    {
-        var window1 = new NativeWindow();
-        var cp = new CreateParams
-        {
-            ClassName = className,
-            ClassStyle = classStyle
-        };
-        window1.CreateHandle(cp);
-        try
-        {
-            Assert.NotEqual(IntPtr.Zero, window1.Handle);
-            Assert.Null(cp.Caption);
-
-            // Call again on another class to test caching.
-            var window2 = new NativeWindow();
-            window2.CreateHandle(cp);
-            try
-            {
-                Assert.NotEqual(IntPtr.Zero, window2.Handle);
-                Assert.NotEqual(window1.Handle, window2.Handle);
-                Assert.Null(cp.Caption);
-            }
-            finally
-            {
-                window2.DestroyHandle();
-            }
-        }
-        finally
-        {
-            window1.DestroyHandle();
-        }
-    }
-
-    public static IEnumerable<object[]> CreateHandle_Caption_TestData()
-    {
-        yield return new object[] { string.Empty, string.Empty };
-        yield return new object[] { "abc", "abc" };
-        yield return new object[] { new string('a', short.MaxValue + 1), new string('a', short.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateHandle_Caption_TestData))]
-    public void NativeWindow_CreateHandle_InvokeWithCaption_Success(string caption, string expectedCaption)
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        var cp = new CreateParams
-        {
-            Caption = caption
-        };
-        window.CreateHandle(cp);
-        try
-        {
-            Assert.NotEqual(IntPtr.Zero, window.Handle);
-            Assert.Equal(expectedCaption, cp.Caption);
-        }
-        finally
-        {
-            window.DestroyHandle();
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_CreateHandle_NullCp_ThrowsNullReferenceException()
-    {
-        var window = new NativeWindow();
-        Assert.Throws<NullReferenceException>(() => window.CreateHandle(null));
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_CreateHandle_AlreadyHasHandle_ThrowsInvalidOperationException()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        IntPtr handle = window.Handle;
-
-        var cp = new CreateParams();
-        Assert.Throws<InvalidOperationException>(() => window.CreateHandle(cp));
-        Assert.Equal(handle, window.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("noSuchClassName")]
-    public void NativeWindow_CreateHandle_InvalidWindowClassName_ThrowsWin32Exception(string className)
-    {
-        var window = new NativeWindow();
-        var cp = new CreateParams
-        {
-            ClassName = className
-        };
-        Assert.Throws<Win32Exception>(() => window.CreateHandle(cp));
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_CreateHandle_InvokeAlreadyExists_ThrowsWin32Exception()
-    {
-        var window1 = new NativeWindow();
-        var cp1 = new CreateParams
-        {
-            ClassName = "SysTabControl32"
-        };
-        window1.CreateHandle(cp1);
-        try
-        {
-            Assert.NotEqual(IntPtr.Zero, window1.Handle);
-
-            var window2 = new NativeWindow();
-            var cp2 = new CreateParams
-            {
-                ClassName = "systabcontrol32"
-            };
-            Assert.Throws<Win32Exception>(() => window2.CreateHandle(cp2));
-            Assert.Equal(IntPtr.Zero, window2.Handle);
-        }
-        finally
-        {
-            window1.DestroyHandle();
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_DestroyHandle_InvokeWithCreatedHandle_Success()
-    {
-        var window = new NativeWindow();
-        var cp = new CreateParams();
-        window.CreateHandle(cp);
-        window.DestroyHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_DestroyHandle_InvokeWithValidAssignedHandle_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        window.DestroyHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_DestroyHandle_InvokeWithInvalidAssignedHandle_Nop()
-    {
-        using (new NoAssertContext())
-        {
-            var window = new NativeWindow();
-            window.AssignHandle((IntPtr)250);
-            window.DestroyHandle();
-            Assert.Equal(IntPtr.Zero, window.Handle);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_DestroyHandle_InvokeWithoutHandle_Nop()
-    {
-        var window = new NativeWindow();
-        window.DestroyHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_DefWndProc_InvokeWithCreatedHandle_Nop(int msg)
-    {
-        var window = new WndProcTrackingNativeWindow();
-        window.CreateHandle(new CreateParams());
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.DefWndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.NotEqual(IntPtr.Zero, window.Handle);
-        }
-        finally
-        {
-            window.DestroyHandle();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    public void NativeWindow_DefWndProc_InvokeWithValidAssignedHandle_Nop(int msg)
-    {
-        using var control = new Control();
-        var window = new WndProcTrackingNativeWindow();
-        window.AssignHandle(control.Handle);
-
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.DefWndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(control.Handle, window.Handle);
-        }
-        finally
-        {
-            window.ReleaseHandle();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_DefWndProc_InvokeWithInvalidHandle_Nop(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            var window = new WndProcTrackingNativeWindow();
-            window.AssignHandle((IntPtr)250);
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.DefWndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal((IntPtr)250, window.Handle);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_DefWindProc_InvokeAfterAssignHandle_Success()
-    {
-        using var control = new Control();
-        var window1 = new WndProcTrackingNativeWindow
-        {
-            MessageTypePredicate = (msg) => msg == 123456
-        };
-        window1.AssignHandle(control.Handle);
-
-        Message m = new Message
-        {
-            Msg = 123456
-        };
-
-        // As we don't have a "Previous" the default window procedure gets called
-        window1.DefWndProc(ref m);
-        Assert.Empty(window1.Messages);
-
-        // This will set the existing window as Previous. When Previous NativeWindows
-        // are registered for the same handle, a chain of calls will happen until the original
-        // registered NativeWindow for a given handle is reached (i.e. no Previous). The
-        // call chain is like this:
-        //
-        //   DefWndProc() -> PreviousWindow.CallBack() -> WndProc() -> DefWndProc()
-        var window2 = new WndProcTrackingNativeWindow
-        {
-            MessageTypePredicate = (msg) => msg == 123456
-        };
-        window2.AssignHandle(window1.Handle);
-        window2.DefWndProc(ref m);
-        Assert.Single(window1.Messages);
-        Assert.Empty(window2.Messages);
-
-        // Check that the message continues to work back.
-        var window3 = new WndProcTrackingNativeWindow
-        {
-            MessageTypePredicate = (msg) => msg == 123456
-        };
-        window3.AssignHandle(window1.Handle);
-        window3.DefWndProc(ref m);
-        Assert.Equal(2, window1.Messages.Count);
-        Assert.Single(window2.Messages);
-        Assert.Empty(window3.Messages);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_DefWndProc_InvokeWithoutHandle_Nop(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            var window = new WndProcTrackingNativeWindow();
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.DefWndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Empty(window.Messages);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_ReleaseHandle_InvokeWithCreatedHandle_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        window.ReleaseHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_ReleaseHandle_InvokeWithValidAssignedHandle_Success()
-    {
-        using var control = new Control();
-        var window = new NativeWindow();
-        window.AssignHandle(control.Handle);
-        window.ReleaseHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_ReleaseHandle_InvokeWithInvalidAssignedHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new Control();
-            var window = new NativeWindow();
-            window.AssignHandle((IntPtr)250);
-            window.ReleaseHandle();
-            Assert.Equal(IntPtr.Zero, window.Handle);
-        }
-    }
-
-    [WinFormsFact]
-    public void NativeWindow_ReleaseHandle_InvokeWithoutHandle_Nop()
-    {
-        var window = new NativeWindow();
-        window.ReleaseHandle();
-        Assert.Equal(IntPtr.Zero, window.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_WndProc_InvokeWithCreatedHandle_Success(int msg)
-    {
-        var window = new SubNativeWindow();
-        window.CreateHandle(new CreateParams());
-
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-        }
-        finally
-        {
-            window.DestroyHandle();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    public void NativeWindow_WndProc_InvokeWithValidAssignedHandle_Success(int msg)
-    {
-        using var control = new Control();
-        var window = new SubNativeWindow();
-        window.AssignHandle(control.Handle);
-
-        try
-        {
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(control.Handle, window.Handle);
-        }
-        finally
-        {
-            window.ReleaseHandle();
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_WndProc_InvokeWithInvalidAssignedHandle_Nop(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            var window = new SubNativeWindow();
-            window.AssignHandle((IntPtr)250);
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal((IntPtr)250, window.Handle);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1234)]
-    [InlineData((int)PInvoke.WM_NCDESTROY)]
-    public void NativeWindow_WndProc_InvokeWithoutHandle_Nop(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            var window = new SubNativeWindow();
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)1
-            };
-            window.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-        }
-    }
-
-    private class SubNativeWindow : NativeWindow
-    {
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class WndProcTrackingNativeWindow : NativeWindow
-    {
-        public Predicate<int> MessageTypePredicate { get; set; }
-
-        public List<Message> Messages { get; } = new List<Message>();
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MessageTypePredicate is null || MessageTypePredicate(m.Msg))
-            {
-                Messages.Add(m);
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NavigateEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NavigateEventArgsTests.cs
deleted file mode 100644
index 5ee4b70620f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NavigateEventArgsTests.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class NavigateEventArgsTests
-{
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Ctor_Bool(bool isForward)
-    {
-        var e = new NavigateEventArgs(isForward);
-        Assert.Equal(isForward, e.Forward);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NodeLabelEditEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NodeLabelEditEventArgsTests.cs
deleted file mode 100644
index f77db17dbd9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NodeLabelEditEventArgsTests.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class NodeLabelEditEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeNode() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_TestData))]
-    public void Ctor_TreeNode(TreeNode node)
-    {
-        var e = new NodeLabelEditEventArgs(node);
-        Assert.Equal(node, e.Node);
-        Assert.Null(e.Label);
-        Assert.False(e.CancelEdit);
-    }
-
-    public static IEnumerable<object[]> Ctor_TreeNode_String_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new TreeNode(), "" };
-        yield return new object[] { new TreeNode(), "label" };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_String_TestData))]
-    public void Ctor_TreeNode_String(TreeNode node, string label)
-    {
-        var e = new NodeLabelEditEventArgs(node, label);
-        Assert.Equal(node, e.Node);
-        Assert.Equal(label, e.Label);
-        Assert.False(e.CancelEdit);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void CancelEdit_Set_GetReturnsExpected(bool value)
-    {
-        var e = new NodeLabelEditEventArgs(new TreeNode())
-        {
-            CancelEdit = value
-        };
-        Assert.Equal(value, e.CancelEdit);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NoneExcludedImageIndexConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NoneExcludedImageIndexConverterTests.cs
deleted file mode 100644
index 7eac7d79ffe..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NoneExcludedImageIndexConverterTests.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class NoneExcludedImageIndexConverterTests
-{
-    [Fact]
-    public void NoneExcludedImageIndexConverter_IncludeNoneAsStandardValue_ReturnsFalse()
-    {
-        Assert.False(new NoneExcludedImageIndexConverter().TestAccessor().Dynamic.IncludeNoneAsStandardValue);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NotifyIconTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NotifyIconTests.cs
deleted file mode 100644
index 0de0a866866..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NotifyIconTests.cs
+++ /dev/null
@@ -1,976 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class NotifyIconTests
-{
-    [WinFormsFact]
-    public void NotifyIcon_Ctor_Default()
-    {
-        using var notifyIcon = new NotifyIcon();
-        Assert.Equal(ToolTipIcon.None, notifyIcon.BalloonTipIcon);
-        Assert.Empty(notifyIcon.BalloonTipText);
-        Assert.Empty(notifyIcon.BalloonTipTitle);
-        Assert.Null(notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.Null(notifyIcon.Site);
-        Assert.Null(notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.False(notifyIcon.Visible);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Ctor_IContainer()
-    {
-        var container = new Container();
-        using var notifyIcon = new NotifyIcon(container);
-        Assert.Equal(ToolTipIcon.None, notifyIcon.BalloonTipIcon);
-        Assert.Empty(notifyIcon.BalloonTipText);
-        Assert.Empty(notifyIcon.BalloonTipTitle);
-        Assert.Same(container, notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.NotNull(notifyIcon.Site);
-        Assert.Null(notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.False(notifyIcon.Visible);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Ctor_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new NotifyIcon(null));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolTipIcon>]
-    public void NotifyIcon_BalloonTipIcon_Set_GetReturnsExpected(ToolTipIcon value)
-    {
-        var notifyIcon = new NotifyIcon
-        {
-            BalloonTipIcon = value
-        };
-        Assert.Equal(value, notifyIcon.BalloonTipIcon);
-
-        // Set same.
-        notifyIcon.BalloonTipIcon = value;
-        Assert.Equal(value, notifyIcon.BalloonTipIcon);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolTipIcon>]
-    public void NotifyIcon_BalloonTipIcon_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolTipIcon value)
-    {
-        var notifyIcon = new NotifyIcon();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => notifyIcon.BalloonTipIcon = value);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void CollectionForm_BalloonTipText_Set_GetReturnsExpected(string value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipText = value
-        };
-        Assert.Equal(value, notifyIcon.BalloonTipText);
-
-        // Set same.
-        notifyIcon.BalloonTipText = value;
-        Assert.Equal(value, notifyIcon.BalloonTipText);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void CollectionForm_BalloonTipText_SetWithCustomOldValue_GetReturnsExpected(string value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipText = "OldValue"
-        };
-
-        notifyIcon.BalloonTipText = value;
-        Assert.Equal(value, notifyIcon.BalloonTipText);
-
-        // Set same.
-        notifyIcon.BalloonTipText = value;
-        Assert.Equal(value, notifyIcon.BalloonTipText);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void CollectionForm_BalloonTipTitle_Set_GetReturnsExpected(string value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = value
-        };
-        Assert.Equal(value, notifyIcon.BalloonTipTitle);
-
-        // Set same.
-        notifyIcon.BalloonTipTitle = value;
-        Assert.Equal(value, notifyIcon.BalloonTipTitle);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void CollectionForm_BalloonTipTitle_SetWithCustomOldValue_GetReturnsExpected(string value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = "OldValue"
-        };
-
-        notifyIcon.BalloonTipTitle = value;
-        Assert.Equal(value, notifyIcon.BalloonTipTitle);
-
-        // Set same.
-        notifyIcon.BalloonTipTitle = value;
-        Assert.Equal(value, notifyIcon.BalloonTipTitle);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void CollectionForm_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-
-        // Set same.
-        notifyIcon.ContextMenuStrip = value;
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void CollectionForm_ContextMenuStrip_SetWithCustomOldValue_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var menu = new ContextMenuStrip();
-        using var notifyIcon = new NotifyIcon
-        {
-            ContextMenuStrip = menu
-        };
-
-        notifyIcon.ContextMenuStrip = value;
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-
-        // Set same.
-        notifyIcon.ContextMenuStrip = value;
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void CollectionForm_ContextMenuStrip_SetDisposed_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var notifyIcon = new NotifyIcon();
-        notifyIcon.Dispose();
-
-        notifyIcon.ContextMenuStrip = value;
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-
-        // Set same.
-        notifyIcon.ContextMenuStrip = value;
-        Assert.Equal(value, notifyIcon.ContextMenuStrip);
-    }
-
-    public static IEnumerable<object[]> Icon_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Icon("bitmaps/10x16_one_entry_32bit.ico") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_Set_TestData))]
-    public void NotifyIcon_Icon_Set_GetReturnsExpected(Icon value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = value
-        };
-        Assert.Same(value, notifyIcon.Icon);
-
-        // Set same.
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_Set_TestData))]
-    public void NotifyIcon_Icon_SetWithCustomOldValue_GetReturnsExpected(Icon value)
-    {
-        using var oldValue = new Icon(new Icon("bitmaps/10x16_one_entry_32bit.ico"), 10, 10);
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = oldValue
-        };
-
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-
-        // Set same.
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_Set_TestData))]
-    public void NotifyIcon_Icon_SetWithVisible_GetReturnsExpected(Icon value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = true,
-            Icon = value
-        };
-        Assert.Same(value, notifyIcon.Icon);
-
-        // Set same.
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-    }
-
-    public static IEnumerable<object[]> Icon_SetDesignMode_TestData()
-    {
-        yield return new object[] { null, 0 };
-        yield return new object[] { new Icon("bitmaps/10x16_one_entry_32bit.ico"), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_SetDesignMode_TestData))]
-    public void NotifyIcon_Icon_SetDesignMode_GetReturnsExpected(Icon value, int expectedDesignModeCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            Site = mockSite.Object,
-            Icon = value
-        };
-        Assert.Same(value, notifyIcon.Icon);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set same.
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Icon_SetDesignMode_TestData))]
-    public void NotifyIcon_Icon_SetDesignModeWithVisible_GetReturnsExpected(Icon value, int expectedDesignModeCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = true,
-            Site = mockSite.Object,
-            Icon = value
-        };
-        Assert.Same(value, notifyIcon.Icon);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set same.
-        notifyIcon.Icon = value;
-        Assert.Same(value, notifyIcon.Icon);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Icon_SetDisposed_ThrowsNullReferenceException()
-    {
-        using var notifyIcon = new NotifyIcon();
-        notifyIcon.Dispose();
-        using var value = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        Assert.Throws<NullReferenceException>(() => notifyIcon.Icon = value);
-        Assert.Same(value, notifyIcon.Icon);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void CollectionForm_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Tag = value
-        };
-        Assert.Same(value, notifyIcon.Tag);
-
-        // Set same.
-        notifyIcon.Tag = value;
-        Assert.Same(value, notifyIcon.Tag);
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Icon icon in new Icon[] { null, new Icon("bitmaps/10x16_one_entry_32bit.ico") })
-            {
-                yield return new object[] { visible, icon, null, string.Empty };
-                yield return new object[] { visible, icon, string.Empty, string.Empty };
-                yield return new object[] { visible, icon, "text", "text" };
-                yield return new object[] { visible, icon, new string('a', NotifyIcon.MaxTextSize), new string('a', NotifyIcon.MaxTextSize) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void CollectionForm_Text_Set_GetReturnsExpected(bool visible, Icon icon, string value, string expected)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = visible,
-            Icon = icon,
-            Text = value
-        };
-        Assert.Equal(expected, notifyIcon.Text);
-
-        // Set same.
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void CollectionForm_Text_SetWithCustomOldValue_GetReturnsExpected(bool visible, Icon icon, string value, string expected)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = visible,
-            Icon = icon,
-            Text = "OldValue"
-        };
-
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-
-        // Set same.
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-    }
-
-    public static IEnumerable<object[]> Text_SetDesignMode_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Icon icon in new Icon[] { null, new Icon("bitmaps/10x16_one_entry_32bit.ico") })
-            {
-                yield return new object[] { visible, icon, null, string.Empty, 0 };
-                yield return new object[] { visible, icon, string.Empty, string.Empty, 0 };
-            }
-
-            yield return new object[] { visible, null, "text", "text", 0 };
-            yield return new object[] { visible, null, new string('a', NotifyIcon.MaxTextSize), new string('a', NotifyIcon.MaxTextSize), 0 };
-        }
-
-        yield return new object[] { false, new Icon("bitmaps/10x16_one_entry_32bit.ico"), "text", "text", 0 };
-        yield return new object[] { false, new Icon("bitmaps/10x16_one_entry_32bit.ico"), new string('a', NotifyIcon.MaxTextSize), new string('a', NotifyIcon.MaxTextSize), 0 };
-        yield return new object[] { true, new Icon("bitmaps/10x16_one_entry_32bit.ico"), "text", "text", 1 };
-        yield return new object[] { true, new Icon("bitmaps/10x16_one_entry_32bit.ico"), new string('a', NotifyIcon.MaxTextSize), new string('a', NotifyIcon.MaxTextSize), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetDesignMode_TestData))]
-    public void CollectionForm_Text_SetDesignMode_GetReturnsExpected(bool visible, Icon icon, string value, string expected, int expectedDesignModeCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = visible,
-            Icon = icon,
-            Site = mockSite.Object,
-            Text = value
-        };
-        Assert.Equal(expected, notifyIcon.Text);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set same.
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Text_SetLongValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var notifyIcon = new NotifyIcon();
-        Assert.Throws<ArgumentOutOfRangeException>("Text", () => notifyIcon.Text = new string('a', NotifyIcon.MaxTextSize + 1));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void CollectionForm_Text_SetDisposed_GetReturnsExpected(bool visible, Icon icon, string value, string expected)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = visible,
-            Icon = icon
-        };
-        notifyIcon.Dispose();
-
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-
-        // Set same.
-        notifyIcon.Text = value;
-        Assert.Equal(expected, notifyIcon.Text);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void NotifyIcon_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = value
-        };
-        Assert.Equal(value, notifyIcon.Visible);
-
-        // Set same.
-        notifyIcon.Visible = value;
-        Assert.Equal(value, notifyIcon.Visible);
-
-        // Set different.
-        notifyIcon.Visible = !value;
-        Assert.Equal(!value, notifyIcon.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void NotifyIcon_Visible_SetWithIcon_GetReturnsExpected(bool value)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = icon,
-            Visible = value
-        };
-        Assert.Equal(value, notifyIcon.Visible);
-
-        // Set same.
-        notifyIcon.Visible = value;
-        Assert.Equal(value, notifyIcon.Visible);
-
-        // Set different.
-        notifyIcon.Visible = !value;
-        Assert.Equal(!value, notifyIcon.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void NotifyIcon_Visible_SetDesignMode_GetReturnsExpected(bool value, int expectedDesignModeCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            Site = mockSite.Object,
-            Visible = value
-        };
-        Assert.Equal(value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set same.
-        notifyIcon.Visible = value;
-        Assert.Equal(value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set different.
-        notifyIcon.Visible = !value;
-        Assert.Equal(!value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount + 1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void NotifyIcon_Visible_SetDesignModeWithIcon_GetReturnsExpected(bool value, int expectedDesignModeCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = icon,
-            Site = mockSite.Object,
-            Visible = value
-        };
-        Assert.Equal(value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set same.
-        notifyIcon.Visible = value;
-        Assert.Equal(value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount));
-
-        // Set different.
-        notifyIcon.Visible = !value;
-        Assert.Equal(!value, notifyIcon.Visible);
-        mockSite.Verify(s => s.DesignMode, Times.Exactly(expectedDesignModeCallCount + 1));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void NotifyIcon_Visible_SetDisposed_ThrowsNullReferenceException(bool value)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            Visible = value
-        };
-        notifyIcon.Dispose();
-        Assert.Throws<NullReferenceException>(() => notifyIcon.Visible = !value);
-        Assert.Equal(value, notifyIcon.Visible);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_BalloonTipClicked_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.BalloonTipClicked += handler;
-        notifyIcon.BalloonTipClicked -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_BalloonTipClosed_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.BalloonTipClosed += handler;
-        notifyIcon.BalloonTipClosed -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_BalloonTipShown_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.BalloonTipShown += handler;
-        notifyIcon.BalloonTipShown -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Click_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.Click += handler;
-        notifyIcon.Click -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_DoubleClick_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.DoubleClick += handler;
-        notifyIcon.DoubleClick -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_MouseClick_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.MouseClick += handler;
-        notifyIcon.MouseClick -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_MouseDoubleClick_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.MouseDoubleClick += handler;
-        notifyIcon.MouseDoubleClick -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_MouseDown_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.MouseDown += handler;
-        notifyIcon.MouseDown -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_MouseMove_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.MouseMove += handler;
-        notifyIcon.MouseMove -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_MouseUp_AddRemoveEvent_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            callCount++;
-        }
-
-        notifyIcon.MouseUp += handler;
-        notifyIcon.MouseUp -= handler;
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_Dispose_Invoke_Success()
-    {
-        using var notifyIcon = new NotifyIcon();
-        int callCount = 0;
-        notifyIcon.Disposed += (sender, e) => callCount++;
-
-        notifyIcon.Dispose();
-
-        Assert.Equal(ToolTipIcon.None, notifyIcon.BalloonTipIcon);
-        Assert.Empty(notifyIcon.BalloonTipText);
-        Assert.Empty(notifyIcon.BalloonTipTitle);
-        Assert.Null(notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.Null(notifyIcon.Site);
-        Assert.Null(notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.False(notifyIcon.Visible);
-        Assert.Equal(1, callCount);
-
-        notifyIcon.Dispose();
-
-        Assert.Equal(ToolTipIcon.None, notifyIcon.BalloonTipIcon);
-        Assert.Empty(notifyIcon.BalloonTipText);
-        Assert.Empty(notifyIcon.BalloonTipTitle);
-        Assert.Null(notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.Null(notifyIcon.Site);
-        Assert.Null(notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.False(notifyIcon.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Dispose_WithProperties_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Icon icon in new Icon[] { null, new Icon("bitmaps/10x16_one_entry_32bit.ico") })
-            {
-                yield return new object[] { visible, icon };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dispose_WithProperties_TestData))]
-    public void NotifyIcon_Dispose_InvokePropertiesSet_Success(bool visible, Icon icon)
-    {
-        using var contextMenuStrip = new ContextMenuStrip();
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipIcon = ToolTipIcon.Error,
-            BalloonTipText = "BalloonTipText",
-            BalloonTipTitle = "BalloonTipTitle",
-            ContextMenuStrip = contextMenuStrip,
-            Icon = icon,
-            Text = "Text",
-            Tag = "Tag",
-            Visible = visible
-        };
-        int callCount = 0;
-        notifyIcon.Disposed += (sender, e) => callCount++;
-
-        notifyIcon.Dispose();
-        Assert.Equal(ToolTipIcon.Error, notifyIcon.BalloonTipIcon);
-        Assert.Equal("BalloonTipText", notifyIcon.BalloonTipText);
-        Assert.Equal("BalloonTipTitle", notifyIcon.BalloonTipTitle);
-        Assert.Null(notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.Null(notifyIcon.Site);
-        Assert.Equal("Tag", notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.Equal(visible, notifyIcon.Visible);
-        Assert.Equal(1, callCount);
-
-        notifyIcon.Dispose();
-        Assert.Equal(ToolTipIcon.Error, notifyIcon.BalloonTipIcon);
-        Assert.Equal("BalloonTipText", notifyIcon.BalloonTipText);
-        Assert.Equal("BalloonTipTitle", notifyIcon.BalloonTipTitle);
-        Assert.Null(notifyIcon.Container);
-        Assert.Null(notifyIcon.ContextMenuStrip);
-        Assert.Null(notifyIcon.Icon);
-        Assert.Null(notifyIcon.Site);
-        Assert.Equal("Tag", notifyIcon.Tag);
-        Assert.Empty(notifyIcon.Text);
-        Assert.Equal(visible, notifyIcon.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> ShowBalloonTip_TestData()
-    {
-        foreach (ToolTipIcon tipIcon in Enum.GetValues(typeof(ToolTipIcon)))
-        {
-            yield return new object[] { 0, tipIcon };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeInt_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = "BalloonTipTitle",
-            BalloonTipText = "BalloonTipText",
-            BalloonTipIcon = tipIcon
-        };
-        notifyIcon.ShowBalloonTip(timeout);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntAdded_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = "BalloonTipTitle",
-            BalloonTipText = "BalloonTipText",
-            BalloonTipIcon = tipIcon,
-            Icon = icon,
-            Visible = true
-        };
-        notifyIcon.ShowBalloonTip(timeout);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntAddedDesignMode_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = "BalloonTipTitle",
-            BalloonTipText = "BalloonTipText",
-            BalloonTipIcon = tipIcon,
-            Icon = icon,
-            Visible = true,
-            Site = mockSite.Object
-        };
-        notifyIcon.ShowBalloonTip(timeout);
-        mockSite.Verify(s => s.DesignMode, Times.Once());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntDisposed_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipTitle = "BalloonTipTitle",
-            BalloonTipText = "BalloonTipText",
-            BalloonTipIcon = tipIcon,
-            Icon = icon,
-            Visible = true
-        };
-        notifyIcon.Dispose();
-
-        notifyIcon.ShowBalloonTip(timeout);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntStringStringToolTipIcon_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var notifyIcon = new NotifyIcon();
-        notifyIcon.ShowBalloonTip(timeout, "tipTitle", "tipText", tipIcon);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntStringStringToolTipIconAdded_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = icon,
-            Visible = true
-        };
-        notifyIcon.ShowBalloonTip(timeout, "tipTitle", "tipText", tipIcon);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntStringStringToolTipIconDisposed_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = icon,
-            Visible = true
-        };
-        notifyIcon.Dispose();
-        notifyIcon.ShowBalloonTip(timeout, "tipTitle", "tipText", tipIcon);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ShowBalloonTip_TestData))]
-    public void NotifyIcon_ShowBalloonTip_InvokeIntStringStringToolTipIconAddedDesignMode_Success(int timeout, ToolTipIcon tipIcon)
-    {
-        using var icon = new Icon("bitmaps/10x16_one_entry_32bit.ico");
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var notifyIcon = new NotifyIcon
-        {
-            Icon = icon,
-            Visible = true,
-            Site = mockSite.Object
-        };
-        notifyIcon.ShowBalloonTip(timeout, "tipTitle", "tipText", tipIcon);
-        mockSite.Verify(s => s.DesignMode, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void NotifyIcon_ShowBalloonTip_InvokeNegativeTimeout_ThrowsArgumentOutOfRangeException()
-    {
-        using var notifyIcon = new NotifyIcon();
-        Assert.Throws<ArgumentOutOfRangeException>("timeout", () => notifyIcon.ShowBalloonTip(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("timeout", () => notifyIcon.ShowBalloonTip(-1, "Title", "Text", ToolTipIcon.Error));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void NotifyIcon_ShowBalloonTip_InvokeInvalidText_ThrowsArgumentException(string tipText)
-    {
-        using var notifyIcon = new NotifyIcon
-        {
-            BalloonTipText = tipText
-        };
-        Assert.Throws<ArgumentException>(() => notifyIcon.ShowBalloonTip(0));
-        Assert.Throws<ArgumentException>(() => notifyIcon.ShowBalloonTip(0, "Title", tipText, ToolTipIcon.Error));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolTipIcon>]
-    public void NotifyIcon_ShowBalloonTip_InvokeInvalidTipIcon_ThrowsInvalidEnumArgumentException(ToolTipIcon tipIcon)
-    {
-        using var notifyIcon = new NotifyIcon();
-        Assert.Throws<InvalidEnumArgumentException>("tipIcon", () => notifyIcon.ShowBalloonTip(0, "Title", "Text", tipIcon));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NumericUpDownAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NumericUpDownAccessibleObjectTests.cs
deleted file mode 100644
index 3ba3fa63df7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/NumericUpDownAccessibleObjectTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class NumericUpDownAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void NumericUpDownAccessibleObject_Ctor_Default()
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        AccessibleObject accessibleObject = numericUpDown.AccessibilityObject;
-        Assert.NotNull(accessibleObject);
-    }
-
-    [WinFormsFact]
-    public void NumericUpDownAccessibleObject_GetPropertyValue_IsKeyboardFocusable_ReturnsTrue()
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        AccessibleObject accessibleObject = numericUpDown.AccessibilityObject;
-
-        bool isKeyboardFocusable = (bool)accessibleObject.GetPropertyValue(Interop.UiaCore.UIA.IsKeyboardFocusablePropertyId);
-        Assert.True(isKeyboardFocusable);
-    }
-
-    [WinFormsFact]
-    public void NumericUpDownAccessibleObject_GetPropertyValue_IsKeyboardFocusable_WhenDisabled_ReturnsFalse()
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        AccessibleObject accessibleObject = numericUpDown.AccessibilityObject;
-
-        numericUpDown.Enabled = false;
-
-        bool isKeyboardFocusable = (bool)accessibleObject.GetPropertyValue(Interop.UiaCore.UIA.IsKeyboardFocusablePropertyId);
-        Assert.False(isKeyboardFocusable);
-    }
-
-    [WinFormsFact]
-    public void NumericUpDownAccessibleObject_ControlType_IsSpinner_IfAccessibleRoleIsDefault()
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        // AccessibleRole is not set = Default
-
-        object actual = numericUpDown.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.SpinnerControlTypeId, actual);
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void NumericUpDownAccessibleObject_Role_IsSpinButton_ByDefault()
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = numericUpDown.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.SpinButton, actual);
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> NumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void NumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        numericUpDown.AccessibleRole = role;
-
-        object actual = numericUpDown.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.SpinButton)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleStatePropertyId, AccessibleStates.None)]
-    public void NumericUpDownAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using NumericUpDown numericUpDown = new NumericUpDown();
-        AccessibleObject accessibleObject = numericUpDown.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OSFeatureTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OSFeatureTests.cs
deleted file mode 100644
index 00bb4d5bac9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OSFeatureTests.cs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class OSFeatureTests
-{
-    [Fact]
-    public void OSFeature_Ctor_Default()
-    {
-        // Make sure it doesn't throw.
-        new SubOSFeature();
-    }
-
-    [Fact]
-    public void OSFeature_Feature_Get_ReturnsExpected()
-    {
-        OSFeature feature = OSFeature.Feature;
-        Assert.NotNull(feature);
-        Assert.Same(feature, OSFeature.Feature);
-    }
-
-    [Fact]
-    public void OSFeature_LayeredWindows_Get_ReturnsExpected()
-    {
-        object feature = OSFeature.LayeredWindows;
-        Assert.NotNull(feature);
-        Assert.Same(feature, OSFeature.LayeredWindows);
-    }
-
-    [Fact]
-    public void OSFeature_Themes_Get_ReturnsExpected()
-    {
-        object feature = OSFeature.Themes;
-        Assert.NotNull(feature);
-        Assert.Same(feature, OSFeature.Themes);
-    }
-
-    public static IEnumerable<object[]> GetVersionPresent_TestData()
-    {
-        yield return new object[] { OSFeature.LayeredWindows, new Version(0, 0, 0, 0) };
-        yield return new object[] { OSFeature.Themes, new Version(0, 0, 0, 0) };
-        yield return new object[] { new object(), null };
-        yield return new object[] { null, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetVersionPresent_TestData))]
-    public void OSFeature_GetVersionPresent_Invoke_ReturnsExpected(object feature, Version expected)
-    {
-        Assert.Equal(expected, OSFeature.Feature.GetVersionPresent(feature));
-
-        // Call again to test caching.
-        Assert.Equal(expected, OSFeature.Feature.GetVersionPresent(feature));
-    }
-
-    public static IEnumerable<object[]> IsPresent_TestData()
-    {
-        yield return new object[] { SystemParameter.DropShadow, true };
-        yield return new object[] { SystemParameter.FlatMenu, true };
-        yield return new object[] { SystemParameter.FontSmoothingContrastMetric, true };
-        yield return new object[] { SystemParameter.FontSmoothingTypeMetric, true };
-        yield return new object[] { SystemParameter.MenuFadeEnabled, true };
-        yield return new object[] { SystemParameter.SelectionFade, true };
-        yield return new object[] { SystemParameter.ToolTipAnimationMetric, true };
-        yield return new object[] { SystemParameter.UIEffects, true };
-        yield return new object[] { SystemParameter.CaretWidthMetric, true };
-        yield return new object[] { SystemParameter.VerticalFocusThicknessMetric, true };
-        yield return new object[] { SystemParameter.HorizontalFocusThicknessMetric, true };
-        yield return new object[] { SystemParameter.DropShadow - 1, false };
-        yield return new object[] { SystemParameter.HorizontalFocusThicknessMetric + 1, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsPresent_TestData))]
-    public void OSFeature_IsPresent_Invoke_ReturnsExpected(SystemParameter feature, bool expected)
-    {
-        Assert.Equal(expected, OSFeature.IsPresent(feature));
-    }
-
-    private class SubOSFeature : OSFeature
-    {
-        public SubOSFeature() : base()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpacityConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpacityConverterTests.cs
deleted file mode 100644
index c0d5e402bd4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpacityConverterTests.cs
+++ /dev/null
@@ -1,130 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.Design.Serialization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class OpacityConverterTests
-{
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(string), true)]
-    public void OpacityConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new OpacityConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_TestData()
-    {
-        yield return new object[] { "0%", 0.0 };
-        yield return new object[] { "100%", 1.0 };
-        yield return new object[] { "90%", 0.9 };
-        yield return new object[] { "  90  %  ", 0.9 };
-        yield return new object[] { "0.0", 0.0 };
-        yield return new object[] { "0.9", 0.9 };
-        yield return new object[] { "1.0", 1.0 };
-        yield return new object[] { "1.2%", 0.012 };
-        yield return new object[] { "1.1", 0.011 };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_TestData))]
-    public void OpacityConverter_ConvertFrom_String_ReturnsExpected(string value, double expected)
-    {
-        var converter = new OpacityConverter();
-        Assert.Equal(expected, Assert.IsType<double>(converter.ConvertFrom(value)), 5);
-        Assert.Equal(expected, Assert.IsType<double>(converter.ConvertFrom(null, null, value)), 5);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void OpacityConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new OpacityConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("")]
-    [InlineData("1%.2")]
-    [InlineData("-1")]
-    [InlineData("101")]
-    [InlineData("-1%")]
-    [InlineData("101%")]
-    [InlineData("-0.1")]
-    [InlineData("-0.1%")]
-    [InlineData("invalid")]
-    public void OpacityConverter_ConvertFrom_InvalidString_ThrowsFormatException(string value)
-    {
-        var converter = new OpacityConverter();
-        Assert.Throws<FormatException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), false)]
-    [InlineData(typeof(double), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void OpacityConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new OpacityConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Theory]
-    [InlineData(0.0, "0%")]
-    [InlineData(0, "0")]
-    public void OpacityConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
-    {
-        var converter = new OpacityConverter();
-        Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
-        Assert.Equal(expected, converter.ConvertTo(null, null, value, typeof(string)));
-    }
-
-    [Fact]
-    public void OpacityConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new OpacityConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void OpacityConverter_ConvertTo_ValueNotDouble_ThrowsNotSupportedException()
-    {
-        var converter = new OpacityConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(double))]
-    [InlineData(typeof(InstanceDescriptor))]
-    [InlineData(typeof(int))]
-    public void OpacityConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new OpacityConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1.1, destinationType));
-    }
-
-    [Fact]
-    public void OpacityConverter_ConverterGetCreateInstanceSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new OpacityConverter();
-        Assert.False(converter.GetCreateInstanceSupported());
-    }
-
-    [Fact]
-    public void OpacityConverter_ConverterGetPropertiesSupported_Invoke_ReturnsFalse()
-    {
-        var converter = new OpacityConverter();
-        Assert.False(converter.GetPropertiesSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpenFileDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpenFileDialogTests.cs
deleted file mode 100644
index 0a67aa770bd..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OpenFileDialogTests.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class OpenFileDialogTests
-{
-    [WinFormsFact]
-    public void OpenFileDialog_Ctor_Default()
-    {
-        using var dialog = new OpenFileDialog();
-        Assert.True(dialog.CheckFileExists);
-        Assert.False(dialog.Multiselect);
-        Assert.False(dialog.ReadOnlyChecked);
-        Assert.True(dialog.SelectReadOnly);
-        Assert.False(dialog.ShowPreview);
-        Assert.False(dialog.ShowReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_CheckFileExists_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            CheckFileExists = value
-        };
-        Assert.Equal(value, dialog.CheckFileExists);
-
-        // Set same.
-        dialog.CheckFileExists = value;
-        Assert.Equal(value, dialog.CheckFileExists);
-
-        // Set different.
-        dialog.CheckFileExists = !value;
-        Assert.Equal(!value, dialog.CheckFileExists);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_Multiselect_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            Multiselect = value
-        };
-        Assert.Equal(value, dialog.Multiselect);
-
-        // Set same.
-        dialog.Multiselect = value;
-        Assert.Equal(value, dialog.Multiselect);
-
-        // Set different.
-        dialog.Multiselect = !value;
-        Assert.Equal(!value, dialog.Multiselect);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_ReadOnlyChecked_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            ReadOnlyChecked = value
-        };
-        Assert.Equal(value, dialog.ReadOnlyChecked);
-
-        // Set same.
-        dialog.ReadOnlyChecked = value;
-        Assert.Equal(value, dialog.ReadOnlyChecked);
-
-        // Set different.
-        dialog.ReadOnlyChecked = !value;
-        Assert.Equal(!value, dialog.ReadOnlyChecked);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_SelectReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            SelectReadOnly = value
-        };
-        Assert.Equal(value, dialog.SelectReadOnly);
-
-        // Set same.
-        dialog.SelectReadOnly = value;
-        Assert.Equal(value, dialog.SelectReadOnly);
-
-        // Set different.
-        dialog.SelectReadOnly = !value;
-        Assert.Equal(!value, dialog.SelectReadOnly);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_ShowPreview_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            ShowPreview = value
-        };
-        Assert.Equal(value, dialog.ShowPreview);
-
-        // Set same.
-        dialog.ShowPreview = value;
-        Assert.Equal(value, dialog.ShowPreview);
-
-        // Set different.
-        dialog.ShowPreview = !value;
-        Assert.Equal(!value, dialog.ShowPreview);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void OpenFileDialog_ShowReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new OpenFileDialog
-        {
-            ShowReadOnly = value
-        };
-        Assert.Equal(value, dialog.ShowReadOnly);
-
-        // Set same.
-        dialog.ShowReadOnly = value;
-        Assert.Equal(value, dialog.ShowReadOnly);
-
-        // Set different.
-        dialog.ShowReadOnly = !value;
-        Assert.Equal(!value, dialog.ShowReadOnly);
-    }
-
-    [WinFormsFact]
-    public void OpenFileDialog_Reset_Invoke_Success()
-    {
-        using var dialog = new OpenFileDialog
-        {
-            CheckFileExists = false,
-            Multiselect = true,
-            ReadOnlyChecked = true,
-            SelectReadOnly = false,
-            ShowPreview = true,
-            ShowReadOnly = true
-        };
-
-        dialog.Reset();
-        Assert.True(dialog.CheckFileExists);
-        Assert.False(dialog.Multiselect);
-        Assert.False(dialog.ReadOnlyChecked);
-        Assert.True(dialog.SelectReadOnly);
-        Assert.False(dialog.ShowPreview);
-        Assert.False(dialog.ShowReadOnly);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OwnerDrawPropertyBagTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OwnerDrawPropertyBagTests.cs
deleted file mode 100644
index 94abcf19a47..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/OwnerDrawPropertyBagTests.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.Serialization.Formatters.Binary;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class OwnerDrawPropertyBagTests
-{
-    [WinFormsFact]
-    public void OwnerDrawPropertyBag_Ctor_Default()
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag bag = treeView.GetItemRenderStyles(null, 0);
-        Assert.Equal(Color.Empty, bag.BackColor);
-        Assert.Null(bag.Font);
-        Assert.Equal(Color.Empty, bag.ForeColor);
-        Assert.True(bag.IsEmpty());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void OwnerDrawPropertyBag_BackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag bag = treeView.GetItemRenderStyles(null, 0);
-
-        bag.BackColor = value;
-        Assert.Equal(value, bag.BackColor);
-        Assert.Equal(value.IsEmpty, bag.IsEmpty());
-
-        // Set same.
-        bag.BackColor = value;
-        Assert.Equal(value, bag.BackColor);
-        Assert.Equal(value.IsEmpty, bag.IsEmpty());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void OwnerDrawPropertyBag_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag bag = treeView.GetItemRenderStyles(null, 0);
-
-        bag.Font = value;
-        Assert.Same(value, bag.Font);
-        Assert.Equal(value is null, bag.IsEmpty());
-
-        // Set same.
-        bag.Font = value;
-        Assert.Same(value, bag.Font);
-        Assert.Equal(value is null, bag.IsEmpty());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void OwnerDrawPropertyBag_ForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag bag = treeView.GetItemRenderStyles(null, 0);
-
-        bag.ForeColor = value;
-        Assert.Equal(value, bag.ForeColor);
-        Assert.Equal(value.IsEmpty, bag.IsEmpty());
-
-        // Set same.
-        bag.ForeColor = value;
-        Assert.Equal(value, bag.ForeColor);
-        Assert.Equal(value.IsEmpty, bag.IsEmpty());
-    }
-
-    [WinFormsFact]
-    public void OwnerDrawPropertyBag_Copy_CustomValue_ReturnsClone()
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag value = treeView.GetItemRenderStyles(null, 0);
-        value.BackColor = Color.Blue;
-        value.Font = SystemFonts.MenuFont;
-        value.ForeColor = Color.Red;
-
-        OwnerDrawPropertyBag bag = OwnerDrawPropertyBag.Copy(value);
-        Assert.NotSame(value, bag);
-        Assert.Equal(Color.Blue, bag.BackColor);
-        Assert.Equal(SystemFonts.MenuFont.Name, bag.Font.Name);
-        Assert.Equal(Color.Red, bag.ForeColor);
-        Assert.False(bag.IsEmpty());
-    }
-
-    [WinFormsFact]
-    public void OwnerDrawPropertyBag_Copy_NullValue_ReturnsDefault()
-    {
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag value = treeView.GetItemRenderStyles(null, 0);
-        OwnerDrawPropertyBag bag = OwnerDrawPropertyBag.Copy(value);
-        Assert.NotSame(value, bag);
-        Assert.Equal(Color.Empty, bag.BackColor);
-        Assert.Null(bag.Font);
-        Assert.Equal(Color.Empty, bag.ForeColor);
-        Assert.True(bag.IsEmpty());
-    }
-
-    [WinFormsFact]
-    public void OwnerDrawPropertyBag_Serialize_Deserialize_Success()
-    {
-        using var formatterScope = new BinaryFormatterScope(enable: true);
-        using var treeView = new SubTreeView();
-        OwnerDrawPropertyBag original = treeView.GetItemRenderStyles(null, 0);
-        original.BackColor = Color.Blue;
-        original.Font = SystemFonts.MenuFont;
-        original.ForeColor = Color.Red;
-
-        using (var stream = new MemoryStream())
-        {
-#pragma warning disable SYSLIB0011 // Type or member is obsolete
-            var formatter = new BinaryFormatter();
-            formatter.Serialize(stream, original);
-
-            stream.Position = 0;
-            OwnerDrawPropertyBag bag = Assert.IsType<OwnerDrawPropertyBag>(formatter.Deserialize(stream));
-#pragma warning restore SYSLIB0011 // Type or member is obsolete
-            Assert.Equal(Color.Blue, bag.BackColor);
-            Assert.Equal(SystemFonts.MenuFont.Name, bag.Font.Name);
-            Assert.Equal(Color.Red, bag.ForeColor);
-            Assert.False(bag.IsEmpty());
-        }
-    }
-
-    private class SubTreeView : TreeView
-    {
-        public new OwnerDrawPropertyBag GetItemRenderStyles(TreeNode node, int state) => base.GetItemRenderStyles(node, state);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingConverterTests.cs
deleted file mode 100644
index 20dd7c446ad..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingConverterTests.cs
+++ /dev/null
@@ -1,421 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Globalization;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PaddingConverterTests
-{
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetConvertFromTheoryData))]
-    [InlineData(typeof(Padding), false)]
-    [InlineData(typeof(string), true)]
-    public void PaddingConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        var converter = new PaddingConverter();
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_TestData()
-    {
-        yield return new object[] { "1,2,3,4", new Padding(1, 2, 3, 4) };
-        yield return new object[] { "  1 , 1,  1, 1 ", new Padding(1) };
-        yield return new object[] { "   ", null };
-        yield return new object[] { string.Empty, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_TestData))]
-    public void PaddingConverter_ConvertFrom_String_ReturnsExpected(string value, object expected)
-    {
-        var converter = new PaddingConverter();
-        Assert.Equal(expected, converter.ConvertFrom(value));
-        Assert.Equal(expected, converter.ConvertFrom(null, null, value));
-        Assert.Equal(expected, converter.ConvertFrom(null, CultureInfo.InvariantCulture, value));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void PaddingConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("1,2,3")]
-    [InlineData("1,2,3,4,5")]
-    public void PaddingConverter_ConvertFrom_InvalidString_ThrowsArgumentException(string value)
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<ArgumentException>("value", () => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(TableLayoutPanelCellPosition), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void PaddingConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        var converter = new PaddingConverter();
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Fact]
-    public void PaddingConverter_ConvertTo_String_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        Assert.Equal("1, 2, 3, 4", converter.ConvertTo(new Padding(1, 2, 3, 4), typeof(string)));
-        Assert.Equal("1, 2, 3, 4", converter.ConvertTo(null, null, new Padding(1, 2, 3, 4), typeof(string)));
-        Assert.Equal("1, 2, 3, 4", converter.ConvertTo(null, CultureInfo.InvariantCulture, new Padding(1, 2, 3, 4), typeof(string)));
-    }
-
-    [Fact]
-    public void PaddingConverter_ConvertTo_InstanceDescriptor_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new Padding(1, 2, 3, 4), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(Padding).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, descriptor.Arguments);
-    }
-
-    [Fact]
-    public void PaddingConverter_ConvertTo_InstanceDescriptorAll_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new Padding(1, 1, 1, 1), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(Padding).GetConstructor(new Type[] { typeof(int) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1 }, descriptor.Arguments);
-    }
-
-    [Fact]
-    public void PaddingConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void PaddingConverter_ConvertTo_ValueNotPadding_ThrowsNotSupportedException()
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(Padding))]
-    [InlineData(typeof(int))]
-    public void PaddingConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new Padding(), destinationType));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_TestData()
-    {
-        yield return new object[] { new Padding(1), 1, new Padding(1, 2, 3, 4) };
-        yield return new object[] { new Padding(1), 2, new Padding(2) };
-        yield return new object[] { new Padding(1, 2, 3, 4), -1, new Padding(1, 2, 3, 4) };
-        yield return new object[] { new Padding(1, 2, 3, 4), 1, new Padding(1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_TestData))]
-    public void PaddingConverter_CreateInstance_ValidPropertyValuesAll_ReturnsExpected(Padding instance, int all, Padding result)
-    {
-        var converter = new PaddingConverter();
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(new ClassWithPadding { Padding = instance });
-        mockContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns(TypeDescriptor.GetProperties(typeof(ClassWithPadding))[0]);
-        Padding padding = Assert.IsType<Padding>(converter.CreateInstance(
-            mockContext.Object, new Dictionary<string, object>
-            {
-                { nameof(Padding.All), all },
-                { nameof(Padding.Left), 1 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }));
-        Assert.Equal(result, padding);
-    }
-
-    [Fact]
-    public void PaddingConverter_CreateInstance_ValidPropertyValuesNullContext_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        Padding expected = new Padding(1, 2, 3, 4);
-        Padding padding = Assert.IsType<Padding>(converter.CreateInstance(
-            null, new Dictionary<string, object>
-            {
-                { nameof(Padding.All), expected.All },
-                { nameof(Padding.Left), expected.Left },
-                { nameof(Padding.Top), expected.Top },
-                { nameof(Padding.Right), expected.Right },
-                { nameof(Padding.Bottom), expected.Bottom }
-            }));
-        Assert.Equal(expected, padding);
-    }
-
-    [Fact]
-    public void PaddingConverter_CreateInstance_NullPropertyValues_ThrowsArgumentNullException()
-    {
-        var converter = new PaddingConverter();
-        Assert.Throws<ArgumentNullException>("propertyValues", () => converter.CreateInstance(new Mock<ITypeDescriptorContext>(MockBehavior.Strict).Object, null));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_InvalidPropertyValueType_TestData()
-    {
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), new object() },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), null },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), new object() },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), null },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), new object() },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), null },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), new object() },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), null },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Bottom), 4 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), new object() }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 },
-                { nameof(Padding.Bottom), null }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(Padding.All), 1 },
-                { nameof(Padding.Left), 2 },
-                { nameof(Padding.Top), 2 },
-                { nameof(Padding.Right), 3 }
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_InvalidPropertyValueType_TestData))]
-    public void PaddingConverter_CreateInstance_InvalidPropertyValueType_ThrowsArgumentException(IDictionary propertyValues)
-    {
-        var converter = new PaddingConverter();
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns(new ClassWithPadding { Padding = new Padding(1) });
-        mockContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns(TypeDescriptor.GetProperties(typeof(ClassWithPadding))[0]);
-
-        Assert.Throws<ArgumentException>("propertyValues", () => converter.CreateInstance(mockContext.Object, propertyValues));
-    }
-
-    [Fact]
-    public void PaddingConverter_CreateInstance_UnknownInstanceType_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        var mockContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockContext
-            .Setup(c => c.Instance)
-            .Returns("abc");
-        mockContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns(TypeDescriptor.GetProperties(typeof(string))[0]);
-
-        var propertyValues = new Dictionary<string, object>
-        {
-            { nameof(Padding.All), 1 },
-            { nameof(Padding.Left), 2 },
-            { nameof(Padding.Top), 2 },
-            { nameof(Padding.Right), 3 },
-            { nameof(Padding.Bottom), 4 },
-        };
-
-        Padding expected = new Padding(2, 2, 3, 4);
-        Padding padding = Assert.IsType<Padding>(converter.CreateInstance(mockContext.Object, propertyValues));
-        Assert.Equal(expected, padding);
-    }
-
-    [Fact]
-    public void PaddingConverter_GetCreateInstanceSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new PaddingConverter();
-        Assert.True(converter.GetCreateInstanceSupported());
-    }
-
-    [Fact]
-    public void PaddingConverter_GetProperties_Invoke_ReturnsExpected()
-    {
-        var converter = new PaddingConverter();
-        PropertyDescriptorCollection properties = converter.GetProperties(null);
-        Assert.Equal(5, properties.Count);
-        Assert.Equal(nameof(Padding.All), properties[0].Name);
-        Assert.Equal(nameof(Padding.Left), properties[1].Name);
-        Assert.Equal(nameof(Padding.Top), properties[2].Name);
-        Assert.Equal(nameof(Padding.Right), properties[3].Name);
-        Assert.Equal(nameof(Padding.Bottom), properties[4].Name);
-    }
-
-    [Fact]
-    public void PaddingConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        var converter = new PaddingConverter();
-        Assert.True(converter.GetPropertiesSupported());
-    }
-
-    private class ClassWithPadding
-    {
-        public Padding Padding { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingTests.cs
deleted file mode 100644
index 9fe388c7b1e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaddingTests.cs
+++ /dev/null
@@ -1,425 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PaddingTests
-{
-    [Fact]
-    public void Padding_Ctor_Default()
-    {
-        var padding = new Padding();
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(0, padding.Left);
-        Assert.Equal(0, padding.Top);
-        Assert.Equal(0, padding.Right);
-        Assert.Equal(0, padding.Bottom);
-        Assert.Equal(0, padding.Horizontal);
-        Assert.Equal(0, padding.Vertical);
-        Assert.Equal(Size.Empty, padding.Size);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Ctor_Int(int all)
-    {
-        var padding = new Padding(all);
-        Assert.Equal(all, padding.All);
-        Assert.Equal(all, padding.Left);
-        Assert.Equal(all, padding.Top);
-        Assert.Equal(all, padding.Right);
-        Assert.Equal(all, padding.Bottom);
-        Assert.Equal(all * 2, padding.Horizontal);
-        Assert.Equal(all * 2, padding.Vertical);
-        Assert.Equal(new Size(all * 2, all * 2), padding.Size);
-    }
-
-    [Theory]
-    [InlineData(-1, -2, -3, -4, -1)]
-    [InlineData(0, 0, 0, 0, 0)]
-    [InlineData(1, 1, 1, 1, 1)]
-    [InlineData(2, 1, 1, 1, -1)]
-    [InlineData(1, 2, 1, 1, -1)]
-    [InlineData(1, 1, 2, 1, -1)]
-    [InlineData(1, 1, 1, 2, -1)]
-    [InlineData(1, 2, 3, 4, -1)]
-    public void Padding_Ctor_Int_Int_Int_Int(int left, int top, int right, int bottom, int expectedAll)
-    {
-        var padding = new Padding(left, top, right, bottom);
-        Assert.Equal(expectedAll, padding.All);
-        Assert.Equal(left, padding.Left);
-        Assert.Equal(top, padding.Top);
-        Assert.Equal(right, padding.Right);
-        Assert.Equal(bottom, padding.Bottom);
-        Assert.Equal(right + left, padding.Horizontal);
-        Assert.Equal(top + bottom, padding.Vertical);
-        Assert.Equal(new Size(right + left, top + bottom), padding.Size);
-    }
-
-    [Fact]
-    public void Padding_Empty_Get_ReturnsExpected()
-    {
-        Padding padding = Padding.Empty;
-        Assert.Equal(0, padding.All);
-        Assert.Equal(0, padding.Left);
-        Assert.Equal(0, padding.Top);
-        Assert.Equal(0, padding.Right);
-        Assert.Equal(0, padding.Bottom);
-        Assert.Equal(0, padding.Horizontal);
-        Assert.Equal(0, padding.Vertical);
-        Assert.Equal(Size.Empty, padding.Size);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_All_Set_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(1, 2, 3, 4)
-        {
-            All = value
-        };
-        Assert.Equal(value, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    [Fact]
-    public void Padding_AllPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.All)];
-        Assert.False(property.CanResetValue(boxedPadding));
-        Assert.False(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(0, ((Padding)boxedPadding).All);
-        Assert.Equal(0, ((Padding)boxedPadding).Left);
-        Assert.Equal(0, ((Padding)boxedPadding).Top);
-        Assert.Equal(0, ((Padding)boxedPadding).Right);
-        Assert.Equal(0, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Fact]
-    public void Padding_AllPropertyDescriptor_ResetValueOnAll_SetsToZero()
-    {
-        var padding = new Padding(1);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.All)];
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(0, ((Padding)boxedPadding).All);
-        Assert.Equal(0, ((Padding)boxedPadding).Left);
-        Assert.Equal(0, ((Padding)boxedPadding).Top);
-        Assert.Equal(0, ((Padding)boxedPadding).Right);
-        Assert.Equal(0, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_All_SetOnAll_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(2)
-        {
-            All = value
-        };
-        Assert.Equal(value, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Left_Set_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(1, 2, 3, 4)
-        {
-            Left = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [Fact]
-    public void Padding_LeftPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.Left)];
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(-1, ((Padding)boxedPadding).All);
-        Assert.Equal(0, ((Padding)boxedPadding).Left);
-        Assert.Equal(2, ((Padding)boxedPadding).Top);
-        Assert.Equal(3, ((Padding)boxedPadding).Right);
-        Assert.Equal(4, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Left_SetOnAll_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(5)
-        {
-            Left = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(value, padding.Left);
-        Assert.Equal(5, padding.Top);
-        Assert.Equal(5, padding.Right);
-        Assert.Equal(5, padding.Bottom);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Top_Set_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(1, 2, 3, 4)
-        {
-            Top = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [Fact]
-    public void Padding_TopPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.Top)];
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(-1, ((Padding)boxedPadding).All);
-        Assert.Equal(1, ((Padding)boxedPadding).Left);
-        Assert.Equal(0, ((Padding)boxedPadding).Top);
-        Assert.Equal(3, ((Padding)boxedPadding).Right);
-        Assert.Equal(4, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Top_SetOnAll_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(5)
-        {
-            Top = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(5, padding.Left);
-        Assert.Equal(value, padding.Top);
-        Assert.Equal(5, padding.Right);
-        Assert.Equal(5, padding.Bottom);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Right_Set_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(1, 2, 3, 4)
-        {
-            Right = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(4, padding.Bottom);
-    }
-
-    [Fact]
-    public void Padding_RightPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.Right)];
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(-1, ((Padding)boxedPadding).All);
-        Assert.Equal(1, ((Padding)boxedPadding).Left);
-        Assert.Equal(2, ((Padding)boxedPadding).Top);
-        Assert.Equal(0, ((Padding)boxedPadding).Right);
-        Assert.Equal(4, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Right_SetOnAll_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(5)
-        {
-            Right = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(5, padding.Left);
-        Assert.Equal(5, padding.Top);
-        Assert.Equal(value, padding.Right);
-        Assert.Equal(5, padding.Bottom);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Bottom_Set_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(1, 2, 3, 4)
-        {
-            Bottom = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(1, padding.Left);
-        Assert.Equal(2, padding.Top);
-        Assert.Equal(3, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    [Fact]
-    public void Padding_BottomPropertyDescriptor_ResetValue_SetsToZero()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        object boxedPadding = padding;
-        PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(padding);
-        PropertyDescriptor property = properties[nameof(Padding.Bottom)];
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-        property.ResetValue(boxedPadding);
-
-        Assert.Equal(-1, ((Padding)boxedPadding).All);
-        Assert.Equal(1, ((Padding)boxedPadding).Left);
-        Assert.Equal(2, ((Padding)boxedPadding).Top);
-        Assert.Equal(3, ((Padding)boxedPadding).Right);
-        Assert.Equal(0, ((Padding)boxedPadding).Bottom);
-        Assert.True(property.CanResetValue(boxedPadding));
-        Assert.True(property.ShouldSerializeValue(boxedPadding));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void Padding_Bottom_SetOnAll_GetReturnsExpected(int value)
-    {
-        var padding = new Padding(5)
-        {
-            Bottom = value
-        };
-        Assert.Equal(-1, padding.All);
-        Assert.Equal(5, padding.Left);
-        Assert.Equal(5, padding.Top);
-        Assert.Equal(5, padding.Right);
-        Assert.Equal(value, padding.Bottom);
-    }
-
-    public static IEnumerable<object[]> Add_TestData()
-    {
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(2, 3, 4, 5), new Padding(3, 5, 7, 9) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Add_TestData))]
-    public void Padding_Add_Invoke_ReturnsExpected(Padding p1, Padding p2, Padding expected)
-    {
-        Assert.Equal(expected, p1 + p2);
-        Assert.Equal(expected, Padding.Add(p1, p2));
-    }
-
-    public static IEnumerable<object[]> Subtract_TestData()
-    {
-        yield return new object[] { new Padding(2, 3, 4, 5), new Padding(1, 2, 3, 4), new Padding(1, 1, 1, 1) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Subtract_TestData))]
-    public void Padding_Subtract_Invoke_ReturnsExpected(Padding p1, Padding p2, Padding expected)
-    {
-        Assert.Equal(expected, p1 - p2);
-        Assert.Equal(expected, Padding.Subtract(p1, p2));
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new Padding(1), new Padding(1), true };
-        yield return new object[] { new Padding(1), new Padding(1, 1, 1, 1), true };
-        yield return new object[] { new Padding(1), new Padding(1, 2, 1, 1), false };
-        yield return new object[] { new Padding(1), new Padding(1, 1, 3, 1), false };
-        yield return new object[] { new Padding(1), new Padding(1, 1, 1, 4), false };
-
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), true };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 1, 3, 4), false };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 2, 4), false };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 3), false };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1), false };
-
-        yield return new object[] { new Padding(1, 2, 3, 4), new object(), false };
-        yield return new object[] { new Padding(1, 2, 3, 4), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void Padding_Equals_Invoke_ReturnsExpected(Padding padding, object other, bool expected)
-    {
-        if (other is Padding otherPadding)
-        {
-            Assert.Equal(expected, padding == otherPadding);
-            Assert.Equal(!expected, padding != otherPadding);
-            Assert.Equal(expected, padding.GetHashCode().Equals(otherPadding.GetHashCode()));
-        }
-
-        Assert.Equal(expected, padding.Equals(other));
-    }
-
-    [Fact]
-    public void Padding_ToString_Invoke_ReturnsExpected()
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        Assert.Equal("{Left=1,Top=2,Right=3,Bottom=4}", padding.ToString());
-    }
-
-    [Fact]
-    public void Padding_ToString_InvokeAll_ReturnsExpected()
-    {
-        var padding = new Padding(1);
-        Assert.Equal("{Left=1,Top=1,Right=1,Bottom=1}", padding.ToString());
-    }
-
-    [Fact]
-    public void Padding_TypeConverter_Get_ReturnsPaddingConverter()
-    {
-        var padding = new Padding(1);
-        Assert.IsType<PaddingConverter>(TypeDescriptor.GetConverter(padding));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PageSetupDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PageSetupDialogTests.cs
deleted file mode 100644
index 461ab583601..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PageSetupDialogTests.cs
+++ /dev/null
@@ -1,445 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing.Printing;
-
-namespace System.Windows.Forms.Tests;
-
-public class PageSetupDialogTests
-{
-    [WinFormsFact]
-    public void PageSetupDialog_Ctor_Default()
-    {
-        using var dialog = new PageSetupDialog();
-        Assert.True(dialog.AllowMargins);
-        Assert.True(dialog.AllowOrientation);
-        Assert.True(dialog.AllowPaper);
-        Assert.True(dialog.AllowPrinter);
-        Assert.Null(dialog.Container);
-        Assert.Null(dialog.Document);
-        Assert.False(dialog.EnableMetric);
-        Assert.Equal(new Margins(0, 0, 0, 0), dialog.MinMargins);
-        Assert.Same(dialog.MinMargins, dialog.MinMargins);
-        Assert.Null(dialog.PageSettings);
-        Assert.Null(dialog.PrinterSettings);
-        Assert.False(dialog.ShowHelp);
-        Assert.True(dialog.ShowNetwork);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_AllowMargins_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            AllowMargins = value
-        };
-        Assert.Equal(value, dialog.AllowMargins);
-
-        // Set same.
-        dialog.AllowMargins = value;
-        Assert.Equal(value, dialog.AllowMargins);
-
-        // Set different.
-        dialog.AllowMargins = !value;
-        Assert.Equal(!value, dialog.AllowMargins);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_AllowOrientation_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            AllowOrientation = value
-        };
-        Assert.Equal(value, dialog.AllowOrientation);
-
-        // Set same.
-        dialog.AllowOrientation = value;
-        Assert.Equal(value, dialog.AllowOrientation);
-
-        // Set different.
-        dialog.AllowOrientation = !value;
-        Assert.Equal(!value, dialog.AllowOrientation);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_AllowPaper_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            AllowPaper = value
-        };
-        Assert.Equal(value, dialog.AllowPaper);
-
-        // Set same.
-        dialog.AllowPaper = value;
-        Assert.Equal(value, dialog.AllowPaper);
-
-        // Set different.
-        dialog.AllowPaper = !value;
-        Assert.Equal(!value, dialog.AllowPaper);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_AllowPrinter_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            AllowPrinter = value
-        };
-        Assert.Equal(value, dialog.AllowPrinter);
-
-        // Set same.
-        dialog.AllowPrinter = value;
-        Assert.Equal(value, dialog.AllowPrinter);
-
-        // Set different.
-        dialog.AllowPrinter = !value;
-        Assert.Equal(!value, dialog.AllowPrinter);
-    }
-
-    public static IEnumerable<object[]> Document_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new PrintDocument() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Document_Set_TestData))]
-    public void PageSetupDialog_Document_Set_GetReturnsExpected(PrintDocument value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            Document = value
-        };
-        Assert.Same(value, dialog.Document);
-        Assert.Same(value?.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(value?.PrinterSettings, dialog.PrinterSettings);
-
-        // Set same.
-        dialog.Document = value;
-        Assert.Same(value, dialog.Document);
-        Assert.Same(value?.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(value?.PrinterSettings, dialog.PrinterSettings);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_Document_SetWithNonNullOldValue_GetReturnsExpected()
-    {
-        using var dialog = new PageSetupDialog
-        {
-            Document = new PrintDocument()
-        };
-
-        using var value = new PrintDocument();
-        dialog.Document = value;
-        Assert.Same(value, dialog.Document);
-        Assert.Same(value.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(value.PrinterSettings, dialog.PrinterSettings);
-
-        // Set same.
-        dialog.Document = value;
-        Assert.Same(value, dialog.Document);
-        Assert.Same(value.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(value.PrinterSettings, dialog.PrinterSettings);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_Document_SetNullWithNonNullOldValue_GetReturnsExpected()
-    {
-        using var original = new PrintDocument();
-        using var dialog = new PageSetupDialog
-        {
-            Document = original
-        };
-
-        dialog.Document = null;
-        Assert.Null(dialog.Document);
-        Assert.Same(original.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(original.PrinterSettings, dialog.PrinterSettings);
-
-        // Set same.
-        dialog.Document = null;
-        Assert.Null(dialog.Document);
-        Assert.Same(original.DefaultPageSettings, dialog.PageSettings);
-        Assert.Same(original.PrinterSettings, dialog.PrinterSettings);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_EnableMetric_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            EnableMetric = value
-        };
-        Assert.Equal(value, dialog.EnableMetric);
-
-        // Set same.
-        dialog.EnableMetric = value;
-        Assert.Equal(value, dialog.EnableMetric);
-
-        // Set different.
-        dialog.EnableMetric = !value;
-        Assert.Equal(!value, dialog.EnableMetric);
-    }
-
-    public static IEnumerable<object[]> MinMargins_Set_TestData()
-    {
-        yield return new object[] { null, new Margins(0, 0, 0, 0) };
-        yield return new object[] { new Margins(), new Margins() };
-        yield return new object[] { new Margins(1, 2, 3, 4), new Margins(1, 2, 3, 4) };
-        yield return new object[] { new Margins(0, 0, 0, 0), new Margins(0, 0, 0, 0) };
-        yield return new object[] { new Margins(1, 0, 0, 0), new Margins(1, 0, 0, 0) };
-        yield return new object[] { new Margins(0, 1, 0, 0), new Margins(0, 1, 0, 0) };
-        yield return new object[] { new Margins(0, 0, 1, 0), new Margins(0, 0, 1, 0) };
-        yield return new object[] { new Margins(0, 0, 0, 1), new Margins(0, 0, 0, 1) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinMargins_Set_TestData))]
-    public void PageSetupDialog_MinMargins_Set_GetReturnsExpected(Margins value, Margins expected)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            MinMargins = value
-        };
-        Assert.Equal(expected, dialog.MinMargins);
-
-        // Set same.
-        dialog.MinMargins = value;
-        Assert.Equal(expected, dialog.MinMargins);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_MinMargins_ResetValue_Success()
-    {
-        using var dialog = new PageSetupDialog();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PageSetupDialog))[nameof(PageSetupDialog.MinMargins)];
-        Assert.False(property.CanResetValue(dialog));
-
-        dialog.MinMargins = new Margins(1, 2, 3, 4);
-        Assert.True(property.CanResetValue(dialog));
-        Assert.Equal(new Margins(1, 2, 3, 4), dialog.MinMargins);
-
-        property.ResetValue(dialog);
-        Assert.False(property.CanResetValue(dialog));
-        Assert.Equal(new Margins(0, 0, 0, 0), dialog.MinMargins);
-    }
-
-    public static IEnumerable<object[]> MinMargins_ShouldSerializeValue_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { new Margins(), true };
-        yield return new object[] { new Margins(1, 2, 3, 4), true };
-        yield return new object[] { new Margins(0, 0, 0, 0), false };
-        yield return new object[] { new Margins(1, 0, 0, 0), true };
-        yield return new object[] { new Margins(0, 1, 0, 0), true };
-        yield return new object[] { new Margins(0, 0, 1, 0), true };
-        yield return new object[] { new Margins(0, 0, 0, 10), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinMargins_ShouldSerializeValue_TestData))]
-    public void PageSetupDialog_MinMargins_ShouldSerializeValue_ReturnsExpected(Margins value, bool expected)
-    {
-        using var dialog = new PageSetupDialog();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PageSetupDialog))[nameof(PageSetupDialog.MinMargins)];
-        Assert.False(property.ShouldSerializeValue(dialog));
-
-        dialog.MinMargins = value;
-        Assert.Equal(expected, property.ShouldSerializeValue(dialog));
-    }
-
-    public static IEnumerable<object[]> PageSettings_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new PageSettings() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PageSettings_Set_TestData))]
-    public void PageSetupDialog_PageSettings_Set_GetReturnsExpected(PageSettings value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            PageSettings = value
-        };
-        Assert.Same(value, dialog.PageSettings);
-        Assert.Null(dialog.Document);
-
-        // Set same.
-        dialog.PageSettings = value;
-        Assert.Same(value, dialog.PageSettings);
-        Assert.Null(dialog.Document);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PageSettings_Set_TestData))]
-    public void PageSetupDialog_PageSettings_SetWithDocument_GetReturnsExpected(PageSettings value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            Document = new PrintDocument(),
-            PageSettings = value
-        };
-        Assert.Same(value, dialog.PageSettings);
-        Assert.Null(dialog.Document);
-
-        // Set same.
-        dialog.PageSettings = value;
-        Assert.Same(value, dialog.PageSettings);
-        Assert.Null(dialog.Document);
-    }
-
-    public static IEnumerable<object[]> PrinterSettings_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new PrinterSettings() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PrinterSettings_Set_TestData))]
-    public void PageSetupDialog_PrinterSettings_Set_GetReturnsExpected(PrinterSettings value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            PrinterSettings = value
-        };
-        Assert.Same(value, dialog.PrinterSettings);
-        Assert.Null(dialog.Document);
-
-        // Set same.
-        dialog.PrinterSettings = value;
-        Assert.Same(value, dialog.PrinterSettings);
-        Assert.Null(dialog.Document);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PrinterSettings_Set_TestData))]
-    public void PageSetupDialog_PrinterSettings_SetWithDocument_GetReturnsExpected(PrinterSettings value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            Document = new PrintDocument(),
-            PrinterSettings = value
-        };
-        Assert.Same(value, dialog.PrinterSettings);
-        Assert.Null(dialog.Document);
-
-        // Set same.
-        dialog.PrinterSettings = value;
-        Assert.Same(value, dialog.PrinterSettings);
-        Assert.Null(dialog.Document);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_ShowHelp_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            ShowHelp = value
-        };
-        Assert.Equal(value, dialog.ShowHelp);
-
-        // Set same.
-        dialog.ShowHelp = value;
-        Assert.Equal(value, dialog.ShowHelp);
-
-        // Set different.
-        dialog.ShowHelp = !value;
-        Assert.Equal(!value, dialog.ShowHelp);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PageSetupDialog_ShowNetwork_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new PageSetupDialog
-        {
-            ShowNetwork = value
-        };
-        Assert.Equal(value, dialog.ShowNetwork);
-
-        // Set same.
-        dialog.ShowNetwork = value;
-        Assert.Equal(value, dialog.ShowNetwork);
-
-        // Set different.
-        dialog.ShowNetwork = !value;
-        Assert.Equal(!value, dialog.ShowNetwork);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_Reset_InvokeDefault_Success()
-    {
-        using var dialog = new PageSetupDialog();
-        dialog.Reset();
-        Assert.True(dialog.AllowMargins);
-        Assert.True(dialog.AllowOrientation);
-        Assert.True(dialog.AllowPaper);
-        Assert.True(dialog.AllowPrinter);
-        Assert.Null(dialog.Container);
-        Assert.Null(dialog.Document);
-        Assert.False(dialog.EnableMetric);
-        Assert.Equal(new Margins(0, 0, 0, 0), dialog.MinMargins);
-        Assert.Same(dialog.MinMargins, dialog.MinMargins);
-        Assert.Null(dialog.PageSettings);
-        Assert.Null(dialog.PrinterSettings);
-        Assert.False(dialog.ShowHelp);
-        Assert.True(dialog.ShowNetwork);
-        Assert.Null(dialog.Site);
-        Assert.Null(dialog.Tag);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_Reset_InvokeComplex_Success()
-    {
-        var container = new Container();
-        using var dialog = new PageSetupDialog
-        {
-            AllowMargins = false,
-            AllowOrientation = false,
-            AllowPaper = false,
-            AllowPrinter = false,
-            Document = new PrintDocument(),
-            MinMargins = new Margins(1, 2, 3, 4),
-            ShowHelp = true,
-            ShowNetwork = false,
-            Tag = "tag"
-        };
-        container.Add(dialog);
-
-        dialog.Reset();
-        Assert.True(dialog.AllowMargins);
-        Assert.True(dialog.AllowOrientation);
-        Assert.True(dialog.AllowPaper);
-        Assert.True(dialog.AllowPrinter);
-        Assert.Same(container, dialog.Container);
-        Assert.Null(dialog.Document);
-        Assert.False(dialog.EnableMetric);
-        Assert.Equal(new Margins(0, 0, 0, 0), dialog.MinMargins);
-        Assert.Same(dialog.MinMargins, dialog.MinMargins);
-        Assert.Null(dialog.PageSettings);
-        Assert.Null(dialog.PrinterSettings);
-        Assert.False(dialog.ShowHelp);
-        Assert.True(dialog.ShowNetwork);
-        Assert.NotNull(dialog.Site);
-        Assert.Equal("tag", dialog.Tag);
-    }
-
-    [WinFormsFact]
-    public void PageSetupDialog_ShowDialog_InvokeWithoutDocument_ThrowsArgumentException()
-    {
-        using var dialog = new PageSetupDialog();
-        Assert.Throws<ArgumentException>(() => dialog.ShowDialog());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaintEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaintEventArgsTests.cs
deleted file mode 100644
index 240bc07ba55..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PaintEventArgsTests.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PaintEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_TestData))]
-    public void Ctor_Graphics_Rectangle(Rectangle clipRect)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        using var e = new PaintEventArgs(graphics, clipRect);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(clipRect, e.ClipRectangle);
-    }
-
-    [Fact]
-    public void Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new PaintEventArgs((Graphics)null, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [Fact]
-    public void Dispose_Invoke_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-        e.Dispose();
-        e.Dispose();
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Dispose_InvokeDisposing_Success(bool disposing)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var e = new SubPaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-        e.DisposeEntry(disposing);
-        e.DisposeEntry(disposing);
-    }
-
-    [Fact]
-    public void GraphicsIdentity()
-    {
-        // https://github.com/dotnet/winforms/issues/3910
-        using var hdc = GdiCache.GetScreenHdc();
-        using PaintEventArgs args = new PaintEventArgs(hdc, default);
-        Graphics g1 = args.Graphics;
-        Graphics g2 = args.Graphics;
-        Assert.Same(g1, g2);
-    }
-
-    private class SubPaintEventArgs : PaintEventArgs
-    {
-        public SubPaintEventArgs(Graphics graphics, Rectangle clipRect) : base(graphics, clipRect)
-        {
-        }
-
-        public void DisposeEntry(bool disposing) => Dispose(disposing);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Panel.PanelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Panel.PanelAccessibleObjectTests.cs
deleted file mode 100644
index dbc6bc6c969..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Panel.PanelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,278 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class Panel_PanelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PanelAccessibleObject_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("ownerControl", () => new Panel.PanelAccessibleObject(owner: null));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_Ctor_Default()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.NotNull(panelAccessibleObject.Owner);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_Description_ReturnsExpected()
-    {
-        var expected = "PanelTestDescription";
-
-        using Panel panel = new()
-        {
-            AccessibleDescription = expected,
-        };
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.Equal(expected, panelAccessibleObject.Description);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_Name_ReturnsExpected()
-    {
-        var expected = "PanelTestName";
-
-        using Panel panel = new()
-        {
-            AccessibleName = expected
-        };
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.Equal(expected, panelAccessibleObject.Name);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "PanelTestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "Panel1")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.PaneControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, false)]
-    [InlineData((int)UIA.LegacyIAccessibleDefaultActionPropertyId, null)]
-    public void PanelAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using Panel panel = new()
-        {
-            Name = "Panel1",
-            AccessibleName = "PanelTestName"
-        };
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-        object actual = panelAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, actual);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void PanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using Panel panel = new();
-        panel.AccessibleRole = role;
-
-        object actual = panel.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-        UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_IsPatternSupported_Invoke_ReturnsTrue_ForLegacyIAccessiblePatternId()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.True(panelAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_Bounds_ReturnsEmpty_IfControlIsNotCreated()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.Equal(Rectangle.Empty, panelAccessibleObject.Bounds);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_Bounds_ReturnsExpected()
-    {
-        Rectangle expected = new(0, 0, 10, 10);
-
-        using Panel panel = new()
-        {
-            Bounds = expected
-        };
-
-        panel.CreateControl();
-        Assert.True(panel.IsHandleCreated);
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-        Assert.Equal(expected, panel.RectangleToClient(panelAccessibleObject.Bounds));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.Equal(panelAccessibleObject, panelAccessibleObject.FragmentRoot);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChildCount_ReturnsMinusOne_IfHandleIsNotCreated()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.False(panel.IsHandleCreated);
-        Assert.Equal(-1, panelAccessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChildCount_ReturnsZero_IfPanelHasNoControls()
-    {
-        using Panel panel = new();
-        panel.CreateControl();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.True(panel.IsHandleCreated);
-        Assert.Equal(0, panelAccessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        using Panel parentPanel = new();
-        parentPanel.CreateControl();
-
-        using Panel childPanel = new();
-        childPanel.CreateControl();
-        parentPanel.Controls.Add(childPanel);
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(parentPanel);
-
-        Assert.True(parentPanel.IsHandleCreated);
-        Assert.True(childPanel.IsHandleCreated);
-        Assert.Equal(1, panelAccessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChild_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using Panel panel = new();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.False(panel.IsHandleCreated);
-        Assert.Null(panelAccessibleObject.GetChild(0));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChild_ReturnsNull_IfPanelHasNoControls()
-    {
-        using Panel panel = new();
-        panel.CreateControl();
-        Panel.PanelAccessibleObject panelAccessibleObject = new(panel);
-
-        Assert.True(panel.IsHandleCreated);
-        Assert.Null(panelAccessibleObject.GetChild(0));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using Panel parentPanel = new();
-        parentPanel.CreateControl();
-
-        using Panel childPanel = new();
-        childPanel.CreateControl();
-        parentPanel.Controls.Add(childPanel);
-
-        Panel.PanelAccessibleObject panelAccessibleObject = new(parentPanel);
-
-        Assert.True(parentPanel.IsHandleCreated);
-        Assert.True(childPanel.IsHandleCreated);
-        Assert.Equal(childPanel.AccessibilityObject, panelAccessibleObject.GetChild(0));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_ChildrenButton_ReturnsExpected()
-    {
-        using Panel panel = new();
-        panel.CreateControl();
-        using Button buttonFirst = new();
-        buttonFirst.CreateControl();
-        panel.Controls.Add(buttonFirst);
-        using Button buttonLast = new();
-        buttonLast.CreateControl();
-        panel.Controls.Add(buttonLast);
-
-        Assert.Equal(buttonFirst.AccessibilityObject, panel.AccessibilityObject.Navigate(AccessibleNavigation.FirstChild));
-        Assert.Equal(buttonLast.AccessibilityObject, panel.AccessibilityObject.Navigate(AccessibleNavigation.LastChild));
-    }
-
-    [WinFormsFact]
-    public void PanelAccessibleObject_BoundingRectangle_IsCorrect()
-    {
-        using Form form = new();
-        using Panel panel1 = new();
-        using Button button1 = new();
-
-        panel1.AutoScroll = true;
-        panel1.Controls.Add(button1);
-        panel1.Location = new Point(50, 50);
-        panel1.Size = new Size(200, 140);
-
-        button1.Location = new Point(17, 16);
-        button1.Size = new Size(237, 153);
-
-        form.ClientSize = new Size(300, 200);
-        form.Controls.Add(panel1);
-
-        form.Show();
-
-        Rectangle boundingRectangle = panel1.AccessibilityObject.BoundingRectangle;
-
-        int horizontalScrollBarHeight = SystemInformation.HorizontalScrollBarHeight;
-        int verticalScrollBarWidth = SystemInformation.VerticalScrollBarWidth;
-
-        Rectangle expected = panel1.RectangleToScreen(panel1.ClientRectangle);
-
-        Assert.Equal(boundingRectangle.Width, expected.Width + verticalScrollBarWidth);
-        Assert.Equal(boundingRectangle.Height, expected.Height + horizontalScrollBarHeight);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PanelTests.cs
deleted file mode 100644
index 4b4f2a22795..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PanelTests.cs
+++ /dev/null
@@ -1,1236 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class PanelTests
-{
-    [WinFormsFact]
-    public void Panel_Ctor_Default()
-    {
-        using var control = new SubPanel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Panel_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubPanel();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56000000, 0x10000)]
-    [InlineData(BorderStyle.Fixed3D, 0x56000000, 0x10200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56800000, 0x10000)]
-    public void Panel_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubPanel
-        {
-            BorderStyle = borderStyle
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Panel_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Panel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Panel_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new Panel
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void Panel_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Panel_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubPanel
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Panel_AutoSizeMode_SetWithCustomLayoutEngineParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubPanel
-        {
-            Parent = parent
-        };
-        parent.SetLayoutEngine(new SubLayoutEngine());
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = new Control().LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-    }
-
-    private class SubLayoutEngine : LayoutEngine
-    {
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void Panel_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Panel_AutoSizeMode_SetWithParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubPanel
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void Panel_AutoSizeMode_SetWithCustomLayoutEngineParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubPanel
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoSizeMode>]
-    public void Panel_AutoSizeMode_SetInvalid_ThrowsInvalidEnumArgumentException(AutoSizeMode value)
-    {
-        using var control = new Panel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoSizeMode = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void Panel_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new Panel
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void Panel_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new Panel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void Panel_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new Panel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsFact]
-    public void Panel_PreferredSize_GetWithChildrenSimple_ReturnsExpected()
-    {
-        using var control = new Panel();
-        using var child = new Control
-        {
-            Size = new Size(16, 20)
-        };
-        control.Controls.Add(child);
-        Assert.Equal(new Size(19, 23), control.PreferredSize);
-    }
-
-    [WinFormsFact]
-    public void Panel_PreferredSize_GetWithChildrenAdvanced_ReturnsExpected()
-    {
-        using var control = new BorderedPanel
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        using var child = new Control
-        {
-            Size = new Size(16, 20)
-        };
-        control.Controls.Add(child);
-        Assert.Equal(new Size(26, 31), control.PreferredSize);
-    }
-
-    private class BorderedPanel : Panel
-    {
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                CreateParams cp = base.CreateParams;
-                cp.Style |= (int)WINDOW_STYLE.WS_BORDER;
-                cp.ExStyle |= (int)WINDOW_EX_STYLE.WS_EX_STATICEDGE;
-                return cp;
-            }
-        }
-
-        public new Size SizeFromClientSize(Size clientSize) => base.SizeFromClientSize(clientSize);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Panel_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Panel
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Panel_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Panel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Panel_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new Panel
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Panel_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Panel
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Panel_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Panel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Panel_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new Panel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Panel_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPanel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubPanel.ScrollStateAutoScrolling, false)]
-    [InlineData(SubPanel.ScrollStateFullDrag, false)]
-    [InlineData(SubPanel.ScrollStateHScrollVisible, false)]
-    [InlineData(SubPanel.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubPanel.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void Panel_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubPanel();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Panel_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubPanel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Panel_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPanel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void Panel_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPanel();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void Panel_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubPanel();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void Panel_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPanel();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Panel_OnResize_Invoke_CallsResize(EventArgs eventArgs)
-    {
-        using var control = new SubPanel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnResize_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_WithHandle_TestData))]
-    public void Panel_OnResize_InvokeWithHandle_CallsResize(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubPanel();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnResize_DesignMode_TestData()
-    {
-        yield return new object[] { true, BorderStyle.None, null, 2 };
-        yield return new object[] { true, BorderStyle.None, new EventArgs(), 2 };
-        yield return new object[] { true, BorderStyle.Fixed3D, null, 1 };
-        yield return new object[] { true, BorderStyle.Fixed3D, new EventArgs(), 1 };
-        yield return new object[] { true, BorderStyle.FixedSingle, null, 1 };
-        yield return new object[] { true, BorderStyle.FixedSingle, new EventArgs(), 1 };
-
-        yield return new object[] { false, BorderStyle.None, null, 1 };
-        yield return new object[] { false, BorderStyle.None, new EventArgs(), 1 };
-        yield return new object[] { false, BorderStyle.Fixed3D, null, 0 };
-        yield return new object[] { false, BorderStyle.Fixed3D, new EventArgs(), 0 };
-        yield return new object[] { false, BorderStyle.FixedSingle, null, 0 };
-        yield return new object[] { false, BorderStyle.FixedSingle, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_DesignMode_TestData))]
-    public void Panel_OnResize_InvokeWithDesignMode_CallsResize(bool resizeRedraw, BorderStyle borderStyle, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new SubPanel
-        {
-            Site = mockSite.Object,
-            BorderStyle = borderStyle
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Panel_ToString_Invoke_ReturnsExpected()
-    {
-        var panel = new Panel { BorderStyle = BorderStyle.Fixed3D };
-        Assert.Equal("System.Windows.Forms.Panel, BorderStyle: System.Windows.Forms.BorderStyle.Fixed3D", panel.ToString());
-    }
-
-    private class SubPanel : Panel
-    {
-        public new const int ScrollStateAutoScrolling = Panel.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = Panel.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = Panel.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = Panel.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = Panel.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBox.PictureBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBox.PictureBoxAccessibleObjectTests.cs
deleted file mode 100644
index fe3b60a133a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBox.PictureBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,150 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class PictureBox_PictureBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("ownerControl", () => new PictureBox.PictureBoxAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_Ctor_Default()
-    {
-        using var pictureBox = new PictureBox();
-        Assert.False(pictureBox.IsHandleCreated);
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-
-        Assert.NotNull(pictureBoxAccessibleObject.Owner);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_Description_ReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            AccessibleDescription = "TestDescription",
-        };
-
-        Assert.False(pictureBox.IsHandleCreated);
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-
-        Assert.Equal("TestDescription", pictureBoxAccessibleObject.Description);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_Name_ReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(pictureBox.IsHandleCreated);
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-
-        Assert.Equal("TestName", pictureBoxAccessibleObject.Name);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_CustomRole_ReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            AccessibleRole = AccessibleRole.PushButton
-        };
-
-        Assert.False(pictureBox.IsHandleCreated);
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-
-        Assert.Equal(AccessibleRole.PushButton, pictureBoxAccessibleObject.Role);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void PictureBoxAccessibleObject_DefaultRole_ReturnsExpected(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var pictureBox = new PictureBox();
-
-        if (createControl)
-        {
-            pictureBox.CreateControl();
-        }
-
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-        Assert.Equal(accessibleRole, pictureBoxAccessibleObject.Role);
-        Assert.Equal(createControl, pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.PaneControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "PictureBox1")]
-    public void PictureBoxAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var pictureBox = new PictureBox
-        {
-            Name = "PictureBox1",
-            AccessibleName = "TestName"
-        };
-
-        PictureBox.PictureBoxAccessibleObject pictureBoxAccessibleObject = new(pictureBox);
-        object value = pictureBoxAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBoxAccessibleObject_IsPatternSupported_Invoke_ReturnsTrue_ForLegacyIAccessiblePatternId()
-    {
-        using var pictureBox = new PictureBox();
-        Assert.False(pictureBox.IsHandleCreated);
-        var pictureBoxAccessibleObject = new PictureBox.PictureBoxAccessibleObject(pictureBox);
-
-        Assert.True(pictureBoxAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PictureBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PictureBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void PictureBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using PictureBox pictureBox = new PictureBox();
-        pictureBox.AccessibleRole = role;
-
-        object actual = pictureBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(pictureBox.IsHandleCreated);
-    }
-}
-
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBoxTests.cs
deleted file mode 100644
index da195c8b296..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PictureBoxTests.cs
+++ /dev/null
@@ -1,2941 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Primitives;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class PictureBoxTests
-{
-    private const string PathImageLocation = "bitmaps/nature24bits.jpg";
-    private const string UrlImageLocation = "https://github.com/dotnet/winforms/blob/main/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.jpg?raw=true";
-
-    [WinFormsFact]
-    public void PictureBox_Ctor_Default()
-    {
-        using var control = new SubPictureBox();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(50, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 50), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(100, 50), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 100, 50), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.IsHandleCreated);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(100, 50), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 100, 50), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.ErrorImage);
-        Assert.Same(control.ErrorImage, control.ErrorImage);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.FontHeight, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Null(control.Image);
-        Assert.Null(control.ImageLocation);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.NotNull(control.InitialImage);
-        Assert.Same(control.InitialImage, control.InitialImage);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(new Size(100, 50), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 50), control.Size);
-        Assert.Equal(PictureBoxSizeMode.Normal, control.SizeMode);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.False(control.WaitOnLoad);
-        Assert.Equal(100, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56000000, 0)]
-    [InlineData(BorderStyle.FixedSingle, 0x56800000, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x56000000, 0x200)]
-    public void PictureBox_CreateParams_Get_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubPictureBox
-        {
-            BorderStyle = borderStyle
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(50, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void PictureBox_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, pictureBox.BorderStyle);
-
-        // Set same.
-        pictureBox.BorderStyle = value;
-        Assert.Equal(value, pictureBox.BorderStyle);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void PictureBox_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.BorderStyle = value;
-        Assert.Equal(value, pictureBox.BorderStyle);
-
-        // Set same.
-        pictureBox.BorderStyle = value;
-        Assert.Equal(value, pictureBox.BorderStyle);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void PictureBox_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => pictureBox.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new PictureBox
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, control.CausesValidation);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_CausesValidation_SetWithHandler_CallsCausesValidationChanged()
-    {
-        using var control = new PictureBox
-        {
-            CausesValidation = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CausesValidationChanged += handler;
-
-        // Set different.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.CausesValidation = true;
-        Assert.True(control.CausesValidation);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Control
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-
-        // Set different.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_Enabled_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-
-        // Set different.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var control = new Control
-        {
-            Enabled = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.EnabledChanged += handler;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_ErrorImage_Set_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ErrorImage = value
-        };
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_ErrorImage_SetWithNonNullOldValue_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ErrorImage = new Bitmap(10, 10)
-        };
-
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_ErrorImage_SetWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_ErrorImage_SetWithNonNullOldValueWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ErrorImage = new Bitmap(10, 10)
-        };
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ErrorImage = value;
-        Assert.Same(value, pictureBox.ErrorImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ErrorImage_ResetValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.ErrorImage)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.CanResetValue(pictureBox));
-
-        pictureBox.ErrorImage = image;
-        Assert.True(property.CanResetValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.ErrorImage);
-        Assert.NotNull(image);
-        Assert.False(property.CanResetValue(pictureBox));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ErrorImage_ShouldSerializeValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.ErrorImage)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-
-        pictureBox.ErrorImage = image;
-        Assert.True(property.ShouldSerializeValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.ErrorImage);
-        Assert.NotNull(image);
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PictureBox_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PictureBox
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void PictureBox_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubPictureBox
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_Image_Set_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            Image = value
-        };
-        Assert.Same(value, pictureBox.Image);
-
-        // Set same.
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_Image_SetWithNonNullOldValue_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            Image = new Bitmap(10, 10)
-        };
-
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-
-        // Set same.
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_Image_SetWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-
-        // Set same.
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_Image_SetWithNonNullOldValueWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            Image = new Bitmap(10, 10)
-        };
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-
-        // Set same.
-        pictureBox.Image = value;
-        Assert.Same(value, pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Image_ResetValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.Image)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.CanResetValue(pictureBox));
-
-        pictureBox.Image = image;
-        Assert.True(property.CanResetValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.Image);
-        Assert.NotNull(image);
-        Assert.False(property.CanResetValue(pictureBox));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Image_ShouldSerializeValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.Image)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-
-        pictureBox.Image = image;
-        Assert.True(property.ShouldSerializeValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.Image);
-        Assert.NotNull(image);
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void PictureBox_ImageLocation_Set_GetReturnsExpected(string value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = value
-        };
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    [InlineData("bitmaps/nature24bits.jpg")]
-    [InlineData("  ")]
-    public void PictureBox_ImageLocation_SetWithImage_GetReturnsExpected(string value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var pictureBox = new PictureBox
-        {
-            Image = image,
-            ImageLocation = value
-        };
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Same(image, pictureBox.Image);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Same(image, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void PictureBox_ImageLocation_SetWithHandle_GetReturnsExpected(string value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ImageLocation_Set_CallsInvalidated()
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = null
-        };
-        int invalidatedCallCount = 0;
-        pictureBox.Invalidated += (sender, e) => invalidatedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        // Set different.
-        pictureBox.ImageLocation = "Location";
-        Assert.Equal("Location", pictureBox.ImageLocation);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        pictureBox.ImageLocation = "Location";
-        Assert.Equal("Location", pictureBox.ImageLocation);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Set null.
-        pictureBox.ImageLocation = null;
-        Assert.Null(pictureBox.ImageLocation);
-        Assert.Equal(3, invalidatedCallCount);
-
-        // Set empty.
-        pictureBox.ImageLocation = string.Empty;
-        Assert.Same(string.Empty, pictureBox.ImageLocation);
-        Assert.Equal(4, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ImageLocation_SetValidWithWaitOnLoadTrueLocal_GetReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-
-        Size expectedImageSize = new(110, 100);
-
-        pictureBox.ImageLocation = PathImageLocation;
-        Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-
-        // Set same.
-        pictureBox.ImageLocation = PathImageLocation;
-        Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_ImageLocation_SetValidWithWaitOnLoadTrueUri_ConfigSwitch_CheckCRL_GetReturnsExpected(bool switchValue)
-    {
-        dynamic testAccessor = typeof(LocalAppContextSwitches).TestAccessor().Dynamic;
-
-        try
-        {
-            AppContext.SetSwitch(LocalAppContextSwitches.ServicePointManagerCheckCrlSwitchName, switchValue);
-            Assert.Equal(switchValue, LocalAppContextSwitches.ServicePointManagerCheckCrl);
-
-            using var pictureBox = new PictureBox
-            {
-                WaitOnLoad = true
-            };
-
-            Size expectedImageSize = new(110, 100);
-
-            pictureBox.ImageLocation = UrlImageLocation;
-            Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-            Assert.Same(UrlImageLocation, pictureBox.ImageLocation);
-
-            // Set same.
-            pictureBox.ImageLocation = UrlImageLocation;
-            Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-            Assert.Same(UrlImageLocation, pictureBox.ImageLocation);
-        }
-        catch
-        {
-            // Swallow network errors.
-        }
-        finally
-        {
-            testAccessor.s_servicePointManagerCheckCrl = 0;
-        }
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_ImageLocation_SetNullOrEmptyWithWaitOnLoadTrue_GetReturnsExpected(string value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-
-        pictureBox.ImageLocation = value;
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchValue")]
-    [InlineData("  ")]
-    public void PictureBox_ImageLocation_SetInvalidWithWaitOnLoadTrue_ThrowsFileNotFoundException(string value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-
-        Assert.ThrowsAny<Exception>(() => pictureBox.ImageLocation = value);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // Set same.
-        Assert.ThrowsAny<Exception>(() => pictureBox.ImageLocation = value);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-    }
-
-    public static IEnumerable<object[]> ImageLocation_SetInvalidWithWaitOnLoadTrueDesignMode_TestData()
-    {
-        foreach (string value in new string[] { " ", "NoSuchImage" })
-        {
-            yield return new object[] { null, null, value };
-            yield return new object[] { new Bitmap(10, 10), new Bitmap(10, 10), value };
-            yield return new object[] { new Bitmap(10, 10), null, value };
-            yield return new object[] { null, new Bitmap(10, 10), value };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageLocation_SetInvalidWithWaitOnLoadTrueDesignMode_TestData))]
-    public void PictureBox_ImageLocation_SetInvalidWithWaitOnLoadTrueDesignMode_GetReturnsExpected(Image initialImage, Image errorImage, string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var pictureBox = new PictureBox
-        {
-            InitialImage = initialImage,
-            ErrorImage = errorImage,
-            WaitOnLoad = true,
-            Site = mockSite.Object
-        };
-
-        pictureBox.ImageLocation = value;
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        pictureBox.Site = null;
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_ImageLocation_SetNullOrEmptyWithError_ResetsImage(string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true,
-            Site = mockSite.Object
-        };
-        pictureBox.ImageLocation = "Invalid";
-        Assert.Equal("Invalid", pictureBox.ImageLocation);
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        pictureBox.Site = null;
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    [InlineData("  ")]
-    [InlineData("bitmaps/nature24bits.jpg")]
-    public void PictureBox_ImageLocation_SetInitializing_GetReturnsExpected(string value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-        ((ISupportInitialize)pictureBox).BeginInit();
-
-        pictureBox.ImageLocation = value;
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // Set same.
-        pictureBox.ImageLocation = value;
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void PictureBox_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new PictureBox
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void PictureBox_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ImeMode_SetWithHandler_DoesNotCallImeModeChanged()
-    {
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void PictureBox_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new PictureBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_InitialImage_Set_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            InitialImage = value
-        };
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_InitialImage_SetWithNonNullOldValue_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            InitialImage = new Bitmap(10, 10)
-        };
-
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_InitialImage_SetWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PictureBox_InitialImage_SetWithNonNullOldValueWithHandle_GetReturnsExpected(Image value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            InitialImage = new Bitmap(10, 10)
-        };
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-
-        // Set same.
-        pictureBox.InitialImage = value;
-        Assert.Same(value, pictureBox.InitialImage);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_InitialImage_ResetValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.InitialImage)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.CanResetValue(pictureBox));
-
-        pictureBox.InitialImage = image;
-        Assert.True(property.CanResetValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.InitialImage);
-        Assert.NotNull(image);
-        Assert.False(property.CanResetValue(pictureBox));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_InitialImage_ShouldSerializeValue_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PictureBox))[nameof(PictureBox.InitialImage)];
-        using var pictureBox = new PictureBox();
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-
-        pictureBox.InitialImage = image;
-        Assert.True(property.ShouldSerializeValue(pictureBox));
-
-        property.ResetValue(pictureBox);
-        Assert.NotSame(image, pictureBox.InitialImage);
-        Assert.NotNull(image);
-        Assert.False(property.ShouldSerializeValue(pictureBox));
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-        yield return new object[] { new Form() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void PictureBox_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new PictureBox
-        {
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void PictureBox_Parent_SetWithNonNullOldParent_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new Control();
-        using var control = new PictureBox
-        {
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new Control();
-        using var control = new PictureBox
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new PictureBox();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void PictureBox_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new PictureBox
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void PictureBox_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new PictureBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    public static IEnumerable<object[]> SizeMode_Set_TestData()
-    {
-        yield return new object[] { PictureBoxSizeMode.Normal, false };
-        yield return new object[] { PictureBoxSizeMode.StretchImage, false };
-        yield return new object[] { PictureBoxSizeMode.AutoSize, true };
-        yield return new object[] { PictureBoxSizeMode.CenterImage, false };
-        yield return new object[] { PictureBoxSizeMode.Zoom, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeMode_Set_TestData))]
-    public void PictureBox_SizeMode_Set_GetReturnsExpected(PictureBoxSizeMode value, bool expectedAutoSize)
-    {
-        using var pictureBox = new SubPictureBox
-        {
-            SizeMode = value
-        };
-        Assert.Equal(value, pictureBox.SizeMode);
-        Assert.Equal(expectedAutoSize, pictureBox.AutoSize);
-        Assert.Equal(expectedAutoSize, pictureBox.GetStyle(ControlStyles.FixedHeight | ControlStyles.FixedWidth));
-
-        // Set same.
-        pictureBox.SizeMode = value;
-        Assert.Equal(value, pictureBox.SizeMode);
-        Assert.Equal(expectedAutoSize, pictureBox.AutoSize);
-        Assert.Equal(expectedAutoSize, pictureBox.GetStyle(ControlStyles.FixedHeight | ControlStyles.FixedWidth));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeMode_Set_TestData))]
-    public void PictureBox_SizeMode_SetWithHandle_GetReturnsExpected(PictureBoxSizeMode value, bool expectedAutoSize)
-    {
-        using var pictureBox = new SubPictureBox();
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        pictureBox.SizeMode = value;
-        Assert.Equal(value, pictureBox.SizeMode);
-        Assert.Equal(expectedAutoSize, pictureBox.AutoSize);
-        Assert.Equal(expectedAutoSize, pictureBox.GetStyle(ControlStyles.FixedHeight | ControlStyles.FixedWidth));
-
-        // Set same.
-        pictureBox.SizeMode = value;
-        Assert.Equal(value, pictureBox.SizeMode);
-        Assert.Equal(expectedAutoSize, pictureBox.AutoSize);
-        Assert.Equal(expectedAutoSize, pictureBox.GetStyle(ControlStyles.FixedHeight | ControlStyles.FixedWidth));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_SizeMode_Set_CallsInvalidated()
-    {
-        using var pictureBox = new PictureBox
-        {
-            SizeMode = PictureBoxSizeMode.Normal
-        };
-        int invalidatedCallCount = 0;
-        pictureBox.Invalidated += (sender, e) => invalidatedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        // Set different.
-        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
-        Assert.Equal(PictureBoxSizeMode.StretchImage, pictureBox.SizeMode);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
-        Assert.Equal(PictureBoxSizeMode.StretchImage, pictureBox.SizeMode);
-        Assert.Equal(1, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_SizeMode_SetWithHandler_CallsSizeModeChanged()
-    {
-        using var pictureBox = new PictureBox
-        {
-            SizeMode = PictureBoxSizeMode.Normal
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(pictureBox, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        pictureBox.SizeModeChanged += handler;
-
-        // Set different.
-        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
-        Assert.Equal(PictureBoxSizeMode.StretchImage, pictureBox.SizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
-        Assert.Equal(PictureBoxSizeMode.StretchImage, pictureBox.SizeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        pictureBox.SizeMode = PictureBoxSizeMode.Normal;
-        Assert.Equal(PictureBoxSizeMode.Normal, pictureBox.SizeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        pictureBox.SizeModeChanged -= handler;
-        pictureBox.SizeMode = PictureBoxSizeMode.StretchImage;
-        Assert.Equal(PictureBoxSizeMode.StretchImage, pictureBox.SizeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<PictureBoxSizeMode>]
-    public void PictureBox_SizeMode_SetInvalid_ThrowsInvalidEnumArgumentException(PictureBoxSizeMode value)
-    {
-        using var pictureBox = new PictureBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => pictureBox.SizeMode = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void PictureBox_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new PictureBox
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new PictureBox
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new PictureBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new PictureBox
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new PictureBox
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void PictureBox_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new PictureBox
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void PictureBox_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new PictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new PictureBox
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_Visible_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new PictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set different.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new PictureBox
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_WaitOnLoad_Set_GetReturnsExpected(bool value)
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = value
-        };
-        Assert.Equal(value, pictureBox.WaitOnLoad);
-
-        // Set same
-        pictureBox.WaitOnLoad = value;
-        Assert.Equal(value, pictureBox.WaitOnLoad);
-
-        // Set different
-        pictureBox.WaitOnLoad = !value;
-        Assert.Equal(!value, pictureBox.WaitOnLoad);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_BeginInit_InvokeMultipleTimes_Success()
-    {
-        using var pictureBox = new PictureBox();
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.BeginInit();
-        supportInitialize.BeginInit();
-    }
-
-    [WinFormsFact]
-    public void PictureBox_BeginInit_EndInitValidImageWaitOnLoadTrue_SetsImage()
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.BeginInit();
-
-        pictureBox.ImageLocation = PathImageLocation;
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        supportInitialize.EndInit();
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_BeginInit_EndInitNullOrEmptyImageWaitOnLoadTrue_DoesNotSetImage(string imageLocation)
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.BeginInit();
-
-        pictureBox.ImageLocation = imageLocation;
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        supportInitialize.EndInit();
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_BeginInit_EndInitWaitOnLoadFalse_DoesNotSetImage()
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = false
-        };
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.BeginInit();
-
-        pictureBox.ImageLocation = PathImageLocation;
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        supportInitialize.EndInit();
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    [InlineData("bitmaps/nature24bits.jpg")]
-    [InlineData("  ")]
-    public void PictureBox_EndInit_InvokeMultipleTimes_Nop(string imageLocation)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = imageLocation
-        };
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.EndInit();
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        supportInitialize.EndInit();
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    [InlineData("bitmaps/nature24bits.jpg")]
-    [InlineData("  ")]
-    public void PictureBox_EndInit_InvokeMultipleTimesWaitOnLoad_DoesNotLoadImage(string imageLocation)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = imageLocation
-        };
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        pictureBox.WaitOnLoad = true;
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        ISupportInitialize supportInitialize = pictureBox;
-        supportInitialize.EndInit();
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        supportInitialize.EndInit();
-        Assert.Equal(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_CancelAsync_InvokeWithoutStarting_Nop()
-    {
-        using var pictureBox = new PictureBox();
-        pictureBox.CancelAsync();
-        pictureBox.CancelAsync();
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Dispose_Success()
-    {
-        using var pictureBox = new PictureBox();
-        pictureBox.Dispose();
-        pictureBox.Dispose();
-    }
-
-    [WinFormsFact]
-    public void PictureBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPictureBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void PictureBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubPictureBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void PictureBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPictureBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchImage")]
-    [InlineData("  ")]
-    public void PictureBox_Load_InvalidUrl_ThrowsException(string value)
-    {
-        using var pictureBox = new PictureBox();
-
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load(value));
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        // Call again.
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load(value));
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchImage")]
-    [InlineData("  ")]
-    public void PictureBox_Load_InvalidUrlWithImage_ThrowsException(string value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var pictureBox = new PictureBox
-        {
-            Image = image
-        };
-
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load(value));
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Same(image, pictureBox.Image);
-
-        // Call again.
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load(value));
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Same(image, pictureBox.Image);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Load_Url_CallsInvalidated()
-    {
-        using var pictureBox = new PictureBox();
-        int invalidatedCallCount = 0;
-        pictureBox.Invalidated += (sender, e) => invalidatedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, pictureBox.Handle);
-
-        // Call different.
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load("Location"));
-        Assert.Equal("Location", pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Call again.
-        Assert.ThrowsAny<Exception>(() => pictureBox.Load("Location"));
-        Assert.Equal("Location", pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Call null.
-        Assert.Throws<InvalidOperationException>(() => pictureBox.Load(null));
-        Assert.Null(pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(3, invalidatedCallCount);
-
-        // Call empty.
-        Assert.Throws<InvalidOperationException>(() => pictureBox.Load(string.Empty));
-        Assert.Same(string.Empty, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(4, invalidatedCallCount);
-
-        // Call valid.
-        pictureBox.Load(PathImageLocation);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-        Assert.Equal(6, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Load_UrlValidWithWaitOnLoadTrueLocal_GetReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-
-        pictureBox.Load(PathImageLocation);
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-
-        // Call again.
-        pictureBox.Load(PathImageLocation);
-        Assert.Same(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PictureBox_Load_UrlValidWithWaitOnLoadTrueUri_ConfigSwitch_CheckCRL_GetReturnsExpected(bool switchValue)
-    {
-        dynamic testAccessor = typeof(LocalAppContextSwitches).TestAccessor().Dynamic;
-
-        try
-        {
-            AppContext.SetSwitch(LocalAppContextSwitches.ServicePointManagerCheckCrlSwitchName, switchValue);
-            Assert.Equal(switchValue, LocalAppContextSwitches.ServicePointManagerCheckCrl);
-
-            using var pictureBox = new PictureBox
-            {
-                WaitOnLoad = true
-            };
-
-            Size expectedImageSize = new(110, 100);
-
-            pictureBox.Load(UrlImageLocation);
-            Assert.Same(UrlImageLocation, pictureBox.ImageLocation);
-            Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-
-            // Call again.
-            pictureBox.Load(UrlImageLocation);
-            Assert.Same(UrlImageLocation, pictureBox.ImageLocation);
-            Assert.Equal(expectedImageSize, pictureBox.Image.Size);
-        }
-        catch
-        {
-            // Swallow network errors.
-        }
-        finally
-        {
-            testAccessor.s_servicePointManagerCheckCrl = 0;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageLocation_SetInvalidWithWaitOnLoadTrueDesignMode_TestData))]
-    public void PictureBox_Load_UrlInvalidWithWaitOnLoadTrueDesignMode_GetReturnsExpected(Image initialImage, Image errorImage, string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var pictureBox = new PictureBox
-        {
-            InitialImage = initialImage,
-            ErrorImage = errorImage,
-            WaitOnLoad = true,
-            Site = mockSite.Object
-        };
-
-        pictureBox.Load(value);
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // Set same.
-        pictureBox.Load(value);
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-        Assert.Equal(value, pictureBox.ImageLocation);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        pictureBox.Site = null;
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_Load_UrlNullOrEmptyWithError_ResetsImage(string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true,
-            Site = mockSite.Object
-        };
-        pictureBox.ImageLocation = "Invalid";
-        Assert.Equal("Invalid", pictureBox.ImageLocation);
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-
-        pictureBox.ImageLocation = value;
-        Assert.Equal(value, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        pictureBox.Site = null;
-    }
-
-    [WinFormsFact]
-    public void PictureBox_Load_UrlInitializing_GetReturnsExpected()
-    {
-        using var pictureBox = new PictureBox
-        {
-            WaitOnLoad = true
-        };
-        ((ISupportInitialize)pictureBox).BeginInit();
-
-        pictureBox.Load(PathImageLocation);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-
-        // Call again.
-        pictureBox.Load(PathImageLocation);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_Load_InvokeWithoutImageLocation_ThrowsInvalidOperationException(string imageLocation)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = imageLocation
-        };
-        Assert.Throws<InvalidOperationException>(() => pictureBox.Load());
-        Assert.Throws<InvalidOperationException>(() => pictureBox.Load(imageLocation));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void PictureBox_LoadAsync_InvokeWithoutImageLocation_ThrowsInvalidOperationException(string imageLocation)
-    {
-        using var pictureBox = new PictureBox
-        {
-            ImageLocation = imageLocation
-        };
-        Assert.Throws<InvalidOperationException>(() => pictureBox.LoadAsync());
-        Assert.Throws<InvalidOperationException>(() => pictureBox.LoadAsync(imageLocation));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnEnabledChanged_Invoke_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void PictureBox_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void PictureBox_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void PictureBox_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnLoadCompleted_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AsyncCompletedEventArgs(null, false, null) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLoadCompleted_TestData))]
-    public void PictureBox_OnLoadCompleted_Invoke_CallsLoadCompleted(AsyncCompletedEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        AsyncCompletedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LoadCompleted += handler;
-        control.OnLoadCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LoadCompleted -= handler;
-        control.OnLoadCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnLoadProgressChanged_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ProgressChangedEventArgs(0, null) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLoadProgressChanged_TestData))]
-    public void PictureBox_OnLoadProgressChanged_Invoke_CallsLoadProgressChanged(ProgressChangedEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        ProgressChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LoadProgressChanged += handler;
-        control.OnLoadProgressChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LoadProgressChanged -= handler;
-        control.OnLoadProgressChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void PictureBox_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_Image_TestData()
-    {
-        foreach (object[] testData in CommonTestHelperEx.GetPaintEventArgsTheoryData())
-        {
-            foreach (PictureBoxSizeMode sizeMode in Enum.GetValues(typeof(PictureBoxSizeMode)))
-            {
-                yield return new object[] { sizeMode, testData[0] };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_Image_TestData))]
-    public void PictureBox_OnPaint_InvokeWithValidImage_CallsLoad(PictureBoxSizeMode sizeMode, PaintEventArgs eventArgs)
-    {
-        using var image = new Bitmap(10, 10);
-        using var pictureBox = new SubPictureBox
-        {
-            SizeMode = sizeMode,
-            Image = image
-        };
-        Assert.Same(image, pictureBox.Image);
-
-        pictureBox.OnPaint(eventArgs);
-        Assert.Same(image, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_Image_TestData))]
-    public void PictureBox_OnPaint_InvokeWithValidImageLocationWaitOnLoadTrue_CallsLoad(PictureBoxSizeMode sizeMode, PaintEventArgs eventArgs)
-    {
-        using var pictureBox = new SubPictureBox
-        {
-            SizeMode = sizeMode,
-            ImageLocation = PathImageLocation
-        };
-        Assert.Null(pictureBox.Image);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-
-        pictureBox.WaitOnLoad = true;
-        pictureBox.OnPaint(eventArgs);
-        Assert.Equal(new Size(110, 100), pictureBox.Image.Size);
-        Assert.Equal(PathImageLocation, pictureBox.ImageLocation);
-    }
-
-    public static IEnumerable<object[]> OnPaint_NullOrEmptyImageLocation_TestData()
-    {
-        foreach (object[] testData in CommonTestHelperEx.GetPaintEventArgsTheoryData())
-        {
-            yield return new object[] { string.Empty, testData[0] };
-            yield return new object[] { null, testData[0] };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_NullOrEmptyImageLocation_TestData))]
-    public void PictureBox_OnPaint_InvokeWithNullOrEmptyImageLocationWaitOnLoadTrue_CallsLoad(string imageLocation, PaintEventArgs eventArgs)
-    {
-        using var pictureBox = new SubPictureBox
-        {
-            ImageLocation = imageLocation
-        };
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        pictureBox.WaitOnLoad = true;
-        pictureBox.OnPaint(eventArgs);
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-    }
-
-    public static IEnumerable<object[]> OnPaint_InvalidImageLocation_TestData()
-    {
-        foreach (object[] testData in CommonTestHelperEx.GetPaintEventArgsTheoryData())
-        {
-            foreach (PictureBoxSizeMode sizeMode in Enum.GetValues(typeof(PictureBoxSizeMode)))
-            {
-                yield return new object[] { sizeMode, "NoSuchImage", testData[0] };
-                yield return new object[] { sizeMode, "  ", testData[0] };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_InvalidImageLocation_TestData))]
-    public void PictureBox_OnPaint_InvokeWithInvalidImageLocationWaitOnLoadTrue_CallsLoad(PictureBoxSizeMode sizeMode, string imageLocation, PaintEventArgs eventArgs)
-    {
-        using var pictureBox = new SubPictureBox
-        {
-            SizeMode = sizeMode,
-            ImageLocation = imageLocation
-        };
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Null(pictureBox.Image);
-
-        pictureBox.WaitOnLoad = true;
-        pictureBox.OnPaint(eventArgs);
-        Assert.Same(imageLocation, pictureBox.ImageLocation);
-        Assert.Same(pictureBox.ErrorImage, pictureBox.Image);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void PictureBox_OnPaint_InvokeWithImage_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubPictureBox
-        {
-            Image = new Bitmap(10, 10)
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnParentChanged_Invoke_CallsParentChanged(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ParentChanged += handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.OnParentChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnResize_Invoke_CallsResize(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnResize_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_WithHandle_TestData))]
-    public void PictureBox_OnResize_InvokeWithHandle_CallsResize(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubPictureBox();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(PictureBoxSizeMode.Normal, 0)]
-    [InlineData(PictureBoxSizeMode.StretchImage, 1)]
-    [InlineData(PictureBoxSizeMode.AutoSize, 0)]
-    [InlineData(PictureBoxSizeMode.CenterImage, 1)]
-    [InlineData(PictureBoxSizeMode.Zoom, 1)]
-    public void PictureBox_OnResize_Invoke_CallsInvalidate(PictureBoxSizeMode sizeMode, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubPictureBox
-        {
-            SizeMode = sizeMode
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(EventArgs.Empty);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnSizeModeChanged_Invoke_CallsSizeModeChanged(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SizeModeChanged += handler;
-        control.OnSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SizeModeChanged -= handler;
-        control.OnSizeModeChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PictureBox_OnVisibleChanged_Invoke_CallsVisibleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubPictureBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void PictureBox_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new PictureBox();
-        Assert.Equal("System.Windows.Forms.PictureBox, SizeMode: Normal", control.ToString());
-    }
-
-    private class SubPictureBox : PictureBox
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnLoadCompleted(AsyncCompletedEventArgs e) => base.OnLoadCompleted(e);
-
-        public new void OnLoadProgressChanged(ProgressChangedEventArgs e) => base.OnLoadProgressChanged(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void OnSizeModeChanged(EventArgs e) => base.OnSizeModeChanged(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PopupEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PopupEventArgsTests.cs
deleted file mode 100644
index 4f0e20741be..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PopupEventArgsTests.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class PopupEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_IWin32Window_Control_Bool_Size_TestData()
-    {
-        yield return new object[] { null, null, false, Size.Empty };
-        yield return new object[] { new SubWin32Window(), new Button(), true, new Size(1, 2) };
-        yield return new object[] { new SubWin32Window(), new Button(), true, new Size(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_IWin32Window_Control_Bool_Size_TestData))]
-    public void Ctor_IWin32Window_Control_Bool_Size(IWin32Window associatedWindow, Control associatedControl, bool isBalloon, Size size)
-    {
-        var e = new PopupEventArgs(associatedWindow, associatedControl, isBalloon, size);
-        Assert.Equal(associatedWindow, e.AssociatedWindow);
-        Assert.Equal(associatedControl, e.AssociatedControl);
-        Assert.Equal(isBalloon, e.IsBalloon);
-        Assert.Equal(size, e.ToolTipSize);
-        Assert.False(e.Cancel);
-    }
-
-    public static IEnumerable<object[]> ToolTipSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolTipSize_TestData))]
-    public void ToolTipSize_Set_GetReturnsExpected(Size value)
-    {
-        var e = new PopupEventArgs(new SubWin32Window(), new Button(), true, new Size(1, 2))
-        {
-            ToolTipSize = value
-        };
-        Assert.Equal(value, e.ToolTipSize);
-    }
-
-    private class SubWin32Window : IWin32Window
-    {
-        public IntPtr Handle { get; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PowerStatusTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PowerStatusTests.cs
deleted file mode 100644
index 060db0f9668..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PowerStatusTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PowerStatusTests
-{
-    [Fact]
-    public void PowerStatus_BatteryChargeStatus_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-
-        // try a valid combination
-        // an edge-case can surface on laptops that are not permanently connected to power
-        // e.g. a charing laptop in a high performance mode would be HIGH | CHARGING
-        Assert.True(EnumIsDefined(status.BatteryChargeStatus));
-
-        // try an invalid (as of time of writing) combination
-        Assert.False(EnumIsDefined((BatteryChargeStatus)67));
-
-        static bool EnumIsDefined(BatteryChargeStatus value)
-        {
-            // BatteryChargeStatus.Unknown == 1111_1111, OR'ing anything with it won't change the result
-            // and thus won't catch invalid combinations, so we need to exclude if from further consideration
-
-            if (value == BatteryChargeStatus.Unknown)
-            {
-                return true;
-            }
-
-            var values = Enum.GetValues(typeof(BatteryChargeStatus))
-                .OfType<BatteryChargeStatus>()
-                .Where(v => v != BatteryChargeStatus.Unknown)
-                .Aggregate((e1, e2) => (e1 | e2));
-
-            return (values & value) == value;
-        }
-    }
-
-    [Fact]
-    public void PowerStatus_BatteryFullLifetime_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-        Assert.True(status.BatteryFullLifetime >= -1);
-    }
-
-    [Fact]
-    public void PowerStatus_BatteryLifePercent_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-        float value = status.BatteryLifePercent;
-        Assert.True((value >= 0 && value <= 100) || value == 255);
-    }
-
-    [Fact]
-    public void PowerStatus_BatteryLifeRemaining_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-        Assert.True(status.BatteryLifeRemaining >= -1);
-    }
-
-    [Fact]
-    public void PowerStatus_PowerLineStatus_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-        Assert.True(Enum.IsDefined(typeof(PowerLineStatus), status.PowerLineStatus));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PreviewKeyDownEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PreviewKeyDownEventArgsTests.cs
deleted file mode 100644
index 4faf8f7646d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PreviewKeyDownEventArgsTests.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PreviewKeyDownEventArgsTests
-{
-    [Theory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Control | Keys.A)]
-    [InlineData(Keys.Alt | Keys.A)]
-    [InlineData(Keys.Shift | Keys.A)]
-    [InlineData(Keys.Control)]
-    [InlineData(Keys.Alt)]
-    [InlineData(Keys.Shift)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.A)]
-    [InlineData((Keys)(-1))]
-    [InlineData((Keys)(0x5D))]
-    [InlineData((Keys)(0xFF))]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | (Keys)(0x5D))]
-    public void Ctor_Keys(Keys keyData)
-    {
-        var e = new PreviewKeyDownEventArgs(keyData);
-        Assert.Equal(keyData, e.KeyData);
-        Assert.Equal((keyData & Keys.Control) == Keys.Control, e.Control);
-        Assert.Equal((keyData & Keys.Alt) == Keys.Alt, e.Alt);
-        Assert.Equal((keyData & Keys.Shift) == Keys.Shift, e.Shift);
-        Assert.Equal((keyData & Keys.Modifiers), e.Modifiers);
-        Assert.Equal((int)(keyData & Keys.KeyCode), e.KeyValue);
-        Assert.False(e.IsInputKey);
-
-        if (Enum.IsDefined(typeof(Keys), e.KeyValue))
-        {
-            Assert.Equal((Keys)e.KeyValue, e.KeyCode);
-        }
-        else
-        {
-            Assert.Equal(Keys.None, e.KeyCode);
-        }
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void IsInputKey_Set_GetReturnsExpected(bool value)
-    {
-        var e = new PreviewKeyDownEventArgs(Keys.A)
-        {
-            IsInputKey = value
-        };
-        Assert.Equal(value, e.IsInputKey);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewControl.PrintPreviewControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewControl.PrintPreviewControlAccessibleObjectTests.cs
deleted file mode 100644
index 8ca2c12f663..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewControl.PrintPreviewControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class PrintPreviewControl_PrintPreviewControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_Ctor_Default()
-    {
-        using PrintPreviewControl control = new();
-        PrintPreviewControl.PrintPreviewControlAccessibleObject accessibleObject = new(control);
-
-        Assert.Equal(control, accessibleObject.Owner);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "PrintPreviewControl1")]
-    public void PrintPreviewControlAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using PrintPreviewControl control = new()
-        {
-            Name = "PrintPreviewControl1",
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(control.IsHandleCreated);
-        var accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-        object value = accessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_GetPropertyValue_Focused_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-
-        var accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-        control.CreateControl();
-        PInvoke.SetFocus(control);
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.True(value);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_GetPropertyValue_Unfocused_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-
-        Assert.False(control.IsHandleCreated);
-        var accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_BoundingRectangle_NoHandle_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.BoundingRectangle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_BoundingRectangle_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-
-        using Panel panel = new();
-        panel.Controls.Add(control);
-        panel.CreateControl();
-
-        Rectangle controlBounds = panel.RectangleToScreen(control.Bounds);
-
-        AccessibleObject accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-        Rectangle accessibleObjectBoundingRectangle = accessibleObject.BoundingRectangle;
-
-        Assert.Equal(controlBounds, accessibleObjectBoundingRectangle);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_Bounds_NoHandle_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibleObject_Bounds_ReturnsExpected()
-    {
-        using PrintPreviewControl control = new();
-        control.CreateControl();
-
-        Rectangle controlClientRectangle = control.RectangleToScreen(control.ClientRectangle);
-
-        AccessibleObject accessibleObject = new PrintPreviewControl.PrintPreviewControlAccessibleObject(control);
-
-        Assert.Equal(controlClientRectangle, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewDialogTests.cs
deleted file mode 100644
index 346323af479..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PrintPreviewDialogTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class PrintPreviewDialogTests
-{
-    [WinFormsTheory]
-    [InlineData(Keys.D1, 1, 1)]
-    [InlineData(Keys.D2, 1, 2)]
-    [InlineData(Keys.D3, 1, 3)]
-    [InlineData(Keys.D4, 2, 2)]
-    [InlineData(Keys.D5, 2, 3)]
-    public void PrintPreviewDialog_Hotkey_Ctrl_Digit_AddsRowsAndColumns(Keys digitKey, int rows, int columns)
-    {
-        using TestPrintPreviewDialog testPrintPreviewDialog = new();
-        testPrintPreviewDialog.TestProcessDialogKey(Keys.Control | digitKey);
-
-        Assert.Equal(rows, testPrintPreviewDialog.PrintPreviewControl.Rows);
-        Assert.Equal(columns, testPrintPreviewDialog.PrintPreviewControl.Columns);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Left)]
-    [InlineData(Keys.Right)]
-    [InlineData(Keys.Up)]
-    [InlineData(Keys.Down)]
-    public void PrintPreviewDialog_Hotkey_ArrowKeys_ReturnsFalse(Keys arrowKey)
-    {
-        using TestPrintPreviewDialog testPrintPreviewDialog = new();
-        Assert.False(testPrintPreviewDialog.TestProcessDialogKey(arrowKey));
-    }
-
-    private class TestPrintPreviewDialog : PrintPreviewDialog
-    {
-        internal bool TestProcessDialogKey(Keys keyData)
-        {
-            return ProcessDialogKey(keyData);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControl.PrintPreviewControlAccessibilityObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControl.PrintPreviewControlAccessibilityObjectTests.cs
deleted file mode 100644
index 53cdfc358ba..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControl.PrintPreviewControlAccessibilityObjectTests.cs
+++ /dev/null
@@ -1,231 +0,0 @@
-using System.Drawing;
-using static System.Windows.Forms.PrintPreviewControl;
-using IScrollProvider = Windows.Win32.UI.Accessibility.IScrollProvider;
-
-namespace System.Windows.Forms.Tests;
-
-public class PrintPreviewControl_PrintPreviewControlAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_Ctor_Default()
-    {
-        using PrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_Ctor_NullControl_ThrowsArgumentException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new PrintPreviewControl.PrintPreviewControlAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_ChildCount_ReturnsExpected()
-    {
-        using SubPrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-
-        control.MakeOnlyVerticalScrollBarVisible();
-        Assert.Equal(1, accessibleObject.GetChildCount());
-
-        control.MakeOnlyHorizontalScrollBarVisible();
-        Assert.Equal(1, accessibleObject.GetChildCount());
-
-        control.MakeBothScrollBarsVisible();
-        Assert.Equal(2, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_GetChild_ReturnsExpected()
-    {
-        using SubPrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        AccessibleObject verticalScrollBarAO = control.VerticalScrollBar.AccessibilityObject;
-        AccessibleObject horizontalScrollBarAO = control.HorizontalScrollBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.False(control.IsHandleCreated);
-
-        control.MakeOnlyVerticalScrollBarVisible();
-        Assert.Equal(verticalScrollBarAO, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-
-        control.MakeOnlyHorizontalScrollBarVisible();
-        Assert.Equal(horizontalScrollBarAO, accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-
-        control.MakeBothScrollBarsVisible();
-        Assert.Equal(verticalScrollBarAO, accessibleObject.GetChild(0));
-        Assert.Equal(horizontalScrollBarAO, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-
-        control.MakeNoScrollBarsVisible();
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_FragmentNavigate_Children_ReturnsExpected()
-    {
-        using SubPrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        AccessibleObject verticalScrollBarAO = control.VerticalScrollBar.AccessibilityObject;
-        AccessibleObject horizontalScrollBarAO = control.HorizontalScrollBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-
-        control.MakeOnlyVerticalScrollBarVisible();
-        Assert.Equal(verticalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(verticalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-
-        control.MakeOnlyHorizontalScrollBarVisible();
-        Assert.Equal(horizontalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(horizontalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-
-        control.MakeBothScrollBarsVisible();
-        Assert.Equal(verticalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(horizontalScrollBarAO, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-
-        control.MakeNoScrollBarsVisible();
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_FragmentNavigate_ReturnsConsistent()
-    {
-        using SubPrintPreviewControl control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        AccessibleObject verticalScrollBarAO = control.VerticalScrollBar.AccessibilityObject;
-        AccessibleObject horizontalScrollBarAO = control.HorizontalScrollBar.AccessibilityObject;
-
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-
-        control.MakeOnlyVerticalScrollBarVisible();
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-
-        control.MakeOnlyHorizontalScrollBarVisible();
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-
-        control.MakeBothScrollBarsVisible();
-        Assert.Equal(horizontalScrollBarAO, verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(verticalScrollBarAO, horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.Equal(accessibleObject, verticalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(accessibleObject, horizontalScrollBarAO.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void PrintPreviewControlAccessibilityObject_ScrollInfo_ReturnsConsistent()
-    {
-        using SubPrintPreviewControl control = new();
-
-        var accessibleObject = (PrintPreviewControlAccessibleObject)control.AccessibilityObject;
-        IScrollProvider.Interface scrollProvider = accessibleObject;
-        Assert.False(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.ScrollPatternId));
-
-        control.MakeOnlyVerticalScrollBarVisible();
-        Assert.True(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.ScrollPatternId));
-
-        Assert.False((bool)scrollProvider.HorizontallyScrollable);
-        Assert.Equal(0, (int)scrollProvider.HorizontalScrollPercent);
-        Assert.Equal(100, (int)scrollProvider.HorizontalViewSize);
-
-        Assert.True((bool)scrollProvider.VerticallyScrollable);
-        Assert.InRange((int)scrollProvider.VerticalScrollPercent, 0, 100);
-        AssertExtensions.GreaterThanOrEqualTo((int)scrollProvider.VerticalViewSize, 0);
-
-        control.MakeNoScrollBarsVisible();
-        Assert.False(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.ScrollPatternId));
-
-        control.MakeOnlyHorizontalScrollBarVisible();
-        Assert.True(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.ScrollPatternId));
-
-        Assert.False((bool)scrollProvider.VerticallyScrollable);
-        Assert.Equal(0, (int)scrollProvider.VerticalScrollPercent);
-        Assert.Equal(100, (int)scrollProvider.VerticalViewSize);
-
-        Assert.True((bool)scrollProvider.HorizontallyScrollable);
-        Assert.InRange((int)scrollProvider.HorizontalScrollPercent, 0, 100);
-        AssertExtensions.GreaterThanOrEqualTo((int)scrollProvider.HorizontalViewSize, 0);
-    }
-
-    private class SubPrintPreviewControl : PrintPreviewControl
-    {
-        public SubPrintPreviewControl()
-        {
-            Size = new(100, 100);
-        }
-
-        public new ScrollBar VerticalScrollBar
-            => this.TestAccessor().Dynamic._vScrollBar;
-
-        public new ScrollBar HorizontalScrollBar
-            => this.TestAccessor().Dynamic._hScrollBar;
-
-        public void MakeNoScrollBarsVisible()
-        {
-            if (!Created)
-            {
-                CreateControl();
-            }
-
-            SetVirtualSizeNoInvalidate(new Size(50, 50));
-        }
-
-        public void MakeOnlyVerticalScrollBarVisible()
-        {
-            if (!Created)
-            {
-                CreateControl();
-            }
-
-            SetVirtualSizeNoInvalidate(new Size(50, 200));
-        }
-
-        public void MakeOnlyHorizontalScrollBarVisible()
-        {
-            if (!Created)
-            {
-                CreateControl();
-            }
-
-            SetVirtualSizeNoInvalidate(new Size(200, 50));
-        }
-
-        public void MakeBothScrollBarsVisible()
-        {
-            if (!Created)
-            {
-                CreateControl();
-            }
-
-            SetVirtualSizeNoInvalidate(new Size(200, 200));
-        }        
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControlTests.cs
deleted file mode 100644
index 2eda82747ed..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Printing/PrintPreviewControlTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PrintPreviewControlTests
-{
-    private const int emptyColorArgb = 0;
-    private const int blueColorArgb = -16776961;
-    private const int greenColorArgb = -16744448;
-    private const int controlDarkColorArgb = -6250336;
-    private const int appWorkSpaceNoHcColorArgb = -5526613;
-    private const int appWorkSpaceHcColorArgb = -1;
-
-    [Theory]
-    [InlineData(emptyColorArgb, false, appWorkSpaceNoHcColorArgb)]
-    [InlineData(emptyColorArgb, true, controlDarkColorArgb)]
-    [InlineData(blueColorArgb, false, blueColorArgb)]
-    [InlineData(greenColorArgb, true, greenColorArgb)]
-    public void ShowPrintPreviewControl_BackColorIsCorrect(int customBackColorArgb, bool isHighContrast, int expectedBackColorArgb)
-    {
-        var control = new PrintPreviewControl();
-
-        if (customBackColorArgb != emptyColorArgb)
-        {
-            control.BackColor = Color.FromArgb(customBackColorArgb);
-        }
-
-        int actualBackColorArgb = control.TestAccessor().Dynamic.GetBackColor(isHighContrast).ToArgb();
-        Assert.Equal(expectedBackColorArgb, actualBackColorArgb);
-
-        // Default AppWorkSpace color in HC theme does not allow to follow HC standards.
-        if (isHighContrast)
-        {
-            Assert.True(!appWorkSpaceHcColorArgb.Equals(actualBackColorArgb));
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorTableTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorTableTests.cs
deleted file mode 100644
index 258dbe9f546..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorTableTests.cs
+++ /dev/null
@@ -1,201 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Microsoft.DotNet.RemoteExecutor;
-using Microsoft.Win32;
-
-namespace System.Windows.Forms.Tests;
-
-public class ProfessionalColorTableTests
-{
-    [WinFormsFact]
-    public void ProfessionalColorTable_Ctor_Default()
-    {
-        var table = new ProfessionalColorTable();
-        Assert.False(table.UseSystemColors);
-    }
-
-    public static IEnumerable<object[]> Properties_TestData()
-    {
-        // Helper function to avoid casting.
-        static Func<ProfessionalColorTable, T> I<T>(Func<ProfessionalColorTable, T> t) => t;
-
-        yield return new object[] { I(t => t.ButtonCheckedGradientBegin) };
-        yield return new object[] { I(t => t.ButtonCheckedGradientEnd) };
-        yield return new object[] { I(t => t.ButtonCheckedGradientMiddle) };
-        yield return new object[] { I(t => t.ButtonCheckedHighlight) };
-        yield return new object[] { I(t => t.ButtonCheckedHighlightBorder) };
-        yield return new object[] { I(t => t.ButtonPressedBorder) };
-        yield return new object[] { I(t => t.ButtonPressedGradientBegin) };
-        yield return new object[] { I(t => t.ButtonPressedGradientEnd) };
-        yield return new object[] { I(t => t.ButtonPressedGradientMiddle) };
-        yield return new object[] { I(t => t.ButtonPressedHighlight) };
-        yield return new object[] { I(t => t.ButtonPressedHighlightBorder) };
-        yield return new object[] { I(t => t.ButtonSelectedBorder) };
-        yield return new object[] { I(t => t.ButtonSelectedGradientBegin) };
-        yield return new object[] { I(t => t.ButtonSelectedGradientEnd) };
-        yield return new object[] { I(t => t.ButtonSelectedGradientMiddle) };
-        yield return new object[] { I(t => t.ButtonSelectedHighlight) };
-        yield return new object[] { I(t => t.ButtonSelectedHighlightBorder) };
-        yield return new object[] { I(t => t.CheckBackground) };
-        yield return new object[] { I(t => t.CheckPressedBackground) };
-        yield return new object[] { I(t => t.CheckSelectedBackground) };
-        yield return new object[] { I(t => t.GripDark) };
-        yield return new object[] { I(t => t.GripLight) };
-        yield return new object[] { I(t => t.ImageMarginGradientBegin) };
-        yield return new object[] { I(t => t.ImageMarginGradientMiddle) };
-        yield return new object[] { I(t => t.ImageMarginRevealedGradientBegin) };
-        yield return new object[] { I(t => t.ImageMarginRevealedGradientEnd) };
-        yield return new object[] { I(t => t.ImageMarginRevealedGradientMiddle) };
-        yield return new object[] { I(t => t.MenuBorder) };
-        yield return new object[] { I(t => t.MenuItemBorder) };
-        yield return new object[] { I(t => t.MenuItemPressedGradientBegin) };
-        yield return new object[] { I(t => t.MenuItemPressedGradientEnd) };
-        yield return new object[] { I(t => t.MenuItemPressedGradientMiddle) };
-        yield return new object[] { I(t => t.MenuItemSelected) };
-        yield return new object[] { I(t => t.MenuItemSelectedGradientBegin) };
-        yield return new object[] { I(t => t.MenuItemSelectedGradientEnd) };
-        yield return new object[] { I(t => t.MenuStripGradientBegin) };
-        yield return new object[] { I(t => t.MenuStripGradientEnd) };
-        yield return new object[] { I(t => t.OverflowButtonGradientBegin) };
-        yield return new object[] { I(t => t.OverflowButtonGradientEnd) };
-        yield return new object[] { I(t => t.OverflowButtonGradientMiddle) };
-        yield return new object[] { I(t => t.RaftingContainerGradientBegin) };
-        yield return new object[] { I(t => t.RaftingContainerGradientEnd) };
-        yield return new object[] { I(t => t.SeparatorDark) };
-        yield return new object[] { I(t => t.SeparatorLight) };
-        yield return new object[] { I(t => t.StatusStripGradientBegin) };
-        yield return new object[] { I(t => t.StatusStripGradientEnd) };
-        yield return new object[] { I(t => t.ToolStripBorder) };
-        yield return new object[] { I(t => t.ToolStripContentPanelGradientBegin) };
-        yield return new object[] { I(t => t.ToolStripContentPanelGradientEnd) };
-        yield return new object[] { I(t => t.ToolStripDropDownBackground) };
-        yield return new object[] { I(t => t.ToolStripGradientBegin) };
-        yield return new object[] { I(t => t.ToolStripGradientEnd) };
-        yield return new object[] { I(t => t.ToolStripGradientMiddle) };
-        yield return new object[] { I(t => t.ToolStripPanelGradientBegin) };
-        yield return new object[] { I(t => t.ToolStripPanelGradientEnd) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Properties_TestData))]
-    public void ProfessionalColorTable_Properties_Get_ReturnsExpected(Func<ProfessionalColorTable, Color> factory)
-    {
-        var table = new ProfessionalColorTable();
-        Color result = factory(table);
-        Assert.Equal(result, factory(table));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Properties_TestData))]
-    public void ProfessionalColorTable_Properties_GetUseSystemColors_ReturnsExpected(Func<ProfessionalColorTable, Color> factory)
-    {
-        var table = new ProfessionalColorTable
-        {
-            UseSystemColors = true
-        };
-        Color result = factory(table);
-        Assert.Equal(result, factory(table));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Properties_TestData))]
-    public void ProfessionalColorTable_Properties_GetToolStripManagerVisualStylesEnabled_ReturnsExpected(Func<ProfessionalColorTable, Color> factory)
-    {
-        bool oldValue = ToolStripManager.VisualStylesEnabled;
-        try
-        {
-            ToolStripManager.VisualStylesEnabled = true;
-
-            var table = new ProfessionalColorTable();
-            Color result = factory(table);
-            Assert.Equal(result, factory(table));
-        }
-        finally
-        {
-            ToolStripManager.VisualStylesEnabled = oldValue;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProfessionalColorTable_ImageMarginGradientEnd_Get_ReturnsExpected(bool useSystemColors)
-    {
-        var table = new ProfessionalColorTable
-        {
-            UseSystemColors = useSystemColors
-        };
-        Assert.NotEqual(table.ImageMarginGradientEnd, table.ImageMarginGradientEnd);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProfessionalColorTable_UseSystemColors_Set_GetReturnsExpected(bool value)
-    {
-        var table = new ProfessionalColorTable
-        {
-            UseSystemColors = value
-        };
-        Assert.Equal(value, table.UseSystemColors);
-
-        // Set same.
-        table.UseSystemColors = value;
-        Assert.Equal(value, table.UseSystemColors);
-
-        // Set different.
-        table.UseSystemColors = !value;
-        Assert.Equal(!value, table.UseSystemColors);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProfessionalColorTable_UseSystemColors_SetWithKnownColor_GetReturnsExpected(bool value)
-    {
-        var table = new ProfessionalColorTable
-        {
-            UseSystemColors = !value
-        };
-        Color result = table.ButtonCheckedGradientBegin;
-        Assert.Equal(result, table.ButtonCheckedGradientBegin);
-
-        table.UseSystemColors = value;
-        Assert.Equal(value, table.UseSystemColors);
-
-        // Set same.
-        table.UseSystemColors = value;
-        Assert.Equal(value, table.UseSystemColors);
-
-        // Set different.
-        table.UseSystemColors = !value;
-        Assert.Equal(!value, table.UseSystemColors);
-    }
-
-    [WinFormsTheory(Skip = "Deadlocks under x86, see: https://github.com/dotnet/winforms/issues/3254, RemoteExecute crash with AbandonedMutexException,see: https://github.com/dotnet/arcade/issues/5325")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3254")]
-    [ActiveIssue("https://github.com/dotnet/arcade/issues/5325")]
-    [InlineData(UserPreferenceCategory.Color)]
-    [InlineData(UserPreferenceCategory.Accessibility)]
-    [InlineData(UserPreferenceCategory.Desktop)]
-    [InlineData(UserPreferenceCategory.Icon)]
-    [InlineData(UserPreferenceCategory.Mouse)]
-    [InlineData(UserPreferenceCategory.Keyboard)]
-    [InlineData(UserPreferenceCategory.Menu)]
-    [InlineData(UserPreferenceCategory.Power)]
-    [InlineData(UserPreferenceCategory.Screensaver)]
-    [InlineData(UserPreferenceCategory.Window)]
-    public void ProfessionalColorTable_ChangeUserPreferences_GetColor_ReturnsExpected(UserPreferenceCategory category)
-    {
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            // Simulate a SystemEvents.UserPreferenceChanged event.
-            var table = new ProfessionalColorTable();
-            Color color = table.ButtonSelectedHighlight;
-            SystemEventsHelper.SendMessageOnUserPreferenceChanged(category);
-            Assert.Equal(color, table.ButtonSelectedHighlight);
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorsTests.cs
deleted file mode 100644
index 23191a454ee..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProfessionalColorsTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ProfessionalColorsTests
-{
-    public static IEnumerable<object[]> Properties_TestData()
-    {
-        static Func<T> I<T>(Func<T> t) => t;
-
-        yield return new object[] { I(() => ProfessionalColors.ButtonCheckedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonCheckedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonCheckedGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonCheckedHighlight) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonCheckedHighlightBorder) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedBorder) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedHighlight) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonPressedHighlightBorder) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedBorder) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedHighlight) };
-        yield return new object[] { I(() => ProfessionalColors.ButtonSelectedHighlightBorder) };
-        yield return new object[] { I(() => ProfessionalColors.CheckBackground) };
-        yield return new object[] { I(() => ProfessionalColors.CheckPressedBackground) };
-        yield return new object[] { I(() => ProfessionalColors.CheckSelectedBackground) };
-        yield return new object[] { I(() => ProfessionalColors.GripDark) };
-        yield return new object[] { I(() => ProfessionalColors.GripLight) };
-        yield return new object[] { I(() => ProfessionalColors.ImageMarginGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ImageMarginGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.ImageMarginRevealedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ImageMarginRevealedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ImageMarginRevealedGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.MenuBorder) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemBorder) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemPressedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemPressedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemPressedGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemSelected) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemSelectedGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.MenuItemSelectedGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.MenuStripGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.MenuStripGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.OverflowButtonGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.OverflowButtonGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.OverflowButtonGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.RaftingContainerGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.RaftingContainerGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.SeparatorDark) };
-        yield return new object[] { I(() => ProfessionalColors.SeparatorLight) };
-        yield return new object[] { I(() => ProfessionalColors.StatusStripGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.StatusStripGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripBorder) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripContentPanelGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripContentPanelGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripDropDownBackground) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripGradientEnd) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripGradientMiddle) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripPanelGradientBegin) };
-        yield return new object[] { I(() => ProfessionalColors.ToolStripPanelGradientEnd) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Properties_TestData))]
-    public void ProfessionalColors_Properties_Get_ReturnsExpected(Func<Color> factory)
-    {
-        Color result = factory();
-        Assert.Equal(result, factory());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Properties_TestData))]
-    public void ProfessionalColors_Properties_GetToolStripManagerVisualStylesEnabled_ReturnsExpected(Func<Color> factory)
-    {
-        bool oldValue = ToolStripManager.VisualStylesEnabled;
-        try
-        {
-            ToolStripManager.VisualStylesEnabled = true;
-
-            Color result = factory();
-            Assert.Equal(result, factory());
-        }
-        finally
-        {
-            ToolStripManager.VisualStylesEnabled = oldValue;
-        }
-    }
-
-    [WinFormsFact]
-    public void ProfessionalColors_ImageMarginGradientEnd_Get_ReturnsExpected()
-    {
-        Assert.NotEqual(ProfessionalColors.ImageMarginGradientEnd, ProfessionalColors.ImageMarginGradientEnd);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarAccessibleObjectTests.cs
deleted file mode 100644
index ff67cb88b11..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,150 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Accessibility;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ProgressBarAccessibleObject
-{
-    [WinFormsFact]
-    public void ProgressBarAccessibilityObject_Properties_ReturnsExpected_IfHandleIsCreated()
-    {
-        using var ownerControl = new ProgressBar
-        {
-            Value = 5,
-        };
-
-        ownerControl.CreateControl();
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Equal(ownerControl.ClientSize, accessibilityObject.Bounds.Size);
-        Assert.Null(accessibilityObject.DefaultAction);
-        Assert.Null(accessibilityObject.Description);
-        Assert.Null(accessibilityObject.Help);
-        Assert.Null(accessibilityObject.KeyboardShortcut);
-        Assert.Null(accessibilityObject.Name);
-        Assert.Equal(AccessibleRole.ProgressBar, accessibilityObject.Role);
-        Assert.Same(ownerControl, accessibilityObject.Owner);
-        Assert.NotNull(accessibilityObject.Parent);
-        Assert.Equal(AccessibleStates.ReadOnly | AccessibleStates.Focusable, accessibilityObject.State);
-        Assert.Equal("5%", accessibilityObject.Value);
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, accessibilityObject.Handle);
-    }
-
-    [WinFormsFact]
-    public void ProgressBarAccessibilityObject_Properties_ReturnsExpected_IfHandleIsNotCreated()
-    {
-        using var ownerControl = new ProgressBar
-        {
-            Value = 5,
-        };
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Equal(Rectangle.Empty.Size, accessibilityObject.Bounds.Size);
-        Assert.Null(accessibilityObject.DefaultAction);
-        Assert.Null(accessibilityObject.Description);
-        Assert.Null(accessibilityObject.Help);
-        Assert.Null(accessibilityObject.KeyboardShortcut);
-        Assert.Null(accessibilityObject.Name);
-        Assert.Equal(AccessibleRole.None, accessibilityObject.Role);
-        Assert.Same(ownerControl, accessibilityObject.Owner);
-        Assert.Null(accessibilityObject.Parent);
-        Assert.Equal(AccessibleStates.None, accessibilityObject.State);
-        Assert.Equal(string.Empty, accessibilityObject.Value);
-        Assert.False(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, accessibilityObject.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData("100%", true, "0%")]
-    [InlineData("0%", true, "0%")]
-    [InlineData(null, true, "0%")]
-    [InlineData("", true, "0%")]
-    [InlineData("INVALID", true, "0%")]
-    [InlineData("100%", false, "")]
-    [InlineData("0%", false, "")]
-    [InlineData(null, false, "")]
-    [InlineData("", false, "")]
-    [InlineData("INVALID", false, "")]
-    public void ProgressBarAccessibilityObject_Value_Set_GetReturnsExpected(string value, bool createControl, string expectedValue)
-    {
-        using var ownerControl = new ProgressBar();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-        accessibilityObject.Value = value;
-        Assert.Equal(expectedValue, accessibilityObject.Value);
-        Assert.Equal(0, ownerControl.Value);
-
-        // Set same.
-        accessibilityObject.Value = value;
-        Assert.Equal(expectedValue, accessibilityObject.Value);
-        Assert.Equal(0, ownerControl.Value);
-    }
-
-    [WinFormsFact]
-    public void ProgressBarAccessibilityObject_GetChildCount_ReturnsExpected()
-    {
-        using var ownerControl = new ProgressBar
-        {
-            Value = 5
-        };
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-        IAccessible iAccessible = accessibilityObject;
-        Assert.Equal(0, iAccessible.accChildCount);
-        Assert.Equal(-1, accessibilityObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void ProgressBarAccessibleObject_ControlType_IsProgressBar_IfAccessibleRoleIsDefault()
-    {
-        using ProgressBar progressBar = new ProgressBar();
-        // AccessibleRole is not set = Default
-
-        object actual = progressBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ProgressBarControlTypeId, actual);
-        Assert.False(progressBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ProgressBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProgressBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ProgressBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ProgressBar progressBar = new ProgressBar();
-        progressBar.AccessibleRole = role;
-
-        object actual = progressBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(progressBar.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarTests.cs
deleted file mode 100644
index b5aeb80f334..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ProgressBarTests.cs
+++ /dev/null
@@ -1,2676 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ProgressBarTests
-{
-    [WinFormsFact]
-    public void ProgressBar_Ctor_Default()
-    {
-        using var control = new SubProgressBar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(23, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 23), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 100, 23), control.ClientRectangle);
-        Assert.Equal(new Size(100, 23), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(100, 23), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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.Highlight, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(23, control.Height);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(100, control.MarqueeAnimationSpeed);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Equal(new Size(100, 23), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 23), control.Size);
-        Assert.Equal(10, control.Step);
-        Assert.Equal(ProgressBarStyle.Blocks, control.Style);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.Visible);
-        Assert.Equal(100, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubProgressBar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_progress32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ProgressBarStyle.Blocks, true, 0x56010000)]
-    [InlineData(ProgressBarStyle.Continuous, true, 0x56010001)]
-    [InlineData(ProgressBarStyle.Marquee, true, 0x56010000)]
-    [InlineData(ProgressBarStyle.Blocks, false, 0x56010000)]
-    [InlineData(ProgressBarStyle.Continuous, false, 0x56010001)]
-    [InlineData(ProgressBarStyle.Marquee, false, 0x56010008)]
-    public void ProgressBar_CreateParams_GetStyle_ReturnsExpected(ProgressBarStyle style, bool designMode, int expectedStyle)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns<IContainer>(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new SubProgressBar
-        {
-            Style = style,
-            Site = mockSite.Object
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_progress32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true, 0x56010000, 0x0)]
-    [InlineData(RightToLeft.No, true, 0x56010000, 0x0)]
-    [InlineData(RightToLeft.Yes, true, 0x56010000, 0x400000)]
-    [InlineData(RightToLeft.Inherit, false, 0x56010000, 0x0)]
-    [InlineData(RightToLeft.No, false, 0x56010000, 0x0)]
-    [InlineData(RightToLeft.Yes, false, 0x56010000, 0x7000)]
-    public void ProgressBar_CreateParams_GetRightToLeft_ReturnsExpected(RightToLeft rightToLeft, bool rightToLeftLayout, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubProgressBar
-        {
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_progress32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(23, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ProgressBar
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = !value;
-        Assert.Equal(!value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void ProgressBar_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new ProgressBar
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ProgressBar_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubProgressBar
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ProgressBar_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ProgressBar
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_CausesValidation_SetWithHandler_CallsCausesValidationChanged()
-    {
-        using var control = new ProgressBar
-        {
-            CausesValidation = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CausesValidationChanged += handler;
-
-        // Set different.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.CausesValidation = true;
-        Assert.True(control.CausesValidation);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubProgressBar();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubProgressBar
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ProgressBar_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubProgressBar
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ProgressBar_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ProgressBar
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.Empty, ProgressBar.DefaultForeColor, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void ProgressBar_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(ProgressBar.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.ForeColor)];
-        using var control = new ProgressBar();
-        Assert.False(property.CanResetValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Highlight, control.ForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(Control))[nameof(Control.ForeColor)];
-        using var control = new ProgressBar();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Highlight, control.ForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void ProgressBar_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new ProgressBar
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void ProgressBar_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void ProgressBar_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    public static IEnumerable<object[]> MarqueeAnimationSpeed_Set_TestData()
-    {
-        foreach (ProgressBarStyle style in Enum.GetValues(typeof(ProgressBarStyle)))
-        {
-            yield return new object[] { style, 0 };
-            yield return new object[] { style, 1 };
-            yield return new object[] { style, 100 };
-            yield return new object[] { style, int.MaxValue };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MarqueeAnimationSpeed_Set_TestData))]
-    public void ProgressBar_MarqueeAnimationSpeed_Set_GetReturnsExpected(ProgressBarStyle style, int value)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style,
-            MarqueeAnimationSpeed = value
-        };
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MarqueeAnimationSpeed_Set_TestData))]
-    public void ProgressBar_MarqueeAnimationSpeed_SetDesignMode_GetReturnsExpected(ProgressBarStyle style, int value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns<IContainer>(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new ProgressBar
-        {
-            Site = mockSite.Object,
-            Style = style,
-            MarqueeAnimationSpeed = value
-        };
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MarqueeAnimationSpeed_Set_TestData))]
-    public void ProgressBar_MarqueeAnimationSpeed_SetWithHandle_GetReturnsExpected(ProgressBarStyle style, int value)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MarqueeAnimationSpeed_Set_TestData))]
-    public void ProgressBar_MarqueeAnimationSpeed_SetWithHandleDesignMode_GetReturnsExpected(ProgressBarStyle style, int value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns<IContainer>(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new ProgressBar
-        {
-            Site = mockSite.Object,
-            Style = style
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MarqueeAnimationSpeed = value;
-        Assert.Equal(value, control.MarqueeAnimationSpeed);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_MarqueeAnimationSpeed_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.MarqueeAnimationSpeed = -1);
-    }
-
-    public static IEnumerable<object[]> Maximum_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 1 };
-        yield return new object[] { 100 };
-        yield return new object[] { int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Maximum_Set_TestData))]
-    public void ProgressBar_Maximum_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Maximum = value
-        };
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Value);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(4)]
-    [InlineData(0)]
-    public void ProgressBar_Maximum_SetLessThanMinimum_SetsMinimumToMaximum(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Minimum = 5,
-            Maximum = value
-        };
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(value, control.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(4)]
-    [InlineData(0)]
-    public void ProgressBar_Maximum_SetLessThanValue_SetsMinimumToValue(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = 5,
-            Maximum = value
-        };
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(value, control.Value);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Maximum_Set_TestData))]
-    public void ProgressBar_Maximum_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Maximum = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_Maximum_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Maximum = -1);
-    }
-
-    public static IEnumerable<object[]> Minimum_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 5 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Minimum_Set_TestData))]
-    public void ProgressBar_Minimum_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(5, control.Value);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(5, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(101)]
-    [InlineData(int.MaxValue)]
-    public void ProgressBar_Minimum_SetGreaterThanMaximum_SetsMaximumToMinimum(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Minimum = value
-        };
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(value, control.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(6)]
-    public void ProgressBar_Minimum_SetGreaterThanValue_SetsMinimumToValue(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Value);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Minimum_Set_TestData))]
-    public void ProgressBar_Minimum_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Minimum = value;
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(5, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(5, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_Minimum_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Minimum = -1);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ProgressBar_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ProgressBar
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ProgressBar_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1)]
-    [InlineData(RightToLeft.Yes, false, 0)]
-    [InlineData(RightToLeft.No, true, 1)]
-    [InlineData(RightToLeft.No, false, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1)]
-    [InlineData(RightToLeft.Inherit, false, 0)]
-    public void ProgressBar_RightToLeftLayout_Set_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new ProgressBar
-        {
-            RightToLeft = rightToLeft
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1, 1, 2)]
-    [InlineData(RightToLeft.Yes, false, 0, 0, 1)]
-    [InlineData(RightToLeft.No, true, 1, 0, 0)]
-    [InlineData(RightToLeft.No, false, 0, 0, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1, 0, 0)]
-    [InlineData(RightToLeft.Inherit, false, 0, 0, 0)]
-    public void ProgressBar_RightToLeftLayout_SetWithHandle_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new ProgressBar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_RightToLeftLayout_SetWithHandler_CallsRightToLeftLayoutChanged()
-    {
-        using var control = new ProgressBar
-        {
-            RightToLeftLayout = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftLayoutChanged += handler;
-
-        // Set different.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeftLayout = true;
-        Assert.True(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_RightToLeftLayout_SetWithHandlerInDisposing_DoesNotRightToLeftLayoutChanged()
-    {
-        using var control = new ProgressBar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeftLayout = true;
-            Assert.True(control.RightToLeftLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    public static IEnumerable<object[]> Step_Set_TestData()
-    {
-        yield return new object[] { int.MinValue };
-        yield return new object[] { 0 };
-        yield return new object[] { 5 };
-        yield return new object[] { int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Step_Set_TestData))]
-    public void ProgressBar_Step_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Step = value
-        };
-        Assert.Equal(value, control.Step);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Step = value;
-        Assert.Equal(value, control.Step);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Step_Set_TestData))]
-    public void ProgressBar_Step_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Step = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Step = value;
-        Assert.Equal(value, control.Step);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Step = value;
-        Assert.Equal(value, control.Step);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ProgressBarStyle>]
-    public void ProgressBar_Style_Set_GetReturnsExpected(ProgressBarStyle value)
-    {
-        using var control = new ProgressBar
-        {
-            Style = value
-        };
-        Assert.Equal(value, control.Style);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ProgressBarStyle>]
-    public void ProgressBar_Style_SetZeroMarqueeAnimationSpeed_GetReturnsExpected(ProgressBarStyle value)
-    {
-        using var control = new ProgressBar
-        {
-            MarqueeAnimationSpeed = 0,
-            Style = value
-        };
-        Assert.Equal(value, control.Style);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ProgressBarStyle.Blocks, 0)]
-    [InlineData(ProgressBarStyle.Continuous, 1)]
-    [InlineData(ProgressBarStyle.Marquee, 1)]
-    public void ProgressBar_Style_SetWithHandle_GetReturnsExpected(ProgressBarStyle value, int expectedCreatedCallCount)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ProgressBarStyle.Blocks, 0)]
-    [InlineData(ProgressBarStyle.Continuous, 1)]
-    [InlineData(ProgressBarStyle.Marquee, 1)]
-    public void ProgressBar_Style_SetWithHandleZeroMarqueeAnimationSpeed_GetReturnsExpected(ProgressBarStyle value, int expectedCreatedCallCount)
-    {
-        using var control = new ProgressBar
-        {
-            MarqueeAnimationSpeed = 0
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Style = value;
-        Assert.Equal(value, control.Style);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ProgressBarStyle>]
-    public void ProgressBar_Style_SetInvalidValue_ThrowsInvalidEnumArgumentException(ProgressBarStyle value)
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Style = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ProgressBar
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ProgressBar_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new ProgressBar
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ProgressBar_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ProgressBar
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ProgressBar_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new ProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Value_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 5 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void ProgressBar_Value_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = value
-        };
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Value);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void ProgressBar_Value_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Value = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(101)]
-    public void ProgressBar_Value_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new ProgressBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Value = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ProgressBar)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ProgressBar_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using var control = new SubProgressBar();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedAccessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_CreateHandle_Invoke_Success()
-    {
-        using var control = new SubProgressBar();
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubProgressBar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ProgressBar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubProgressBar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubProgressBar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> Increment_TestData()
-    {
-        foreach (ProgressBarStyle style in new ProgressBarStyle[] { ProgressBarStyle.Blocks, ProgressBarStyle.Continuous })
-        {
-            yield return new object[] { style, 0, 1, 1 };
-            yield return new object[] { style, 0, 100, 100 };
-            yield return new object[] { style, 0, 101, 100 };
-            yield return new object[] { style, 0, 0, 0 };
-            yield return new object[] { style, 0, -1, 0 };
-            yield return new object[] { style, 100, -1, 99 };
-            yield return new object[] { style, 100, -100, 0 };
-            yield return new object[] { style, 100, -101, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Increment_TestData))]
-    public void ProgressBar_Increment_Invoke_Success(ProgressBarStyle style, int originalValue, int value, int expectedValue)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style,
-            Value = originalValue
-        };
-        control.Increment(value);
-        Assert.Equal(expectedValue, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Increment_TestData))]
-    public void ProgressBar_Increment_InvokeWithHandle_Success(ProgressBarStyle style, int originalValue, int value, int expectedValue)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style,
-            Value = originalValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Increment(value);
-        Assert.Equal(expectedValue, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ProgressBar_Increment_Marquee_ThrowsInvalidOperationException(int value)
-    {
-        using var control = new ProgressBar
-        {
-            Style = ProgressBarStyle.Marquee
-        };
-        Assert.Throws<InvalidOperationException>(() => control.Increment(value));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void MonthControl_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnForeColorChanged_InvokeWithHandle_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int invalidatedCallCount = 0;
-        InvalidateEventHandler invalidatedHandler = (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        EventHandler createdHandler = (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.ForeColorChanged += handler;
-        control.Invalidated += invalidatedHandler;
-        control.StyleChanged += styleChangedHandler;
-        control.HandleCreated += createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.Invalidated -= invalidatedHandler;
-        control.StyleChanged -= styleChangedHandler;
-        control.HandleCreated -= createdHandler;
-        control.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_TestData()
-    {
-        foreach (ProgressBarStyle style in Enum.GetValues(typeof(ProgressBarStyle)))
-        {
-            foreach (object[] testData in CommonTestHelper.GetEventArgsTheoryData())
-            {
-                yield return new object[] { style, testData[0] };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void ProgressBar_OnHandleCreated_Invoke_CallsHandleCreated(ProgressBarStyle style, EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar
-        {
-            Style = style
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void ProgressBar_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(ProgressBarStyle style, EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar
-        {
-            Style = style
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ProgressBar_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void ProgressBar_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ProgressBar_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ProgressBar_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ProgressBar_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ProgressBar_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubProgressBar();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null };
-        yield return new object[] { RightToLeft.Yes, new EventArgs() };
-        yield return new object[] { RightToLeft.No, null };
-        yield return new object[] { RightToLeft.No, new EventArgs() };
-        yield return new object[] { RightToLeft.Inherit, null };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_TestData))]
-    public void ProgressBar_OnRightToLeftLayoutChanged_Invoke_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs)
-    {
-        using var control = new SubProgressBar
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_WithHandle_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null, 1 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.Inherit, null, 0 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_WithHandle_TestData))]
-    public void ProgressBar_OnRightToLeftLayoutChanged_InvokeWithHandle_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCreatedCallCount)
-    {
-        using var control = new SubProgressBar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount * 2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_OnRightToLeftLayoutChanged_InvokeInDisposing_DoesNotCallRightToLeftLayoutChanged()
-    {
-        using var control = new SubProgressBar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    public static IEnumerable<object[]> PerformStep_TestData()
-    {
-        foreach (ProgressBarStyle style in new ProgressBarStyle[] { ProgressBarStyle.Blocks, ProgressBarStyle.Continuous })
-        {
-            yield return new object[] { style, 0, 1, 1 };
-            yield return new object[] { style, 0, 100, 100 };
-            yield return new object[] { style, 0, 101, 100 };
-            yield return new object[] { style, 0, 0, 0 };
-            yield return new object[] { style, 0, -1, 0 };
-            yield return new object[] { style, 100, -1, 99 };
-            yield return new object[] { style, 100, -100, 0 };
-            yield return new object[] { style, 100, -101, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformStep_TestData))]
-    public void ProgressBar_PerformStep_Invoke_Success(ProgressBarStyle style, int originalValue, int step, int expectedValue)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style,
-            Value = originalValue,
-            Step = step
-        };
-        control.PerformStep();
-        Assert.Equal(expectedValue, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformStep_TestData))]
-    public void ProgressBar_PerformStep_InvokeWithHandle_Success(ProgressBarStyle style, int originalValue, int step, int expectedValue)
-    {
-        using var control = new ProgressBar
-        {
-            Style = style,
-            Value = originalValue,
-            Step = step
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.PerformStep();
-        Assert.Equal(expectedValue, control.Value);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ProgressBar_PerformStep_Marquee_ThrowsInvalidOperationException(int step)
-    {
-        using var control = new ProgressBar
-        {
-            Style = ProgressBarStyle.Marquee,
-            Step = step
-        };
-        Assert.Throws<InvalidOperationException>(() => control.PerformStep());
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ResetForeColor_Invoke_Success()
-    {
-        using var control = new ProgressBar();
-
-        // Reset without value.
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.Highlight, control.ForeColor);
-
-        // Reset with value.
-        control.ForeColor = Color.Black;
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.Highlight, control.ForeColor);
-
-        // Reset again.
-        control.ResetForeColor();
-        Assert.Equal(SystemColors.Highlight, control.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ProgressBar_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new ProgressBar();
-        Assert.Equal("System.Windows.Forms.ProgressBar, Minimum: 0, Maximum: 100, Value: 0", control.ToString());
-    }
-
-    public class SubProgressBar : ProgressBar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsHandleCreated => base.IsHandleCreated;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnRightToLeftLayoutChanged(EventArgs e) => base.OnRightToLeftLayoutChanged(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGrid.PropertyGridAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGrid.PropertyGridAccessibleObjectTests.cs
deleted file mode 100644
index 4cfb21de877..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGrid.PropertyGridAccessibleObjectTests.cs
+++ /dev/null
@@ -1,223 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Windows.Forms.PropertyGridInternal;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGrid_PropertyGridAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject =
-            new PropertyGrid.PropertyGridAccessibleObject(propertyGrid);
-
-        Assert.NotNull(accessibleObject.Owner);
-        Assert.Equal(propertyGrid, accessibleObject.Owner);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TableItemPatternId)]
-    [InlineData((int)UiaCore.UIA.GridItemPatternId)]
-    public void GridEntryAccessibleObject_SupportsPattern(int pattern)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        GridEntry defaultGridEntry = propertyGrid.GetDefaultGridEntry();
-        GridEntry parentGridEntry = defaultGridEntry.ParentGridEntry; // Category which has item pattern.
-        AccessibleObject accessibleObject = parentGridEntry.AccessibilityObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)pattern));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.GridPatternId)]
-    [InlineData((int)UiaCore.UIA.TablePatternId)]
-    public void PropertyGridAccessibleObject_SupportsPattern(int pattern)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        PropertyGrid.PropertyGridAccessibleObject propertyGridAccessibleObject =
-            new PropertyGrid.PropertyGridAccessibleObject(propertyGrid);
-
-        // First child should be PropertyGrid toolbox.
-        AccessibleObject firstChild = (AccessibleObject)propertyGridAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-
-        // Second child entry should be PropertyGridView.
-        AccessibleObject gridViewChild = (AccessibleObject)firstChild.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-
-        Assert.True(gridViewChild.IsPatternSupported((UiaCore.UIA)pattern));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void PropertyGridAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            propertyGrid.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = propertyGrid.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.Equal(createControl, propertyGrid.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> PropertyGridAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PropertyGridAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void PropertyGridAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.AccessibleRole = role;
-
-        object actual = propertyGrid.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        AccessibleObject expected = propertyGrid.ToolbarAccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfToolbarHidden()
-    {
-        using PropertyGrid propertyGrid = new() { ToolbarVisible = false };
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        AccessibleObject expected = propertyGrid.GridViewAccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        AccessibleObject expected = propertyGrid.HelpPaneAccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfHelpHidden()
-    {
-        using PropertyGrid propertyGrid = new() { HelpVisible = false };
-
-        // Assign an object with commands to make CommandsPane visible
-        using Component component = new();
-        component.Site = new SiteWithMenuCommands();
-        propertyGrid.SelectedObject = component;
-
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        AccessibleObject expected = propertyGrid.CommandsPaneAccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfHelpAndCommandsHidden()
-    {
-        using PropertyGrid propertyGrid = new() { HelpVisible = false, CommandsVisibleIfAvailable = false };
-        PropertyGrid.PropertyGridAccessibleObject accessibleObject = new(propertyGrid);
-
-        AccessibleObject expected = propertyGrid.GridViewAccessibleObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    private class SiteWithMenuCommands : ISite
-    {
-        private class MenuCommandService : IMenuCommandService
-        {
-            public DesignerVerbCollection Verbs { get; } = new DesignerVerbCollection(new[] { new DesignerVerb("", null) });
-
-            public void AddCommand(MenuCommand command) => throw new NotImplementedException();
-
-            public void AddVerb(DesignerVerb verb) => throw new NotImplementedException();
-
-            public MenuCommand FindCommand(CommandID commandID) => throw new NotImplementedException();
-
-            public bool GlobalInvoke(CommandID commandID) => throw new NotImplementedException();
-
-            public void RemoveCommand(MenuCommand command) => throw new NotImplementedException();
-
-            public void RemoveVerb(DesignerVerb verb) => throw new NotImplementedException();
-
-            public void ShowContextMenu(CommandID menuID, int x, int y) => throw new NotImplementedException();
-        }
-
-        public IComponent Component { get; }
-
-        public IContainer Container { get; }
-
-        public bool DesignMode => false;
-
-        public string Name { get; set; }
-
-        public object GetService(Type serviceType)
-        {
-            return serviceType == typeof(IMenuCommandService) ? new MenuCommandService() : null;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/CommandsPane.CommandsPaneAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/CommandsPane.CommandsPaneAccessibleObjectTests.cs
deleted file mode 100644
index b26c2589798..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/CommandsPane.CommandsPaneAccessibleObjectTests.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class CommandsPane_CommandsPaneAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void CommandsPaneAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using CommandsPane commandsPane = new CommandsPane(propertyGrid);
-        CommandsPane.CommandsPaneAccessibleObject accessibleObject =
-            new CommandsPane.CommandsPaneAccessibleObject(commandsPane, propertyGrid);
-
-        Assert.Equal(commandsPane, accessibleObject.Owner);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(commandsPane.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void CommandsPaneAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using CommandsPane commandsPane = new CommandsPane(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        object actual = commandsPane.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(commandsPane.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void CommandsPaneAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using CommandsPane commandsPane = new CommandsPane(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            commandsPane.CreateControl();
-        }
-
-        AccessibleRole actual = commandsPane.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.Equal(createControl, commandsPane.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DetailsButton.DetailsButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DetailsButton.DetailsButtonAccessibleObjectTests.cs
deleted file mode 100644
index bc105cabc40..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DetailsButton.DetailsButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class DetailsButton_DetailsButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DetailsButtonAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using GridErrorDialog gridErrorDlg = new GridErrorDialog(propertyGrid);
-        using DetailsButton detailsButton = new DetailsButton(gridErrorDlg);
-        DetailsButton.DetailsButtonAccessibleObject accessibleObject = new DetailsButton.DetailsButtonAccessibleObject(detailsButton);
-
-        Assert.Equal(detailsButton, accessibleObject.Owner);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(gridErrorDlg.IsHandleCreated);
-        Assert.False(detailsButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DetailsButtonAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using GridErrorDialog gridErrorDlg = new GridErrorDialog(propertyGrid);
-        using DetailsButton detailsButton = new DetailsButton(gridErrorDlg);
-        // AccessibleRole is not set = Default
-
-        object actual = detailsButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(gridErrorDlg.IsHandleCreated);
-        Assert.False(detailsButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.PushButton)]
-    [InlineData(false, AccessibleRole.None)]
-    public void DetailsButtonAccessibleObject_Role_IsPushButton_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using GridErrorDialog gridErrorDlg = new GridErrorDialog(propertyGrid);
-        using DetailsButton detailsButton = new DetailsButton(gridErrorDlg);
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            detailsButton.CreateControl();
-        }
-
-        AccessibleRole actual = detailsButton.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(gridErrorDlg.IsHandleCreated);
-        Assert.Equal(createControl, detailsButton.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs
deleted file mode 100644
index f194dd4950f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/DropDownButton.DropDownButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class DropDownButton_DropDownButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DropDownButtonAccessibleObject_Ctor_Default()
-    {
-        using DropDownButton dropDownButton = new DropDownButton();
-        DropDownButton.DropDownButtonAccessibleObject accessibleObject =
-            new DropDownButton.DropDownButtonAccessibleObject(dropDownButton);
-
-        Assert.Equal(dropDownButton, accessibleObject.Owner);
-        Assert.False(dropDownButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DropDownButtonAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        using DropDownButton dropDownButton = new DropDownButton();
-        // AccessibleRole is not set = Default
-
-        object actual = dropDownButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-        Assert.False(dropDownButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId, true)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.PushButton)]
-    [InlineData((int)UiaCore.UIA.ValueValuePropertyId, null)]
-    public void DomainUpDownAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using DropDownButton dropDownButton = new DropDownButton();
-        AccessibleObject accessibleObject = dropDownButton.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(dropDownButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DropDownButtonAccessibleObject_Role_IsPushButton_ByDefault()
-    {
-        using DropDownButton dropDownButton = new DropDownButton();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = dropDownButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.PushButton, actual);
-        Assert.False(dropDownButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    public void DropDownButtonAccessibleObject_FragmentNavigate_ChildrenAreNull(int direction)
-    {
-        using DropDownButton dropDownButton = new();
-
-        object actual = dropDownButton.AccessibilityObject.FragmentNavigate((UiaCore.NavigateDirection)direction);
-
-        Assert.Null(actual);
-        Assert.False(dropDownButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void DropDownButtonAccessibleObject_FragmentNavigate_ParentIsGridEntry()
-    {
-        using PropertyGrid control = new();
-        using Button button = new();
-        control.SelectedObject = button;
-        control.SelectedGridItem = control.GetCurrentEntries()[1].GridItems[5]; // FlatStyle property
-
-        PropertyGridView gridView = control.TestAccessor().GridView;
-        DropDownButton dropDownButton = gridView.DropDownButton;
-        dropDownButton.Visible = true;
-
-        object actual = dropDownButton.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(gridView.SelectedGridEntry.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(dropDownButton.IsHandleCreated); // Setting Visible property forces Handle creation
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/HelpPane.HelpPaneAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/HelpPane.HelpPaneAccessibleObjectTests.cs
deleted file mode 100644
index 6e13925ea81..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/HelpPane.HelpPaneAccessibleObjectTests.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class HelpPane_HelpPaneAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void HelpPaneAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using HelpPane helpPane = new HelpPane(propertyGrid);
-        HelpPane.HelpPaneAccessibleObject accessibleObject =
-            new HelpPane.HelpPaneAccessibleObject(helpPane, propertyGrid);
-
-        Assert.Equal(helpPane, accessibleObject.Owner);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(helpPane.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void HelpPaneAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using HelpPane helpPane = new HelpPane(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        object actual = helpPane.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(helpPane.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void HelpPaneAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using HelpPane helpPane = new HelpPane(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            helpPane.CreateControl();
-        }
-
-        AccessibleRole actual = helpPane.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.Equal(createControl, helpPane.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertiesTabTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertiesTabTests.cs
deleted file mode 100644
index 6f7855826c5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertiesTabTests.cs
+++ /dev/null
@@ -1,244 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertiesTabTests
-{
-    [Fact]
-    public void PropertiesTab_Ctor_Default()
-    {
-        var tab = new PropertiesTab();
-        Assert.NotNull(tab.Bitmap);
-        Assert.Same(tab.Bitmap, tab.Bitmap);
-        Assert.Null(tab.Components);
-        Assert.Equal("vs.properties", tab.HelpKeyword);
-        Assert.NotEqual(tab.TabName, tab.HelpKeyword);
-        Assert.NotEmpty(tab.TabName);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetDefaultProperty_InvokeWithoutDefaultProperty_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Null(tab.GetDefaultProperty(new ClassWithoutDefaultProperty()));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetDefaultProperty_InvokeWithoutDefaultWithNameProperty_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Equal("Name", tab.GetDefaultProperty(new ClassWithNameProperty()).Name);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetDefaultProperty_InvokeWithDefaultProperty_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Equal("Value", tab.GetDefaultProperty(new ClassWithDefaultProperty()).Name);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetDefaultProperty_InvokeNullGetProperties_ReturnsExpected()
-    {
-        var tab = new NullGetPropertiesPropertiesTab();
-        Assert.Null(tab.GetDefaultProperty(new ClassWithNameProperty()));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetDefaultProperty_InvokeNullComponent_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Null(tab.GetDefaultProperty(null));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObject_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(new ClassWithDefaultProperty());
-        Assert.Equal(2, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeNullObject_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Empty(tab.GetProperties(null));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectNullAttributes_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(new ClassWithDefaultProperty(), null);
-        Assert.Equal(2, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectEmptyAttributes_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(new ClassWithDefaultProperty(), Array.Empty<Attribute>());
-        Assert.Equal(3, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.NotBrowsableProperty)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectCustomAttributes_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(new ClassWithDefaultProperty(), new Attribute[] { new BrowsableAttribute(false) });
-        Assert.Equal(1, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.NotBrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeNullObjectAttributes_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Empty(tab.GetProperties(null, null));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectNullAttributesNullContext_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(null, new ClassWithDefaultProperty(), null);
-        Assert.Equal(2, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectNullAttributesNullPropertyContextPropertiesSupported_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        var mockTypeDescriptorContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockTypeDescriptorContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns((PropertyDescriptor)null)
-            .Verifiable();
-        PropertyDescriptorCollection properties = tab.GetProperties(mockTypeDescriptorContext.Object, new ClassWithDefaultProperty(), null);
-        Assert.Equal(2, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-        mockTypeDescriptorContext.Verify(c => c.PropertyDescriptor, Times.Once());
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectNullAttributesCustomPropertyContext_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        var mockTypeDescriptorContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockTypeDescriptorContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns(TypeDescriptor.GetProperties(typeof(ParentClass))[0])
-            .Verifiable();
-        PropertyDescriptorCollection properties = tab.GetProperties(mockTypeDescriptorContext.Object, new ClassWithDefaultProperty(), null);
-        Assert.Equal(2, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-        mockTypeDescriptorContext.Verify(c => c.PropertyDescriptor, Times.Exactly(2));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectNullAttributesCustomContextCustomTypeConverter_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        var mockTypeDescriptorContext = new Mock<ITypeDescriptorContext>(MockBehavior.Strict);
-        mockTypeDescriptorContext
-            .Setup(c => c.PropertyDescriptor)
-            .Returns(TypeDescriptor.GetProperties(typeof(CustomTypeConverterParentClass))[0])
-            .Verifiable();
-        PropertyDescriptorCollection properties = tab.GetProperties(mockTypeDescriptorContext.Object, new ClassWithDefaultProperty(), null);
-        Assert.Equal(1, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithNameProperty.Name)]);
-        mockTypeDescriptorContext.Verify(c => c.PropertyDescriptor, Times.Exactly(2));
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectEmptyAttributesNullContext_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(null, new ClassWithDefaultProperty(), Array.Empty<Attribute>());
-        Assert.Equal(3, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.Value)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.NotBrowsableProperty)]);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.BrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeObjectCustomAttributesNullContext_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        PropertyDescriptorCollection properties = tab.GetProperties(null, new ClassWithDefaultProperty(), new Attribute[] { new BrowsableAttribute(false) });
-        Assert.Equal(1, properties.Count);
-        Assert.NotNull(properties[nameof(ClassWithDefaultProperty.NotBrowsableProperty)]);
-    }
-
-    [Fact]
-    public void PropertiesTab_GetProperties_InvokeNullObjectAttributesContext_ReturnsExpected()
-    {
-        var tab = new PropertiesTab();
-        Assert.Empty(tab.GetProperties(null, null, null));
-    }
-
-    private class NullGetPropertiesPropertiesTab : PropertiesTab
-    {
-        public override PropertyDescriptorCollection GetProperties(object component) => null;
-    }
-
-    private class ClassWithoutDefaultProperty
-    {
-        public int Value { get; set; }
-    }
-
-    private class ClassWithNameProperty
-    {
-        public int Name { get; set; }
-    }
-
-    [DefaultProperty(nameof(ClassWithDefaultProperty.Value))]
-    private class ClassWithDefaultProperty
-    {
-        public int Value { get; set; }
-
-        [Browsable(false)]
-        public int NotBrowsableProperty { get; set; }
-
-        [Browsable(true)]
-        public int BrowsableProperty { get; set; }
-    }
-
-    private class ParentClass
-    {
-        public ClassWithNameProperty Child { get; set; }
-    }
-
-    private class CustomTypeConverter : TypeConverter
-    {
-        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
-        {
-            return TypeDescriptor.GetProperties(typeof(ClassWithNameProperty));
-        }
-
-        public override bool GetPropertiesSupported(ITypeDescriptorContext context) => true;
-    }
-
-    private class CustomTypeConverterParentClass
-    {
-        [TypeConverter(typeof(CustomTypeConverter))]
-        public ClassWithDefaultProperty Child { get; set; }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs
deleted file mode 100644
index f4eb3e9d95d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyDescriptorGridEntry.PropertyDescriptorGridEntryAccessibleObjectTests.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyDescriptorGridEntryAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_Navigates_to_DropDownControlHolder()
-    {
-        using PropertyGrid propertyGrid = new();
-        using PropertyGridView propertyGridView = new(serviceProvider: null, propertyGrid);
-
-        TestPropertyGridViewAccessibleObject accessibleObject = new(propertyGridView, parentPropertyGrid: null);
-        propertyGridView.Properties.SetObject(propertyGrid.TestAccessor().Dynamic.s_accessibilityProperty, accessibleObject);
-
-        TestPropertyDescriptorGridEntry gridEntry = new(propertyGrid, null, false);
-        propertyGridView.TestAccessor().Dynamic._selectedGridEntry = gridEntry;
-
-        PropertyGridView.DropDownHolder dropDownHolder = new(propertyGridView);
-        dropDownHolder.TestAccessor().Dynamic.SetState(0x00000002, true); // Control class States.Visible flag
-        propertyGridView.TestAccessor().Dynamic._dropDownHolder = dropDownHolder;
-        gridEntry.TestAccessor().Dynamic._parent = new TestGridEntry(propertyGrid, null, propertyGridView);
-
-        UiaCore.IRawElementProviderFragment firstChild = gridEntry.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.NotNull(firstChild);
-        Assert.Equal(typeof(PropertyGridView.DropDownHolder.DropDownHolderAccessibleObject), firstChild.GetType());
-    }
-
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new();
-        TestPropertyDescriptorGridEntry propertyDescriptorGridEntryTestEntity = new(propertyGrid, null, false);
-        AccessibleObject propertyDescriptorGridEntryAccessibleObject = propertyDescriptorGridEntryTestEntity.AccessibilityObject;
-
-        Assert.NotNull(propertyDescriptorGridEntryAccessibleObject);
-
-        GridEntry owningGridEntry = ((IOwnedObject<GridEntry>)propertyDescriptorGridEntryAccessibleObject).Owner;
-
-        Assert.Equal(propertyDescriptorGridEntryTestEntity, owningGridEntry);
-    }
-
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_ExpandCollapseState_collapsed_by_default()
-    {
-        using PropertyGrid propertyGrid = new();
-        TestPropertyDescriptorGridEntry propertyDescriptorGridEntryTestEntity = new(propertyGrid, null, false);
-        AccessibleObject propertyDescriptorGridEntryAccessibleObject = propertyDescriptorGridEntryTestEntity.AccessibilityObject;
-
-        UiaCore.ExpandCollapseState expandCollapseState = propertyDescriptorGridEntryAccessibleObject.ExpandCollapseState;
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, expandCollapseState);
-    }
-
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_ExpandCollapseState_reflects_ExpandablePropertyState()
-    {
-        using PropertyGrid propertyGrid = new();
-        TestEntity testEntity = new();
-        testEntity.SizeProperty = Size.Empty;
-        propertyGrid.SelectedObject = testEntity;
-
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        int firstPropertyIndex = 1; // Index 0 corresponds to the category grid entry.
-        var gridEntry = (PropertyDescriptorGridEntry)propertyGridView.AccessibilityGetGridEntries()[firstPropertyIndex];
-
-        var selectedGridEntry = propertyGridView.TestAccessor().Dynamic._selectedGridEntry as PropertyDescriptorGridEntry;
-        Assert.Equal(gridEntry.PropertyName, selectedGridEntry.PropertyName);
-
-        AccessibleObject selectedGridEntryAccessibleObject = gridEntry.AccessibilityObject;
-
-        gridEntry.InternalExpanded = false;
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, selectedGridEntryAccessibleObject.ExpandCollapseState);
-
-        gridEntry.InternalExpanded = true;
-        Assert.Equal(UiaCore.ExpandCollapseState.Expanded, selectedGridEntryAccessibleObject.ExpandCollapseState);
-    }
-
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_IsPatternSupported_IfExpandCollapsePatternAndEnumerable_ReturnsTrue()
-    {
-        using PropertyGrid propertyGrid = new();
-        using PropertyGridView propertyGridView = new(serviceProvider: null, propertyGrid);
-
-        TestGridEntry parent = new(propertyGrid, peParent: null, propertyGridView);
-        PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(typeof(TestEntity)).
-            Find(nameof(TestEntity.SizeProperty), ignoreCase: false);
-
-        EnumerablePropertyDescriptorGridEntry gridEntry = new(propertyGrid, parent, propertyDescriptor, hide: false);
-        AccessibleObject accessibleObject = gridEntry.AccessibilityObject;
-
-        Assert.True(gridEntry.Enumerable);
-        Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.ExpandCollapsePatternId));
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(propertyGridView.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyDescriptorGridEntryAccessibleObject_IsPatternSupported_IfExpandCollapsePatternAndDropDownEditable_ReturnsTrue()
-    {
-        using PropertyGrid propertyGrid = new();
-        using PropertyGridView propertyGridView = new(serviceProvider: null, propertyGrid);
-
-        TestGridEntry parent = new(propertyGrid, peParent: null, propertyGridView);
-        PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(typeof(TestEntity)).
-            Find(nameof(TestEntity.SizeProperty), ignoreCase: false);
-
-        DropDownEditablePropertyDescriptorGridEntry gridEntry = new(propertyGrid, parent, propertyDescriptor, hide: false);
-        AccessibleObject accessibleObject = gridEntry.AccessibilityObject;
-
-        Assert.True(gridEntry.NeedsDropDownButton);
-        Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.ExpandCollapsePatternId));
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(propertyGridView.IsHandleCreated);
-    }
-
-    private class TestGridEntry : GridEntry
-    {
-        readonly PropertyGridView _propertyGridView;
-
-        public TestGridEntry(PropertyGrid ownerGrid, GridEntry peParent, PropertyGridView propertyGridView)
-            : base(ownerGrid, peParent)
-        {
-            _propertyGridView = propertyGridView;
-        }
-
-        internal override PropertyGridView OwnerGridView => _propertyGridView;
-    }
-
-    private class TestPropertyDescriptorGridEntry : PropertyDescriptorGridEntry
-    {
-        private GridEntryCollection _collection;
-
-        public TestPropertyDescriptorGridEntry(PropertyGrid ownerGrid, GridEntry parent, bool hide)
-            : base(ownerGrid, parent, hide)
-        {
-        }
-
-        public override GridEntryCollection Children
-        {
-            get
-            {
-                _collection ??= new GridEntryCollection();
-
-                return _collection;
-            }
-        }
-
-        internal override bool Enumerable => false;
-    }
-
-    private class TestPropertyGridViewAccessibleObject : PropertyGridView.PropertyGridViewAccessibleObject
-    {
-        public TestPropertyGridViewAccessibleObject(PropertyGridView owner, PropertyGrid parentPropertyGrid)
-            : base(owner, parentPropertyGrid)
-        {
-        }
-    }
-
-    internal class TestEntity
-    {
-        public Size SizeProperty
-        {
-            get; set;
-        }
-    }
-
-    private class EnumerablePropertyDescriptorGridEntry : PropertyDescriptorGridEntry
-    {
-        public EnumerablePropertyDescriptorGridEntry(PropertyGrid ownerGrid, GridEntry parent, PropertyDescriptor propertyDescriptor, bool hide)
-            : base(ownerGrid, parent, propertyDescriptor, hide)
-        {
-        }
-
-        internal override bool Enumerable => true;
-    }
-
-    private class DropDownEditablePropertyDescriptorGridEntry : PropertyDescriptorGridEntry
-    {
-        public DropDownEditablePropertyDescriptorGridEntry(PropertyGrid ownerGrid, GridEntry parent, PropertyDescriptor propertyDescriptor, bool hide)
-            : base(ownerGrid, parent, propertyDescriptor, hide)
-        {
-        }
-
-        public override bool NeedsDropDownButton => true;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs
deleted file mode 100644
index efebc9e1416..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolder.DropDownHolderAccessibleObjectTests.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyGridView_DropDownHolder_DropDownHolderAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void DropDownHolder_AccessibilityObject_Constructor_initializes_fields()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        using PropertyGridView.DropDownHolder dropDownHolderControl = new PropertyGridView.DropDownHolder(propertyGridView);
-        PropertyGridView.DropDownHolder.DropDownHolderAccessibleObject dropDownHolderControlAccessibilityObject =
-            Assert.IsAssignableFrom<PropertyGridView.DropDownHolder.DropDownHolderAccessibleObject>(
-                dropDownHolderControl.AccessibilityObject);
-
-        PropertyGridView.DropDownHolder dropDownHolder =
-            dropDownHolderControlAccessibilityObject.TestAccessor().Dynamic._owningDropDownHolder;
-        Assert.NotNull(dropDownHolder);
-        Assert.Same(dropDownHolder, dropDownHolderControl);
-    }
-
-    [WinFormsFact]
-    public void DropDownHolder_AccessibilityObject_Constructor_throws_error_if_passed_control_is_null()
-    {
-        Assert.Throws<ArgumentNullException>(() =>
-        {
-            var dropDownHolderAccessibleObject = new PropertyGridView.DropDownHolder.DropDownHolderAccessibleObject(null);
-        });
-    }
-
-    [WinFormsFact]
-    public void DropDownHolder_AccessibilityObject_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        using PropertyGridView.DropDownHolder ownerControl = new(propertyGridView);
-        Control.ControlAccessibleObject accessibilityObject = ownerControl.AccessibilityObject as Control.ControlAccessibleObject;
-
-        Assert.Equal(ownerControl, accessibilityObject.Owner);
-        Assert.Equal(SR.PropertyGridViewDropDownControlHolderAccessibleName,
-            accessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId));
-
-        AccessibleObject selectedGridEntryAccessibleObject = null;
-        Assert.Equal(selectedGridEntryAccessibleObject, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[0];
-        PropertyDescriptorGridEntry gridEntry = new PropertyDescriptorGridEntry(propertyGrid, null, property, false);
-        propertyGridView.TestAccessor().Dynamic._selectedGridEntry = gridEntry;
-
-        ownerControl.Visible = true;
-
-        selectedGridEntryAccessibleObject = gridEntry.AccessibilityObject;
-        Assert.Equal(selectedGridEntryAccessibleObject, accessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-
-        Assert.Equal(propertyGridView.AccessibilityObject, accessibilityObject.FragmentRoot);
-    }
-
-    [WinFormsFact]
-    public void DropDownHolderAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        using PropertyGridView.DropDownHolder dropDownControlHolder = new PropertyGridView.DropDownHolder(propertyGridView);
-        // AccessibleRole is not set = Default
-
-        object actual = dropDownControlHolder.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(dropDownControlHolder.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolderTests.cs
deleted file mode 100644
index f1e40d41d87..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.DropDownHolderTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyGridView_DropDownHolderTests
-{
-    [WinFormsFact]
-    public void DropDownHolder_AccessibilityObject_Constructor_initializes_correctly()
-    {
-        using PropertyGridView propertyGridView = new PropertyGridView(null, null);
-        propertyGridView.BackColor = Color.Green;
-        using PropertyGridView.DropDownHolder dropDownHolder = new PropertyGridView.DropDownHolder(propertyGridView);
-
-        Assert.Equal(Color.Green, dropDownHolder.BackColor);
-    }
-
-    [WinFormsFact]
-    public void DropDownHolder_SupportsUiaProviders_returns_true()
-    {
-        using PropertyGridView propertyGridView = new PropertyGridView(null, null);
-        using PropertyGridView.DropDownHolder dropDownHolder = new PropertyGridView.DropDownHolder(propertyGridView);
-        Assert.True(dropDownHolder.SupportsUiaProviders);
-    }
-
-    [WinFormsFact]
-    public void DropDownHolder_CreateAccessibilityObject_creates_DropDownHolderAccessibleObject()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        using PropertyGridView.DropDownHolder dropDownHolder = new PropertyGridView.DropDownHolder(propertyGridView);
-
-        AccessibleObject accessibleObject = dropDownHolder.AccessibilityObject;
-        Assert.Equal("DropDownHolderAccessibleObject", accessibleObject.GetType().Name);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxAccessibleObjectTests.cs
deleted file mode 100644
index c484581c7a7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.Control;
-using static System.Windows.Forms.PropertyGridInternal.PropertyGridView;
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyGridView_GridViewListBoxAccessibleObjectTest
-{
-    [WinFormsFact]
-    public void GridViewListBoxAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        using GridViewListBox gridViewListBox = new GridViewListBox(propertyGridView);
-
-        Type type = gridViewListBox.AccessibilityObject.GetType();
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)Activator.CreateInstance(type, gridViewListBox);
-
-        Assert.Equal(gridViewListBox, accessibleObject.Owner);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(gridViewListBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GridViewListBoxAccessibleObject_ControlType_IsList_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = propertyGridView.DropDownListBoxAccessibleObject;
-        // AccessibleRole is not set = Default
-
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ListControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.List)]
-    [InlineData(false, AccessibleRole.None)]
-    public void GridViewListBoxAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        using GridViewListBox gridViewListBox = new GridViewListBox(propertyGridView);
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            gridViewListBox.CreateControl();
-        }
-
-        AccessibleRole actual = gridViewListBox.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.Equal(createControl, gridViewListBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxTests.cs
deleted file mode 100644
index b8ce7aa0e93..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewListBoxTests.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyGridView_GridViewListBoxTests
-{
-    [WinFormsFact]
-    public void GridViewListBoxAccessibleObject_checks_arguments()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid
-        {
-            SelectedObject = Size.Empty
-        };
-        propertyGrid.CreateControl();
-
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        using PropertyGridView.GridViewListBox gridViewListBox = new PropertyGridView.GridViewListBox(propertyGridView);
-        AccessibleObject gridViewListBoxAccessibleObject = gridViewListBox.AccessibilityObject;
-        Assert.NotNull(gridViewListBoxAccessibleObject);
-
-        Assert.Throws<ArgumentNullException>(() =>
-        {
-            Type gridViewListBoxAccessibleObjectType = gridViewListBoxAccessibleObject.GetType();
-            Assert.Equal("GridViewListBoxAccessibleObject", gridViewListBoxAccessibleObjectType.Name);
-            ConstructorInfo constructorInfo = gridViewListBoxAccessibleObjectType.GetConstructors()[0];
-
-            using PropertyGridView.GridViewListBox owningGridViewListBox = new PropertyGridView.GridViewListBox(null);
-            constructorInfo.Invoke(new object[] { owningGridViewListBox });
-        });
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs
deleted file mode 100644
index b93bb35a117..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridView.GridViewTextBox.GridViewTextBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,215 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using static System.Windows.Forms.Control;
-using static Interop;
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public class PropertyGridView_GridViewTextBox_GridViewTextBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_created_for_string_property()
-    {
-        TestEntityWithTextField testEntity = new TestEntityWithTextField
-        {
-            TextProperty = "Test"
-        };
-
-        using PropertyGrid propertyGrid = new PropertyGrid
-        {
-            SelectedObject = testEntity
-        };
-
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        int firstPropertyIndex = 1; // Index 0 corresponds to the category grid entry.
-        PropertyDescriptorGridEntry gridEntry = (PropertyDescriptorGridEntry)propertyGridView.AccessibilityGetGridEntries()[firstPropertyIndex];
-        PropertyDescriptorGridEntry selectedGridEntry = propertyGridView.TestAccessor().Dynamic._selectedGridEntry;
-
-        Assert.Equal(gridEntry.PropertyName, selectedGridEntry.PropertyName);
-        // Force the entry edit control Handle creation.
-        // GridViewEditAccessibleObject exists, if its control is already created.
-        // In UI case an entry edit control is created when an PropertyGridView gets focus.
-        Assert.NotEqual(IntPtr.Zero, propertyGridView.TestAccessor().Dynamic.EditTextBox.Handle);
-
-        AccessibleObject selectedGridEntryAccessibleObject = gridEntry.AccessibilityObject;
-        UiaCore.IRawElementProviderFragment editFieldAccessibleObject = selectedGridEntryAccessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.NotNull(editFieldAccessibleObject);
-
-        Assert.Equal("GridViewTextBoxAccessibleObject", editFieldAccessibleObject.GetType().Name);
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_FragmentNavigate_navigates_correctly()
-    {
-        using PropertyGrid propertyGrid = new()
-        {
-            SelectedObject = Point.Empty
-        };
-
-        propertyGrid.CreateControl();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        int firstPropertyIndex = 2; // Index of Text property which has a RichEdit control as an editor.
-        PropertyDescriptorGridEntry gridEntry = (PropertyDescriptorGridEntry)propertyGridView.AccessibilityGetGridEntries()[firstPropertyIndex];
-
-        propertyGridView.TestAccessor().Dynamic._selectedGridEntry = gridEntry;
-
-        // Force the entry edit control Handle creation.
-        // GridViewEditAccessibleObject exists, if its control is already created.
-        // In UI case an entry edit control is created when an PropertyGridView gets focus.
-        Assert.NotEqual(IntPtr.Zero, propertyGridView.TestAccessor().Dynamic.EditTextBox.Handle);
-
-        UiaCore.IRawElementProviderFragment editFieldAccessibleObject = gridEntry.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.Equal("GridViewTextBoxAccessibleObject", editFieldAccessibleObject.GetType().Name);
-
-        // The case with drop down holder:
-        using PropertyGridView.DropDownHolder dropDownHolder = new(propertyGridView);
-        dropDownHolder.CreateControl();
-        propertyGridView.TestAccessor().Dynamic._dropDownHolder = dropDownHolder;
-
-        dropDownHolder.TestAccessor().Dynamic.SetState(0x00000002, true); // Control class States.Visible flag
-        UiaCore.IRawElementProviderFragment dropDownHolderAccessibleObject = gridEntry.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-
-        Assert.Equal("DropDownHolderAccessibleObject", dropDownHolderAccessibleObject.GetType().Name);
-        Assert.True(propertyGridView.DropDownVisible);
-        object previousAccessibleObject = editFieldAccessibleObject.Navigate(UiaCore.NavigateDirection.PreviousSibling);
-        Assert.NotNull(previousAccessibleObject);
-        Assert.Same(dropDownHolder.AccessibilityObject, previousAccessibleObject);
-    }
-
-    public class TestEntityWithTextField
-    {
-        public string TextProperty { get; set; }
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_ctor_default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        Type gridViewTextBoxType = typeof(PropertyGridView).GetNestedType("GridViewTextBox", BindingFlags.NonPublic);
-        Assert.NotNull(gridViewTextBoxType);
-        TextBox gridViewTextBox = (TextBox)Activator.CreateInstance(gridViewTextBoxType, gridView);
-        Type accessibleObjectType = gridViewTextBoxType.GetNestedType("GridViewTextBoxAccessibleObject", BindingFlags.NonPublic);
-        Assert.NotNull(accessibleObjectType);
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)Activator.CreateInstance(accessibleObjectType, gridViewTextBox);
-        Assert.Equal(gridViewTextBox, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_ctor_ThrowsException_IfOwnerIsNull()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        Type gridViewTextBoxType = typeof(PropertyGridView).GetNestedType("GridViewTextBox", BindingFlags.NonPublic);
-        Assert.NotNull(gridViewTextBoxType);
-        TextBox gridViewTextBox = (TextBox)Activator.CreateInstance(gridViewTextBoxType, gridView);
-        Type accessibleObjectType = gridViewTextBoxType.GetNestedType("GridViewTextBoxAccessibleObject", BindingFlags.NonPublic);
-        Assert.NotNull(accessibleObjectType);
-        Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(accessibleObjectType, (TextBox)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsValuePatternAvailablePropertyId)]
-    public void GridViewTextBoxAccessibleObject_GetPropertyValue_PatternsSuported(int propertyID)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = gridView.EditAccessibleObject;
-        Assert.True((bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyID));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    [InlineData((int)UiaCore.UIA.TextPatternId)]
-    [InlineData((int)UiaCore.UIA.TextPattern2Id)]
-    public void GridViewTextBoxAccessibleObject_IsPatternSupported_PatternsSuported(int patternId)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = gridView.EditAccessibleObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_ControlType_IsEdit_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = gridView.EditAccessibleObject;
-
-        // AccessibleRole is not set = Default
-
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.EditControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_GetPropertyValue_FrameworkIdPropertyId_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = gridView.EditAccessibleObject;
-
-        Assert.Equal("WinForm", accessibleObject.GetPropertyValue(UiaCore.UIA.FrameworkIdPropertyId));
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text)]
-    [InlineData(false, AccessibleRole.None)]
-    public void GridViewTextBoxAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            gridView.TestAccessor().Dynamic.EditTextBox.CreateControl(true); // "true" means ignoring Visible value
-        }
-
-        AccessibleRole actual = gridView.EditAccessibleObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_RuntimeId_ReturnsNull()
-    {
-        using PropertyGrid propertyGrid = new() { SelectedObject = new TestEntityWithTextField() { TextProperty = "Test" } };
-
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-        int firstPropertyIndex = 1; // Index 0 corresponds to the category grid entry.
-        PropertyDescriptorGridEntry gridEntry = (PropertyDescriptorGridEntry)propertyGridView.AccessibilityGetGridEntries()[firstPropertyIndex];
-
-        // Force the entry edit control Handle creation.
-        // GridViewEditAccessibleObject exists, if its control is already created.
-        // In UI case an entry edit control is created when an PropertyGridView gets focus.
-        Assert.NotEqual(IntPtr.Zero, propertyGridView.TestAccessor().Dynamic.EditTextBox.Handle);
-
-        AccessibleObject editFieldAccessibleObject = (AccessibleObject)gridEntry.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        propertyGridView.TestAccessor().Dynamic._selectedGridEntry = null;
-
-        Assert.NotNull(editFieldAccessibleObject.RuntimeId);
-    }
-
-    [WinFormsFact]
-    public void GridViewTextBoxAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        PropertyGridView gridView = propertyGrid.TestAccessor().GridView;
-        AccessibleObject accessibleObject = gridView.EditAccessibleObject;
-
-        Assert.Equal(propertyGrid.AccessibilityObject, accessibleObject.FragmentRoot);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.Rendering.cs
deleted file mode 100644
index 6a626bcd212..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.Rendering.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-using System.Windows.Forms.PropertyGridInternal;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class PropertyGridViewTests
-{
-    [WinFormsFact]
-    public void PropertyGridView_Render_Labels_Values_Correctly()
-    {
-        Point pt = default;
-        using PropertyGrid propertyGrid = new()
-        {
-            SelectedObject = pt,
-            Size = new(300, 200),
-            Visible = true
-        };
-
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        // For us to be able to render PropertyGridView and its values
-        // PropertyGrid must be visible and have a valid handle.
-        // To be Visible is must either be visible (we don't want this in tests) or
-        // have no parent - so we can't add it to another control (such as a form).
-        propertyGrid.CreateControl();
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new(emf);
-
-        propertyGridView.PrintToMetafile(emf);
-
-        // Only care about text: labels and values
-        emf.Validate(
-            state,
-
-            // Category: Misc
-            Validate.SkipTo(
-                Validate.TextOut("Misc", new(25, 4, 25, 14), stateValidators: State.FontFace(Control.DefaultFont.Name))),
-
-            // Value for "X"
-            Validate.SkipTo(
-                Validate.TextOut(" ", new(145, 22, 5, 14))), // blank??
-            Validate.SkipTo(
-                Validate.TextOut(pt.X.ToString(), new(145, 22, 5, 14), stateValidators: State.FontFace(Control.DefaultFont.Name))),
-            // Label for "X"
-            Validate.SkipTo(
-                Validate.TextOut(nameof(Point.X), new(25, 23, 6, 14), stateValidators: State.FontFace(Control.DefaultFont.Name))),
-
-            // Value for "Y"
-            Validate.SkipTo(
-                Validate.TextOut(" ", new(145, 41, 5, 14))), // blank??
-            Validate.SkipTo(
-                Validate.TextOut(pt.Y.ToString(), new(145, 41, 5, 14), stateValidators: State.FontFace(Control.DefaultFont.Name))),
-            // Label for "Y"
-            Validate.SkipTo(
-                Validate.TextOut(nameof(Point.Y), new(25, 42, 6, 14), stateValidators: State.FontFace(Control.DefaultFont.Name))),
-
-           Validate.SkipAll());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.cs
deleted file mode 100644
index 14e6b9873fc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/PropertyGridViewTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.PropertyGridInternal.Tests;
-
-public partial class PropertyGridViewTests
-{
-    [WinFormsFact]
-    public void PropertyGridView_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new();
-        PropertyGridView propertyGridView = propertyGrid.TestAccessor().GridView;
-
-        // TODO: validate properties
-
-        Assert.NotNull(propertyGridView);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridTestAccessor.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridTestAccessor.cs
deleted file mode 100644
index 7a982081fe9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridTestAccessor.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public static partial class TestAccessors
-{
-    public class PropertyGridTestAccessor : TestAccessor<Windows.Forms.PropertyGrid>
-    {
-        public PropertyGridTestAccessor(Windows.Forms.PropertyGrid instance) : base(instance) { }
-
-        internal Windows.Forms.PropertyGridInternal.PropertyGridView GridView => Dynamic._gridView;
-
-        internal void SaveSelectedTabIndex() { Dynamic.SaveSelectedTabIndex(); }
-
-        internal bool TryGetSavedTabIndex(out int selectedTabIndex) { return Dynamic.TryGetSavedTabIndex(out selectedTabIndex); }
-
-        internal Dictionary<int, int> _designerSelections => Dynamic._designerSelections;
-    }
-
-    public static PropertyGridTestAccessor TestAccessor(this Windows.Forms.PropertyGrid propertyGrid)
-        => new(propertyGrid);
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridViewTestAccessor.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridViewTestAccessor.cs
deleted file mode 100644
index e44933a78f8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridInternal/TestAccessors.PropertyGridViewTestAccessor.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public static partial class TestAccessors
-{
-    internal class PropertyGridViewTestAccessor : TestAccessor<Windows.Forms.PropertyGridInternal.PropertyGridView>
-    {
-        public PropertyGridViewTestAccessor(Windows.Forms.PropertyGridInternal.PropertyGridView instance) : base(instance) { }
-
-        internal Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry SelectedGridEntry
-        {
-            get => Dynamic.selectedGridEntry;
-            set => Dynamic.selectedGridEntry = value;
-        }
-    }
-
-    internal static PropertyGridViewTestAccessor TestAccessor(this Windows.Forms.PropertyGridInternal.PropertyGridView propertyGridView)
-        => new(propertyGridView);
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridTests.cs
deleted file mode 100644
index 89620c4c5ff..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridTests.cs
+++ /dev/null
@@ -1,4156 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Drawing.Design;
-using System.Runtime.CompilerServices;
-using System.Windows.Forms.PropertyGridInternal;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-using System.Windows.Forms.Design;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class PropertyGridTests
-{
-    [WinFormsFact]
-    public void PropertyGrid_Ctor_Default()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.NotNull(control.ActiveControl);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        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(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(130, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 130, 130), control.Bounds);
-        Assert.True(((BrowsableAttribute)Assert.Single(control.BrowsableAttributes)).Browsable);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.CanShowCommands);
-        Assert.True(control.CanShowVisualStyleGlyphs);
-        Assert.False(control.Capture);
-        Assert.Equal(SystemColors.ControlText, control.CategoryForeColor);
-        Assert.Equal(SystemColors.Control, control.CategorySplitterColor);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 130, 130), control.ClientRectangle);
-        Assert.Equal(new Size(130, 130), control.ClientSize);
-        Assert.Equal(Color.Red, control.CommandsActiveLinkColor);
-        Assert.Equal(SystemColors.Control, control.CommandsBackColor);
-        Assert.Equal(SystemColors.ControlDark, control.CommandsBorderColor);
-        Assert.Equal(Color.FromArgb(255, 133, 133, 133), control.CommandsDisabledLinkColor);
-        Assert.Equal(SystemColors.ControlText, control.CommandsForeColor);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 255), control.CommandsLinkColor);
-        Assert.False(control.CommandsVisible);
-        Assert.True(control.CommandsVisibleIfAvailable);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.NotEqual(Point.Empty, control.ContextMenuDefaultLocation);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Equal(4, control.Controls.Count);
-        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(130, 130), control.DefaultSize);
-        Assert.Equal(typeof(PropertiesTab), control.DefaultTabType);
-        Assert.False(control.DesignMode);
-        Assert.Equal(SystemColors.GrayText, control.DisabledItemForeColor);
-        Assert.Equal(new Rectangle(0, 0, 130, 130), control.DisplayRectangle);
-        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.False(control.DrawFlatToolbar);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.True(control.HasChildren);
-        Assert.Equal(130, control.Height);
-        Assert.Equal(SystemColors.Control, control.HelpBackColor);
-        Assert.Equal(SystemColors.ControlText, control.HelpForeColor);
-        Assert.Equal(SystemColors.ControlDark, control.HelpBorderColor);
-        Assert.True(control.HelpVisible);
-        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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.False(control.LargeButtons);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(SystemColors.InactiveBorder, control.LineColor);
-        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.NotEqual(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.NotEmpty(control.PropertyTabs);
-        Assert.NotSame(control.PropertyTabs, control.PropertyTabs);
-        Assert.Equal(PropertySort.Categorized | PropertySort.Alphabetical, control.PropertySort);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(130, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Null(control.SelectedGridItem);
-        Assert.Equal(SystemColors.Highlight, control.SelectedItemWithFocusBackColor);
-        Assert.Equal(SystemColors.HighlightText, control.SelectedItemWithFocusForeColor);
-        Assert.Null(control.SelectedObject);
-        Assert.Empty(control.SelectedObjects);
-        Assert.Same(control.SelectedObjects, control.SelectedObjects);
-        Assert.IsType<PropertiesTab>(control.SelectedTab);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(130, 130), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.True(control.ToolbarVisible);
-        Assert.NotNull(control.ToolStripRenderer);
-        Assert.Same(control.ToolStripRenderer, control.ToolStripRenderer);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.Equal(SystemColors.Window, control.ViewBackColor);
-        Assert.Equal(SystemColors.ControlDark, control.ViewBorderColor);
-        Assert.Equal(SystemColors.WindowText, control.ViewForeColor);
-        Assert.False(control.VScroll);
-        Assert.Equal(130, control.Width);
-
-        PropertyGridView propertyGridView = control.TestAccessor().GridView;
-        Assert.NotNull(propertyGridView);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubPropertyGrid();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(130, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(130, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void PropertyGrid_AutoScroll_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubPropertyGrid();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void PropertyGrid_AutoScroll_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubPropertyGrid.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, control.Controls.OfType<ToolStrip>().Single().BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, control.Controls.OfType<ToolStrip>().Single().BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void PropertyGrid_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, control.Controls.OfType<ToolStrip>().Single().BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expected, control.Controls.OfType<ToolStrip>().Single().BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.BackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.BackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void PropertyGrid_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new PropertyGrid
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void PropertyGrid_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new PropertyGrid
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void PropertyGrid_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new PropertyGrid();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    public static IEnumerable<object[]> BrowsableAttributes_Set_TestData()
-    {
-        yield return new object[] { null, new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes }) };
-        yield return new object[] { AttributeCollection.Empty, new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes }) };
-        yield return new object[] { new AttributeCollection(), new AttributeCollection() };
-        yield return new object[] { new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes }), new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes }) };
-        yield return new object[] { new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes, ReadOnlyAttribute.Yes }), new AttributeCollection(new Attribute[] { BrowsableAttribute.Yes, ReadOnlyAttribute.Yes }) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BrowsableAttributes_Set_TestData))]
-    public void PropertyGrid_BrowsableAttributes_Set_GetReturnsExpected(AttributeCollection value, AttributeCollection expected)
-    {
-        using var control = new PropertyGrid
-        {
-            BrowsableAttributes = value
-        };
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BrowsableAttributes = value;
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BrowsableAttributes_Set_TestData))]
-    public void PropertyGrid_BrowsableAttributes_SetEmptySelectedObjects_GetReturnsExpected(AttributeCollection value, AttributeCollection expected)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedObjects = Array.Empty<object>(),
-            BrowsableAttributes = value
-        };
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BrowsableAttributes = value;
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BrowsableAttributes_Set_TestData))]
-    public void PropertyGrid_BrowsableAttributes_SetCustomSelectedObjects_GetReturnsExpected(AttributeCollection value, AttributeCollection expected)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedObjects = new object[] { 1 },
-            BrowsableAttributes = value
-        };
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BrowsableAttributes = value;
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BrowsableAttributes_Set_TestData))]
-    public void PropertyGrid_BrowsableAttributes_SetWithHandle_GetReturnsExpected(AttributeCollection value, AttributeCollection expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BrowsableAttributes = value;
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BrowsableAttributes = value;
-        Assert.Equal(expected, control.BrowsableAttributes);
-        Assert.NotSame(value, control.BrowsableAttributes);
-        Assert.Same(control.BrowsableAttributes, control.BrowsableAttributes);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PropertyGrid_CanShowVisualStyleGlyphs_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubPropertyGrid
-        {
-            CanShowVisualStyleGlyphs = value
-        };
-        Assert.Equal(value, control.CanShowVisualStyleGlyphs);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CanShowVisualStyleGlyphs = value;
-        Assert.Equal(value, control.CanShowVisualStyleGlyphs);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CanShowVisualStyleGlyphs = !value;
-        Assert.Equal(!value, control.CanShowVisualStyleGlyphs);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PropertyGrid_CanShowVisualStyleGlyphs_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CanShowVisualStyleGlyphs = value;
-        Assert.Equal(value, control.CanShowVisualStyleGlyphs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CanShowVisualStyleGlyphs = value;
-        Assert.Equal(value, control.CanShowVisualStyleGlyphs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.CanShowVisualStyleGlyphs = !value;
-        Assert.Equal(!value, control.CanShowVisualStyleGlyphs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CategoryForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CategoryForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            CategoryForeColor = value
-        };
-        Assert.Equal(value, control.CategoryForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CategoryForeColor = value;
-        Assert.Equal(value, control.CategoryForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CategoryForeColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CategoryForeColor = value;
-        Assert.Equal(value, control.CategoryForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CategoryForeColor = value;
-        Assert.Equal(value, control.CategoryForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CategoryForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CategoryForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CategoryForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.CategoryForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.CategoryForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CategoryForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CategoryForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CategoryForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.CategoryForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.CategoryForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CategorySplitterColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            CategorySplitterColor = value
-        };
-        Assert.Equal(value, control.CategorySplitterColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CategorySplitterColor = value;
-        Assert.Equal(value, control.CategorySplitterColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CategorySplitterColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CategorySplitterColor = value;
-        Assert.Equal(value, control.CategorySplitterColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CategorySplitterColor = value;
-        Assert.Equal(value, control.CategorySplitterColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CategorySplitterColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CategorySplitterColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CategorySplitterColor = Color.Red;
-        Assert.Equal(Color.Red, control.CategorySplitterColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.CategorySplitterColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CategorySplitterColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CategorySplitterColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CategorySplitterColor = Color.Red;
-        Assert.Equal(Color.Red, control.CategorySplitterColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.CategorySplitterColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> CommandsActiveLinkColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Red };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Blue, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsActiveLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsActiveLinkColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsActiveLinkColor = value
-        };
-        Assert.Equal(expected, control.CommandsActiveLinkColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsActiveLinkColor = value;
-        Assert.Equal(expected, control.CommandsActiveLinkColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsActiveLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsActiveLinkColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsActiveLinkColor = value;
-        Assert.Equal(expected, control.CommandsActiveLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsActiveLinkColor = value;
-        Assert.Equal(expected, control.CommandsActiveLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsActiveLinkColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsActiveLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsActiveLinkColor = Color.Black;
-        Assert.Equal(Color.Black, control.CommandsActiveLinkColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.Red, control.CommandsActiveLinkColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsActiveLinkColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsActiveLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsActiveLinkColor = Color.Black;
-        Assert.Equal(Color.Black, control.CommandsActiveLinkColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.Red, control.CommandsActiveLinkColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_CommandsBackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsBackColor = value
-        };
-        Assert.Equal(expected, control.CommandsBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsBackColor = value;
-        Assert.Equal(expected, control.CommandsBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_CommandsBackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsBackColor = value;
-        Assert.Equal(expected, control.CommandsBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsBackColor = value;
-        Assert.Equal(expected, control.CommandsBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsBackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsBackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.CommandsBackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsBackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsBackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.CommandsBackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BackColor_SetTransparent_ThrowsArgmentException()
-    {
-        using var control = new PropertyGrid();
-        Assert.Throws<ArgumentException>(() => control.CommandsBackColor = Color.FromArgb(254, 1, 2, 3));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CommandsBorderColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsBorderColor = value
-        };
-        Assert.Equal(value, control.CommandsBorderColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsBorderColor = value;
-        Assert.Equal(value, control.CommandsBorderColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_CommandsBorderColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsBorderColor = value;
-        Assert.Equal(value, control.CommandsBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsBorderColor = value;
-        Assert.Equal(value, control.CommandsBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsBorderColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsBorderColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.CommandsBorderColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsBorderColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsBorderColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.CommandsBorderColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> CommandsDisabledLinkColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.FromArgb(255, 133, 133, 133) };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Blue, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsDisabledLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsDisabledLinkColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsDisabledLinkColor = value
-        };
-        Assert.Equal(expected, control.CommandsDisabledLinkColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsDisabledLinkColor = value;
-        Assert.Equal(expected, control.CommandsDisabledLinkColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsDisabledLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsDisabledLinkColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsDisabledLinkColor = value;
-        Assert.Equal(expected, control.CommandsDisabledLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsDisabledLinkColor = value;
-        Assert.Equal(expected, control.CommandsDisabledLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsDisabledLinkColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsDisabledLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsDisabledLinkColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsDisabledLinkColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.FromArgb(255, 133, 133, 133), control.CommandsDisabledLinkColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsDisabledLinkColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsDisabledLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsDisabledLinkColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsDisabledLinkColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.FromArgb(255, 133, 133, 133), control.CommandsDisabledLinkColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PropertyGrid_CommandsForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsForeColor = value
-        };
-        Assert.Equal(expected, control.CommandsForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsForeColor = value;
-        Assert.Equal(expected, control.CommandsForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PropertyGrid_CommandsForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsForeColor = value;
-        Assert.Equal(expected, control.CommandsForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsForeColor = value;
-        Assert.Equal(expected, control.CommandsForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.CommandsForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.CommandsForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> CommandsLinkColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.FromArgb(255, 0, 0, 255) };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Blue, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsLinkColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            CommandsLinkColor = value
-        };
-        Assert.Equal(expected, control.CommandsLinkColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsLinkColor = value;
-        Assert.Equal(expected, control.CommandsLinkColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CommandsLinkColor_Set_TestData))]
-    public void PropertyGrid_CommandsLinkColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsLinkColor = value;
-        Assert.Equal(expected, control.CommandsLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsLinkColor = value;
-        Assert.Equal(expected, control.CommandsLinkColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsLinkColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.CommandsLinkColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsLinkColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 255), control.CommandsLinkColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_CommandsLinkColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.CommandsLinkColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.CommandsLinkColor = Color.Red;
-        Assert.Equal(Color.Red, control.CommandsLinkColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 255), control.CommandsLinkColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void PropertyGrid_CommandsVisibleIfAvailable_Set_GetReturnsExpected(bool visible, bool value)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CommandsVisibleIfAvailable = value;
-        Assert.Equal(value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CommandsVisibleIfAvailable = value;
-        Assert.Equal(value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CommandsVisibleIfAvailable = !value;
-        Assert.Equal(!value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 7)]
-    [InlineData(true, false, 7)]
-    [InlineData(false, true, 0)]
-    [InlineData(false, false, 0)]
-    public void PropertyGrid_CommandsVisibleIfAvailable_SetWithHandle_GetReturnsExpected(bool visible, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.CommandsVisibleIfAvailable = value;
-        Assert.Equal(value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CommandsVisibleIfAvailable = value;
-        Assert.Equal(value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.CommandsVisibleIfAvailable = !value;
-        Assert.Equal(!value, control.CommandsVisibleIfAvailable);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_DisabledItemForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            DisabledItemForeColor = value
-        };
-        Assert.Equal(value, control.DisabledItemForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DisabledItemForeColor = value;
-        Assert.Equal(value, control.DisabledItemForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_DisabledItemForeColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DisabledItemForeColor = value;
-        Assert.Equal(value, control.DisabledItemForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DisabledItemForeColor = value;
-        Assert.Equal(value, control.DisabledItemForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_DisabledItemForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.DisabledItemForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.DisabledItemForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.DisabledItemForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.GrayText, control.DisabledItemForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_DisabledItemForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.DisabledItemForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.DisabledItemForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.DisabledItemForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.GrayText, control.DisabledItemForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PropertyGrid_DrawFlatToolbar_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubPropertyGrid
-        {
-            DrawFlatToolbar = value
-        };
-        Assert.Equal(value, control.DrawFlatToolbar);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DrawFlatToolbar = value;
-        Assert.Equal(value, control.DrawFlatToolbar);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DrawFlatToolbar = !value;
-        Assert.Equal(!value, control.DrawFlatToolbar);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_DrawFlatToolbar_SetWithCommandColors_GetReturnsExpected()
-    {
-        using var control = new SubPropertyGrid
-        {
-            CommandsBackColor = Color.FromArgb(255, 0, 0, 1),
-            CommandsForeColor = Color.FromArgb(255, 0, 0, 2),
-            CommandsLinkColor = Color.FromArgb(255, 0, 0, 3),
-            CommandsActiveLinkColor = Color.FromArgb(255, 0, 0, 4),
-            CommandsDisabledLinkColor = Color.FromArgb(255, 0, 0, 5)
-        };
-
-        // Set true.
-        control.DrawFlatToolbar = true;
-        Assert.True(control.DrawFlatToolbar);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 1), control.CommandsBackColor);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 2), control.CommandsForeColor);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 255), control.CommandsLinkColor);
-        Assert.Equal(Color.Red, control.CommandsActiveLinkColor);
-        Assert.Equal(Color.FromArgb(255, 133, 133, 133), control.CommandsDisabledLinkColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set false.
-        control.DrawFlatToolbar = false;
-        Assert.False(control.DrawFlatToolbar);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 1), control.CommandsBackColor);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 2), control.CommandsForeColor);
-        Assert.Equal(Color.FromArgb(255, 0, 0, 255), control.CommandsLinkColor);
-        Assert.Equal(Color.Red, control.CommandsActiveLinkColor);
-        Assert.Equal(Color.FromArgb(255, 133, 133, 133), control.CommandsDisabledLinkColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void PropertyGrid_DrawFlatToolbar_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DrawFlatToolbar = value;
-        Assert.Equal(value, control.DrawFlatToolbar);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DrawFlatToolbar = value;
-        Assert.Equal(value, control.DrawFlatToolbar);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DrawFlatToolbar = !value;
-        Assert.Equal(!value, control.DrawFlatToolbar);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PropertyGrid_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.Empty, Control.DefaultForeColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void PropertyGrid_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(PropertyGrid.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_HelpBackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            HelpBackColor = value
-        };
-        Assert.Equal(expected, control.HelpBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HelpBackColor = value;
-        Assert.Equal(expected, control.HelpBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_HelpBackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HelpBackColor = value;
-        Assert.Equal(expected, control.HelpBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HelpBackColor = value;
-        Assert.Equal(expected, control.HelpBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpBackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.HelpBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpBackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.HelpBackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpBackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.HelpBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpBackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Control, control.HelpBackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpBackColor_SetTransparent_ThrowsArgmentException()
-    {
-        using var control = new PropertyGrid();
-        Assert.Throws<ArgumentException>(() => control.HelpBackColor = Color.FromArgb(254, 1, 2, 3));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_HelpBorderColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            HelpBorderColor = value
-        };
-        Assert.Equal(value, control.HelpBorderColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HelpBorderColor = value;
-        Assert.Equal(value, control.HelpBorderColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_HelpBorderColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HelpBorderColor = value;
-        Assert.Equal(value, control.HelpBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HelpBorderColor = value;
-        Assert.Equal(value, control.HelpBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpBorderColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.HelpBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpBorderColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.HelpBorderColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpBorderColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.HelpBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpBorderColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.HelpBorderColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PropertyGrid_HelpForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            HelpForeColor = value
-        };
-        Assert.Equal(expected, control.HelpForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HelpForeColor = value;
-        Assert.Equal(expected, control.HelpForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void PropertyGrid_HelpForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HelpForeColor = value;
-        Assert.Equal(expected, control.HelpForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HelpForeColor = value;
-        Assert.Equal(expected, control.HelpForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.HelpForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.HelpForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_HelpForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.HelpForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.HelpForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.HelpForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlText, control.HelpForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 0, 1)]
-    [InlineData(true, false, 1, 1, 2)]
-    [InlineData(false, true, 1, 2, 2)]
-    [InlineData(false, false, 0, 0, 1)]
-    public void PropertyGrid_HelpVisible_Set_GetReturnsExpected(bool visible, bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2, int expectedLayoutCallCount3)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.HelpVisible = value;
-        Assert.Equal(value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HelpVisible = value;
-        Assert.Equal(value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HelpVisible = !value;
-        Assert.Equal(!value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount3, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 7, 2, 7, 10)]
-    [InlineData(true, false, 10, 2, 10, 13)]
-    [InlineData(false, true, 1, 1, 2, 2)]
-    [InlineData(false, false, 0, 1, 0, 1)]
-    public void PropertyGrid_HelpVisible_SetWithHandle_GetReturnsExpected(
-        bool visible,
-        bool value,
-        int expectedLayoutCallCount1,
-        int expectedInvalidatedCallCount,
-        int expectedLayoutCallCount2,
-        int expectedLayoutCallCount3)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HelpVisible = value;
-        Assert.Equal(value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HelpVisible = value;
-        Assert.Equal(value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.HelpVisible = !value;
-        Assert.Equal(!value, control.HelpVisible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount3, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void PropertyGrid_LargeButtons_Set_GetReturnsExpected(bool visible, bool value)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.LargeButtons = value;
-        Assert.Equal(value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LargeButtons = value;
-        Assert.Equal(value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.LargeButtons = !value;
-        Assert.Equal(!value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 12, 2, 17, 4)]
-    [InlineData(true, false, 7, 0, 12, 2)]
-    [InlineData(false, true, 0, 1, 0, 2)]
-    [InlineData(false, false, 0, 0, 0, 1)]
-    public void PropertyGrid_LargeButtons_SetWithHandle_GetReturnsExpected(bool visible, bool value, int expectedLayoutCallCount1, int expectedInvalidatedCallCount1, int expectedLayoutCallCount2, int expectedInvalidatedCallCount2)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LargeButtons = value;
-        Assert.Equal(value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LargeButtons = value;
-        Assert.Equal(value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.LargeButtons = !value;
-        Assert.Equal(!value, control.LargeButtons);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_LineColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            LineColor = value
-        };
-        Assert.Equal(value, control.LineColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LineColor = value;
-        Assert.Equal(value, control.LineColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_LineColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LineColor = value;
-        Assert.Equal(value, control.LineColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LineColor = value;
-        Assert.Equal(value, control.LineColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_LineColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.LineColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.LineColor = Color.Red;
-        Assert.Equal(Color.Red, control.LineColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.InactiveBorder, control.LineColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_LineColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.LineColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.LineColor = Color.Red;
-        Assert.Equal(Color.Red, control.LineColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.InactiveBorder, control.LineColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void PropertyGrid_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new PropertyGrid
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void PropertyGrid_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<PropertySort>]
-    public void PropertyGrid_PropertySort_Set_GetReturnsExpected(PropertySort value)
-    {
-        using var control = new PropertyGrid
-        {
-            PropertySort = value
-        };
-
-        Assert.Equal(value, control.PropertySort);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.PropertySort = value;
-        Assert.Equal(value, control.PropertySort);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<PropertySort>]
-    public void PropertyGrid_PropertySort_SetWithHandle_GetReturnsExpected(PropertySort value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.PropertySort = value;
-        Assert.Equal(value, control.PropertySort);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.PropertySort = value;
-        Assert.Equal(value, control.PropertySort);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_PropertyTabCollection_AddAndRemoveTabType_Success()
-    {
-        using PropertyGrid grid = new();
-        Assert.Equal(1, grid.PropertyTabs.Count);
-
-        grid.PropertyTabs.AddTabType(typeof(TestPropertyTab));
-        Assert.Equal(2, grid.PropertyTabs.Count);
-
-        grid.PropertyTabs.RemoveTabType(typeof(TestPropertyTab));
-        Assert.Equal(1, grid.PropertyTabs.Count);
-    }
-
-    private class TestPropertyTab : PropertyTab
-    {
-        public override string TabName => "TestTabName";
-
-        public override Bitmap Bitmap => new(10, 10);
-
-        public override PropertyDescriptorCollection GetProperties(object component, Attribute[] attributes) => throw new NotImplementedException();
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedGridItem_SetNull_ThrowsArgumentNullException()
-    {
-        using var control = new PropertyGrid();
-        Assert.Throws<ArgumentNullException>("items", () => control.SelectedGridItem = null);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedGridItem_SetNotGridEntry_ThrowsInvalidCastException()
-    {
-        using var control = new PropertyGrid();
-        var mockGridItem = new Mock<GridItem>(MockBehavior.Strict);
-        Assert.Throws<InvalidCastException>(() => control.SelectedGridItem = mockGridItem.Object);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_SelectedItemWithFocusBackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedItemWithFocusBackColor = value
-        };
-        Assert.Equal(value, control.SelectedItemWithFocusBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedItemWithFocusBackColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_SelectedItemWithFocusBackColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedItemWithFocusBackColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedItemWithFocusBackColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedItemWithFocusBackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.SelectedItemWithFocusBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.SelectedItemWithFocusBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.SelectedItemWithFocusBackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Highlight, control.SelectedItemWithFocusBackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedItemWithFocusBackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.SelectedItemWithFocusBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.SelectedItemWithFocusBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.SelectedItemWithFocusBackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Highlight, control.SelectedItemWithFocusBackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_SelectedItemWithFocusForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedItemWithFocusForeColor = value
-        };
-        Assert.Equal(value, control.SelectedItemWithFocusForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedItemWithFocusForeColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_SelectedItemWithFocusForeColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedItemWithFocusForeColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedItemWithFocusForeColor = value;
-        Assert.Equal(value, control.SelectedItemWithFocusForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedItemWithFocusForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.SelectedItemWithFocusForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.SelectedItemWithFocusForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.SelectedItemWithFocusForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.HighlightText, control.SelectedItemWithFocusForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedItemWithFocusForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.SelectedItemWithFocusForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.SelectedItemWithFocusForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.SelectedItemWithFocusForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.HighlightText, control.SelectedItemWithFocusForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> SelectedObject_Set_TestData()
-    {
-        yield return new object[] { null, null, Array.Empty<object>() };
-        yield return new object[] { 1, 1, new object[] { 1 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedObject_Set_TestData))]
-    public void PropertyGrid_SelectedObject_Set_GetReturnsExpected(object value, object expected, object[] expectedSelectedObjects)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedObject = value
-        };
-        Assert.Equal(expected, control.SelectedObject);
-        Assert.Equal(expectedSelectedObjects, control.SelectedObjects);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedObject = value;
-        Assert.Equal(expected, control.SelectedObject);
-        Assert.Equal(expectedSelectedObjects, control.SelectedObjects);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedObject_Set_TestData))]
-    public void PropertyGrid_SelectedObject_SetWithHandle_GetReturnsExpected(object value, object expected, object[] expectedSelectedObjects)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedObject = value;
-        Assert.Equal(expected, control.SelectedObject);
-        Assert.Equal(expectedSelectedObjects, control.SelectedObjects);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedObject = value;
-        Assert.Equal(expected, control.SelectedObject);
-        Assert.Equal(expectedSelectedObjects, control.SelectedObjects);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectedObjects_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<object>(), null };
-        yield return new object[] { Array.Empty<object>(), Array.Empty<object>(), null };
-        yield return new object[] { new object[] { 1 }, new object[] { 1 }, 1 };
-        yield return new object[] { new object[] { 2 }, new object[] { 2 }, 2 };
-        yield return new object[] { new object[] { "2" }, new object[] { "2" }, "2" };
-        yield return new object[] { new object[] { 1, 2, 3 }, new object[] { 1, 2, 3 }, 1 };
-        yield return new object[] { new object[] { 1, "2", 3 }, new object[] { 1, "2", 3 }, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedObjects_Set_TestData))]
-    public void PropertyGrid_SelectedObjects_Set_GetReturnsExpected(object[] value, object[] expected, object expectedSelectedObject)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedObjects = value
-        };
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedObjects = value;
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedObjects_Set_TestData))]
-    public void PropertyGrid_SelectedObjects_SetWithCustomOldValue_GetReturnsExpected(object[] value, object[] expected, object expectedSelectedObject)
-    {
-        using var control = new PropertyGrid
-        {
-            SelectedObjects = new object[] { 1 }
-        };
-
-        control.SelectedObjects = value;
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedObjects = value;
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedObjects_Set_TestData))]
-    public void PropertyGrid_SelectedObjects_SetWithHandle_GetReturnsExpected(object[] value, object[] expected, object expectedSelectedObject)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedObjects = value;
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedObjects = value;
-        Assert.Equal(expected, control.SelectedObjects);
-        Assert.NotSame(value, control.SelectedObjects);
-        Assert.NotSame(control.SelectedObjects, control.SelectedObjects);
-        Assert.Equal(expectedSelectedObject, control.SelectedObject);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SelectedObjects_SetNullInValue_ThrowsArgumentException()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Throws<ArgumentException>(() => control.SelectedObjects = new object[] { null });
-    }
-
-    private ISite CreateISiteObject()
-    {
-        var mockComponentChangeService = new Mock<IComponentChangeService>(MockBehavior.Strict);
-        var mockPropertyValueUIService = new Mock<IPropertyValueUIService>(MockBehavior.Strict);
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-           .Setup(h => h.Container)
-           .Returns((IContainer)null);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IPropertyValueUIService)))
-            .Returns(mockPropertyValueUIService.Object);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        return mockSite.Object;
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Site_ShouldSaveSelectedTabIndex()
-    {
-        using PropertyGrid propertyGrid = new();
-        var propertyGridTestAccessor = propertyGrid.TestAccessor();
-
-        propertyGrid.Site = CreateISiteObject();
-        Assert.NotNull(propertyGrid.ActiveDesigner);
-
-        propertyGridTestAccessor.SaveSelectedTabIndex();
-        Dictionary<int, int> _designerSelections = propertyGridTestAccessor._designerSelections;
-        Assert.NotNull(_designerSelections);
-        Assert.True(_designerSelections.ContainsKey(propertyGrid.ActiveDesigner.GetHashCode()));
-
-        int savedTabIndex = _designerSelections[propertyGrid.ActiveDesigner.GetHashCode()];
-        int selectedTabIndex = -1;
-        Assert.NotEqual(savedTabIndex, selectedTabIndex);
-
-        bool isInvokeMethodSuccessful = propertyGridTestAccessor.TryGetSavedTabIndex(out selectedTabIndex);
-        Assert.True(isInvokeMethodSuccessful);
-        Assert.Equal(savedTabIndex, selectedTabIndex);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SiteChange_ShouldNotSaveSelectedTabIndex()
-    {
-        using PropertyGrid propertyGrid = new();
-        var propertyGridTestAccessor = propertyGrid.TestAccessor();
-        propertyGrid.Site = CreateISiteObject();
-        var previousActiveDesigner = propertyGrid.ActiveDesigner;
-        propertyGridTestAccessor.SaveSelectedTabIndex();
-
-        //Set other Site
-        propertyGrid.Site = CreateISiteObject();
-        Assert.NotNull(propertyGrid.ActiveDesigner);
-        Assert.NotEqual(previousActiveDesigner, propertyGrid.ActiveDesigner);
-
-        int selectedTabIndex = -1;
-        bool isInvokeMethodSuccessful = propertyGridTestAccessor.TryGetSavedTabIndex(out selectedTabIndex);
-        Assert.False(isInvokeMethodSuccessful);
-        Assert.Equal(-1, selectedTabIndex);
-
-        Dictionary<int, int> _designerSelections = propertyGridTestAccessor._designerSelections;
-        Assert.NotNull(_designerSelections);
-        Assert.True(_designerSelections.ContainsKey(previousActiveDesigner.GetHashCode()));
-    }
-
-    public static IEnumerable<object[]> Site_Set_TestData()
-    {
-        yield return new object[] { null };
-
-        var mockNullSite = new Mock<ISite>(MockBehavior.Strict);
-        mockNullSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockNullSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockNullSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        yield return new object[] { mockNullSite.Object };
-
-#if false
-        var mockInvalidSite = new Mock<ISite>(MockBehavior.Strict);
-        mockInvalidSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockInvalidSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new object());
-        mockInvalidSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns((IDesignerHost)null);
-        yield return new object[] { mockInvalidSite.Object };
-#endif
-
-        var mockNullDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockNullDesignerHost
-            .Setup(h => h.Container)
-            .Returns((IContainer)null);
-        mockNullDesignerHost
-            .Setup(h => h.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockNullDesignerHost
-            .Setup(h => h.GetService(typeof(IPropertyValueUIService)))
-            .Returns(null);
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite1
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockNullDesignerHost.Object);
-        yield return new object[] { mockSite1.Object };
-
-        var mockComponentChangeService = new Mock<IComponentChangeService>(MockBehavior.Strict);
-        var mockPropertyValueUIService = new Mock<IPropertyValueUIService>(MockBehavior.Strict);
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns((IContainer)null);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IComponentChangeService)))
-            .Returns(mockComponentChangeService.Object);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IPropertyValueUIService)))
-            .Returns(mockPropertyValueUIService.Object);
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite2
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        yield return new object[] { mockSite2.Object };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void PropertyGrid_Site_Set_GetReturnsExpected(ISite value)
-    {
-        using var control = new PropertyGrid
-        {
-            Site = value
-        };
-        Assert.Same(value, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void PropertyGrid_Site_SetWithHandle_GetReturnsExpected(ISite value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Site = value;
-        Assert.Same(value, control.Site);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Site_SetInvalidDesignerHost_DoesNotThrowInvalidCastException()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(new object());
-        using var control = new PropertyGrid();
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Site_SetInvalidDesignerHostComponentChangeService_DoesNotThrowInvalidCastException()
-    {
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns((IContainer)null);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IComponentChangeService)))
-            .Returns(new object());
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IPropertyValueUIService)))
-            .Returns(null);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        using var control = new PropertyGrid();
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Site_SetInvalidDesignerHostPropertyValueUIService_DoesNotThrowInvalidCastException()
-    {
-        var mockDesignerHost = new Mock<IDesignerHost>(MockBehavior.Strict);
-        mockDesignerHost
-            .Setup(h => h.Container)
-            .Returns((IContainer)null);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockDesignerHost
-            .Setup(h => h.GetService(typeof(IPropertyValueUIService)))
-            .Returns(new object());
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.GetService(typeof(IDesignerHost)))
-            .Returns(mockDesignerHost.Object);
-        using var control = new PropertyGrid();
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void PropertyGrid_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new PropertyGrid
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void PropertyGrid_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new PropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 0, 1)]
-    [InlineData(true, false, 1, 1, 2)]
-    [InlineData(false, true, 1, 2, 2)]
-    [InlineData(false, false, 0, 0, 1)]
-    public void PropertyGrid_ToolbarVisible_Set_GetReturnsExpected(bool visible, bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2, int expectedLayoutCallCount3)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ToolbarVisible = value;
-        Assert.Equal(value, control.ToolbarVisible);
-        Assert.Equal(visible && value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ToolbarVisible = value;
-        Assert.Equal(value, control.ToolbarVisible);
-        Assert.Equal(visible && value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ToolbarVisible = !value;
-        Assert.Equal(!value, control.ToolbarVisible);
-        Assert.Equal(visible && !value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount3, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 7, 2, 7, 4, 11, 6)]
-    [InlineData(true, false, 11, 2, 11, 4, 15, 6)]
-    [InlineData(false, true, 1, 1, 2, 2, 2, 3)]
-    [InlineData(false, false, 0, 1, 0, 2, 1, 3)]
-    public void PropertyGrid_ToolbarVisible_SetWithHandle_GetReturnsExpected(bool visible, bool value, int expectedLayoutCallCount1, int expectedInvalidatedCallCount1, int expectedLayoutCallCount2, int expectedInvalidatedCallCount2, int expectedLayoutCallCount3, int expectedInvalidatedCallCount3)
-    {
-        using var control = new PropertyGrid
-        {
-            Visible = visible
-        };
-
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ToolbarVisible = value;
-        Assert.Equal(value, control.ToolbarVisible);
-        Assert.Equal(visible && value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ToolbarVisible = value;
-        Assert.Equal(value, control.ToolbarVisible);
-        Assert.Equal(visible && value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ToolbarVisible = !value;
-        Assert.Equal(!value, control.ToolbarVisible);
-        Assert.Equal(visible && !value, control.Controls.OfType<ToolStrip>().Single().Visible);
-        Assert.False(control.CommandsVisible);
-        Assert.Equal(expectedLayoutCallCount3, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ToolStripRenderer_Set_GetReturnsExpected()
-    {
-        var value = new SubToolStripRenderer();
-        using var control = new SubPropertyGrid
-        {
-            ToolStripRenderer = value
-        };
-
-        Assert.Same(value, control.ToolStripRenderer);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ToolStripRenderer = value;
-        Assert.Same(value, control.ToolStripRenderer);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.ToolStripRenderer = null;
-        Assert.NotNull(control.ToolStripRenderer);
-        Assert.Same(control.ToolStripRenderer, control.ToolStripRenderer);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_ViewBackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            ViewBackColor = value
-        };
-
-        Assert.Equal(expected, control.ViewBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ViewBackColor = value;
-        Assert.Equal(expected, control.ViewBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void PropertyGrid_ViewBackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ViewBackColor = value;
-        Assert.Equal(expected, control.ViewBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ViewBackColor = value;
-        Assert.Equal(expected, control.ViewBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewBackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.ViewBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewBackColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.ViewBackColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewBackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewBackColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ViewBackColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewBackColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.Window, control.ViewBackColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewBackColor_SetTransparent_ThrowsArgmentException()
-    {
-        using var control = new PropertyGrid();
-        Assert.Throws<ArgumentException>(() => control.ViewBackColor = Color.FromArgb(254, 1, 2, 3));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_ViewBorderColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid
-        {
-            ViewBorderColor = value
-        };
-        Assert.Equal(value, control.ViewBorderColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ViewBorderColor = value;
-        Assert.Equal(value, control.ViewBorderColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CategoryForeColor_Set_TestData))]
-    public void PropertyGrid_ViewBorderColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ViewBorderColor = value;
-        Assert.Equal(value, control.ViewBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ViewBorderColor = value;
-        Assert.Equal(value, control.ViewBorderColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewBorderColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.ViewBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewBorderColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.ViewBorderColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewBorderColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewBorderColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ViewBorderColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewBorderColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.ControlDark, control.ViewBorderColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    public static IEnumerable<object[]> ViewForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.ControlText };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ViewForeColor_Set_TestData))]
-    public void PropertyGrid_ViewForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid
-        {
-            ViewForeColor = value
-        };
-        Assert.Equal(expected, control.ViewForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ViewForeColor = value;
-        Assert.Equal(expected, control.ViewForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ViewForeColor_Set_TestData))]
-    public void PropertyGrid_ViewForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new PropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ViewForeColor = value;
-        Assert.Equal(expected, control.ViewForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ViewForeColor = value;
-        Assert.Equal(expected, control.ViewForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.CanResetValue(control));
-
-        control.ViewForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewForeColor);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ViewForeColor);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_ViewForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(PropertyGrid))[nameof(PropertyGrid.ViewForeColor)];
-        using var control = new PropertyGrid();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ViewForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ViewForeColor);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(SystemColors.WindowText, control.ViewForeColor);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubPropertyGrid.ScrollStateAutoScrolling, false)]
-    [InlineData(SubPropertyGrid.ScrollStateFullDrag, false)]
-    [InlineData(SubPropertyGrid.ScrollStateHScrollVisible, false)]
-    [InlineData(SubPropertyGrid.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubPropertyGrid.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void PropertyGrid_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void PropertyGrid_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void PropertyGrid_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, KeyEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void PropertyGrid_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, KeyPressEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void PropertyGrid_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, KeyEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), false };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0), true };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0), false };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0), true };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0), false };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0), true };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0), false };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0), true };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0), false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void PropertyGrid_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs, bool expectedIsHandleCreated)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, MouseEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_OnMouseDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnMouseEnter_Invoke_CallsMouseEnter(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void PropertyGrid_OnMouseLeave_Invoke_CallsMouseLeave(EventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseMove_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseMove_TestData))]
-    public void PropertyGrid_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-        void handler(object sender, MouseEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_OnMouseMove_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubPropertyGrid();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseMove(null));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void PropertyGrid_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubPropertyGrid();
-        int callCount = 0;
-
-        void handler(object sender, MouseEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_Buttons_AccessibleRole_IsRadiButton()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton categoryButton = toolStripButtons[0];
-        ToolStripButton alphaButton = toolStripButtons[1];
-
-        Assert.Equal(AccessibleRole.RadioButton, categoryButton.AccessibleRole);
-        Assert.Equal(AccessibleRole.RadioButton, alphaButton.AccessibleRole);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_SystemColorsChanged_DoesNotLeakImageList()
-    {
-        using SubPropertyGrid propertyGrid = new SubPropertyGrid();
-
-        ImageList normalButtons = propertyGrid.TestAccessor().Dynamic._normalButtonImages;
-
-        Assert.NotNull(normalButtons);
-
-        propertyGrid.OnSystemColorsChanged(EventArgs.Empty);
-
-        ImageList newNormalButtons = propertyGrid.TestAccessor().Dynamic._normalButtonImages;
-        Assert.NotNull(newNormalButtons);
-        Assert.NotSame(normalButtons, newNormalButtons);
-
-        GC.Collect();
-        GC.WaitForPendingFinalizers();
-
-#if DEBUG
-        Assert.True(normalButtons.IsDisposed);
-#endif
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void PropertyGrid_SetEnableFalse_DoesntBreakEntries_AndFlagsReturnCorrectValue(bool enable)
-    {
-        using PropertyGrid propertyGrid = new();
-        using Button button = new();
-        propertyGrid.SelectedObject = button;
-        propertyGrid.Enabled = enable;
-        var entry = (GridEntry)propertyGrid.SelectedGridItem;
-
-        Assert.True(entry.EntryFlags != 0);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(button.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_BindObject()
-    {
-        using PropertyGrid propertyGrid = new();
-        object @object = new();
-        propertyGrid.SelectedObject = @object;
-        GridItem selectedItem = propertyGrid.SelectedGridItem;
-        Assert.True(selectedItem is not null);
-        Assert.Equal("System.Object", selectedItem.Label);
-        Assert.IsAssignableFrom<IRootGridEntry>(selectedItem);
-        SingleSelectRootGridEntry gridEntry = Assert.IsAssignableFrom<SingleSelectRootGridEntry>(selectedItem);
-        AttributeCollection browsableAttributes = gridEntry.BrowsableAttributes;
-        Assert.Single(browsableAttributes);
-        Assert.Equal(BrowsableAttribute.Yes, browsableAttributes[0]);
-        Type propertyType = gridEntry.PropertyType;
-        Assert.True(propertyType == typeof(object));
-
-        AttributeCollection attributes = gridEntry.TestAccessor().Dynamic.Attributes;
-        bool foundTypeForward = false;
-        foreach (object attribute in attributes)
-        {
-            if (attribute is TypeForwardedFromAttribute forwardedFrom)
-            {
-                Assert.Equal(
-                    "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
-                    forwardedFrom.AssemblyFullName);
-                foundTypeForward = true;
-                break;
-            }
-        }
-
-        Assert.True(foundTypeForward, "Did not find TypeForwardedAttribute.");
-
-        TypeConverter typeConverter = gridEntry.TypeConverter;
-        Assert.IsType<TypeConverter>(typeConverter);
-        propertyGrid.Enabled = true;
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    private class SubPropertyGrid : PropertyGrid
-    {
-        public new const int ScrollStateAutoScrolling = PropertyGrid.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = PropertyGrid.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = PropertyGrid.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = PropertyGrid.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = PropertyGrid.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new Type DefaultTabType => base.DefaultTabType;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new bool DrawFlatToolbar
-        {
-            get => base.DrawFlatToolbar;
-            set => base.DrawFlatToolbar = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new ToolStripRenderer ToolStripRenderer
-        {
-            get => base.ToolStripRenderer;
-            set => base.ToolStripRenderer = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs eventargs) => base.OnMouseEnter(eventargs);
-
-        public new void OnMouseLeave(EventArgs eventargs) => base.OnMouseLeave(eventargs);
-
-        public new void OnMouseMove(MouseEventArgs eventargs) => base.OnMouseMove(eventargs);
-
-        public new void OnMouseUp(MouseEventArgs eventargs) => base.OnMouseUp(eventargs);
-
-        public new void OnSystemColorsChanged(EventArgs e) => base.OnSystemColorsChanged(e);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    [WinFormsFact]
-    public void PropertyGrid_NotifyParentChange()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/10427
-        using PropertyGrid propertyGrid = new();
-        propertyGrid.Site = new MySite();
-        MyClass myClass = new();
-        propertyGrid.SelectedObject = myClass;
-        PropertyGridView propertyGridView = (PropertyGridView)propertyGrid.Controls[2];
-        GridEntry entry = propertyGridView.SelectedGridEntry;
-        var descriptor = entry.GridItems[0] as PropertyDescriptorGridEntry;
-
-        descriptor.SetPropertyTextValue("123");
-        Assert.Equal("123", myClass.ParentGridEntry.NestedGridEntry);
-    }
-
-    private class MyClass
-    {
-        [TypeConverter(typeof(ExpandableObjectConverter))]
-        public virtual MyExpandableClass ParentGridEntry { get; set; } = new() { };
-
-        public class MyExpandableClass
-        {
-            [NotifyParentProperty(true)]
-            [TypeConverter(typeof(StringConverter))]
-            public string NestedGridEntry { get; set; }
-        }
-    }
-
-    private class MySite : ISite
-    {
-        private IComponentChangeService _componentChangeService = new ComponentChangeService();
-        public IComponent Component => null;
-        public IContainer Container => null;
-        public bool DesignMode => false;
-        public string Name { get; set; }
-
-        public object GetService(Type serviceType)
-            => serviceType == typeof(IComponentChangeService) ? _componentChangeService : null;
-
-        public class ComponentChangeService : IComponentChangeService
-        {
-#pragma warning disable CS0067 // Required by Interface
-            public event ComponentEventHandler ComponentAdded;
-            public event ComponentEventHandler ComponentAdding;
-            public event ComponentChangedEventHandler ComponentChanged;
-            public event ComponentChangingEventHandler ComponentChanging;
-            public event ComponentEventHandler ComponentRemoved;
-            public event ComponentEventHandler ComponentRemoving;
-            public event ComponentRenameEventHandler ComponentRename;
-#pragma warning restore
-
-            public void OnComponentChanged(object component, MemberDescriptor member, object oldValue, object newValue)
-            {
-            }
-
-            public void OnComponentChanging(object component, MemberDescriptor member)
-            {
-                if (member is null)
-                    return;
-                Reflection.MemberInfo[] properties = component.GetType().GetMembers();
-                Assert.False(properties.All(p => p.Name != member.Name), "Property not found!");
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStrip.PropertyGridToolStripAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStrip.PropertyGridToolStripAccessibleObjectTests.cs
deleted file mode 100644
index 28ad4abac32..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStrip.PropertyGridToolStripAccessibleObjectTests.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGridToolStrip_PropertyGridToolStripAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PropertyGridToolStripAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using PropertyGridToolStrip propertyGridToolStrip = new PropertyGridToolStrip(propertyGrid);
-        PropertyGridToolStrip.PropertyGridToolStripAccessibleObject accessibleObject =
-            new PropertyGridToolStrip.PropertyGridToolStripAccessibleObject(propertyGridToolStrip, propertyGrid);
-
-        Assert.Equal(propertyGridToolStrip, accessibleObject.Owner);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(propertyGridToolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripAccessibleObject_ControlType_IsToolBar_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using PropertyGridToolStrip propertyGridToolStrip = new PropertyGridToolStrip(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        object actual = propertyGridToolStrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ToolBarControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(propertyGridToolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripAccessibleObject_Role_IsToolBar_ByDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using PropertyGridToolStrip propertyGridToolStrip = new PropertyGridToolStrip(propertyGrid);
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = propertyGridToolStrip.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.ToolBar, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-        Assert.False(propertyGridToolStrip.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButton.PropertyGridToolStripButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButton.PropertyGridToolStripButtonAccessibleObjectTests.cs
deleted file mode 100644
index a47b522afac..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButton.PropertyGridToolStripButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGridToolStripButton_PropertyGridToolStripButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_IsItemSelected_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        AccessibleObject categoryButtonAccessibleObject = toolStripButtons[0].AccessibilityObject;
-        AccessibleObject alphaButtonAccessibleObject = toolStripButtons[1].AccessibilityObject;
-
-        Assert.True(categoryButtonAccessibleObject.IsItemSelected);
-        Assert.False(alphaButtonAccessibleObject.IsItemSelected);
-
-        alphaButtonAccessibleObject.SelectItem();
-
-        Assert.False(categoryButtonAccessibleObject.IsItemSelected);
-        Assert.True(alphaButtonAccessibleObject.IsItemSelected);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_Role_IsRadiButton()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        AccessibleObject accessibleObject = toolStripButtons[0].AccessibilityObject;
-
-        Assert.Equal(AccessibleRole.RadioButton, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_SelectionItemPatternSupported_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton propertyPagesButton = propertyGrid.TestAccessor().Dynamic._viewPropertyPagesButton;
-        AccessibleObject categoryButtonAccessibleObject = toolStripButtons[0].AccessibilityObject;
-        AccessibleObject alphaButtonAccessibleObject = toolStripButtons[1].AccessibilityObject;
-        AccessibleObject propertyPagesButtonAccessibleObject = propertyPagesButton.AccessibilityObject;
-
-        Assert.True(categoryButtonAccessibleObject.IsPatternSupported(UIA.SelectionItemPatternId));
-        Assert.True(alphaButtonAccessibleObject.IsPatternSupported(UIA.SelectionItemPatternId));
-
-        // In accordance with the behavior of the PropertyGrid, the "Property Page" button does not have
-        // the role of a "RadioButton" and therefore does not support the "SelectionItem" pattern
-        Assert.False(propertyPagesButtonAccessibleObject.IsPatternSupported(UIA.SelectionItemPatternId));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsRadioButton()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        AccessibleObject accessibleObject = toolStripButtons[0].AccessibilityObject;
-
-        UiaCore.UIA actual = (UiaCore.UIA)accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.RadioButtonControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_AddToSelection_UpdatesCheckedStateAndPropertySort()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton categoryButton = toolStripButtons[0];
-        ToolStripButton alphaButton = toolStripButtons[1];
-        AccessibleObject alphaButtonAccessibleObject = alphaButton.AccessibilityObject;
-        AccessibleObject categoryButtonAccessibleObject = categoryButton.AccessibilityObject;
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-
-        alphaButtonAccessibleObject.AddToSelection();
-
-        Assert.False(categoryButton.Checked);
-        Assert.True(alphaButton.Checked);
-        Assert.Equal(PropertySort.Alphabetical, propertyGrid.PropertySort);
-
-        categoryButtonAccessibleObject.AddToSelection();
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_Invoke_UpdatesCheckedStateAndPropertySort()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton categoryButton = toolStripButtons[0];
-        ToolStripButton alphaButton = toolStripButtons[1];
-        AccessibleObject alphaButtonAccessibleObject = alphaButton.AccessibilityObject;
-        AccessibleObject categoryButtonAccessibleObject = categoryButton.AccessibilityObject;
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-
-        alphaButtonAccessibleObject.Invoke();
-
-        Assert.False(categoryButton.Checked);
-        Assert.True(alphaButton.Checked);
-        Assert.Equal(PropertySort.Alphabetical, propertyGrid.PropertySort);
-
-        categoryButtonAccessibleObject.Invoke();
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_RemoveFromSelection_DoesNotUpdateCheckedStateAndPropertySort()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton categoryButton = toolStripButtons[0];
-        ToolStripButton alphaButton = toolStripButtons[1];
-        AccessibleObject alphaButtonAccessibleObject = alphaButton.AccessibilityObject;
-        AccessibleObject categoryButtonAccessibleObject = categoryButton.AccessibilityObject;
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-
-        alphaButtonAccessibleObject.RemoveFromSelection();
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_SelectItem_UpdatesCheckedStateAndPropertySort()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton categoryButton = toolStripButtons[0];
-        ToolStripButton alphaButton = toolStripButtons[1];
-        AccessibleObject alphaButtonAccessibleObject = alphaButton.AccessibilityObject;
-        AccessibleObject categoryButtonAccessibleObject = categoryButton.AccessibilityObject;
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-
-        alphaButtonAccessibleObject.SelectItem();
-
-        Assert.False(categoryButton.Checked);
-        Assert.True(alphaButton.Checked);
-        Assert.Equal(PropertySort.Alphabetical, propertyGrid.PropertySort);
-
-        categoryButtonAccessibleObject.SelectItem();
-
-        Assert.True(categoryButton.Checked);
-        Assert.False(alphaButton.Checked);
-        Assert.Equal(PropertySort.CategorizedAlphabetical, propertyGrid.PropertySort);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridToolStripButtonAccessibleObject_IsTogglePatternSupported_ReturnsExpected()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-        ToolStripButton propertyPagesButton = propertyGrid.TestAccessor().Dynamic._viewPropertyPagesButton;
-        AccessibleObject categoryButtonAccessibleObject = toolStripButtons[0].AccessibilityObject;
-        AccessibleObject alphaButtonAccessibleObject = toolStripButtons[1].AccessibilityObject;
-        AccessibleObject propertyPagesButtonAccessibleObject = propertyPagesButton.AccessibilityObject;
-
-        Assert.False(categoryButtonAccessibleObject.IsPatternSupported(UIA.TogglePatternId));
-        Assert.False(alphaButtonAccessibleObject.IsPatternSupported(UIA.TogglePatternId));
-        Assert.False(propertyPagesButtonAccessibleObject.IsPatternSupported(UIA.TogglePatternId));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButtonTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButtonTests.cs
deleted file mode 100644
index 696ab31ae77..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridToolStripButtonTests.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGridToolStripButtonTests
-{
-    [WinFormsFact]
-    public void PropertyGridToolStripButton_AccessibilityObject_ReturnsPropertyGridToolStripButtonAccessibleObject()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ToolStripButton[] toolStripButtons = propertyGrid.TestAccessor().Dynamic._viewSortButtons;
-
-        Assert.IsType<PropertyGridToolStripButton.PropertyGridToolStripButtonAccessibleObject>(toolStripButtons[0].AccessibilityObject);
-        Assert.IsType<PropertyGridToolStripButton.PropertyGridToolStripButtonAccessibleObject>(toolStripButtons[1].AccessibilityObject);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.GridViewListBoxItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.GridViewListBoxItemAccessibleObjectTests.cs
deleted file mode 100644
index 890d9a7c60d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.GridViewListBoxItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using System.Windows.Forms.PropertyGridInternal;
-using static System.Windows.Forms.PropertyGridInternal.PropertyGridView;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGridView_GridViewListBoxItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void GridViewListBoxItemAccessibleObject_Ctor_OwnerGridViewListBoxCannotBeNull()
-    {
-        Type type = typeof(PropertyGridView)
-            .GetNestedType("GridViewListBoxItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        Assert.Throws<TargetInvocationException>(() => (AccessibleObject)Activator.CreateInstance(type, new object[] { null, new ItemArray.Entry("A") }));
-    }
-
-    [WinFormsFact]
-    public void GridViewListBoxItemAccessibleObject_Ctor_OwnerItemCannotBeNull()
-    {
-        using GridViewListBox control = new(new PropertyGridView(null, null));
-        Type type = typeof(PropertyGridView)
-            .GetNestedType("GridViewListBoxItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        Assert.Throws<TargetInvocationException>(() => (AccessibleObject)Activator.CreateInstance(type, new object[] { control, null }));
-    }
-
-    [WinFormsFact]
-    public void GridViewListBoxItemAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using GridViewListBox control = new(new PropertyGridView(null, null));
-        Type type = typeof(PropertyGridView)
-            .GetNestedType("GridViewListBoxItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control, new ItemArray.Entry("A") });
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Some string for test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void GridViewListBoxItemAccessibleObject_Name_ReturnsExpected(string testName)
-    {
-        using GridViewListBox control = new(new PropertyGridView(null, null));
-        Type type = typeof(PropertyGridView)
-            .GetNestedType("GridViewListBoxItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var itemEntry = new ItemArray.Entry(testName);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control, itemEntry });
-
-        Assert.Equal(itemEntry.ToString(), accessibleObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.InvokePatternId)]
-    public void GridViewListBoxItemAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        using GridViewListBox control = new(new PropertyGridView(null, null));
-        Type type = typeof(PropertyGridView)
-            .GetNestedType("GridViewListBoxItemAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);
-        var accessibleObject = (AccessibleObject)Activator.CreateInstance(type, new object[] { control, new ItemArray.Entry("A") });
-
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.PropertyGridViewAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.PropertyGridViewAccessibleObjectTests.cs
deleted file mode 100644
index 0350895b545..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyGridView.PropertyGridViewAccessibleObjectTests.cs
+++ /dev/null
@@ -1,338 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Reflection;
-using System.Windows.Forms.PropertyGridInternal;
-using static System.Windows.Forms.Control;
-using static System.Windows.Forms.PropertyGridInternal.PropertyGridView;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyGridView_PropertyGridViewAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Ctor_Default()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-        Assert.NotNull(accessibleObject);
-
-        using PropertyGridView propertyGridView = new PropertyGridView(null, propertyGrid);
-        accessibleObject = new PropertyGridViewAccessibleObject(propertyGridView, propertyGrid);
-        Assert.NotNull(accessibleObject);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new PropertyGridViewAccessibleObject(null, null));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.Parent)]
-    [InlineData((int)UiaCore.NavigateDirection.NextSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.PreviousSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    public void PropertyGridViewAccessibleObject_FragmentNavigate_DoesNotThrowExpection_WithoutOwnerGrid(int direction)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using PropertyGridView propertyGridView = new PropertyGridView(null, null);
-        AccessibleObject accessibleObject = new PropertyGridViewAccessibleObject(propertyGridView, propertyGrid);
-        Assert.Null(accessibleObject.FragmentNavigate((UiaCore.NavigateDirection)direction));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_GetFocused_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        GridEntry entry = (GridEntry)((GridEntry)propertyGrid.GetCurrentEntries()[0]).Children[2];
-        entry.HasFocus = true;
-        entry.Select();
-        Assert.Equal(entry, propertyGrid.SelectedGridItem);
-
-        AccessibleObject focusedEntry = propertyGrid.GridViewAccessibleObject.GetFocused();
-        Assert.Equal(entry.AccessibilityObject, focusedEntry);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_GetSelected_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        GridEntry entry = (GridEntry)((GridEntry)propertyGrid.GetCurrentEntries()[0]).Children[2];
-        entry.HasFocus = true;
-        entry.Select();
-        Assert.Equal(entry, propertyGrid.SelectedGridItem);
-
-        AccessibleObject focusedEntry = propertyGrid.GridViewAccessibleObject.GetSelected();
-        Assert.Equal(entry.AccessibilityObject, focusedEntry);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_GetChildCount_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-
-        Assert.Equal(0, accessibleObject.GetChildCount()); // propertyGrid doesn't have an item
-
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-
-        int count = 0;
-
-        foreach (GridEntry category in propertyGrid.GetCurrentEntries())
-        {
-            count++;
-
-            foreach (GridEntry entry in category.Children)
-            {
-                count++;
-            }
-        }
-
-        Assert.Equal(count, accessibleObject.GetChildCount()); // Properties
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_GetChild_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-
-        Assert.Equal(0, accessibleObject.GetChildCount()); // propertyGrid doesn't have items
-        Assert.Null(accessibleObject.GetChild(0)); // GetChild method should not throw an exception
-
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-
-        Assert.True(accessibleObject.GetChild(0) is GridEntry.GridEntryAccessibleObject); // "Accessibility" category entry
-        Assert.True(accessibleObject.GetChild(1) is GridEntry.GridEntryAccessibleObject); // "AccessibleDescriptor" entry
-        Assert.True(accessibleObject.GetChild(2) is GridEntry.GridEntryAccessibleObject); // "AccessibleName" entry
-        Assert.True(accessibleObject.GetChild(3) is GridEntry.GridEntryAccessibleObject); // "AccessibleRole" entry
-        Assert.True(accessibleObject.GetChild(4) is GridEntry.GridEntryAccessibleObject); // "Appearance" category entry
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Bounds_InsidePropertyGridBounds()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        propertyGrid.Size = new Size(300, 500);
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-
-        Rectangle gridViewBounds = propertyGrid.RectangleToClient(accessibleObject.Bounds);
-        Rectangle propertyGridBounds = propertyGrid.Bounds;
-        Assert.True(propertyGridBounds.Contains(gridViewBounds));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_ControlType_IsTable_IfAccessibleRoleIsDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        // AccessibleRole is not set = Default
-
-        object actual = propertyGrid.GridViewAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TableControlTypeId, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Role_IsTable_ByDefault()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = propertyGrid.GridViewAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Table, actual);
-        Assert.False(propertyGrid.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_GetItem_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-
-        int i = 0;
-
-        foreach (GridEntry category in propertyGrid.GetCurrentEntries())
-        {
-            AccessibleObject categoryAccessibilityObject = category.AccessibilityObject;
-            AccessibleObject categoryItem = (AccessibleObject)accessibleObject.GetItem(i, 1);
-            Assert.Equal(categoryAccessibilityObject, categoryItem);
-            i++;
-
-            foreach (GridEntry entry in category.Children)
-            {
-                AccessibleObject entryAccessibilityObject = entry.AccessibilityObject;
-                AccessibleObject entryItem = (AccessibleObject)accessibleObject.GetItem(i, 1);
-                Assert.Equal(categoryAccessibilityObject, categoryItem);
-                i++;
-            }
-        }
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_State_IsFocusable()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State & AccessibleStates.Focusable);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Ctor_NullOwnerParameter_ThrowsArgumentNullException()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-        Type type = accessibleObject.GetType();
-        ConstructorInfo ctor = type.GetConstructor(new Type[] { typeof(PropertyGridView), typeof(PropertyGrid) });
-        Assert.NotNull(ctor);
-        Assert.Throws<TargetInvocationException>(() => ctor.Invoke(new object[] { null, null }));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsGridPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTablePatternAvailablePropertyId)]
-    public void PropertyGridViewAccessibleObject_Pattern_IsAvailable(int propertyId)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-        Assert.True((bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TablePatternId)]
-    [InlineData((int)UiaCore.UIA.GridPatternId)]
-    public void PropertyGridViewAccessibleObject_IsPatternSupported(int patternId)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        AccessibleObject accessibleObject = propertyGrid.GridViewAccessibleObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Entry_IsOffscreen_ReturnsCorrectValue()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.Size = new Size(300, 500);
-        propertyGrid.Location = new Point(0, 0);
-        propertyGrid.CreateControl();
-        using ComboBox comboBox = new ComboBox();
-        propertyGrid.SelectedObject = comboBox;
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        PropertyGridView propertyGridView = (PropertyGridView)accessibleObject.Owner;
-
-        Rectangle gridViewRectangle = accessibleObject.Bounds;
-
-        int ROWLABEL = 1;
-        int ROWVALUE = 2;
-
-        foreach (GridEntry category in propertyGrid.GetCurrentEntries())
-        {
-            AccessibleObject categoryAccessibilityObject = category.AccessibilityObject;
-            int row = propertyGridView.GetRowFromGridEntry(category);
-            Rectangle rect = propertyGridView.GetRectangle(row, ROWVALUE | ROWLABEL);
-            rect = propertyGridView.RectangleToScreen(rect);
-
-            bool visible = rect.Height > 0 &&
-                         ((rect.Y > gridViewRectangle.Y + 1 && rect.Y < gridViewRectangle.Bottom - 1) ||
-                          (rect.Y < gridViewRectangle.Bottom - 1 && rect.Bottom > gridViewRectangle.Y + 1)); // +-1 are borders
-
-            Assert.Equal(!visible, (bool)categoryAccessibilityObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId));
-
-            foreach (GridEntry entry in category.Children)
-            {
-                AccessibleObject entryAccessibilityObject = entry.AccessibilityObject;
-                row = propertyGridView.GetRowFromGridEntry(entry);
-                rect = propertyGridView.GetRectangle(row, ROWVALUE | ROWLABEL);
-                rect = propertyGridView.RectangleToScreen(rect);
-
-                visible = rect.Height > 0 &&
-                         ((rect.Y > gridViewRectangle.Y + 1 && rect.Y < gridViewRectangle.Bottom - 1) ||
-                          (rect.Y < gridViewRectangle.Bottom - 1 && rect.Bottom > gridViewRectangle.Y + 1)); // +-1 are borders
-
-                Assert.Equal(!visible, (bool)entryAccessibilityObject.GetPropertyValue(UiaCore.UIA.IsOffscreenPropertyId));
-            }
-        }
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Owner_IsNotNull()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        Assert.NotNull(accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Parent_IsNotNull_IfHandleIsCreated()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        propertyGrid.CreateControl();
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        Assert.NotNull(accessibleObject.Parent);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridViewAccessibleObject_Parent_IsNull_IfHandleIsNotCreated()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        Assert.Null(accessibleObject.Parent);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Some test text")]
-    [InlineData("")]
-    public void PropertyGridView_GridViewListBoxAccessibleObject_Name_ReturnsDeterminedName(string name)
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        Control.ControlAccessibleObject gridViewAccessibleObject = (Control.ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        PropertyGridView propertyGridView = (PropertyGridView)gridViewAccessibleObject.Owner;
-
-        propertyGridView.DropDownListBoxAccessibleObject.Name = name;
-        string listAccessibleName = propertyGridView.DropDownListBoxAccessibleObject.Name;
-        Assert.Equal(name, listAccessibleName);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridView_GridViewListBoxAccessibleObject_ReturnsDefaultName()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        Control.ControlAccessibleObject gridViewAccessibleObject = (Control.ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        PropertyGridView propertyGridView = (PropertyGridView)gridViewAccessibleObject.Owner;
-
-        string listAccessibleName = propertyGridView.DropDownListBoxAccessibleObject.Name;
-        Assert.Equal(SR.PropertyGridEntryValuesListDefaultAccessibleName, listAccessibleName);
-    }
-
-    [WinFormsFact]
-    public void PropertyGridView_GridViewListBoxAccessibleObject_ReturnsDefaultName_IfBaseNameIsSetAsNull()
-    {
-        using PropertyGrid propertyGrid = new PropertyGrid();
-        Control.ControlAccessibleObject gridViewAccessibleObject = (Control.ControlAccessibleObject)propertyGrid.GridViewAccessibleObject;
-        PropertyGridView propertyGridView = (PropertyGridView)gridViewAccessibleObject.Owner;
-
-        propertyGridView.DropDownListBoxAccessibleObject.Name = null;
-        string listAccessibleName = propertyGridView.DropDownListBoxAccessibleObject.Name;
-        Assert.Equal(SR.PropertyGridEntryValuesListDefaultAccessibleName, listAccessibleName);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyManagerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyManagerTests.cs
deleted file mode 100644
index 2bc756727a0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyManagerTests.cs
+++ /dev/null
@@ -1,442 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertyManagerTests
-{
-    [Fact]
-    public void PropertyManager_Ctor_Default()
-    {
-        var manager = new PropertyManager();
-        Assert.Equal(1, manager.Count);
-        Assert.Equal(0, manager.Position);
-        Assert.Null(manager.Current);
-        Assert.Empty(manager.GetListName(null));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void PropertyManager_Position_Set_Nop(int value)
-    {
-        var context = new BindingContext();
-        var source = new BindingSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[new DataSource()]);
-        manager.Position = value;
-        Assert.Equal(0, manager.Position);
-    }
-
-    [Fact]
-    public void PropertyManager_GetListName_Invoke_ReturnsEmpty()
-    {
-        var context = new BindingContext();
-        var source = new BindingSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[new DataSource()]);
-        Assert.Equal("System.Windows.Forms.Tests.PropertyManagerTests+DataSource.", manager.GetListName());
-        Assert.Empty(manager.GetListName(null));
-    }
-
-    [Fact]
-    public void PropertyManager_GetListName_NoDataSource_ThrowsArgumentException()
-    {
-        var manager = new PropertyManager();
-        Assert.Throws<ArgumentException>(() => manager.GetListName());
-    }
-
-    /*
-    public static IEnumerable<object[]> GetItemProperties_Parameterless_TestData()
-    {
-        yield return new object[] { new PropertyManager(), Array.Empty<string>() };
-
-        var singleContext = new BindingContext();
-        yield return new object[] { singleContext[new DataSource()], new string[] { "Property" } };
-
-        var listContext = new BindingContext();
-        yield return new object[] { listContext[new ListDataSource()], new string[] { "ListProperty" } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetItemProperties_Parameterless_TestData))]
-    public void PropertyManager_GetItemProperties_InvokeParameterless_ReturnsExpected(PropertyManager manager, string[] expected)
-    {
-        IEnumerable<PropertyDescriptor> properties = manager.GetItemProperties()?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-    }
-
-    public static IEnumerable<object[]> GetItemProperties_DataSourcesAndListAccessors_TestData()
-    {
-        yield return new object[] { new PropertyManager(), null, null, Array.Empty<string>() };
-        yield return new object[] { new PropertyManager(), new ArrayList(), new ArrayList(), Array.Empty<string>() };
-
-        var singleContext = new BindingContext();
-        yield return new object[] { singleContext[new DataSource()], null, null, new string[] { "Property" } };
-        yield return new object[] { singleContext[new DataSource()], null, new ArrayList(), new string[] { "Property" } };
-
-        var listContext = new BindingContext();
-        yield return new object[] { listContext[new ListDataSource()], null, new ArrayList(), new string[] { "ListProperty" } };
-        yield return new object[] { listContext[new ListDataSource()], null, new ArrayList(TypeDescriptor.GetProperties(typeof(ListDataSource))), new string[] { "Property" } };
-    }
-
-    [Theory]
-    [MemberData(nameof(GetItemProperties_DataSourcesAndListAccessors_TestData))]
-    public void PropertyManager_GetItemProperties_InvokeWithDataSourcesAndListAccessors_ReturnsExpected(PropertyManager manager, ArrayList dataSources, ArrayList listAccessors, string[] expected)
-    {
-        IEnumerable<PropertyDescriptor> properties = manager.GetItemProperties(dataSources, listAccessors)?.Cast<PropertyDescriptor>();
-        Assert.Equal(expected, properties?.Select(p => p.Name));
-    }*/
-
-    [Fact]
-    public void PropertyManager_CancelCurrentEdit_NullCurrent_Nop()
-    {
-        var manager = new PropertyManager();
-        manager.CancelCurrentEdit();
-        manager.CancelCurrentEdit();
-    }
-
-    [Fact]
-    public void PropertyManager_CancelCurrentEdit_IEditableObjectCurrent_CallsCancelEdit()
-    {
-        var mockDataSource = new Mock<IEditableObject>(MockBehavior.Strict);
-        mockDataSource
-            .Setup(o => o.CancelEdit())
-            .Verifiable();
-
-        var manager = new PropertyManager(mockDataSource.Object);
-        manager.CancelCurrentEdit();
-        mockDataSource.Verify(o => o.CancelEdit(), Times.Exactly(1));
-
-        manager.CancelCurrentEdit();
-        mockDataSource.Verify(o => o.CancelEdit(), Times.Exactly(2));
-    }
-
-    [Fact]
-    public void PropertyManager_CancelCurrentEdit_NonNullCurrent_Nop()
-    {
-        var manager = new PropertyManager(new DataSource());
-        manager.CancelCurrentEdit();
-        manager.CancelCurrentEdit();
-    }
-
-    [Fact]
-    public void PropertyManager_EndCurrentEdit_NullCurrent_Nop()
-    {
-        var manager = new PropertyManager();
-        manager.EndCurrentEdit();
-        manager.EndCurrentEdit();
-    }
-
-    [Fact]
-    public void PropertyManager_EndCurrentEdit_IEditableObjectCurrent_CallsEndEdit()
-    {
-        var mockDataSource = new Mock<IEditableObject>(MockBehavior.Strict);
-        mockDataSource
-            .Setup(o => o.EndEdit())
-            .Verifiable();
-
-        var manager = new PropertyManager(mockDataSource.Object);
-        manager.EndCurrentEdit();
-        mockDataSource.Verify(o => o.EndEdit(), Times.Exactly(1));
-
-        manager.EndCurrentEdit();
-        mockDataSource.Verify(o => o.EndEdit(), Times.Exactly(2));
-    }
-
-    [WinFormsTheory(Skip = "Flaky test, see: https://github.com/dotnet/winforms/issues/1030")]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void PropertyManager_EndCurrentEdit_IEditableObjectCurrentNotSuccess_DoesNotCallEndEdit(bool cancel, int expectedCallCount)
-    {
-        int callCount = 0;
-        var dataSource = new EditableDataSource
-        {
-            EndEditHandler = () =>
-            {
-                callCount++;
-            }
-        };
-
-        var manager = new PropertyManager(dataSource);
-        using var control = new SubControl { Visible = true };
-        control.CreateControl();
-        var controlBindings = new ControlBindingsCollection(control);
-        var cancelBinding = new Binding("Value", dataSource, "Property", true);
-        BindingCompleteEventHandler bindingCompleteHandler = (sender, e) =>
-        {
-            e.Cancel = cancel;
-        };
-
-        cancelBinding.BindingComplete += bindingCompleteHandler;
-        controlBindings.Add(cancelBinding);
-        manager.Bindings.Add(cancelBinding);
-        manager.EndCurrentEdit();
-        Assert.Equal(expectedCallCount, callCount);
-
-        manager.EndCurrentEdit();
-        Assert.Equal(expectedCallCount * 2, callCount);
-    }
-
-    [Fact]
-    public void PropertyManager_EndCurrentEdit_NonNullCurrent_Nop()
-    {
-        var manager = new PropertyManager(new DataSource());
-        manager.EndCurrentEdit();
-        manager.EndCurrentEdit();
-    }
-
-    [Fact]
-    public void PropertyManager_ResumeBinding_SuspendBinding_Success()
-    {
-        var manager = new PropertyManager(new DataSource());
-        manager.ResumeBinding();
-        manager.SuspendBinding();
-        manager.ResumeBinding();
-        manager.SuspendBinding();
-    }
-
-    [Fact]
-    public void PropertyManager_ResumeBinding_Invoke_CallsHandlers()
-    {
-        var manager = new PropertyManager(new DataSource());
-
-        // No handlers.
-        manager.ResumeBinding();
-
-        // Only current changed handler.
-        int currentChangedCallCount = 0;
-        EventHandler currentChangedHandler = (sender, e) =>
-        {
-            currentChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-        };
-        manager.CurrentChanged += currentChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(1, currentChangedCallCount);
-
-        // Current changed and current item changed handler.
-        int currentItemChangedCallCount = 0;
-        EventHandler currentItemChangedHandler = (sender, e) =>
-        {
-            currentItemChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-        };
-        manager.CurrentItemChanged += currentItemChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(1, currentItemChangedCallCount);
-
-        // Only current item changed handler.
-        manager.CurrentChanged -= currentChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-
-        // No handlers.
-        manager.CurrentItemChanged -= currentItemChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-    }
-
-    [Fact]
-    public void PropertyManager_SuspendBinding_Invoke_CallsHandlers()
-    {
-        var mockDataSource = new Mock<IEditableObject>(MockBehavior.Strict);
-        mockDataSource
-            .Setup(o => o.EndEdit())
-            .Verifiable();
-
-        var manager = new PropertyManager(mockDataSource.Object);
-
-        // No handlers.
-        manager.SuspendBinding();
-        mockDataSource.Verify(o => o.EndEdit(), Times.Exactly(1));
-
-        // Only current changed handler.
-        int currentChangedCallCount = 0;
-        EventHandler currentChangedHandler = (sender, e) =>
-        {
-            currentChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-        };
-        manager.CurrentChanged += currentChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(1, currentChangedCallCount);
-
-        // Current changed and current item changed handler.
-        int currentItemChangedCallCount = 0;
-        EventHandler currentItemChangedHandler = (sender, e) =>
-        {
-            currentItemChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Same(EventArgs.Empty, e);
-        };
-        manager.CurrentItemChanged += currentItemChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(1, currentItemChangedCallCount);
-
-        // Only current item changed handler.
-        manager.CurrentChanged -= currentChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-
-        // No handlers.
-        manager.CurrentItemChanged -= currentItemChangedHandler;
-        manager.ResumeBinding();
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-    }
-
-    [Fact]
-    public void PropertyManager_OnCurrentChanged_Invoke_CallsHandlers()
-    {
-        var manager = new PropertyManager(new DataSource());
-
-        // No handlers.
-        manager.OnCurrentChanged(null);
-
-        // Only current changed handler.
-        int currentChangedCallCount = 0;
-        EventHandler currentChangedHandler = (sender, e) =>
-        {
-            currentChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Null(e);
-        };
-        manager.CurrentChanged += currentChangedHandler;
-        manager.OnCurrentChanged(null);
-        Assert.Equal(1, currentChangedCallCount);
-
-        // Current changed and current item changed handler.
-        int currentItemChangedCallCount = 0;
-        EventHandler currentItemChangedHandler = (sender, e) =>
-        {
-            currentItemChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Null(e);
-        };
-        manager.CurrentItemChanged += currentItemChangedHandler;
-        manager.OnCurrentChanged(null);
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(1, currentItemChangedCallCount);
-
-        // Only current item changed handler.
-        manager.CurrentChanged -= currentChangedHandler;
-        manager.OnCurrentChanged(null);
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-
-        // No handlers.
-        manager.CurrentItemChanged -= currentItemChangedHandler;
-        manager.OnCurrentChanged(null);
-        Assert.Equal(2, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-    }
-
-    [Fact]
-    public void PropertyManager_OnCurrentItemChanged_Invoke_CallsHandlers()
-    {
-        var manager = new PropertyManager(new DataSource());
-
-        // No handlers.
-        manager.OnCurrentChanged(null);
-
-        // Only current changed handler.
-        int currentChangedCallCount = 0;
-        EventHandler currentChangedHandler = (sender, e) =>
-        {
-            currentChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Null(e);
-        };
-        manager.CurrentChanged += currentChangedHandler;
-        manager.OnCurrentItemChanged(null);
-        Assert.Equal(0, currentChangedCallCount);
-
-        // Current changed and current item changed handler.
-        int currentItemChangedCallCount = 0;
-        EventHandler currentItemChangedHandler = (sender, e) =>
-        {
-            currentItemChangedCallCount++;
-            Assert.Same(manager, sender);
-            Assert.Null(e);
-        };
-        manager.CurrentItemChanged += currentItemChangedHandler;
-        manager.OnCurrentItemChanged(null);
-        Assert.Equal(0, currentChangedCallCount);
-        Assert.Equal(1, currentItemChangedCallCount);
-
-        // Only current item changed handler.
-        manager.CurrentChanged -= currentChangedHandler;
-        manager.OnCurrentItemChanged(null);
-        Assert.Equal(0, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-
-        // No handlers.
-        manager.CurrentItemChanged -= currentItemChangedHandler;
-        manager.OnCurrentItemChanged(null);
-        Assert.Equal(0, currentChangedCallCount);
-        Assert.Equal(2, currentItemChangedCallCount);
-    }
-
-    [Fact]
-    public void PropertyManager_AddNew_Invoke_ThrowsNotSupportedException()
-    {
-        var context = new BindingContext();
-        var source = new BindingSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[new DataSource()]);
-        Assert.Throws<NotSupportedException>(() => manager.AddNew());
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void PropertyManager_RemoveAt_Invoke_ThrowsNotSupportedException(int index)
-    {
-        var context = new BindingContext();
-        var source = new BindingSource();
-        PropertyManager manager = Assert.IsType<PropertyManager>(context[new DataSource()]);
-        Assert.Throws<NotSupportedException>(() => manager.RemoveAt(index));
-    }
-
-    private class ListDataSource
-    {
-        public List<DataSource> ListProperty { get; set; }
-    }
-
-    private class DataSource
-    {
-        public int Property { get; set; }
-    }
-
-    private class SubControl : Control, INotifyPropertyChanged
-    {
-        event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
-        {
-            add { }
-            remove { }
-        }
-
-        public string Value { get; set; }
-    }
-
-    private class EditableDataSource : IEditableObject
-    {
-        public int Property { get; set; }
-
-        public void BeginEdit() => throw new NotImplementedException();
-
-        public void CancelEdit() => throw new NotImplementedException();
-
-        public Action EndEditHandler { get; set; }
-
-        public void EndEdit() => EndEditHandler();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyStoreTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyStoreTests.cs
deleted file mode 100644
index 1d38925fd81..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyStoreTests.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class PropertyStoreTests
-{
-    private static readonly int s_bool = PropertyStore.CreateKey();
-    private static readonly int s_byte = PropertyStore.CreateKey();
-    private static readonly int s_sbyte = PropertyStore.CreateKey();
-    private static readonly int s_char = PropertyStore.CreateKey();
-    private static readonly int s_decimal = PropertyStore.CreateKey();
-    private static readonly int s_double = PropertyStore.CreateKey();
-    private static readonly int s_float = PropertyStore.CreateKey();
-    private static readonly int s_int = PropertyStore.CreateKey();
-    private static readonly int s_uint = PropertyStore.CreateKey();
-    private static readonly int s_long = PropertyStore.CreateKey();
-    private static readonly int s_ulong = PropertyStore.CreateKey();
-    private static readonly int s_short = PropertyStore.CreateKey();
-    private static readonly int s_ushort = PropertyStore.CreateKey();
-    private static readonly int s_object = PropertyStore.CreateKey();
-    private static readonly int s_color = PropertyStore.CreateKey();
-    private static readonly int s_formWindowState = PropertyStore.CreateKey();
-
-    public static IEnumerable<object[]> PropertyStore_TryGetValue_Exists_TestData()
-    {
-        yield return new object[] { s_bool, true };
-        yield return new object[] { s_byte, (byte)1 };
-        yield return new object[] { s_sbyte, (sbyte)-1 };
-        yield return new object[] { s_char, 'a' };
-        yield return new object[] { s_decimal, 1.0m };
-        yield return new object[] { s_double, 1.0d };
-        yield return new object[] { s_float, 1.0f };
-        yield return new object[] { s_int, 1 };
-        yield return new object[] { s_uint, (uint)1 };
-        yield return new object[] { s_long, 1L };
-        yield return new object[] { s_ulong, 1UL };
-        yield return new object[] { s_short, (short)1 };
-        yield return new object[] { s_ushort, (ushort)1 };
-        yield return new object[] { s_object, new object() };
-        yield return new object[] { s_color, Color.Red };
-        yield return new object[] { s_formWindowState, FormWindowState.Maximized };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PropertyStore_TryGetValue_Exists_TestData))]
-    public void PropertyStore_TryGetValue_Exists(int key, object? value)
-    {
-        PropertyStore store = new();
-        store.SetObject(key, value);
-        Assert.True(store.ContainsObject(key), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(key, out object? outValue));
-        Assert.Equal(value, outValue);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PropertyStore_TryGetValue_Exists_TestData))]
-    public void PropertyStore_TryGetValue_Exists_Null(int key, object? value)
-    {
-        PropertyStore store = new();
-        store.SetObject(key, null);
-        Assert.True(store.ContainsObject(key), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(key, out object? outValue));
-        Assert.NotEqual(value, outValue);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PropertyStore_TryGetValue_Exists_TestData))]
-    public void PropertyStore_TryGetValue_NotExists(int key, object? value)
-    {
-        PropertyStore store = new();
-        store.SetObject(key, null);
-        store.RemoveObject(key);
-        Assert.False(store.ContainsObject(key), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(key, out object? outValue), "PropertyStore contains key.");
-        Assert.NotEqual(value, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Enum_Unset_IsDefault()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_formWindowState), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(s_formWindowState, out FormWindowState outValue), "PropertyStore contains key.");
-        FormWindowState windowState = default;
-        Assert.Equal(windowState, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Struct_Unset_IsDefault()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_color), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(s_color, out Color outValue), "PropertyStore contains key.");
-        Color color = default;
-        Assert.Equal(color, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Primitive_Unset_IsDefault()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_int), "PropertyStore does not contain key.");
-        Assert.False(store.TryGetObject(s_int, out int outValue), "PropertyStore contains key.");
-        int intDefault = default;
-        Assert.Equal(intDefault, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Enum_Null()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_formWindowState, null);
-        Assert.True(store.ContainsObject(s_formWindowState), "PropertyStore contains key.");
-        Assert.True(store.TryGetObject(s_formWindowState, out FormWindowState outValue), "PropertyStore contains key.");
-        FormWindowState windowState = default;
-        Assert.Equal(windowState, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Struct_Null()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_color, null);
-        Assert.True(store.ContainsObject(s_color), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(s_color, out Color outValue), "PropertyStore does not contain key.");
-        Color color = default;
-        Assert.Equal(color, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Primitive_Null()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_int, null);
-        Assert.True(store.ContainsObject(s_int), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(s_int, out int outValue), "PropertyStore does not contain key.");
-        int intDefault = default;
-        Assert.Equal(intDefault, outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Enum_Nullable()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_formWindowState, null);
-        Assert.True(store.ContainsObject(s_formWindowState), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(s_formWindowState, out FormWindowState? outValue), "PropertyStore does not contain key.");
-        Assert.Null(outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Struct_Nullable()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_color, null);
-        Assert.True(store.ContainsObject(s_color), "PropertyStore does not contain key.");
-        Assert.True(store.TryGetObject(s_color, out Color? outValue), "PropertyStore does not contain key.");
-        Assert.Null(outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Primitive_Nullable()
-    {
-        PropertyStore store = new();
-        store.SetObject(s_int, null);
-        Assert.True(store.ContainsObject(s_int), "PropertyStore contains key.");
-        Assert.True(store.TryGetObject(s_int, out int? outValue), "PropertyStore contains key.");
-        Assert.Null(outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Enum_Unset_Nullable()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_formWindowState), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(s_formWindowState, out FormWindowState? outValue), "PropertyStore contains key.");
-        Assert.Null(outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Struct_Unset_Nullable()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_color), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(s_color, out Color? outValue), "PropertyStore contains key.");
-        Assert.Null(outValue);
-    }
-
-    [WinFormsFact]
-    public void PropertyStore_TryGetValue_Primitive_Unset_Nullable()
-    {
-        PropertyStore store = new();
-        Assert.False(store.ContainsObject(s_int), "PropertyStore contains key.");
-        Assert.False(store.TryGetObject(s_int, out int? outValue), "PropertyStore contains key.");
-        Assert.Null(outValue);
-    }
-}
-
-
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyTabChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyTabChangedEventArgsTests.cs
deleted file mode 100644
index 25a47eb9349..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyTabChangedEventArgsTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Design;
-using System.Windows.Forms.PropertyGridInternal;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertyTabChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_PropertyTab_PropertyTab_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new EventsTab(null), new PropertiesTab() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_PropertyTab_PropertyTab_TestData))]
-    public void Ctor_PropertyTab_PropertyTab(PropertyTab oldTab, PropertyTab newTab)
-    {
-        var e = new PropertyTabChangedEventArgs(oldTab, newTab);
-        Assert.Equal(oldTab, e.OldTab);
-        Assert.Equal(newTab, e.NewTab);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyValueChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyValueChangedEventArgsTests.cs
deleted file mode 100644
index c00f32df6c5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/PropertyValueChangedEventArgsTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class PropertyValueChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_GridItem_Object_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new SubGridItem(), 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_GridItem_Object_TestData))]
-    public void Ctor_GridItem_Object(GridItem changedItem, object oldValue)
-    {
-        var e = new PropertyValueChangedEventArgs(changedItem, oldValue);
-        Assert.Equal(changedItem, e.ChangedItem);
-        Assert.Equal(oldValue, e.OldValue);
-    }
-
-    private class SubGridItem : GridItem
-    {
-        public override GridItemCollection GridItems { get; }
-
-        public override GridItemType GridItemType { get; }
-
-        public override string Label { get; }
-
-        public override GridItem Parent { get; }
-
-        public override PropertyDescriptor PropertyDescriptor { get; }
-
-        public override object Value { get; }
-
-        public override bool Select() => false;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryAccessibilityHelpEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryAccessibilityHelpEventArgsTests.cs
deleted file mode 100644
index 279eda0cbbe..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryAccessibilityHelpEventArgsTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class QueryAccessibilityHelpEventArgsTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var e = new QueryAccessibilityHelpEventArgs();
-        Assert.Null(e.HelpNamespace);
-        Assert.Null(e.HelpString);
-        Assert.Null(e.HelpKeyword);
-    }
-
-    [Theory]
-    [InlineData(null, null, null)]
-    [InlineData("", "", "")]
-    [InlineData("helpNamespace", "helpString", "helpKeyword")]
-    public void Ctor_String_String_String(string helpNamespace, string helpString, string helpKeyword)
-    {
-        var e = new QueryAccessibilityHelpEventArgs(helpNamespace, helpString, helpKeyword);
-        Assert.Equal(helpNamespace, e.HelpNamespace);
-        Assert.Equal(helpString, e.HelpString);
-        Assert.Equal(helpKeyword, e.HelpKeyword);
-    }
-
-    public static IEnumerable<object[]> String_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { "" };
-        yield return new object[] { "value" };
-    }
-
-    [Theory]
-    [MemberData(nameof(String_TestData))]
-    public void HelpNamespace_Set_GetReturnsExpected(string value)
-    {
-        var e = new QueryAccessibilityHelpEventArgs("helpNamespace", "helpString", "helpKeyword")
-        {
-            HelpNamespace = value
-        };
-        Assert.Equal(value, e.HelpNamespace);
-    }
-
-    [Theory]
-    [MemberData(nameof(String_TestData))]
-    public void HelpString_Set_GetReturnsExpected(string value)
-    {
-        var e = new QueryAccessibilityHelpEventArgs("helpNamespace", "helpString", "helpKeyword")
-        {
-            HelpString = value
-        };
-        Assert.Equal(value, e.HelpString);
-    }
-
-    [Theory]
-    [MemberData(nameof(String_TestData))]
-    public void HelpKeyword_Set_GetReturnsExpected(string value)
-    {
-        var e = new QueryAccessibilityHelpEventArgs("helpNamespace", "helpString", "helpKeyword")
-        {
-            HelpKeyword = value
-        };
-        Assert.Equal(value, e.HelpKeyword);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryContinueDragEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryContinueDragEventArgsTests.cs
deleted file mode 100644
index 8c9429453f0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QueryContinueDragEventArgsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class QueryContinueDragEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, false, (DragAction)(DragAction.Continue - 1))]
-    [InlineData(0, true, DragAction.Drop)]
-    public void Ctor_Int_Bool_DragAction(int keyState, bool escapePressed, DragAction action)
-    {
-        var e = new QueryContinueDragEventArgs(keyState, escapePressed, action);
-        Assert.Equal(keyState, e.KeyState);
-        Assert.Equal(escapePressed, e.EscapePressed);
-        Assert.Equal(action, e.Action);
-    }
-
-    [Theory]
-    [InlineData((DragAction)(DragAction.Continue - 1))]
-    [InlineData(DragAction.Drop)]
-    public void Action_Set_GetReturnsExpected(DragAction value)
-    {
-        var e = new QueryContinueDragEventArgs(1, false, DragAction.Continue)
-        {
-            Action = value
-        };
-        Assert.Equal(value, e.Action);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QuestionEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QuestionEventArgsTests.cs
deleted file mode 100644
index 255e8f0e7b8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/QuestionEventArgsTests.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class QuestionEventArgsTests
-{
-    [Fact]
-    public void Ctor_Default()
-    {
-        var e = new QuestionEventArgs();
-        Assert.False(e.Response);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Ctor_Bool(bool response)
-    {
-        var e = new QuestionEventArgs(response);
-        Assert.Equal(response, e.Response);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Response_Set_GetReturnsExpected(bool value)
-    {
-        var e = new QuestionEventArgs(!value)
-        {
-            Response = value
-        };
-        Assert.Equal(value, e.Response);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButton.RadioButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButton.RadioButtonAccessibleObjectTests.cs
deleted file mode 100644
index 12dcb3a673d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButton.RadioButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,222 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-using RadioButtonAccessibleObject = System.Windows.Forms.RadioButton.RadioButtonAccessibleObject;
-
-namespace System.Windows.Forms.Tests;
-
-public class RadioButton_RadioButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>(() => new RadioButtonAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Ctor_Default()
-    {
-        using var radioButton = new RadioButton();
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.NotNull(radioButtonAccessibleObject.Owner);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton
-        {
-            AccessibleDefaultActionDescription = "TestActionDescription"
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal("TestActionDescription", radioButtonAccessibleObject.DefaultAction);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_GetProperyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton
-        {
-            AccessibleDefaultActionDescription = "TestActionDescription"
-        };
-
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal("TestActionDescription", radioButtonAccessibleObject.GetPropertyValue(UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Description_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton
-        {
-            AccessibleDescription = "TestDescription"
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal("TestDescription", radioButtonAccessibleObject.Description);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Name_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton
-        {
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal("TestName", radioButtonAccessibleObject.Name);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Role_Custom_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton
-        {
-            AccessibleRole = AccessibleRole.PushButton
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal(AccessibleRole.PushButton, radioButtonAccessibleObject.Role);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButtonAccessibleObject_Role_Default_ReturnsExpected()
-    {
-        using var radioButton = new RadioButton();
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.Equal(AccessibleRole.RadioButton, radioButtonAccessibleObject.Role);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleStates.Focusable, AccessibleStates.Focusable | AccessibleStates.Checked)]
-    [InlineData(false, AccessibleStates.None, AccessibleStates.None)]
-    public void RadioButtonAccessibleObject_State_ReturnsExpected(bool createControl, AccessibleStates accessibleStatesFirstStage, AccessibleStates accessibleStatesSecondStage)
-    {
-        using var radioButton = new RadioButton();
-
-        if (createControl)
-        {
-            radioButton.CreateControl();
-        }
-
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-        Assert.Equal(accessibleStatesFirstStage, radioButtonAccessibleObject.State);
-
-        radioButtonAccessibleObject.DoDefaultAction();
-
-        Assert.Equal(accessibleStatesSecondStage, radioButtonAccessibleObject.State);
-        Assert.Equal(createControl, radioButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void RadioButtonAccessibleObject_IsItemSelected_ReturnsExpected(bool createControl)
-    {
-        using var radioButton = new RadioButton();
-
-        if (createControl)
-        {
-            radioButton.CreateControl();
-        }
-
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-        Assert.False(radioButtonAccessibleObject.IsItemSelected);
-
-        radioButtonAccessibleObject.DoDefaultAction();
-
-        Assert.Equal(createControl, radioButtonAccessibleObject.IsItemSelected);
-        Assert.Equal(createControl, radioButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.RadioButtonControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "RadioButton1")]
-    public void RadioButtonAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var radioButton = new RadioButton
-        {
-            Name = "RadioButton1",
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-        object value = radioButtonAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.LegacyIAccessiblePatternId)]
-    [InlineData((int)UIA.SelectionItemPatternId)]
-    public void RadioButtonAccessibleObject_IsPatternSupported_Invoke_ReturnsExpected(int patternId)
-    {
-        using var radioButton = new RadioButton
-        {
-            Name = "RadioButton1"
-        };
-
-        Assert.False(radioButton.IsHandleCreated);
-        var radioButtonAccessibleObject = new RadioButtonAccessibleObject(radioButton);
-
-        Assert.True(radioButtonAccessibleObject.IsPatternSupported((UIA)patternId));
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RadioButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RadioButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void RadioButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using RadioButton radioButton = new RadioButton();
-        radioButton.AccessibleRole = role;
-
-        object actual = radioButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButtonTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButtonTests.cs
deleted file mode 100644
index 2942529e713..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RadioButtonTests.cs
+++ /dev/null
@@ -1,1627 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop.UiaCore;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class RadioButtonTests
-{
-    [WinFormsFact]
-    public void RadioButton_Ctor_Default()
-    {
-        using var control = new SubRadioButton();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(Appearance.Normal, control.Appearance);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.True(control.AutoCheck);
-        Assert.False(control.AutoEllipsis);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(24, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(ContentAlignment.MiddleLeft, control.CheckAlign);
-        Assert.False(control.Checked);
-        Assert.Equal(new Size(104, 24), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(104, 24), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 104, 24), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.True(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.NotNull(control.FlatAppearance);
-        Assert.Same(control.FlatAppearance, control.FlatAppearance);
-        Assert.Equal(FlatStyle.Standard, control.FlatStyle);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(24, control.Height);
-        Assert.Null(control.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, control.ImageAlign);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsDefault);
-        Assert.False(control.IsMirrored);
-        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("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(14, 13), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(104, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(104, 24), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ContentAlignment.MiddleLeft, control.TextAlign);
-        Assert.Equal(TextImageRelation.Overlay, control.TextImageRelation);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.True(control.UseCompatibleTextRendering);
-        Assert.True(control.UseMnemonic);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(104, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubRadioButton();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(24, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x5600000B, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x5600000B)]
-    [InlineData(false, 0x5600000B)]
-    public void RadioButton_CreateParams_GetUserPaint_ReturnsExpected(bool userPaint, int expectedStyle)
-    {
-        using var control = new SubRadioButton();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Button", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(24, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void RadioButton_CheckAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new RadioButton();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.CheckAlign = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RadioRadioButton_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RadioButton
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RadioRadioButton_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RadioRadioButton_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new RadioButton
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> TextAlign_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-            {
-                foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-                {
-                    yield return new object[] { autoSize, flatStyle, value };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_Set_TestData))]
-    public void RadioRadioButton_TextAlign_Set_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value)
-    {
-        using var control = new SubRadioButton
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextAlign_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (ContentAlignment value in Enum.GetValues(typeof(ContentAlignment)))
-            {
-                int expectedCallCount = value == ContentAlignment.MiddleLeft ? 0 : 1;
-                yield return new object[] { autoSize, FlatStyle.Flat, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.Popup, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.Standard, value, expectedCallCount, 0 };
-                yield return new object[] { autoSize, FlatStyle.System, value, expectedCallCount, expectedCallCount };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextAlign_SetWithHandle_TestData))]
-    public void RadioRadioButton_TextAlign_SetWithHandle_GetReturnsExpected(bool autoSize, FlatStyle flatStyle, ContentAlignment value, int expectedInvalidatedCallCount, int expectedStyleChangedCallCount)
-    {
-        using var control = new SubRadioButton
-        {
-            AutoSize = autoSize,
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    public void RadioRadioButton_TextAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var control = new SubRadioButton();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextAlign = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_Invoke_ReturnsExpected_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        control.CreateControl();
-        Assert.True(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.True(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.Focusable, instance.State);
-        Assert.Equal(AccessibleRole.RadioButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_Invoke_ReturnsExpected_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        Assert.False(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.False(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.None, instance.State);
-        Assert.Equal(AccessibleRole.RadioButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle,
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-
-        control.CreateControl();
-        Assert.True(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.True(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.Focusable, instance.State);
-        Assert.Equal(AccessibleRole.HelpBalloon, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle,
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-
-        Assert.False(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.False(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.None, instance.State);
-        Assert.Equal(AccessibleRole.HelpBalloon, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [InlineData(FlatStyle.Flat, "", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Popup, "", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Standard, "", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.System, "", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Flat, "Description", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Popup, "Description", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Standard, "Description", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.System, "Description", true, AccessibleStates.Focusable)]
-    [InlineData(FlatStyle.Flat, "", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Popup, "", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Standard, "", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.System, "", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Flat, "Description", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Popup, "Description", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.Standard, "Description", false, AccessibleStates.None)]
-    [InlineData(FlatStyle.System, "Description", false, AccessibleStates.None)]
-    public void RadioButton_CreateAccessibilityInstance_InvokeWithCustomDefaultActionDescription_ReturnsExpected(FlatStyle flatStyle, string defaultActionDescription, bool createControl, AccessibleStates expectedAccessibleStates)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle,
-            AccessibleDefaultActionDescription = defaultActionDescription
-        };
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(defaultActionDescription, instance.DefaultAction);
-        Assert.Equal(expectedAccessibleStates, instance.State);
-        Assert.Equal(AccessibleRole.RadioButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeChecked_ReturnsExpected_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle,
-            Checked = true
-        };
-
-        control.CreateControl();
-        Assert.True(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.True(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.Focusable | AccessibleStates.Checked, instance.State);
-        Assert.Equal(AccessibleRole.RadioButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeChecked_ReturnsExpected_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle,
-            Checked = true
-        };
-
-        Assert.False(control.IsHandleCreated);
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.False(control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.NotEmpty(instance.DefaultAction);
-        Assert.Equal(AccessibleStates.Checked, instance.State);
-        Assert.Equal(AccessibleRole.RadioButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeDoDefaultAction_CallsOnClick_IfHandleIsCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        control.CreateControl();
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        instance.DoDefaultAction();
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<FlatStyle>]
-    public void RadioButton_CreateAccessibilityInstance_InvokeDoDefaultAction_CallsOnClick_IfHandleIsNotCreated(FlatStyle flatStyle)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-
-        int callCount = 0;
-        control.Click += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        RadioButton.RadioButtonAccessibleObject instance = Assert.IsType<RadioButton.RadioButtonAccessibleObject>(control.CreateAccessibilityInstance());
-        instance.DoDefaultAction();
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubRadioButton();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, true)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, true)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void RadioButton_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubRadioButton();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void RadioButton_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubRadioButton();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnCheckedChanged_Invoke_CallsCheckedChanged(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CheckedChanged += handler;
-        control.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.CheckedChanged -= handler;
-        control.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnCheckedChanged_InvokeWithHandle_CallsCheckedChanged(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CheckedChanged += handler;
-        control.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.CheckedChanged -= handler;
-        control.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnClick_TestData()
-    {
-        foreach (bool autoCheck in new bool[] { true, false })
-        {
-            yield return new object[] { autoCheck, null };
-            yield return new object[] { autoCheck, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnClick_TestData))]
-    public void RadioButton_OnClick_Invoke_CallsClick(bool autoCheck, EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton
-        {
-            AutoCheck = autoCheck
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(autoCheck, control.Checked);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoCheck, control.Checked);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoCheck, control.Checked);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnClick_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnClick_WithHandle_TestData))]
-    public void RadioButton_OnClick_InvokeWithHandle_CallsClick(bool autoCheck, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubRadioButton
-        {
-            AutoCheck = autoCheck
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(autoCheck, control.Checked);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoCheck, control.Checked);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(autoCheck, control.Checked);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnEnter_InvokeWithHandle_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(invalidatedCallCount >= 0);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(invalidatedCallCount >= 0);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RadioButton_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void RadioButton_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void RadioButton_OnMouseUp_Invoke_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_MouseDown_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            bool expectedIsHandleCreated = flatStyle != FlatStyle.System;
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), expectedIsHandleCreated };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), expectedIsHandleCreated };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), false };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4), false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_MouseDown_TestData))]
-    public void RadioButton_OnMouseUp_InvokeMouseDown_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs, bool expectedIsHandleCreated)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void RadioButton_OnMouseUp_InvokeWithHandle_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_WithHandle_TestData()
-    {
-        foreach (FlatStyle flatStyle in Enum.GetValues(typeof(FlatStyle)))
-        {
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new MouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.None, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-            yield return new object[] { flatStyle, new HandledMouseEventArgs(MouseButtons.Right, 1, 2, 3, 4) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_WithHandle_TestData))]
-    public void RadioButton_OnMouseUp_InvokeMouseDownWithHandle_CallsMouseUp(FlatStyle flatStyle, MouseEventArgs eventArgs)
-    {
-        using var control = new SubRadioButton
-        {
-            FlatStyle = flatStyle
-        };
-        control.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_OnMouseUp_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubRadioButton();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null));
-    }
-
-    [WinFormsFact]
-    public void RadioButton_PerformClick_Invoke_CallsClick()
-    {
-        using var control = new SubRadioButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_PerformClick_InvokeWithHandle_CallsClick()
-    {
-        using var control = new SubRadioButton();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a', false)]
-    [InlineData(true, "", char.MinValue, false)]
-    [InlineData(true, "&a", 'a', true)]
-    [InlineData(true, "&a", 'b', false)]
-    [InlineData(true, "&&a", 'a', false)]
-    [InlineData(true, "&", 'a', false)]
-    [InlineData(true, "text", 'a', false)]
-    [InlineData(false, "", 'a', false)]
-    [InlineData(false, "", char.MinValue, false)]
-    [InlineData(false, "&a", 'a', false)]
-    [InlineData(false, "&a", 'b', false)]
-    [InlineData(false, "&&a", 'a', false)]
-    [InlineData(false, "&", 'a', false)]
-    [InlineData(false, "text", 'a', false)]
-    public void RadioButton_ProcessMnemonic_Invoke_ReturnsExpected(bool useMnemonic, string text, char charCode, bool expected)
-    {
-        using var control = new SubRadioButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        Assert.Equal(expected, control.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a')]
-    [InlineData(true, "", char.MinValue)]
-    [InlineData(true, "&a", 'a')]
-    [InlineData(true, "&a", 'b')]
-    [InlineData(true, "&&a", 'a')]
-    [InlineData(true, "&", 'a')]
-    [InlineData(true, "text", 'a')]
-    [InlineData(false, "", 'a')]
-    [InlineData(false, "", char.MinValue)]
-    [InlineData(false, "&a", 'a')]
-    [InlineData(false, "&a", 'b')]
-    [InlineData(false, "&&a", 'a')]
-    [InlineData(false, "&", 'a')]
-    [InlineData(false, "text", 'a')]
-    public void RadioButton_ProcessMnemonic_InvokeCantProcessMnemonic_ReturnsFalse(bool useMnemonic, string text, char charCode)
-    {
-        using var control = new SubRadioButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text,
-            Enabled = false
-        };
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        Assert.False(control.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a', false)]
-    [InlineData(true, "", char.MinValue, false)]
-    [InlineData(true, "&a", 'a', true)]
-    [InlineData(true, "&a", 'b', false)]
-    [InlineData(true, "&&a", 'a', false)]
-    [InlineData(true, "&", 'a', false)]
-    [InlineData(true, "text", 'a', false)]
-    [InlineData(false, "", 'a', false)]
-    [InlineData(false, "", char.MinValue, false)]
-    [InlineData(false, "&a", 'a', false)]
-    [InlineData(false, "&a", 'b', false)]
-    [InlineData(false, "&&a", 'a', false)]
-    [InlineData(false, "&", 'a', false)]
-    [InlineData(false, "text", 'a', false)]
-    public void RadioButton_ProcessMnemonic_InvokeWithHandle_ReturnsExpected(bool useMnemonic, string text, char charCode, bool expected)
-    {
-        using var control = new SubRadioButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-
-        Assert.Equal(expected, control.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "", 'a')]
-    [InlineData(true, "", char.MinValue)]
-    [InlineData(true, "&a", 'a')]
-    [InlineData(true, "&a", 'b')]
-    [InlineData(true, "&&a", 'a')]
-    [InlineData(true, "&", 'a')]
-    [InlineData(true, "text", 'a')]
-    [InlineData(false, "", 'a')]
-    [InlineData(false, "", char.MinValue)]
-    [InlineData(false, "&a", 'a')]
-    [InlineData(false, "&a", 'b')]
-    [InlineData(false, "&&a", 'a')]
-    [InlineData(false, "&", 'a')]
-    [InlineData(false, "text", 'a')]
-    public void RadioButton_ProcessMnemonic_InvokeCantProcessMnemonicWithHandle_ReturnsFalse(bool useMnemonic, string text, char charCode)
-    {
-        using var control = new SubRadioButton
-        {
-            UseMnemonic = useMnemonic,
-            Text = text,
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        Assert.False(control.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_RaiseAutomationEvent_Invoke_Success()
-    {
-        using var radioButton = new TestRadioButton();
-        Assert.False(radioButton.IsHandleCreated);
-
-        var accessibleObject = (SubRadioButtonAccessibleObject)radioButton.AccessibilityObject;
-        Assert.Equal(0, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(0, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-
-        radioButton.PerformClick();
-
-        Assert.Equal(1, accessibleObject.RaiseAutomationEventCallsCount);
-        Assert.Equal(1, accessibleObject.RaiseAutomationPropertyChangedEventCallsCount);
-        Assert.False(radioButton.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void RadioButton_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubRadioButton();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RadioButton_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new RadioButton();
-        Assert.Equal("System.Windows.Forms.RadioButton, Checked: False", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void RadioButton_ToString_InvokeShortText_ReturnsExpected()
-    {
-        using var control = new RadioButton
-        {
-            Text = "Text"
-        };
-        Assert.Equal("System.Windows.Forms.RadioButton, Checked: False", control.ToString());
-    }
-
-    private class SubRadioButton : RadioButton
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsHandleCreated => base.IsHandleCreated;
-
-        public new bool IsDefault
-        {
-            get => base.IsDefault;
-            set => base.IsDefault = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void CreateControl() => base.CreateControl();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnCheckedChanged(EventArgs e) => base.OnCheckedChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(MouseEventArgs eventargs) => base.OnMouseDown(eventargs);
-
-        public new void OnMouseUp(MouseEventArgs eventargs) => base.OnMouseUp(eventargs);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    private class TestRadioButton : RadioButton
-    {
-        protected override AccessibleObject CreateAccessibilityInstance()
-        {
-            return new SubRadioButtonAccessibleObject(this);
-        }
-    }
-
-    private class SubRadioButtonAccessibleObject : RadioButton.RadioButtonAccessibleObject
-    {
-        public SubRadioButtonAccessibleObject(RadioButton owner) : base(owner)
-        {
-            RaiseAutomationEventCallsCount = 0;
-            RaiseAutomationPropertyChangedEventCallsCount = 0;
-        }
-
-        public int RaiseAutomationEventCallsCount { get; private set; }
-
-        public int RaiseAutomationPropertyChangedEventCallsCount { get; private set; }
-
-        internal override bool RaiseAutomationEvent(UIA eventId)
-        {
-            RaiseAutomationEventCallsCount++;
-            return base.RaiseAutomationEvent(eventId);
-        }
-
-        internal override bool RaiseAutomationPropertyChangedEvent(UIA propertyId, object oldValue, object newValue)
-        {
-            RaiseAutomationPropertyChangedEventCallsCount++;
-            return base.RaiseAutomationPropertyChangedEvent(propertyId, oldValue, newValue);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RetrieveVirtualItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RetrieveVirtualItemEventArgsTests.cs
deleted file mode 100644
index 26a398b6f4d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RetrieveVirtualItemEventArgsTests.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class RetrieveVirtualItemEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int itemIndex)
-    {
-        var e = new RetrieveVirtualItemEventArgs(itemIndex);
-        Assert.Equal(itemIndex, e.ItemIndex);
-        Assert.Null(e.Item);
-    }
-
-    public static IEnumerable<object[]> Item_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ListViewItem() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Item_TestData))]
-    public void Item_Set_GetReturnsExpected(ListViewItem value)
-    {
-        var e = new RetrieveVirtualItemEventArgs(1)
-        {
-            Item = value
-        };
-        Assert.Equal(value, e.Item);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RichTextBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RichTextBoxTests.cs
deleted file mode 100644
index bc474b417f2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RichTextBoxTests.cs
+++ /dev/null
@@ -1,10835 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Windows.Forms.Automation;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using Moq.Protected;
-using Windows.Win32.System.Ole;
-using Windows.Win32.UI.Controls.RichEdit;
-using static Interop;
-using static Interop.Richedit;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class RichTextBoxTests
-{
-    private static int s_preferredHeight = Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3;
-
-    [WinFormsFact]
-    public void RichTextBox_Ctor_Default()
-    {
-        using var control = new SubRichTextBox();
-        Assert.False(control.AcceptsTab);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.False(control.AutoWordSelection);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(96, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 96), control.Bounds);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanRedo);
-        Assert.True(control.CanSelect);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(96, 92), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 96, 92), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.IBeam, control.Cursor);
-        Assert.Same(Cursors.IBeam, 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(100, 96), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.True(control.DetectUrls);
-        Assert.Equal(new Rectangle(0, 0, 96, 92), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.EnableAutoDragDrop);
-        Assert.True(control.Enabled);
-        Assert.False(control.EnableAutoDragDrop);
-        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.False(control.HasChildren);
-        Assert.Equal(96, control.Height);
-        Assert.True(control.HideSelection);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(RichTextBoxLanguageOptions.AutoFont | RichTextBoxLanguageOptions.DualFont, control.LanguageOption);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Empty(control.Lines);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(int.MaxValue, control.MaxLength);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(control.Modified);
-        Assert.True(control.Multiline);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal(control.PreferredSize.Height, control.PreferredHeight);
-        Assert.Empty(control.RedoActionName);
-        Assert.False(control.ReadOnly);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.RightMargin);
-        Assert.True(control.RichTextShortcutsEnabled);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Null(control.Rtf);
-        Assert.Equal(RichTextBoxScrollBars.Both, control.ScrollBars);
-        Assert.Equal(Color.Empty, control.SelectionBackColor);
-        Assert.False(control.ShowSelectionMargin);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 96), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.Empty(control.UndoActionName);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(100, control.Width);
-        Assert.True(control.WordWrap);
-        Assert.Equal(1.0f, control.ZoomFactor);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubRichTextBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("RICHEDIT50W", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56210044, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56210044, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x56210044, 0x200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56210044, 0x200)]
-    public void RichTextBox_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubRichTextBox
-        {
-            BorderStyle = borderStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Equal("RICHEDIT50W", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, RichTextBoxScrollBars.Both, 0x56210044)]
-    [InlineData(true, true, RichTextBoxScrollBars.ForcedBoth, 0x56212044)]
-    [InlineData(true, true, RichTextBoxScrollBars.ForcedHorizontal, 0x56010044)]
-    [InlineData(true, true, RichTextBoxScrollBars.ForcedVertical, 0x56212044)]
-    [InlineData(true, true, RichTextBoxScrollBars.Horizontal, 0x56010044)]
-    [InlineData(true, true, RichTextBoxScrollBars.None, 0x56010044)]
-    [InlineData(true, true, RichTextBoxScrollBars.Vertical, 0x56210044)]
-    [InlineData(true, false, RichTextBoxScrollBars.Both, 0x563100C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.ForcedBoth, 0x563120C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.ForcedHorizontal, 0x561120C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.ForcedVertical, 0x562120C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.Horizontal, 0x561100C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.None, 0x560100C4)]
-    [InlineData(true, false, RichTextBoxScrollBars.Vertical, 0x562100C4)]
-    [InlineData(false, true, RichTextBoxScrollBars.Both, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.ForcedBoth, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.ForcedHorizontal, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.ForcedVertical, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.Horizontal, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.None, 0x560100C0)]
-    [InlineData(false, true, RichTextBoxScrollBars.Vertical, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.Both, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.ForcedBoth, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.ForcedHorizontal, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.ForcedVertical, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.Horizontal, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.None, 0x560100C0)]
-    [InlineData(false, false, RichTextBoxScrollBars.Vertical, 0x560100C0)]
-    public void RichTextBox_CreateParams_GetMultiline_ReturnsExpected(bool multiline, bool wordWrap, RichTextBoxScrollBars scrollBars, int expectedStyle)
-    {
-        using var control = new SubRichTextBox
-        {
-            Multiline = multiline,
-            WordWrap = wordWrap,
-            ScrollBars = scrollBars
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("RICHEDIT50W", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(96, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AllowDrop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AllowDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DropTargetMock dropTarget = new();
-        Assert.Equal(ApartmentState.STA, Application.OleRequired());
-        Assert.Equal(HRESULT.DRAGDROP_E_ALREADYREGISTERED, PInvoke.RegisterDragDrop(control, dropTarget));
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Theory]
-    [BoolData]
-    public void RichTextBox_AllowDrop_SetWithHandleNonSTAThread_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubRichTextBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AutoSize_SetNotMultiline_TestData()
-    {
-        yield return new object[] { true, s_preferredHeight, 96, 1 };
-        yield return new object[] { false, 96, s_preferredHeight, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoSize_SetNotMultiline_TestData))]
-    public void RichTextBox_AutoSize_SetNotMultiline_GetReturnsExpected(bool value, int expectedHeight, int expectedHeight2, int expectedLayoutCallCount)
-    {
-        using var control = new SubRichTextBox
-        {
-            Multiline = false
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(expectedHeight2, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AutoSize_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubRichTextBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new RichTextBox
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_AutoWordSelection_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.AutoWordSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_SETOPTIONS.
-        PInvoke.SendMessage(control, PInvoke.EM_SETOPTIONS, (WPARAM)(int)ECOOP.OR, (LPARAM)(int)ECO.AUTOWORDSELECTION);
-        Assert.False(control.AutoWordSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AutoWordSelection_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            AutoWordSelection = value
-        };
-        Assert.Equal(value, control.AutoWordSelection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoWordSelection = value;
-        Assert.Equal(value, control.AutoWordSelection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoWordSelection = !value;
-        Assert.Equal(!value, control.AutoWordSelection);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_AutoWordSelection_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoWordSelection = value;
-        Assert.Equal(value, control.AutoWordSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoWordSelection = value;
-        Assert.Equal(value, control.AutoWordSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoWordSelection = !value;
-        Assert.Equal(!value, control.AutoWordSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 65)]
-    [InlineData(false, 64)]
-    public void RichTextBox_AutoWordSelection_GetOptions_Success(bool value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AutoWordSelection = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETOPTIONS));
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void RichTextBox_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new RichTextBox
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void Control_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new Control();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void RichTextBox_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new RichTextBox
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void RichTextBox_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubRichTextBox
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2000)]
-    [InlineData(2001)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_BulletIndent_Set_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox
-        {
-            BulletIndent = value
-        };
-        Assert.Equal(value, control.BulletIndent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BulletIndent = value;
-        Assert.Equal(value, control.BulletIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2000)]
-    [InlineData(2001)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_BulletIndent_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BulletIndent = value;
-        Assert.Equal(value, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BulletIndent = value;
-        Assert.Equal(value, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_BulletIndent_SetSelectionBulletWithHandle_GetReturnsExpected(int value, int selectionHangingIndent)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SelectionBullet = true;
-
-        control.BulletIndent = value;
-        Assert.Equal(value, control.BulletIndent);
-        Assert.Equal(selectionHangingIndent, control.SelectionHangingIndent);
-        Assert.True(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BulletIndent = value;
-        Assert.Equal(value, control.BulletIndent);
-        Assert.Equal(selectionHangingIndent, control.SelectionHangingIndent);
-        Assert.True(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    public void RichTextBox_BulletIndent_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.BulletIndent = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanRedo_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.CanRedo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CanRedo_CustomCanRedo_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, false };
-        yield return new object[] { (IntPtr)1, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanRedo_CustomCanRedo_TestData))]
-    public void RichTextBox_CanRedo_CustomCanRedo_ReturnsExpected(IntPtr result, bool expected)
-    {
-        using var control = new CustomCanRedoRichTextBox
-        {
-            Result = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.CanRedo);
-    }
-
-    private class CustomCanRedoRichTextBox : RichTextBox
-    {
-        public IntPtr Result { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANREDO)
-            {
-                m.Result = Result;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanRedo_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.False(control.CanRedo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanRedo_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.False(control.CanRedo);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanUndo_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CanUndo_CustomCanUndo_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, false };
-        yield return new object[] { (IntPtr)1, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanUndo_CustomCanUndo_TestData))]
-    public void RichTextBox_CanUndo_CustomCanUndo_ReturnsExpected(IntPtr result, bool expected)
-    {
-        using var control = new CustomCanUndoRichTextBox
-        {
-            Result = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.CanUndo);
-    }
-
-    private class CustomCanUndoRichTextBox : RichTextBox
-    {
-        public IntPtr Result { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANUNDO)
-            {
-                m.Result = Result;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanUndo_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanUndo_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.False(control.CanUndo);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_DetectUrls_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.DetectUrls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_AUTOURLDETECT.
-        PInvoke.SendMessage(control, PInvoke.EM_AUTOURLDETECT, 0);
-        Assert.True(control.DetectUrls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_DetectUrls_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            DetectUrls = value
-        };
-        Assert.Equal(value, control.DetectUrls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DetectUrls = value;
-        Assert.Equal(value, control.DetectUrls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DetectUrls = !value;
-        Assert.Equal(!value, control.DetectUrls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void RichTextBox_DetectUrls_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DetectUrls = value;
-        Assert.Equal(value, control.DetectUrls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.DetectUrls = value;
-        Assert.Equal(value, control.DetectUrls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.DetectUrls = !value;
-        Assert.Equal(!value, control.DetectUrls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void RichTextBox_DetectUrls_GetAutoUrlDetect_Success(bool value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.DetectUrls = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETAUTOURLDETECT));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_EnableAutoDragDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            EnableAutoDragDrop = value
-        };
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_EnableAutoDragDrop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_EnableAutoDragDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DropTargetMock dropTarget = new();
-        Assert.Equal(ApartmentState.STA, Application.OleRequired());
-        Assert.Equal(HRESULT.DRAGDROP_E_ALREADYREGISTERED, PInvoke.RegisterDragDrop(control, dropTarget));
-
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [Theory]
-    [BoolData]
-    public void RichTextBox_EnableAutoDragDrop_SetWithHandleNonSTAThread_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.EnableAutoDragDrop = value;
-        Assert.Equal(value, control.EnableAutoDragDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void RichTextBox_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubRichTextBox
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void RichTextBox_Font_SetWithText_GetReturnsExpected(Font value)
-    {
-        using var control = new SubRichTextBox
-        {
-            Text = "text",
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void RichTextBox_Font_SetWithNonNullOldValue_GetReturnsExpected(Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubRichTextBox
-        {
-            Font = oldValue
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void RichTextBox_Font_SetWithNonNullOldValueWithText_GetReturnsExpected(Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubRichTextBox
-        {
-            Font = oldValue,
-            Text = "text"
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f), 1 };
-            yield return new object[] { userPaint, null, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void RichTextBox_Font_SetWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubRichTextBox();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void RichTextBox_Font_SetWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubRichTextBox
-        {
-            Text = "text"
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithNonNullOldValueWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f) };
-            yield return new object[] { userPaint, null };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
-    public void RichTextBox_Font_SetWithNonNullOldValueWithHandle_GetReturnsExpected(bool userPaint, Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubRichTextBox
-        {
-            Font = oldValue
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
-    public void RichTextBox_Font_SetWithNonNullOldValueWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubRichTextBox
-        {
-            Font = oldValue,
-            Text = "text"
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Font_GetCharFormat_TestData()
-    {
-        yield return new object[] { "Arial", 8.25f, FontStyle.Regular, GraphicsUnit.Point, 1, 165, 0 };
-        yield return new object[] { "Arial", 8.25f, FontStyle.Bold, GraphicsUnit.Point, 1, 165, CFE.BOLD };
-        yield return new object[] { "Arial", 8.25f, FontStyle.Italic, GraphicsUnit.Point, 1, 165, CFE.ITALIC };
-        yield return new object[] { "Arial", 8.25f, FontStyle.Strikeout, GraphicsUnit.Point, 1, 165, CFE.STRIKEOUT };
-        yield return new object[] { "Arial", 8.25f, FontStyle.Underline, GraphicsUnit.Point, 1, 165, CFE.UNDERLINE };
-        yield return new object[] { "Arial", 8.25f, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10, 165, CFE.BOLD | CFE.ITALIC | CFE.UNDERLINE | CFE.STRIKEOUT };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_GetCharFormat_TestData))]
-    public unsafe void RichTextBox_Font_GetCharFormat_Success(string familyName, float emSize, FontStyle style, GraphicsUnit unit, byte gdiCharSet, int expectedYHeight, int expectedEffects)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W),
-            dwMask = (CFM)int.MaxValue
-        };
-
-        nint result;
-
-        using (var font = new Font(familyName, emSize, style, unit, gdiCharSet))
-        {
-            control.Font = font;
-            result = PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.ALL, ref format);
-            Assert.NotEqual(0, result);
-            Assert.Equal(familyName, format.FaceName.ToString());
-            Assert.Equal(expectedYHeight, format.yHeight);
-            Assert.Equal(CFE.AUTOBACKCOLOR | CFE.AUTOCOLOR | (CFE)expectedEffects, format.dwEffects);
-            Assert.Equal(0, format.bPitchAndFamily);
-
-            // Set null.
-            control.Font = null;
-        }
-
-        var format1 = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W),
-            dwMask = (CFM)int.MaxValue
-        };
-
-        result = PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.ALL, ref format1);
-        Assert.NotEqual(0, result);
-        Assert.Equal(Control.DefaultFont.Name, format1.FaceName.ToString());
-        Assert.Equal((int)(Control.DefaultFont.SizeInPoints * 20), (int)format1.yHeight);
-        Assert.True(format1.dwEffects.HasFlag(CFE.AUTOBACKCOLOR));
-        Assert.True(format1.dwEffects.HasFlag(CFE.AUTOCOLOR));
-        Assert.Equal(0, format1.bPitchAndFamily);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void RichTextBox_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new RichTextBox
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void RichTextBox_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_ForeColor_GetCharFormat_Success()
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.ALL, ref format));
-        Assert.Equal(0x785634, format.crTextColor);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_ForeColor_GetCharFormatWithTextColor_Success()
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ForeColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.ALL, ref format));
-        Assert.Equal(0x785634, format.crTextColor);
-
-        // Set different.
-        control.ForeColor = Color.FromArgb(0x34, 0x56, 0x78, 0x90);
-        format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.ALL, ref format));
-        Assert.Equal(0x907856, format.crTextColor);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> LanguageOption_CustomGetLangOptions_TestData()
-    {
-        foreach (RichTextBoxLanguageOptions options in Enum.GetValues(typeof(RichTextBoxLanguageOptions)))
-        {
-            yield return new object[] { (IntPtr)options, options };
-        }
-
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)(-1), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LanguageOption_CustomGetLangOptions_TestData))]
-    public void RichTextBox_LanguageOption_CustomGetLangOptions_ReturnsExpected(IntPtr result, RichTextBoxLanguageOptions expected)
-    {
-        using var control = new CustomGetLangOptionsRichTextBox
-        {
-            GetLangOptionsResult = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.LanguageOption);
-    }
-
-    private class CustomGetLangOptionsRichTextBox : RichTextBox
-    {
-        public bool MakeCustom { get; set; }
-        public IntPtr GetLangOptionsResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.EM_GETLANGOPTIONS)
-            {
-                m.Result = GetLangOptionsResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<RichTextBoxLanguageOptions>]
-    public void RichTextBox_LanguageOption_Set_GetReturnsExpected(RichTextBoxLanguageOptions value)
-    {
-        using var control = new RichTextBox
-        {
-            LanguageOption = value
-        };
-        Assert.Equal(value, control.LanguageOption);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LanguageOption = value;
-        Assert.Equal(value, control.LanguageOption);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RichTextBoxLanguageOptions>]
-    public void RichTextBox_LanguageOption_SetWithHandle_GetReturnsExpected(RichTextBoxLanguageOptions value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LanguageOption = value;
-        Assert.Equal(value, control.LanguageOption);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LanguageOption = value;
-        Assert.Equal(value, control.LanguageOption);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RichTextBoxLanguageOptions>]
-    public unsafe void RichTextBox_LanguageOption_GetCharFormat_Success(RichTextBoxLanguageOptions value)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.LanguageOption = value;
-        Assert.Equal(value, (RichTextBoxLanguageOptions)(int)PInvoke.SendMessage(control, PInvoke.EM_GETLANGOPTIONS));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_MaxLength_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0x7FFFFFFF, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_LIMITTEXT.
-        PInvoke.SendMessage(control, PInvoke.EM_LIMITTEXT, 0, 1);
-        Assert.Equal(0x7FFFFFFF, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_EXLIMITTEXT.
-        PInvoke.SendMessage(control, PInvoke.EM_EXLIMITTEXT, 0, 2);
-        Assert.Equal(0x7FFFFFFF, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_MaxLength_Set_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox
-        {
-            MaxLength = value
-        };
-        Assert.Equal(value, control.MaxLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_MaxLength_SetWithLongText_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            MaxLength = 2
-        };
-        Assert.Equal(2, control.MaxLength);
-        Assert.Equal("Text", control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_MaxLength_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_MaxLength_SetWithLongTextWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = "Text";
-        control.MaxLength = 2;
-        Assert.Equal(2, control.MaxLength);
-        Assert.Equal("Text", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0x10000)]
-    [InlineData(1, 1)]
-    [InlineData(64000, 64000)]
-    [InlineData(0x7FFFFFFE, 0x7FFFFFFE)]
-    [InlineData(int.MaxValue, 0x7FFFFFFF)]
-    public void RichTextBox_MaxLength_GetLimitText_Success(int value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MaxLength = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETLIMITTEXT));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_MaxLength_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.MaxLength = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_Multiline_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubRichTextBox
-        {
-            AutoSize = false,
-            Multiline = value
-        };
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.Equal(96, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Multiline_SetAutoSize_TestData()
-    {
-        yield return new object[] { true, 96, s_preferredHeight };
-        yield return new object[] { false, s_preferredHeight, 96 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Multiline_SetAutoSize_TestData))]
-    public void RichTextBox_Multiline_SetAutoSize_GetReturnsExpected(bool value, int expectedHeight1, int expectedHeight2)
-    {
-        using var control = new SubRichTextBox
-        {
-            AutoSize = true,
-            Multiline = value
-        };
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedHeight1, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedHeight1, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.Equal(expectedHeight2, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_Multiline_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubRichTextBox
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.Multiline = !value;
-            Assert.Equal(!value, control.Multiline);
-            Assert.Equal(96, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Multiline_SetAutoSizeWithParent_TestData()
-    {
-        yield return new object[] { true, 96, 0, s_preferredHeight };
-        yield return new object[] { false, s_preferredHeight, 1, 96 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Multiline_SetAutoSizeWithParent_TestData))]
-    public void RichTextBox_Multiline_SetAutoSizeWithParent_GetReturnsExpected(bool value, int expectedHeight1, int expectedParentLayoutCallCount, int expectedHeight2)
-    {
-        using var parent = new Control();
-        using var control = new SubRichTextBox
-        {
-            AutoSize = true,
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(expectedHeight1, control.Height);
-            Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(expectedHeight1, control.Height);
-            Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.Multiline = !value;
-            Assert.Equal(!value, control.Multiline);
-            Assert.Equal(expectedHeight2, control.Height);
-            Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void RichTextBox_Multiline_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Multiline_SetWithHandler_CallsMultilineChanged()
-    {
-        using var control = new RichTextBox
-        {
-            Multiline = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.MultilineChanged += handler;
-
-        // Set different.
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Multiline = true;
-        Assert.True(control.Multiline);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.MultilineChanged -= handler;
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_RedoActionName_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Empty(control.RedoActionName);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> RedoActionName_CustomGetRedoName_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, IntPtr.Zero, string.Empty };
-        yield return new object[] { (IntPtr)1, IntPtr.Zero, "Unknown" };
-        yield return new object[] { (IntPtr)1, (IntPtr)1, "Typing" };
-        yield return new object[] { (IntPtr)1, (IntPtr)2, "Delete" };
-        yield return new object[] { (IntPtr)1, (IntPtr)3, "Drag and Drop" };
-        yield return new object[] { (IntPtr)1, (IntPtr)4, "Cut" };
-        yield return new object[] { (IntPtr)1, (IntPtr)5, "Paste" };
-        yield return new object[] { (IntPtr)1, (IntPtr)6, "Unknown" };
-        yield return new object[] { (IntPtr)1, (IntPtr)7, "Unknown" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RedoActionName_CustomGetRedoName_TestData))]
-    public void RichTextBox_RedoActionName_CustomGetRedoName_ReturnsExpected(IntPtr canRedoResult, IntPtr getRedoNameResult, string expected)
-    {
-        using var control = new CustomGetRedoNameRichTextBox
-        {
-            CanRedoResult = canRedoResult,
-            GetRedoNameResult = getRedoNameResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.RedoActionName);
-    }
-
-    private class CustomGetRedoNameRichTextBox : RichTextBox
-    {
-        public IntPtr CanRedoResult { get; set; }
-        public IntPtr GetRedoNameResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANREDO)
-            {
-                m.Result = CanRedoResult;
-                return;
-            }
-            else if (m.Msg == (int)PInvoke.EM_GETREDONAME)
-            {
-                m.Result = GetRedoNameResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_RedoActionName_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Empty(control.RedoActionName);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_RedoActionName_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Empty(control.RedoActionName);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_RichTextShortcutsEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            RichTextShortcutsEnabled = value
-        };
-        Assert.Equal(value, control.RichTextShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RichTextShortcutsEnabled = value;
-        Assert.Equal(value, control.RichTextShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RichTextShortcutsEnabled = !value;
-        Assert.Equal(!value, control.RichTextShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_RichTextShortcutsEnabled_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RichTextShortcutsEnabled = value;
-        Assert.Equal(value, control.RichTextShortcutsEnabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.RichTextShortcutsEnabled = value;
-        Assert.Equal(value, control.RichTextShortcutsEnabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.RichTextShortcutsEnabled = !value;
-        Assert.Equal(!value, control.RichTextShortcutsEnabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_RightMargin_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.RightMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_RightMargin_Set_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox
-        {
-            RightMargin = value
-        };
-        Assert.Equal(value, control.RightMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_RightMargin_SetWithCustomOldValue_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox
-        {
-            RightMargin = 1
-        };
-
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void RichTextBox_RightMargin_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 0)]
-    [InlineData(64000, 0)]
-    [InlineData(0x7FFFFFFE, 0)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_RightMargin_SetWithCustomOldValueWithHandle_GetReturnsExpected(int value, int expectedCreatedCallCount)
-    {
-        using var control = new RichTextBox
-        {
-            RightMargin = 1
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.RightMargin = value;
-        Assert.Equal(value, control.RightMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_RightMargin_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.RightMargin = -1);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string rtf1 = control.Rtf;
-        Assert.StartsWith("{\\rtf", rtf1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string rtf2 = control.Rtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.NotSame(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetWithPlainText_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text"
-        };
-        string rtf1 = control.Rtf;
-        Assert.Contains("Text", rtf1);
-        Assert.StartsWith("{\\rtf", rtf1);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        string rtf2 = control.Rtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.NotSame(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetWithPlainTextWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string rtf1 = control.Rtf;
-        Assert.Contains("Text", rtf1);
-        Assert.StartsWith("{\\rtf", rtf1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string rtf2 = control.Rtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.NotSame(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetCantCreateHandle_ReturnsNull()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Null(control.Rtf);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetDisposed_ReturnsNull()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Null(control.Rtf);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_GetDisposedWithText_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        control.Text = "text";
-        Assert.Throws<ObjectDisposedException>(() => control.Rtf);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_Rtf_Set_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1Hello World}"
-        };
-
-        string rtf = control.Rtf;
-        Assert.StartsWith("{\\rtf", rtf);
-        Assert.NotSame(rtf, control.Rtf);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-
-        control.Rtf = nullOrEmpty;
-        rtf = control.Rtf;
-        Assert.StartsWith("{\\rtf", rtf);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("{\\rtf1Hello World}", "Hello World")]
-    [InlineData(@"{\rtf1\ansi{Sample for {\v HIDDEN }text}}", "Sample for HIDDEN text")]
-    public void RichTextBox_Rtf_Set_GetTextExpected(string rtf, string plainText)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = rtf
-        };
-
-        string readRtf = control.Rtf;
-        Assert.StartsWith("{\\rtf", readRtf);
-        Assert.NotSame(readRtf, control.Rtf);
-        Assert.Equal(plainText, control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_Rtf_SetWithHandle_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Rtf = "{\\rtf1Hello World}";
-        string rtf = control.Rtf;
-        Assert.StartsWith("{\\rtf", rtf);
-        Assert.NotSame(rtf, control.Rtf);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Rtf = nullOrEmpty;
-        rtf = control.Rtf;
-        Assert.StartsWith("{\\rtf", rtf);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-
-        // Set same.
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(5, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(5, callCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_SetWithHandlerWithHandle_CallsTextChanged()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(4, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Rtf = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(6, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Rtf = "{\\rtf1text}";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(6, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Rtf_SetInvalidValue_ThrowsArgumentException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentException>(() => control.Rtf = "text");
-        Assert.True(control.IsHandleCreated);
-        Assert.DoesNotContain("text", control.Rtf);
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("{\\rtf Hello World}", "{\\rtf Hello World}")]
-    public void RichTextBox_Rtf_SetCantCreateHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.Rtf = value;
-        Assert.Equal(expected, control.Rtf);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Rtf = value;
-        Assert.Equal(expected, control.Rtf);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void RichTextBox_Rtf_SetDisposed_ThrowsObjectDisposedException(string value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.Rtf = value);
-    }
-
-    public static IEnumerable<object[]> ScrollBars_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            foreach (RichTextBoxScrollBars value in Enum.GetValues(typeof(RichTextBoxScrollBars)))
-            {
-                yield return new object[] { autoSize, value };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollBars_Set_TestData))]
-    public void RichTextBox_ScrollBars_Set_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value)
-    {
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.ScrollBars = value;
-        Assert.Equal(value, control.ScrollBars);
-        Assert.Equal(autoSize, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ScrollBars = value;
-        Assert.Equal(value, control.ScrollBars);
-        Assert.Equal(autoSize, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ScrollBars_SetWithParent_TestData()
-    {
-        yield return new object[] { false, RichTextBoxScrollBars.Both, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedBoth, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedHorizontal, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedVertical, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.Horizontal, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.None, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.Vertical, 0 };
-
-        yield return new object[] { true, RichTextBoxScrollBars.Both, 0 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedBoth, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedHorizontal, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedVertical, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.Horizontal, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.None, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.Vertical, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollBars_SetWithParent_TestData))]
-    public void RichTextBox_ScrollBars_SetWithParent_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("ScrollBars", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ScrollBars = value;
-            Assert.Equal(value, control.ScrollBars);
-            Assert.Equal(autoSize, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.ScrollBars = value;
-            Assert.Equal(value, control.ScrollBars);
-            Assert.Equal(autoSize, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> ScrollBars_SetWithHandle_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, RichTextBoxScrollBars.Both, 0, 0 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedBoth, 1, 1 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedHorizontal, 0, 1 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.ForcedVertical, 1, 1 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.Horizontal, 0, 1 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.None, 0, 1 };
-            yield return new object[] { autoSize, RichTextBoxScrollBars.Vertical, 0, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollBars_SetWithHandle_TestData))]
-    public void RichTextBox_ScrollBars_SetWithHandle_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedLayoutCallCount, int expectedCreatedCallCount)
-    {
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.ScrollBars = value;
-        Assert.Equal(value, control.ScrollBars);
-        Assert.Equal(autoSize, control.AutoSize);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.ScrollBars = value;
-        Assert.Equal(value, control.ScrollBars);
-        Assert.Equal(autoSize, control.AutoSize);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ScrollBars_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { false, RichTextBoxScrollBars.Both, 0, 0, 0 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedBoth, 1, 1, 1 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedHorizontal, 0, 0, 1 };
-        yield return new object[] { false, RichTextBoxScrollBars.ForcedVertical, 1, 1, 1 };
-        yield return new object[] { false, RichTextBoxScrollBars.Horizontal, 0, 0, 1 };
-        yield return new object[] { false, RichTextBoxScrollBars.None, 0, 0, 1 };
-        yield return new object[] { false, RichTextBoxScrollBars.Vertical, 0, 0, 1 };
-
-        yield return new object[] { true, RichTextBoxScrollBars.Both, 0, 0, 0 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedBoth, 1, 1, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedHorizontal, 0, 1, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.ForcedVertical, 1, 1, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.Horizontal, 0, 1, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.None, 0, 1, 1 };
-        yield return new object[] { true, RichTextBoxScrollBars.Vertical, 0, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollBars_SetWithParentWithHandle_TestData))]
-    public void RichTextBox_ScrollBars_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, RichTextBoxScrollBars value, int expectedLayoutCallCount, int expectedParentLayoutCallCount, int expectedCreatedCallCount)
-    {
-        using var parent = new Control();
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.ScrollBars = value;
-            Assert.Equal(value, control.ScrollBars);
-            Assert.Equal(autoSize, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-            // Set same.
-            control.ScrollBars = value;
-            Assert.Equal(value, control.ScrollBars);
-            Assert.Equal(autoSize, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(expectedCreatedCallCount, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RichTextBoxScrollBars>]
-    [InlineData(RichTextBoxScrollBars.Both + 1)]
-    [InlineData(RichTextBoxScrollBars.ForcedHorizontal - 1)]
-    public void RichTextBox_ScrollBars_SetInvalidValue_ThrowsInvalidEnumArgumentException(RichTextBoxScrollBars value)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ScrollBars = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_Get_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        string rtf1 = control.SelectedRtf;
-        Assert.Empty(rtf1);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        string rtf2 = control.SelectedRtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string rtf1 = control.SelectedRtf;
-        Assert.Empty(rtf1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string rtf2 = control.SelectedRtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_GetWithPlainText_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectedText = "ex"
-        };
-        string rtf1 = control.SelectedRtf;
-        Assert.Empty(rtf1);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        string rtf2 = control.SelectedRtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_GetWithPlainTextWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectedText = "ex"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string rtf1 = control.SelectedRtf;
-        Assert.Empty(rtf1);
-        Assert.DoesNotContain("ex", rtf1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string rtf2 = control.SelectedRtf;
-        Assert.Equal(rtf1, rtf2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Empty(control.SelectedRtf);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectedRtf);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_SelectedRtf_Set_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox
-        {
-            SelectedRtf = "{\\rtf1Hell}"
-        };
-
-        string rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        control.SelectedRtf = nullOrEmpty;
-        rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_SelectedRtf_SetWithHandle_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedRtf = "{\\rtf1Hell}";
-        string rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.SelectedRtf = nullOrEmpty;
-        rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_SelectedRtf_SetWithRtf_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1Hello World}",
-            SelectedRtf = "{\\rtf1Hell}"
-        };
-
-        string rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        control.SelectedRtf = nullOrEmpty;
-        rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void RichTextBox_SelectedRtf_SetWithRtfWithHandle_GetReturnsExpected(string nullOrEmpty)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1Hello World}"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedRtf = "{\\rtf1Hell}";
-        string rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.SelectedRtf = nullOrEmpty;
-        rtf = control.SelectedRtf;
-        Assert.Empty(rtf);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedRtf_SetInvalidValue_ThrowsArgumentException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentException>(() => control.SelectedRtf = "text");
-        Assert.True(control.IsHandleCreated);
-        Assert.DoesNotContain("text", control.Rtf);
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("{\\rtf Hello World}")]
-    public void RichTextBox_SelectedRtf_SetCantCreateHandle_GetReturnsExpected(string value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectedRtf = value;
-        Assert.Empty(control.SelectedRtf);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedRtf = value;
-        Assert.Empty(control.SelectedRtf);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void RichTextBox_SelectedRtf_SetDisposed_ThrowsObjectDisposedException(string value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectedRtf = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedText_Get_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        string text1 = control.SelectedText;
-        Assert.Empty(text1);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        string text2 = control.SelectedText;
-        Assert.Equal(text1, text2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedText_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string text1 = control.SelectedText;
-        Assert.Empty(text1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string text2 = control.SelectedText;
-        Assert.Equal(text1, text2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedText_GetWithPlainText_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectedText = "ex"
-        };
-        string text1 = control.SelectedText;
-        Assert.Empty(text1);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        string text2 = control.SelectedText;
-        Assert.Equal(text1, text2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedText_GetWithPlainTextWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectedText = "ex"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        string text1 = control.SelectedText;
-        Assert.Empty(text1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        string text2 = control.SelectedText;
-        Assert.Equal(text1, text2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectedText_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectedText);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void RichTextBox_SelectedText_Set_GetReturnsExpected(string value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectedText = value
-        };
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void RichTextBox_SelectedText_SetWithHandle_GetReturnsExpected(string value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void RichTextBox_SelectedText_SetWithRtf_GetReturnsExpected(string value)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1Hello World}",
-            SelectedText = value
-        };
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void RichTextBox_SelectedText_SetWithText_GetReturnsExpected(string value)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World",
-            SelectedText = value
-        };
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void RichTextBox_SelectedText_SetWithTextWithHandle_GetReturnsExpected(string value)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void RichTextBox_SelectedText_SetDisposed_ThrowsObjectDisposedException(string value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectedText = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionAlignment_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionAlignment_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionAlignment_CustomGetParamFormat_TestData()
-    {
-        yield return new object[] { 0, 0, HorizontalAlignment.Left };
-        yield return new object[] { 0, PFA.CENTER, HorizontalAlignment.Left };
-        yield return new object[] { PFM.ALIGNMENT, PFA.LEFT, HorizontalAlignment.Left };
-        yield return new object[] { PFM.ALIGNMENT, PFA.CENTER, HorizontalAlignment.Center };
-        yield return new object[] { PFM.ALIGNMENT, PFA.RIGHT, HorizontalAlignment.Right };
-        yield return new object[] { PFM.ALIGNMENT, PFA.JUSTIFY, HorizontalAlignment.Left };
-        yield return new object[] { PFM.ALIGNMENT, PFA.FULL_INTERWORD, HorizontalAlignment.Left };
-        yield return new object[] { PFM.ALIGNMENT | PFM.ALIGNMENT, PFA.CENTER, HorizontalAlignment.Center };
-        yield return new object[] { PFM.NUMBERING, PFA.CENTER, HorizontalAlignment.Left };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionAlignment_CustomGetParamFormat_TestData))]
-    public void RichTextBox_SelectionAlignment_CustomGetParaFormat_ReturnsExpected(uint mask, uint alignment, HorizontalAlignment expected)
-    {
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = new PARAFORMAT
-            {
-                dwMask = (PFM)mask,
-                wAlignment = (PFA)alignment
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionAlignment);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionAlignment_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionAlignment_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionAlignment);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void RichTextBox_SelectionAlignment_Set_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionAlignment = value
-        };
-        Assert.Equal(value, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionAlignment = value;
-        Assert.Equal(value, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void RichTextBox_SelectionAlignment_SetWithHandle_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionAlignment = value;
-        Assert.Equal(value, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionAlignment = value;
-        Assert.Equal(value, control.SelectionAlignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(HorizontalAlignment.Left, 1)]
-    [InlineData(HorizontalAlignment.Center, 3)]
-    [InlineData(HorizontalAlignment.Right, 2)]
-    public unsafe void RichTextBox_SelectionAlignment_GetCharFormat_Success(HorizontalAlignment value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            BulletIndent = 11,
-            SelectionHangingIndent = 10
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionAlignment = value;
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(expected, (int)format.wAlignment);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void RichTextBox_SelectionAlignment_SetInvalidValue_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.SelectionAlignment = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void RichTextBox_SelectionAlignment_SetCantCreateHandle_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionAlignment = value;
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionAlignment = value;
-        Assert.Equal(HorizontalAlignment.Left, control.SelectionAlignment);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void RichTextBox_SelectionAlignment_SetDisposed_ThrowsObjectDisposedException(HorizontalAlignment value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionAlignment = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBackColor_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(SystemColors.Window, control.SelectionBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionBackColor_CustomGetCharFormat_TestData()
-    {
-        yield return new object[] { 0, 0, 0x78563412, Color.Empty };
-        yield return new object[] { 0, CFE.AUTOBACKCOLOR, 0x78563412, Color.Red };
-        yield return new object[] { 0, CFE.AUTOBACKCOLOR | CFE.ALLCAPS, 0x78563412, Color.Red };
-        yield return new object[] { CFM.BACKCOLOR, 0, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { CFM.BACKCOLOR, 0, 0x785634, Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
-        yield return new object[] { CFM.BACKCOLOR | CFM.ANIMATION, 0, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { CFM.BACKCOLOR, CFE.AUTOBACKCOLOR, 0x78563412, Color.Red };
-        yield return new object[] { CFM.ALLCAPS, 0, 0x78563412, Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_CustomGetCharFormat_TestData))]
-    public void RichTextBox_SelectionBackColor_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, int backColor, Color expected)
-    {
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = new CHARFORMAT2W
-            {
-                dwMask = (CFM)mask,
-                dwEffects = (CFE)effects,
-                crBackColor = backColor
-            },
-            BackColor = Color.Red
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionBackColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_CustomGetCharFormat_TestData))]
-    public void RichTextBox_SelectionBackColor_CustomGetCharFormatWithBackColor_ReturnsExpected(uint mask, uint effects, int backColor, Color expected)
-    {
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = new CHARFORMAT2W
-            {
-                dwMask = (CFM)mask,
-                dwEffects = (CFE)effects,
-                crBackColor = backColor
-            },
-            BackColor = Color.Red
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionBackColor = Color.Yellow;
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionBackColor);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBackColor_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(Color.Empty, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBackColor_GetDisposed_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Equal(Color.Empty, control.SelectionBackColor);
-    }
-
-    public static IEnumerable<object[]> SelectionBackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_Set_TestData))]
-    public void RichTextBox_SelectionBackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionBackColor = value
-        };
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionBackColor = value;
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SelectionBackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_SetWithHandle_TestData))]
-    public void RichTextBox_SelectionBackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionBackColor = value;
-        Assert.Equal(expected, control.SelectionBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionBackColor = value;
-        Assert.Equal(expected, control.SelectionBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_SelectionBackColor_GetCharFormat_Success()
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionBackColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(0x785634, format.crBackColor);
-    }
-
-    public static IEnumerable<object[]> SelectionBackColor_SetCantCreate_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionBackColor_SetCantCreateHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionBackColor = value;
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionBackColor = value;
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBackColor_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionBackColor_SetDisposed_ThrowsObjectDisposedException(Color value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-
-        control.SelectionBackColor = value;
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionBackColor = value;
-        Assert.Equal(value, control.SelectionBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBullet_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBullet_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionBullet_CustomGetParamFormat_TestData()
-    {
-        yield return new object[] { 0, 0, false };
-        yield return new object[] { 0, PFN.BULLET, false };
-        yield return new object[] { PFM.NUMBERING, PFN.BULLET, true };
-        yield return new object[] { PFM.NUMBERING, 0, false };
-        yield return new object[] { PFM.NUMBERING, PFN.ARABIC, false };
-        yield return new object[] { PFM.NUMBERING, PFN.LCLETTER, false };
-        yield return new object[] { PFM.NUMBERING, PFN.LCROMAN, false };
-        yield return new object[] { PFM.NUMBERING, PFN.UCLETTER, false };
-        yield return new object[] { PFM.NUMBERING, PFN.UCROMAN, false };
-        yield return new object[] { PFM.NUMBERING, PFN.UCROMAN + 1, false };
-        yield return new object[] { PFM.NUMBERING | PFM.ALIGNMENT, PFN.BULLET, true };
-        yield return new object[] { PFM.ALIGNMENT, PFN.BULLET, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionBullet_CustomGetParamFormat_TestData))]
-    public void RichTextBox_SelectionBullet_CustomGetParaFormat_ReturnsExpected(uint mask, uint numbering, bool expected)
-    {
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = new PARAFORMAT
-            {
-                dwMask = (PFM)mask,
-                wNumbering = (PFN)numbering
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionBullet);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBullet_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.False(control.SelectionBullet);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionBullet_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionBullet);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionBullet_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionBullet = value
-        };
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionBullet = value;
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.SelectionBullet = !value;
-        Assert.Equal(!value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionBullet_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionBullet = value;
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionBullet = value;
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.SelectionBullet = !value;
-        Assert.Equal(!value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionBullet_SetWithSelectionHangingIndentWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SelectionHangingIndent = 10;
-
-        control.SelectionBullet = value;
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionBullet = value;
-        Assert.Equal(value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.SelectionBullet = !value;
-        Assert.Equal(!value, control.SelectionBullet);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1, 165)]
-    [InlineData(false, 0, 0)]
-    public unsafe void RichTextBox_SelectionBullet_GetParaFormat_Success(bool value, int expected, int expectedOffset)
-    {
-        using var control = new RichTextBox
-        {
-            BulletIndent = 11,
-            SelectionHangingIndent = 10
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionBullet = value;
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(expectedOffset, (int)format.dxOffset);
-        Assert.Equal(expected, (int)format.wNumbering);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionBullet_SetCantCreateHandle_GetReturnExpected(bool value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionBullet = value;
-        Assert.False(control.SelectionBullet);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionBullet = value;
-        Assert.False(control.SelectionBullet);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SelectionBullet = !value;
-        Assert.False(control.SelectionBullet);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionBullet_SetDisposed_ThrowsObjectDisposedException(bool value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionBullet = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionCharOffset_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionCharOffset_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionCharOffset_CustomGetCharFormat_TestData()
-    {
-        yield return new object[] { 0, 0, 0 };
-        yield return new object[] { 0, 900, 60 };
-        yield return new object[] { 0, 30000, 2000 };
-        yield return new object[] { 0, 60000, 4000 };
-        yield return new object[] { 0, -900, -60 };
-
-        yield return new object[] { CFM.OFFSET, 0, 0 };
-        yield return new object[] { CFM.OFFSET, 900, 60 };
-        yield return new object[] { CFM.OFFSET, 30000, 2000 };
-        yield return new object[] { CFM.OFFSET, 60000, 4000 };
-        yield return new object[] { CFM.OFFSET, -900, -60 };
-        yield return new object[] { CFM.OFFSET | CFM.ALLCAPS, -900, -60 };
-
-        yield return new object[] { CFM.ALLCAPS, 0, 0 };
-        yield return new object[] { CFM.ALLCAPS, 900, 60 };
-        yield return new object[] { CFM.ALLCAPS, 30000, 2000 };
-        yield return new object[] { CFM.ALLCAPS, 60000, 4000 };
-        yield return new object[] { CFM.ALLCAPS, -900, -60 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionCharOffset_CustomGetCharFormat_TestData))]
-    public void RichTextBox_SelectionCharOffset_CustomGetCharFormat_Success(uint mask, int yOffset, int expected)
-    {
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = new CHARFORMAT2W
-            {
-                dwMask = (CFM)mask,
-                yOffset = yOffset
-            }
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionCharOffset);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionCharOffset_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionCharOffset_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionCharOffset);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2000)]
-    [InlineData(10)]
-    [InlineData(0)]
-    [InlineData(-10)]
-    [InlineData(-2000)]
-    public void RichTextBox_SelectionCharOffset_Set_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionCharOffset = value
-        };
-        Assert.Equal(value, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionCharOffset = value;
-        Assert.Equal(value, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2000)]
-    [InlineData(10)]
-    [InlineData(0)]
-    [InlineData(-10)]
-    [InlineData(-2000)]
-    public void RichTextBox_SelectionCharOffset_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionCharOffset = value;
-        Assert.Equal(value, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionCharOffset = value;
-        Assert.Equal(value, control.SelectionCharOffset);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_SelectionCharOffset_GetCharFormat_Success()
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionCharOffset = 60;
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(900, format.yOffset);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2001)]
-    [InlineData(-20001)]
-    public void RichTextBox_SelectionCharOffset_SetInvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionCharOffset = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionCharOffset_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionCharOffset = value;
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionCharOffset = value;
-        Assert.Equal(0, control.SelectionCharOffset);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionCharOffset_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionCharOffset = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionColor_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(Color.Black, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(Color.Black, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionColor_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(Color.Black, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(Color.Black, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionColor_CustomGetCharFormat_TestData()
-    {
-        yield return new object[] { CFM.COLOR, 0x785634, Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
-        yield return new object[] { CFM.COLOR, 0x78563412, Color.FromArgb(0xFF, 0x12, 0x34, 0x56) };
-        yield return new object[] { CFM.COLOR, 0, Color.Black };
-
-        yield return new object[] { 0, 0x785634, Color.Empty };
-        yield return new object[] { 0, 0x78563412, Color.Empty };
-        yield return new object[] { 0, 0, Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionColor_CustomGetCharFormat_TestData))]
-    public void RichTextBox_SelectionColor_CustomGetCharFormat_Success(uint mask, int textColor, Color expected)
-    {
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = new CHARFORMAT2W
-            {
-                dwMask = (CFM)mask,
-                crTextColor = textColor
-            }
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionColor);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionColor_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(Color.Empty, control.SelectionColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionColor_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionColor);
-    }
-
-    public static IEnumerable<object[]> SelectionColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78), Color.FromArgb(0xFF, 0x34, 0x56, 0x78) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionColor_Set_TestData))]
-    public void RichTextBox_SelectionColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionColor = value
-        };
-        Assert.Equal(expected, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionColor = value;
-        Assert.Equal(expected, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionColor_Set_TestData))]
-    public void RichTextBox_SelectionColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionColor = value;
-        Assert.Equal(expected, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionColor = value;
-        Assert.Equal(expected, control.SelectionColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_SelectionColor_GetCharFormat_Success()
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionColor = Color.FromArgb(0x12, 0x34, 0x56, 0x78);
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(0x785634, format.crTextColor);
-    }
-
-    public static IEnumerable<object[]> SelectionColor_SetCantCreate_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(0x12, 0x34, 0x56, 0x78) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionColor_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionColor_SetCantCreateHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionColor = value;
-        Assert.Equal(Color.Empty, control.SelectionColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionColor = value;
-        Assert.Equal(Color.Empty, control.SelectionColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionColor_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionColor_SetDisposed_ThrowsObjectDisposedException(Color value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionColor = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionFont_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Font result1 = control.SelectionFont;
-        Assert.NotNull(result1);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Font result2 = control.SelectionFont;
-        Assert.NotNull(result2);
-        Assert.NotSame(result1, result2);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionFont_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Font result1 = control.SelectionFont;
-        Assert.NotNull(result1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Font result2 = control.SelectionFont;
-        Assert.NotNull(result2);
-        Assert.NotSame(result1, result2);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionFont_CustomGetCharFormat_TestData()
-    {
-        char[] arial = new char[] { 'A', 'r', 'i', 'a', 'l' };
-
-        yield return new object[] { 0, 0, 0, Array.Empty<char>(), string.Empty, 13, FontStyle.Regular };
-        yield return new object[] { 0, 0, 0, arial, "Arial", 13, FontStyle.Regular };
-        yield return new object[] { 0, 0, 0, new char[] { 'A', 'r', 'i', 'a', 'l', '\0', 'm' }, "Arial", 13, FontStyle.Regular };
-        yield return new object[] { 0, 0, 0, new char[] { 'N', 'r', 'i', 'a', 'l', '\0', 'm' }, "Nrial", 13, FontStyle.Regular };
-
-        yield return new object[] { 0, 0, 200, arial, "Arial", 13, FontStyle.Regular };
-        yield return new object[] { CFM.SIZE, 0, 200, arial, "Arial", 10, FontStyle.Regular };
-        yield return new object[] { CFM.SIZE, 0, 250, arial, "Arial", 12.5f, FontStyle.Regular };
-        yield return new object[] { CFM.SIZE | CFM.ALLCAPS, 0, 250, arial, "Arial", 12.5f, FontStyle.Regular };
-
-        yield return new object[] { CFM.BOLD, CFE.BOLD, 0, arial, "Arial", 13, FontStyle.Bold };
-        yield return new object[] { CFM.BOLD, CFE.BOLD | CFE.ALLCAPS, 0, arial, "Arial", 13, FontStyle.Bold };
-
-        yield return new object[] { CFM.ITALIC, CFE.ITALIC, 0, arial, "Arial", 13, FontStyle.Italic };
-        yield return new object[] { CFM.ITALIC, CFE.ITALIC | CFE.ALLCAPS, 0, arial, "Arial", 13, FontStyle.Italic };
-
-        yield return new object[] { CFM.STRIKEOUT, CFE.STRIKEOUT, 0, arial, "Arial", 13, FontStyle.Strikeout };
-        yield return new object[] { CFM.STRIKEOUT, CFE.STRIKEOUT | CFE.STRIKEOUT, 0, arial, "Arial", 13, FontStyle.Strikeout };
-
-        yield return new object[] { CFM.UNDERLINE, CFE.UNDERLINE, 0, arial, "Arial", 13, FontStyle.Underline };
-        yield return new object[] { CFM.UNDERLINE, CFE.UNDERLINE | CFE.UNDERLINE, 0, arial, "Arial", 13, FontStyle.Underline };
-
-        yield return new object[] { CFM.ALLCAPS, CFE.BOLD, 0, arial, "Arial", 13, FontStyle.Regular };
-        yield return new object[] { CFM.ALLCAPS, CFE.BOLD | CFE.ALLCAPS, 0, arial, "Arial", 13, FontStyle.Regular };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_CustomGetCharFormat_TestData))]
-    public unsafe void RichTextBox_SelectionFont_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, int yHeight, char[] faceName, string expectedFontName, float expectedSize, FontStyle expectedStyle)
-    {
-        var result = new CHARFORMAT2W
-        {
-            dwMask = CFM.FACE | (CFM)mask,
-            dwEffects = (CFE)effects,
-            yHeight = yHeight,
-            bCharSet = 2
-        };
-        for (int i = 0; i < faceName.Length; i++)
-        {
-            result._szFaceName[i] = faceName[i];
-        }
-
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = result
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Font font = control.SelectionFont;
-        Assert.Equal(expectedFontName, font.OriginalFontName);
-        Assert.Equal(expectedSize, font.Size);
-        Assert.Equal(expectedStyle, font.Style);
-        Assert.Equal(GraphicsUnit.Point, font.Unit);
-        Assert.Equal(2, font.GdiCharSet);
-    }
-
-    public static IEnumerable<object[]> SelectionFont_InvalidCustomGetCharFormat_TestData()
-    {
-        char[] arial = new char[] { 'A', 'r', 'i', 'a', 'l' };
-
-        yield return new object[] { 0, 0, arial };
-        yield return new object[] { CFM.ANIMATION, 0, arial };
-        yield return new object[] { CFM.SIZE, -200, arial };
-        yield return new object[] { CFM.SIZE, 0, arial };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_InvalidCustomGetCharFormat_TestData))]
-    public unsafe void RichTextBox_SelectionFont_InvalidCustomGetCharFormat_ReturnsExpected(uint mask, int yHeight, char[] faceName)
-    {
-        var result = new CHARFORMAT2W
-        {
-            dwMask = (CFM)mask,
-            yHeight = yHeight
-        };
-        for (int i = 0; i < faceName.Length; i++)
-        {
-            result._szFaceName[i] = faceName[i];
-        }
-
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Null(control.SelectionFont);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionFont_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Null(control.SelectionFont);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionFont_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionFont);
-    }
-
-    public static IEnumerable<object[]> SelectionFont_Set_TestData()
-    {
-        yield return new object[] { "Arial", 8.25f, false, FontStyle.Regular, 0, 0, 1 };
-        yield return new object[] { "Arial", 8.25f, true, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_Set_TestData))]
-    public void RichTextBox_SelectionFont_Set_GetReturnsExpected(string fontName, float fontSize, bool hasStyle, FontStyle fontStyle, GraphicsUnit units, byte gdiCharSet, byte expectedGdiCharset)
-    {
-        using Font value = hasStyle ? new Font(fontName, fontSize, fontStyle, units, gdiCharSet) : new Font(fontName, fontSize);
-        using var control = new RichTextBox
-        {
-            SelectionFont = value
-        };
-        Font result1 = control.SelectionFont;
-        Assert.NotSame(result1, value);
-        Assert.Equal(value?.Name, result1.Name);
-        Assert.Equal(value?.Size, result1.Size);
-        Assert.Equal(value?.Style, result1.Style);
-        Assert.Equal(expectedGdiCharset, result1.GdiCharSet);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionFont = value;
-        Font result2 = control.SelectionFont;
-        Assert.Equal(value?.Name, result2.Name);
-        Assert.Equal(value?.Size, result2.Size);
-        Assert.Equal(value?.Style, result2.Style);
-        Assert.Equal(expectedGdiCharset, result2.GdiCharSet);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_Set_TestData))]
-    public void RichTextBox_SelectionFont_SetWithHandle_GetReturnsExpected(string fontName, float fontSize, bool hasStyle, FontStyle fontStyle, GraphicsUnit units, byte gdiCharSet, byte expectedGdiCharset)
-    {
-        using Font value = hasStyle ? new Font(fontName, fontSize, fontStyle, units, gdiCharSet) : new Font(fontName, fontSize);
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionFont = value;
-        Font result1 = control.SelectionFont;
-        Assert.NotSame(result1, value);
-        Assert.Equal(value?.Name, result1.Name);
-        Assert.Equal(value?.Size, result1.Size);
-        Assert.Equal(value?.Style, result1.Style);
-        Assert.Equal(expectedGdiCharset, result1.GdiCharSet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionFont = value;
-        Font result2 = control.SelectionFont;
-        Assert.Equal(value?.Name, result2.Name);
-        Assert.Equal(value?.Size, result2.Size);
-        Assert.Equal(value?.Style, result2.Style);
-        Assert.Equal(expectedGdiCharset, result2.GdiCharSet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionFont_SetCantCreate_TestData()
-    {
-        yield return new object[] { new Font("Arial", 8.25f) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionFont_SetCantCreateHandle_GetReturnsExpected(Font value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionFont = value;
-        Assert.Null(control.SelectionFont);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionFont = value;
-        Assert.Null(control.SelectionFont);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionFont_SetDisposed_ThrowsObjectDisposedException(Font value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionFont = value);
-    }
-
-    public static IEnumerable<object[]> SelectionFont_GetCharFormat_TestData()
-    {
-        yield return new object[] { new Font("Arial", 8.25f), 165, 0 };
-        yield return new object[] { new Font("Arial", 8.25f, FontStyle.Bold), 165, CFE.BOLD };
-        yield return new object[] { new Font("Arial", 8.25f, FontStyle.Italic), 165, CFE.ITALIC };
-        yield return new object[] { new Font("Arial", 8.25f, FontStyle.Strikeout), 165, CFE.STRIKEOUT };
-        yield return new object[] { new Font("Arial", 8.25f, FontStyle.Underline), 165, CFE.UNDERLINE };
-        yield return new object[] { new Font("Arial", 8.25f, FontStyle.Bold | FontStyle.Italic | FontStyle.Regular | FontStyle.Strikeout | FontStyle.Underline, GraphicsUnit.Point, 10), 165, CFE.BOLD | CFE.ITALIC | CFE.UNDERLINE | CFE.STRIKEOUT };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionFont_GetCharFormat_TestData))]
-    public unsafe void RichTextBox_SelectionFont_GetCharFormat_Success(Font value, int expectedYHeight, int expectedEffects)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionFont = value;
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W),
-            dwMask = (CFM)int.MaxValue
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal("Arial", format.FaceName.ToString());
-        Assert.Equal(expectedYHeight, (int)format.yHeight);
-        Assert.Equal(CFE.AUTOBACKCOLOR | CFE.AUTOCOLOR | (CFE)expectedEffects, format.dwEffects);
-        Assert.Equal(0, format.bPitchAndFamily);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionFont_SetNull_ThrowsNullReferenceException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<NullReferenceException>(() => control.SelectionFont = null);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionHangingIndent_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionHangingIndent_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionHangingIndent_CustomGetParamFormat_TestData()
-    {
-        yield return new object[] { 0, 0, 0 };
-        yield return new object[] { 0, 20, 0 };
-        yield return new object[] { PFM.OFFSET, 900, 60 };
-        yield return new object[] { PFM.OFFSET, 30000, 2000 };
-        yield return new object[] { PFM.OFFSET, 60000, 4000 };
-        yield return new object[] { PFM.OFFSET, -900, -60 };
-        yield return new object[] { PFM.OFFSET | PFM.ALIGNMENT, -900, -60 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionHangingIndent_CustomGetParamFormat_TestData))]
-    public void RichTextBox_SelectionHangingIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxOffset, int expected)
-    {
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = new PARAFORMAT
-            {
-                dwMask = (PFM)mask,
-                dxOffset = dxOffset
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionHangingIndent_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionHangingIndent_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionHangingIndent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionHangingIndent_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionHangingIndent = value
-        };
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionHangingIndent = value;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionHangingIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionHangingIndent = value;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionHangingIndent = value;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.False(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionHangingIndent_SetSelectionBulletWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SelectionBullet = true;
-
-        control.SelectionHangingIndent = value;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.True(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionHangingIndent = value;
-        Assert.Equal(expected, control.SelectionHangingIndent);
-        Assert.Equal(0, control.BulletIndent);
-        Assert.True(control.SelectionBullet);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 15)]
-    [InlineData(2000, 30000)]
-    [InlineData(2001, 30015)]
-    [InlineData(int.MaxValue, 0)]
-    public unsafe void RichTextBox_SelectionHangingIndent_GetCharFormat_Success(int value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionHangingIndent = value;
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(expected, format.dxOffset);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionHangingIndent_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionHangingIndent = value;
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionHangingIndent = value;
-        Assert.Equal(0, control.SelectionHangingIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionHangingIndent_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionHangingIndent = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionIndent_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionIndent_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionIndent_CustomGetParamFormat_TestData()
-    {
-        yield return new object[] { 0, 0, 0 };
-        yield return new object[] { 0, 20, 0 };
-        yield return new object[] { PFM.STARTINDENT, 900, 60 };
-        yield return new object[] { PFM.STARTINDENT, 30000, 2000 };
-        yield return new object[] { PFM.STARTINDENT, 60000, 4000 };
-        yield return new object[] { PFM.STARTINDENT, -900, -60 };
-        yield return new object[] { PFM.STARTINDENT | PFM.ALIGNMENT, -900, -60 };
-        yield return new object[] { PFM.ALIGNMENT, 20, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionIndent_CustomGetParamFormat_TestData))]
-    public void RichTextBox_SelectionIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxStartIndent, int expected)
-    {
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = new PARAFORMAT
-            {
-                dwMask = (PFM)mask,
-                dxStartIndent = dxStartIndent
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionIndent);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionIndent_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionIndent_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionIndent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionIndent_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionIndent = value
-        };
-        Assert.Equal(expected, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionIndent = value;
-        Assert.Equal(expected, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionIndent = value;
-        Assert.Equal(expected, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionIndent = value;
-        Assert.Equal(expected, control.SelectionIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(int.MinValue, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 15)]
-    [InlineData(2000, 30000)]
-    [InlineData(2001, 30015)]
-    [InlineData(int.MaxValue, 0)]
-    public unsafe void RichTextBox_SelectionIndent_GetCharFormat_Success(int value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionIndent = value;
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(expected, format.dxStartIndent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionIndent_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionIndent = value;
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionIndent = value;
-        Assert.Equal(0, control.SelectionIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionIndent_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionIndent = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionLength_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionLength_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionLength_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionLength_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionLength);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "t")]
-    [InlineData("text", 2, 2, "te")]
-    [InlineData("text", 3, 3, "tex")]
-    [InlineData("text", 4, 4, "text")]
-    [InlineData("text", 5, 4, "text")]
-    public void RichTextBox_SelectionLength_Set_GetReturnsExpected(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text,
-            SelectionLength = value
-        };
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "e")]
-    [InlineData("text", 2, 2, "ex")]
-    [InlineData("text", 3, 3, "ext")]
-    [InlineData("text", 5, 3, "ext")]
-    public void RichTextBox_SelectionLength_SetWithSelectionStart_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text,
-            SelectionStart = 1,
-            SelectionLength = value
-        };
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "t")]
-    [InlineData("text", 2, 2, "te")]
-    [InlineData("text", 4, 4, "text")]
-    [InlineData("text", 5, 4, "text")]
-    public void RichTextBox_SelectionLength_SetWithHandle_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(4, 4)]
-    [InlineData(5, 4)]
-    public unsafe void RichTextBox_SelectionLength_GetSel_Success(int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectionStart = 1
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionLength = value;
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETSEL, (WPARAM)(&selectionStart), (LPARAM)(&selectionEnd));
-        Assert.Equal(1, PARAM.LOWORD(result));
-        Assert.Equal(expected, PARAM.HIWORD(result));
-        Assert.Equal(1, selectionStart);
-        Assert.Equal(expected, selectionEnd);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionLength_SetNegative_ThrowArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionLength = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionLength_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionLength_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionLength = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionProtected_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.False(control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.False(control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionProtected_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.False(control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionProtected_CustomGetCharFormat_TestData()
-    {
-        yield return new object[] { 0, 0, false };
-        yield return new object[] { 0, CFE.PROTECTED, false };
-        yield return new object[] { 0, CFE.PROTECTED | CFE.ALLCAPS, false };
-        yield return new object[] { CFM.PROTECTED, 0, false };
-        yield return new object[] { CFM.PROTECTED, CFE.PROTECTED, true };
-        yield return new object[] { CFM.PROTECTED, CFE.PROTECTED | CFE.ALLCAPS, true };
-        yield return new object[] { CFM.PROTECTED, CFE.ALLCAPS, false };
-        yield return new object[] { CFM.ALLCAPS, CFE.PROTECTED, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionProtected_CustomGetCharFormat_TestData))]
-    public void RichTextBox_SelectionProtected_CustomGetCharFormat_ReturnsExpected(uint mask, uint effects, bool expected)
-    {
-        using var control = new CustomGetCharFormatRichTextBox
-        {
-            ExpectedWParam = (IntPtr)SCF.SELECTION,
-            GetCharFormatResult = new CHARFORMAT2W
-            {
-                dwMask = (CFM)mask,
-                dwEffects = (CFE)effects
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionProtected);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionProtected_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.False(control.SelectionProtected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionProtected_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionProtected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionProtected_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionProtected = value
-        };
-        Assert.Equal(value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionProtected = value;
-        Assert.Equal(value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.SelectionProtected = !value;
-        Assert.Equal(!value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionProtected_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionProtected = value;
-        Assert.Equal(value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionProtected = value;
-        Assert.Equal(value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.SelectionProtected = !value;
-        Assert.Equal(!value, control.SelectionProtected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public unsafe void RichTextBox_SelectionProtected_GetCharFormat_Success(bool value)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionProtected = value;
-        var format = new CHARFORMAT2W
-        {
-            cbSize = (uint)sizeof(CHARFORMAT2W),
-            dwMask = CFM.PROTECTED
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETCHARFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(value, (format.dwEffects & CFE.PROTECTED) != 0);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionProtected_SetCantCreateHandle_GetReturnExpected(bool value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionProtected = value;
-        Assert.False(control.SelectionProtected);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionProtected = value;
-        Assert.False(control.SelectionProtected);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SelectionProtected = !value;
-        Assert.False(control.SelectionProtected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_SelectionProtected_SetDisposed_ThrowsObjectDisposedException(bool value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionProtected = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionRightIndent_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionRightIndent_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionRightIndent_CustomGetParamFormat_TestData()
-    {
-        yield return new object[] { 0, 0, 0 };
-        yield return new object[] { 0, 20, 0 };
-        yield return new object[] { PFM.RIGHTINDENT, 900, 60 };
-        yield return new object[] { PFM.RIGHTINDENT, 30000, 2000 };
-        yield return new object[] { PFM.RIGHTINDENT, 60000, 4000 };
-        yield return new object[] { PFM.RIGHTINDENT, -900, -60 };
-        yield return new object[] { PFM.RIGHTINDENT | PFM.ALIGNMENT, -900, -60 };
-        yield return new object[] { PFM.ALIGNMENT, 20, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionRightIndent_CustomGetParamFormat_TestData))]
-    public void RichTextBox_SelectionRightIndent_CustomGetParaFormat_ReturnsExpected(uint mask, int dxRightIndent, int expected)
-    {
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = new PARAFORMAT
-            {
-                dwMask = (PFM)mask,
-                dxRightIndent = dxRightIndent
-            }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionRightIndent);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionRightIndent_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionRightIndent_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionRightIndent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionRightIndent_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionRightIndent = value
-        };
-        Assert.Equal(expected, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionRightIndent = value;
-        Assert.Equal(expected, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2000, 2000)]
-    [InlineData(2001, 2001)]
-    [InlineData(int.MaxValue, 0)]
-    public void RichTextBox_SelectionRightIndent_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionRightIndent = value;
-        Assert.Equal(expected, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionRightIndent = value;
-        Assert.Equal(expected, control.SelectionRightIndent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 15)]
-    [InlineData(2000, 30000)]
-    [InlineData(2001, 30015)]
-    [InlineData(int.MaxValue, 0)]
-    public unsafe void RichTextBox_SelectionRightIndent_GetCharFormat_Success(int value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionRightIndent = value;
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(expected, format.dxRightIndent);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionRightIndent_SetNegative_ThrowArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionRightIndent = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionRightIndent_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionRightIndent = value;
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionRightIndent = value;
-        Assert.Equal(0, control.SelectionRightIndent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionRightIndent_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionRightIndent = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionStart_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionStart_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionStart_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionStart_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionStart);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 1, 0)]
-    [InlineData("text", 0, 0)]
-    [InlineData("text", 1, 1)]
-    [InlineData("text", 2, 2)]
-    [InlineData("text", 3, 3)]
-    [InlineData("text", 4, 4)]
-    [InlineData("text", 5, 4)]
-    public void RichTextBox_SelectionStart_Set_GetReturnsExpected(string text, int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text,
-            SelectionStart = value
-        };
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "te")]
-    [InlineData("text", 1, 1, "ex")]
-    [InlineData("text", 2, 2, "xt")]
-    [InlineData("text", 3, 3, "t")]
-    [InlineData("text", 5, 4, "")]
-    public void RichTextBox_SelectionStart_SetWithSelectionLength_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text,
-            SelectionLength = 2,
-            SelectionStart = value
-        };
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 1, 0)]
-    [InlineData("text", 0, 0)]
-    [InlineData("text", 1, 1)]
-    [InlineData("text", 2, 2)]
-    [InlineData("text", 3, 3)]
-    [InlineData("text", 4, 4)]
-    [InlineData("text", 5, 4)]
-    public void RichTextBox_SelectionStart_SetWithHandle_Success(string text, int value, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0, 1)]
-    [InlineData(1, 1, 2)]
-    [InlineData(2, 2, 3)]
-    [InlineData(3, 3, 4)]
-    [InlineData(5, 4, 4)]
-    public unsafe void RichTextBox_SelectionStart_GetSel_Success(int value, int expectedSelectionStart, int expectedEnd)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text",
-            SelectionLength = 1
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionStart = value;
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETSEL, (WPARAM)(&selectionStart), (LPARAM)(&selectionEnd));
-        Assert.Equal(expectedSelectionStart, PARAM.LOWORD(result));
-        Assert.Equal(expectedEnd, PARAM.HIWORD(result));
-        Assert.Equal(expectedSelectionStart, selectionStart);
-        Assert.Equal(expectedEnd, selectionEnd);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionStart_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_SelectionStart_SetDisposed_ThrowsObjectDisposedException(int value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionStart = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionTabs_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Empty(control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Empty(control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionTabs_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Empty(control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Empty(control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionTabs_CustomGetParaFormat_TestData()
-    {
-        yield return new object[] { 0, 3, new int[] { 900, 600, -900 }, Array.Empty<int>() };
-        yield return new object[] { PFM.TABSTOPS, 3, new int[] { 900, 600, -900 }, new int[] { 60, 40, -60 } };
-        yield return new object[] { PFM.TABSTOPS, 1, new int[] { 900, 600, -900 }, new int[] { 60 } };
-        yield return new object[] { PFM.TABSTOPS, 32, Enumerable.Repeat(900, 32).ToArray(), Enumerable.Repeat(60, 32).ToArray() };
-        yield return new object[] { PFM.TABSTOPS | PFM.ALIGNMENT, 3, new int[] { 900, 600, -900 }, new int[] { 60, 40, -60 } };
-        yield return new object[] { PFM.ALIGNMENT, 3, new int[] { 900, 600, -900 }, Array.Empty<int>() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_CustomGetParaFormat_TestData))]
-    public unsafe void RichTextBox_SelectionTabs_CustomGetParaFormat_ReturnsExpected(int mask, short tabCount, int[] tabs, int[] expected)
-    {
-        var result = new PARAFORMAT
-        {
-            dwMask = (PFM)mask,
-            cTabCount = tabCount
-        };
-        for (int i = 0; i < tabs.Length; i++)
-        {
-            result.rgxTabs[i] = tabs[i];
-        }
-
-        using var control = new CustomGetParaFormatRichTextBox
-        {
-            GetParaFormatResult = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeCustom = true;
-        Assert.Equal(expected, control.SelectionTabs);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionTabs_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Empty(control.SelectionTabs);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionTabs_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionTabs);
-    }
-
-    public static IEnumerable<object[]> SelectionTabs_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<int>() };
-        yield return new object[] { Array.Empty<int>(), Array.Empty<int>() };
-        yield return new object[] { new int[] { 1, 2 }, new int[] { 1, 2 } };
-        yield return new object[] { new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 } };
-        yield return new object[] { new int[] { 1, 2, 3, 4 }, new int[] { 1, 2, 3, 4 } };
-        yield return new object[] { new int[] { 1, 0, 3 }, new int[] { 1, 0, 3 } };
-        yield return new object[] { new int[] { 1, -1, 3 }, Array.Empty<int>() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_Set_TestData))]
-    public void RichTextBox_SelectionTabs_Set_GetReturnsExpected(int[] value, int[] expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionTabs = value
-        };
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionTabs = value;
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_Set_TestData))]
-    public void RichTextBox_SelectionTabs_SetWithHandle_GetReturnsExpected(int[] value, int[] expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionTabs = value;
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionTabs = value;
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionTabs_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { null, Array.Empty<int>() };
-        yield return new object[] { Array.Empty<int>(), Array.Empty<int>() };
-        yield return new object[] { new int[] { 1, 2 }, new int[] { 1, 2 } };
-        yield return new object[] { new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 } };
-        yield return new object[] { new int[] { 1, 2, 3, 4 }, new int[] { 1, 2, 3, 4 } };
-        yield return new object[] { new int[] { 1, 0, 3 }, new int[] { 1, 0, 3 } };
-        yield return new object[] { new int[] { 1, -1, 3 }, new int[] { 2, 3, 4 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_SetWithCustomOldValue_TestData))]
-    public void RichTextBox_SelectionTabs_SetWithCustomOldValueWithHandle_GetReturnsExpected(int[] value, int[] expected)
-    {
-        using var control = new RichTextBox
-        {
-            SelectionTabs = new int[] { 2, 3, 4 }
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionTabs = value;
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionTabs = value;
-        Assert.Equal(expected, control.SelectionTabs);
-        Assert.NotSame(control.SelectionTabs, control.SelectionTabs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(new int[0])]
-    [InlineData(null)]
-    public unsafe void RichTextBox_SelectionTabs_GetParaFormat_Success(int[] nullOrEmptyValue)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionTabs = new int[] { 1, 2, 3 };
-        var format = new PARAFORMAT
-        {
-            cbSize = (uint)sizeof(PARAFORMAT)
-        };
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(3, format.cTabCount);
-        Assert.Equal(15, format.rgxTabs[0]);
-        Assert.Equal(30, format.rgxTabs[1]);
-        Assert.Equal(45, format.rgxTabs[2]);
-
-        // Set null or empty.
-        control.SelectionTabs = nullOrEmptyValue;
-        Assert.NotEqual(0, (int)PInvoke.SendMessage(control, PInvoke.EM_GETPARAFORMAT, (WPARAM)(uint)SCF.SELECTION, ref format));
-        Assert.Equal(0, format.cTabCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionTabs_SetLongLength_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionTabs = new int[33]);
-    }
-
-    public static IEnumerable<object[]> SelectionTabs_SetCantCreate_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { Array.Empty<int>() };
-        yield return new object[] { new int[] { 1 } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionTabs_SetCantCreateHandle_GetReturnsExpected(int[] value)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.SelectionTabs = value;
-        Assert.Empty(control.SelectionTabs);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionTabs = value;
-        Assert.Empty(control.SelectionTabs);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionTabs_SetCantCreate_TestData))]
-    public void RichTextBox_SelectionTabs_SetDisposed_ThrowsObjectDisposedException(int[] value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionTabs = value);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionType_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionType_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, RichTextBoxSelectionTypes.Text)]
-    [InlineData(4, RichTextBoxSelectionTypes.Text | RichTextBoxSelectionTypes.MultiChar)]
-    public void RichTextBox_SelectionType_GetWithSelectionLengthWithHandle_ReturnsExpected(int selectionLength, RichTextBoxSelectionTypes expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "text",
-            SelectionLength = selectionLength
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(expected, control.SelectionType);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SelectionType_CustomSelectionType_TestData()
-    {
-        yield return new object[] { 0, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Empty };
-        yield return new object[] { 0, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.Empty };
-
-        yield return new object[] { 1, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Text };
-        yield return new object[] { 1, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.MultiObject };
-        yield return new object[] { 1, (IntPtr)(-1), -1 };
-
-        yield return new object[] { 4, (IntPtr)RichTextBoxSelectionTypes.Text, RichTextBoxSelectionTypes.Text };
-        yield return new object[] { 4, (IntPtr)RichTextBoxSelectionTypes.MultiObject, RichTextBoxSelectionTypes.MultiObject };
-        yield return new object[] { 4, (IntPtr)(-1), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectionType_CustomSelectionType_TestData))]
-    public void RichTextBox_SelectionType_CustomSelectionType_ReturnsExpected(int selectionLength, IntPtr result, RichTextBoxSelectionTypes expected)
-    {
-        using var control = new CustomSelectionTypeRichTextBox
-        {
-            Text = "text",
-            SelectionLength = selectionLength,
-            SelectionTypeResult = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.SelectionType);
-    }
-
-    private class CustomSelectionTypeRichTextBox : RichTextBox
-    {
-        public IntPtr SelectionTypeResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_SELECTIONTYPE)
-            {
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = SelectionTypeResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionType_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Equal(RichTextBoxSelectionTypes.Empty, control.SelectionType);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SelectionType_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectionType);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_ShowSelectionMargin_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.ShowSelectionMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_SETOPTIONS.
-        PInvoke.SendMessage(control, PInvoke.EM_SETOPTIONS, (WPARAM)(int)ECOOP.OR, (LPARAM)(nint)ECO.SELECTIONBAR);
-        Assert.False(control.ShowSelectionMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_ShowSelectionMargin_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox
-        {
-            ShowSelectionMargin = value
-        };
-        Assert.Equal(value, control.ShowSelectionMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowSelectionMargin = value;
-        Assert.Equal(value, control.ShowSelectionMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowSelectionMargin = !value;
-        Assert.Equal(!value, control.ShowSelectionMargin);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void RichTextBox_ShowSelectionMargin_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ShowSelectionMargin = value;
-        Assert.Equal(value, control.ShowSelectionMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ShowSelectionMargin = value;
-        Assert.Equal(value, control.ShowSelectionMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ShowSelectionMargin = !value;
-        Assert.Equal(!value, control.ShowSelectionMargin);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x1000041)]
-    [InlineData(false, 0x41)]
-    public void RichTextBox_ShowSelectionMargin_GetOptions_Success(bool value, int expected)
-    {
-        using var control = new RichTextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ShowSelectionMargin = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETOPTIONS));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_TextLength_GetDefaultWithoutHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_TextLength_GetDefaultWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0)]
-    [InlineData("a\0b", 1)]
-    [InlineData("a", 1)]
-    [InlineData("\ud83c\udf09", 2)] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
-    public void RichTextBox_TextLength_GetSetWithHandle_Success(string text, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0)]
-    [InlineData("a\0b", 1)]
-    [InlineData("a", 1)]
-    [InlineData("\ud83c\udf09", 2)] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
-    public void RichTextBox_TextLength_GetWithHandle_ReturnsExpected(string text, int expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = text;
-        Assert.Equal(expected, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TextLength_GetCustomGetTextLengthEx_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)(-1), -1 };
-        yield return new object[] { (IntPtr)1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextLength_GetCustomGetTextLengthEx_TestData))]
-    public void RichTextBox_TextLength_GetCustomGetTextLengthEx_Success(IntPtr result, int expected)
-    {
-        using var control = new CustomGetTextLengthExRichTextBox
-        {
-            GetTextLengthExResult = result
-        };
-        Assert.Equal(expected, control.TextLength);
-    }
-
-    private class CustomGetTextLengthExRichTextBox : RichTextBox
-    {
-        public IntPtr GetTextLengthExResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_GETTEXTLENGTHEX)
-            {
-                GETTEXTLENGTHEX* gtl = (GETTEXTLENGTHEX*)m.WParam;
-                Assert.Equal(GTL.NUMCHARS, gtl->flags);
-                Assert.Equal(1200u, gtl->codepage);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = GetTextLengthExResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    public static IEnumerable<object[]> RichTextBox_Text_GetWithHandle_TestData()
-    {
-        yield return new object[] { null, string.Empty };
-        yield return new object[] { string.Empty, string.Empty };
-        yield return new object[] { " ", " " };
-        yield return new object[] { "abc", "abc" };
-        yield return new object[] { "a\0b", "a" };
-        yield return new object[] { "\ud83c\udf09", "\ud83c\udf09" }; // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
-        yield return new object[] { "\n\n", "\n\n" };
-        yield return new object[] { "\r\r", "\n\n" };
-        yield return new object[] { "\n\r", "\n\n" };
-        yield return new object[] { "\r\n\r\n", "\n\n" };
-        yield return new object[] { "a6\r\nb\r\nc\r\nd\r\n", "a6\nb\nc\nd\n" };
-        yield return new object[] { "a7\nb\rc\r\n\n\rd\r\r\n", "a7\nb\nc\n\n\nd", SAME, "a7\nb\nc\n\n\nd " }; // RichEdit20W has a trailing space
-
-        // 0x0008 to 0x007F: https://www.unicode.org/charts/PDF/U0000.pdf
-        // 0x2000 to 0x2069: https://www.unicode.org/charts/PDF/U2000.pdf
-
-        var chars = Enumerable.Range(0x0008, /* 0x0008 to 0x007F */ 0x007F - 0x0008 + 1).Union(
-                    Enumerable.Range(0x2000, /* 0x2000 to 0x2069 */ 0x2069 - 0x2000 + 1));
-
-        foreach (int i in chars)
-        {
-            if (i == 0x000B) // Vertical Tabulation
-            {
-                // NOTE: The old control works the same, but StreamOut() substituted 0x000B with \n
-                yield return new object[] { $"{(char)i}ab", "ab", "\nab" };
-                yield return new object[] { $"a{(char)i}b", "ab", "a\nb" };
-                yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n\n", "ab\n\n\n" };
-                yield return new object[] { $"ab{(char)i}", $"ab", "ab\n" };
-                yield return new object[] { $"ab\r\n{(char)i}", "ab\n", "ab\n\n" };
-
-                continue;
-            }
-
-            if (i == 0x000D) // Carriage Return (\r) gets replaced with Line Feed (\n)
-            {
-                yield return new object[] { $"{(char)i}ab", "\nab" };
-                yield return new object[] { $"a{(char)i}b", "a\nb" };
-                yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n", SAME, "ab\n " }; // RichEdit20W has a trailing space
-                yield return new object[] { $"ab{(char)i}", "ab\n" };
-                yield return new object[] { $"ab\r\n{(char)i}", "ab\n\n" };
-
-                continue;
-            }
-
-            if (i == 0x2028) // Line Separator (\v)
-            {
-                // NOTE: The old control works the same, but StreamOut() substituted 0x2028 with \n
-                yield return new object[] { $"{(char)i}ab", "ab", "\nab" };
-                yield return new object[] { $"a{(char)i}b", "ab", "a\nb" };
-                yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n\n", "ab\n\n\n" };
-                yield return new object[] { $"ab{(char)i}", $"ab", "ab\n" };
-                yield return new object[] { $"ab\r\n{(char)i}", "ab\n", "ab\n\n" };
-
-                continue;
-            }
-
-            if (i == 0x2029) // Paragraph Separator
-            {
-                yield return new object[] { $"{(char)i}ab", "\nab" };
-                yield return new object[] { $"a{(char)i}b", "a\nb" };
-                yield return new object[] { $"ab\r\n{(char)i}\r\n", "ab\n", SAME, "ab\n\n\n" }; // RichEdit20W has extra line feeds
-                yield return new object[] { $"ab{(char)i}", $"ab\n" };
-                yield return new object[] { $"ab\r\n{(char)i}", "ab\n\n" };
-
-                continue;
-            }
-
-            yield return new object[] { $"{(char)i}ab", $"{(char)i}ab" };
-            yield return new object[] { $"a{(char)i}b", $"a{(char)i}b" };
-            yield return new object[] { $"ab\r\n{(char)i}\r\n", $"ab\n{(char)i}\n" };
-            yield return new object[] { $"ab{(char)i}", $"ab{(char)i}" };
-            yield return new object[] { $"ab\r\n{(char)i}", $"ab\n{(char)i}" };
-        }
-    }
-
-    private const string SAME = "SAME";
-
-    // NOTE: do not convert this into a theory as it will run hundreds of tests
-    // and with that will cycle through hundreds of UI controls.
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/6609")]
-    [WinFormsFact]
-    [SkipOnArchitecture(TestArchitectures.X86,
-        "Flaky tests, see: https://github.com/dotnet/winforms/issues/6609")]
-    public void RichTextBox_Text_GetWithHandle_ReturnsExpected()
-    {
-        using (var control = new RichTextBox())
-        {
-            control.CreateControl();
-
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            // verify against RichEdit20W
-            using (var riched20 = new RichEdit20W())
-            {
-                riched20.CreateControl();
-
-                foreach (object[] testCaseData in RichTextBox_Text_GetWithHandle_TestData())
-                {
-                    string text = (string)testCaseData[0];
-                    string expectedText = (string)testCaseData[1];
-                    string oldWayExpectedText = testCaseData.Length > 2 ? (string)testCaseData[2] : SAME;
-                    string oldControlExpectedText = testCaseData.Length > 3 ? (string)testCaseData[3] : SAME;
-
-                    // NOTE: in certain scenarios the old way (using StreamOut() method) returned a different
-                    // text value to the new way (via GetTextEx() method).
-                    // If oldWayExpectedText is SAME, assume StreamOut() returned the same expectedText.
-                    if (oldWayExpectedText is SAME)
-                    {
-                        oldWayExpectedText = expectedText;
-                    }
-
-                    // NOTE: in certain scenarios the old control returns a different text value to the new control.
-                    // If oldControlExpectedText is SAME, assume the old control returns the same expectedText.
-                    if (oldControlExpectedText is SAME)
-                    {
-                        oldControlExpectedText = expectedText;
-                    }
-
-                    control.Text = text;
-                    Assert.Equal(expectedText, control.Text);
-
-                    // verify the old behaviour via StreamOut(SF.TEXT | SF.UNICODE)
-                    string textOldWay = control.TestAccessor().Dynamic.StreamOut(SF.TEXT | SF.UNICODE);
-                    Assert.Equal(oldWayExpectedText, textOldWay);
-
-                    // verify against RichEdit20W
-                    riched20.Text = text;
-                    Assert.Equal(oldControlExpectedText, riched20.Text);
-                }
-            }
-
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("abc", "abc")]
-    [InlineData("a\0b", "a\0b")]
-    [InlineData("\ud83c\udf09", "\ud83c\udf09")] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
-    [InlineData("\n\n", "\n\n")]
-    [InlineData("\r\r", "\r\r")]
-    [InlineData("\r\n\r\n", "\r\n\r\n")]
-    [InlineData("a\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nd\r\n")]
-    [InlineData("a\nb\rc\r\n\n\rd\r\r\n", "a\nb\rc\r\n\n\rd\r\r\n")]
-    public void RichTextBox_Text_GetWithoutHandle_ReturnsExpected(string text, string expected)
-    {
-        using (var control = new RichTextBox())
-        {
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            Assert.Empty(control.Text);
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            control.Text = text;
-
-            Assert.Equal(expected, control.Text);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-
-        // verify against RichEdit20W
-        using (var riched20 = new RichEdit20W())
-        {
-            Assert.Empty(riched20.Text);
-            Assert.False(riched20.IsHandleCreated);
-
-            riched20.Text = text;
-
-            Assert.Equal(expected, riched20.Text);
-            Assert.False(riched20.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("abc", "abc")]
-    [InlineData("a\0b", "a")]
-    [InlineData("\ud83c\udf09", "\ud83c\udf09")] // emoji, surrogate pair https://charbase.com/1f309-unicode-bridge-at-night
-    [InlineData("\n\n", "\r\n\r\n")]
-    [InlineData("\r\r", "\r\n\r\n")]
-    [InlineData("\r\n\r\n", "\r\n\r\n")]
-    [InlineData("a\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nd\r\n")]
-    [InlineData("a1\nb\rc\n\r\n\rd\r\r\n", "a1\r\nb\r\nc\r\n\r\n\r\nd")]
-    public void RichTextBox_Text_GetTextEx_USECRLF_ReturnsExpected(string text, string expected)
-    {
-        using var control = new RichTextBox();
-        control.CreateControl();
-
-        Assert.Empty(control.Text);
-
-        control.Text = text;
-
-        string textOldWay = control.TestAccessor().Dynamic.GetTextEx(GT.USECRLF);
-        Assert.Equal(expected, textOldWay);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Text_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Text_GetWithRtf_ReturnsExpected()
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf Hello World}"
-        };
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Text_GetDisposed_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Empty(control.Text);
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null, string.Empty };
-            yield return new object[] { autoSize, string.Empty, string.Empty };
-            yield return new object[] { autoSize, "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void RichTextBox_Text_Set_GetReturnsExpected(bool autoSize, string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (control, e) => layoutCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void RichTextBox_Text_SetWithRtfText_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf Hello World}",
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Contains(expected, control.Rtf);
-        Assert.DoesNotContain("Hello World", control.Rtf);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Contains(expected, control.Rtf);
-        Assert.DoesNotContain("Hello World", control.Rtf);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithParent_TestData()
-    {
-        yield return new object[] { true, null, string.Empty, 1 };
-        yield return new object[] { true, string.Empty, string.Empty, 1 };
-        yield return new object[] { true, "text", "text", 1 };
-
-        yield return new object[] { false, null, string.Empty, 0 };
-        yield return new object[] { false, string.Empty, string.Empty, 0 };
-        yield return new object[] { false, "text", "text", 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParent_TestData))]
-    public void RichTextBox_Text_SetWithParent_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new RichTextBox
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        int layoutCallCount = 0;
-        control.Layout += (control, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.Modified);
-            Assert.False(control.CanUndo);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.Modified);
-            Assert.False(control.CanUndo);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Text_SetWithSelection_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 0, 2, "t", "t" };
-        yield return new object[] { string.Empty, 0, 2, "text", "text" };
-
-        yield return new object[] { string.Empty, 1, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 1, 2, "t", "t" };
-        yield return new object[] { string.Empty, 1, 2, "text", "text" };
-
-        yield return new object[] { "text", 0, 2, null, string.Empty };
-        yield return new object[] { "text", 0, 2, "t", "t" };
-        yield return new object[] { "text", 0, 2, "te", "te" };
-        yield return new object[] { "text", 0, 2, "tex", "tex" };
-
-        yield return new object[] { "text", 1, 2, null, string.Empty };
-        yield return new object[] { "text", 1, 2, "t", "t" };
-        yield return new object[] { "text", 1, 2, "te", "te" };
-        yield return new object[] { "text", 1, 2, "tex", "tex" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithSelection_TestData))]
-    public void RichTextBox_Text_SetWithSelection_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = oldValue,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-        };
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", true)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", false)]
-    public void RichTextBox_Text_SetModified_GetReturnsExpected(string value, string expected, bool expectedModified)
-    {
-        using var control = new RichTextBox
-        {
-            Modified = true,
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expectedModified, control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void RichTextBox_Text_SetWithHandle_GetReturnsExpected(bool autoSize, string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (control, e) => layoutCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void RichTextBox_Text_SetWithRtfTextWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf Hello World}"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Contains(expected, control.Rtf);
-        Assert.DoesNotContain("Hello World", control.Rtf);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Contains(expected, control.Rtf);
-        Assert.DoesNotContain("Hello World", control.Rtf);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithParent_TestData))]
-    public void RichTextBox_Text_SetWithParentWithHandle_GetReturnsExpected(bool autoSize, string value, string expected, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new RichTextBox
-        {
-            Parent = parent,
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (control, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Text", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.Modified);
-            Assert.False(control.CanUndo);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.Modified);
-            Assert.False(control.CanUndo);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("text", "text")]
-    public void RichTextBox_Text_SetModifiedWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            Modified = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithSelectionWithHandle_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 0, 2, "t", "t" };
-        yield return new object[] { string.Empty, 0, 2, "text", "text" };
-
-        yield return new object[] { string.Empty, 1, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 1, 2, "t", "t" };
-        yield return new object[] { string.Empty, 1, 2, "text", "text" };
-
-        yield return new object[] { "text", 0, 2, null, string.Empty };
-        yield return new object[] { "text", 0, 2, "t", "t" };
-        yield return new object[] { "text", 0, 2, "te", "te" };
-        yield return new object[] { "text", 0, 2, "tex", "tex" };
-
-        yield return new object[] { "text", 1, 2, null, string.Empty };
-        yield return new object[] { "text", 1, 2, "t", "t" };
-        yield return new object[] { "text", 1, 2, "te", "te" };
-        yield return new object[] { "text", 1, 2, "tex", "tex" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithSelectionWithHandle_TestData))]
-    public void RichTextBox_Text_SetWithSelectionWith_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = oldValue,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new RichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Text_SetWithHandlerWithHandle_CallsTextChanged()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(3, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(3, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void RichTextBox_Text_SetCantCreateHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void RichTextBox_Text_SetDisposed_ThrowsObjectDisposedException(string value)
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-
-        control.Text = value;
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_UndoActionName_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Empty(control.UndoActionName);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> UndoActionName_CustomGetUndoName_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, IntPtr.Zero, string.Empty };
-        yield return new object[] { (IntPtr)1, IntPtr.Zero, "Unknown" };
-        yield return new object[] { (IntPtr)1, (IntPtr)1, "Typing" };
-        yield return new object[] { (IntPtr)1, (IntPtr)2, "Delete" };
-        yield return new object[] { (IntPtr)1, (IntPtr)3, "Drag and Drop" };
-        yield return new object[] { (IntPtr)1, (IntPtr)4, "Cut" };
-        yield return new object[] { (IntPtr)1, (IntPtr)5, "Paste" };
-        yield return new object[] { (IntPtr)1, (IntPtr)6, "Unknown" };
-        yield return new object[] { (IntPtr)1, (IntPtr)7, "Unknown" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UndoActionName_CustomGetUndoName_TestData))]
-    public void RichTextBox_UndoActionName_CustomGetUndoName_ReturnsExpected(IntPtr canUndoResult, IntPtr getUndoNameResult, string expected)
-    {
-        using var control = new CustomGetUndoNameRichTextBox
-        {
-            CanUndoResult = canUndoResult,
-            GetUndoNameResult = getUndoNameResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.UndoActionName);
-    }
-
-    private class CustomGetUndoNameRichTextBox : RichTextBox
-    {
-        public IntPtr CanUndoResult { get; set; }
-        public IntPtr GetUndoNameResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANUNDO)
-            {
-                m.Result = CanUndoResult;
-                return;
-            }
-            else if (m.Msg == (int)PInvoke.EM_GETUNDONAME)
-            {
-                m.Result = GetUndoNameResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_UndoActionName_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleRichTextBox();
-        Assert.Empty(control.UndoActionName);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_UndoActionName_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new RichTextBox();
-        control.Dispose();
-        Assert.Empty(control.UndoActionName);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_ZoomFactor_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(1, control.ZoomFactor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_SETZOOM.
-        PInvoke.SendMessage(control, PInvoke.EM_SETZOOM, 2, 10);
-        Assert.Equal(0.2f, control.ZoomFactor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 1.0f)]
-    [InlineData(10, 1, 10.0f)]
-    [InlineData(10, 2, 5.0f)]
-    [InlineData(1, 10, 0.1f)]
-    [InlineData(1, 0, 1f)]
-    [InlineData(0, 1, 1f)]
-    [InlineData(0, 0, 1f)]
-    public void RichTextBox_ZoomFactor_CustomGetZoom_ReturnsExpected(int numerator, int denominator, float expected)
-    {
-        using var control = new CustomGetZoomRichTextBox
-        {
-            NumeratorResult = numerator,
-            DenominatorResult = denominator
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.ZoomFactor);
-    }
-
-    private class CustomGetZoomRichTextBox : RichTextBox
-    {
-        public int NumeratorResult { get; set; }
-        public int DenominatorResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_GETZOOM)
-            {
-                int* pNumerator = (int*)m.WParam;
-                int* pDenominator = (int*)m.LParam;
-
-                *pNumerator = NumeratorResult;
-                *pDenominator = DenominatorResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0.015626f, 0.016f)]
-    [InlineData(63.9f, 63.9f)]
-    [InlineData(1.0f, 1.0f)]
-    [InlineData(2.0f, 2.0f)]
-    [InlineData(float.NaN, -2147483.75f)]
-    public void RichTextBox_ZoomFactor_Set_GetReturnsExpected(float value, float expected)
-    {
-        using var control = new RichTextBox
-        {
-            ZoomFactor = value
-        };
-        Assert.Equal(expected, control.ZoomFactor, 2f);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ZoomFactor = value;
-        Assert.Equal(expected, control.ZoomFactor, 2f);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0.015626f, 0.016f)]
-    [InlineData(63.9f, 63.9f)]
-    [InlineData(1.0f, 1.0f)]
-    [InlineData(2.0f, 2.0f)]
-    [InlineData(float.NaN, 1.0f)]
-    public void RichTextBox_ZoomFactor_SetWithHandle_GetReturnsExpected(float value, float expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ZoomFactor = value;
-        Assert.Equal(expected, control.ZoomFactor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ZoomFactor = value;
-        Assert.Equal(expected, control.ZoomFactor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0.015624f)]
-    [InlineData(0.015625f)]
-    [InlineData(64.0f)]
-    [InlineData(64.1f)]
-    [InlineData(float.PositiveInfinity)]
-    [InlineData(float.NegativeInfinity)]
-    public void RichTextBox_ZoomFactor_SetInvalidValue_ThrowsArgumentOutOfRangeException(float value)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ZoomFactor = value);
-    }
-
-    public static IEnumerable<object[]> CanPaste_TestData()
-    {
-        yield return new object[] { DataFormats.GetFormat(DataFormats.Palette), false };
-        yield return new object[] { new DataFormats.Format("UnknownName", int.MaxValue), false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanPaste_TestData))]
-    public void RichTextBox_CanPaste_Invoke_ReturnsExpected(DataFormats.Format format, bool expected)
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(expected, control.CanPaste(format));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanPaste_TestData))]
-    public void RichTextBox_CanPaste_InvokeWithHandle_ReturnsExpected(DataFormats.Format format, bool expected)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.CanPaste(format));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CanPaste_CustomCanPaste_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, false };
-        yield return new object[] { (IntPtr)1, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanPaste_CustomCanPaste_TestData))]
-    public void RichTextBox_CanPaste_CustomCanPaste_ReturnsExpected(IntPtr result, bool expected)
-    {
-        using var control = new CustomCanPasteRichTextBox
-        {
-            Result = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.CanPaste(DataFormats.GetFormat(DataFormats.Text)));
-    }
-
-    private class CustomCanPasteRichTextBox : RichTextBox
-    {
-        public IntPtr Result { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANPASTE)
-            {
-                m.Result = Result;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_OleObject_IncompleteOleObject_DoNothing()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        using var memoryStream = new MemoryStream();
-        using var bitmap = new Bitmap(100, 100);
-        bitmap.Save(memoryStream, Drawing.Imaging.ImageFormat.Png);
-        Clipboard.SetData("Embed Source", memoryStream);
-
-        Assert.Equal(string.Empty, control.Text);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CanPaste_NullFormat_ThrowsNullReferenceException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<NullReferenceException>(() => control.CanPaste(null));
-    }
-
-    public static IEnumerable<object[]> Find_String_TestData()
-    {
-        yield return new object[] { string.Empty, string.Empty, -1 };
-        yield return new object[] { string.Empty, "abc", -1 };
-
-        yield return new object[] { "abc", string.Empty, -1 };
-        yield return new object[] { "abc", "a", 0 };
-        yield return new object[] { "abc", "ab", 0 };
-        yield return new object[] { "abc", "abc", 0 };
-        yield return new object[] { "abc", "abcd", -1 };
-        yield return new object[] { "abc", "b", 1 };
-        yield return new object[] { "abc", "d", -1 };
-        yield return new object[] { "abc", "ABC", 0 };
-
-        yield return new object[] { "aa", "a", 0 };
-        yield return new object[] { "abc def", "ef", 5 };
-        yield return new object[] { "abc def", "def", 4 };
-        yield return new object[] { "abc def", " ", 3 };
-
-        yield return new object[] { "ab\u0640cd", "abcd", 0 };
-        yield return new object[] { "ab\u0640cd", "\u0640", 2 };
-        yield return new object[] { "ab\u0640cd", "bc", 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_TestData))]
-    public void RichTextBox_Find_String_ReturnsExpected(string text, string str, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(str));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Find_String_RichTextBoxFinds_TestData()
-    {
-        yield return new object[] { string.Empty, string.Empty, RichTextBoxFinds.None, -1 };
-        yield return new object[] { string.Empty, "abc", RichTextBoxFinds.None, -1 };
-        yield return new object[] { string.Empty, string.Empty, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { string.Empty, "abc", RichTextBoxFinds.Reverse, -1 };
-
-        yield return new object[] { "abc", string.Empty, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "a", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "a", RichTextBoxFinds.Reverse, 0 };
-        yield return new object[] { "abc", "ab", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abc", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abcd", RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "b", RichTextBoxFinds.None, 1 };
-        yield return new object[] { "abc", "d", RichTextBoxFinds.None, -1 };
-
-        yield return new object[] { "abc", "ABC", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abc", RichTextBoxFinds.MatchCase, 0 };
-        yield return new object[] { "abc", "ABC", RichTextBoxFinds.MatchCase, -1 };
-
-        yield return new object[] { "aa", "a", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "aa", "a", RichTextBoxFinds.Reverse, 1 };
-        yield return new object[] { "aa", string.Empty, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc def", "ef", RichTextBoxFinds.None, 5 };
-        yield return new object[] { "abc def", "def", RichTextBoxFinds.None, 4 };
-        yield return new object[] { "abc def", " ", RichTextBoxFinds.None, 3 };
-        yield return new object[] { "abc def", "ef", RichTextBoxFinds.WholeWord, -1 };
-        yield return new object[] { "abc def", "def", RichTextBoxFinds.WholeWord, 4 };
-        yield return new object[] { "abc def", " ", RichTextBoxFinds.WholeWord, -1 };
-
-        yield return new object[] { "ab\u0640cd", "abcd", RichTextBoxFinds.None, 0 };
-        yield return new object[] { "ab\u0640cd", "\u0640", RichTextBoxFinds.None, 2 };
-        yield return new object[] { "ab\u0640cd", "bc", RichTextBoxFinds.None, 1 };
-        yield return new object[] { "ab\u0640cd", "abcd", RichTextBoxFinds.NoHighlight, 0 };
-        yield return new object[] { "ab\u0640cd", "\u0640", RichTextBoxFinds.NoHighlight, 2 };
-        yield return new object[] { "ab\u0640cd", "bc", RichTextBoxFinds.NoHighlight, 1 };
-        yield return new object[] { "abcd", "abcd", RichTextBoxFinds.NoHighlight, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringRichTextBoxFinds_ReturnsExpected(string text, string str, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(str, options));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Find_String_Int_RichTextBoxFinds_TestData()
-    {
-        yield return new object[] { string.Empty, string.Empty, 0, RichTextBoxFinds.None, -1 };
-        yield return new object[] { string.Empty, "abc", 0, RichTextBoxFinds.None, -1 };
-        yield return new object[] { string.Empty, string.Empty, 0, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { string.Empty, "abc", 0, RichTextBoxFinds.Reverse, -1 };
-
-        yield return new object[] { "abc", string.Empty, 0, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "a", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "a", 0, RichTextBoxFinds.Reverse, 0 };
-        yield return new object[] { "abc", "ab", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abc", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abcd", 0, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "b", 0, RichTextBoxFinds.None, 1 };
-        yield return new object[] { "abc", "d", 0, RichTextBoxFinds.None, -1 };
-
-        yield return new object[] { "abc", "ABC", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "abc", "abc", 0, RichTextBoxFinds.MatchCase, 0 };
-        yield return new object[] { "abc", "ABC", 0, RichTextBoxFinds.MatchCase, -1 };
-
-        yield return new object[] { "aa", "a", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "aa", "a", 0, RichTextBoxFinds.Reverse, 1 };
-        yield return new object[] { "aa", string.Empty, 0, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc def", "ef", 0, RichTextBoxFinds.None, 5 };
-        yield return new object[] { "abc def", "def", 0, RichTextBoxFinds.None, 4 };
-        yield return new object[] { "abc def", " ", 0, RichTextBoxFinds.None, 3 };
-        yield return new object[] { "abc def", "ef", 0, RichTextBoxFinds.WholeWord, -1 };
-        yield return new object[] { "abc def", "def", 0, RichTextBoxFinds.WholeWord, 4 };
-        yield return new object[] { "abc def", " ", 0, RichTextBoxFinds.WholeWord, -1 };
-
-        yield return new object[] { "abc", "a", 1, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "a", 2, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "c", 2, RichTextBoxFinds.None, 2 };
-        yield return new object[] { "abc", "a", 1, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc", "a", 2, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc", "c", 2, RichTextBoxFinds.Reverse, 2 };
-
-        yield return new object[] { "ab\u0640cd", "abcd", 0, RichTextBoxFinds.None, 0 };
-        yield return new object[] { "ab\u0640cd", "\u0640", 0, RichTextBoxFinds.None, 2 };
-        yield return new object[] { "ab\u0640cd", "bc", 0, RichTextBoxFinds.None, 1 };
-        yield return new object[] { "ab\u0640cd", "abcd", 0, RichTextBoxFinds.NoHighlight, 0 };
-        yield return new object[] { "ab\u0640cd", "\u0640", 0, RichTextBoxFinds.NoHighlight, 2 };
-        yield return new object[] { "ab\u0640cd", "bc", 0, RichTextBoxFinds.NoHighlight, 1 };
-        yield return new object[] { "abcd", "abcd", 0, RichTextBoxFinds.NoHighlight, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_Int_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringIntRichTextBoxFinds_ReturnsExpected(string text, string str, int start, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(str, start, options));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Find_String_Int_Int_RichTextBoxFinds_TestData()
-    {
-        foreach (int end in new int[] { -1, 0 })
-        {
-            yield return new object[] { string.Empty, string.Empty, 0, end, RichTextBoxFinds.None, -1 };
-            yield return new object[] { string.Empty, "abc", 0, end, RichTextBoxFinds.None, -1 };
-            yield return new object[] { string.Empty, string.Empty, 0, end, RichTextBoxFinds.Reverse, -1 };
-            yield return new object[] { string.Empty, "abc", 0, end, RichTextBoxFinds.Reverse, -1 };
-
-            yield return new object[] { "abc", string.Empty, 0, end, RichTextBoxFinds.None, -1 };
-            yield return new object[] { "abc", "a", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "abc", "a", 0, end, RichTextBoxFinds.Reverse, 0 };
-            yield return new object[] { "abc", "ab", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "abc", "abc", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "abc", "abcd", 0, end, RichTextBoxFinds.None, -1 };
-            yield return new object[] { "abc", "b", 0, end, RichTextBoxFinds.None, 1 };
-            yield return new object[] { "abc", "d", 0, end, RichTextBoxFinds.None, -1 };
-
-            yield return new object[] { "abc", "ABC", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "abc", "abc", 0, end, RichTextBoxFinds.MatchCase, 0 };
-            yield return new object[] { "abc", "ABC", 0, end, RichTextBoxFinds.MatchCase, -1 };
-
-            yield return new object[] { "aa", "a", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "aa", "a", 0, end, RichTextBoxFinds.Reverse, 1 };
-            yield return new object[] { "abc", string.Empty, 0, end, RichTextBoxFinds.Reverse, -1 };
-            yield return new object[] { "abc def", "ef", 0, end, RichTextBoxFinds.None, 5 };
-            yield return new object[] { "abc def", "def", 0, end, RichTextBoxFinds.None, 4 };
-            yield return new object[] { "abc def", " ", 0, end, RichTextBoxFinds.None, 3 };
-            yield return new object[] { "abc def", "ef", 0, end, RichTextBoxFinds.WholeWord, -1 };
-            yield return new object[] { "abc def", "def", 0, end, RichTextBoxFinds.WholeWord, 4 };
-            yield return new object[] { "abc def", " ", 0, end, RichTextBoxFinds.WholeWord, -1 };
-
-            yield return new object[] { "ab\u0640cd", "abcd", 0, end, RichTextBoxFinds.None, 0 };
-            yield return new object[] { "ab\u0640cd", "\u0640", 0, end, RichTextBoxFinds.None, 2 };
-            yield return new object[] { "ab\u0640cd", "bc", 0, end, RichTextBoxFinds.None, 1 };
-            yield return new object[] { "ab\u0640cd", "abcd", 0, end, RichTextBoxFinds.NoHighlight, 0 };
-            yield return new object[] { "ab\u0640cd", "\u0640", 0, end, RichTextBoxFinds.NoHighlight, 2 };
-            yield return new object[] { "ab\u0640cd", "bc", 0, end, RichTextBoxFinds.NoHighlight, 1 };
-            yield return new object[] { "abcd", "abcd", 0, end, RichTextBoxFinds.NoHighlight, 0 };
-        }
-
-        yield return new object[] { "abc", "a", 1, 3, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "a", 2, 3, RichTextBoxFinds.None, -1 };
-        yield return new object[] { "abc", "c", 2, 3, RichTextBoxFinds.None, 2 };
-        yield return new object[] { "abc", "a", 1, 3, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc", "a", 2, 3, RichTextBoxFinds.Reverse, -1 };
-        yield return new object[] { "abc", "c", 2, 3, RichTextBoxFinds.Reverse, 2 };
-
-        yield return new object[] { "abc", "c", 0, 5, RichTextBoxFinds.None, 2 };
-        yield return new object[] { "abc", "c", 0, 2, RichTextBoxFinds.None, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_Int_Int_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringIntIntRichTextBoxFinds_ReturnsExpected(string text, string str, int start, int end, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(str, start, end, options));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_TestData))]
-    public void RichTextBox_Find_StringWithHandle_ReturnsExpected(string text, string str, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(str));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(str, options));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_Int_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringIntRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, int start, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(str, start, options));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_String_Int_Int_RichTextBoxFinds_TestData))]
-    public void RichTextBox_Find_StringIntIntRichTextBoxFindsWithHandle_ReturnsExpected(string text, string str, int start, int end, RichTextBoxFinds options, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(str, start, end, options));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Find_CharArray_TestData()
-    {
-        yield return new object[] { string.Empty, Array.Empty<char>(), -1 };
-        yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, -1 };
-
-        yield return new object[] { "abc", Array.Empty<char>(), -1 };
-        yield return new object[] { "abc", new char[] { 'a' }, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b' }, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0 };
-        yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0 };
-        yield return new object[] { "abc", new char[] { 'c', 'b' }, 1 };
-        yield return new object[] { "abc", new char[] { 'b' }, 1 };
-        yield return new object[] { "abc", new char[] { 'd' }, -1 };
-        yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, -1 };
-
-        yield return new object[] { "aa", new char[] { 'a' }, 0 };
-        yield return new object[] { "abc def", new char[] { 'e', 'f' }, 5 };
-        yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 4 };
-        yield return new object[] { "abc def", new char[] { ' ' }, 3 };
-
-        yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0 };
-        yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 2 };
-        yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_TestData))]
-    public void RichTextBox_Find_CharArray_ReturnsExpected(string text, char[] characterSet, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(characterSet));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Find_CharArray_Int_TestData()
-    {
-        yield return new object[] { string.Empty, Array.Empty<char>(), 0, -1 };
-        yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, 0, -1 };
-
-        yield return new object[] { "abc", Array.Empty<char>(), 0, -1 };
-        yield return new object[] { "abc", new char[] { 'a' }, 0, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b' }, 0, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0, 0 };
-        yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0, 0 };
-        yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0, 0 };
-        yield return new object[] { "abc", new char[] { 'c', 'b' }, 0, 1 };
-        yield return new object[] { "abc", new char[] { 'b' }, 0, 1 };
-        yield return new object[] { "abc", new char[] { 'd' }, 0, -1 };
-        yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, 0, -1 };
-
-        yield return new object[] { "aa", new char[] { 'a' }, 0, 0 };
-        yield return new object[] { "abc def", new char[] { 'e', 'f' }, 0, 5 };
-        yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 0, 4 };
-        yield return new object[] { "abc def", new char[] { ' ' }, 0, 3 };
-
-        yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0, 0 };
-        yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 0, 2 };
-        yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 0, 1 };
-
-        yield return new object[] { "abc", new char[] { 'a' }, 1, -1 };
-        yield return new object[] { "abc", new char[] { 'a' }, 2, -1 };
-        yield return new object[] { "abc", new char[] { 'c' }, 2, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_Int_TestData))]
-    public void RichTextBox_Find_CharArrayInt_ReturnsExpected(string text, char[] characterSet, int start, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(characterSet, start));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Find_CharArray_Int_Int_TestData()
-    {
-        foreach (int end in new int[] { -1, 0 })
-        {
-            yield return new object[] { string.Empty, Array.Empty<char>(), 0, end, -1 };
-            yield return new object[] { string.Empty, new char[] { 'a', 'b', 'c' }, 0, end, -1 };
-
-            yield return new object[] { "abc", Array.Empty<char>(), 0, end, -1 };
-            yield return new object[] { "abc", new char[] { 'a' }, 0, end, 0 };
-            yield return new object[] { "abc", new char[] { 'a', 'b' }, 0, end, 0 };
-            yield return new object[] { "abc", new char[] { 'a', 'b', 'c' }, 0, end, 0 };
-            yield return new object[] { "abc", new char[] { 'a', 'b', 'c', 'd' }, 0, end, 0 };
-            yield return new object[] { "abc", new char[] { 'c', 'b', 'a' }, 0, end, 0 };
-            yield return new object[] { "abc", new char[] { 'c', 'b' }, 0, end, 1 };
-            yield return new object[] { "abc", new char[] { 'b' }, 0, end, 1 };
-            yield return new object[] { "abc", new char[] { 'd' }, 0, end, -1 };
-            yield return new object[] { "abc", new char[] { 'A', 'B', 'C' }, 0, end, -1 };
-
-            yield return new object[] { "aa", new char[] { 'a' }, 0, end, 0 };
-            yield return new object[] { "abc def", new char[] { 'e', 'f' }, 0, end, 5 };
-            yield return new object[] { "abc def", new char[] { 'd', 'e', 'f' }, 0, end, 4 };
-            yield return new object[] { "abc def", new char[] { ' ' }, 0, end, 3 };
-
-            yield return new object[] { "ab\u0640cd", new char[] { 'a', 'b', 'c', 'd' }, 0, end, 0 };
-            yield return new object[] { "ab\u0640cd", new char[] { '\u0640' }, 0, end, 2 };
-            yield return new object[] { "ab\u0640cd", new char[] { 'b', 'c' }, 0, end, 1 };
-        }
-
-        yield return new object[] { "abc", new char[] { 'a' }, 1, 3, -1 };
-        yield return new object[] { "abc", new char[] { 'a' }, 2, 3, -1 };
-        yield return new object[] { "abc", new char[] { 'c' }, 2, 3, 2 };
-
-        yield return new object[] { "abc", new char[] { 'c' }, 0, 5, 2 };
-        yield return new object[] { "abc", new char[] { 'c' }, 0, 2, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_Int_Int_TestData))]
-    public void RichTextBox_Find_CharArrayIntInt_ReturnsExpected(string text, char[] characterSet, int start, int end, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.Find(characterSet, start, end));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_TestData))]
-    public void RichTextBox_Find_CharArrayWithHandle_ReturnsExpected(string text, char[] characterSet, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(characterSet));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_Int_TestData))]
-    public void RichTextBox_Find_CharArrayIntWithHandle_ReturnsExpected(string text, char[] characterSet, int start, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(characterSet, start));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Find_CharArray_Int_Int_TestData))]
-    public void RichTextBox_Find_CharArrayIntIntWithHandle_ReturnsExpected(string text, char[] characterSet, int start, int end, int expected)
-    {
-        using var control = new RichTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.Find(characterSet, start, end));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_NullStrEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentNullException>("str", () => control.Find((string)null));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 1, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 1, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, -2, RichTextBoxFinds.None));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_NullStrNotEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "t"
-        };
-        Assert.Throws<ArgumentNullException>("str", () => control.Find((string)null));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 2, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, -1, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 2, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentNullException>("str", () => control.Find(null, 0, -2, RichTextBoxFinds.None));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_NullCharacterSetEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find((char[])null));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 1));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 1, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, -2));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_NullCharacterSetNotEmpty_ThrowsArgumentNullException()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "t"
-        };
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find((char[])null));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 2));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, -1, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 2, 0));
-        Assert.Throws<ArgumentNullException>("characterSet", () => control.Find(null, 0, -2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void RichTextBox_Find_InvalidStartEmpty_ThrowsArgumentOutOfRangeException(int start)
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, 0, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(new char[] { 's' }, start));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(new char[] { 's' }, start, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    public void RichTextBox_Find_InvalidStartNotEmpty_ThrowsArgumentOutOfRangeException(int start)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "t"
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find("s", start, 0, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(new char[] { 's' }, start));
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Find(new char[] { 's' }, start, 0));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_InvalidEndEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find("s", 0, -2, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(new char[] { 's' }, 0, -2));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_InvalidEndNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "t"
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find("s", 0, -2, RichTextBoxFinds.NoHighlight));
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(new char[] { 's' }, 0, -2));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Find_StartGreaterThanEnd_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "t"
-        };
-        Assert.Throws<ArgumentException>(() => control.Find("s", 1, 0, RichTextBoxFinds.None));
-        Assert.Throws<ArgumentException>(() => control.Find("s", 1, 0, RichTextBoxFinds.Reverse));
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(new char[] { 's' }, 1, 0));
-        Assert.Throws<ArgumentOutOfRangeException>("end", () => control.Find(new char[] { 's' }, 1, 0));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokePlainTextEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.LoadFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokePlainTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokePlainTextEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.LoadFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokePlainTextNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-        control.LoadFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokePlainTextWithRtf_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1OldText}"
-        };
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.DoesNotContain("OldText", control.Rtf);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeUnicodeTextEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeUnicodeTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeUnicodeTextEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeUnicodeTextNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-        control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeUnicodeTextWithRtf_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1OldText}"
-        };
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.Unicode.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.DoesNotContain("OldText", control.Rtf);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeRichTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("{\\rtf1Hello World}");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.RichText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvokeRichTextWithRtf_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Rtf = "{\\rtf1OldText}"
-        };
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("{\\rtf1Hello World}");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        control.LoadFile(stream, RichTextBoxStreamType.RichText);
-        Assert.Equal("Hello World", control.Text);
-        Assert.DoesNotContain("OldText", control.Rtf);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_NullData_ThrowsArgumentNullException()
-    {
-        using var control = new RichTextBox();
-        Assert.Throws<ArgumentNullException>("data", () => control.LoadFile((Stream)null, RichTextBoxStreamType.RichText));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RichTextBoxStreamType>]
-    public void RichTextBox_LoadFile_InvalidFileType_ThrowsInvalidEnumArgumentException(RichTextBoxStreamType fileType)
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        Assert.Throws<InvalidEnumArgumentException>("fileType", () => control.LoadFile(stream, fileType));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RichTextBoxStreamType.RichNoOleObjs)]
-    [InlineData(RichTextBoxStreamType.TextTextOleObjs)]
-    public void RichTextBox_LoadFile_UnprocessableFileType_ThrowsArgumentException(RichTextBoxStreamType fileType)
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        Assert.Throws<ArgumentException>(() => control.LoadFile(stream, fileType));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_RichTextEmpty_ThrowsArgumentException()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText));
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_LoadFile_InvalidRtf_ThrowsArgumentException()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        byte[] buffer = Encoding.ASCII.GetBytes("Hello World");
-        stream.Write(buffer, 0, buffer.Length);
-        stream.Position = 0;
-
-        Assert.Throws<ArgumentException>(() => control.LoadFile(stream, RichTextBoxStreamType.RichText));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubRichTextBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_GetLineFromCharIndex_InvokeEmpty_Success(int index)
-    {
-        using var control = new RichTextBox();
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void RichTextBox_GetLineFromCharIndex_InvokeNotEmpty_Success(int index)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "text"
-        };
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void RichTextBox_GetLineFromCharIndex_InvokeEmptyWithHandle_Success(int index)
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void RichTextBox_GetLineFromCharIndex_InvokeNotEmptyWithHandle_Success(int index)
-    {
-        using var control = new RichTextBox
-        {
-            Text = "text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetLineFromCharIndex_CustomLineFromChar_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1) };
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)1 };
-        yield return new object[] { (IntPtr)int.MaxValue };
-        yield return new object[] { PARAM.FromLowHigh(1, 2) };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetLineFromCharIndex_CustomLineFromChar_TestData))]
-    public void RichTextBox_GetLineFromCharIndex_CustomLineFromChar_Success(IntPtr result)
-    {
-        using var control = new CustomLineFromCharRichTextBox
-        {
-            LineFromCharResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, control.GetLineFromCharIndex(1));
-    }
-
-    private class CustomLineFromCharRichTextBox : RichTextBox
-    {
-        public IntPtr LineFromCharResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_LINEFROMCHAR)
-            {
-                Assert.Equal((IntPtr)1, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = LineFromCharResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    public static IEnumerable<object[]> GetLineFromCharIndex_CustomExLineFromChar_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1), -1 };
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)1, 1 };
-        yield return new object[] { (IntPtr)int.MaxValue, 0x7FFFFFFF };
-        yield return new object[] { PARAM.FromLowHigh(1, 2), 0x20001 };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetLineFromCharIndex_CustomExLineFromChar_TestData))]
-    public void RichTextBox_GetLineFromCharIndex_CustomExLineFromChar_Success(IntPtr result, int expected)
-    {
-        using var control = new CustomExLineFromCharRichTextBox
-        {
-            ExLineFromCharResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetLineFromCharIndex(1));
-    }
-
-    private class CustomExLineFromCharRichTextBox : RichTextBox
-    {
-        public IntPtr ExLineFromCharResult { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_EXLINEFROMCHAR)
-            {
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.Equal((IntPtr)1, m.LParam);
-                m.Result = ExLineFromCharResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void RichTextBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubRichTextBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubRichTextBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnContentsResized_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContentsResizedEventArgs(new Rectangle()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnContentsResized_TestData))]
-    public void RichTextBox_OnContentsResized_Invoke_CallsContentsResized(ContentsResizedEventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        int callCount = 0;
-        ContentsResizedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ContentsResized += handler;
-        control.OnContentsResized(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ContentsResized -= handler;
-        control.OnContentsResized(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnHScroll_Invoke_CallsHScroll(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HScroll += handler;
-        control.OnHScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HScroll -= handler;
-        control.OnHScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnImeChange_Invoke_CallsImeChange(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ImeChange += handler;
-        control.OnImeChange(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ImeChange -= handler;
-        control.OnImeChange(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLinkClicked_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new LinkClickedEventArgs(null) };
-        yield return new object[] { new LinkClickedEventArgs("") };
-        yield return new object[] { new LinkClickedEventArgs("text") };
-        yield return new object[] { new LinkClickedEventArgs("", 10, 0) };
-        yield return new object[] { new LinkClickedEventArgs("text", 10, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLinkClicked_TestData))]
-    public void RichTextBox_OnLinkClicked_Invoke_CallsLinkClicked(LinkClickedEventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        LinkClickedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LinkClicked += handler;
-        control.OnLinkClicked(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.LinkClicked -= handler;
-        control.OnLinkClicked(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> RichTextBox_InvalidLinkClickedEventArgs_TestData()
-    {
-        yield return new object[] { -1, 0 };
-        yield return new object[] { 0, -1 };
-        yield return new object[] { int.MaxValue, 1 };
-        yield return new object[] { 1, int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RichTextBox_InvalidLinkClickedEventArgs_TestData))]
-    public void RichTextBox_InvalidLinkClickedEventArgs_ThrowsArgumentOutOfRangeException(int linkStart, int linkLength)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>(() => new LinkClickedEventArgs("text", linkStart, linkLength));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnProtected_Invoke_CallsProtected(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Protected += handler;
-        control.OnProtected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Protected -= handler;
-        control.OnProtected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnSelectionChanged_Invoke_CallsSelectionChanged(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SelectionChanged += handler;
-        control.OnSelectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SelectionChanged -= handler;
-        control.OnSelectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnVScroll_Invoke_CallsVScroll(EventArgs eventArgs)
-    {
-        using var control = new SubRichTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VScroll += handler;
-        control.OnVScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.VScroll -= handler;
-        control.OnVScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Redo_Invoke_Success()
-    {
-        using var control = new RichTextBox();
-        control.Redo();
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.Redo();
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_Redo_InvokeWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Redo();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Redo();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokePlainTextEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokePlainTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokePlainTextEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokePlainTextNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeUnicodeTextEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeUnicodeTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.PlainText);
-        Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeUnicodePlainTextEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Empty(Encoding.Unicode.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeUnicodePlainTextNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.UnicodePlainText);
-        Assert.Equal("Hello World", Encoding.Unicode.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichTextEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichText);
-        string text = Encoding.ASCII.GetString(stream.ToArray());
-        Assert.StartsWith("{\\rtf", text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichTextNotEmpty_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichText);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichTextEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichText);
-        string text = Encoding.ASCII.GetString(stream.ToArray());
-        Assert.StartsWith("{\\rtf", text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichTextNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichText);
-        string text = Encoding.ASCII.GetString(stream.ToArray());
-        Assert.StartsWith("{\\rtf", text);
-        Assert.Contains("Hello World", text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeTextTextOleObjsEmpty_Success()
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeTextTextOleObjsNotEmpty_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeTextTextOleObjsEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeTextTextOleObjsNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.TextTextOleObjs);
-        Assert.Equal("Hello World", Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichNoOleObjsNotEmpty_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
-        Assert.Empty(Encoding.ASCII.GetString(stream.ToArray()));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichNoOleObjsEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
-        string text = Encoding.ASCII.GetString(stream.ToArray());
-        Assert.StartsWith("{\\rtf", text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_InvokeRichNoOleObjsNotEmptyWithHandle_Success()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Hello World"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var stream = new MemoryStream();
-        control.SaveFile(stream, RichTextBoxStreamType.RichNoOleObjs);
-        string text = Encoding.ASCII.GetString(stream.ToArray());
-        Assert.StartsWith("{\\rtf", text);
-        Assert.Contains("Hello World", text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_NullData_Nop()
-    {
-        using var control = new RichTextBox();
-        control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_NullDataWithText_Nop()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text"
-        };
-        control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_NullDataWithHandle_Nop()
-    {
-        using var control = new RichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SaveFile_NullDataWithTextWithHandle_Nop()
-    {
-        using var control = new RichTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SaveFile((Stream)null, RichTextBoxStreamType.RichText);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RichTextBoxStreamType>]
-    public void RichTextBox_SaveFile_InvalidFileType_ThrowsInvalidEnumArgumentException(RichTextBoxStreamType fileType)
-    {
-        using var control = new RichTextBox();
-        using var stream = new MemoryStream();
-        Assert.Throws<InvalidEnumArgumentException>("fileType", () => control.SaveFile(stream, fileType));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_SetAnsiRtf_DoesNotCorrupt()
-    {
-        // RichTextBox.Rtf treats input as code page specific (i.e. not Unicode). To see
-        // that we're actually using the code page we'll set the text to 0xA0 (160 / nbsp) to see
-        // that we can get it back out. If the encoding is not done in the codepage we'll likely
-        // get multiple ASCII bytes back out. UTF-8, for example, encodes the .NET UTF-16 0x00A0 (160)
-        // to 0xC2 0xA0.
-
-        // Ultimately we should really update RichTextBox to always stream data in Unicode as
-        // we're hard-coded to load 4.1 (see RichTextBox.CreateParams).
-
-        using var control = new RichTextBox();
-
-        Span<char> input = stackalloc char[] { (char)0xA0 };
-        control.Rtf = $"{{\\rtf1\\ansi {input[0]}}}";
-
-        Span<byte> output = stackalloc byte[16];
-
-        int currentCodePage = (CodePagesEncodingProvider.Instance.GetEncoding(0) ?? Encoding.UTF8).CodePage;
-
-        // The non-lossy conversion of nbsp only works single byte Windows code pages (e.g. not Japanese).
-        if (currentCodePage >= 1250 && currentCodePage <= 1258)
-        {
-            Assert.Equal(input[0], control.Text[0]);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_GetDlgCode_TestData()
-    {
-        yield return new object[] { true, (IntPtr)2 };
-        yield return new object[] { false, IntPtr.Zero };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_GetDlgCode_TestData))]
-    public void RichTextBox_WndProc_InvokeGetDlgCodeWithoutHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubRichTextBox
-            {
-                AcceptsTab = acceptsTabs
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_GETDLGCODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_GetDlgCode_TestData))]
-    public void RichTextBox_WndProc_InvokeGetDlgCodeWithHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
-    {
-        using var control = new SubRichTextBox
-        {
-            AcceptsTab = acceptsTabs
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_GETDLGCODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_WndProc_InvokeImeNotifyCallCountWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubRichTextBox();
-            int imeModeChangedCallCount = 0;
-            control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
-            int imeChangeCallCount = 0;
-            control.ImeChange += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                imeChangeCallCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_IME_NOTIFY,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, imeModeChangedCallCount);
-            Assert.Equal(1, imeChangeCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_WndProc_InvokeImeNotifyCallCountWithHandle_Success()
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int imeModeChangedCallCount = 0;
-        control.ImeModeChanged += (sender, e) => imeModeChangedCallCount++;
-        int imeChangeCallCount = 0;
-        control.ImeChange += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            imeChangeCallCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_IME_NOTIFY,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, imeModeChangedCallCount);
-        Assert.Equal(1, imeChangeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectCommand_TestData()
-    {
-        foreach (IntPtr lParam in new IntPtr[] { IntPtr.Zero, (IntPtr)1 })
-        {
-            yield return new object[] { IntPtr.Zero, lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_CHANGE), lParam, 1 };
-            yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_UPDATE), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_CHANGE), lParam, 1 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_HSCROLL), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_VSCROLL), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, 456), lParam, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommand_TestData))]
-    public void RichTextBox_WndProc_InvokeReflectCommandWithoutHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
-    {
-        using var control = new SubRichTextBox();
-
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            textChangedCallCount++;
-        };
-        int modifiedCallCount = 0;
-        control.ModifiedChanged += (sender, e) => modifiedCallCount++;
-        int hScrollCallCount = 0;
-        control.HScroll += (sender, e) => hScrollCallCount++;
-        int vScrollCallCount = 0;
-        control.VScroll += (sender, e) => vScrollCallCount++;
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-            WParam = wParam,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
-        Assert.Equal(0, hScrollCallCount);
-        Assert.Equal(0, vScrollCallCount);
-        Assert.Equal(0, modifiedCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommand_TestData))]
-    public void RichTextBox_WndProc_InvokeReflectCommandWithHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            textChangedCallCount++;
-        };
-        int hScrollCallCount = 0;
-        control.HScroll += (sender, e) => hScrollCallCount++;
-        int vScrollCallCount = 0;
-        control.VScroll += (sender, e) => vScrollCallCount++;
-        int modifiedCallCount = 0;
-        control.ModifiedChanged += (sender, e) => modifiedCallCount++;
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-            WParam = wParam,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
-        Assert.Equal(0, hScrollCallCount);
-        Assert.Equal(0, vScrollCallCount);
-        Assert.Equal(0, modifiedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectCommandWithLParam_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, 0, 0, 0 };
-        yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_CHANGE), 1, 0, 0 };
-        yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_UPDATE), 0, 0, 0 };
-        yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_CHANGE), 1, 0, 0 };
-        yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_HSCROLL), 0, 1, 0 };
-        yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_VSCROLL), 0, 0, 1 };
-        yield return new object[] { PARAM.FromLowHigh(123, 456), 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommandWithLParam_TestData))]
-    public void RichTextBox_WndProc_InvokeReflectCommandWithHandleWithLParam_Success(IntPtr wParam, int expectedTextChangedCallCount, int expectedHScrollCallCount, int expectedVScrollCallCount)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            textChangedCallCount++;
-        };
-        int hScrollCallCount = 0;
-        control.HScroll += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            hScrollCallCount++;
-        };
-        int vScrollCallCount = 0;
-        control.VScroll += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            vScrollCallCount++;
-        };
-        int modifiedCallCount = 0;
-        control.ModifiedChanged += (sender, e) => modifiedCallCount++;
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_COMMAND),
-            WParam = wParam,
-            LParam = control.Handle,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
-        Assert.Equal(expectedHScrollCallCount, hScrollCallCount);
-        Assert.Equal(expectedVScrollCallCount, vScrollCallCount);
-        Assert.Equal(0, modifiedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectNotify_TestData()
-    {
-        foreach (IntPtr hWnd in new IntPtr[] { IntPtr.Zero, (IntPtr)1 })
-        {
-            yield return new object[] { hWnd, (int)Richedit.EN.LINK };
-            yield return new object[] { hWnd, (int)Richedit.EN.DROPFILES };
-            yield return new object[] { hWnd, (int)Richedit.EN.REQUESTRESIZE };
-            yield return new object[] { hWnd, (int)Richedit.EN.SELCHANGE };
-            yield return new object[] { hWnd, (int)Richedit.EN.PROTECTED };
-            yield return new object[] { hWnd, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotify_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithoutHandle_Success(IntPtr hWnd, int code)
-    {
-        using var control = new SubRichTextBox();
-
-        NMHDR nmhdr = new()
-        {
-            code = (uint)code
-        };
-
-        Message m = new()
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = hWnd,
-            LParam = (IntPtr)(&nmhdr),
-            Result = (IntPtr)250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)0, m.Result);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndDropFiles_Success()
-    {
-        using var control = new SubRichTextBox
-        {
-            Text = "text"
-        };
-
-        var dropFiles = new ENDROPFILES
-        {
-            nmhdr = new NMHDR
-            {
-                code = (int)Richedit.EN.DROPFILES
-            }
-        };
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = control.Handle,
-            LParam = (IntPtr)(&dropFiles),
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)1, m.Result);
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectNotifyWithHWndSelChange_TestData()
-    {
-        yield return new object[] { -1, -1, -1, 0 };
-        yield return new object[] { -2, -1, -1, 1 };
-        yield return new object[] { 0, -1, -1, 1 };
-        yield return new object[] { 1, -1, -1, 1 };
-        yield return new object[] { -1, -2, -1, 1 };
-        yield return new object[] { -1, 0, -1, 1 };
-        yield return new object[] { -1, 1, -1, 1 };
-        yield return new object[] { -1, -1, (int)SEL.EMPTY, 1 };
-        yield return new object[] { -1, -1, (int)SEL.TEXT, 1 };
-        yield return new object[] { 0, 1, (int)SEL.TEXT, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotifyWithHWndSelChange_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndSelChange_Success(int min, int max, int selectionType, int expectedSelectionChangedCallCount)
-    {
-        using var control = new SubRichTextBox();
-
-        int selectionChangedCallCount = 0;
-        control.SelectionChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectionChangedCallCount++;
-        };
-        var selChange = new SELCHANGE
-        {
-            nmhdr = new NMHDR
-            {
-                code = (int)Richedit.EN.SELCHANGE
-            },
-            chrg = new CHARRANGE
-            {
-                cpMin = min,
-                cpMax = max
-            },
-            seltyp = (SEL)selectionType
-        };
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = control.Handle,
-            LParam = (IntPtr)(&selChange),
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedSelectionChangedCallCount, selectionChangedCallCount);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectNotifyWithHWndProtected_TestData()
-    {
-        yield return new object[] { 0, (IntPtr)1, 1 };
-        yield return new object[] { CFM.ALLCAPS, (IntPtr)1, 1 };
-        yield return new object[] { CFM.PROTECTED, IntPtr.Zero, 0 };
-        yield return new object[] { CFM.PROTECTED | CFM.ALLCAPS, IntPtr.Zero, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotifyWithHWndProtected_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHWndProtected_Success(int mask, IntPtr expectedResult, int expectedProtectedCallCount)
-    {
-        using var control = new SubRichTextBox();
-        int protectedCallCount = 0;
-        control.Protected += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            protectedCallCount++;
-        };
-
-        var format = new CHARFORMAT2W
-        {
-            dwMask = (CFM)mask
-        };
-        IntPtr ptr = Marshal.AllocCoTaskMem(100);
-        try
-        {
-            Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)Richedit.EN.PROTECTED);
-            Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvoke.EM_SETCHARFORMAT);
-            Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format));
-            var m = new Message
-            {
-                Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-                HWnd = control.Handle,
-                LParam = ptr,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)expectedResult, m.Result);
-            Assert.Equal(expectedProtectedCallCount, protectedCallCount);
-            Assert.True(control.IsHandleCreated);
-        }
-        finally
-        {
-            Marshal.FreeCoTaskMem(ptr);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotify_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandle_Success(IntPtr hWnd, int code)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        NMHDR nmhdr = new()
-        {
-            code = (uint)code
-        };
-
-        Message m = new()
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = hWnd,
-            LParam = (IntPtr)(&nmhdr),
-            Result = (IntPtr)250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)0, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndDropFiles_Success()
-    {
-        using var control = new SubRichTextBox
-        {
-            Text = "text"
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var dropFiles = new ENDROPFILES
-        {
-            nmhdr = new NMHDR
-            {
-                code = (int)Richedit.EN.DROPFILES
-            }
-        };
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = control.Handle,
-            LParam = (IntPtr)(&dropFiles),
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)1, m.Result);
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectNotifyWithHwndRequestResize_TestData()
-    {
-        yield return new object[] { BorderStyle.Fixed3D, Rectangle.Empty, new Rectangle(0, 0, 0, 1) };
-        yield return new object[] { BorderStyle.FixedSingle, Rectangle.Empty, Rectangle.Empty };
-        yield return new object[] { BorderStyle.None, Rectangle.Empty, Rectangle.Empty };
-
-        yield return new object[] { BorderStyle.Fixed3D, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 5) };
-        yield return new object[] { BorderStyle.FixedSingle, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { BorderStyle.None, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotifyWithHwndRequestResize_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndRequestResize_Success(BorderStyle borderStyle, Rectangle result, Rectangle expected)
-    {
-        using var control = new SubRichTextBox
-        {
-            BorderStyle = borderStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int contentsResizedCallCount = 0;
-        control.ContentsResized += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expected, e.NewRectangle);
-            contentsResizedCallCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int resizeCallCount = 0;
-        control.Resize += (sender, e) => resizeCallCount++;
-        var reqResize = new REQRESIZE
-        {
-            nmhdr = new NMHDR
-            {
-                code = (int)Richedit.EN.REQUESTRESIZE
-            },
-            rc = result
-        };
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = control.Handle,
-            LParam = (IntPtr)(&reqResize),
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(1, contentsResizedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotifyWithHWndSelChange_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndSelChange_Success(int min, int max, int selectionType, int expectedSelectionChangedCallCount)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int selectionChangedCallCount = 0;
-        control.SelectionChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectionChangedCallCount++;
-        };
-        var selChange = new SELCHANGE
-        {
-            nmhdr = new NMHDR
-            {
-                code = (int)Richedit.EN.SELCHANGE
-            },
-            chrg = new CHARRANGE
-            {
-                cpMin = min,
-                cpMax = max
-            },
-            seltyp = (SEL)selectionType
-        };
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-            HWnd = control.Handle,
-            LParam = (IntPtr)(&selChange),
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedSelectionChangedCallCount, selectionChangedCallCount);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectNotifyWithHWndProtected_TestData))]
-    public unsafe void RichTextBox_WndProc_InvokeReflectNotifyWithHandleWithHWndProtected_Success(int mask, IntPtr expectedResult, int expectedProtectedCallCount)
-    {
-        using var control = new SubRichTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int protectedCallCount = 0;
-        control.Protected += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            protectedCallCount++;
-        };
-
-        var format = new CHARFORMAT2W
-        {
-            dwMask = (CFM)mask
-        };
-        IntPtr ptr = Marshal.AllocCoTaskMem(100);
-        try
-        {
-            Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)Richedit.EN.PROTECTED);
-            Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvoke.EM_SETCHARFORMAT);
-            Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format));
-            var m = new Message
-            {
-                Msg = (int)(MessageId.WM_REFLECT_NOTIFY),
-                HWnd = control.Handle,
-                LParam = ptr,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal((IntPtr)expectedResult, m.Result);
-            Assert.Equal(expectedProtectedCallCount, protectedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            Marshal.FreeCoTaskMem(ptr);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void RichTextBox_WndProc_InvokeSetFontWithoutHandle_ReturnsExpected(bool multiline, int expectedMargin)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubRichTextBox
-            {
-                Multiline = multiline
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_SETFONT,
-                Result = (IntPtr)250
-            };
-            int textChangedCallCount = 0;
-            control.TextChanged += (sender, e) => textChangedCallCount++;
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, textChangedCallCount);
-            IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-            Assert.Equal(expectedMargin, PARAM.HIWORD(result));
-            Assert.Equal(expectedMargin, PARAM.LOWORD(result));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1, 2)]
-    [InlineData(false, 0, 0)]
-    public void RichTextBox_WndProc_InvokeSetFontWithHandle_ReturnsExpected(bool multiline, int expectedLeft, int expectedRight)
-    {
-        using var control = new SubRichTextBox
-        {
-            Multiline = multiline
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        PInvoke.SendMessage(control, PInvoke.EM_SETMARGINS, (WPARAM)(uint)(PInvoke.EC_LEFTMARGIN | PInvoke.EC_RIGHTMARGIN), LPARAM.MAKELPARAM(1, 2));
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) => textChangedCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFONT,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, textChangedCallCount);
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-        Assert.Equal(expectedLeft, PARAM.LOWORD(result));
-        Assert.Equal(expectedRight, PARAM.HIWORD(result));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CheckDefaultNativeControlVersions()
-    {
-        using var control = new RichTextBox();
-        control.CreateControl();
-
-        Assert.Contains("RICHEDIT50W", GetClassName(control.HWND), StringComparison.Ordinal);
-    }
-
-    [WinFormsFact]
-    public void RichTextBox_CheckRichEditWithVersionCanCreateOldVersions()
-    {
-        using (var riched32 = new RichEdit())
-        {
-            riched32.CreateControl();
-            Assert.Contains(".RichEdit.", GetClassName(riched32.HWND), StringComparison.Ordinal);
-        }
-
-        using (var riched20 = new RichEdit20W())
-        {
-            riched20.CreateControl();
-            Assert.Contains(".RichEdit20W.", GetClassName(riched20.HWND), StringComparison.Ordinal);
-
-            string rtfString = @"{\rtf1\ansi{" +
-                @"The next line\par " +
-                @"is {\v ###NOT### }hidden\par in plain text!}}";
-
-            riched20.Rtf = rtfString;
-
-            using var richTextBox = new RichTextBox();
-            richTextBox.CreateControl();
-            richTextBox.Rtf = rtfString;
-
-            Assert.Equal(riched20.TextLength, richTextBox.TextLength);
-            Assert.Equal(riched20.Text, richTextBox.Text);
-            Assert.Equal(richTextBox.Text.Length, richTextBox.TextLength);
-
-            int startOfIs = riched20.Text.IndexOf("is", StringComparison.Ordinal);
-            int endOfHidden = riched20.Text.IndexOf("hidden", StringComparison.Ordinal) + "hidden".Length;
-            richTextBox.Select(startOfIs, endOfHidden - startOfIs);
-            Assert.Equal("is ###NOT### hidden", richTextBox.SelectedText);
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void RichTextBox_OnGotFocus_RaisesAutomationNotification_WithText(EventArgs eventArgs)
-    {
-        Mock<Control> mockParent = new() { CallBase = true };
-        Mock<Control.ControlAccessibleObject> mockAccessibleObject = new(MockBehavior.Strict, mockParent.Object);
-        mockAccessibleObject
-            .Setup(a => a.InternalRaiseAutomationNotification(
-                It.IsAny<AutomationNotificationKind>(),
-                It.IsAny<AutomationNotificationProcessing>(),
-                It.IsAny<string>()))
-            .Returns(true)
-            .Verifiable();
-        mockParent.Protected().Setup<AccessibleObject>("CreateAccessibilityInstance")
-            .Returns(mockAccessibleObject.Object);
-
-        using Control parent = mockParent.Object;
-        string richTextBoxContent = "RichTextBox";
-        using var control = new SubRichTextBox
-        {
-            Parent = parent,
-            Text = richTextBoxContent,
-        };
-
-        // Enforce accessible object creation
-        Assert.Equal(mockAccessibleObject.Object, parent.AccessibilityObject);
-
-        control.OnGotFocus(eventArgs);
-
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(
-            AutomationNotificationKind.Other,
-            AutomationNotificationProcessing.MostRecent,
-            richTextBoxContent),
-            Times.Once);
-    }
-
-    private class CustomGetParaFormatRichTextBox : RichTextBox
-    {
-        public bool MakeCustom { get; set; }
-        public IntPtr ExpectedWParam { get; set; }
-        public PARAFORMAT GetParaFormatResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.EM_GETPARAFORMAT)
-            {
-                PARAFORMAT* format = (PARAFORMAT*)m.LParam;
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.NotEqual(IntPtr.Zero, m.LParam);
-                *format = GetParaFormatResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class CustomGetCharFormatRichTextBox : RichTextBox
-    {
-        public bool MakeCustom { get; set; }
-        public IntPtr ExpectedWParam { get; set; }
-        public CHARFORMAT2W GetCharFormatResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.EM_GETCHARFORMAT)
-            {
-                CHARFORMAT2W* format = (CHARFORMAT2W*)m.LParam;
-                Assert.Equal(ExpectedWParam, m.WParam);
-                Assert.NotEqual(IntPtr.Zero, m.LParam);
-                *format = GetCharFormatResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class CantCreateHandleRichTextBox : RichTextBox
-    {
-        protected override void CreateHandle()
-        {
-            // Nop.
-        }
-    }
-
-    private class SubRichTextBox : RichTextBox
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnContentsResized(ContentsResizedEventArgs e) => base.OnContentsResized(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHScroll(EventArgs e) => base.OnHScroll(e);
-
-        public new void OnImeChange(EventArgs e) => base.OnImeChange(e);
-
-        public new void OnLinkClicked(LinkClickedEventArgs e) => base.OnLinkClicked(e);
-
-        public new void OnProtected(EventArgs e) => base.OnProtected(e);
-
-        public new void OnSelectionChanged(EventArgs e) => base.OnSelectionChanged(e);
-
-        public new void OnVScroll(EventArgs e) => base.OnVScroll(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private static unsafe string GetClassName(HWND hWnd)
-    {
-        int length = 0;
-        Span<char> buffer = stackalloc char[PInvoke.MaxClassName];
-        fixed (char* lpClassName = buffer)
-        {
-            length = PInvoke.GetClassName(hWnd, lpClassName, buffer.Length);
-        }
-
-        return new string(buffer[..length]);
-    }
-
-    /// <summary>
-    /// Represents RichEdit 1.0 control.
-    /// </summary>
-    private class RichEdit : RichEditWithVersion
-    {
-        protected override string NativeDll => "riched32.dll";
-        protected override string WindowClassName => "RichEdit";
-    }
-
-    /// <summary>
-    /// Represents RichEdit 2.0 control.
-    /// </summary>
-    private class RichEdit20W : RichEditWithVersion
-    {
-        protected override string NativeDll => "riched20.dll";
-        protected override string WindowClassName => "RichEdit20W";
-    }
-
-    private abstract class RichEditWithVersion : RichTextBox
-    {
-        // NOTE: Do not unload the library once it is loaded!
-        // To prevent race conditions where one thread unloads the library
-        // while another thread instantiates the control.
-        private IntPtr _nativeDllHandle = IntPtr.Zero;
-
-        protected abstract string NativeDll { get; }
-        protected abstract string WindowClassName { get; }
-
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                // This code is copied and adapted from the original RichTextBox implemenation
-                // https://referencesource.microsoft.com/#System.Windows.Forms/winforms/Managed/System/WinForms/RichTextBox.cs,357
-
-                if (_nativeDllHandle == IntPtr.Zero)
-                {
-                    _nativeDllHandle = PInvoke.LoadLibraryFromSystemPathIfAvailable(NativeDll);
-
-                    int lastWin32Error = Marshal.GetLastWin32Error();
-                    if ((ulong)_nativeDllHandle < (ulong)32)
-                    {
-                        throw new Win32Exception(lastWin32Error, $"Failed to load '{NativeDll}'");
-                    }
-                }
-
-                CreateParams cp = base.CreateParams;
-
-                cp.ClassName = WindowClassName;
-
-                return cp;
-            }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RowStyleTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RowStyleTests.cs
deleted file mode 100644
index 6b6f7373b75..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/RowStyleTests.cs
+++ /dev/null
@@ -1,141 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class RowStyleTests
-{
-    [WinFormsFact]
-    public void RowStyle_Ctor_Default()
-    {
-        var style = new RowStyle();
-        Assert.Equal(SizeType.AutoSize, style.SizeType);
-        Assert.Equal(0, style.Height);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SizeType>]
-    [InvalidEnumData<SizeType>]
-    public void RowStyle_Ctor_SizeType(SizeType sizeType)
-    {
-        var style = new RowStyle(sizeType);
-        Assert.Equal(sizeType, style.SizeType);
-        Assert.Equal(0, style.Height);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SizeType.AutoSize, 0)]
-    [InlineData(SizeType.Absolute, 1)]
-    [InlineData(SizeType.Percent, 2)]
-    [InlineData((SizeType)(SizeType.AutoSize - 1), 3)]
-    [InlineData((SizeType)(SizeType.Percent + 1), 4)]
-    public void RowStyle_Ctor_SizeType_Float(SizeType sizeType, float width)
-    {
-        var style = new RowStyle(sizeType, width);
-        Assert.Equal(sizeType, style.SizeType);
-        Assert.Equal(width, style.Height);
-    }
-
-    [WinFormsFact]
-    public void RowStyle_Ctor_NegativeHeight_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new RowStyle(SizeType.AutoSize, -1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(float.MaxValue)]
-    public void RowStyle_Height_Set_GetReturnsExpected(float value)
-    {
-        var style = new RowStyle
-        {
-            Height = value
-        };
-        Assert.Equal(value, style.Height);
-
-        // Set same.
-        style.Height = value;
-        Assert.Equal(value, style.Height);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(float.MaxValue, 1)]
-    public void RowStyle_Height_SetWithOwner_GetReturnsExpected(float value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new RowStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.Height = value;
-        Assert.Equal(value, style.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        style.Height = value;
-        Assert.Equal(value, style.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(float.MaxValue, 1)]
-    public void RowStyle_Height_SetWithOwnerWithHandle_GetReturnsExpected(float value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new RowStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.Height = value;
-        Assert.Equal(value, style.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        style.Height = value;
-        Assert.Equal(value, style.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void RowStyle_Height_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        var style = new RowStyle();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => style.Height = -1);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SaveFileDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SaveFileDialogTests.cs
deleted file mode 100644
index 4824b1997ec..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SaveFileDialogTests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class SaveFileDialogTests
-{
-    [WinFormsFact]
-    public void SaveFileDialog_Ctor_Default()
-    {
-        using var dialog = new SaveFileDialog();
-        Assert.True(dialog.CheckWriteAccess);
-        Assert.False(dialog.CreatePrompt);
-        Assert.True(dialog.ExpandedMode);
-        Assert.True(dialog.OverwritePrompt);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SaveFileDialog_CheckWriteAccess_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SaveFileDialog
-        {
-            CheckWriteAccess = value
-        };
-        Assert.Equal(value, dialog.CheckWriteAccess);
-
-        // Set same.
-        dialog.CheckWriteAccess = value;
-        Assert.Equal(value, dialog.CheckWriteAccess);
-
-        // Set different.
-        dialog.CheckWriteAccess = !value;
-        Assert.Equal(!value, dialog.CheckWriteAccess);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SaveFileDialog_CreatePrompt_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SaveFileDialog
-        {
-            CreatePrompt = value
-        };
-        Assert.Equal(value, dialog.CreatePrompt);
-
-        // Set same.
-        dialog.CreatePrompt = value;
-        Assert.Equal(value, dialog.CreatePrompt);
-
-        // Set different.
-        dialog.CreatePrompt = !value;
-        Assert.Equal(!value, dialog.CreatePrompt);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SaveFileDialog_ExpandedMode_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SaveFileDialog
-        {
-            ExpandedMode = value
-        };
-        Assert.Equal(value, dialog.ExpandedMode);
-
-        // Set same.
-        dialog.ExpandedMode = value;
-        Assert.Equal(value, dialog.ExpandedMode);
-
-        // Set different.
-        dialog.ExpandedMode = !value;
-        Assert.Equal(!value, dialog.ExpandedMode);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SaveFileDialog_OverwritePrompt_Set_GetReturnsExpected(bool value)
-    {
-        using var dialog = new SaveFileDialog
-        {
-            OverwritePrompt = value
-        };
-        Assert.Equal(value, dialog.OverwritePrompt);
-
-        // Set same.
-        dialog.OverwritePrompt = value;
-        Assert.Equal(value, dialog.OverwritePrompt);
-
-        // Set different.
-        dialog.OverwritePrompt = !value;
-        Assert.Equal(!value, dialog.OverwritePrompt);
-    }
-
-    [WinFormsFact]
-    public void SaveFileDialog_Reset_Invoke_Success()
-    {
-        using var dialog = new SaveFileDialog
-        {
-            CheckWriteAccess = false,
-            CreatePrompt = true,
-            ExpandedMode = false,
-            OverwritePrompt = false
-        };
-
-        dialog.Reset();
-        Assert.True(dialog.CheckWriteAccess);
-        Assert.False(dialog.CreatePrompt);
-        Assert.True(dialog.ExpandedMode);
-        Assert.True(dialog.OverwritePrompt);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenDcCacheTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenDcCacheTests.cs
deleted file mode 100644
index 18914b4310f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenDcCacheTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ScreenDcCacheTests
-{
-    [Fact(Skip = "Run manually, takes a few minutes and is very resource intensive.")]
-    public void StressTest()
-    {
-        Random random = new Random();
-        using ScreenDcCache cache = new ScreenDcCache();
-
-        for (int i = 0; i < 10000; i++)
-        {
-            Thread.Sleep(random.Next(5));
-            Task.Run(() =>
-            {
-                using var screen = cache.Acquire();
-                Assert.False(screen.HDC.IsNull);
-                Thread.Sleep(random.Next(5));
-            });
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenTests.cs
deleted file mode 100644
index 319f2f272e4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScreenTests.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ScreenTests
-{
-    [Fact]
-    public void Screen_AllScreens_Get_ReturnsExpected()
-    {
-        Screen[] screens = Screen.AllScreens;
-        Assert.NotEmpty(screens);
-        Assert.Same(screens, Screen.AllScreens);
-
-        foreach (Screen screen in screens)
-        {
-            VerifyScreen(screen);
-        }
-
-        Assert.Contains(screens, s => s.Primary);
-    }
-
-    [Fact]
-    public void Screen_PrimaryScreen_Get_ReturnsExpected()
-    {
-        Screen screen = Screen.PrimaryScreen;
-        Assert.NotNull(screen);
-        VerifyScreen(screen);
-    }
-
-    public static IEnumerable<object[]> Equals_Screen_TestData()
-    {
-        var screen = new Screen((HMONITOR)1);
-        yield return new object[] { screen, screen, true };
-        yield return new object[] { screen, new Screen((HMONITOR)1), true };
-        yield return new object[] { screen, new Screen((HMONITOR)2), false };
-    }
-
-    public static IEnumerable<object[]> Equals_Object_TestData()
-    {
-        var screen = new Screen((HMONITOR)1);
-        yield return new object[] { screen, new object(), false };
-        yield return new object[] { screen, null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Screen_TestData))]
-    [MemberData(nameof(Equals_Object_TestData))]
-    public void Screen_Equals_Invoke_ReturnsExpected(Screen screen, object obj, bool expected)
-    {
-        Assert.Equal(expected, screen.Equals(obj));
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_Screen_TestData))]
-    public void Screen_GetHashCode_Invoke_ReturnsExpected(Screen screen1, Screen screen2, bool expected)
-    {
-        Assert.Equal(expected, screen1.GetHashCode().Equals(screen2.GetHashCode()));
-    }
-
-    public static IEnumerable<object[]> FromControl_TestData()
-    {
-        yield return new object[] { new Control() };
-
-        var createdControl = new Control();
-        Assert.NotEqual(IntPtr.Zero, createdControl.Handle);
-        yield return new object[] { createdControl };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromControl_TestData))]
-    public void Screen_FromControl_Invoke_ReturnsExpected(Control control)
-    {
-        Screen screen = Screen.FromControl(control);
-        Assert.NotNull(screen);
-        VerifyScreen(screen);
-    }
-
-    [Fact]
-    public void Screen_FromControl_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("control", () => Screen.FromControl(null));
-    }
-
-    public static IEnumerable<object[]> FromHandle_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { new Control().Handle };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromHandle_TestData))]
-    public void Screen_FromHandle_Invoke_ReturnsExpected(IntPtr handle)
-    {
-        Screen screen = Screen.FromHandle(handle);
-        Assert.NotNull(screen);
-        VerifyScreen(screen);
-    }
-
-    public static IEnumerable<object[]> FromPoint_TestData()
-    {
-        yield return new object[] { new Point(-1, -2) };
-        yield return new object[] { new Point(0, 0) };
-        yield return new object[] { new Point(1, 2) };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue) };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromPoint_TestData))]
-    public void Screen_FromPoint_Invoke_ReturnsExpected(Point point)
-    {
-        Screen screen = Screen.FromPoint(point);
-        Assert.NotNull(screen);
-        VerifyScreen(screen);
-    }
-
-    public static IEnumerable<object[]> FromRectangle_TestData()
-    {
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(int.MaxValue, int.MaxValue, int.MaxValue, int.MaxValue) };
-    }
-
-    [Theory]
-    [MemberData(nameof(FromRectangle_TestData))]
-    public void Screen_FromRectangle_Invoke_ReturnsExpected(Rectangle rectangle)
-    {
-        Screen screen = Screen.FromRectangle(rectangle);
-        Assert.NotNull(screen);
-        VerifyScreen(screen);
-    }
-
-    [Theory]
-    [MemberData(nameof(FromControl_TestData))]
-    public void Screen_GetBounds_InvokeControl_ReturnsExpected(Control control)
-    {
-        Screen screen = Screen.FromControl(control);
-        Assert.Equal(screen.Bounds, Screen.GetBounds(control));
-    }
-
-    [Theory]
-    [MemberData(nameof(FromPoint_TestData))]
-    public void Screen_GetBounds_InvokePoint_ReturnsExpected(Point point)
-    {
-        Screen screen = Screen.FromPoint(point);
-        Assert.Equal(screen.Bounds, Screen.GetBounds(point));
-    }
-
-    [Theory]
-    [MemberData(nameof(FromRectangle_TestData))]
-    public void Screen_GetBounds_InvokeRectangle_ReturnsExpected(Rectangle rectangle)
-    {
-        Screen screen = Screen.FromRectangle(rectangle);
-        Assert.Equal(screen.Bounds, Screen.GetBounds(rectangle));
-    }
-
-    [Fact]
-    public void Screen_GetBounds_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("control", () => Screen.GetBounds(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(FromControl_TestData))]
-    public void Screen_GetWorkingArea_InvokeControl_ReturnsExpected(Control control)
-    {
-        Screen screen = Screen.FromControl(control);
-        Assert.Equal(screen.WorkingArea, Screen.GetWorkingArea(control));
-    }
-
-    [Theory]
-    [MemberData(nameof(FromPoint_TestData))]
-    public void Screen_GetWorkingArea_InvokePoint_ReturnsExpected(Point point)
-    {
-        Screen screen = Screen.FromPoint(point);
-        Assert.Equal(screen.WorkingArea, Screen.GetWorkingArea(point));
-    }
-
-    [Theory]
-    [MemberData(nameof(FromRectangle_TestData))]
-    public void Screen_GetWorkingArea_InvokeRectangle_ReturnsExpected(Rectangle rectangle)
-    {
-        Screen screen = Screen.FromRectangle(rectangle);
-        Assert.Equal(screen.WorkingArea, Screen.GetWorkingArea(rectangle));
-    }
-
-    [Fact]
-    public void Screen_GetWorkingArea_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("control", () => Screen.GetWorkingArea(null));
-    }
-
-    [Fact]
-    public void Screen_ToString_Invoke_ReturnsExpected()
-    {
-        Screen screen = Screen.PrimaryScreen;
-        Assert.Equal($"Screen[Bounds={screen.Bounds} WorkingArea={screen.WorkingArea} Primary=True DeviceName={screen.DeviceName}", screen.ToString());
-    }
-
-    private static void VerifyScreen(Screen screen)
-    {
-        Assert.Contains(screen.BitsPerPixel, new int[] { 1, 2, 4, 8, 16, 24, 32, 48, 64 });
-        Assert.True(screen.Bounds.Width != 0);
-        Assert.True(screen.Bounds.Height != 0);
-        Assert.InRange(screen.DeviceName.Length, 1, 32);
-        Assert.Equal(screen.DeviceName, screen.DeviceName.Trim('\0'));
-        Assert.InRange(screen.WorkingArea.Width, 0, screen.Bounds.Width);
-        Assert.InRange(screen.WorkingArea.Height, 0, screen.Bounds.Height);
-        Assert.InRange(screen.WorkingArea.X, screen.Bounds.X, screen.Bounds.X + screen.Bounds.Width);
-        Assert.InRange(screen.WorkingArea.Y, screen.Bounds.Y, screen.Bounds.Y + screen.Bounds.Width);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarAccessibleObjectTests.cs
deleted file mode 100644
index 4176180260a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,195 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ScrollBar_ScrollBarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ScrollBarAccessibleObject_ctor_ThrowsException_IfScrollBarAccessibleObjectIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ScrollBar.ScrollBarAccessibleObject(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ScrollBar)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ScrollBarAccessibleObject_Ctor_Default(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var scrollBar = new SubScrollBar();
-
-        if (createControl)
-        {
-            scrollBar.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarAccessibleObject_IsPatternSupported_Invoke_ReturnsExpected()
-    {
-        using var scrollBar = new SubScrollBar();
-        scrollBar.CreateControl();
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsPatternSupported(UIA.ValuePatternId));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.ScrollBarControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.IsValuePatternAvailablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "AutomId")]
-    [InlineData((int)UIA.RangeValueMaximumPropertyId, 100d)]
-    [InlineData((int)UIA.RangeValueMinimumPropertyId, 0d)]
-    [InlineData((int)UIA.RangeValueValuePropertyId, 0d)]
-    [InlineData((int)UIA.RangeValueLargeChangePropertyId, 10d)]
-    [InlineData((int)UIA.RangeValueSmallChangePropertyId, 1d)]
-    [InlineData((int)UIA.RangeValueIsReadOnlyPropertyId, false)]
-    public void ScrollBarAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var scrollBar = new SubScrollBar
-        {
-            AccessibleName = "TestName",
-            Name = "AutomId"
-        };
-
-        Assert.False(scrollBar.IsHandleCreated);
-        var scrollBarAccessibleObject = new ScrollBar.ScrollBarAccessibleObject(scrollBar);
-        object value = scrollBarAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ScrollBar scrollBar = new SubScrollBar();
-        scrollBar.AccessibleRole = role;
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using SubScrollBar scrollBar = new();
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(scrollBar.AccessibilityObject.RuntimeId, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ScrollBarAccessibleObject_GetPropertyValue_IsEnabled_ReturnsExpected(bool enabled)
-    {
-        using SubScrollBar scrollBar = new()
-        {
-            Enabled = enabled
-        };
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId);
-
-        Assert.Equal(scrollBar.Enabled, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsValuePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsRangeValuePatternAvailablePropertyId))]
-    public void ScrollBarAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using SubScrollBar scrollBar = new() { Enabled = true };
-        ScrollBar.ScrollBarAccessibleObject accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(100, 100d)]
-    [InlineData(1, 1d)]
-    [InlineData(0, 0d)]
-    [InlineData(50d, 50d)]
-    public void ScrollBarAccessibleObject_SetValue_Invoke_ReturnsExpected(int newValue, object expected)
-    {
-        using var scrollBar = new SubScrollBar();
-        scrollBar.CreateControl();
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        accessibleObject.SetValue(newValue);
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.RangeValueValuePropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.Equal(expected, (double)scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(101)]
-    [InlineData(-1)]
-    public void ScrollBarAccessibleObject_SetValue_OutOfRangeValue_ThrowExceptionExpected(int newValue)
-    {
-        using var scrollBar = new SubScrollBar();
-        scrollBar.CreateControl();
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => accessibleObject.SetValue(newValue));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    private class SubScrollBar : ScrollBar
-    {
-        public SubScrollBar() : base()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarChildAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarChildAccessibleObjectTests.cs
deleted file mode 100644
index 6184c5787bc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBar.ScrollBarChildAccessibleObjectTests.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.ScrollBar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ScrollBar_ScrollBarChildAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_Ctor_Default()
-    {
-        var accessibleObject = new ScrollBarChildAccessibleObject(null);
-        Assert.Null(accessibleObject.OwningScrollBar);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_Bounds_IsEmptyRectangle_IfOwningControlIsNotCreated()
-    {
-        using SubScrollBar control = new();
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_Bounds_IsEmptyRectangle_IfOwningControlIsNotVisible()
-    {
-        using SubScrollBar control = new();
-        control.CreateControl();
-        control.Visible = false;
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_Bounds_IsNotEmptyRectangle()
-    {
-        using SubScrollBar control = new();
-        control.CreateControl();
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using SubScrollBar control = new();
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using SubScrollBar control = new();
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBarChildAccessibleObject_IsDisplayed_ReturnsExpected(bool isVisible)
-    {
-        using SubScrollBar control = new();
-        control.Visible = isVisible;
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(isVisible, accessibleObject.IsDisplayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBarChildAccessibleObject_GetPropertyValue_ControlType_ReturnsExpected()
-    {
-        var accessibleObject = new ScrollBarChildAccessibleObject(null);
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBarChildAccessibleObject_GetPropertyValue_IsEnabled_ReturnsExpected(bool isEnabled)
-    {
-        using SubScrollBar control = new();
-        control.Enabled = isEnabled;
-        var accessibleObject = new ScrollBarChildAccessibleObject(control);
-
-        Assert.Equal(isEnabled, accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class SubScrollBar : ScrollBar
-    { }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBarTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBarTests.cs
deleted file mode 100644
index bc4d08048b8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollBarTests.cs
+++ /dev/null
@@ -1,3252 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ScrollBarTests
-{
-    [WinFormsFact]
-    public void ScrollBar_Ctor_Default()
-    {
-        using var control = new SubScrollBar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, control.DefaultImeMode);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.Equal(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, control.Height);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(10, control.LargeChange);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ScaleScrollBarForDpiChange);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubScrollBar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ScrollBar", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new SubScrollBar
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ScrollBar_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubScrollBar
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void ScrollBar_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new SubScrollBar
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ScrollBar_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubScrollBar
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ScrollBar_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new SubScrollBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_Enabled_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ScrollBar_Enabled_GetScrollInfo_Updates()
-    {
-        using var control = new SubScrollBar
-        {
-            LargeChange = 15
-        };
-
-        // Enable.
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Enabled = true;
-        Assert.True(PInvoke.GetScrollInfo(control.HWND, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(15u, si.nPage);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.EnabledChanged += handler;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ScrollBar_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubScrollBar
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ScrollBar_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubScrollBar
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit)]
-    [InlineData(RightToLeft.No)]
-    [InlineData(RightToLeft.Yes)]
-    public unsafe void ScrollBar_Handle_GetDefault_ReturnsExpected(RightToLeft rightToLeft)
-    {
-        using var control = new SubScrollBar
-        {
-            RightToLeft = rightToLeft,
-            Minimum = 5,
-            Value = 25,
-            Maximum = 105,
-            LargeChange = 15,
-            SmallChange = 10,
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(5, si.nMin);
-        Assert.Equal(105, si.nMax);
-        Assert.Equal(25, si.nPos);
-        Assert.Equal(15u, si.nPage);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ScrollBar_ImeMode_Set_GetReturnsExpected(ImeMode value)
-    {
-        using var control = new SubScrollBar
-        {
-            ImeMode = value
-        };
-        Assert.Equal(value, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(value, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void ScrollBar_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new SubScrollBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(10)]
-    [InlineData(11)]
-    public void ScrollBar_LargeChange_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            LargeChange = value
-        };
-        Assert.Equal(value, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_LargeChange_SetLarge_GetReturnsExpected()
-    {
-        using var control = new SubScrollBar
-        {
-            Minimum = 5,
-            Maximum = 10,
-            LargeChange = 7
-        };
-        Assert.Equal(6, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Change maximum.
-        control.Maximum = 15;
-        Assert.Equal(7, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(10)]
-    [InlineData(11)]
-    public unsafe void ScrollBar_LargeChange_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal((uint)value, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal((uint)value, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(10)]
-    [InlineData(11)]
-    public unsafe void ScrollBar_LargeChange_SetWithHandleDisabled_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_LargeChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubScrollBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.LargeChange = -1);
-        Assert.Equal(10, control.LargeChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(8, 9)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public void ScrollBar_Maximum_Set_GetReturnsExpected(int value, int expectedLargeChange)
-    {
-        using var control = new SubScrollBar
-        {
-            Maximum = value
-        };
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(8, 9)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public unsafe void ScrollBar_Maximum_SetWithHandle_GetReturnsExpected(int value, int expectedLargeChange)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(value, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal((uint)expectedLargeChange, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(value, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal((uint)expectedLargeChange, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(8, 9)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public unsafe void ScrollBar_Maximum_SetWithHandleDisabled_GetReturnsExpected(int value, int expectedLargeChange)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(expectedLargeChange, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, createdCallCount);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Maximum_SetLessThanValueAndMinimum_SetsValueAndMinimum()
-    {
-        using var control = new SubScrollBar
-        {
-            Value = 10,
-            Minimum = 8,
-            Maximum = 5
-        };
-        Assert.Equal(5, control.Maximum);
-        Assert.Equal(5, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(1, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Maximum_SetNegative_SetsValueAndMinimum()
-    {
-        using var control = new SubScrollBar
-        {
-            Maximum = -1
-        };
-        Assert.Equal(-1, control.Maximum);
-        Assert.Equal(-1, control.Minimum);
-        Assert.Equal(-1, control.Value);
-        Assert.Equal(1, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(5)]
-    public void ScrollBar_Minimum_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(5)]
-    public unsafe void ScrollBar_Minimum_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Minimum = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(100, si.nMax);
-        Assert.Equal(value, si.nMin);
-        Assert.Equal(5, si.nPos);
-        Assert.Equal(10u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(100, si.nMax);
-        Assert.Equal(value, si.nMin);
-        Assert.Equal(5, si.nPos);
-        Assert.Equal(10u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(5)]
-    public unsafe void ScrollBar_Minimum_SetWithHandleDisabled_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Value = 5,
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Minimum = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Minimum_SetGreaterThanValueAndMaximum_SetsValueAndMinimum()
-    {
-        using var control = new SubScrollBar
-        {
-            Value = 10,
-            Maximum = 8,
-            Minimum = 12
-        };
-        Assert.Equal(12, control.Maximum);
-        Assert.Equal(12, control.Minimum);
-        Assert.Equal(12, control.Value);
-        Assert.Equal(1, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ScrollBar_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new SubScrollBar
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ScrollBar_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new SubScrollBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_ScaleScrollBarForDpiChange_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar
-        {
-            ScaleScrollBarForDpiChange = value
-        };
-        Assert.Equal(value, control.ScaleScrollBarForDpiChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ScaleScrollBarForDpiChange = value;
-        Assert.Equal(value, control.ScaleScrollBarForDpiChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ScaleScrollBarForDpiChange = !value;
-        Assert.Equal(!value, control.ScaleScrollBarForDpiChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(5, 5)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public void ScrollBar_SmallChange_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new SubScrollBar
-        {
-            SmallChange = value
-        };
-        Assert.Equal(expected, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SmallChange = value;
-        Assert.Equal(expected, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_SmallChange_SetLarge_GetReturnsExpected()
-    {
-        using var control = new SubScrollBar
-        {
-            LargeChange = 10,
-            SmallChange = 11
-        };
-        Assert.Equal(10, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Change large change.
-        control.LargeChange = 15;
-        Assert.Equal(11, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(5, 5)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public void ScrollBar_SmallChange_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SmallChange = value;
-        Assert.Equal(expected, control.SmallChange);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SmallChange = value;
-        Assert.Equal(expected, control.SmallChange);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(5, 5)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public void ScrollBar_SmallChange_SetWithHandleDisabled_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SmallChange = value;
-        Assert.Equal(expected, control.SmallChange);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SmallChange = value;
-        Assert.Equal(expected, control.SmallChange);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_SmallChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubScrollBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SmallChange = -1);
-        Assert.Equal(1, control.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new SubScrollBar
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ScrollBar_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubScrollBar
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ScrollBar_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(90)]
-    [InlineData(91)]
-    [InlineData(100)]
-    public void ScrollBar_Value_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Value = value
-        };
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0)]
-    [InlineData(5, 5)]
-    [InlineData(90, 90)]
-    [InlineData(91, 91)]
-    [InlineData(100, 91)]
-    public unsafe void ScrollBar_Value_SetWithHandle_GetReturnsExpected(int value, int expectedPos)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Value = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(100, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(expectedPos, si.nPos);
-        Assert.Equal((uint)10u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(100, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(expectedPos, si.nPos);
-        Assert.Equal((uint)10u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(90)]
-    [InlineData(91)]
-    [InlineData(100)]
-    public unsafe void ScrollBar_Value_SetWithHandleDisabled_GetReturnsExpected(int value)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Value = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        var si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(10, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        si = new SCROLLINFO
-        {
-            cbSize = (uint)sizeof(SCROLLINFO),
-            fMask = SCROLLINFO_MASK.SIF_ALL
-        };
-        Assert.True(PInvoke.GetScrollInfo((HWND)control.Handle, SCROLLBAR_CONSTANTS.SB_CTL, ref si));
-        Assert.Equal(0, si.nMax);
-        Assert.Equal(0, si.nMin);
-        Assert.Equal(0, si.nPos);
-        Assert.Equal(0u, si.nPage);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_Value_SetWithHandler_CallsValueChanged()
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler valueChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ValueChanged += valueChangedHandler;
-
-        // Set different.
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Value = 2;
-        Assert.Equal(2, control.Value);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ValueChanged -= valueChangedHandler;
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(101)]
-    public void ScrollBar_Value_SetOutOfRange_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new SubScrollBar();
-        var paramName = "value";
-        ArgumentOutOfRangeException ex = Assert.Throws<ArgumentOutOfRangeException>(paramName, () => control.Value = value);
-        string expectedMessage = new ArgumentOutOfRangeException(paramName, string.Format(SR.InvalidBoundArgument, nameof(control.Value), value, $"'{nameof(control.Minimum)}'", $"'{nameof(control.Maximum)}'")).Message;
-        Assert.Equal(expectedMessage, ex.Message);
-        Assert.Equal(0, control.Value);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubScrollBar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, -6, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_TestData))]
-    public void ScrollBar_GetScaledBounds_Invoke_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new SubScrollBar();
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetScaledBounds_Vertical_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { Rectangle.Empty, new Size(0, 0), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(1, 1), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(2, 3), specified, Rectangle.Empty };
-            yield return new object[] { Rectangle.Empty, new Size(-2, -3), specified, Rectangle.Empty };
-        }
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.All, new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.X, new Rectangle(0, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Y, new Rectangle(1, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(0, 0), BoundsSpecified.Height, new Rectangle(1, 2, 3, 0) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.All, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.X, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Y, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(1, 1), BoundsSpecified.Height, new Rectangle(1, 2, 3, 4) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.All, new Rectangle(2, 6, 3, 12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.X, new Rectangle(2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Y, new Rectangle(1, 6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(2, 3), BoundsSpecified.Height, new Rectangle(1, 2, 3, 12) };
-
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.All, new Rectangle(-2, -6, 3, -12) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.X, new Rectangle(-2, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Y, new Rectangle(1, -6, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Width, new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Size(-2, -3), BoundsSpecified.Height, new Rectangle(1, 2, 3, -12) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetScaledBounds_Vertical_TestData))]
-    public void ScrollBar_GetScaledBounds_InvokeVertical_ReturnsExpected(Rectangle bounds, SizeF factor, BoundsSpecified specified, Rectangle expected)
-    {
-        using var control = new VerticalScrollBar();
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetScaledBounds(bounds, factor, specified));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ScrollBar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubScrollBar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubScrollBar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnEnabledChanged_Invoke_CallsEnabled(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnEnabledChanged_InvokeWithHandle_CallsEnabledChanged(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EnabledChanged += handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ScrollBar_OnMouseWheel_Invoke_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_OnMouseWheel_InvokeHandledMouseEventArgs_SetsHandled()
-    {
-        using var control = new SubScrollBar();
-        var eventArgs = new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4);
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.True(eventArgs.Handled);
-            callCount++;
-        };
-        control.MouseWheel += handler;
-
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(eventArgs.Handled);
-    }
-
-    public static IEnumerable<object[]> OnMouseWheel_TestData()
-    {
-        yield return new object[] { RightToLeft.No, 10, -119, new List<ScrollEventArgs>(), 10 };
-        yield return new object[] { RightToLeft.No, 10, 0, new List<ScrollEventArgs>(), 10 };
-        yield return new object[] { RightToLeft.No, 10, 119, new List<ScrollEventArgs>(), 10 };
-        yield return new object[] { RightToLeft.Yes, 10, -119, new List<ScrollEventArgs>(), 10 };
-        yield return new object[] { RightToLeft.Yes, 10, 0, new List<ScrollEventArgs>(), 10 };
-        yield return new object[] { RightToLeft.Yes, 10, 119, new List<ScrollEventArgs>(), 10 };
-
-        // Decrement.
-        yield return new object[]
-        {
-            RightToLeft.No, 10, 120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 9, 9),
-            }, 9
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 10, 121,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 9, 9),
-            }, 9
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 10, 240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 9, 8),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 8, 8),
-            }, 8
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 1, 120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 1, 0),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 0, 0),
-            }, 0
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 1, 240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 1, 0),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 0, 0),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 0, 0),
-            }, 0
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 100, 240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 100, 99),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 99, 98),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 98, 98),
-            }, 98
-        };
-
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, -120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 9, 9),
-            }, 9
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, -121,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 9, 9),
-            }, 9
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, -240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 10, 9),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 9, 8),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 8, 8),
-            }, 8
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 1, -120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 1, 0),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 0, 0),
-            }, 0
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 1, -240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 1, 0),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 0, 0),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 0, 0),
-            }, 0
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 100, -240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 100, 99),
-                new ScrollEventArgs(ScrollEventType.SmallDecrement, 99, 98),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 98, 98),
-            }, 98
-        };
-
-        // Increment.
-        yield return new object[]
-        {
-            RightToLeft.No, 10, -120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 11, 11),
-            }, 11
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 10, -121,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 11, 11),
-            }, 11
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 10, -240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 11, 12),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 12, 12),
-            }, 12
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 90, -120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 90, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 99, -120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 99, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-        yield return new object[]
-        {
-            RightToLeft.No, 99, -240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 99, 91),
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 91, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, 120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 11, 11),
-            }, 11
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, 121,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 11, 11),
-            }, 11
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 10, 240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 10, 11),
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 11, 12),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 12, 12),
-            }, 12
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 90, 120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 90, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 99, 120,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 99, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-        yield return new object[]
-        {
-            RightToLeft.Yes, 99, 240,
-            new List<ScrollEventArgs>
-            {
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 99, 91),
-                new ScrollEventArgs(ScrollEventType.SmallIncrement, 91, 91),
-                new ScrollEventArgs(ScrollEventType.EndScroll, 91, 91),
-            }, 91
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseWheel_TestData))]
-    public void ScrollBar_OnMouseWheel_InvokeWithScroll_CallsScroll(RightToLeft rightToLeft, int originalValue, int delta, IList<ScrollEventArgs> expected, int expectedValue)
-    {
-        using var control = new SubScrollBar
-        {
-            RightToLeft = rightToLeft,
-            Value = originalValue
-        };
-        var eventArgs = new MouseEventArgs(MouseButtons.Left, 0, 0, 0, delta);
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expected[callCount].Type, e.Type);
-            Assert.Equal(expected[callCount].NewValue, e.NewValue);
-            Assert.Equal(expected[callCount].OldValue, e.OldValue);
-            Assert.Equal(ScrollOrientation.HorizontalScroll, e.ScrollOrientation);
-            callCount++;
-        };
-        control.Scroll += handler;
-
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(expectedValue, control.Value);
-        Assert.Equal(expected.Count, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ScrollBar_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnScroll_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.SmallDecrement, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_TestData))]
-    public void ScrollBar_OnScroll_Invoke_CallsScroll(ScrollEventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollBar_OnValueChanged_Invoke_CallsValueChanged(EventArgs eventArgs)
-    {
-        using var control = new SubScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ValueChanged += handler;
-        control.OnValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ValueChanged -= handler;
-        control.OnValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ScaleScrollBarForDpi_WithSize_TestData()
-    {
-        yield return new object[] { true, 100, 200, ScrollOrientation.HorizontalScroll, new Size(10, 20), new Size(20, 20) };
-        yield return new object[] { true, 200, 100, ScrollOrientation.HorizontalScroll, new Size(10, 20), new Size(5, 20) };
-        yield return new object[] { true, 100, 200, ScrollOrientation.VerticalScroll, new Size(10, 20), new Size(10, 40) };
-        yield return new object[] { true, 200, 100, ScrollOrientation.VerticalScroll, new Size(10, 20), new Size(10, 10) };
-
-        yield return new object[] { false, 100, 200, ScrollOrientation.HorizontalScroll, new Size(10, 20), new Size(10, 20) };
-        yield return new object[] { false, 100, 100, ScrollOrientation.VerticalScroll, new Size(10, 20), new Size(10, 20) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScaleScrollBarForDpi_WithSize_TestData))]
-    public void ScrollBar_ScaleScrollBarForDpi_InvokeWithSize_Nop(bool scaleScrollBarForDpiChange, int deviceDpiOld, int deviceDpiNew, ScrollOrientation orientation, Size controlSize, Size expected)
-    {
-        using var control = new SubScrollBar
-        {
-            ScaleScrollBarForDpiChange = scaleScrollBarForDpiChange,
-            Size = controlSize
-        };
-
-        control.TestAccessor().Dynamic._scrollOrientation = orientation;
-
-        SizeF factor = new (((float)deviceDpiNew) / deviceDpiOld, ((float)deviceDpiNew) / deviceDpiOld);
-        control.ScaleControl(factor, factor, null);
-
-        Assert.Equal(expected, control.Size);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_UpdateScrollInfo_NoHandle_Success(bool enabled)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = enabled
-        };
-        control.UpdateScrollInfo();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_UpdateScrollInfo_WithHandle_Success(bool enabled)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = enabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateScrollInfo();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollBar_UpdateScrollInfo_WithHandleRightToLeft_Success(bool enabled)
-    {
-        using var control = new SubScrollBar
-        {
-            Enabled = enabled,
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpdateScrollInfo();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new SubScrollBar();
-        Assert.Equal("System.Windows.Forms.Tests.ScrollBarTests+SubScrollBar, Minimum: 0, Maximum: 100, Value: 0", control.ToString());
-    }
-
-    public static IEnumerable<object[]> WndProc_EraseBkgnd_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            foreach (bool allPaintingInWmPaint in new bool[] { true, false })
-            {
-                foreach (bool opaque in new bool[] { true, false })
-                {
-                    yield return new object[] { userPaint, allPaintingInWmPaint, opaque };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_EraseBkgnd_TestData))]
-    public void Control_WndProc_InvokeEraseBkgnd_Nop(bool userPaint, bool allPaintingInWmPaint, bool opaque)
-    {
-        using var control = new SubScrollBar();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        control.SetStyle(ControlStyles.AllPaintingInWmPaint, allPaintingInWmPaint);
-        control.SetStyle(ControlStyles.Opaque, opaque);
-        int paintCallCount = 0;
-        control.Paint += (sender, e) => paintCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_ERASEBKGND,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, paintCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_Scroll_TestData()
-    {
-        foreach (MessageId msg in new MessageId[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, MessageId.WM_REFLECT | PInvoke.WM_VSCROLL })
-        {
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.SmallIncrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.SmallIncrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.SmallIncrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.SmallIncrement, 86, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.SmallIncrement, 16, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.SmallIncrement, 11, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.SmallIncrement, 2, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.SmallIncrement, 1, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.SmallDecrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.SmallDecrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.SmallDecrement, 91, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.SmallDecrement, 86, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.SmallDecrement, 16, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.SmallDecrement, 11, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.SmallDecrement, 2, ScrollEventType.SmallIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.SmallDecrement, 1, ScrollEventType.SmallIncrement };
-
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.LargeIncrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.LargeIncrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.LargeIncrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.LargeIncrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.LargeIncrement, 25, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.LargeIncrement, 20, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.LargeIncrement, 11, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.LargeIncrement, 10, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.LargeDecrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.LargeDecrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.LargeDecrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.LargeDecrement, 91, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.LargeDecrement, 25, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.LargeDecrement, 20, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.LargeDecrement, 11, ScrollEventType.LargeIncrement };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.LargeDecrement, 10, ScrollEventType.LargeIncrement };
-
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.SmallDecrement, 99, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.SmallDecrement, 98, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.SmallDecrement, 90, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.SmallDecrement, 84, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.SmallDecrement, 14, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.SmallDecrement, 9, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.SmallDecrement, 0, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.SmallDecrement, 0, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.SmallIncrement, 99, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.SmallIncrement, 98, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.SmallIncrement, 90, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.SmallIncrement, 84, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.SmallIncrement, 14, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.SmallIncrement, 9, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.SmallIncrement, 0, ScrollEventType.SmallDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.SmallIncrement, 0, ScrollEventType.SmallDecrement };
-
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.LargeDecrement, 90, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.LargeDecrement, 89, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.LargeDecrement, 81, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.LargeDecrement, 75, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.LargeDecrement, 5, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.LargeDecrement, 0, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.LargeDecrement, 0, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.LargeDecrement, 0, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.LargeIncrement, 90, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.LargeIncrement, 89, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.LargeIncrement, 81, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.LargeIncrement, 75, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.LargeIncrement, 5, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.LargeIncrement, 0, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.LargeIncrement, 0, ScrollEventType.LargeDecrement };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.LargeIncrement, 0, ScrollEventType.LargeDecrement };
-
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.First, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.Last, 0, ScrollEventType.First };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.Last, 0, ScrollEventType.First };
-
-            yield return new object[] { msg, RightToLeft.No, 100, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 99, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 91, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 85, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 15, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 1, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.No, 0, ScrollEventType.Last, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 100, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 99, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 91, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 85, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 15, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 1, ScrollEventType.First, 91, ScrollEventType.Last };
-            yield return new object[] { msg, RightToLeft.Yes, 0, ScrollEventType.First, 91, ScrollEventType.Last };
-
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.EndScroll, 10, ScrollEventType.EndScroll };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.EndScroll, 10, ScrollEventType.EndScroll };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.ThumbPosition, 10, ScrollEventType.ThumbPosition };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.ThumbPosition, 10, ScrollEventType.ThumbPosition };
-            yield return new object[] { msg, RightToLeft.No, 10, ScrollEventType.ThumbTrack, 10, ScrollEventType.ThumbTrack };
-            yield return new object[] { msg, RightToLeft.Yes, 10, ScrollEventType.ThumbTrack, 10, ScrollEventType.ThumbTrack };
-            yield return new object[] { msg, RightToLeft.No, 10, (ScrollEventType)(ScrollEventType.SmallDecrement - 1), 10, (ScrollEventType)ushort.MaxValue };
-            yield return new object[] { msg, RightToLeft.Yes, 10, (ScrollEventType)(ScrollEventType.SmallDecrement - 1), 10, (ScrollEventType)ushort.MaxValue };
-            yield return new object[] { msg, RightToLeft.No, 10, (ScrollEventType)(ScrollEventType.EndScroll + 1), 10, (ScrollEventType)(ScrollEventType.EndScroll + 1) };
-            yield return new object[] { msg, RightToLeft.Yes, 10, (ScrollEventType)(ScrollEventType.EndScroll + 1), 10, (ScrollEventType)(ScrollEventType.EndScroll + 1) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_Scroll_TestData))]
-    public void ScrollBar_WndProc_InvokeScroll_Success(int msg, RightToLeft rightToLeft, int originalValue, ScrollEventType eventType, int expectedValue, ScrollEventType expectedEventType)
-    {
-        using var control = new SubScrollBar
-        {
-            RightToLeft = rightToLeft,
-            Value = originalValue
-        };
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedEventType, e.Type);
-            Assert.Equal(expectedValue, e.NewValue);
-            Assert.Equal(originalValue, e.OldValue);
-            Assert.Equal(ScrollOrientation.HorizontalScroll, e.ScrollOrientation);
-            callCount++;
-        };
-        control.Scroll += handler;
-
-        var message = new Message
-        {
-            Msg = msg,
-            WParam = (IntPtr)eventType
-        };
-        control.WndProc(ref message);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedValue, control.Value);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSizeWithoutHandle_Success()
-    {
-        using var control = new SubScrollBar();
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SIZE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Control_WndProc_InvokeSizeWithHandle_Success()
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SIZE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollBar_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubScrollBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.Yes, 50)]
-    [InlineData(RightToLeft.No, 50)]
-    [InlineData(RightToLeft.No, 100)]
-    public void HScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnRectangle(RightToLeft rightToLeft, int value)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum: 100, value);
-
-        Assert.True(HFirstPageButton(hScrollBar).Bounds.Width > 0);
-        Assert.True(HFirstPageButton(hScrollBar).Bounds.Height > 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, 100, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    [InlineData(RightToLeft.No, 100, 0)]
-    public void HScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle(RightToLeft rightToLeft, int maximum, int value)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.True(HFirstPageButton(hScrollBar).Bounds.Width == 0 || HFirstPageButton(hScrollBar).Bounds.Height == 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.No, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 100, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 0, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 100, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.No, 0, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 0, 0, AccessibleStates.Invisible)]
-    public void HScrollBarFirstPageButtonAccessibleObject_State_ReturnExpected(RightToLeft rightToLeft, int maximum, int value, AccessibleStates accessibleState)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.Equal(accessibleState, HFirstPageButton(hScrollBar).State);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0)]
-    [InlineData(RightToLeft.No, 50)]
-    [InlineData(RightToLeft.Yes, 100)]
-    [InlineData(RightToLeft.Yes, 50)]
-    public void HScrollBarLastPageButtonAccessibleObject_Bounds_ReturnRectangle(RightToLeft rightToLeft, int value)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum: 100, value);
-
-        Assert.True(HLastPageButton(hScrollBar).Bounds.Width > 0);
-        Assert.True(HLastPageButton(hScrollBar).Bounds.Height > 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 100)]
-    [InlineData(RightToLeft.Yes, 100, 0)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void HScrollBarLastPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle(RightToLeft rightToLeft, int maximum, int value)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.True(HLastPageButton(hScrollBar).Bounds.Width == 0 || HLastPageButton(hScrollBar).Bounds.Height == 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 0, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 100, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 100, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 100, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 0, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 0, 0, AccessibleStates.Invisible)]
-    public void HScrollBarLastPageButtonAccessibleObject_State_ReturnExpected(RightToLeft rightToLeft, int maximum, int value, AccessibleStates accessibleState)
-    {
-        using HScrollBar hScrollBar = new();
-        SetHScrollBar(hScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.Equal(accessibleState, HLastPageButton(hScrollBar).State);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 0)]
-    [InlineData(RightToLeft.Yes, 100, 0)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle(RightToLeft rightToLeft, int maximum, int value)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.True(VFirstPageButton(vScrollBar).Bounds.Width == 0 || VFirstPageButton(vScrollBar).Bounds.Height == 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0)]
-    [InlineData(RightToLeft.No, 50)]
-    [InlineData(RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.Yes, 50)]
-    public void VScrollBarLastPageButtonAccessibleObject_Bounds_ReturnRectangle(RightToLeft rightToLeft, int value)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum: 100, value);
-
-        Assert.True(VLastPageButton(vScrollBar).Bounds.Width > 0);
-        Assert.True(VLastPageButton(vScrollBar).Bounds.Height > 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 100)]
-    [InlineData(RightToLeft.Yes, 100, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarLastPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle(RightToLeft rightToLeft, int maximum, int value)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.True(VLastPageButton(vScrollBar).Bounds.Width == 0 || VLastPageButton(vScrollBar).Bounds.Height == 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 0, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 100, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 100, 0, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 100, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.No, 0, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 0, 0, AccessibleStates.Invisible)]
-    public void VScrollBarLastPageButtonAccessibleObject_State_ReturnsExpected(RightToLeft rightToLeft, int maximum, int value, AccessibleStates accessibleState)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.Equal(accessibleState, VLastPageButton(vScrollBar).State);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 50)]
-    [InlineData(RightToLeft.Yes, 50)]
-    [InlineData(RightToLeft.No, 100)]
-    [InlineData(RightToLeft.Yes, 100)]
-    public void VScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnRectangle(RightToLeft rightToLeft, int value)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum: 100, value);
-
-        Assert.True(VFirstPageButton(vScrollBar).Bounds.Width > 0);
-        Assert.True(VFirstPageButton(vScrollBar).Bounds.Height > 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 100, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.No, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 100, 100, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 100, 50, AccessibleStates.None)]
-    [InlineData(RightToLeft.Yes, 100, 100, AccessibleStates.None)]
-    [InlineData(RightToLeft.No, 0, 0, AccessibleStates.Invisible)]
-    [InlineData(RightToLeft.Yes, 0, 0, AccessibleStates.Invisible)]
-    public void VScrollBarFirstPageButtonAccessibleObject_State_ReturnsExpected(RightToLeft rightToLeft, int maximum, int value, AccessibleStates accessibleState)
-    {
-        using VScrollBar vScrollBar = new();
-        SetVScrollBar(vScrollBar, rightToLeft, minimum: 0, maximum, value);
-
-        Assert.Equal(accessibleState, VFirstPageButton(vScrollBar).State);
-    }
-
-    private void SetVScrollBar(VScrollBar vScrollBar, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        Form form = new();
-        form.Show();
-        vScrollBar.RightToLeft = rightToLeft;
-        vScrollBar.Minimum = minimum;
-        vScrollBar.Maximum = maximum;
-        vScrollBar.Value = value;
-        vScrollBar.Size = new(50, 200);
-        vScrollBar.Parent = form;
-        Application.DoEvents();
-    }
-
-    private ScrollBar.ScrollBarFirstPageButtonAccessibleObject VFirstPageButton(VScrollBar vScrollBar)
-        => ((VScrollBar.ScrollBarAccessibleObject)vScrollBar.AccessibilityObject).FirstPageButtonAccessibleObject;
-
-    private ScrollBar.ScrollBarLastPageButtonAccessibleObject VLastPageButton(VScrollBar vScrollBar)
-        => ((VScrollBar.ScrollBarAccessibleObject)vScrollBar.AccessibilityObject).LastPageButtonAccessibleObject;
-
-    private void SetHScrollBar(HScrollBar hScrollBar, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        Form form = new();
-        form.Show();
-        hScrollBar.RightToLeft = rightToLeft;
-        hScrollBar.Minimum = minimum;
-        hScrollBar.Maximum = maximum;
-        hScrollBar.Value = value;
-        hScrollBar.Size = new(200, 50);
-        hScrollBar.Parent = form;
-        Application.DoEvents();
-    }
-
-    private ScrollBar.ScrollBarFirstPageButtonAccessibleObject HFirstPageButton(HScrollBar hScrollBar)
-        => ((VScrollBar.ScrollBarAccessibleObject)hScrollBar.AccessibilityObject).FirstPageButtonAccessibleObject;
-
-    private ScrollBar.ScrollBarLastPageButtonAccessibleObject HLastPageButton(HScrollBar hScrollBar)
-        => ((VScrollBar.ScrollBarAccessibleObject)hScrollBar.AccessibilityObject).LastPageButtonAccessibleObject;
-
-    private class VerticalScrollBar : ScrollBar
-    {
-        protected override CreateParams CreateParams
-        {
-            get
-            {
-                CreateParams cp = base.CreateParams;
-                cp.Style |= (int)SCROLLBAR_CONSTANTS.SB_VERT;
-                return cp;
-            }
-        }
-
-        public new Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) => base.GetScaledBounds(bounds, factor, specified);
-    }
-
-    private class SubScrollBar : ScrollBar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-        
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new Rectangle GetScaledBounds(Rectangle bounds, SizeF factor, BoundsSpecified specified) => base.GetScaledBounds(bounds, factor, specified);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnMouseWheel(MouseEventArgs e) => base.OnMouseWheel(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnScroll(ScrollEventArgs se) => base.OnScroll(se);
-
-        public new void OnValueChanged(EventArgs e) => base.OnValueChanged(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void UpdateScrollInfo() => base.UpdateScrollInfo();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollEventArgsTests.cs
deleted file mode 100644
index 1181ab573f3..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollEventArgsTests.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ScrollEventArgsTests
-{
-    [Theory]
-    [InlineData((ScrollEventType)(ScrollEventType.EndScroll + 1), -2)]
-    [InlineData(ScrollEventType.LargeIncrement, -1)]
-    [InlineData(ScrollEventType.EndScroll, 0)]
-    [InlineData(ScrollEventType.LargeIncrement, 1)]
-    public void Ctor_ScrollEventType_Int(ScrollEventType type, int newValue)
-    {
-        var e = new ScrollEventArgs(type, newValue);
-        Assert.Equal(type, e.Type);
-        Assert.Equal(newValue, e.NewValue);
-        Assert.Equal(-1, e.OldValue);
-        Assert.Equal(ScrollOrientation.HorizontalScroll, e.ScrollOrientation);
-    }
-
-    [Theory]
-    [InlineData((ScrollEventType)(ScrollEventType.EndScroll + 1), -2, -2)]
-    [InlineData(ScrollEventType.LargeIncrement, -1, -1)]
-    [InlineData(ScrollEventType.EndScroll, 0, 0)]
-    [InlineData(ScrollEventType.LargeIncrement, 1, 2)]
-    public void Ctor_ScrollEventType_Int_Int(ScrollEventType type, int oldValue, int newValue)
-    {
-        var e = new ScrollEventArgs(type, oldValue, newValue);
-        Assert.Equal(type, e.Type);
-        Assert.Equal(oldValue, e.OldValue);
-        Assert.Equal(newValue, e.NewValue);
-        Assert.Equal(ScrollOrientation.HorizontalScroll, e.ScrollOrientation);
-    }
-
-    [Theory]
-    [InlineData((ScrollEventType)(ScrollEventType.EndScroll + 1), -2, (ScrollOrientation)(ScrollOrientation.HorizontalScroll - 1))]
-    [InlineData(ScrollEventType.LargeIncrement, -1, ScrollOrientation.HorizontalScroll)]
-    [InlineData(ScrollEventType.EndScroll, 0, ScrollOrientation.VerticalScroll)]
-    [InlineData(ScrollEventType.LargeIncrement, 1, ScrollOrientation.VerticalScroll)]
-    public void Ctor_ScrollEventType_Int_ScrollOrientation(ScrollEventType type, int newValue, ScrollOrientation scroll)
-    {
-        var e = new ScrollEventArgs(type, newValue, scroll);
-        Assert.Equal(type, e.Type);
-        Assert.Equal(-1, e.OldValue);
-        Assert.Equal(newValue, e.NewValue);
-        Assert.Equal(scroll, e.ScrollOrientation);
-    }
-
-    [Theory]
-    [InlineData((ScrollEventType)(ScrollEventType.EndScroll + 1), -2, -2, (ScrollOrientation)(ScrollOrientation.HorizontalScroll - 1))]
-    [InlineData(ScrollEventType.LargeIncrement, -1, -1, ScrollOrientation.HorizontalScroll)]
-    [InlineData(ScrollEventType.EndScroll, 0, 0, ScrollOrientation.VerticalScroll)]
-    [InlineData(ScrollEventType.LargeIncrement, 1, 2, ScrollOrientation.VerticalScroll)]
-    public void Ctor_ScrollEventType_Int_Int_ScrollOrientation(ScrollEventType type, int oldValue, int newValue, ScrollOrientation scroll)
-    {
-        var e = new ScrollEventArgs(type, oldValue, newValue, scroll);
-        Assert.Equal(type, e.Type);
-        Assert.Equal(oldValue, e.OldValue);
-        Assert.Equal(newValue, e.NewValue);
-        Assert.Equal(scroll, e.ScrollOrientation);
-    }
-
-    [Theory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void NewValue_Set_GetReturnsExpected(int value)
-    {
-        var e = new ScrollEventArgs(ScrollEventType.LargeIncrement, 2)
-        {
-            NewValue = value
-        };
-        Assert.Equal(value, e.NewValue);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollPropertiesTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollPropertiesTests.cs
deleted file mode 100644
index 29faaa693be..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollPropertiesTests.cs
+++ /dev/null
@@ -1,587 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ScrollPropertiesTests
-{
-    public static IEnumerable<object[]> Ctor_ScrollableControl_TestData()
-    {
-        yield return new object[] { new ScrollableControl() };
-        yield return new object[] { null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ScrollableControl_TestData))]
-    public void ScrollProperties_Ctor_Control(ScrollableControl container)
-    {
-        var properties = new SubScrollProperties(container);
-        Assert.Same(container, properties.ParentControl);
-        Assert.True(properties.Enabled);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.False(properties.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, properties.Enabled);
-
-        // Set same.
-        properties.Enabled = value;
-        Assert.Equal(value, properties.Enabled);
-
-        // Set different.
-        properties.Enabled = !value;
-        Assert.Equal(!value, properties.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Enabled_SetAutoScrollContainer_Nop(bool value)
-    {
-        using var container = new ScrollableControl()
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            Enabled = value
-        };
-        Assert.True(properties.Enabled);
-
-        // Set same.
-        properties.Enabled = value;
-        Assert.True(properties.Enabled);
-
-        // Set different.
-        properties.Enabled = !value;
-        Assert.True(properties.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Enabled_SetNullContainer_GetReturnsExpected(bool value)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, properties.Enabled);
-
-        // Set same.
-        properties.Enabled = value;
-        Assert.Equal(value, properties.Enabled);
-
-        // Set different.
-        properties.Enabled = !value;
-        Assert.Equal(!value, properties.Enabled);
-    }
-
-    public static IEnumerable<object[]> LargeChange_Set_TestData()
-    {
-        yield return new object[] { 10 };
-        yield return new object[] { 12 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeChange_Set_TestData))]
-    public void ScrollProperties_LargeChange_Set_GetReturnsExpected(int value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            LargeChange = value
-        };
-        Assert.Equal(value, properties.LargeChange);
-
-        // Set same.
-        properties.LargeChange = value;
-        Assert.Equal(value, properties.LargeChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeChange_Set_TestData))]
-    public void ScrollProperties_LargeChange_SetAutoScrollContainer_GetReturnsExpected(int value)
-    {
-        using var container = new ScrollableControl
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            LargeChange = value
-        };
-        Assert.Equal(value, properties.LargeChange);
-
-        // Set same.
-        properties.LargeChange = value;
-        Assert.Equal(value, properties.LargeChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LargeChange_Set_TestData))]
-    public void ScrollProperties_LargeChange_SetNullContainer_GetReturnsExpected(int value)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            LargeChange = value
-        };
-        Assert.Equal(value, properties.LargeChange);
-
-        // Set same.
-        properties.LargeChange = value;
-        Assert.Equal(value, properties.LargeChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_LargeChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => properties.LargeChange = -1);
-        Assert.Equal(10, properties.LargeChange);
-    }
-
-    public static IEnumerable<object[]> SmallChange_Set_TestData()
-    {
-        yield return new object[] { 1, 1 };
-        yield return new object[] { 8, 8 };
-        yield return new object[] { 10, 10 };
-        yield return new object[] { 12, 10 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallChange_Set_TestData))]
-    public void ScrollProperties_SmallChange_Set_GetReturnsExpected(int value, int expectedValue)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            SmallChange = value
-        };
-        Assert.Equal(expectedValue, properties.SmallChange);
-
-        // Set same.
-        properties.SmallChange = value;
-        Assert.Equal(expectedValue, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallChange_Set_TestData))]
-    public void ScrollProperties_SmallChange_SetAutoScrollContainer_GetReturnsExpected(int value, int expectedValue)
-    {
-        using var container = new ScrollableControl
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            SmallChange = value
-        };
-        Assert.Equal(expectedValue, properties.SmallChange);
-
-        // Set same.
-        properties.SmallChange = value;
-        Assert.Equal(expectedValue, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SmallChange_Set_TestData))]
-    public void ScrollProperties_SmallChange_SetNullContainer_ReturnsExpected(int value, int expectedValue)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            SmallChange = value
-        };
-        Assert.Equal(expectedValue, properties.SmallChange);
-
-        // Set same.
-        properties.SmallChange = value;
-        Assert.Equal(expectedValue, properties.SmallChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_SmallChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => properties.SmallChange = -1);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    public static IEnumerable<object[]> Maximum_Set_TestData()
-    {
-        yield return new object[] { 0, 1 };
-        yield return new object[] { 8, 9 };
-        yield return new object[] { 10, 10 };
-        yield return new object[] { 50, 10 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Maximum_Set_TestData))]
-    public void ScrollProperties_Maximum_Set_GetReturnsExpected(int value, int expectedLargeChange)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Maximum = value
-        };
-        Assert.Equal(value, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(expectedLargeChange, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set value.
-        properties.Maximum = value;
-        Assert.Equal(value, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(expectedLargeChange, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Maximum_Set_TestData))]
-    public void ScrollProperties_Maximum_SetNullContainer_GetReturnsExpected(int value, int expectedLargeChange)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            Maximum = value
-        };
-        Assert.Equal(value, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(expectedLargeChange, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set value.
-        properties.Maximum = value;
-        Assert.Equal(value, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(expectedLargeChange, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_Maximum_SetLessThanValueAndMinimum_SetsValueAndMinimum()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Value = 10,
-            Minimum = 8,
-            Maximum = 5
-        };
-        Assert.Equal(5, properties.Maximum);
-        Assert.Equal(5, properties.Minimum);
-        Assert.Equal(5, properties.Value);
-        Assert.Equal(1, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_Maximum_SetNegative_SetsValueAndMinimum()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Maximum = -1
-        };
-        Assert.Equal(-1, properties.Maximum);
-        Assert.Equal(-1, properties.Minimum);
-        Assert.Equal(-1, properties.Value);
-        Assert.Equal(1, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(8)]
-    public void ScrollProperties_Maximum_SetAutoScrollContainer_Nop(int value)
-    {
-        using var container = new ScrollableControl()
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            Maximum = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    public static IEnumerable<object[]> Minimum_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 5 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Minimum_Set_TestData))]
-    public void ScrollProperties_Minimum_Set_GetReturnsExpected(int value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(value, properties.Minimum);
-        Assert.Equal(5, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set same.
-        properties.Minimum = value;
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(value, properties.Minimum);
-        Assert.Equal(5, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_Minimum_SetGreaterThanValueAndMaximum_SetsValueAndMinimum()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Value = 10,
-            Maximum = 8,
-            Minimum = 12
-        };
-        Assert.Equal(12, properties.Maximum);
-        Assert.Equal(12, properties.Minimum);
-        Assert.Equal(12, properties.Value);
-        Assert.Equal(1, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(8)]
-    public void ScrollProperties_Minimum_SetAutoScrollContainer_Nop(int value)
-    {
-        using var container = new ScrollableControl
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            Minimum = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Minimum_Set_TestData))]
-    public void ScrollProperties_Minimum_SetNullContainer_GetReturnsExpected(int value)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(value, properties.Minimum);
-        Assert.Equal(5, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set same.
-        properties.Minimum = value;
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(value, properties.Minimum);
-        Assert.Equal(5, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsFact]
-    public void ScrollProperties_Minimum_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => properties.Minimum = -1);
-        Assert.Equal(0, properties.Minimum);
-    }
-
-    public static IEnumerable<object[]> Value_Set_TestData()
-    {
-        yield return new object[] { 0 };
-        yield return new object[] { 5 };
-        yield return new object[] { 100 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void ScrollProperties_Value_Set_GetReturnsExpected(int value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Value = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(value, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set same.
-        properties.Value = value;
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(value, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(5)]
-    [InlineData(100)]
-    public void ScrollProperties_Value_SetAutoScrollContainer_GetReturnsExpected(int value)
-    {
-        using var container = new ScrollableControl
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            Value = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(value, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void ScrollProperties_Value_SetNullContainer_GetReturnsExpected(int value)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            Value = value
-        };
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(value, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-
-        // Set same.
-        properties.Value = value;
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(value, properties.Value);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(101)]
-    public void ScrollProperties_Value_SetOutOfRange_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => properties.Value = value);
-        Assert.Equal(0, properties.Value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var container = new ScrollableControl();
-        var properties = new SubScrollProperties(container)
-        {
-            Visible = value
-        };
-        Assert.Equal(value, properties.Visible);
-
-        // Set same.
-        properties.Visible = value;
-        Assert.Equal(value, properties.Visible);
-
-        // Set different.
-        properties.Visible = !value;
-        Assert.Equal(!value, properties.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Visible_SetAutoScrollContainer_Nop(bool value)
-    {
-        using var container = new ScrollableControl()
-        {
-            AutoScroll = true
-        };
-        var properties = new SubScrollProperties(container)
-        {
-            Visible = value
-        };
-        Assert.False(properties.Visible);
-
-        // Set same.
-        properties.Visible = value;
-        Assert.False(properties.Visible);
-
-        // Set different.
-        properties.Visible = !value;
-        Assert.False(properties.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollProperties_Visible_SetNullContainer_GetReturnsExpected(bool value)
-    {
-        var properties = new SubScrollProperties(null)
-        {
-            Visible = value
-        };
-        Assert.Equal(value, properties.Visible);
-
-        // Set same.
-        properties.Visible = value;
-        Assert.Equal(value, properties.Visible);
-
-        // Set different.
-        properties.Visible = !value;
-        Assert.Equal(!value, properties.Visible);
-    }
-
-    private class SubScrollProperties : HScrollProperties
-    {
-        public SubScrollProperties(ScrollableControl container) : base(container)
-        {
-        }
-
-        public new ScrollableControl ParentControl => base.ParentControl;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollableControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollableControlTests.cs
deleted file mode 100644
index 3d1a1403481..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ScrollableControlTests.cs
+++ /dev/null
@@ -1,2664 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ScrollableControlTests
-{
-    [WinFormsFact]
-    public void ScrollableControl_Ctor_Default()
-    {
-        using var control = new SubScrollableControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubScrollableControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x56110000)]
-    [InlineData(true, false, 0x56110000)]
-    [InlineData(false, true, 0x56110000)]
-    [InlineData(false, false, 0x56010000)]
-    public void ScrollableControl_CreateParams_GetHScroll_ReturnsExpected(bool hScroll, bool horizontalScrollVisible, int expectedStyle)
-    {
-        using var control = new SubScrollableControl();
-        control.HorizontalScroll.Visible = horizontalScrollVisible;
-        control.HScroll = hScroll;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x56210000)]
-    [InlineData(true, false, 0x56210000)]
-    [InlineData(false, true, 0x56210000)]
-    [InlineData(false, false, 0x56010000)]
-    public void ScrollableControl_CreateParams_GetVScroll_ReturnsExpected(bool vScroll, bool verticalScrollVisible, int expectedStyle)
-    {
-        using var control = new SubScrollableControl();
-        control.VerticalScroll.Visible = verticalScrollVisible;
-        control.VScroll = vScroll;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetClientRectangle_TestData()
-    {
-        const int width = 70;
-        const int height = 80;
-
-        // create handle
-        yield return new object[] { true, width, height, width - 20, height + 50, new Rectangle(0, 0, width - SystemInformation.VerticalScrollBarWidth, height) };
-        yield return new object[] { true, width, height, width + 50, height - 20, new Rectangle(0, 0, width, height - SystemInformation.HorizontalScrollBarHeight) };
-        yield return new object[] { true, width, height, width + 50, height + 50, new Rectangle(0, 0, width - SystemInformation.VerticalScrollBarWidth, height - SystemInformation.HorizontalScrollBarHeight) };
-        yield return new object[] { true, width, height, width - 20, height - 20, new Rectangle(0, 0, width, height) };
-
-        // no handle
-        yield return new object[] { false, width, height, width + 50, height - 20, new Rectangle(0, 0, width, height) };
-        yield return new object[] { false, width, height, width - 20, height + 50, new Rectangle(0, 0, width, height) };
-        yield return new object[] { false, width, height, width + 50, height + 50, new Rectangle(0, 0, width, height) };
-        yield return new object[] { false, width, height, width - 20, height - 20, new Rectangle(0, 0, width, height) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetClientRectangle_TestData))]
-    public void ScrollableControl_ClientRectangle_should_reduce_if_scrollbars_shown(bool createHandle, int width, int height, int childWidth, int childHeight, Rectangle expected)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = true,
-            ClientSize = new Size(width, height)
-        };
-
-        // if handle isn't created, scrollbars won't be rendered, which in turn affects the size of ClientRectangle
-        if (createHandle)
-        {
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-        }
-
-        // add a child control
-        var child = new Button
-        {
-            Width = childWidth,
-            Height = childHeight
-        };
-        control.Controls.Add(child);
-
-        Assert.Equal(expected, control.ClientRectangle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void ScrollableControl_AutoScroll_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubScrollableControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void ScrollableControl_AutoScroll_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMargin_Set_TestData()
-    {
-        yield return new object[] { true, new Size(0, 0), 0 };
-        yield return new object[] { true, new Size(1, 0), 1 };
-        yield return new object[] { true, new Size(0, 1), 1 };
-        yield return new object[] { true, new Size(1, 2), 1 };
-        yield return new object[] { false, new Size(0, 0), 0 };
-        yield return new object[] { false, new Size(1, 0), 0 };
-        yield return new object[] { false, new Size(0, 1), 0 };
-        yield return new object[] { false, new Size(1, 2), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void ScrollableControl_AutoScrollMargin_Set_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void ScrollableControl_AutoScrollMargin_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_AutoScrollMargin_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ScrollableControl))[nameof(ScrollableControl.AutoScrollMargin)];
-        using var control = new ScrollableControl();
-        Assert.False(property.CanResetValue(control));
-
-        control.AutoScrollMargin = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.AutoScrollMargin);
-        Assert.True(property.CanResetValue(control));
-
-        control.AutoScrollMargin = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.AutoScrollMargin);
-        Assert.True(property.CanResetValue(control));
-
-        control.AutoScrollMargin = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.AutoScrollMargin);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_AutoScrollMargin_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ScrollableControl))[nameof(ScrollableControl.AutoScrollMargin)];
-        using var control = new ScrollableControl();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMargin = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.AutoScrollMargin);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMargin = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.AutoScrollMargin);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMargin = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.AutoScrollMargin);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, -1)]
-    [InlineData(-1, -2)]
-    public void ScrollableControl_AutoScrollMargin_SetInvalid_ThrowsArgumentOutOfRangeException(int x, int y)
-    {
-        using var control = new ScrollableControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.AutoScrollMargin = new Size(x, y));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void ScrollableControl_AutoScrollPosition_Set_GetReturnsExpected(Point value)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScrollPosition = value
-        };
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void ScrollableControl_AutoScrollPosition_SetWithHandle_GetReturnsExpected(Point value)
-    {
-        using var control = new ScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void ScrollableControl_AutoScrollPosition_SetWithAutoScroll_GetReturnsExpected(Point value)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = true,
-            AutoScrollPosition = value
-        };
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void ScrollableControl_AutoScrollPosition_SetWithVisibleBars_GetReturnsExpected(Point value)
-    {
-        using var control = new ScrollableControl();
-        control.HorizontalScroll.Visible = true;
-        control.VerticalScroll.Visible = true;
-
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMinSize_TestData()
-    {
-        yield return new object[] { true, new Size(-1, -2), true, 3 };
-        yield return new object[] { true, new Size(0, 0), true, 0 };
-        yield return new object[] { true, new Size(1, 0), true, 4 };
-        yield return new object[] { true, new Size(0, 1), true, 4 };
-        yield return new object[] { true, new Size(1, 2), true, 4 };
-
-        yield return new object[] { false, new Size(-1, -2), true, 3 };
-        yield return new object[] { false, new Size(0, 0), false, 0 };
-        yield return new object[] { false, new Size(1, 0), true, 4 };
-        yield return new object[] { false, new Size(0, 1), true, 4 };
-        yield return new object[] { false, new Size(1, 2), true, 4 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_TestData))]
-    public void ScrollableControl_AutoScrollMinSize_Set_GetReturnsExpected(bool autoScroll, Size value, bool expectedAutoScroll, int expectedLayoutCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMinSize_WithHandle_TestData()
-    {
-        yield return new object[] { true, new Size(-1, -2), true, 3, 0 };
-        yield return new object[] { true, new Size(0, 0), true, 0, 0 };
-        yield return new object[] { true, new Size(1, 0), true, 4, 2 };
-        yield return new object[] { true, new Size(0, 1), true, 4, 2 };
-        yield return new object[] { true, new Size(1, 2), true, 4, 2 };
-
-        yield return new object[] { false, new Size(-1, -2), true, 3, 0 };
-        yield return new object[] { false, new Size(0, 0), false, 0, 0 };
-        yield return new object[] { false, new Size(1, 0), true, 4, 2 };
-        yield return new object[] { false, new Size(0, 1), true, 4, 2 };
-        yield return new object[] { false, new Size(1, 2), true, 4, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_WithHandle_TestData))]
-    public void ScrollableControl_AutoScrollMinSize_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value, bool expectedAutoScroll, int expectedLayoutCallCount, int expectedStyleChangedCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_AutoScrollMinSize_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ScrollableControl))[nameof(ScrollableControl.AutoScrollMinSize)];
-        using var control = new ScrollableControl();
-        Assert.False(property.CanResetValue(control));
-
-        control.AutoScrollMinSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.AutoScrollMinSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.AutoScrollMinSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.AutoScrollMinSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.AutoScrollMinSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.AutoScrollMinSize);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_AutoScrollMinSize_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ScrollableControl))[nameof(ScrollableControl.AutoScrollMinSize)];
-        using var control = new ScrollableControl();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMinSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.AutoScrollMinSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMinSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.AutoScrollMinSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.AutoScrollMinSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.AutoScrollMinSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false, false)]
-    [InlineData(false, false, false)]
-    [InlineData(true, true, true)]
-    [InlineData(false, true, true)]
-    public void ScrollableControl_DisplayRectangle_GetWithClientRectangle_ReturnsExpected(bool autoScroll, bool hScroll, bool vScroll)
-    {
-        using var control = new SubScrollableControl
-        {
-            ClientSize = new Size(70, 80),
-            Padding = new Padding(1, 2, 3, 4),
-            AutoScroll = autoScroll,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        Assert.Equal(new Rectangle(1, 2, 66, 74), control.DisplayRectangle);
-
-        // Get again.
-        Assert.Equal(new Rectangle(1, 2, 66, 74), control.DisplayRectangle);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollableControl_HScroll_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollableControl
-        {
-            HScroll = value
-        };
-        Assert.Equal(value, control.HScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HScroll = value;
-        Assert.Equal(value, control.HScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HScroll = !value;
-        Assert.Equal(!value, control.HScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollableControl_HScroll_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HScroll = value;
-        Assert.Equal(value, control.HScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.HScroll = value;
-        Assert.Equal(value, control.HScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.HScroll = !value;
-        Assert.Equal(!value, control.HScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateHScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Padding_Set_TestData), MemberType = typeof(ControlTests))]
-    public void ScrollableControl_Padding_Set_GetReturnsExpected(Padding value, Padding expected, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new ScrollableControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new ScrollableControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ScrollableControl_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var control = new ScrollableControl
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, control.RightToLeft);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollableControl_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ScrollableControl
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollableControl_VScroll_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollableControl
-        {
-            VScroll = value
-        };
-        Assert.Equal(value, control.VScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.VScroll = value;
-        Assert.Equal(value, control.VScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.VScroll = !value;
-        Assert.Equal(!value, control.VScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ScrollableControl_VScroll_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.VScroll = value;
-        Assert.Equal(value, control.VScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.VScroll = value;
-        Assert.Equal(value, control.VScroll);
-        Assert.Equal(value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.VScroll = !value;
-        Assert.Equal(!value, control.VScroll);
-        Assert.Equal(!value, control.GetScrollState(SubScrollableControl.ScrollStateVScrollVisible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScrollStateAutoScrolling_Get_ReturnsExpected()
-    {
-        Assert.Equal(0x0001, SubScrollableControl.ScrollStateAutoScrolling);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScrollStateHScrollVisible_Get_ReturnsExpected()
-    {
-        Assert.Equal(0x0002, SubScrollableControl.ScrollStateHScrollVisible);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScrollStateVScrollVisible_Get_ReturnsExpected()
-    {
-        Assert.Equal(0x0004, SubScrollableControl.ScrollStateVScrollVisible);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScrollStateUserHasScrolled_Get_ReturnsExpected()
-    {
-        Assert.Equal(0x0008, SubScrollableControl.ScrollStateUserHasScrolled);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScrollStateFullDrag_Get_ReturnsExpected()
-    {
-        Assert.Equal(0x0010, SubScrollableControl.ScrollStateFullDrag);
-    }
-
-    public static IEnumerable<object[]> AdjustFormScrollbars_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true, 0, true, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, false, false, 0, false, 1 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, true, false, 0, false, 1 };
-
-            yield return new object[] { rightToLeft, true, 0, false, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, false, false, 0, false, 1 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, true, false, 0, false, 1 };
-
-            yield return new object[] { rightToLeft, false, 0, true, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, false, false, 0, false, 1 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, true, false, 0, false, 1 };
-
-            yield return new object[] { rightToLeft, false, 0, false, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 0, true, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, false, false, 0, false, 1 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, true, false, 0, false, 1 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, false, false, 1, false, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, true, false, 1, false, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, false, false, 1, false, 1 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, true, false, 1, false, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_Invoke_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue)
-    {
-        using var control = new SubScrollableControl
-        {
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.False(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.False(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_InvokeAutoScroll_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = true,
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.False(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.False(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AdjustFormScrollbars_AutoScrollMinSize_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true, 0, true, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 0, true, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, true, true, 0, true, 1 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, true, true, 1, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, true, true, 1, true, 1 };
-
-            yield return new object[] { rightToLeft, true, 0, false, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 0, true, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, true, true, 0, true, 1 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, true, true, 1, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, true, true, 1, true, 1 };
-
-            yield return new object[] { rightToLeft, false, 0, true, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 0, true, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, true, true, 0, true, 1 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, true, true, 1, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, true, true, 1, true, 1 };
-
-            yield return new object[] { rightToLeft, false, 0, false, 0, false, false, 0, false, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 0, true, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, true, true, 0, true, 1 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, true, true, 1, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, false, true, 0, true, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, true, true, 1, true, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_AutoScrollMinSize_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_InvokeAutoScrollMinSize_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScrollMinSize = new Size(10, 20),
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.True(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.True(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AdjustFormScrollbars_WithHandle_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true, 0, true, 0, false, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, true, 0, true, 0, true, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, false, false, 0, false, 1, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, true, false, 0, false, 1, 0 };
-
-            yield return new object[] { rightToLeft, true, 0, false, 0, false, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, true, 0, false, 0, true, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, false, false, 0, false, 1, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, true, false, 0, false, 1, 0 };
-
-            yield return new object[] { rightToLeft, false, 0, true, 0, false, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, false, 0, true, 0, true, false, 0, false, 0, 1 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, false, false, 0, false, 1, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, true, false, 0, false, 1, 0 };
-
-            yield return new object[] { rightToLeft, false, 0, false, 0, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 0, true, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, false, false, 0, false, 1, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, true, false, 0, false, 1, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, false, false, 1, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, true, false, 1, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, false, false, 1, false, 1, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, true, false, 1, false, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_WithHandle_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_InvokeWithHandle_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubScrollableControl
-        {
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.False(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.False(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_WithHandle_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_InvokeWithHandleAutoScroll_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = true,
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.False(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.False(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AdjustFormScrollbars_WithHandleAutoScrollMinSize_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true, 0, true, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 0, true, 0, true, true, 0, true, 0, 0 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 0, true, 1, true, true, 0, true, 1, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 1, true, 0, true, true, 1, true, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 1, true, 1, true, true, 1, true, 1, 0 };
-
-            yield return new object[] { rightToLeft, true, 0, false, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 0, false, 0, true, true, 0, true, 0, 1 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 0, false, 1, true, true, 0, true, 1, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 1, false, 0, true, true, 1, true, 0, 0 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, true, 1, false, 1, true, true, 1, true, 1, 0 };
-
-            yield return new object[] { rightToLeft, false, 0, true, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 0, true, 0, true, true, 0, true, 0, 1 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 0, true, 1, true, true, 0, true, 1, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 1, true, 0, true, true, 1, true, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 1, true, 1, true, true, 1, true, 1, 0 };
-
-            yield return new object[] { rightToLeft, false, 0, false, 0, false, false, 0, false, 0, 0 };
-            yield return new object[] { rightToLeft, false, 0, false, 0, true, true, 0, true, 0, 1 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 0, false, 1, true, true, 0, true, 1, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 1, false, 0, true, true, 1, true, 0, 0 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, false, true, 0, true, 0, 2 };
-            yield return new object[] { rightToLeft, false, 1, false, 1, true, true, 1, true, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AdjustFormScrollbars_WithHandleAutoScrollMinSize_TestData))]
-    public void ScrollableControl_AdjustFormScrollbars_InvokeWithHandleAutoScrollMinSize_Success(RightToLeft rightToLeft, bool hScroll, int hValue, bool vScroll, int vValue, bool displayScrollbars, bool expectedHScroll, int expectedHValue, bool expectedVScroll, int expectedVValue, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScrollMinSize = new Size(10, 20),
-            RightToLeft = rightToLeft,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.HorizontalScroll.Value = hValue;
-        control.VerticalScroll.Value = vValue;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AdjustFormScrollbars(displayScrollbars);
-        Assert.Equal(expectedHScroll, control.HScroll);
-        Assert.Equal(expectedHValue, control.HorizontalScroll.Value);
-        Assert.True(control.HorizontalScroll.Visible);
-        Assert.Equal(expectedVScroll, control.VScroll);
-        Assert.Equal(expectedVValue, control.VerticalScroll.Value);
-        Assert.True(control.VerticalScroll.Visible);
-        Assert.False(control.GetScrollState(SubScrollableControl.ScrollStateUserHasScrolled));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubScrollableControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubScrollableControl.ScrollStateAutoScrolling, false)]
-    [InlineData(SubScrollableControl.ScrollStateFullDrag, false)]
-    [InlineData(SubScrollableControl.ScrollStateHScrollVisible, false)]
-    [InlineData(SubScrollableControl.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubScrollableControl.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ScrollableControl_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubScrollableControl();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ScrollableControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubScrollableControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubScrollableControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        // The control must be passed along as separate variable in order to be disposed properly.
-        Control affectedControl = null;
-
-        yield return new object[] { true, null, 1, null };
-        yield return new object[] { true, new LayoutEventArgs(null, null), 1, null };
-        yield return new object[] { true, new LayoutEventArgs(affectedControl = new Control(), "affectedProperty"), 2, affectedControl };
-
-        yield return new object[] { false, null, 1, null };
-        yield return new object[] { false, new LayoutEventArgs(null, null), 1, null };
-        yield return new object[] { false, new LayoutEventArgs(affectedControl = new Control(), "affectedProperty"), 1, affectedControl };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void ScrollableControl_OnLayout_Invoke_CallsLayout(bool autoScroll, LayoutEventArgs eventArgs, int expectedCallCount, Control affectedControl)
-    {
-        Assert.Same(eventArgs?.AffectedComponent, affectedControl);
-
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollableControl_OnPaddingChanged_Invoke_CallsPaddingChanged(EventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.PaddingChanged += handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnPaddingChanged_WithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, null };
-            yield return new object[] { resizeRedraw, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaddingChanged_WithHandle_TestData))]
-    public void ScrollableControl_OnPaddingChanged_InvokeWithHandle_CallsPaddingChanged(bool resizeRedraw, EventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.PaddingChanged += handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (bool hScroll in new bool[] { true, false })
-        {
-            foreach (bool vScroll in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb), new Bitmap(10, 10, PixelFormat.Format32bppArgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        yield return new object[] { hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void ScrollableControl_OnPaintBackground_Invoke_Success(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubScrollableControl
-        {
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    // TODO: unify
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_off_WithParent_TestData()
-    {
-        Func<Control> controlFactory = () => new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        Func<TabPage> tabPageFactory = () => new TabPage
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        foreach (Func<Control> parentFactory in new Func<Control>[] { controlFactory, tabPageFactory })
-        {
-            foreach (bool hScroll in new bool[] { true, false })
-            {
-                foreach (bool vScroll in new bool[] { true, false })
-                {
-                    foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                    {
-                        foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                        {
-                            int expected = backgroundImage is not null && (backgroundImageLayout == ImageLayout.Zoom || backgroundImageLayout == ImageLayout.Stretch || backgroundImageLayout == ImageLayout.Center) && (hScroll || vScroll) ? 0 : 1;
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        }
-                    }
-
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_on_WithParent_TestData()
-    {
-        foreach (Func<Control> parentFactory in new Func<Control>[] { CreateControl, CreateTabPage })
-        {
-            int expected1 = parentFactory == CreateTabPage ? 0 : 1;
-            int expected2 = parentFactory == CreateTabPage ? 0 : 2;
-            int expected3 = parentFactory == CreateTabPage ? 0 : 3;
-
-            foreach (bool hScroll in new bool[] { true, false })
-            {
-                foreach (bool vScroll in new bool[] { true, false })
-                {
-                    foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                    {
-                        foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                        {
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-
-                            int expected = parentFactory == CreateTabPage
-                                ? 0
-                                : backgroundImage is not null && (backgroundImageLayout == ImageLayout.Zoom || backgroundImageLayout == ImageLayout.Stretch || backgroundImageLayout == ImageLayout.Center)
-                                    && (hScroll || vScroll)
-                                        ? 0
-                                        : 1;
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                        }
-                    }
-
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-                    yield return new object[] { parentFactory(), hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected1 };
-                }
-            }
-        }
-
-        static Control CreateControl() => new()
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        static TabPage CreateTabPage() => new()
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_VisualStyles_on_WithParent_TestData))]
-    public void ScrollableControl_OnPaintBackground_InvokeWithParent_CallsPaint(Control parent, bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubScrollableControl
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 0, 0), e.ClipRectangle);
-            parentCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void ScrollableControl_OnPaintBackground_InvokeWithHandle_Success(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubScrollableControl
-        {
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_WithParentWithHandle_TestData()
-    {
-        foreach (bool hScroll in new bool[] { true, false })
-        {
-            foreach (bool vScroll in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        int expected = backgroundImage is not null && (backgroundImageLayout == ImageLayout.Zoom || backgroundImageLayout == ImageLayout.Stretch || backgroundImageLayout == ImageLayout.Center) && (!hScroll && vScroll) ? 0 : 1;
-                        yield return new object[] { hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                        yield return new object[] { hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    }
-                }
-
-                yield return new object[] { hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                yield return new object[] { hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_WithParentWithHandle_TestData))]
-    public void ScrollableControl_OnPaintBackground_InvokeWithParentWithHandle_CallsPaint(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var parent = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        using var control = new SubScrollableControl
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 10, 20), e.ClipRectangle);
-            parentCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_OnPaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var control = new SubScrollableControl();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollableControl_OnRightToLeftChanged_Invoke_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ScrollableControl_OnRightToLeftChanged_InvokeWithHandle_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "RightToLeft")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                Assert.Equal("RightToLeft", e.AffectedProperty);
-                layoutCallCount++;
-            }
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnScroll_TestData()
-    {
-        yield return new object[] { null };
-
-        foreach (ScrollEventType eventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            foreach (ScrollOrientation orientation in Enum.GetValues(typeof(ScrollOrientation)))
-            {
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 1, orientation) };
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 2, orientation) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_TestData))]
-    public void ScrollableControl_OnScroll_Invoke_CallsScroll(ScrollEventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_TestData))]
-    public void ScrollableControl_OnScroll_InvokeWithHandle_CallsScroll(ScrollEventArgs eventArgs)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-#pragma warning disable 0618
-    [WinFormsFact]
-    public void ScrollableControl_Scale_InvokeWithoutPaddingWithDockPadding_Success()
-    {
-        using var control = new SubScrollableControl();
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        control.Scale(10, 20);
-
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(Padding.Empty, control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_Scale_InvokeWithoutPaddingWithoutDockPadding_Success()
-    {
-        using var control = new SubScrollableControl();
-        control.Scale(10, 20);
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(Padding.Empty, control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_Scale_InvokeWithPaddingWithDockPadding_Success()
-    {
-        using var control = new SubScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        control.Scale(10, 20);
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_Scale_InvokeWithPaddingWithoutDockPadding_Success()
-    {
-        using var control = new SubScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        control.Scale(10, 20);
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleCore_InvokeWithoutPaddingWithDockPadding_Success()
-    {
-        using var control = new SubScrollableControl();
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        control.ScaleCore(10, 20);
-
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(Padding.Empty, control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleCore_InvokeWithoutPaddingWithoutDockPadding_Success()
-    {
-        using var control = new SubScrollableControl();
-        control.ScaleCore(10, 20);
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(Padding.Empty, control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleCore_InvokeWithPaddingWithDockPadding_Success()
-    {
-        using var control = new SubScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        control.ScaleCore(10, 20);
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleCore_InvokeWithPaddingWithoutDockPadding_Success()
-    {
-        using var control = new SubScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        control.ScaleCore(10, 20);
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        Assert.Equal(new Padding(1, 2, 3, 4), control.Padding);
-    }
-#pragma warning restore 0618
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleControl_InvokeWithDockPadding_Success()
-    {
-        using var control = new ScrollableControl
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(3, control.DockPadding.Right);
-        Assert.Equal(4, control.DockPadding.Bottom);
-        control.Scale(new SizeF(10, 20));
-
-        Assert.Equal(10, control.DockPadding.Left);
-        Assert.Equal(40, control.DockPadding.Top);
-        Assert.Equal(30, control.DockPadding.Right);
-        Assert.Equal(80, control.DockPadding.Bottom);
-        Assert.Equal(new Padding(10, 40, 30, 80), control.Padding);
-    }
-
-    [WinFormsFact]
-    public void ScrollableControl_ScaleControl_InvokeWithoutDockPadding_Success()
-    {
-        using var control = new ScrollableControl();
-        control.Scale(new SizeF(10, 20));
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(Padding.Empty, control.Padding);
-    }
-
-    public static IEnumerable<object[]> SetAutoScrollMargin_TestData()
-    {
-        yield return new object[] { true, -1, -1, new Size(0, 0), 0 };
-        yield return new object[] { true, 0, 0, new Size(0, 0), 0 };
-        yield return new object[] { true, 0, 1, new Size(0, 1), 1 };
-        yield return new object[] { true, 1, 0, new Size(1, 0), 1 };
-        yield return new object[] { true, 1, 2, new Size(1, 2), 1 };
-        yield return new object[] { false, -1, -1, new Size(0, 0), 0 };
-        yield return new object[] { false, 0, 0, new Size(0, 0), 0 };
-        yield return new object[] { false, 0, 1, new Size(0, 1), 0 };
-        yield return new object[] { false, 1, 0, new Size(1, 0), 0 };
-        yield return new object[] { false, 1, 2, new Size(1, 2), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetAutoScrollMargin_TestData))]
-    public void ScrollableControl_SetAutoScrollMargin_Invoke_Success(bool autoScroll, int width, int height, Size expectedAutoScrollMargin, int expectedLayoutCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SetAutoScrollMargin(width, height);
-        Assert.Equal(expectedAutoScrollMargin, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetAutoScrollMargin_TestData))]
-    public void ScrollableControl_SetAutoScrollMargin_InvokeWithHandle_Success(bool autoScroll, int width, int height, Size expectedAutoScrollMargin, int expectedLayoutCallCount)
-    {
-        using var control = new ScrollableControl
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.SetAutoScrollMargin(width, height);
-        Assert.Equal(expectedAutoScrollMargin, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetDisplayRectLocation_TestData()
-    {
-        const int width = 70;
-        const int height = 80;
-        Size scrollableSize = new Size(100, 150);
-        Size nonScrollableSize = new Size(width, height);
-
-        yield return new object[] { true, width, height, 0, 0, new Point(0, 0), scrollableSize };
-        yield return new object[] { false, width, height, 0, 0, new Point(0, 0), nonScrollableSize };
-
-        yield return new object[] { true, width, height, -10, 0, new Point(-10, 0), scrollableSize };
-        yield return new object[] { false, width, height, -10, 0, new Point(0, 0), nonScrollableSize };
-
-        yield return new object[] { true, width, height, 0, -20, new Point(0, -20), scrollableSize };
-        yield return new object[] { false, width, height, 0, -20, new Point(0, 0), nonScrollableSize };
-
-        yield return new object[] { true, width, height, -10, -20, new Point(-10, -20), scrollableSize };
-        yield return new object[] { false, width, height, -10, -20, new Point(0, 0), nonScrollableSize };
-
-        // Overflow.
-        yield return new object[] { true, width, height, -100, -20, new Point(-30, -20), scrollableSize };
-        yield return new object[] { false, width, height, -100, -20, new Point(0, 0), nonScrollableSize };
-
-        yield return new object[] { true, width, height, -10, -200, new Point(-10, -70), scrollableSize };
-        yield return new object[] { false, width, height, -10, -200, new Point(0, 0), nonScrollableSize };
-
-        // Underflow.
-        yield return new object[] { true, width, height, 1, 20, new Point(0, 0), scrollableSize };
-        yield return new object[] { false, width, height, 1, 20, new Point(0, 0), nonScrollableSize };
-
-        yield return new object[] { true, width, height, 10, 2, new Point(0, 0), scrollableSize };
-        yield return new object[] { false, width, height, 10, 2, new Point(0, 0), nonScrollableSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDisplayRectLocation_TestData))]
-    public void ScrollableControl_SetDisplayRectLocation_Invoke_Success(bool autoScroll, int width, int height, int scrollX, int scrollY, Point expectedDisplayRectangleLocation, Size expectedDisplayRectangleSize)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = autoScroll,
-            ClientSize = new Size(width, height)
-        };
-
-        // Without child.
-        control.SetDisplayRectLocation(scrollX, scrollY);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-
-        // With child.
-        using var child = new LargeControl();
-        control.Controls.Add(child);
-        Assert.Equal(child.ExpectedSize, child.Bounds);
-
-        control.SetDisplayRectLocation(scrollX, scrollY);
-        Assert.Equal(expectedDisplayRectangleSize, control.DisplayRectangle.Size);
-        Assert.Equal(expectedDisplayRectangleLocation, control.DisplayRectangle.Location);
-        Assert.Equal(expectedDisplayRectangleLocation, control.AutoScrollPosition);
-        Assert.Equal(child.ExpectedSize, child.Bounds);
-    }
-
-    public static IEnumerable<object[]> SetDisplayRectLocation_WithHandle_TestData()
-    {
-        const int width = 70;
-        const int height = 80;
-        Size scrollableSize = new Size(100, 150);
-        Size nonScrollableSize = new Size(width, height);
-
-        yield return new object[] { true, width, height, 0, 0, new Point(0, 0), scrollableSize, 1 };
-        yield return new object[] { false, width, height, 0, 0, new Point(0, 0), nonScrollableSize, 0 };
-
-        yield return new object[] { true, width, height, -10, 0, new Point(-10, 0), scrollableSize, 1 };
-        yield return new object[] { false, width, height, -10, 0, new Point(0, 0), nonScrollableSize, 0 };
-
-        yield return new object[] { true, width, height, 0, -20, new Point(0, -20), scrollableSize, 1 };
-        yield return new object[] { false, width, height, 0, -20, new Point(0, 0), nonScrollableSize, 0 };
-
-        yield return new object[] { true, width, height, -10, -20, new Point(-10, -20), scrollableSize, 1 };
-        yield return new object[] { false, width, height, -10, -20, new Point(0, 0), nonScrollableSize, 0 };
-
-        // Overflow.
-        yield return new object[] { true, width, height, -100, -20, new Point(-47, -20), scrollableSize, 1 };
-        yield return new object[] { false, width, height, -100, -20, new Point(0, 0), nonScrollableSize, 0 };
-
-        yield return new object[] { true, width, height, -10, -200, new Point(-10, -87), scrollableSize, 1 };
-        yield return new object[] { false, width, height, -10, -200, new Point(0, 0), nonScrollableSize, 0 };
-
-        // Underflow.
-        yield return new object[] { true, width, height, 1, 20, new Point(0, 0), scrollableSize, 1 };
-        yield return new object[] { false, width, height, 1, 20, new Point(0, 0), nonScrollableSize, 0 };
-
-        yield return new object[] { true, width, height, 10, 2, new Point(0, 0), scrollableSize, 1 };
-        yield return new object[] { false, width, height, 10, 2, new Point(0, 0), nonScrollableSize, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetDisplayRectLocation_WithHandle_TestData))]
-    public void ScrollableControl_SetDisplayRectLocation_InvokeWithHandle_Success(bool autoScroll, int width, int height, int scrollX, int scrollY, Point expectedDisplayRectangleLocation, Size expectedDisplayRectangleSize, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = autoScroll,
-            ClientSize = new Size(width, height)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Without child.
-        control.SetDisplayRectLocation(scrollX, scrollY);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // With child.
-        using var child = new LargeControl();
-        control.Controls.Add(child);
-        Assert.Equal(child.ExpectedSize, child.Bounds);
-
-        control.SetDisplayRectLocation(scrollX, scrollY);
-        Assert.Equal(expectedDisplayRectangleSize, control.DisplayRectangle.Size);
-        Assert.Equal(expectedDisplayRectangleLocation, control.DisplayRectangle.Location);
-        Assert.Equal(expectedDisplayRectangleLocation, control.AutoScrollPosition);
-        Assert.Equal(new Rectangle(expectedDisplayRectangleLocation, child.ExpectedSize.Size), child.Bounds);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetScrollState_TestData()
-    {
-        yield return new object[] { 1, true, true };
-        yield return new object[] { 1, false, false };
-        yield return new object[] { 0, true, true };
-        yield return new object[] { 0, false, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetScrollState_TestData))]
-    public void ScrollableControl_SetScrollState_Invoke_GetScrollStateReturnsExpected(int bit, bool value, bool expected)
-    {
-        using var control = new SubScrollableControl();
-        control.SetScrollState(bit, value);
-        Assert.Equal(expected, control.GetScrollState(bit));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SetScrollState(bit, value);
-        Assert.Equal(expected, control.GetScrollState(bit));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetScrollState_TestData))]
-    public void ScrollableControl_GetScrollState_InvokeWithHandle_GetStyleReturnsExpected(int bit, bool value, bool expected)
-    {
-        using var control = new SubScrollableControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetScrollState(bit, value);
-        Assert.Equal(expected, control.GetScrollState(bit));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SetScrollState(bit, value);
-        Assert.Equal(expected, control.GetScrollState(bit));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ScrollControlIntoView_TestData()
-    {
-        // Can't scroll - invalid child.
-        yield return new object[] { true, true, true, new Size(70, 80), null, new Rectangle(0, 0, 70, 80) };
-        yield return new object[] { false, true, true, new Size(70, 80), null, new Rectangle(0, 0, 70, 80) };
-
-        yield return new object[] { true, true, true, new Size(70, 80), new Control(), new Rectangle(0, 0, 70, 80) };
-
-        // Can't scroll - not AutoScroll.
-        yield return new object[] { false, true, true, new Size(70, 80), new LargeControl(), new Rectangle(0, 0, 70, 80) };
-
-        // Can't scroll - not HScroll or VScroll.
-        yield return new object[] { true, false, false, new Size(70, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-
-        // Can't scroll - empty.
-        yield return new object[] { true, false, false, new Size(0, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-        yield return new object[] { true, false, false, new Size(-1, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-        yield return new object[] { true, false, false, new Size(70, 0), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-        yield return new object[] { true, false, false, new Size(70, -1), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-
-        // Can scroll.
-        yield return new object[] { true, true, false, new Size(70, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-        yield return new object[] { true, false, true, new Size(70, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-        yield return new object[] { true, true, true, new Size(70, 80), new LargeControl(), new Rectangle(0, 0, 100, 150) };
-
-        yield return new object[] { true, true, false, new Size(70, 80), new SmallControl(), new Rectangle(0, 0, 70, 80) };
-        yield return new object[] { true, false, true, new Size(70, 80), new SmallControl(), new Rectangle(0, 0, 70, 80) };
-        yield return new object[] { true, true, true, new Size(70, 80), new SmallControl(), new Rectangle(0, 0, 70, 80) };
-
-        foreach (bool hScroll in new bool[] { true, false })
-        {
-            var childControl = new SmallControl();
-            var parentControl = new LargeControl();
-            parentControl.Controls.Add(childControl);
-            yield return new object[] { true, true, true, new Size(70, 80), parentControl, new Rectangle(0, 0, 100, 150) };
-            yield return new object[] { true, hScroll, true, new Size(70, 80), childControl, new Rectangle(0, 0, 100, 150) };
-        }
-
-        foreach (bool vScroll in new bool[] { true, false })
-        {
-            var childControl = new SmallControl();
-            var parentControl = new LargeControl();
-            parentControl.Controls.Add(childControl);
-            yield return new object[] { true, true, true, new Size(70, 80), parentControl, new Rectangle(0, 0, 100, 150) };
-            yield return new object[] { true, true, vScroll, new Size(70, 80), childControl, new Rectangle(0, 0, 100, 150) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollControlIntoView_TestData))]
-    public void ScrollableControl_ScrollControlIntoView_Invoke_Success(bool autoScroll, bool hScroll, bool vScroll, Size clientSize, Control activeControl, Rectangle expectedDisplayRectangle)
-    {
-        using var control = new SubScrollableControl
-        {
-            AutoScroll = autoScroll,
-            HScroll = hScroll,
-            VScroll = vScroll,
-            ClientSize = clientSize
-        };
-        if ((activeControl is LargeControl || activeControl is SmallControl))
-        {
-            control.Controls.Add(activeControl.Parent ?? activeControl);
-        }
-
-        control.ScrollControlIntoView(activeControl);
-        Assert.Equal(expectedDisplayRectangle, control.DisplayRectangle);
-
-        control.Controls.Clear();
-    }
-
-    private class LargeControl : Control
-    {
-        protected override Size DefaultSize => new(100, 150);
-
-        public Rectangle ExpectedSize => new(new Point(0, 0), DefaultSize);
-    }
-
-    private class SmallControl : Control
-    {
-        protected override Size DefaultSize => new(50, 60);
-    }
-
-    public class SubScrollableControl : ScrollableControl
-    {
-        public new const int ScrollStateAutoScrolling = ScrollableControl.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ScrollableControl.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ScrollableControl.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ScrollableControl.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ScrollableControl.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new void AdjustFormScrollbars(bool displayScrollbars) => base.AdjustFormScrollbars(displayScrollbars);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnPaddingChanged(EventArgs e) => base.OnPaddingChanged(e);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-
-        public new void OnScroll(ScrollEventArgs se) => base.OnScroll(se);
-
-        public new void ScaleCore(float dx, float dy) => base.ScaleCore(dx, dy);
-
-        public new void SetDisplayRectLocation(int x, int y) => base.SetDisplayRectLocation(x, y);
-
-        public new void SetScrollState(int bit, bool value) => base.SetScrollState(bit, value);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SearchForVirtualItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SearchForVirtualItemEventArgsTests.cs
deleted file mode 100644
index fb16624a73e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SearchForVirtualItemEventArgsTests.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SearchForVirtualItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Bool_Bool_Bool_String_Point_SearchDirectionHint_Int_TestData()
-    {
-        yield return new object[] { true, false, true, null, Point.Empty, (SearchDirectionHint)(SearchDirectionHint.Down + 1), -2 };
-        yield return new object[] { false, true, false, "", new Point(1, 2), SearchDirectionHint.Down, -1 };
-        yield return new object[] { false, true, false, "text", new Point(-1, -2), SearchDirectionHint.Down, 0 };
-        yield return new object[] { false, true, false, "text", new Point(1, 2), SearchDirectionHint.Down, 1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Bool_Bool_Bool_String_Point_SearchDirectionHint_Int_TestData))]
-    public void Ctor_Bool_Bool_Bool_String_Point_SearchDirectionHint_Int(bool isTextSearch, bool isPrefixSearch, bool includeSubItemsInSearch, string text, Point startingPoint, SearchDirectionHint direction, int startIndex)
-    {
-        var e = new SearchForVirtualItemEventArgs(isTextSearch, isPrefixSearch, includeSubItemsInSearch, text, startingPoint, direction, startIndex);
-        Assert.Equal(isTextSearch, e.IsTextSearch);
-        Assert.Equal(isPrefixSearch, e.IsPrefixSearch);
-        Assert.Equal(includeSubItemsInSearch, e.IncludeSubItemsInSearch);
-        Assert.Equal(text, e.Text);
-        Assert.Equal(startingPoint, e.StartingPoint);
-        Assert.Equal(direction, e.Direction);
-        Assert.Equal(startIndex, e.StartIndex);
-        Assert.Equal(-1, e.Index);
-    }
-
-    [Theory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Index_Set_GetReturnsExpected(int value)
-    {
-        var e = new SearchForVirtualItemEventArgs(false, true, false, "text", new Point(1, 2), SearchDirectionHint.Down, 1)
-        {
-            Index = value
-        };
-        Assert.Equal(value, e.Index);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SelectedGridItemChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SelectedGridItemChangedEventArgsTests.cs
deleted file mode 100644
index ad7e5f3056f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SelectedGridItemChangedEventArgsTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SelectedGridItemChangedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_GridItem_Object_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new SubGridItem(), null };
-        yield return new object[] { null, new SubGridItem() };
-        yield return new object[] { new SubGridItem(), new SubGridItem() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_GridItem_Object_TestData))]
-    public void Ctor_GridItem_GridItem(GridItem oldSel, GridItem newSel)
-    {
-        var e = new SelectedGridItemChangedEventArgs(oldSel, newSel);
-        Assert.Equal(oldSel, e.OldSelection);
-        Assert.Equal(newSel, e.NewSelection);
-    }
-
-    private class SubGridItem : GridItem
-    {
-        public override GridItemCollection GridItems { get; }
-
-        public override GridItemType GridItemType { get; }
-
-        public override string Label { get; }
-
-        public override GridItem Parent { get; }
-
-        public override PropertyDescriptor PropertyDescriptor { get; }
-
-        public override object Value { get; }
-
-        public override bool Select() => false;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SendKeysTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SendKeysTests.cs
deleted file mode 100644
index 5fe8f58d39a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SendKeysTests.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class SendKeysTests
-{
-    [WinFormsFact(Skip = "This test depends on focus and should be run manually.")]
-    public void SendKeysGrouping()
-    {
-        // Regression https://github.com/dotnet/winforms/issues/6666
-
-        using var form = new CaptureForm();
-        form.Show();
-        form.Focus();
-        SendKeys.SendWait("^(a)^(c)");
-
-        Assert.Equal(4, form.KeyEvents.Count);
-        Assert.Equal(Keys.ControlKey, form.KeyEvents[0].KeyCode);
-        Assert.Equal(Keys.A, form.KeyEvents[1].KeyCode);
-        Assert.Equal(Keys.Control, form.KeyEvents[1].Modifiers);
-        Assert.Equal(Keys.ControlKey, form.KeyEvents[2].KeyCode);
-        Assert.Equal(Keys.C, form.KeyEvents[3].KeyCode);
-        Assert.Equal(Keys.Control, form.KeyEvents[3].Modifiers);
-    }
-
-    private class CaptureForm : Form
-    {
-        public List<KeyEventArgs> KeyEvents { get; } = new();
-
-        protected override void OnKeyDown(KeyEventArgs e)
-        {
-            KeyEvents.Add(e);
-            base.OnKeyDown(e);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SpecialFolderEnumConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SpecialFolderEnumConverterTests.cs
deleted file mode 100644
index 4fd5aeb856e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SpecialFolderEnumConverterTests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SpecialFolderEnumConverterTests
-{
-    [Fact]
-    public void SpecialFolderEnumConverter_ConvertFrom_String_Success()
-    {
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(new FolderBrowserDialog()).Find(nameof(FolderBrowserDialog.RootFolder), ignoreCase: false);
-        TypeConverter converter = descriptor.Converter;
-        Assert.Equal(Environment.SpecialFolder.CommonDocuments, converter.ConvertFrom("CommonDocuments"));
-    }
-
-    [Fact]
-    public void SpecialFolderEnumConverter_GetStandardValues_Invoke_ReturnsExpected()
-    {
-        TypeConverter converter = GetNewSpecialFolderEnumConverter();
-        var expected = new Environment.SpecialFolder[]
-        {
-            Environment.SpecialFolder.AdminTools,
-            Environment.SpecialFolder.ApplicationData,
-            Environment.SpecialFolder.CDBurning,
-            Environment.SpecialFolder.CommonAdminTools,
-            Environment.SpecialFolder.CommonApplicationData,
-            Environment.SpecialFolder.CommonDesktopDirectory,
-            Environment.SpecialFolder.CommonDocuments,
-            Environment.SpecialFolder.CommonMusic,
-            Environment.SpecialFolder.CommonOemLinks,
-            Environment.SpecialFolder.CommonPictures,
-            Environment.SpecialFolder.CommonProgramFiles,
-            Environment.SpecialFolder.CommonProgramFilesX86,
-            Environment.SpecialFolder.CommonPrograms,
-            Environment.SpecialFolder.CommonStartMenu,
-            Environment.SpecialFolder.CommonStartup,
-            Environment.SpecialFolder.CommonTemplates,
-            Environment.SpecialFolder.CommonVideos,
-            Environment.SpecialFolder.Cookies,
-            Environment.SpecialFolder.Desktop,
-            Environment.SpecialFolder.DesktopDirectory,
-            Environment.SpecialFolder.Favorites,
-            Environment.SpecialFolder.Fonts,
-            Environment.SpecialFolder.History,
-            Environment.SpecialFolder.InternetCache,
-            Environment.SpecialFolder.LocalApplicationData,
-            Environment.SpecialFolder.LocalizedResources,
-            Environment.SpecialFolder.MyComputer,
-            Environment.SpecialFolder.MyDocuments,
-            Environment.SpecialFolder.MyMusic,
-            Environment.SpecialFolder.MyPictures,
-            Environment.SpecialFolder.MyVideos,
-            Environment.SpecialFolder.NetworkShortcuts,
-            Environment.SpecialFolder.PrinterShortcuts,
-            Environment.SpecialFolder.ProgramFiles,
-            Environment.SpecialFolder.ProgramFilesX86,
-            Environment.SpecialFolder.Programs,
-            Environment.SpecialFolder.Recent,
-            Environment.SpecialFolder.Resources,
-            Environment.SpecialFolder.SendTo,
-            Environment.SpecialFolder.StartMenu,
-            Environment.SpecialFolder.Startup,
-            Environment.SpecialFolder.System,
-            Environment.SpecialFolder.SystemX86,
-            Environment.SpecialFolder.Templates,
-            Environment.SpecialFolder.UserProfile,
-            Environment.SpecialFolder.Windows
-        };
-        Assert.Equal(expected, converter.GetStandardValues(null).Cast<Environment.SpecialFolder>());
-
-        converter = GetNewSpecialFolderEnumConverter();
-        var mockProvider = new Mock<TypeDescriptionProvider>(MockBehavior.Strict);
-        mockProvider
-            .Setup(p => p.GetReflectionType(typeof(Environment.SpecialFolder), null))
-            .Returns(() => typeof(CustomReflectionType));
-
-        TypeDescriptor.AddProvider(mockProvider.Object, typeof(Environment.SpecialFolder));
-        Assert.Equal(new Environment.SpecialFolder[] { Environment.SpecialFolder.Personal }, converter.GetStandardValues(null).Cast<Environment.SpecialFolder>());
-        TypeDescriptor.RemoveProvider(mockProvider.Object, typeof(Environment.SpecialFolder));
-    }
-
-    [Fact]
-    public void SpecialFolderEnumConverter_GetStandardValues_NonSpecialFolderType_ReturnsExpected()
-    {
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(new FolderBrowserDialog()).Find(nameof(FolderBrowserDialog.RootFolder), ignoreCase: false);
-        TypeConverter converter = (TypeConverter)Activator.CreateInstance(descriptor.Converter.GetType(), new Type[] { typeof(CustomEnum) });
-        Assert.Equal(new CustomEnum[] { CustomEnum.Value }, converter.GetStandardValues(null).Cast<CustomEnum>());
-    }
-
-    private TypeConverter GetNewSpecialFolderEnumConverter()
-    {
-        PropertyDescriptor descriptor = TypeDescriptor.GetProperties(new FolderBrowserDialog()).Find(nameof(FolderBrowserDialog.RootFolder), ignoreCase: false);
-        return (TypeConverter)Activator.CreateInstance(descriptor.Converter.GetType(), new Type[] { typeof(Environment.SpecialFolder) });
-    }
-
-    private class CustomReflectionType
-    {
-#pragma warning disable CS0649
-        public static int Personal;
-#pragma warning restore CS0649
-    }
-
-    private enum CustomEnum
-    {
-        Value
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitContainer.SplitContainerAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitContainer.SplitContainerAccessibleObjectTests.cs
deleted file mode 100644
index a5cfa3bad80..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitContainer.SplitContainerAccessibleObjectTests.cs
+++ /dev/null
@@ -1,118 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class SplitContainer_SplitContainerAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void SplitContainerAccessibleObject_Ctor_Default()
-    {
-        using SplitContainer splitContainer = new();
-        SplitContainer.SplitContainerAccessibleObject accessibleObject = new(splitContainer);
-
-        Assert.Equal(splitContainer, accessibleObject.Owner);
-        Assert.False(splitContainer.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitContainerAccessibleObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using SplitContainer splitContainer = new();
-        splitContainer.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = splitContainer.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-
-        Assert.Equal(UIA.PaneControlTypeId, actual);
-        Assert.True(splitContainer.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitContainerAccessibleObject_Role_IsClient_ByDefault()
-    {
-        using SplitContainer splitContainer = new();
-        splitContainer.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = splitContainer.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Client, actual);
-        Assert.True(splitContainer.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SplitContainerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitContainerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void SplitContainerAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using SplitContainer splitContainer = new();
-        splitContainer.AccessibleRole = role;
-
-        object actual = splitContainer.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-        UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(splitContainer.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "SplitContainer1")]
-    public void SplitContainerAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using SplitContainer control = new()
-        {
-            Name = "SplitContainer1",
-            AccessibleName = "TestName"
-        };
-
-        var accessibleObject = new SplitContainer.SplitContainerAccessibleObject(control);
-        object value = accessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitContainerAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsTrue_IfControlHasFocus()
-    {
-        using SplitContainer control = new();
-
-        var accessibleObject = new SplitContainer.SplitContainerAccessibleObject(control);
-        Assert.False(control.IsHandleCreated);
-        control.FocusActiveControlInternal();
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.True(value);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitContainerAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsFalse_IfControlHasNoFocus()
-    {
-        using SplitContainer control = new();
-
-        var accessibleObject = new SplitContainer.SplitContainerAccessibleObject(control);
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(value);
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Splitter.SplitterAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Splitter.SplitterAccessibleObjectTests.cs
deleted file mode 100644
index 044d5aa9aa6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/Splitter.SplitterAccessibleObjectTests.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class Splitter_SplitterAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void SplitterAccessibleObject_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("ownerControl", () => new Splitter.SplitterAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void SplitterAccessibleObject_Ctor_Default()
-    {
-        using var splitter = new Splitter();
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.NotNull(splitterAccessibleObject.Owner);
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterAccessibleObject_Description_ReturnsExpected()
-    {
-        using var splitter = new Splitter
-        {
-            AccessibleDescription = "TestDescription"
-        };
-
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.Equal("TestDescription", splitterAccessibleObject.Description);
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterAccessibleObject_Name_ReturnsExpected()
-    {
-        using var splitter = new Splitter
-        {
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.Equal("TestName", splitterAccessibleObject.Name);
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterAccessibleObject_CustomRole_ReturnsExpected()
-    {
-        using var splitter = new Splitter
-        {
-            AccessibleRole = AccessibleRole.PushButton
-        };
-
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.Equal(AccessibleRole.PushButton, splitterAccessibleObject.Role);
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void SplitterAccessibleObject_DefaultRole_ReturnsNone_IfControlIsNotCreated(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var splitter = new Splitter();
-
-        if (createControl)
-        {
-            splitter.CreateControl();
-        }
-
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.Equal(accessibleRole, splitterAccessibleObject.Role);
-        Assert.Equal(createControl, splitter.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.ControlTypePropertyId, UIA.PaneControlTypeId)] // If AccessibleRole is Default
-    [InlineData((int)UIA.IsKeyboardFocusablePropertyId, true)]
-    [InlineData((int)UIA.AutomationIdPropertyId, "Splitter1")]
-    public void SplitterAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var splitter = new Splitter
-        {
-            Name = "Splitter1",
-            AccessibleName = "TestName"
-        };
-
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-        object value = splitterAccessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterAccessibleObject_IsPatternSupported_Invoke_ReturnsTrue_ForLegacyIAccessiblePattern()
-    {
-        using var splitter = new Splitter
-        {
-            Name = "Splitter1"
-        };
-        Assert.False(splitter.IsHandleCreated);
-        var splitterAccessibleObject = new Splitter.SplitterAccessibleObject(splitter);
-
-        Assert.True(splitterAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(splitter.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SplitterAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitterAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void SplitterAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using Splitter splitter = new Splitter();
-        splitter.AccessibleRole = role;
-
-        object actual = splitter.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(splitter.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterCancelEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterCancelEventArgsTests.cs
deleted file mode 100644
index ea2943b88be..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterCancelEventArgsTests.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SplitterCancelEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1, -1, -1)]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(1, 2, 3, 4)]
-    public void Ctor_Int_Int_Int_Int(int mouseCursorX, int mouseCursorY, int splitX, int splitY)
-    {
-        var e = new SplitterCancelEventArgs(mouseCursorX, mouseCursorY, splitX, splitY);
-        Assert.Equal(mouseCursorX, e.MouseCursorX);
-        Assert.Equal(mouseCursorY, e.MouseCursorY);
-        Assert.Equal(splitX, e.SplitX);
-        Assert.Equal(splitY, e.SplitY);
-        Assert.False(e.Cancel);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SplitX_Set_GetReturnsExpected(int value)
-    {
-        var e = new SplitterCancelEventArgs(1, 2, 3, 4)
-        {
-            SplitX = value
-        };
-        Assert.Equal(value, e.SplitX);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SplitY_Set_GetReturnsExpected(int value)
-    {
-        var e = new SplitterCancelEventArgs(1, 2, 3, 4)
-        {
-            SplitY = value
-        };
-        Assert.Equal(value, e.SplitY);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterEventArgsTests.cs
deleted file mode 100644
index 3159112c971..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterEventArgsTests.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SplitterEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1, -1, -1)]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(1, 2, 3, 4)]
-    public void Ctor_Int_Int_Int_Int(int x, int y, int splitX, int splitY)
-    {
-        var e = new SplitterEventArgs(x, y, splitX, splitY);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(splitX, e.SplitX);
-        Assert.Equal(splitY, e.SplitY);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SplitX_Set_GetReturnsExpected(int value)
-    {
-        var e = new SplitterEventArgs(1, 2, 3, 4)
-        {
-            SplitX = value
-        };
-        Assert.Equal(value, e.SplitX);
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SplitY_Set_GetReturnsExpected(int value)
-    {
-        var e = new SplitterEventArgs(1, 2, 3, 4)
-        {
-            SplitY = value
-        };
-        Assert.Equal(value, e.SplitY);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterPanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterPanelTests.cs
deleted file mode 100644
index 6f93c8f709e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterPanelTests.cs
+++ /dev/null
@@ -1,1221 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class SplitterPanelTests
-{
-    public static IEnumerable<object[]> Ctor_SplitContainer_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SplitContainer() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_SplitContainer_TestData))]
-    public void SplitterPanel_Ctor_SplitContainer(SplitContainer owner)
-    {
-        using var control = new SplitterPanel(owner);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Equal(Cursors.Default, control.Cursor);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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.True(control.Enabled);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, 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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Anchor_Set_TestData), MemberType = typeof(ControlTests))]
-    public void SplitterPanel_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Anchor = value
-        };
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SplitterPanel_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SplitterPanel(null);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new SplitterPanel(null)
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void SplitterPanel_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SplitterPanel(null);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void SplitterPanel_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new Control();
-        using var control = new SplitterPanel(null)
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void SplitterPanel_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void SplitterPanel_AutoSizeMode_SetWithHandleWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new Control();
-        using var control = new SplitterPanel(null)
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void SplitterPanel_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void SplitterPanel_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void SplitterPanel_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void SplitterPanel_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Dock = value
-        };
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Dock = DockStyle.None
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void SplitterPanel_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4)]
-    [InlineData(0)]
-    [InlineData(2)]
-    [InlineData(40)]
-    public void SplitterPanel_Height_Set_ThrowsNotSupportedException(int value)
-    {
-        using var control = new SplitterPanel(null);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        Assert.Throws<NotSupportedException>(() => control.Height = value);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Throws<NotSupportedException>(() => control.Height = value);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Location_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(-1, -2), 1 };
-        yield return new object[] { new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void SplitterPanel_Location_Set_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SplitterPanel(null);
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_Location_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new SplitterPanel(null);
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different x.
-        control.Location = new Point(2, 2);
-        Assert.Equal(new Point(2, 2), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Set different y.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MaximumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void SplitterPanel_MaximumSize_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MinimumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void SplitterPanel_MinimumSize_Set_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void SplitterPanel_Name_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Name = value
-        };
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Get again.
-        control.Name = value;
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-        yield return new object[] { new Form() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void SplitterPanel_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new Control();
-        using var control = new SplitterPanel(null);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(-3, -4), 1 };
-        yield return new object[] { new Size(0, 0), 1 };
-        yield return new object[] { new Size(1, 0), 1 };
-        yield return new object[] { new Size(0, 2), 1 };
-        yield return new object[] { new Size(30, 40), 1 };
-        yield return new object[] { new Size(200, 100), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void SplitterPanel_Size_Set_GetReturnsExpected(Size value, int expectedLayoutCallCount)
-    {
-        using var control = new SplitterPanel(null);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Size = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Size = value;
-        Assert.Equal(value, control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.DisplayRectangle);
-        Assert.Equal(value, control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(value.Width, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(value.Height, control.Bottom);
-        Assert.Equal(value.Width, control.Width);
-        Assert.Equal(value.Height, control.Height);
-        Assert.Equal(new Rectangle(0, 0, value.Width, value.Height), control.Bounds);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void SplitterPanel_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new SplitterPanel(null)
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new SplitterPanel(null);
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SplitterPanel_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SplitterPanel_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new SplitterPanel(null)
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void SplitterPanel_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void SplitterPanel_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SplitterPanel(null);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SplitterPanel(null);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void SplitterPanel_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void SplitterPanel_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new SplitterPanel(null)
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-4)]
-    [InlineData(0)]
-    [InlineData(2)]
-    [InlineData(40)]
-    public void SplitterPanel_Width_Set_ThrowsNotSupportedException(int value)
-    {
-        using var control = new SplitterPanel(null);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        Assert.Throws<NotSupportedException>(() => control.Width = value);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Throws<NotSupportedException>(() => control.Width = value);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(0, control.Top);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterTests.cs
deleted file mode 100644
index 96124b878fa..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SplitterTests.cs
+++ /dev/null
@@ -1,2387 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class SplitterTests
-{
-    [WinFormsFact]
-    public void Splitter_Ctor_Default()
-    {
-        using var control = new SubSplitter();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(3, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 3, 3), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(3, 3), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 3, 3), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.VSplit, control.Cursor);
-        Assert.Same(Cursors.VSplit, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(3, 3), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 3, 3), control.DisplayRectangle);
-        Assert.Equal(DockStyle.Left, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(25, control.MinExtra);
-        Assert.Equal(25, control.MinSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(new Size(3, 3), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(3, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(3, 3), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(3, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Splitter_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubSplitter();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(3, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(3, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56000000, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x56000000, 0x200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56800000, 0)]
-    public void Splitter_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubSplitter
-        {
-            BorderStyle = borderStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(3, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(3, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Splitter_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Splitter
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = !value;
-        Assert.Equal(!value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AnchorStyles>]
-    [InvalidEnumData<AnchorStyles>]
-    public void Splitter_Anchor_Set_GetReturnsExpected(AnchorStyles value)
-    {
-        using var control = new Splitter();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Anchor = value;
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void Splitter_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new Splitter
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Splitter_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void Splitter_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubSplitter
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Splitter_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void Splitter_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new Splitter()
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(3, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(3, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void Splitter_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(3, control.Height);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(3, control.Height);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void Splitter_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new Splitter();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    public static IEnumerable<object[]> DefaultCursor_TestData()
-    {
-        yield return new object[] { DockStyle.Top, Cursors.HSplit };
-        yield return new object[] { DockStyle.Bottom, Cursors.HSplit };
-        yield return new object[] { DockStyle.Left, Cursors.VSplit };
-        yield return new object[] { DockStyle.Right, Cursors.VSplit };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultCursor_TestData))]
-    public void Splitter_DefaultCursor_GetWithDockStyle_ReturnsExpected(DockStyle dock, Cursor expected)
-    {
-        using var control = new SubSplitter
-        {
-            Dock = dock
-        };
-        Assert.Equal(expected, control.Cursor);
-        Assert.Equal(expected, control.DefaultCursor);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DockStyle.Left)]
-    [InlineData(DockStyle.Right)]
-    [InlineData(DockStyle.Top)]
-    [InlineData(DockStyle.Bottom)]
-    public void Splitter_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Splitter();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DockStyle.Left, 40, 0)]
-    [InlineData(DockStyle.Right, 40, 0)]
-    [InlineData(DockStyle.Top, 50, 1)]
-    [InlineData(DockStyle.Bottom, 50, 1)]
-    public void Splitter_Dock_SetCustomWidthHeight_GetReturnsExpected(DockStyle value, int expectedHeight, int expectedLayoutCallCount)
-    {
-        using var control = new Splitter
-        {
-            Width = 50,
-            Height = 40
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(50, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(50, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DockStyle.Left)]
-    [InlineData(DockStyle.Right)]
-    [InlineData(DockStyle.Top)]
-    [InlineData(DockStyle.Bottom)]
-    public void Splitter_Dock_SetWithOldValue_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Splitter
-        {
-            Dock = DockStyle.Top
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(DockStyle.Left, 40, 1)]
-    [InlineData(DockStyle.Right, 40, 1)]
-    [InlineData(DockStyle.Top, 50, 0)]
-    [InlineData(DockStyle.Bottom, 50, 0)]
-    public void Splitter_Dock_SetWithOldValueCustomWidthHeight_GetReturnsExpected(DockStyle value, int expectedWidth, int expectedLayoutCallCount)
-    {
-        using var control = new Splitter
-        {
-            Dock = DockStyle.Top,
-            Width = 50,
-            Height = 40
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(40, control.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(40, control.Height);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Dock_SetWithParent_TestData()
-    {
-        yield return new object[] { DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Left, 0 };
-        yield return new object[] { DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Top, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_SetWithParent_TestData))]
-    public void Splitter_Dock_SetWithParent_GetReturnsExpected(DockStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Splitter();
-        using var control = new Splitter
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Dock", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.None, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.None, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Splitter_Dock_SetWithOldValueWithParent_TestData()
-    {
-        yield return new object[] { DockStyle.Bottom, DockStyle.Bottom, 0 };
-        yield return new object[] { DockStyle.Left, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Bottom, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Left, 0 };
-        yield return new object[] { DockStyle.Right, DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Left, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Right, 0 };
-        yield return new object[] { DockStyle.Top, DockStyle.Right, 1 };
-
-        yield return new object[] { DockStyle.Bottom, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Left, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Right, DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Top, DockStyle.Top, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Splitter_Dock_SetWithOldValueWithParent_TestData))]
-    public void Splitter_Dock_SetWithOldValueWithParent_GetReturnsExpected(DockStyle oldValue, DockStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Splitter();
-        using var control = new Splitter
-        {
-            Dock = oldValue,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Dock", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.None, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.None, control.Anchor);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(DockStyle.Left)]
-    [InlineData(DockStyle.Right)]
-    [InlineData(DockStyle.Top)]
-    [InlineData(DockStyle.Bottom)]
-    public void Splitter_Dock_SetWithHandle_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.None, control.Anchor);
-        Assert.Equal(3, control.Width);
-        Assert.Equal(3, control.Height);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new Splitter
-        {
-            Dock = DockStyle.Bottom
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    [InlineData(DockStyle.None)]
-    [InlineData(DockStyle.Fill)]
-    public void Splitter_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new Splitter();
-        Assert.Throws<ArgumentException>(() => control.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void Splitter_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubSplitter
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void Splitter_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void Splitter_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new Splitter
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.Empty, Control.DefaultForeColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void Splitter_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void Splitter_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new Splitter
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void Splitter_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void Splitter_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new Splitter();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(25, 25)]
-    [InlineData(50, 50)]
-    public void Splitter_MinExtra_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new Splitter
-        {
-            MinExtra = value
-        };
-        Assert.Equal(expected, control.MinExtra);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinExtra = value;
-        Assert.Equal(expected, control.MinExtra);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(25, 25)]
-    [InlineData(50, 50)]
-    public void Splitter_MinExtra_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MinExtra = value;
-        Assert.Equal(expected, control.MinExtra);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MinExtra = value;
-        Assert.Equal(expected, control.MinExtra);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(25, 25)]
-    [InlineData(50, 50)]
-    public void Splitter_MinSize_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new Splitter
-        {
-            MinSize = value
-        };
-        Assert.Equal(expected, control.MinSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinSize = value;
-        Assert.Equal(expected, control.MinSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(25, 25)]
-    [InlineData(50, 50)]
-    public void Splitter_MinSize_SetWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MinSize = value;
-        Assert.Equal(expected, control.MinSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MinSize = value;
-        Assert.Equal(expected, control.MinSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SplitPosition_Set_TestData()
-    {
-        yield return new object[] { DockStyle.Right, -2 };
-        yield return new object[] { DockStyle.Right, 1 };
-        yield return new object[] { DockStyle.Right, 0 };
-        yield return new object[] { DockStyle.Right, 25 };
-
-        yield return new object[] { DockStyle.Left, -2 };
-        yield return new object[] { DockStyle.Left, 1 };
-        yield return new object[] { DockStyle.Left, 0 };
-        yield return new object[] { DockStyle.Left, 25 };
-
-        yield return new object[] { DockStyle.Top, -2 };
-        yield return new object[] { DockStyle.Top, 1 };
-        yield return new object[] { DockStyle.Top, 0 };
-        yield return new object[] { DockStyle.Top, 25 };
-
-        yield return new object[] { DockStyle.Bottom, -2 };
-        yield return new object[] { DockStyle.Bottom, 1 };
-        yield return new object[] { DockStyle.Bottom, 0 };
-        yield return new object[] { DockStyle.Bottom, 25 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitPosition_Set_TestData))]
-    public void Splitter_SplitPosition_Set_GetReturnsExpected(DockStyle dock, int value)
-    {
-        using var control = new Splitter
-        {
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitPosition_Set_TestData))]
-    public void Splitter_SplitPosition_SetWithParent_GetReturnsExpected(DockStyle dock, int value)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var control = new Splitter
-        {
-            Parent = parent,
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SplitPosition_SetWithParentNoChild_TestData()
-    {
-        foreach (DockStyle childDock in Enum.GetValues(typeof(DockStyle)))
-        {
-            yield return new object[] { childDock, DockStyle.Right, -2 };
-            yield return new object[] { childDock, DockStyle.Right, 1 };
-            yield return new object[] { childDock, DockStyle.Right, 0 };
-            yield return new object[] { childDock, DockStyle.Right, 25 };
-
-            yield return new object[] { childDock, DockStyle.Left, -2 };
-            yield return new object[] { childDock, DockStyle.Left, 1 };
-            yield return new object[] { childDock, DockStyle.Left, 0 };
-            yield return new object[] { childDock, DockStyle.Left, 25 };
-
-            yield return new object[] { childDock, DockStyle.Top, -2 };
-            yield return new object[] { childDock, DockStyle.Top, 1 };
-            yield return new object[] { childDock, DockStyle.Top, 0 };
-            yield return new object[] { childDock, DockStyle.Top, 25 };
-
-            yield return new object[] { childDock, DockStyle.Bottom, -2 };
-            yield return new object[] { childDock, DockStyle.Bottom, 1 };
-            yield return new object[] { childDock, DockStyle.Bottom, 0 };
-            yield return new object[] { childDock, DockStyle.Bottom, 25 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitPosition_SetWithParentNoChild_TestData))]
-    public void Splitter_SplitPosition_SetWithParentNoChild_GetReturnsExpected(DockStyle childDock, DockStyle dock, int value)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var child = new Control
-        {
-            Parent = parent,
-            Dock = childDock,
-            Bounds = new Rectangle(10, 10, 50, 50)
-        };
-        using var control = new Splitter
-        {
-            Parent = parent,
-            Dock = dock,
-            Location = new Point(50, 0)
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 25)]
-    [InlineData(-1, 25)]
-    [InlineData(0, 25)]
-    [InlineData(25, 25)]
-    [InlineData(40, 40)]
-    [InlineData(50, 50)]
-    [InlineData(100, 72)]
-    [InlineData(110, 72)]
-    public void Splitter_SplitPosition_SetWithParentLeftChild_GetReturnsExpected(int value, int expected)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var child = new Control
-        {
-            Parent = parent,
-            Bounds = new Rectangle(0, 0, 0, 100)
-        };
-        using var control = new Splitter
-        {
-            Parent = parent,
-            Dock = DockStyle.Left,
-            Bounds = new Rectangle(50, 0, 3, 3)
-        };
-        Assert.Equal(child.Right, control.Left);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(expected, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitPosition_Set_TestData))]
-    public void Splitter_SplitPosition_SetWithHandle_GetReturnsExpected(DockStyle dock, int value)
-    {
-        using var control = new Splitter
-        {
-            Dock = dock
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitPosition_Set_TestData))]
-    public void Splitter_SplitPosition_SetWithParentHandle_GetReturnsExpected(DockStyle dock, int value)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var control = new Splitter
-        {
-            Parent = parent,
-            Dock = dock
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 25)]
-    [InlineData(-1, 25)]
-    [InlineData(0, 25)]
-    [InlineData(25, 25)]
-    [InlineData(40, 40)]
-    [InlineData(50, 50)]
-    [InlineData(100, 72)]
-    [InlineData(110, 72)]
-    public void Splitter_SplitPosition_SetWithParentLeftChildWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var child = new Control
-        {
-            Parent = parent,
-            Bounds = new Rectangle(0, 0, 0, 100)
-        };
-        using var control = new Splitter
-        {
-            Parent = parent,
-            Dock = DockStyle.Left,
-            Bounds = new Rectangle(50, 0, 3, 3)
-        };
-        Assert.Equal(child.Right, control.Left);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.SplitPosition = value;
-        Assert.Equal(expected, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(child.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SplitPosition = value;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(child.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_SplitPosition_SetWithHandler_DoesNotCallsSplitterMoved()
-    {
-        using var control = new Splitter
-        {
-            SplitPosition = 0
-        };
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int callCount = 0;
-        SplitterEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(control.Left, e.X);
-            Assert.Equal(control.Top, e.Y);
-            Assert.Equal(control.Left + control.Bounds.Width / 2, e.SplitX);
-            Assert.Equal(control.Top + control.Bounds.Height / 2, e.SplitY);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.SplitterMoved += handler;
-
-        // Set different.
-        control.SplitPosition = 1;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.SplitPosition = 1;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.SplitPosition = 2;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.SplitterMoved -= handler;
-        control.SplitPosition = 1;
-        Assert.Equal(-1, control.SplitPosition);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Splitter_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new Splitter()
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Splitter_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new Splitter()
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Splitter_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Splitter()
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Splitter_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new Splitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new Splitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Same("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Same("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Same("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubSplitter();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void Splitter_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubSplitter();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void Splitter_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubSplitter();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> KeyEventArgs_TestData()
-    {
-        yield return new object[] { new KeyEventArgs(Keys.None) };
-        yield return new object[] { new KeyEventArgs(Keys.Cancel) };
-        yield return new object[] { new KeyEventArgs(Keys.Escape) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyEventArgs_TestData))]
-    public void Splitter_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void Splitter_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(KeyEventArgs_TestData))]
-    public void Splitter_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void Splitter_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 2, 3, 4) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4) };
-        yield return new object[] { new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void Splitter_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnMouseDown_WithTarget_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 2, 3, 4), false };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), true };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Middle, 1, 2, 3, 4), false };
-        yield return new object[] { new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_WithTarget_TestData))]
-    public void Splitter_OnMouseDown_InvokeWithTarget_CallsMouseDown(MouseEventArgs eventArgs, bool expectedIsHandleCreated)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var child = new Control
-        {
-            Parent = parent,
-            Bounds = new Rectangle(0, 0, 0, 100)
-        };
-        using var control = new SubSplitter
-        {
-            Parent = parent,
-            Dock = DockStyle.Left,
-            Bounds = new Rectangle(50, 0, 3, 3)
-        };
-        Assert.Equal(child.Right, control.Left);
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-        Assert.Equal(expectedIsHandleCreated, child.IsHandleCreated);
-        Assert.Equal(expectedIsHandleCreated, parent.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.Equal(expectedIsHandleCreated, control.IsHandleCreated);
-        Assert.Equal(expectedIsHandleCreated, child.IsHandleCreated);
-        Assert.Equal(expectedIsHandleCreated, parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void Splitter_OnMouseDown_InvokeWithHandle_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseDown_TestData))]
-    public void Splitter_OnMouseDown_InvokeWithTargetWithHandle_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var parent = new Control
-        {
-            Width = 100,
-            Height = 100
-        };
-        using var child = new Control
-        {
-            Parent = parent,
-            Bounds = new Rectangle(0, 0, 0, 100)
-        };
-        using var control = new SubSplitter
-        {
-            Parent = parent,
-            Dock = DockStyle.Left,
-            Bounds = new Rectangle(50, 0, 3, 3)
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.Equal(child.Right, control.Left);
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(child.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.True(child.IsHandleCreated);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Splitter_OnMouseDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubSplitter();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Splitter_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void Splitter_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int splitterMovingCallCount = 0;
-        control.SplitterMoving += (sender, e) => splitterMovingCallCount++;
-        int splitterMovedCallCount = 0;
-        control.SplitterMoved += (sender, e) => splitterMovedCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, splitterMovingCallCount);
-        Assert.Equal(0, splitterMovedCallCount);
-    }
-
-    public static IEnumerable<object[]> SplitterEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SplitterEventArgs(0, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitterEventArgs_TestData))]
-    public void Splitter_OnSplitterMoved_Invoke_CallsSplitterMoved(SplitterEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int callCount = 0;
-        SplitterEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SplitterMoved += handler;
-        control.OnSplitterMoved(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SplitterMoved -= handler;
-        control.OnSplitterMoved(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SplitterEventArgs_TestData))]
-    public void Splitter_OnSplitterMoving_Invoke_CallsSplitterMoving(SplitterEventArgs eventArgs)
-    {
-        using var control = new SubSplitter();
-        int callCount = 0;
-        SplitterEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SplitterMoving += handler;
-        control.OnSplitterMoving(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.SplitterMoving -= handler;
-        control.OnSplitterMoving(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new Splitter();
-        Assert.Equal("System.Windows.Forms.Splitter, MinExtra: 25, MinSize: 25", control.ToString());
-    }
-
-    private class SubSplitter : Splitter
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnSplitterMoved(SplitterEventArgs sevent) => base.OnSplitterMoved(sevent);
-
-        public new void OnSplitterMoving(SplitterEventArgs sevent) => base.OnSplitterMoving(sevent);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStrip.StatusStripAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStrip.StatusStripAccessibleObjectTests.cs
deleted file mode 100644
index 7d494303205..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStrip.StatusStripAccessibleObjectTests.cs
+++ /dev/null
@@ -1,939 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-using static Interop.UiaCore;
-using static System.Windows.Forms.Tests.ToolStripAccessibleObjectTests;
-
-namespace System.Windows.Forms.Tests;
-
-public class StatusStrip_StatusStripAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected()
-    {
-        using var statusStrip = new StatusStrip()
-        {
-            Name = "Name1",
-            AccessibleName = "Test Name"
-        };
-
-        AccessibleObject statusStripAccessibleObject = statusStrip.AccessibilityObject;
-        var accessibleName = statusStripAccessibleObject.GetPropertyValue(UIA.NamePropertyId);
-
-        Assert.Equal("Test Name", accessibleName);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var statusStrip = new StatusStrip();
-        AccessibleObject statusStripAccessibleObject = statusStrip.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = statusStripAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_LegacyIAccessible_Custom_Role_ReturnsExpected()
-    {
-        using var statusStrip = new StatusStrip()
-        {
-            AccessibleRole = AccessibleRole.Link
-        };
-
-        AccessibleObject statusStripAccessibleObject = statusStrip.AccessibilityObject;
-        var accessibleObjectRole = statusStripAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_LegacyIAccessible_Custom_Description_ReturnsExpected()
-    {
-        using var statusStrip = new StatusStrip()
-        {
-            AccessibleDescription = "Test Description"
-        };
-
-        AccessibleObject statusStripAccessibleObject = statusStrip.AccessibilityObject;
-        var accessibleObjectDescription = statusStripAccessibleObject.Description;
-
-        Assert.Equal("Test Description", accessibleObjectDescription);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_ControlType_IsStatusBar_IfAccessibleRoleIsDefault()
-    {
-        using StatusStrip statusStrip = new StatusStrip();
-        // AccessibleRole is not set = Default
-
-        object actual = statusStrip.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-
-        Assert.Equal(UIA.StatusBarControlTypeId, actual);
-        Assert.False(statusStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_Role_IsStatusBar_ByDefault()
-    {
-        using StatusStrip statusStrip = new StatusStrip();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = statusStrip.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.StatusBar, actual);
-        Assert.False(statusStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void StatusStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using StatusStrip statusStrip = new StatusStrip();
-        statusStrip.AccessibleRole = role;
-
-        object actual = statusStrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(statusStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData()
-    {
-        Array directions = Enum.GetValues<NavigateDirection>();
-
-        foreach (NavigateDirection direction in directions)
-        {
-            yield return new object[] { direction };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated(int navigateDirection)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(itemCount: 1, createControl: false);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate((NavigateDirection)navigateDirection));
-        Assert.False(statusStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using StatusStrip statusStrip = CreateStatusStrip();
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void StatusStripAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using StatusStrip statusStrip = CreateStatusStrip();
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(70, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(70, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData()
-    {
-        foreach (object[] data in StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(70, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisibleAndToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfOverflow(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: true, itemCount: 1);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndStackLayout(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: false, itemCount: 1);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData()
-    {
-        Size overflowSize = new(70, 10);
-
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, overflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock: null, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        statusStrip.Items.Insert(0, CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        statusStrip.Items.Add(CreateSkippedItem());
-        statusStrip.Items.Add(CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items.Insert(0, CreateSkippedItem());
-
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items.Insert(0, CreateSkippedItem());
-
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(70, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(140, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (object[] data in StatusStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in StatusStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmptyAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfLastItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        statusStrip.Items.Add(CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        statusStrip.Items.Add(CreateSkippedItem());
-        statusStrip.Items.Add(CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkippedAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        statusStrip.Items.Add(CreateSkippedItem());
-        statusStrip.Items.Add(CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items.Insert(0, CreateSkippedItem());
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.Items.Add(CreateSkippedItem());
-        statusStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items.Insert(0, CreateSkippedItem());
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.Items.Add(CreateSkippedItem());
-        statusStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        statusStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfOverflow_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow: true, itemCount: 3);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(70, 30);
-        Size horizontalOverflowGripSize = new(80, 30);
-        Size verticalOverflowSize = new(80, 55);
-        Size verticalOverflowGripSize = new(80, 65);
-        Size bothOverflowSize = new(70, 25);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData()
-    {
-        Size horizontalOverflowSize = new(70, 30);
-        Size horizontalOverflowGripSize = new(80, 30);
-        Size verticalOverflowSize = new(30, 55);
-        Size verticalOverflowGripSize = new(30, 65);
-        Size bothOverflowSize = new(70, 30);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow: false, itemCount: 2);
-
-        statusStrip.Items.Insert(1, CreateSkippedItem());
-
-        statusStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(70, 30);
-        Size horizontalOverflowGripSize = new(80, 30);
-        Size verticalOverflowSize = new(60, 60);
-        Size verticalOverflowGripSize = new(70, 70);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(115, 60);
-        Size verticalOverflowSize = new(70, 60);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, verticalOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData))]
-    public void StatusStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using StatusStrip statusStrip = CreateStatusStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        statusStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = statusStrip.AccessibilityObject;
-        AccessibleObject expected = statusStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-    }
-
-    private StatusStrip CreateStatusStrip(
-       ToolStripGripStyle? gripStyle = null,
-       ToolStripLayoutStyle? layoutStyle = null,
-       DockStyle? dock = null,
-       Size? size = null,
-       bool? canOverflow = null,
-       int itemCount = 0,
-       bool createControl = true
-    )
-    {
-        StatusStrip statusStrip = new();
-
-        if (layoutStyle is not null)
-        {
-            statusStrip.LayoutStyle = layoutStyle.Value;
-        }
-
-        if (gripStyle is not null)
-        {
-            statusStrip.GripStyle = gripStyle.Value;
-        }
-
-        if (dock is not null)
-        {
-            statusStrip.Dock = dock.Value;
-        }
-
-        if (size is not null)
-        {
-            statusStrip.AutoSize = false;
-            statusStrip.Size = size.Value;
-        }
-
-        if (canOverflow is not null)
-        {
-            statusStrip.CanOverflow = canOverflow.Value;
-        }
-
-        for (int i = 0; i < itemCount; i++)
-        {
-            statusStrip.Items.Add(CreateStatusStripItem());
-        }
-
-        statusStrip.PerformLayout();
-
-        if (createControl)
-        {
-            statusStrip.CreateControl();
-        }
-
-        return statusStrip;
-
-        ToolStripItem CreateStatusStripItem()
-        {
-            return new ToolStripStatusLabel()
-            {
-                AutoSize = false,
-                Size = new Size(50, 25)
-            };
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.Rendering.cs
deleted file mode 100644
index a172313ec90..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.Rendering.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class StatusStripTests
-{
-    [WinFormsFact]
-    public void StatusStrip_RendersBorderCorrectly()
-    {
-        using Form form = new Form();
-        using StatusStrip statusStrip = new StatusStrip
-        {
-            BackColor = Color.Blue,
-            SizingGrip = false,
-            Renderer = new ToolStripProfessionalRenderer(new CustomColorTable()),
-            Size = new Size(200, 38)
-        };
-        form.Controls.Add(statusStrip);
-
-        // Force the handle creation
-        Assert.NotEqual(IntPtr.Zero, form.Handle);
-        Assert.NotEqual(IntPtr.Zero, statusStrip.Handle);
-
-        // Create an Enhance Metafile into which we will render the control
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        // Render the control
-        statusStrip.PrintToMetafile(emf);
-
-        Rectangle bounds = statusStrip.Bounds;
-        Rectangle bitBltBounds = new Rectangle(bounds.X, 0, bounds.Width - 1, bounds.Height - 1);
-        Rectangle polylineBounds = new Rectangle(bounds.X, 0, bounds.Width - 1, 15);
-
-        // This is the default pen style GDI+ renders polylines with
-        PEN_STYLE penStyle = PEN_STYLE.PS_SOLID | PEN_STYLE.PS_JOIN_ROUND | PEN_STYLE.PS_COSMETIC |
-            PEN_STYLE.PS_ENDCAP_FLAT | PEN_STYLE.PS_JOIN_MITER | PEN_STYLE.PS_GEOMETRIC;
-
-        emf.Validate(
-           state,
-           Validate.BitBltValidator(bitBltBounds, State.BrushColor(Color.Blue)),
-           Validate.Polyline16(polylineBounds, null, State.Pen(16, Color.Green, penStyle)));
-
-        var details = emf.RecordsToString();
-    }
-
-    private sealed class CustomColorTable : ProfessionalColorTable
-    {
-        public override Color StatusStripBorder => Color.Green;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.cs
deleted file mode 100644
index d9a5bc4c8a1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/StatusStripTests.cs
+++ /dev/null
@@ -1,1366 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class StatusStripTests
-{
-    [WinFormsFact]
-    public void StatusStrip_Ctor_Default()
-    {
-        using var control = new SubStatusStrip();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.AllowMerge);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(22, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 22), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanOverflow);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.False(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 22), control.ClientRectangle);
-        Assert.Equal(new Size(200, 22), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(DockStyle.Bottom, control.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.AboveRight, control.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(new Padding(1, 0, 14, 0), control.DefaultPadding);
-        Assert.Equal(new Size(200, 22), control.DefaultSize);
-        Assert.False(control.DefaultShowItemToolTips);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayedItems);
-        Assert.Same(control.DisplayedItems, control.DisplayedItems);
-        Assert.Equal(new Rectangle(1, 0, 185, 22), control.DisplayRectangle);
-        Assert.Equal(DockStyle.Bottom, 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(1, control.DockPadding.Left);
-        Assert.Equal(14, control.DockPadding.Right);
-        Assert.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Hidden, control.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Horizontal, control.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.GripMargin);
-        Assert.Equal(Rectangle.Empty, control.GripRectangle);
-        Assert.False(control.HasChildren);
-        Assert.Equal(22, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Null(control.ImageList);
-        Assert.Equal(new Size(16, 16), control.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsDropDown);
-        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.IsType<TableLayoutSettings>(control.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.Table, control.LayoutStyle);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(new Size(185, 22), control.MaxItemSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.NotNull(control.OverflowButton);
-        Assert.Same(control.OverflowButton, control.OverflowButton);
-        Assert.Same(control, control.OverflowButton.GetCurrentParent());
-        Assert.Equal(new Padding(1, 0, 14, 0), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.False(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 22), control.Size);
-        Assert.True(control.SizingGrip);
-        Assert.Equal(new Rectangle(188, 0, 12, 22), control.SizeGripBounds);
-        Assert.True(control.Stretch);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, control.TextDirection);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.True(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubStatusStrip();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(22, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void StatusStrip_CanOverflow_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new StatusStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> DefaultPadding_Get_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, RightToLeft.Yes, new Padding(14, 0, 1, 0) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, RightToLeft.No, new Padding(1, 0, 14, 0) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, RightToLeft.Inherit, new Padding(1, 0, 14, 0) };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, RightToLeft.Yes, new Padding(14, 0, 1, 0) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, RightToLeft.No, new Padding(1, 0, 14, 0) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, RightToLeft.Inherit, new Padding(1, 0, 14, 0) };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, RightToLeft.Yes, new Padding(14, 0, 1, 0) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, RightToLeft.No, new Padding(1, 0, 14, 0) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, RightToLeft.Inherit, new Padding(1, 0, 14, 0) };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, RightToLeft.Yes, new Padding(14, 0, 1, 0) };
-        yield return new object[] { ToolStripLayoutStyle.Table, RightToLeft.No, new Padding(1, 0, 14, 0) };
-        yield return new object[] { ToolStripLayoutStyle.Table, RightToLeft.Inherit, new Padding(1, 0, 14, 0) };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, RightToLeft.Yes, new Padding(1, 3, 1, 22) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, RightToLeft.No, new Padding(1, 3, 1, 22) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, RightToLeft.Inherit, new Padding(1, 3, 1, 22) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultPadding_Get_TestData))]
-    public void StatusStrip_DefaultPadding_Get_ReturnsExpected(ToolStripLayoutStyle layoutStyle, RightToLeft rightToLeft, Padding expected)
-    {
-        using var control = new SubStatusStrip
-        {
-            LayoutStyle = layoutStyle,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultPadding);
-    }
-
-    public static IEnumerable<object[]> Dock_Set_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, 0, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Fill, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Fill, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, 1, Orientation.Vertical, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_Set_TestData))]
-    public void StatusStrip_Dock_Set_GetReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle value, int expectedLayoutCallCount, Orientation expectedOrientation, int expectedLayoutStyleChangedCallCount)
-    {
-        using var control = new StatusStrip
-        {
-            LayoutStyle = layoutStyle
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "Dock")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                layoutCallCount++;
-            }
-        };
-        int layoutStyleChangedCallCount = 0;
-        control.LayoutStyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutStyleChangedCallCount++;
-        };
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 0)]
-    [InlineData(ToolStripGripStyle.Visible, 1)]
-    public void StatusStrip_GripStyle_Set_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new StatusStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> LayoutStyle_Set_TestData()
-    {
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.None, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-        }
-
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.Right, DockStyle.Left })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_Set_TestData))]
-    public void StatusStrip_LayoutStyle_Set_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var control = new StatusStrip
-        {
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Padding_Set_TestData()
-    {
-        yield return new object[] { new Padding(), new Padding(), 1, 1 };
-        yield return new object[] { new Padding(1, 0, 14, 0), new Padding(1, 0, 14, 0), 0, 0 };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 1 };
-        yield return new object[] { new Padding(1), new Padding(1), 1, 1 };
-        yield return new object[] { new Padding(-1, -2, -3, -4), Padding.Empty, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Set_TestData))]
-    public void StatusStrip_Padding_Set_GetReturnsExpected(Padding value, Padding expected, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new StatusStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Padding", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new StatusStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer), 3)]
-    [InlineData(ToolStripRenderMode.ManagerRenderMode, typeof(ToolStripProfessionalRenderer), 2)]
-    public void StatusStrip_RenderMode_Set_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType, int expectedSameRendererChangedCallCount)
-    {
-        using var control = new StatusStrip();
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        // Set same.
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-
-        // Set different.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(expectedSameRendererChangedCallCount, rendererChangedCallCount);
-
-        // Set System.
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(expectedSameRendererChangedCallCount + 1, rendererChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer), 2)]
-    [InlineData(ToolStripRenderMode.ManagerRenderMode, typeof(ToolStripProfessionalRenderer), 1)]
-    public void StatusStrip_RenderMode_SetWithCustomRenderer_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType, int expectedSameRendererChangedCallCount)
-    {
-        using var control = new StatusStrip
-        {
-            Renderer = new SubToolStripRenderer()
-        };
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(expectedSameRendererChangedCallCount, rendererChangedCallCount);
-
-        // Set System.
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(expectedSameRendererChangedCallCount + 1, rendererChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_RenderMode_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(StatusStrip))[nameof(ToolStrip.RenderMode)];
-        using var control = new StatusStrip();
-        Assert.False(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, control.RenderMode);
-        Assert.True(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-
-        control.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_RenderMode_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(StatusStrip))[nameof(ToolStrip.RenderMode)];
-        using var control = new StatusStrip();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, control.RenderMode);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripRenderMode>]
-    public void StatusStrip_RenderMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripRenderMode value)
-    {
-        using var control = new StatusStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RenderMode = value);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_RenderMode_SetCustomThrowsInvalidEnumArgumentException()
-    {
-        using var control = new StatusStrip();
-        Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);
-    }
-
-    public static IEnumerable<object[]> SizeGripBounds_Get_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { true, layoutStyle, RightToLeft.Yes, new Rectangle(0, 0, 12, 22) };
-            yield return new object[] { true, layoutStyle, RightToLeft.No, new Rectangle(188, 0, 12, 22) };
-            yield return new object[] { true, layoutStyle, RightToLeft.Inherit, new Rectangle(188, 0, 12, 22) };
-            yield return new object[] { false, layoutStyle, RightToLeft.Yes, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.No, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.Inherit, Rectangle.Empty };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeGripBounds_Get_TestData))]
-    public void StatusStrip_SizeGripBounds_Get_ReturnsExpected(bool sizingGrip, ToolStripLayoutStyle layoutStyle, RightToLeft rightToLeft, Rectangle expected)
-    {
-        using var control = new SubStatusStrip
-        {
-            SizingGrip = sizingGrip,
-            LayoutStyle = layoutStyle,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.SizeGripBounds);
-    }
-
-    public static IEnumerable<object[]> SizeGripBounds_GetLargeSize_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { true, layoutStyle, RightToLeft.Yes, new Rectangle(0, 10, 12, 22) };
-            yield return new object[] { true, layoutStyle, RightToLeft.No, new Rectangle(198, 10, 12, 22) };
-            yield return new object[] { true, layoutStyle, RightToLeft.Inherit, new Rectangle(198, 10, 12, 22) };
-            yield return new object[] { false, layoutStyle, RightToLeft.Yes, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.No, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.Inherit, Rectangle.Empty };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeGripBounds_GetLargeSize_TestData))]
-    public void StatusStrip_SizeGripBounds_GetLargeSize_ReturnsExpected(bool sizingGrip, ToolStripLayoutStyle layoutStyle, RightToLeft rightToLeft, Rectangle expected)
-    {
-        using var control = new SubStatusStrip
-        {
-            SizingGrip = sizingGrip,
-            LayoutStyle = layoutStyle,
-            RightToLeft = rightToLeft,
-            Size = new Size(210, 32)
-        };
-        Assert.Equal(expected, control.SizeGripBounds);
-    }
-
-    public static IEnumerable<object[]> SizeGripBounds_GetSmallSize_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { true, layoutStyle, RightToLeft.Yes, new Rectangle(0, 0, 12, 12) };
-            yield return new object[] { true, layoutStyle, RightToLeft.No, new Rectangle(178, 0, 12, 12) };
-            yield return new object[] { true, layoutStyle, RightToLeft.Inherit, new Rectangle(178, 0, 12, 12) };
-            yield return new object[] { false, layoutStyle, RightToLeft.Yes, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.No, Rectangle.Empty };
-            yield return new object[] { false, layoutStyle, RightToLeft.Inherit, Rectangle.Empty };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizeGripBounds_GetSmallSize_TestData))]
-    public void StatusStrip_SizeGripBounds_GetSmallSize_ReturnsExpected(bool sizingGrip, ToolStripLayoutStyle layoutStyle, RightToLeft rightToLeft, Rectangle expected)
-    {
-        using var control = new SubStatusStrip
-        {
-            SizingGrip = sizingGrip,
-            LayoutStyle = layoutStyle,
-            RightToLeft = rightToLeft,
-            Size = new Size(190, 12)
-        };
-        Assert.Equal(expected, control.SizeGripBounds);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void StatusStrip_SizingGrip_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new StatusStrip
-        {
-            SizingGrip = value
-        };
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SizingGrip = value;
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SizingGrip = !value;
-        Assert.Equal(!value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SizingGrip_SetRightToLeft_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, true, 1, 0 };
-        yield return new object[] { RightToLeft.No, true, 0, 0 };
-        yield return new object[] { RightToLeft.Inherit, true, 0, 0 };
-
-        yield return new object[] { RightToLeft.Yes, false, 0, 1 };
-        yield return new object[] { RightToLeft.No, false, 0, 0 };
-        yield return new object[] { RightToLeft.Inherit, false, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SizingGrip_SetRightToLeft_TestData))]
-    public void StatusStrip_SizingGrip_SetRightToLeft_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedChildrenCallCount1, int expectedChildrenCallCount2)
-    {
-        using var control = new StatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = value
-        };
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Equal(expectedChildrenCallCount1, control.Controls.Count);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SizingGrip = value;
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Equal(expectedChildrenCallCount1, control.Controls.Count);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SizingGrip = !value;
-        Assert.Equal(!value, control.SizingGrip);
-        Assert.Equal(expectedChildrenCallCount2, control.Controls.Count);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StatusStrip_SizingGrip_SetRightToLeftNonReadOnlyControls_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true };
-            yield return new object[] { rightToLeft, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStrip_SizingGrip_SetRightToLeftNonReadOnlyControls_TestData))]
-    public void StatusStrip_SizingGrip_SetRightToLeftNonReadOnlyControls_GetReturnsExpected(RightToLeft rightToLeft, bool value)
-    {
-        using var control = new NonReadOnlyControlsStatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = value
-        };
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SizingGrip = value;
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.SizingGrip = !value;
-        Assert.Equal(!value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void StatusStrip_SizingGrip_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new StatusStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SizingGrip = value;
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SizingGrip = value;
-        Assert.Equal(value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.SizingGrip = !value;
-        Assert.Equal(!value, control.SizingGrip);
-        Assert.Empty(control.Controls);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void StatusStrip_ShowItemToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new StatusStrip
-        {
-            ShowItemToolTips = value
-        };
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowItemToolTips = !value;
-        Assert.Equal(!value, control.ShowItemToolTips);
-        Assert.Equal(!value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubStatusStrip();
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.StatusBar, instance.Role);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Button_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-        yield return new object[] { "-", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Button_TestData))]
-    public void StatusStrip_CreateDefaultItem_Invoke_Success(string text, Image image, EventHandler onClick)
-    {
-        using var control = new SubStatusStrip();
-        ToolStripStatusLabel button = Assert.IsType<ToolStripStatusLabel>(control.CreateDefaultItem(text, image, onClick));
-        Assert.Equal(text, button.Text);
-        Assert.Same(image, button.Image);
-    }
-
-    public static IEnumerable<object[]> Dispose_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true };
-            yield return new object[] { rightToLeft, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dispose_TestData))]
-    public void StatusStrip_Dispose_Invoke_Success(RightToLeft rightToLeft, bool sizingGrip)
-    {
-        using var control = new StatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = sizingGrip
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dispose_TestData))]
-    public void StatusStrip_Dispose_InvokeDisposing_Success(RightToLeft rightToLeft, bool sizingGrip)
-    {
-        using var control = new SubStatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = sizingGrip
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    public static IEnumerable<object[]> Dispose_NotDisposing_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, true, 1 };
-        yield return new object[] { RightToLeft.No, true, 0 };
-        yield return new object[] { RightToLeft.Inherit, true, 0 };
-
-        yield return new object[] { RightToLeft.Yes, false, 0 };
-        yield return new object[] { RightToLeft.No, false, 0 };
-        yield return new object[] { RightToLeft.Inherit, false, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dispose_NotDisposing_TestData))]
-    public void StatusStrip_Dispose_InvokeNotDisposing_Success(RightToLeft rightToLeft, bool sizingGrip, int expectedChildrenCallCount1)
-    {
-        using var control = new SubStatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = sizingGrip
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Equal(expectedChildrenCallCount1, control.Controls.Count);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Equal(expectedChildrenCallCount1, control.Controls.Count);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("text")]
-    [InlineData("-")]
-    public void StatusStrip_CreateDefaultItem_PerformClick_Success(string text)
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var control = new SubStatusStrip();
-        ToolStripItem button = Assert.IsAssignableFrom<ToolStripItem>(control.CreateDefaultItem(text, null, onClick));
-        button.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubStatusStrip();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubStatusStrip.ScrollStateAutoScrolling, false)]
-    [InlineData(SubStatusStrip.ScrollStateFullDrag, false)]
-    [InlineData(SubStatusStrip.ScrollStateHScrollVisible, false)]
-    [InlineData(SubStatusStrip.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubStatusStrip.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void StatusStrip_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubStatusStrip();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void StatusStrip_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubStatusStrip();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            foreach (DockStyle dock in Enum.GetValues(typeof(DockStyle)))
-            {
-                yield return new object[] { layoutStyle, dock, new LayoutEventArgs(null, null) };
-                yield return new object[] { layoutStyle, dock, new LayoutEventArgs(new Control(), "AffectedProperty") };
-                yield return new object[] { layoutStyle, dock, new LayoutEventArgs(new SubToolStripItem(), "AffectedProperty") };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void Control_OnLayout_Invoke_CallsLayout(ToolStripLayoutStyle layoutStyle, DockStyle dock, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubStatusStrip
-        {
-            LayoutStyle = layoutStyle,
-            Dock = dock
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void Control_OnLayout_Invoke_CreatesSizingGrip()
-    {
-        var eventArgs = new LayoutEventArgs(null, null);
-
-        using var control = new SubStatusStrip
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e == eventArgs)
-            {
-                layoutCallCount++;
-            }
-        };
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, layoutCallCount);
-        Control grip = Assert.IsAssignableFrom<Control>(Assert.Single(control.Controls));
-        Assert.Equal(control.SizeGripBounds, grip.Bounds);
-        Assert.Equal(Color.Transparent, grip.BackColor);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_OnLayout_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubStatusStrip();
-        Assert.Throws<NullReferenceException>(() => control.OnLayout(null));
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            yield return new object[] { rightToLeft, true };
-            yield return new object[] { rightToLeft, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void StatusStrip_OnPaintBackground_Invoke_Success(RightToLeft rightToLeft, bool sizingGrip)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubStatusStrip
-        {
-            RightToLeft = rightToLeft,
-            SizingGrip = sizingGrip
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void StatusStrip_OnPaintBackground_NullE_ThrowsArgumentNullException()
-    {
-        using var control = new SubStatusStrip();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-    }
-
-    private class NonReadOnlyControlsStatusStrip : StatusStrip
-    {
-        protected override ControlCollection CreateControlsInstance() => new(this);
-    }
-
-    private class SubStatusStrip : StatusStrip
-    {
-        public new const int ScrollStateAutoScrolling = StatusStrip.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = StatusStrip.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = StatusStrip.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = StatusStrip.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = StatusStrip.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new DockStyle DefaultDock => base.DefaultDock;
-
-        public new Padding DefaultGripMargin => base.DefaultGripMargin;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DefaultShowItemToolTips => base.DefaultShowItemToolTips;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new Size MaxItemSize => base.MaxItemSize;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ToolStripItem CreateDefaultItem(string text, Image image, EventHandler onClick) => base.CreateDefaultItem(text, image, onClick);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new void OnLayout(LayoutEventArgs levent) => base.OnLayout(levent);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void OnSpringTableLayoutCore() => base.OnSpringTableLayoutCore();
-
-        public new void SetDisplayedItems() => base.SetDisplayedItems();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SystemInformationTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SystemInformationTests.cs
deleted file mode 100644
index cdd286ddb2a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/SystemInformationTests.cs
+++ /dev/null
@@ -1,864 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class SystemInformationTests
-{
-    private const int LogicalDpi = 96;
-
-    [Fact]
-    public void SystemInformation_ActiveWindowTrackingDelay_Get_ReturnsExpected()
-    {
-        int delay = SystemInformation.ActiveWindowTrackingDelay;
-        Assert.True(delay >= 0);
-        Assert.Equal(delay, SystemInformation.ActiveWindowTrackingDelay);
-    }
-
-    [Fact]
-    public void SystemInformation_ArrangeDirection_Get_ReturnsExpected()
-    {
-        ArrangeDirection direction = SystemInformation.ArrangeDirection;
-        Assert.Equal((ArrangeDirection)0, direction & ~(ArrangeDirection.Up | ArrangeDirection.Down | ArrangeDirection.Left | ArrangeDirection.Right));
-        Assert.Equal(direction, SystemInformation.ArrangeDirection);
-    }
-
-    [Fact]
-    public void SystemInformation_ArrangeStartingPosition_Get_ReturnsExpected()
-    {
-        ArrangeStartingPosition position = SystemInformation.ArrangeStartingPosition;
-        Assert.Equal((ArrangeStartingPosition)0, position & ~(ArrangeStartingPosition.BottomLeft | ArrangeStartingPosition.BottomRight | ArrangeStartingPosition.Hide | ArrangeStartingPosition.TopLeft | ArrangeStartingPosition.TopRight));
-        Assert.Equal(position, SystemInformation.ArrangeStartingPosition);
-    }
-
-    [Fact]
-    public void SystemInformation_BootMode_Get_ReturnsExpected()
-    {
-        BootMode bootMode = SystemInformation.BootMode;
-        Assert.True(Enum.IsDefined(typeof(BootMode), bootMode));
-        Assert.Equal(bootMode, SystemInformation.BootMode);
-    }
-
-    [Fact]
-    public void SystemInformation_Border3DSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.Border3DSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.Border3DSize);
-    }
-
-    [Fact]
-    public void SystemInformation_BorderMultiplierFactor_Get_ReturnsExpected()
-    {
-        int factor = SystemInformation.BorderMultiplierFactor;
-        Assert.True(factor >= 0);
-        Assert.Equal(factor, SystemInformation.BorderMultiplierFactor);
-    }
-
-    [Fact]
-    public void SystemInformation_BorderSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.BorderSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.BorderSize);
-    }
-
-    [Fact]
-    public void SystemInformation_CaptionButtonSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.CaptionButtonSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.CaptionButtonSize);
-    }
-
-    [Fact]
-    public void SystemInformation_CaptionHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.CaptionHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.CaptionHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_CaretBlinkTime_Get_ReturnsExpected()
-    {
-        int blinkTime = SystemInformation.CaretBlinkTime;
-        Assert.True(blinkTime >= 0);
-        Assert.Equal(blinkTime, SystemInformation.CaretBlinkTime);
-    }
-
-    [Fact]
-    public void SystemInformation_CaretWidth_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.CaretWidth;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.CaretWidth);
-    }
-
-    [Fact]
-    public void SystemInformation_ComputerName_Get_ReturnsExpected()
-    {
-        string name = SystemInformation.ComputerName;
-        Assert.InRange(name.Length, 1, 256);
-        Assert.Equal(name, name.Trim('\0'));
-        Assert.Equal(name, SystemInformation.ComputerName);
-    }
-
-    [Fact]
-    public void SystemInformation_CursorSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.CursorSize;
-        Assert.Contains(size, new Size[] { new Size(32, 32), new Size(48, 48), new Size(64, 64) });
-        Assert.Equal(size, SystemInformation.CursorSize);
-    }
-
-    [Fact]
-    public void SystemInformation_DbcsEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.DbcsEnabled, SystemInformation.DbcsEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_DebugOS_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.DbcsEnabled, SystemInformation.DebugOS);
-    }
-
-    [Fact]
-    public void SystemInformation_DoubleClickSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.DoubleClickSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.DoubleClickSize);
-    }
-
-    [Fact]
-    public void SystemInformation_DoubleClickTime_Get_ReturnsExpected()
-    {
-        int time = SystemInformation.DoubleClickTime;
-        Assert.True(time > 0);
-        Assert.Equal(time, SystemInformation.DoubleClickTime);
-    }
-
-    [Fact]
-    public void SystemInformation_DragFullWindows_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.DragFullWindows, SystemInformation.DragFullWindows);
-    }
-
-    [Fact]
-    public void SystemInformation_DragSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.DragSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.DragSize);
-    }
-
-    [Fact]
-    public void SystemInformation_FixedFrameBorderSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.FixedFrameBorderSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.FixedFrameBorderSize);
-    }
-
-    [Fact]
-    public void SystemInformation_FontSmoothingContrast_Get_ReturnsExpected()
-    {
-        int contrast = SystemInformation.FontSmoothingContrast;
-        Assert.True(contrast >= 0);
-        Assert.Equal(contrast, SystemInformation.FontSmoothingContrast);
-    }
-
-    [Fact]
-    public void SystemInformation_FontSmoothingType_Get_ReturnsExpected()
-    {
-        int contrast = SystemInformation.FontSmoothingType;
-        Assert.True(contrast > 0);
-        Assert.Equal(contrast, SystemInformation.FontSmoothingType);
-    }
-
-    [Fact]
-    public void SystemInformation_FrameBorderSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.FrameBorderSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.FrameBorderSize);
-    }
-
-    [Fact]
-    public void SystemInformation_HighContrast_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.HighContrast, SystemInformation.HighContrast);
-    }
-
-    [Fact]
-    public void SystemInformation_HorizontalFocusThickness_Get_ReturnsExpected()
-    {
-        int thickness = SystemInformation.HorizontalFocusThickness;
-        Assert.True(thickness >= 0);
-        Assert.Equal(thickness, SystemInformation.HorizontalFocusThickness);
-    }
-
-    [Fact]
-    public void SystemInformation_HorizontalResizeBorderThickness_Get_ReturnsExpected()
-    {
-        int thickness = SystemInformation.HorizontalResizeBorderThickness;
-        Assert.True(thickness >= 0);
-        Assert.Equal(thickness, SystemInformation.HorizontalResizeBorderThickness);
-    }
-
-    [Fact]
-    public void SystemInformation_HorizontalScrollBarArrowWidth_Get_ReturnsExpected()
-    {
-        int width = SystemInformation.HorizontalScrollBarArrowWidth;
-        Assert.True(width >= 0);
-        Assert.Equal(width, SystemInformation.GetHorizontalScrollBarArrowWidthForDpi(LogicalDpi));
-        Assert.Equal(width, SystemInformation.HorizontalScrollBarArrowWidth);
-    }
-
-    [Fact]
-    public void SystemInformation_HorizontalScrollBarHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.HorizontalScrollBarHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.HorizontalScrollBarHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_HorizontalScrollBarThumbWidth_Get_ReturnsExpected()
-    {
-        int width = SystemInformation.HorizontalScrollBarThumbWidth;
-        Assert.True(width >= 0);
-        Assert.Equal(width, SystemInformation.HorizontalScrollBarThumbWidth);
-    }
-
-    [Fact]
-    public void SystemInformation_IconHorizontalSpacing_Get_ReturnsExpected()
-    {
-        int spacing = SystemInformation.IconHorizontalSpacing;
-        Assert.True(spacing >= 0);
-        Assert.Equal(spacing, SystemInformation.IconHorizontalSpacing);
-    }
-
-    [Fact]
-    public void SystemInformation_IconSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.IconSize;
-        Assert.True(size.Width >= 32);
-        Assert.True(size.Height >= 32);
-        Assert.Equal(size, SystemInformation.IconSize);
-    }
-
-    [Fact]
-    public void SystemInformation_IconSpacingSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.IconSpacingSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.IconSpacingSize);
-    }
-
-    [Fact]
-    public void SystemInformation_IconVerticalSpacing_Get_ReturnsExpected()
-    {
-        int spacing = SystemInformation.IconVerticalSpacing;
-        Assert.True(spacing >= 0);
-        Assert.Equal(spacing, SystemInformation.IconVerticalSpacing);
-    }
-
-    [Fact]
-    public void SystemInformation_IsActiveWindowTrackingEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsActiveWindowTrackingEnabled, SystemInformation.IsActiveWindowTrackingEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsComboBoxAnimationEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsComboBoxAnimationEnabled, SystemInformation.IsComboBoxAnimationEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsDropShadowEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsDropShadowEnabled, SystemInformation.IsDropShadowEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsFlatMenuEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsFlatMenuEnabled, SystemInformation.IsFlatMenuEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsFontSmoothingEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsFontSmoothingEnabled, SystemInformation.IsFontSmoothingEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsHotTrackingEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsHotTrackingEnabled, SystemInformation.IsHotTrackingEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsIconTitleWrappingEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsIconTitleWrappingEnabled, SystemInformation.IsIconTitleWrappingEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsKeyboardPreferred_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsKeyboardPreferred, SystemInformation.IsKeyboardPreferred);
-    }
-
-    [Fact]
-    public void SystemInformation_IsListBoxSmoothScrollingEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsListBoxSmoothScrollingEnabled, SystemInformation.IsListBoxSmoothScrollingEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsMenuAnimationEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsMenuAnimationEnabled, SystemInformation.IsMenuAnimationEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsMenuFadeEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsMenuFadeEnabled, SystemInformation.IsMenuFadeEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsMinimizeRestoreAnimationEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsMinimizeRestoreAnimationEnabled, SystemInformation.IsMinimizeRestoreAnimationEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsSelectionFadeEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsSelectionFadeEnabled, SystemInformation.IsSelectionFadeEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsSnapToDefaultEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsSnapToDefaultEnabled, SystemInformation.IsSnapToDefaultEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsTitleBarGradientEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsTitleBarGradientEnabled, SystemInformation.IsTitleBarGradientEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_IsToolTipAnimationEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.IsToolTipAnimationEnabled, SystemInformation.IsToolTipAnimationEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_KanjiWindowHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.KanjiWindowHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.KanjiWindowHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_KeyboardDelay_Get_ReturnsExpected()
-    {
-        int delay = SystemInformation.KeyboardDelay;
-        Assert.True(delay >= 0);
-        Assert.Equal(delay, SystemInformation.KeyboardDelay);
-    }
-
-    [Fact]
-    public void SystemInformation_KeyboardSpeed_Get_ReturnsExpected()
-    {
-        int speed = SystemInformation.KeyboardSpeed;
-        Assert.True(speed >= 0);
-        Assert.Equal(speed, SystemInformation.KeyboardSpeed);
-    }
-
-    [Fact]
-    public void SystemInformation_MaxWindowTrackSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MaxWindowTrackSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MaxWindowTrackSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuAccessKeysUnderlined_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, SystemInformation.MenuAccessKeysUnderlined);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuBarButtonSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MenuBarButtonSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MenuBarButtonSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuButtonSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MenuButtonSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MenuButtonSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuCheckSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MenuCheckSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MenuCheckSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuFont_Get_ReturnsExpected()
-    {
-        Font font = SystemInformation.MenuFont;
-        Assert.NotNull(font);
-        Assert.Equal(font, SystemInformation.MenuFont);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.MenuHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.MenuHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_MenuShowDelay_Get_ReturnsExpected()
-    {
-        int delay = SystemInformation.MenuShowDelay;
-        Assert.True(delay >= 0);
-        Assert.Equal(delay, SystemInformation.MenuShowDelay);
-    }
-
-    [Fact]
-    public void SystemInformation_MidEastEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MidEastEnabled, SystemInformation.MidEastEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_MinimizedWindowSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MinimizedWindowSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MinimizedWindowSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MinimizedWindowSpacingSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MinimizedWindowSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MinimizedWindowSpacingSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MinimumWindowSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MinimumWindowSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.MinimumWindowSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MinWindowTrackSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MinWindowTrackSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.MinWindowTrackSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MonitorCount_Get_ReturnsExpected()
-    {
-        int count = SystemInformation.MonitorCount;
-        Assert.True(count > 0);
-        Assert.Equal(count, Screen.AllScreens.Length);
-        Assert.Equal(count, SystemInformation.MonitorCount);
-    }
-
-    [Fact]
-    public void SystemInformation_MonitorsSameDisplayFormat_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MonitorsSameDisplayFormat, SystemInformation.MonitorsSameDisplayFormat);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseButtons_Get_ReturnsExpected()
-    {
-        int count = SystemInformation.MouseButtons;
-        Assert.True(count >= 0);
-        Assert.Equal(count, SystemInformation.MouseButtons);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseButtonsSwapped_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MouseButtonsSwapped, SystemInformation.MouseButtonsSwapped);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseHoverSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.MouseHoverSize;
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-        Assert.Equal(size, SystemInformation.MouseHoverSize);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseHoverTime_Get_ReturnsExpected()
-    {
-        int count = SystemInformation.MouseHoverTime;
-        Assert.True(count > 0);
-        Assert.Equal(count, SystemInformation.MouseHoverTime);
-    }
-
-    [Fact]
-    public void SystemInformation_MousePresent_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MousePresent, SystemInformation.MousePresent);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseSpeed_Get_ReturnsExpected()
-    {
-        int count = SystemInformation.MouseSpeed;
-        Assert.True(count > 0);
-        Assert.Equal(count, SystemInformation.MouseSpeed);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseWheelPresent_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.MouseWheelPresent, SystemInformation.MouseWheelPresent);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseWheelScrollDelta_Get_ReturnsExpected()
-    {
-        int delta = SystemInformation.MouseWheelScrollDelta;
-        Assert.Equal(120, delta);
-        Assert.Equal(delta, SystemInformation.MouseWheelScrollDelta);
-    }
-
-    [Fact]
-    public void SystemInformation_MouseWheelScrollLines_Get_ReturnsExpected()
-    {
-        int lines = SystemInformation.MouseWheelScrollLines;
-        Assert.True(lines > 0);
-        Assert.Equal(lines, SystemInformation.MouseWheelScrollLines);
-    }
-
-    [Fact]
-    public void SystemInformation_NativeMouseWheelSupport_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.NativeMouseWheelSupport, SystemInformation.NativeMouseWheelSupport);
-    }
-
-    [Fact]
-    public void SystemInformation_Network_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.Network, SystemInformation.Network);
-    }
-
-    [Fact]
-    public void SystemInformation_PenWindows_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.PenWindows, SystemInformation.PenWindows);
-    }
-
-    [Fact]
-    public void SystemInformation_PopupMenuAlignment_Get_ReturnsExpected()
-    {
-        LeftRightAlignment alignment = SystemInformation.PopupMenuAlignment;
-        Assert.True(Enum.IsDefined(typeof(LeftRightAlignment), alignment));
-        Assert.Equal(alignment, SystemInformation.PopupMenuAlignment);
-    }
-
-    [Fact]
-    public void SystemInformation_PowerStatus_Get_ReturnsExpected()
-    {
-        PowerStatus status = SystemInformation.PowerStatus;
-        Assert.NotNull(status);
-        Assert.Same(status, SystemInformation.PowerStatus);
-    }
-
-    [Fact]
-    public void SystemInformation_PrimaryMonitorMaximizedWindowSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.PrimaryMonitorMaximizedWindowSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.PrimaryMonitorMaximizedWindowSize);
-    }
-
-    [Fact]
-    public void SystemInformation_PrimaryMonitorSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.PrimaryMonitorSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.PrimaryMonitorSize);
-    }
-
-    [Fact]
-    public void SystemInformation_RightAlignedMenus_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.RightAlignedMenus, SystemInformation.RightAlignedMenus);
-    }
-
-    [Fact]
-    public void SystemInformation_ScreenOrientation_Get_ReturnsExpected()
-    {
-        ScreenOrientation orientation = SystemInformation.ScreenOrientation;
-        Assert.True(Enum.IsDefined(typeof(ScreenOrientation), orientation));
-        Assert.Equal(orientation, SystemInformation.ScreenOrientation);
-    }
-
-    [Fact]
-    public void SystemInformation_Secure_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.Secure, SystemInformation.Secure);
-    }
-
-    [Fact]
-    public void SystemInformation_ShowSounds_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.ShowSounds, SystemInformation.ShowSounds);
-    }
-
-    [Fact]
-    public void SystemInformation_SizingBorderWidth_Get_ReturnsExpected()
-    {
-        int width = SystemInformation.SizingBorderWidth;
-        Assert.True(width > 0);
-        Assert.Equal(width, SystemInformation.SizingBorderWidth);
-    }
-
-    [Fact]
-    public void SystemInformation_SmallCaptionButtonSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.SmallCaptionButtonSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.SmallCaptionButtonSize);
-    }
-
-    [Fact]
-    public void SystemInformation_SmallIconSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.SmallIconSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.SmallIconSize);
-    }
-
-    [Fact]
-    public void SystemInformation_TerminalServerSession_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.TerminalServerSession, SystemInformation.TerminalServerSession);
-    }
-
-    [Fact]
-    public void SystemInformation_ToolWindowCaptionButtonSize_Get_ReturnsExpected()
-    {
-        Size size = SystemInformation.ToolWindowCaptionButtonSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, SystemInformation.ToolWindowCaptionButtonSize);
-    }
-
-    [Fact]
-    public void SystemInformation_ToolWindowCaptionHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.ToolWindowCaptionHeight;
-        Assert.True(height > 0);
-        Assert.Equal(height, SystemInformation.ToolWindowCaptionHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_UIEffectsEnabled_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.UIEffectsEnabled, SystemInformation.UIEffectsEnabled);
-    }
-
-    [Fact]
-    public void SystemInformation_UserDomainName_Get_ReturnsExpected()
-    {
-        string domainName = SystemInformation.UserDomainName;
-        Assert.Equal(Environment.UserDomainName, domainName);
-        Assert.Equal(domainName, SystemInformation.UserDomainName);
-    }
-
-    [Fact]
-    public void SystemInformation_UserInteractive_Get_ReturnsExpected()
-    {
-        Assert.Equal(SystemInformation.UserInteractive, SystemInformation.UserInteractive);
-    }
-
-    [Fact]
-    public void SystemInformation_UserName_Get_ReturnsExpected()
-    {
-        string name = SystemInformation.UserName;
-        Assert.InRange(name.Length, 1, 256);
-        Assert.Equal(name, name.Trim('\0'));
-        Assert.Equal(name, SystemInformation.UserName);
-    }
-
-    [Fact]
-    public void SystemInformation_VerticalFocusThickness_Get_ReturnsExpected()
-    {
-        int thickness = SystemInformation.VerticalFocusThickness;
-        Assert.True(thickness >= 0);
-        Assert.Equal(thickness, SystemInformation.VerticalFocusThickness);
-    }
-
-    [Fact]
-    public void SystemInformation_VerticalResizeBorderThickness_Get_ReturnsExpected()
-    {
-        int thickness = SystemInformation.VerticalResizeBorderThickness;
-        Assert.True(thickness >= 0);
-        Assert.Equal(thickness, SystemInformation.VerticalResizeBorderThickness);
-    }
-
-    [Fact]
-    public void SystemInformation_VerticalScrollBarArrowHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.VerticalScrollBarArrowHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.VerticalScrollBarArrowHeightForDpi(LogicalDpi));
-        Assert.Equal(height, SystemInformation.VerticalScrollBarArrowHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_VerticalScrollBarThumbHeight_Get_ReturnsExpected()
-    {
-        int height = SystemInformation.VerticalScrollBarThumbHeight;
-        Assert.True(height >= 0);
-        Assert.Equal(height, SystemInformation.VerticalScrollBarThumbHeight);
-    }
-
-    [Fact]
-    public void SystemInformation_VerticalScrollBarWidth_Get_ReturnsExpected()
-    {
-        int width = SystemInformation.VerticalScrollBarWidth;
-        Assert.True(width >= 0);
-        Assert.Equal(width, SystemInformation.GetVerticalScrollBarWidthForDpi(LogicalDpi));
-        Assert.Equal(width, SystemInformation.VerticalScrollBarWidth);
-    }
-
-    [Fact]
-    public void SystemInformation_VirtualScreen_Get_ReturnsExpected()
-    {
-        Rectangle screen = SystemInformation.VirtualScreen;
-        Assert.True(screen.Width != 0);
-        Assert.True(screen.Height != 0);
-        Assert.Equal(screen, SystemInformation.VirtualScreen);
-    }
-
-    [Fact]
-    public void SystemInformation_WorkingArea_Get_ReturnsExpected()
-    {
-        Rectangle workingArea = SystemInformation.WorkingArea;
-        Assert.True(workingArea.X >= 0);
-        Assert.True(workingArea.Y >= 0);
-        Assert.True(workingArea.Width > 0);
-        Assert.True(workingArea.Height > 0);
-        Assert.Equal(workingArea, SystemInformation.WorkingArea);
-    }
-
-    public static IEnumerable<object[]> Dpi_TestData()
-    {
-        yield return new object[] { -10 };
-        yield return new object[] { 0 };
-        yield return new object[] { LogicalDpi };
-        yield return new object[] { 300 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_GetBorderSizeForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        Size size = SystemInformation.GetBorderSizeForDpi(dpi);
-        Assert.True(size.Width >= 0);
-        Assert.True(size.Height >= 0);
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_GetHorizontalScrollBarArrowWidthForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        int width = SystemInformation.GetHorizontalScrollBarArrowWidthForDpi(dpi);
-        Assert.True(width >= 0);
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_GetHorizontalScrollBarHeightForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        int height = SystemInformation.GetHorizontalScrollBarHeightForDpi(dpi);
-        Assert.True(height >= 0);
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_GetMenuFontForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        Font font = SystemInformation.GetMenuFontForDpi(dpi);
-        Assert.NotNull(font);
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_GetVerticalScrollBarWidthForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        int width = SystemInformation.GetVerticalScrollBarWidthForDpi(dpi);
-        Assert.True(width >= 0);
-    }
-
-    [Theory]
-    [MemberData(nameof(Dpi_TestData))]
-    public void SystemInformation_VerticalScrollBarArrowHeightForDpi_Invoke_ReturnsExpected(int dpi)
-    {
-        int height = SystemInformation.VerticalScrollBarArrowHeightForDpi(dpi);
-        Assert.True(height >= 0);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.ControlCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.ControlCollectionTests.cs
deleted file mode 100644
index 181bcef5c7b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.ControlCollectionTests.cs
+++ /dev/null
@@ -1,1569 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using static Interop;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControlControlCollectionTests
-{
-    [WinFormsFact]
-    public void TabControlControlCollection_Ctor_TabControl()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.ControlCollection(owner);
-        Assert.Empty(collection);
-        Assert.False(collection.IsReadOnly);
-        Assert.Same(owner, collection.Owner);
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new TabControl.ControlCollection(null));
-    }
-
-    public static IEnumerable<object[]> Add_TestData()
-    {
-        yield return new object[] { TabAppearance.Buttons };
-        yield return new object[] { TabAppearance.FlatButtons };
-        yield return new object[] { TabAppearance.Normal };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabControlControlCollection_Add_InvokeValueWithoutHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Add_WithHandle_TestData()
-    {
-        yield return new object[] { TabAppearance.Buttons, Size.Empty, 0 };
-        yield return new object[] { TabAppearance.FlatButtons, Size.Empty, 1 };
-        yield return new object[] { TabAppearance.Normal, Size.Empty, 0 };
-
-        yield return new object[] { TabAppearance.Buttons, new Size(100, 120), 0 };
-        yield return new object[] { TabAppearance.FlatButtons, new Size(100, 120), 1 };
-        yield return new object[] { TabAppearance.Normal, new Size(100, 120), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabControlControlCollection_Add_InvokeValueWithoutHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(13, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value1, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("Visible", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabControlControlCollection_Add_InvokeValueWithHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabControlControlCollection_Add_InvokeValueWithHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(13, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value1, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("Visible", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(3, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_OwnerWithSiteContainer_AddsToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.NotNull(value.Site);
-        Assert.Same(value, Assert.Single(container.Components));
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_OwnerWithSiteContainerValueHasSite_DoesNotAddToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        var mockValueSite = new Mock<ISite>(MockBehavior.Strict);
-        mockValueSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockValueSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage
-        {
-            Site = mockValueSite.Object
-        };
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.Same(mockValueSite.Object, value.Site);
-        Assert.Empty(container.Components);
-        mockSite.Verify(s => s.Container, Times.Never());
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_OwnerWithSiteNoContainer_DoesNotAddContainer()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.Null(value.Site);
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_ManyControls_Success()
-    {
-        using var owner = new TabControl();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        var items = new List<TabPage>();
-        for (int i = 0; i < 24; i++)
-        {
-            var value = new TabPage();
-            items.Add(value);
-            collection.Add(value);
-            Assert.Equal(items, collection.Cast<Control>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value.Parent);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabControlControlCollection_Add_GetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabControlControlCollection_Add_GetItemsDesignModeWithHandle_Success(string text, string expectedText)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_InvalidValue_ThrowsArgumentException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.ControlCollection(owner);
-        using var value = new Control();
-        Assert.Throws<ArgumentException>(() => collection.Add(value));
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Add_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.ControlCollection(owner);
-        Assert.Throws<ArgumentNullException>(() => collection.Add(null));
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_InvokeValueWithoutHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.ControlCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_InvokeValueWithHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.ControlCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_InvokeValueWithoutHandleOwnerWithHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(6, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(6, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Null(value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(7, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_InvokeValueWithHandleOwnerWithHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_SelectedTabWithoutHandle_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        using var value3 = new TabPage();
-        using var value4 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value1);
-        collection.Add(value2);
-        collection.Add(value3);
-        collection.Add(value4);
-        owner.SelectedTab = value4;
-        Assert.Same(value4, owner.SelectedTab);
-
-        // Remove other.
-        collection.Remove(value2);
-        Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected.
-        collection.Remove(value4);
-        Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value1);
-        Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value3);
-        Assert.Empty(collection);
-        Assert.Null(owner.SelectedTab);
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_SelectedTabWithHandle_SetsSelectedToZero()
-    {
-        using var owner = new TabControl();
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        using var value3 = new TabPage();
-        using var value4 = new TabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(value1);
-        collection.Add(value2);
-        collection.Add(value3);
-        collection.Add(value4);
-        owner.SelectedTab = value4;
-        Assert.Same(value4, owner.SelectedTab);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        // Remove other.
-        collection.Remove(value2);
-        Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>());
-        Assert.Same(value4, owner.SelectedTab);
-
-        // Remove selected.
-        collection.Remove(value4);
-        Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>());
-        Assert.Same(value1, owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value1);
-        Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>());
-        Assert.Same(value3, owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value3);
-        Assert.Empty(collection);
-        Assert.Null(owner.SelectedTab);
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_ManyControls_Success()
-    {
-        using var owner = new TabControl();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-
-        var items = new List<TabPage>();
-        for (int i = 0; i < 24; i++)
-        {
-            var value = new TabPage();
-            items.Add(value);
-            collection.Add(value);
-            Assert.Equal(items, collection.Cast<Control>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value.Parent);
-        }
-
-        for (int i = 0; i < 24; i++)
-        {
-            items.RemoveAt(0);
-            collection.Remove(collection[0]);
-            Assert.Equal(items, collection.Cast<Control>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControlControlCollection_Remove_NoSuchControl_Nop()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.ControlCollection(owner);
-        using var value1 = new Control();
-        using var value2 = new Control();
-        collection.Remove(null);
-        collection.Remove(value1);
-        collection.Remove(value2);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabControlControlCollection_Remove_GetItemsWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Remove(page2);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabControlControlCollection_Remove_GetItemsDesignModeWithHandle_Success()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        TabControl.ControlCollection collection = Assert.IsType<TabControl.ControlCollection>(owner.Controls);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Remove(page2);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    private class NullTextTabPage : TabPage
-    {
-        public override string Text
-        {
-            get => null;
-            set { }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabControlAccessibleObjectTests.cs
deleted file mode 100644
index cc542162eb1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,786 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-using static Interop.UiaCore;
-using static System.Windows.Forms.TabControl;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControl_TabControlAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void TabControlAccessibilityObject_Ctor_Default()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-
-        Assert.NotNull(tabControl.AccessibilityObject);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibilityObject_ControlType_IsTabControl_IfAccessibleRoleIsDefault()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = tabControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TabControlTypeId, actual);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibilityObject_Role_IsPageTabList_ByDefault()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = tabControl.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.PageTabList, actual);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TabControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TabControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TabControl tabControl = new();
-        tabControl.AccessibleRole = role;
-
-        object actual = tabControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void TabControlAccessibleObject_Bounds_ReturnsExpected(bool createControl, bool boundsIsEmpty)
-    {
-        using TabControl tabControl = new();
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        Assert.Equal(boundsIsEmpty, accessibleObject.Bounds.IsEmpty);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, AccessibleStates.Focusable)]
-    [InlineData(true, false, AccessibleStates.Focusable | AccessibleStates.Unavailable)]
-    [InlineData(false, true, AccessibleStates.None)]
-    [InlineData(false, false, AccessibleStates.None)]
-    public void TabControlAccessibleObject_State_ReturnsExpected(bool createControl, bool enabled, AccessibleStates expectedAccessibleStates)
-    {
-        using TabControl tabControl = new() { Enabled = enabled };
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(expectedAccessibleStates, accessibleObject.State);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabControlAccessibleObject_IsSelectionRequired_ReturnsTrue(bool createControl)
-    {
-        using TabControl tabControl = new();
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True(accessibleObject.IsSelectionRequired);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChildCount_ReturnsMinusOne_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChildCount_ReturnsZero_IfTabPagesListIsEmpty()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChild_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChild_ReturnsNull_IfTabPagesListIsEmpty()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Equal(pages[1].TabAccessibilityObject, accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetChild_ReturnsExpectd_AfterUpdatingSelectedTab()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject.GetChild(0));
-
-        tabControl.SelectedIndex = 1;
-
-        Assert.Equal(pages[1].AccessibilityObject, accessibleObject.GetChild(0));
-
-        tabControl.SelectedIndex = 2;
-
-        Assert.Equal(pages[2].AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_HitTest_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.HitTest(10, 33));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_HitTest_ReturnsTabControlAccessibleObject_IfTabPagesListIsEmpty()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(accessibleObject, accessibleObject.HitTest(10, 33));
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_HitTest_ReturnsTabPane()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        AccessibleObject expectedAccessibleObject = tabControl.SelectedTab.AccessibilityObject;
-        Point point = expectedAccessibleObject.Bounds.Location;
-
-        Assert.Equal(expectedAccessibleObject, accessibleObject.HitTest(point.X, point.Y));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_HitTest_ReturnsFirstItem()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        AccessibleObject expectedAccessibleObject = pages[0].TabAccessibilityObject;
-        Point point = expectedAccessibleObject.Bounds.Location;
-
-        Assert.Equal(expectedAccessibleObject, accessibleObject.HitTest(point.X, point.Y));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_HitTest_ReturnsSecondItem()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        AccessibleObject expectedAccessibleObject = pages[1].TabAccessibilityObject;
-        Point point = expectedAccessibleObject.Bounds.Location;
-
-        Assert.Equal(expectedAccessibleObject, accessibleObject.HitTest(point.X, point.Y));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfTabPagesListIsEmpty()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfSingleItem()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(tabControl.SelectedTab.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfThreeItems()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(tabControl.SelectedTab.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(pages[2].TabAccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfSecondTabIsSelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-
-        tabControl.SelectedIndex = 1;
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(tabControl.SelectedTab.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(pages[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(pages[2].TabAccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.False(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpectd_AfterUpdatingSelectedTab()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-        tabControl.SelectedIndex = 1;
-
-        Assert.Equal(pages[1].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-
-        tabControl.SelectedIndex = 2;
-
-        Assert.Equal(pages[2].AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabControlAccessibleObject_GetSelection_ReturnsExpected(int selectedIndex)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-        tabControl.SelectedIndex = selectedIndex;
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        IRawElementProviderSimple[] selectedAccessibleObjects = accessibleObject.GetSelection();
-
-        Assert.Equal(1, selectedAccessibleObjects.Length);
-        Assert.Equal(pages[selectedIndex].TabAccessibilityObject, selectedAccessibleObjects[0]);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.Equal(selectedIndex == 1, pages[1].IsHandleCreated);
-        Assert.Equal(selectedIndex == 2, pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabControlAccessibleObject_GetSelection_ReturnsEmptyArray_IfHandleIsNotCreated(int selectedIndex)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.SelectedIndex = selectedIndex;
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        IRawElementProviderSimple[] selectedAccessibleObjects = accessibleObject.GetSelection();
-
-        Assert.Equal(0, selectedAccessibleObjects.Length);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(pages[2].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetSelection_ReturnsEmptyArray_IfTabPagesListIsEmpty()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        IRawElementProviderSimple[] selectedAccessibleObjects = accessibleObject.GetSelection();
-
-        Assert.Equal(0, selectedAccessibleObjects.Length);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_Support_SelectionPattern()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UIA.SelectionPatternId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetPropertyValue_IsSelectionPatternAvailable_ReturnsTrue()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsSelectionPatternAvailablePropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_Support_LegacyIAccessible()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetPropertyValue_IsLegacyIAccessiblePatternAvailable_ReturnsTrue()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabControlAccessibleObject_Name_ReturnsExpected(string accessibleName)
-    {
-        using TabControl tabControl = new TabControl();
-        tabControl.AccessibleName = accessibleName;
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(accessibleName, accessibleObject.Name);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabControlAccessibleObject_Description_ReturnsExpected(string accessibleDescription)
-    {
-        using TabControl tabControl = new();
-        tabControl.AccessibleDescription = accessibleDescription;
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(accessibleDescription, accessibleObject.Description);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabControlAccessibleObject_AccessibleDefaultActionDescription_ReturnsExpected(string accessibleDefaultActionDescription)
-    {
-        using TabControl tabControl = new();
-        tabControl.AccessibleDefaultActionDescription = accessibleDefaultActionDescription;
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(accessibleDefaultActionDescription, accessibleObject.DefaultAction);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabControlAccessibleObject_GetProperyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected(string accessibleDefaultActionDescription)
-    {
-        using TabControl tabControl = new();
-        tabControl.AccessibleDefaultActionDescription = accessibleDefaultActionDescription;
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(!string.IsNullOrEmpty(accessibleDefaultActionDescription) ? accessibleDefaultActionDescription : null,
-            accessibleObject.GetPropertyValue(UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabControlAccessibleObject_RuntimeId_ReturnsExpected(bool createControl)
-    {
-        using TabControl tabControl = new();
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        Assert.NotNull(tabControl.AccessibilityObject.RuntimeId);
-        Assert.Equal(tabControl.InternalHandle, (IntPtr)tabControl.AccessibilityObject.RuntimeId[1]);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetPropertyValue_HasKeyboardFocusPropertyId_ReturnsFalse()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetPropertyValue_IsKeyboardFocusablePropertyId_ReturnsTrue()
-    {
-        using TabControl tabControl = new TabControl();
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsKeyboardFocusablePropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabControlAccessibleObject_GetPropertyValue_IsEnabledPropertyId_ReturnsTrue(bool enabled)
-    {
-        using TabControl tabControl = new TabControl() { Enabled = enabled };
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(enabled, (bool)accessibleObject.GetPropertyValue(UIA.IsEnabledPropertyId));
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabControlAccessibleObject_GetPropertyValue_NativeWindowHandlePropertyId_ReturnsTrue(bool createControl)
-    {
-        using TabControl tabControl = new TabControl();
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal((nint)tabControl.InternalHandle, (nint)accessibleObject.GetPropertyValue(UIA.NativeWindowHandlePropertyId));
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "&Name", "Alt+n")]
-    [InlineData(false, "&Name", "Alt+n")]
-    [InlineData(true, "Name", null)]
-    [InlineData(false, "Name", null)]
-    public void TabControlAccessibleObject_KeyboardShortcut_ReturnExpected(bool createControl, string text, string expectedKeyboardShortcut)
-    {
-        using TabControl tabControl = new() { Text = text };
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(expectedKeyboardShortcut, accessibleObject.KeyboardShortcut);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "&Name", "Alt+n")]
-    [InlineData(false, "&Name", "Alt+n")]
-    [InlineData(true, "Name", "")]
-    [InlineData(false, "Name", "")]
-    public void TabControlAccessibleObject_GetPropertyValue_AccessKey_ReturnExpected(bool createControl, string text, string expectedKeyboardShortcut)
-    {
-        using TabControl tabControl = new() { Text = text };
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabControlAccessibleObject accessibleObject = Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        Assert.Equal(expectedKeyboardShortcut, accessibleObject.GetPropertyValue(UIA.AccessKeyPropertyId));
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControlAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using TabControl tabControl = new();
-
-        object actual = tabControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(tabControl.AccessibilityObject.RuntimeId, actual);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabControlAccessibleObject_GetPropertyValue_IsEnabled_ReturnsExpected(bool enabled)
-    {
-        using TabControl tabControl = new()
-        {
-            Enabled = enabled
-        };
-
-        object actual = tabControl.AccessibilityObject.GetPropertyValue(UIA.IsEnabledPropertyId);
-
-        Assert.Equal(tabControl.Enabled, actual);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "TabControl1")]
-    public void TabControlAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using TabControl tabControl = new()
-        {
-            Name = "TabControl1",
-            AccessibleName = "TestName"
-        };
-
-        object actual = tabControl.AccessibilityObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, actual);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsValuePatternAvailablePropertyId))]
-    public void TabControlAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using TabControl tabControl = new();
-        TabControlAccessibleObject accessibleObject = (TabControlAccessibleObject)tabControl.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UIA)propertyId) ?? false);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabPageCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabPageCollectionTests.cs
deleted file mode 100644
index 29889cc5a39..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControl.TabPageCollectionTests.cs
+++ /dev/null
@@ -1,4982 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using static Interop;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControlTabPageCollectionTests
-{
-    public static IEnumerable<object[]> Add_TestData()
-    {
-        yield return new object[] { TabAppearance.Buttons };
-        yield return new object[] { TabAppearance.FlatButtons };
-        yield return new object[] { TabAppearance.Normal };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_Add_InvokeValueWithoutHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Add_WithHandle_TestData()
-    {
-        yield return new object[] { TabAppearance.Buttons, Size.Empty, 0 };
-        yield return new object[] { TabAppearance.FlatButtons, Size.Empty, 1 };
-        yield return new object[] { TabAppearance.Normal, Size.Empty, 0 };
-
-        yield return new object[] { TabAppearance.Buttons, new Size(100, 120), 0 };
-        yield return new object[] { TabAppearance.FlatButtons, new Size(100, 120), 1 };
-        yield return new object[] { TabAppearance.Normal, new Size(100, 120), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabPageCollection_Add_InvokeValueWithoutHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(13, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value1, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("Visible", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_Add_InvokeValueWithHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new TabPage[] { value1, value2, value1, }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabPageCollection_Add_InvokeValueWithHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Add(value2);
-            Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Add(value1);
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(13, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value1, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("Visible", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(3, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Add_OwnerWithSiteContainer_AddsToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.NotNull(value.Site);
-        Assert.Same(value, Assert.Single(container.Components));
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Add_OwnerWithSiteContainerValueHasSite_DoesNotAddToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        var mockValueSite = new Mock<ISite>(MockBehavior.Strict);
-        mockValueSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockValueSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage
-        {
-            Site = mockValueSite.Object
-        };
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.Same(mockValueSite.Object, value.Site);
-        Assert.Empty(container.Components);
-        mockSite.Verify(s => s.Container, Times.Never());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Add_OwnerWithSiteNoContainer_DoesNotAddContainer()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value);
-        Assert.Same(owner, value.Parent);
-        Assert.Null(value.Site);
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Add_ManyControls_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        var items = new List<TabPage>();
-        for (int i = 0; i < 24; i++)
-        {
-            var value = new TabPage();
-            items.Add(value);
-            collection.Add(value);
-            Assert.Equal(items, collection.Cast<TabPage>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(items, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value.Parent);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Add_GetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Add_GetItemsDesignModeWithHandle_Success(string text, string expectedText)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Add_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.Add((TabPage)null));
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPageCollection_Add_InvokeString_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(text);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Empty(page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.False(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, "", "")]
-    [InlineData("", "", "", "")]
-    [InlineData("name", "text", "name", "text")]
-    public void TabPageCollection_Add_InvokeStringString_Success(string key, string text, string expectedName, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(key, text);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.False(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, -1, "", "")]
-    [InlineData("", "", 0, "", "")]
-    [InlineData("name", "text", 1, "name", "text")]
-    public void TabPageCollection_Add_InvokeStringStringInt_Success(string key, string text, int imageIndex, string expectedName, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(key, text, imageIndex);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(imageIndex, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.False(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, null, "", "", "")]
-    [InlineData("", "", "", "", "", "")]
-    [InlineData("name", "text", "imageKey", "name", "text", "imageKey")]
-    public void TabPageCollection_Add_InvokeStringStringString_Success(string key, string text, string imageKey, string expectedName, string expectedText, string expectedImageKey)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(key, text, imageKey);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Equal(expectedImageKey, page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.False(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_IListAdd_InvokeValueWithoutHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Add first.
-            iList.Add(value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            iList.Add(value2);
-            Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            iList.Add(value1);
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> IListAdd_InvalidValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListAdd_InvalidValue_TestData))]
-    public void TabPageCollection_IListAdd_InvalidValue_ThrowsArgumentException(object value)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Throws<ArgumentException>(() => iList.Add(value));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_AddRange_Invoke_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        owner.Layout += parentHandler;
-        int controlAddedCallCount = 0;
-        owner.ControlAdded += (sender, e) => controlAddedCallCount++;
-
-        try
-        {
-            collection.AddRange(new TabPage[] { child1, child2, child3 });
-            Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(6, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            collection.AddRange(new TabPage[] { child1, child2, child3 });
-            Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Add empty.
-            collection.AddRange(Array.Empty<TabPage>());
-            Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Same(owner, child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(9, parentLayoutCallCount);
-            Assert.Equal(3, controlAddedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_AddRange_NullPages_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("pages", () => collection.AddRange(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Ctor_TabControl()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Empty(collection);
-        Assert.False(iList.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(iList.IsReadOnly);
-        Assert.False(iList.IsSynchronized);
-        Assert.Same(collection, iList.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Ctor_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new TabControl.TabPageCollection(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeEmpty_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.CopyTo(null, 0);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeNotEmpty_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child1);
-        iList.Add(child2);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, child1, child2, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_NullArray_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child);
-
-        Assert.Throws<ArgumentNullException>("destinationArray", () => iList.CopyTo(null, 0));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvalidIndex_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child);
-
-        var array = new object[] { 1, 2 };
-        Assert.Throws<ArgumentOutOfRangeException>("destinationIndex", () => iList.CopyTo(array, -1));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeNullGetItemsEmpty_Success()
-    {
-        using var owner = new NullGetItemsTabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.CopyTo(null, 0);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeInvalidGetItemsEmpty_Success()
-    {
-        using var owner = new InvalidGetItemsTabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.CopyTo(null, 0);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        iList.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeNullGetItemsNotEmpty_Success()
-    {
-        using var owner = new NullGetItemsTabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child1);
-        iList.Add(child2);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        Assert.Throws<ArgumentNullException>("sourceArray", () => iList.CopyTo(array, 1));
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_CopyTo_InvokeInvalidGetItemsNotEmpty_Success()
-    {
-        using var owner = new InvalidGetItemsTabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child1);
-        iList.Add(child2);
-
-        var array = new object[] { 1, 2, 3, 4 };
-        Assert.Throws<InvalidCastException>(() => iList.CopyTo(array, 1));
-        Assert.Equal(new object[] { 1, 2, 3, 4 }, array);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Clear_InvokeEmpty_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        owner.Layout += parentHandler;
-        int controlRemovedCallCount = 0;
-        owner.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        try
-        {
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Clear again.
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Clear_InvokeNotEmpty_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child3, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int controlRemovedCallCount = 0;
-        owner.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        try
-        {
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Clear again.
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Clear_InvokeEmptyWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int controlRemovedCallCount = 0;
-        owner.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        owner.Layout += parentHandler;
-
-        try
-        {
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Clear again.
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Clear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int controlRemovedCallCount = 0;
-        owner.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(child3, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Clear again.
-            collection.Clear();
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Clear_GetItemsWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Clear();
-        Assert.Equal(0, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Contains_Invoke_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.True(collection.Contains(child1));
-        Assert.True(collection.Contains(child2));
-        Assert.False(collection.Contains(new TabPage()));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Contains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.False(collection.Contains(new TabPage()));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Contains_NullPage_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("page", () => collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListContains_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child1);
-        iList.Add(child2);
-
-        Assert.True(iList.Contains(child1));
-        Assert.True(iList.Contains(child2));
-        Assert.False(iList.Contains(new TabPage()));
-        Assert.False(iList.Contains(new Control()));
-        Assert.False(iList.Contains(new object()));
-        Assert.False(iList.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListContains_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.False(iList.Contains(new TabPage()));
-        Assert.False(iList.Contains(new Control()));
-        Assert.False(iList.Contains(new object()));
-        Assert.False(iList.Contains(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, false)]
-    [InlineData("", false)]
-    [InlineData("name1", true)]
-    [InlineData("NAME1", true)]
-    [InlineData("name2", true)]
-    [InlineData("NoSuchName", false)]
-    [InlineData("abcd", false)]
-    [InlineData("abcde", false)]
-    [InlineData("abcdef", false)]
-    public void TabPageCollection_ContainsKey_Invoke_ReturnsExpected(string key, bool expected)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(expected, collection.ContainsKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.ContainsKey(key));
-        Assert.False(collection.ContainsKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TabPageCollection_ContainsKey_InvokeEmpty_ReturnsExpected(string key)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        Assert.False(collection.ContainsKey(key));
-
-        // Call again.
-        Assert.False(collection.ContainsKey(key));
-        Assert.False(collection.ContainsKey("NoSuchKey"));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child1, enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child2, enumerator.Current);
-
-            Assert.True(enumerator.MoveNext());
-            Assert.Same(child3, enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_AddDuringEnumeration_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IEnumerator enumerator = collection.GetEnumerator();
-        collection.Add(child);
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeRemoveBeforeEnumeration_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        collection.Remove(child1);
-
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child1, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child2, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-        // Call again.
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeRemoveAtEndOfEnumeration_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        IEnumerator enumerator = collection.GetEnumerator();
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child1, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child2, enumerator.Current);
-
-        Assert.True(enumerator.MoveNext());
-        Assert.Same(child3, enumerator.Current);
-
-        collection.Remove(child1);
-        Assert.Same(child3, enumerator.Current);
-
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-        // Call again.
-        Assert.False(enumerator.MoveNext());
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-        collection.Add(child1);
-        Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeNullGetItems_ReturnsExpected()
-    {
-        using var owner = new NullGetItemsTabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IEnumerator enumerator = collection.GetEnumerator();
-        for (int i = 0; i < 2; i++)
-        {
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            // Call again.
-            Assert.False(enumerator.MoveNext());
-            Assert.Throws<InvalidOperationException>(() => enumerator.Current);
-
-            enumerator.Reset();
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_GetEnumerator_InvokeInvalidGetItems_ReturnsExpected()
-    {
-        using var owner = new InvalidGetItemsTabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<InvalidCastException>(() => collection.GetEnumerator());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IndexOf_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        Assert.Equal(0, collection.IndexOf(child1));
-        Assert.Equal(1, collection.IndexOf(child2));
-        Assert.Equal(-1, collection.IndexOf(new TabPage()));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Equal(-1, collection.IndexOf(new TabPage()));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IndexOf_NullPage_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("page", () => collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListIndexOf_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(child1);
-        iList.Add(child2);
-
-        Assert.Equal(0, iList.IndexOf(child1));
-        Assert.Equal(1, iList.IndexOf(child2));
-        Assert.Equal(-1, iList.IndexOf(new TabPage()));
-        Assert.Equal(-1, iList.IndexOf(new Control()));
-        Assert.Equal(-1, iList.IndexOf(new object()));
-        Assert.Equal(-1, iList.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListIndexOf_InvokeEmpty_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Equal(-1, iList.IndexOf(new TabPage()));
-        Assert.Equal(-1, iList.IndexOf(new Control()));
-        Assert.Equal(-1, iList.IndexOf(new object()));
-        Assert.Equal(-1, iList.IndexOf(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1)]
-    [InlineData("", -1)]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    [InlineData("NoSuchName", -1)]
-    [InlineData("abcd", -1)]
-    [InlineData("abcde", -1)]
-    [InlineData("abcdef", -1)]
-    public void TabPageCollection_IndexOfKey_InvokeNotEmpty_ReturnsExpected(string key, int expected)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(expected, collection.IndexOfKey(key));
-
-        // Call again.
-        Assert.Equal(expected, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TabPageCollection_IndexOfKey_InvokeEmpty_ReturnsExpected(string key)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        Assert.Equal(-1, collection.IndexOfKey(key));
-
-        // Call again.
-        Assert.Equal(-1, collection.IndexOfKey(key));
-        Assert.Equal(-1, collection.IndexOfKey("NoSuchKey"));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_Insert_InvokeValueWithoutHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Add first.
-            collection.Insert(0, value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Insert(0, value2);
-            Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Insert(2, value1);
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(7, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.Same(value1, events[5].AffectedControl);
-            Assert.Equal("ChildIndex", events[5].AffectedProperty);
-            Assert.Same(value1, events[6].AffectedControl);
-            Assert.Equal("ChildIndex", events[6].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabPageCollection_Insert_InvokeValueWithoutHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Insert(0, value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Insert(0, value2);
-            Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(1, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(10, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value2, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Insert(2, value1);
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(1, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(15, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value2, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("ChildIndex", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.Same(value1, events[13].AffectedControl);
-            Assert.Equal("Visible", events[13].AffectedProperty);
-            Assert.Same(value1, events[14].AffectedControl);
-            Assert.Equal("ChildIndex", events[14].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_Insert_InvokeValueWithHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Add first.
-            collection.Insert(0, value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            collection.Insert(0, value2);
-            Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            collection.Insert(2, value1);
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(7, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Equal("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Equal("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Equal("ChildIndex", events[4].AffectedProperty);
-            Assert.Same(value1, events[5].AffectedControl);
-            Assert.Equal("ChildIndex", events[5].AffectedProperty);
-            Assert.Same(value1, events[6].AffectedControl);
-            Assert.Equal("ChildIndex", events[6].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_WithHandle_TestData))]
-    public void TabPageCollection_Insert_InvokeValueWithHandleOwnerWithHandle_Success(TabAppearance appearance, Size itemSize, int expectedParentInvalidatedCallCount)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            ItemSize = itemSize,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Add first.
-            collection.Insert(0, value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add another.
-            collection.Insert(0, value2);
-            Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(1, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(10, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value2, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 2, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Add again.
-            collection.Insert(2, value1);
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(owner.DisplayRectangle, value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(owner.DisplayRectangle, value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(1, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(15, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Equal("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Equal("Visible", events[1].AffectedProperty);
-            Assert.Same(value1, events[2].AffectedControl);
-            Assert.Equal("Bounds", events[2].AffectedProperty);
-            Assert.Same(value1, events[3].AffectedControl);
-            Assert.Equal("Bounds", events[3].AffectedProperty);
-            Assert.Same(value1, events[4].AffectedControl);
-            Assert.Equal("Visible", events[4].AffectedProperty);
-            Assert.Same(value2, events[5].AffectedControl);
-            Assert.Equal("Parent", events[5].AffectedProperty);
-            Assert.Same(value2, events[6].AffectedControl);
-            Assert.Equal("Visible", events[6].AffectedProperty);
-            Assert.Same(value2, events[7].AffectedControl);
-            Assert.Equal("Bounds", events[7].AffectedProperty);
-            Assert.Same(value2, events[8].AffectedControl);
-            Assert.Equal("Bounds", events[8].AffectedProperty);
-            Assert.Same(value2, events[9].AffectedControl);
-            Assert.Equal("ChildIndex", events[9].AffectedProperty);
-            Assert.Same(value1, events[10].AffectedControl);
-            Assert.Equal("ChildIndex", events[10].AffectedProperty);
-            Assert.Same(value1, events[11].AffectedControl);
-            Assert.Equal("Visible", events[11].AffectedProperty);
-            Assert.Same(value1, events[12].AffectedControl);
-            Assert.Equal("Visible", events[12].AffectedProperty);
-            Assert.Same(value1, events[13].AffectedControl);
-            Assert.Equal("Visible", events[13].AffectedProperty);
-            Assert.Same(value1, events[14].AffectedControl);
-            Assert.Equal("ChildIndex", events[14].AffectedProperty);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(3, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount * 3, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_OwnerWithSiteContainer_AddsToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Insert(0, value);
-        Assert.Same(owner, value.Parent);
-        Assert.NotNull(value.Site);
-        Assert.Same(value, Assert.Single(container.Components));
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_OwnerWithSiteContainerValueHasSite_DoesNotAddToContainer()
-    {
-        var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        var mockValueSite = new Mock<ISite>(MockBehavior.Strict);
-        mockValueSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockValueSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage
-        {
-            Site = mockValueSite.Object
-        };
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Insert(0, value);
-        Assert.Same(owner, value.Parent);
-        Assert.Same(mockValueSite.Object, value.Site);
-        Assert.Empty(container.Components);
-        mockSite.Verify(s => s.Container, Times.Never());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_OwnerWithSiteNoContainer_DoesNotAddContainer()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var value = new TabPage();
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Insert(0, value);
-        Assert.Same(owner, value.Parent);
-        Assert.Null(value.Site);
-        mockSite.Verify(s => s.Container, Times.Once());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_ManyControls_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        var items = new List<TabPage>();
-        for (int i = 0; i < 24; i++)
-        {
-            var value = new TabPage();
-            items.Insert(0, value);
-            collection.Insert(0, value);
-            Assert.Equal(items, collection.Cast<TabPage>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(items, owner.Controls.Cast<TabPage>());
-            Assert.Same(owner, value.Parent);
-        }
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPageCollection_Insert_InvokeIntString_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Insert(0, text);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Empty(page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.True(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, "", "")]
-    [InlineData("", "", "", "")]
-    [InlineData("name", "text", "name", "text")]
-    public void TabPageCollection_Insert_InvokeIntStringString_Success(string key, string text, string expectedName, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Insert(0, key, text);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.True(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, -1, "", "")]
-    [InlineData("", "", 0, "", "")]
-    [InlineData("name", "text", 1, "name", "text")]
-    public void TabPageCollection_Insert_InvokeIntStringStringInt_Success(string key, string text, int imageIndex, string expectedName, string expectedText)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Insert(0, key, text, imageIndex);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(imageIndex, page.ImageIndex);
-        Assert.Empty(page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.True(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, null, null, "", "", "")]
-    [InlineData("", "", "", "", "", "")]
-    [InlineData("name", "text", "imageKey", "name", "text", "imageKey")]
-    public void TabPageCollection_Insert_InvokeIntStringStringString_Success(string key, string text, string imageKey, string expectedName, string expectedText, string expectedImageKey)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Insert(0, key, text, imageKey);
-
-        TabPage page = Assert.IsType<TabPage>(Assert.Single(collection));
-        Assert.Equal(expectedName, page.Name);
-        Assert.Equal(expectedText, page.Text);
-        Assert.Equal(-1, page.ImageIndex);
-        Assert.Equal(expectedImageKey, page.ImageKey);
-        Assert.Same(owner, page.Parent);
-        Assert.True(page.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Insert_GetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Insert(0, page3);
-        collection.Insert(0, page2);
-        collection.Insert(0, page1);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Insert_GetItemsDesignModeWithHandle_Success(string text, string expectedText)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Insert(0, page3);
-        collection.Insert(0, page2);
-        collection.Insert(0, page1);
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_NullTabPage_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("tabPage", () => collection.Insert(0, (TabPage)null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_NegativeIndexEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, value));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text", 1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text", "imageKey"));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_NegativeIndexEmptyWithHandle_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, value));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text", 1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(-1, "key", "text", "imageKey"));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Insert_InvalidIndexEmpty_Nop(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>(() => collection.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Insert_InvalidIndexEmptyWithHandle_Nop(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>(() => collection.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabPageCollection_Insert_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child);
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, value));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text", 1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text", "imageKey"));
-        Assert.Same(child, Assert.Single(collection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabPageCollection_Insert_InvalidIndexNotEmptyWithHandle_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, value));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text"));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text", 1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.Insert(index, "key", "text", "imageKey"));
-        Assert.Same(child, Assert.Single(collection));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Add_TestData))]
-    public void TabPageCollection_IListInsert_InvokeValueWithoutHandleOwnerWithoutHandle_Success(TabAppearance appearance)
-    {
-        using var owner = new TabControl
-        {
-            Appearance = appearance,
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Add first.
-            iList.Insert(0, value1);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Same("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Same("Visible", events[1].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add another.
-            iList.Insert(0, value2);
-            Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Same(owner, value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(5, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Same("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Same("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Same("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Same("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Same("ChildIndex", events[4].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Add again.
-            iList.Insert(2, value1);
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>());
-            Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>());
-            Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>());
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Same(owner, value2.Parent);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(7, parentLayoutCallCount);
-            Assert.Same(value1, events[0].AffectedControl);
-            Assert.Same("Parent", events[0].AffectedProperty);
-            Assert.Same(value1, events[1].AffectedControl);
-            Assert.Same("Visible", events[1].AffectedProperty);
-            Assert.Same(value2, events[2].AffectedControl);
-            Assert.Same("Parent", events[2].AffectedProperty);
-            Assert.Same(value2, events[3].AffectedControl);
-            Assert.Same("Visible", events[3].AffectedProperty);
-            Assert.Same(value2, events[4].AffectedControl);
-            Assert.Same("ChildIndex", events[4].AffectedProperty);
-            Assert.Same(value1, events[5].AffectedControl);
-            Assert.Same("ChildIndex", events[5].AffectedProperty);
-            Assert.Same(value1, events[6].AffectedControl);
-            Assert.Same("ChildIndex", events[6].AffectedProperty);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> IListInsert_InvalidValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListInsert_InvalidValue_TestData))]
-    public void TabPageCollection_IListInsert_NotTabPage_ThrowsArgumentException(object value)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Throws<ArgumentException>(() => iList.Insert(0, value));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListInsert_NegativeIndexEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList.Insert(-1, value));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListInsert_NegativeIndexEmptyWithHandle_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList.Insert(-1, value));
-        Assert.Empty(collection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListInsert_InvalidIndexEmpty_Nop(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>(() => iList.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListInsert_InvalidIndexEmptyWithHandle_Nop(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>(() => iList.Insert(index, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabPageCollection_IListInsert_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        collection.Add(child);
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList.Insert(index, value));
-        Assert.Same(child, Assert.Single(collection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabPageCollection_IListInsert_InvalidIndexNotEmptyWithHandle_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        collection.Add(child);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList.Insert(index, value));
-        Assert.Same(child, Assert.Single(collection));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name1", 0)]
-    [InlineData("NAME1", 0)]
-    [InlineData("name2", 1)]
-    public void TabPageCollection_Item_GetStringValidKey_ReturnsExpected(string key, int expectedIndex)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Equal(collection[expectedIndex], collection[key]);
-
-        // Call again.
-        Assert.Equal(collection[expectedIndex], collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void TabPageCollection_Item_GetStringNoSuchKey_ReturnsNull(string key)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Null(collection[key]);
-
-        // Call again.
-        Assert.Null(collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TabPageCollection_Item_GetStringEmpty_ReturnsNull(string key)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        Assert.Null(collection[key]);
-
-        // Call again.
-        Assert.Null(collection[key]);
-        Assert.Null(collection["NoSuchKey"]);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Item_GetIntValidIndex_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        Assert.Same(page1, collection[0]);
-        Assert.Same(page2, collection[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPageCollection_Item_GetIntInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_GetIntInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_SetValidIndex_ReturnsExpected(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        using var newPage = new TabPage();
-        collection[index] = newPage;
-        Assert.Same(newPage, collection[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_SetValidIndexDesignMode_ReturnsExpected(int index)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        using var newPage = new TabPage();
-        collection[index] = newPage;
-        Assert.Same(newPage, collection[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_SetValidIndexWithHandle_ReturnsExpected(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        using var newPage = new TabPage();
-        collection[index] = newPage;
-        Assert.Same(newPage, collection[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_SetValidIndexDesignModeWithHandle_ReturnsExpected(int index)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        using var newPage = new TabPage();
-        collection[index] = newPage;
-        Assert.Same(newPage, collection[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Item_SetGetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        collection[1] = value;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Item_SetGetItemsDesignModeWithHandle_Success(string text, string expectedText)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        using var value = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        collection[1] = value;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Item_SetNull_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page);
-
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Item_SetNullWithHandle_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Add(page);
-
-        Assert.Throws<ArgumentNullException>("value", () => collection[0] = null);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPageCollection_Item_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = page);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_Item_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = page2);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListItem_GetValidIndex_ReturnsExpected()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        iList.Add(page2);
-        Assert.Same(page1, iList[0]);
-        Assert.Same(page2, iList[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPageCollection_IListItem_GetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_GetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_SetValidIndex_ReturnsExpected(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        iList.Add(page2);
-        iList.Add(page3);
-
-        using var newPage = new TabPage();
-        iList[index] = newPage;
-        Assert.Same(newPage, iList[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_SetValidIndexDesignMode_ReturnsExpected(int index)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        iList.Add(page2);
-        iList.Add(page3);
-
-        using var newPage = new TabPage();
-        iList[index] = newPage;
-        Assert.Same(newPage, iList[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_SetValidIndexWithHandle_ReturnsExpected(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        iList.Add(page2);
-        iList.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        using var newPage = new TabPage();
-        iList[index] = newPage;
-        Assert.Same(newPage, iList[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_SetValidIndexDesignModeWithHandle_ReturnsExpected(int index)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        iList.Add(page2);
-        iList.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        using var newPage = new TabPage();
-        iList[index] = newPage;
-        Assert.Same(newPage, iList[index]);
-        Assert.Same(owner, page1.Parent);
-        Assert.Same(owner, page2.Parent);
-        Assert.Same(owner, page3.Parent);
-        Assert.Null(newPage.Parent);
-        Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>());
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-        Assert.False(page3.IsHandleCreated);
-        Assert.False(newPage.IsHandleCreated);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    public static IEnumerable<object[]> IListItem_InvalidValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListItem_InvalidValue_TestData))]
-    public void TabPageCollection_IListItem_SetInvalidValue_ThrowsArgumentException(object value)
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page);
-        Assert.Throws<ArgumentException>(() => iList[0] = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPageCollection_IListItem_SetInvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index] = page);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_IListItem_SetInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(page1);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => iList[index] = page2);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_InvokeValueWithoutHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_InvokeValueWithHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_InvokeValueWithoutHandleOwnerWithHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int parentInvalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        owner.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(6, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(0, owner.SelectedIndex);
-            Assert.Equal(2, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(6, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(value1.Parent);
-            Assert.True(value1.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(4, 24, 392, 272), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(3, layoutCallCount1);
-            Assert.Equal(1, layoutCallCount2);
-            Assert.Equal(7, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_InvokeValueWithHandleOwnerWithHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, value1.Handle);
-        int invalidatedCallCount1 = 0;
-        value1.Invalidated += (sender, e) => invalidatedCallCount1++;
-        int styleChangedCallCount1 = 0;
-        value1.StyleChanged += (sender, e) => styleChangedCallCount1++;
-        int createdCallCount1 = 0;
-        value1.HandleCreated += (sender, e) => createdCallCount1++;
-        Assert.NotEqual(IntPtr.Zero, value2.Handle);
-        int invalidatedCallCount2 = 0;
-        value2.Invalidated += (sender, e) => invalidatedCallCount2++;
-        int styleChangedCallCount2 = 0;
-        value2.StyleChanged += (sender, e) => styleChangedCallCount2++;
-        int createdCallCount2 = 0;
-        value2.HandleCreated += (sender, e) => createdCallCount2++;
-
-        try
-        {
-            // Remove last.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            collection.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(value1, Assert.Single(owner.Controls));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            collection.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Empty(owner.Controls);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.True(value1.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount1);
-            Assert.Equal(0, styleChangedCallCount1);
-            Assert.Equal(0, createdCallCount1);
-            Assert.True(value2.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount2);
-            Assert.Equal(0, styleChangedCallCount2);
-            Assert.Equal(0, createdCallCount2);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_SelectedTabWithoutHandle_ThrowsArgumentOutOfRangeException()
-    {
-        using var owner = new TabControl();
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        using var value3 = new TabPage();
-        using var value4 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-        collection.Add(value3);
-        collection.Add(value4);
-        owner.SelectedTab = value4;
-        Assert.Same(value4, owner.SelectedTab);
-
-        // Remove other.
-        collection.Remove(value2);
-        Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected.
-        collection.Remove(value4);
-        Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value1);
-        Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>());
-        Assert.Throws<ArgumentOutOfRangeException>(() => owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value3);
-        Assert.Empty(collection);
-        Assert.Null(owner.SelectedTab);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_SelectedTabWithHandle_SetsSelectedToZero()
-    {
-        using var owner = new TabControl();
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        using var value3 = new TabPage();
-        using var value4 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(value1);
-        collection.Add(value2);
-        collection.Add(value3);
-        collection.Add(value4);
-        owner.SelectedTab = value4;
-        Assert.Same(value4, owner.SelectedTab);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        // Remove other.
-        collection.Remove(value2);
-        Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>());
-        Assert.Same(value4, owner.SelectedTab);
-
-        // Remove selected.
-        collection.Remove(value4);
-        Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>());
-        Assert.Same(value1, owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value1);
-        Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>());
-        Assert.Same(value3, owner.SelectedTab);
-
-        // Remove selected again.
-        collection.Remove(value3);
-        Assert.Empty(collection);
-        Assert.Null(owner.SelectedTab);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_ManyControls_Success()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-
-        var items = new List<TabPage>();
-        for (int i = 0; i < 24; i++)
-        {
-            var value = new TabPage();
-            items.Add(value);
-            collection.Add(value);
-            Assert.Equal(items, collection.Cast<TabPage>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-            Assert.Same(owner, value.Parent);
-        }
-
-        for (int i = 0; i < 24; i++)
-        {
-            items.RemoveAt(0);
-            collection.Remove(collection[0]);
-            Assert.Equal(items, collection.Cast<TabPage>());
-            Assert.Equal(items, owner.TabPages.Cast<TabPage>());
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_NoSuchValueEmpty_Nop()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        using var value = new TabPage();
-        collection.Remove(value);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_NoSuchValueNotEmpty_Nop()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page1);
-        using var value = new TabPage();
-        collection.Remove(value);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabControlControlCollection_Remove_GetItemsWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Remove(page2);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabControlControlCollection_Remove_GetItemsDesignModeWithHandle_Success()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(page1);
-        collection.Add(page2);
-        collection.Add(page3);
-
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        collection.Remove(page2);
-        Assert.Equal(2, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Remove_NullValue_ThrowsArgumentNullException()
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentNullException>("value", () => collection.Remove((TabPage)null));
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_IListRemove_InvokeValueWithoutHandleOwnerWithoutHandle_Success()
-    {
-        using var owner = new TabControl
-        {
-            Bounds = new Rectangle(0, 0, 400, 300)
-        };
-        using var value1 = new TabPage();
-        using var value2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Add(value1);
-        iList.Add(value2);
-
-        int layoutCallCount1 = 0;
-        value1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        value2.Layout += (sender, e) => layoutCallCount2++;
-        int parentLayoutCallCount = 0;
-        var events = new List<LayoutEventArgs>();
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            events.Add(e);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            // Remove last.
-            iList.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove again.
-            iList.Remove(value2);
-            Assert.Same(value1, Assert.Single(collection));
-            Assert.Same(value1, Assert.Single(owner.TabPages));
-            Assert.Same(owner, value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove first.
-            iList.Remove(value1);
-            Assert.Empty(collection);
-            Assert.Empty(owner.TabPages);
-            Assert.Null(value1.Parent);
-            Assert.False(value1.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value1.Bounds);
-            Assert.Null(value1.Site);
-            Assert.Null(value2.Parent);
-            Assert.False(value2.Visible);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), value2.Bounds);
-            Assert.Null(value2.Site);
-            Assert.Equal(-1, owner.SelectedIndex);
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(value1.IsHandleCreated);
-            Assert.False(value2.IsHandleCreated);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> IListRemove_InvalidValue_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IListRemove_InvalidValue_TestData))]
-    public void TabPageCollection_IListRemove_InvalidValue_Nop(object value)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        IList iList = collection;
-        iList.Remove(value);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_RemoveAt_Invoke_Success()
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-
-        int layoutCallCount = 0;
-        child1.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        object affectedControl = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            affectedControl = child2;
-            collection.RemoveAt(1);
-            Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-
-            // Remove again.
-            affectedControl = child1;
-            collection.RemoveAt(0);
-            Assert.Empty(collection);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPageCollection_RemoveAt_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        var collection = new TabControl.TabPageCollection(owner);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPageCollection_RemoveAtInvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var owner = new TabControl();
-        using var child = new TabPage();
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveAt(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void TabPageCollection_RemoveByKey_InvokeValidKey_ReturnsExpected(string key)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        int layoutCallCount = 0;
-        child2.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        object affectedControl = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(affectedControl, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-
-        try
-        {
-            affectedControl = child2;
-            collection.RemoveByKey(key);
-            Assert.Equal(new TabPage[] { child1, child3 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Same(owner, child3.Parent);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // Remove again.
-            affectedControl = child3;
-            collection.RemoveByKey(key);
-            Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>());
-            Assert.Same(owner, child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void TabPageCollection_RemoveByKey_InvokeNoSuchKey_ReturnsNull(string key)
-    {
-        using var owner = new TabControl();
-        using var child1 = new TabPage
-        {
-            Name = "name1"
-        };
-        using var child2 = new TabPage
-        {
-            Name = "name2"
-        };
-        using var child3 = new TabPage
-        {
-            Name = "name2"
-        };
-        var collection = new TabControl.TabPageCollection(owner);
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        collection.RemoveByKey(key);
-        Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>());
-
-        // Call again.
-        collection.RemoveByKey(key);
-        Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>());
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_By_Index()
-    {
-        using var TabControl = new TabControl();
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-
-        page1.Text = "First works";
-        TabControl.TabPages.Add(page1);
-
-        page2.Text = "Second works";
-        TabControl.TabPages.Insert(1, page2);
-        Assert.Equal(2, TabControl.TabPages.Count);
-        Assert.Equal(page2, TabControl.TabPages[1]);
-        Assert.Equal(page2, TabControl.Controls[1]);
-
-        page3.Text = "Third works";
-        TabControl.TabPages.Insert(1, page3);
-        Assert.Equal(3, TabControl.TabPages.Count);
-        Assert.Equal(page3, TabControl.TabPages[1]);
-        Assert.Equal(page3, TabControl.Controls[1]);
-        Assert.Equal(page2, TabControl.TabPages[2]);
-        Assert.Equal(page2, TabControl.Controls[2]);
-    }
-
-    [WinFormsFact]
-    public void TabPageCollection_Insert_First_item()
-    {
-        using var TabControl = new TabControl();
-
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-
-        page1.Text = "First works";
-        TabControl.TabPages.Insert(0, page1);
-        Assert.Equal(1, TabControl.TabPages.Count);
-        Assert.Equal(page1, TabControl.TabPages[0]);
-        Assert.Equal(page1, TabControl.Controls[0]);
-
-        page2.Text = "Second works";
-        TabControl.TabPages.Insert(1, page2);
-        Assert.Equal(2, TabControl.TabPages.Count);
-        Assert.Equal(page2, TabControl.TabPages[1]);
-        Assert.Equal(page2, TabControl.Controls[1]);
-
-        page3.Text = "Third works";
-        TabControl.TabPages.Insert(1, page3);
-        Assert.Equal(3, TabControl.TabPages.Count);
-        Assert.Equal(page3, TabControl.TabPages[1]);
-        Assert.Equal(page3, TabControl.Controls[1]);
-        Assert.Equal(page2, TabControl.TabPages[2]);
-        Assert.Equal(page2, TabControl.Controls[2]);
-    }
-
-    private class NullGetItemsTabControl : TabControl
-    {
-        protected override object[] GetItems() => null;
-    }
-
-    private class InvalidGetItemsTabControl : TabControl
-    {
-        protected override object[] GetItems() => new object[] { 1 };
-    }
-
-    private class NullTextTabPage : TabPage
-    {
-        public override string Text
-        {
-            get => null;
-            set { }
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlCancelEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlCancelEventArgsTests.cs
deleted file mode 100644
index 2b3859c43e3..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlCancelEventArgsTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControlCancelEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TabPage_Int_Bool_TabControlAction_TestData()
-    {
-        yield return new object[] { null, -2, false, (TabControlAction)(TabControlAction.Selecting - 1) };
-        yield return new object[] { new TabPage(), -1, true, TabControlAction.Selecting };
-        yield return new object[] { new TabPage(), 0, false, TabControlAction.Selected };
-        yield return new object[] { new TabPage(), 1, true, TabControlAction.Selected };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_TabPage_Int_Bool_TabControlAction_TestData))]
-    public void Ctor_TabPage_Int_Bool_TabControlAction(TabPage tabPage, int tabPageIndex, bool cancel, TabControlAction action)
-    {
-        var e = new TabControlCancelEventArgs(tabPage, tabPageIndex, cancel, action);
-        Assert.Equal(tabPage, e.TabPage);
-        Assert.Equal(tabPageIndex, e.TabPageIndex);
-        Assert.Equal(cancel, e.Cancel);
-        Assert.Equal(action, e.Action);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlEventArgsTests.cs
deleted file mode 100644
index 731bea8def5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlEventArgsTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControlEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TabPage_Int_TabControlAction_TestData()
-    {
-        yield return new object[] { null, -2, (TabControlAction)(TabControlAction.Selecting - 1) };
-        yield return new object[] { new TabPage(), -1, TabControlAction.Selecting };
-        yield return new object[] { new TabPage(), 0, TabControlAction.Selected };
-        yield return new object[] { new TabPage(), 1, TabControlAction.Selected };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_TabPage_Int_TabControlAction_TestData))]
-    public void Ctor_TabPage_Int_TabControlAction(TabPage tabPage, int tabPageIndex, TabControlAction action)
-    {
-        var e = new TabControlEventArgs(tabPage, tabPageIndex, action);
-        Assert.Equal(tabPage, e.TabPage);
-        Assert.Equal(tabPageIndex, e.TabPageIndex);
-        Assert.Equal(action, e.Action);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlTests.cs
deleted file mode 100644
index c3d1ba4eda4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabControlTests.cs
+++ /dev/null
@@ -1,5822 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabControlTests
-{
-    [WinFormsFact]
-    public void TabControl_Ctor_Default()
-    {
-        using var control = new SubTabControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.Equal(TabAlignment.Top, control.Alignment);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(TabAppearance.Normal, control.Appearance);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Equal(TabDrawMode.Normal, control.DrawMode);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, control.Height);
-        Assert.False(control.HotTrack);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(Size.Empty, control.ItemSize);
-        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.False(control.Multiline);
-        Assert.Equal(new Point(6, 3), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(new Size(200, 100), control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedTab);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.False(control.ShowToolTips);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(TabSizeMode.Normal, control.SizeMode);
-        Assert.Equal(0, control.TabCount);
-        Assert.Equal(0, control.TabIndex);
-        Assert.Empty(control.TabPages);
-        Assert.Same(control.TabPages, control.TabPages);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010800, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010A00)]
-    [InlineData(false, 0x56010800)]
-    public void TabControl_CreateParams_GetMultiline_ReturnsExpected(bool multiline, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            Multiline = multiline
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabDrawMode.Normal, 0x56010800)]
-    [InlineData(TabDrawMode.OwnerDrawFixed, 0x56012800)]
-    public void TabControl_CreateParams_GetDrawMode_ReturnsExpected(TabDrawMode drawMode, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            DrawMode = drawMode
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x56010800)]
-    [InlineData(false, true, 0x56010800)]
-    [InlineData(true, false, 0x56014800)]
-    [InlineData(false, false, 0x56010800)]
-    public void TabControl_CreateParams_GetShowToolTips_ReturnsExpected(bool ShowToolTips, bool designMode, int expectedStyle)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns<IContainer>(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new SubTabControl
-        {
-            ShowToolTips = ShowToolTips,
-            Site = mockSite.Object
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabAlignment.Bottom, 0x56010802)]
-    [InlineData(TabAlignment.Left, 0x56010A80)]
-    [InlineData(TabAlignment.Right, 0x56010A82)]
-    [InlineData(TabAlignment.Top, 0x56010800)]
-    public void TabControl_CreateParams_GetAlignment_ReturnsExpected(TabAlignment alignment, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            Alignment = alignment
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010840)]
-    [InlineData(false, 0x56010800)]
-    public void TabControl_CreateParams_GetHotTrack_ReturnsExpected(bool hotTrack, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            HotTrack = hotTrack
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabAppearance.Normal, TabAlignment.Bottom, 0x56010802)]
-    [InlineData(TabAppearance.Normal, TabAlignment.Left, 0x56010A80)]
-    [InlineData(TabAppearance.Normal, TabAlignment.Right, 0x56010A82)]
-    [InlineData(TabAppearance.Normal, TabAlignment.Top, 0x56010800)]
-    [InlineData(TabAppearance.Buttons, TabAlignment.Bottom, 0x56010902)]
-    [InlineData(TabAppearance.Buttons, TabAlignment.Left, 0x56010B80)]
-    [InlineData(TabAppearance.Buttons, TabAlignment.Right, 0x56010B82)]
-    [InlineData(TabAppearance.Buttons, TabAlignment.Top, 0x56010900)]
-    [InlineData(TabAppearance.FlatButtons, TabAlignment.Bottom, 0x56010902)]
-    [InlineData(TabAppearance.FlatButtons, TabAlignment.Left, 0x56010B80)]
-    [InlineData(TabAppearance.FlatButtons, TabAlignment.Right, 0x56010B82)]
-    [InlineData(TabAppearance.FlatButtons, TabAlignment.Top, 0x56010908)]
-    public void TabControl_CreateParams_GetAppearance_ReturnsExpected(TabAppearance appearance, TabAlignment alignment, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            Appearance = appearance,
-            Alignment = alignment
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabSizeMode.FillToRight, 0x56010000)]
-    [InlineData(TabSizeMode.Fixed, 0x56010400)]
-    [InlineData(TabSizeMode.Normal, 0x56010800)]
-    public void TabControl_CreateParams_GetSizeMode_ReturnsExpected(TabSizeMode sizeMode, int expectedStyle)
-    {
-        using var control = new SubTabControl
-        {
-            SizeMode = sizeMode
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true, 0x56010800, 0x0)]
-    [InlineData(RightToLeft.No, true, 0x56010800, 0x0)]
-    [InlineData(RightToLeft.Yes, true, 0x56010800, 0x500000)]
-    [InlineData(RightToLeft.Inherit, false, 0x56010800, 0x0)]
-    [InlineData(RightToLeft.No, false, 0x56010800, 0x0)]
-    [InlineData(RightToLeft.Yes, false, 0x56010800, 0x7000)]
-    public void TabControl_CreateParams_GetRightToLeft_ReturnsExpected(RightToLeft rightToLeft, bool rightToLeftLayout, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubTabControl
-        {
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTabControl32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    public static IEnumerable<object[]> Alignment_Set_TestData()
-    {
-        yield return new object[] { true, TabAlignment.Top, true };
-        yield return new object[] { true, TabAlignment.Bottom, true };
-        yield return new object[] { true, TabAlignment.Left, true };
-        yield return new object[] { true, TabAlignment.Right, true };
-
-        yield return new object[] { false, TabAlignment.Top, false };
-        yield return new object[] { false, TabAlignment.Bottom, false };
-        yield return new object[] { false, TabAlignment.Left, true };
-        yield return new object[] { false, TabAlignment.Right, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_Set_TestData))]
-    public void TabControl_Alignment_Set_GetReturnsExpected(bool multiline, TabAlignment value, bool expectedMultiline)
-    {
-        using var control = new TabControl
-        {
-            Multiline = multiline,
-            Alignment = value
-        };
-        Assert.Equal(value, control.Alignment);
-        Assert.Equal(expectedMultiline, control.Multiline);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Alignment = value;
-        Assert.Equal(value, control.Alignment);
-        Assert.Equal(expectedMultiline, control.Multiline);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Alignment_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, TabAlignment.Top, true, 0 };
-        yield return new object[] { true, TabAlignment.Bottom, true, 1 };
-        yield return new object[] { true, TabAlignment.Left, true, 1 };
-        yield return new object[] { true, TabAlignment.Right, true, 1 };
-
-        yield return new object[] { false, TabAlignment.Top, false, 0 };
-        yield return new object[] { false, TabAlignment.Bottom, false, 1 };
-        yield return new object[] { false, TabAlignment.Left, true, 1 };
-        yield return new object[] { false, TabAlignment.Right, true, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Alignment_SetWithHandle_TestData))]
-    public void TabControl_Alignment_SetWithHandle_GetReturnsExpected(bool multiline, TabAlignment value, bool expectedMultiline, int expectedCreatedCallCount)
-    {
-        using var control = new TabControl
-        {
-            Multiline = multiline
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Alignment = value;
-        Assert.Equal(value, control.Alignment);
-        Assert.Equal(expectedMultiline, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Alignment = value;
-        Assert.Equal(value, control.Alignment);
-        Assert.Equal(expectedMultiline, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TabAlignment>]
-    public void TabControl_Alignment_SetInvalidValue_ThrowsInvalidEnumArgumentException(TabAlignment value)
-    {
-        using var control = new TabControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Alignment = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabAlignment.Bottom)]
-    [InlineData(TabAlignment.Left)]
-    [InlineData(TabAlignment.Right)]
-    public void TabControl_Appearance_GetFlatButtonsWithAlignment_ReturnsExpected(TabAlignment alignment)
-    {
-        using var control = new TabControl
-        {
-            Appearance = TabAppearance.FlatButtons,
-            Alignment = alignment
-        };
-        Assert.Equal(TabAppearance.Buttons, control.Appearance);
-        Assert.Equal(alignment, control.Alignment);
-        Assert.False(control.IsHandleCreated);
-
-        control.Alignment = TabAlignment.Top;
-        Assert.Equal(TabAppearance.FlatButtons, control.Appearance);
-        Assert.Equal(TabAlignment.Top, control.Alignment);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TabAppearance>]
-    public void TabControl_Appearance_Set_GetReturnsExpected(TabAppearance value)
-    {
-        using var control = new TabControl
-        {
-            Appearance = value
-        };
-        Assert.Equal(value, control.Appearance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Appearance = value;
-        Assert.Equal(value, control.Appearance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabAppearance.Normal, 0)]
-    [InlineData(TabAppearance.Buttons, 1)]
-    [InlineData(TabAppearance.FlatButtons, 1)]
-    public void TabControl_Appearance_SetWithHandle_GetReturnsExpected(TabAppearance value, int expectedCreatedCallCount)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Appearance = value;
-        Assert.Equal(value, control.Appearance);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedCreatedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Appearance = value;
-        Assert.Equal(value, control.Appearance);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedCreatedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TabAppearance>]
-    public void TabControl_Appearance_SetInvalidValue_ThrowsInvalidEnumArgumentException(TabAppearance value)
-    {
-        using var control = new TabControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Appearance = value);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void TabControl_BackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var control = new TabControl
-        {
-            BackColor = value
-        };
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void TabControl_BackColor_SetWithHandle_GetReturnsExpected(Color value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_BackColor_SetWithHandler_DoesNotCallBackColorChanged()
-    {
-        using var control = new TabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(SystemColors.Control, control.BackColor);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void TabControl_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new TabControl
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new TabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void TabControl_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubTabControl
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new TabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void TabControl_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new TabControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DisplayRectangle_Get_ReturnsExpectedAndCreatesHandle()
-    {
-        using var control = new TabControl();
-        Rectangle displayRectangle = control.DisplayRectangle;
-        Assert.True(displayRectangle.X >= 0);
-        Assert.True(displayRectangle.Y >= 0);
-        Assert.Equal(200 - displayRectangle.X * 2, control.DisplayRectangle.Width);
-        Assert.Equal(100 - displayRectangle.Y * 2, control.DisplayRectangle.Height);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(displayRectangle, control.DisplayRectangle);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DisplayRectangle_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Rectangle displayRectangle = control.DisplayRectangle;
-        Assert.True(displayRectangle.X >= 0);
-        Assert.True(displayRectangle.Y >= 0);
-        Assert.Equal(200 - displayRectangle.X * 2, control.DisplayRectangle.Width);
-        Assert.Equal(100 - displayRectangle.Y * 2, control.DisplayRectangle.Height);
-        Assert.Equal(displayRectangle, control.DisplayRectangle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DisplayRectangle_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        Rectangle displayRectangle = control.DisplayRectangle;
-        Assert.True(displayRectangle.X >= 0);
-        Assert.True(displayRectangle.Y >= 0);
-        Assert.Equal(200 - displayRectangle.X * 2, control.DisplayRectangle.Width);
-        Assert.Equal(100 - displayRectangle.Y * 2, control.DisplayRectangle.Height);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(displayRectangle, control.DisplayRectangle);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabControl_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubTabControl();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabControl_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTabControl
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabControl_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TabDrawMode>]
-    public void TabControl_DrawMode_Set_GetReturnsExpected(TabDrawMode value)
-    {
-        using var control = new TabControl
-        {
-            DrawMode = value
-        };
-        Assert.Equal(value, control.DrawMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabDrawMode.Normal, 0)]
-    [InlineData(TabDrawMode.OwnerDrawFixed, 1)]
-    public void TabControl_DrawMode_SetWithHandle_GetReturnsExpected(TabDrawMode value, int expectedCreatedCallCount)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TabDrawMode>]
-    public void TabControl_DrawMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(TabDrawMode value)
-    {
-        using var control = new TabControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DrawMode = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void TabControl_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TabControl
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.Empty, Control.DefaultForeColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void TabControl_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new TabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(TabControl.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_Handle_GetNoImageList_Success()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Handle_GetWithImageList_Success()
-    {
-        using var imageList = new ImageList();
-        using var control = new TabControl
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal((nint)imageList.Handle, (nint)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Handle_GetItemsEmpty_Success()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMCOUNT));
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabControl_Handle_GetItems_Success(string text, string expectedText)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(3, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabControl_HotTrack_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTabControl
-        {
-            HotTrack = value
-        };
-        Assert.Equal(value, control.HotTrack);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HotTrack = value;
-        Assert.Equal(value, control.HotTrack);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HotTrack = !value;
-        Assert.Equal(!value, control.HotTrack);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TabControl_HotTrack_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HotTrack = value;
-        Assert.Equal(value, control.HotTrack);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.HotTrack = value;
-        Assert.Equal(value, control.HotTrack);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.HotTrack = !value;
-        Assert.Equal(!value, control.HotTrack);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ImageList_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ImageList() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void TabControl_ImageList_Set_GetReturnsExpected(ImageList value)
-    {
-        using var control = new TabControl
-        {
-            ImageList = value
-        };
-        Assert.Same(value, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void TabControl_ImageList_SetWithNonNullOldValue_GetReturnsExpected(ImageList value)
-    {
-        using var oldValue = new ImageList();
-        using var control = new TabControl
-        {
-            ImageList = oldValue
-        };
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void TabControl_ImageList_SetWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_Set_TestData))]
-    public void TabControl_ImageList_SetWithHandleWithNonNullOldValue_GetReturnsExpected(ImageList value)
-    {
-        using var oldValue = new ImageList();
-        using var control = new TabControl
-        {
-            ImageList = oldValue
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageList = value;
-        Assert.Same(value, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_SetWithTabPages_Success()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        using var imageList = new ImageList();
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var image3 = new Bitmap(10, 10);
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        imageList.Images.Add(image3);
-        control.ImageList = imageList;
-        Assert.Same(imageList, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.ImageList = null;
-        Assert.Null(control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_Set_CreatesImageHandle()
-    {
-        using var control = new TabControl();
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.True(imageList.HandleCreated);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_SetGetImageListWithHandle_Success()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        // Set non-null.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.True(imageList.HandleCreated);
-        Assert.Equal((nint)imageList.Handle, (nint)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-
-        // Set null.
-        control.ImageList = null;
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_Dispose_DetachesFromTabControl()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var control = new TabControl
-        {
-            ImageList = imageList1
-        };
-        Assert.Same(imageList1, control.ImageList);
-
-        imageList1.Dispose();
-        Assert.Null(control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_DisposeWithHandle_DetachesFromTabControl()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = imageList1;
-        Assert.Same(imageList1, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.Dispose();
-        Assert.Null(control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, control.ImageList);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_RecreateHandle_Nop()
-    {
-        using var imageList1 = new ImageList();
-        int recreateCallCount1 = 0;
-        imageList1.RecreateHandle += (sender, e) => recreateCallCount1++;
-        using var imageList2 = new ImageList();
-        using var control = new TabControl
-        {
-            ImageList = imageList1
-        };
-        Assert.Same(imageList1, control.ImageList);
-        Assert.Equal(0, recreateCallCount1);
-
-        imageList1.ImageSize = new Size(1, 2);
-        Assert.Equal(1, recreateCallCount1);
-        Assert.Same(imageList1, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.ImageSize = new Size(2, 3);
-        Assert.Equal(2, recreateCallCount1);
-        Assert.Same(imageList2, control.ImageList);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ImageList_RecreateHandleWithHandle_Success()
-    {
-        using var imageList1 = new ImageList();
-        int recreateCallCount1 = 0;
-        imageList1.RecreateHandle += (sender, e) => recreateCallCount1++;
-        using var imageList2 = new ImageList();
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageList = imageList1;
-        Assert.Same(imageList1, control.ImageList);
-        Assert.Equal(0, recreateCallCount1);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        imageList1.ImageSize = new Size(1, 2);
-        Assert.Equal(1, recreateCallCount1);
-        Assert.Same(imageList1, control.ImageList);
-        Assert.Equal((nint)imageList1.Handle, (nint)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Make sure we detached the setter.
-        control.ImageList = imageList2;
-        imageList1.ImageSize = new Size(2, 3);
-        Assert.Equal(2, recreateCallCount1);
-        Assert.Same(imageList2, control.ImageList);
-        Assert.Equal((nint)imageList2.Handle, (nint)PInvoke.SendMessage(control, PInvoke.TCM_GETIMAGELIST));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_GetEmptyWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Size size = control.ItemSize;
-        Assert.Equal(0, size.Width);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, control.ItemSize);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_GetNotEmptyWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Size size = control.ItemSize;
-        Assert.True(size.Width > 0);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, control.ItemSize);
-    }
-
-    public static IEnumerable<object[]> ItemSize_Set_TestData()
-    {
-        yield return new object[] { new Size(0, 0) };
-        yield return new object[] { new Size(0, 16) };
-        yield return new object[] { new Size(16, 0) };
-        yield return new object[] { new Size(16, 16) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemSize_Set_TestData))]
-    public void TabControl_ItemSize_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new TabControl
-        {
-            ItemSize = value
-        };
-        Assert.Equal(value, control.ItemSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ItemSize = value;
-        Assert.Equal(value, control.ItemSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ItemSize_SetWithHandle_TestData()
-    {
-        yield return new object[] { new Size(0, 16) };
-        yield return new object[] { new Size(16, 0) };
-        yield return new object[] { new Size(16, 16) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemSize_SetWithHandle_TestData))]
-    public void TabControl_ItemSize_SetWithHandle_GetReturnsExpected(Size value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ItemSize = value;
-        Assert.Equal(value, control.ItemSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ItemSize = value;
-        Assert.Equal(value, control.ItemSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SetEmptyWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl
-        {
-            ItemSize = new Size(16, 16)
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ItemSize = Size.Empty;
-        Size size = control.ItemSize;
-        Assert.Equal(0, size.Width);
-        Assert.True(size.Height > 0);
-        Assert.Equal(size, control.ItemSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabControl))[nameof(TabControl.ItemSize)];
-        using var control = new TabControl();
-        Assert.False(property.CanResetValue(control));
-
-        control.ItemSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.ItemSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.ItemSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.ItemSize);
-        Assert.True(property.CanResetValue(control));
-
-        control.ItemSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.ItemSize);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.ItemSize);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabControl))[nameof(TabControl.ItemSize)];
-        using var control = new TabControl();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.ItemSize = new Size(1, 0);
-        Assert.Equal(new Size(1, 0), control.ItemSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.ItemSize = new Size(0, 1);
-        Assert.Equal(new Size(0, 1), control.ItemSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.ItemSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.ItemSize);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(Size.Empty, control.ItemSize);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_SetNegativeWidth_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ItemSize = new Size(-1, 1));
-    }
-
-    [WinFormsFact]
-    public void TabControl_ItemSize_SetNegativeHeight_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ItemSize = new Size(1, -1));
-    }
-
-    public static IEnumerable<object[]> Multiline_Set_TestData()
-    {
-        yield return new object[] { TabAlignment.Bottom, true, TabAlignment.Bottom, TabAlignment.Bottom };
-        yield return new object[] { TabAlignment.Left, true, TabAlignment.Left, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Right, true, TabAlignment.Right, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Top, true, TabAlignment.Top, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Bottom, false, TabAlignment.Bottom, TabAlignment.Bottom };
-        yield return new object[] { TabAlignment.Left, false, TabAlignment.Top, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Right, false, TabAlignment.Top, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Top, false, TabAlignment.Top, TabAlignment.Top };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Multiline_Set_TestData))]
-    public void TabControl_Multiline_Set_GetReturnsExpected(TabAlignment alignment, bool value, TabAlignment expectedAlignment1, TabAlignment expectedAlignment2)
-    {
-        using var control = new SubTabControl
-        {
-            Alignment = alignment,
-            Multiline = value
-        };
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedAlignment1, control.Alignment);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedAlignment1, control.Alignment);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.Equal(expectedAlignment2, control.Alignment);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Multiline_SetWithHandle_TestData()
-    {
-        yield return new object[] { TabAlignment.Bottom, true, TabAlignment.Bottom, 1, TabAlignment.Bottom };
-        yield return new object[] { TabAlignment.Left, true, TabAlignment.Left, 0, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Right, true, TabAlignment.Right, 0, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Top, true, TabAlignment.Top, 1, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Bottom, false, TabAlignment.Bottom, 0, TabAlignment.Bottom };
-        yield return new object[] { TabAlignment.Left, false, TabAlignment.Top, 1, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Right, false, TabAlignment.Top, 1, TabAlignment.Top };
-        yield return new object[] { TabAlignment.Top, false, TabAlignment.Top, 0, TabAlignment.Top };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Multiline_SetWithHandle_TestData))]
-    public void TabControl_Multiline_SetWithHandle_GetReturnsExpected(TabAlignment alignment, bool value, TabAlignment expectedAlignment1, int expectedCreatedCallCount, TabAlignment expectedAlignment2)
-    {
-        using var control = new SubTabControl
-        {
-            Alignment = alignment
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedAlignment1, control.Alignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(expectedAlignment1, control.Alignment);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(expectedAlignment2, control.Alignment);
-        Assert.Equal(!value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Padding_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0) };
-        yield return new object[] { new Point(0, 16) };
-        yield return new object[] { new Point(16, 0) };
-        yield return new object[] { new Point(16, 16) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Set_TestData))]
-    public void TabControl_Padding_Set_GetReturnsExpected(Point value)
-    {
-        using var control = new TabControl
-        {
-            Padding = value
-        };
-        Assert.Equal(value, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(value, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_Set_TestData))]
-    public void TabControl_Padding_SetWithHandle_GetReturnsExpected(Point value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Padding = value;
-        Assert.Equal(value, control.Padding);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(value, control.Padding);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_Padding_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabControl))[nameof(TabControl.Padding)];
-        using var control = new TabControl();
-        Assert.False(property.CanResetValue(control));
-
-        control.Padding = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Padding);
-        Assert.True(property.CanResetValue(control));
-
-        control.Padding = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Padding);
-        Assert.True(property.CanResetValue(control));
-
-        control.Padding = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Padding);
-        Assert.True(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Point(6, 3), control.Padding);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Padding_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabControl))[nameof(TabControl.Padding)];
-        using var control = new TabControl();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Padding = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Padding);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Padding = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Padding);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Padding = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Padding);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Point(6, 3), control.Padding);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Padding_SetNegativeX_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Padding = new Point(-1, 1));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Padding_SetNegativeY_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Padding = new Point(1, -1));
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1)]
-    [InlineData(RightToLeft.Yes, false, 0)]
-    [InlineData(RightToLeft.No, true, 1)]
-    [InlineData(RightToLeft.No, false, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1)]
-    [InlineData(RightToLeft.Inherit, false, 0)]
-    public void TabControl_RightToLeftLayout_Set_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new TabControl
-        {
-            RightToLeft = rightToLeft
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1, 1, 2)]
-    [InlineData(RightToLeft.Yes, false, 0, 0, 1)]
-    [InlineData(RightToLeft.No, true, 1, 0, 0)]
-    [InlineData(RightToLeft.No, false, 0, 0, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1, 0, 0)]
-    [InlineData(RightToLeft.Inherit, false, 0, 0, 0)]
-    public void TabControl_RightToLeftLayout_SetWithHandle_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new TabControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RightToLeftLayout_SetWithHandler_CallsRightToLeftLayoutChanged()
-    {
-        using var control = new TabControl
-        {
-            RightToLeftLayout = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftLayoutChanged += handler;
-
-        // Set different.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeftLayout = true;
-        Assert.True(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RightToLeftLayout_SetWithHandlerInDisposing_DoesNotRightToLeftLayoutChanged()
-    {
-        using var control = new TabControl
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeftLayout = true;
-            Assert.True(control.RightToLeftLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RowCount_Get_ReturnsExpectedAndCreatesHandle()
-    {
-        using var control = new TabControl();
-        Assert.Equal(0, control.RowCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RowCount_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, control.RowCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(-1, control.SelectedIndex);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_GetWithPagesWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(0, control.SelectedIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabControl_SelectedIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new TabControl
-        {
-            SelectedIndex = value
-        };
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabControl_SelectedIndex_SetWithPages_GetReturnsExpected(int value)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value < 0 || value >= control.TabPages.Count ? null : control.TabPages[value], control.SelectedTab);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(value < 0 || value >= control.TabPages.Count ? null : control.TabPages[value], control.SelectedTab);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabControl_SelectedIndex_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedIndex = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedTab);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedTab);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1, new bool[] { false, false })]
-    [InlineData(0, 0, new bool[] { true, false })]
-    [InlineData(1, 1, new bool[] { false, true })]
-    [InlineData(2, 0, new bool[] { true, false })]
-    public void TabControl_SelectedIndex_SetWithPagesWithHandle_GetReturnsExpected(int value, int expected, bool[] expectedVisible)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedIndex = value;
-        Assert.Equal(expected, control.SelectedIndex);
-        Assert.Equal(expected == -1 ? null : control.TabPages[expected], control.SelectedTab);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible));
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(expected, control.SelectedIndex);
-        Assert.Equal(expected == -1 ? null : control.TabPages[expected], control.SelectedTab);
-        Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_SetWithHandler_CallsSelectedIndexChanged()
-    {
-        using var control = new TabControl();
-        int deselectingCallCount = 0;
-        int deselectedCallCount = 0;
-        int selectingCallCount = 0;
-        int selectedCallCount = 0;
-        int selectedIndexChangedCallCount = 0;
-        void deselectingHandler(object sender, TabControlCancelEventArgs e) => deselectingCallCount++;
-        void deselectedHandler(object sender, TabControlEventArgs e) => deselectedCallCount++;
-        void selectingHandler(object sender, TabControlCancelEventArgs e) => selectingCallCount++;
-        void selectedHandler(object sender, TabControlEventArgs e) => selectedCallCount++;
-        void selectedIndexChangedHandler(object sender, EventArgs e) => selectedIndexChangedCallCount++;
-        control.Deselecting += deselectingHandler;
-        control.Deselected += deselectedHandler;
-        control.Selecting += selectingHandler;
-        control.Selected += selectedHandler;
-        control.SelectedIndexChanged += selectedIndexChangedHandler;
-
-        // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal(0, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Remove handler.
-        control.Deselecting -= deselectingHandler;
-        control.Deselected -= deselectedHandler;
-        control.Selecting -= selectingHandler;
-        control.Selected -= selectedHandler;
-        control.SelectedIndexChanged -= selectedIndexChangedHandler;
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(0, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_SetWithHandleWithHandler_CallsSelectedIndexChanged()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int deselectingCallCount = 0;
-        int deselectedCallCount = 0;
-        int selectingCallCount = 0;
-        int selectedCallCount = 0;
-        int selectedIndexChangedCallCount = 0;
-        void deselectingHandler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Deselecting, e.Action);
-            Assert.False(e.Cancel);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(deselectingCallCount, deselectedCallCount);
-            Assert.Equal(deselectingCallCount, selectingCallCount);
-            Assert.Equal(deselectingCallCount, selectedCallCount);
-            Assert.Equal(deselectingCallCount, selectedIndexChangedCallCount);
-            deselectingCallCount++;
-        }
-
-        void deselectedHandler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Deselected, e.Action);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(deselectedCallCount, selectingCallCount);
-            Assert.Equal(deselectedCallCount, selectedCallCount);
-            Assert.Equal(deselectedCallCount, selectedIndexChangedCallCount);
-            deselectedCallCount++;
-        }
-
-        void selectingHandler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Selecting, e.Action);
-            Assert.False(e.Cancel);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(selectingCallCount, selectedCallCount);
-            Assert.Equal(selectingCallCount, selectedIndexChangedCallCount);
-            selectingCallCount++;
-        }
-
-        void selectedHandler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Selected, e.Action);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(selectedCallCount, selectedIndexChangedCallCount);
-            selectedCallCount++;
-        }
-
-        void selectedIndexChangedHandler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            selectedIndexChangedCallCount++;
-        }
-
-        control.Deselecting += deselectingHandler;
-        control.Deselected += deselectedHandler;
-        control.Selecting += selectingHandler;
-        control.Selected += selectedHandler;
-        control.SelectedIndexChanged += selectedIndexChangedHandler;
-
-        // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, deselectingCallCount);
-        Assert.Equal(1, deselectedCallCount);
-        Assert.Equal(1, selectingCallCount);
-        Assert.Equal(1, selectedCallCount);
-        Assert.Equal(1, selectedIndexChangedCallCount);
-
-        // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, deselectingCallCount);
-        Assert.Equal(2, deselectedCallCount);
-        Assert.Equal(2, selectingCallCount);
-        Assert.Equal(2, selectedCallCount);
-        Assert.Equal(2, selectedIndexChangedCallCount);
-
-        // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(3, deselectedCallCount);
-        Assert.Equal(3, selectingCallCount);
-        Assert.Equal(3, selectedCallCount);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-
-        // Remove handler.
-        control.Deselecting -= deselectingHandler;
-        control.Deselected -= deselectedHandler;
-        control.Selecting -= selectingHandler;
-        control.Selected -= selectedHandler;
-        control.SelectedIndexChanged -= selectedIndexChangedHandler;
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(3, deselectedCallCount);
-        Assert.Equal(3, selectingCallCount);
-        Assert.Equal(3, selectedCallCount);
-        Assert.Equal(3, selectedIndexChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_SetWithHandleWithHandlerCancelDeselecting_DoesNotCallSelectedIndexChanged()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int deselectingCallCount = 0;
-        int deselectedCallCount = 0;
-        int selectingCallCount = 0;
-        int selectedCallCount = 0;
-        int selectedIndexChangedCallCount = 0;
-        void deselectingHandler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Deselecting, e.Action);
-            Assert.False(e.Cancel);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(0, deselectedCallCount);
-            Assert.Equal(0, selectingCallCount);
-            Assert.Equal(0, selectedCallCount);
-            Assert.Equal(0, selectedIndexChangedCallCount);
-            deselectingCallCount++;
-
-            e.Cancel = true;
-        }
-
-        void deselectedHandler(object sender, TabControlEventArgs e) => deselectedCallCount++;
-        void selectingHandler(object sender, TabControlCancelEventArgs e) => selectingCallCount++;
-        void selectedHandler(object sender, TabControlEventArgs e) => selectedCallCount++;
-        void selectedIndexChangedHandler(object sender, EventArgs e) => selectedIndexChangedCallCount++;
-        control.Deselecting += deselectingHandler;
-        control.Deselected += deselectedHandler;
-        control.Selecting += selectingHandler;
-        control.Selected += selectedHandler;
-        control.SelectedIndexChanged += selectedIndexChangedHandler;
-
-        // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Remove handler.
-        control.Deselecting -= deselectingHandler;
-        control.Deselected -= deselectedHandler;
-        control.Selecting -= selectingHandler;
-        control.Selected -= selectedHandler;
-        control.SelectedIndexChanged -= selectedIndexChangedHandler;
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(0, deselectedCallCount);
-        Assert.Equal(0, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_SetWithHandleWithHandlerCancelSelecting_DoesNotCallSelectedIndexChanged()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int deselectingCallCount = 0;
-        int deselectedCallCount = 0;
-        int selectingCallCount = 0;
-        int selectedCallCount = 0;
-        int selectedIndexChangedCallCount = 0;
-        void deselectingHandler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Deselecting, e.Action);
-            Assert.False(e.Cancel);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(deselectingCallCount, deselectedCallCount);
-            Assert.Equal(deselectingCallCount, selectingCallCount);
-            Assert.Equal(0, selectedCallCount);
-            Assert.Equal(0, selectedIndexChangedCallCount);
-            deselectingCallCount++;
-        }
-
-        void deselectedHandler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Deselected, e.Action);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(deselectedCallCount, selectingCallCount);
-            Assert.Equal(0, selectedCallCount);
-            Assert.Equal(0, selectedIndexChangedCallCount);
-            deselectedCallCount++;
-        }
-
-        void selectingHandler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TabControlAction.Selecting, e.Action);
-            Assert.False(e.Cancel);
-            Assert.Null(e.TabPage);
-            Assert.Equal(control.SelectedIndex, e.TabPageIndex);
-            Assert.Equal(0, selectedCallCount);
-            Assert.Equal(0, selectedIndexChangedCallCount);
-            selectingCallCount++;
-
-            e.Cancel = true;
-        }
-
-        void selectedHandler(object sender, TabControlEventArgs e) => selectedCallCount++;
-        void selectedIndexChangedHandler(object sender, EventArgs e) => selectedIndexChangedCallCount++;
-        control.Deselecting += deselectingHandler;
-        control.Deselected += deselectedHandler;
-        control.Selecting += selectingHandler;
-        control.Selected += selectedHandler;
-        control.SelectedIndexChanged += selectedIndexChangedHandler;
-
-        // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(1, deselectingCallCount);
-        Assert.Equal(1, deselectedCallCount);
-        Assert.Equal(1, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, deselectingCallCount);
-        Assert.Equal(2, deselectedCallCount);
-        Assert.Equal(2, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(3, deselectedCallCount);
-        Assert.Equal(3, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-
-        // Remove handler.
-        control.Deselecting -= deselectingHandler;
-        control.Deselected -= deselectedHandler;
-        control.Selecting -= selectingHandler;
-        control.Selected -= selectedHandler;
-        control.SelectedIndexChanged -= selectedIndexChangedHandler;
-        control.SelectedIndex = 0;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(3, deselectingCallCount);
-        Assert.Equal(3, deselectedCallCount);
-        Assert.Equal(3, selectingCallCount);
-        Assert.Equal(0, selectedCallCount);
-        Assert.Equal(0, selectedIndexChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedIndex_SetInvalid_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = -2);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedTab_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Null(control.SelectedTab);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedTab_GetWithPagesWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabControl_SelectedTab_GetWithInvalidIndexNotGotPages_ReturnsNull(int value)
-    {
-        using var control = new TabControl
-        {
-            SelectedIndex = value
-        };
-        Assert.Null(control.SelectedTab);
-
-        Assert.Empty(control.TabPages);
-        Assert.Null(control.SelectedTab);
-    }
-
-    public static IEnumerable<object[]> SelectedTab_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TabPage() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedTab_Set_TestData))]
-    public void TabControl_SelectedTab_SetWithoutPages_GetReturnsExpected(TabPage value)
-    {
-        using var control = new TabControl
-        {
-            SelectedTab = value
-        };
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedTab = value;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedTab_SetWithPages_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Set valid.
-        control.SelectedTab = page2;
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set same.
-        control.SelectedTab = page2;
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set invalid.
-        control.SelectedTab = page3;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set different.
-        control.SelectedTab = page1;
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set invalid.
-        control.SelectedTab = null;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedTab_Set_TestData))]
-    public void TabControl_SelectedTab_SetWithoutPagesWithHandle_GetReturnsExpected(TabPage value)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedTab = value;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectedTab = value;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectedTab_SetWithPagesWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set valid.
-        control.SelectedTab = page2;
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set same.
-        control.SelectedTab = page2;
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set invalid.
-        control.SelectedTab = page3;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set different.
-        control.SelectedTab = page1;
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set invalid.
-        control.SelectedTab = null;
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TabSizeMode>]
-    public void TabControl_SizeMode_Set_GetReturnsExpected(TabSizeMode value)
-    {
-        using var control = new TabControl
-        {
-            SizeMode = value
-        };
-        Assert.Equal(value, control.SizeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SizeMode = value;
-        Assert.Equal(value, control.SizeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TabSizeMode.Normal, 0)]
-    [InlineData(TabSizeMode.FillToRight, 1)]
-    [InlineData(TabSizeMode.Fixed, 1)]
-    public void TabControl_SizeMode_SetWithHandle_GetReturnsExpected(TabSizeMode value, int expectedCreatedCallCount)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SizeMode = value;
-        Assert.Equal(value, control.SizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.SizeMode = value;
-        Assert.Equal(value, control.SizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TabSizeMode>]
-    public void TabControl_SizeMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(TabSizeMode value)
-    {
-        using var control = new TabControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.SizeMode = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabControl_ShowToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTabControl
-        {
-            ShowToolTips = value
-        };
-        Assert.Equal(value, control.ShowToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowToolTips = value;
-        Assert.Equal(value, control.ShowToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowToolTips = !value;
-        Assert.Equal(!value, control.ShowToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TabControl_ShowToolTips_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ShowToolTips = value;
-        Assert.Equal(value, control.ShowToolTips);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.ShowToolTips = value;
-        Assert.Equal(value, control.ShowToolTips);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.ShowToolTips = !value;
-        Assert.Equal(!value, control.ShowToolTips);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabControl_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabControl
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabControl_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new TabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        Control.ControlCollection controls = Assert.IsType<TabControl.ControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.False(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    [WinFormsFact]
-    public void TabControl_CreateHandle_Invoke_Success()
-    {
-        using var control = new SubTabControl();
-        control.CreateHandle();
-        Assert.False(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeTabPageWithoutHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Deselect first.
-        control.DeselectTab(page1);
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Select and deselect first.
-        control.SelectTab(page1);
-        control.DeselectTab(page1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect again.
-        control.DeselectTab(page1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect last.
-        control.DeselectTab(page2);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeTabPageWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect first.
-        control.DeselectTab(page1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Select and deselect first.
-        control.SelectTab(0);
-        control.DeselectTab(page1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect again.
-        control.DeselectTab(page1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect last.
-        control.DeselectTab(page2);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(2, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvalidTabPageNameWithoutPages_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.DeselectTab(page));
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvalidTabPageNameWithPages_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.DeselectTab(page3));
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeStringWithoutHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage
-        {
-            Name = "Name1"
-        };
-        using var page2 = new TabPage
-        {
-            Name = "Name2"
-        };
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Deselect first.
-        control.DeselectTab("Name1");
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Select and deselect first.
-        control.SelectTab("Name1");
-        control.DeselectTab("Name1");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect again.
-        control.DeselectTab("Name1");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect last.
-        control.DeselectTab("Name2");
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeStringWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage
-        {
-            Name = "Name1"
-        };
-        using var page2 = new TabPage
-        {
-            Name = "Name2"
-        };
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect first.
-        control.DeselectTab("Name1");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Select and deselect first.
-        control.SelectTab(0);
-        control.DeselectTab("Name1");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect again.
-        control.DeselectTab("Name1");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect last.
-        control.DeselectTab("Name2");
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(2, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_NullTabPageName_ThrowsArgumentNullException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentNullException>("tabPageName", () => control.DeselectTab((string)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    public void TabControl_DeselectTab_InvalidTabPageNameWithoutPages_ThrowsArgumentNullException(string tabPageName)
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentNullException>("tabPage", () => control.DeselectTab(tabPageName));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    public void TabControl_DeselectTab_InvalidTabPageNameWithPages_ThrowsArgumentNullException(string tabPageName)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentNullException>("tabPage", () => control.DeselectTab(tabPageName));
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeIntWithoutHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Deselect first.
-        control.DeselectTab(0);
-        Assert.Null(control.SelectedTab);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Select and deselect first.
-        control.SelectTab(0);
-        control.DeselectTab(0);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect again.
-        control.DeselectTab(0);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect last.
-        control.DeselectTab(1);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_DeselectTab_InvokeIntWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Deselect first.
-        control.DeselectTab(0);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Select and deselect first.
-        control.SelectTab(0);
-        control.DeselectTab(0);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect again.
-        control.DeselectTab(0);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Deselect last.
-        control.DeselectTab(1);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(2, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabControl_DeselectTab_InvalidIndexWithoutPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.DeselectTab(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabControl_DeselectTab_InvalidIndexWithPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.DeselectTab(index));
-    }
-
-    [WinFormsFact]
-    public void TabControl_Dispose_InvokeWithImageList_DetachesImageList()
-    {
-        using var control = new TabControl();
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        control.Dispose();
-        Assert.Same(imageList, control.ImageList);
-
-        imageList.Dispose();
-        Assert.Same(imageList, control.ImageList);
-    }
-
-    [WinFormsFact]
-    public void TabControl_Dispose_InvokeDisposingWithImageList_DetachesImageList()
-    {
-        using var control = new SubTabControl();
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        control.Dispose(true);
-        Assert.Same(imageList, control.ImageList);
-
-        imageList.Dispose();
-        Assert.Same(imageList, control.ImageList);
-    }
-
-    [WinFormsFact]
-    public void TabControl_Dispose_InvokeNotDisposingWithImageList_DoesNotDetachImageList()
-    {
-        using var control = new SubTabControl();
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        control.Dispose(false);
-        Assert.Same(imageList, control.ImageList);
-
-        imageList.Dispose();
-        Assert.Null(control.ImageList);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabControl_GetControl_Invoke_ReturnsExpected(int index)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Same(control.TabPages[index], control.GetControl(index));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabControl_GetControl_InvokeWithoutPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new SubTabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetControl(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabControl_GetControl_InvokeInvalidIndexWithPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetControl(index));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvokeWithoutHandle_ReturnsExpectedAndCreatedHandle()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        Rectangle rect1 = control.GetTabRect(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetTabRect(0));
-        Assert.True(control.IsHandleCreated);
-
-        Rectangle rect2 = control.GetTabRect(1);
-        Assert.True(rect2.X >= rect1.X + rect1.Width);
-        Assert.Equal(rect2.Y, rect1.Y);
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvokeWithHandle_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Rectangle rect1 = control.GetTabRect(0);
-        Assert.True(rect1.X >= 0);
-        Assert.True(rect1.Y >= 0);
-        Assert.True(rect1.Width > 0);
-        Assert.True(rect1.Height > 0);
-        Assert.Equal(rect1, control.GetTabRect(0));
-        Assert.True(control.IsHandleCreated);
-
-        Rectangle rect2 = control.GetTabRect(1);
-        Assert.True(rect2.X >= rect1.X + rect1.Width);
-        Assert.Equal(rect2.Y, rect1.Y);
-        Assert.True(rect2.Width > 0);
-        Assert.True(rect2.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetTabRect_InvokeCustomGetItemRect_TestData()
-    {
-        yield return new object[] { new RECT(), Rectangle.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Rectangle(1, 2, 2, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetTabRect_InvokeCustomGetItemRect_TestData))]
-    public void TabControl_GetTabRect_InvokeCustomGetItemRect_ReturnsExpected(object getItemRectResult, Rectangle expected)
-    {
-        using var control = new CustomGetItemRectTabControl
-        {
-            GetItemRectResult = (RECT)getItemRectResult
-        };
-        using var page = new TabPage();
-        control.TabPages.Add(page);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, control.GetTabRect(0));
-    }
-
-    private class CustomGetItemRectTabControl : TabControl
-    {
-        public RECT GetItemRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.TCM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetItemRectResult;
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvokeInvalidGetItemRect_ReturnsExpected()
-    {
-        using var control = new InvalidGetItemRectTabControl();
-        using var page = new TabPage();
-        control.TabPages.Add(page);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Equal(new Rectangle(1, 2, 2, 2), control.GetTabRect(0));
-    }
-
-    private class InvalidGetItemRectTabControl : TabControl
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.TCM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = new RECT(1, 2, 3, 4);
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvalidIndexEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(1));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvalidIndexNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        control.TabPages.Add(page1);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(2));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvalidIndexWithHandleEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(0));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(1));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTabRect_InvalidIndexWithHandleNotEmpty_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        control.TabPages.Add(page1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(-1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(1));
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.GetTabRect(2));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeWithoutPages_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        object[] result = Assert.IsType<TabPage[]>(control.GetItems());
-        Assert.Empty(result);
-        Assert.Same(result, control.GetItems());
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeWithPages_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new SubTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        object[] result = Assert.IsType<TabPage[]>(control.GetItems());
-        Assert.Equal(new object[] { page1, page2 }, result);
-        Assert.NotSame(result, control.GetItems());
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(object))]
-    [InlineData(typeof(TabPage))]
-    public void TabControl_GetItems_InvokeTypeWithoutPages_ReturnsExpected(Type baseType)
-    {
-        using var control = new SubTabControl();
-        object[] result = control.GetItems(baseType);
-        Assert.Empty(result);
-        Assert.IsType(baseType.MakeArrayType(), result);
-        Assert.NotSame(result, control.GetItems());
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(TabPage))]
-    [InlineData(typeof(Control))]
-    [InlineData(typeof(object))]
-    public void TabControl_GetItems_InvokeTypeBaseTypeWithPages_ReturnsExpected(Type baseType)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new SubTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        object[] result = control.GetItems(baseType);
-        Assert.IsType(baseType.MakeArrayType(), result);
-        Assert.Equal(new object[] { page1, page2 }, result);
-        Assert.NotSame(result, control.GetItems(baseType));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeTypeSubTypeWithPages_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        using var page = new SubTabPage();
-        control.TabPages.Add(page);
-        object[] result = Assert.IsType<SubTabPage[]>(control.GetItems(typeof(SubTabPage)));
-        Assert.Equal(new object[] { page }, result);
-        Assert.NotSame(result, control.GetItems(typeof(SubTabPage)));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeNullBaseType_ThrowsArgumentNullException()
-    {
-        using var control = new SubTabControl();
-        Assert.Throws<ArgumentNullException>("elementType", () => control.GetItems(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(int))]
-    public void TabControl_GetItems_InvokeInvalidTypeWithoutPages_ThrowsInvalidCastException(Type baseType)
-    {
-        using var control = new SubTabControl();
-        Assert.Throws<InvalidCastException>(() => control.GetItems(baseType));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeInvalidTypeWithPages_ThrowsInvalidCastException()
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new SubTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<InvalidCastException>(() => control.GetItems(typeof(int)));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetItems_InvokeInvalidInheritedTypeWithPages_ThrowsArrayTypeMismatchException()
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new SubTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArrayTypeMismatchException>(() => control.GetItems(typeof(SubTabPage)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TabControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTabControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetToolTipText_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabControl();
-        using var item = new TabPage
-        {
-            ToolTipText = "text"
-        };
-        Assert.Equal("text", control.GetToolTipText(item));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetToolTipText_NullItem_ThrowsArgumentNullException()
-    {
-        using var control = new SubTabControl();
-        Assert.Throws<ArgumentNullException>("item", () => control.GetToolTipText(null));
-    }
-
-    [WinFormsFact]
-    public void TabControl_GetToolTipText_ItemNotTabPage_ThrowsArgumentException()
-    {
-        using var control = new SubTabControl();
-        Assert.Throws<ArgumentException>("item", () => control.GetToolTipText(new object()));
-    }
-
-    public static IEnumerable<object[]> IsInputKey_TestData()
-    {
-        yield return new object[] { Keys.Tab, false };
-        yield return new object[] { Keys.Return, false };
-        yield return new object[] { Keys.Escape, false };
-        yield return new object[] { Keys.A, false };
-        yield return new object[] { Keys.C, false };
-        yield return new object[] { Keys.Insert, false };
-        yield return new object[] { Keys.Space, false };
-        yield return new object[] { Keys.Home, true };
-        yield return new object[] { Keys.End, true };
-        ;
-        yield return new object[] { Keys.Back, false };
-        yield return new object[] { Keys.Next, true };
-        yield return new object[] { Keys.Prior, true };
-        yield return new object[] { Keys.Delete, false };
-        yield return new object[] { Keys.D0, false };
-        yield return new object[] { Keys.NumPad0, false };
-        yield return new object[] { Keys.F1, false };
-        yield return new object[] { Keys.F2, false };
-        yield return new object[] { Keys.F3, false };
-        yield return new object[] { Keys.F4, false };
-        yield return new object[] { Keys.RButton, false };
-        yield return new object[] { Keys.PageUp, true };
-        yield return new object[] { Keys.PageDown, true };
-        yield return new object[] { Keys.None, false };
-
-        yield return new object[] { Keys.Control | Keys.Tab, false };
-        yield return new object[] { Keys.Control | Keys.Return, false };
-        yield return new object[] { Keys.Control | Keys.Escape, false };
-        yield return new object[] { Keys.Control | Keys.A, false };
-        yield return new object[] { Keys.Control | Keys.C, false };
-        yield return new object[] { Keys.Control | Keys.Insert, false };
-        yield return new object[] { Keys.Control | Keys.Space, false };
-        yield return new object[] { Keys.Control | Keys.Home, true };
-        yield return new object[] { Keys.Control | Keys.End, true };
-        ;
-        yield return new object[] { Keys.Control | Keys.Back, false };
-        yield return new object[] { Keys.Control | Keys.Next, true };
-        yield return new object[] { Keys.Control | Keys.Prior, true };
-        yield return new object[] { Keys.Control | Keys.Delete, false };
-        yield return new object[] { Keys.Control | Keys.D0, false };
-        yield return new object[] { Keys.Control | Keys.NumPad0, false };
-        yield return new object[] { Keys.Control | Keys.F1, false };
-        yield return new object[] { Keys.Control | Keys.F2, false };
-        yield return new object[] { Keys.Control | Keys.F3, false };
-        yield return new object[] { Keys.Control | Keys.F4, false };
-        yield return new object[] { Keys.Control | Keys.RButton, false };
-        yield return new object[] { Keys.Control | Keys.PageUp, true };
-        yield return new object[] { Keys.Control | Keys.PageDown, true };
-        yield return new object[] { Keys.Control | Keys.None, false };
-
-        yield return new object[] { Keys.Alt | Keys.Tab, false };
-        yield return new object[] { Keys.Alt | Keys.Up, false };
-        yield return new object[] { Keys.Alt | Keys.Down, false };
-        yield return new object[] { Keys.Alt | Keys.Left, false };
-        yield return new object[] { Keys.Alt | Keys.Right, false };
-        yield return new object[] { Keys.Alt | Keys.Return, false };
-        yield return new object[] { Keys.Alt | Keys.Escape, false };
-        yield return new object[] { Keys.Alt | Keys.A, false };
-        yield return new object[] { Keys.Alt | Keys.C, false };
-        yield return new object[] { Keys.Alt | Keys.Insert, false };
-        yield return new object[] { Keys.Alt | Keys.Space, false };
-        yield return new object[] { Keys.Alt | Keys.Home, false };
-        yield return new object[] { Keys.Alt | Keys.End, false };
-        ;
-        yield return new object[] { Keys.Alt | Keys.Back, false };
-        yield return new object[] { Keys.Alt | Keys.Next, false };
-        yield return new object[] { Keys.Alt | Keys.Prior, false };
-        yield return new object[] { Keys.Alt | Keys.Delete, false };
-        yield return new object[] { Keys.Alt | Keys.D0, false };
-        yield return new object[] { Keys.Alt | Keys.NumPad0, false };
-        yield return new object[] { Keys.Alt | Keys.F1, false };
-        yield return new object[] { Keys.Alt | Keys.F2, false };
-        yield return new object[] { Keys.Alt | Keys.F3, false };
-        yield return new object[] { Keys.Alt | Keys.F4, false };
-        yield return new object[] { Keys.Alt | Keys.RButton, false };
-        yield return new object[] { Keys.Alt | Keys.PageUp, false };
-        yield return new object[] { Keys.Alt | Keys.PageDown, false };
-        yield return new object[] { Keys.Alt | Keys.None, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    [InlineData(Keys.Up, false)]
-    [InlineData(Keys.Down, false)]
-    [InlineData(Keys.Left, false)]
-    [InlineData(Keys.Right, false)]
-    [InlineData(Keys.Control | Keys.Up, false)]
-    [InlineData(Keys.Control | Keys.Down, false)]
-    [InlineData(Keys.Control | Keys.Left, false)]
-    [InlineData(Keys.Control | Keys.Right, false)]
-    public void TabControl_IsInputKey_InvokeWithoutHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubTabControl();
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    [InlineData(Keys.Up, true)]
-    [InlineData(Keys.Down, true)]
-    [InlineData(Keys.Left, true)]
-    [InlineData(Keys.Right, true)]
-    [InlineData(Keys.Control | Keys.Up, true)]
-    [InlineData(Keys.Control | Keys.Down, true)]
-    [InlineData(Keys.Control | Keys.Left, true)]
-    [InlineData(Keys.Control | Keys.Right, true)]
-    public void TabControl_IsInputKey_InvokeWithHandle_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TabControlEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TabControlEventArgs(null, 0, TabControlAction.Deselecting) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlEventArgs_TestData))]
-    public void TabControl_OnDeselected_Invoke_CallsDeselected(TabControlEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        void handler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.Deselected += handler;
-        control.OnDeselected(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Deselected -= handler;
-        control.OnDeselected(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlEventArgs_TestData))]
-    public void TabControl_OnDeselected_InvokeWithSelectedTab_CallsDeselected(TabControlEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.SelectedIndex = 0;
-        int callCount = 0;
-        int leaveCallCount1 = 0;
-        int leaveCallCount2 = 0;
-        void handler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(callCount, leaveCallCount1);
-            callCount++;
-        }
-
-        void leaveHandler1(object sender, EventArgs e)
-        {
-            Assert.Same(page1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            leaveCallCount1++;
-        }
-
-        void leaveHandler2(object sender, EventArgs e) => leaveCallCount2++;
-
-        // Call with handler.
-        control.Deselected += handler;
-        page1.Leave += leaveHandler1;
-        page2.Leave += leaveHandler2;
-        control.OnDeselected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, leaveCallCount1);
-        Assert.Equal(0, leaveCallCount2);
-
-        // Remove handler.
-        control.Deselected -= handler;
-        page1.Leave -= leaveHandler1;
-        page2.Leave -= leaveHandler2;
-        control.OnDeselected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, leaveCallCount1);
-        Assert.Equal(0, leaveCallCount2);
-    }
-
-    public static IEnumerable<object[]> TabControlCancelEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TabControlCancelEventArgs(null, 0, true, TabControlAction.Deselecting) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlCancelEventArgs_TestData))]
-    public void TabControl_OnDeselecting_Invoke_CallsDeselecting(TabControlCancelEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        void handler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.Deselecting += handler;
-        control.OnDeselecting(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Deselecting -= handler;
-        control.OnDeselecting(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> DrawItemEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var bitmap = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(bitmap);
-        yield return new object[] { new DrawItemEventArgs(graphics, null, new Rectangle(1, 2, 3, 4), 0, DrawItemState.Checked) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawItemEventArgs_TestData))]
-    public void TabControl_OnDrawItem_Invoke_CallsDrawItem(DrawItemEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        void handler(object sender, DrawItemEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.DrawItem += handler;
-        control.OnDrawItem(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DrawItem -= handler;
-        control.OnDrawItem(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnEnter_InvokeWithSelectedTab_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.SelectedTab = page2;
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        page1.Enter += (sender, e) => childCallCount1++;
-        page2.Enter += (sender, e) =>
-        {
-            Assert.Same(page2, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount2++;
-        };
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(0, childCallCount1);
-            Assert.Equal(0, childCallCount2);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnLeave_InvokeWithSelectedTab_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.SelectedTab = page2;
-
-        int callCount = 0;
-        int childCallCount1 = 0;
-        int childCallCount2 = 0;
-        page1.Leave += (sender, e) => childCallCount1++;
-        page2.Leave += (sender, e) =>
-        {
-            Assert.Same(page2, sender);
-            Assert.Same(eventArgs, e);
-            childCallCount2++;
-        };
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(0, childCallCount1);
-            Assert.Equal(1, childCallCount2);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(1, childCallCount2);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, childCallCount1);
-        Assert.Equal(2, childCallCount2);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null };
-        yield return new object[] { RightToLeft.Yes, new EventArgs() };
-        yield return new object[] { RightToLeft.No, null };
-        yield return new object[] { RightToLeft.No, new EventArgs() };
-        yield return new object[] { RightToLeft.Inherit, null };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_TestData))]
-    public void TabControl_OnRightToLeftLayoutChanged_Invoke_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs)
-    {
-        using var control = new SubTabControl
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_WithHandle_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null, 1 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.Inherit, null, 0 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_WithHandle_TestData))]
-    public void TabControl_OnRightToLeftLayoutChanged_InvokeWithHandle_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCreatedCallCount)
-    {
-        using var control = new SubTabControl
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedCreatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount * 2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_OnRightToLeftLayoutChanged_InvokeInDisposing_DoesNotCallRightToLeftLayoutChanged()
-    {
-        using var control = new SubTabControl
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlEventArgs_TestData))]
-    public void TabControl_OnSelected_InvokeWithSelectedTab_CallsSelected(TabControlEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.SelectedIndex = 0;
-        int callCount = 0;
-        int enterCallCount1 = 0;
-        int enterCallCount2 = 0;
-        void handler(object sender, TabControlEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(callCount, enterCallCount1);
-            callCount++;
-        }
-
-        void enterHandler1(object sender, EventArgs e)
-        {
-            Assert.Same(page1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            enterCallCount1++;
-        }
-
-        void enterHandler2(object sender, EventArgs e) => enterCallCount2++;
-
-        // Call with handler.
-        control.Selected += handler;
-        page1.Enter += enterHandler1;
-        page2.Enter += enterHandler2;
-        control.OnSelected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, enterCallCount1);
-        Assert.Equal(0, enterCallCount2);
-
-        // Remove handler.
-        control.Selected -= handler;
-        page1.Enter -= enterHandler1;
-        page2.Enter -= enterHandler2;
-        control.OnSelected(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, enterCallCount1);
-        Assert.Equal(0, enterCallCount2);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnSelectedIndexChanged_Invoke_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnSelectedIndexChanged_InvokeWithPages_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnSelectedIndexChanged_InvokeWithHandle_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabControl_OnSelectedIndexChanged_InvokeWithHandleWithPages_CallsSelectedIndexChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.SelectedIndexChanged += handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-
-        // Remove handler.
-        control.SelectedIndexChanged -= handler;
-        control.OnSelectedIndexChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabControlCancelEventArgs_TestData))]
-    public void TabControl_OnSelecting_Invoke_CallsSelecting(TabControlCancelEventArgs eventArgs)
-    {
-        using var control = new SubTabControl();
-        int callCount = 0;
-        void handler(object sender, TabControlCancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.Selecting += handler;
-        control.OnSelecting(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Selecting -= handler;
-        control.OnSelecting(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RecreateHandle_InvokeWithoutHandle_Nop()
-    {
-        using var control = new SubTabControl();
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RecreateHandle_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubTabControl();
-        IntPtr handle1 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.Empty(control.Controls);
-        Assert.Empty(control.TabPages);
-        Assert.True(control.IsHandleCreated);
-
-        control.RecreateHandle();
-        IntPtr handle2 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle1, handle2);
-        Assert.Empty(control.Controls);
-        Assert.Empty(control.TabPages);
-        Assert.True(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        IntPtr handle3 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle3);
-        Assert.NotEqual(handle2, handle3);
-        Assert.Empty(control.Controls);
-        Assert.Empty(control.TabPages);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RecreateHandle_InvokeNotEmptyWithHandle_Success()
-    {
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var control = new SubTabControl();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        IntPtr handle1 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle1);
-        Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>());
-        Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>());
-        Assert.True(control.IsHandleCreated);
-
-        control.RecreateHandle();
-        IntPtr handle2 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle2);
-        Assert.NotEqual(handle1, handle2);
-        Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>());
-        Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>());
-        Assert.True(control.IsHandleCreated);
-
-        // Invoke again.
-        control.RecreateHandle();
-        IntPtr handle3 = control.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle3);
-        Assert.NotEqual(handle2, handle3);
-        Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>());
-        Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabControl_RecreateHandle_GetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var control = new SubTabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = text,
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        control.TabPages.Add(page3);
-
-        control.RecreateHandle();
-        Assert.Equal(3, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabControl_RemoveAll_InvokeEmpty_Success()
-    {
-        using var control = new SubTabControl();
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e) => layoutCallCount++;
-        control.Layout += layoutHandler;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        try
-        {
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // RemoveAll again.
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_RemoveAll_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        control.TabPages.Add(child1);
-        control.TabPages.Add(child2);
-        control.TabPages.Add(child3);
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(child3, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        control.Layout += layoutHandler;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        try
-        {
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // RemoveAll again.
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_RemoveAll_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubTabControl();
-
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int parentInvalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        control.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e) => layoutCallCount++;
-        control.Layout += layoutHandler;
-
-        try
-        {
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // RemoveAll again.
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_RemoveAll_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        control.TabPages.Add(child1);
-        control.TabPages.Add(child2);
-        control.TabPages.Add(child3);
-
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int parentInvalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        control.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(child3, e.AffectedControl);
-            Assert.Equal("Parent", e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        control.Layout += layoutHandler;
-
-        try
-        {
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-
-            // RemoveAll again.
-            control.RemoveAll();
-            Assert.Empty(control.TabPages);
-            Assert.Empty(control.Controls);
-            Assert.Null(child1.Parent);
-            Assert.Null(child2.Parent);
-            Assert.Null(child3.Parent);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(3, controlRemovedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-            Assert.True(child1.IsHandleCreated);
-            Assert.False(child2.IsHandleCreated);
-            Assert.False(child3.IsHandleCreated);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabControl_RemoveAll_GetItemsWithHandle_Success()
-    {
-        using var control = new SubTabControl();
-        using var child1 = new TabPage();
-        using var child2 = new TabPage();
-        using var child3 = new TabPage();
-        control.TabPages.Add(child1);
-        control.TabPages.Add(child2);
-        control.TabPages.Add(child3);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.RemoveAll();
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TCM_GETITEMCOUNT));
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeTabPageWithPages_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Set valid.
-        control.SelectTab(page2);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set same.
-        control.SelectTab(page2);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set different.
-        control.SelectTab(page1);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeTabPageWithPagesWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set valid.
-        control.SelectTab(page2);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set same.
-        control.SelectTab(page2);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set different.
-        control.SelectTab(page1);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_NullTabPage_ThrowsArgumentNullException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentNullException>("tabPage", () => control.SelectTab((TabPage)null));
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_NoSuchTabPageWithoutPages_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.SelectTab(page));
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_NoSuchTabPageWithPages_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.SelectTab(page3));
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeStringWithPages_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage
-        {
-            Name = "Name1"
-        };
-        using var page2 = new TabPage
-        {
-            Name = "Name2"
-        };
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Set valid.
-        control.SelectTab("Name2");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set same.
-        control.SelectTab("Name2");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set different.
-        control.SelectTab("Name1");
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeStringWithPagesWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage
-        {
-            Name = "Name1"
-        };
-        using var page2 = new TabPage
-        {
-            Name = "Name2"
-        };
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set valid.
-        control.SelectTab("Name2");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set same.
-        control.SelectTab("Name2");
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set different.
-        control.SelectTab("Name1");
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_NullTabPageName_ThrowsArgumentNullException()
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentNullException>("tabPageName", () => control.SelectTab((string)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    public void TabControl_SelectTab_NoSuchTabPageNameWithoutPages_ThrowsArgumentOutOfRangeException(string tabPageName)
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentNullException>("tabPage", () => control.SelectTab(tabPageName));
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("NoSuchName")]
-    public void TabControl_SelectTab_NoSuchTabPageNameWithPages_ThrowsArgumentOutOfRangeException(string tabPageName)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        using var page3 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentNullException>("tabPage", () => control.SelectTab(tabPageName));
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeIntWithPages_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-
-        // Set valid.
-        control.SelectTab(1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set same.
-        control.SelectTab(1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set different.
-        control.SelectTab(0);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabControl_SelectTab_InvokeIntWithPagesWithHandle_GetReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int pageInvalidatedCallCount1 = 0;
-        page1.Invalidated += (sender, e) => pageInvalidatedCallCount1++;
-        int pageStyleChangedCallCount1 = 0;
-        page1.StyleChanged += (sender, e) => pageStyleChangedCallCount1++;
-        int pageCreatedCallCount1 = 0;
-        page1.HandleCreated += (sender, e) => pageCreatedCallCount1++;
-        int pageInvalidatedCallCount2 = 0;
-        page2.Invalidated += (sender, e) => pageInvalidatedCallCount2++;
-        int pageStyleChangedCallCount2 = 0;
-        page2.StyleChanged += (sender, e) => pageStyleChangedCallCount2++;
-        int pageCreatedCallCount2 = 0;
-        page2.HandleCreated += (sender, e) => pageCreatedCallCount2++;
-        Assert.True(page1.IsHandleCreated);
-        Assert.False(page2.IsHandleCreated);
-
-        // Set valid.
-        control.SelectTab(1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set same.
-        control.SelectTab(1);
-        Assert.Same(page2, control.SelectedTab);
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(page1.Visible);
-        Assert.True(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-
-        // Set different.
-        control.SelectTab(0);
-        Assert.Same(page1, control.SelectedTab);
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.True(page1.Visible);
-        Assert.False(page2.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(page1.IsHandleCreated);
-        Assert.Equal(1, pageInvalidatedCallCount1);
-        Assert.Equal(0, pageStyleChangedCallCount1);
-        Assert.Equal(0, pageCreatedCallCount1);
-        Assert.True(page2.IsHandleCreated);
-        Assert.Equal(0, pageInvalidatedCallCount2);
-        Assert.Equal(0, pageStyleChangedCallCount2);
-        Assert.Equal(1, pageCreatedCallCount2);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabControl_SelectTab_InvalidIndexWithoutPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new TabControl();
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.SelectTab(index));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TabControl_SelectTab_InvalidIndexWithPages_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage();
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => control.SelectTab(index));
-    }
-
-    [WinFormsFact]
-    public void TabControl_ToString_InvokeEmpty_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        Assert.Equal("System.Windows.Forms.TabControl, TabPages.Count: 0", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TabControl_ToString_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new TabControl();
-        using var page1 = new TabPage("text1");
-        using var page2 = new TabPage("text2");
-        control.TabPages.Add(page1);
-        control.TabPages.Add(page2);
-        Assert.Equal("System.Windows.Forms.TabControl, TabPages.Count: 2, TabPages[0]: TabPage: {text1}", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TabControl_Invokes_SetToolTip_IfExternalToolTipIsSet()
-    {
-        using TabControl control = new TabControl() { ShowToolTips = true };
-        using ToolTip toolTip = new ToolTip();
-        control.CreateControl();
-
-        dynamic tabControl = control.TestAccessor().Dynamic;
-        string actual = tabControl._controlTipText;
-
-        Assert.Empty(actual);
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        string text = "Some test text";
-        toolTip.SetToolTip(control, text); // Invokes TabControl's SetToolTip inside
-        actual = tabControl._controlTipText;
-
-        Assert.Equal(text, actual);
-    }
-
-    private class SubTabPage : TabPage
-    {
-    }
-
-    private class NullTextTabPage : TabPage
-    {
-        public override string Text
-        {
-            get => null;
-            set { }
-        }
-    }
-
-    public class SubTabControl : TabControl
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new Control.ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new object[] GetItems() => base.GetItems();
-
-        public new object[] GetItems(Type baseType) => base.GetItems(baseType);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new string GetToolTipText(object item) => base.GetToolTipText(item);
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnDeselected(TabControlEventArgs e) => base.OnDeselected(e);
-
-        public new void OnDeselecting(TabControlCancelEventArgs e) => base.OnDeselecting(e);
-
-        public new void OnDrawItem(DrawItemEventArgs e) => base.OnDrawItem(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnRightToLeftLayoutChanged(EventArgs e) => base.OnRightToLeftLayoutChanged(e);
-
-        public new void OnSelected(TabControlEventArgs e) => base.OnSelected(e);
-
-        public new void OnSelectedIndexChanged(EventArgs e) => base.OnSelectedIndexChanged(e);
-
-        public new void OnSelecting(TabControlCancelEventArgs e) => base.OnSelecting(e);
-
-        public new void RecreateHandle() => base.RecreateHandle();
-
-        public new void RemoveAll() => base.RemoveAll();
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabAccessibleObjectTests.cs
deleted file mode 100644
index e24b75cb798..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabAccessibleObjectTests.cs
+++ /dev/null
@@ -1,1155 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-using static Interop.UiaCore;
-using static System.Windows.Forms.TabControl;
-using static System.Windows.Forms.TabPage;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabPage_TabAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void TabAccessibleObject_Bounds_ReturnsExpected(bool createControl, bool boundsIsEmpty)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(boundsIsEmpty, accessibleObject.Bounds.IsEmpty);
-        Assert.Equal(createControl, pages[0].IsHandleCreated);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibilityObject_IsDisconnected_WhenTabPageReleasesUiaProvider()
-    {
-        using TabPage tabPage = new();
-        EnforceTabAccessibilityObjectCreation(tabPage);
-
-        tabPage.ReleaseUiaProvider(tabPage.HWND);
-
-        Assert.Null(tabPage.TestAccessor().Dynamic._tabAccessibilityObject);
-        Assert.True(tabPage.IsHandleCreated);
-
-        static void EnforceTabAccessibilityObjectCreation(TabPage tabPage)
-        {
-            _ = tabPage.TabAccessibilityObject;
-            Assert.NotNull(tabPage.TestAccessor().Dynamic._tabAccessibilityObject);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Test", "Test")]
-    public void TabAccessibleObject_Name_ReturnsTabPageText(string text, string expectedText)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage() { Text = text, Name = "Test" });
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(expectedText, accessibleObject.Name);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DefaultAction_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new TabControl();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DefaultAction_Returns_NotEmptyString_IfHandleIsCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.PageTab)]
-    [InlineData(false, AccessibleRole.None)]
-    public void TabAccessibleObject_Role_ReturnsNone_IfHandleIsNotCreated(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(expectedAccessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, pages[0].IsHandleCreated);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TabAccessibleObject_State_ReturnsExpected_IfHandleIsCreated(bool tabControlEnabled, bool tabPageEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = tabControlEnabled };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new() { Enabled = tabPageEnabled }, new() { Enabled = tabPageEnabled } });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(AccessibleStates.Focusable | AccessibleStates.Selectable | AccessibleStates.Selected, accessibleObject1.State);
-        Assert.Equal(AccessibleStates.Focusable | AccessibleStates.Selectable, accessibleObject2.State);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_State_ReturnsNone_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_FragmentRoot_ReturnsTabControlAccessibleObject()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject.FragmentRoot);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_FragmentNavigate_Parent_ReturnsTabControlAccessibleObject()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected_AfterChaningSelectedTab()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(pages[0].AccessibilityObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-
-        tabControl.SelectedIndex = 1;
-
-        Assert.Equal(pages[1].AccessibilityObject, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_Supports_LegacyIAccessiblePattern()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_GetPropertyValue_IsLegacyIAccessiblePatternAvailable_ReturnsTrue()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_Supports_SelectionItemPattern()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.SelectionItemPatternId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_GetPropertyValue_IsSelectionItemPatternAvailable_ReturnsTrue()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsSelectionItemPatternAvailablePropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoesNotSupport_InvokePattern()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.False(accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_GetPropertyValue_IsInvokePatternPatternAvailable_ReturnsTrue()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.IsInvokePatternAvailablePropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoDefaultAction_WorksCorrectly()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.Equal(1, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoDefaultAction_DoesNotAffectTabControl_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoDefaultAction_DoesNotAffectTabControl_IfTabControlIsDisabled()
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.DoDefaultAction();
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SelectItem_WorksCorrectly()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.SelectItem();
-
-        Assert.Equal(1, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SelectItem_DoesNotAffectTabControl_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-
-        accessibleObject.SelectItem();
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SelectItem_DoesNotAffectTabControl_IfTabControlIsDisabled()
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.SelectItem();
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_AddToSelection_WorksCorrectly()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.AddToSelection();
-
-        Assert.Equal(1, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_AddToSelection__DoesNotAffectTabControl_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-
-        accessibleObject.AddToSelection();
-
-        Assert.Equal(-1, tabControl.SelectedIndex);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_AddToSelection_DoesNotAffectTabControl_IfTabControlIsDisabled()
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-
-        accessibleObject.AddToSelection();
-
-        Assert.Equal(0, tabControl.SelectedIndex);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, -1)]
-    public void TabAccessibleObject_RemoveFromSelection_DoesNotAffectTabControl(bool createControl, int expectedIndex)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(expectedIndex, tabControl.SelectedIndex);
-
-        accessibleObject.RemoveFromSelection();
-
-        Assert.Equal(expectedIndex, tabControl.SelectedIndex);
-        Assert.Equal(createControl, pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_ItemSelectionContainer_ReturnsTabControlAccessibleObject(bool createControl)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject.ItemSelectionContainer);
-        Assert.Equal(createControl, pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_ItemIsSelected_ReturnsExpected_IfHandleIsCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-        tabControl.CreateControl();
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.True(accessibleObject1.IsItemSelected);
-        Assert.False(accessibleObject2.IsItemSelected);
-
-        tabControl.SelectedIndex = 1;
-
-        Assert.False(accessibleObject1.IsItemSelected);
-        Assert.True(accessibleObject2.IsItemSelected);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_ItemIsSelected_ReturnsFalse_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.False(accessibleObject1.IsItemSelected);
-        Assert.False(accessibleObject2.IsItemSelected);
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_DoDefaultAction_InvokeRaiseAutomationEvent(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() { Enabled = tabPageEnabled } });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[1].TabAccessibilityObject.DoDefaultAction();
-        Application.DoEvents();
-
-        Assert.Equal(1, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoDefaultAction_DoesNotInvoke_RaiseAutomationEvent_IfTabAlreadySelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[0].TabAccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_DoDefaultAction_DoesNotInvoke_RaiseAutomationEvent_IfAccessibleObjectIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        pages[0].TabAccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_DoDefaultAction_DoesNotInvoke_RaiseAutomationEvent_IfTabControlIsDisabled(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() { Enabled = tabPageEnabled } });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[1].TabAccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedTab_InvokeRaiseAutomationEvent()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        tabControl.SelectedTab = pages[1];
-        Application.DoEvents();
-
-        Assert.Equal(1, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedTab_DoesNotInvoke_RaiseAutomationEvent_IfAccessibleObjectIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        tabControl.SelectedTab = pages[1];
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedTab_DoesNotInvoke_RaiseAutomationEvent_IfTabAlreadySelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        tabControl.SelectedTab = pages[0];
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedIndex_InvokeRaiseAutomationEvent()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        tabControl.SelectedIndex = 1;
-        Application.DoEvents();
-
-        Assert.Equal(1, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedIndex_DoesNotInvoke_RaiseAutomationEvent_IfAccessibleObjectIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        tabControl.SelectedIndex = 1;
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SetSelectedIndex_DoesNotInvoke_RaiseAutomationEvent_IfTabAlreadySelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        tabControl.SelectedIndex = 0;
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_OnGotFocus_InvokeTabAccessibleObject_RaiseAutomationEvent()
-    {
-        using SubTabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        tabControl.OnGotFocus();
-
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_OnGotFocus_DoesNotInvoke_RaiseAutomationEvent_IfControlTabAccessibleObjectIsNotCreated()
-    {
-        using SubTabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        tabControl.OnGotFocus();
-
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_AddToSelection_InvokeRaiseAutomationEvent(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() { Enabled = tabPageEnabled } });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[1].TabAccessibilityObject.AddToSelection();
-        Application.DoEvents();
-
-        Assert.Equal(1, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_AddToSelection_DoesNotInvoke_RaiseAutomationEvent_IfAccessibleObjectIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        pages[0].TabAccessibilityObject.AddToSelection();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_AddToSelection_DoesNotInvoke_RaiseAutomationEvent_IfTabAlreadySelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        pages[0].TabAccessibilityObject.AddToSelection();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_AddToSelection_DoesNotInvoke_RaiseAutomationEvent_IfTabControlIsDisabled(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new() { Enabled = tabPageEnabled }, new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[0].TabAccessibilityObject.AddToSelection();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_SelectItem_InvokeRaiseAutomationEvent(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() { Enabled = tabPageEnabled } });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[1].TabAccessibilityObject.SelectItem();
-        Application.DoEvents();
-
-        Assert.Equal(1, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(1, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SelectItem_DoesNotInvoke_RaiseAutomationEvent_IfAccessibleObjectIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        pages[0].TabAccessibilityObject.SelectItem();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_SelectItem_DoesNotInvoke_RaiseAutomationEvent_IfTabAlreadySelected()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[0]);
-        pages[0].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[0].TabAccessibilityObject.SelectItem();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_SelectItem_DoesNotInvoke_RaiseAutomationEvent_IfTabControlIsDisabled(bool tabPageEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = false };
-        TabPageCollection pages = tabControl.TabPages;
-        tabControl.CreateControl();
-        pages.AddRange(new TabPage[] { new(), new() { Enabled = tabPageEnabled } });
-
-        SubTabAccessibleObject tabAccessibleObject = new(pages[1]);
-        pages[1].TestAccessor().Dynamic._tabAccessibilityObject = tabAccessibleObject;
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-
-        pages[1].TabAccessibilityObject.SelectItem();
-
-        Assert.Equal(0, tabAccessibleObject.CallSelectionItemEventCount);
-        Assert.Equal(0, tabAccessibleObject.CallFocusChangedEventCount);
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabAccessibleObject_RuntimeId_ReturnsExpected(bool createControl)
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-
-        if (createControl)
-        {
-            tabControl.CreateControl();
-        }
-
-        pages.AddRange(new TabPage[] { new TabPage(), new TabPage() });
-        TabAccessibleObject accessibleObject1 = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-        TabAccessibleObject accessibleObject2 = Assert.IsType<TabAccessibleObject>(pages[1].TabAccessibilityObject);
-
-        Assert.NotNull(accessibleObject1.RuntimeId);
-        Assert.Equal(tabControl.HandleInternal, (IntPtr)accessibleObject1.RuntimeId[1]);
-        Assert.Equal(accessibleObject1.GetHashCode(), accessibleObject1.RuntimeId[2]);
-        Assert.NotNull(accessibleObject2.RuntimeId);
-        Assert.Equal(tabControl.HandleInternal, (IntPtr)accessibleObject2.RuntimeId[1]);
-        Assert.Equal(accessibleObject2.GetHashCode(), accessibleObject2.RuntimeId[2]);
-        Assert.Equal(createControl, pages[0].IsHandleCreated);
-        Assert.Equal(createControl, pages[1].IsHandleCreated);
-        Assert.Equal(createControl, tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, true)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TabAccessibleObject_GetPropertyValue_IsEnabledPropertyId_ReturnsExpected(bool tabControlEnabled, bool tabPageEnabled, bool expectedEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = tabControlEnabled };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage() { Enabled = tabPageEnabled });
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.Equal(expectedEnabled, (bool)accessibleObject.GetPropertyValue(UIA.IsEnabledPropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_GetPropertyValue_IsKeyboardFocusablePropertyId_ReturnsTrue()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsKeyboardFocusablePropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabAccessibleObject_GetPropertyValue_HasKeyboardFocusPropertyId_ReturnsTrue()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        Assert.IsType<TabControlAccessibleObject>(tabControl.AccessibilityObject);
-        TabAccessibleObject accessibleObject = Assert.IsType<TabAccessibleObject>(pages[0].TabAccessibilityObject);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    private class SubTabControl : TabControl
-    {
-        internal void OnGotFocus() => base.OnGotFocus(EventArgs.Empty);
-    }
-
-    private class SubTabAccessibleObject : TabAccessibleObject
-    {
-        internal SubTabAccessibleObject(TabPage owningTabPage) : base(owningTabPage)
-        {
-        }
-
-        internal int CallSelectionItemEventCount { get; private set; }
-
-        internal int CallFocusChangedEventCount { get; private set; }
-
-        internal override bool RaiseAutomationEvent(UiaCore.UIA eventId)
-        {
-            switch (eventId)
-            {
-                case UiaCore.UIA.SelectionItem_ElementSelectedEventId:
-                    CallSelectionItemEventCount++;
-                    break;
-                case UiaCore.UIA.AutomationFocusChangedEventId:
-                    CallFocusChangedEventCount++;
-                    break;
-                default:
-                    break;
-            }
-
-            return base.RaiseAutomationEvent(eventId);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabPageAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabPageAccessibleObjectTests.cs
deleted file mode 100644
index 710018262f2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPage.TabPageAccessibleObjectTests.cs
+++ /dev/null
@@ -1,559 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop.UiaCore;
-using static System.Windows.Forms.TabControl;
-using static System.Windows.Forms.TabPage;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabPage_TabPageAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void TabPageAccessibilityObject_Ctor_Default()
-    {
-        using TabPage tabPage = new();
-        tabPage.CreateControl();
-
-        Assert.NotNull(tabPage.AccessibilityObject);
-        Assert.True(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibilityObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using TabPage tabPage = new();
-        tabPage.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = tabPage.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-
-        Assert.Equal(UIA.PaneControlTypeId, actual);
-        Assert.True(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void TabPageAccessibilityObject_Role_ReturnsExpected(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using TabPage tabPage = new();
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        Assert.Equal(expectedAccessibleRole, tabPage.AccessibilityObject.Role);
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TabPageAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TabPageAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TabPageAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TabPage tabPage = new();
-        tabPage.AccessibleRole = role;
-
-        object actual = tabPage.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-        UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    public void TabPageAccessibleObject_Bounds_ReturnsExpected(bool createControl, bool boundsIsEmpty)
-    {
-        using TabPage tabPage = new();
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(boundsIsEmpty, accessibleObject.Bounds.IsEmpty);
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Accessible Name", "Text", "Accessible Name")]
-    [InlineData("", "Text", "")]
-    [InlineData(null, "Text", "Text")]
-    [InlineData(null, null, null)]
-    public void TabPageAccessibleObject_Name_ReturnsExpected(string accessibleName, string tabPageText, string expectedName)
-    {
-        using TabPage tabPage = new()
-        {
-            AccessibleName = accessibleName,
-            Text = tabPageText,
-            Name = "Name",
-        };
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(expectedName, accessibleObject.Name);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabPageAccessibleObject_Description_ReturnsExpected(string accessibleDescription)
-    {
-        using TabPage tabPage = new();
-        tabPage.AccessibleDescription = accessibleDescription;
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(accessibleDescription, accessibleObject.Description);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabPageAccessibleObject_RuntimeId_ReturnsExpected(bool createControl)
-    {
-        using TabPage tabPage = new();
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        Assert.NotNull(tabPage.AccessibilityObject.RuntimeId);
-        Assert.Equal(tabPage.HandleInternal, (IntPtr)tabPage.AccessibilityObject.RuntimeId[1]);
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test")]
-    [InlineData("")]
-    [InlineData(null)]
-    public void TabPageAccessibleObject_AccessibleDefaultActionDescription_ReturnsExpected(string accessibleDefaultActionDescription)
-    {
-        using TabPage tabPage = new();
-        tabPage.AccessibleDefaultActionDescription = accessibleDefaultActionDescription;
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(accessibleDefaultActionDescription, accessibleObject.DefaultAction);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, AccessibleStates.Focusable)]
-    [InlineData(true, false, AccessibleStates.Focusable | AccessibleStates.Unavailable)]
-    [InlineData(false, true, AccessibleStates.None)]
-    [InlineData(false, false, AccessibleStates.None)]
-    public void TabPageAccessibleObject_State_ReturnExpected(bool createControl, bool enabled, AccessibleStates expectedAccessibleStates)
-    {
-        using TabPage tabPage = new() { Enabled = enabled };
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(expectedAccessibleStates, accessibleObject.State);
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_FragmentNaviage_ReturnsNull_IfTabPageHasNotTabControl()
-    {
-        using TabPage tabPage = new();
-        tabPage.CreateControl();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_FragmentNaviage_ReturnsNull_IfHandleIsNotCreated()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(pages[0].AccessibilityObject);
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_FragmentNaviage_ReturnsExpected_IfSingleItem()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage());
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(pages[0].AccessibilityObject);
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_FragmentNaviage_ReturnsExpected_IfThreeItem()
-    {
-        using TabControl tabControl = new();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-        tabControl.CreateControl();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(pages[0].AccessibilityObject);
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.False(pages[1].IsHandleCreated);
-        Assert.False(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_FragmentNaviage_ReturnsExpected_AfterChaningSelectedTab()
-    {
-        using TabControl tabControl = new();
-        tabControl.CreateControl();
-        TabPageCollection pages = tabControl.TabPages;
-        pages.AddRange(new TabPage[] { new(), new(), new() });
-
-        TabPageAccessibleObject accessibleObject1 = Assert.IsType<TabPageAccessibleObject>(pages[0].AccessibilityObject);
-        TabPageAccessibleObject accessibleObject2 = Assert.IsType<TabPageAccessibleObject>(pages[1].AccessibilityObject);
-        TabPageAccessibleObject accessibleObject3 = Assert.IsType<TabPageAccessibleObject>(pages[2].AccessibilityObject);
-
-        // First tab is selected
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.LastChild));
-
-        // Second tab is selected
-        tabControl.SelectedIndex = 1;
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.LastChild));
-
-        // Third tab is selected
-        tabControl.SelectedIndex = 2;
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(tabControl.AccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(pages[0].TabAccessibilityObject, accessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject3.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.True(pages[0].IsHandleCreated);
-        Assert.True(pages[1].IsHandleCreated);
-        Assert.True(pages[2].IsHandleCreated);
-        Assert.True(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_Supports_LegacyIAccessiblePattern()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.True(accessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_DoesNotSupports_ValuePattern()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.False(accessibleObject.IsPatternSupported(UIA.ValuePatternId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_GetPropertyValue_IsLegacyIAccessiblePatternAvailable_ReturnsTrue()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsLegacyIAccessiblePatternAvailablePropertyId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_GetPropertyValue_IsValuePatternAvailable_ReturnsFalse()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.IsValuePatternAvailablePropertyId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_GetPropertyValue_HasKeyboardFocusPropertyId_ReturnsFalse()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_GetPropertyValue_IsKeyboardFocusablePropertyId_ReturnsTrue()
-    {
-        using TabPage tabPage = new();
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsKeyboardFocusablePropertyId));
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TabPageAccessibleObject_GetPropertyValue_IsEnabledPropertyId_ReturnsExpected(bool tabControlEnabled, bool tabPageEnabled, bool expectedEnabled)
-    {
-        using TabControl tabControl = new() { Enabled = tabControlEnabled };
-        TabPageCollection pages = tabControl.TabPages;
-        pages.Add(new TabPage() { Enabled = tabPageEnabled });
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(pages[0].AccessibilityObject);
-
-        Assert.Equal(expectedEnabled, (bool)accessibleObject.GetPropertyValue(UIA.IsEnabledPropertyId));
-        Assert.False(pages[0].IsHandleCreated);
-        Assert.False(tabControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TabPageAccessibleObject_GetPropertyValue_NativeWindowHandlePropertyId_ReturnsTrue(bool createControl)
-    {
-        using TabPage tabPage = new();
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal((nint)tabPage.InternalHandle, (nint)accessibleObject.GetPropertyValue(UIA.NativeWindowHandlePropertyId));
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "&Name", "Alt+n")]
-    [InlineData(false, "&Name", "Alt+n")]
-    [InlineData(true, "Name", null)]
-    [InlineData(false, "Name", null)]
-    public void TabPageAccessibleObject_KeyboardShortcut_ReturnExpected(bool createControl, string text, string expectedKeyboardShortcut)
-    {
-        using TabPage tabPage = new() { Text = text };
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(expectedKeyboardShortcut, accessibleObject.KeyboardShortcut);
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "&Name", "Alt+n")]
-    [InlineData(false, "&Name", "Alt+n")]
-    [InlineData(true, "Name", "")]
-    [InlineData(false, "Name", "")]
-    public void TabPageAccessibleObject_GetPropertyValue_AccessKey_ReturnExpected(bool createControl, string text, string expectedKeyboardShortcut)
-    {
-        using TabPage tabPage = new() { Text = text };
-
-        if (createControl)
-        {
-            tabPage.CreateControl();
-        }
-
-        TabPageAccessibleObject accessibleObject = Assert.IsType<TabPageAccessibleObject>(tabPage.AccessibilityObject);
-
-        Assert.Equal(expectedKeyboardShortcut, accessibleObject.GetPropertyValue(UIA.AccessKeyPropertyId));
-        Assert.Equal(createControl, tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "TabPage1")]
-    public void TabPageAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using TabPage tabPage = new()
-        {
-            Name = "TabPage1",
-            AccessibleName = "TestName"
-        };
-
-        object actual = tabPage.AccessibilityObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, actual);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UIA.IsValuePatternAvailablePropertyId))]
-    public void TabPageAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using TabPage tabPage = new();
-        TabPageAccessibleObject accessibleObject = (TabPageAccessibleObject)tabPage.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UIA)propertyId) ?? false);
-        Assert.False(tabPage.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPageAccessibleObject_BoundingRectangle_IsCorrect()
-    {
-        using Form form = new();
-        using TabControl tabControl = new();
-        using Button button = new Button();
-        using TabPage tabPage = new TabPage();
-
-        tabControl.Controls.Add(tabPage);
-        tabControl.Location = new Point(22, 25);
-        tabControl.Size = new Size(151, 104);
-
-        button.Location = new Point(16, 12);
-        button.Size = new Size(198, 86);
-
-        tabPage.AutoScroll = true;
-        tabPage.Controls.Add(button);
-        tabPage.Location = new Point(4, 24);
-        tabPage.Padding = new Padding(3);
-        tabPage.Size = new Size(143, 76);
-
-        form.ClientSize = new Size(520, 305);
-        form.Controls.Add(tabControl);
-
-        form.Show();
-
-        Rectangle boundingRectangle = tabPage.AccessibilityObject.BoundingRectangle;
-
-        int horizontalScrollBarHeight = SystemInformation.HorizontalScrollBarHeight;
-        int verticalScrollBarWidth = SystemInformation.VerticalScrollBarWidth;
-
-        Rectangle expected = tabPage.RectangleToScreen(tabPage.ClientRectangle);
-
-        Assert.Equal(boundingRectangle.Width, expected.Width + verticalScrollBarWidth);
-        Assert.Equal(boundingRectangle.Height, expected.Height + horizontalScrollBarHeight);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.TabPageControlCollection.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.TabPageControlCollection.cs
deleted file mode 100644
index 0439832bf95..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.TabPageControlCollection.cs
+++ /dev/null
@@ -1,109 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TabPageTabPageControlCollectionTests
-{
-    [WinFormsFact]
-    public void TabPageControlCollection_Ctor_TabPage()
-    {
-        using var owner = new TabPage();
-        var collection = new TabPage.TabPageControlCollection(owner);
-        Assert.Empty(collection);
-        Assert.False(collection.IsReadOnly);
-        Assert.Same(owner, collection.Owner);
-    }
-
-    [WinFormsFact]
-    public void TabPageControlCollection_NullOwner_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("owner", () => new TabPage.TabPageControlCollection(null));
-    }
-
-    [WinFormsFact]
-    public void TabPageControlCollection_Add_ControlExistingCollection_Success()
-    {
-        using var owner = new TabPage();
-        using var control1 = new Control();
-        using var control2 = new Control();
-        TabPage.TabPageControlCollection collection = Assert.IsType<TabPage.TabPageControlCollection>(owner.Controls);
-        int parentLayoutCallCount = 0;
-        string affectedProperty = null;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(collection.Cast<Control>().Last(), e.AffectedControl);
-            Assert.Equal(affectedProperty, e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        owner.Layout += parentHandler;
-        int layoutCallCount1 = 0;
-        control1.Layout += (sender, e) => layoutCallCount1++;
-        int layoutCallCount2 = 0;
-        control2.Layout += (sender, e) => layoutCallCount2++;
-
-        try
-        {
-            affectedProperty = "Parent";
-            collection.Add(control1);
-            Assert.Same(control1, Assert.Single(collection));
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(control1, Assert.Single(owner.Controls));
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-
-            // Add another.
-            collection.Add(control2);
-            Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add existing.
-            affectedProperty = "ChildIndex";
-            collection.Add(control1);
-            Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());
-            Assert.Same(owner, control1.Parent);
-            Assert.Equal(0, control1.TabIndex);
-            Assert.Same(owner, control2.Parent);
-            Assert.Equal(1, control2.TabIndex);
-            Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>());
-            Assert.Equal(0, layoutCallCount1);
-            Assert.Equal(0, layoutCallCount2);
-            Assert.Equal(3, parentLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.False(control1.IsHandleCreated);
-            Assert.False(control2.IsHandleCreated);
-
-            // Add null.
-            collection.Add(null);
-            Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());
-        }
-        finally
-        {
-            owner.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ControlCollection_Add_TabPageValue_ThrowsArgumentException()
-    {
-        using var owner = new TabPage();
-        using var control = new TabPage();
-        var collection = new TabPage.TabPageControlCollection(owner);
-        Assert.Throws<ArgumentException>(() => collection.Add(control));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.cs
deleted file mode 100644
index 898e5159e0c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TabPageTests.cs
+++ /dev/null
@@ -1,5320 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Drawing.Imaging;
-using Microsoft.DotNet.RemoteExecutor;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TabPageTests
-{
-    [WinFormsFact]
-    public void TabPage_Ctor_Default()
-    {
-        using var control = new SubTabPage();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.True(control.CausesValidation);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.IsType<TabPage.TabPageControlCollection>(control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Ctor_String(string text, string expectedText)
-    {
-        using var control = new SubTabPage(text);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.True(control.CausesValidation);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.IsType<TabPage.TabPageControlCollection>(control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPage_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTabPage();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Anchor_Set_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new TabPage
-        {
-            Anchor = value
-        };
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Anchor_Set_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_Anchor_SetWithOldValue_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new TabPage
-        {
-            Anchor = AnchorStyles.Left
-        };
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Anchor_SetWithDock_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_Anchor_SetWithDock_GetReturnsExpected(DockStyle dock, AnchorStyles value, AnchorStyles expectedAnchor, DockStyle expectedDock)
-    {
-        using var control = new TabPage
-        {
-            Dock = dock
-        };
-
-        control.Anchor = value;
-        Assert.Equal(expectedAnchor, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expectedAnchor, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPage_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new TabPage
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void TabPage_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubTabPage();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void TabPage_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void TabPage_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubTabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void TabPage_AutoSizeMode_SetWithHandleWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public static void TabPage_BackColor_Get_ReturnsExpected(bool useVisualStyleBackColor)
-    {
-        using var control = new TabPage
-        {
-            UseVisualStyleBackColor = useVisualStyleBackColor
-        };
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [BoolData]
-    public static void TabPage_BackColor_GetVisualStyles_ReturnsExpected(bool useVisualStyleBackColorParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((useVisualStyleBackColorString) =>
-        {
-            bool useVisualStyleBackColor = bool.Parse(useVisualStyleBackColorString);
-
-            Application.EnableVisualStyles();
-
-            using var control = new TabPage
-            {
-                UseVisualStyleBackColor = useVisualStyleBackColor
-            };
-            Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        }, useVisualStyleBackColorParam.ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, TabAppearance.Buttons)]
-    [InlineData(true, TabAppearance.FlatButtons)]
-    // Has different behaviour with VisualStyles on, see: TabPage_BackColor_TabAppearance_Normal_GetWithParent_ReturnsExpected
-    // [InlineData(true, TabAppearance.Normal)]
-    [InlineData(false, TabAppearance.Buttons)]
-    [InlineData(false, TabAppearance.FlatButtons)]
-    [InlineData(false, TabAppearance.Normal)]
-    public static void TabPage_BackColor_GetWithParent_ReturnsExpected(bool useVisualStyleBackColor, TabAppearance parentAppearance)
-    {
-        if (Application.UseVisualStyles)
-        {
-            return;
-        }
-
-        using var parent = new TabControl
-        {
-            Appearance = parentAppearance
-        };
-        using var control = new TabPage
-        {
-            UseVisualStyleBackColor = useVisualStyleBackColor,
-            Parent = parent
-        };
-
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-    }
-
-    [WinFormsFact]
-    public static void TabPage_BackColor_TabAppearance_Normal_GetWithParent_ReturnsExpected()
-    {
-        using var parent = new TabControl
-        {
-            Appearance = TabAppearance.Normal
-        };
-        using var control = new TabPage
-        {
-            UseVisualStyleBackColor = true,
-            Parent = parent
-        };
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(Color.Transparent, control.BackColor);
-        }
-        else
-        {
-            Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        }
-    }
-
-    public static IEnumerable<object[]> BackColor_GetVisualStylesWithParent_TestData()
-    {
-        yield return new object[] { true, TabAppearance.Buttons, Control.DefaultBackColor };
-        yield return new object[] { true, TabAppearance.FlatButtons, Control.DefaultBackColor };
-        yield return new object[] { true, TabAppearance.Normal, Color.Transparent };
-        yield return new object[] { false, TabAppearance.Buttons, Control.DefaultBackColor };
-        yield return new object[] { false, TabAppearance.FlatButtons, Control.DefaultBackColor };
-        yield return new object[] { false, TabAppearance.Normal, Control.DefaultBackColor };
-    }
-
-    [WinFormsTheory(Skip = "Crash with AbandonedMutexException. See: https://github.com/dotnet/arcade/issues/5325")]
-    [MemberData(nameof(BackColor_GetVisualStylesWithParent_TestData))]
-    public static void TabPage_BackColor_GetVisualStylesWithParent_ReturnsExpected(bool useVisualStyleBackColorParam, TabAppearance parentAppearanceParam, Color expectedParam)
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        RemoteExecutor.Invoke((useVisualStyleBackColorString, parentAppearanceString, expectedString) =>
-        {
-            bool useVisualStyleBackColor = bool.Parse(useVisualStyleBackColorString);
-            TabAppearance parentAppearance = (TabAppearance)Enum.Parse(typeof(TabAppearance), parentAppearanceString);
-            Color expected = Color.FromArgb(int.Parse(expectedString));
-
-            Application.EnableVisualStyles();
-
-            using var parent = new TabControl
-            {
-                Appearance = parentAppearance
-            };
-            using var control = new TabPage
-            {
-                UseVisualStyleBackColor = useVisualStyleBackColor,
-                Parent = parent
-            };
-            Assert.Equal(expected.ToArgb(), control.BackColor.ToArgb());
-        }, useVisualStyleBackColorParam.ToString(), parentAppearanceParam.ToString(), expectedParam.ToArgb().ToString()).Dispose();
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void TabPage_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TabPage
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void TabPage_BackColor_SetWithUseVisualStyleBackColor_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TabPage
-        {
-            UseVisualStyleBackColor = true,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void TabPage_BackColor_SetDesignMode_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new TabPage
-        {
-            Site = mockSite.Object,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void TabPage_BackColor_SetDesignModeWithUseVisualStyleBackColor_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new TabPage
-        {
-            Site = mockSite.Object,
-            UseVisualStyleBackColor = true,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(value.IsEmpty, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(value.IsEmpty, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void TabPage_BackColor_SetDesignModeWithInvalidDescriptor_GetReturnsExpected(Color value, Color expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IDictionaryService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IExtenderListService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(IComponentChangeService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(ITypeDescriptorFilterService)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new TabPage
-        {
-            Site = mockSite.Object,
-            UseVisualStyleBackColor = true,
-        };
-        var mockCustomTypeDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-        mockCustomTypeDescriptor
-            .Setup(d => d.GetProperties())
-            .Returns(PropertyDescriptorCollection.Empty);
-        var mockProvider = new Mock<TypeDescriptionProvider>(MockBehavior.Strict);
-        mockProvider
-            .Setup(p => p.GetCache(control))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetExtendedTypeDescriptor(control))
-            .CallBase();
-        mockProvider
-            .Setup(p => p.GetTypeDescriptor(typeof(TabPage), control))
-            .Returns(mockCustomTypeDescriptor.Object);
-        TypeDescriptor.AddProvider(mockProvider.Object, control);
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void TabPage_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new TabPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void TabPage_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new TabPage
-        {
-            Dock = value
-        };
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void TabPage_Dock_SetWithOldValue_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new TabPage
-        {
-            Dock = DockStyle.Top
-        };
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Dock_SetWithAnchor_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_Dock_SetWithAnchor_GetReturnsExpected(AnchorStyles anchor, DockStyle value, AnchorStyles expectedAnchor)
-    {
-        using var control = new TabPage
-        {
-            Anchor = anchor
-        };
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(expectedAnchor, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(expectedAnchor, control.Anchor);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new TabPage
-        {
-            Dock = DockStyle.None
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void TabPage_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new TabPage();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false, 1, 2)]
-    [InlineData(true, true, 0, 1)]
-    [InlineData(false, false, 0, 0)]
-    [InlineData(false, true, 0, 0)]
-    public void TabPage_Enabled_SetWithHandle_GetReturnsExpected(bool userPaint, bool value, int expectedInvalidateCallCount1, int expectedInvalidateCallCount2)
-    {
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Enabled = value;
-        Assert.Equal(value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Enabled = !value;
-        Assert.Equal(!value, control.Enabled);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var control = new TabPage
-        {
-            Enabled = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.EnabledChanged += handler;
-
-        // Set different.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Enabled = true;
-        Assert.True(control.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.EnabledChanged -= handler;
-        control.Enabled = false;
-        Assert.False(control.Enabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new TabPage
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent,
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithDesignModeParent_GetReturnsExpected(int value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent,
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithImageKey_GetReturnsExpected(int value)
-    {
-        using var control = new TabPage
-        {
-            ImageKey = "imageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithParentWithHandle_GetReturnsExpected(int value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TabPage_ImageIndex_SetWithDesignModeParentWithHandle_GetReturnsExpected(int value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ImageIndex = value;
-        Assert.Equal(value, control.ImageIndex);
-        Assert.Empty(control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public unsafe void TabPageCollection_ImageIndex_SetGetItemsWithHandle_Success(int imageIndex)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ImageIndex = imageIndex;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(imageIndex, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public unsafe void TabPageCollection_ImageIndex_SetGetItemsWithHandleDesignMode_Success(int imageIndex)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ImageIndex = imageIndex;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(imageIndex, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPage_ImageIndex_SetInvalidValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ImageIndex = -2);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_Set_GetReturnsExpected(string value)
-    {
-        using var control = new TabPage
-        {
-            ImageKey = value
-        };
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithParent_GetReturnsExpected(string value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            ImageKey = value
-        };
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithDesignModeParent_GetReturnsExpected(string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            ImageKey = value
-        };
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithImageIndex_GetReturnsExpected(string value)
-    {
-        using var control = new TabPage
-        {
-            ImageIndex = 1,
-            ImageKey = value
-        };
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.True(control.Visible);
-        Assert.Equal(value, control.ImageKey);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.True(control.Visible);
-        Assert.Equal(value, control.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithHandle_GetReturnsExpected(string value)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithHandleWithParent_GetReturnsExpected(string value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void TabPage_ImageKey_SetWithDesignModeParentWithHandle_GetReturnsExpected(string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ImageKey = value;
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(value, control.ImageKey);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabPageCollection_ImageKey_SetGetItemsWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ImageKey = "ImageKey";
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabPageCollection_ImageKey_SetGetItemsWithHandleDesignMode_Success()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ImageKey = "ImageKey";
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    public static IEnumerable<object[]> Location_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(-1, -2), 1 };
-        yield return new object[] { new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void TabPage_Location_Set_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new TabPage();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void TabPage_Location_SetWithParent_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Location = value;
-            Assert.Equal(new Size(200, 100), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-            Assert.Equal(new Size(200, 100), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X + 200, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y + 100, control.Bottom);
-            Assert.Equal(200, control.Width);
-            Assert.Equal(100, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.Location = value;
-            Assert.Equal(new Size(200, 100), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-            Assert.Equal(new Size(200, 100), control.Size);
-            Assert.Equal(value.X, control.Left);
-            Assert.Equal(value.X + 200, control.Right);
-            Assert.Equal(value, control.Location);
-            Assert.Equal(value.Y, control.Top);
-            Assert.Equal(value.Y + 100, control.Bottom);
-            Assert.Equal(200, control.Width);
-            Assert.Equal(100, control.Height);
-            Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Location_SetWithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, new Point(0, 0), 0 };
-            yield return new object[] { resizeRedraw, new Point(-1, -2), 1 };
-            yield return new object[] { resizeRedraw, new Point(1, 0), 1 };
-            yield return new object[] { resizeRedraw, new Point(0, 2), 1 };
-            yield return new object[] { resizeRedraw, new Point(1, 2), 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_SetWithHandle_TestData))]
-    public void TabPage_Location_SetWithHandle_GetReturnsExpected(bool resizeRedraw, Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Location_SetWithParentWithHandle_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, new Point(0, 0) };
-            yield return new object[] { resizeRedraw, new Point(-1, -2) };
-            yield return new object[] { resizeRedraw, new Point(1, 0) };
-            yield return new object[] { resizeRedraw, new Point(0, 2) };
-            yield return new object[] { resizeRedraw, new Point(1, 2) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_SetWithParentWithHandle_TestData))]
-    public void TabPage_Location_SetWithParentWithHandle_GetReturnsExpected(bool resizeRedraw, Point value)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        Rectangle expected = parent.DisplayRectangle;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Location = value;
-            Assert.Equal(expected.Size, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.DisplayRectangle);
-            Assert.Equal(expected.Size, control.Size);
-            Assert.Equal(expected.X, control.Left);
-            Assert.Equal(expected.X + expected.Width, control.Right);
-            Assert.Equal(expected.Location, control.Location);
-            Assert.Equal(expected.Y, control.Top);
-            Assert.Equal(expected.Y + expected.Height, control.Bottom);
-            Assert.Equal(expected.Width, control.Width);
-            Assert.Equal(expected.Height, control.Height);
-            Assert.Equal(expected, control.Bounds);
-            Assert.Equal(0, moveCallCount);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.Location = value;
-            Assert.Equal(expected.Size, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.DisplayRectangle);
-            Assert.Equal(expected.Size, control.Size);
-            Assert.Equal(expected.X, control.Left);
-            Assert.Equal(expected.X + expected.Width, control.Right);
-            Assert.Equal(expected.Location, control.Location);
-            Assert.Equal(expected.Y, control.Top);
-            Assert.Equal(expected.Y + expected.Height, control.Bottom);
-            Assert.Equal(expected.Width, control.Width);
-            Assert.Equal(expected.Height, control.Height);
-            Assert.Equal(expected, control.Bounds);
-            Assert.Equal(0, moveCallCount);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(2, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TabPage_Location_SetWithHandleWithTransparentBackColor_DoesNotCallInvalidate(bool supportsTransparentBackgroundColor, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
-        control.BackColor = Color.FromArgb(254, 255, 255, 255);
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackgroundColor);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-
-        // Set different.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Location_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new TabPage();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different x.
-        control.Location = new Point(2, 2);
-        Assert.Equal(new Point(2, 2), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Set different y.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Location_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabPage))[nameof(TabPage.Location)];
-        using var control = new TabPage();
-        Assert.False(property.CanResetValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.False(property.CanResetValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.False(property.CanResetValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.False(property.CanResetValue(control));
-
-        control.Location = Point.Empty;
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void TabPage_Location_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TabPage))[nameof(TabPage.Location)];
-        using var control = new TabPage();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 0);
-        Assert.Equal(new Point(1, 0), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(0, 1);
-        Assert.Equal(new Point(0, 1), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Location = Point.Empty;
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MaximumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_MaximumSize_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new TabPage
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MinimumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void TabPage_MinimumSize_Set_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new TabPage
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TabControl() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void TabPage_Parent_Set_GetReturnsExpected(Control value)
-    {
-        using var control = new TabPage
-        {
-            Parent = value
-        };
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void TabPage_Parent_SetWithNonNullOldParent_GetReturnsExpected(Control value)
-    {
-        using var oldParent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = oldParent
-        };
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.Empty(oldParent.Controls);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void TabPage_Parent_SetWithHandle_GetReturnsExpected(Control value)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Parent = value;
-        Assert.Same(value, control.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new TabPage();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Parent_SetNonTabControl_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new TabPage();
-        Assert.Throws<ArgumentException>(() => control.Parent = parent);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TabPage_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new TabPage
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TabPage_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new TabPage
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new TabPage();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new TabPage
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabPage
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_SetWithParent_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent,
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_SetWithDesignModeParent_GetReturnsExpected(string value, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent,
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_SetWithParentWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_Text_SetWithDesignModeParentWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Text_SetGetItemsWithHandle_Success(string text, string expectedText)
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.Text = text;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Text", "Text")]
-    [InlineData("&&Text", "&&Text")]
-    [InlineData("&", "&&")]
-    [InlineData("&Text", "&&Text")]
-    public unsafe void TabPageCollection_Text_SetGetItemsWithHandleDesignMode_Success(string text, string expectedText)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.Text = text;
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal(expectedText, new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new TabPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_ToolTipText_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabPage
-        {
-            ToolTipText = value
-        };
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_ToolTipText_SetWithParent_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent,
-            ToolTipText = value
-        };
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_ToolTipText_SetWithDesignModeParent_GetReturnsExpected(string value, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent,
-            ToolTipText = value
-        };
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.False(control.Visible);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TabPage_ToolTipText_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 0)]
-    [InlineData("", "", 0)]
-    [InlineData("text", "text", 1)]
-    public void TabPage_ToolTipText_SetWithParentWithHandle_GetReturnsExpected(string value, string expected, int expectedInvalidateCallCount)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 0)]
-    [InlineData("", "", 0)]
-    [InlineData("text", "text", 1)]
-    public void TabPage_ToolTipText_SetWithDesignModeParentWithHandle_GetReturnsExpected(string value, string expected, int expectedInvalidateCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.ToolTipText = value;
-        Assert.Equal(expected, control.ToolTipText);
-        Assert.True(control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidateCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabPageCollection_ToolTipText_SetGetItemsWithHandle_Success()
-    {
-        using var owner = new TabControl();
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ToolTipText = "ToolTipText";
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsFact]
-    public unsafe void TabPageCollection_ToolTipText_SetGetItemsWithHandleDesignMode_Success()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new TabControl
-        {
-            Site = mockSite.Object
-        };
-        using var page1 = new TabPage();
-        using var page2 = new TabPage
-        {
-            Text = "Text",
-            ImageIndex = 1
-        };
-        using var page3 = new NullTextTabPage();
-        owner.TabPages.Add(page1);
-        owner.TabPages.Add(page2);
-        owner.TabPages.Add(page3);
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-
-        page2.ToolTipText = "ToolTipText";
-        Assert.Equal(3, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMCOUNT));
-
-        char* buffer = stackalloc char[256];
-        ComCtl32.TCITEMW item = default;
-        item.cchTextMax = int.MaxValue;
-        item.pszText = buffer;
-        item.dwStateMask = (TAB_CONTROL_ITEM_STATE)uint.MaxValue;
-        item.mask = (TCITEMHEADERA_MASK)uint.MaxValue;
-
-        // Get item 0.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 0, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-
-        // Get item 1.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 1, ref item));
-        Assert.Equal(TAB_CONTROL_ITEM_STATE.TCIS_BUTTONPRESSED, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Equal("Text", new string(item.pszText));
-        Assert.Equal(1, item.iImage);
-
-        // Get item 2.
-        Assert.Equal(1, (int)PInvoke.SendMessage(owner, PInvoke.TCM_GETITEMW, 2, ref item));
-        Assert.Equal((TAB_CONTROL_ITEM_STATE)0, item.dwState);
-        Assert.Equal(IntPtr.Zero, item.lParam);
-        Assert.Equal(int.MaxValue, item.cchTextMax);
-        Assert.Empty(new string(item.pszText));
-        Assert.Equal(-1, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_UseVisualStyleBackColor_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage
-        {
-            UseVisualStyleBackColor = value
-        };
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TabPage_UseVisualStyleBackColor_SetWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TabPage();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UseVisualStyleBackColor = value;
-        Assert.Equal(value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UseVisualStyleBackColor = !value;
-        Assert.Equal(!value, control.UseVisualStyleBackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TabPage
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_Visible_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent,
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(value, control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Equal(value, control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, true };
-            yield return new object[] { userPaint, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandle_TestData))]
-    public void TabPage_Visible_SetWithHandle_GetReturnsExpected(bool userPaint, bool value)
-    {
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TabPage_Visible_SetWithParentWithHandle_GetReturnsExpected(bool value)
-    {
-        using var parent = new TabControl();
-        using var control = new TabPage
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new TabPage
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabPage();
-        Control.ControlCollection controls = Assert.IsType<TabPage.TabPageControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.False(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabPage();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubTabPage.ScrollStateAutoScrolling, false)]
-    [InlineData(SubTabPage.ScrollStateFullDrag, false)]
-    [InlineData(SubTabPage.ScrollStateHScrollVisible, false)]
-    [InlineData(SubTabPage.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubTabPage.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void TabPage_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubTabPage();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, true)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TabPage_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTabPage();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTabPage();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetTabPageOfComponent_InvokeTabPageInHierarchy_ReturnsExpected()
-    {
-        using var grandparent = new TabPage();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Same(grandparent, TabPage.GetTabPageOfComponent(control));
-        Assert.Same(grandparent, TabPage.GetTabPageOfComponent(parent));
-        Assert.Same(grandparent, TabPage.GetTabPageOfComponent(grandparent));
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetTabPageOfComponent_InvokeNoTabPageInHierarchy_ReturnsNull()
-    {
-        using var grandparent = new Control();
-        using var parent = new Control
-        {
-            Parent = grandparent
-        };
-        using var control = new Control
-        {
-            Parent = parent
-        };
-        Assert.Null(TabPage.GetTabPageOfComponent(control));
-        Assert.Null(TabPage.GetTabPageOfComponent(parent));
-        Assert.Null(TabPage.GetTabPageOfComponent(grandparent));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("NotAControl")]
-    public void TabPage_GetTabPageOfComponent_InvokeInvalidControl_ReturnsNull(object comp)
-    {
-        Assert.Null(TabPage.GetTabPageOfComponent(comp));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabPage_OnEnter_Invoke_DoesNotCallEnter(EventArgs eventArgs)
-    {
-        using var control = new SubTabPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabPage_OnEnter_InvokeWithParent_DoesNotCallEnter(EventArgs eventArgs)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabPage_OnLeave_Invoke_DoesNotCallLeave(EventArgs eventArgs)
-    {
-        using var control = new SubTabPage();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TabPage_OnLeave_InvokeWithParent_DoesNotCallLeave(EventArgs eventArgs)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb), new Bitmap(10, 10, PixelFormat.Format32bppArgb) })
-        {
-            foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-            {
-                yield return new object[] { true, Color.Empty, backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.Red, backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                yield return new object[] { true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                yield return new object[] { false, Color.Empty, backgroundImage, backgroundImageLayout };
-                yield return new object[] { false, Color.Red, backgroundImage, backgroundImageLayout };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void TabPage_OnPaintBackground_Invoke_Success(bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_WithParent_TestData()
-    {
-        foreach (TabAppearance appearance in Enum.GetValues(typeof(TabAppearance)))
-        {
-            foreach (bool useVisualStyleBackColor in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    }
-                }
-
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_WithParent_TestData))]
-    public void TabPage_OnPaintBackground_InvokeWithParent_CallsPaint(TabAppearance appearance, bool useVisualStyleBackColor, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var parent = new TabControl
-        {
-            Bounds = new Rectangle(1, 2, 30, 40),
-            Appearance = appearance
-        };
-        using var control = new SubTabPage
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent,
-            UseVisualStyleBackColor = useVisualStyleBackColor
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(1, 2, 0, 0), e.ClipRectangle);
-            parentCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void TabPage_OnPaintBackground_InvokeWithHandle_Success(bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_WithParentWithHandle_TestData()
-    {
-        foreach (TabAppearance appearance in Enum.GetValues(typeof(TabAppearance)))
-        {
-            foreach (bool useVisualStyleBackColor in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    }
-                }
-
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { appearance, useVisualStyleBackColor, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { appearance, useVisualStyleBackColor, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_WithParentWithHandle_TestData))]
-    public void TabPage_OnPaintBackground_InvokeWithParentWithHandle_CallsPaint(TabAppearance appearance, bool useVisualStyleBackColor, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var parent = new TabControl
-        {
-            Bounds = new Rectangle(1, 2, 30, 40),
-            Appearance = appearance,
-        };
-        using var control = new SubTabPage
-        {
-            Bounds = new Rectangle(1, 2, 10, 20),
-            Parent = parent,
-            UseVisualStyleBackColor = useVisualStyleBackColor
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(parent.DisplayRectangle, e.ClipRectangle);
-            parentCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TabPage_OnPaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var control = new SubTabPage();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 0, 0, specified, 0 };
-            yield return new object[] { -1, -2, -3, -4, specified, 1 };
-            yield return new object[] { 1, 0, 0, 0, specified, 1 };
-            yield return new object[] { 0, 2, 0, 0, specified, 1 };
-            yield return new object[] { 1, 2, 0, 0, specified, 1 };
-            yield return new object[] { 0, 0, 1, 0, specified, 0 };
-            yield return new object[] { 0, 0, 0, 2, specified, 0 };
-            yield return new object[] { 0, 0, 1, 2, specified, 0 };
-            yield return new object[] { 1, 2, 30, 40, specified, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TabPage_SetBoundsCore_Invoke_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubTabPage();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TabPage_SetBoundsCore_InvokeWithParent_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(1, resizeCallCount);
-            Assert.Equal(1, sizeChangedCallCount);
-            Assert.Equal(1, clientSizeChangedCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Call again.
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(new Size(width, height), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-            Assert.Equal(new Size(width, height), control.Size);
-            Assert.Equal(x, control.Left);
-            Assert.Equal(x + width, control.Right);
-            Assert.Equal(y, control.Top);
-            Assert.Equal(y + height, control.Bottom);
-            Assert.Equal(width, control.Width);
-            Assert.Equal(height, control.Height);
-            Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(1, layoutCallCount);
-            Assert.Equal(1, resizeCallCount);
-            Assert.Equal(1, sizeChangedCallCount);
-            Assert.Equal(1, clientSizeChangedCallCount);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_WithHandle_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { true, 0, 0, 0, 0, specified, 0, 0, 0, 1 };
-            yield return new object[] { true, -1, -2, -3, -4, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, 1, 0, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, 0, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, 1, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, 0, 0, 1, 0, specified, 1, 0, 0, 1 };
-            yield return new object[] { true, 0, 0, 0, 2, specified, 0, 2, 0, 1 };
-            yield return new object[] { true, 0, 0, 1, 2, specified, 1, 2, 0, 1 };
-            yield return new object[] { true, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-
-            yield return new object[] { false, 0, 0, 0, 0, specified, 0, 0, 0, 0 };
-            yield return new object[] { false, -1, -2, -3, -4, specified, 0, 0, 1, 0 };
-            yield return new object[] { false, 1, 0, 0, 0, specified, 0, 0, 1, 0 };
-            yield return new object[] { false, 0, 2, 0, 0, specified, 0, 0, 1, 0 };
-            yield return new object[] { false, 1, 2, 0, 0, specified, 0, 0, 1, 0 };
-            yield return new object[] { false, 0, 0, 1, 0, specified, 1, 0, 0, 0 };
-            yield return new object[] { false, 0, 0, 0, 2, specified, 0, 2, 0, 0 };
-            yield return new object[] { false, 0, 0, 1, 2, specified, 1, 2, 0, 0 };
-            yield return new object[] { false, 1, 2, 30, 40, specified, 30, 40, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithHandle_TestData))]
-    public void TabPage_SetBoundsCore_InvokeWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified, int expectedWidth, int expectedHeight, int expectedLocationChangedCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTabPage();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_WithParentWithHandle_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            foreach (bool resizeRedraw in new bool[] { true, false })
-            {
-                yield return new object[] { resizeRedraw, 0, 0, 0, 0, specified };
-                yield return new object[] { resizeRedraw, -1, -2, -3, -4, specified };
-                yield return new object[] { resizeRedraw, 1, 0, 0, 0, specified };
-                yield return new object[] { resizeRedraw, 0, 2, 0, 0, specified };
-                yield return new object[] { resizeRedraw, 1, 2, 0, 0, specified };
-                yield return new object[] { resizeRedraw, 0, 0, 1, 0, specified };
-                yield return new object[] { resizeRedraw, 0, 0, 0, 2, specified };
-                yield return new object[] { resizeRedraw, 0, 0, 1, 2, specified };
-                yield return new object[] { resizeRedraw, 1, 2, 30, 40, specified };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_WithParentWithHandle_TestData))]
-    public void TabPage_SetBoundsCore_InvokeWithParentWithHandle_Success(bool resizeRedraw, int x, int y, int width, int height, BoundsSpecified specified)
-    {
-        using var parent = new TabControl();
-        using var control = new SubTabPage
-        {
-            Parent = parent
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        Rectangle expected = parent.DisplayRectangle;
-
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        int parentLayoutCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            Assert.Equal(parentLayoutCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            Assert.Equal(parentLayoutCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(parentLayoutCallCount, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(layoutCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, parentLayoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount - 1, parentLayoutCallCount);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(expected.Size, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.DisplayRectangle);
-            Assert.Equal(expected.Size, control.Size);
-            Assert.Equal(expected.X, control.Left);
-            Assert.Equal(expected.X + expected.Width, control.Right);
-            Assert.Equal(expected.Location, control.Location);
-            Assert.Equal(expected.Y, control.Top);
-            Assert.Equal(expected.Y + expected.Height, control.Bottom);
-            Assert.Equal(expected.Width, control.Width);
-            Assert.Equal(expected.Height, control.Height);
-            Assert.Equal(expected, control.Bounds);
-            Assert.Equal(0, moveCallCount);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Call again.
-            control.SetBoundsCore(x, y, width, height, specified);
-            Assert.Equal(expected.Size, control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, expected.Width, expected.Height), control.DisplayRectangle);
-            Assert.Equal(expected.Size, control.Size);
-            Assert.Equal(expected.X, control.Left);
-            Assert.Equal(expected.X + expected.Width, control.Right);
-            Assert.Equal(expected.Location, control.Location);
-            Assert.Equal(expected.Y, control.Top);
-            Assert.Equal(expected.Y + expected.Height, control.Bottom);
-            Assert.Equal(expected.Width, control.Width);
-            Assert.Equal(expected.Height, control.Height);
-            Assert.Equal(expected, control.Bounds);
-            Assert.Equal(0, moveCallCount);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.Equal(0, resizeCallCount);
-            Assert.Equal(0, sizeChangedCallCount);
-            Assert.Equal(0, clientSizeChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TabPage_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new TabPage();
-        Assert.Equal("TabPage: {}", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TabPage_ToString_InvokeWithText_ReturnsExpected()
-    {
-        using var control = new TabPage("text");
-        Assert.Equal("TabPage: {text}", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TabPage_ToString_InvokeWithNullText_ReturnsExpected()
-    {
-        using var control = new NullTextTabPage();
-        Assert.Equal("TabPage: {}", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetCaptionForTool_ReturnsToolTipText_IfToolTipTextIsSet()
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-        using ToolTip toolTip = new ToolTip();
-
-        string actual = ((IKeyboardToolTip)control).GetCaptionForTool(toolTip);
-
-        Assert.Equal(text, actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetCaptionForTool_ReturnsExternalToolTipText_IfInternalsAreNotSet()
-    {
-        using TabPage control = new TabPage();
-        using ToolTip toolTip = new ToolTip();
-        control.CreateControl();
-
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the tooltip native window Handle
-
-        string text = "Some test text";
-        toolTip.SetToolTip(control, text);
-
-        string actual = ((IKeyboardToolTip)control).GetCaptionForTool(toolTip);
-
-        Assert.Equal(text, actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetCaptionForTool_ReturnsNull_IfNoToolTipIsSet()
-    {
-        using TabPage control = new TabPage();
-        using ToolTip toolTip = new ToolTip();
-
-        string actual = ((IKeyboardToolTip)control).GetCaptionForTool(toolTip);
-
-        Assert.Null(actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetNeighboringToolsRectangles_ReturnsEmptyCollection_IfPageDoesntHaveTabControl()
-    {
-        using TabPage control = new TabPage();
-
-        IList<Rectangle> actual = ((IKeyboardToolTip)control).GetNeighboringToolsRectangles();
-
-        Assert.Empty(actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    [InlineData(4)]
-    public void TabPage_GetNeighboringToolsRectangles_ReturnsCorrect(int index)
-    {
-        using TabControl tabControl = new TabControl();
-        const int pagesCount = 5;
-
-        for (int i = 0; i < pagesCount; i++)
-        {
-            tabControl.TabPages.Add(new TabPage());
-        }
-
-        TabPage testedTab = tabControl.TabPages[index];
-        IList<Rectangle> neighborsRectangles = ((IKeyboardToolTip)testedTab).GetNeighboringToolsRectangles();
-
-        Assert.NotEmpty(neighborsRectangles);
-
-        if (index > 0) // has the left neighbor
-        {
-            Assert.True(neighborsRectangles.Contains(GetTabRect(index - 1))); // check the left neighbor
-
-            for (int i = 0; i < index - 1; i++)
-            {
-                Assert.False(neighborsRectangles.Contains(GetTabRect(i))); // check the rest lefts
-            }
-        }
-
-        if (index < pagesCount - 1) // has the right neighbor
-        {
-            Assert.True(neighborsRectangles.Contains(GetTabRect(index + 1))); // check the right neighbor
-
-            for (int i = index + 2; i < pagesCount; i++)
-            {
-                Assert.False(neighborsRectangles.Contains(GetTabRect(i))); // check the rest rights
-            }
-        }
-
-        Rectangle GetTabRect(int index)
-            => tabControl.RectangleToScreen(tabControl.GetTabRect(index));
-    }
-
-    [WinFormsFact]
-    public void TabPage_InternalToolTip_IsSet_IfNoExternalIsSet()
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        ToolTip internalToolTip = control.TestAccessor().Dynamic._internalToolTip;
-        string actual = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Equal(text, actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_InternalToolTip_IsNotSet_IfExternalIsSet()
-    {
-        using TabPage control = new TabPage();
-        using ToolTip toolTip = new ToolTip();
-        string text = "Some test text";
-        control.ToolTipText = text;
-        control.CreateControl();
-
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the tooltip native window Handle
-
-        toolTip.SetToolTip(control, text);
-        ToolTip internalToolTip = control.TestAccessor().Dynamic._internalToolTip;
-        string actual = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Null(actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetToolNativeScreenRectangle_ReturnsExpected()
-    {
-        using TabControl tabControl = new TabControl();
-        using TabPage page = new TabPage();
-        tabControl.TabPages.Add(page);
-
-        Rectangle expected = tabControl.RectangleToScreen(tabControl.GetTabRect(0));
-        Rectangle actual = page.GetToolNativeScreenRectangle();
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void TabPage_GetToolNativeScreenRectangle_ReturnsEmpty_WithoutParent()
-    {
-        using TabPage control = new TabPage();
-
-        Rectangle actual = control.GetToolNativeScreenRectangle();
-
-        Assert.Equal(Rectangle.Empty, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, null)]
-    [InlineData(false, "Some test text")]
-    public void TabPage_SetToolTip_ManagesAssociatedToolTips_ForOneToolTipInstance(bool createToolTip, string expectedText)
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        dynamic tabPageDynamic = control.TestAccessor().Dynamic;
-        ToolTip internalToolTip = tabPageDynamic._internalToolTip;
-        ToolTip externalToolTip = tabPageDynamic._externalToolTip;
-        List<ToolTip> associatedToolTips = tabPageDynamic._associatedToolTips;
-        string actualText = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Equal(text, actualText);
-        Assert.Null(externalToolTip);
-        Assert.Null(associatedToolTips);
-
-        using ToolTip toolTip = createToolTip
-            ? new ToolTip() // TabPage's SetToolTip will clear the internal toolTip because external one is set
-            : null;  // TabPage's SetToolTip won't change states of fields and won't throw any exceptions
-
-        control.SetToolTip(toolTip);
-
-        externalToolTip = tabPageDynamic._externalToolTip;
-        associatedToolTips = tabPageDynamic._associatedToolTips;
-        actualText = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Equal(expectedText, actualText);
-        Assert.Equal(toolTip, externalToolTip);
-        Assert.Null(associatedToolTips);
-    }
-
-    [WinFormsFact]
-    public void TabPage_SetToolTip_ManagesInternalAndAssociatedToolTips_ForTwoToolTipInstances()
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        dynamic tabPageDynamic = control.TestAccessor().Dynamic;
-        ToolTip internalToolTip = tabPageDynamic._internalToolTip;
-        ToolTip externalToolTip = tabPageDynamic._externalToolTip;
-        List<ToolTip> associatedToolTips = tabPageDynamic._associatedToolTips;
-        string actualText = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Equal(text, actualText);
-        Assert.Null(externalToolTip);
-        Assert.Null(associatedToolTips);
-
-        using ToolTip toolTip1 = new ToolTip();
-        using ToolTip toolTip2 = new ToolTip();
-
-        control.SetToolTip(toolTip1);
-        control.SetToolTip(toolTip2);
-
-        actualText = internalToolTip.GetCaptionForTool(control);
-        externalToolTip = tabPageDynamic._externalToolTip;
-        associatedToolTips = tabPageDynamic._associatedToolTips;
-
-        Assert.Null(actualText);
-        Assert.Equal(toolTip1, externalToolTip);
-        Assert.Equal(2, associatedToolTips.Count);
-        Assert.Equal(toolTip1, associatedToolTips[0]);
-        Assert.Equal(toolTip2, associatedToolTips[1]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(false, false)]
-    public void TabPage_RemoveToolTip_ManagesAssociatedToolTips_ForOneToolTipInstance(bool createToolTip, bool setToolTip)
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        dynamic tabPageDynamic = control.TestAccessor().Dynamic;
-        ToolTip internalToolTip = tabPageDynamic._internalToolTip;
-        ToolTip externalToolTip = tabPageDynamic._externalToolTip;
-
-        using ToolTip toolTip = createToolTip
-            ? new ToolTip() // TabPage's RemoveToolTip will clear the internal toolTip because external one is set
-            : null;  // TabPage's RemoveToolTip won't change states of fields and won't throw any exceptions
-
-        if (createToolTip && setToolTip)
-        {
-            // A simple workaround in the test to set expected states for fields
-            control.SetToolTip(toolTip);
-        }
-
-        control.RemoveToolTip(toolTip);
-
-        List<ToolTip> associatedToolTips = tabPageDynamic._associatedToolTips;
-        string actualText = internalToolTip.GetCaptionForTool(control);
-
-        Assert.Equal(text, actualText);
-        Assert.Null(externalToolTip);
-        Assert.Null(associatedToolTips);
-    }
-
-    [WinFormsFact]
-    public void TabPage_RemoveToolTip_ManagesAssociatedToolTips_ForTwoToolTipInstances()
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        dynamic tabPageDynamic = control.TestAccessor().Dynamic;
-        ToolTip internalToolTip = tabPageDynamic._internalToolTip;
-
-        using ToolTip toolTip1 = new ToolTip();
-        using ToolTip toolTip2 = new ToolTip();
-
-        // A simple workaround in the test to set expected states for fields
-        control.SetToolTip(toolTip1);
-        control.SetToolTip(toolTip2);
-
-        control.RemoveToolTip(toolTip1);
-
-        List<ToolTip> associatedToolTips = tabPageDynamic._associatedToolTips;
-        ToolTip externalToolTip = tabPageDynamic._externalToolTip;
-
-        Assert.Equal(toolTip2, externalToolTip);
-        Assert.Null(associatedToolTips);
-    }
-
-    [WinFormsFact]
-    public void TabPage_RemoveToolTip_ManagesAssociatedToolTips_ForThreeToolTipInstances()
-    {
-        using TabPage control = new TabPage();
-        string text = "Some test text";
-        control.ToolTipText = text;
-
-        dynamic tabPageDynamic = control.TestAccessor().Dynamic;
-        ToolTip internalToolTip = tabPageDynamic._internalToolTip;
-        ToolTip externalToolTip = tabPageDynamic._externalToolTip;
-
-        using ToolTip toolTip1 = new ToolTip();
-        using ToolTip toolTip2 = new ToolTip();
-        using ToolTip toolTip3 = new ToolTip();
-
-        // A simple workaround in the test to set expected states for fields
-        control.SetToolTip(toolTip1);
-        control.SetToolTip(toolTip2);
-        control.SetToolTip(toolTip3);
-
-        control.RemoveToolTip(toolTip1);
-
-        List<ToolTip> associatedToolTips = tabPageDynamic._associatedToolTips;
-
-        Assert.Equal(2, associatedToolTips.Count);
-        Assert.Equal(toolTip2, associatedToolTips[0]);
-        Assert.Equal(toolTip3, associatedToolTips[1]);
-    }
-
-    private class NullTextTabPage : TabPage
-    {
-        public override string Text
-        {
-            get => null;
-            set { }
-        }
-    }
-
-    private class SubTabPage : TabPage
-    {
-        public new const int ScrollStateAutoScrolling = TabPage.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = TabPage.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = TabPage.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = TabPage.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = TabPage.ScrollStateFullDrag;
-
-        public SubTabPage() : base()
-        {
-        }
-
-        public SubTabPage(string text) : base(text)
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutCellPaintEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutCellPaintEventArgsTests.cs
deleted file mode 100644
index 6303b03ab6a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutCellPaintEventArgsTests.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TableLayoutCellPaintEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Rectangle_Rectangle_Int_Int_TestData()
-    {
-        yield return new object[] { Rectangle.Empty, Rectangle.Empty, -2, -2 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), -1, -1 };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4), new Rectangle(-1, -2, -3, -4), 0, 0 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(2, 3, 4, 5), 1, 2 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_Rectangle_Rectangle_Int_Int_TestData))]
-    public void Ctor_Graphics_Rectangle_Rectangle_Int_Int(Rectangle clipRectangle, Rectangle cellBounds, int column, int row)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new TableLayoutCellPaintEventArgs(graphics, clipRectangle, cellBounds, column, row);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(clipRectangle, e.ClipRectangle);
-        Assert.Equal(cellBounds, e.CellBounds);
-        Assert.Equal(column, e.Column);
-        Assert.Equal(row, e.Row);
-    }
-
-    [Fact]
-    public void Ctor_NullGraphics_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("graphics", () => new TableLayoutCellPaintEventArgs(
-            (Graphics)null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4), 1, 2));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutColumnStyleCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutColumnStyleCollectionTests.cs
deleted file mode 100644
index bda7078102f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutColumnStyleCollectionTests.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutColumnStyleCollectionTests
-{
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Add_ColumnStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-
-        var style = new ColumnStyle();
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Add_RowStyle_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-
-        var style = new RowStyle();
-        Assert.Throws<InvalidCastException>(() => collection.Add(style));
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Insert_ColumnStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-
-        var style = new ColumnStyle();
-        collection.Insert(0, style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Item_SetColumnStyle_GetReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-        collection.Add(new ColumnStyle());
-
-        var style = new ColumnStyle();
-        collection[0] = style;
-        Assert.Single(collection);
-        Assert.Equal(style, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Item_GetNotColumnStyle_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-        Assert.Throws<InvalidCastException>(() => collection.Add(new RowStyle()));
-        Assert.Throws<InvalidCastException>(() => collection[0]);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Remove_ColumnStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-        var style = new ColumnStyle();
-        collection.Add(style);
-        collection.Remove(style);
-        Assert.Empty(collection);
-
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_Contains_ColumnStyle_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-        var style = new ColumnStyle();
-        collection.Add(style);
-        Assert.True(collection.Contains(style));
-        Assert.False(collection.Contains(new ColumnStyle()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutColumnStyleCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutColumnStyleCollection collection = settings.ColumnStyles;
-        var style = new ColumnStyle();
-        collection.Add(style);
-        Assert.Equal(0, collection.IndexOf(style));
-        Assert.Equal(-1, collection.IndexOf(new ColumnStyle()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutControlCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutControlCollectionTests.cs
deleted file mode 100644
index 9f7986ccca5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutControlCollectionTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutControlCollectionTests
-{
-    [WinFormsFact]
-    public void TableLayoutControlCollection_Ctor_TableLayoutPanel()
-    {
-        using var container = new TableLayoutPanel();
-        var collection = new TableLayoutControlCollection(container);
-        Assert.Equal(container, collection.Container);
-        Assert.Equal(container, collection.Owner);
-        Assert.Empty(collection);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutControlCollection_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new TableLayoutControlCollection(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void TableLayoutControlCollection_Add_ValidControl_Success(int column, int row)
-    {
-        using var container = new TableLayoutPanel();
-        var collection = new TableLayoutControlCollection(container);
-        using var child = new Control();
-        collection.Add(child, column, row);
-        Assert.Equal(child, Assert.Single(collection));
-        Assert.Equal(column, container.GetColumn(child));
-        Assert.Equal(row, container.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutControlCollection_Add_NegativeColumn_ThrowsArgumentOutOfRangeException()
-    {
-        using var container = new TableLayoutPanel();
-        var collection = new TableLayoutControlCollection(container);
-        using var child = new Control();
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => collection.Add(child, -2, 2));
-        Assert.Equal(child, Assert.Single(collection));
-        Assert.Equal(-1, container.GetColumn(child));
-        Assert.Equal(-1, container.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutControlCollection_Add_NegativeRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var container = new TableLayoutPanel();
-        var collection = new TableLayoutControlCollection(container);
-        using var child = new Control();
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => collection.Add(child, 1, -2));
-        Assert.Equal(child, Assert.Single(collection));
-        Assert.Equal(1, container.GetColumn(child));
-        Assert.Equal(-1, container.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutControlCollection_Add_NullControl_ThrowsArgumentNullException()
-    {
-        using var container = new TableLayoutPanel();
-        var collection = new TableLayoutControlCollection(container);
-        Assert.Throws<ArgumentNullException>("control", () => collection.Add(null, 1, 2));
-        Assert.Empty(collection);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanel.TableLayoutPanelAccessibleObectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanel.TableLayoutPanelAccessibleObectTests.cs
deleted file mode 100644
index 58c693cad39..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanel.TableLayoutPanelAccessibleObectTests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutPanel_TableLayoutPanelAccessibilityObjectTests
-{
-    [WinFormsFact]
-    public void TableLayoutPanelAccessibilityObject_Ctor_Default()
-    {
-        using TableLayoutPanel tableLayoutPanel = new TableLayoutPanel();
-        tableLayoutPanel.CreateControl();
-
-        Assert.NotNull(tableLayoutPanel.AccessibilityObject);
-        Assert.True(tableLayoutPanel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanelAccessibilityObject_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using TableLayoutPanel tableLayoutPanel = new TableLayoutPanel();
-        tableLayoutPanel.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = tableLayoutPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.PaneControlTypeId, actual);
-        Assert.True(tableLayoutPanel.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanelAccessibilityObject_Role_IsClient_ByDefault()
-    {
-        using TableLayoutPanel tableLayoutPanel = new TableLayoutPanel();
-        tableLayoutPanel.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = tableLayoutPanel.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Client, actual);
-        Assert.True(tableLayoutPanel.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TableLayoutPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TableLayoutPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TableLayoutPanelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TableLayoutPanel tableLayoutPanel = new TableLayoutPanel();
-        tableLayoutPanel.AccessibleRole = role;
-
-        object actual = tableLayoutPanel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(tableLayoutPanel.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelCellPositionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelCellPositionTests.cs
deleted file mode 100644
index 9e6c47884d6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelCellPositionTests.cs
+++ /dev/null
@@ -1,328 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TableLayoutPanelCellPositionTests
-{
-    [Fact]
-    public void TableLayoutPanelCellPosition_Ctor_Default()
-    {
-        var style = new TableLayoutPanelCellPosition();
-        Assert.Equal(0, style.Column);
-        Assert.Equal(0, style.Row);
-    }
-
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    public void TableLayoutPanelCellPosition_Ctor_Int_int(int column, int row)
-    {
-        var style = new TableLayoutPanelCellPosition(column, row);
-        Assert.Equal(column, style.Column);
-        Assert.Equal(row, style.Row);
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_Ctor_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => new TableLayoutPanelCellPosition(-2, 0));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_Ctor_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => new TableLayoutPanelCellPosition(0, -2));
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TableLayoutPanelCellPosition_Column_Set_GetReturnsExpected(int value)
-    {
-        var style = new TableLayoutPanelCellPosition
-        {
-            Column = value
-        };
-        Assert.Equal(value, style.Column);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TableLayoutPanelCellPosition_Row_Set_GetReturnsExpected(int value)
-    {
-        var style = new TableLayoutPanelCellPosition
-        {
-            Row = value
-        };
-        Assert.Equal(value, style.Row);
-    }
-
-    public static IEnumerable<object[]> Equals_TestData()
-    {
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), new TableLayoutPanelCellPosition(1, 2), true };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), new TableLayoutPanelCellPosition(2, 2), false };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), new TableLayoutPanelCellPosition(1, 3), false };
-
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), new object(), false };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), null, false };
-    }
-
-    [Theory]
-    [MemberData(nameof(Equals_TestData))]
-    public void TableLayoutPanelCellPosition_Equals_Invoke_ReturnsExpected(TableLayoutPanelCellPosition position, object other, bool expected)
-    {
-        if (other is TableLayoutPanelCellPosition otherPosition)
-        {
-            Assert.Equal(expected, position.GetHashCode().Equals(other.GetHashCode()));
-            Assert.Equal(expected, position == otherPosition);
-            Assert.Equal(!expected, position != otherPosition);
-        }
-
-        Assert.Equal(expected, position.Equals(other));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ToString_Invoke_ReturnsExpected()
-    {
-        var position = new TableLayoutPanelCellPosition(1, 2);
-        Assert.Equal("1,2", position.ToString());
-    }
-
-    public static TheoryData<Type, bool> CanConvertFromData =>
-        CommonTestHelper.GetConvertFromTheoryData();
-
-    [Theory]
-    [MemberData(nameof(CanConvertFromData))]
-    [InlineData(typeof(TableLayoutSettings), false)]
-    [InlineData(typeof(string), true)]
-    public void TableLayoutPanelCellPosition_ConverterCanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Equal(expected, converter.CanConvertFrom(sourceType));
-    }
-
-    public static IEnumerable<object[]> ConvertFrom_TestData()
-    {
-        yield return new object[] { "1,2", new TableLayoutPanelCellPosition(1, 2) };
-        yield return new object[] { "  1 , 2 ", new TableLayoutPanelCellPosition(1, 2) };
-        yield return new object[] { "   ", null };
-        yield return new object[] { string.Empty, null };
-    }
-
-    [Theory]
-    [MemberData(nameof(ConvertFrom_TestData))]
-    public void TableLayoutPanelCellPosition_ConverterConvertFrom_String_ReturnsExpected(string value, object expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Equal(expected, converter.ConvertFrom(value));
-        Assert.Equal(expected, converter.ConvertFrom(null, null, value));
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(null)]
-    public void TableLayoutPanelCellPosition_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(value));
-    }
-
-    [Theory]
-    [InlineData("1")]
-    [InlineData("1,2,3")]
-    public void TableLayoutPanelCellPosition_ConverterConvertFrom_InvalidString_ThrowsArgumentException(string value)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentException>("value", () => converter.ConvertFrom(value));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterConvertFrom_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => converter.ConvertFrom("-2,2"));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterConvertFrom_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => converter.ConvertFrom("1,-2"));
-    }
-
-    [Theory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(TableLayoutPanelCellPosition), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void TableLayoutPanelCellPosition_ConverterCanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterConvertTo_InstanceDescriptor_ReturnsExpected()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(new TableLayoutPanelCellPosition(1, 2), typeof(InstanceDescriptor)));
-        Assert.Equal(typeof(TableLayoutPanelCellPosition).GetConstructor(new Type[] { typeof(int), typeof(int) }), descriptor.MemberInfo);
-        Assert.Equal(new object[] { 1, 2 }, descriptor.Arguments);
-        Assert.True(descriptor.IsComplete);
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterConvertTo_ValueNotTableLayoutPanelCellPosition_ThrowsNotSupportedException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [Theory]
-    [InlineData(typeof(TableLayoutPanelCellPosition))]
-    [InlineData(typeof(int))]
-    public void TableLayoutPanelCellPosition_ConverterConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new TableLayoutPanelCellPosition(), destinationType));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterCreateInstance_ValidPropertyValues_ReturnsExpected()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        TableLayoutPanelCellPosition position = Assert.IsType<TableLayoutPanelCellPosition>(converter.CreateInstance(null, new Dictionary<string, object>
-        {
-            { nameof(TableLayoutPanelCellPosition.Column), 1 },
-            { nameof(TableLayoutPanelCellPosition.Row), 2 }
-        }));
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 2), position);
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterCreateInstance_NullPropertyValues_ThrowsArgumentNullException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentNullException>("propertyValues", () => converter.CreateInstance(null, null));
-    }
-
-    public static IEnumerable<object[]> CreateInstance_InvalidPropertyValueType_TestData()
-    {
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Row), new object() },
-                { nameof(TableLayoutPanelCellPosition.Column), 2 },
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Row), null },
-                { nameof(TableLayoutPanelCellPosition.Column), 2 },
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Column), 2 }
-            }
-        };
-
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Row), 1 },
-                { nameof(TableLayoutPanelCellPosition.Column), new object() }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Row), 1 },
-                { nameof(TableLayoutPanelCellPosition.Column), null }
-            }
-        };
-        yield return new object[]
-        {
-            new Dictionary<string, object>
-            {
-                { nameof(TableLayoutPanelCellPosition.Row), 1 }
-            }
-        };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateInstance_InvalidPropertyValueType_TestData))]
-    public void TableLayoutPanelCellPosition_CreateInstance_InvalidPropertyValueType_ThrowsArgumentException(IDictionary propertyValues)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentException>("propertyValues", () => converter.CreateInstance(null, propertyValues));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterCreateInstance_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => converter.CreateInstance(null, new Dictionary<string, object>
-        {
-            { nameof(TableLayoutPanelCellPosition.Column), -2 },
-            { nameof(TableLayoutPanelCellPosition.Row), 2 }
-        }));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterCreateInstance_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => converter.CreateInstance(null, new Dictionary<string, object>
-        {
-            { nameof(TableLayoutPanelCellPosition.Column), 1 },
-            { nameof(TableLayoutPanelCellPosition.Row), -2 }
-        }));
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterGetCreateInstanceSupported_Invoke_ReturnsTrue()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.True(converter.GetCreateInstanceSupported());
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterGetProperties_Invoke_ReturnsExpected()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        PropertyDescriptorCollection properties = converter.GetProperties(null);
-        Assert.Equal(2, properties.Count);
-        Assert.Equal(nameof(TableLayoutPanelCellPosition.Column), properties[0].Name);
-        Assert.Equal(nameof(TableLayoutPanelCellPosition.Row), properties[1].Name);
-    }
-
-    [Fact]
-    public void TableLayoutPanelCellPosition_ConverterGetPropertiesSupported_Invoke_ReturnsTrue()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutPanelCellPosition));
-        Assert.True(converter.GetPropertiesSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelTests.cs
deleted file mode 100644
index b702da585b5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutPanelTests.cs
+++ /dev/null
@@ -1,2261 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutPanelTests
-{
-    [WinFormsFact]
-    public void TableLayoutPanel_Ctor_Default()
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(TableLayoutPanelCellBorderStyle.None, control.CellBorderStyle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(0, control.ColumnCount);
-        Assert.Empty(control.ColumnStyles);
-        Assert.Same(control.LayoutSettings.ColumnStyles, control.ColumnStyles);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(TableLayoutPanelGrowStyle.AddRows, control.GrowStyle);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.NotNull(control.LayoutSettings);
-        Assert.Same(control.LayoutSettings, control.LayoutSettings);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, control.RowCount);
-        Assert.Empty(control.RowStyles);
-        Assert.Same(control.LayoutSettings.RowStyles, control.RowStyles);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTableLayoutPanel();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(100, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(200, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void TableLayoutPanel_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new TableLayoutPanel()
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void TableLayoutPanel_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void TableLayoutPanel_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    public static IEnumerable<object[]> CellBorderStyle_Set_TestData()
-    {
-        foreach (bool resizeRedraw in new bool[] { true, false })
-        {
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.Inset, true, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.InsetDouble, true, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.None, resizeRedraw, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.Outset, true, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.OutsetDouble, true, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.OutsetPartial, true, 1 };
-            yield return new object[] { resizeRedraw, TableLayoutPanelCellBorderStyle.Single, true, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CellBorderStyle_Set_TestData))]
-    public void TableLayoutPanel_CellBorderStyle_Set_GetReturnsExpected(bool resizeRedraw, TableLayoutPanelCellBorderStyle value, bool expectedResizeRedraw, int expectedLayoutCallCount)
-    {
-        using var control = new SubTableLayoutPanel();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("CellBorderStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.CellBorderStyle = value;
-        Assert.Equal(value, control.CellBorderStyle);
-        Assert.Equal(expectedResizeRedraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CellBorderStyle = value;
-        Assert.Equal(value, control.CellBorderStyle);
-        Assert.Equal(expectedResizeRedraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CellBorderStyle_Set_TestData))]
-    public void TableLayoutPanel_CellBorderStyle_SetWithHandle_GetReturnsExpected(bool resizeRedraw, TableLayoutPanelCellBorderStyle value, bool expectedResizeRedraw, int expectedLayoutCallCount)
-    {
-        using var control = new SubTableLayoutPanel();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("CellBorderStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.CellBorderStyle = value;
-        Assert.Equal(value, control.CellBorderStyle);
-        Assert.Equal(expectedResizeRedraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CellBorderStyle = value;
-        Assert.Equal(value, control.CellBorderStyle);
-        Assert.Equal(expectedResizeRedraw, control.GetStyle(ControlStyles.ResizeRedraw));
-        Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TableLayoutPanelCellBorderStyle>]
-    public void TableLayoutPanel_CellBorderStyle_SetInvalid_ThrowsArgumentOutOfRangeException(TableLayoutPanelCellBorderStyle value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.CellBorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    public void TableLayoutPanel_ColumnCount_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Columns", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.ColumnCount = value;
-        Assert.Equal(value, control.ColumnCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ColumnCount = value;
-        Assert.Equal(value, control.ColumnCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_ColumnCount_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ColumnCount = -1);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_Controls_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TableLayoutPanel))[nameof(Control.Controls)];
-        using var control = new TableLayoutPanel();
-        Assert.False(property.CanResetValue(control));
-
-        Assert.Empty(control.Controls);
-        Assert.False(property.CanResetValue(control));
-
-        using var child = new Control();
-        control.Controls.Add(child);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_Controls_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TableLayoutPanel))[nameof(Control.Controls)];
-        using var control = new TableLayoutPanel();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        Assert.Empty(control.Controls);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        using var child = new Control();
-        control.Controls.Add(child);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Same(child, Assert.Single(control.Controls));
-        Assert.True(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize, 1)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows, 0)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns, 1)]
-    public void TableLayoutPanel_GrowStyle_Set_GetReturnsExpected(TableLayoutPanelGrowStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GrowStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GrowStyle = value;
-        Assert.Equal(value, control.GrowStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GrowStyle = value;
-        Assert.Equal(value, control.GrowStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TableLayoutPanelGrowStyle>]
-    public void TableLayoutPanel_GrowStyle_SetInvalid_ThrowsArgumentOutOfRangeException(TableLayoutPanelGrowStyle value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.GrowStyle = value);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetEmptyStub_Success()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("LayoutSettings", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Empty(control.LayoutSettings.ColumnStyles);
-        Assert.Empty(control.LayoutSettings.RowStyles);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Empty(control.LayoutSettings.ColumnStyles);
-        Assert.Empty(control.LayoutSettings.RowStyles);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetStubWithoutControls_Success()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        var columnStyle = new ColumnStyle(SizeType.Percent, 1);
-        var rowStyle = new RowStyle(SizeType.Percent, 1);
-        settings.ColumnStyles.Add(columnStyle);
-        settings.RowStyles.Add(rowStyle);
-
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("LayoutSettings", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Equal(columnStyle, Assert.Single(control.LayoutSettings.ColumnStyles));
-        Assert.Equal(rowStyle, Assert.Single(control.LayoutSettings.RowStyles));
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Empty(control.LayoutSettings.ColumnStyles);
-        Assert.Empty(control.LayoutSettings.RowStyles);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetStubWithControls_Success()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        var columnStyle = new ColumnStyle(SizeType.Percent, 1);
-        var rowStyle = new RowStyle(SizeType.Percent, 1);
-
-        settings.SetColumnSpan("name", 1);
-        settings.SetRowSpan("name", 2);
-        settings.SetColumn("name", 3);
-        settings.SetRow("name", 4);
-        settings.SetColumnSpan("noSuchName", 5);
-        settings.SetRowSpan("noSuchName", 6);
-        settings.SetColumn("noSuchName", 7);
-        settings.SetRow("noSuchName", 8);
-        settings.ColumnStyles.Add(columnStyle);
-        settings.RowStyles.Add(rowStyle);
-
-        using var control = new TableLayoutPanel();
-        using var controlWithName = new Control { Name = "name" };
-        using var controlWithDefaultName = new Control();
-        using var controlWithoutName = new ControlWithNullName();
-        control.Controls.Add(controlWithName);
-        control.Controls.Add(controlWithDefaultName);
-        control.Controls.Add(controlWithoutName);
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("LayoutSettings", e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        control.Layout += layoutHandler;
-
-        try
-        {
-            control.LayoutSettings = settings;
-            Assert.NotSame(settings, control.LayoutSettings);
-            Assert.Equal(columnStyle, Assert.Single(control.LayoutSettings.ColumnStyles));
-            Assert.Equal(rowStyle, Assert.Single(control.LayoutSettings.RowStyles));
-            Assert.Equal(1, control.LayoutSettings.GetColumnSpan(controlWithName));
-            Assert.Equal(2, control.LayoutSettings.GetRowSpan(controlWithName));
-            Assert.Equal(3, control.LayoutSettings.GetColumn(controlWithName));
-            Assert.Equal(4, control.LayoutSettings.GetRow(controlWithName));
-            Assert.Equal(1, layoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.LayoutSettings = settings;
-            Assert.NotSame(settings, control.LayoutSettings);
-            Assert.Empty(control.LayoutSettings.ColumnStyles);
-            Assert.Empty(control.LayoutSettings.RowStyles);
-            Assert.Equal(2, layoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetStub_ResetsOriginalSettings()
-    {
-        var converter = new TableLayoutSettingsTypeConverter();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(converter.ConvertFrom(@"<?xml version=""1.0"" encoding=""utf-16""?><Root />"));
-        settings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 1));
-        settings.RowStyles.Add(new RowStyle(SizeType.Percent, 1));
-
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("LayoutSettings", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutSettings = settings;
-        Assert.NotSame(settings, control.LayoutSettings);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetNull_ThrowsNNotSupportedException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<NotSupportedException>(() => control.LayoutSettings = null);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_LayoutSettings_SetNonStub_ThrowsNNotSupportedException()
-    {
-        var otherControl = new TableLayoutPanel();
-
-        using var control = new TableLayoutPanel();
-        Assert.Throws<NotSupportedException>(() => control.LayoutSettings = otherControl.LayoutSettings);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    public void TableLayoutPanel_RowCount_Set_GetReturnsExpected(int value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Rows", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RowCount = value;
-        Assert.Equal(value, control.RowCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RowCount = value;
-        Assert.Equal(value, control.RowCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_RowCount_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.RowCount = -1);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTableLayoutPanel();
-        TableLayoutControlCollection controls = Assert.IsType<TableLayoutControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.False(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetCellPosition_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), control.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetCellPosition_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetCellPosition(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetCellPosition_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetCellPosition(child, new TableLayoutPanelCellPosition { Column = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => control.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetCellPosition_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetCellPosition(child, new TableLayoutPanelCellPosition { Row = -2 });
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => control.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetColumn_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        Assert.Equal(-1, control.GetColumn(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetColumn_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetColumn(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetColumnSpan_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        Assert.Equal(1, control.GetColumnSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetColumnSpan_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetColumnSpan(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetColumnWidths_NoColumns_ReturnsExpected()
-    {
-        var panel = new TableLayoutPanel();
-        Assert.Empty(panel.GetColumnWidths());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetColumnWidths_InvokeNoChildren_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new Button();
-        var panel = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle
-        };
-        Assert.Equal(new int[] { 0, 0, 200 }, panel.GetColumnWidths());
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 10, 11)]
-    [InlineData(2, 2, 11, 12)]
-    [InlineData(4, 4, 10, 11)]
-    public void TableLayoutPanel_GetControlFromPosition_ControlExistsAddedToContainer_ReturnsExpected(int columnSpan, int rowSpan, int column, int row)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(child);
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-        control.SetColumn(child, 10);
-        control.SetRow(child, 11);
-
-        Assert.Equal(child, control.GetControlFromPosition(column, row));
-
-        // Call again to test caching.
-        Assert.Equal(child, control.GetControlFromPosition(column, row));
-
-        // Invalidate the column cache.
-        control.SetColumn(child, 20);
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Revalidate the column cache.
-        control.SetColumn(child, 10);
-        Assert.Same(child, control.GetControlFromPosition(column, row));
-
-        // Invalidate the row cache.
-        control.SetRow(child, 20);
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Revalidate the row cache.
-        control.SetRow(child, 11);
-        Assert.Same(child, control.GetControlFromPosition(column, row));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 9, 11)]
-    [InlineData(1, 1, 10, 10)]
-    [InlineData(1, 1, 11, 11)]
-    [InlineData(1, 1, 10, 12)]
-    [InlineData(2, 2, 8, 9)]
-    [InlineData(2, 2, 9, 10)]
-    [InlineData(4, 4, 9, 10)]
-    public void TableLayoutPanel_GetControlFromPosition_OutOfRange_ReturnsNull(int columnSpan, int rowSpan, int column, int row)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(child);
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-        control.SetColumn(child, 10);
-        control.SetRow(child, 11);
-
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Call again to test caching.
-        Assert.Null(control.GetControlFromPosition(column, row));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 10, 11)]
-    [InlineData(2, 2, 11, 12)]
-    [InlineData(4, 4, 10, 11)]
-    public void TableLayoutPanel_GetControlFromPosition_ControlExistsNotVisible_ReturnsNull(int columnSpan, int rowSpan, int column, int row)
-    {
-        using var child = new Control
-        {
-            Visible = false
-        };
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(child);
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-        control.SetColumn(child, 10);
-        control.SetRow(child, 11);
-
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Call again to test caching.
-        Assert.Null(control.GetControlFromPosition(column, row));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 10, 11)]
-    [InlineData(2, 2, 11, 12)]
-    [InlineData(4, 4, 10, 11)]
-    public void TableLayoutPanel_GetControlFromPosition_ControlExistsButNotAddedToContainer_ReturnsNull(int columnSpan, int rowSpan, int column, int row)
-    {
-        using var child = new Control
-        {
-            Visible = false
-        };
-        using var control = new TableLayoutPanel();
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-        control.SetColumn(child, 10);
-        control.SetRow(child, 11);
-
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Call again to test caching.
-        Assert.Null(control.GetControlFromPosition(column, row));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1, 10, 11)]
-    [InlineData(2, 2, 11, 12)]
-    [InlineData(4, 4, 10, 11)]
-    public void TableLayoutPanel_GetControlFromPosition_ControlExistsButNotAddedToContainerWithChildren_ReturnsNull(int columnSpan, int rowSpan, int column, int row)
-    {
-        using var otherChild = new Control();
-        using var child = new Control
-        {
-            Visible = false
-        };
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(otherChild);
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-        control.SetColumn(child, 10);
-        control.SetRow(child, 11);
-
-        Assert.Null(control.GetControlFromPosition(column, row));
-
-        // Call again to test caching.
-        Assert.Null(control.GetControlFromPosition(column, row));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetControlFromPosition_NoSuchControl_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Null(control.GetControlFromPosition(0, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutPanel_GetControlFromPosition_NegativeColumn_ThrowsArgumentOutOfRangeException(int column)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => control.GetControlFromPosition(column, 0));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    public void TableLayoutPanel_GetControlFromPosition_NegativeRow_ThrowsArgumentOutOfRangeException(int row)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => control.GetControlFromPosition(0, row));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1)]
-    [InlineData(2, 3)]
-    public void TableLayoutPanel_GetPositionFromControl_ControlExists_ReturnsExpected(int columnSpan, int rowSpan)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(child);
-        control.SetColumn(child, 1);
-        control.SetRow(child, 2);
-        control.SetColumnSpan(child, columnSpan);
-        control.SetRowSpan(child, rowSpan);
-
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 2), control.GetPositionFromControl(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetPositionFromControl_NotVisibleSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.Controls.Add(child);
-        control.SetColumn(child, 1);
-        control.SetRow(child, 2);
-
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 2), control.GetPositionFromControl(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetPositionFromControl_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetColumn(child, 1);
-        control.SetRow(child, 2);
-
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), control.GetPositionFromControl(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetPositionFromControl_NullControl_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Equal(new TableLayoutPanelCellPosition(-1, -1), control.GetPositionFromControl(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetRow_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        Assert.Equal(-1, control.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetRow_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetRow(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetRowHeights_NoRows_ReturnsExpected()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Empty(control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_InvokeNoChildren_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle
-        };
-        Assert.Equal(new int[] { 0, 100 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomAutoSizeStyles_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.AutoSize, 20));
-        Assert.Equal(new int[] { 0, 80 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.AutoSize, 30));
-        Assert.Equal(new int[] { 0, 80 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.AutoSize, 6));
-        Assert.Equal(new int[] { 0, 80 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomAbsoluteStyles_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 10));
-        Assert.Equal(new int[] { 10, 90 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 5));
-        Assert.Equal(new int[] { 10, 90 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 6));
-        Assert.Equal(new int[] { 10, 90 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomPercentStyles_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Percent, 20));
-        Assert.Equal(new int[] { 80, 0 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Percent, 30));
-        Assert.Equal(new int[] { 32, 48 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Percent, 6));
-        Assert.Equal(new int[] { 32, 48 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomStylesPercentOverflow_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Percent, 75));
-        Assert.Equal(new int[] { 80, 0 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 100));
-        Assert.Equal(new int[] { -20, 100 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomStylesPercentAutoSize_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Percent, 75));
-        Assert.Equal(new int[] { 80, 0 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.AutoSize, 100));
-        Assert.Equal(new int[] { 80, 0 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomStylesAbsoluteAutoSize_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 50));
-        Assert.Equal(new int[] { 50, 30 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.AutoSize, 100));
-        Assert.Equal(new int[] { 50, 30 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomStylesAbsoluteOverflow_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(70, 80)
-        };
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 100));
-        Assert.Equal(new int[] { 100, 0 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 100));
-        Assert.Equal(new int[] { 100, 100 }, control.GetRowHeights());
-    }
-
-    [WinFormsTheory]
-    [InlineData(TableLayoutPanelGrowStyle.FixedSize)]
-    [InlineData(TableLayoutPanelGrowStyle.AddRows)]
-    [InlineData(TableLayoutPanelGrowStyle.AddColumns)]
-    public void TableLayoutPanel_GetRowHeights_CustomInvalidStyles_ReturnsExpected(TableLayoutPanelGrowStyle growStyle)
-    {
-        using var control = new TableLayoutPanel
-        {
-            ColumnCount = 3,
-            RowCount = 2,
-            GrowStyle = growStyle,
-            ClientSize = new Size(50, 50)
-        };
-        control.RowStyles.Add(new RowStyle((SizeType)(SizeType.AutoSize - 1), 22));
-        Assert.Equal(new int[] { 0, 50 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle((SizeType)(SizeType.AutoSize - 1), 22));
-        Assert.Equal(new int[] { 0, 50 }, control.GetRowHeights());
-
-        control.RowStyles.Add(new RowStyle((SizeType)(SizeType.AutoSize - 1), 6));
-        Assert.Equal(new int[] { 0, 50 }, control.GetRowHeights());
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetRowSpan_NoSuchControl_ReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        Assert.Equal(1, control.GetRowSpan(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetRowSpan_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.GetRowSpan(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubTableLayoutPanel.ScrollStateAutoScrolling, false)]
-    [InlineData(SubTableLayoutPanel.ScrollStateFullDrag, false)]
-    [InlineData(SubTableLayoutPanel.ScrollStateHScrollVisible, false)]
-    [InlineData(SubTableLayoutPanel.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubTableLayoutPanel.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void TableLayoutPanel_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TableLayoutPanel_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> OnCellPaint_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new TableLayoutCellPaintEventArgs(graphics, Rectangle.Empty, Rectangle.Empty, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnCellPaint_TestData))]
-    public void TableLayoutPanel_OnCellPaint_Invoke_CallsCellPaint(TableLayoutCellPaintEventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        int callCount = 0;
-        TableLayoutCellPaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CellPaint += handler;
-        control.OnCellPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.CellPaint -= handler;
-        control.OnCellPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TableLayoutPanel_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TableLayoutPanel_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TableLayoutPanel_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        yield return new object[] { new LayoutEventArgs(null, null) };
-        yield return new object[] { new LayoutEventArgs(new Control(), null) };
-        yield return new object[] { new LayoutEventArgs(new Control(), string.Empty) };
-        yield return new object[] { new LayoutEventArgs(new Control(), "ChildIndex") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Visible") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Items") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Rows") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "Columns") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "RowStyles") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "ColumnStyles") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "TableIndex") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "GrowStyle") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "CellBorderStyle") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "LayoutSettings") };
-        yield return new object[] { new LayoutEventArgs(new Control(), "NoSuchProperty") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void TableLayoutPanel_OnLayout_Invoke_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void TableLayoutPanel_OnLayout_InvokeWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_OnLayout_InvokeNullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Throws<NullReferenceException>(() => control.OnLayout(null));
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-        {
-            foreach (TableLayoutPanelCellBorderStyle cellBorderStyle in Enum.GetValues(typeof(TableLayoutPanelCellBorderStyle)))
-            {
-                foreach (bool hScroll in new bool[] { true, false })
-                {
-                    foreach (bool vScroll in new bool[] { true, false })
-                    {
-                        yield return new object[] { rightToLeft, cellBorderStyle, hScroll, vScroll };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void TableLayoutPanel_OnPaintBackground_InvokeEmpty_Success(RightToLeft rightToLeft, TableLayoutPanelCellBorderStyle cellBorderStyle, bool hScroll, bool vScroll)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubTableLayoutPanel
-        {
-            RightToLeft = rightToLeft,
-            CellBorderStyle = cellBorderStyle,
-            HScroll = hScroll,
-            VScroll = vScroll,
-        };
-        int cellPaintCallCount = 0;
-        control.CellPaint += (sender, e) => cellPaintCallCount++;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, cellPaintCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, cellPaintCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void TableLayoutPanel_OnPaintBackground_InvokeNotEmpty_Success(RightToLeft rightToLeft, TableLayoutPanelCellBorderStyle cellBorderStyle, bool hScroll, bool vScroll)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(15, 2, 5, 20));
-
-        using var control = new SubTableLayoutPanel
-        {
-            RightToLeft = rightToLeft,
-            CellBorderStyle = cellBorderStyle,
-            HScroll = hScroll,
-            VScroll = vScroll,
-        };
-        int cellPaintCallCount = 0;
-        control.CellPaint += (sender, e) =>
-        {
-            Assert.Same(eventArgs.Graphics, e.Graphics);
-            Assert.Equal(eventArgs.ClipRectangle, e.ClipRectangle);
-            Assert.Equal(1, e.Column);
-            if ((cellPaintCallCount % 2) == 0)
-            {
-                Assert.Equal(0, e.Row);
-            }
-            else
-            {
-                Assert.Equal(1, e.Row);
-            }
-
-            cellPaintCallCount++;
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        using var child1 = new Control();
-        control.Controls.Add(child1);
-        control.SetRow(child1, 0);
-        control.SetColumn(child1, 1);
-
-        using var child2 = new Control();
-        control.Controls.Add(child2);
-        control.SetRow(child2, 1);
-        control.SetColumn(child2, 1);
-
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 10));
-        control.RowStyles.Add(new RowStyle(SizeType.Absolute, 10));
-        control.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 10));
-        control.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 10));
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, cellPaintCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(4, cellPaintCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_OnPaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var control = new SubTableLayoutPanel();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    public static IEnumerable<object[]> SetCellPosition_TestData()
-    {
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, -1) };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, -1) };
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, 0) };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, 0) };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_TestData))]
-    public void TableLayoutPanel_SetCellPosition_Invoke_GetReturnsExpected(TableLayoutPanelCellPosition value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetCellPosition(child, value);
-        Assert.Equal(value, control.GetCellPosition(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetCellPosition(child, value);
-        Assert.Equal(value, control.GetCellPosition(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetCellPosition_ControlWithParent_TestData()
-    {
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, -1), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, -1), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(-1, 0), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(0, 0), 1 };
-        yield return new object[] { new TableLayoutPanelCellPosition(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetCellPosition_ControlWithParent_TestData))]
-    public void TableLayoutPanel_SetCellPosition_InvokeControlWithParent_GetReturnsExpected(TableLayoutPanelCellPosition value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetCellPosition(child, value);
-            Assert.Equal(value, control.GetCellPosition(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetCellPosition(child, value);
-            Assert.Equal(value, control.GetCellPosition(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetCellPosition_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetCellPosition(child, new TableLayoutPanelCellPosition(1, 1));
-        Assert.Equal(new TableLayoutPanelCellPosition(1, 1), control.GetCellPosition(child));
-
-        control.SetCellPosition(child, new TableLayoutPanelCellPosition(2, 2));
-        Assert.Equal(new TableLayoutPanelCellPosition(2, 2), control.GetCellPosition(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetCellPosition_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetCellPosition(null, new TableLayoutPanelCellPosition()));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumn_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetColumn(child, value);
-        Assert.Equal(value, control.GetColumn(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetColumn(child, value);
-        Assert.Equal(value, control.GetColumn(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetColumn_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetColumn(child, value);
-            Assert.Equal(value, control.GetColumn(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetColumn(child, value);
-            Assert.Equal(value, control.GetColumn(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetColumn_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetColumn(child, 1);
-        Assert.Equal(1, control.GetColumn(child));
-
-        control.SetColumn(child, 2);
-        Assert.Equal(2, control.GetColumn(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetColumn_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetColumn(null, 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetColumn_InvalidColumn_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("column", () => control.SetColumn(new Control(), -2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetColumnSpan_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetColumnSpan(child, value);
-        Assert.Equal(value, control.GetColumnSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetColumnSpan(child, value);
-        Assert.Equal(value, control.GetColumnSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetColumnSpan_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("ColumnSpan", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetColumnSpan(child, value);
-            Assert.Equal(value, control.GetColumnSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetColumnSpan(child, value);
-            Assert.Equal(value, control.GetColumnSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetColumnSpan_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-
-        control.SetColumnSpan(child, 1);
-        Assert.Equal(1, control.GetColumnSpan(child));
-
-        control.SetColumnSpan(child, 2);
-        Assert.Equal(2, control.GetColumnSpan(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutPanel_SetColumnSpan_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetColumnSpan(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutPanel_SetColumnSpan_InvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SetColumnSpan(new Control(), value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRow_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetRow(child, value);
-        Assert.Equal(value, control.GetRow(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetRow(child, value);
-        Assert.Equal(value, control.GetRow(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetRow_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("TableIndex", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetRow(child, value);
-            Assert.Equal(value, control.GetRow(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetRow(child, value);
-            Assert.Equal(value, control.GetRow(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetRow_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetRow(child, 1);
-        Assert.Equal(1, control.GetRow(child));
-
-        control.SetRow(child, 2);
-        Assert.Equal(2, control.GetRow(child));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetRow_NullControl_ThrowsArgumentNullException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetRow(null, 1));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetRow_InvalidRow_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("row", () => control.SetRow(new Control(), -2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(int.MaxValue)]
-    public void TableLayoutPanel_SetRowSpan_Invoke_GetReturnsExpected(int value)
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-
-        control.SetRowSpan(child, value);
-        Assert.Equal(value, control.GetRowSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-
-        // Set same.
-        control.SetRowSpan(child, value);
-        Assert.Equal(value, control.GetRowSpan(child));
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, childLayoutCallCount);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(child.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TableLayoutPanel_SetRowSpan_InvokeControlWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var child = new Control
-        {
-            Parent = parent
-        };
-        using var control = new TableLayoutPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int childLayoutCallCount = 0;
-        child.Layout += (sender, e) => childLayoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs eventArgs)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(child, eventArgs.AffectedControl);
-            Assert.Equal("RowSpan", eventArgs.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.SetRowSpan(child, value);
-            Assert.Equal(value, control.GetRowSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.SetRowSpan(child, value);
-            Assert.Equal(value, control.GetRowSpan(child));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, childLayoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(child.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_SetRowSpan_InvokeMultipleTimes_GetReturnsExpected()
-    {
-        using var child = new Control();
-        using var control = new TableLayoutPanel();
-        control.SetRowSpan(child, 1);
-        Assert.Equal(1, control.GetRowSpan(child));
-
-        control.SetRowSpan(child, 2);
-        Assert.Equal(2, control.GetRowSpan(child));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TableLayoutPanel_SetRowSpan_NullControl_ThrowsArgumentNullException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentNullException>("control", () => control.SetRowSpan(null, value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutPanel_SetRowSpan_InvalidValue_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TableLayoutPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SetRowSpan(new Control(), value));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutPanel_IExtenderProviderCanExtend_InvokeParent_ReturnsTrue()
-    {
-        using var extendee = new Control();
-        using var control = new TableLayoutPanel();
-        extendee.Parent = control;
-
-        IExtenderProvider extenderProvider = control;
-        Assert.True(extenderProvider.CanExtend(extendee));
-    }
-
-    public static IEnumerable<object[]> IExtenderProvider_CanExtend_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IExtenderProvider_CanExtend_TestData))]
-    public void TableLayoutPanel_IExtenderProviderCanExtend_NotControl_ReturnsFalse(object obj)
-    {
-        using var control = new TableLayoutPanel();
-        IExtenderProvider extenderProvider = control;
-        Assert.False(extenderProvider.CanExtend(obj));
-    }
-
-    [TypeDescriptionProvider(typeof(CustomTypeDescriptionProvider))]
-    private class ControlWithNullName : Control
-    {
-    }
-
-    private class CustomTypeDescriptionProvider : TypeDescriptionProvider
-    {
-        public CustomTypeDescriptionProvider()
-        {
-        }
-
-        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
-        {
-            var mockDescriptor = new Mock<ICustomTypeDescriptor>(MockBehavior.Strict);
-            mockDescriptor
-                .Setup(c => c.GetProperties())
-                .Returns(new PropertyDescriptorCollection(Array.Empty<PropertyDescriptor>()));
-            return mockDescriptor.Object;
-        }
-    }
-
-    private class SubTableLayoutPanel : TableLayoutPanel
-    {
-        public new const int ScrollStateAutoScrolling = TableLayoutPanel.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = TableLayoutPanel.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = TableLayoutPanel.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = TableLayoutPanel.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = TableLayoutPanel.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnCellPaint(TableLayoutCellPaintEventArgs e) => base.OnCellPaint(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnLayout(LayoutEventArgs levent) => base.OnLayout(levent);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void ScaleControl(SizeF factor, BoundsSpecified specified) => base.ScaleControl(factor, specified);
-
-        public new void ScaleCore(float dx, float dy) => base.ScaleCore(dx, dy);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutRowStyleCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutRowStyleCollectionTests.cs
deleted file mode 100644
index bb4cc21a9b6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutRowStyleCollectionTests.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutRowStyleCollectionTests
-{
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Add_RowStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Add_ColumnStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-
-        var style = new ColumnStyle();
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Insert_RowStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-
-        var style = new RowStyle();
-        collection.Insert(0, style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Item_SetRowStyle_GetReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-        collection.Add(new RowStyle());
-
-        var style = new RowStyle();
-        collection[0] = style;
-        Assert.Single(collection);
-        Assert.Equal(style, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Item_GetNotRowStyle_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-        collection.Add(new ColumnStyle());
-        Assert.Throws<InvalidCastException>(() => collection[0]);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Remove_RowStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        collection.Remove(style);
-        Assert.Empty(collection);
-
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_Contains_RowStyle_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.True(collection.Contains(style));
-        Assert.False(collection.Contains(new RowStyle()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutRowStyleCollection_IndexOf_Invoke_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutRowStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Equal(0, collection.IndexOf(style));
-        Assert.Equal(-1, collection.IndexOf(new RowStyle()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleCollectionTests.cs
deleted file mode 100644
index 1eb3fe2390b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleCollectionTests.cs
+++ /dev/null
@@ -1,294 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutStyleCollectionTests
-{
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Properties_GetDefault_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        Assert.Equal(0, collection.Count);
-        Assert.False(collection.IsFixedSize);
-        Assert.False(collection.IsReadOnly);
-        Assert.False(collection.IsSynchronized);
-        Assert.NotNull(collection.SyncRoot);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Add_TableLayoutStyle_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Add_Object_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Add_Null_ThrowsArgumentNullException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        Assert.Throws<ArgumentNullException>("style", () => collection.Add(null));
-        Assert.Throws<ArgumentNullException>("style", () => ((IList)collection).Add(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Add_ObjectNotTableLayoutStyle_ThrowsInvalidCastException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        Assert.Throws<InvalidCastException>(() => collection.Add(new object()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Add_StyleAlreadyAdded_ThrowsArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Throws<ArgumentException>("style", () => collection.Add(style));
-        Assert.Throws<ArgumentException>("style", () => ((IList)collection).Add(style));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Insert_Object_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-
-        var style = new RowStyle();
-        collection.Insert(0, style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutStyleCollection_Insert_Null_ThrowsArgumentNullException(int index)
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        Assert.Throws<ArgumentNullException>("style", () => ((IList)collection).Insert(index, null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Insert_ObjectNotTableLayoutStyle_ArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        Assert.Throws<ArgumentException>(() => collection.Insert(0, new object()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Insert_StyleAlreadyAdded_ThrowsArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Throws<ArgumentException>("style", () => ((IList)collection).Insert(0, style));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Item_SetTableLayoutStyle_GetReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        collection.Add(new RowStyle());
-
-        var style = new RowStyle();
-        collection[0] = style;
-        Assert.Single(collection);
-        Assert.Equal(style, collection[0]);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Item_SetObject_GetReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        collection.Add(new RowStyle());
-
-        var style = new RowStyle();
-        collection[0] = style;
-        Assert.Single(collection);
-        Assert.Equal(style, collection[0]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void TableLayoutStyleCollection_Item_SetNull_ThrowsArgumentNullException(int index)
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        collection.Add(new RowStyle());
-        Assert.Throws<ArgumentNullException>("value", () => collection[index] = null);
-        Assert.Throws<ArgumentNullException>("value", () => ((IList)collection)[index] = null);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Item_ObjectNotTableLayoutStyle_ThrowsArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        collection.Add(new RowStyle());
-        Assert.Throws<ArgumentException>(() => collection[0] = new object());
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Item_StyleAlreadyAdded_ThrowsArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Throws<ArgumentException>("style", () => collection[0] = style);
-        Assert.Throws<ArgumentException>("style", () => ((IList)collection)[0] = style);
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Remove_Object_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        collection.Remove(style);
-        Assert.Empty(collection);
-
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Remove_Null_Nop()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        collection.Remove(null);
-        Assert.Same(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Remove_ObjectNotTableLayoutStyle_ThrowsArgumentException()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        Assert.Throws<ArgumentException>(() => collection.Remove(new object()));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_RemoveAt_Invoke_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        collection.RemoveAt(0);
-        Assert.Empty(collection);
-
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Clear_Invoke_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        TableLayoutStyleCollection collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        collection.Clear();
-        Assert.Empty(collection);
-
-        collection.Clear();
-        Assert.Empty(collection);
-
-        collection.Add(style);
-        Assert.Equal(style, Assert.Single(collection));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_Contains_Object_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.True(collection.Contains(style));
-        Assert.False(collection.Contains(new ColumnStyle()));
-        Assert.False(collection.Contains(new RowStyle()));
-        Assert.False(collection.Contains(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_IndexOf_Object_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-        Assert.Equal(0, collection.IndexOf(style));
-        Assert.Equal(-1, collection.IndexOf(new ColumnStyle()));
-        Assert.Equal(-1, collection.IndexOf(new RowStyle()));
-        Assert.Equal(-1, collection.IndexOf(null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyleCollection_CopyTo_Invoke_Success()
-    {
-        using var toolStrip = new ToolStrip { LayoutStyle = ToolStripLayoutStyle.Table };
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.LayoutSettings);
-        IList collection = settings.RowStyles;
-        var style = new RowStyle();
-        collection.Add(style);
-
-        var array = new object[] { 1, 2, 3 };
-        collection.CopyTo(array, 1);
-        Assert.Equal(new object[] { 1, style, 3 }, array);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleTests.cs
deleted file mode 100644
index d3beae881ea..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TableLayoutStyleTests.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design.Serialization;
-using System.Reflection;
-
-namespace System.Windows.Forms.Tests;
-
-public class TableLayoutStyleTests
-{
-    [WinFormsFact]
-    public void TableLayoutStyle_Ctor_Default()
-    {
-        var style = new SubTableLayoutStyle();
-        Assert.Equal(SizeType.AutoSize, style.SizeType);
-    }
-
-    [WinFormsTheory]
-    [EnumData<SizeType>]
-    [InvalidEnumData<SizeType>]
-    public void TableLayoutStyle_SizeType_Set_GetReturnsExpected(SizeType value)
-    {
-        var style = new SubTableLayoutStyle
-        {
-            SizeType = value
-        };
-        Assert.Equal(value, style.SizeType);
-
-        // Set same.
-        style.SizeType = value;
-        Assert.Equal(value, style.SizeType);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SizeType.Absolute, 1)]
-    [InlineData(SizeType.AutoSize, 0)]
-    [InlineData(SizeType.Percent, 1)]
-    [InlineData((SizeType.AutoSize - 1), 1)]
-    [InlineData((SizeType.Percent + 1), 1)]
-    public void TableLayoutStyle_SizeType_SetWithOwner_GetReturnsExpected(SizeType value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new ColumnStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.SizeType = value;
-        Assert.Equal(value, style.SizeType);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        style.SizeType = value;
-        Assert.Equal(value, style.SizeType);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(SizeType.Absolute, 1)]
-    [InlineData(SizeType.AutoSize, 0)]
-    [InlineData(SizeType.Percent, 1)]
-    [InlineData((SizeType.AutoSize - 1), 1)]
-    [InlineData((SizeType.Percent + 1), 1)]
-    public void TableLayoutStyle_SizeType_SetWithOwnerWithHandle_GetReturnsExpected(SizeType value, int expectedLayoutCallCount)
-    {
-        using var control = new TableLayoutPanel();
-        var style = new ColumnStyle();
-        control.LayoutSettings.RowStyles.Add(style);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Style", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        style.SizeType = value;
-        Assert.Equal(value, style.SizeType);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        style.SizeType = value;
-        Assert.Equal(value, style.SizeType);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(string), true)]
-    [InlineData(typeof(InstanceDescriptor), true)]
-    [InlineData(typeof(TableLayoutStyle), false)]
-    [InlineData(typeof(int), false)]
-    [InlineData(null, false)]
-    public void TableLayoutStyle_ConverterCanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        Assert.Equal(expected, converter.CanConvertTo(destinationType));
-    }
-
-    public static IEnumerable<object[]> ConvertTo_TestData()
-    {
-        yield return new object[] { new RowStyle(SizeType.AutoSize, 1), typeof(RowStyle).GetConstructor(Array.Empty<Type>()), Array.Empty<object>() };
-        yield return new object[] { new RowStyle(SizeType.Absolute, 1), typeof(RowStyle).GetConstructor(new Type[] { typeof(SizeType), typeof(int) }), new object[] { SizeType.Absolute, 1f } };
-        yield return new object[] { new RowStyle(SizeType.Percent, 1), typeof(RowStyle).GetConstructor(new Type[] { typeof(SizeType), typeof(int) }), new object[] { SizeType.Percent, 1f } };
-        yield return new object[] { new ColumnStyle(SizeType.AutoSize, 1), typeof(ColumnStyle).GetConstructor(Array.Empty<Type>()), Array.Empty<object>() };
-        yield return new object[] { new ColumnStyle(SizeType.Absolute, 1), typeof(ColumnStyle).GetConstructor(new Type[] { typeof(SizeType), typeof(int) }), new object[] { SizeType.Absolute, 1f } };
-        yield return new object[] { new ColumnStyle(SizeType.Percent, 1), typeof(ColumnStyle).GetConstructor(new Type[] { typeof(SizeType), typeof(int) }), new object[] { SizeType.Percent, 1f } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ConvertTo_TestData))]
-    public void TableLayoutStyle_ConverterConvertTo_InstanceDescriptorRowAbsolutePercent_ReturnsExpected(object value, ConstructorInfo expectedConstructor, object[] expectedArguments)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        InstanceDescriptor descriptor = Assert.IsType<InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
-        Assert.Equal(expectedConstructor, descriptor.MemberInfo);
-        Assert.Equal(expectedArguments, descriptor.Arguments);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<SizeType>]
-    public void TableLayoutStyle_ConverterConvertTo_InvalidSizeType_ThrowsNotSupportedException(SizeType sizeType)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new SubTableLayoutStyle { SizeType = sizeType }, typeof(InstanceDescriptor)));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyle_ConverterConvertTo_NullDestinationType_ThrowsArgumentNullException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
-    }
-
-    [WinFormsFact]
-    public void TableLayoutStyle_ConverterConvertTo_ValueNotTableLayoutStyle_ThrowsNotSupportedException()
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(typeof(TableLayoutPanelCellPosition))]
-    [InlineData(typeof(int))]
-    public void TableLayoutStyle_ConverterConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
-    {
-        TypeConverter converter = TypeDescriptor.GetConverter(typeof(TableLayoutStyle));
-        Assert.Throws<NotSupportedException>(() => converter.ConvertTo(new RowStyle(), destinationType));
-    }
-
-    private class SubTableLayoutStyle : TableLayoutStyle
-    {
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TaskDialogTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TaskDialogTests.cs
deleted file mode 100644
index e20e6f56ab8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TaskDialogTests.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.DotNet.RemoteExecutor;
-
-namespace System.Windows.Forms.Tests;
-
-public class TaskDialogTests
-{
-    [WinFormsFact]
-    public void TaskDialog_ShowDialog_SetProperty_SameThread_Success()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-            Control.CheckForIllegalCrossThreadCalls = true;
-
-            TaskDialogPage page = new TaskDialogPage();
-            page.Created += (_, __) =>
-            {
-                // Set the property in the same thread.
-                page.Text = "X";
-                page.BoundDialog.Close();
-            };
-
-            TaskDialog.ShowDialog(page);
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-
-    [WinFormsFact]
-    public void TaskDialog_ShowDialog_SetProperty_DifferentThread_ThrowsInvalidOperationException()
-    {
-        // Run this from another thread as we call Application.EnableVisualStyles.
-        using RemoteInvokeHandle invokerHandle = RemoteExecutor.Invoke(() =>
-        {
-            Application.EnableVisualStyles();
-            Control.CheckForIllegalCrossThreadCalls = true;
-
-            TaskDialogPage page = new TaskDialogPage();
-            page.Created += (_, __) =>
-            {
-                // Set the property in a different thread.
-                var separateTask = Task.Run(() => page.Text = "X");
-                Assert.Throws<InvalidOperationException>(separateTask.GetAwaiter().GetResult);
-
-                page.BoundDialog.Close();
-            };
-
-            TaskDialog.ShowDialog(page);
-        });
-
-        // verify the remote process succeeded
-        Assert.Equal(RemoteExecutor.SuccessExitCode, invokerHandle.ExitCode);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TestAccessors.KeyboardToolTipStateMachineTestAccessor.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TestAccessors.KeyboardToolTipStateMachineTestAccessor.cs
deleted file mode 100644
index 913d0bf4863..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TestAccessors.KeyboardToolTipStateMachineTestAccessor.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System;
-
-public static partial class TestAccessors
-{
-    internal class KeyboardToolTipStateMachineTestAccessor : TestAccessor<KeyboardToolTipStateMachine>
-    {
-        public KeyboardToolTipStateMachineTestAccessor(KeyboardToolTipStateMachine instance)
-            : base(instance) { }
-
-        internal bool IsToolTracked(IKeyboardToolTip sender) => (bool)Dynamic.IsToolTracked(sender);
-    }
-
-    internal static KeyboardToolTipStateMachineTestAccessor TestAccessor(this KeyboardToolTipStateMachine instance)
-        => new(instance);
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxAccessibleObjectTests.cs
deleted file mode 100644
index 6d22f25e984..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,178 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TextBoxAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData((int)Interop.UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)Interop.UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    public void TextBoxAccessibleObject_TextPatternAvailable(int propertyId)
-    {
-        using TextBox textBox = new TextBox();
-        AccessibleObject textBoxAccessibleObject = textBox.AccessibilityObject;
-
-        // Interop.UiaCore.UIA accessible level (internal) is less than the test level (public) so it needs boxing and unboxing
-        Assert.True((bool)textBoxAccessibleObject.GetPropertyValue((Interop.UiaCore.UIA)propertyId));
-        Assert.False(textBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)Interop.UiaCore.UIA.LegacyIAccessiblePatternId)]
-    [InlineData((int)Interop.UiaCore.UIA.TextPatternId)]
-    [InlineData((int)Interop.UiaCore.UIA.TextPattern2Id)]
-    [InlineData((int)Interop.UiaCore.UIA.ValuePatternId)]
-    public void TextBoxAccessibleObject_PatternSupported(int patternId)
-    {
-        using TextBox textBox = new TextBox();
-        AccessibleObject textBoxAccessibleObject = textBox.AccessibilityObject;
-
-        // Interop.UiaCore.UIA accessible level (internal) is less than the test level (public) so it needs boxing and unboxing
-        Assert.True(textBoxAccessibleObject.IsPatternSupported((Interop.UiaCore.UIA)patternId));
-        Assert.False(textBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxAccessibilityObject_ControlType_IsEdit_IfAccessibleRoleIsDefault()
-    {
-        using TextBox textBox = new TextBox();
-        textBox.CreateControl();
-        // AccessibleRole is not set = Default
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(Interop.UiaCore.UIA.EditControlTypeId, actual);
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxAccessibilityObject_Role_IsText_ByDefault()
-    {
-        using TextBox textBox = new TextBox();
-        textBox.CreateControl();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = textBox.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Text, actual);
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TextBoxAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TextBox textBox = new TextBox();
-        textBox.AccessibleRole = role;
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.ControlTypePropertyId);
-        Interop.UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(textBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxAccessibleObject_GetPropertyValue_Value_AccessDenied_WithUseSystemPasswordChar()
-    {
-        using TextBox textBox = new TextBox();
-        textBox.UseSystemPasswordChar = true;
-        textBox.Text = "some text";
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.ValueValuePropertyId);
-
-        Assert.Equal(SR.AccessDenied, actual);
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TextBoxAccessibleObject_IsPassword_IsExpected_WithUseSystemPasswordChar(bool useSystemPasswordChar)
-    {
-        using TextBox textBox = new TextBox();
-        textBox.UseSystemPasswordChar = useSystemPasswordChar;
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.IsPasswordPropertyId);
-
-        Assert.Equal(useSystemPasswordChar, actual);
-        // Handle is recreated when setting UseSystemPasswordChar
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Placeholder text", "Placeholder text")]
-    public void TextBoxAccessibleObject_GetPropertyValue_HelpText_IsExpected(string placeholderText, string expectedHelpText)
-    {
-        using TextBox textBox = new() { PlaceholderText = placeholderText };
-
-        object helpText = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.HelpTextPropertyId);
-
-        Assert.Equal(expectedHelpText, helpText);
-    }
-
-    [WinFormsTheory]
-    [InlineData('\0')]
-    [InlineData('*')]
-    public void TextBoxAccessibleObject_IsPassword_IsExpected_WithPasswordChar(char passwordChar)
-    {
-        using TextBox textBox = new TextBox();
-        textBox.PasswordChar = passwordChar;
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.IsPasswordPropertyId);
-        bool expected = passwordChar != '\0';
-
-        Assert.Equal(expected, actual);
-        // Handle is recreated when getting PasswordChar
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxAccessibleObject_IsPassword_IsFalse_ForMultilineTextBox_WithUseSystemPasswordChar()
-    {
-        using TextBox textBox = new TextBox();
-        textBox.Multiline = true;
-        textBox.UseSystemPasswordChar = true;
-
-        bool actual = (bool)textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.IsPasswordPropertyId);
-
-        Assert.False(actual);
-        // Handle is recreated when setting UseSystemPasswordChar
-        Assert.True(textBox.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('\0')]
-    [InlineData('*')]
-    public void TextBoxAccessibleObject_IsPassword_IsExpected_ForMultilineTextBox_WithPasswordChar(char passwordChar)
-    {
-        using TextBox textBox = new TextBox();
-        textBox.PasswordChar = passwordChar;
-        textBox.Multiline = true;
-
-        object actual = textBox.AccessibilityObject.GetPropertyValue(Interop.UiaCore.UIA.IsPasswordPropertyId);
-        bool expected = passwordChar != '\0';
-
-        Assert.Equal(expected, actual);
-        // Handle is recreated when getting PasswordChar
-        Assert.True(textBox.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBase.TextBoxBaseUiaTextProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBase.TextBoxBaseUiaTextProviderTests.cs
deleted file mode 100644
index 7d9cfcc354f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBase.TextBoxBaseUiaTextProviderTests.cs
+++ /dev/null
@@ -1,924 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Automation;
-using static System.Windows.Forms.TextBoxBase;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TextBoxBase_TextBoxBaseUiaTextProviderTests
-{
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_ctor_DoesntCreateControlHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        Assert.False(textBoxBase.IsHandleCreated);
-
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_Ctor_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new TextBoxBaseUiaTextProvider(null));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_IsMultiline_IsCorrect()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        textBoxBase.Multiline = false;
-        Assert.False(provider.IsMultiline);
-
-        textBoxBase.Multiline = true;
-        Assert.True(provider.IsMultiline);
-
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TextBoxBaseUiaTextProvider_IsReadOnly_IsCorrect(bool readOnly)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        textBoxBase.ReadOnly = readOnly;
-        Assert.Equal(readOnly, provider.IsReadOnly);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_IsScrollable_IsCorrect()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.True(provider.IsScrollable);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_IsScrollable_False_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.False(provider.IsScrollable);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseTextProvider_GetWindowStyle_ReturnsNoneForNotInitializedControl()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.Equal(WINDOW_STYLE.WS_OVERLAPPED, provider.WindowStyle);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true)]
-    [InlineData(RightToLeft.No, false)]
-    public void TextBoxBaseUiaTextProvider_IsReadingRTL_ReturnsCorrectValue(RightToLeft rightToLeft, bool expectedResult)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        textBoxBase.RightToLeft = rightToLeft;
-
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.Equal(expectedResult, provider.IsReadingRTL);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes)]
-    [InlineData(RightToLeft.No)]
-    public void TextBoxBaseUiaTextProvider_IsReadingRTL_ReturnsFalse_WithoutHandle(RightToLeft rightToLeft)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.RightToLeft = rightToLeft;
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.False(provider.IsReadingRTL);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_DocumentRange_IsNotNull()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.NotNull(provider.DocumentRange);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_SupportedTextSelection_IsNotNull()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        UiaCore.SupportedTextSelection uiaTextRange = provider.SupportedTextSelection;
-        Assert.Equal(UiaCore.SupportedTextSelection.Single, uiaTextRange);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetCaretRange_IsNotNull()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        UiaCore.ITextRangeProvider uiaTextRange = provider.GetCaretRange(out _);
-        Assert.NotNull(uiaTextRange);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetCaretRange_IsNull_IfHandleIsNotCreated()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        UiaCore.ITextRangeProvider uiaTextRange = provider.GetCaretRange(out _);
-        Assert.Null(uiaTextRange);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(30, 0, 0)]
-    [InlineData(30, 19, 1)] // Only 1 lines are placed at a height equal to 19
-    [InlineData(30, 50, 3)] // Only 3 lines are placed at a height equal to 50
-    [InlineData(30, 100, 6)] // Only 6 lines are placed at a height equal to 100
-    public void TextBoxBaseUiaTextProvider_LinesPerPage_IsCorrect_with_handle(int width, int height, int lines)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase { Size = new Size(width, height) };
-        textBoxBase.CreateControl();
-        Assert.True(textBoxBase.IsHandleCreated);
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.Equal(1, provider.LinesPerPage);
-
-        textBoxBase.Multiline = true;
-        Assert.Equal(lines, provider.LinesPerPage);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_LinesPerPage_ReturnsMinusOne_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.Equal(-1, provider.LinesPerPage);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_FirstVisibleLine_Get_ReturnsCorrectValue()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.Multiline = true;
-        textBoxBase.Size = new Size(50, 100);
-        textBoxBase.CreateControl();
-        Assert.True(textBoxBase.IsHandleCreated);
-
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.Equal(0, provider.FirstVisibleLine);
-
-        provider.LineScroll(0, 2);
-        Assert.Equal(0, provider.FirstVisibleLine);
-
-        textBoxBase.Text = "Some long long test text for testing GetFirstVisibleLine method";
-        provider.LineScroll(0, 2);
-        Assert.Equal(2, provider.FirstVisibleLine);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_FirstVisibleLine_Get_ReturnsMinusOne_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        int line = provider.FirstVisibleLine;
-        Assert.Equal(-1, line);
-
-        textBoxBase.Multiline = true;
-        textBoxBase.Size = new Size(30, 100);
-
-        line = provider.FirstVisibleLine;
-        Assert.Equal(-1, line);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_LineCount_Get_ReturnsCorrectValue()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.Equal(1, provider.LinesCount);
-
-        textBoxBase.Multiline = true;
-        textBoxBase.Size = new Size(30, 50);
-        Assert.Equal(1, provider.LinesCount);
-
-        textBoxBase.Text += "1\r\n";
-        Assert.Equal(2, provider.LinesCount);
-
-        textBoxBase.Text += "2\r\n";
-        Assert.Equal(3, provider.LinesCount);
-
-        textBoxBase.Text += "3\r\n";
-        Assert.Equal(4, provider.LinesCount);
-
-        textBoxBase.Text += "4\r\n";
-        Assert.Equal(5, provider.LinesCount);
-
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_LineCount_Get_ReturnsMinusOne_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.Equal(-1, provider.LinesCount);
-
-        textBoxBase.Multiline = true;
-        textBoxBase.Size = new Size(30, 50);
-        Assert.Equal(-1, provider.LinesCount);
-
-        textBoxBase.Text += "1\r\n";
-        Assert.Equal(-1, provider.LinesCount);
-
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxBase_GetLineFromCharIndex_TestData()
-    {
-        yield return new object[] { new Size(50, 20), false, 0, 0 };
-        yield return new object[] { new Size(50, 20), false, 50, 0 };
-        yield return new object[] { new Size(100, 50), true, 50, 3 };
-        yield return new object[] { new Size(50, 50), true, 50, 8 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBase_GetLineFromCharIndex_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetLineFromCharIndex_ReturnsCorrectValue(Size size, bool multiline, int charIndex, int expectedLine)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Multiline = multiline };
-        textBoxBase.CreateControl();
-        textBoxBase.Text = "Some test text for testing GetLineFromCharIndex method";
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        int actualLine = provider.GetLineFromCharIndex(charIndex);
-        Assert.Equal(expectedLine, actualLine);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameter 'expectedLine'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBase_GetLineFromCharIndex_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetLineFromCharIndex_ReturnsMinusOne_WithoutHandle(Size size, bool multiline, int charIndex, int expectedLine)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Size = size,
-            Multiline = multiline,
-            Text = "Some test text for testing GetLineFromCharIndex method"
-        };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        int actualLine = provider.GetLineFromCharIndex(charIndex);
-
-        Assert.Equal(-1, actualLine);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetLineIndex_TestData()
-    {
-        yield return new object[] { new Size(50, 20), false, 0, 0 };
-        yield return new object[] { new Size(50, 20), false, 3, 0 };
-        yield return new object[] { new Size(50, 50), true, 3, 19 };
-        yield return new object[] { new Size(100, 50), true, 3, 40 };
-        yield return new object[] { new Size(50, 50), true, 100, -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetLineIndex_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetLineIndex_ReturnsCorrectValue(Size size, bool multiline, int lineIndex, int expectedIndex)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Size = size,
-            Multiline = multiline,
-            Text = "Some test text for testing GetLineIndex method"
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        int actualIndex = provider.GetLineIndex(lineIndex);
-
-        Assert.Equal(expectedIndex, actualIndex);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameter 'expectedIndex'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetLineIndex_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetLineIndex_ReturnsMinusOne_WithoutHandle(Size size, bool multiline, int lineIndex, int expectedIndex)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Size = size,
-            Multiline = multiline,
-            Text = "Some test text for testing GetLineIndex method"
-        };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        int actualIndex = provider.GetLineIndex(lineIndex);
-
-        Assert.Equal(-1, actualIndex);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetLogfont_ReturnsCorrectValue()
-    {
-        using (new NoAssertContext())
-        {
-            using TextBoxBase textBoxBase = new SubTextBoxBase();
-            textBoxBase.CreateControl();
-            TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-            LOGFONTW expected = LOGFONTW.FromFont(textBoxBase.Font);
-            LOGFONTW actual = provider.Logfont;
-            Assert.False(string.IsNullOrEmpty(actual.FaceName.ToString()));
-            Assert.Equal(expected, actual);
-            Assert.True(textBoxBase.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetLogfont_ReturnsEmpty_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        LOGFONTW expected = default;
-        LOGFONTW actual = provider.Logfont;
-        Assert.True(string.IsNullOrEmpty(actual.FaceName.ToString()));
-        Assert.Equal(expected, actual);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetPositionFromChar_TestData()
-    {
-        yield return new object[] { new Size(50, 20), "Some test text for testing", false, 0, new Point(1, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text for testing", false, 15, new Point(79, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text for testing", true, 15, new Point(27, 30) };
-        yield return new object[] { new Size(100, 60), "This is a\r\nlong long text\r\nfor testing\r\nGetPositionFromChar method", true, 0, new Point(4, 1) };
-        yield return new object[] { new Size(100, 60), "This is a\r\nlong long text\r\nfor testing\r\nGetPositionFromChar method", true, 6, new Point(31, 1) };
-        yield return new object[] { new Size(100, 60), "This is a\r\nlong long text\r\nfor testing\r\nGetPositionFromChar method", true, 26, new Point(78, 16) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetPositionFromChar_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetPositionFromChar_ReturnsCorrectValue(Size size, string text, bool multiline, int charIndex, Point expectedPoint)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Text = text, Multiline = multiline };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Point actualPoint = provider.GetPositionFromChar(charIndex);
-
-        Assert.True(actualPoint.X >= expectedPoint.X - 1 || actualPoint.X <= expectedPoint.X + 1);
-        Assert.True(actualPoint.Y >= expectedPoint.Y - 1 || actualPoint.Y <= expectedPoint.Y + 1);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameter 'expectedPoint'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetPositionFromChar_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetPositionFromChar_ReturnsEmpty_WithoutHandle(Size size, string text, bool multiline, int charIndex, Point expectedPoint)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Text = text, Multiline = multiline };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Point actualPoint = provider.GetPositionFromChar(charIndex);
-        Assert.Equal(Point.Empty, actualPoint);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_TestData()
-    {
-        yield return new object[] { new Size(50, 20), "", false, 0, new Point(0, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text", false, 100, new Point(0, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text", false, -1, new Point(0, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text", false, 12, new Point(71, 0) };
-        yield return new object[] { new Size(50, 20), "Some test text", true, 12, new Point(19, 30) };
-        yield return new object[] { new Size(100, 60), "Some test \n text", false, 10, new Point(56, 0) };
-        yield return new object[] { new Size(100, 60), "Some test \n text", true, 10, new Point(59, 1) };
-        yield return new object[] { new Size(100, 60), "Some test \r\n text", false, 10, new Point(56, 0) };
-        yield return new object[] { new Size(100, 60), "Some test \r\n text", true, 10, new Point(59, 1) };
-        yield return new object[] { new Size(100, 60), "Some test \r\n text", false, 12, new Point(60, 0) };
-        yield return new object[] { new Size(100, 60), "Some test \r\n text", true, 12, new Point(7, 16) };
-        yield return new object[] { new Size(100, 60), "Some test \t text", false, 10, new Point(57, 0) };
-        yield return new object[] { new Size(100, 60), "Some test \t text", true, 10, new Point(60, 1) };
-        yield return new object[] { new Size(40, 60), "Some test \t text", true, 12, new Point(8, 46) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue(Size size, string text, bool multiline, int charIndex, Point expectedPoint)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Text = text, Multiline = multiline };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Point actualPoint = provider.GetPositionFromCharForUpperRightCorner(charIndex, textBoxBase.Text);
-        Assert.True(actualPoint.X >= expectedPoint.X - 1 || actualPoint.X <= expectedPoint.X + 1);
-        Assert.True(actualPoint.Y >= expectedPoint.Y - 1 || actualPoint.Y <= expectedPoint.Y + 1);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameter 'expectedPoint'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsCorrectValue_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetPositionFromCharForUpperRightCorner_ReturnsMinusOne_WithoutHandle(Size size, string text, bool multiline, int charIndex, Point expectedPoint)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Text = text, Multiline = multiline };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Point actualPoint = provider.GetPositionFromCharForUpperRightCorner(charIndex, textBoxBase.Text);
-        Assert.Equal(Point.Empty, actualPoint);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetFormattingRectangle_TestData()
-    {
-        yield return new object[] { false, new Size(0, 0), new Rectangle(1, 0, 78, 16) };
-        yield return new object[] { false, new Size(50, 50), new Rectangle(1, 1, 44, 15) };
-        yield return new object[] { false, new Size(250, 100), new Rectangle(1, 1, 244, 15) };
-        yield return new object[] { true, new Size(0, 0), new Rectangle(4, 0, 72, 16) };
-
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { true, new Size(50, 50), new Rectangle(4, 1, 38, 44) };
-            yield return new object[] { true, new Size(250, 100), new Rectangle(4, 1, 238, 94) };
-        }
-        else
-        {
-            yield return new object[] { true, new Size(50, 50), new Rectangle(4, 1, 38, 30) };
-            yield return new object[] { true, new Size(250, 100), new Rectangle(4, 1, 238, 90) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetFormattingRectangle_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetFormattingRectangle_ReturnsCorrectValue(bool multiline, Size size, Rectangle expectedRectangle)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Multiline = multiline };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Rectangle providerRectangle = provider.BoundingRectangle;
-
-        Assert.Equal(expectedRectangle, providerRectangle);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameter 'expectedRectangle'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetFormattingRectangle_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetFormattingRectangle_ReturnsEmpty_WithoutHandle(bool multiline, Size size, Rectangle expectedRectangle)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size, Multiline = multiline };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Rectangle providerRectangle = provider.BoundingRectangle;
-
-        Assert.Equal(Drawing.Rectangle.Empty, providerRectangle);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("Text")]
-    [InlineData("Some test text")]
-    public void TextBoxBaseUiaTextProvider_Text_ReturnsCorrectValue(string text)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.Text = text;
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        textBoxBase.CreateControl();
-        string expected = textBoxBase.Text;
-        string actual = provider.Text.Trim('\0');
-        Assert.Equal(expected, actual);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("Text")]
-    [InlineData("Some test text")]
-    public void TextBoxBaseUiaTextProvider_Text_ReturnsEmpty_WithoutHandle(string text)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.Text = text;
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        string expected = string.Empty;
-        string actual = provider.Text.Trim('\0');
-        Assert.Equal(expected, actual);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("")]
-    [InlineData("Text")]
-    [InlineData("Some test text for testing")]
-    [InlineData("Some very very very long test text for testing GetTextLength method")]
-    public void TextBoxBaseUiaTextProvider_TextLength_ReturnsCorrectValue(string text)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase
-        {
-            Text = text
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.Equal(textBoxBase.Text.Length, provider.TextLength);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_WindowExStyle_ReturnsCorrectValue()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        WINDOW_EX_STYLE actual = provider.WindowExStyle;
-        Assert.Equal(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE, actual);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_WindowExStyle_ReturnsLeft_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        WINDOW_EX_STYLE actual = provider.WindowExStyle;
-        Assert.Equal(WINDOW_EX_STYLE.WS_EX_LEFT, actual);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_EditStyle_ReturnsCorrectValue()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        WINDOW_STYLE actual = provider.WindowStyle;
-        Assert.False(((int)actual & PInvoke.ES_RIGHT) != 0);
-        Assert.True(((int)actual & PInvoke.ES_AUTOVSCROLL) != 0);
-        Assert.True(((int)actual & PInvoke.ES_AUTOHSCROLL) != 0);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_EditStyle_ReturnsLeft_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        WINDOW_STYLE actual = provider.WindowStyle;
-        Assert.Equal(PInvoke.ES_LEFT, (int)actual);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxBase_GetVisibleRangePoints_ForSinglelineTextBox_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0, 0 };
-        yield return new object[] { new Size(0, 20), 0, 0 };
-        yield return new object[] { new Size(30, 30), 0, 4 };
-        yield return new object[] { new Size(50, 20), 0, 8 };
-        yield return new object[] { new Size(150, 20), 0, 26 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBase_GetVisibleRangePoints_ForSinglelineTextBox_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ForSinglelineTextBox_ReturnsCorrectValue(Size size, int expectedStart, int expectedEnd)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Multiline = false,
-            Text = "Some test text for testing",
-            Size = size
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        provider.GetVisibleRangePoints(out int providerVisibleStart, out int providerVisibleEnd);
-
-        Assert.True(providerVisibleStart >= 0);
-        Assert.True(providerVisibleStart < textBoxBase.Text.Length);
-        Assert.True(providerVisibleEnd >= 0);
-        Assert.True(providerVisibleEnd <= textBoxBase.Text.Length);
-
-        Assert.Equal(expectedStart, providerVisibleStart);
-        Assert.Equal(expectedEnd, providerVisibleEnd);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ForMultilineTextBox_TestData()
-    {
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { new Size(0, 0), 0, 0 };
-            yield return new object[] { new Size(0, 20), 0, 0 };
-            yield return new object[] { new Size(30, 30), 0, 5 };
-            yield return new object[] { new Size(50, 20), 0, 5 };
-            yield return new object[] { new Size(120, 20), 0, 19 };
-            yield return new object[] { new Size(50, 80), 0, 26 };
-        }
-        else
-        {
-            yield return new object[] { new Size(0, 0), 0, 0 };
-            yield return new object[] { new Size(0, 20), 0, 0 };
-            yield return new object[] { new Size(30, 30), 0, 3 };
-            yield return new object[] { new Size(50, 20), 0, 6 };
-            yield return new object[] { new Size(120, 20), 0, 20 };
-            yield return new object[] { new Size(50, 80), 0, 26 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ForMultilineTextBox_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ForMultilineTextBox_ReturnsCorrectValue(
-        Size size, int expectedStart, int expectedEnd)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Multiline = true,
-            Text = "Some test text for testing",
-            Size = size,
-            WordWrap = true
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        provider.GetVisibleRangePoints(out int providerVisibleStart, out int providerVisibleEnd);
-
-        Assert.True(providerVisibleStart >= 0);
-        Assert.True(providerVisibleStart < textBoxBase.Text.Length);
-        Assert.True(providerVisibleEnd >= 0);
-        Assert.True(providerVisibleEnd <= textBoxBase.Text.Length);
-
-        Assert.Equal(expectedStart, providerVisibleStart);
-        Assert.Equal(expectedEnd, providerVisibleEnd);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-#pragma warning disable xUnit1026 // Disable xUnit1026 warning: The method doesn't use parameters 'expectedStart' and 'expectedEnd'
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ForMultilineTextBox_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetVisibleRangePoints_ReturnsZeros_WithoutHandle(Size size, int expectedStart, int expectedEnd)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase() { Size = size };
-        textBoxBase.Text = "Some test text for testing";
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        provider.GetVisibleRangePoints(out int providerVisibleStart, out int providerVisibleEnd);
-
-        Assert.Equal(0, providerVisibleStart);
-        Assert.Equal(0, providerVisibleEnd);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-#pragma warning restore xUnit1026
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_GetVisibleRanges_TestData()
-    {
-        yield return new object[] { new Size(0, 0) };
-        yield return new object[] { new Size(100, 20) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetVisibleRanges_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetVisibleRanges_ReturnsCorrectValue(Size size)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Text = "Some test text for testing",
-            Size = size
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.NotNull(provider.GetVisibleRanges());
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_GetVisibleRanges_TestData))]
-    public void TextBoxBaseUiaTextProvider_GetVisibleRanges_ReturnsNull_WithoutHandle(Size size)
-    {
-        using SubTextBoxBase textBoxBase = new SubTextBoxBase()
-        {
-            Text = "Some test text for testing",
-            Size = size
-        };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.Null(provider.GetVisibleRanges());
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_RangeFromAnnotation_DoesntThrowAnException()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        // RangeFromAnnotation doesn't throw an exception
-        UiaCore.ITextRangeProvider range = provider.RangeFromAnnotation(textBoxBase.AccessibilityObject);
-        // RangeFromAnnotation implementation can be changed so this test can be changed too
-        Assert.NotNull(range);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_RangeFromChild_DoesntThrowAnException()
-    {
-        using (new NoAssertContext())
-        {
-            using TextBoxBase textBoxBase = new SubTextBoxBase();
-            TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-            // RangeFromChild doesn't throw an exception
-            UiaCore.ITextRangeProvider range = provider.RangeFromChild(textBoxBase.AccessibilityObject);
-            // RangeFromChild implementation can be changed so this test can be changed too
-            Assert.Null(range);
-        }
-    }
-
-    public static IEnumerable<object[]> TextBoxBaseUiaTextProvider_RangeFromPoint_TestData()
-    {
-        yield return new object[] { Point.Empty };
-        yield return new object[] { new Point(10, 10) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_RangeFromPoint_TestData))]
-    public void TextBoxBaseUiaTextProvider_RangeFromPoint_DoesntThrowAnException(Point point)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        UiaTextRange textRangeProvider = provider.RangeFromPoint(point) as UiaTextRange;
-        Assert.NotNull(textRangeProvider);
-
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseUiaTextProvider_RangeFromPoint_TestData))]
-    public void TextBoxBaseUiaTextProvider_RangeFromPoint_ReturnsNull_WithoutHandle(Point point)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        UiaTextRange textRangeProvider = provider.RangeFromPoint(point) as UiaTextRange;
-        Assert.Null(textRangeProvider);
-
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 5)]
-    [InlineData(0, 10)]
-    public void TextBoxBaseUiaTextProvider_SetSelection_GetSelection_ReturnCorrectValue(int start, int end)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        textBoxBase.Text = "Some test text for testing";
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        provider.SetSelection(start, end);
-        UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-        Assert.NotNull(selection);
-
-        UiaTextRange textRange = selection[0] as UiaTextRange;
-        Assert.NotNull(textRange);
-
-        Assert.Equal(start, textRange.Start);
-        Assert.Equal(end, textRange.End);
-
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(2, 5)]
-    [InlineData(0, 10)]
-    public void TextBoxBaseUiaTextProvider_SetSelection_GetSelection_DontWork_WithoutHandle(int start, int end)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.Text = "Some test text for testing";
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        provider.SetSelection(start, end);
-        Assert.False(textBoxBase.IsHandleCreated);
-        UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-        Assert.Null(selection);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-5, 10)]
-    [InlineData(5, 100)]
-    public void TextBoxBaseUiaTextProvider_SetSelection_DoesntSelectText_IfIncorrectArguments(int start, int end)
-    {
-        using (new NoAssertContext())
-        {
-            using TextBoxBase textBoxBase = new SubTextBoxBase();
-            textBoxBase.CreateControl();
-            textBoxBase.Text = "Some test text for testing";
-            TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-            provider.SetSelection(start, end);
-            UiaCore.ITextRangeProvider[] selection = provider.GetSelection();
-            Assert.NotNull(selection);
-
-            UiaTextRange textRange = selection[0] as UiaTextRange;
-            Assert.NotNull(textRange);
-
-            Assert.Equal(0, textRange.Start);
-            Assert.Equal(0, textRange.End);
-
-            Assert.True(textBoxBase.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(2)]
-    public void TextBoxBaseUiaTextProvider_LineScroll_ReturnCorrectValue(int expectedLine)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase
-        {
-            Multiline = true,
-            Text = "Some long long test text for testing GetFirstVisibleLine method",
-            Size = new Size(50, 100)
-        };
-        textBoxBase.CreateControl();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-
-        Assert.True(provider.LineScroll(0, expectedLine));
-        Assert.Equal(expectedLine, provider.FirstVisibleLine);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(2)]
-    public void TextBoxBaseUiaTextProvider_LineScroll_DoesntWork_WithoutHandle(int expectedLine)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase
-        {
-            Multiline = true,
-            Size = new Size(50, 100)
-        };
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        textBoxBase.Text = "Some long long test text for testing GetFirstVisibleLine method";
-
-        Assert.False(provider.LineScroll(0, expectedLine));
-        Assert.Equal(-1, provider.FirstVisibleLine);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetLogfont_ReturnSegoe_ByDefault()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        Assert.NotEqual(IntPtr.Zero, textBoxBase.Handle);
-
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        LOGFONTW logFont = provider.Logfont;
-        string actual = logFont.FaceName.ToString();
-        Assert.Equal("Segoe UI", actual);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseUiaTextProvider_GetLogfont_ReturnEmpty_WithoutHandle()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        TextBoxBaseUiaTextProvider provider = new TextBoxBaseUiaTextProvider(textBoxBase);
-        Assert.False(textBoxBase.IsHandleCreated);
-
-        Assert.Equal(new LOGFONTW(), provider.Logfont);
-    }
-
-    private class SubTextBoxBase : TextBoxBase
-    { }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBaseAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBaseAccessibleObjectTests.cs
deleted file mode 100644
index 94540871061..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextBoxBaseAccessibleObjectTests.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TextBoxBaseAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void TextBoxBaseAccessibleObject_ctor_default()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-
-        AccessibleObject textBoxAccessibleObject = textBoxBase.AccessibilityObject;
-        Assert.NotNull(textBoxAccessibleObject);
-
-        TextBoxBase.TextBoxBaseAccessibleObject textBoxBaseAccessibleObject = new TextBoxBase.TextBoxBaseAccessibleObject(textBoxBase);
-        Assert.NotNull(textBoxBaseAccessibleObject);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)Interop.UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)Interop.UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    [InlineData((int)Interop.UiaCore.UIA.IsValuePatternAvailablePropertyId)]
-    public void TextBoxBaseAccessibleObject_PatternAvailable(int propertyId)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        AccessibleObject textBoxAccessibleObject = textBoxBase.AccessibilityObject;
-
-        // Interop.UiaCore.UIA accessible level (internal) is less than the test level (public) so it needs boxing and unboxing
-        Assert.True((bool)textBoxAccessibleObject.GetPropertyValue((Interop.UiaCore.UIA)propertyId));
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)Interop.UiaCore.UIA.TextPatternId)]
-    [InlineData((int)Interop.UiaCore.UIA.TextPattern2Id)]
-    [InlineData((int)Interop.UiaCore.UIA.ValuePatternId)]
-    public void TextBoxBaseAccessibleObject_PatternSupported(int patternId)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        AccessibleObject textBoxAccessibleObject = textBoxBase.AccessibilityObject;
-
-        // Interop.UiaCore.UIA accessible level (internal) is less than the test level (public) so it needs boxing and unboxing
-        Assert.True(textBoxAccessibleObject.IsPatternSupported((Interop.UiaCore.UIA)patternId));
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseAccessibleObject_SetValue_OwnerTextChanged()
-    {
-        const string text = "some text";
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-        accessibleObject.SetValue(text);
-
-        Assert.Equal(text, textBoxBase.Text);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TextBoxBaseAccessibleObject_IsReadOnly_ReturnsCorrectValue(bool readOnly)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-
-        textBoxBase.ReadOnly = readOnly;
-        Assert.Equal(textBoxBase.ReadOnly, accessibleObject.IsReadOnly);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseAccessibleObject_Name_ReturnsNullAsDefault()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-        Assert.Empty(accessibleObject.Name);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBaseAccessibleObject_Value_EqualsText()
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.CreateControl();
-        textBoxBase.Text = "Some test text";
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-        Assert.Equal(textBoxBase.Text, accessibleObject.Value);
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(50, 20)]
-    [InlineData(100, 10)]
-    public void TextBoxBaseAccessibleObject_BoundingRectangle_IsCorrect(int width, int height)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase { Size = new Size(width, height) };
-        textBoxBase.CreateControl();
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-        Rectangle expected = textBoxBase.RectangleToScreen(textBoxBase.ClientRectangle);
-        Rectangle actual = accessibleObject.BoundingRectangle;
-
-        Assert.True(actual.Contains(expected));
-        Assert.True(textBoxBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text, (int)UiaCore.UIA.EditControlTypeId)]
-    [InlineData(false, AccessibleRole.None, (int)UiaCore.UIA.PaneControlTypeId)]
-    public void TextBoxBaseAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool createControl, AccessibleRole expectedRole, int expectedType)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            textBoxBase.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = textBoxBase.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-        Assert.Equal(createControl, textBoxBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TextBoxBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TextBoxBaseAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TextBoxBase textBoxBase = new SubTextBoxBase();
-        textBoxBase.AccessibleRole = role;
-
-        object actual = textBoxBase.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(textBoxBase.IsHandleCreated);
-    }
-
-    private class SubTextBoxBase : TextBoxBase
-    { }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextRendererTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextRendererTests.cs
deleted file mode 100644
index dd0d6a1703d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TextRendererTests.cs
+++ /dev/null
@@ -1,834 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Drawing.Drawing2D;
-using System.Drawing.Imaging;
-using System.Drawing.Text;
-using System.Windows.Forms.Metafiles;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class TextRendererTests
-{
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Point_Color_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Point.Empty, Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Black };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.White };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Transparent };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Empty };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Point_Color_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontPointColor_Success(TextRenderingHint textRenderingHint, string text, Font font, Point pt, Color foreColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Point_Color_Color_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Point.Empty, Color.Red, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Red, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Black, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.White, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Transparent, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Empty, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Black };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.White };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Transparent };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Empty };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Point_Color_Color_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontPointColorColor_Success(TextRenderingHint textRenderingHint, string text, Font font, Point pt, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, backColor);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, backColor);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Point_Color_TextFormatFlags_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Point.Empty, Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Black, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.White, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Transparent, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Empty, TextFormatFlags.Default, };
-
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.Bottom | TextFormatFlags.Right };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, (TextFormatFlags)1024 };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.RightToLeft };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, (TextFormatFlags)int.MaxValue };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Point_Color_TextFormatFlags_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontPointColorTextFormatFlags_Success(TextRenderingHint textRenderingHint, string text, Font font, Point pt, Color foreColor, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, flags);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, flags);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Point_Color_Color_TextFormatFlags_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Red, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Black, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.White, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Transparent, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Point(1, 2), Color.Empty, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Black, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.White, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Transparent, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Empty, TextFormatFlags.Default, };
-
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.Bottom | TextFormatFlags.Right };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, (TextFormatFlags)1024 };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.RightToLeft };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, (TextFormatFlags)int.MaxValue };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Point_Color_Color_TextFormatFlags_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontPointColorColorTextFormatFlags_Success(TextRenderingHint textRenderingHint, string text, Font font, Point pt, Color foreColor, Color backColor, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, backColor, flags);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, pt, foreColor, backColor, flags);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Rectangle_Color_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Rectangle.Empty, Color.Red };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, -3, -4), Color.Red };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 3, 4), Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Black };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.White };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Transparent };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Empty };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Rectangle_Color_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontRectangleColor_Success(TextRenderingHint textRenderingHint, string text, Font font, Rectangle bounds, Color foreColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, bounds, foreColor);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, bounds, foreColor);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Rectangle_Color_Color_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Rectangle.Empty, Color.Red, Color.Blue };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, -3, -4), Color.Red, Color.Blue };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Red, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Black, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.White, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Transparent, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Empty, Color.Blue };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Red };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Black };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.White };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Transparent };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Empty };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Rectangle_Color_Color_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontRectangleColorColor_Success(TextRenderingHint textRenderingHint, string text, Font font, Rectangle rectangle, Color foreColor, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, backColor);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, backColor);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Rectangle_Color_TextFormatFlags_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Rectangle.Empty, Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, -3, -4), Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Black, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.White, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Transparent, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Empty, TextFormatFlags.Default, };
-
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.Bottom | TextFormatFlags.Right };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Red, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, (TextFormatFlags)1024 };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.RightToLeft };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, (TextFormatFlags)int.MaxValue };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Rectangle_Color_TextFormatFlags_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontRectangleColorTextFormatFlags_Success(TextRenderingHint textRenderingHint, string text, Font font, Rectangle rectangle, Color foreColor, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, flags);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, flags);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_String_Font_Rectangle_Color_Color_TextFormatFlags_TestData()
-    {
-        foreach (TextRenderingHint hint in Enum.GetValues(typeof(TextRenderingHint)))
-        {
-            foreach (string text in new string[] { null, string.Empty, "string" })
-            {
-                yield return new object[] { hint, text, null, Rectangle.Empty, Color.Red, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, -3, -4), Color.Red, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, null, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Blue, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Black, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.White, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Transparent, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Empty, Color.Blue, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Red, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Black, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.White, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Transparent, TextFormatFlags.Default, };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Empty, TextFormatFlags.Default, };
-
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.Bottom | TextFormatFlags.Right };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, int.MaxValue, int.MaxValue), Color.Red, Color.Blue, TextFormatFlags.SingleLine };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, (TextFormatFlags)1024 };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.RightToLeft };
-                yield return new object[] { hint, text, SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, (TextFormatFlags)int.MaxValue };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawText_IDeviceContext_String_Font_Rectangle_Color_Color_TextFormatFlags_TestData))]
-    public void TextRenderer_DrawText_InvokeIDeviceContextStringFontRectangleColorColorTextFormatFlags_Success(TextRenderingHint textRenderingHint, string text, Font font, Rectangle rectangle, Color foreColor, Color backColor, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        graphics.TextRenderingHint = textRenderingHint;
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, backColor, flags);
-
-        // Call again to test caching.
-        TextRenderer.DrawText(graphics, text, font, rectangle, foreColor, backColor, flags);
-    }
-
-    [WinFormsFact]
-    public void TextRenderer_DrawText_Mocked_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var mockDeviceContext = new Mock<IDeviceContext>(MockBehavior.Strict);
-        mockDeviceContext
-            .Setup(c => c.GetHdc())
-            .Returns(() => graphics.GetHdc())
-            .Verifiable();
-        mockDeviceContext
-            .Setup(c => c.ReleaseHdc())
-            .Callback(() => graphics.ReleaseHdc())
-            .Verifiable();
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, Point.Empty, Color.Red);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Once());
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Once());
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(2));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(2));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(3));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(3));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(4));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(4));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(5));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(5));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(6));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(6));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(7));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(7));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(8));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(8));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, Point.Empty, Color.Red);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(9));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(9));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(10));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(10));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, Point.Empty, Color.Red, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(11));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(11));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, Point.Empty, Color.Red, Color.Blue, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(12));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(12));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(13));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(13));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(14));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(14));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(15));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(15));
-
-        TextRenderer.DrawText(mockDeviceContext.Object, "text".AsSpan(), SystemFonts.MenuFont, new Rectangle(1, 2, 300, 400), Color.Red, Color.Blue, TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(16));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(16));
-    }
-
-    [WinFormsFact]
-    public void TextRenderer_DrawText_NullDc_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dc", () => TextRenderer.DrawText(null, "text", SystemFonts.MenuFont, Point.Empty, Color.Red));
-    }
-
-    public static IEnumerable<object[]> MeasureText_String_Font_TestData()
-    {
-        yield return new object[] { "string", null };
-        yield return new object[] { "string", SystemFonts.MenuFont };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_TestData))]
-    public void TextRenderer_MeasureText_InvokeStringFont_ReturnsExpected(string text, Font font)
-    {
-        Size result = TextRenderer.MeasureText(text, font);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(text, font));
-    }
-
-    public static IEnumerable<object[]> MeasureText_String_Font_Size_TestData()
-    {
-        yield return new object[] { "string", null, Size.Empty };
-        yield return new object[] { "string", null, new Size(1, 2) };
-        yield return new object[] { "string", null, new Size(100, 200) };
-        yield return new object[] { "string", null, new Size(int.MaxValue, int.MaxValue) };
-        yield return new object[] { "string", SystemFonts.MenuFont, Size.Empty };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(1, 2) };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200) };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_Size_TestData))]
-    public void TextRenderer_MeasureText_InvokeStringFontSize_ReturnsExpected(string text, Font font, Size proposedSize)
-    {
-        Size result = TextRenderer.MeasureText(text, font, proposedSize);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(text, font, proposedSize));
-    }
-
-    public static IEnumerable<object[]> MeasureText_String_Font_Size_TextFormatFlags_TestData()
-    {
-        yield return new object[] { "string", null, Size.Empty, TextFormatFlags.Default };
-        yield return new object[] { "string", null, new Size(1, 2), TextFormatFlags.Default };
-        yield return new object[] { "string", null, new Size(100, 200), TextFormatFlags.Default };
-        yield return new object[] { "string", null, new Size(int.MaxValue, int.MaxValue), TextFormatFlags.Default };
-        yield return new object[] { "string", SystemFonts.MenuFont, Size.Empty, TextFormatFlags.Default };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(1, 2), TextFormatFlags.Default };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), TextFormatFlags.Default };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(int.MaxValue, int.MaxValue), TextFormatFlags.Default };
-
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), TextFormatFlags.Bottom | TextFormatFlags.Right };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), TextFormatFlags.SingleLine };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(int.MaxValue, int.MaxValue), TextFormatFlags.SingleLine };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), (TextFormatFlags)1024 };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), TextFormatFlags.RightToLeft };
-        yield return new object[] { "string", SystemFonts.MenuFont, new Size(100, 200), (TextFormatFlags)int.MaxValue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_Size_TextFormatFlags_TestData))]
-    public void TextRenderer_MeasureText_InvokeStringFontSizeTextFormatFlags_ReturnsExpected(string text, Font font, Size proposedSize, TextFormatFlags flags)
-    {
-        Size result = TextRenderer.MeasureText(text, font, proposedSize, flags);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(text, font, proposedSize, flags));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_TestData))]
-    public void TextRenderer_MeasureText_InvokeIDeviceContextStringFont_ReturnsExpected(string text, Font font)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        Size result = TextRenderer.MeasureText(graphics, text, font);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(graphics, text, font));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_Size_TestData))]
-    public void TextRenderer_MeasureText_InvokeIDeviceContextStringFontSize_ReturnsExpected(string text, Font font, Size proposedSize)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        Size result = TextRenderer.MeasureText(graphics, text, font, proposedSize);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(graphics, text, font, proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MeasureText_String_Font_Size_TextFormatFlags_TestData))]
-    public void TextRenderer_MeasureText_InvokeIDeviceContextStringFontSizeTextFormatFlags_ReturnsExpected(string text, Font font, Size proposedSize, TextFormatFlags flags)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        Size result = TextRenderer.MeasureText(graphics, text, font, proposedSize, flags);
-        Assert.True(result.Width > 0);
-        Assert.True(result.Height > 0);
-
-        // Call again to test caching.
-        Assert.Equal(result, TextRenderer.MeasureText(graphics, text, font, proposedSize, flags));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void TextRenderer_MeasureText_NullOrEmptyString_ReturnsEmpty(string text)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text, SystemFonts.MenuFont));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text, SystemFonts.MenuFont, new Size(300, 400)));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text, SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text, SystemFonts.MenuFont));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text, SystemFonts.MenuFont, new Size(300, 400)));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text, SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text.AsSpan(), SystemFonts.MenuFont));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text.AsSpan(), SystemFonts.MenuFont, new Size(300, 400)));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(text.AsSpan(), SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text.AsSpan(), SystemFonts.MenuFont));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text.AsSpan(), SystemFonts.MenuFont, new Size(300, 400)));
-        Assert.Equal(Size.Empty, TextRenderer.MeasureText(graphics, text.AsSpan(), SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default));
-    }
-
-    [WinFormsFact]
-    public void TextRenderer_MeasureText_Mocked_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var mockDeviceContext = new Mock<IDeviceContext>(MockBehavior.Strict);
-        mockDeviceContext
-            .Setup(c => c.GetHdc())
-            .Returns(() => graphics.GetHdc())
-            .Verifiable();
-        mockDeviceContext
-            .Setup(c => c.ReleaseHdc())
-            .Callback(() => graphics.ReleaseHdc())
-            .Verifiable();
-
-        TextRenderer.MeasureText(mockDeviceContext.Object, "text", SystemFonts.MenuFont);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Once());
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Once());
-
-        TextRenderer.MeasureText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Size(300, 400));
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(2));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(2));
-
-        TextRenderer.MeasureText(mockDeviceContext.Object, "text", SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default);
-        mockDeviceContext.Verify(c => c.GetHdc(), Times.Exactly(3));
-        mockDeviceContext.Verify(c => c.ReleaseHdc(), Times.Exactly(3));
-    }
-
-    [WinFormsFact]
-    public void TextRenderer_MeasureText_NullDc_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("dc", () => TextRenderer.MeasureText(null, string.Empty, SystemFonts.MenuFont));
-        Assert.Throws<ArgumentNullException>("dc", () => TextRenderer.MeasureText(null, string.Empty, SystemFonts.MenuFont, new Size(300, 400)));
-        Assert.Throws<ArgumentNullException>("dc", () => TextRenderer.MeasureText(null, string.Empty, SystemFonts.MenuFont, new Size(300, 400), TextFormatFlags.Default));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_DrawText_DefaultBackground_RendersTransparent_TestData))]
-    public unsafe void TextRenderer_DrawText_DefaultBackground_RendersTransparent(Func<IDeviceContext, Action> func)
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-        func(new HdcDeviceContextAdapter(emf)).Invoke();
-
-        emf.Validate(
-            state,
-            Validate.TextOut(
-                "Acrylic",
-                bounds: null,                                   // Don't care about the bounds for this test
-                State.FontFace(SystemFonts.DefaultFont.Name),
-                State.TextColor(Color.Blue),
-                State.BackgroundMode(BACKGROUND_MODE.TRANSPARENT)));
-    }
-
-    public static TheoryData<Func<IDeviceContext, Action>> TextRenderer_DrawText_DefaultBackground_RendersTransparent_TestData
-        => new()
-        {
-                (IDeviceContext context) => () =>
-                    TextRenderer.DrawText(context, "Acrylic", SystemFonts.DefaultFont,
-                        pt: default, Color.Blue),
-                (IDeviceContext context) => () =>
-                    TextRenderer.DrawText(context, "Acrylic", SystemFonts.DefaultFont,
-                        pt: default, Color.Blue, flags: default),
-                (IDeviceContext context) => () =>
-                    TextRenderer.DrawText(context, "Acrylic", SystemFonts.DefaultFont,
-                        bounds: new Rectangle(0, 0, int.MaxValue, int.MaxValue), Color.Blue),
-                (IDeviceContext context) => () =>
-                    TextRenderer.DrawText(context, "Acrylic", SystemFonts.DefaultFont,
-                        bounds: new Rectangle(0, 0, int.MaxValue, int.MaxValue), Color.Blue, flags: default),
-            };
-
-    [Theory]
-    [MemberData(nameof(TextRenderer_Span_ModifyString_ThrowsArgumentOutOfRange_TestData))]
-    public void TextRenderer_Span_ModifyString_ThrowsArgumentOutOfRange(Action action)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("flags", action);
-    }
-
-#pragma warning disable CS0618 // Type or member is obsolete
-    public static TheoryData<Action> TextRenderer_Span_ModifyString_ThrowsArgumentOutOfRange_TestData()
-        => new()
-        {
-            () => TextRenderer.DrawText(
-                MockDC.Instance,
-                string.Empty.AsSpan(),
-                null,
-                new Point(),
-                Color.Empty,
-                TextFormatFlags.ModifyString),
-            () => TextRenderer.DrawText(
-                MockDC.Instance,
-                string.Empty.AsSpan(),
-                null,
-                new Point(),
-                Color.Empty,
-                Color.Empty,
-                TextFormatFlags.ModifyString),
-            () => TextRenderer.DrawText(
-                MockDC.Instance,
-                string.Empty.AsSpan(),
-                null,
-                new Rectangle(),
-                Color.Empty,
-                TextFormatFlags.ModifyString),
-            () => TextRenderer.DrawText(
-                MockDC.Instance,
-                string.Empty.AsSpan(),
-                null,
-                new Rectangle(),
-                Color.Empty,
-                Color.Empty,
-                TextFormatFlags.ModifyString),
-            () => TextRenderer.MeasureText(
-                MockDC.Instance,
-                string.Empty.AsSpan(),
-                null,
-                new Size(),
-                TextFormatFlags.ModifyString),
-            () => TextRenderer.MeasureText(
-                string.Empty.AsSpan(),
-                null,
-                new Size(),
-                TextFormatFlags.ModifyString),
-        };
-#pragma warning restore CS0618 // Type or member is obsolete
-
-    private class MockDC : IDeviceContext
-    {
-        public static MockDC Instance { get; } = new MockDC();
-        public void Dispose() { }
-        public IntPtr GetHdc() => IntPtr.Zero;
-        public void ReleaseHdc() { }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_DrawText_Padding_TestData))]
-    public unsafe void TextRenderer_DrawText_Padding_Point(TextFormatFlags flags, Rectangle expectedBounds)
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-        TextRenderer.DrawText(
-            new HdcDeviceContextAdapter(emf),
-            "Sparkling Cider",
-            SystemFonts.DefaultFont,
-            (Point)default,
-            Color.Red,
-            flags);
-
-        emf.Validate(
-            state,
-            Validate.TextOut(
-                "Sparkling Cider",
-                expectedBounds,
-                State.FontFace(SystemFonts.DefaultFont.Name),
-                State.TextColor(Color.Red)));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_DrawText_Padding_TestData))]
-    public unsafe void TextRenderer_DrawText_Padding_Rectangle(TextFormatFlags flags, Rectangle expectedBounds)
-    {
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-        TextRenderer.DrawText(
-            new HdcDeviceContextAdapter(emf),
-            "Sparkling Cider",
-            SystemFonts.DefaultFont,
-            new Rectangle(0, 0, int.MaxValue, int.MaxValue),
-            Color.Red,
-            flags);
-
-        emf.Validate(
-            state,
-            Validate.TextOut(
-                "Sparkling Cider",
-                expectedBounds,
-                State.FontFace(SystemFonts.DefaultFont.Name),
-                State.TextColor(Color.Red)));
-    }
-
-    public static TheoryData<TextFormatFlags, Rectangle> TextRenderer_DrawText_Padding_TestData
-        => new()
-        {
-            { TextFormatFlags.GlyphOverhangPadding, new Rectangle(3, 0, 70, 12) },
-            { TextFormatFlags.LeftAndRightPadding, new Rectangle(5, 0, 70, 12) },
-            { TextFormatFlags.NoPadding, new Rectangle(0, 0, 70, 12) }
-        };
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_MeasureText_Padding_TestData))]
-    public void TextRenderer_MeasureText_Padding(TextFormatFlags flags, Size expectedSize)
-    {
-        using var image = new Bitmap(200, 50);
-        using Graphics graphics = Graphics.FromImage(image);
-        Size size = TextRenderer.MeasureText(
-            graphics,
-            "Sparkling Cider",
-            SystemFonts.DefaultFont,
-            new Size(int.MaxValue, int.MaxValue),
-            flags);
-
-        Assert.Equal(expectedSize, size);
-    }
-
-    public static TheoryData<TextFormatFlags, Size> TextRenderer_MeasureText_Padding_TestData
-        => new()
-        {
-            { TextFormatFlags.GlyphOverhangPadding, new Size(78, 13) },
-            { TextFormatFlags.LeftAndRightPadding, new Size(82, 13) },
-            { TextFormatFlags.NoPadding, new Size(71, 13) }
-        };
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_DrawText_ApplyState_TestData))]
-    public void TextRenderer_DrawText_ApplyState(TextFormatFlags flags, Rectangle expectedBounds)
-    {
-        using var hdc = new PInvoke.CreateDcScope(default);
-        DeviceContextState state = new DeviceContextState(hdc);
-
-        using MemoryStream stream = new MemoryStream(1024);
-        using (Metafile metafileRecorder = new Metafile(stream, hdc.HDC, EmfType.EmfOnly))
-        using (Graphics graphics = Graphics.FromImage(metafileRecorder))
-        {
-            using Matrix matrix = new Matrix();
-            matrix.Translate(5, 10);
-            graphics.Transform = matrix;
-            using Region region = new(new Rectangle(1, 2, 6, 8));
-            graphics.Clip = region;
-
-            // We have modified graphics, but several tests don't set all the flags
-            // TextRenderer asserts for to ensure integrity.
-            using NoAssertContext noAssertContext = new();
-
-            TextRenderer.DrawText(
-                graphics,
-                "Landshark",
-                SystemFonts.DefaultFont,
-                new Rectangle(0, 0, int.MaxValue, int.MaxValue),
-                Color.Red,
-                flags);
-        }
-
-        // Need to queue the stream back to the beginning for the reader
-        stream.Position = 0;
-        using Metafile metafile = new Metafile(stream);
-        using var emf = new EmfScope((HENHMETAFILE)metafile.GetHenhmetafile());
-
-        emf.Validate(
-            state,
-            Validate.TextOut(
-                "Landshark",
-                expectedBounds,
-                State.FontFace(SystemFonts.DefaultFont.Name),
-                State.TextColor(Color.Red)));
-    }
-
-    public static TheoryData<TextFormatFlags, Rectangle> TextRenderer_DrawText_ApplyState_TestData
-        => new()
-        {
-            { TextFormatFlags.Default, new Rectangle(3, 0, 49, 12) },
-            { TextFormatFlags.PreserveGraphicsTranslateTransform, new Rectangle(8, 10, 49, 12) },
-            { TextFormatFlags.PreserveGraphicsClipping, new Rectangle(6, 12, 5, 0) },
-            { TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.PreserveGraphicsTranslateTransform, new Rectangle(8, 12, 3, 7) },
-        };
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextRenderer_MeasureText_ApplyState_TestData))]
-    public void TextRenderer_MeasureText_ApplyState(TextFormatFlags flags, Size expectedSize)
-    {
-        using var image = new Bitmap(200, 50);
-        using Graphics graphics = Graphics.FromImage(image);
-        using Matrix matrix = new Matrix();
-        matrix.Translate(5, 10);
-        graphics.Transform = matrix;
-        using Region region = new(new Rectangle(1, 2, 6, 8));
-        graphics.Clip = region;
-
-        // We have modified graphics, but several tests don't set all the flags
-        // TextRenderer asserts for to ensure integrity.
-        using NoAssertContext noAssertContext = new();
-
-        Size size = TextRenderer.MeasureText(
-            graphics,
-            "Landshark",
-            SystemFonts.DefaultFont,
-            new Size(int.MaxValue, int.MaxValue),
-            flags);
-
-        Assert.Equal(expectedSize, size);
-    }
-
-    public static TheoryData<TextFormatFlags, Size> TextRenderer_MeasureText_ApplyState_TestData
-        => new()
-        {
-            // State application doesn't practically impact size measurements, but we still want to have a regression test
-            // here in case something sneaks in.
-            { TextFormatFlags.Default, new Size(57, 13) },
-            { TextFormatFlags.PreserveGraphicsTranslateTransform, new Size(57, 13) },
-            { TextFormatFlags.PreserveGraphicsClipping, new Size(57, 13) },
-            { TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.PreserveGraphicsTranslateTransform, new Size(57, 13) },
-        };
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TimerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TimerTests.cs
deleted file mode 100644
index 7636d41d9ec..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TimerTests.cs
+++ /dev/null
@@ -1,462 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class TimerTests
-{
-    [WinFormsFact]
-    public void Timer_Ctor_Default()
-    {
-        using var timer = new SubTimer();
-        Assert.Null(timer.Container);
-        Assert.False(timer.DesignMode);
-        Assert.False(timer.Enabled);
-        Assert.Equal(100, timer.Interval);
-        Assert.Null(timer.Site);
-        Assert.Null(timer.Tag);
-    }
-
-    [WinFormsFact]
-    public void Timer_Ctor_IContainer()
-    {
-        using var container = new Container();
-        using var timer = new SubTimer(container);
-        Assert.Same(container, timer.Container);
-        Assert.False(timer.DesignMode);
-        Assert.False(timer.Enabled);
-        Assert.Equal(100, timer.Interval);
-        Assert.NotNull(timer.Site);
-        Assert.Null(timer.Tag);
-    }
-
-    [WinFormsFact]
-    public void Timer_Ctor_NullContainer_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("container", () => new Timer(null));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Enabled_Set_GetReturnsExpected(bool value)
-    {
-        using var timer = new Timer
-        {
-            Enabled = value
-        };
-        Assert.Equal(value, timer.Enabled);
-
-        // Set same.
-        timer.Enabled = value;
-        Assert.Equal(value, timer.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Enabled_SetDesignMode_GetReturnsExpected(bool value)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        timer.Site = mockSite.Object;
-        Assert.True(timer.DesignMode);
-
-        timer.Enabled = value;
-        Assert.Equal(value, timer.Enabled);
-
-        // Set same.
-        timer.Enabled = value;
-        Assert.Equal(value, timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Enabled_SetDesignModeAfterEnabling_GetReturnsExpected(bool value)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        timer.Site = mockSite.Object;
-        Assert.True(timer.DesignMode);
-
-        timer.Start();
-
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-
-        timer.Enabled = value;
-        Assert.Equal(value, timer.Enabled);
-
-        // Set same.
-        timer.Enabled = value;
-        Assert.Equal(value, timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(100)]
-    public void Timer_Interval_Set_GetReturnsExpected(int value)
-    {
-        using var timer = new Timer
-        {
-            Interval = value
-        };
-        Assert.Equal(value, timer.Interval);
-
-        // Set same.
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(100)]
-    public void Timer_Interval_SetStarted_GetReturnsExpected(int value)
-    {
-        using var timer = new Timer();
-        timer.Start();
-
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // Set same.
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(100)]
-    public void Timer_Interval_SetStopped_GetReturnsExpected(int value)
-    {
-        using var timer = new Timer();
-        timer.Start();
-        timer.Stop();
-
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // Set same.
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(100)]
-    public void Timer_Interval_SetDesignMode_GetReturnsExpected(int value)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        timer.Site = mockSite.Object;
-        Assert.True(timer.DesignMode);
-
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // Set same.
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(100)]
-    public void Timer_Interval_SetDesignModeAfterEnabling_GetReturnsExpected(int value)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        timer.Site = mockSite.Object;
-        Assert.True(timer.DesignMode);
-
-        timer.Start();
-
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(false);
-
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // Set same.
-        timer.Interval = value;
-        Assert.Equal(value, timer.Interval);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(-1)]
-    public void Timer_Interval_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var timer = new Timer();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => timer.Interval = value);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Timer_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var timer = new Timer
-        {
-            Tag = value
-        };
-        Assert.Same(value, timer.Tag);
-
-        // Set same.
-        timer.Tag = value;
-        Assert.Same(value, timer.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void Timer_Tag_SetDesignMode_GetReturnsExpected(object value)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        timer.Site = mockSite.Object;
-        Assert.True(timer.DesignMode);
-
-        timer.Tag = value;
-        Assert.Same(value, timer.Tag);
-
-        // Set same.
-        timer.Tag = value;
-        Assert.Same(value, timer.Tag);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Start_Stop_Success(bool designMode)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        timer.Site = mockSite.Object;
-        Assert.Equal(designMode, timer.DesignMode);
-
-        // Start
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // Stop.
-        timer.Stop();
-        Assert.False(timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Start_MultipleTimes_Success(bool designMode)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        timer.Site = mockSite.Object;
-        Assert.Equal(designMode, timer.DesignMode);
-
-        // Start
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // Start again.
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Stop_Restart_Success(bool designMode)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        timer.Site = mockSite.Object;
-        Assert.Equal(designMode, timer.DesignMode);
-
-        // Start
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // Stop.
-        timer.Stop();
-        Assert.False(timer.Enabled);
-
-        // Start again.
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // Stop again.
-        timer.Stop();
-        Assert.False(timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Timer_Stop_MultipleTimes_Success(bool designMode)
-    {
-        using var timer = new SubTimer();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        timer.Site = mockSite.Object;
-        Assert.Equal(designMode, timer.DesignMode);
-
-        // Start
-        timer.Start();
-        Assert.True(timer.Enabled);
-
-        // Stop.
-        timer.Stop();
-        Assert.False(timer.Enabled);
-
-        // Stop again.
-        timer.Stop();
-        Assert.False(timer.Enabled);
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        timer.Site = null;
-    }
-
-    [WinFormsFact]
-    public void Timer_OnTick_Invoke_CallsTick()
-    {
-        using var timer = new SubTimer();
-        var eventArgs = new EventArgs();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(timer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        timer.Tick += handler;
-        timer.OnTick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        timer.Tick -= handler;
-        timer.OnTick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void Timer_Dispose_NotStarted_Success()
-    {
-        using var timer = new Timer();
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-
-        // Call again.
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-    }
-
-    [WinFormsFact]
-    public void Timer_Dispose_Started_Success()
-    {
-        using var timer = new Timer();
-        timer.Start();
-
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-
-        // Call again.
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-    }
-
-    [WinFormsFact]
-    public void Timer_Dispose_Stopped_Success()
-    {
-        using var timer = new Timer();
-        timer.Start();
-        timer.Stop();
-
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-
-        // Call again.
-        timer.Dispose();
-        Assert.False(timer.Enabled);
-    }
-
-    [WinFormsFact]
-    public void Timer_ToString_Invoke_ReturnsExpected()
-    {
-        using var timer = new Timer();
-        Assert.Equal("System.Windows.Forms.Timer, Interval: 100", timer.ToString());
-    }
-
-    private class SubTimer : Timer
-    {
-        public SubTimer() : base()
-        {
-        }
-
-        public SubTimer(IContainer container) : base(container)
-        {
-        }
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new void OnTick(EventArgs e) => base.OnTick(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStrip.ToolStripAccessibleObjectWrapperForItemsOnOverflowTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStrip.ToolStripAccessibleObjectWrapperForItemsOnOverflowTests.cs
deleted file mode 100644
index f9ac989e840..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStrip.ToolStripAccessibleObjectWrapperForItemsOnOverflowTests.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using static System.Windows.Forms.ToolStripItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStrip_ToolStripAccessibleObjectWrapperForItemsOnOverflowTests
-{
-    [WinFormsFact]
-    public void ToolStripAccessibleObjectWrapperForItemsOnOverflow_Ctor_Default()
-    {
-        using ToolStripButton toolStripItem = new ToolStripButton();
-
-        Type type = typeof(ToolStrip)
-            .GetNestedType("ToolStripAccessibleObjectWrapperForItemsOnOverflow", BindingFlags.Instance | BindingFlags.NonPublic);
-        ToolStripItemAccessibleObject accessibleObject = (ToolStripItemAccessibleObject)Activator.CreateInstance(type, toolStripItem);
-
-        Assert.Equal(toolStripItem, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObjectWrapperForItemsOnOverflow_ControlType_IsPane_IfAccessibleRoleIsDefault()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        using ToolStripButton toolStripItem = new ToolStripButton();
-        toolStrip.Items.Add(toolStripItem);
-        toolStripItem.SetPlacement(ToolStripItemPlacement.Overflow);
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject.GetChild(1);
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObjectWrapperForItemsOnOverflow_Role_IsPushButton_ByDefault()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        using ToolStripButton toolStripItem = new ToolStripButton();
-        toolStrip.Items.Add(toolStripItem);
-        toolStripItem.SetPlacement(ToolStripItemPlacement.Overflow);
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject.GetChild(1);
-        AccessibleRole actual = accessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.PushButton, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObjectWrapperForItemsOnOverflow_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObjectWrapperForItemsOnOverflow_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripAccessibleObjectWrapperForItemsOnOverflow_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        using ToolStripButton toolStripItem = new ToolStripButton();
-        toolStrip.Items.Add(toolStripItem);
-        toolStripItem.SetPlacement(ToolStripItemPlacement.Overflow);
-        toolStripItem.AccessibleRole = role;
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject.GetChild(1);
-        AccessibleRole actual = accessibleObject.Role;
-
-        Assert.Equal(role, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripAccessibleObjectTests.cs
deleted file mode 100644
index c9cd07c15f2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripAccessibleObjectTests.cs
+++ /dev/null
@@ -1,995 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_Ctor_Default()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-
-        var accessibleObject = new ToolStrip.ToolStripAccessibleObject(toolStrip);
-        Assert.NotNull(accessibleObject.Owner);
-        Assert.Equal(AccessibleRole.ToolBar, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip()
-        {
-            Name = "Name1",
-            AccessibleName = "Test Name"
-        };
-
-        AccessibleObject toolStripAccessibleObject = toolStrip.AccessibilityObject;
-        var accessibleName = toolStripAccessibleObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal("Test Name", accessibleName);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var toolStrip = new ToolStrip();
-        AccessibleObject toolStripAccessibleObject = toolStrip.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = toolStripAccessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_LegacyIAccessible_Custom_Role_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip()
-        {
-            AccessibleRole = AccessibleRole.Link
-        };
-
-        AccessibleObject toolStripAccessibleObject = toolStrip.AccessibilityObject;
-        var accessibleObjectRole = toolStripAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_LegacyIAccessible_Custom_Description_ReturnsExpected()
-    {
-        using var toolStrip = new ToolStrip()
-        {
-            AccessibleDescription = "Test Description"
-        };
-
-        AccessibleObject toolStripAccessibleObject = toolStrip.AccessibilityObject;
-        var accessibleObjectDescription = toolStripAccessibleObject.Description;
-
-        Assert.Equal("Test Description", accessibleObjectDescription);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_ControlType_IsToolBar_IfAccessibleRoleIsDefault()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ToolBarControlTypeId, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        toolStrip.AccessibleRole = role;
-
-        object actual = toolStrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData()
-    {
-        Array directions = Enum.GetValues<UiaCore.NavigateDirection>();
-
-        foreach (UiaCore.NavigateDirection direction in directions)
-        {
-            yield return new object[] { direction };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated(int navigateDirection)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(itemCount: 1, createControl: false);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate((UiaCore.NavigateDirection)navigateDirection));
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using ToolStrip toolStrip = CreateToolStrip();
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using ToolStrip toolStrip = CreateToolStrip();
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ThumbButton()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        toolStrip.CreateControl();
-
-        var accessibleObject = toolStrip.AccessibilityObject;
-
-        UiaCore.IRawElementProviderFragment firstChild = accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        Assert.NotNull(firstChild);
-        Assert.Equal(UiaCore.UIA.ThumbControlTypeId, firstChild.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-
-            yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-        }
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData()
-    {
-        foreach (object[] data in ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (bool canOverflow in canOverflowValues)
-        {
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-            yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfGripVisibleAndToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndOverflow_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfOverflow(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: true, itemCount: 1);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndStackLayout(ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(ToolStripGripStyle.Hidden, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData()
-    {
-        Size overflowSize = new(10, 10);
-
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, overflowSize };
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, overflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndCannotOverflowAndNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfCanNotOverflowAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock: null, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        toolStrip.Items.Insert(0, CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items.Add(CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items.Insert(0, CreateSkippedItem());
-
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfFirstItemSkippedAndSecondAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items.Insert(0, CreateSkippedItem());
-
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGripAndNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData()
-    {
-        Size horizontalSize = new(300, 30);
-        Size verticalSize = new(30, 300);
-
-        bool[] canOverflowValues = new[] { true, false };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-            foreach (bool canOverflow in canOverflowValues)
-            {
-                yield return new object[] { grip, ToolStripLayoutStyle.Table, null, verticalSize, canOverflow };
-                yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, horizontalSize, canOverflow };
-            }
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_TestData()
-    {
-        foreach (object[] data in ToolStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData())
-        {
-            yield return data;
-        }
-
-        foreach (object[] data in ToolStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData())
-        {
-            yield return data;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmpty(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfToolStripIsEmptyAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfLastItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 1);
-
-        toolStrip.Items.Add(CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNoGrip_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items.Add(CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfGripVisible_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsSkippedAndGripVisible(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 0);
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items.Add(CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Grip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items.Insert(0, CreateSkippedItem());
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfFirstItemSkippedAndAlignedAndLastSkippedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items.Insert(0, CreateSkippedItem());
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items[3].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[2].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfAllItemsAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size, bool canOverflow)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow, itemCount: 2);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-        toolStrip.Items[1].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(10, 25);
-        Size verticalOverflowSize = new(25, 10);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfOverflow_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow: true, itemCount: 3);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData()
-    {
-        Size horizontalOverflowSize = new(30, 30);
-        Size horizontalOverflowGripSize = new(40, 30);
-        Size verticalOverflowSize = new(30, 30);
-        Size verticalOverflowGripSize = new(30, 40);
-        Size bothOverflowSize = new(25, 25);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflow_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflow(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData()
-    {
-        Size horizontalOverflowSize = new(40, 30);
-        Size horizontalOverflowGripSize = new(50, 30);
-        Size verticalOverflowSize = new(30, 55);
-        Size verticalOverflowGripSize = new(30, 65);
-        Size bothOverflowSize = new(28, 28);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Table, null, bothOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.Flow, null, bothOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemSkipped_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndItemSkipped(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow: false, itemCount: 2);
-
-        toolStrip.Items.Insert(1, CreateSkippedItem());
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData()
-    {
-        Size horizontalOverflowSize = new(60, 30);
-        Size horizontalOverflowGripSize = new(70, 30);
-        Size verticalOverflowSize = new(30, 70);
-        Size verticalOverflowGripSize = new(30, 60);
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.HorizontalStackWithOverflow, null, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.VerticalStackWithOverflow, null, verticalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, horizontalOverflowSize };
-
-        yield return new object[] { ToolStripGripStyle.Visible, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowGripSize };
-        yield return new object[] { ToolStripGripStyle.Hidden, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, verticalOverflowSize };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    public static IEnumerable<object[]> ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData()
-    {
-        Size overflowSize = new(30, 40);
-
-        foreach (ToolStripGripStyle grip in Enum.GetValues<ToolStripGripStyle>())
-        {
-            yield return new object[] { grip, ToolStripLayoutStyle.Table, null, overflowSize };
-            yield return new object[] { grip, ToolStripLayoutStyle.Flow, null, overflowSize };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripAccessibleObject_FragmentNavigate_IfCannotOverflowAndItemAlignedAndNonStackLayout_TestData))]
-    public void ToolStripAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfCannotOverflowAndFirstItemAlignedAndNonStackLayout(ToolStripGripStyle grip, ToolStripLayoutStyle layout, DockStyle? dock, Size size)
-    {
-        using ToolStrip toolStrip = CreateToolStrip(grip, layout, dock, size, canOverflow: false, itemCount: 3);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        AccessibleObject accessibleObject = toolStrip.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    internal static ToolStripItem CreateSkippedItem()
-    {
-        Label emptyLabel = new();
-
-        return new ToolStripControlHost(emptyLabel);
-    }
-
-    internal static ToolStripLayoutStyle[] GetStackToolStripLayoutStyles()
-    {
-        return new ToolStripLayoutStyle[]
-        {
-            ToolStripLayoutStyle.HorizontalStackWithOverflow,
-            ToolStripLayoutStyle.VerticalStackWithOverflow,
-            ToolStripLayoutStyle.StackWithOverflow
-        };
-    }
-
-    internal static ToolStripLayoutStyle[] GetNonStackToolStripLayoutStyles()
-    {
-        return new ToolStripLayoutStyle[]
-        {
-            ToolStripLayoutStyle.Table,
-            ToolStripLayoutStyle.Flow
-        };
-    }
-
-    internal static IEnumerable<(ToolStripLayoutStyle, ToolStripGripStyle)> GetLayoutsWithGripVisible()
-    {
-        foreach (ToolStripLayoutStyle layout in GetStackToolStripLayoutStyles())
-        {
-            yield return (layout, ToolStripGripStyle.Visible);
-        }
-    }
-
-    internal static IEnumerable<(ToolStripLayoutStyle, ToolStripGripStyle)> GetLayoutsWithGripNotVisible()
-    {
-        foreach (ToolStripLayoutStyle layout in GetStackToolStripLayoutStyles())
-        {
-            yield return (layout, ToolStripGripStyle.Hidden);
-        }
-
-        foreach (ToolStripLayoutStyle layout in GetNonStackToolStripLayoutStyles())
-        {
-            yield return (layout, ToolStripGripStyle.Visible);
-            yield return (layout, ToolStripGripStyle.Hidden);
-        }
-    }
-
-    private ToolStrip CreateToolStrip(
-        ToolStripGripStyle? gripStyle = null,
-        ToolStripLayoutStyle? layoutStyle = null,
-        DockStyle? dock = null,
-        Size? size = null,
-        bool? canOverflow = null,
-        int itemCount = 0,
-        bool createControl = true
-    )
-    {
-        ToolStrip toolStrip = new();
-
-        if (layoutStyle is not null)
-        {
-            toolStrip.LayoutStyle = layoutStyle.Value;
-        }
-
-        if (gripStyle is not null)
-        {
-            toolStrip.GripStyle = gripStyle.Value;
-        }
-
-        if (dock is not null)
-        {
-            toolStrip.Dock = dock.Value;
-        }
-
-        if (size is not null)
-        {
-            toolStrip.AutoSize = false;
-            toolStrip.Size = size.Value;
-        }
-
-        if (canOverflow is not null)
-        {
-            toolStrip.CanOverflow = canOverflow.Value;
-        }
-
-        for (int i = 0; i < itemCount; i++)
-        {
-            toolStrip.Items.Add(CreateToolStripItem());
-        }
-
-        toolStrip.PerformLayout();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        return toolStrip;
-
-        ToolStripItem CreateToolStripItem()
-        {
-            return new ToolStripButton()
-            {
-                AutoSize = false,
-                Size = new Size(25, 25)
-            };
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripArrowRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripArrowRenderEventArgsTests.cs
deleted file mode 100644
index 2d9d6798a68..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripArrowRenderEventArgsTests.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripArrowRenderEventArgsTests
-{
-    [WinFormsFact]
-    public void ToolStripArrowRenderEventArgs_NullGraphics_ThrowsArgumentNullException()
-    {
-        using var toolStripButton = new ToolStripButton();
-        Assert.Throws<ArgumentNullException>(() => new ToolStripArrowRenderEventArgs(null, toolStripButton, Rectangle.Empty, Color.Empty, ArrowDirection.Up));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStripItem_Rectangle_Color_ArrowDirection_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { graphics, null, Rectangle.Empty, Color.Empty, (ArrowDirection)(ArrowDirection.Down + 1) };
-        yield return new object[] { graphics, new ToolStripButton(), new Rectangle(1, 2, 3, 4), Color.Blue, ArrowDirection.Down };
-        yield return new object[] { graphics, new ToolStripButton(), new Rectangle(-1, -2, -3, -4), Color.Blue, ArrowDirection.Down };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStripItem_Rectangle_Color_ArrowDirection_TestData))]
-    public void Ctor_Graphics_ToolStripItem_Rectangle_Color_ArrowDirection(Graphics g, ToolStripItem toolStripItem, Rectangle arrowRectangle, Color arrowColor, ArrowDirection arrowDirection)
-    {
-        var e = new ToolStripArrowRenderEventArgs(g, toolStripItem, arrowRectangle, arrowColor, arrowDirection);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(arrowRectangle, e.ArrowRectangle);
-        Assert.Equal(toolStripItem, e.Item);
-        Assert.Equal(arrowColor, e.ArrowColor);
-        Assert.Equal(arrowDirection, e.Direction);
-    }
-
-    public static IEnumerable<object[]> ArrowRectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, -3, -4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ArrowRectangle_TestData))]
-    public void ArrowRectangle_Set_GetReturnsExpected(Rectangle value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var button = new ToolStripButton();
-            var e = new ToolStripArrowRenderEventArgs(graphics, button, new Rectangle(1, 2, 3, 4), Color.Blue, ArrowDirection.Down)
-            {
-                ArrowRectangle = value
-            };
-            Assert.Equal(value, e.ArrowRectangle);
-        }
-    }
-
-    public static IEnumerable<object[]> ArrowColor_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ArrowColor_TestData))]
-    public void ArrowColor_Set_GetReturnsExpected(Color value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var button = new ToolStripButton();
-            var e = new ToolStripArrowRenderEventArgs(graphics, button, new Rectangle(1, 2, 3, 4), Color.Blue, ArrowDirection.Down)
-            {
-                ArrowColor = value
-            };
-            Assert.Equal(value, e.ArrowColor);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((ArrowDirection)(ArrowDirection.Down + 1))]
-    [InlineData(ArrowDirection.Up)]
-    public void Direction_Set_GetReturnsExpected(ArrowDirection value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var button = new ToolStripButton();
-            var e = new ToolStripArrowRenderEventArgs(graphics, button, new Rectangle(1, 2, 3, 4), Color.Blue, ArrowDirection.Down)
-            {
-                Direction = value
-            };
-            Assert.Equal(value, e.Direction);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButton.ToolStripButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButton.ToolStripButtonAccessibleObjectTests.cs
deleted file mode 100644
index 6efc5e6cec9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButton.ToolStripButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripButton;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripButton_ToolStripButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Ctor_Default()
-    {
-        using ToolStripButton toolStripButton = new();
-        ToolStripButtonAccessibleObject accessibleObject = new(toolStripButton);
-
-        Assert.Equal(toolStripButton, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripButton toolStripButton = new();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Role_IsPushButton_ByDefault()
-    {
-        using ToolStripButton toolStripButton = new();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.PushButton, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Role_IsCheckButton_IfCheckOnClick()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            CheckOnClick = true
-        };
-
-        AccessibleRole actual = toolStripButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.CheckButton, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Role_IsCheckButton_IfChecked()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            Checked = true
-        };
-
-        AccessibleRole actual = toolStripButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.CheckButton, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripButton toolStripButton = new();
-        toolStripButton.AccessibleRole = role;
-
-        object actual = toolStripButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsCheckBox_IfCheckOnClick()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            CheckOnClick = true
-        };
-
-        object actual = toolStripButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = UiaCore.UIA.CheckBoxControlTypeId;
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_GetPropertyValue_ControlType_IsCheckBox_IfChecked()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            Checked = true
-        };
-
-        object actual = toolStripButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = UiaCore.UIA.CheckBoxControlTypeId;
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, true)]
-    [InlineData(true, CheckState.Unchecked, true)]
-    [InlineData(true, CheckState.Indeterminate, true)]
-    [InlineData(false, CheckState.Checked, true)]
-    [InlineData(false, CheckState.Unchecked, false)]
-    [InlineData(false, CheckState.Indeterminate, true)]
-    public void ToolStripButtonAccessibleObject_IsTogglePatternSupported_ReturnsExpected(bool checkOnClick, CheckState checkState, bool expected)
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            CheckOnClick = checkOnClick,
-            CheckState = checkState
-        };
-
-        object actual = toolStripButton.AccessibilityObject.IsPatternSupported(UiaCore.UIA.TogglePatternId);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_IsTogglePatternSupported_ReturnsTrue_IfAccessibleRoleIsCheckButton()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            AccessibleRole = AccessibleRole.CheckButton
-        };
-
-        object actual = toolStripButton.AccessibilityObject.IsPatternSupported(UiaCore.UIA.TogglePatternId);
-
-        Assert.Equal(true, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(CheckState.Checked, (int)UiaCore.ToggleState.On)]
-    [InlineData(CheckState.Unchecked, (int)UiaCore.ToggleState.Off)]
-    [InlineData(CheckState.Indeterminate, (int)UiaCore.ToggleState.Indeterminate)]
-    public void ToolStripButtonAccessibleObject_ToggleState_ReturnsExpected(CheckState checkState, int expectedToggleState)
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            CheckState = checkState
-        };
-
-        object actual = toolStripButton.AccessibilityObject.ToggleState;
-
-        Assert.Equal((UiaCore.ToggleState)expectedToggleState, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Toggle_Invoke()
-    {
-        using ToolStripButton toolStripButton = new()
-        {
-            CheckOnClick = true
-        };
-
-        int clickCounter = 0;
-
-        toolStripButton.Click += (s, e) => { clickCounter++; };
-
-        Assert.Equal(UiaCore.ToggleState.Off, toolStripButton.AccessibilityObject.ToggleState);
-
-        toolStripButton.AccessibilityObject.Toggle();
-
-        Assert.Equal(UiaCore.ToggleState.On, toolStripButton.AccessibilityObject.ToggleState);
-
-        toolStripButton.AccessibilityObject.Toggle();
-
-        Assert.Equal(UiaCore.ToggleState.Off, toolStripButton.AccessibilityObject.ToggleState);
-
-        Assert.Equal(0, clickCounter);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButtonAccessibleObject_Toggle_DoesNotChangeChecked_IfTogglePatternNotSupported()
-    {
-        using ToolStripButton toolStripButton = new();
-
-        Assert.False(toolStripButton.AccessibilityObject.IsPatternSupported(UiaCore.UIA.TogglePatternId));
-        Assert.False(toolStripButton.Checked);
-
-        toolStripButton.AccessibilityObject.Toggle();
-
-        Assert.False(toolStripButton.Checked);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.Rendering.cs
deleted file mode 100644
index a0364dfa862..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.Rendering.cs
+++ /dev/null
@@ -1,173 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ToolStripButtonTests
-{
-    [WinFormsFact]
-    public void ToolStripButton_RendersTextCorrectly()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        using ToolStripButton toolStripButton = new()
-        {
-            Text = "Hello"
-        };
-        toolStrip.Items.Add(toolStripButton);
-        form.Controls.Add(toolStrip);
-
-        using EmfScope emf = new();
-
-        DeviceContextState state = new(emf);
-
-        Rectangle bounds = toolStripButton.Bounds;
-
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-            state,
-             Validate.TextOut("Hello"));
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_RendersBackgroundCorrectly()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        using ToolStripButton toolStripButton = new()
-        {
-            BackColor = Color.Blue,
-        };
-        toolStrip.Items.Add(toolStripButton);
-        form.Controls.Add(toolStrip);
-
-        using EmfScope emf = new();
-        DeviceContextState state = new(emf);
-        Rectangle bounds = toolStripButton.Bounds;
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-           state,
-           Validate.Polygon16(
-                bounds: null,
-                points: null,
-                State.Brush(Color.Blue, BRUSH_STYLE.BS_SOLID)));
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_Selected_RendersBackgroundCorrectly_HighContrast()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        toolStrip.Renderer = new ToolStripSystemHighContrastRenderer();
-        using ToolStripButton toolStripButton = new();
-        toolStrip.Items.Add(toolStripButton);
-        form.Controls.Add(toolStrip);
-        toolStripButton.Select();
-
-        using EmfScope emf = new();
-        DeviceContextState state = new(emf);
-        Rectangle bounds = toolStripButton.Bounds;
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-           state,
-           Validate.Polygon16(
-                bounds: null,
-                points: null,
-                State.Brush(SystemColors.Highlight, BRUSH_STYLE.BS_SOLID)),
-           Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16), 2));
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_Indeterminate_RendersBackgroundCorrectly_HighContrast()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        toolStrip.Renderer = new ToolStripSystemHighContrastRenderer();
-        using ToolStripButton toolStripButton = new();
-        toolStrip.Items.Add(toolStripButton);
-        form.Controls.Add(toolStrip);
-        toolStripButton.CheckState = CheckState.Indeterminate;
-
-        using EmfScope emf = new();
-        DeviceContextState state = new(emf);
-        Rectangle bounds = toolStripButton.Bounds;
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-           state,
-           Validate.Polygon16(
-                bounds: null,
-                points: null,
-                State.Brush(SystemColors.Highlight, BRUSH_STYLE.BS_SOLID)),
-           Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16));
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_DropDownButton_Selected_RendersBackgroundCorrectly_HighContrast()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        toolStrip.Renderer = new ToolStripSystemHighContrastRenderer();
-        using ToolStripDropDownButton toolStripDropDownButton = new();
-        toolStrip.Items.Add(toolStripDropDownButton);
-        form.Controls.Add(toolStrip);
-        toolStripDropDownButton.Select();
-
-        using EmfScope emf = new();
-        DeviceContextState state = new(emf);
-        Rectangle bounds = toolStripDropDownButton.Bounds;
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripDropDownButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-           state,
-           Validate.Polygon16(
-                bounds: null,
-                points: null,
-                State.Brush(SystemColors.Highlight, BRUSH_STYLE.BS_SOLID)),
-           Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16), 2),
-           Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16), 1));
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_SplitButton_Selected_RendersBackgroundCorrectly_HighContrast()
-    {
-        using Form form = new();
-        using ToolStrip toolStrip = new();
-        toolStrip.Renderer = new ToolStripSystemHighContrastRenderer();
-        using ToolStripSplitButton toolStripDropDownButton = new();
-        toolStrip.Items.Add(toolStripDropDownButton);
-        form.Controls.Add(toolStrip);
-        toolStripDropDownButton.Select();
-
-        using EmfScope emf = new();
-        DeviceContextState state = new(emf);
-        Rectangle bounds = toolStripDropDownButton.Bounds;
-        using PaintEventArgs e = new(emf, bounds);
-        toolStripDropDownButton.TestAccessor().Dynamic.OnPaint(e);
-
-        emf.Validate(
-           state,
-           Validate.Polygon16(
-                bounds: null,
-                points: null,
-                State.Brush(SystemColors.Highlight, BRUSH_STYLE.BS_SOLID)),
-           Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYPOLYGON16), 2),
-           Validate.Repeat(Validate.SkipType(ENHANCED_METAFILE_RECORD_TYPE.EMR_POLYGON16), 2));
-    }
-
-    private class ToolStripSystemHighContrastRenderer : ToolStripSystemRenderer
-    {
-        internal override ToolStripRenderer RendererOverride => HighContrastRenderer;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.cs
deleted file mode 100644
index 0dd551f2b04..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripButtonTests.cs
+++ /dev/null
@@ -1,1758 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.DataBinding.TestUtilities;
-using System.Windows.Forms.TestUtilities;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ToolStripButtonTests
-{
-    [WinFormsFact]
-    public void ToolStripButton_Ctor_Default()
-    {
-        using var item = new SubToolStripButton();
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Empty(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripButton_Ctor_String(string text)
-    {
-        using var item = new SubToolStripButton(text);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Equal(text, item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_Image_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Image_TestData))]
-    public void ToolStripButton_Ctor_Image(Image image)
-    {
-        using var item = new SubToolStripButton(image);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Same(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Null(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_TestData()
-    {
-        foreach (string text in new string[] { null, string.Empty, "text" })
-        {
-            yield return new object[] { text, null };
-            yield return new object[] { text, new Bitmap(10, 10) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_TestData))]
-    public void ToolStripButton_Ctor_String_Image(string text, Image image)
-    {
-        using var item = new SubToolStripButton(text, image);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Same(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Equal(text, item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_TestData))]
-    public void ToolStripButton_Ctor_String_Image_EventHandler(string text, Image image, EventHandler onClick)
-    {
-        using var item = new SubToolStripButton(text, image, onClick);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Equal(text, item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_Ctor_String_Image_EventHandler_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new ToolStripButton("text", null, onClick);
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_String_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null, null, string.Empty };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick, string.Empty, string.Empty };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick, "name", "name" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_String_TestData))]
-    public void ToolStripButton_Ctor_String_Image_EventHandler_String(string text, Image image, EventHandler onClick, string name, string expectedName)
-    {
-        using var item = new SubToolStripButton(text, image, onClick, name);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.True(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.True(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Equal(expectedName, item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Equal(text, item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_Ctor_String_Image_EventHandler_String_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new ToolStripButton("text", null, onClick, "name");
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripButton_AutoToolTip_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new ToolStripButton
-        {
-            AutoToolTip = value
-        };
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set same.
-        item.AutoToolTip = value;
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set different.
-        item.AutoToolTip = !value;
-        Assert.Equal(!value, item.AutoToolTip);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_BasicCommandBinding()
-    {
-        const string CommandParameter = nameof(CommandParameter);
-
-        using SubToolStripButton button = new();
-
-        // TestCommandExecutionAbility is controlling the execution context.
-        CommandViewModel viewModel = new() { TestCommandExecutionAbility = true };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(button, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        button.CommandChanged += handler;
-        button.Command = viewModel.TestCommand;
-        Assert.Equal(1, callCount);
-
-        button.CommandParameterChanged += handler;
-        button.CommandParameter = CommandParameter;
-        Assert.Equal(2, callCount);
-
-        Assert.Same(viewModel.TestCommand, button.Command);
-        Assert.True(button.Enabled);
-
-        // OnClick is invoking the command in the ViewModel.
-        // The CommandParameter should make its way into the viewmodel's CommandExecuteResult property.
-        button.OnClick(EventArgs.Empty);
-        Assert.Same(CommandParameter, viewModel.CommandExecuteResult);
-
-        // We're changing the execution context.
-        // The ViewModel calls RaiseCanExecuteChanged, which the Button should handle.
-        viewModel.TestCommandExecutionAbility = false;
-        Assert.False(button.Enabled);
-
-        // Remove handler.
-        button.CommandChanged -= handler;
-        button.Command = null;
-        Assert.Equal(2, callCount);
-
-        button.CommandParameterChanged -= handler;
-        button.CommandParameter = null;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripButton_CheckOnClick_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new ToolStripButton
-        {
-            CheckOnClick = value
-        };
-        Assert.Equal(value, item.CheckOnClick);
-
-        // Set same.
-        item.CheckOnClick = value;
-        Assert.Equal(value, item.CheckOnClick);
-
-        // Set different.
-        item.CheckOnClick = !value;
-        Assert.Equal(!value, item.CheckOnClick);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Unchecked, CheckState.Checked)]
-    public void ToolStripButton_Checked_Set_GetReturnsExpected(bool value, CheckState expectedCheckState1, CheckState expectedCheckState2)
-    {
-        using var item = new ToolStripButton
-        {
-            Checked = value
-        };
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-
-        // Set same.
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-
-        // Set different.
-        item.Checked = !value;
-        Assert.Equal(!value, item.Checked);
-        Assert.Equal(expectedCheckState2, item.CheckState);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Unchecked, CheckState.Checked)]
-    public void ToolStripButton_Checked_SetWithOwner_GetReturnsExpected(bool value, CheckState expectedCheckState1, CheckState expectedCheckState2)
-    {
-        using var owner = new ToolStrip();
-        using var item = new ToolStripButton
-        {
-            Owner = owner,
-            Checked = value
-        };
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Checked = !value;
-        Assert.Equal(!value, item.Checked);
-        Assert.Equal(expectedCheckState2, item.CheckState);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Unchecked, CheckState.Checked)]
-    public void ToolStripButton_Checked_SetWithOwnerWithHandle_GetReturnsExpected(bool value, CheckState expectedCheckState1, CheckState expectedCheckState2)
-    {
-        using var owner = new ToolStrip();
-        using var item = new ToolStripButton
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Checked = !value;
-        Assert.Equal(!value, item.Checked);
-        Assert.Equal(expectedCheckState2, item.CheckState);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, CheckState.Unchecked)]
-    [InlineData(false, CheckState.Unchecked, CheckState.Checked)]
-    public void ToolStripButton_Checked_SetWithParent_GetReturnsExpected(bool value, CheckState expectedCheckState1, CheckState expectedCheckState2)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent,
-            Checked = value
-        };
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Checked = !value;
-        Assert.Equal(!value, item.Checked);
-        Assert.Equal(expectedCheckState2, item.CheckState);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, CheckState.Checked, CheckState.Unchecked)]
-    [InlineData(false, 0, CheckState.Unchecked, CheckState.Checked)]
-    public void ToolStripButton_Checked_SetWithParentWithHandle_GetReturnsExpected(bool value, int expectedInvalidatedCallCount, CheckState expectedCheckState1, CheckState expectedCheckState2)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Checked = value;
-        Assert.Equal(value, item.Checked);
-        Assert.Equal(expectedCheckState1, item.CheckState);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Checked = !value;
-        Assert.Equal(!value, item.Checked);
-        Assert.Equal(expectedCheckState2, item.CheckState);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_Checked_SetWithHandler_CallsCheckedChanged()
-    {
-        using var item = new ToolStripButton
-        {
-            Checked = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.CheckedChanged += handler;
-        int checkStateCallCount = 0;
-        EventHandler checkStateHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            checkStateCallCount++;
-        };
-        item.CheckStateChanged += checkStateHandler;
-
-        // Set different.
-        item.Checked = false;
-        Assert.False(item.Checked);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, checkStateCallCount);
-
-        // Set same.
-        item.Checked = false;
-        Assert.False(item.Checked);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, checkStateCallCount);
-
-        // Set different.
-        item.Checked = true;
-        Assert.True(item.Checked);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, checkStateCallCount);
-
-        // Remove handler.
-        item.CheckedChanged -= handler;
-        item.Checked = false;
-        Assert.False(item.Checked);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, checkStateCallCount);
-
-        // Remove other handler.
-        item.CheckStateChanged -= checkStateHandler;
-        item.Checked = true;
-        Assert.True(item.Checked);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, checkStateCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<CheckState>]
-    public void ToolStripButton_CheckState_Set_GetReturnsExpected(CheckState value)
-    {
-        using var item = new ToolStripButton
-        {
-            CheckState = value
-        };
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-
-        // Set same.
-        item.CheckState = value;
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-    }
-
-    [WinFormsTheory]
-    [EnumData<CheckState>]
-    public void ToolStripButton_CheckState_SetWithOwner_GetReturnsExpected(CheckState value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new ToolStripButton
-        {
-            Owner = owner,
-            CheckState = value
-        };
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.CheckState = value;
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<CheckState>]
-    public void ToolStripButton_CheckState_SetWithOwnerWithHandle_GetReturnsExpected(CheckState value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new ToolStripButton
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.CheckState = value;
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.CheckState = value;
-        Assert.Equal(value, item.CheckState);
-        Assert.Equal(value != CheckState.Unchecked, item.Checked);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_CheckState_SetWithHandler_CallsCheckedChanged()
-    {
-        using var item = new ToolStripButton
-        {
-            CheckState = CheckState.Checked
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.CheckedChanged += handler;
-        int checkStateCallCount = 0;
-        EventHandler checkStateHandler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            checkStateCallCount++;
-        };
-        item.CheckStateChanged += checkStateHandler;
-
-        // Set different.
-        item.CheckState = CheckState.Unchecked;
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, checkStateCallCount);
-
-        // Set same.
-        item.CheckState = CheckState.Unchecked;
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, checkStateCallCount);
-
-        // Set different.
-        item.CheckState = CheckState.Indeterminate;
-        Assert.Equal(CheckState.Indeterminate, item.CheckState);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, checkStateCallCount);
-
-        // Remove handler.
-        item.CheckedChanged -= handler;
-        item.CheckState = CheckState.Unchecked;
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, checkStateCallCount);
-
-        // Remove other handler.
-        item.CheckStateChanged -= checkStateHandler;
-        item.CheckState = CheckState.Indeterminate;
-        Assert.Equal(CheckState.Indeterminate, item.CheckState);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, checkStateCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<CheckState>]
-    public void ToolStripButton_CheckState_SetInvalidValue_ThrowsInvalidEnumArgumentException(CheckState value)
-    {
-        using var item = new ToolStripButton();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.CheckState = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var item = new SubToolStripButton();
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.PushButton, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var item = new SubToolStripButton
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.HelpBalloon, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_CreateAccessibilityInstance_InvokeCheckOnClick_ReturnsExpected()
-    {
-        using var item = new SubToolStripButton
-        {
-            CheckOnClick = true
-        };
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.CheckButton, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, AccessibleStates.Focusable | AccessibleStates.Checked)]
-    [InlineData(true, CheckState.Indeterminate, AccessibleStates.Focusable | AccessibleStates.Checked)]
-    [InlineData(false, CheckState.Checked, AccessibleStates.None)]
-    [InlineData(false, CheckState.Indeterminate, AccessibleStates.None)]
-    public void ToolStripButton_CreateAccessibilityInstance_InvokeChecked_ReturnsExpected(bool enabled, CheckState checkState, AccessibleStates expectedState)
-    {
-        using var item = new SubToolStripButton
-        {
-            Enabled = enabled,
-            CheckState = checkState
-        };
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.CheckButton, accessibleObject.Role);
-        Assert.Equal(expectedState, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleStates.Focused | AccessibleStates.HotTracked | AccessibleStates.Focusable)]
-    [InlineData(false, AccessibleStates.None)]
-    public void ToolStripButton_CreateAccessibilityInstance_InvokeSelected_ReturnsExpected(bool enabled, AccessibleStates expectedState)
-    {
-        using var item = new SubToolStripButton
-        {
-            Enabled = enabled
-        };
-        item.Select();
-        Assert.Equal(item.CanSelect, item.Selected);
-
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.PushButton, accessibleObject.Role);
-        Assert.Equal(expectedState, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripButton_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var item = new ToolStripButton();
-        Assert.Equal(new Size(23, 4), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(23, 4), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripButton_OnCheckedChanged_Invoke_CallsCheckedChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.CheckedChanged += handler;
-        item.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.CheckedChanged -= handler;
-        item.OnCheckedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripButton_OnCheckStateChanged_Invoke_CallsCheckStateChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.CheckStateChanged += handler;
-        item.OnCheckStateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.CheckStateChanged -= handler;
-        item.OnCheckStateChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripButton_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripButton();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(item.Checked);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(item.Checked);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripButton_OnClick_InvokeCheckOnClick_CallsClick(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripButton
-        {
-            CheckOnClick = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(item.Checked);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(item.Checked);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripButton_OnPaint_Invoke_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        using var item = new SubToolStripButton();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_TestData()
-    {
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.No, ToolStripItemDisplayStyle.None, 0, 0, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.No, ToolStripItemDisplayStyle.Image, 1, 0, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.No, ToolStripItemDisplayStyle.ImageAndText, 1, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-
-        yield return new object[] { ContentAlignment.TopLeft, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Top | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.TopLeft, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.TopLeft, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.TopCenter, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Top | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.TopCenter, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.TopCenter, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.TopRight, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Top | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.TopRight, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.TopRight, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-
-        yield return new object[] { ContentAlignment.MiddleLeft, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.MiddleLeft, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleLeft, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleCenter, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleRight, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.MiddleRight, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.MiddleRight, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-
-        yield return new object[] { ContentAlignment.BottomLeft, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.BottomLeft, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.BottomLeft, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Left | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.BottomCenter, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.BottomCenter, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.BottomCenter, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.HorizontalCenter | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.BottomRight, RightToLeft.Yes, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix | TextFormatFlags.RightToLeft };
-        yield return new object[] { ContentAlignment.BottomRight, RightToLeft.Inherit, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-        yield return new object[] { ContentAlignment.BottomRight, RightToLeft.No, ToolStripItemDisplayStyle.Text, 0, 1, TextFormatFlags.Right | TextFormatFlags.Bottom | TextFormatFlags.HidePrefix };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void ToolStripButton_OnPaint_InvokeWithOwner_DoesNotCallPaint(ContentAlignment textAlign, RightToLeft rightToLeft, ToolStripItemDisplayStyle displayStyle, int expectedRenderItemImageCallCount, int expectedRenderItemTextCallCount, TextFormatFlags expectedTextFormat)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        var renderer = new SubToolStripRenderer();
-        using var owner = new ToolStrip
-        {
-            Renderer = renderer
-        };
-        using var font = new Font("Arial", 8.25f);
-        using var item = new SubToolStripButton
-        {
-            DisplayStyle = displayStyle,
-            Font = font,
-            ForeColor = Color.Red,
-            RightToLeft = rightToLeft,
-            Text = "Text",
-            TextAlign = textAlign,
-            TextDirection = ToolStripTextDirection.Vertical270,
-            Owner = owner
-        };
-
-        int renderButtonBackgroundCallCount = 0;
-        renderer.RenderButtonBackground += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            renderButtonBackgroundCallCount++;
-        };
-        int renderItemImageCallCount = 0;
-        renderer.RenderItemImage += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            Assert.True(e.ImageRectangle.X >= 0);
-            Assert.True(e.ImageRectangle.Y >= 0);
-            Assert.Equal(0, e.ImageRectangle.Width);
-            Assert.Equal(0, e.ImageRectangle.Height);
-            renderItemImageCallCount++;
-        };
-        int renderItemTextCallCount = 0;
-        renderer.RenderItemText += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            Assert.Equal("Text", e.Text);
-            Assert.Equal(Color.Red, e.TextColor);
-            Assert.Equal(ToolStripTextDirection.Vertical270, e.TextDirection);
-            Assert.Same(font, e.TextFont);
-            Assert.Equal(expectedTextFormat, e.TextFormat);
-            Assert.True(e.TextRectangle.X >= 0);
-            Assert.True(e.TextRectangle.Y >= 0);
-            Assert.True(e.TextRectangle.Width >= 0);
-            Assert.True(e.TextRectangle.Height >= 0);
-            renderItemTextCallCount++;
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, renderButtonBackgroundCallCount);
-        Assert.Equal(expectedRenderItemImageCallCount, renderItemImageCallCount);
-        Assert.Equal(expectedRenderItemTextCallCount, renderItemTextCallCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, renderButtonBackgroundCallCount);
-        Assert.Equal(expectedRenderItemImageCallCount * 2, renderItemImageCallCount);
-        Assert.Equal(expectedRenderItemTextCallCount * 2, renderItemTextCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void ToolStripButton_OnPaint_InvokeWithOwnerCantShowKeyboardCues_DoesNotCallPaint(ContentAlignment textAlign, RightToLeft rightToLeft, ToolStripItemDisplayStyle displayStyle, int expectedRenderItemImageCallCount, int expectedRenderItemTextCallCount, TextFormatFlags expectedTextFormat)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        var renderer = new SubToolStripRenderer();
-        using var owner = new ToolStrip
-        {
-            Renderer = renderer
-        };
-        using var font = new Font("Arial", 8.25f);
-        using var item = new CantShowKeyboardCuesToolStripButton
-        {
-            DisplayStyle = displayStyle,
-            Font = font,
-            ForeColor = Color.Red,
-            RightToLeft = rightToLeft,
-            Text = "Text",
-            TextAlign = textAlign,
-            TextDirection = ToolStripTextDirection.Vertical270,
-            Owner = owner
-        };
-
-        int renderButtonBackgroundCallCount = 0;
-        renderer.RenderButtonBackground += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            renderButtonBackgroundCallCount++;
-        };
-        int renderItemImageCallCount = 0;
-        renderer.RenderItemImage += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            Assert.True(e.ImageRectangle.X >= 0);
-            Assert.True(e.ImageRectangle.Y >= 0);
-            Assert.Equal(0, e.ImageRectangle.Width);
-            Assert.Equal(0, e.ImageRectangle.Height);
-            renderItemImageCallCount++;
-        };
-        int renderItemTextCallCount = 0;
-        renderer.RenderItemText += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Null(e.ToolStrip);
-            Assert.Equal("Text", e.Text);
-            Assert.Equal(Color.Red, e.TextColor);
-            Assert.Equal(ToolStripTextDirection.Vertical270, e.TextDirection);
-            Assert.Same(font, e.TextFont);
-            Assert.Equal(expectedTextFormat, e.TextFormat);
-            Assert.True(e.TextRectangle.X >= 0);
-            Assert.True(e.TextRectangle.Y >= 0);
-            Assert.True(e.TextRectangle.Width >= 0);
-            Assert.True(e.TextRectangle.Height >= 0);
-            renderItemTextCallCount++;
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, renderButtonBackgroundCallCount);
-        Assert.Equal(expectedRenderItemImageCallCount, renderItemImageCallCount);
-        Assert.Equal(expectedRenderItemTextCallCount, renderItemTextCallCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, renderButtonBackgroundCallCount);
-        Assert.Equal(expectedRenderItemImageCallCount * 2, renderItemImageCallCount);
-        Assert.Equal(expectedRenderItemTextCallCount * 2, renderItemTextCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_WithParent_TestData()
-    {
-        foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-
-            var image = new Bitmap(10, 10);
-            Graphics graphics = Graphics.FromImage(image);
-            yield return new object[] { displayStyle, new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4)) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_WithParent_TestData))]
-    public void ToolStripButton_OnPaint_InvokeWithParent_DoesNotCallPaint(ToolStripItemDisplayStyle displayStyle, PaintEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        using var parent = new ToolStrip
-        {
-            Renderer = renderer
-        };
-        using var font = new Font("Arial", 8.25f);
-        using var item = new SubToolStripButton
-        {
-            DisplayStyle = displayStyle,
-            Font = font,
-            ForeColor = Color.Red,
-            Text = "Text",
-            TextDirection = ToolStripTextDirection.Vertical270,
-            Parent = parent
-        };
-
-        int renderButtonBackgroundCallCount = 0;
-        renderer.RenderButtonBackground += (sender, e) => renderButtonBackgroundCallCount++;
-        int renderItemImageCallCount = 0;
-        renderer.RenderItemImage += (sender, e) => renderItemImageCallCount++;
-        int renderItemTextCallCount = 0;
-        renderer.RenderItemText += (sender, e) => renderItemTextCallCount++;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderButtonBackgroundCallCount);
-        Assert.Equal(0, renderItemImageCallCount);
-        Assert.Equal(0, renderItemTextCallCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderButtonBackgroundCallCount);
-        Assert.Equal(0, renderItemImageCallCount);
-        Assert.Equal(0, renderItemTextCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripButton_OnPaint_NullE_ThrowsNullReferenceException()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripButton
-        {
-            Owner = owner
-        };
-        Assert.Throws<NullReferenceException>(() => item.OnPaint(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_EnterKey_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var item = new SubToolStripButton
-        {
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_EnterKeyWithParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_EnterKeyWithDropDownParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        var parent = new ToolStripDropDown();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_SpaceKey_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var item = new SubToolStripButton
-        {
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_SpaceKeyWithParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        var parent = new ToolStripDropDown();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripButton_ProcessDialogKey_SpaceKeyWithDropDownParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        var parent = new ToolStripDropDown();
-        using var item = new SubToolStripButton
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.None)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripButton_ProcessDialogKey_UnknownKey_ReturnsFalse(Keys keyData)
-    {
-        using var item = new SubToolStripButton();
-        int callCount = 0;
-        item.Click += (sender, e) => callCount++;
-        Assert.False(item.ProcessDialogKey(keyData));
-        Assert.Equal(0, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    private class CantShowKeyboardCuesToolStripButton : ToolStripButton
-    {
-        protected internal override bool ShowKeyboardCues => false;
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-    }
-
-    private class SubToolStripButton : ToolStripButton
-    {
-        public SubToolStripButton() : base()
-        {
-        }
-
-        public SubToolStripButton(string text) : base(text)
-        {
-        }
-
-        public SubToolStripButton(Image image) : base(image)
-        {
-        }
-
-        public SubToolStripButton(string text, Image image) : base(text, image)
-        {
-        }
-
-        public SubToolStripButton(string text, Image image, EventHandler onClick) : base(text, image, onClick)
-        {
-        }
-
-        public SubToolStripButton(string text, Image image, EventHandler onClick, string name) : base(text, image, onClick, name)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void OnCheckedChanged(EventArgs e) => base.OnCheckedChanged(e);
-
-        public new void OnCheckStateChanged(EventArgs e) => base.OnCheckStateChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxAccessibleObjectTests.cs
deleted file mode 100644
index fd26b4aee48..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripComboBox_ToolStripComboBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripComboBoxAccessibleObject_ReleaseUiaProvider_ToolStripComboBoxControl()
-    {
-        using var toolStrip = new ToolStrip();
-        using var toolStripComboBox = new ToolStripComboBox();
-        toolStrip.Items.Add(toolStripComboBox);
-        toolStripComboBox.Parent = toolStrip;
-        toolStrip.CreateControl();
-
-        _ = toolStripComboBox.AccessibilityObject;
-        _ = toolStripComboBox.Control.AccessibilityObject;
-
-        Assert.True(toolStripComboBox.Control.IsAccessibilityObjectCreated);
-
-        toolStripComboBox.ReleaseUiaProvider();
-
-        Assert.False(toolStripComboBox.Control.IsAccessibilityObjectCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxControl.ToolStripComboBoxControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxControl.ToolStripComboBoxControlAccessibleObjectTests.cs
deleted file mode 100644
index 3973c63e8ec..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripComboBox.ToolStripComboBoxControl.ToolStripComboBoxControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripComboBox;
-using static System.Windows.Forms.ToolStripComboBox.ToolStripComboBoxControl;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripComboBox_ToolStripComboBoxControl_ToolStripComboBoxControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripComboBoxControlAccessibleObject_ctor_default()
-    {
-        using ToolStripComboBox toolStripComboBox = new ToolStripComboBox();
-        ToolStripComboBoxControl control = (ToolStripComboBoxControl)toolStripComboBox.ComboBox;
-        control.CreateControl();
-        ToolStripComboBoxControlAccessibleObject accessibleObject = new ToolStripComboBoxControlAccessibleObject(control);
-
-        Assert.Equal(control, accessibleObject.Owner);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripComboBoxControlAccessibleObject_ControlType_IsComboBox_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripComboBox toolStripComboBox = new ToolStripComboBox();
-        // AccessibleRole is not set = Default
-        ToolStripComboBoxControl control = (ToolStripComboBoxControl)toolStripComboBox.ComboBox;
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = toolStripComboBox.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(AccessibleRole.ComboBox, accessibleObject.Role);
-        Assert.Equal(UiaCore.UIA.ComboBoxControlTypeId, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripComboBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripComboBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripComboBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripComboBox toolStripComboBox = new ToolStripComboBox();
-        toolStripComboBox.AccessibleRole = role;
-        ToolStripComboBoxControl control = (ToolStripComboBoxControl)toolStripComboBox.ComboBox;
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = toolStripComboBox.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(role, accessibleObject.Role);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripComboBoxControlAccessibleObject_FragmentNavigate_ChildrenAreExpected()
-    {
-        using ToolStripComboBoxControl control = new();
-        control.CreateControl();
-
-        object firstChild = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild);
-        object lastChild = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild);
-
-        Assert.Equal(control.ChildEditAccessibleObject, firstChild);
-        Assert.Equal(((ToolStripComboBoxControlAccessibleObject)control.AccessibilityObject).DropDownButtonUiaProvider, lastChild);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripComboBoxControlAccessibleObject_FragmentNavigate_ParentIsToolStrip()
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStripComboBoxControl control = new();
-        using ToolStripComboBox item = new();
-        using ToolStrip toolStrip = new();
-        control.Owner = item;
-        item.Parent = toolStrip;
-
-        object actual = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(toolStrip.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContainer.ToolStripContainerAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContainer.ToolStripContainerAccessibleObjectTests.cs
deleted file mode 100644
index 7bd4560df96..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContainer.ToolStripContainerAccessibleObjectTests.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripContainer_ToolStripContainerAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripContainerAccessibleObject_Ctor_Default()
-    {
-        using ToolStripContainer toolStripContainer = new();
-        ToolStripContainer.ToolStripContainerAccessibleObject accessibleObject = new(toolStripContainer);
-
-        Assert.Equal(toolStripContainer, accessibleObject.Owner);
-        Assert.False(toolStripContainer.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "ToolStripContainer1")]
-    public void ToolStripContainerAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using var control = new ToolStripContainer
-        {
-            Name = "ToolStripContainer1",
-            AccessibleName = "TestName"
-        };
-
-        var accessibleObject = new ToolStripContainer.ToolStripContainerAccessibleObject(control);
-        object value = accessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContainerAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsTrue_IfControlHasFocus()
-    {
-        using var control = new ToolStripContainer();
-
-        var accessibleObject = new ToolStripContainer.ToolStripContainerAccessibleObject(control);
-        Assert.False(control.IsHandleCreated);
-        control.FocusActiveControlInternal();
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.True(value);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContainerAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsFalse_IfControlHasNoFocus()
-    {
-        using var control = new ToolStripContainer();
-
-        var accessibleObject = new ToolStripContainer.ToolStripContainerAccessibleObject(control);
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(value);
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelRenderEventArgsTests.cs
deleted file mode 100644
index 3b7526440f6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelRenderEventArgsTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripContentPanelRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStripContentPanel_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { graphics, null };
-        yield return new object[] { null, new ToolStripContentPanel() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStripContentPanel_TestData))]
-    public void ToolStripContentPanelRenderEventArgs_Null_Graphics_ToolStripContentPanel_ThrowsArgumentNullException(Graphics g, ToolStripContentPanel toolStripContentPanel)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripContentPanelRenderEventArgs(g, toolStripContentPanel));
-    }
-
-    [WinFormsFact]
-    public void Ctor_Graphics_ToolStripContentPanel()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var toolStripContentPanel = new ToolStripContentPanel();
-        var e = new ToolStripContentPanelRenderEventArgs(graphics, toolStripContentPanel);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(toolStripContentPanel, e.ToolStripContentPanel);
-        Assert.False(e.Handled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Handled_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var panel = new ToolStripContentPanel();
-            var e = new ToolStripContentPanelRenderEventArgs(graphics, panel)
-            {
-                Handled = value
-            };
-            Assert.Equal(value, e.Handled);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelTests.cs
deleted file mode 100644
index f009d6e564f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripContentPanelTests.cs
+++ /dev/null
@@ -1,2098 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using Moq.Protected;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripContentPanelTests
-{
-    [WinFormsFact]
-    public void ToolStripContentPanel_Ctor_SplitContainer()
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.None, control.BorderStyle);
-        Assert.Equal(100, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        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(200, 100), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(100, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(200, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(200, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.Anchor_Set_TestData), MemberType = typeof(ControlTests))]
-    public void ToolStripContentPanel_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Anchor = value
-        };
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void ToolStripContentPanel_AutoScroll_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubToolStripContentPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 2, 5)]
-    [InlineData(false, 1, 4)]
-    public void ToolStripContentPanel_AutoScroll_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2)
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoScroll", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.Equal(value, control.AutoScroll);
-        Assert.Equal(value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount1 * 2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.Equal(!value, control.AutoScroll);
-        Assert.Equal(!value, control.GetScrollState(SubToolStripContentPanel.ScrollStateAutoScrolling));
-        Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMargin_Set_TestData()
-    {
-        yield return new object[] { true, new Size(0, 0), 0 };
-        yield return new object[] { true, new Size(1, 0), 1 };
-        yield return new object[] { true, new Size(0, 1), 1 };
-        yield return new object[] { true, new Size(1, 2), 1 };
-        yield return new object[] { false, new Size(0, 0), 0 };
-        yield return new object[] { false, new Size(1, 0), 0 };
-        yield return new object[] { false, new Size(0, 1), 0 };
-        yield return new object[] { false, new Size(1, 2), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void ToolStripContentPanel_AutoScrollMargin_Set_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void ToolStripContentPanel_AutoScrollMargin_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.Equal(autoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMinSize_TestData()
-    {
-        yield return new object[] { true, new Size(-1, -2), true, 3 };
-        yield return new object[] { true, new Size(0, 0), true, 0 };
-        yield return new object[] { true, new Size(1, 0), true, 3 };
-        yield return new object[] { true, new Size(0, 1), true, 3 };
-        yield return new object[] { true, new Size(1, 2), true, 3 };
-
-        yield return new object[] { false, new Size(-1, -2), true, 3 };
-        yield return new object[] { false, new Size(0, 0), false, 0 };
-        yield return new object[] { false, new Size(1, 0), true, 3 };
-        yield return new object[] { false, new Size(0, 1), true, 3 };
-        yield return new object[] { false, new Size(1, 2), true, 3 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_TestData))]
-    public void ToolStripContentPanel_AutoScrollMinSize_Set_GetReturnsExpected(bool autoScroll, Size value, bool expectedAutoScroll, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_TestData))]
-    public void ToolStripContentPanel_AutoScrollMinSize_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value, bool expectedAutoScroll, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.Equal(expectedAutoScroll, control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void ToolStripContentPanel_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new ToolStripContentPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void ToolStripContentPanel_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new Control();
-        using var control = new ToolStripContentPanel
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void ToolStripContentPanel_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    [InvalidEnumData<AutoSizeMode>]
-    public void ToolStripContentPanel_AutoSizeMode_SetWithHandleWithParent_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var parent = new Control();
-        using var control = new ToolStripContentPanel
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(AutoSizeMode.GrowOnly, control.AutoSizeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, parentInvalidatedCallCount);
-        Assert.Equal(0, parentStyleChangedCallCount);
-        Assert.Equal(0, parentCreatedCallCount);
-        Assert.Equal(0, parentLayoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripContentPanel_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithParent_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Blue };
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Transparent, Color.Transparent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithParent_TestData))]
-    public void ToolStripContentPanel_BackColor_SetWithParent_GetReturnsExpected(Color value, Color expected)
-    {
-        using var parent = new Control
-        {
-            BackColor = Color.Blue
-        };
-        using var control = new ToolStripContentPanel
-        {
-            Parent = parent,
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(Color.Blue, parent.BackColor);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(Color.Blue, parent.BackColor);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithToolStripContainerParent_TestData()
-    {
-        yield return new object[] { Color.Empty, Color.Blue, Color.Blue };
-        yield return new object[] { Color.Red, Color.Red, Color.Blue };
-        yield return new object[] { Color.Transparent, Color.Transparent, Color.Transparent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithToolStripContainerParent_TestData))]
-    public void ToolStripContentPanel_BackColor_SetWithToolStripContainerParent_GetReturnsExpected(Color value, Color expected, Color expectedBackColor)
-    {
-        using var parent = new ToolStripContainer
-        {
-            BackColor = Color.Blue
-        };
-        ToolStripContentPanel control = parent.ContentPanel;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expectedBackColor, parent.BackColor);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        Assert.Equal(expected, control.BackColor);
-        Assert.Equal(expectedBackColor, parent.BackColor);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new ToolStripContentPanel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void ToolStripContentPanel_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void ToolStripContentPanel_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void ToolStripContentPanel_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_CausesValidation_SetWithHandler_CallsCausesValidationChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            CausesValidation = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CausesValidationChanged += handler;
-
-        // Set different.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.CausesValidation = true;
-        Assert.True(control.CausesValidation);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void ToolStripContentPanel_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Dock = value
-        };
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Dock = DockStyle.None
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void ToolStripContentPanel_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Dock = value);
-    }
-
-    public static IEnumerable<object[]> Location_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(-1, -2), 1 };
-        yield return new object[] { new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void ToolStripContentPanel_Location_Set_GetReturnsExpected(Point value, int expectedLocationChangedCallCount)
-    {
-        using var control = new ToolStripContentPanel();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(200, 100), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, 200, 100), control.DisplayRectangle);
-        Assert.Equal(new Size(200, 100), control.Size);
-        Assert.Equal(value.X, control.Left);
-        Assert.Equal(value.X + 200, control.Right);
-        Assert.Equal(value, control.Location);
-        Assert.Equal(value.Y, control.Top);
-        Assert.Equal(value.Y + 100, control.Bottom);
-        Assert.Equal(200, control.Width);
-        Assert.Equal(100, control.Height);
-        Assert.Equal(new Rectangle(value.X, value.Y, 200, 100), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Location_SetWithHandler_CallsLocationChanged()
-    {
-        using var control = new ToolStripContentPanel();
-        int locationChangedCallCount = 0;
-        EventHandler locationChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-        control.LocationChanged += locationChangedHandler;
-        int moveCallCount = 0;
-        EventHandler moveHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            moveCallCount++;
-        };
-        control.Move += moveHandler;
-
-        // Set different.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set same.
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(1, locationChangedCallCount);
-        Assert.Equal(1, moveCallCount);
-
-        // Set different x.
-        control.Location = new Point(2, 2);
-        Assert.Equal(new Point(2, 2), control.Location);
-        Assert.Equal(2, locationChangedCallCount);
-        Assert.Equal(2, moveCallCount);
-
-        // Set different y.
-        control.Location = new Point(2, 3);
-        Assert.Equal(new Point(2, 3), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-
-        // Remove handler.
-        control.LocationChanged -= locationChangedHandler;
-        control.Move -= moveHandler;
-        control.Location = new Point(1, 2);
-        Assert.Equal(new Point(1, 2), control.Location);
-        Assert.Equal(3, locationChangedCallCount);
-        Assert.Equal(3, moveCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MaximumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void ToolStripContentPanel_MaximumSize_Set_GetReturnsExpected(Size value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(value, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlTests.MinimumSize_Set_TestData), MemberType = typeof(ControlTests))]
-    public void ToolStripContentPanel_MinimumSize_Set_GetReturnsExpected(Size value, Size expectedSize, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Size = Size.Empty
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(value, control.MinimumSize);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripContentPanel_Name_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Name = value
-        };
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-
-        // Get again.
-        control.Name = value;
-        Assert.Equal(expected, control.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Renderer_Get_CallsOnRendererChanged()
-    {
-        using var control = new ToolStripContentPanel();
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-    }
-
-    public static IEnumerable<object[]> Renderer_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (bool doubleBuffered in new bool[] { true, false })
-            {
-                yield return new object[] { visible, doubleBuffered, new SubToolStripRenderer(), false };
-                yield return new object[] { visible, doubleBuffered, new ToolStripSystemRenderer(), false };
-                yield return new object[] { visible, doubleBuffered, new ToolStripProfessionalRenderer(), true };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Renderer_Set_TestData))]
-    public void ToolStripContentPanel_Renderer_Set_ReturnsExpected(bool visible, bool doubleBuffered, ToolStripRenderer value, bool expectedDoubleBuffered)
-    {
-        using var control = new SubToolStripContentPanel
-        {
-            Visible = visible
-        };
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-
-        control.Renderer = value;
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Renderer = value;
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.Renderer = null;
-        Assert.NotNull(control.Renderer);
-        Assert.NotSame(value, control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.True(control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Renderer_Set_TestData))]
-    public void ToolStripContentPanel_Renderer_SetWithHandle_ReturnsExpected(bool visible, bool doubleBuffered, ToolStripRenderer value, bool expectedDoubleBuffered)
-    {
-        using var control = new SubToolStripContentPanel
-        {
-            Visible = visible
-        };
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Renderer = value;
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Renderer = value;
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set null.
-        control.Renderer = null;
-        Assert.NotNull(control.Renderer);
-        Assert.NotSame(value, control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.True(control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Renderer_Set_CallsInitializeContentPanel()
-    {
-        using var control = new SubToolStripContentPanel();
-        var mockToolStripRenderer = new Mock<ToolStripRenderer>(MockBehavior.Strict);
-        mockToolStripRenderer
-            .Protected()
-            .Setup("InitializeContentPanel", control)
-            .Verifiable();
-        control.Renderer = mockToolStripRenderer.Object;
-        Assert.Same(mockToolStripRenderer.Object, control.Renderer);
-        mockToolStripRenderer.Protected().Verify("InitializeContentPanel", Times.Once(), control);
-
-        // Call again.
-        control.Renderer = mockToolStripRenderer.Object;
-        Assert.Same(mockToolStripRenderer.Object, control.Renderer);
-        mockToolStripRenderer.Protected().Verify("InitializeContentPanel", Times.Once(), control);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Renderer_SetWithHandler_CallsRendererChanged()
-    {
-        using var control = new ToolStripContentPanel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RendererChanged += handler;
-
-        // Set different.
-        var renderer = new SubToolStripRenderer();
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(2, callCount);
-
-        // Set same.
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(2, callCount);
-
-        // Set different.
-        control.Renderer = null;
-        Assert.NotNull(control.Renderer);
-        Assert.NotSame(renderer, control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RendererChanged -= handler;
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(3, callCount);
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.ManagerRenderMode, typeof(ToolStripProfessionalRenderer), 3)]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer), 4)]
-    [InlineData(ToolStripRenderMode.System, typeof(ToolStripSystemRenderer), 4)]
-    public void ToolStripContentPanel_RenderMode_Set_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType, int expectedSetSameCallCount)
-    {
-        using var control = new ToolStripContentPanel();
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        // Set same.
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(3, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(expectedSetSameCallCount, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer))]
-    [InlineData(ToolStripRenderMode.System, typeof(ToolStripSystemRenderer))]
-    public void ToolStripContentPanel_RenderMode_SetWithCustomRenderer_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType)
-    {
-        using var control = new ToolStrip
-        {
-            Renderer = new SubToolStripRenderer()
-        };
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set ManagerRenderMode.
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(3, rendererChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.ManagerRenderMode, typeof(ToolStripProfessionalRenderer), 3)]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer), 4)]
-    [InlineData(ToolStripRenderMode.System, typeof(ToolStripSystemRenderer), 4)]
-    public void ToolStripContentPanel_RenderMode_SetWithHandle_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType, int expectedSetSameCallCount)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        // Set same.
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripSystemRenderer>(control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(3, rendererChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(expectedSetSameCallCount, rendererChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedSetSameCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripRenderMode>]
-    public void ToolStripContentPanel_RenderMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripRenderMode value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RenderMode = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_RenderMode_SetCustomThrowsInvalidEnumArgumentException()
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_RenderMode_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripContentPanel))[nameof(ToolStripContentPanel.RenderMode)];
-        using var item = new SubToolStripContentPanel();
-        Assert.False(property.CanResetValue(item));
-
-        item.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, item.RenderMode);
-        Assert.True(property.CanResetValue(item));
-
-        item.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, item.RenderMode);
-        Assert.False(property.CanResetValue(item));
-
-        item.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, item.RenderMode);
-        Assert.False(property.CanResetValue(item));
-
-        item.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, item.RenderMode);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripRenderMode.System, item.RenderMode);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_RenderMode_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripContentPanel))[nameof(ToolStripContentPanel.RenderMode)];
-        using var item = new SubToolStripContentPanel();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, item.RenderMode);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, item.RenderMode);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, item.RenderMode);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, item.RenderMode);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripRenderMode.System, item.RenderMode);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ToolStripContentPanel_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubToolStripContentPanel.ScrollStateAutoScrolling, false)]
-    [InlineData(SubToolStripContentPanel.ScrollStateFullDrag, false)]
-    [InlineData(SubToolStripContentPanel.ScrollStateHScrollVisible, false)]
-    [InlineData(SubToolStripContentPanel.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubToolStripContentPanel.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ToolStripContentPanel_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ToolStripContentPanel_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_Visible_SetWithRenderer_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripContentPanel();
-        Assert.NotNull(control.Renderer);
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new ToolStripContentPanel
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripContentPanel_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripContentPanel();
-        int loadCallCount = 0;
-        control.Load += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            loadCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, loadCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, loadCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripContentPanel_OnLoad_Invoke_CallsLoad(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripContentPanel();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Load += handler;
-        control.OnLoad(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Load -= handler;
-        control.OnLoad(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripContentPanel_OnPaintBackground_Invoke_CallsRenderToolStripContentPanelBackground(bool handled)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        var renderer = new SubToolStripRenderer();
-        using var control = new SubToolStripContentPanel
-        {
-            Renderer = renderer
-        };
-
-        int callCount = 0;
-        renderer.RenderToolStripContentPanelBackground += (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(control, e.ToolStripContentPanel);
-            Assert.False(e.Handled);
-
-            e.Handled = handled;
-            callCount++;
-        };
-
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripContentPanel_OnPaintBackground_InvokeNullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubToolStripContentPanel();
-        Assert.Throws<NullReferenceException>(() => control.OnPaintBackground(null));
-    }
-
-    public static IEnumerable<object[]> OnRendererChanged_TestData()
-    {
-        foreach (bool doubleBuffered in new bool[] { true, false })
-        {
-            yield return new object[] { doubleBuffered, null, null, true };
-            yield return new object[] { doubleBuffered, null, new EventArgs(), true };
-            yield return new object[] { doubleBuffered, new SubToolStripRenderer(), null, false };
-            yield return new object[] { doubleBuffered, new SubToolStripRenderer(), new EventArgs(), false };
-            yield return new object[] { doubleBuffered, new ToolStripSystemRenderer(), null, false };
-            yield return new object[] { doubleBuffered, new ToolStripSystemRenderer(), new EventArgs(), false };
-            yield return new object[] { doubleBuffered, new ToolStripProfessionalRenderer(), null, true };
-            yield return new object[] { doubleBuffered, new ToolStripProfessionalRenderer(), new EventArgs(), true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRendererChanged_TestData))]
-    public void ToolStripContentPanel_OnRendererChanged_Invoke_CallsRendererChanged(bool doubleBuffered, ToolStripRenderer renderer, EventArgs eventArgs, bool expectedDoubleBuffered)
-    {
-        using var control = new SubToolStripContentPanel
-        {
-            Renderer = renderer
-        };
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RendererChanged += handler;
-        control.OnRendererChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RendererChanged -= handler;
-        control.OnRendererChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRendererChanged_TestData))]
-    public void ToolStripContentPanel_OnRendererChanged_InvokeWithHandle_CallsRendererChanged(bool doubleBuffered, ToolStripRenderer renderer, EventArgs eventArgs, bool expectedDoubleBuffered)
-    {
-        using var control = new SubToolStripContentPanel
-        {
-            Renderer = renderer
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, doubleBuffered);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RendererChanged += handler;
-        control.OnRendererChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.RendererChanged -= handler;
-        control.OnRendererChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedDoubleBuffered, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripContentPanel_OnRendererChanged_Invoke_CallsInitializeContentPanel(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripContentPanel();
-        var mockToolStripRenderer = new Mock<ToolStripRenderer>(MockBehavior.Strict);
-        mockToolStripRenderer
-            .Protected()
-            .Setup("InitializeContentPanel", control)
-            .Verifiable();
-        control.Renderer = mockToolStripRenderer.Object;
-        Assert.Same(mockToolStripRenderer.Object, control.Renderer);
-        mockToolStripRenderer.Protected().Verify("InitializeContentPanel", Times.Once(), control);
-
-        control.OnRendererChanged(eventArgs);
-        mockToolStripRenderer.Protected().Verify("InitializeContentPanel", Times.Exactly(2), control);
-
-        // Call again.
-        control.OnRendererChanged(eventArgs);
-        mockToolStripRenderer.Protected().Verify("InitializeContentPanel", Times.Exactly(3), control);
-    }
-
-    private class SubToolStripContentPanel : ToolStripContentPanel
-    {
-        public new const int ScrollStateAutoScrolling = ToolStripContentPanel.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ToolStripContentPanel.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ToolStripContentPanel.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ToolStripContentPanel.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ToolStripContentPanel.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnLoad(EventArgs e) => base.OnLoad(e);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void OnRendererChanged(EventArgs e) => base.OnRendererChanged(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripControlHostAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripControlHostAccessibleObjectTests.cs
deleted file mode 100644
index 9974080b748..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripControlHostAccessibleObjectTests.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripControlHost;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripControlHost_ToolStripControlHostAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_Ctor_OwnerToolStripControlHostCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripControlHostAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_Ctor_Default()
-    {
-        using Control control = new();
-        using ToolStripControlHost toolStrip = new(control);
-        var accessibleObject = (ToolStripControlHostAccessibleObject)toolStrip.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(toolStrip, accessibleObject.Owner);
-        Assert.False(toolStrip.Control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_DefaultAction_ReturnsExpected()
-    {
-        using Control control = new();
-        using ToolStripControlHost toolStrip = new(control);
-        var accessibleObject = (ToolStripControlHostAccessibleObject)toolStrip.AccessibilityObject;
-
-        Assert.Equal(string.Empty, accessibleObject.DefaultAction);
-        Assert.False(toolStrip.Control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_Role_ReturnsExpected()
-    {
-        AccessibleRole testRole = AccessibleRole.Cell;
-        using Control control = new();
-        using ToolStripControlHost toolStrip = new(control);
-        var accessibleObject = (ToolStripControlHostAccessibleObject)toolStrip.AccessibilityObject;
-
-        control.AccessibleRole = testRole;
-
-        Assert.Equal(testRole, accessibleObject.Role);
-        Assert.False(toolStrip.Control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_FragmentNavigate_ReturnsExpected()
-    {
-        using Control control = new();
-        using ToolStripControlHost toolStrip = new(control);
-        var accessibleObject = (ToolStripControlHostAccessibleObject)toolStrip.AccessibilityObject;
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(toolStrip.Control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHostAccessibleObject_ReleaseUiaProvider_ToolStripControlHostControl()
-    {
-        using var toolStrip = new ToolStrip();
-        using Control control = new();
-        using ToolStripControlHost toolStripControlHost = new(control);
-        toolStrip.Items.Add(toolStripControlHost);
-        toolStripControlHost.Parent = toolStrip;
-        toolStrip.CreateControl();
-
-        _ = toolStripControlHost.AccessibilityObject;
-        _ = toolStripControlHost.Control.AccessibilityObject;
-
-        Assert.True(toolStripControlHost.Control.IsAccessibilityObjectCreated);
-
-        toolStripControlHost.ReleaseUiaProvider();
-
-        Assert.False(toolStripControlHost.Control.IsAccessibilityObjectCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripHostedControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripHostedControlAccessibleObjectTests.cs
deleted file mode 100644
index ac3125f783d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHost.ToolStripHostedControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripControlHost_ToolStripHostedControlAccessibleObjectTests
-{
-    public static IEnumerable<object[]> ToolStripItemAccessibleObject_TestData()
-    {
-        return ReflectionHelper.GetPublicNotAbstractClasses<ToolStripControlHost>().Select(type => new object[] { type });
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripHostedControlAccessibleObject_GetPropertyValue_IsOffscreenPropertyId_ReturnExpected(Type type)
-    {
-        using var toolStrip = new ToolStrip();
-        toolStrip.CreateControl();
-        using ToolStripControlHost item = ReflectionHelper.InvokePublicConstructor<ToolStripControlHost>(type);
-        item.Size = new Size(0, 0);
-        toolStrip.Items.Add(item);
-
-        Assert.True(GetIsOffscreenPropertyValue(item.AccessibilityObject));
-        Assert.True(GetIsOffscreenPropertyValue(item.Control.AccessibilityObject));
-    }
-
-    private bool GetIsOffscreenPropertyValue(AccessibleObject accessibleObject) =>
-        (bool)accessibleObject.GetPropertyValue(UIA.IsOffscreenPropertyId) || (accessibleObject.Bounds.Width > 0 && accessibleObject.Bounds.Height > 0);
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHostTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHostTests.cs
deleted file mode 100644
index a8af1e013be..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripControlHostTests.cs
+++ /dev/null
@@ -1,4709 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.ComponentModel.Design;
-using System.Drawing;
-using System.Reflection;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripControlHostTests
-{
-    public static IEnumerable<object[]> Ctor_Control_TestData()
-    {
-        yield return new object[] { new Control() };
-        yield return new object[]
-        {
-            new Control
-            {
-                AccessibleDefaultActionDescription = "AccessibleDefaultActionDescription",
-                AccessibleDescription = "AccessibleDescription",
-                AccessibleName = "AccessibleName",
-                AccessibleRole = AccessibleRole.HelpBalloon,
-                BackColor = Color.Red,
-                BackgroundImage = new Bitmap(10, 10),
-                BackgroundImageLayout = ImageLayout.Zoom,
-                Bounds = new Rectangle(1, 2, 3, 4),
-                CausesValidation = false,
-                ForeColor = Color.Blue,
-                Font = SystemFonts.MenuFont,
-                RightToLeft = RightToLeft.Yes,
-                Tag = new object(),
-                Text = "text"
-            }
-        };
-        yield return new object[] { new Control { Enabled = false } };
-        yield return new object[] { new Control { Visible = false } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Control_TestData))]
-    public void ToolStripControlHost_Ctor_Control(Control c)
-    {
-        using var item = new SubToolStripControlHost(c);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(c.BackColor, item.BackColor);
-        Assert.Equal(c.BackgroundImage, item.BackgroundImage);
-        Assert.Equal(c.BackgroundImageLayout, item.BackgroundImageLayout);
-        Assert.Equal(c.Bounds, item.Bounds);
-        Assert.Equal(c.CanSelect, item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Equal(c.CausesValidation, item.CausesValidation);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 0, 0), item.ContentRectangle);
-        Assert.Same(c, item.Control);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ControlAlign);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(c.Size, item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.Equal(c.Enabled, item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.Equal(c.Focused, item.Focused);
-        Assert.Same(c.Font, item.Font);
-        Assert.Equal(c.ForeColor, item.ForeColor);
-        Assert.Equal(c.Height, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(c.RightToLeft, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.Equal(c.Focused, item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(c.Size, item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(c.Text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(c.Width, item.Width);
-
-        Assert.True(c.Visible);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Ctor_NullControl_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("c", () => new SubToolStripControlHost(null));
-        Assert.Throws<ArgumentNullException>("c", () => new SubToolStripControlHost(null, "name"));
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripControlHost_AccessibleDefaultActionDescription_Set_GetReturnsExpected(string value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            AccessibleDefaultActionDescription = value
-        };
-        Assert.Equal(value, item.AccessibleDefaultActionDescription);
-        Assert.Equal(value, c.AccessibleDefaultActionDescription);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.AccessibleDefaultActionDescription = value;
-        Assert.Equal(value, item.AccessibleDefaultActionDescription);
-        Assert.Equal(value, c.AccessibleDefaultActionDescription);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_AccessibleDefaultActionDescription_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.AccessibleDefaultActionDescription = "value");
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripControlHost_AccessibleDescription_Set_GetReturnsExpected(string value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            AccessibleDescription = value
-        };
-        Assert.Equal(value, item.AccessibleDescription);
-        Assert.Equal(value, c.AccessibleDescription);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.AccessibleDescription = value;
-        Assert.Equal(value, item.AccessibleDescription);
-        Assert.Equal(value, c.AccessibleDescription);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_AccessibleDescription_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.AccessibleDescription = "value");
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripControlHost_AccessibleName_Set_GetReturnsExpected(string value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            AccessibleName = value
-        };
-        Assert.Equal(value, item.AccessibleName);
-        Assert.Equal(value, c.AccessibleName);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.AccessibleName = value;
-        Assert.Equal(value, item.AccessibleName);
-        Assert.Equal(value, c.AccessibleName);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_AccessibleName_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.AccessibleName = "value");
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleRole>]
-    public void ToolStripControlHost_AccessibleRole_Set_GetReturnsExpected(AccessibleRole value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            AccessibleRole = value
-        };
-        Assert.Equal(value, item.AccessibleRole);
-        Assert.Equal(value, c.AccessibleRole);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.AccessibleRole = value;
-        Assert.Equal(value, item.AccessibleRole);
-        Assert.Equal(value, c.AccessibleRole);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AccessibleRole>]
-    public void ToolStripControlHost_AccessibleRole_SetInvalid_ThrowsInvalidEnumArgumentException(AccessibleRole value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.AccessibleRole = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripControlHost_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, item.BackColor);
-        Assert.Equal(expected, c.BackColor);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.Equal(expected, c.BackColor);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.BackColorChanged += handler;
-
-        // Set different.
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.BackColor = Color.Red);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.BackColor)];
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        Assert.False(property.CanResetValue(item));
-
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_ResetValueDisposed_ThrowsObjectDisposedException()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.BackColor)];
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.CanResetValue(item));
-
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item));
-        Assert.IsType<ObjectDisposedException>(ex.InnerException);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.BackColor)];
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackColor_ShouldSerializeValueDisposed_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.BackColor)];
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackgroundImage_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.BackgroundImage);
-    }
-
-    public static IEnumerable<object[]> BackgroundImage_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripControlHost_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            BackgroundImage = value
-        };
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.Equal(value, c.BackgroundImage);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.Equal(value, c.BackgroundImage);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackgroundImage_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        using var value = new Bitmap(10, 10);
-        Assert.Throws<ObjectDisposedException>(() => item.BackgroundImage = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackgroundImageLayout_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.BackgroundImageLayout);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripControlHost_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.Equal(value, c.BackgroundImageLayout);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.Equal(value, c.BackgroundImageLayout);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_BackgroundImageLayout_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.BackgroundImageLayout = ImageLayout.Zoom);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripControlHost_CanSelect_InvokeDesignMode_ReturnsExpected(bool enabled)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var c = new Control
-        {
-            Enabled = enabled
-        };
-        using var item = new ToolStripControlHost(c)
-        {
-            Site = mockSite.Object
-        };
-        Assert.True(item.CanSelect);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_CanSelect_GetDisposed_ReturnsFalse()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(item.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripControlHost_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, item.CausesValidation);
-        Assert.Equal(value, c.CausesValidation);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same
-        item.CausesValidation = value;
-        Assert.Equal(value, item.CausesValidation);
-        Assert.Equal(value, c.CausesValidation);
-        Assert.False(c.IsHandleCreated);
-
-        // Set different
-        item.CausesValidation = !value;
-        Assert.Equal(!value, item.CausesValidation);
-        Assert.Equal(!value, c.CausesValidation);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeBackColor_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.BackColorChanged += (sender, e) => callCount++;
-
-        c.BackColor = Color.Red;
-        Assert.Equal(Color.Red, c.BackColor);
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeBackgroundImage_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var backgroundImage = new Bitmap(10, 10);
-        c.BackgroundImage = backgroundImage;
-        Assert.Same(backgroundImage, c.BackgroundImage);
-        Assert.Same(backgroundImage, item.BackgroundImage);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeBackgroundImageLayout_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        c.BackgroundImageLayout = ImageLayout.Zoom;
-        Assert.Equal(ImageLayout.Zoom, c.BackgroundImageLayout);
-        Assert.Equal(ImageLayout.Zoom, item.BackgroundImageLayout);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeCausesValidation_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        c.CausesValidation = false;
-        Assert.False(c.CausesValidation);
-        Assert.False(item.CausesValidation);
-
-        c.CausesValidation = true;
-        Assert.True(c.CausesValidation);
-        Assert.True(item.CausesValidation);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeEnabled_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.EnabledChanged += (sender, e) => callCount++;
-
-        c.Enabled = false;
-        Assert.False(c.Enabled);
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        c.Enabled = true;
-        Assert.True(c.Enabled);
-        Assert.True(item.Enabled);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeFont_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var value = new Font("Arial", 8.25f);
-        c.Font = value;
-        Assert.Same(value, c.Font);
-        Assert.Same(value, item.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeForeColor_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.ForeColorChanged += (sender, e) => callCount++;
-
-        c.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, c.ForeColor);
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeRightToLeft_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.RightToLeftChanged += (sender, e) => callCount++;
-
-        c.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, c.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeSize_GetReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        c.Size = new Size(10, 20);
-        Assert.Equal(new Size(10, 20), c.Size);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeText_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.TextChanged += (sender, e) => callCount++;
-
-        c.Text = "Text";
-        Assert.Equal("Text", c.Text);
-        Assert.Equal("Text", item.Text);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Control_ChangeVisible_UpdatesHost()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        item.VisibleChanged += (sender, e) => callCount++;
-
-        c.Visible = false;
-        Assert.False(c.Visible);
-        Assert.False(item.Available);
-        Assert.False(item.Visible);
-        Assert.Equal(1, callCount);
-
-        c.Visible = true;
-        Assert.True(c.Visible);
-        Assert.True(item.Available);
-        Assert.False(item.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripControlHost_ControlAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var c = new Control
-        {
-            Bounds = new Rectangle(10, 20, 30, 40)
-        };
-        using var item = new ToolStripControlHost(c)
-        {
-            ControlAlign = value
-        };
-        Assert.Equal(value, item.ControlAlign);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), item.Bounds);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), c.Bounds);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ControlAlign = value;
-        Assert.Equal(value, item.ControlAlign);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), item.Bounds);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), c.Bounds);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripControlHost_ControlAlign_SetDisposed_GetReturnsExpected(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        item.ControlAlign = value;
-        Assert.Equal(value, item.ControlAlign);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ControlAlign = value;
-        Assert.Equal(value, item.ControlAlign);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripControlHost_ControlAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.ControlAlign = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_DefaultSize_GetDisposed_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripControlHost_DisplayStyle_Set_GetReturnsExpected(ToolStripItemDisplayStyle value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            DisplayStyle = value
-        };
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_DisplayStyle_SetWithHandler_CallsDisplayStyleChanged()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.DisplayStyleChanged += handler;
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.None;
-        Assert.Equal(ToolStripItemDisplayStyle.None, item.DisplayStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.DisplayStyleChanged -= handler;
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripControlHost_DisplayStyle_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemDisplayStyle value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.DisplayStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripControlHost_DoubleClickEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            DoubleClickEnabled = value
-        };
-        Assert.Equal(value, item.DoubleClickEnabled);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.DoubleClickEnabled = value;
-        Assert.Equal(value, item.DoubleClickEnabled);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Enabled_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Enabled);
-    }
-
-    public static IEnumerable<object[]> Enabled_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true };
-                yield return new object[] { visible, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripControlHost_Enabled_Set_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            Visible = visible,
-            Image = image,
-            Enabled = value
-        };
-        Assert.Equal(value, item.Enabled);
-        Assert.Equal(value, c.Enabled);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.Equal(value, c.Enabled);
-        Assert.False(c.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.Equal(!value, c.Enabled);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.EnabledChanged += handler;
-
-        // Set different.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Enabled = true;
-        Assert.True(item.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.Enabled = false;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Enabled_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Enabled = false);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Focused_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Focused);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Font);
-    }
-
-    public static IEnumerable<object[]> Font_Set_TestData()
-    {
-        foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-            yield return new object[] { displayStyle, new Font("Arial", 8.25f) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ToolStripControlHost_Font_Set_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, item.Font);
-        Assert.Equal(value ?? Control.DefaultFont, c.Font);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, item.Font);
-        Assert.Equal(value ?? Control.DefaultFont, c.Font);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        using var font = new Font("Arial", 8.25f);
-        Assert.Throws<ObjectDisposedException>(() => item.Font = font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.Font)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.CanResetValue(item));
-
-        using var font = new Font("Arial", 8.25f);
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.CanResetValue(item));
-
-        item.Font = null;
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.False(property.CanResetValue(item));
-
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_ResetValueDisposed_ThrowsObjectDisposedException()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.Font)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.CanResetValue(item));
-
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item));
-        Assert.IsType<ObjectDisposedException>(ex.InnerException);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.Font)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        using var font = new Font("Arial", 8.25f);
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.Font = null;
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultFont, item.Font);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Font_ShouldSerializeValueDisposed_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.Font)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripControlHost_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, item.ForeColor);
-        Assert.Equal(expected, c.ForeColor);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.Equal(expected, c.ForeColor);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.ForeColorChanged += handler;
-
-        // Set different.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.ForeColor = Color.Red);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.ForeColor)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.CanResetValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_ResetValueDisposed_ThrowsObjectDisposedException()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.ForeColor)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.CanResetValue(item));
-
-        TargetInvocationException ex = Assert.Throws<TargetInvocationException>(() => property.ResetValue(item));
-        Assert.IsType<ObjectDisposedException>(ex.InnerException);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.ForeColor)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ForeColor_ShouldSerializeValueDisposed_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripControlHost))[nameof(ToolStripControlHost.ForeColor)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    public static IEnumerable<object[]> Image_Set_TestData()
-    {
-        foreach (Color imageTransparentColor in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { imageTransparentColor, null };
-            yield return new object[] { imageTransparentColor, new Bitmap(10, 10) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripControlHost_Image_Set_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            ImageTransparentColor = imageTransparentColor
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripControlHost_ImageAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            ImageAlign = value
-        };
-        Assert.Equal(value, item.ImageAlign);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ImageAlign = value;
-        Assert.Equal(value, item.ImageAlign);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripControlHost_ImageAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.ImageAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripControlHost_ImageIndex_Set_GetReturnsExpected(int value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ImageIndex = value;
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripControlHost_ImageKey_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ImageKey = value;
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemImageScaling>]
-    public void ToolStripControlHost_ImageScaling_Set_GetReturnsExpected(ToolStripItemImageScaling value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            ImageScaling = value
-        };
-        Assert.Equal(value, item.ImageScaling);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ImageScaling = value;
-        Assert.Equal(value, item.ImageScaling);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageTransparentColor_Set_TestData()
-    {
-        foreach (Color color in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { null, color };
-            yield return new object[] { new Bitmap(10, 10), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), color };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripControlHost_ImageTransparentColor_Set_GetReturnsExpected(Image image, Color value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            Image = image
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    foreach (bool allowDrop in new bool[] { true, false })
-                    {
-                        yield return new object[] { enabled, visible, image, allowDrop };
-                        yield return new object[] { enabled, visible, image, allowDrop };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripControlHost_Parent_Set_GetReturnsExpected(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Parent = parent
-        };
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Same(c, Assert.Single(parent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.Parent = parent;
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Same(c, Assert.Single(parent.Controls));
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.Parent = otherParent;
-        Assert.Same(otherParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Same(c, Assert.Single(otherParent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.Parent = null;
-        Assert.Null(item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.Parent = statusParent;
-        Assert.Same(statusParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Empty(statusParent.Items);
-        Assert.Same(c, Assert.Single(statusParent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripControlHost_Parent_SetWithOwner_GetReturnsExpected(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var owner = new ToolStrip();
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Owner = owner,
-            Parent = parent
-        };
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Same(c, Assert.Single(parent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.Parent = parent;
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Same(c, Assert.Single(parent.Controls));
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.Parent = otherParent;
-        Assert.Same(otherParent, item.Parent);
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Same(c, Assert.Single(otherParent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.Parent = null;
-        Assert.Null(item.Parent);
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Same(c, Assert.Single(otherParent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.Parent = statusParent;
-        Assert.Same(statusParent, item.Parent);
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Empty(statusParent.Items);
-        Assert.Same(c, Assert.Single(statusParent.Controls));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Parent_SetDisposed_GetReturnsExpected()
-    {
-        using var parent = new ToolStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Parent = parent);
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_GetDisposed_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RightToLeft>]
-    public void ToolStripControlHost_RightToLeft_SetDisposed_Nop(RightToLeft value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        item.RightToLeft = value;
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.Equal(RightToLeft.No, c.RightToLeft);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.RightToLeft = value;
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.Equal(RightToLeft.No, c.RightToLeft);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ToolStripControlHost_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(expected, item.RightToLeft);
-        Assert.Equal(expected, c.RightToLeft);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.RightToLeft = value;
-        Assert.Equal(expected, item.RightToLeft);
-        Assert.Equal(expected, c.RightToLeft);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.RightToLeftChanged += handler;
-
-        // Set different.
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.RightToLeftChanged -= handler;
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ToolStripControlHost_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.RightToLeft = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(SubToolStripControlHost))[nameof(ToolStripControlHost.RightToLeft)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.False(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_ResetValueDisposed_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(SubToolStripControlHost))[nameof(ToolStripControlHost.RightToLeft)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        item.Dispose();
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(SubToolStripControlHost))[nameof(ToolStripControlHost.RightToLeft)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_RightToLeft_ShouldSerializeValueDisposed_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(SubToolStripControlHost))[nameof(ToolStripControlHost.RightToLeft)];
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        item.Dispose();
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripControlHost_RightToLeftAutoMirrorImage_Set_GetReturnsExpected(bool value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c)
-        {
-            RightToLeftAutoMirrorImage = value
-        };
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.RightToLeftAutoMirrorImage = value;
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-        Assert.False(c.IsHandleCreated);
-
-        // Set different.
-        item.RightToLeftAutoMirrorImage = !value;
-        Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Selected_GetDisposed_ReturnsFalse()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.False(item.Selected);
-    }
-
-    public static IEnumerable<object[]> Site_Set_TestData()
-    {
-        foreach (string name in new string[] { null, string.Empty, "name" })
-        {
-            foreach (bool designMode in new bool[] { true, false })
-            {
-                yield return new object[] { null, name, designMode };
-                yield return new object[] { new Container(), name, designMode };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_Set_TestData))]
-    public void ToolStripControlHost_Site_Set_GetReturnsExpected(IContainer container, string name, bool designMode)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(name);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-
-        item.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, item.Site);
-        Assert.NotSame(mockSite.Object, c.Site);
-        Assert.Same(c, c.Site.Component);
-        Assert.Same(container, c.Site.Container);
-        Assert.Equal(designMode, c.Site.DesignMode);
-        Assert.Equal(name, c.Site.Name);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.Site = mockSite.Object;
-        Assert.Same(mockSite.Object, item.Site);
-        Assert.NotSame(mockSite.Object, c.Site);
-        Assert.Same(c, c.Site.Component);
-        Assert.Same(container, c.Site.Container);
-        Assert.Equal(designMode, c.Site.DesignMode);
-        Assert.Equal(name, c.Site.Name);
-        Assert.False(c.IsHandleCreated);
-
-        // Set null.
-        item.Site = null;
-        Assert.Null(item.Site);
-        Assert.Null(c.Site);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_GetControlSiteContainerAfterSettingNull_IsNull()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        ISite oldSite = c.Site;
-
-        item.Site = null;
-        Assert.Null(oldSite.Container);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_GetControlSiteDesignModeAfterSettingNull_IsFalse()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        ISite oldSite = c.Site;
-
-        item.Site = null;
-        Assert.False(oldSite.DesignMode);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_GetControlSiteNameAfterSettingNull_IsNull()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        ISite oldSite = c.Site;
-
-        item.Site = null;
-        Assert.Null(oldSite.Name);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripControlHost_Site_SetControlSiteName_GetReturnsExpected(string value, string expected)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(expected);
-        mockSite
-            .SetupSet(s => s.Name = value)
-            .Verifiable();
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-
-        c.Site.Name = value;
-        Assert.Equal(expected, item.Site.Name);
-        Assert.Equal(expected, c.Site.Name);
-        mockSite.VerifySet(s => s.Name = value, Times.Once());
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        c.Site.Name = value;
-        Assert.Equal(expected, item.Site.Name);
-        Assert.Equal(expected, c.Site.Name);
-        mockSite.VerifySet(s => s.Name = value, Times.Exactly(2));
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_SetControlSiteNameAfterSettingNull_IsNull()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        using var container = new Container();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns(container);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        ISite oldSite = c.Site;
-
-        item.Site = null;
-        oldSite.Name = "name";
-        Assert.Null(oldSite.Name);
-    }
-
-    public static IEnumerable<object[]> Site_GetService_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Site_GetService_TestData))]
-    public void ToolStripControlHost_Site_ControlSiteGetService_ReturnsExpected(object result)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.GetService(typeof(int)))
-            .Returns(result)
-            .Verifiable();
-        item.Site = mockSite.Object;
-        Assert.Same(result, c.Site.GetService(typeof(int)));
-        mockSite.Verify(s => s.GetService(typeof(int)), Times.Once());
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteGetServiceIDictionaryServices_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        Assert.Same(c.Site, c.Site.GetService(typeof(IDictionaryService)));
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteGetServiceAfterSettingNull_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        ISite oldSite = c.Site;
-
-        item.Site = null;
-        Assert.Null(oldSite.GetService(typeof(int)));
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteGetServiceNullServiceType_ThrowsArgumentNullException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        Assert.Throws<ArgumentNullException>("service", () => c.Site.GetService(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("value")]
-    public void ToolStripControlHost_Site_ControlSiteGetKey_NoSuchValueEmpty_ReturnsExpected(object value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-        Assert.Null(iDictionaryService.GetKey(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("value")]
-    public void ToolStripControlHost_Site_ControlSiteGetKey_NoSuchValueNotEmpty_ReturnsExpected(object value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-
-        iDictionaryService.SetValue("key1", "value1");
-        Assert.Null(iDictionaryService.GetKey(value));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("key")]
-    public void ToolStripControlHost_Site_ControlSiteGetValue_NoSuchKeyEmpty_ReturnsExpected(object key)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-        Assert.Null(iDictionaryService.GetValue(key));
-    }
-
-    [WinFormsTheory]
-    [InlineData("key")]
-    public void ToolStripControlHost_Site_ControlSiteGetValue_NoSuchKeyNotEmpty_ReturnsExpected(object key)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-
-        iDictionaryService.SetValue("key1", "value1");
-        Assert.Null(iDictionaryService.GetValue(key));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteGetValue_NullKey_ThrowsArgumentNullException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-
-        iDictionaryService.SetValue("key1", "value1");
-        Assert.Throws<ArgumentNullException>("key", () => iDictionaryService.GetValue(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteSetValue_Invoke_Success()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-
-        // Set custom.
-        iDictionaryService.SetValue("key1", "value1");
-        Assert.Equal("value1", iDictionaryService.GetValue("key1"));
-        Assert.Equal("key1", iDictionaryService.GetKey("value1"));
-
-        // Set same key.
-        iDictionaryService.SetValue("key1", "otherValue");
-        Assert.Equal("otherValue", iDictionaryService.GetValue("key1"));
-        Assert.Equal("key1", iDictionaryService.GetKey("otherValue"));
-
-        // Set null value.
-        iDictionaryService.SetValue("key2", null);
-        Assert.Null(iDictionaryService.GetValue("key2"));
-        Assert.Null(iDictionaryService.GetKey(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_ControlSiteSetValue_NullKey_ThrowsArgumentNullException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        item.Site = mockSite.Object;
-        IDictionaryService iDictionaryService = Assert.IsAssignableFrom<IDictionaryService>(c.Site);
-
-        Assert.Throws<ArgumentNullException>("key", () => iDictionaryService.SetValue(null, "value"));
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Site_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        Assert.Throws<ObjectDisposedException>(() => item.Site = mockSite.Object);
-        Assert.Equal(mockSite.Object, item.Site);
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(0, 0) };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(22, 23) };
-        yield return new object[] { new Size(23, 22) };
-        yield return new object[] { new Size(23, 23) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void ToolStripControlHost_Size_Set_GetReturnsExpected(Size value)
-    {
-        using var c = new Control
-        {
-            Bounds = new Rectangle(1, 2, 3, 4)
-        };
-        using var item = new ToolStripControlHost(c);
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(new Rectangle(1, 2, value.Width, value.Height), c.Bounds);
-        Assert.Equal(0, locationChangedCallCount);
-
-        // Set same.
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(new Rectangle(1, 2, value.Width, value.Height), c.Bounds);
-        Assert.Equal(0, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void ToolStripControlHost_Size_SetDisposed_GetReturnsExpected(Size value)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(0, locationChangedCallCount);
-
-        // Set same.
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(0, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripControlHost_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Text = value
-        };
-        Assert.Equal(expected, item.Text);
-        Assert.Equal(expected, c.Text);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.Text = value;
-        Assert.Equal(expected, item.Text);
-        Assert.Equal(expected, c.Text);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.TextChanged += handler;
-
-        // Set different.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Text = string.Empty;
-        Assert.Empty(item.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.TextChanged -= handler;
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripControlHost_TextAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, item.TextAlign);
-
-        // Set same.
-        item.TextAlign = value;
-        Assert.Equal(value, item.TextAlign);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripControlHost_TextAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextAlign = value);
-    }
-
-    public static IEnumerable<object[]> TextDirection_Set_TestData()
-    {
-        yield return new object[] { ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90 };
-        yield return new object[] { ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_Set_TestData))]
-    public void ToolStripControlHost_TextDirection_Set_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            TextDirection = value
-        };
-        Assert.Equal(expected, item.TextDirection);
-
-        // Set same.
-        item.TextDirection = value;
-        Assert.Equal(expected, item.TextDirection);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripTextDirection>]
-    public void ToolStripControlHost_TextDirection_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripTextDirection value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextDirection = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextImageRelation>]
-    public void ToolStripControlHost_TextImageRelation_Set_GetReturnsExpected(TextImageRelation value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            TextImageRelation = value
-        };
-        Assert.Equal(value, item.TextImageRelation);
-
-        // Set same.
-        item.TextImageRelation = value;
-        Assert.Equal(value, item.TextImageRelation);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextImageRelation>]
-    [InlineData((TextImageRelation)3)]
-    [InlineData((TextImageRelation)5)]
-    [InlineData((TextImageRelation)6)]
-    [InlineData((TextImageRelation)7)]
-    public void ToolStripControlHost_TextImageRelation_SetInvalid_ThrowsInvalidEnumArgumentException(TextImageRelation value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextImageRelation = value);
-    }
-
-    public static IEnumerable<object[]> SetVisibleCore_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true };
-                yield return new object[] { enabled, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripControlHost_Visible_Set_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Image = image,
-            Visible = value
-        };
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, c.Visible);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, c.Visible);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.Equal(!value, c.Visible);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Visible_SetWithHandler_CallsAvailableChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.AvailableChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.VisibleChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ToolStripControlHost_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using var c = new Control();
-        if (createControl)
-        {
-            c.CreateControl();
-        }
-
-        Assert.Equal(createControl, c.IsHandleCreated);
-        using var item = new SubToolStripControlHost(c);
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(createControl, c.IsHandleCreated);
-        Assert.Empty(accessibleObject.DefaultAction);
-        Assert.Equal(expectedAccessibleRole, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            AccessibleDefaultActionDescription = "AccessibleDefaultActionDescription",
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        c.AccessibleRole = AccessibleRole.Alert;
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Empty(accessibleObject.DefaultAction);
-        Assert.Equal(AccessibleRole.Alert, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_CreateAccessibilityInstance_InvokeDisposed_ReturnsExpected()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Empty(accessibleObject.DefaultAction);
-        Assert.Equal(AccessibleRole.Default, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_CreateAccessibilityInstanceDoDefaultAction_Nop()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        accessibleObject.DoDefaultAction();
-
-        // Call again.
-        accessibleObject.DoDefaultAction();
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Dispose_Invoke_Success()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            if (callCount == 0)
-            {
-                Assert.Same(c, item.Control);
-                Assert.False(c.IsDisposed);
-            }
-
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.True(c.IsDisposed);
-            Assert.Null(item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.True(c.IsDisposed);
-            Assert.Null(item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Dispose_InvokeDisposing_Success()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            if (callCount == 0)
-            {
-                Assert.Equal(c, item.Control);
-                Assert.False(c.IsDisposed);
-            }
-
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(true);
-            Assert.False(item.IsDisposed);
-            Assert.True(c.IsDisposed);
-            Assert.Null(item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(true);
-            Assert.False(item.IsDisposed);
-            Assert.True(c.IsDisposed);
-            Assert.Null(item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Dispose_InvokeNotDisposing_Success()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(false);
-            Assert.False(item.IsDisposed);
-            Assert.False(c.IsDisposed);
-            Assert.Same(c, item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(0, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(false);
-            Assert.False(item.IsDisposed);
-            Assert.False(c.IsDisposed);
-            Assert.Same(c, item.Control);
-            Assert.Null(item.Image);
-            Assert.Equal(0, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Focus_InvokeWithoutHandle_Nop()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Focus();
-        Assert.False(c.Focused);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_Focus_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.Focus());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripControlHost_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var c = new Control
-        {
-            MinimumSize = new Size(10, 20)
-        };
-        using var item = new ToolStripControlHost(c);
-        Assert.Equal(new Size(10, 20), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(10, 20), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripControlHost_GetPreferredSize_InvokeWithPadding_ReturnsExpected(Size proposedSize)
-    {
-        using var c = new Control
-        {
-            MinimumSize = new Size(10, 20)
-        };
-        using var item = new ToolStripControlHost(c)
-        {
-            Padding = new Padding(1, 2, 3, 4)
-        };
-        Assert.Equal(new Size(14, 26), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(14, 26), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripControlHost_GetPreferredSize_InvokeDisposed_ThrowsObjectDisposedException(Size proposedSize)
-    {
-        using var c = new Control();
-        using var item = new ToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Throws<ObjectDisposedException>(() => item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripControlHost_OnBoundsChanged_Invoke_Success(ContentAlignment controlAlign)
-    {
-        using var c = new Control
-        {
-            Bounds = new Rectangle(10, 20, 30, 40)
-        };
-        using var item = new SubToolStripControlHost(c)
-        {
-            ControlAlign = controlAlign
-        };
-
-        item.OnBoundsChanged();
-        Assert.Equal(new Rectangle(10, 20, 30, 40), item.Bounds);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), c.Bounds);
-        Assert.False(c.IsHandleCreated);
-
-        // Call again.
-        item.OnBoundsChanged();
-        Assert.Equal(new Rectangle(10, 20, 30, 40), item.Bounds);
-        Assert.Equal(new Rectangle(10, 20, 30, 40), c.Bounds);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_OnBoundsChanged_InvokeDisposed_Nop()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        item.OnBoundsChanged();
-
-        // Call again.
-        item.OnBoundsChanged();
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Enter += handler;
-        item.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.Enter -= handler;
-        item.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnGotFocus_Invoke_CallsGotFocus(EventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.GotFocus += handler;
-        item.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.GotFocus -= handler;
-        item.OnGotFocus(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnHostedControlResize_Invoke_CallsHostedControlResize(EventArgs eventArgs)
-    {
-        using var c = new Control
-        {
-            Bounds = new Rectangle(1, 2, 3, 4)
-        };
-        using var item = new SubToolStripControlHost(c);
-
-        item.OnHostedControlResize(eventArgs);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), item.Bounds);
-
-        // Call again.
-        item.OnHostedControlResize(eventArgs);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), item.Bounds);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripControlHost_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.KeyDown += handler;
-        item.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.KeyDown -= handler;
-        item.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void ToolStripControlHost_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.KeyPress += handler;
-        item.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.KeyPress -= handler;
-        item.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripControlHost_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.KeyUp += handler;
-        item.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.KeyUp -= handler;
-        item.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStripControlHost_OnLayout_Invoke_Nop(LayoutEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-
-        item.OnLayout(eventArgs);
-
-        // Call again.
-        item.OnLayout(eventArgs);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Leave += handler;
-        item.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.Leave -= handler;
-        item.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnLostFocus_Invoke_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.LostFocus += handler;
-        item.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.LostFocus -= handler;
-        item.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripControlHost_OnPaint_Invoke_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnParentChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    foreach (bool allowDrop in new bool[] { true, false })
-                    {
-                        yield return new object[] { enabled, visible, image, allowDrop, null, null };
-                        yield return new object[] { enabled, visible, image, allowDrop, null, new ToolStrip() };
-                        yield return new object[] { enabled, visible, image, allowDrop, new ToolStrip(), null };
-                        yield return new object[] { enabled, visible, image, allowDrop, new ToolStrip(), new ToolStrip() };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ToolStripControlHost_OnParentChanged_Invoke_Success(bool enabled, bool visible, Image image, bool allowDrop, ToolStrip oldParent, ToolStrip newParent)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop
-        };
-        item.OnParentChanged(oldParent, newParent);
-        Assert.Null(item.Owner);
-        Assert.Empty(c.Controls);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ToolStripControlHost_OnParentChanged_InvokeWithOwner_Success(bool enabled, bool visible, Image image, bool allowDrop, ToolStrip oldParent, ToolStrip newParent)
-    {
-        using var owner = new ToolStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Owner = owner
-        };
-        item.OnParentChanged(oldParent, newParent);
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(owner.Controls);
-        Assert.Empty(c.Controls);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripControlHost_OnParentChanged_InvokeControlWithoutParent_Success(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop
-        };
-
-        item.OnParentChanged(null, parent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.OnParentChanged(parent, parent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.OnParentChanged(parent, otherParent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.OnParentChanged(otherParent, null);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.OnParentChanged(null, statusParent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripControlHost_OnParentChanged_InvokeControlWithParent_Success(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var controlParent = new Control();
-        using var c = new Control
-        {
-            Parent = controlParent
-        };
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop
-        };
-
-        item.OnParentChanged(null, parent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Same(controlParent, c.Parent);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.OnParentChanged(parent, parent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Same(controlParent, c.Parent);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.OnParentChanged(parent, otherParent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Same(controlParent, c.Parent);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.OnParentChanged(otherParent, null);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Same(controlParent, c.Parent);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.OnParentChanged(null, statusParent);
-        Assert.Null(item.Parent);
-        Assert.Null(item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(parent.Controls);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(otherParent.Controls);
-        Assert.Same(controlParent, c.Parent);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ToolStripControlHost_OnParentChanged_InvokeDisposed_Success(bool enabled, bool visible, Image image, bool allowDrop, ToolStrip oldParent, ToolStrip newParent)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop
-        };
-        item.Dispose();
-
-        item.OnParentChanged(oldParent, newParent);
-        Assert.Null(item.Owner);
-        Assert.Empty(c.Controls);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ToolStripControlHost_OnParentChanged_InvokeDisposedWithOwner_Success(bool enabled, bool visible, Image image, bool allowDrop, ToolStrip oldParent, ToolStrip newParent)
-    {
-        using var owner = new ToolStrip();
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Owner = owner
-        };
-        item.Dispose();
-
-        item.OnParentChanged(oldParent, newParent);
-        Assert.Null(item.Owner);
-        Assert.Empty(c.Controls);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeBackColorChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.BackColorChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnBackColorChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeClick_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Click += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnClick(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeDoubleClick_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.DoubleClick += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnDoubleClick(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> DragEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DragEventArgs(null, 1, 2, 3, DragDropEffects.Copy, DragDropEffects.Move) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeDragDrop_Success(DragEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.DragDrop += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnDragDrop(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeDragEnter_Success(DragEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.DragEnter += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnDragEnter(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeDragLeave_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.DragLeave += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnDragLeave(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeDragOver_Success(DragEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.DragOver += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnDragOver(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeEnabledChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.EnabledChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnEnabledChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeEnter_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Enter += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnEnter(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeForeColorChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.ForeColorChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnForeColorChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> GiveFeedbackEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new GiveFeedbackEventArgs(DragDropEffects.None, true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GiveFeedbackEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeGiveFeedback_Success(GiveFeedbackEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.GiveFeedback += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnGiveFeedback(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeGotFocus_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.GotFocus += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnGotFocus(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeKeyDown_Success(KeyEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.KeyDown += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnKeyDown(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeKeyPress_Success(KeyPressEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.KeyPress += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnKeyPress(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeKeyUp_Success(KeyEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.KeyUp += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnKeyUp(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeLeave_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Leave += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnLeave(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeLocationChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnLocationChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeLostFocus_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.LostFocus += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnLostFocus(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseDown_Success(MouseEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseDown += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseDown(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseEnter_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseEnter += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseEnter(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseHover_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseHover += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseHover(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseLeave_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseLeave += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseLeave(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseMove_Success(MouseEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseMove += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseMove(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeMouseUp_Success(MouseEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.MouseUp += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnMouseUp(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokePaint_Success(PaintEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Paint += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnPaint(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> QueryContinueDragEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new QueryContinueDragEventArgs(0, true, DragAction.Drop) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(QueryContinueDragEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeQueryContinueDrag_Success(QueryContinueDragEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.QueryContinueDrag += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnQueryContinueDrag(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeQueryAccessibilityHelp_Success()
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.QueryAccessibilityHelp += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            e.HelpKeyword = "1";
-            e.HelpNamespace = "FileName";
-            callCount++;
-        };
-
-        Assert.Equal(1, c.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Equal("FileName", fileName);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeResize_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl
-        {
-            Bounds = new Rectangle(1, 2, 3, 4)
-        };
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        c.OnResize(eventArgs);
-        Assert.Equal(new Rectangle(1, 2, 3, 4), item.Bounds);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeRightToLeftChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeTextChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.TextChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnTextChanged(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeValidated_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Validated += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnValidated(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> CancelEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs() };
-        yield return new object[] { new CancelEventArgs(true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CancelEventArgs_TestData))]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeValidating_Success(CancelEventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.Validating += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnValidating(eventArgs);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnSubscribeControlEvents_InvokeVisibleChanged_Success(EventArgs eventArgs)
-    {
-        using var c = new SubControl();
-        using var item = new SubToolStripControlHost(c);
-        item.OnSubscribeControlEvents(c);
-
-        int callCount = 0;
-        item.VisibleChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        c.OnVisibleChanged(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, -1)]
-    public void ToolStripControlHost_OnUnsubscribeControlEvents_Invoke_Success(bool createControl, int expectedResult)
-    {
-        using var c = new SubControl();
-
-        if (createControl)
-        {
-            c.CreateControl();
-        }
-
-        using var item = new SubToolStripControlHost(c);
-        item.OnUnsubscribeControlEvents(c);
-
-        int backColorChangedCallCount = 0;
-        item.BackColorChanged += (sender, e) => backColorChangedCallCount++;
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-        int doubleClickCallCount = 0;
-        item.Click += (sender, e) => doubleClickCallCount++;
-        int dragDropCallCount = 0;
-        item.DragDrop += (sender, e) => dragDropCallCount++;
-        int dragEnterCallCount = 0;
-        item.DragEnter += (sender, e) => dragEnterCallCount++;
-        int dragLeaveCallCount = 0;
-        item.DragLeave += (sender, e) => dragLeaveCallCount++;
-        int dragOverCallCount = 0;
-        item.DragOver += (sender, e) => dragOverCallCount++;
-        int enabledChangedCallCount = 0;
-        item.EnabledChanged += (sender, e) => enabledChangedCallCount++;
-        int enterCallCount = 0;
-        item.Enter += (sender, e) => enterCallCount++;
-        int foreColorChangedCallCount = 0;
-        item.Enter += (sender, e) => foreColorChangedCallCount++;
-        int giveFeedbackCallCount = 0;
-        item.GiveFeedback += (sender, e) => giveFeedbackCallCount++;
-        int gotFocusCallCount = 0;
-        item.GotFocus += (sender, e) => gotFocusCallCount++;
-        int keyDownCallCount = 0;
-        item.KeyDown += (sender, e) => keyDownCallCount++;
-        int keyPressCallCount = 0;
-        item.KeyPress += (sender, e) => keyPressCallCount++;
-        int keyUpCallCount = 0;
-        item.KeyUp += (sender, e) => keyUpCallCount++;
-        int leaveCallCount = 0;
-        item.Leave += (sender, e) => leaveCallCount++;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-        int lostFocusCallCount = 0;
-        item.LostFocus += (sender, e) => lostFocusCallCount++;
-        int mouseDownCallCount = 0;
-        item.MouseDown += (sender, e) => mouseDownCallCount++;
-        int mouseEnterCallCount = 0;
-        item.MouseEnter += (sender, e) => mouseEnterCallCount++;
-        int mouseHoverCallCount = 0;
-        item.MouseHover += (sender, e) => mouseHoverCallCount++;
-        int mouseLeaveCallCount = 0;
-        item.MouseLeave += (sender, e) => mouseLeaveCallCount++;
-        int mouseMoveCallCount = 0;
-        item.MouseMove += (sender, e) => mouseMoveCallCount++;
-        int mouseUpCallCount = 0;
-        item.MouseUp += (sender, e) => mouseUpCallCount++;
-        int paintCallCount = 0;
-        item.Paint += (sender, e) => paintCallCount++;
-        int queryAccessibilityHelpCallCount = 0;
-        item.QueryAccessibilityHelp += (sender, e) => queryAccessibilityHelpCallCount++;
-        int queryContinueDragCallCount = 0;
-        item.QueryContinueDrag += (sender, e) => queryContinueDragCallCount++;
-        int rightToLeftChangedCallCount = 0;
-        item.RightToLeftChanged += (sender, e) => rightToLeftChangedCallCount++;
-        int textChangedCallCount = 0;
-        item.TextChanged += (sender, e) => textChangedCallCount++;
-        int validatedCallCount = 0;
-        item.Validated += (sender, e) => validatedCallCount++;
-        int validatingCallCount = 0;
-        item.Validating += (sender, e) => validatingCallCount++;
-
-        c.OnBackColorChanged(EventArgs.Empty);
-        Assert.Equal(0, backColorChangedCallCount);
-
-        c.OnClick(EventArgs.Empty);
-        Assert.Equal(0, clickCallCount);
-
-        c.OnDoubleClick(EventArgs.Empty);
-        Assert.Equal(0, doubleClickCallCount);
-
-        c.OnEnabledChanged(EventArgs.Empty);
-        Assert.Equal(0, enabledChangedCallCount);
-
-        c.OnEnter(EventArgs.Empty);
-        Assert.Equal(0, enterCallCount);
-
-        c.OnForeColorChanged(EventArgs.Empty);
-        Assert.Equal(0, foreColorChangedCallCount);
-
-        c.OnGiveFeedback(new GiveFeedbackEventArgs(DragDropEffects.All, false));
-        Assert.Equal(0, giveFeedbackCallCount);
-
-        c.OnGotFocus(EventArgs.Empty);
-        Assert.Equal(0, gotFocusCallCount);
-
-        c.OnKeyDown(new KeyEventArgs(Keys.A));
-        Assert.Equal(0, keyDownCallCount);
-
-        c.OnKeyPress(new KeyPressEventArgs('a'));
-        Assert.Equal(0, keyPressCallCount);
-
-        c.OnKeyUp(new KeyEventArgs(Keys.A));
-        Assert.Equal(0, keyUpCallCount);
-
-        c.OnLeave(EventArgs.Empty);
-        Assert.Equal(0, leaveCallCount);
-
-        c.OnLocationChanged(EventArgs.Empty);
-        Assert.Equal(0, locationChangedCallCount);
-
-        c.OnLostFocus(EventArgs.Empty);
-        Assert.Equal(0, lostFocusCallCount);
-
-        c.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.Equal(0, mouseDownCallCount);
-
-        c.OnMouseEnter(EventArgs.Empty);
-        Assert.Equal(0, mouseEnterCallCount);
-
-        c.OnMouseHover(EventArgs.Empty);
-        Assert.Equal(0, mouseHoverCallCount);
-
-        c.OnMouseLeave(EventArgs.Empty);
-        Assert.Equal(0, mouseLeaveCallCount);
-
-        c.OnMouseMove(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.Equal(0, mouseMoveCallCount);
-
-        c.OnMouseUp(new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0));
-        Assert.Equal(0, mouseUpCallCount);
-
-        Assert.Equal(expectedResult, c.AccessibilityObject.GetHelpTopic(out string fileName));
-        Assert.Null(fileName);
-        Assert.Equal(0, queryAccessibilityHelpCallCount);
-
-        c.OnQueryContinueDrag(new QueryContinueDragEventArgs(0, false, DragAction.Cancel));
-        Assert.Equal(0, queryContinueDragCallCount);
-
-        using var image = new Bitmap(10, 10);
-        var graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-        c.OnPaint(eventArgs);
-        Assert.Equal(0, paintCallCount);
-
-        c.OnResize(EventArgs.Empty);
-        Assert.Equal(Size.Empty, c.Size);
-
-        c.Size = new Size(10, 20);
-        Assert.Equal(new Size(10, 20), c.Size);
-
-        c.OnRightToLeftChanged(EventArgs.Empty);
-        Assert.Equal(0, rightToLeftChangedCallCount);
-
-        c.OnTextChanged(EventArgs.Empty);
-        Assert.Equal(0, textChangedCallCount);
-
-        c.OnValidated(EventArgs.Empty);
-        Assert.Equal(0, validatedCallCount);
-
-        c.OnValidating(new CancelEventArgs());
-        Assert.Equal(0, validatingCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_OnUnsubscribeControlEvents_InvokeNullControl_Nop()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.OnUnsubscribeControlEvents(null);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripControlHost_OnValidated_Invoke_CallsValidated(EventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Validated += handler;
-        item.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.Validated -= handler;
-        item.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CancelEventArgs_TestData))]
-    public void ToolStripControlHost_OnValidating_Invoke_CallsValidating(CancelEventArgs eventArgs)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        CancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Validating += handler;
-        item.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.Validating -= handler;
-        item.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripControlHost_ProcessCmdKey_Invoke_ReturnsFalse(Keys keyData)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        var m = new Message();
-        Assert.False(item.ProcessCmdKey(ref m, keyData));
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    public void ToolStripControlHost_ProcessCmdKey_InvokeWithCustomControl_ReturnsFalse(Keys keyData, bool result)
-    {
-        int callCount = 0;
-        bool action(Message actualMsg, Keys actualKeyData)
-        {
-            callCount++;
-            return result;
-        }
-
-        using var c = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = action
-        };
-        using var item = new SubToolStripControlHost(c);
-        var m = new Message
-        {
-            Msg = 1
-        };
-        Assert.False(item.ProcessCmdKey(ref m, keyData));
-        Assert.Equal(0, callCount);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripControlHost_ProcessCmdKey_InvokeDisposed_ReturnsFalse(Keys keyData)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        var m = new Message();
-        Assert.False(item.ProcessCmdKey(ref m, keyData));
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripControlHost_ProcessDialogKey_Invoke_ReturnsFalse(Keys keyData)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-
-        Assert.False(item.ProcessDialogKey(keyData));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    public void ToolStripControlHost_ProcessDialogKey_InvokeWithCustomControl_ReturnsFalse(Keys keyData, bool result)
-    {
-        int callCount = 0;
-        bool action(Keys actualKeyData)
-        {
-            callCount++;
-            return result;
-        }
-
-        using var c = new CustomProcessControl
-        {
-            ProcessDialogKeyAction = action
-        };
-        using var item = new SubToolStripControlHost(c);
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-
-        Assert.False(item.ProcessDialogKey(keyData));
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, callCount);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripControlHost_ProcessDialogKey_InvokeDisposed_ReturnsFalse(Keys keyData)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-
-        Assert.False(item.ProcessDialogKey(keyData));
-        Assert.Equal(0, clickCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a')]
-    [InlineData(char.MinValue)]
-    public void ToolStripControlHost_ProcessMnemonic_Invoke_ReturnsFalse(char charCode)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-
-        Assert.False(item.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData('a', true)]
-    [InlineData('a', false)]
-    public void ToolStripControlHost_ProcessMnemonic_InvokeWithCustomControl_ReturnsExpected(char charCode, bool result)
-    {
-        int callCount = 0;
-        bool action(char actualCharCode)
-        {
-            Assert.Equal(charCode, actualCharCode);
-            callCount++;
-            return result;
-        }
-
-        using var c = new CustomProcessControl
-        {
-            ProcessMnemonicAction = action
-        };
-        using var item = new SubToolStripControlHost(c);
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-
-        Assert.Equal(result, item.ProcessMnemonic(charCode));
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(1, callCount);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripControlHost_ProcessMnemonic_InvokeDisposed_ThrowsObjectDisposedException(bool enabled)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled
-        };
-        item.Dispose();
-
-        int clickCallCount = 0;
-        item.Click += (sender, e) => clickCallCount++;
-        Assert.Throws<ObjectDisposedException>(() => item.ProcessMnemonic('a'));
-        Assert.Equal(0, clickCallCount);
-        Assert.False(item.Pressed);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<Keys, bool> ProcessDialogKeyAction { get; set; }
-
-        protected override bool ProcessDialogKey(Keys keyData) => ProcessDialogKeyAction(keyData);
-
-        public Func<char, bool> ProcessMnemonicAction { get; set; }
-
-        protected internal override bool ProcessMnemonic(char charCode) => ProcessMnemonicAction(charCode);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ResetBackColor_Invoke_Success()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-
-        // Reset without value.
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Equal(Control.DefaultBackColor, c.BackColor);
-
-        // Reset with value.
-        item.BackColor = Color.Black;
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Equal(Control.DefaultBackColor, c.BackColor);
-
-        // Reset again.
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Equal(Control.DefaultBackColor, c.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ResetBackColor_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.ResetBackColor());
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ResetForeColor_Invoke_Success()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-
-        // Reset without value.
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(Control.DefaultForeColor, c.ForeColor);
-
-        // Reset with value.
-        item.ForeColor = Color.Black;
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(Control.DefaultForeColor, c.ForeColor);
-
-        // Reset again.
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(Control.DefaultForeColor, c.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_ResetForeColor_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        item.Dispose();
-
-        Assert.Throws<ObjectDisposedException>(() => item.ResetForeColor());
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripControlHost_SetVisibleCore_Invoke_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c)
-        {
-            Enabled = enabled,
-            Image = image
-        };
-
-        item.SetVisibleCore(value);
-        Assert.Equal(value, c.Visible);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(c.IsHandleCreated);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.Equal(value, c.Visible);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(c.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, c.Visible);
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(c.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_SetVisibleCore_InvokeWithHandler_CallsAvailableChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.AvailableChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripControlHost_SetVisibleCore_InvokeWithHandler_CallsVisibleChanged()
-    {
-        using var c = new Control();
-        using var item = new SubToolStripControlHost(c);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.VisibleChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    private class SubControl : Control
-    {
-        public new void CreateControl() => base.CreateControl();
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDragDrop(DragEventArgs e) => base.OnDragDrop(e);
-
-        public new void OnDragEnter(DragEventArgs e) => base.OnDragEnter(e);
-
-        public new void OnDragLeave(EventArgs e) => base.OnDragLeave(e);
-
-        public new void OnDragOver(DragEventArgs e) => base.OnDragOver(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnGiveFeedback(GiveFeedbackEventArgs e) => base.OnGiveFeedback(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnLocationChanged(EventArgs e) => base.OnLocationChanged(e);
-
-        public new void OnLostFocus(EventArgs e) => base.OnLostFocus(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseHover(EventArgs e) => base.OnMouseHover(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnQueryContinueDrag(QueryContinueDragEventArgs e) => base.OnQueryContinueDrag(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new void OnValidated(EventArgs e) => base.OnValidated(e);
-
-        public new void OnValidating(CancelEventArgs e) => base.OnValidating(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-    }
-
-    private class SubToolStripControlHost : ToolStripControlHost
-    {
-        public SubToolStripControlHost(Control c) : base(c)
-        {
-        }
-
-        public SubToolStripControlHost(Control c, string name) : base(c, name)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new void OnBoundsChanged() => base.OnBoundsChanged();
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnGotFocus(EventArgs e) => base.OnGotFocus(e);
-
-        public new void OnHostedControlResize(EventArgs e) => base.OnHostedControlResize(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnLostFocus(EventArgs e) => base.OnLostFocus(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnParentChanged(ToolStrip oldParent, ToolStrip newParent) => base.OnParentChanged(oldParent, newParent);
-
-        public new void OnSubscribeControlEvents(Control control) => base.OnSubscribeControlEvents(control);
-
-        public new void OnUnsubscribeControlEvents(Control control) => base.OnUnsubscribeControlEvents(control);
-
-        public new void OnValidated(EventArgs e) => base.OnValidated(e);
-
-        public new void OnValidating(CancelEventArgs e) => base.OnValidating(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void SetVisibleCore(bool visible) => base.SetVisibleCore(visible);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDown.ToolStripDropDownAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDown.ToolStripDropDownAccessibleObjectTests.cs
deleted file mode 100644
index 62c02265355..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDown.ToolStripDropDownAccessibleObjectTests.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripDropDown;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDown_ToolStripDropDownAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDownAccessibleObject_ctor_default()
-    {
-        using ToolStripDropDown toolStripDropDown = new ToolStripDropDown();
-        ToolStripDropDownAccessibleObject accessibleObject = new ToolStripDropDownAccessibleObject(toolStripDropDown);
-
-        Assert.Equal(toolStripDropDown, accessibleObject.Owner);
-        Assert.False(toolStripDropDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownAccessibleObject_ControlType_IsMenu_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripDropDown toolStripDropDown = new ToolStripDropDown();
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = toolStripDropDown.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.MenuControlTypeId, actual);
-        Assert.False(toolStripDropDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownAccessibleObject_Role_IsMenuPopup_ByDefault()
-    {
-        using ToolStripDropDown toolStripDropDown = new ToolStripDropDown();
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = toolStripDropDown.AccessibilityObject;
-        AccessibleRole actual = accessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuPopup, actual);
-        Assert.False(toolStripDropDown.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripDropDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripDropDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripDropDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripDropDown toolStripDropDown = new ToolStripDropDown();
-        toolStripDropDown.AccessibleRole = role;
-
-        AccessibleObject accessibleObject = toolStripDropDown.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(role, accessibleObject.Role);
-        Assert.Equal(expected, actual);
-        Assert.False(toolStripDropDown.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownButton.ToolStripDropDownButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownButton.ToolStripDropDownButtonAccessibleObjectTests.cs
deleted file mode 100644
index de695c6cb2d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownButton.ToolStripDropDownButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripDropDownButton;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDownButton_ToolStripDropDownButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDownButtonAccessibleObject_Ctor_Default()
-    {
-        using ToolStripDropDownButton toolStripDropDownButton = new ToolStripDropDownButton();
-        ToolStripDropDownButtonAccessibleObject accessibleObject = new ToolStripDropDownButtonAccessibleObject(toolStripDropDownButton);
-
-        Assert.Equal(toolStripDropDownButton, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownButtonAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripDropDownButton toolStripDropDownButton = new ToolStripDropDownButton();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripDropDownButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownButtonAccessibleObject_Role_IsMenuItem_ByDefault()
-    {
-        using ToolStripDropDownButton toolStripDropDownButton = new ToolStripDropDownButton();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripDropDownButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuItem, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripDropDownButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripDropDownButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripDropDownButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripDropDownButton toolStripDropDownButton = new ToolStripDropDownButton();
-        toolStripDropDownButton.AccessibleRole = role;
-
-        object actual = toolStripDropDownButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownButtonAccessibleObject_FragmentNavigate_Child_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new();
-
-        using ToolStripDropDownButton dropDownItem = new ToolStripDropDownButton();
-        dropDownItem.DropDownItems.Add(string.Empty);
-
-        toolStrip.Items.Add(dropDownItem);
-
-        toolStrip.CreateControl();
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        dropDownItem.DropDown.Show();
-
-        AccessibleObject expected = dropDownItem.DropDown.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosedEventArgsTests.cs
deleted file mode 100644
index d27801b6238..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosedEventArgsTests.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ToolStripDropDownClosedEventArgsTests
-{
-    [Theory]
-    [InlineData(ToolStripDropDownCloseReason.AppClicked)]
-    [InlineData((ToolStripDropDownCloseReason)(ToolStripDropDownCloseReason.AppFocusChange - 1))]
-    public void Ctor_CloseReason(ToolStripDropDownCloseReason closeReason)
-    {
-        var e = new ToolStripDropDownClosedEventArgs(closeReason);
-        Assert.Equal(closeReason, e.CloseReason);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosingEventArgsTests.cs
deleted file mode 100644
index 2d93e15e57d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownClosingEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class ToolStripDropDownClosingEventArgsTests
-{
-    [Theory]
-    [InlineData(ToolStripDropDownCloseReason.AppClicked)]
-    [InlineData((ToolStripDropDownCloseReason)(ToolStripDropDownCloseReason.AppFocusChange - 1))]
-    public void Ctor_CloseReason(ToolStripDropDownCloseReason closeReason)
-    {
-        var e = new ToolStripDropDownClosingEventArgs(closeReason);
-        Assert.Equal(closeReason, e.CloseReason);
-        Assert.False(e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemAccessibleObjectTests.cs
deleted file mode 100644
index 1b8502a4a7f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,225 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDownItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_Ctor_OwnerToolStripDropDownItemCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripDropDownItemAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_Ctor_Default()
-    {
-        using SubToolStripDropDownItem control = new();
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(control, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_Role_ReturnsExpected_ControlHasDefaultRole()
-    {
-        using SubToolStripDropDownItem control = new();
-        control.AccessibleRole = AccessibleRole.Default;
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(AccessibleRole.MenuItem, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_Role_ReturnsExpected_ControlHasNotDefaultRole()
-    {
-        AccessibleRole testRole = AccessibleRole.Cell;
-        using SubToolStripDropDownItem control = new();
-        control.AccessibleRole = testRole;
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(testRole, accessibleObject.Role);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        using SubToolStripDropDownItem control = new();
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)ExpandCollapseState.Collapsed))]
-    [InlineData(true, ((int)ExpandCollapseState.Expanded))]
-    public void ToolStripDropDownItemAccessibleObject_ExpandCollapseState_ReturnsExpected(bool visible, int expected)
-    {
-        using SubToolStripDropDownItem control = new();
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-        control.DropDown.Items.Add(new SubToolStripDropDownItem());
-        control.DropDown.Visible = visible;
-
-        Assert.Equal((ExpandCollapseState)expected, accessibleObject.ExpandCollapseState);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildCount_ReturnsExpected_IfNoDropDownItems()
-    {
-        using SubToolStripDropDownItem control = new();
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildCount_ReturnsExpected_IfCollapsed()
-    {
-        using SubToolStripDropDownItem control = new();
-        control.DropDown.Items.Add(new SubToolStripDropDownItem());
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildCount_ReturnsExpected()
-    {
-        int testCount = 2;
-        using SubToolStripDropDownItem control = new();
-        for (int i = 0; i < testCount; i++)
-        {
-            control.DropDown.Items.Add(new SubToolStripDropDownItem() { Available = true });
-        }
-
-        control.DropDown.Visible = true;
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(testCount, accessibleObject.GetChildCount());
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildCount_ReturnsNull_IfNoDropDownItems()
-    {
-        using SubToolStripDropDownItem control = new();
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(0));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChild_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        using SubToolStripDropDownItem control = new();
-        using SubToolStripDropDownItem item1 = new() { Available = true };
-        using SubToolStripDropDownItem item2 = new() { Available = true };
-        control.DropDown.Items.AddRange(new[] { item1, item2 });
-
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(item1.AccessibilityObject, accessibleObject.GetChild(0));
-        Assert.Equal(item2.AccessibilityObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        using SubToolStripDropDownItem control = new();
-        using SubToolStripDropDownItem item1 = new();
-        using SubToolStripDropDownItem item2 = new();
-        using SubToolStripDropDownItem notItem = new();
-        control.DropDown.Items.AddRange(new[] { item1, item2 });
-
-        var accessibleObjectItem1 = (ToolStripDropDownItemAccessibleObject)item1.AccessibilityObject;
-        var accessibleObjectItem2 = (ToolStripDropDownItemAccessibleObject)item2.AccessibilityObject;
-        var accessibleObjectNotItem = (ToolStripDropDownItemAccessibleObject)notItem.AccessibilityObject;
-
-        Assert.Equal(accessibleObjectItem2, accessibleObjectItem1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObjectItem2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObjectNotItem.FragmentNavigate(NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        using SubToolStripDropDownItem control = new();
-        using SubToolStripDropDownItem item1 = new();
-        using SubToolStripDropDownItem item2 = new();
-        using SubToolStripDropDownItem notItem = new();
-        control.DropDown.Items.AddRange(new[] { item1, item2 });
-
-        var accessibleObjectItem1 = (ToolStripDropDownItemAccessibleObject)item1.AccessibilityObject;
-        var accessibleObjectItem2 = (ToolStripDropDownItemAccessibleObject)item2.AccessibilityObject;
-        var accessibleObjectNotItem = (ToolStripDropDownItemAccessibleObject)notItem.AccessibilityObject;
-
-        Assert.Null(accessibleObjectItem1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObjectItem1, accessibleObjectItem2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObjectNotItem.FragmentNavigate(NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildFragmentCount_ReturnsExpected()
-    {
-        int testCount = 2;
-        using SubToolStripDropDownItem control = new();
-        for (int i = 0; i < testCount; i++)
-        {
-            control.DropDownItems.Add(new SubToolStripDropDownItem() { Available = true });
-        }
-
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-        accessibleObject.GetChildCount();
-
-        Assert.Equal(testCount, accessibleObject.GetChildFragmentCount());
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_GetChildFragmentIndex_ReturnsExpected()
-    {
-        using NoAssertContext context = new();
-        using SubToolStripDropDownItem control = new();
-
-        using SubToolStripDropDownItem item1 = new() { Available = true };
-        using SubToolStripDropDownItem item2 = new() { Available = true };
-        using SubToolStripDropDownItem notItem = new();
-        control.DropDownItems.AddRange(new[] { item1, item2 });
-
-        var accessibleObject = (ToolStripDropDownItemAccessibleObject)control.AccessibilityObject;
-        var accessibleObjectItem1 = (ToolStripDropDownItemAccessibleObject)item1.AccessibilityObject;
-        var accessibleObjectItem2 = (ToolStripDropDownItemAccessibleObject)item2.AccessibilityObject;
-        var accessibleObjectNotItem = (ToolStripDropDownItemAccessibleObject)notItem.AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject.GetChildFragmentIndex(accessibleObjectItem1));
-        Assert.Equal(1, accessibleObject.GetChildFragmentIndex(accessibleObjectItem2));
-        Assert.Equal(-1, accessibleObject.GetChildFragmentIndex(accessibleObjectNotItem));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItemAccessibleObject_ReleaseUiaProvider_DropDown()
-    {
-        using NoAssertContext context = new();
-        using var toolStripDropDownItem = new SubToolStripDropDownItem();
-
-        _ = toolStripDropDownItem.AccessibilityObject;
-        _ = toolStripDropDownItem.DropDown.AccessibilityObject;
-
-        Assert.True(toolStripDropDownItem.DropDown.IsAccessibilityObjectCreated);
-
-        toolStripDropDownItem.ReleaseUiaProvider();
-
-        Assert.False(toolStripDropDownItem.DropDown.IsAccessibilityObjectCreated);
-    }
-
-    private class SubToolStripDropDownItem : ToolStripDropDownItem
-    {
-        public SubToolStripDropDownItem() : base() { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemTests.cs
deleted file mode 100644
index 0c16e397cf9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownItemTests.cs
+++ /dev/null
@@ -1,539 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemDropDownTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDownItem_Ctor_Default()
-    {
-        using var item = new SubToolStripDropDownItem();
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.Equal(ToolStripDropDownDirection.Default, item.DropDownDirection);
-        Assert.Equal(Point.Empty, item.DropDownLocation);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(item.HasDropDownItems);
-        Assert.False(item.HasDropDown);
-        Assert.Equal(23, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_TestData))]
-    public void ToolStripDropDownItem_Ctor_String_Image_EventHandler(string text, Image image, EventHandler onClick)
-    {
-        using var item = new SubToolStripDropDownItem(text, image, onClick);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.Equal(ToolStripDropDownDirection.Default, item.DropDownDirection);
-        Assert.Equal(Point.Empty, item.DropDownLocation);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(item.HasDropDownItems);
-        Assert.False(item.HasDropDown);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_Ctor_String_Image_EventHandler_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new SubToolStripDropDownItem("text", null, onClick);
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_String_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null, null, string.Empty };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick, string.Empty, string.Empty };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick, "name", "name" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_String_TestData))]
-    public void ToolStripDropDownItem_Ctor_String_Image_EventHandler_String(string text, Image image, EventHandler onClick, string name, string expectedName)
-    {
-        using var item = new SubToolStripDropDownItem(text, image, onClick, name);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.Equal(ToolStripDropDownDirection.Default, item.DropDownDirection);
-        Assert.Equal(Point.Empty, item.DropDownLocation);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(item.HasDropDownItems);
-        Assert.False(item.HasDropDown);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Equal(expectedName, item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_Ctor_String_Image_EventHandler_String_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new SubToolStripDropDownItem("text", null, onClick, "name");
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_ToolStripItemArray_TestData()
-    {
-        yield return new object[] { null, null, null, Array.Empty<ToolStripItem>() };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), Array.Empty<ToolStripItem>(), Array.Empty<ToolStripItem>() };
-
-        var items = new ToolStripItem[] { new SubToolStripItem() };
-        yield return new object[] { "text", new Bitmap(10, 10), items, items };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_ToolStripItemArray_TestData))]
-    public void ToolStripDropDownItem_Ctor_String_Image_ToolStripItemArray(string text, Image image, ToolStripItem[] dropDownItems, ToolStripItem[] expectedDropDownItems)
-    {
-        using var item = new SubToolStripDropDownItem(text, image, dropDownItems);
-        Assert.Equal(dropDownItems is not null, item.HasDropDown);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.NotNull(item.DropDown);
-        Assert.Same(item.DropDown, item.DropDown);
-        Assert.True(item.DropDown.IsAutoGenerated);
-        Assert.True(item.DropDown.ShowItemToolTips);
-        Assert.Same(item, item.DropDown.OwnerItem);
-        Assert.Equal(ToolStripDropDownDirection.Default, item.DropDownDirection);
-        Assert.Equal(expectedDropDownItems, item.DropDownItems.Cast<ToolStripItem>());
-        Assert.Same(item.DropDownItems, item.DropDownItems);
-        Assert.True(item.HasDropDown);
-        Assert.Equal(Point.Empty, item.DropDownLocation);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(expectedDropDownItems.Length > 0, item.HasDropDownItems);
-        Assert.True(item.HasDropDown);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_DropDown_Get_ReturnsExpected()
-    {
-        using var item = new SubToolStripDropDownItem();
-        Assert.NotNull(item.DropDown);
-        Assert.Same(item.DropDown, item.DropDown);
-        Assert.True(item.DropDown.IsAutoGenerated);
-        Assert.True(item.DropDown.ShowItemToolTips);
-        Assert.Same(item, item.DropDown.OwnerItem);
-        Assert.True(item.HasDropDown);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDownItem_DropDown_GetWithOwner_ReturnsExpected(bool showItemToolTips)
-    {
-        using var owner = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripDropDownItem
-        {
-            Owner = owner
-        };
-        Assert.NotNull(item.DropDown);
-        Assert.Same(item.DropDown, item.DropDown);
-        Assert.True(item.DropDown.IsAutoGenerated);
-        Assert.True(item.DropDown.ShowItemToolTips);
-        Assert.Same(item, item.DropDown.OwnerItem);
-        Assert.True(item.HasDropDown);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDownItem_DropDown_GetWithParent_ReturnsExpected(bool showItemToolTips)
-    {
-        using var parent = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripDropDownItem
-        {
-            Parent = parent
-        };
-        Assert.NotNull(item.DropDown);
-        Assert.Same(item.DropDown, item.DropDown);
-        Assert.True(item.DropDown.IsAutoGenerated);
-        Assert.Equal(showItemToolTips, item.DropDown.ShowItemToolTips);
-        Assert.Same(item, item.DropDown.OwnerItem);
-        Assert.True(item.HasDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_DropDown_GetCustomCreateDefaultDropDown_ReturnsExpected()
-    {
-        using var result = new ToolStripDropDown();
-        using var item = new CustomCreateDefaultDropDownToolStripDropDownItem
-        {
-            CreateDefaultDropDownResult = result
-        };
-        Assert.NotNull(item.DropDown);
-        Assert.Same(item.DropDown, item.DropDown);
-        Assert.Same(result, item.DropDown);
-        Assert.True(result.IsAutoGenerated);
-        Assert.True(result.ShowItemToolTips);
-        Assert.Null(item.DropDown.OwnerItem);
-        Assert.True(item.HasDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_DropDown_GetNullCreateDefaultDropDown_ReturnsExpected()
-    {
-        using var item = new CustomCreateDefaultDropDownToolStripDropDownItem
-        {
-            CreateDefaultDropDownResult = null
-        };
-        Assert.Throws<NullReferenceException>(() => item.DropDown);
-        Assert.Throws<NullReferenceException>(() => item.DropDown);
-        Assert.False(item.HasDropDown);
-    }
-
-    private class CustomCreateDefaultDropDownToolStripDropDownItem : ToolStripDropDownItem
-    {
-        public ToolStripDropDown CreateDefaultDropDownResult { get; set; }
-
-        protected override ToolStripDropDown CreateDefaultDropDown() => CreateDefaultDropDownResult;
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownItem_DropDownItems_Get_ReturnsExpected()
-    {
-        using var item = new SubToolStripDropDownItem();
-        Assert.Empty(item.DropDownItems);
-        Assert.Same(item.DropDownItems, item.DropDownItems);
-        Assert.True(item.HasDropDown);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-    }
-
-    private class SubToolStripDropDownItem : ToolStripDropDownItem
-    {
-        public SubToolStripDropDownItem() : base()
-        {
-        }
-
-        public SubToolStripDropDownItem(string text, Image image, EventHandler onClick) : base(text, image, onClick)
-        {
-        }
-
-        public SubToolStripDropDownItem(string text, Image image, EventHandler onClick, string name) : base(text, image, onClick, name)
-        {
-        }
-
-        public SubToolStripDropDownItem(string text, Image image, params ToolStripItem[] dropDownItems) : base(text, image, dropDownItems)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ToolStripDropDown CreateDefaultDropDown() => base.CreateDefaultDropDown();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObjectTests.cs
deleted file mode 100644
index 564e0ffe2bc..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObjectTests.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDownMenu_ToolStripDropDownMenuAccessibleObjectTests
-{
-    public static IEnumerable<object[]> ToolStripDropDownMenuAccessible_FragmentNavigate_WithoutItem_TestData()
-    {
-        IEnumerable<Type> types = ReflectionHelper.GetPublicNotAbstractClasses<ToolStripDropDownItem>().Select(type => type);
-        foreach (Type itemType in types)
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                yield return new object[] { itemType, createControl };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripDropDownMenuAccessible_FragmentNavigate_WithoutItem_TestData))]
-    public void ToolStripDropDownMenuAccessible_FragmentNavigate_ReturnExpected_WithoutItem(Type itemType, bool createControl)
-    {
-        using ToolStrip toolStrip = new();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        using ToolStripDropDownItem item = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(itemType);
-        toolStrip.Items.Add(item);
-
-        AccessibleObject accessibleObject = item.DropDown.AccessibilityObject;
-
-        Assert.Equal(item.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Null(item.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(item.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ToolStripDropDownMenuAccessible_FragmentNavigate_ReturnExpected_WithoutItem_ToolStripOverflowButton(bool createControl)
-    {
-        using ToolStrip toolStrip = new();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        ToolStripOverflowButton item = toolStrip.OverflowButton;
-
-        AccessibleObject accessibleObject = item.DropDown.AccessibilityObject;
-
-        Assert.Equal(item.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Null(item.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(item.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(createControl, toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripDropDownMenuAccessible_FragmentNavigate_TestData()
-    {
-        IEnumerable<Type> types = ReflectionHelper.GetPublicNotAbstractClasses<ToolStripDropDownItem>().Select(type => type);
-        foreach (Type ownerType in types)
-        {
-            foreach (Type parentType in types)
-            {
-                foreach (Type childType in types)
-                {
-                    foreach (bool createControl in new[] { true, false })
-                    {
-                        yield return new object[] { ownerType, parentType, childType, createControl };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripDropDownMenuAccessible_FragmentNavigate_TestData))]
-    public void ToolStripDropDownMenuAccessible_FragmentNavigate_ReturnExpected(Type ownerType, Type parentType, Type childType, bool createControl)
-    {
-        using ToolStrip toolStrip = new();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        using ToolStripDropDownItem ownerItem = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(ownerType);
-        using ToolStripDropDownItem parentItem1 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(parentType);
-        using ToolStripDropDownItem parentItem2 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(parentType);
-        using ToolStripDropDownItem childItem1 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem2 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem3 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem4 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-
-        toolStrip.Items.Add(ownerItem);
-        ownerItem.DropDownItems.Add(parentItem1);
-        ownerItem.DropDownItems.Add(parentItem2);
-        parentItem1.DropDownItems.Add(childItem1);
-        parentItem1.DropDownItems.Add(childItem2);
-        parentItem2.DropDownItems.Add(childItem3);
-        parentItem2.DropDownItems.Add(childItem4);
-
-        ownerItem.DropDown.Show();
-        AccessibleObject accessibleObject = ownerItem.DropDown.AccessibilityObject;
-
-        Assert.Equal(ownerItem.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(parentItem1.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(parentItem2.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject, ownerItem.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, ownerItem.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        parentItem1.DropDown.Show();
-        AccessibleObject accessibleObject1 = parentItem1.DropDown.AccessibilityObject;
-
-        Assert.Equal(parentItem1.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(childItem1.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(childItem2.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject1, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject1, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject1, childItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject1, childItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        parentItem2.DropDown.Show();
-        AccessibleObject accessibleObject2 = parentItem2.DropDown.AccessibilityObject;
-
-        Assert.Equal(parentItem2.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(childItem3.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(childItem4.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject2, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject2, childItem3.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, childItem4.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        Assert.Equal(createControl, toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripDropDownMenuAccessible_FragmentNavigate_ToolStripOverflowButton_TestData()
-    {
-        IEnumerable<Type> types = ReflectionHelper.GetPublicNotAbstractClasses<ToolStripDropDownItem>().Select(type => type);
-        foreach (Type parentType in types)
-        {
-            foreach (Type childType in types)
-            {
-                foreach (bool createControl in new[] { true, false })
-                {
-                    yield return new object[] { parentType, childType };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripDropDownMenuAccessible_FragmentNavigate_ToolStripOverflowButton_TestData))]
-    public void ToolStripDropDownMenuAccessible_FragmentNavigate_ReturnExpected_ToolStripOverflowButton(Type parentType, Type childType)
-    {
-        using ToolStrip toolStrip = new();
-        toolStrip.CreateControl();
-
-        using ToolStripDropDownItem parentItem1 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(parentType);
-        using ToolStripDropDownItem parentItem2 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(parentType);
-        using ToolStripDropDownItem childItem1 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem2 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem3 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-        using ToolStripDropDownItem childItem4 = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(childType);
-
-        parentItem1.DropDownItems.Add(childItem1);
-        parentItem1.DropDownItems.Add(childItem2);
-        parentItem2.DropDownItems.Add(childItem3);
-        parentItem2.DropDownItems.Add(childItem4);
-
-        using ToolStripOverflowButton ownerItem = toolStrip.OverflowButton;
-        toolStrip.OverflowItems.Add(parentItem1);
-        toolStrip.OverflowItems.Add(parentItem2);
-
-        // ToolStripSplitStackLayout does it in runtime when Layout method is working.
-        // Use this way as a workaround in tests.
-        // It should be reset in the end of the test to avoid Dispose method errors.
-        parentItem1.ParentInternal = ownerItem.DropDown;
-        parentItem2.ParentInternal = ownerItem.DropDown;
-
-        ownerItem.DropDown.Show();
-        AccessibleObject accessibleObject = ownerItem.DropDown.AccessibilityObject;
-
-        Assert.Equal(ownerItem.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(parentItem1.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(parentItem2.AccessibilityObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject, ownerItem.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject, ownerItem.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        parentItem1.DropDown.Show();
-        AccessibleObject accessibleObject1 = parentItem1.DropDown.AccessibilityObject;
-
-        Assert.Equal(parentItem1.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(childItem1.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(childItem2.AccessibilityObject, accessibleObject1.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject1, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject1, parentItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject1, childItem1.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject1, childItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        parentItem2.DropDown.Show();
-        AccessibleObject accessibleObject2 = parentItem2.DropDown.AccessibilityObject;
-
-        Assert.Equal(parentItem2.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(childItem3.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(childItem4.AccessibilityObject, accessibleObject2.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject2, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject2, parentItem2.AccessibilityObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.Equal(accessibleObject2, childItem3.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(accessibleObject2, childItem4.AccessibilityObject.FragmentNavigate(NavigateDirection.Parent));
-
-        // Reset the parent to avoid errors when disposing.
-        parentItem1.ParentInternal = null;
-        parentItem2.ParentInternal = null;
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsControlElement_ReturnsExpected_InToolStripMenuItem()
-    {
-        using ToolStripMenuItem menuItem = new();
-
-        ToolStripDropDown dropDown = menuItem.DropDown;
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)dropDown.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsControlElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsControlElement_ReturnsExpected_InToolStripDropDownButton()
-    {
-        using ToolStripDropDownButton dropDownButton = new();
-
-        ToolStripDropDown dropDown = dropDownButton.DropDown;
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)dropDown.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsControlElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsControlElement_ReturnsExpected_InContextMenuStrip()
-    {
-        using ContextMenuStrip contextMenu = new();
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)contextMenu.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsControlElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsContentElement_ReturnsExpected_InToolStripMenuItem()
-    {
-        using ToolStripMenuItem menuItem = new();
-
-        ToolStripDropDown dropDown = menuItem.DropDown;
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)dropDown.AccessibilityObject;
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.IsContentElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsContentElement_ReturnsExpected_InToolStripDropDownButton()
-    {
-        using ToolStripDropDownButton dropDownButton = new();
-
-        ToolStripDropDown dropDown = dropDownButton.DropDown;
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)dropDown.AccessibilityObject;
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UIA.IsContentElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenuAccessible_GetPropertyValue_IsContentElement_ReturnsExpected_InContextMenuStrip()
-    {
-        using ContextMenuStrip contextMenu = new();
-
-        ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject accessibleObject = (ToolStripDropDownMenu.ToolStripDropDownMenuAccessibleObject)contextMenu.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsContentElementPropertyId));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownTests.cs
deleted file mode 100644
index a92137976e9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripDropDownTests.cs
+++ /dev/null
@@ -1,5122 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDownTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDown_Ctor_Default()
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.AllowMerge);
-        Assert.False(control.AllowTransparency);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.True(control.AutoClose);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(25, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanOverflow);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.False(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.ClientRectangle);
-        Assert.Equal(new Size(100, 25), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(DockStyle.None, control.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(new Padding(1, 2, 1, 2), control.DefaultPadding);
-        Assert.Equal(new Size(100, 25), control.DefaultSize);
-        Assert.True(control.DefaultShowItemToolTips);
-        Assert.False(control.DesignMode);
-        Assert.Empty(control.DisplayedItems);
-        Assert.Same(control.DisplayedItems, control.DisplayedItems);
-        Assert.Equal(new Rectangle(1, 2, 98, 21), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.NotNull(control.DockPadding);
-        Assert.Same(control.DockPadding, control.DockPadding);
-        Assert.Equal(2, control.DockPadding.Top);
-        Assert.Equal(2, control.DockPadding.Bottom);
-        Assert.Equal(1, control.DockPadding.Left);
-        Assert.Equal(1, control.DockPadding.Right);
-        Assert.True(control.DoubleBuffered);
-        Assert.Equal(SystemInformation.IsDropShadowEnabled, control.DropShadowEnabled);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Hidden, control.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Horizontal, control.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.GripMargin);
-        Assert.Equal(Rectangle.Empty, control.GripRectangle);
-        Assert.False(control.HasChildren);
-        Assert.Equal(25, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Null(control.ImageList);
-        Assert.Equal(new Size(16, 16), control.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsAutoGenerated);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.True(control.IsDropDown);
-        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.IsType<FlowLayoutSettings>(control.LayoutSettings);
-        Assert.Same(control.LayoutSettings, control.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.Flow, control.LayoutStyle);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(Screen.GetWorkingArea(new Rectangle(0, 0, 100, 25)).Size - new Size(2, 4), control.MaxItemSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.Equal(1, control.Opacity);
-        Assert.NotNull(control.OverflowButton);
-        Assert.Same(control.OverflowButton, control.OverflowButton);
-        Assert.Same(control, control.OverflowButton.GetCurrentParent());
-        Assert.Null(control.OwnerItem);
-        Assert.Equal(new Padding(1, 2, 1, 2), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(SystemInformation.WorkingArea.X + 2, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(2, 4), control.Size);
-        Assert.False(control.Stretch);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, control.TextDirection);
-        Assert.Equal(0, control.Top);
-        Assert.True(control.TopMost);
-        Assert.True(control.TopLevel);
-        Assert.Same(control, control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(2, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubToolStripDropDown();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(SystemInformation.IsDropShadowEnabled ? 0x20808 : 0x808, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(25, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(-0x7E000000, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CreateParams_GetDropShadowEnabled_TestData()
-    {
-        yield return new object[] { true, SystemInformation.IsDropShadowEnabled ? 0x20808 : 0x808 };
-        yield return new object[] { false, 0x808 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateParams_GetDropShadowEnabled_TestData))]
-    public void ToolStripDropDown_CreateParams_GetDropShadowEnabled_ReturnsExpected(bool dropShadowEnabled, int expectedClassStyle)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            DropShadowEnabled = dropShadowEnabled
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(expectedClassStyle, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(25, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(-0x7E000000, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> CreateParams_GetTopLevelOpacity_TestData()
-    {
-        yield return new object[] { true, 1.0, SystemInformation.IsDropShadowEnabled ? 0x20808 : 0x808, -0x7E000000, 0x10000 };
-        yield return new object[] { true, 0.5, SystemInformation.IsDropShadowEnabled ? 0x20008 : 0x8, -0x7E000000, 0x90000 };
-        yield return new object[] { false, 1.0, SystemInformation.IsDropShadowEnabled ? 0x20008 : 0x8, 0x46000000, 0x10000 };
-        yield return new object[] { false, 0.5, SystemInformation.IsDropShadowEnabled ? 0x20008 : 0x8, 0x46000000, 0x10000 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateParams_GetTopLevelOpacity_TestData))]
-    public void ToolStripDropDown_CreateParams_GetTopLevelOpacity_ReturnsExpected(bool topLevel, float opacity, int expectedClassStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            TopLevel = topLevel,
-            Opacity = opacity
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(expectedClassStyle, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(25, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AllowItemReorder_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            AllowItemReorder = value
-        };
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [Fact] // x-thread
-    public void ToolStripDropDown_AllowItemReorder_SetWithHandleNonSTAThread_ThrowsInvalidOperationException()
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<InvalidOperationException>(() => control.AllowItemReorder = true);
-        Assert.True(control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Can set to false.
-        control.AllowItemReorder = false;
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AllowItemReorder_SetWithHandleSTA_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_AllowItemReorder_SetAllowDrop_ThrowsArgumentException()
-    {
-        using var control = new ToolStripDropDown
-        {
-            AllowDrop = true
-        };
-        Assert.Throws<ArgumentException>(() => control.AllowItemReorder = true);
-        Assert.False(control.AllowItemReorder);
-
-        control.AllowItemReorder = false;
-        Assert.False(control.AllowItemReorder);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AllowTransparency_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> AllowTransparency_SetWithOpacity_TestData()
-    {
-        yield return new object[] { true, 0.5 };
-        yield return new object[] { false, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowTransparency_SetWithOpacity_TestData))]
-    public void ToolStripDropDown_AllowTransparency_SetWithOpacity_GetReturnsExpected(bool value, float expectedOpacity)
-    {
-        using var control = new ToolStripDropDown
-        {
-            Opacity = 0.5,
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AllowTransparency_SetNotTopLevel_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            AllowTransparency = value
-        };
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripDropDown_AllowTransparency_SetWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AllowTransparency_SetWithOpacityWithHandle_TestData()
-    {
-        yield return new object[] { true, 0.5, 0 };
-        yield return new object[] { false, 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AllowTransparency_SetWithOpacityWithHandle_TestData))]
-    public void ToolStripDropDown_AllowTransparency_SetWithOpacityWithHandle_GetReturnsExpected(bool value, float expectedOpacity, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown
-        {
-            Opacity = 0.5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(expectedOpacity, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripDropDown_AllowTransparency_SetNotTopLevelWithHandle_GetReturnsExpected(bool value, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowTransparency = value;
-        Assert.Equal(value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowTransparency = !value;
-        Assert.Equal(!value, control.AllowTransparency);
-        Assert.Equal(1, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Anchor_Set_TestData()
-    {
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.None, AnchorStyles.None, DockStyle.None };
-        yield return new object[] { (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void ToolStripDropDown_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected, DockStyle expectedDock)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AutoClose_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            AutoClose = value
-        };
-        Assert.Equal(value, control.AutoClose);
-        Assert.Equal(!value, control.IsHandleCreated);
-
-        // Set same.
-        control.AutoClose = value;
-        Assert.Equal(value, control.AutoClose);
-        Assert.Equal(!value, control.IsHandleCreated);
-
-        // Set different.
-        control.AutoClose = !value;
-        Assert.Equal(!value, control.AutoClose);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_AutoClose_SetNotTopMost_GetReturnsExpected(bool value)
-    {
-        using var control = new NotTopMostToolStripDropDown
-        {
-            AutoClose = value
-        };
-        Assert.Equal(value, control.AutoClose);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoClose = value;
-        Assert.Equal(value, control.AutoClose);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoClose = !value;
-        Assert.Equal(!value, control.AutoClose);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ToolStripDropDown_AutoSize_Set_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0, 0)]
-    [InlineData(false, 1, 2)]
-    public void ToolStripDropDown_AutoSize_SetWithParent_GetReturnsExpected(bool value, int expectedLayoutCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new ToolStripDropDown
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void ToolStripDropDown_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripDropDown_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.True(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.True(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> BindingContext_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new BindingContext() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void ToolStripDropDown_BindingContext_Set_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            BindingContext = value
-        };
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_BindingContext_SetWithHandler_CallsBindingContextChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_CanOverflow_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripDropDown_CanOverflow_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void ToolStripDropDown_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ContextMenuStrip = value;
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_ContextMenuStrip_SetWithHandler_CallsContextMenuStripChanged()
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ContextMenuStripChanged += handler;
-
-        // Set different.
-        using var menu1 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu2;
-        Assert.Same(menu2, control.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.ContextMenuStrip = null;
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.ContextMenuStripChanged -= handler;
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_Get_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Get_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_Get_ReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStripDropDown
-        {
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Get_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_GetDesignMode_ReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new ToolStripDropDown
-        {
-            Site = mockSite.Object,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_GetWithParent_TestData()
-    {
-        foreach (DockStyle parentDock in new object[] { DockStyle.None, DockStyle.Left, DockStyle.Right, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetWithParent_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_GetWithParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        using var parent = new Control
-        {
-            Dock = parentDock
-        };
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            Parent = parent,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetWithParent_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_GetDesignModeWithParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var parent = new Control
-        {
-            Dock = parentDock
-        };
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            Parent = parent,
-            Site = mockSite.Object,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_Set_TestData()
-    {
-        yield return new object[] { ToolStripDropDownDirection.AboveLeft, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripDropDownDirection.AboveRight, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripDropDownDirection.BelowLeft, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripDropDownDirection.BelowRight, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripDropDownDirection.Default, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripDropDownDirection.Left, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripDropDownDirection.Right, ToolStripDropDownDirection.Right };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Set_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_Set_GetReturnsExpected(ToolStripDropDownDirection value, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStripDropDown
-        {
-            DefaultDropDownDirection = value
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Set_TestData))]
-    public void ToolStripDropDown_DefaultDropDownDirection_SetWithHandle_GetReturnsExpected(ToolStripDropDownDirection value, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_DefaultDropDownDirection_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.DefaultDropDownDirection)];
-        using var control = new ToolStripDropDown();
-        Assert.False(property.CanResetValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Right;
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_DefaultDropDownDirection_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.DefaultDropDownDirection)];
-        using var control = new ToolStripDropDown();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Right;
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Default;
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripDropDownDirection>]
-    public void ToolStripDropDown_DefaultDropDownDirection_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripDropDownDirection value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DefaultDropDownDirection = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_Get_ReturnsSame()
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotSame(Control.DefaultFont, control.Font);
-        Assert.Same(control.Font, control.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_GetWithParent_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new Control
-        {
-            Font = font1
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.NotSame(font1, control.Font);
-        Assert.Same(control.Font, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            Font = font1
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.NotSame(Control.DefaultFont, control.Font);
-        Assert.Same(control.Font, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ToolStripDropDown_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_SetWithItemsWithHandler_CallsFontChanged()
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new ToolStripDropDown();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(font2, item1.Font);
-        Assert.Same(font2, item2.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(Control.DefaultFont, item1.Font);
-        Assert.Equal(Control.DefaultFont, item2.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Font_SetWithItemsWithFontWithHandler_CallsFontChanged()
-    {
-        using var childFont1 = new Font("Arial", 1);
-        using var childFont2 = new Font("Arial", 1);
-        using var child1 = new SubToolStripItem
-        {
-            Font = childFont1
-        };
-        using var child2 = new SubToolStripItem
-        {
-            Font = childFont2
-        };
-        using var control = new ToolStripDropDown();
-        control.Items.Add(child1);
-        control.Items.Add(child2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripDropDown_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ToolStripDropDown
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripDropDown_GripMargin_Set_GetReturnsExpected(Padding value)
-    {
-        using var control = new ToolStripDropDown();
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 0)]
-    [InlineData(ToolStripGripStyle.Visible, 1)]
-    public void ToolStripDropDown_GripStyle_Set_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        Assert.Empty(control.DisplayedItems);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripGripStyle>]
-    public void ToolStripDropDown_GripStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripGripStyle value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.GripStyle = value);
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void ToolStripDropDown_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new ToolStripDropDown
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void ToolStripDropDown_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void ToolStripDropDown_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    public static IEnumerable<object[]> Location_Set_TestData()
-    {
-        yield return new object[] { new Point(0, 0), new Point(0, 0), 0 };
-        yield return new object[] { new Point(-1, -2), new Point(0, 0), 0 };
-        yield return new object[] { new Point(1, 0), new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Location_Set_TestData))]
-    public void ToolStripDropDown_Location_Set_GetReturnsExpected(Point value, Point expected, int expectedLocationChangedCallCount)
-    {
-        if (value != Point.Empty)
-        {
-            expected.X = Math.Max(expected.X, SystemInformation.WorkingArea.X);
-            expected.Y = Math.Max(expected.Y, SystemInformation.WorkingArea.Y);
-
-            if (expectedLocationChangedCallCount == 0 && SystemInformation.WorkingArea.Location != Point.Empty)
-                expectedLocationChangedCallCount = 1;
-        }
-
-        using var control = new ToolStripDropDown();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) => layoutCallCount++;
-        control.Resize += (sender, e) => resizeCallCount++;
-        control.SizeChanged += (sender, e) => sizeChangedCallCount++;
-        control.ClientSizeChanged += (sender, e) => clientSizeChangedCallCount++;
-
-        control.Location = value;
-        Assert.Equal(new Size(100, 25), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.ClientRectangle);
-        Assert.Equal(new Rectangle(1, 2, 98, 21), control.DisplayRectangle);
-        Assert.Equal(new Size(100, 25), control.Size);
-        Assert.Equal(expected.X, control.Left);
-        Assert.Equal(expected.X + 100, control.Right);
-        Assert.Equal(expected, control.Location);
-        Assert.Equal(expected.Y, control.Top);
-        Assert.Equal(expected.Y + 25, control.Bottom);
-        Assert.Equal(100, control.Width);
-        Assert.Equal(25, control.Height);
-        Assert.Equal(new Rectangle(expected.X, expected.Y, 100, 25), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Location = value;
-        Assert.Equal(new Size(100, 25), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.ClientRectangle);
-        Assert.Equal(new Rectangle(1, 2, 98, 21), control.DisplayRectangle);
-        Assert.Equal(new Size(100, 25), control.Size);
-        Assert.Equal(expected.X, control.Left);
-        Assert.Equal(expected.X + 100, control.Right);
-        Assert.Equal(expected, control.Location);
-        Assert.Equal(expected.Y, control.Top);
-        Assert.Equal(expected.Y + 25, control.Bottom);
-        Assert.Equal(100, control.Width);
-        Assert.Equal(25, control.Height);
-        Assert.Equal(new Rectangle(expected.X, expected.Y, 100, 25), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.Equal(0, resizeCallCount);
-        Assert.Equal(0, sizeChangedCallCount);
-        Assert.Equal(0, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Opacity_Set_TestData()
-    {
-        foreach (bool allowTransparency in new bool[] { true, false })
-        {
-            yield return new object[] { allowTransparency, 1.1, 1.0, allowTransparency };
-            yield return new object[] { allowTransparency, 1.0, 1.0, allowTransparency };
-            yield return new object[] { allowTransparency, 0.5, 0.5, true };
-            yield return new object[] { allowTransparency, 0, 0, true };
-            yield return new object[] { allowTransparency, -0.1, 0, true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_Set_TestData))]
-    public void ToolStripDropDown_Opacity_Set_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency)
-    {
-        using var control = new ToolStripDropDown
-        {
-            AllowTransparency = allowTransparency,
-            Opacity = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_Set_TestData))]
-    public void ToolStripDropDown_Opacity_SetTopLevel_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            AllowTransparency = allowTransparency,
-            Opacity = value
-        };
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetNotTransparentWithHandle_TestData()
-    {
-        yield return new object[] { true, 1.1, 1.0, 1 };
-        yield return new object[] { true, 1.0, 1.0, 1 };
-        yield return new object[] { false, 1.1, 1.0, 0 };
-        yield return new object[] { false, 1.0, 1.0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetNotTransparentWithHandle_TestData))]
-    public void ToolStripDropDown_Opacity_SetNotTransparentWithHandle_GetReturnsExpected(bool allowTransparency, double value, double expected, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = allowTransparency;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(allowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0.5, 0.5, 0)]
-    [InlineData(0, 0, 0)]
-    [InlineData(-0.1, 0, 0)]
-    public void ToolStripDropDown_Opacity_SetTransparentWithHandleSetAllowTransparencyBefore_GetReturnsExpected(float value, float expected, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown
-        {
-            AllowTransparency = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetTransparentWithHandle_TestData()
-    {
-        yield return new object[] { true, 0.5, 0.5, 0 };
-        yield return new object[] { true, 0, 0, 0 };
-        yield return new object[] { true, -0.1, -0, 0 };
-
-        yield return new object[] { false, 0.5, 0.5, 2 };
-        yield return new object[] { false, 0, 0, 2 };
-        yield return new object[] { false, -0.1, -0, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetTransparentWithHandle_TestData))]
-    public void ToolStripDropDown_Opacity_SetTransparentWithHandleSetAllowTransparencyAfter_GetReturnsExpected(bool allowTransparency, float value, float expected, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.AllowTransparency = allowTransparency;
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Opacity = value;
-        Assert.True(control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Opacity_SetTopLevelWithHandle_TestData()
-    {
-        yield return new object[] { true, 1.1, 1.0, true, 1 };
-        yield return new object[] { true, 1.0, 1.0, true, 1 };
-        yield return new object[] { true, 0.5, 0.5, true, 0 };
-        yield return new object[] { true, 0, 0, true, 0 };
-        yield return new object[] { true, -0.1, 0, true, 0 };
-
-        yield return new object[] { false, 1.1, 1.0, false, 0 };
-        yield return new object[] { false, 1.0, 1.0, false, 0 };
-        yield return new object[] { false, 0.5, 0.5, true, 2 };
-        yield return new object[] { false, 0, 0, true, 2 };
-        yield return new object[] { false, -0.1, 0, true, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Opacity_SetTopLevelWithHandle_TestData))]
-    public void ToolStripDropDown_Opacity_SetTopLevelWithHandle_GetReturnsExpected(bool allowTransparency, double value, double expected, bool expectedAllowTransparency, int expectedStyleChangedCallCount)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TopLevel = false,
-            AllowTransparency = allowTransparency
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Opacity = value;
-        Assert.Equal(expectedAllowTransparency, control.AllowTransparency);
-        Assert.Equal(expected, control.Opacity);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Region_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Region() };
-        yield return new object[] { new Region(new Rectangle(1, 2, 3, 4)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void ToolStripDropDown_Region_Set_GetReturnsExpected(Region value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            Region = value
-        };
-        Assert.Same(value, control.Region);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Region_Set_TestData))]
-    public void ToolStripDropDown_Region_SetWithHandle_GetReturnsExpected(Region value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Region = value;
-        Assert.Same(value, control.Region);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Region_SetWithHandler_CallsRegionChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RegionChanged += handler;
-
-        // Set different.
-        using var region1 = new Region();
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var region2 = new Region();
-        control.Region = region2;
-        Assert.Same(region2, control.Region);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Region = null;
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.RegionChanged -= handler;
-        control.Region = region1;
-        Assert.Same(region1, control.Region);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_RightToLeft_GetWithSourceToolStripDropDown_ReturnsExpected()
-    {
-        using var sourceControl = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var control = new ToolStripDropDown();
-        control.Show(sourceControl, Point.Empty);
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_RightToLeft_GetWithOwnerItem_ReturnsExpected()
-    {
-        using var ownerItem = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var control = new ToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-
-        control.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_RightToLeft_GetWithSourceControlAndOwnerItem_ReturnsExpected()
-    {
-        using var sourceControl = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var ownerItem = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new ToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        control.Show(sourceControl, Point.Empty);
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, 1)]
-    [InlineData(RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, 0)]
-    public void ToolStripDropDown_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ToolStripDropDown_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_Stretch_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            Stretch = value
-        };
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_Stretch_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ToolStripDropDown_TabIndex_Set_GetReturnsExpected(int value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TabIndex = value
-        };
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabIndex = value;
-        Assert.Equal(value, control.TabIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_TabIndex_SetWithHandler_CallsTabIndexChanged()
-    {
-        using var control = new ToolStripDropDown
-        {
-            TabIndex = 0
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabIndexChanged += handler;
-
-        // Set different.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabIndex = 2;
-        Assert.Equal(2, control.TabIndex);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabIndexChanged -= handler;
-        control.TabIndex = 1;
-        Assert.Equal(1, control.TabIndex);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_TabIndex_SetNegative_CallsArgumentOutOfRangeException()
-    {
-        using var control = new ToolStripDropDown();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.TabIndex = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new ToolStripDropDown
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripDropDown_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ToolStripDropDown
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripDropDown_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStripDropDown_TextDirection_Set_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStripDropDown_TextDirection_SetWithHandle_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount * 2 + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0)]
-    [InlineData(true, false, 1)]
-    [InlineData(false, true, 0)]
-    [InlineData(false, false, 1)]
-    public void ToolStripDropDown_TopLevel_Set_GetReturnsExpected(bool visible, bool value, int expectedStyleChangedCallCount1)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            Visible = visible
-        };
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TopLevel = value;
-        Assert.Equal(value, control.TopLevel);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TopLevel = value;
-        Assert.Equal(value, control.TopLevel);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TopLevel = !value;
-        Assert.Equal(!value, control.TopLevel);
-        Assert.Equal(!value, control.GetTopLevel());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1 + 1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0, 1, 0)]
-    [InlineData(false, false, 1, 3, 1)]
-    public void ToolStripDropDown_TopLevel_SetWithHandle_GetReturnsExpected(bool visible, bool value, int expectedStyleChangedCallCount1, int expectedStyleChangedCallCount2, int expectedCreatedCallCount)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            Visible = visible
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TopLevel = value;
-        Assert.Equal(value, control.TopLevel);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TopLevel = value;
-        Assert.Equal(value, control.TopLevel);
-        Assert.Equal(value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount1, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount1, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TopLevel = !value;
-        Assert.Equal(!value, control.TopLevel);
-        Assert.Equal(!value, control.GetTopLevel());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount2, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount2, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_TopLevel_SetWithParent_ThrowsArgumentException()
-    {
-        using var parent = new Control();
-        using var control = new SubToolStripDropDown
-        {
-            TopLevel = false,
-            Parent = parent
-        };
-        Assert.Throws<ArgumentException>("value", () => control.TopLevel = true);
-        control.TopLevel = false;
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripDropDown();
-        ToolStripDropDown.ToolStripDropDownAccessibleObject instance = Assert.IsType<ToolStripDropDown.ToolStripDropDownAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.MenuPopup, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        ToolStripDropDown.ToolStripDropDownAccessibleObject instance = Assert.IsType<ToolStripDropDown.ToolStripDropDownAccessibleObject>(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);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Button_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Button_TestData))]
-    public void ToolStripDropDown_CreateDefaultItem_InvokeButton_Success(string text, Image image, EventHandler onClick)
-    {
-        using var control = new SubToolStripDropDown();
-        ToolStripButton button = Assert.IsType<ToolStripButton>(control.CreateDefaultItem(text, image, onClick));
-        Assert.Equal(text, button.Text);
-        Assert.Same(image, button.Image);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Separator_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null };
-        yield return new object[] { new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Separator_TestData))]
-    public void ToolStripDropDown_CreateDefaultItem_InvokeSeparator_Success(Image image, EventHandler onClick)
-    {
-        using var control = new SubToolStripDropDown();
-        ToolStripSeparator separator = Assert.IsType<ToolStripSeparator>(control.CreateDefaultItem("-", image, onClick));
-        Assert.Empty(separator.Text);
-        Assert.Null(separator.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 1)]
-    [InlineData("text", 1)]
-    [InlineData("-", 0)]
-    public void ToolStripDropDown_CreateDefaultItem_PerformClick_Success(string text, int expectedCallCount)
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var control = new SubToolStripDropDown();
-        ToolStripItem button = Assert.IsAssignableFrom<ToolStripItem>(control.CreateDefaultItem(text, null, onClick));
-        button.PerformClick();
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_CreateLayoutSettings_InvokeFlow_ReturnsExpected()
-    {
-        using var toolStrip = new SubToolStripDropDown();
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(toolStrip.CreateLayoutSettings(ToolStripLayoutStyle.Flow));
-        Assert.Equal(FlowDirection.TopDown, settings.FlowDirection);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.False(settings.WrapContents);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_CreateLayoutSettings_InvokeTable_ReturnsExpected()
-    {
-        var toolStrip = new SubToolStripDropDown();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.CreateLayoutSettings(ToolStripLayoutStyle.Table));
-        Assert.Equal(0, settings.ColumnCount);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Equal(TableLayoutPanelGrowStyle.AddRows, settings.GrowStyle);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-        Assert.Equal(0, settings.RowCount);
-        Assert.Empty(settings.RowStyles);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripLayoutStyle>]
-    [InlineData(ToolStripLayoutStyle.StackWithOverflow)]
-    [InlineData(ToolStripLayoutStyle.HorizontalStackWithOverflow)]
-    [InlineData(ToolStripLayoutStyle.VerticalStackWithOverflow)]
-    public void ToolStripDropDown_CreateLayoutSettings_InvalidLayoutStyle_ReturnsNull(ToolStripLayoutStyle layoutStyle)
-    {
-        var toolStrip = new SubToolStripDropDown();
-        Assert.Null(toolStrip.CreateLayoutSettings(layoutStyle));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_Invoke_Success()
-    {
-        using var control = new ToolStripDropDown();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeWithSourceControl_Success()
-    {
-        using var sourceControl = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var control = new ToolStripDropDown();
-        control.Show(sourceControl, Point.Empty);
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeNotVisible_Success()
-    {
-        using var control = new ToolStripDropDown
-        {
-            Visible = false
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeWithItems_Success()
-    {
-        using var control = new ToolStripDropDown();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeDisposing_Success()
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeNotDisposing_Success()
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeDisposingWithSourceControl_Success()
-    {
-        using var sourceControl = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var control = new SubToolStripDropDown();
-        control.Show(sourceControl, Point.Empty);
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.No, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeNotDisposingWithSourceControl_Success()
-    {
-        using var sourceControl = new Control
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var control = new SubToolStripDropDown();
-        control.Show(sourceControl, Point.Empty);
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-            Assert.False(control.Visible);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeDisposingWithItems_Success()
-    {
-        using var control = new SubToolStripDropDown();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_Dispose_InvokeNotDisposingWithItems_Success()
-    {
-        using var control = new SubToolStripDropDown();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, item1.Owner);
-            Assert.Same(control, item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(item1.IsDisposed);
-            Assert.False(item2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, item1CallCount);
-            Assert.Equal(0, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, item1.Owner);
-            Assert.Same(control, item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(item1.IsDisposed);
-            Assert.False(item2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, item1CallCount);
-            Assert.Equal(0, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubToolStripDropDown.ScrollStateAutoScrolling, false)]
-    [InlineData(SubToolStripDropDown.ScrollStateFullDrag, false)]
-    [InlineData(SubToolStripDropDown.ScrollStateHScrollVisible, false)]
-    [InlineData(SubToolStripDropDown.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubToolStripDropDown.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ToolStripDropDown_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ToolStripDropDown_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.True(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> UICuesEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new UICuesEventArgs(UICues.None) };
-        yield return new object[] { new UICuesEventArgs(UICues.Changed) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UICuesEventArgs_TestData))]
-    public void ToolStripDropDown_OnChangeUICues_Invoke_CallsChangeUICues(UICuesEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        UICuesEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ChangeUICues += handler;
-        control.OnChangeUICues(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ChangeUICues -= handler;
-        control.OnChangeUICues(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnClosed_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStripDropDownClosedEventArgs(ToolStripDropDownCloseReason.AppFocusChange) };
-        yield return new object[] { new SubToolStripItem(), null };
-        yield return new object[] { new SubToolStripItem(), new ToolStripDropDownClosedEventArgs(ToolStripDropDownCloseReason.AppFocusChange) };
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        var designModeOwnerItem = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-        yield return new object[] { designModeOwnerItem, null };
-        yield return new object[] { designModeOwnerItem, new ToolStripDropDownClosedEventArgs(ToolStripDropDownCloseReason.AppFocusChange) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnClosed_TestData))]
-    public void ToolStripDropDown_OnClosed_Invoke_CallsClosed(ToolStripItem ownerItem, ToolStripDropDownClosedEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        int callCount = 0;
-        ToolStripDropDownClosedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Closed += handler;
-        control.OnClosed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Closed -= handler;
-        control.OnClosed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnClosed_TestData))]
-    public void ToolStripDropDown_OnClosed_InvokeWithHandle_CallsClosed(ToolStripItem ownerItem, ToolStripDropDownClosedEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        ToolStripDropDownClosedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Closed += handler;
-        control.OnClosed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Closed -= handler;
-        control.OnClosed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnClosing_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripDropDownClosingEventArgs(ToolStripDropDownCloseReason.AppFocusChange) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnClosing_TestData))]
-    public void ToolStripDropDown_OnClosing_Invoke_CallsClosing(ToolStripDropDownClosingEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        void handler(object sender, ToolStripDropDownClosingEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.Closing += handler;
-        control.OnClosing(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Closing -= handler;
-        control.OnClosing(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnEnter_Invoke_CallsEnter(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Enter += handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Enter -= handler;
-        control.OnEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> GiveFeedbackEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new GiveFeedbackEventArgs(DragDropEffects.None, true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GiveFeedbackEventArgs_TestData))]
-    public void ToolStripDropDown_OnGiveFeedback_Invoke_CallsGiveFeedback(GiveFeedbackEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        GiveFeedbackEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.GiveFeedback += handler;
-        control.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.GiveFeedback -= handler;
-        control.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_TestData()
-    {
-        foreach (bool topLevel in new bool[] { true, false })
-        {
-            yield return new object[] { topLevel, 1, null };
-            yield return new object[] { topLevel, 1, new EventArgs() };
-            yield return new object[] { topLevel, 0.5, null };
-            yield return new object[] { topLevel, 0.5, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void ToolStripDropDown_OnHandleCreated_Invoke_CallsHandleCreated(bool topLevel, float opacity, EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            TopLevel = topLevel,
-            Opacity = opacity
-        };
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void ToolStripDropDown_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(bool topLevel, float opacity, EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            TopLevel = topLevel,
-            Opacity = opacity
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HelpEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new HelpEventArgs(new Point(1, 2)) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HelpEventArgs_TestData))]
-    public void ToolStripDropDown_OnHelpRequested_Invoke_CallsHelpRequested(HelpEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        HelpEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HelpRequested += handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.HelpRequested -= handler;
-        control.OnHelpRequested(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripDropDown_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyPressEventArgsTheoryData))]
-    public void ToolStripDropDown_OnKeyPress_Invoke_CallsKeyPress(KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetKeyEventArgsTheoryData))]
-    public void ToolStripDropDown_OnKeyUp_Invoke_CallsKeyUp(KeyEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        yield return new object[] { true, null, 2 };
-        yield return new object[] { true, new LayoutEventArgs(null, null), 2 };
-        yield return new object[] { true, new LayoutEventArgs(new Control(), "affectedProperty"), 2 };
-
-        yield return new object[] { false, null, 1 };
-        yield return new object[] { false, new LayoutEventArgs(null, null), 1 };
-        yield return new object[] { false, new LayoutEventArgs(new Control(), "affectedProperty"), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void ToolStripDropDown_OnLayout_Invoke_CallsLayout(bool autoSize, LayoutEventArgs eventArgs, int expectedLayoutCallCount)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLayout_WithOverflowButton_TestData()
-    {
-        foreach (bool autoSize in new bool[] { true, false })
-        {
-            yield return new object[] { autoSize, null };
-            yield return new object[] { autoSize, new LayoutEventArgs(null, null) };
-            yield return new object[] { autoSize, new LayoutEventArgs(new Control(), "affectedProperty") };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithOverflowButton_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithOverflowButton_CallsLayout(bool autoSize, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotNull(control.OverflowButton);
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithOverflowButton_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithOverflowButtonWithDropDown_CallsLayout(bool autoSize, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        control.OverflowButton.DropDown = new ToolStripDropDown();
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithItems_CallsLayout(bool autoSize, LayoutEventArgs eventArgs, int expectedLayoutCallCount)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemLayoutCallCount1 = 0;
-        item1.Layout += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            itemLayoutCallCount1++;
-        };
-        int itemLayoutCallCount2 = 0;
-        item2.Layout += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            itemLayoutCallCount2++;
-        };
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount, itemLayoutCallCount1);
-        Assert.Equal(expectedLayoutCallCount, itemLayoutCallCount2);
-        Assert.Equal(expectedLayoutCallCount, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount + 1, itemLayoutCallCount1);
-        Assert.Equal(expectedLayoutCallCount + 1, itemLayoutCallCount2);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLayout_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 2, 3 };
-        yield return new object[] { true, new LayoutEventArgs(null, null), 2, 3 };
-        yield return new object[] { true, new LayoutEventArgs(new Control(), "affectedProperty"), 2, 3 };
-
-        yield return new object[] { false, null, 1, 1 };
-        yield return new object[] { false, new LayoutEventArgs(null, null), 1, 1 };
-        yield return new object[] { false, new LayoutEventArgs(new Control(), "affectedProperty"), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithHandle_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithHandle_CallsLayout(bool autoSize, LayoutEventArgs eventArgs, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithOverflowButton_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithOverflowButtonWithHandle_CallsLayout(bool autoSize, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotNull(control.OverflowButton);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithOverflowButton_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithOverflowButtonWithDropDownWithHandle_CallsLayout(bool autoSize, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        control.OverflowButton.DropDown = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnLayout_WithItemsWithHandle_TestData()
-    {
-        yield return new object[] { true, null, 2, 3 };
-        yield return new object[] { true, new LayoutEventArgs(null, null), 2, 3 };
-        yield return new object[] { true, new LayoutEventArgs(new Control(), "affectedProperty"), 2, 3 };
-
-        yield return new object[] { false, null, 1, 1 };
-        yield return new object[] { false, new LayoutEventArgs(null, null), 1, 1 };
-        yield return new object[] { false, new LayoutEventArgs(new Control(), "affectedProperty"), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_WithItemsWithHandle_TestData))]
-    public void ToolStripDropDown_OnLayout_InvokeWithItemsWithHandle_CallsLayout(bool autoSize, LayoutEventArgs eventArgs, int expectedLayoutCallCount, int expectedInvalidatedCallCount)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStripDropDown
-        {
-            AutoSize = autoSize
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int itemLayoutCallCount1 = 0;
-        item1.Layout += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            itemLayoutCallCount1++;
-        };
-        int itemLayoutCallCount2 = 0;
-        item2.Layout += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            itemLayoutCallCount2++;
-        };
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount, itemLayoutCallCount1);
-        Assert.Equal(expectedLayoutCallCount, itemLayoutCallCount2);
-        Assert.Equal(expectedLayoutCallCount, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(expectedLayoutCallCount, callCount);
-        Assert.Equal(expectedLayoutCallCount + 1, itemLayoutCallCount1);
-        Assert.Equal(expectedLayoutCallCount + 1, itemLayoutCallCount2);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnOpened_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { null, new EventArgs() };
-        yield return new object[] { new SubToolStripItem(), null };
-        yield return new object[] { new SubToolStripItem(), new EventArgs() };
-
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        var designModeOwnerItem = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-        yield return new object[] { designModeOwnerItem, null };
-        yield return new object[] { designModeOwnerItem, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnOpened_TestData))]
-    public void ToolStripDropDown_OnOpened_Invoke_CallsOpened(ToolStripItem ownerItem, EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Opened += handler;
-        control.OnOpened(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Opened -= handler;
-        control.OnOpened(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnOpened_TestData))]
-    public void ToolStripDropDown_OnOpened_InvokeWithHandle_CallsOpened(ToolStripItem ownerItem, EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Opened += handler;
-        control.OnOpened(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Opened -= handler;
-        control.OnOpened(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnOpening_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs(false) };
-        yield return new object[] { new CancelEventArgs(true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnOpening_TestData))]
-    public void ToolStripDropDown_OnOpening_Invoke_CallsOpening(CancelEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        void handler(object sender, CancelEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        }
-
-        // Call with handler.
-        control.Opening += handler;
-        control.OnOpening(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Opening -= handler;
-        control.OnOpening(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnScroll_TestData()
-    {
-        foreach (ScrollEventType eventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            foreach (ScrollOrientation orientation in Enum.GetValues(typeof(ScrollOrientation)))
-            {
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 1, orientation) };
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 2, orientation) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_TestData))]
-    public void ToolStripDropDown_OnScroll_Invoke_CallsHandler(ScrollEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_OnScroll_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.Throws<NullReferenceException>(() => control.OnScroll(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnStyleChanged_Invoke_CallsStyleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.StyleChanged += handler;
-        control.OnStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.StyleChanged -= handler;
-        control.OnStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripDropDown_OnValidated_Invoke_CallsValidated(EventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Validated += handler;
-        control.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Validated -= handler;
-        control.OnValidated(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnValidating_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs() };
-        yield return new object[] { new CancelEventArgs(true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnValidating_TestData))]
-    public void ToolStripDropDown_OnValidating_Invoke_CallsValidating(CancelEventArgs eventArgs)
-    {
-        using var control = new SubToolStripDropDown();
-        int callCount = 0;
-        CancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Validating += handler;
-        control.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Validating -= handler;
-        control.OnValidating(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_KeyboardArrowNavigation_Test()
-    {
-        ToolStripMenuItem toolStrip = new ToolStripMenuItem();
-        ToolStripItemCollection items = toolStrip.DropDown.DisplayedItems;
-        items.Add("First item");
-        items.Add("Second item");
-        items.Add("Third item");
-        items.Add("Fourth item");
-        items.Add("Fifth item");
-
-        for (int i = 1; i < items.Count; i++) //it needs for correct work of ToolStrip.GetNextItemVertical method
-        {
-            items[i].SetBounds(0, items[i - 1].Bounds.Bottom + 1, items[i].Bounds.Width, items[i].Bounds.Height);
-        }
-
-        ToolStripItem expected = items[4];
-        ToolStripItem actual = toolStrip.DropDown.GetNextItem(start: null, direction: ArrowDirection.Up);
-        Assert.Equal(expected, actual);
-
-        expected = items[4];
-        actual = toolStrip.DropDown.GetNextItem(start: items[0], direction: ArrowDirection.Up);
-        Assert.Equal(expected, actual);
-
-        expected = items[0];
-        actual = toolStrip.DropDown.GetNextItem(start: null, direction: ArrowDirection.Down);
-        Assert.Equal(expected, actual);
-
-        expected = items[1];
-        actual = toolStrip.DropDown.GetNextItem(start: items[0], direction: ArrowDirection.Down);
-        Assert.Equal(expected, actual);
-
-        expected = items[0];
-        actual = toolStrip.DropDown.GetNextItem(start: items[4], direction: ArrowDirection.Down);
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDown_WorkingAreaConstrained_DefaultValueTest()
-    {
-        using var control = new ToolStripDropDown();
-        Assert.True(control.WorkingAreaConstrained);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripDropDown_WorkingAreaConstrained_AssignmentTest(bool value)
-    {
-        using var control = new ToolStripDropDown();
-        control.WorkingAreaConstrained = value;
-        Assert.Equal(value, control.WorkingAreaConstrained);
-    }
-
-    private class SubAxHost : AxHost
-    {
-        public SubAxHost(string clsid) : base(clsid)
-        {
-        }
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-        public event LayoutEventHandler Layout;
-
-        protected internal override void OnLayout(LayoutEventArgs e)
-        {
-            Layout?.Invoke(this, e);
-            base.OnLayout(e);
-        }
-    }
-
-    private class NotTopMostToolStripDropDown : ToolStripDropDown
-    {
-        protected override bool TopMost => false;
-    }
-
-    private class SubToolStripDropDown : ToolStripDropDown
-    {
-        public new const int ScrollStateAutoScrolling = ToolStrip.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ToolStrip.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ToolStrip.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ToolStrip.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ToolStrip.ScrollStateFullDrag;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new DockStyle DefaultDock => base.DefaultDock;
-
-        public new Padding DefaultGripMargin => base.DefaultGripMargin;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DefaultShowItemToolTips => base.DefaultShowItemToolTips;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new Size MaxItemSize => base.MaxItemSize;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool TopMost => base.TopMost;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new ToolStripItem CreateDefaultItem(string text, Image image, EventHandler onClick) => base.CreateDefaultItem(text, image, onClick);
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new LayoutSettings CreateLayoutSettings(ToolStripLayoutStyle layoutStyle) => base.CreateLayoutSettings(layoutStyle);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnChangeUICues(UICuesEventArgs e) => base.OnChangeUICues(e);
-
-        public new void OnClosed(ToolStripDropDownClosedEventArgs e) => base.OnClosed(e);
-
-        public new void OnClosing(ToolStripDropDownClosingEventArgs e) => base.OnClosing(e);
-
-        public new void OnEnter(EventArgs e) => base.OnEnter(e);
-
-        public new void OnGiveFeedback(GiveFeedbackEventArgs e) => base.OnGiveFeedback(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnHelpRequested(HelpEventArgs e) => base.OnHelpRequested(e);
-
-        public new void OnItemClicked(ToolStripItemClickedEventArgs e) => base.OnItemClicked(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnMouseUp(MouseEventArgs mea) => base.OnMouseUp(mea);
-
-        public new void OnOpened(EventArgs e) => base.OnOpened(e);
-
-        public new void OnOpening(CancelEventArgs e) => base.OnOpening(e);
-
-        public new void OnParentChanged(EventArgs e) => base.OnParentChanged(e);
-
-        public new void OnScroll(ScrollEventArgs se) => base.OnScroll(se);
-
-        public new void OnStyleChanged(EventArgs e) => base.OnStyleChanged(e);
-
-        public new void OnValidated(EventArgs e) => base.OnValidated(e);
-
-        public new void OnValidating(CancelEventArgs e) => base.OnValidating(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new bool ProcessDialogChar(char charCode) => base.ProcessDialogChar(charCode);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void SetVisibleCore(bool visible) => base.SetVisibleCore(visible);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGrip.ToolStripGripAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGrip.ToolStripGripAccessibleObjectTests.cs
deleted file mode 100644
index 1f8d1766400..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGrip.ToolStripGripAccessibleObjectTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripGrip;
-using static Interop;
-
-namespace System.Windows.Forms;
-
-public class ToolStripGrip_ToolStripGripAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripGripAccessibleObject_Ctor_Default()
-    {
-        using ToolStripGrip toolStripGrip = new ToolStripGrip();
-        ToolStripGripAccessibleObject accessibleObject = new ToolStripGripAccessibleObject(toolStripGrip);
-
-        Assert.Equal(toolStripGrip, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripGripAccessibleObject_ControlType_IsThumb_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripGrip toolStripGrip = new ToolStripGrip();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripGrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ThumbControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripGripAccessibleObject_Role_IsGrip_ByDefault()
-    {
-        using ToolStripGrip toolStripGrip = new ToolStripGrip();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripGrip.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Grip, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripGripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripGripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripGripAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripGrip toolStripGrip = new ToolStripGrip();
-        toolStripGrip.AccessibleRole = role;
-
-        object actual = toolStripGrip.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGripRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGripRenderEventArgsTests.cs
deleted file mode 100644
index 0d290003d53..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripGripRenderEventArgsTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripGripRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStrip_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStrip() };
-        yield return new object[] { graphics, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStrip_TestData))]
-    public void ToolStripGripRenderEventArgs_Null_Graphics_ToolStrip_ThrowsArgumentNullException(Graphics g, ToolStrip toolStrip)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripGripRenderEventArgs(g, toolStrip));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStrip_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { graphics, new ToolStrip() };
-        yield return new object[]
-        {
-            graphics, new ToolStrip
-            {
-                LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow,
-                GripStyle = ToolStripGripStyle.Visible
-            }
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStrip_TestData))]
-    public void Ctor_Graphics_ToolStrip(Graphics g, ToolStrip toolStrip)
-    {
-        var e = new ToolStripGripRenderEventArgs(g, toolStrip);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(toolStrip, e.ToolStrip);
-        Assert.Equal(new Rectangle(Point.Empty, toolStrip.Size), e.AffectedBounds);
-        Assert.Equal(toolStrip.GripRectangle, e.GripBounds);
-        Assert.Equal(toolStrip.GripDisplayStyle, e.GripDisplayStyle);
-        Assert.Equal(toolStrip.GripStyle, e.GripStyle);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemAccessibleObjectTests.cs
deleted file mode 100644
index b6d0773fccb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,344 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_Ctor_ToolStripItem()
-    {
-        using var item = new SubToolStripItem
-        {
-            AccessibleDefaultActionDescription = "DefaultActionDescription",
-            AccessibleDescription = "Description",
-            AccessibleName = "Name",
-            AccessibleRole = AccessibleRole.MenuBar
-        };
-
-        var accessibleObject = new ToolStripItem.ToolStripItemAccessibleObject(item);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.Equal("DefaultActionDescription", accessibleObject.DefaultAction);
-        Assert.Equal("Description", accessibleObject.Description);
-        Assert.Null(accessibleObject.Help);
-        Assert.Empty(accessibleObject.KeyboardShortcut);
-        Assert.Equal("Name", accessibleObject.Name);
-        Assert.Null(accessibleObject.Parent);
-        Assert.Equal(AccessibleRole.MenuBar, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_Ctor_NullOwnerItem_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("ownerItem", () => new ToolStripItem.ToolStripItemAccessibleObject(null));
-    }
-
-    public static IEnumerable<object[]> ToolStripItemAccessibleObject_TestData()
-    {
-        return ReflectionHelper.GetPublicNotAbstractClasses<ToolStripItem>().Select(type => new object[] { type });
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripItemAccessibleObject_LegacyIAccessible_Custom_Role_ReturnsExpected(Type type)
-    {
-        using (new NoAssertContext())
-        {
-            using ToolStripItem item = ReflectionHelper.InvokePublicConstructor<ToolStripItem>(type);
-            item.AccessibleRole = AccessibleRole.Link;
-            AccessibleObject toolStripItemAccessibleObject = item.AccessibilityObject;
-
-            var accessibleObjectRole = toolStripItemAccessibleObject.Role;
-
-            Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripItemAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue(Type type)
-    {
-        using ToolStripItem item = ReflectionHelper.InvokePublicConstructor<ToolStripItem>(type);
-        AccessibleObject toolStripItemAccessibleObject = item.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = toolStripItemAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripItemAccessibleObject_LegacyIAccessible_Custom_Description_ReturnsExpected(Type type)
-    {
-        using ToolStripItem item = ReflectionHelper.InvokePublicConstructor<ToolStripItem>(type);
-        item.AccessibleDescription = "Test Accessible Description";
-        AccessibleObject toolStripItemAccessibleObject = item.AccessibilityObject;
-
-        var accessibleObjectDescription = toolStripItemAccessibleObject.Description;
-
-        Assert.Equal("Test Accessible Description", accessibleObjectDescription);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripItemAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected(Type type)
-    {
-        using ToolStripItem item = ReflectionHelper.InvokePublicConstructor<ToolStripItem>(type);
-        AccessibleObject toolStripItemAccessibleObject = item.AccessibilityObject;
-
-        // By default Name has string.Empty value, because if AccessibleName is not defined
-        // then control uses the value of "Text" property from owner Item (by default an empty string)
-        Assert.Equal(string.Empty, toolStripItemAccessibleObject.GetPropertyValue(UIA.NamePropertyId));
-
-        item.Name = "Name1";
-        item.AccessibleName = "Test Name";
-
-        var accessibleName = toolStripItemAccessibleObject.GetPropertyValue(UIA.NamePropertyId);
-
-        Assert.Equal("Test Name", accessibleName);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_TestData))]
-    public void ToolStripHostedControlAccessibleObject_GetPropertyValue_IsOffscreenPropertyId_ReturnExpected(Type type)
-    {
-        using var toolStrip = new ToolStrip();
-        toolStrip.CreateControl();
-        using ToolStripItem item = ReflectionHelper.InvokePublicConstructor<ToolStripItem>(type);
-        item.Size = new Size(0, 0);
-        toolStrip.Items.Add(item);
-
-        AccessibleObject toolStripItemAccessibleObject = item.AccessibilityObject;
-
-        Assert.True((bool)toolStripItemAccessibleObject.GetPropertyValue(UIA.IsOffscreenPropertyId) ||
-            (toolStripItemAccessibleObject.Bounds.Width > 0 && toolStripItemAccessibleObject.Bounds.Height > 0));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        // Test the Default role case separately because ToolStripItemAccessibleObject
-        // has default Role property value as "PushButton"
-
-        using ToolStripItem toolStripItem = new SubToolStripItem();
-        // AccessibleRole is not set = Default
-
-        UIA actual = (UIA)toolStripItem.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-
-        Assert.Equal(UIA.ButtonControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public static IEnumerable<object[]> ToolStripItemAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue_TestData))]
-    public void ToolStripItemAccessibleObject_GetPropertyValue_ControlTypeProperty_ReturnsCorrectValue(AccessibleRole role)
-    {
-        using ToolStripItem toolStripItem = new SubToolStripItem();
-        toolStripItem.AccessibleRole = role;
-
-        UIA actual = (UIA)toolStripItem.AccessibilityObject.GetPropertyValue(UIA.ControlTypePropertyId);
-        UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        // Check if the method returns an exist UIA_ControlTypeId
-        Assert.True(actual >= UIA.ButtonControlTypeId && actual <= UIA.AppBarControlTypeId);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_GetPropertyValue_ReturnsExpected()
-    {
-        using ToolStripItem toolStripItem = new SubToolStripItem();
-
-        Assert.False((bool)toolStripItem.AccessibilityObject.GetPropertyValue(UIA.IsExpandCollapsePatternAvailablePropertyId));
-        Assert.Null(toolStripItem.AccessibilityObject.GetPropertyValue(UIA.ValueValuePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_GetPropertyValue_IsControlElement_ReturnsExpected()
-    {
-        using ToolStripItem toolStripItem = new SubToolStripItem();
-
-        AccessibleObject accessibleObject = toolStripItem.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsControlElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_GetPropertyValue_IsContentElement_ReturnsExpected()
-    {
-        using ToolStripItem toolStripItem = new SubToolStripItem();
-
-        AccessibleObject accessibleObject = toolStripItem.AccessibilityObject;
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UIA.IsContentElementPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using ToolStrip toolStrip = new();
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.PerformLayout();
-        toolStrip.CreateControl();
-
-        AccessibleObject accessibleObject = toolStrip.Items[0].AccessibilityObject;
-        AccessibleObject expected = toolStrip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Parent_ReturnsNull_IfHandleNotCreated()
-    {
-        using ToolStrip toolStrip = new();
-        toolStrip.Items.Add(string.Empty);
-
-        AccessibleObject accessibleObject = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Child_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new();
-        toolStrip.Items.Add(string.Empty);
-
-        AccessibleObject accessibleObject = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Sibling_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new() { AutoSize = false, Size = new(300, 30) };
-
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject grip = toolStrip.Grip.AccessibilityObject;
-        AccessibleObject item1 = toolStrip.Items[0].AccessibilityObject;
-        AccessibleObject item2 = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(item1, grip.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(item2, item1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(item2.FragmentNavigate(NavigateDirection.NextSibling));
-
-        Assert.Equal(item1, item2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(grip, item1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(grip.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_PreviousSibling_ReturnExpected_IfGripHidden()
-    {
-        using ToolStrip toolStrip = new() { GripStyle = ToolStripGripStyle.Hidden };
-
-        toolStrip.Items.Add(string.Empty);
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfItemsAligned()
-    {
-        using ToolStrip toolStrip = new() { AutoSize = false, Size = new(300, 30) };
-
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject grip = toolStrip.Grip.AccessibilityObject;
-        AccessibleObject item1 = toolStrip.Items[0].AccessibilityObject;
-        AccessibleObject item2 = toolStrip.Items[1].AccessibilityObject;
-
-        Assert.Equal(item2, grip.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(item1, item2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(item1.FragmentNavigate(NavigateDirection.NextSibling));
-
-        Assert.Equal(item2, item1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(grip, item2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(grip.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemAccessibleObject_FragmentNavigate_Sibling_ReturnExpected_IfItemsSkipped()
-    {
-        using ToolStrip toolStrip = new() { AutoSize = false, Size = new(300, 30) };
-
-        ToolStripItem CreateSkippedItem()
-        {
-            return new ToolStripControlHost(new Label());
-        }
-
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(CreateSkippedItem());
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(CreateSkippedItem());
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject grip = toolStrip.Grip.AccessibilityObject;
-        AccessibleObject item2 = toolStrip.Items[1].AccessibilityObject;
-        AccessibleObject item4 = toolStrip.Items[3].AccessibilityObject;
-
-        Assert.Equal(item2, grip.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(item4, item2.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(item4.FragmentNavigate(NavigateDirection.NextSibling));
-
-        Assert.Equal(item2, item4.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(grip, item2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(grip.FragmentNavigate(NavigateDirection.PreviousSibling));
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-        public SubToolStripItem() : base()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemClickedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemClickedEventArgsTests.cs
deleted file mode 100644
index bbcb3f673a4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemClickedEventArgsTests.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemClickedEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ToolStripItem_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripButton() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItem_TestData))]
-    public void Ctor_ToolStripItem(ToolStripItem clickedItem)
-    {
-        var e = new ToolStripItemClickedEventArgs(clickedItem);
-        Assert.Equal(clickedItem, e.ClickedItem);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemCollectionTests.cs
deleted file mode 100644
index aee061500b5..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemCollectionTests.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemCollectionTests
-{
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void ToolStripItemCollection_Find_InvokeKeyExists_ReturnsExpected(string key)
-    {
-        using ToolStripMenuItem toolStrip = new ToolStripMenuItem();
-
-        var child1 = new ToolStripMenuItem
-        {
-            Name = "name1"
-        };
-        var child2 = new ToolStripMenuItem
-        {
-            Name = "name2"
-        };
-        var child3 = new ToolStripMenuItem
-        {
-            Name = "name2"
-        };
-
-        var grandchild1 = new ToolStripMenuItem
-        {
-            Name = "name1"
-        };
-        var grandchild2 = new ToolStripMenuItem
-        {
-            Name = "name2"
-        };
-        var grandchild3 = new ToolStripMenuItem
-        {
-            Name = "name2"
-        };
-        child3.DropDownItems.Add(grandchild1);
-        child3.DropDownItems.Add(grandchild2);
-        child3.DropDownItems.Add(grandchild3);
-        ToolStripItemCollection collection = toolStrip.DropDownItems;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        // Search all children.
-        Assert.Equal(new ToolStripMenuItem[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Call again.
-        Assert.Equal(new ToolStripMenuItem[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Don't search all children.
-        Assert.Equal(new ToolStripMenuItem[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-
-        // Call again.
-        Assert.Equal(new ToolStripMenuItem[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ToolStripItemCollection_Find_InvokeNoSuchKey_ReturnsEmpty(string key)
-    {
-        using ToolStripMenuItem toolStrip = new ToolStripMenuItem();
-
-        var child1 = new ToolStripMenuItem()
-        {
-            Name = "name1"
-        };
-        var child2 = new ToolStripMenuItem()
-        {
-            Name = "name2"
-        };
-        var child3 = new ToolStripMenuItem()
-        {
-            Name = "name2"
-        };
-        var collection = toolStrip.DropDown.DisplayedItems;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Empty(collection.Find(key, searchAllChildren: true));
-        Assert.Empty(collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void ToolStripItemCollection_Find_NullOrEmptyKey_ThrowsArgumentNullException(string key)
-    {
-        using ToolStripMenuItem toolStrip = new ToolStripMenuItem();
-        var collection = toolStrip.DropDown.DisplayedItems;
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: true));
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemCollection_AddRange_ToolStripItemCollection_Success()
-    {
-        using var contextMenuStrip = new ContextMenuStrip();
-        using var toolStripDropDownButton = new ToolStripDropDownButton();
-
-        // Add 0 items.
-        contextMenuStrip.Items.AddRange(toolStripDropDownButton.DropDownItems);
-        Assert.Equal(0, contextMenuStrip.Items.Count);
-
-        // Add 3 items.
-        toolStripDropDownButton.DropDownItems.Add("a");
-        toolStripDropDownButton.DropDownItems.Add("b");
-        toolStripDropDownButton.DropDownItems.Add("c");
-        contextMenuStrip.Items.AddRange(toolStripDropDownButton.DropDownItems);
-        Assert.Equal(3, contextMenuStrip.Items.Count);
-
-        // Validate order.
-        Assert.Equal("a", contextMenuStrip.Items[0].Text);
-        Assert.Equal("b", contextMenuStrip.Items[1].Text);
-        Assert.Equal("c", contextMenuStrip.Items[2].Text);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemEventArgsTests.cs
deleted file mode 100644
index beb19e24d10..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemEventArgsTests.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ToolStripItem_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripButton() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItem_TestData))]
-    public void Ctor_ToolStripItem(ToolStripItem item)
-    {
-        var e = new ToolStripItemEventArgs(item);
-        Assert.Equal(item, e.Item);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemImageRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemImageRenderEventArgsTests.cs
deleted file mode 100644
index 3fdff7bbf3f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemImageRenderEventArgsTests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemImageRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStripItem_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStripButton() };
-        yield return new object[] { graphics, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStripItem_TestData))]
-    public void ToolStripItemImageRenderEventArgs_Null_Graphics_ToolStripItem_ThrowsArgumentNullException(Graphics g, ToolStripItem toolStripItem)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripItemImageRenderEventArgs(g, toolStripItem, Rectangle.Empty));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStripItem_Rectangle_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { graphics, new ToolStripButton(), new Rectangle(1, 2, 3, 4), null };
-        yield return new object[] { graphics, new ToolStripButton() { Image = image }, new Rectangle(1, 2, 3, 4), image };
-        yield return new object[]
-        {
-            graphics, new ToolStripButton
-            {
-                RightToLeft = RightToLeft.Yes,
-                Image = image
-            }, new Rectangle(1, 2, 3, 4), image
-        };
-        yield return new object[]
-        {
-            graphics, new ToolStripButton
-            {
-                RightToLeftAutoMirrorImage = true,
-                Image = image
-            }, new Rectangle(1, 2, 3, 4), image
-        };
-        yield return new object[]
-        {
-            graphics, new ToolStripButton
-            {
-                RightToLeftAutoMirrorImage = true,
-                RightToLeft = RightToLeft.Yes
-            }, new Rectangle(1, 2, 3, 4), null
-        };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStripItem_Rectangle_TestData))]
-    public void ToolStripItemImageRenderEventArgs_Ctor_Graphics_ToolStripItem_Rectangle(Graphics g, ToolStripItem item, Rectangle imageRectangle, Image expectedImage)
-    {
-        var e = new ToolStripItemImageRenderEventArgs(g, item, imageRectangle);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(imageRectangle, e.ImageRectangle);
-        Assert.Same(expectedImage, e.Image);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItemImageRenderEventArgs_Ctor_Graphics_ToolStripItem_Rectangle_MirroredImage()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics g = Graphics.FromImage(image))
-        {
-            var item = new ToolStripButton
-            {
-                RightToLeftAutoMirrorImage = true,
-                RightToLeft = RightToLeft.Yes,
-                Image = image
-            };
-            var e = new ToolStripItemImageRenderEventArgs(g, item, new Rectangle(1, 2, 3, 4));
-            Assert.Equal(g, e.Graphics);
-            Assert.Equal(item, e.Item);
-            Assert.Equal(new Rectangle(1, 2, 3, 4), e.ImageRectangle);
-            Assert.NotSame(image, e.Image);
-            Assert.Equal(image.Size, e.Image.Size);
-        }
-    }
-
-    public static IEnumerable<object[]> Ctor_ToolStripItem_Image_Rectangle_TestData()
-    {
-        yield return new object[] { new ToolStripButton(), new Bitmap(10, 10), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new ToolStripButton() { Image = new Bitmap(10, 10) }, new Bitmap(10, 10), new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItem_Image_Rectangle_TestData))]
-    public void ToolStripItemImageRenderEventArgs_Ctor_ToolStripItem_Image_Rectangle(ToolStripItem item, Image image, Rectangle imageRectangle)
-    {
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new ToolStripItemImageRenderEventArgs(graphics, item, image, imageRectangle);
-
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(image, e.Image);
-        Assert.Equal(imageRectangle, e.ImageRectangle);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemRenderEventArgsTests.cs
deleted file mode 100644
index d7fdf51d742..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemRenderEventArgsTests.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStripItem_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStripButton() };
-        yield return new object[] { graphics, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStripItem_TestData))]
-    public void ToolStripItemRenderEventArgs_Null_Graphics_ToolStripItem_ThrowsArgumentNullException(Graphics g, ToolStripItem toolStripItem)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripItemRenderEventArgs(g, toolStripItem));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStripItem_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { graphics, new ToolStripButton(), null };
-
-        var toolStripItem = new ToolStripButton();
-        var toolStrip = new ToolStrip();
-        toolStrip.Items.Add(toolStripItem);
-        yield return new object[] { graphics, toolStripItem, null };
-        yield return new object[] { graphics, toolStrip.OverflowButton, toolStrip };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStripItem_TestData))]
-    public void Ctor_Graphics_ToolStripItem(Graphics g, ToolStripItem item, ToolStrip expectedToolStrip)
-    {
-        var e = new ToolStripItemRenderEventArgs(g, item);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(expectedToolStrip, e.ToolStrip);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTests.cs
deleted file mode 100644
index 1b7dc015eaa..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTests.cs
+++ /dev/null
@@ -1,15595 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices.ComTypes;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemTests
-{
-    [WinFormsFact]
-    public void ToolStripItem_Ctor_Default()
-    {
-        using var item = new SubToolStripItem();
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_TestData))]
-    public void ToolStripItem_Ctor_String_Image_EventHandler(string text, Image image, EventHandler onClick)
-    {
-        using var item = new SubToolStripItem(text, image, onClick);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Ctor_String_Image_EventHandler_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new SubToolStripItem("text", null, onClick);
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> Ctor_String_Image_EventHandler_String_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null, null, string.Empty };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick, string.Empty, string.Empty };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick, "name", "name" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_String_Image_EventHandler_String_TestData))]
-    public void ToolStripItem_Ctor_String_Image_EventHandler_String(string text, Image image, EventHandler onClick, string name, string expectedName)
-    {
-        using var item = new SubToolStripItem(text, image, onClick, name);
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 23, 23), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 19, 19), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(23, 23), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(23, item.Height);
-        Assert.Equal(image, item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Equal(expectedName, item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(23, 23), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Equal(text, item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(23, item.Width);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Ctor_String_Image_EventHandler_String_InvokeClick_CallsOnClick()
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var item = new SubToolStripItem("text", null, onClick, "name");
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> AccessibilityObject_Get_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AccessibleObject() };
-        yield return new object[] { new SubToolStripItem.ToolStripItemAccessibleObject(new SubToolStripItem()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AccessibilityObject_Get_TestData))]
-    public void ToolStripItem_AccessibilityObject_GetCustomCreateAccessibilityInstance_ReturnsExpected(AccessibleObject result)
-    {
-        using var item = new CustomCreateAccessibilityInstanceToolStripItem
-        {
-            CreateAccessibilityInstanceResult = result
-        };
-        Assert.Same(result, item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-    }
-
-    private class CustomCreateAccessibilityInstanceToolStripItem : ToolStripItem
-    {
-        public AccessibleObject CreateAccessibilityInstanceResult { get; set; }
-
-        protected override AccessibleObject CreateAccessibilityInstance() => CreateAccessibilityInstanceResult;
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_AccessibleDefaultActionDescription_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AccessibleDefaultActionDescription = value
-        };
-        Assert.Equal(value, item.AccessibleDefaultActionDescription);
-
-        // Set same.
-        item.AccessibleDefaultActionDescription = value;
-        Assert.Equal(value, item.AccessibleDefaultActionDescription);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_AccessibleDescription_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AccessibleDescription = value
-        };
-        Assert.Equal(value, item.AccessibleDescription);
-
-        // Set same.
-        item.AccessibleDescription = value;
-        Assert.Equal(value, item.AccessibleDescription);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_AccessibleName_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AccessibleName = value
-        };
-        Assert.Equal(value, item.AccessibleName);
-
-        // Set same.
-        item.AccessibleName = value;
-        Assert.Equal(value, item.AccessibleName);
-    }
-
-    [WinFormsTheory]
-    [EnumData<AccessibleRole>]
-    public void ToolStripItem_AccessibleRole_Set_GetReturnsExpected(AccessibleRole value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AccessibleRole = value
-        };
-        Assert.Equal(value, item.AccessibleRole);
-
-        // Set same.
-        item.AccessibleRole = value;
-        Assert.Equal(value, item.AccessibleRole);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AccessibleRole>]
-    public void ToolStripItem_AccessibleRole_SetInvalid_ThrowsInvalidEnumArgumentException(AccessibleRole value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.AccessibleRole = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemAlignment>]
-    public void ToolStripItem_Alignment_Set_GetReturnsExpected(ToolStripItemAlignment value)
-    {
-        using var item = new SubToolStripItem();
-
-        item.Alignment = value;
-        Assert.Equal(value, item.Alignment);
-
-        // Set same.
-        item.Alignment = value;
-        Assert.Equal(value, item.Alignment);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemAlignment>]
-    public void ToolStripItem_Alignment_SetWithParent_GetReturnsExpected(ToolStripItemAlignment value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        parent.Layout += (sender, e) => parentLayoutCallCount++;
-
-        item.Alignment = value;
-        Assert.Equal(value, item.Alignment);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Alignment = value;
-        Assert.Equal(value, item.Alignment);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemAlignment.Left, 0)]
-    [InlineData(ToolStripItemAlignment.Right, 1)]
-    public void ToolStripItem_Alignment_SetWithParentWithHandle_GetReturnsExpected(ToolStripItemAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Null(e.AffectedComponent);
-            Assert.Null(e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemAlignment>]
-    public void ToolStripItem_Alignment_SetWithOwner_GetReturnsExpected(ToolStripItemAlignment value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemAlignment>]
-    public void ToolStripItem_Alignment_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripItemAlignment value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Alignment = value;
-            Assert.Equal(value, item.Alignment);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemAlignment>]
-    public void ToolStripItem_Alignment_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemAlignment value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.Alignment = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, item.AllowDrop);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_SetWithOwner_GetReturnsExpected(bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            AllowDrop = value
-        };
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_SetWithOwnerWithHandle_GetReturnsExpected(bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-        Assert.False(owner.AllowDrop);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            AllowDrop = value
-        };
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_SetWithParentWithHandle_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-        Assert.False(parent.AllowDrop);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AllowDrop_SetWithParentWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip
-        {
-            AllowDrop = true
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            AllowDrop = value
-        };
-        Assert.Equal(value, item.AllowDrop);
-
-        // Set same.
-        item.AllowDrop = value;
-        Assert.Equal(value, item.AllowDrop);
-
-        // Set different.
-        item.AllowDrop = !value;
-        Assert.Equal(!value, item.AllowDrop);
-    }
-
-    [Fact] // x-thread
-    public void Control_AllowDrop_SetWithParentWithHandleNonSTAThread_ThrowsInvalidOperationException()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<InvalidOperationException>(() => item.AllowDrop = true);
-        Assert.False(item.AllowDrop);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Can set to false.
-        item.AllowDrop = false;
-        Assert.False(item.AllowDrop);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Anchor_Set_TestData()
-    {
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left };
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top };
-        yield return new object[] { AnchorStyles.None, AnchorStyles.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-        yield return new object[] { (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right };
-        yield return new object[] { (AnchorStyles)0x10, AnchorStyles.Top | AnchorStyles.Left };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void ToolStripItem_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            Anchor = value
-        };
-        Assert.Equal(expected, item.Anchor);
-
-        // Set same.
-        item.Anchor = value;
-        Assert.Equal(expected, item.Anchor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void ToolStripItem_Anchor_SetWithOwner_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Anchor = value;
-            Assert.Equal(expected, item.Anchor);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Anchor = value;
-            Assert.Equal(expected, item.Anchor);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void ToolStripItem_Anchor_SetWithParent_GetReturnsExpected(AnchorStyles value, AnchorStyles expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Anchor = value;
-            Assert.Equal(expected, item.Anchor);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Anchor = value;
-            Assert.Equal(expected, item.Anchor);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AutoSize = value
-        };
-        Assert.Equal(value, item.AutoSize);
-
-        // Set same.
-        item.AutoSize = value;
-        Assert.Equal(value, item.AutoSize);
-
-        // Set different.
-        item.AutoSize = !value;
-        Assert.Equal(!value, item.AutoSize);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ToolStripItem_AutoSize_SetWithOwner_GetReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set different.
-            item.AutoSize = !value;
-            Assert.Equal(!value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount + 1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ToolStripItem_AutoSize_SetWithOwnerWithHandle_GetReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            item.AutoSize = !value;
-            Assert.Equal(!value, item.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount + 1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2 + 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AutoSize_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            item.AutoSize = !value;
-            Assert.Equal(!value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AutoSize_SetWithParentWithHandle_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.AutoSize = value;
-            Assert.Equal(value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            item.AutoSize = !value;
-            Assert.Equal(!value, item.AutoSize);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_AutoToolTip_GetWithDefaultAutoToolTip_ReturnsExpected()
-    {
-        using var item = new CustomDefaultAutoToolTipToolStripItem();
-        Assert.True(item.AutoToolTip);
-    }
-
-    private class CustomDefaultAutoToolTipToolStripItem : ToolStripItem
-    {
-        protected override bool DefaultAutoToolTip => true;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_AutoToolTip_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            AutoToolTip = value
-        };
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set same.
-        item.AutoToolTip = value;
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set different.
-        item.AutoToolTip = !value;
-        Assert.Equal(!value, item.AutoToolTip);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_Set_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Available = value
-        };
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetDesignMode_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Available = value
-        };
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_Available_SetSelected_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem();
-        item.Select();
-        Assert.True(item.Selected);
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Selected);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetDesignModeWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Owner = owner,
-        };
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Available_SetWithOwnerWithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true, 0 };
-                yield return new object[] { enabled, image, false, 2 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Available_SetWithOwnerWithHandle_TestData))]
-    public void ToolStripItem_Available_SetWithOwnerWithHandle_GetReturnsExpected(bool enabled, Image image, bool value, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.Equal(!value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.Equal(!value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetDesignModeWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Parent = parent
-        };
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.Equal(!value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Available_SetWithParentWithHandle_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Available = value;
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Available);
-        Assert.Equal(!value, item.Visible);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Available_SetWithHandler_CallsAvailableChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.AvailableChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Available_SetWithHandler_CallsVisibleChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.VisibleChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_BackColor_GetWithOwner_ReturnsExpected()
-    {
-        using var owner = new ToolStrip
-        {
-            BackColor = Color.Red
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_BackColor_GetWithParent_ReturnsExpected()
-    {
-        using var parent = new ToolStrip
-        {
-            BackColor = Color.Red
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(Color.Red, item.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripItem_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, item.BackColor);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripItem_BackColor_SetWithOwner_GetReturnsExpected(Color value, Color expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripItem_BackColor_SetWithOwnerWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetBackColorTheoryData))]
-    public void ToolStripItem_BackColor_SetWithParent_GetReturnsExpected(Color value, Color expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, Control.DefaultBackColor, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithParentWithHandle_TestData))]
-    public void ToolStripItem_BackColor_SetWithParentWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackColor = value;
-        Assert.Equal(expected, item.BackColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.BackColorChanged += handler;
-
-        // Set different.
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.BackColor = Color.Empty;
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.BackColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.BackColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.BackColor = Color.Red;
-        Assert.Equal(Color.Red, item.BackColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    public static IEnumerable<object[]> BackgroundImage_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripItem_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var item = new SubToolStripItem
-        {
-            BackgroundImage = value
-        };
-        Assert.Equal(value, item.BackgroundImage);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripItem_BackgroundImage_SetWithOwner_GetReturnsExpected(Image value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripItem_BackgroundImage_SetWithOwnerWithHandle_GetReturnsExpected(Image value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripItem_BackgroundImage_SetWithParent_GetReturnsExpected(Image value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackgroundImage_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { null, 0 };
-        yield return new object[] { new Bitmap(10, 10), 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_SetWithParentWithHandle_TestData))]
-    public void ToolStripItem_BackgroundImage_SetWithParentWithHandle_GetReturnsExpected(Image value, int expectedInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripItem_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var item = new SubToolStripItem
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, item.BackgroundImageLayout);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripItem_BackgroundImageLayout_SetWithOwner_GetReturnsExpected(ImageLayout value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripItem_BackgroundImageLayout_SetWithOwnerWithHandle_GetReturnsExpected(ImageLayout value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripItem_BackgroundImageLayout_SetWithParent_GetReturnsExpected(ImageLayout value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ImageLayout.None, 1)]
-    [InlineData(ImageLayout.Tile, 0)]
-    [InlineData(ImageLayout.Center, 1)]
-    [InlineData(ImageLayout.Stretch, 1)]
-    [InlineData(ImageLayout.Zoom, 1)]
-    public void ToolStripItem_BackgroundImageLayout_SetWithParentWithHandle_GetReturnsExpected(ImageLayout value, int expectedInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void ToolStripItem_BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.BackgroundImageLayout = value);
-    }
-
-    public static IEnumerable<object[]> ContentRectangle_GetWithPadding_ReturnsExpected()
-    {
-        yield return new object[] { new Padding(-23), new Rectangle(2, 2, 19, 19) };
-        yield return new object[] { new Padding(-24), new Rectangle(2, 2, 19, 19) };
-        yield return new object[] { new Padding(2), new Rectangle(0, 0, 23, 23) };
-        yield return new object[] { new Padding(23), new Rectangle(-21, -21, 65, 65) };
-        yield return new object[] { new Padding(24), new Rectangle(-22, -22, 67, 67) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContentRectangle_GetWithPadding_ReturnsExpected))]
-    public void ToolStripItem_ContentRectangle_GetWithLargePadding_ReturnsExpected(Padding padding, Rectangle expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            Padding = padding
-        };
-        Assert.Equal(expected, item.ContentRectangle);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DefaultMargin_GetWithToolStripOwner_ReturnsExpected()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DefaultMargin_GetWithToolStripParent_ReturnsExpected()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DefaultMargin_GetWithStatusStripOwner_ReturnsExpected()
-    {
-        using var owner = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(new Padding(0, 2, 0, 0), item.DefaultMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DefaultMargin_GetWithStatusStripParent_ReturnsExpected()
-    {
-        using var parent = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(new Padding(0, 1, 0, 2), item.DefaultMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DisplayStyle_GetWithCustomDisplayStyle_ReturnsExpected()
-    {
-        using var item = new CustomDefaultDisplayStyleToolStripItem();
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-    }
-
-    private class CustomDefaultDisplayStyleToolStripItem : ToolStripItem
-    {
-        protected override ToolStripItemDisplayStyle DefaultDisplayStyle => ToolStripItemDisplayStyle.Text;
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripItem_DisplayStyle_Set_GetReturnsExpected(ToolStripItemDisplayStyle value)
-    {
-        using var item = new SubToolStripItem
-        {
-            DisplayStyle = value
-        };
-        Assert.Equal(value, item.DisplayStyle);
-
-        // Set same.
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemDisplayStyle.None, 1)]
-    [InlineData(ToolStripItemDisplayStyle.Text, 1)]
-    [InlineData(ToolStripItemDisplayStyle.Image, 1)]
-    [InlineData(ToolStripItemDisplayStyle.ImageAndText, 0)]
-    public void ToolStripItem_DisplayStyle_SetWithOwner_GetReturnsExpected(ToolStripItemDisplayStyle value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("DisplayStyle", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.DisplayStyle = value;
-            Assert.Equal(value, item.DisplayStyle);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.DisplayStyle = value;
-            Assert.Equal(value, item.DisplayStyle);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemDisplayStyle.None, 1)]
-    [InlineData(ToolStripItemDisplayStyle.Text, 1)]
-    [InlineData(ToolStripItemDisplayStyle.Image, 1)]
-    [InlineData(ToolStripItemDisplayStyle.ImageAndText, 0)]
-    public void ToolStripItem_DisplayStyle_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripItemDisplayStyle value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("DisplayStyle", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.DisplayStyle = value;
-            Assert.Equal(value, item.DisplayStyle);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.DisplayStyle = value;
-            Assert.Equal(value, item.DisplayStyle);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripItem_DisplayStyle_SetWithParent_GetReturnsExpected(ToolStripItemDisplayStyle value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripItem_DisplayStyle_SetWithParentWithHandle_GetReturnsExpected(ToolStripItemDisplayStyle value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-        Assert.Equal(0, parentLayoutCallCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DisplayStyle_SetWithHandler_CallsDisplayStyleChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.DisplayStyleChanged += handler;
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.None;
-        Assert.Equal(ToolStripItemDisplayStyle.None, item.DisplayStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.DisplayStyleChanged -= handler;
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripItem_DisplayStyle_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemDisplayStyle value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.DisplayStyle = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DisplayStyle_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.DisplayStyle)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_DisplayStyle_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.DisplayStyle)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void ToolStripItem_Dock_Set_GetReturnsExpected(DockStyle value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Dock = value
-        };
-        Assert.Equal(value, item.Dock);
-
-        // Set same.
-        item.Dock = value;
-        Assert.Equal(value, item.Dock);
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void ToolStripItem_Dock_SetWithOwner_GetReturnsExpected(DockStyle value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Dock = value;
-            Assert.Equal(value, item.Dock);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Dock = value;
-            Assert.Equal(value, item.Dock);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<DockStyle>]
-    public void ToolStripItem_Dock_SetWithParent_GetReturnsExpected(DockStyle value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Dock = value;
-            Assert.Equal(value, item.Dock);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Dock = value;
-            Assert.Equal(value, item.Dock);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void ToolStripItem_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_DoubleClickEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            DoubleClickEnabled = value
-        };
-        Assert.Equal(value, item.DoubleClickEnabled);
-
-        // Set same.
-        item.DoubleClickEnabled = value;
-        Assert.Equal(value, item.DoubleClickEnabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void ToolStripItem_Enabled_GetWithOwner_ReturnsExpected(bool ownerEnabled, bool enabled, bool expected)
-    {
-        using var owner = new ToolStrip
-        {
-            Enabled = ownerEnabled
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(ownerEnabled, item.Enabled);
-
-        // Set custom.
-        item.Enabled = enabled;
-        Assert.Equal(expected, item.Enabled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, true)]
-    [InlineData(false, false, false)]
-    public void ToolStripItem_Enabled_GetWithParent_ReturnsExpected(bool parentEnabled, bool enabled, bool expected)
-    {
-        using var parent = new ToolStrip
-        {
-            Enabled = parentEnabled
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.True(item.Enabled);
-
-        // Set custom.
-        item.Enabled = enabled;
-        Assert.Equal(expected, item.Enabled);
-    }
-
-    public static IEnumerable<object[]> Enabled_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true };
-                yield return new object[] { visible, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_Set_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Enabled = value
-        };
-        Assert.Equal(value, item.Enabled);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_Enabled_SetSelected_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem();
-        item.Select();
-        Assert.True(item.Selected);
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.Equal(value, item.Selected);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.Equal(value, item.Selected);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Enabled_SetPressed_GetReturnsExpected()
-    {
-        using var item = new SubToolStripItem();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            item.Enabled = false;
-            Assert.False(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetDesignMode_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object,
-            Enabled = value
-        };
-        Assert.Equal(value, item.Enabled);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetWithOwner_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetWithImageWithOwner_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetDesignModeWithOwner_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object,
-            Owner = owner
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetWithOwnerWithHandle_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetWithParent_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetWithImageWithParent_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripItem_Enabled_SetDesignModeWithParent_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Site = mockSite.Object,
-            Parent = parent
-        };
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Enabled_SetWithParentWithHandle_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true, 0 };
-                yield return new object[] { visible, image, false, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_SetWithParentWithHandle_TestData))]
-    public void ToolStripItem_Enabled_SetWithParentWithHandle_GetReturnsExpected(bool visible, Image image, bool value, int expectedInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.EnabledChanged += handler;
-
-        // Set different.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Enabled = true;
-        Assert.True(item.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.Enabled = false;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Font_GetWithParent_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var parent = new ToolStrip
-        {
-            Font = font
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotNull(item.Font);
-        Assert.NotSame(font, item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Font_GetWithOwner_ReturnsExpected()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var owner = new ToolStrip
-        {
-            Font = font
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Same(font, item.Font);
-    }
-
-    public static IEnumerable<object[]> Font_Set_TestData()
-    {
-        foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-            yield return new object[] { displayStyle, new Font("Arial", 8.25f) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ToolStripItem_Font_Set_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value)
-    {
-        using var item = new SubToolStripItem
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.Font = value;
-        Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-
-        // Set same.
-        item.Font = value;
-        Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithOwner_TestData()
-    {
-        foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null, 0 };
-        }
-
-        yield return new object[] { ToolStripItemDisplayStyle.None, new Font("Arial", 8.25f), 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.Text, new Font("Arial", 8.25f), 1 };
-        yield return new object[] { ToolStripItemDisplayStyle.Image, new Font("Arial", 8.25f), 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.ImageAndText, new Font("Arial", 8.25f), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithOwner_TestData))]
-    public void ToolStripItem_Font_SetWithOwner_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithOwner_TestData))]
-    public void ToolStripItem_Font_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ToolStripItem_Font_SetWithParent_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ToolStripItem_Font_SetWithParentWithHandle_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Font = value;
-            Assert.Equal(value ?? new SubToolStripItem().Font, item.Font);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Font_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Font)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        using var font = new Font("Arial", 8.25f);
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.CanResetValue(item));
-
-        item.Font = null;
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.False(property.CanResetValue(item));
-
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Font_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Font)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        using var font = new Font("Arial", 8.25f);
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.Font = null;
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Font = font;
-        Assert.Same(font, item.Font);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ForeColor_GetWithOwner_ReturnsExpected()
-    {
-        using var owner = new ToolStrip
-        {
-            ForeColor = Color.Red
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ForeColor_GetWithParent_ReturnsExpected()
-    {
-        using var parent = new ToolStrip
-        {
-            ForeColor = Color.Red
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(Color.Red, item.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripItem_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, item.ForeColor);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripItem_ForeColor_SetWithOwner_GetReturnsExpected(Color value, Color expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripItem_ForeColor_SetWithOwnerWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripItem_ForeColor_SetWithParent_GetReturnsExpected(Color value, Color expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, Control.DefaultForeColor, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithParentWithHandle_TestData))]
-    public void ToolStripItem_ForeColor_SetWithParentWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.ForeColorChanged += handler;
-
-        // Set different.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ForeColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ForeColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Height_Set_GetReturnsExpected(int value)
-    {
-        using var item = new SubToolStripItem();
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        item.Height = value;
-        Assert.Equal(value, item.Height);
-        Assert.Equal(0, locationChangedCallCount);
-
-        // Set same.
-        item.Height = value;
-        Assert.Equal(value, item.Height);
-        Assert.Equal(0, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Height_SetWithOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Height_SetWithOwnerWithHandle_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(23, 0)]
-    public void ToolStripItem_Height_SetWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(23, 0)]
-    public void ToolStripItem_Height_SetWithParentWithHandle_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Height = value;
-            Assert.Equal(value, item.Height);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Image_GetWithOwner_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ImageList() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_GetWithOwner_TestData))]
-    public void ToolStripItem_Image_GetWithOwner_ReturnsNull(ImageList imageList)
-    {
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Null(item.Image);
-
-        // Get again to test caching behavior.
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_GetWithValidImageIndexWithOwner_ReturnsExpected()
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = 0,
-            Owner = owner
-        };
-        Assert.NotNull(item.Image);
-
-        // Get again to test caching behavior.
-        Assert.Same(item.Image, item.Image);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_GetWithInvalidImageIndexWithOwner_ReturnsExpected()
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = 1,
-            Owner = owner
-        };
-        Assert.Null(item.Image);
-
-        // Get again to test caching behavior.
-        Assert.Null(item.Image);
-    }
-
-    public static IEnumerable<object[]> Image_GetWithParent_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ImageList() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_GetWithParent_TestData))]
-    public void ToolStripItem_Image_GetWithParent_ReturnsNull(ImageList imageList)
-    {
-        using var parent = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Null(item.Image);
-
-        // Get again to test caching behavior.
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_Image_GetWithImageIndexWithParent_ReturnsExpected(int imageIndex)
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var parent = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = imageIndex,
-            Parent = parent
-        };
-        Assert.Null(item.Image);
-
-        // Get again to test caching behavior.
-        Assert.Null(item.Image);
-    }
-
-    public static IEnumerable<object[]> Image_Set_TestData()
-    {
-        foreach (Color imageTransparentColor in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { imageTransparentColor, null };
-            yield return new object[] { imageTransparentColor, new Bitmap(10, 10) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripItem_Image_Set_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-    }
-
-    public static IEnumerable<object[]> Image_SetWithImageIndex_TestData()
-    {
-        foreach (Color imageTransparentColor in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { imageTransparentColor, null, 1 };
-            yield return new object[] { imageTransparentColor, new Bitmap(10, 10), -1 };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), -1 };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), -1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithImageIndex_TestData))]
-    public void ToolStripItem_Image_SetWithImageIndex_GetReturnsExpected(Color imageTransparentColor, Image value, int expectedImageIndex)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor,
-            ImageIndex = 1
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(expectedImageIndex, item.ImageIndex);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(expectedImageIndex, item.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripItem_Image_SetWithNonNullOldValue_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var oldValue = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = oldValue,
-            ImageTransparentColor = imageTransparentColor
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithImageIndex_TestData))]
-    public void ToolStripItem_Image_SetWithNonNullOldValueWithImageIndex_GetReturnsExpected(Color imageTransparentColor, Image value, int expectedImageIndex)
-    {
-        using var oldValue = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = oldValue,
-            ImageTransparentColor = imageTransparentColor,
-            ImageIndex = 1
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(expectedImageIndex, item.ImageIndex);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(expectedImageIndex, item.ImageIndex);
-    }
-
-    public static IEnumerable<object[]> Image_SetWithOwner_TestData()
-    {
-        foreach (Color imageTransparentColor in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { imageTransparentColor, null, 0 };
-            yield return new object[] { imageTransparentColor, new Bitmap(10, 10), 1 };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), 1 };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithOwner_TestData))]
-    public void ToolStripItem_Image_SetWithOwner_GetReturnsExpected(Color imageTransparentColor, Image value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor,
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            if (e.AffectedProperty != "ImageIndex")
-            {
-                Assert.Same(owner, sender);
-                Assert.Same(item, e.AffectedComponent);
-                Assert.Equal("Image", e.AffectedProperty);
-                ownerLayoutCallCount++;
-            }
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_SetWithOwner_TestData))]
-    public void ToolStripItem_Image_SetWithOwnerWithHandle_GetReturnsExpected(Color imageTransparentColor, Image value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            if (e.AffectedProperty != "ImageIndex")
-            {
-                Assert.Same(owner, sender);
-                Assert.Same(item, e.AffectedComponent);
-                Assert.Equal("Image", e.AffectedProperty);
-                ownerLayoutCallCount++;
-            }
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripItem_Image_SetWithParent_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor,
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripItem_Image_SetWithParentWithHandle_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            ImageTransparentColor = imageTransparentColor,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Image = value;
-            Assert.Equal(value, item.Image);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Image)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        using var image = new Bitmap(10, 10);
-        item.Image = image;
-        Assert.Same(image, item.Image);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.Image);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_ResetValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Image)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = 0,
-            Owner = owner
-        };
-        Assert.False(property.CanResetValue(item));
-
-        using var otherImage = new Bitmap(10, 10);
-        item.Image = otherImage;
-        Assert.Same(otherImage, item.Image);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.Image);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Image)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        using var image = new Bitmap(10, 10);
-        item.Image = image;
-        Assert.Same(image, item.Image);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.Image);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Image_ShouldSerializeValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Image)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = 0,
-            Owner = owner
-        };
-        Assert.False(property.ShouldSerializeValue(item));
-
-        using var otherImage = new Bitmap(10, 10);
-        item.Image = otherImage;
-        Assert.Same(otherImage, item.Image);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.Image);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_ImageAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageAlign = value
-        };
-        Assert.Equal(value, item.ImageAlign);
-
-        // Set same.
-        item.ImageAlign = value;
-        Assert.Equal(value, item.ImageAlign);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ContentAlignment.TopLeft, 1)]
-    [InlineData(ContentAlignment.TopCenter, 1)]
-    [InlineData(ContentAlignment.TopRight, 1)]
-    [InlineData(ContentAlignment.MiddleLeft, 1)]
-    [InlineData(ContentAlignment.MiddleCenter, 0)]
-    [InlineData(ContentAlignment.MiddleRight, 1)]
-    [InlineData(ContentAlignment.BottomLeft, 1)]
-    [InlineData(ContentAlignment.BottomCenter, 1)]
-    [InlineData(ContentAlignment.BottomRight, 1)]
-    public void ToolStripItem_ImageAlign_SetWithOwner_GetReturnsExpected(ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageAlign", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ContentAlignment.TopLeft, 1)]
-    [InlineData(ContentAlignment.TopCenter, 1)]
-    [InlineData(ContentAlignment.TopRight, 1)]
-    [InlineData(ContentAlignment.MiddleLeft, 1)]
-    [InlineData(ContentAlignment.MiddleCenter, 0)]
-    [InlineData(ContentAlignment.MiddleRight, 1)]
-    [InlineData(ContentAlignment.BottomLeft, 1)]
-    [InlineData(ContentAlignment.BottomCenter, 1)]
-    [InlineData(ContentAlignment.BottomRight, 1)]
-    public void ToolStripItem_ImageAlign_SetWithOwnerWithHandle_GetReturnsExpected(ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageAlign", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_ImageAlign_SetWithParent_GetReturnsExpected(ContentAlignment value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_ImageAlign_SetWithParentWithHandle_GetReturnsExpected(ContentAlignment value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageAlign = value;
-            Assert.Equal(value, item.ImageAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripItem_ImageAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.ImageAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_Set_GetReturnsExpected(int value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageIndex = value;
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithImage_GetReturnsExpected(int value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            ImageIndex = value
-        };
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageIndex = value;
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithImageKey_GetReturnsExpected(int value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageKey = "ImageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageIndex = value;
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageIndex", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1, false)]
-    [InlineData(0, 0, true)]
-    [InlineData(1, 0, false)]
-    public void ToolStripItem_ImageIndex_SetWithOwnerWithImageList_GetReturnsExpected(int value, int expected, bool expectedHasImage)
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageIndex", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(expected, item.ImageIndex);
-            Assert.Empty(item.ImageKey);
-            Assert.Equal(expectedHasImage, item.Image is not null);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(expected, item.ImageIndex);
-            Assert.Empty(item.ImageKey);
-            Assert.Equal(expectedHasImage, item.Image is not null);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithOwnerWithHandle_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageIndex", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithParent_GetReturnsExpected(int value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithParentWithImageList_GetReturnsExpected(int value)
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var parent = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripItem_ImageIndex_SetWithParentWithHandle_GetReturnsExpected(int value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageIndex = value;
-            Assert.Equal(value, item.ImageIndex);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException()
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => item.ImageIndex = -2);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ResetValueWithImage_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ResetValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ShouldSerializeValueWithImage_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        Assert.False(property.ShouldSerializeValue(item));
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(0, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageIndex_ShouldSerializeValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageIndex)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.ImageIndex = 0;
-        Assert.Equal(0, item.ImageIndex);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.ImageIndex = -1;
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageKey = value;
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithImage_GetReturnsExpected(string value, string expected)
-    {
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            ImageKey = value
-        };
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageKey = value;
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithImageIndex_GetReturnsExpected(string value, string expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageIndex = 1,
-            ImageKey = value
-        };
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageKey = value;
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithOwner_GetReturnsExpected(string value, string expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageKey", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("Image", "Image", true)]
-    [InlineData("image", "image", true)]
-    [InlineData("OtherImage", "OtherImage", false)]
-    public void ToolStripItem_ImageKey_SetWithOwnerWithImageList_GetReturnsExpected(string value, string expected, bool expectedHasImage)
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image", image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageKey", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedHasImage, item.Image is not null);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Equal(-1, item.ImageIndex);
-            Assert.Equal(expectedHasImage, item.Image is not null);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithOwnerWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageKey", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithParent_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithParentWithImageList_GetReturnsExpected(string value, string expected)
-    {
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        using var parent = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_ImageKey_SetWithParentWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageKey = value;
-            Assert.Equal(expected, item.ImageKey);
-            Assert.Null(item.Image);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageKey_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        // Set null.
-        item.ImageKey = null;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        // Set empty.
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.ImageKey = "text";
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageKey_ResetValueWithImage_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        Assert.False(property.CanResetValue(item));
-
-        // Set null.
-        item.ImageKey = null;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        // Set empty.
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.ImageKey = "text";
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageKey_ResetValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image", image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageKey = "Image";
-        Assert.Equal("Image", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageKey = "NoSuchImage";
-        Assert.Equal("NoSuchImage", item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageKey_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set null.
-        item.ImageKey = null;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set empty.
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.ImageKey = "text";
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageKey_ShouldSerializeValueWithImage_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set null.
-        item.ImageKey = null;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set empty.
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.ImageKey = "text";
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal("text", item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact(Skip = "https://github.com/dotnet/winforms/issues/8636")]
-    public void ToolStripItem_ImageKey_ShouldSerializeValueWithOwnerWithImageList_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageKey)];
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image", image);
-        using var owner = new ToolStrip
-        {
-            ImageList = imageList
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ImageKey = "Image";
-        Assert.Equal("Image", item.ImageKey);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.ImageKey = "NoSuchImage";
-        Assert.Equal("NoSuchImage", item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ImageKey = string.Empty;
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Empty(item.ImageKey);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemImageScaling>]
-    public void ToolStripItem_ImageScaling_Set_GetReturnsExpected(ToolStripItemImageScaling value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ImageScaling = value
-        };
-        Assert.Equal(value, item.ImageScaling);
-
-        // Set same.
-        item.ImageScaling = value;
-        Assert.Equal(value, item.ImageScaling);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemImageScaling.None, 1)]
-    [InlineData(ToolStripItemImageScaling.SizeToFit, 0)]
-    public void ToolStripItem_ImageScaling_SetWithOwner_GetReturnsExpected(ToolStripItemImageScaling value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageScaling", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemImageScaling.None, 1)]
-    [InlineData(ToolStripItemImageScaling.SizeToFit, 0)]
-    public void ToolStripItem_ImageScaling_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripItemImageScaling value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("ImageScaling", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemImageScaling>]
-    public void ToolStripItem_ImageScaling_SetWithParent_GetReturnsExpected(ToolStripItemImageScaling value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemImageScaling>]
-    public void ToolStripItem_ImageScaling_SetWithParentWithHandle_GetReturnsExpected(ToolStripItemImageScaling value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.ImageScaling = value;
-            Assert.Equal(value, item.ImageScaling);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemImageScaling>]
-    public void ToolStripItem_ImageScaling_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemImageScaling value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.ImageScaling = value);
-    }
-
-    public static IEnumerable<object[]> ImageTransparentColor_Set_TestData()
-    {
-        foreach (Color color in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { null, color };
-            yield return new object[] { new Bitmap(10, 10), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), color };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripItem_ImageTransparentColor_Set_GetReturnsExpected(Image image, Color value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripItem_ImageTransparentColor_SetWithCustomOldValue_GetReturnsExpected(Image image, Color value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            ImageTransparentColor = Color.Red
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripItem_ImageTransparentColor_SetWithOwner_GetReturnsExpected(Image image, Color value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            Image = image
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageTransparentColor_SetWithOwnerWithHandle_TestData()
-    {
-        yield return new object[] { null, Color.Empty, 0 };
-        yield return new object[] { null, Color.Red, 0 };
-        yield return new object[] { new Bitmap(10, 10), Color.Empty, 0 };
-        yield return new object[] { new Bitmap(10, 10), Color.Red, 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), Color.Empty, 0 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), Color.Red, 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), Color.Empty, 0 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_SetWithOwnerWithHandle_TestData))]
-    public void ToolStripItem_ImageTransparentColor_SetWithOwnerWithHandle_GetReturnsExpected(Image image, Color value, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripItem_ImageTransparentColor_SetWithParent_GetReturnsExpected(Image image, Color value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            Image = image
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ImageTransparentColor_SetWithParentWithHandle_TestData()
-    {
-        yield return new object[] { null, Color.Empty, 0 };
-        yield return new object[] { null, Color.Red, 1 };
-        yield return new object[] { new Bitmap(10, 10), Color.Empty, 0 };
-        yield return new object[] { new Bitmap(10, 10), Color.Red, 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), Color.Empty, 0 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), Color.Red, 1 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), Color.Empty, 0 };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_SetWithParentWithHandle_TestData))]
-    public void ToolStripItem_ImageTransparentColor_SetWithParentWithHandle_GetReturnsExpected(Image image, Color value, int expectedParentInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            Image = image
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedParentInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(expectedParentInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageTransparentColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageTransparentColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.ImageTransparentColor = Color.Red;
-        Assert.Equal(Color.Red, item.ImageTransparentColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ImageTransparentColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ImageTransparentColor)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ImageTransparentColor = Color.Red;
-        Assert.Equal(Color.Red, item.ImageTransparentColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithOwner_ReturnsFalse()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithDropDownOwner_ReturnsTrue()
-    {
-        using var owner = new ToolStripDropDown();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.True(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithOverflowingOwner_ReturnsTrue()
-    {
-        using var owner = new ToolStrip
-        {
-            Size = new Size(1, 2)
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(item.IsOnDropDown);
-        owner.LayoutEngine.Layout(owner, null);
-        Assert.True(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithParent_ReturnsFalse()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.False(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithDropDownParent_ReturnsTrue()
-    {
-        using var parent = new ToolStripDropDown();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.True(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_IsOnDropDown_GetWithOverflowingParent_ReturnsFalse()
-    {
-        using var parent = new ToolStrip
-        {
-            Size = new Size(1, 2)
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.False(item.IsOnDropDown);
-        parent.LayoutEngine.Layout(parent, null);
-        Assert.False(item.IsOnDropDown);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Margin_GetWithDefaultMargin_ReturnsExpected()
-    {
-        using var item = new CustomDefaultMarginToolStripItem();
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-    }
-
-    private class CustomDefaultMarginToolStripItem : ToolStripItem
-    {
-        protected internal override Padding DefaultMargin => new(1, 2, 3, 4);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripItem_Margin_Set_GetReturnsExpected(Padding value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Margin = value
-        };
-        Assert.Equal(value, item.Margin);
-
-        // Set same.
-        item.Margin = value;
-        Assert.Equal(value, item.Margin);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripItem_Margin_SetWithOwner_GetReturnsExpected(Padding value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Margin", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripItem_Margin_SetWithOwnerWithHandle_GetReturnsExpected(Padding value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Margin", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripItem_Margin_SetWithParent_GetReturnsExpected(Padding value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Margin", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStripItem_Margin_SetWithParentWithHandle_GetReturnsExpected(Padding value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Margin", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Margin = value;
-            Assert.Equal(value, item.Margin);
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Margin_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Margin)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.Margin = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Margin_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Margin)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Margin = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [EnumData<MergeAction>]
-    public void ToolStripItem_MergeAction_Set_GetReturnsExpected(MergeAction value)
-    {
-        using var item = new SubToolStripItem
-        {
-            MergeAction = value
-        };
-        Assert.Equal(value, item.MergeAction);
-
-        // Set same.
-        item.MergeAction = value;
-        Assert.Equal(value, item.MergeAction);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<MergeAction>]
-    public void ToolStripItem_MergeAction_SetInvalid_ThrowsInvalidEnumArgumentException(MergeAction value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.MergeAction = value);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_MergeIndex_Set_GetReturnsExpected(int value)
-    {
-        using var item = new SubToolStripItem
-        {
-            MergeIndex = value
-        };
-        Assert.Equal(value, item.MergeIndex);
-
-        // Set same.
-        item.MergeIndex = value;
-        Assert.Equal(value, item.MergeIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripItem_Name_GetWithSite_ReturnsExpected(string siteName, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns(siteName);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-        Assert.Equal(expected, item.Name);
-        mockSite.Verify(s => s.Name, Times.Once());
-
-        // Get again.
-        Assert.Equal(expected, item.Name);
-        mockSite.Verify(s => s.Name, Times.Exactly(2));
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_Name_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Name = value
-        };
-        Assert.Equal(value, item.Name);
-
-        // Set same.
-        item.Name = value;
-        Assert.Equal(value, item.Name);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_Name_SetDesignMode_Nop(string value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-
-        item.Name = value;
-        Assert.Equal("name", item.Name);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemOverflow>]
-    public void ToolStripItem_Overflow_Set_GetReturnsExpected(ToolStripItemOverflow value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Overflow = value
-        };
-        Assert.Equal(value, item.Overflow);
-        Assert.False(item.IsOnOverflow);
-
-        // Set same.
-        item.Overflow = value;
-        Assert.Equal(value, item.Overflow);
-        Assert.False(item.IsOnOverflow);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemOverflow.Never, ToolStripItemPlacement.Main, 1)]
-    [InlineData(ToolStripItemOverflow.Always, ToolStripItemPlacement.Overflow, 1)]
-    [InlineData(ToolStripItemOverflow.AsNeeded, ToolStripItemPlacement.None, 0)]
-    public void ToolStripItem_Overflow_SetWithOwner_GetReturnsExpected(ToolStripItemOverflow value, ToolStripItemPlacement expectedPlacement, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(owner, e.AffectedComponent);
-            Assert.Equal("Overflow", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.Equal(value == ToolStripItemOverflow.Always, item.IsOnOverflow);
-            Assert.Equal(expectedPlacement, item.Placement);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.Equal(value == ToolStripItemOverflow.Always, item.IsOnOverflow);
-            Assert.Equal(expectedPlacement, item.Placement);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripItemOverflow.Never, ToolStripItemPlacement.Main, 1)]
-    [InlineData(ToolStripItemOverflow.Always, ToolStripItemPlacement.Overflow, 1)]
-    [InlineData(ToolStripItemOverflow.AsNeeded, ToolStripItemPlacement.None, 0)]
-    public void ToolStripItem_Overflow_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripItemOverflow value, ToolStripItemPlacement expectedPlacement, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(owner, e.AffectedComponent);
-            Assert.Equal("Overflow", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.Equal(value == ToolStripItemOverflow.Always, item.IsOnOverflow);
-            Assert.Equal(expectedPlacement, item.Placement);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.Equal(value == ToolStripItemOverflow.Always, item.IsOnOverflow);
-            Assert.Equal(expectedPlacement, item.Placement);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemOverflow>]
-    public void ToolStripItem_Overflow_SetWithParent_GetReturnsExpected(ToolStripItemOverflow value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.False(item.IsOnOverflow);
-            Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.False(item.IsOnOverflow);
-            Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemOverflow>]
-    public void ToolStripItem_Overflow_SetWithParentWithHandle_GetReturnsExpected(ToolStripItemOverflow value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.False(item.IsOnOverflow);
-            Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Overflow = value;
-            Assert.Equal(value, item.Overflow);
-            Assert.False(item.IsOnOverflow);
-            Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemOverflow>]
-    public void ToolStripItem_Overflow_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemOverflow value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.Overflow = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Owner_Set_GetReturnsExpected()
-    {
-        using var owner = new ToolStrip();
-        using var otherOwner = new ToolStrip();
-        using var statusOwner = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Same(owner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.Owner = otherOwner;
-        Assert.Same(otherOwner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Same(item, Assert.Single(otherOwner.Items));
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.Owner = null;
-        Assert.Null(item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.Owner = statusOwner;
-        Assert.Same(statusOwner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Empty(otherOwner.Items);
-        Assert.Same(item, Assert.Single(statusOwner.Items));
-        Assert.Equal(new Padding(0, 2, 0, 0), item.Margin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Owner_SetWithMargin_GetReturnsExpected()
-    {
-        using var owner = new ToolStrip();
-        using var otherOwner = new ToolStrip();
-        using var statusOwner = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Margin = new Padding(1, 2, 3, 4),
-            Owner = owner
-        };
-        Assert.Same(owner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set same.
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set different.
-        item.Owner = otherOwner;
-        Assert.Same(otherOwner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Same(item, Assert.Single(otherOwner.Items));
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set null.
-        item.Owner = null;
-        Assert.Null(item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set status strip.
-        item.Owner = statusOwner;
-        Assert.Same(statusOwner, item.Owner);
-        Assert.Null(item.Parent);
-        Assert.Empty(owner.Items);
-        Assert.Empty(otherOwner.Items);
-        Assert.Same(item, Assert.Single(statusOwner.Items));
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.Yes, RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Inherit, RightToLeft.Yes, 1)]
-    [InlineData(RightToLeft.No, RightToLeft.Yes, RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.No, RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.No, RightToLeft.Inherit, RightToLeft.No, 1)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Yes, RightToLeft.Yes, 0)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.Inherit, RightToLeft.No, 1)]
-    public void ToolStripItem_Owner_SetWithRightToLeft_CallsRightToLeftChanged(RightToLeft ownerRightToLeft, RightToLeft rightToLeft, RightToLeft expectedRightToLeft, int expectedRightToLeftChangedCallCount)
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = ownerRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            RightToLeft = rightToLeft
-        };
-        int rightToLeftChangedCallCount = 0;
-        item.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rightToLeftChangedCallCount++;
-        };
-
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Equal(expectedRightToLeft, item.RightToLeft);
-        Assert.Equal(expectedRightToLeftChangedCallCount, rightToLeftChangedCallCount);
-
-        // Set same.
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Equal(expectedRightToLeft, item.RightToLeft);
-        Assert.Equal(expectedRightToLeftChangedCallCount, rightToLeftChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Owner_SetWithHandler_CallsOwnerChanged()
-    {
-        using var owner = new ToolStrip();
-        using var otherOwner = new ToolStrip();
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        item.OwnerChanged += handler;
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Owner = otherOwner;
-        Assert.Same(otherOwner, item.Owner);
-        Assert.Empty(owner.Items);
-        Assert.Same(item, Assert.Single(otherOwner.Items));
-        Assert.Equal(3, callCount);
-
-        // Set null.
-        item.Owner = null;
-        Assert.Null(item.Owner);
-        Assert.Empty(owner.Items);
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(4, callCount);
-
-        // Remove handler.
-        item.OwnerChanged -= handler;
-        item.Owner = owner;
-        Assert.Same(owner, item.Owner);
-        Assert.Same(item, Assert.Single(owner.Items));
-        Assert.Empty(otherOwner.Items);
-        Assert.Equal(4, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OwnerItem_GetWithOwner_ReturnsNull()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Null(item.OwnerItem);
-    }
-
-    public static IEnumerable<object[]> OwnerItem_GetWithDropDown_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubToolStripItem() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OwnerItem_GetWithDropDown_TestData))]
-    public void ToolStripItem_OwnerItem_GetWithDropDownOwner_ReturnsExpected(ToolStripItem result)
-    {
-        using var owner = new ToolStripDropDown
-        {
-            OwnerItem = result
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Same(result, item.OwnerItem);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OwnerItem_GetWithParent_ReturnsNull()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Null(item.OwnerItem);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OwnerItem_GetWithDropDown_TestData))]
-    public void ToolStripItem_OwnerItem_GetWithDropDownParent_ReturnsExpected(ToolStripItem result)
-    {
-        using var parent = new ToolStripDropDown
-        {
-            OwnerItem = result
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Same(result, item.OwnerItem);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OwnerItem_GetWithOwnerAndParent_ReturnsExpected()
-    {
-        using var ownerItem = new SubToolStripItem();
-        using var owner = new ToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        using var parentItem = new SubToolStripItem();
-        using var parent = new ToolStripDropDown
-        {
-            OwnerItem = parentItem
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        Assert.Same(parentItem, item.OwnerItem);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Padding_GetWithDefaultPadding_ReturnsExpected()
-    {
-        using var item = new CustomDefaultPaddingToolStripItem();
-        Assert.Equal(new Padding(2, 3, 4, 5), item.Padding);
-    }
-
-    private class CustomDefaultPaddingToolStripItem : ToolStripItem
-    {
-        protected override Padding DefaultPadding => new(2, 3, 4, 5);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ToolStripItem_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, item.Padding);
-
-        // Set same.
-        item.Padding = value;
-        Assert.Equal(expected, item.Padding);
-    }
-
-    public static IEnumerable<object[]> Padding_SetWithOwner_TestData()
-    {
-        yield return new object[] { new Padding(), new Padding(), 0, 0 };
-        yield return new object[] { new Padding(1, 2, 3, 4), new Padding(1, 2, 3, 4), 1, 1 };
-        yield return new object[] { new Padding(1), new Padding(1), 1, 1 };
-        yield return new object[] { new Padding(-1, -2, -3, -4), Padding.Empty, 1, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_SetWithOwner_TestData))]
-    public void ToolStripItem_Padding_SetWithOwner_GetReturnsExpected(Padding value, Padding expected, int expectedOwnerLayoutCallCount1, int expectedOwnerLayoutCallCount2)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Padding", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(expectedOwnerLayoutCallCount1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(expectedOwnerLayoutCallCount2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Padding_SetWithOwner_TestData))]
-    public void ToolStripItem_Padding_SetWithOwnerWithHandle_GetReturnsExpected(Padding value, Padding expected, int expectedOwnerLayoutCallCount1, int expectedOwnerLayoutCallCount2)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Padding", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(expectedOwnerLayoutCallCount1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount1 * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(expectedOwnerLayoutCallCount2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount2 * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ToolStripItem_Padding_SetWithParent_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void ToolStripItem_Padding_SetWithParentWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Padding = value;
-            Assert.Equal(expected, item.Padding);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Padding_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Padding)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.Padding = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Padding);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Padding_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Padding)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Padding = new Padding(1, 2, 3, 4);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Padding);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    public static IEnumerable<object[]> Parent_Set_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    foreach (bool allowDrop in new bool[] { true, false })
-                    {
-                        yield return new object[] { enabled, visible, image, allowDrop };
-                        yield return new object[] { enabled, visible, image, allowDrop };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripItem_Parent_Set_GetReturnsExpected(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Parent = parent
-        };
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set same.
-        item.Parent = parent;
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set different.
-        item.Parent = otherParent;
-        Assert.Same(otherParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set null.
-        item.Parent = null;
-        Assert.Null(item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Set status strip.
-        item.Parent = statusParent;
-        Assert.Same(statusParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(statusParent.Items);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Parent_Set_TestData))]
-    public void ToolStripItem_Parent_SetWithMargin_GetReturnsExpected(bool enabled, bool visible, Image image, bool allowDrop)
-    {
-        using var parent = new ToolStrip();
-        using var otherParent = new ToolStrip();
-        using var statusParent = new StatusStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop,
-            Margin = new Padding(1, 2, 3, 4),
-            Parent = parent
-        };
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set same.
-        item.Parent = parent;
-        Assert.Same(parent, item.Parent);
-        Assert.Same(parent, item.GetCurrentParent());
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set different.
-        item.Parent = otherParent;
-        Assert.Same(otherParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set null.
-        item.Parent = null;
-        Assert.Null(item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Set status strip.
-        item.Parent = statusParent;
-        Assert.Same(statusParent, item.Parent);
-        Assert.Null(item.Owner);
-        Assert.Empty(parent.Items);
-        Assert.Empty(otherParent.Items);
-        Assert.Empty(statusParent.Items);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Releases_UiaProvider()
-    {
-        using ToolStripWithDisconnectCount toolStrip = new();
-
-        using ToolStripDropDownItemWithAccessibleObjectFieldAccessor toolStripDropDownItem1 = new();
-        toolStrip.Items.Add(toolStripDropDownItem1);
-
-        using ToolStripDropDownItemWithAccessibleObjectFieldAccessor toolStripDropDownItem2 = new();
-        toolStripDropDownItem1.DropDownItems.Add(toolStripDropDownItem2);
-
-        _ = toolStrip.AccessibilityObject;
-        Assert.True(toolStrip.IsAccessibilityObjectCreated);
-
-        toolStrip.ReleaseUiaProvider(toolStrip.HWND);
-
-        Assert.Equal(1, toolStrip.Disconnects);
-        Assert.True(toolStripDropDownItem1.IsAccessibleObjectCleared());
-        Assert.True(toolStripDropDownItem2.IsAccessibleObjectCleared());
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes)]
-    [InlineData(RightToLeft.No, RightToLeft.No)]
-    public void ToolStripItem_RightToLeft_GetWithOwner_ReturnsExpected(RightToLeft ownerRightToLeft, RightToLeft expected)
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = ownerRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(expected, item.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No)]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes)]
-    [InlineData(RightToLeft.No, RightToLeft.No)]
-    public void ToolStripItem_RightToLeft_GetWithParent_ReturnsExpected(RightToLeft parentRightToLeft, RightToLeft expected)
-    {
-        using var parent = new ToolStrip
-        {
-            RightToLeft = parentRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(expected, item.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_RightToLeft_GetWithOwnerAndParent_ReturnsExpected()
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var parent = new ToolStrip
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RightToLeft>]
-    public void ToolStripItem_RightToLeft_Set_GetReturnsExpected(RightToLeft value)
-    {
-        using var item = new SubToolStripItem
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(value, item.RightToLeft);
-
-        // Set same.
-        item.RightToLeft = value;
-        Assert.Equal(value, item.RightToLeft);
-    }
-
-    public static IEnumerable<object[]> RightToLeft_SetWithOwner_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Yes, RightToLeft.Yes, 0 };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.No, RightToLeft.No, 1 };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Inherit, RightToLeft.Yes, 0 };
-        yield return new object[] { RightToLeft.No, RightToLeft.Yes, RightToLeft.Yes, 1 };
-        yield return new object[] { RightToLeft.No, RightToLeft.No, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.No, RightToLeft.Inherit, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Yes, RightToLeft.Yes, 1 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.No, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Inherit, RightToLeft.No, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_SetWithOwner_TestData))]
-    public void ToolStripItem_RightToLeft_SetWithOwner_GetReturnsExpected(RightToLeft ownerRightToLeft, RightToLeft value, RightToLeft expected, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = ownerRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_SetWithOwner_TestData))]
-    public void ToolStripItem_RightToLeft_SetWithOwnerWithHandle_GetReturnsExpected(RightToLeft ownerRightToLeft, RightToLeft value, RightToLeft expected, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = ownerRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> RightToLeft_SetWithParent_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Yes, RightToLeft.Yes };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.No, RightToLeft.No };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Inherit, RightToLeft.Yes };
-        yield return new object[] { RightToLeft.No, RightToLeft.Yes, RightToLeft.Yes };
-        yield return new object[] { RightToLeft.No, RightToLeft.No, RightToLeft.No };
-        yield return new object[] { RightToLeft.No, RightToLeft.Inherit, RightToLeft.No };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Yes, RightToLeft.Yes };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.No, RightToLeft.No };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Inherit, RightToLeft.No };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_SetWithParent_TestData))]
-    public void ToolStripItem_RightToLeft_SetWithParent_GetReturnsExpected(RightToLeft parentRightToLeft, RightToLeft value, RightToLeft expected)
-    {
-        using var parent = new ToolStrip
-        {
-            RightToLeft = parentRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(RightToLeft_SetWithParent_TestData))]
-    public void ToolStripItem_RightToLeft_SetWithParentWithHandle_GetReturnsExpected(RightToLeft parentRightToLeft, RightToLeft value, RightToLeft expected)
-    {
-        using var parent = new ToolStrip
-        {
-            RightToLeft = parentRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.RightToLeft = value;
-            Assert.Equal(expected, item.RightToLeft);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.RightToLeftChanged += handler;
-
-        // Set different.
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.RightToLeftChanged -= handler;
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ToolStripItem_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.RightToLeft = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_RightToLeft_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.RightToLeft)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(property.CanResetValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_RightToLeft_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.RightToLeft)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.RightToLeft = RightToLeft.No;
-        Assert.Equal(RightToLeft.No, item.RightToLeft);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_RightToLeftAutoMirrorImage_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            RightToLeftAutoMirrorImage = value
-        };
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-
-        // Set same.
-        item.RightToLeftAutoMirrorImage = value;
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-
-        // Set different.
-        item.RightToLeftAutoMirrorImage = !value;
-        Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_RightToLeftAutoMirrorImage_SetWithOwner_GetReturnsExpected(bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set different.
-            item.RightToLeftAutoMirrorImage = !value;
-            Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_RightToLeftAutoMirrorImage_SetWithOwnerWithHandle_GetReturnsExpected(bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("RightToLeftAutoMirrorImage", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            item.RightToLeftAutoMirrorImage = !value;
-            Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_RightToLeftAutoMirrorImage_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            item.RightToLeftAutoMirrorImage = !value;
-            Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_RightToLeftAutoMirrorImage_SetWithParentWithHandle_GetReturnsExpected(bool value, int expectedParentInvalidatedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.RightToLeftAutoMirrorImage = value;
-            Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            item.RightToLeftAutoMirrorImage = !value;
-            Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentInvalidatedCallCount + 1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetCantSelect_ReturnsFalse()
-    {
-        using var item = new CannotSelectToolStripItem();
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetDesignMode_ReturnsFalse()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithOwner_ReturnsFalse()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithDraggingOwner_ReturnsFalse()
-    {
-        using var owner = new SubToolStrip();
-        owner.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithSelectionSuspendedOwner_ReturnsFalse()
-    {
-        using var owner = new SubToolStrip();
-        owner.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotNull(owner.GetItemAt(item.Bounds.X, item.Bounds.Y));
-        owner.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithParent_ReturnsFalse()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithDraggingParent_ReturnsFalse()
-    {
-        using var parent = new SubToolStrip();
-        parent.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithSelectionSuspendedParentNotCurrentItem_ReturnsFalse()
-    {
-        using var parent = new SubToolStrip();
-        parent.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotNull(parent.GetItemAt(item.Bounds.X, item.Bounds.Y));
-        parent.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Selected_GetWithSelectionSuspendedParentCurrentItem_ReturnsTrue()
-    {
-        using var parent = new SubToolStrip();
-        parent.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            Owner = parent,
-        };
-        Assert.True(item.Visible);
-        parent.PerformLayout();
-        Assert.Same(item, parent.GetItemAt(item.Bounds.X, item.Bounds.Y));
-        parent.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-
-        Assert.True(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ShowKeyboardCues_GetDesignMode_ReturnsTrue()
-    {
-        var mockSite = new Mock<ISite>();
-        mockSite
-        .Setup(s => s.DesignMode)
-        .Returns(true);
-        using var item = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-        Assert.True(item.ShowKeyboardCues);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Size_GetWithDefaultSize_ReturnsExpected()
-    {
-        using var item = new CustomDefaultSizeToolStripItem();
-        Assert.Equal(new Size(10, 11), item.Size);
-    }
-
-    private class CustomDefaultSizeToolStripItem : ToolStripItem
-    {
-        protected override Size DefaultSize => new(10, 11);
-    }
-
-    public static IEnumerable<object[]> Size_Set_TestData()
-    {
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(0, 0) };
-        yield return new object[] { new Size(1, 2) };
-        yield return new object[] { new Size(22, 23) };
-        yield return new object[] { new Size(23, 22) };
-        yield return new object[] { new Size(23, 23) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void ToolStripItem_Size_Set_GetReturnsExpected(Size value)
-    {
-        using var item = new SubToolStripItem();
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(0, locationChangedCallCount);
-
-        // Set same.
-        item.Size = value;
-        Assert.Equal(value, item.Size);
-        Assert.Equal(0, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void ToolStripItem_Size_SetWithOwner_GetReturnsExpected(Size value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_Set_TestData))]
-    public void ToolStripItem_Size_SetWithOwnerWithHandle_GetReturnsExpected(Size value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Size_SetWithParent_TestData()
-    {
-        yield return new object[] { new Size(-1, -2), 1 };
-        yield return new object[] { new Size(0, 0), 1 };
-        yield return new object[] { new Size(1, 2), 1 };
-        yield return new object[] { new Size(22, 23), 1 };
-        yield return new object[] { new Size(23, 22), 1 };
-        yield return new object[] { new Size(23, 23), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParent_TestData))]
-    public void ToolStripItem_Size_SetWithParent_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Size_SetWithParent_TestData))]
-    public void ToolStripItem_Size_SetWithParentWithHandle_GetReturnsExpected(Size value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Size = value;
-            Assert.Equal(value, item.Size);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripItem_Tag_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Tag = value
-        };
-        Assert.Same(value, item.Tag);
-
-        // Set same.
-        item.Tag = value;
-        Assert.Same(value, item.Tag);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripItem_Text_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Text = value
-        };
-        Assert.Equal(value, item.Text);
-
-        // Set same.
-        item.Text = value;
-        Assert.Equal(value, item.Text);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 0)]
-    [InlineData("text", 1)]
-    public void ToolStripItem_Text_SetWithOwner_GetReturnsExpected(string value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Text", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.False(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 0)]
-    [InlineData("text", 1)]
-    public void ToolStripItem_Text_SetWithOwnerWithHandle_GetReturnsExpected(string value, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Text", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripItem_Text_SetWithParent_GetReturnsExpected(string value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripItem_Text_SetWithParentWithHandle_GetReturnsExpected(string value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Text = value;
-            Assert.Equal(value, item.Text);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.TextChanged += handler;
-
-        // Set different.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Text = string.Empty;
-        Assert.Empty(item.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.TextChanged -= handler;
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_TextAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var item = new SubToolStripItem
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, item.TextAlign);
-
-        // Set same.
-        item.TextAlign = value;
-        Assert.Equal(value, item.TextAlign);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ContentAlignment.TopLeft, 1)]
-    [InlineData(ContentAlignment.TopCenter, 1)]
-    [InlineData(ContentAlignment.TopRight, 1)]
-    [InlineData(ContentAlignment.MiddleLeft, 1)]
-    [InlineData(ContentAlignment.MiddleCenter, 0)]
-    [InlineData(ContentAlignment.MiddleRight, 1)]
-    [InlineData(ContentAlignment.BottomLeft, 1)]
-    [InlineData(ContentAlignment.BottomCenter, 1)]
-    [InlineData(ContentAlignment.BottomRight, 1)]
-    public void ToolStripItem_TextAlign_SetWithOwner_GetReturnsExpected(ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextAlign", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ContentAlignment.TopLeft, 1)]
-    [InlineData(ContentAlignment.TopCenter, 1)]
-    [InlineData(ContentAlignment.TopRight, 1)]
-    [InlineData(ContentAlignment.MiddleLeft, 1)]
-    [InlineData(ContentAlignment.MiddleCenter, 0)]
-    [InlineData(ContentAlignment.MiddleRight, 1)]
-    [InlineData(ContentAlignment.BottomLeft, 1)]
-    [InlineData(ContentAlignment.BottomCenter, 1)]
-    [InlineData(ContentAlignment.BottomRight, 1)]
-    public void ToolStripItem_TextAlign_SetWithOwnerWithHandle_GetReturnsExpected(ContentAlignment value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextAlign", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_TextAlign_SetWithParent_GetReturnsExpected(ContentAlignment value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripItem_TextAlign_SetWithParentWithHandle_GetReturnsExpected(ContentAlignment value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextAlign = value;
-            Assert.Equal(value, item.TextAlign);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripItem_TextAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270)]
-    public void ToolStripItem_TextDirection_GetWithOwner_ReturnsExpected(ToolStripTextDirection ownerTextDirection, ToolStripTextDirection expected)
-    {
-        using var owner = new ToolStrip
-        {
-            TextDirection = ownerTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(expected, item.TextDirection);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270)]
-    public void ToolStripItem_TextDirection_GetWithParent_ReturnsExpected(ToolStripTextDirection parentTextDirection, ToolStripTextDirection expected)
-    {
-        using var parent = new ToolStrip
-        {
-            TextDirection = parentTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(expected, item.TextDirection);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_TextDirection_GetWithOwnerAndParent_ReturnsExpected()
-    {
-        using var owner = new ToolStrip
-        {
-            TextDirection = ToolStripTextDirection.Vertical90
-        };
-        using var parent = new ToolStrip
-        {
-            TextDirection = ToolStripTextDirection.Vertical270
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        Assert.Equal(ToolStripTextDirection.Vertical270, item.TextDirection);
-    }
-
-    public static IEnumerable<object[]> TextDirection_Set_TestData()
-    {
-        yield return new object[] { ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90 };
-        yield return new object[] { ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_Set_TestData))]
-    public void ToolStripItem_TextDirection_Set_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            TextDirection = value
-        };
-        Assert.Equal(expected, item.TextDirection);
-
-        // Set same.
-        item.TextDirection = value;
-        Assert.Equal(expected, item.TextDirection);
-    }
-
-    public static IEnumerable<object[]> TextDirection_SetWithOwner_TestData()
-    {
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90 };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_SetWithOwner_TestData))]
-    public void ToolStripItem_TextDirection_SetWithOwner_GetReturnsExpected(ToolStripTextDirection ownerTextDirection, ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var owner = new ToolStrip
-        {
-            TextDirection = ownerTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_SetWithOwner_TestData))]
-    public void ToolStripItem_TextDirection_SetWithOwnerWithHandle_GetReturnsExpected(ToolStripTextDirection ownerTextDirection, ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var owner = new ToolStrip
-        {
-            TextDirection = ownerTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_SetWithOwner_TestData))]
-    public void ToolStripItem_TextDirection_SetWithParent_GetReturnsExpected(ToolStripTextDirection parentTextDirection, ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var parent = new ToolStrip
-        {
-            TextDirection = parentTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_SetWithOwner_TestData))]
-    public void ToolStripItem_TextDirection_SetWithParentWithHandle_GetReturnsExpected(ToolStripTextDirection parentTextDirection, ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var parent = new ToolStrip
-        {
-            TextDirection = parentTextDirection
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextDirection = value;
-            Assert.Equal(expected, item.TextDirection);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripTextDirection>]
-    public void ToolStripItem_TextDirection_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripTextDirection value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextDirection = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_TextDirection_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.TextDirection)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Vertical270;
-        Assert.Equal(ToolStripTextDirection.Vertical270, item.TextDirection);
-        Assert.True(property.CanResetValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Vertical90;
-        Assert.Equal(ToolStripTextDirection.Vertical90, item.TextDirection);
-        Assert.True(property.CanResetValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Horizontal;
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_TextDirection_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.TextDirection)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Vertical270;
-        Assert.Equal(ToolStripTextDirection.Vertical270, item.TextDirection);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Vertical90;
-        Assert.Equal(ToolStripTextDirection.Vertical90, item.TextDirection);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        item.TextDirection = ToolStripTextDirection.Horizontal;
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextImageRelation>]
-    public void ToolStripItem_TextImageRelation_Set_GetReturnsExpected(TextImageRelation value)
-    {
-        using var item = new SubToolStripItem
-        {
-            TextImageRelation = value
-        };
-        Assert.Equal(value, item.TextImageRelation);
-
-        // Set same.
-        item.TextImageRelation = value;
-        Assert.Equal(value, item.TextImageRelation);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TextImageRelation.Overlay, 1)]
-    [InlineData(TextImageRelation.ImageBeforeText, 0)]
-    [InlineData(TextImageRelation.TextBeforeImage, 1)]
-    [InlineData(TextImageRelation.ImageAboveText, 1)]
-    [InlineData(TextImageRelation.TextAboveImage, 1)]
-    public void ToolStripItem_TextImageRelation_SetWithOwner_GetReturnsExpected(TextImageRelation value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextImageRelation", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(TextImageRelation.Overlay, 1)]
-    [InlineData(TextImageRelation.ImageBeforeText, 0)]
-    [InlineData(TextImageRelation.TextBeforeImage, 1)]
-    [InlineData(TextImageRelation.ImageAboveText, 1)]
-    [InlineData(TextImageRelation.TextAboveImage, 1)]
-    public void ToolStripItem_TextImageRelation_SetWithOwnerWithHandle_GetReturnsExpected(TextImageRelation value, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("TextImageRelation", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextImageRelation>]
-    public void ToolStripItem_TextImageRelation_SetWithParent_GetReturnsExpected(TextImageRelation value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextImageRelation>]
-    public void ToolStripItem_TextImageRelation_SetWithParentWithHandle_GetReturnsExpected(TextImageRelation value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.TextImageRelation = value;
-            Assert.Equal(value, item.TextImageRelation);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextImageRelation>]
-    [InlineData((TextImageRelation)3)]
-    [InlineData((TextImageRelation)5)]
-    [InlineData((TextImageRelation)6)]
-    [InlineData((TextImageRelation)7)]
-    public void ToolStripItem_TextImageRelation_SetInvalid_ThrowsInvalidEnumArgumentException(TextImageRelation value)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextImageRelation = value);
-    }
-
-    public static IEnumerable<object[]> ToolTipText_Get_TestData()
-    {
-        yield return new object[] { true, null, null };
-        yield return new object[] { true, "", "" };
-        yield return new object[] { true, "text", "text" };
-        yield return new object[] { true, "&", "&" };
-        yield return new object[] { true, "&&", "&&" };
-        yield return new object[] { true, "&T", "T" };
-        yield return new object[] { true, "&Text", "Text" };
-        yield return new object[] { true, "&Text1&Text2", "&Text1&Text2" };
-        yield return new object[] { true, "Text1&Text2", "Text1Text2" };
-
-        yield return new object[] { false, null, null };
-        yield return new object[] { false, "", null };
-        yield return new object[] { false, "text", null };
-        yield return new object[] { false, "&", null };
-        yield return new object[] { false, "&&", null };
-        yield return new object[] { false, "&T", null };
-        yield return new object[] { false, "&Text", null };
-        yield return new object[] { false, "&Text1&Text2", null };
-        yield return new object[] { false, "Text1&Text2", null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolTipText_Get_TestData))]
-    public void ToolStripItem_ToolTipText_Get_ReturnsExpected(bool autoToolTip, string text, string expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            AutoToolTip = autoToolTip,
-            Text = text
-        };
-        Assert.Equal(expected, item.ToolTipText);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripItem_ToolTipText_Set_GetReturnsExpected(string value)
-    {
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = value
-        };
-        Assert.Equal(value, item.ToolTipText);
-
-        // Set same.
-        item.ToolTipText = value;
-        Assert.Equal(value, item.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ToolTipText_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ToolTipText)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        // Set null.
-        item.ToolTipText = null;
-        Assert.Null(item.ToolTipText);
-        Assert.False(property.CanResetValue(item));
-
-        // Set empty.
-        item.ToolTipText = string.Empty;
-        Assert.Empty(item.ToolTipText);
-        Assert.False(property.CanResetValue(item));
-
-        // Set custom
-        item.ToolTipText = "text";
-        Assert.Equal("text", item.ToolTipText);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.ToolTipText);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ToolTipText_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.ToolTipText)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set null.
-        item.ToolTipText = null;
-        Assert.Null(item.ToolTipText);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set empty.
-        item.ToolTipText = string.Empty;
-        Assert.Empty(item.ToolTipText);
-        Assert.False(property.ShouldSerializeValue(item));
-
-        // Set custom
-        item.ToolTipText = "text";
-        Assert.Equal("text", item.ToolTipText);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Null(item.ToolTipText);
-        Assert.False(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ToolStripItem_Visible_GetWithOwner_ReturnsExpected(bool ownerVisible, bool visible)
-    {
-        using var owner = new ToolStrip
-        {
-            Visible = ownerVisible
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.False(item.Visible);
-
-        // Set custom.
-        item.Visible = visible;
-        Assert.False(item.Visible);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void ToolStripItem_Visible_GetWithParent_ReturnsExpected(bool parentVisible, bool visible, bool expected)
-    {
-        using var parent = new ToolStrip
-        {
-            Visible = parentVisible
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(parentVisible, item.Visible);
-
-        // Set custom.
-        item.Visible = visible;
-        Assert.Equal(expected, item.Visible);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_Set_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Visible = value
-        };
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetDesignMode_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Visible = value
-        };
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_Visible_SetSelected_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem();
-        item.Select();
-        Assert.True(item.Selected);
-
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Selected);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetDesignModeWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Owner = owner,
-        };
-
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithOwnerWithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true, 0 };
-                yield return new object[] { enabled, image, false, 2 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithOwnerWithHandle_TestData))]
-    public void ToolStripItem_Visible_SetWithOwnerWithHandle_GetReturnsExpected(bool enabled, Image image, bool value, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Visible = value;
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetDesignModeWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Parent = parent
-        };
-
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_Visible_SetWithParentWithHandle_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.Visible = value;
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Visible_SetWithHandler_CallsAvailableChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.AvailableChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.VisibleChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Visible_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Visible)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.CanResetValue(item));
-
-        item.Visible = false;
-        Assert.False(item.Visible);
-        Assert.False(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.False(item.Visible);
-        Assert.False(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Visible_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripItem))[nameof(ToolStripItem.Visible)];
-        using var item = new SubToolStripItem();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.Visible = false;
-        Assert.False(item.Visible);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.False(item.Visible);
-        Assert.True(property.ShouldSerializeValue(item));
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Width_Set_GetReturnsExpected(int value)
-    {
-        using var item = new SubToolStripItem();
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        item.Width = value;
-        Assert.Equal(value, item.Width);
-        Assert.Equal(0, locationChangedCallCount);
-
-        // Set same.
-        item.Width = value;
-        Assert.Equal(value, item.Width);
-        Assert.Equal(0, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Width_SetWithOwner_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [IntegerData<int>]
-    public void ToolStripItem_Width_SetWithOwnerWithHandle_GetReturnsExpected(int value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(23, 0)]
-    public void ToolStripItem_Width_SetWithParent_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 1)]
-    [InlineData(23, 0)]
-    public void ToolStripItem_Width_SetWithParentWithHandle_GetReturnsExpected(int value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) => locationChangedCallCount++;
-
-        try
-        {
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.Width = value;
-            Assert.Equal(value, item.Width);
-            Assert.Equal(0, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var item = new SubToolStripItem();
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.PushButton, accessibleObject.Role);
-        Assert.Equal(AccessibleStates.Focusable, accessibleObject.State);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Dispose_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Dispose_InvokeWithImage_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Dispose_InvokeWithOwner_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            Owner = owner
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose();
-            Assert.True(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Null(item.Owner);
-            Assert.Empty(owner.Items);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose();
-            Assert.True(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Null(item.Owner);
-            Assert.Empty(owner.Items);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Dispose_InvokeWithParent_Success()
-    {
-        using var image = new Bitmap(10, 10);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            Parent = parent
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Same(parent, item.Parent);
-            Assert.Empty(parent.Items);
-            Assert.Equal(1, callCount);
-
-            // Dispose multiple times.
-            item.Dispose();
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Same(parent, item.Parent);
-            Assert.Empty(parent.Items);
-            Assert.Equal(2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_Dispose_InvokeBool_Success(bool disposing, int expectedCallCount)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Null(item.Image);
-            Assert.Equal(expectedCallCount * 2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_Dispose_InvokeBoolWithImage_Success(bool disposing, int expectedCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using var item = new SubToolStripItem
-        {
-            Image = image
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Equal(expectedCallCount * 2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_Dispose_InvokeBoolWithOwner_Success(bool disposing, int expectedCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            Owner = owner
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(disposing);
-            Assert.Equal(disposing, item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Equal(disposing, item.Owner is null);
-            Assert.Equal(!disposing, owner.Items.Contains(item));
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(disposing);
-            Assert.Equal(disposing, item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Equal(disposing, item.Owner is null);
-            Assert.Equal(!disposing, owner.Items.Contains(item));
-            Assert.Equal(expectedCallCount * 2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_Dispose_InvokeBoolWithParent_Success(bool disposing, int expectedCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Image = image,
-            Parent = parent
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Equal(callCount > 0, item.Image is null);
-            callCount++;
-        }
-
-        item.Disposed += handler;
-
-        try
-        {
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Same(parent, item.Parent);
-            Assert.Empty(parent.Items);
-            Assert.Equal(expectedCallCount, callCount);
-
-            // Dispose multiple times.
-            item.Dispose(disposing);
-            Assert.False(item.IsDisposed);
-            Assert.Equal(disposing, item.Image is null);
-            Assert.Same(parent, item.Parent);
-            Assert.Empty(parent.Items);
-            Assert.Equal(expectedCallCount * 2, callCount);
-        }
-        finally
-        {
-            item.Disposed -= handler;
-        }
-    }
-
-    public static IEnumerable<object[]> DoDragDrop_TestData()
-    {
-        foreach (DragDropEffects allowedEffects in Enum.GetValues(typeof(DragDropEffects)))
-        {
-            yield return new object[] { "text", allowedEffects };
-            yield return new object[] { new SubToolStripItem(), allowedEffects };
-            yield return new object[] { new DataObject(), allowedEffects };
-            yield return new object[] { new DataObject("data"), allowedEffects };
-            yield return new object[] { new Mock<IDataObject>(MockBehavior.Strict).Object, allowedEffects };
-            yield return new object[] { new Mock<IComDataObject>(MockBehavior.Strict).Object, allowedEffects };
-        }
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void ToolStripItem_DoDragDrop_Invoke_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Equal(DragDropEffects.None, item.DoDragDrop(data, allowedEffects));
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void ToolStripItem_DoDragDrop_InvokeWithParent_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(DragDropEffects.None, item.DoDragDrop(data, allowedEffects));
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void ToolStripItem_DoDragDrop_InvokeWithParentAllowItemReorder_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var parent = new ToolStrip
-        {
-            AllowItemReorder = true
-        };
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(DragDropEffects.None, item.DoDragDrop(data, allowedEffects));
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void ToolStripItem_DoDragDrop_InvokeWithOwner_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(DragDropEffects.None, item.DoDragDrop(data, allowedEffects));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    [MemberData(nameof(DoDragDrop_TestData))]
-    public void ToolStripItem_DoDragDrop_InvokeWithOwnerAllowItemReorder_ReturnsNone(object data, DragDropEffects allowedEffects)
-    {
-        using var owner = new ToolStrip
-        {
-            AllowItemReorder = true
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(DragDropEffects.None, item.DoDragDrop(data, allowedEffects));
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact(Skip = "hangs CI, see https://github.com/dotnet/winforms/issues/3336")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3336")]
-    public void ToolStripItem_DoDragDrop_NullData_ThrowsArgumentNullException()
-    {
-        using var item = new SubToolStripItem();
-        Assert.Throws<ArgumentNullException>("data", () => item.DoDragDrop(null, DragDropEffects.All));
-    }
-
-    private class CustomDataObject : IDataObject
-    {
-        public object GetData(string format, bool autoConvert) => throw new NotImplementedException();
-
-        public object GetData(string format) => throw new NotImplementedException();
-
-        public object GetData(Type format) => throw new NotImplementedException();
-
-        public bool GetDataPresent(string format, bool autoConvert) => throw new NotImplementedException();
-
-        public bool GetDataPresent(string format) => throw new NotImplementedException();
-
-        public bool GetDataPresent(Type format) => throw new NotImplementedException();
-
-        public string[] GetFormats(bool autoConvert) => throw new NotImplementedException();
-
-        public string[] GetFormats() => throw new NotImplementedException();
-
-        public void SetData(string format, bool autoConvert, object data) => throw new NotImplementedException();
-
-        public void SetData(string format, object data) => throw new NotImplementedException();
-
-        public void SetData(Type format, object data) => throw new NotImplementedException();
-
-        public void SetData(object data) => throw new NotImplementedException();
-    }
-
-    private class CustomComDataObject : IComDataObject
-    {
-        public void GetData(ref FORMATETC format, out STGMEDIUM medium) => throw new NotImplementedException();
-
-        public void GetDataHere(ref FORMATETC format, ref STGMEDIUM medium) => throw new NotImplementedException();
-
-        public int QueryGetData(ref FORMATETC format) => throw new NotImplementedException();
-
-        public int GetCanonicalFormatEtc(ref FORMATETC formatIn, out FORMATETC formatOut) => throw new NotImplementedException();
-
-        public void SetData(ref FORMATETC formatIn, ref STGMEDIUM medium, bool release) => throw new NotImplementedException();
-
-        public IEnumFORMATETC EnumFormatEtc(DATADIR direction) => throw new NotImplementedException();
-
-        public int DAdvise(ref FORMATETC pFormatetc, ADVF advf, IAdviseSink adviseSink, out int connection) => throw new NotImplementedException();
-
-        public void DUnadvise(int connection) => throw new NotImplementedException();
-
-        public int EnumDAdvise(out IEnumSTATDATA enumAdvise) => throw new NotImplementedException();
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_GetCurrentParent_InvokeWithoutParent_ReturnsNull()
-    {
-        using var item = new SubToolStripItem();
-        Assert.Null(item.GetCurrentParent());
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_GetCurrentParent_InvokeWithOwner_ReturnsNull()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, item.GetCurrentParent());
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_GetCurrentParent_InvokeWithParent_ReturnsExpected()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Null(item.GetCurrentParent());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripItem_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var item = new SubToolStripItem();
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripItem_GetPreferredSize_InvokeWithOwner_ReturnsExpected(Size proposedSize)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripItem_GetPreferredSize_InvokeWithParent_ReturnsExpected(Size proposedSize)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(4, 4), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [InlineData('a')]
-    [InlineData('\0')]
-    public void ToolStripItem_IsInputChar_Invoke_ReturnsFalse(char charCode)
-    {
-        using var item = new SubToolStripItem();
-        Assert.False(item.IsInputChar(charCode));
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripItem_IsInputKey_Invoke_ReturnsFalse(Keys keyData)
-    {
-        using var item = new SubToolStripItem();
-        Assert.False(item.IsInputKey(keyData));
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Invalidate_Invoke_Nop()
-    {
-        using var item = new SubToolStripItem();
-        item.Invalidate();
-
-        // Call again.
-        item.Invalidate();
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Invalidate_InvokeWithOwner_Nop()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        item.Invalidate();
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        item.Invalidate();
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Invalidate_InvokeWithOwnerWithHandler_Nop()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Invalidate();
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        item.Invalidate();
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Invalidate_InvokeWithParent_Nop()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        item.Invalidate();
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        item.Invalidate();
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Invalidate_InvokeWithParentWithHandler_CallsInvalidate()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Invalidate();
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        item.Invalidate();
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Invalidate_Rectangle_TestData()
-    {
-        yield return new object[] { Rectangle.Empty };
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void ToolStripItem_Invalidate_InvokeRectangle_Nop(Rectangle r)
-    {
-        using var item = new SubToolStripItem();
-        item.Invalidate(r);
-
-        // Call again.
-        item.Invalidate(r);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void ToolStripItem_Invalidate_InvokeRectangleWithOwner_Nop(Rectangle r)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        item.Invalidate(r);
-        Assert.False(owner.IsHandleCreated);
-
-        // Call again.
-        item.Invalidate(r);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void ToolStripItem_Invalidate_InvokeRectangleWithOwnerWithHandler_Nop(Rectangle r)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Invalidate(r);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        item.Invalidate(r);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void ToolStripItem_Invalidate_InvokeRectangleWithParent_Nop(Rectangle r)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        item.Invalidate(r);
-        Assert.False(parent.IsHandleCreated);
-
-        // Call again.
-        item.Invalidate(r);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Invalidate_Rectangle_TestData))]
-    public void ToolStripItem_Invalidate_InvokeRectangleWithParentWithHandler_CallsInvalidate(Rectangle r)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Invalidate(r);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        item.Invalidate(r);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnAvailableChanged_Invoke_CallsAvailableChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.AvailableChanged += handler;
-        item.OnAvailableChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.OnAvailableChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnBackColorChanged_InvokeWithOwner_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnBackColorChanged_InvokeWithOwnerWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnBackColorChanged_InvokeWithParent_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnBackColorChanged_InvokeWithParentWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnBoundsChanged_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-        item.OnBoundsChanged();
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnBoundsChanged_InvokeWithOwner_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnBoundsChanged();
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnBoundsChanged_InvokeWithOwnerWithHandle_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnBoundsChanged();
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnBoundsChanged_InvokeWithParent_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnBoundsChanged();
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnBoundsChanged_InvokeWithParentWithHandle_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnBoundsChanged();
-            Assert.Equal(1, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            Assert.False(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnDisplayStyleChanged_Invoke_CallsDisplayStyleChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DisplayStyleChanged += handler;
-        item.OnDisplayStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DisplayStyleChanged -= handler;
-        item.OnDisplayStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DoubleClick += handler;
-        item.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DoubleClick -= handler;
-        item.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> DragEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new DragEventArgs(null, 0, 0, 0, DragDropEffects.None, DragDropEffects.None) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_OnDragDrop_Invoke_CallsDragDrop(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragDrop += handler;
-        item.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragDrop -= handler;
-        item.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_OnDragEnter_Invoke_CallsDragEnter(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragEnter += handler;
-        item.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragEnter -= handler;
-        item.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnDragLeave_Invoke_CallsDragLeave(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragLeave += handler;
-        item.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragLeave -= handler;
-        item.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_OnDragOver_Invoke_CallsDragOver(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragOver += handler;
-        item.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragOver -= handler;
-        item.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnEnabledChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_Invoke_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_InvokeDesignMode_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_InvokeWithOwner_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_InvokeWithOwnerWithHandle_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_InvokeWithParent_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnEnabledChanged_InvokeWithParentWithHandle_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_TestData()
-    {
-        foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-            yield return new object[] { displayStyle, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnFontChanged_Invoke_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.OnFontChanged(eventArgs);
-
-        // Call again.
-        item.OnFontChanged(eventArgs);
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_WithOwner_TestData()
-    {
-        yield return new object[] { ToolStripItemDisplayStyle.None, null, 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.None, new EventArgs(), 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.Text, null, 1 };
-        yield return new object[] { ToolStripItemDisplayStyle.Text, new EventArgs(), 1 };
-        yield return new object[] { ToolStripItemDisplayStyle.Image, null, 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.Image, new EventArgs(), 0 };
-        yield return new object[] { ToolStripItemDisplayStyle.ImageAndText, null, 1 };
-        yield return new object[] { ToolStripItemDisplayStyle.ImageAndText, new EventArgs(), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithOwner_TestData))]
-    public void ToolStripItem_OnFontChanged_InvokeWithOwner_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithOwner_TestData))]
-    public void ToolStripItem_OnFontChanged_InvokeWithOwnerWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(expectedParentLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnFontChanged_InvokeWithParent_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnFontChanged_InvokeWithParentWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnForeColorChanged_Invoke_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnForeColorChanged_InvokeWithOwner_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnForeColorChanged_InvokeWithOwnerWithHandle_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnForeColorChanged_InvokeWithParent_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnForeColorChanged_InvokeWithParentWithHandle_CallsForeColorChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnGiveFeedback_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new GiveFeedbackEventArgs(DragDropEffects.None, true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnGiveFeedback_TestData))]
-    public void ToolStripItem_OnGiveFeedback_Invoke_CallsGiveFeedback(GiveFeedbackEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        GiveFeedbackEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.GiveFeedback += handler;
-        item.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.GiveFeedback -= handler;
-        item.OnGiveFeedback(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStripItem_OnLayout_Invoke_Nop(LayoutEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-
-        item.OnLayout(eventArgs);
-
-        // Call again.
-        item.OnLayout(eventArgs);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnLocationChanged_Invoke_CallsLocationChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.LocationChanged += handler;
-        item.OnLocationChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.LocationChanged -= handler;
-        item.OnLocationChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripItem_OnMouseDown_Invoke_Nop(MouseEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseDown += handler;
-        item.OnMouseDown(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseDown -= handler;
-        item.OnMouseDown(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnMouseEnter_Invoke_DoesNotCallMouseEnter(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        item.MouseEnter += handler;
-        item.OnMouseEnter(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseEnter -= handler;
-        item.OnMouseEnter(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnMouseHover_Invoke_DoesNotCallMouseHover(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseHover += handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseHover -= handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseHover_WithOwner_TestData()
-    {
-        foreach (string toolTipText in new string[] { null, string.Empty, "ToolTipText" })
-        {
-            foreach (bool showItemToolTips in new bool[] { true, false })
-            {
-                yield return new object[] { toolTipText, showItemToolTips, null };
-                yield return new object[] { toolTipText, showItemToolTips, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseHover_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseHover_InvokeWithOwner_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseHover += handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseHover -= handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseHover_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseHover_InvokeWithParent_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseHover += handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseHover -= handler;
-        item.OnMouseHover(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnMouseLeave_Invoke_Nop(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseLeave += handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseLeave -= handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseLeave_WithOwner_TestData()
-    {
-        foreach (string toolTipText in new string[] { null, string.Empty, "ToolTipText" })
-        {
-            foreach (bool showItemToolTips in new bool[] { true, false })
-            {
-                yield return new object[] { toolTipText, showItemToolTips, null };
-                yield return new object[] { toolTipText, showItemToolTips, new EventArgs() };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseLeave_InvokeWithOwner_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseLeave += handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseLeave -= handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseLeave_InvokeWithOwnerAfterHover_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Owner = owner
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        item.OnMouseHover(eventArgs);
-
-        // Call with handler.
-        item.MouseLeave += handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseLeave -= handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseLeave_InvokeWithParent_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseLeave += handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseLeave -= handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseLeave_WithOwner_TestData))]
-    public void ToolStripItem_OnMouseLeave_InvokeWithParentAfterHover_Nop(string toolTipText, bool showItemToolTips, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip
-        {
-            ShowItemToolTips = showItemToolTips
-        };
-        using var item = new SubToolStripItem
-        {
-            ToolTipText = toolTipText,
-            Parent = parent
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        item.OnMouseHover(eventArgs);
-
-        // Call with handler.
-        item.MouseLeave += handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseLeave -= handler;
-        item.OnMouseLeave(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripItem_OnMouseMove_Invoke_Nop(MouseEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseMove += handler;
-        item.OnMouseMove(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseMove -= handler;
-        item.OnMouseMove(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void ToolStripItem_OnMouseUp_Invoke_Nop(MouseEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.MouseUp += handler;
-        item.OnMouseUp(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.MouseUp -= handler;
-        item.OnMouseUp(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnOwnerChanged_Invoke_CallsOwnerChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.OwnerChanged += handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Remove handler.
-        item.OwnerChanged -= handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnOwnerChanged_InvokeWithMargin_CallsOwnerChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Margin = new Padding(1, 2, 3, 4)
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.OwnerChanged += handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-
-        // Remove handler.
-        item.OwnerChanged -= handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(new Padding(1, 2, 3, 4), item.Margin);
-    }
-
-    public static IEnumerable<object[]> OnOwnerChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Yes, null, RightToLeft.Yes, 0 };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Yes, new EventArgs(), RightToLeft.Yes, 0 };
-
-        yield return new object[] { RightToLeft.Yes, RightToLeft.No, null, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.No, new EventArgs(), RightToLeft.No, 0 };
-
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Inherit, null, RightToLeft.Yes, 1 };
-        yield return new object[] { RightToLeft.Yes, RightToLeft.Inherit, new EventArgs(), RightToLeft.Yes, 1 };
-
-        yield return new object[] { RightToLeft.No, RightToLeft.Yes, null, RightToLeft.Yes, 0 };
-        yield return new object[] { RightToLeft.No, RightToLeft.Yes, new EventArgs(), RightToLeft.Yes, 0 };
-
-        yield return new object[] { RightToLeft.No, RightToLeft.No, null, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.No, RightToLeft.No, new EventArgs(), RightToLeft.No, 0 };
-
-        yield return new object[] { RightToLeft.No, RightToLeft.Inherit, null, RightToLeft.No, 1 };
-        yield return new object[] { RightToLeft.No, RightToLeft.Inherit, new EventArgs(), RightToLeft.No, 1 };
-
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Yes, null, RightToLeft.Yes, 0 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Yes, new EventArgs(), RightToLeft.Yes, 0 };
-
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.No, null, RightToLeft.No, 0 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.No, new EventArgs(), RightToLeft.No, 0 };
-
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Inherit, null, RightToLeft.No, 1 };
-        yield return new object[] { RightToLeft.Inherit, RightToLeft.Inherit, new EventArgs(), RightToLeft.No, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnOwnerChanged_TestData))]
-    public void ToolStripItem_OnOwnerChanged_InvokeWithRightToLeft_CallsHandler(RightToLeft ownerRightToLeft, RightToLeft rightToLeft, EventArgs eventArgs, RightToLeft expectedRightToLeft, int expectedRightToLeftChangedCallCount)
-    {
-        using var owner = new ToolStrip
-        {
-            RightToLeft = ownerRightToLeft
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            RightToLeft = rightToLeft
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int rightToLeftChangedCallCount = 0;
-        item.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rightToLeftChangedCallCount++;
-        };
-
-        // Call with handler.
-        item.OwnerChanged += handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedRightToLeft, item.RightToLeft);
-        Assert.Equal(expectedRightToLeftChangedCallCount, rightToLeftChangedCallCount);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Remove handler.
-        item.OwnerChanged -= handler;
-        item.OnOwnerChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedRightToLeft, item.RightToLeft);
-        Assert.Equal(expectedRightToLeftChangedCallCount * 2, rightToLeftChangedCallCount);
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnOwnerFontChanged_Invoke_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.OnOwnerFontChanged(eventArgs);
-
-        // Call again.
-        item.OnOwnerFontChanged(eventArgs);
-
-        // Call with font.
-        item.Font = new Font("Arial", 8.25f);
-        item.OnOwnerFontChanged(eventArgs);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithOwner_TestData))]
-    public void ToolStripItem_OnOwnerFontChanged_InvokeWithOwner_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs, int expectedOwnerLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedOwnerLayoutCallCount, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Call again.
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Call with font.
-            owner.Layout -= ownerHandler;
-            item.Font = new Font("Arial", 8.25f);
-            owner.Layout += ownerHandler;
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedOwnerLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_WithOwner_TestData))]
-    public void ToolStripItem_OnOwnerFontChanged_InvokeWithOwnerWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs, int expectedParentLayoutCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        void invalidatedHandler(object sender, EventArgs e) => invalidatedCallCount++;
-        owner.Invalidated += invalidatedHandler;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Font", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedParentLayoutCallCount, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedParentLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call with font.
-            owner.Layout -= ownerHandler;
-            owner.Invalidated -= invalidatedHandler;
-            item.Font = new Font("Arial", 8.25f);
-            owner.Layout += ownerHandler;
-            owner.Invalidated += invalidatedHandler;
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(expectedParentLayoutCallCount * 2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount * 4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnOwnerFontChanged_InvokeWithParent_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Call again.
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Call with font.
-            item.Font = new Font("Arial", 8.25f);
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripItem_OnOwnerFontChanged_InvokeWithParentWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call with font.
-            item.Font = new Font("Arial", 8.25f);
-            item.OnOwnerFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripItem_OnPaint_Invoke_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnParentBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.BackColorChanged += handler;
-        item.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        item.BackColorChanged -= handler;
-        item.BackColor = Color.Red;
-        item.BackColorChanged += handler;
-        item.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.BackColorChanged -= handler;
-        item.OnParentBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnParentChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    foreach (bool allowDrop in new bool[] { true, false })
-                    {
-                        yield return new object[] { enabled, visible, image, allowDrop, null, null };
-                        yield return new object[] { enabled, visible, image, allowDrop, null, new ToolStrip() };
-                        yield return new object[] { enabled, visible, image, allowDrop, new ToolStrip(), null };
-                        yield return new object[] { enabled, visible, image, allowDrop, new ToolStrip(), new ToolStrip() };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentChanged_TestData))]
-    public void ToolStripItem_OnParentChanged_Invoke_Success(bool enabled, bool visible, Image image, bool allowDrop, ToolStrip oldParent, ToolStrip newParent)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            AllowDrop = allowDrop
-        };
-        item.OnParentChanged(oldParent, newParent);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnEnabledChanged_TestData))]
-    public void ToolStripItem_OnParentEnabledChanged_Invoke_CallsEnabledChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.NotSame(eventArgs, e);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.EnabledChanged += handler;
-        item.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.OnParentEnabledChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_OnParentForeColorChanged_Invoke_CallsHandler()
-    {
-        using var item = new SubToolStripItem();
-        var eventArgs = new EventArgs();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.ForeColorChanged += handler;
-        item.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        item.ForeColorChanged -= handler;
-        item.ForeColor = Color.Red;
-        item.ForeColorChanged += handler;
-        item.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.OnParentForeColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnParentRightToLeftChanged_Invoke_CallsParentRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.RightToLeftChanged += handler;
-        item.OnParentRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.RightToLeftChanged -= handler;
-        item.OnParentRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnParentRightToLeftChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Inherit, null, 1 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.Yes, null, 0 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnParentRightToLeftChanged_TestData))]
-    public void ToolStripItem_OnParentRightToLeftChanged_InvokeWithRightToLeft_CallsRightToLeftChange(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCallCount)
-    {
-        using var item = new SubToolStripItem
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.RightToLeftChanged += handler;
-        item.OnParentRightToLeftChanged(eventArgs);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Remove handler.
-        item.RightToLeftChanged -= handler;
-        item.OnParentRightToLeftChanged(eventArgs);
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    public static IEnumerable<object[]> OnQueryContinueDrag_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new QueryContinueDragEventArgs(0, true, DragAction.Drop) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnQueryContinueDrag_TestData))]
-    public void ToolStripItem_OnQueryContinueDrag_Invoke_CallsQueryContinueDrag(QueryContinueDragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        QueryContinueDragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.QueryContinueDrag += handler;
-        item.OnQueryContinueDrag(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.QueryContinueDrag -= handler;
-        item.OnQueryContinueDrag(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_QueryAccessibilityHelp_AddRemove_Success()
-    {
-        using var item = new SubToolStripItem();
-        QueryAccessibilityHelpEventHandler handler = (sender, e) => { };
-        item.QueryAccessibilityHelp += handler;
-        item.QueryAccessibilityHelp -= handler;
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnRightToLeftChanged_Invoke_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.RightToLeftChanged += handler;
-        item.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.RightToLeftChanged -= handler;
-        item.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnRightToLeftChanged_InvokeWithOwner_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.RightToLeftChanged += handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove handler.
-            item.RightToLeftChanged -= handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnRightToLeftChanged_InvokeWithOwnerWithHandle_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.RightToLeftChanged += handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.RightToLeftChanged -= handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnRightToLeftChanged_InvokeWithParent_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.RightToLeftChanged += handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Remove handler.
-            item.RightToLeftChanged -= handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnRightToLeftChanged_InvokeWithParentWithHandle_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.RightToLeftChanged += handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.RightToLeftChanged -= handler;
-            item.OnRightToLeftChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnTextChanged_Invoke_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.TextChanged += handler;
-        item.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.TextChanged -= handler;
-        item.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnTextChanged_InvokeWithOwner_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Text", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.TextChanged += handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove handler.
-            item.TextChanged -= handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnTextChanged_InvokeWithOwnerWithHandle_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Text", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.TextChanged += handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.TextChanged -= handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnTextChanged_InvokeWithParent_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.TextChanged += handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Remove handler.
-            item.TextChanged -= handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_OnTextChanged_InvokeWithParentWithHandle_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.TextChanged += handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.TextChanged -= handler;
-            item.OnTextChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (bool visible in new bool[] { true, false })
-            {
-                foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-                {
-                    yield return new object[] { enabled, visible, image, null };
-                    yield return new object[] { enabled, visible, image, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_Invoke_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.VisibleChanged += handler;
-        item.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeDesignMode_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.VisibleChanged += handler;
-        item.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithOwner_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.VisibleChanged += handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Remove handler.
-            item.VisibleChanged -= handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithOwnerWithHandle_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Items", e.AffectedProperty);
-            ownerLayoutCallCount++;
-        }
-
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.VisibleChanged += handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(2, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.VisibleChanged -= handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(4, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithDisposingOwner_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int disposedCallCount = 0;
-        owner.Disposed += (sender, e) =>
-        {
-            try
-            {
-                int callCount = 0;
-                EventHandler handler = (sender, e) =>
-                {
-                    Assert.Same(item, sender);
-                    Assert.Same(eventArgs, e);
-                    callCount++;
-                };
-
-                // Call with handler.
-                item.VisibleChanged += handler;
-                item.OnVisibleChanged(eventArgs);
-                Assert.Equal(1, callCount);
-                Assert.Equal(0, ownerLayoutCallCount);
-                Assert.False(owner.IsHandleCreated);
-                Assert.Equal(0, invalidatedCallCount);
-                Assert.Equal(0, styleChangedCallCount);
-                Assert.Equal(0, createdCallCount);
-
-                // Remove handler.
-                item.VisibleChanged -= handler;
-                item.OnVisibleChanged(eventArgs);
-                Assert.Equal(1, callCount);
-                Assert.Equal(0, ownerLayoutCallCount);
-                Assert.False(owner.IsHandleCreated);
-                Assert.Equal(0, invalidatedCallCount);
-                Assert.Equal(0, styleChangedCallCount);
-                Assert.Equal(0, createdCallCount);
-            }
-            finally
-            {
-                owner.Layout -= ownerHandler;
-            }
-
-            disposedCallCount++;
-        };
-        owner.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithDisposedOwner_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        owner.Dispose();
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.VisibleChanged += handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.VisibleChanged -= handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithParent_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.VisibleChanged += handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Remove handler.
-            item.VisibleChanged -= handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStripItem_OnVisibleChanged_InvokeWithParentWithHandle_CallsVisibleChanged(bool enabled, bool visible, Image image, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Visible = visible,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            int callCount = 0;
-            EventHandler handler = (sender, e) =>
-            {
-                Assert.Same(item, sender);
-                Assert.Same(eventArgs, e);
-                callCount++;
-            };
-
-            // Call with handler.
-            item.VisibleChanged += handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Remove handler.
-            item.VisibleChanged -= handler;
-            item.OnVisibleChanged(eventArgs);
-            Assert.Equal(1, callCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> PerformClick_TestData()
-    {
-        yield return new object[] { true, true, 1 };
-        yield return new object[] { true, false, 0 };
-        yield return new object[] { false, true, 0 };
-        yield return new object[] { false, false, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformClick_TestData))]
-    public void ToolStripItem_PerformClick_Invoke_Success(bool enabled, bool available, int expectedClickCount)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Available = available
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.False(item.Pressed);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_PerformClick_InvokeDesignMode_Success()
-    {
-        var mockSite = new Mock<ISite>();
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var item = new SubToolStripItem
-        {
-            Site = mockSite.Object
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.False(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(item.Pressed);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformClick_TestData))]
-    public void ToolStripItem_PerformClick_InvokeDoesNotSupportItemClick_Success(bool enabled, bool available, int expectedClickCount)
-    {
-        using var control = new ToolStrip();
-        ToolStripItem grip = Assert.IsAssignableFrom<ToolStripItem>(Assert.Single(control.DisplayedItems));
-        grip.Enabled = enabled;
-        grip.Available = available;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(grip, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.False(grip.Pressed);
-            callCount++;
-        };
-        int itemClickedCallCount = 0;
-        ToolStripItemClickedEventHandler itemClickedHandler = (sender, e) => itemClickedCallCount++;
-        control.ItemClicked += itemClickedHandler;
-
-        // Call with handler.
-        grip.Click += handler;
-        grip.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(grip.Pressed);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        grip.Click -= handler;
-        grip.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(grip.Pressed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PerformClick_TestData))]
-    public void ToolStripItem_PerformClick_InvokeCantSelect_Success(bool enabled, bool available, int expectedClickCount)
-    {
-        using var item = new CannotSelectToolStripItem
-        {
-            Enabled = enabled,
-            Available = available
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.False(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.False(item.Pressed);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(expectedClickCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_PerformClick_InvokeWithOwner_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        int callCount = 0;
-        int itemClickedCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-        ToolStripItemClickedEventHandler itemClickedHandler = (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.ClickedItem);
-            itemClickedCallCount++;
-            Assert.True(itemClickedCallCount > callCount);
-        };
-        owner.ItemClicked += itemClickedHandler;
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.False(owner.IsHandleCreated);
-
-        // Remove other handler.
-        owner.ItemClicked -= itemClickedHandler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_PerformClick_InvokeWithOwnerWithHandle_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        int itemClickedCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-        ToolStripItemClickedEventHandler itemClickedHandler = (sender, e) =>
-        {
-            Assert.Same(owner, sender);
-            Assert.Same(item, e.ClickedItem);
-            itemClickedCallCount++;
-            Assert.True(itemClickedCallCount > callCount);
-        };
-        owner.ItemClicked += itemClickedHandler;
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove other handler.
-        owner.ItemClicked -= itemClickedHandler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_PerformClick_InvokeWithParent_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int itemClickedCallCount = 0;
-        parent.ItemClicked += (sender, e) => itemClickedCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.False(parent.IsHandleCreated);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_PerformClick_InvokeWithParentWithHandle_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int itemClickedCallCount = 0;
-        parent.ItemClicked += (sender, e) => itemClickedCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Click += handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        item.Click -= handler;
-        item.PerformClick();
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, itemClickedCallCount);
-        Assert.False(item.Pressed);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Enter)]
-    [InlineData(Keys.Space)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripItem_ProcessCmdKey_Invoke_ReturnsFalse(Keys keyData)
-    {
-        using var item = new SubToolStripItem();
-        var message = new Message();
-        Assert.False(item.ProcessCmdKey(ref message, keyData));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_ProcessDialogKey_EnterKey_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_ProcessDialogKey_EnterKeyWithParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_ProcessDialogKey_EnterKeyWithDropDownParent_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        var parent = new ToolStripDropDown();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent,
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessDialogKey(Keys.Enter));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Space)]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.None)]
-    [InlineData((Keys)(Keys.None - 1))]
-    public void ToolStripItem_ProcessDialogKey_UnknownKey_ReturnsFalse(Keys keyData)
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        item.Click += (sender, e) => callCount++;
-        Assert.False(item.ProcessDialogKey(keyData));
-        Assert.Equal(0, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void ToolStripItem_ProcessMnemonic_Invoke_PerformsClick(bool enabled, int expectedCallCount)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(item.Pressed);
-            callCount++;
-        };
-
-        item.Click += handler;
-        Assert.True(item.ProcessMnemonic('a'));
-        Assert.Equal(expectedCallCount, callCount);
-        Assert.False(item.Pressed);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetBackColor_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-
-        // Reset with value.
-        item.BackColor = Color.Black;
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-
-        // Reset again.
-        item.ResetBackColor();
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetDisplayStyle_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetDisplayStyle();
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-
-        // Reset with value.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        item.ResetDisplayStyle();
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-
-        // Reset again.
-        item.ResetDisplayStyle();
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetFont_Invoke_Success()
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        Assert.NotSame(font, item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-
-        // Reset with value.
-        item.Font = font;
-        item.ResetFont();
-        Assert.NotSame(font, item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-
-        // Reset again.
-        item.ResetFont();
-        Assert.NotSame(font, item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetForeColor_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-
-        // Reset with value.
-        item.ForeColor = Color.Black;
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-
-        // Reset again.
-        item.ResetForeColor();
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetImage_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetImage();
-        Assert.Null(item.Image);
-
-        // Reset with value.
-        item.Image = new Bitmap(10, 10);
-        item.ResetImage();
-        Assert.Null(item.Image);
-
-        // Reset again.
-        item.ResetImage();
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetMargin_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetMargin();
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Reset with value.
-        item.Margin = new Padding(1, 2, 3, 4);
-        item.ResetMargin();
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-
-        // Reset again.
-        item.ResetMargin();
-        Assert.Equal(new Padding(0, 1, 0, 2), item.Margin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetPadding_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetPadding();
-        Assert.Equal(Padding.Empty, item.Padding);
-
-        // Reset with value.
-        item.Padding = new Padding(1, 2, 3, 4);
-        item.ResetPadding();
-        Assert.Equal(Padding.Empty, item.Padding);
-
-        // Reset again.
-        item.ResetPadding();
-        Assert.Equal(Padding.Empty, item.Padding);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetRightToLeft_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetRightToLeft();
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-
-        // Reset with value.
-        item.RightToLeft = RightToLeft.Yes;
-        item.ResetRightToLeft();
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-
-        // Reset again.
-        item.ResetRightToLeft();
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ResetTextDirection_Invoke_Success()
-    {
-        using var item = new SubToolStripItem();
-
-        // Reset without value.
-        item.ResetTextDirection();
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-
-        // Reset with value.
-        item.TextDirection = ToolStripTextDirection.Vertical90;
-        item.ResetTextDirection();
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-
-        // Reset again.
-        item.ResetTextDirection();
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_Select_Invoke_Success(bool enabled)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled
-        };
-
-        item.Select();
-        Assert.Equal(item.CanSelect, item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.Equal(item.CanSelect, item.Selected);
-    }
-
-    public static IEnumerable<object[]> Select_WithoutToolStripItemAccessibleObject_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new AccessibleObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Select_WithoutToolStripItemAccessibleObject_TestData))]
-    public void ToolStripItem_Select_InvokeWithoutToolStripItemAccessibleObject_Success(AccessibleObject result)
-    {
-        using var item = new CustomCreateAccessibilityInstanceToolStripItem
-        {
-            CreateAccessibilityInstanceResult = result
-        };
-
-        item.Select();
-        Assert.True(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_CantSelect_Success()
-    {
-        using var item = new CannotSelectToolStripItem();
-        item.Select();
-        Assert.False(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithOwnerItemOnDropdown_Success()
-    {
-        using var ownerItemOwner = new ToolStripDropDown();
-        using var ownerItem = new SubToolStripItem
-        {
-            Owner = ownerItemOwner
-        };
-        using var owner = new ToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(ownerItem.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(ownerItem.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithOwnerItemNotOnDropDown_Success()
-    {
-        using var ownerItem = new SubToolStripItem();
-        using var owner = new ToolStripDropDown
-        {
-            OwnerItem = ownerItem
-        };
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(ownerItem.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(ownerItem.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithOwner_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithOwnerWithHandle_Success()
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithDraggingOwner_Success()
-    {
-        using var owner = new SubToolStrip();
-        owner.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-
-        item.Select();
-        Assert.False(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithSelectionSuspendedOwner_Success()
-    {
-        using var owner = new SubToolStrip();
-        owner.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotNull(owner.GetItemAt(item.Bounds.X, item.Bounds.Y));
-        owner.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-
-        item.Select();
-        Assert.False(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithParent_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithParentWithHandle_Success()
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithDraggingParent_Success()
-    {
-        using var parent = new SubToolStrip();
-        parent.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-
-        item.Select();
-        Assert.True(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.True(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_Select_InvokeWithSelectionSuspendedParent_Success()
-    {
-        using var parent = new SubToolStrip();
-        parent.OnBeginDrag(EventArgs.Empty);
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotNull(parent.GetItemAt(item.Bounds.X, item.Bounds.Y));
-        parent.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-
-        item.Select();
-        Assert.False(item.Selected);
-
-        // Select again.
-        item.Select();
-        Assert.False(item.Selected);
-    }
-
-    public static IEnumerable<object[]> SetBounds_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 0, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(1, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 0, -1, -2), 0 };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), 0 };
-        yield return new object[] { new Rectangle(0, 0, 1, 2), 0 };
-        yield return new object[] { new Rectangle(0, 0, 22, 23), 0 };
-        yield return new object[] { new Rectangle(0, 0, 23, 22), 0 };
-        yield return new object[] { new Rectangle(0, 0, 23, 23), 0 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_TestData))]
-    public void ToolStripItem_SetBounds_Invoke_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var item = new SubToolStripItem();
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        item.SetBounds(bounds);
-        Assert.Equal(bounds, item.Bounds);
-        Assert.Equal(bounds.Size, item.Size);
-        Assert.Equal(bounds.Width, item.Width);
-        Assert.Equal(bounds.Height, item.Height);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-
-        // Set same.
-        item.SetBounds(bounds);
-        Assert.Equal(bounds, item.Bounds);
-        Assert.Equal(bounds.Size, item.Size);
-        Assert.Equal(bounds.Width, item.Width);
-        Assert.Equal(bounds.Height, item.Height);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_TestData))]
-    public void ToolStripItem_SetBounds_InvokeWithOwner_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_TestData))]
-    public void ToolStripItem_SetBounds_InvokeWithOwnerWithHandle_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_WithParent_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 0, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(0, 2, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(1, 2, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(0, 0, -1, -2), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 1, 2), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 22, 23), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 23, 22), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 23, 23), 0, 0 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_WithParent_TestData))]
-    public void ToolStripItem_SetBounds_InvokeWithParent_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_WithParent_TestData))]
-    public void ToolStripItem_SetBounds_InvokeWithParentWithHandle_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(expectedParentLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetVisibleCore_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true };
-                yield return new object[] { enabled, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_Invoke_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image
-        };
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeDesignMode_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object
-        };
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripItem_SetVisibleCore_InvokeSelected_GetReturnsExpected(bool value)
-    {
-        using var item = new SubToolStripItem();
-        item.Select();
-        Assert.True(item.Selected);
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Selected);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.Equal(value, item.Selected);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeDesignModeWithOwner_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Owner = owner,
-        };
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.False(item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(owner.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetVisibleCore_InvokeWithOwnerWithHandle_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { enabled, image, true, 0 };
-                yield return new object[] { enabled, image, false, 2 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_InvokeWithOwnerWithHandle_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeWithOwnerWithHandle_GetReturnsExpected(bool enabled, Image image, bool value, int expectedInvalidatedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Owner = owner
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.False(item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(owner.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeDesignModeWithParent_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Site = mockSite.Object,
-            Parent = parent
-        };
-
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.False(parent.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetVisibleCore_TestData))]
-    public void ToolStripItem_SetVisibleCore_InvokeWithParentWithHandle_GetReturnsExpected(bool enabled, Image image, bool value)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Enabled = enabled,
-            Image = image,
-            Parent = parent
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        item.SetVisibleCore(value);
-        Assert.Equal(value, item.Visible);
-        Assert.Equal(value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        item.Available = !value;
-        Assert.Equal(!value, item.Visible);
-        Assert.Equal(!value, item.Available);
-        Assert.False(item.Selected);
-        Assert.True(parent.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_SetVisibleCore_InvokeWithHandler_CallsAvailableChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.AvailableChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.AvailableChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_SetVisibleCore_InvokeWithHandler_CallsVisibleChanged()
-    {
-        using var item = new SubToolStripItem();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.VisibleChanged += handler;
-
-        // Set different.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Available = true;
-        Assert.True(item.Available);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.VisibleChanged -= handler;
-        item.Available = false;
-        Assert.False(item.Available);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ToString_InvokeWithoutText_ReturnsExpected()
-    {
-        using var item = new SubToolStripItem();
-        Assert.Equal("System.Windows.Forms.Tests.ToolStripItemTests+SubToolStripItem", item.ToString());
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "System.Windows.Forms.Tests.ToolStripItemTests+SubToolStripItem")]
-    [InlineData("", "System.Windows.Forms.Tests.ToolStripItemTests+SubToolStripItem")]
-    [InlineData("text", "text")]
-    public void ToolStripItem_ToString_InvokeWithText_ReturnsExpected(string text, string expected)
-    {
-        using var item = new SubToolStripItem
-        {
-            Text = text
-        };
-        Assert.Equal(expected, item.ToString());
-    }
-
-    [WinFormsFact]
-    public void ToolStripItem_ToString_InvokeWithNullText_ReturnsExpected()
-    {
-        using var item = new NullTextToolStripItem();
-        Assert.Equal("System.Windows.Forms.Tests.ToolStripItemTests+NullTextToolStripItem", item.ToString());
-    }
-
-    private class NullTextToolStripItem : ToolStripItem
-    {
-        public override string Text
-        {
-            get => null;
-            set { }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_IDropTargetOnDragDrop_Invoke_CallsDragDrop(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        IDropTarget dropTarget = item;
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragDrop += handler;
-        dropTarget.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragDrop -= handler;
-        dropTarget.OnDragDrop(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_IDropTargetOnDragEnter_Invoke_CallsDragEnter(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        IDropTarget dropTarget = item;
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragEnter += handler;
-        dropTarget.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragEnter -= handler;
-        dropTarget.OnDragEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStripItem_IDropTargetOnDragLeave_Invoke_CallsDragLeave(EventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        IDropTarget dropTarget = item;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragLeave += handler;
-        dropTarget.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragLeave -= handler;
-        dropTarget.OnDragLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DragEventArgs_TestData))]
-    public void ToolStripItem_IDropTargetOnDragOver_Invoke_CallsDragOver(DragEventArgs eventArgs)
-    {
-        using var item = new SubToolStripItem();
-        IDropTarget dropTarget = item;
-        int callCount = 0;
-        DragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.DragOver += handler;
-        dropTarget.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        item.DragOver -= handler;
-        dropTarget.OnDragOver(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    private class SubToolStrip : ToolStrip
-    {
-        public new void OnBeginDrag(EventArgs e) => base.OnBeginDrag(e);
-
-        public new void OnMouseDown(MouseEventArgs mea) => base.OnMouseDown(mea);
-    }
-
-    private class FlippingEnabledToolStripItem : ToolStripItem
-    {
-        public FlippingEnabledToolStripItem() : base()
-        {
-        }
-
-        private int _callCount;
-
-        public override bool Enabled
-        {
-            get
-            {
-                if (_callCount <= 1)
-                {
-                    _callCount++;
-                    return true;
-                }
-
-                return false;
-            }
-            set { }
-        }
-    }
-
-    private class CannotSelectToolStripItem : ToolStripItem
-    {
-        public override bool CanSelect => false;
-    }
-
-    private class SubToolStripButton : ToolStripButton
-    {
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-        public SubToolStripItem() : base()
-        {
-        }
-
-        public SubToolStripItem(string text, Image image, EventHandler onClick) : base(text, image, onClick)
-        {
-        }
-
-        public SubToolStripItem(string text, Image image, EventHandler onClick, string name) : base(text, image, onClick, name)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new bool IsInputChar(char charCode) => base.IsInputChar(charCode);
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnAvailableChanged(EventArgs e) => base.OnAvailableChanged(e);
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnBoundsChanged() => base.OnBoundsChanged();
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDisplayStyleChanged(EventArgs e) => base.OnDisplayStyleChanged(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnDragDrop(DragEventArgs e) => base.OnDragDrop(e);
-
-        public new void OnDragEnter(DragEventArgs e) => base.OnDragEnter(e);
-
-        public new void OnDragLeave(EventArgs e) => base.OnDragLeave(e);
-
-        public new void OnDragOver(DragEventArgs e) => base.OnDragOver(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnGiveFeedback(GiveFeedbackEventArgs giveFeedbackEvent) => base.OnGiveFeedback(giveFeedbackEvent);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnLocationChanged(EventArgs e) => base.OnLocationChanged(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseHover(EventArgs e) => base.OnMouseHover(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs e) => base.OnMouseUp(e);
-
-        public new void OnOwnerChanged(EventArgs e) => base.OnOwnerChanged(e);
-
-        public new void OnOwnerFontChanged(EventArgs e) => base.OnOwnerFontChanged(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnParentBackColorChanged(EventArgs e) => base.OnParentBackColorChanged(e);
-
-        public new void OnParentChanged(ToolStrip oldParent, ToolStrip newParent) => base.OnParentChanged(oldParent, newParent);
-
-        public new void OnParentEnabledChanged(EventArgs e) => base.OnParentEnabledChanged(e);
-
-        public new void OnParentForeColorChanged(EventArgs e) => base.OnParentForeColorChanged(e);
-
-        public new void OnParentRightToLeftChanged(EventArgs e) => base.OnParentRightToLeftChanged(e);
-
-        public new void OnQueryContinueDrag(QueryContinueDragEventArgs e) => base.OnQueryContinueDrag(e);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new bool ProcessMnemonic(char charCode) => base.ProcessMnemonic(charCode);
-
-        public new void SetBounds(Rectangle bounds) => base.SetBounds(bounds);
-
-        public new void SetVisibleCore(bool visible) => base.SetVisibleCore(visible);
-    }
-
-    private class  ToolStripWithDisconnectCount : ToolStrip
-    {
-        public ToolStripWithDisconnectCount() : base() { }
-
-        public int Disconnects { get; private set; }
-
-        internal new void ReleaseUiaProvider(HWND handle)
-        {
-            base.ReleaseUiaProvider(handle);
-
-            Disconnects++;
-        }
-    }
-
-    private class ToolStripDropDownItemWithAccessibleObjectFieldAccessor : ToolStripDropDownItem
-    {
-        public ToolStripDropDownItemWithAccessibleObjectFieldAccessor() : base() { }
-
-        public bool IsAccessibleObjectCleared()
-        {
-            var key = this.TestAccessor().Dynamic.s_accessibilityProperty;
-            var accessibleObject = Properties.GetObject(key) as AccessibleObject;
-
-            return accessibleObject is null;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTextRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTextRenderEventArgsTests.cs
deleted file mode 100644
index a4e2ca32e47..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripItemTextRenderEventArgsTests.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripItemTextRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_ToolStripItem_String_Rectangle_Color_Font_TextFormatFlags_TestData()
-    {
-        yield return new object[] { new ToolStripButton(), null, Rectangle.Empty, Color.Empty, null, (TextFormatFlags)(TextFormatFlags.Top - 1) };
-        yield return new object[] { new ToolStripButton(), "", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, TextFormatFlags.Top };
-        yield return new object[] { new ToolStripButton() { RightToLeft = RightToLeft.Yes }, "text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, TextFormatFlags.Bottom };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItem_String_Rectangle_Color_Font_TextFormatFlags_TestData))]
-    public void Ctor_ToolStripItem_String_Rectangle_Color_Font_TextFormatFlags(ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, TextFormatFlags format)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics g = Graphics.FromImage(image);
-
-        var e = new ToolStripItemTextRenderEventArgs(g, item, text, textRectangle, textColor, textFont, format);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(text, e.Text);
-        Assert.Equal(textRectangle, e.TextRectangle);
-        Assert.Equal(textColor, e.TextColor);
-        Assert.Equal(textFont, e.TextFont);
-        Assert.Equal(format, e.TextFormat);
-        Assert.Equal(item.TextDirection, e.TextDirection);
-    }
-
-    public static IEnumerable<object[]> Ctor_ToolStripItem_String_Rectangle_Color_Font_ContentAlignment_TestData()
-    {
-        yield return new object[] { new ToolStripButton(), null, Rectangle.Empty, Color.Empty, null, (ContentAlignment)(ContentAlignment.TopLeft - 1), TextFormatFlags.Default | TextFormatFlags.Top | TextFormatFlags.HidePrefix };
-        yield return new object[] { new ToolStripButton(), "", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, ContentAlignment.MiddleCenter, TextFormatFlags.Default | TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.HidePrefix };
-        yield return new object[] { new ToolStripButton(), "", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, ContentAlignment.BottomRight, TextFormatFlags.Default | TextFormatFlags.Bottom | TextFormatFlags.Right | TextFormatFlags.HidePrefix };
-        yield return new object[] { new ToolStripButton() { RightToLeft = RightToLeft.Yes }, "text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, (ContentAlignment)(-1), TextFormatFlags.Default | TextFormatFlags.Bottom | TextFormatFlags.Right | TextFormatFlags.RightToLeft | TextFormatFlags.HidePrefix };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItem_String_Rectangle_Color_Font_ContentAlignment_TestData))]
-    public void Ctor_ToolStripItem_String_Rectangle_Color_Font_ContentAlignment(ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, ContentAlignment textAlign, TextFormatFlags expectedTextFormat)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics g = Graphics.FromImage(image);
-
-        var e = new ToolStripItemTextRenderEventArgs(g, item, text, textRectangle, textColor, textFont, textAlign);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(item, e.Item);
-        Assert.Equal(text, e.Text);
-        Assert.Equal(textRectangle, e.TextRectangle);
-        Assert.Equal(textColor, e.TextColor);
-        Assert.Equal(textFont, e.TextFont);
-        Assert.Equal(expectedTextFormat, e.TextFormat);
-        Assert.Equal(item.TextDirection, e.TextDirection);
-    }
-
-    [Fact]
-    public void Ctor_NullItem_ThrowsArgumentNullException()
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            Assert.Throws<ArgumentNullException>("item", () => new ToolStripItemTextRenderEventArgs(graphics, null, "", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, TextFormatFlags.Top));
-            Assert.Throws<ArgumentNullException>("item", () => new ToolStripItemTextRenderEventArgs(graphics, null, "", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.DefaultFont, ContentAlignment.TopLeft));
-        }
-    }
-
-    public static IEnumerable<object[]> TextColor_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextColor_TestData))]
-    public void TextColor_Set_GetReturnsExpected(Color value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new ToolStripItemTextRenderEventArgs(graphics, new ToolStripButton(), "", new Rectangle(1, 2, 3, 4), Color.Blue, SystemFonts.DefaultFont, TextFormatFlags.Top)
-            {
-                TextColor = value
-            };
-            Assert.Equal(value, e.TextColor);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripLabel.ToolStripLabelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripLabel.ToolStripLabelAccessibleObjectTests.cs
deleted file mode 100644
index 05d7a68ad28..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripLabel.ToolStripLabelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripLabel;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripLabel_ToolStripLabelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripLabelAccessibleObject_Ctor_Default()
-    {
-        using ToolStripLabel toolStripLabel = new ToolStripLabel();
-        ToolStripLabelAccessibleObject accessibleObject = new ToolStripLabelAccessibleObject(toolStripLabel);
-
-        Assert.Equal(toolStripLabel, accessibleObject.Owner);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.UIA.HyperlinkControlTypeId)]
-    [InlineData(false, (int)UiaCore.UIA.TextControlTypeId)]
-    public void ToolStripLabelAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool isLink, int expectedType)
-    {
-        using ToolStripLabel toolStripLabel = new ToolStripLabel();
-        toolStripLabel.IsLink = isLink;
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Link)]
-    [InlineData(false, AccessibleRole.StaticText)]
-    public void ToolStripLabelAccessibleObject_Role_IsExpected_ByDefault(bool isLink, AccessibleRole expectedRole)
-    {
-        using ToolStripLabel toolStripLabel = new ToolStripLabel();
-        toolStripLabel.IsLink = isLink;
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripLabel.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripLabel toolStripLabel = new ToolStripLabel();
-        toolStripLabel.AccessibleRole = role;
-
-        Assert.Equal(AccessibleRoleControlTypeMap.GetControlType(role), toolStripLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.Null(toolStripLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleStates.ReadOnly | AccessibleStates.Focusable)]
-    [InlineData(false, AccessibleStates.ReadOnly)]
-    public void ToolStripLabelAccessibleObject_GetPropertyValue_LegacyIAccessibleStatePropertyId_ReturnsExpected(bool isLink, AccessibleStates expectedState)
-    {
-        using ToolStripLabel toolStripLabel = new ToolStripLabel() { IsLink = isLink };
-        object actual = toolStripLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleStatePropertyId);
-
-        Assert.Equal(expectedState, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItem.ToolStripMenuItemAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItem.ToolStripMenuItemAccessibleObjectTests.cs
deleted file mode 100644
index ba3994f3553..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItem.ToolStripMenuItemAccessibleObjectTests.cs
+++ /dev/null
@@ -1,210 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripMenuItem;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripMenuItem_ToolStripMenuItemAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_Ctor_Default()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem();
-        ToolStripMenuItemAccessibleObject accessibleObject = new ToolStripMenuItemAccessibleObject(toolStripMenuItem);
-
-        Assert.Equal(toolStripMenuItem, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_ControlType_IsMenuItem_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripMenuItem.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.MenuItemControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_Role_IsMenuItem_ByDefault()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripMenuItem.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuItem, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripMenuItemAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripMenuItemAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripMenuItemAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem();
-        toolStripMenuItem.AccessibleRole = role;
-
-        object actual = toolStripMenuItem.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_GetPropertyValue_PositionInSet_ReturnsExpected_IfNoParent()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new();
-
-        AccessibleObject accessibilityObject = toolStripMenuItem.AccessibilityObject;
-
-        Assert.Null(accessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_GetPropertyValue_PositionInSet_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = new();
-
-        using ToolStripMenuItem item1 = new();
-        menuStrip.Items.Add(item1);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(1, menuStrip.Items.Count);
-        Assert.Equal(1, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-
-        using ToolStripSeparator separator = new();
-        menuStrip.Items.Add(separator);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(2, menuStrip.Items.Count);
-        Assert.Equal(1, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-        Assert.Null(separator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-
-        using ToolStripMenuItem item2 = new();
-        menuStrip.Items.Add(item2);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(3, menuStrip.Items.Count);
-        Assert.Equal(1, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-        Assert.Null(separator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-        Assert.Equal(2, item2.AccessibilityObject.GetPropertyValue(UiaCore.UIA.PositionInSetPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_GetPropertyValue_SizeOfSet_ReturnsExpected_IfNoParent()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new();
-
-        AccessibleObject accessibilityObject = toolStripMenuItem.AccessibilityObject;
-
-        Assert.Null(accessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_GetPropertyValue_SizeOfSet_ReturnsExpected()
-    {
-        using MenuStrip menuStrip = new();
-
-        using ToolStripMenuItem item1 = new();
-        menuStrip.Items.Add(item1);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(1, menuStrip.Items.Count);
-        Assert.Equal(1, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-
-        using ToolStripSeparator separator = new();
-        menuStrip.Items.Add(separator);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(2, menuStrip.Items.Count);
-        Assert.Equal(1, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-        Assert.Null(separator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-
-        using ToolStripMenuItem item2 = new();
-        menuStrip.Items.Add(item2);
-        menuStrip.PerformLayout();
-
-        Assert.Equal(3, menuStrip.Items.Count);
-        Assert.Equal(2, item1.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-        Assert.Null(separator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-        Assert.Equal(2, item2.AccessibilityObject.GetPropertyValue(UiaCore.UIA.SizeOfSetPropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, CheckState.Checked, true)]
-    [InlineData(true, CheckState.Unchecked, true)]
-    [InlineData(true, CheckState.Indeterminate, true)]
-    [InlineData(false, CheckState.Checked, true)]
-    [InlineData(false, CheckState.Unchecked, false)]
-    [InlineData(false, CheckState.Indeterminate, true)]
-    public void ToolStripMenuItemAccessibleObject_IsTogglePatternSupported_ReturnsExpected(bool checkOnClick, CheckState checkState, bool expected)
-    {
-        using ToolStripMenuItem toolStripMenuItem = new()
-        {
-            CheckOnClick = checkOnClick,
-            CheckState = checkState
-        };
-
-        object actual = toolStripMenuItem.AccessibilityObject.IsPatternSupported(UiaCore.UIA.TogglePatternId);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(CheckState.Checked, (int)UiaCore.ToggleState.On)]
-    [InlineData(CheckState.Unchecked, (int)UiaCore.ToggleState.Off)]
-    [InlineData(CheckState.Indeterminate, (int)UiaCore.ToggleState.Indeterminate)]
-    public void ToolStripMenuItemAccessibleObject_ToggleState_ReturnsExpected(CheckState checkState, int expectedToggleState)
-    {
-        using ToolStripMenuItem toolStripMenuItem = new()
-        {
-            CheckState = checkState
-        };
-
-        object actual = toolStripMenuItem.AccessibilityObject.ToggleState;
-
-        Assert.Equal((UiaCore.ToggleState)expectedToggleState, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripMenuItemAccessibleObject_Toggle_Invoke()
-    {
-        using ToolStripMenuItem toolStripMenuItem = new()
-        {
-            CheckOnClick = true
-        };
-
-        int clickCounter = 0;
-
-        toolStripMenuItem.Click += (s, e) => { clickCounter++; };
-
-        Assert.Equal(UiaCore.ToggleState.Off, toolStripMenuItem.AccessibilityObject.ToggleState);
-
-        toolStripMenuItem.AccessibilityObject.Toggle();
-
-        Assert.Equal(UiaCore.ToggleState.On, toolStripMenuItem.AccessibilityObject.ToggleState);
-
-        toolStripMenuItem.AccessibilityObject.Toggle();
-
-        Assert.Equal(UiaCore.ToggleState.Off, toolStripMenuItem.AccessibilityObject.ToggleState);
-
-        Assert.Equal(0, clickCounter);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItemTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItemTests.cs
deleted file mode 100644
index e1d07a1f583..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripMenuItemTests.cs
+++ /dev/null
@@ -1,197 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripMenuItemTests
-{
-    [WinFormsFact]
-    public void ToolStripMenuItem_Ctor_Default()
-    {
-        using var item = new SubToolStripMenuItem();
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 32, 19), item.Bounds);
-        Assert.True(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(-2, 2, 36, 15), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(new Padding(0, 0, 0, 0), item.DefaultMargin);
-        Assert.Equal(new Padding(4, 0, 4, 0), item.DefaultPadding);
-        Assert.Equal(new Size(32, 19), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.Equal(ToolStripDropDownDirection.Default, item.DropDownDirection);
-        Assert.Equal(Point.Empty, item.DropDownLocation);
-        Assert.False(item.Checked);
-        Assert.False(item.CheckOnClick);
-        Assert.Equal(CheckState.Unchecked, item.CheckState);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.False(item.HasDropDownItems);
-        Assert.False(item.HasDropDown);
-        Assert.Equal(19, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsMdiWindowListEntry);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.True(item.IsTopLevel);
-        Assert.Equal(Padding.Empty, item.Margin);
-        Assert.Null(item.MdiForm);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.Never, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(new Padding(4, 0, 4, 0), item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Equal(Keys.None, item.ShortcutKeys);
-        Assert.True(item.ShowShortcutKeys);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(32, 19), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(32, item.Width);
-    }
-
-    public static IEnumerable<object[]> GetNativeMenuItemImage_TestData()
-    {
-        yield return new object[] { PInvoke.SC_MINIMIZE };
-        yield return new object[] { PInvoke.SC_CLOSE };
-        yield return new object[] { PInvoke.SC_RESTORE };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNativeMenuItemImage_TestData))]
-    public void ToolStripMenuItem_GetNativeMenuItemImage_ReturnsExpected(int nativeMenuCommandID)
-    {
-        using Form form = new();
-        form.CreateControl();
-        HMENU hmenu = PInvoke.GetSystemMenu(form, bRevert: false);
-        using SubToolStripMenuItem menuItem = new(hmenu, nativeMenuCommandID, form);
-
-        using Bitmap bitmap = menuItem.TestAccessor().Dynamic.GetNativeMenuItemImage();
-        Assert.NotNull(bitmap);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.F1)]
-    [InlineData(Keys.None)]
-    [InlineData(Keys.Control | Keys.Add)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.D)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.A)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift | Keys.F1)]
-    public void ToolStripMenuItem_SetShortcutKeys(Keys keys)
-    {
-        using var item = new SubToolStripMenuItem();
-        item.ShortcutKeys = keys;
-        Assert.Equal(keys, item.ShortcutKeys);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Control)]
-    [InlineData(Keys.Control | Keys.Alt)]
-    [InlineData(Keys.Control | Keys.Alt | Keys.Shift)]
-    public void ToolStripMenuItem_SetShortcutKeys_ThrowsInvalidEnumArgumentException(Keys keys)
-    {
-        using var item = new SubToolStripMenuItem();
-        Assert.Throws<InvalidEnumArgumentException>(() => item.ShortcutKeys = keys);
-    }
-
-    private class SubToolStripMenuItem : ToolStripMenuItem
-    {
-        public SubToolStripMenuItem() : base()
-        {
-        }
-
-        public SubToolStripMenuItem(string text, Image image, EventHandler onClick) : base(text, image, onClick)
-        {
-        }
-
-        public SubToolStripMenuItem(string text, Image image, EventHandler onClick, string name) : base(text, image, onClick, name)
-        {
-        }
-
-        public SubToolStripMenuItem(string text, Image image, params ToolStripItem[] dropDownItems) : base(text, image, dropDownItems)
-        {
-        }
-
-        internal SubToolStripMenuItem(HMENU hmenu, int nativeMenuCommandId, IWin32Window targetWindow) : base(hmenu, nativeMenuCommandId, targetWindow)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ToolStripDropDown CreateDefaultDropDown() => base.CreateDefaultDropDown();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripNumericUpDown.ToolStripNumericUpDownAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripNumericUpDown.ToolStripNumericUpDownAccessibleObjectTests.cs
deleted file mode 100644
index 8e0771206f8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripNumericUpDown.ToolStripNumericUpDownAccessibleObjectTests.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripControlHost;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripNumericUpDown_ToolStripNumericUpDownAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripNumericUpDownAccessibleObject_Ctor_Default()
-    {
-        using ToolStripNumericUpDown toolStripNumericUpDown = new ToolStripNumericUpDown();
-        ToolStripHostedControlAccessibleObject accessibleObject = (ToolStripHostedControlAccessibleObject)toolStripNumericUpDown.Control.AccessibilityObject;
-
-        ToolStripNumericUpDown actual = accessibleObject.TestAccessor().Dynamic._toolStripControlHost;
-
-        Assert.Equal(toolStripNumericUpDown, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripNumericUpDownAccessibleObject_ControlType_IsSpinner_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripNumericUpDown toolStripNumericUpDown = new ToolStripNumericUpDown();
-        // AccessibleRole is not set = Default
-
-        Assert.Equal(UiaCore.UIA.SpinnerControlTypeId, toolStripNumericUpDown.Control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-        Assert.Null(toolStripNumericUpDown.Control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ValueValuePropertyId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Client)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ToolStripNumericUpDownAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using ToolStripNumericUpDown toolStripNumericUpDown = new ToolStripNumericUpDown();
-        // AccessibleRole is not set = Default
-        Control control = toolStripNumericUpDown.Control;
-
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        AccessibleRole actual = toolStripNumericUpDown.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripNumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripNumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripNumericUpDownAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripNumericUpDown toolStripNumericUpDown = new ToolStripNumericUpDown();
-        toolStripNumericUpDown.AccessibleRole = role;
-
-        object actual = toolStripNumericUpDown.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflow.ToolStripOverflowAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflow.ToolStripOverflowAccessibleObjectTests.cs
deleted file mode 100644
index 8ad93de77d8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflow.ToolStripOverflowAccessibleObjectTests.cs
+++ /dev/null
@@ -1,222 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripOverflow;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripOverflow_ToolStripOverflowAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_ctor_default()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-        ToolStripOverflowAccessibleObject accessibleObject = new(toolStripOverflow);
-
-        Assert.Equal(toolStripOverflow, accessibleObject.Owner);
-        Assert.False(toolStripOverflow.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_ControlType_IsToolBar_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-        // AccessibleRole is not set = Default
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.MenuControlTypeId, actual);
-        Assert.False(toolStripOverflow.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_Role_IsToolBar_ByDefault()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripOverflow.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuPopup, actual);
-        Assert.False(toolStripOverflow.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripOverflowAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripOverflowAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripOverflowAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-        toolStripOverflow.AccessibleRole = role;
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(role, accessibleObject.Role);
-        Assert.Equal(expected, actual);
-        Assert.False(toolStripOverflow.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.NextSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.PreviousSibling)]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleNotCreated(int navigateDirection)
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-        AccessibleObject expected = toolStripItem.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate((UiaCore.NavigateDirection)navigateDirection));
-        Assert.False(toolStripOverflow.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-        AccessibleObject expected = toolStripItem.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_Sibling_ReturnsExpected()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using ToolStrip toolStrip = CreateToolStripWithOverflow(5);
-
-        toolStrip.OverflowButton.DropDown.CreateControl(ignoreVisible: true);
-
-        AccessibleObject accessibleObject = toolStrip.OverflowButton.DropDown.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected_IfItemAligned()
-    {
-        using ToolStrip toolStrip = CreateToolStripWithOverflow(5);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        toolStrip.OverflowButton.DropDown.CreateControl(ignoreVisible: true);
-
-        AccessibleObject accessibleObject = toolStrip.OverflowButton.DropDown.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using ToolStrip toolStrip = CreateToolStripWithOverflow(5);
-
-        toolStrip.OverflowButton.DropDown.CreateControl(ignoreVisible: true);
-
-        AccessibleObject accessibleObject = toolStrip.OverflowButton.DropDown.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[4].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected_IfItemAligned()
-    {
-        using ToolStrip toolStrip = CreateToolStripWithOverflow(5);
-
-        toolStrip.Items[0].Alignment = ToolStripItemAlignment.Right;
-
-        toolStrip.PerformLayout();
-
-        toolStrip.OverflowButton.DropDown.CreateControl(ignoreVisible: true);
-
-        AccessibleObject accessibleObject = toolStrip.OverflowButton.DropDown.AccessibilityObject;
-        AccessibleObject expected = toolStrip.Items[4].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowAccessibleObject_FragmentNavigate_Child_ReturnsNullIfOverflowEmpty()
-    {
-        using ToolStripButton toolStripItem = new();
-        using ToolStripOverflow toolStripOverflow = new(toolStripItem);
-
-        toolStripOverflow.CreateControl(ignoreVisible: true);
-
-        AccessibleObject accessibleObject = toolStripOverflow.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    private static ToolStrip CreateToolStripWithOverflow(int itemCount)
-    {
-        ToolStrip toolStrip = new()
-        {
-            AutoSize = false,
-            Size = new(20, 30),
-            CanOverflow = true,
-        };
-
-        for (int i = 0; i < itemCount; i++)
-        {
-            toolStrip.Items.Add(CreateItem(i, ToolStripItemAlignment.Left));
-        }
-
-        return toolStrip;
-
-        ToolStripItem CreateItem(int index, ToolStripItemAlignment align)
-        {
-            return new ToolStripButton
-            {
-                AutoSize = false,
-                Size = new(25, 25),
-                Alignment = align
-            };
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflowButton.ToolStripOverflowButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflowButton.ToolStripOverflowButtonAccessibleObjectTests.cs
deleted file mode 100644
index 4e9332a2851..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripOverflowButton.ToolStripOverflowButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripOverflowButton;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripOverflowButton_ToolStripOverflowButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripOverflowButtonAccessibleObject_Ctor_Default()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        ToolStripOverflowButton toolStripOverflowButton = new ToolStripOverflowButton(toolStrip);
-        ToolStripOverflowButtonAccessibleObject accessibleObject = new ToolStripOverflowButtonAccessibleObject(toolStripOverflowButton);
-
-        Assert.Equal(toolStripOverflowButton, accessibleObject.Owner);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowButtonAccessibleObject_ControlType_IsMenuItem_IfAccessibleRoleIsDefault()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        ToolStripOverflowButton toolStripOverflowButton = new ToolStripOverflowButton(toolStrip);
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripOverflowButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.MenuItemControlTypeId, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowButtonAccessibleObject_Role_IsMenuItem_ByDefault()
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        ToolStripOverflowButton toolStripOverflowButton = new ToolStripOverflowButton(toolStrip);
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripOverflowButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuItem, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripOverflowButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripOverflowButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripOverflowButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStrip toolStrip = new ToolStrip();
-        ToolStripOverflowButton toolStripOverflowButton = new ToolStripOverflowButton(toolStrip);
-        toolStripOverflowButton.AccessibleRole = role;
-
-        object actual = toolStripOverflowButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowButtonAccessibleObject_FragmentNavigate_Child_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new() { AutoSize = false, Size = new(30, 30) };
-
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-
-        toolStrip.CreateControl();
-        toolStrip.PerformLayout();
-
-        AccessibleObject accessibleObject = toolStrip.OverflowButton.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        toolStrip.OverflowButton.DropDown.Show();
-
-        AccessibleObject expected = toolStrip.OverflowButton.DropDown.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripOverflowButtonAccessibleObject_FragmentNavigate_Siblings_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new() { AutoSize = false, Size = new(60, 30) };
-
-        // 1 item displayed and 2 overflown
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-        toolStrip.Items.Add(string.Empty);
-
-        toolStrip.PerformLayout();
-
-        AccessibleObject overflowButton = toolStrip.OverflowButton.AccessibilityObject;
-        AccessibleObject item1 = toolStrip.Items[0].AccessibilityObject;
-
-        Assert.Null(overflowButton.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(item1, overflowButton.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanel.ToolStripPanelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanel.ToolStripPanelAccessibleObjectTests.cs
deleted file mode 100644
index 8eb7c89b371..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanel.ToolStripPanelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripPanel;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripPanel_ToolStripPanelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripPanelAccessibleObject_Ctor_Default()
-    {
-        using ToolStripPanel control = new();
-        var accessibleObject = (ToolStripPanelAccessibleObject)control.AccessibilityObject;
-
-        Assert.Equal(control, accessibleObject.Owner);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanelAccessibleObject_GetPropertyValue_IsKeyboardFocusable_False()
-    {
-        using ToolStripPanel control = new();
-
-        var accessibleObject = (ToolStripPanelAccessibleObject)control.AccessibilityObject;
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.IsKeyboardFocusablePropertyId);
-
-        Assert.False(value);
-        Assert.False(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRenderEventArgsTests.cs
deleted file mode 100644
index c4f2da2c24a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRenderEventArgsTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripPanelRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStripPanel_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { graphics, null };
-        yield return new object[] { null, new ToolStripPanel() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStripPanel_TestData))]
-    public void ToolStripPanelRenderEventArgs_Null_Graphics_ToolStripPanel_ThrowsArgumentNullException(Graphics g, ToolStripPanel toolStripPanel)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripPanelRenderEventArgs(g, toolStripPanel));
-    }
-
-    [WinFormsFact]
-    public void Ctor_Graphics_ToolStripPanel()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var toolStripPanel = new ToolStripPanel();
-        var e = new ToolStripPanelRenderEventArgs(graphics, toolStripPanel);
-        Assert.Equal(graphics, e.Graphics);
-        Assert.Equal(toolStripPanel, e.ToolStripPanel);
-        Assert.False(e.Handled);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Handled_Set_GetReturnsExpected(bool value)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            using var panel = new ToolStripPanel();
-            var e = new ToolStripPanelRenderEventArgs(graphics, panel)
-            {
-                Handled = value
-            };
-            Assert.Equal(value, e.Handled);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRow.ToolStripPanelRowControlCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRow.ToolStripPanelRowControlCollectionTests.cs
deleted file mode 100644
index ed0b74b7de1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelRow.ToolStripPanelRowControlCollectionTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripPanelRowControlCollectionTests
-{
-    [WinFormsFact]
-    public void GetControl_ShouldNotThrowIndexOutOfRangeException()
-    {
-        // https://github.com/dotnet/winforms/issues/9126
-        using Form form = new();
-        using ToolStripContainer toolStripContainer = new();
-        using ToolStrip toolStrip1 = new();
-        using ToolStrip toolStrip2 = new();
-
-        toolStripContainer.TopToolStripPanel.SuspendLayout();
-        toolStripContainer.SuspendLayout();
-        form.SuspendLayout();
-
-        toolStripContainer.TopToolStripPanel.Controls.Add(toolStrip1);
-        toolStripContainer.TopToolStripPanel.Controls.Add(toolStrip2);
-
-        toolStrip1.Location = new Point(3, 0);
-        toolStrip2.Location = new Point(148, 0);
-
-        form.Controls.Add(toolStripContainer);
-        toolStripContainer.TopToolStripPanel.ResumeLayout(false);
-        toolStripContainer.TopToolStripPanel.PerformLayout();
-        toolStripContainer.ResumeLayout(false);
-        toolStripContainer.PerformLayout();
-        form.ResumeLayout(false);
-
-        var exception = Record.Exception(() => form.Show());
-
-        Assert.Null(exception);
-    }
-}
-
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelTests.cs
deleted file mode 100644
index 40e75055870..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripPanelTests.cs
+++ /dev/null
@@ -1,429 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripPanelTests
-{
-    [WinFormsFact]
-    public void ToolStripPanel_Ctor_Default()
-    {
-        using var control = new SubToolStripPanel();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        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.None, control.AutoScaleMode);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(0, control.Bottom);
-        Assert.Equal(Rectangle.Empty, control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(Rectangle.Empty, control.ClientRectangle);
-        Assert.Equal(Size.Empty, control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(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(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.Equal(Size.Empty, control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(Rectangle.Empty, control.DisplayRectangle);
-        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.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(0, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, 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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(0, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(new Padding(3, 0, 0, 0), control.RowMargin);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(Size.Empty, control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(0, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanel_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubToolStripPanel();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripPanel_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var panel = new ToolStripPanel
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, panel.AllowDrop);
-        Assert.False(panel.IsHandleCreated);
-
-        // Set same.
-        panel.AllowDrop = value;
-        Assert.Equal(value, panel.AllowDrop);
-        Assert.False(panel.IsHandleCreated);
-
-        // Set different.
-        panel.AllowDrop = !value;
-        Assert.Equal(!value, panel.AllowDrop);
-        Assert.False(panel.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void AutoScroll_Set_GetReturnsExpected(bool value)
-    {
-        using var panel = new ToolStripPanel
-        {
-            AutoScroll = value
-        };
-        Assert.Equal(value, panel.AutoScroll);
-
-        // Set same.
-        panel.AutoScroll = value;
-        Assert.Equal(value, panel.AutoScroll);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData), TestIncludeType.NoNegatives)]
-    public void AutoScrollMargin_Set_GetReturnsExpected(Size value)
-    {
-        using var panel = new ToolStripPanel
-        {
-            AutoScrollMargin = value
-        };
-        Assert.Equal(value, panel.AutoScrollMargin);
-
-        // Set same.
-        panel.AutoScrollMargin = value;
-        Assert.Equal(value, panel.AutoScrollMargin);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData), TestIncludeType.NoPositives)]
-    public void AutoScrollMargin_SetInvalid_ThrowsArgumentOutOfRangeException(Size value)
-    {
-        using var panel = new ToolStripPanel();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => panel.AutoScrollMargin = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetSizeTheoryData))]
-    public void AutoScrollMinSize_Set_GetReturnsExpected(Size value)
-    {
-        using var panel = new ToolStripPanel
-        {
-            AutoScrollMinSize = value
-        };
-        Assert.Equal(value, panel.AutoScrollMinSize);
-        Assert.Equal(value != Size.Empty, panel.AutoScroll);
-
-        // Set same.
-        panel.AutoScrollMinSize = value;
-        Assert.Equal(value, panel.AutoScrollMinSize);
-        Assert.Equal(value != Size.Empty, panel.AutoScroll);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripPanel_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStripPanel();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanel_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new ToolStripPanel
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void RowMargin_Set_GetReturnsExpected(Padding value)
-    {
-        using var panel = new ToolStripPanel
-        {
-            RowMargin = value
-        };
-        Assert.Equal(value, panel.RowMargin);
-
-        // Set same.
-        panel.RowMargin = value;
-        Assert.Equal(value, panel.RowMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanel_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripPanel();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ToolStripPanel_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubToolStripPanel();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanel_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStripPanel();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void ToolStripPanel_AddTwoToolStrips_DoesNotThrowInvalidCastException()
-    {
-        using ToolStripContainer toolStripContainer = new();
-        using ToolStrip toolStrip1 = new();
-        using ToolStrip toolStrip2 = new();
-
-        toolStripContainer.TopToolStripPanel.Controls.Add(toolStrip1);
-        var exception = Record.Exception(() => toolStripContainer.TopToolStripPanel.Controls.Add(toolStrip2));
-
-        Assert.Null(exception);
-    }
-
-    private class SubToolStripPanel : ToolStripPanel
-    {
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripProgressBar.ToolStripProgressBarControl.ToolStripProgressBarControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripProgressBar.ToolStripProgressBarControl.ToolStripProgressBarControlAccessibleObjectTests.cs
deleted file mode 100644
index 499ea5ad49b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripProgressBar.ToolStripProgressBarControl.ToolStripProgressBarControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,138 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripProgressBar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripProgressBar_ToolStripProgressBarControl_ToolStripProgressBarControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripProgressBarControlAccessibleObject_ctor_default()
-    {
-        using ToolStripProgressBarControl toolStripProgressBarControl = new ToolStripProgressBarControl();
-        ToolStripProgressBarControlAccessibleObject accessibleObject = new ToolStripProgressBarControlAccessibleObject(toolStripProgressBarControl);
-
-        Assert.Equal(toolStripProgressBarControl, accessibleObject.Owner);
-        Assert.False(toolStripProgressBarControl.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripProgressBarControlAccessibleObject_ControlType_IsProgressBar_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripProgressBarControl toolStripProgressBarControl = new ToolStripProgressBarControl();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripProgressBarControl.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ProgressBarControlTypeId, actual);
-        Assert.False(toolStripProgressBarControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ProgressBar)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ToolStripProgressBarControlAccessibleObject_Role_IsExpected_ByDefault(bool createControl, AccessibleRole expectedRole)
-    {
-        using ToolStripProgressBarControl toolStripProgressBarControl = new ToolStripProgressBarControl();
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            toolStripProgressBarControl.CreateControl();
-        }
-
-        object actual = toolStripProgressBarControl.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, toolStripProgressBarControl.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripProgressBarControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripProgressBarControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripProgressBarControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripProgressBarControl toolStripProgressBarControl = new ToolStripProgressBarControl();
-        toolStripProgressBarControl.AccessibleRole = role;
-
-        AccessibleObject accessibleObject = toolStripProgressBarControl.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(role, accessibleObject.Role);
-        Assert.Equal(expected, actual);
-        Assert.False(toolStripProgressBarControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.NavigateDirection.FirstChild)]
-    [InlineData((int)UiaCore.NavigateDirection.LastChild)]
-    public void ToolStripProgressBarControlAccessibleObject_FragmentNavigate_ChildrenAreNull(int direction)
-    {
-        using ToolStripProgressBarControl control = new();
-
-        object actual = control.AccessibilityObject.FragmentNavigate((UiaCore.NavigateDirection)direction);
-
-        Assert.Null(actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripProgressBarControlAccessibleObject_FragmentNavigate_ParentIsToolStrip()
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStripProgressBarControl control = new();
-        using ToolStripProgressBar item = new();
-        using ToolStrip toolStrip = new();
-        control.Owner = item;
-        item.Parent = toolStrip;
-
-        object actual = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(toolStrip.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripProgressBarControlAccessibleObject_FragmentNavigate_SiblingsAreExpected()
-    {
-        using NoAssertContext noAssertContext = new();
-        using ToolStripProgressBarControl control = new();
-        using ToolStripProgressBar item = new();
-        using ToolStrip toolStrip = new() { Size = new Drawing.Size(500, 25) };
-        using ToolStripLabel label = new() { Text = "Label" };
-        using ToolStripButton button = new() { Text = "Button" };
-
-        toolStrip.CreateControl();
-        control.Owner = item;
-        item.Parent = toolStrip;
-        toolStrip.Items.Add(label);
-        toolStrip.Items.Add(item);
-        toolStrip.Items.Add(button);
-
-        object nextSibling = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling);
-        object previousSibling = control.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling);
-
-        Assert.Equal(button.AccessibilityObject, nextSibling);
-        Assert.Equal(label.AccessibilityObject, previousSibling);
-        Assert.False(control.IsHandleCreated);
-        Assert.True(toolStrip.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRenderEventArgsTests.cs
deleted file mode 100644
index 326ca605c92..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRenderEventArgsTests.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStrip_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStrip() };
-        yield return new object[] { graphics, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStrip_TestData))]
-    public void ToolStripRenderEventArgs_Null_Graphics_ToolStrip_ThrowsArgumentNullException(Graphics g, ToolStrip toolStrip)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripRenderEventArgs(g, toolStrip));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStrip_TestData()
-    {
-        yield return new object[] { new ToolStrip(), new Rectangle(0, 0, 100, 25), SystemColors.Control };
-        yield return new object[] { new ToolStrip() { BackColor = Color.Red }, new Rectangle(0, 0, 100, 25), Color.Red };
-        yield return new object[] { new ToolStripDropDown(), new Rectangle(0, 0, 100, 25), SystemColors.Menu };
-        yield return new object[] { new MenuStrip(), new Rectangle(0, 0, 200, 24), SystemColors.MenuBar };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStrip_TestData))]
-    public void ToolStripRenderEventArgs_Ctor_Graphics_ToolStrip(ToolStrip toolStrip, Rectangle expectedAffectedBounds, Color expectedBackColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new ToolStripRenderEventArgs(graphics, toolStrip);
-
-        Assert.Same(graphics, e.Graphics);
-        Assert.Same(toolStrip, e.ToolStrip);
-        Assert.Equal(expectedAffectedBounds, e.AffectedBounds);
-        Assert.Equal(expectedBackColor, e.BackColor);
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStrip_Rectangle_Color_TestData()
-    {
-        yield return new object[] { new ToolStrip(), new Rectangle(1, 2, 3, 4), Color.Empty, SystemColors.Control };
-        yield return new object[] { new ToolStrip() { BackColor = Color.Red }, new Rectangle(1, 2, 3, 4), Color.Empty, Color.Red };
-        yield return new object[] { new ToolStripDropDown(), new Rectangle(1, 2, 3, 4), Color.Empty, SystemColors.Menu };
-        yield return new object[] { new MenuStrip(), new Rectangle(1, 2, 3, 4), Color.Empty, SystemColors.MenuBar };
-        yield return new object[] { new ToolStrip() { BackColor = Color.Red }, new Rectangle(1, 2, 3, 4), Color.Blue, Color.Blue };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStrip_Rectangle_Color_TestData))]
-    public void ToolStripRenderEventArgs_Ctor_Graphics_ToolStrip_Rectangle_Color(ToolStrip toolStrip, Rectangle affectedBounds, Color backColor, Color expectedBackColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        var e = new ToolStripRenderEventArgs(graphics, toolStrip, affectedBounds, backColor);
-
-        Assert.Same(graphics, e.Graphics);
-        Assert.Same(toolStrip, e.ToolStrip);
-        Assert.Equal(affectedBounds, e.AffectedBounds);
-        Assert.Equal(expectedBackColor, e.BackColor);
-    }
-
-    public static IEnumerable<object[]> ConnectedArea_Empty_TestData()
-    {
-        yield return new object[] { new ToolStrip() };
-        yield return new object[] { new ToolStripDropDown() };
-        yield return new object[] { new ToolStripOverflow(new ToolStripButton()) };
-        yield return new object[] { new ToolStripOverflow(new ToolStripDropDownButton()) };
-
-        var ownedDropDownItem = new ToolStripDropDownButton();
-        var owner = new ToolStrip();
-        owner.Items.Add(ownedDropDownItem);
-        yield return new object[] { new ToolStripOverflow(ownedDropDownItem) };
-        yield return new object[] { new ToolStripOverflow(owner.OverflowButton) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ConnectedArea_Empty_TestData))]
-    public void ToolStripRenderEventArgs_ConnectedArea_Get_ReturnsEmpty(ToolStrip toolStrip)
-    {
-        using (var image = new Bitmap(10, 10))
-        using (Graphics graphics = Graphics.FromImage(image))
-        {
-            var e = new ToolStripRenderEventArgs(graphics, toolStrip, new Rectangle(1, 2, 3, 4), Color.Empty);
-            Assert.Equal(Rectangle.Empty, e.ConnectedArea);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRendererTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRendererTests.cs
deleted file mode 100644
index 1cb66ae6bc9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripRendererTests.cs
+++ /dev/null
@@ -1,1071 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripRendererTests
-{
-    [WinFormsFact]
-    public void ToolStripRenderer_CreateDisabledImage_Invoke_Success()
-    {
-        using var image = new Bitmap(10, 11);
-        Image result = Assert.IsType<Bitmap>(ToolStripRenderer.CreateDisabledImage(image));
-        Assert.NotSame(result, image);
-        Assert.Equal(new Size(10, 11), result.Size);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_CreateDisabledImage_NullImage_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("normalImage", () => ToolStripRenderer.CreateDisabledImage(null));
-    }
-
-    public static IEnumerable<object[]> ToolStripArrowRenderEventArgs_TestData()
-    {
-        foreach (ArrowDirection arrowDirection in Enum.GetValues(typeof(ArrowDirection)))
-        {
-            yield return new object[] { null, Rectangle.Empty, Color.Empty, arrowDirection };
-            yield return new object[] { new SubToolStripItem(), new Rectangle(1, 2, 3, 4), Color.Red, arrowDirection };
-        }
-
-        yield return new object[] { null, Rectangle.Empty, Color.Empty, ArrowDirection.Left - 1 };
-        yield return new object[] { null, Rectangle.Empty, Color.Empty, ArrowDirection.Up + 1 };
-        yield return new object[] { new SubToolStripItem(), new Rectangle(1, 2, 3, 4), Color.Red, ArrowDirection.Left - 1 };
-        yield return new object[] { new SubToolStripItem(), new Rectangle(1, 2, 3, 4), Color.Red, ArrowDirection.Up + 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripArrowRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawArrow_Invoke_CallsRenderArrow(ToolStripItem toolStripItem, Rectangle arrowRectangle, Color arrowColor, ArrowDirection arrowDirection)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var eventArgs = new ToolStripArrowRenderEventArgs(graphics, toolStripItem, arrowRectangle, arrowColor, arrowDirection);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripArrowRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderArrow += handler;
-        renderer.DrawArrow(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderArrow -= handler;
-        renderer.DrawArrow(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_DrawArrow_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.DrawArrow(null));
-    }
-
-    public static IEnumerable<object[]> ToolStripItemRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripItemRenderEventArgs(graphics, new SubToolStripItem()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawButtonBackground_Invoke_CallsRenderButtonBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderButtonBackground += handler;
-        renderer.DrawButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderButtonBackground -= handler;
-        renderer.DrawButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawDropDownButtonBackground_Invoke_CallsRenderDropDownButtonBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderDropDownButtonBackground += handler;
-        renderer.DrawDropDownButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderDropDownButtonBackground -= handler;
-        renderer.DrawDropDownButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripGripRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripGripRenderEventArgs(graphics, new ToolStrip()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripGripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawGrip_Invoke_CallsRenderGrip(ToolStripGripRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripGripRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderGrip += handler;
-        renderer.DrawGrip(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderGrip -= handler;
-        renderer.DrawGrip(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawItemBackground_Invoke_CallsRenderItemBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderItemBackground += handler;
-        renderer.DrawItemBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderItemBackground -= handler;
-        renderer.DrawItemBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripItemImageRenderEventArgs_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { graphics, new SubToolStripItem(), new Bitmap(10, 10), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { graphics, new SubToolStripItem { Enabled = false }, new Bitmap(10, 10), new Rectangle(1, 2, 3, 4) };
-
-        foreach (ToolStripItemImageScaling imageScaling in Enum.GetValues(typeof(ToolStripItemImageScaling)))
-        {
-            yield return new object[] { graphics, new SubToolStripItem { ImageScaling = imageScaling }, new Bitmap(10, 10), new Rectangle(1, 2, 3, 4) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemImageRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawItemCheck_Invoke_CallsRenderItemCheck(Graphics graphics, ToolStripItem item, Image image, Rectangle imageRectangle)
-    {
-        var eventArgs = new ToolStripItemImageRenderEventArgs(graphics, item, image, imageRectangle);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemImageRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderItemCheck += handler;
-        renderer.DrawItemCheck(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderItemCheck -= handler;
-        renderer.DrawItemCheck(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_DrawItemCheck_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.DrawItemCheck(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemImageRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawItemImage_Invoke_CallsRenderItemImage(Graphics graphics, ToolStripItem item, Image image, Rectangle imageRectangle)
-    {
-        var eventArgs = new ToolStripItemImageRenderEventArgs(graphics, item, image, imageRectangle);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemImageRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderItemImage += handler;
-        renderer.DrawItemImage(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderItemImage -= handler;
-        renderer.DrawItemImage(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_DrawItemImage_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.DrawItemImage(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawImageMargin_Invoke_CallsRenderImageMargin(ToolStripRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderImageMargin += handler;
-        renderer.DrawImageMargin(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderImageMargin -= handler;
-        renderer.DrawImageMargin(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripItemTextRenderEventArgs_TestData()
-    {
-        yield return new object[] { new SubToolStripItem(), null, Rectangle.Empty, Color.Empty, null, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), null, new Rectangle(1, 2, 0, 4), Color.Empty, null, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), null, new Rectangle(1, 2, 3, 0), Color.Empty, null, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), null, new Rectangle(1, 2, 3, 4), Color.Empty, null, TextFormatFlags.Left };
-
-        yield return new object[] { new SubToolStripItem(), "Text", Rectangle.Empty, Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), "Text", new Rectangle(1, 2, 0, 4), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), "Text", new Rectangle(1, 2, 3, 0), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem(), "Text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem() { Enabled = false }, "Text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem() { TextDirection = ToolStripTextDirection.Vertical270 }, "Text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-        yield return new object[] { new SubToolStripItem() { TextDirection = ToolStripTextDirection.Vertical90 }, "Text", new Rectangle(1, 2, 3, 4), Color.Red, SystemFonts.MenuFont, TextFormatFlags.Left };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemTextRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawItemText_Invoke_CallsRenderItemText(ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, TextFormatFlags format)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var eventArgs = new ToolStripItemTextRenderEventArgs(graphics, item, text, textRectangle, textColor, textFont, format);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemTextRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderItemText += handler;
-        renderer.DrawItemText(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderItemText -= handler;
-        renderer.DrawItemText(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_DrawItemText_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.DrawItemText(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawLabelBackground_Invoke_CallsRenderLabelBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderLabelBackground += handler;
-        renderer.DrawLabelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderLabelBackground -= handler;
-        renderer.DrawLabelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawMenuItemBackground_Invoke_CallsRenderMenuItemBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderMenuItemBackground += handler;
-        renderer.DrawMenuItemBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderMenuItemBackground -= handler;
-        renderer.DrawMenuItemBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawOverflowButtonBackground_Invoke_CallsRenderOverflowButtonBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderOverflowButtonBackground += handler;
-        renderer.DrawOverflowButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderOverflowButtonBackground -= handler;
-        renderer.DrawOverflowButtonBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripSeparatorRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripSeparatorRenderEventArgs(graphics, new ToolStripSeparator(), true) };
-        yield return new object[] { new ToolStripSeparatorRenderEventArgs(graphics, new ToolStripSeparator(), false) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripSeparatorRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawSeparator_Invoke_CallsRenderSeparator(ToolStripSeparatorRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripSeparatorRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderSeparator += handler;
-        renderer.DrawSeparator(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderSeparator -= handler;
-        renderer.DrawSeparator(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawSplitButton_Invoke_CallsRenderSplitButtonBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderSplitButtonBackground += handler;
-        renderer.DrawSplitButton(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderSplitButtonBackground -= handler;
-        renderer.DrawSplitButton(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> StatusStripSizingGrip_TestData()
-    {
-        yield return new object[] { new ToolStrip() };
-        yield return new object[] { new StatusStrip() };
-        yield return new object[] { new StatusStrip { GripStyle = ToolStripGripStyle.Hidden } };
-        yield return new object[] { new StatusStrip { RightToLeft = RightToLeft.Yes } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripSizingGrip_TestData))]
-    public void ToolStripRenderer_DrawStatusStripSizingGrip_Invoke_CallsRenderStatusStripSizingGrip(ToolStrip toolStrip)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var eventArgs = new ToolStripRenderEventArgs(graphics, toolStrip);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderStatusStripSizingGrip += handler;
-        renderer.DrawStatusStripSizingGrip(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderStatusStripSizingGrip -= handler;
-        renderer.DrawStatusStripSizingGrip(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void DrawStatusStripSizingGrip_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.DrawStatusStripSizingGrip(null));
-    }
-
-    public static IEnumerable<object[]> ToolStripRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripRenderEventArgs(graphics, new ToolStrip()) };
-        yield return new object[] { new ToolStripRenderEventArgs(graphics, new StatusStrip()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawToolStripBackground_Invoke_CallsRenderToolStripBackground(ToolStripRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderToolStripBackground += handler;
-        renderer.DrawToolStripBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderToolStripBackground -= handler;
-        renderer.DrawToolStripBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawToolStripBorder_Invoke_CallsRenderToolStripBorder(ToolStripRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderToolStripBorder += handler;
-        renderer.DrawToolStripBorder(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderToolStripBorder -= handler;
-        renderer.DrawToolStripBorder(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripContentPanelRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawToolStripContentPanelBackground_Invoke_CallsRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripContentPanelRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderToolStripContentPanelBackground += handler;
-        renderer.DrawToolStripContentPanelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderToolStripContentPanelBackground -= handler;
-        renderer.DrawToolStripContentPanelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripPanelRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripPanelRenderEventArgs(graphics, new ToolStripPanel()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripPanelRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawToolStripPanelBackground_Invoke_CallsRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripPanelRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderToolStripPanelBackground += handler;
-        renderer.DrawToolStripPanelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderToolStripPanelBackground -= handler;
-        renderer.DrawToolStripPanelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_DrawToolStripStatusLabelBackground_Invoke_CallsRenderToolStripStatusLabelBackground(ToolStripItemRenderEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        ToolStripItemRenderEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(renderer, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        renderer.RenderToolStripStatusLabelBackground += handler;
-        renderer.DrawToolStripStatusLabelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        renderer.RenderToolStripStatusLabelBackground -= handler;
-        renderer.DrawToolStripStatusLabelBackground(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> ToolStripContentPanelRenderEventArgs_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new ToolStripContentPanelRenderEventArgs(graphics, new ToolStripContentPanel()) };
-    }
-
-    public static IEnumerable<object[]> Initialize_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Initialize_TestData))]
-    public void ToolStripRenderer_Initialize_Invoke_Nop(ToolStrip toolStrip)
-    {
-        var renderer = new SubToolStripRenderer();
-        renderer.Initialize(toolStrip);
-    }
-
-    public static IEnumerable<object[]> InitializeContentPanel_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripContentPanel() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InitializeContentPanel_TestData))]
-    public void ToolStripRenderer_InitializeContentPanel_Invoke_Nop(ToolStripContentPanel contentPanel)
-    {
-        var renderer = new SubToolStripRenderer();
-        renderer.InitializeContentPanel(contentPanel);
-    }
-
-    public static IEnumerable<object[]> InitializeItem_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubToolStripItem() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InitializeItem_TestData))]
-    public void ToolStripRenderer_InitializeItem_Invoke_Nop(ToolStripItem item)
-    {
-        var renderer = new SubToolStripRenderer();
-        renderer.InitializeItem(item);
-    }
-
-    public static IEnumerable<object[]> InitializePanel_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ToolStripPanel() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(InitializePanel_TestData))]
-    public void ToolStripRenderer_InitializePanel_Invoke_Nop(ToolStripPanel toolStripPanel)
-    {
-        var renderer = new SubToolStripRenderer();
-        renderer.InitializePanel(toolStripPanel);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripArrowRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderArrow_Invoke_Nop(ToolStripItem toolStripItem, Rectangle arrowRectangle, Color arrowColor, ArrowDirection arrowDirection)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new ToolStripArrowRenderEventArgs(graphics, toolStripItem, arrowRectangle, arrowColor, arrowDirection);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderArrow += (sender, e) => callCount++;
-        renderer.OnRenderArrow(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_OnRenderArrow_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.OnRenderArrow(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderButtonBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderButtonBackground += (sender, e) => callCount++;
-        renderer.OnRenderButtonBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderDropDownButtonBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderDropDownButtonBackground += (sender, e) => callCount++;
-        renderer.OnRenderDropDownButtonBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripGripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderGrip_Invoke_Nop(ToolStripGripRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderGrip += (sender, e) => callCount++;
-        renderer.OnRenderGrip(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderImageMargin_Invoke_Nop(ToolStripRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderImageMargin += (sender, e) => callCount++;
-        renderer.OnRenderImageMargin(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderItemBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderItemBackground += (sender, e) => callCount++;
-        renderer.OnRenderItemBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemImageRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderItemCheck_Invoke_Nop(Graphics graphics, ToolStripItem item, Image image, Rectangle imageRectangle)
-    {
-        var e = new ToolStripItemImageRenderEventArgs(graphics, item, image, imageRectangle);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderItemCheck += (sender, e) => callCount++;
-        renderer.OnRenderItemCheck(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_OnRenderItemCheck_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.OnRenderItemCheck(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemImageRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderItemImage_Invoke_Nop(Graphics graphics, ToolStripItem item, Image image, Rectangle imageRectangle)
-    {
-        var e = new ToolStripItemImageRenderEventArgs(graphics, item, image, imageRectangle);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderItemImage += (sender, e) => callCount++;
-        renderer.OnRenderItemImage(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_OnRenderItemImage_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.OnRenderItemImage(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemTextRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderItemText_Invoke_Nop(ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, TextFormatFlags format)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new ToolStripItemTextRenderEventArgs(graphics, item, text, textRectangle, textColor, textFont, format);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderItemText += (sender, e) => callCount++;
-        renderer.OnRenderItemText(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_OnRenderItemText_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.OnRenderItemText(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderLabelBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderLabelBackground += (sender, e) => callCount++;
-        renderer.OnRenderLabelBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderMenuItemBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderMenuItemBackground += (sender, e) => callCount++;
-        renderer.OnRenderMenuItemBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderOverflowButtonBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderOverflowButtonBackground += (sender, e) => callCount++;
-        renderer.OnRenderOverflowButtonBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripSeparatorRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderSeparator_Invoke_Nop(ToolStripSeparatorRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderSeparator += (sender, e) => callCount++;
-        renderer.OnRenderSeparator(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderSplitButtonBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderSplitButtonBackground += (sender, e) => callCount++;
-        renderer.OnRenderSplitButtonBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StatusStripSizingGrip_TestData))]
-    public void ToolStripRenderer_OnRenderStatusStripSizingGrip_Invoke_Nop(ToolStrip toolStrip)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        var e = new ToolStripRenderEventArgs(graphics, toolStrip);
-
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderStatusStripSizingGrip += (sender, e) => callCount++;
-        renderer.OnRenderStatusStripSizingGrip(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_OnRenderStatusStripSizingGrip_NullE_ThrowsArgumentNullException()
-    {
-        var renderer = new SubToolStripRenderer();
-        Assert.Throws<ArgumentNullException>("e", () => renderer.OnRenderStatusStripSizingGrip(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderToolStripBackground_Invoke_Nop(ToolStripRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderToolStripBackground += (sender, e) => callCount++;
-        renderer.OnRenderToolStripBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderToolStripBorder_Invoke_Nop(ToolStripRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderToolStripBorder += (sender, e) => callCount++;
-        renderer.OnRenderToolStripBorder(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripContentPanelRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderToolStripContentPanelBackground_Invoke_Nop(ToolStripContentPanelRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderToolStripContentPanelBackground += (sender, e) => callCount++;
-        renderer.OnRenderToolStripContentPanelBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripPanelRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderToolStripPanelBackground_Invoke_Nop(ToolStripPanelRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderToolStripPanelBackground += (sender, e) => callCount++;
-        renderer.OnRenderToolStripPanelBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItemRenderEventArgs_TestData))]
-    public void ToolStripRenderer_OnRenderToolStripStatusLabelBackground_Invoke_Nop(ToolStripItemRenderEventArgs e)
-    {
-        var renderer = new SubToolStripRenderer();
-        int callCount = 0;
-        renderer.RenderToolStripStatusLabelBackground += (sender, e) => callCount++;
-        renderer.OnRenderToolStripStatusLabelBackground(e);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripRenderer_ScaleArrowOffsetsIfNeeded_Invoke_Success()
-    {
-        SubToolStripRenderer.ScaleArrowOffsetsIfNeeded();
-
-        // Call again.
-        SubToolStripRenderer.ScaleArrowOffsetsIfNeeded();
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(96)]
-    public void ToolStripRenderer_ScaleArrowOffsetsIfNeeded_InvokeInt_Success(int dpi)
-    {
-        SubToolStripRenderer.ScaleArrowOffsetsIfNeeded(dpi);
-
-        // Call again.
-        SubToolStripRenderer.ScaleArrowOffsetsIfNeeded(dpi);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-        public new void Initialize(ToolStrip toolStrip) => base.Initialize(toolStrip);
-
-        public new void InitializeContentPanel(ToolStripContentPanel contentPanel) => base.InitializeContentPanel(contentPanel);
-
-        public new void InitializeItem(ToolStripItem item) => base.InitializeItem(item);
-
-        public new void InitializePanel(ToolStripPanel toolStripPanel) => base.InitializePanel(toolStripPanel);
-
-        public new void OnRenderArrow(ToolStripArrowRenderEventArgs e) => base.OnRenderArrow(e);
-
-        public new void OnRenderButtonBackground(ToolStripItemRenderEventArgs e) => base.OnRenderButtonBackground(e);
-
-        public new void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e) => base.OnRenderDropDownButtonBackground(e);
-
-        public new void OnRenderGrip(ToolStripGripRenderEventArgs e) => base.OnRenderGrip(e);
-
-        public new void OnRenderImageMargin(ToolStripRenderEventArgs e) => base.OnRenderImageMargin(e);
-
-        public new void OnRenderItemBackground(ToolStripItemRenderEventArgs e) => base.OnRenderItemBackground(e);
-
-        public new void OnRenderItemCheck(ToolStripItemImageRenderEventArgs e) => base.OnRenderItemCheck(e);
-
-        public new void OnRenderItemImage(ToolStripItemImageRenderEventArgs e) => base.OnRenderItemImage(e);
-
-        public new void OnRenderItemText(ToolStripItemTextRenderEventArgs e) => base.OnRenderItemText(e);
-
-        public new void OnRenderLabelBackground(ToolStripItemRenderEventArgs e) => base.OnRenderLabelBackground(e);
-
-        public new void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e) => base.OnRenderMenuItemBackground(e);
-
-        public new void OnRenderOverflowButtonBackground(ToolStripItemRenderEventArgs e) => base.OnRenderOverflowButtonBackground(e);
-
-        public new void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e) => base.OnRenderSeparator(e);
-
-        public new void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e) => base.OnRenderSplitButtonBackground(e);
-
-        public new void OnRenderStatusStripSizingGrip(ToolStripRenderEventArgs e) => base.OnRenderStatusStripSizingGrip(e);
-
-        public new void OnRenderToolStripBackground(ToolStripRenderEventArgs e) => base.OnRenderToolStripBackground(e);
-
-        public new void OnRenderToolStripBorder(ToolStripRenderEventArgs e) => base.OnRenderToolStripBorder(e);
-
-        public new void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e) => base.OnRenderToolStripContentPanelBackground(e);
-
-        public new void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e) => base.OnRenderToolStripPanelBackground(e);
-
-        public new void OnRenderToolStripStatusLabelBackground(ToolStripItemRenderEventArgs e) => base.OnRenderToolStripStatusLabelBackground(e);
-
-        public static new void ScaleArrowOffsetsIfNeeded() => ToolStripRenderer.ScaleArrowOffsetsIfNeeded();
-
-        public static new void ScaleArrowOffsetsIfNeeded(int dpi) => ToolStripRenderer.ScaleArrowOffsetsIfNeeded(dpi);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripScrollButton.ToolStripScrollButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripScrollButton.ToolStripScrollButtonAccessibleObjectTests.cs
deleted file mode 100644
index 4685023785d..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripScrollButton.ToolStripScrollButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripScrollButtonAccessibleObject_ToolStripScrollButtonAccessibleObjectTests
-{
-    public static IEnumerable<object[]> ToolStripScrollButtonAccessibleObject_FragmentNavigate_TestData()
-    {
-        IEnumerable<Type> types = ReflectionHelper.GetPublicNotAbstractClasses<ToolStripDropDownItem>().Select(type => type);
-        foreach (Type itemType in types)
-        {
-            foreach (bool createControl in new[] { true, false })
-            {
-                yield return new object[] { itemType, createControl };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripScrollButtonAccessibleObject_FragmentNavigate_TestData))]
-    public void ToolStripScrollButtonAccessibleObject_FragmentNavigate_ReturnsExpected(Type itemType, bool createControl)
-    {
-        using ToolStrip toolStrip = new();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        using ToolStripDropDownItem ownerItem = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(itemType);
-        SubToolStripDropDownMenu dropDownMenu = new SubToolStripDropDownMenu(ownerItem, true, true);
-
-        toolStrip.Items.Add(ownerItem);
-        ownerItem.TestAccessor().Dynamic._dropDown = dropDownMenu;
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 1"));
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 2"));
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 3"));
-        dropDownMenu.UpdateDisplayedItems();
-
-        AccessibleObject accessibleObject = dropDownMenu.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        if (!createControl)
-        {
-            return;
-        }
-
-        dropDownMenu.CreateControl(ignoreVisible: true);
-
-        AccessibleObject upScrollButtonAccessibleObject = dropDownMenu.UpScrollButton.AccessibilityObject;
-        AccessibleObject itemAccessibleObject1 = dropDownMenu.Items[0].AccessibilityObject;
-        AccessibleObject itemAccessibleObject2 = dropDownMenu.Items[1].AccessibilityObject;
-        AccessibleObject itemAccessibleObject3 = dropDownMenu.Items[2].AccessibilityObject;
-        AccessibleObject downScrollButtonAccessibleObject = dropDownMenu.DownScrollButton.AccessibilityObject;
-
-        Assert.Equal(upScrollButtonAccessibleObject, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(downScrollButtonAccessibleObject, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(upScrollButtonAccessibleObject, itemAccessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(itemAccessibleObject2, itemAccessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(itemAccessibleObject2, itemAccessibleObject3.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(downScrollButtonAccessibleObject, itemAccessibleObject3.FragmentNavigate(NavigateDirection.NextSibling));
-
-        Assert.Equal(accessibleObject, upScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Equal(itemAccessibleObject1, upScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Null(upScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(upScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(upScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(accessibleObject, downScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.Parent));
-        Assert.Null(downScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(itemAccessibleObject3, downScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(downScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(downScrollButtonAccessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Equal(createControl, toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripScrollButtonAccessibleObject_FragmentNavigate_TestData))]
-    public void ToolStripScrollButtonAccessibleObject_FragmentNavigate_ReturnsNull_If_ScrollButtonsHidden(Type itemType, bool createControl)
-    {
-        using ToolStrip toolStrip = new();
-
-        if (createControl)
-        {
-            toolStrip.CreateControl();
-        }
-
-        using ToolStripDropDownItem ownerItem = ReflectionHelper.InvokePublicConstructor<ToolStripDropDownItem>(itemType);
-        SubToolStripDropDownMenu dropDownMenu = new SubToolStripDropDownMenu(ownerItem, true, false);
-
-        toolStrip.Items.Add(ownerItem);
-        ownerItem.TestAccessor().Dynamic._dropDown = dropDownMenu;
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 1"));
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 2"));
-
-        dropDownMenu.UpdateDisplayedItems();
-
-        AccessibleObject accessibleObject = dropDownMenu.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        if (!createControl)
-        {
-            return;
-        }
-
-        dropDownMenu.CreateControl(ignoreVisible: true);
-
-        AccessibleObject itemAccessibleObject1 = dropDownMenu.Items[0].AccessibilityObject;
-        AccessibleObject itemAccessibleObject2 = dropDownMenu.Items[1].AccessibilityObject;
-
-        Assert.Equal(itemAccessibleObject1, accessibleObject.FragmentNavigate(NavigateDirection.FirstChild));
-        Assert.Equal(itemAccessibleObject2, accessibleObject.FragmentNavigate(NavigateDirection.LastChild));
-
-        Assert.Null(itemAccessibleObject1.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Equal(itemAccessibleObject2, itemAccessibleObject1.FragmentNavigate(NavigateDirection.NextSibling));
-        Assert.Equal(itemAccessibleObject1, itemAccessibleObject2.FragmentNavigate(NavigateDirection.PreviousSibling));
-        Assert.Null(itemAccessibleObject2.FragmentNavigate(NavigateDirection.NextSibling));
-    }
-
-    [WinFormsFact]
-    public void ToolStripScrollButtonAccessibleObject_Properties_ReturnExpected()
-    {
-        using ToolStrip toolStrip = new();
-        using ToolStripDropDownItem ownerItem = new ToolStripDropDownButton();
-        SubToolStripDropDownMenu dropDownMenu = new SubToolStripDropDownMenu(ownerItem, true, true);
-
-        toolStrip.Items.Add(ownerItem);
-        ownerItem.TestAccessor().Dynamic._dropDown = dropDownMenu;
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 1"));
-        ownerItem.DropDownItems.Add(new ToolStripDropDownButton("Item 2"));
-        dropDownMenu.UpdateDisplayedItems();
-
-        AccessibleObject upScrollButtonAccessibleObject = dropDownMenu.UpScrollButton.AccessibilityObject;
-        AccessibleObject downScrollButtonAccessibleObject = dropDownMenu.DownScrollButton.AccessibilityObject;
-
-        var expectedUpButtonName = SR.ToolStripScrollButtonUpAccessibleName;
-        var expectedDownButtonName = SR.ToolStripScrollButtonDownAccessibleName;
-        var expectedDefaultAction = SR.AccessibleActionPress;
-        var expectedControlType = UIA.ButtonControlTypeId;
-
-        Assert.Equal(expectedUpButtonName, upScrollButtonAccessibleObject.Name);
-        Assert.Equal(expectedDefaultAction, upScrollButtonAccessibleObject.DefaultAction);
-        Assert.Equal(expectedControlType, upScrollButtonAccessibleObject.GetPropertyValue(UIA.ControlTypePropertyId));
-
-        Assert.Equal(expectedDownButtonName, downScrollButtonAccessibleObject.Name);
-        Assert.Equal(expectedDefaultAction, downScrollButtonAccessibleObject.DefaultAction);
-        Assert.Equal(expectedControlType, downScrollButtonAccessibleObject.GetPropertyValue(UIA.ControlTypePropertyId));
-    }
-
-    private class SubToolStripDropDownMenu : ToolStripDropDownMenu
-    {
-        private readonly bool _requiresScrollButtons;
-
-        internal SubToolStripDropDownMenu(ToolStripItem ownerItem, bool isAutoGenerated, bool requiresScrollButtons) : base(ownerItem, isAutoGenerated)
-        {
-            _requiresScrollButtons = requiresScrollButtons;
-        }
-
-        internal override bool RequiresScrollButtons => _requiresScrollButtons;
-
-        internal void UpdateDisplayedItems() => base.SetDisplayedItems();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparator.ToolStripSeparatorAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparator.ToolStripSeparatorAccessibleObjectTests.cs
deleted file mode 100644
index b0abfd589e2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparator.ToolStripSeparatorAccessibleObjectTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripSeparator;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSeparator_ToolStripSeparatorAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripSeparatorAccessibleObject_Ctor_Default()
-    {
-        using ToolStripSeparator toolStripSeparator = new ToolStripSeparator();
-        ToolStripSeparatorAccessibleObject accessibleObject = new ToolStripSeparatorAccessibleObject(toolStripSeparator);
-
-        Assert.Equal(toolStripSeparator, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparatorAccessibleObject_ControlType_IsSeparator_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripSeparator toolStripSeparator = new ToolStripSeparator();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripSeparator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.SeparatorControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparatorAccessibleObject_Role_IsSeparator_ByDefault()
-    {
-        using ToolStripSeparator toolStripSeparator = new ToolStripSeparator();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripSeparator.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Separator, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripSeparatorAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripSeparatorAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripSeparatorAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripSeparator toolStripSeparator = new ToolStripSeparator();
-        toolStripSeparator.AccessibleRole = role;
-
-        object actual = toolStripSeparator.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorRenderEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorRenderEventArgsTests.cs
deleted file mode 100644
index 5332eaf3ce2..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorRenderEventArgsTests.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSeparatorRenderEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_Null_Graphics_ToolStripSeparator_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-
-        yield return new object[] { null, null };
-        yield return new object[] { null, new ToolStripSeparator() };
-        yield return new object[] { graphics, null };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Null_Graphics_ToolStripSeparator_TestData))]
-    public void ToolStripSeparatorRenderEventArgs_Null_Graphics_ToolStripSeparator_ThrowsArgumentNullException(Graphics g, ToolStripSeparator toolStripSeparator)
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripSeparatorRenderEventArgs(g, toolStripSeparator, true));
-    }
-
-    public static IEnumerable<object[]> Ctor_Graphics_ToolStripItem_Bool_TestData()
-    {
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { graphics, new ToolStripSeparator(), true };
-        yield return new object[] { graphics, new ToolStripSeparator(), false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_Graphics_ToolStripItem_Bool_TestData))]
-    public void Ctor_Graphics_ToolStripItem_Bool(Graphics g, ToolStripSeparator separator, bool vertical)
-    {
-        var e = new ToolStripSeparatorRenderEventArgs(g, separator, vertical);
-        Assert.Equal(g, e.Graphics);
-        Assert.Equal(separator, e.Item);
-        Assert.Equal(vertical, e.Vertical);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorTests.cs
deleted file mode 100644
index b1760d7bc88..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSeparatorTests.cs
+++ /dev/null
@@ -1,1665 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSeparatorTests
-{
-    [WinFormsFact]
-    public void ToolStripSeparator_Ctor_Default()
-    {
-        using var item = new SubToolStripSeparator();
-        Assert.NotNull(item.AccessibilityObject);
-        Assert.Same(item.AccessibilityObject, item.AccessibilityObject);
-        Assert.Null(item.AccessibleDefaultActionDescription);
-        Assert.Null(item.AccessibleDescription);
-        Assert.Null(item.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, item.AccessibleRole);
-        Assert.Equal(ToolStripItemAlignment.Left, item.Alignment);
-        Assert.False(item.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, item.Anchor);
-        Assert.True(item.AutoSize);
-        Assert.False(item.AutoToolTip);
-        Assert.True(item.Available);
-        Assert.Equal(Control.DefaultBackColor, item.BackColor);
-        Assert.Null(item.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, item.BackgroundImageLayout);
-        Assert.Equal(new Rectangle(0, 0, 6, 6), item.Bounds);
-        Assert.False(item.CanSelect);
-        Assert.True(item.CanRaiseEvents);
-        Assert.Null(item.Container);
-        Assert.Equal(new Rectangle(2, 2, 2, 2), item.ContentRectangle);
-        Assert.False(item.DefaultAutoToolTip);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DefaultDisplayStyle);
-        Assert.Equal(Padding.Empty, item.DefaultMargin);
-        Assert.Equal(Padding.Empty, item.DefaultPadding);
-        Assert.Equal(new Size(6, 6), item.DefaultSize);
-        Assert.False(item.DesignMode);
-        Assert.True(item.DismissWhenClicked);
-        Assert.Equal(ToolStripItemDisplayStyle.ImageAndText, item.DisplayStyle);
-        Assert.Equal(DockStyle.None, item.Dock);
-        Assert.False(item.DoubleClickEnabled);
-        Assert.True(item.Enabled);
-        Assert.NotNull(item.Events);
-        Assert.Same(item.Events, item.Events);
-        Assert.NotNull(item.Font);
-        Assert.NotSame(Control.DefaultFont, item.Font);
-        Assert.Same(item.Font, item.Font);
-        Assert.Equal(SystemColors.ControlDark, item.ForeColor);
-        Assert.Equal(6, item.Height);
-        Assert.Null(item.Image);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.ImageAlign);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Equal(ToolStripItemImageScaling.SizeToFit, item.ImageScaling);
-        Assert.Equal(Color.Empty, item.ImageTransparentColor);
-        Assert.False(item.IsDisposed);
-        Assert.False(item.IsOnDropDown);
-        Assert.False(item.IsOnOverflow);
-        Assert.Equal(Padding.Empty, item.Margin);
-        Assert.Equal(MergeAction.Append, item.MergeAction);
-        Assert.Equal(-1, item.MergeIndex);
-        Assert.Empty(item.Name);
-        Assert.Equal(ToolStripItemOverflow.AsNeeded, item.Overflow);
-        Assert.Null(item.OwnerItem);
-        Assert.Equal(Padding.Empty, item.Padding);
-        Assert.Null(item.Parent);
-        Assert.Equal(ToolStripItemPlacement.None, item.Placement);
-        Assert.False(item.Pressed);
-        Assert.Equal(RightToLeft.Inherit, item.RightToLeft);
-        Assert.False(item.RightToLeftAutoMirrorImage);
-        Assert.False(item.Selected);
-        Assert.Equal(SystemInformation.MenuAccessKeysUnderlined, item.ShowKeyboardCues);
-        Assert.Null(item.Site);
-        Assert.Equal(new Size(6, 6), item.Size);
-        Assert.Null(item.Tag);
-        Assert.Empty(item.Text);
-        Assert.Equal(ContentAlignment.MiddleCenter, item.TextAlign);
-        Assert.Equal(ToolStripTextDirection.Horizontal, item.TextDirection);
-        Assert.Equal(TextImageRelation.ImageBeforeText, item.TextImageRelation);
-        Assert.Null(item.ToolTipText);
-        Assert.False(item.Visible);
-        Assert.Equal(6, item.Width);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripSeparator_AutoToolTip_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            AutoToolTip = value
-        };
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set same.
-        item.AutoToolTip = value;
-        Assert.Equal(value, item.AutoToolTip);
-
-        // Set different.
-        item.AutoToolTip = !value;
-        Assert.Equal(!value, item.AutoToolTip);
-    }
-
-    public static IEnumerable<object[]> BackgroundImage_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Bitmap(10, 10) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-        yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackgroundImage_Set_TestData))]
-    public void ToolStripSeparator_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            BackgroundImage = value
-        };
-        Assert.Equal(value, item.BackgroundImage);
-
-        // Set same.
-        item.BackgroundImage = value;
-        Assert.Equal(value, item.BackgroundImage);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void ToolStripSeparator_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, item.BackgroundImageLayout);
-
-        // Set same.
-        item.BackgroundImageLayout = value;
-        Assert.Equal(value, item.BackgroundImageLayout);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_CanSelect_InvokeDesignMode_ReturnsTrue()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var item = new ToolStripSeparator
-        {
-            Site = mockSite.Object
-        };
-        Assert.True(item.CanSelect);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripSeparator_DisplayStyle_Set_GetReturnsExpected(ToolStripItemDisplayStyle value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            DisplayStyle = value
-        };
-        Assert.Equal(value, item.DisplayStyle);
-
-        // Set same.
-        item.DisplayStyle = value;
-        Assert.Equal(value, item.DisplayStyle);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_DisplayStyle_SetWithHandler_CallsDisplayStyleChanged()
-    {
-        using var item = new ToolStripSeparator();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.DisplayStyleChanged += handler;
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(ToolStripItemDisplayStyle.Text, item.DisplayStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.DisplayStyle = ToolStripItemDisplayStyle.None;
-        Assert.Equal(ToolStripItemDisplayStyle.None, item.DisplayStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.DisplayStyleChanged -= handler;
-        item.DisplayStyle = ToolStripItemDisplayStyle.Text;
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripItemDisplayStyle>]
-    public void ToolStripSeparator_DisplayStyle_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripItemDisplayStyle value)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.DisplayStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripSeparator_DoubleClickEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            DoubleClickEnabled = value
-        };
-        Assert.Equal(value, item.DoubleClickEnabled);
-
-        // Set same.
-        item.DoubleClickEnabled = value;
-        Assert.Equal(value, item.DoubleClickEnabled);
-    }
-
-    public static IEnumerable<object[]> Enabled_Set_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            foreach (Image image in new Image[] { null, new Bitmap(10, 10) })
-            {
-                yield return new object[] { visible, image, true };
-                yield return new object[] { visible, image, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Enabled_Set_TestData))]
-    public void ToolStripSeparator_Enabled_Set_GetReturnsExpected(bool visible, Image image, bool value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            Visible = visible,
-            Image = image,
-            Enabled = value
-        };
-        Assert.Equal(value, item.Enabled);
-
-        // Set same.
-        item.Enabled = value;
-        Assert.Equal(value, item.Enabled);
-
-        // Set different.
-        item.Enabled = !value;
-        Assert.Equal(!value, item.Enabled);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_Enabled_SetWithHandler_CallsEnabledChanged()
-    {
-        using var item = new ToolStripSeparator();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.EnabledChanged += handler;
-
-        // Set different.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Enabled = false;
-        Assert.False(item.Enabled);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Enabled = true;
-        Assert.True(item.Enabled);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.EnabledChanged -= handler;
-        item.Enabled = false;
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Font_Set_TestData()
-    {
-        foreach (Enum displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-            yield return new object[] { displayStyle, new Font("Arial", 8.25f) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_Set_TestData))]
-    public void ToolStripSeparator_Font_Set_GetReturnsExpected(ToolStripItemDisplayStyle displayStyle, Font value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.Font = value;
-        Assert.Equal(value ?? new ToolStripSeparator().Font, item.Font);
-
-        // Set same.
-        item.Font = value;
-        Assert.Equal(value ?? new ToolStripSeparator().Font, item.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStripSeparator_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, item.ForeColor);
-
-        // Set same.
-        item.ForeColor = value;
-        Assert.Equal(expected, item.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var item = new ToolStripSeparator();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.ForeColorChanged += handler;
-
-        // Set different.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.ForeColorChanged -= handler;
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripSeparator))[nameof(ToolStripSeparator.ForeColor)];
-        using var item = new ToolStripSeparator();
-        Assert.False(property.CanResetValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.CanResetValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.True(property.CanResetValue(item));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStripSeparator))[nameof(ToolStripSeparator.ForeColor)];
-        using var item = new ToolStripSeparator();
-        Assert.False(property.ShouldSerializeValue(item));
-
-        item.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, item.ForeColor);
-        Assert.True(property.ShouldSerializeValue(item));
-
-        property.ResetValue(item);
-        Assert.Equal(Control.DefaultForeColor, item.ForeColor);
-        Assert.True(property.ShouldSerializeValue(item));
-    }
-
-    public static IEnumerable<object[]> Image_Set_TestData()
-    {
-        foreach (Color imageTransparentColor in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { imageTransparentColor, null };
-            yield return new object[] { imageTransparentColor, new Bitmap(10, 10) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")) };
-            yield return new object[] { imageTransparentColor, Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Image_Set_TestData))]
-    public void ToolStripSeparator_Image_Set_GetReturnsExpected(Color imageTransparentColor, Image value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ImageTransparentColor = imageTransparentColor
-        };
-
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-
-        // Set same.
-        item.Image = value;
-        Assert.Equal(value, item.Image);
-        Assert.Equal(-1, item.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripSeparator_ImageAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ImageAlign = value
-        };
-        Assert.Equal(value, item.ImageAlign);
-
-        // Set same.
-        item.ImageAlign = value;
-        Assert.Equal(value, item.ImageAlign);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripSeparator_ImageAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.ImageAlign = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ToolStripSeparator_ImageIndex_Set_GetReturnsExpected(int value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageIndex = value;
-        Assert.Equal(value, item.ImageIndex);
-        Assert.Empty(item.ImageKey);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolStripSeparator_ImageKey_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-
-        // Set same.
-        item.ImageKey = value;
-        Assert.Equal(expected, item.ImageKey);
-        Assert.Equal(-1, item.ImageIndex);
-        Assert.Null(item.Image);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolStripItemImageScaling>]
-    public void ToolStripSeparator_ImageScaling_Set_GetReturnsExpected(ToolStripItemImageScaling value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ImageScaling = value
-        };
-        Assert.Equal(value, item.ImageScaling);
-
-        // Set same.
-        item.ImageScaling = value;
-        Assert.Equal(value, item.ImageScaling);
-    }
-
-    public static IEnumerable<object[]> ImageTransparentColor_Set_TestData()
-    {
-        foreach (Color color in new Color[] { Color.Empty, Color.Red })
-        {
-            yield return new object[] { null, color };
-            yield return new object[] { new Bitmap(10, 10), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "nature24bits.gif")), color };
-            yield return new object[] { Image.FromFile(Path.Combine("bitmaps", "10x16_one_entry_32bit.ico")), color };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageTransparentColor_Set_TestData))]
-    public void ToolStripSeparator_ImageTransparentColor_Set_GetReturnsExpected(Image image, Color value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            Image = image
-        };
-
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-
-        // Set same.
-        item.ImageTransparentColor = value;
-        Assert.Equal(value, item.ImageTransparentColor);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStripSeparator_RightToLeftAutoMirrorImage_Set_GetReturnsExpected(bool value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            RightToLeftAutoMirrorImage = value
-        };
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-
-        // Set same.
-        item.RightToLeftAutoMirrorImage = value;
-        Assert.Equal(value, item.RightToLeftAutoMirrorImage);
-
-        // Set different.
-        item.RightToLeftAutoMirrorImage = !value;
-        Assert.Equal(!value, item.RightToLeftAutoMirrorImage);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolStripSeparator_Text_Set_GetReturnsExpected(string value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            Text = value
-        };
-        Assert.Equal(value, item.Text);
-
-        // Set same.
-        item.Text = value;
-        Assert.Equal(value, item.Text);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var item = new ToolStripSeparator();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        item.TextChanged += handler;
-
-        // Set different.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        item.Text = string.Empty;
-        Assert.Empty(item.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        item.TextChanged -= handler;
-        item.Text = "value";
-        Assert.Equal("value", item.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ContentAlignment>]
-    public void ToolStripSeparator_TextAlign_Set_GetReturnsExpected(ContentAlignment value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, item.TextAlign);
-
-        // Set same.
-        item.TextAlign = value;
-        Assert.Equal(value, item.TextAlign);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ContentAlignment>]
-    [InlineData((ContentAlignment)int.MaxValue)]
-    [InlineData((ContentAlignment)int.MinValue)]
-    public void ToolStripSeparator_TextAlign_SetInvalid_ThrowsInvalidEnumArgumentException(ContentAlignment value)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextAlign = value);
-    }
-
-    public static IEnumerable<object[]> TextDirection_Set_TestData()
-    {
-        yield return new object[] { ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal };
-        yield return new object[] { ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90 };
-        yield return new object[] { ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextDirection_Set_TestData))]
-    public void ToolStripSeparator_TextDirection_Set_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected)
-    {
-        using var item = new ToolStripSeparator
-        {
-            TextDirection = value
-        };
-        Assert.Equal(expected, item.TextDirection);
-
-        // Set same.
-        item.TextDirection = value;
-        Assert.Equal(expected, item.TextDirection);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripTextDirection>]
-    public void ToolStripSeparator_TextDirection_SetInvalid_ThrowsInvalidEnumArgumentException(ToolStripTextDirection value)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextDirection = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TextImageRelation>]
-    public void ToolStripSeparator_TextImageRelation_Set_GetReturnsExpected(TextImageRelation value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            TextImageRelation = value
-        };
-        Assert.Equal(value, item.TextImageRelation);
-
-        // Set same.
-        item.TextImageRelation = value;
-        Assert.Equal(value, item.TextImageRelation);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TextImageRelation>]
-    [InlineData((TextImageRelation)3)]
-    [InlineData((TextImageRelation)5)]
-    [InlineData((TextImageRelation)6)]
-    [InlineData((TextImageRelation)7)]
-    public void ToolStripSeparator_TextImageRelation_SetInvalid_ThrowsInvalidEnumArgumentException(TextImageRelation value)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => item.TextImageRelation = value);
-    }
-
-    [WinFormsTheory]
-    [StringData]
-    public void ToolStripSeparator_ToolTipText_Set_GetReturnsExpected(string value)
-    {
-        using var item = new ToolStripSeparator
-        {
-            ToolTipText = value
-        };
-        Assert.Equal(value, item.ToolTipText);
-
-        // Set same.
-        item.ToolTipText = value;
-        Assert.Equal(value, item.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var item = new SubToolStripSeparator();
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.Separator, accessibleObject.Role);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var item = new SubToolStripSeparator
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        ToolStripItem.ToolStripItemAccessibleObject accessibleObject = Assert.IsAssignableFrom<ToolStripItem.ToolStripItemAccessibleObject>(item.CreateAccessibilityInstance());
-        Assert.Equal(AccessibleRole.HelpBalloon, accessibleObject.Role);
-        Assert.NotSame(accessibleObject, item.CreateAccessibilityInstance());
-        Assert.NotSame(accessibleObject, item.AccessibilityObject);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void ToolStripSeparator_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var item = new ToolStripSeparator();
-        Assert.Equal(new Size(6, 6), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(6, 6), item.GetPreferredSize(proposedSize));
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithOwner_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, Size.Empty, new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(-1, -2), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(10, 20), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(30, 40), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(int.MaxValue, int.MaxValue), new Size(6, 23) };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, Size.Empty, new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(-1, -2), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(10, 20), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(30, 40), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(6, 23) };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, Size.Empty, new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(-1, -2), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(10, 20), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(30, 40), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(6, 23) };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, Size.Empty, new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(-1, -2), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(10, 20), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(30, 40), new Size(6, 23) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(int.MaxValue, int.MaxValue), new Size(6, 23) };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, Size.Empty, new Size(23, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(-1, -2), new Size(23, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(10, 20), new Size(23, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(30, 40), new Size(23, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(23, 6) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithOwner_TestData))]
-    public void ToolStripSeparator_GetPreferredSize_InvokeWithOwner_ReturnsExpected(ToolStripLayoutStyle ownerLayoutStyle, Size proposedSize, Size expected)
-    {
-        using var owner = new ToolStrip
-        {
-            LayoutStyle = ownerLayoutStyle
-        };
-        using var item = new ToolStripSeparator
-        {
-            Owner = owner
-        };
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithToolStripDropDownMenuOwner_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { layoutStyle, Size.Empty };
-            yield return new object[] { layoutStyle, new Size(-1, -2) };
-            yield return new object[] { layoutStyle, new Size(10, 20) };
-            yield return new object[] { layoutStyle, new Size(30, 40) };
-            yield return new object[] { layoutStyle, new Size(int.MaxValue, int.MaxValue) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithToolStripDropDownMenuOwner_TestData))]
-    public void ToolStripSeparator_GetPreferredSize_InvokeWithToolStripDropDownMenuOwner_ReturnsExpected(ToolStripLayoutStyle ownerLayoutStyle, Size proposedSize)
-    {
-        using var owner = new ToolStripDropDownMenu
-        {
-            LayoutStyle = ownerLayoutStyle
-        };
-        using var item = new ToolStripSeparator
-        {
-            Owner = owner
-        };
-        Assert.Equal(new Size(52, 6), item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(new Size(52, 6), item.GetPreferredSize(proposedSize));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithOwner_TestData))]
-    public void ToolStripSeparator_GetPreferredSize_InvokeWithParent_ReturnsExpected(ToolStripLayoutStyle parentLayoutStyle, Size proposedSize, Size expected)
-    {
-        using var parent = new ToolStrip
-        {
-            LayoutStyle = parentLayoutStyle
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent
-        };
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithToolStripDropDownMenuParent_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, Size.Empty, new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(-1, -2), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(10, 20), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(30, 40), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, new Size(int.MaxValue, int.MaxValue), new Size(91, 6) };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, Size.Empty, new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(-1, -2), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(10, 20), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(30, 40), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(91, 6) };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, Size.Empty, new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(-1, -2), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(10, 20), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(30, 40), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(52, 6) };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, Size.Empty, new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(-1, -2), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(10, 20), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(30, 40), new Size(91, 6) };
-        yield return new object[] { ToolStripLayoutStyle.Table, new Size(int.MaxValue, int.MaxValue), new Size(91, 6) };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, Size.Empty, new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(-1, -2), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(10, 20), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(30, 40), new Size(52, 6) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, new Size(int.MaxValue, int.MaxValue), new Size(52, 6) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithToolStripDropDownMenuParent_TestData))]
-    public void ToolStripSeparator_GetPreferredSize_InvokeWithToolStripDropDownMenuParent_ReturnsExpected(ToolStripLayoutStyle ownerLayoutStyle, Size proposedSize, Size expected)
-    {
-        using var parent = new ToolStripDropDownMenu
-        {
-            LayoutStyle = ownerLayoutStyle
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent
-        };
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-
-        // Call again.
-        Assert.Equal(expected, item.GetPreferredSize(proposedSize));
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_TestData()
-    {
-        foreach (ToolStripItemDisplayStyle displayStyle in Enum.GetValues(typeof(ToolStripItemDisplayStyle)))
-        {
-            yield return new object[] { displayStyle, null };
-            yield return new object[] { displayStyle, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripSeparator_OnFontChanged_Invoke_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var item = new SubToolStripSeparator
-        {
-            DisplayStyle = displayStyle
-        };
-
-        item.OnFontChanged(eventArgs);
-
-        // Call again.
-        item.OnFontChanged(eventArgs);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripSeparator_OnFontChanged_InvokeWithOwner_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripSeparator_OnFontChanged_InvokeWithOwnerWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, owner.Handle);
-        int invalidatedCallCount = 0;
-        owner.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        owner.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        owner.HandleCreated += (sender, e) => createdCallCount++;
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.True(owner.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripSeparator_OnFontChanged_InvokeWithParent_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void ToolStripSeparator_OnFontChanged_InvokeWithParentWithHandle_Success(ToolStripItemDisplayStyle displayStyle, EventArgs eventArgs)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent,
-            DisplayStyle = displayStyle
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        parent.HandleCreated += (sender, e) => createdCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Call again.
-            item.OnFontChanged(eventArgs);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripSeparator_OnPaint_Invoke_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        using var item = new SubToolStripSeparator();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_WithOwner_TestData()
-    {
-        foreach (ToolStripLayoutStyle layoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { layoutStyle, null };
-
-            var image = new Bitmap(10, 10);
-            Graphics graphics = Graphics.FromImage(image);
-            yield return new object[] { layoutStyle, new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4)) };
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripSeparator_OnPaint_InvokeWithOwner_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int renderSeparatorCallCount = 0;
-        renderer.RenderSeparator += (sender, e) => renderSeparatorCallCount++;
-        using var owner = new ToolStrip
-        {
-            Renderer = renderer
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderSeparatorCallCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderSeparatorCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void ToolStripSeparator_OnPaint_InvokeWithParent_DoesNotCallPaint(PaintEventArgs eventArgs)
-    {
-        var renderer = new SubToolStripRenderer();
-        int renderSeparatorCallCount = 0;
-        renderer.RenderSeparator += (sender, e) => renderSeparatorCallCount++;
-        using var parent = new ToolStrip
-        {
-            Renderer = renderer
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderSeparatorCallCount);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(0, renderSeparatorCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaint_WithOwnerAndParent_TestData()
-    {
-        foreach (ToolStripLayoutStyle ownerLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            yield return new object[] { ownerLayoutStyle, ToolStripLayoutStyle.Flow, true };
-            yield return new object[] { ownerLayoutStyle, ToolStripLayoutStyle.HorizontalStackWithOverflow, true };
-            yield return new object[] { ownerLayoutStyle, ToolStripLayoutStyle.StackWithOverflow, true };
-            yield return new object[] { ownerLayoutStyle, ToolStripLayoutStyle.Table, true };
-            yield return new object[] { ownerLayoutStyle, ToolStripLayoutStyle.VerticalStackWithOverflow, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_WithOwnerAndParent_TestData))]
-    public void ToolStripSeparator_OnPaint_InvokeWithOwnerAndParent_DoesNotCallPaint(ToolStripLayoutStyle ownerLayoutStyle, ToolStripLayoutStyle parentLayoutStyle, bool expectedVertical)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        var renderer1 = new SubToolStripRenderer();
-        var renderer2 = new SubToolStripRenderer();
-        using var owner = new ToolStrip
-        {
-            LayoutStyle = ownerLayoutStyle,
-            Renderer = renderer1
-        };
-        using var parent = new ToolStrip
-        {
-            LayoutStyle = parentLayoutStyle,
-            Renderer = renderer2
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        int renderSeparatorCallCount1 = 0;
-        renderer1.RenderSeparator += (sender, e) =>
-        {
-            Assert.Same(renderer1, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Same(parent, e.ToolStrip);
-            Assert.Equal(expectedVertical, e.Vertical);
-            renderSeparatorCallCount1++;
-        };
-        int renderSeparatorCallCount2 = 0;
-        renderer2.RenderSeparator += (sender, e) => renderSeparatorCallCount2++;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, renderSeparatorCallCount1);
-        Assert.Equal(0, renderSeparatorCallCount2);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, renderSeparatorCallCount1);
-        Assert.Equal(0, renderSeparatorCallCount2);
-    }
-
-    public static IEnumerable<object[]> OnPaint_WithOwnerAndToolStripDropDownMenuParent_TestData()
-    {
-        foreach (ToolStripLayoutStyle ownerLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-        {
-            foreach (ToolStripLayoutStyle parentLayoutStyle in Enum.GetValues(typeof(ToolStripLayoutStyle)))
-            {
-                yield return new object[] { ownerLayoutStyle, parentLayoutStyle };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_WithOwnerAndToolStripDropDownMenuParent_TestData))]
-    public void ToolStripSeparator_OnPaint_InvokeWithOwnerAndToolStripDropDownMenuParent_DoesNotCallPaint(ToolStripLayoutStyle ownerLayoutStyle, ToolStripLayoutStyle parentLayoutStyle)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        var renderer1 = new SubToolStripRenderer();
-        var renderer2 = new SubToolStripRenderer();
-        using var owner = new ToolStrip
-        {
-            LayoutStyle = ownerLayoutStyle,
-            Renderer = renderer1
-        };
-        using var parent = new ToolStripDropDownMenu
-        {
-            LayoutStyle = parentLayoutStyle,
-            Renderer = renderer2
-        };
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        int renderSeparatorCallCount1 = 0;
-        renderer1.RenderSeparator += (sender, e) =>
-        {
-            Assert.Same(renderer1, sender);
-            Assert.Same(graphics, e.Graphics);
-            Assert.Same(item, e.Item);
-            Assert.Same(parent, e.ToolStrip);
-            Assert.False(e.Vertical);
-            renderSeparatorCallCount1++;
-        };
-        int renderSeparatorCallCount2 = 0;
-        renderer2.RenderSeparator += (sender, e) => renderSeparatorCallCount2++;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        item.Paint += handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(1, renderSeparatorCallCount1);
-        Assert.Equal(0, renderSeparatorCallCount2);
-
-        // Remove handler.
-        item.Paint -= handler;
-        item.OnPaint(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(2, renderSeparatorCallCount1);
-        Assert.Equal(0, renderSeparatorCallCount2);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSeparator_OnPaint_NullE_ThrowsNullReferenceException()
-    {
-        using var owner = new ToolStrip();
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner,
-            Parent = parent
-        };
-        Assert.Throws<NullReferenceException>(() => item.OnPaint(null));
-    }
-
-    public static IEnumerable<object[]> SetBounds_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 0, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(1, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 0, -1, -2), 0 };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), 0 };
-        yield return new object[] { new Rectangle(0, 0, 1, 2), 0 };
-        yield return new object[] { new Rectangle(0, 0, 5, 6), 0 };
-        yield return new object[] { new Rectangle(0, 0, 6, 5), 0 };
-        yield return new object[] { new Rectangle(0, 0, 6, 6), 0 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_TestData))]
-    public void ToolStripSeparator_SetBounds_Invoke_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var item = new SubToolStripSeparator();
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        item.SetBounds(bounds);
-        Assert.Equal(bounds, item.Bounds);
-        Assert.Equal(bounds.Size, item.Size);
-        Assert.Equal(bounds.Width, item.Width);
-        Assert.Equal(bounds.Height, item.Height);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-
-        // Set same.
-        item.SetBounds(bounds);
-        Assert.Equal(bounds, item.Bounds);
-        Assert.Equal(bounds.Size, item.Size);
-        Assert.Equal(bounds.Width, item.Width);
-        Assert.Equal(bounds.Height, item.Height);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_TestData))]
-    public void ToolStripSeparator_SetBounds_InvokeWithOwner_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var owner = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_ToolStripDropDownMenuOwner_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 0, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(1, 2, 23, 23), 1 };
-        yield return new object[] { new Rectangle(0, 0, -1, -2), 1 };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), 1 };
-        yield return new object[] { new Rectangle(0, 0, 1, 2), 1 };
-        yield return new object[] { new Rectangle(0, 0, 5, 6), 1 };
-        yield return new object[] { new Rectangle(0, 0, 6, 5), 1 };
-        yield return new object[] { new Rectangle(0, 0, 6, 6), 1 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1 };
-        yield return new object[] { new Rectangle(2, 0, 3, 4), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_ToolStripDropDownMenuOwner_TestData))]
-    public void ToolStripSeparator_SetBounds_InvokeWithToolStripDropDownMenuOwner_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount)
-    {
-        using var owner = new ToolStripDropDownMenu();
-        using var item = new SubToolStripSeparator
-        {
-            Owner = owner
-        };
-        int ownerLayoutCallCount = 0;
-        void ownerHandler(object sender, LayoutEventArgs e) => ownerLayoutCallCount++;
-        owner.Layout += ownerHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(new Rectangle(2, bounds.Y, 57, bounds.Height), item.Bounds);
-            Assert.Equal(new Size(57, bounds.Height), item.Size);
-            Assert.Equal(57, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(new Rectangle(2, bounds.Y, 57, bounds.Height), item.Bounds);
-            Assert.Equal(new Size(57, bounds.Height), item.Size);
-            Assert.Equal(57, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, ownerLayoutCallCount);
-            Assert.False(owner.IsHandleCreated);
-        }
-        finally
-        {
-            owner.Layout -= ownerHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> SetBounds_WithParent_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 0, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(0, 2, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(1, 2, 23, 23), 1, 1 };
-        yield return new object[] { new Rectangle(0, 0, -1, -2), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 1, 2), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 5, 6), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 6, 5), 0, 1 };
-        yield return new object[] { new Rectangle(0, 0, 6, 6), 0, 0 };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), 1, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_WithParent_TestData))]
-    public void ToolStripSeparator_SetBounds_InvokeWithParent_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStrip();
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBounds_WithParent_TestData))]
-    public void ToolStripSeparator_SetBounds_InvokeWithDropDownMenuParent_GetReturnsExpected(Rectangle bounds, int expectedLocationChangedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new ToolStripDropDownMenu();
-        using var item = new SubToolStripSeparator
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(item, e.AffectedComponent);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            item.SetBounds(bounds);
-            Assert.Equal(bounds, item.Bounds);
-            Assert.Equal(bounds.Size, item.Size);
-            Assert.Equal(bounds.Width, item.Width);
-            Assert.Equal(bounds.Height, item.Height);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    private class SubToolStripSeparator : ToolStripSeparator
-    {
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool DefaultAutoToolTip => base.DefaultAutoToolTip;
-
-        public new ToolStripItemDisplayStyle DefaultDisplayStyle => base.DefaultDisplayStyle;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DismissWhenClicked => base.DismissWhenClicked;
-
-        public new EventHandlerList Events => base.Events;
-
-        public new ToolStrip Parent
-        {
-            get => base.Parent;
-            set => base.Parent = value;
-        }
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void SetBounds(Rectangle bounds) => base.SetBounds(bounds);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSettingsManagerTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSettingsManagerTests.cs
deleted file mode 100644
index 9d840736c68..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSettingsManagerTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSettingsManagerTests : IClassFixture<UserConfigDisposableFixture>
-{
-    [WinFormsFact]
-    public void ToolStripSettingsManager_Save_Load_RoundTripExpected()
-    {
-        using var mainForm = new Form();
-
-        using var toolStrip = new ToolStrip();
-        toolStrip.Name = "Child";
-        toolStrip.Size = new Drawing.Size(10, 10);
-        toolStrip.Visible = false;
-        mainForm.Controls.Add(toolStrip);
-
-        var toolStripSettingsManager = new ToolStripSettingsManager(mainForm, "MainForm");
-
-        toolStripSettingsManager.Save();
-
-        toolStrip.Size = new Drawing.Size(5, 5);
-        toolStrip.Visible = true;
-
-        toolStripSettingsManager.Load();
-
-        Assert.Equal(new Drawing.Size(10, 10), toolStrip.Size);
-        Assert.False(toolStrip.Visible);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonAccessibleObjectTests.cs
deleted file mode 100644
index 10d0752ea01..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripSplitButton;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSplitButton_ToolStripSplitButtonAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripSplitButtonAccessibleObject_Ctor_Default()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new ToolStripSplitButton();
-        ToolStripSplitButtonAccessibleObject accessibleObject = new ToolStripSplitButtonAccessibleObject(toolStripSplitButton);
-
-        Assert.Equal(toolStripSplitButton, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonAccessibleObject_ControlType_IsButton_IfAccessibleRoleIsDefault()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new ToolStripSplitButton();
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripSplitButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonAccessibleObject_Role_IsMenuItem_ByDefault()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new ToolStripSplitButton();
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripSplitButton.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.MenuItem, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripSplitButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripSplitButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripSplitButtonAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripSplitButton toolStripSplitButton = new ToolStripSplitButton();
-        toolStripSplitButton.AccessibleRole = role;
-
-        object actual = toolStripSplitButton.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonExAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonExAccessibleObjectTests.cs
deleted file mode 100644
index f4e04dd817b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonExAccessibleObjectTests.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripSplitButton;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSplitButton_ToolStripSplitButtonExAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_Ctor_OwnerToolStripSplitButtonCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripSplitButtonExAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_ControlType_ReturnsExpected()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_DropDownItemsCount_ReturnsExpected_IfDropDownCollapsed()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.Equal(UiaCore.ExpandCollapseState.Collapsed, accessibleObject.ExpandCollapseState);
-        Assert.Equal(0, accessibleObject.TestAccessor().Dynamic.DropDownItemsCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        using ToolStrip toolStrip = new();
-        toolStrip.Items.Add(toolStripSplitButton);
-        toolStrip.PerformLayout();
-        toolStrip.CreateControl();
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-        AccessibleObject expected = toolStrip.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Parent_ReturnsNull_IfHandleNotCreated()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        using ToolStrip toolStrip = new();
-        toolStrip.Items.Add(toolStripSplitButton);
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Child_ReturnsExpected()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripItem item1 = toolStripSplitButton.DropDownItems.Add(string.Empty);
-        ToolStripItem item2 = toolStripSplitButton.DropDownItems.Add(string.Empty);
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        toolStripSplitButton.DropDown.Show();
-
-        Assert.Equal(item1.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(item2.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfDropDownNotOpened()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        toolStripSplitButton.DropDownItems.Add(string.Empty);
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Child_ReturnsNull_IfNoDropDownItems()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonExAccessibleObject_FragmentNavigate_Child_ReturnsExpected_IfItemsAligned()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripItem item1 = toolStripSplitButton.DropDownItems.Add(string.Empty);
-        ToolStripItem item2 = toolStripSplitButton.DropDownItems.Add(string.Empty);
-
-        item1.Alignment = ToolStripItemAlignment.Right;
-
-        ToolStripSplitButtonExAccessibleObject accessibleObject = new(toolStripSplitButton);
-
-        toolStripSplitButton.DropDown.Show();
-
-        Assert.Equal(item1.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(item2.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonUiaProviderTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonUiaProviderTests.cs
deleted file mode 100644
index 3678130d0a6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButton.ToolStripSplitButtonUiaProviderTests.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripSplitButton;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSplitButton_ToolStripSplitButtonUiaProviderTests
-{
-    [WinFormsFact]
-    public void ToolStripSplitButtonUiaProvider_Ctor_OwnerToolStripSplitButtonCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ToolStripSplitButtonUiaProvider(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButtonUiaProvider_IsIAccessibleExSupported_ReturnsExpected()
-    {
-        using ToolStripSplitButton toolStripSplitButton = new();
-
-        ToolStripSplitButtonUiaProvider accessibleObject = new(toolStripSplitButton);
-
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButtonTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButtonTests.cs
deleted file mode 100644
index 731e1dd5ce8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripSplitButtonTests.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripSplitButtonTests
-{
-    public static IEnumerable<object[]> ToolStripItem_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new SubToolStripItem() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripItem_Set_TestData))]
-    public void ToolStripSplitButton_DefaultItem_Set_GetReturnsExpected(ToolStripItem value)
-    {
-        using var button = new ToolStripSplitButton
-        {
-            DefaultItem = value
-        };
-        Assert.Same(value, button.DefaultItem);
-
-        // Set same.
-        button.DefaultItem = value;
-        Assert.Same(value, button.DefaultItem);
-    }
-
-    [WinFormsFact]
-    public void ToolStripSplitButton_DefaultItem_SetWithHandler_CallsOnDefaultItemChanged()
-    {
-        using var button = new ToolStripSplitButton();
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(button, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        button.DefaultItemChanged += handler;
-
-        // Set non-null.
-        using var item1 = new SubToolStripItem();
-        button.DefaultItem = item1;
-        Assert.Same(item1, button.DefaultItem);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        button.DefaultItem = item1;
-        Assert.Same(item1, button.DefaultItem);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var item2 = new SubToolStripItem();
-        button.DefaultItem = item2;
-        Assert.Same(item2, button.DefaultItem);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        button.DefaultItem = null;
-        Assert.Null(button.DefaultItem);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        button.DefaultItemChanged -= handler;
-        button.DefaultItem = item1;
-        Assert.Equal(item1, button.DefaultItem);
-        Assert.Equal(3, callCount);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-        public SubToolStripItem() : base()
-        {
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripStatusLabel.ToolStripStatusLabelAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripStatusLabel.ToolStripStatusLabelAccessibleObjectTests.cs
deleted file mode 100644
index e6d95ba4b8c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripStatusLabel.ToolStripStatusLabelAccessibleObjectTests.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.ToolStripStatusLabel;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripStatusLabel_ToolStripStatusLabelAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripStatusLabelAccessibleObject_Ctor_Default()
-    {
-        using ToolStripStatusLabel toolStripStatusLabel = new ToolStripStatusLabel();
-        ToolStripStatusLabelAccessibleObject accessibleObject = new ToolStripStatusLabelAccessibleObject(toolStripStatusLabel);
-
-        Assert.Equal(toolStripStatusLabel, accessibleObject.Owner);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.UIA.HyperlinkControlTypeId)]
-    [InlineData(false, (int)UiaCore.UIA.TextControlTypeId)]
-    public void ToolStripStatusLabelAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool isLink, int expectedType)
-    {
-        using ToolStripStatusLabel toolStripStatusLabel = new ToolStripStatusLabel();
-        toolStripStatusLabel.IsLink = isLink;
-        // AccessibleRole is not set = Default
-
-        object actual = toolStripStatusLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Link)]
-    [InlineData(false, AccessibleRole.StaticText)]
-    public void ToolStripStatusLabelAccessibleObject_Role_IsExpected_ByDefault(bool isLink, AccessibleRole expectedRole)
-    {
-        using ToolStripStatusLabel toolStripStatusLabel = new ToolStripStatusLabel();
-        toolStripStatusLabel.IsLink = isLink;
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = toolStripStatusLabel.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-    }
-
-    public static IEnumerable<object[]> ToolStripStatusLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripStatusLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripStatusLabelAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripStatusLabel toolStripStatusLabel = new ToolStripStatusLabel();
-        toolStripStatusLabel.AccessibleRole = role;
-
-        object actual = toolStripStatusLabel.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.Rendering.cs
deleted file mode 100644
index f14d2ad51c4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.Rendering.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ToolStripTests
-{
-    [WinFormsFact]
-    public void ToolStrip_RendersBackgroundCorrectly()
-    {
-        using Form form = new Form();
-        using ToolStrip toolStrip = new ToolStrip
-        {
-            BackColor = Color.Blue,
-            Size = new Size(200, 38)
-        };
-        form.Controls.Add(toolStrip);
-
-        // Force the handle creation
-        Assert.NotEqual(IntPtr.Zero, form.Handle);
-        Assert.NotEqual(IntPtr.Zero, toolStrip.Handle);
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        Rectangle bounds = toolStrip.Bounds;
-        using var e = new PaintEventArgs(emf, bounds);
-        toolStrip.TestAccessor().Dynamic.OnPaintBackground(e);
-
-        Rectangle bitBltBounds = new Rectangle(bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1);
-
-        RECT[] expectedRects = new RECT[]
-        {
-            new RECT(0, 0, 1, 1),
-            new RECT(bounds.Width - 3, 0, bounds.Width, 1),
-            new RECT(bounds.Width - 1, 1, bounds.Width, 3),
-            new RECT(0, bounds.Height - 2, 1, bounds.Height - 1),
-            new RECT(bounds.Width - 1, bounds.Height - 2, bounds.Width, bounds.Height - 1),
-            new RECT(0, bounds.Height - 1, 2, bounds.Height),
-            new RECT(bounds.Width - 2, bounds.Height - 1, bounds.Width, bounds.Height)
-        };
-
-        emf.Validate(
-            state,
-            Validate.BitBltValidator(
-                bitBltBounds,
-                State.BrushColor(Color.Blue)),
-            Validate.BitBltValidator(
-                bitBltBounds,
-                State.BrushColor(form.BackColor),
-                State.Clipping(expectedRects)));
-
-        var details = emf.RecordsToString();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.cs
deleted file mode 100644
index b98cb598e75..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTests.cs
+++ /dev/null
@@ -1,7505 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Drawing.Imaging;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-using Windows.Win32.System.Ole;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ToolStripTests
-{
-    [WinFormsFact]
-    public void ToolStrip_Ctor_Default()
-    {
-        using var control = new SubToolStrip();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.AllowMerge);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(25, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanOverflow);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.False(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.ClientRectangle);
-        Assert.Equal(new Size(100, 25), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(DockStyle.Top, control.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.BelowRight, control.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(new Padding(0, 0, 1, 0), control.DefaultPadding);
-        Assert.Equal(new Size(100, 25), control.DefaultSize);
-        Assert.True(control.DefaultShowItemToolTips);
-        Assert.False(control.DesignMode);
-        Assert.Single(control.DisplayedItems);
-        Assert.Same(control.DisplayedItems, control.DisplayedItems);
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(new Rectangle(9, 0, 90, 25), control.DisplayRectangle);
-            Assert.Equal(new Size(90, 25), control.MaxItemSize);
-        }
-        else
-        {
-            Assert.Equal(new Rectangle(7, 0, 92, 25), control.DisplayRectangle);
-            Assert.Equal(new Size(92, 25), control.MaxItemSize);
-        }
-
-        Assert.Equal(DockStyle.Top, 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(1, control.DockPadding.Right);
-        Assert.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Visible, control.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Vertical, control.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.GripMargin);
-        Assert.Equal(2, control.GripRectangle.X);
-        Assert.Equal(0, control.GripRectangle.Y);
-        Assert.True(control.GripRectangle.Width > 0);
-        Assert.Equal(25, control.GripRectangle.Height);
-        Assert.False(control.HasChildren);
-        Assert.Equal(25, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Null(control.ImageList);
-        Assert.Equal(new Size(16, 16), control.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsDropDown);
-        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.Null(control.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.HorizontalStackWithOverflow, control.LayoutStyle);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.NotNull(control.OverflowButton);
-        Assert.Same(control.OverflowButton, control.OverflowButton);
-        Assert.Same(control, control.OverflowButton.GetCurrentParent());
-        Assert.Equal(new Padding(0, 0, 1, 0), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 25), control.Size);
-        Assert.False(control.Stretch);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, control.TextDirection);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.True(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(100, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Ctor_ToolStripItemArray_TestData()
-    {
-        yield return new object[] { Array.Empty<ToolStripItem>() };
-        yield return new object[] { new ToolStripItem[] { new SubToolStripItem() } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_ToolStripItemArray_TestData))]
-    public void ToolStrip_Ctor_ToolStripItemArray(ToolStripItem[] items)
-    {
-        using var control = new SubToolStrip(items);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.AllowMerge);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(25, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.False(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CanOverflow);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 100, 25), control.ClientRectangle);
-        Assert.Equal(new Size(100, 25), control.ClientSize);
-        Assert.False(control.Created);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(DockStyle.Top, control.DefaultDock);
-        Assert.Equal(ToolStripDropDownDirection.BelowRight, control.DefaultDropDownDirection);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(new Padding(0, 0, 1, 0), control.DefaultPadding);
-        Assert.Equal(new Size(100, 25), control.DefaultSize);
-        Assert.True(control.DefaultShowItemToolTips);
-        Assert.False(control.DesignMode);
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(new Rectangle(9, 0, 90, 25), control.DisplayRectangle);
-            Assert.Equal(new Size(90, 25), control.MaxItemSize);
-        }
-        else
-        {
-            Assert.Equal(new Rectangle(7, 0, 92, 25), control.DisplayRectangle);
-            Assert.Equal(new Size(92, 25), control.MaxItemSize);
-        }
-
-        Assert.Equal(DockStyle.Top, 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(1, control.DockPadding.Right);
-        Assert.True(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(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(ToolStripGripStyle.Visible, control.GripStyle);
-        Assert.Equal(ToolStripGripDisplayStyle.Vertical, control.GripDisplayStyle);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.GripMargin);
-        Assert.Equal(2, control.GripRectangle.X);
-        Assert.Equal(0, control.GripRectangle.Y);
-        Assert.True(control.GripRectangle.Width > 0);
-        Assert.Equal(25, control.GripRectangle.Height);
-        Assert.False(control.HasChildren);
-        Assert.Equal(25, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Null(control.ImageList);
-        Assert.Equal(new Size(16, 16), control.ImageScalingSize);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsDropDown);
-        Assert.False(control.IsMirrored);
-        Assert.NotSame(items, control.Items);
-        Assert.Same(control.Items, control.Items);
-        Assert.Equal(items, control.Items.Cast<ToolStripItem>());
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Null(control.LayoutSettings);
-        Assert.Equal(ToolStripLayoutStyle.HorizontalStackWithOverflow, control.LayoutStyle);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.NotNull(control.OverflowButton);
-        Assert.Same(control.OverflowButton, control.OverflowButton);
-        Assert.Same(control, control.OverflowButton.GetCurrentParent());
-        Assert.Equal(new Padding(0, 0, 1, 0), control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowItemToolTips);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 25), control.Size);
-        Assert.False(control.Stretch);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(ToolStripTextDirection.Horizontal, control.TextDirection);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.True(control.Visible);
-        Assert.False(control.VScroll);
-        Assert.Equal(100, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Ctor_NullItems_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("toolStripItems", () => new ToolStrip(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Ctor_NullValueInItems_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("value", () => new ToolStrip(new ToolStripItem[] { null }));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(25, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000000, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            AllowDrop = value
-        };
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ToolStrip_AllowDrop_SetWithChildren_GetReturnsExpected(bool childAllowDrop, bool value)
-    {
-        using var control = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            AllowDrop = childAllowDrop
-        };
-        control.Items.Add(item);
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowDrop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowDrop_SetWithHandleAlreadyRegistered_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        DropTargetMock dropTarget = new();
-        Assert.Equal(ApartmentState.STA, Application.OleRequired());
-        Assert.Equal(HRESULT.S_OK, PInvoke.RegisterDragDrop(control, dropTarget));
-
-        try
-        {
-            control.AllowDrop = value;
-            Assert.Equal(value, control.AllowDrop);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.AllowDrop = value;
-            Assert.Equal(value, control.AllowDrop);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set different.
-            control.AllowDrop = value;
-            Assert.Equal(value, control.AllowDrop);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            PInvoke.RevokeDragDrop((HWND)control.Handle);
-        }
-    }
-
-    [Fact] // x-thread
-    public void ToolStrip_AllowDrop_SetWithHandleNonSTAThread_ThrowsInvalidOperationException()
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<InvalidOperationException>(() => control.AllowDrop = true);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Can set to false.
-        control.AllowDrop = false;
-        Assert.False(control.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void ToolStrip_AllowDrop_SetWithChildrenWithHandle_GetReturnsExpected(bool childAllowDrop, bool value)
-    {
-        using var control = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            AllowDrop = childAllowDrop
-        };
-        control.Items.Add(item);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowDrop = value;
-        Assert.Equal(value, control.AllowDrop);
-        Assert.Equal(childAllowDrop, item.AllowDrop);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_AllowDrop_SetAllowItemReorder_ThrowsArgumentException()
-    {
-        using var control = new ToolStrip
-        {
-            AllowItemReorder = true
-        };
-        Assert.Throws<ArgumentException>(() => control.AllowDrop = true);
-        Assert.False(control.AllowDrop);
-
-        control.AllowDrop = false;
-        Assert.False(control.AllowDrop);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowItemReorder_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            AllowItemReorder = value
-        };
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [Fact] // x-thread
-    public void ToolStrip_AllowItemReorder_SetWithHandleNonSTAThread_ThrowsInvalidOperationException()
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Throws<InvalidOperationException>(() => control.AllowItemReorder = true);
-        Assert.True(control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Can set to false.
-        control.AllowItemReorder = false;
-        Assert.False(control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowItemReorder_SetWithHandleSTA_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowItemReorder = value;
-        Assert.Equal(value, control.AllowItemReorder);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_AllowItemReorder_SetAllowDrop_ThrowsArgumentException()
-    {
-        using var control = new ToolStrip
-        {
-            AllowDrop = true
-        };
-        Assert.Throws<ArgumentException>(() => control.AllowItemReorder = true);
-        Assert.False(control.AllowItemReorder);
-
-        control.AllowItemReorder = false;
-        Assert.False(control.AllowItemReorder);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowMerge_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            AllowMerge = value
-        };
-        Assert.Equal(value, control.AllowMerge);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowMerge = value;
-        Assert.Equal(value, control.AllowMerge);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowMerge = value;
-        Assert.Equal(value, control.AllowMerge);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AllowMerge_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AllowMerge = value;
-        Assert.Equal(value, control.AllowMerge);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AllowMerge = value;
-        Assert.Equal(value, control.AllowMerge);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AllowMerge = value;
-        Assert.Equal(value, control.AllowMerge);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Anchor_Set_TestData()
-    {
-        yield return new object[] { AnchorStyles.Top, AnchorStyles.Top, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom, AnchorStyles.Top | AnchorStyles.Bottom, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left, AnchorStyles.Top | AnchorStyles.Left, DockStyle.Top };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Bottom, AnchorStyles.Bottom, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left, AnchorStyles.Bottom | AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Left, AnchorStyles.Left, DockStyle.None };
-        yield return new object[] { AnchorStyles.Left | AnchorStyles.Right, AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.Right, AnchorStyles.Right, DockStyle.None };
-
-        yield return new object[] { AnchorStyles.None, AnchorStyles.None, DockStyle.None };
-        yield return new object[] { (AnchorStyles)(-1), AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-        yield return new object[] { (AnchorStyles)int.MaxValue, AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right, DockStyle.None };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Anchor_Set_TestData))]
-    public void ToolStrip_Anchor_Set_GetReturnsExpected(AnchorStyles value, AnchorStyles expected, DockStyle expectedDock)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Anchor", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Anchor = value;
-        Assert.Equal(expected, control.Anchor);
-        Assert.Equal(expectedDock, control.Dock);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AutoScroll_Set_ThrowsNotSupportedException(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<NotSupportedException>(() => control.AutoScroll = value);
-        Assert.False(control.AutoScroll);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMargin_Set_TestData()
-    {
-        yield return new object[] { new Size(0, 0), 0 };
-        yield return new object[] { new Size(1, 0), 0 };
-        yield return new object[] { new Size(0, 1), 0 };
-        yield return new object[] { new Size(1, 2), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void ToolStrip_AutoScrollMargin_Set_GetReturnsExpected(Size value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_AutoScrollMinSize_Set_ThrowsNotSupportedException()
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        Assert.Throws<NotSupportedException>(() => control.AutoScrollMinSize = new Size(1, 2));
-        Assert.Equal(new Size(1, 2), control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMinSize = new Size(1, 2);
-        Assert.Equal(new Size(1, 2), control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetPointTheoryData))]
-    public void ToolStrip_AutoScrollPosition_Set_GetReturnsExpected(Point value)
-    {
-        using var control = new ToolStrip
-        {
-            AutoScrollPosition = value
-        };
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollPosition = value;
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0, 2, 2)]
-    [InlineData(false, 2, 2, 3)]
-    public void ToolStrip_AutoSize_SetWithParent_GetReturnsExpected(bool value, int expectedLayoutCallCount1, int expectedLayoutCallCount2, int expectedLayoutCallCount3)
-    {
-        using var parent = new Control();
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            if (e.AffectedProperty != "AutoSize")
-            {
-                Assert.Equal("Bounds", e.AffectedProperty);
-            }
-
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount1, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(expectedLayoutCallCount2, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount3, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ToolStrip_AutoSize_SetWithToolStripPanelParent_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var parent = new ToolStripPanel();
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new ToolStrip
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, Control.DefaultBackColor };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void ToolStrip_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ToolStrip
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_BindingContext_GetWithParent_ReturnsExpected()
-    {
-        var bindingContext = new BindingContext();
-        using var parent = new Control
-        {
-            BindingContext = bindingContext
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.Same(bindingContext, control.BindingContext);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_BindingContext_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        var bindingContext = new BindingContext();
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            BindingContext = bindingContext
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.Null(control.BindingContext);
-    }
-
-    public static IEnumerable<object[]> BindingContext_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new BindingContext() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void ToolStrip_BindingContext_Set_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new ToolStrip
-        {
-            BindingContext = value
-        };
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BindingContext_Set_TestData))]
-    public void ToolStrip_BindingContext_SetWithNonNullBindingContext_GetReturnsExpected(BindingContext value)
-    {
-        using var control = new ToolStrip
-        {
-            BindingContext = new BindingContext()
-        };
-
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BindingContext = value;
-        Assert.Same(value, control.BindingContext);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_BindingContext_SetWithHandler_CallsBindingContextChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BindingContextChanged += handler;
-
-        // Set different.
-        var context1 = new BindingContext();
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var context2 = new BindingContext();
-        control.BindingContext = context2;
-        Assert.Same(context2, control.BindingContext);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BindingContext = null;
-        Assert.Null(control.BindingContext);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BindingContextChanged -= handler;
-        control.BindingContext = context1;
-        Assert.Same(context1, control.BindingContext);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_CanOverflow_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void ToolStrip_CanOverflow_SetWithHandle_GetReturnsExpected(bool value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.CanOverflow = value;
-        Assert.Equal(value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.CanOverflow = !value;
-        Assert.Equal(!value, control.CanOverflow);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_CausesValidation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            CausesValidation = value
-        };
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        control.CausesValidation = value;
-        Assert.Equal(value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        control.CausesValidation = !value;
-        Assert.Equal(!value, control.CausesValidation);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CausesValidation_SetWithHandler_CallsCausesValidationChanged()
-    {
-        using var control = new ToolStrip
-        {
-            CausesValidation = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CausesValidationChanged += handler;
-
-        // Set different.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.CausesValidation = true;
-        Assert.True(control.CausesValidation);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.CausesValidationChanged -= handler;
-        control.CausesValidation = false;
-        Assert.False(control.CausesValidation);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetCursorTheoryData))]
-    public void ToolStrip_Cursor_Set_GetReturnsExpected(Cursor value)
-    {
-        using var control = new ToolStrip
-        {
-            Cursor = value
-        };
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Cursor = value;
-        Assert.Same(value ?? Cursors.Default, control.Cursor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Cursor_SetWithHandler_CallsCursorChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.CursorChanged += handler;
-
-        // Set different.
-        using var cursor1 = new Cursor((IntPtr)1);
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var cursor2 = new Cursor((IntPtr)2);
-        control.Cursor = cursor2;
-        Assert.Same(cursor2, control.Cursor);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Cursor = null;
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.CursorChanged -= handler;
-        control.Cursor = cursor1;
-        Assert.Same(cursor1, control.Cursor);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_Get_ReturnsSame()
-    {
-        using var control = new ToolStrip();
-        Assert.NotSame(Control.DefaultFont, control.Font);
-        Assert.Same(control.Font, control.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_GetWithParent_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new Control
-        {
-            Font = font1
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.NotSame(font1, control.Font);
-        Assert.Same(control.Font, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_GetWithParentCantAccessProperties_ReturnsExpected()
-    {
-        using var font1 = new Font("Arial", 8.25f);
-        using var font2 = new Font("Arial", 8.5f);
-        using var parent = new SubAxHost("00000000-0000-0000-0000-000000000000")
-        {
-            Font = font1
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent
-        };
-        Assert.NotSame(Control.DefaultFont, control.Font);
-        Assert.Same(control.Font, control.Font);
-
-        // Set custom.
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void ToolStrip_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubToolStrip
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_SetWithItemsWithHandler_CallsFontChanged()
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new ToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(font2, item1.Font);
-        Assert.Same(font2, item2.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(Control.DefaultFont, item1.Font);
-        Assert.Equal(Control.DefaultFont, item2.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(font1, item1.Font);
-        Assert.Same(font1, item2.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Font_SetWithItemsWithFontWithHandler_CallsFontChanged()
-    {
-        using var childFont1 = new Font("Arial", 1);
-        using var childFont2 = new Font("Arial", 1);
-        using var child1 = new SubToolStripItem
-        {
-            Font = childFont1
-        };
-        using var child2 = new SubToolStripItem
-        {
-            Font = childFont2
-        };
-        using var control = new ToolStrip();
-        control.Items.Add(child1);
-        control.Items.Add(child2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Same(childFont1, child1.Font);
-        Assert.Same(childFont2, child2.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_Get_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Get_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_Get_ReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Get_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_GetDesignMode_ReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var control = new ToolStrip
-        {
-            Site = mockSite.Object,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_GetWithParent_TestData()
-    {
-        foreach (DockStyle parentDock in new object[] { DockStyle.None, DockStyle.Left, DockStyle.Right, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Flow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.Table, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { parentDock, ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetWithParent_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_GetWithParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        using var parent = new Control
-        {
-            Dock = parentDock
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetWithParent_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_GetDesignModeWithParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var parent = new Control
-        {
-            Dock = parentDock
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent,
-            Site = mockSite.Object,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_GetWithToolStripPanelParent_TestData()
-    {
-        foreach (DockStyle childDock in new object[] { DockStyle.None, DockStyle.Left, DockStyle.Right, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetWithToolStripPanelParent_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_GetWithToolStripPanelParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        using var parent = new ToolStripPanel
-        {
-            Dock = parentDock
-        };
-        using var control = new ToolStrip
-        {
-            Parent = parent,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_GetDesignModeWithToolStripPanelParent_TestData()
-    {
-        foreach (DockStyle childDock in new object[] { DockStyle.None, DockStyle.Left, DockStyle.Right, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.BelowLeft };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.BelowRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.Yes, ToolStripDropDownDirection.AboveLeft };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.No, ToolStripDropDownDirection.AboveRight };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.AboveRight };
-
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Left };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Yes, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.No, ToolStripDropDownDirection.Right };
-            yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, childDock, RightToLeft.Inherit, ToolStripDropDownDirection.Right };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_GetDesignModeWithToolStripPanelParent_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_GetDesignModeWithToolStripPanelParent_ReturnsExpected(DockStyle parentDock, ToolStripLayoutStyle layoutStyle, DockStyle dock, RightToLeft rightToLeft, ToolStripDropDownDirection expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Default);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns("Name");
-        using var parent = new ToolStripPanel
-        {
-            Site = mockSite.Object,
-            Dock = parentDock
-        };
-        using var control = new SubToolStrip
-        {
-            Parent = parent,
-            Site = mockSite.Object,
-            LayoutStyle = layoutStyle,
-            Dock = dock,
-            RightToLeft = rightToLeft
-        };
-        Assert.True(control.DesignMode);
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-    }
-
-    public static IEnumerable<object[]> DefaultDropDownDirection_Set_TestData()
-    {
-        yield return new object[] { ToolStripDropDownDirection.AboveLeft, ToolStripDropDownDirection.AboveLeft };
-        yield return new object[] { ToolStripDropDownDirection.AboveRight, ToolStripDropDownDirection.AboveRight };
-        yield return new object[] { ToolStripDropDownDirection.BelowLeft, ToolStripDropDownDirection.BelowLeft };
-        yield return new object[] { ToolStripDropDownDirection.BelowRight, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripDropDownDirection.Default, ToolStripDropDownDirection.BelowRight };
-        yield return new object[] { ToolStripDropDownDirection.Left, ToolStripDropDownDirection.Left };
-        yield return new object[] { ToolStripDropDownDirection.Right, ToolStripDropDownDirection.Right };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Set_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_Set_GetReturnsExpected(ToolStripDropDownDirection value, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStrip
-        {
-            DefaultDropDownDirection = value
-        };
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DefaultDropDownDirection_Set_TestData))]
-    public void ToolStrip_DefaultDropDownDirection_SetWithHandle_GetReturnsExpected(ToolStripDropDownDirection value, ToolStripDropDownDirection expected)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DefaultDropDownDirection = value;
-        Assert.Equal(expected, control.DefaultDropDownDirection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_DefaultDropDownDirection_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.DefaultDropDownDirection)];
-        using var control = new ToolStrip();
-        Assert.False(property.CanResetValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Right;
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_DefaultDropDownDirection_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.DefaultDropDownDirection)];
-        using var control = new ToolStrip();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Right;
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripDropDownDirection.Right, control.DefaultDropDownDirection);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.DefaultDropDownDirection = ToolStripDropDownDirection.Default;
-        Assert.Equal(ToolStripDropDownDirection.BelowRight, control.DefaultDropDownDirection);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripDropDownDirection>]
-    public void ToolStrip_DefaultDropDownDirection_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripDropDownDirection value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.DefaultDropDownDirection = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_DefaultGripMargin_Get_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_DefaultGripMargin_GetWithGrip_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        Assert.Equal(new Padding(2, 2, 2, 2), control.GripMargin);
-        Assert.Equal(new Padding(2, 2, 2, 2), control.DefaultGripMargin);
-    }
-
-    public static IEnumerable<object[]> DisplayRectangle_TestData()
-    {
-        int x = Application.UseVisualStyles ? 9 : 7;
-        int width = Application.UseVisualStyles ? 90 : 92;
-        int height = Application.UseVisualStyles ? 16 : 18;
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Visible, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Visible, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Visible, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Hidden, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Hidden, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Flow, ToolStripGripStyle.Hidden, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Yes, new Rectangle(0, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.No, new Rectangle(x, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Inherit, new Rectangle(x, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Yes, new Rectangle(0, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.No, new Rectangle(x, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Inherit, new Rectangle(x, 0, width, 25) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Visible, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Visible, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Visible, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Hidden, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Hidden, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.Table, ToolStripGripStyle.Hidden, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Yes, new Rectangle(0, x, 99, height) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.No, new Rectangle(0, x, 99, height) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Visible, RightToLeft.Inherit, new Rectangle(0, x, 99, height) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Yes, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.No, new Rectangle(0, 0, 99, 25) };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripGripStyle.Hidden, RightToLeft.Inherit, new Rectangle(0, 0, 99, 25) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DisplayRectangle_TestData))]
-    public void ToolStrip_DisplayRectangle_Get_ReturnsExpected(ToolStripLayoutStyle layoutStyle, ToolStripGripStyle gripStyle, RightToLeft rightToLeft, Rectangle expected)
-    {
-        using var control = new SubToolStrip
-        {
-            LayoutStyle = layoutStyle,
-            GripStyle = gripStyle,
-            RightToLeft = rightToLeft
-        };
-        Assert.Equal(expected, control.DisplayRectangle);
-        Assert.Equal(expected.Size, control.MaxItemSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dock_GetDefaultDock_ReturnsExpected()
-    {
-        using var control = new CustomDefaultDockToolStrip();
-        Assert.Equal(DockStyle.Right, control.Dock);
-    }
-
-    private class CustomDefaultDockToolStrip : ToolStrip
-    {
-        protected override DockStyle DefaultDock => DockStyle.Right;
-    }
-
-    public static IEnumerable<object[]> Dock_Set_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Fill, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Fill, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Fill, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, 1, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, 1, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, 1, Orientation.Vertical, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, 1, Orientation.Vertical, 0 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, 0, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, 0, Orientation.Vertical, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_Set_TestData))]
-    public void ToolStrip_Dock_Set_GetReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle value, int expectedLayoutCallCount, Orientation expectedOrientation, int expectedLayoutStyleChangedCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            LayoutStyle = layoutStyle
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "Dock")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                layoutCallCount++;
-            }
-        };
-        int layoutStyleChangedCallCount = 0;
-        control.LayoutStyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutStyleChangedCallCount++;
-        };
-
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Dock = value;
-        Assert.Equal(value, control.Dock);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Dock_SetWithParent_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, Orientation.Horizontal, 1, 0, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, Orientation.Vertical, 0, 0, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Fill, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Fill, Orientation.Horizontal, 1, 0, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Fill, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Fill, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Fill, Orientation.Vertical, 0, 0, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, Orientation.Horizontal, 1, 0, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, Orientation.Vertical, 0, 0, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, Orientation.Horizontal, 1, 0, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, Orientation.Horizontal, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, Orientation.Vertical, 0, 0, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, Orientation.Horizontal, 1, 0, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, Orientation.Vertical, 0, 1, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, Orientation.Vertical, 0, 0, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, Orientation.Horizontal, 0, 0, 0 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, Orientation.Horizontal, 0, 0, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, Orientation.Horizontal, 0, 0, 0 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, Orientation.Horizontal, 0, 0, 0 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, Orientation.Vertical, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_SetWithParent_TestData))]
-    public void ToolStrip_Dock_SetWithParent_GetReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle value, Orientation expectedOrientation, int expectedLayoutCallCount, int expectedLayoutStyleChangedCallCount, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new ToolStrip
-        {
-            LayoutStyle = layoutStyle,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "Dock")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                layoutCallCount++;
-            }
-        };
-        int layoutStyleChangedCallCount = 0;
-        control.LayoutStyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutStyleChangedCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            if (e.AffectedProperty == "Dock" || e.AffectedProperty == "Orientation")
-            {
-                Assert.Same(parent, sender);
-                Assert.Same(control, e.AffectedControl);
-                parentLayoutCallCount++;
-            }
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(expectedLayoutStyleChangedCallCount, layoutStyleChangedCallCount);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> Dock_SetWithToolStripPanelParent_TestData()
-    {
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Bottom, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Bottom, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Bottom, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Bottom, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Bottom, Orientation.Horizontal, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Fill, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Fill, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Fill, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Fill, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Fill, Orientation.Horizontal, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Left, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Left, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Left, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Left, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Left, Orientation.Horizontal, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.None, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.None, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.None, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.None, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.None, Orientation.Horizontal, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Right, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Right, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Right, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Right, Orientation.Horizontal, 1 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Right, Orientation.Horizontal, 1 };
-
-        yield return new object[] { ToolStripLayoutStyle.Flow, DockStyle.Top, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.HorizontalStackWithOverflow, DockStyle.Top, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.StackWithOverflow, DockStyle.Top, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.Table, DockStyle.Top, Orientation.Horizontal, 0 };
-        yield return new object[] { ToolStripLayoutStyle.VerticalStackWithOverflow, DockStyle.Top, Orientation.Horizontal, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Dock_SetWithToolStripPanelParent_TestData))]
-    public void ToolStrip_Dock_SetWithToolStripPanelParent_GetReturnsExpected(ToolStripLayoutStyle layoutStyle, DockStyle value, Orientation expectedOrientation, int expectedLayoutCallCount)
-    {
-        using var parent = new ToolStripPanel();
-        using var control = new ToolStrip
-        {
-            LayoutStyle = layoutStyle,
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "Dock")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                layoutCallCount++;
-            }
-        };
-        int layoutStyleChangedCallCount = 0;
-        control.LayoutStyleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutStyleChangedCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            if (e.AffectedProperty == "Dock" || e.AffectedProperty == "Orientation")
-            {
-                Assert.Same(parent, sender);
-                Assert.Same(control, e.AffectedControl);
-                parentLayoutCallCount++;
-            }
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(0, layoutStyleChangedCallCount);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Dock = value;
-            Assert.Equal(value, control.Dock);
-            Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.Equal(0, layoutStyleChangedCallCount);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dock_SetWithHandler_CallsDockChanged()
-    {
-        using var control = new ToolStrip
-        {
-            Dock = DockStyle.None
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.DockChanged += handler;
-
-        // Set different.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Dock = DockStyle.Left;
-        Assert.Equal(DockStyle.Left, control.Dock);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.Dock = DockStyle.Top;
-        Assert.Equal(DockStyle.Top, control.Dock);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<DockStyle>]
-    public void ToolStrip_Dock_SetInvalid_ThrowsInvalidEnumArgumentException(DockStyle value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Dock = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetForeColorTheoryData))]
-    public void ToolStrip_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new ToolStrip
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStrip_GripMargin_Set_GetReturnsExpected(Padding value)
-    {
-        using var control = new ToolStrip();
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.False(control.IsHandleCreated);
-
-        ToolStripItem grip = Assert.IsAssignableFrom<ToolStripItem>(Assert.Single(control.DisplayedItems));
-        Assert.Equal(value, grip.Margin);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingTheoryData))]
-    public void ToolStrip_GripMargin_SetWithGrip_GetReturnsExpected(Padding value)
-    {
-        using var control = new ToolStrip();
-        ToolStripItem grip = Assert.IsAssignableFrom<ToolStripItem>(Assert.Single(control.DisplayedItems));
-
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.Equal(value, grip.Margin);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripMargin = value;
-        Assert.Equal(value, control.GripMargin);
-        Assert.Equal(value, grip.Margin);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 1, 0)]
-    [InlineData(ToolStripGripStyle.Visible, 0, 1)]
-    public void ToolStrip_GripStyle_Set_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount, int expectedCount)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        Assert.Equal(expectedCount, control.DisplayedItems.Count);
-        Assert.True(control.DisplayedItems.Cast<ToolStripItem>().All(i => i.Visible));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 1)]
-    [InlineData(ToolStripGripStyle.Visible, 0)]
-    public void ToolStrip_GripStyle_SetWithGrip_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        ToolStripItem grip = Assert.IsAssignableFrom<ToolStripItem>(Assert.Single(control.DisplayedItems));
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(value == ToolStripGripStyle.Visible, grip.Visible);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(value == ToolStripGripStyle.Visible, grip.Visible);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripGripStyle.Hidden, 1)]
-    [InlineData(ToolStripGripStyle.Visible, 0)]
-    public void ToolStrip_GripStyle_SetWithHandle_GetReturnsExpected(ToolStripGripStyle value, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("GripStyle", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.GripStyle = value;
-        Assert.Equal(value, control.GripStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripGripStyle>]
-    public void ToolStrip_GripStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripGripStyle value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.GripStyle = value);
-    }
-
-    public static IEnumerable<object[]> LayoutStyle_Set_TestData()
-    {
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.None, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-        }
-
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.Right, DockStyle.Left })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_Set_TestData))]
-    public void ToolStrip_LayoutStyle_Set_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_Set_TestData))]
-    public void ToolStrip_LayoutStyle_SetWithParent_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new ToolStrip
-        {
-            Parent = parent,
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.LayoutStyle = value;
-            Assert.Equal(expected, control.LayoutStyle);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.LayoutStyle = value;
-            Assert.Equal(expected, control.LayoutStyle);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> LayoutStyle_SetWithToolStripPanelParent_TestData()
-    {
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.None, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-        }
-
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.Right, DockStyle.Left })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_SetWithToolStripPanelParent_TestData))]
-    public void ToolStrip_LayoutStyle_SetWithToolStripPanelParent_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var parent = new ToolStripPanel();
-        using var control = new ToolStrip
-        {
-            Parent = parent,
-            Dock = dock
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.LayoutStyle = value;
-            Assert.Equal(expected, control.LayoutStyle);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.LayoutStyle = value;
-            Assert.Equal(expected, control.LayoutStyle);
-            Assert.Equal(expectedOrientation, control.Orientation);
-            Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-            Assert.Equal(expectedLayoutCallCount * 2, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    public static IEnumerable<object[]> LayoutStyle_SetWithCustomOldValue_TestData()
-    {
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.None, DockStyle.Top, DockStyle.Bottom })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        }
-
-        foreach (DockStyle dock in new DockStyle[] { DockStyle.Right }) //, DockStyle.Left })
-        {
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 0 };
-            yield return new object[] { dock, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-            yield return new object[] { dock, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_SetWithCustomOldValue_TestData))]
-    public void ToolStrip_LayoutStyle_SetWithCustomOldValue_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle oldValue, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            Dock = dock,
-            LayoutStyle = oldValue
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> LayoutStyle_SetWithHandle_TestData()
-    {
-        yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.None, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-        yield return new object[] { DockStyle.None, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-        yield return new object[] { DockStyle.None, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.None, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 2 };
-
-        yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 2 };
-        yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 2 };
-        yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 2 };
-        yield return new object[] { DockStyle.Left, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-
-        yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 2 };
-        yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 2 };
-        yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 0 };
-        yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 2 };
-        yield return new object[] { DockStyle.Right, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 1 };
-
-        yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-        yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-        yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.Top, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 2 };
-
-        yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Flow, ToolStripLayoutStyle.Flow, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.HorizontalStackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 1 };
-        yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.StackWithOverflow, ToolStripLayoutStyle.HorizontalStackWithOverflow, Orientation.Horizontal, ToolStripGripDisplayStyle.Vertical, 0 };
-        yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.Table, ToolStripLayoutStyle.Table, Orientation.Horizontal, ToolStripGripDisplayStyle.Horizontal, 1 };
-        yield return new object[] { DockStyle.Bottom, ToolStripLayoutStyle.VerticalStackWithOverflow, ToolStripLayoutStyle.VerticalStackWithOverflow, Orientation.Vertical, ToolStripGripDisplayStyle.Horizontal, 2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(LayoutStyle_SetWithHandle_TestData))]
-    public void ToolStrip_LayoutStyle_SetWithHandle_GetReturnsExpected(DockStyle dock, ToolStripLayoutStyle value, ToolStripLayoutStyle expected, Orientation expectedOrientation, ToolStripGripDisplayStyle expectedGripDisplayStyle, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip
-        {
-            Dock = dock
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LayoutStyle = value;
-        Assert.Equal(expected, control.LayoutStyle);
-        Assert.Equal(expectedOrientation, control.Orientation);
-        Assert.Equal(expectedGripDisplayStyle, control.GripDisplayStyle);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_LayoutStyle_SetWithHandler_CallsLayoutStyleChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.LayoutStyleChanged += handler;
-
-        // Set different.
-        control.LayoutStyle = ToolStripLayoutStyle.Flow;
-        Assert.Equal(ToolStripLayoutStyle.Flow, control.LayoutStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.LayoutStyle = ToolStripLayoutStyle.Flow;
-        Assert.Equal(ToolStripLayoutStyle.Flow, control.LayoutStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.LayoutStyle = ToolStripLayoutStyle.Table;
-        Assert.Equal(ToolStripLayoutStyle.Table, control.LayoutStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.LayoutStyleChanged -= handler;
-        control.LayoutStyle = ToolStripLayoutStyle.Flow;
-        Assert.Equal(ToolStripLayoutStyle.Flow, control.LayoutStyle);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> Renderer_Set_TestData()
-    {
-        yield return new object[] { new SubToolStripRenderer() };
-        yield return new object[] { new ToolStripSystemRenderer() };
-        yield return new object[] { new ToolStripProfessionalRenderer() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Renderer_Set_TestData))]
-    public void ToolStrip_Renderer_Set_ReturnsExpected(ToolStripRenderer value)
-    {
-        using var control = new ToolStrip
-        {
-            Renderer = value
-        };
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-
-        // Set same.
-        control.Renderer = value;
-        Assert.Same(value, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-
-        // Set null.
-        control.Renderer = null;
-        Assert.NotNull(control.Renderer);
-        Assert.NotSame(value, control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Renderer_SetWithHandler_CallsRendererChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RendererChanged += handler;
-
-        // Set different.
-        var renderer = new SubToolStripRenderer();
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Renderer = null;
-        Assert.NotNull(control.Renderer);
-        Assert.NotSame(renderer, control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RendererChanged -= handler;
-        control.Renderer = renderer;
-        Assert.Same(renderer, control.Renderer);
-        Assert.Equal(2, callCount);
-    }
-
-    private class SubToolStripRenderer : ToolStripRenderer
-    {
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer))]
-    [InlineData(ToolStripRenderMode.System, typeof(ToolStripSystemRenderer))]
-    public void ToolStrip_RenderMode_Set_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType)
-    {
-        using var control = new ToolStrip();
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        // Set same.
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(0, rendererChangedCallCount);
-
-        // Set different.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-
-        // Set ManagerRenderMode.
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(3, rendererChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripRenderMode.Professional, typeof(ToolStripProfessionalRenderer))]
-    [InlineData(ToolStripRenderMode.System, typeof(ToolStripSystemRenderer))]
-    public void ToolStrip_RenderMode_SetWithCustomRenderer_ReturnsExpected(ToolStripRenderMode value, Type expectedRendererType)
-    {
-        using var control = new ToolStrip
-        {
-            Renderer = new SubToolStripRenderer()
-        };
-        int rendererChangedCallCount = 0;
-        control.RendererChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            rendererChangedCallCount++;
-        };
-
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(1, rendererChangedCallCount);
-
-        // Set same.
-        control.RenderMode = value;
-        Assert.Equal(value, control.RenderMode);
-        Assert.IsType(expectedRendererType, control.Renderer);
-        Assert.Equal(2, rendererChangedCallCount);
-
-        // Set ManagerRenderMode.
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.NotNull(control.Renderer);
-        Assert.Same(control.Renderer, control.Renderer);
-        Assert.IsType<ToolStripProfessionalRenderer>(control.Renderer);
-        Assert.Equal(3, rendererChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_RenderMode_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.RenderMode)];
-        using var control = new ToolStrip();
-        Assert.False(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, control.RenderMode);
-        Assert.True(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.True(property.CanResetValue(control));
-
-        control.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(property.CanResetValue(control));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_RenderMode_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolStrip))[nameof(ToolStrip.RenderMode)];
-        using var control = new ToolStrip();
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.Professional;
-        Assert.Equal(ToolStripRenderMode.Professional, control.RenderMode);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.System;
-        Assert.Equal(ToolStripRenderMode.System, control.RenderMode);
-        Assert.True(property.ShouldSerializeValue(control));
-
-        control.Renderer = new SubToolStripRenderer();
-        Assert.Equal(ToolStripRenderMode.Custom, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        control.RenderMode = ToolStripRenderMode.ManagerRenderMode;
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-
-        property.ResetValue(control);
-        Assert.Equal(ToolStripRenderMode.ManagerRenderMode, control.RenderMode);
-        Assert.False(property.ShouldSerializeValue(control));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripRenderMode>]
-    public void ToolStrip_RenderMode_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripRenderMode value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RenderMode = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_RenderMode_SetCustomThrowsInvalidEnumArgumentException()
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<NotSupportedException>(() => control.RenderMode = ToolStripRenderMode.Custom);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, RightToLeft.Yes, 1)]
-    [InlineData(RightToLeft.No, RightToLeft.No, 0)]
-    [InlineData(RightToLeft.Inherit, RightToLeft.No, 0)]
-    public void ToolStrip_RightToLeft_Set_GetReturnsExpected(RightToLeft value, RightToLeft expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ToolStrip_RightToLeft_SetWithChildren_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new ToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expected, item1.RightToLeft);
-        Assert.Equal(expected, item2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(expected, item1.RightToLeft);
-        Assert.Equal(expected, item2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetRightToLeftTheoryData))]
-    public void ToolStrip_RightToLeft_SetWithChildrenWithRightToLeft_GetReturnsExpected(RightToLeft value, RightToLeft expected)
-    {
-        using var item1 = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var item2 = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new ToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, item1.RightToLeft);
-        Assert.Equal(RightToLeft.No, item2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(expected, control.RightToLeft);
-        Assert.Equal(RightToLeft.Yes, item1.RightToLeft);
-        Assert.Equal(RightToLeft.No, item2.RightToLeft);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_RightToLeft_SetWithHandler_CallsRightToLeftChanged()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.Yes, control.RightToLeft);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<RightToLeft>]
-    public void ToolStrip_RightToLeft_SetInvalid_ThrowsInvalidEnumArgumentException(RightToLeft value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.RightToLeft = value);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_ShowToolTipItems_GetDefaultShowItemToolTips_ReturnsExpected()
-    {
-        using var control = new CustomDefaultShowItemToolTipsToolStrip();
-        Assert.False(control.ShowItemToolTips);
-    }
-
-    private class CustomDefaultShowItemToolTipsToolStrip : ToolStrip
-    {
-        protected override bool DefaultShowItemToolTips => false;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_ShowItemToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            ShowItemToolTips = value
-        };
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowItemToolTips = !value;
-        Assert.Equal(!value, control.ShowItemToolTips);
-        Assert.Equal(!value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_ShowItemToolTips_SetWithItems_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        using var item = new SubToolStripItem();
-        control.Items.Add(item);
-
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowItemToolTips = !value;
-        Assert.Equal(!value, control.ShowItemToolTips);
-        Assert.Equal(!value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_ShowItemToolTips_SetWithOverflowButton_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotNull(control.OverflowButton);
-
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.Equal(value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShowItemToolTips = value;
-        Assert.Equal(value, control.ShowItemToolTips);
-        Assert.Equal(value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShowItemToolTips = !value;
-        Assert.Equal(!value, control.ShowItemToolTips);
-        Assert.Equal(value, control.OverflowButton.DropDown.ShowItemToolTips);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_Stretch_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            Stretch = value
-        };
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_Stretch_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Stretch = value;
-        Assert.Equal(value, control.Stretch);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_TabStop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubToolStrip
-        {
-            TabStop = value
-        };
-        Assert.Equal(value, control.TabStop);
-        Assert.Equal(value, control.GetStyle(ControlStyles.Selectable));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.Equal(value, control.GetStyle(ControlStyles.Selectable));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.TabStop = !value;
-        Assert.Equal(!value, control.TabStop);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.Selectable));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_TabStop_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.Equal(value, control.GetStyle(ControlStyles.Selectable));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TabStop = value;
-        Assert.Equal(value, control.TabStop);
-        Assert.Equal(value, control.GetStyle(ControlStyles.Selectable));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.TabStop = !value;
-        Assert.Equal(!value, control.TabStop);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.Selectable));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_TabStop_SetWithHandler_CallsTabStopChanged()
-    {
-        using var control = new ToolStrip
-        {
-            TabStop = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TabStopChanged += handler;
-
-        // Set different.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.TabStop = true;
-        Assert.True(control.TabStop);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.TabStop = false;
-        Assert.False(control.TabStop);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_Set_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_SetWithHandle_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_SetWithItems_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expected, item1.TextDirection);
-        Assert.Equal(expected, item2.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(expected, item1.TextDirection);
-        Assert.Equal(expected, item2.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_SetWithItemsWithTextDirection_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        using var item1 = new SubToolStripItem
-        {
-            TextDirection = ToolStripTextDirection.Vertical90
-        };
-        using var item2 = new SubToolStripItem
-        {
-            TextDirection = ToolStripTextDirection.Vertical270
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(ToolStripTextDirection.Vertical90, item1.TextDirection);
-        Assert.Equal(ToolStripTextDirection.Vertical270, item2.TextDirection);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextDirection = value;
-        Assert.Equal(expected, control.TextDirection);
-        Assert.Equal(ToolStripTextDirection.Vertical90, item1.TextDirection);
-        Assert.Equal(ToolStripTextDirection.Vertical270, item2.TextDirection);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_SetWithItemsWithHandle_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        control.Layout += layoutHandler;
-
-        try
-        {
-            control.TextDirection = value;
-            Assert.Equal(expected, control.TextDirection);
-            Assert.Equal(expected, item1.TextDirection);
-            Assert.Equal(expected, item2.TextDirection);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount * 3, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.TextDirection = value;
-            Assert.Equal(expected, control.TextDirection);
-            Assert.Equal(expected, item1.TextDirection);
-            Assert.Equal(expected, item2.TextDirection);
-            Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal((expectedLayoutCallCount + 1) * 3, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripTextDirection.Inherit, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Horizontal, ToolStripTextDirection.Horizontal, 1)]
-    [InlineData(ToolStripTextDirection.Vertical90, ToolStripTextDirection.Vertical90, 1)]
-    [InlineData(ToolStripTextDirection.Vertical270, ToolStripTextDirection.Vertical270, 1)]
-    public void ToolStrip_TextDirection_SetWithItemsWithTextDirectionWithHandle_GetReturnsExpected(ToolStripTextDirection value, ToolStripTextDirection expected, int expectedLayoutCallCount)
-    {
-        using var control = new ToolStrip();
-        using var item1 = new SubToolStripItem
-        {
-            TextDirection = ToolStripTextDirection.Vertical90
-        };
-        using var item2 = new SubToolStripItem
-        {
-            TextDirection = ToolStripTextDirection.Vertical270
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        void layoutHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("TextDirection", e.AffectedProperty);
-            layoutCallCount++;
-        }
-
-        control.Layout += layoutHandler;
-
-        try
-        {
-            control.TextDirection = value;
-            Assert.Equal(expected, control.TextDirection);
-            Assert.Equal(ToolStripTextDirection.Vertical90, item1.TextDirection);
-            Assert.Equal(ToolStripTextDirection.Vertical270, item2.TextDirection);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.TextDirection = value;
-            Assert.Equal(expected, control.TextDirection);
-            Assert.Equal(ToolStripTextDirection.Vertical90, item1.TextDirection);
-            Assert.Equal(ToolStripTextDirection.Vertical270, item2.TextDirection);
-            Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount + 1, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            control.Layout -= layoutHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripTextDirection>]
-    public void ToolStrip_TextDirection_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolStripTextDirection value)
-    {
-        using var control = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextDirection = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new ToolStrip
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Visible_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, true, 0 };
-            yield return new object[] { userPaint, false, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Visible_SetWithHandle_TestData))]
-    public void ToolStrip_Visible_SetWithHandle_GetReturnsExpected(bool userPaint, bool value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubToolStrip();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new ToolStrip
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateAccessibilityInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        ToolStrip.ToolStripAccessibleObject instance = Assert.IsType<ToolStrip.ToolStripAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.ToolBar, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubToolStrip
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        ToolStrip.ToolStripAccessibleObject instance = Assert.IsType<ToolStrip.ToolStripAccessibleObject>(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);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateControlsInstance_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        Control.ControlCollection controls = Assert.IsAssignableFrom<Control.ControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.True(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateControlsInstance_InvokeDesignMode_ReturnsExpected()
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubToolStrip
-        {
-            Site = mockSite.Object
-        };
-        Control.ControlCollection controls = Assert.IsAssignableFrom<Control.ControlCollection>(control.CreateControlsInstance());
-        Assert.Empty(controls);
-        Assert.Same(control, controls.Owner);
-        Assert.False(controls.IsReadOnly);
-        Assert.NotSame(controls, control.CreateControlsInstance());
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Button_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null, null };
-        yield return new object[] { string.Empty, new Bitmap(10, 10), onClick };
-        yield return new object[] { "text", new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Button_TestData))]
-    public void ToolStrip_CreateDefaultItem_InvokeButton_Success(string text, Image image, EventHandler onClick)
-    {
-        using var control = new SubToolStrip();
-        ToolStripButton button = Assert.IsType<ToolStripButton>(control.CreateDefaultItem(text, image, onClick));
-        Assert.Equal(text, button.Text);
-        Assert.Same(image, button.Image);
-    }
-
-    public static IEnumerable<object[]> CreateDefaultItem_Separator_TestData()
-    {
-        EventHandler onClick = (sender, e) => { };
-
-        yield return new object[] { null, null };
-        yield return new object[] { new Bitmap(10, 10), onClick };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CreateDefaultItem_Separator_TestData))]
-    public void ToolStrip_CreateDefaultItem_InvokeSeparator_Success(Image image, EventHandler onClick)
-    {
-        using var control = new SubToolStrip();
-        ToolStripSeparator separator = Assert.IsType<ToolStripSeparator>(control.CreateDefaultItem("-", image, onClick));
-        Assert.Empty(separator.Text);
-        Assert.Null(separator.Image);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1)]
-    [InlineData("", 1)]
-    [InlineData("text", 1)]
-    [InlineData("-", 0)]
-    public void ToolStrip_CreateDefaultItem_PerformClick_Success(string text, int expectedCallCount)
-    {
-        int callCount = 0;
-        EventHandler onClick = (sender, e) => callCount++;
-        using var control = new SubToolStrip();
-        ToolStripItem button = Assert.IsAssignableFrom<ToolStripItem>(control.CreateDefaultItem(text, null, onClick));
-        button.PerformClick();
-        Assert.Equal(expectedCallCount, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateLayoutSettings_InvokeFlow_ReturnsExpected()
-    {
-        using var toolStrip = new SubToolStrip();
-        FlowLayoutSettings settings = Assert.IsType<FlowLayoutSettings>(toolStrip.CreateLayoutSettings(ToolStripLayoutStyle.Flow));
-        Assert.Equal(FlowDirection.LeftToRight, settings.FlowDirection);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-        Assert.True(settings.WrapContents);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_CreateLayoutSettings_InvokeTable_ReturnsExpected()
-    {
-        using var toolStrip = new SubToolStrip();
-        TableLayoutSettings settings = Assert.IsType<TableLayoutSettings>(toolStrip.CreateLayoutSettings(ToolStripLayoutStyle.Table));
-        Assert.Equal(0, settings.ColumnCount);
-        Assert.Empty(settings.ColumnStyles);
-        Assert.Equal(TableLayoutPanelGrowStyle.AddRows, settings.GrowStyle);
-        Assert.NotNull(settings.LayoutEngine);
-        Assert.Same(settings.LayoutEngine, settings.LayoutEngine);
-        Assert.Equal(0, settings.RowCount);
-        Assert.Empty(settings.RowStyles);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolStripLayoutStyle>]
-    [InlineData(ToolStripLayoutStyle.StackWithOverflow)]
-    [InlineData(ToolStripLayoutStyle.HorizontalStackWithOverflow)]
-    [InlineData(ToolStripLayoutStyle.VerticalStackWithOverflow)]
-    public void ToolStrip_CreateLayoutSettings_InvalidLayoutStyle_ReturnsNull(ToolStripLayoutStyle layoutStyle)
-    {
-        using var toolStrip = new SubToolStrip();
-        Assert.Null(toolStrip.CreateLayoutSettings(layoutStyle));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_Invoke_Success()
-    {
-        using var control = new ToolStrip();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeNotVisible_Success()
-    {
-        using var control = new ToolStrip
-        {
-            Visible = false
-        };
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeWithItems_Success()
-    {
-        using var control = new ToolStrip();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeDisposing_Success()
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeNotDisposing_Success()
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeDisposingWithItems_Success()
-    {
-        using var control = new SubToolStrip();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.Items);
-            Assert.Empty(control.DataBindings);
-            Assert.Null(item1.Owner);
-            Assert.Null(item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.True(control.Visible);
-            Assert.True(item1.IsDisposed);
-            Assert.True(item2.IsDisposed);
-            Assert.True(control.Visible);
-            Assert.Equal(2, callCount);
-            Assert.Equal(1, item1CallCount);
-            Assert.Equal(1, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_Dispose_InvokeNotDisposingWithItems_Success()
-    {
-        using var control = new SubToolStrip();
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemRemovedCallCount = 0;
-        control.ItemRemoved += (sender, e) => itemRemovedCallCount++;
-        int controlRemovedCallCount = 0;
-        control.ControlRemoved += (sender, e) => controlRemovedCallCount++;
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-        int item1CallCount = 0;
-        item1.Disposed += (sender, e) => item1CallCount++;
-        int item2CallCount = 0;
-        item2.Disposed += (sender, e) => item2CallCount++;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, item1.Owner);
-            Assert.Same(control, item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(item1.IsDisposed);
-            Assert.False(item2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, item1CallCount);
-            Assert.Equal(0, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());
-            Assert.Empty(control.DataBindings);
-            Assert.Same(control, item1.Owner);
-            Assert.Same(control, item2.Owner);
-            Assert.Equal(0, controlRemovedCallCount);
-            Assert.Equal(0, itemRemovedCallCount);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.False(item1.IsDisposed);
-            Assert.False(item2.IsDisposed);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, item1CallCount);
-            Assert.Equal(0, item2CallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [EnumData<ArrowDirection>]
-    public void ToolStrip_GetNextItem_NoItems_ReturnsNull(ArrowDirection direction)
-    {
-        using var toolStrip = new ToolStrip();
-        Assert.Null(toolStrip.GetNextItem(new SubToolStripItem(), direction));
-        Assert.Null(toolStrip.GetNextItem(null, direction));
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ArrowDirection>]
-    public void ToolStrip_GetNextItem_InvalidDirection_ThrowsInvalidEnumArgumentException(ArrowDirection direction)
-    {
-        using var toolStrip = new ToolStrip();
-        Assert.Throws<InvalidEnumArgumentException>("direction", () => toolStrip.GetNextItem(new SubToolStripItem(), direction));
-        Assert.Throws<InvalidEnumArgumentException>("direction", () => toolStrip.GetNextItem(null, direction));
-    }
-
-    public static IEnumerable<object[]> ToolStrip_GetNextItem_TestData()
-    {
-        foreach (RightToLeft rtl in Enum.GetValues(typeof(RightToLeft)))
-        {
-            foreach (bool tabStop in new bool[] { true, false })
-            {
-                foreach (bool useTabKey in new bool[] { true, false })
-                {
-                    yield return new object[] { rtl, tabStop, useTabKey };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStrip_GetNextItem_TestData))]
-    public void ToolStrip_GetNextItem_ReturnsForwardItem(RightToLeft rightToLeft, bool tabStop, bool useTabKey)
-    {
-        using ToolStrip toolStrip = new() { RightToLeft = rightToLeft, TabStop = tabStop };
-        using ToolStripButton toolStripButton1 = new();
-        using ToolStripButton toolStripButton2 = new();
-        using ToolStripButton toolStripButton3 = new();
-        toolStrip.Items.AddRange(new ToolStripItem[] { toolStripButton1, toolStripButton2, toolStripButton3 });
-
-        if (useTabKey)
-        {
-            toolStrip.TestAccessor().Dynamic.LastKeyData = Keys.Tab;
-        }
-
-        ToolStripItem actual = toolStrip.GetNextItem(toolStrip.Items[0], ArrowDirection.Right);
-
-        Assert.Equal(toolStripButton2, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStrip_GetNextItem_TestData))]
-    public void ToolStrip_GetNextItem_CyclesForwardExpected(RightToLeft rightToLeft, bool tabStop, bool useTabKey)
-    {
-        using ToolStrip toolStrip = new() { RightToLeft = rightToLeft, TabStop = tabStop };
-        using ToolStripButton toolStripButton1 = new();
-        using ToolStripButton toolStripButton2 = new();
-        using ToolStripButton toolStripButton3 = new();
-        toolStrip.Items.AddRange(new ToolStripItem[] { toolStripButton1, toolStripButton2, toolStripButton3 });
-
-        if (useTabKey)
-        {
-            toolStrip.TestAccessor().Dynamic.LastKeyData = Keys.Tab;
-        }
-
-        ToolStripItem nextToolStripItem1 = toolStrip.GetNextItem(toolStripButton1, ArrowDirection.Right);
-        ToolStripItem nextToolStripItem2 = toolStrip.GetNextItem(toolStripButton2, ArrowDirection.Right);
-        ToolStripItem nextToolStripItem3 = toolStrip.GetNextItem(toolStripButton3, ArrowDirection.Right);
-
-        Assert.Equal(toolStripButton2, nextToolStripItem1);
-        Assert.Equal(toolStripButton3, nextToolStripItem2);
-        Assert.Equal(toolStripButton1, nextToolStripItem3);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStrip_GetNextItem_TestData))]
-    public void ToolStrip_GetNextItem_ReturnsBackwardItem(RightToLeft rightToLeft, bool tabStop, bool useTabKey)
-    {
-        using ToolStrip toolStrip = new() { RightToLeft = rightToLeft, TabStop = tabStop };
-        using ToolStripButton toolStripButton1 = new();
-        using ToolStripButton toolStripButton2 = new();
-        using ToolStripButton toolStripButton3 = new();
-        toolStrip.Items.AddRange(new ToolStripItem[] { toolStripButton1, toolStripButton2, toolStripButton3 });
-
-        if (useTabKey)
-        {
-            toolStrip.TestAccessor().Dynamic.LastKeyData = Keys.Shift | Keys.Tab;
-        }
-
-        ToolStripItem actual = toolStrip.GetNextItem(toolStrip.Items[0], ArrowDirection.Left);
-
-        Assert.Equal(toolStripButton3, actual);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStrip_GetNextItem_TestData))]
-    public void ToolStrip_GetNextItem_CyclesBackwardExpected(RightToLeft rightToLeft, bool tabStop, bool useTabKey)
-    {
-        using ToolStrip toolStrip = new() { RightToLeft = rightToLeft, TabStop = tabStop };
-        using ToolStripButton toolStripButton1 = new();
-        using ToolStripButton toolStripButton2 = new();
-        using ToolStripButton toolStripButton3 = new();
-        toolStrip.Items.AddRange(new ToolStripItem[] { toolStripButton1, toolStripButton2, toolStripButton3 });
-
-        if (useTabKey)
-        {
-            toolStrip.TestAccessor().Dynamic.LastKeyData = Keys.Shift | Keys.Tab;
-        }
-
-        ToolStripItem previousToolStripItem1 = toolStrip.GetNextItem(toolStripButton1, ArrowDirection.Left);
-        ToolStripItem previousToolStripItem2 = toolStrip.GetNextItem(toolStripButton3, ArrowDirection.Left);
-        ToolStripItem previousToolStripItem3 = toolStrip.GetNextItem(toolStripButton2, ArrowDirection.Left);
-
-        Assert.Equal(toolStripButton3, previousToolStripItem1);
-        Assert.Equal(toolStripButton2, previousToolStripItem2);
-        Assert.Equal(toolStripButton1, previousToolStripItem3);
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        Assert.Equal(AutoSizeMode.GrowAndShrink, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubToolStrip.ScrollStateAutoScrolling, false)]
-    [InlineData(SubToolStrip.ScrollStateFullDrag, false)]
-    [InlineData(SubToolStrip.ScrollStateHScrollVisible, false)]
-    [InlineData(SubToolStrip.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubToolStrip.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void ToolStrip_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubToolStrip();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, false)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, true)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void ToolStrip_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubToolStrip();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubToolStrip();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnBeginDrag_Invoke_CallsBeginDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeginDrag += handler;
-        control.OnBeginDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BeginDrag -= handler;
-        control.OnBeginDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnBeginDrag_InvokeWithHandle_CallsBeginDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeginDrag += handler;
-        control.OnBeginDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.BeginDrag -= handler;
-        control.OnBeginDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ControlEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ControlEventArgs(null) };
-        yield return new object[] { new ControlEventArgs(new Control()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlEventArgs_TestData))]
-    public void ToolStrip_OnControlAdded_Invoke_CallsControlAdded(ControlEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        ControlEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ControlAdded += handler;
-        control.OnControlAdded(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ControlAdded -= handler;
-        control.OnControlAdded(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ControlEventArgs_TestData))]
-    public void ToolStrip_OnControlRemoved_Invoke_CallsControlRemoved(ControlEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        ControlEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ControlRemoved += handler;
-        control.OnControlRemoved(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ControlRemoved -= handler;
-        control.OnControlRemoved(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnDockChanged_Invoke_CallsDockChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DockChanged += handler;
-        control.OnDockChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DockChanged -= handler;
-        control.OnDockChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnEndDrag_Invoke_CallsEndDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EndDrag += handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EndDrag -= handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnEndDrag_InvokeCalledBeginDrag_CallsEndDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        control.OnBeginDrag(EventArgs.Empty);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EndDrag += handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EndDrag -= handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnEndDrag_InvokeWithHandle_CallsEndDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EndDrag += handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.EndDrag -= handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnEndDrag_InvokeCalledBeginDragWithHandle_CallsEndDrag(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        control.OnBeginDrag(EventArgs.Empty);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EndDrag += handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.EndDrag -= handler;
-        control.OnEndDrag(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsCurrentlyDragging);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(Control.DefaultFont.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnFontChanged_InvokeWithChildren_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnFontChanged_InvokeWithChildrenWithFont_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var childFont1 = new Font("Arial", 1);
-        using var childFont2 = new Font("Arial", 2);
-        using var item1 = new SubToolStripItem
-        {
-            Font = childFont1
-        };
-        using var item2 = new SubToolStripItem
-        {
-            Font = childFont2
-        };
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_Invoke_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithOverflowButton_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotNull(control.OverflowButton);
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithOverflowButtonWithDropDown_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        control.OverflowButton.DropDown = new ToolStripDropDown();
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithItems_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int itemLayoutCallCount1 = 0;
-        item1.Layout += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            itemLayoutCallCount1++;
-        };
-        int itemLayoutCallCount2 = 0;
-        item2.Layout += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            itemLayoutCallCount2++;
-        };
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, itemLayoutCallCount1);
-        Assert.Equal(2, itemLayoutCallCount2);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, itemLayoutCallCount1);
-        Assert.Equal(3, itemLayoutCallCount2);
-        Assert.Equal(3, layoutCompletedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithOverflowButtonWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotNull(control.OverflowButton);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithOverflowButtonWithDropDownWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        control.OverflowButton.DropDown = new ToolStripDropDown();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetLayoutEventArgsTheoryData))]
-    public void ToolStrip_OnLayout_InvokeWithItemsWithHandle_CallsLayout(LayoutEventArgs eventArgs)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int itemLayoutCallCount1 = 0;
-        item1.Layout += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            itemLayoutCallCount1++;
-        };
-        int itemLayoutCallCount2 = 0;
-        item2.Layout += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            itemLayoutCallCount2++;
-        };
-        int layoutCompletedCallCount = 0;
-        control.LayoutCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            layoutCompletedCallCount++;
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(2, itemLayoutCallCount1);
-        Assert.Equal(2, itemLayoutCallCount2);
-        Assert.Equal(2, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(3, itemLayoutCallCount1);
-        Assert.Equal(3, itemLayoutCallCount2);
-        Assert.Equal(3, layoutCompletedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnLayoutCompleted_Invoke_CallsLayoutCompleted(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LayoutCompleted += handler;
-        control.OnLayoutCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LayoutCompleted -= handler;
-        control.OnLayoutCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnLayoutStyleChanged_Invoke_CallsLayoutStyleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LayoutStyleChanged += handler;
-        control.OnLayoutStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LayoutStyleChanged -= handler;
-        control.OnLayoutStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnLeave_Invoke_CallsLeave(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Leave += handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Leave -= handler;
-        control.OnLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnLostFocus_Invoke_CallsLostFocus(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.LostFocus += handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        control.OnLostFocus(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolStrip_OnMouseLeave_UnselectsToolStripItem(bool toolStripItemEnabled)
-    {
-        using var toolStrip = new SubToolStrip()
-        {
-            GripStyle = ToolStripGripStyle.Hidden
-        };
-        using var item = new SubToolStripItem()
-        {
-            Enabled = toolStripItemEnabled,
-            Parent = toolStrip,
-            SupportsDisabledHotTracking = true
-        };
-
-        item.SetPlacement(ToolStripItemPlacement.Main);
-        toolStrip.Items.Add(item);
-        toolStrip.SetDisplayedItems();
-
-        toolStrip.OnMouseMove(new MouseEventArgs(MouseButtons.Left, 1, item.Bounds.X, item.Bounds.Y, 0));
-        Assert.Equal(item.CanSelect, item.Selected);
-
-        toolStrip.OnMouseLeave(new EventArgs());
-        Assert.False(item.Selected);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnPaint_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubToolStrip();
-        Assert.Throws<NullReferenceException>(() => control.OnPaint(null));
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_TestData()
-    {
-        foreach (bool hScroll in new bool[] { true, false })
-        {
-            foreach (bool vScroll in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb), new Bitmap(10, 10, PixelFormat.Format32bppArgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        yield return new object[] { hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout };
-                        yield return new object[] { hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout };
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void ToolStrip_OnPaintBackground_Invoke_Success(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubToolStrip
-        {
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    // TODO: unify
-    // Correct the implementation as per ScrollableControlTests.OnPaintBackground_VisualStyles_off_WithParent_TestData
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_off_WithParent_TestData()
-    {
-        var control = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        var tabPage = new TabPage
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        foreach (Control parent in new Control[] { control, tabPage })
-        {
-            foreach (bool hScroll in new bool[] { true, false })
-            {
-                foreach (bool vScroll in new bool[] { true, false })
-                {
-                    foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                    {
-                        foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                        {
-                            int expected = backgroundImage is not null && (backgroundImageLayout == ImageLayout.Zoom || backgroundImageLayout == ImageLayout.Stretch || backgroundImageLayout == ImageLayout.Center) && (hScroll || vScroll) ? 0 : 1;
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                            yield return new object[] { parent, hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        }
-                    }
-
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                }
-            }
-        }
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_VisualStyles_on_WithParent_TestData()
-    {
-        var control = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        var tabPage = new TabPage
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        foreach (Control parent in new Control[] { control, tabPage })
-        {
-            int expected1 = parent == tabPage ? 0 : 1;
-            int expected2 = parent == tabPage ? 0 : 2;
-            int expected3 = parent == tabPage ? 0 : 3;
-
-            foreach (bool hScroll in new bool[] { true, false })
-            {
-                foreach (bool vScroll in new bool[] { true, false })
-                {
-                    foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                    {
-                        foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                        {
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, expected1 };
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, expected1 };
-                            yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, expected1 };
-                            yield return new object[] { parent, hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, expected1 };
-
-                            int expected = parent == tabPage
-                                ? 0
-                                : backgroundImage is not null && (backgroundImageLayout == ImageLayout.Zoom || backgroundImageLayout == ImageLayout.Stretch || backgroundImageLayout == ImageLayout.Center)
-                                    && (hScroll || vScroll)
-                                        ? 1
-                                        : 2;
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                            yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, expected };
-                        }
-                    }
-
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected1 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected2 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, expected2 };
-
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parent, hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected2 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected3 };
-                    yield return new object[] { parent, hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, expected3 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_VisualStyles_on_WithParent_TestData))]
-    public void ToolStrip_OnPaintBackground_InvokeWithParent_CallsPaint(Control parent, bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubToolStrip
-        {
-            Bounds = new Rectangle(0, 0, 30, 25),
-            Parent = parent,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            parentCallCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount, parentCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_TestData))]
-    public void ToolStrip_OnPaintBackground_InvokeWithHandle_Success(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var control = new SubToolStrip
-        {
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnPaintBackground_WithParentWithHandle_TestData()
-    {
-        foreach (bool hScroll in new bool[] { true, false })
-        {
-            foreach (bool vScroll in new bool[] { true, false })
-            {
-                foreach (Image backgroundImage in new Image[] { null, new Bitmap(10, 10, PixelFormat.Format32bppRgb) })
-                {
-                    foreach (ImageLayout backgroundImageLayout in Enum.GetValues(typeof(ImageLayout)))
-                    {
-                        yield return new object[] { hScroll, vScroll, true, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, true, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), backgroundImage, backgroundImageLayout, 1 };
-                        yield return new object[] { hScroll, vScroll, false, Color.Empty, backgroundImage, backgroundImageLayout, 0 };
-                        yield return new object[] { hScroll, vScroll, false, Color.Red, backgroundImage, backgroundImageLayout, 0 };
-                    }
-                }
-
-                yield return new object[] { hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 1 };
-                yield return new object[] { hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-                yield return new object[] { hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.None, 0 };
-
-                yield return new object[] { hScroll, vScroll, true, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(100, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { hScroll, vScroll, true, Color.FromArgb(0, 50, 100, 150), new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 2 };
-                yield return new object[] { hScroll, vScroll, false, Color.Empty, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-                yield return new object[] { hScroll, vScroll, false, Color.Red, new Bitmap(10, 10, PixelFormat.Format32bppArgb), ImageLayout.Tile, 1 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaintBackground_WithParentWithHandle_TestData))]
-    public void ToolStrip_OnPaintBackground_InvokeWithParentWithHandle_CallsPaint(bool hScroll, bool vScroll, bool supportsTransparentBackColor, Color backColor, Image backgroundImage, ImageLayout backgroundImageLayout, int expectedPaintCallCount)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, new Rectangle(1, 2, 3, 4));
-
-        using var parent = new Control
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-        using var control = new SubToolStrip
-        {
-            Bounds = new Rectangle(0, 0, 30, 25),
-            Parent = parent,
-            HScroll = hScroll,
-            VScroll = vScroll
-        };
-        control.SetStyle(ControlStyles.SupportsTransparentBackColor, supportsTransparentBackColor);
-        control.BackColor = backColor;
-        control.BackgroundImage = backgroundImage;
-        control.BackgroundImageLayout = backgroundImageLayout;
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int parentCallCount = 0;
-        PaintEventHandler parentHandler = (sender, e) =>
-        {
-            Assert.Same(parent, sender);
-            Assert.NotSame(graphics, e.Graphics);
-            Assert.Equal(new Rectangle(0, 0, 30, 25), e.ClipRectangle);
-            parentCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Paint += handler;
-        parent.Paint += parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount + 1, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        parent.Paint -= parentHandler;
-        control.OnPaintBackground(eventArgs);
-        Assert.Equal(0, callCount);
-        Assert.Equal(expectedPaintCallCount + 1, parentCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnPaintBackground_NullEventArgs_ThrowsArgumentNullException()
-    {
-        using var control = new SubToolStrip();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaintBackground(null));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnPaintGrip_Invoke_CallsPaintGrip()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.PaintGrip += handler;
-        control.OnPaintGrip(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.PaintGrip -= handler;
-        control.OnPaintGrip(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnPaintGrip_InvokeWithHandle_CallsPaintGrip()
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.PaintGrip += handler;
-        control.OnPaintGrip(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.PaintGrip -= handler;
-        control.OnPaintGrip(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnPaintGrip_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubToolStrip();
-        Assert.Throws<NullReferenceException>(() => control.OnPaintGrip(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_Invoke_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeft", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(4, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_InvokeWithHandle_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            if (e.AffectedProperty == "RightToLeft")
-            {
-                Assert.Same(control, sender);
-                Assert.Same(control, e.AffectedControl);
-                Assert.Equal("RightToLeft", e.AffectedProperty);
-                layoutCallCount++;
-            }
-        };
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(3, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(4, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(6, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_InvokeWithChildren_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.Inherit
-        };
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        int item1CallCount = 0;
-        int item2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        item1.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            Assert.Same(eventArgs, e);
-            item1CallCount++;
-        };
-        item2.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            Assert.Same(eventArgs, e);
-            item2CallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, item1CallCount);
-        Assert.Equal(1, item2CallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, item1CallCount);
-        Assert.Equal(2, item2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_InvokeWithItemsWithRightToLeft_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var item1 = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        using var item2 = new SubToolStripItem
-        {
-            RightToLeft = RightToLeft.No
-        };
-        using var control = new SubToolStrip();
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-
-        int callCount = 0;
-        int item1CallCount = 0;
-        int item2CallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        item1.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item1, sender);
-            Assert.Same(eventArgs, e);
-            item1CallCount++;
-        };
-        item2.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(item2, sender);
-            Assert.Same(eventArgs, e);
-            item2CallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, item1CallCount);
-        Assert.Equal(0, item2CallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, item1CallCount);
-        Assert.Equal(0, item2CallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_InvokeWithOverflowButton_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-
-        int callCount = 0;
-        int overflowButtonCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        control.OverflowButton.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(control.OverflowButton, sender);
-            Assert.Same(eventArgs, e);
-            overflowButtonCallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, overflowButtonCallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, overflowButtonCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnRightToLeftChanged_InvokeWithGrip_CallsRightToLeftChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        ToolStripItem grip = Assert.IsAssignableFrom<ToolStripItem>(Assert.Single(control.DisplayedItems));
-
-        int callCount = 0;
-        int gripCallCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        grip.RightToLeftChanged += (sender, e) =>
-        {
-            Assert.Same(grip, sender);
-            Assert.Same(eventArgs, e);
-            gripCallCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftChanged += handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, gripCallCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.OnRightToLeftChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, gripCallCount);
-    }
-
-    public static IEnumerable<object[]> OnScroll_TestData()
-    {
-        foreach (ScrollEventType eventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            foreach (ScrollOrientation orientation in Enum.GetValues(typeof(ScrollOrientation)))
-            {
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 1, orientation) };
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 2, orientation) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_TestData))]
-    public void ToolStrip_OnScroll_Invoke_CallsHandler(ScrollEventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnScroll_WithHandle_TestData()
-    {
-        foreach (ScrollEventType eventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            foreach (ScrollOrientation orientation in Enum.GetValues(typeof(ScrollOrientation)))
-            {
-                int expected = eventType != ScrollEventType.ThumbTrack ? 1 : 0;
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 1, orientation), 0 };
-                yield return new object[] { new ScrollEventArgs(eventType, 1, 2, orientation), expected };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_WithHandle_TestData))]
-    public void ToolStrip_OnScroll_InvokeWithHandle_CallsHandler(ScrollEventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int callCount = 0;
-        ScrollEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnScroll_WithItems_TestData()
-    {
-        int x = Application.UseVisualStyles ? 9 : 7;
-
-        foreach (ScrollEventType scrollEventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            if (scrollEventType == ScrollEventType.ThumbTrack)
-            {
-                break;
-            }
-
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 100, 200), new Point(x, 101), new Point(0, 100) };
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 200, 100), new Point(x, -99), new Point(0, -100) };
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 100, 100), new Point(x, 1), new Point(0, 0) };
-        }
-
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 100, 200), new Point(x, 1), new Point(0, 0) };
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 200, 100), new Point(x, 1), new Point(0, 0) };
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 0, 0), new Point(x, 1), new Point(0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_WithItems_TestData))]
-    public void ToolStrip_OnScroll_InvokeWithItems_Success(ScrollEventArgs eventArgs, Point expectedItem1Location, Point expectedItem2Location)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStrip
-        {
-            Size = new Size(400, 500)
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        Rectangle oldBounds1 = item1.Bounds;
-        Rectangle oldBounds2 = item2.Bounds;
-        control.OnScroll(eventArgs);
-        Assert.Equal(new Rectangle(expectedItem1Location, oldBounds1.Size), item1.Bounds);
-        Assert.Equal(new Rectangle(expectedItem2Location, oldBounds2.Size), item2.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnScroll_WithItemsWithHandle_TestData()
-    {
-        int x = Application.UseVisualStyles ? 9 : 7;
-
-        foreach (ScrollEventType scrollEventType in Enum.GetValues(typeof(ScrollEventType)))
-        {
-            if (scrollEventType == ScrollEventType.ThumbTrack)
-            {
-                break;
-            }
-
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 100, 200), new Point(x, 101), new Point(0, 100), 1 };
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 200, 100), new Point(x, -99), new Point(0, -100), 1 };
-            yield return new object[] { new ScrollEventArgs(scrollEventType, 100, 100), new Point(x, 1), new Point(0, 0), 0 };
-        }
-
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 100, 200), new Point(x, 1), new Point(0, 0), 0 };
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 200, 100), new Point(x, 1), new Point(0, 0), 0 };
-        yield return new object[] { new ScrollEventArgs(ScrollEventType.ThumbTrack, 0, 0), new Point(x, 1), new Point(0, 0), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnScroll_WithItemsWithHandle_TestData))]
-    public void ToolStrip_OnScroll_InvokeWithItemsWithHandle_Success(ScrollEventArgs eventArgs, Point expectedItem1Location, Point expectedItem2Location, int expectedInvalidatedCallCount)
-    {
-        using var item1 = new SubToolStripItem();
-        using var item2 = new SubToolStripItem();
-        using var control = new SubToolStrip
-        {
-            Size = new Size(400, 500)
-        };
-        control.Items.Add(item1);
-        control.Items.Add(item2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        Rectangle oldBounds1 = item1.Bounds;
-        Rectangle oldBounds2 = item2.Bounds;
-        control.OnScroll(eventArgs);
-        Assert.Equal(new Rectangle(expectedItem1Location, oldBounds1.Size), item1.Bounds);
-        Assert.Equal(new Rectangle(expectedItem2Location, oldBounds2.Size), item2.Bounds);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnScroll_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubToolStrip();
-        Assert.Throws<NullReferenceException>(() => control.OnScroll(null));
-    }
-
-    public static IEnumerable<object[]> OnTabStopChanged_TestData()
-    {
-        foreach (bool tabStop in new bool[] { true, false })
-        {
-            yield return new object[] { tabStop, null };
-            yield return new object[] { tabStop, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTabStopChanged_TestData))]
-    public void ToolStrip_OnTabStopChanged_Invoke_CallsTabStopChanged(bool tabStop, EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip
-        {
-            TabStop = tabStop
-        };
-        control.SetStyle(ControlStyles.Selectable, !tabStop);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TabStopChanged += handler;
-        control.OnTabStopChanged(eventArgs);
-        Assert.Equal(tabStop, control.GetStyle(ControlStyles.Selectable));
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.TabStopChanged -= handler;
-        control.OnTabStopChanged(eventArgs);
-        Assert.Equal(tabStop, control.GetStyle(ControlStyles.Selectable));
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnVisibleChanged_TestData()
-    {
-        foreach (bool visible in new bool[] { true, false })
-        {
-            yield return new object[] { visible, null };
-            yield return new object[] { visible, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnVisibleChanged_TestData))]
-    public void ToolStrip_OnVisibleChanged_Invoke_CallsVisibleChanged(bool visible, EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip
-        {
-            Visible = visible
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_OnVisibleChanged_InvokeInDisposing_DoesNotCallVisibleChanged()
-    {
-        using var control = new SubToolStrip();
-        int callCount = 0;
-        control.VisibleChanged += (sender, e) => callCount++;
-
-        int disposedCallCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            control.OnVisibleChanged(EventArgs.Empty);
-            Assert.Equal(1, callCount);
-            disposedCallCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Equal(1, disposedCallCount);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void ToolStrip_OnVisibleChanged_InvokeDisposed_CallsVisibleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubToolStrip();
-        control.Dispose();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.VisibleChanged += handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.OnVisibleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void ToolStrip_ProcessCmdKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubToolStrip();
-        var m = new Message();
-        Assert.False(control.ProcessCmdKey(ref m, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    [InlineData(Keys.Space)]
-    [InlineData(Keys.Control)]
-    [InlineData(Keys.Tab)]
-    [InlineData(Keys.Control & Keys.Tab)]
-    public void ToolStrip_ProcessCmdKey_InvokeWithParent_ReturnsFalse(Keys keyData)
-    {
-        using var parent = new Control();
-        using var control = new SubToolStrip
-        {
-            Parent = parent
-        };
-        var msg = new Message();
-        Assert.False(control.ProcessCmdKey(ref msg, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    [InlineData(Keys.Space, true)]
-    [InlineData(Keys.Space, false)]
-    [InlineData(Keys.Control, true)]
-    [InlineData(Keys.Control, false)]
-    [InlineData(Keys.Tab, true)]
-    [InlineData(Keys.Tab, false)]
-    [InlineData(Keys.Control & Keys.Tab, true)]
-    [InlineData(Keys.Control & Keys.Tab, false)]
-    public void ToolStrip_ProcessCmdKey_InvokeWithCustomParent_ReturnsExpected(Keys keyData, bool result)
-    {
-        using var control = new SubToolStrip();
-        var msg = new Message
-        {
-            Msg = 1
-        };
-        int callCount = 0;
-        bool action(Message actualMsg, Keys actualKeyData)
-        {
-            Assert.Equal(1, actualMsg.Msg);
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = action
-        };
-        control.Parent = parent;
-
-        Assert.Equal(result, control.ProcessCmdKey(ref msg, keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void ToolStrip_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubToolStrip();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetItemLocation_TestData()
-    {
-        yield return new object[] { new Point(1, 0), 1 };
-        yield return new object[] { new Point(0, 2), 1 };
-        yield return new object[] { new Point(1, 2), 1 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(0, 0), 0 };
-        yield return new object[] { new Point(1, 2), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetItemLocation_TestData))]
-    public void ToolStrip_SetItemLocation_Invoke_GetReturnsExpected(Point location, int expectedLocationChangedCallCount)
-    {
-        using var control = new SubToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = control
-        };
-        int controlLayoutCallCount = 0;
-        void controlHandler(object sender, LayoutEventArgs e) => controlLayoutCallCount++;
-        control.Layout += controlHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            Rectangle oldBounds = item.Bounds;
-            control.SetItemLocation(item, location);
-            Assert.Equal(new Rectangle(location, oldBounds.Size), item.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, controlLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.SetItemLocation(item, location);
-            Assert.Equal(new Rectangle(location, oldBounds.Size), item.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, controlLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Layout -= controlHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetItemLocation_TestData))]
-    public void ToolStrip_SetItemLocation_InvokeWithHandle_GetReturnsExpected(Point location, int expectedLocationChangedCallCount)
-    {
-        using var control = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = control
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int controlLayoutCallCount = 0;
-        void controlHandler(object sender, LayoutEventArgs e) => controlLayoutCallCount++;
-        control.Layout += controlHandler;
-        int locationChangedCallCount = 0;
-        item.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(item, sender);
-            Assert.Same(EventArgs.Empty, e);
-            locationChangedCallCount++;
-        };
-
-        try
-        {
-            Rectangle oldBounds = item.Bounds;
-            control.SetItemLocation(item, location);
-            Assert.Equal(new Rectangle(location, oldBounds.Size), item.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, controlLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.SetItemLocation(item, location);
-            Assert.Equal(new Rectangle(location, oldBounds.Size), item.Bounds);
-            Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-            Assert.Equal(0, controlLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-        finally
-        {
-            control.Layout -= controlHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_SetItemLocation_NullItem_ThrowsArgumentNullException()
-    {
-        using var control = new SubToolStrip();
-        Assert.Throws<ArgumentNullException>("item", () => control.SetItemLocation(null, Point.Empty));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_SetItemLocation_ItemHasNoOwner_ThrowsNotSupportedException()
-    {
-        using var control = new SubToolStrip();
-        using var item = new SubToolStripItem();
-        Assert.Throws<NotSupportedException>(() => control.SetItemLocation(item, Point.Empty));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_SetItemLocation_ItemHasDifferentOwner_ThrowsNotSupportedException()
-    {
-        using var control = new SubToolStrip();
-        using var otherControl = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Owner = otherControl
-        };
-        Assert.Throws<NotSupportedException>(() => control.SetItemLocation(item, Point.Empty));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_SetItemLocation_ItemHasSameParent_ThrowsNotSupportedException()
-    {
-        using var control = new SubToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = control
-        };
-        Assert.Throws<NotSupportedException>(() => control.SetItemLocation(item, Point.Empty));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_SetItemLocation_ItemHasDifferentParent_ThrowsNotSupportedException()
-    {
-        using var control = new SubToolStrip();
-        using var otherControl = new ToolStrip();
-        using var item = new SubToolStripItem
-        {
-            Parent = otherControl
-        };
-        Assert.Throws<NotSupportedException>(() => control.SetItemLocation(item, Point.Empty));
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_WndProc_InvokeMouseActivate_Success()
-    {
-        using var control = new SubToolStrip();
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEACTIVATE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_WndProc_InvokeMouseActivateWithHandle_Success()
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEACTIVATE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubToolStrip();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_KeyboardAccelerators_ReturnsExpected()
-    {
-        using SubToolStripDropDown toolStrip = new();
-        bool result = true;
-
-        // it needs for correct work of Control.CanProcessMnemonic method
-        toolStrip.Enabled = true;
-        toolStrip.Visible = true;
-
-        result &= !toolStrip.ProcessDialogChar('F');
-        toolStrip.DisplayedItems.Add("&First item");
-        toolStrip.DisplayedItems.Add("&Second item");
-        toolStrip.DisplayedItems.Add("Third item");
-
-        // it needs for correct work of Control.CanProcessMnemonic method
-        toolStrip.Visible = true;
-        result &= toolStrip.ProcessDialogChar('F');
-        result &= toolStrip.ProcessDialogChar('S');
-        result &= !toolStrip.ProcessDialogChar('T');
-
-        Assert.True(result);
-    }
-
-    [WinFormsTheory]
-    [InlineData("ScrollButtonDown", 96, 16)]
-    [InlineData("ScrollButtonDown", 120, 24)]
-    [InlineData("ScrollButtonDown", 144, 24)]
-    [InlineData("ScrollButtonDown", 168, 32)]
-    [InlineData("ScrollButtonDown", 288, 48)]
-    [InlineData("ScrollButtonUp", 96, 16)]
-    [InlineData("ScrollButtonUp", 120, 24)]
-    [InlineData("ScrollButtonUp", 144, 24)]
-    [InlineData("ScrollButtonUp", 168, 32)]
-    [InlineData("ScrollButtonUp", 288, 48)]
-    public void ToolStripScrollButton_Arrows_Size_ReturnsExpected(string resourceName, int dpi, int expectedSide)
-    {
-        Type toolStripScrollButtonType = typeof(ToolStripScrollButton);
-        var accessor = typeof(DpiHelper).TestAccessor();
-        Size defaultSize = new(16, 16);
-        int oldDeviceDpi = DpiHelper.DeviceDpi;
-        DpiTestData dpiTestData = new()
-        {
-            ResourceName = resourceName,
-            Dpi = dpi,
-            ExpectedSide = expectedSide,
-        };
-
-        try
-        {
-            accessor.Dynamic.DeviceDpi = dpiTestData.Dpi;
-            Bitmap bitmap = DpiHelper.GetScaledBitmapFromIcon(toolStripScrollButtonType, dpiTestData.ResourceName, defaultSize);
-            Assert.Equal(dpiTestData.ExpectedSide, bitmap.Width);
-            Assert.Equal(dpiTestData.ExpectedSide, bitmap.Height);
-        }
-        finally
-        {
-            accessor.Dynamic.DeviceDpi = oldDeviceDpi;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(ToolStripLayoutStyle.Flow, true, ToolStripGripStyle.Visible)]
-    [InlineData(ToolStripLayoutStyle.HorizontalStackWithOverflow, true, ToolStripGripStyle.Visible)]
-    [InlineData(ToolStripLayoutStyle.StackWithOverflow, true, ToolStripGripStyle.Visible)]
-    [InlineData(ToolStripLayoutStyle.Table, true, ToolStripGripStyle.Visible)]
-    [InlineData(ToolStripLayoutStyle.VerticalStackWithOverflow, true, ToolStripGripStyle.Visible)]
-    [InlineData(ToolStripLayoutStyle.Flow, true, ToolStripGripStyle.Hidden)]
-    [InlineData(ToolStripLayoutStyle.HorizontalStackWithOverflow, true, ToolStripGripStyle.Hidden)]
-    [InlineData(ToolStripLayoutStyle.StackWithOverflow, true, ToolStripGripStyle.Hidden)]
-    [InlineData(ToolStripLayoutStyle.Table, true, ToolStripGripStyle.Hidden)]
-    [InlineData(ToolStripLayoutStyle.VerticalStackWithOverflow, true, ToolStripGripStyle.Hidden)]
-    public void ToolStrip_GetNextItem_ItemsBackwardExpected(ToolStripLayoutStyle toolStripLayoutStyle, bool tabStop, ToolStripGripStyle gripStyle)
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/9181,https://github.com/dotnet/winforms/issues/9438
-        // and it verifies that setting TabStop=true,
-        // When typing Right arrow keyboard, the next focus position is first item on the left.
-        // When typing Left arrow keyboard, the next focus position is first item on the Right.
-
-        using ToolStrip toolStrip = new() { LayoutStyle = toolStripLayoutStyle, TabStop = tabStop, GripStyle = gripStyle };
-        using ToolStripMenuItem toolStripMenuItem1 = new();
-        using ToolStripMenuItem toolStripMenuItem2 = new();
-        using ToolStripMenuItem toolStripMenuItem3 = new();
-        toolStrip.Items.AddRange(new ToolStripItem[] { toolStripMenuItem1, toolStripMenuItem2, toolStripMenuItem3 });
-
-        toolStrip.TestAccessor().Dynamic.LastKeyData = Keys.Left;
-        ToolStripItem previousToolStripItem1 = toolStrip.GetNextItem(start: null, ArrowDirection.Left);
-        Assert.Equal(toolStrip.Items[2], previousToolStripItem1);
-
-        ToolStripItem previousToolStripItem2 = toolStrip.GetNextItem(start: null, ArrowDirection.Right);
-        Assert.Equal(toolStrip.Items[0], previousToolStripItem2);
-
-        Assert.False(toolStrip.IsHandleCreated);
-    }
-
-    private class SubAxHost : AxHost
-    {
-        public SubAxHost(string clsid) : base(clsid)
-        {
-        }
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<char, bool> ProcessDialogCharAction { get; set; }
-
-        protected override bool ProcessDialogChar(char charCode) => ProcessDialogCharAction(charCode);
-    }
-
-    private class SubToolStripItem : ToolStripItem
-    {
-        public event LayoutEventHandler Layout;
-
-        protected internal override void OnLayout(LayoutEventArgs e)
-        {
-            Layout?.Invoke(this, e);
-            base.OnLayout(e);
-        }
-    }
-
-    private class DpiTestData
-    {
-        public string ResourceName { get; set; }
-
-        public int Dpi { get; set; }
-
-        public int ExpectedSide { get; set; }
-    }
-
-    private class SubToolStripDropDown : ToolStripDropDown
-    {
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool ProcessDialogChar(char charCode) => base.ProcessDialogChar(charCode);
-    }
-
-    private class SubToolStrip : ToolStrip
-    {
-        public new const int ScrollStateAutoScrolling = ToolStrip.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = ToolStrip.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = ToolStrip.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = ToolStrip.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = ToolStrip.ScrollStateFullDrag;
-
-        public SubToolStrip() : base()
-        {
-        }
-
-        public SubToolStrip(ToolStripItem[] items) : base(items)
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new DockStyle DefaultDock => base.DefaultDock;
-
-        public new Padding DefaultGripMargin => base.DefaultGripMargin;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DefaultShowItemToolTips => base.DefaultShowItemToolTips;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new ToolStripItemCollection DisplayedItems => base.DisplayedItems;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new Size MaxItemSize => base.MaxItemSize;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new ControlCollection CreateControlsInstance() => base.CreateControlsInstance();
-
-        public new ToolStripItem CreateDefaultItem(string text, Image image, EventHandler onClick) => base.CreateDefaultItem(text, image, onClick);
-
-        public new LayoutSettings CreateLayoutSettings(ToolStripLayoutStyle layoutStyle) => base.CreateLayoutSettings(layoutStyle);
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsInputChar(char charCode) => base.IsInputChar(charCode);
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnBeginDrag(EventArgs e) => base.OnBeginDrag(e);
-
-        public new void OnControlAdded(ControlEventArgs e) => base.OnControlAdded(e);
-
-        public new void OnControlRemoved(ControlEventArgs e) => base.OnControlRemoved(e);
-
-        public new void OnDockChanged(EventArgs e) => base.OnDockChanged(e);
-
-        public new void OnEnabledChanged(EventArgs e) => base.OnEnabledChanged(e);
-
-        public new void OnEndDrag(EventArgs e) => base.OnEndDrag(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnInvalidated(InvalidateEventArgs e) => base.OnInvalidated(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnLayoutCompleted(EventArgs e) => base.OnLayoutCompleted(e);
-
-        public new void OnLayoutStyleChanged(EventArgs e) => base.OnLayoutStyleChanged(e);
-
-        public new void OnLeave(EventArgs e) => base.OnLeave(e);
-
-        public new void OnLostFocus(EventArgs e) => base.OnLostFocus(e);
-
-        public new void OnMouseCaptureChanged(EventArgs e) => base.OnMouseCaptureChanged(e);
-
-        public new void OnMouseDown(MouseEventArgs mea) => base.OnMouseDown(mea);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs mea) => base.OnMouseMove(mea);
-
-        public new void OnMouseUp(MouseEventArgs mea) => base.OnMouseUp(mea);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnPaintBackground(PaintEventArgs e) => base.OnPaintBackground(e);
-
-        public new void OnPaintGrip(PaintEventArgs e) => base.OnPaintGrip(e);
-
-        public new void OnRightToLeftChanged(EventArgs e) => base.OnRightToLeftChanged(e);
-
-        public new void OnScroll(ScrollEventArgs se) => base.OnScroll(se);
-
-        public new void OnTabStopChanged(EventArgs e) => base.OnTabStopChanged(e);
-
-        public new void OnVisibleChanged(EventArgs e) => base.OnVisibleChanged(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void Select(bool directed, bool forward) => base.Select(directed, forward);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetDisplayedItems() => base.SetDisplayedItems();
-
-        public new void SetItemLocation(ToolStripItem item, Point location) => base.SetItemLocation(item, location);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void SetVisibleCore(bool visible) => base.SetVisibleCore(visible);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxAccessibleObjectTests.cs
deleted file mode 100644
index 5d002d7fbd1..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxAccessibleObjectTests.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripTextBox_ToolStripTextBoxAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripTextBoxAccessibleObject_GetPropertyValue_Custom_Name_ReturnsExpected()
-    {
-        using var toolStripTextBox = new ToolStripTextBox()
-        {
-            Name = "Name1",
-            AccessibleName = "Test Name"
-        };
-
-        AccessibleObject toolStripTextBoxAccessibleObject = toolStripTextBox.AccessibilityObject;
-        var accessibleName = toolStripTextBoxAccessibleObject.GetPropertyValue(UIA.NamePropertyId);
-
-        Assert.Equal("Test Name", accessibleName);
-    }
-
-    [WinFormsFact]
-    public void ToolStripTextBoxAccessibleObject_IsPatternSupported_LegacyIAccessible_ReturnsTrue()
-    {
-        using var toolStripTextBox = new ToolStripTextBox();
-        AccessibleObject toolStripTextBoxAccessibleObject = toolStripTextBox.AccessibilityObject;
-
-        bool supportsLegacyIAccessiblePatternId = toolStripTextBoxAccessibleObject.IsPatternSupported(UIA.LegacyIAccessiblePatternId);
-
-        Assert.True(supportsLegacyIAccessiblePatternId);
-    }
-
-    [WinFormsFact]
-    public void ToolStripTextBoxAccessibleObject_LegacyIAccessible_Custom_Role_ReturnsExpected()
-    {
-        using var toolStripTextBox = new ToolStripTextBox()
-        {
-            AccessibleRole = AccessibleRole.Link
-        };
-
-        AccessibleObject toolStripTextBoxAccessibleObject = toolStripTextBox.AccessibilityObject;
-        var accessibleObjectRole = toolStripTextBoxAccessibleObject.Role;
-
-        Assert.Equal(AccessibleRole.Link, accessibleObjectRole);
-    }
-
-    [WinFormsFact]
-    public void ToolStripTextBoxAccessibleObject_LegacyIAccessible_Custom_Description_ReturnsExpected()
-    {
-        using var toolStripTextBox = new ToolStripTextBox()
-        {
-            AccessibleDescription = "Test Description"
-        };
-
-        AccessibleObject toolStripTextBoxAccessibleObject = toolStripTextBox.AccessibilityObject;
-        var accessibleObjectDescription = toolStripTextBoxAccessibleObject.Description;
-
-        Assert.Equal("Test Description", accessibleObjectDescription);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControlAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControlAccessibleObjectTests.cs
deleted file mode 100644
index 0029f8c5207..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolStripTextBox.ToolStripTextBoxControlAccessibleObjectTests.cs
+++ /dev/null
@@ -1,140 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Reflection;
-using static System.Windows.Forms.Control;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripTextBox_ToolStripTextBoxControlAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void ToolStripTextBoxControlAccessibleObject_ctor_default()
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        TextBox textBox = toolStripTextBox.TextBox;
-        Type type = toolStripTextBox.GetType().GetNestedType("ToolStripTextBoxControlAccessibleObject", BindingFlags.NonPublic);
-        Assert.NotNull(type);
-        ControlAccessibleObject accessibleObject = (ControlAccessibleObject)Activator.CreateInstance(type, textBox);
-        Assert.Equal(textBox, accessibleObject.Owner);
-    }
-
-    [WinFormsFact]
-    public void ToolStripTextBoxControlAccessibleObject_ctor_ThrowsException_IfOwnerIsNull()
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        TextBox textBox = toolStripTextBox.TextBox;
-        Type type = toolStripTextBox.GetType().GetNestedType("ToolStripTextBoxControlAccessibleObject", BindingFlags.NonPublic);
-        Assert.NotNull(type);
-        Assert.Throws<TargetInvocationException>(() => Activator.CreateInstance(type, (Control)null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ToolStripTextBoxControlAccessibleObject_IsReadOnly_IsExpected(bool readOnly)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        TextBox textBox = toolStripTextBox.TextBox;
-        textBox.ReadOnly = readOnly;
-        AccessibleObject accessibleObject = textBox.AccessibilityObject;
-        Assert.Equal(readOnly, accessibleObject.IsReadOnly);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsValuePatternAvailablePropertyId)]
-    public void ToolStripTextBoxControlAccessibleObject_GetPropertyValue_PatternsSuported(int propertyID)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        TextBox textBox = toolStripTextBox.TextBox;
-        AccessibleObject accessibleObject = textBox.AccessibilityObject;
-        Assert.True((bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyID));
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ValuePatternId)]
-    [InlineData((int)UiaCore.UIA.TextPatternId)]
-    [InlineData((int)UiaCore.UIA.TextPattern2Id)]
-    public void ToolStripTextBoxControlAccessibleObject_IsPatternSupported_PatternsSuported(int patternId)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        TextBox textBox = toolStripTextBox.TextBox;
-        AccessibleObject accessibleObject = textBox.AccessibilityObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, (int)UiaCore.UIA.EditControlTypeId)]
-    [InlineData(false, (int)UiaCore.UIA.PaneControlTypeId)]
-    public void ToolStripTextBoxControlAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool createControl, int expectedType)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        // AccessibleRole is not set = Default
-        TextBox toolStripTextBoxControl = toolStripTextBox.TextBox;
-
-        if (createControl)
-        {
-            toolStripTextBoxControl.CreateControl();
-        }
-
-        object actual = toolStripTextBox.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-        Assert.Equal(createControl, toolStripTextBoxControl.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text)]
-    [InlineData(false, AccessibleRole.None)]
-    public void ToolStripTextBoxControlAccessibleObject_Default_Role_IsExpected(bool createControl, AccessibleRole expectedRole)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        // AccessibleRole is not set = Default
-        TextBox toolStripTextBoxControl = toolStripTextBox.TextBox;
-
-        if (createControl)
-        {
-            toolStripTextBoxControl.CreateControl();
-        }
-
-        object actual = toolStripTextBox.AccessibilityObject.Role;
-
-        Assert.Equal(expectedRole, actual);
-        Assert.Equal(createControl, toolStripTextBoxControl.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ToolStripTextBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ToolStripTextBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void ToolStripTextBoxControlAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using ToolStripTextBox toolStripTextBox = new ToolStripTextBox();
-        toolStripTextBox.AccessibleRole = role;
-
-        TextBox toolStripTextBoxControl = toolStripTextBox.TextBox;
-        AccessibleObject accessibleObject = toolStripTextBox.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(role, accessibleObject.Role);
-        Assert.Equal(expected, actual);
-        Assert.False(toolStripTextBoxControl.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipBufferTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipBufferTests.cs
deleted file mode 100644
index fe652c4506c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipBufferTests.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.InteropServices;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class ToolTipBufferTests
-{
-    [WinFormsFact]
-    public void ToolTipBuffer_Buffer_GetEmpty_ReturnsZero()
-    {
-        var buffer = new ToolTipBuffer();
-        Assert.Equal(IntPtr.Zero, buffer.Buffer);
-    }
-
-    [WinFormsFact]
-    public void ToolTipBuffer_SetText_NoBuffer_Success()
-    {
-        var buffer = new ToolTipBuffer();
-        IntPtr memory1 = buffer.Buffer;
-        Assert.Null(Marshal.PtrToStringUni(memory1));
-
-        buffer.SetText("text");
-        IntPtr memory2 = buffer.Buffer;
-        Assert.NotEqual(memory1, memory2);
-        Assert.Equal("text", Marshal.PtrToStringUni(memory2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    public void ToolTipBuffer_SetText_EmptyNoBuffer_Success(string empty)
-    {
-        var buffer = new ToolTipBuffer();
-        IntPtr memory1 = buffer.Buffer;
-        Assert.Null(Marshal.PtrToStringUni(memory1));
-
-        buffer.SetText(empty);
-        IntPtr memory2 = buffer.Buffer;
-        Assert.NotEqual(memory1, memory2);
-        Assert.Empty(Marshal.PtrToStringUni(memory2));
-    }
-
-    [WinFormsTheory]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void ToolTipBuffer_SetTextLonger_Success(string longer)
-    {
-        var buffer = new ToolTipBuffer();
-        buffer.SetText("text");
-        IntPtr memory1 = buffer.Buffer;
-        Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer));
-
-        // Set longer.
-        buffer.SetText(longer);
-        IntPtr memory2 = buffer.Buffer;
-        Assert.NotEqual(IntPtr.Zero, memory2);
-        Assert.Equal(longer, Marshal.PtrToStringUni(memory2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("a", "a")]
-    [InlineData("ab", "ab")]
-    [InlineData("abc", "abc")]
-    public void ToolTipBuffer_SetTextShorter_Success(string shorter, string expected)
-    {
-        var buffer = new ToolTipBuffer();
-        buffer.SetText("text");
-        IntPtr memory1 = buffer.Buffer;
-        Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer));
-
-        // Set longer.
-        buffer.SetText(shorter);
-        IntPtr memory2 = buffer.Buffer;
-        Assert.Equal(memory1, memory2);
-        Assert.Equal(expected, Marshal.PtrToStringUni(memory2));
-    }
-
-    [WinFormsTheory]
-    [InlineData("text")]
-    [InlineData("abcd")]
-    public void ToolTipBuffer_SetTextSameLength_Success(string sameLength)
-    {
-        var buffer = new ToolTipBuffer();
-        buffer.SetText("text");
-        IntPtr memory1 = buffer.Buffer;
-        Assert.Equal("text", Marshal.PtrToStringUni(buffer.Buffer));
-
-        // Set longer.
-        buffer.SetText(sameLength);
-        IntPtr memory2 = buffer.Buffer;
-        Assert.Equal(memory1, memory2);
-        Assert.Equal(sameLength, Marshal.PtrToStringUni(memory2));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipTests.cs
deleted file mode 100644
index b59b4827086..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/ToolTipTests.cs
+++ /dev/null
@@ -1,927 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using Moq.Protected;
-using System.Windows.Forms.Automation;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolTipTests
-{
-    [WinFormsFact]
-    public void ToolTip_Ctor_Default()
-    {
-        using var toolTip = new SubToolTip();
-        Assert.True(toolTip.Active);
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(SystemColors.Info, toolTip.BackColor);
-        Assert.True(toolTip.CanRaiseEvents);
-        Assert.Null(toolTip.Container);
-        Assert.False(toolTip.DesignMode);
-        Assert.NotNull(toolTip.Events);
-        Assert.Same(toolTip.Events, toolTip.Events);
-        Assert.Equal(SystemColors.InfoText, toolTip.ForeColor);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.False(toolTip.IsBalloon);
-        Assert.False(toolTip.OwnerDraw);
-        Assert.Equal(100, toolTip.ReshowDelay);
-        Assert.False(toolTip.ShowAlways);
-        Assert.Null(toolTip.Site);
-        Assert.False(toolTip.StripAmpersands);
-        Assert.Null(toolTip.Tag);
-        Assert.Equal(ToolTipIcon.None, toolTip.ToolTipIcon);
-        Assert.Empty(toolTip.ToolTipTitle);
-        Assert.True(toolTip.UseAnimation);
-        Assert.True(toolTip.UseFading);
-        Assert.False(toolTip.GetHandleCreated());
-    }
-
-    [WinFormsFact]
-    public void Ctor_IContainer_TestData()
-    {
-        using var container = new Container();
-        using var toolTip = new SubToolTip(container);
-        Assert.True(toolTip.Active);
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(SystemColors.Info, toolTip.BackColor);
-        Assert.True(toolTip.CanRaiseEvents);
-        Assert.Same(container, toolTip.Container);
-        Assert.False(toolTip.DesignMode);
-        Assert.NotNull(toolTip.Events);
-        Assert.Same(toolTip.Events, toolTip.Events);
-        Assert.Equal(SystemColors.InfoText, toolTip.ForeColor);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.False(toolTip.IsBalloon);
-        Assert.False(toolTip.OwnerDraw);
-        Assert.Equal(100, toolTip.ReshowDelay);
-        Assert.False(toolTip.ShowAlways);
-        Assert.NotNull(toolTip.Site);
-        Assert.False(toolTip.StripAmpersands);
-        Assert.Null(toolTip.Tag);
-        Assert.Equal(ToolTipIcon.None, toolTip.ToolTipIcon);
-        Assert.Empty(toolTip.ToolTipTitle);
-        Assert.True(toolTip.UseAnimation);
-        Assert.True(toolTip.UseFading);
-        Assert.False(toolTip.GetHandleCreated());
-    }
-
-    [WinFormsFact]
-    public void ToolTip_Ctor_NullCont_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("cont", () => new ToolTip(null));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var toolTip = new SubToolTip();
-        CreateParams createParams = toolTip.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("tooltips_class32", createParams.ClassName);
-        Assert.Equal(0, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(0, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x2, createParams.Style);
-        Assert.Equal(0, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.NotSame(createParams, toolTip.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_Active_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            Active = value
-        };
-        Assert.Equal(value, toolTip.Active);
-
-        // Set same
-        toolTip.Active = value;
-        Assert.Equal(value, toolTip.Active);
-
-        // Set different
-        toolTip.Active = !value;
-        Assert.Equal(!value, toolTip.Active);
-        Assert.False(toolTip.GetHandleCreated());
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_Active_SetDesignMode_GetReturnsExpected(bool value)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var toolTip = new ToolTip
-        {
-            Site = mockSite.Object,
-            Active = value
-        };
-        Assert.Equal(value, toolTip.Active);
-
-        // Set same
-        toolTip.Active = value;
-        Assert.Equal(value, toolTip.Active);
-
-        // Set different
-        toolTip.Active = !value;
-        Assert.Equal(!value, toolTip.Active);
-        Assert.False(toolTip.GetHandleCreated());
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict.
-        // All invocations on the mock must have a corresponding setup.
-        toolTip.Site = null;
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0, 0)]
-    [InlineData(1, 10, 0)]
-    [InlineData(2, 20, 0)]
-    [InlineData(100, 1000, 20)]
-    [InlineData(500, 5000, 100)]
-    [InlineData(5000, 50000, 1000)]
-    public void ToolTip_AutomaticDelay_Set_GetReturnsExpected(int value, int expectedAutoPopDelay, int expectedReshowDelay)
-    {
-        using var toolTip = new ToolTip
-        {
-            InitialDelay = 80,
-            AutoPopDelay = 70,
-            ReshowDelay = 60,
-            AutomaticDelay = value
-        };
-        Assert.Equal(value, toolTip.AutomaticDelay);
-        Assert.Equal(expectedAutoPopDelay, toolTip.AutoPopDelay);
-        Assert.Equal(value, toolTip.InitialDelay);
-        Assert.Equal(expectedReshowDelay, toolTip.ReshowDelay);
-
-        // Set same
-        toolTip.InitialDelay = 80;
-        toolTip.AutoPopDelay = 70;
-        toolTip.ReshowDelay = 60;
-        toolTip.AutomaticDelay = value;
-        Assert.Equal(value, toolTip.AutomaticDelay);
-        Assert.Equal(expectedAutoPopDelay, toolTip.AutoPopDelay);
-        Assert.Equal(value, toolTip.InitialDelay);
-        Assert.Equal(expectedReshowDelay, toolTip.ReshowDelay);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_AutomaticDelay_ShouldSerialize_ReturnsExpected()
-    {
-        using var toolTip = new ToolTip();
-
-        var properties = TypeDescriptor.GetProperties(typeof(ToolTip));
-        PropertyDescriptor automaticProperty = properties[nameof(ToolTip.AutomaticDelay)];
-        PropertyDescriptor initialProperty = properties[nameof(ToolTip.InitialDelay)];
-        PropertyDescriptor reshowProperty = properties[nameof(ToolTip.ReshowDelay)];
-        PropertyDescriptor autoPopProperty = properties[nameof(ToolTip.AutoPopDelay)];
-
-        // No delays were set, thus we have nothing to serialize.
-        Assert.False(automaticProperty.ShouldSerializeValue(toolTip));
-        Assert.False(initialProperty.ShouldSerializeValue(toolTip));
-        Assert.False(reshowProperty.ShouldSerializeValue(toolTip));
-        Assert.False(autoPopProperty.ShouldSerializeValue(toolTip));
-
-        toolTip.AutomaticDelay = toolTip.AutomaticDelay;
-
-        // No delays were were changed compared to the defaultvalues, thus we have nothing to serialize.
-        Assert.False(automaticProperty.ShouldSerializeValue(toolTip));
-        Assert.False(initialProperty.ShouldSerializeValue(toolTip));
-        Assert.False(reshowProperty.ShouldSerializeValue(toolTip));
-        Assert.False(autoPopProperty.ShouldSerializeValue(toolTip));
-
-        toolTip.AutomaticDelay = 0;
-
-        // Automatic delay will be used to calculate all other delays, thus it is the only one to serialize.
-        Assert.True(automaticProperty.ShouldSerializeValue(toolTip));
-        Assert.False(initialProperty.ShouldSerializeValue(toolTip));
-        Assert.False(reshowProperty.ShouldSerializeValue(toolTip));
-        Assert.False(autoPopProperty.ShouldSerializeValue(toolTip));
-
-        toolTip.InitialDelay = 10;
-
-        // Serializing all delays because we ignore automatic delay at least in a single case.
-        Assert.True(automaticProperty.ShouldSerializeValue(toolTip));
-        Assert.True(initialProperty.ShouldSerializeValue(toolTip));
-        Assert.True(reshowProperty.ShouldSerializeValue(toolTip));
-        Assert.True(autoPopProperty.ShouldSerializeValue(toolTip));
-
-        Assert.False(toolTip.GetHandleCreated());
-    }
-
-    [WinFormsFact]
-    public void ToolTip_AutomaticDelay_SetNegativeValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => toolTip.AutomaticDelay = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(100)]
-    [InlineData(500)]
-    [InlineData(5000)]
-    public void ToolTip_AutoPopDelay_Set_GetReturnsExpected(int value)
-    {
-        using var toolTip = new ToolTip
-        {
-            AutoPopDelay = value
-        };
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(value, toolTip.AutoPopDelay);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.Equal(100, toolTip.ReshowDelay);
-
-        // Set same
-        toolTip.AutoPopDelay = value;
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(value, toolTip.AutoPopDelay);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.Equal(100, toolTip.ReshowDelay);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_AutoPopDelay_ShouldSerialize_ReturnsExpected()
-    {
-        using var toolTip = new ToolTip();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolTip))[nameof(ToolTip.AutoPopDelay)];
-        Assert.False(property.ShouldSerializeValue(toolTip));
-
-        toolTip.AutoPopDelay = toolTip.AutoPopDelay;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-
-        toolTip.AutoPopDelay = 0;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_AutoPopDelay_SetNegativeValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => toolTip.AutoPopDelay = -1);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void ToolTip_BackColor_Set_GetReturnsExpected(Color value)
-    {
-        using var toolTip = new ToolTip
-        {
-            BackColor = value
-        };
-        Assert.Equal(value, toolTip.BackColor);
-
-        // Set same.
-        toolTip.BackColor = value;
-        Assert.Equal(value, toolTip.BackColor);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_IsPersistent_Get_ReturnsExpected()
-    {
-        bool persistentToolTipSupported = OsVersion.IsWindows11_OrGreater();
-
-        using var toolTip = new ToolTip();
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-
-        _ = toolTip.Handle;
-
-        toolTip.AutomaticDelay = toolTip.AutomaticDelay;
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-
-        toolTip.AutoPopDelay = 0x7FFF;
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-
-        toolTip.AutoPopDelay = toolTip.AutoPopDelay;
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-
-        toolTip.ReshowDelay = 30;
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_IsPersistent_Get_ReturnsExpected_AutoPopChanged()
-    {
-        bool persistentToolTipSupported = OsVersion.IsWindows11_OrGreater();
-
-        using var toolTip = new ToolTip();
-        // IsPersistent is not set until the tooltip window is created.
-        toolTip.AutoPopDelay = 30;
-        Assert.Equal(persistentToolTipSupported, toolTip.IsPersistent);
-
-        _ = toolTip.Handle;
-        Assert.False(toolTip.IsPersistent);
-
-        // We can not make tooltip persistent again programmatically.
-        toolTip.AutomaticDelay = toolTip.AutomaticDelay;
-        Assert.False(toolTip.IsPersistent);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorTheoryData))]
-    public void ToolTip_ForeColor_Set_GetReturnsExpected(Color value)
-    {
-        using var toolTip = new ToolTip
-        {
-            ForeColor = value
-        };
-        Assert.Equal(value, toolTip.ForeColor);
-
-        // Set same.
-        toolTip.ForeColor = value;
-        Assert.Equal(value, toolTip.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_ForeColor_SetEmpty_ThrowsArgumentException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentException>("value", () => toolTip.ForeColor = Color.Empty);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(100)]
-    [InlineData(500)]
-    [InlineData(5000)]
-    public void ToolTip_InitialDelay_Set_GetReturnsExpected(int value)
-    {
-        using var toolTip = new ToolTip
-        {
-            InitialDelay = value
-        };
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(value, toolTip.InitialDelay);
-        Assert.Equal(100, toolTip.ReshowDelay);
-
-        // Set same
-        toolTip.InitialDelay = value;
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(value, toolTip.InitialDelay);
-        Assert.Equal(100, toolTip.ReshowDelay);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_InitialDelay_ShouldSerialize_ReturnsExpected()
-    {
-        using var toolTip = new ToolTip();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolTip))[nameof(ToolTip.InitialDelay)];
-        Assert.False(property.ShouldSerializeValue(toolTip));
-
-        toolTip.InitialDelay = toolTip.InitialDelay;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-
-        toolTip.InitialDelay = 0;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_InitialDelay_SetNegativeValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => toolTip.InitialDelay = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_IsBalloon_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            IsBalloon = value
-        };
-        Assert.Equal(value, toolTip.IsBalloon);
-
-        // Set same
-        toolTip.IsBalloon = value;
-        Assert.Equal(value, toolTip.IsBalloon);
-
-        // Set different
-        toolTip.IsBalloon = !value;
-        Assert.Equal(!value, toolTip.IsBalloon);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_OwnerDraw_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            OwnerDraw = value
-        };
-        Assert.Equal(value, toolTip.OwnerDraw);
-
-        // Set same
-        toolTip.OwnerDraw = value;
-        Assert.Equal(value, toolTip.OwnerDraw);
-
-        // Set different
-        toolTip.OwnerDraw = !value;
-        Assert.Equal(!value, toolTip.OwnerDraw);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(100)]
-    [InlineData(500)]
-    [InlineData(5000)]
-    public void ToolTip_ReshowDelay_Set_GetReturnsExpected(int value)
-    {
-        using var toolTip = new ToolTip
-        {
-            ReshowDelay = value
-        };
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.Equal(value, toolTip.ReshowDelay);
-
-        // Set same
-        toolTip.ReshowDelay = value;
-        Assert.Equal(500, toolTip.AutomaticDelay);
-        Assert.Equal(5000, toolTip.AutoPopDelay);
-        Assert.Equal(500, toolTip.InitialDelay);
-        Assert.Equal(value, toolTip.ReshowDelay);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_ReshowDelay_ShouldSerialize_ReturnsExpected()
-    {
-        using var toolTip = new ToolTip();
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(ToolTip))[nameof(ToolTip.ReshowDelay)];
-        Assert.False(property.ShouldSerializeValue(toolTip));
-
-        toolTip.ReshowDelay = toolTip.ReshowDelay;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-
-        toolTip.ReshowDelay = 0;
-        Assert.True(property.ShouldSerializeValue(toolTip));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_ReshowDelay_SetNegativeValue_ThrowsArgumentOutOfRangeException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => toolTip.ReshowDelay = -1);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_ShowAlways_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            ShowAlways = value
-        };
-        Assert.Equal(value, toolTip.ShowAlways);
-
-        // Set same
-        toolTip.ShowAlways = value;
-        Assert.Equal(value, toolTip.ShowAlways);
-
-        // Set different
-        toolTip.ShowAlways = !value;
-        Assert.Equal(!value, toolTip.ShowAlways);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_StripAmpersands_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            StripAmpersands = value
-        };
-        Assert.Equal(value, toolTip.StripAmpersands);
-
-        // Set same
-        toolTip.StripAmpersands = value;
-        Assert.Equal(value, toolTip.StripAmpersands);
-
-        // Set different
-        toolTip.StripAmpersands = !value;
-        Assert.Equal(!value, toolTip.StripAmpersands);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolTip_Tag_Set_GetReturnsExpected(object value)
-    {
-        using var toolTip = new ToolTip
-        {
-            Tag = value
-        };
-        Assert.Same(value, toolTip.Tag);
-
-        // Set same
-        toolTip.Tag = value;
-        Assert.Same(value, toolTip.Tag);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ToolTipIcon>]
-    public void ToolTip_ToolTipIcon_Set_GetReturnsExpected(ToolTipIcon value)
-    {
-        using var toolTip = new ToolTip
-        {
-            ToolTipIcon = value
-        };
-        Assert.Equal(value, toolTip.ToolTipIcon);
-
-        // Set same
-        toolTip.ToolTipIcon = value;
-        Assert.Equal(value, toolTip.ToolTipIcon);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ToolTipIcon>]
-    public void ToolTip_ToolTipIcon_SetInvalidValue_ThrowsInvalidEnumArgumentException(ToolTipIcon value)
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => toolTip.ToolTipIcon = value);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolTip_ToolTipTitle_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var toolTip = new ToolTip
-        {
-            ToolTipTitle = value
-        };
-        Assert.Equal(expected, toolTip.ToolTipTitle);
-
-        // Set same
-        toolTip.ToolTipTitle = value;
-        Assert.Equal(expected, toolTip.ToolTipTitle);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_UseAnimation_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            UseAnimation = value
-        };
-        Assert.Equal(value, toolTip.UseAnimation);
-
-        // Set same
-        toolTip.UseAnimation = value;
-        Assert.Equal(value, toolTip.UseAnimation);
-
-        // Set different
-        toolTip.UseAnimation = !value;
-        Assert.Equal(!value, toolTip.UseAnimation);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ToolTip_UseFading_Set_GetReturnsExpected(bool value)
-    {
-        using var toolTip = new ToolTip
-        {
-            UseFading = value
-        };
-        Assert.Equal(value, toolTip.UseFading);
-
-        // Set same
-        toolTip.UseFading = value;
-        Assert.Equal(value, toolTip.UseFading);
-
-        // Set different
-        toolTip.UseFading = !value;
-        Assert.Equal(!value, toolTip.UseFading);
-    }
-
-    public static IEnumerable<object[]> CanExtend_TestData()
-    {
-        yield return new object[] { null, false };
-        yield return new object[] { new object(), false };
-        yield return new object[] { new ToolTip(), false };
-        yield return new object[] { new Control(), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanExtend_TestData))]
-    public void ToolTip_CanExtend_Invoke_ReurnsExpected(object target, bool expected)
-    {
-        using var toolTip = new ToolTip();
-        Assert.Equal(expected, toolTip.CanExtend(target));
-    }
-
-    public static IEnumerable<object[]> GetToolTip_NoSuchControl_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Control() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetToolTip_NoSuchControl_TestData))]
-    public void ToolTip_GetToolTip_NoSuchControl_ReturnsEmpty(Control control)
-    {
-        using var toolTip = new ToolTip();
-        Assert.Empty(toolTip.GetToolTip(control));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_RemoveAll_InvokeWithTools_GetToolTipReturnsEmpty()
-    {
-        using var control = new Control();
-        using var toolTip = new ToolTip();
-        toolTip.SetToolTip(control, "caption");
-        toolTip.RemoveAll();
-        Assert.Empty(toolTip.GetToolTip(control));
-
-        toolTip.RemoveAll();
-        Assert.Empty(toolTip.GetToolTip(control));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_RemoveAll_InvokeWithoutTools_Nop()
-    {
-        using var toolTip = new ToolTip();
-        toolTip.RemoveAll();
-        toolTip.RemoveAll();
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolTip_SetToolTip_Invoke_GetToolTipReturnsExpected(string caption, string expected)
-    {
-        using var toolTip = new ToolTip();
-        using var control = new Control();
-        toolTip.SetToolTip(control, caption);
-        Assert.Equal(expected, toolTip.GetToolTip(control));
-
-        // Set same.
-        toolTip.SetToolTip(control, caption);
-        Assert.Equal(expected, toolTip.GetToolTip(control));
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void ToolTip_SetToolTip_InvokeDesignMode_GetToolTipReturnsExpected(string caption, string expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var toolTip = new ToolTip
-        {
-            Site = mockSite.Object
-        };
-        using var control = new Control();
-        toolTip.SetToolTip(control, caption);
-        Assert.Equal(expected, toolTip.GetToolTip(control));
-
-        // Set same.
-        toolTip.SetToolTip(control, caption);
-        Assert.Equal(expected, toolTip.GetToolTip(control));
-
-        // NB: disposing the component with strictly mocked object causes tests to fail
-        // Moq.MockException : ISite.Container invocation failed with mock behavior Strict. All invocations on the mock must have a corresponding setup.
-        toolTip.Site = null;
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolTip_SetToolTip_NullControl_ThrowsArgumentNullException(string caption)
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentNullException>("control", () => toolTip.SetToolTip(null, caption));
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolTip_Show_InvokeStringIWin32WindowControlWindow_Nop(string text)
-    {
-        using var toolTip = new ToolTip();
-        using var control = new Control();
-        toolTip.Show(text, control);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void ToolTip_Show_InvokeStringIWin32WindowNonControlWindow_Nop(string text)
-    {
-        using var toolTip = new ToolTip();
-        var mockWindow = new Mock<IWin32Window>(MockBehavior.Strict);
-        toolTip.Show(text, mockWindow.Object);
-    }
-
-    public static IEnumerable<object[]> Show_StringIWin32WindowInt_TestData()
-    {
-        foreach (int duration in new int[] { 0, 10 })
-        {
-            yield return new object[] { null, duration };
-            yield return new object[] { string.Empty, duration };
-            yield return new object[] { "text", duration };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Show_StringIWin32WindowInt_TestData))]
-    public void ToolTip_Show_InvokeStringIWin32WindowIntControlWindow_Nop(string text, int duration)
-    {
-        using var toolTip = new ToolTip();
-        using var control = new Control();
-        toolTip.Show(text, control, duration);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Show_StringIWin32WindowInt_TestData))]
-    public void ToolTip_Show_InvokeStringIWin32WindowIntNonControlWindow_Nop(string text, int duration)
-    {
-        using var toolTip = new ToolTip();
-        var mockWindow = new Mock<IWin32Window>(MockBehavior.Strict);
-        toolTip.Show(text, mockWindow.Object, duration);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_Show_NullWindow_ThrowsArgumentNullException()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Throws<ArgumentNullException>("window", () => toolTip.Show("text", null));
-        Assert.Throws<ArgumentNullException>("window", () => toolTip.Show("text", null, 1));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_Show_NegativeDuration_ThrowsArgumentOutOfRangeException()
-    {
-        using var toolTip = new ToolTip();
-        var mockWindow = new Mock<IWin32Window>(MockBehavior.Strict);
-        Assert.Throws<ArgumentOutOfRangeException>("duration", () => toolTip.Show("text", mockWindow.Object, -1));
-    }
-
-    [WinFormsFact]
-    public void ToolTip_ToString_Invoke_ReturnsExpected()
-    {
-        using var toolTip = new ToolTip();
-        Assert.Equal("System.Windows.Forms.ToolTip InitialDelay: 500, ShowAlways: False", toolTip.ToString());
-    }
-
-    [WinFormsFact]
-    public void ToolTip_SetToolTipToControl_Invokes_SetToolTip_OfControl()
-    {
-        using ToolTip toolTip = new ToolTip();
-        SubControl control = new SubControl();
-        control.CreateControl();
-
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        toolTip.SetToolTip(control, "Some test text");
-
-        Assert.Equal(1, control.InvokeSetCount);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_RemoveAll_Invokes_RemoveToolTip_OfControl()
-    {
-        using ToolTip toolTip = new ToolTip();
-        using SubControl control = new SubControl();
-
-        // Create a top level control to the toolTip consider
-        // the tested control as created when destroying regions
-        using Control topLevelControl = new Control();
-        topLevelControl.Controls.Add(control);
-        topLevelControl.CreateControl();
-        control.CreateControl();
-
-        Assert.True(toolTip.Handle != IntPtr.Zero); // A workaround to create the toolTip native window Handle
-
-        toolTip.SetToolTip(control, "Some test text");
-        toolTip.RemoveAll();
-
-        Assert.Equal(1, control.InvokeRemoveCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void ToolTip_WmShow_Invokes_AnnounceText_WithExpectedText_ForTabControlTabs()
-    {
-        using NoAssertContext context = new();
-        Mock<TabControl> mockTabControl = new() { CallBase = true, Object = { ShowToolTips = true } };
-        Mock<Control.ControlAccessibleObject> mockAccessibleObject = new(MockBehavior.Strict, mockTabControl.Object);
-        mockAccessibleObject
-            .Setup(a => a.InternalRaiseAutomationNotification(
-                It.IsAny<AutomationNotificationKind>(),
-                It.IsAny<AutomationNotificationProcessing>(),
-                It.IsAny<string>()))
-            .Returns(true);
-        mockTabControl.Protected().Setup<AccessibleObject>("CreateAccessibilityInstance").Returns(mockAccessibleObject.Object);
-
-        // We need a Form because tooltips don't work on controls without a valid parent.
-        using Form form = new();
-        using ToolTip toolTip = new();
-        using TabControl tabControl = mockTabControl.Object;
-        using TabPage tabPage = new() { ToolTipText = "TabPage" };
-
-        toolTip.SetToolTip(tabControl, "TabControl");
-        tabControl.Controls.Add(tabPage);
-        form.Controls.Add(tabControl);
-        form.Show();
-
-        Assert.NotEqual(IntPtr.Zero, tabControl.InternalHandle);
-        Assert.True(toolTip.GetHandleCreated());
-
-        // Enforce AccessibilityObject creation.
-        Assert.Equal(mockAccessibleObject.Object, tabControl.AccessibilityObject);
-
-        // Post MOUSEMOVE to the tooltip queue and then just remove it from the queue without handling.
-        // This will update the point returned by GetMessagePos which is used by PInvoke.TTM_POPUP to determine the tool to display.
-        Assert.True(PInvoke.PostMessage(toolTip, PInvoke.WM_MOUSEMOVE, lParam: PARAM.FromPoint(tabPage.GetToolNativeScreenRectangle().Location)));
-        MSG msg = default;
-        Assert.True(PInvoke.PeekMessage(&msg, toolTip, (uint)PInvoke.WM_MOUSEMOVE, (uint)PInvoke.WM_MOUSEMOVE, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE));
-
-        // Show the tooltip.
-        PInvoke.SendMessage(toolTip, PInvoke.TTM_POPUP);
-
-        mockAccessibleObject.Verify(a => a.InternalRaiseAutomationNotification(
-            AutomationNotificationKind.ActionCompleted,
-            AutomationNotificationProcessing.All,
-            $" {tabPage.ToolTipText}"),
-            Times.Once);
-    }
-
-    [WinFormsFact]
-    public void ToolTip_SetToolTip_TabControl_DoesNotAddToolForTabControlItself()
-    {
-        // We need a Form because tooltips don't work on controls without a valid parent.
-        using Form form = new();
-        using ToolTip toolTip = new();
-        using TabControl tabControl = new() { ShowToolTips = true };
-        using TabPage tabPage1 = new();
-        using TabPage tabPage2 = new();
-
-        toolTip.SetToolTip(tabControl, "Test");
-        tabControl.Controls.Add(tabPage1);
-        tabControl.Controls.Add(tabPage2);
-        form.Controls.Add(tabControl);
-        form.Show();
-
-        Assert.NotEqual(IntPtr.Zero, tabControl.InternalHandle);
-        Assert.True(toolTip.GetHandleCreated());
-
-        // Only tools for TabPages were added.
-        Assert.Equal(tabControl.TabCount, (int)PInvoke.SendMessage(toolTip, PInvoke.TTM_GETTOOLCOUNT));
-    }
-
-    private class SubToolTip : ToolTip
-    {
-        public SubToolTip() : base()
-        {
-        }
-
-        public SubToolTip(IContainer cont) : base(cont)
-        {
-        }
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new EventHandlerList Events => base.Events;
-    }
-
-    private class SubControl : Control
-    {
-        public int InvokeSetCount { get; set; }
-        public int InvokeRemoveCount { get; set; }
-
-        internal override void SetToolTip(ToolTip toolTip)
-        {
-            InvokeSetCount++;
-            base.SetToolTip(toolTip);
-        }
-
-        internal override void RemoveToolTip(ToolTip toolTip)
-        {
-            InvokeRemoveCount++;
-            base.RemoveToolTip(toolTip);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarAccessibleObjectTests.cs
deleted file mode 100644
index e8042c343c4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,487 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_Properties_ReturnsExpected_IfHandleIsCreated()
-    {
-        using var ownerControl = new TrackBar
-        {
-            Value = 5,
-        };
-
-        ownerControl.CreateControl();
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Equal(ownerControl.Size, accessibilityObject.Bounds.Size);
-        Assert.Null(accessibilityObject.DefaultAction);
-        Assert.Null(accessibilityObject.Description);
-        Assert.True(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, accessibilityObject.Handle);
-        Assert.Null(accessibilityObject.Help);
-        Assert.Null(accessibilityObject.KeyboardShortcut);
-        Assert.Null(accessibilityObject.Name);
-        Assert.Equal(AccessibleRole.Slider, accessibilityObject.Role);
-        Assert.Same(ownerControl, accessibilityObject.Owner);
-        Assert.NotNull(accessibilityObject.Parent);
-        Assert.Equal(AccessibleStates.Focusable, accessibilityObject.State);
-        Assert.Equal("50", accessibilityObject.Value);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_Properties_ReturnsExpected_IfHandleIsNotCreated()
-    {
-        using var ownerControl = new TrackBar
-        {
-            Value = 5,
-        };
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Equal(Rectangle.Empty.Size, accessibilityObject.Bounds.Size);
-        Assert.Null(accessibilityObject.DefaultAction);
-        Assert.Null(accessibilityObject.Description);
-        Assert.Null(accessibilityObject.Help);
-        Assert.Null(accessibilityObject.KeyboardShortcut);
-        Assert.Null(accessibilityObject.Name);
-        Assert.Equal(AccessibleRole.Slider, accessibilityObject.Role);
-        Assert.Same(ownerControl, accessibilityObject.Owner);
-        Assert.Null(accessibilityObject.Parent);
-        Assert.Equal(AccessibleStates.None, accessibilityObject.State);
-        Assert.Equal(string.Empty, accessibilityObject.Value);
-        Assert.False(ownerControl.IsHandleCreated);
-        Assert.Equal(ownerControl.Handle, accessibilityObject.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData("100", 10, "100", true)]
-    [InlineData("50", 5, "50", true)]
-    [InlineData("54", 5, "50", true)]
-    [InlineData("56", 5, "50", true)]
-    [InlineData("0", 0, "0", true)]
-    [InlineData("100", 0, "", false)]
-    [InlineData("50", 0, "", false)]
-    [InlineData("54", 0, "", false)]
-    [InlineData("56", 0, "", false)]
-    [InlineData("0", 0, "", false)]
-    public void TrackBarAccessibilityObject_Value_Set_GetReturnsExpected(string value, int expected, string expectedValueString, bool createControl)
-    {
-        using var ownerControl = new TrackBar();
-        if (createControl)
-        {
-            ownerControl.CreateControl();
-        }
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Equal(createControl, ownerControl.IsHandleCreated);
-
-        accessibilityObject.Value = value;
-
-        Assert.Equal(expectedValueString, accessibilityObject.Value);
-        Assert.Equal(expected, ownerControl.Value);
-
-        // Set same.
-        accessibilityObject.Value = value;
-
-        Assert.Equal(expectedValueString, accessibilityObject.Value);
-        Assert.Equal(expected, ownerControl.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NotAnInt")]
-    public void TrackBarAccessibilityObject_Value_SetInvalid_ThrowsCOMException_IfHandleIsCreated(string value)
-    {
-        using var ownerControl = new TrackBar
-        {
-            Value = 5
-        };
-
-        ownerControl.CreateControl();
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-
-        Assert.Throws<COMException>(() => accessibilityObject.Value = value);
-        Assert.Equal("50", accessibilityObject.Value);
-        Assert.Equal(5, ownerControl.Value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("NotAnInt")]
-    public void TrackBarAccessibilityObject_Value_SetInvalid_ThrowsCOMException_IfHandleIsNotCreated(string value)
-    {
-        using var ownerControl = new TrackBar
-        {
-            Value = 5
-        };
-
-        Control.ControlAccessibleObject accessibilityObject = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(ownerControl.AccessibilityObject);
-        accessibilityObject.Value = value;
-
-        Assert.Equal(string.Empty, accessibilityObject.Value);
-        Assert.Equal(5, ownerControl.Value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_ButtonsAreDisplayed_TestData))]
-    public void TrackBarAccessibilityObject_GetChildCount_ReturnsThree_IfAllButtonsAreDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibilityObject = Assert.IsAssignableFrom<TrackBar.TrackBarAccessibleObject>(trackBar.AccessibilityObject);
-
-        // All control elements (thumb and left/right buttons) are displayed
-        Assert.Equal(3, accessibilityObject.GetChildCount());
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_GetChildCount_ReturnsTwo_IfFirstButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibilityObject = Assert.IsAssignableFrom<TrackBar.TrackBarAccessibleObject>(trackBar.AccessibilityObject);
-
-        // Only thumb and left/right button are displayed
-        Assert.Equal(2, accessibilityObject.GetChildCount());
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_GetChildCount_ReturnsTwo_IfLastButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibilityObject = Assert.IsAssignableFrom<TrackBar.TrackBarAccessibleObject>(trackBar.AccessibilityObject);
-
-        // Only thumb and left/right button are displayed
-        Assert.Equal(2, accessibilityObject.GetChildCount());
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void TrackBarAccessibilityObject_GetChildCount_ReturnsTwo_MinimumEqualsMaximum(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibilityObject = Assert.IsAssignableFrom<TrackBar.TrackBarAccessibleObject>(trackBar.AccessibilityObject);
-
-        // Only thumb and left/right button are displayed.
-        // The left/right button is displayed even if the minimum is equal to the maximum
-        Assert.Equal(2, accessibilityObject.GetChildCount());
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarAccessibilityObject_GetChildCount_ReturnsMinusOne_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibilityObject = Assert.IsAssignableFrom<TrackBar.TrackBarAccessibleObject>(trackBar.AccessibilityObject);
-
-        Assert.Equal(-1, accessibilityObject.GetChildCount());
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_ButtonsAreDisplayed_TestData))]
-    public void TrackBarAccessibilityObject_GetChild_ReturnsExpected_ButtonsAreDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.LastButtonAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_GetChild_ReturnsExpected_FirstButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.LastButtonAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_GetChild_ReturnsExpected_LastButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarAccessibilityObject_GetChild_ReturnsNull_IfHandleNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_ControlType_IsSlider_IfAccessibleRoleIsDefault()
-    {
-        using TrackBar trackBar = new();
-
-        // AccessibleRole is not set = Default
-        object actual = trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.SliderControlTypeId, actual);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_Role_IsStatusBar_ByDefault()
-    {
-        using TrackBar trackBar = new();
-
-        // AccessibleRole is not set = Default
-        Assert.Equal(AccessibleRole.Slider, trackBar.AccessibilityObject.Role);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrackBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void TrackBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using TrackBar trackBar = new();
-        trackBar.AccessibleRole = role;
-
-        object actual = trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test Description")]
-    [InlineData(null)]
-    public void TrackBarAccessibilityObject_DefaultAction_ReturnExpected(string defaultAction)
-    {
-        using TrackBar trackBar = new();
-        trackBar.AccessibleDefaultActionDescription = defaultAction;
-
-        Assert.Equal(defaultAction, trackBar.AccessibilityObject.DefaultAction);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("Test Description")]
-    [InlineData(null)]
-    public void TrackBarAccessibilityObject_GetProperyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnExpected(string defaultAction)
-    {
-        using TrackBar trackBar = new();
-        trackBar.AccessibleDefaultActionDescription = defaultAction;
-
-        Assert.Equal(defaultAction, trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_ButtonsAreDisplayed_TestData))]
-    public void TrackBarAccessibilityObject_FragmentNavigate_Child_ReturnsExpected_ButtonsAreDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Equal(accessibleObject.FirstButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject.LastButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_FragmentNavigate_Child_ReturnsExpected_IfFirstButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject.LastButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarAccessibilityObject_FragmentNavigate_Child_ReturnsExpected_IfLastButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Equal(accessibleObject.FirstButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarAccessibilityObject_FragmentNavigate_Child_ReturnsNull_IfHandleNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_IsPatternSupported_ReturnsExpected()
-    {
-        using TrackBar trackBar = new();
-
-        Assert.True(trackBar.AccessibilityObject.IsPatternSupported(UiaCore.UIA.ValuePatternId));
-        Assert.True(trackBar.AccessibilityObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TrackBarAccessibilityObject_GetPropertyValue_IsEnabledProperty_ReturnsExpected(bool enabled)
-    {
-        using TrackBar trackBar = new()
-        {
-            Enabled = enabled
-        };
-
-        Assert.Equal(enabled, trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using TrackBar trackBar = new();
-        object actual = trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(trackBar.AccessibilityObject.RuntimeId, actual);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.NamePropertyId, "TestAccessibleName")]
-    [InlineData((int)UiaCore.UIA.AutomationIdPropertyId, "TestControlName")]
-    public void TrackBarAccessibilityObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using TrackBar trackBar = new()
-        {
-            Name = expected.ToString(),
-            AccessibleName = expected.ToString()
-        };
-
-        TrackBar.TrackBarAccessibleObject accessibilityObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        object value = accessibilityObject.GetPropertyValue((UiaCore.UIA)propertyID);
-        Assert.Equal(expected, value);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarAccessibilityObject_GetPropertyValue_NativeWindowHandle_ReturnsExpected()
-    {
-        using TrackBar trackBar = new();
-        trackBar.CreateControl(false);
-        object actual = trackBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NativeWindowHandlePropertyId);
-
-        Assert.Equal((nint)trackBar.InternalHandle, actual);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void TrackBarAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using TrackBar trackBar = new();
-        TrackBar.TrackBarAccessibleObject accessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    private TrackBar GetTrackBar(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int value, int minimum, int maximum)
-    {
-        TrackBar trackBar = new()
-        {
-            Value = value,
-            Maximum = maximum,
-            Minimum = minimum,
-            LargeChange = 3,
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-
-        if (createControl)
-        {
-            trackBar.CreateControl();
-        }
-
-        return trackBar;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarChildAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarChildAccessibleObjectTests.cs
deleted file mode 100644
index 0f0f5697eb7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarChildAccessibleObjectTests.cs
+++ /dev/null
@@ -1,109 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.TrackBar;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBar_TrackBarChildAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_Ctor_OwnerTrackBarCannotBeNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new SubTrackBarChildAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_Bounds_IsEmptyRectangle_IfOwningControlIsNotCreated()
-    {
-        using TrackBar control = new();
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_Bounds_IsEmptyRectangle_IfOwningControlIsNotVisible()
-    {
-        using TrackBar control = new();
-        control.CreateControl();
-        control.Visible = false;
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_Bounds_IsNotEmptyRectangle()
-    {
-        using TrackBar control = new();
-        control.CreateControl();
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_FragmentNavigate_Parent_ReturnsExpected()
-    {
-        using TrackBar control = new();
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using TrackBar control = new();
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(control.AccessibilityObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBarChildAccessibleObject_IsDisplayed_ReturnsExpected(bool isVisible)
-    {
-        using TrackBar control = new();
-        control.Visible = isVisible;
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(isVisible, accessibleObject.IsDisplayed);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBarChildAccessibleObject_GetPropertyValue_ControlType_ReturnsExpected()
-    {
-        using TrackBar control = new();
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(UiaCore.UIA.ButtonControlTypeId, accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBarChildAccessibleObject_GetPropertyValue_IsEnabled_ReturnsExpected(bool isEnabled)
-    {
-        using TrackBar control = new();
-        control.Enabled = isEnabled;
-        var accessibleObject = new SubTrackBarChildAccessibleObject(control);
-
-        Assert.Equal(isEnabled, accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class SubTrackBarChildAccessibleObject : TrackBarChildAccessibleObject
-    {
-        public SubTrackBarChildAccessibleObject(TrackBar owningTrackBar) : base(owningTrackBar)
-        { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarFirstButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarFirstButtonAccessibleObjectTests.cs
deleted file mode 100644
index 5546a178719..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarFirstButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,400 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBar_TrackBarFirstButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsDisplayed_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Bounds_ReturnsNotEmptyRectangle_IfButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Bounds_ReturnsEmptyRectangle_IfButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Bounds_ReturnsEmptyRectangle_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_DefaultAction_ReturnActionPress(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(SR.AccessibleActionPress, accessibleObject.DefaultAction);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Help_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Null(accessibleObject.Help);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_DecreaseButtonName_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            foreach (bool rightToLeftLayout in new[] { true, false })
-            {
-                if (rightToLeft == RightToLeft.Yes && rightToLeftLayout == false)
-                {
-                    continue;
-                }
-
-                foreach (bool createControl in new[] { true, false })
-                {
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 5 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 0 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 10 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 0, /*value*/ 0 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrackBarAccessibleObject_DecreaseButtonName_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Name_ReturnDescreaseName(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(SR.TrackBarLargeDecreaseButtonName, accessibleObject.Name);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_IncreaseButtonName_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    if (orientation == Orientation.Vertical || (rightToLeft == RightToLeft.Yes && rightToLeftLayout == false))
-                    {
-                        foreach (bool createControl in new[] { true, false })
-                        {
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 5 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 0 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 10 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 0, /*value*/ 0 };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrackBarAccessibleObject_IncreaseButtonName_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Name_ReturnIncreaseName(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(SR.TrackBarLargeIncreaseButtonName, accessibleObject.Name);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Role_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-        AccessibleRole accessibleRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_State_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-        AccessibleStates expectedState = accessibleObject.IsDisplayed || !trackBar.IsHandleCreated
-                                         ? AccessibleStates.None
-                                         : AccessibleStates.Invisible;
-
-        Assert.Equal(expectedState, accessibleObject.State);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_FragmentNavigate_ReturnsNull_IfFirstButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = trackBarAccessibleObject.FirstButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_FragmentNavigate_ReturnsNull_MinimumEqualsMaximum(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = trackBarAccessibleObject.FirstButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsDisplayed_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_FragmentNavigate_ReturnsExpected_IfFirstButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = trackBarAccessibleObject.FirstButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(trackBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_GetChildCount_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_GetChild_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Orientation.Vertical, RightToLeft.Yes, true)]
-    [InlineData(Orientation.Vertical, RightToLeft.Yes, false)]
-    [InlineData(Orientation.Vertical, RightToLeft.No, true)]
-    [InlineData(Orientation.Vertical, RightToLeft.No, false)]
-    [InlineData(Orientation.Horizontal, RightToLeft.Yes, false)]
-    public void TrackBarFirstButtonAccessibleObject_Invoke_Increase_WorkCorrectly(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value: 5, 0, 10);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(5, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(8, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(10, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(10, trackBar.Value);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Orientation.Horizontal, RightToLeft.No, true)]
-    [InlineData(Orientation.Horizontal, RightToLeft.No, false)]
-    [InlineData(Orientation.Horizontal, RightToLeft.Yes, true)]
-    public void TrackBarFirstButtonAccessibleObject_Invoke_Decrease_WorkCorrectly(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value: 5, 0, 10);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(5, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(2, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(0, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(0, trackBar.Value);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.Equal(value, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, trackBar.Value);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_InvokePattern_DoesNotSupport(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.True(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = true;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = false;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsDisplayed_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        trackBar.Visible = true;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsDisplayed_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        trackBar.Visible = false;
-        TrackBar.TrackBarFirstButtonAccessibleObject accessibleObject = GetTrackBarFirstButton(trackBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    private TrackBar GetTrackBar(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int value, int minimum, int maximum)
-    {
-        TrackBar trackBar = new()
-        {
-            Value = value,
-            Maximum = maximum,
-            Minimum = minimum,
-            LargeChange = 3,
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-
-        if (createControl)
-        {
-            trackBar.CreateControl();
-        }
-
-        return trackBar;
-    }
-
-    private TrackBar.TrackBarFirstButtonAccessibleObject GetTrackBarFirstButton(TrackBar trackBar)
-    {
-        TrackBar.TrackBarAccessibleObject trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        return trackBarAccessibleObject.FirstButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarLastButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarLastButtonAccessibleObjectTests.cs
deleted file mode 100644
index 96cce5fd07b..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarLastButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,401 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBar_TrackBarLastButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsDisplayed_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Bounds_ReturnsNotEmptyRectangle_IfButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Bounds_ReturnsEmptyRectangle_IfButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Bounds_ReturnsEmptyRectangle_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_DefaultAction_ReturnActionPress(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(SR.AccessibleActionPress, accessibleObject.DefaultAction);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Help_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Null(accessibleObject.Help);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_IncreaseButtonName_TestData()
-    {
-        foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-        {
-            foreach (bool rightToLeftLayout in new[] { true, false })
-            {
-                if (rightToLeft == RightToLeft.Yes && rightToLeftLayout == false)
-                {
-                    continue;
-                }
-
-                foreach (bool createControl in new[] { true, false })
-                {
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 5 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 0 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 10 };
-                    yield return new object[] { Orientation.Horizontal, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 0, /*value*/ 0 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrackBarAccessibleObject_IncreaseButtonName_TestData))]
-    public void TrackBarFirstButtonAccessibleObject_Name_ReturnIncreaseName(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(SR.TrackBarLargeIncreaseButtonName, accessibleObject.Name);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TrackBarAccessibleObject_DecreaseButtonName_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in new RightToLeft[] { RightToLeft.Yes, RightToLeft.No })
-            {
-                foreach (bool rightToLeftLayout in new[] { true, false })
-                {
-                    if (orientation == Orientation.Vertical || (rightToLeft == RightToLeft.Yes && rightToLeftLayout == false))
-                    {
-                        foreach (bool createControl in new[] { true, false })
-                        {
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 5 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 0 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 10, /*value*/ 10 };
-                            yield return new object[] { orientation, rightToLeft, rightToLeftLayout, createControl, /*minumim*/ 0, /*maximum*/ 0, /*value*/ 0 };
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TrackBarAccessibleObject_DecreaseButtonName_TestData))]
-    public void TrackBarLLastButtonAccessibleObject_Name_ReturnDecreaseName(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(SR.TrackBarLargeDecreaseButtonName, accessibleObject.Name);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Role_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-        AccessibleRole accessibleRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_State_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-        var bounds = accessibleObject.Bounds;
-        AccessibleStates expectedState = accessibleObject.IsDisplayed || !trackBar.IsHandleCreated
-                                            ? AccessibleStates.None
-                                            : AccessibleStates.Invisible;
-
-        Assert.Equal(expectedState, accessibleObject.State);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarLastButtonAccessibleObject_FragmentNavigate_ReturnsNull_IfButtonIsHidden(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = trackBarAccessibleObject.LastButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void TrackBarLastButtonAccessibleObject_FragmentNavigate_ReturnsNull_MinimumEqualsMaximum(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = trackBarAccessibleObject.LastButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(trackBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarLastButtonAccessibleObject_FragmentNavigate_ReturnsNull_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsDisplayed_TestData))]
-    public void TrackBarLastButtonAccessibleObject_FragmentNavigate_ReturnsExpected_IfButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = trackBarAccessibleObject.LastButtonAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(trackBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_GetChildCount_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_GetChild_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Orientation.Vertical, RightToLeft.Yes, true)]
-    [InlineData(Orientation.Vertical, RightToLeft.Yes, false)]
-    [InlineData(Orientation.Vertical, RightToLeft.No, true)]
-    [InlineData(Orientation.Vertical, RightToLeft.No, false)]
-    [InlineData(Orientation.Horizontal, RightToLeft.Yes, false)]
-    public void TrackBarLastButtonAccessibleObject_Invoke_Decrease_WorkCorrectly(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value: 5, 0, 10);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(5, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(2, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(0, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(0, trackBar.Value);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Orientation.Horizontal, RightToLeft.No, true)]
-    [InlineData(Orientation.Horizontal, RightToLeft.No, false)]
-    [InlineData(Orientation.Horizontal, RightToLeft.Yes, true)]
-    public void TrackBarLastButtonAccessibleObject_Invoke_Increase_WorkCorrectly(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value: 5, 0, 10);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(5, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(8, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(10, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(10, trackBar.Value);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarLastButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.Equal(value, trackBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, trackBar.Value);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_InvokePattern_DoesNotSupport(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.True(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = true;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarLastButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = false;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsDisplayed_TestData))]
-    public void TrackBarLastButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        trackBar.Visible = true;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsDisplayed_TestData))]
-    public void TrackBarLastButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        trackBar.Visible = false;
-        TrackBar.TrackBarLastButtonAccessibleObject accessibleObject = GetTrackBarLastButton(trackBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    private TrackBar GetTrackBar(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int value, int minimum, int maximum)
-    {
-        TrackBar trackBar = new()
-        {
-            Value = value,
-            Maximum = maximum,
-            Minimum = minimum,
-            LargeChange = 3,
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-
-        if (createControl)
-        {
-            trackBar.CreateControl();
-        }
-
-        return trackBar;
-    }
-
-    private TrackBar.TrackBarLastButtonAccessibleObject GetTrackBarLastButton(TrackBar trackBar)
-    {
-        TrackBar.TrackBarAccessibleObject trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        return trackBarAccessibleObject.LastButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarThumbAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarThumbAccessibleObjectTests.cs
deleted file mode 100644
index c6386aaf6f7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TrackBar.TrackBarThumbAccessibleObjectTests.cs
+++ /dev/null
@@ -1,263 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBar_TrackBarThumbAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarThumbAccessibleObject_Bounds_ReturnsEmptyRectangle_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarThumbAccessibleObject_Bounds_ReturnsRectangle_IfHandleIsCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_DefaultAction_ReturnActionPress(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_Help_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Null(accessibleObject.Help);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_Name_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Equal(SR.TrackBarPositionButtonName, accessibleObject.Name);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_Role_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-        AccessibleRole accessibleRole = createControl ? AccessibleRole.Indicator : AccessibleRole.None;
-
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_State_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_ButtonsAreDisplayed_TestData))]
-    public void TrackBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_IfButtonsIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = trackBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(trackBarAccessibleObject.LastButtonAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(trackBarAccessibleObject.FirstButtonAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_FirstButtonIsHidden_TestData))]
-    public void TrackBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_IfFirstButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = trackBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Equal(trackBarAccessibleObject.LastButtonAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_LastButtonIsHidden_TestData))]
-    public void TrackBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_IfLastButtonIsDisplayed(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: true, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = trackBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(trackBarAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(trackBarAccessibleObject.FirstButtonAccessibleObject, accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.True(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void TrackBarThumbAccessibleObject_FragmentNavigate_ReturnNull_IfHandleIsNotCreated(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl: false, value, minimum, maximum);
-        var trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = trackBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(Interop.UiaCore.NavigateDirection.LastChild));
-        Assert.False(trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_GetChildCount_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_GetChild_ReturnExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_InvokePattern_DoesNotSupport(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.False(accessibleObject.IsPatternSupported(Interop.UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = true;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Enabled = false;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Visible = true;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(TrackBarTestHelper), nameof(TrackBarTestHelper.TrackBarAccessibleObject_TestData))]
-    public void TrackBarThumbAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int minimum, int maximum, int value)
-    {
-        using TrackBar trackBar = GetTrackBar(orientation, rightToLeft, rightToLeftLayout, createControl, value, minimum, maximum);
-        trackBar.Visible = false;
-        TrackBar.TrackBarThumbAccessibleObject accessibleObject = GetTrackBarThumb(trackBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, trackBar.IsHandleCreated);
-    }
-
-    private TrackBar GetTrackBar(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, bool createControl, int value, int minimum, int maximum)
-    {
-        TrackBar trackBar = new()
-        {
-            Value = value,
-            Maximum = maximum,
-            Minimum = minimum,
-            LargeChange = 3,
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-
-        if (createControl)
-        {
-            trackBar.CreateControl();
-        }
-
-        return trackBar;
-    }
-
-    private TrackBar.TrackBarThumbAccessibleObject GetTrackBarThumb(TrackBar trackBar)
-    {
-        TrackBar.TrackBarAccessibleObject trackBarAccessibleObject = (TrackBar.TrackBarAccessibleObject)trackBar.AccessibilityObject;
-
-        return trackBarAccessibleObject.ThumbAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.IKeyboardToolTipTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.IKeyboardToolTipTests.cs
deleted file mode 100644
index 707c757efc4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.IKeyboardToolTipTests.cs
+++ /dev/null
@@ -1,434 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeNode_TreeNodeIKeyboardToolTipTests
-{
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeAllowsToolTip_ReturnsExpected(bool insideTreeView, bool showNodeToolTips)
-    {
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        TreeNode treeNode = new TreeNode();
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-        }
-
-        Assert.True(((IKeyboardToolTip)treeNode).AllowsToolTip());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeAllowsChildrenToShowToolTips_ReturnsExpected(
-        bool insideTreeView,
-        bool showNodeToolTips,
-        bool expectedResult)
-    {
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        TreeNode treeNode = new TreeNode();
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)treeNode).AllowsChildrenToShowToolTips());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeCanShowToolTipsNow_ReturnsExpected(
-        bool insideTreeView,
-        bool showNodeToolTips,
-        bool expectedResult)
-    {
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        TreeNode treeNode = new TreeNode();
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)treeNode).CanShowToolTipsNow());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, "Test tooltip")]
-    [InlineData(true, false, "Test tooltip")]
-    [InlineData(false, true, "Test tooltip")]
-    [InlineData(false, false, "Test tooltip")]
-    public void TreeNodeIKeyboardToolTip_InvokeGetCaptionForTool_ReturnsExpected(
-        bool insideTreeView,
-        bool showNodeToolTips,
-        string toolTipText)
-    {
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        using var toolTip = new ToolTip();
-        TreeNode treeNode = new TreeNode() { ToolTipText = toolTipText };
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-        }
-
-        Assert.Equal(toolTipText, ((IKeyboardToolTip)treeNode).GetCaptionForTool(toolTip));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNativeScreenRectangle_ReturnsExpected(
-        bool insideTreeView,
-        bool showNodeToolTips)
-    {
-        TreeNode treeNode = new TreeNode();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        Rectangle expectedBounds = Rectangle.Empty;
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-            expectedBounds = GetRectangle(treeView, treeNode);
-        }
-
-        Assert.Equal(expectedBounds, ((IKeyboardToolTip)treeNode).GetNativeScreenRectangle());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_FirstTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode firstTreeNode = treeView.Nodes[0];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)firstTreeNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(1, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[1]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_MiddleTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode middleTreeNode = treeView.Nodes[1];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)middleTreeNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[0]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[2]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_LastTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode lastTreeNode = treeView.Nodes[0];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)lastTreeNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(1, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[1]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_FirstSubTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode rootNode = treeView.Nodes[0];
-        rootNode.Expand();
-        TreeNode firstSubNode = rootNode.Nodes[0];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)firstSubNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, rootNode), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, rootNode.Nodes[1]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_MiddleSubTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode rootNode = treeView.Nodes[0];
-        rootNode.Expand();
-        TreeNode middleSubNode = rootNode.Nodes[1];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)middleSubNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, rootNode.Nodes[0]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, rootNode.Nodes[2]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_LastSubTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode rootNode = treeView.Nodes[0];
-        rootNode.Expand();
-        TreeNode lastSubNode = rootNode.Nodes[2];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)lastSubNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, rootNode.Nodes[1]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[1]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_SubSubTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode rootNode = treeView.Nodes[0];
-        rootNode.Expand();
-        TreeNode lastSubNode = rootNode.Nodes[2];
-        lastSubNode.Expand();
-        TreeNode subSubNode = lastSubNode.Nodes[0];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)subSubNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[1]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, lastSubNode), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_TreeNodeAfterExpandedNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode firstNode = treeView.Nodes[0];
-        firstNode.Expand();
-        TreeNode middleNode = treeView.Nodes[1];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)middleNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[2]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, firstNode.Nodes[2]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_TreeNodeAfterExpandedSubNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode firstNode = treeView.Nodes[0];
-        firstNode.Expand();
-        TreeNode subNode = firstNode.Nodes[2];
-        subNode.Expand();
-        TreeNode middleNode = treeView.Nodes[1];
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)middleNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, treeView.Nodes[2]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, subNode.Nodes[0]), neighboringRectangles);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_ExpandedSubTreeNode_ReturnsExpected(bool showNodeToolTips)
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        treeView.Nodes.AddRange(treeNodesList.ToArray());
-        TreeNode rootNode = treeView.Nodes[0];
-        rootNode.Expand();
-        TreeNode lastSubNode = rootNode.Nodes[2];
-        lastSubNode.Expand();
-
-        IList<Rectangle> neighboringRectangles = ((IKeyboardToolTip)lastSubNode).GetNeighboringToolsRectangles();
-
-        Assert.Equal(2, neighboringRectangles.Count);
-        Assert.Contains(GetRectangle(treeView, rootNode.Nodes[1]), neighboringRectangles);
-        Assert.Contains(GetRectangle(treeView, lastSubNode.Nodes[0]), neighboringRectangles);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeIKeyboardToolTip_InvokeGetNeighboringToolsRectangles_WithoutTreeView_ReturnsEmptyList()
-    {
-        List<TreeNode> treeNodesList = GetHierarchyNodes();
-
-        Assert.Equal(0, ((IKeyboardToolTip)treeNodesList[0]).GetNeighboringToolsRectangles().Count);
-        Assert.Equal(0, ((IKeyboardToolTip)treeNodesList[1]).GetNeighboringToolsRectangles().Count);
-        Assert.Equal(0, ((IKeyboardToolTip)treeNodesList[2]).GetNeighboringToolsRectangles().Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeIKeyboardToolTip_InvokeGetOwnerWindow_ReturnsExpected(bool insideTreeView)
-    {
-        TreeNode treeNode = new TreeNode();
-        using var treeView = new TreeView();
-        IWin32Window expectedOwner = null;
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-            expectedOwner = treeView;
-        }
-
-        Assert.Equal(expectedOwner, ((IKeyboardToolTip)treeNode).GetOwnerWindow());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, RightToLeft.Yes, true)]
-    [InlineData(true, RightToLeft.No, false)]
-    [InlineData(true, RightToLeft.Inherit, false)]
-    [InlineData(false, RightToLeft.Yes, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeHasRtlModeEnabled_ReturnsExpected(
-        bool insideTreeView,
-        RightToLeft rightToLeft,
-        bool expected)
-    {
-        TreeNode treeNode = new TreeNode();
-        using var treeView = new TreeView() { RightToLeft = rightToLeft };
-        IWin32Window expectedOwner = null;
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-            expectedOwner = treeView;
-        }
-
-        Assert.Equal(expected, ((IKeyboardToolTip)treeNode).HasRtlModeEnabled());
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TreeNodeIKeyboardToolTip_InvokeIsHoveredWithMouse_ReturnsExpected(
-        bool insideTreeView,
-        bool isHovered,
-        bool expected)
-    {
-        Point initialPosition = Cursor.Position;
-        try
-        {
-            TreeNode treeNode = new TreeNode();
-            using var treeView = new TreeView() { Size = new Size(50, 50) };
-            treeView.CreateControl();
-
-            if (insideTreeView)
-            {
-                treeView.Nodes.Add(treeNode);
-            }
-
-            Point position = treeView.AccessibilityObject.Bounds.Location;
-            if (!isHovered)
-            {
-                position.X--;
-                position.Y--;
-            }
-
-            Cursor.Position = position;
-            Assert.Equal(expected, ((IKeyboardToolTip)treeNode).IsHoveredWithMouse());
-        }
-        finally
-        {
-            Cursor.Position = initialPosition;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, true)]
-    [InlineData(true, false, false)]
-    [InlineData(false, true, false)]
-    [InlineData(false, false, false)]
-    public void TreeNodeIKeyboardToolTip_Invoke_ReturnsExpected(
-        bool insideTreeView,
-        bool showNodeToolTips,
-        bool expectedResult)
-    {
-        using var treeView = new TreeView() { ShowNodeToolTips = showNodeToolTips };
-        TreeNode treeNode = new TreeNode();
-
-        if (insideTreeView)
-        {
-            treeView.Nodes.Add(treeNode);
-        }
-
-        Assert.Equal(expectedResult, ((IKeyboardToolTip)treeNode).ShowsOwnToolTip());
-    }
-
-    private List<TreeNode> GetHierarchyNodes()
-    {
-        List<TreeNode> treeNodesList = new List<TreeNode>();
-
-        TreeNode rootNode1 = new TreeNode();
-        TreeNode rootNode2 = new TreeNode();
-        TreeNode rootNode3 = new TreeNode();
-
-        TreeNode subNode1 = new TreeNode();
-        TreeNode subNode2 = new TreeNode();
-        TreeNode subNode3 = new TreeNode();
-
-        TreeNode subSubNode = new TreeNode();
-
-        subNode3.Nodes.Add(subSubNode);
-        rootNode1.Nodes.AddRange(new TreeNode[] { subNode1, subNode2, subNode3 });
-        treeNodesList.AddRange(new TreeNode[] { rootNode1, rootNode2, rootNode3 });
-        return treeNodesList;
-    }
-
-    private Rectangle GetRectangle(TreeView treeView, TreeNode treeNode)
-    {
-        return treeView.RectangleToScreen(treeNode.Bounds);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.TreeNodeAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.TreeNodeAccessibleObjectTests.cs
deleted file mode 100644
index 96fa96429d4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNode.TreeNodeAccessibleObjectTests.cs
+++ /dev/null
@@ -1,599 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.TreeNode;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeNodeAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Ctor_Default()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.NotNull(node.AccessibilityObject);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Ctor_ThrowsException_IfOwningNodeIsNull()
-    {
-        using TreeView control = new();
-
-        Assert.Throws<ArgumentNullException>(() => new TreeNodeAccessibleObject(null, control));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Ctor_ThrowsException_IfOwningTreeIsNull()
-    {
-        TreeNode node = new();
-
-        Assert.Throws<ArgumentNullException>(() => new TreeNodeAccessibleObject(node, null));
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_DefaultAction_IsEmptyString_IfNodeIsLeaf()
-    {
-        using TreeView control = new() { CheckBoxes = false };
-        TreeNode node = new(control);
-
-        Assert.Empty(node.AccessibilityObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_DefaultAction_ReturnsExpected_IfNodeIsParent(bool isExpanded)
-    {
-        using TreeView control = new() { CheckBoxes = false };
-        TreeNode node = new TreeNode("Root node", new TreeNode[] { new() });
-        control.Nodes.Add(node);
-        if (isExpanded)
-        {
-            node.Expand();
-        }
-
-        string expected = isExpanded ? SR.AccessibleActionCollapse : SR.AccessibleActionExpand;
-
-        Assert.Equal(expected, node.AccessibilityObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_DefaultAction_ReturnsExpected_IfNodesAreCheckBoxes(bool isChecked)
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control) { Checked = isChecked };
-
-        string expected = isChecked ? SR.AccessibleActionUncheck : SR.AccessibleActionCheck;
-
-        Assert.Equal(expected, node.AccessibilityObject.DefaultAction);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_DoDefaultAction_ToggleNodeCheckBox_IfNodesAreCheckBoxes(bool isChecked)
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control) { Checked = isChecked };
-
-        Assert.Equal(isChecked, node.Checked);
-
-        node.AccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(!isChecked, node.Checked);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_DoDefaultAction_ExpandOrCollapse_IfNodeIsNotLeaf(bool isExpanded)
-    {
-        using TreeView control = new();
-        TreeNode node = new TreeNode("Root node", new TreeNode[] { new() });
-        control.Nodes.Add(node);
-        if (isExpanded)
-        {
-            node.Expand();
-        }
-
-        Assert.Equal(isExpanded, node.IsExpanded);
-
-        node.AccessibilityObject.DoDefaultAction();
-
-        Assert.Equal(!isExpanded, node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_FragmentRoot_ReturnsTree()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Equal(control.AccessibilityObject, node.AccessibilityObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_FragmentNavigate_Parent_ReturnsTree()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        var actual = (AccessibleObject)node.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(control.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_FragmentNavigate_Parent_ReturnsParent()
-    {
-        using TreeView control = new();
-        TreeNode node = new();
-        control.Nodes.Add(new TreeNode("Root node", new[] { node }));
-
-        var actual = (AccessibleObject)node.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.Parent);
-
-        Assert.Equal(node.Parent.AccessibilityObject, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected(bool isExpanded)
-    {
-        using TreeView control = new();
-        TreeNode node = new TreeNode("Root node", new TreeNode[] { new(), new(), new() });
-        control.Nodes.Add(node);
-        if (isExpanded)
-        {
-            node.Expand();
-        }
-
-        // If node is collapsed, child is not visible, so returns null instead of child ao.
-        AccessibleObject expected = isExpanded ? node.FirstNode?.AccessibilityObject : null;
-
-        Assert.Equal(expected, node.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected(bool isExpanded)
-    {
-        using TreeView control = new();
-        TreeNode node = new TreeNode("Root node", new TreeNode[] { new(), new(), new() });
-        control.Nodes.Add(node);
-        if (isExpanded)
-        {
-            node.Expand();
-        }
-
-        // If node is collapsed, child is not visible, so returns null instead of child ao.
-        AccessibleObject expected = isExpanded ? node.LastNode?.AccessibilityObject : null;
-
-        Assert.Equal(expected, node.AccessibilityObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_FragmentNavigate_NextSibling_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new(), new(), new() });
-
-        AccessibleObject accessibleObject1 = control.Nodes[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Nodes[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Nodes[2].AccessibilityObject;
-
-        Assert.Equal(accessibleObject2, accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(accessibleObject3, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_FragmentNavigate_PreviousSibling_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new(), new(), new() });
-
-        AccessibleObject accessibleObject1 = control.Nodes[0].AccessibilityObject;
-        AccessibleObject accessibleObject2 = control.Nodes[1].AccessibilityObject;
-        AccessibleObject accessibleObject3 = control.Nodes[2].AccessibilityObject;
-
-        Assert.Null(accessibleObject1.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject1, accessibleObject2.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(accessibleObject2, accessibleObject3.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeNodeAccessibleObject_GetPropertyValue_ControlType_IsTreeItem(bool checkBoxes)
-    {
-        using TreeView control = new() { CheckBoxes = checkBoxes };
-        TreeNode node = new(control);
-
-        UiaCore.UIA expected = UiaCore.UIA.TreeItemControlTypeId;
-        object actual = node.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expected, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ExpandCollapsePatternId, false)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId, true)]
-    [InlineData((int)UiaCore.UIA.ScrollItemPatternId, true)]
-    [InlineData((int)UiaCore.UIA.SelectionItemPatternId, true)]
-    public void TreeNodeAccessibleObject_IsPatternSupported_IfCommonNodes(int patternId, bool expected)
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Equal(node.AccessibilityObject.IsPatternSupported((UiaCore.UIA)patternId), expected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ExpandCollapsePatternId, false)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId, true)]
-    [InlineData((int)UiaCore.UIA.ScrollItemPatternId, true)]
-    [InlineData((int)UiaCore.UIA.SelectionItemPatternId, true)]
-    [InlineData((int)UiaCore.UIA.TogglePatternId, true)]
-    public void TreeNodeAccessibleObject_IsPatternSupported_IfNodesAreCheckBoxes(int patternId, bool expected)
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control);
-
-        Assert.Equal(node.AccessibilityObject.IsPatternSupported((UiaCore.UIA)patternId), expected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.ExpandCollapsePatternId, false)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId, true)]
-    [InlineData((int)UiaCore.UIA.ScrollItemPatternId, true)]
-    [InlineData((int)UiaCore.UIA.SelectionItemPatternId, true)]
-    [InlineData((int)UiaCore.UIA.ValuePatternId, true)]
-    public void TreeNodeAccessibleObject_IsPatternSupported_IfNodesAreEditable(int patternId, bool expected)
-    {
-        using TreeView control = new() { LabelEdit = true };
-        TreeNode node = new(control);
-
-        Assert.Equal(node.AccessibilityObject.IsPatternSupported((UiaCore.UIA)patternId), expected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Index_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new(), new(), new() });
-
-        TreeNodeAccessibleObject accessibleObject1 = control.Nodes[0].AccessibilityObject;
-        TreeNodeAccessibleObject accessibleObject2 = control.Nodes[1].AccessibilityObject;
-        TreeNodeAccessibleObject accessibleObject3 = control.Nodes[2].AccessibilityObject;
-
-        Assert.Equal(0, accessibleObject1.Index);
-        Assert.Equal(1, accessibleObject2.Index);
-        Assert.Equal(2, accessibleObject3.Index);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Name_EqualsText()
-    {
-        using TreeView control = new();
-        string testText = "This is test string for Text property of TreeNode.";
-        TreeNode node = new(control) { Text = testText };
-
-        Assert.Equal(testText, node.AccessibilityObject.Name);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Parent_ReturnsNull_IfNodeHasNoParent()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Null(node.AccessibilityObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Parent_ReturnsParent()
-    {
-        using TreeView control = new();
-        TreeNode node = new();
-
-        control.Nodes.Add(new TreeNode("Root node", new[] { node }));
-
-        Assert.Equal(node.Parent.AccessibilityObject, node.AccessibilityObject.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Role_IsOutlineItem()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Equal(AccessibleRole.OutlineItem, node.AccessibilityObject.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Role_IsCheckButton_IfNodesAreCheckBoxes()
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control);
-
-        Assert.Equal(AccessibleRole.CheckButton, node.AccessibilityObject.Role);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Expand_WorksExpected_IfNodeIsCollapsed()
-    {
-        using TreeView control = new();
-        TreeNode node = new("Root node", new TreeNode[] { new() });
-
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsExpanded);
-
-        node.AccessibilityObject.Expand();
-
-        Assert.True(node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Expand_DoesNothing_IfNodeHasNoChild()
-    {
-        using TreeView control = new();
-        TreeNode node = new();
-
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsExpanded);
-
-        node.AccessibilityObject.Expand();
-
-        Assert.False(node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Collapse_WorksExpected_IfNodeIsExpanded()
-    {
-        using TreeView control = new();
-        TreeNode node = new("Root node", new TreeNode[] { new() });
-
-        control.Nodes.Add(node);
-
-        node.Expand();
-        Assert.True(node.IsExpanded);
-
-        node.AccessibilityObject.Collapse();
-
-        Assert.False(node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_ExpandCollapseState_ReturnsLeafNode_IfNodeHasNoChild()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Equal(UiaCore.ExpandCollapseState.LeafNode, node.AccessibilityObject.ExpandCollapseState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_ExpandCollapseState_ReturnsExpected(bool isExpanded)
-    {
-        using TreeView control = new();
-        TreeNode node = new("Root node", new TreeNode[] { new() });
-
-        control.Nodes.Add(node);
-
-        if (isExpanded)
-        {
-            node.Expand();
-        }
-
-        UiaCore.ExpandCollapseState expected = isExpanded
-                ? UiaCore.ExpandCollapseState.Expanded
-                : UiaCore.ExpandCollapseState.Collapsed;
-
-        Assert.Equal(expected, node.AccessibilityObject.ExpandCollapseState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_ItemSelectionContainer_ReturnsExpected()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-
-        Assert.Equal(control.AccessibilityObject, node.AccessibilityObject.ItemSelectionContainer);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_Toggle_WorksExpected(bool isChecked)
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control) { Checked = isChecked };
-
-        Assert.Equal(isChecked, node.Checked);
-
-        node.AccessibilityObject.Toggle();
-
-        Assert.Equal(!isChecked, node.Checked);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNodeAccessibleObject_ToggleState_WorksExpected(bool isChecked)
-    {
-        using TreeView control = new() { CheckBoxes = true };
-        TreeNode node = new(control) { Checked = isChecked };
-
-        UiaCore.ToggleState expected = isChecked ? UiaCore.ToggleState.On : UiaCore.ToggleState.Off;
-
-        Assert.Equal(expected, node.AccessibilityObject.ToggleState);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_SelectItem_WorksExpected()
-    {
-        using TreeView control = new();
-
-        control.Nodes.Add("Node1");
-        control.Nodes.Add("Node2");
-        control.Nodes.Add("Node3");
-        control.Nodes.Add("Node4");
-
-        Assert.Null(control.SelectedNode);
-
-        control.Nodes[1].AccessibilityObject.SelectItem();
-        Assert.Equal("Node2", control.SelectedNode?.Text);
-
-        control.Nodes[3].AccessibilityObject.SelectItem();
-        Assert.Equal("Node4", control.SelectedNode?.Text);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_Value_EqualsText()
-    {
-        using TreeView control = new() { LabelEdit = true };
-        string testText = "This is test string for Text property of TreeNode.";
-        TreeNode node = new(control) { Text = testText };
-
-        Assert.Equal(testText, node.AccessibilityObject.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_HasChildren_ExpandCollapsePatternAvailable()
-    {
-        using TreeView control = new();
-        TreeNode node = new(control);
-        node.Nodes.Add("ChildNode");
-
-        Assert.True(node.AccessibilityObject.IsPatternSupported(UiaCore.UIA.ExpandCollapsePatternId));
-        Assert.True(node.childNodes.Count > 0);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_IsDisconnected_WhenTreeViewIsReleased()
-    {
-        using TreeView control = new();
-        AccessibilityObjectDisconnectTrackingTreeNode firstLevelNode = new(control);
-        control.Nodes.Add(firstLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode secondLevelNode = new(control);
-        firstLevelNode.Nodes.Add(secondLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode thirdLevelNode = new(control);
-        secondLevelNode.Nodes.Add(thirdLevelNode);
-        control.CreateControl();
-
-        control.ReleaseUiaProvider(control.HWND);
-
-        Assert.True(firstLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(secondLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(thirdLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_IsDisconnected_WhenRemoved()
-    {
-        using TreeView control = new();
-        AccessibilityObjectDisconnectTrackingTreeNode firstLevelNode = new(control);
-        control.Nodes.Add(firstLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode secondLevelNode = new(control);
-        firstLevelNode.Nodes.Add(secondLevelNode);
-        control.CreateControl();
-
-        control.Nodes.Remove(firstLevelNode);
-
-        Assert.True(firstLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(secondLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_IsDisconnected_WhenCleared()
-    {
-        using TreeView control = new();
-        AccessibilityObjectDisconnectTrackingTreeNode firstLevelNode = new(control);
-        control.Nodes.Add(firstLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode secondLevelNode = new(control);
-        firstLevelNode.Nodes.Add(secondLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode thirdLevelNode = new(control);
-        secondLevelNode.Nodes.Add(thirdLevelNode);
-        control.CreateControl();
-
-        control.Nodes.Clear();
-
-        Assert.True(firstLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(secondLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(thirdLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_IsDisconnected_WhenReplacedByIndex()
-    {
-        using TreeView control = new();
-        AccessibilityObjectDisconnectTrackingTreeNode firstLevelNode = new(control);
-        control.Nodes.Add(firstLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode secondLevelNode = new(control);
-        firstLevelNode.Nodes.Add(secondLevelNode);
-        AccessibilityObjectDisconnectTrackingTreeNode thirdLevelNode = new(control);
-        secondLevelNode.Nodes.Add(thirdLevelNode);
-        control.CreateControl();
-
-        control.Nodes[0] = new TreeNode();
-
-        Assert.True(firstLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(secondLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(thirdLevelNode.IsAccessibilityObjectDisconnected);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    private class AccessibilityObjectDisconnectTrackingTreeNode : TreeNode
-    {
-        public AccessibilityObjectDisconnectTrackingTreeNode(TreeView treeView) : base(treeView) { }
-
-        public bool IsAccessibilityObjectDisconnected { get; private set; }
-
-        internal override void ReleaseUiaProvider()
-        {
-            base.ReleaseUiaProvider();
-            IsAccessibilityObjectDisconnected = true;
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeCollectionTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeCollectionTests.cs
deleted file mode 100644
index ada9f83d8ec..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeCollectionTests.cs
+++ /dev/null
@@ -1,226 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeNodeCollectionTests
-{
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNodeCollection_Add_String_Success(string text, string expectedText)
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        TreeNode treeNode = collection.Add(text);
-        Assert.Same(treeNode, collection[0]);
-        Assert.Same(treeNode, Assert.Single(collection));
-        Assert.Equal(Color.Empty, treeNode.BackColor);
-        Assert.True(treeNode.Bounds.X > 0);
-        Assert.Equal(0, treeNode.Bounds.Y);
-        Assert.True(treeNode.Bounds.Width > 0);
-        Assert.True(treeNode.Bounds.Height > 0);
-        Assert.False(treeNode.Checked);
-        Assert.Null(treeNode.ContextMenuStrip);
-        Assert.Null(treeNode.FirstNode);
-        Assert.Equal(Color.Empty, treeNode.ForeColor);
-        Assert.Equal(expectedText, treeNode.FullPath);
-        Assert.Equal(-1, treeNode.ImageIndex);
-        Assert.Empty(treeNode.ImageKey);
-        Assert.Equal(0, treeNode.Index);
-        Assert.False(treeNode.IsEditing);
-        Assert.False(treeNode.IsExpanded);
-        Assert.False(treeNode.IsSelected);
-        Assert.True(treeNode.IsVisible);
-        Assert.Null(treeNode.LastNode);
-        Assert.Equal(0, treeNode.Level);
-        Assert.Empty(treeNode.Name);
-        Assert.Null(treeNode.NextNode);
-        Assert.Null(treeNode.NextVisibleNode);
-        Assert.Null(treeNode.NodeFont);
-        Assert.Empty(treeNode.Nodes);
-        Assert.Same(treeNode.Nodes, treeNode.Nodes);
-        Assert.Null(treeNode.Parent);
-        Assert.Null(treeNode.PrevNode);
-        Assert.Null(treeNode.PrevVisibleNode);
-        Assert.Equal(-1, treeNode.SelectedImageIndex);
-        Assert.Empty(treeNode.SelectedImageKey);
-        Assert.Equal(-1, treeNode.StateImageIndex);
-        Assert.Empty(treeNode.StateImageKey);
-        Assert.Null(treeNode.Tag);
-        Assert.Equal(expectedText, treeNode.Text);
-        Assert.Empty(treeNode.ToolTipText);
-        Assert.Same(treeView, treeNode.TreeView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void TreeNodeCollection_Item_GetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add("text");
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void TreeNodeCollection_Item_SetInvalidIndex_ThrowsArgumentOutOfRangeException(int index)
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add("text");
-        Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new TreeNode());
-    }
-
-    [WinFormsFact]
-    public void TreeNodeCollection_Item_SetNullTreeNode_ThrowsArgumentNullException()
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        TreeNode node = new TreeNode("Node 0");
-        collection.Add(node);
-        Assert.Throws<ArgumentNullException>(() => collection[0] = null);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeCollection_Item_SetTreeNodeAlreadyAdded_Noop()
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        TreeNode node = new TreeNode("Node 0");
-        collection.Add(node);
-        collection[0] = node;
-        Assert.Equal(1, collection.Count);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeCollection_Item_SetExistentTreeNodeDifferentIndex_ThrowsArgumentException()
-    {
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add("Node 0");
-        collection.Add("Node 1");
-        TreeNode node = collection[0];
-        Assert.Throws<ArgumentException>(() => collection[1] = node);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeCollection_Item_SetTreeNodeBoundToAnotherTreeView_ThrowsArgumentException()
-    {
-        using var anotherTreeView = new TreeView();
-        anotherTreeView.Nodes.Add("Node 0");
-
-        using var treeView = new TreeView();
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add("Node 1");
-        TreeNode nodeOfAnotherTreeView = anotherTreeView.Nodes[0];
-        Assert.Throws<ArgumentException>(() => collection[0] = nodeOfAnotherTreeView);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeCollection_Item_SetTreeNodeReplacesExistingOne()
-    {
-        using var treeView = new TreeView();
-        IntPtr forcedHandle = treeView.Handle;
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add("Node 1");
-        collection[0] = new TreeNode("New node 1");
-        Assert.Equal(1, treeView._nodesByHandle.Count);
-        Assert.Equal(1, collection.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData("name2")]
-    [InlineData("NAME2")]
-    public void TreeNodeCollection_Find_InvokeKeyExists_ReturnsExpected(string key)
-    {
-        using var treeView = new TreeView();
-        var child1 = new TreeNode
-        {
-            Name = "name1"
-        };
-        var child2 = new TreeNode
-        {
-            Name = "name2"
-        };
-        var child3 = new TreeNode
-        {
-            Name = "name2"
-        };
-
-        var grandchild1 = new TreeNode
-        {
-            Name = "name1"
-        };
-        var grandchild2 = new TreeNode
-        {
-            Name = "name2"
-        };
-        var grandchild3 = new TreeNode
-        {
-            Name = "name2"
-        };
-        child3.Nodes.Add(grandchild1);
-        child3.Nodes.Add(grandchild2);
-        child3.Nodes.Add(grandchild3);
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        // Search all children.
-        Assert.Equal(new TreeNode[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Call again.
-        Assert.Equal(new TreeNode[] { child2, child3, grandchild2, grandchild3 }, collection.Find(key, searchAllChildren: true));
-
-        // Don't search all children.
-        Assert.Equal(new TreeNode[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-
-        // Call again.
-        Assert.Equal(new TreeNode[] { child2, child3 }, collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [InlineData("NoSuchName")]
-    [InlineData("abcd")]
-    [InlineData("abcde")]
-    [InlineData("abcdef")]
-    public void TreeNodeCollection_Find_InvokeNoSuchKey_ReturnsEmpty(string key)
-    {
-        using var treeView = new TreeView();
-        var child1 = new TreeNode
-        {
-            Name = "name1"
-        };
-        var child2 = new TreeNode
-        {
-            Name = "name2"
-        };
-        var child3 = new TreeNode
-        {
-            Name = "name2"
-        };
-        TreeNodeCollection collection = treeView.Nodes;
-        collection.Add(child1);
-        collection.Add(child2);
-        collection.Add(child3);
-
-        Assert.Empty(collection.Find(key, searchAllChildren: true));
-        Assert.Empty(collection.Find(key, searchAllChildren: false));
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public void TreeNodeCollection_Find_NullOrEmptyKey_ThrowsArgumentNullException(string key)
-    {
-        using var treeView = new TreeView();
-        var collection = treeView.Nodes;
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: true));
-        Assert.Throws<ArgumentNullException>("key", () => collection.Find(key, searchAllChildren: false));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseClickEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseClickEventArgsTests.cs
deleted file mode 100644
index 9490c0bbcee..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseClickEventArgsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TreeNodeMouseClickEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_MouseButtons_Int_Int_Int_Int_TestData()
-    {
-        yield return new object[] { null, MouseButtons.Left, 1, 2, 3 };
-        yield return new object[] { new TreeNode(), (MouseButtons)1, 0, 0, 0 };
-        yield return new object[] { new TreeNode(), (MouseButtons)3, -1, -1, -1 };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_MouseButtons_Int_Int_Int_Int_TestData))]
-    public void Ctor_TreeNode_MouseButtons_Int_Int_Int_Int(TreeNode node, MouseButtons button, int clicks, int x, int y)
-    {
-        var e = new TreeNodeMouseClickEventArgs(node, button, clicks, x, y);
-        Assert.Equal(node, e.Node);
-        Assert.Equal(button, e.Button);
-        Assert.Equal(clicks, e.Clicks);
-        Assert.Equal(x, e.X);
-        Assert.Equal(y, e.Y);
-        Assert.Equal(0, e.Delta);
-        Assert.Equal(new Point(x, y), e.Location);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseHoverEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseHoverEventArgsTests.cs
deleted file mode 100644
index a78c44a1e52..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeMouseHoverEventArgsTests.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TreeNodeMouseHoverEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeNode() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_TestData))]
-    public void Ctor_TreeNode(TreeNode node)
-    {
-        var e = new TreeNodeMouseHoverEventArgs(node);
-        Assert.Equal(node, e.Node);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeTests.cs
deleted file mode 100644
index 8dd084273fb..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeNodeTests.cs
+++ /dev/null
@@ -1,4737 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.Serialization;
-using System.Windows.Forms.TestUtilities;
-using static Interop.ComCtl32;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeNodeTests
-{
-    [WinFormsFact]
-    public void TreeNode_Ctor_Default()
-    {
-        var node = new TreeNode();
-        Assert.Equal(Color.Empty, node.BackColor);
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(node.Checked);
-        Assert.Null(node.ContextMenuStrip);
-        Assert.Null(node.FirstNode);
-        Assert.Equal(Color.Empty, node.ForeColor);
-        Assert.Throws<InvalidOperationException>(() => node.FullPath);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.Equal(0, node.Index);
-        Assert.False(node.IsEditing);
-        Assert.False(node.IsExpanded);
-        Assert.False(node.IsSelected);
-        Assert.False(node.IsVisible);
-        Assert.Null(node.LastNode);
-        Assert.Equal(0, node.Level);
-        Assert.Empty(node.Name);
-        Assert.Null(node.NextNode);
-        Assert.Null(node.NextVisibleNode);
-        Assert.Null(node.NodeFont);
-        Assert.Empty(node.Nodes);
-        Assert.Same(node.Nodes, node.Nodes);
-        Assert.Null(node.Parent);
-        Assert.Null(node.PrevNode);
-        Assert.Null(node.PrevVisibleNode);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.Null(node.Tag);
-        Assert.Empty(node.Text);
-        Assert.Empty(node.ToolTipText);
-        Assert.Null(node.TreeView);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_Ctor_String(string text, string expectedText)
-    {
-        var node = new TreeNode(text);
-        Assert.Equal(Color.Empty, node.BackColor);
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(node.Checked);
-        Assert.Null(node.ContextMenuStrip);
-        Assert.Null(node.FirstNode);
-        Assert.Equal(Color.Empty, node.ForeColor);
-        Assert.Throws<InvalidOperationException>(() => node.FullPath);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.Equal(0, node.Index);
-        Assert.False(node.IsEditing);
-        Assert.False(node.IsExpanded);
-        Assert.False(node.IsSelected);
-        Assert.False(node.IsVisible);
-        Assert.Null(node.LastNode);
-        Assert.Equal(0, node.Level);
-        Assert.Empty(node.Name);
-        Assert.Null(node.NextNode);
-        Assert.Null(node.NextVisibleNode);
-        Assert.Null(node.NodeFont);
-        Assert.Empty(node.Nodes);
-        Assert.Same(node.Nodes, node.Nodes);
-        Assert.Null(node.Parent);
-        Assert.Null(node.PrevNode);
-        Assert.Null(node.PrevVisibleNode);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.Null(node.Tag);
-        Assert.Equal(expectedText, node.Text);
-        Assert.Empty(node.ToolTipText);
-        Assert.Null(node.TreeView);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Ctor_String_TreeNodeArray()
-    {
-        // Work around: We cannot serialize type System.Windows.Forms.TreeNode[] because it lives in the GAC.
-        TreeNode_Ctor_String_TreeNodeArray_Helper(null, Array.Empty<TreeNode>(), string.Empty);
-        TreeNode_Ctor_String_TreeNodeArray_Helper(string.Empty, Array.Empty<TreeNode>(), string.Empty);
-        TreeNode_Ctor_String_TreeNodeArray_Helper("text", new TreeNode[] { new TreeNode() }, "text");
-        TreeNode_Ctor_String_TreeNodeArray_Helper("text", new TreeNode[] { new TreeNode(), new TreeNode("text") }, "text");
-    }
-
-    private void TreeNode_Ctor_String_TreeNodeArray_Helper(string text, TreeNode[] children, string expectedText)
-    {
-        var node = new TreeNode(text, children);
-        Assert.Equal(Color.Empty, node.BackColor);
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(node.Checked);
-        Assert.Null(node.ContextMenuStrip);
-        Assert.Same(children.FirstOrDefault(), node.FirstNode);
-        Assert.Equal(Color.Empty, node.ForeColor);
-        Assert.Throws<InvalidOperationException>(() => node.FullPath);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.Equal(0, node.Index);
-        Assert.False(node.IsEditing);
-        Assert.False(node.IsExpanded);
-        Assert.False(node.IsSelected);
-        Assert.False(node.IsVisible);
-        Assert.Same(children.LastOrDefault(), node.LastNode);
-        Assert.Equal(0, node.Level);
-        Assert.Empty(node.Name);
-        Assert.Null(node.NextNode);
-        Assert.Null(node.NextVisibleNode);
-        Assert.Null(node.NodeFont);
-        Assert.Equal(children, node.Nodes.Cast<TreeNode>());
-        Assert.Same(node.Nodes, node.Nodes);
-        Assert.Null(node.Parent);
-        Assert.Null(node.PrevNode);
-        Assert.Null(node.PrevVisibleNode);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.Null(node.Tag);
-        Assert.Equal(expectedText, node.Text);
-        Assert.Empty(node.ToolTipText);
-        Assert.Null(node.TreeView);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, -1, -1, "")]
-    [InlineData(null, 0, 0, "")]
-    [InlineData("text", 1, 1, "text")]
-    [InlineData("text", 1, 14, "text")]
-    public void TreeNode_Ctor_String_Int_Int(string text, int imageIndex, int selectedImageIndex, string expectedText)
-    {
-        var node = new TreeNode(text, imageIndex, selectedImageIndex);
-        Assert.Equal(Color.Empty, node.BackColor);
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(node.Checked);
-        Assert.Null(node.ContextMenuStrip);
-        Assert.Null(node.FirstNode);
-        Assert.Equal(Color.Empty, node.ForeColor);
-        Assert.Throws<InvalidOperationException>(() => node.FullPath);
-        Assert.Equal(imageIndex, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.Equal(0, node.Index);
-        Assert.False(node.IsEditing);
-        Assert.False(node.IsExpanded);
-        Assert.False(node.IsSelected);
-        Assert.False(node.IsVisible);
-        Assert.Null(node.LastNode);
-        Assert.Equal(0, node.Level);
-        Assert.Empty(node.Name);
-        Assert.Null(node.NextNode);
-        Assert.Null(node.NextVisibleNode);
-        Assert.Null(node.NodeFont);
-        Assert.Empty(node.Nodes);
-        Assert.Same(node.Nodes, node.Nodes);
-        Assert.Null(node.Parent);
-        Assert.Null(node.PrevNode);
-        Assert.Null(node.PrevVisibleNode);
-        Assert.Equal(selectedImageIndex, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.Null(node.Tag);
-        Assert.Equal(expectedText, node.Text);
-        Assert.Empty(node.ToolTipText);
-        Assert.Null(node.TreeView);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Ctor_String_Int_Int_TreeNodeArray()
-    {
-        // Work around: We cannot serialize type System.Windows.Forms.TreeNode[] because it lives in the GAC.
-        TreeNode_Ctor_String_Int_Int_TreeNodeArray_Helper(null, -1, -1, Array.Empty<TreeNode>(), "");
-        TreeNode_Ctor_String_Int_Int_TreeNodeArray_Helper(null, 0, 0, Array.Empty<TreeNode>(), "");
-        TreeNode_Ctor_String_Int_Int_TreeNodeArray_Helper("text", 1, 1, new TreeNode[] { new TreeNode() }, "text");
-        TreeNode_Ctor_String_Int_Int_TreeNodeArray_Helper("text", 1, 14, new TreeNode[] { new TreeNode(), new TreeNode("text") }, "text");
-    }
-
-    private void TreeNode_Ctor_String_Int_Int_TreeNodeArray_Helper(string text, int imageIndex, int selectedImageIndex, TreeNode[] children, string expectedText)
-    {
-        var node = new TreeNode(text, imageIndex, selectedImageIndex, children);
-        Assert.Equal(Color.Empty, node.BackColor);
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(node.Checked);
-        Assert.Null(node.ContextMenuStrip);
-        Assert.Same(children.FirstOrDefault(), node.FirstNode);
-        Assert.Equal(Color.Empty, node.ForeColor);
-        Assert.Throws<InvalidOperationException>(() => node.FullPath);
-        Assert.Equal(imageIndex, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.Equal(0, node.Index);
-        Assert.False(node.IsEditing);
-        Assert.False(node.IsExpanded);
-        Assert.False(node.IsSelected);
-        Assert.False(node.IsVisible);
-        Assert.Same(children.LastOrDefault(), node.LastNode);
-        Assert.Equal(0, node.Level);
-        Assert.Empty(node.Name);
-        Assert.Null(node.NextNode);
-        Assert.Null(node.NextVisibleNode);
-        Assert.Null(node.NodeFont);
-        Assert.Equal(children, node.Nodes.Cast<TreeNode>());
-        Assert.Same(node.Nodes, node.Nodes);
-        Assert.Null(node.Parent);
-        Assert.Null(node.PrevNode);
-        Assert.Null(node.PrevVisibleNode);
-        Assert.Equal(selectedImageIndex, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.Null(node.Tag);
-        Assert.Equal(expectedText, node.Text);
-        Assert.Empty(node.ToolTipText);
-        Assert.Null(node.TreeView);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Ctor_NullChildren_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("nodes", () => new TreeNode("text", null));
-        Assert.Throws<ArgumentNullException>("nodes", () => new TreeNode("text", 0, 0, null));
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Ctor_NullValueInChildren_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("node", () => new TreeNode("text", new TreeNode[] { null }));
-        Assert.Throws<ArgumentNullException>("node", () => new TreeNode("text", 0, 0, new TreeNode[] { null }));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-3)]
-    public void TreeNode_Ctor_InvalidImageIndex_ThrowsArgumentOutOfRangeException(int imageIndex)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new TreeNode("text", imageIndex, 0));
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new TreeNode("text", imageIndex, 0, Array.Empty<TreeNode>()));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-3)]
-    public void TreeNode_Ctor_InvalidSelectedImageIndex_ThrowsArgumentOutOfRangeException(int selectedImageIndex)
-    {
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new TreeNode("text", 0, selectedImageIndex));
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => new TreeNode("text", 0, selectedImageIndex, Array.Empty<TreeNode>()));
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_BackColor_Set_GetReturnsExpected(Color value)
-    {
-        var node = new TreeNode
-        {
-            BackColor = value
-        };
-        Assert.Equal(value, node.BackColor);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_BackColor_SetWithTreeView_GetReturnsExpected(Color value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, 0 };
-        yield return new object[] { Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithTreeViewWithHandle_TestData))]
-    public void TreeNode_BackColor_SetWithTreeViewWithHandle_GetReturnsExpected(Color value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Blue };
-        yield return new object[] { Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithCustomOldValue_TestData))]
-    public void TreeNode_BackColor_SetWithCustomOldValue_GetReturnsExpected(Color value)
-    {
-        var node = new TreeNode
-        {
-            BackColor = Color.Blue
-        };
-
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_BackColor_SetWithCustomOldValueWithTreeView_GetReturnsExpected(Color value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode
-        {
-            BackColor = Color.Blue
-        };
-        control.Nodes.Add(node);
-
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithCustomOldValueWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, 1 };
-        yield return new object[] { Color.Red, 1 };
-        yield return new object[] { Color.Blue, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithCustomOldValueWithTreeViewWithHandle_TestData))]
-    public void TreeNode_BackColor_SetWithCustomOldValueWithTreeViewWithHandle_GetReturnsExpected(Color value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode
-        {
-            BackColor = Color.Blue
-        };
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.BackColor = value;
-        Assert.Equal(value, node.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_BackColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TreeNode))[nameof(TreeNode.BackColor)];
-        var node = new TreeNode();
-        Assert.False(property.CanResetValue(node));
-
-        node.BackColor = Color.Red;
-        Assert.Equal(Color.Red, node.BackColor);
-        Assert.False(property.CanResetValue(node));
-
-        property.ResetValue(node);
-        Assert.Equal(Color.Red, node.BackColor);
-        Assert.False(property.CanResetValue(node));
-    }
-
-    [WinFormsFact]
-    public void TreeNode_BackColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TreeNode))[nameof(TreeNode.BackColor)];
-        var node = new TreeNode();
-        Assert.False(property.ShouldSerializeValue(node));
-
-        node.BackColor = Color.Red;
-        Assert.Equal(Color.Red, node.BackColor);
-        Assert.True(property.ShouldSerializeValue(node));
-
-        property.ResetValue(node);
-        Assert.Equal(Color.Red, node.BackColor);
-        Assert.True(property.ShouldSerializeValue(node));
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Bounds_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Rectangle bounds = node.Bounds;
-        Assert.True(bounds.X > 0);
-        Assert.Equal(0, bounds.Y);
-        Assert.True(bounds.Width > 0);
-        Assert.True(bounds.Height > 0);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Bounds_GetWithTreeViewWithHandle_Success()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Rectangle bounds = node.Bounds;
-        Assert.True(bounds.X > 0);
-        Assert.Equal(0, bounds.Y);
-        Assert.True(bounds.Width > 0);
-        Assert.True(bounds.Height > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Bounds_Get_CustomGetItemRect_TestData()
-    {
-        yield return new object[] { new RECT(), Rectangle.Empty };
-        yield return new object[] { new RECT(1, 2, 3, 4), new Rectangle(1, 2, 2, 2) };
-
-        yield return new object[] { new RECT(0, 1, 3, 4), new Rectangle(0, 1, 3, 3) };
-        yield return new object[] { new RECT(1, 0, 3, 4), new Rectangle(1, 0, 2, 4) };
-        yield return new object[] { new RECT(1, 2, 0, 4), new Rectangle(1, 2, -1, 2) };
-        yield return new object[] { new RECT(1, 2, 3, 0), new Rectangle(1, 2, 2, -2) };
-        yield return new object[] { new RECT(0, 0, 3, 4), new Rectangle(0, 0, 3, 4) };
-
-        yield return new object[] { new RECT(-1, 0, 3, 4), new Rectangle(-1, 0, 4, 4) };
-        yield return new object[] { new RECT(1, -2, 3, 4), new Rectangle(1, -2, 2, 6) };
-        yield return new object[] { new RECT(1, 2, -3, 4), new Rectangle(1, 2, -4, 2) };
-        yield return new object[] { new RECT(1, 2, 3, -4), new Rectangle(1, 2, 2, -6) };
-        yield return new object[] { new RECT(-3, -4, -1, -2), new Rectangle(-3, -4, 2, 2) };
-
-        yield return new object[] { new RECT(1, 118, 3, 4), new Rectangle(1, 118, 2, -114) };
-        yield return new object[] { new RECT(1, 117, 3, 4), new Rectangle(1, 117, 2, -113) };
-        yield return new object[] { new RECT(94, 2, 3, 4), new Rectangle(94, 2, -91, 2) };
-        yield return new object[] { new RECT(93, 2, 3, 4), new Rectangle(93, 2, -90, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Bounds_Get_CustomGetItemRect_TestData))]
-    public void TreeNode_Bounds_GetCustomGetItemRect_ReturnsExpected(object getItemRectResult, Rectangle expected)
-    {
-        using var control = new CustomGetItemRectTreeView
-        {
-            GetItemRectResult = (RECT)getItemRectResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, node.Bounds);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Bounds_GetInvalidGetItemRect_ReturnsExpected()
-    {
-        using var control = new InvalidGetItemRectTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeInvalid = true;
-
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Bounds_GetWithTreeViewDisposed_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.Equal(Rectangle.Empty, node.Bounds);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNode_Checked_Set_GetReturnsExpected(bool value)
-    {
-        var node = new TreeNode
-        {
-            Checked = value
-        };
-        Assert.Equal(value, node.Checked);
-
-        // Set same
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-
-        // Set different
-        node.Checked = !value;
-        Assert.Equal(!value, node.Checked);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TreeNode_Checked_SetWithTreeView_GetReturnsExpected(bool checkBoxes, bool value)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        node.Checked = !value;
-        Assert.Equal(!value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TreeNode_Checked_SetWithTreeViewWithHandle_GetReturnsExpected(bool checkBoxes, bool value)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different
-        node.Checked = !value;
-        Assert.Equal(!value, node.Checked);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 8192)]
-    [InlineData(true, false, 4096)]
-    [InlineData(false, true, 8192)]
-    [InlineData(false, false, 4096)]
-    public void TreeNode_Checked_GetItemState_ReturnsExpected(bool checkBoxes, bool @checked, int expectedValue)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.Checked = @checked;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal((TVIS)expectedValue, item.state);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeNode_Checked_SetWithTreeViewDisposed_GetReturnsExpected(bool value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.Checked = value;
-        Assert.Equal(value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different
-        node.Checked = !value;
-        Assert.Equal(!value, node.Checked);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_ForeColor_Set_GetReturnsExpected(Color value)
-    {
-        var node = new TreeNode
-        {
-            ForeColor = value
-        };
-        Assert.Equal(value, node.ForeColor);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_ForeColor_SetWithTreeView_GetReturnsExpected(Color value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, 0 };
-        yield return new object[] { Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithTreeViewWithHandle_TestData))]
-    public void TreeNode_ForeColor_SetWithTreeViewWithHandle_GetReturnsExpected(Color value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { Color.Empty };
-        yield return new object[] { Color.Blue };
-        yield return new object[] { Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithCustomOldValue_TestData))]
-    public void TreeNode_ForeColor_SetWithCustomOldValue_GetReturnsExpected(Color value)
-    {
-        var node = new TreeNode
-        {
-            ForeColor = Color.Blue
-        };
-
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void TreeNode_ForeColor_SetWithCustomOldValueWithTreeView_GetReturnsExpected(Color value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode
-        {
-            ForeColor = Color.Blue
-        };
-        control.Nodes.Add(node);
-
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithCustomOldValueWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, 1 };
-        yield return new object[] { Color.Red, 1 };
-        yield return new object[] { Color.Blue, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithCustomOldValueWithTreeViewWithHandle_TestData))]
-    public void TreeNode_ForeColor_SetWithCustomOldValueWithTreeViewWithHandle_GetReturnsExpected(Color value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode
-        {
-            ForeColor = Color.Blue
-        };
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.ForeColor = value;
-        Assert.Equal(value, node.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_ForeColor_ResetValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TreeNode))[nameof(TreeNode.ForeColor)];
-        var node = new TreeNode();
-        Assert.False(property.CanResetValue(node));
-
-        node.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, node.ForeColor);
-        Assert.False(property.CanResetValue(node));
-
-        property.ResetValue(node);
-        Assert.Equal(Color.Red, node.ForeColor);
-        Assert.False(property.CanResetValue(node));
-    }
-
-    [WinFormsFact]
-    public void TreeNode_ForeColor_ShouldSerializeValue_Success()
-    {
-        PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(TreeNode))[nameof(TreeNode.ForeColor)];
-        var node = new TreeNode();
-        Assert.False(property.ShouldSerializeValue(node));
-
-        node.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, node.ForeColor);
-        Assert.True(property.ShouldSerializeValue(node));
-
-        property.ResetValue(node);
-        Assert.Equal(Color.Red, node.ForeColor);
-        Assert.True(property.ShouldSerializeValue(node));
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Handle_GetWithoutTreeView_ReturnsExpected()
-    {
-        var node = new TreeNode();
-        IntPtr handle = node.Handle;
-        Assert.Equal(IntPtr.Zero, handle);
-        Assert.Equal(handle, node.Handle);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Handle_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        IntPtr handle = node.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Equal(handle, node.Handle);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 8192)]
-    [InlineData(true, false, 4096)]
-    [InlineData(false, true, 0)]
-    [InlineData(false, false, 0)]
-    public void TreeNode_Handle_GetChecked_ReturnsExpected(bool checkBoxes, bool @checked, int expectedValue)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode
-        {
-            Checked = @checked
-        };
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal((TVIS)expectedValue, item.state);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Handle_GetWithTreeViewDisposed_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-        IntPtr handle = node.Handle;
-        Assert.NotEqual(IntPtr.Zero, handle);
-        Assert.Equal(handle, node.Handle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> TreeNode_ImageIndex_TestData()
-    {
-        // { image index, expected index without image, expected index with image }
-        yield return new object[] { -2, -2, -2 };
-        yield return new object[] { -1, -1, -1 };
-        yield return new object[] { 0, -1, 0 };
-        yield return new object[] { 1, -1, 0 };
-        yield return new object[] { 2, -1, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_ImageIndex_SetWithoutTreeView_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_ImageIndex_SetWithImageKey_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            ImageKey = "ImageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.ImageKey);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.ImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.ImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_ImageIndex_SetWithTreeView_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_ImageIndex_SetWithTreeViewWithEmptyList_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageIndex = value;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, -2)]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void TreeNode_ImageIndex_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageIndex = value;
-        Assert.Equal(expected, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(expected, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_ImageIndex_SetWithTreeViewWithHandle_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.ImageIndex);
-        Assert.Empty(node.ImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    public void TreeNode_ImageIndex_GetItemWithoutImageList_Success(int value, int expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 2)]
-    public void TreeNode_ImageIndex_GetItemWithEmptyImageList_Success(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 2)]
-    public void TreeNode_ImageIndex_GetItemWithImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TreeNode_ImageIndex_SetWithTreeViewDisposed_GetReturnsExpected(int value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.ImageIndex = value;
-        Assert.Equal(value, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-3)]
-    public void TreeNode_ImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        var node = new TreeNode();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => node.ImageIndex = value);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_ImageIndex_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.ImageIndex = 0;
-        Assert.Equal(0, node.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_ImageKey_SetWithoutTreeView_GetReturnsExpected(string value, string expected)
-    {
-        var node = new TreeNode
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("ImageKey", "ImageKey")]
-    public void TreeNode_ImageKey_SetWithImageIndex_GetReturnsExpected(string value, string expectedImageKey)
-    {
-        var node = new TreeNode
-        {
-            ImageIndex = 0,
-            ImageKey = value
-        };
-        Assert.Equal(expectedImageKey, node.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.ImageIndex);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expectedImageKey, node.ImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_ImageKey_SetWithTreeView_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_ImageKey_SetWithTreeViewWithEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Image1", "Image1")]
-    [InlineData("image1", "image1")]
-    [InlineData("Image2", "Image2")]
-    [InlineData("NoSuchImage", "NoSuchImage")]
-    public void TreeNode_ImageKey_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_ImageKey_SetWithTreeViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.Equal(-1, node.ImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Image1")]
-    [InlineData("image1")]
-    [InlineData("Image2")]
-    [InlineData("NoSuchImage")]
-    public void TreeNode_ImageKey_GetItemWithoutImageList_Success(string value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(0, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("Image1", 0)]
-    [InlineData("image1", 0)]
-    [InlineData("Image2", 0)]
-    [InlineData("NoSuchImage", 0)]
-    public void TreeNode_ImageKey_GetItemWithEmptyImageList_Success(string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(expected, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("Image1", 0)]
-    [InlineData("image1", 0)]
-    [InlineData("Image2", 1)]
-    [InlineData("NoSuchImage", 0)]
-    public void TreeNode_ImageKey_GetItemWithImageList_Success(string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.ImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(expected, column.iImage);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_ImageKey_SetWithTreeViewDisposed_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.ImageKey = value;
-        Assert.Equal(expected, node.ImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_ImageKey_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.ImageKey = "Key";
-        Assert.Equal("Key", node.ImageKey);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Index_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Equal(0, node.Index);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Index_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, node.Index);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Index_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Equal(0, node1.Index);
-        Assert.Equal(1, node2.Index);
-        Assert.Equal(2, node3.Index);
-        Assert.Equal(0, node4.Index);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Index_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Equal(0, node1.Index);
-        Assert.Equal(1, node2.Index);
-        Assert.Equal(2, node3.Index);
-        Assert.Equal(0, node4.Index);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Index_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, node1.Index);
-        Assert.Equal(1, node2.Index);
-        Assert.Equal(2, node3.Index);
-        Assert.Equal(0, node4.Index);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsEditing_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsEditing);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsEditing_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(node.IsEditing);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsEditing_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.False(node.IsEditing);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsExpanded_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsExpanded_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(node.IsExpanded);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, false)]
-    [InlineData((int)TVIS.BOLD, false)]
-    [InlineData((int)TVIS.EXPANDED, true)]
-    [InlineData((int)(TVIS.EXPANDED | TVIS.BOLD), true)]
-    [InlineData((int)TVIS.EXPANDEDONCE, false)]
-    public void TreeNode_IsExpanded_GetCustomGetItem_ReturnsExpected(int getItemStateResult, bool expected)
-    {
-        using var control = new CustomGetItemTreeView
-        {
-            GetItemStateResult = (TVIS)getItemStateResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, node.IsExpanded);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, false)]
-    [InlineData((int)TVIS.BOLD, false)]
-    [InlineData((int)TVIS.EXPANDED, true)]
-    [InlineData((int)(TVIS.EXPANDED | TVIS.BOLD), true)]
-    [InlineData((int)TVIS.EXPANDEDONCE, false)]
-    public void TreeNode_IsExpanded_GetInvalidGetItem_ReturnsExpected(int getItemStateResult, bool expected)
-    {
-        using var control = new InvalidGetItemTreeView
-        {
-            GetItemStateResult = (TVIS)getItemStateResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Equal(expected, node.IsExpanded);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsExpanded_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.False(node.IsExpanded);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsSelected_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsSelected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsSelected_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(node.IsSelected);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, false)]
-    [InlineData((int)TVIS.BOLD, false)]
-    [InlineData((int)TVIS.SELECTED, true)]
-    [InlineData((int)(TVIS.SELECTED | TVIS.BOLD), true)]
-    public void TreeNode_IsSelected_GetCustomGetItem_ReturnsExpected(int getItemStateResult, bool expected)
-    {
-        using var control = new CustomGetItemTreeView
-        {
-            GetItemStateResult = (TVIS)getItemStateResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, node.IsSelected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, false)]
-    [InlineData((int)TVIS.BOLD, false)]
-    [InlineData((int)TVIS.SELECTED, true)]
-    [InlineData((int)(TVIS.SELECTED | TVIS.BOLD), true)]
-    public void TreeNode_IsSelected_GetInvalidGetItem_ReturnsExpected(int getItemStateResult, bool expected)
-    {
-        using var control = new InvalidGetItemTreeView
-        {
-            GetItemStateResult = (TVIS)getItemStateResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        Assert.Equal(expected, node.IsSelected);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsSelected_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.False(node.IsSelected);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsVisible_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.False(node.IsVisible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsVisible_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(node.IsVisible);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> IsVisible_Get_CustomGetItemRect_TestData()
-    {
-        yield return new object[] { new RECT(), false };
-        yield return new object[] { new RECT(1, 2, 3, 4), true };
-
-        yield return new object[] { new RECT(0, 1, 3, 4), true };
-        yield return new object[] { new RECT(1, 0, 3, 4), true };
-        yield return new object[] { new RECT(1, 2, 0, 4), false };
-        yield return new object[] { new RECT(1, 2, 3, 0), false };
-        yield return new object[] { new RECT(0, 0, 3, 4), true };
-
-        yield return new object[] { new RECT(-1, 0, 3, 4), true };
-        yield return new object[] { new RECT(1, -2, 3, 4), true };
-        yield return new object[] { new RECT(1, 2, -3, 4), false };
-        yield return new object[] { new RECT(1, 2, 3, -4), false };
-        yield return new object[] { new RECT(-3, -4, -1, -2), false };
-
-        yield return new object[] { new RECT(1, 118, 3, 4), false };
-        yield return new object[] { new RECT(1, 117, 3, 4), false };
-        yield return new object[] { new RECT(94, 2, 3, 4), true };
-        yield return new object[] { new RECT(93, 2, 3, 4), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsVisible_Get_CustomGetItemRect_TestData))]
-    public void TreeNode_IsVisible_GetCustomGetItemRect_ReturnsExpected(object getItemRectResult, bool expected)
-    {
-        using var control = new CustomGetItemRectTreeView
-        {
-            GetItemRectResult = (RECT)getItemRectResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Equal(expected, node.IsVisible);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsVisible_GetInvalidGetItemRect_ReturnsExpected()
-    {
-        using var control = new InvalidGetItemRectTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MakeInvalid = true;
-
-        Assert.False(node.IsVisible);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_IsVisible_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.False(node.IsVisible);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Level_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Equal(0, node.Level);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Level_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, node.Level);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Level_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Equal(1, node1.Level);
-        Assert.Equal(1, node2.Level);
-        Assert.Equal(1, node3.Level);
-        Assert.Equal(2, node4.Level);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Level_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Equal(1, node1.Level);
-        Assert.Equal(1, node2.Level);
-        Assert.Equal(1, node3.Level);
-        Assert.Equal(2, node4.Level);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Level_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(1, node1.Level);
-        Assert.Equal(1, node2.Level);
-        Assert.Equal(1, node3.Level);
-        Assert.Equal(2, node4.Level);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_Name_Set_GetReturnsExpected(string value, string expected)
-    {
-        var node = new TreeNode
-        {
-            Name = value
-        };
-        Assert.Equal(expected, node.Name);
-
-        // Set same.
-        node.Name = value;
-        Assert.Equal(expected, node.Name);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextNode_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Null(node.NextNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextNode_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node.NextNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextNode_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Equal(node2, node1.NextNode);
-        Assert.Equal(node3, node2.NextNode);
-        Assert.Null(node3.NextNode);
-        Assert.Null(node4.NextNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextNode_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Equal(node2, node1.NextNode);
-        Assert.Equal(node3, node2.NextNode);
-        Assert.Null(node3.NextNode);
-        Assert.Null(node4.NextNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextNode_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(node2, node1.NextNode);
-        Assert.Equal(node3, node2.NextNode);
-        Assert.Null(node3.NextNode);
-        Assert.Null(node4.NextNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextVisibleNode_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Null(node.NextVisibleNode);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextVisibleNode_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node.NextVisibleNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextVisibleNode_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.Null(node.NextVisibleNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextVisibleNode_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Null(node1.NextVisibleNode);
-        Assert.Null(node2.NextVisibleNode);
-        Assert.Null(node3.NextVisibleNode);
-        Assert.Null(node4.NextVisibleNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextVisibleNode_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Null(node1.NextVisibleNode);
-        Assert.Null(node2.NextVisibleNode);
-        Assert.Null(node3.NextVisibleNode);
-        Assert.Null(node4.NextVisibleNode);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_NextVisibleNode_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node1.NextVisibleNode);
-        Assert.Null(node2.NextVisibleNode);
-        Assert.Null(node3.NextVisibleNode);
-        Assert.Null(node4.NextVisibleNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_NextVisibleNode_GetCustomGetNextItem_ReturnsExpected()
-    {
-        using var control = new CustomGetNextItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeCustom = true;
-        control.GetNextItemResult = node.Handle;
-        try
-        {
-            Assert.Same(node, node.NextVisibleNode);
-        }
-        finally
-        {
-            control.MakeCustom = false;
-        }
-    }
-
-    public static IEnumerable<object[]> NextVisibleNode_InvalidGetNextItem_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NextVisibleNode_InvalidGetNextItem_TestData))]
-    public void TreeNode_NextVisibleNode_GetInvalidGetNextItem_ReturnsExpected(IntPtr getNextItemResult)
-    {
-        using var control = new CustomGetNextItemTreeView
-        {
-            GetNextItemResult = getNextItemResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeCustom = true;
-        try
-        {
-            Assert.Null(node.NextVisibleNode);
-        }
-        finally
-        {
-            control.MakeCustom = false;
-        }
-    }
-
-    private class CustomGetNextItemTreeView : TreeView
-    {
-        public IntPtr GetNextItemResult { get; set; }
-        public bool MakeCustom { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.TVM_GETNEXTITEM)
-            {
-                Assert.Equal((IntPtr)PInvoke.TVGN_NEXTVISIBLE, m.WParam);
-                Assert.NotEqual(IntPtr.Zero, m.LParam);
-                m.Result = GetNextItemResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Parent_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Null(node.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_Parent_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Parent_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Equal(parent, node1.Parent);
-        Assert.Equal(parent, node2.Parent);
-        Assert.Equal(parent, node3.Parent);
-        Assert.Equal(node3, node4.Parent);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Parent_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Equal(parent, node1.Parent);
-        Assert.Equal(parent, node2.Parent);
-        Assert.Equal(parent, node3.Parent);
-        Assert.Equal(node3, node4.Parent);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Parent_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(parent, node1.Parent);
-        Assert.Equal(parent, node2.Parent);
-        Assert.Equal(parent, node3.Parent);
-        Assert.Equal(node3, node4.Parent);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevNode_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Null(node.PrevNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevNode_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node.PrevNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevNode_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Null(node1.PrevNode);
-        Assert.Equal(node1, node2.PrevNode);
-        Assert.Equal(node2, node3.PrevNode);
-        Assert.Null(node4.PrevNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevNode_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Null(node1.PrevNode);
-        Assert.Equal(node1, node2.PrevNode);
-        Assert.Equal(node2, node3.PrevNode);
-        Assert.Null(node4.PrevNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevNode_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node1.PrevNode);
-        Assert.Equal(node1, node2.PrevNode);
-        Assert.Equal(node2, node3.PrevNode);
-        Assert.Null(node4.PrevNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevVisibleNode_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Null(node.PrevVisibleNode);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevVisibleNode_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node.PrevVisibleNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevVisibleNode_GetWithTreeViewDisposed_ReturnsFalse()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Dispose();
-        Assert.Null(node.PrevVisibleNode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevVisibleNode_GetWithParent_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Null(node1.PrevVisibleNode);
-        Assert.Null(node2.PrevVisibleNode);
-        Assert.Null(node3.PrevVisibleNode);
-        Assert.Null(node4.PrevVisibleNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevVisibleNode_GetWithParentWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Null(node1.PrevVisibleNode);
-        Assert.Null(node2.PrevVisibleNode);
-        Assert.Null(node3.PrevVisibleNode);
-        Assert.Null(node4.PrevVisibleNode);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_PrevVisibleNode_GetWithParentWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(node1.PrevVisibleNode);
-        Assert.Null(node2.PrevVisibleNode);
-        Assert.Null(node3.PrevVisibleNode);
-        Assert.Null(node4.PrevVisibleNode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_PrevVisibleNode_GetCustomGetPreviousItem_ReturnsExpected()
-    {
-        using var control = new CustomGetPreviousItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeCustom = true;
-        control.GetPreviousItemResult = node.Handle;
-        try
-        {
-            Assert.Same(node, node.PrevVisibleNode);
-        }
-        finally
-        {
-            control.MakeCustom = false;
-        }
-    }
-
-    public static IEnumerable<object[]> PrevVisibleNode_InvalidGetPreviousItemResult_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { (IntPtr)1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PrevVisibleNode_InvalidGetPreviousItemResult_TestData))]
-    public void TreeNode_PrevVisibleNode_InvalidGetPreviousItemResult_ReturnsExpected(IntPtr getPreviousItemResult)
-    {
-        using var control = new CustomGetPreviousItemTreeView
-        {
-            GetPreviousItemResult = getPreviousItemResult
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeCustom = true;
-        try
-        {
-            Assert.Null(node.PrevVisibleNode);
-        }
-        finally
-        {
-            control.MakeCustom = false;
-        }
-    }
-
-    private class CustomGetPreviousItemTreeView : TreeView
-    {
-        public IntPtr GetPreviousItemResult { get; set; }
-        public bool MakeCustom { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeCustom && m.Msg == (int)PInvoke.TVM_GETNEXTITEM)
-            {
-                Assert.Equal((IntPtr)PInvoke.TVGN_PREVIOUSVISIBLE, m.WParam);
-                Assert.NotEqual(IntPtr.Zero, m.LParam);
-                m.Result = GetPreviousItemResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TreeNode_NodeFont_Set_GetReturnsExpected(Font value)
-    {
-        var node = new TreeNode
-        {
-            NodeFont = value
-        };
-        Assert.Equal(value, node.NodeFont);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TreeNode_NodeFont_SetWithTreeView_GetReturnsExpected(Font value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> NodeFont_SetWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { null, 0 };
-        yield return new object[] { new Font("Arial", 8.25f), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NodeFont_SetWithTreeViewWithHandle_TestData))]
-    public void TreeNode_NodeFont_SetWithTreeViewWithHandle_GetReturnsExpected(Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TreeNode_NodeFont_SetWithCustomOldValue_GetReturnsExpected(Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        var node = new TreeNode
-        {
-            NodeFont = oldValue
-        };
-
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TreeNode_NodeFont_SetWithCustomOldValueWithTreeView_GetReturnsExpected(Font value)
-    {
-        using var control = new TreeView();
-        using var oldValue = new Font("Arial", 1);
-        var node = new TreeNode
-        {
-            NodeFont = oldValue
-        };
-        control.Nodes.Add(node);
-
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> NodeFont_SetWithCustomOldValueWithTreeViewWithHandle_TestData()
-    {
-        yield return new object[] { null, 1 };
-        yield return new object[] { new Font("Arial", 8.25f), 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NodeFont_SetWithCustomOldValueWithTreeViewWithHandle_TestData))]
-    public void TreeNode_NodeFont_SetWithCustomOldValueWithTreeViewWithHandle_GetReturnsExpected(Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        using var oldValue = new Font("Arial", 1);
-        var node = new TreeNode
-        {
-            NodeFont = oldValue
-        };
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.NodeFont = value;
-        Assert.Equal(value, node.NodeFont);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(2, 0)]
-    public void TreeNode_SelectedImageIndex_SetWithoutTreeView_GetReturnsExpected(int value, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            SelectedImageIndex = value
-        };
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_SelectedImageIndex_SetWithSelectedImageKey_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            SelectedImageKey = "SelectedImageKey",
-            SelectedImageIndex = value
-        };
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.SelectedImageKey);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.SelectedImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.SelectedImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.SelectedImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_SelectedImageIndex_SetWithTreeView_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_SelectedImageIndex_SetWithTreeViewWithEmptyList_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageIndex = value;
-        Assert.Equal(expectedWithoutImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(expectedWithoutImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, -2)]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void TreeNode_SelectedImageIndex_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageIndex = value;
-        Assert.Equal(expected, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(expected, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNode_ImageIndex_TestData))]
-    public void TreeNode_SelectedImageIndex_SetWithTreeViewWithHandle_GetReturnsExpected(int value, int expectedWithoutImage, int expectedWithImage)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.ImageList = imageList;
-        Assert.Equal(expectedWithoutImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.SelectedImageIndex);
-        Assert.Empty(node.SelectedImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    public void TreeNode_SelectedImageIndex_GetItemWithoutImageList_Success(int value, int expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_IMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 2)]
-    public void TreeNode_SelectedImageIndex_GetItemWithEmptyImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_SELECTEDIMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2, 0)]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 2)]
-    public void TreeNode_SelectedImageIndex_GetItemWithImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_SELECTEDIMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, item.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TreeNode_SelectedImageIndex_SetWithTreeViewDisposed_GetReturnsExpected(int value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.SelectedImageIndex = value;
-        Assert.Equal(value, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-3)]
-    public void TreeNode_SelectedImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        var node = new TreeNode();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => node.SelectedImageIndex = value);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_SelectedImageIndex_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.SelectedImageIndex = 0;
-        Assert.Equal(0, node.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_SelectedImageKey_SetWithoutTreeView_GetReturnsExpected(string value, string expected)
-    {
-        var node = new TreeNode
-        {
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("SelectedImageKey", "SelectedImageKey")]
-    public void TreeNode_SelectedImageKey_SetWithSelectedImageIndex_GetReturnsExpected(string value, string expectedSelectedImageKey)
-    {
-        var node = new TreeNode
-        {
-            SelectedImageIndex = 0,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expectedSelectedImageKey, node.SelectedImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.SelectedImageIndex);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expectedSelectedImageKey, node.SelectedImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_SelectedImageKey_SetWithTreeView_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_SelectedImageKey_SetWithTreeViewWithEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("Image1", "Image1")]
-    [InlineData("image1", "image1")]
-    [InlineData("Image2", "Image2")]
-    [InlineData("NoSuchImage", "NoSuchImage")]
-    public void TreeNode_SelectedImageKey_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_SelectedImageKey_SetWithTreeViewWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.Equal(-1, node.SelectedImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Image1")]
-    [InlineData("image1")]
-    [InlineData("Image2")]
-    [InlineData("NoSuchImage")]
-    public void TreeNode_SelectedImageKey_GetItemWithoutImageList_Success(string value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_SELECTEDIMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(0, column.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("Image1", 0)]
-    [InlineData("image1", 0)]
-    [InlineData("Image2", 0)]
-    [InlineData("NoSuchImage", 0)]
-    public void TreeNode_SelectedImageKey_GetItemWithEmptyImageList_Success(string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_SELECTEDIMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(expected, column.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("Image1", 0)]
-    [InlineData("image1", 0)]
-    [InlineData("Image2", 1)]
-    [InlineData("NoSuchImage", 0)]
-    public void TreeNode_SelectedImageKey_GetItemWithImageList_Success(string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            ImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.SelectedImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_SELECTEDIMAGE,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal(expected, column.iSelectedImage);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_SelectedImageKey_SetWithTreeViewDisposed_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.SelectedImageKey = value;
-        Assert.Equal(expected, node.SelectedImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_SelectedImageKey_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.SelectedImageKey = "Key";
-        Assert.Equal("Key", node.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(2, 0)]
-    [InlineData(14, 0)]
-    public void TreeNode_StateImageIndex_SetWithoutTreeView_GetReturnsExpected(int value, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            StateImageIndex = value
-        };
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 0)]
-    [InlineData(2, 0)]
-    [InlineData(14, 0)]
-    public void TreeNode_StateImageIndex_SetWithStateImageKey_GetReturnsExpected(int value, int expectedWithImage)
-    {
-        var node = new TreeNode
-        {
-            StateImageKey = "StateImageKey",
-            StateImageIndex = value
-        };
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.StateImageKey);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.StateImageKey);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.StateImageIndex);
-        Assert.Equal(ImageList.Indexer.DefaultKey, node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StateImageIndex_SetWithTreeView_TestData()
-    {
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { checkBoxes, -1, -1 };
-            yield return new object[] { checkBoxes, 0, 0 };
-            yield return new object[] { checkBoxes, 1, 0 };
-            yield return new object[] { checkBoxes, 2, 0 };
-            yield return new object[] { checkBoxes, 14, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageIndex_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageIndex_SetWithTreeView_GetReturnsExpected(bool checkBoxes, int value, int expectedWithImage)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageIndex_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageIndex_SetWithTreeViewWithEmptyList_GetReturnsExpected(bool checkBoxes, int value, int expectedWithImage)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageIndex = value;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StateImageIndex_SetWithTreeViewNotEmptyList_TestData()
-    {
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { checkBoxes, -1, -1 };
-            yield return new object[] { checkBoxes, 0, 0 };
-            yield return new object[] { checkBoxes, 1, 1 };
-            yield return new object[] { checkBoxes, 2, 1 };
-            yield return new object[] { checkBoxes, 14, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageIndex_SetWithTreeViewNotEmptyList_TestData))]
-    public void TreeNode_StateImageIndex_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(bool checkBoxes, int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageIndex = value;
-        Assert.Equal(expected, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(expected, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StateImageIndex_SetWithTreeViewWithHandle_TestData()
-    {
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { checkBoxes, -1, checkBoxes ? 1 : 0 };
-            yield return new object[] { checkBoxes, 0, checkBoxes ? 1 : 0 };
-            yield return new object[] { checkBoxes, 1, checkBoxes ? 1 : 0 };
-            yield return new object[] { checkBoxes, 2, checkBoxes ? 1 : 0 };
-            yield return new object[] { checkBoxes, 14, checkBoxes ? 1 : 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageIndex_SetWithTreeViewWithHandle_TestData))]
-    public void TreeNode_StateImageIndex_SetWithTreeViewWithHandle_GetReturnsExpected(bool checkBoxes, int value, int expectedCreatedCallCount)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -1, 4096)]
-    [InlineData(true, 0, 4096)]
-    [InlineData(true, 1, 4096)]
-    [InlineData(true, 14, 4096)]
-    [InlineData(false, -1, 0)]
-    [InlineData(false, 0, 4096)]
-    [InlineData(false, 1, 8192)]
-    [InlineData(false, 14, 61440)]
-    public void TreeNode_StateImageIndex_GetColumnWithoutImageList_Success(bool checkBoxes, int value, int expected)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal((TVIS)expected, item.state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 4096)]
-    [InlineData(1, 8192)]
-    [InlineData(2, 12288)]
-    [InlineData(14, 61440)]
-    public void TreeNode_StateImageIndex_GetColumnWithEmptyImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal((TVIS)expected, item.state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 4096)]
-    [InlineData(1, 8192)]
-    [InlineData(2, 12288)]
-    [InlineData(14, 61440)]
-    public void TreeNode_StateImageIndex_GetColumnWithImageList_Success(int value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image1);
-        imageList.Images.Add(image2);
-        using var control = new TreeView
-        {
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageIndex = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal((TVIS)expected, item.state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, -1, -1)]
-    [InlineData(true, 0, 0)]
-    [InlineData(true, 1, 0)]
-    [InlineData(true, 14, 0)]
-    [InlineData(false, -1, -1)]
-    [InlineData(false, 0, 0)]
-    [InlineData(false, 1, 0)]
-    [InlineData(false, 14, 0)]
-    public void TreeNode_StateImageIndex_SetWithTreeViewDisposed_GetReturnsExpected(bool checkBoxes, int value, int expectedWithImage)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.StateImageIndex = value;
-        Assert.Equal(value, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Add to image list.
-        using var image = new Bitmap(10, 10);
-        imageList.Images.Add(image);
-        Assert.Equal(expectedWithImage, node.StateImageIndex);
-        Assert.Empty(node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(15)]
-    public void TreeNode_StateImageIndex_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        var node = new TreeNode();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => node.StateImageIndex = value);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_StateImageIndex_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.StateImageIndex = 0;
-        Assert.Equal(0, node.StateImageIndex);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(-1, node.StateImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_StateImageKey_SetWithoutTreeView_GetReturnsExpected(string value, string expected)
-    {
-        var node = new TreeNode
-        {
-            StateImageKey = value
-        };
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("StateImageKey", "StateImageKey")]
-    public void TreeNode_StateImageKey_SetWithStateImageIndex_GetReturnsExpected(string value, string expectedStateImageKey)
-    {
-        var node = new TreeNode
-        {
-            StateImageIndex = 0,
-            StateImageKey = value
-        };
-        Assert.Equal(expectedStateImageKey, node.StateImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.StateImageIndex);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expectedStateImageKey, node.StateImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.StateImageIndex);
-
-        // Set tree view.
-        using var control = new TreeView();
-        control.Nodes.Add(node);
-        Assert.Equal(expectedStateImageKey, node.StateImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.StateImageIndex);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(expectedStateImageKey, node.StateImageKey);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, node.StateImageIndex);
-    }
-
-    public static IEnumerable<object[]> StateImageKey_SetWithTreeView_TestData()
-    {
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { checkBoxes, null, string.Empty };
-            yield return new object[] { checkBoxes, string.Empty, string.Empty };
-            yield return new object[] { checkBoxes, "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageKey_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageKey_SetWithTreeView_GetReturnsExpected(bool checkBoxes, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Add image list.
-        using var imageList = new ImageList();
-        control.StateImageList = imageList;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageKey_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageKey_SetWithTreeViewWithEmptyList_GetReturnsExpected(bool checkBoxes, string value, string expected)
-    {
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> StateImageKey_SetWithTreeViewWithImageList_TestData()
-    {
-        foreach (bool checkBoxes in new bool[] { true, false })
-        {
-            yield return new object[] { checkBoxes, null, "" };
-            yield return new object[] { checkBoxes, "", "" };
-            yield return new object[] { checkBoxes, "Image1", "Image1" };
-            yield return new object[] { checkBoxes, "image1", "image1" };
-            yield return new object[] { checkBoxes, "Image2", "Image2" };
-            yield return new object[] { checkBoxes, "NoSuchImage", "NoSuchImage" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageKey_SetWithTreeViewWithImageList_TestData))]
-    public void TreeNode_StateImageKey_SetWithTreeViewWithNotEmptyList_GetReturnsExpected(bool checkBoxes, string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageKey_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageKey_SetWithTreeViewWithHandle_GetReturnsExpected(bool checkBoxes, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.Equal(-1, node.StateImageIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Image1")]
-    [InlineData("image1")]
-    [InlineData("Image2")]
-    [InlineData("NoSuchImage")]
-    public void TreeNode_StateImageKey_GetColumnWithoutImageList_Success(string value)
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal((TVIS)0, column.state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, null, 4096)]
-    [InlineData(true, "", 4096)]
-    [InlineData(true, "Image1", 4096)]
-    [InlineData(true, "image1", 4096)]
-    [InlineData(true, "Image2", 4096)]
-    [InlineData(true, "NoSuchImage", 4096)]
-    [InlineData(false, null, 0)]
-    [InlineData(false, "", 0)]
-    [InlineData(false, "Image1", 0)]
-    [InlineData(false, "image1", 0)]
-    [InlineData(false, "Image2", 0)]
-    [InlineData(false, "NoSuchImage", 0)]
-    public void TreeNode_StateImageKey_GetColumnWithEmptyImageList_Success(bool checkBoxes, string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal((TVIS)expected, column.state);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, null, 4096)]
-    [InlineData(true, "", 4096)]
-    [InlineData(true, "Image1", 4096)]
-    [InlineData(true, "image1", 4096)]
-    [InlineData(true, "Image2", 4096)]
-    [InlineData(true, "NoSuchImage", 4096)]
-    [InlineData(false, null, 0)]
-    [InlineData(false, "", 0)]
-    [InlineData(false, "Image1", 4096)]
-    [InlineData(false, "image1", 4096)]
-    [InlineData(false, "Image2", 8192)]
-    [InlineData(false, "NoSuchImage", 0)]
-    public void TreeNode_StateImageKey_GetColumnWithImageList_Success(bool checkBoxes, string value, int expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add("Image1", image1);
-        imageList.Images.Add("Image2", image2);
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes,
-            StateImageList = imageList
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.StateImageKey = value;
-        var column = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_STATE,
-            stateMask = TVIS.STATEIMAGEMASK,
-            hItem = node.Handle
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref column));
-        Assert.Equal((TVIS)expected, column.state);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(StateImageKey_SetWithTreeView_TestData))]
-    public void TreeNode_StateImageKey_SetWithTreeViewDisposed_GetReturnsExpected(bool checkBoxes, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.StateImageKey = value;
-        Assert.Equal(expected, node.StateImageKey);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_StateImageKey_SetInvalidSetItem_ThrowsInvalidOperationException()
-    {
-        using var control = new InvalidSetItemTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.MakeInvalid = true;
-        node.StateImageKey = "Key";
-        Assert.Equal("Key", node.StateImageKey);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TreeNode_Tag_Set_GetReturnsExpected(string value)
-    {
-        var node = new TreeNode
-        {
-            Tag = value
-        };
-        Assert.Same(value, node.Tag);
-
-        // Set same.
-        node.Tag = value;
-        Assert.Same(value, node.Tag);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeNode_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        var node = new TreeNode
-        {
-            Text = value
-        };
-        Assert.Equal(expected, node.Text);
-
-        // Set same.
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithTreeView_TestData()
-    {
-        foreach (bool scrollable in new bool[] { true, false })
-        {
-            yield return new object[] { scrollable, null, string.Empty };
-            yield return new object[] { scrollable, string.Empty, string.Empty };
-            yield return new object[] { scrollable, "text", "text" };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithTreeView_TestData))]
-    public void TreeNode_Text_SetWithTreeView_GetReturnsExpected(bool scrollable, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            Scrollable = scrollable
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithTreeView_TestData))]
-    public void TreeNode_Text_SetWithTreeViewWithHandle_GetReturnsExpected(bool scrollable, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            Scrollable = scrollable
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithTreeView_TestData))]
-    public unsafe void TreeNode_Text_GetItem_Success(bool scrollable, string value, string expected)
-    {
-        using var image1 = new Bitmap(10, 10);
-        using var image2 = new Bitmap(10, 10);
-        using var control = new TreeView
-        {
-            Scrollable = scrollable
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        char* textBuffer = stackalloc char[256];
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        node.Text = value;
-        var item = new TVITEMW
-        {
-            mask = TVITEM_MASK.TVIF_HANDLE | TVITEM_MASK.TVIF_TEXT,
-            hItem = node.Handle,
-            cchTextMax = 256,
-            pszText = (IntPtr)textBuffer
-        };
-        Assert.Equal(1, (int)PInvoke.SendMessage(control, PInvoke.TVM_GETITEMW, 0, ref item));
-        Assert.Equal(expected, new string((char*)item.pszText));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithTreeView_TestData))]
-    public void TreeNode_Text_SetWithTreeViewDisposed_GetReturnsExpected(bool scrollable, string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            Scrollable = scrollable
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Dispose();
-
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same
-        node.Text = value;
-        Assert.Equal(expected, node.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TreeNode_ToolTipText_Set_GetReturnsExpected(string value)
-    {
-        var node = new TreeNode
-        {
-            ToolTipText = value
-        };
-        Assert.Same(value, node.ToolTipText);
-
-        // Set same.
-        node.ToolTipText = value;
-        Assert.Same(value, node.ToolTipText);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_TreeView_GetWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-
-        Assert.Same(control, node.TreeView);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_TreeView_GetWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Same(control, node.TreeView);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_TreeView_GetWithTreeView_ReturnsExpected()
-    {
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.Null(node1.TreeView);
-        Assert.Null(node2.TreeView);
-        Assert.Null(node3.TreeView);
-        Assert.Null(node4.TreeView);
-    }
-
-    [WinFormsFact]
-    public void TreeView_TreeView_GetWithTreeViewWithTreeView_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-
-        Assert.Same(control, node1.TreeView);
-        Assert.Same(control, node2.TreeView);
-        Assert.Same(control, node3.TreeView);
-        Assert.Same(control, node4.TreeView);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_TreeView_GetWithTreeViewWithTreeViewWithHandle_ReturnsExpected()
-    {
-        using var control = new TreeView();
-        var parent = new TreeNode();
-        var node1 = new TreeNode();
-        var node2 = new TreeNode();
-        var node3 = new TreeNode();
-        var node4 = new TreeNode();
-        control.Nodes.Add(parent);
-        parent.Nodes.Add(node1);
-        parent.Nodes.Add(node2);
-        parent.Nodes.Add(node3);
-        node3.Nodes.Add(node4);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Same(control, node1.TreeView);
-        Assert.Same(control, node2.TreeView);
-        Assert.Same(control, node3.TreeView);
-        Assert.Same(control, node4.TreeView);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_InvokeGetSelfAndChildNodes_ReturnsExpected()
-    {
-        TreeNode rootNode = new TreeNode();
-        TreeNode subNodeLevel1 = new TreeNode();
-        TreeNode subNodeLevel2 = new TreeNode();
-        TreeNode subNodeLevel3 = new TreeNode();
-        subNodeLevel2.Nodes.Add(subNodeLevel3);
-        subNodeLevel1.Nodes.Add(subNodeLevel2);
-        rootNode.Nodes.Add(subNodeLevel1);
-        List<TreeNode> nodes = rootNode.GetSelfAndChildNodes();
-        Assert.Equal(4, nodes.Count);
-        Assert.Contains(rootNode, nodes);
-        Assert.Contains(subNodeLevel1, nodes);
-        Assert.Contains(subNodeLevel2, nodes);
-        Assert.Contains(subNodeLevel3, nodes);
-    }
-
-    [WinFormsFact]
-    public void TreeNode_InvokeAdd_WithoutTree_DoesNotAddNodeToTrackList()
-    {
-        TreeNode treeNode = new TreeNode();
-        TreeNode treeSubNode = new TreeNode();
-        treeNode.Nodes.Add(treeSubNode);
-
-        Assert.False((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(treeNode));
-        Assert.False((bool)KeyboardToolTipStateMachine.Instance.TestAccessor().Dynamic.IsToolTracked(treeSubNode));
-    }
-
-    private class InvalidSetItemTreeView : TreeView
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.TVM_SETITEMW)
-            {
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class CustomGetItemTreeView : TreeView
-    {
-        public TVIS GetItemStateResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.TVM_GETITEMW)
-            {
-                TVITEMW* pItem = (TVITEMW*)m.LParam;
-                pItem->state = GetItemStateResult;
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class InvalidGetItemTreeView : TreeView
-    {
-        public bool MakeInvalid { get; set; }
-
-        public TVIS GetItemStateResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.TVM_GETITEMW)
-            {
-                TVITEMW* pItem = (TVITEMW*)m.LParam;
-                pItem->state = GetItemStateResult;
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                m.Result = (IntPtr)0;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class CustomGetItemRectTreeView : TreeView
-    {
-        public RECT GetItemRectResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.TVM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = GetItemRectResult;
-                Assert.Equal((IntPtr)1, m.WParam);
-                m.Result = (IntPtr)1;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class InvalidGetItemRectTreeView : TreeView
-    {
-        public bool MakeInvalid { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (MakeInvalid && m.Msg == (int)PInvoke.TVM_GETITEMRECT)
-            {
-                RECT* pRect = (RECT*)m.LParam;
-                *pRect = new RECT(1, 2, 3, 4);
-                m.Result = IntPtr.Zero;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    private class SubTreeNode : TreeNode
-    {
-        public SubTreeNode(SerializationInfo serializationInfo, StreamingContext context) : base(serializationInfo, context)
-        {
-        }
-
-        public new void Deserialize(SerializationInfo serializationInfo, StreamingContext context) => base.Deserialize(serializationInfo, context);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeView.TreeViewAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeView.TreeViewAccessibleObjectTests.cs
deleted file mode 100644
index db56ff41d56..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeView.TreeViewAccessibleObjectTests.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using static System.Windows.Forms.TreeView;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeViewAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_Ctor_Default()
-    {
-        using TreeView control = new();
-        control.CreateControl();
-
-        Assert.NotNull(control.AccessibilityObject);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_Ctor_ThrowsException_IfOwnerIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new TreeViewAccessibleObject(null));
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_ControlType_IsTree_IfAccessibleRoleIsDefault()
-    {
-        using TreeView control = new();
-
-        // AccessibleRole is not set = Default
-        object actual = control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.TreeControlTypeId, actual);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_Role_IsOutline_ByDefault()
-    {
-        using TreeView control = new();
-        control.CreateControl();
-
-        // AccessibleRole is not set = Default
-        AccessibleRole actual = control.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.Outline, actual);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_FragmentRoot_ReturnsExpected()
-    {
-        using TreeView control = new();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-
-        Assert.Equal(accessibleObject, accessibleObject.FragmentRoot);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_FragmentNavigate_FirstChild_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new("Node 1"), new("Node 2"), new("Node 3") });
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        AccessibleObject expected = control.Nodes[0].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_FragmentNavigate_LastChild_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new("Node 1"), new("Node 2"), new("Node 3") });
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        AccessibleObject expected = control.Nodes[^1].AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    [InlineData(10)]
-    public void TreeViewAccessibleObject_FragmentNavigate_GetChild_ReturnsExpected(int index)
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new("Node 1"), new("Node 2"), new("Node 3") });
-
-        AccessibleObject expected = index >= 0 && index < control.Nodes.Count
-            ? control.Nodes[index].AccessibilityObject
-            : null;
-
-        Assert.Equal(expected, control.AccessibilityObject.GetChild(index));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_FragmentNavigate_GetChildCount_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.Nodes.AddRange(new TreeNode[] { new("Node 1"), new("Node 2"), new("Node 3") });
-
-        int expected = 3;
-
-        Assert.Equal(expected, control.AccessibilityObject.GetChildCount());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeViewAccessibleObject_GetPropertyValue_IsEnabled_ReturnsExpected(bool isEnabled)
-    {
-        using TreeView control = new() { Enabled = isEnabled };
-
-        Assert.Equal(isEnabled, control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsTrue_IfNoItems()
-    {
-        using TreeView control = new();
-
-        Assert.True(control.Enabled);
-        Assert.True((bool)control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsFalse_IfIsDisabled()
-    {
-        using TreeView control = new() { Enabled = false };
-
-        Assert.False(control.Enabled);
-        Assert.False((bool)control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsFalse_IfContainsItems()
-    {
-        using TreeView control = new();
-        control.Nodes.Add("Node 1");
-
-        Assert.True(control.Enabled);
-        Assert.False((bool)control.AccessibilityObject.GetPropertyValue(UiaCore.UIA.HasKeyboardFocusPropertyId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessiblePatternId)]
-    [InlineData((int)UiaCore.UIA.SelectionPatternId)]
-    public void TreeViewAccessibleObject_IsPatternSupported_ReturnsExpected(int patternId)
-    {
-        using TreeView control = new();
-
-        Assert.True(control.AccessibilityObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_IsSelectionRequired_ReturnsTrue_IfControlHasItem()
-    {
-        using TreeView control = new();
-        control.Nodes.Add("Item1");
-
-        Assert.True(control.AccessibilityObject.IsSelectionRequired);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_IsSelectionRequired_ReturnsFalse_IfControlHasNoItem()
-    {
-        using TreeView control = new();
-
-        Assert.False(control.AccessibilityObject.IsSelectionRequired);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetSelection_ReturnsEmptyArray_IfControlIsNotCreated()
-    {
-        using TreeView control = new();
-
-        Assert.Empty(control.AccessibilityObject.GetSelection());
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetSelection_ReturnsEmptyArray_IfNoSelectedNodes()
-    {
-        using TreeView control = new();
-        control.CreateControl();
-
-        Assert.Empty(control.AccessibilityObject.GetSelection());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeViewAccessibleObject_GetSelection_ReturnsExpected()
-    {
-        using TreeView control = new();
-        control.CreateControl();
-        control.Nodes.AddRange(new TreeNode[] { new("Node 1"), new("Node 2"), new("Node 3") });
-        control.SelectedNode = control.Nodes[1];
-
-        UiaCore.IRawElementProviderSimple[] expected = new[] { control.Nodes[1].AccessibilityObject };
-
-        Assert.Equal(expected, control.AccessibilityObject.GetSelection());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_HitTest_ReturnsNull_IfControlDoesNotCreated()
-    {
-        using TreeView control = new() { Size = new Size(300, 100) };
-        TreeNode node = new("First node.");
-        control.Nodes.Add(node);
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        Point point = accessibleObject.Bounds.Location;
-
-        Assert.Null(accessibleObject.HitTest(point.X, point.Y));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_HitTest_ReturnsTree()
-    {
-        using TreeView control = new() { Size = new Size(300, 100) };
-        TreeNode node = new("First node.");
-        control.Nodes.Add(node);
-        control.CreateControl();
-
-        AccessibleObject accessibleObject = control.AccessibilityObject;
-        Point point = new Point(accessibleObject.Bounds.X, accessibleObject.Bounds.Bottom - 1);
-
-        Assert.Equal(accessibleObject, accessibleObject.HitTest(point.X, point.Y));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeNodeAccessibleObject_HitTest_ReturnsNode()
-    {
-        using TreeView control = new() { Size = new Size(300, 100) };
-        TreeNode node = new("First node.");
-        control.Nodes.Add(node);
-        control.CreateControl();
-
-        Point point = node.AccessibilityObject.Bounds.Location;
-
-        Assert.Equal(node.AccessibilityObject, control.AccessibilityObject.HitTest(point.X, point.Y));
-        Assert.True(control.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewCancelEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewCancelEventArgsTests.cs
deleted file mode 100644
index 95bf157b6ed..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewCancelEventArgsTests.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TreeViewCancelEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_Bool_TreeViewAction_TestData()
-    {
-        yield return new object[] { null, false, (TreeViewAction)(TreeViewAction.Unknown - 1) };
-        yield return new object[] { new TreeNode(), true, TreeViewAction.ByKeyboard };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_Bool_TreeViewAction_TestData))]
-    public void Ctor_TreeNode_Bool_TreeViewAction(TreeNode node, bool cancel, TreeViewAction action)
-    {
-        var e = new TreeViewCancelEventArgs(node, cancel, action);
-        Assert.Equal(node, e.Node);
-        Assert.Equal(cancel, e.Cancel);
-        Assert.Equal(action, e.Action);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewEventArgsTests.cs
deleted file mode 100644
index 38f24ca4f16..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewEventArgsTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TreeViewEventArgsTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeNode() };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_TestData))]
-    public void Ctor_TreeNode(TreeNode node)
-    {
-        var e = new TreeViewEventArgs(node);
-        Assert.Equal(node, e.Node);
-        Assert.Equal(TreeViewAction.Unknown, e.Action);
-    }
-
-    public static IEnumerable<object[]> Ctor_TreeNode_TreeViewAction_TestData()
-    {
-        yield return new object[] { null, (TreeViewAction)(TreeViewAction.Unknown - 1) };
-        yield return new object[] { new TreeNode(), TreeViewAction.ByKeyboard };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_TreeNode_TreeViewAction_TestData))]
-    public void Ctor_TreeNode_TreeViewAction(TreeNode node, TreeViewAction action)
-    {
-        var e = new TreeViewEventArgs(node, action);
-        Assert.Equal(node, e.Node);
-        Assert.Equal(action, e.Action);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewHitTestInfoTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewHitTestInfoTests.cs
deleted file mode 100644
index 0d3d325a65a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewHitTestInfoTests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeViewHitTestInfoTests
-{
-    public static IEnumerable<object[]> Ctor_TreeNode_TreeViewHitTestLocations_TestData()
-    {
-        foreach (TreeViewHitTestLocations hitLocation in Enum.GetValues(typeof(TreeViewHitTestLocations)))
-        {
-            yield return new object[] { null, hitLocation };
-            yield return new object[] { new TreeNode(), hitLocation };
-        }
-
-        yield return new object[] { null, 0 };
-        yield return new object[] { new TreeNode(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Ctor_TreeNode_TreeViewHitTestLocations_TestData))]
-    public void TreeViewHitTestInfo_Ctor_TreeNode_TreeViewHitTestLocations(TreeNode hitNode, TreeViewHitTestLocations hitLocation)
-    {
-        var hitTestInfo = new TreeViewHitTestInfo(hitNode, hitLocation);
-        Assert.Same(hitNode, hitTestInfo.Node);
-        Assert.Equal(hitLocation, hitTestInfo.Location);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewImageIndexConverterTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewImageIndexConverterTests.cs
deleted file mode 100644
index b48e633401a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewImageIndexConverterTests.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.ComponentModel.TypeConverter;
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TreeViewImageIndexConverterTests
-{
-    [Fact]
-    public void TreeViewImageIndexConverter_IncludeNoneAsStandardValue_ReturnsFalse()
-    {
-        Assert.False(new TreeViewImageIndexConverter().TestAccessor().Dynamic.IncludeNoneAsStandardValue);
-    }
-
-    [Fact]
-    public void TreeViewImageIndexConverter_ConvertTo_destinationType_null_ThrowsArgumentNullException()
-    {
-        var converter = new TreeViewImageIndexConverter();
-
-        Assert.Throws<ArgumentNullException>("destinationType", () => converter.ConvertTo(context: null, culture: null, new object(), destinationType: null));
-    }
-
-    public static IEnumerable<object[]> TreeViewImageIndexConverter_ConvertFrom_special_string_to_int_ReturnsExpected_TestData()
-    {
-        yield return new object[] { SR.toStringDefault, -1, };
-        yield return new object[] { SR.toStringDefault, ImageList.Indexer.DefaultIndex };
-        yield return new object[] { SR.toStringNone, -2 };
-        yield return new object[] { SR.toStringNone, ImageList.Indexer.NoneIndex };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewImageIndexConverter_ConvertFrom_special_string_to_int_ReturnsExpected_TestData))]
-    public void TreeViewImageIndexConverter_ConvertFrom_special_string_to_int_ReturnsExpected(object value, object expected)
-    {
-        var converter = new TreeViewImageIndexConverter();
-
-        object result = converter.ConvertFrom(context: null, culture: null, value);
-
-        Assert.Equal(expected, result);
-    }
-
-    public static IEnumerable<object[]> TreeViewImageIndexConverter_ConvertTo_special_int_to_string_ReturnsExpected_TestData()
-    {
-        yield return new object[] { -1, SR.toStringDefault };
-        yield return new object[] { ImageList.Indexer.DefaultIndex, SR.toStringDefault };
-        yield return new object[] { -2, SR.toStringNone };
-        yield return new object[] { ImageList.Indexer.NoneIndex, SR.toStringNone };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewImageIndexConverter_ConvertTo_special_int_to_string_ReturnsExpected_TestData))]
-    public void TreeViewImageIndexConverter_ConvertTo_special_int_to_string_ReturnsExpected(object value, object expected)
-    {
-        var converter = new TreeViewImageIndexConverter();
-
-        object result = converter.ConvertTo(context: null, culture: null, value, destinationType: typeof(string));
-
-        Assert.Equal(expected, result);
-    }
-
-    [Fact]
-    public void TreeViewImageIndexConverter_GetStandardValues_Null_Context_ReturnsExpected()
-    {
-        var converter = new TreeViewImageIndexConverter();
-
-        StandardValuesCollection result = converter.GetStandardValues(context: null);
-
-        Assert.Equal(2, result.Count);
-        Assert.Equal(ImageList.Indexer.DefaultIndex, result[0]);
-        Assert.Equal(ImageList.Indexer.NoneIndex, result[1]);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewTests.cs
deleted file mode 100644
index c63399439a4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TreeViewTests.cs
+++ /dev/null
@@ -1,7269 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Moq;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class TreeViewTests
-{
-    [WinFormsFact]
-    public void TreeView_Ctor_Default()
-    {
-        using var control = new SubTreeView();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(97, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 121, 97), control.Bounds);
-        Assert.True(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.False(control.CheckBoxes);
-        Assert.Equal(117, control.ClientSize.Width);
-        Assert.Equal(93, control.ClientSize.Height);
-        Assert.Equal(new Rectangle(0, 0, 117, 93), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(121, 97), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 117, 93), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.Equal(TreeViewDrawMode.Normal, control.DrawMode);
-        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.False(control.FullRowSelect);
-        Assert.False(control.HasChildren);
-        Assert.Equal(97, control.Height);
-        Assert.True(control.HideSelection);
-        Assert.False(control.HotTracking);
-        Assert.Equal(-1, control.ImageIndex);
-        Assert.Equal(string.Empty, control.ImageKey);
-        Assert.Null(control.ImageList);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.Equal(19, control.Indent);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(Control.DefaultFont.Height + 3, control.ItemHeight);
-        Assert.False(control.LabelEdit);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Color.Empty, control.LineColor);
-        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.Same(control.Nodes, control.Nodes);
-        Assert.Empty(control.Nodes);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("\\", control.PathSeparator);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(121, 97), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(121, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.Scrollable);
-        Assert.Equal(-1, control.SelectedImageIndex);
-        Assert.Equal(string.Empty, control.SelectedImageKey);
-        Assert.Null(control.SelectedNode);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowLines);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.False(control.ShowNodeToolTips);
-        Assert.True(control.ShowPlusMinus);
-        Assert.True(control.ShowRootLines);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(121, 97), control.Size);
-        Assert.False(control.Sorted);
-        Assert.Null(control.StateImageList);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.Null(control.TopNode);
-        Assert.Null(control.TreeViewNodeSorter);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(0, control.VisibleCount);
-        Assert.Equal(121, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTreeView();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_CreateParams_GetDefaultWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56010007, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x56010007, 0x200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56810007, 0)]
-    public void TreeView_CreateParams_GetBorder_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubTreeView
-        {
-            BorderStyle = borderStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010007)]
-    [InlineData(false, 0x56012007)]
-    public void TreeView_CreateParams_GetScrollable_ReturnsExpected(bool scrollable, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            Scrollable = scrollable
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010007)]
-    [InlineData(false, 0x56010027)]
-    public void TreeView_CreateParams_GetHideSelection_ReturnsExpected(bool hideSelection, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            HideSelection = hideSelection
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x5601000F)]
-    [InlineData(false, 0x56010007)]
-    public void TreeView_CreateParams_GetLabelEdit_ReturnsExpected(bool labelEdit, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            LabelEdit = labelEdit
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010007)]
-    [InlineData(false, 0x56010005)]
-    public void TreeView_CreateParams_GetShowLines_ReturnsExpected(bool showLines, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            ShowLines = showLines
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010007)]
-    [InlineData(false, 0x56010006)]
-    public void TreeView_CreateParams_GetShowPlusMinus_ReturnsExpected(bool showPlusMinus, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            ShowPlusMinus = showPlusMinus
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010007)]
-    [InlineData(false, 0x56010003)]
-    public void TreeView_CreateParams_GetShowRootLines_ReturnsExpected(bool showRootLines, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            ShowRootLines = showRootLines
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010207)]
-    [InlineData(false, 0x56010007)]
-    public void TreeView_CreateParams_GetHotTracking_ReturnsExpected(bool hotTracking, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            HotTracking = hotTracking
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56011007)]
-    [InlineData(false, 0x56010007)]
-    public void TreeView_CreateParams_GetFullRowSelect_ReturnsExpected(bool fullRowSelect, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            FullRowSelect = fullRowSelect
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TreeView_CreateParams_GetItemHeight_ReturnsExpected(int value)
-    {
-        using var control = new SubTreeView
-        {
-            ItemHeight = value
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void TreeView_CreateParams_GetItemHeightWithHandle_ReturnsExpected(int itemHeight)
-    {
-        using var control = new SubTreeView
-        {
-            ItemHeight = itemHeight
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(11, 0x56014007, 1)]
-    [InlineData(12, 0x56010007, 0)]
-    public void TreeView_CreateParams_GetItemHeightInSetterWithHandle_ReturnsExpected(int itemHeight, int expectedStyle, int expectedCreatedCallCount)
-    {
-        using var control = new SubTreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) =>
-        {
-            CreateParams createParams = control.CreateParams;
-            Assert.Null(createParams.Caption);
-            Assert.Equal("SysTreeView32", createParams.ClassName);
-            Assert.Equal(0x8, createParams.ClassStyle);
-            Assert.Equal(0x200, createParams.ExStyle);
-            Assert.Equal(97, createParams.Height);
-            Assert.Equal(IntPtr.Zero, createParams.Parent);
-            Assert.Null(createParams.Param);
-            Assert.Equal(expectedStyle, createParams.Style);
-            Assert.Equal(121, createParams.Width);
-            Assert.Equal(0, createParams.X);
-            Assert.Equal(0, createParams.Y);
-            Assert.Same(createParams, control.CreateParams);
-            Assert.True(control.IsHandleCreated);
-            createdCallCount++;
-        };
-        control.ItemHeight = itemHeight;
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(true, false)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public void TreeView_CreateParams_GetShowNodeTooltips_ReturnsExpected(bool designMode, bool showNodeTooltips)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        using var control = new SubTreeView
-        {
-            Site = mockSite.Object,
-            ShowNodeToolTips = showNodeTooltips
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x56010007)]
-    [InlineData(true, false, 0x56010007)]
-    [InlineData(false, true, 0x56010807)]
-    [InlineData(false, false, 0x56010007)]
-    public void TreeView_CreateParams_GetShowNodeTooltipsWithHandle_ReturnsExpected(bool designMode, bool showNodeTooltips, int expectedStyle)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(designMode);
-        using var control = new SubTreeView
-        {
-            Site = mockSite.Object,
-            ShowNodeToolTips = showNodeTooltips
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TreeView_CreateParams_GetCheckBoxes_ReturnsExpected(bool checkBoxes)
-    {
-        using var control = new SubTreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010007, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x56010107)]
-    [InlineData(false, 0x56010007)]
-    public void TreeView_CreateParams_GetCheckBoxesWithHandle_ReturnsExpected(bool checkBoxes, int expectedStyle)
-    {
-        using var control = new SubTreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true, 0x56010007, 0x200)]
-    [InlineData(RightToLeft.No, true, 0x56010007, 0x200)]
-    [InlineData(RightToLeft.Yes, true, 0x56010007, 0x400200)]
-    [InlineData(RightToLeft.Inherit, false, 0x56010007, 0x200)]
-    [InlineData(RightToLeft.No, false, 0x56010007, 0x200)]
-    [InlineData(RightToLeft.Yes, false, 0x56010047, 0x7200)]
-    public void TreeView_CreateParams_GetRightToLeft_ReturnsExpected(RightToLeft rightToLeft, bool rightToLeftLayout, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubTreeView
-        {
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("SysTreeView32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(97, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(121, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void TreeView_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TreeView
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window, 0 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void TreeView_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void TreeView_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new TreeView
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void TreeView_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new TreeView
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TreeView_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImageLayout>]
-    public void BackgroundImageLayout_SetInvalid_ThrowsInvalidEnumArgumentException(ImageLayout value)
-    {
-        using var control = new TreeView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BackgroundImageLayout = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var treeView = new TreeView
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, treeView.BorderStyle);
-
-        // Set same.
-        treeView.BorderStyle = value;
-        Assert.Equal(value, treeView.BorderStyle);
-    }
-
-    [WinFormsFact]
-    public void BorderStyle_SetWithUpdateStylesHandler_CallsStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            BorderStyle = BorderStyle.Fixed3D
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.BorderStyle = BorderStyle.None;
-        Assert.Equal(BorderStyle.None, treeView.BorderStyle);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.BorderStyle = BorderStyle.None;
-        Assert.Equal(BorderStyle.None, treeView.BorderStyle);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.BorderStyle = BorderStyle.FixedSingle;
-        Assert.Equal(BorderStyle.FixedSingle, treeView.BorderStyle);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.BorderStyle = BorderStyle.Fixed3D;
-        Assert.Equal(BorderStyle.Fixed3D, treeView.BorderStyle);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void BorderStyle_SetWithInvalidatedWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            BorderStyle = BorderStyle.Fixed3D
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.BorderStyle = BorderStyle.None;
-        Assert.Equal(BorderStyle.None, treeView.BorderStyle);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.BorderStyle = BorderStyle.None;
-        Assert.Equal(BorderStyle.None, treeView.BorderStyle);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.BorderStyle = BorderStyle.FixedSingle;
-        Assert.Equal(BorderStyle.FixedSingle, treeView.BorderStyle);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.BorderStyle = BorderStyle.Fixed3D;
-        Assert.Equal(BorderStyle.Fixed3D, treeView.BorderStyle);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var treeView = new TreeView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => treeView.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckBoxes_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            CheckBoxes = value
-        };
-        Assert.Equal(value, treeView.CheckBoxes);
-
-        // Set same.
-        treeView.CheckBoxes = value;
-        Assert.Equal(value, treeView.CheckBoxes);
-
-        // Set different.
-        treeView.CheckBoxes = !value;
-        Assert.Equal(!value, treeView.CheckBoxes);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void CheckBoxes_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.CheckBoxes = value;
-        Assert.Equal(value, treeView.CheckBoxes);
-
-        // Set same.
-        treeView.CheckBoxes = value;
-        Assert.Equal(value, treeView.CheckBoxes);
-
-        // Set different.
-        treeView.CheckBoxes = !value;
-        Assert.Equal(!value, treeView.CheckBoxes);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxes_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            CheckBoxes = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.CheckBoxes = false;
-        Assert.False(treeView.CheckBoxes);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void CheckBoxes_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            CheckBoxes = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.CheckBoxes = false;
-        Assert.False(treeView.CheckBoxes);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.CheckBoxes = true;
-        Assert.True(treeView.CheckBoxes);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new SubTreeView
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, treeView.DoubleBuffered);
-
-        // Set same.
-        treeView.DoubleBuffered = value;
-        Assert.Equal(value, treeView.DoubleBuffered);
-
-        // Set different.
-        treeView.DoubleBuffered = !value;
-        Assert.Equal(!value, treeView.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new SubTreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.DoubleBuffered = value;
-        Assert.Equal(value, treeView.DoubleBuffered);
-
-        // Set same.
-        treeView.DoubleBuffered = value;
-        Assert.Equal(value, treeView.DoubleBuffered);
-
-        // Set different.
-        treeView.DoubleBuffered = !value;
-        Assert.Equal(!value, treeView.DoubleBuffered);
-    }
-
-    [WinFormsFact]
-    public void DoubleBuffered_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new SubTreeView
-        {
-            DoubleBuffered = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.DoubleBuffered = false;
-        Assert.False(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DoubleBuffered_SetWithUpdateStylesHandlerWithHandle_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new SubTreeView
-        {
-            DoubleBuffered = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.DoubleBuffered = false;
-        Assert.False(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.DoubleBuffered = true;
-        Assert.True(treeView.DoubleBuffered);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TreeViewDrawMode>]
-    public void DrawMode_Set_GetReturnsExpected(TreeViewDrawMode value)
-    {
-        using var control = new TreeView
-        {
-            DrawMode = value
-        };
-        Assert.Equal(value, control.DrawMode);
-
-        // Set same.
-        control.DrawMode = value;
-        Assert.Equal(value, control.DrawMode);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TreeViewDrawMode>]
-    public void DrawMode_SetWithHandle_GetReturnsExpected(TreeViewDrawMode value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.DrawMode = value;
-        Assert.Equal(value, treeView.DrawMode);
-
-        // Set same.
-        treeView.DrawMode = value;
-        Assert.Equal(value, treeView.DrawMode);
-    }
-
-    [WinFormsFact]
-    public void DrawMode_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new SubTreeView
-        {
-            DrawMode = TreeViewDrawMode.Normal
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawText, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawText, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawAll;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawAll, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.DrawMode = TreeViewDrawMode.Normal;
-        Assert.Equal(TreeViewDrawMode.Normal, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void DrawMode_SetWithUpdateStylesHandlerWithHandle_DoesNotCallStyleChangedCallsInvalidated()
-    {
-        using var treeView = new SubTreeView
-        {
-            DrawMode = TreeViewDrawMode.Normal
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawText, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawText;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawText, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.DrawMode = TreeViewDrawMode.OwnerDrawAll;
-        Assert.Equal(TreeViewDrawMode.OwnerDrawAll, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.DrawMode = TreeViewDrawMode.Normal;
-        Assert.Equal(TreeViewDrawMode.Normal, treeView.DrawMode);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TreeViewDrawMode>]
-    public void DrawMode_SetInvalid_ThrowsInvalidEnumArgumentException(TreeViewDrawMode value)
-    {
-        using var treeView = new TreeView();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => treeView.DrawMode = value);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TreeView
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-    }
-
-    [WinFormsFact]
-    public void ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FullRowSelect_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            FullRowSelect = value
-        };
-        Assert.Equal(value, treeView.FullRowSelect);
-
-        // Set same.
-        treeView.FullRowSelect = value;
-        Assert.Equal(value, treeView.FullRowSelect);
-
-        // Set different.
-        treeView.FullRowSelect = !value;
-        Assert.Equal(!value, treeView.FullRowSelect);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void FullRowSelect_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.FullRowSelect = value;
-        Assert.Equal(value, treeView.FullRowSelect);
-
-        // Set same.
-        treeView.FullRowSelect = value;
-        Assert.Equal(value, treeView.FullRowSelect);
-
-        // Set different.
-        treeView.FullRowSelect = !value;
-        Assert.Equal(!value, treeView.FullRowSelect);
-    }
-
-    [WinFormsFact]
-    public void FullRowSelect_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            FullRowSelect = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.FullRowSelect = false;
-        Assert.False(treeView.FullRowSelect);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void FullRowSelect_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            FullRowSelect = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.FullRowSelect = false;
-        Assert.False(treeView.FullRowSelect);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.FullRowSelect = true;
-        Assert.True(treeView.FullRowSelect);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Handle_GetVersion_ReturnsExpected()
-    {
-        using var control = new TreeView();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int version = Application.UseVisualStyles ? 6 : 5;
-        Assert.Equal(version, (int)PInvoke.SendMessage(control, PInvoke.CCM_GETVERSION));
-    }
-
-    public static IEnumerable<object[]> Handle_CustomGetVersion_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, 1 };
-        yield return new object[] { (IntPtr)4, 1 };
-        yield return new object[] { (IntPtr)5, 0 };
-        yield return new object[] { (IntPtr)6, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Handle_CustomGetVersion_TestData))]
-    public void TreeView_Handle_CustomGetVersion_Success(IntPtr getVersionResult, int expectedSetVersionCallCount)
-    {
-        using var control = new CustomGetVersionTreeView
-        {
-            GetVersionResult = getVersionResult
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expectedSetVersionCallCount, control.SetVersionCallCount);
-    }
-
-    private class CustomGetVersionTreeView : TreeView
-    {
-        public IntPtr GetVersionResult { get; set; }
-        public int SetVersionCallCount { get; set; }
-
-        protected override void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.CCM_GETVERSION)
-            {
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = GetVersionResult;
-                return;
-            }
-            else if (m.Msg == (int)PInvoke.CCM_SETVERSION)
-            {
-                Assert.Equal((IntPtr)5, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                SetVersionCallCount++;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HideSelection_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            HideSelection = value
-        };
-        Assert.Equal(value, treeView.HideSelection);
-
-        // Set same.
-        treeView.HideSelection = value;
-        Assert.Equal(value, treeView.HideSelection);
-
-        // Set different.
-        treeView.HideSelection = !value;
-        Assert.Equal(!value, treeView.HideSelection);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HideSelection_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.HideSelection = value;
-        Assert.Equal(value, treeView.HideSelection);
-
-        // Set same.
-        treeView.HideSelection = value;
-        Assert.Equal(value, treeView.HideSelection);
-
-        // Set different.
-        treeView.HideSelection = !value;
-        Assert.Equal(!value, treeView.HideSelection);
-    }
-
-    [WinFormsFact]
-    public void HideSelection_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            HideSelection = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.HideSelection = true;
-        Assert.True(treeView.HideSelection);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void HideSelection_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            HideSelection = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.HideSelection = true;
-        Assert.True(treeView.HideSelection);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.HideSelection = false;
-        Assert.False(treeView.HideSelection);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HotTracking_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            HotTracking = value
-        };
-        Assert.Equal(value, treeView.HotTracking);
-
-        // Set same.
-        treeView.HotTracking = value;
-        Assert.Equal(value, treeView.HotTracking);
-
-        // Set different.
-        treeView.HotTracking = !value;
-        Assert.Equal(!value, treeView.HotTracking);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void HotTracking_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.HotTracking = value;
-        Assert.Equal(value, treeView.HotTracking);
-
-        // Set same.
-        treeView.HotTracking = value;
-        Assert.Equal(value, treeView.HotTracking);
-
-        // Set different.
-        treeView.HotTracking = !value;
-        Assert.Equal(!value, treeView.HotTracking);
-    }
-
-    [WinFormsFact]
-    public void HotTracking_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            HotTracking = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.HotTracking = false;
-        Assert.False(treeView.HotTracking);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void HotTracking_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            HotTracking = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.HotTracking = false;
-        Assert.False(treeView.HotTracking);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.HotTracking = true;
-        Assert.True(treeView.HotTracking);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageIndex_SetWithoutImageList_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView
-        {
-            ImageIndex = value
-        };
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageIndex_SetWithoutImageListWithImageKey_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            ImageIndex = value
-        };
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ImageIndex_SetWithEmptyImageList_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            ImageIndex = value
-        };
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ImageIndex_SetWithEmptyImageListWithImageKey_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            ImageList = imageList,
-            ImageIndex = value
-        };
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void ImageIndex_SetWithImageList_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add(new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            ImageIndex = value
-        };
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void ImageIndex_SetWithImageListWithImageKey_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            ImageList = imageList,
-            ImageIndex = value
-        };
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void ImageIndex_SetWithoutImageListWithHandle_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageIndex = value;
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(-1, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void ImageIndex_SetWithEmptyImageListWithHandle_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageIndex = value;
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(0, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void ImageIndex_SetWithImageListWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add(new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        treeView.ImageIndex = value;
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-
-        // Set same.
-        treeView.ImageIndex = value;
-        Assert.Equal(expected, treeView.ImageIndex);
-        Assert.Empty(treeView.ImageKey);
-    }
-
-    [WinFormsFact]
-    public void ImageIndex_SetInvalid_Throws()
-    {
-        using var treeView = new TreeView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => treeView.ImageIndex = -2);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void ImageKey_SetWithoutImageList_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView
-        {
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void ImageKey_SetWithoutImageListWithImageIndex_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView
-        {
-            ImageIndex = 1,
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-    }
-
-    public static IEnumerable<object[]> ImageKey_Set_TestData()
-    {
-        yield return new object[] { null, "", 0 };
-        yield return new object[] { "", "", 0 };
-        yield return new object[] { "reasonable", "reasonable", -1 };
-        yield return new object[] { "(none)", "", 0 };
-        yield return new object[] { "imageKey", "imageKey", -1 };
-        yield return new object[] { "ImageKey", "ImageKey", -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void ImageKey_SetWithEmptyImageList_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void ImageKey_SetWithEmptyImageListWithImageIndex_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageIndex = 1,
-            ImageList = imageList,
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void ImageKey_SetWithNonEmptyImageList_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 0)]
-    [InlineData("", "", 1)]
-    [InlineData("reasonable", "reasonable", -1)]
-    [InlineData("(none)", "", 0)]
-    [InlineData("imageKey", "imageKey", -1)]
-    [InlineData("ImageKey", "ImageKey", -1)]
-    public void ImageKey_SetWithNonEmptyImageListWithImageIndex_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageIndex = 1,
-            ImageList = imageList,
-            ImageKey = value
-        };
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void ImageKey_SetWithoutImageListWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(-1, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void ImageKey_SetWithEmptyImageListWithHandle_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void ImageKey_SetWithNonEmptyImageListWithHandle_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-
-        // Set same.
-        treeView.ImageKey = value;
-        Assert.Equal(expected, treeView.ImageKey);
-        Assert.Equal(expectedImageIndex, treeView.ImageIndex);
-    }
-
-    public static IEnumerable<object[]> ImageList_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ImageList() };
-
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        yield return new object[] { imageList };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_Set_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            ImageList = value
-        };
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithCheckboxes_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            CheckBoxes = true,
-            ImageList = value
-        };
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithNonNullOldValue_GetReturnsExpected(ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithStateImageList_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            StateImageList = value,
-            ImageList = value
-        };
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithHandleWithCheckBoxes_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            CheckBoxes = true
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithNonNullOldValueWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void ImageList_SetWithStateImageListWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            StateImageList = value
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-
-        // Set same.
-        treeView.ImageList = value;
-        Assert.Same(value, treeView.ImageList);
-    }
-
-    [WinFormsFact]
-    public void ImageList_Dispose_DetachesFromTreeView()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList1
-        };
-        Assert.Same(imageList1, treeView.ImageList);
-
-        imageList1.Dispose();
-        Assert.Null(treeView.ImageList);
-
-        // Make sure we detached the setter.
-        treeView.ImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, treeView.ImageList);
-    }
-
-    [WinFormsFact]
-    public void ImageList_CreateHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.Same(imageList, treeView.ImageList);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void ImageList_CreateHandleWithHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.Same(imageList, treeView.ImageList);
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void ImageList_RecreateHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.Same(imageList, treeView.ImageList);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        imageList.ImageSize = new Size(10, 10);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void ImageList_RecreateHandleWithHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.Same(imageList, treeView.ImageList);
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        imageList.ImageSize = new Size(10, 10);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 19)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 2)]
-    [InlineData(5, 5)]
-    [InlineData(6, 6)]
-    [InlineData(32000, 32000)]
-    public void Indent_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var treeView = new TreeView
-        {
-            Indent = value
-        };
-        Assert.Equal(expected, treeView.Indent);
-
-        // Set same.
-        treeView.Indent = value;
-        Assert.Equal(expected, treeView.Indent);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(5)]
-    [InlineData(6)]
-    [InlineData(32000)]
-    public void Indent_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.Indent = value;
-        Assert.True(treeView.Indent > 0);
-
-        // Set same.
-        treeView.Indent = value;
-        Assert.True(treeView.Indent > 0);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(32001)]
-    public void Indent_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var treeView = new TreeView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => treeView.Indent = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(-1)]
-    [InlineData(32001)]
-    public void Indent_SetInvalidWithCustomValue_ThrowsArgumentOutOfRangeException(int indent)
-    {
-        using var treeView = new TreeView
-        {
-            Indent = 1
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => treeView.Indent = indent);
-    }
-
-    public static IEnumerable<object[]> ItemHeight_Get_TestData()
-    {
-        var font = new Font(FontFamily.GenericSansSerif, 100);
-        yield return new object[] { font, true, TreeViewDrawMode.Normal, font.Height + 3 };
-        yield return new object[] { font, true, TreeViewDrawMode.OwnerDrawText, font.Height + 3 };
-        yield return new object[] { font, true, TreeViewDrawMode.OwnerDrawAll, font.Height + 3 };
-        yield return new object[] { font, false, TreeViewDrawMode.Normal, font.Height + 3 };
-        yield return new object[] { font, false, TreeViewDrawMode.OwnerDrawText, font.Height + 3 };
-        yield return new object[] { font, false, TreeViewDrawMode.OwnerDrawAll, font.Height + 3 };
-
-        Font smallFont = new Font(FontFamily.GenericSansSerif, 2);
-        yield return new object[] { smallFont, true, TreeViewDrawMode.Normal, smallFont.Height + 3 };
-        yield return new object[] { smallFont, true, TreeViewDrawMode.OwnerDrawText, smallFont.Height + 3 };
-        yield return new object[] { smallFont, true, TreeViewDrawMode.OwnerDrawAll, 16 };
-        yield return new object[] { smallFont, false, TreeViewDrawMode.Normal, smallFont.Height + 3 };
-        yield return new object[] { smallFont, false, TreeViewDrawMode.OwnerDrawText, smallFont.Height + 3 };
-        yield return new object[] { smallFont, false, TreeViewDrawMode.OwnerDrawAll, smallFont.Height + 3 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemHeight_Get_TestData))]
-    public void ItemHeight_Get_ReturnsExpected(Font font, bool checkBoxes, TreeViewDrawMode drawMode, int expectedHeight)
-    {
-        using var treeView = new TreeView
-        {
-            Font = font,
-            CheckBoxes = checkBoxes,
-            DrawMode = drawMode
-        };
-        Assert.Equal(expectedHeight, treeView.ItemHeight);
-    }
-
-    public static IEnumerable<object[]> ItemHeight_Set_TestData()
-    {
-        yield return new object[] { -1, Control.DefaultFont.Height + 3 };
-        yield return new object[] { 1, 1 };
-        yield return new object[] { 2, 2 };
-        yield return new object[] { 32766, 32766 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ItemHeight_Set_TestData))]
-    public void TreeView_ItemHeight_Set_GetReturnsExpected(int value, int expected)
-    {
-        using var control = new TreeView
-        {
-            ItemHeight = value
-        };
-        Assert.Equal(expected, control.ItemHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ItemHeight = value;
-        Assert.Equal(expected, control.ItemHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 0)]
-    [InlineData(32766, 0)]
-    public void TreeView_ItemHeight_SetWithHandle_GetReturnsExpected(int value, int expectedCreatedCallCount)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ItemHeight = value;
-        Assert.True(control.ItemHeight > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.ItemHeight = value;
-        Assert.True(control.ItemHeight > 0);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(32767)]
-    public void TreeView_ItemHeight_SetInvalid_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TreeView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ItemHeight = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-2)]
-    [InlineData(0)]
-    [InlineData(-1)]
-    [InlineData(32767)]
-    public void TreeView_ItemHeight_SetInvalidWithCustomValue_ThrowsArgumentOutOfRangeException(int indent)
-    {
-        using var control = new TreeView
-        {
-            ItemHeight = 1
-        };
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.ItemHeight = indent);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void LabelEdit_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            LabelEdit = value
-        };
-        Assert.Equal(value, treeView.LabelEdit);
-
-        // Set same.
-        treeView.LabelEdit = value;
-        Assert.Equal(value, treeView.LabelEdit);
-
-        // Set different.
-        treeView.LabelEdit = !value;
-        Assert.Equal(!value, treeView.LabelEdit);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void LabelEdit_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.LabelEdit = value;
-        Assert.Equal(value, treeView.LabelEdit);
-
-        // Set same.
-        treeView.LabelEdit = value;
-        Assert.Equal(value, treeView.LabelEdit);
-
-        // Set different.
-        treeView.LabelEdit = !value;
-        Assert.Equal(!value, treeView.LabelEdit);
-    }
-
-    [WinFormsFact]
-    public void LabelEdit_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            LabelEdit = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.LabelEdit = false;
-        Assert.False(treeView.LabelEdit);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void LabelEdit_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            LabelEdit = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.LabelEdit = false;
-        Assert.False(treeView.LabelEdit);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.LabelEdit = true;
-        Assert.True(treeView.LabelEdit);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetColorWithEmptyTheoryData))]
-    public void LineColor_Set_GetReturnsExpected(Color value)
-    {
-        using var treeView = new TreeView
-        {
-            LineColor = value
-        };
-        Assert.Equal(value, treeView.LineColor);
-
-        // Set same.
-        treeView.LineColor = value;
-        Assert.Equal(value, treeView.LineColor);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void PathSeparator_Set_GetReturnsExpected(string value)
-    {
-        using var treeView = new TreeView
-        {
-            PathSeparator = value
-        };
-        Assert.Same(value, treeView.PathSeparator);
-
-        // Set same.
-        treeView.PathSeparator = value;
-        Assert.Same(value, treeView.PathSeparator);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TreeView_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TreeView
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TreeView_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1)]
-    [InlineData(RightToLeft.Yes, false, 0)]
-    [InlineData(RightToLeft.No, true, 1)]
-    [InlineData(RightToLeft.No, false, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1)]
-    [InlineData(RightToLeft.Inherit, false, 0)]
-    public void TrackBar_RightToLeftLayout_Set_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new TreeView
-        {
-            RightToLeft = rightToLeft
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1, 1, 2)]
-    [InlineData(RightToLeft.Yes, false, 0, 0, 1)]
-    [InlineData(RightToLeft.No, true, 1, 0, 0)]
-    [InlineData(RightToLeft.No, false, 0, 0, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1, 0, 0)]
-    [InlineData(RightToLeft.Inherit, false, 0, 0, 0)]
-    public void TrackBar_RightToLeftLayout_SetWithHandle_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new TrackBar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_RightToLeftLayout_SetWithHandler_CallsRightToLeftLayoutChanged()
-    {
-        using var control = new TrackBar
-        {
-            RightToLeftLayout = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftLayoutChanged += handler;
-
-        // Set different.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeftLayout = true;
-        Assert.True(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_RightToLeftLayout_SetWithHandlerInDisposing_DoesNotRightToLeftLayoutChanged()
-    {
-        using var control = new TrackBar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeftLayout = true;
-            Assert.True(control.RightToLeftLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Scrollable_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            Scrollable = value
-        };
-        Assert.Equal(value, treeView.Scrollable);
-
-        // Set same.
-        treeView.Scrollable = value;
-        Assert.Equal(value, treeView.Scrollable);
-
-        // Set different.
-        treeView.Scrollable = !value;
-        Assert.Equal(!value, treeView.Scrollable);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Scrollable_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.Scrollable = value;
-        Assert.Equal(value, treeView.Scrollable);
-
-        // Set same.
-        treeView.Scrollable = value;
-        Assert.Equal(value, treeView.Scrollable);
-
-        // Set different.
-        treeView.Scrollable = !value;
-        Assert.Equal(!value, treeView.Scrollable);
-    }
-
-    [WinFormsFact]
-    public void Scrollable_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            Scrollable = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.Scrollable = true;
-        Assert.True(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Scrollable_SetWithUpdateStylesHandlerWithHandle_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            Scrollable = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.Scrollable = true;
-        Assert.True(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.Scrollable = false;
-        Assert.False(treeView.Scrollable);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SelectedImageIndex_SetWithoutImageList_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView
-        {
-            SelectedImageIndex = value
-        };
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SelectedImageIndex_SetWithoutImageListWithImageKey_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            SelectedImageIndex = value
-        };
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void SelectedImageIndex_SetWithEmptyImageList_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            SelectedImageIndex = value
-        };
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void SelectedImageIndex_SetWithEmptyImageListWithImageKey_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            ImageList = imageList,
-            SelectedImageIndex = value
-        };
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void SelectedImageIndex_SetWithImageList_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add(new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            SelectedImageIndex = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void SelectedImageIndex_SetWithImageListWithImageKey_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageKey = "imageKey",
-            ImageList = imageList,
-            SelectedImageIndex = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void SelectedImageIndex_SetWithoutImageListWithHandle_GetReturnsExpected(int value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    public void SelectedImageIndex_SetWithEmptyImageListWithHandle_GetReturnsExpected(int value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(0, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(2, 1)]
-    public void SelectedImageIndex_SetWithImageListWithHandle_GetReturnsExpected(int value, int expected)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add(new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-
-        // Set same.
-        treeView.SelectedImageIndex = value;
-        Assert.Equal(expected, treeView.SelectedImageIndex);
-        Assert.Empty(treeView.SelectedImageKey);
-    }
-
-    [WinFormsFact]
-    public void SelectedImageIndex_SetInvalid_Throws()
-    {
-        using var treeView = new TreeView();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => treeView.SelectedImageIndex = -2);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void SelectedImageKey_SetWithoutImageList_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView
-        {
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void SelectedImageKey_SetWithoutImageListWithImageIndex_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView
-        {
-            SelectedImageIndex = 1,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void SelectedImageKey_SetWithEmptyImageList_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void SelectedImageKey_SetWithEmptyImageListWithImageIndex_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            SelectedImageIndex = 1,
-            ImageList = imageList,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void SelectedImageKey_SetWithNonEmptyImageList_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", 0)]
-    [InlineData("", "", 1)]
-    [InlineData("reasonable", "reasonable", -1)]
-    [InlineData("(none)", "", 0)]
-    [InlineData("imageKey", "imageKey", -1)]
-    [InlineData("ImageKey", "ImageKey", -1)]
-    public void SelectedImageKey_SetWithNonEmptyImageListWithImageIndex_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            SelectedImageIndex = 1,
-            ImageList = imageList,
-            SelectedImageKey = value
-        };
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    [InlineData("(none)", "")]
-    public void SelectedImageKey_SetWithoutImageListWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(-1, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void SelectedImageKey_SetWithEmptyImageListWithHandle_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageKey_Set_TestData))]
-    public void SelectedImageKey_SetWithNonEmptyImageListWithHandle_GetReturnsExpected(string value, string expected, int expectedImageIndex)
-    {
-        using var imageList = new ImageList();
-        imageList.Images.Add(new Bitmap(10, 10));
-        imageList.Images.Add("imageKey", new Bitmap(10, 10));
-        using var treeView = new TreeView
-        {
-            ImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-
-        // Set same.
-        treeView.SelectedImageKey = value;
-        Assert.Equal(expected, treeView.SelectedImageKey);
-        Assert.Equal(expectedImageIndex, treeView.SelectedImageIndex);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowLines_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            ShowLines = value
-        };
-        Assert.Equal(value, treeView.ShowLines);
-
-        // Set same.
-        treeView.ShowLines = value;
-        Assert.Equal(value, treeView.ShowLines);
-
-        // Set different.
-        treeView.ShowLines = !value;
-        Assert.Equal(!value, treeView.ShowLines);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowLines_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ShowLines = value;
-        Assert.Equal(value, treeView.ShowLines);
-
-        // Set same.
-        treeView.ShowLines = value;
-        Assert.Equal(value, treeView.ShowLines);
-
-        // Set different.
-        treeView.ShowLines = !value;
-        Assert.Equal(!value, treeView.ShowLines);
-    }
-
-    [WinFormsFact]
-    public void ShowLines_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowLines = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.ShowLines = true;
-        Assert.True(treeView.ShowLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowLines = true;
-        Assert.True(treeView.ShowLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowLines = false;
-        Assert.False(treeView.ShowLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowLines = true;
-        Assert.True(treeView.ShowLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ShowLines_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowLines = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.ShowLines = false;
-        Assert.False(treeView.ShowLines);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowLines = false;
-        Assert.False(treeView.ShowLines);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowLines = true;
-        Assert.True(treeView.ShowLines);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowLines = false;
-        Assert.False(treeView.ShowLines);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowNodeToolTips_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            ShowNodeToolTips = value
-        };
-        Assert.Equal(value, treeView.ShowNodeToolTips);
-
-        // Set same.
-        treeView.ShowNodeToolTips = value;
-        Assert.Equal(value, treeView.ShowNodeToolTips);
-
-        // Set different.
-        treeView.ShowNodeToolTips = !value;
-        Assert.Equal(!value, treeView.ShowNodeToolTips);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowNodeToolTips_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ShowNodeToolTips = value;
-        Assert.Equal(value, treeView.ShowNodeToolTips);
-
-        // Set same.
-        treeView.ShowNodeToolTips = value;
-        Assert.Equal(value, treeView.ShowNodeToolTips);
-
-        // Set different.
-        treeView.ShowNodeToolTips = !value;
-        Assert.Equal(!value, treeView.ShowNodeToolTips);
-    }
-
-    [WinFormsFact]
-    public void ShowNodeToolTips_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowNodeToolTips = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowNodeToolTips = false;
-        Assert.False(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ShowNodeToolTips_SetWithUpdateStylesHandlerWithHandle_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowNodeToolTips = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowNodeToolTips = false;
-        Assert.False(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowNodeToolTips = true;
-        Assert.True(treeView.ShowNodeToolTips);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowPlusMinus_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            ShowPlusMinus = value
-        };
-        Assert.Equal(value, treeView.ShowPlusMinus);
-
-        // Set same.
-        treeView.ShowPlusMinus = value;
-        Assert.Equal(value, treeView.ShowPlusMinus);
-
-        // Set different.
-        treeView.ShowPlusMinus = !value;
-        Assert.Equal(!value, treeView.ShowPlusMinus);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowPlusMinus_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ShowPlusMinus = value;
-        Assert.Equal(value, treeView.ShowPlusMinus);
-
-        // Set same.
-        treeView.ShowPlusMinus = value;
-        Assert.Equal(value, treeView.ShowPlusMinus);
-
-        // Set different.
-        treeView.ShowPlusMinus = !value;
-        Assert.Equal(!value, treeView.ShowPlusMinus);
-    }
-
-    [WinFormsFact]
-    public void ShowPlusMinus_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowPlusMinus = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowPlusMinus = true;
-        Assert.True(treeView.ShowPlusMinus);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ShowPlusMinus_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowPlusMinus = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowPlusMinus = true;
-        Assert.True(treeView.ShowPlusMinus);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowPlusMinus = false;
-        Assert.False(treeView.ShowPlusMinus);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowRootLines_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            ShowRootLines = value
-        };
-        Assert.Equal(value, treeView.ShowRootLines);
-
-        // Set same.
-        treeView.ShowRootLines = value;
-        Assert.Equal(value, treeView.ShowRootLines);
-
-        // Set different.
-        treeView.ShowRootLines = !value;
-        Assert.Equal(!value, treeView.ShowRootLines);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void ShowRootLines_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.ShowRootLines = value;
-        Assert.Equal(value, treeView.ShowRootLines);
-
-        // Set same.
-        treeView.ShowRootLines = value;
-        Assert.Equal(value, treeView.ShowRootLines);
-
-        // Set different.
-        treeView.ShowRootLines = !value;
-        Assert.Equal(!value, treeView.ShowRootLines);
-    }
-
-    [WinFormsFact]
-    public void ShowRootLines_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowRootLines = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowRootLines = true;
-        Assert.True(treeView.ShowRootLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void ShowRootLines_SetWithUpdateStylesHandlerWithHandle_CallsStyleChangedCallsInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            ShowRootLines = true
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set same.
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(1, styleChangedCallCount);
-        Assert.Equal(1, invalidatedCallCount);
-
-        // Set different.
-        treeView.ShowRootLines = true;
-        Assert.True(treeView.ShowRootLines);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.ShowRootLines = false;
-        Assert.False(treeView.ShowRootLines);
-        Assert.Equal(2, styleChangedCallCount);
-        Assert.Equal(2, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Sorted_Set_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView
-        {
-            Sorted = value
-        };
-        Assert.Equal(value, treeView.Sorted);
-
-        // Set same.
-        treeView.Sorted = value;
-        Assert.Equal(value, treeView.Sorted);
-
-        // Set different.
-        treeView.Sorted = !value;
-        Assert.Equal(!value, treeView.Sorted);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void Sorted_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.Sorted = value;
-        Assert.Equal(value, treeView.Sorted);
-
-        // Set same.
-        treeView.Sorted = value;
-        Assert.Equal(value, treeView.Sorted);
-
-        // Set different.
-        treeView.Sorted = !value;
-        Assert.Equal(!value, treeView.Sorted);
-    }
-
-    [WinFormsFact]
-    public void Sorted_SetWithUpdateStylesHandler_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            Sorted = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-
-        // Set different.
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.Sorted = false;
-        Assert.False(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsFact]
-    public void Sorted_SetWithUpdateStylesHandlerWithHandle_DoesNotCallStyleChangedDoesNotCallInvalidated()
-    {
-        using var treeView = new TreeView
-        {
-            Sorted = false
-        };
-        int styleChangedCallCount = 0;
-        int invalidatedCallCount = 0;
-        EventHandler styleChangedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.Same(EventArgs.Empty, e);
-            styleChangedCallCount++;
-        };
-        InvalidateEventHandler invalidatedHandler = (sender, e) =>
-        {
-            Assert.Same(treeView, sender);
-            Assert.NotNull(e);
-            invalidatedCallCount++;
-        };
-        treeView.StyleChanged += styleChangedHandler;
-        treeView.Invalidated += invalidatedHandler;
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        // Set different.
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set same.
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Set different.
-        treeView.Sorted = false;
-        Assert.False(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-
-        // Remove handler.
-        treeView.StyleChanged -= styleChangedHandler;
-        treeView.Invalidated -= invalidatedHandler;
-        treeView.Sorted = true;
-        Assert.True(treeView.Sorted);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, invalidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void StateImageList_Set_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView
-        {
-            StateImageList = value
-        };
-        Assert.Same(value, treeView.StateImageList);
-
-        // Set same.
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void StateImageList_SetWithNonNullOldValue_GetReturnsExpected(ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-
-        // Set same.
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void StateImageList_SetWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var treeView = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-
-        // Set same.
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImageList_TestData))]
-    public void StateImageList_SetWithNonNullOldValueWithHandle_GetReturnsExpected(ImageList value)
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-
-        // Set same.
-        treeView.StateImageList = value;
-        Assert.Same(value, treeView.StateImageList);
-    }
-
-    [WinFormsFact]
-    public void StateImageList_Dispose_DetachesFromTreeView()
-    {
-        using var imageList1 = new ImageList();
-        using var imageList2 = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList1
-        };
-        Assert.Same(imageList1, treeView.StateImageList);
-
-        imageList1.Dispose();
-        Assert.Null(treeView.StateImageList);
-
-        // Make sure we detached the setter.
-        treeView.StateImageList = imageList2;
-        imageList1.Dispose();
-        Assert.Same(imageList2, treeView.StateImageList);
-    }
-
-    [WinFormsFact]
-    public void StateImageList_CreateHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.Same(imageList, treeView.StateImageList);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void StateImageList_CreateHandleWithHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.Same(imageList, treeView.StateImageList);
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void StateImageList_RecreateHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.Same(imageList, treeView.StateImageList);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        imageList.ImageSize = new Size(10, 10);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsFact]
-    public void StateImageList_RecreateHandleWithHandle_DetachesFromTreeView()
-    {
-        using var imageList = new ImageList();
-        using var treeView = new TreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.Same(imageList, treeView.StateImageList);
-        Assert.NotEqual(IntPtr.Zero, treeView.Handle);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        imageList.ImageSize = new Size(10, 10);
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TreeView_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new TreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = "otherText";
-        Assert.Equal("otherText", control.Text);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(3, callCount);
-
-        // Set empty.
-        control.Text = string.Empty;
-        Assert.Empty(control.Text);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> TreeViewNodeSorter_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { StringComparer.CurrentCulture };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewNodeSorter_TestData))]
-    public void TreeViewNodeSorter_Set_GetReturnsExpected(IComparer value)
-    {
-        using var treeView = new TreeView
-        {
-            TreeViewNodeSorter = value
-        };
-        Assert.Same(value, treeView.TreeViewNodeSorter);
-
-        // Set same.
-        treeView.TreeViewNodeSorter = value;
-        Assert.Same(value, treeView.TreeViewNodeSorter);
-    }
-
-    [WinFormsFact]
-    public void AddExistingNodeAsChild_ThrowsArgumentException()
-    {
-        using var treeView = new TreeView();
-        var node = new TreeNode();
-        treeView.Nodes.Add(node);
-
-        Assert.Throws<ArgumentException>(() => node.Nodes.Add(node));
-    }
-
-    [WinFormsFact]
-    public void TreeView_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTreeView();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetNodeAt_Empty_TestData()
-    {
-        yield return new object[] { new Point(int.MinValue, int.MinValue) };
-        yield return new object[] { new Point(-1, -2) };
-        yield return new object[] { new Point(-1, 0) };
-        yield return new object[] { new Point(-1, 2) };
-        yield return new object[] { new Point(0, -2) };
-        yield return new object[] { new Point(0, 0) };
-        yield return new object[] { new Point(0, 2) };
-        yield return new object[] { new Point(1, -2) };
-        yield return new object[] { new Point(1, 0) };
-        yield return new object[] { new Point(1, 2) };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_Empty_TestData))]
-    public void TreeView_GetNodeAt_InvokePointEmpty_ReturnsNull(Point pt)
-    {
-        using var control = new TreeView();
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetNodeAt_NotEmptyValid_TestData()
-    {
-        yield return new object[] { new Point(0, 0) };
-        yield return new object[] { new Point(20, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyValid_TestData))]
-    public void TreeView_GetNodeAt_InvokePointNotEmptyValid_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.Same(node1, control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Same(node1, control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetNodeAt_NotEmptyInvalid_TestData()
-    {
-        yield return new object[] { new Point(int.MinValue, int.MinValue) };
-        yield return new object[] { new Point(-1, -2) };
-        yield return new object[] { new Point(-1, 0) };
-        yield return new object[] { new Point(-1, 2) };
-        yield return new object[] { new Point(0, -2) };
-        yield return new object[] { new Point(1, -2) };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyInvalid_TestData))]
-    public void TreeView_GetNodeAt_InvokePointNotEmptyInvalid_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_Empty_TestData))]
-    public void TreeView_GetNodeAt_InvokePointEmptyWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyValid_TestData))]
-    public void TreeView_GetNodeAt_InvokePointNotEmptyValidWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Same(node1, control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Same(node1, control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyInvalid_TestData))]
-    public void TreeView_GetNodeAt_InvokePointNotEmptyInvalidWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_Empty_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntEmpty_ReturnsNull(Point pt)
-    {
-        using var control = new TreeView();
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyValid_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntNotEmptyValid_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.Same(node1, control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Same(node1, control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyInvalid_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntNotEmptyInvalid_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_Empty_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntEmptyWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyValid_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntNotEmptyValidWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Same(node1, control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Same(node1, control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetNodeAt_NotEmptyInvalid_TestData))]
-    public void TreeView_GetNodeAt_InvokeIntIntNotEmptyInvalidWithHandle_Success(Point pt)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Null(control.GetNodeAt(pt.X, pt.Y));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TreeView_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTreeView();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TreeView_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTreeView();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> HitTest_Empty_TestData()
-    {
-        yield return new object[] { new Point(int.MinValue, int.MinValue), TreeViewHitTestLocations.AboveClientArea | TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, -2), TreeViewHitTestLocations.AboveClientArea | TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, 0), TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, 2), TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(0, -2), TreeViewHitTestLocations.AboveClientArea };
-        yield return new object[] { new Point(0, 0), TreeViewHitTestLocations.None };
-        yield return new object[] { new Point(0, 2), TreeViewHitTestLocations.None };
-        yield return new object[] { new Point(1, -2), TreeViewHitTestLocations.AboveClientArea };
-        yield return new object[] { new Point(1, 0), TreeViewHitTestLocations.None };
-        yield return new object[] { new Point(1, 2), TreeViewHitTestLocations.None };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue), TreeViewHitTestLocations.BelowClientArea | TreeViewHitTestLocations.RightOfClientArea };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_Empty_TestData))]
-    public void TreeView_HitTest_InvokePointEmpty_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HitTest_NotEmptyValid_TestData()
-    {
-        yield return new object[] { new Point(0, 0), TreeViewHitTestLocations.Indent };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyValid_TestData))]
-    public void TreeView_HitTest_InvokePointNotEmptyValid_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> HitTest_NotEmptyInvalid_TestData()
-    {
-        yield return new object[] { new Point(int.MinValue, int.MinValue), TreeViewHitTestLocations.AboveClientArea | TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, -2), TreeViewHitTestLocations.AboveClientArea | TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, 0), TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(-1, 2), TreeViewHitTestLocations.LeftOfClientArea };
-        yield return new object[] { new Point(0, -2), TreeViewHitTestLocations.AboveClientArea };
-        yield return new object[] { new Point(1, -2), TreeViewHitTestLocations.AboveClientArea };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue), TreeViewHitTestLocations.BelowClientArea | TreeViewHitTestLocations.RightOfClientArea };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyInvalid_TestData))]
-    public void TreeView_HitTest_InvokePointNotEmptyInvalid_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_Empty_TestData))]
-    public void TreeView_HitTest_InvokePointEmptyWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyValid_TestData))]
-    public void TreeView_HitTest_InvokePointNotEmptyValidWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyInvalid_TestData))]
-    public void TreeView_HitTest_InvokePointNotEmptyInvalidWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_Empty_TestData))]
-    public void TreeView_HitTest_InvokeIntIntEmpty_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyValid_TestData))]
-    public void TreeView_HitTest_InvokeIntIntNotEmptyValid_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyInvalid_TestData))]
-    public void TreeView_HitTest_InvokeIntIntNotEmptyInvalid_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_Empty_TestData))]
-    public void TreeView_HitTest_InvokeIntIntEmptyWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyValid_TestData))]
-    public void TreeView_HitTest_InvokeIntIntNotEmptyValidWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Same(node1, result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(HitTest_NotEmptyInvalid_TestData))]
-    public void TreeView_HitTest_InvokeIntIntNotEmptyInvalidWithHandle_Success(Point pt, TreeViewHitTestLocations expectedLocations)
-    {
-        using var control = new TreeView();
-        var node1 = new TreeNode("Some Long Text");
-        control.Nodes.Add(node1);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        TreeViewHitTestInfo result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        result = control.HitTest(pt.X, pt.Y);
-        Assert.Equal(expectedLocations, result.Location);
-        Assert.Null(result.Node);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> TreeViewEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeViewEventArgs(null) };
-        yield return new object[] { new TreeViewEventArgs(new TreeNode()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewEventArgs_TestData))]
-    public void TreeView_OnAfterCheck_Invoke_CallsAfterCheck(TreeViewEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AfterCheck += handler;
-        control.OnAfterCheck(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AfterCheck -= handler;
-        control.OnAfterCheck(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewEventArgs_TestData))]
-    public void TreeView_OnAfterCollapse_Invoke_CallsAfterCollapse(TreeViewEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AfterCollapse += handler;
-        control.OnAfterCollapse(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AfterCollapse -= handler;
-        control.OnAfterCollapse(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewEventArgs_TestData))]
-    public void TreeView_OnAfterExpand_Invoke_CallsAfterExpand(TreeViewEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AfterExpand += handler;
-        control.OnAfterExpand(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AfterExpand -= handler;
-        control.OnAfterExpand(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> NodeLabelEditEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new NodeLabelEditEventArgs(null) };
-        yield return new object[] { new NodeLabelEditEventArgs(new TreeNode()) };
-        yield return new object[] { new NodeLabelEditEventArgs(new TreeNode(), "label") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NodeLabelEditEventArgs_TestData))]
-    public void TreeView_OnAfterLabelEdit_Invoke_CallsAfterLabelEdit(NodeLabelEditEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        NodeLabelEditEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AfterLabelEdit += handler;
-        control.OnAfterLabelEdit(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AfterLabelEdit -= handler;
-        control.OnAfterLabelEdit(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewEventArgs_TestData))]
-    public void TreeView_OnAfterSelect_Invoke_CallsOnAfterSelect(TreeViewEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AfterSelect += handler;
-        control.OnAfterSelect(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AfterSelect -= handler;
-        control.OnAfterSelect(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> TreeViewCancelEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeViewCancelEventArgs(null, false, TreeViewAction.ByKeyboard) };
-        yield return new object[] { new TreeViewCancelEventArgs(new TreeNode(), true, TreeViewAction.ByKeyboard) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewCancelEventArgs_TestData))]
-    public void TreeView_OnBeforeExpand_Invoke_CallsBeforeExpand(TreeViewCancelEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewCancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeforeExpand += handler;
-        control.OnBeforeExpand(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BeforeExpand -= handler;
-        control.OnBeforeExpand(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(NodeLabelEditEventArgs_TestData))]
-    public void TreeView_OnBeforeLabelEdit_Invoke_CallsBeforeLabelEdit(NodeLabelEditEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        NodeLabelEditEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeforeLabelEdit += handler;
-        control.OnBeforeLabelEdit(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BeforeLabelEdit -= handler;
-        control.OnBeforeLabelEdit(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewCancelEventArgs_TestData))]
-    public void TreeView_OnBeforeCollapse_Invoke_CallsBeforeCollapse(TreeViewCancelEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewCancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeforeCollapse += handler;
-        control.OnBeforeCollapse(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BeforeCollapse -= handler;
-        control.OnBeforeCollapse(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeViewCancelEventArgs_TestData))]
-    public void TreeView_OnBeforeSelect_Invoke_CallsBeforeSelect(TreeViewCancelEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeViewCancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BeforeSelect += handler;
-        control.OnBeforeSelect(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BeforeSelect -= handler;
-        control.OnBeforeSelect(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnDrawNode_TestData()
-    {
-        yield return new object[] { null };
-
-        var image = new Bitmap(10, 10);
-        Graphics graphics = Graphics.FromImage(image);
-        yield return new object[] { new DrawTreeNodeEventArgs(graphics, null, Rectangle.Empty, TreeNodeStates.Checked) };
-
-        yield return new object[] { new DrawTreeNodeEventArgs(graphics, new TreeNode(), new Rectangle(1, 2, 3, 4), TreeNodeStates.Checked) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDrawNode_TestData))]
-    public void TreeView_OnDrawNode_Invoke_CallsDrawNode(DrawTreeNodeEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        DrawTreeNodeEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DrawNode += handler;
-        control.OnDrawNode(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DrawNode -= handler;
-        control.OnDrawNode(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnItemDrag_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ItemDragEventArgs(MouseButtons.None) };
-        yield return new object[] { new ItemDragEventArgs(MouseButtons.Right, new object()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnItemDrag_TestData))]
-    public void TreeView_OnItemDrag_Invoke_CallsItemDrag(ItemDragEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        ItemDragEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ItemDrag += handler;
-        control.OnItemDrag(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ItemDrag -= handler;
-        control.OnItemDrag(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_TestData()
-    {
-        yield return new object[] { new KeyEventArgs(Keys.None) };
-        yield return new object[] { new KeyEventArgs(Keys.A) };
-        yield return new object[] { new KeyEventArgs(Keys.Space) };
-        yield return new object[] { new KeyEventArgs(Keys.Control | Keys.Space) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_TestData))]
-    public void TreeView_OnKeyDown_Invoke_CallsKeyDown(KeyEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnKeyDown_WithSelectedNode_TestData()
-    {
-        yield return new object[] { false, true, false, new KeyEventArgs(Keys.None), 0, 0, false };
-        yield return new object[] { false, true, false, new KeyEventArgs(Keys.A), 0, 0, false };
-        yield return new object[] { false, true, false, new KeyEventArgs(Keys.Space), 1, 1, true };
-        yield return new object[] { false, true, true, new KeyEventArgs(Keys.Space), 1, 0, true };
-        yield return new object[] { false, true, false, new KeyEventArgs(Keys.Control | Keys.Space), 1, 1, true };
-        yield return new object[] { false, true, true, new KeyEventArgs(Keys.Control | Keys.Space), 1, 0, true };
-
-        yield return new object[] { true, true, false, new KeyEventArgs(Keys.Space), 0, 0, true };
-        yield return new object[] { true, false, false, new KeyEventArgs(Keys.Space), 0, 0, true };
-        yield return new object[] { false, false, false, new KeyEventArgs(Keys.Space), 0, 0, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyDown_WithSelectedNode_TestData))]
-    public void TreeView_OnKeyDown_InvokeWithSelectedNode_CallsKeyDown(bool handled, bool checkBoxes, bool cancel, KeyEventArgs eventArgs, int expectedBeforeCheckCallCount, int expectedAfterCheckCallCount, bool expectedHandled)
-    {
-        using var control = new SubTreeView
-        {
-            CheckBoxes = checkBoxes
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        control.SelectedNode = node;
-
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-            e.Handled = handled;
-        };
-        int beforeCheckCallCount = 0;
-        TreeViewCancelEventHandler beforeCheckHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TreeViewAction.ByKeyboard, e.Action);
-            Assert.False(e.Cancel);
-            beforeCheckCallCount++;
-            e.Cancel = cancel;
-        };
-        int afterCheckCallCount = 0;
-        TreeViewEventHandler afterCheckHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(TreeViewAction.ByKeyboard, e.Action);
-            afterCheckCallCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.BeforeCheck += beforeCheckHandler;
-        control.AfterCheck += afterCheckHandler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedAfterCheckCallCount == 1, node.Checked);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(expectedBeforeCheckCallCount, beforeCheckCallCount);
-        Assert.Equal(expectedAfterCheckCallCount, afterCheckCallCount);
-
-        // Call again.
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.False(node.Checked);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(expectedBeforeCheckCallCount * 2, beforeCheckCallCount);
-        Assert.Equal(expectedAfterCheckCallCount * 2, afterCheckCallCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.BeforeCheck -= beforeCheckHandler;
-        control.AfterCheck -= afterCheckHandler;
-        control.OnKeyDown(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(expectedBeforeCheckCallCount * 2, beforeCheckCallCount);
-        Assert.Equal(expectedAfterCheckCallCount * 2, afterCheckCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_OnKeyDown_NullEventArgs_ThrowsNullReferenceException()
-    {
-        using var control = new SubTreeView();
-        Assert.Throws<NullReferenceException>(() => control.OnKeyDown(null));
-    }
-
-    public static IEnumerable<object[]> OnKeyPress_TestData()
-    {
-        yield return new object[] { true, new KeyPressEventArgs('\0'), true };
-        yield return new object[] { true, new KeyPressEventArgs('a'), true };
-        yield return new object[] { true, new KeyPressEventArgs(' '), true };
-
-        yield return new object[] { false, new KeyPressEventArgs('\0'), false };
-        yield return new object[] { false, new KeyPressEventArgs('a'), false };
-        yield return new object[] { false, new KeyPressEventArgs(' '), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyPress_TestData))]
-    public void TreeView_OnKeyPress_Invoke_CallsKeyPress(bool handled, KeyPressEventArgs eventArgs, bool expectedHandled)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            e.Handled = handled;
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnKeyPress(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void TreeView_OnKeyPress_NullEventArgs_ThrowsNullReferenceException()
-    {
-        using var control = new SubTreeView();
-        Assert.Throws<NullReferenceException>(() => control.OnKeyPress(null));
-    }
-
-    public static IEnumerable<object[]> OnKeyUp_TestData()
-    {
-        yield return new object[] { true, new KeyEventArgs(Keys.None), true };
-        yield return new object[] { true, new KeyEventArgs(Keys.A), true };
-        yield return new object[] { true, new KeyEventArgs(Keys.Space), true };
-        yield return new object[] { true, new KeyEventArgs(Keys.Control | Keys.Space), true };
-
-        yield return new object[] { false, new KeyEventArgs(Keys.None), false };
-        yield return new object[] { false, new KeyEventArgs(Keys.A), false };
-        yield return new object[] { false, new KeyEventArgs(Keys.Space), true };
-        yield return new object[] { false, new KeyEventArgs(Keys.Control | Keys.Space), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnKeyUp_TestData))]
-    public void TreeView_OnKeyUp_Invoke_CallsKeyUp(bool handled, KeyEventArgs eventArgs, bool expectedHandled)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            e.Handled = handled;
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyUp += handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-
-        // Remove handler.
-        control.KeyUp -= handler;
-        control.OnKeyUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void TreeView_OnKeyUp_NullEventArgs_ThrowsNullReferenceException()
-    {
-        using var control = new SubTreeView();
-        Assert.Throws<NullReferenceException>(() => control.OnKeyUp(null));
-    }
-
-    /*
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            //Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-    */
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_WithHandleWithProperties_TestData()
-    {
-        yield return new object[] { Array.Empty<Image>(), null, false };
-        yield return new object[] { new Image[] { new Bitmap(10, 10) }, null, true };
-        yield return new object[] { Array.Empty<Image>(), new EventArgs(), false };
-        yield return new object[] { new Image[] { new Bitmap(10, 10) }, new EventArgs(), true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_WithHandleWithProperties_TestData))]
-    public void TreeView_OnHandleCreated_InvokeWithHandleWithProperties_CallsHandleCreated(Image[] images, EventArgs eventArgs, bool expectedStateImageListHandleCreated)
-    {
-        using var imageList = new ImageList();
-        using var stateImageList = new ImageList();
-        stateImageList.Images.AddRange(images);
-        using var control = new SubTreeView
-        {
-            CheckBoxes = true,
-            ShowNodeToolTips = true,
-            BackColor = Color.Red,
-            ForeColor = Color.Blue,
-            LineColor = Color.Yellow,
-            ImageList = imageList,
-            StateImageList = stateImageList,
-            Indent = 10,
-            ItemHeight = 11
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        control.SelectedNode = node;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.CheckBoxes);
-        Assert.True(control.ShowNodeToolTips);
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Blue, control.ForeColor);
-        Assert.Equal(Color.Yellow, control.LineColor);
-        Assert.Same(imageList, control.ImageList);
-        Assert.True(control.ImageList.HandleCreated);
-        Assert.Same(stateImageList, control.StateImageList);
-        Assert.Equal(expectedStateImageListHandleCreated, control.StateImageList.HandleCreated);
-        Assert.Equal(10, control.Indent);
-        Assert.Equal(11, control.ItemHeight);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.CheckBoxes);
-        Assert.True(control.ShowNodeToolTips);
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Blue, control.ForeColor);
-        Assert.Equal(Color.Yellow, control.LineColor);
-        Assert.Same(imageList, control.ImageList);
-        Assert.True(control.ImageList.HandleCreated);
-        Assert.Same(stateImageList, control.StateImageList);
-        Assert.Equal(expectedStateImageListHandleCreated, control.StateImageList.HandleCreated);
-        Assert.Equal(10, control.Indent);
-        Assert.Equal(11, control.ItemHeight);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_WithHandleWithProperties_TestData))]
-    public void TreeView_OnHandleCreated_InvokeWithHandleWithPropertiesDesignMode_CallsHandleCreated(Image[] images, EventArgs eventArgs, bool expectedStateImageListHandleCreated)
-    {
-        using var imageList = new ImageList();
-        using var stateImageList = new ImageList();
-        stateImageList.Images.AddRange(images);
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        using var control = new SubTreeView
-        {
-            CheckBoxes = true,
-            ShowNodeToolTips = true,
-            BackColor = Color.Red,
-            ForeColor = Color.Blue,
-            LineColor = Color.Yellow,
-            ImageList = imageList,
-            StateImageList = stateImageList,
-            Indent = 10,
-            ItemHeight = 11,
-            Site = mockSite.Object
-        };
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        control.SelectedNode = node;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.False(control.GetStyle(ControlStyles.UserPaint));
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.CheckBoxes);
-        Assert.True(control.ShowNodeToolTips);
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Blue, control.ForeColor);
-        Assert.Equal(Color.Yellow, control.LineColor);
-        Assert.Same(imageList, control.ImageList);
-        Assert.True(control.ImageList.HandleCreated);
-        Assert.Same(stateImageList, control.StateImageList);
-        Assert.Equal(expectedStateImageListHandleCreated, control.StateImageList.HandleCreated);
-        Assert.Equal(10, control.Indent);
-        Assert.Equal(11, control.ItemHeight);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.CheckBoxes);
-        Assert.True(control.ShowNodeToolTips);
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(Color.Blue, control.ForeColor);
-        Assert.Equal(Color.Yellow, control.LineColor);
-        Assert.Same(imageList, control.ImageList);
-        Assert.True(control.ImageList.HandleCreated);
-        Assert.Same(stateImageList, control.StateImageList);
-        Assert.Equal(expectedStateImageListHandleCreated, control.StateImageList.HandleCreated);
-        Assert.Equal(10, control.Indent);
-        Assert.Equal(11, control.ItemHeight);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleDestroyed_InvokeWithHandleWithSelectedNode_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        var node = new TreeNode();
-        control.Nodes.Add(node);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectedNode = node;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Same(node, control.SelectedNode);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Same(node, control.SelectedNode);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnHandleDestroyed_InvokeWithHandleWithStateImageList_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var imageList = new ImageList();
-        Assert.NotEqual(IntPtr.Zero, imageList.Handle);
-
-        using var control = new SubTreeView
-        {
-            StateImageList = imageList
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            //Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Same(imageList, control.StateImageList);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Same(imageList, control.StateImageList);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnMouseHover_Invoke_CallsMouseHover(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int nodeCallCount = 0;
-        control.NodeMouseHover += (sender, e) => nodeCallCount++;
-
-        // Call with handler.
-        control.MouseHover += handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Call leave.
-        control.OnMouseLeave(null);
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseHover -= handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnMouseHover_InvokeWithHandle_CallsMouseHover(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int nodeCallCount = 0;
-        control.NodeMouseHover += (sender, e) => nodeCallCount++;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.MouseHover += handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Call leave.
-        control.OnMouseLeave(null);
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseHover -= handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(2, callCount);
-        Assert.Equal(0, nodeCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TreeView_OnMouseLeave_Invoke_CallsMouseLeave(EventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> TreeNodeMouseClickEventArgs_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeNodeMouseClickEventArgs(null, MouseButtons.None, 0, 0, 0) };
-        yield return new object[] { new TreeNodeMouseClickEventArgs(new TreeNode(), MouseButtons.Right, 1, 2, 3) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNodeMouseClickEventArgs_TestData))]
-    public void TreeView_OnNodeMouseClick_Invoke_CallsNodeMouseClick(TreeNodeMouseClickEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeNodeMouseClickEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.NodeMouseClick += handler;
-        control.OnNodeMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.NodeMouseClick -= handler;
-        control.OnNodeMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TreeNodeMouseClickEventArgs_TestData))]
-    public void TreeView_OnNodeMouseDoubleClick_Invoke_CallsNodeMouseDoubleClick(TreeNodeMouseClickEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeNodeMouseClickEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.NodeMouseDoubleClick += handler;
-        control.OnNodeMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.NodeMouseDoubleClick -= handler;
-        control.OnNodeMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnNodeMouseHover_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new TreeNodeMouseHoverEventArgs(null) };
-        yield return new object[] { new TreeNodeMouseHoverEventArgs(new TreeNode()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnNodeMouseHover_TestData))]
-    public void TreeView_OnNodeMouseHover_Invoke_CallsNodeMouseHover(TreeNodeMouseHoverEventArgs eventArgs)
-    {
-        using var control = new SubTreeView();
-        int callCount = 0;
-        TreeNodeMouseHoverEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.NodeMouseHover += handler;
-        control.OnNodeMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.NodeMouseHover -= handler;
-        control.OnNodeMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null };
-        yield return new object[] { RightToLeft.Yes, new EventArgs() };
-        yield return new object[] { RightToLeft.No, null };
-        yield return new object[] { RightToLeft.No, new EventArgs() };
-        yield return new object[] { RightToLeft.Inherit, null };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_TestData))]
-    public void TreeView_OnRightToLeftLayoutChanged_Invoke_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs)
-    {
-        using var control = new SubTreeView
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_WithHandle_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null, 1 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.Inherit, null, 0 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_WithHandle_TestData))]
-    public void TreeView_OnRightToLeftLayoutChanged_InvokeWithHandle_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCreatedCallCount)
-    {
-        using var control = new SubTreeView
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount * 2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TreeView_OnRightToLeftLayoutChanged_InvokeInDisposing_DoesNotCallRightToLeftLayoutChanged()
-    {
-        using var control = new SubTreeView
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true)]
-    [InlineData(false, true)]
-    [InlineData(false, false)]
-    public unsafe void TreeView_InvokeGetToolInfoWrapper_ReturnsExpected(bool showNodeToolTips, bool useKeyboardToolTip)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        ToolTip toolTip = useKeyboardToolTip ? treeView.KeyboardToolTip : new ToolTip();
-        ComCtl32.ToolInfoWrapper<Control> wrapper = treeView.GetToolInfoWrapper(TOOLTIP_FLAGS.TTF_ABSOLUTE, "Test caption", toolTip);
-
-        Assert.Equal("Test caption", wrapper.Text);
-        // Assert.Equal method does not work because char* cannot be used as an argument to it
-        Assert.Equal(string.Empty, new string(wrapper.Info.lpszText));
-    }
-
-    [WinFormsFact]
-    public unsafe void TreeView_ShowNodesEnabled_ExternalToolTip_InvokeGetToolInfoWrapper_ReturnsExpected()
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = true;
-        ToolTip toolTip = new ToolTip();
-        ComCtl32.ToolInfoWrapper<Control> wrapper = treeView.GetToolInfoWrapper(TOOLTIP_FLAGS.TTF_ABSOLUTE, "Test caption", toolTip);
-        char* expected = (char*)(-1);
-
-        Assert.Null(wrapper.Text);
-        //Assert.Equal method does not work because char* cannot be used as an argument to it
-        Assert.True(wrapper.Info.lpszText == expected);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeAdd_AddNodeToTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        treeView.Nodes.Add(treeNode);
-
-        Assert.True(KeyboardToolTipStateMachine.Instance.TestAccessor().IsToolTracked(treeNode));
-        treeView.Nodes.Remove(treeNode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeAddRange_AddNodesToTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode1 = new TreeNode();
-        TreeNode treeNode2 = new TreeNode();
-        TreeNode treeNode3 = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-
-        treeView.Nodes.AddRange(new TreeNode[] { treeNode1, treeNode2, treeNode3 });
-
-        Assert.True(accessor.IsToolTracked(treeNode1));
-        Assert.True(accessor.IsToolTracked(treeNode2));
-        Assert.True(accessor.IsToolTracked(treeNode3));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeAdd_AddSubNodeToTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        TreeNode treeSubNodeLevel1 = new TreeNode();
-        TreeNode treeSubNodeLevel2 = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        treeView.Nodes.Add(treeNode);
-        treeNode.Nodes.Add(treeSubNodeLevel1);
-        treeSubNodeLevel1.Nodes.Add(treeSubNodeLevel2);
-
-        Assert.True(accessor.IsToolTracked(treeNode));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel2));
-        treeView.Nodes.Remove(treeNode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeAdd_AddNodeAndSubNodeToTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        TreeNode treeSubNodeLevel1 = new TreeNode();
-        TreeNode treeSubNodeLevel2 = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        treeNode.Nodes.Add(treeSubNodeLevel1);
-        treeSubNodeLevel1.Nodes.Add(treeSubNodeLevel2);
-        treeView.Nodes.Add(treeNode);
-
-        Assert.True(accessor.IsToolTracked(treeNode));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel2));
-        treeView.Nodes.Remove(treeNode);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeRemove_RemoveNodeFromTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-
-        treeView.Nodes.Add(treeNode);
-        Assert.True(accessor.IsToolTracked(treeNode));
-
-        treeView.Nodes.Remove(treeNode);
-
-        Assert.False(accessor.IsToolTracked(treeNode));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeRemove_RemoveNodeAndSubNodesFromTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        TreeNode treeSubNodeLevel1 = new TreeNode();
-        TreeNode treeSubNodeLevel2 = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        treeNode.Nodes.Add(treeSubNodeLevel1);
-        treeSubNodeLevel1.Nodes.Add(treeSubNodeLevel2);
-        treeView.Nodes.Add(treeNode);
-
-        Assert.True(accessor.IsToolTracked(treeNode));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel2));
-
-        treeView.Nodes.Remove(treeNode);
-
-        Assert.False(accessor.IsToolTracked(treeNode));
-        Assert.False(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.False(accessor.IsToolTracked(treeSubNodeLevel2));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeInsert_AddNodeToTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-
-        treeView.Nodes.Insert(0, treeNode);
-
-        Assert.True(KeyboardToolTipStateMachine.Instance.TestAccessor().IsToolTracked(treeNode));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_InvokeDispose_RemoveNodesFromTrackList(bool showNodeToolTips)
-    {
-        using var treeView = new TreeView();
-        treeView.ShowNodeToolTips = showNodeToolTips;
-        TreeNode treeNode = new TreeNode();
-        TreeNode treeSubNodeLevel1 = new TreeNode();
-        TreeNode treeSubNodeLevel2 = new TreeNode();
-        var accessor = KeyboardToolTipStateMachine.Instance.TestAccessor();
-        treeNode.Nodes.Add(treeSubNodeLevel1);
-        treeSubNodeLevel1.Nodes.Add(treeSubNodeLevel2);
-        treeView.Nodes.Add(treeNode);
-
-        Assert.True(accessor.IsToolTracked(treeNode));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.True(accessor.IsToolTracked(treeSubNodeLevel2));
-
-        treeView.Dispose();
-
-        Assert.False(accessor.IsToolTracked(treeNode));
-        Assert.False(accessor.IsToolTracked(treeSubNodeLevel1));
-        Assert.False(accessor.IsToolTracked(treeSubNodeLevel2));
-    }
-
-    [WinFormsFact]
-    public void TreeView_Invokes_SetToolTip_IfExternalToolTipIsSet()
-    {
-        using TreeView treeView = new TreeView();
-        treeView.ShowNodeToolTips = true;
-        using ToolTip toolTip = new ToolTip();
-        treeView.CreateControl();
-
-        dynamic listViewDynamic = treeView.TestAccessor().Dynamic;
-        string actual = listViewDynamic.controlToolTipText;
-
-        Assert.Null(actual);
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        string text = "Some test text";
-        toolTip.SetToolTip(treeView, text); // Invokes TreeView's SetToolTip inside
-        actual = listViewDynamic.controlToolTipText;
-
-        Assert.Equal(text, actual);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Remove_NotSelectedNode()
-    {
-        using TreeView treeView = new();
-        treeView.CreateControl();
-        treeView.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeView.SelectedNode = treeView.Nodes[0];
-
-        Assert.True(treeView.Nodes[0].IsSelected);
-        Assert.Equal(3, treeView.Nodes.Count);
-        Assert.Equal(treeView.Nodes[0], treeView.SelectedNode);
-
-        treeView.Nodes.Remove(treeView.Nodes[2]);
-
-        Assert.True(treeView.Nodes[0].IsSelected);
-        Assert.Equal(2, treeView.Nodes.Count);
-        Assert.Equal(treeView.Nodes[0], treeView.SelectedNode);
-
-        treeView.Nodes.Remove(treeView.Nodes[1]);
-
-        Assert.True(treeView.Nodes[0].IsSelected);
-        Assert.Equal(1, treeView.Nodes.Count);
-        Assert.Equal(treeView.Nodes[0], treeView.SelectedNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Remove_SelectedNode()
-    {
-        using TreeView treeView = new();
-        treeView.CreateControl();
-        treeView.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeView.SelectedNode = treeView.Nodes[0];
-
-        for (int count = treeView.Nodes.Count; count > 1; count -= 1)
-        {
-            TreeNode node = treeView.Nodes[0];
-
-            Assert.True(node.IsSelected);
-            Assert.Equal(count, treeView.Nodes.Count);
-            Assert.Equal(node, treeView.SelectedNode);
-
-            treeView.Nodes.Remove(node);
-            count -= 1;
-
-            Assert.False(node.IsSelected);
-            Assert.Equal(count, treeView.Nodes.Count);
-
-            if (count == 0)
-            {
-                Assert.Null(treeView.SelectedNode);
-            }
-            else
-            {
-                Assert.Equal(treeView.Nodes[0], treeView.SelectedNode);
-            }
-        }
-    }
-
-    [WinFormsFact]
-    public void TreeView_Remove_NotSelectedSubNode()
-    {
-        using TreeView treeView = new();
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeView.SelectedNode = treeNode.Nodes[0];
-
-        Assert.True(treeNode.Nodes[0].IsSelected);
-        Assert.Equal(3, treeNode.Nodes.Count);
-        Assert.Equal(treeNode.Nodes[0], treeView.SelectedNode);
-
-        treeNode.Nodes.Remove(treeNode.Nodes[2]);
-
-        Assert.True(treeNode.Nodes[0].IsSelected);
-        Assert.Equal(2, treeNode.Nodes.Count);
-        Assert.Equal(treeNode.Nodes[0], treeView.SelectedNode);
-
-        treeNode.Nodes.Remove(treeNode.Nodes[1]);
-
-        Assert.True(treeNode.Nodes[0].IsSelected);
-        Assert.Equal(1, treeNode.Nodes.Count);
-        Assert.Equal(treeNode.Nodes[0], treeView.SelectedNode);
-    }
-
-    [WinFormsFact]
-    public void TreeView_Remove_SelectedSubNode()
-    {
-        using TreeView treeView = new();
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeView.SelectedNode = treeNode.Nodes[0];
-
-        for (int count = treeNode.Nodes.Count; count > 1; count -= 1)
-        {
-            TreeNode node = treeNode.Nodes[0];
-
-            Assert.True(node.IsSelected);
-            Assert.Equal(count, treeNode.Nodes.Count);
-            Assert.Equal(node, treeView.SelectedNode);
-
-            treeView.Nodes.Remove(node);
-            count -= 1;
-
-            Assert.False(node.IsSelected);
-            Assert.Equal(count, treeNode.Nodes.Count);
-
-            if (count == 0)
-            {
-                Assert.Equal(treeView.Nodes[0], treeView.SelectedNode);
-            }
-            else
-            {
-                Assert.Equal(treeNode.Nodes[0], treeView.SelectedNode);
-            }
-        }
-    }
-
-    [WinFormsFact]
-    public void TreeView_Remove_ParentSelectedNode()
-    {
-        using TreeView treeView = new();
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.Add("Test 1");
-
-        treeView.SelectedNode = treeNode.Nodes[0];
-
-        Assert.True(treeNode.Nodes[0].IsSelected);
-        Assert.Equal(treeNode.Nodes[0], treeView.SelectedNode);
-        Assert.Equal(1, treeNode.Nodes.Count);
-        Assert.Equal(1, treeView.Nodes.Count);
-
-        treeView.Nodes.Remove(treeNode);
-
-        Assert.False(treeNode.Nodes[0].IsSelected);
-        Assert.Null(treeView.SelectedNode);
-        Assert.Equal(0, treeView.Nodes.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_Remove_NotCheckedNode(bool checkBoxes)
-    {
-        using TreeView treeView = new() { CheckBoxes = checkBoxes };
-        treeView.CreateControl();
-        treeView.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeView.Nodes[0].Checked = true;
-
-        Assert.True(treeView.Nodes[0].Checked);
-        Assert.Equal(3, treeView.Nodes.Count);
-
-        treeView.Nodes.Remove(treeView.Nodes[2]);
-
-        Assert.True(treeView.Nodes[0].Checked);
-        Assert.Equal(2, treeView.Nodes.Count);
-
-        treeView.Nodes.Remove(treeView.Nodes[1]);
-
-        Assert.True(treeView.Nodes[0].Checked);
-        Assert.Equal(1, treeView.Nodes.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_Remove_CheckedNode(bool checkBoxes)
-    {
-        using TreeView treeView = new() { CheckBoxes = checkBoxes };
-        treeView.CreateControl();
-        treeView.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        for (int count = treeView.Nodes.Count; count > 1; count -= 1)
-        {
-            TreeNode node = treeView.Nodes[0];
-            node.Checked = true;
-
-            Assert.True(node.Checked);
-            Assert.Equal(count, treeView.Nodes.Count);
-
-            treeView.Nodes.Remove(node);
-            count -= 1;
-
-            Assert.True(node.Checked);
-            Assert.Equal(count, treeView.Nodes.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_Remove_NotCheckedSubNode(bool checkBoxes)
-    {
-        using TreeView treeView = new() { CheckBoxes = checkBoxes };
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        treeNode.Nodes[0].Checked = true;
-
-        Assert.True(treeNode.Nodes[0].Checked);
-        Assert.Equal(3, treeNode.Nodes.Count);
-
-        treeNode.Nodes.Remove(treeNode.Nodes[2]);
-
-        Assert.True(treeNode.Nodes[0].Checked);
-        Assert.Equal(2, treeNode.Nodes.Count);
-
-        treeNode.Nodes.Remove(treeNode.Nodes[1]);
-
-        Assert.True(treeNode.Nodes[0].Checked);
-        Assert.Equal(1, treeNode.Nodes.Count);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_Remove_CheckedSubNode(bool checkBoxes)
-    {
-        using TreeView treeView = new() { CheckBoxes = checkBoxes };
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.AddRange(new TreeNode[] { new("Test 1"), new("Test 2"), new("Test 3") });
-
-        for (int count = treeNode.Nodes.Count; count > 1; count -= 1)
-        {
-            TreeNode node = treeNode.Nodes[0];
-            node.Checked = true;
-
-            Assert.True(node.Checked);
-            Assert.Equal(count, treeNode.Nodes.Count);
-
-            treeView.Nodes.Remove(node);
-            count -= 1;
-
-            Assert.True(node.Checked);
-            Assert.Equal(count, treeNode.Nodes.Count);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void TreeView_Remove_ParentCheckedNode(bool checkBoxes)
-    {
-        using TreeView treeView = new() { CheckBoxes = checkBoxes };
-        treeView.CreateControl();
-
-        treeView.Nodes.Add("Test");
-        TreeNode treeNode = treeView.Nodes[0];
-        treeNode.Nodes.Add("Test 1");
-
-        treeView.Nodes[0].Checked = true;
-        treeNode.Nodes[0].Checked = true;
-
-        Assert.True(treeNode.Checked);
-        Assert.True(treeNode.Nodes[0].Checked);
-        Assert.Equal(1, treeNode.Nodes.Count);
-        Assert.Equal(1, treeView.Nodes.Count);
-
-        treeView.Nodes.Remove(treeNode);
-
-        Assert.True(treeNode.Checked);
-        Assert.True(treeNode.Nodes[0].Checked);
-        Assert.Equal(1, treeNode.Nodes.Count);
-        Assert.Equal(0, treeView.Nodes.Count);
-    }
-
-    [WinFormsFact]
-    public void TreeView_TreeViewNodeSorter_ComparesTreeNodes()
-    {
-        using TreeView treeView = new();
-
-        treeView.Nodes.Add("Root 1");
-        treeView.Nodes[0].Nodes.Add("Child 1");
-        treeView.Nodes[0].Nodes.Add("Child 2");
-
-        treeView.Nodes.Add("Root 2");
-        treeView.Nodes[1].Nodes.Add("Child 3");
-        treeView.Nodes[1].Nodes.Add("Child 4");
-
-        IComparer treeSorter = Comparer<object>.Create(
-            (object x, object y) =>
-            {
-                Assert.True(x is TreeNode);
-                Assert.True(y is TreeNode);
-
-                return 0;
-            });
-
-        // Setting TreeViewNodeSorter invokes sorting automatically
-        treeView.TreeViewNodeSorter = treeSorter;
-    }
-
-    [WinFormsTheory]
-    [InlineData("A", "B")]
-    [InlineData("A", "A")]
-    [InlineData("B", "A")]
-    public void Clear_AfterSort_ShouldNotGetStuck(string firstNodeText, string secondNodeText)
-    {
-        using TreeView treeView = new();
-        TreeNode parent = new("Parent");
-        treeView.Nodes.Add(parent);
-
-        TreeNode firstNode = new(firstNodeText);
-        parent.Nodes.Add(firstNode);
-        TreeNode secondNode = new(secondNodeText);
-        parent.Nodes.Add(secondNode);
-
-        treeView.Sort();
-
-        Stopwatch timer = new();
-        timer.Start();
-        parent.Nodes.Clear();
-        timer.Stop();
-        Assert.True(timer.ElapsedMilliseconds <= 500);
-    }
-
-    [WinFormsTheory]
-    [InlineData("A", "B")]
-    [InlineData("A", "A")]
-    [InlineData("B", "A")]
-    public void Remove_AfterSort_ShouldNotThrowException(string firstNodeText, string secondNodeText)
-    {
-        using TreeView treeView = new();
-        TreeNode parent = new("Parent");
-        treeView.Nodes.Add(parent);
-
-        TreeNode firstNode = new(firstNodeText);
-        parent.Nodes.Add(firstNode);
-        TreeNode secondNode = new(secondNodeText);
-        parent.Nodes.Add(secondNode);
-
-        treeView.Sort();
-
-        parent.Nodes.Remove(firstNode);
-
-        parent.Nodes.Remove(secondNode);
-    }
-
-    private class SubTreeView : TreeView
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnAfterCheck(TreeViewEventArgs e) => base.OnAfterCheck(e);
-
-        public new void OnAfterCollapse(TreeViewEventArgs e) => base.OnAfterCollapse(e);
-
-        public new void OnAfterExpand(TreeViewEventArgs e) => base.OnAfterExpand(e);
-
-        public new void OnAfterLabelEdit(NodeLabelEditEventArgs e) => base.OnAfterLabelEdit(e);
-
-        public new void OnAfterSelect(TreeViewEventArgs e) => base.OnAfterSelect(e);
-
-        public new void OnBeforeCheck(TreeViewCancelEventArgs e) => base.OnBeforeCheck(e);
-
-        public new void OnBeforeCollapse(TreeViewCancelEventArgs e) => base.OnBeforeCollapse(e);
-
-        public new void OnBeforeExpand(TreeViewCancelEventArgs e) => base.OnBeforeExpand(e);
-
-        public new void OnBeforeLabelEdit(NodeLabelEditEventArgs e) => base.OnBeforeLabelEdit(e);
-
-        public new void OnBeforeSelect(TreeViewCancelEventArgs e) => base.OnBeforeSelect(e);
-
-        public new void OnDrawNode(DrawTreeNodeEventArgs e) => base.OnDrawNode(e);
-
-        public new void OnItemDrag(ItemDragEventArgs e) => base.OnItemDrag(e);
-
-        public new void OnKeyDown(KeyEventArgs e) => base.OnKeyDown(e);
-
-        public new void OnKeyPress(KeyPressEventArgs e) => base.OnKeyPress(e);
-
-        public new void OnKeyUp(KeyEventArgs e) => base.OnKeyUp(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMouseHover(EventArgs e) => base.OnMouseHover(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnNodeMouseClick(TreeNodeMouseClickEventArgs e) => base.OnNodeMouseClick(e);
-
-        public new void OnNodeMouseDoubleClick(TreeNodeMouseClickEventArgs e) => base.OnNodeMouseDoubleClick(e);
-
-        public new void OnNodeMouseHover(TreeNodeMouseHoverEventArgs e) => base.OnNodeMouseHover(e);
-
-        public new void OnRightToLeftLayoutChanged(EventArgs e) => base.OnRightToLeftLayoutChanged(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TypeValidationEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TypeValidationEventArgsTests.cs
deleted file mode 100644
index 77046afe279..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/TypeValidationEventArgsTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class TypeValidationEventArgsTests
-{
-    [Theory]
-    [InlineData(typeof(int), true, "returnValue", "message")]
-    [InlineData(typeof(int), true, "returnValue", "")]
-    [InlineData(null, false, null, null)]
-    public void Ctor_Type_Object_Object_String(Type validatingType, bool isValidInput, object returnValue, string message)
-    {
-        var e = new TypeValidationEventArgs(validatingType, isValidInput, returnValue, message);
-        Assert.Equal(validatingType, e.ValidatingType);
-        Assert.Equal(isValidInput, e.IsValidInput);
-        Assert.Equal(returnValue, e.ReturnValue);
-        Assert.Equal(message, e.Message);
-        Assert.False(e.Cancel);
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void Cancel_Set_GetReturnsExpected(bool value)
-    {
-        var e = new TypeValidationEventArgs(typeof(int), true, "returnValue", "message")
-        {
-            Cancel = value
-        };
-        Assert.Equal(value, e.Cancel);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UICuesEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UICuesEventArgsTests.cs
deleted file mode 100644
index 5af30b3fe28..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UICuesEventArgsTests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class UICuesEventArgsTests
-{
-    [Theory]
-    [InlineData((UICues)(-1))]
-    [InlineData(UICues.None)]
-    [InlineData(UICues.ShowFocus)]
-    [InlineData(UICues.ShowKeyboard)]
-    [InlineData(UICues.Shown)]
-    [InlineData(UICues.ChangeFocus)]
-    [InlineData(UICues.ChangeKeyboard)]
-    [InlineData(UICues.Changed)]
-    [InlineData(UICues.Changed | UICues.Shown)]
-    public void Ctor_UICues(UICues uicues)
-    {
-        var e = new UICuesEventArgs(uicues);
-        Assert.Equal((uicues & UICues.ShowFocus) != 0, e.ShowFocus);
-        Assert.Equal((uicues & UICues.ShowKeyboard) != 0, e.ShowKeyboard);
-        Assert.Equal((uicues & UICues.ChangeFocus) != 0, e.ChangeFocus);
-        Assert.Equal((uicues & UICues.ChangeKeyboard) != 0, e.ChangeKeyboard);
-        Assert.Equal(uicues & UICues.Changed, e.Changed);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObject.DirectionButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObject.DirectionButtonAccessibleObjectTests.cs
deleted file mode 100644
index 17c276db91f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObject.DirectionButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.UpDownBase;
-using static System.Windows.Forms.UpDownBase.UpDownButtons;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class UpDownBase_UpDownButtons_UpDownButtonsAccessibleObject_DirectionButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [InlineData(((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(((int)UiaCore.UIA.IsInvokePatternAvailablePropertyId))]
-    public void UpDownButtonsAccessibleObject_DirectionButtonAccessibleObject_GetPropertyValue_IsPatternSupported(int propertyId)
-    {
-        using SubUpDownBase upDownBase = new();
-        using UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = new(upDownButtons);
-        // UpButton has 0 index
-        AccessibleObject upButton = accessibleObject.GetChild(index: 0);
-        bool actual = (bool)upButton.GetPropertyValue((UiaCore.UIA)propertyId);
-
-        Assert.True(actual);
-        Assert.False(upDownButtons.IsHandleCreated);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.PushButton)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleStatePropertyId, AccessibleStates.None)]
-    [InlineData((int)UiaCore.UIA.ValueValuePropertyId, null)]
-    public void NumericUpDownAccessibleObject_DirectionButtonAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using SubUpDownBase upDownBase = new();
-        using UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = new(upDownButtons);
-        // UpButton has 0 index
-        AccessibleObject upButton = accessibleObject.GetChild(index: 0);
-        object actual = upButton.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void UpDownButtonsAccessibleObject_DirectionButtonAccessibleObject_FragmentNavigate_Parent_ReturnsExpected(int childIndex)
-    {
-        using SubUpDownBase upDownBase = new();
-        using UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = new(upDownButtons);
-
-        // UpButton has 0 index, DownButton has 1 index
-        AccessibleObject directionButton = accessibleObject.GetChild(childIndex);
-
-        Assert.Equal(accessibleObject, directionButton.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(upDownButtons.IsHandleCreated);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void UpDownButtonsAccessibleObject_DirectionButtonAccessibleObject_FragmentNavigate_Child_ReturnsNull(int childIndex)
-    {
-        using SubUpDownBase upDownBase = new();
-        using UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = new(upDownButtons);
-
-        // UpButton has 0 index, DownButton has 1 index
-        AccessibleObject directionButton = accessibleObject.GetChild(childIndex);
-
-        Assert.Null(directionButton.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(directionButton.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-
-        Assert.False(upDownButtons.IsHandleCreated);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    private class SubUpDownBase : UpDownBase
-    {
-        protected override void UpdateEditText() => throw new NotImplementedException();
-
-        public override void UpButton() => throw new NotImplementedException();
-
-        public override void DownButton() => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObjectTests.cs
deleted file mode 100644
index 8f2fc3f4099..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownButtons.UpDownButtonsAccessibleObjectTests.cs
+++ /dev/null
@@ -1,224 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.Automation;
-using static System.Windows.Forms.UpDownBase;
-using static System.Windows.Forms.UpDownBase.UpDownButtons;
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class UpDownBase_UpDownButtons_UpDownButtonsAccessibleObject
-{
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_Ctor_Default()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        using UpDownButtons upDownButtons = new UpDownButtons(upDownBase);
-        UpDownButtonsAccessibleObject accessibleObject = new UpDownButtonsAccessibleObject(upDownButtons);
-
-        Assert.Equal(upDownButtons, accessibleObject.Owner);
-        Assert.False(upDownBase.IsHandleCreated);
-        Assert.False(upDownButtons.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_ControlType_IsSpinner_IfAccessibleRoleIsDefault()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        // AccessibleRole is not set = Default
-
-        object actual = upDownButtons.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.SpinnerControlTypeId, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_Role_IsSpinButton_ByDefault()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        // AccessibleRole is not set = Default
-
-        AccessibleRole actual = upDownButtons.AccessibilityObject.Role;
-
-        Assert.Equal(AccessibleRole.SpinButton, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UpDownButtonsAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpDownButtonsAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        upDownButtons.AccessibleRole = role;
-
-        object actual = upDownButtons.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_Name_ReturnsExpected()
-    {
-        const string name = "Test name";
-        using SubUpDownBase upDownBase = new();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        upDownButtons.AccessibleName = name;
-
-        object actual = upDownButtons.AccessibilityObject.GetPropertyValue(UiaCore.UIA.NamePropertyId);
-
-        Assert.Equal(name, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_RuntimeId_ReturnsExpected()
-    {
-        using SubUpDownBase upDownBase = new();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-
-        object actual = upDownButtons.AccessibilityObject.GetPropertyValue(UiaCore.UIA.RuntimeIdPropertyId);
-
-        Assert.Equal(upDownButtons.AccessibilityObject.RuntimeId, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_BoundingRectangle_ReturnsExpected()
-    {
-        using SubUpDownBase upDownBase = new();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        object actual = upDownButtons.AccessibilityObject.GetPropertyValue(UiaCore.UIA.BoundingRectanglePropertyId);
-
-        Assert.Equal(UiaTextProvider.BoundingRectangleAsArray(upDownButtons.AccessibilityObject.BoundingRectangle), actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(false, ((int)UiaCore.UIA.IsExpandCollapsePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsGridPatternAvailablePropertyId))]
-    [InlineData(true, ((int)UiaCore.UIA.IsLegacyIAccessiblePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsMultipleViewPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsScrollPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsSelectionPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTableItemPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTablePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTextPatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsTogglePatternAvailablePropertyId))]
-    [InlineData(false, ((int)UiaCore.UIA.IsValuePatternAvailablePropertyId))]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_Pattern_ReturnsExpected(bool expected, int propertyId)
-    {
-        using TrackBar trackBar = new();
-        using SubUpDownBase upDownBase = new();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = (UpDownButtonsAccessibleObject)upDownButtons.AccessibilityObject;
-
-        Assert.Equal(expected, accessibleObject.GetPropertyValue((UiaCore.UIA)propertyId) ?? false);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleRolePropertyId, AccessibleRole.SpinButton)]
-    [InlineData((int)UiaCore.UIA.LegacyIAccessibleStatePropertyId, AccessibleStates.None)]
-    [InlineData((int)UiaCore.UIA.ValueValuePropertyId, null)]
-    public void UpDownButtonsAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
-    {
-        using TrackBar trackBar = new();
-        using SubUpDownBase upDownBase = new();
-        UpDownButtons upDownButtons = upDownBase.UpDownButtonsInternal;
-        UpDownButtonsAccessibleObject accessibleObject = (UpDownButtonsAccessibleObject)upDownButtons.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);
-
-        Assert.Equal(expected, actual);
-        Assert.False(upDownBase.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_FragmentNavigate_Parent_ReturnsNull()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        using UpDownButtons upDownButtons = new UpDownButtons(upDownBase);
-        UpDownButtonsAccessibleObject accessibleObject = new UpDownButtonsAccessibleObject(upDownButtons);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.False(upDownBase.IsHandleCreated);
-        Assert.False(upDownButtons.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_FragmentNavigate_Sibling_ReturnsNull()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        using UpDownButtons upDownButtons = new UpDownButtons(upDownBase);
-        UpDownButtonsAccessibleObject accessibleObject = new UpDownButtonsAccessibleObject(upDownButtons);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.False(upDownBase.IsHandleCreated);
-        Assert.False(upDownButtons.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_FragmentNavigate_Child_ReturnsExpected_InNumericUpDown()
-    {
-        using NumericUpDown numericUpDown = new();
-        UpDownButtonsAccessibleObject accessibleObject = (UpDownButtonsAccessibleObject)numericUpDown.UpDownButtonsInternal.AccessibilityObject;
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject upButton = accessibleObject.GetChild(0);
-        AccessibleObject downButton = accessibleObject.GetChild(1);
-
-        Assert.Equal(upButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(downButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(numericUpDown.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownButtonsAccessibleObject_FragmentNavigate_Child_ReturnsExpected_InDomainUpDown()
-    {
-        using DomainUpDown domainUpDown = new();
-        UpDownButtonsAccessibleObject accessibleObject = (UpDownButtonsAccessibleObject)domainUpDown.UpDownButtonsInternal.AccessibilityObject;
-
-        // UpButton has 0 childId, DownButton has 1 childId
-        AccessibleObject upButton = accessibleObject.GetChild(0);
-        AccessibleObject downButton = accessibleObject.GetChild(1);
-
-        Assert.Equal(upButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(downButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(domainUpDown.IsHandleCreated);
-    }
-
-    private class SubUpDownBase : UpDownBase
-    {
-        protected override void UpdateEditText() => throw new NotImplementedException();
-
-        public override void UpButton() => throw new NotImplementedException();
-
-        public override void DownButton() => throw new NotImplementedException();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownEdit.UpDownEditAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownEdit.UpDownEditAccessibleObjectTests.cs
deleted file mode 100644
index 5189a12a753..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBase.UpDownEdit.UpDownEditAccessibleObjectTests.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static Interop;
-
-namespace System.Windows.Forms.Tests;
-
-public class UpDownEditAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_ctor_default()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        UpDownBase.UpDownEdit.UpDownEditAccessibleObject accessibleObject = new UpDownBase.UpDownEdit.UpDownEditAccessibleObject(upDownEdit, upDown);
-        Assert.Equal(upDownEdit, accessibleObject.Owner);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_ctor_ThrowsException_IfParentIsNull()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        Assert.Throws<ArgumentNullException>(() => new UpDownBase.UpDownEdit.UpDownEditAccessibleObject(upDownEdit, null));
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_ctor_ThrowsException_IfOwnerIsNull()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        Assert.Throws<ArgumentNullException>(() => new UpDownBase.UpDownEdit.UpDownEditAccessibleObject(null, upDown));
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_IsIAccessibleExSupported_ReturnsTrue()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.True(accessibleObject.IsIAccessibleExSupported());
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_Custom_Name_ReturnsCorrectValue()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        string name = "Custom name";
-        upDown.AccessibleName = name;
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Equal(name, accessibleObject.Name);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_Default_Name_ReturnsNull()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Null(accessibleObject.Name);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_Default_Name_ReturnsExpected_NumericUpDown()
-    {
-        using NumericUpDown upDown = new();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Equal(SR.EditDefaultAccessibleName, accessibleObject.Name);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_Default_Name_ReturnsExpected_DomainUpDown()
-    {
-        using DomainUpDown upDown = new();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Equal(SR.EditDefaultAccessibleName, accessibleObject.Name);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownEditAccessibleObject_KeyboardShortcut_ReturnsParentsKeyboardShortcut()
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Equal(upDown.AccessibilityObject.KeyboardShortcut, accessibleObject.KeyboardShortcut);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void UpDownEditAccessibleObject_IsReadOnly_IsExpected(bool readOnly)
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        upDownEdit.ReadOnly = readOnly;
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.Equal(readOnly, accessibleObject.IsReadOnly);
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.IsTextPatternAvailablePropertyId)]
-    [InlineData((int)UiaCore.UIA.IsTextPattern2AvailablePropertyId)]
-    public void UpDownEditAccessibleObject_GetPropertyValue_PatternsSuported(int propertyID)
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.True((bool)accessibleObject.GetPropertyValue((UiaCore.UIA)propertyID));
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UiaCore.UIA.TextPatternId)]
-    [InlineData((int)UiaCore.UIA.TextPattern2Id)]
-    public void UpDownEditAccessibleObject_IsPatternSupported_PatternsSuported(int patternId)
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        Assert.True(accessibleObject.IsPatternSupported((UiaCore.UIA)patternId));
-        Assert.False(upDown.IsHandleCreated);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text, (int)UiaCore.UIA.EditControlTypeId)]
-    [InlineData(false, AccessibleRole.None, (int)UiaCore.UIA.PaneControlTypeId)]
-    public void UpDownEditAccessibleObject_ControlType_IsExpected_IfAccessibleRoleIsDefault(bool createControl, AccessibleRole expectedRole, int expectedType)
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        // AccessibleRole is not set = Default
-
-        if (createControl)
-        {
-            upDownEdit.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = upDownEdit.AccessibilityObject;
-        object actual = accessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal((UiaCore.UIA)expectedType, actual);
-        Assert.Equal(createControl, upDownEdit.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UpDownEditAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpDownEditAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void UpDownEditAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using UpDownBase upDown = new SubUpDownBase();
-        using UpDownBase.UpDownEdit upDownEdit = new UpDownBase.UpDownEdit(upDown);
-        upDownEdit.AccessibleRole = role;
-
-        object actual = upDownEdit.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(upDownEdit.IsHandleCreated);
-    }
-
-    private class SubUpDownBase : UpDownBase
-    {
-        public override void DownButton() { }
-
-        public override void UpButton() { }
-
-        protected override void UpdateEditText() { }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBaseTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBaseTests.cs
deleted file mode 100644
index 249506f553f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownBaseTests.cs
+++ /dev/null
@@ -1,3235 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class UpDownBaseTests
-{
-    [WinFormsFact]
-    public void UpDownBase_Ctor_Default()
-    {
-        using var control = new SubUpDownBase();
-        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);
-        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(122, control.PreferredHeight), control.PreferredSize);
-        }
-        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(123, control.PreferredHeight), control.PreferredSize);
-        }
-
-        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.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.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.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubUpDownBase();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-
-        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);
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
-        }
-        else
-        {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE | WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
-        }
-
-        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);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56010000, 0x10000)]
-    [InlineData(BorderStyle.Fixed3D, 0x56010000, 0x10200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56810000, 0x10000)]
-    public void UpDownSubUpDownBase_CreateParams_GetBorderStyleNoVisualStyles_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_AutoScroll_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoScroll = value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_AutoScroll_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoScroll = value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScroll = value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoScroll = !value;
-        Assert.False(control.AutoScroll);
-        Assert.False(control.GetScrollState(SubUpDownBase.ScrollStateAutoScrolling));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMargin_Set_TestData()
-    {
-        yield return new object[] { true, new Size(0, 0) };
-        yield return new object[] { true, new Size(1, 0) };
-        yield return new object[] { true, new Size(0, 1) };
-        yield return new object[] { true, new Size(1, 2) };
-        yield return new object[] { false, new Size(0, 0) };
-        yield return new object[] { false, new Size(1, 0) };
-        yield return new object[] { false, new Size(0, 1) };
-        yield return new object[] { false, new Size(1, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void UpDownBase_AutoScrollMargin_Set_GetReturnsExpected(bool autoScroll, Size value)
-    {
-        using var control = new SubUpDownBase
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMargin_Set_TestData))]
-    public void UpDownBase_AutoScrollMargin_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value)
-    {
-        using var control = new SubUpDownBase
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Null(e.AffectedControl);
-            Assert.Null(e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMargin = value;
-        Assert.Equal(value, control.AutoScrollMargin);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> AutoScrollMinSize_TestData()
-    {
-        foreach (bool autoScroll in new bool[] { true, false })
-        {
-            yield return new object[] { autoScroll, new Size(-1, -2), 1 };
-            yield return new object[] { autoScroll, new Size(0, 0), 0 };
-            yield return new object[] { autoScroll, new Size(1, 0), 1 };
-            yield return new object[] { autoScroll, new Size(0, 1), 1 };
-            yield return new object[] { autoScroll, new Size(1, 2), 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_TestData))]
-    public void UpDownBase_AutoScrollMinSize_Set_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new SubUpDownBase
-        {
-            AutoScroll = autoScroll
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoScrollMinSize_TestData))]
-    public void UpDownBase_AutoScrollMinSize_SetWithHandle_GetReturnsExpected(bool autoScroll, Size value, int expectedLayoutCallCount)
-    {
-        using var control = new SubUpDownBase
-        {
-            AutoScroll = autoScroll
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            layoutCallCount++;
-        };
-
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoScrollMinSize = value;
-        Assert.Equal(value, control.AutoScrollMinSize);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new SubUpDownBase
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red };
-        yield return new object[] { Color.Empty, SystemColors.Window };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void UpDownBase_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubUpDownBase
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BackColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Red, Color.Red, 1 };
-        yield return new object[] { Color.Empty, SystemColors.Window, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_SetWithHandle_TestData))]
-    public void UpDownBase_BackColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void UpDownBase_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new SubUpDownBase
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void UpDownBase_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubUpDownBase
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> BorderStyle_Set_TestData()
-    {
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { BorderStyle.Fixed3D, new Size(122, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.FixedSingle, new Size(122, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.None, new Size(122, Control.DefaultFont.Height + 3) };
-        }
-        else
-        {
-            yield return new object[] { BorderStyle.Fixed3D, new Size(123, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.FixedSingle, new Size(121, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.None, new Size(119, Control.DefaultFont.Height + 3) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderStyle_Set_TestData))]
-    public void UpDownBase_BorderStyle_Set_GetReturnsExpected(BorderStyle value, Size expectedPreferredSize)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(expectedPreferredSize.Height, control.PreferredHeight);
-        Assert.Equal(expectedPreferredSize, control.PreferredSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(expectedPreferredSize.Height, control.PreferredHeight);
-        Assert.Equal(expectedPreferredSize, control.PreferredSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> BorderStyle_SetWithHandle_TestData()
-    {
-        if (Application.UseVisualStyles)
-        {
-            yield return new object[] { BorderStyle.Fixed3D, 0, 0, new Size(122, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.FixedSingle, 0, 1, new Size(122, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.None, 1, 1, new Size(123, Control.DefaultFont.Height + 3) };
-        }
-        else
-        {
-            yield return new object[] { BorderStyle.Fixed3D, 0, 0, new Size(123, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.FixedSingle, 1, 1, new Size(123, Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3) };
-            yield return new object[] { BorderStyle.None, 2, 1, new Size(123, Control.DefaultFont.Height + 3) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BorderStyle_SetWithHandle_TestData))]
-    public void UpDownBase_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount, int expectedCreatedCallCount, Size expectedPreferredSize)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(expectedPreferredSize.Height, control.PreferredHeight);
-        Assert.Equal(expectedPreferredSize, control.PreferredSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.Equal(expectedPreferredSize.Height, control.PreferredHeight);
-        Assert.Equal(expectedPreferredSize, control.PreferredSize);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void UpDownBase_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_ChangingText_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase
-        {
-            ChangingText = value
-        };
-        Assert.Equal(value, control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ChangingText = value;
-        Assert.Equal(value, control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ChangingText = !value;
-        Assert.Equal(!value, control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_ChangingText_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ChangingText = value;
-        Assert.Equal(value, control.ChangingText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ChangingText = value;
-        Assert.Equal(value, control.ChangingText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ChangingText = !value;
-        Assert.Equal(!value, control.ChangingText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ContextMenuStrip_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new ContextMenuStrip() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ContextMenuStrip_Set_TestData))]
-    public void UpDownBase_ContextMenuStrip_Set_GetReturnsExpected(ContextMenuStrip value)
-    {
-        using var control = new SubUpDownBase
-        {
-            ContextMenuStrip = value
-        };
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ContextMenuStrip = value;
-        Assert.Same(value, control.ContextMenuStrip);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_ContextMenuStrip_SetWithHandler_CallsContextMenuStripChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ContextMenuStripChanged += handler;
-
-        // Set different.
-        using var menu1 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var menu2 = new ContextMenuStrip();
-        control.ContextMenuStrip = menu2;
-        Assert.Same(menu2, control.ContextMenuStrip);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.ContextMenuStrip = null;
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.ContextMenuStripChanged -= handler;
-        control.ContextMenuStrip = menu1;
-        Assert.Same(menu1, control.ContextMenuStrip);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void UpDownBase_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubUpDownBase
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void UpDownBase_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_InterceptArrowKeys_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase
-        {
-            InterceptArrowKeys = value
-        };
-        Assert.Equal(value, control.InterceptArrowKeys);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.InterceptArrowKeys = value;
-        Assert.Equal(value, control.InterceptArrowKeys);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.InterceptArrowKeys = !value;
-        Assert.Equal(!value, control.InterceptArrowKeys);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_InterceptArrowKeys_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.InterceptArrowKeys = value;
-        Assert.Equal(value, control.InterceptArrowKeys);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.InterceptArrowKeys = value;
-        Assert.Equal(value, control.InterceptArrowKeys);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.InterceptArrowKeys = !value;
-        Assert.Equal(!value, control.InterceptArrowKeys);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> MaximumSize_Set_TestData()
-    {
-        yield return new object[] { Size.Empty, 120, 0 };
-        yield return new object[] { new Size(-1, -2), 0, 1 };
-        yield return new object[] { new Size(0, 1), 120, 0 };
-        yield return new object[] { new Size(0, 10), 120, 0 };
-        yield return new object[] { new Size(1, 0), 1, 1 };
-        yield return new object[] { new Size(10, 0), 10, 1 };
-        yield return new object[] { new Size(1, 2), 1, 1 };
-        yield return new object[] { new Size(3, 4), 3, 1 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), 120, 0 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), 120, 0 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), 120, 0 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), 120, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MaximumSize_Set_TestData))]
-    public void UpDownBase_MaximumSize_Set_GetReturnsExpected(Size value, int expectedWidth, int expectedLayoutCallCount)
-    {
-        using var control = new SubUpDownBase();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MaximumSize = value;
-        Assert.Equal(new Size(value.Width, 0), control.MaximumSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaximumSize = value;
-        Assert.Equal(new Size(value.Width, 0), control.MaximumSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MinimumSize_Set_TestData()
-    {
-        yield return new object[] { Size.Empty, 120, 0 };
-        yield return new object[] { new Size(0, 1), 120, 0 };
-        yield return new object[] { new Size(0, 10), 120, 0 };
-        yield return new object[] { new Size(1, 0), 120, 0 };
-        yield return new object[] { new Size(10, 0), 120, 0 };
-        yield return new object[] { new Size(-1, -2), 120, 0 };
-        yield return new object[] { new Size(1, 2), 120, 0 };
-        yield return new object[] { new Size(3, 4), 120, 0 };
-        yield return new object[] { new Size(ushort.MaxValue - 1, ushort.MaxValue - 1), ushort.MaxValue - 1, 1 };
-        yield return new object[] { new Size(ushort.MaxValue, ushort.MaxValue), ushort.MaxValue, 1 };
-        yield return new object[] { new Size(ushort.MaxValue + 1, ushort.MaxValue + 1), ushort.MaxValue + 1, 1 };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue), int.MaxValue, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MinimumSize_Set_TestData))]
-    public void UpDownBase_MinimumSize_Set_GetReturnsExpected(Size value, int expectedWidth, int expectedLayoutCallCount)
-    {
-        using var control = new SubUpDownBase();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.MinimumSize = value;
-        Assert.Equal(new Size(value.Width, 0), control.MinimumSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MinimumSize = value;
-        Assert.Equal(new Size(value.Width, 0), control.MinimumSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.Size);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_ReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase
-        {
-            ReadOnly = value
-        };
-        Assert.Equal(value, control.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ReadOnly = !value;
-        Assert.Equal(!value, control.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_ReadOnly_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ReadOnly = !value;
-        Assert.Equal(!value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Text_Set_TestData()
-    {
-        foreach (bool changingText in new bool[] { true, false })
-        {
-            yield return new object[] { changingText, true, null, string.Empty, 1, 0, true };
-            yield return new object[] { changingText, false, null, string.Empty, 0, 0, false };
-            yield return new object[] { changingText, true, string.Empty, string.Empty, 1, 0, true };
-            yield return new object[] { changingText, false, string.Empty, string.Empty, 0, 0, false };
-        }
-
-        yield return new object[] { true, true, "text", "text", 1, 1, true };
-        yield return new object[] { false, true, "text", "text", 1, 1, true };
-        yield return new object[] { true, false, "text", "text", 0, 1, false };
-        yield return new object[] { false, false, "text", "text", 1, 1, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void UpDownBase_Text_Set_GetReturnsExpected(bool changingText, bool userEdit, string value, string expected, int expectedValidateEditTextCallCount, int expectedOnChangedCallCount, bool expectedUserEdit)
-    {
-        using (new NoAssertContext())
-        {
-            int validateEditTextCallCount = 0;
-            int onChangedCallCount = 0;
-            using var control = new CustomValidateUpDownBase
-            {
-                ChangingText = changingText,
-                UserEdit = userEdit,
-                ValidateEditTextAction = () => validateEditTextCallCount++
-            };
-            control.OnChangedAction = (source, e) =>
-            {
-                Assert.Same(control, ((Control)source).Parent);
-                Assert.Same(EventArgs.Empty, e);
-                onChangedCallCount++;
-            };
-
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.ChangingText);
-            Assert.Equal(expectedUserEdit, control.UserEdit);
-            Assert.Equal(expectedValidateEditTextCallCount, validateEditTextCallCount);
-            Assert.Equal(expectedOnChangedCallCount, onChangedCallCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.ChangingText);
-            Assert.Equal(expectedUserEdit, control.UserEdit);
-            Assert.Equal(expectedValidateEditTextCallCount * 2, validateEditTextCallCount);
-            Assert.Equal(expectedOnChangedCallCount, onChangedCallCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_Set_TestData))]
-    public void UpDownBase_Text_SetWithHandle_GetReturnsExpected(bool changingText, bool userEdit, string value, string expected, int expectedValidateEditTextCallCount, int expectedOnChangedCallCount, bool expectedUserEdit)
-    {
-        using (new NoAssertContext())
-        {
-            int validateEditTextCallCount = 0;
-            int onChangedCallCount = 0;
-            using var control = new CustomValidateUpDownBase
-            {
-                ChangingText = changingText,
-                UserEdit = userEdit,
-                ValidateEditTextAction = () => validateEditTextCallCount++
-            };
-            control.OnChangedAction = (source, e) =>
-            {
-                Assert.Same(control, ((Control)source).Parent);
-                Assert.Same(EventArgs.Empty, e);
-                onChangedCallCount++;
-            };
-            Assert.NotEqual(IntPtr.Zero, control.Handle);
-            int invalidatedCallCount = 0;
-            control.Invalidated += (sender, e) => invalidatedCallCount++;
-            int styleChangedCallCount = 0;
-            control.StyleChanged += (sender, e) => styleChangedCallCount++;
-            int createdCallCount = 0;
-            control.HandleCreated += (sender, e) => createdCallCount++;
-
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.ChangingText);
-            Assert.Equal(expectedUserEdit, control.UserEdit);
-            Assert.Equal(expectedValidateEditTextCallCount, validateEditTextCallCount);
-            Assert.Equal(expectedOnChangedCallCount, onChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-
-            // Set same.
-            control.Text = value;
-            Assert.Equal(expected, control.Text);
-            Assert.False(control.ChangingText);
-            Assert.Equal(expectedUserEdit, control.UserEdit);
-            Assert.Equal(expectedValidateEditTextCallCount * 2, validateEditTextCallCount);
-            Assert.Equal(expectedOnChangedCallCount, onChangedCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-        }
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void UpDownBase_TextAlign_Set_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var control = new SubUpDownBase
-        {
-            TextAlign = value
-        };
-        Assert.Equal(value, control.TextAlign);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<HorizontalAlignment>]
-    public void UpDownBase_TextAlign_SetWithHandle_GetReturnsExpected(HorizontalAlignment value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TextAlign = value;
-        Assert.Equal(value, control.TextAlign);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<HorizontalAlignment>]
-    public void UpDownBase_TextAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(HorizontalAlignment value)
-    {
-        var control = new SubUpDownBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TextAlign = value);
-    }
-
-    public static IEnumerable<object[]> UpDownAlign_Set_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                yield return new object[] { borderStyle, rightToLeft, LeftRightAlignment.Left };
-                yield return new object[] { borderStyle, rightToLeft, LeftRightAlignment.Right };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpDownAlign_Set_TestData))]
-    public void UpDownBase_UpDownAlign_Set_GetReturnsExpected(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment value)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = value
-        };
-        Assert.Equal(value, control.UpDownAlign);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UpDownAlign = value;
-        Assert.Equal(value, control.UpDownAlign);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> UpDownAlign_SetWithHandle_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                yield return new object[] { borderStyle, rightToLeft, LeftRightAlignment.Left, 1 };
-                yield return new object[] { borderStyle, rightToLeft, LeftRightAlignment.Right, 0 };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(UpDownAlign_SetWithHandle_TestData))]
-    public void UpDownBase_UpDownAlign_SetWithHandle_GetReturnsExpected(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UpDownAlign = value;
-        Assert.Equal(value, control.UpDownAlign);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UpDownAlign = value;
-        Assert.Equal(value, control.UpDownAlign);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<LeftRightAlignment>]
-    public void UpDownBase_UpDownAlign_SetInvalidValue_ThrowsInvalidEnumArgumentException(LeftRightAlignment value)
-    {
-        var control = new SubUpDownBase();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.UpDownAlign = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_UserEdit_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase
-        {
-            UserEdit = value
-        };
-        Assert.Equal(value, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.UserEdit = value;
-        Assert.Equal(value, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.UserEdit = !value;
-        Assert.Equal(!value, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_UserEdit_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.UserEdit = value;
-        Assert.Equal(value, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.UserEdit = value;
-        Assert.Equal(value, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.UserEdit = !value;
-        Assert.Equal(!value, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubUpDownBase();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        yield return new object[] { Size.Empty };
-        yield return new object[] { new Size(-1, -2) };
-        yield return new object[] { new Size(10, 20) };
-        yield return new object[] { new Size(30, 40) };
-        yield return new object[] { new Size(int.MaxValue, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void UpDownBase_GetPreferredSize_Invoke_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubUpDownBase();
-
-        int expectedWidth = Application.UseVisualStyles ? 122 : 123;
-        Size preferredSize = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), preferredSize);
-
-        // Call again.
-        preferredSize = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), preferredSize);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void UpDownBase_GetPreferredSize_InvokeWithBounds_ReturnsExpected(Size proposedSize)
-    {
-        using var control = new SubUpDownBase
-        {
-            Bounds = new Rectangle(1, 2, 30, 40)
-        };
-
-        int expectedWidth = Application.UseVisualStyles ? 32 : 33;
-
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithConstrainedSize_TestData()
-    {
-        int expectedWidth = Application.UseVisualStyles ? 122 : 123;
-
-        yield return new object[] { Size.Empty, Size.Empty, new Size(30, 40), expectedWidth };
-        yield return new object[] { new Size(10, 20), Size.Empty, new Size(30, 40), expectedWidth };
-        yield return new object[] { new Size(30, 40), Size.Empty, new Size(30, 40), expectedWidth };
-        yield return new object[] { new Size(31, 40), Size.Empty, new Size(30, 40), expectedWidth };
-        yield return new object[] { new Size(30, 41), Size.Empty, new Size(30, 40), expectedWidth };
-        yield return new object[] { new Size(40, 50), Size.Empty, new Size(30, 40), expectedWidth };
-
-        yield return new object[] { Size.Empty, new Size(20, 10), new Size(30, 40), 20 };
-        yield return new object[] { Size.Empty, new Size(30, 40), new Size(30, 40), 30 };
-        yield return new object[] { Size.Empty, new Size(31, 40), new Size(30, 40), 31 };
-        yield return new object[] { Size.Empty, new Size(30, 41), new Size(30, 40), 30 };
-        yield return new object[] { Size.Empty, new Size(40, 50), new Size(30, 40), 40 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), new Size(30, 40), 40 };
-        yield return new object[] { new Size(10, 20), new Size(40, 50), new Size(int.MaxValue, int.MaxValue), 40 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), 20 };
-        yield return new object[] { new Size(10, 20), new Size(20, 30), new Size(30, 40), 20 };
-        yield return new object[] { new Size(30, 40), new Size(20, 30), new Size(30, 40), 30 };
-        yield return new object[] { new Size(30, 40), new Size(40, 50), new Size(30, 40), 40 };
-        yield return new object[] { new Size(40, 50), new Size(20, 30), new Size(30, 40), 40 };
-        yield return new object[] { new Size(40, 50), new Size(40, 50), new Size(30, 40), 40 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithConstrainedSize_TestData))]
-    public void UpDownBase_GetPreferredSize_InvokeWithConstrainedSize_ReturnsExpected(Size minimumSize, Size maximumSize, Size proposedSize, int expectedWidth)
-    {
-        using var control = new SubUpDownBase
-        {
-            MinimumSize = minimumSize,
-            MaximumSize = maximumSize,
-        };
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(expectedWidth, control.PreferredHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubUpDownBase.ScrollStateAutoScrolling, false)]
-    [InlineData(SubUpDownBase.ScrollStateFullDrag, false)]
-    [InlineData(SubUpDownBase.ScrollStateHScrollVisible, false)]
-    [InlineData(SubUpDownBase.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubUpDownBase.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void UpDownBase_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubUpDownBase();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, true)]
-    [InlineData(ControlStyles.ResizeRedraw, true)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void UpDownBase_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubUpDownBase();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubUpDownBase();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> OnChanged_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { new object(), new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnChanged_TestData))]
-    public void UpDownBase_OnChanged_Invoke_Nop(object source, EventArgs e)
-    {
-        using var control = new SubUpDownBase();
-        control.OnChanged(source, e);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.OnChanged(source, e);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnChanged_TestData))]
-    public void UpDownBase_OnChanged_InvokeWithHandle_Nop(object source, EventArgs e)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.OnChanged(source, e);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.OnChanged(source, e);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> OnFontChanged_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                foreach (LeftRightAlignment upDownAlign in Enum.GetValues(typeof(LeftRightAlignment)))
-                {
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, null };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnFontChanged_TestData))]
-    public void UpDownBase_OnFontChanged_Invoke_CallsFontChanged(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment upDownAlign, EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = upDownAlign
-        };
-        int preferredHeight = control.PreferredHeight;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleCreated_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                foreach (LeftRightAlignment upDownAlign in Enum.GetValues(typeof(LeftRightAlignment)))
-                {
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, null };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void UpDownBase_OnHandleCreated_Invoke_CallsHandleCreated(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment upDownAlign, EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = upDownAlign
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleCreated_TestData))]
-    public void UpDownBase_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment upDownAlign, EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = upDownAlign
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UpDownBase_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UpDownBase_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnLayout_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                foreach (LeftRightAlignment upDownAlign in Enum.GetValues(typeof(LeftRightAlignment)))
-                {
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, null };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new LayoutEventArgs(null, null) };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new LayoutEventArgs(new Control(), "affectedProperty") };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnLayout_TestData))]
-    public void UpDownBase_OnLayout_Invoke_CallsLayout(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment upDownAlign, LayoutEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = upDownAlign
-        };
-        int callCount = 0;
-        LayoutEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Layout += handler;
-        control.OnLayout(eventArgs);
-        Assert.NotEqual(0, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Layout -= handler;
-        control.OnLayout(eventArgs);
-        Assert.NotEqual(0, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> MouseEventArgs_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseEventArgs_TestData))]
-    public void UpDownBase_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnMouseDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubUpDownBase();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseDown(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UpDownBase_OnMouseEnter_Invoke_CallsMouseEnter(EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseEnter += handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseEnter -= handler;
-        control.OnMouseEnter(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UpDownSubUpDownBase_OnMouseHover_Invoke_CallsMouseHover(EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseHover += handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseHover -= handler;
-        control.OnMouseHover(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UpDownBase_OnMouseLeave_Invoke_CallsMouseLeave(EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseLeave += handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseLeave -= handler;
-        control.OnMouseLeave(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void UpDownBase_OnMouseMove_Invoke_CallsMouseMove(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseMove += handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseMove -= handler;
-        control.OnMouseMove(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseEventArgs_TestData))]
-    public void UpUpBase_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnMouseUp_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubUpDownBase();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseUp(null));
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseEventArgs_TestData))]
-    public void UpDownBase_OnMouseWheel_Invoke_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UpDownBase_OnMouseWheel_InvokeHandledMouseEventArgs_SetsHandled(bool handled)
-    {
-        using var control = new SubUpDownBase();
-        var eventArgs = new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, handled);
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(handled, eventArgs.Handled);
-            callCount++;
-        };
-        control.MouseWheel += handler;
-
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnMouseWheel_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubUpDownBase();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseWheel(null));
-    }
-
-    public static IEnumerable<object[]> OnPaint_TestData()
-    {
-        foreach (bool enabled in new bool[] { true, false })
-        {
-            foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-            {
-                foreach (Color backColor in new Color[] { Color.Red, Color.Empty })
-                {
-                    yield return new object[] { new Size(100, 200), enabled, borderStyle, backColor };
-                    yield return new object[] { new Size(10, 10), enabled, borderStyle, backColor };
-                    yield return new object[] { new Size(9, 10), enabled, borderStyle, backColor };
-                    yield return new object[] { new Size(10, 9), enabled, borderStyle, backColor };
-                    yield return new object[] { new Size(9, 9), enabled, borderStyle, backColor };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void UpDownBase_OnPaint_Invoke_CallsPaint(Size size, bool enabled, BorderStyle borderStyle, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubUpDownBase
-        {
-            Size = size,
-            Enabled = enabled,
-            BorderStyle = borderStyle,
-            BackColor = backColor
-        };
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnPaint_TestData))]
-    public void UpDownBase_OnPaint_InvokeWithHandle_CallsPaint(Size size, bool enabled, BorderStyle borderStyle, Color backColor)
-    {
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using var eventArgs = new PaintEventArgs(graphics, Rectangle.Empty);
-
-        using var control = new SubUpDownBase
-        {
-            Size = size,
-            Enabled = enabled,
-            BorderStyle = borderStyle,
-            BackColor = backColor
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnPaint_VisualStyles_on_NullE_ThrowsNullReferenceException()
-    {
-        if (!Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubUpDownBase();
-        Assert.Throws<NullReferenceException>(() => control.OnPaint(null));
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnPaint_VisualStyles_off_NullE_ThrowsArgumentNullException()
-    {
-        if (Application.RenderWithVisualStyles)
-        {
-            return;
-        }
-
-        using var control = new SubUpDownBase();
-        Assert.Throws<ArgumentNullException>(() => control.OnPaint(null));
-    }
-
-    public static IEnumerable<object[]> OnTextBoxKeyDown_TestData()
-    {
-        foreach (object source in new object[] { null, new object() })
-        {
-            foreach (bool userEdit in new bool[] { true, false })
-            {
-                yield return new object[] { true, userEdit, source, new KeyEventArgs(Keys.A), 0, 0, 0, false };
-                yield return new object[] { false, userEdit, source, new KeyEventArgs(Keys.A), 0, 0, 0, false };
-                yield return new object[] { true, userEdit, source, new KeyEventArgs(Keys.Up), 1, 0, 0, true };
-                yield return new object[] { false, userEdit, source, new KeyEventArgs(Keys.Up), 0, 0, 0, false };
-                yield return new object[] { true, userEdit, source, new KeyEventArgs(Keys.Down), 0, 1, 0, true };
-                yield return new object[] { false, userEdit, source, new KeyEventArgs(Keys.Down), 0, 0, 0, false };
-                yield return new object[] { true, userEdit, source, new KeyEventArgs(Keys.Left), 0, 0, 0, false };
-                yield return new object[] { false, userEdit, source, new KeyEventArgs(Keys.Left), 0, 0, 0, false };
-                yield return new object[] { true, userEdit, source, new KeyEventArgs(Keys.Right), 0, 0, 0, false };
-                yield return new object[] { false, userEdit, source, new KeyEventArgs(Keys.Right), 0, 0, 0, false };
-            }
-
-            foreach (bool interceptArrowKeys in new bool[] { true, false })
-            {
-                yield return new object[] { interceptArrowKeys, true, source, new KeyEventArgs(Keys.Return), 0, 0, 1, false };
-                yield return new object[] { interceptArrowKeys, false, source, new KeyEventArgs(Keys.Return), 0, 0, 0, false };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextBoxKeyDown_TestData))]
-    public void UpDownBase_OnTextBoxKeyDown_Invoke_CallsKeyDown(bool interceptArrowKeys, bool userEdit, object source, KeyEventArgs eventArgs, int expectedUpButtonCallCount, int expectedDownButtonCallCount, int expectedValidateEditTextCallCount, bool expectedHandled)
-    {
-        int upButtonCallCount = 0;
-        int downButtonCallCount = 0;
-        int validateEditTextCallCount = 0;
-        using var control = new CustomValidateUpDownBase
-        {
-            InterceptArrowKeys = interceptArrowKeys,
-            UserEdit = userEdit,
-            UpButtonAction = () => upButtonCallCount++,
-            DownButtonAction = () => downButtonCallCount++,
-            ValidateEditTextAction = () => validateEditTextCallCount++
-        };
-        int callCount = 0;
-        KeyEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyDown += handler;
-        control.OnTextBoxKeyDown(source, eventArgs);
-        Assert.Equal(expectedUpButtonCallCount, upButtonCallCount);
-        Assert.Equal(expectedDownButtonCallCount, downButtonCallCount);
-        Assert.Equal(expectedValidateEditTextCallCount, validateEditTextCallCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyDown -= handler;
-        control.OnTextBoxKeyDown(source, eventArgs);
-        Assert.Equal(expectedUpButtonCallCount * 2, upButtonCallCount);
-        Assert.Equal(expectedDownButtonCallCount * 2, downButtonCallCount);
-        Assert.Equal(expectedValidateEditTextCallCount * 2, validateEditTextCallCount);
-        Assert.Equal(expectedHandled, eventArgs.Handled);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_OnTextBoxKeyDown_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubUpDownBase();
-        Assert.Throws<NullReferenceException>(() => control.OnTextBoxKeyDown(new object(), null));
-    }
-
-    public static IEnumerable<object[]> OnTextBoxKeyPress_TestData()
-    {
-        yield return new object[] { null, null };
-        yield return new object[] { null, null };
-        yield return new object[] { null, new KeyPressEventArgs('a') };
-        yield return new object[] { null, new KeyPressEventArgs('a') };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextBoxKeyPress_TestData))]
-    public void UpPressBase_OnTextBoxKeyPress_Invoke_CallsKeyPress(object source, KeyPressEventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        KeyPressEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.KeyPress += handler;
-        control.OnTextBoxKeyPress(source, eventArgs);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.KeyPress -= handler;
-        control.OnTextBoxKeyPress(source, eventArgs);
-        Assert.False(eventArgs?.Handled ?? false);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnTextBoxLostFocus_TestData()
-    {
-        yield return new object[] { true, null, null, 1 };
-        yield return new object[] { true, null, null, 1 };
-        yield return new object[] { true, null, new EventArgs(), 1 };
-        yield return new object[] { true, null, new EventArgs(), 1 };
-        yield return new object[] { false, null, null, 0 };
-        yield return new object[] { false, null, null, 0 };
-        yield return new object[] { false, null, new EventArgs(), 0 };
-        yield return new object[] { false, null, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextBoxLostFocus_TestData))]
-    public void UpPressBase_OnTextBoxLostFocus_Invoke_CallsLostFocus(bool userEdit, object source, EventArgs eventArgs, int expectedValidateEditTextCallCount)
-    {
-        int validateEditTextCallCount = 0;
-        using var control = new CustomValidateUpDownBase
-        {
-            UserEdit = userEdit,
-            ValidateEditTextAction = () => validateEditTextCallCount++
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) => callCount++;
-
-        // Call with handler.
-        control.LostFocus += handler;
-        control.OnTextBoxLostFocus(source, eventArgs);
-        Assert.Equal(expectedValidateEditTextCallCount, validateEditTextCallCount);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.LostFocus -= handler;
-        control.OnTextBoxLostFocus(source, eventArgs);
-        Assert.Equal(expectedValidateEditTextCallCount * 2, validateEditTextCallCount);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> OnTextBoxResize_TestData()
-    {
-        foreach (BorderStyle borderStyle in Enum.GetValues(typeof(BorderStyle)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                foreach (LeftRightAlignment upDownAlign in Enum.GetValues(typeof(LeftRightAlignment)))
-                {
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, null, null };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new object(), null };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, null, new EventArgs() };
-                    yield return new object[] { borderStyle, rightToLeft, upDownAlign, new object(), new EventArgs() };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextBoxResize_TestData))]
-    public void UpDownBase_OnTextBoxResize_Invoke_CallsTextBoxResize(BorderStyle borderStyle, RightToLeft rightToLeft, LeftRightAlignment upDownAlign, object source, EventArgs eventArgs)
-    {
-        using var control = new SubUpDownBase
-        {
-            BorderStyle = borderStyle,
-            RightToLeft = rightToLeft,
-            UpDownAlign = upDownAlign
-        };
-        int preferredHeight = control.PreferredHeight;
-
-        // Call with handler.
-        control.OnTextBoxResize(source, eventArgs);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.OnTextBoxResize(source, eventArgs);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnTextBoxTextChanged_TestData()
-    {
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            yield return new object[] { true, userEdit, null, null, userEdit };
-            yield return new object[] { true, userEdit, null, null, userEdit };
-            yield return new object[] { true, userEdit, null, new EventArgs(), userEdit };
-            yield return new object[] { true, userEdit, null, new EventArgs(), userEdit };
-        }
-
-        foreach (bool userEdit in new bool[] { true, false })
-        {
-            yield return new object[] { false, userEdit, null, null, true };
-            yield return new object[] { false, userEdit, null, null, true };
-            yield return new object[] { false, userEdit, null, new EventArgs(), true };
-            yield return new object[] { false, userEdit, null, new EventArgs(), true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnTextBoxTextChanged_TestData))]
-    public void UpPressBase_OnTextBoxTextChanged_Invoke_CallsTextChanged(bool changingText, bool userEdit, object source, EventArgs eventArgs, bool expectedUserEdit)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new CustomValidateUpDownBase
-            {
-                ChangingText = changingText,
-                UserEdit = userEdit
-            };
-            int onChangedCallCount = 0;
-            control.OnChangedAction = (sender, e) =>
-            {
-                Assert.Same(source, sender);
-                Assert.Same(EventArgs.Empty, e);
-                onChangedCallCount++;
-            };
-            int callCount = 0;
-            EventHandler handler = (sender, e) => callCount++;
-
-            // Call with handler.
-            control.TextChanged += handler;
-            control.OnTextBoxTextChanged(source, eventArgs);
-            Assert.False(control.ChangingText);
-            Assert.Equal(expectedUserEdit, control.UserEdit);
-            Assert.Equal(1, callCount);
-            Assert.Equal(1, onChangedCallCount);
-
-            // Remove handler.
-            control.TextChanged -= handler;
-            control.OnTextBoxTextChanged(source, eventArgs);
-            Assert.False(control.ChangingText);
-            Assert.True(control.UserEdit);
-            Assert.Equal(1, callCount);
-            Assert.Equal(2, onChangedCallCount);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(1, 2)]
-    [InlineData(0, 0)]
-    [InlineData(-1, -2)]
-    public void UpDownBase_RescaleConstantsForDpi_Invoke_Nop(int deviceDpiOld, int deviceDpiNew)
-    {
-        using var control = new SubUpDownBase();
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 0, 1)]
-    [InlineData("tex", 0, 4)]
-    [InlineData("text", 1, 2)]
-    public void UpDownBase_Select_Invoke_Success(string text, int start, int length)
-    {
-        using var control = new SubUpDownBase
-        {
-            Text = text
-        };
-        control.Select(start, length);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Select(start, length);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 0, 1)]
-    [InlineData("tex", 0, 4)]
-    [InlineData("text", 1, 2)]
-    public void UpDownBase_Select_InvokeWithHandle_Success(string text, int start, int length)
-    {
-        using var control = new SubUpDownBase
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Select(start, length);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Select(start, length);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 120, 0, specified, 0, 0 };
-            yield return new object[] { -1, -2, -3, -4, specified, 1, 1 };
-            yield return new object[] { 1, 0, 120, 0, specified, 1, 0 };
-            yield return new object[] { 0, 2, 120, 0, specified, 1, 0 };
-            yield return new object[] { 1, 2, 120, 0, specified, 1, 0 };
-            yield return new object[] { 0, 0, 1, 0, specified, 0, 1 };
-            yield return new object[] { 0, 0, 120, 2, specified, 0, 0 };
-            yield return new object[] { 0, 0, 1, 2, specified, 0, 1 };
-            yield return new object[] { 1, 2, 30, 40, specified, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void UpDownBase_SetBoundsCore_Invoke_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubUpDownBase();
-        int preferredHeight = control.PreferredHeight;
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(new Size(width, Control.DefaultFont.Height + 7), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, Control.DefaultFont.Height + 7), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, Control.DefaultFont.Height + 7), control.DisplayRectangle);
-        }
-        else
-        {
-            Assert.Equal(new Size(width - 4, Control.DefaultFont.Height + 3), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width - 4, Control.DefaultFont.Height + 3), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width - 4, Control.DefaultFont.Height + 3), control.DisplayRectangle);
-        }
-
-        Assert.Equal(new Size(width, preferredHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + preferredHeight, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, preferredHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-
-        if (Application.UseVisualStyles)
-        {
-            Assert.Equal(new Size(width, Control.DefaultFont.Height + 7), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width, Control.DefaultFont.Height + 7), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width, Control.DefaultFont.Height + 7), control.DisplayRectangle);
-        }
-        else
-        {
-            Assert.Equal(new Size(width - 4, Control.DefaultFont.Height + 3), control.ClientSize);
-            Assert.Equal(new Rectangle(0, 0, width - 4, Control.DefaultFont.Height + 3), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, width - 4, Control.DefaultFont.Height + 3), control.DisplayRectangle);
-        }
-
-        Assert.Equal(new Size(width, preferredHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + preferredHeight, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(preferredHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, preferredHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_ValidateEditText_Invoke_Nop()
-    {
-        using var control = new SubUpDownBase();
-        control.ValidateEditText();
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.ValidateEditText();
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_ValidateEditText_InvokeWithHandle_Nop()
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ValidateEditText();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.ValidateEditText();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeKillFocusWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubUpDownBase();
-            int callCount = 0;
-            control.LostFocus += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_KILLFOCUS,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeKillFocusWithHandle_Success()
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.LostFocus += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_KILLFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeMouseHoverWithoutHandle_Success()
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubUpDownBase();
-            int callCount = 0;
-            control.MouseHover += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Same(EventArgs.Empty, e);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_MOUSEHOVER,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeSetFocusWithoutHandle_Success()
-    {
-        using var control = new SubUpDownBase();
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_WndProc_InvokeSetFocusWithHandle_Success()
-    {
-        using var control = new SubUpDownBase();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.GotFocus += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UpDownBase_Invokes_SetToolTip_IfExternalToolTipIsSet()
-    {
-        using UpDownBase upDownBase = new SubUpDownBase();
-        using ToolTip toolTip = new ToolTip();
-        upDownBase.CreateControl();
-
-        string actualEditToolTipText = toolTip.GetToolTip(upDownBase._upDownEdit);
-        string actualButtonsToolTipText = toolTip.GetToolTip(upDownBase._upDownButtons);
-
-        Assert.Empty(actualEditToolTipText);
-        Assert.Empty(actualButtonsToolTipText);
-        Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle
-
-        string text = "Some test text";
-        toolTip.SetToolTip(upDownBase, text); // Invokes UpDownBase's SetToolTip inside
-        actualEditToolTipText = toolTip.GetToolTip(upDownBase._upDownEdit);
-        actualButtonsToolTipText = toolTip.GetToolTip(upDownBase._upDownButtons);
-
-        Assert.Equal(text, actualEditToolTipText);
-        Assert.Equal(text, actualButtonsToolTipText);
-    }
-
-    private class CustomValidateUpDownBase : UpDownBase
-    {
-        public new bool ChangingText
-        {
-            get => base.ChangingText;
-            set => base.ChangingText = value;
-        }
-
-        public Action DownButtonAction { get; set; }
-
-        public override void DownButton() => DownButtonAction();
-
-        public Action<object, EventArgs> OnChangedAction { get; set; }
-
-        protected override void OnChanged(object source, EventArgs e) => OnChangedAction(source, e);
-
-        public new void OnTextBoxKeyDown(object source, KeyEventArgs e) => base.OnTextBoxKeyDown(source, e);
-
-        public new void OnTextBoxLostFocus(object source, EventArgs e) => base.OnTextBoxLostFocus(source, e);
-
-        public new void OnTextBoxTextChanged(object source, EventArgs e) => base.OnTextBoxTextChanged(source, e);
-
-        public Action UpButtonAction { get; set; }
-
-        public override void UpButton() => UpButtonAction();
-
-        public Action UpdateEditTextAction { get; set; }
-
-        protected override void UpdateEditText() => UpdateEditTextAction();
-
-        public new bool UserEdit
-        {
-            get => base.UserEdit;
-            set => base.UserEdit = value;
-        }
-
-        public Action ValidateEditTextAction { get; set; }
-
-        protected override void ValidateEditText() => ValidateEditTextAction();
-    }
-
-    public class SubUpDownBase : UpDownBase
-    {
-        public new const int ScrollStateAutoScrolling = UpDownBase.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = UpDownBase.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = UpDownBase.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = UpDownBase.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = UpDownBase.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new bool ChangingText
-        {
-            get => base.ChangingText;
-            set => base.ChangingText = value;
-        }
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool UserEdit
-        {
-            get => base.UserEdit;
-            set => base.UserEdit = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public override void DownButton()
-        {
-            throw new NotImplementedException();
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnChanged(object source, EventArgs e) => base.OnChanged(source, e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnLayout(LayoutEventArgs e) => base.OnLayout(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnMouseEnter(EventArgs e) => base.OnMouseEnter(e);
-
-        public new void OnMouseHover(EventArgs e) => base.OnMouseHover(e);
-
-        public new void OnMouseLeave(EventArgs e) => base.OnMouseLeave(e);
-
-        public new void OnMouseMove(MouseEventArgs e) => base.OnMouseMove(e);
-
-        public new void OnMouseUp(MouseEventArgs mevent) => base.OnMouseUp(mevent);
-
-        public new void OnMouseWheel(MouseEventArgs e) => base.OnMouseWheel(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnTextBoxKeyDown(object source, KeyEventArgs e) => base.OnTextBoxKeyDown(source, e);
-
-        public new void OnTextBoxKeyPress(object source, KeyPressEventArgs e) => base.OnTextBoxKeyPress(source, e);
-
-        public new void OnTextBoxLostFocus(object source, EventArgs e) => base.OnTextBoxLostFocus(source, e);
-
-        public new void OnTextBoxResize(object source, EventArgs e) => base.OnTextBoxResize(source, e);
-
-        public new void OnTextBoxTextChanged(object source, EventArgs e) => base.OnTextBoxTextChanged(source, e);
-
-        public new void RescaleConstantsForDpi(int deviceDpiOld, int deviceDpiNew) => base.RescaleConstantsForDpi(deviceDpiOld, deviceDpiNew);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public override void UpButton()
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override void UpdateEditText()
-        {
-            throw new NotImplementedException();
-        }
-
-        public new void ValidateEditText() => base.ValidateEditText();
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownEventArgsTests.cs
deleted file mode 100644
index 242afd8c7ec..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UpDownEventArgsTests.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class UpDownEventArgsTests
-{
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void Ctor_Int(int buttonPushed)
-    {
-        var e = new UpDownEventArgs(buttonPushed);
-        Assert.Equal(buttonPushed, e.ButtonID);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserConfigDisposableFixture.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserConfigDisposableFixture.cs
deleted file mode 100644
index 6904eacb8f7..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserConfigDisposableFixture.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Configuration;
-
-namespace System.Windows.Forms.Tests;
-
-public class UserConfigDisposableFixture : IDisposable
-{
-    public UserConfigDisposableFixture()
-    {
-        DeleteUserConfig();
-    }
-
-    public void Dispose()
-    {
-        DeleteUserConfig();
-    }
-
-    private static void DeleteUserConfig()
-    {
-        var configuration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal);
-        if (File.Exists(configuration.FilePath))
-        {
-            File.Delete(configuration.FilePath);
-        }
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserControlTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserControlTests.cs
deleted file mode 100644
index 1f6fde346e4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/UserControlTests.cs
+++ /dev/null
@@ -1,1881 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.Layout;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class UserControlTests
-{
-    [WinFormsFact]
-    public void UserControl_Ctor_Default()
-    {
-        using var control = new SubUserControl();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Null(control.ActiveControl);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        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(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(150, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 150, 150), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Rectangle(0, 0, 150, 150), control.ClientRectangle);
-        Assert.Equal(new Size(150, 150), control.ClientSize);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(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(150, 150), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 150, 150), control.DisplayRectangle);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(150, 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.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        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(Size.Empty, control.PreferredSize);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(150, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(150, 150), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(150, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UserControl_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubUserControl();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x10000, createParams.ExStyle);
-        Assert.Equal(150, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(150, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x56010000, 0x10000)]
-    [InlineData(BorderStyle.Fixed3D, 0x56010000, 0x10200)]
-    [InlineData(BorderStyle.FixedSingle, 0x56810000, 0x10000)]
-    public void UserControl_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubUserControl
-        {
-            BorderStyle = borderStyle
-        };
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(150, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(150, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void UserControl_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new UserControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UserControl_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new UserControl
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_Set_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var control = new SubUserControl();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetDesignMode_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubUserControl
-        {
-            Site = mockSite.Object
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetWithParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubUserControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetDesignModeWithParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(new AmbientProperties());
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        using var control = new SubUserControl
-        {
-            Parent = parent,
-            Site = mockSite.Object
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(0, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(0, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetWithCustomLayoutEngineParent_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubUserControl
-        {
-            Parent = parent
-        };
-        parent.SetLayoutEngine(new SubLayoutEngine());
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.False(control.IsHandleCreated);
-            Assert.Equal(0, layoutCallCount);
-            Assert.False(parent.IsHandleCreated);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    private class CustomLayoutEngineControl : Control
-    {
-        private LayoutEngine _layoutEngine;
-
-        public CustomLayoutEngineControl()
-        {
-            _layoutEngine = new Control().LayoutEngine;
-        }
-
-        public void SetLayoutEngine(LayoutEngine layoutEngine)
-        {
-            _layoutEngine = layoutEngine;
-        }
-
-        public override LayoutEngine LayoutEngine => _layoutEngine;
-    }
-
-    private class SubLayoutEngine : LayoutEngine
-    {
-    }
-
-    [WinFormsTheory]
-    [EnumData<AutoSizeMode>]
-    public void UserControl_AutoSizeMode_SetWithHandle_GetReturnsExpected(AutoSizeMode value)
-    {
-        using var control = new SubUserControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSizeMode = value;
-        Assert.Equal(value, control.AutoSizeMode);
-        Assert.Equal(value, control.GetAutoSizeMode());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetWithParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubUserControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(AutoSizeMode.GrowAndShrink, 1)]
-    [InlineData(AutoSizeMode.GrowOnly, 0)]
-    public void UserControl_AutoSizeMode_SetWithCustomLayoutEngineParentWithHandle_GetReturnsExpected(AutoSizeMode value, int expectedLayoutCallCount)
-    {
-        using var parent = new CustomLayoutEngineControl();
-        using var control = new SubUserControl
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("AutoSize", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int parentInvalidatedCallCount = 0;
-        parent.Invalidated += (sender, e) => parentInvalidatedCallCount++;
-        int parentStyleChangedCallCount = 0;
-        parent.StyleChanged += (sender, e) => parentStyleChangedCallCount++;
-        int parentCreatedCallCount = 0;
-        parent.HandleCreated += (sender, e) => parentCreatedCallCount++;
-
-        try
-        {
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-
-            // Set same.
-            control.AutoSizeMode = value;
-            Assert.Equal(value, control.AutoSizeMode);
-            Assert.Equal(value, control.GetAutoSizeMode());
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(expectedLayoutCallCount, parentLayoutCallCount);
-            Assert.True(control.IsHandleCreated);
-            Assert.Equal(0, invalidatedCallCount);
-            Assert.Equal(0, styleChangedCallCount);
-            Assert.Equal(0, createdCallCount);
-            Assert.True(parent.IsHandleCreated);
-            Assert.Equal(0, parentInvalidatedCallCount);
-            Assert.Equal(0, parentStyleChangedCallCount);
-            Assert.Equal(0, parentCreatedCallCount);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoSizeMode>]
-    public void UserControl_AutoSizeMode_SetInvalid_ThrowsInvalidEnumArgumentException(AutoSizeMode value)
-    {
-        using var control = new UserControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoSizeMode = value);
-    }
-
-    public static IEnumerable<object[]> AutoValidate_Set_TestData()
-    {
-        yield return new object[] { AutoValidate.Disable, AutoValidate.Disable };
-        yield return new object[] { AutoValidate.EnablePreventFocusChange, AutoValidate.EnablePreventFocusChange };
-        yield return new object[] { AutoValidate.EnableAllowFocusChange, AutoValidate.EnableAllowFocusChange };
-        yield return new object[] { AutoValidate.Inherit, AutoValidate.EnablePreventFocusChange };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(AutoValidate_Set_TestData))]
-    public void UserControl_AutoValidate_Set_GetReturnsExpected(AutoValidate value, AutoValidate expected)
-    {
-        using var control = new UserControl
-        {
-            AutoValidate = value
-        };
-        Assert.Equal(expected, control.AutoValidate);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoValidate = value;
-        Assert.Equal(expected, control.AutoValidate);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void UserControl_AutoValidate_SetWithHandler_CallsAutoValidateChanged()
-    {
-        using var control = new UserControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoValidateChanged += handler;
-
-        // Set different.
-        control.AutoValidate = AutoValidate.EnablePreventFocusChange;
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoValidate = AutoValidate.EnablePreventFocusChange;
-        Assert.Equal(AutoValidate.EnablePreventFocusChange, control.AutoValidate);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoValidate = AutoValidate.EnableAllowFocusChange;
-        Assert.Equal(AutoValidate.EnableAllowFocusChange, control.AutoValidate);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoValidateChanged -= handler;
-        control.AutoValidate = AutoValidate.Disable;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<AutoValidate>]
-    public void UserControl_AutoValidate_SetInvalidValue_ThrowsInvalidEnumArgumentException(AutoValidate value)
-    {
-        using var control = new UserControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.AutoValidate = value);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void UserControl_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new UserControl
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 1)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 0)]
-    public void UserControl_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedInvalidatedCallCount)
-    {
-        using var control = new UserControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedInvalidatedCallCount, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void UserControl_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new UserControl();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void UserControl_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new UserControl
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void UserControl_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new UserControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new UserControl();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubUserControl();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, true)]
-    [InlineData(SubUserControl.ScrollStateAutoScrolling, false)]
-    [InlineData(SubUserControl.ScrollStateFullDrag, false)]
-    [InlineData(SubUserControl.ScrollStateHScrollVisible, false)]
-    [InlineData(SubUserControl.ScrollStateUserHasScrolled, false)]
-    [InlineData(SubUserControl.ScrollStateVScrollVisible, false)]
-    [InlineData(int.MaxValue, false)]
-    [InlineData((-1), false)]
-    public void UserControl_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
-    {
-        using var control = new SubUserControl();
-        Assert.Equal(expected, control.GetScrollState(bit));
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, true)]
-    [InlineData(ControlStyles.UserPaint, true)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, true)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, false)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void UserControl_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubUserControl();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void UserControl_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubUserControl();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsFact]
-    public void UserControl_OnCreateControl_Invoke_Nop()
-    {
-        using var control = new SubUserControl();
-        int bindingContextChangedCallCount = 0;
-        int loadChangedCallCount = 0;
-        control.BindingContextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(bindingContextChangedCallCount, loadChangedCallCount);
-            bindingContextChangedCallCount++;
-        };
-        control.Load += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(bindingContextChangedCallCount - 1, loadChangedCallCount);
-            loadChangedCallCount++;
-        };
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(1, bindingContextChangedCallCount);
-        Assert.Equal(1, loadChangedCallCount);
-
-        control.OnCreateControl();
-        Assert.False(control.Created);
-        Assert.False(control.IsHandleCreated);
-        Assert.Equal(2, bindingContextChangedCallCount);
-        Assert.Equal(2, loadChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UserControl_OnLoad_Invoke_CallsLoad(EventArgs eventArgs)
-    {
-        using var control = new SubUserControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Load += handler;
-        control.OnLoad(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Load -= handler;
-        control.OnLoad(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void UserControl_OnMouseDown_Invoke_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUserControl();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void UserControl_OnMouseDown_InvokeWithHandle_CallsMouseDown(MouseEventArgs eventArgs)
-    {
-        using var control = new SubUserControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDown += handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseDown -= handler;
-        control.OnMouseDown(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UserControl_OnResize_Invoke_CallsResize(EventArgs eventArgs)
-    {
-        using var control = new SubUserControl();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void UserControl_OnResize_InvokeWithBackgroundImage_CallsResize(EventArgs eventArgs)
-    {
-        using var backgroundImage = new Bitmap(10, 10);
-        using var control = new SubUserControl
-        {
-            BackgroundImage = backgroundImage
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnResize_WithHandle_TestData()
-    {
-        yield return new object[] { true, null, 1 };
-        yield return new object[] { true, new EventArgs(), 1 };
-        yield return new object[] { false, null, 0 };
-        yield return new object[] { false, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_WithHandle_TestData))]
-    public void UserControl_OnResize_InvokeWithHandle_CallsResize(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubUserControl();
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnResize_WithHandle_TestData))]
-    public void UserControl_OnResize_InvokeWithBackgroundImageWithHandle_CallsResize(bool resizeRedraw, EventArgs eventArgs, int expectedInvalidatedCallCount)
-    {
-        using var backgroundImage = new Bitmap(10, 10);
-        using var control = new SubUserControl
-        {
-            BackgroundImage = backgroundImage
-        };
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            layoutCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Call with handler.
-        control.Resize += handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount + 1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.Resize -= handler;
-        control.OnResize(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(2, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal((expectedInvalidatedCallCount + 1) * 2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_ValidateChildren_InvokeWithoutChildren_ReturnsTrue()
-    {
-        using var control = new UserControl();
-        Assert.True(control.ValidateChildren());
-    }
-
-    public static IEnumerable<object[]> ValidateChildren_TestData()
-    {
-        yield return new object[] { true, 0 };
-        yield return new object[] { false, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValidateChildren_TestData))]
-    public void UserControl_ValidateChildren_InvokeWithChildren_ReturnsExpected(bool cancel, int expectedCallCount)
-    {
-        using var control = new UserControl();
-        using var child1 = new Control();
-        using var grandchild1 = new Control();
-        child1.Controls.Add(grandchild1);
-        using var child2 = new UserControl();
-        using var grandchild2 = new Control();
-        child2.Controls.Add(grandchild2);
-        using var child3 = new TabControl();
-        using var grandchild3 = new TabPage();
-        child3.Controls.Add(grandchild3);
-        using var child4 = new SubControl();
-        child4.SetStyle(ControlStyles.Selectable, false);
-        using var child5 = new SubControl
-        {
-            Enabled = false
-        };
-        using var child6 = new SubControl
-        {
-            Visible = false
-        };
-        using var child7 = new SubControl
-        {
-            TabStop = false
-        };
-        using var child8 = new SubControl
-        {
-            CausesValidation = false
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-        control.Controls.Add(child5);
-        control.Controls.Add(child6);
-        control.Controls.Add(child7);
-        control.Controls.Add(child8);
-
-        int validatingCallCount = 0;
-        control.Validating += (sender, e) => validatingCallCount++;
-        int validatedCallCount = 0;
-        control.Validated += (sender, e) => validatedCallCount++;
-
-        int child1ValidatingCallCount = 0;
-        child1.Validating += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.False(e.Cancel);
-            child1ValidatingCallCount++;
-            e.Cancel = cancel;
-        };
-        int child1ValidatedCallCount = 0;
-        child1.Validated += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1ValidatedCallCount++;
-        };
-        int grandchild1ValidatingCallCount = 0;
-        grandchild1.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild1, sender);
-            Assert.False(e.Cancel);
-            grandchild1ValidatingCallCount++;
-        };
-        int grandchild1ValidatedCallCount = 0;
-        grandchild1.Validated += (sender, e) => grandchild1ValidatedCallCount++;
-        int child2ValidatingCallCount = 0;
-        child2.Validating += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.False(e.Cancel);
-            child2ValidatingCallCount++;
-        };
-        int child2ValidatedCallCount = 0;
-        child2.Validated += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2ValidatedCallCount++;
-        };
-        int grandchild2ValidatingCallCount = 0;
-        grandchild2.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.False(e.Cancel);
-            grandchild2ValidatingCallCount++;
-        };
-        int grandchild2ValidatedCallCount = 0;
-        grandchild2.Validated += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            grandchild2ValidatedCallCount++;
-        };
-        int child3ValidatingCallCount = 0;
-        child3.Validating += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.False(e.Cancel);
-            child3ValidatingCallCount++;
-        };
-        int child3ValidatedCallCount = 0;
-        child3.Validated += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child3ValidatedCallCount++;
-        };
-        int grandchild3ValidatingCallCount = 0;
-        grandchild3.Validating += (sender, e) => grandchild3ValidatingCallCount++;
-        int grandchild3ValidatedCallCount = 0;
-        grandchild3.Validated += (sender, e) => grandchild3ValidatedCallCount++;
-        int child4ValidatingCallCount = 0;
-        child4.Validating += (sender, e) => child4ValidatingCallCount++;
-        int child4ValidatedCallCount = 0;
-        child4.Validated += (sender, e) => child4ValidatedCallCount++;
-        int child5ValidatingCallCount = 0;
-        child5.Validating += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.False(e.Cancel);
-            child5ValidatingCallCount++;
-        };
-        int child5ValidatedCallCount = 0;
-        child5.Validated += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child5ValidatedCallCount++;
-        };
-        int child6ValidatingCallCount = 0;
-        child6.Validating += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.False(e.Cancel);
-            child6ValidatingCallCount++;
-        };
-        int child6ValidatedCallCount = 0;
-        child6.Validated += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child6ValidatedCallCount++;
-        };
-        int child7ValidatingCallCount = 0;
-        child7.Validating += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.False(e.Cancel);
-            child7ValidatingCallCount++;
-        };
-        int child7ValidatedCallCount = 0;
-        child7.Validated += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child7ValidatedCallCount++;
-        };
-        int child8ValidatingCallCount = 0;
-        child8.Validating += (sender, e) => child8ValidatingCallCount++;
-        int child8ValidatedCallCount = 0;
-        child8.Validated += (sender, e) => child8ValidatedCallCount++;
-
-        Assert.Equal(!cancel, control.ValidateChildren());
-        Assert.Equal(0, validatingCallCount);
-        Assert.Equal(0, validatedCallCount);
-        Assert.Equal(1, child1ValidatingCallCount);
-        Assert.Equal(expectedCallCount, child1ValidatedCallCount);
-        Assert.Equal(0, grandchild1ValidatingCallCount);
-        Assert.Equal(0, grandchild1ValidatedCallCount);
-        Assert.Equal(1, child2ValidatingCallCount);
-        Assert.Equal(1, child2ValidatedCallCount);
-        Assert.Equal(1, grandchild2ValidatingCallCount);
-        Assert.Equal(1, grandchild2ValidatedCallCount);
-        Assert.Equal(1, child3ValidatingCallCount);
-        Assert.Equal(1, child3ValidatedCallCount);
-        Assert.Equal(0, grandchild3ValidatingCallCount);
-        Assert.Equal(0, grandchild3ValidatedCallCount);
-        Assert.Equal(0, child4ValidatingCallCount);
-        Assert.Equal(0, child4ValidatedCallCount);
-        Assert.Equal(1, child5ValidatingCallCount);
-        Assert.Equal(1, child5ValidatedCallCount);
-        Assert.Equal(1, child6ValidatingCallCount);
-        Assert.Equal(1, child6ValidatedCallCount);
-        Assert.Equal(1, child7ValidatingCallCount);
-        Assert.Equal(1, child7ValidatedCallCount);
-        Assert.Equal(0, child8ValidatingCallCount);
-        Assert.Equal(0, child8ValidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ValidationConstraints>]
-    public void UserControl_ValidateChildren_InvokeValidationConstraintsWithoutChildren_ReturnsTrue(ValidationConstraints validationConstraints)
-    {
-        using var control = new UserControl();
-        Assert.True(control.ValidateChildren(validationConstraints));
-    }
-
-    public static IEnumerable<object[]> ValidateChildren_ValidationConstraints_TestData()
-    {
-        yield return new object[] { ValidationConstraints.ImmediateChildren, true, 0, 0, 0, 1, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.ImmediateChildren, false, 1, 0, 0, 1, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Selectable, true, 0, 1, 0, 0, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.Selectable, false, 1, 1, 0, 0, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Enabled, true, 0, 1, 1, 1, 0, 1, 1 };
-        yield return new object[] { ValidationConstraints.Enabled, false, 1, 1, 1, 1, 0, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.Visible, true, 0, 1, 0, 1, 1, 0, 1 };
-        yield return new object[] { ValidationConstraints.Visible, false, 1, 1, 0, 1, 1, 0, 1 };
-
-        yield return new object[] { ValidationConstraints.TabStop, true, 0, 1, 0, 1, 1, 1, 0 };
-        yield return new object[] { ValidationConstraints.TabStop, false, 1, 1, 0, 1, 1, 1, 0 };
-
-        yield return new object[] { ValidationConstraints.None, true, 0, 1, 1, 1, 1, 1, 1 };
-        yield return new object[] { ValidationConstraints.None, false, 1, 1, 1, 1, 1, 1, 1 };
-
-        yield return new object[] { ValidationConstraints.ImmediateChildren | ValidationConstraints.Selectable | ValidationConstraints.Enabled | ValidationConstraints.Visible | ValidationConstraints.TabStop, true, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { ValidationConstraints.ImmediateChildren | ValidationConstraints.Selectable | ValidationConstraints.Enabled | ValidationConstraints.Visible | ValidationConstraints.TabStop, false, 1, 0, 0, 0, 0, 0, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ValidateChildren_ValidationConstraints_TestData))]
-    public void UserControl_ValidateChildren_InvokeValidationConstraintsWithChildren_ReturnsExpected(ValidationConstraints validationConstraints, bool cancel, int expectedChild1CallCount, int expectedGrandchild2CallCount, int expectedGrandchild3CallCount, int expectedChild4CallCount, int expectedChild5CallCount, int expectedChild6CallCount, int expectedChild7CallCount)
-    {
-        using var control = new UserControl();
-        using var child1 = new Control();
-        using var grandchild1 = new Control();
-        child1.Controls.Add(grandchild1);
-        using var child2 = new UserControl();
-        using var grandchild2 = new Control();
-        child2.Controls.Add(grandchild2);
-        using var child3 = new TabControl();
-        using var grandchild3 = new TabPage();
-        child3.Controls.Add(grandchild3);
-        using var child4 = new SubControl();
-        child4.SetStyle(ControlStyles.Selectable, false);
-        using var child5 = new SubControl
-        {
-            Enabled = false
-        };
-        using var child6 = new SubControl
-        {
-            Visible = false
-        };
-        using var child7 = new SubControl
-        {
-            TabStop = false
-        };
-        using var child8 = new SubControl
-        {
-            CausesValidation = false
-        };
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.Controls.Add(child3);
-        control.Controls.Add(child4);
-        control.Controls.Add(child5);
-        control.Controls.Add(child6);
-        control.Controls.Add(child7);
-        control.Controls.Add(child8);
-
-        int validatingCallCount = 0;
-        control.Validating += (sender, e) => validatingCallCount++;
-        int validatedCallCount = 0;
-        control.Validated += (sender, e) => validatedCallCount++;
-
-        int child1ValidatingCallCount = 0;
-        child1.Validating += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.False(e.Cancel);
-            child1ValidatingCallCount++;
-            e.Cancel = cancel;
-        };
-        int child1ValidatedCallCount = 0;
-        child1.Validated += (sender, e) =>
-        {
-            Assert.Same(child1, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child1ValidatedCallCount++;
-        };
-        int grandchild1ValidatingCallCount = 0;
-        grandchild1.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild1, sender);
-            Assert.False(e.Cancel);
-            grandchild1ValidatingCallCount++;
-        };
-        int grandchild1ValidatedCallCount = 0;
-        grandchild1.Validated += (sender, e) => grandchild1ValidatedCallCount++;
-        int child2ValidatingCallCount = 0;
-        child2.Validating += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.False(e.Cancel);
-            child2ValidatingCallCount++;
-        };
-        int child2ValidatedCallCount = 0;
-        child2.Validated += (sender, e) =>
-        {
-            Assert.Same(child2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child2ValidatedCallCount++;
-        };
-        int grandchild2ValidatingCallCount = 0;
-        grandchild2.Validating += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.False(e.Cancel);
-            grandchild2ValidatingCallCount++;
-        };
-        int grandchild2ValidatedCallCount = 0;
-        grandchild2.Validated += (sender, e) =>
-        {
-            Assert.Same(grandchild2, sender);
-            Assert.Same(EventArgs.Empty, e);
-            grandchild2ValidatedCallCount++;
-        };
-        int child3ValidatingCallCount = 0;
-        child3.Validating += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.False(e.Cancel);
-            child3ValidatingCallCount++;
-        };
-        int child3ValidatedCallCount = 0;
-        child3.Validated += (sender, e) =>
-        {
-            Assert.Same(child3, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child3ValidatedCallCount++;
-        };
-        int grandchild3ValidatingCallCount = 0;
-        grandchild3.Validating += (sender, e) => grandchild3ValidatingCallCount++;
-        int grandchild3ValidatedCallCount = 0;
-        grandchild3.Validated += (sender, e) => grandchild3ValidatedCallCount++;
-        int child4ValidatingCallCount = 0;
-        child4.Validating += (sender, e) => child4ValidatingCallCount++;
-        int child4ValidatedCallCount = 0;
-        child4.Validated += (sender, e) => child4ValidatedCallCount++;
-        int child5ValidatingCallCount = 0;
-        child5.Validating += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.False(e.Cancel);
-            child5ValidatingCallCount++;
-        };
-        int child5ValidatedCallCount = 0;
-        child5.Validated += (sender, e) =>
-        {
-            Assert.Same(child5, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child5ValidatedCallCount++;
-        };
-        int child6ValidatingCallCount = 0;
-        child6.Validating += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.False(e.Cancel);
-            child6ValidatingCallCount++;
-        };
-        int child6ValidatedCallCount = 0;
-        child6.Validated += (sender, e) =>
-        {
-            Assert.Same(child6, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child6ValidatedCallCount++;
-        };
-        int child7ValidatingCallCount = 0;
-        child7.Validating += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.False(e.Cancel);
-            child7ValidatingCallCount++;
-        };
-        int child7ValidatedCallCount = 0;
-        child7.Validated += (sender, e) =>
-        {
-            Assert.Same(child7, sender);
-            Assert.Same(EventArgs.Empty, e);
-            child7ValidatedCallCount++;
-        };
-        int child8ValidatingCallCount = 0;
-        child8.Validating += (sender, e) => child8ValidatingCallCount++;
-        int child8ValidatedCallCount = 0;
-        child8.Validated += (sender, e) => child8ValidatedCallCount++;
-
-        Assert.Equal(!cancel, control.ValidateChildren(validationConstraints));
-        Assert.Equal(0, validatingCallCount);
-        Assert.Equal(0, validatedCallCount);
-        Assert.Equal(1, child1ValidatingCallCount);
-        Assert.Equal(expectedChild1CallCount, child1ValidatedCallCount);
-        Assert.Equal(0, grandchild1ValidatingCallCount);
-        Assert.Equal(0, grandchild1ValidatedCallCount);
-        Assert.Equal(1, child2ValidatingCallCount);
-        Assert.Equal(1, child2ValidatedCallCount);
-        Assert.Equal(expectedGrandchild2CallCount, grandchild2ValidatingCallCount);
-        Assert.Equal(expectedGrandchild2CallCount, grandchild2ValidatedCallCount);
-        Assert.Equal(1, child3ValidatingCallCount);
-        Assert.Equal(1, child3ValidatedCallCount);
-        Assert.Equal(expectedGrandchild3CallCount, grandchild3ValidatingCallCount);
-        Assert.Equal(expectedGrandchild3CallCount, grandchild3ValidatedCallCount);
-        Assert.Equal(expectedChild4CallCount, child4ValidatingCallCount);
-        Assert.Equal(expectedChild4CallCount, child4ValidatedCallCount);
-        Assert.Equal(expectedChild5CallCount, child5ValidatingCallCount);
-        Assert.Equal(expectedChild5CallCount, child5ValidatedCallCount);
-        Assert.Equal(expectedChild6CallCount, child6ValidatingCallCount);
-        Assert.Equal(expectedChild6CallCount, child6ValidatedCallCount);
-        Assert.Equal(expectedChild7CallCount, child7ValidatingCallCount);
-        Assert.Equal(expectedChild7CallCount, child7ValidatedCallCount);
-        Assert.Equal(0, child8ValidatingCallCount);
-        Assert.Equal(0, child8ValidatedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((ValidationConstraints)(-1))]
-    [InlineData((ValidationConstraints)(0x20))]
-    public void UserControl_ValidateChildren_InvalidValidationConstraints_ThrowsInvalidEnumArgumentException(ValidationConstraints validationConstraints)
-    {
-        using var control = new UserControl();
-        Assert.Throws<InvalidEnumArgumentException>("validationConstraints", () => control.ValidateChildren(validationConstraints));
-    }
-
-    [WinFormsFact]
-    public void UserControl_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubUserControl();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_WndProc_InvokeSetFocusWithHandle_Success()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubUserControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Same(child1, control.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void UserControl_WndProc_InvokeSetFocusWithActiveControlWithHandle_Success()
-    {
-        using var child1 = new Control();
-        using var child2 = new Control();
-        using var control = new SubUserControl();
-        control.Controls.Add(child1);
-        control.Controls.Add(child2);
-        control.ActiveControl = child2;
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_SETFOCUS,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Same(child2, control.ActiveControl);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubControl : Control
-    {
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-
-    public class SubUserControl : UserControl
-    {
-        public new const int ScrollStateAutoScrolling = UserControl.ScrollStateAutoScrolling;
-
-        public new const int ScrollStateHScrollVisible = UserControl.ScrollStateHScrollVisible;
-
-        public new const int ScrollStateVScrollVisible = UserControl.ScrollStateVScrollVisible;
-
-        public new const int ScrollStateUserHasScrolled = UserControl.ScrollStateUserHasScrolled;
-
-        public new const int ScrollStateFullDrag = UserControl.ScrollStateFullDrag;
-
-        public new SizeF AutoScaleFactor => base.AutoScaleFactor;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new bool HScroll
-        {
-            get => base.HScroll;
-            set => base.HScroll = value;
-        }
-
-        public new bool VScroll
-        {
-            get => base.VScroll;
-            set => base.VScroll = value;
-        }
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetScrollState(int bit) => base.GetScrollState(bit);
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new void OnCreateControl() => base.OnCreateControl();
-
-        public new void OnLoad(EventArgs e) => base.OnLoad(e);
-
-        public new void OnMouseDown(MouseEventArgs e) => base.OnMouseDown(e);
-
-        public new void OnResize(EventArgs e) => base.OnResize(e);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs
deleted file mode 100644
index 56bf0c50fe4..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstLineButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,343 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_ScrollBarFirstLineButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Description_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Name_ReturnNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.NotNull(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes)]
-    [InlineData(RightToLeft.No)]
-    public void VScrollBarFirstLineButtonAccessibleObject_Invoke_DecreaseValue(RightToLeft rightToLeft)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(49, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarFirstLineButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarLineButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarFirstLineButtonAccessibleObject accessibleObject = GetFirstLineButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar vScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            SmallChange = 1,
-            LargeChange = 2,
-            Size = new Size(500, 50)
-        };
-
-        if (createControl)
-        {
-            vScrollBar.CreateControl();
-        }
-
-        return vScrollBar;
-    }
-
-    private ScrollBarFirstLineButtonAccessibleObject GetFirstLineButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.FirstLineButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs
deleted file mode 100644
index 5c218065a25..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarFirstPageButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,381 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_ScrollBarFirstPageButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_State_ReturnNone_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsExpected_ButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        AccessibleObject thumb = scrollBarAccessibleObject.ThumbAccessibleObject;
-        AccessibleObject lineButton = scrollBarAccessibleObject.FirstLineButtonAccessibleObject;
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(thumb, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Equal(lineButton, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsNull_ButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsNull_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_FragmentNavigate_ReturnsNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes)]
-    [InlineData(RightToLeft.No)]
-    public void VScrollBarFirstPageButtonAccessibleObject_Invoke_DecreaseValue(RightToLeft rightToLeft)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum: 100, value: 50);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(48, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(46, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 0, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 0, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_Invoke_DoesNotWork_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarFirstPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsDisplayed_TestData))]
-    public void VScrollBarFirstLineButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarFirstPageButtonAccessibleObject accessibleObject = GetFirstPageButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar vScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            LargeChange = 2,
-            SmallChange = 1
-        };
-
-        if (createControl)
-        {
-            vScrollBar.CreateControl();
-        }
-
-        return vScrollBar;
-    }
-
-    private ScrollBarFirstPageButtonAccessibleObject GetFirstPageButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.FirstPageButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs
deleted file mode 100644
index d22ea7b7e36..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastLineButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,353 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_ScrollBarLastLineButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Role_ReturnPushButton_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleRole.PushButton, accessibleObject.Role);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Role_ReturnNone_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_LastPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_FragmentNavigate_ReturnsExpected_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes)]
-    [InlineData(RightToLeft.No)]
-    public void VScrollBarLastLineButtonAccessibleObject_Invoke_IncreaseValue(RightToLeft rightToLeft)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(51, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 99, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 99, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarLastLineButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarLinePageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastLineButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarLastLineButtonAccessibleObject accessibleObject = GetLastLineButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar vScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(500, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            vScrollBar.CreateControl();
-        }
-
-        return vScrollBar;
-    }
-
-    private ScrollBarLastLineButtonAccessibleObject GetLastLineButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.LastLineButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs
deleted file mode 100644
index 383a3786c4c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarLastPageButtonAccessibleObjectTests.cs
+++ /dev/null
@@ -1,368 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_ScrollBarLastPageButtonAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Bounds_ReturnEmptyRectangle_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(Rectangle.Empty, accessibleObject.Bounds);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_DefaultAction_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.DefaultAction);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_DefaultAction_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.DefaultAction);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Role_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-        AccessibleRole expectedRole = createControl ? AccessibleRole.PushButton : AccessibleRole.None;
-
-        Assert.Equal(expectedRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_State_ReturnNone_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(createControl, accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnExpected_LastPageButtonIsDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.ThumbAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnNull_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnNull_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes)]
-    [InlineData(RightToLeft.No)]
-    public void VScrollBarLastPageButtonAccessibleObject_Invoke_IncreaseValue(RightToLeft rightToLeft)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum: 100, value: 50);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(50, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(52, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(54, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.No, 99, 100)]
-    [InlineData(RightToLeft.No, 0, 0)]
-    [InlineData(RightToLeft.Yes, 99, 100)]
-    [InlineData(RightToLeft.Yes, 0, 0)]
-    public void VScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_OutOfRange(RightToLeft rightToLeft, int value, int maximum)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum: 0, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_IfHandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_Invoke_DoesNotWork_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.Equal(value, scrollBar.Value);
-
-        accessibleObject.Invoke();
-
-        Assert.Equal(value, scrollBar.Value);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsDisplayed_TestData))]
-    public void VScrollBarLastPageButtonAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarLastPageButtonAccessibleObject accessibleObject = GetLastPageButton(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarLastPageButtonAccessibleObject GetLastPageButton(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.LastPageButtonAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarThumbAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarThumbAccessibleObjectTests.cs
deleted file mode 100644
index 55a722c992f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.ScrollBarThumbAccessibleObjectTests.cs
+++ /dev/null
@@ -1,289 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_ScrollBarThumbAccessibleObjectTests
-{
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_GetChild_ReturnNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_GetChildCount_ReturnMinusOne(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(-1, accessibleObject.GetChildCount());
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_DefaultAction_ReturnNotNull(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(string.Empty, accessibleObject.DefaultAction);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Description_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Description);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Description_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Name_ReturnNotNull_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.NotEmpty(accessibleObject.Name);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Name_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Role_ReturnIndicator_HandleIsCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleRole.Indicator, accessibleObject.Role);
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_Role_ReturnNone_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleRole.None, accessibleObject.Role);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_State_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Equal(AccessibleStates.None, accessibleObject.State);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_InvokePattern_Supported(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False(accessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void VScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_BothPageButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstPageButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarThumbAccessibleObject_FragmentNavigate_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        var scrollBarAccessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        ScrollBarThumbAccessibleObject accessibleObject = scrollBarAccessibleObject.ThumbAccessibleObject;
-
-        Assert.Equal(scrollBarAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Equal(scrollBarAccessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Equal(scrollBarAccessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarThumbAccessibleObject_FragmentNavigate_ReturnNull_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.NextSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.PreviousSibling));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsTrue_OwnerEnabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = true;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.True((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_GetPropertyValue_IsEnabledProperty_ReturnsFalse_OwnerDisabled(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Enabled = false;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False((bool)accessibleObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_IsDisplayed_ReturnsTrue_OwnerVisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = true;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.True(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarThumbAccessibleObject_IsDisplayed_ReturnsFalse_OwnerInvisible(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        scrollBar.Visible = false;
-        ScrollBarThumbAccessibleObject accessibleObject = GetThumb(scrollBar);
-
-        Assert.False(accessibleObject.IsDisplayed);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar hScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            Size = new Size(200, 50),
-            SmallChange = 1,
-            LargeChange = 2
-        };
-
-        if (createControl)
-        {
-            hScrollBar.CreateControl();
-        }
-
-        return hScrollBar;
-    }
-
-    private ScrollBarThumbAccessibleObject GetThumb(ScrollBar scrollBar)
-    {
-        var accessibleObject = (ScrollBar.ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        return accessibleObject.ThumbAccessibleObject;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.VScrollBarAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.VScrollBarAccessibleObjectTests.cs
deleted file mode 100644
index a59d12be243..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBar.VScrollBarAccessibleObjectTests.cs
+++ /dev/null
@@ -1,279 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static System.Windows.Forms.ScrollBar;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBar_VScrollBarAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void VScrollBarAccessibleObject_ctor_ThrowsException_IfVScrollBarAccessibleObjectIsNull()
-    {
-        Assert.Throws<ArgumentNullException>(() => new ScrollBarAccessibleObject(null));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.ScrollBar)]
-    [InlineData(false, AccessibleRole.None)]
-    public void VScrollBarAccessibleObject_Ctor_Default(bool createControl, AccessibleRole accessibleRole)
-    {
-        using var scrollBar = new VScrollBar();
-
-        if (createControl)
-        {
-            scrollBar.CreateControl();
-        }
-
-        AccessibleObject accessibleObject = scrollBar.AccessibilityObject;
-
-        Assert.NotNull(accessibleObject);
-        Assert.Equal(accessibleRole, accessibleObject.Role);
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Test")]
-    public void VScrollBarAccessibleObject_Description_Get_ReturnsExpected(string accessibleDescription)
-    {
-        using var scrollBar = new VScrollBar();
-        scrollBar.AccessibleDescription = accessibleDescription;
-        ScrollBarAccessibleObject accessibleObject =
-            Assert.IsType<ScrollBarAccessibleObject>(scrollBar.AccessibilityObject);
-
-        Assert.Equal(accessibleDescription, accessibleObject.Description);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("Test")]
-    public void VScrollBarAccessibleObject_Name_Get_ReturnsExpected(string accessibleName)
-    {
-        using var scrollBar = new VScrollBar();
-        scrollBar.AccessibleName = accessibleName;
-        ScrollBarAccessibleObject accessibleObject =
-            Assert.IsType<ScrollBarAccessibleObject>(scrollBar.AccessibilityObject);
-
-        Assert.Equal(accessibleName, accessibleObject.Name);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void VScrollBarAccessibleObject_ControlType_IsScrollBar_IfAccessibleRoleIsDefault()
-    {
-        using VScrollBar scrollBar = new VScrollBar();
-        // AccessibleRole is not set = Default
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-
-        Assert.Equal(UiaCore.UIA.ScrollBarControlTypeId, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> VScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData()
-    {
-        Array roles = Enum.GetValues(typeof(AccessibleRole));
-
-        foreach (AccessibleRole role in roles)
-        {
-            if (role == AccessibleRole.Default)
-            {
-                continue; // The test checks custom roles
-            }
-
-            yield return new object[] { role };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(VScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole_TestData))]
-    public void VScrollBarAccessibleObject_GetPropertyValue_ControlType_IsExpected_ForCustomRole(AccessibleRole role)
-    {
-        using VScrollBar scrollBar = new VScrollBar();
-        scrollBar.AccessibleRole = role;
-
-        object actual = scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);
-        UiaCore.UIA expected = AccessibleRoleControlTypeMap.GetControlType(role);
-
-        Assert.Equal(expected, actual);
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_TestData))]
-    public void VScrollBarAccessibleObject_FragmentNavigate_Child_ReturnExpected(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl, rightToLeft, minimum, maximum, value);
-        var accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.FirstChild));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.LastChild));
-        Assert.Equal(createControl, scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void VScrollBarAccessibleObject_GetChildCount_ReturnsFive_AllButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(5, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarAccessibleObject_GetChildCount_ReturnsFour_FirstPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarAccessibleObject_GetChildCount_ReturnsFour_LastPageButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(4, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarAccessibleObject_GetChildCount_ReturnsThree_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-
-        Assert.Equal(3, accessibleObject.GetChildCount());
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_BothButtonAreDisplayed_TestData))]
-    public void VScrollBarAccessibleObject_GetChild_ReturnExpected_AllButtonsAreDisplayed(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.FirstPageButtonAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastPageButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_FirstPageButtonIsHidden_TestData))]
-    public void VScrollBarAccessibleObject_GetChild_ReturnExpected_FirstButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.LastPageButtonAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.VScrollBarAccessibleObject_LastPageButtonIsHidden_TestData))]
-    public void VScrollBarAccessibleObject_GetChild_ReturnExpected_LastButtonIsHidden(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.FirstPageButtonAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_MinimumEqualsMaximum_TestData))]
-    public void VScrollBarAccessibleObject_GetChild_ReturnExpected_MinimumEqualsMaximum(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: true, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Equal(accessibleObject.FirstLineButtonAccessibleObject, accessibleObject.GetChild(0));
-        Assert.Equal(accessibleObject.ThumbAccessibleObject, accessibleObject.GetChild(1));
-        Assert.Equal(accessibleObject.LastLineButtonAccessibleObject, accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.True(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(ScrollBarTestHelper), nameof(ScrollBarTestHelper.ScrollBarAccessibleObject_WithoutCreateControl_TestData))]
-    public void VScrollBarAccessibleObject_GetChild_ReturnExpected_HandleIsNotCreated(RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        using VScrollBar scrollBar = GetVScrollBar(createControl: false, rightToLeft, minimum, maximum, value);
-        ScrollBarAccessibleObject accessibleObject = (ScrollBarAccessibleObject)scrollBar.AccessibilityObject;
-        Assert.Null(accessibleObject.GetChild(-1));
-        Assert.Null(accessibleObject.GetChild(0));
-        Assert.Null(accessibleObject.GetChild(1));
-        Assert.Null(accessibleObject.GetChild(2));
-        Assert.Null(accessibleObject.GetChild(3));
-        Assert.Null(accessibleObject.GetChild(4));
-        Assert.Null(accessibleObject.GetChild(5));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void VScrollBarAccessibilityObject_GetPropertyValue_IsEnabledProperty_ReturnsExpected(bool enabled)
-    {
-        using VScrollBar scrollBar = new()
-        {
-            Enabled = enabled
-        };
-
-        Assert.Equal(enabled, scrollBar.AccessibilityObject.GetPropertyValue(UiaCore.UIA.IsEnabledPropertyId));
-        Assert.False(scrollBar.IsHandleCreated);
-    }
-
-    private VScrollBar GetVScrollBar(bool createControl, RightToLeft rightToLeft, int minimum, int maximum, int value)
-    {
-        VScrollBar vScrollBar = new()
-        {
-            RightToLeft = rightToLeft,
-            Value = value,
-            Minimum = minimum,
-            Maximum = maximum,
-            SmallChange = 1,
-            LargeChange = 2,
-            Size = new Size(500, 50)
-        };
-
-        if (createControl)
-        {
-            vScrollBar.CreateControl();
-        }
-
-        return vScrollBar;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBarTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBarTests.cs
deleted file mode 100644
index e5adcb76083..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollBarTests.cs
+++ /dev/null
@@ -1,294 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class VScrollBarTests
-{
-    [WinFormsFact]
-    public void VScrollBar_Ctor_Default()
-    {
-        using var control = new SubVScrollBar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(0, control.Bounds.X);
-        Assert.Equal(0, control.Bounds.Y);
-        Assert.True(control.Bounds.Width > 0);
-        Assert.True(control.Bounds.Height > 0);
-        Assert.True(control.Bottom > 0);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(0, control.ClientRectangle.X);
-        Assert.Equal(0, control.ClientRectangle.Y);
-        Assert.True(control.ClientRectangle.Width > 0);
-        Assert.True(control.ClientRectangle.Height > 0);
-        Assert.True(control.ClientSize.Width > 0);
-        Assert.True(control.ClientSize.Height > 0);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, control.DefaultImeMode);
-        Assert.Equal(Padding.Empty, control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.True(control.DefaultSize.Width > 0);
-        Assert.True(control.DefaultSize.Height > 0);
-        Assert.False(control.DesignMode);
-        Assert.Equal(0, control.DisplayRectangle.X);
-        Assert.Equal(0, control.DisplayRectangle.Y);
-        Assert.True(control.DisplayRectangle.Width > 0);
-        Assert.True(control.DisplayRectangle.Height > 0);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.True(control.Height > 0);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(10, control.LargeChange);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(Padding.Empty, control.Margin);
-        Assert.Equal(100, control.Maximum);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.True(control.PreferredSize.Width > 0);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.True(control.Right > 0);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.True(control.ScaleScrollBarForDpiChange);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.True(control.Size.Width > 0);
-        Assert.True(control.Size.Height > 0);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, control.TabIndex);
-        Assert.False(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.Visible);
-        Assert.True(control.Width > 0);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void VScrollBar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubVScrollBar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("ScrollBar", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.True(createParams.Height > 0);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56000001, createParams.Style);
-        Assert.True(createParams.Width > 0);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<RightToLeft>]
-    [InvalidEnumData<RightToLeft>]
-    public void VScrollBar_RightToLeft_Set_GetReturnsNo(RightToLeft value)
-    {
-        using var control = new SubVScrollBar
-        {
-            RightToLeft = value
-        };
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-
-        // Set same.
-        control.RightToLeft = value;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-    }
-
-    [WinFormsFact]
-    public void VScrollBar_RightToLeft_SetWithHandler_DoesNotCallRightToLeftChanged()
-    {
-        using var control = new SubVScrollBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftChanged += handler;
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.RightToLeft = RightToLeft.Inherit;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.RightToLeftChanged -= handler;
-        control.RightToLeft = RightToLeft.Yes;
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void VScrollBar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubVScrollBar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void VScrollBar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubVScrollBar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void VScrollBar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubVScrollBar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    private class SubVScrollBar : VScrollBar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollPropertiesTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollPropertiesTests.cs
deleted file mode 100644
index bf40f9d1990..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VScrollPropertiesTests.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class VScrollPropertiesTests
-{
-    public static IEnumerable<object[]> Ctor_ScrollableControl_TestData()
-    {
-        yield return new object[] { new ScrollableControl() };
-        yield return new object[] { null };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_ScrollableControl_TestData))]
-    public void VScrollProperties_Ctor_Control(ScrollableControl container)
-    {
-        var properties = new SubVScrollProperties(container);
-        Assert.Equal(container, properties.ParentControlEntry);
-        Assert.True(properties.Enabled);
-        Assert.Equal(10, properties.LargeChange);
-        Assert.Equal(1, properties.SmallChange);
-        Assert.Equal(100, properties.Maximum);
-        Assert.Equal(0, properties.Minimum);
-        Assert.Equal(0, properties.Value);
-        Assert.False(properties.Visible);
-    }
-
-    private class SubVScrollProperties : VScrollProperties
-    {
-        public SubVScrollProperties(ScrollableControl container) : base(container)
-        {
-        }
-
-        public ScrollableControl ParentControlEntry => ParentControl;
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/TextMetricsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/TextMetricsTests.cs
deleted file mode 100644
index fd4774f3fe6..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/TextMetricsTests.cs
+++ /dev/null
@@ -1,337 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Windows.Forms.TestUtilities;
-
-namespace System.Windows.Forms.VisualStyles.Tests;
-
-// NB: doesn't require thread affinity
-public class TextMetricsTests
-{
-    [Fact]
-    public void TextMetrics_Ctor_Default()
-    {
-        var metric = new TextMetrics();
-        Assert.Equal(0, metric.Ascent);
-        Assert.Equal(0, metric.AverageCharWidth);
-        Assert.Equal('\0', metric.BreakChar);
-        Assert.Equal(TextMetricsCharacterSet.Ansi, metric.CharSet);
-        Assert.Equal('\0', metric.DefaultChar);
-        Assert.Equal(0, metric.Descent);
-        Assert.Equal(0, metric.DigitizedAspectX);
-        Assert.Equal(0, metric.DigitizedAspectY);
-        Assert.Equal(0, metric.ExternalLeading);
-        Assert.Equal('\0', metric.FirstChar);
-        Assert.Equal(0, metric.Height);
-        Assert.Equal(0, metric.InternalLeading);
-        Assert.False(metric.Italic);
-        Assert.Equal(0, metric.MaxCharWidth);
-        Assert.Equal(0, metric.Overhang);
-        Assert.Equal((TextMetricsPitchAndFamilyValues)0, metric.PitchAndFamily);
-        Assert.False(metric.StruckOut);
-        Assert.False(metric.Underlined);
-        Assert.Equal(0, metric.Weight);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_Ascent_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            Ascent = value
-        };
-        Assert.Equal(value, metric.Ascent);
-
-        // Set same.
-        metric.Ascent = value;
-        Assert.Equal(value, metric.Ascent);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_AverageCharWidth_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            AverageCharWidth = value
-        };
-        Assert.Equal(value, metric.AverageCharWidth);
-
-        // Set same.
-        metric.AverageCharWidth = value;
-        Assert.Equal(value, metric.AverageCharWidth);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCharTheoryData))]
-    public void TextMetrics_BreakChar_Set_GetReturnsExpected(char value)
-    {
-        var metric = new TextMetrics
-        {
-            BreakChar = value
-        };
-        Assert.Equal(value, metric.BreakChar);
-
-        // Set same.
-        metric.BreakChar = value;
-        Assert.Equal(value, metric.BreakChar);
-    }
-
-    [Theory]
-    [EnumData<TextMetricsCharacterSet>]
-    [InvalidEnumData<TextMetricsCharacterSet>]
-    public void TextMetrics_CharSet_Set_GetReturnsExpected(TextMetricsCharacterSet value)
-    {
-        var metric = new TextMetrics
-        {
-            CharSet = value
-        };
-        Assert.Equal(value, metric.CharSet);
-
-        // Set same.
-        metric.CharSet = value;
-        Assert.Equal(value, metric.CharSet);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCharTheoryData))]
-    public void TextMetrics_DefaultChar_Set_GetReturnsExpected(char value)
-    {
-        var metric = new TextMetrics
-        {
-            DefaultChar = value
-        };
-        Assert.Equal(value, metric.DefaultChar);
-
-        // Set same.
-        metric.DefaultChar = value;
-        Assert.Equal(value, metric.DefaultChar);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_Descent_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            Descent = value
-        };
-        Assert.Equal(value, metric.Descent);
-
-        // Set same.
-        metric.Descent = value;
-        Assert.Equal(value, metric.Descent);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_DigitizedAspectX_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            DigitizedAspectX = value
-        };
-        Assert.Equal(value, metric.DigitizedAspectX);
-
-        // Set same.
-        metric.DigitizedAspectX = value;
-        Assert.Equal(value, metric.DigitizedAspectX);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_DigitizedAspectY_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            DigitizedAspectY = value
-        };
-        Assert.Equal(value, metric.DigitizedAspectY);
-
-        // Set same.
-        metric.DigitizedAspectY = value;
-        Assert.Equal(value, metric.DigitizedAspectY);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_ExternalLeading_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            ExternalLeading = value
-        };
-        Assert.Equal(value, metric.ExternalLeading);
-
-        // Set same.
-        metric.ExternalLeading = value;
-        Assert.Equal(value, metric.ExternalLeading);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCharTheoryData))]
-    public void TextMetrics_FirstChar_Set_GetReturnsExpected(char value)
-    {
-        var metric = new TextMetrics
-        {
-            FirstChar = value
-        };
-        Assert.Equal(value, metric.FirstChar);
-
-        // Set same.
-        metric.FirstChar = value;
-        Assert.Equal(value, metric.FirstChar);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_Height_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            Height = value
-        };
-        Assert.Equal(value, metric.Height);
-
-        // Set same.
-        metric.Height = value;
-        Assert.Equal(value, metric.Height);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_InternalLeading_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            InternalLeading = value
-        };
-        Assert.Equal(value, metric.InternalLeading);
-
-        // Set same.
-        metric.InternalLeading = value;
-        Assert.Equal(value, metric.InternalLeading);
-    }
-
-    [Theory]
-    [BoolData]
-    public void TextMetrics_Italic_Set_GetReturnsExpected(bool value)
-    {
-        var metric = new TextMetrics
-        {
-            Italic = value
-        };
-        Assert.Equal(value, metric.Italic);
-
-        // Set same.
-        metric.Italic = value;
-        Assert.Equal(value, metric.Italic);
-    }
-
-    [Theory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCharTheoryData))]
-    public void TextMetrics_LastChar_Set_GetReturnsExpected(char value)
-    {
-        var metric = new TextMetrics
-        {
-            LastChar = value
-        };
-        Assert.Equal(value, metric.LastChar);
-
-        // Set same.
-        metric.LastChar = value;
-        Assert.Equal(value, metric.LastChar);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_MaxCharWidth_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            MaxCharWidth = value
-        };
-        Assert.Equal(value, metric.MaxCharWidth);
-
-        // Set same.
-        metric.MaxCharWidth = value;
-        Assert.Equal(value, metric.MaxCharWidth);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_Overhang_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            Overhang = value
-        };
-        Assert.Equal(value, metric.Overhang);
-
-        // Set same.
-        metric.Overhang = value;
-        Assert.Equal(value, metric.Overhang);
-    }
-
-    [Theory]
-    [EnumData<TextMetricsPitchAndFamilyValues>]
-    [InvalidEnumData<TextMetricsPitchAndFamilyValues>]
-    public void TextMetrics_PitchAndFamily_GetReturnsExpected(TextMetricsPitchAndFamilyValues value)
-    {
-        var metric = new TextMetrics
-        {
-            PitchAndFamily = value
-        };
-        Assert.Equal(value, metric.PitchAndFamily);
-
-        // Set same.
-        metric.PitchAndFamily = value;
-        Assert.Equal(value, metric.PitchAndFamily);
-    }
-
-    [Theory]
-    [BoolData]
-    public void TextMetrics_StruckOut_Set_GetReturnsExpected(bool value)
-    {
-        var metric = new TextMetrics
-        {
-            StruckOut = value
-        };
-        Assert.Equal(value, metric.StruckOut);
-
-        // Set same.
-        metric.StruckOut = value;
-        Assert.Equal(value, metric.StruckOut);
-    }
-
-    [Theory]
-    [BoolData]
-    public void TextMetrics_Underlined_Set_GetReturnsExpected(bool value)
-    {
-        var metric = new TextMetrics
-        {
-            Underlined = value
-        };
-        Assert.Equal(value, metric.Underlined);
-
-        // Set same.
-        metric.Underlined = value;
-        Assert.Equal(value, metric.Underlined);
-    }
-
-    [Theory]
-    [IntegerData<int>]
-    public void TextMetrics_Weight_Set_GetReturnsExpected(int value)
-    {
-        var metric = new TextMetrics
-        {
-            Weight = value
-        };
-        Assert.Equal(value, metric.Weight);
-
-        // Set same.
-        metric.Weight = value;
-        Assert.Equal(value, metric.Weight);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleElementTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleElementTests.cs
deleted file mode 100644
index 0bbec950b81..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleElementTests.cs
+++ /dev/null
@@ -1,658 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.VisualStyles.Tests;
-
-// NB: doesn't require thread affinity
-public class VisualStyleElementTests
-{
-    public static IEnumerable<object[]> CreateElement_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 0 };
-        yield return new object[] { "className", -1, -2 };
-    }
-
-    [Theory]
-    [MemberData(nameof(CreateElement_TestData))]
-    public void VisualStyleElement_CreateElement_Invoke_ReturnsExpected(string className, int part, int state)
-    {
-        VisualStyleElement element = VisualStyleElement.CreateElement(className, part, state);
-        Assert.Same(className, element.ClassName);
-        Assert.Equal(part, element.Part);
-        Assert.Equal(state, element.State);
-    }
-
-    [WinFormsFact]
-    public void VisualStyleElement_CreateElement_NullClassName_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("className", () => VisualStyleElement.CreateElement(null, 1, 2));
-    }
-
-    public static IEnumerable<object[]> KnownElements_TestData()
-    {
-        // Identity function to avoid constant casting
-        static Func<VisualStyleElement> I(Func<VisualStyleElement> factory) => factory;
-
-        yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Normal), "BUTTON", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Hot), "BUTTON", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Pressed), "BUTTON", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Disabled), "BUTTON", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.Button.PushButton.Default), "BUTTON", 1, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedNormal), "BUTTON", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedHot), "BUTTON", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedPressed), "BUTTON", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.UncheckedDisabled), "BUTTON", 2, 4 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedNormal), "BUTTON", 2, 5 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedHot), "BUTTON", 2, 6 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedPressed), "BUTTON", 2, 7 };
-        yield return new object[] { I(() => VisualStyleElement.Button.RadioButton.CheckedDisabled), "BUTTON", 2, 8 };
-
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedNormal), "BUTTON", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedHot), "BUTTON", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedPressed), "BUTTON", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.UncheckedDisabled), "BUTTON", 3, 4 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedNormal), "BUTTON", 3, 5 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedHot), "BUTTON", 3, 6 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedPressed), "BUTTON", 3, 7 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.CheckedDisabled), "BUTTON", 3, 8 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedNormal), "BUTTON", 3, 9 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedHot), "BUTTON", 3, 10 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedPressed), "BUTTON", 3, 11 };
-        yield return new object[] { I(() => VisualStyleElement.Button.CheckBox.MixedDisabled), "BUTTON", 3, 12 };
-
-        yield return new object[] { I(() => VisualStyleElement.Button.GroupBox.Normal), "BUTTON", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Button.GroupBox.Disabled), "BUTTON", 4, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Button.UserButton.Normal), "BUTTON", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Normal), "COMBOBOX", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Hot), "COMBOBOX", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Pressed), "COMBOBOX", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButton.Disabled), "COMBOBOX", 1, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.Border.Normal), "COMBOBOX", 4, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.ReadOnlyButton.Normal), "COMBOBOX", 5, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButtonRight.Normal), "COMBOBOX", 6, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.ComboBox.DropDownButtonLeft.Normal), "COMBOBOX", 7, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Page.Up.Normal), "PAGE", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Up.Hot), "PAGE", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Up.Pressed), "PAGE", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Up.Disabled), "PAGE", 1, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Page.Down.Normal), "PAGE", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Down.Hot), "PAGE", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Down.Pressed), "PAGE", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Page.Down.Disabled), "PAGE", 2, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Normal), "PAGE", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Hot), "PAGE", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Pressed), "PAGE", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Page.UpHorizontal.Disabled), "PAGE", 3, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Normal), "PAGE", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Hot), "PAGE", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Pressed), "PAGE", 4, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Page.DownHorizontal.Disabled), "PAGE", 4, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Spin.Up.Normal), "SPIN", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Up.Hot), "SPIN", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Up.Pressed), "SPIN", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Up.Disabled), "SPIN", 1, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Spin.Down.Normal), "SPIN", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Down.Hot), "SPIN", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Down.Pressed), "SPIN", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.Down.Disabled), "SPIN", 2, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Normal), "SPIN", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Hot), "SPIN", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Pressed), "SPIN", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.UpHorizontal.Disabled), "SPIN", 3, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Normal), "SPIN", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Hot), "SPIN", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Pressed), "SPIN", 4, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Spin.DownHorizontal.Disabled), "SPIN", 4, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpNormal), "SCROLLBAR", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpHot), "SCROLLBAR", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpPressed), "SCROLLBAR", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.UpDisabled), "SCROLLBAR", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownNormal), "SCROLLBAR", 1, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownHot), "SCROLLBAR", 1, 6 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownPressed), "SCROLLBAR", 1, 7 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.DownDisabled), "SCROLLBAR", 1, 8 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftNormal), "SCROLLBAR", 1, 9 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftHot), "SCROLLBAR", 1, 10 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftPressed), "SCROLLBAR", 1, 11 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.LeftDisabled), "SCROLLBAR", 1, 12 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightNormal), "SCROLLBAR", 1, 13 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightHot), "SCROLLBAR", 1, 14 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightPressed), "SCROLLBAR", 1, 15 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ArrowButton.RightDisabled), "SCROLLBAR", 1, 16 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Normal), "SCROLLBAR", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Hot), "SCROLLBAR", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Pressed), "SCROLLBAR", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Disabled), "SCROLLBAR", 2, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Normal), "SCROLLBAR", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Hot), "SCROLLBAR", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Pressed), "SCROLLBAR", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.ThumbButtonVertical.Disabled), "SCROLLBAR", 3, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Normal), "SCROLLBAR", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Hot), "SCROLLBAR", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Pressed), "SCROLLBAR", 4, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.RightTrackHorizontal.Disabled), "SCROLLBAR", 4, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Normal), "SCROLLBAR", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Hot), "SCROLLBAR", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Pressed), "SCROLLBAR", 5, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LeftTrackHorizontal.Disabled), "SCROLLBAR", 5, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Normal), "SCROLLBAR", 6, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Hot), "SCROLLBAR", 6, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Pressed), "SCROLLBAR", 6, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled), "SCROLLBAR", 6, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Normal), "SCROLLBAR", 7, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Hot), "SCROLLBAR", 7, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Pressed), "SCROLLBAR", 7, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.UpperTrackVertical.Disabled), "SCROLLBAR", 7, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.GripperHorizontal.Normal), "SCROLLBAR", 8, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.GripperVertical.Normal), "SCROLLBAR", 9, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.SizeBox.RightAlign), "SCROLLBAR", 10, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ScrollBar.SizeBox.LeftAlign), "SCROLLBAR", 10, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Normal), "TAB", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Hot), "TAB", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Pressed), "TAB", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItem.Disabled), "TAB", 1, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Normal), "TAB", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Hot), "TAB", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Pressed), "TAB", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemLeftEdge.Disabled), "TAB", 2, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Normal), "TAB", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Hot), "TAB", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Pressed), "TAB", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemRightEdge.Disabled), "TAB", 3, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TabItemBothEdges.Normal), "TAB", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Normal), "TAB", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Hot), "TAB", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Pressed), "TAB", 5, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItem.Disabled), "TAB", 5, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Normal), "TAB", 6, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Hot), "TAB", 6, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Pressed), "TAB", 6, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemLeftEdge.Disabled), "TAB", 6, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Normal), "TAB", 7, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Hot), "TAB", 7, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Pressed), "TAB", 7, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemRightEdge.Disabled), "TAB", 7, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.TopTabItemBothEdges.Normal), "TAB", 8, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.Pane.Normal), "TAB", 9, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Tab.Body.Normal), "TAB", 10, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderBackground.Normal), "EXPLORERBAR", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Normal), "EXPLORERBAR", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Hot), "EXPLORERBAR", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderClose.Pressed), "EXPLORERBAR", 2, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Normal), "EXPLORERBAR", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Hot), "EXPLORERBAR", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.Pressed), "EXPLORERBAR", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedNormal), "EXPLORERBAR", 3, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedHot), "EXPLORERBAR", 3, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.HeaderPin.SelectedPressed), "EXPLORERBAR", 3, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Normal), "EXPLORERBAR", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Hot), "EXPLORERBAR", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.IEBarMenu.Pressed), "EXPLORERBAR", 4, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupBackground.Normal), "EXPLORERBAR", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Normal), "EXPLORERBAR", 6, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Hot), "EXPLORERBAR", 6, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupCollapse.Pressed), "EXPLORERBAR", 6, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Normal), "EXPLORERBAR", 7, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Hot), "EXPLORERBAR", 7, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupExpand.Pressed), "EXPLORERBAR", 7, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.NormalGroupHead.Normal), "EXPLORERBAR", 8, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupBackground.Normal), "EXPLORERBAR", 9, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Normal), "EXPLORERBAR", 10, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Hot), "EXPLORERBAR", 10, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupCollapse.Pressed), "EXPLORERBAR", 10, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Normal), "EXPLORERBAR", 11, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Hot), "EXPLORERBAR", 11, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupExpand.Pressed), "EXPLORERBAR", 11, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerBar.SpecialGroupHead.Normal), "EXPLORERBAR", 12, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Header.Item.Normal), "HEADER", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Header.Item.Hot), "HEADER", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Header.Item.Pressed), "HEADER", 1, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Normal), "HEADER", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Hot), "HEADER", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemLeft.Pressed), "HEADER", 2, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Normal), "HEADER", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Hot), "HEADER", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Header.ItemRight.Pressed), "HEADER", 3, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Header.SortArrow.SortedUp), "HEADER", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Header.SortArrow.SortedDown), "HEADER", 4, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.ListView.Item.Normal), "LISTVIEW", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ListView.Item.Hot), "LISTVIEW", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ListView.Item.Selected), "LISTVIEW", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ListView.Item.Disabled), "LISTVIEW", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ListView.Item.SelectedNotFocus), "LISTVIEW", 1, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.ListView.Group.Normal), "LISTVIEW", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ListView.Detail.Normal), "LISTVIEW", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ListView.SortedDetail.Normal), "LISTVIEW", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ListView.EmptyText.Normal), "LISTVIEW", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Normal), "MENUBAND", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Hot), "MENUBAND", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Pressed), "MENUBAND", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Disabled), "MENUBAND", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.Checked), "MENUBAND", 1, 5 };
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.NewApplicationButton.HotChecked), "MENUBAND", 1, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.MenuBand.Separator.Normal), "MENUBAND", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.Item.Normal), "MENU", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Menu.Item.Selected), "MENU", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Menu.Item.Demoted), "MENU", 1, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.DropDown.Normal), "MENU", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.BarItem.Normal), "MENU", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.BarDropDown.Normal), "MENU", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.Chevron.Normal), "MENU", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Menu.Separator.Normal), "MENU", 6, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ProgressBar.Bar.Normal), "PROGRESS", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ProgressBar.BarVertical.Normal), "PROGRESS", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ProgressBar.Chunk.Normal), "PROGRESS", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ProgressBar.ChunkVertical.Normal), "PROGRESS", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Rebar.Gripper.Normal), "REBAR", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Rebar.GripperVertical.Normal), "REBAR", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Rebar.Band.Normal), "REBAR", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Normal), "REBAR", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Hot), "REBAR", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Rebar.Chevron.Pressed), "REBAR", 4, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Normal), "REBAR", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Hot), "REBAR", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Rebar.ChevronVertical.Pressed), "REBAR", 5, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.UserPane.Normal), "STARTPANEL", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.MorePrograms.Normal), "STARTPANEL", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Normal), "STARTPANEL", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Hot), "STARTPANEL", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.MoreProgramsArrow.Pressed), "STARTPANEL", 3, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.ProgList.Normal), "STARTPANEL", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.ProgListSeparator.Normal), "STARTPANEL", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.PlaceList.Normal), "STARTPANEL", 6, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.PlaceListSeparator.Normal), "STARTPANEL", 7, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOff.Normal), "STARTPANEL", 8, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Normal), "STARTPANEL", 9, 1 };
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Hot), "STARTPANEL", 9, 2 };
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.LogOffButtons.Pressed), "STARTPANEL", 9, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.UserPicture.Normal), "STARTPANEL", 10, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.StartPanel.Preview.Normal), "STARTPANEL", 11, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Status.Bar.Normal), "STATUS", 0, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Status.Pane.Normal), "STATUS", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Status.GripperPane.Normal), "STATUS", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Status.Gripper.Normal), "STATUS", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TaskBand.GroupCount.Normal), "TASKBAND", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TaskBand.FlashButton.Normal), "TASKBAND", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TaskBand.FlashButtonGroupMenu.Normal), "TASKBAND", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TaskbarClock.Time.Normal), "CLOCK", 1, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundBottom.Normal), "TASKBAR", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundRight.Normal), "TASKBAR", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundTop.Normal), "TASKBAR", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.BackgroundLeft.Normal), "TASKBAR", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarBottom.Normal), "TASKBAR", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarRight.Normal), "TASKBAR", 6, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarTop.Normal), "TASKBAR", 7, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Taskbar.SizingBarLeft.Normal), "TASKBAR", 8, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Bar.Normal), "TOOLBAR", 0, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Normal), "TOOLBAR", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Hot), "TOOLBAR", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Pressed), "TOOLBAR", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Disabled), "TOOLBAR", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.Checked), "TOOLBAR", 1, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.Button.HotChecked), "TOOLBAR", 1, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Normal), "TOOLBAR", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Hot), "TOOLBAR", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Pressed), "TOOLBAR", 2, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Disabled), "TOOLBAR", 2, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.Checked), "TOOLBAR", 2, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.DropDownButton.HotChecked), "TOOLBAR", 2, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Normal), "TOOLBAR", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Hot), "TOOLBAR", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Pressed), "TOOLBAR", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Disabled), "TOOLBAR", 3, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.Checked), "TOOLBAR", 3, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButton.HotChecked), "TOOLBAR", 3, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Normal), "TOOLBAR", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Hot), "TOOLBAR", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Pressed), "TOOLBAR", 4, 3 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Disabled), "TOOLBAR", 4, 4 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.Checked), "TOOLBAR", 4, 5 };
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SplitButtonDropDown.HotChecked), "TOOLBAR", 4, 6 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SeparatorHorizontal.Normal), "TOOLBAR", 5, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolBar.SeparatorVertical.Normal), "TOOLBAR", 6, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Standard.Normal), "TOOLTIP", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Standard.Link), "TOOLTIP", 1, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.StandardTitle.Normal), "TOOLTIP", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Balloon.Normal), "TOOLTIP", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Balloon.Link), "TOOLTIP", 3, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.BalloonTitle.Normal), "TOOLTIP", 4, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Normal), "TOOLTIP", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Hot), "TOOLTIP", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.ToolTip.Close.Pressed), "TOOLTIP", 5, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Track.Normal), "TRACKBAR", 1, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.TrackVertical.Normal), "TRACKBAR", 2, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Normal), "TRACKBAR", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Hot), "TRACKBAR", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Pressed), "TRACKBAR", 3, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Focused), "TRACKBAR", 3, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Thumb.Disabled), "TRACKBAR", 3, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Normal), "TRACKBAR", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Hot), "TRACKBAR", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Pressed), "TRACKBAR", 4, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Focused), "TRACKBAR", 4, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbBottom.Disabled), "TRACKBAR", 4, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Normal), "TRACKBAR", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Hot), "TRACKBAR", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Pressed), "TRACKBAR", 5, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Focused), "TRACKBAR", 5, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbTop.Disabled), "TRACKBAR", 5, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Normal), "TRACKBAR", 6, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Hot), "TRACKBAR", 6, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Pressed), "TRACKBAR", 6, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Focused), "TRACKBAR", 6, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbVertical.Disabled), "TRACKBAR", 6, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Normal), "TRACKBAR", 7, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Hot), "TRACKBAR", 7, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Pressed), "TRACKBAR", 7, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Focused), "TRACKBAR", 7, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbLeft.Disabled), "TRACKBAR", 7, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Normal), "TRACKBAR", 8, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Hot), "TRACKBAR", 8, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Pressed), "TRACKBAR", 8, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Focused), "TRACKBAR", 8, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.ThumbRight.Disabled), "TRACKBAR", 8, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.Ticks.Normal), "TRACKBAR", 9, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrackBar.TicksVertical.Normal), "TRACKBAR", 10, 1 };
-
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Normal), "TREEVIEW", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Hot), "TREEVIEW", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Selected), "TREEVIEW", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Item.Disabled), "TREEVIEW", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Item.SelectedNotFocus), "TREEVIEW", 1, 5 };
-
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Glyph.Closed), "TREEVIEW", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Glyph.Opened), "TREEVIEW", 2, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.TreeView.Branch.Normal), "TREEVIEW", 3, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.ExplorerTreeView.Glyph.Closed), "Explorer::TreeView", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.ExplorerTreeView.Glyph.Opened), "Explorer::TreeView", 2, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Normal), "EDIT", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Hot), "EDIT", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Selected), "EDIT", 1, 3 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Disabled), "EDIT", 1, 4 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Focused), "EDIT", 1, 5 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.ReadOnly), "EDIT", 1, 6 };
-        yield return new object[] { I(() => VisualStyleElement.TextBox.TextEdit.Assist), "EDIT", 1, 7 };
-
-        yield return new object[] { I(() => VisualStyleElement.TextBox.Caret.Normal), "EDIT", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrayNotify.Background.Normal), "TRAYNOTIFY", 1, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.TrayNotify.AnimateBackground.Normal), "TRAYNOTIFY", 2, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.Caption.Active), "WINDOW", 1, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.Caption.Inactive), "WINDOW", 1, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.Caption.Disabled), "WINDOW", 1, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Active), "WINDOW", 2, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Inactive), "WINDOW", 2, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCaption.Disabled), "WINDOW", 2, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Active), "WINDOW", 3, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Inactive), "WINDOW", 3, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MinCaption.Disabled), "WINDOW", 3, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Active), "WINDOW", 4, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Inactive), "WINDOW", 4, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMinCaption.Disabled), "WINDOW", 4, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Active), "WINDOW", 5, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Inactive), "WINDOW", 5, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxCaption.Disabled), "WINDOW", 5, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Active), "WINDOW", 6, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Inactive), "WINDOW", 6, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallMaxCaption.Disabled), "WINDOW", 6, 3 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameLeft.Active), "WINDOW", 7, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameLeft.Inactive), "WINDOW", 7, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameRight.Active), "WINDOW", 8, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameRight.Inactive), "WINDOW", 8, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameBottom.Active), "WINDOW", 9, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameBottom.Inactive), "WINDOW", 9, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeft.Active), "WINDOW", 10, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeft.Inactive), "WINDOW", 10, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRight.Active), "WINDOW", 11, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRight.Inactive), "WINDOW", 11, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottom.Active), "WINDOW", 12, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottom.Inactive), "WINDOW", 12, 2 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Normal), "WINDOW", 13, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Hot), "WINDOW", 13, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Pressed), "WINDOW", 13, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SysButton.Disabled), "WINDOW", 13, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Normal), "WINDOW", 14, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Hot), "WINDOW", 14, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Pressed), "WINDOW", 14, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiSysButton.Disabled), "WINDOW", 14, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Normal), "WINDOW", 15, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Hot), "WINDOW", 15, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Pressed), "WINDOW", 15, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MinButton.Disabled), "WINDOW", 15, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Normal), "WINDOW", 16, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Hot), "WINDOW", 16, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Pressed), "WINDOW", 16, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiMinButton.Disabled), "WINDOW", 16, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Normal), "WINDOW", 17, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Hot), "WINDOW", 17, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Pressed), "WINDOW", 17, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MaxButton.Disabled), "WINDOW", 17, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Normal), "WINDOW", 18, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Hot), "WINDOW", 18, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Pressed), "WINDOW", 18, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.CloseButton.Disabled), "WINDOW", 18, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Normal), "WINDOW", 19, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Hot), "WINDOW", 19, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Pressed), "WINDOW", 19, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCloseButton.Disabled), "WINDOW", 19, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Normal), "WINDOW", 20, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Hot), "WINDOW", 20, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Pressed), "WINDOW", 20, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiCloseButton.Disabled), "WINDOW", 20, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Normal), "WINDOW", 21, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Hot), "WINDOW", 21, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Pressed), "WINDOW", 21, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.RestoreButton.Disabled), "WINDOW", 21, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Normal), "WINDOW", 22, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Hot), "WINDOW", 22, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Pressed), "WINDOW", 22, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiRestoreButton.Disabled), "WINDOW", 22, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Normal), "WINDOW", 23, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Hot), "WINDOW", 23, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Pressed), "WINDOW", 23, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HelpButton.Disabled), "WINDOW", 23, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Normal), "WINDOW", 24, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Hot), "WINDOW", 24, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Pressed), "WINDOW", 24, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.MdiHelpButton.Disabled), "WINDOW", 24, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Normal), "WINDOW", 25, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Hot), "WINDOW", 25, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Pressed), "WINDOW", 25, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalScroll.Disabled), "WINDOW", 25, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Normal), "WINDOW", 26, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Hot), "WINDOW", 26, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Pressed), "WINDOW", 26, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.HorizontalThumb.Disabled), "WINDOW", 26, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Normal), "WINDOW", 27, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Hot), "WINDOW", 27, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Pressed), "WINDOW", 27, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalScroll.Disabled), "WINDOW", 27, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Normal), "WINDOW", 28, 1 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Hot), "WINDOW", 28, 2 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Pressed), "WINDOW", 28, 3 };
-        yield return new object[] { I(() => VisualStyleElement.Window.VerticalThumb.Disabled), "WINDOW", 28, 4 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.Dialog.Normal), "WINDOW", 29, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.CaptionSizingTemplate.Normal), "WINDOW", 30, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallCaptionSizingTemplate.Normal), "WINDOW", 31, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameLeftSizingTemplate.Normal), "WINDOW", 32, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameLeftSizingTemplate.Normal), "WINDOW", 33, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameRightSizingTemplate.Normal), "WINDOW", 34, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameRightSizingTemplate.Normal), "WINDOW", 35, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.FrameBottomSizingTemplate.Normal), "WINDOW", 36, 0 };
-
-        yield return new object[] { I(() => VisualStyleElement.Window.SmallFrameBottomSizingTemplate.Normal), "WINDOW", 37, 0 };
-    }
-
-    [Theory]
-    [MemberData(nameof(KnownElements_TestData))]
-    public void VisualStyleElement_KnownElements_Get_ReturnsExpected(Func<VisualStyleElement> elementFactory, string expectedClassName, int expectedPart, int expectedState)
-    {
-        VisualStyleElement element = elementFactory();
-        Assert.Same(expectedClassName, element.ClassName);
-        Assert.Equal(expectedPart, element.Part);
-        Assert.Equal(expectedState, element.State);
-        Assert.Same(element, elementFactory());
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleInformationTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleInformationTests.cs
deleted file mode 100644
index 197a9698813..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleInformationTests.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.VisualStyles.Tests;
-
-// NB: doesn't require thread affinity
-public class VisualStyleInformationTests
-{
-    [Fact]
-    public void VisualStyleInformation_Author_Get_ReturnsExpected()
-    {
-        string author = VisualStyleInformation.Author;
-        Assert.NotNull(author);
-        Assert.Equal(author, VisualStyleInformation.Author);
-        Assert.DoesNotContain('\0', author);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_ColorScheme_Get_ReturnsExpected()
-    {
-        string scheme = VisualStyleInformation.ColorScheme;
-        Assert.NotNull(scheme);
-        Assert.Equal(scheme, VisualStyleInformation.ColorScheme);
-        Assert.DoesNotContain('\0', scheme);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_ColorScheme_Get_ReturnsDifferent()
-    {
-        string scheme = VisualStyleInformation.ColorScheme;
-        if (scheme != string.Empty)
-        {
-            Assert.NotEqual(scheme, VisualStyleInformation.Size);
-            Assert.NotEqual(scheme, VisualStyleInformation.Version);
-        }
-
-        Assert.DoesNotContain('\0', scheme);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Company_Get_ReturnsExpected()
-    {
-        string company = VisualStyleInformation.Company;
-        Assert.NotNull(company);
-        Assert.Equal(company, VisualStyleInformation.Company);
-        Assert.DoesNotContain('\0', company);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_ControlHighlightHot_Get_ReturnsExpected()
-    {
-        Color color = VisualStyleInformation.ControlHighlightHot;
-        Assert.NotEqual(Color.Empty, color);
-        Assert.Equal(color, VisualStyleInformation.ControlHighlightHot);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Copyright_Get_ReturnsExpected()
-    {
-        string copyright = VisualStyleInformation.Copyright;
-        Assert.NotNull(copyright);
-        Assert.Equal(copyright, VisualStyleInformation.Copyright);
-        Assert.DoesNotContain('\0', copyright);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Description_Get_ReturnsExpected()
-    {
-        string description = VisualStyleInformation.Description;
-        Assert.NotNull(description);
-        Assert.Equal(description, VisualStyleInformation.Description);
-        Assert.DoesNotContain('\0', description);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_DisplayName_Get_ReturnsExpected()
-    {
-        string displayName = VisualStyleInformation.DisplayName;
-        Assert.NotNull(displayName);
-        Assert.Equal(displayName, VisualStyleInformation.DisplayName);
-        Assert.DoesNotContain('\0', displayName);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_IsEnabledByUser_Get_ReturnsExpected()
-    {
-        bool enabled = VisualStyleInformation.IsEnabledByUser;
-        Assert.Equal(enabled, VisualStyleInformation.IsEnabledByUser);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_IsSupportedByOS_Get_ReturnsExpected()
-    {
-        bool supported = VisualStyleInformation.IsSupportedByOS;
-        Assert.True(supported);
-        Assert.Equal(supported, VisualStyleInformation.IsSupportedByOS);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_MinimumColorDepth_Get_ReturnsExpected()
-    {
-        int depth = VisualStyleInformation.MinimumColorDepth;
-        Assert.True(depth >= 0);
-        Assert.Equal(depth, VisualStyleInformation.MinimumColorDepth);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Size_Get_ReturnsExpected()
-    {
-        string size = VisualStyleInformation.Size;
-        Assert.NotNull(size);
-        Assert.Equal(size, VisualStyleInformation.Size);
-        Assert.DoesNotContain('\0', size);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Size_Get_ReturnsDifferent()
-    {
-        string size = VisualStyleInformation.Size;
-        if (size != string.Empty)
-        {
-            Assert.NotEqual(size, VisualStyleInformation.ColorScheme);
-            Assert.NotEqual(size, VisualStyleInformation.Version);
-        }
-
-        Assert.DoesNotContain('\0', size);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_SupportsFlatMenus_Get_ReturnsExpected()
-    {
-        bool supported = VisualStyleInformation.SupportsFlatMenus;
-        Assert.Equal(supported, VisualStyleInformation.SupportsFlatMenus);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_TextControlBorder_Get_ReturnsExpected()
-    {
-        Color color = VisualStyleInformation.TextControlBorder;
-        Assert.NotEqual(Color.Empty, color);
-        Assert.Equal(color, VisualStyleInformation.TextControlBorder);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Url_Get_ReturnsExpected()
-    {
-        string url = VisualStyleInformation.Url;
-        Assert.NotNull(url);
-        Assert.Equal(url, VisualStyleInformation.Url);
-        Assert.DoesNotContain('\0', url);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Version_Get_ReturnsExpected()
-    {
-        string version = VisualStyleInformation.Version;
-        Assert.NotNull(version);
-        Assert.Equal(version, VisualStyleInformation.Version);
-        Assert.DoesNotContain('\0', version);
-    }
-
-    [Fact]
-    public void VisualStyleInformation_Version_Get_ReturnsDifferent()
-    {
-        string version = VisualStyleInformation.Version;
-        if (version != string.Empty)
-        {
-            Assert.NotEqual(version, VisualStyleInformation.ColorScheme);
-            Assert.NotEqual(version, VisualStyleInformation.Size);
-        }
-
-        Assert.DoesNotContain('\0', version);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleRendererTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleRendererTests.cs
deleted file mode 100644
index 7710df8dade..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/VisualStyles/VisualStyleRendererTests.cs
+++ /dev/null
@@ -1,588 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-
-namespace System.Windows.Forms.VisualStyles.Tests;
-
-// NB: doesn't require thread affinity
-public class VisualStyleRendererTests
-{
-    public static IEnumerable<object[]> Ctor_VisualStyleElement_TestData()
-    {
-        yield return new object[] { VisualStyleElement.Button.PushButton.Hot };
-        yield return new object[] { VisualStyleElement.Button.PushButton.Normal };
-        yield return new object[] { VisualStyleElement.Button.RadioButton.CheckedHot };
-        yield return new object[] { VisualStyleElement.Button.RadioButton.CheckedNormal };
-        yield return new object[] { VisualStyleElement.ComboBox.DropDownButton.Hot };
-        yield return new object[] { VisualStyleElement.ComboBox.DropDownButton.Normal };
-        yield return new object[] { VisualStyleElement.CreateElement("BUTTON", 0, int.MinValue) };
-        yield return new object[] { VisualStyleElement.CreateElement("BUTTON", 0, int.MaxValue) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_VisualStyleElement_TestData))]
-    public void VisualStyleRenderer_Ctor_String_Int_Int(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(element.ClassName, element.Part, element.State);
-        Assert.Equal(element.ClassName, renderer.Class);
-        Assert.Equal(element.Part, renderer.Part);
-        Assert.Equal(element.State, renderer.State);
-        Assert.Equal(0, renderer.LastHResult);
-        Assert.NotEqual(IntPtr.Zero, renderer.Handle);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_Ctor_NullClassName_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("className", () => new VisualStyleRenderer(null, 0, 0));
-    }
-
-    public static IEnumerable<object[]> Ctor_InvalidElement_TestData()
-    {
-        yield return new object[] { VisualStyleElement.CreateElement("", 0, 0) };
-        yield return new object[] { VisualStyleElement.CreateElement("NoSuchClassName", 0, 0) };
-        yield return new object[] { VisualStyleElement.CreateElement("BUTTON", -1, 0) };
-        yield return new object[] { VisualStyleElement.CreateElement("BUTTON", int.MinValue, 0) };
-        yield return new object[] { VisualStyleElement.CreateElement("BUTTON", int.MaxValue, 0) };
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidElement_TestData))]
-    public void VisualStyleRenderer_Ctor_InvalidClassNamePartOrState_ThrowsArgumentException(VisualStyleElement element)
-    {
-        Assert.Throws<ArgumentException>(() => new VisualStyleRenderer(element.ClassName, element.Part, element.State));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_VisualStyleElement_TestData))]
-    public void VisualStyleRenderer_Ctor_VisualStyleElement(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(element);
-        Assert.Equal(element.ClassName, renderer.Class);
-        Assert.Equal(element.Part, renderer.Part);
-        Assert.Equal(element.State, renderer.State);
-        Assert.Equal(0, renderer.LastHResult);
-        Assert.NotEqual(IntPtr.Zero, renderer.Handle);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_Ctor_NullElement_ThrowsNullReferenceException()
-    {
-        Assert.Throws<NullReferenceException>(() => new VisualStyleRenderer(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidElement_TestData))]
-    public void VisualStyleRenderer_Ctor_InvalidElement_ThrowsArgumentException(VisualStyleElement element)
-    {
-        Assert.Throws<ArgumentException>(() => new VisualStyleRenderer(element));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_IsSupported_Get_ReturnsExpected()
-    {
-        bool result = VisualStyleRenderer.IsSupported;
-        Assert.True(result);
-        Assert.Equal(result, VisualStyleRenderer.IsSupported);
-    }
-
-    public static IEnumerable<object[]> IsElementDefined_TestData()
-    {
-        yield return new object[] { VisualStyleElement.Button.PushButton.Hot, true };
-        yield return new object[] { VisualStyleElement.Button.PushButton.Normal, true };
-        yield return new object[] { VisualStyleElement.Button.RadioButton.CheckedHot, true };
-        yield return new object[] { VisualStyleElement.Button.RadioButton.CheckedNormal, true };
-        yield return new object[] { VisualStyleElement.ComboBox.DropDownButton.Hot, true };
-        yield return new object[] { VisualStyleElement.ComboBox.DropDownButton.Normal, true };
-
-        yield return new object[] { VisualStyleElement.CreateElement(string.Empty, 0, 0), false };
-        yield return new object[] { VisualStyleElement.CreateElement("NoSuchName", 0, 0), false };
-    }
-
-    [Theory]
-    [MemberData(nameof(IsElementDefined_TestData))]
-    public void VisualStyleRenderer_IsElementDefined_Invoke_ReturnsExpected(VisualStyleElement element, bool expected)
-    {
-        Assert.Equal(expected, VisualStyleRenderer.IsElementDefined(element));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_IsElementDefined_NullElement_ThrowsArgumentNullException()
-    {
-        Assert.Throws<ArgumentNullException>("element", () => VisualStyleRenderer.IsElementDefined(null));
-    }
-
-    public static IEnumerable<object[]> DrawBackground_IDeviceContext_Rectangle_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(0, 0, 3, -1) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(0, 0, -1, -1) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawBackground_IDeviceContext_Rectangle_TestData))]
-    public void VisualStyleRenderer_DrawBackground_InvokeIDeviceContextRectangle_Success(Rectangle bounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        renderer.DrawBackground(graphics, bounds);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    public static IEnumerable<object[]> DrawBackground_IDeviceContext_Rectangle_Rectangle_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 0), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, -1), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, -1), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, -1, 4) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, 3, -1) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(0, 0, -1, -1) };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), new Rectangle(-1, -2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawBackground_IDeviceContext_Rectangle_Rectangle_TestData))]
-    public void VisualStyleRenderer_DrawBackground_InvokeIDeviceContextRectangleRectangle_Success(Rectangle bounds, Rectangle clipBounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        renderer.DrawBackground(graphics, bounds, clipBounds);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawBackground_NullDc_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawBackground(null, new Rectangle(1, 2, 3, 4)));
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawBackground(null, new Rectangle(1, 2, 3, 4), new Rectangle(1, 2, 3, 4)));
-    }
-
-    public static IEnumerable<object[]> DrawEdge_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Edges.Top, EdgeStyle.Bump, EdgeEffects.Mono };
-        yield return new object[] { new Rectangle(1, 2, 3, 4), Edges.Left | Edges.Top | Edges.Right | Edges.Bottom | Edges.Diagonal, EdgeStyle.Sunken, EdgeEffects.FillInterior | EdgeEffects.Flat | EdgeEffects.Soft | EdgeEffects.Mono };
-        yield return new object[] { new Rectangle(0, 0, 3, 4), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, 0, 4), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, -1, 4), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, 3, 0), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, 3, -1), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, 0, 0), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(0, 0, -1, -1), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4), Edges.Left, EdgeStyle.Raised, EdgeEffects.None };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawEdge_TestData))]
-    public void VisualStyleRenderer_DrawEdge_Invoke_Success(Rectangle bounds, Edges edges, EdgeStyle style, EdgeEffects effects)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Rectangle result = renderer.DrawEdge(graphics, bounds, edges, style, effects);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawEdge_NullDc_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawEdge(null, new Rectangle(1, 2, 3, 4), Edges.Top, EdgeStyle.Bump, EdgeEffects.FillInterior));
-    }
-
-    [Theory]
-    [InvalidEnumData<Edges>]
-    public void VisualStyleRenderer_DrawEdge_InvalidEdges_ThrowsInvalidEnumArgumentException(Edges edges)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Assert.Throws<InvalidEnumArgumentException>("edges", () => renderer.DrawEdge(graphics, new Rectangle(1, 2, 3, 4), edges, EdgeStyle.Bump, EdgeEffects.FillInterior));
-    }
-
-    [Theory]
-    [InvalidEnumData<EdgeStyle>]
-    public void VisualStyleRenderer_DrawEdge_InvalidStyle_ThrowsInvalidEnumArgumentException(EdgeStyle style)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Assert.Throws<InvalidEnumArgumentException>("style", () => renderer.DrawEdge(graphics, new Rectangle(1, 2, 3, 4), Edges.Bottom, style, EdgeEffects.FillInterior));
-    }
-
-    [Theory]
-    [InvalidEnumData<EdgeEffects>]
-    public void VisualStyleRenderer_DrawEdge_InvalidEffects_ThrowsInvalidEnumArgumentException(EdgeEffects effects)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Assert.Throws<InvalidEnumArgumentException>("effects", () => renderer.DrawEdge(graphics, new Rectangle(1, 2, 3, 4), Edges.Bottom, EdgeStyle.Bump, effects));
-    }
-
-    public static IEnumerable<object[]> DrawImage_IDeviceContext_Rectangle_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(0, 0, 3, -1) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(0, 0, -1, -1) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawBackground_IDeviceContext_Rectangle_TestData))]
-    public void VisualStyleRenderer_DrawImage_InvokeIDeviceContextRectangleImage_Success(Rectangle bounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using var image = new Bitmap(10, 10);
-        renderer.DrawImage(graphics, bounds, image);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawBackground_IDeviceContext_Rectangle_TestData))]
-    public void VisualStyleRenderer_DrawImage_InvokeIDeviceContextRectangleImageListInt_Success(Rectangle bounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        renderer.DrawImage(graphics, bounds, imageList, 0);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawImage_NullG_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        Assert.Throws<ArgumentNullException>("g", () => renderer.DrawImage(null, new Rectangle(1, 2, 3, 4), image));
-        Assert.Throws<ArgumentNullException>("g", () => renderer.DrawImage(null, new Rectangle(1, 2, 3, 4), imageList, 0));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawImage_NullImage_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var image = new Bitmap(10, 10);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Assert.Throws<ArgumentNullException>("image", () => renderer.DrawImage(graphics, new Rectangle(1, 2, 3, 4), null));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawImage_NullImageList_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var image = new Bitmap(10, 10);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        Assert.Throws<ArgumentNullException>("imageList", () => renderer.DrawImage(graphics, new Rectangle(1, 2, 3, 4), null, 0));
-    }
-
-    [Theory]
-    [InlineData(-1)]
-    [InlineData(1)]
-    public void VisualStyleRenderer_DrawImage_InvalidImageIndex_ThrowsArgumentNullException(int imageIndex)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using var image = new Bitmap(10, 10);
-        using var imageList = new ImageList();
-        imageList.Images.Add(image);
-        Assert.Throws<ArgumentOutOfRangeException>("imageIndex", () => renderer.DrawImage(graphics, new Rectangle(1, 2, 3, 4), imageList, imageIndex));
-    }
-
-    public static IEnumerable<object[]> DrawParentBackground_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(0, 0, 3, -1) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(0, 0, -1, -1) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawParentBackground_TestData))]
-    public void VisualStyleRenderer_DrawParentBackgroundInvokeIDeviceContextRectangleChildWithoutHandle_Success(Rectangle bounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using var childControl = new Control();
-        renderer.DrawParentBackground(graphics, bounds, childControl);
-        Assert.False(childControl.IsHandleCreated);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    public static IEnumerable<object[]> DrawParentBackground_WithHandle_TestData()
-    {
-        yield return new object[] { new Rectangle(1, 2, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 4) };
-        yield return new object[] { new Rectangle(0, 0, 0, 4) };
-        yield return new object[] { new Rectangle(0, 0, -1, 4) };
-        yield return new object[] { new Rectangle(0, 0, 3, 0) };
-        yield return new object[] { new Rectangle(0, 0, 3, -1) };
-        yield return new object[] { new Rectangle(0, 0, 0, 0) };
-        yield return new object[] { new Rectangle(0, 0, -1, -1) };
-        yield return new object[] { new Rectangle(-1, -2, 3, 4) };
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawParentBackground_WithHandle_TestData))]
-    public void VisualStyleRenderer_DrawParentBackground_InvokeIDeviceContextRectangleChildWithHandle_Success(Rectangle bounds)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        using var childControl = new Control();
-        Assert.NotEqual(IntPtr.Zero, childControl.Handle);
-        renderer.DrawParentBackground(graphics, bounds, childControl);
-        Assert.True(childControl.IsHandleCreated);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawParentBackground_NullDc_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var childControl = new Control();
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawParentBackground(null, new Rectangle(1, 2, 3, 4), childControl));
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_Rectangle_String_TestData()
-    {
-        foreach (string textToDraw in new string[] { null, string.Empty, "text" })
-        {
-            yield return new object[] { new Rectangle(1, 2, 3, 4), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, 3, 4), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, 0, 4), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, -1, 4), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, 3, 0), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, 3, -1), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, 0, 0), textToDraw };
-            yield return new object[] { new Rectangle(0, 0, -1, -1), textToDraw };
-            yield return new object[] { new Rectangle(-1, -2, 3, 4), textToDraw };
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawText_IDeviceContext_Rectangle_String_TestData))]
-    public void VisualStyleRenderer_DrawText_InvokeIDeviceContextRectangleString_Success(Rectangle bounds, string textToDraw)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        renderer.DrawText(graphics, bounds, textToDraw);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_Rectangle_String_Bool_TestData()
-    {
-        foreach (string textToDraw in new string[] { null, string.Empty, "text" })
-        {
-            foreach (bool drawDisabled in new bool[] { true, false })
-            {
-                yield return new object[] { new Rectangle(1, 2, 3, 4), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, 3, 4), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, 0, 4), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, -1, 4), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, 3, 0), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, 3, -1), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, 0, 0), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(0, 0, -1, -1), textToDraw, drawDisabled };
-                yield return new object[] { new Rectangle(-1, -2, 3, 4), textToDraw, drawDisabled };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawText_IDeviceContext_Rectangle_String_Bool_TestData))]
-    public void VisualStyleRenderer_DrawText_InvokeIDeviceContextRectangleStringBool_Success(Rectangle bounds, string textToDraw, bool drawDisabled)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        renderer.DrawText(graphics, bounds, textToDraw, drawDisabled);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    public static IEnumerable<object[]> DrawText_IDeviceContext_Rectangle_String_Bool_TextFormatFlags_TestData()
-    {
-        foreach (string textToDraw in new string[] { null, string.Empty, "text" })
-        {
-            foreach (bool drawDisabled in new bool[] { true, false })
-            {
-                yield return new object[] { new Rectangle(1, 2, 3, 4), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, 3, 4), textToDraw, drawDisabled, TextFormatFlags.VerticalCenter };
-                yield return new object[] { new Rectangle(0, 0, 0, 4), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, -1, 4), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, 3, 0), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, 3, -1), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, 0, 0), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(0, 0, -1, -1), textToDraw, drawDisabled, TextFormatFlags.Default };
-                yield return new object[] { new Rectangle(-1, -2, 3, 4), textToDraw, drawDisabled, TextFormatFlags.Default };
-            }
-        }
-    }
-
-    [Theory]
-    [MemberData(nameof(DrawText_IDeviceContext_Rectangle_String_Bool_TextFormatFlags_TestData))]
-    public void VisualStyleRenderer_DrawText_InvokeIDeviceContextRectangleStringBoolTextFormatFlags_Success(Rectangle bounds, string textToDraw, bool drawDisabled, TextFormatFlags flags)
-    {
-        // Don't verify anything, just make sure the interop call succeeds.
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var bitmap = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(bitmap);
-        renderer.DrawText(graphics, bounds, textToDraw, drawDisabled, flags);
-        Assert.Equal(0, renderer.LastHResult);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_DrawText_NullDc_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-        using var image = new Bitmap(10, 10);
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawText(null, new Rectangle(1, 2, 3, 4), "text"));
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawText(null, new Rectangle(1, 2, 3, 4), "text", true));
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawText(null, new Rectangle(1, 2, 3, 4), "text", false));
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawText(null, new Rectangle(1, 2, 3, 4), "text", true, TextFormatFlags.Default));
-        Assert.Throws<ArgumentNullException>("dc", () => renderer.DrawText(null, new Rectangle(1, 2, 3, 4), "text", false, TextFormatFlags.Default));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_GetMargins()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
-
-        using var form = new Form();
-        using Graphics graphics = form.CreateGraphics();
-
-        // GetMargins should not throw an exception.
-        // See https://github.com/dotnet/winforms/issues/526.
-        renderer.GetMargins(graphics, MarginProperty.SizingMargins);
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_VisualStyleElement_TestData))]
-    public void VisualStyleRenderer_SetParameters_InvokeStringIntInt_Success(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Hot);
-        renderer.SetParameters(element.ClassName, element.Part, element.State);
-        Assert.Equal(element.ClassName, renderer.Class);
-        Assert.Equal(element.Part, renderer.Part);
-        Assert.Equal(element.State, renderer.State);
-        Assert.Equal(0, renderer.LastHResult);
-        Assert.NotEqual(IntPtr.Zero, renderer.Handle);
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidElement_TestData))]
-    public void VisualStyleRenderer_SetParameters_InvalidClassNamePartState_ThrowsArgumentException(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Hot);
-        Assert.Throws<ArgumentException>(() => renderer.SetParameters(element.ClassName, element.Part, element.State));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_VisualStyleElement_TestData))]
-    public void VisualStyleRenderer_SetParameters_InvokeVisualStyleElement_Success(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Hot);
-        renderer.SetParameters(element);
-        Assert.Equal(element.ClassName, renderer.Class);
-        Assert.Equal(element.Part, renderer.Part);
-        Assert.Equal(element.State, renderer.State);
-        Assert.Equal(0, renderer.LastHResult);
-        Assert.NotEqual(IntPtr.Zero, renderer.Handle);
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_SetParameters_NullElement_ThrowsArgumentNullException()
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Hot);
-        Assert.Throws<ArgumentNullException>("element", () => renderer.SetParameters(null));
-    }
-
-    [Theory]
-    [MemberData(nameof(Ctor_InvalidElement_TestData))]
-    public void VisualStyleRenderer_SetParameters_InvalidElement_ThrowsArgumentException(VisualStyleElement element)
-    {
-        var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Hot);
-        Assert.Throws<ArgumentException>(() => renderer.SetParameters(element));
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_IsBackgroundPartiallyTransparent_Invoke_ReturnsExpected()
-    {
-        var renderer = new VisualStyleRenderer("BUTTON", 0, 0);
-        Assert.False(renderer.IsBackgroundPartiallyTransparent());
-    }
-
-    [Fact]
-    public void VisualStyleRenderer_GetFont_for_TextFont()
-    {
-        var renderer = new VisualStyleRenderer("TEXTSTYLE", 1, 0);
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-        using Font font = renderer.GetFont(graphics, FontProperty.TextFont);
-
-        Assert.NotNull(font);
-    }
-
-    [Theory]
-    [InvalidEnumData<FontProperty>]
-    public void VisualStyleRenderer_GetFont_for_InvalidFontProperty(FontProperty value)
-    {
-        var renderer = new VisualStyleRenderer("TEXTSTYLE", 1, 0);
-        using var image = new Bitmap(10, 10);
-        using Graphics graphics = Graphics.FromImage(image);
-
-        Assert.Throws<InvalidEnumArgumentException>("prop", () => renderer.GetFont(graphics, value));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowser.WebBrowserAccessibleObjectTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowser.WebBrowserAccessibleObjectTests.cs
deleted file mode 100644
index 80f12016a1e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowser.WebBrowserAccessibleObjectTests.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using static System.Windows.Forms.WebBrowser;
-using static Interop.UiaCore;
-
-namespace System.Windows.Forms.Tests;
-
-public class WebBrowser_WebBrowserAccessibleObjectTests
-{
-    [WinFormsFact]
-    public void WebBrowserAccessibleObject_Ctor_Default()
-    {
-        using WebBrowser webBrowser = new();
-        WebBrowserAccessibleObject accessibleObject = (WebBrowserAccessibleObject)webBrowser.AccessibilityObject;
-
-        Assert.Equal(webBrowser, accessibleObject.Owner);
-        Assert.False(webBrowser.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)UIA.NamePropertyId, "TestName")]
-    [InlineData((int)UIA.AutomationIdPropertyId, "ToolStripContainer1")]
-    public void WebBrowserAccessibleObject_GetPropertyValue_Invoke_ReturnsExpected(int propertyID, object expected)
-    {
-        using WebBrowser webBrowser = new WebBrowser
-        {
-            Name = expected.ToString(),
-            AccessibleName = expected.ToString()
-        };
-
-        WebBrowserAccessibleObject accessibleObject = (WebBrowserAccessibleObject)webBrowser.AccessibilityObject;
-        object value = accessibleObject.GetPropertyValue((UIA)propertyID);
-
-        Assert.Equal(expected, value);
-        Assert.False(webBrowser.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowserAccessibleObject_GetPropertyValue_HasKeyboardFocus_ReturnsFalse_IfControlHasNoFocus()
-    {
-        using WebBrowser webBrowser = new();
-
-        WebBrowserAccessibleObject accessibleObject = (WebBrowserAccessibleObject)webBrowser.AccessibilityObject;
-        bool value = (bool)accessibleObject.GetPropertyValue(UIA.HasKeyboardFocusPropertyId);
-
-        Assert.False(value);
-        Assert.False(webBrowser.IsHandleCreated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserDocumentCompletedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserDocumentCompletedEventArgsTests.cs
deleted file mode 100644
index 5d2b5e64e01..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserDocumentCompletedEventArgsTests.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class WebBrowserDocumentCompletedEventArgsTests
-{
-    [Fact]
-    public void Ctor_Uri()
-    {
-        var url = new Uri("http://google.com");
-        var e = new WebBrowserDocumentCompletedEventArgs(url);
-        Assert.Equal(url, e.Url);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatedEventArgsTests.cs
deleted file mode 100644
index d272acccf7e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatedEventArgsTests.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class WebBrowserNavigatedEventArgsTests
-{
-    [Fact]
-    public void Ctor_Uri()
-    {
-        var url = new Uri("http://google.com");
-        var e = new WebBrowserNavigatedEventArgs(url);
-        Assert.Equal(url, e.Url);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatingEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatingEventArgsTests.cs
deleted file mode 100644
index 60aa9f78d47..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserNavigatingEventArgsTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class WebBrowserNavigatingEventArgsTests
-{
-    [Theory]
-    [InlineData(null)]
-    [InlineData("")]
-    [InlineData("targetFrameName")]
-    public void Ctor_Uri(string targetFrameName)
-    {
-        var url = new Uri("http://google.com");
-        var e = new WebBrowserNavigatingEventArgs(url, targetFrameName);
-        Assert.Equal(url, e.Url);
-        Assert.Equal(targetFrameName, e.TargetFrameName);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserProgressChangedEventArgsTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserProgressChangedEventArgsTests.cs
deleted file mode 100644
index a76c83e548a..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserProgressChangedEventArgsTests.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-// NB: doesn't require thread affinity
-public class WebBrowserProgressChangedEventArgsTests
-{
-    [Theory]
-    [InlineData(-1, -1)]
-    [InlineData(0, 0)]
-    [InlineData(1, 2)]
-    [InlineData(2, 1)]
-    public void Ctor_Long_Long(long currentProgress, long maximumProgress)
-    {
-        var e = new WebBrowserProgressChangedEventArgs(currentProgress, maximumProgress);
-        Assert.Equal(currentProgress, e.CurrentProgress);
-        Assert.Equal(maximumProgress, e.MaximumProgress);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserTests.cs
deleted file mode 100644
index 1fd854c28a9..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WebBrowserTests.cs
+++ /dev/null
@@ -1,4745 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using static Interop.Mshtml;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads
-public class WebBrowserTests
-{
-    [WinFormsFact]
-    public void WebBrowser_Ctor_Default()
-    {
-        using var control = new SubWebBrowser();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.AllowDrop);
-        Assert.True(control.AllowNavigation);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(250, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 250, 250), control.Bounds);
-        Assert.False(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.True(control.CanEnableIme);
-        Assert.True(control.CanRaiseEvents);
-        Assert.False(control.CanSelect);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(250, 250), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 250, 250), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(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(250, 250), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 250, 250), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(Control.DefaultForeColor, control.ForeColor);
-        Assert.False(control.HasChildren);
-        Assert.Equal(250, control.Height);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IsWebBrowserContextMenuEnabled);
-        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.Null(control.ObjectForScripting);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(250, 250), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(250, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(250, 250), control.Size);
-        Assert.True(control.ScrollBarsEnabled);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.NotNull(control.Version);
-        Assert.NotSame(control.Version, control.Version);
-        Assert.True(control.Visible);
-        Assert.True(control.WebBrowserShortcutsEnabled);
-        Assert.Equal(250, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubWebBrowser();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(250, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010000, createParams.Style);
-        Assert.Equal(250, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ActiveXInstance_GetWithHandle_ReturnsNull()
-    {
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Null(control.ActiveXInstance);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowNavigation_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            AllowNavigation = value
-        };
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowNavigation = value;
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowNavigation = !value;
-        Assert.Equal(!value, control.AllowNavigation);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowNavigation_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.AllowNavigation = value;
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowNavigation = value;
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowNavigation = !value;
-        Assert.Equal(!value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowNavigation_SetWithSink_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.CreateSink();
-
-        control.AllowNavigation = value;
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowNavigation = value;
-        Assert.Equal(value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowNavigation = !value;
-        Assert.Equal(!value, control.AllowNavigation);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        control.Stop();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AllowWebBrowserDrop_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.True(control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AllowWebBrowserDrop_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.True(control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AllowWebBrowserDrop_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.AllowWebBrowserDrop);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AllowWebBrowserDrop_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.AllowWebBrowserDrop);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowWebBrowserDrop_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            AllowWebBrowserDrop = value
-        };
-        Assert.Equal(value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowWebBrowserDrop = value;
-        Assert.Equal(value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowWebBrowserDrop = !value;
-        Assert.Equal(!value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowWebBrowserDrop_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.AllowWebBrowserDrop = value;
-        Assert.Equal(value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(value, ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.AllowWebBrowserDrop = value;
-        Assert.Equal(value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(value, ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.AllowWebBrowserDrop = !value;
-        Assert.Equal(!value, control.AllowWebBrowserDrop);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(!value, ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowWebBrowserDrop_SetDisposed_ThrowsObjectDisposedException(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.AllowWebBrowserDrop = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_AllowWebBrowserDrop_SetDetached_ThrowsInvalidOperationException(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.AllowWebBrowserDrop = value);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_CanGoBack_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        Assert.False(control.CanGoBack);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_CanGoBack_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file1 = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file1.Path));
-        Assert.True(await source.Task);
-
-        Assert.False(control.CanGoBack);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_CanGoForward_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.CanGoForward);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_CanGoForward_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file1 = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file1.Path));
-        Assert.True(await source.Task);
-
-        Assert.False(control.CanGoForward);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Document_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Null(control.Document);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Document_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Null(control.Document);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("<title>NewDocument</title>", "NewDocument")]
-    [InlineData("<title></title>", "")]
-    public async Task WebBrowser_Document_GetWithDocument_ReturnsExpected(string titleHtml, string expectedTitle)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        string html = $"<html><head>{titleHtml}</head></html>";
-        using var file = CreateTempFile(html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        HtmlDocument document = control.Document;
-        Assert.NotNull(document);
-        Assert.NotSame(document, control.Document);
-        Assert.Equal(expectedTitle, document.Title);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Document_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.Document);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Document_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.Document);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Null(control.DocumentStream);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Null(control.DocumentStream);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_DocumentStream_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        MemoryStream documentStream = Assert.IsType<MemoryStream>(control.DocumentStream);
-        Assert.Equal(Html, Encoding.UTF8.GetString(documentStream.ToArray()));
-        Assert.NotSame(documentStream, control.DocumentStream);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentStream);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentStream);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_DocumentStream_Set_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var value = new MemoryStream(Encoding.UTF8.GetBytes(Html));
-        await Task.Run(() => control.DocumentStream = value);
-        Assert.True(await source.Task);
-        Assert.Equal(Html, control.DocumentText);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-
-        // Set null.
-        control.DocumentStream = null;
-        Assert.True(await source.Task);
-        Assert.Equal(Html, control.DocumentText);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentStream = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentStream_SetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentStream = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Empty(control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Empty(control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_DocumentText_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        string documentText = control.DocumentText;
-        Assert.Equal(documentText, control.DocumentText);
-        Assert.NotSame(documentText, control.DocumentText);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentText);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentText);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void WebBrowser_DocumentText_Set_GetReturnsExpected(string value)
-    {
-        using var control = new WebBrowser
-        {
-            DocumentText = value
-        };
-        Assert.NotEmpty(control.DocumentText);
-        Assert.DoesNotContain('\0', control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.DocumentText = value;
-        Assert.NotEmpty(control.DocumentText);
-        Assert.DoesNotContain('\0', control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void WebBrowser_DocumentText_SetWithInstance_GetReturnsExpected(string value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.DocumentText = value;
-        Assert.NotEmpty(control.DocumentText);
-        Assert.DoesNotContain('\0', control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.DocumentText = value;
-        Assert.NotEmpty(control.DocumentText);
-        Assert.DoesNotContain('\0', control.DocumentText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_DocumentText_SetValidHtml_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        var source = new TaskCompletionSource<bool>();
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal("about:blank", e.Url.OriginalString);
-            Assert.Empty(e.TargetFrameName);
-            Assert.False(e.Cancel);
-            navigatingCallCount++;
-        };
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal("about:blank", e.Url.OriginalString);
-            navigatedCallCount++;
-        };
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            documentTitleChangedCallCount++;
-        };
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal("about:blank", e.Url.OriginalString);
-            documentCompletedCallCount++;
-            source.SetResult(true);
-        };
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            encryptionLevelChangedCallCount++;
-        };
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            statusTextChangedCallCount++;
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        await Task.Run(() => control.DocumentText = Html);
-        Assert.True(await source.Task);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(1, navigatingCallCount);
-        Assert.Equal(2, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount > 0);
-        Assert.Equal(1, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-
-        // Call again
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.DocumentText = Html);
-        Assert.True(await source.Task);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(2, navigatingCallCount);
-        Assert.Equal(4, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount > 0);
-        Assert.Equal(2, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-
-        // Set null.
-        control.DocumentText = null;
-        Assert.True(await source.Task);
-        Assert.Equal(Html, control.DocumentText);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-
-        // Set empty.
-        control.DocumentText = string.Empty;
-        Assert.True(await source.Task);
-        Assert.Equal(Html, control.DocumentText);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentText = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentText_SetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentText = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentTitle_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Empty(control.DocumentTitle);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentTitle_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Empty(control.DocumentTitle);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("<title>NewDocument</title>", "NewDocument")]
-    [InlineData("<title></title>", "")]
-    [InlineData("", "")]
-    public async Task WebBrowser_DocumentTitle_GetWithDocument_ReturnsExpected(string titleHtml, string expected)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        string html = $"<html><head>{titleHtml}</head></html>";
-        using var file = CreateTempFile(html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.Equal(expected, control.DocumentTitle);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentTitle_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentTitle);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentTitle_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentTitle);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentType_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Empty(control.DocumentType);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentType_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Empty(control.DocumentType);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_DocumentType_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.NotEmpty(control.DocumentType);
-        Assert.DoesNotContain('\0', control.DocumentType);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentType_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.DocumentType);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DocumentType_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.DocumentType);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_EncryptionLevel_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Equal(WebBrowserEncryptionLevel.Unknown, control.EncryptionLevel);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_EncryptionLevel_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Equal(WebBrowserEncryptionLevel.Unknown, control.EncryptionLevel);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_EncryptionLevel_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.Equal(WebBrowserEncryptionLevel.Insecure, control.EncryptionLevel);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_EncryptionLevel_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.EncryptionLevel);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_EncryptionLevel_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.EncryptionLevel);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Focused_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.False(control.Focused);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Focused_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.Focused);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Focused_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.Focused);
-        Assert.Null(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsBusy_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.False(control.IsBusy);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsBusy_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.IsBusy);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_IsBusy_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.False(control.IsBusy);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsBusy_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.IsBusy);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsBusy_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.IsBusy);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsOffline_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.False(control.IsOffline);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsOffline_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.IsOffline);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsOffline_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.IsOffline);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_IsOffline_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.IsOffline);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_IsWebBrowserContextMenuEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            IsWebBrowserContextMenuEnabled = value
-        };
-        Assert.Equal(value, control.IsWebBrowserContextMenuEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.IsWebBrowserContextMenuEnabled = value;
-        Assert.Equal(value, control.IsWebBrowserContextMenuEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.IsWebBrowserContextMenuEnabled = !value;
-        Assert.Equal(!value, control.IsWebBrowserContextMenuEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_IsWebBrowserContextMenuEnabled_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.IsWebBrowserContextMenuEnabled = value;
-        Assert.Equal(value, control.IsWebBrowserContextMenuEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.IsWebBrowserContextMenuEnabled = value;
-        Assert.Equal(value, control.IsWebBrowserContextMenuEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.IsWebBrowserContextMenuEnabled = !value;
-        Assert.Equal(!value, control.IsWebBrowserContextMenuEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ObjectForScripting_Set_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CustomScriptingObject() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ObjectForScripting_Set_TestData))]
-    public void WebBrowser_ObjectForScripting_Set_GetReturnsExpected(object value)
-    {
-        using var control = new WebBrowser
-        {
-            ObjectForScripting = value
-        };
-        Assert.Same(value, control.ObjectForScripting);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ObjectForScripting = value;
-        Assert.Same(value, control.ObjectForScripting);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ObjectForScripting_Set_TestData))]
-    public void WebBrowser_ObjectForScripting_SetWithInstance_GetReturnsExpected(object value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent,
-            ObjectForScripting = value
-        };
-        Assert.Same(value, control.ObjectForScripting);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.ObjectForScripting = value;
-        Assert.Same(value, control.ObjectForScripting);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ObjectForScripting_SetNotComVisible_ThrowsArgumentException()
-    {
-        using var control = new WebBrowser();
-        Assert.Throws<ArgumentException>("value", () => control.ObjectForScripting = new PrivateClass());
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void WebBrowser_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new WebBrowser
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void WebBrowser_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)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);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new WebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetNonNull_AddsToControls()
-    {
-        using var parent = new WebBrowser();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Same(control, Assert.Single(parent.Controls));
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetParent_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetParentNotVisible_GetReturnsExpected()
-    {
-        using var parent = new Control
-        {
-            Visible = false
-        };
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetChildNotVisible_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Visible = false,
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetWithHandle_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetWithHandleParentNotVisible_GetReturnsExpected()
-    {
-        using var parent = new Control
-        {
-            Visible = false
-        };
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetWithHandleChildNotVisible_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        Assert.NotEqual(IntPtr.Zero, parent.Handle);
-
-        using var control = new WebBrowser
-        {
-            Visible = false,
-            Parent = parent
-        };
-        Assert.Same(parent, control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetWithHandler_CallsParentChanged()
-    {
-        using var parent = new WebBrowser();
-        using var control = new WebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ParentChanged += handler;
-
-        // Set different.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(1, callCount);
-
-        // Set null.
-        control.Parent = null;
-        Assert.Null(control.Parent);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ParentChanged -= handler;
-        control.Parent = parent;
-        Assert.Same(parent, control.Parent);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Parent_SetSame_ThrowsArgumentException()
-    {
-        using var control = new WebBrowser();
-        Assert.Throws<ArgumentException>(() => control.Parent = control);
-        Assert.Null(control.Parent);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ReadyState_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Equal(WebBrowserReadyState.Uninitialized, control.ReadyState);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ReadyState_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Equal(WebBrowserReadyState.Uninitialized, control.ReadyState);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_ReadyState_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.Equal(WebBrowserReadyState.Complete, control.ReadyState);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ReadyState_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.ReadyState);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ReadyState_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.ReadyState);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ScriptErrorsSuppressed_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.False(control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ScriptErrorsSuppressed_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ScriptErrorsSuppressed_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.ScriptErrorsSuppressed);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ScriptErrorsSuppressed_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.ScriptErrorsSuppressed);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScriptErrorsSuppressed_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            ScriptErrorsSuppressed = value
-        };
-        Assert.Equal(value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.ScriptErrorsSuppressed = value;
-        Assert.Equal(value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.ScriptErrorsSuppressed = !value;
-        Assert.Equal(!value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScriptErrorsSuppressed_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ScriptErrorsSuppressed = value;
-        Assert.Equal(value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(value, ((IWebBrowser2)control.ActiveXInstance).Silent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.ScriptErrorsSuppressed = value;
-        Assert.Equal(value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(value, ((IWebBrowser2)control.ActiveXInstance).Silent);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.ScriptErrorsSuppressed = !value;
-        Assert.Equal(!value, control.ScriptErrorsSuppressed);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScriptErrorsSuppressed_SetDisposed_ThrowsObjectDisposedException(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.ScriptErrorsSuppressed = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScriptErrorsSuppressed_SetDetached_ThrowsInvalidOperationException(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.ScriptErrorsSuppressed = value);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScrollBarsEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            ScrollBarsEnabled = value
-        };
-        Assert.Equal(value, control.ScrollBarsEnabled);
-        Assert.Equal(!value, control.ActiveXInstance is not null);
-        Assert.Equal(!value, control.IsHandleCreated);
-
-        // Set same.
-        control.ScrollBarsEnabled = value;
-        Assert.Equal(value, control.ScrollBarsEnabled);
-        Assert.Equal(!value, control.ActiveXInstance is not null);
-        Assert.Equal(!value, control.IsHandleCreated);
-
-        // Set different.
-        control.ScrollBarsEnabled = !value;
-        Assert.Equal(!value, control.ScrollBarsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_ScrollBarsEnabled_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ScrollBarsEnabled = value;
-        Assert.Equal(value, control.ScrollBarsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.ScrollBarsEnabled = value;
-        Assert.Equal(value, control.ScrollBarsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.ScrollBarsEnabled = !value;
-        Assert.Equal(!value, control.ScrollBarsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_StatusText_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Empty(control.StatusText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_StatusText_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Empty(control.StatusText);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_StatusText_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.Equal("Done", control.StatusText);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_StatusText_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.StatusText);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_StatusText_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.StatusText);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_Get_ReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Url_GetWithDocument_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-
-        Assert.Equal(new Uri(file.Path), control.Url);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.Url);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_GetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.Url);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Url_Set_GetReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            Assert.Empty(e.TargetFrameName);
-            Assert.False(e.Cancel);
-            navigatingCallCount++;
-        };
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            navigatedCallCount++;
-        };
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            documentTitleChangedCallCount++;
-        };
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            documentCompletedCallCount++;
-            source.SetResult(true);
-        };
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            encryptionLevelChangedCallCount++;
-        };
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            statusTextChangedCallCount++;
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        await Task.Run(() => control.Url = new Uri(file.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(1, navigatingCallCount);
-        Assert.Equal(1, navigatedCallCount);
-        Assert.Equal(2, documentTitleChangedCallCount);
-        Assert.Equal(1, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-
-        // Set same.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Url = new Uri(file.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(2, navigatingCallCount);
-        Assert.Equal(2, navigatedCallCount);
-        Assert.Equal(4, documentTitleChangedCallCount);
-        Assert.Equal(2, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-    }
-
-    public static IEnumerable<object[]> Url_Set_NullOrEmpty_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Uri("", UriKind.Relative) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Url_Set_NullOrEmpty_TestData))]
-    public async Task WebBrowser_Url_SetNullOrEmpty_GoesToBlank(Uri nullOrEmptyUri)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        await Task.Run(() => control.Url = new Uri(file.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Url = nullOrEmptyUri);
-        Assert.True(await source.Task);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_SetRelativeUri_ThrowsArgumentException()
-    {
-        using var control = new WebBrowser();
-        var relativeUri = new Uri("/path", UriKind.Relative);
-        Assert.Throws<ArgumentException>(() => control.Url = relativeUri);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_SetDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.Url = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Url_SetDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.Url = null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Version_GetWithInstance_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.NotNull(control.Version);
-        Assert.NotSame(control.Version, control.Version);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_Visible_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            Visible = value
-        };
-        Assert.Equal(value, control.Visible);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Visible = !value;
-        Assert.Equal(!value, control.Visible);
-        Assert.Equal(!value, control.ActiveXInstance is not null);
-        Assert.Equal(!value, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Visible_SetTrue_GetReturnsExpected()
-    {
-        using var control = new WebBrowser
-        {
-            Visible = false
-        };
-        Assert.False(control.Visible);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_Visible_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set same.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-
-        // Set different.
-        control.Visible = value;
-        Assert.Equal(value, control.Visible);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Visible_SetTrueWithHandle_GetReturnsExpected()
-    {
-        using var control = new WebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Null(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Visible_SetWithHandler_CallsVisibleChanged()
-    {
-        using var control = new WebBrowser
-        {
-            Visible = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.VisibleChanged += handler;
-
-        // Set different.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Visible = true;
-        Assert.True(control.Visible);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.VisibleChanged -= handler;
-        control.Visible = false;
-        Assert.False(control.Visible);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_WebBrowserShortcutsEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new WebBrowser
-        {
-            WebBrowserShortcutsEnabled = value
-        };
-        Assert.Equal(value, control.WebBrowserShortcutsEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.WebBrowserShortcutsEnabled = value;
-        Assert.Equal(value, control.WebBrowserShortcutsEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.WebBrowserShortcutsEnabled = !value;
-        Assert.Equal(!value, control.WebBrowserShortcutsEnabled);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_WebBrowserShortcutsEnabled_SetWithInstance_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.WebBrowserShortcutsEnabled = value;
-        Assert.Equal(value, control.WebBrowserShortcutsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.WebBrowserShortcutsEnabled = value;
-        Assert.Equal(value, control.WebBrowserShortcutsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Set different.
-        control.WebBrowserShortcutsEnabled = !value;
-        Assert.Equal(!value, control.WebBrowserShortcutsEnabled);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AttachInterfaces_Invoke_Success()
-    {
-        object nativeActiveXObject = null;
-
-        try
-        {
-            Type t = Type.GetTypeFromCLSID(new Guid("0002DF01-0000-0000-C000-000000000046"));
-            nativeActiveXObject = Activator.CreateInstance(t);
-        }
-        catch (COMException)
-        {
-            // Windows doesn't have IE browser capability installed,
-            // run 'Get-WindowsCapability -online' for more details
-            //
-            // xUnit doesn't support dynamic test skipping, https://github.com/xunit/xunit/issues/2073
-            // just return. The test will be marked as success, but it is better than just fail.
-            //
-            //Skip.If(true, "Windows doesn't have IE browser capability installed");
-            return;
-        }
-
-        using var control = new SubWebBrowser();
-        control.AttachInterfaces(nativeActiveXObject);
-
-        // Attach again.
-        control.AttachInterfaces(nativeActiveXObject);
-
-        control.DetachInterfaces();
-
-        // Attach null.
-        control.AttachInterfaces(null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AttachInterfaces_InvokeWithInstance_Success()
-    {
-        object nativeActiveXObject = null;
-
-        try
-        {
-            Type t = Type.GetTypeFromCLSID(new Guid("0002DF01-0000-0000-C000-000000000046"));
-            nativeActiveXObject = Activator.CreateInstance(t);
-        }
-        catch (COMException)
-        {
-            // Windows doesn't have IE browser capability installed,
-            // run 'Get-WindowsCapability -online' for more details
-            //
-            // xUnit doesn't support dynamic test skipping, https://github.com/xunit/xunit/issues/2073
-            // just return. The test will be marked as success, but it is better than just fail.
-            //
-            //Skip.If(true, "Windows doesn't have IE browser capability installed");
-            return;
-        }
-
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.AttachInterfaces(nativeActiveXObject);
-
-        // Attach again.
-        control.AttachInterfaces(nativeActiveXObject);
-
-        control.DetachInterfaces();
-
-        // Attach null.
-        control.AttachInterfaces(null);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_AttachInterfaces_InvalidNativeActiveXObject_ThrowsInvalidCastException()
-    {
-        using var control = new SubWebBrowser();
-        Assert.Throws<InvalidCastException>(() => control.AttachInterfaces(new object()));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_CreateSink_InvokeWithInstance_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-        control.CreateSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        control.CreateSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_CreateSink_InvokeWithoutInstance_Nop(bool allowNavigation)
-    {
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation
-        };
-        control.CreateSink();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        control.CreateSink();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_CreateWebBrowserSiteBase_Invoke_ReturnsExpected()
-    {
-        using var control = new SubWebBrowser();
-        WebBrowserSiteBase siteBase = control.CreateWebBrowserSiteBase();
-        Assert.NotNull(siteBase);
-        Assert.NotSame(siteBase, control.CreateWebBrowserSiteBase());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DetachInterfaces_Invoke_Success()
-    {
-        using var control = new SubWebBrowser();
-        control.DetachInterfaces();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.DetachInterfaces();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_DetachInterfaces_InvokeWithInstance_Success()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-
-        control.DetachInterfaces();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.DetachInterfaces();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_DetachSink_InvokeWithCreatedSink_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-        control.CreateSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        control.DetachSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.DetachSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_DetachSink_InvokeWithInstance_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-
-        control.DetachSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Call again.
-        control.DetachSink();
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_DetachSink_InvokeWithoutInstance_Nop(bool allowNavigation)
-    {
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation
-        };
-        control.DetachSink();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.DetachSink();
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Dispose_Invoke_Success()
-    {
-        using var control = new WebBrowser();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            Assert.Null(control.ActiveXInstance);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowser_Dispose_InvokeWithInstance_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            Assert.Null(control.ActiveXInstance);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose();
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void WebBrowserDispose_InvokeDisposing_Success()
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            Assert.Null(control.ActiveXInstance);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowserDispose_InvokeNotDisposing_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.NotNull(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.NotNull(control.ActiveXInstance);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.NotNull(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.NotNull(control.ActiveXInstance);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void WebBrowserDispose_InvokeDisposingWithInstance_Success(bool allowNavigation)
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            AllowNavigation = allowNavigation,
-            Parent = parent
-        };
-
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsHandleCreated);
-            Assert.True(control.Disposing);
-            Assert.Equal(callCount > 0, control.IsDisposed);
-            Assert.Null(control.ActiveXInstance);
-            callCount++;
-        }
-
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(1, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(true);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.True(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(2, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void WebBrowserDispose_InvokeNotDisposingWithInstance_Success()
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        void handler(object sender, EventArgs e) => callCount++;
-        control.Disposed += handler;
-
-        try
-        {
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-
-            // Dispose multiple times.
-            control.Dispose(false);
-            Assert.Null(control.Parent);
-            Assert.Empty(control.Controls);
-            Assert.Empty(control.DataBindings);
-            Assert.False(control.IsDisposed);
-            Assert.False(control.Disposing);
-            Assert.Null(control.ActiveXInstance);
-            Assert.Equal(0, callCount);
-            Assert.False(control.IsHandleCreated);
-        }
-        finally
-        {
-            control.Disposed -= handler;
-        }
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubWebBrowser();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void WebBrowser_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubWebBrowser();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoBack_InvokeCantGoBack_Nop()
-    {
-        using var control = new WebBrowser();
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        Assert.False(control.GoBack());
-        Assert.Null(control.Url);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoBack_InvokeCantGoBackWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        Assert.False(control.GoBack());
-        Assert.Null(control.Url);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_GoBack_Invoke_CallsCanGoBackChanged()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            canGoBackChangedCallCount++;
-        };
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            canGoForwardChangedCallCount++;
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file1 = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file1.Path));
-        Assert.True(await source.Task);
-        Assert.False(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Navigate.
-        using var file2 = CreateTempFile(Html);
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file2.Path));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Navigate again.
-        using var file3 = CreateTempFile(Html);
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file3.Path));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Go back.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => Assert.True(control.GoBack()));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.True(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(1, canGoForwardChangedCallCount);
-
-        // Go back again.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => Assert.True(control.GoBack()));
-        Assert.True(await source.Task);
-        Assert.False(control.CanGoBack);
-        Assert.True(control.CanGoForward);
-        Assert.Equal(2, canGoBackChangedCallCount);
-        Assert.Equal(1, canGoForwardChangedCallCount);
-
-        // Go back again.
-        Assert.False(control.GoBack());
-        Assert.False(control.CanGoBack);
-        Assert.True(control.CanGoForward);
-        Assert.Equal(2, canGoBackChangedCallCount);
-        Assert.Equal(1, canGoForwardChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoBack_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.False(control.GoBack());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoForward_InvokeCantGoForward_Nop()
-    {
-        using var control = new WebBrowser();
-        Assert.False(control.GoForward());
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoForward_InvokeCantGoForwardWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        Assert.False(control.GoForward());
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_GoForward_Invoke_CallsCanGoForwardChanged()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            canGoBackChangedCallCount++;
-        };
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            canGoForwardChangedCallCount++;
-        };
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file1 = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file1.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Navigate.
-        using var file2 = CreateTempFile(Html);
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file2.Path));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Navigate again.
-        using var file3 = CreateTempFile(Html);
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file3.Path));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Go back.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => Assert.True(control.GoBack()));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.True(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(1, canGoForwardChangedCallCount);
-
-        // Go forward.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => Assert.True(control.GoForward()));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(2, canGoForwardChangedCallCount);
-
-        // Go forward again.
-        Assert.False(control.GoForward());
-        Assert.True(control.CanGoBack);
-        Assert.False(control.CanGoForward);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(2, canGoForwardChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoForward_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.False(control.GoForward());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoHome_InvokeCantGoHome_Nop()
-    {
-        using var control = new WebBrowser();
-        control.GoHome();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoHome_InvokeCantGoHomeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.GoHome();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoHome_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.GoHome());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoHome_InvokeDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.GoHome());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoSearch_InvokeCantGoSearch_Nop()
-    {
-        using var control = new WebBrowser();
-        control.GoSearch();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoSearch_InvokeCantGoSearchWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.GoSearch();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoSearch_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.GoSearch());
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_GoSearch_InvokeDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.GoSearch());
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Navigate_InvokeString_CallsMethods()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            Assert.Empty(e.TargetFrameName);
-            Assert.False(e.Cancel);
-            navigatingCallCount++;
-        };
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            navigatedCallCount++;
-        };
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            documentTitleChangedCallCount++;
-        };
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            documentCompletedCallCount++;
-            source.SetResult(true);
-        };
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            encryptionLevelChangedCallCount++;
-        };
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            statusTextChangedCallCount++;
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(1, navigatingCallCount);
-        Assert.Equal(1, navigatedCallCount);
-        Assert.Equal(2, documentTitleChangedCallCount);
-        Assert.Equal(1, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-
-        // Call again
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(2, navigatingCallCount);
-        Assert.Equal(2, navigatedCallCount);
-        Assert.Equal(4, documentTitleChangedCallCount);
-        Assert.Equal(2, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-    }
-
-    [WinFormsTheory]
-    [NullAndEmptyStringData]
-    public async Task WebBrowser_Navigate_NullOrEmptyString_GoesToBlank(string nullOrEmptyString)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        await Task.Run(() => control.Navigate(new Uri(file.Path)));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(nullOrEmptyString));
-        Assert.True(await source.Task);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Navigate_InvokeUri_CallsMethods()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            Assert.Empty(e.TargetFrameName);
-            Assert.False(e.Cancel);
-            navigatingCallCount++;
-        };
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            navigatedCallCount++;
-        };
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            documentTitleChangedCallCount++;
-        };
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(new Uri(file.Path), e.Url);
-            documentCompletedCallCount++;
-            source.SetResult(true);
-        };
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            encryptionLevelChangedCallCount++;
-        };
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            statusTextChangedCallCount++;
-        };
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        await Task.Run(() => control.Navigate(new Uri(file.Path)));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(1, navigatingCallCount);
-        Assert.Equal(1, navigatedCallCount);
-        Assert.Equal(2, documentTitleChangedCallCount);
-        Assert.Equal(1, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-
-        // Call again.
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(new Uri(file.Path)));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(2, navigatingCallCount);
-        Assert.Equal(2, navigatedCallCount);
-        Assert.Equal(4, documentTitleChangedCallCount);
-        Assert.Equal(2, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount > 0);
-        Assert.True(statusTextChangedCallCount > 0);
-    }
-
-    public static IEnumerable<object[]> Navigate_NullOrEmptyUri_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new Uri("", UriKind.Relative) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Navigate_NullOrEmptyUri_TestData))]
-    public async Task WebBrowser_Navigate_NullOrEmptyUri_GoesToBlank(Uri nullOrEmptyUri)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-
-        await Task.Run(() => control.Navigate(new Uri(file.Path)));
-        Assert.True(await source.Task);
-        Assert.Equal(new Uri(file.Path), control.Url);
-
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(nullOrEmptyUri));
-        Assert.True(await source.Task);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Navigate_InvokeWithDocument_CallsCanGoBackChanged()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        var source = new TaskCompletionSource<bool>();
-        control.DocumentCompleted += (sender, e) => source.SetResult(true);
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            canGoBackChangedCallCount++;
-        };
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file1 = CreateTempFile(Html);
-        await Task.Run(() => control.Navigate(file1.Path));
-        Assert.True(await source.Task);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-
-        // Navigate again.
-        using var file2 = CreateTempFile(Html);
-        source = new TaskCompletionSource<bool>();
-        await Task.Run(() => control.Navigate(file2.Path));
-        Assert.True(await source.Task);
-        Assert.True(control.CanGoBack);
-        Assert.Equal(1, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Navigate_RelativeUri_ThrowsArgumentException()
-    {
-        using var control = new WebBrowser();
-        var relativeUri = new Uri("/path", UriKind.Relative);
-        Assert.Throws<ArgumentException>(() => control.Navigate(relativeUri));
-        Assert.Throws<ArgumentException>(() => control.Navigate(relativeUri, "targetFrameName"));
-        Assert.Throws<ArgumentException>(() => control.Navigate(relativeUri, false));
-        Assert.Throws<ArgumentException>(() => control.Navigate(relativeUri, "targetFrameName", null, null));
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Navigate_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.Navigate("about:blank"));
-        Assert.Throws<ObjectDisposedException>(() => control.Navigate(new Uri("http://google.com")));
-        Assert.Throws<ObjectDisposedException>(() => control.Navigate(new Uri("http://google.com"), "targetFrameName"));
-        Assert.Throws<ObjectDisposedException>(() => control.Navigate(new Uri("http://google.com"), false));
-        Assert.Throws<ObjectDisposedException>(() => control.Navigate(new Uri("http://google.com"), "targetFrameName", null, null));
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Navigate_InvokeDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.Navigate("about:blank"));
-        Assert.Throws<InvalidOperationException>(() => control.Navigate(new Uri("http://google.com")));
-        Assert.Throws<InvalidOperationException>(() => control.Navigate(new Uri("http://google.com"), "targetFrameName"));
-        Assert.Throws<InvalidOperationException>(() => control.Navigate(new Uri("http://google.com"), false));
-        Assert.Throws<InvalidOperationException>(() => control.Navigate(new Uri("http://google.com"), "targetFrameName", null, null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnCanGoBackChanged_Invoke_CallsCanGoBackChanged(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CanGoBackChanged += handler;
-        control.OnCanGoBackChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.CanGoBackChanged -= handler;
-        control.OnCanGoBackChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnCanGoForwardChanged_Invoke_CallsCanGoForwardChanged(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.CanGoForwardChanged += handler;
-        control.OnCanGoForwardChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.CanGoForwardChanged -= handler;
-        control.OnCanGoForwardChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnDocumentCompleted_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new WebBrowserDocumentCompletedEventArgs(null) };
-        yield return new object[] { new WebBrowserDocumentCompletedEventArgs(new Uri("http://microsoft.com")) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDocumentCompleted_TestData))]
-    public void WebBrowser_OnDocumentCompleted_Invoke_CallsDocumentCompleted(WebBrowserDocumentCompletedEventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        WebBrowserDocumentCompletedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DocumentCompleted += handler;
-        control.OnDocumentCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.DocumentCompleted -= handler;
-        control.OnDocumentCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnDocumentCompleted_WithInstance_TestData()
-    {
-        foreach (bool allowWebBrowserDrop in new bool[] { true, false })
-        {
-            yield return new object[] { allowWebBrowserDrop, null };
-            yield return new object[] { allowWebBrowserDrop, new WebBrowserDocumentCompletedEventArgs(null) };
-            yield return new object[] { allowWebBrowserDrop, new WebBrowserDocumentCompletedEventArgs(new Uri("http://microsoft.com")) };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnDocumentCompleted_WithInstance_TestData))]
-    public void WebBrowser_OnDocumentCompleted_InvokeWithInstance_CallsDocumentCompleted(bool allowWebBrowserDrop, WebBrowserDocumentCompletedEventArgs eventArgs)
-    {
-        var parent = new Control();
-        var control = new SubWebBrowser
-        {
-            Parent = parent,
-            AllowWebBrowserDrop = allowWebBrowserDrop
-        };
-
-        int callCount = 0;
-        WebBrowserDocumentCompletedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-        ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget = !allowWebBrowserDrop;
-
-        // Call with handler.
-        control.DocumentCompleted += handler;
-        control.OnDocumentCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(!allowWebBrowserDrop, ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.DocumentCompleted -= handler;
-        control.OnDocumentCompleted(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.Equal(!allowWebBrowserDrop, ((IWebBrowser2)control.ActiveXInstance).RegisterAsDropTarget);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_OnDocumentCompleted_InvokeDisposed_ThrowsObjectDisposedException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.OnDocumentCompleted(null));
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_OnDocumentCompleted_InvokeDetached_ThrowsInvalidOperationException()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowser
-        {
-            Parent = parent
-        };
-        control.DetachInterfaces();
-        Assert.Throws<InvalidOperationException>(() => control.OnDocumentCompleted(null));
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnDocumentTitleChanged_Invoke_CallsDocumentTitleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DocumentTitleChanged += handler;
-        control.OnDocumentTitleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.DocumentTitleChanged -= handler;
-        control.OnDocumentTitleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnEncryptionLevelChanged_Invoke_CallsEncryptionLevelChanged(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.EncryptionLevelChanged += handler;
-        control.OnEncryptionLevelChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.EncryptionLevelChanged -= handler;
-        control.OnEncryptionLevelChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnFileDownload_Invoke_CallsFileDownload(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FileDownload += handler;
-        control.OnFileDownload(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.FileDownload -= handler;
-        control.OnFileDownload(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnNavigated_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new WebBrowserNavigatedEventArgs(null) };
-        yield return new object[] { new WebBrowserNavigatedEventArgs(new Uri("http://microsoft.com")) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnNavigated_TestData))]
-    public void WebBrowser_OnNavigated_Invoke_CallsNavigated(WebBrowserNavigatedEventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        WebBrowserNavigatedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Navigated += handler;
-        control.OnNavigated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Navigated -= handler;
-        control.OnNavigated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnNavigating_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new WebBrowserNavigatingEventArgs(null, null) };
-        yield return new object[] { new WebBrowserNavigatingEventArgs(new Uri("http://microsoft.com"), "targetFrameName") };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnNavigating_TestData))]
-    public void WebBrowser_OnNavigating_Invoke_CallsNavigating(WebBrowserNavigatingEventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        WebBrowserNavigatingEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Navigating += handler;
-        control.OnNavigating(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.Navigating -= handler;
-        control.OnNavigating(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnNewWindow_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new CancelEventArgs(false) };
-        yield return new object[] { new CancelEventArgs(true) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnNewWindow_TestData))]
-    public void WebBrowser_OnNewWindow_Invoke_CallsNewWindow(CancelEventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        CancelEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.NewWindow += handler;
-        control.OnNewWindow(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.NewWindow -= handler;
-        control.OnNewWindow(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnProgressChanged_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new WebBrowserProgressChangedEventArgs(-1, -2) };
-        yield return new object[] { new WebBrowserProgressChangedEventArgs(2, 1) };
-        yield return new object[] { new WebBrowserProgressChangedEventArgs(1, 100) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnProgressChanged_TestData))]
-    public void WebBrowser_OnProgressChanged_Invoke_CallsProgressChanged(WebBrowserProgressChangedEventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        WebBrowserProgressChangedEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ProgressChanged += handler;
-        control.OnProgressChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.ProgressChanged -= handler;
-        control.OnProgressChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void WebBrowser_OnStatusTextChanged_Invoke_CallsStatusTextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubWebBrowser();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.StatusTextChanged += handler;
-        control.OnStatusTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.StatusTextChanged -= handler;
-        control.OnStatusTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Null(control.ActiveXInstance);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Print_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.Print();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Refresh_InvokeCantRefresh_Nop()
-    {
-        using var control = new WebBrowser();
-        control.Refresh();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Refresh_InvokeCantRefreshWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.Refresh();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Refresh_InvokeWithDocument_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        void oldHandler(object sender, WebBrowserDocumentCompletedEventArgs e) => source.SetResult(true);
-        control.DocumentCompleted += oldHandler;
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-        control.DocumentCompleted -= oldHandler;
-
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) => navigatingCallCount++;
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) => navigatedCallCount++;
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) => documentTitleChangedCallCount++;
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) => documentCompletedCallCount++;
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) => encryptionLevelChangedCallCount++;
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) => statusTextChangedCallCount++;
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        control.Refresh();
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount >= 0);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount >= 0);
-        Assert.True(statusTextChangedCallCount >= 0);
-
-        // Call again
-        control.Refresh();
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount >= 0);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount >= 0);
-        Assert.True(statusTextChangedCallCount >= 0);
-    }
-
-    [WinFormsFact]
-    public async Task WebBrowser_Refresh_InvokeWithDocumentText_Success()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        void oldHandler(object sender, WebBrowserDocumentCompletedEventArgs e) => source.SetResult(true);
-        control.DocumentCompleted += oldHandler;
-        await Task.Run(() => control.DocumentText = Html);
-        Assert.True(await source.Task);
-        control.DocumentCompleted -= oldHandler;
-
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) => navigatingCallCount++;
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) => navigatedCallCount++;
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) => documentTitleChangedCallCount++;
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) => documentCompletedCallCount++;
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) => encryptionLevelChangedCallCount++;
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) => statusTextChangedCallCount++;
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        control.Refresh();
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.Equal(0, documentTitleChangedCallCount);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.Equal(0, encryptionLevelChangedCallCount);
-        Assert.Equal(0, statusTextChangedCallCount);
-
-        // Call again
-        control.Refresh();
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.Equal(0, documentTitleChangedCallCount);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.Equal(0, encryptionLevelChangedCallCount);
-        Assert.Equal(0, statusTextChangedCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<WebBrowserRefreshOption>]
-    [InvalidEnumData<WebBrowserRefreshOption>]
-    public void WebBrowser_Refresh_InvokeWebBrowserRefreshOptionCantRefresh_Nop(WebBrowserRefreshOption opt)
-    {
-        using var control = new WebBrowser();
-        control.Refresh(opt);
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<WebBrowserRefreshOption>]
-    [InvalidEnumData<WebBrowserRefreshOption>]
-    public void WebBrowser_Refresh_InvokeWebBrowserRefreshOptionCantRefreshWithInstance_Nop(WebBrowserRefreshOption opt)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.Refresh(opt);
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<WebBrowserRefreshOption>]
-    [InvalidEnumData<WebBrowserRefreshOption>]
-    public async Task WebBrowser_Refresh_InvokeWebBrowserRefreshOptionWithDocument_Success(WebBrowserRefreshOption opt)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        void oldHandler(object sender, WebBrowserDocumentCompletedEventArgs e) => source.SetResult(true);
-        control.DocumentCompleted += oldHandler;
-        await Task.Run(() => control.Navigate(file.Path));
-        Assert.True(await source.Task);
-        control.DocumentCompleted -= oldHandler;
-
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) => navigatingCallCount++;
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) => navigatedCallCount++;
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) => documentTitleChangedCallCount++;
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) => documentCompletedCallCount++;
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) => encryptionLevelChangedCallCount++;
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) => statusTextChangedCallCount++;
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        control.Refresh(opt);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount >= 0);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount >= 0);
-        Assert.True(statusTextChangedCallCount >= 0);
-
-        // Call again
-        control.Refresh(opt);
-        Assert.Equal(new Uri(file.Path), control.Url);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.True(documentTitleChangedCallCount >= 0);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.True(encryptionLevelChangedCallCount >= 0);
-        Assert.True(statusTextChangedCallCount >= 0);
-    }
-
-    [WinFormsTheory]
-    [EnumData<WebBrowserRefreshOption>]
-    [InvalidEnumData<WebBrowserRefreshOption>]
-    public async Task WebBrowser_Refresh_InvokeWebBrowserRefreshOptionWithDocumentText_Success(WebBrowserRefreshOption opt)
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        const string Html = "<html><head><title>NewDocument</title></head></html>";
-        using var file = CreateTempFile(Html);
-        var source = new TaskCompletionSource<bool>();
-        void oldHandler(object sender, WebBrowserDocumentCompletedEventArgs e) => source.SetResult(true);
-        control.DocumentCompleted += oldHandler;
-        await Task.Run(() => control.DocumentText = Html);
-        Assert.True(await source.Task);
-        control.DocumentCompleted -= oldHandler;
-
-        int navigatingCallCount = 0;
-        control.Navigating += (sender, e) => navigatingCallCount++;
-        int navigatedCallCount = 0;
-        control.Navigated += (sender, e) => navigatedCallCount++;
-        int documentTitleChangedCallCount = 0;
-        control.DocumentTitleChanged += (sender, e) => documentTitleChangedCallCount++;
-        int documentCompletedCallCount = 0;
-        control.DocumentCompleted += (sender, e) => documentCompletedCallCount++;
-        int encryptionLevelChangedCallCount = 0;
-        control.EncryptionLevelChanged += (sender, e) => encryptionLevelChangedCallCount++;
-        int statusTextChangedCallCount = 0;
-        control.StatusTextChanged += (sender, e) => statusTextChangedCallCount++;
-        int canGoBackChangedCallCount = 0;
-        control.CanGoBackChanged += (sender, e) => canGoBackChangedCallCount++;
-        int canGoForwardChangedCallCount = 0;
-        control.CanGoForwardChanged += (sender, e) => canGoForwardChangedCallCount++;
-
-        control.Refresh(opt);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.Equal(0, documentTitleChangedCallCount);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.Equal(0, encryptionLevelChangedCallCount);
-        Assert.Equal(0, statusTextChangedCallCount);
-
-        // Call again
-        control.Refresh(opt);
-        Assert.Equal("about:blank", control.Url.OriginalString);
-        Assert.Equal(0, navigatingCallCount);
-        Assert.Equal(0, navigatedCallCount);
-        Assert.Equal(0, documentTitleChangedCallCount);
-        Assert.Equal(0, documentCompletedCallCount);
-        Assert.Equal(0, canGoBackChangedCallCount);
-        Assert.Equal(0, canGoForwardChangedCallCount);
-        Assert.Equal(0, encryptionLevelChangedCallCount);
-        Assert.Equal(0, statusTextChangedCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Refresh_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.Refresh();
-        control.Refresh(WebBrowserRefreshOption.Normal);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPageSetupDialog_Invoke_Nop()
-    {
-        using var control = new WebBrowser();
-        control.ShowPageSetupDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPageSetupDialog_InvokeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ShowPageSetupDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPageSetupDialog_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.ShowPageSetupDialog();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintDialog_Invoke_Nop()
-    {
-        using var control = new WebBrowser();
-        control.ShowPrintDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintDialog_InvokeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ShowPrintDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintDialog_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.ShowPrintDialog();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintPreviewDialog_Invoke_Nop()
-    {
-        using var control = new WebBrowser();
-        control.ShowPrintPreviewDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintPreviewDialog_InvokeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ShowPrintPreviewDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPrintPreviewDialog_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.ShowPrintPreviewDialog();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPropertiesDialog_Invoke_Nop()
-    {
-        using var control = new WebBrowser();
-        control.ShowPropertiesDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPropertiesDialog_InvokeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ShowPropertiesDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowPropertiesDialog_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.ShowPropertiesDialog();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowSaveAsDialog_Invoke_Nop()
-    {
-        using var control = new WebBrowser();
-        control.ShowSaveAsDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowSaveAsDialog_InvokeWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.ShowSaveAsDialog();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_ShowSaveAsDialog_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.ShowSaveAsDialog();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Stop_InvokeCantStop_Nop()
-    {
-        using var control = new WebBrowser();
-        control.Stop();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Stop_InvokeCantStopWithInstance_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-
-        control.Stop();
-        Assert.Null(control.Url);
-        Assert.NotNull(control.ActiveXInstance);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_Stop_InvokeDisposed_Nop()
-    {
-        using var parent = new Control();
-        using var control = new WebBrowser
-        {
-            Parent = parent
-        };
-        control.Dispose();
-        control.Stop();
-    }
-
-    [WinFormsFact]
-    public void WebBrowser_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubWebBrowser();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        ((Control)control).MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithoutContextMenuStrip_TestData()
-    {
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2) };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2) };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2) };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void WebBrowser_WndProc_InvokeContextMenuWithoutContextMenuStripWithoutHandle_Success(Size size, IntPtr lParam)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubWebBrowser
-            {
-                Size = size
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1), (IntPtr)250, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0), IntPtr.Zero, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2), IntPtr.Zero, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250, true };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2), (IntPtr)250, true };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1), IntPtr.Zero, false };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(p.X, p.Y), IntPtr.Zero, true };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData))]
-    public void WebBrowser_WndProc_InvokeContextMenuWithContextMenuStripWithoutHandle_Success(Size size, IntPtr lParam, IntPtr expectedResult, bool expectedHandleCreated)
-    {
-        using (new NoAssertContext())
-        {
-            using var menu = new ContextMenuStrip();
-            using var control = new SubWebBrowser
-            {
-                ContextMenuStrip = menu,
-                Size = size
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(menu.Visible);
-            Assert.Equal(expectedResult == (IntPtr)250, menu.SourceControl == control);
-            Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void WebBrowser_WndProc_InvokeContextMenuWithoutContextMenuStripWithHandle_Success(Size size, IntPtr lParam)
-    {
-        using var control = new SubWebBrowser
-        {
-            Size = size
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        yield return new object[] { new Size(10, 20), (IntPtr)(-1), (IntPtr)250 };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(0, 0), IntPtr.Zero };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(1, 2), IntPtr.Zero };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250 };
-        yield return new object[] { new Size(10, 20), PARAM.FromLowHigh(-1, -2), (IntPtr)250 };
-
-        yield return new object[] { Size.Empty, (IntPtr)(-1), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(0, 0), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(1, 2), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(p.X, p.Y), IntPtr.Zero };
-        yield return new object[] { Size.Empty, PARAM.FromLowHigh(-1, -2), IntPtr.Zero };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithHandle_TestData))]
-    public void WebBrowser_WndProc_InvokeContextMenuWithContextMenuStripWithHandle_Success(Size size, IntPtr lParam, IntPtr expectedResult)
-    {
-        using var menu = new ContextMenuStrip();
-        using var control = new SubWebBrowser
-        {
-            ContextMenuStrip = menu,
-            Size = size
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.False(menu.Visible);
-        Assert.Equal(expectedResult == (IntPtr)250, menu.SourceControl == control);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private static TempFile CreateTempFile(string html)
-    {
-        byte[] data = Encoding.UTF8.GetBytes(html);
-        return TempFile.Create(data);
-    }
-
-    private class PrivateClass
-    {
-    }
-
-#pragma warning disable CS0618
-    // This class must be ComVisible because WebBrowser scripting requires IDispatch and ITypeInfo support.
-    [ComVisible(true)]
-    [ClassInterface(ClassInterfaceType.AutoDispatch)]
-#pragma warning restore CS0618
-    public class CustomScriptingObject
-    {
-    }
-
-    private class SubWebBrowser : WebBrowser
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new void AttachInterfaces(object nativeActiveXObject) => base.AttachInterfaces(nativeActiveXObject);
-
-        public new void CreateSink() => base.CreateSink();
-
-        public new WebBrowserSiteBase CreateWebBrowserSiteBase() => base.CreateWebBrowserSiteBase();
-
-        public new void DetachInterfaces() => base.DetachInterfaces();
-
-        public new void DetachSink() => base.DetachSink();
-
-        public new void Dispose(bool disposing) => base.Dispose(disposing);
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new void OnCanGoBackChanged(EventArgs e) => base.OnCanGoBackChanged(e);
-
-        public new void OnCanGoForwardChanged(EventArgs e) => base.OnCanGoForwardChanged(e);
-
-        public new void OnDocumentCompleted(WebBrowserDocumentCompletedEventArgs e) => base.OnDocumentCompleted(e);
-
-        public new void OnDocumentTitleChanged(EventArgs e) => base.OnDocumentTitleChanged(e);
-
-        public new void OnEncryptionLevelChanged(EventArgs e) => base.OnEncryptionLevelChanged(e);
-
-        public new void OnFileDownload(EventArgs e) => base.OnFileDownload(e);
-
-        public new void OnNavigated(WebBrowserNavigatedEventArgs e) => base.OnNavigated(e);
-
-        public new void OnNavigating(WebBrowserNavigatingEventArgs e) => base.OnNavigating(e);
-
-        public new void OnNewWindow(CancelEventArgs e) => base.OnNewWindow(e);
-
-        public new void OnProgressChanged(WebBrowserProgressChangedEventArgs e) => base.OnProgressChanged(e);
-
-        public new void OnStatusTextChanged(EventArgs e) => base.OnStatusTextChanged(e);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WindowsFormsSynchronizationContextTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WindowsFormsSynchronizationContextTests.cs
deleted file mode 100644
index d521b6d40c0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/WindowsFormsSynchronizationContextTests.cs
+++ /dev/null
@@ -1,151 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class WindowsFormsSynchronizationContextTests
-{
-    [WinFormsFact]
-    public void WindowsFormsSynchronizationContext_CreateCopy_Invoke_Success()
-    {
-        var context = new WindowsFormsSynchronizationContext();
-        WindowsFormsSynchronizationContext copy = Assert.IsType<WindowsFormsSynchronizationContext>(context.CreateCopy());
-        Assert.NotSame(context, copy);
-
-        // Send something.
-        object state = new();
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) =>
-        {
-            Assert.Same(state, actualState);
-            callCount++;
-        };
-        copy.Send(callback, state);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        copy.Send(callback, state);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact(Skip = "WindowsFormsSynchronizationContext disposed of too early. See: https://github.com/dotnet/winforms/issues/3297")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3297")]
-    public void WindowsFormsSynchronizationContext_Dispose_MultipleTimes_Success()
-    {
-        var context = new WindowsFormsSynchronizationContext();
-        int callCount = 0;
-        SendOrPostCallback callback = (state) => callCount++;
-        context.Dispose();
-        context.Send(callback, new object());
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        context.Dispose();
-        context.Send(callback, new object());
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> Send_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Send_TestData))]
-    public void WindowsFormsSynchronizationContext_Send_InvokeSameThread_Success(object state)
-    {
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) =>
-        {
-            Assert.Same(state, actualState);
-            callCount++;
-        };
-        var context = new WindowsFormsSynchronizationContext();
-        context.Send(callback, state);
-        Assert.Equal(1, callCount);
-
-        // Call again.
-        context.Send(callback, state);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void WindowsFormsSynchronizationContext_Send_InvokeDeletedThread_ThrowsInvalidAsynchronousStateException()
-    {
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) => callCount++;
-        WindowsFormsSynchronizationContext context = null;
-        Thread thread = new Thread(() =>
-        {
-            context = new WindowsFormsSynchronizationContext();
-        });
-        thread.Start();
-        thread.Join();
-        Assert.Throws<InvalidAsynchronousStateException>(() => context.Send(callback, new object()));
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory(Skip = "WindowsFormsSynchronizationContext disposed of too early. See: https://github.com/dotnet/winforms/issues/3297")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3297")]
-    [MemberData(nameof(Send_TestData))]
-    public void WindowsFormsSynchronizationContext_Send_InvokeDisposed_Nop(object state)
-    {
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) => callCount++;
-        var context = new WindowsFormsSynchronizationContext();
-        context.Dispose();
-
-        context.Send(callback, state);
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        context.Send(callback, state);
-        Assert.Equal(0, callCount);
-    }
-
-    public static IEnumerable<object[]> Post_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new object() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Post_TestData))]
-    public void WindowsFormsSynchronizationContext_Post_InvokeSameThread_Success(object state)
-    {
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) =>
-        {
-            Assert.Same(state, actualState);
-            callCount++;
-        };
-        var context = new WindowsFormsSynchronizationContext();
-        context.Post(callback, state);
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        context.Post(callback, state);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory(Skip = "WindowsFormsSynchronizationContext disposed of too early. See: https://github.com/dotnet/winforms/issues/3297")]
-    [ActiveIssue("https://github.com/dotnet/winforms/issues/3297")]
-    [MemberData(nameof(Send_TestData))]
-    public void WindowsFormsSynchronizationContext_Post_InvokeDisposed_Nop(object state)
-    {
-        int callCount = 0;
-        SendOrPostCallback callback = (actualState) => callCount++;
-        var context = new WindowsFormsSynchronizationContext();
-        context.Dispose();
-
-        context.Post(callback, state);
-        Assert.Equal(0, callCount);
-
-        // Call again.
-        context.Post(callback, state);
-        Assert.Equal(0, callCount);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestAccessorTests.cs b/src/System.Windows.Forms/tests/UnitTests/TestAccessorTests.cs
deleted file mode 100644
index 190781eaa21..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TestAccessorTests.cs
+++ /dev/null
@@ -1,234 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.CSharp.RuntimeBinder;
-
-namespace System.Windows.Forms.Tests;
-
-public class TestAccessorTests
-{
-    [Fact]
-    public void TestAccessor_DynamicAccess_InstanceField()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-        access._integer = 5;
-        Assert.Equal(5, access._integer);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_StaticField()
-    {
-        // Don't need to create an instance to access a static, can
-        // use typeof instead
-        dynamic access = typeof(PrivateTestClass).TestAccessor().Dynamic;
-        access.s_integer = 16;
-        Assert.Equal(16, access.s_integer);
-
-        // Attempt using an instance as well
-        var testClass = new PrivateTestClass();
-        access = testClass.TestAccessor().Dynamic;
-        access.s_integer = 18;
-        Assert.Equal(18, access.s_integer);
-
-        // Try the static class version
-        access = typeof(PrivateStaticTestClass).TestAccessor().Dynamic;
-        access.s_integer = 21;
-        Assert.Equal(21, access.s_integer);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_ReadOnlyInstanceField()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-        access._readOnlyInteger = 7;
-        Assert.Equal(7, access._readOnlyInteger);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_ObjectInstanceField()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-        List<string> list = access._list;
-        Assert.NotNull(list);
-        Assert.Single(list);
-        Assert.Equal("42", list[0]);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_InstanceProperty()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-        access.Long = 1970;
-        Assert.Equal(1970, access.Long);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_StaticProperty()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-        access.Int = 1989;
-        Assert.Equal(1989, access.Int);
-
-        // Now try without an instance
-        access = typeof(PrivateTestClass).TestAccessor().Dynamic;
-        access.Int = 1988;
-        Assert.Equal(1988, access.Int);
-
-        // Try the static class version
-        access = typeof(PrivateStaticTestClass).TestAccessor().Dynamic;
-        access.Int = 1991;
-        Assert.Equal(1991, access.Int);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_PublicField()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-
-        // If the API is public we want to access "normally", so we prevent this.
-        Assert.Throws<RuntimeBinderException>(() => access.PublicField = 1918);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_PublicProperty()
-    {
-        var testClass = new PrivateTestClass();
-        dynamic access = testClass.TestAccessor().Dynamic;
-
-        // If the API is public we want to access "normally", so we prevent this.
-        Assert.Throws<RuntimeBinderException>(() => access.PublicProperty = "What?");
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_InstanceMethod()
-    {
-        var testClass = new PrivateTestClass();
-        Assert.Equal(4, testClass.TestAccessor().Dynamic.ToStringLength(2001));
-        Assert.Equal(7, testClass.TestAccessor().Dynamic.ToStringLength("Flubber"));
-    }
-
-    [Fact]
-    public void TestAccessor_FuncDelegateAccess_InstanceMethod()
-    {
-        var testClass = new PrivateTestClass();
-        ITestAccessor accessor = testClass.TestAccessor();
-        Assert.Equal(4, accessor.CreateDelegate<Func<int, int>>("ToStringLength")(2001));
-        Assert.Equal(7, accessor.CreateDelegate<Func<string, int>>("ToStringLength")("Flubber"));
-    }
-
-    [Fact]
-    public void TestAccessor_NamedDelegateAccess_InstanceMethod()
-    {
-        var testClass = new PrivateTestClass();
-        ITestAccessor accessor = testClass.TestAccessor();
-        Assert.Equal(5, accessor.CreateDelegate<ToStringLength>()("25624"));
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_StaticMethod()
-    {
-        var testClass = new PrivateTestClass();
-        Assert.Equal(2, testClass.TestAccessor().Dynamic.AddOne(1));
-
-        // Hit the static class version
-        Assert.Equal(3, typeof(PrivateStaticTestClass).TestAccessor().Dynamic.AddOne(2));
-    }
-
-    [Fact]
-    public void TestAccessor_FuncDelegateAccess_StaticMethod()
-    {
-        var testClass = new PrivateTestClass();
-        Assert.Equal(2000, testClass.TestAccessor().CreateDelegate<Func<int, int>>("AddOne")(1999));
-
-        // Hit the static class version
-        Assert.Equal(21, typeof(PrivateStaticTestClass).TestAccessor().CreateDelegate<Func<int, int>>("AddOne")(20));
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_UpcastType()
-    {
-        A a = new B();
-        dynamic accessor = a.TestAccessor().Dynamic;
-        accessor._b = 3;
-        Assert.Equal(3, accessor._b);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_BaseClassField()
-    {
-        A a = new B();
-        dynamic accessor = a.TestAccessor().Dynamic;
-        accessor._a = 5;
-        Assert.Equal(5, accessor._a);
-    }
-
-    [Fact]
-    public void TestAccessor_DynamicAccess_BaseClassMethod()
-    {
-        A a = new B();
-        dynamic accessor = a.TestAccessor().Dynamic;
-        Assert.Equal(42, (int)accessor.AMethod());
-    }
-
-    // As you can't use a ref struct as a generic parameter to Action/Func, you
-    // need to use a defined delegate to access an internal method that takes
-    // or returns a ref struct (such as Spans).
-
-    public delegate int ToStringLength(ReadOnlySpan<char> value);
-
-#pragma warning disable IDE0044   // use readonly
-#pragma warning disable IDE0051   // unaccessed private
-#pragma warning disable IDE0052   // unaccessed private
-#pragma warning disable CS0169    // unused field
-#pragma warning disable CA1823    // unused field
-
-    public class A
-    {
-        private int AMethod() => 42;
-        private int _a;
-    }
-
-    public class B : A
-    {
-        private int _b;
-    }
-
-    public class PrivateTestClass
-    {
-        private int _integer;
-        private readonly int _readOnlyInteger;
-        private List<string> _list = new() { "42" };
-
-        private long Long { get; set; }
-
-        public float PublicField;
-        public string PublicProperty { get; set; }
-
-        // It is important that we have multiple methods with the same name for testing.
-        private int ToStringLength(int value) => ToStringLength(value.ToString());
-        private int ToStringLength(string value) => value.Length;
-        private int ToStringLength(ReadOnlySpan<char> value) => value.Length;
-
-        private static int s_integer;
-        private static int Int { get; set; }
-
-        private static int AddOne(int value) => value + 1;
-    }
-
-    public static class PrivateStaticTestClass
-    {
-        private static int s_integer;
-        private static int Int { get; set; }
-        private static int AddOne(int value) => value + 1;
-    }
-#pragma warning restore IDE0044
-#pragma warning restore IDE0051
-#pragma warning restore CS0169
-#pragma warning restore CA1823
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources.resx b/src/System.Windows.Forms/tests/UnitTests/TestResources.resx
deleted file mode 100644
index 20d70228094..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TestResources.resx
+++ /dev/null
@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <data name="SomeMetadataTest1" xml:space="preserve">
-    <value>Some text for MetaData 1 node</value>
-  </data>
-  <data name="SomeMetadataTest2" xml:space="preserve">
-    <value>Some text for MetaData 2 node</value>
-    <comment>Some comment for MetaData 2 node</comment>
-  </data>
-  <data name="SomeDataTest1" xml:space="preserve">
-    <value>Some text for Data 1 node</value>
-  </data>
-  <data name="SomeDataTest2" xml:space="preserve">
-    <value>Some text for Data 2 node</value>
-    <comment>Some comment for Data 2 node</comment>
-  </data>
-  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="Error" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>TestResources//Files//Error.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="ErrorControl" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>TestResources//Files//ErrorControl.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
-  </data>
-  <data name="text.ansi" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>TestResources//Files//text.ansi.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;us-ascii</value>
-  </data>
-  <data name="text.utf8" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>TestResources//Files//text.utf8.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
-  </data>
-</root>
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/ComClasses.cs b/src/System.Windows.Forms/tests/UnitTests/TestResources/ComClasses.cs
deleted file mode 100644
index fefc59c4f58..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TestResources/ComClasses.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable enable
-
-using System.Runtime.InteropServices;
-using Windows.Win32.System.Com;
-
-namespace System.Windows.Forms.Tests.TestResources;
-
-internal static class ComClasses
-{
-    public static ComClassFactory? VisualBasicSimpleControl { get; }
-        = RuntimeInformation.ProcessArchitecture == Architecture.X86
-            ? new ComClassFactory(
-                // This is actually a .ocx
-                Path.GetFullPath(@"TestResources\VB6\SimpleControl.vb6"),
-                new Guid("366D0F1F-2D8A-4C9B-897D-CE1E74EDD6E5"))
-            : null;
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/Error.ico b/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/Error.ico
deleted file mode 100644
index 97abee5d3b2..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/Error.ico and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/ErrorControl.bmp b/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/ErrorControl.bmp
deleted file mode 100644
index 49a5c36bdec..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/ErrorControl.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.ansi.txt b/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.ansi.txt
deleted file mode 100644
index 4add785dafe..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.ansi.txt
+++ /dev/null
@@ -1 +0,0 @@
-Text
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.utf8.txt b/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.utf8.txt
deleted file mode 100644
index 1d122a1c065..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TestResources/Files/text.utf8.txt
+++ /dev/null
@@ -1 +0,0 @@
-Привет
\ No newline at end of file
diff --git a/src/System.Windows.Forms/tests/UnitTests/TestResources/VB6/SimpleControl.vb6 b/src/System.Windows.Forms/tests/UnitTests/TestResources/VB6/SimpleControl.vb6
deleted file mode 100644
index 79d9d2124e6..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/TestResources/VB6/SimpleControl.vb6 and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/Text/FontMetrics.cs b/src/System.Windows.Forms/tests/UnitTests/Text/FontMetrics.cs
deleted file mode 100644
index f431ae9ac64..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/Text/FontMetrics.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-
-namespace System.Windows.Forms.Tests.Text;
-
-public class FontMetrics
-{
-    [Theory]
-    [InlineData("Arial", 9.0f, 15)]
-    [InlineData("Arial", 12.0f, 18)]
-    [InlineData("Microsoft Sans Serif", 16.0f, 26)]
-    [InlineData("Times New Roman", 11.0f, 17)]
-    [InlineData("MS Gothic", 10.0f, 14)]
-    public void Font_GetHeight(string family, float size, int height)
-    {
-        using Font font = new Font(family, size);
-        if (font.Name != family)
-        {
-            // Not installed on this machine
-            return;
-        }
-
-        using var hfont = GdiCache.GetHFONT(font, FONT_QUALITY.CLEARTYPE_QUALITY);
-        Assert.Equal(height, hfont.Data.Height);
-    }
-
-    [Theory]
-    [InlineData("Arial", 9.0f, 3, 4)]
-    [InlineData("Arial", 12.0f, 3, 5)]
-    [InlineData("Microsoft Sans Serif", 16.0f, 5, 7)]
-    [InlineData("Times New Roman", 11.0f, 3, 5)]
-    [InlineData("MS Gothic", 10.0f, 3, 4)]
-    public void Font_GetTextMargins(string family, float size, int left, int right)
-    {
-        using Font font = new Font(family, size);
-        if (font.Name != family)
-        {
-            // Not installed on this machine
-            return;
-        }
-
-        using var hfont = GdiCache.GetHFONT(font, FONT_QUALITY.CLEARTYPE_QUALITY);
-        DRAWTEXTPARAMS margins = hfont.GetTextMargins();
-        Assert.Equal(left, margins.iLeftMargin);
-        Assert.Equal(right, margins.iRightMargin);
-    }
-
-    [Theory]
-    [InlineData("Arial", 9.0f, 73, 15)]
-    [InlineData("Arial", 12.0f, 95, 18)]
-    [InlineData("Microsoft Sans Serif", 16.0f, 136, 26)]
-    [InlineData("Times New Roman", 11.0f, 84, 17)]
-    [InlineData("MS Gothic", 10.0f, 91, 14)]
-    public void Font_GetTextExtent(string family, float size, int width, int height)
-    {
-        using Font font = new Font(family, size);
-        if (font.Name != family)
-        {
-            // Not installed on this machine
-            return;
-        }
-
-        using var hfont = GdiCache.GetHFONT(font, FONT_QUALITY.CLEARTYPE_QUALITY);
-        using var screen = GdiCache.GetScreenHdc();
-        Size extent = screen.HDC.GetTextExtent("Whizzo Butter", hfont);
-        Assert.Equal(width, extent.Width);
-        Assert.Equal(height, extent.Height);
-    }
-
-    [Theory(Skip = "Flaky in debug builds. See: https://github.com/dotnet/winforms/issues/8612")]
-    [MemberData(nameof(MeasureTextData))]
-    public void Font_MeasureText(string family, float size, Size proposedSize, uint dt, Size expected)
-    {
-        using Font font = new Font(family, size);
-        if (font.Name != family)
-        {
-            // Not installed on this machine
-            return;
-        }
-
-        using var hfont = GdiCache.GetHFONT(font, FONT_QUALITY.CLEARTYPE_QUALITY);
-        using var screen = GdiCache.GetScreenHdc();
-        Size measure = screen.HDC.MeasureText("Windows Foundation Classes", hfont, proposedSize, (TextFormatFlags)dt);
-        Assert.Equal(expected, measure);
-    }
-
-    public static TheoryData<string, float, Size, uint, Size> MeasureTextData =>
-        new()
-        {
-            { "Arial", 9.0f, new Size(-1, -1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(-1, -1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(-1, -1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(-1, -1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(-1, -1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(0, 0), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(0, 0), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(0, 0), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(0, 0), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(0, 0), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(300, 300), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(300, 300), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(300, 300), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(300, 300), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(300, 300), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(1, 1), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(189, 14) },
-            { "Arial", 9.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(173, 15) },
-            { "Arial", 12.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(215, 18) },
-            { "Microsoft Sans Serif", 16.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(299, 26) },
-            { "Times New Roman", 11.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(179, 17) },
-            { "MS Gothic", 10.0f, new Size(int.MaxValue, int.MaxValue), (uint)DRAW_TEXT_FORMAT.DT_SINGLELINE, new Size(189, 14) },
-        };
-
-    [Theory]
-    [MemberData(nameof(AdjustData))]
-    public unsafe void Font_AdjustForVerticalAlignment(string family, float size, Rectangle bounds, uint dt, Rectangle expected)
-    {
-        using Font font = new Font(family, size);
-        if (font.Name != family)
-        {
-            // Not installed on this machine
-            return;
-        }
-
-        using var hfont = GdiCache.GetHFONT(font, FONT_QUALITY.CLEARTYPE_QUALITY);
-        using var screen = GdiCache.GetScreenHdc();
-        using PInvoke.SelectObjectScope fontSelection = new(screen, hfont.Object);
-
-        DRAWTEXTPARAMS param = default;
-        Rectangle result = screen.HDC.AdjustForVerticalAlignment(
-            "Windows Foundation Classes",
-            bounds,
-            (DRAW_TEXT_FORMAT)dt,
-            &param);
-        Assert.Equal(expected, result);
-    }
-
-    public static TheoryData<string, float, Rectangle, uint, Rectangle> AdjustData =>
-        new()
-        {
-            { "Arial", 9.0f, new Rectangle(1, 1, 1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 1, 1, 1) },
-            { "Arial", 12.0f, new Rectangle(1, 1, 1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 1, 1, 1) },
-            { "Microsoft Sans Serif", 16.0f, new Rectangle(1, 1, 1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 1, 1, 1) },
-            { "Times New Roman", 11.0f, new Rectangle(1, 1, 1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 1, 1, 1) },
-            { "MS Gothic", 10.0f, new Rectangle(1, 1, 1, 1), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 1, 1, 1) },
-            { "Arial", 9.0f, new Rectangle(1, 1, 100, 100), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 86, 100, 100) },
-            { "Arial", 12.0f, new Rectangle(1, 1, 100, 100), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 83, 100, 100) },
-            { "Microsoft Sans Serif", 16.0f, new Rectangle(1, 1, 100, 100), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 75, 100, 100) },
-            { "Times New Roman", 11.0f, new Rectangle(1, 1, 100, 100), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 84, 100, 100) },
-            { "MS Gothic", 10.0f, new Rectangle(1, 1, 100, 100), (uint)DRAW_TEXT_FORMAT.DT_BOTTOM, new Rectangle(1, 87, 100, 100) },
-        };
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TextBoxBaseTests.cs b/src/System.Windows.Forms/tests/UnitTests/TextBoxBaseTests.cs
deleted file mode 100644
index 08d96ffd2d8..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TextBoxBaseTests.cs
+++ /dev/null
@@ -1,8088 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using Moq;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class TextBoxBaseTests
-{
-    private static int s_preferredHeight = Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3;
-
-    [WinFormsFact]
-    public void TextBoxBase_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x560100C0, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x560100C0)]
-    [InlineData(false, 0x560101C0)]
-    public void TextBoxBase_CreateParams_GetHideSelection_ReturnsExpected(bool hideSelection, int expectedStyle)
-    {
-        using var control = new SubTextBox
-        {
-            HideSelection = hideSelection
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0x560108C0)]
-    [InlineData(false, 0x560100C0)]
-    public void TextBoxBase_CreateParams_GetReadOnly_ReturnsExpected(bool readOnly, int expectedStyle)
-    {
-        using var control = new SubTextBox
-        {
-            ReadOnly = readOnly
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.None, 0x560100C0, 0)]
-    [InlineData(BorderStyle.Fixed3D, 0x560100C0, 0x00200)]
-    [InlineData(BorderStyle.FixedSingle, 0x568100C0, 0)]
-    public void TextBoxBase_CreateParams_GetBorderStyle_ReturnsExpected(BorderStyle borderStyle, int expectedStyle, int expectedExStyle)
-    {
-        using var control = new SubTextBox
-        {
-            BorderStyle = borderStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(control.Height, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, true, 0x56010044)]
-    [InlineData(true, false, 0x560100C4)]
-    [InlineData(false, true, 0x560100C0)]
-    [InlineData(false, false, 0x560100C0)]
-    public void TextBoxBase_CreateParams_GetMultiline_ReturnsExpected(bool multiline, bool wordWrap, int expectedStyle)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = multiline,
-            WordWrap = wordWrap
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_AcceptsTab_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TextBox
-        {
-            AcceptsTab = value
-        };
-        Assert.Equal(value, control.AcceptsTab);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AcceptsTab = value;
-        Assert.Equal(value, control.AcceptsTab);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AcceptsTab = !value;
-        Assert.Equal(!value, control.AcceptsTab);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_AcceptsTab_SetWithHandler_CallsAcceptsTabChanged()
-    {
-        using var control = new TextBox
-        {
-            AcceptsTab = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AcceptsTabChanged += handler;
-
-        // Set different.
-        control.AcceptsTab = false;
-        Assert.False(control.AcceptsTab);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AcceptsTab = false;
-        Assert.False(control.AcceptsTab);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AcceptsTab = true;
-        Assert.True(control.AcceptsTab);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AcceptsTabChanged -= handler;
-        control.AcceptsTab = false;
-        Assert.False(control.AcceptsTab);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.Multiline);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_AutoSize_SetMultiline_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = true
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.Multiline);
-
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_AutoSize_SetWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.AutoSize = value;
-            Assert.Equal(value, control.AutoSize);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.AutoSize = !value;
-            Assert.Equal(!value, control.AutoSize);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new TextBox
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_BackColor_GetReadOnly_ReturnsExpected()
-    {
-        using var control = new TextBox
-        {
-            ReadOnly = true
-        };
-        Assert.Equal(SystemColors.Control, control.BackColor);
-    }
-
-    public static IEnumerable<object[]> BackColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.Window };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(BackColor_Set_TestData))]
-    public void TextBoxBase_BackColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TextBox
-        {
-            BackColor = value
-        };
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackColor = value;
-        Assert.Equal(expected, control.BackColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_BackColor_SetWithHandler_CallsBackColorChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackColorChanged += handler;
-
-        // Set different.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackColor = Color.Empty;
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.BackColor = Color.Red;
-        Assert.Equal(Color.Red, control.BackColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void TextBoxBase_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new TextBox
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void TextBoxBase_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubTextBox
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        void handler(object sender, EventArgs e)
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        }
-
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<BorderStyle>]
-    public void TextBoxBase_BorderStyle_Set_GetReturnsExpected(BorderStyle value)
-    {
-        using var control = new TextBox()
-        {
-            BorderStyle = value
-        };
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, BorderStyle.Fixed3D, 0)]
-    [InlineData(true, BorderStyle.FixedSingle, 1)]
-    [InlineData(true, BorderStyle.None, 1)]
-    [InlineData(false, BorderStyle.Fixed3D, 0)]
-    [InlineData(false, BorderStyle.FixedSingle, 0)]
-    [InlineData(false, BorderStyle.None, 0)]
-    public void TextBoxBase_BorderStyle_SetWithParent_GetReturnsExpected(bool autoSize, BorderStyle value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new TextBox()
-        {
-            AutoSize = autoSize,
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("BorderStyle", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.BorderStyle = value;
-            Assert.Equal(value, control.BorderStyle);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.BorderStyle = value;
-            Assert.Equal(value, control.BorderStyle);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(BorderStyle.Fixed3D, 0)]
-    [InlineData(BorderStyle.FixedSingle, 1)]
-    [InlineData(BorderStyle.None, 1)]
-    public void TextBoxBase_BorderStyle_SetWithHandle_GetReturnsExpected(BorderStyle value, int expectedStyleChangedCallCount)
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, createdCallCount);
-
-        // Set same.
-        control.BorderStyle = value;
-        Assert.Equal(value, control.BorderStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedStyleChangedCallCount, invalidatedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, styleChangedCallCount);
-        Assert.Equal(expectedStyleChangedCallCount, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_BorderStyle_SetWithHandler_CallsBorderStyleChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BorderStyleChanged += handler;
-
-        // Set different.
-        control.BorderStyle = BorderStyle.FixedSingle;
-        Assert.Equal(BorderStyle.FixedSingle, control.BorderStyle);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BorderStyle = BorderStyle.FixedSingle;
-        Assert.Equal(BorderStyle.FixedSingle, control.BorderStyle);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BorderStyle = BorderStyle.Fixed3D;
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BorderStyleChanged -= handler;
-        control.BorderStyle = BorderStyle.FixedSingle;
-        Assert.Equal(BorderStyle.FixedSingle, control.BorderStyle);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<BorderStyle>]
-    public void TextBoxBase_BorderStyle_SetInvalid_ThrowsInvalidEnumArgumentException(BorderStyle value)
-    {
-        using var control = new TextBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.BorderStyle = value);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_CanUndo_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> CanUndo_CustomCanUndo_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, false };
-        yield return new object[] { (IntPtr)1, true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(CanUndo_CustomCanUndo_TestData))]
-    public void TextBoxBase_CanUndo_CustomCanUndo_ReturnsExpected(IntPtr result, bool expected)
-    {
-        using var control = new CustomCanUndoTextBoxBase
-        {
-            Result = result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.CanUndo);
-    }
-
-    private class CustomCanUndoTextBoxBase : TextBoxBase
-    {
-        public IntPtr Result { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CANUNDO)
-            {
-                m.Result = Result;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_CanUndo_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Dispose_ClearsTextProvider()
-    {
-        using TextBox control = new();
-        control.CreateControl();
-        var textBoxBaseAccessibleObject = (TextBoxBase.TextBoxBaseAccessibleObject)control.AccessibilityObject;
-        TextBoxBase.TextBoxBaseUiaTextProvider provider = textBoxBaseAccessibleObject.TestAccessor().Dynamic._textProvider;
-
-        Assert.IsType<TextBoxBase.TextBoxBaseUiaTextProvider>(provider);
-
-        control.Dispose();
-        provider = textBoxBaseAccessibleObject.TestAccessor().Dynamic._textProvider;
-
-        Assert.Null(provider);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_RecreateControl_DoesntClearTextProvider()
-    {
-        using TextBox control = new();
-        control.CreateControl();
-        TextBoxBase.TextBoxBaseUiaTextProvider provider = control.AccessibilityObject.TestAccessor().Dynamic._textProvider;
-
-        Assert.IsType<TextBoxBase.TextBoxBaseUiaTextProvider>(provider);
-
-        control.RecreateHandleCore();
-        provider = control.AccessibilityObject.TestAccessor().Dynamic._textProvider;
-
-        // The control's accessible object and its providers shouldn't be cleaned when recreating of the control
-        // because this object and all its providers will continue to be used. 
-        Assert.IsType<TextBoxBase.TextBoxBaseUiaTextProvider>(provider);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_CanUndo_GetDisposed_ThrowsObjectDisposedException()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.False(control.CanUndo);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TextBoxBase_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubTextBox
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TextBoxBase_Font_SetWithText_GetReturnsExpected(Font value)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text",
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TextBoxBase_Font_SetWithNonNullOldValue_GetReturnsExpected(Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubTextBox
-        {
-            Font = oldValue
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TextBoxBase_Font_SetWithNonNullOldValueWithText_GetReturnsExpected(Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubTextBox
-        {
-            Font = oldValue,
-            Text = "text"
-        };
-
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f), 1 };
-            yield return new object[] { userPaint, null, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void TextBoxBase_Font_SetWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTextBox();
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithHandle_TestData))]
-    public void TextBoxBase_Font_SetWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Font_SetWithNonNullOldValueWithHandle_TestData()
-    {
-        foreach (bool userPaint in new bool[] { true, false })
-        {
-            yield return new object[] { userPaint, new Font("Arial", 8.25f) };
-            yield return new object[] { userPaint, null };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
-    public void TextBoxBase_Font_SetWithNonNullOldValueWithHandle_GetReturnsExpected(bool userPaint, Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubTextBox
-        {
-            Font = oldValue
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Font_SetWithNonNullOldValueWithHandle_TestData))]
-    public void TextBoxBase_Font_SetWithNonNullOldValueWithTextWithHandle_GetReturnsExpected(bool userPaint, Font value)
-    {
-        using var oldValue = new Font("Arial", 1);
-        using var control = new SubTextBox
-        {
-            Font = oldValue,
-            Text = "text"
-        };
-        control.SetStyle(ControlStyles.UserPaint, userPaint);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(userPaint, control.GetStyle(ControlStyles.UserPaint));
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        // Set different.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White, Color.White };
-        yield return new object[] { Color.Black, Color.Black };
-        yield return new object[] { Color.Red, Color.Red };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void TextBoxBase_ForeColor_Set_GetReturnsExpected(Color value, Color expected)
-    {
-        using var control = new TextBox
-        {
-            ForeColor = value
-        };
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ForeColor_SetWithHandle_TestData()
-    {
-        yield return new object[] { Color.Empty, SystemColors.WindowText, 0 };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3), Color.FromArgb(254, 1, 2, 3), 1 };
-        yield return new object[] { Color.White, Color.White, 1 };
-        yield return new object[] { Color.Black, Color.Black, 1 };
-        yield return new object[] { Color.Red, Color.Red, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_SetWithHandle_TestData))]
-    public void TextBoxBase_ForeColor_SetWithHandle_GetReturnsExpected(Color value, Color expected, int expectedInvalidatedCallCount)
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(expected, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ForeColor_SetWithHandler_CallsForeColorChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(Color.Red, control.ForeColor);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 3)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Handle_GetMargins_Success(bool multiline, int expected)
-    {
-        using var control = new TextBox
-        {
-            Multiline = multiline
-        };
-        control.CreateControl();
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-        Assert.Equal(expected, PARAM.LOWORD(result));
-        Assert.Equal(expected, PARAM.HIWORD(result));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 3)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Handle_GetMarginsWithFont_Success(bool multiline, int expected)
-    {
-        using var font = new Font("Arial", 8.25f);
-        using var control = new TextBox
-        {
-            Multiline = multiline,
-            Font = font
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-        Assert.Equal(expected, PARAM.LOWORD(result));
-        Assert.Equal(expected, PARAM.HIWORD(result));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Handle_GetModify_Success(bool value, int expected)
-    {
-        using var control = new TextBox
-        {
-            Modified = value
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETMODIFY));
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_HideSelection_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox
-        {
-            HideSelection = value
-        };
-        Assert.Equal(value, control.HideSelection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.HideSelection = value;
-        Assert.Equal(value, control.HideSelection);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.HideSelection = !value;
-        Assert.Equal(!value, control.HideSelection);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void TextBoxBase_HideSelection_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.HideSelection = value;
-        Assert.Equal(value, control.HideSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.HideSelection = value;
-        Assert.Equal(value, control.HideSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.HideSelection = !value;
-        Assert.Equal(!value, control.HideSelection);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_HideSelection_SetWithHandler_CallsHideSelectionChanged()
-    {
-        using var control = new TextBox
-        {
-            HideSelection = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.HideSelectionChanged += handler;
-
-        // Set different.
-        control.HideSelection = false;
-        Assert.False(control.HideSelection);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.HideSelection = false;
-        Assert.False(control.HideSelection);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.HideSelection = true;
-        Assert.True(control.HideSelection);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.HideSelectionChanged -= handler;
-        control.HideSelection = false;
-        Assert.False(control.HideSelection);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> ImeModeBase_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.OnHalf };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void TextBoxBase_ImeModeBase_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new SubTextBox
-        {
-            ImeModeBase = value
-        };
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImeMode>]
-    public void TextBoxBase_ImeModeBase_SetReadOnly_GetReturnsExpected(ImeMode value)
-    {
-        using var control = new SubTextBox
-        {
-            ReadOnly = true,
-            ImeModeBase = value
-        };
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void TextBoxBase_ImeModeBase_SetDesignMode_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        using var control = new SubTextBox
-        {
-            Site = mockSite.Object,
-            ImeModeBase = value
-        };
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void TextBoxBase_ImeModeBase_SetReadOnlyDesignMode_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        var mockSite = new Mock<ISite>(MockBehavior.Strict);
-        mockSite
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite
-            .Setup(s => s.DesignMode)
-            .Returns(true);
-        mockSite
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        mockSite
-            .Setup(s => s.Name)
-            .Returns((string)null);
-        using var control = new SubTextBox
-        {
-            Site = mockSite.Object,
-            ReadOnly = true,
-            ImeModeBase = value
-        };
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeModeBase_Set_TestData))]
-    public void TextBoxBase_ImeModeBase_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeModeBase = value;
-        Assert.Equal(expected, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ImeModeBase_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeModeBase = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeModeBase);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ImeModeBase = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeModeBase);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ImeModeBase = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeModeBase);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeModeBase = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeModeBase);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void TextBoxBase_ImeModeBase_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new SubTextBox();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeModeBase = value);
-    }
-
-    public static IEnumerable<object[]> Lines_Get_TestData()
-    {
-        yield return new object[] { string.Empty, Array.Empty<string>() };
-        yield return new object[] { "\r", new string[] { string.Empty, string.Empty } };
-        yield return new object[] { "\n", new string[] { string.Empty, string.Empty } };
-        yield return new object[] { "\r\n", new string[] { string.Empty, string.Empty } };
-
-        yield return new object[] { "abc", new string[] { "abc" } };
-
-        yield return new object[] { "\rabc", new string[] { string.Empty, "abc" } };
-        yield return new object[] { "\nabc", new string[] { string.Empty, "abc" } };
-        yield return new object[] { "\r\nabc", new string[] { string.Empty, "abc" } };
-
-        yield return new object[] { "abc\r", new string[] { "abc", string.Empty } };
-        yield return new object[] { "abc\n", new string[] { "abc", string.Empty } };
-        yield return new object[] { "abc\r\n", new string[] { "abc", string.Empty } };
-
-        yield return new object[] { "abc\rdef", new string[] { "abc", "def" } };
-        yield return new object[] { "abc\ndef", new string[] { "abc", "def" } };
-        yield return new object[] { "abc\r\ndef", new string[] { "abc", "def" } };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Lines_Get_TestData))]
-    public void TextBoxBase_Lines_Get_ReturnsExpected(string text, string[] expected)
-    {
-        using var control = new SubTextBox();
-        Assert.Empty(control.Lines);
-
-        control.Text = text;
-        Assert.Equal(expected, control.Lines);
-    }
-
-    public static IEnumerable<object[]> Lines_Set_TestData()
-    {
-        yield return new object[] { null, Array.Empty<string>(), string.Empty };
-        yield return new object[] { Array.Empty<string>(), Array.Empty<string>(), string.Empty };
-        yield return new object[] { Array.Empty<string>(), Array.Empty<string>(), string.Empty };
-        yield return new object[] { new string[] { "abc" }, new string[] { "abc" }, "abc" };
-        yield return new object[] { new string[] { "abc", "def" }, new string[] { "abc", "def" }, "abc\r\ndef" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Lines_Set_TestData))]
-    public void TextBoxBase_Lines_Set_GetReturnsExpected(string[] lines, string[] expected, string expectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Lines = lines
-        };
-        Assert.NotSame(lines, control.Lines);
-        Assert.Equal(expected, control.Lines);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        Assert.NotSame(lines, control.Lines);
-        Assert.Equal(expected, control.Lines);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_MaxLength_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_LIMITTEXT.
-        PInvoke.SendMessage(control, PInvoke.EM_LIMITTEXT, 0, 1);
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void TextBoxBase_MaxLength_Set_GetReturnsExpected(int value)
-    {
-        using var control = new TextBox
-        {
-            MaxLength = value
-        };
-        Assert.Equal(value, control.MaxLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_MaxLength_SetWithLongText_Success()
-    {
-        using var control = new TextBox
-        {
-            Text = "Text",
-            MaxLength = 2
-        };
-        Assert.Equal(2, control.MaxLength);
-        Assert.Equal("Text", control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(64000)]
-    [InlineData(0x7FFFFFFE)]
-    [InlineData(int.MaxValue)]
-    public void TextBoxBase_MaxLength_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.MaxLength = value;
-        Assert.Equal(value, control.MaxLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_MaxLength_SetWithLongTextWithHandle_Success()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = "Text";
-        control.MaxLength = 2;
-        Assert.Equal(2, control.MaxLength);
-        Assert.Equal("Text", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0x7FFFFFFE)]
-    [InlineData(1, 1)]
-    [InlineData(64000, 64000)]
-    [InlineData(0x7FFFFFFE, 0x7FFFFFFE)]
-    [InlineData(int.MaxValue, 0x7FFFFFFE)]
-    public void TextBoxBase_MaxLength_GetLimitText_Success(int value, int expected)
-    {
-        using var control = new TextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.MaxLength = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETLIMITTEXT));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_MaxLength_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new TextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.MaxLength = -1);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Modified_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int modifiedChangedCallCount = 0;
-        control.ModifiedChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(control.Modified);
-            modifiedChangedCallCount++;
-        };
-
-        Assert.False(control.Modified);
-        Assert.Equal(0, modifiedChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_SETMODIFY.
-        PInvoke.SendMessage(control, PInvoke.EM_SETMODIFY, (WPARAM)(BOOL)true);
-        Assert.Equal(0, modifiedChangedCallCount);
-
-        Assert.True(control.Modified);
-        Assert.Equal(1, modifiedChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_Modified_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-
-        control.Modified = value;
-        Assert.Equal(value, control.Modified);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Modified = value;
-        Assert.Equal(value, control.Modified);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Modified = !value;
-        Assert.Equal(!value, control.Modified);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_Modified_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Modified = value;
-        Assert.Equal(value, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Modified = value;
-        Assert.Equal(value, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Modified = !value;
-        Assert.Equal(!value, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Modified_GetModify_Success(bool value, int expected)
-    {
-        using var control = new TextBox();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Modified = value;
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.EM_GETMODIFY));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Modified_SetWithHandler_CallsModifiedChanged()
-    {
-        using var control = new TextBox
-        {
-            Modified = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ModifiedChanged += handler;
-
-        // Set different.
-        control.Modified = false;
-        Assert.False(control.Modified);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Modified = false;
-        Assert.False(control.Modified);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Modified = true;
-        Assert.True(control.Modified);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ModifiedChanged -= handler;
-        control.Modified = false;
-        Assert.False(control.Modified);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_Multiline_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = value
-        };
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_Multiline_SetNotAutoSize_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox
-        {
-            AutoSize = false,
-            Multiline = value
-        };
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.AutoSize);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Multiline_SetWithParent_GetReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            //TODO
-            //Assert.Equal("Bounds", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.Multiline = !value;
-            Assert.Equal(!value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.Equal(value, control.GetStyle(ControlStyles.FixedHeight));
-            Assert.True(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 4)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Multiline_SetNotAutoSizeWithParent_GetReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent,
-            AutoSize = false
-        };
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.Multiline = value;
-            Assert.Equal(value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.Multiline = !value;
-            Assert.Equal(!value, control.Multiline);
-            Assert.Equal(s_preferredHeight, control.Height);
-            Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-            Assert.False(control.AutoSize);
-            Assert.Equal(4, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_Multiline_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Multiline = value;
-        Assert.Equal(value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.Multiline = !value;
-        Assert.Equal(!value, control.Multiline);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Multiline_SetWithHandler_CallsMultilineChanged()
-    {
-        using var control = new TextBox
-        {
-            Multiline = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.MultilineChanged += handler;
-
-        // Set different.
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Multiline = true;
-        Assert.True(control.Multiline);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.MultilineChanged -= handler;
-        control.Multiline = false;
-        Assert.False(control.Multiline);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TextBoxBase_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TextBox
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(s_preferredHeight, control.PreferredHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(s_preferredHeight, control.PreferredHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TextBoxBase_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.Equal(s_preferredHeight, control.PreferredHeight);
-        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.Equal(s_preferredHeight, control.PreferredHeight);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new TextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    public static IEnumerable<object[]> PreferredHeight_Get_TestData()
-    {
-        yield return new object[] { BorderStyle.None, Control.DefaultFont.Height };
-        yield return new object[] { BorderStyle.Fixed3D, s_preferredHeight };
-        yield return new object[] { BorderStyle.FixedSingle, s_preferredHeight };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(PreferredHeight_Get_TestData))]
-    public void TextBoxBase_PreferredHeight_Get_ReturnsExpected(BorderStyle borderStyle, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            BorderStyle = borderStyle
-        };
-        Assert.Equal(expected, control.PreferredHeight);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ReadOnly_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int readOnlyChangedCallCount = 0;
-        control.ReadOnlyChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.True(control.ReadOnly);
-            readOnlyChangedCallCount++;
-        };
-
-        Assert.False(control.ReadOnly);
-        Assert.Equal(0, readOnlyChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call EM_SETREADONLY.
-        PInvoke.SendMessage(control, PInvoke.EM_SETREADONLY, (WPARAM)(BOOL)true);
-        Assert.Equal(0, readOnlyChangedCallCount);
-
-        Assert.False(control.ReadOnly);
-        Assert.Equal(0, readOnlyChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_ReadOnly_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ReadOnly = !value;
-        Assert.Equal(!value, control.ReadOnly);
-        Assert.Equal(value, control.IsHandleCreated);
-
-        // Set different again.
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_ReadOnly_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ReadOnly = value;
-        Assert.Equal(value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.ReadOnly = !value;
-        Assert.Equal(!value, control.ReadOnly);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_ReadOnly_GetModify_Success(bool value)
-    {
-        using TextBox control = new();
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.ReadOnly = value;
-
-        WINDOW_STYLE style = (WINDOW_STYLE)PInvoke.GetWindowLong(control, WINDOW_LONG_PTR_INDEX.GWL_STYLE);
-        Assert.Equal(value, ((int)style & PInvoke.ES_READONLY) != 0);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ReadOnly_SetWithHandler_CallsReadOnlyChanged()
-    {
-        using var control = new TextBox
-        {
-            ReadOnly = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ReadOnlyChanged += handler;
-
-        // Set different.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.ReadOnly = true;
-        Assert.True(control.ReadOnly);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ReadOnlyChanged -= handler;
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ImeMode.NoControl, 0)]
-    [InlineData(ImeMode.Katakana, 1)]
-    public void TextBoxBase_ReadOnly_SetWithHandler_CallsImeModeChanged(ImeMode imeMode, int expectedCallCount)
-    {
-        using var control = new TextBox
-        {
-            ReadOnly = true,
-            ImeMode = imeMode
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(imeMode, control.ImeMode);
-        Assert.Equal(expectedCallCount, callCount);
-
-        // Set same.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(imeMode, control.ImeMode);
-        Assert.Equal(expectedCallCount * 1, callCount);
-
-        // Set different.
-        control.ReadOnly = true;
-        Assert.True(control.ReadOnly);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(expectedCallCount + 1, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(imeMode, control.ImeMode);
-        Assert.Equal(expectedCallCount + 1, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ImeMode.NoControl)]
-    [InlineData(ImeMode.Katakana)]
-    public void TextBoxBase_ReadOnly_SetWithHandlerImeNotSupported_DoesNotCallImeModeChanged(ImeMode imeMode)
-    {
-        using var control = new ImeNotSupportedTextBox
-        {
-            ReadOnly = true,
-            ImeMode = imeMode
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ReadOnly = true;
-        Assert.True(control.ReadOnly);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ReadOnly = false;
-        Assert.False(control.ReadOnly);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectedText_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectedText_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectedText_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Empty(control.SelectedText);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", null, "", 0)]
-    [InlineData("", "", "", 0)]
-    [InlineData("", "abc", "abc", 3)]
-    [InlineData("text", null, "text", 0)]
-    [InlineData("text", "", "text", 0)]
-    [InlineData("text", "abc", "abctext", 3)]
-    public void TextBoxBase_SelectedText_Set_GetReturnsExpected(string text, string value, string expected, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectedText = value
-        };
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SelectedText_Set_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 0, null, string.Empty, 0 };
-        yield return new object[] { string.Empty, 0, 0, string.Empty, string.Empty, 0 };
-        yield return new object[] { string.Empty, 0, 0, "abc", "abc", 3 };
-
-        yield return new object[] { "text", 0, 0, null, "text", 0 };
-        yield return new object[] { "text", 0, 0, string.Empty, "text", 0 };
-        yield return new object[] { "text", 0, 0, "abc", "abctext", 3 };
-
-        yield return new object[] { "text", 1, 0, null, "text", 1 };
-        yield return new object[] { "text", 1, 0, string.Empty, "text", 1 };
-        yield return new object[] { "text", 1, 0, "abc", "tabcext", 4 };
-
-        yield return new object[] { "text", 3, 0, null, "text", 3 };
-        yield return new object[] { "text", 3, 0, string.Empty, "text", 3 };
-        yield return new object[] { "text", 3, 0, "abc", "texabct", 6 };
-
-        yield return new object[] { "text", 0, 2, null, "xt", 0 };
-        yield return new object[] { "text", 0, 2, string.Empty, "xt", 0 };
-        yield return new object[] { "text", 0, 2, "abc", "abcxt", 3 };
-
-        yield return new object[] { "text", 1, 2, null, "tt", 1 };
-        yield return new object[] { "text", 1, 2, string.Empty, "tt", 1 };
-        yield return new object[] { "text", 1, 2, "abc", "tabct", 4 };
-
-        yield return new object[] { "text", 0, 4, null, string.Empty, 0 };
-        yield return new object[] { "text", 0, 4, string.Empty, string.Empty, 0 };
-        yield return new object[] { "text", 0, 4, "abc", "abc", 3 };
-        yield return new object[] { "text", 0, 4, "abcd", "abcd", 4 };
-        yield return new object[] { "text", 0, 4, "abcde", "abcde", 5 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedText_Set_TestData))]
-    public void TextBoxBase_SelectedText_SetWithSelectionStartAndLength_GetReturnsExpected(string text, int selectionStart, int selectionLength, string value, string expected, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-            SelectedText = value
-        };
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedText_Set_TestData))]
-    public void TextBoxBase_SelectedText_SetModified_GetReturnsExpected(string text, int selectionStart, int selectionLength, string value, string expected, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-            Modified = true,
-            SelectedText = value
-        };
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedText_Set_TestData))]
-    public void TextBoxBase_SelectedText_SetWithSelectionStartAndLengthWithMaxLength_GetReturnsExpected(string text, int selectionStart, int selectionLength, string value, string expected, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-            SelectedText = value,
-            MaxLength = 1
-        };
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.CanUndo);
-        Assert.Equal(1, control.MaxLength);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SelectedText_Set_TestData))]
-    public void TextBoxBase_SelectedText_SetWithHandle_GetReturnsExpected(string text, int selectionStart, int selectionLength, string value, string expected, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectedText = value;
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.CanUndo);
-        Assert.Equal(0x7FFF, control.MaxLength);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TextBoxBase_SelectedText_SetCantCreateHandle_GetReturnsExpected(string value)
-    {
-        using var control = new CantCreateHandleTextBox();
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedText = value;
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [StringWithNullData]
-    public void TextBoxBase_SelectedText_SetDisposed_ThrowsObjectDisposedException(string value)
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Throws<ObjectDisposedException>(() => control.SelectedText = value);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionLength_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionLength_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.Equal(0, control.SelectionLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionLength_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Equal(0, control.SelectionLength);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "t")]
-    [InlineData("text", 2, 2, "te")]
-    [InlineData("text", 3, 3, "tex")]
-    [InlineData("text", 4, 4, "text")]
-    [InlineData("text", 5, 4, "text")]
-    public void TextBoxBase_SelectionLength_Set_GetReturnsExpected(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionLength = value
-        };
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "e")]
-    [InlineData("text", 2, 2, "ex")]
-    [InlineData("text", 3, 3, "ext")]
-    [InlineData("text", 5, 3, "ext")]
-    public void TextBoxBase_SelectionLength_SetWithSelectionStart_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = 1,
-            SelectionLength = value
-        };
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "")]
-    [InlineData("text", 1, 1, "t")]
-    [InlineData("text", 2, 2, "te")]
-    [InlineData("text", 4, 4, "text")]
-    [InlineData("text", 5, 4, "text")]
-    public void TextBoxBase_SelectionLength_SetWithHandle_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionLength = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(expected, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(4, 4)]
-    [InlineData(5, 4)]
-    public unsafe void TextBoxBase_SelectionLength_GetSel_Success(int value, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            SelectionStart = 1
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionLength = value;
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        LRESULT result = PInvoke.SendMessage(
-            control,
-            PInvoke.EM_GETSEL,
-            (WPARAM)(&selectionStart),
-            (LPARAM)(&selectionEnd));
-        Assert.Equal(1, result.LOWORD);
-        Assert.Equal(expected, result.HIWORD);
-        Assert.Equal(1, selectionStart);
-        Assert.Equal(expected, selectionEnd);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionLength_SetNegative_ThrowArgumentOutOfRangeException()
-    {
-        using var control = new SubTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionLength = -1);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionStart_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionStart_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionStart_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Equal(0, control.SelectionStart);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 1, 0)]
-    [InlineData("text", 0, 0)]
-    [InlineData("text", 1, 1)]
-    [InlineData("text", 2, 2)]
-    [InlineData("text", 3, 3)]
-    [InlineData("text", 4, 4)]
-    [InlineData("text", 5, 4)]
-    public void TextBoxBase_SelectionStart_Set_GetReturnsExpected(string text, int value, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = value
-        };
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0, "")]
-    [InlineData("", 1, 0, "")]
-    [InlineData("text", 0, 0, "te")]
-    [InlineData("text", 1, 1, "ex")]
-    [InlineData("text", 2, 2, "xt")]
-    [InlineData("text", 3, 3, "t")]
-    [InlineData("text", 5, 4, "")]
-    public void TextBoxBase_SelectionStart_SetWithSelectionLength_Success(string text, int value, int expected, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionLength = 2,
-            SelectionStart = value
-        };
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0, 0)]
-    [InlineData("", 1, 0)]
-    [InlineData("text", 0, 0)]
-    [InlineData("text", 1, 1)]
-    [InlineData("text", 2, 2)]
-    [InlineData("text", 3, 3)]
-    [InlineData("text", 4, 4)]
-    [InlineData("text", 5, 4)]
-    public void TextBoxBase_SelectionStart_SetWithHandle_Success(string text, int value, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(expected, control.SelectionStart);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0, 1)]
-    [InlineData(1, 1, 2)]
-    [InlineData(2, 2, 3)]
-    [InlineData(3, 3, 4)]
-    [InlineData(5, 4, 4)]
-    public unsafe void TextBoxBase_SelectionStart_GetSel_Success(int value, int expectedSelectionStart, int expectedEnd)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            SelectionLength = 1
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectionStart = value;
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        LRESULT result = PInvoke.SendMessage(
-            control,
-            PInvoke.EM_GETSEL,
-            (WPARAM)(&selectionStart),
-            (LPARAM)(&selectionEnd));
-        Assert.Equal(expectedSelectionStart, result.LOWORD);
-        Assert.Equal(expectedEnd, result.HIWORD);
-        Assert.Equal(expectedSelectionStart, selectionStart);
-        Assert.Equal(expectedEnd, selectionEnd);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectionStart_SetNegative_ThrowArgumentOutOfRangeException()
-    {
-        using var control = new SubTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectionStart = -1);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_SelectionStart_SetCantCreateHandle_GetReturnsExpected(int value)
-    {
-        using var control = new CantCreateHandleTextBox();
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_SelectionStart_SetDisposed_ReturnsExpected(int value)
-    {
-        using var control = new TextBox();
-        control.Dispose();
-
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectionStart = value;
-        Assert.Equal(0, control.SelectionStart);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class ImeNotSupportedTextBox : TextBox
-    {
-        protected override ImeMode DefaultImeMode => ImeMode.Disable;
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_ShortcutsEnabled_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new TextBox
-        {
-            ShortcutsEnabled = value
-        };
-        Assert.Equal(value, control.ShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ShortcutsEnabled = value;
-        Assert.Equal(value, control.ShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.ShortcutsEnabled = !value;
-        Assert.Equal(!value, control.ShortcutsEnabled);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Text_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Text_GetCantCreateHandle_ReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Text_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TextBoxBase_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithSelection_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 2, null, string.Empty, 0, 0, string.Empty };
-        yield return new object[] { string.Empty, 0, 2, "t", "t", 0, 1, "t" };
-        yield return new object[] { string.Empty, 0, 2, "text", "text", 0, 2, "te" };
-
-        yield return new object[] { string.Empty, 1, 2, null, string.Empty, 0, 0, string.Empty };
-        yield return new object[] { string.Empty, 1, 2, "t", "t", 0, 1, "t" };
-        yield return new object[] { string.Empty, 1, 2, "text", "text", 0, 2, "te" };
-
-        yield return new object[] { "text", 0, 2, null, string.Empty, 0, 0, string.Empty };
-        yield return new object[] { "text", 0, 2, "t", "t", 0, 1, "t" };
-        yield return new object[] { "text", 0, 2, "te", "te", 0, 2, "te" };
-        yield return new object[] { "text", 0, 2, "tex", "tex", 0, 2, "te" };
-
-        yield return new object[] { "text", 1, 2, null, string.Empty, 0, 0, string.Empty };
-        yield return new object[] { "text", 1, 2, "t", "t", 1, 0, string.Empty };
-        yield return new object[] { "text", 1, 2, "te", "te", 1, 1, "e" };
-        yield return new object[] { "text", 1, 2, "tex", "tex", 1, 2, "ex" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithSelection_TestData))]
-    public void TextBoxBase_Text_SetWithSelection_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = oldValue,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-        };
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TextBoxBase_Text_SetModified_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubTextBox
-        {
-            Modified = true,
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TextBoxBase_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", true)]
-    [InlineData("text", "text", false)]
-    public void TextBoxBase_Text_SetModifiedWithHandle_GetReturnsExpected(string value, string expected, bool expectedModified)
-    {
-        using var control = new SubTextBox
-        {
-            Modified = true
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expectedModified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expectedModified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Text_SetWithSelectionWithHandle_TestData()
-    {
-        yield return new object[] { string.Empty, 0, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 0, 2, "t", "t" };
-        yield return new object[] { string.Empty, 0, 2, "text", "text" };
-
-        yield return new object[] { string.Empty, 1, 2, null, string.Empty };
-        yield return new object[] { string.Empty, 1, 2, "t", "t" };
-        yield return new object[] { string.Empty, 1, 2, "text", "text" };
-
-        yield return new object[] { "text", 0, 2, null, string.Empty };
-        yield return new object[] { "text", 0, 2, "t", "t" };
-        yield return new object[] { "text", 0, 2, "te", "te" };
-        yield return new object[] { "text", 0, 2, "tex", "tex" };
-
-        yield return new object[] { "text", 1, 2, null, string.Empty };
-        yield return new object[] { "text", 1, 2, "t", "t" };
-        yield return new object[] { "text", 1, 2, "te", "te" };
-        yield return new object[] { "text", 1, 2, "tex", "tex" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Text_SetWithSelectionWithHandle_TestData))]
-    public void TextBoxBase_Text_SetWithSelectionWith_GetReturnsExpected(string oldValue, int selectionStart, int selectionLength, string value, string expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = oldValue,
-            SelectionStart = selectionStart,
-            SelectionLength = selectionLength,
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.TextLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.Modified);
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Text_SetWithHandlerWithHandle_CallsTextChanged()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TextBoxBase_Text_SetCantCreateHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new CantCreateHandleTextBox();
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TextBoxBase_Text_SetDisposed_ThrowsObjectDisposedException(string value, string expected)
-    {
-        using var control = new TextBox();
-        control.Dispose();
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_TextLength_GetDefaultWithoutHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(0, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_TextLength_GetDefaultWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        Assert.Equal(0, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0)]
-    [InlineData("a\0b", 3)]
-    [InlineData("a", 1)]
-    [InlineData("\ud83c\udf09", 2)]
-    public void TextBoxBase_TextLength_GetSetWithHandle_Success(string text, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text
-        };
-        Assert.Equal(expected, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData("", 0)]
-    [InlineData("a\0b", 1)]
-    [InlineData("a", 1)]
-    [InlineData("\ud83c\udf09", 2)]
-    public void TextBoxBase_TextLength_GetWithHandle_ReturnsExpected(string text, int expected)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = text;
-        Assert.Equal(expected, control.TextLength);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_TextLength_GetCantCreateHandle_GetReturnsExpected()
-    {
-        using var control = new CantCreateHandleTextBox();
-        Assert.Equal(0, control.TextLength);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_TextLength_GetDisposed_ReturnsExpected()
-    {
-        using var control = new TextBox();
-        control.Dispose();
-        Assert.Equal(0, control.TextLength);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_WordWrap_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTextBox();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.WordWrap = value;
-        Assert.Equal(value, control.WordWrap);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.WordWrap = value;
-        Assert.Equal(value, control.WordWrap);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.WordWrap = !value;
-        Assert.Equal(!value, control.WordWrap);
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1)]
-    [InlineData(false, 1)]
-    public void TextBoxBase_WordWrap_SetWithParent_GetReturnsExpected(bool value, int expectedParentLayoutCallCount)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e)
-        {
-            Assert.Same(parent, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("WordWrap", e.AffectedProperty);
-            parentLayoutCallCount++;
-        }
-
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.WordWrap = value;
-            Assert.Equal(value, control.WordWrap);
-            Assert.Equal(expectedParentLayoutCallCount, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.WordWrap = value;
-            Assert.Equal(value, control.WordWrap);
-            Assert.Equal(expectedParentLayoutCallCount * 2, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.WordWrap = !value;
-            Assert.Equal(!value, control.WordWrap);
-            Assert.Equal(expectedParentLayoutCallCount * 2 + 1, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TextBoxBase_WordWrap_SetNotAutoSizeWithParent_GetReturnsExpected(bool value)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent,
-            AutoSize = false
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-        int parentLayoutCallCount = 0;
-        void parentHandler(object sender, LayoutEventArgs e) => parentLayoutCallCount++;
-        parent.Layout += parentHandler;
-
-        try
-        {
-            control.WordWrap = value;
-            Assert.Equal(value, control.WordWrap);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set same.
-            control.WordWrap = value;
-            Assert.Equal(value, control.WordWrap);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-
-            // Set different.
-            control.WordWrap = !value;
-            Assert.Equal(!value, control.WordWrap);
-            Assert.Equal(0, layoutCallCount);
-            Assert.Equal(0, parentLayoutCallCount);
-            Assert.False(control.IsHandleCreated);
-            Assert.False(parent.IsHandleCreated);
-        }
-        finally
-        {
-            parent.Layout -= parentHandler;
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 0)]
-    [InlineData(false, 1)]
-    public void TextBoxBase_WordWrap_SetWithHandle_GetReturnsExpected(bool value, int expectedCreatedCallCount)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.WordWrap = value;
-        Assert.Equal(value, control.WordWrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.WordWrap = value;
-        Assert.Equal(value, control.WordWrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set different.
-        control.WordWrap = !value;
-        Assert.Equal(!value, control.WordWrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount + 1, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "", false)]
-    [InlineData("", "", false)]
-    [InlineData("text", "text", true)]
-    public void TextBoxBase_AppendText_InvokeEmpty_Success(string text, string expected, bool expectedHandleCreated)
-    {
-        using var control = new SubTextBox();
-        control.AppendText(text);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0, false)]
-    [InlineData("", 0, false)]
-    [InlineData("text", 7, true)]
-    public void TextBoxBase_AppendText_InvokeNotEmpty_Success(string text, int expectedSelectionStart, bool expectedHandleCreated)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc"
-        };
-        control.AppendText(text);
-        Assert.Equal("abc" + text, control.Text);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1, 2, "bc", false)]
-    [InlineData("", 1, 2, "bc", false)]
-    [InlineData("text", 7, 0, "", true)]
-    public void TextBoxBase_AppendText_InvokeNotEmptyWithSelectionStart_Success(string text, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText, bool expectedHandleCreated)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.AppendText(text);
-        Assert.Equal("abc" + text, control.Text);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1, 2, "bc", false)]
-    [InlineData("", 1, 2, "bc", false)]
-    [InlineData("text", 1, 2, "bc", true)]
-    public void TextBoxBase_AppendText_InvokeNotEmptyWithSelectionStartZeroWidth_Success(string text, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText, bool expectedHandleCreated)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2,
-            Width = 0
-        };
-        control.AppendText(text);
-        Assert.Equal("abc" + text, control.Text);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 1, 2, "bc", false)]
-    [InlineData("", 1, 2, "bc", false)]
-    [InlineData("text", 1, 2, "bc", true)]
-    public void TextBoxBase_AppendText_InvokeNotEmptyWithSelectionStartZeroHeight_Success(string text, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText, bool expectedHandleCreated)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2,
-            AutoSize = false,
-            Height = 0
-        };
-        control.AppendText(text);
-        Assert.Equal("abc" + text, control.Text);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, "")]
-    [InlineData("", "")]
-    [InlineData("text", "text")]
-    public void TextBoxBase_AppendText_InvokeEmptyWithHandle_Success(string text, string expected)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AppendText(text);
-        Assert.Equal(expected, control.Text);
-        Assert.Equal(expected.Length, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(null, 0)]
-    [InlineData("", 0)]
-    [InlineData("text", 7)]
-    public void TextBoxBase_AppendText_InvokeNotEmptyWithHandle_Success(string text, int expectedSelectionStart)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.AppendText(text);
-        Assert.Equal("abc" + text, control.Text);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Clear_InvokeEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Clear_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Clear_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Clear_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Clear();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ClearUndo_Invoke_Nop()
-    {
-        using var control = new SubTextBox();
-        control.ClearUndo();
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-
-        control.ClearUndo();
-        Assert.False(control.CanUndo);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ClearUndo_InvokeWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ClearUndo();
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.ClearUndo();
-        Assert.False(control.CanUndo);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ClearUndo_CanUndo_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Copy();
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-
-        control.ClearUndo();
-        control.Undo();
-        Assert.Equal("bcxt", control.Text);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Copy_PasteEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.Copy();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Copy_PasteNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Copy();
-        Assert.Equal("abc", control.Text);
-        Assert.True(control.IsHandleCreated);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-        Assert.True(control.CanUndo);
-        Assert.True(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Copy_PasteEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Copy();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Copy_PasteNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Copy();
-        Assert.Equal("abc", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-        Assert.True(control.CanUndo);
-        Assert.True(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_CreateHandle_Invoke_Success()
-    {
-        using var control = new SubTextBox();
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsFact]
-    public unsafe void TextBoxBase_CreateHandle_GetSel_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-
-        control.CreateHandle();
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        LRESULT result = PInvoke.SendMessage(
-            control,
-            PInvoke.EM_GETSEL,
-            (WPARAM)(&selectionStart),
-            (LPARAM)(&selectionEnd));
-        Assert.Equal(1, PARAM.LOWORD(result));
-        Assert.Equal(3, PARAM.HIWORD(result));
-        Assert.Equal(1, selectionStart);
-        Assert.Equal(3, selectionEnd);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Cut_PasteEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.Cut();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Cut_PasteNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Cut();
-        Assert.Equal("a", control.Text);
-        Assert.True(control.IsHandleCreated);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-        Assert.True(control.CanUndo);
-        Assert.True(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Cut_PasteEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Cut();
-        Assert.Empty(control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        Assert.Equal("text", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Cut_PasteNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Cut();
-        Assert.Equal("a", control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-        Assert.True(control.CanUndo);
-        Assert.True(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_DeselectAll_InvokeEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.DeselectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_DeselectAll_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.DeselectAll();
-        Assert.Equal(1, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    public static IEnumerable<object[]> GetCharFromPosition_TestData()
-    {
-        yield return new object[] { Point.Empty };
-        yield return new object[] { new Point(-1, -2) };
-        yield return new object[] { new Point(1, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharFromPosition_TestData))]
-    public void TextBoxBase_GetCharFromPosition_InvokeEmpty_Success(Point pt)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal('\0', control.GetCharFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetCharFromPosition_InvokeNotEmptyValid_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-
-        Assert.NotEqual('\0', control.GetCharFromPosition(new Point(10, 2)));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetCharFromPosition_NotEmptyInvalid_TestData()
-    {
-        yield return new object[] { Point.Empty, "T" };
-        yield return new object[] { new Point(-1, -2), "t" };
-        yield return new object[] { new Point(1, 2), "T" };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue), "t" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharFromPosition_NotEmptyInvalid_TestData))]
-    public void TextBoxBase_GetCharFromPosition_InvokeNotEmptyInvalid_Success(Point pt, char expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.Equal(expected, control.GetCharFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharFromPosition_TestData))]
-    public void TextBoxBase_GetCharFromPosition_InvokeEmptyWithHandle_Success(Point pt)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal('\0', control.GetCharFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetCharFromPosition_InvokeNotEmptyValidWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.NotEqual('\0', control.GetCharFromPosition(new Point(10, 2)));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharFromPosition_NotEmptyInvalid_TestData))]
-    public void TextBoxBase_GetCharFromPosition_InvokeNotEmptyInvalidWithHandle_Success(Point pt, char expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.GetCharFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetCharIndexFromPosition_TestData()
-    {
-        yield return new object[] { Point.Empty };
-        yield return new object[] { new Point(-1, -2) };
-        yield return new object[] { new Point(1, 2) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharIndexFromPosition_TestData))]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeEmpty_Success(Point pt)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.GetCharIndexFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeNotEmptyValid_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-
-        int index = control.GetCharIndexFromPosition(new Point(10, 2));
-        Assert.True(index > 0 && index < 4);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetCharIndexFromPosition_NotEmptyInvalid_TestData()
-    {
-        yield return new object[] { Point.Empty, 0 };
-        yield return new object[] { new Point(-1, -2), 3 };
-        yield return new object[] { new Point(1, 2), 0 };
-        yield return new object[] { new Point(int.MaxValue, int.MaxValue), 3 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharIndexFromPosition_NotEmptyInvalid_TestData))]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeNotEmptyInvalid_Success(Point pt, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.Equal(expected, control.GetCharIndexFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharIndexFromPosition_TestData))]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeEmptyWithHandle_Success(Point pt)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetCharIndexFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeNotEmptyValidWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int index = control.GetCharIndexFromPosition(new Point(10, 2));
-        Assert.True(index > 0 && index < 4);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharIndexFromPosition_NotEmptyInvalid_TestData))]
-    public void TextBoxBase_GetCharIndexFromPosition_InvokeNotEmptyInvalidWithHandle_Success(Point pt, int expected)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(expected, control.GetCharIndexFromPosition(pt));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetCharIndexFromPosition_CustomCharFromPos_TestData()
-    {
-        yield return new object[] { string.Empty, (IntPtr)(-1), 0 };
-        yield return new object[] { string.Empty, (IntPtr)0, 0 };
-        yield return new object[] { string.Empty, (IntPtr)1, 0 };
-        yield return new object[] { string.Empty, (IntPtr)short.MaxValue, 0 };
-        yield return new object[] { string.Empty, (IntPtr)int.MaxValue, 0 };
-
-        yield return new object[] { "text", (IntPtr)(-1), 3 };
-        yield return new object[] { "text", (IntPtr)0, 0 };
-        yield return new object[] { "text", (IntPtr)1, 1 };
-        yield return new object[] { "text", (IntPtr)3, 3 };
-        yield return new object[] { "text", (IntPtr)4, 3 };
-        yield return new object[] { "text", PARAM.FromLowHigh(1, 2), 1 };
-        yield return new object[] { "text", (IntPtr)short.MaxValue, 3 };
-        yield return new object[] { "text", (IntPtr)int.MaxValue, 3 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetCharIndexFromPosition_CustomCharFromPos_TestData))]
-    public void TextBoxBase_GetCharIndexFromPosition_CustomCharFromPos_Success(string text, IntPtr result, int expected)
-    {
-        using var control = new CustomCharFromPosTextBox
-        {
-            Text = text,
-            CharFromPosResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetCharIndexFromPosition(new Point(1, 2)));
-    }
-
-    private class CustomCharFromPosTextBox : TextBox
-    {
-        public IntPtr CharFromPosResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_CHARFROMPOS)
-            {
-                Assert.Equal(IntPtr.Zero, m.WParam);
-                Assert.Equal(2, PARAM.SignedHIWORD(m.LParam));
-                Assert.Equal(1, PARAM.SignedLOWORD(m.LParam));
-                m.Result = CharFromPosResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetFirstCharIndexFromLine_InvokeEmpty_ReturnsExpected(int lineNumber)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.GetFirstCharIndexFromLine(lineNumber));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetFirstCharIndexFromLine_InvokeNotEmpty_ReturnsExpected(int lineNumber)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.GetFirstCharIndexFromLine(lineNumber));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetFirstCharIndexFromLine_InvokeEmptyWithHandle_ReturnsExpected(int lineNumber)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetFirstCharIndexFromLine(lineNumber));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetFirstCharIndexFromLine_InvokeNotEmptyWithHandle_ReturnsExpected(int lineNumber)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetFirstCharIndexFromLine(lineNumber));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetFirstCharIndexFromLine_CustomLineFromChar_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1), -1 };
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)1, 1 };
-        yield return new object[] { (IntPtr)int.MaxValue, 0x7FFFFFFF };
-        yield return new object[] { PARAM.FromLowHigh(1, 2), 0x20001 };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetFirstCharIndexFromLine_CustomLineFromChar_TestData))]
-    public void TextBoxBase_GetFirstCharIndexFromLine_CustomLineIndex_Success(IntPtr result, int expected)
-    {
-        using var control = new CustomLineIndexTextBox
-        {
-            ExpectedWParam = (IntPtr)1,
-            LineIndexResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetFirstCharIndexFromLine(1));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetFirstCharIndexFromLine_NegativeLineNumber_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("lineNumber", () => control.GetFirstCharIndexFromLine(-1));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetFirstCharIndexOfCurrentLine_InvokeEmpty_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.GetFirstCharIndexOfCurrentLine());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetFirstCharIndexOfCurrentLine_InvokeNotEmpty_ReturnsExpected()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        Assert.Equal(0, control.GetFirstCharIndexOfCurrentLine());
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetFirstCharIndexOfCurrentLine_InvokeEmptyWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetFirstCharIndexOfCurrentLine());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetFirstCharIndexOfCurrentLine_InvokeNotEmptyWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetFirstCharIndexOfCurrentLine());
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetFirstCharIndexOfCurrentLine_CustomLineFromChar_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1), -1 };
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)1, 1 };
-        yield return new object[] { (IntPtr)int.MaxValue, 0x7FFFFFFF };
-        yield return new object[] { PARAM.FromLowHigh(1, 2), 0x20001 };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetFirstCharIndexOfCurrentLine_CustomLineFromChar_TestData))]
-    public void TextBoxBase_GetFirstCharIndexOfCurrentLine_CustomLineIndex_Success(IntPtr result, int expected)
-    {
-        using var control = new CustomLineIndexTextBox
-        {
-            ExpectedWParam = (IntPtr)(-1),
-            LineIndexResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetFirstCharIndexOfCurrentLine());
-    }
-
-    private class CustomLineIndexTextBox : TextBox
-    {
-        public IntPtr ExpectedWParam { get; set; }
-        public IntPtr LineIndexResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_LINEINDEX)
-            {
-                Assert.Equal(ExpectedWParam, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = LineIndexResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetLineFromCharIndex_InvokeEmpty_Success(int index)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void TextBoxBase_GetLineFromCharIndex_InvokeNotEmpty_Success(int index)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        control.CreateControl();
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetLineFromCharIndex_InvokeEmptyWithHandle_Success(int index)
-    {
-        using var control = new SubTextBox();
-        control.CreateControl();
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void TextBoxBase_GetLineFromCharIndex_InvokeNotEmptyWithHandle_Success(int index)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        control.CreateControl();
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(0, control.GetLineFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetLineFromCharIndex_CustomLineFromChar_TestData()
-    {
-        yield return new object[] { (IntPtr)(-1), -1 };
-        yield return new object[] { IntPtr.Zero, 0 };
-        yield return new object[] { (IntPtr)1, 1 };
-        yield return new object[] { (IntPtr)int.MaxValue, 0x7FFFFFFF };
-        yield return new object[] { PARAM.FromLowHigh(1, 2), 0x20001 };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), -1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetLineFromCharIndex_CustomLineFromChar_TestData))]
-    public void TextBoxBase_GetLineFromCharIndex_CustomLineFromChar_Success(IntPtr result, int expected)
-    {
-        using var control = new CustomLineFromCharTextBox
-        {
-            LineFromCharResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetLineFromCharIndex(1));
-    }
-
-    private class CustomLineFromCharTextBox : TextBox
-    {
-        public IntPtr LineFromCharResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_LINEFROMCHAR)
-            {
-                Assert.Equal((IntPtr)1, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = LineFromCharResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeEmpty_ReturnsEmpty(int index)
-    {
-        using var control = new TextBox();
-        Assert.Equal(Point.Empty, control.GetPositionFromCharIndex(index));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeValidIndexNotEmpty_ReturnsExpected(int index)
-    {
-        using var control = new TextBox
-        {
-            Text = "text"
-        };
-        Point pt = control.GetPositionFromCharIndex(index);
-        Assert.True(pt.X > 0);
-        Assert.Equal(0, pt.Y);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeInvalidIndexNotEmpty_ReturnsEmpty(int index)
-    {
-        using var control = new TextBox
-        {
-            Text = "text"
-        };
-        Assert.Equal(Point.Empty, control.GetPositionFromCharIndex(index));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeEmptyWithHandle_ReturnsEmpty(int index)
-    {
-        using var control = new TextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(Point.Empty, control.GetPositionFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(2)]
-    [InlineData(3)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeValidIndexNotEmptyWithHandle_ReturnsExpected(int index)
-    {
-        using var control = new TextBox
-        {
-            Text = "text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Point pt = control.GetPositionFromCharIndex(index);
-        Assert.True(pt.X > 0);
-        Assert.Equal(0, pt.Y);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(4)]
-    [InlineData(5)]
-    public void TextBoxBase_GetPositionFromCharIndex_InvokeInvalidIndexNotEmptyWithHandle_ReturnsEmpty(int index)
-    {
-        using var control = new TextBox
-        {
-            Text = "text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(Point.Empty, control.GetPositionFromCharIndex(index));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> GetPositionFromCharIndex_CustomPosFromChar_TestData()
-    {
-        yield return new object[] { IntPtr.Zero, Point.Empty };
-        yield return new object[] { (IntPtr)1, new Point(1, 0) };
-        yield return new object[] { PARAM.FromLowHigh(1, 2), new Point(1, 2) };
-        yield return new object[] { PARAM.FromLowHigh(-1, -2), new Point(-1, -2) };
-        yield return new object[] { PARAM.FromLowHigh(int.MaxValue, int.MaxValue), new Point(-1, -1) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPositionFromCharIndex_CustomPosFromChar_TestData))]
-    public void TextBoxBase_GetPositionFromCharIndex_CustomPosFromChar_Success(IntPtr result, Point expected)
-    {
-        using var control = new CustomPosFromCharTextBox
-        {
-            Text = "text",
-            PosFromCharResult = (IntPtr)result
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.GetPositionFromCharIndex(1));
-    }
-
-    private class CustomPosFromCharTextBox : TextBox
-    {
-        public IntPtr PosFromCharResult { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_POSFROMCHAR)
-            {
-                Assert.Equal((IntPtr)1, m.WParam);
-                Assert.Equal(IntPtr.Zero, m.LParam);
-                m.Result = PosFromCharResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_TestData()
-    {
-        foreach (bool multiline in new bool[] { true, false })
-        {
-            foreach (bool wordWrap in new bool[] { true, false })
-            {
-                yield return new object[] { multiline, wordWrap, BorderStyle.Fixed3D, Size.Empty, new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.Fixed3D, new Size(-1, -2), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.Fixed3D, new Size(10, 20), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.Fixed3D, new Size(30, 40), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.Fixed3D, new Size(int.MaxValue, int.MaxValue), new Size(4, s_preferredHeight) };
-
-                yield return new object[] { multiline, wordWrap, BorderStyle.FixedSingle, Size.Empty, new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.FixedSingle, new Size(-1, -2), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.FixedSingle, new Size(10, 20), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.FixedSingle, new Size(30, 40), new Size(4, s_preferredHeight) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.FixedSingle, new Size(int.MaxValue, int.MaxValue), new Size(4, s_preferredHeight) };
-
-                yield return new object[] { multiline, wordWrap, BorderStyle.None, Size.Empty, new Size(0, Control.DefaultFont.Height) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.None, new Size(-1, -2), new Size(0, Control.DefaultFont.Height) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.None, new Size(10, 20), new Size(0, Control.DefaultFont.Height) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.None, new Size(30, 40), new Size(0, Control.DefaultFont.Height) };
-                yield return new object[] { multiline, wordWrap, BorderStyle.None, new Size(int.MaxValue, int.MaxValue), new Size(0, Control.DefaultFont.Height) };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void TextBox_GetPreferredSize_Invoke_ReturnsExpected(bool multiline, bool wordWrap, BorderStyle borderStyle, Size proposedSize, Size expected)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = multiline,
-            WordWrap = wordWrap,
-            BorderStyle = borderStyle
-        };
-        Assert.Equal(expected, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_TestData))]
-    public void TextBox_GetPreferredSize_InvokeWithPadding_ReturnsExpected(bool multiline, bool wordWrap, BorderStyle borderStyle, Size proposedSize, Size expected)
-    {
-        var padding = new Padding(1, 2, 3, 4);
-        using var control = new SubTextBox
-        {
-            Padding = padding,
-            Multiline = multiline,
-            WordWrap = wordWrap,
-            BorderStyle = borderStyle
-        };
-        Assert.Equal(expected + padding.Size, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(expected + padding.Size, control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> GetPreferredSize_WithText_TestData()
-    {
-        yield return new object[] { BorderStyle.Fixed3D, Size.Empty, 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.Fixed3D, new Size(-1, -2), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.Fixed3D, new Size(10, 20), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.Fixed3D, new Size(30, 40), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.Fixed3D, new Size(int.MaxValue, int.MaxValue), 4, s_preferredHeight };
-
-        yield return new object[] { BorderStyle.FixedSingle, Size.Empty, 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.FixedSingle, new Size(-1, -2), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.FixedSingle, new Size(10, 20), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.FixedSingle, new Size(30, 40), 4, s_preferredHeight };
-        yield return new object[] { BorderStyle.FixedSingle, new Size(int.MaxValue, int.MaxValue), 4, s_preferredHeight };
-
-        yield return new object[] { BorderStyle.None, Size.Empty, 0, Control.DefaultFont.Height };
-        yield return new object[] { BorderStyle.None, new Size(-1, -2), 0, Control.DefaultFont.Height };
-        yield return new object[] { BorderStyle.None, new Size(10, 20), 0, Control.DefaultFont.Height };
-        yield return new object[] { BorderStyle.None, new Size(30, 40), 0, Control.DefaultFont.Height };
-        yield return new object[] { BorderStyle.None, new Size(int.MaxValue, int.MaxValue), 0, Control.DefaultFont.Height };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithText_TestData))]
-    public void TextBox_GetPreferredSize_InvokeWithText_ReturnsExpected(BorderStyle borderStyle, Size proposedSize, int expectedAdditionalWidth, int expectedHeight)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            BorderStyle = borderStyle
-        };
-        int width = TextRenderer.MeasureText(control.Text, control.Font).Width;
-
-        Assert.Equal(new Size(width + expectedAdditionalWidth, expectedHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        Assert.Equal(new Size(width + expectedAdditionalWidth, expectedHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithText_TestData))]
-    public void TextBox_GetPreferredSize_InvokeWithNewLineMultiline_ReturnsExpected(BorderStyle borderStyle, Size proposedSize, int expectedAdditionalWidth, int expectedMinimumHeight)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "a\rn\nb",
-            Multiline = true,
-            BorderStyle = borderStyle
-        };
-        int width = TextRenderer.MeasureText(control.Text, control.Font).Width;
-
-        Size result = control.GetPreferredSize(proposedSize);
-        Assert.Equal(width + expectedAdditionalWidth, result.Width);
-        Assert.True(result.Height >= expectedMinimumHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        result = control.GetPreferredSize(proposedSize);
-        Assert.Equal(width + expectedAdditionalWidth, result.Width);
-        Assert.True(result.Height >= expectedMinimumHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(GetPreferredSize_WithText_TestData))]
-    public void TextBox_GetPreferredSize_InvokeWithNewLineNotMultiline_ReturnsExpected(BorderStyle borderStyle, Size proposedSize, int expectedAdditionalWidth, int expectedHeight)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "a\rn\nb",
-            BorderStyle = borderStyle
-        };
-        int width = TextRenderer.MeasureText(control.Text, control.Font, Size.Empty, TextFormatFlags.SingleLine).Width;
-
-        Size result = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(width + expectedAdditionalWidth, expectedHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        result = control.GetPreferredSize(proposedSize);
-        Assert.Equal(new Size(width + expectedAdditionalWidth, expectedHeight), control.GetPreferredSize(proposedSize));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TextBoxBase_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    public static IEnumerable<object[]> IsInputKey_TestData()
-    {
-        foreach (bool multiline in new bool[] { true, false })
-        {
-            foreach (bool acceptsTab in new bool[] { true, false })
-            {
-                foreach (bool readOnly in new bool[] { true, false })
-                {
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Tab, multiline && acceptsTab };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Tab | Keys.Control, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Tab | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Escape, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Escape | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Back | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.PageUp, true };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.PageUp | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.PageDown, true };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.PageDown | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Home, true };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.Home | Keys.Alt, false };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.End, true };
-                    yield return new object[] { multiline, acceptsTab, readOnly, Keys.End | Keys.Alt, false };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    [InlineData(true, true, true, Keys.A, false)]
-    [InlineData(true, true, true, Keys.Back, false)]
-    [InlineData(true, true, false, Keys.Back, true)]
-    [InlineData(true, true, true, Keys.Left, false)]
-    [InlineData(true, true, false, Keys.Left, false)]
-    [InlineData(true, true, true, Keys.Right, false)]
-    [InlineData(true, true, false, Keys.Right, false)]
-    [InlineData(true, true, true, Keys.Up, false)]
-    [InlineData(true, true, false, Keys.Up, false)]
-    [InlineData(false, true, true, Keys.Up, false)]
-    [InlineData(false, true, false, Keys.Up, false)]
-    [InlineData(true, true, true, Keys.Down, false)]
-    [InlineData(true, true, false, Keys.Down, false)]
-    [InlineData(false, true, true, Keys.Down, false)]
-    [InlineData(false, true, false, Keys.Down, false)]
-    [InlineData(false, true, true, Keys.Down | Keys.Alt, false)]
-    [InlineData(false, true, false, Keys.Down | Keys.Alt, false)]
-    public void TextBoxBase_IsInputKey_Invoke_ReturnsExpected(bool multiline, bool acceptsTab, bool readOnly, Keys keyData, bool expected)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = multiline,
-            AcceptsTab = acceptsTab,
-            ReadOnly = readOnly
-        };
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(IsInputKey_TestData))]
-    [InlineData(true, true, true, Keys.A, true)]
-    [InlineData(true, true, true, Keys.Back, true)]
-    [InlineData(true, true, false, Keys.Back, true)]
-    [InlineData(true, true, true, Keys.Left, true)]
-    [InlineData(true, true, false, Keys.Left, true)]
-    [InlineData(true, true, true, Keys.Right, true)]
-    [InlineData(true, true, false, Keys.Right, true)]
-    [InlineData(true, true, true, Keys.Up, true)]
-    [InlineData(true, true, false, Keys.Up, true)]
-    [InlineData(false, true, true, Keys.Up, true)]
-    [InlineData(false, true, false, Keys.Up, true)]
-    [InlineData(true, true, true, Keys.Down, true)]
-    [InlineData(true, true, false, Keys.Down, true)]
-    [InlineData(false, true, true, Keys.Down, true)]
-    [InlineData(false, true, false, Keys.Down, true)]
-    [InlineData(false, true, true, Keys.Down | Keys.Alt, false)]
-    [InlineData(false, true, false, Keys.Down | Keys.Alt, false)]
-    public void TextBoxBase_IsInputKey_InvokeWithHandle_ReturnsExpected(bool multiline, bool acceptsTab, bool readOnly, Keys keyData, bool expected)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = multiline,
-            AcceptsTab = acceptsTab,
-            ReadOnly = readOnly
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnAcceptsTabChanged_Invoke_CallsAcceptsTabChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.AcceptsTabChanged += handler;
-        control.OnAcceptsTabChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.AcceptsTabChanged -= handler;
-        control.OnAcceptsTabChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnBorderStyleChanged_Invoke_CallsBorderStyleChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BorderStyleChanged += handler;
-        control.OnBorderStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.BorderStyleChanged -= handler;
-        control.OnBorderStyleChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnFontChanged_Invoke_CallsFontChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.FontChanged += handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.OnFontChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleDestroyed_TestData()
-    {
-        foreach (bool modified in new bool[] { true, false })
-        {
-            yield return new object[] { modified, null };
-            yield return new object[] { modified, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_TestData))]
-    public void TextBoxBase_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(bool modified, EventArgs eventArgs)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            SelectionStart = 1,
-            SelectionLength = 2,
-            Modified = modified
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(1, control.SelectionStart);
-        Assert.Equal(2, control.SelectionLength);
-        Assert.Equal(modified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(1, control.SelectionStart);
-        Assert.Equal(2, control.SelectionLength);
-        Assert.Equal(modified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnHideSelectionChanged_Invoke_CallsHideSelectionChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HideSelectionChanged += handler;
-        control.OnHideSelectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.HideSelectionChanged -= handler;
-        control.OnHideSelectionChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnModifiedChanged_Invoke_CallsModifiedChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ModifiedChanged += handler;
-        control.OnModifiedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ModifiedChanged -= handler;
-        control.OnModifiedChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void TextBoxBase_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> OnMouseUp_TestData()
-    {
-        yield return new object[] { null };
-        yield return new object[] { new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void TextBoxBase_OnMouseUp_Invoke_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(eventArgs is not null && eventArgs.Button == MouseButtons.Left, control.IsHandleCreated);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.Equal(eventArgs is not null && eventArgs.Button == MouseButtons.Left, control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnMouseUp_TestData))]
-    public void TextBoxBase_OnMouseUp_InvokeWithHandle_CallsMouseUp(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int clickCallCount = 0;
-        control.Click += (sender, e) => clickCallCount++;
-        int mouseClickCallCount = 0;
-        control.MouseClick += (sender, e) => mouseClickCallCount++;
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseUp += handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.MouseUp -= handler;
-        control.OnMouseUp(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(0, clickCallCount);
-        Assert.Equal(0, mouseClickCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnMultilineChanged_Invoke_CallsMultilineChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MultilineChanged += handler;
-        control.OnMultilineChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MultilineChanged -= handler;
-        control.OnMultilineChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnPaddingChanged_Invoke_CallsPaddingChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.PaddingChanged += handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.OnPaddingChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaintEventArgsTheoryData))]
-    public void TextBoxBase_OnPaint_Invoke_CallsPaint(PaintEventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        PaintEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Paint += handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Paint -= handler;
-        control.OnPaint(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnReadOnlyChanged_Invoke_CallsReadOnlyChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ReadOnlyChanged += handler;
-        control.OnReadOnlyChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ReadOnlyChanged -= handler;
-        control.OnReadOnlyChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBoxBase_OnTextChanged_Invoke_CallsTextChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.TextChanged += handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.OnTextChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Paste_InvokeEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.Paste();
-        Assert.NotNull(control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Paste_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Paste();
-        Assert.Equal("abc", control.Text);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> ProcessCmdKey_TestData()
-    {
-        foreach (bool shortcutsEnabled in new bool[] { true, false })
-        {
-            foreach (bool readOnly in new bool[] { true, false })
-            {
-                yield return new object[] { shortcutsEnabled, readOnly, Keys.None, false };
-                yield return new object[] { shortcutsEnabled, readOnly, Keys.A, false };
-
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlZ, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlC, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlX, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlV, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlA, true };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlL, !shortcutsEnabled || readOnly };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlR, !shortcutsEnabled || readOnly };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlE, !shortcutsEnabled || readOnly };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlY, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlDel, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.ShiftDel, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.ShiftIns, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlJ, !shortcutsEnabled || readOnly };
-
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlZ | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlC | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlX | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlV | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlA | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlL | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlR | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlE | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlY | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlDel | Keys.Shift, !shortcutsEnabled };
-                yield return new object[] { shortcutsEnabled, readOnly, (Keys)Shortcut.CtrlJ | Keys.Shift, !shortcutsEnabled };
-
-                yield return new object[] { shortcutsEnabled, readOnly, Keys.Control | Keys.Back, !shortcutsEnabled || !readOnly };
-                yield return new object[] { shortcutsEnabled, readOnly, Keys.Control | Keys.Shift | Keys.Back, !shortcutsEnabled || !readOnly };
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessCmdKey_TestData))]
-    public void TextBoxBase_ProcessCmdKey_Invoke_ReturnsExpected(bool shortcutsEnabled, bool readOnly, Keys keyData, bool expected)
-    {
-        using var control = new SubTextBox
-        {
-            ShortcutsEnabled = shortcutsEnabled,
-            ReadOnly = readOnly
-        };
-        var m = new Message();
-        Assert.Equal(expected, control.ProcessCmdKey(ref m, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ProcessCmdKey_TestData))]
-    public void TextBoxBase_ProcessCmdKey_InvokeWithParent_ReturnsFalse(bool shortcutsEnabled, bool readOnly, Keys keyData, bool expected)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent,
-            ShortcutsEnabled = shortcutsEnabled,
-            ReadOnly = readOnly
-        };
-        var msg = new Message();
-        Assert.Equal(expected, control.ProcessCmdKey(ref msg, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void TextBoxBase_ProcessCmdKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubTextBox();
-        var m = new Message();
-        Assert.False(control.ProcessCmdKey(ref m, keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, false, (Keys)Shortcut.CtrlA, true, true)]
-    [InlineData(true, false, (Keys)Shortcut.CtrlA, false, true)]
-    [InlineData(false, false, (Keys)Shortcut.CtrlA, true, true)]
-    [InlineData(false, false, (Keys)Shortcut.CtrlA, false, true)]
-    [InlineData(true, true, (Keys)Shortcut.CtrlL, true, true)]
-    [InlineData(true, true, (Keys)Shortcut.CtrlL, false, true)]
-    [InlineData(true, false, (Keys)Shortcut.CtrlL, true, true)]
-    [InlineData(true, false, (Keys)Shortcut.CtrlL, false, false)]
-    [InlineData(true, false, Keys.A, true, true)]
-    [InlineData(true, false, Keys.A, false, false)]
-    public void TextBoxBase_ProcessCmdKey_InvokeWithCustomParent_ReturnsExpected(bool shortcutsEnabled, bool readOnly, Keys keyData, bool result, bool expected)
-    {
-        using var control = new SubTextBox
-        {
-            ShortcutsEnabled = shortcutsEnabled,
-            ReadOnly = readOnly
-        };
-        var msg = new Message
-        {
-            Msg = 1
-        };
-        int callCount = 0;
-        bool action(Message actualMsg, Keys actualKeyData)
-        {
-            Assert.Equal(1, actualMsg.Msg);
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessCmdKeyAction = action
-        };
-        control.Parent = parent;
-
-        Assert.Equal(expected, control.ProcessCmdKey(ref msg, keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<Keys, bool> ProcessDialogKeyAction { get; set; }
-
-        protected override bool ProcessDialogKey(Keys keyData) => ProcessDialogKeyAction(keyData);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ProcessCmdKey_CtrlBackspaceTextEmpty_RemainsEmpty()
-    {
-        using var control = new SubTextBox();
-
-        var message = new Message();
-        Assert.True(control.ProcessCmdKey(ref message, Keys.Control | Keys.Back));
-        Assert.Empty(control.Text);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ProcessCmdKey_CtrlBackspaceReadOnly_Nop()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text",
-            ReadOnly = true
-        };
-
-        var message = new Message();
-        Assert.False(control.ProcessCmdKey(ref message, Keys.Control | Keys.Back));
-        Assert.Equal("text", control.Text);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCtrlBackspaceData))]
-    public void TextBoxBase_ProcessCmdKey_CtrlBackspace_ClearsSelection(string text, string expected, int cursorRelativeToEnd)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = text.Length + cursorRelativeToEnd
-        };
-
-        var message = new Message();
-        Assert.True(control.ProcessCmdKey(ref message, Keys.Control | Keys.Back));
-        Assert.Equal(expected, control.Text);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelper), nameof(CommonTestHelper.GetCtrlBackspaceRepeatedData))]
-    public void TextBoxBase_ProcessCmdKey_CtrlBackspaceRepeated_ClearsSelection(string text, string expected, int repeats)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text,
-            SelectionStart = text.Length,
-            SelectionLength = 0
-        };
-
-        for (int i = 0; i < repeats; i++)
-        {
-            var message = new Message();
-            Assert.True(control.ProcessCmdKey(ref message, Keys.Control | Keys.Back));
-        }
-
-        Assert.Equal(expected, control.Text);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ProcessCmdKey_CtrlBackspaceWithSelection_ClearsSelection()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "123-5-7-9",
-            SelectionStart = 2,
-            SelectionLength = 5
-        };
-
-        var message = new Message();
-        Assert.True(control.ProcessCmdKey(ref message, Keys.Control | Keys.Back));
-        Assert.Equal("12-9", control.Text);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, Keys.A)]
-    [InlineData(false, Keys.A)]
-    [InlineData(true, Keys.Tab)]
-    [InlineData(false, Keys.Tab)]
-    [InlineData(true, Keys.Control | Keys.Tab)]
-    [InlineData(false, Keys.Control | Keys.Tab)]
-    [InlineData(true, Keys.Control | Keys.A)]
-    [InlineData(false, Keys.Control | Keys.A)]
-    public void TextBox_ProcessDialogKey_InvokeWithoutParent_ReturnsFalse(bool acceptsTab, Keys keyData)
-    {
-        using var control = new SubTextBox
-        {
-            AcceptsTab = acceptsTab
-        };
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, Keys.A)]
-    [InlineData(false, Keys.A)]
-    [InlineData(true, Keys.Tab)]
-    [InlineData(false, Keys.Tab)]
-    [InlineData(true, Keys.Control | Keys.Tab)]
-    [InlineData(false, Keys.Control | Keys.Tab)]
-    [InlineData(true, Keys.Control | Keys.A)]
-    [InlineData(false, Keys.Control | Keys.A)]
-    public void TextBox_ProcessDialogKey_InvokeWithParent_ReturnsFalse(bool acceptsTab, Keys keyData)
-    {
-        using var parent = new Control();
-        using var control = new SubTextBox
-        {
-            Parent = parent,
-            AcceptsTab = acceptsTab
-        };
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, Keys.A, Keys.A, true)]
-    [InlineData(false, Keys.A, Keys.A, false)]
-    [InlineData(true, Keys.Tab, Keys.Tab, true)]
-    [InlineData(false, Keys.Tab, Keys.Tab, false)]
-    [InlineData(true, Keys.Control | Keys.Tab, Keys.Tab, true)]
-    [InlineData(false, Keys.Control | Keys.Tab, Keys.Control | Keys.Tab, false)]
-    [InlineData(true, Keys.Control | Keys.A, Keys.Control | Keys.A, true)]
-    [InlineData(false, Keys.Control | Keys.A, Keys.Control | Keys.A, false)]
-    public void TextBox_ProcessDialogKey_InvokeWithCustomParent_ReturnsExpected(bool acceptsTab, Keys keyData, Keys expectedKeyData, bool result)
-    {
-        int callCount = 0;
-        bool action(Keys actualKeyData)
-        {
-            Assert.Equal(expectedKeyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessDialogKeyAction = action
-        };
-        using var control = new SubTextBox
-        {
-            Parent = parent,
-            AcceptsTab = acceptsTab
-        };
-        Assert.Equal(result, control.ProcessDialogKey(keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "")]
-    [InlineData(false, "")]
-    [InlineData(true, "Text")]
-    [InlineData(false, "Text")]
-    [InlineData(true, "Text\r\nMoreText")]
-    [InlineData(false, "Text\r\nMoreText")]
-    public void TextBoxBase_ScrollToCaret_InvokeWithoutHandleRecreate_Success(bool multiline, string text)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = multiline,
-            Text = text
-        };
-        control.ScrollToCaret();
-        Assert.False(control.IsHandleCreated);
-
-        // Create Handle.
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.True(control.IsHandleCreated);
-
-        // Recreate Handle.
-        control.RecreateHandle();
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, "")]
-    [InlineData(false, "")]
-    [InlineData(true, "Text")]
-    [InlineData(false, "Text")]
-    [InlineData(true, "Text\r\nMoreText")]
-    [InlineData(false, "Text\r\nMoreText")]
-    public void TextBoxBase_ScrollToCaret_InvokeWithHandle_Success(bool multiline, string text)
-    {
-        using var control = new TextBox
-        {
-            Multiline = multiline,
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ScrollToCaret();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> ScrollToCaret_NoGetOleInterface_TestData()
-    {
-        yield return new object[] { IntPtr.Zero };
-        yield return new object[] { Marshal.GetIUnknownForObject(new object()) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ScrollToCaret_NoGetOleInterface_TestData))]
-    public void TextBoxBase_ScrollToCaret_InvokeWithHandleCustomGetOleInterfaceTextBox_Success(IntPtr lParam)
-    {
-        using var control = new CustomGetOleInterfaceTextBox
-        {
-            GetOleInterfaceResult = IntPtr.Zero,
-            GetOleInterfaceLParam = lParam,
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ScrollToCaret();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ScrollToCaret_InvokeWithHandleNoSuchGetOleInterfaceTextBox_ThrowsArgumentNullException()
-    {
-        IntPtr pUnk = Marshal.GetIUnknownForObject(new CustomTextDocument());
-        using var control = new CustomGetOleInterfaceTextBox
-        {
-            GetOleInterfaceResult = (IntPtr)1,
-            GetOleInterfaceLParam = pUnk,
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ScrollToCaret();
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [ComImport]
-    [Guid("8CC497C0-A1DF-11ce-8098-00AA0047BE5D")]
-    private interface ITextDocument
-    {
-    }
-
-    private class CustomTextDocument : ITextDocument
-    {
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ScrollToCaret_InvokeWithHandleInvalidGetOleInterfaceTextBox_ThrowsArgumentNullException()
-    {
-        IntPtr pUnk = Marshal.GetIUnknownForObject(new object());
-        using var control = new CustomGetOleInterfaceTextBox
-        {
-            GetOleInterfaceResult = (IntPtr)1,
-            GetOleInterfaceLParam = pUnk,
-            Text = "Text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        Assert.Throws<ArgumentNullException>("pUnk", () => control.ScrollToCaret());
-    }
-
-    private class CustomGetOleInterfaceTextBox : TextBox
-    {
-        public IntPtr GetOleInterfaceResult { get; set; }
-
-        public IntPtr GetOleInterfaceLParam { get; set; }
-
-        protected override unsafe void WndProc(ref Message m)
-        {
-            if (m.Msg == (int)PInvoke.EM_GETOLEINTERFACE)
-            {
-                IntPtr* pParam = (IntPtr*)m.LParam;
-                *pParam = GetOleInterfaceLParam;
-                m.Result = GetOleInterfaceResult;
-                return;
-            }
-
-            base.WndProc(ref m);
-        }
-    }
-
-    public static IEnumerable<object[]> Select_TestData()
-    {
-        yield return new object[] { string.Empty, 0, -1, 0, 0, string.Empty };
-        yield return new object[] { string.Empty, 0, 0, 0, 0, string.Empty };
-        yield return new object[] { string.Empty, 0, 1, 0, 0, string.Empty };
-        yield return new object[] { string.Empty, 1, 1, 0, 0, string.Empty };
-
-        yield return new object[] { "text", 0, -1, 0, 0, string.Empty };
-        yield return new object[] { "text", 0, 0, 0, 0, string.Empty };
-        yield return new object[] { "text", 0, 1, 0, 1, "t" };
-        yield return new object[] { "text", 1, 2, 1, 2, "ex" };
-        yield return new object[] { "text", 3, 1, 3, 1, "t" };
-        yield return new object[] { "text", 3, 2, 3, 1, "t" };
-        yield return new object[] { "text", 4, 1, 4, 0, string.Empty };
-        yield return new object[] { "text", 5, 1, 4, 0, string.Empty };
-        yield return new object[] { "text", 0, 4, 0, 4, "text" };
-        yield return new object[] { "text", 0, 5, 0, 4, "text" };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Select_TestData))]
-    public void TextBoxBase_Select_Invoke_Success(string text, int start, int length, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text
-        };
-        control.Select(start, length);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Select(start, length);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Select_TestData))]
-    public void TextBoxBase_Select_InvokeWithHandle_Success(string text, int start, int length, int expectedSelectionStart, int expectedSelectionLength, string expectedSelectedText)
-    {
-        using var control = new SubTextBox
-        {
-            Text = text
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Select(start, length);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Select(start, length);
-        Assert.Equal(expectedSelectionStart, control.SelectionStart);
-        Assert.Equal(expectedSelectionLength, control.SelectionLength);
-        Assert.Equal(expectedSelectedText, control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 0, 0, 0)]
-    [InlineData(0, -1, 0, 0)]
-    [InlineData(1, 2, 1, 3)]
-    [InlineData(5, 2, 4, 4)]
-    [InlineData(0, 4, 0, 4)]
-    [InlineData(0, 5, 0, 4)]
-    public unsafe void TextBoxBase_Select_GetSel_Success(int start, int length, int expectedSelectionStart, int expectedEnd)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.Select(start, length);
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        LRESULT result = PInvoke.SendMessage(
-            control,
-            PInvoke.EM_GETSEL,
-            (WPARAM)(&selectionStart),
-            (LPARAM)(&selectionEnd));
-        Assert.Equal(expectedSelectionStart, result.LOWORD);
-        Assert.Equal(expectedEnd, result.HIWORD);
-        Assert.Equal(expectedSelectionStart, selectionStart);
-        Assert.Equal(expectedEnd, selectionEnd);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Select_NegativeStart_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubTextBox();
-        Assert.Throws<ArgumentOutOfRangeException>("start", () => control.Select(-1, 0));
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectAll_InvokeEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectAll_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.Equal("text", control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.Equal("text", control.SelectedText);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectAll_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Empty(control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_SelectAll_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "text"
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.Equal("text", control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.SelectAll();
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(4, control.SelectionLength);
-        Assert.Equal("text", control.SelectedText);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public unsafe void TextBoxBase_SelectAll_GetSel_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        control.SelectAll();
-        int selectionStart = 0;
-        int selectionEnd = 0;
-        LRESULT result = PInvoke.SendMessage(
-            control,
-            PInvoke.EM_GETSEL,
-            (WPARAM)(&selectionStart),
-            (LPARAM)(&selectionEnd));
-        Assert.Equal(0, result.LOWORD);
-        Assert.Equal(4, result.HIWORD);
-        Assert.Equal(0, selectionStart);
-        Assert.Equal(4, selectionEnd);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 0, 0, specified, 0, 1 };
-            yield return new object[] { -1, -2, -3, -4, specified, 1, 1 };
-            yield return new object[] { 1, 0, 0, 0, specified, 1, 1 };
-            yield return new object[] { 0, 2, 0, 0, specified, 1, 1 };
-            yield return new object[] { 1, 2, 0, 0, specified, 1, 1 };
-            yield return new object[] { 0, 0, 1, 0, specified, 0, 1 };
-            yield return new object[] { 0, 0, 0, 2, specified, 0, 1 };
-            yield return new object[] { 0, 0, 1, 2, specified, 0, 1 };
-            yield return new object[] { 1, 2, 30, 40, specified, 1, 1 };
-            yield return new object[] { 0, 0, 100, s_preferredHeight, specified, 0, 0 };
-            yield return new object[] { 1, 2, 100, s_preferredHeight, specified, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TextBoxBase_SetBoundsCore_InvokeAutoSize_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubTextBox();
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, s_preferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, s_preferredHeight - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, s_preferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, s_preferredHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + s_preferredHeight, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, s_preferredHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, s_preferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, s_preferredHeight - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, s_preferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, s_preferredHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + s_preferredHeight, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, s_preferredHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_NoAutoSize_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            yield return new object[] { 0, 0, 0, 0, specified, 0, 1 };
-            yield return new object[] { -1, -2, -3, -4, specified, 1, 1 };
-            yield return new object[] { 1, 0, 0, 0, specified, 1, 1 };
-            yield return new object[] { 0, 2, 0, 0, specified, 1, 1 };
-            yield return new object[] { 1, 2, 0, 0, specified, 1, 1 };
-            yield return new object[] { 0, 0, 1, 0, specified, 0, 1 };
-            yield return new object[] { 0, 0, 0, 2, specified, 0, 1 };
-            yield return new object[] { 0, 0, 1, 2, specified, 0, 1 };
-            yield return new object[] { 1, 2, 30, 40, specified, 1, 1 };
-            yield return new object[] { 0, 0, 100, s_preferredHeight, specified, 0, 0 };
-            yield return new object[] { 1, 2, 100, s_preferredHeight, specified, 1, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TextBoxBase_SetBoundsCore_InvokeMultiline_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubTextBox
-        {
-            Multiline = true
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, height - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, height - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TextBoxBase_SetBoundsCore_InvokeNotAutoSize_Success(int x, int y, int width, int height, BoundsSpecified specified, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubTextBox
-        {
-            AutoSize = false
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, height - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(width - 4, height - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width - 4, height - 4), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal("System.Windows.Forms.Tests.TextBoxBaseTests+SubTextBox, Text: ", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ToString_InvokeShortText_ReturnsExpected()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text"
-        };
-        Assert.Equal("System.Windows.Forms.Tests.TextBoxBaseTests+SubTextBox, Text: Text", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_ToString_InvokeLongText_ReturnsExpected()
-    {
-        using var control = new SubTextBox
-        {
-            Text = new string('a', 41)
-        };
-        Assert.Equal("System.Windows.Forms.Tests.TextBoxBaseTests+SubTextBox, Text: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Undo_InvokeEmpty_Success()
-    {
-        using var control = new SubTextBox();
-        control.Undo();
-        Assert.Empty(control.Text);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Undo_InvokeNotEmpty_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Undo();
-        Assert.Equal("abc", control.Text);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Undo_InvokeEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Undo();
-        Assert.Empty(control.Text);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Undo_InvokeNotEmptyWithHandle_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Undo();
-        Assert.Equal("abc", control.Text);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_Undo_CanUndo_Success()
-    {
-        using var control = new SubTextBox
-        {
-            Text = "abc",
-            SelectionStart = 1,
-            SelectionLength = 2
-        };
-        control.Copy();
-
-        control.Text = "text";
-        control.SelectionLength = 2;
-        control.Paste();
-        Assert.Equal("bcxt", control.Text);
-
-        control.Undo();
-        Assert.Equal("text", control.Text);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithoutContextMenuStrip_TestData()
-    {
-        foreach (bool shortcutsEnabled in new bool[] { true, false })
-        {
-            IntPtr expectedResult = shortcutsEnabled ? IntPtr.Zero : (IntPtr)250;
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, (IntPtr)(-1), expectedResult };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult };
-
-            yield return new object[] { Size.Empty, shortcutsEnabled, (IntPtr)(-1), expectedResult };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void TextBoxBase_WndProc_InvokeContextMenuWithoutContextMenuStripWithoutHandle_Success(Size size, bool shortcutsEnabled, IntPtr lParam, IntPtr expectedResult)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubTextBox
-            {
-                Size = size,
-                ShortcutsEnabled = shortcutsEnabled
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        foreach (bool shortcutsEnabled in new bool[] { true, false })
-        {
-            IntPtr expectedResult = shortcutsEnabled ? IntPtr.Zero : (IntPtr)250;
-
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, (IntPtr)(-1), (IntPtr)250, true, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult, false, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult, false, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250, true, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult, false, true };
-
-            yield return new object[] { Size.Empty, shortcutsEnabled, (IntPtr)(-1), expectedResult, false, false };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult, false, true };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult, false, true };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(p.X, p.Y), expectedResult, false, true };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult, false, true };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithoutHandle_TestData))]
-    public void TextBoxBase_WndProc_InvokeContextMenuWithContextMenuStripWithoutHandle_Success(Size size, bool shortcutsEnabled, IntPtr lParam, IntPtr expectedResult, bool expectedHasSourceControl, bool expectedHandleCreated)
-    {
-        using (new NoAssertContext())
-        {
-            using var menu = new ContextMenuStrip();
-            using var control = new SubTextBox
-            {
-                ContextMenuStrip = menu,
-                Size = size,
-                ShortcutsEnabled = shortcutsEnabled
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_CONTEXTMENU,
-                LParam = lParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(menu.Visible);
-            Assert.Equal(expectedHasSourceControl, menu.SourceControl == control);
-            Assert.Equal(expectedHandleCreated, control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithoutContextMenuStrip_TestData))]
-    public void TextBoxBase_WndProc_InvokeContextMenuWithoutContextMenuStripWithHandle_Success(Size size, bool shortcutsEnabled, IntPtr lParam, IntPtr expectedResult)
-    {
-        using var control = new SubTextBox
-        {
-            Size = size,
-            ShortcutsEnabled = shortcutsEnabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ContextMenuWithContextMenuStripWithHandle_TestData()
-    {
-        using var control = new Control();
-        Point p = control.PointToScreen(new Point(5, 5));
-
-        foreach (bool shortcutsEnabled in new bool[] { true, false })
-        {
-            IntPtr expectedResult = shortcutsEnabled ? IntPtr.Zero : (IntPtr)250;
-
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, (IntPtr)(-1), (IntPtr)250, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult, false };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult, false };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(p.X, p.Y), (IntPtr)250, true };
-            yield return new object[] { new Size(10, 20), shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult, false };
-
-            yield return new object[] { Size.Empty, shortcutsEnabled, (IntPtr)(-1), expectedResult, false };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(0, 0), expectedResult, false };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(1, 2), expectedResult, false };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(p.X, p.Y), expectedResult, false };
-            yield return new object[] { Size.Empty, shortcutsEnabled, PARAM.FromLowHigh(-1, -2), expectedResult, false };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ContextMenuWithContextMenuStripWithHandle_TestData))]
-    public void TextBoxBase_WndProc_InvokeContextMenuWithContextMenuStripWithHandle_Success(Size size, bool shortcutsEnabled, IntPtr lParam, IntPtr expectedResult, bool expectedHasSourceControl)
-    {
-        using var menu = new ContextMenuStrip();
-        using var control = new SubTextBox
-        {
-            ContextMenuStrip = menu,
-            Size = size,
-            ShortcutsEnabled = shortcutsEnabled
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_CONTEXTMENU,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.False(menu.Visible);
-        Assert.Equal(expectedHasSourceControl, menu.SourceControl == control);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_GetDlgCode_TestData()
-    {
-        yield return new object[] { true, (IntPtr)2 };
-        yield return new object[] { false, IntPtr.Zero };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_GetDlgCode_TestData))]
-    public void TextBoxBase_WndProc_InvokeGetDlgCodeWithoutHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubTextBox
-            {
-                AcceptsTab = acceptsTabs
-            };
-            var m = new Message
-            {
-                Msg = (int)PInvoke.WM_GETDLGCODE,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.False(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_GetDlgCode_TestData))]
-    public void TextBoxBase_WndProc_InvokeGetDlgCodeWithHandle_ReturnsExpected(bool acceptsTabs, IntPtr expectedResult)
-    {
-        using var control = new SubTextBox
-        {
-            AcceptsTab = acceptsTabs
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_GETDLGCODE,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_MouseDown_TestData()
-    {
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Left, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_LBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Left, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Middle, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_MBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Middle, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.Right, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_RBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.Right, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 1, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDOWN, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 1, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, (IntPtr)250, MouseButtons.None, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), IntPtr.Zero, IntPtr.Zero, MouseButtons.None, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), (IntPtr)250, MouseButtons.XButton1, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(2, 1), IntPtr.Zero, MouseButtons.XButton1, 2, -1, -2 };
-
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, 0, 0 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, 1, 2 };
-        yield return new object[] { true, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), (IntPtr)250, MouseButtons.XButton2, 2, -1, -2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, IntPtr.Zero, PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, 0, 0 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(1, 2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, 1, 2 };
-        yield return new object[] { false, (int)PInvoke.WM_XBUTTONDBLCLK, PARAM.FromLowHigh(-1, -2), PARAM.FromLowHigh(1, 2), IntPtr.Zero, MouseButtons.XButton2, 2, -1, -2 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithoutHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubTextBox();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            int callCount = 0;
-            control.MouseDown += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithoutHandleNotSelectable_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubTextBox();
-            control.SetStyle(ControlStyles.UserMouse, userMouse);
-            control.SetStyle(ControlStyles.Selectable, false);
-            int callCount = 0;
-            control.MouseDown += (sender, e) =>
-            {
-                Assert.Same(control, sender);
-                Assert.Equal(expectedButton, e.Button);
-                Assert.Equal(expectedClicks, e.Clicks);
-                Assert.Equal(expectedX, e.X);
-                Assert.Equal(expectedY, e.Y);
-                Assert.Equal(0, e.Delta);
-                callCount++;
-            };
-            var m = new Message
-            {
-                Msg = msg,
-                LParam = lParam,
-                WParam = wParam,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(expectedResult, m.Result);
-            Assert.Equal(1, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_LBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_MBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_MBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_RBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_RBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_XBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_XBUTTONDBLCLK)]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithoutHandleNotEnabled_DoesNotCallMouseDown(int msg)
-    {
-        using (new NoAssertContext())
-        {
-            using var control = new SubTextBox
-            {
-                Enabled = false
-            };
-            int callCount = 0;
-            control.MouseDown += (sender, e) => callCount++;
-            var m = new Message
-            {
-                Msg = msg,
-                Result = (IntPtr)250
-            };
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(0, callCount);
-            Assert.True(control.Capture);
-            Assert.False(control.Focused);
-            Assert.True(control.IsHandleCreated);
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithHandle_Success(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubTextBox();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_MouseDown_TestData))]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithHandleNotSelectable_DoesNotCallMouseDown(bool userMouse, int msg, IntPtr lParam, IntPtr wParam, IntPtr expectedResult, MouseButtons expectedButton, int expectedClicks, int expectedX, int expectedY)
-    {
-        using var control = new SubTextBox();
-        control.SetStyle(ControlStyles.UserMouse, userMouse);
-        control.SetStyle(ControlStyles.Selectable, false);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(expectedButton, e.Button);
-            Assert.Equal(expectedClicks, e.Clicks);
-            Assert.Equal(expectedX, e.X);
-            Assert.Equal(expectedY, e.Y);
-            Assert.Equal(0, e.Delta);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = msg,
-            LParam = lParam,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(expectedResult, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData((int)PInvoke.WM_LBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_LBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_MBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_MBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_RBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_RBUTTONDBLCLK)]
-    [InlineData((int)PInvoke.WM_XBUTTONDOWN)]
-    [InlineData((int)PInvoke.WM_XBUTTONDBLCLK)]
-    public void TextBoxBase_WndProc_InvokeMouseDownWithHandleNotEnabled_DoesNotCallMouseDown(int msg)
-    {
-        using var control = new SubTextBox
-        {
-            Enabled = false
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseDown += (sender, e) => callCount++;
-        var m = new Message
-        {
-            Msg = msg,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, callCount);
-        Assert.True(control.Capture);
-        Assert.False(control.Focused);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBoxBase_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_ReflectCommand_TestData()
-    {
-        foreach (IntPtr lParam in new IntPtr[] { IntPtr.Zero, (IntPtr)1 })
-        {
-            yield return new object[] { IntPtr.Zero, lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_CHANGE), lParam, 1 };
-            yield return new object[] { PARAM.FromLowHigh(0, (int)PInvoke.EN_UPDATE), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_CHANGE), lParam, 1 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_HSCROLL), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, (int)PInvoke.EN_VSCROLL), lParam, 0 };
-            yield return new object[] { PARAM.FromLowHigh(123, 456), lParam, 0 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommand_TestData))]
-    public void TextBoxBase_WndProc_InvokeReflectCommandWithoutHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
-    {
-        using var control = new SubTextBox();
-
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            textChangedCallCount++;
-        };
-        int modifiedCallCount = 0;
-        control.ModifiedChanged += (sender, e) => modifiedCallCount++;
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT | PInvoke.WM_COMMAND),
-            WParam = wParam,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
-        Assert.Equal(0, modifiedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_ReflectCommand_TestData))]
-    public void TextBoxBase_WndProc_InvokeReflectCommandWithHandle_Success(IntPtr wParam, IntPtr lParam, int expectedTextChangedCallCount)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            textChangedCallCount++;
-        };
-        int modifiedCallCount = 0;
-        control.ModifiedChanged += (sender, e) => modifiedCallCount++;
-        var m = new Message
-        {
-            Msg = (int)(MessageId.WM_REFLECT | PInvoke.WM_COMMAND),
-            WParam = wParam,
-            LParam = lParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(expectedTextChangedCallCount, textChangedCallCount);
-        Assert.Equal(0, modifiedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 3)]
-    [InlineData(false, 0)]
-    public void TextBoxBase_WndProc_InvokeSetFontWithoutHandle_ReturnsExpected(bool multiline, int expectedMargin)
-    {
-        using (new NoAssertContext())
-        {
-            using SubTextBox control = new()
-            {
-                Multiline = multiline
-            };
-
-            Message m = new()
-            {
-                Msg = (int)PInvoke.WM_SETFONT,
-                Result = 250
-            };
-
-            int textChangedCallCount = 0;
-            control.TextChanged += (sender, e) => textChangedCallCount++;
-            control.WndProc(ref m);
-            Assert.Equal(IntPtr.Zero, m.Result);
-            Assert.Equal(!multiline, control.IsHandleCreated);
-            Assert.Equal(0, textChangedCallCount);
-            control.CreateControl();
-            nint result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-            Assert.Equal(expectedMargin, PARAM.HIWORD(result));
-            Assert.Equal(expectedMargin, PARAM.LOWORD(result));
-        }
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, 1, 2)]
-    [InlineData(false, 0, 0)]
-    public void TextBoxBase_WndProc_InvokeSetFontWithHandle_ReturnsExpected(bool multiline, int expectedLeft, int expectedRight)
-    {
-        using SubTextBox control = new()
-        {
-            Multiline = multiline
-        };
-
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        PInvoke.SendMessage(
-            control,
-            PInvoke.EM_SETMARGINS,
-            (WPARAM)(PInvoke.EC_LEFTMARGIN | PInvoke.EC_RIGHTMARGIN),
-            LPARAM.MAKELPARAM(1, 2));
-        int textChangedCallCount = 0;
-        control.TextChanged += (sender, e) => textChangedCallCount++;
-
-        Message m = new()
-        {
-            Msg = (int)PInvoke.WM_SETFONT,
-            Result = 250
-        };
-
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(0, textChangedCallCount);
-        IntPtr result = PInvoke.SendMessage(control, PInvoke.EM_GETMARGINS);
-        Assert.Equal(expectedLeft, PARAM.LOWORD(result));
-        Assert.Equal(expectedRight, PARAM.HIWORD(result));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class CantCreateHandleTextBox : TextBox
-    {
-        protected override void CreateHandle()
-        {
-            // Nop.
-        }
-    }
-
-    private class SubTextBox : TextBox
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnAcceptsTabChanged(EventArgs e) => base.OnAcceptsTabChanged(e);
-
-        public new void OnBorderStyleChanged(EventArgs e) => base.OnBorderStyleChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnFontChanged(EventArgs e) => base.OnFontChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnHideSelectionChanged(EventArgs e) => base.OnHideSelectionChanged(e);
-
-        public new void OnModifiedChanged(EventArgs e) => base.OnModifiedChanged(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseUp(MouseEventArgs mevent) => base.OnMouseUp(mevent);
-
-        public new void OnMultilineChanged(EventArgs e) => base.OnMultilineChanged(e);
-
-        public new void OnPaddingChanged(EventArgs e) => base.OnPaddingChanged(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnReadOnlyChanged(EventArgs e) => base.OnReadOnlyChanged(e);
-
-        public new void OnTextChanged(EventArgs e) => base.OnTextChanged(e);
-
-        public new bool ProcessCmdKey(ref Message m, Keys keyData) => base.ProcessCmdKey(ref m, keyData);
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new void RecreateHandle() => base.RecreateHandle();
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-
-    private class SubTextBoxBase : TextBoxBase
-    {
-    }
-
-    public static IEnumerable<object[]> TextBoxBase_GetLineFromCharIndex_TestData()
-    {
-        yield return new object[] { new Size(50, 20), false, 0, 0 };
-        yield return new object[] { new Size(50, 20), false, 50, 0 };
-        yield return new object[] { new Size(100, 50), true, 50, 3 };
-        yield return new object[] { new Size(50, 50), true, 50, 8 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBase_GetLineFromCharIndex_TestData))]
-    public void TextBoxBase_GetLineFromCharIndex_ReturnsCorrectValue(Size size, bool multiline, int charIndex, int expectedLine)
-    {
-        using var textBoxBase = new SubTextBoxBase() { Size = size, Multiline = multiline };
-        textBoxBase.Text = "Some test text for testing GetLineFromCharIndex method";
-        int actualLine = textBoxBase.GetLineFromCharIndex(charIndex);
-        Assert.Equal(expectedLine, actualLine);
-    }
-
-    public static IEnumerable<object[]> TextBoxBase_GetPositionFromCharIndex_TestData()
-    {
-        yield return new object[] { new Size(50, 20), false, 0, new Point(1, 0) };
-        yield return new object[] { new Size(50, 20), false, 15, new Point(79, 0) };
-        yield return new object[] { new Size(50, 50), true, 12, new Point(14, 31) };
-        yield return new object[] { new Size(100, 50), true, 22, new Point(37, 16) };
-        yield return new object[] { new Size(50, 50), true, 100, Point.Empty };
-        yield return new object[] { new Size(50, 50), true, -1, Point.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBoxBase_GetPositionFromCharIndex_TestData))]
-    public void TextBoxBase_GetPositionFromCharIndex_ReturnsCorrectValue(Size size, bool multiline, int charIndex, Point expectedPoint)
-    {
-        using var textBoxBase = new SubTextBoxBase() { Size = size, Multiline = multiline };
-        textBoxBase.Text = "Some test text for testing GetPositionFromCharIndex method";
-        Point actualPoint = textBoxBase.GetPositionFromCharIndex(charIndex);
-        Assert.True(actualPoint.X >= expectedPoint.X - 1 || actualPoint.X <= expectedPoint.X + 1);
-        Assert.True(actualPoint.Y >= expectedPoint.Y - 1 || actualPoint.Y <= expectedPoint.Y + 1);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.Rendering.cs b/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.Rendering.cs
deleted file mode 100644
index 966f85f910f..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.Rendering.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Drawing;
-using System.Windows.Forms.Metafiles;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class TextBoxTests
-{
-    [WinFormsFact]
-    public void TextBox_Disabled_PlaceholderText_RendersBackgroundCorrectly()
-    {
-        // Regression test for https://github.com/dotnet/winforms/issues/3706
-
-        using Form form = new Form();
-        using TextBox textBox = new TextBox
-        {
-            Size = new Size(80, 23),
-            PlaceholderText = "abc",
-            Enabled = false
-        };
-        form.Controls.Add(textBox);
-
-        // Force the handle creation
-        Assert.NotEqual(IntPtr.Zero, form.Handle);
-        Assert.NotEqual(IntPtr.Zero, textBox.Handle);
-
-        using var emf = new EmfScope();
-        DeviceContextState state = new DeviceContextState(emf);
-
-        textBox.TestAccessor().Dynamic.DrawPlaceholderText(emf.HDC);
-
-        emf.Validate(
-            state,
-            Validate.TextOut(
-                "abc",
-                bounds: null,                                   // Don't care about the bounds for this test
-                State.BackgroundMode(BACKGROUND_MODE.TRANSPARENT)));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.cs b/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.cs
deleted file mode 100644
index 157e4fe044c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TextBoxTests.cs
+++ /dev/null
@@ -1,735 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public partial class TextBoxTests
-{
-    private static int s_preferredHeight = Control.DefaultFont.Height + SystemInformation.BorderSize.Height * 4 + 3;
-
-    [WinFormsFact]
-    public void TextBox_Ctor_Default()
-    {
-        using var control = new SubTextBox();
-        Assert.False(control.AcceptsReturn);
-        Assert.False(control.AcceptsTab);
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.Empty(control.AutoCompleteCustomSource);
-        Assert.Same(control.AutoCompleteCustomSource, control.AutoCompleteCustomSource);
-        Assert.Equal(AutoCompleteMode.None, control.AutoCompleteMode);
-        Assert.Equal(AutoCompleteSource.None, control.AutoCompleteSource);
-        Assert.True(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(control.PreferredHeight, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 100, control.PreferredHeight), control.Bounds);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.CanUndo);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(CharacterCasing.Normal, control.CharacterCasing);
-        Assert.Equal(new Size(96, control.PreferredHeight - 4), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 96, control.PreferredHeight - 4), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.IBeam, control.Cursor);
-        Assert.Same(Cursors.IBeam, 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(100, control.PreferredHeight), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 96, control.PreferredHeight - 4), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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.False(control.HasChildren);
-        Assert.Equal(control.PreferredHeight, control.Height);
-        Assert.True(control.HideSelection);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Empty(control.Lines);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(32767, control.MaxLength);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.False(control.Modified);
-        Assert.False(control.Multiline);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(4, control.PreferredSize.Width);
-        Assert.True(control.PreferredSize.Height > 0);
-        Assert.True(control.PreferredHeight > 0);
-        Assert.False(control.ReadOnly);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(100, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(ScrollBars.None, control.ScrollBars);
-        Assert.Empty(control.SelectedText);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.True(control.ShortcutsEnabled);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(100, 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.TextLength);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseSystemPasswordChar);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.Equal(100, control.Width);
-        Assert.True(control.WordWrap);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("Edit", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0x200, createParams.ExStyle);
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x560100C0, createParams.Style);
-        Assert.Equal(100, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_CanEnableIme_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.True(control.CanEnableIme);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.True(control.CanEnableIme);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_CanEnableIme_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.True(control.CanEnableIme);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.True(control.CanEnableIme);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBox_ImeMode_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_ImeMode_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBox_ImeModeBase_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_ImeModeBase_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PasswordChar_GetWithoutHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal('\0', control.PasswordChar);
-        Assert.True(control.IsHandleCreated);
-
-        // Get again.
-        Assert.Equal('\0', control.PasswordChar);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PasswordChar_GetWithHandle_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        Assert.Equal('\0', control.PasswordChar);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Get again.
-        Assert.Equal('\0', control.PasswordChar);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderText()
-    {
-        using var tb = new TextBox
-        {
-            PlaceholderText = "Enter your name"
-        };
-        Assert.False(string.IsNullOrEmpty(tb.PlaceholderText));
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderText_DefaultValue()
-    {
-        using var tb = new TextBox();
-        Assert.Equal(string.Empty, tb.PlaceholderText);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderText_When_InAccessibility_Doesnot_Raise_TextChanged()
-    {
-        using var tb = new SubTextBox();
-        bool eventRaised = false;
-        EventHandler handler = (o, e) => eventRaised = true;
-        tb.TextChanged += handler;
-        tb.CreateAccessibilityInstance();
-        Assert.False(eventRaised);
-        tb.TextChanged -= handler;
-    }
-
-    public static IEnumerable<object[]> TextBox_ShouldRenderPlaceHolderText_TestData()
-    {
-        // Test PlaceholderText
-        yield return new object[] { null, /* isUserPaint */ false, /* isIsFocused */ false, /* textCount */ 0, /* expected */ false };
-        yield return new object[] { "", /* isUserPaint */ false, /* isIsFocused */ false, /* textCount */ 0, /* expected */ false };
-
-        // Test UserPaint
-        yield return new object[] { "Text", /* isUserPaint */ true, /* isIsFocused */ false, /* textCount */ 0, /* expected */ false };
-
-        // Test Focused
-        yield return new object[] { "Text", /* isUserPaint */ false, /* isIsFocused */ true, /* textCount */ 0, /* expected */ false };
-
-        // Test TextLength
-        yield return new object[] { "Text", /* isUserPaint */ false, /* isIsFocused */ false, /* textCount */ 1, /* expected */ false };
-
-        // Happy path
-        yield return new object[] { "Text", /* isUserPaint */ false, /* isIsFocused */ false, /* textCount */ 0, /* expected */ true };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(TextBox_ShouldRenderPlaceHolderText_TestData))]
-    public void TextBox_ShouldRenderPlaceHolderText(string text, bool isUserPaint, bool isIsFocused, int textCount, bool expected)
-    {
-        using var textBox = new SubTextBox() { PlaceholderText = text, IsUserPaint = isUserPaint, IsFocused = isIsFocused, TextCount = textCount };
-
-        bool result = textBox.TestAccessor().Dynamic.ShouldRenderPlaceHolderText();
-        Assert.Equal(expected, result);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderText_NullValue_CoercedTo_StringEmpty()
-    {
-        using var tb = new TextBox()
-        {
-            PlaceholderText = "Text"
-        };
-
-        tb.PlaceholderText = null;
-        Assert.Equal(string.Empty, tb.PlaceholderText);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderText_Overriden()
-    {
-        using var tb = new SubTextBox();
-
-        Assert.NotNull(tb);
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderTextAlignments()
-    {
-        using var tb = new TextBox
-        {
-            PlaceholderText = "Enter your name"
-        };
-
-        // Cover the Placeholder draw code path
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-        tb.TextAlign = HorizontalAlignment.Center;
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-        tb.TextAlign = HorizontalAlignment.Right;
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-
-        Assert.False(string.IsNullOrEmpty(tb.PlaceholderText));
-    }
-
-    [WinFormsFact]
-    public void TextBox_PlaceholderTextAlignmentsInRightToLeft()
-    {
-        using var tb = new TextBox
-        {
-            PlaceholderText = "Enter your name",
-            RightToLeft = RightToLeft.Yes
-        };
-
-        // Cover the Placeholder draw code path in RightToLeft scenario
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-        tb.TextAlign = HorizontalAlignment.Center;
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-        tb.TextAlign = HorizontalAlignment.Right;
-        PInvoke.SendMessage(tb, PInvoke.WM_PAINT, (WPARAM)(BOOL)false);
-
-        Assert.False(string.IsNullOrEmpty(tb.PlaceholderText));
-    }
-
-    [WinFormsTheory]
-    [InlineData(true, AccessibleRole.Text)]
-    [InlineData(false, AccessibleRole.None)]
-    public void TextBox_CreateAccessibilityInstance_Invoke_ReturnsExpected(bool createControl, AccessibleRole expectedAccessibleRole)
-    {
-        using var control = new SubTextBox();
-        if (createControl)
-        {
-            control.CreateControl();
-        }
-
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Control.ControlAccessibleObject instance = Assert.IsType<TextBox.TextBoxAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.Equal(createControl, control.IsHandleCreated);
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(expectedAccessibleRole, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
-        Assert.Equal(createControl, control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
-    {
-        using var control = new SubTextBox
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        Control.ControlAccessibleObject instance = Assert.IsType<TextBox.TextBoxAccessibleObject>(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);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TextBox_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, true)]
-    [InlineData(ControlStyles.StandardClick, false)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, false)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TextBox_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTextBox();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TextBox_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTextBox();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBox_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBox_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TextBox_OnHandleDestroyed_Invoke_CallsHandleDestroyed(EventArgs eventArgs)
-    {
-        using var control = new SubTextBox();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnHandleDestroyed_TestData()
-    {
-        foreach (bool modified in new bool[] { true, false })
-        {
-            yield return new object[] { modified, null };
-            yield return new object[] { modified, new EventArgs() };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnHandleDestroyed_TestData))]
-    public void TextBox_OnHandleDestroyed_InvokeWithHandle_CallsHandleDestroyed(bool modified, EventArgs eventArgs)
-    {
-        using var control = new SubTextBox
-        {
-            Text = "Text",
-            SelectionStart = 1,
-            SelectionLength = 2,
-            Modified = modified
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleDestroyed += handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(modified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.HandleDestroyed -= handler;
-        control.OnHandleDestroyed(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.Equal(s_preferredHeight, control.Height);
-        Assert.Equal(0, control.SelectionStart);
-        Assert.Equal(0, control.SelectionLength);
-        Assert.Equal(modified, control.Modified);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    private class SubTextBox : TextBox
-    {
-        public int TextCount;
-        public bool IsFocused;
-        public bool TextAccessed;
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool IsHandleCreated => base.IsHandleCreated;
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public override string PlaceholderText { get => base.PlaceholderText; set => base.PlaceholderText = value; }
-
-        public new AccessibleObject CreateAccessibilityInstance() => base.CreateAccessibilityInstance();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public override bool Focused => IsFocused;
-        public override int TextLength => TextCount;
-
-        public override string Text
-        {
-            get
-            {
-                TextAccessed = true;
-                return base.Text;
-            }
-            set => base.Text = value;
-        }
-
-        public bool IsUserPaint
-        {
-            get => GetStyle(ControlStyles.UserPaint);
-            set => SetStyle(ControlStyles.UserPaint, value);
-        }
-
-        public new void CreateControl() => base.CreateControl();
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ThreadContextTests.cs b/src/System.Windows.Forms/tests/UnitTests/ThreadContextTests.cs
deleted file mode 100644
index b94fd7dcd09..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ThreadContextTests.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Moq;
-
-namespace System.Windows.Forms.Tests;
-
-public class ThreadContextTests
-{
-    private delegate bool MessageCallback(ref Message m);
-
-    // WM_USER is 0x400, just need to be above that
-    const uint TestMessageId1 = 0x441;
-    const uint TestMessageId2 = 0x442;
-    const uint TestMessageId3 = 0x443;
-
-    [StaFact]
-    public void ThreadContext_EmptyProcessFiltersWorks()
-    {
-        // Test that no filters at all does not throw, and that returns false from translation
-        Application.ThreadContext threadContext = new Application.ThreadContext();
-        var msg = new MSG();
-        Assert.False(threadContext.PreTranslateMessage(ref msg));
-    }
-
-    [StaFact]
-    public void ThreadContext_WrongProcessFiltersPassesThrough()
-    {
-        // Test that a filter for the wrong ID returns false, but does get called
-        Application.ThreadContext threadContext = new Application.ThreadContext();
-
-        MessageId filterId = TestMessageId2;
-        var mockContext = new Mock<IMessageFilter>(MockBehavior.Strict);
-        mockContext.Setup(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny))
-                   .Returns((MessageCallback)((ref Message m) => m.Msg == (int)filterId));
-
-        threadContext.AddMessageFilter(mockContext.Object);
-        var msg = new MSG
-        {
-            message = (uint)TestMessageId1
-        };
-        Assert.False(threadContext.PreTranslateMessage(ref msg));
-        mockContext.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(1));
-    }
-
-    [StaFact]
-    public void ThreadContext_CorrectProcessFiltersProcesses()
-    {
-        // Test that a filter with the correct ID returns true
-        Application.ThreadContext threadContext = new Application.ThreadContext();
-
-        MessageId filterId = TestMessageId2;
-        var mockContext = new Mock<IMessageFilter>(MockBehavior.Strict);
-        mockContext.Setup(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny))
-                   .Returns((MessageCallback)((ref Message m) => m.Msg == (int)filterId));
-
-        threadContext.AddMessageFilter(mockContext.Object);
-        var msg = new MSG
-        {
-            message = (uint)filterId
-        };
-        Assert.True(threadContext.PreTranslateMessage(ref msg));
-        mockContext.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(1));
-    }
-
-    [StaFact]
-    public void ThreadContext_MultipleProcessFiltersProcesses()
-    {
-        // Test that multiple filters work
-        Application.ThreadContext threadContext = new Application.ThreadContext();
-
-        MessageId filterId2 = TestMessageId2;
-        var mockContext2 = new Mock<IMessageFilter>(MockBehavior.Strict);
-        mockContext2.Setup(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny))
-                   .Returns((MessageCallback)((ref Message m) => m.Msg == (int)filterId2));
-        threadContext.AddMessageFilter(mockContext2.Object);
-
-        MessageId filterId3 = TestMessageId3;
-        var mockContext3 = new Mock<IMessageFilter>(MockBehavior.Strict);
-        mockContext3.Setup(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny))
-                   .Returns((MessageCallback)((ref Message m) => m.Msg == (int)filterId3));
-        threadContext.AddMessageFilter(mockContext3.Object);
-
-        var msg = new MSG
-        {
-            message = (uint)TestMessageId1
-        };
-        Assert.False(threadContext.PreTranslateMessage(ref msg));
-
-        mockContext2.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(1));
-        mockContext3.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(1));
-
-        msg = new MSG
-        {
-            message = (uint)TestMessageId2
-        };
-        Assert.True(threadContext.PreTranslateMessage(ref msg));
-
-        mockContext2.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(2));
-        mockContext3.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(1));
-
-        msg = new MSG
-        {
-            message = (uint)TestMessageId3
-        };
-        Assert.True(threadContext.PreTranslateMessage(ref msg));
-
-        mockContext2.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(3));
-        mockContext3.Verify(c => c.PreFilterMessage(ref It.Ref<Message>.IsAny), Times.Exactly(2));
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ToolStripContainerTests.cs b/src/System.Windows.Forms/tests/UnitTests/ToolStripContainerTests.cs
deleted file mode 100644
index 02fd4fda716..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ToolStripContainerTests.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripContainerTests
-{
-    [WinFormsFact]
-    public void ToolStripContainer_Constructor()
-    {
-        using var tsc = new ToolStripContainer();
-
-        Assert.NotNull(tsc);
-        Assert.NotNull(tsc.TopToolStripPanel);
-        Assert.NotNull(tsc.BottomToolStripPanel);
-        Assert.NotNull(tsc.LeftToolStripPanel);
-        Assert.NotNull(tsc.RightToolStripPanel);
-        Assert.NotNull(tsc.ContentPanel);
-        Assert.Equal(DockStyle.Top, tsc.TopToolStripPanel.Dock);
-        Assert.Equal(DockStyle.Bottom, tsc.BottomToolStripPanel.Dock);
-        Assert.Equal(DockStyle.Left, tsc.LeftToolStripPanel.Dock);
-        Assert.Equal(DockStyle.Right, tsc.RightToolStripPanel.Dock);
-
-        Assert.NotNull(tsc.Controls);
-        Assert.Equal(5, tsc.Controls.Count);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/ToolStripDropDownMenuTests.cs b/src/System.Windows.Forms/tests/UnitTests/ToolStripDropDownMenuTests.cs
deleted file mode 100644
index 151fc722a09..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/ToolStripDropDownMenuTests.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Windows.Forms.Tests;
-
-public class ToolStripDropDownMenuTests
-{
-    [WinFormsFact]
-    public void ToolStripDropDownMenu_Constructor()
-    {
-        using var menu = new ToolStripDropDownMenu();
-
-        Assert.NotNull(menu);
-    }
-
-    [WinFormsFact]
-    public void ToolStripDropDownMenu_ConstructorOwnerItemBool()
-    {
-        using var owner = new ToolStripButton();
-        var isAutoGenerated = true;
-
-        using var menu = new ToolStripDropDownMenu(owner, isAutoGenerated);
-
-        Assert.NotNull(menu);
-        Assert.Equal(owner, menu.OwnerItem);
-        Assert.True(menu.IsAutoGenerated);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/TrackBarTests.cs b/src/System.Windows.Forms/tests/UnitTests/TrackBarTests.cs
deleted file mode 100644
index c1f1ff4394e..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/TrackBarTests.cs
+++ /dev/null
@@ -1,3313 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using System.Windows.Forms.TestUtilities;
-using static Interop;
-using Point = System.Drawing.Point;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-public class TrackBarTests
-{
-    public static readonly int s_dimension = (SystemInformation.HorizontalScrollBarHeight * 8) / 3;
-
-    [WinFormsFact]
-    public void TrackBar_Ctor_Default()
-    {
-        using var control = new SubTrackBar();
-        Assert.Null(control.AccessibleDefaultActionDescription);
-        Assert.Null(control.AccessibleDescription);
-        Assert.Null(control.AccessibleName);
-        Assert.Equal(AccessibleRole.Default, control.AccessibleRole);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.True(control.AutoSize);
-        Assert.Equal(Control.DefaultBackColor, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.Null(control.BindingContext);
-        Assert.Equal(s_dimension, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 104, s_dimension), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CanSelect);
-        Assert.False(control.Capture);
-        Assert.True(control.CausesValidation);
-        Assert.Equal(new Size(104, s_dimension), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, 104, s_dimension), control.ClientRectangle);
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.Empty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Same(Cursors.Default, control.Cursor);
-        Assert.Same(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Disable, 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(104, s_dimension), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(new Rectangle(0, 0, 104, s_dimension), control.DisplayRectangle);
-        Assert.Equal(DockStyle.None, control.Dock);
-        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.False(control.HasChildren);
-        Assert.Equal(s_dimension, control.Height);
-        Assert.Equal(ImeMode.Disable, control.ImeMode);
-        Assert.Equal(ImeMode.Disable, control.ImeModeBase);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Equal(5, control.LargeChange);
-        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(10, control.Maximum);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Orientation.Horizontal, control.Orientation);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.Equal(new Size(104, s_dimension), control.PreferredSize);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.False(control.ResizeRedraw);
-        Assert.Equal(104, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.False(control.RightToLeftLayout);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(1, control.TickFrequency);
-        Assert.Equal(TickStyle.BottomRight, control.TickStyle);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.False(control.UseWaitCursor);
-        Assert.Equal(0, control.Value);
-        Assert.True(control.Visible);
-        Assert.Equal(104, control.Width);
-
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_CreateParams_GetDefault_ReturnsExpected()
-    {
-        using var control = new SubTrackBar();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_trackbar32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(s_dimension, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010001, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TickStyle.Both, 0x56010009)]
-    [InlineData(TickStyle.BottomRight, 0x56010001)]
-    [InlineData(TickStyle.None, 0x56010010)]
-    [InlineData(TickStyle.TopLeft, 0x56010005)]
-    public void TrackBar_CreateParams_GetTickStyle_ReturnsExpected(TickStyle tickStyle, int expectedStyle)
-    {
-        using var control = new SubTrackBar
-        {
-            TickStyle = tickStyle
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_trackbar32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(s_dimension, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Orientation.Horizontal, 0x56010001)]
-    [InlineData(Orientation.Vertical, 0x56010003)]
-    public void TrackBar_CreateParams_GetOrientation_ReturnsExpected(Orientation orientation, int expectedStyle)
-    {
-        using var control = new SubTrackBar
-        {
-            Orientation = orientation
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_trackbar32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(0, createParams.ExStyle);
-        Assert.Equal(s_dimension, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(expectedStyle, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true, 0x0)]
-    [InlineData(RightToLeft.No, true, 0x0)]
-    [InlineData(RightToLeft.Yes, true, 0x500000)]
-    [InlineData(RightToLeft.Inherit, false, 0x0)]
-    [InlineData(RightToLeft.No, false, 0x0)]
-    [InlineData(RightToLeft.Yes, false, 0x7000)]
-    public void TrackBar_CreateParams_GetRightToLeft_ReturnsExpected(RightToLeft rightToLeft, bool rightToLeftLayout, int expectedExStyle)
-    {
-        using var control = new SubTrackBar
-        {
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Equal("msctls_trackbar32", createParams.ClassName);
-        Assert.Equal(0x8, createParams.ClassStyle);
-        Assert.Equal(expectedExStyle, createParams.ExStyle);
-        Assert.Equal(s_dimension, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(0x56010001, createParams.Style);
-        Assert.Equal(104, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_AutoSize_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar();
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_AutoSize_SetWithOrientation_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar
-        {
-            Orientation = Orientation.Vertical
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_AutoSize_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(new Size(104, s_dimension), control.Size);
-        Assert.False(control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_AutoSize_SetWithOrientationWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar
-        {
-            Orientation = Orientation.Vertical
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) => layoutCallCount++;
-
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(s_dimension, s_dimension), control.Size);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.AutoSize = value;
-        Assert.Equal(value, control.AutoSize);
-        Assert.Equal(new Size(s_dimension, s_dimension), control.Size);
-        Assert.Equal(value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.AutoSize = !value;
-        Assert.Equal(!value, control.AutoSize);
-        Assert.Equal(new Size(s_dimension, s_dimension), control.Size);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.Equal(0, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void ToolStrip_AutoSize_SetWithHandler_CallsAutoSizeChanged()
-    {
-        using var control = new ToolStrip
-        {
-            AutoSize = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.AutoSizeChanged += handler;
-
-        // Set different.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.AutoSize = true;
-        Assert.True(control.AutoSize);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.AutoSizeChanged -= handler;
-        control.AutoSize = false;
-        Assert.False(control.AutoSize);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetImageTheoryData))]
-    public void TrackBar_BackgroundImage_Set_GetReturnsExpected(Image value)
-    {
-        using var control = new TrackBar
-        {
-            BackgroundImage = value
-        };
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImage = value;
-        Assert.Same(value, control.BackgroundImage);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_BackgroundImage_SetWithHandler_CallsBackgroundImageChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageChanged += handler;
-
-        // Set different.
-        using var image1 = new Bitmap(10, 10);
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var image2 = new Bitmap(10, 10);
-        control.BackgroundImage = image2;
-        Assert.Same(image2, control.BackgroundImage);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.BackgroundImage = null;
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.BackgroundImageChanged -= handler;
-        control.BackgroundImage = image1;
-        Assert.Same(image1, control.BackgroundImage);
-        Assert.Equal(3, callCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<ImageLayout>]
-    public void TrackBar_BackgroundImageLayout_Set_GetReturnsExpected(ImageLayout value)
-    {
-        using var control = new SubTrackBar
-        {
-            BackgroundImageLayout = value
-        };
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.BackgroundImageLayout = value;
-        Assert.Equal(value, control.BackgroundImageLayout);
-        Assert.False(control.DoubleBuffered);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_BackgroundImageLayout_SetWithHandler_CallsBackgroundImageLayoutChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.BackgroundImageLayoutChanged += handler;
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.BackgroundImageLayout = ImageLayout.Stretch;
-        Assert.Equal(ImageLayout.Stretch, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.BackgroundImageLayoutChanged -= handler;
-        control.BackgroundImageLayout = ImageLayout.Center;
-        Assert.Equal(ImageLayout.Center, control.BackgroundImageLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_DoubleBuffered_Get_ReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar();
-        control.SetStyle(ControlStyles.OptimizedDoubleBuffer, value);
-        Assert.Equal(value, control.DoubleBuffered);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_DoubleBuffered_Set_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar
-        {
-            DoubleBuffered = value
-        };
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_DoubleBuffered_SetWithHandle_GetReturnsExpected(bool value)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.DoubleBuffered = value;
-        Assert.Equal(value, control.DoubleBuffered);
-        Assert.Equal(value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set different.
-        control.DoubleBuffered = !value;
-        Assert.Equal(!value, control.DoubleBuffered);
-        Assert.Equal(!value, control.GetStyle(ControlStyles.OptimizedDoubleBuffer));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetFontTheoryData))]
-    public void TrackBar_Font_Set_GetReturnsExpected(Font value)
-    {
-        using var control = new SubTrackBar
-        {
-            Font = value
-        };
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Font = value;
-        Assert.Equal(value ?? Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Font_SetWithHandler_CallsFontChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.FontChanged += handler;
-
-        // Set different.
-        using var font1 = new Font("Arial", 8.25f);
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        using var font2 = SystemFonts.DialogFont;
-        control.Font = font2;
-        Assert.Same(font2, control.Font);
-        Assert.Equal(2, callCount);
-
-        // Set null.
-        control.Font = null;
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(3, callCount);
-
-        // Remove handler.
-        control.FontChanged -= handler;
-        control.Font = font1;
-        Assert.Same(font1, control.Font);
-        Assert.Equal(3, callCount);
-    }
-
-    public static IEnumerable<object[]> ForeColor_Set_TestData()
-    {
-        yield return new object[] { Color.Red };
-        yield return new object[] { Color.FromArgb(254, 1, 2, 3) };
-        yield return new object[] { Color.White };
-        yield return new object[] { Color.Black };
-        yield return new object[] { Color.Empty };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void TrackBar_ForeColor_Set_Nop(Color value)
-    {
-        using var control = new TrackBar
-        {
-            ForeColor = value
-        };
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ForeColor_Set_TestData))]
-    public void TrackBar_ForeColor_SetWithHandle_Nop(Color value)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ForeColor = value;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ForeColor = value;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_ForeColor_SetWithHandler_DoesNotCallForeColorChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ForeColorChanged += handler;
-
-        // Set different.
-        control.ForeColor = Color.Red;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ForeColor = Color.Red;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ForeColor = Color.Empty;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ForeColorChanged -= handler;
-        control.ForeColor = Color.Red;
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Handle_GetWithMaximum_Success()
-    {
-        using var control = new TrackBar
-        {
-            Maximum = 11
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(11, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Handle_GetWithMinimum_Success()
-    {
-        using var control = new TrackBar
-        {
-            Minimum = 11
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(11, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Inherit, true, 5)]
-    [InlineData(RightToLeft.No, true, 5)]
-    [InlineData(RightToLeft.Yes, true, 5)]
-    [InlineData(RightToLeft.Inherit, false, 5)]
-    [InlineData(RightToLeft.No, false, 5)]
-    [InlineData(RightToLeft.Yes, false, 5)]
-    public void TrackBar_Handle_GetWithValue_Success(RightToLeft rightToLeft, bool rightToLeftLayout, int expected)
-    {
-        using var control = new TrackBar
-        {
-            Value = 5,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Handle_GetWithValueVertical_Success()
-    {
-        using var control = new TrackBar
-        {
-            Orientation = Orientation.Vertical,
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Handle_GetWithLargeChange_Success()
-    {
-        using var control = new TrackBar
-        {
-            LargeChange = 11
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(11, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPAGESIZE));
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Handle_GetWithSmallChange_Success()
-    {
-        using var control = new TrackBar
-        {
-            SmallChange = 11
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(11, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETLINESIZE));
-    }
-
-    public static IEnumerable<object[]> Handle_GetSize_TestData()
-    {
-        yield return new object[] { true, Orientation.Horizontal, new Size(104, s_dimension) };
-        yield return new object[] { true, Orientation.Vertical, new Size(s_dimension, s_dimension) };
-        yield return new object[] { false, Orientation.Horizontal, new Size(104, s_dimension) };
-        yield return new object[] { false, Orientation.Vertical, new Size(s_dimension, s_dimension) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Handle_GetSize_TestData))]
-    public void TrackBar_Handle_GetSize_Success(bool autoSize, Orientation orientation, Size expected)
-    {
-        using var control = new TrackBar
-        {
-            AutoSize = autoSize,
-            Orientation = orientation
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        Assert.Equal(expected, control.Size);
-    }
-
-    public static IEnumerable<object[]> ImeMode_Set_TestData()
-    {
-        yield return new object[] { ImeMode.Inherit, ImeMode.NoControl };
-        yield return new object[] { ImeMode.NoControl, ImeMode.NoControl };
-        yield return new object[] { ImeMode.On, ImeMode.On };
-        yield return new object[] { ImeMode.Off, ImeMode.Off };
-        yield return new object[] { ImeMode.Disable, ImeMode.Disable };
-        yield return new object[] { ImeMode.Hiragana, ImeMode.Hiragana };
-        yield return new object[] { ImeMode.Katakana, ImeMode.Katakana };
-        yield return new object[] { ImeMode.KatakanaHalf, ImeMode.KatakanaHalf };
-        yield return new object[] { ImeMode.AlphaFull, ImeMode.AlphaFull };
-        yield return new object[] { ImeMode.Alpha, ImeMode.Alpha };
-        yield return new object[] { ImeMode.HangulFull, ImeMode.HangulFull };
-        yield return new object[] { ImeMode.Hangul, ImeMode.Hangul };
-        yield return new object[] { ImeMode.Close, ImeMode.Close };
-        yield return new object[] { ImeMode.OnHalf, ImeMode.On };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void TrackBar_ImeMode_Set_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new TrackBar
-        {
-            ImeMode = value
-        };
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(ImeMode_Set_TestData))]
-    public void TrackBar_ImeMode_SetWithHandle_GetReturnsExpected(ImeMode value, ImeMode expected)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.ImeMode = value;
-        Assert.Equal(expected, control.ImeMode);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_ImeMode_SetWithHandler_CallsImeModeChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ImeModeChanged += handler;
-
-        // Set different.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set same.
-        control.ImeMode = ImeMode.On;
-        Assert.Equal(ImeMode.On, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Set different.
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-
-        // Remove handler.
-        control.ImeModeChanged -= handler;
-        control.ImeMode = ImeMode.Off;
-        Assert.Equal(ImeMode.Off, control.ImeMode);
-        Assert.Equal(0, callCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<ImeMode>]
-    public void TrackBar_ImeMode_SetInvalid_ThrowsInvalidEnumArgumentException(ImeMode value)
-    {
-        using var control = new TrackBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.ImeMode = value);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(11)]
-    public void TrackBar_LargeChange_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar
-        {
-            LargeChange = value
-        };
-        Assert.Equal(value, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(11)]
-    public void TrackBar_LargeChange_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPAGESIZE));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.LargeChange = value;
-        Assert.Equal(value, control.LargeChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPAGESIZE));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_LargeChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubTrackBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.LargeChange = -1);
-        Assert.Equal(5, control.LargeChange);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(8)]
-    [InlineData(10)]
-    [InlineData(11)]
-    public void TrackBar_Maximum_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar
-        {
-            Maximum = value
-        };
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0, 1)]
-    [InlineData(8, 1)]
-    [InlineData(10, 0)]
-    [InlineData(11, 1)]
-    public void TrackBar_Maximum_SetWithHandle_GetReturnsExpected(int value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Maximum = value;
-        Assert.Equal(value, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(0, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(0, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Maximum_SetLessThanValueAndMinimum_SetsValueAndMinimum()
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 10,
-            Minimum = 8,
-            Maximum = 5
-        };
-        Assert.Equal(5, control.Maximum);
-        Assert.Equal(5, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Maximum_SetLessThanValueAndMinimumWithHandle_SetsValueAndMinimum()
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 10,
-            Minimum = 8
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Maximum = 5;
-        Assert.Equal(5, control.Maximum);
-        Assert.Equal(5, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Maximum_SetNegative_SetsValueAndMinimum()
-    {
-        using var control = new SubTrackBar
-        {
-            Maximum = -1
-        };
-        Assert.Equal(-1, control.Maximum);
-        Assert.Equal(-1, control.Minimum);
-        Assert.Equal(-1, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(5)]
-    public void TrackBar_Minimum_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 5,
-            Minimum = value
-        };
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 0)]
-    [InlineData(5, 1)]
-    public void TrackBar_Minimum_SetWithHandle_GetReturnsExpected(int value, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Minimum = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(10, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Minimum = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(value, control.Minimum);
-        Assert.Equal(5, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(10, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(5, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Minimum_SetGreaterThanValueAndMaximum_SetsValueAndMinimum()
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 10,
-            Maximum = 8,
-            Minimum = 12
-        };
-        Assert.Equal(12, control.Maximum);
-        Assert.Equal(12, control.Minimum);
-        Assert.Equal(12, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Minimum_SetGreaterThanValueAndMaximumWithHandle_SetsValueAndMinimum()
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 10,
-            Maximum = 8
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Minimum = 12;
-        Assert.Equal(12, control.Maximum);
-        Assert.Equal(12, control.Minimum);
-        Assert.Equal(12, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(12, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(12, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(12, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(1, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Orientation_Set_TestData()
-    {
-        yield return new object[] { true, Orientation.Horizontal, new Size(104, s_dimension), false };
-        yield return new object[] { true, Orientation.Vertical, new Size(104, s_dimension), true };
-        yield return new object[] { false, Orientation.Horizontal, new Size(104, s_dimension), false };
-        yield return new object[] { false, Orientation.Vertical, new Size(104, s_dimension), false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Orientation_Set_TestData))]
-    public void TrackBar_Orientation_Set_GetReturnsExpected(bool autoSize, Orientation value, Size expectedSize, bool expectedFixedWidth)
-    {
-        using var control = new SubTrackBar
-        {
-            AutoSize = autoSize,
-            Orientation = value
-        };
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.False(control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Orientation_SetWithCustomOldValue_TestData()
-    {
-        yield return new object[] { true, Orientation.Horizontal, new Size(s_dimension, s_dimension), false, true };
-        yield return new object[] { true, Orientation.Vertical, new Size(104, s_dimension), true, false };
-        yield return new object[] { false, Orientation.Horizontal, new Size(s_dimension, s_dimension), false, false };
-        yield return new object[] { false, Orientation.Vertical, new Size(104, s_dimension), false, false };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Orientation_SetWithCustomOldValue_TestData))]
-    public void TrackBar_Orientation_SetWithCustomOldValue_GetReturnsExpected(bool autoSize, Orientation value, Size expectedSize, bool expectedFixedWidth, bool expectedFixedHeight)
-    {
-        using var control = new SubTrackBar
-        {
-            AutoSize = autoSize,
-            Orientation = Orientation.Vertical
-        };
-
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Orientation_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, Orientation.Horizontal, new Size(104, s_dimension), false, false, 0 };
-        yield return new object[] { true, Orientation.Vertical, new Size(s_dimension, 104), true, false, 1 };
-        yield return new object[] { false, Orientation.Horizontal, new Size(104, s_dimension), false, false, 0 };
-        yield return new object[] { false, Orientation.Vertical, new Size(s_dimension, 104), false, false, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Orientation_SetWithHandle_TestData))]
-    public void TrackBar_Orientation_SetWithHandle_GetReturnsExpected(bool autoSize, Orientation value, Size expectedSize, bool expectedFixedWidth, bool expectedFixedHeight, int expectedCreatedCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            AutoSize = autoSize
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> Orientation_SetWithCustomOldValueWithHandle_TestData()
-    {
-        yield return new object[] { true, Orientation.Horizontal, new Size(s_dimension, s_dimension), false, true, 1 };
-        yield return new object[] { true, Orientation.Vertical, new Size(s_dimension, s_dimension), true, false, 0 };
-        yield return new object[] { false, Orientation.Horizontal, new Size(s_dimension, s_dimension), false, false, 1 };
-        yield return new object[] { false, Orientation.Vertical, new Size(s_dimension, s_dimension), false, false, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Orientation_SetWithCustomOldValueWithHandle_TestData))]
-    public void TrackBar_Orientation_SetWithCustomOldValueWithHandle_GetReturnsExpected(bool autoSize, Orientation value, Size expectedSize, bool expectedFixedWidth, bool expectedFixedHeight, int expectedCreatedCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            AutoSize = autoSize,
-            Orientation = Orientation.Vertical
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.Orientation = value;
-        Assert.Equal(value, control.Orientation);
-        Assert.Equal(expectedSize, control.Size);
-        Assert.Equal(expectedFixedWidth, control.GetStyle(ControlStyles.FixedWidth));
-        Assert.Equal(expectedFixedHeight, control.GetStyle(ControlStyles.FixedHeight));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<Orientation>]
-    public void TrackBar_Orientation_SetInvalidValue_ThrowsInvalidEnumArgumentException(Orientation value)
-    {
-        using var control = new TrackBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.Orientation = value);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TrackBar_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TrackBar
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
-    public void TrackBar_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        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);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Padding_SetWithHandler_CallsPaddingChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Equal(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.PaddingChanged += handler;
-
-        // Set different.
-        var padding1 = new Padding(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        var padding2 = new Padding(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1)]
-    [InlineData(RightToLeft.Yes, false, 0)]
-    [InlineData(RightToLeft.No, true, 1)]
-    [InlineData(RightToLeft.No, false, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1)]
-    [InlineData(RightToLeft.Inherit, false, 0)]
-    public void TrackBar_RightToLeftLayout_Set_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            RightToLeft = rightToLeft
-        };
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(RightToLeft.Yes, true, 1, 1, 2)]
-    [InlineData(RightToLeft.Yes, false, 0, 0, 1)]
-    [InlineData(RightToLeft.No, true, 1, 0, 0)]
-    [InlineData(RightToLeft.No, false, 0, 0, 0)]
-    [InlineData(RightToLeft.Inherit, true, 1, 0, 0)]
-    [InlineData(RightToLeft.Inherit, false, 0, 0, 0)]
-    public void TrackBar_RightToLeftLayout_SetWithHandle_GetReturnsExpected(RightToLeft rightToLeft, bool value, int expectedLayoutCallCount, int expectedCreatedCallCount1, int expectedCreatedCallCount2)
-    {
-        using var control = new TrackBar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        int layoutCallCount = 0;
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("RightToLeftLayout", e.AffectedProperty);
-            layoutCallCount++;
-        };
-
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set same.
-        control.RightToLeftLayout = value;
-        Assert.Equal(value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount1, createdCallCount);
-
-        // Set different.
-        control.RightToLeftLayout = !value;
-        Assert.Equal(!value, control.RightToLeftLayout);
-        Assert.Equal(expectedLayoutCallCount + 1, layoutCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_RightToLeftLayout_SetWithHandler_CallsRightToLeftLayoutChanged()
-    {
-        using var control = new TrackBar
-        {
-            RightToLeftLayout = true
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.RightToLeftLayoutChanged += handler;
-
-        // Set different.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.RightToLeftLayout = true;
-        Assert.True(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.RightToLeftLayout = false;
-        Assert.False(control.RightToLeftLayout);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_RightToLeftLayout_SetWithHandlerInDisposing_DoesNotRightToLeftLayoutChanged()
-    {
-        using var control = new TrackBar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.RightToLeftLayout = true;
-            Assert.True(control.RightToLeftLayout);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(11)]
-    public void TrackBar_SmallChange_Set_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar
-        {
-            SmallChange = value
-        };
-        Assert.Equal(value, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SmallChange = value;
-        Assert.Equal(value, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(11)]
-    public void TrackBar_SmallChange_SetWithHandle_GetReturnsExpected(int value)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SmallChange = value;
-        Assert.Equal(value, control.SmallChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETLINESIZE));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.SmallChange = value;
-        Assert.Equal(value, control.SmallChange);
-        Assert.Equal(value, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETLINESIZE));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_SmallChange_SetNegative_ThrowsArgumentOutOfRangeException()
-    {
-        using var control = new SubTrackBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SmallChange = -1);
-        Assert.Equal(1, control.SmallChange);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TrackBar_Text_Set_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TrackBar
-        {
-            Text = value
-        };
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NormalizedStringData]
-    public void TrackBar_Text_SetWithHandle_GetReturnsExpected(string value, string expected)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Text = value;
-        Assert.Equal(expected, control.Text);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Text_SetWithHandler_CallsTextChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Equal(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.TextChanged += handler;
-
-        // Set different.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Text = null;
-        Assert.Empty(control.Text);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.TextChanged -= handler;
-        control.Text = "text";
-        Assert.Equal("text", control.Text);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(20)]
-    [InlineData(int.MaxValue)]
-    public void TrackBar_TickFrequency_Set_GetReturnsExpected(int value)
-    {
-        using var control = new TrackBar
-        {
-            TickFrequency = value
-        };
-        Assert.Equal(value, control.TickFrequency);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TickFrequency = value;
-        Assert.Equal(value, control.TickFrequency);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 1)]
-    [InlineData(0, 1)]
-    [InlineData(1, 0)]
-    [InlineData(20, 1)]
-    [InlineData(int.MaxValue, 1)]
-    public void TrackBar_TickFrequency_SetWithHandle_GetReturnsExpected(int value, int expectedInvalidatedCallCount)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TickFrequency = value;
-        Assert.Equal(value, control.TickFrequency);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.TickFrequency = value;
-        Assert.Equal(value, control.TickFrequency);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [EnumData<TickStyle>]
-    public void TrackBar_TickStyle_Set_GetReturnsExpected(TickStyle value)
-    {
-        using var control = new TrackBar
-        {
-            TickStyle = value
-        };
-        Assert.Equal(value, control.TickStyle);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.TickStyle = value;
-        Assert.Equal(value, control.TickStyle);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(TickStyle.Both, 1)]
-    [InlineData(TickStyle.BottomRight, 0)]
-    [InlineData(TickStyle.None, 1)]
-    [InlineData(TickStyle.TopLeft, 1)]
-    public void TrackBar_TickStyle_SetWithHandle_GetReturnsExpected(TickStyle value, int expectedCreatedCallCount)
-    {
-        using var control = new TrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.TickStyle = value;
-        Assert.Equal(value, control.TickStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Set same.
-        control.TickStyle = value;
-        Assert.Equal(value, control.TickStyle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [InvalidEnumData<TickStyle>]
-    public void TrackBar_TickStyle_SetInvalidValue_ThrowsInvalidEnumArgumentException(TickStyle value)
-    {
-        using var control = new TrackBar();
-        Assert.Throws<InvalidEnumArgumentException>("value", () => control.TickStyle = value);
-    }
-
-    public static IEnumerable<object[]> Value_Set_TestData()
-    {
-        foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-        {
-            foreach (RightToLeft rightToLeft in Enum.GetValues(typeof(RightToLeft)))
-            {
-                foreach (bool rightToLeftLayout in new bool[] { true, false })
-                {
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 0 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 1 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 5 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 9 };
-                    yield return new object[] { orientation, rightToLeft, rightToLeftLayout, 10 };
-                }
-            }
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_Set_TestData))]
-    public void TrackBar_Value_Set_GetReturnsExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int value)
-    {
-        using var control = new TrackBar
-        {
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout,
-            Value = value
-        };
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(9)]
-    [InlineData(10)]
-    [InlineData(11)]
-    public void TrackBar_Value_SetInitialising_GetReturnsExpected(int value)
-    {
-        using var control = new TrackBar();
-        control.BeginInit();
-
-        control.Value = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Value_SetWithHandle_TestData()
-    {
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, true, 0, 0 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, false, 0, 10 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, true, 0, 0 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, false, 0, 0 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, true, 0, 0 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, false, 0, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, true, 0, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, false, 0, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, true, 0, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, false, 0, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, true, 0, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, false, 0, 10 };
-
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, true, 1, 1 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, false, 1, 9 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, true, 1, 1 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, false, 1, 1 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, true, 1, 1 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, false, 1, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, true, 1, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, false, 1, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, true, 1, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, false, 1, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, true, 1, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, false, 1, 9 };
-
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, true, 5, 5 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, false, 5, 5 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, true, 5, 5 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, false, 5, 5 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, true, 5, 5 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, false, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, true, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, false, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, true, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, false, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, true, 5, 5 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, false, 5, 5 };
-
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, true, 9, 9 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, false, 9, 1 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, true, 9, 9 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, false, 9, 9 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, true, 9, 9 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, false, 9, 9 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, true, 9, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, false, 9, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, true, 9, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, false, 9, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, true, 9, 1 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, false, 9, 1 };
-
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, true, 10, 10 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Yes, false, 10, 0 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, true, 10, 10 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.No, false, 10, 10 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, true, 10, 10 };
-        yield return new object[] { Orientation.Horizontal, RightToLeft.Inherit, false, 10, 10 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, true, 10, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Yes, false, 10, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, true, 10, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.No, false, 10, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, true, 10, 0 };
-        yield return new object[] { Orientation.Vertical, RightToLeft.Inherit, false, 10, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Value_SetWithHandle_TestData))]
-    public void TrackBar_Value_SetWithHandle_GetReturnsExpected(Orientation orientation, RightToLeft rightToLeft, bool rightToLeftLayout, int value, int expectedPos)
-    {
-        using var control = new TrackBar
-        {
-            Orientation = orientation,
-            RightToLeft = rightToLeft,
-            RightToLeftLayout = rightToLeftLayout
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Value = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(expectedPos, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Value = value;
-        Assert.Equal(10, control.Maximum);
-        Assert.Equal(0, control.Minimum);
-        Assert.Equal(value, control.Value);
-        Assert.Equal(5, control.LargeChange);
-        Assert.Equal(1, control.SmallChange);
-        Assert.Equal(expectedPos, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_Value_SetWithHandler_CallsValueChanged()
-    {
-        using var control = new TrackBar();
-        int callCount = 0;
-        EventHandler valueChangedHandler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        control.ValueChanged += valueChangedHandler;
-
-        // Set different.
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(1, callCount);
-
-        // Set same.
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(1, callCount);
-
-        // Set different.
-        control.Value = 2;
-        Assert.Equal(2, control.Value);
-        Assert.Equal(2, callCount);
-
-        // Remove handler.
-        control.ValueChanged -= valueChangedHandler;
-        control.Value = 1;
-        Assert.Equal(1, control.Value);
-        Assert.Equal(2, callCount);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(11)]
-    public void TrackBar_Value_SetOutOfRange_ThrowsArgumentOutOfRangeException(int value)
-    {
-        using var control = new TrackBar();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.Value = value);
-        Assert.Equal(0, control.Value);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_BeginInit_InvokeMultipleTimes_Success()
-    {
-        using var control = new TrackBar();
-        control.BeginInit();
-
-        // Call again.
-        control.BeginInit();
-    }
-
-    [WinFormsFact]
-    public void TrackBar_CreateHandle_Invoke_Success()
-    {
-        using var control = new SubTrackBar();
-        control.CreateHandle();
-        Assert.True(control.Created);
-        Assert.True(control.IsHandleCreated);
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-    }
-
-    [WinFormsTheory]
-    [InlineData(0)]
-    [InlineData(1)]
-    [InlineData(5)]
-    [InlineData(9)]
-    [InlineData(10)]
-    public void TrackBar_EndInit_InvokeNotInitializing_Nop(int value)
-    {
-        using var control = new TrackBar();
-        control.Value = value;
-        Assert.Equal(value, control.Value);
-
-        control.EndInit();
-        Assert.Equal(value, control.Value);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.EndInit();
-        Assert.Equal(value, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0)]
-    [InlineData(0, 0)]
-    [InlineData(1, 1)]
-    [InlineData(5, 5)]
-    [InlineData(9, 9)]
-    [InlineData(10, 10)]
-    [InlineData(11, 10)]
-    public void TrackBar_EndInit_InvokeInitializing_Success(int value, int expectedValue)
-    {
-        using var control = new TrackBar();
-        control.BeginInit();
-        control.Value = value;
-        Assert.Equal(value, control.Value);
-
-        control.EndInit();
-        Assert.Equal(expectedValue, control.Value);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.EndInit();
-        Assert.Equal(expectedValue, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTrackBar();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, false)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void TrackBar_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubTrackBar();
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void TrackBar_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubTrackBar();
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.Alt, false)]
-    [InlineData(Keys.Alt | Keys.PageUp, false)]
-    [InlineData(Keys.PageUp, true)]
-    [InlineData(Keys.PageDown, true)]
-    [InlineData(Keys.Home, true)]
-    [InlineData(Keys.End, true)]
-    [InlineData(Keys.A, false)]
-    public void TrackBar_IsInputKey_Invoke_ReturnsExpected(Keys keyData, bool expected)
-    {
-        using var control = new SubTrackBar();
-        Assert.Equal(expected, control.IsInputKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnBackColorChanged_Invoke_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnBackColorChanged_InvokeWithHandle_CallsBackColorChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.BackColorChanged += handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.BackColorChanged -= handler;
-        control.OnBackColorChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnClick_Invoke_CallsClick(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Click += handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Click -= handler;
-        control.OnClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnDoubleClick_Invoke_CallsDoubleClick(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.DoubleClick += handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.DoubleClick -= handler;
-        control.OnDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnHandleCreated_Invoke_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnHandleCreated_InvokeWithHandle_CallsHandleCreated(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.HandleCreated += handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-
-        // Remove handler.
-        control.HandleCreated -= handler;
-        control.OnHandleCreated(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void TrackBar_OnMouseClick_Invoke_CallsMouseClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseClick += handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseClick -= handler;
-        control.OnMouseClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetMouseEventArgsTheoryData))]
-    public void TrackBar_OnMouseDoubleClick_Invoke_CallsMouseDoubleClick(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseDoubleClick += handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseDoubleClick -= handler;
-        control.OnMouseDoubleClick(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> MouseEventArgs_TestData()
-    {
-        yield return new object[] { new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 0, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 1, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 2, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Left, 3, 0, 0, 0) };
-        yield return new object[] { new MouseEventArgs(MouseButtons.Right, 3, 0, 0, 0) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(MouseEventArgs_TestData))]
-    public void TrackBar_OnMouseWheel_Invoke_CallsMouseWheel(MouseEventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.MouseWheel += handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.MouseWheel -= handler;
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [BoolData]
-    public void TrackBar_OnMouseWheel_InvokeHandledMouseEventArgs_SetsHandled(bool handled)
-    {
-        using var control = new SubTrackBar();
-        var eventArgs = new HandledMouseEventArgs(MouseButtons.Left, 1, 2, 3, 4, handled);
-        int callCount = 0;
-        MouseEventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            Assert.Equal(handled, eventArgs.Handled);
-            callCount++;
-        };
-        control.MouseWheel += handler;
-
-        control.OnMouseWheel(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(eventArgs.Handled);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_OnMouseWheel_NullE_ThrowsNullReferenceException()
-    {
-        using var control = new SubTrackBar();
-        Assert.Throws<NullReferenceException>(() => control.OnMouseWheel(null));
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null };
-        yield return new object[] { RightToLeft.Yes, new EventArgs() };
-        yield return new object[] { RightToLeft.No, null };
-        yield return new object[] { RightToLeft.No, new EventArgs() };
-        yield return new object[] { RightToLeft.Inherit, null };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs() };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_TestData))]
-    public void TrackBar_OnRightToLeftLayoutChanged_Invoke_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar
-        {
-            RightToLeft = rightToLeft
-        };
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> OnRightToLeftLayoutChanged_WithHandle_TestData()
-    {
-        yield return new object[] { RightToLeft.Yes, null, 1 };
-        yield return new object[] { RightToLeft.Yes, new EventArgs(), 1 };
-        yield return new object[] { RightToLeft.No, null, 0 };
-        yield return new object[] { RightToLeft.No, new EventArgs(), 0 };
-        yield return new object[] { RightToLeft.Inherit, null, 0 };
-        yield return new object[] { RightToLeft.Inherit, new EventArgs(), 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(OnRightToLeftLayoutChanged_WithHandle_TestData))]
-    public void TrackBar_OnRightToLeftLayoutChanged_InvokeWithHandle_CallsRightToLeftLayoutChanged(RightToLeft rightToLeft, EventArgs eventArgs, int expectedCreatedCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            RightToLeft = rightToLeft
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.RightToLeftLayoutChanged += handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount, createdCallCount);
-
-        // Remove handler.
-        control.RightToLeftLayoutChanged -= handler;
-        control.OnRightToLeftLayoutChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(expectedCreatedCallCount * 2, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_OnRightToLeftLayoutChanged_InvokeInDisposing_DoesNotCallRightToLeftLayoutChanged()
-    {
-        using var control = new SubTrackBar
-        {
-            RightToLeft = RightToLeft.Yes
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-
-        int callCount = 0;
-        control.RightToLeftLayoutChanged += (sender, e) => callCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int disposedCallCount = 0;
-        control.Disposed += (sender, e) =>
-        {
-            control.OnRightToLeftLayoutChanged(EventArgs.Empty);
-            Assert.Equal(0, callCount);
-            Assert.Equal(0, createdCallCount);
-            disposedCallCount++;
-        };
-
-        control.Dispose();
-        Assert.Equal(1, disposedCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnScroll_Invoke_CallsScroll(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.Scroll += handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.Scroll -= handler;
-        control.OnScroll(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnSystemColorsChanged_Invoke_CallsSystemColorsChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SystemColorsChanged += handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Remove handler.
-        control.SystemColorsChanged -= handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnSystemColorsChanged_InvokeWithHandle_CallsSystemColorsChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.SystemColorsChanged += handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(2, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Remove handler.
-        control.SystemColorsChanged -= handler;
-        control.OnSystemColorsChanged(eventArgs);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(4, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsTheory]
-    [NewAndDefaultData<EventArgs>]
-    public void TrackBar_OnValueChanged_Invoke_CallsValueChanged(EventArgs eventArgs)
-    {
-        using var control = new SubTrackBar();
-        int callCount = 0;
-        EventHandler handler = (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
-            callCount++;
-        };
-
-        // Call with handler.
-        control.ValueChanged += handler;
-        control.OnValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-
-        // Remove handler.
-        control.ValueChanged -= handler;
-        control.OnValueChanged(eventArgs);
-        Assert.Equal(1, callCount);
-    }
-
-    public static IEnumerable<object[]> SetBoundsCore_TestData()
-    {
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            foreach (Orientation orientation in Enum.GetValues(typeof(Orientation)))
-            {
-                yield return new object[] { false, orientation, 0, 0, 104, s_dimension, specified, 104, s_dimension, 0, 0 };
-                yield return new object[] { false, orientation, 0, 0, 0, 0, specified, 0, 0, 0, 1 };
-                yield return new object[] { false, orientation, -1, -2, -3, -4, specified, -3, -4, 1, 1 };
-                yield return new object[] { false, orientation, 1, 0, 0, 0, specified, 0, 0, 1, 1 };
-                yield return new object[] { false, orientation, 0, 2, 0, 0, specified, 0, 0, 1, 1 };
-                yield return new object[] { false, orientation, 1, 2, 0, 0, specified, 0, 0, 1, 1 };
-                yield return new object[] { false, orientation, 0, 0, 1, 0, specified, 1, 0, 0, 1 };
-                yield return new object[] { false, orientation, 0, 0, 0, 2, specified, 0, 2, 0, 1 };
-                yield return new object[] { false, orientation, 0, 0, 1, 2, specified, 1, 2, 0, 1 };
-                yield return new object[] { false, orientation, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-            }
-        }
-
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            if ((specified & BoundsSpecified.Height) != 0)
-            {
-                continue;
-            }
-
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 104, s_dimension, specified, 104, s_dimension, 0, 0 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 0, 0, specified, 0, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, -1, -2, -3, -4, specified, -3, -4, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 0, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 1, 0, specified, 1, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 0, 2, specified, 0, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 1, 2, specified, 1, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-        }
-
-        foreach (BoundsSpecified specified in new BoundsSpecified[] { BoundsSpecified.Height, BoundsSpecified.Size, BoundsSpecified.All })
-        {
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 104, s_dimension, specified, 104, s_dimension, 0, 0 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 0, 0, specified, 0, s_dimension, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, -1, -2, -3, -4, specified, -3, s_dimension, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 0, 0, 0, specified, 0, s_dimension, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 2, 0, 0, specified, 0, s_dimension, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 2, 0, 0, specified, 0, s_dimension, 1, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 1, 0, specified, 1, s_dimension, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 0, 2, specified, 0, s_dimension, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 0, 0, 1, 2, specified, 1, s_dimension, 0, 1 };
-            yield return new object[] { true, Orientation.Horizontal, 1, 2, 30, 40, specified, 30, s_dimension, 1, 1 };
-        }
-
-        foreach (BoundsSpecified specified in Enum.GetValues(typeof(BoundsSpecified)))
-        {
-            if ((specified & BoundsSpecified.Width) != 0)
-            {
-                continue;
-            }
-
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 104, s_dimension, specified, 104, s_dimension, 0, 0 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 0, 0, specified, 0, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, -1, -2, -3, -4, specified, -3, -4, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 0, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 2, 0, 0, specified, 0, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 1, 0, specified, 1, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 0, 2, specified, 0, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 1, 2, specified, 1, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 2, 30, 40, specified, 30, 40, 1, 1 };
-        }
-
-        foreach (BoundsSpecified specified in new BoundsSpecified[] { BoundsSpecified.Width, BoundsSpecified.Size, BoundsSpecified.All })
-        {
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 104, s_dimension, specified, s_dimension, s_dimension, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 0, 0, specified, s_dimension, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, -1, -2, -3, -4, specified, s_dimension, -4, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 0, 0, 0, specified, s_dimension, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 2, 0, 0, specified, s_dimension, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 2, 0, 0, specified, s_dimension, 0, 1, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 1, 0, specified, s_dimension, 0, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 0, 2, specified, s_dimension, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 0, 0, 1, 2, specified, s_dimension, 2, 0, 1 };
-            yield return new object[] { true, Orientation.Vertical, 1, 2, 30, 40, specified, s_dimension, 40, 1, 1 };
-        }
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetBoundsCore_TestData))]
-    public void TrackBar_SetBoundsCore_Invoke_Success(bool autoSize, Orientation orientation, int x, int y, int width, int height, BoundsSpecified specified, int expectedWidth, int expectedHeight, int expectedLocationChangedCallCount, int expectedLayoutCallCount)
-    {
-        using var control = new SubTrackBar
-        {
-            AutoSize = autoSize,
-            Orientation = orientation
-        };
-        int moveCallCount = 0;
-        int locationChangedCallCount = 0;
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        control.Move += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(locationChangedCallCount, moveCallCount);
-            Assert.Equal(layoutCallCount, moveCallCount);
-            Assert.Equal(resizeCallCount, moveCallCount);
-            Assert.Equal(sizeChangedCallCount, moveCallCount);
-            Assert.Equal(clientSizeChangedCallCount, moveCallCount);
-            moveCallCount++;
-        };
-        control.LocationChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(moveCallCount - 1, locationChangedCallCount);
-            Assert.Equal(layoutCallCount, locationChangedCallCount);
-            Assert.Equal(resizeCallCount, locationChangedCallCount);
-            Assert.Equal(sizeChangedCallCount, locationChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, locationChangedCallCount);
-            locationChangedCallCount++;
-        };
-        control.Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.SetBoundsCore(x, y, width, height, specified);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(expectedLocationChangedCallCount, moveCallCount);
-        Assert.Equal(expectedLocationChangedCallCount, locationChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, layoutCallCount);
-        Assert.Equal(expectedLayoutCallCount, resizeCallCount);
-        Assert.Equal(expectedLayoutCallCount, sizeChangedCallCount);
-        Assert.Equal(expectedLayoutCallCount, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetRange_TestData()
-    {
-        yield return new object[] { 0, 10, 0, 10, 5 };
-        yield return new object[] { 0, 9, 0, 9, 5 };
-        yield return new object[] { 1, 10, 1, 10, 5 };
-        yield return new object[] { 10, 0, 10, 10, 10 };
-        yield return new object[] { 1, 9, 1, 9, 5 };
-        yield return new object[] { 5, 9, 5, 9, 5 };
-        yield return new object[] { 6, 9, 6, 9, 6 };
-        yield return new object[] { 1, 5, 1, 5, 5 };
-        yield return new object[] { 1, 4, 1, 4, 4 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetRange_TestData))]
-    public void TrackBar_SetRange_Invoke_Success(int minValue, int maxValue, int expectedMinimum, int expectedMaximum, int expectedValue)
-    {
-        using var control = new TrackBar
-        {
-            Value = 5
-        };
-
-        control.SetRange(minValue, maxValue);
-        Assert.Equal(expectedMinimum, control.Minimum);
-        Assert.Equal(expectedMaximum, control.Maximum);
-        Assert.Equal(expectedValue, control.Value);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> SetRange_WithRange_TestData()
-    {
-        yield return new object[] { 0, 10, 0, 10, 5, 0 };
-        yield return new object[] { 0, 9, 0, 9, 5, 1 };
-        yield return new object[] { 1, 10, 1, 10, 5, 1 };
-        yield return new object[] { 10, 0, 10, 10, 10, 1 };
-        yield return new object[] { 1, 9, 1, 9, 5, 1 };
-        yield return new object[] { 5, 9, 5, 9, 5, 1 };
-        yield return new object[] { 6, 9, 6, 9, 6, 1 };
-        yield return new object[] { 1, 5, 1, 5, 5, 1 };
-        yield return new object[] { 1, 4, 1, 4, 4, 1 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(SetRange_WithRange_TestData))]
-    public void TrackBar_SetRange_InvokeWithHandle_Success(int minValue, int maxValue, int expectedMinimum, int expectedMaximum, int expectedValue, int expectedInvalidatedCallCount)
-    {
-        using var control = new TrackBar
-        {
-            Value = 5
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.SetRange(minValue, maxValue);
-        Assert.Equal(expectedMinimum, control.Minimum);
-        Assert.Equal(expectedMaximum, control.Maximum);
-        Assert.Equal(expectedValue, control.Value);
-        Assert.Equal(expectedMinimum, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMIN));
-        Assert.Equal(expectedMaximum, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETRANGEMAX));
-        Assert.Equal(expectedValue, (int)PInvoke.SendMessage(control, PInvoke.TBM_GETPOS));
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void TrackBar_ToString_Invoke_ReturnsExpected()
-    {
-        using var control = new TrackBar();
-        Assert.Equal("System.Windows.Forms.TrackBar, Minimum: 0, Maximum: 10, Value: 0", control.ToString());
-    }
-
-    [WinFormsFact]
-    public void TrackBar_WndProc_InvokeMouseHoverWithHandle_Success()
-    {
-        using var control = new SubTrackBar();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int callCount = 0;
-        control.MouseHover += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            callCount++;
-        };
-        var m = new Message
-        {
-            Msg = (int)PInvoke.WM_MOUSEHOVER,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal(IntPtr.Zero, m.Result);
-        Assert.Equal(1, callCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public static IEnumerable<object[]> WndProc_Scroll_TestData()
-    {
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, IntPtr.Zero };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(-1, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(0, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(1, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(2, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(3, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(4, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(5, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(6, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(7, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(8, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_HSCROLL, PARAM.FromLowHigh(9, int.MaxValue) };
-
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, IntPtr.Zero };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(-1, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(0, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(1, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(2, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(3, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(4, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(5, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(6, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(7, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(8, int.MaxValue) };
-        yield return new object[] { MessageId.WM_REFLECT | PInvoke.WM_VSCROLL, PARAM.FromLowHigh(9, int.MaxValue) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(WndProc_Scroll_TestData))]
-    public void TrackBar_WndProc_InvokeScrollWithHandle_Success(int msg, IntPtr wParam)
-    {
-        using var control = new SubTrackBar
-        {
-            Value = 10
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        int scrollCallCount = 0;
-        control.Scroll += (sender, e) => scrollCallCount++;
-        int valueChangedCallCount = 0;
-        control.ValueChanged += (sender, e) => valueChangedCallCount++;
-        var m = new Message
-        {
-            Msg = msg,
-            WParam = wParam,
-            Result = (IntPtr)250
-        };
-        control.WndProc(ref m);
-        Assert.Equal((IntPtr)250, m.Result);
-        Assert.Equal(10, control.Value);
-        Assert.Equal(0, scrollCallCount);
-        Assert.Equal(0, valueChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    public class SubTrackBar : TrackBar
-    {
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new bool ShowFocusCues => base.ShowFocusCues;
-
-        public new bool ShowKeyboardCues => base.ShowKeyboardCues;
-
-        public new void CreateHandle() => base.CreateHandle();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool IsInputKey(Keys keyData) => base.IsInputKey(keyData);
-
-        public new void OnBackColorChanged(EventArgs e) => base.OnBackColorChanged(e);
-
-        public new void OnClick(EventArgs e) => base.OnClick(e);
-
-        public new void OnDoubleClick(EventArgs e) => base.OnDoubleClick(e);
-
-        public new void OnForeColorChanged(EventArgs e) => base.OnForeColorChanged(e);
-
-        public new void OnHandleCreated(EventArgs e) => base.OnHandleCreated(e);
-
-        public new void OnHandleDestroyed(EventArgs e) => base.OnHandleDestroyed(e);
-
-        public new void OnMouseClick(MouseEventArgs e) => base.OnMouseClick(e);
-
-        public new void OnMouseDoubleClick(MouseEventArgs e) => base.OnMouseDoubleClick(e);
-
-        public new void OnMouseWheel(MouseEventArgs e) => base.OnMouseWheel(e);
-
-        public new void OnPaint(PaintEventArgs e) => base.OnPaint(e);
-
-        public new void OnRightToLeftLayoutChanged(EventArgs e) => base.OnRightToLeftLayoutChanged(e);
-
-        public new void OnScroll(EventArgs e) => base.OnScroll(e);
-
-        public new void OnSystemColorsChanged(EventArgs e) => base.OnSystemColorsChanged(e);
-
-        public new void OnValueChanged(EventArgs e) => base.OnValueChanged(e);
-
-        public new void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) => base.SetBoundsCore(x, y, width, height, specified);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-
-        public new void WndProc(ref Message m) => base.WndProc(ref m);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/WebBrowserBaseTests.cs b/src/System.Windows.Forms/tests/UnitTests/WebBrowserBaseTests.cs
deleted file mode 100644
index 29bfdcc7ce0..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/WebBrowserBaseTests.cs
+++ /dev/null
@@ -1,944 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel;
-using System.Drawing;
-using Moq;
-using Size = System.Drawing.Size;
-
-namespace System.Windows.Forms.Tests;
-
-[Collection("Sequential")] // workaround for WebBrowser control corrupting memory when run on multiple UI threads (instantiated via GUID)
-public class WebBrowserBaseTests
-{
-    public static IEnumerable<object[]> Bounds_Set_TestData()
-    {
-        yield return new object[] { 0, 0, 0, 0 };
-        yield return new object[] { -1, -2, -3, -4 };
-        yield return new object[] { 1, 0, 0, 0 };
-        yield return new object[] { 0, 2, 0, 0 };
-        yield return new object[] { 1, 2, 0, 0 };
-        yield return new object[] { 0, 0, 1, 0 };
-        yield return new object[] { 0, 0, 0, 2 };
-        yield return new object[] { 0, 0, 1, 2 };
-        yield return new object[] { 1, 2, 30, 40 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Bounds_Set_TestData))]
-    public void WebBrowserBase_Bounds_Set_GetReturnsExpected(int x, int y, int width, int height)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        ((Control)control).Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(width, height), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, width, height), control.DisplayRectangle);
-        Assert.Equal(new Size(width, height), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + width, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + height, control.Bottom);
-        Assert.Equal(width, control.Width);
-        Assert.Equal(height, control.Height);
-        Assert.Equal(new Rectangle(x, y, width, height), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    public static IEnumerable<object[]> Bounds_SetWithHandle_TestData()
-    {
-        yield return new object[] { true, 0, 0, 0, 0, 0, 0, 1 };
-        yield return new object[] { true, -1, -2, -3, -4, 0, 0, 1 };
-        yield return new object[] { true, 1, 0, 0, 0, 0, 0, 1 };
-        yield return new object[] { true, 0, 2, 0, 0, 0, 0, 1 };
-        yield return new object[] { true, 1, 2, 0, 0, 0, 0, 1 };
-        yield return new object[] { true, 0, 0, 1, 0, 1, 0, 1 };
-        yield return new object[] { true, 0, 0, 0, 2, 0, 2, 1 };
-        yield return new object[] { true, 0, 0, 1, 2, 1, 2, 1 };
-        yield return new object[] { true, 1, 2, 30, 40, 30, 40, 1 };
-
-        yield return new object[] { false, 0, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, -1, -2, -3, -4, 0, 0, 0 };
-        yield return new object[] { false, 1, 0, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 2, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 1, 2, 0, 0, 0, 0, 0 };
-        yield return new object[] { false, 0, 0, 1, 0, 1, 0, 0 };
-        yield return new object[] { false, 0, 0, 0, 2, 0, 2, 0 };
-        yield return new object[] { false, 0, 0, 1, 2, 1, 2, 0 };
-        yield return new object[] { false, 1, 2, 30, 40, 30, 40, 0 };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(Bounds_SetWithHandle_TestData))]
-    public void WebBrowserBase_Bounds_SetWithHandle_GetReturnsExpected(bool resizeRedraw, int x, int y, int width, int height, int expectedWidth, int expectedHeight, int expectedInvalidatedCallCount)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        control.SetStyle(ControlStyles.ResizeRedraw, resizeRedraw);
-        int layoutCallCount = 0;
-        int resizeCallCount = 0;
-        int sizeChangedCallCount = 0;
-        int clientSizeChangedCallCount = 0;
-        ((Control)control).Layout += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(control, e.AffectedControl);
-            Assert.Equal("Bounds", e.AffectedProperty);
-            Assert.Equal(resizeCallCount, layoutCallCount);
-            Assert.Equal(sizeChangedCallCount, layoutCallCount);
-            Assert.Equal(clientSizeChangedCallCount, layoutCallCount);
-            layoutCallCount++;
-        };
-        control.Resize += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(layoutCallCount - 1, resizeCallCount);
-            Assert.Equal(sizeChangedCallCount, resizeCallCount);
-            Assert.Equal(clientSizeChangedCallCount, resizeCallCount);
-            resizeCallCount++;
-        };
-        control.SizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, sizeChangedCallCount);
-            Assert.Equal(clientSizeChangedCallCount, sizeChangedCallCount);
-            sizeChangedCallCount++;
-        };
-        control.ClientSizeChanged += (sender, e) =>
-        {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(resizeCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(layoutCallCount - 1, clientSizeChangedCallCount);
-            Assert.Equal(sizeChangedCallCount - 1, clientSizeChangedCallCount);
-            clientSizeChangedCallCount++;
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Call again.
-        control.Bounds = new Rectangle(x, y, width, height);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.ClientSize);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.ClientRectangle);
-        Assert.Equal(new Rectangle(0, 0, expectedWidth, expectedHeight), control.DisplayRectangle);
-        Assert.Equal(new Size(expectedWidth, expectedHeight), control.Size);
-        Assert.Equal(x, control.Left);
-        Assert.Equal(x + expectedWidth, control.Right);
-        Assert.Equal(y, control.Top);
-        Assert.Equal(y + expectedHeight, control.Bottom);
-        Assert.Equal(expectedWidth, control.Width);
-        Assert.Equal(expectedHeight, control.Height);
-        Assert.Equal(new Rectangle(x, y, expectedWidth, expectedHeight), control.Bounds);
-        Assert.Equal(1, layoutCallCount);
-        Assert.Equal(1, resizeCallCount);
-        Assert.Equal(1, sizeChangedCallCount);
-        Assert.Equal(1, clientSizeChangedCallCount);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(expectedInvalidatedCallCount, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_CanSelect_GetInPlaceActive_ReturnsExpected()
-    {
-        using var parent = new Control();
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Parent = parent
-        };
-        Assert.True(control.CanSelect);
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Site_Set_GetReturnsExpected()
-    {
-        var mockSite1 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite1
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite1
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Site = mockSite1.Object
-        };
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.Site = mockSite1.Object;
-        Assert.Same(mockSite1.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set another.
-        var mockSite2 = new Mock<ISite>(MockBehavior.Strict);
-        mockSite2
-            .Setup(s => s.Container)
-            .Returns((IContainer)null);
-        mockSite2
-            .Setup(s => s.GetService(typeof(AmbientProperties)))
-            .Returns(null);
-        control.Site = mockSite2.Object;
-        Assert.Same(mockSite2.Object, control.Site);
-        Assert.False(control.IsHandleCreated);
-
-        // Set null.
-        control.Site = null;
-        Assert.Null(control.Site);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_BackColorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackColorChanged += handler);
-        control.BackColorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_BackgroundImageChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackgroundImageChanged += handler);
-        control.BackgroundImageChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_BackgroundImageLayoutChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BackgroundImageLayoutChanged += handler);
-        control.BackgroundImageLayoutChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_BindingContextChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.BindingContextChanged += handler);
-        control.BindingContextChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_UICuesEventHandler_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        UICuesEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ChangeUICues += handler);
-        control.ChangeUICues -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Click_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Click += handler);
-        control.Click -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_CursorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.CursorChanged += handler);
-        control.CursorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DoubleClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DoubleClick += handler);
-        control.DoubleClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DragDrop_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragDrop += handler);
-        control.DragDrop -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DragEnter_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragEnter += handler);
-        control.DragEnter -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DragLeave_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragLeave += handler);
-        control.DragLeave -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DragOver_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        DragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.DragOver += handler);
-        control.DragOver -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_EnabledChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.EnabledChanged += handler);
-        control.EnabledChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Enter_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Enter += handler);
-        control.Enter -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_FontChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.FontChanged += handler);
-        control.FontChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_ForeColorChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ForeColorChanged += handler);
-        control.ForeColorChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_GiveFeedback_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        GiveFeedbackEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.GiveFeedback += handler);
-        control.GiveFeedback -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_HelpRequested_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        HelpEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.HelpRequested += handler);
-        control.HelpRequested -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_ImeModeChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.ImeModeChanged += handler);
-        control.ImeModeChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_KeyDown_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        KeyEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyDown += handler);
-        control.KeyDown -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_KeyPress_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        KeyPressEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyPress += handler);
-        control.KeyPress -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_KeyUp_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        KeyEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.KeyUp += handler);
-        control.KeyUp -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Layout_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        LayoutEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Layout += handler);
-        ((Control)control).Layout -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Leave_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Leave += handler);
-        control.Leave -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseCaptureChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseCaptureChanged += handler);
-        control.MouseCaptureChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseClick += handler);
-        control.MouseClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseDoubleClick_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseDoubleClick += handler);
-        control.MouseDoubleClick -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseDown_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseDown += handler);
-        control.MouseDown -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseEnter_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseEnter += handler);
-        control.MouseEnter -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseHover_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseHover += handler);
-        control.MouseHover -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseLeave_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseLeave += handler);
-        control.MouseLeave -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseMove_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseMove += handler);
-        control.MouseMove -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseUp_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseUp += handler);
-        control.MouseUp -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_MouseWheel_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        MouseEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.MouseWheel += handler);
-        control.MouseWheel -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_Paint_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        PaintEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.Paint += handler);
-        control.Paint -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_QueryAccessibilityHelp__AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        QueryAccessibilityHelpEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.QueryAccessibilityHelp += handler);
-        control.QueryAccessibilityHelp -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_QueryContinueDrag__AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        QueryContinueDragEventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.QueryContinueDrag += handler);
-        control.QueryContinueDrag -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_RightToLeftChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.RightToLeftChanged += handler);
-        control.RightToLeftChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_StyleChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.StyleChanged += handler);
-        control.StyleChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_TextChanged_AddRemove_ThrowsNotSupportedException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        EventHandler handler = (sender, e) => { };
-        Assert.Throws<NotSupportedException>(() => control.TextChanged += handler);
-        control.TextChanged -= handler;
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_CreateWebBrowserSiteBase_Invoke_ReturnsExpected()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        WebBrowserSiteBase siteBase = control.CreateWebBrowserSiteBase();
-        Assert.NotNull(siteBase);
-        Assert.NotSame(siteBase, control.CreateWebBrowserSiteBase());
-    }
-
-    public static IEnumerable<object[]> DrawToBitmap_TestData()
-    {
-        yield return new object[] { new Rectangle(0, 0, 1, 1) };
-        yield return new object[] { new Rectangle(0, 0, 10, 10) };
-        yield return new object[] { new Rectangle(2, 3, 10, 15) };
-        yield return new object[] { new Rectangle(2, 3, 15, 10) };
-        yield return new object[] { new Rectangle(0, 0, 100, 150) };
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawToBitmap_TestData))]
-    public void WebBrowserBase_DrawToBitmap_Invoke_Success(Rectangle targetBounds)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Width = 20,
-            Height = 20,
-        };
-        using var bitmap = new Bitmap(20, 20);
-        control.DrawToBitmap(bitmap, targetBounds);
-        Assert.True(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [MemberData(nameof(DrawToBitmap_TestData))]
-    public void WebBrowserBase_DrawToBitmap_InvokeWithHandle_Success(Rectangle rectangle)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Width = 20,
-            Height = 20,
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
-        int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
-        int styleChangedCallCount = 0;
-        ((Control)control).StyleChanged += (sender, e) => styleChangedCallCount++;
-        int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        using var bitmap = new Bitmap(20, 20);
-        control.DrawToBitmap(bitmap, rectangle);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_DrawToBitmap_NullBitmap_ThrowsArgumentNullException()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        Assert.Throws<ArgumentNullException>("bitmap", () => control.DrawToBitmap(null, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1, 0, 1, 2)]
-    [InlineData(0, -1, 1, 2)]
-    [InlineData(0, 0, -1, 2)]
-    [InlineData(0, 0, 0, 2)]
-    [InlineData(0, 0, 1, -1)]
-    [InlineData(0, 0, 1, 0)]
-    public void WebBrowserBase_DrawToBitmap_InvalidTargetBounds_ThrowsArgumentException(int x, int y, int width, int height)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Width = 20,
-            Height = 20
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(x, y, width, height)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void WebBrowserBase_DrawToBitmap_InvokeZeroWidth_ThrowsArgumentException(int width)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Width = width,
-            Height = 20
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsTheory]
-    [InlineData(-1)]
-    [InlineData(0)]
-    public void WebBrowserBase_DrawToBitmap_InvokeZeroHeight_ThrowsArgumentException(int height)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Width = 20,
-            Height = height
-        };
-        using var bitmap = new Bitmap(10, 10);
-        Assert.Throws<ArgumentException>(() => control.DrawToBitmap(bitmap, new Rectangle(1, 2, 3, 4)));
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_GetAutoSizeMode_Invoke_ReturnsExpected()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
-    }
-
-    [WinFormsTheory]
-    [InlineData(ControlStyles.ContainerControl, false)]
-    [InlineData(ControlStyles.UserPaint, false)]
-    [InlineData(ControlStyles.Opaque, false)]
-    [InlineData(ControlStyles.ResizeRedraw, false)]
-    [InlineData(ControlStyles.FixedWidth, false)]
-    [InlineData(ControlStyles.FixedHeight, false)]
-    [InlineData(ControlStyles.StandardClick, true)]
-    [InlineData(ControlStyles.Selectable, true)]
-    [InlineData(ControlStyles.UserMouse, false)]
-    [InlineData(ControlStyles.SupportsTransparentBackColor, false)]
-    [InlineData(ControlStyles.StandardDoubleClick, true)]
-    [InlineData(ControlStyles.AllPaintingInWmPaint, true)]
-    [InlineData(ControlStyles.CacheText, false)]
-    [InlineData(ControlStyles.EnableNotifyMessage, false)]
-    [InlineData(ControlStyles.DoubleBuffer, false)]
-    [InlineData(ControlStyles.OptimizedDoubleBuffer, false)]
-    [InlineData(ControlStyles.UseTextForAccessibility, true)]
-    [InlineData((ControlStyles)0, true)]
-    [InlineData((ControlStyles)int.MaxValue, false)]
-    [InlineData((ControlStyles)(-1), false)]
-    public void WebBrowserBase_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        Assert.Equal(expected, control.GetStyle(flag));
-
-        // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
-    }
-
-    [WinFormsFact]
-    public void WebBrowserBase_GetTopLevel_Invoke_ReturnsExpected()
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        Assert.False(control.GetTopLevel());
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void WebBrowserBase_ProcessDialogKey_InvokeWithoutParent_ReturnsFalse(Keys keyData)
-    {
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2");
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A)]
-    public void WebBrowserBase_ProcessDialogKey_InvokeWithParent_ReturnsFalse(Keys keyData)
-    {
-        using var parent = new Control
-        {
-            Visible = false
-        };
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Parent = parent
-        };
-        Assert.False(control.ProcessDialogKey(keyData));
-        Assert.False(control.IsHandleCreated);
-    }
-
-    [WinFormsTheory]
-    [InlineData(Keys.A, true)]
-    [InlineData(Keys.A, false)]
-    public void WebBrowserBase_ProcessDialogKey_InvokeWithCustomParent_ReturnsExpected(Keys keyData, bool result)
-    {
-        int callCount = 0;
-        bool action(Keys actualKeyData)
-        {
-            Assert.Equal(keyData, actualKeyData);
-            callCount++;
-            return result;
-        }
-
-        using var parent = new CustomProcessControl
-        {
-            ProcessDialogKeyAction = action,
-            Visible = false
-        };
-        using var control = new SubWebBrowserBase("8856f961-340a-11d0-a96b-00c04fd705a2")
-        {
-            Parent = parent
-        };
-        Assert.Equal(result, control.ProcessDialogKey(keyData));
-        Assert.Equal(1, callCount);
-        Assert.False(control.IsHandleCreated);
-    }
-
-    private class CustomProcessControl : Control
-    {
-        public Func<Message, Keys, bool> ProcessCmdKeyAction { get; set; }
-
-        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) => ProcessCmdKeyAction(msg, keyData);
-
-        public Func<char, bool> ProcessDialogCharAction { get; set; }
-
-        protected override bool ProcessDialogChar(char charCode) => ProcessDialogCharAction(charCode);
-
-        public Func<Keys, bool> ProcessDialogKeyAction { get; set; }
-
-        protected override bool ProcessDialogKey(Keys keyData) => ProcessDialogKeyAction(keyData);
-
-        public Func<Message, bool> ProcessKeyPreviewAction { get; set; }
-
-        protected override bool ProcessKeyPreview(ref Message m) => ProcessKeyPreviewAction(m);
-    }
-
-    private class SubWebBrowserBase : WebBrowserBase
-    {
-        public SubWebBrowserBase(string clsidString) : base(clsidString)
-        {
-        }
-
-        public new bool CanEnableIme => base.CanEnableIme;
-
-        public new bool CanRaiseEvents => base.CanRaiseEvents;
-
-        public new CreateParams CreateParams => base.CreateParams;
-
-        public new Cursor DefaultCursor => base.DefaultCursor;
-
-        public new ImeMode DefaultImeMode => base.DefaultImeMode;
-
-        public new Padding DefaultMargin => base.DefaultMargin;
-
-        public new Size DefaultMaximumSize => base.DefaultMaximumSize;
-
-        public new Size DefaultMinimumSize => base.DefaultMinimumSize;
-
-        public new Padding DefaultPadding => base.DefaultPadding;
-
-        public new Size DefaultSize => base.DefaultSize;
-
-        public new bool DesignMode => base.DesignMode;
-
-        public new bool DoubleBuffered
-        {
-            get => base.DoubleBuffered;
-            set => base.DoubleBuffered = value;
-        }
-
-        public new EventHandlerList Events => base.Events;
-
-        public new int FontHeight
-        {
-            get => base.FontHeight;
-            set => base.FontHeight = value;
-        }
-
-        public new ImeMode ImeModeBase
-        {
-            get => base.ImeModeBase;
-            set => base.ImeModeBase = value;
-        }
-
-        public new bool ResizeRedraw
-        {
-            get => base.ResizeRedraw;
-            set => base.ResizeRedraw = value;
-        }
-
-        public new void AttachInterfaces(object nativeActiveXObject) => base.AttachInterfaces(nativeActiveXObject);
-
-        public new void CreateSink() => base.CreateSink();
-
-        public new void DetachInterfaces() => base.DetachInterfaces();
-
-        public new void DetachSink() => base.DetachSink();
-
-        public new WebBrowserSiteBase CreateWebBrowserSiteBase() => base.CreateWebBrowserSiteBase();
-
-        public new AutoSizeMode GetAutoSizeMode() => base.GetAutoSizeMode();
-
-        public new bool GetStyle(ControlStyles flag) => base.GetStyle(flag);
-
-        public new bool GetTopLevel() => base.GetTopLevel();
-
-        public new bool ProcessDialogKey(Keys keyData) => base.ProcessDialogKey(keyData);
-
-        public new void SetStyle(ControlStyles flag, bool value) => base.SetStyle(flag, value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/10x16_one_entry_32bit.ico b/src/System.Windows.Forms/tests/UnitTests/bitmaps/10x16_one_entry_32bit.ico
deleted file mode 100644
index 07d51f406ca..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/10x16_one_entry_32bit.ico and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/1bit.png b/src/System.Windows.Forms/tests/UnitTests/bitmaps/1bit.png
deleted file mode 100644
index b87b1cd2350..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/1bit.png and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/256x256_one_entry_32bit.ico b/src/System.Windows.Forms/tests/UnitTests/bitmaps/256x256_one_entry_32bit.ico
deleted file mode 100644
index d6fdd64e1c8..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/256x256_one_entry_32bit.ico and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/EmptyFile b/src/System.Windows.Forms/tests/UnitTests/bitmaps/EmptyFile
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/almogaver24bits.bmp b/src/System.Windows.Forms/tests/UnitTests/bitmaps/almogaver24bits.bmp
deleted file mode 100644
index 5aaa8976e04..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/almogaver24bits.bmp and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/cursor.cur b/src/System.Windows.Forms/tests/UnitTests/bitmaps/cursor.cur
deleted file mode 100644
index f94e9f40328..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/cursor.cur and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/milkmateya01.emf b/src/System.Windows.Forms/tests/UnitTests/bitmaps/milkmateya01.emf
deleted file mode 100644
index acf9e84bf32..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/milkmateya01.emf and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.gif b/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.gif
deleted file mode 100644
index dfd1cd5c978..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.gif and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.jpg b/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.jpg
deleted file mode 100644
index dc21e0de7b3..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/nature24bits.jpg and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/bitmaps/telescope_01.wmf b/src/System.Windows.Forms/tests/UnitTests/bitmaps/telescope_01.wmf
deleted file mode 100644
index 453986c39c1..00000000000
Binary files a/src/System.Windows.Forms/tests/UnitTests/bitmaps/telescope_01.wmf and /dev/null differ
diff --git a/src/System.Windows.Forms/tests/UnitTests/misc/CollectionHelperTests.cs b/src/System.Windows.Forms/tests/UnitTests/misc/CollectionHelperTests.cs
deleted file mode 100644
index 6091dfd4605..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/misc/CollectionHelperTests.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections;
-
-namespace System.Windows.Forms.misc.Tests;
-
-public class CollectionHelperTests
-{
-    [Fact]
-    public void HashtableCopyTo_throws_when_target_is_null()
-    {
-        Dictionary<string, string> source = new();
-        Assert.Throws<ArgumentNullException>(() => source.HashtableCopyTo(target: null, index: 0));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_throws_when_target_rank_greather_than_one()
-    {
-        Dictionary<string, string> source = new();
-        var target = new object[3, 3];
-
-        Assert.Throws<ArgumentException>(() => source.HashtableCopyTo(target, index: 0));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_throws_when_index_less_than_zero()
-    {
-        Dictionary<string, string> source = new();
-        var target = new object[3];
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => source.HashtableCopyTo(target, index: -2));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_throws_when_index_greather_than_target_length()
-    {
-        Dictionary<string, string> source = new();
-        var target = new object[3];
-
-        Assert.Throws<ArgumentOutOfRangeException>(() => source.HashtableCopyTo(target, index: 5));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_throws_when_target_lowerbound_is_non_zero()
-    {
-        Dictionary<string, string> source = new();
-        var target = Array.CreateInstance(typeof(double), new int[] { 3 }, new int[] { 2 });
-
-        Assert.Throws<ArgumentException>(() => source.HashtableCopyTo(target, index: 0));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_throws_when_target_too_small()
-    {
-        Dictionary<string, string> source = new()
-        {
-            { "key-one", "value-one" },
-            { "key-two", "value-two" },
-        };
-        var target = new object[3];
-
-        Assert.Throws<ArgumentException>(() => source.HashtableCopyTo(target, index: 2));
-    }
-
-    [Fact]
-    public void HashtableCopyTo_successfully_copies_to_KeyValuePair_array()
-    {
-        Dictionary<string, string> source = new()
-        {
-            { "key-one", "value-one" },
-            { "key-two", "value-two" },
-        };
-        var target = new KeyValuePair<string, string>[2];
-
-        source.HashtableCopyTo(target, index: 0);
-
-        var firstTargetItem = target[0];
-        Assert.Equal(typeof(KeyValuePair<string, string>), firstTargetItem.GetType());
-        Assert.Equal("key-one", firstTargetItem.Key);
-        Assert.Equal("value-one", firstTargetItem.Value);
-
-        var secondTargetItem = target[1];
-        Assert.Equal(typeof(KeyValuePair<string, string>), secondTargetItem.GetType());
-        Assert.Equal("key-two", secondTargetItem.Key);
-        Assert.Equal("value-two", secondTargetItem.Value);
-    }
-
-    [Fact]
-    public void HashtableCopyTo_successfully_copies_to_DictionaryEntry_array()
-    {
-        Dictionary<string, string> source = new()
-        {
-            { "key-one", "value-one" },
-            { "key-two", "value-two" },
-        };
-        var target = new DictionaryEntry[2];
-
-        source.HashtableCopyTo(target, index: 0);
-
-        var firstTargetItem = target[0];
-        Assert.Equal(typeof(DictionaryEntry), firstTargetItem.GetType());
-        Assert.Equal("key-one", (string)firstTargetItem.Key);
-        Assert.Equal("value-one", (string)firstTargetItem.Value);
-
-        var secondTargetItem = target[1];
-        Assert.Equal(typeof(DictionaryEntry), secondTargetItem.GetType());
-        Assert.Equal("key-two", (string)secondTargetItem.Key);
-        Assert.Equal("value-two", (string)secondTargetItem.Value);
-    }
-
-    [Fact]
-    public void HashtableCopyTo_successfully_copies_to_Object_array()
-    {
-        Dictionary<string, string> source = new()
-        {
-            { "key-one", "value-one" },
-            { "key-two", "value-two" },
-        };
-        var target = new object[2];
-
-        source.HashtableCopyTo(target, index: 0);
-
-        var firstTargetItem = (DictionaryEntry)target[0];
-        Assert.Equal("key-one", (string)firstTargetItem.Key);
-        Assert.Equal("value-one", (string)firstTargetItem.Value);
-
-        var secondTargetItem = (DictionaryEntry)target[1];
-        Assert.Equal("key-two", (string)secondTargetItem.Key);
-        Assert.Equal("value-two", (string)secondTargetItem.Value);
-    }
-}
diff --git a/src/System.Windows.Forms/tests/UnitTests/runtimeconfig.template.json b/src/System.Windows.Forms/tests/UnitTests/runtimeconfig.template.json
deleted file mode 100644
index e460762026c..00000000000
--- a/src/System.Windows.Forms/tests/UnitTests/runtimeconfig.template.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "configProperties": {
-    "TestSwitch.LocalAppContext.DisableCaching": "true",
-    "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": "false"
-  }
-}
\ No newline at end of file